Update prebuilt Clang to r416183b from Android.

https://android.googlesource.com/platform/prebuilts/clang/host/
linux-x86/+/06a71ddac05c22edb2d10b590e1769b3f8619bef

clang 12.0.5 (based on r416183b) from build 7284624.

Change-Id: I277a316abcf47307562d8b748b84870f31a72866
Signed-off-by: Olivier Deprez <olivier.deprez@arm.com>
diff --git a/linux-x64/clang/include/llvm/ADT/APFixedPoint.h b/linux-x64/clang/include/llvm/ADT/APFixedPoint.h
new file mode 100644
index 0000000..d6349e6
--- /dev/null
+++ b/linux-x64/clang/include/llvm/ADT/APFixedPoint.h
@@ -0,0 +1,237 @@
+//===- APFixedPoint.h - Fixed point constant handling -----------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+/// \file
+/// Defines the fixed point number interface.
+/// This is a class for abstracting various operations performed on fixed point
+/// types.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_ADT_APFIXEDPOINT_H
+#define LLVM_ADT_APFIXEDPOINT_H
+
+#include "llvm/ADT/APSInt.h"
+#include "llvm/ADT/SmallString.h"
+#include "llvm/Support/raw_ostream.h"
+
+namespace llvm {
+
+class APFloat;
+struct fltSemantics;
+
+/// The fixed point semantics work similarly to fltSemantics. The width
+/// specifies the whole bit width of the underlying scaled integer (with padding
+/// if any). The scale represents the number of fractional bits in this type.
+/// When HasUnsignedPadding is true and this type is unsigned, the first bit
+/// in the value this represents is treated as padding.
+class FixedPointSemantics {
+public:
+  FixedPointSemantics(unsigned Width, unsigned Scale, bool IsSigned,
+                      bool IsSaturated, bool HasUnsignedPadding)
+      : Width(Width), Scale(Scale), IsSigned(IsSigned),
+        IsSaturated(IsSaturated), HasUnsignedPadding(HasUnsignedPadding) {
+    assert(Width >= Scale && "Not enough room for the scale");
+    assert(!(IsSigned && HasUnsignedPadding) &&
+           "Cannot have unsigned padding on a signed type.");
+  }
+
+  unsigned getWidth() const { return Width; }
+  unsigned getScale() const { return Scale; }
+  bool isSigned() const { return IsSigned; }
+  bool isSaturated() const { return IsSaturated; }
+  bool hasUnsignedPadding() const { return HasUnsignedPadding; }
+
+  void setSaturated(bool Saturated) { IsSaturated = Saturated; }
+
+  /// Return the number of integral bits represented by these semantics. These
+  /// are separate from the fractional bits and do not include the sign or
+  /// padding bit.
+  unsigned getIntegralBits() const {
+    if (IsSigned || (!IsSigned && HasUnsignedPadding))
+      return Width - Scale - 1;
+    else
+      return Width - Scale;
+  }
+
+  /// Return the FixedPointSemantics that allows for calculating the full
+  /// precision semantic that can precisely represent the precision and ranges
+  /// of both input values. This does not compute the resulting semantics for a
+  /// given binary operation.
+  FixedPointSemantics
+  getCommonSemantics(const FixedPointSemantics &Other) const;
+
+  /// Returns true if this fixed-point semantic with its value bits interpreted
+  /// as an integer can fit in the given floating point semantic without
+  /// overflowing to infinity.
+  /// For example, a signed 8-bit fixed-point semantic has a maximum and
+  /// minimum integer representation of 127 and -128, respectively. If both of
+  /// these values can be represented (possibly inexactly) in the floating
+  /// point semantic without overflowing, this returns true.
+  bool fitsInFloatSemantics(const fltSemantics &FloatSema) const;
+
+  /// Return the FixedPointSemantics for an integer type.
+  static FixedPointSemantics GetIntegerSemantics(unsigned Width,
+                                                 bool IsSigned) {
+    return FixedPointSemantics(Width, /*Scale=*/0, IsSigned,
+                               /*IsSaturated=*/false,
+                               /*HasUnsignedPadding=*/false);
+  }
+
+private:
+  unsigned Width          : 16;
+  unsigned Scale          : 13;
+  unsigned IsSigned       : 1;
+  unsigned IsSaturated    : 1;
+  unsigned HasUnsignedPadding : 1;
+};
+
+/// The APFixedPoint class works similarly to APInt/APSInt in that it is a
+/// functional replacement for a scaled integer. It is meant to replicate the
+/// fixed point types proposed in ISO/IEC JTC1 SC22 WG14 N1169. The class carries
+/// info about the fixed point type's width, sign, scale, and saturation, and
+/// provides different operations that would normally be performed on fixed point
+/// types.
+class APFixedPoint {
+public:
+  APFixedPoint(const APInt &Val, const FixedPointSemantics &Sema)
+      : Val(Val, !Sema.isSigned()), Sema(Sema) {
+    assert(Val.getBitWidth() == Sema.getWidth() &&
+           "The value should have a bit width that matches the Sema width");
+  }
+
+  APFixedPoint(uint64_t Val, const FixedPointSemantics &Sema)
+      : APFixedPoint(APInt(Sema.getWidth(), Val, Sema.isSigned()), Sema) {}
+
+  // Zero initialization.
+  APFixedPoint(const FixedPointSemantics &Sema) : APFixedPoint(0, Sema) {}
+
+  APSInt getValue() const { return APSInt(Val, !Sema.isSigned()); }
+  inline unsigned getWidth() const { return Sema.getWidth(); }
+  inline unsigned getScale() const { return Sema.getScale(); }
+  inline bool isSaturated() const { return Sema.isSaturated(); }
+  inline bool isSigned() const { return Sema.isSigned(); }
+  inline bool hasPadding() const { return Sema.hasUnsignedPadding(); }
+  FixedPointSemantics getSemantics() const { return Sema; }
+
+  bool getBoolValue() const { return Val.getBoolValue(); }
+
+  // Convert this number to match the semantics provided. If the overflow
+  // parameter is provided, set this value to true or false to indicate if this
+  // operation results in an overflow.
+  APFixedPoint convert(const FixedPointSemantics &DstSema,
+                       bool *Overflow = nullptr) const;
+
+  // Perform binary operations on a fixed point type. The resulting fixed point
+  // value will be in the common, full precision semantics that can represent
+  // the precision and ranges of both input values. See convert() for an
+  // explanation of the Overflow parameter.
+  APFixedPoint add(const APFixedPoint &Other, bool *Overflow = nullptr) const;
+  APFixedPoint sub(const APFixedPoint &Other, bool *Overflow = nullptr) const;
+  APFixedPoint mul(const APFixedPoint &Other, bool *Overflow = nullptr) const;
+  APFixedPoint div(const APFixedPoint &Other, bool *Overflow = nullptr) const;
+
+  // Perform shift operations on a fixed point type. Unlike the other binary
+  // operations, the resulting fixed point value will be in the original
+  // semantic.
+  APFixedPoint shl(unsigned Amt, bool *Overflow = nullptr) const;
+  APFixedPoint shr(unsigned Amt, bool *Overflow = nullptr) const {
+    // Right shift cannot overflow.
+    if (Overflow)
+      *Overflow = false;
+    return APFixedPoint(Val >> Amt, Sema);
+  }
+
+  /// Perform a unary negation (-X) on this fixed point type, taking into
+  /// account saturation if applicable.
+  APFixedPoint negate(bool *Overflow = nullptr) const;
+
+  /// Return the integral part of this fixed point number, rounded towards
+  /// zero. (-2.5k -> -2)
+  APSInt getIntPart() const {
+    if (Val < 0 && Val != -Val) // Cover the case when we have the min val
+      return -(-Val >> getScale());
+    else
+      return Val >> getScale();
+  }
+
+  /// Return the integral part of this fixed point number, rounded towards
+  /// zero. The value is stored into an APSInt with the provided width and sign.
+  /// If the overflow parameter is provided, and the integral value is not able
+  /// to be fully stored in the provided width and sign, the overflow parameter
+  /// is set to true.
+  APSInt convertToInt(unsigned DstWidth, bool DstSign,
+                      bool *Overflow = nullptr) const;
+
+  /// Convert this fixed point number to a floating point value with the
+  /// provided semantics.
+  APFloat convertToFloat(const fltSemantics &FloatSema) const;
+
+  void toString(SmallVectorImpl<char> &Str) const;
+  std::string toString() const {
+    SmallString<40> S;
+    toString(S);
+    return std::string(S.str());
+  }
+
+  // If LHS > RHS, return 1. If LHS == RHS, return 0. If LHS < RHS, return -1.
+  int compare(const APFixedPoint &Other) const;
+  bool operator==(const APFixedPoint &Other) const {
+    return compare(Other) == 0;
+  }
+  bool operator!=(const APFixedPoint &Other) const {
+    return compare(Other) != 0;
+  }
+  bool operator>(const APFixedPoint &Other) const { return compare(Other) > 0; }
+  bool operator<(const APFixedPoint &Other) const { return compare(Other) < 0; }
+  bool operator>=(const APFixedPoint &Other) const {
+    return compare(Other) >= 0;
+  }
+  bool operator<=(const APFixedPoint &Other) const {
+    return compare(Other) <= 0;
+  }
+
+  static APFixedPoint getMax(const FixedPointSemantics &Sema);
+  static APFixedPoint getMin(const FixedPointSemantics &Sema);
+
+  /// Given a floating point semantic, return the next floating point semantic
+  /// with a larger exponent and larger or equal mantissa.
+  static const fltSemantics *promoteFloatSemantics(const fltSemantics *S);
+
+  /// Create an APFixedPoint with a value equal to that of the provided integer,
+  /// and in the same semantics as the provided target semantics. If the value
+  /// is not able to fit in the specified fixed point semantics, and the
+  /// overflow parameter is provided, it is set to true.
+  static APFixedPoint getFromIntValue(const APSInt &Value,
+                                      const FixedPointSemantics &DstFXSema,
+                                      bool *Overflow = nullptr);
+
+  /// Create an APFixedPoint with a value equal to that of the provided
+  /// floating point value, in the provided target semantics. If the value is
+  /// not able to fit in the specified fixed point semantics and the overflow
+  /// parameter is specified, it is set to true.
+  /// For NaN, the Overflow flag is always set. For +inf and -inf, if the
+  /// semantic is saturating, the value saturates. Otherwise, the Overflow flag
+  /// is set.
+  static APFixedPoint getFromFloatValue(const APFloat &Value,
+                                        const FixedPointSemantics &DstFXSema,
+                                        bool *Overflow = nullptr);
+
+private:
+  APSInt Val;
+  FixedPointSemantics Sema;
+};
+
+inline raw_ostream &operator<<(raw_ostream &OS, const APFixedPoint &FX) {
+  OS << FX.toString();
+  return OS;
+}
+
+} // namespace llvm
+
+#endif
diff --git a/linux-x64/clang/include/llvm/ADT/APFloat.h b/linux-x64/clang/include/llvm/ADT/APFloat.h
index a9648d3..1f9ac22 100644
--- a/linux-x64/clang/include/llvm/ADT/APFloat.h
+++ b/linux-x64/clang/include/llvm/ADT/APFloat.h
@@ -18,6 +18,7 @@
 
 #include "llvm/ADT/APInt.h"
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/FloatingPointMode.h"
 #include "llvm/Support/ErrorHandling.h"
 #include <memory>
 
@@ -38,6 +39,7 @@
 class APFloat;
 class raw_ostream;
 
+template <typename T> class Expected;
 template <typename T> class SmallVectorImpl;
 
 /// Enum that represents what fraction of the LSB truncated bits of an fp number
@@ -140,15 +142,16 @@
 // members.
 struct APFloatBase {
   typedef APInt::WordType integerPart;
-  static const unsigned integerPartWidth = APInt::APINT_BITS_PER_WORD;
+  static constexpr unsigned integerPartWidth = APInt::APINT_BITS_PER_WORD;
 
   /// A signed type to represent a floating point numbers unbiased exponent.
-  typedef signed short ExponentType;
+  typedef int32_t ExponentType;
 
   /// \name Floating Point Semantics.
   /// @{
   enum Semantics {
     S_IEEEhalf,
+    S_BFloat,
     S_IEEEsingle,
     S_IEEEdouble,
     S_x87DoubleExtended,
@@ -160,6 +163,7 @@
   static Semantics SemanticsToEnum(const llvm::fltSemantics &Sem);
 
   static const fltSemantics &IEEEhalf() LLVM_READNONE;
+  static const fltSemantics &BFloat() LLVM_READNONE;
   static const fltSemantics &IEEEsingle() LLVM_READNONE;
   static const fltSemantics &IEEEdouble() LLVM_READNONE;
   static const fltSemantics &IEEEquad() LLVM_READNONE;
@@ -181,17 +185,24 @@
   };
 
   /// IEEE-754R 4.3: Rounding-direction attributes.
-  enum roundingMode {
-    rmNearestTiesToEven,
-    rmTowardPositive,
-    rmTowardNegative,
-    rmTowardZero,
-    rmNearestTiesToAway
-  };
+  using roundingMode = llvm::RoundingMode;
+
+  static constexpr roundingMode rmNearestTiesToEven =
+                                                RoundingMode::NearestTiesToEven;
+  static constexpr roundingMode rmTowardPositive = RoundingMode::TowardPositive;
+  static constexpr roundingMode rmTowardNegative = RoundingMode::TowardNegative;
+  static constexpr roundingMode rmTowardZero     = RoundingMode::TowardZero;
+  static constexpr roundingMode rmNearestTiesToAway =
+                                                RoundingMode::NearestTiesToAway;
 
   /// IEEE-754R 7: Default exception handling.
   ///
   /// opUnderflow or opOverflow are always returned or-ed with opInexact.
+  ///
+  /// APFloat models this behavior specified by IEEE-754:
+  ///   "For operations producing results in floating-point format, the default
+  ///    result of an operation that signals the invalid operation exception
+  ///    shall be a quiet NaN."
   enum opStatus {
     opOK = 0x00,
     opInvalidOp = 0x01,
@@ -238,7 +249,7 @@
   /// \name Constructors
   /// @{
 
-  IEEEFloat(const fltSemantics &); // Default construct to 0.0
+  IEEEFloat(const fltSemantics &); // Default construct to +0.0
   IEEEFloat(const fltSemantics &, integerPart);
   IEEEFloat(const fltSemantics &, uninitializedTag);
   IEEEFloat(const fltSemantics &, const APInt &);
@@ -294,7 +305,7 @@
                                           bool, roundingMode);
   opStatus convertFromZeroExtendedInteger(const integerPart *, unsigned int,
                                           bool, roundingMode);
-  opStatus convertFromString(StringRef, roundingMode);
+  Expected<opStatus> convertFromString(StringRef, roundingMode);
   APInt bitcastToAPInt() const;
   double convertToDouble() const;
   float convertToFloat() const;
@@ -481,7 +492,8 @@
   integerPart addSignificand(const IEEEFloat &);
   integerPart subtractSignificand(const IEEEFloat &, integerPart);
   lostFraction addOrSubtractSignificand(const IEEEFloat &, bool subtract);
-  lostFraction multiplySignificand(const IEEEFloat &, const IEEEFloat *);
+  lostFraction multiplySignificand(const IEEEFloat &, IEEEFloat);
+  lostFraction multiplySignificand(const IEEEFloat&);
   lostFraction divideSignificand(const IEEEFloat &);
   void incrementSignificand();
   void initialize(const fltSemantics *);
@@ -504,6 +516,7 @@
   opStatus divideSpecials(const IEEEFloat &);
   opStatus multiplySpecials(const IEEEFloat &);
   opStatus modSpecials(const IEEEFloat &);
+  opStatus remainderSpecials(const IEEEFloat&);
 
   /// @}
 
@@ -520,16 +533,20 @@
                                         bool *) const;
   opStatus convertFromUnsignedParts(const integerPart *, unsigned int,
                                     roundingMode);
-  opStatus convertFromHexadecimalString(StringRef, roundingMode);
-  opStatus convertFromDecimalString(StringRef, roundingMode);
+  Expected<opStatus> convertFromHexadecimalString(StringRef, roundingMode);
+  Expected<opStatus> convertFromDecimalString(StringRef, roundingMode);
   char *convertNormalToHexString(char *, unsigned int, bool,
                                  roundingMode) const;
   opStatus roundSignificandWithExponent(const integerPart *, unsigned int, int,
                                         roundingMode);
+  ExponentType exponentNaN() const;
+  ExponentType exponentInf() const;
+  ExponentType exponentZero() const;
 
   /// @}
 
   APInt convertHalfAPFloatToAPInt() const;
+  APInt convertBFloatAPFloatToAPInt() const;
   APInt convertFloatAPFloatToAPInt() const;
   APInt convertDoubleAPFloatToAPInt() const;
   APInt convertQuadrupleAPFloatToAPInt() const;
@@ -537,6 +554,7 @@
   APInt convertPPCDoubleDoubleAPFloatToAPInt() const;
   void initFromAPInt(const fltSemantics *Sem, const APInt &api);
   void initFromHalfAPInt(const APInt &api);
+  void initFromBFloatAPInt(const APInt &api);
   void initFromFloatAPInt(const APInt &api);
   void initFromDoubleAPInt(const APInt &api);
   void initFromQuadrupleAPInt(const APInt &api);
@@ -578,7 +596,7 @@
 IEEEFloat frexp(const IEEEFloat &Val, int &Exp, IEEEFloat::roundingMode RM);
 
 // This mode implements more precise float in terms of two APFloats.
-// The interface and layout is designed for arbitray underlying semantics,
+// The interface and layout is designed for arbitrary underlying semantics,
 // though currently only PPCDoubleDouble semantics are supported, whose
 // corresponding underlying semantics are IEEEdouble.
 class DoubleAPFloat final : public APFloatBase {
@@ -643,7 +661,7 @@
   cmpResult compare(const DoubleAPFloat &RHS) const;
   bool bitwiseIsEqual(const DoubleAPFloat &RHS) const;
   APInt bitcastToAPInt() const;
-  opStatus convertFromString(StringRef, roundingMode);
+  Expected<opStatus> convertFromString(StringRef, roundingMode);
   opStatus next(bool nextDown);
 
   opStatus convertToInteger(MutableArrayRef<integerPart> Input,
@@ -846,6 +864,9 @@
   APFloat(const fltSemantics &Semantics) : U(Semantics) {}
   APFloat(const fltSemantics &Semantics, StringRef S);
   APFloat(const fltSemantics &Semantics, integerPart I) : U(Semantics, I) {}
+  template <typename T,
+            typename = std::enable_if_t<std::is_floating_point<T>::value>>
+  APFloat(const fltSemantics &Semantics, T V) = delete;
   // TODO: Remove this constructor. This isn't faster than the first one.
   APFloat(const fltSemantics &Semantics, uninitializedTag)
       : U(Semantics, uninitialized) {}
@@ -940,9 +961,10 @@
 
   /// Returns a float which is bitcasted from an all one value int.
   ///
+  /// \param Semantics - type float semantics
   /// \param BitWidth - Select float type
-  /// \param isIEEE   - If 128 bit number, select between PPC and IEEE
-  static APFloat getAllOnesValue(unsigned BitWidth, bool isIEEE = false);
+  static APFloat getAllOnesValue(const fltSemantics &Semantics,
+                                 unsigned BitWidth);
 
   /// Used to insert APFloat objects, or objects that contain APFloat objects,
   /// into FoldingSets.
@@ -1025,6 +1047,13 @@
     APFLOAT_DISPATCH_ON_SEMANTICS(next(nextDown));
   }
 
+  /// Negate an APFloat.
+  APFloat operator-() const {
+    APFloat Result(*this);
+    Result.changeSign();
+    return Result;
+  }
+
   /// Add two APFloats, rounding ties to the nearest even.
   /// No error checking.
   APFloat operator+(const APFloat &RHS) const {
@@ -1100,14 +1129,34 @@
     APFLOAT_DISPATCH_ON_SEMANTICS(
         convertFromZeroExtendedInteger(Input, InputSize, IsSigned, RM));
   }
-  opStatus convertFromString(StringRef, roundingMode);
+  Expected<opStatus> convertFromString(StringRef, roundingMode);
   APInt bitcastToAPInt() const {
     APFLOAT_DISPATCH_ON_SEMANTICS(bitcastToAPInt());
   }
   double convertToDouble() const { return getIEEE().convertToDouble(); }
   float convertToFloat() const { return getIEEE().convertToFloat(); }
 
-  bool operator==(const APFloat &) const = delete;
+  bool operator==(const APFloat &RHS) const { return compare(RHS) == cmpEqual; }
+
+  bool operator!=(const APFloat &RHS) const { return compare(RHS) != cmpEqual; }
+
+  bool operator<(const APFloat &RHS) const {
+    return compare(RHS) == cmpLessThan;
+  }
+
+  bool operator>(const APFloat &RHS) const {
+    return compare(RHS) == cmpGreaterThan;
+  }
+
+  bool operator<=(const APFloat &RHS) const {
+    cmpResult Res = compare(RHS);
+    return Res == cmpLessThan || Res == cmpEqual;
+  }
+
+  bool operator>=(const APFloat &RHS) const {
+    cmpResult Res = compare(RHS);
+    return Res == cmpGreaterThan || Res == cmpEqual;
+  }
 
   cmpResult compare(const APFloat &RHS) const {
     assert(&getSemantics() == &RHS.getSemantics() &&
@@ -1239,7 +1288,7 @@
     return B;
   if (B.isNaN())
     return A;
-  return (B.compare(A) == APFloat::cmpLessThan) ? B : A;
+  return B < A ? B : A;
 }
 
 /// Implements IEEE maxNum semantics. Returns the larger of the 2 arguments if
@@ -1250,7 +1299,7 @@
     return B;
   if (B.isNaN())
     return A;
-  return (A.compare(B) == APFloat::cmpLessThan) ? B : A;
+  return A < B ? B : A;
 }
 
 /// Implements IEEE 754-2018 minimum semantics. Returns the smaller of 2
@@ -1263,7 +1312,7 @@
     return B;
   if (A.isZero() && B.isZero() && (A.isNegative() != B.isNegative()))
     return A.isNegative() ? A : B;
-  return (B.compare(A) == APFloat::cmpLessThan) ? B : A;
+  return B < A ? B : A;
 }
 
 /// Implements IEEE 754-2018 maximum semantics. Returns the larger of 2
@@ -1276,7 +1325,7 @@
     return B;
   if (A.isZero() && B.isZero() && (A.isNegative() != B.isNegative()))
     return A.isNegative() ? B : A;
-  return (A.compare(B) == APFloat::cmpLessThan) ? B : A;
+  return A < B ? B : A;
 }
 
 } // namespace llvm
diff --git a/linux-x64/clang/include/llvm/ADT/APInt.h b/linux-x64/clang/include/llvm/ADT/APInt.h
index 2381b75..b97ea2c 100644
--- a/linux-x64/clang/include/llvm/ADT/APInt.h
+++ b/linux-x64/clang/include/llvm/ADT/APInt.h
@@ -31,6 +31,7 @@
 template <typename T> class SmallVectorImpl;
 template <typename T> class ArrayRef;
 template <typename T> class Optional;
+template <typename T> struct DenseMapInfo;
 
 class APInt;
 
@@ -84,7 +85,7 @@
     UP,
   };
 
-  static const WordType WORDTYPE_MAX = ~WordType(0);
+  static constexpr WordType WORDTYPE_MAX = ~WordType(0);
 
 private:
   /// This union is used to store the integer value. When the
@@ -96,7 +97,7 @@
 
   unsigned BitWidth; ///< The number of bits in this APInt.
 
-  friend struct DenseMapAPIntKeyInfo;
+  friend struct DenseMapInfo<APInt>;
 
   friend class APSInt;
 
@@ -389,6 +390,11 @@
   /// \returns true if this APInt is positive.
   bool isStrictlyPositive() const { return isNonNegative() && !isNullValue(); }
 
+  /// Determine if this APInt Value is non-positive (<= 0).
+  ///
+  /// \returns true if this APInt is non-positive.
+  bool isNonPositive() const { return !isStrictlyPositive(); }
+
   /// Determine if all bits are set
   ///
   /// This checks to see if the value has all bits of the APInt are set or not.
@@ -595,8 +601,8 @@
   /// Constructs an APInt value that has a contiguous range of bits set. The
   /// bits from loBit (inclusive) to hiBit (exclusive) will be set. All other
   /// bits will be zero. For example, with parameters(32, 0, 16) you would get
-  /// 0x0000FFFF. If hiBit is less than loBit then the set bits "wrap". For
-  /// example, with parameters (32, 28, 4), you would get 0xF000000F.
+  /// 0x0000FFFF. Please call getBitsSetWithWrap if \p loBit may be greater than
+  /// \p hiBit.
   ///
   /// \param numBits the intended bit width of the result
   /// \param loBit the index of the lowest bit set.
@@ -604,11 +610,25 @@
   ///
   /// \returns An APInt value with the requested bits set.
   static APInt getBitsSet(unsigned numBits, unsigned loBit, unsigned hiBit) {
+    assert(loBit <= hiBit && "loBit greater than hiBit");
     APInt Res(numBits, 0);
     Res.setBits(loBit, hiBit);
     return Res;
   }
 
+  /// Wrap version of getBitsSet.
+  /// If \p hiBit is bigger than \p loBit, this is same with getBitsSet.
+  /// If \p hiBit is not bigger than \p loBit, the set bits "wrap". For example,
+  /// with parameters (32, 28, 4), you would get 0xF000000F.
+  /// If \p hiBit is equal to \p loBit, you would get a result with all bits
+  /// set.
+  static APInt getBitsSetWithWrap(unsigned numBits, unsigned loBit,
+                                  unsigned hiBit) {
+    APInt Res(numBits, 0);
+    Res.setBitsWithWrap(loBit, hiBit);
+    return Res;
+  }
+
   /// Get a value with upper bits starting at loBit set.
   ///
   /// Constructs an APInt value that has a contiguous range of bits set. The
@@ -745,8 +765,8 @@
 
   /// Move assignment operator.
   APInt &operator=(APInt &&that) {
-#ifdef _MSC_VER
-    // The MSVC std::shuffle implementation still does self-assignment.
+#ifdef EXPENSIVE_CHECKS
+    // Some std::shuffle implementations still do self-assignment.
     if (this == &that)
       return *this;
 #endif
@@ -774,11 +794,10 @@
   APInt &operator=(uint64_t RHS) {
     if (isSingleWord()) {
       U.VAL = RHS;
-      clearUnusedBits();
-    } else {
-      U.pVal[0] = RHS;
-      memset(U.pVal+1, 0, (getNumWords() - 1) * APINT_WORD_SIZE);
+      return clearUnusedBits();
     }
+    U.pVal[0] = RHS;
+    memset(U.pVal + 1, 0, (getNumWords() - 1) * APINT_WORD_SIZE);
     return *this;
   }
 
@@ -835,10 +854,9 @@
   APInt &operator|=(uint64_t RHS) {
     if (isSingleWord()) {
       U.VAL |= RHS;
-      clearUnusedBits();
-    } else {
-      U.pVal[0] |= RHS;
+      return clearUnusedBits();
     }
+    U.pVal[0] |= RHS;
     return *this;
   }
 
@@ -865,10 +883,9 @@
   APInt &operator^=(uint64_t RHS) {
     if (isSingleWord()) {
       U.VAL ^= RHS;
-      clearUnusedBits();
-    } else {
-      U.pVal[0] ^= RHS;
+      return clearUnusedBits();
     }
+    U.pVal[0] ^= RHS;
     return *this;
   }
 
@@ -1109,6 +1126,10 @@
   APInt uadd_sat(const APInt &RHS) const;
   APInt ssub_sat(const APInt &RHS) const;
   APInt usub_sat(const APInt &RHS) const;
+  APInt smul_sat(const APInt &RHS) const;
+  APInt umul_sat(const APInt &RHS) const;
+  APInt sshl_sat(const APInt &RHS) const;
+  APInt ushl_sat(const APInt &RHS) const;
 
   /// Array-indexing support.
   ///
@@ -1245,7 +1266,7 @@
   /// \returns true if *this <= RHS when considered signed.
   bool sle(uint64_t RHS) const { return !sgt(RHS); }
 
-  /// Unsigned greather than comparison
+  /// Unsigned greater than comparison
   ///
   /// Regards both *this and RHS as unsigned quantities and compares them for
   /// the validity of the greater-than relationship.
@@ -1264,7 +1285,7 @@
     return (!isSingleWord() && getActiveBits() > 64) || getZExtValue() > RHS;
   }
 
-  /// Signed greather than comparison
+  /// Signed greater than comparison
   ///
   /// Regards both *this and RHS as signed quantities and compares them for the
   /// validity of the greater-than relationship.
@@ -1342,6 +1363,19 @@
   /// that is greater than or equal to the current width.
   APInt trunc(unsigned width) const;
 
+  /// Truncate to new width with unsigned saturation.
+  ///
+  /// If the APInt, treated as unsigned integer, can be losslessly truncated to
+  /// the new bitwidth, then return truncated APInt. Else, return max value.
+  APInt truncUSat(unsigned width) const;
+
+  /// Truncate to new width with signed saturation.
+  ///
+  /// If this APInt, treated as signed integer, can be losslessly truncated to
+  /// the new bitwidth, then return truncated APInt. Else, return either
+  /// signed min value if the APInt was negative, or signed max value.
+  APInt truncSSat(unsigned width) const;
+
   /// Sign extend to a new width.
   ///
   /// This operation sign extends the APInt to a new width. If the high order
@@ -1369,6 +1403,12 @@
   /// extended, truncated, or left alone to make it that width.
   APInt zextOrTrunc(unsigned width) const;
 
+  /// Truncate to width
+  ///
+  /// Make this APInt have the bit width given by \p width. The value is
+  /// truncated or left alone to make it that width.
+  APInt truncOrSelf(unsigned width) const;
+
   /// Sign extend or truncate to width
   ///
   /// Make this APInt have the bit width given by \p width. The value is sign
@@ -1413,7 +1453,31 @@
     setBit(BitWidth - 1);
   }
 
+  /// Set a given bit to a given value.
+  void setBitVal(unsigned BitPosition, bool BitValue) {
+    if (BitValue)
+      setBit(BitPosition);
+    else
+      clearBit(BitPosition);
+  }
+
   /// Set the bits from loBit (inclusive) to hiBit (exclusive) to 1.
+  /// This function handles "wrap" case when \p loBit >= \p hiBit, and calls
+  /// setBits when \p loBit < \p hiBit.
+  /// For \p loBit == \p hiBit wrap case, set every bit to 1.
+  void setBitsWithWrap(unsigned loBit, unsigned hiBit) {
+    assert(hiBit <= BitWidth && "hiBit out of range");
+    assert(loBit <= BitWidth && "loBit out of range");
+    if (loBit < hiBit) {
+      setBits(loBit, hiBit);
+      return;
+    }
+    setLowBits(hiBit);
+    setHighBits(BitWidth - loBit);
+  }
+
+  /// Set the bits from loBit (inclusive) to hiBit (exclusive) to 1.
+  /// This function handles case when \p loBit <= \p hiBit.
   void setBits(unsigned loBit, unsigned hiBit) {
     assert(hiBit <= BitWidth && "hiBit out of range");
     assert(loBit <= BitWidth && "loBit out of range");
@@ -1467,6 +1531,13 @@
       U.pVal[whichWord(BitPosition)] &= Mask;
   }
 
+  /// Set bottom loBits bits to 0.
+  void clearLowBits(unsigned loBits) {
+    assert(loBits <= BitWidth && "More bits than bitwidth");
+    APInt Keep = getHighBitsSet(BitWidth, BitWidth - loBits);
+    *this &= Keep;
+  }
+
   /// Set the sign bit to 0.
   void clearSignBit() {
     clearBit(BitWidth - 1);
@@ -1496,9 +1567,11 @@
 
   /// Insert the bits from a smaller APInt starting at bitPosition.
   void insertBits(const APInt &SubBits, unsigned bitPosition);
+  void insertBits(uint64_t SubBits, unsigned bitPosition, unsigned numBits);
 
   /// Return an APInt with the extracted bits [bitPosition,bitPosition+numBits).
   APInt extractBits(unsigned numBits, unsigned bitPosition) const;
+  uint64_t extractBitsAsZExtValue(unsigned numBits, unsigned bitPosition) const;
 
   /// @}
   /// \name Value Characterization Functions
@@ -1548,11 +1621,7 @@
   /// returns the smallest bit width that will retain the negative value. For
   /// example, -1 can be written as 0b1 or 0xFFFFFFFFFF. 0b1 is shorter and so
   /// for -1, this function will always return 1.
-  unsigned getMinSignedBits() const {
-    if (isNegative())
-      return BitWidth - countLeadingOnes() + 1;
-    return getActiveBits() + 1;
-  }
+  unsigned getMinSignedBits() const { return BitWidth - getNumSignBits() + 1; }
 
   /// Get zero extended value
   ///
@@ -1714,13 +1783,13 @@
     return BitsToDouble(getWord(0));
   }
 
-  /// Converts APInt bits to a double
+  /// Converts APInt bits to a float
   ///
   /// The conversion does not do a translation from integer to float, it just
   /// re-interprets the bits as a float. Note that it is valid to do this on
   /// any bit width. Exactly 32 bits will be translated.
   float bitsToFloat() const {
-    return BitsToFloat(getWord(0));
+    return BitsToFloat(static_cast<uint32_t>(getWord(0)));
   }
 
   /// Converts a double to APInt bits.
@@ -2149,7 +2218,7 @@
 
 /// Converts the given APInt to a float value.
 ///
-/// Treast the APInt as a signed value for conversion purposes.
+/// Treats the APInt as a signed value for conversion purposes.
 inline float RoundSignedAPIntToFloat(const APInt &APIVal) {
   return float(APIVal.signedRoundToDouble());
 }
@@ -2185,7 +2254,7 @@
 /// count as an overflow, but here we want to allow values to decrease
 /// and increase as long as they are within the same interval.
 /// Specifically, adding of two negative numbers should not cause an
-/// overflow (as long as the magnitude does not exceed the bith width).
+/// overflow (as long as the magnitude does not exceed the bit width).
 /// On the other hand, given a positive number, adding a negative
 /// number to it can give a negative result, which would cause the
 /// value to go from [-2^BW, 0) to [0, 2^BW). In that sense, zero is
@@ -2207,6 +2276,12 @@
 /// coefficients.
 Optional<APInt> SolveQuadraticEquationWrap(APInt A, APInt B, APInt C,
                                            unsigned RangeWidth);
+
+/// Compare two values, and if they are different, return the position of the
+/// most significant bit that is different in the values.
+Optional<unsigned> GetMostSignificantDifferentBit(const APInt &A,
+                                                  const APInt &B);
+
 } // End of APIntOps namespace
 
 // See friend declaration above. This additional declaration is required in
@@ -2219,7 +2294,7 @@
 
 /// LoadIntFromMemory - Loads the integer stored in the LoadBytes bytes starting
 /// from Src into IntVal, which is assumed to be wide enough and to hold zero.
-void LoadIntFromMemory(APInt &IntVal, uint8_t *Src, unsigned LoadBytes);
+void LoadIntFromMemory(APInt &IntVal, const uint8_t *Src, unsigned LoadBytes);
 
 } // namespace llvm
 
diff --git a/linux-x64/clang/include/llvm/ADT/AllocatorList.h b/linux-x64/clang/include/llvm/ADT/AllocatorList.h
index 405a2e4..404a657 100644
--- a/linux-x64/clang/include/llvm/ADT/AllocatorList.h
+++ b/linux-x64/clang/include/llvm/ADT/AllocatorList.h
@@ -110,21 +110,14 @@
 
     template <class OtherValueT, class OtherIteratorBase>
     IteratorImpl(const IteratorImpl<OtherValueT, OtherIteratorBase> &X,
-                 typename std::enable_if<std::is_convertible<
-                     OtherIteratorBase, IteratorBase>::value>::type * = nullptr)
+                 std::enable_if_t<std::is_convertible<
+                     OtherIteratorBase, IteratorBase>::value> * = nullptr)
         : base_type(X.wrapped()) {}
 
     ~IteratorImpl() = default;
 
     reference operator*() const { return base_type::wrapped()->V; }
     pointer operator->() const { return &operator*(); }
-
-    friend bool operator==(const IteratorImpl &L, const IteratorImpl &R) {
-      return L.wrapped() == R.wrapped();
-    }
-    friend bool operator!=(const IteratorImpl &L, const IteratorImpl &R) {
-      return !(L == R);
-    }
   };
 
 public:
diff --git a/linux-x64/clang/include/llvm/ADT/Any.h b/linux-x64/clang/include/llvm/ADT/Any.h
index 5dcd6e7..0aded62 100644
--- a/linux-x64/clang/include/llvm/ADT/Any.h
+++ b/linux-x64/clang/include/llvm/ADT/Any.h
@@ -38,7 +38,7 @@
     explicit StorageImpl(T &&Value) : Value(std::move(Value)) {}
 
     std::unique_ptr<StorageBase> clone() const override {
-      return llvm::make_unique<StorageImpl<T>>(Value);
+      return std::make_unique<StorageImpl<T>>(Value);
     }
 
     const void *id() const override { return &TypeId<T>::Id; }
@@ -59,26 +59,26 @@
   // When T is Any or T is not copy-constructible we need to explicitly disable
   // the forwarding constructor so that the copy constructor gets selected
   // instead.
-  template <
-      typename T,
-      typename std::enable_if<
-          llvm::conjunction<
-              llvm::negation<std::is_same<typename std::decay<T>::type, Any>>,
-              // We also disable this overload when an `Any` object can be
-              // converted to the parameter type because in that case, this
-              // constructor may combine with that conversion during overload
-              // resolution for determining copy constructibility, and then
-              // when we try to determine copy constructibility below we may
-              // infinitely recurse. This is being evaluated by the standards
-              // committee as a potential DR in `std::any` as well, but we're
-              // going ahead and adopting it to work-around usage of `Any` with
-              // types that need to be implicitly convertible from an `Any`.
-              llvm::negation<std::is_convertible<Any, typename std::decay<T>::type>>,
-              std::is_copy_constructible<typename std::decay<T>::type>>::value,
-          int>::type = 0>
+  template <typename T,
+            std::enable_if_t<
+                llvm::conjunction<
+                    llvm::negation<std::is_same<std::decay_t<T>, Any>>,
+                    // We also disable this overload when an `Any` object can be
+                    // converted to the parameter type because in that case,
+                    // this constructor may combine with that conversion during
+                    // overload resolution for determining copy
+                    // constructibility, and then when we try to determine copy
+                    // constructibility below we may infinitely recurse. This is
+                    // being evaluated by the standards committee as a potential
+                    // DR in `std::any` as well, but we're going ahead and
+                    // adopting it to work-around usage of `Any` with types that
+                    // need to be implicitly convertible from an `Any`.
+                    llvm::negation<std::is_convertible<Any, std::decay_t<T>>>,
+                    std::is_copy_constructible<std::decay_t<T>>>::value,
+                int> = 0>
   Any(T &&Value) {
-    using U = typename std::decay<T>::type;
-    Storage = llvm::make_unique<StorageImpl<U>>(std::forward<T>(Value));
+    Storage =
+        std::make_unique<StorageImpl<std::decay_t<T>>>(std::forward<T>(Value));
   }
 
   Any(Any &&Other) : Storage(std::move(Other.Storage)) {}
@@ -114,32 +114,27 @@
 template <typename T> bool any_isa(const Any &Value) {
   if (!Value.Storage)
     return false;
-  using U =
-      typename std::remove_cv<typename std::remove_reference<T>::type>::type;
-  return Value.Storage->id() == &Any::TypeId<U>::Id;
+  return Value.Storage->id() ==
+         &Any::TypeId<std::remove_cv_t<std::remove_reference_t<T>>>::Id;
 }
 
 template <class T> T any_cast(const Any &Value) {
-  using U =
-      typename std::remove_cv<typename std::remove_reference<T>::type>::type;
-  return static_cast<T>(*any_cast<U>(&Value));
+  return static_cast<T>(
+      *any_cast<std::remove_cv_t<std::remove_reference_t<T>>>(&Value));
 }
 
 template <class T> T any_cast(Any &Value) {
-  using U =
-      typename std::remove_cv<typename std::remove_reference<T>::type>::type;
-  return static_cast<T>(*any_cast<U>(&Value));
+  return static_cast<T>(
+      *any_cast<std::remove_cv_t<std::remove_reference_t<T>>>(&Value));
 }
 
 template <class T> T any_cast(Any &&Value) {
-  using U =
-      typename std::remove_cv<typename std::remove_reference<T>::type>::type;
-  return static_cast<T>(std::move(*any_cast<U>(&Value)));
+  return static_cast<T>(std::move(
+      *any_cast<std::remove_cv_t<std::remove_reference_t<T>>>(&Value)));
 }
 
 template <class T> const T *any_cast(const Any *Value) {
-  using U =
-      typename std::remove_cv<typename std::remove_reference<T>::type>::type;
+  using U = std::remove_cv_t<std::remove_reference_t<T>>;
   assert(Value && any_isa<T>(*Value) && "Bad any cast!");
   if (!Value || !any_isa<U>(*Value))
     return nullptr;
@@ -147,7 +142,7 @@
 }
 
 template <class T> T *any_cast(Any *Value) {
-  using U = typename std::decay<T>::type;
+  using U = std::decay_t<T>;
   assert(Value && any_isa<U>(*Value) && "Bad any cast!");
   if (!Value || !any_isa<U>(*Value))
     return nullptr;
diff --git a/linux-x64/clang/include/llvm/ADT/ArrayRef.h b/linux-x64/clang/include/llvm/ADT/ArrayRef.h
index 773c88f..5ed4d07 100644
--- a/linux-x64/clang/include/llvm/ADT/ArrayRef.h
+++ b/linux-x64/clang/include/llvm/ADT/ArrayRef.h
@@ -38,7 +38,7 @@
   /// This is intended to be trivially copyable, so it should be passed by
   /// value.
   template<typename T>
-  class LLVM_NODISCARD ArrayRef {
+  class LLVM_GSL_POINTER LLVM_NODISCARD ArrayRef {
   public:
     using iterator = const T *;
     using const_iterator = const T *;
@@ -97,37 +97,45 @@
     /*implicit*/ constexpr ArrayRef(const T (&Arr)[N]) : Data(Arr), Length(N) {}
 
     /// Construct an ArrayRef from a std::initializer_list.
+#if LLVM_GNUC_PREREQ(9, 0, 0)
+// Disable gcc's warning in this constructor as it generates an enormous amount
+// of messages. Anyone using ArrayRef should already be aware of the fact that
+// it does not do lifetime extension.
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Winit-list-lifetime"
+#endif
     /*implicit*/ ArrayRef(const std::initializer_list<T> &Vec)
     : Data(Vec.begin() == Vec.end() ? (T*)nullptr : Vec.begin()),
       Length(Vec.size()) {}
+#if LLVM_GNUC_PREREQ(9, 0, 0)
+#pragma GCC diagnostic pop
+#endif
 
     /// Construct an ArrayRef<const T*> from ArrayRef<T*>. This uses SFINAE to
     /// ensure that only ArrayRefs of pointers can be converted.
     template <typename U>
-    ArrayRef(
-        const ArrayRef<U *> &A,
-        typename std::enable_if<
-           std::is_convertible<U *const *, T const *>::value>::type * = nullptr)
-      : Data(A.data()), Length(A.size()) {}
+    ArrayRef(const ArrayRef<U *> &A,
+             std::enable_if_t<std::is_convertible<U *const *, T const *>::value>
+                 * = nullptr)
+        : Data(A.data()), Length(A.size()) {}
 
     /// Construct an ArrayRef<const T*> from a SmallVector<T*>. This is
     /// templated in order to avoid instantiating SmallVectorTemplateCommon<T>
     /// whenever we copy-construct an ArrayRef.
-    template<typename U, typename DummyT>
+    template <typename U, typename DummyT>
     /*implicit*/ ArrayRef(
-      const SmallVectorTemplateCommon<U *, DummyT> &Vec,
-      typename std::enable_if<
-          std::is_convertible<U *const *, T const *>::value>::type * = nullptr)
-      : Data(Vec.data()), Length(Vec.size()) {
-    }
+        const SmallVectorTemplateCommon<U *, DummyT> &Vec,
+        std::enable_if_t<std::is_convertible<U *const *, T const *>::value> * =
+            nullptr)
+        : Data(Vec.data()), Length(Vec.size()) {}
 
     /// Construct an ArrayRef<const T*> from std::vector<T*>. This uses SFINAE
     /// to ensure that only vectors of pointers can be converted.
-    template<typename U, typename A>
+    template <typename U, typename A>
     ArrayRef(const std::vector<U *, A> &Vec,
-             typename std::enable_if<
-                 std::is_convertible<U *const *, T const *>::value>::type* = 0)
-      : Data(Vec.data()), Length(Vec.size()) {}
+             std::enable_if_t<std::is_convertible<U *const *, T const *>::value>
+                 * = 0)
+        : Data(Vec.data()), Length(Vec.size()) {}
 
     /// @}
     /// @name Simple Operations
@@ -246,7 +254,7 @@
     /// The declaration here is extra complicated so that "arrayRef = {}"
     /// continues to select the move assignment operator.
     template <typename U>
-    typename std::enable_if<std::is_same<U, T>::value, ArrayRef<T>>::type &
+    std::enable_if_t<std::is_same<U, T>::value, ArrayRef<T>> &
     operator=(U &&Temporary) = delete;
 
     /// Disallow accidental assignment from a temporary.
@@ -254,7 +262,7 @@
     /// The declaration here is extra complicated so that "arrayRef = {}"
     /// continues to select the move assignment operator.
     template <typename U>
-    typename std::enable_if<std::is_same<U, T>::value, ArrayRef<T>>::type &
+    std::enable_if_t<std::is_same<U, T>::value, ArrayRef<T>> &
     operator=(std::initializer_list<U>) = delete;
 
     /// @}
@@ -298,17 +306,17 @@
     /// Construct an empty MutableArrayRef from None.
     /*implicit*/ MutableArrayRef(NoneType) : ArrayRef<T>() {}
 
-    /// Construct an MutableArrayRef from a single element.
+    /// Construct a MutableArrayRef from a single element.
     /*implicit*/ MutableArrayRef(T &OneElt) : ArrayRef<T>(OneElt) {}
 
-    /// Construct an MutableArrayRef from a pointer and length.
+    /// Construct a MutableArrayRef from a pointer and length.
     /*implicit*/ MutableArrayRef(T *data, size_t length)
       : ArrayRef<T>(data, length) {}
 
-    /// Construct an MutableArrayRef from a range.
+    /// Construct a MutableArrayRef from a range.
     MutableArrayRef(T *begin, T *end) : ArrayRef<T>(begin, end) {}
 
-    /// Construct an MutableArrayRef from a SmallVector.
+    /// Construct a MutableArrayRef from a SmallVector.
     /*implicit*/ MutableArrayRef(SmallVectorImpl<T> &Vec)
     : ArrayRef<T>(Vec) {}
 
@@ -316,12 +324,12 @@
     /*implicit*/ MutableArrayRef(std::vector<T> &Vec)
     : ArrayRef<T>(Vec) {}
 
-    /// Construct an ArrayRef from a std::array
+    /// Construct a MutableArrayRef from a std::array
     template <size_t N>
     /*implicit*/ constexpr MutableArrayRef(std::array<T, N> &Arr)
         : ArrayRef<T>(Arr) {}
 
-    /// Construct an MutableArrayRef from a C array.
+    /// Construct a MutableArrayRef from a C array.
     template <size_t N>
     /*implicit*/ constexpr MutableArrayRef(T (&Arr)[N]) : ArrayRef<T>(Arr) {}
 
@@ -481,6 +489,12 @@
     return Vec;
   }
 
+  /// Construct an ArrayRef from a std::array.
+  template <typename T, std::size_t N>
+  ArrayRef<T> makeArrayRef(const std::array<T, N> &Arr) {
+    return Arr;
+  }
+
   /// Construct an ArrayRef from an ArrayRef (no-op) (const)
   template <typename T> ArrayRef<T> makeArrayRef(const ArrayRef<T> &Vec) {
     return Vec;
@@ -518,11 +532,21 @@
     return LHS.equals(RHS);
   }
 
-  template<typename T>
+  template <typename T>
+  inline bool operator==(SmallVectorImpl<T> &LHS, ArrayRef<T> RHS) {
+    return ArrayRef<T>(LHS).equals(RHS);
+  }
+
+  template <typename T>
   inline bool operator!=(ArrayRef<T> LHS, ArrayRef<T> RHS) {
     return !(LHS == RHS);
   }
 
+  template <typename T>
+  inline bool operator!=(SmallVectorImpl<T> &LHS, ArrayRef<T> RHS) {
+    return !(LHS == RHS);
+  }
+
   /// @}
 
   template <typename T> hash_code hash_value(ArrayRef<T> S) {
diff --git a/linux-x64/clang/include/llvm/ADT/BitVector.h b/linux-x64/clang/include/llvm/ADT/BitVector.h
index fabf5d9..2a85778 100644
--- a/linux-x64/clang/include/llvm/ADT/BitVector.h
+++ b/linux-x64/clang/include/llvm/ADT/BitVector.h
@@ -14,6 +14,7 @@
 #define LLVM_ADT_BITVECTOR_H
 
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/DenseMapInfo.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/Support/MathExtras.h"
 #include <algorithm>
@@ -71,7 +72,7 @@
 };
 
 class BitVector {
-  typedef unsigned long BitWord;
+  typedef uintptr_t BitWord;
 
   enum { BITWORD_SIZE = (unsigned)sizeof(BitWord) * CHAR_BIT };
 
@@ -187,12 +188,12 @@
   /// all - Returns true if all bits are set.
   bool all() const {
     for (unsigned i = 0; i < Size / BITWORD_SIZE; ++i)
-      if (Bits[i] != ~0UL)
+      if (Bits[i] != ~BitWord(0))
         return false;
 
     // If bits remain check that they are ones. The unused bits are always zero.
     if (unsigned Remainder = Size % BITWORD_SIZE)
-      return Bits[Size / BITWORD_SIZE] == (1UL << Remainder) - 1;
+      return Bits[Size / BITWORD_SIZE] == (BitWord(1) << Remainder) - 1;
 
     return true;
   }
@@ -202,9 +203,10 @@
     return !any();
   }
 
-  /// find_first_in - Returns the index of the first set bit in the range
-  /// [Begin, End).  Returns -1 if all bits in the range are unset.
-  int find_first_in(unsigned Begin, unsigned End) const {
+  /// find_first_in - Returns the index of the first set / unset bit,
+  /// depending on \p Set, in the range [Begin, End).
+  /// Returns -1 if all bits in the range are unset / set.
+  int find_first_in(unsigned Begin, unsigned End, bool Set = true) const {
     assert(Begin <= End && End <= Size);
     if (Begin == End)
       return -1;
@@ -213,8 +215,14 @@
     unsigned LastWord = (End - 1) / BITWORD_SIZE;
 
     // Check subsequent words.
+    // The code below is based on search for the first _set_ bit. If
+    // we're searching for the first _unset_, we just take the
+    // complement of each word before we use it and apply
+    // the same method.
     for (unsigned i = FirstWord; i <= LastWord; ++i) {
       BitWord Copy = Bits[i];
+      if (!Set)
+        Copy = ~Copy;
 
       if (i == FirstWord) {
         unsigned FirstBit = Begin % BITWORD_SIZE;
@@ -265,32 +273,7 @@
   /// find_first_unset_in - Returns the index of the first unset bit in the
   /// range [Begin, End).  Returns -1 if all bits in the range are set.
   int find_first_unset_in(unsigned Begin, unsigned End) const {
-    assert(Begin <= End && End <= Size);
-    if (Begin == End)
-      return -1;
-
-    unsigned FirstWord = Begin / BITWORD_SIZE;
-    unsigned LastWord = (End - 1) / BITWORD_SIZE;
-
-    // Check subsequent words.
-    for (unsigned i = FirstWord; i <= LastWord; ++i) {
-      BitWord Copy = Bits[i];
-
-      if (i == FirstWord) {
-        unsigned FirstBit = Begin % BITWORD_SIZE;
-        Copy |= maskTrailingOnes<BitWord>(FirstBit);
-      }
-
-      if (i == LastWord) {
-        unsigned LastBit = (End - 1) % BITWORD_SIZE;
-        Copy |= maskTrailingZeros<BitWord>(LastBit + 1);
-      }
-      if (Copy != ~0UL) {
-        unsigned Result = i * BITWORD_SIZE + countTrailingOnes(Copy);
-        return Result < size() ? Result : -1;
-      }
-    }
-    return -1;
+    return find_first_in(Begin, End, /* Set = */ false);
   }
 
   /// find_last_unset_in - Returns the index of the last unset bit in the
@@ -317,7 +300,7 @@
         Copy |= maskTrailingOnes<BitWord>(FirstBit);
       }
 
-      if (Copy != ~0UL) {
+      if (Copy != ~BitWord(0)) {
         unsigned Result =
             (CurrentWord + 1) * BITWORD_SIZE - countLeadingOnes(Copy) - 1;
         return Result < Size ? Result : -1;
@@ -414,21 +397,21 @@
     if (I == E) return *this;
 
     if (I / BITWORD_SIZE == E / BITWORD_SIZE) {
-      BitWord EMask = 1UL << (E % BITWORD_SIZE);
-      BitWord IMask = 1UL << (I % BITWORD_SIZE);
+      BitWord EMask = BitWord(1) << (E % BITWORD_SIZE);
+      BitWord IMask = BitWord(1) << (I % BITWORD_SIZE);
       BitWord Mask = EMask - IMask;
       Bits[I / BITWORD_SIZE] |= Mask;
       return *this;
     }
 
-    BitWord PrefixMask = ~0UL << (I % BITWORD_SIZE);
+    BitWord PrefixMask = ~BitWord(0) << (I % BITWORD_SIZE);
     Bits[I / BITWORD_SIZE] |= PrefixMask;
     I = alignTo(I, BITWORD_SIZE);
 
     for (; I + BITWORD_SIZE <= E; I += BITWORD_SIZE)
-      Bits[I / BITWORD_SIZE] = ~0UL;
+      Bits[I / BITWORD_SIZE] = ~BitWord(0);
 
-    BitWord PostfixMask = (1UL << (E % BITWORD_SIZE)) - 1;
+    BitWord PostfixMask = (BitWord(1) << (E % BITWORD_SIZE)) - 1;
     if (I < E)
       Bits[I / BITWORD_SIZE] |= PostfixMask;
 
@@ -453,21 +436,21 @@
     if (I == E) return *this;
 
     if (I / BITWORD_SIZE == E / BITWORD_SIZE) {
-      BitWord EMask = 1UL << (E % BITWORD_SIZE);
-      BitWord IMask = 1UL << (I % BITWORD_SIZE);
+      BitWord EMask = BitWord(1) << (E % BITWORD_SIZE);
+      BitWord IMask = BitWord(1) << (I % BITWORD_SIZE);
       BitWord Mask = EMask - IMask;
       Bits[I / BITWORD_SIZE] &= ~Mask;
       return *this;
     }
 
-    BitWord PrefixMask = ~0UL << (I % BITWORD_SIZE);
+    BitWord PrefixMask = ~BitWord(0) << (I % BITWORD_SIZE);
     Bits[I / BITWORD_SIZE] &= ~PrefixMask;
     I = alignTo(I, BITWORD_SIZE);
 
     for (; I + BITWORD_SIZE <= E; I += BITWORD_SIZE)
-      Bits[I / BITWORD_SIZE] = 0UL;
+      Bits[I / BITWORD_SIZE] = BitWord(0);
 
-    BitWord PostfixMask = (1UL << (E % BITWORD_SIZE)) - 1;
+    BitWord PostfixMask = (BitWord(1) << (E % BITWORD_SIZE)) - 1;
     if (I < E)
       Bits[I / BITWORD_SIZE] &= ~PostfixMask;
 
@@ -531,24 +514,10 @@
 
   // Comparison operators.
   bool operator==(const BitVector &RHS) const {
-    unsigned ThisWords = NumBitWords(size());
-    unsigned RHSWords  = NumBitWords(RHS.size());
-    unsigned i;
-    for (i = 0; i != std::min(ThisWords, RHSWords); ++i)
-      if (Bits[i] != RHS.Bits[i])
-        return false;
-
-    // Verify that any extra words are all zeros.
-    if (i != ThisWords) {
-      for (; i != ThisWords; ++i)
-        if (Bits[i])
-          return false;
-    } else if (i != RHSWords) {
-      for (; i != RHSWords; ++i)
-        if (RHS.Bits[i])
-          return false;
-    }
-    return true;
+    if (size() != RHS.size())
+      return false;
+    unsigned NumWords = NumBitWords(size());
+    return Bits.take_front(NumWords) == RHS.Bits.take_front(NumWords);
   }
 
   bool operator!=(const BitVector &RHS) const {
@@ -719,6 +688,14 @@
     if (this == &RHS) return *this;
 
     Size = RHS.size();
+
+    // Handle tombstone when the BitVector is a key of a DenseHash.
+    if (RHS.isInvalid()) {
+      std::free(Bits.data());
+      Bits = None;
+      return *this;
+    }
+
     unsigned RHSWords = NumBitWords(Size);
     if (Size <= getBitCapacity()) {
       if (Size)
@@ -758,6 +735,16 @@
     std::swap(Size, RHS.Size);
   }
 
+  void invalid() {
+    assert(!Size && Bits.empty());
+    Size = (unsigned)-1;
+  }
+  bool isInvalid() const { return Size == (unsigned)-1; }
+
+  ArrayRef<BitWord> getData() const {
+    return Bits.take_front(NumBitWords(size()));
+  }
+
   //===--------------------------------------------------------------------===//
   // Portable bit mask operations.
   //===--------------------------------------------------------------------===//
@@ -868,7 +855,7 @@
     //  Then set any stray high bits of the last used word.
     unsigned ExtraBits = Size % BITWORD_SIZE;
     if (ExtraBits) {
-      BitWord ExtraBitMask = ~0UL << ExtraBits;
+      BitWord ExtraBitMask = ~BitWord(0) << ExtraBits;
       if (t)
         Bits[UsedWords-1] |= ExtraBitMask;
       else
@@ -932,6 +919,23 @@
   return X.getMemorySize();
 }
 
+template <> struct DenseMapInfo<BitVector> {
+  static inline BitVector getEmptyKey() { return BitVector(); }
+  static inline BitVector getTombstoneKey() {
+    BitVector V;
+    V.invalid();
+    return V;
+  }
+  static unsigned getHashValue(const BitVector &V) {
+    return DenseMapInfo<std::pair<unsigned, ArrayRef<uintptr_t>>>::getHashValue(
+        std::make_pair(V.size(), V.getData()));
+  }
+  static bool isEqual(const BitVector &LHS, const BitVector &RHS) {
+    if (LHS.isInvalid() || RHS.isInvalid())
+      return LHS.isInvalid() == RHS.isInvalid();
+    return LHS == RHS;
+  }
+};
 } // end namespace llvm
 
 namespace std {
diff --git a/linux-x64/clang/include/llvm/ADT/Bitfields.h b/linux-x64/clang/include/llvm/ADT/Bitfields.h
new file mode 100644
index 0000000..d93f648
--- /dev/null
+++ b/linux-x64/clang/include/llvm/ADT/Bitfields.h
@@ -0,0 +1,289 @@
+//===-- llvm/ADT/Bitfield.h - Get and Set bits in an integer ---*- C++ -*--===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file implements methods to test, set and extract typed bits from packed
+/// unsigned integers.
+///
+/// Why not C++ bitfields?
+/// ----------------------
+/// C++ bitfields do not offer control over the bit layout nor consistent
+/// behavior when it comes to out of range values.
+/// For instance, the layout is implementation defined and adjacent bits may be
+/// packed together but are not required to. This is problematic when storage is
+/// sparse and data must be stored in a particular integer type.
+///
+/// The methods provided in this file ensure precise control over the
+/// layout/storage as well as protection against out of range values.
+///
+/// Usage example
+/// -------------
+/// \code{.cpp}
+///  uint8_t Storage = 0;
+///
+///  // Store and retrieve a single bit as bool.
+///  using Bool = Bitfield::Element<bool, 0, 1>;
+///  Bitfield::set<Bool>(Storage, true);
+///  EXPECT_EQ(Storage, 0b00000001);
+///  //                          ^
+///  EXPECT_EQ(Bitfield::get<Bool>(Storage), true);
+///
+///  // Store and retrieve a 2 bit typed enum.
+///  // Note: enum underlying type must be unsigned.
+///  enum class SuitEnum : uint8_t { CLUBS, DIAMONDS, HEARTS, SPADES };
+///  // Note: enum maximum value needs to be passed in as last parameter.
+///  using Suit = Bitfield::Element<SuitEnum, 1, 2, SuitEnum::SPADES>;
+///  Bitfield::set<Suit>(Storage, SuitEnum::HEARTS);
+///  EXPECT_EQ(Storage, 0b00000101);
+///  //                        ^^
+///  EXPECT_EQ(Bitfield::get<Suit>(Storage), SuitEnum::HEARTS);
+///
+///  // Store and retrieve a 5 bit value as unsigned.
+///  using Value = Bitfield::Element<unsigned, 3, 5>;
+///  Bitfield::set<Value>(Storage, 10);
+///  EXPECT_EQ(Storage, 0b01010101);
+///  //                   ^^^^^
+///  EXPECT_EQ(Bitfield::get<Value>(Storage), 10U);
+///
+///  // Interpret the same 5 bit value as signed.
+///  using SignedValue = Bitfield::Element<int, 3, 5>;
+///  Bitfield::set<SignedValue>(Storage, -2);
+///  EXPECT_EQ(Storage, 0b11110101);
+///  //                   ^^^^^
+///  EXPECT_EQ(Bitfield::get<SignedValue>(Storage), -2);
+///
+///  // Ability to efficiently test if a field is non zero.
+///  EXPECT_TRUE(Bitfield::test<Value>(Storage));
+///
+///  // Alter Storage changes value.
+///  Storage = 0;
+///  EXPECT_EQ(Bitfield::get<Bool>(Storage), false);
+///  EXPECT_EQ(Bitfield::get<Suit>(Storage), SuitEnum::CLUBS);
+///  EXPECT_EQ(Bitfield::get<Value>(Storage), 0U);
+///  EXPECT_EQ(Bitfield::get<SignedValue>(Storage), 0);
+///
+///  Storage = 255;
+///  EXPECT_EQ(Bitfield::get<Bool>(Storage), true);
+///  EXPECT_EQ(Bitfield::get<Suit>(Storage), SuitEnum::SPADES);
+///  EXPECT_EQ(Bitfield::get<Value>(Storage), 31U);
+///  EXPECT_EQ(Bitfield::get<SignedValue>(Storage), -1);
+/// \endcode
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_ADT_BITFIELDS_H
+#define LLVM_ADT_BITFIELDS_H
+
+#include <cassert>
+#include <climits> // CHAR_BIT
+#include <cstddef> // size_t
+#include <cstdint> // uintXX_t
+#include <limits>  // numeric_limits
+#include <type_traits>
+
+namespace llvm {
+
+namespace bitfields_details {
+
+/// A struct defining useful bit patterns for n-bits integer types.
+template <typename T, unsigned Bits> struct BitPatterns {
+  /// Bit patterns are forged using the equivalent `Unsigned` type because of
+  /// undefined operations over signed types (e.g. Bitwise shift operators).
+  /// Moreover same size casting from unsigned to signed is well defined but not
+  /// the other way around.
+  using Unsigned = typename std::make_unsigned<T>::type;
+  static_assert(sizeof(Unsigned) == sizeof(T), "Types must have same size");
+
+  static constexpr unsigned TypeBits = sizeof(Unsigned) * CHAR_BIT;
+  static_assert(TypeBits >= Bits, "n-bit must fit in T");
+
+  /// e.g. with TypeBits == 8 and Bits == 6.
+  static constexpr Unsigned AllZeros = Unsigned(0);                  // 00000000
+  static constexpr Unsigned AllOnes = ~Unsigned(0);                  // 11111111
+  static constexpr Unsigned Umin = AllZeros;                         // 00000000
+  static constexpr Unsigned Umax = AllOnes >> (TypeBits - Bits);     // 00111111
+  static constexpr Unsigned SignBitMask = Unsigned(1) << (Bits - 1); // 00100000
+  static constexpr Unsigned Smax = Umax >> 1U;                       // 00011111
+  static constexpr Unsigned Smin = ~Smax;                            // 11100000
+  static constexpr Unsigned SignExtend = Unsigned(Smin << 1U);       // 11000000
+};
+
+/// `Compressor` is used to manipulate the bits of a (possibly signed) integer
+/// type so it can be packed and unpacked into a `bits` sized integer,
+/// `Compressor` is specialized on signed-ness so no runtime cost is incurred.
+/// The `pack` method also checks that the passed in `UserValue` is valid.
+template <typename T, unsigned Bits, bool = std::is_unsigned<T>::value>
+struct Compressor {
+  static_assert(std::is_unsigned<T>::value, "T is unsigned");
+  using BP = BitPatterns<T, Bits>;
+
+  static T pack(T UserValue, T UserMaxValue) {
+    assert(UserValue <= UserMaxValue && "value is too big");
+    assert(UserValue <= BP::Umax && "value is too big");
+    return UserValue;
+  }
+
+  static T unpack(T StorageValue) { return StorageValue; }
+};
+
+template <typename T, unsigned Bits> struct Compressor<T, Bits, false> {
+  static_assert(std::is_signed<T>::value, "T is signed");
+  using BP = BitPatterns<T, Bits>;
+
+  static T pack(T UserValue, T UserMaxValue) {
+    assert(UserValue <= UserMaxValue && "value is too big");
+    assert(UserValue <= T(BP::Smax) && "value is too big");
+    assert(UserValue >= T(BP::Smin) && "value is too small");
+    if (UserValue < 0)
+      UserValue &= ~BP::SignExtend;
+    return UserValue;
+  }
+
+  static T unpack(T StorageValue) {
+    if (StorageValue >= T(BP::SignBitMask))
+      StorageValue |= BP::SignExtend;
+    return StorageValue;
+  }
+};
+
+/// Impl is where Bifield description and Storage are put together to interact
+/// with values.
+template <typename Bitfield, typename StorageType> struct Impl {
+  static_assert(std::is_unsigned<StorageType>::value,
+                "Storage must be unsigned");
+  using IntegerType = typename Bitfield::IntegerType;
+  using C = Compressor<IntegerType, Bitfield::Bits>;
+  using BP = BitPatterns<StorageType, Bitfield::Bits>;
+
+  static constexpr size_t StorageBits = sizeof(StorageType) * CHAR_BIT;
+  static_assert(Bitfield::FirstBit <= StorageBits, "Data must fit in mask");
+  static_assert(Bitfield::LastBit <= StorageBits, "Data must fit in mask");
+  static constexpr StorageType Mask = BP::Umax << Bitfield::Shift;
+
+  /// Checks `UserValue` is within bounds and packs it between `FirstBit` and
+  /// `LastBit` of `Packed` leaving the rest unchanged.
+  static void update(StorageType &Packed, IntegerType UserValue) {
+    const StorageType StorageValue = C::pack(UserValue, Bitfield::UserMaxValue);
+    Packed &= ~Mask;
+    Packed |= StorageValue << Bitfield::Shift;
+  }
+
+  /// Interprets bits between `FirstBit` and `LastBit` of `Packed` as
+  /// an`IntegerType`.
+  static IntegerType extract(StorageType Packed) {
+    const StorageType StorageValue = (Packed & Mask) >> Bitfield::Shift;
+    return C::unpack(StorageValue);
+  }
+
+  /// Interprets bits between `FirstBit` and `LastBit` of `Packed` as
+  /// an`IntegerType`.
+  static StorageType test(StorageType Packed) { return Packed & Mask; }
+};
+
+/// `Bitfield` deals with the following type:
+/// - unsigned enums
+/// - signed and unsigned integer
+/// - `bool`
+/// Internally though we only manipulate integer with well defined and
+/// consistent semantics, this excludes typed enums and `bool` that are replaced
+/// with their unsigned counterparts. The correct type is restored in the public
+/// API.
+template <typename T, bool = std::is_enum<T>::value>
+struct ResolveUnderlyingType {
+  using type = typename std::underlying_type<T>::type;
+};
+template <typename T> struct ResolveUnderlyingType<T, false> {
+  using type = T;
+};
+template <> struct ResolveUnderlyingType<bool, false> {
+  /// In case sizeof(bool) != 1, replace `void` by an additionnal
+  /// std::conditional.
+  using type = std::conditional<sizeof(bool) == 1, uint8_t, void>::type;
+};
+
+} // namespace bitfields_details
+
+/// Holds functions to get, set or test bitfields.
+struct Bitfield {
+  /// Describes an element of a Bitfield. This type is then used with the
+  /// Bitfield static member functions.
+  /// \tparam T         The type of the field once in unpacked form.
+  /// \tparam Offset    The position of the first bit.
+  /// \tparam Size      The size of the field.
+  /// \tparam MaxValue  For enums the maximum enum allowed.
+  template <typename T, unsigned Offset, unsigned Size,
+            T MaxValue = std::is_enum<T>::value
+                             ? T(0) // coupled with static_assert below
+                             : std::numeric_limits<T>::max()>
+  struct Element {
+    using Type = T;
+    using IntegerType =
+        typename bitfields_details::ResolveUnderlyingType<T>::type;
+    static constexpr unsigned Shift = Offset;
+    static constexpr unsigned Bits = Size;
+    static constexpr unsigned FirstBit = Offset;
+    static constexpr unsigned LastBit = Shift + Bits - 1;
+    static constexpr unsigned NextBit = Shift + Bits;
+
+  private:
+    template <typename, typename> friend struct bitfields_details::Impl;
+
+    static_assert(Bits > 0, "Bits must be non zero");
+    static constexpr size_t TypeBits = sizeof(IntegerType) * CHAR_BIT;
+    static_assert(Bits <= TypeBits, "Bits may not be greater than T size");
+    static_assert(!std::is_enum<T>::value || MaxValue != T(0),
+                  "Enum Bitfields must provide a MaxValue");
+    static_assert(!std::is_enum<T>::value ||
+                      std::is_unsigned<IntegerType>::value,
+                  "Enum must be unsigned");
+    static_assert(std::is_integral<IntegerType>::value &&
+                      std::numeric_limits<IntegerType>::is_integer,
+                  "IntegerType must be an integer type");
+
+    static constexpr IntegerType UserMaxValue =
+        static_cast<IntegerType>(MaxValue);
+  };
+
+  /// Unpacks the field from the `Packed` value.
+  template <typename Bitfield, typename StorageType>
+  static typename Bitfield::Type get(StorageType Packed) {
+    using I = bitfields_details::Impl<Bitfield, StorageType>;
+    return static_cast<typename Bitfield::Type>(I::extract(Packed));
+  }
+
+  /// Return a non-zero value if the field is non-zero.
+  /// It is more efficient than `getField`.
+  template <typename Bitfield, typename StorageType>
+  static StorageType test(StorageType Packed) {
+    using I = bitfields_details::Impl<Bitfield, StorageType>;
+    return I::test(Packed);
+  }
+
+  /// Sets the typed value in the provided `Packed` value.
+  /// The method will asserts if the provided value is too big to fit in.
+  template <typename Bitfield, typename StorageType>
+  static void set(StorageType &Packed, typename Bitfield::Type Value) {
+    using I = bitfields_details::Impl<Bitfield, StorageType>;
+    I::update(Packed, static_cast<typename Bitfield::IntegerType>(Value));
+  }
+
+  /// Returns whether the two bitfields share common bits.
+  template <typename A, typename B> static constexpr bool isOverlapping() {
+    return A::LastBit >= B::FirstBit && B::LastBit >= A::FirstBit;
+  }
+
+  template <typename A> static constexpr bool areContiguous() { return true; }
+  template <typename A, typename B, typename... Others>
+  static constexpr bool areContiguous() {
+    return A::NextBit == B::FirstBit && areContiguous<B, Others...>();
+  }
+};
+
+} // namespace llvm
+
+#endif // LLVM_ADT_BITFIELDS_H
diff --git a/linux-x64/clang/include/llvm/ADT/BitmaskEnum.h b/linux-x64/clang/include/llvm/ADT/BitmaskEnum.h
index 1a18bc7..89e5508 100644
--- a/linux-x64/clang/include/llvm/ADT/BitmaskEnum.h
+++ b/linux-x64/clang/include/llvm/ADT/BitmaskEnum.h
@@ -71,49 +71,49 @@
 
 template <typename E>
 struct is_bitmask_enum<
-    E, typename std::enable_if<sizeof(E::LLVM_BITMASK_LARGEST_ENUMERATOR) >=
-                               0>::type> : std::true_type {};
+    E, std::enable_if_t<sizeof(E::LLVM_BITMASK_LARGEST_ENUMERATOR) >= 0>>
+    : std::true_type {};
 namespace BitmaskEnumDetail {
 
 /// Get a bitmask with 1s in all places up to the high-order bit of E's largest
 /// value.
-template <typename E> typename std::underlying_type<E>::type Mask() {
+template <typename E> std::underlying_type_t<E> Mask() {
   // On overflow, NextPowerOf2 returns zero with the type uint64_t, so
   // subtracting 1 gives us the mask with all bits set, like we want.
-  return NextPowerOf2(static_cast<typename std::underlying_type<E>::type>(
+  return NextPowerOf2(static_cast<std::underlying_type_t<E>>(
              E::LLVM_BITMASK_LARGEST_ENUMERATOR)) -
          1;
 }
 
 /// Check that Val is in range for E, and return Val cast to E's underlying
 /// type.
-template <typename E> typename std::underlying_type<E>::type Underlying(E Val) {
-  auto U = static_cast<typename std::underlying_type<E>::type>(Val);
+template <typename E> std::underlying_type_t<E> Underlying(E Val) {
+  auto U = static_cast<std::underlying_type_t<E>>(Val);
   assert(U >= 0 && "Negative enum values are not allowed.");
   assert(U <= Mask<E>() && "Enum value too large (or largest val too small?)");
   return U;
 }
 
-template <typename E,
-          typename = typename std::enable_if<is_bitmask_enum<E>::value>::type>
+constexpr unsigned bitWidth(uint64_t Value) {
+  return Value ? 1 + bitWidth(Value >> 1) : 0;
+}
+
+template <typename E, typename = std::enable_if_t<is_bitmask_enum<E>::value>>
 E operator~(E Val) {
   return static_cast<E>(~Underlying(Val) & Mask<E>());
 }
 
-template <typename E,
-          typename = typename std::enable_if<is_bitmask_enum<E>::value>::type>
+template <typename E, typename = std::enable_if_t<is_bitmask_enum<E>::value>>
 E operator|(E LHS, E RHS) {
   return static_cast<E>(Underlying(LHS) | Underlying(RHS));
 }
 
-template <typename E,
-          typename = typename std::enable_if<is_bitmask_enum<E>::value>::type>
+template <typename E, typename = std::enable_if_t<is_bitmask_enum<E>::value>>
 E operator&(E LHS, E RHS) {
   return static_cast<E>(Underlying(LHS) & Underlying(RHS));
 }
 
-template <typename E,
-          typename = typename std::enable_if<is_bitmask_enum<E>::value>::type>
+template <typename E, typename = std::enable_if_t<is_bitmask_enum<E>::value>>
 E operator^(E LHS, E RHS) {
   return static_cast<E>(Underlying(LHS) ^ Underlying(RHS));
 }
@@ -121,22 +121,19 @@
 // |=, &=, and ^= return a reference to LHS, to match the behavior of the
 // operators on builtin types.
 
-template <typename E,
-          typename = typename std::enable_if<is_bitmask_enum<E>::value>::type>
+template <typename E, typename = std::enable_if_t<is_bitmask_enum<E>::value>>
 E &operator|=(E &LHS, E RHS) {
   LHS = LHS | RHS;
   return LHS;
 }
 
-template <typename E,
-          typename = typename std::enable_if<is_bitmask_enum<E>::value>::type>
+template <typename E, typename = std::enable_if_t<is_bitmask_enum<E>::value>>
 E &operator&=(E &LHS, E RHS) {
   LHS = LHS & RHS;
   return LHS;
 }
 
-template <typename E,
-          typename = typename std::enable_if<is_bitmask_enum<E>::value>::type>
+template <typename E, typename = std::enable_if_t<is_bitmask_enum<E>::value>>
 E &operator^=(E &LHS, E RHS) {
   LHS = LHS ^ RHS;
   return LHS;
@@ -146,6 +143,10 @@
 
 // Enable bitmask enums in namespace ::llvm and all nested namespaces.
 LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE();
+template <typename E, typename = std::enable_if_t<is_bitmask_enum<E>::value>>
+constexpr unsigned BitWidth = BitmaskEnumDetail::bitWidth(uint64_t{
+    static_cast<std::underlying_type_t<E>>(
+        E::LLVM_BITMASK_LARGEST_ENUMERATOR)});
 
 } // namespace llvm
 
diff --git a/linux-x64/clang/include/llvm/ADT/CachedHashString.h b/linux-x64/clang/include/llvm/ADT/CachedHashString.h
index 80144fb..6233d0f 100644
--- a/linux-x64/clang/include/llvm/ADT/CachedHashString.h
+++ b/linux-x64/clang/include/llvm/ADT/CachedHashString.h
@@ -19,9 +19,8 @@
 #ifndef LLVM_ADT_CACHED_HASH_STRING_H
 #define LLVM_ADT_CACHED_HASH_STRING_H
 
-#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/DenseMapInfo.h"
 #include "llvm/ADT/StringRef.h"
-#include "llvm/Support/raw_ostream.h"
 
 namespace llvm {
 
diff --git a/linux-x64/clang/include/llvm/ADT/CoalescingBitVector.h b/linux-x64/clang/include/llvm/ADT/CoalescingBitVector.h
new file mode 100644
index 0000000..0a7dcfe
--- /dev/null
+++ b/linux-x64/clang/include/llvm/ADT/CoalescingBitVector.h
@@ -0,0 +1,443 @@
+//===- llvm/ADT/CoalescingBitVector.h - A coalescing bitvector --*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file A bitvector that uses an IntervalMap to coalesce adjacent elements
+/// into intervals.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_ADT_COALESCINGBITVECTOR_H
+#define LLVM_ADT_COALESCINGBITVECTOR_H
+
+#include "llvm/ADT/IntervalMap.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/iterator_range.h"
+#include "llvm/Support/Debug.h"
+#include "llvm/Support/raw_ostream.h"
+
+#include <algorithm>
+#include <initializer_list>
+
+namespace llvm {
+
+/// A bitvector that, under the hood, relies on an IntervalMap to coalesce
+/// elements into intervals. Good for representing sets which predominantly
+/// contain contiguous ranges. Bad for representing sets with lots of gaps
+/// between elements.
+///
+/// Compared to SparseBitVector, CoalescingBitVector offers more predictable
+/// performance for non-sequential find() operations.
+///
+/// \tparam IndexT - The type of the index into the bitvector.
+template <typename IndexT> class CoalescingBitVector {
+  static_assert(std::is_unsigned<IndexT>::value,
+                "Index must be an unsigned integer.");
+
+  using ThisT = CoalescingBitVector<IndexT>;
+
+  /// An interval map for closed integer ranges. The mapped values are unused.
+  using MapT = IntervalMap<IndexT, char>;
+
+  using UnderlyingIterator = typename MapT::const_iterator;
+
+  using IntervalT = std::pair<IndexT, IndexT>;
+
+public:
+  using Allocator = typename MapT::Allocator;
+
+  /// Construct by passing in a CoalescingBitVector<IndexT>::Allocator
+  /// reference.
+  CoalescingBitVector(Allocator &Alloc)
+      : Alloc(&Alloc), Intervals(Alloc) {}
+
+  /// \name Copy/move constructors and assignment operators.
+  /// @{
+
+  CoalescingBitVector(const ThisT &Other)
+      : Alloc(Other.Alloc), Intervals(*Other.Alloc) {
+    set(Other);
+  }
+
+  ThisT &operator=(const ThisT &Other) {
+    clear();
+    set(Other);
+    return *this;
+  }
+
+  CoalescingBitVector(ThisT &&Other) = delete;
+  ThisT &operator=(ThisT &&Other) = delete;
+
+  /// @}
+
+  /// Clear all the bits.
+  void clear() { Intervals.clear(); }
+
+  /// Check whether no bits are set.
+  bool empty() const { return Intervals.empty(); }
+
+  /// Count the number of set bits.
+  unsigned count() const {
+    unsigned Bits = 0;
+    for (auto It = Intervals.begin(), End = Intervals.end(); It != End; ++It)
+      Bits += 1 + It.stop() - It.start();
+    return Bits;
+  }
+
+  /// Set the bit at \p Index.
+  ///
+  /// This method does /not/ support setting a bit that has already been set,
+  /// for efficiency reasons. If possible, restructure your code to not set the
+  /// same bit multiple times, or use \ref test_and_set.
+  void set(IndexT Index) {
+    assert(!test(Index) && "Setting already-set bits not supported/efficient, "
+                           "IntervalMap will assert");
+    insert(Index, Index);
+  }
+
+  /// Set the bits set in \p Other.
+  ///
+  /// This method does /not/ support setting already-set bits, see \ref set
+  /// for the rationale. For a safe set union operation, use \ref operator|=.
+  void set(const ThisT &Other) {
+    for (auto It = Other.Intervals.begin(), End = Other.Intervals.end();
+         It != End; ++It)
+      insert(It.start(), It.stop());
+  }
+
+  /// Set the bits at \p Indices. Used for testing, primarily.
+  void set(std::initializer_list<IndexT> Indices) {
+    for (IndexT Index : Indices)
+      set(Index);
+  }
+
+  /// Check whether the bit at \p Index is set.
+  bool test(IndexT Index) const {
+    const auto It = Intervals.find(Index);
+    if (It == Intervals.end())
+      return false;
+    assert(It.stop() >= Index && "Interval must end after Index");
+    return It.start() <= Index;
+  }
+
+  /// Set the bit at \p Index. Supports setting an already-set bit.
+  void test_and_set(IndexT Index) {
+    if (!test(Index))
+      set(Index);
+  }
+
+  /// Reset the bit at \p Index. Supports resetting an already-unset bit.
+  void reset(IndexT Index) {
+    auto It = Intervals.find(Index);
+    if (It == Intervals.end())
+      return;
+
+    // Split the interval containing Index into up to two parts: one from
+    // [Start, Index-1] and another from [Index+1, Stop]. If Index is equal to
+    // either Start or Stop, we create one new interval. If Index is equal to
+    // both Start and Stop, we simply erase the existing interval.
+    IndexT Start = It.start();
+    if (Index < Start)
+      // The index was not set.
+      return;
+    IndexT Stop = It.stop();
+    assert(Index <= Stop && "Wrong interval for index");
+    It.erase();
+    if (Start < Index)
+      insert(Start, Index - 1);
+    if (Index < Stop)
+      insert(Index + 1, Stop);
+  }
+
+  /// Set union. If \p RHS is guaranteed to not overlap with this, \ref set may
+  /// be a faster alternative.
+  void operator|=(const ThisT &RHS) {
+    // Get the overlaps between the two interval maps.
+    SmallVector<IntervalT, 8> Overlaps;
+    getOverlaps(RHS, Overlaps);
+
+    // Insert the non-overlapping parts of all the intervals from RHS.
+    for (auto It = RHS.Intervals.begin(), End = RHS.Intervals.end();
+         It != End; ++It) {
+      IndexT Start = It.start();
+      IndexT Stop = It.stop();
+      SmallVector<IntervalT, 8> NonOverlappingParts;
+      getNonOverlappingParts(Start, Stop, Overlaps, NonOverlappingParts);
+      for (IntervalT AdditivePortion : NonOverlappingParts)
+        insert(AdditivePortion.first, AdditivePortion.second);
+    }
+  }
+
+  /// Set intersection.
+  void operator&=(const ThisT &RHS) {
+    // Get the overlaps between the two interval maps (i.e. the intersection).
+    SmallVector<IntervalT, 8> Overlaps;
+    getOverlaps(RHS, Overlaps);
+    // Rebuild the interval map, including only the overlaps.
+    clear();
+    for (IntervalT Overlap : Overlaps)
+      insert(Overlap.first, Overlap.second);
+  }
+
+  /// Reset all bits present in \p Other.
+  void intersectWithComplement(const ThisT &Other) {
+    SmallVector<IntervalT, 8> Overlaps;
+    if (!getOverlaps(Other, Overlaps)) {
+      // If there is no overlap with Other, the intersection is empty.
+      return;
+    }
+
+    // Delete the overlapping intervals. Split up intervals that only partially
+    // intersect an overlap.
+    for (IntervalT Overlap : Overlaps) {
+      IndexT OlapStart, OlapStop;
+      std::tie(OlapStart, OlapStop) = Overlap;
+
+      auto It = Intervals.find(OlapStart);
+      IndexT CurrStart = It.start();
+      IndexT CurrStop = It.stop();
+      assert(CurrStart <= OlapStart && OlapStop <= CurrStop &&
+             "Expected some intersection!");
+
+      // Split the overlap interval into up to two parts: one from [CurrStart,
+      // OlapStart-1] and another from [OlapStop+1, CurrStop]. If OlapStart is
+      // equal to CurrStart, the first split interval is unnecessary. Ditto for
+      // when OlapStop is equal to CurrStop, we omit the second split interval.
+      It.erase();
+      if (CurrStart < OlapStart)
+        insert(CurrStart, OlapStart - 1);
+      if (OlapStop < CurrStop)
+        insert(OlapStop + 1, CurrStop);
+    }
+  }
+
+  bool operator==(const ThisT &RHS) const {
+    // We cannot just use std::equal because it checks the dereferenced values
+    // of an iterator pair for equality, not the iterators themselves. In our
+    // case that results in comparison of the (unused) IntervalMap values.
+    auto ItL = Intervals.begin();
+    auto ItR = RHS.Intervals.begin();
+    while (ItL != Intervals.end() && ItR != RHS.Intervals.end() &&
+           ItL.start() == ItR.start() && ItL.stop() == ItR.stop()) {
+      ++ItL;
+      ++ItR;
+    }
+    return ItL == Intervals.end() && ItR == RHS.Intervals.end();
+  }
+
+  bool operator!=(const ThisT &RHS) const { return !operator==(RHS); }
+
+  class const_iterator
+      : public std::iterator<std::forward_iterator_tag, IndexT> {
+    friend class CoalescingBitVector;
+
+    // For performance reasons, make the offset at the end different than the
+    // one used in \ref begin, to optimize the common `It == end()` pattern.
+    static constexpr unsigned kIteratorAtTheEndOffset = ~0u;
+
+    UnderlyingIterator MapIterator;
+    unsigned OffsetIntoMapIterator = 0;
+
+    // Querying the start/stop of an IntervalMap iterator can be very expensive.
+    // Cache these values for performance reasons.
+    IndexT CachedStart = IndexT();
+    IndexT CachedStop = IndexT();
+
+    void setToEnd() {
+      OffsetIntoMapIterator = kIteratorAtTheEndOffset;
+      CachedStart = IndexT();
+      CachedStop = IndexT();
+    }
+
+    /// MapIterator has just changed, reset the cached state to point to the
+    /// start of the new underlying iterator.
+    void resetCache() {
+      if (MapIterator.valid()) {
+        OffsetIntoMapIterator = 0;
+        CachedStart = MapIterator.start();
+        CachedStop = MapIterator.stop();
+      } else {
+        setToEnd();
+      }
+    }
+
+    /// Advance the iterator to \p Index, if it is contained within the current
+    /// interval. The public-facing method which supports advancing past the
+    /// current interval is \ref advanceToLowerBound.
+    void advanceTo(IndexT Index) {
+      assert(Index <= CachedStop && "Cannot advance to OOB index");
+      if (Index < CachedStart)
+        // We're already past this index.
+        return;
+      OffsetIntoMapIterator = Index - CachedStart;
+    }
+
+    const_iterator(UnderlyingIterator MapIt) : MapIterator(MapIt) {
+      resetCache();
+    }
+
+  public:
+    const_iterator() { setToEnd(); }
+
+    bool operator==(const const_iterator &RHS) const {
+      // Do /not/ compare MapIterator for equality, as this is very expensive.
+      // The cached start/stop values make that check unnecessary.
+      return std::tie(OffsetIntoMapIterator, CachedStart, CachedStop) ==
+             std::tie(RHS.OffsetIntoMapIterator, RHS.CachedStart,
+                      RHS.CachedStop);
+    }
+
+    bool operator!=(const const_iterator &RHS) const {
+      return !operator==(RHS);
+    }
+
+    IndexT operator*() const { return CachedStart + OffsetIntoMapIterator; }
+
+    const_iterator &operator++() { // Pre-increment (++It).
+      if (CachedStart + OffsetIntoMapIterator < CachedStop) {
+        // Keep going within the current interval.
+        ++OffsetIntoMapIterator;
+      } else {
+        // We reached the end of the current interval: advance.
+        ++MapIterator;
+        resetCache();
+      }
+      return *this;
+    }
+
+    const_iterator operator++(int) { // Post-increment (It++).
+      const_iterator tmp = *this;
+      operator++();
+      return tmp;
+    }
+
+    /// Advance the iterator to the first set bit AT, OR AFTER, \p Index. If
+    /// no such set bit exists, advance to end(). This is like std::lower_bound.
+    /// This is useful if \p Index is close to the current iterator position.
+    /// However, unlike \ref find(), this has worst-case O(n) performance.
+    void advanceToLowerBound(IndexT Index) {
+      if (OffsetIntoMapIterator == kIteratorAtTheEndOffset)
+        return;
+
+      // Advance to the first interval containing (or past) Index, or to end().
+      while (Index > CachedStop) {
+        ++MapIterator;
+        resetCache();
+        if (OffsetIntoMapIterator == kIteratorAtTheEndOffset)
+          return;
+      }
+
+      advanceTo(Index);
+    }
+  };
+
+  const_iterator begin() const { return const_iterator(Intervals.begin()); }
+
+  const_iterator end() const { return const_iterator(); }
+
+  /// Return an iterator pointing to the first set bit AT, OR AFTER, \p Index.
+  /// If no such set bit exists, return end(). This is like std::lower_bound.
+  /// This has worst-case logarithmic performance (roughly O(log(gaps between
+  /// contiguous ranges))).
+  const_iterator find(IndexT Index) const {
+    auto UnderlyingIt = Intervals.find(Index);
+    if (UnderlyingIt == Intervals.end())
+      return end();
+    auto It = const_iterator(UnderlyingIt);
+    It.advanceTo(Index);
+    return It;
+  }
+
+  /// Return a range iterator which iterates over all of the set bits in the
+  /// half-open range [Start, End).
+  iterator_range<const_iterator> half_open_range(IndexT Start,
+                                                 IndexT End) const {
+    assert(Start < End && "Not a valid range");
+    auto StartIt = find(Start);
+    if (StartIt == end() || *StartIt >= End)
+      return {end(), end()};
+    auto EndIt = StartIt;
+    EndIt.advanceToLowerBound(End);
+    return {StartIt, EndIt};
+  }
+
+  void print(raw_ostream &OS) const {
+    OS << "{";
+    for (auto It = Intervals.begin(), End = Intervals.end(); It != End;
+         ++It) {
+      OS << "[" << It.start();
+      if (It.start() != It.stop())
+        OS << ", " << It.stop();
+      OS << "]";
+    }
+    OS << "}";
+  }
+
+#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+  LLVM_DUMP_METHOD void dump() const {
+    // LLDB swallows the first line of output after callling dump(). Add
+    // newlines before/after the braces to work around this.
+    dbgs() << "\n";
+    print(dbgs());
+    dbgs() << "\n";
+  }
+#endif
+
+private:
+  void insert(IndexT Start, IndexT End) { Intervals.insert(Start, End, 0); }
+
+  /// Record the overlaps between \p this and \p Other in \p Overlaps. Return
+  /// true if there is any overlap.
+  bool getOverlaps(const ThisT &Other,
+                   SmallVectorImpl<IntervalT> &Overlaps) const {
+    for (IntervalMapOverlaps<MapT, MapT> I(Intervals, Other.Intervals);
+         I.valid(); ++I)
+      Overlaps.emplace_back(I.start(), I.stop());
+    assert(llvm::is_sorted(Overlaps,
+                           [](IntervalT LHS, IntervalT RHS) {
+                             return LHS.second < RHS.first;
+                           }) &&
+           "Overlaps must be sorted");
+    return !Overlaps.empty();
+  }
+
+  /// Given the set of overlaps between this and some other bitvector, and an
+  /// interval [Start, Stop] from that bitvector, determine the portions of the
+  /// interval which do not overlap with this.
+  void getNonOverlappingParts(IndexT Start, IndexT Stop,
+                              const SmallVectorImpl<IntervalT> &Overlaps,
+                              SmallVectorImpl<IntervalT> &NonOverlappingParts) {
+    IndexT NextUncoveredBit = Start;
+    for (IntervalT Overlap : Overlaps) {
+      IndexT OlapStart, OlapStop;
+      std::tie(OlapStart, OlapStop) = Overlap;
+
+      // [Start;Stop] and [OlapStart;OlapStop] overlap iff OlapStart <= Stop
+      // and Start <= OlapStop.
+      bool DoesOverlap = OlapStart <= Stop && Start <= OlapStop;
+      if (!DoesOverlap)
+        continue;
+
+      // Cover the range [NextUncoveredBit, OlapStart). This puts the start of
+      // the next uncovered range at OlapStop+1.
+      if (NextUncoveredBit < OlapStart)
+        NonOverlappingParts.emplace_back(NextUncoveredBit, OlapStart - 1);
+      NextUncoveredBit = OlapStop + 1;
+      if (NextUncoveredBit > Stop)
+        break;
+    }
+    if (NextUncoveredBit <= Stop)
+      NonOverlappingParts.emplace_back(NextUncoveredBit, Stop);
+  }
+
+  Allocator *Alloc;
+  MapT Intervals;
+};
+
+} // namespace llvm
+
+#endif // LLVM_ADT_COALESCINGBITVECTOR_H
diff --git a/linux-x64/clang/include/llvm/ADT/DAGDeltaAlgorithm.h b/linux-x64/clang/include/llvm/ADT/DAGDeltaAlgorithm.h
index d4cdc3c..c3872af 100644
--- a/linux-x64/clang/include/llvm/ADT/DAGDeltaAlgorithm.h
+++ b/linux-x64/clang/include/llvm/ADT/DAGDeltaAlgorithm.h
@@ -29,7 +29,7 @@
 ///
 ///   P(S) => P(S union pred(S))
 ///
-/// The minization algorithm uses this dependency information to attempt to
+/// The minimization algorithm uses this dependency information to attempt to
 /// eagerly prune large subsets of changes. As with \see DeltaAlgorithm, the DAG
 /// is not required to satisfy this property, but the algorithm will run
 /// substantially fewer tests with appropriate dependencies. \see DeltaAlgorithm
diff --git a/linux-x64/clang/include/llvm/ADT/DeltaAlgorithm.h b/linux-x64/clang/include/llvm/ADT/DeltaAlgorithm.h
index 114b954..e1743fd 100644
--- a/linux-x64/clang/include/llvm/ADT/DeltaAlgorithm.h
+++ b/linux-x64/clang/include/llvm/ADT/DeltaAlgorithm.h
@@ -54,7 +54,7 @@
   /// Split - Partition a set of changes \p S into one or two subsets.
   void Split(const changeset_ty &S, changesetlist_ty &Res);
 
-  /// Delta - Minimize a set of \p Changes which has been partioned into
+  /// Delta - Minimize a set of \p Changes which has been partitioned into
   /// smaller sets, by attempting to remove individual subsets.
   changeset_ty Delta(const changeset_ty &Changes,
                      const changesetlist_ty &Sets);
diff --git a/linux-x64/clang/include/llvm/ADT/DenseMap.h b/linux-x64/clang/include/llvm/ADT/DenseMap.h
index a05cf81..ce0b05d 100644
--- a/linux-x64/clang/include/llvm/ADT/DenseMap.h
+++ b/linux-x64/clang/include/llvm/ADT/DenseMap.h
@@ -18,6 +18,7 @@
 #include "llvm/Support/AlignOf.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/MathExtras.h"
+#include "llvm/Support/MemAlloc.h"
 #include "llvm/Support/ReverseIteration.h"
 #include "llvm/Support/type_traits.h"
 #include <algorithm>
@@ -38,33 +39,7 @@
 // implementation without requiring two members.
 template <typename KeyT, typename ValueT>
 struct DenseMapPair : public std::pair<KeyT, ValueT> {
-
-  // FIXME: Switch to inheriting constructors when we drop support for older
-  //        clang versions.
-  // NOTE: This default constructor is declared with '{}' rather than
-  //       '= default' to work around a separate bug in clang-3.8. This can
-  //       also go when we switch to inheriting constructors.
-  DenseMapPair() {}
-
-  DenseMapPair(const KeyT &Key, const ValueT &Value)
-      : std::pair<KeyT, ValueT>(Key, Value) {}
-
-  DenseMapPair(KeyT &&Key, ValueT &&Value)
-      : std::pair<KeyT, ValueT>(std::move(Key), std::move(Value)) {}
-
-  template <typename AltKeyT, typename AltValueT>
-  DenseMapPair(AltKeyT &&AltKey, AltValueT &&AltValue,
-               typename std::enable_if<
-                   std::is_convertible<AltKeyT, KeyT>::value &&
-                   std::is_convertible<AltValueT, ValueT>::value>::type * = 0)
-      : std::pair<KeyT, ValueT>(std::forward<AltKeyT>(AltKey),
-                                std::forward<AltValueT>(AltValue)) {}
-
-  template <typename AltPairT>
-  DenseMapPair(AltPairT &&AltPair,
-               typename std::enable_if<std::is_convertible<
-                   AltPairT, std::pair<KeyT, ValueT>>::value>::type * = nullptr)
-      : std::pair<KeyT, ValueT>(std::forward<AltPairT>(AltPair)) {}
+  using std::pair<KeyT, ValueT>::pair;
 
   KeyT &getFirst() { return std::pair<KeyT, ValueT>::first; }
   const KeyT &getFirst() const { return std::pair<KeyT, ValueT>::first; }
@@ -145,9 +120,8 @@
     }
 
     const KeyT EmptyKey = getEmptyKey(), TombstoneKey = getTombstoneKey();
-    if (is_trivially_copyable<KeyT>::value &&
-        is_trivially_copyable<ValueT>::value) {
-      // Use a simpler loop when these are trivial types.
+    if (std::is_trivially_destructible<ValueT>::value) {
+      // Use a simpler loop when values don't need destruction.
       for (BucketT *P = getBuckets(), *E = getBucketsEnd(); P != E; ++P)
         P->getFirst() = EmptyKey;
     } else {
@@ -176,13 +150,19 @@
   iterator find(const_arg_type_t<KeyT> Val) {
     BucketT *TheBucket;
     if (LookupBucketFor(Val, TheBucket))
-      return makeIterator(TheBucket, getBucketsEnd(), *this, true);
+      return makeIterator(TheBucket,
+                          shouldReverseIterate<KeyT>() ? getBuckets()
+                                                       : getBucketsEnd(),
+                          *this, true);
     return end();
   }
   const_iterator find(const_arg_type_t<KeyT> Val) const {
     const BucketT *TheBucket;
     if (LookupBucketFor(Val, TheBucket))
-      return makeConstIterator(TheBucket, getBucketsEnd(), *this, true);
+      return makeConstIterator(TheBucket,
+                               shouldReverseIterate<KeyT>() ? getBuckets()
+                                                            : getBucketsEnd(),
+                               *this, true);
     return end();
   }
 
@@ -195,14 +175,20 @@
   iterator find_as(const LookupKeyT &Val) {
     BucketT *TheBucket;
     if (LookupBucketFor(Val, TheBucket))
-      return makeIterator(TheBucket, getBucketsEnd(), *this, true);
+      return makeIterator(TheBucket,
+                          shouldReverseIterate<KeyT>() ? getBuckets()
+                                                       : getBucketsEnd(),
+                          *this, true);
     return end();
   }
   template<class LookupKeyT>
   const_iterator find_as(const LookupKeyT &Val) const {
     const BucketT *TheBucket;
     if (LookupBucketFor(Val, TheBucket))
-      return makeConstIterator(TheBucket, getBucketsEnd(), *this, true);
+      return makeConstIterator(TheBucket,
+                               shouldReverseIterate<KeyT>() ? getBuckets()
+                                                            : getBucketsEnd(),
+                               *this, true);
     return end();
   }
 
@@ -236,16 +222,22 @@
   std::pair<iterator, bool> try_emplace(KeyT &&Key, Ts &&... Args) {
     BucketT *TheBucket;
     if (LookupBucketFor(Key, TheBucket))
-      return std::make_pair(
-               makeIterator(TheBucket, getBucketsEnd(), *this, true),
-               false); // Already in map.
+      return std::make_pair(makeIterator(TheBucket,
+                                         shouldReverseIterate<KeyT>()
+                                             ? getBuckets()
+                                             : getBucketsEnd(),
+                                         *this, true),
+                            false); // Already in map.
 
     // Otherwise, insert the new element.
     TheBucket =
         InsertIntoBucket(TheBucket, std::move(Key), std::forward<Ts>(Args)...);
-    return std::make_pair(
-             makeIterator(TheBucket, getBucketsEnd(), *this, true),
-             true);
+    return std::make_pair(makeIterator(TheBucket,
+                                       shouldReverseIterate<KeyT>()
+                                           ? getBuckets()
+                                           : getBucketsEnd(),
+                                       *this, true),
+                          true);
   }
 
   // Inserts key,value pair into the map if the key isn't already in the map.
@@ -255,15 +247,21 @@
   std::pair<iterator, bool> try_emplace(const KeyT &Key, Ts &&... Args) {
     BucketT *TheBucket;
     if (LookupBucketFor(Key, TheBucket))
-      return std::make_pair(
-               makeIterator(TheBucket, getBucketsEnd(), *this, true),
-               false); // Already in map.
+      return std::make_pair(makeIterator(TheBucket,
+                                         shouldReverseIterate<KeyT>()
+                                             ? getBuckets()
+                                             : getBucketsEnd(),
+                                         *this, true),
+                            false); // Already in map.
 
     // Otherwise, insert the new element.
     TheBucket = InsertIntoBucket(TheBucket, Key, std::forward<Ts>(Args)...);
-    return std::make_pair(
-             makeIterator(TheBucket, getBucketsEnd(), *this, true),
-             true);
+    return std::make_pair(makeIterator(TheBucket,
+                                       shouldReverseIterate<KeyT>()
+                                           ? getBuckets()
+                                           : getBucketsEnd(),
+                                       *this, true),
+                          true);
   }
 
   /// Alternate version of insert() which allows a different, and possibly
@@ -276,16 +274,22 @@
                                       const LookupKeyT &Val) {
     BucketT *TheBucket;
     if (LookupBucketFor(Val, TheBucket))
-      return std::make_pair(
-               makeIterator(TheBucket, getBucketsEnd(), *this, true),
-               false); // Already in map.
+      return std::make_pair(makeIterator(TheBucket,
+                                         shouldReverseIterate<KeyT>()
+                                             ? getBuckets()
+                                             : getBucketsEnd(),
+                                         *this, true),
+                            false); // Already in map.
 
     // Otherwise, insert the new element.
     TheBucket = InsertIntoBucketWithLookup(TheBucket, std::move(KV.first),
                                            std::move(KV.second), Val);
-    return std::make_pair(
-             makeIterator(TheBucket, getBucketsEnd(), *this, true),
-             true);
+    return std::make_pair(makeIterator(TheBucket,
+                                       shouldReverseIterate<KeyT>()
+                                           ? getBuckets()
+                                           : getBucketsEnd(),
+                                       *this, true),
+                          true);
   }
 
   /// insert - Range insertion of pairs.
@@ -422,8 +426,8 @@
     setNumEntries(other.getNumEntries());
     setNumTombstones(other.getNumTombstones());
 
-    if (is_trivially_copyable<KeyT>::value &&
-        is_trivially_copyable<ValueT>::value)
+    if (std::is_trivially_copyable<KeyT>::value &&
+        std::is_trivially_copyable<ValueT>::value)
       memcpy(reinterpret_cast<void *>(getBuckets()), other.getBuckets(),
              getNumBuckets() * sizeof(BucketT));
     else
@@ -721,7 +725,7 @@
   unsigned NumBuckets;
 
 public:
-  /// Create a DenseMap wth an optional \p InitialReserve that guarantee that
+  /// Create a DenseMap with an optional \p InitialReserve that guarantee that
   /// this number of elements can be inserted in the map without grow()
   explicit DenseMap(unsigned InitialReserve = 0) { init(InitialReserve); }
 
@@ -748,7 +752,7 @@
 
   ~DenseMap() {
     this->destroyAll();
-    operator delete(Buckets);
+    deallocate_buffer(Buckets, sizeof(BucketT) * NumBuckets, alignof(BucketT));
   }
 
   void swap(DenseMap& RHS) {
@@ -768,7 +772,7 @@
 
   DenseMap& operator=(DenseMap &&other) {
     this->destroyAll();
-    operator delete(Buckets);
+    deallocate_buffer(Buckets, sizeof(BucketT) * NumBuckets, alignof(BucketT));
     init(0);
     swap(other);
     return *this;
@@ -776,7 +780,7 @@
 
   void copyFrom(const DenseMap& other) {
     this->destroyAll();
-    operator delete(Buckets);
+    deallocate_buffer(Buckets, sizeof(BucketT) * NumBuckets, alignof(BucketT));
     if (allocateBuckets(other.NumBuckets)) {
       this->BaseT::copyFrom(other);
     } else {
@@ -809,10 +813,12 @@
     this->moveFromOldBuckets(OldBuckets, OldBuckets+OldNumBuckets);
 
     // Free the old table.
-    operator delete(OldBuckets);
+    deallocate_buffer(OldBuckets, sizeof(BucketT) * OldNumBuckets,
+                      alignof(BucketT));
   }
 
   void shrink_and_clear() {
+    unsigned OldNumBuckets = NumBuckets;
     unsigned OldNumEntries = NumEntries;
     this->destroyAll();
 
@@ -825,7 +831,8 @@
       return;
     }
 
-    operator delete(Buckets);
+    deallocate_buffer(Buckets, sizeof(BucketT) * OldNumBuckets,
+                      alignof(BucketT));
     init(NewNumBuckets);
   }
 
@@ -861,7 +868,8 @@
       return false;
     }
 
-    Buckets = static_cast<BucketT*>(operator new(sizeof(BucketT) * NumBuckets));
+    Buckets = static_cast<BucketT *>(
+        allocate_buffer(sizeof(BucketT) * NumBuckets, alignof(BucketT)));
     return true;
   }
 };
@@ -946,7 +954,7 @@
           std::swap(*LHSB, *RHSB);
           continue;
         }
-        // Swap separately and handle any assymetry.
+        // Swap separately and handle any asymmetry.
         std::swap(LHSB->getFirst(), RHSB->getFirst());
         if (hasLHSValue) {
           ::new (&RHSB->getSecond()) ValueT(std::move(LHSB->getSecond()));
@@ -1028,16 +1036,13 @@
   }
 
   void grow(unsigned AtLeast) {
-    if (AtLeast >= InlineBuckets)
+    if (AtLeast > InlineBuckets)
       AtLeast = std::max<unsigned>(64, NextPowerOf2(AtLeast-1));
 
     if (Small) {
-      if (AtLeast < InlineBuckets)
-        return; // Nothing to do.
-
       // First move the inline buckets into a temporary storage.
       AlignedCharArrayUnion<BucketT[InlineBuckets]> TmpStorage;
-      BucketT *TmpBegin = reinterpret_cast<BucketT *>(TmpStorage.buffer);
+      BucketT *TmpBegin = reinterpret_cast<BucketT *>(&TmpStorage);
       BucketT *TmpEnd = TmpBegin;
 
       // Loop over the buckets, moving non-empty, non-tombstones into the
@@ -1057,10 +1062,13 @@
         P->getFirst().~KeyT();
       }
 
-      // Now make this map use the large rep, and move all the entries back
-      // into it.
-      Small = false;
-      new (getLargeRep()) LargeRep(allocateBuckets(AtLeast));
+      // AtLeast == InlineBuckets can happen if there are many tombstones,
+      // and grow() is used to remove them. Usually we always switch to the
+      // large rep here.
+      if (AtLeast > InlineBuckets) {
+        Small = false;
+        new (getLargeRep()) LargeRep(allocateBuckets(AtLeast));
+      }
       this->moveFromOldBuckets(TmpBegin, TmpEnd);
       return;
     }
@@ -1076,7 +1084,8 @@
     this->moveFromOldBuckets(OldRep.Buckets, OldRep.Buckets+OldRep.NumBuckets);
 
     // Free the old table.
-    operator delete(OldRep.Buckets);
+    deallocate_buffer(OldRep.Buckets, sizeof(BucketT) * OldRep.NumBuckets,
+                      alignof(BucketT));
   }
 
   void shrink_and_clear() {
@@ -1123,8 +1132,8 @@
     assert(Small);
     // Note that this cast does not violate aliasing rules as we assert that
     // the memory's dynamic type is the small, inline bucket buffer, and the
-    // 'storage.buffer' static type is 'char *'.
-    return reinterpret_cast<const BucketT *>(storage.buffer);
+    // 'storage' is a POD containing a char buffer.
+    return reinterpret_cast<const BucketT *>(&storage);
   }
 
   BucketT *getInlineBuckets() {
@@ -1135,7 +1144,7 @@
   const LargeRep *getLargeRep() const {
     assert(!Small);
     // Note, same rule about aliasing as with getInlineBuckets.
-    return reinterpret_cast<const LargeRep *>(storage.buffer);
+    return reinterpret_cast<const LargeRep *>(&storage);
   }
 
   LargeRep *getLargeRep() {
@@ -1160,15 +1169,17 @@
     if (Small)
       return;
 
-    operator delete(getLargeRep()->Buckets);
+    deallocate_buffer(getLargeRep()->Buckets,
+                      sizeof(BucketT) * getLargeRep()->NumBuckets,
+                      alignof(BucketT));
     getLargeRep()->~LargeRep();
   }
 
   LargeRep allocateBuckets(unsigned Num) {
     assert(Num > InlineBuckets && "Must allocate more buckets than are inline");
-    LargeRep Rep = {
-      static_cast<BucketT*>(operator new(sizeof(BucketT) * Num)), Num
-    };
+    LargeRep Rep = {static_cast<BucketT *>(allocate_buffer(
+                        sizeof(BucketT) * Num, alignof(BucketT))),
+                    Num};
     return Rep;
   }
 };
@@ -1179,8 +1190,6 @@
   friend class DenseMapIterator<KeyT, ValueT, KeyInfoT, Bucket, true>;
   friend class DenseMapIterator<KeyT, ValueT, KeyInfoT, Bucket, false>;
 
-  using ConstIterator = DenseMapIterator<KeyT, ValueT, KeyInfoT, Bucket, true>;
-
 public:
   using difference_type = ptrdiff_t;
   using value_type =
@@ -1213,41 +1222,43 @@
   // for const iterator destinations so it doesn't end up as a user defined copy
   // constructor.
   template <bool IsConstSrc,
-            typename = typename std::enable_if<!IsConstSrc && IsConst>::type>
+            typename = std::enable_if_t<!IsConstSrc && IsConst>>
   DenseMapIterator(
       const DenseMapIterator<KeyT, ValueT, KeyInfoT, Bucket, IsConstSrc> &I)
       : DebugEpochBase::HandleBase(I), Ptr(I.Ptr), End(I.End) {}
 
   reference operator*() const {
     assert(isHandleInSync() && "invalid iterator access!");
+    assert(Ptr != End && "dereferencing end() iterator");
     if (shouldReverseIterate<KeyT>())
       return Ptr[-1];
     return *Ptr;
   }
   pointer operator->() const {
     assert(isHandleInSync() && "invalid iterator access!");
+    assert(Ptr != End && "dereferencing end() iterator");
     if (shouldReverseIterate<KeyT>())
       return &(Ptr[-1]);
     return Ptr;
   }
 
-  bool operator==(const ConstIterator &RHS) const {
-    assert((!Ptr || isHandleInSync()) && "handle not in sync!");
+  friend bool operator==(const DenseMapIterator &LHS,
+                         const DenseMapIterator &RHS) {
+    assert((!LHS.Ptr || LHS.isHandleInSync()) && "handle not in sync!");
     assert((!RHS.Ptr || RHS.isHandleInSync()) && "handle not in sync!");
-    assert(getEpochAddress() == RHS.getEpochAddress() &&
+    assert(LHS.getEpochAddress() == RHS.getEpochAddress() &&
            "comparing incomparable iterators!");
-    return Ptr == RHS.Ptr;
+    return LHS.Ptr == RHS.Ptr;
   }
-  bool operator!=(const ConstIterator &RHS) const {
-    assert((!Ptr || isHandleInSync()) && "handle not in sync!");
-    assert((!RHS.Ptr || RHS.isHandleInSync()) && "handle not in sync!");
-    assert(getEpochAddress() == RHS.getEpochAddress() &&
-           "comparing incomparable iterators!");
-    return Ptr != RHS.Ptr;
+
+  friend bool operator!=(const DenseMapIterator &LHS,
+                         const DenseMapIterator &RHS) {
+    return !(LHS == RHS);
   }
 
   inline DenseMapIterator& operator++() {  // Preincrement
     assert(isHandleInSync() && "invalid iterator access!");
+    assert(Ptr != End && "incrementing end() iterator");
     if (shouldReverseIterate<KeyT>()) {
       --Ptr;
       RetreatPastEmptyBuckets();
diff --git a/linux-x64/clang/include/llvm/ADT/DenseMapInfo.h b/linux-x64/clang/include/llvm/ADT/DenseMapInfo.h
index 5ef6f3a..8271b93 100644
--- a/linux-x64/clang/include/llvm/ADT/DenseMapInfo.h
+++ b/linux-x64/clang/include/llvm/ADT/DenseMapInfo.h
@@ -13,11 +13,11 @@
 #ifndef LLVM_ADT_DENSEMAPINFO_H
 #define LLVM_ADT_DENSEMAPINFO_H
 
+#include "llvm/ADT/APInt.h"
+#include "llvm/ADT/APSInt.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/StringRef.h"
-#include "llvm/Support/PointerLikeTypeTraits.h"
-#include "llvm/Support/ScalableSize.h"
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
@@ -25,6 +25,24 @@
 
 namespace llvm {
 
+namespace detail {
+
+/// Simplistic combination of 32-bit hash values into 32-bit hash values.
+static inline unsigned combineHashValue(unsigned a, unsigned b) {
+  uint64_t key = (uint64_t)a << 32 | (uint64_t)b;
+  key += ~(key << 32);
+  key ^= (key >> 22);
+  key += ~(key << 13);
+  key ^= (key >> 8);
+  key += (key << 3);
+  key ^= (key >> 15);
+  key += ~(key << 27);
+  key ^= (key >> 31);
+  return (unsigned)key;
+}
+
+} // end namespace detail
+
 template<typename T>
 struct DenseMapInfo {
   //static inline T getEmptyKey();
@@ -33,18 +51,28 @@
   //static bool isEqual(const T &LHS, const T &RHS);
 };
 
-// Provide DenseMapInfo for all pointers.
+// Provide DenseMapInfo for all pointers. Come up with sentinel pointer values
+// that are aligned to alignof(T) bytes, but try to avoid requiring T to be
+// complete. This allows clients to instantiate DenseMap<T*, ...> with forward
+// declared key types. Assume that no pointer key type requires more than 4096
+// bytes of alignment.
 template<typename T>
 struct DenseMapInfo<T*> {
+  // The following should hold, but it would require T to be complete:
+  // static_assert(alignof(T) <= (1 << Log2MaxAlign),
+  //               "DenseMap does not support pointer keys requiring more than "
+  //               "Log2MaxAlign bits of alignment");
+  static constexpr uintptr_t Log2MaxAlign = 12;
+
   static inline T* getEmptyKey() {
     uintptr_t Val = static_cast<uintptr_t>(-1);
-    Val <<= PointerLikeTypeTraits<T*>::NumLowBitsAvailable;
+    Val <<= Log2MaxAlign;
     return reinterpret_cast<T*>(Val);
   }
 
   static inline T* getTombstoneKey() {
     uintptr_t Val = static_cast<uintptr_t>(-2);
-    Val <<= PointerLikeTypeTraits<T*>::NumLowBitsAvailable;
+    Val <<= Log2MaxAlign;
     return reinterpret_cast<T*>(Val);
   }
 
@@ -67,6 +95,17 @@
   }
 };
 
+// Provide DenseMapInfo for unsigned chars.
+template <> struct DenseMapInfo<unsigned char> {
+  static inline unsigned char getEmptyKey() { return ~0; }
+  static inline unsigned char getTombstoneKey() { return ~0 - 1; }
+  static unsigned getHashValue(const unsigned char &Val) { return Val * 37U; }
+
+  static bool isEqual(const unsigned char &LHS, const unsigned char &RHS) {
+    return LHS == RHS;
+  }
+};
+
 // Provide DenseMapInfo for unsigned shorts.
 template <> struct DenseMapInfo<unsigned short> {
   static inline unsigned short getEmptyKey() { return 0xFFFF; }
@@ -187,17 +226,8 @@
   }
 
   static unsigned getHashValue(const Pair& PairVal) {
-    uint64_t key = (uint64_t)FirstInfo::getHashValue(PairVal.first) << 32
-          | (uint64_t)SecondInfo::getHashValue(PairVal.second);
-    key += ~(key << 32);
-    key ^= (key >> 22);
-    key += ~(key << 13);
-    key ^= (key >> 8);
-    key += (key << 3);
-    key ^= (key >> 15);
-    key += ~(key << 27);
-    key ^= (key >> 31);
-    return (unsigned)key;
+    return detail::combineHashValue(FirstInfo::getHashValue(PairVal.first),
+                                    SecondInfo::getHashValue(PairVal.second));
   }
 
   static bool isEqual(const Pair &LHS, const Pair &RHS) {
@@ -206,6 +236,56 @@
   }
 };
 
+// Provide DenseMapInfo for all tuples whose members have info.
+template <typename... Ts> struct DenseMapInfo<std::tuple<Ts...>> {
+  using Tuple = std::tuple<Ts...>;
+
+  static inline Tuple getEmptyKey() {
+    return Tuple(DenseMapInfo<Ts>::getEmptyKey()...);
+  }
+
+  static inline Tuple getTombstoneKey() {
+    return Tuple(DenseMapInfo<Ts>::getTombstoneKey()...);
+  }
+
+  template <unsigned I>
+  static unsigned getHashValueImpl(const Tuple &values, std::false_type) {
+    using EltType = typename std::tuple_element<I, Tuple>::type;
+    std::integral_constant<bool, I + 1 == sizeof...(Ts)> atEnd;
+    return detail::combineHashValue(
+        DenseMapInfo<EltType>::getHashValue(std::get<I>(values)),
+        getHashValueImpl<I + 1>(values, atEnd));
+  }
+
+  template <unsigned I>
+  static unsigned getHashValueImpl(const Tuple &values, std::true_type) {
+    return 0;
+  }
+
+  static unsigned getHashValue(const std::tuple<Ts...> &values) {
+    std::integral_constant<bool, 0 == sizeof...(Ts)> atEnd;
+    return getHashValueImpl<0>(values, atEnd);
+  }
+
+  template <unsigned I>
+  static bool isEqualImpl(const Tuple &lhs, const Tuple &rhs, std::false_type) {
+    using EltType = typename std::tuple_element<I, Tuple>::type;
+    std::integral_constant<bool, I + 1 == sizeof...(Ts)> atEnd;
+    return DenseMapInfo<EltType>::isEqual(std::get<I>(lhs), std::get<I>(rhs)) &&
+           isEqualImpl<I + 1>(lhs, rhs, atEnd);
+  }
+
+  template <unsigned I>
+  static bool isEqualImpl(const Tuple &lhs, const Tuple &rhs, std::true_type) {
+    return true;
+  }
+
+  static bool isEqual(const Tuple &lhs, const Tuple &rhs) {
+    std::integral_constant<bool, 0 == sizeof...(Ts)> atEnd;
+    return isEqualImpl<0>(lhs, rhs, atEnd);
+  }
+};
+
 // Provide DenseMapInfo for StringRefs.
 template <> struct DenseMapInfo<StringRef> {
   static inline StringRef getEmptyKey() {
@@ -269,18 +349,46 @@
   static bool isEqual(hash_code LHS, hash_code RHS) { return LHS == RHS; }
 };
 
-template <> struct DenseMapInfo<ElementCount> {
-  static inline ElementCount getEmptyKey() { return {~0U, true}; }
-  static inline ElementCount getTombstoneKey() { return {~0U - 1, false}; }
-  static unsigned getHashValue(const ElementCount& EltCnt) {
-    if (EltCnt.Scalable)
-      return (EltCnt.Min * 37U) - 1U;
-
-    return EltCnt.Min * 37U;
+/// Provide DenseMapInfo for APInt.
+template <> struct DenseMapInfo<APInt> {
+  static inline APInt getEmptyKey() {
+    APInt V(nullptr, 0);
+    V.U.VAL = 0;
+    return V;
   }
 
-  static bool isEqual(const ElementCount& LHS, const ElementCount& RHS) {
-    return LHS == RHS;
+  static inline APInt getTombstoneKey() {
+    APInt V(nullptr, 0);
+    V.U.VAL = 1;
+    return V;
+  }
+
+  static unsigned getHashValue(const APInt &Key) {
+    return static_cast<unsigned>(hash_value(Key));
+  }
+
+  static bool isEqual(const APInt &LHS, const APInt &RHS) {
+    return LHS.getBitWidth() == RHS.getBitWidth() && LHS == RHS;
+  }
+};
+
+/// Provide DenseMapInfo for APSInt, using the DenseMapInfo for APInt.
+template <> struct DenseMapInfo<APSInt> {
+  static inline APSInt getEmptyKey() {
+    return APSInt(DenseMapInfo<APInt>::getEmptyKey());
+  }
+
+  static inline APSInt getTombstoneKey() {
+    return APSInt(DenseMapInfo<APInt>::getTombstoneKey());
+  }
+
+  static unsigned getHashValue(const APSInt &Key) {
+    return static_cast<unsigned>(hash_value(Key));
+  }
+
+  static bool isEqual(const APSInt &LHS, const APSInt &RHS) {
+    return LHS.getBitWidth() == RHS.getBitWidth() &&
+           LHS.isUnsigned() == RHS.isUnsigned() && LHS == RHS;
   }
 };
 
diff --git a/linux-x64/clang/include/llvm/ADT/DenseSet.h b/linux-x64/clang/include/llvm/ADT/DenseSet.h
index 9afb715..edce7c4 100644
--- a/linux-x64/clang/include/llvm/ADT/DenseSet.h
+++ b/linux-x64/clang/include/llvm/ADT/DenseSet.h
@@ -66,6 +66,12 @@
 
   explicit DenseSetImpl(unsigned InitialReserve = 0) : TheMap(InitialReserve) {}
 
+  template <typename InputIt>
+  DenseSetImpl(const InputIt &I, const InputIt &E)
+      : DenseSetImpl(PowerOf2Ceil(std::distance(I, E))) {
+    insert(I, E);
+  }
+
   DenseSetImpl(std::initializer_list<ValueT> Elems)
       : DenseSetImpl(PowerOf2Ceil(Elems.size())) {
     insert(Elems.begin(), Elems.end());
@@ -124,8 +130,12 @@
 
     Iterator& operator++() { ++I; return *this; }
     Iterator operator++(int) { auto T = *this; ++I; return T; }
-    bool operator==(const ConstIterator& X) const { return I == X.I; }
-    bool operator!=(const ConstIterator& X) const { return I != X.I; }
+    friend bool operator==(const Iterator &X, const Iterator &Y) {
+      return X.I == Y.I;
+    }
+    friend bool operator!=(const Iterator &X, const Iterator &Y) {
+      return X.I != Y.I;
+    }
   };
 
   class ConstIterator {
@@ -149,8 +159,12 @@
 
     ConstIterator& operator++() { ++I; return *this; }
     ConstIterator operator++(int) { auto T = *this; ++I; return T; }
-    bool operator==(const ConstIterator& X) const { return I == X.I; }
-    bool operator!=(const ConstIterator& X) const { return I != X.I; }
+    friend bool operator==(const ConstIterator &X, const ConstIterator &Y) {
+      return X.I == Y.I;
+    }
+    friend bool operator!=(const ConstIterator &X, const ConstIterator &Y) {
+      return X.I != Y.I;
+    }
   };
 
   using iterator = Iterator;
@@ -167,6 +181,11 @@
     return ConstIterator(TheMap.find(V));
   }
 
+  /// Check if the set contains the given element.
+  bool contains(const_arg_type_t<ValueT> V) const {
+    return TheMap.find(V) != TheMap.end();
+  }
+
   /// Alternative version of find() which allows a different, and possibly less
   /// expensive, key type.
   /// The DenseMapInfo is responsible for supplying methods
diff --git a/linux-x64/clang/include/llvm/ADT/DepthFirstIterator.h b/linux-x64/clang/include/llvm/ADT/DepthFirstIterator.h
index 11967f5..5bfea28 100644
--- a/linux-x64/clang/include/llvm/ADT/DepthFirstIterator.h
+++ b/linux-x64/clang/include/llvm/ADT/DepthFirstIterator.h
@@ -198,7 +198,7 @@
   // nodes that a depth first iteration did not find: ie unreachable nodes.
   //
   bool nodeVisited(NodeRef Node) const {
-    return this->Visited.count(Node) != 0;
+    return this->Visited.contains(Node);
   }
 
   /// getPathLength - Return the length of the path from the entry node to the
diff --git a/linux-x64/clang/include/llvm/ADT/DirectedGraph.h b/linux-x64/clang/include/llvm/ADT/DirectedGraph.h
new file mode 100644
index 0000000..e8bb9e6
--- /dev/null
+++ b/linux-x64/clang/include/llvm/ADT/DirectedGraph.h
@@ -0,0 +1,279 @@
+//===- llvm/ADT/DirectedGraph.h - Directed Graph ----------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the interface and a base class implementation for a
+// directed graph.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_ADT_DIRECTEDGRAPH_H
+#define LLVM_ADT_DIRECTEDGRAPH_H
+
+#include "llvm/ADT/GraphTraits.h"
+#include "llvm/ADT/SetVector.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/Support/Debug.h"
+#include "llvm/Support/raw_ostream.h"
+
+namespace llvm {
+
+/// Represent an edge in the directed graph.
+/// The edge contains the target node it connects to.
+template <class NodeType, class EdgeType> class DGEdge {
+public:
+  DGEdge() = delete;
+  /// Create an edge pointing to the given node \p N.
+  explicit DGEdge(NodeType &N) : TargetNode(N) {}
+  explicit DGEdge(const DGEdge<NodeType, EdgeType> &E)
+      : TargetNode(E.TargetNode) {}
+  DGEdge<NodeType, EdgeType> &operator=(const DGEdge<NodeType, EdgeType> &E) {
+    TargetNode = E.TargetNode;
+    return *this;
+  }
+
+  /// Static polymorphism: delegate implementation (via isEqualTo) to the
+  /// derived class.
+  bool operator==(const DGEdge &E) const {
+    return getDerived().isEqualTo(E.getDerived());
+  }
+  bool operator!=(const DGEdge &E) const { return !operator==(E); }
+
+  /// Retrieve the target node this edge connects to.
+  const NodeType &getTargetNode() const { return TargetNode; }
+  NodeType &getTargetNode() {
+    return const_cast<NodeType &>(
+        static_cast<const DGEdge<NodeType, EdgeType> &>(*this).getTargetNode());
+  }
+
+  /// Set the target node this edge connects to.
+  void setTargetNode(const NodeType &N) { TargetNode = N; }
+
+protected:
+  // As the default implementation use address comparison for equality.
+  bool isEqualTo(const EdgeType &E) const { return this == &E; }
+
+  // Cast the 'this' pointer to the derived type and return a reference.
+  EdgeType &getDerived() { return *static_cast<EdgeType *>(this); }
+  const EdgeType &getDerived() const {
+    return *static_cast<const EdgeType *>(this);
+  }
+
+  // The target node this edge connects to.
+  NodeType &TargetNode;
+};
+
+/// Represent a node in the directed graph.
+/// The node has a (possibly empty) list of outgoing edges.
+template <class NodeType, class EdgeType> class DGNode {
+public:
+  using EdgeListTy = SetVector<EdgeType *>;
+  using iterator = typename EdgeListTy::iterator;
+  using const_iterator = typename EdgeListTy::const_iterator;
+
+  /// Create a node with a single outgoing edge \p E.
+  explicit DGNode(EdgeType &E) : Edges() { Edges.insert(&E); }
+  DGNode() = default;
+
+  explicit DGNode(const DGNode<NodeType, EdgeType> &N) : Edges(N.Edges) {}
+  DGNode(DGNode<NodeType, EdgeType> &&N) : Edges(std::move(N.Edges)) {}
+
+  DGNode<NodeType, EdgeType> &operator=(const DGNode<NodeType, EdgeType> &N) {
+    Edges = N.Edges;
+    return *this;
+  }
+  DGNode<NodeType, EdgeType> &operator=(const DGNode<NodeType, EdgeType> &&N) {
+    Edges = std::move(N.Edges);
+    return *this;
+  }
+
+  /// Static polymorphism: delegate implementation (via isEqualTo) to the
+  /// derived class.
+  friend bool operator==(const NodeType &M, const NodeType &N) {
+    return M.isEqualTo(N);
+  }
+  friend bool operator!=(const NodeType &M, const NodeType &N) {
+    return !(M == N);
+  }
+
+  const_iterator begin() const { return Edges.begin(); }
+  const_iterator end() const { return Edges.end(); }
+  iterator begin() { return Edges.begin(); }
+  iterator end() { return Edges.end(); }
+  const EdgeType &front() const { return *Edges.front(); }
+  EdgeType &front() { return *Edges.front(); }
+  const EdgeType &back() const { return *Edges.back(); }
+  EdgeType &back() { return *Edges.back(); }
+
+  /// Collect in \p EL, all the edges from this node to \p N.
+  /// Return true if at least one edge was found, and false otherwise.
+  /// Note that this implementation allows more than one edge to connect
+  /// a given pair of nodes.
+  bool findEdgesTo(const NodeType &N, SmallVectorImpl<EdgeType *> &EL) const {
+    assert(EL.empty() && "Expected the list of edges to be empty.");
+    for (auto *E : Edges)
+      if (E->getTargetNode() == N)
+        EL.push_back(E);
+    return !EL.empty();
+  }
+
+  /// Add the given edge \p E to this node, if it doesn't exist already. Returns
+  /// true if the edge is added and false otherwise.
+  bool addEdge(EdgeType &E) { return Edges.insert(&E); }
+
+  /// Remove the given edge \p E from this node, if it exists.
+  void removeEdge(EdgeType &E) { Edges.remove(&E); }
+
+  /// Test whether there is an edge that goes from this node to \p N.
+  bool hasEdgeTo(const NodeType &N) const {
+    return (findEdgeTo(N) != Edges.end());
+  }
+
+  /// Retrieve the outgoing edges for the node.
+  const EdgeListTy &getEdges() const { return Edges; }
+  EdgeListTy &getEdges() {
+    return const_cast<EdgeListTy &>(
+        static_cast<const DGNode<NodeType, EdgeType> &>(*this).Edges);
+  }
+
+  /// Clear the outgoing edges.
+  void clear() { Edges.clear(); }
+
+protected:
+  // As the default implementation use address comparison for equality.
+  bool isEqualTo(const NodeType &N) const { return this == &N; }
+
+  // Cast the 'this' pointer to the derived type and return a reference.
+  NodeType &getDerived() { return *static_cast<NodeType *>(this); }
+  const NodeType &getDerived() const {
+    return *static_cast<const NodeType *>(this);
+  }
+
+  /// Find an edge to \p N. If more than one edge exists, this will return
+  /// the first one in the list of edges.
+  const_iterator findEdgeTo(const NodeType &N) const {
+    return llvm::find_if(
+        Edges, [&N](const EdgeType *E) { return E->getTargetNode() == N; });
+  }
+
+  // The list of outgoing edges.
+  EdgeListTy Edges;
+};
+
+/// Directed graph
+///
+/// The graph is represented by a table of nodes.
+/// Each node contains a (possibly empty) list of outgoing edges.
+/// Each edge contains the target node it connects to.
+template <class NodeType, class EdgeType> class DirectedGraph {
+protected:
+  using NodeListTy = SmallVector<NodeType *, 10>;
+  using EdgeListTy = SmallVector<EdgeType *, 10>;
+public:
+  using iterator = typename NodeListTy::iterator;
+  using const_iterator = typename NodeListTy::const_iterator;
+  using DGraphType = DirectedGraph<NodeType, EdgeType>;
+
+  DirectedGraph() = default;
+  explicit DirectedGraph(NodeType &N) : Nodes() { addNode(N); }
+  DirectedGraph(const DGraphType &G) : Nodes(G.Nodes) {}
+  DirectedGraph(DGraphType &&RHS) : Nodes(std::move(RHS.Nodes)) {}
+  DGraphType &operator=(const DGraphType &G) {
+    Nodes = G.Nodes;
+    return *this;
+  }
+  DGraphType &operator=(const DGraphType &&G) {
+    Nodes = std::move(G.Nodes);
+    return *this;
+  }
+
+  const_iterator begin() const { return Nodes.begin(); }
+  const_iterator end() const { return Nodes.end(); }
+  iterator begin() { return Nodes.begin(); }
+  iterator end() { return Nodes.end(); }
+  const NodeType &front() const { return *Nodes.front(); }
+  NodeType &front() { return *Nodes.front(); }
+  const NodeType &back() const { return *Nodes.back(); }
+  NodeType &back() { return *Nodes.back(); }
+
+  size_t size() const { return Nodes.size(); }
+
+  /// Find the given node \p N in the table.
+  const_iterator findNode(const NodeType &N) const {
+    return llvm::find_if(Nodes,
+                         [&N](const NodeType *Node) { return *Node == N; });
+  }
+  iterator findNode(const NodeType &N) {
+    return const_cast<iterator>(
+        static_cast<const DGraphType &>(*this).findNode(N));
+  }
+
+  /// Add the given node \p N to the graph if it is not already present.
+  bool addNode(NodeType &N) {
+    if (findNode(N) != Nodes.end())
+      return false;
+    Nodes.push_back(&N);
+    return true;
+  }
+
+  /// Collect in \p EL all edges that are coming into node \p N. Return true
+  /// if at least one edge was found, and false otherwise.
+  bool findIncomingEdgesToNode(const NodeType &N, SmallVectorImpl<EdgeType*> &EL) const {
+    assert(EL.empty() && "Expected the list of edges to be empty.");
+    EdgeListTy TempList;
+    for (auto *Node : Nodes) {
+      if (*Node == N)
+        continue;
+      Node->findEdgesTo(N, TempList);
+      llvm::append_range(EL, TempList);
+      TempList.clear();
+    }
+    return !EL.empty();
+  }
+
+  /// Remove the given node \p N from the graph. If the node has incoming or
+  /// outgoing edges, they are also removed. Return true if the node was found
+  /// and then removed, and false if the node was not found in the graph to
+  /// begin with.
+  bool removeNode(NodeType &N) {
+    iterator IT = findNode(N);
+    if (IT == Nodes.end())
+      return false;
+    // Remove incoming edges.
+    EdgeListTy EL;
+    for (auto *Node : Nodes) {
+      if (*Node == N)
+        continue;
+      Node->findEdgesTo(N, EL);
+      for (auto *E : EL)
+        Node->removeEdge(*E);
+      EL.clear();
+    }
+    N.clear();
+    Nodes.erase(IT);
+    return true;
+  }
+
+  /// Assuming nodes \p Src and \p Dst are already in the graph, connect node \p
+  /// Src to node \p Dst using the provided edge \p E. Return true if \p Src is
+  /// not already connected to \p Dst via \p E, and false otherwise.
+  bool connect(NodeType &Src, NodeType &Dst, EdgeType &E) {
+    assert(findNode(Src) != Nodes.end() && "Src node should be present.");
+    assert(findNode(Dst) != Nodes.end() && "Dst node should be present.");
+    assert((E.getTargetNode() == Dst) &&
+           "Target of the given edge does not match Dst.");
+    return Src.addEdge(E);
+  }
+
+protected:
+  // The list of nodes in the graph.
+  NodeListTy Nodes;
+};
+
+} // namespace llvm
+
+#endif // LLVM_ADT_DIRECTEDGRAPH_H
diff --git a/linux-x64/clang/include/llvm/ADT/EnumeratedArray.h b/linux-x64/clang/include/llvm/ADT/EnumeratedArray.h
new file mode 100644
index 0000000..a66ec9d
--- /dev/null
+++ b/linux-x64/clang/include/llvm/ADT/EnumeratedArray.h
@@ -0,0 +1,49 @@
+//===- llvm/ADT/EnumeratedArray.h - Enumerated Array-------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines an array type that can be indexed using scoped enum values.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_ADT_ENUMERATEDARRAY_H
+#define LLVM_ADT_ENUMERATEDARRAY_H
+
+#include <cassert>
+
+namespace llvm {
+
+template <typename ValueType, typename Enumeration,
+          Enumeration LargestEnum = Enumeration::Last, typename IndexType = int,
+          IndexType Size = 1 + static_cast<IndexType>(LargestEnum)>
+class EnumeratedArray {
+public:
+  EnumeratedArray() = default;
+  EnumeratedArray(ValueType V) {
+    for (IndexType IX = 0; IX < Size; ++IX) {
+      Underlying[IX] = V;
+    }
+  }
+  inline const ValueType &operator[](const Enumeration Index) const {
+    auto IX = static_cast<const IndexType>(Index);
+    assert(IX >= 0 && IX < Size && "Index is out of bounds.");
+    return Underlying[IX];
+  }
+  inline ValueType &operator[](const Enumeration Index) {
+    return const_cast<ValueType &>(
+        static_cast<const EnumeratedArray<ValueType, Enumeration, LargestEnum,
+                                          IndexType, Size> &>(*this)[Index]);
+  }
+  inline IndexType size() { return Size; }
+
+private:
+  ValueType Underlying[Size];
+};
+
+} // namespace llvm
+
+#endif // LLVM_ADT_ENUMERATEDARRAY_H
diff --git a/linux-x64/clang/include/llvm/ADT/FloatingPointMode.h b/linux-x64/clang/include/llvm/ADT/FloatingPointMode.h
new file mode 100644
index 0000000..6988309
--- /dev/null
+++ b/linux-x64/clang/include/llvm/ADT/FloatingPointMode.h
@@ -0,0 +1,195 @@
+//===- llvm/Support/FloatingPointMode.h -------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Utilities for dealing with flags related to floating point mode controls.
+//
+//===----------------------------------------------------------------------===/
+
+#ifndef LLVM_FLOATINGPOINTMODE_H
+#define LLVM_FLOATINGPOINTMODE_H
+
+#include "llvm/ADT/StringSwitch.h"
+#include "llvm/Support/raw_ostream.h"
+
+namespace llvm {
+
+/// Rounding mode.
+///
+/// Enumerates supported rounding modes, as well as some special values. The set
+/// of the modes must agree with IEEE-754, 4.3.1 and 4.3.2. The constants
+/// assigned to the IEEE rounding modes must agree with the values used by
+/// FLT_ROUNDS (C11, 5.2.4.2.2p8).
+///
+/// This value is packed into bitfield in some cases, including \c FPOptions, so
+/// the rounding mode values and the special value \c Dynamic must fit into the
+/// the bit field (now - 3 bits). The value \c Invalid is used only in values
+/// returned by intrinsics to indicate errors, it should never be stored as
+/// rounding mode value, so it does not need to fit the bit fields.
+///
+enum class RoundingMode : int8_t {
+  // Rounding mode defined in IEEE-754.
+  TowardZero        = 0,    ///< roundTowardZero.
+  NearestTiesToEven = 1,    ///< roundTiesToEven.
+  TowardPositive    = 2,    ///< roundTowardPositive.
+  TowardNegative    = 3,    ///< roundTowardNegative.
+  NearestTiesToAway = 4,    ///< roundTiesToAway.
+
+  // Special values.
+  Dynamic = 7,    ///< Denotes mode unknown at compile time.
+  Invalid = -1    ///< Denotes invalid value.
+};
+
+/// Returns text representation of the given rounding mode.
+inline StringRef spell(RoundingMode RM) {
+  switch (RM) {
+  case RoundingMode::TowardZero: return "towardzero";
+  case RoundingMode::NearestTiesToEven: return "tonearest";
+  case RoundingMode::TowardPositive: return "upward";
+  case RoundingMode::TowardNegative: return "downward";
+  case RoundingMode::NearestTiesToAway: return "tonearestaway";
+  case RoundingMode::Dynamic: return "dynamic";
+  default: return "invalid";
+  }
+}
+
+inline raw_ostream &operator << (raw_ostream &OS, RoundingMode RM) {
+  OS << spell(RM);
+  return OS;
+}
+
+/// Represent subnormal handling kind for floating point instruction inputs and
+/// outputs.
+struct DenormalMode {
+  /// Represent handled modes for denormal (aka subnormal) modes in the floating
+  /// point environment.
+  enum DenormalModeKind : int8_t {
+    Invalid = -1,
+
+    /// IEEE-754 denormal numbers preserved.
+    IEEE,
+
+    /// The sign of a flushed-to-zero number is preserved in the sign of 0
+    PreserveSign,
+
+    /// Denormals are flushed to positive zero.
+    PositiveZero
+  };
+
+  /// Denormal flushing mode for floating point instruction results in the
+  /// default floating point environment.
+  DenormalModeKind Output = DenormalModeKind::Invalid;
+
+  /// Denormal treatment kind for floating point instruction inputs in the
+  /// default floating-point environment. If this is not DenormalModeKind::IEEE,
+  /// floating-point instructions implicitly treat the input value as 0.
+  DenormalModeKind Input = DenormalModeKind::Invalid;
+
+  constexpr DenormalMode() = default;
+  constexpr DenormalMode(DenormalModeKind Out, DenormalModeKind In) :
+    Output(Out), Input(In) {}
+
+
+  static constexpr DenormalMode getInvalid() {
+    return DenormalMode(DenormalModeKind::Invalid, DenormalModeKind::Invalid);
+  }
+
+  static constexpr DenormalMode getIEEE() {
+    return DenormalMode(DenormalModeKind::IEEE, DenormalModeKind::IEEE);
+  }
+
+  static constexpr DenormalMode getPreserveSign() {
+    return DenormalMode(DenormalModeKind::PreserveSign,
+                        DenormalModeKind::PreserveSign);
+  }
+
+  static constexpr DenormalMode getPositiveZero() {
+    return DenormalMode(DenormalModeKind::PositiveZero,
+                        DenormalModeKind::PositiveZero);
+  }
+
+  bool operator==(DenormalMode Other) const {
+    return Output == Other.Output && Input == Other.Input;
+  }
+
+  bool operator!=(DenormalMode Other) const {
+    return !(*this == Other);
+  }
+
+  bool isSimple() const {
+    return Input == Output;
+  }
+
+  bool isValid() const {
+    return Output != DenormalModeKind::Invalid &&
+           Input != DenormalModeKind::Invalid;
+  }
+
+  inline void print(raw_ostream &OS) const;
+
+  inline std::string str() const {
+    std::string storage;
+    raw_string_ostream OS(storage);
+    print(OS);
+    return OS.str();
+  }
+};
+
+inline raw_ostream& operator<<(raw_ostream &OS, DenormalMode Mode) {
+  Mode.print(OS);
+  return OS;
+}
+
+/// Parse the expected names from the denormal-fp-math attribute.
+inline DenormalMode::DenormalModeKind
+parseDenormalFPAttributeComponent(StringRef Str) {
+  // Assume ieee on unspecified attribute.
+  return StringSwitch<DenormalMode::DenormalModeKind>(Str)
+    .Cases("", "ieee", DenormalMode::IEEE)
+    .Case("preserve-sign", DenormalMode::PreserveSign)
+    .Case("positive-zero", DenormalMode::PositiveZero)
+    .Default(DenormalMode::Invalid);
+}
+
+/// Return the name used for the denormal handling mode used by the the
+/// expected names from the denormal-fp-math attribute.
+inline StringRef denormalModeKindName(DenormalMode::DenormalModeKind Mode) {
+  switch (Mode) {
+  case DenormalMode::IEEE:
+    return "ieee";
+  case DenormalMode::PreserveSign:
+    return "preserve-sign";
+  case DenormalMode::PositiveZero:
+    return "positive-zero";
+  default:
+    return "";
+  }
+}
+
+/// Returns the denormal mode to use for inputs and outputs.
+inline DenormalMode parseDenormalFPAttribute(StringRef Str) {
+  StringRef OutputStr, InputStr;
+  std::tie(OutputStr, InputStr) = Str.split(',');
+
+  DenormalMode Mode;
+  Mode.Output = parseDenormalFPAttributeComponent(OutputStr);
+
+  // Maintain compatability with old form of the attribute which only specified
+  // one component.
+  Mode.Input = InputStr.empty() ? Mode.Output  :
+               parseDenormalFPAttributeComponent(InputStr);
+
+  return Mode;
+}
+
+void DenormalMode::print(raw_ostream &OS) const {
+  OS << denormalModeKindName(Output) << ',' << denormalModeKindName(Input);
+}
+
+}
+
+#endif // LLVM_FLOATINGPOINTMODE_H
diff --git a/linux-x64/clang/include/llvm/ADT/FoldingSet.h b/linux-x64/clang/include/llvm/ADT/FoldingSet.h
index d5837e5..fb1cb03 100644
--- a/linux-x64/clang/include/llvm/ADT/FoldingSet.h
+++ b/linux-x64/clang/include/llvm/ADT/FoldingSet.h
@@ -85,17 +85,17 @@
 ///
 ///    MyNode *M = MyFoldingSet.FindNodeOrInsertPos(ID, InsertPoint);
 ///
-/// If found then M with be non-NULL, else InsertPoint will point to where it
+/// If found then M will be non-NULL, else InsertPoint will point to where it
 /// should be inserted using InsertNode.
 ///
-/// 3) If you get a NULL result from FindNodeOrInsertPos then you can as a new
-/// node with FindNodeOrInsertPos;
+/// 3) If you get a NULL result from FindNodeOrInsertPos then you can insert a
+/// new node with InsertNode;
 ///
-///    InsertNode(N, InsertPoint);
+///    MyFoldingSet.InsertNode(M, InsertPoint);
 ///
 /// 4) Finally, if you want to remove a node from the folding set call;
 ///
-///    bool WasRemoved = RemoveNode(N);
+///    bool WasRemoved = MyFoldingSet.RemoveNode(M);
 ///
 /// The result indicates whether the node existed in the folding set.
 
@@ -110,8 +110,6 @@
 /// back to the bucket to facilitate node removal.
 ///
 class FoldingSetBase {
-  virtual void anchor(); // Out of line virtual method.
-
 protected:
   /// Buckets - Array of bucket chains.
   void **Buckets;
@@ -154,11 +152,6 @@
   /// empty - Returns true if there are no nodes in the folding set.
   bool empty() const { return NumNodes == 0; }
 
-  /// reserve - Increase the number of buckets such that adding the
-  /// EltCount-th node won't cause a rebucket operation. reserve is permitted
-  /// to allocate more space than requested by EltCount.
-  void reserve(unsigned EltCount);
-
   /// capacity - Returns the number of nodes permitted in the folding set
   /// before a rebucket operation is performed.
   unsigned capacity() {
@@ -167,32 +160,46 @@
     return NumBuckets * 2;
   }
 
+protected:
+  /// Functions provided by the derived class to compute folding properties.
+  /// This is effectively a vtable for FoldingSetBase, except that we don't
+  /// actually store a pointer to it in the object.
+  struct FoldingSetInfo {
+    /// GetNodeProfile - Instantiations of the FoldingSet template implement
+    /// this function to gather data bits for the given node.
+    void (*GetNodeProfile)(const FoldingSetBase *Self, Node *N,
+                           FoldingSetNodeID &ID);
+
+    /// NodeEquals - Instantiations of the FoldingSet template implement
+    /// this function to compare the given node with the given ID.
+    bool (*NodeEquals)(const FoldingSetBase *Self, Node *N,
+                       const FoldingSetNodeID &ID, unsigned IDHash,
+                       FoldingSetNodeID &TempID);
+
+    /// ComputeNodeHash - Instantiations of the FoldingSet template implement
+    /// this function to compute a hash value for the given node.
+    unsigned (*ComputeNodeHash)(const FoldingSetBase *Self, Node *N,
+                                FoldingSetNodeID &TempID);
+  };
+
 private:
   /// GrowHashTable - Double the size of the hash table and rehash everything.
-  void GrowHashTable();
+  void GrowHashTable(const FoldingSetInfo &Info);
 
   /// GrowBucketCount - resize the hash table and rehash everything.
   /// NewBucketCount must be a power of two, and must be greater than the old
   /// bucket count.
-  void GrowBucketCount(unsigned NewBucketCount);
+  void GrowBucketCount(unsigned NewBucketCount, const FoldingSetInfo &Info);
 
 protected:
-  /// GetNodeProfile - Instantiations of the FoldingSet template implement
-  /// this function to gather data bits for the given node.
-  virtual void GetNodeProfile(Node *N, FoldingSetNodeID &ID) const = 0;
-
-  /// NodeEquals - Instantiations of the FoldingSet template implement
-  /// this function to compare the given node with the given ID.
-  virtual bool NodeEquals(Node *N, const FoldingSetNodeID &ID, unsigned IDHash,
-                          FoldingSetNodeID &TempID) const=0;
-
-  /// ComputeNodeHash - Instantiations of the FoldingSet template implement
-  /// this function to compute a hash value for the given node.
-  virtual unsigned ComputeNodeHash(Node *N, FoldingSetNodeID &TempID) const = 0;
-
   // The below methods are protected to encourage subclasses to provide a more
   // type-safe API.
 
+  /// reserve - Increase the number of buckets such that adding the
+  /// EltCount-th node won't cause a rebucket operation. reserve is permitted
+  /// to allocate more space than requested by EltCount.
+  void reserve(unsigned EltCount, const FoldingSetInfo &Info);
+
   /// RemoveNode - Remove a node from the folding set, returning true if one
   /// was removed or false if the node was not in the folding set.
   bool RemoveNode(Node *N);
@@ -200,17 +207,18 @@
   /// GetOrInsertNode - If there is an existing simple Node exactly
   /// equal to the specified node, return it.  Otherwise, insert 'N' and return
   /// it instead.
-  Node *GetOrInsertNode(Node *N);
+  Node *GetOrInsertNode(Node *N, const FoldingSetInfo &Info);
 
   /// FindNodeOrInsertPos - Look up the node specified by ID.  If it exists,
   /// return it.  If not, return the insertion token that will make insertion
   /// faster.
-  Node *FindNodeOrInsertPos(const FoldingSetNodeID &ID, void *&InsertPos);
+  Node *FindNodeOrInsertPos(const FoldingSetNodeID &ID, void *&InsertPos,
+                            const FoldingSetInfo &Info);
 
   /// InsertNode - Insert the specified node into the folding set, knowing that
   /// it is not already in the folding set.  InsertPos must be obtained from
   /// FindNodeOrInsertPos.
-  void InsertNode(Node *N, void *InsertPos);
+  void InsertNode(Node *N, void *InsertPos, const FoldingSetInfo &Info);
 };
 
 //===----------------------------------------------------------------------===//
@@ -397,7 +405,7 @@
 //===----------------------------------------------------------------------===//
 /// FoldingSetImpl - An implementation detail that lets us share code between
 /// FoldingSet and ContextualFoldingSet.
-template <class T> class FoldingSetImpl : public FoldingSetBase {
+template <class Derived, class T> class FoldingSetImpl : public FoldingSetBase {
 protected:
   explicit FoldingSetImpl(unsigned Log2InitSize)
       : FoldingSetBase(Log2InitSize) {}
@@ -427,29 +435,40 @@
     return bucket_iterator(Buckets + (hash & (NumBuckets-1)), true);
   }
 
+  /// reserve - Increase the number of buckets such that adding the
+  /// EltCount-th node won't cause a rebucket operation. reserve is permitted
+  /// to allocate more space than requested by EltCount.
+  void reserve(unsigned EltCount) {
+    return FoldingSetBase::reserve(EltCount, Derived::getFoldingSetInfo());
+  }
+
   /// RemoveNode - Remove a node from the folding set, returning true if one
   /// was removed or false if the node was not in the folding set.
-  bool RemoveNode(T *N) { return FoldingSetBase::RemoveNode(N); }
+  bool RemoveNode(T *N) {
+    return FoldingSetBase::RemoveNode(N);
+  }
 
   /// GetOrInsertNode - If there is an existing simple Node exactly
   /// equal to the specified node, return it.  Otherwise, insert 'N' and
   /// return it instead.
   T *GetOrInsertNode(T *N) {
-    return static_cast<T *>(FoldingSetBase::GetOrInsertNode(N));
+    return static_cast<T *>(
+        FoldingSetBase::GetOrInsertNode(N, Derived::getFoldingSetInfo()));
   }
 
   /// FindNodeOrInsertPos - Look up the node specified by ID.  If it exists,
   /// return it.  If not, return the insertion token that will make insertion
   /// faster.
   T *FindNodeOrInsertPos(const FoldingSetNodeID &ID, void *&InsertPos) {
-    return static_cast<T *>(FoldingSetBase::FindNodeOrInsertPos(ID, InsertPos));
+    return static_cast<T *>(FoldingSetBase::FindNodeOrInsertPos(
+        ID, InsertPos, Derived::getFoldingSetInfo()));
   }
 
   /// InsertNode - Insert the specified node into the folding set, knowing that
   /// it is not already in the folding set.  InsertPos must be obtained from
   /// FindNodeOrInsertPos.
   void InsertNode(T *N, void *InsertPos) {
-    FoldingSetBase::InsertNode(N, InsertPos);
+    FoldingSetBase::InsertNode(N, InsertPos, Derived::getFoldingSetInfo());
   }
 
   /// InsertNode - Insert the specified node into the folding set, knowing that
@@ -470,32 +489,43 @@
 /// moved-from state is not a valid state for anything other than
 /// move-assigning and destroying. This is primarily to enable movable APIs
 /// that incorporate these objects.
-template <class T> class FoldingSet final : public FoldingSetImpl<T> {
-  using Super = FoldingSetImpl<T>;
+template <class T>
+class FoldingSet : public FoldingSetImpl<FoldingSet<T>, T> {
+  using Super = FoldingSetImpl<FoldingSet, T>;
   using Node = typename Super::Node;
 
-  /// GetNodeProfile - Each instantiatation of the FoldingSet needs to provide a
+  /// GetNodeProfile - Each instantiation of the FoldingSet needs to provide a
   /// way to convert nodes into a unique specifier.
-  void GetNodeProfile(Node *N, FoldingSetNodeID &ID) const override {
+  static void GetNodeProfile(const FoldingSetBase *, Node *N,
+                             FoldingSetNodeID &ID) {
     T *TN = static_cast<T *>(N);
     FoldingSetTrait<T>::Profile(*TN, ID);
   }
 
   /// NodeEquals - Instantiations may optionally provide a way to compare a
   /// node with a specified ID.
-  bool NodeEquals(Node *N, const FoldingSetNodeID &ID, unsigned IDHash,
-                  FoldingSetNodeID &TempID) const override {
+  static bool NodeEquals(const FoldingSetBase *, Node *N,
+                         const FoldingSetNodeID &ID, unsigned IDHash,
+                         FoldingSetNodeID &TempID) {
     T *TN = static_cast<T *>(N);
     return FoldingSetTrait<T>::Equals(*TN, ID, IDHash, TempID);
   }
 
   /// ComputeNodeHash - Instantiations may optionally provide a way to compute a
   /// hash value directly from a node.
-  unsigned ComputeNodeHash(Node *N, FoldingSetNodeID &TempID) const override {
+  static unsigned ComputeNodeHash(const FoldingSetBase *, Node *N,
+                                  FoldingSetNodeID &TempID) {
     T *TN = static_cast<T *>(N);
     return FoldingSetTrait<T>::ComputeHash(*TN, TempID);
   }
 
+  static const FoldingSetBase::FoldingSetInfo &getFoldingSetInfo() {
+    static constexpr FoldingSetBase::FoldingSetInfo Info = {
+        GetNodeProfile, NodeEquals, ComputeNodeHash};
+    return Info;
+  }
+  friend Super;
+
 public:
   explicit FoldingSet(unsigned Log2InitSize = 6) : Super(Log2InitSize) {}
   FoldingSet(FoldingSet &&Arg) = default;
@@ -512,36 +542,52 @@
 /// function with signature
 ///   void Profile(FoldingSetNodeID &, Ctx);
 template <class T, class Ctx>
-class ContextualFoldingSet final : public FoldingSetImpl<T> {
+class ContextualFoldingSet
+    : public FoldingSetImpl<ContextualFoldingSet<T, Ctx>, T> {
   // Unfortunately, this can't derive from FoldingSet<T> because the
   // construction of the vtable for FoldingSet<T> requires
   // FoldingSet<T>::GetNodeProfile to be instantiated, which in turn
   // requires a single-argument T::Profile().
 
-  using Super = FoldingSetImpl<T>;
+  using Super = FoldingSetImpl<ContextualFoldingSet, T>;
   using Node = typename Super::Node;
 
   Ctx Context;
 
+  static const Ctx &getContext(const FoldingSetBase *Base) {
+    return static_cast<const ContextualFoldingSet*>(Base)->Context;
+  }
+
   /// GetNodeProfile - Each instantiatation of the FoldingSet needs to provide a
   /// way to convert nodes into a unique specifier.
-  void GetNodeProfile(Node *N, FoldingSetNodeID &ID) const override {
+  static void GetNodeProfile(const FoldingSetBase *Base, Node *N,
+                             FoldingSetNodeID &ID) {
     T *TN = static_cast<T *>(N);
-    ContextualFoldingSetTrait<T, Ctx>::Profile(*TN, ID, Context);
+    ContextualFoldingSetTrait<T, Ctx>::Profile(*TN, ID, getContext(Base));
   }
 
-  bool NodeEquals(Node *N, const FoldingSetNodeID &ID, unsigned IDHash,
-                  FoldingSetNodeID &TempID) const override {
+  static bool NodeEquals(const FoldingSetBase *Base, Node *N,
+                         const FoldingSetNodeID &ID, unsigned IDHash,
+                         FoldingSetNodeID &TempID) {
     T *TN = static_cast<T *>(N);
     return ContextualFoldingSetTrait<T, Ctx>::Equals(*TN, ID, IDHash, TempID,
-                                                     Context);
+                                                     getContext(Base));
   }
 
-  unsigned ComputeNodeHash(Node *N, FoldingSetNodeID &TempID) const override {
+  static unsigned ComputeNodeHash(const FoldingSetBase *Base, Node *N,
+                                  FoldingSetNodeID &TempID) {
     T *TN = static_cast<T *>(N);
-    return ContextualFoldingSetTrait<T, Ctx>::ComputeHash(*TN, TempID, Context);
+    return ContextualFoldingSetTrait<T, Ctx>::ComputeHash(*TN, TempID,
+                                                          getContext(Base));
   }
 
+  static const FoldingSetBase::FoldingSetInfo &getFoldingSetInfo() {
+    static constexpr FoldingSetBase::FoldingSetInfo Info = {
+        GetNodeProfile, NodeEquals, ComputeNodeHash};
+    return Info;
+  }
+  friend Super;
+
 public:
   explicit ContextualFoldingSet(Ctx Context, unsigned Log2InitSize = 6)
       : Super(Log2InitSize), Context(Context) {}
diff --git a/linux-x64/clang/include/llvm/ADT/FunctionExtras.h b/linux-x64/clang/include/llvm/ADT/FunctionExtras.h
index 121aa52..7f8fb10 100644
--- a/linux-x64/clang/include/llvm/ADT/FunctionExtras.h
+++ b/linux-x64/clang/include/llvm/ADT/FunctionExtras.h
@@ -11,11 +11,11 @@
 /// in `<function>`.
 ///
 /// It provides `unique_function`, which works like `std::function` but supports
-/// move-only callable objects.
+/// move-only callable objects and const-qualification.
 ///
 /// Future plans:
-/// - Add a `function` that provides const, volatile, and ref-qualified support,
-///   which doesn't work with `std::function`.
+/// - Add a `function` that provides ref-qualified support, which doesn't work
+///   with `std::function`.
 /// - Provide support for specifying multiple signatures to type erase callable
 ///   objects with an overload set, such as those produced by generic lambdas.
 /// - Expand to include a copyable utility that directly replaces std::function
@@ -34,23 +34,42 @@
 
 #include "llvm/ADT/PointerIntPair.h"
 #include "llvm/ADT/PointerUnion.h"
+#include "llvm/Support/MemAlloc.h"
 #include "llvm/Support/type_traits.h"
 #include <memory>
+#include <type_traits>
 
 namespace llvm {
 
+/// unique_function is a type-erasing functor similar to std::function.
+///
+/// It can hold move-only function objects, like lambdas capturing unique_ptrs.
+/// Accordingly, it is movable but not copyable.
+///
+/// It supports const-qualification:
+/// - unique_function<int() const> has a const operator().
+///   It can only hold functions which themselves have a const operator().
+/// - unique_function<int()> has a non-const operator().
+///   It can hold functions with a non-const operator(), like mutable lambdas.
 template <typename FunctionT> class unique_function;
 
-template <typename ReturnT, typename... ParamTs>
-class unique_function<ReturnT(ParamTs...)> {
+namespace detail {
+
+template <typename T>
+using EnableIfTrivial =
+    std::enable_if_t<llvm::is_trivially_move_constructible<T>::value &&
+                     std::is_trivially_destructible<T>::value>;
+
+template <typename ReturnT, typename... ParamTs> class UniqueFunctionBase {
+protected:
   static constexpr size_t InlineStorageSize = sizeof(void *) * 3;
 
-  // MSVC has a bug and ICEs if we give it a particular dependent value
-  // expression as part of the `std::conditional` below. To work around this,
-  // we build that into a template struct's constexpr bool.
-  template <typename T> struct IsSizeLessThanThresholdT {
-    static constexpr bool value = sizeof(T) <= (2 * sizeof(void *));
-  };
+  template <typename T, class = void>
+  struct IsSizeLessThanThresholdT : std::false_type {};
+
+  template <typename T>
+  struct IsSizeLessThanThresholdT<
+      T, std::enable_if_t<sizeof(T) <= 2 * sizeof(void *)>> : std::true_type {};
 
   // Provide a type function to map parameters that won't observe extra copies
   // or moves and which are small enough to likely pass in register to values
@@ -112,8 +131,11 @@
 
     // For in-line storage, we just provide an aligned character buffer. We
     // provide three pointers worth of storage here.
-    typename std::aligned_storage<InlineStorageSize, alignof(void *)>::type
-        InlineStorage;
+    // This is mutable as an inlined `const unique_function<void() const>` may
+    // still modify its own mutable members.
+    mutable
+        typename std::aligned_storage<InlineStorageSize, alignof(void *)>::type
+            InlineStorage;
   } StorageUnion;
 
   // A compressed pointer to either our dispatching callback or our table of
@@ -136,11 +158,25 @@
         .template get<NonTrivialCallbacks *>();
   }
 
-  void *getInlineStorage() { return &StorageUnion.InlineStorage; }
+  CallPtrT getCallPtr() const {
+    return isTrivialCallback() ? getTrivialCallback()
+                               : getNonTrivialCallbacks()->CallPtr;
+  }
 
-  void *getOutOfLineStorage() {
+  // These three functions are only const in the narrow sense. They return
+  // mutable pointers to function state.
+  // This allows unique_function<T const>::operator() to be const, even if the
+  // underlying functor may be internally mutable.
+  //
+  // const callers must ensure they're only used in const-correct ways.
+  void *getCalleePtr() const {
+    return isInlineStorage() ? getInlineStorage() : getOutOfLineStorage();
+  }
+  void *getInlineStorage() const { return &StorageUnion.InlineStorage; }
+  void *getOutOfLineStorage() const {
     return StorageUnion.OutOfLineStorage.StoragePtr;
   }
+
   size_t getOutOfLineStorageSize() const {
     return StorageUnion.OutOfLineStorage.Size;
   }
@@ -152,10 +188,11 @@
     StorageUnion.OutOfLineStorage = {Ptr, Size, Alignment};
   }
 
-  template <typename CallableT>
-  static ReturnT CallImpl(void *CallableAddr, AdjustedParamT<ParamTs>... Params) {
-    return (*reinterpret_cast<CallableT *>(CallableAddr))(
-        std::forward<ParamTs>(Params)...);
+  template <typename CalledAsT>
+  static ReturnT CallImpl(void *CallableAddr,
+                          AdjustedParamT<ParamTs>... Params) {
+    auto &Func = *reinterpret_cast<CalledAsT *>(CallableAddr);
+    return Func(std::forward<ParamTs>(Params)...);
   }
 
   template <typename CallableT>
@@ -169,11 +206,54 @@
     reinterpret_cast<CallableT *>(CallableAddr)->~CallableT();
   }
 
-public:
-  unique_function() = default;
-  unique_function(std::nullptr_t /*null_callable*/) {}
+  // The pointers to call/move/destroy functions are determined for each
+  // callable type (and called-as type, which determines the overload chosen).
+  // (definitions are out-of-line).
 
-  ~unique_function() {
+  // By default, we need an object that contains all the different
+  // type erased behaviors needed. Create a static instance of the struct type
+  // here and each instance will contain a pointer to it.
+  // Wrap in a struct to avoid https://gcc.gnu.org/PR71954
+  template <typename CallableT, typename CalledAs, typename Enable = void>
+  struct CallbacksHolder {
+    static NonTrivialCallbacks Callbacks;
+  };
+  // See if we can create a trivial callback. We need the callable to be
+  // trivially moved and trivially destroyed so that we don't have to store
+  // type erased callbacks for those operations.
+  template <typename CallableT, typename CalledAs>
+  struct CallbacksHolder<CallableT, CalledAs, EnableIfTrivial<CallableT>> {
+    static TrivialCallback Callbacks;
+  };
+
+  // A simple tag type so the call-as type to be passed to the constructor.
+  template <typename T> struct CalledAs {};
+
+  // Essentially the "main" unique_function constructor, but subclasses
+  // provide the qualified type to be used for the call.
+  // (We always store a T, even if the call will use a pointer to const T).
+  template <typename CallableT, typename CalledAsT>
+  UniqueFunctionBase(CallableT Callable, CalledAs<CalledAsT>) {
+    bool IsInlineStorage = true;
+    void *CallableAddr = getInlineStorage();
+    if (sizeof(CallableT) > InlineStorageSize ||
+        alignof(CallableT) > alignof(decltype(StorageUnion.InlineStorage))) {
+      IsInlineStorage = false;
+      // Allocate out-of-line storage. FIXME: Use an explicit alignment
+      // parameter in C++17 mode.
+      auto Size = sizeof(CallableT);
+      auto Alignment = alignof(CallableT);
+      CallableAddr = allocate_buffer(Size, Alignment);
+      setOutOfLineStorage(CallableAddr, Size, Alignment);
+    }
+
+    // Now move into the storage.
+    new (CallableAddr) CallableT(std::move(Callable));
+    CallbackAndInlineFlag.setPointerAndInt(
+        &CallbacksHolder<CallableT, CalledAsT>::Callbacks, IsInlineStorage);
+  }
+
+  ~UniqueFunctionBase() {
     if (!CallbackAndInlineFlag.getPointer())
       return;
 
@@ -189,7 +269,7 @@
                         getOutOfLineStorageAlignment());
   }
 
-  unique_function(unique_function &&RHS) noexcept {
+  UniqueFunctionBase(UniqueFunctionBase &&RHS) noexcept {
     // Copy the callback and inline flag.
     CallbackAndInlineFlag = RHS.CallbackAndInlineFlag;
 
@@ -218,75 +298,86 @@
 #endif
   }
 
-  unique_function &operator=(unique_function &&RHS) noexcept {
+  UniqueFunctionBase &operator=(UniqueFunctionBase &&RHS) noexcept {
     if (this == &RHS)
       return *this;
 
     // Because we don't try to provide any exception safety guarantees we can
     // implement move assignment very simply by first destroying the current
     // object and then move-constructing over top of it.
-    this->~unique_function();
-    new (this) unique_function(std::move(RHS));
+    this->~UniqueFunctionBase();
+    new (this) UniqueFunctionBase(std::move(RHS));
     return *this;
   }
 
-  template <typename CallableT> unique_function(CallableT Callable) {
-    bool IsInlineStorage = true;
-    void *CallableAddr = getInlineStorage();
-    if (sizeof(CallableT) > InlineStorageSize ||
-        alignof(CallableT) > alignof(decltype(StorageUnion.InlineStorage))) {
-      IsInlineStorage = false;
-      // Allocate out-of-line storage. FIXME: Use an explicit alignment
-      // parameter in C++17 mode.
-      auto Size = sizeof(CallableT);
-      auto Alignment = alignof(CallableT);
-      CallableAddr = allocate_buffer(Size, Alignment);
-      setOutOfLineStorage(CallableAddr, Size, Alignment);
-    }
+  UniqueFunctionBase() = default;
 
-    // Now move into the storage.
-    new (CallableAddr) CallableT(std::move(Callable));
-
-    // See if we can create a trivial callback. We need the callable to be
-    // trivially moved and trivially destroyed so that we don't have to store
-    // type erased callbacks for those operations.
-    //
-    // FIXME: We should use constexpr if here and below to avoid instantiating
-    // the non-trivial static objects when unnecessary. While the linker should
-    // remove them, it is still wasteful.
-    if (llvm::is_trivially_move_constructible<CallableT>::value &&
-        std::is_trivially_destructible<CallableT>::value) {
-      // We need to create a nicely aligned object. We use a static variable
-      // for this because it is a trivial struct.
-      static TrivialCallback Callback = { &CallImpl<CallableT> };
-
-      CallbackAndInlineFlag = {&Callback, IsInlineStorage};
-      return;
-    }
-
-    // Otherwise, we need to point at an object that contains all the different
-    // type erased behaviors needed. Create a static instance of the struct type
-    // here and then use a pointer to that.
-    static NonTrivialCallbacks Callbacks = {
-        &CallImpl<CallableT>, &MoveImpl<CallableT>, &DestroyImpl<CallableT>};
-
-    CallbackAndInlineFlag = {&Callbacks, IsInlineStorage};
-  }
-
-  ReturnT operator()(ParamTs... Params) {
-    void *CallableAddr =
-        isInlineStorage() ? getInlineStorage() : getOutOfLineStorage();
-
-    return (isTrivialCallback()
-                ? getTrivialCallback()
-                : getNonTrivialCallbacks()->CallPtr)(CallableAddr, Params...);
-  }
-
+public:
   explicit operator bool() const {
     return (bool)CallbackAndInlineFlag.getPointer();
   }
 };
 
+template <typename R, typename... P>
+template <typename CallableT, typename CalledAsT, typename Enable>
+typename UniqueFunctionBase<R, P...>::NonTrivialCallbacks UniqueFunctionBase<
+    R, P...>::CallbacksHolder<CallableT, CalledAsT, Enable>::Callbacks = {
+    &CallImpl<CalledAsT>, &MoveImpl<CallableT>, &DestroyImpl<CallableT>};
+
+template <typename R, typename... P>
+template <typename CallableT, typename CalledAsT>
+typename UniqueFunctionBase<R, P...>::TrivialCallback
+    UniqueFunctionBase<R, P...>::CallbacksHolder<
+        CallableT, CalledAsT, EnableIfTrivial<CallableT>>::Callbacks{
+        &CallImpl<CalledAsT>};
+
+} // namespace detail
+
+template <typename R, typename... P>
+class unique_function<R(P...)> : public detail::UniqueFunctionBase<R, P...> {
+  using Base = detail::UniqueFunctionBase<R, P...>;
+
+public:
+  unique_function() = default;
+  unique_function(std::nullptr_t) {}
+  unique_function(unique_function &&) = default;
+  unique_function(const unique_function &) = delete;
+  unique_function &operator=(unique_function &&) = default;
+  unique_function &operator=(const unique_function &) = delete;
+
+  template <typename CallableT>
+  unique_function(CallableT Callable)
+      : Base(std::forward<CallableT>(Callable),
+             typename Base::template CalledAs<CallableT>{}) {}
+
+  R operator()(P... Params) {
+    return this->getCallPtr()(this->getCalleePtr(), Params...);
+  }
+};
+
+template <typename R, typename... P>
+class unique_function<R(P...) const>
+    : public detail::UniqueFunctionBase<R, P...> {
+  using Base = detail::UniqueFunctionBase<R, P...>;
+
+public:
+  unique_function() = default;
+  unique_function(std::nullptr_t) {}
+  unique_function(unique_function &&) = default;
+  unique_function(const unique_function &) = delete;
+  unique_function &operator=(unique_function &&) = default;
+  unique_function &operator=(const unique_function &) = delete;
+
+  template <typename CallableT>
+  unique_function(CallableT Callable)
+      : Base(std::forward<CallableT>(Callable),
+             typename Base::template CalledAs<const CallableT>{}) {}
+
+  R operator()(P... Params) const {
+    return this->getCallPtr()(this->getCalleePtr(), Params...);
+  }
+};
+
 } // end namespace llvm
 
 #endif // LLVM_ADT_FUNCTION_H
diff --git a/linux-x64/clang/include/llvm/ADT/Hashing.h b/linux-x64/clang/include/llvm/ADT/Hashing.h
index f639aa2..cb53b7f 100644
--- a/linux-x64/clang/include/llvm/ADT/Hashing.h
+++ b/linux-x64/clang/include/llvm/ADT/Hashing.h
@@ -45,13 +45,14 @@
 #define LLVM_ADT_HASHING_H
 
 #include "llvm/Support/DataTypes.h"
-#include "llvm/Support/Host.h"
+#include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/SwapByteOrder.h"
 #include "llvm/Support/type_traits.h"
 #include <algorithm>
 #include <cassert>
 #include <cstring>
 #include <string>
+#include <tuple>
 #include <utility>
 
 namespace llvm {
@@ -101,8 +102,7 @@
 /// differing argument types even if they would implicit promote to a common
 /// type without changing the value.
 template <typename T>
-typename std::enable_if<is_integral_or_enum<T>::value, hash_code>::type
-hash_value(T value);
+std::enable_if_t<is_integral_or_enum<T>::value, hash_code> hash_value(T value);
 
 /// Compute a hash_code for a pointer's address.
 ///
@@ -113,6 +113,10 @@
 template <typename T, typename U>
 hash_code hash_value(const std::pair<T, U> &arg);
 
+/// Compute a hash_code for a tuple.
+template <typename... Ts>
+hash_code hash_value(const std::tuple<Ts...> &arg);
+
 /// Compute a hash_code for a standard string.
 template <typename T>
 hash_code hash_value(const std::basic_string<T> &arg);
@@ -158,10 +162,10 @@
 }
 
 /// Some primes between 2^63 and 2^64 for various uses.
-static const uint64_t k0 = 0xc3a5c85c97cb3127ULL;
-static const uint64_t k1 = 0xb492b66fbe98f273ULL;
-static const uint64_t k2 = 0x9ae16a3b2f90404fULL;
-static const uint64_t k3 = 0xc949d7c7509e6557ULL;
+static constexpr uint64_t k0 = 0xc3a5c85c97cb3127ULL;
+static constexpr uint64_t k1 = 0xb492b66fbe98f273ULL;
+static constexpr uint64_t k2 = 0x9ae16a3b2f90404fULL;
+static constexpr uint64_t k3 = 0xc949d7c7509e6557ULL;
 
 /// Bitwise right rotate.
 /// Normally this will compile to a single instruction, especially if the
@@ -191,7 +195,7 @@
   uint8_t b = s[len >> 1];
   uint8_t c = s[len - 1];
   uint32_t y = static_cast<uint32_t>(a) + (static_cast<uint32_t>(b) << 8);
-  uint32_t z = len + (static_cast<uint32_t>(c) << 2);
+  uint32_t z = static_cast<uint32_t>(len) + (static_cast<uint32_t>(c) << 2);
   return shift_mix(y * k2 ^ z * k3 ^ seed) * k2;
 }
 
@@ -257,7 +261,7 @@
 /// Currently, the algorithm for computing hash codes is based on CityHash and
 /// keeps 56 bytes of arbitrary state.
 struct hash_state {
-  uint64_t h0, h1, h2, h3, h4, h5, h6;
+  uint64_t h0 = 0, h1 = 0, h2 = 0, h3 = 0, h4 = 0, h5 = 0, h6 = 0;
 
   /// Create a new hash_state structure and initialize it based on the
   /// seed and the first 64-byte chunk.
@@ -360,7 +364,7 @@
 /// Helper to get the hashable data representation for a type.
 /// This variant is enabled when the type itself can be used.
 template <typename T>
-typename std::enable_if<is_hashable_data<T>::value, T>::type
+std::enable_if_t<is_hashable_data<T>::value, T>
 get_hashable_data(const T &value) {
   return value;
 }
@@ -368,7 +372,7 @@
 /// This variant is enabled when we must first call hash_value and use the
 /// result as our data.
 template <typename T>
-typename std::enable_if<!is_hashable_data<T>::value, size_t>::type
+std::enable_if_t<!is_hashable_data<T>::value, size_t>
 get_hashable_data(const T &value) {
   using ::llvm::hash_value;
   return hash_value(value);
@@ -442,7 +446,7 @@
 /// are stored in contiguous memory, this routine avoids copying each value
 /// and directly reads from the underlying memory.
 template <typename ValueT>
-typename std::enable_if<is_hashable_data<ValueT>::value, hash_code>::type
+std::enable_if_t<is_hashable_data<ValueT>::value, hash_code>
 hash_combine_range_impl(ValueT *first, ValueT *last) {
   const uint64_t seed = get_execution_seed();
   const char *s_begin = reinterpret_cast<const char *>(first);
@@ -492,7 +496,7 @@
 /// useful at minimizing the code in the recursive calls to ease the pain
 /// caused by a lack of variadic functions.
 struct hash_combine_recursive_helper {
-  char buffer[64];
+  char buffer[64] = {};
   hash_state state;
   const uint64_t seed;
 
@@ -540,7 +544,7 @@
       // store types smaller than the buffer.
       if (!store_and_advance(buffer_ptr, buffer_end, data,
                              partial_store_size))
-        abort();
+        llvm_unreachable("buffer smaller than stored type");
     }
     return buffer_ptr;
   }
@@ -627,8 +631,7 @@
 // Declared and documented above, but defined here so that any of the hashing
 // infrastructure is available.
 template <typename T>
-typename std::enable_if<is_integral_or_enum<T>::value, hash_code>::type
-hash_value(T value) {
+std::enable_if_t<is_integral_or_enum<T>::value, hash_code> hash_value(T value) {
   return ::llvm::hashing::detail::hash_integer_value(
       static_cast<uint64_t>(value));
 }
@@ -647,6 +650,26 @@
   return hash_combine(arg.first, arg.second);
 }
 
+// Implementation details for the hash_value overload for std::tuple<...>(...).
+namespace hashing {
+namespace detail {
+
+template <typename... Ts, std::size_t... Indices>
+hash_code hash_value_tuple_helper(const std::tuple<Ts...> &arg,
+                                  std::index_sequence<Indices...> indices) {
+  return hash_combine(std::get<Indices>(arg)...);
+}
+
+} // namespace detail
+} // namespace hashing
+
+template <typename... Ts>
+hash_code hash_value(const std::tuple<Ts...> &arg) {
+  // TODO: Use std::apply when LLVM starts using C++17.
+  return ::llvm::hashing::detail::hash_value_tuple_helper(
+      arg, typename std::index_sequence_for<Ts...>());
+}
+
 // Declared and documented above, but defined here so that any of the hashing
 // infrastructure is available.
 template <typename T>
diff --git a/linux-x64/clang/include/llvm/ADT/ImmutableMap.h b/linux-x64/clang/include/llvm/ADT/ImmutableMap.h
index 86fd7fe..81b21a7 100644
--- a/linux-x64/clang/include/llvm/ADT/ImmutableMap.h
+++ b/linux-x64/clang/include/llvm/ADT/ImmutableMap.h
@@ -70,33 +70,14 @@
   using TreeTy = ImutAVLTree<ValInfo>;
 
 protected:
-  TreeTy* Root;
+  IntrusiveRefCntPtr<TreeTy> Root;
 
 public:
   /// Constructs a map from a pointer to a tree root.  In general one
   /// should use a Factory object to create maps instead of directly
   /// invoking the constructor, but there are cases where make this
   /// constructor public is useful.
-  explicit ImmutableMap(const TreeTy* R) : Root(const_cast<TreeTy*>(R)) {
-    if (Root) { Root->retain(); }
-  }
-
-  ImmutableMap(const ImmutableMap &X) : Root(X.Root) {
-    if (Root) { Root->retain(); }
-  }
-
-  ~ImmutableMap() {
-    if (Root) { Root->release(); }
-  }
-
-  ImmutableMap &operator=(const ImmutableMap &X) {
-    if (Root != X.Root) {
-      if (X.Root) { X.Root->retain(); }
-      if (Root) { Root->release(); }
-      Root = X.Root;
-    }
-    return *this;
-  }
+  explicit ImmutableMap(const TreeTy *R) : Root(const_cast<TreeTy *>(R)) {}
 
   class Factory {
     typename TreeTy::Factory F;
@@ -115,12 +96,12 @@
 
     LLVM_NODISCARD ImmutableMap add(ImmutableMap Old, key_type_ref K,
                                     data_type_ref D) {
-      TreeTy *T = F.add(Old.Root, std::pair<key_type,data_type>(K,D));
+      TreeTy *T = F.add(Old.Root.get(), std::pair<key_type, data_type>(K, D));
       return ImmutableMap(Canonicalize ? F.getCanonicalTree(T): T);
     }
 
     LLVM_NODISCARD ImmutableMap remove(ImmutableMap Old, key_type_ref K) {
-      TreeTy *T = F.remove(Old.Root,K);
+      TreeTy *T = F.remove(Old.Root.get(), K);
       return ImmutableMap(Canonicalize ? F.getCanonicalTree(T): T);
     }
 
@@ -134,19 +115,20 @@
   }
 
   bool operator==(const ImmutableMap &RHS) const {
-    return Root && RHS.Root ? Root->isEqual(*RHS.Root) : Root == RHS.Root;
+    return Root && RHS.Root ? Root->isEqual(*RHS.Root.get()) : Root == RHS.Root;
   }
 
   bool operator!=(const ImmutableMap &RHS) const {
-    return Root && RHS.Root ? Root->isNotEqual(*RHS.Root) : Root != RHS.Root;
+    return Root && RHS.Root ? Root->isNotEqual(*RHS.Root.get())
+                            : Root != RHS.Root;
   }
 
   TreeTy *getRoot() const {
     if (Root) { Root->retain(); }
-    return Root;
+    return Root.get();
   }
 
-  TreeTy *getRootWithoutRetain() const { return Root; }
+  TreeTy *getRootWithoutRetain() const { return Root.get(); }
 
   void manualRetain() {
     if (Root) Root->retain();
@@ -217,7 +199,7 @@
     data_type_ref getData() const { return (*this)->second; }
   };
 
-  iterator begin() const { return iterator(Root); }
+  iterator begin() const { return iterator(Root.get()); }
   iterator end() const { return iterator(); }
 
   data_type* lookup(key_type_ref K) const {
@@ -243,7 +225,7 @@
   unsigned getHeight() const { return Root ? Root->getHeight() : 0; }
 
   static inline void Profile(FoldingSetNodeID& ID, const ImmutableMap& M) {
-    ID.AddPointer(M.Root);
+    ID.AddPointer(M.Root.get());
   }
 
   inline void Profile(FoldingSetNodeID& ID) const {
@@ -266,7 +248,7 @@
   using FactoryTy = typename TreeTy::Factory;
 
 protected:
-  TreeTy *Root;
+  IntrusiveRefCntPtr<TreeTy> Root;
   FactoryTy *Factory;
 
 public:
@@ -274,44 +256,12 @@
   /// should use a Factory object to create maps instead of directly
   /// invoking the constructor, but there are cases where make this
   /// constructor public is useful.
-  explicit ImmutableMapRef(const TreeTy *R, FactoryTy *F)
-      : Root(const_cast<TreeTy *>(R)), Factory(F) {
-    if (Root) {
-      Root->retain();
-    }
-  }
+  ImmutableMapRef(const TreeTy *R, FactoryTy *F)
+      : Root(const_cast<TreeTy *>(R)), Factory(F) {}
 
-  explicit ImmutableMapRef(const ImmutableMap<KeyT, ValT> &X,
-                           typename ImmutableMap<KeyT, ValT>::Factory &F)
-    : Root(X.getRootWithoutRetain()),
-      Factory(F.getTreeFactory()) {
-    if (Root) { Root->retain(); }
-  }
-
-  ImmutableMapRef(const ImmutableMapRef &X) : Root(X.Root), Factory(X.Factory) {
-    if (Root) {
-      Root->retain();
-    }
-  }
-
-  ~ImmutableMapRef() {
-    if (Root)
-      Root->release();
-  }
-
-  ImmutableMapRef &operator=(const ImmutableMapRef &X) {
-    if (Root != X.Root) {
-      if (X.Root)
-        X.Root->retain();
-
-      if (Root)
-        Root->release();
-
-      Root = X.Root;
-      Factory = X.Factory;
-    }
-    return *this;
-  }
+  ImmutableMapRef(const ImmutableMap<KeyT, ValT> &X,
+                  typename ImmutableMap<KeyT, ValT>::Factory &F)
+      : Root(X.getRootWithoutRetain()), Factory(F.getTreeFactory()) {}
 
   static inline ImmutableMapRef getEmptyMap(FactoryTy *F) {
     return ImmutableMapRef(0, F);
@@ -326,12 +276,13 @@
   }
 
   ImmutableMapRef add(key_type_ref K, data_type_ref D) const {
-    TreeTy *NewT = Factory->add(Root, std::pair<key_type, data_type>(K, D));
+    TreeTy *NewT =
+        Factory->add(Root.get(), std::pair<key_type, data_type>(K, D));
     return ImmutableMapRef(NewT, Factory);
   }
 
   ImmutableMapRef remove(key_type_ref K) const {
-    TreeTy *NewT = Factory->remove(Root, K);
+    TreeTy *NewT = Factory->remove(Root.get(), K);
     return ImmutableMapRef(NewT, Factory);
   }
 
@@ -340,15 +291,16 @@
   }
 
   ImmutableMap<KeyT, ValT> asImmutableMap() const {
-    return ImmutableMap<KeyT, ValT>(Factory->getCanonicalTree(Root));
+    return ImmutableMap<KeyT, ValT>(Factory->getCanonicalTree(Root.get()));
   }
 
   bool operator==(const ImmutableMapRef &RHS) const {
-    return Root && RHS.Root ? Root->isEqual(*RHS.Root) : Root == RHS.Root;
+    return Root && RHS.Root ? Root->isEqual(*RHS.Root.get()) : Root == RHS.Root;
   }
 
   bool operator!=(const ImmutableMapRef &RHS) const {
-    return Root && RHS.Root ? Root->isNotEqual(*RHS.Root) : Root != RHS.Root;
+    return Root && RHS.Root ? Root->isNotEqual(*RHS.Root.get())
+                            : Root != RHS.Root;
   }
 
   bool isEmpty() const { return !Root; }
@@ -377,7 +329,7 @@
     data_type_ref getData() const { return (*this)->second; }
   };
 
-  iterator begin() const { return iterator(Root); }
+  iterator begin() const { return iterator(Root.get()); }
   iterator end() const { return iterator(); }
 
   data_type *lookup(key_type_ref K) const {
@@ -403,7 +355,7 @@
   unsigned getHeight() const { return Root ? Root->getHeight() : 0; }
 
   static inline void Profile(FoldingSetNodeID &ID, const ImmutableMapRef &M) {
-    ID.AddPointer(M.Root);
+    ID.AddPointer(M.Root.get());
   }
 
   inline void Profile(FoldingSetNodeID &ID) const { return Profile(ID, *this); }
diff --git a/linux-x64/clang/include/llvm/ADT/ImmutableSet.h b/linux-x64/clang/include/llvm/ADT/ImmutableSet.h
index 5871054..f19913f 100644
--- a/linux-x64/clang/include/llvm/ADT/ImmutableSet.h
+++ b/linux-x64/clang/include/llvm/ADT/ImmutableSet.h
@@ -15,6 +15,7 @@
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/FoldingSet.h"
+#include "llvm/ADT/IntrusiveRefCntPtr.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/iterator.h"
 #include "llvm/Support/Allocator.h"
@@ -169,7 +170,7 @@
   bool contains(key_type_ref K) { return (bool) find(K); }
 
   /// foreach - A member template the accepts invokes operator() on a functor
-  ///  object (specifed by Callback) for every node/subtree in the tree.
+  ///  object (specified by Callback) for every node/subtree in the tree.
   ///  Nodes are visited using an inorder traversal.
   template <typename Callback>
   void foreach(Callback& C) {
@@ -183,7 +184,7 @@
   }
 
   /// validateTree - A utility method that checks that the balancing and
-  ///  ordering invariants of the tree are satisifed.  It is a recursive
+  ///  ordering invariants of the tree are satisfied.  It is a recursive
   ///  method that returns the height of the tree, which is then consumed
   ///  by the enclosing validateTree call.  External callers should ignore the
   ///  return value.  An invalid tree will cause an assertion to fire in
@@ -205,8 +206,7 @@
                              ImutInfo::KeyOfValue(getValue()))) &&
            "Value in left child is not less that current value");
 
-
-    assert(!(getRight() ||
+    assert((!getRight() ||
              ImutInfo::isLess(ImutInfo::KeyOfValue(getValue()),
                               ImutInfo::KeyOfValue(getRight()->getValue()))) &&
            "Current value is not less that value of right child");
@@ -358,6 +358,12 @@
   }
 };
 
+template <typename ImutInfo>
+struct IntrusiveRefCntPtrInfo<ImutAVLTree<ImutInfo>> {
+  static void retain(ImutAVLTree<ImutInfo> *Tree) { Tree->retain(); }
+  static void release(ImutAVLTree<ImutInfo> *Tree) { Tree->release(); }
+};
+
 //===----------------------------------------------------------------------===//
 // Immutable AVL-Tree Factory class.
 //===----------------------------------------------------------------------===//
@@ -451,7 +457,7 @@
 
   //===--------------------------------------------------===//
   // "createNode" is used to generate new tree roots that link
-  // to other trees.  The functon may also simply move links
+  // to other trees.  The function may also simply move links
   // in an existing root if that root is still marked mutable.
   // This is necessary because otherwise our balancing code
   // would leak memory as it would create nodes that are
@@ -962,33 +968,14 @@
   using TreeTy = ImutAVLTree<ValInfo>;
 
 private:
-  TreeTy *Root;
+  IntrusiveRefCntPtr<TreeTy> Root;
 
 public:
   /// Constructs a set from a pointer to a tree root.  In general one
   /// should use a Factory object to create sets instead of directly
   /// invoking the constructor, but there are cases where make this
   /// constructor public is useful.
-  explicit ImmutableSet(TreeTy* R) : Root(R) {
-    if (Root) { Root->retain(); }
-  }
-
-  ImmutableSet(const ImmutableSet &X) : Root(X.Root) {
-    if (Root) { Root->retain(); }
-  }
-
-  ~ImmutableSet() {
-    if (Root) { Root->release(); }
-  }
-
-  ImmutableSet &operator=(const ImmutableSet &X) {
-    if (Root != X.Root) {
-      if (X.Root) { X.Root->retain(); }
-      if (Root) { Root->release(); }
-      Root = X.Root;
-    }
-    return *this;
-  }
+  explicit ImmutableSet(TreeTy *R) : Root(R) {}
 
   class Factory {
     typename TreeTy::Factory F;
@@ -1017,7 +1004,7 @@
     ///  The memory allocated to represent the set is released when the
     ///  factory object that created the set is destroyed.
     LLVM_NODISCARD ImmutableSet add(ImmutableSet Old, value_type_ref V) {
-      TreeTy *NewT = F.add(Old.Root, V);
+      TreeTy *NewT = F.add(Old.Root.get(), V);
       return ImmutableSet(Canonicalize ? F.getCanonicalTree(NewT) : NewT);
     }
 
@@ -1029,7 +1016,7 @@
     ///  The memory allocated to represent the set is released when the
     ///  factory object that created the set is destroyed.
     LLVM_NODISCARD ImmutableSet remove(ImmutableSet Old, value_type_ref V) {
-      TreeTy *NewT = F.remove(Old.Root, V);
+      TreeTy *NewT = F.remove(Old.Root.get(), V);
       return ImmutableSet(Canonicalize ? F.getCanonicalTree(NewT) : NewT);
     }
 
@@ -1048,21 +1035,20 @@
   }
 
   bool operator==(const ImmutableSet &RHS) const {
-    return Root && RHS.Root ? Root->isEqual(*RHS.Root) : Root == RHS.Root;
+    return Root && RHS.Root ? Root->isEqual(*RHS.Root.get()) : Root == RHS.Root;
   }
 
   bool operator!=(const ImmutableSet &RHS) const {
-    return Root && RHS.Root ? Root->isNotEqual(*RHS.Root) : Root != RHS.Root;
+    return Root && RHS.Root ? Root->isNotEqual(*RHS.Root.get())
+                            : Root != RHS.Root;
   }
 
   TreeTy *getRoot() {
     if (Root) { Root->retain(); }
-    return Root;
+    return Root.get();
   }
 
-  TreeTy *getRootWithoutRetain() const {
-    return Root;
-  }
+  TreeTy *getRootWithoutRetain() const { return Root.get(); }
 
   /// isEmpty - Return true if the set contains no elements.
   bool isEmpty() const { return !Root; }
@@ -1083,7 +1069,7 @@
 
   using iterator = ImutAVLValueIterator<ImmutableSet>;
 
-  iterator begin() const { return iterator(Root); }
+  iterator begin() const { return iterator(Root.get()); }
   iterator end() const { return iterator(); }
 
   //===--------------------------------------------------===//
@@ -1093,7 +1079,7 @@
   unsigned getHeight() const { return Root ? Root->getHeight() : 0; }
 
   static void Profile(FoldingSetNodeID &ID, const ImmutableSet &S) {
-    ID.AddPointer(S.Root);
+    ID.AddPointer(S.Root.get());
   }
 
   void Profile(FoldingSetNodeID &ID) const { return Profile(ID, *this); }
@@ -1115,7 +1101,7 @@
   using FactoryTy = typename TreeTy::Factory;
 
 private:
-  TreeTy *Root;
+  IntrusiveRefCntPtr<TreeTy> Root;
   FactoryTy *Factory;
 
 public:
@@ -1123,42 +1109,18 @@
   /// should use a Factory object to create sets instead of directly
   /// invoking the constructor, but there are cases where make this
   /// constructor public is useful.
-  explicit ImmutableSetRef(TreeTy* R, FactoryTy *F)
-    : Root(R),
-      Factory(F) {
-    if (Root) { Root->retain(); }
-  }
-
-  ImmutableSetRef(const ImmutableSetRef &X)
-    : Root(X.Root),
-      Factory(X.Factory) {
-    if (Root) { Root->retain(); }
-  }
-
-  ~ImmutableSetRef() {
-    if (Root) { Root->release(); }
-  }
-
-  ImmutableSetRef &operator=(const ImmutableSetRef &X) {
-    if (Root != X.Root) {
-      if (X.Root) { X.Root->retain(); }
-      if (Root) { Root->release(); }
-      Root = X.Root;
-      Factory = X.Factory;
-    }
-    return *this;
-  }
+  ImmutableSetRef(TreeTy *R, FactoryTy *F) : Root(R), Factory(F) {}
 
   static ImmutableSetRef getEmptySet(FactoryTy *F) {
     return ImmutableSetRef(0, F);
   }
 
   ImmutableSetRef add(value_type_ref V) {
-    return ImmutableSetRef(Factory->add(Root, V), Factory);
+    return ImmutableSetRef(Factory->add(Root.get(), V), Factory);
   }
 
   ImmutableSetRef remove(value_type_ref V) {
-    return ImmutableSetRef(Factory->remove(Root, V), Factory);
+    return ImmutableSetRef(Factory->remove(Root.get(), V), Factory);
   }
 
   /// Returns true if the set contains the specified value.
@@ -1167,20 +1129,19 @@
   }
 
   ImmutableSet<ValT> asImmutableSet(bool canonicalize = true) const {
-    return ImmutableSet<ValT>(canonicalize ?
-                              Factory->getCanonicalTree(Root) : Root);
+    return ImmutableSet<ValT>(
+        canonicalize ? Factory->getCanonicalTree(Root.get()) : Root.get());
   }
 
-  TreeTy *getRootWithoutRetain() const {
-    return Root;
-  }
+  TreeTy *getRootWithoutRetain() const { return Root.get(); }
 
   bool operator==(const ImmutableSetRef &RHS) const {
-    return Root && RHS.Root ? Root->isEqual(*RHS.Root) : Root == RHS.Root;
+    return Root && RHS.Root ? Root->isEqual(*RHS.Root.get()) : Root == RHS.Root;
   }
 
   bool operator!=(const ImmutableSetRef &RHS) const {
-    return Root && RHS.Root ? Root->isNotEqual(*RHS.Root) : Root != RHS.Root;
+    return Root && RHS.Root ? Root->isNotEqual(*RHS.Root.get())
+                            : Root != RHS.Root;
   }
 
   /// isEmpty - Return true if the set contains no elements.
@@ -1196,7 +1157,7 @@
 
   using iterator = ImutAVLValueIterator<ImmutableSetRef>;
 
-  iterator begin() const { return iterator(Root); }
+  iterator begin() const { return iterator(Root.get()); }
   iterator end() const { return iterator(); }
 
   //===--------------------------------------------------===//
@@ -1206,7 +1167,7 @@
   unsigned getHeight() const { return Root ? Root->getHeight() : 0; }
 
   static void Profile(FoldingSetNodeID &ID, const ImmutableSetRef &S) {
-    ID.AddPointer(S.Root);
+    ID.AddPointer(S.Root.get());
   }
 
   void Profile(FoldingSetNodeID &ID) const { return Profile(ID, *this); }
diff --git a/linux-x64/clang/include/llvm/ADT/IntervalMap.h b/linux-x64/clang/include/llvm/ADT/IntervalMap.h
index 12828c4..0b6c7d6 100644
--- a/linux-x64/clang/include/llvm/ADT/IntervalMap.h
+++ b/linux-x64/clang/include/llvm/ADT/IntervalMap.h
@@ -491,7 +491,7 @@
   struct CacheAlignedPointerTraits {
     static inline void *getAsVoidPointer(void *P) { return P; }
     static inline void *getFromVoidPointer(void *P) { return P; }
-    enum { NumLowBitsAvailable = Log2CacheLine };
+    static constexpr int NumLowBitsAvailable = Log2CacheLine;
   };
   PointerIntPair<void*, Log2CacheLine, unsigned, CacheAlignedPointerTraits> pip;
 
@@ -823,7 +823,7 @@
   }
 
   /// reset - Reset cached information about node(Level) from subtree(Level -1).
-  /// @param Level 1..height. THe node to update after parent node changed.
+  /// @param Level 1..height. The node to update after parent node changed.
   void reset(unsigned Level) {
     path[Level] = Entry(subtree(Level - 1), offset(Level));
   }
@@ -884,7 +884,7 @@
   }
 
   /// getLeftSibling - Get the left sibling node at Level, or a null NodeRef.
-  /// @param Level Get the sinbling to node(Level).
+  /// @param Level Get the sibling to node(Level).
   /// @return Left sibling, or NodeRef().
   NodeRef getRightSibling(unsigned Level) const;
 
@@ -963,7 +963,6 @@
 
 private:
   // The root data is either a RootLeaf or a RootBranchData instance.
-  LLVM_ALIGNAS(RootLeaf) LLVM_ALIGNAS(RootBranchData)
   AlignedCharArrayUnion<RootLeaf, RootBranchData> data;
 
   // Tree height.
@@ -979,10 +978,7 @@
   Allocator &allocator;
 
   /// Represent data as a node type without breaking aliasing rules.
-  template <typename T>
-  T &dataAs() const {
-    return *bit_cast<T *>(const_cast<char *>(data.buffer));
-  }
+  template <typename T> T &dataAs() const { return *bit_cast<T *>(&data); }
 
   const RootLeaf &rootLeaf() const {
     assert(!branched() && "Cannot acces leaf data in branched root");
@@ -1040,7 +1036,7 @@
 
 public:
   explicit IntervalMap(Allocator &a) : height(0), rootSize(0), allocator(a) {
-    assert((uintptr_t(data.buffer) & (alignof(RootLeaf) - 1)) == 0 &&
+    assert((uintptr_t(&data) & (alignof(RootLeaf) - 1)) == 0 &&
            "Insufficient alignment");
     new(&rootLeaf()) RootLeaf();
   }
@@ -1396,7 +1392,7 @@
     setRoot(map->rootSize);
   }
 
-  /// preincrement - move to the next interval.
+  /// preincrement - Move to the next interval.
   const_iterator &operator++() {
     assert(valid() && "Cannot increment end()");
     if (++path.leafOffset() == path.leafSize() && branched())
@@ -1404,14 +1400,14 @@
     return *this;
   }
 
-  /// postincrement - Dont do that!
+  /// postincrement - Don't do that!
   const_iterator operator++(int) {
     const_iterator tmp = *this;
     operator++();
     return tmp;
   }
 
-  /// predecrement - move to the previous interval.
+  /// predecrement - Move to the previous interval.
   const_iterator &operator--() {
     if (path.leafOffset() && (valid() || !branched()))
       --path.leafOffset();
@@ -1420,7 +1416,7 @@
     return *this;
   }
 
-  /// postdecrement - Dont do that!
+  /// postdecrement - Don't do that!
   const_iterator operator--(int) {
     const_iterator tmp = *this;
     operator--();
diff --git a/linux-x64/clang/include/llvm/ADT/IntrusiveRefCntPtr.h b/linux-x64/clang/include/llvm/ADT/IntrusiveRefCntPtr.h
index 6d97fe1..ca4c40d 100644
--- a/linux-x64/clang/include/llvm/ADT/IntrusiveRefCntPtr.h
+++ b/linux-x64/clang/include/llvm/ADT/IntrusiveRefCntPtr.h
@@ -58,6 +58,7 @@
 #include <atomic>
 #include <cassert>
 #include <cstddef>
+#include <memory>
 
 namespace llvm {
 
@@ -70,10 +71,23 @@
 template <class Derived> class RefCountedBase {
   mutable unsigned RefCount = 0;
 
-public:
+protected:
   RefCountedBase() = default;
   RefCountedBase(const RefCountedBase &) {}
+  RefCountedBase &operator=(const RefCountedBase &) = delete;
 
+#ifndef NDEBUG
+  ~RefCountedBase() {
+    assert(RefCount == 0 &&
+           "Destruction occured when there are still references to this.");
+  }
+#else
+  // Default the destructor in release builds, A trivial destructor may enable
+  // better codegen.
+  ~RefCountedBase() = default;
+#endif
+
+public:
   void Retain() const { ++RefCount; }
 
   void Release() const {
@@ -85,10 +99,24 @@
 
 /// A thread-safe version of \c RefCountedBase.
 template <class Derived> class ThreadSafeRefCountedBase {
-  mutable std::atomic<int> RefCount;
+  mutable std::atomic<int> RefCount{0};
 
 protected:
-  ThreadSafeRefCountedBase() : RefCount(0) {}
+  ThreadSafeRefCountedBase() = default;
+  ThreadSafeRefCountedBase(const ThreadSafeRefCountedBase &) {}
+  ThreadSafeRefCountedBase &
+  operator=(const ThreadSafeRefCountedBase &) = delete;
+
+#ifndef NDEBUG
+  ~ThreadSafeRefCountedBase() {
+    assert(RefCount == 0 &&
+           "Destruction occured when there are still references to this.");
+  }
+#else
+  // Default the destructor in release builds, A trivial destructor may enable
+  // better codegen.
+  ~ThreadSafeRefCountedBase() = default;
+#endif
 
 public:
   void Retain() const { RefCount.fetch_add(1, std::memory_order_relaxed); }
@@ -149,6 +177,11 @@
   }
 
   template <class X>
+  IntrusiveRefCntPtr(std::unique_ptr<X> S) : Obj(S.release()) {
+    retain();
+  }
+
+  template <class X>
   IntrusiveRefCntPtr(const IntrusiveRefCntPtr<X> &S) : Obj(S.get()) {
     retain();
   }
@@ -264,6 +297,12 @@
   }
 };
 
+/// Factory function for creating intrusive ref counted pointers.
+template <typename T, typename... Args>
+IntrusiveRefCntPtr<T> makeIntrusiveRefCnt(Args &&...A) {
+  return IntrusiveRefCntPtr<T>(new T(std::forward<Args>(A)...));
+}
+
 } // end namespace llvm
 
 #endif // LLVM_ADT_INTRUSIVEREFCNTPTR_H
diff --git a/linux-x64/clang/include/llvm/ADT/Optional.h b/linux-x64/clang/include/llvm/ADT/Optional.h
index b45a740..daa9ee6 100644
--- a/linux-x64/clang/include/llvm/ADT/Optional.h
+++ b/linux-x64/clang/include/llvm/ADT/Optional.h
@@ -15,6 +15,7 @@
 #ifndef LLVM_ADT_OPTIONAL_H
 #define LLVM_ADT_OPTIONAL_H
 
+#include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/None.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/type_traits.h"
@@ -43,21 +44,21 @@
 public:
   ~OptionalStorage() { reset(); }
 
-  OptionalStorage() noexcept : empty(), hasVal(false) {}
+  constexpr OptionalStorage() noexcept : empty(), hasVal(false) {}
 
-  OptionalStorage(OptionalStorage const &other) : OptionalStorage() {
+  constexpr OptionalStorage(OptionalStorage const &other) : OptionalStorage() {
     if (other.hasValue()) {
       emplace(other.value);
     }
   }
-  OptionalStorage(OptionalStorage &&other) : OptionalStorage() {
+  constexpr OptionalStorage(OptionalStorage &&other) : OptionalStorage() {
     if (other.hasValue()) {
       emplace(std::move(other.value));
     }
   }
 
   template <class... Args>
-  explicit OptionalStorage(in_place_t, Args &&... args)
+  constexpr explicit OptionalStorage(in_place_t, Args &&... args)
       : value(std::forward<Args>(args)...), hasVal(true) {}
 
   void reset() noexcept {
@@ -67,13 +68,13 @@
     }
   }
 
-  bool hasValue() const noexcept { return hasVal; }
+  constexpr bool hasValue() const noexcept { return hasVal; }
 
   T &getValue() LLVM_LVALUE_FUNCTION noexcept {
     assert(hasVal);
     return value;
   }
-  T const &getValue() const LLVM_LVALUE_FUNCTION noexcept {
+  constexpr T const &getValue() const LLVM_LVALUE_FUNCTION noexcept {
     assert(hasVal);
     return value;
   }
@@ -148,16 +149,16 @@
 public:
   ~OptionalStorage() = default;
 
-  OptionalStorage() noexcept : empty{} {}
+  constexpr OptionalStorage() noexcept : empty{} {}
 
-  OptionalStorage(OptionalStorage const &other) = default;
-  OptionalStorage(OptionalStorage &&other) = default;
+  constexpr OptionalStorage(OptionalStorage const &other) = default;
+  constexpr OptionalStorage(OptionalStorage &&other) = default;
 
   OptionalStorage &operator=(OptionalStorage const &other) = default;
   OptionalStorage &operator=(OptionalStorage &&other) = default;
 
   template <class... Args>
-  explicit OptionalStorage(in_place_t, Args &&... args)
+  constexpr explicit OptionalStorage(in_place_t, Args &&... args)
       : value(std::forward<Args>(args)...), hasVal(true) {}
 
   void reset() noexcept {
@@ -167,13 +168,13 @@
     }
   }
 
-  bool hasValue() const noexcept { return hasVal; }
+  constexpr bool hasValue() const noexcept { return hasVal; }
 
   T &getValue() LLVM_LVALUE_FUNCTION noexcept {
     assert(hasVal);
     return value;
   }
-  T const &getValue() const LLVM_LVALUE_FUNCTION noexcept {
+  constexpr T const &getValue() const LLVM_LVALUE_FUNCTION noexcept {
     assert(hasVal);
     return value;
   }
@@ -221,11 +222,12 @@
   constexpr Optional() {}
   constexpr Optional(NoneType) {}
 
-  Optional(const T &y) : Storage(optional_detail::in_place_t{}, y) {}
-  Optional(const Optional &O) = default;
+  constexpr Optional(const T &y) : Storage(optional_detail::in_place_t{}, y) {}
+  constexpr Optional(const Optional &O) = default;
 
-  Optional(T &&y) : Storage(optional_detail::in_place_t{}, std::move(y)) {}
-  Optional(Optional &&O) = default;
+  constexpr Optional(T &&y)
+      : Storage(optional_detail::in_place_t{}, std::move(y)) {}
+  constexpr Optional(Optional &&O) = default;
 
   Optional &operator=(T &&y) {
     Storage = std::move(y);
@@ -238,7 +240,7 @@
     Storage.emplace(std::forward<ArgTypes>(Args)...);
   }
 
-  static inline Optional create(const T *y) {
+  static constexpr Optional create(const T *y) {
     return y ? Optional(*y) : Optional();
   }
 
@@ -250,16 +252,20 @@
 
   void reset() { Storage.reset(); }
 
-  const T *getPointer() const { return &Storage.getValue(); }
+  constexpr const T *getPointer() const { return &Storage.getValue(); }
   T *getPointer() { return &Storage.getValue(); }
-  const T &getValue() const LLVM_LVALUE_FUNCTION { return Storage.getValue(); }
+  constexpr const T &getValue() const LLVM_LVALUE_FUNCTION {
+    return Storage.getValue();
+  }
   T &getValue() LLVM_LVALUE_FUNCTION { return Storage.getValue(); }
 
-  explicit operator bool() const { return hasValue(); }
-  bool hasValue() const { return Storage.hasValue(); }
-  const T *operator->() const { return getPointer(); }
+  constexpr explicit operator bool() const { return hasValue(); }
+  constexpr bool hasValue() const { return Storage.hasValue(); }
+  constexpr const T *operator->() const { return getPointer(); }
   T *operator->() { return getPointer(); }
-  const T &operator*() const LLVM_LVALUE_FUNCTION { return getValue(); }
+  constexpr const T &operator*() const LLVM_LVALUE_FUNCTION {
+    return getValue();
+  }
   T &operator*() LLVM_LVALUE_FUNCTION { return getValue(); }
 
   template <typename U>
@@ -267,6 +273,14 @@
     return hasValue() ? getValue() : std::forward<U>(value);
   }
 
+  /// Apply a function to the value if present; otherwise return None.
+  template <class Function>
+  auto map(const Function &F) const LLVM_LVALUE_FUNCTION
+      -> Optional<decltype(F(getValue()))> {
+    if (*this) return F(getValue());
+    return None;
+  }
+
 #if LLVM_HAS_RVALUE_REFERENCE_THIS
   T &&getValue() && { return std::move(Storage.getValue()); }
   T &&operator*() && { return std::move(Storage.getValue()); }
@@ -275,140 +289,168 @@
   T getValueOr(U &&value) && {
     return hasValue() ? std::move(getValue()) : std::forward<U>(value);
   }
+
+  /// Apply a function to the value if present; otherwise return None.
+  template <class Function>
+  auto map(const Function &F) &&
+      -> Optional<decltype(F(std::move(*this).getValue()))> {
+    if (*this) return F(std::move(*this).getValue());
+    return None;
+  }
 #endif
 };
 
+template <class T> llvm::hash_code hash_value(const Optional<T> &O) {
+  return O ? hash_combine(true, *O) : hash_value(false);
+}
+
 template <typename T, typename U>
-bool operator==(const Optional<T> &X, const Optional<U> &Y) {
+constexpr bool operator==(const Optional<T> &X, const Optional<U> &Y) {
   if (X && Y)
     return *X == *Y;
   return X.hasValue() == Y.hasValue();
 }
 
 template <typename T, typename U>
-bool operator!=(const Optional<T> &X, const Optional<U> &Y) {
+constexpr bool operator!=(const Optional<T> &X, const Optional<U> &Y) {
   return !(X == Y);
 }
 
 template <typename T, typename U>
-bool operator<(const Optional<T> &X, const Optional<U> &Y) {
+constexpr bool operator<(const Optional<T> &X, const Optional<U> &Y) {
   if (X && Y)
     return *X < *Y;
   return X.hasValue() < Y.hasValue();
 }
 
 template <typename T, typename U>
-bool operator<=(const Optional<T> &X, const Optional<U> &Y) {
+constexpr bool operator<=(const Optional<T> &X, const Optional<U> &Y) {
   return !(Y < X);
 }
 
 template <typename T, typename U>
-bool operator>(const Optional<T> &X, const Optional<U> &Y) {
+constexpr bool operator>(const Optional<T> &X, const Optional<U> &Y) {
   return Y < X;
 }
 
 template <typename T, typename U>
-bool operator>=(const Optional<T> &X, const Optional<U> &Y) {
+constexpr bool operator>=(const Optional<T> &X, const Optional<U> &Y) {
   return !(X < Y);
 }
 
-template<typename T>
-bool operator==(const Optional<T> &X, NoneType) {
+template <typename T>
+constexpr bool operator==(const Optional<T> &X, NoneType) {
   return !X;
 }
 
-template<typename T>
-bool operator==(NoneType, const Optional<T> &X) {
+template <typename T>
+constexpr bool operator==(NoneType, const Optional<T> &X) {
   return X == None;
 }
 
-template<typename T>
-bool operator!=(const Optional<T> &X, NoneType) {
+template <typename T>
+constexpr bool operator!=(const Optional<T> &X, NoneType) {
   return !(X == None);
 }
 
-template<typename T>
-bool operator!=(NoneType, const Optional<T> &X) {
+template <typename T>
+constexpr bool operator!=(NoneType, const Optional<T> &X) {
   return X != None;
 }
 
-template <typename T> bool operator<(const Optional<T> &X, NoneType) {
+template <typename T> constexpr bool operator<(const Optional<T> &X, NoneType) {
   return false;
 }
 
-template <typename T> bool operator<(NoneType, const Optional<T> &X) {
+template <typename T> constexpr bool operator<(NoneType, const Optional<T> &X) {
   return X.hasValue();
 }
 
-template <typename T> bool operator<=(const Optional<T> &X, NoneType) {
+template <typename T>
+constexpr bool operator<=(const Optional<T> &X, NoneType) {
   return !(None < X);
 }
 
-template <typename T> bool operator<=(NoneType, const Optional<T> &X) {
+template <typename T>
+constexpr bool operator<=(NoneType, const Optional<T> &X) {
   return !(X < None);
 }
 
-template <typename T> bool operator>(const Optional<T> &X, NoneType) {
+template <typename T> constexpr bool operator>(const Optional<T> &X, NoneType) {
   return None < X;
 }
 
-template <typename T> bool operator>(NoneType, const Optional<T> &X) {
+template <typename T> constexpr bool operator>(NoneType, const Optional<T> &X) {
   return X < None;
 }
 
-template <typename T> bool operator>=(const Optional<T> &X, NoneType) {
+template <typename T>
+constexpr bool operator>=(const Optional<T> &X, NoneType) {
   return None <= X;
 }
 
-template <typename T> bool operator>=(NoneType, const Optional<T> &X) {
+template <typename T>
+constexpr bool operator>=(NoneType, const Optional<T> &X) {
   return X <= None;
 }
 
-template <typename T> bool operator==(const Optional<T> &X, const T &Y) {
+template <typename T>
+constexpr bool operator==(const Optional<T> &X, const T &Y) {
   return X && *X == Y;
 }
 
-template <typename T> bool operator==(const T &X, const Optional<T> &Y) {
+template <typename T>
+constexpr bool operator==(const T &X, const Optional<T> &Y) {
   return Y && X == *Y;
 }
 
-template <typename T> bool operator!=(const Optional<T> &X, const T &Y) {
+template <typename T>
+constexpr bool operator!=(const Optional<T> &X, const T &Y) {
   return !(X == Y);
 }
 
-template <typename T> bool operator!=(const T &X, const Optional<T> &Y) {
+template <typename T>
+constexpr bool operator!=(const T &X, const Optional<T> &Y) {
   return !(X == Y);
 }
 
-template <typename T> bool operator<(const Optional<T> &X, const T &Y) {
+template <typename T>
+constexpr bool operator<(const Optional<T> &X, const T &Y) {
   return !X || *X < Y;
 }
 
-template <typename T> bool operator<(const T &X, const Optional<T> &Y) {
+template <typename T>
+constexpr bool operator<(const T &X, const Optional<T> &Y) {
   return Y && X < *Y;
 }
 
-template <typename T> bool operator<=(const Optional<T> &X, const T &Y) {
+template <typename T>
+constexpr bool operator<=(const Optional<T> &X, const T &Y) {
   return !(Y < X);
 }
 
-template <typename T> bool operator<=(const T &X, const Optional<T> &Y) {
+template <typename T>
+constexpr bool operator<=(const T &X, const Optional<T> &Y) {
   return !(Y < X);
 }
 
-template <typename T> bool operator>(const Optional<T> &X, const T &Y) {
+template <typename T>
+constexpr bool operator>(const Optional<T> &X, const T &Y) {
   return Y < X;
 }
 
-template <typename T> bool operator>(const T &X, const Optional<T> &Y) {
+template <typename T>
+constexpr bool operator>(const T &X, const Optional<T> &Y) {
   return Y < X;
 }
 
-template <typename T> bool operator>=(const Optional<T> &X, const T &Y) {
+template <typename T>
+constexpr bool operator>=(const Optional<T> &X, const T &Y) {
   return !(X < Y);
 }
 
-template <typename T> bool operator>=(const T &X, const Optional<T> &Y) {
+template <typename T>
+constexpr bool operator>=(const T &X, const Optional<T> &Y) {
   return !(X < Y);
 }
 
diff --git a/linux-x64/clang/include/llvm/ADT/PointerEmbeddedInt.h b/linux-x64/clang/include/llvm/ADT/PointerEmbeddedInt.h
index 3eb6edb..fbc48af 100644
--- a/linux-x64/clang/include/llvm/ADT/PointerEmbeddedInt.h
+++ b/linux-x64/clang/include/llvm/ADT/PointerEmbeddedInt.h
@@ -94,7 +94,7 @@
     return T(reinterpret_cast<uintptr_t>(P), typename T::RawValueTag());
   }
 
-  enum { NumLowBitsAvailable = T::Shift };
+  static constexpr int NumLowBitsAvailable = T::Shift;
 };
 
 // Teach DenseMap how to use PointerEmbeddedInt objects as keys if the Int type
diff --git a/linux-x64/clang/include/llvm/ADT/PointerIntPair.h b/linux-x64/clang/include/llvm/ADT/PointerIntPair.h
index 24a2bb6..cb8b202 100644
--- a/linux-x64/clang/include/llvm/ADT/PointerIntPair.h
+++ b/linux-x64/clang/include/llvm/ADT/PointerIntPair.h
@@ -13,6 +13,7 @@
 #ifndef LLVM_ADT_POINTERINTPAIR_H
 #define LLVM_ADT_POINTERINTPAIR_H
 
+#include "llvm/Support/Compiler.h"
 #include "llvm/Support/PointerLikeTypeTraits.h"
 #include "llvm/Support/type_traits.h"
 #include <cassert>
@@ -59,19 +60,19 @@
 
   IntType getInt() const { return (IntType)Info::getInt(Value); }
 
-  void setPointer(PointerTy PtrVal) {
+  void setPointer(PointerTy PtrVal) LLVM_LVALUE_FUNCTION {
     Value = Info::updatePointer(Value, PtrVal);
   }
 
-  void setInt(IntType IntVal) {
+  void setInt(IntType IntVal) LLVM_LVALUE_FUNCTION {
     Value = Info::updateInt(Value, static_cast<intptr_t>(IntVal));
   }
 
-  void initWithPointer(PointerTy PtrVal) {
+  void initWithPointer(PointerTy PtrVal) LLVM_LVALUE_FUNCTION {
     Value = Info::updatePointer(0, PtrVal);
   }
 
-  void setPointerAndInt(PointerTy PtrVal, IntType IntVal) {
+  void setPointerAndInt(PointerTy PtrVal, IntType IntVal) LLVM_LVALUE_FUNCTION {
     Value = Info::updateInt(Info::updatePointer(0, PtrVal),
                             static_cast<intptr_t>(IntVal));
   }
@@ -89,7 +90,7 @@
 
   void *getOpaqueValue() const { return reinterpret_cast<void *>(Value); }
 
-  void setFromOpaqueValue(void *Val) {
+  void setFromOpaqueValue(void *Val) LLVM_LVALUE_FUNCTION {
     Value = reinterpret_cast<intptr_t>(Val);
   }
 
@@ -146,7 +147,7 @@
                 "cannot use a pointer type that has all bits free");
   static_assert(IntBits <= PtrTraits::NumLowBitsAvailable,
                 "PointerIntPair with integer size too large for pointer");
-  enum : uintptr_t {
+  enum MaskAndShiftConstants : uintptr_t {
     /// PointerBitMask - The bits that come from the pointer.
     PointerBitMask =
         ~(uintptr_t)(((intptr_t)1 << PtrTraits::NumLowBitsAvailable) - 1),
@@ -234,7 +235,8 @@
     return PointerIntPair<PointerTy, IntBits, IntType>::getFromOpaqueValue(P);
   }
 
-  enum { NumLowBitsAvailable = PtrTraits::NumLowBitsAvailable - IntBits };
+  static constexpr int NumLowBitsAvailable =
+      PtrTraits::NumLowBitsAvailable - IntBits;
 };
 
 } // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/ADT/PointerSumType.h b/linux-x64/clang/include/llvm/ADT/PointerSumType.h
index d467f83..a7ef774 100644
--- a/linux-x64/clang/include/llvm/ADT/PointerSumType.h
+++ b/linux-x64/clang/include/llvm/ADT/PointerSumType.h
@@ -214,7 +214,7 @@
   LookupOverload(PointerSumTypeMember<N, PointerT, TraitsT> *);
   template <TagT N> static void LookupOverload(...);
   template <TagT N> struct Lookup {
-    // Compute a particular member type by resolving the lookup helper ovorload.
+    // Compute a particular member type by resolving the lookup helper overload.
     using MemberT = decltype(
         LookupOverload<N>(static_cast<PointerSumTypeHelper *>(nullptr)));
 
diff --git a/linux-x64/clang/include/llvm/ADT/PointerUnion.h b/linux-x64/clang/include/llvm/ADT/PointerUnion.h
index 2bcdf54..c396910 100644
--- a/linux-x64/clang/include/llvm/ADT/PointerUnion.h
+++ b/linux-x64/clang/include/llvm/ADT/PointerUnion.h
@@ -54,21 +54,14 @@
 };
 
 namespace pointer_union_detail {
-  constexpr int constexprMin(int a, int b) { return a < b ? a : b; }
   /// Determine the number of bits required to store integers with values < n.
   /// This is ceil(log2(n)).
   constexpr int bitsRequired(unsigned n) {
     return n > 1 ? 1 + bitsRequired((n + 1) / 2) : 0;
   }
 
-  // FIXME: In C++14, replace this with
-  //   std::min({PointerLikeTypeTraits<Ts>::NumLowBitsAvailable...})
-  template <typename T> constexpr int lowBitsAvailable() {
-    return PointerLikeTypeTraits<T>::NumLowBitsAvailable;
-  }
-  template <typename T1, typename T2, typename... Ts>
-  constexpr int lowBitsAvailable() {
-    return constexprMin(lowBitsAvailable<T1>(), lowBitsAvailable<T2, Ts...>());
+  template <typename... Ts> constexpr int lowBitsAvailable() {
+    return std::min<int>({PointerLikeTypeTraits<Ts>::NumLowBitsAvailable...});
   }
 
   /// Find the index of a type in a list of types. TypeIndex<T, Us...>::Index
@@ -100,13 +93,6 @@
     static constexpr int NumLowBitsAvailable = lowBitsAvailable<PTs...>();
   };
 
-  /// Implement assigment in terms of construction.
-  template <typename Derived, typename T> struct AssignableFrom {
-    Derived &operator=(T t) {
-      return static_cast<Derived &>(*this) = Derived(t);
-    }
-  };
-
   template <typename Derived, typename ValTy, int I, typename ...Types>
   class PointerUnionMembers;
 
@@ -167,10 +153,11 @@
               void *, pointer_union_detail::bitsRequired(sizeof...(PTs)), int,
               pointer_union_detail::PointerUnionUIntTraits<PTs...>>,
           0, PTs...> {
-  // The first type is special in some ways, but we don't want PointerUnion to
-  // be a 'template <typename First, typename ...Rest>' because it's much more
-  // convenient to have a name for the whole pack. So split off the first type
-  // here.
+  // The first type is special because we want to directly cast a pointer to a
+  // default-initialized union to a pointer to the first type. But we don't
+  // want PointerUnion to be a 'template <typename First, typename ...Rest>'
+  // because it's much more convenient to have a name for the whole pack. So
+  // split off the first type here.
   using First = typename pointer_union_detail::GetFirstType<PTs...>::type;
   using Base = typename PointerUnion::PointerUnionMembers;
 
@@ -182,17 +169,12 @@
 
   /// Test if the pointer held in the union is null, regardless of
   /// which type it is.
-  bool isNull() const {
-    // Convert from the void* to one of the pointer types, to make sure that
-    // we recursively strip off low bits if we have a nested PointerUnion.
-    return !PointerLikeTypeTraits<First>::getFromVoidPointer(
-        this->Val.getPointer());
-  }
+  bool isNull() const { return !this->Val.getPointer(); }
 
   explicit operator bool() const { return !isNull(); }
 
   /// Test if the Union currently holds the type matching T.
-  template <typename T> int is() const {
+  template <typename T> bool is() const {
     constexpr int Index = pointer_union_detail::TypeIndex<T, PTs...>::Index;
     static_assert(Index < sizeof...(PTs),
                   "PointerUnion::is<T> given type not in the union");
@@ -208,7 +190,7 @@
   }
 
   /// Returns the current pointer if it is of the specified pointer type,
-  /// otherwises returns null.
+  /// otherwise returns null.
   template <typename T> T dyn_cast() const {
     if (is<T>())
       return get<T>();
@@ -226,7 +208,8 @@
   First *getAddrOfPtr1() {
     assert(is<First>() && "Val is not the first pointer");
     assert(
-        get<First>() == this->Val.getPointer() &&
+        PointerLikeTypeTraits<First>::getAsVoidPointer(get<First>()) ==
+            this->Val.getPointer() &&
         "Can't get the address because PointerLikeTypeTraits changes the ptr");
     return const_cast<First *>(
         reinterpret_cast<const First *>(this->Val.getAddrOfPointer()));
@@ -282,16 +265,6 @@
       PointerUnion<PTs...>::Val)>::NumLowBitsAvailable;
 };
 
-/// A pointer union of three pointer types. See documentation for PointerUnion
-/// for usage.
-template <typename PT1, typename PT2, typename PT3>
-using PointerUnion3 = PointerUnion<PT1, PT2, PT3>;
-
-/// A pointer union of four pointer types. See documentation for PointerUnion
-/// for usage.
-template <typename PT1, typename PT2, typename PT3, typename PT4>
-using PointerUnion4 = PointerUnion<PT1, PT2, PT3, PT4>;
-
 // Teach DenseMap how to use PointerUnions as keys.
 template <typename ...PTs> struct DenseMapInfo<PointerUnion<PTs...>> {
   using Union = PointerUnion<PTs...>;
diff --git a/linux-x64/clang/include/llvm/ADT/PostOrderIterator.h b/linux-x64/clang/include/llvm/ADT/PostOrderIterator.h
index 2fe7447..bb413a9 100644
--- a/linux-x64/clang/include/llvm/ADT/PostOrderIterator.h
+++ b/linux-x64/clang/include/llvm/ADT/PostOrderIterator.h
@@ -18,6 +18,7 @@
 #include "llvm/ADT/GraphTraits.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallPtrSet.h"
+#include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/iterator_range.h"
 #include <iterator>
 #include <set>
@@ -101,7 +102,7 @@
 
   // VisitStack - Used to maintain the ordering.  Top = current block
   // First element is basic block pointer, second is the 'next child' to visit
-  std::vector<std::pair<NodeRef, ChildItTy>> VisitStack;
+  SmallVector<std::pair<NodeRef, ChildItTy>, 8> VisitStack;
 
   po_iterator(NodeRef BB) {
     this->insertEdge(Optional<NodeRef>(), BB);
diff --git a/linux-x64/clang/include/llvm/ADT/PriorityWorklist.h b/linux-x64/clang/include/llvm/ADT/PriorityWorklist.h
index 96d22c8..01dd59a 100644
--- a/linux-x64/clang/include/llvm/ADT/PriorityWorklist.h
+++ b/linux-x64/clang/include/llvm/ADT/PriorityWorklist.h
@@ -110,7 +110,7 @@
 
   /// Insert a sequence of new elements into the PriorityWorklist.
   template <typename SequenceT>
-  typename std::enable_if<!std::is_convertible<SequenceT, T>::value>::type
+  std::enable_if_t<!std::is_convertible<SequenceT, T>::value>
   insert(SequenceT &&Input) {
     if (std::begin(Input) == std::end(Input))
       // Nothing to do for an empty input sequence.
diff --git a/linux-x64/clang/include/llvm/ADT/SCCIterator.h b/linux-x64/clang/include/llvm/ADT/SCCIterator.h
index eb1a5d0..8a7c0a7 100644
--- a/linux-x64/clang/include/llvm/ADT/SCCIterator.h
+++ b/linux-x64/clang/include/llvm/ADT/SCCIterator.h
@@ -124,17 +124,20 @@
     return CurrentSCC;
   }
 
-  /// Test if the current SCC has a loop.
+  /// Test if the current SCC has a cycle.
   ///
   /// If the SCC has more than one node, this is trivially true.  If not, it may
-  /// still contain a loop if the node has an edge back to itself.
-  bool hasLoop() const;
+  /// still contain a cycle if the node has an edge back to itself.
+  bool hasCycle() const;
 
   /// This informs the \c scc_iterator that the specified \c Old node
   /// has been deleted, and \c New is to be used in its place.
   void ReplaceNode(NodeRef Old, NodeRef New) {
     assert(nodeVisitNumbers.count(Old) && "Old not in scc_iterator?");
-    nodeVisitNumbers[New] = nodeVisitNumbers[Old];
+    // Do the assignment in two steps, in case 'New' is not yet in the map, and
+    // inserting it causes the map to grow.
+    auto tempVal = nodeVisitNumbers[Old];
+    nodeVisitNumbers[New] = tempVal;
     nodeVisitNumbers.erase(Old);
   }
 };
@@ -209,7 +212,7 @@
 }
 
 template <class GraphT, class GT>
-bool scc_iterator<GraphT, GT>::hasLoop() const {
+bool scc_iterator<GraphT, GT>::hasCycle() const {
     assert(!CurrentSCC.empty() && "Dereferencing END SCC iterator!");
     if (CurrentSCC.size() > 1)
       return true;
diff --git a/linux-x64/clang/include/llvm/ADT/STLExtras.h b/linux-x64/clang/include/llvm/ADT/STLExtras.h
index 81dce01..c8c1aff 100644
--- a/linux-x64/clang/include/llvm/ADT/STLExtras.h
+++ b/linux-x64/clang/include/llvm/ADT/STLExtras.h
@@ -17,7 +17,6 @@
 #define LLVM_ADT_STLEXTRAS_H
 
 #include "llvm/ADT/Optional.h"
-#include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/iterator.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/Config/abi-breaking.h"
@@ -80,6 +79,79 @@
       typename std::add_const<T>::type>::type;
 };
 
+/// Utilities for detecting if a given trait holds for some set of arguments
+/// 'Args'. For example, the given trait could be used to detect if a given type
+/// has a copy assignment operator:
+///   template<class T>
+///   using has_copy_assign_t = decltype(std::declval<T&>()
+///                                                 = std::declval<const T&>());
+///   bool fooHasCopyAssign = is_detected<has_copy_assign_t, FooClass>::value;
+namespace detail {
+template <typename...> using void_t = void;
+template <class, template <class...> class Op, class... Args> struct detector {
+  using value_t = std::false_type;
+};
+template <template <class...> class Op, class... Args>
+struct detector<void_t<Op<Args...>>, Op, Args...> {
+  using value_t = std::true_type;
+};
+} // end namespace detail
+
+template <template <class...> class Op, class... Args>
+using is_detected = typename detail::detector<void, Op, Args...>::value_t;
+
+/// Check if a Callable type can be invoked with the given set of arg types.
+namespace detail {
+template <typename Callable, typename... Args>
+using is_invocable =
+    decltype(std::declval<Callable &>()(std::declval<Args>()...));
+} // namespace detail
+
+template <typename Callable, typename... Args>
+using is_invocable = is_detected<detail::is_invocable, Callable, Args...>;
+
+/// This class provides various trait information about a callable object.
+///   * To access the number of arguments: Traits::num_args
+///   * To access the type of an argument: Traits::arg_t<Index>
+///   * To access the type of the result:  Traits::result_t
+template <typename T, bool isClass = std::is_class<T>::value>
+struct function_traits : public function_traits<decltype(&T::operator())> {};
+
+/// Overload for class function types.
+template <typename ClassType, typename ReturnType, typename... Args>
+struct function_traits<ReturnType (ClassType::*)(Args...) const, false> {
+  /// The number of arguments to this function.
+  enum { num_args = sizeof...(Args) };
+
+  /// The result type of this function.
+  using result_t = ReturnType;
+
+  /// The type of an argument to this function.
+  template <size_t Index>
+  using arg_t = typename std::tuple_element<Index, std::tuple<Args...>>::type;
+};
+/// Overload for class function types.
+template <typename ClassType, typename ReturnType, typename... Args>
+struct function_traits<ReturnType (ClassType::*)(Args...), false>
+    : function_traits<ReturnType (ClassType::*)(Args...) const> {};
+/// Overload for non-class function types.
+template <typename ReturnType, typename... Args>
+struct function_traits<ReturnType (*)(Args...), false> {
+  /// The number of arguments to this function.
+  enum { num_args = sizeof...(Args) };
+
+  /// The result type of this function.
+  using result_t = ReturnType;
+
+  /// The type of an argument to this function.
+  template <size_t i>
+  using arg_t = typename std::tuple_element<i, std::tuple<Args...>>::type;
+};
+/// Overload for non-class function type references.
+template <typename ReturnType, typename... Args>
+struct function_traits<ReturnType (&)(Args...), false>
+    : public function_traits<ReturnType (*)(Args...)> {};
+
 //===----------------------------------------------------------------------===//
 //     Extra additions to <functional>
 //===----------------------------------------------------------------------===//
@@ -95,18 +167,6 @@
   }
 };
 
-template <class Ty> struct less_ptr {
-  bool operator()(const Ty* left, const Ty* right) const {
-    return *left < *right;
-  }
-};
-
-template <class Ty> struct greater_ptr {
-  bool operator()(const Ty* left, const Ty* right) const {
-    return *right < *left;
-  }
-};
-
 /// An efficient, type-erasing, non-owning reference to a callable. This is
 /// intended for use as the type of a function parameter that is not used
 /// after the function in question returns.
@@ -131,10 +191,17 @@
   function_ref(std::nullptr_t) {}
 
   template <typename Callable>
-  function_ref(Callable &&callable,
-               typename std::enable_if<
-                   !std::is_same<typename std::remove_reference<Callable>::type,
-                                 function_ref>::value>::type * = nullptr)
+  function_ref(
+      Callable &&callable,
+      // This is not the copy-constructor.
+      std::enable_if_t<
+          !std::is_same<std::remove_cv_t<std::remove_reference_t<Callable>>,
+                        function_ref>::value> * = nullptr,
+      // Functor must be callable and return a suitable type.
+      std::enable_if_t<std::is_void<Ret>::value ||
+                       std::is_convertible<decltype(std::declval<Callable>()(
+                                               std::declval<Params>()...)),
+                                           Ret>::value> * = nullptr)
       : callback(callback_fn<typename std::remove_reference<Callable>::type>),
         callable(reinterpret_cast<intptr_t>(&callable)) {}
 
@@ -142,18 +209,9 @@
     return callback(callable, std::forward<Params>(params)...);
   }
 
-  operator bool() const { return callback; }
+  explicit operator bool() const { return callback; }
 };
 
-// deleter - Very very very simple method that is used to invoke operator
-// delete on something.  It is used like this:
-//
-//   for_each(V.begin(), B.end(), deleter<Interval>);
-template <class T>
-inline void deleter(T *Ptr) {
-  delete Ptr;
-}
-
 //===----------------------------------------------------------------------===//
 //     Extra additions to <iterator>
 //===----------------------------------------------------------------------===//
@@ -163,16 +221,14 @@
 using std::begin;
 
 template <typename ContainerTy>
-auto adl_begin(ContainerTy &&container)
-    -> decltype(begin(std::forward<ContainerTy>(container))) {
+decltype(auto) adl_begin(ContainerTy &&container) {
   return begin(std::forward<ContainerTy>(container));
 }
 
 using std::end;
 
 template <typename ContainerTy>
-auto adl_end(ContainerTy &&container)
-    -> decltype(end(std::forward<ContainerTy>(container))) {
+decltype(auto) adl_end(ContainerTy &&container) {
   return end(std::forward<ContainerTy>(container));
 }
 
@@ -187,14 +243,12 @@
 } // end namespace adl_detail
 
 template <typename ContainerTy>
-auto adl_begin(ContainerTy &&container)
-    -> decltype(adl_detail::adl_begin(std::forward<ContainerTy>(container))) {
+decltype(auto) adl_begin(ContainerTy &&container) {
   return adl_detail::adl_begin(std::forward<ContainerTy>(container));
 }
 
 template <typename ContainerTy>
-auto adl_end(ContainerTy &&container)
-    -> decltype(adl_detail::adl_end(std::forward<ContainerTy>(container))) {
+decltype(auto) adl_end(ContainerTy &&container) {
   return adl_detail::adl_end(std::forward<ContainerTy>(container));
 }
 
@@ -210,6 +264,19 @@
   return adl_begin(RangeOrContainer) == adl_end(RangeOrContainer);
 }
 
+/// Returns true if the given container only contains a single element.
+template <typename ContainerTy> bool hasSingleElement(ContainerTy &&C) {
+  auto B = std::begin(C), E = std::end(C);
+  return B != E && std::next(B) == E;
+}
+
+/// Return a range covering \p RangeOrContainer with the first N elements
+/// excluded.
+template <typename T> auto drop_begin(T &&RangeOrContainer, size_t N) {
+  return make_range(std::next(adl_begin(RangeOrContainer), N),
+                    adl_end(RangeOrContainer));
+}
+
 // mapped_iterator - This is a simple iterator adapter that causes a function to
 // be applied whenever operator* is invoked on the iterator.
 
@@ -227,7 +294,7 @@
 
   ItTy getCurrent() { return this->I; }
 
-  FuncReturnTy operator*() { return F(*this->I); }
+  FuncReturnTy operator*() const { return F(*this->I); }
 
 private:
   FuncTy F;
@@ -241,9 +308,7 @@
 }
 
 template <class ContainerTy, class FuncTy>
-auto map_range(ContainerTy &&C, FuncTy F)
-    -> decltype(make_range(map_iterator(C.begin(), F),
-                           map_iterator(C.end(), F))) {
+auto map_range(ContainerTy &&C, FuncTy F) {
   return make_range(map_iterator(C.begin(), F), map_iterator(C.end(), F));
 }
 
@@ -271,8 +336,7 @@
 // Note that the container must have rbegin()/rend() methods for this to work.
 template <typename ContainerTy>
 auto reverse(ContainerTy &&C,
-             typename std::enable_if<has_rbegin<ContainerTy>::value>::type * =
-                 nullptr) -> decltype(make_range(C.rbegin(), C.rend())) {
+             std::enable_if_t<has_rbegin<ContainerTy>::value> * = nullptr) {
   return make_range(C.rbegin(), C.rend());
 }
 
@@ -286,11 +350,8 @@
 // Note that the container must have begin()/end() methods which return
 // bidirectional iterators for this to work.
 template <typename ContainerTy>
-auto reverse(
-    ContainerTy &&C,
-    typename std::enable_if<!has_rbegin<ContainerTy>::value>::type * = nullptr)
-    -> decltype(make_range(llvm::make_reverse_iterator(std::end(C)),
-                           llvm::make_reverse_iterator(std::begin(C)))) {
+auto reverse(ContainerTy &&C,
+             std::enable_if_t<!has_rbegin<ContainerTy>::value> * = nullptr) {
   return make_range(llvm::make_reverse_iterator(std::end(C)),
                     llvm::make_reverse_iterator(std::begin(C)));
 }
@@ -477,7 +538,7 @@
   early_inc_iterator_impl(WrappedIteratorT I) : BaseT(I) {}
 
   using BaseT::operator*;
-  typename BaseT::reference operator*() {
+  decltype(*std::declval<WrappedIteratorT>()) operator*() {
 #if LLVM_ENABLE_ABI_BREAKING_CHECKS
     assert(!IsEarlyIncremented && "Cannot dereference twice!");
     IsEarlyIncremented = true;
@@ -494,12 +555,12 @@
     return *this;
   }
 
-  using BaseT::operator==;
-  bool operator==(const early_inc_iterator_impl &RHS) const {
+  friend bool operator==(const early_inc_iterator_impl &LHS,
+                         const early_inc_iterator_impl &RHS) {
 #if LLVM_ENABLE_ABI_BREAKING_CHECKS
-    assert(!IsEarlyIncremented && "Cannot compare after dereferencing!");
+    assert(!LHS.IsEarlyIncremented && "Cannot compare after dereferencing!");
 #endif
-    return BaseT::operator==(RHS);
+    return (const BaseT &)LHS == (const BaseT &)RHS;
   }
 };
 
@@ -530,10 +591,6 @@
 template <typename R, typename UnaryPredicate>
 bool any_of(R &&range, UnaryPredicate P);
 
-template <size_t... I> struct index_sequence;
-
-template <class... Ts> struct index_sequence_for;
-
 namespace detail {
 
 using std::declval;
@@ -568,38 +625,38 @@
   std::tuple<Iters...> iterators;
 
 protected:
-  template <size_t... Ns> value_type deref(index_sequence<Ns...>) const {
+  template <size_t... Ns> value_type deref(std::index_sequence<Ns...>) const {
     return value_type(*std::get<Ns>(iterators)...);
   }
 
   template <size_t... Ns>
-  decltype(iterators) tup_inc(index_sequence<Ns...>) const {
+  decltype(iterators) tup_inc(std::index_sequence<Ns...>) const {
     return std::tuple<Iters...>(std::next(std::get<Ns>(iterators))...);
   }
 
   template <size_t... Ns>
-  decltype(iterators) tup_dec(index_sequence<Ns...>) const {
+  decltype(iterators) tup_dec(std::index_sequence<Ns...>) const {
     return std::tuple<Iters...>(std::prev(std::get<Ns>(iterators))...);
   }
 
 public:
   zip_common(Iters &&... ts) : iterators(std::forward<Iters>(ts)...) {}
 
-  value_type operator*() { return deref(index_sequence_for<Iters...>{}); }
+  value_type operator*() { return deref(std::index_sequence_for<Iters...>{}); }
 
   const value_type operator*() const {
-    return deref(index_sequence_for<Iters...>{});
+    return deref(std::index_sequence_for<Iters...>{});
   }
 
   ZipType &operator++() {
-    iterators = tup_inc(index_sequence_for<Iters...>{});
+    iterators = tup_inc(std::index_sequence_for<Iters...>{});
     return *reinterpret_cast<ZipType *>(this);
   }
 
   ZipType &operator--() {
     static_assert(Base::IsBidirectional,
                   "All inner iterators must be at least bidirectional.");
-    iterators = tup_dec(index_sequence_for<Iters...>{});
+    iterators = tup_dec(std::index_sequence_for<Iters...>{});
     return *reinterpret_cast<ZipType *>(this);
   }
 };
@@ -618,7 +675,8 @@
 template <typename... Iters>
 class zip_shortest : public zip_common<zip_shortest<Iters...>, Iters...> {
   template <size_t... Ns>
-  bool test(const zip_shortest<Iters...> &other, index_sequence<Ns...>) const {
+  bool test(const zip_shortest<Iters...> &other,
+            std::index_sequence<Ns...>) const {
     return all_of(std::initializer_list<bool>{std::get<Ns>(this->iterators) !=
                                               std::get<Ns>(other.iterators)...},
                   identity<bool>{});
@@ -630,7 +688,7 @@
   zip_shortest(Iters &&... ts) : Base(std::forward<Iters>(ts)...) {}
 
   bool operator==(const zip_shortest<Iters...> &other) const {
-    return !test(other, index_sequence_for<Iters...>{});
+    return !test(other, std::index_sequence_for<Iters...>{});
   }
 };
 
@@ -646,18 +704,21 @@
 private:
   std::tuple<Args...> ts;
 
-  template <size_t... Ns> iterator begin_impl(index_sequence<Ns...>) const {
+  template <size_t... Ns>
+  iterator begin_impl(std::index_sequence<Ns...>) const {
     return iterator(std::begin(std::get<Ns>(ts))...);
   }
-  template <size_t... Ns> iterator end_impl(index_sequence<Ns...>) const {
+  template <size_t... Ns> iterator end_impl(std::index_sequence<Ns...>) const {
     return iterator(std::end(std::get<Ns>(ts))...);
   }
 
 public:
   zippy(Args &&... ts_) : ts(std::forward<Args>(ts_)...) {}
 
-  iterator begin() const { return begin_impl(index_sequence_for<Args...>{}); }
-  iterator end() const { return end_impl(index_sequence_for<Args...>{}); }
+  iterator begin() const {
+    return begin_impl(std::index_sequence_for<Args...>{});
+  }
+  iterator end() const { return end_impl(std::index_sequence_for<Args...>{}); }
 };
 
 } // end namespace detail
@@ -681,16 +742,15 @@
 
 namespace detail {
 template <typename Iter>
-static Iter next_or_end(const Iter &I, const Iter &End) {
+Iter next_or_end(const Iter &I, const Iter &End) {
   if (I == End)
     return End;
   return std::next(I);
 }
 
 template <typename Iter>
-static auto deref_or_none(const Iter &I, const Iter &End)
-    -> llvm::Optional<typename std::remove_const<
-        typename std::remove_reference<decltype(*I)>::type>::type> {
+auto deref_or_none(const Iter &I, const Iter &End) -> llvm::Optional<
+    std::remove_const_t<std::remove_reference_t<decltype(*I)>>> {
   if (I == End)
     return None;
   return *I;
@@ -727,20 +787,20 @@
 
   template <size_t... Ns>
   bool test(const zip_longest_iterator<Iters...> &other,
-            index_sequence<Ns...>) const {
+            std::index_sequence<Ns...>) const {
     return llvm::any_of(
         std::initializer_list<bool>{std::get<Ns>(this->iterators) !=
                                     std::get<Ns>(other.iterators)...},
         identity<bool>{});
   }
 
-  template <size_t... Ns> value_type deref(index_sequence<Ns...>) const {
+  template <size_t... Ns> value_type deref(std::index_sequence<Ns...>) const {
     return value_type(
         deref_or_none(std::get<Ns>(iterators), std::get<Ns>(end_iterators))...);
   }
 
   template <size_t... Ns>
-  decltype(iterators) tup_inc(index_sequence<Ns...>) const {
+  decltype(iterators) tup_inc(std::index_sequence<Ns...>) const {
     return std::tuple<Iters...>(
         next_or_end(std::get<Ns>(iterators), std::get<Ns>(end_iterators))...);
   }
@@ -750,17 +810,19 @@
       : iterators(std::forward<Iters>(ts.first)...),
         end_iterators(std::forward<Iters>(ts.second)...) {}
 
-  value_type operator*() { return deref(index_sequence_for<Iters...>{}); }
+  value_type operator*() { return deref(std::index_sequence_for<Iters...>{}); }
 
-  value_type operator*() const { return deref(index_sequence_for<Iters...>{}); }
+  value_type operator*() const {
+    return deref(std::index_sequence_for<Iters...>{});
+  }
 
   zip_longest_iterator<Iters...> &operator++() {
-    iterators = tup_inc(index_sequence_for<Iters...>{});
+    iterators = tup_inc(std::index_sequence_for<Iters...>{});
     return *this;
   }
 
   bool operator==(const zip_longest_iterator<Iters...> &other) const {
-    return !test(other, index_sequence_for<Iters...>{});
+    return !test(other, std::index_sequence_for<Iters...>{});
   }
 };
 
@@ -777,12 +839,13 @@
 private:
   std::tuple<Args...> ts;
 
-  template <size_t... Ns> iterator begin_impl(index_sequence<Ns...>) const {
+  template <size_t... Ns>
+  iterator begin_impl(std::index_sequence<Ns...>) const {
     return iterator(std::make_pair(adl_begin(std::get<Ns>(ts)),
                                    adl_end(std::get<Ns>(ts)))...);
   }
 
-  template <size_t... Ns> iterator end_impl(index_sequence<Ns...>) const {
+  template <size_t... Ns> iterator end_impl(std::index_sequence<Ns...>) const {
     return iterator(std::make_pair(adl_end(std::get<Ns>(ts)),
                                    adl_end(std::get<Ns>(ts)))...);
   }
@@ -790,8 +853,10 @@
 public:
   zip_longest_range(Args &&... ts_) : ts(std::forward<Args>(ts_)...) {}
 
-  iterator begin() const { return begin_impl(index_sequence_for<Args...>{}); }
-  iterator end() const { return end_impl(index_sequence_for<Args...>{}); }
+  iterator begin() const {
+    return begin_impl(std::index_sequence_for<Args...>{});
+  }
+  iterator end() const { return end_impl(std::index_sequence_for<Args...>{}); }
 };
 } // namespace detail
 
@@ -847,7 +912,7 @@
   /// Increments the first non-end iterator.
   ///
   /// It is an error to call this with all iterators at the end.
-  template <size_t... Ns> void increment(index_sequence<Ns...>) {
+  template <size_t... Ns> void increment(std::index_sequence<Ns...>) {
     // Build a sequence of functions to increment each iterator if possible.
     bool (concat_iterator::*IncrementHelperFns[])() = {
         &concat_iterator::incrementHelper<Ns>...};
@@ -876,7 +941,7 @@
   /// reference.
   ///
   /// It is an error to call this with all iterators at the end.
-  template <size_t... Ns> ValueT &get(index_sequence<Ns...>) const {
+  template <size_t... Ns> ValueT &get(std::index_sequence<Ns...>) const {
     // Build a sequence of functions to get from iterator if possible.
     ValueT *(concat_iterator::*GetHelperFns[])() const = {
         &concat_iterator::getHelper<Ns>...};
@@ -890,7 +955,7 @@
   }
 
 public:
-  /// Constructs an iterator from a squence of ranges.
+  /// Constructs an iterator from a sequence of ranges.
   ///
   /// We need the full range to know how to switch between each of the
   /// iterators.
@@ -901,11 +966,13 @@
   using BaseT::operator++;
 
   concat_iterator &operator++() {
-    increment(index_sequence_for<IterTs...>());
+    increment(std::index_sequence_for<IterTs...>());
     return *this;
   }
 
-  ValueT &operator*() const { return get(index_sequence_for<IterTs...>()); }
+  ValueT &operator*() const {
+    return get(std::index_sequence_for<IterTs...>());
+  }
 
   bool operator==(const concat_iterator &RHS) const {
     return Begins == RHS.Begins && Ends == RHS.Ends;
@@ -928,10 +995,10 @@
 private:
   std::tuple<RangeTs...> Ranges;
 
-  template <size_t... Ns> iterator begin_impl(index_sequence<Ns...>) {
+  template <size_t... Ns> iterator begin_impl(std::index_sequence<Ns...>) {
     return iterator(std::get<Ns>(Ranges)...);
   }
-  template <size_t... Ns> iterator end_impl(index_sequence<Ns...>) {
+  template <size_t... Ns> iterator end_impl(std::index_sequence<Ns...>) {
     return iterator(make_range(std::end(std::get<Ns>(Ranges)),
                                std::end(std::get<Ns>(Ranges)))...);
   }
@@ -940,8 +1007,8 @@
   concat_range(RangeTs &&... Ranges)
       : Ranges(std::forward<RangeTs>(Ranges)...) {}
 
-  iterator begin() { return begin_impl(index_sequence_for<RangeTs...>{}); }
-  iterator end() { return end_impl(index_sequence_for<RangeTs...>{}); }
+  iterator begin() { return begin_impl(std::index_sequence_for<RangeTs...>{}); }
+  iterator end() { return end_impl(std::index_sequence_for<RangeTs...>{}); }
 };
 
 } // end namespace detail
@@ -957,6 +1024,243 @@
       std::forward<RangeTs>(Ranges)...);
 }
 
+/// A utility class used to implement an iterator that contains some base object
+/// and an index. The iterator moves the index but keeps the base constant.
+template <typename DerivedT, typename BaseT, typename T,
+          typename PointerT = T *, typename ReferenceT = T &>
+class indexed_accessor_iterator
+    : public llvm::iterator_facade_base<DerivedT,
+                                        std::random_access_iterator_tag, T,
+                                        std::ptrdiff_t, PointerT, ReferenceT> {
+public:
+  ptrdiff_t operator-(const indexed_accessor_iterator &rhs) const {
+    assert(base == rhs.base && "incompatible iterators");
+    return index - rhs.index;
+  }
+  bool operator==(const indexed_accessor_iterator &rhs) const {
+    return base == rhs.base && index == rhs.index;
+  }
+  bool operator<(const indexed_accessor_iterator &rhs) const {
+    assert(base == rhs.base && "incompatible iterators");
+    return index < rhs.index;
+  }
+
+  DerivedT &operator+=(ptrdiff_t offset) {
+    this->index += offset;
+    return static_cast<DerivedT &>(*this);
+  }
+  DerivedT &operator-=(ptrdiff_t offset) {
+    this->index -= offset;
+    return static_cast<DerivedT &>(*this);
+  }
+
+  /// Returns the current index of the iterator.
+  ptrdiff_t getIndex() const { return index; }
+
+  /// Returns the current base of the iterator.
+  const BaseT &getBase() const { return base; }
+
+protected:
+  indexed_accessor_iterator(BaseT base, ptrdiff_t index)
+      : base(base), index(index) {}
+  BaseT base;
+  ptrdiff_t index;
+};
+
+namespace detail {
+/// The class represents the base of a range of indexed_accessor_iterators. It
+/// provides support for many different range functionalities, e.g.
+/// drop_front/slice/etc.. Derived range classes must implement the following
+/// static methods:
+///   * ReferenceT dereference_iterator(const BaseT &base, ptrdiff_t index)
+///     - Dereference an iterator pointing to the base object at the given
+///       index.
+///   * BaseT offset_base(const BaseT &base, ptrdiff_t index)
+///     - Return a new base that is offset from the provide base by 'index'
+///       elements.
+template <typename DerivedT, typename BaseT, typename T,
+          typename PointerT = T *, typename ReferenceT = T &>
+class indexed_accessor_range_base {
+public:
+  using RangeBaseT =
+      indexed_accessor_range_base<DerivedT, BaseT, T, PointerT, ReferenceT>;
+
+  /// An iterator element of this range.
+  class iterator : public indexed_accessor_iterator<iterator, BaseT, T,
+                                                    PointerT, ReferenceT> {
+  public:
+    // Index into this iterator, invoking a static method on the derived type.
+    ReferenceT operator*() const {
+      return DerivedT::dereference_iterator(this->getBase(), this->getIndex());
+    }
+
+  private:
+    iterator(BaseT owner, ptrdiff_t curIndex)
+        : indexed_accessor_iterator<iterator, BaseT, T, PointerT, ReferenceT>(
+              owner, curIndex) {}
+
+    /// Allow access to the constructor.
+    friend indexed_accessor_range_base<DerivedT, BaseT, T, PointerT,
+                                       ReferenceT>;
+  };
+
+  indexed_accessor_range_base(iterator begin, iterator end)
+      : base(offset_base(begin.getBase(), begin.getIndex())),
+        count(end.getIndex() - begin.getIndex()) {}
+  indexed_accessor_range_base(const iterator_range<iterator> &range)
+      : indexed_accessor_range_base(range.begin(), range.end()) {}
+  indexed_accessor_range_base(BaseT base, ptrdiff_t count)
+      : base(base), count(count) {}
+
+  iterator begin() const { return iterator(base, 0); }
+  iterator end() const { return iterator(base, count); }
+  ReferenceT operator[](unsigned index) const {
+    assert(index < size() && "invalid index for value range");
+    return DerivedT::dereference_iterator(base, index);
+  }
+  ReferenceT front() const {
+    assert(!empty() && "expected non-empty range");
+    return (*this)[0];
+  }
+  ReferenceT back() const {
+    assert(!empty() && "expected non-empty range");
+    return (*this)[size() - 1];
+  }
+
+  /// Compare this range with another.
+  template <typename OtherT> bool operator==(const OtherT &other) const {
+    return size() ==
+               static_cast<size_t>(std::distance(other.begin(), other.end())) &&
+           std::equal(begin(), end(), other.begin());
+  }
+  template <typename OtherT> bool operator!=(const OtherT &other) const {
+    return !(*this == other);
+  }
+
+  /// Return the size of this range.
+  size_t size() const { return count; }
+
+  /// Return if the range is empty.
+  bool empty() const { return size() == 0; }
+
+  /// Drop the first N elements, and keep M elements.
+  DerivedT slice(size_t n, size_t m) const {
+    assert(n + m <= size() && "invalid size specifiers");
+    return DerivedT(offset_base(base, n), m);
+  }
+
+  /// Drop the first n elements.
+  DerivedT drop_front(size_t n = 1) const {
+    assert(size() >= n && "Dropping more elements than exist");
+    return slice(n, size() - n);
+  }
+  /// Drop the last n elements.
+  DerivedT drop_back(size_t n = 1) const {
+    assert(size() >= n && "Dropping more elements than exist");
+    return DerivedT(base, size() - n);
+  }
+
+  /// Take the first n elements.
+  DerivedT take_front(size_t n = 1) const {
+    return n < size() ? drop_back(size() - n)
+                      : static_cast<const DerivedT &>(*this);
+  }
+
+  /// Take the last n elements.
+  DerivedT take_back(size_t n = 1) const {
+    return n < size() ? drop_front(size() - n)
+                      : static_cast<const DerivedT &>(*this);
+  }
+
+  /// Allow conversion to any type accepting an iterator_range.
+  template <typename RangeT, typename = std::enable_if_t<std::is_constructible<
+                                 RangeT, iterator_range<iterator>>::value>>
+  operator RangeT() const {
+    return RangeT(iterator_range<iterator>(*this));
+  }
+
+  /// Returns the base of this range.
+  const BaseT &getBase() const { return base; }
+
+private:
+  /// Offset the given base by the given amount.
+  static BaseT offset_base(const BaseT &base, size_t n) {
+    return n == 0 ? base : DerivedT::offset_base(base, n);
+  }
+
+protected:
+  indexed_accessor_range_base(const indexed_accessor_range_base &) = default;
+  indexed_accessor_range_base(indexed_accessor_range_base &&) = default;
+  indexed_accessor_range_base &
+  operator=(const indexed_accessor_range_base &) = default;
+
+  /// The base that owns the provided range of values.
+  BaseT base;
+  /// The size from the owning range.
+  ptrdiff_t count;
+};
+} // end namespace detail
+
+/// This class provides an implementation of a range of
+/// indexed_accessor_iterators where the base is not indexable. Ranges with
+/// bases that are offsetable should derive from indexed_accessor_range_base
+/// instead. Derived range classes are expected to implement the following
+/// static method:
+///   * ReferenceT dereference(const BaseT &base, ptrdiff_t index)
+///     - Dereference an iterator pointing to a parent base at the given index.
+template <typename DerivedT, typename BaseT, typename T,
+          typename PointerT = T *, typename ReferenceT = T &>
+class indexed_accessor_range
+    : public detail::indexed_accessor_range_base<
+          DerivedT, std::pair<BaseT, ptrdiff_t>, T, PointerT, ReferenceT> {
+public:
+  indexed_accessor_range(BaseT base, ptrdiff_t startIndex, ptrdiff_t count)
+      : detail::indexed_accessor_range_base<
+            DerivedT, std::pair<BaseT, ptrdiff_t>, T, PointerT, ReferenceT>(
+            std::make_pair(base, startIndex), count) {}
+  using detail::indexed_accessor_range_base<
+      DerivedT, std::pair<BaseT, ptrdiff_t>, T, PointerT,
+      ReferenceT>::indexed_accessor_range_base;
+
+  /// Returns the current base of the range.
+  const BaseT &getBase() const { return this->base.first; }
+
+  /// Returns the current start index of the range.
+  ptrdiff_t getStartIndex() const { return this->base.second; }
+
+  /// See `detail::indexed_accessor_range_base` for details.
+  static std::pair<BaseT, ptrdiff_t>
+  offset_base(const std::pair<BaseT, ptrdiff_t> &base, ptrdiff_t index) {
+    // We encode the internal base as a pair of the derived base and a start
+    // index into the derived base.
+    return std::make_pair(base.first, base.second + index);
+  }
+  /// See `detail::indexed_accessor_range_base` for details.
+  static ReferenceT
+  dereference_iterator(const std::pair<BaseT, ptrdiff_t> &base,
+                       ptrdiff_t index) {
+    return DerivedT::dereference(base.first, base.second + index);
+  }
+};
+
+/// Given a container of pairs, return a range over the first elements.
+template <typename ContainerTy> auto make_first_range(ContainerTy &&c) {
+  return llvm::map_range(
+      std::forward<ContainerTy>(c),
+      [](decltype((*std::begin(c))) elt) -> decltype((elt.first)) {
+        return elt.first;
+      });
+}
+
+/// Given a container of pairs, return a range over the second elements.
+template <typename ContainerTy> auto make_second_range(ContainerTy &&c) {
+  return llvm::map_range(
+      std::forward<ContainerTy>(c),
+      [](decltype((*std::begin(c))) elt) -> decltype((elt.second)) {
+        return elt.second;
+      });
+}
+
 //===----------------------------------------------------------------------===//
 //     Extra additions to <utility>
 //===----------------------------------------------------------------------===//
@@ -984,34 +1288,11 @@
   FuncTy func;
 
   template <typename T>
-  auto operator()(const T &lhs, const T &rhs) const
-      -> decltype(func(lhs.first, rhs.first)) {
+  decltype(auto) operator()(const T &lhs, const T &rhs) const {
     return func(lhs.first, rhs.first);
   }
 };
 
-// A subset of N3658. More stuff can be added as-needed.
-
-/// Represents a compile-time sequence of integers.
-template <class T, T... I> struct integer_sequence {
-  using value_type = T;
-
-  static constexpr size_t size() { return sizeof...(I); }
-};
-
-/// Alias for the common case of a sequence of size_ts.
-template <size_t... I>
-struct index_sequence : integer_sequence<std::size_t, I...> {};
-
-template <std::size_t N, std::size_t... I>
-struct build_index_impl : build_index_impl<N - 1, N - 1, I...> {};
-template <std::size_t... I>
-struct build_index_impl<0, I...> : index_sequence<I...> {};
-
-/// Creates a compile-time integer sequence for a parameter pack.
-template <class... Ts>
-struct index_sequence_for : build_index_impl<sizeof...(Ts)> {};
-
 /// Utility type to build an inheritance chain that makes it easy to rank
 /// overload candidates.
 template <int N> struct rank : rank<N - 1> {};
@@ -1045,6 +1326,16 @@
 //     Extra additions for arrays
 //===----------------------------------------------------------------------===//
 
+// We have a copy here so that LLVM behaves the same when using different
+// standard libraries.
+template <class Iterator, class RNG>
+void shuffle(Iterator first, Iterator last, RNG &&g) {
+  // It would be better to use a std::uniform_int_distribution,
+  // but that would be stdlib dependent.
+  for (auto size = last - first; size > 1; ++first, (void)--size)
+    std::iter_swap(first, first + g() % size);
+}
+
 /// Find the length of an array.
 template <class T, std::size_t N>
 constexpr inline size_t array_lengthof(T (&)[N]) {
@@ -1071,6 +1362,23 @@
   return array_pod_sort_comparator<T>;
 }
 
+#ifdef EXPENSIVE_CHECKS
+namespace detail {
+
+inline unsigned presortShuffleEntropy() {
+  static unsigned Result(std::random_device{}());
+  return Result;
+}
+
+template <class IteratorTy>
+inline void presortShuffle(IteratorTy Start, IteratorTy End) {
+  std::mt19937 Generator(presortShuffleEntropy());
+  std::shuffle(Start, End, Generator);
+}
+
+} // end namespace detail
+#endif
+
 /// array_pod_sort - This sorts an array with the specified start and end
 /// extent.  This is just like std::sort, except that it calls qsort instead of
 /// using an inlined template.  qsort is slightly slower than std::sort, but
@@ -1092,8 +1400,7 @@
   auto NElts = End - Start;
   if (NElts <= 1) return;
 #ifdef EXPENSIVE_CHECKS
-  std::mt19937 Generator(std::random_device{}());
-  std::shuffle(Start, End, Generator);
+  detail::presortShuffle<IteratorTy>(Start, End);
 #endif
   qsort(&*Start, NElts, sizeof(*Start), get_array_pod_sort_comparator(*Start));
 }
@@ -1109,24 +1416,42 @@
   auto NElts = End - Start;
   if (NElts <= 1) return;
 #ifdef EXPENSIVE_CHECKS
-  std::mt19937 Generator(std::random_device{}());
-  std::shuffle(Start, End, Generator);
+  detail::presortShuffle<IteratorTy>(Start, End);
 #endif
   qsort(&*Start, NElts, sizeof(*Start),
         reinterpret_cast<int (*)(const void *, const void *)>(Compare));
 }
 
+namespace detail {
+template <typename T>
+// We can use qsort if the iterator type is a pointer and the underlying value
+// is trivially copyable.
+using sort_trivially_copyable = conjunction<
+    std::is_pointer<T>,
+    std::is_trivially_copyable<typename std::iterator_traits<T>::value_type>>;
+} // namespace detail
+
 // Provide wrappers to std::sort which shuffle the elements before sorting
 // to help uncover non-deterministic behavior (PR35135).
-template <typename IteratorTy>
+template <typename IteratorTy,
+          std::enable_if_t<!detail::sort_trivially_copyable<IteratorTy>::value,
+                           int> = 0>
 inline void sort(IteratorTy Start, IteratorTy End) {
 #ifdef EXPENSIVE_CHECKS
-  std::mt19937 Generator(std::random_device{}());
-  std::shuffle(Start, End, Generator);
+  detail::presortShuffle<IteratorTy>(Start, End);
 #endif
   std::sort(Start, End);
 }
 
+// Forward trivially copyable types to array_pod_sort. This avoids a large
+// amount of code bloat for a minor performance hit.
+template <typename IteratorTy,
+          std::enable_if_t<detail::sort_trivially_copyable<IteratorTy>::value,
+                           int> = 0>
+inline void sort(IteratorTy Start, IteratorTy End) {
+  array_pod_sort(Start, End);
+}
+
 template <typename Container> inline void sort(Container &&C) {
   llvm::sort(adl_begin(C), adl_end(C));
 }
@@ -1134,8 +1459,7 @@
 template <typename IteratorTy, typename Compare>
 inline void sort(IteratorTy Start, IteratorTy End, Compare Comp) {
 #ifdef EXPENSIVE_CHECKS
-  std::mt19937 Generator(std::random_device{}());
-  std::shuffle(Start, End, Generator);
+  detail::presortShuffle<IteratorTy>(Start, End);
 #endif
   std::sort(Start, End, Comp);
 }
@@ -1149,41 +1473,23 @@
 //     Extra additions to <algorithm>
 //===----------------------------------------------------------------------===//
 
-/// For a container of pointers, deletes the pointers and then clears the
-/// container.
-template<typename Container>
-void DeleteContainerPointers(Container &C) {
-  for (auto V : C)
-    delete V;
-  C.clear();
-}
-
-/// In a container of pairs (usually a map) whose second element is a pointer,
-/// deletes the second elements and then clears the container.
-template<typename Container>
-void DeleteContainerSeconds(Container &C) {
-  for (auto &V : C)
-    delete V.second;
-  C.clear();
-}
-
 /// Get the size of a range. This is a wrapper function around std::distance
 /// which is only enabled when the operation is O(1).
 template <typename R>
-auto size(R &&Range, typename std::enable_if<
-                         std::is_same<typename std::iterator_traits<decltype(
-                                          Range.begin())>::iterator_category,
-                                      std::random_access_iterator_tag>::value,
-                         void>::type * = nullptr)
-    -> decltype(std::distance(Range.begin(), Range.end())) {
+auto size(R &&Range,
+          std::enable_if_t<
+              std::is_base_of<std::random_access_iterator_tag,
+                              typename std::iterator_traits<decltype(
+                                  Range.begin())>::iterator_category>::value,
+              void> * = nullptr) {
   return std::distance(Range.begin(), Range.end());
 }
 
 /// Provide wrappers to std::for_each which take ranges instead of having to
 /// pass begin/end explicitly.
-template <typename R, typename UnaryPredicate>
-UnaryPredicate for_each(R &&Range, UnaryPredicate P) {
-  return std::for_each(adl_begin(Range), adl_end(Range), P);
+template <typename R, typename UnaryFunction>
+UnaryFunction for_each(R &&Range, UnaryFunction F) {
+  return std::for_each(adl_begin(Range), adl_end(Range), F);
 }
 
 /// Provide wrappers to std::all_of which take ranges instead of having to pass
@@ -1209,27 +1515,26 @@
 
 /// Provide wrappers to std::find which take ranges instead of having to pass
 /// begin/end explicitly.
-template <typename R, typename T>
-auto find(R &&Range, const T &Val) -> decltype(adl_begin(Range)) {
+template <typename R, typename T> auto find(R &&Range, const T &Val) {
   return std::find(adl_begin(Range), adl_end(Range), Val);
 }
 
 /// Provide wrappers to std::find_if which take ranges instead of having to pass
 /// begin/end explicitly.
 template <typename R, typename UnaryPredicate>
-auto find_if(R &&Range, UnaryPredicate P) -> decltype(adl_begin(Range)) {
+auto find_if(R &&Range, UnaryPredicate P) {
   return std::find_if(adl_begin(Range), adl_end(Range), P);
 }
 
 template <typename R, typename UnaryPredicate>
-auto find_if_not(R &&Range, UnaryPredicate P) -> decltype(adl_begin(Range)) {
+auto find_if_not(R &&Range, UnaryPredicate P) {
   return std::find_if_not(adl_begin(Range), adl_end(Range), P);
 }
 
 /// Provide wrappers to std::remove_if which take ranges instead of having to
 /// pass begin/end explicitly.
 template <typename R, typename UnaryPredicate>
-auto remove_if(R &&Range, UnaryPredicate P) -> decltype(adl_begin(Range)) {
+auto remove_if(R &&Range, UnaryPredicate P) {
   return std::remove_if(adl_begin(Range), adl_end(Range), P);
 }
 
@@ -1245,6 +1550,13 @@
   return std::copy(adl_begin(Range), adl_end(Range), Out);
 }
 
+/// Provide wrappers to std::move which take ranges instead of having to
+/// pass begin/end explicitly.
+template <typename R, typename OutputIt>
+OutputIt move(R &&Range, OutputIt Out) {
+  return std::move(adl_begin(Range), adl_end(Range), Out);
+}
+
 /// Wrapper function around std::find to detect if an element exists
 /// in a container.
 template <typename R, typename E>
@@ -1252,62 +1564,67 @@
   return std::find(adl_begin(Range), adl_end(Range), Element) != adl_end(Range);
 }
 
+/// Wrapper function around std::is_sorted to check if elements in a range \p R
+/// are sorted with respect to a comparator \p C.
+template <typename R, typename Compare> bool is_sorted(R &&Range, Compare C) {
+  return std::is_sorted(adl_begin(Range), adl_end(Range), C);
+}
+
+/// Wrapper function around std::is_sorted to check if elements in a range \p R
+/// are sorted in non-descending order.
+template <typename R> bool is_sorted(R &&Range) {
+  return std::is_sorted(adl_begin(Range), adl_end(Range));
+}
+
 /// Wrapper function around std::count to count the number of times an element
 /// \p Element occurs in the given range \p Range.
-template <typename R, typename E>
-auto count(R &&Range, const E &Element) ->
-    typename std::iterator_traits<decltype(adl_begin(Range))>::difference_type {
+template <typename R, typename E> auto count(R &&Range, const E &Element) {
   return std::count(adl_begin(Range), adl_end(Range), Element);
 }
 
 /// Wrapper function around std::count_if to count the number of times an
 /// element satisfying a given predicate occurs in a range.
 template <typename R, typename UnaryPredicate>
-auto count_if(R &&Range, UnaryPredicate P) ->
-    typename std::iterator_traits<decltype(adl_begin(Range))>::difference_type {
+auto count_if(R &&Range, UnaryPredicate P) {
   return std::count_if(adl_begin(Range), adl_end(Range), P);
 }
 
 /// Wrapper function around std::transform to apply a function to a range and
 /// store the result elsewhere.
-template <typename R, typename OutputIt, typename UnaryPredicate>
-OutputIt transform(R &&Range, OutputIt d_first, UnaryPredicate P) {
-  return std::transform(adl_begin(Range), adl_end(Range), d_first, P);
+template <typename R, typename OutputIt, typename UnaryFunction>
+OutputIt transform(R &&Range, OutputIt d_first, UnaryFunction F) {
+  return std::transform(adl_begin(Range), adl_end(Range), d_first, F);
 }
 
 /// Provide wrappers to std::partition which take ranges instead of having to
 /// pass begin/end explicitly.
 template <typename R, typename UnaryPredicate>
-auto partition(R &&Range, UnaryPredicate P) -> decltype(adl_begin(Range)) {
+auto partition(R &&Range, UnaryPredicate P) {
   return std::partition(adl_begin(Range), adl_end(Range), P);
 }
 
 /// Provide wrappers to std::lower_bound which take ranges instead of having to
 /// pass begin/end explicitly.
-template <typename R, typename T>
-auto lower_bound(R &&Range, T &&Value) -> decltype(adl_begin(Range)) {
+template <typename R, typename T> auto lower_bound(R &&Range, T &&Value) {
   return std::lower_bound(adl_begin(Range), adl_end(Range),
                           std::forward<T>(Value));
 }
 
 template <typename R, typename T, typename Compare>
-auto lower_bound(R &&Range, T &&Value, Compare C)
-    -> decltype(adl_begin(Range)) {
+auto lower_bound(R &&Range, T &&Value, Compare C) {
   return std::lower_bound(adl_begin(Range), adl_end(Range),
                           std::forward<T>(Value), C);
 }
 
 /// Provide wrappers to std::upper_bound which take ranges instead of having to
 /// pass begin/end explicitly.
-template <typename R, typename T>
-auto upper_bound(R &&Range, T &&Value) -> decltype(adl_begin(Range)) {
+template <typename R, typename T> auto upper_bound(R &&Range, T &&Value) {
   return std::upper_bound(adl_begin(Range), adl_end(Range),
                           std::forward<T>(Value));
 }
 
 template <typename R, typename T, typename Compare>
-auto upper_bound(R &&Range, T &&Value, Compare C)
-    -> decltype(adl_begin(Range)) {
+auto upper_bound(R &&Range, T &&Value, Compare C) {
   return std::upper_bound(adl_begin(Range), adl_end(Range),
                           std::forward<T>(Value), C);
 }
@@ -1326,7 +1643,7 @@
 /// Requires that C is always true below some limit, and always false above it.
 template <typename R, typename Predicate,
           typename Val = decltype(*adl_begin(std::declval<R>()))>
-auto partition_point(R &&Range, Predicate P) -> decltype(adl_begin(Range)) {
+auto partition_point(R &&Range, Predicate P) {
   return std::partition_point(adl_begin(Range), adl_end(Range), P);
 }
 
@@ -1339,15 +1656,6 @@
          std::equal(adl_begin(Range) + 1, adl_end(Range), adl_begin(Range)));
 }
 
-/// Given a range of type R, iterate the entire range and return a
-/// SmallVector with elements of the vector.  This is useful, for example,
-/// when you want to iterate a range and then sort the results.
-template <unsigned Size, typename R>
-SmallVector<typename std::remove_const<detail::ValueOfRange<R>>::type, Size>
-to_vector(R &&Range) {
-  return {adl_begin(Range), adl_end(Range)};
-}
-
 /// Provide a container algorithm similar to C++ Library Fundamentals v2's
 /// `erase_if` which is equivalent to:
 ///
@@ -1360,6 +1668,22 @@
   C.erase(remove_if(C, P), C.end());
 }
 
+/// Wrapper function to remove a value from a container:
+///
+/// C.erase(remove(C.begin(), C.end(), V), C.end());
+template <typename Container, typename ValueType>
+void erase_value(Container &C, ValueType V) {
+  C.erase(std::remove(C.begin(), C.end(), V), C.end());
+}
+
+/// Wrapper function to append a range to a container.
+///
+/// C.insert(C.end(), R.begin(), R.end());
+template <typename Container, typename Range>
+inline void append_range(Container &C, Range &&R) {
+  C.insert(C.end(), R.begin(), R.end());
+}
+
 /// Given a sequence container Cont, replace the range [ContIt, ContEnd) with
 /// the range [ValIt, ValEnd) (which is not from the same container).
 template<typename Container, typename RandomAccessIterator>
@@ -1387,45 +1711,73 @@
   replace(Cont, ContIt, ContEnd, R.begin(), R.end());
 }
 
+/// An STL-style algorithm similar to std::for_each that applies a second
+/// functor between every pair of elements.
+///
+/// This provides the control flow logic to, for example, print a
+/// comma-separated list:
+/// \code
+///   interleave(names.begin(), names.end(),
+///              [&](StringRef name) { os << name; },
+///              [&] { os << ", "; });
+/// \endcode
+template <typename ForwardIterator, typename UnaryFunctor,
+          typename NullaryFunctor,
+          typename = typename std::enable_if<
+              !std::is_constructible<StringRef, UnaryFunctor>::value &&
+              !std::is_constructible<StringRef, NullaryFunctor>::value>::type>
+inline void interleave(ForwardIterator begin, ForwardIterator end,
+                       UnaryFunctor each_fn, NullaryFunctor between_fn) {
+  if (begin == end)
+    return;
+  each_fn(*begin);
+  ++begin;
+  for (; begin != end; ++begin) {
+    between_fn();
+    each_fn(*begin);
+  }
+}
+
+template <typename Container, typename UnaryFunctor, typename NullaryFunctor,
+          typename = typename std::enable_if<
+              !std::is_constructible<StringRef, UnaryFunctor>::value &&
+              !std::is_constructible<StringRef, NullaryFunctor>::value>::type>
+inline void interleave(const Container &c, UnaryFunctor each_fn,
+                       NullaryFunctor between_fn) {
+  interleave(c.begin(), c.end(), each_fn, between_fn);
+}
+
+/// Overload of interleave for the common case of string separator.
+template <typename Container, typename UnaryFunctor, typename StreamT,
+          typename T = detail::ValueOfRange<Container>>
+inline void interleave(const Container &c, StreamT &os, UnaryFunctor each_fn,
+                       const StringRef &separator) {
+  interleave(c.begin(), c.end(), each_fn, [&] { os << separator; });
+}
+template <typename Container, typename StreamT,
+          typename T = detail::ValueOfRange<Container>>
+inline void interleave(const Container &c, StreamT &os,
+                       const StringRef &separator) {
+  interleave(
+      c, os, [&](const T &a) { os << a; }, separator);
+}
+
+template <typename Container, typename UnaryFunctor, typename StreamT,
+          typename T = detail::ValueOfRange<Container>>
+inline void interleaveComma(const Container &c, StreamT &os,
+                            UnaryFunctor each_fn) {
+  interleave(c, os, each_fn, ", ");
+}
+template <typename Container, typename StreamT,
+          typename T = detail::ValueOfRange<Container>>
+inline void interleaveComma(const Container &c, StreamT &os) {
+  interleaveComma(c, os, [&](const T &a) { os << a; });
+}
+
 //===----------------------------------------------------------------------===//
 //     Extra additions to <memory>
 //===----------------------------------------------------------------------===//
 
-// Implement make_unique according to N3656.
-
-/// Constructs a `new T()` with the given args and returns a
-///        `unique_ptr<T>` which owns the object.
-///
-/// Example:
-///
-///     auto p = make_unique<int>();
-///     auto p = make_unique<std::tuple<int, int>>(0, 1);
-template <class T, class... Args>
-typename std::enable_if<!std::is_array<T>::value, std::unique_ptr<T>>::type
-make_unique(Args &&... args) {
-  return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
-}
-
-/// Constructs a `new T[n]` with the given args and returns a
-///        `unique_ptr<T[]>` which owns the object.
-///
-/// \param n size of the new array.
-///
-/// Example:
-///
-///     auto p = make_unique<int[]>(2); // value-initializes the array with 0's.
-template <class T>
-typename std::enable_if<std::is_array<T>::value && std::extent<T>::value == 0,
-                        std::unique_ptr<T>>::type
-make_unique(size_t n) {
-  return std::unique_ptr<T>(new typename std::remove_extent<T>::type[n]());
-}
-
-/// This function isn't used and is only here to provide better compile errors.
-template <class T, class... Args>
-typename std::enable_if<std::extent<T>::value != 0>::type
-make_unique(Args &&...) = delete;
-
 struct FreeDeleter {
   void operator()(void* v) {
     ::free(v);
@@ -1439,20 +1791,6 @@
   }
 };
 
-/// A functor like C++14's std::less<void> in its absence.
-struct less {
-  template <typename A, typename B> bool operator()(A &&a, B &&b) const {
-    return std::forward<A>(a) < std::forward<B>(b);
-  }
-};
-
-/// A functor like C++14's std::equal<void> in its absence.
-struct equal {
-  template <typename A, typename B> bool operator()(A &&a, B &&b) const {
-    return std::forward<A>(a) == std::forward<B>(b);
-  }
-};
-
 /// Binary functor that adapts to any other binary functor after dereferencing
 /// operands.
 template <typename T> struct deref {
@@ -1461,8 +1799,7 @@
   // Could be further improved to cope with non-derivable functors and
   // non-binary functors (should be a variadic template member function
   // operator()).
-  template <typename A, typename B>
-  auto operator()(A &lhs, B &rhs) const -> decltype(func(*lhs, *rhs)) {
+  template <typename A, typename B> auto operator()(A &lhs, B &rhs) const {
     assert(lhs);
     assert(rhs);
     return func(*lhs, *rhs);
@@ -1483,6 +1820,8 @@
   result_pair(std::size_t Index, IterOfRange<R> Iter)
       : Index(Index), Iter(Iter) {}
 
+  result_pair<R>(const result_pair<R> &Other)
+      : Index(Other.Index), Iter(Other.Iter) {}
   result_pair<R> &operator=(const result_pair<R> &Other) {
     Index = Other.Index;
     Iter = Other.Iter;
@@ -1531,6 +1870,7 @@
     return Result.Iter == RHS.Result.Iter;
   }
 
+  enumerator_iter<R>(const enumerator_iter<R> &Other) : Result(Other.Result) {}
   enumerator_iter<R> &operator=(const enumerator_iter<R> &Other) {
     Result = Other.Result;
     return *this;
@@ -1580,8 +1920,7 @@
 namespace detail {
 
 template <typename F, typename Tuple, std::size_t... I>
-auto apply_tuple_impl(F &&f, Tuple &&t, index_sequence<I...>)
-    -> decltype(std::forward<F>(f)(std::get<I>(std::forward<Tuple>(t))...)) {
+decltype(auto) apply_tuple_impl(F &&f, Tuple &&t, std::index_sequence<I...>) {
   return std::forward<F>(f)(std::get<I>(std::forward<Tuple>(t))...);
 }
 
@@ -1591,11 +1930,8 @@
 /// tuple variadically to f as if by calling f(a1, a2, ..., an) and
 /// return the result.
 template <typename F, typename Tuple>
-auto apply_tuple(F &&f, Tuple &&t) -> decltype(detail::apply_tuple_impl(
-    std::forward<F>(f), std::forward<Tuple>(t),
-    build_index_impl<
-        std::tuple_size<typename std::decay<Tuple>::type>::value>{})) {
-  using Indices = build_index_impl<
+decltype(auto) apply_tuple(F &&f, Tuple &&t) {
+  using Indices = std::make_index_sequence<
       std::tuple_size<typename std::decay<Tuple>::type>::value>;
 
   return detail::apply_tuple_impl(std::forward<F>(f), std::forward<Tuple>(t),
@@ -1604,49 +1940,89 @@
 
 /// Return true if the sequence [Begin, End) has exactly N items. Runs in O(N)
 /// time. Not meant for use with random-access iterators.
-template <typename IterTy>
+/// Can optionally take a predicate to filter lazily some items.
+template <typename IterTy,
+          typename Pred = bool (*)(const decltype(*std::declval<IterTy>()) &)>
 bool hasNItems(
     IterTy &&Begin, IterTy &&End, unsigned N,
-    typename std::enable_if<
-        !std::is_same<
-            typename std::iterator_traits<typename std::remove_reference<
-                decltype(Begin)>::type>::iterator_category,
-            std::random_access_iterator_tag>::value,
-        void>::type * = nullptr) {
-  for (; N; --N, ++Begin)
+    Pred &&ShouldBeCounted =
+        [](const decltype(*std::declval<IterTy>()) &) { return true; },
+    std::enable_if_t<
+        !std::is_base_of<std::random_access_iterator_tag,
+                         typename std::iterator_traits<std::remove_reference_t<
+                             decltype(Begin)>>::iterator_category>::value,
+        void> * = nullptr) {
+  for (; N; ++Begin) {
     if (Begin == End)
       return false; // Too few.
-  return Begin == End;
+    N -= ShouldBeCounted(*Begin);
+  }
+  for (; Begin != End; ++Begin)
+    if (ShouldBeCounted(*Begin))
+      return false; // Too many.
+  return true;
 }
 
 /// Return true if the sequence [Begin, End) has N or more items. Runs in O(N)
 /// time. Not meant for use with random-access iterators.
-template <typename IterTy>
+/// Can optionally take a predicate to lazily filter some items.
+template <typename IterTy,
+          typename Pred = bool (*)(const decltype(*std::declval<IterTy>()) &)>
 bool hasNItemsOrMore(
     IterTy &&Begin, IterTy &&End, unsigned N,
-    typename std::enable_if<
-        !std::is_same<
-            typename std::iterator_traits<typename std::remove_reference<
-                decltype(Begin)>::type>::iterator_category,
-            std::random_access_iterator_tag>::value,
-        void>::type * = nullptr) {
-  for (; N; --N, ++Begin)
+    Pred &&ShouldBeCounted =
+        [](const decltype(*std::declval<IterTy>()) &) { return true; },
+    std::enable_if_t<
+        !std::is_base_of<std::random_access_iterator_tag,
+                         typename std::iterator_traits<std::remove_reference_t<
+                             decltype(Begin)>>::iterator_category>::value,
+        void> * = nullptr) {
+  for (; N; ++Begin) {
     if (Begin == End)
       return false; // Too few.
+    N -= ShouldBeCounted(*Begin);
+  }
   return true;
 }
 
+/// Returns true if the sequence [Begin, End) has N or less items. Can
+/// optionally take a predicate to lazily filter some items.
+template <typename IterTy,
+          typename Pred = bool (*)(const decltype(*std::declval<IterTy>()) &)>
+bool hasNItemsOrLess(
+    IterTy &&Begin, IterTy &&End, unsigned N,
+    Pred &&ShouldBeCounted = [](const decltype(*std::declval<IterTy>()) &) {
+      return true;
+    }) {
+  assert(N != std::numeric_limits<unsigned>::max());
+  return !hasNItemsOrMore(Begin, End, N + 1, ShouldBeCounted);
+}
+
+/// Returns true if the given container has exactly N items
+template <typename ContainerTy> bool hasNItems(ContainerTy &&C, unsigned N) {
+  return hasNItems(std::begin(C), std::end(C), N);
+}
+
+/// Returns true if the given container has N or more items
+template <typename ContainerTy>
+bool hasNItemsOrMore(ContainerTy &&C, unsigned N) {
+  return hasNItemsOrMore(std::begin(C), std::end(C), N);
+}
+
+/// Returns true if the given container has N or less items
+template <typename ContainerTy>
+bool hasNItemsOrLess(ContainerTy &&C, unsigned N) {
+  return hasNItemsOrLess(std::begin(C), std::end(C), N);
+}
+
 /// Returns a raw pointer that represents the same address as the argument.
 ///
-/// The late bound return should be removed once we move to C++14 to better
-/// align with the C++20 declaration. Also, this implementation can be removed
-/// once we move to C++20 where it's defined as std::to_addres()
+/// This implementation can be removed once we move to C++20 where it's defined
+/// as std::to_address().
 ///
 /// The std::pointer_traits<>::to_address(p) variations of these overloads has
 /// not been implemented.
-template <class Ptr> auto to_address(const Ptr &P) -> decltype(P.operator->()) {
-  return P.operator->();
-}
+template <class Ptr> auto to_address(const Ptr &P) { return P.operator->(); }
 template <class T> constexpr T *to_address(T *P) { return P; }
 
 } // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/ADT/ScopedHashTable.h b/linux-x64/clang/include/llvm/ADT/ScopedHashTable.h
index 40c49eb..a5e57c6 100644
--- a/linux-x64/clang/include/llvm/ADT/ScopedHashTable.h
+++ b/linux-x64/clang/include/llvm/ADT/ScopedHashTable.h
@@ -32,7 +32,7 @@
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseMapInfo.h"
-#include "llvm/Support/Allocator.h"
+#include "llvm/Support/AllocatorBase.h"
 #include <cassert>
 #include <new>
 
diff --git a/linux-x64/clang/include/llvm/ADT/Sequence.h b/linux-x64/clang/include/llvm/ADT/Sequence.h
index 8c505f2..8a695d7 100644
--- a/linux-x64/clang/include/llvm/ADT/Sequence.h
+++ b/linux-x64/clang/include/llvm/ADT/Sequence.h
@@ -42,6 +42,10 @@
   value_sequence_iterator(const value_sequence_iterator &) = default;
   value_sequence_iterator(value_sequence_iterator &&Arg)
       : Value(std::move(Arg.Value)) {}
+  value_sequence_iterator &operator=(const value_sequence_iterator &Arg) {
+    Value = Arg.Value;
+    return *this;
+  }
 
   template <typename U, typename Enabler = decltype(ValueT(std::declval<U>()))>
   value_sequence_iterator(U &&Value) : Value(std::forward<U>(Value)) {}
diff --git a/linux-x64/clang/include/llvm/ADT/SetOperations.h b/linux-x64/clang/include/llvm/ADT/SetOperations.h
index 037256a..6087f47 100644
--- a/linux-x64/clang/include/llvm/ADT/SetOperations.h
+++ b/linux-x64/clang/include/llvm/ADT/SetOperations.h
@@ -65,6 +65,27 @@
     S1.erase(*SI);
 }
 
+/// set_is_subset(A, B) - Return true iff A in B
+///
+template <class S1Ty, class S2Ty>
+bool set_is_subset(const S1Ty &S1, const S2Ty &S2) {
+  if (S1.size() > S2.size())
+    return false;
+  for (auto &It : S1)
+    if (!S2.count(It))
+      return false;
+  return true;
+}
+
+/// set_is_strict_subset(A, B) - Return true iff A in B and and A != B
+///
+template <class S1Ty, class S2Ty>
+bool set_is_strict_subset(const S1Ty &S1, const S2Ty &S2) {
+  if (S1.size() >= S2.size())
+    return false;
+  return set_is_subset(S1, S2);
+}
+
 } // End llvm namespace
 
 #endif
diff --git a/linux-x64/clang/include/llvm/ADT/SetVector.h b/linux-x64/clang/include/llvm/ADT/SetVector.h
index d0a0d28..32bcd50 100644
--- a/linux-x64/clang/include/llvm/ADT/SetVector.h
+++ b/linux-x64/clang/include/llvm/ADT/SetVector.h
@@ -174,7 +174,7 @@
     set_.erase(V);
 
     // FIXME: No need to use the non-const iterator when built with
-    // std:vector.erase(const_iterator) as defined in C++11. This is for
+    // std::vector.erase(const_iterator) as defined in C++11. This is for
     // compatibility with non-standard libstdc++ up to 4.8 (fixed in 4.9).
     auto NI = vector_.begin();
     std::advance(NI, std::distance<iterator>(NI, I));
@@ -205,6 +205,11 @@
     return true;
   }
 
+  /// Check if the SetVector contains the given key.
+  bool contains(const key_type &key) const {
+    return set_.find(key) != set_.end();
+  }
+
   /// Count the number of elements of a given key in the SetVector.
   /// \returns 0 if the element is not in the SetVector, 1 if it is.
   size_type count(const key_type &key) const {
@@ -263,6 +268,11 @@
       remove(*SI);
   }
 
+  void swap(SetVector<T, Vector, Set> &RHS) {
+    set_.swap(RHS.set_);
+    vector_.swap(RHS.vector_);
+  }
+
 private:
   /// A wrapper predicate designed for use with std::remove_if.
   ///
@@ -308,4 +318,22 @@
 
 } // end namespace llvm
 
+namespace std {
+
+/// Implement std::swap in terms of SetVector swap.
+template<typename T, typename V, typename S>
+inline void
+swap(llvm::SetVector<T, V, S> &LHS, llvm::SetVector<T, V, S> &RHS) {
+  LHS.swap(RHS);
+}
+
+/// Implement std::swap in terms of SmallSetVector swap.
+template<typename T, unsigned N>
+inline void
+swap(llvm::SmallSetVector<T, N> &LHS, llvm::SmallSetVector<T, N> &RHS) {
+  LHS.swap(RHS);
+}
+
+} // end namespace std
+
 #endif // LLVM_ADT_SETVECTOR_H
diff --git a/linux-x64/clang/include/llvm/ADT/SmallBitVector.h b/linux-x64/clang/include/llvm/ADT/SmallBitVector.h
index 742450e..f570bac 100644
--- a/linux-x64/clang/include/llvm/ADT/SmallBitVector.h
+++ b/linux-x64/clang/include/llvm/ADT/SmallBitVector.h
@@ -287,11 +287,11 @@
   /// Returns -1 if the next unset bit is not found.
   int find_next_unset(unsigned Prev) const {
     if (isSmall()) {
-      ++Prev;
       uintptr_t Bits = getSmallBits();
       // Mask in previous bits.
-      uintptr_t Mask = (1 << Prev) - 1;
-      Bits |= Mask;
+      Bits |= (uintptr_t(1) << (Prev + 1)) - 1;
+      // Mask in unused bits.
+      Bits |= ~uintptr_t(0) << getSmallSize();
 
       if (Bits == ~uintptr_t(0) || Prev + 1 >= getSmallSize())
         return -1;
@@ -662,6 +662,19 @@
       getPointer()->clearBitsNotInMask(Mask, MaskWords);
   }
 
+  void invalid() {
+    assert(empty());
+    X = (uintptr_t)-1;
+  }
+  bool isInvalid() const { return X == (uintptr_t)-1; }
+
+  ArrayRef<uintptr_t> getData(uintptr_t &Store) const {
+    if (!isSmall())
+      return getPointer()->getData();
+    Store = getSmallBits();
+    return makeArrayRef(Store);
+  }
+
 private:
   template <bool AddBits, bool InvertMask>
   void applyMask(const uint32_t *Mask, unsigned MaskWords) {
@@ -699,6 +712,24 @@
   return Result;
 }
 
+template <> struct DenseMapInfo<SmallBitVector> {
+  static inline SmallBitVector getEmptyKey() { return SmallBitVector(); }
+  static inline SmallBitVector getTombstoneKey() {
+    SmallBitVector V;
+    V.invalid();
+    return V;
+  }
+  static unsigned getHashValue(const SmallBitVector &V) {
+    uintptr_t Store;
+    return DenseMapInfo<std::pair<unsigned, ArrayRef<uintptr_t>>>::getHashValue(
+        std::make_pair(V.size(), V.getData(Store)));
+  }
+  static bool isEqual(const SmallBitVector &LHS, const SmallBitVector &RHS) {
+    if (LHS.isInvalid() || RHS.isInvalid())
+      return LHS.isInvalid() == RHS.isInvalid();
+    return LHS == RHS;
+  }
+};
 } // end namespace llvm
 
 namespace std {
diff --git a/linux-x64/clang/include/llvm/ADT/SmallPtrSet.h b/linux-x64/clang/include/llvm/ADT/SmallPtrSet.h
index 9135182..57dd8f6 100644
--- a/linux-x64/clang/include/llvm/ADT/SmallPtrSet.h
+++ b/linux-x64/clang/include/llvm/ADT/SmallPtrSet.h
@@ -278,7 +278,7 @@
                                const DebugEpochBase &Epoch)
       : SmallPtrSetIteratorImpl(BP, E), DebugEpochBase::HandleBase(&Epoch) {}
 
-  // Most methods provided by baseclass.
+  // Most methods are provided by the base class.
 
   const PtrTy operator*() const {
     assert(isHandleInSync() && "invalid iterator access!");
@@ -346,14 +346,8 @@
   using ConstPtrTraits = PointerLikeTypeTraits<ConstPtrType>;
 
 protected:
-  // Constructors that forward to the base.
-  SmallPtrSetImpl(const void **SmallStorage, const SmallPtrSetImpl &that)
-      : SmallPtrSetImplBase(SmallStorage, that) {}
-  SmallPtrSetImpl(const void **SmallStorage, unsigned SmallSize,
-                  SmallPtrSetImpl &&that)
-      : SmallPtrSetImplBase(SmallStorage, SmallSize, std::move(that)) {}
-  explicit SmallPtrSetImpl(const void **SmallStorage, unsigned SmallSize)
-      : SmallPtrSetImplBase(SmallStorage, SmallSize) {}
+  // Forward constructors to the base.
+  using SmallPtrSetImplBase::SmallPtrSetImplBase;
 
 public:
   using iterator = SmallPtrSetIterator<PtrType>;
@@ -378,10 +372,15 @@
     return erase_imp(PtrTraits::getAsVoidPointer(Ptr));
   }
   /// count - Return 1 if the specified pointer is in the set, 0 otherwise.
-  size_type count(ConstPtrType Ptr) const { return find(Ptr) != end() ? 1 : 0; }
+  size_type count(ConstPtrType Ptr) const {
+    return find_imp(ConstPtrTraits::getAsVoidPointer(Ptr)) != EndPointer();
+  }
   iterator find(ConstPtrType Ptr) const {
     return makeIterator(find_imp(ConstPtrTraits::getAsVoidPointer(Ptr)));
   }
+  bool contains(ConstPtrType Ptr) const {
+    return find_imp(ConstPtrTraits::getAsVoidPointer(Ptr)) != EndPointer();
+  }
 
   template <typename IterT>
   void insert(IterT I, IterT E) {
@@ -409,6 +408,32 @@
   }
 };
 
+/// Equality comparison for SmallPtrSet.
+///
+/// Iterates over elements of LHS confirming that each value from LHS is also in
+/// RHS, and that no additional values are in RHS.
+template <typename PtrType>
+bool operator==(const SmallPtrSetImpl<PtrType> &LHS,
+                const SmallPtrSetImpl<PtrType> &RHS) {
+  if (LHS.size() != RHS.size())
+    return false;
+
+  for (const auto *KV : LHS)
+    if (!RHS.count(KV))
+      return false;
+
+  return true;
+}
+
+/// Inequality comparison for SmallPtrSet.
+///
+/// Equivalent to !(LHS == RHS).
+template <typename PtrType>
+bool operator!=(const SmallPtrSetImpl<PtrType> &LHS,
+                const SmallPtrSetImpl<PtrType> &RHS) {
+  return !(LHS == RHS);
+}
+
 /// SmallPtrSet - This class implements a set which is optimized for holding
 /// SmallSize or less elements.  This internally rounds up SmallSize to the next
 /// power of two if it is not already a power of two.  See the comments above
diff --git a/linux-x64/clang/include/llvm/ADT/SmallSet.h b/linux-x64/clang/include/llvm/ADT/SmallSet.h
index 6b128c2..0600e52 100644
--- a/linux-x64/clang/include/llvm/ADT/SmallSet.h
+++ b/linux-x64/clang/include/llvm/ADT/SmallSet.h
@@ -232,6 +232,13 @@
     return {Set.end()};
   }
 
+  /// Check if the SmallSet contains the given element.
+  bool contains(const T &V) const {
+    if (isSmall())
+      return vfind(V) != Vector.end();
+    return Set.find(V) != Set.end();
+  }
+
 private:
   bool isSmall() const { return Set.empty(); }
 
@@ -248,6 +255,31 @@
 template <typename PointeeType, unsigned N>
 class SmallSet<PointeeType*, N> : public SmallPtrSet<PointeeType*, N> {};
 
+/// Equality comparison for SmallSet.
+///
+/// Iterates over elements of LHS confirming that each element is also a member
+/// of RHS, and that RHS contains no additional values.
+/// Equivalent to N calls to RHS.count.
+/// For small-set mode amortized complexity is O(N^2)
+/// For large-set mode amortized complexity is linear, worst case is O(N^2) (if
+/// every hash collides).
+template <typename T, unsigned LN, unsigned RN, typename C>
+bool operator==(const SmallSet<T, LN, C> &LHS, const SmallSet<T, RN, C> &RHS) {
+  if (LHS.size() != RHS.size())
+    return false;
+
+  // All elements in LHS must also be in RHS
+  return all_of(LHS, [&RHS](const T &E) { return RHS.count(E); });
+}
+
+/// Inequality comparison for SmallSet.
+///
+/// Equivalent to !(LHS == RHS). See operator== for performance notes.
+template <typename T, unsigned LN, unsigned RN, typename C>
+bool operator!=(const SmallSet<T, LN, C> &LHS, const SmallSet<T, RN, C> &RHS) {
+  return !(LHS == RHS);
+}
+
 } // end namespace llvm
 
 #endif // LLVM_ADT_SMALLSET_H
diff --git a/linux-x64/clang/include/llvm/ADT/SmallString.h b/linux-x64/clang/include/llvm/ADT/SmallString.h
index 898be80..c0e8fcd 100644
--- a/linux-x64/clang/include/llvm/ADT/SmallString.h
+++ b/linux-x64/clang/include/llvm/ADT/SmallString.h
@@ -30,6 +30,12 @@
   /// Initialize from a StringRef.
   SmallString(StringRef S) : SmallVector<char, InternalLen>(S.begin(), S.end()) {}
 
+  /// Initialize by concatenating a list of StringRefs.
+  SmallString(std::initializer_list<StringRef> Refs)
+      : SmallVector<char, InternalLen>() {
+    this->append(Refs);
+  }
+
   /// Initialize with a range.
   template<typename ItTy>
   SmallString(ItTy S, ItTy E) : SmallVector<char, InternalLen>(S, E) {}
@@ -65,6 +71,12 @@
     SmallVectorImpl<char>::append(RHS.begin(), RHS.end());
   }
 
+  /// Assign from a list of StringRefs.
+  void assign(std::initializer_list<StringRef> Refs) {
+    this->clear();
+    append(Refs);
+  }
+
   /// @}
   /// @name String Concatenation
   /// @{
@@ -89,6 +101,20 @@
     SmallVectorImpl<char>::append(RHS.begin(), RHS.end());
   }
 
+  /// Append from a list of StringRefs.
+  void append(std::initializer_list<StringRef> Refs) {
+    size_t SizeNeeded = this->size();
+    for (const StringRef &Ref : Refs)
+      SizeNeeded += Ref.size();
+    this->reserve(SizeNeeded);
+    auto CurEnd = this->end();
+    for (const StringRef &Ref : Refs) {
+      this->uninitialized_copy(Ref.begin(), Ref.end(), CurEnd);
+      CurEnd += Ref.size();
+    }
+    this->set_size(SizeNeeded);
+  }
+
   /// @}
   /// @name String Comparison
   /// @{
@@ -263,7 +289,7 @@
   // Extra methods.
 
   /// Explicit conversion to StringRef.
-  StringRef str() const { return StringRef(this->begin(), this->size()); }
+  StringRef str() const { return StringRef(this->data(), this->size()); }
 
   // TODO: Make this const, if it's safe...
   const char* c_str() {
@@ -275,10 +301,14 @@
   /// Implicit conversion to StringRef.
   operator StringRef() const { return str(); }
 
+  explicit operator std::string() const {
+    return std::string(this->data(), this->size());
+  }
+
   // Extra operators.
-  const SmallString &operator=(StringRef RHS) {
-    this->clear();
-    return *this += RHS;
+  SmallString &operator=(StringRef RHS) {
+    this->assign(RHS);
+    return *this;
   }
 
   SmallString &operator+=(StringRef RHS) {
diff --git a/linux-x64/clang/include/llvm/ADT/SmallVector.h b/linux-x64/clang/include/llvm/ADT/SmallVector.h
index 1758690..2e47846 100644
--- a/linux-x64/clang/include/llvm/ADT/SmallVector.h
+++ b/linux-x64/clang/include/llvm/ADT/SmallVector.h
@@ -14,12 +14,11 @@
 #define LLVM_ADT_SMALLVECTOR_H
 
 #include "llvm/ADT/iterator_range.h"
-#include "llvm/Support/AlignOf.h"
 #include "llvm/Support/Compiler.h"
+#include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/MemAlloc.h"
 #include "llvm/Support/type_traits.h"
-#include "llvm/Support/ErrorHandling.h"
 #include <algorithm>
 #include <cassert>
 #include <cstddef>
@@ -27,6 +26,7 @@
 #include <cstring>
 #include <initializer_list>
 #include <iterator>
+#include <limits>
 #include <memory>
 #include <new>
 #include <type_traits>
@@ -34,11 +34,23 @@
 
 namespace llvm {
 
-/// This is all the non-templated stuff common to all SmallVectors.
-class SmallVectorBase {
+/// This is all the stuff common to all SmallVectors.
+///
+/// The template parameter specifies the type which should be used to hold the
+/// Size and Capacity of the SmallVector, so it can be adjusted.
+/// Using 32 bit size is desirable to shrink the size of the SmallVector.
+/// Using 64 bit size is desirable for cases like SmallVector<char>, where a
+/// 32 bit size would limit the vector to ~4GB. SmallVectors are used for
+/// buffering bitcode output - which can exceed 4GB.
+template <class Size_T> class SmallVectorBase {
 protected:
   void *BeginX;
-  unsigned Size = 0, Capacity;
+  Size_T Size = 0, Capacity;
+
+  /// The maximum value of the Size_T used.
+  static constexpr size_t SizeTypeMax() {
+    return std::numeric_limits<Size_T>::max();
+  }
 
   SmallVectorBase() = delete;
   SmallVectorBase(void *FirstEl, size_t TotalCapacity)
@@ -46,7 +58,15 @@
 
   /// This is an implementation of the grow() method which only works
   /// on POD-like data types and is out of line to reduce code duplication.
-  void grow_pod(void *FirstEl, size_t MinCapacity, size_t TSize);
+  /// This function will report a fatal error if it cannot increase capacity.
+  void grow_pod(void *FirstEl, size_t MinSize, size_t TSize);
+
+  /// Report that MinSize doesn't fit into this vector's size type. Throws
+  /// std::length_error or calls report_fatal_error.
+  LLVM_ATTRIBUTE_NORETURN static void report_size_overflow(size_t MinSize);
+  /// Report that this vector is already at maximum capacity. Throws
+  /// std::length_error or calls report_fatal_error.
+  LLVM_ATTRIBUTE_NORETURN static void report_at_maximum_capacity();
 
 public:
   size_t size() const { return Size; }
@@ -69,17 +89,26 @@
   }
 };
 
+template <class T>
+using SmallVectorSizeType =
+    typename std::conditional<sizeof(T) < 4 && sizeof(void *) >= 8, uint64_t,
+                              uint32_t>::type;
+
 /// Figure out the offset of the first element.
 template <class T, typename = void> struct SmallVectorAlignmentAndSize {
-  AlignedCharArrayUnion<SmallVectorBase> Base;
-  AlignedCharArrayUnion<T> FirstEl;
+  alignas(SmallVectorBase<SmallVectorSizeType<T>>) char Base[sizeof(
+      SmallVectorBase<SmallVectorSizeType<T>>)];
+  alignas(T) char FirstEl[sizeof(T)];
 };
 
 /// This is the part of SmallVectorTemplateBase which does not depend on whether
 /// the type T is a POD. The extra dummy template argument is used by ArrayRef
 /// to avoid unnecessarily requiring T to be complete.
 template <typename T, typename = void>
-class SmallVectorTemplateCommon : public SmallVectorBase {
+class SmallVectorTemplateCommon
+    : public SmallVectorBase<SmallVectorSizeType<T>> {
+  using Base = SmallVectorBase<SmallVectorSizeType<T>>;
+
   /// Find the address of the first element.  For this pointer math to be valid
   /// with small-size of 0 for T with lots of alignment, it's important that
   /// SmallVectorStorage is properly-aligned even for small-size of 0.
@@ -91,21 +120,125 @@
   // Space after 'FirstEl' is clobbered, do not add any instance vars after it.
 
 protected:
-  SmallVectorTemplateCommon(size_t Size)
-      : SmallVectorBase(getFirstEl(), Size) {}
+  SmallVectorTemplateCommon(size_t Size) : Base(getFirstEl(), Size) {}
 
-  void grow_pod(size_t MinCapacity, size_t TSize) {
-    SmallVectorBase::grow_pod(getFirstEl(), MinCapacity, TSize);
+  void grow_pod(size_t MinSize, size_t TSize) {
+    Base::grow_pod(getFirstEl(), MinSize, TSize);
   }
 
   /// Return true if this is a smallvector which has not had dynamic
   /// memory allocated for it.
-  bool isSmall() const { return BeginX == getFirstEl(); }
+  bool isSmall() const { return this->BeginX == getFirstEl(); }
 
   /// Put this vector in a state of being small.
   void resetToSmall() {
-    BeginX = getFirstEl();
-    Size = Capacity = 0; // FIXME: Setting Capacity to 0 is suspect.
+    this->BeginX = getFirstEl();
+    this->Size = this->Capacity = 0; // FIXME: Setting Capacity to 0 is suspect.
+  }
+
+  /// Return true if V is an internal reference to the given range.
+  bool isReferenceToRange(const void *V, const void *First, const void *Last) const {
+    // Use std::less to avoid UB.
+    std::less<> LessThan;
+    return !LessThan(V, First) && LessThan(V, Last);
+  }
+
+  /// Return true if V is an internal reference to this vector.
+  bool isReferenceToStorage(const void *V) const {
+    return isReferenceToRange(V, this->begin(), this->end());
+  }
+
+  /// Return true if First and Last form a valid (possibly empty) range in this
+  /// vector's storage.
+  bool isRangeInStorage(const void *First, const void *Last) const {
+    // Use std::less to avoid UB.
+    std::less<> LessThan;
+    return !LessThan(First, this->begin()) && !LessThan(Last, First) &&
+           !LessThan(this->end(), Last);
+  }
+
+  /// Return true unless Elt will be invalidated by resizing the vector to
+  /// NewSize.
+  bool isSafeToReferenceAfterResize(const void *Elt, size_t NewSize) {
+    // Past the end.
+    if (LLVM_LIKELY(!isReferenceToStorage(Elt)))
+      return true;
+
+    // Return false if Elt will be destroyed by shrinking.
+    if (NewSize <= this->size())
+      return Elt < this->begin() + NewSize;
+
+    // Return false if we need to grow.
+    return NewSize <= this->capacity();
+  }
+
+  /// Check whether Elt will be invalidated by resizing the vector to NewSize.
+  void assertSafeToReferenceAfterResize(const void *Elt, size_t NewSize) {
+    assert(isSafeToReferenceAfterResize(Elt, NewSize) &&
+           "Attempting to reference an element of the vector in an operation "
+           "that invalidates it");
+  }
+
+  /// Check whether Elt will be invalidated by increasing the size of the
+  /// vector by N.
+  void assertSafeToAdd(const void *Elt, size_t N = 1) {
+    this->assertSafeToReferenceAfterResize(Elt, this->size() + N);
+  }
+
+  /// Check whether any part of the range will be invalidated by clearing.
+  void assertSafeToReferenceAfterClear(const T *From, const T *To) {
+    if (From == To)
+      return;
+    this->assertSafeToReferenceAfterResize(From, 0);
+    this->assertSafeToReferenceAfterResize(To - 1, 0);
+  }
+  template <
+      class ItTy,
+      std::enable_if_t<!std::is_same<std::remove_const_t<ItTy>, T *>::value,
+                       bool> = false>
+  void assertSafeToReferenceAfterClear(ItTy, ItTy) {}
+
+  /// Check whether any part of the range will be invalidated by growing.
+  void assertSafeToAddRange(const T *From, const T *To) {
+    if (From == To)
+      return;
+    this->assertSafeToAdd(From, To - From);
+    this->assertSafeToAdd(To - 1, To - From);
+  }
+  template <
+      class ItTy,
+      std::enable_if_t<!std::is_same<std::remove_const_t<ItTy>, T *>::value,
+                       bool> = false>
+  void assertSafeToAddRange(ItTy, ItTy) {}
+
+  /// Check whether any argument will be invalidated by growing for
+  /// emplace_back.
+  template <class ArgType1, class... ArgTypes>
+  void assertSafeToEmplace(ArgType1 &Arg1, ArgTypes &... Args) {
+    this->assertSafeToAdd(&Arg1);
+    this->assertSafeToEmplace(Args...);
+  }
+  void assertSafeToEmplace() {}
+
+  /// Reserve enough space to add one element, and return the updated element
+  /// pointer in case it was a reference to the storage.
+  template <class U>
+  static const T *reserveForParamAndGetAddressImpl(U *This, const T &Elt,
+                                                   size_t N) {
+    size_t NewSize = This->size() + N;
+    if (LLVM_LIKELY(NewSize <= This->capacity()))
+      return &Elt;
+
+    bool ReferencesStorage = false;
+    int64_t Index = -1;
+    if (!U::TakesParamByValue) {
+      if (LLVM_UNLIKELY(This->isReferenceToStorage(&Elt))) {
+        ReferencesStorage = true;
+        Index = &Elt - This->begin();
+      }
+    }
+    This->grow(NewSize);
+    return ReferencesStorage ? This->begin() + Index : &Elt;
   }
 
 public:
@@ -123,6 +256,10 @@
   using pointer = T *;
   using const_pointer = const T *;
 
+  using Base::capacity;
+  using Base::empty;
+  using Base::size;
+
   // forward iterator creation methods.
   iterator begin() { return (iterator)this->BeginX; }
   const_iterator begin() const { return (const_iterator)this->BeginX; }
@@ -136,7 +273,9 @@
   const_reverse_iterator rend() const { return const_reverse_iterator(begin());}
 
   size_type size_in_bytes() const { return size() * sizeof(T); }
-  size_type max_size() const { return size_type(-1) / sizeof(T); }
+  size_type max_size() const {
+    return std::min(this->SizeTypeMax(), size_type(-1) / sizeof(T));
+  }
 
   size_t capacity_in_bytes() const { return capacity() * sizeof(T); }
 
@@ -173,11 +312,24 @@
   }
 };
 
-/// SmallVectorTemplateBase<TriviallyCopyable = false> - This is where we put method
-/// implementations that are designed to work with non-POD-like T's.
-template <typename T, bool = is_trivially_copyable<T>::value>
+/// SmallVectorTemplateBase<TriviallyCopyable = false> - This is where we put
+/// method implementations that are designed to work with non-trivial T's.
+///
+/// We approximate is_trivially_copyable with trivial move/copy construction and
+/// trivial destruction. While the standard doesn't specify that you're allowed
+/// copy these types with memcpy, there is no way for the type to observe this.
+/// This catches the important case of std::pair<POD, POD>, which is not
+/// trivially assignable.
+template <typename T, bool = (is_trivially_copy_constructible<T>::value) &&
+                             (is_trivially_move_constructible<T>::value) &&
+                             std::is_trivially_destructible<T>::value>
 class SmallVectorTemplateBase : public SmallVectorTemplateCommon<T> {
+  friend class SmallVectorTemplateCommon<T>;
+
 protected:
+  static constexpr bool TakesParamByValue = false;
+  using ValueParamT = const T &;
+
   SmallVectorTemplateBase(size_t Size) : SmallVectorTemplateCommon<T>(Size) {}
 
   static void destroy_range(T *S, T *E) {
@@ -207,18 +359,32 @@
   /// element, or MinSize more elements if specified.
   void grow(size_t MinSize = 0);
 
+  /// Reserve enough space to add one element, and return the updated element
+  /// pointer in case it was a reference to the storage.
+  const T *reserveForParamAndGetAddress(const T &Elt, size_t N = 1) {
+    return this->reserveForParamAndGetAddressImpl(this, Elt, N);
+  }
+
+  /// Reserve enough space to add one element, and return the updated element
+  /// pointer in case it was a reference to the storage.
+  T *reserveForParamAndGetAddress(T &Elt, size_t N = 1) {
+    return const_cast<T *>(
+        this->reserveForParamAndGetAddressImpl(this, Elt, N));
+  }
+
+  static T &&forward_value_param(T &&V) { return std::move(V); }
+  static const T &forward_value_param(const T &V) { return V; }
+
 public:
   void push_back(const T &Elt) {
-    if (LLVM_UNLIKELY(this->size() >= this->capacity()))
-      this->grow();
-    ::new ((void*) this->end()) T(Elt);
+    const T *EltPtr = reserveForParamAndGetAddress(Elt);
+    ::new ((void *)this->end()) T(*EltPtr);
     this->set_size(this->size() + 1);
   }
 
   void push_back(T &&Elt) {
-    if (LLVM_UNLIKELY(this->size() >= this->capacity()))
-      this->grow();
-    ::new ((void*) this->end()) T(::std::move(Elt));
+    T *EltPtr = reserveForParamAndGetAddress(Elt);
+    ::new ((void *)this->end()) T(::std::move(*EltPtr));
     this->set_size(this->size() + 1);
   }
 
@@ -231,12 +397,21 @@
 // Define this out-of-line to dissuade the C++ compiler from inlining it.
 template <typename T, bool TriviallyCopyable>
 void SmallVectorTemplateBase<T, TriviallyCopyable>::grow(size_t MinSize) {
-  if (MinSize > UINT32_MAX)
-    report_bad_alloc_error("SmallVector capacity overflow during allocation");
+  // Ensure we can fit the new capacity.
+  // This is only going to be applicable when the capacity is 32 bit.
+  if (MinSize > this->SizeTypeMax())
+    this->report_size_overflow(MinSize);
+
+  // Ensure we can meet the guarantee of space for at least one more element.
+  // The above check alone will not catch the case where grow is called with a
+  // default MinSize of 0, but the current capacity cannot be increased.
+  // This is only going to be applicable when the capacity is 32 bit.
+  if (this->capacity() == this->SizeTypeMax())
+    this->report_at_maximum_capacity();
 
   // Always grow, even from zero.
   size_t NewCapacity = size_t(NextPowerOf2(this->capacity() + 2));
-  NewCapacity = std::min(std::max(NewCapacity, MinSize), size_t(UINT32_MAX));
+  NewCapacity = std::min(std::max(NewCapacity, MinSize), this->SizeTypeMax());
   T *NewElts = static_cast<T*>(llvm::safe_malloc(NewCapacity*sizeof(T)));
 
   // Move the elements over.
@@ -254,10 +429,23 @@
 }
 
 /// SmallVectorTemplateBase<TriviallyCopyable = true> - This is where we put
-/// method implementations that are designed to work with POD-like T's.
+/// method implementations that are designed to work with trivially copyable
+/// T's. This allows using memcpy in place of copy/move construction and
+/// skipping destruction.
 template <typename T>
 class SmallVectorTemplateBase<T, true> : public SmallVectorTemplateCommon<T> {
+  friend class SmallVectorTemplateCommon<T>;
+
 protected:
+  /// True if it's cheap enough to take parameters by value. Doing so avoids
+  /// overhead related to mitigations for reference invalidation.
+  static constexpr bool TakesParamByValue = sizeof(T) <= 2 * sizeof(void *);
+
+  /// Either const T& or T, depending on whether it's cheap enough to take
+  /// parameters by value.
+  using ValueParamT =
+      typename std::conditional<TakesParamByValue, T, const T &>::type;
+
   SmallVectorTemplateBase(size_t Size) : SmallVectorTemplateCommon<T>(Size) {}
 
   // No need to do a destroy loop for POD's.
@@ -284,8 +472,8 @@
   template <typename T1, typename T2>
   static void uninitialized_copy(
       T1 *I, T1 *E, T2 *Dest,
-      typename std::enable_if<std::is_same<typename std::remove_const<T1>::type,
-                                           T2>::value>::type * = nullptr) {
+      std::enable_if_t<std::is_same<typename std::remove_const<T1>::type,
+                                    T2>::value> * = nullptr) {
     // Use memcpy for PODs iterated by pointers (which includes SmallVector
     // iterators): std::uninitialized_copy optimizes to memmove, but we can
     // use memcpy here. Note that I and E are iterators and thus might be
@@ -298,11 +486,26 @@
   /// least one more element or MinSize if specified.
   void grow(size_t MinSize = 0) { this->grow_pod(MinSize, sizeof(T)); }
 
+  /// Reserve enough space to add one element, and return the updated element
+  /// pointer in case it was a reference to the storage.
+  const T *reserveForParamAndGetAddress(const T &Elt, size_t N = 1) {
+    return this->reserveForParamAndGetAddressImpl(this, Elt, N);
+  }
+
+  /// Reserve enough space to add one element, and return the updated element
+  /// pointer in case it was a reference to the storage.
+  T *reserveForParamAndGetAddress(T &Elt, size_t N = 1) {
+    return const_cast<T *>(
+        this->reserveForParamAndGetAddressImpl(this, Elt, N));
+  }
+
+  /// Copy \p V or return a reference, depending on \a ValueParamT.
+  static ValueParamT forward_value_param(ValueParamT V) { return V; }
+
 public:
-  void push_back(const T &Elt) {
-    if (LLVM_UNLIKELY(this->size() >= this->capacity()))
-      this->grow();
-    memcpy(reinterpret_cast<void *>(this->end()), &Elt, sizeof(T));
+  void push_back(ValueParamT Elt) {
+    const T *EltPtr = reserveForParamAndGetAddress(Elt);
+    memcpy(reinterpret_cast<void *>(this->end()), EltPtr, sizeof(T));
     this->set_size(this->size() + 1);
   }
 
@@ -322,6 +525,9 @@
   using size_type = typename SuperClass::size_type;
 
 protected:
+  using SmallVectorTemplateBase<T>::TakesParamByValue;
+  using ValueParamT = typename SuperClass::ValueParamT;
+
   // Default ctor - Initialize to empty.
   explicit SmallVectorImpl(unsigned N)
       : SmallVectorTemplateBase<T>(N) {}
@@ -341,29 +547,38 @@
     this->Size = 0;
   }
 
-  void resize(size_type N) {
+private:
+  template <bool ForOverwrite> void resizeImpl(size_type N) {
     if (N < this->size()) {
-      this->destroy_range(this->begin()+N, this->end());
-      this->set_size(N);
+      this->pop_back_n(this->size() - N);
     } else if (N > this->size()) {
-      if (this->capacity() < N)
-        this->grow(N);
+      this->reserve(N);
       for (auto I = this->end(), E = this->begin() + N; I != E; ++I)
-        new (&*I) T();
+        if (ForOverwrite)
+          new (&*I) T;
+        else
+          new (&*I) T();
       this->set_size(N);
     }
   }
 
-  void resize(size_type N, const T &NV) {
+public:
+  void resize(size_type N) { resizeImpl<false>(N); }
+
+  /// Like resize, but \ref T is POD, the new values won't be initialized.
+  void resize_for_overwrite(size_type N) { resizeImpl<true>(N); }
+
+  void resize(size_type N, ValueParamT NV) {
+    if (N == this->size())
+      return;
+
     if (N < this->size()) {
-      this->destroy_range(this->begin()+N, this->end());
-      this->set_size(N);
-    } else if (N > this->size()) {
-      if (this->capacity() < N)
-        this->grow(N);
-      std::uninitialized_fill(this->end(), this->begin()+N, NV);
-      this->set_size(N);
+      this->pop_back_n(this->size() - N);
+      return;
     }
+
+    // N > this->size(). Defer to append.
+    this->append(N - this->size(), NV);
   }
 
   void reserve(size_type N) {
@@ -371,6 +586,12 @@
       this->grow(N);
   }
 
+  void pop_back_n(size_type NumItems) {
+    assert(this->size() >= NumItems);
+    this->destroy_range(this->end() - NumItems, this->end());
+    this->set_size(this->size() - NumItems);
+  }
+
   LLVM_NODISCARD T pop_back_val() {
     T Result = ::std::move(this->back());
     this->pop_back();
@@ -381,24 +602,21 @@
 
   /// Add the specified range to the end of the SmallVector.
   template <typename in_iter,
-            typename = typename std::enable_if<std::is_convertible<
+            typename = std::enable_if_t<std::is_convertible<
                 typename std::iterator_traits<in_iter>::iterator_category,
-                std::input_iterator_tag>::value>::type>
+                std::input_iterator_tag>::value>>
   void append(in_iter in_start, in_iter in_end) {
+    this->assertSafeToAddRange(in_start, in_end);
     size_type NumInputs = std::distance(in_start, in_end);
-    if (NumInputs > this->capacity() - this->size())
-      this->grow(this->size()+NumInputs);
-
+    this->reserve(this->size() + NumInputs);
     this->uninitialized_copy(in_start, in_end, this->end());
     this->set_size(this->size() + NumInputs);
   }
 
   /// Append \p NumInputs copies of \p Elt to the end.
-  void append(size_type NumInputs, const T &Elt) {
-    if (NumInputs > this->capacity() - this->size())
-      this->grow(this->size()+NumInputs);
-
-    std::uninitialized_fill_n(this->end(), NumInputs, Elt);
+  void append(size_type NumInputs, ValueParamT Elt) {
+    const T *EltPtr = this->reserveForParamAndGetAddress(Elt, NumInputs);
+    std::uninitialized_fill_n(this->end(), NumInputs, *EltPtr);
     this->set_size(this->size() + NumInputs);
   }
 
@@ -410,18 +628,19 @@
   // re-initializing them - for all assign(...) variants.
 
   void assign(size_type NumElts, const T &Elt) {
+    this->assertSafeToReferenceAfterResize(&Elt, 0);
     clear();
-    if (this->capacity() < NumElts)
-      this->grow(NumElts);
+    this->reserve(NumElts);
     this->set_size(NumElts);
     std::uninitialized_fill(this->begin(), this->end(), Elt);
   }
 
   template <typename in_iter,
-            typename = typename std::enable_if<std::is_convertible<
+            typename = std::enable_if_t<std::is_convertible<
                 typename std::iterator_traits<in_iter>::iterator_category,
-                std::input_iterator_tag>::value>::type>
+                std::input_iterator_tag>::value>>
   void assign(in_iter in_start, in_iter in_end) {
+    this->assertSafeToReferenceAfterClear(in_start, in_end);
     clear();
     append(in_start, in_end);
   }
@@ -435,8 +654,7 @@
     // Just cast away constness because this is a non-const member function.
     iterator I = const_cast<iterator>(CI);
 
-    assert(I >= this->begin() && "Iterator to erase is out of bounds.");
-    assert(I < this->end() && "Erasing at past-the-end iterator.");
+    assert(this->isReferenceToStorage(CI) && "Iterator to erase is out of bounds.");
 
     iterator N = I;
     // Shift all elts down one.
@@ -451,9 +669,7 @@
     iterator S = const_cast<iterator>(CS);
     iterator E = const_cast<iterator>(CE);
 
-    assert(S >= this->begin() && "Range to erase is out of bounds.");
-    assert(S <= E && "Trying to erase invalid range.");
-    assert(E <= this->end() && "Trying to erase past the end.");
+    assert(this->isRangeInStorage(S, E) && "Range to erase is out of bounds.");
 
     iterator N = S;
     // Shift all elts down.
@@ -464,20 +680,26 @@
     return(N);
   }
 
-  iterator insert(iterator I, T &&Elt) {
+private:
+  template <class ArgType> iterator insert_one_impl(iterator I, ArgType &&Elt) {
+    // Callers ensure that ArgType is derived from T.
+    static_assert(
+        std::is_same<std::remove_const_t<std::remove_reference_t<ArgType>>,
+                     T>::value,
+        "ArgType must be derived from T!");
+
     if (I == this->end()) {  // Important special case for empty vector.
-      this->push_back(::std::move(Elt));
+      this->push_back(::std::forward<ArgType>(Elt));
       return this->end()-1;
     }
 
-    assert(I >= this->begin() && "Insertion iterator is out of bounds.");
-    assert(I <= this->end() && "Inserting past the end of the vector.");
+    assert(this->isReferenceToStorage(I) && "Insertion iterator is out of bounds.");
 
-    if (this->size() >= this->capacity()) {
-      size_t EltNo = I-this->begin();
-      this->grow();
-      I = this->begin()+EltNo;
-    }
+    // Grow if necessary.
+    size_t Index = I - this->begin();
+    std::remove_reference_t<ArgType> *EltPtr =
+        this->reserveForParamAndGetAddress(Elt);
+    I = this->begin() + Index;
 
     ::new ((void*) this->end()) T(::std::move(this->back()));
     // Push everything else over.
@@ -485,45 +707,26 @@
     this->set_size(this->size() + 1);
 
     // If we just moved the element we're inserting, be sure to update
-    // the reference.
-    T *EltPtr = &Elt;
-    if (I <= EltPtr && EltPtr < this->end())
+    // the reference (never happens if TakesParamByValue).
+    static_assert(!TakesParamByValue || std::is_same<ArgType, T>::value,
+                  "ArgType must be 'T' when taking by value!");
+    if (!TakesParamByValue && this->isReferenceToRange(EltPtr, I, this->end()))
       ++EltPtr;
 
-    *I = ::std::move(*EltPtr);
+    *I = ::std::forward<ArgType>(*EltPtr);
     return I;
   }
 
+public:
+  iterator insert(iterator I, T &&Elt) {
+    return insert_one_impl(I, this->forward_value_param(std::move(Elt)));
+  }
+
   iterator insert(iterator I, const T &Elt) {
-    if (I == this->end()) {  // Important special case for empty vector.
-      this->push_back(Elt);
-      return this->end()-1;
-    }
-
-    assert(I >= this->begin() && "Insertion iterator is out of bounds.");
-    assert(I <= this->end() && "Inserting past the end of the vector.");
-
-    if (this->size() >= this->capacity()) {
-      size_t EltNo = I-this->begin();
-      this->grow();
-      I = this->begin()+EltNo;
-    }
-    ::new ((void*) this->end()) T(std::move(this->back()));
-    // Push everything else over.
-    std::move_backward(I, this->end()-1, this->end());
-    this->set_size(this->size() + 1);
-
-    // If we just moved the element we're inserting, be sure to update
-    // the reference.
-    const T *EltPtr = &Elt;
-    if (I <= EltPtr && EltPtr < this->end())
-      ++EltPtr;
-
-    *I = *EltPtr;
-    return I;
+    return insert_one_impl(I, this->forward_value_param(Elt));
   }
 
-  iterator insert(iterator I, size_type NumToInsert, const T &Elt) {
+  iterator insert(iterator I, size_type NumToInsert, ValueParamT Elt) {
     // Convert iterator to elt# to avoid invalidating iterator when we reserve()
     size_t InsertElt = I - this->begin();
 
@@ -532,11 +735,11 @@
       return this->begin()+InsertElt;
     }
 
-    assert(I >= this->begin() && "Insertion iterator is out of bounds.");
-    assert(I <= this->end() && "Inserting past the end of the vector.");
+    assert(this->isReferenceToStorage(I) && "Insertion iterator is out of bounds.");
 
-    // Ensure there is enough space.
-    reserve(this->size() + NumToInsert);
+    // Ensure there is enough space, and get the (maybe updated) address of
+    // Elt.
+    const T *EltPtr = this->reserveForParamAndGetAddress(Elt, NumToInsert);
 
     // Uninvalidate the iterator.
     I = this->begin()+InsertElt;
@@ -553,7 +756,12 @@
       // Copy the existing elements that get replaced.
       std::move_backward(I, OldEnd-NumToInsert, OldEnd);
 
-      std::fill_n(I, NumToInsert, Elt);
+      // If we just moved the element we're inserting, be sure to update
+      // the reference (never happens if TakesParamByValue).
+      if (!TakesParamByValue && I <= EltPtr && EltPtr < this->end())
+        EltPtr += NumToInsert;
+
+      std::fill_n(I, NumToInsert, *EltPtr);
       return I;
     }
 
@@ -566,18 +774,23 @@
     size_t NumOverwritten = OldEnd-I;
     this->uninitialized_move(I, OldEnd, this->end()-NumOverwritten);
 
+    // If we just moved the element we're inserting, be sure to update
+    // the reference (never happens if TakesParamByValue).
+    if (!TakesParamByValue && I <= EltPtr && EltPtr < this->end())
+      EltPtr += NumToInsert;
+
     // Replace the overwritten part.
-    std::fill_n(I, NumOverwritten, Elt);
+    std::fill_n(I, NumOverwritten, *EltPtr);
 
     // Insert the non-overwritten middle part.
-    std::uninitialized_fill_n(OldEnd, NumToInsert-NumOverwritten, Elt);
+    std::uninitialized_fill_n(OldEnd, NumToInsert - NumOverwritten, *EltPtr);
     return I;
   }
 
   template <typename ItTy,
-            typename = typename std::enable_if<std::is_convertible<
+            typename = std::enable_if_t<std::is_convertible<
                 typename std::iterator_traits<ItTy>::iterator_category,
-                std::input_iterator_tag>::value>::type>
+                std::input_iterator_tag>::value>>
   iterator insert(iterator I, ItTy From, ItTy To) {
     // Convert iterator to elt# to avoid invalidating iterator when we reserve()
     size_t InsertElt = I - this->begin();
@@ -587,8 +800,10 @@
       return this->begin()+InsertElt;
     }
 
-    assert(I >= this->begin() && "Insertion iterator is out of bounds.");
-    assert(I <= this->end() && "Inserting past the end of the vector.");
+    assert(this->isReferenceToStorage(I) && "Insertion iterator is out of bounds.");
+
+    // Check that the reserve that follows doesn't invalidate the iterators.
+    this->assertSafeToAddRange(From, To);
 
     size_t NumToInsert = std::distance(From, To);
 
@@ -639,6 +854,7 @@
   }
 
   template <typename... ArgTypes> reference emplace_back(ArgTypes &&... Args) {
+    this->assertSafeToEmplace(Args...);
     if (LLVM_UNLIKELY(this->size() >= this->capacity()))
       this->grow();
     ::new ((void *)this->end()) T(std::forward<ArgTypes>(Args)...);
@@ -675,10 +891,8 @@
     std::swap(this->Capacity, RHS.Capacity);
     return;
   }
-  if (RHS.size() > this->capacity())
-    this->grow(RHS.size());
-  if (this->size() > RHS.capacity())
-    RHS.grow(this->size());
+  this->reserve(RHS.size());
+  RHS.reserve(this->size());
 
   // Swap the shared elements.
   size_t NumShared = this->size();
@@ -733,8 +947,7 @@
   // FIXME: don't do this if they're efficiently moveable.
   if (this->capacity() < RHSSize) {
     // Destroy current elements.
-    this->destroy_range(this->begin(), this->end());
-    this->set_size(0);
+    this->clear();
     CurSize = 0;
     this->grow(RHSSize);
   } else if (CurSize) {
@@ -793,8 +1006,7 @@
   // elements.
   if (this->capacity() < RHSSize) {
     // Destroy current elements.
-    this->destroy_range(this->begin(), this->end());
-    this->set_size(0);
+    this->clear();
     CurSize = 0;
     this->grow(RHSSize);
   } else if (CurSize) {
@@ -817,13 +1029,71 @@
 /// to avoid allocating unnecessary storage.
 template <typename T, unsigned N>
 struct SmallVectorStorage {
-  AlignedCharArrayUnion<T> InlineElts[N];
+  alignas(T) char InlineElts[N * sizeof(T)];
 };
 
 /// We need the storage to be properly aligned even for small-size of 0 so that
 /// the pointer math in \a SmallVectorTemplateCommon::getFirstEl() is
 /// well-defined.
-template <typename T> struct alignas(alignof(T)) SmallVectorStorage<T, 0> {};
+template <typename T> struct alignas(T) SmallVectorStorage<T, 0> {};
+
+/// Forward declaration of SmallVector so that
+/// calculateSmallVectorDefaultInlinedElements can reference
+/// `sizeof(SmallVector<T, 0>)`.
+template <typename T, unsigned N> class LLVM_GSL_OWNER SmallVector;
+
+/// Helper class for calculating the default number of inline elements for
+/// `SmallVector<T>`.
+///
+/// This should be migrated to a constexpr function when our minimum
+/// compiler support is enough for multi-statement constexpr functions.
+template <typename T> struct CalculateSmallVectorDefaultInlinedElements {
+  // Parameter controlling the default number of inlined elements
+  // for `SmallVector<T>`.
+  //
+  // The default number of inlined elements ensures that
+  // 1. There is at least one inlined element.
+  // 2. `sizeof(SmallVector<T>) <= kPreferredSmallVectorSizeof` unless
+  // it contradicts 1.
+  static constexpr size_t kPreferredSmallVectorSizeof = 64;
+
+  // static_assert that sizeof(T) is not "too big".
+  //
+  // Because our policy guarantees at least one inlined element, it is possible
+  // for an arbitrarily large inlined element to allocate an arbitrarily large
+  // amount of inline storage. We generally consider it an antipattern for a
+  // SmallVector to allocate an excessive amount of inline storage, so we want
+  // to call attention to these cases and make sure that users are making an
+  // intentional decision if they request a lot of inline storage.
+  //
+  // We want this assertion to trigger in pathological cases, but otherwise
+  // not be too easy to hit. To accomplish that, the cutoff is actually somewhat
+  // larger than kPreferredSmallVectorSizeof (otherwise,
+  // `SmallVector<SmallVector<T>>` would be one easy way to trip it, and that
+  // pattern seems useful in practice).
+  //
+  // One wrinkle is that this assertion is in theory non-portable, since
+  // sizeof(T) is in general platform-dependent. However, we don't expect this
+  // to be much of an issue, because most LLVM development happens on 64-bit
+  // hosts, and therefore sizeof(T) is expected to *decrease* when compiled for
+  // 32-bit hosts, dodging the issue. The reverse situation, where development
+  // happens on a 32-bit host and then fails due to sizeof(T) *increasing* on a
+  // 64-bit host, is expected to be very rare.
+  static_assert(
+      sizeof(T) <= 256,
+      "You are trying to use a default number of inlined elements for "
+      "`SmallVector<T>` but `sizeof(T)` is really big! Please use an "
+      "explicit number of inlined elements with `SmallVector<T, N>` to make "
+      "sure you really want that much inline storage.");
+
+  // Discount the size of the header itself when calculating the maximum inline
+  // bytes.
+  static constexpr size_t PreferredInlineBytes =
+      kPreferredSmallVectorSizeof - sizeof(SmallVector<T, 0>);
+  static constexpr size_t NumElementsThatFit = PreferredInlineBytes / sizeof(T);
+  static constexpr size_t value =
+      NumElementsThatFit == 0 ? 1 : NumElementsThatFit;
+};
 
 /// This is a 'vector' (really, a variable-sized array), optimized
 /// for the case when the array is small.  It contains some number of elements
@@ -831,10 +1101,20 @@
 /// elements is below that threshold.  This allows normal "small" cases to be
 /// fast without losing generality for large inputs.
 ///
-/// Note that this does not attempt to be exception safe.
+/// \note
+/// In the absence of a well-motivated choice for the number of inlined
+/// elements \p N, it is recommended to use \c SmallVector<T> (that is,
+/// omitting the \p N). This will choose a default number of inlined elements
+/// reasonable for allocation on the stack (for example, trying to keep \c
+/// sizeof(SmallVector<T>) around 64 bytes).
 ///
-template <typename T, unsigned N>
-class SmallVector : public SmallVectorImpl<T>, SmallVectorStorage<T, N> {
+/// \warning This does not attempt to be exception safe.
+///
+/// \see https://llvm.org/docs/ProgrammersManual.html#llvm-adt-smallvector-h
+template <typename T,
+          unsigned N = CalculateSmallVectorDefaultInlinedElements<T>::value>
+class LLVM_GSL_OWNER SmallVector : public SmallVectorImpl<T>,
+                                   SmallVectorStorage<T, N> {
 public:
   SmallVector() : SmallVectorImpl<T>(N) {}
 
@@ -849,9 +1129,9 @@
   }
 
   template <typename ItTy,
-            typename = typename std::enable_if<std::is_convertible<
+            typename = std::enable_if_t<std::is_convertible<
                 typename std::iterator_traits<ItTy>::iterator_category,
-                std::input_iterator_tag>::value>::type>
+                std::input_iterator_tag>::value>>
   SmallVector(ItTy S, ItTy E) : SmallVectorImpl<T>(N) {
     this->append(S, E);
   }
@@ -871,7 +1151,7 @@
       SmallVectorImpl<T>::operator=(RHS);
   }
 
-  const SmallVector &operator=(const SmallVector &RHS) {
+  SmallVector &operator=(const SmallVector &RHS) {
     SmallVectorImpl<T>::operator=(RHS);
     return *this;
   }
@@ -886,17 +1166,17 @@
       SmallVectorImpl<T>::operator=(::std::move(RHS));
   }
 
-  const SmallVector &operator=(SmallVector &&RHS) {
+  SmallVector &operator=(SmallVector &&RHS) {
     SmallVectorImpl<T>::operator=(::std::move(RHS));
     return *this;
   }
 
-  const SmallVector &operator=(SmallVectorImpl<T> &&RHS) {
+  SmallVector &operator=(SmallVectorImpl<T> &&RHS) {
     SmallVectorImpl<T>::operator=(::std::move(RHS));
     return *this;
   }
 
-  const SmallVector &operator=(std::initializer_list<T> IL) {
+  SmallVector &operator=(std::initializer_list<T> IL) {
     this->assign(IL);
     return *this;
   }
@@ -907,6 +1187,17 @@
   return X.capacity_in_bytes();
 }
 
+/// Given a range of type R, iterate the entire range and return a
+/// SmallVector with elements of the vector.  This is useful, for example,
+/// when you want to iterate a range and then sort the results.
+template <unsigned Size, typename R>
+SmallVector<typename std::remove_const<typename std::remove_reference<
+                decltype(*std::begin(std::declval<R &>()))>::type>::type,
+            Size>
+to_vector(R &&Range) {
+  return {std::begin(Range), std::end(Range)};
+}
+
 } // end namespace llvm
 
 namespace std {
diff --git a/linux-x64/clang/include/llvm/ADT/SparseMultiSet.h b/linux-x64/clang/include/llvm/ADT/SparseMultiSet.h
index d9d3ff4..307d2c3 100644
--- a/linux-x64/clang/include/llvm/ADT/SparseMultiSet.h
+++ b/linux-x64/clang/include/llvm/ADT/SparseMultiSet.h
@@ -94,7 +94,7 @@
   /// tombstones, in which case they are actually nodes in a single-linked
   /// freelist of recyclable slots.
   struct SMSNode {
-    static const unsigned INVALID = ~0U;
+    static constexpr unsigned INVALID = ~0U;
 
     ValueT Data;
     unsigned Prev;
diff --git a/linux-x64/clang/include/llvm/ADT/SparseSet.h b/linux-x64/clang/include/llvm/ADT/SparseSet.h
index a6eb9b9..d8acf1e 100644
--- a/linux-x64/clang/include/llvm/ADT/SparseSet.h
+++ b/linux-x64/clang/include/llvm/ADT/SparseSet.h
@@ -21,7 +21,7 @@
 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallVector.h"
-#include "llvm/Support/Allocator.h"
+#include "llvm/Support/AllocatorBase.h"
 #include <cassert>
 #include <cstdint>
 #include <cstdlib>
@@ -79,7 +79,7 @@
   }
 };
 
-/// SparseSet - Fast set implmentation for objects that can be identified by
+/// SparseSet - Fast set implementation for objects that can be identified by
 /// small unsigned keys.
 ///
 /// SparseSet allocates memory proportional to the size of the key universe, so
@@ -229,12 +229,15 @@
     return const_cast<SparseSet*>(this)->findIndex(KeyIndexOf(Key));
   }
 
+  /// Check if the set contains the given \c Key.
+  ///
+  /// @param Key A valid key to find.
+  bool contains(const KeyT &Key) const { return find(Key) == end() ? 0 : 1; }
+
   /// count - Returns 1 if this set contains an element identified by Key,
   /// 0 otherwise.
   ///
-  size_type count(const KeyT &Key) const {
-    return find(Key) == end() ? 0 : 1;
-  }
+  size_type count(const KeyT &Key) const { return contains(Key) ? 1 : 0; }
 
   /// insert - Attempts to insert a new element.
   ///
diff --git a/linux-x64/clang/include/llvm/ADT/Statistic.h b/linux-x64/clang/include/llvm/ADT/Statistic.h
index 2ac59da..aa338cc 100644
--- a/linux-x64/clang/include/llvm/ADT/Statistic.h
+++ b/linux-x64/clang/include/llvm/ADT/Statistic.h
@@ -36,6 +36,8 @@
 // configure time.
 #if !defined(NDEBUG) || LLVM_FORCE_ENABLE_STATS
 #define LLVM_ENABLE_STATS 1
+#else
+#define LLVM_ENABLE_STATS 0
 #endif
 
 namespace llvm {
@@ -44,38 +46,39 @@
 class raw_fd_ostream;
 class StringRef;
 
-class Statistic {
+class StatisticBase {
 public:
   const char *DebugType;
   const char *Name;
   const char *Desc;
-  std::atomic<unsigned> Value;
-  std::atomic<bool> Initialized;
 
-  unsigned getValue() const { return Value.load(std::memory_order_relaxed); }
+  StatisticBase(const char *DebugType, const char *Name, const char *Desc)
+      : DebugType(DebugType), Name(Name), Desc(Desc) {}
+
   const char *getDebugType() const { return DebugType; }
   const char *getName() const { return Name; }
   const char *getDesc() const { return Desc; }
+};
 
-  /// construct - This should only be called for non-global statistics.
-  void construct(const char *debugtype, const char *name, const char *desc) {
-    DebugType = debugtype;
-    Name = name;
-    Desc = desc;
-    Value = 0;
-    Initialized = false;
-  }
+class TrackingStatistic : public StatisticBase {
+public:
+  std::atomic<unsigned> Value;
+  std::atomic<bool> Initialized;
+
+  TrackingStatistic(const char *DebugType, const char *Name, const char *Desc)
+      : StatisticBase(DebugType, Name, Desc), Value(0), Initialized(false) {}
+
+  unsigned getValue() const { return Value.load(std::memory_order_relaxed); }
 
   // Allow use of this class as the value itself.
   operator unsigned() const { return getValue(); }
 
-#if LLVM_ENABLE_STATS
-   const Statistic &operator=(unsigned Val) {
+  const TrackingStatistic &operator=(unsigned Val) {
     Value.store(Val, std::memory_order_relaxed);
     return init();
   }
 
-  const Statistic &operator++() {
+  const TrackingStatistic &operator++() {
     Value.fetch_add(1, std::memory_order_relaxed);
     return init();
   }
@@ -85,7 +88,7 @@
     return Value.fetch_add(1, std::memory_order_relaxed);
   }
 
-  const Statistic &operator--() {
+  const TrackingStatistic &operator--() {
     Value.fetch_sub(1, std::memory_order_relaxed);
     return init();
   }
@@ -95,14 +98,14 @@
     return Value.fetch_sub(1, std::memory_order_relaxed);
   }
 
-  const Statistic &operator+=(unsigned V) {
+  const TrackingStatistic &operator+=(unsigned V) {
     if (V == 0)
       return *this;
     Value.fetch_add(V, std::memory_order_relaxed);
     return init();
   }
 
-  const Statistic &operator-=(unsigned V) {
+  const TrackingStatistic &operator-=(unsigned V) {
     if (V == 0)
       return *this;
     Value.fetch_sub(V, std::memory_order_relaxed);
@@ -119,42 +122,8 @@
     init();
   }
 
-#else  // Statistics are disabled in release builds.
-
-  const Statistic &operator=(unsigned Val) {
-    return *this;
-  }
-
-  const Statistic &operator++() {
-    return *this;
-  }
-
-  unsigned operator++(int) {
-    return 0;
-  }
-
-  const Statistic &operator--() {
-    return *this;
-  }
-
-  unsigned operator--(int) {
-    return 0;
-  }
-
-  const Statistic &operator+=(const unsigned &V) {
-    return *this;
-  }
-
-  const Statistic &operator-=(const unsigned &V) {
-    return *this;
-  }
-
-  void updateMax(unsigned V) {}
-
-#endif  // LLVM_ENABLE_STATS
-
 protected:
-  Statistic &init() {
+  TrackingStatistic &init() {
     if (!Initialized.load(std::memory_order_acquire))
       RegisterStatistic();
     return *this;
@@ -163,13 +132,50 @@
   void RegisterStatistic();
 };
 
+class NoopStatistic : public StatisticBase {
+public:
+  using StatisticBase::StatisticBase;
+
+  unsigned getValue() const { return 0; }
+
+  // Allow use of this class as the value itself.
+  operator unsigned() const { return 0; }
+
+  const NoopStatistic &operator=(unsigned Val) { return *this; }
+
+  const NoopStatistic &operator++() { return *this; }
+
+  unsigned operator++(int) { return 0; }
+
+  const NoopStatistic &operator--() { return *this; }
+
+  unsigned operator--(int) { return 0; }
+
+  const NoopStatistic &operator+=(const unsigned &V) { return *this; }
+
+  const NoopStatistic &operator-=(const unsigned &V) { return *this; }
+
+  void updateMax(unsigned V) {}
+};
+
+#if LLVM_ENABLE_STATS
+using Statistic = TrackingStatistic;
+#else
+using Statistic = NoopStatistic;
+#endif
+
 // STATISTIC - A macro to make definition of statistics really simple.  This
 // automatically passes the DEBUG_TYPE of the file into the statistic.
 #define STATISTIC(VARNAME, DESC)                                               \
-  static llvm::Statistic VARNAME = {DEBUG_TYPE, #VARNAME, DESC, {0}, {false}}
+  static llvm::Statistic VARNAME = {DEBUG_TYPE, #VARNAME, DESC}
+
+// ALWAYS_ENABLED_STATISTIC - A macro to define a statistic like STATISTIC but
+// it is enabled even if LLVM_ENABLE_STATS is off.
+#define ALWAYS_ENABLED_STATISTIC(VARNAME, DESC)                                \
+  static llvm::TrackingStatistic VARNAME = {DEBUG_TYPE, #VARNAME, DESC}
 
 /// Enable the collection and printing of statistics.
-void EnableStatistics(bool PrintOnExit = true);
+void EnableStatistics(bool DoPrintOnExit = true);
 
 /// Check if statistics are enabled.
 bool AreStatisticsEnabled();
diff --git a/linux-x64/clang/include/llvm/ADT/StringExtras.h b/linux-x64/clang/include/llvm/ADT/StringExtras.h
index 16ac90b..10596cf 100644
--- a/linux-x64/clang/include/llvm/ADT/StringExtras.h
+++ b/linux-x64/clang/include/llvm/ADT/StringExtras.h
@@ -66,17 +66,29 @@
 ///
 /// If \p C is not a valid hex digit, -1U is returned.
 inline unsigned hexDigitValue(char C) {
-  if (C >= '0' && C <= '9') return C-'0';
-  if (C >= 'a' && C <= 'f') return C-'a'+10U;
-  if (C >= 'A' && C <= 'F') return C-'A'+10U;
-  return -1U;
+  struct HexTable {
+    unsigned LUT[255] = {};
+    constexpr HexTable() {
+      // Default initialize everything to invalid.
+      for (int i = 0; i < 255; ++i)
+        LUT[i] = ~0U;
+      // Initialize `0`-`9`.
+      for (int i = 0; i < 10; ++i)
+        LUT['0' + i] = i;
+      // Initialize `A`-`F` and `a`-`f`.
+      for (int i = 0; i < 6; ++i)
+        LUT['A' + i] = LUT['a' + i] = 10 + i;
+    }
+  };
+  constexpr HexTable Table;
+  return Table.LUT[static_cast<unsigned char>(C)];
 }
 
 /// Checks if character \p C is one of the 10 decimal digits.
 inline bool isDigit(char C) { return C >= '0' && C <= '9'; }
 
 /// Checks if character \p C is a hexadecimal numeric character.
-inline bool isHexDigit(char C) { return hexDigitValue(C) != -1U; }
+inline bool isHexDigit(char C) { return hexDigitValue(C) != ~0U; }
 
 /// Checks if character \p C is a valid letter as classified by "C" locale.
 inline bool isAlpha(char C) {
@@ -107,6 +119,14 @@
   return (0x20 <= UC) && (UC <= 0x7E);
 }
 
+/// Checks whether character \p C is whitespace in the "C" locale.
+///
+/// Locale-independent version of the C standard library isspace.
+inline bool isSpace(char C) {
+  return C == ' ' || C == '\f' || C == '\n' || C == '\r' || C == '\t' ||
+         C == '\v';
+}
+
 /// Returns the corresponding lowercase character if \p x is uppercase.
 inline char toLower(char x) {
   if (x >= 'A' && x <= 'Z')
@@ -157,34 +177,68 @@
   return toHex(toStringRef(Input), LowerCase);
 }
 
-inline uint8_t hexFromNibbles(char MSB, char LSB) {
+/// Store the binary representation of the two provided values, \p MSB and
+/// \p LSB, that make up the nibbles of a hexadecimal digit. If \p MSB or \p LSB
+/// do not correspond to proper nibbles of a hexadecimal digit, this method
+/// returns false. Otherwise, returns true.
+inline bool tryGetHexFromNibbles(char MSB, char LSB, uint8_t &Hex) {
   unsigned U1 = hexDigitValue(MSB);
   unsigned U2 = hexDigitValue(LSB);
-  assert(U1 != -1U && U2 != -1U);
+  if (U1 == ~0U || U2 == ~0U)
+    return false;
 
-  return static_cast<uint8_t>((U1 << 4) | U2);
+  Hex = static_cast<uint8_t>((U1 << 4) | U2);
+  return true;
 }
 
-/// Convert hexadecimal string \p Input to its binary representation.
-/// The return string is half the size of \p Input.
-inline std::string fromHex(StringRef Input) {
-  if (Input.empty())
-    return std::string();
+/// Return the binary representation of the two provided values, \p MSB and
+/// \p LSB, that make up the nibbles of a hexadecimal digit.
+inline uint8_t hexFromNibbles(char MSB, char LSB) {
+  uint8_t Hex = 0;
+  bool GotHex = tryGetHexFromNibbles(MSB, LSB, Hex);
+  (void)GotHex;
+  assert(GotHex && "MSB and/or LSB do not correspond to hex digits");
+  return Hex;
+}
 
-  std::string Output;
+/// Convert hexadecimal string \p Input to its binary representation and store
+/// the result in \p Output. Returns true if the binary representation could be
+/// converted from the hexadecimal string. Returns false if \p Input contains
+/// non-hexadecimal digits. The output string is half the size of \p Input.
+inline bool tryGetFromHex(StringRef Input, std::string &Output) {
+  if (Input.empty())
+    return true;
+
   Output.reserve((Input.size() + 1) / 2);
   if (Input.size() % 2 == 1) {
-    Output.push_back(hexFromNibbles('0', Input.front()));
+    uint8_t Hex = 0;
+    if (!tryGetHexFromNibbles('0', Input.front(), Hex))
+      return false;
+
+    Output.push_back(Hex);
     Input = Input.drop_front();
   }
 
   assert(Input.size() % 2 == 0);
   while (!Input.empty()) {
-    uint8_t Hex = hexFromNibbles(Input[0], Input[1]);
+    uint8_t Hex = 0;
+    if (!tryGetHexFromNibbles(Input[0], Input[1], Hex))
+      return false;
+
     Output.push_back(Hex);
     Input = Input.drop_front(2);
   }
-  return Output;
+  return true;
+}
+
+/// Convert hexadecimal string \p Input to its binary representation.
+/// The return string is half the size of \p Input.
+inline std::string fromHex(StringRef Input) {
+  std::string Hex;
+  bool GotHex = tryGetFromHex(Input, Hex);
+  (void)GotHex;
+  assert(GotHex && "Input contains non hex digits");
+  return Hex;
 }
 
 /// Convert the string \p S to an integer of the specified type using
@@ -237,7 +291,7 @@
 
 inline std::string itostr(int64_t X) {
   if (X < 0)
-    return utostr(static_cast<uint64_t>(-X), true);
+    return utostr(static_cast<uint64_t>(1) + ~static_cast<uint64_t>(X), true);
   else
     return utostr(static_cast<uint64_t>(X));
 }
@@ -292,6 +346,18 @@
 /// printLowerCase - Print each character as lowercase if it is uppercase.
 void printLowerCase(StringRef String, raw_ostream &Out);
 
+/// Converts a string from camel-case to snake-case by replacing all uppercase
+/// letters with '_' followed by the letter in lowercase, except if the
+/// uppercase letter is the first character of the string.
+std::string convertToSnakeFromCamelCase(StringRef input);
+
+/// Converts a string from snake-case to camel-case by replacing all occurrences
+/// of '_' followed by a lowercase letter with the letter in uppercase.
+/// Optionally allow capitalization of the first letter (if it is a lowercase
+/// letter)
+std::string convertToCamelFromSnakeCase(StringRef input,
+                                        bool capitalizeFirst = false);
+
 namespace detail {
 
 template <typename IteratorT>
@@ -318,13 +384,16 @@
 
   size_t Len = (std::distance(Begin, End) - 1) * Separator.size();
   for (IteratorT I = Begin; I != End; ++I)
-    Len += (*Begin).size();
+    Len += (*I).size();
   S.reserve(Len);
+  size_t PrevCapacity = S.capacity();
+  (void)PrevCapacity;
   S += (*Begin);
   while (++Begin != End) {
     S += Separator;
     S += (*Begin);
   }
+  assert(PrevCapacity == S.capacity() && "String grew during building");
   return S;
 }
 
@@ -345,7 +414,7 @@
   join_items_impl(Result, Separator, std::forward<Args>(Items)...);
 }
 
-inline size_t join_one_item_size(char C) { return 1; }
+inline size_t join_one_item_size(char) { return 1; }
 inline size_t join_one_item_size(const char *S) { return S ? ::strlen(S) : 0; }
 
 template <typename T> inline size_t join_one_item_size(const T &Str) {
@@ -396,6 +465,30 @@
   return Result;
 }
 
+/// A helper class to return the specified delimiter string after the first
+/// invocation of operator StringRef().  Used to generate a comma-separated
+/// list from a loop like so:
+///
+/// \code
+///   ListSeparator SD;
+///   for (auto &I : C)
+///     OS << SD << I.getName();
+/// \end
+class ListSeparator {
+  bool First = true;
+  StringRef Separator;
+
+public:
+  ListSeparator(StringRef Separator = ", ") : Separator(Separator) {}
+  operator StringRef() {
+    if (First) {
+      First = false;
+      return {};
+    }
+    return Separator;
+  }
+};
+
 } // end namespace llvm
 
 #endif // LLVM_ADT_STRINGEXTRAS_H
diff --git a/linux-x64/clang/include/llvm/ADT/StringMap.h b/linux-x64/clang/include/llvm/ADT/StringMap.h
index 8a586fc..a82afc9 100644
--- a/linux-x64/clang/include/llvm/ADT/StringMap.h
+++ b/linux-x64/clang/include/llvm/ADT/StringMap.h
@@ -13,36 +13,17 @@
 #ifndef LLVM_ADT_STRINGMAP_H
 #define LLVM_ADT_STRINGMAP_H
 
-#include "llvm/ADT/StringRef.h"
-#include "llvm/ADT/iterator.h"
-#include "llvm/ADT/iterator_range.h"
-#include "llvm/Support/Allocator.h"
+#include "llvm/ADT/StringMapEntry.h"
+#include "llvm/Support/AllocatorBase.h"
 #include "llvm/Support/PointerLikeTypeTraits.h"
-#include "llvm/Support/ErrorHandling.h"
-#include <algorithm>
-#include <cassert>
-#include <cstdint>
-#include <cstdlib>
-#include <cstring>
 #include <initializer_list>
 #include <iterator>
-#include <utility>
 
 namespace llvm {
 
-template<typename ValueTy> class StringMapConstIterator;
-template<typename ValueTy> class StringMapIterator;
-template<typename ValueTy> class StringMapKeyIterator;
-
-/// StringMapEntryBase - Shared base class of StringMapEntry instances.
-class StringMapEntryBase {
-  size_t StrLen;
-
-public:
-  explicit StringMapEntryBase(size_t Len) : StrLen(Len) {}
-
-  size_t getKeyLength() const { return StrLen; }
-};
+template <typename ValueTy> class StringMapConstIterator;
+template <typename ValueTy> class StringMapIterator;
+template <typename ValueTy> class StringMapKeyIterator;
 
 /// StringMapImpl - This is the base class of StringMap that is shared among
 /// all of its instantiations.
@@ -58,8 +39,7 @@
   unsigned ItemSize;
 
 protected:
-  explicit StringMapImpl(unsigned itemSize)
-      : ItemSize(itemSize) {}
+  explicit StringMapImpl(unsigned itemSize) : ItemSize(itemSize) {}
   StringMapImpl(StringMapImpl &&RHS)
       : TheTable(RHS.TheTable), NumBuckets(RHS.NumBuckets),
         NumItems(RHS.NumItems), NumTombstones(RHS.NumTombstones),
@@ -98,10 +78,12 @@
   void init(unsigned Size);
 
 public:
+  static constexpr uintptr_t TombstoneIntVal =
+      static_cast<uintptr_t>(-1)
+      << PointerLikeTypeTraits<StringMapEntryBase *>::NumLowBitsAvailable;
+
   static StringMapEntryBase *getTombstoneVal() {
-    uintptr_t Val = static_cast<uintptr_t>(-1);
-    Val <<= PointerLikeTypeTraits<StringMapEntryBase *>::NumLowBitsAvailable;
-    return reinterpret_cast<StringMapEntryBase *>(Val);
+    return reinterpret_cast<StringMapEntryBase *>(TombstoneIntVal);
   }
 
   unsigned getNumBuckets() const { return NumBuckets; }
@@ -118,104 +100,11 @@
   }
 };
 
-/// StringMapEntry - This is used to represent one value that is inserted into
-/// a StringMap.  It contains the Value itself and the key: the string length
-/// and data.
-template<typename ValueTy>
-class StringMapEntry : public StringMapEntryBase {
-public:
-  ValueTy second;
-
-  explicit StringMapEntry(size_t strLen)
-    : StringMapEntryBase(strLen), second() {}
-  template <typename... InitTy>
-  StringMapEntry(size_t strLen, InitTy &&... InitVals)
-      : StringMapEntryBase(strLen), second(std::forward<InitTy>(InitVals)...) {}
-  StringMapEntry(StringMapEntry &E) = delete;
-
-  StringRef getKey() const {
-    return StringRef(getKeyData(), getKeyLength());
-  }
-
-  const ValueTy &getValue() const { return second; }
-  ValueTy &getValue() { return second; }
-
-  void setValue(const ValueTy &V) { second = V; }
-
-  /// getKeyData - Return the start of the string data that is the key for this
-  /// value.  The string data is always stored immediately after the
-  /// StringMapEntry object.
-  const char *getKeyData() const {return reinterpret_cast<const char*>(this+1);}
-
-  StringRef first() const { return StringRef(getKeyData(), getKeyLength()); }
-
-  /// Create a StringMapEntry for the specified key construct the value using
-  /// \p InitiVals.
-  template <typename AllocatorTy, typename... InitTy>
-  static StringMapEntry *Create(StringRef Key, AllocatorTy &Allocator,
-                                InitTy &&... InitVals) {
-    size_t KeyLength = Key.size();
-
-    // Allocate a new item with space for the string at the end and a null
-    // terminator.
-    size_t AllocSize = sizeof(StringMapEntry) + KeyLength + 1;
-    size_t Alignment = alignof(StringMapEntry);
-
-    StringMapEntry *NewItem =
-      static_cast<StringMapEntry*>(Allocator.Allocate(AllocSize,Alignment));
-    assert(NewItem && "Unhandled out-of-memory");
-
-    // Construct the value.
-    new (NewItem) StringMapEntry(KeyLength, std::forward<InitTy>(InitVals)...);
-
-    // Copy the string information.
-    char *StrBuffer = const_cast<char*>(NewItem->getKeyData());
-    if (KeyLength > 0)
-      memcpy(StrBuffer, Key.data(), KeyLength);
-    StrBuffer[KeyLength] = 0;  // Null terminate for convenience of clients.
-    return NewItem;
-  }
-
-  /// Create - Create a StringMapEntry with normal malloc/free.
-  template <typename... InitType>
-  static StringMapEntry *Create(StringRef Key, InitType &&... InitVal) {
-    MallocAllocator A;
-    return Create(Key, A, std::forward<InitType>(InitVal)...);
-  }
-
-  static StringMapEntry *Create(StringRef Key) {
-    return Create(Key, ValueTy());
-  }
-
-  /// GetStringMapEntryFromKeyData - Given key data that is known to be embedded
-  /// into a StringMapEntry, return the StringMapEntry itself.
-  static StringMapEntry &GetStringMapEntryFromKeyData(const char *KeyData) {
-    char *Ptr = const_cast<char*>(KeyData) - sizeof(StringMapEntry<ValueTy>);
-    return *reinterpret_cast<StringMapEntry*>(Ptr);
-  }
-
-  /// Destroy - Destroy this StringMapEntry, releasing memory back to the
-  /// specified allocator.
-  template<typename AllocatorTy>
-  void Destroy(AllocatorTy &Allocator) {
-    // Free memory referenced by the item.
-    size_t AllocSize = sizeof(StringMapEntry) + getKeyLength() + 1;
-    this->~StringMapEntry();
-    Allocator.Deallocate(static_cast<void *>(this), AllocSize);
-  }
-
-  /// Destroy this object, releasing memory back to the malloc allocator.
-  void Destroy() {
-    MallocAllocator A;
-    Destroy(A);
-  }
-};
-
 /// StringMap - This is an unconventional map that is specialized for handling
 /// keys that are "strings", which are basically ranges of bytes. This does some
 /// funky memory allocation and hashing things to make it extremely efficient,
 /// storing the string data *after* the value in the map.
-template<typename ValueTy, typename AllocatorTy = MallocAllocator>
+template <typename ValueTy, typename AllocatorTy = MallocAllocator>
 class StringMap : public StringMapImpl {
   AllocatorTy Allocator;
 
@@ -225,14 +114,15 @@
   StringMap() : StringMapImpl(static_cast<unsigned>(sizeof(MapEntryTy))) {}
 
   explicit StringMap(unsigned InitialSize)
-    : StringMapImpl(InitialSize, static_cast<unsigned>(sizeof(MapEntryTy))) {}
+      : StringMapImpl(InitialSize, static_cast<unsigned>(sizeof(MapEntryTy))) {}
 
   explicit StringMap(AllocatorTy A)
-    : StringMapImpl(static_cast<unsigned>(sizeof(MapEntryTy))), Allocator(A) {}
+      : StringMapImpl(static_cast<unsigned>(sizeof(MapEntryTy))), Allocator(A) {
+  }
 
   StringMap(unsigned InitialSize, AllocatorTy A)
-    : StringMapImpl(InitialSize, static_cast<unsigned>(sizeof(MapEntryTy))),
-      Allocator(A) {}
+      : StringMapImpl(InitialSize, static_cast<unsigned>(sizeof(MapEntryTy))),
+        Allocator(A) {}
 
   StringMap(std::initializer_list<std::pair<StringRef, ValueTy>> List)
       : StringMapImpl(List.size(), static_cast<unsigned>(sizeof(MapEntryTy))) {
@@ -244,9 +134,9 @@
   StringMap(StringMap &&RHS)
       : StringMapImpl(std::move(RHS)), Allocator(std::move(RHS.Allocator)) {}
 
-  StringMap(const StringMap &RHS) :
-    StringMapImpl(static_cast<unsigned>(sizeof(MapEntryTy))),
-    Allocator(RHS.Allocator) {
+  StringMap(const StringMap &RHS)
+      : StringMapImpl(static_cast<unsigned>(sizeof(MapEntryTy))),
+        Allocator(RHS.Allocator) {
     if (RHS.empty())
       return;
 
@@ -293,7 +183,7 @@
       for (unsigned I = 0, E = NumBuckets; I != E; ++I) {
         StringMapEntryBase *Bucket = TheTable[I];
         if (Bucket && Bucket != getTombstoneVal()) {
-          static_cast<MapEntryTy*>(Bucket)->Destroy(Allocator);
+          static_cast<MapEntryTy *>(Bucket)->Destroy(Allocator);
         }
       }
     }
@@ -303,7 +193,7 @@
   AllocatorTy &getAllocator() { return Allocator; }
   const AllocatorTy &getAllocator() const { return Allocator; }
 
-  using key_type = const char*;
+  using key_type = const char *;
   using mapped_type = ValueTy;
   using value_type = StringMapEntry<ValueTy>;
   using size_type = size_t;
@@ -311,17 +201,13 @@
   using const_iterator = StringMapConstIterator<ValueTy>;
   using iterator = StringMapIterator<ValueTy>;
 
-  iterator begin() {
-    return iterator(TheTable, NumBuckets == 0);
-  }
-  iterator end() {
-    return iterator(TheTable+NumBuckets, true);
-  }
+  iterator begin() { return iterator(TheTable, NumBuckets == 0); }
+  iterator end() { return iterator(TheTable + NumBuckets, true); }
   const_iterator begin() const {
     return const_iterator(TheTable, NumBuckets == 0);
   }
   const_iterator end() const {
-    return const_iterator(TheTable+NumBuckets, true);
+    return const_iterator(TheTable + NumBuckets, true);
   }
 
   iterator_range<StringMapKeyIterator<ValueTy>> keys() const {
@@ -331,14 +217,16 @@
 
   iterator find(StringRef Key) {
     int Bucket = FindKey(Key);
-    if (Bucket == -1) return end();
-    return iterator(TheTable+Bucket, true);
+    if (Bucket == -1)
+      return end();
+    return iterator(TheTable + Bucket, true);
   }
 
   const_iterator find(StringRef Key) const {
     int Bucket = FindKey(Key);
-    if (Bucket == -1) return end();
-    return const_iterator(TheTable+Bucket, true);
+    if (Bucket == -1)
+      return end();
+    return const_iterator(TheTable + Bucket, true);
   }
 
   /// lookup - Return the entry for the specified key, or a default
@@ -355,15 +243,33 @@
   ValueTy &operator[](StringRef Key) { return try_emplace(Key).first->second; }
 
   /// count - Return 1 if the element is in the map, 0 otherwise.
-  size_type count(StringRef Key) const {
-    return find(Key) == end() ? 0 : 1;
-  }
+  size_type count(StringRef Key) const { return find(Key) == end() ? 0 : 1; }
 
   template <typename InputTy>
   size_type count(const StringMapEntry<InputTy> &MapEntry) const {
     return count(MapEntry.getKey());
   }
 
+  /// equal - check whether both of the containers are equal.
+  bool operator==(const StringMap &RHS) const {
+    if (size() != RHS.size())
+      return false;
+
+    for (const auto &KeyValue : *this) {
+      auto FindInRHS = RHS.find(KeyValue.getKey());
+
+      if (FindInRHS == RHS.end())
+        return false;
+
+      if (!(KeyValue.getValue() == FindInRHS->getValue()))
+        return false;
+    }
+
+    return true;
+  }
+
+  bool operator!=(const StringMap &RHS) const { return !(*this == RHS); }
+
   /// insert - Insert the specified key/value pair into the map.  If the key
   /// already exists in the map, return false and ignore the request, otherwise
   /// insert it and return true.
@@ -371,7 +277,7 @@
     unsigned BucketNo = LookupBucketFor(KeyValue->getKey());
     StringMapEntryBase *&Bucket = TheTable[BucketNo];
     if (Bucket && Bucket != getTombstoneVal())
-      return false;  // Already exists in map.
+      return false; // Already exists in map.
 
     if (Bucket == getTombstoneVal())
       --NumTombstones;
@@ -391,6 +297,16 @@
     return try_emplace(KV.first, std::move(KV.second));
   }
 
+  /// Inserts an element or assigns to the current element if the key already
+  /// exists. The return type is the same as try_emplace.
+  template <typename V>
+  std::pair<iterator, bool> insert_or_assign(StringRef Key, V &&Val) {
+    auto Ret = try_emplace(Key, std::forward<V>(Val));
+    if (!Ret.second)
+      Ret.first->second = std::forward<V>(Val);
+    return Ret;
+  }
+
   /// Emplace a new element for the specified key into the map if the key isn't
   /// already in the map. The bool component of the returned pair is true
   /// if and only if the insertion takes place, and the iterator component of
@@ -415,14 +331,15 @@
 
   // clear - Empties out the StringMap
   void clear() {
-    if (empty()) return;
+    if (empty())
+      return;
 
     // Zap all values, resetting the keys back to non-present (not tombstone),
     // which is safe because we're removing all elements.
     for (unsigned I = 0, E = NumBuckets; I != E; ++I) {
       StringMapEntryBase *&Bucket = TheTable[I];
       if (Bucket && Bucket != getTombstoneVal()) {
-        static_cast<MapEntryTy*>(Bucket)->Destroy(Allocator);
+        static_cast<MapEntryTy *>(Bucket)->Destroy(Allocator);
       }
       Bucket = nullptr;
     }
@@ -433,9 +350,7 @@
 
   /// remove - Remove the specified key/value pair from the map, but do not
   /// erase it.  This aborts if the key is not in the map.
-  void remove(MapEntryTy *KeyValue) {
-    RemoveKey(KeyValue);
-  }
+  void remove(MapEntryTy *KeyValue) { RemoveKey(KeyValue); }
 
   void erase(iterator I) {
     MapEntryTy &V = *I;
@@ -445,7 +360,8 @@
 
   bool erase(StringRef Key) {
     iterator I = find(Key);
-    if (I == end()) return false;
+    if (I == end())
+      return false;
     erase(I);
     return true;
   }
@@ -464,7 +380,8 @@
   explicit StringMapIterBase(StringMapEntryBase **Bucket,
                              bool NoAdvance = false)
       : Ptr(Bucket) {
-    if (!NoAdvance) AdvancePastEmptyBuckets();
+    if (!NoAdvance)
+      AdvancePastEmptyBuckets();
   }
 
   DerivedTy &operator=(const DerivedTy &Other) {
@@ -472,7 +389,9 @@
     return static_cast<DerivedTy &>(*this);
   }
 
-  bool operator==(const DerivedTy &RHS) const { return Ptr == RHS.Ptr; }
+  friend bool operator==(const DerivedTy &LHS, const DerivedTy &RHS) {
+    return LHS.Ptr == RHS.Ptr;
+  }
 
   DerivedTy &operator++() { // Preincrement
     ++Ptr;
diff --git a/linux-x64/clang/include/llvm/ADT/StringMapEntry.h b/linux-x64/clang/include/llvm/ADT/StringMapEntry.h
new file mode 100644
index 0000000..ea3aad6
--- /dev/null
+++ b/linux-x64/clang/include/llvm/ADT/StringMapEntry.h
@@ -0,0 +1,135 @@
+//===- StringMapEntry.h - String Hash table map interface -------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the StringMapEntry class - it is intended to be a low
+// dependency implementation detail of StringMap that is more suitable for
+// inclusion in public headers than StringMap.h itself is.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_ADT_STRINGMAPENTRY_H
+#define LLVM_ADT_STRINGMAPENTRY_H
+
+#include "llvm/ADT/StringRef.h"
+
+namespace llvm {
+
+/// StringMapEntryBase - Shared base class of StringMapEntry instances.
+class StringMapEntryBase {
+  size_t keyLength;
+
+public:
+  explicit StringMapEntryBase(size_t keyLength) : keyLength(keyLength) {}
+
+  size_t getKeyLength() const { return keyLength; }
+};
+
+/// StringMapEntryStorage - Holds the value in a StringMapEntry.
+///
+/// Factored out into a separate base class to make it easier to specialize.
+/// This is primarily intended to support StringSet, which doesn't need a value
+/// stored at all.
+template <typename ValueTy>
+class StringMapEntryStorage : public StringMapEntryBase {
+public:
+  ValueTy second;
+
+  explicit StringMapEntryStorage(size_t keyLength)
+      : StringMapEntryBase(keyLength), second() {}
+  template <typename... InitTy>
+  StringMapEntryStorage(size_t keyLength, InitTy &&... initVals)
+      : StringMapEntryBase(keyLength),
+        second(std::forward<InitTy>(initVals)...) {}
+  StringMapEntryStorage(StringMapEntryStorage &e) = delete;
+
+  const ValueTy &getValue() const { return second; }
+  ValueTy &getValue() { return second; }
+
+  void setValue(const ValueTy &V) { second = V; }
+};
+
+template <> class StringMapEntryStorage<NoneType> : public StringMapEntryBase {
+public:
+  explicit StringMapEntryStorage(size_t keyLength, NoneType none = None)
+      : StringMapEntryBase(keyLength) {}
+  StringMapEntryStorage(StringMapEntryStorage &entry) = delete;
+
+  NoneType getValue() const { return None; }
+};
+
+/// StringMapEntry - This is used to represent one value that is inserted into
+/// a StringMap.  It contains the Value itself and the key: the string length
+/// and data.
+template <typename ValueTy>
+class StringMapEntry final : public StringMapEntryStorage<ValueTy> {
+public:
+  using StringMapEntryStorage<ValueTy>::StringMapEntryStorage;
+
+  StringRef getKey() const {
+    return StringRef(getKeyData(), this->getKeyLength());
+  }
+
+  /// getKeyData - Return the start of the string data that is the key for this
+  /// value.  The string data is always stored immediately after the
+  /// StringMapEntry object.
+  const char *getKeyData() const {
+    return reinterpret_cast<const char *>(this + 1);
+  }
+
+  StringRef first() const {
+    return StringRef(getKeyData(), this->getKeyLength());
+  }
+
+  /// Create a StringMapEntry for the specified key construct the value using
+  /// \p InitiVals.
+  template <typename AllocatorTy, typename... InitTy>
+  static StringMapEntry *Create(StringRef key, AllocatorTy &allocator,
+                                InitTy &&... initVals) {
+    size_t keyLength = key.size();
+
+    // Allocate a new item with space for the string at the end and a null
+    // terminator.
+    size_t allocSize = sizeof(StringMapEntry) + keyLength + 1;
+    size_t alignment = alignof(StringMapEntry);
+
+    StringMapEntry *newItem =
+        static_cast<StringMapEntry *>(allocator.Allocate(allocSize, alignment));
+    assert(newItem && "Unhandled out-of-memory");
+
+    // Construct the value.
+    new (newItem) StringMapEntry(keyLength, std::forward<InitTy>(initVals)...);
+
+    // Copy the string information.
+    char *strBuffer = const_cast<char *>(newItem->getKeyData());
+    if (keyLength > 0)
+      memcpy(strBuffer, key.data(), keyLength);
+    strBuffer[keyLength] = 0; // Null terminate for convenience of clients.
+    return newItem;
+  }
+
+  /// GetStringMapEntryFromKeyData - Given key data that is known to be embedded
+  /// into a StringMapEntry, return the StringMapEntry itself.
+  static StringMapEntry &GetStringMapEntryFromKeyData(const char *keyData) {
+    char *ptr = const_cast<char *>(keyData) - sizeof(StringMapEntry<ValueTy>);
+    return *reinterpret_cast<StringMapEntry *>(ptr);
+  }
+
+  /// Destroy - Destroy this StringMapEntry, releasing memory back to the
+  /// specified allocator.
+  template <typename AllocatorTy> void Destroy(AllocatorTy &allocator) {
+    // Free memory referenced by the item.
+    size_t AllocSize = sizeof(StringMapEntry) + this->getKeyLength() + 1;
+    this->~StringMapEntry();
+    allocator.Deallocate(static_cast<void *>(this), AllocSize,
+                         alignof(StringMapEntry));
+  }
+};
+
+} // end namespace llvm
+
+#endif // LLVM_ADT_STRINGMAPENTRY_H
diff --git a/linux-x64/clang/include/llvm/ADT/StringRef.h b/linux-x64/clang/include/llvm/ADT/StringRef.h
index 4661b1e..98c120f 100644
--- a/linux-x64/clang/include/llvm/ADT/StringRef.h
+++ b/linux-x64/clang/include/llvm/ADT/StringRef.h
@@ -18,9 +18,18 @@
 #include <cstring>
 #include <limits>
 #include <string>
+#if __cplusplus > 201402L
+#include <string_view>
+#endif
 #include <type_traits>
 #include <utility>
 
+// Declare the __builtin_strlen intrinsic for MSVC so it can be used in
+// constexpr context.
+#if defined(_MSC_VER)
+extern "C" size_t __builtin_strlen(const char *);
+#endif
+
 namespace llvm {
 
   class APInt;
@@ -45,9 +54,9 @@
   /// situations where the character data resides in some other buffer, whose
   /// lifetime extends past that of the StringRef. For this reason, it is not in
   /// general safe to store a StringRef.
-  class StringRef {
+  class LLVM_GSL_POINTER StringRef {
   public:
-    static const size_t npos = ~size_t(0);
+    static constexpr size_t npos = ~size_t(0);
 
     using iterator = const char *;
     using const_iterator = const char *;
@@ -67,6 +76,21 @@
       return ::memcmp(Lhs,Rhs,Length);
     }
 
+    // Constexpr version of std::strlen.
+    static constexpr size_t strLen(const char *Str) {
+#if __cplusplus > 201402L
+      return std::char_traits<char>::length(Str);
+#elif __has_builtin(__builtin_strlen) || defined(__GNUC__) || \
+    (defined(_MSC_VER) && _MSC_VER >= 1916)
+      return __builtin_strlen(Str);
+#else
+      const char *Begin = Str;
+      while (*Str != '\0')
+        ++Str;
+      return Str - Begin;
+#endif
+    }
+
   public:
     /// @name Constructors
     /// @{
@@ -79,8 +103,8 @@
     StringRef(std::nullptr_t) = delete;
 
     /// Construct a string ref from a cstring.
-    /*implicit*/ StringRef(const char *Str)
-        : Data(Str), Length(Str ? ::strlen(Str) : 0) {}
+    /*implicit*/ constexpr StringRef(const char *Str)
+        : Data(Str), Length(Str ? strLen(Str) : 0) {}
 
     /// Construct a string ref from a pointer and length.
     /*implicit*/ constexpr StringRef(const char *data, size_t length)
@@ -90,6 +114,12 @@
     /*implicit*/ StringRef(const std::string &Str)
       : Data(Str.data()), Length(Str.length()) {}
 
+#if __cplusplus > 201402L
+    /// Construct a string ref from an std::string_view.
+    /*implicit*/ constexpr StringRef(std::string_view Str)
+        : Data(Str.data()), Length(Str.size()) {}
+#endif
+
     static StringRef withNullAsEmpty(const char *data) {
       return StringRef(data ? data : "");
     }
@@ -235,17 +265,20 @@
     /// The declaration here is extra complicated so that `stringRef = {}`
     /// and `stringRef = "abc"` continue to select the move assignment operator.
     template <typename T>
-    typename std::enable_if<std::is_same<T, std::string>::value,
-                            StringRef>::type &
+    std::enable_if_t<std::is_same<T, std::string>::value, StringRef> &
     operator=(T &&Str) = delete;
 
     /// @}
     /// @name Type Conversions
     /// @{
 
-    operator std::string() const {
-      return str();
+    explicit operator std::string() const { return str(); }
+
+#if __cplusplus > 201402L
+    operator std::string_view() const {
+      return std::string_view(data(), size());
     }
+#endif
 
     /// @}
     /// @name String Predicates
@@ -474,7 +507,7 @@
     /// this returns true to signify the error.  The string is considered
     /// erroneous if empty or if it overflows T.
     template <typename T>
-    typename std::enable_if<std::numeric_limits<T>::is_signed, bool>::type
+    std::enable_if_t<std::numeric_limits<T>::is_signed, bool>
     getAsInteger(unsigned Radix, T &Result) const {
       long long LLVal;
       if (getAsSignedInteger(*this, Radix, LLVal) ||
@@ -485,7 +518,7 @@
     }
 
     template <typename T>
-    typename std::enable_if<!std::numeric_limits<T>::is_signed, bool>::type
+    std::enable_if_t<!std::numeric_limits<T>::is_signed, bool>
     getAsInteger(unsigned Radix, T &Result) const {
       unsigned long long ULLVal;
       // The additional cast to unsigned long long is required to avoid the
@@ -508,7 +541,7 @@
     /// The portion of the string representing the discovered numeric value
     /// is removed from the beginning of the string.
     template <typename T>
-    typename std::enable_if<std::numeric_limits<T>::is_signed, bool>::type
+    std::enable_if_t<std::numeric_limits<T>::is_signed, bool>
     consumeInteger(unsigned Radix, T &Result) {
       long long LLVal;
       if (consumeSignedInteger(*this, Radix, LLVal) ||
@@ -519,7 +552,7 @@
     }
 
     template <typename T>
-    typename std::enable_if<!std::numeric_limits<T>::is_signed, bool>::type
+    std::enable_if_t<!std::numeric_limits<T>::is_signed, bool>
     consumeInteger(unsigned Radix, T &Result) {
       unsigned long long ULLVal;
       if (consumeUnsignedInteger(*this, Radix, ULLVal) ||
@@ -546,7 +579,8 @@
     ///
     /// If \p AllowInexact is false, the function will fail if the string
     /// cannot be represented exactly.  Otherwise, the function only fails
-    /// in case of an overflow or underflow.
+    /// in case of an overflow or underflow, or an invalid floating point
+    /// representation.
     bool getAsDouble(double &Result, bool AllowInexact = true) const;
 
     /// @}
diff --git a/linux-x64/clang/include/llvm/ADT/StringSet.h b/linux-x64/clang/include/llvm/ADT/StringSet.h
index af3a44a..c424517 100644
--- a/linux-x64/clang/include/llvm/ADT/StringSet.h
+++ b/linux-x64/clang/include/llvm/ADT/StringSet.h
@@ -1,4 +1,4 @@
-//===- StringSet.h - The LLVM Compiler Driver -------------------*- C++ -*-===//
+//===- StringSet.h - An efficient set built on StringMap --------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -14,44 +14,41 @@
 #define LLVM_ADT_STRINGSET_H
 
 #include "llvm/ADT/StringMap.h"
-#include "llvm/ADT/StringRef.h"
-#include "llvm/Support/Allocator.h"
-#include <cassert>
-#include <initializer_list>
-#include <utility>
 
 namespace llvm {
 
-  /// StringSet - A wrapper for StringMap that provides set-like functionality.
-  template <class AllocatorTy = MallocAllocator>
-  class StringSet : public StringMap<char, AllocatorTy> {
-    using base = StringMap<char, AllocatorTy>;
+/// StringSet - A wrapper for StringMap that provides set-like functionality.
+template <class AllocatorTy = MallocAllocator>
+class StringSet : public StringMap<NoneType, AllocatorTy> {
+  using Base = StringMap<NoneType, AllocatorTy>;
 
-  public:
-    StringSet() = default;
-    StringSet(std::initializer_list<StringRef> S) {
-      for (StringRef X : S)
-        insert(X);
-    }
-    explicit StringSet(AllocatorTy A) : base(A) {}
+public:
+  StringSet() = default;
+  StringSet(std::initializer_list<StringRef> initializer) {
+    for (StringRef str : initializer)
+      insert(str);
+  }
+  explicit StringSet(AllocatorTy a) : Base(a) {}
 
-    std::pair<typename base::iterator, bool> insert(StringRef Key) {
-      assert(!Key.empty());
-      return base::insert(std::make_pair(Key, '\0'));
-    }
+  std::pair<typename Base::iterator, bool> insert(StringRef key) {
+    return Base::try_emplace(key);
+  }
 
-    template <typename InputIt>
-    void insert(const InputIt &Begin, const InputIt &End) {
-      for (auto It = Begin; It != End; ++It)
-        base::insert(std::make_pair(*It, '\0'));
-    }
+  template <typename InputIt>
+  void insert(const InputIt &begin, const InputIt &end) {
+    for (auto it = begin; it != end; ++it)
+      insert(*it);
+  }
 
-    template <typename ValueTy>
-    std::pair<typename base::iterator, bool>
-    insert(const StringMapEntry<ValueTy> &MapEntry) {
-      return insert(MapEntry.getKey());
-    }
-  };
+  template <typename ValueTy>
+  std::pair<typename Base::iterator, bool>
+  insert(const StringMapEntry<ValueTy> &mapEntry) {
+    return insert(mapEntry.getKey());
+  }
+
+  /// Check if the set contains the given \c key.
+  bool contains(StringRef key) const { return Base::FindKey(key) != -1; }
+};
 
 } // end namespace llvm
 
diff --git a/linux-x64/clang/include/llvm/ADT/TinyPtrVector.h b/linux-x64/clang/include/llvm/ADT/TinyPtrVector.h
index ac82451..ed20a76 100644
--- a/linux-x64/clang/include/llvm/ADT/TinyPtrVector.h
+++ b/linux-x64/clang/include/llvm/ADT/TinyPtrVector.h
@@ -31,6 +31,10 @@
 public:
   using VecTy = SmallVector<EltTy, 4>;
   using value_type = typename VecTy::value_type;
+  // EltTy must be the first pointer type so that is<EltTy> is true for the
+  // default-constructed PtrUnion. This allows an empty TinyPtrVector to
+  // naturally vend a begin/end iterator of type EltTy* without an additional
+  // check for the empty state.
   using PtrUnion = PointerUnion<EltTy, VecTy *>;
 
 private:
@@ -96,14 +100,14 @@
       if (RHS.Val.template is<EltTy>()) {
         V->clear();
         V->push_back(RHS.front());
-        RHS.Val = (EltTy)nullptr;
+        RHS.Val = EltTy();
         return *this;
       }
       delete V;
     }
 
     Val = RHS.Val;
-    RHS.Val = (EltTy)nullptr;
+    RHS.Val = EltTy();
     return *this;
   }
 
@@ -148,10 +152,10 @@
   }
 
   // Implicit conversion to ArrayRef<U> if EltTy* implicitly converts to U*.
-  template<typename U,
-           typename std::enable_if<
-               std::is_convertible<ArrayRef<EltTy>, ArrayRef<U>>::value,
-               bool>::type = false>
+  template <
+      typename U,
+      std::enable_if_t<std::is_convertible<ArrayRef<EltTy>, ArrayRef<U>>::value,
+                       bool> = false>
   operator ArrayRef<U>() const {
     return operator ArrayRef<EltTy>();
   }
@@ -213,9 +217,9 @@
 
   EltTy operator[](unsigned i) const {
     assert(!Val.isNull() && "can't index into an empty vector");
-    if (EltTy V = Val.template dyn_cast<EltTy>()) {
+    if (Val.template is<EltTy>()) {
       assert(i == 0 && "tinyvector index out of range");
-      return V;
+      return Val.template get<EltTy>();
     }
 
     assert(i < Val.template get<VecTy*>()->size() &&
@@ -225,29 +229,29 @@
 
   EltTy front() const {
     assert(!empty() && "vector empty");
-    if (EltTy V = Val.template dyn_cast<EltTy>())
-      return V;
+    if (Val.template is<EltTy>())
+      return Val.template get<EltTy>();
     return Val.template get<VecTy*>()->front();
   }
 
   EltTy back() const {
     assert(!empty() && "vector empty");
-    if (EltTy V = Val.template dyn_cast<EltTy>())
-      return V;
+    if (Val.template is<EltTy>())
+      return Val.template get<EltTy>();
     return Val.template get<VecTy*>()->back();
   }
 
   void push_back(EltTy NewVal) {
-    assert(NewVal && "Can't add a null value");
-
     // If we have nothing, add something.
     if (Val.isNull()) {
       Val = NewVal;
+      assert(!Val.isNull() && "Can't add a null value");
       return;
     }
 
     // If we have a single value, convert to a vector.
-    if (EltTy V = Val.template dyn_cast<EltTy>()) {
+    if (Val.template is<EltTy>()) {
+      EltTy V = Val.template get<EltTy>();
       Val = new VecTy();
       Val.template get<VecTy*>()->push_back(V);
     }
@@ -267,7 +271,7 @@
   void clear() {
     // If we have a single value, convert to empty.
     if (Val.template is<EltTy>()) {
-      Val = (EltTy)nullptr;
+      Val = EltTy();
     } else if (VecTy *Vec = Val.template dyn_cast<VecTy*>()) {
       // If we have a vector form, just clear it.
       Vec->clear();
@@ -282,7 +286,7 @@
     // If we have a single value, convert to empty.
     if (Val.template is<EltTy>()) {
       if (I == begin())
-        Val = (EltTy)nullptr;
+        Val = EltTy();
     } else if (VecTy *Vec = Val.template dyn_cast<VecTy*>()) {
       // multiple items in a vector; just do the erase, there is no
       // benefit to collapsing back to a pointer
@@ -298,7 +302,7 @@
 
     if (Val.template is<EltTy>()) {
       if (S == begin() && S != E)
-        Val = (EltTy)nullptr;
+        Val = EltTy();
     } else if (VecTy *Vec = Val.template dyn_cast<VecTy*>()) {
       return Vec->erase(S, E);
     }
@@ -313,7 +317,8 @@
       return std::prev(end());
     }
     assert(!Val.isNull() && "Null value with non-end insert iterator.");
-    if (EltTy V = Val.template dyn_cast<EltTy>()) {
+    if (Val.template is<EltTy>()) {
+      EltTy V = Val.template get<EltTy>();
       assert(I == begin());
       Val = Elt;
       push_back(V);
@@ -339,7 +344,8 @@
       }
 
       Val = new VecTy();
-    } else if (EltTy V = Val.template dyn_cast<EltTy>()) {
+    } else if (Val.template is<EltTy>()) {
+      EltTy V = Val.template get<EltTy>();
       Val = new VecTy();
       Val.template get<VecTy*>()->push_back(V);
     }
diff --git a/linux-x64/clang/include/llvm/ADT/Triple.h b/linux-x64/clang/include/llvm/ADT/Triple.h
index edeb31e..f6f0155 100644
--- a/linux-x64/clang/include/llvm/ADT/Triple.h
+++ b/linux-x64/clang/include/llvm/ADT/Triple.h
@@ -19,6 +19,8 @@
 
 namespace llvm {
 
+class VersionTuple;
+
 /// Triple - Helper class for working with autoconf configuration names. For
 /// historical reasons, we also call these 'triples' (they used to contain
 /// exactly three fields).
@@ -54,6 +56,7 @@
     avr,            // AVR: Atmel AVR microcontroller
     bpfel,          // eBPF or extended BPF or 64-bit BPF (little endian)
     bpfeb,          // eBPF or extended BPF or 64-bit BPF (big endian)
+    csky,           // CSKY: csky
     hexagon,        // Hexagon: hexagon
     mips,           // MIPS: mips, mipsallegrex, mipsr6
     mipsel,         // MIPSEL: mipsel, mipsallegrexe, mipsr6el
@@ -61,6 +64,7 @@
     mips64el,       // MIPS64EL: mips64el, mips64r6el, mipsn32el, mipsn32r6el
     msp430,         // MSP430: msp430
     ppc,            // PPC: powerpc
+    ppcle,          // PPCLE: powerpc (little endian)
     ppc64,          // PPC64: powerpc64, ppu
     ppc64le,        // PPC64LE: powerpc64le
     r600,           // R600: AMD GPUs HD2XXX - HD6XXX
@@ -95,11 +99,14 @@
     wasm64,         // WebAssembly with 64-bit pointers
     renderscript32, // 32-bit RenderScript
     renderscript64, // 64-bit RenderScript
-    LastArchType = renderscript64
+    ve,             // NEC SX-Aurora Vector Engine
+    LastArchType = ve
   };
   enum SubArchType {
     NoSubArch,
 
+    ARMSubArch_v8_7a,
+    ARMSubArch_v8_6a,
     ARMSubArch_v8_5a,
     ARMSubArch_v8_4a,
     ARMSubArch_v8_3a,
@@ -124,11 +131,15 @@
     ARMSubArch_v5te,
     ARMSubArch_v4t,
 
+    AArch64SubArch_arm64e,
+
     KalimbaSubArch_v3,
     KalimbaSubArch_v4,
     KalimbaSubArch_v5,
 
-    MipsSubArch_r6
+    MipsSubArch_r6,
+
+    PPCSubArch_spe
   };
   enum VendorType {
     UnknownVendor,
@@ -136,8 +147,6 @@
     Apple,
     PC,
     SCEI,
-    BGP,
-    BGQ,
     Freescale,
     IBM,
     ImaginationTechnologies,
@@ -169,11 +178,11 @@
     OpenBSD,
     Solaris,
     Win32,
+    ZOS,
     Haiku,
     Minix,
     RTEMS,
     NaCl,       // Native Client
-    CNK,        // BG/P Compute-Node Kernel
     AIX,
     CUDA,       // NVIDIA CUDA
     NVCL,       // NVIDIA OpenCL
@@ -203,8 +212,6 @@
     CODE16,
     EABI,
     EABIHF,
-    ELFv1,
-    ELFv2,
     Android,
     Musl,
     MuslEABI,
@@ -223,6 +230,7 @@
 
     COFF,
     ELF,
+    GOFF,
     MachO,
     Wasm,
     XCOFF,
@@ -436,17 +444,7 @@
   /// compatibility, which handles supporting skewed version numbering schemes
   /// used by the "darwin" triples.
   bool isMacOSXVersionLT(unsigned Major, unsigned Minor = 0,
-                         unsigned Micro = 0) const {
-    assert(isMacOSX() && "Not an OS X triple!");
-
-    // If this is OS X, expect a sane version number.
-    if (getOS() == Triple::MacOSX)
-      return isOSVersionLT(Major, Minor, Micro);
-
-    // Otherwise, compare to the "Darwin" number.
-    assert(Major == 10 && "Unexpected major version");
-    return isOSVersionLT(Minor + 4, Micro, 0);
-  }
+                         unsigned Micro = 0) const;
 
   /// isMacOSX - Is this a Mac OS X triple. For legacy reasons, we support both
   /// "darwin" and "osx" as OS X triples.
@@ -477,7 +475,9 @@
     return getSubArch() == Triple::ARMSubArch_v7k;
   }
 
-  /// isOSDarwin - Is this a "Darwin" OS (OS X, iOS, or watchOS).
+  bool isOSzOS() const { return getOS() == Triple::ZOS; }
+
+  /// isOSDarwin - Is this a "Darwin" OS (macOS, iOS, tvOS or watchOS).
   bool isOSDarwin() const {
     return isMacOSX() || isiOS() || isWatchOS();
   }
@@ -490,6 +490,12 @@
     return getEnvironment() == Triple::MacABI;
   }
 
+  /// Returns true for targets that run on a macOS machine.
+  bool isTargetMachineMac() const {
+    return isMacOSX() || (isOSDarwin() && (isSimulatorEnvironment() ||
+                                           isMacCatalystEnvironment()));
+  }
+
   bool isOSNetBSD() const {
     return getOS() == Triple::NetBSD;
   }
@@ -629,6 +635,9 @@
     return getObjectFormat() == Triple::COFF;
   }
 
+  /// Tests whether the OS uses the GOFF binary format.
+  bool isOSBinFormatGOFF() const { return getObjectFormat() == Triple::GOFF; }
+
   /// Tests whether the environment is MachO.
   bool isOSBinFormatMachO() const {
     return getObjectFormat() == Triple::MachO;
@@ -690,6 +699,13 @@
     return getArch() == Triple::nvptx || getArch() == Triple::nvptx64;
   }
 
+  /// Tests whether the target is AMDGCN
+  bool isAMDGCN() const { return getArch() == Triple::amdgcn; }
+
+  bool isAMDGPU() const {
+    return getArch() == Triple::r600 || getArch() == Triple::amdgcn;
+  }
+
   /// Tests whether the target is Thumb (little and big endian).
   bool isThumb() const {
     return getArch() == Triple::thumb || getArch() == Triple::thumbeb;
@@ -702,7 +718,17 @@
 
   /// Tests whether the target is AArch64 (little and big endian).
   bool isAArch64() const {
-    return getArch() == Triple::aarch64 || getArch() == Triple::aarch64_be;
+    return getArch() == Triple::aarch64 || getArch() == Triple::aarch64_be ||
+           getArch() == Triple::aarch64_32;
+  }
+
+  /// Tests whether the target is AArch64 and pointers are the size specified by
+  /// \p PointerWidth.
+  bool isAArch64(int PointerWidth) const {
+    assert(PointerWidth == 64 || PointerWidth == 32);
+    if (!isAArch64())
+      return false;
+    return isArch64Bit() ? PointerWidth == 64 : PointerWidth == 32;
   }
 
   /// Tests whether the target is MIPS 32-bit (little and big endian).
@@ -720,6 +746,17 @@
     return isMIPS32() || isMIPS64();
   }
 
+  /// Tests whether the target is PowerPC (32- or 64-bit LE or BE).
+  bool isPPC() const {
+    return getArch() == Triple::ppc || getArch() == Triple::ppc64 ||
+           getArch() == Triple::ppcle || getArch() == Triple::ppc64le;
+  }
+
+  /// Tests whether the target is 32-bit PowerPC (little and big endian).
+  bool isPPC32() const {
+    return getArch() == Triple::ppc || getArch() == Triple::ppcle;
+  }
+
   /// Tests whether the target is 64-bit PowerPC (little and big endian).
   bool isPPC64() const {
     return getArch() == Triple::ppc64 || getArch() == Triple::ppc64le;
@@ -730,9 +767,40 @@
     return getArch() == Triple::riscv32 || getArch() == Triple::riscv64;
   }
 
+  /// Tests whether the target is SystemZ.
+  bool isSystemZ() const {
+    return getArch() == Triple::systemz;
+  }
+
+  /// Tests whether the target is x86 (32- or 64-bit).
+  bool isX86() const {
+    return getArch() == Triple::x86 || getArch() == Triple::x86_64;
+  }
+
+  /// Tests whether the target is VE
+  bool isVE() const {
+    return getArch() == Triple::ve;
+  }
+
+  /// Tests whether the target is wasm (32- and 64-bit).
+  bool isWasm() const {
+    return getArch() == Triple::wasm32 || getArch() == Triple::wasm64;
+  }
+
+  // Tests whether the target is CSKY
+  bool isCSKY() const {
+    return getArch() == Triple::csky;
+  }
+
+  /// Tests whether the target is the Apple "arm64e" AArch64 subarch.
+  bool isArm64e() const {
+    return getArch() == Triple::aarch64 &&
+           getSubArch() == Triple::AArch64SubArch_arm64e;
+  }
+
   /// Tests whether the target supports comdat
   bool supportsCOMDAT() const {
-    return !isOSBinFormatMachO();
+    return !(isOSBinFormatMachO() || isOSBinFormatXCOFF());
   }
 
   /// Tests whether the target uses emulated TLS as default.
@@ -740,6 +808,14 @@
     return isAndroid() || isOSOpenBSD() || isWindowsCygwinEnvironment();
   }
 
+  /// Tests whether the target uses -data-sections as default.
+  bool hasDefaultDataSections() const {
+    return isOSBinFormatXCOFF() || isWasm();
+  }
+
+  /// Tests if the environment supports dllimport/export annotations.
+  bool hasDLLImportExport() const { return isOSWindows() || isPS4CPU(); }
+
   /// @}
   /// @name Mutators
   /// @{
@@ -839,6 +915,12 @@
   /// Merge target triples.
   std::string merge(const Triple &Other) const;
 
+  /// Some platforms have different minimum supported OS versions that
+  /// varies by the architecture specified in the triple. This function
+  /// returns the minimum supported OS version for this triple if one an exists,
+  /// or an invalid version tuple if this triple doesn't have one.
+  VersionTuple getMinimumSupportedOSVersion() const;
+
   /// @}
   /// @name Static helpers for IDs.
   /// @{
@@ -873,6 +955,10 @@
   static ArchType getArchTypeForLLVMName(StringRef Str);
 
   /// @}
+
+  /// Returns a canonicalized OS version number for the specified OS.
+  static VersionTuple getCanonicalVersionForOS(OSType OSKind,
+                                               const VersionTuple &Version);
 };
 
 } // End llvm namespace
diff --git a/linux-x64/clang/include/llvm/ADT/TypeSwitch.h b/linux-x64/clang/include/llvm/ADT/TypeSwitch.h
new file mode 100644
index 0000000..bfcb206
--- /dev/null
+++ b/linux-x64/clang/include/llvm/ADT/TypeSwitch.h
@@ -0,0 +1,176 @@
+//===- TypeSwitch.h - Switch functionality for RTTI casting -*- C++ -*-----===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+//  This file implements the TypeSwitch template, which mimics a switch()
+//  statement whose cases are type names.
+//
+//===-----------------------------------------------------------------------===/
+
+#ifndef LLVM_ADT_TYPESWITCH_H
+#define LLVM_ADT_TYPESWITCH_H
+
+#include "llvm/ADT/Optional.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/Support/Casting.h"
+
+namespace llvm {
+namespace detail {
+
+template <typename DerivedT, typename T> class TypeSwitchBase {
+public:
+  TypeSwitchBase(const T &value) : value(value) {}
+  TypeSwitchBase(TypeSwitchBase &&other) : value(other.value) {}
+  ~TypeSwitchBase() = default;
+
+  /// TypeSwitchBase is not copyable.
+  TypeSwitchBase(const TypeSwitchBase &) = delete;
+  void operator=(const TypeSwitchBase &) = delete;
+  void operator=(TypeSwitchBase &&other) = delete;
+
+  /// Invoke a case on the derived class with multiple case types.
+  template <typename CaseT, typename CaseT2, typename... CaseTs,
+            typename CallableT>
+  DerivedT &Case(CallableT &&caseFn) {
+    DerivedT &derived = static_cast<DerivedT &>(*this);
+    return derived.template Case<CaseT>(caseFn)
+        .template Case<CaseT2, CaseTs...>(caseFn);
+  }
+
+  /// Invoke a case on the derived class, inferring the type of the Case from
+  /// the first input of the given callable.
+  /// Note: This inference rules for this overload are very simple: strip
+  ///       pointers and references.
+  template <typename CallableT> DerivedT &Case(CallableT &&caseFn) {
+    using Traits = function_traits<std::decay_t<CallableT>>;
+    using CaseT = std::remove_cv_t<std::remove_pointer_t<
+        std::remove_reference_t<typename Traits::template arg_t<0>>>>;
+
+    DerivedT &derived = static_cast<DerivedT &>(*this);
+    return derived.template Case<CaseT>(std::forward<CallableT>(caseFn));
+  }
+
+protected:
+  /// Trait to check whether `ValueT` provides a 'dyn_cast' method with type
+  /// `CastT`.
+  template <typename ValueT, typename CastT>
+  using has_dyn_cast_t =
+      decltype(std::declval<ValueT &>().template dyn_cast<CastT>());
+
+  /// Attempt to dyn_cast the given `value` to `CastT`. This overload is
+  /// selected if `value` already has a suitable dyn_cast method.
+  template <typename CastT, typename ValueT>
+  static auto castValue(
+      ValueT value,
+      typename std::enable_if_t<
+          is_detected<has_dyn_cast_t, ValueT, CastT>::value> * = nullptr) {
+    return value.template dyn_cast<CastT>();
+  }
+
+  /// Attempt to dyn_cast the given `value` to `CastT`. This overload is
+  /// selected if llvm::dyn_cast should be used.
+  template <typename CastT, typename ValueT>
+  static auto castValue(
+      ValueT value,
+      typename std::enable_if_t<
+          !is_detected<has_dyn_cast_t, ValueT, CastT>::value> * = nullptr) {
+    return dyn_cast<CastT>(value);
+  }
+
+  /// The root value we are switching on.
+  const T value;
+};
+} // end namespace detail
+
+/// This class implements a switch-like dispatch statement for a value of 'T'
+/// using dyn_cast functionality. Each `Case<T>` takes a callable to be invoked
+/// if the root value isa<T>, the callable is invoked with the result of
+/// dyn_cast<T>() as a parameter.
+///
+/// Example:
+///  Operation *op = ...;
+///  LogicalResult result = TypeSwitch<Operation *, LogicalResult>(op)
+///    .Case<ConstantOp>([](ConstantOp op) { ... })
+///    .Default([](Operation *op) { ... });
+///
+template <typename T, typename ResultT = void>
+class TypeSwitch : public detail::TypeSwitchBase<TypeSwitch<T, ResultT>, T> {
+public:
+  using BaseT = detail::TypeSwitchBase<TypeSwitch<T, ResultT>, T>;
+  using BaseT::BaseT;
+  using BaseT::Case;
+  TypeSwitch(TypeSwitch &&other) = default;
+
+  /// Add a case on the given type.
+  template <typename CaseT, typename CallableT>
+  TypeSwitch<T, ResultT> &Case(CallableT &&caseFn) {
+    if (result)
+      return *this;
+
+    // Check to see if CaseT applies to 'value'.
+    if (auto caseValue = BaseT::template castValue<CaseT>(this->value))
+      result = caseFn(caseValue);
+    return *this;
+  }
+
+  /// As a default, invoke the given callable within the root value.
+  template <typename CallableT>
+  LLVM_NODISCARD ResultT Default(CallableT &&defaultFn) {
+    if (result)
+      return std::move(*result);
+    return defaultFn(this->value);
+  }
+
+  LLVM_NODISCARD
+  operator ResultT() {
+    assert(result && "Fell off the end of a type-switch");
+    return std::move(*result);
+  }
+
+private:
+  /// The pointer to the result of this switch statement, once known,
+  /// null before that.
+  Optional<ResultT> result;
+};
+
+/// Specialization of TypeSwitch for void returning callables.
+template <typename T>
+class TypeSwitch<T, void>
+    : public detail::TypeSwitchBase<TypeSwitch<T, void>, T> {
+public:
+  using BaseT = detail::TypeSwitchBase<TypeSwitch<T, void>, T>;
+  using BaseT::BaseT;
+  using BaseT::Case;
+  TypeSwitch(TypeSwitch &&other) = default;
+
+  /// Add a case on the given type.
+  template <typename CaseT, typename CallableT>
+  TypeSwitch<T, void> &Case(CallableT &&caseFn) {
+    if (foundMatch)
+      return *this;
+
+    // Check to see if any of the types apply to 'value'.
+    if (auto caseValue = BaseT::template castValue<CaseT>(this->value)) {
+      caseFn(caseValue);
+      foundMatch = true;
+    }
+    return *this;
+  }
+
+  /// As a default, invoke the given callable within the root value.
+  template <typename CallableT> void Default(CallableT &&defaultFn) {
+    if (!foundMatch)
+      defaultFn(this->value);
+  }
+
+private:
+  /// A flag detailing if we have already found a match.
+  bool foundMatch = false;
+};
+} // end namespace llvm
+
+#endif // LLVM_ADT_TYPESWITCH_H
diff --git a/linux-x64/clang/include/llvm/ADT/VariadicFunction.h b/linux-x64/clang/include/llvm/ADT/VariadicFunction.h
deleted file mode 100644
index 5aefb05..0000000
--- a/linux-x64/clang/include/llvm/ADT/VariadicFunction.h
+++ /dev/null
@@ -1,330 +0,0 @@
-//===- VariadicFunction.h - Variadic Functions ------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-//  This file implements compile-time type-safe variadic functions.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_ADT_VARIADICFUNCTION_H
-#define LLVM_ADT_VARIADICFUNCTION_H
-
-#include "llvm/ADT/ArrayRef.h"
-
-namespace llvm {
-
-// Define macros to aid in expanding a comma separated series with the index of
-// the series pasted onto the last token.
-#define LLVM_COMMA_JOIN1(x) x ## 0
-#define LLVM_COMMA_JOIN2(x) LLVM_COMMA_JOIN1(x), x ## 1
-#define LLVM_COMMA_JOIN3(x) LLVM_COMMA_JOIN2(x), x ## 2
-#define LLVM_COMMA_JOIN4(x) LLVM_COMMA_JOIN3(x), x ## 3
-#define LLVM_COMMA_JOIN5(x) LLVM_COMMA_JOIN4(x), x ## 4
-#define LLVM_COMMA_JOIN6(x) LLVM_COMMA_JOIN5(x), x ## 5
-#define LLVM_COMMA_JOIN7(x) LLVM_COMMA_JOIN6(x), x ## 6
-#define LLVM_COMMA_JOIN8(x) LLVM_COMMA_JOIN7(x), x ## 7
-#define LLVM_COMMA_JOIN9(x) LLVM_COMMA_JOIN8(x), x ## 8
-#define LLVM_COMMA_JOIN10(x) LLVM_COMMA_JOIN9(x), x ## 9
-#define LLVM_COMMA_JOIN11(x) LLVM_COMMA_JOIN10(x), x ## 10
-#define LLVM_COMMA_JOIN12(x) LLVM_COMMA_JOIN11(x), x ## 11
-#define LLVM_COMMA_JOIN13(x) LLVM_COMMA_JOIN12(x), x ## 12
-#define LLVM_COMMA_JOIN14(x) LLVM_COMMA_JOIN13(x), x ## 13
-#define LLVM_COMMA_JOIN15(x) LLVM_COMMA_JOIN14(x), x ## 14
-#define LLVM_COMMA_JOIN16(x) LLVM_COMMA_JOIN15(x), x ## 15
-#define LLVM_COMMA_JOIN17(x) LLVM_COMMA_JOIN16(x), x ## 16
-#define LLVM_COMMA_JOIN18(x) LLVM_COMMA_JOIN17(x), x ## 17
-#define LLVM_COMMA_JOIN19(x) LLVM_COMMA_JOIN18(x), x ## 18
-#define LLVM_COMMA_JOIN20(x) LLVM_COMMA_JOIN19(x), x ## 19
-#define LLVM_COMMA_JOIN21(x) LLVM_COMMA_JOIN20(x), x ## 20
-#define LLVM_COMMA_JOIN22(x) LLVM_COMMA_JOIN21(x), x ## 21
-#define LLVM_COMMA_JOIN23(x) LLVM_COMMA_JOIN22(x), x ## 22
-#define LLVM_COMMA_JOIN24(x) LLVM_COMMA_JOIN23(x), x ## 23
-#define LLVM_COMMA_JOIN25(x) LLVM_COMMA_JOIN24(x), x ## 24
-#define LLVM_COMMA_JOIN26(x) LLVM_COMMA_JOIN25(x), x ## 25
-#define LLVM_COMMA_JOIN27(x) LLVM_COMMA_JOIN26(x), x ## 26
-#define LLVM_COMMA_JOIN28(x) LLVM_COMMA_JOIN27(x), x ## 27
-#define LLVM_COMMA_JOIN29(x) LLVM_COMMA_JOIN28(x), x ## 28
-#define LLVM_COMMA_JOIN30(x) LLVM_COMMA_JOIN29(x), x ## 29
-#define LLVM_COMMA_JOIN31(x) LLVM_COMMA_JOIN30(x), x ## 30
-#define LLVM_COMMA_JOIN32(x) LLVM_COMMA_JOIN31(x), x ## 31
-
-/// Class which can simulate a type-safe variadic function.
-///
-/// The VariadicFunction class template makes it easy to define
-/// type-safe variadic functions where all arguments have the same
-/// type.
-///
-/// Suppose we need a variadic function like this:
-///
-///   ResultT Foo(const ArgT &A_0, const ArgT &A_1, ..., const ArgT &A_N);
-///
-/// Instead of many overloads of Foo(), we only need to define a helper
-/// function that takes an array of arguments:
-///
-///   ResultT FooImpl(ArrayRef<const ArgT *> Args) {
-///     // 'Args[i]' is a pointer to the i-th argument passed to Foo().
-///     ...
-///   }
-///
-/// and then define Foo() like this:
-///
-///   const VariadicFunction<ResultT, ArgT, FooImpl> Foo;
-///
-/// VariadicFunction takes care of defining the overloads of Foo().
-///
-/// Actually, Foo is a function object (i.e. functor) instead of a plain
-/// function.  This object is stateless and its constructor/destructor
-/// does nothing, so it's safe to create global objects and call Foo(...) at
-/// any time.
-///
-/// Sometimes we need a variadic function to have some fixed leading
-/// arguments whose types may be different from that of the optional
-/// arguments.  For example:
-///
-///   bool FullMatch(const StringRef &S, const RE &Regex,
-///                  const ArgT &A_0, ..., const ArgT &A_N);
-///
-/// VariadicFunctionN is for such cases, where N is the number of fixed
-/// arguments.  It is like VariadicFunction, except that it takes N more
-/// template arguments for the types of the fixed arguments:
-///
-///   bool FullMatchImpl(const StringRef &S, const RE &Regex,
-///                      ArrayRef<const ArgT *> Args) { ... }
-///   const VariadicFunction2<bool, const StringRef&,
-///                           const RE&, ArgT, FullMatchImpl>
-///       FullMatch;
-///
-/// Currently VariadicFunction and friends support up-to 3
-/// fixed leading arguments and up-to 32 optional arguments.
-template <typename ResultT, typename ArgT,
-          ResultT (*Func)(ArrayRef<const ArgT *>)>
-struct VariadicFunction {
-  ResultT operator()() const {
-    return Func(None);
-  }
-
-#define LLVM_DEFINE_OVERLOAD(N) \
-  ResultT operator()(LLVM_COMMA_JOIN ## N(const ArgT &A)) const { \
-    const ArgT *const Args[] = { LLVM_COMMA_JOIN ## N(&A) }; \
-    return Func(makeArrayRef(Args)); \
-  }
-  LLVM_DEFINE_OVERLOAD(1)
-  LLVM_DEFINE_OVERLOAD(2)
-  LLVM_DEFINE_OVERLOAD(3)
-  LLVM_DEFINE_OVERLOAD(4)
-  LLVM_DEFINE_OVERLOAD(5)
-  LLVM_DEFINE_OVERLOAD(6)
-  LLVM_DEFINE_OVERLOAD(7)
-  LLVM_DEFINE_OVERLOAD(8)
-  LLVM_DEFINE_OVERLOAD(9)
-  LLVM_DEFINE_OVERLOAD(10)
-  LLVM_DEFINE_OVERLOAD(11)
-  LLVM_DEFINE_OVERLOAD(12)
-  LLVM_DEFINE_OVERLOAD(13)
-  LLVM_DEFINE_OVERLOAD(14)
-  LLVM_DEFINE_OVERLOAD(15)
-  LLVM_DEFINE_OVERLOAD(16)
-  LLVM_DEFINE_OVERLOAD(17)
-  LLVM_DEFINE_OVERLOAD(18)
-  LLVM_DEFINE_OVERLOAD(19)
-  LLVM_DEFINE_OVERLOAD(20)
-  LLVM_DEFINE_OVERLOAD(21)
-  LLVM_DEFINE_OVERLOAD(22)
-  LLVM_DEFINE_OVERLOAD(23)
-  LLVM_DEFINE_OVERLOAD(24)
-  LLVM_DEFINE_OVERLOAD(25)
-  LLVM_DEFINE_OVERLOAD(26)
-  LLVM_DEFINE_OVERLOAD(27)
-  LLVM_DEFINE_OVERLOAD(28)
-  LLVM_DEFINE_OVERLOAD(29)
-  LLVM_DEFINE_OVERLOAD(30)
-  LLVM_DEFINE_OVERLOAD(31)
-  LLVM_DEFINE_OVERLOAD(32)
-#undef LLVM_DEFINE_OVERLOAD
-};
-
-template <typename ResultT, typename Param0T, typename ArgT,
-          ResultT (*Func)(Param0T, ArrayRef<const ArgT *>)>
-struct VariadicFunction1 {
-  ResultT operator()(Param0T P0) const {
-    return Func(P0, None);
-  }
-
-#define LLVM_DEFINE_OVERLOAD(N) \
-  ResultT operator()(Param0T P0, LLVM_COMMA_JOIN ## N(const ArgT &A)) const { \
-    const ArgT *const Args[] = { LLVM_COMMA_JOIN ## N(&A) }; \
-    return Func(P0, makeArrayRef(Args)); \
-  }
-  LLVM_DEFINE_OVERLOAD(1)
-  LLVM_DEFINE_OVERLOAD(2)
-  LLVM_DEFINE_OVERLOAD(3)
-  LLVM_DEFINE_OVERLOAD(4)
-  LLVM_DEFINE_OVERLOAD(5)
-  LLVM_DEFINE_OVERLOAD(6)
-  LLVM_DEFINE_OVERLOAD(7)
-  LLVM_DEFINE_OVERLOAD(8)
-  LLVM_DEFINE_OVERLOAD(9)
-  LLVM_DEFINE_OVERLOAD(10)
-  LLVM_DEFINE_OVERLOAD(11)
-  LLVM_DEFINE_OVERLOAD(12)
-  LLVM_DEFINE_OVERLOAD(13)
-  LLVM_DEFINE_OVERLOAD(14)
-  LLVM_DEFINE_OVERLOAD(15)
-  LLVM_DEFINE_OVERLOAD(16)
-  LLVM_DEFINE_OVERLOAD(17)
-  LLVM_DEFINE_OVERLOAD(18)
-  LLVM_DEFINE_OVERLOAD(19)
-  LLVM_DEFINE_OVERLOAD(20)
-  LLVM_DEFINE_OVERLOAD(21)
-  LLVM_DEFINE_OVERLOAD(22)
-  LLVM_DEFINE_OVERLOAD(23)
-  LLVM_DEFINE_OVERLOAD(24)
-  LLVM_DEFINE_OVERLOAD(25)
-  LLVM_DEFINE_OVERLOAD(26)
-  LLVM_DEFINE_OVERLOAD(27)
-  LLVM_DEFINE_OVERLOAD(28)
-  LLVM_DEFINE_OVERLOAD(29)
-  LLVM_DEFINE_OVERLOAD(30)
-  LLVM_DEFINE_OVERLOAD(31)
-  LLVM_DEFINE_OVERLOAD(32)
-#undef LLVM_DEFINE_OVERLOAD
-};
-
-template <typename ResultT, typename Param0T, typename Param1T, typename ArgT,
-          ResultT (*Func)(Param0T, Param1T, ArrayRef<const ArgT *>)>
-struct VariadicFunction2 {
-  ResultT operator()(Param0T P0, Param1T P1) const {
-    return Func(P0, P1, None);
-  }
-
-#define LLVM_DEFINE_OVERLOAD(N) \
-  ResultT operator()(Param0T P0, Param1T P1, \
-                     LLVM_COMMA_JOIN ## N(const ArgT &A)) const { \
-    const ArgT *const Args[] = { LLVM_COMMA_JOIN ## N(&A) }; \
-    return Func(P0, P1, makeArrayRef(Args)); \
-  }
-  LLVM_DEFINE_OVERLOAD(1)
-  LLVM_DEFINE_OVERLOAD(2)
-  LLVM_DEFINE_OVERLOAD(3)
-  LLVM_DEFINE_OVERLOAD(4)
-  LLVM_DEFINE_OVERLOAD(5)
-  LLVM_DEFINE_OVERLOAD(6)
-  LLVM_DEFINE_OVERLOAD(7)
-  LLVM_DEFINE_OVERLOAD(8)
-  LLVM_DEFINE_OVERLOAD(9)
-  LLVM_DEFINE_OVERLOAD(10)
-  LLVM_DEFINE_OVERLOAD(11)
-  LLVM_DEFINE_OVERLOAD(12)
-  LLVM_DEFINE_OVERLOAD(13)
-  LLVM_DEFINE_OVERLOAD(14)
-  LLVM_DEFINE_OVERLOAD(15)
-  LLVM_DEFINE_OVERLOAD(16)
-  LLVM_DEFINE_OVERLOAD(17)
-  LLVM_DEFINE_OVERLOAD(18)
-  LLVM_DEFINE_OVERLOAD(19)
-  LLVM_DEFINE_OVERLOAD(20)
-  LLVM_DEFINE_OVERLOAD(21)
-  LLVM_DEFINE_OVERLOAD(22)
-  LLVM_DEFINE_OVERLOAD(23)
-  LLVM_DEFINE_OVERLOAD(24)
-  LLVM_DEFINE_OVERLOAD(25)
-  LLVM_DEFINE_OVERLOAD(26)
-  LLVM_DEFINE_OVERLOAD(27)
-  LLVM_DEFINE_OVERLOAD(28)
-  LLVM_DEFINE_OVERLOAD(29)
-  LLVM_DEFINE_OVERLOAD(30)
-  LLVM_DEFINE_OVERLOAD(31)
-  LLVM_DEFINE_OVERLOAD(32)
-#undef LLVM_DEFINE_OVERLOAD
-};
-
-template <typename ResultT, typename Param0T, typename Param1T,
-          typename Param2T, typename ArgT,
-          ResultT (*Func)(Param0T, Param1T, Param2T, ArrayRef<const ArgT *>)>
-struct VariadicFunction3 {
-  ResultT operator()(Param0T P0, Param1T P1, Param2T P2) const {
-    return Func(P0, P1, P2, None);
-  }
-
-#define LLVM_DEFINE_OVERLOAD(N) \
-  ResultT operator()(Param0T P0, Param1T P1, Param2T P2, \
-                     LLVM_COMMA_JOIN ## N(const ArgT &A)) const { \
-    const ArgT *const Args[] = { LLVM_COMMA_JOIN ## N(&A) }; \
-    return Func(P0, P1, P2, makeArrayRef(Args)); \
-  }
-  LLVM_DEFINE_OVERLOAD(1)
-  LLVM_DEFINE_OVERLOAD(2)
-  LLVM_DEFINE_OVERLOAD(3)
-  LLVM_DEFINE_OVERLOAD(4)
-  LLVM_DEFINE_OVERLOAD(5)
-  LLVM_DEFINE_OVERLOAD(6)
-  LLVM_DEFINE_OVERLOAD(7)
-  LLVM_DEFINE_OVERLOAD(8)
-  LLVM_DEFINE_OVERLOAD(9)
-  LLVM_DEFINE_OVERLOAD(10)
-  LLVM_DEFINE_OVERLOAD(11)
-  LLVM_DEFINE_OVERLOAD(12)
-  LLVM_DEFINE_OVERLOAD(13)
-  LLVM_DEFINE_OVERLOAD(14)
-  LLVM_DEFINE_OVERLOAD(15)
-  LLVM_DEFINE_OVERLOAD(16)
-  LLVM_DEFINE_OVERLOAD(17)
-  LLVM_DEFINE_OVERLOAD(18)
-  LLVM_DEFINE_OVERLOAD(19)
-  LLVM_DEFINE_OVERLOAD(20)
-  LLVM_DEFINE_OVERLOAD(21)
-  LLVM_DEFINE_OVERLOAD(22)
-  LLVM_DEFINE_OVERLOAD(23)
-  LLVM_DEFINE_OVERLOAD(24)
-  LLVM_DEFINE_OVERLOAD(25)
-  LLVM_DEFINE_OVERLOAD(26)
-  LLVM_DEFINE_OVERLOAD(27)
-  LLVM_DEFINE_OVERLOAD(28)
-  LLVM_DEFINE_OVERLOAD(29)
-  LLVM_DEFINE_OVERLOAD(30)
-  LLVM_DEFINE_OVERLOAD(31)
-  LLVM_DEFINE_OVERLOAD(32)
-#undef LLVM_DEFINE_OVERLOAD
-};
-
-// Cleanup the macro namespace.
-#undef LLVM_COMMA_JOIN1
-#undef LLVM_COMMA_JOIN2
-#undef LLVM_COMMA_JOIN3
-#undef LLVM_COMMA_JOIN4
-#undef LLVM_COMMA_JOIN5
-#undef LLVM_COMMA_JOIN6
-#undef LLVM_COMMA_JOIN7
-#undef LLVM_COMMA_JOIN8
-#undef LLVM_COMMA_JOIN9
-#undef LLVM_COMMA_JOIN10
-#undef LLVM_COMMA_JOIN11
-#undef LLVM_COMMA_JOIN12
-#undef LLVM_COMMA_JOIN13
-#undef LLVM_COMMA_JOIN14
-#undef LLVM_COMMA_JOIN15
-#undef LLVM_COMMA_JOIN16
-#undef LLVM_COMMA_JOIN17
-#undef LLVM_COMMA_JOIN18
-#undef LLVM_COMMA_JOIN19
-#undef LLVM_COMMA_JOIN20
-#undef LLVM_COMMA_JOIN21
-#undef LLVM_COMMA_JOIN22
-#undef LLVM_COMMA_JOIN23
-#undef LLVM_COMMA_JOIN24
-#undef LLVM_COMMA_JOIN25
-#undef LLVM_COMMA_JOIN26
-#undef LLVM_COMMA_JOIN27
-#undef LLVM_COMMA_JOIN28
-#undef LLVM_COMMA_JOIN29
-#undef LLVM_COMMA_JOIN30
-#undef LLVM_COMMA_JOIN31
-#undef LLVM_COMMA_JOIN32
-
-} // end namespace llvm
-
-#endif  // LLVM_ADT_VARIADICFUNCTION_H
diff --git a/linux-x64/clang/include/llvm/ADT/Waymarking.h b/linux-x64/clang/include/llvm/ADT/Waymarking.h
new file mode 100644
index 0000000..f00bc10
--- /dev/null
+++ b/linux-x64/clang/include/llvm/ADT/Waymarking.h
@@ -0,0 +1,325 @@
+//===- Waymarking.h - Array waymarking algorithm ----------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Utility to backtrace an array's head, from a pointer into it. For the
+// backtrace to work, we use "Waymarks", which are special tags embedded into
+// the array's elements.
+//
+// A Tag of n-bits (in size) is composed as follows:
+//
+// bits: |   n-1   |             n-2 ... 0              |
+//       .---------.------------------------------------.
+//       |Stop Mask|(2^(n-1))-ary numeric system - digit|
+//       '---------'------------------------------------'
+//
+// Backtracing is done as follows:
+// Walk back (starting from a given pointer to an element into the array), until
+// a tag with a "Stop Mask" is reached. Then start calculating the "Offset" from
+// the array's head, by picking up digits along the way, until another stop is
+// reached. The "Offset" is then subtracted from the current pointer, and the
+// result is the array's head.
+// A special case - if we first encounter a Tag with a Stop and a zero digit,
+// then this is already the head.
+//
+// For example:
+// In case of 2 bits:
+//
+// Tags:
+// x0 - binary digit 0
+// x1 - binary digit 1
+// 1x - stop and calculate (s)
+//
+// Array:
+//         .---.---.---.---.---.---.---.---.---.---.---.---.---.---.---.---.
+// head -> |s0 |s1 | 0 |s1 | 0 | 0 |s1 | 1 | 1 |s1 | 0 | 1 | 0 |s1 | 0 | 1 |
+//         '---'---'---'---'---'---'---'---'---'---'---'---'---'---'---'---'
+//             |-1 |-2     |-4         |-7         |-10            |-14
+//          <_ |   |       |           |           |               |
+//          <_____ |       |           |           |               |
+//          <_____________ |           |           |               |
+//          <_________________________ |           |               |
+//          <_____________________________________ |               |
+//          <_____________________________________________________ |
+//
+//
+// In case of 3 bits:
+//
+// Tags:
+// x00 - quaternary digit 0
+// x01 - quaternary digit 1
+// x10 - quaternary digit 2
+// x11 - quaternary digit 3
+// 1xy - stop and calculate (s)
+//
+// Array:
+//         .---.---.---.---.---.---.---.---.---.---.---.---.---.---.---.---.
+// head -> |s0 |s1 |s2 |s3 | 0 |s1 | 2 |s1 | 0 |s2 | 2 |s2 | 0 |s3 | 2 |s3 |
+//         '---'---'---'---'---'---'---'---'---'---'---'---'---'---'---'---'
+//             |-1 |-2 |-3 |-4     |-6     |-8     |-10    |-12    |-14    |-16
+//          <_ |   |   |   |       |       |       |       |       |       |
+//          <_____ |   |   |       |       |       |       |       |       |
+//          <_________ |   |       |       |       |       |       |       |
+//          <_____________ |       |       |       |       |       |       |
+//          <_____________________ |       |       |       |       |       |
+//          <_____________________________ |       |       |       |       |
+//          <_____________________________________ |       |       |       |
+//          <_____________________________________________ |       |       |
+//          <_____________________________________________________ |       |
+//          <_____________________________________________________________ |
+//
+//
+// The API introduce 2 functions:
+// 1. fillWaymarks
+// 2. followWaymarks
+//
+// Example:
+//   int N = 10;
+//   int M = 5;
+//   int **A = new int *[N + M];   // Define the array.
+//   for (int I = 0; I < N + M; ++I)
+//     A[I] = new int(I);
+//
+//   fillWaymarks(A, A + N);       // Set the waymarks for the first N elements
+//                                 // of the array.
+//                                 // Note that it must be done AFTER we fill
+//                                 // the array's elements.
+//
+//   ...                           // Elements which are not in the range
+//                                 // [A, A+N) will not be marked, and we won't
+//                                 // be able to call followWaymarks on them.
+//
+//   ...                           // Elements which will be changed after the
+//                                 // call to fillWaymarks, will have to be
+//                                 // retagged.
+//
+//   fillWaymarks(A + N, A + N + M, N); // Set the waymarks of the remaining M
+//                                      // elements.
+//   ...
+//   int **It = A + N + 1;
+//   int **B = followWaymarks(It); // Find the head of the array containing It.
+//   assert(B == A);
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_ADT_WAYMARKING_H
+#define LLVM_ADT_WAYMARKING_H
+
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/Support/PointerLikeTypeTraits.h"
+
+namespace llvm {
+
+namespace detail {
+
+template <unsigned NumBits> struct WaymarkingTraits {
+  enum : unsigned {
+    // The number of bits of a Waymarking Tag.
+    NUM_BITS = NumBits,
+
+    // A Tag is composed from a Mark and a Stop mask.
+    MARK_SIZE = NUM_BITS - 1,
+    STOP_MASK = (1 << MARK_SIZE),
+    MARK_MASK = (STOP_MASK - 1),
+    TAG_MASK = (MARK_MASK | STOP_MASK),
+
+    // The number of pre-computed tags (for fast fill).
+    NUM_STATIC_TAGS = 32
+  };
+
+private:
+  // Add a new tag, calculated from Count and Stop, to the Vals pack, while
+  // continuing recursively to decrease Len down to 0.
+  template <unsigned Len, bool Stop, unsigned Count, uint8_t... Vals>
+  struct AddTag;
+
+  // Delegate to the specialized AddTag according to the need of a Stop mask.
+  template <unsigned Len, unsigned Count, uint8_t... Vals> struct GenTag {
+    typedef
+        typename AddTag<Len, (Count <= MARK_MASK), Count, Vals...>::Xdata Xdata;
+  };
+
+  // Start adding tags while calculating the next Count, which is actually the
+  // number of already calculated tags (equivalent to the position in the
+  // array).
+  template <unsigned Len, uint8_t... Vals> struct GenOffset {
+    typedef typename GenTag<Len, sizeof...(Vals), Vals...>::Xdata Xdata;
+  };
+
+  // Add the tag and remove it from Count.
+  template <unsigned Len, unsigned Count, uint8_t... Vals>
+  struct AddTag<Len, false, Count, Vals...> {
+    typedef typename GenTag<Len - 1, (Count >> MARK_SIZE), Vals...,
+                            Count & MARK_MASK>::Xdata Xdata;
+  };
+
+  // We have reached the end of this Count, so start with a new Count.
+  template <unsigned Len, unsigned Count, uint8_t... Vals>
+  struct AddTag<Len, true, Count, Vals...> {
+    typedef typename GenOffset<Len - 1, Vals...,
+                               (Count & MARK_MASK) | STOP_MASK>::Xdata Xdata;
+  };
+
+  template <unsigned Count, uint8_t... Vals> struct TagsData {
+    // The remaining number for calculating the next tag, following the last one
+    // in Values.
+    static const unsigned Remain = Count;
+
+    // The array of ordered pre-computed Tags.
+    static const uint8_t Values[sizeof...(Vals)];
+  };
+
+  // Specialize the case when Len equals 0, as the recursion stop condition.
+  template <unsigned Count, uint8_t... Vals>
+  struct AddTag<0, false, Count, Vals...> {
+    typedef TagsData<Count, Vals...> Xdata;
+  };
+
+  template <unsigned Count, uint8_t... Vals>
+  struct AddTag<0, true, Count, Vals...> {
+    typedef TagsData<Count, Vals...> Xdata;
+  };
+
+public:
+  typedef typename GenOffset<NUM_STATIC_TAGS>::Xdata Tags;
+};
+
+template <unsigned NumBits>
+template <unsigned Count, uint8_t... Vals>
+const uint8_t WaymarkingTraits<NumBits>::TagsData<
+    Count, Vals...>::Values[sizeof...(Vals)] = {Vals...};
+
+} // end namespace detail
+
+/// This class is responsible for tagging (and retrieving the tag of) a given
+/// element of type T.
+template <class T, class WTraits = detail::WaymarkingTraits<
+                       PointerLikeTypeTraits<T>::NumLowBitsAvailable>>
+struct Waymarker {
+  using Traits = WTraits;
+  static void setWaymark(T &N, unsigned Tag) { N.setWaymark(Tag); }
+  static unsigned getWaymark(const T &N) { return N.getWaymark(); }
+};
+
+template <class T, class WTraits> struct Waymarker<T *, WTraits> {
+  using Traits = WTraits;
+  static void setWaymark(T *&N, unsigned Tag) {
+    reinterpret_cast<uintptr_t &>(N) |= static_cast<uintptr_t>(Tag);
+  }
+  static unsigned getWaymark(const T *N) {
+    return static_cast<unsigned>(reinterpret_cast<uintptr_t>(N)) &
+           Traits::TAG_MASK;
+  }
+};
+
+/// Sets up the waymarking algorithm's tags for a given range [Begin, End).
+///
+/// \param Begin The beginning of the range to mark with tags (inclusive).
+/// \param End The ending of the range to mark with tags (exclusive).
+/// \param Offset The position in the supposed tags array from which to start
+/// marking the given range.
+template <class TIter, class Marker = Waymarker<
+                           typename std::iterator_traits<TIter>::value_type>>
+void fillWaymarks(TIter Begin, TIter End, size_t Offset = 0) {
+  if (Begin == End)
+    return;
+
+  size_t Count = Marker::Traits::Tags::Remain;
+  if (Offset <= Marker::Traits::NUM_STATIC_TAGS) {
+    // Start by filling the pre-calculated tags, starting from the given offset.
+    while (Offset != Marker::Traits::NUM_STATIC_TAGS) {
+      Marker::setWaymark(*Begin, Marker::Traits::Tags::Values[Offset]);
+
+      ++Offset;
+      ++Begin;
+
+      if (Begin == End)
+        return;
+    }
+  } else {
+    // The given offset is larger than the number of pre-computed tags, so we
+    // must do it the hard way.
+    // Calculate the next remaining Count, as if we have filled the tags up to
+    // the given offset.
+    size_t Off = Marker::Traits::NUM_STATIC_TAGS;
+    do {
+      ++Off;
+
+      unsigned Tag = Count & Marker::Traits::MARK_MASK;
+
+      // If the count can fit into the tag, then the counting must stop.
+      if (Count <= Marker::Traits::MARK_MASK) {
+        Tag |= Marker::Traits::STOP_MASK;
+        Count = Off;
+      } else
+        Count >>= Marker::Traits::MARK_SIZE;
+    } while (Off != Offset);
+  }
+
+  // By now, we have the matching remaining Count for the current offset.
+  do {
+    ++Offset;
+
+    unsigned Tag = Count & Marker::Traits::MARK_MASK;
+
+    // If the count can fit into the tag, then the counting must stop.
+    if (Count <= Marker::Traits::MARK_MASK) {
+      Tag |= Marker::Traits::STOP_MASK;
+      Count = Offset;
+    } else
+      Count >>= Marker::Traits::MARK_SIZE;
+
+    Marker::setWaymark(*Begin, Tag);
+    ++Begin;
+  } while (Begin != End);
+}
+
+/// Sets up the waymarking algorithm's tags for a given range.
+///
+/// \param Range The range to mark with tags.
+/// \param Offset The position in the supposed tags array from which to start
+/// marking the given range.
+template <typename R, class Marker = Waymarker<typename std::remove_reference<
+                          decltype(*std::begin(std::declval<R &>()))>::type>>
+void fillWaymarks(R &&Range, size_t Offset = 0) {
+  return fillWaymarks<decltype(std::begin(std::declval<R &>())), Marker>(
+      adl_begin(Range), adl_end(Range), Offset);
+}
+
+/// Retrieves the element marked with tag of only STOP_MASK, by following the
+/// waymarks. This is the first element in a range passed to a previous call to
+/// \c fillWaymarks with \c Offset 0.
+///
+/// For the trivial usage of calling \c fillWaymarks(Array), and \I is an
+/// iterator inside \c Array, this function retrieves the head of \c Array, by
+/// following the waymarks.
+///
+/// \param I The iterator into an array which was marked by the waymarking tags
+/// (by a previous call to \c fillWaymarks).
+template <class TIter, class Marker = Waymarker<
+                           typename std::iterator_traits<TIter>::value_type>>
+TIter followWaymarks(TIter I) {
+  unsigned Tag;
+  do
+    Tag = Marker::getWaymark(*I--);
+  while (!(Tag & Marker::Traits::STOP_MASK));
+
+  // Special case for the first Use.
+  if (Tag != Marker::Traits::STOP_MASK) {
+    ptrdiff_t Offset = Tag & Marker::Traits::MARK_MASK;
+    while (!((Tag = Marker::getWaymark(*I)) & Marker::Traits::STOP_MASK)) {
+      Offset = (Offset << Marker::Traits::MARK_SIZE) + Tag;
+      --I;
+    }
+    I -= Offset;
+  }
+  return ++I;
+}
+
+} // end namespace llvm
+
+#endif // LLVM_ADT_WAYMARKING_H
diff --git a/linux-x64/clang/include/llvm/ADT/bit.h b/linux-x64/clang/include/llvm/ADT/bit.h
index a790d5e..d76bc6c 100644
--- a/linux-x64/clang/include/llvm/ADT/bit.h
+++ b/linux-x64/clang/include/llvm/ADT/bit.h
@@ -22,23 +22,28 @@
 // This implementation of bit_cast is different from the C++17 one in two ways:
 //  - It isn't constexpr because that requires compiler support.
 //  - It requires trivially-constructible To, to avoid UB in the implementation.
-template <typename To, typename From
-          , typename = typename std::enable_if<sizeof(To) == sizeof(From)>::type
+template <
+    typename To, typename From,
+    typename = std::enable_if_t<sizeof(To) == sizeof(From)>
 #if (__has_feature(is_trivially_constructible) && defined(_LIBCPP_VERSION)) || \
     (defined(__GNUC__) && __GNUC__ >= 5)
-          , typename = typename std::is_trivially_constructible<To>::type
+    ,
+    typename = std::enable_if_t<std::is_trivially_constructible<To>::value>
 #elif __has_feature(is_trivially_constructible)
-          , typename = typename std::enable_if<__is_trivially_constructible(To)>::type
+    ,
+    typename = std::enable_if_t<__is_trivially_constructible(To)>
 #else
   // See comment below.
 #endif
 #if (__has_feature(is_trivially_copyable) && defined(_LIBCPP_VERSION)) || \
     (defined(__GNUC__) && __GNUC__ >= 5)
-          , typename = typename std::enable_if<std::is_trivially_copyable<To>::value>::type
-          , typename = typename std::enable_if<std::is_trivially_copyable<From>::value>::type
+    ,
+    typename = std::enable_if_t<std::is_trivially_copyable<To>::value>,
+    typename = std::enable_if_t<std::is_trivially_copyable<From>::value>
 #elif __has_feature(is_trivially_copyable)
-          , typename = typename std::enable_if<__is_trivially_copyable(To)>::type
-          , typename = typename std::enable_if<__is_trivially_copyable(From)>::type
+    ,
+    typename = std::enable_if_t<__is_trivially_copyable(To)>,
+    typename = std::enable_if_t<__is_trivially_copyable(From)>
 #else
 // This case is GCC 4.x. clang with libc++ or libstdc++ never get here. Unlike
 // llvm/Support/type_traits.h's is_trivially_copyable we don't want to
@@ -46,7 +51,7 @@
 // compilation failures on the bots instead of locally. That's acceptable
 // because it's very few developers, and only until we move past C++11.
 #endif
->
+    >
 inline To bit_cast(const From &from) noexcept {
   To to;
   std::memcpy(&to, &from, sizeof(To));
diff --git a/linux-x64/clang/include/llvm/ADT/fallible_iterator.h b/linux-x64/clang/include/llvm/ADT/fallible_iterator.h
index 6501ad2..a196d88 100644
--- a/linux-x64/clang/include/llvm/ADT/fallible_iterator.h
+++ b/linux-x64/clang/include/llvm/ADT/fallible_iterator.h
@@ -86,7 +86,7 @@
     return fallible_iterator(std::move(I), &Err);
   }
 
-  /// Construct a fallible iteratro that can be used as an end-of-range value.
+  /// Construct a fallible iterator that can be used as an end-of-range value.
   ///
   /// A value created by this method can be dereferenced (if the underlying
   /// value points at a valid value) and compared, but not incremented or
@@ -96,12 +96,10 @@
   }
 
   /// Forward dereference to the underlying iterator.
-  auto operator*() -> decltype(*std::declval<Underlying>()) { return *I; }
+  decltype(auto) operator*() { return *I; }
 
   /// Forward const dereference to the underlying iterator.
-  auto operator*() const -> decltype(*std::declval<const Underlying>()) {
-    return *I;
-  }
+  decltype(auto) operator*() const { return *I; }
 
   /// Forward structure dereference to the underlying iterator (if the
   /// underlying iterator supports it).
diff --git a/linux-x64/clang/include/llvm/ADT/ilist.h b/linux-x64/clang/include/llvm/ADT/ilist.h
index 06c7abf..d5a1f28 100644
--- a/linux-x64/clang/include/llvm/ADT/ilist.h
+++ b/linux-x64/clang/include/llvm/ADT/ilist.h
@@ -198,10 +198,12 @@
   iplist_impl &operator=(const iplist_impl &) = delete;
 
   iplist_impl(iplist_impl &&X)
-      : TraitsT(std::move(X)), IntrusiveListT(std::move(X)) {}
+      : TraitsT(std::move(static_cast<TraitsT &>(X))),
+        IntrusiveListT(std::move(static_cast<IntrusiveListT &>(X))) {}
   iplist_impl &operator=(iplist_impl &&X) {
-    *static_cast<TraitsT *>(this) = std::move(X);
-    *static_cast<IntrusiveListT *>(this) = std::move(X);
+    *static_cast<TraitsT *>(this) = std::move(static_cast<TraitsT &>(X));
+    *static_cast<IntrusiveListT *>(this) =
+        std::move(static_cast<IntrusiveListT &>(X));
     return *this;
   }
 
diff --git a/linux-x64/clang/include/llvm/ADT/ilist_iterator.h b/linux-x64/clang/include/llvm/ADT/ilist_iterator.h
index cbe5cef..be87634 100644
--- a/linux-x64/clang/include/llvm/ADT/ilist_iterator.h
+++ b/linux-x64/clang/include/llvm/ADT/ilist_iterator.h
@@ -88,15 +88,14 @@
   // This is templated so that we can allow constructing a const iterator from
   // a nonconst iterator...
   template <bool RHSIsConst>
-  ilist_iterator(
-      const ilist_iterator<OptionsT, IsReverse, RHSIsConst> &RHS,
-      typename std::enable_if<IsConst || !RHSIsConst, void *>::type = nullptr)
+  ilist_iterator(const ilist_iterator<OptionsT, IsReverse, RHSIsConst> &RHS,
+                 std::enable_if_t<IsConst || !RHSIsConst, void *> = nullptr)
       : NodePtr(RHS.NodePtr) {}
 
   // This is templated so that we can allow assigning to a const iterator from
   // a nonconst iterator...
   template <bool RHSIsConst>
-  typename std::enable_if<IsConst || !RHSIsConst, ilist_iterator &>::type
+  std::enable_if_t<IsConst || !RHSIsConst, ilist_iterator &>
   operator=(const ilist_iterator<OptionsT, IsReverse, RHSIsConst> &RHS) {
     NodePtr = RHS.NodePtr;
     return *this;
diff --git a/linux-x64/clang/include/llvm/ADT/iterator.h b/linux-x64/clang/include/llvm/ADT/iterator.h
index 467fd4c..6625a3f 100644
--- a/linux-x64/clang/include/llvm/ADT/iterator.h
+++ b/linux-x64/clang/include/llvm/ADT/iterator.h
@@ -142,28 +142,30 @@
     return tmp;
   }
 
+#ifndef __cpp_impl_three_way_comparison
   bool operator!=(const DerivedT &RHS) const {
-    return !static_cast<const DerivedT *>(this)->operator==(RHS);
+    return !(static_cast<const DerivedT &>(*this) == RHS);
   }
+#endif
 
   bool operator>(const DerivedT &RHS) const {
     static_assert(
         IsRandomAccess,
         "Relational operators are only defined for random access iterators.");
-    return !static_cast<const DerivedT *>(this)->operator<(RHS) &&
-           !static_cast<const DerivedT *>(this)->operator==(RHS);
+    return !(static_cast<const DerivedT &>(*this) < RHS) &&
+           !(static_cast<const DerivedT &>(*this) == RHS);
   }
   bool operator<=(const DerivedT &RHS) const {
     static_assert(
         IsRandomAccess,
         "Relational operators are only defined for random access iterators.");
-    return !static_cast<const DerivedT *>(this)->operator>(RHS);
+    return !(static_cast<const DerivedT &>(*this) > RHS);
   }
   bool operator>=(const DerivedT &RHS) const {
     static_assert(
         IsRandomAccess,
         "Relational operators are only defined for random access iterators.");
-    return !static_cast<const DerivedT *>(this)->operator<(RHS);
+    return !(static_cast<const DerivedT &>(*this) < RHS);
   }
 
   PointerT operator->() { return &static_cast<DerivedT *>(this)->operator*(); }
@@ -194,14 +196,14 @@
     typename T = typename std::iterator_traits<WrappedIteratorT>::value_type,
     typename DifferenceTypeT =
         typename std::iterator_traits<WrappedIteratorT>::difference_type,
-    typename PointerT = typename std::conditional<
+    typename PointerT = std::conditional_t<
         std::is_same<T, typename std::iterator_traits<
                             WrappedIteratorT>::value_type>::value,
-        typename std::iterator_traits<WrappedIteratorT>::pointer, T *>::type,
-    typename ReferenceT = typename std::conditional<
+        typename std::iterator_traits<WrappedIteratorT>::pointer, T *>,
+    typename ReferenceT = std::conditional_t<
         std::is_same<T, typename std::iterator_traits<
                             WrappedIteratorT>::value_type>::value,
-        typename std::iterator_traits<WrappedIteratorT>::reference, T &>::type>
+        typename std::iterator_traits<WrappedIteratorT>::reference, T &>>
 class iterator_adaptor_base
     : public iterator_facade_base<DerivedT, IteratorCategoryT, T,
                                   DifferenceTypeT, PointerT, ReferenceT> {
@@ -260,12 +262,16 @@
     return *static_cast<DerivedT *>(this);
   }
 
-  bool operator==(const DerivedT &RHS) const { return I == RHS.I; }
-  bool operator<(const DerivedT &RHS) const {
+  friend bool operator==(const iterator_adaptor_base &LHS,
+                         const iterator_adaptor_base &RHS) {
+    return LHS.I == RHS.I;
+  }
+  friend bool operator<(const iterator_adaptor_base &LHS,
+                        const iterator_adaptor_base &RHS) {
     static_assert(
         BaseT::IsRandomAccess,
         "Relational operators are only defined for random access iterators.");
-    return I < RHS.I;
+    return LHS.I < RHS.I;
   }
 
   ReferenceT operator*() const { return *I; }
@@ -281,8 +287,8 @@
 ///   using iterator = pointee_iterator<SmallVectorImpl<T *>::iterator>;
 /// \endcode
 template <typename WrappedIteratorT,
-          typename T = typename std::remove_reference<
-              decltype(**std::declval<WrappedIteratorT>())>::type>
+          typename T = std::remove_reference_t<decltype(
+              **std::declval<WrappedIteratorT>())>>
 struct pointee_iterator
     : iterator_adaptor_base<
           pointee_iterator<WrappedIteratorT, T>, WrappedIteratorT,
@@ -333,6 +339,13 @@
                     PointerIteratorT(std::end(std::forward<RangeT>(Range))));
 }
 
+template <typename WrappedIteratorT,
+          typename T1 = std::remove_reference_t<decltype(
+              **std::declval<WrappedIteratorT>())>,
+          typename T2 = std::add_pointer_t<T1>>
+using raw_pointer_iterator =
+    pointer_iterator<pointee_iterator<WrappedIteratorT, T1>, T2>;
+
 // Wrapper iterator over iterator ItType, adding DataRef to the type of ItType,
 // to create NodeRef = std::pair<InnerTypeOfItType, DataRef>.
 template <typename ItType, typename NodeRef, typename DataRef>
diff --git a/linux-x64/clang/include/llvm/ADT/iterator_range.h b/linux-x64/clang/include/llvm/ADT/iterator_range.h
index 774c7c4..a9b46a3 100644
--- a/linux-x64/clang/include/llvm/ADT/iterator_range.h
+++ b/linux-x64/clang/include/llvm/ADT/iterator_range.h
@@ -18,7 +18,6 @@
 #ifndef LLVM_ADT_ITERATOR_RANGE_H
 #define LLVM_ADT_ITERATOR_RANGE_H
 
-#include <iterator>
 #include <utility>
 
 namespace llvm {
@@ -44,6 +43,7 @@
 
   IteratorT begin() const { return begin_iterator; }
   IteratorT end() const { return end_iterator; }
+  bool empty() const { return begin_iterator == end_iterator; }
 };
 
 /// Convenience function for iterating over sub-ranges.
@@ -58,11 +58,6 @@
   return iterator_range<T>(std::move(p.first), std::move(p.second));
 }
 
-template <typename T>
-iterator_range<decltype(adl_begin(std::declval<T>()))> drop_begin(T &&t,
-                                                                  int n) {
-  return make_range(std::next(adl_begin(t), n), adl_end(t));
-}
 }
 
 #endif
diff --git a/linux-x64/clang/include/llvm/ADT/simple_ilist.h b/linux-x64/clang/include/llvm/ADT/simple_ilist.h
index 9257b47..d5ae20c 100644
--- a/linux-x64/clang/include/llvm/ADT/simple_ilist.h
+++ b/linux-x64/clang/include/llvm/ADT/simple_ilist.h
@@ -52,7 +52,7 @@
 /// to calling \a std::for_each() on the range to be discarded.
 ///
 /// The currently available \p Options customize the nodes in the list.  The
-/// same options must be specified in the \a ilist_node instantation for
+/// same options must be specified in the \a ilist_node instantiation for
 /// compatibility (although the order is irrelevant).
 /// \li Use \a ilist_tag to designate which ilist_node for a given \p T this
 /// list should use.  This is useful if a type \p T is part of multiple,
diff --git a/linux-x64/clang/include/llvm/Analysis/AliasAnalysis.h b/linux-x64/clang/include/llvm/Analysis/AliasAnalysis.h
index 9483415..8a3ea62 100644
--- a/linux-x64/clang/include/llvm/Analysis/AliasAnalysis.h
+++ b/linux-x64/clang/include/llvm/Analysis/AliasAnalysis.h
@@ -42,10 +42,6 @@
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Analysis/MemoryLocation.h"
-#include "llvm/Analysis/TargetLibraryInfo.h"
-#include "llvm/IR/Function.h"
-#include "llvm/IR/Instruction.h"
-#include "llvm/IR/Instructions.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/Pass.h"
 #include <cstdint>
@@ -56,10 +52,17 @@
 namespace llvm {
 
 class AnalysisUsage;
+class AtomicCmpXchgInst;
 class BasicAAResult;
 class BasicBlock;
+class CatchPadInst;
+class CatchReturnInst;
 class DominatorTree;
-class OrderedBasicBlock;
+class FenceInst;
+class Function;
+class InvokeInst;
+class PreservedAnalyses;
+class TargetLibraryInfo;
 class Value;
 
 /// The possible results of an alias query.
@@ -226,11 +229,21 @@
   /// non-volatile loads from objects pointed to by its pointer-typed
   /// arguments, with arbitrary offsets.
   ///
-  /// This property corresponds to the IntrReadArgMem LLVM intrinsic flag.
+  /// This property corresponds to the combination of the IntrReadMem
+  /// and IntrArgMemOnly LLVM intrinsic flags.
   FMRB_OnlyReadsArgumentPointees =
       FMRL_ArgumentPointees | static_cast<int>(ModRefInfo::Ref),
 
   /// The only memory references in this function (if it has any) are
+  /// non-volatile stores from objects pointed to by its pointer-typed
+  /// arguments, with arbitrary offsets.
+  ///
+  /// This property corresponds to the combination of the IntrWriteMem
+  /// and IntrArgMemOnly LLVM intrinsic flags.
+  FMRB_OnlyWritesArgumentPointees =
+      FMRL_ArgumentPointees | static_cast<int>(ModRefInfo::Mod),
+
+  /// The only memory references in this function (if it has any) are
   /// non-volatile loads and stores from objects pointed to by its
   /// pointer-typed arguments, with arbitrary offsets.
   ///
@@ -239,12 +252,48 @@
       FMRL_ArgumentPointees | static_cast<int>(ModRefInfo::ModRef),
 
   /// The only memory references in this function (if it has any) are
+  /// reads of memory that is otherwise inaccessible via LLVM IR.
+  ///
+  /// This property corresponds to the LLVM IR inaccessiblememonly attribute.
+  FMRB_OnlyReadsInaccessibleMem =
+      FMRL_InaccessibleMem | static_cast<int>(ModRefInfo::Ref),
+
+  /// The only memory references in this function (if it has any) are
+  /// writes to memory that is otherwise inaccessible via LLVM IR.
+  ///
+  /// This property corresponds to the LLVM IR inaccessiblememonly attribute.
+  FMRB_OnlyWritesInaccessibleMem =
+      FMRL_InaccessibleMem | static_cast<int>(ModRefInfo::Mod),
+
+  /// The only memory references in this function (if it has any) are
   /// references of memory that is otherwise inaccessible via LLVM IR.
   ///
   /// This property corresponds to the LLVM IR inaccessiblememonly attribute.
   FMRB_OnlyAccessesInaccessibleMem =
       FMRL_InaccessibleMem | static_cast<int>(ModRefInfo::ModRef),
 
+  /// The function may perform non-volatile loads from objects pointed
+  /// to by its pointer-typed arguments, with arbitrary offsets, and
+  /// it may also perform loads of memory that is otherwise
+  /// inaccessible via LLVM IR.
+  ///
+  /// This property corresponds to the LLVM IR
+  /// inaccessiblemem_or_argmemonly attribute.
+  FMRB_OnlyReadsInaccessibleOrArgMem = FMRL_InaccessibleMem |
+                                       FMRL_ArgumentPointees |
+                                       static_cast<int>(ModRefInfo::Ref),
+
+  /// The function may perform non-volatile stores to objects pointed
+  /// to by its pointer-typed arguments, with arbitrary offsets, and
+  /// it may also perform stores of memory that is otherwise
+  /// inaccessible via LLVM IR.
+  ///
+  /// This property corresponds to the LLVM IR
+  /// inaccessiblemem_or_argmemonly attribute.
+  FMRB_OnlyWritesInaccessibleOrArgMem = FMRL_InaccessibleMem |
+                                        FMRL_ArgumentPointees |
+                                        static_cast<int>(ModRefInfo::Mod),
+
   /// The function may perform non-volatile loads and stores of objects
   /// pointed to by its pointer-typed arguments, with arbitrary offsets, and
   /// it may also perform loads and stores of memory that is otherwise
@@ -269,7 +318,7 @@
   //
   // This property corresponds to the LLVM IR 'writeonly' attribute.
   // This property corresponds to the IntrWriteMem LLVM intrinsic flag.
-  FMRB_DoesNotReadMemory = FMRL_Anywhere | static_cast<int>(ModRefInfo::Mod),
+  FMRB_OnlyWritesMemory = FMRL_Anywhere | static_cast<int>(ModRefInfo::Mod),
 
   /// This indicates that the function could not be classified into one of the
   /// behaviors above.
@@ -297,7 +346,15 @@
 class AAQueryInfo {
 public:
   using LocPair = std::pair<MemoryLocation, MemoryLocation>;
-  using AliasCacheT = SmallDenseMap<LocPair, AliasResult, 8>;
+  struct CacheEntry {
+    AliasResult Result;
+    /// Number of times a NoAlias assumption has been used.
+    /// 0 for assumptions that have not been used, -1 for definitive results.
+    int NumAssumptionUses;
+    /// Whether this is a definitive (non-assumption) result.
+    bool isDefinitive() const { return NumAssumptionUses < 0; }
+  };
+  using AliasCacheT = SmallDenseMap<LocPair, CacheEntry, 8>;
   AliasCacheT AliasCache;
 
   using IsCapturedCacheT = SmallDenseMap<const Value *, bool, 8>;
@@ -356,7 +413,8 @@
 
   /// A convenience wrapper around the primary \c alias interface.
   AliasResult alias(const Value *V1, const Value *V2) {
-    return alias(V1, LocationSize::unknown(), V2, LocationSize::unknown());
+    return alias(MemoryLocation::getBeforeOrAfter(V1),
+                 MemoryLocation::getBeforeOrAfter(V2));
   }
 
   /// A trivial helper function to check to see if the specified pointers are
@@ -373,7 +431,8 @@
 
   /// A convenience wrapper around the \c isNoAlias helper interface.
   bool isNoAlias(const Value *V1, const Value *V2) {
-    return isNoAlias(MemoryLocation(V1), MemoryLocation(V2));
+    return isNoAlias(MemoryLocation::getBeforeOrAfter(V1),
+                     MemoryLocation::getBeforeOrAfter(V2));
   }
 
   /// A trivial helper function to check to see if the specified pointers are
@@ -395,7 +454,7 @@
   /// A convenience wrapper around the primary \c pointsToConstantMemory
   /// interface.
   bool pointsToConstantMemory(const Value *P, bool OrLocal = false) {
-    return pointsToConstantMemory(MemoryLocation(P), OrLocal);
+    return pointsToConstantMemory(MemoryLocation::getBeforeOrAfter(P), OrLocal);
   }
 
   /// @}
@@ -488,7 +547,7 @@
   /// write at most from objects pointed to by their pointer-typed arguments
   /// (with arbitrary offsets).
   static bool onlyAccessesArgPointees(FunctionModRefBehavior MRB) {
-    return !(MRB & FMRL_Anywhere & ~FMRL_ArgumentPointees);
+    return !((unsigned)MRB & FMRL_Anywhere & ~FMRL_ArgumentPointees);
   }
 
   /// Checks if functions with the specified behavior are known to potentially
@@ -496,26 +555,27 @@
   /// (with arbitrary offsets).
   static bool doesAccessArgPointees(FunctionModRefBehavior MRB) {
     return isModOrRefSet(createModRefInfo(MRB)) &&
-           (MRB & FMRL_ArgumentPointees);
+           ((unsigned)MRB & FMRL_ArgumentPointees);
   }
 
   /// Checks if functions with the specified behavior are known to read and
   /// write at most from memory that is inaccessible from LLVM IR.
   static bool onlyAccessesInaccessibleMem(FunctionModRefBehavior MRB) {
-    return !(MRB & FMRL_Anywhere & ~FMRL_InaccessibleMem);
+    return !((unsigned)MRB & FMRL_Anywhere & ~FMRL_InaccessibleMem);
   }
 
   /// Checks if functions with the specified behavior are known to potentially
   /// read or write from memory that is inaccessible from LLVM IR.
   static bool doesAccessInaccessibleMem(FunctionModRefBehavior MRB) {
-    return isModOrRefSet(createModRefInfo(MRB)) && (MRB & FMRL_InaccessibleMem);
+    return isModOrRefSet(createModRefInfo(MRB)) &&
+             ((unsigned)MRB & FMRL_InaccessibleMem);
   }
 
   /// Checks if functions with the specified behavior are known to read and
   /// write at most from memory that is inaccessible from LLVM IR or objects
   /// pointed to by their pointer-typed arguments (with arbitrary offsets).
   static bool onlyAccessesInaccessibleOrArgMem(FunctionModRefBehavior MRB) {
-    return !(MRB & FMRL_Anywhere &
+    return !((unsigned)MRB & FMRL_Anywhere &
              ~(FMRL_InaccessibleMem | FMRL_ArgumentPointees));
   }
 
@@ -643,19 +703,16 @@
 
   /// Return information about whether a particular call site modifies
   /// or reads the specified memory location \p MemLoc before instruction \p I
-  /// in a BasicBlock. An ordered basic block \p OBB can be used to speed up
-  /// instruction ordering queries inside the BasicBlock containing \p I.
+  /// in a BasicBlock.
   /// Early exits in callCapturesBefore may lead to ModRefInfo::Must not being
   /// set.
   ModRefInfo callCapturesBefore(const Instruction *I,
-                                const MemoryLocation &MemLoc, DominatorTree *DT,
-                                OrderedBasicBlock *OBB = nullptr);
+                                const MemoryLocation &MemLoc, DominatorTree *DT);
 
   /// A convenience wrapper to synthesize a memory location.
   ModRefInfo callCapturesBefore(const Instruction *I, const Value *P,
-                                LocationSize Size, DominatorTree *DT,
-                                OrderedBasicBlock *OBB = nullptr) {
-    return callCapturesBefore(I, MemoryLocation(P, Size), DT, OBB);
+                                LocationSize Size, DominatorTree *DT) {
+    return callCapturesBefore(I, MemoryLocation(P, Size), DT);
   }
 
   /// @}
@@ -718,40 +775,7 @@
                            AAQueryInfo &AAQI);
   ModRefInfo getModRefInfo(const Instruction *I,
                            const Optional<MemoryLocation> &OptLoc,
-                           AAQueryInfo &AAQIP) {
-    if (OptLoc == None) {
-      if (const auto *Call = dyn_cast<CallBase>(I)) {
-        return createModRefInfo(getModRefBehavior(Call));
-      }
-    }
-
-    const MemoryLocation &Loc = OptLoc.getValueOr(MemoryLocation());
-
-    switch (I->getOpcode()) {
-    case Instruction::VAArg:
-      return getModRefInfo((const VAArgInst *)I, Loc, AAQIP);
-    case Instruction::Load:
-      return getModRefInfo((const LoadInst *)I, Loc, AAQIP);
-    case Instruction::Store:
-      return getModRefInfo((const StoreInst *)I, Loc, AAQIP);
-    case Instruction::Fence:
-      return getModRefInfo((const FenceInst *)I, Loc, AAQIP);
-    case Instruction::AtomicCmpXchg:
-      return getModRefInfo((const AtomicCmpXchgInst *)I, Loc, AAQIP);
-    case Instruction::AtomicRMW:
-      return getModRefInfo((const AtomicRMWInst *)I, Loc, AAQIP);
-    case Instruction::Call:
-      return getModRefInfo((const CallInst *)I, Loc, AAQIP);
-    case Instruction::Invoke:
-      return getModRefInfo((const InvokeInst *)I, Loc, AAQIP);
-    case Instruction::CatchPad:
-      return getModRefInfo((const CatchPadInst *)I, Loc, AAQIP);
-    case Instruction::CatchRet:
-      return getModRefInfo((const CatchReturnInst *)I, Loc, AAQIP);
-    default:
-      return ModRefInfo::NoModRef;
-    }
-  }
+                           AAQueryInfo &AAQIP);
 
   class Concept;
 
@@ -765,6 +789,9 @@
 
   std::vector<AnalysisKey *> AADeps;
 
+  /// Query depth used to distinguish recursive queries.
+  unsigned Depth = 0;
+
   friend class BatchAAResults;
 };
 
@@ -805,6 +832,13 @@
   FunctionModRefBehavior getModRefBehavior(const CallBase *Call) {
     return AA.getModRefBehavior(Call);
   }
+  bool isMustAlias(const MemoryLocation &LocA, const MemoryLocation &LocB) {
+    return alias(LocA, LocB) == MustAlias;
+  }
+  bool isMustAlias(const Value *V1, const Value *V2) {
+    return alias(MemoryLocation(V1, LocationSize::precise(1)),
+                 MemoryLocation(V2, LocationSize::precise(1))) == MustAlias;
+  }
 };
 
 /// Temporary typedef for legacy code that uses a generic \c AliasAnalysis
@@ -949,7 +983,7 @@
 
   /// A pointer to the AAResults object that this AAResult is
   /// aggregated within. May be null if not aggregated.
-  AAResults *AAR;
+  AAResults *AAR = nullptr;
 
   /// Helper to dispatch calls back through the derived type.
   DerivedT &derived() { return static_cast<DerivedT &>(*this); }
@@ -1065,9 +1099,6 @@
 /// Return true if this pointer is returned by a noalias function.
 bool isNoAliasCall(const Value *V);
 
-/// Return true if this is an argument with the noalias attribute.
-bool isNoAliasArgument(const Value *V);
-
 /// Return true if this pointer refers to a distinct and identifiable object.
 /// This returns true for:
 ///    Global Variables and Functions (but not Global Aliases)
@@ -1115,12 +1146,7 @@
     ResultGetters.push_back(&getModuleAAResultImpl<AnalysisT>);
   }
 
-  Result run(Function &F, FunctionAnalysisManager &AM) {
-    Result R(AM.getResult<TargetLibraryAnalysis>(F));
-    for (auto &Getter : ResultGetters)
-      (*Getter)(F, AM, R);
-    return R;
-  }
+  Result run(Function &F, FunctionAnalysisManager &AM);
 
 private:
   friend AnalysisInfoMixin<AAManager>;
@@ -1143,8 +1169,8 @@
   static void getModuleAAResultImpl(Function &F, FunctionAnalysisManager &AM,
                                     AAResults &AAResults) {
     auto &MAMProxy = AM.getResult<ModuleAnalysisManagerFunctionProxy>(F);
-    auto &MAM = MAMProxy.getManager();
-    if (auto *R = MAM.template getCachedResult<AnalysisT>(*F.getParent())) {
+    if (auto *R =
+            MAMProxy.template getCachedResult<AnalysisT>(*F.getParent())) {
       AAResults.addAAResult(*R);
       MAMProxy
           .template registerOuterAnalysisInvalidation<AnalysisT, AAManager>();
@@ -1179,14 +1205,9 @@
 
   static char ID;
 
-  ExternalAAWrapperPass() : ImmutablePass(ID) {
-    initializeExternalAAWrapperPassPass(*PassRegistry::getPassRegistry());
-  }
+  ExternalAAWrapperPass();
 
-  explicit ExternalAAWrapperPass(CallbackT CB)
-      : ImmutablePass(ID), CB(std::move(CB)) {
-    initializeExternalAAWrapperPassPass(*PassRegistry::getPassRegistry());
-  }
+  explicit ExternalAAWrapperPass(CallbackT CB);
 
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.setPreservesAll();
diff --git a/linux-x64/clang/include/llvm/Analysis/AliasSetTracker.h b/linux-x64/clang/include/llvm/Analysis/AliasSetTracker.h
index 34a509b..b27fd5a 100644
--- a/linux-x64/clang/include/llvm/Analysis/AliasSetTracker.h
+++ b/linux-x64/clang/include/llvm/Analysis/AliasSetTracker.h
@@ -20,9 +20,10 @@
 #include "llvm/ADT/DenseMapInfo.h"
 #include "llvm/ADT/ilist.h"
 #include "llvm/ADT/ilist_node.h"
-#include "llvm/Analysis/AliasAnalysis.h"
+#include "llvm/Analysis/MemoryLocation.h"
 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/Metadata.h"
+#include "llvm/IR/PassManager.h"
 #include "llvm/IR/ValueHandle.h"
 #include "llvm/Support/Casting.h"
 #include <cassert>
@@ -33,6 +34,7 @@
 
 namespace llvm {
 
+class AAResults;
 class AliasSetTracker;
 class BasicBlock;
 class LoadInst;
@@ -45,6 +47,8 @@
 class VAArgInst;
 class Value;
 
+enum AliasResult : uint8_t;
+
 class AliasSet : public ilist_node<AliasSet> {
   friend class AliasSetTracker;
 
@@ -87,11 +91,7 @@
         AAInfo = NewAAInfo;
       else {
         AAMDNodes Intersection(AAInfo.intersect(NewAAInfo));
-        if (!Intersection) {
-          // NewAAInfo conflicts with AAInfo.
-          AAInfo = DenseMapInfo<AAMDNodes>::getTombstoneKey();
-          return SizeChanged;
-        }
+        SizeChanged |= Intersection != AAInfo;
         AAInfo = Intersection;
       }
       return SizeChanged;
@@ -297,7 +297,7 @@
   void addPointer(AliasSetTracker &AST, PointerRec &Entry, LocationSize Size,
                   const AAMDNodes &AAInfo, bool KnownMustAlias = false,
                   bool SkipSizeUpdate = false);
-  void addUnknownInst(Instruction *I, AliasAnalysis &AA);
+  void addUnknownInst(Instruction *I, AAResults &AA);
 
   void removeUnknownInst(AliasSetTracker &AST, Instruction *I) {
     bool WasEmpty = UnknownInsts.empty();
@@ -315,8 +315,8 @@
   /// If the specified pointer "may" (or must) alias one of the members in the
   /// set return the appropriate AliasResult. Otherwise return NoAlias.
   AliasResult aliasesPointer(const Value *Ptr, LocationSize Size,
-                             const AAMDNodes &AAInfo, AliasAnalysis &AA) const;
-  bool aliasesUnknownInst(const Instruction *Inst, AliasAnalysis &AA) const;
+                             const AAMDNodes &AAInfo, AAResults &AA) const;
+  bool aliasesUnknownInst(const Instruction *Inst, AAResults &AA) const;
 };
 
 inline raw_ostream& operator<<(raw_ostream &OS, const AliasSet &AS) {
@@ -342,9 +342,9 @@
   /// handle.
   struct ASTCallbackVHDenseMapInfo : public DenseMapInfo<Value *> {};
 
-  AliasAnalysis &AA;
-  MemorySSA *MSSA;
-  Loop *L;
+  AAResults &AA;
+  MemorySSA *MSSA = nullptr;
+  Loop *L = nullptr;
   ilist<AliasSet> AliasSets;
 
   using PointerMapType = DenseMap<ASTCallbackVH, AliasSet::PointerRec *,
@@ -356,9 +356,9 @@
 public:
   /// Create an empty collection of AliasSets, and use the specified alias
   /// analysis object to disambiguate load and store addresses.
-  explicit AliasSetTracker(AliasAnalysis &aa) : AA(aa) {}
-  explicit AliasSetTracker(AliasAnalysis &aa, MemorySSA *mssa, Loop *l)
-      : AA(aa), MSSA(mssa), L(l) {}
+  explicit AliasSetTracker(AAResults &AA) : AA(AA) {}
+  explicit AliasSetTracker(AAResults &AA, MemorySSA *MSSA, Loop *L)
+      : AA(AA), MSSA(MSSA), L(L) {}
   ~AliasSetTracker() { clear(); }
 
   /// These methods are used to add different types of instructions to the alias
@@ -397,7 +397,7 @@
   AliasSet &getAliasSetFor(const MemoryLocation &MemLoc);
 
   /// Return the underlying alias analysis object used by this tracker.
-  AliasAnalysis &getAliasAnalysis() const { return AA; }
+  AAResults &getAliasAnalysis() const { return AA; }
 
   /// This method is used to remove a pointer value from the AliasSetTracker
   /// entirely. It should be used when an instruction is deleted from the
@@ -461,6 +461,14 @@
   return OS;
 }
 
+class AliasSetsPrinterPass : public PassInfoMixin<AliasSetsPrinterPass> {
+  raw_ostream &OS;
+
+public:
+  explicit AliasSetsPrinterPass(raw_ostream &OS);
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+};
+
 } // end namespace llvm
 
 #endif // LLVM_ANALYSIS_ALIASSETTRACKER_H
diff --git a/linux-x64/clang/include/llvm/Analysis/AssumeBundleQueries.h b/linux-x64/clang/include/llvm/Analysis/AssumeBundleQueries.h
new file mode 100644
index 0000000..4d28842
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Analysis/AssumeBundleQueries.h
@@ -0,0 +1,167 @@
+//===- AssumeBundleQueries.h - utilities to query assume bundles *- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contain tools to query into assume bundles. assume bundles can be
+// built using utilities from Transform/Utils/AssumeBundleBuilder.h
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_UTILS_ASSUMEBUNDLEQUERIES_H
+#define LLVM_TRANSFORMS_UTILS_ASSUMEBUNDLEQUERIES_H
+
+#include "llvm/IR/Attributes.h"
+#include "llvm/IR/Instructions.h"
+#include "llvm/ADT/DenseMap.h"
+
+namespace llvm {
+class IntrinsicInst;
+class AssumptionCache;
+class DominatorTree;
+
+/// Index of elements in the operand bundle.
+/// If the element exist it is guaranteed to be what is specified in this enum
+/// but it may not exist.
+enum AssumeBundleArg {
+  ABA_WasOn = 0,
+  ABA_Argument = 1,
+};
+
+/// Query the operand bundle of an llvm.assume to find a single attribute of
+/// the specified kind applied on a specified Value.
+///
+/// This has a non-constant complexity. It should only be used when a single
+/// attribute is going to be queried.
+///
+/// Return true iff the queried attribute was found.
+/// If ArgVal is set. the argument will be stored to ArgVal.
+bool hasAttributeInAssume(CallInst &AssumeCI, Value *IsOn, StringRef AttrName,
+                          uint64_t *ArgVal = nullptr);
+inline bool hasAttributeInAssume(CallInst &AssumeCI, Value *IsOn,
+                                 Attribute::AttrKind Kind,
+                                 uint64_t *ArgVal = nullptr) {
+  return hasAttributeInAssume(AssumeCI, IsOn,
+                              Attribute::getNameFromAttrKind(Kind), ArgVal);
+}
+
+template<> struct DenseMapInfo<Attribute::AttrKind> {
+  static Attribute::AttrKind getEmptyKey() {
+    return Attribute::EmptyKey;
+  }
+  static Attribute::AttrKind getTombstoneKey() {
+    return Attribute::TombstoneKey;
+  }
+  static unsigned getHashValue(Attribute::AttrKind AK) {
+    return hash_combine(AK);
+  }
+  static bool isEqual(Attribute::AttrKind LHS, Attribute::AttrKind RHS) {
+    return LHS == RHS;
+  }
+};
+
+/// The map Key contains the Value on for which the attribute is valid and
+/// the Attribute that is valid for that value.
+/// If the Attribute is not on any value, the Value is nullptr.
+using RetainedKnowledgeKey = std::pair<Value *, Attribute::AttrKind>;
+
+struct MinMax {
+  unsigned Min;
+  unsigned Max;
+};
+
+/// A mapping from intrinsics (=`llvm.assume` calls) to a value range
+/// (=knowledge) that is encoded in them. How the value range is interpreted
+/// depends on the RetainedKnowledgeKey that was used to get this out of the
+/// RetainedKnowledgeMap.
+using Assume2KnowledgeMap = DenseMap<IntrinsicInst *, MinMax>;
+
+using RetainedKnowledgeMap =
+    DenseMap<RetainedKnowledgeKey, Assume2KnowledgeMap>;
+
+/// Insert into the map all the informations contained in the operand bundles of
+/// the llvm.assume. This should be used instead of hasAttributeInAssume when
+/// many queries are going to be made on the same llvm.assume.
+/// String attributes are not inserted in the map.
+/// If the IR changes the map will be outdated.
+void fillMapFromAssume(CallInst &AssumeCI, RetainedKnowledgeMap &Result);
+
+/// Represent one information held inside an operand bundle of an llvm.assume.
+/// AttrKind is the property that holds.
+/// WasOn if not null is that Value for which AttrKind holds.
+/// ArgValue is optionally an argument of the attribute.
+/// For example if we know that %P has an alignment of at least four:
+///  - AttrKind will be Attribute::Alignment.
+///  - WasOn will be %P.
+///  - ArgValue will be 4.
+struct RetainedKnowledge {
+  Attribute::AttrKind AttrKind = Attribute::None;
+  unsigned ArgValue = 0;
+  Value *WasOn = nullptr;
+  bool operator==(RetainedKnowledge Other) const {
+    return AttrKind == Other.AttrKind && WasOn == Other.WasOn &&
+           ArgValue == Other.ArgValue;
+  }
+  bool operator!=(RetainedKnowledge Other) const { return !(*this == Other); }
+  operator bool() const { return AttrKind != Attribute::None; }
+  static RetainedKnowledge none() { return RetainedKnowledge{}; }
+};
+
+/// Retreive the information help by Assume on the operand at index Idx.
+/// Assume should be an llvm.assume and Idx should be in the operand bundle.
+RetainedKnowledge getKnowledgeFromOperandInAssume(CallInst &Assume,
+                                                  unsigned Idx);
+
+/// Retreive the information help by the Use U of an llvm.assume. the use should
+/// be in the operand bundle.
+inline RetainedKnowledge getKnowledgeFromUseInAssume(const Use *U) {
+  return getKnowledgeFromOperandInAssume(*cast<CallInst>(U->getUser()),
+                                         U->getOperandNo());
+}
+
+/// Tag in operand bundle indicating that this bundle should be ignored.
+constexpr StringRef IgnoreBundleTag = "ignore";
+
+/// Return true iff the operand bundles of the provided llvm.assume doesn't
+/// contain any valuable information. This is true when:
+///  - The operand bundle is empty
+///  - The operand bundle only contains information about dropped values or
+///    constant folded values.
+///
+/// the argument to the call of llvm.assume may still be useful even if the
+/// function returned true.
+bool isAssumeWithEmptyBundle(CallInst &Assume);
+
+/// Return a valid Knowledge associated to the Use U if its Attribute kind is
+/// in AttrKinds.
+RetainedKnowledge getKnowledgeFromUse(const Use *U,
+                                      ArrayRef<Attribute::AttrKind> AttrKinds);
+
+/// Return a valid Knowledge associated to the Value V if its Attribute kind is
+/// in AttrKinds and it matches the Filter.
+RetainedKnowledge getKnowledgeForValue(
+    const Value *V, ArrayRef<Attribute::AttrKind> AttrKinds,
+    AssumptionCache *AC = nullptr,
+    function_ref<bool(RetainedKnowledge, Instruction *,
+                            const CallBase::BundleOpInfo *)>
+        Filter = [](auto...) { return true; });
+
+/// Return a valid Knowledge associated to the Value V if its Attribute kind is
+/// in AttrKinds and the knowledge is suitable to be used in the context of
+/// CtxI.
+RetainedKnowledge getKnowledgeValidInContext(
+    const Value *V, ArrayRef<Attribute::AttrKind> AttrKinds,
+    const Instruction *CtxI, const DominatorTree *DT = nullptr,
+    AssumptionCache *AC = nullptr);
+
+/// This extracts the Knowledge from an element of an operand bundle.
+/// This is mostly for use in the assume builder.
+RetainedKnowledge getKnowledgeFromBundle(CallInst &Assume,
+                                         const CallBase::BundleOpInfo &BOI);
+
+} // namespace llvm
+
+#endif
diff --git a/linux-x64/clang/include/llvm/Analysis/AssumptionCache.h b/linux-x64/clang/include/llvm/Analysis/AssumptionCache.h
index b428464..0ef63dc 100644
--- a/linux-x64/clang/include/llvm/Analysis/AssumptionCache.h
+++ b/linux-x64/clang/include/llvm/Analysis/AssumptionCache.h
@@ -39,6 +39,21 @@
 /// register any new \@llvm.assume calls that they create. Deletions of
 /// \@llvm.assume calls do not require special handling.
 class AssumptionCache {
+public:
+  /// Value of ResultElem::Index indicating that the argument to the call of the
+  /// llvm.assume.
+  enum : unsigned { ExprResultIdx = std::numeric_limits<unsigned>::max() };
+
+  struct ResultElem {
+    WeakTrackingVH Assume;
+
+    /// contains either ExprResultIdx or the index of the operand bundle
+    /// containing the knowledge.
+    unsigned Index;
+    operator Value *() const { return Assume; }
+  };
+
+private:
   /// The function for which this cache is handling assumptions.
   ///
   /// We track this to lazily populate our assumptions.
@@ -46,7 +61,7 @@
 
   /// Vector of weak value handles to calls of the \@llvm.assume
   /// intrinsic.
-  SmallVector<WeakTrackingVH, 4> AssumeHandles;
+  SmallVector<ResultElem, 4> AssumeHandles;
 
   class AffectedValueCallbackVH final : public CallbackVH {
     AssumptionCache *AC;
@@ -66,15 +81,15 @@
   /// A map of values about which an assumption might be providing
   /// information to the relevant set of assumptions.
   using AffectedValuesMap =
-      DenseMap<AffectedValueCallbackVH, SmallVector<WeakTrackingVH, 1>,
+      DenseMap<AffectedValueCallbackVH, SmallVector<ResultElem, 1>,
                AffectedValueCallbackVH::DMI>;
   AffectedValuesMap AffectedValues;
 
   /// Get the vector of assumptions which affect a value from the cache.
-  SmallVector<WeakTrackingVH, 1> &getOrInsertAffectedValues(Value *V);
+  SmallVector<ResultElem, 1> &getOrInsertAffectedValues(Value *V);
 
-  /// Copy affected values in the cache for OV to be affected values for NV.
-  void copyAffectedValuesInCache(Value *OV, Value *NV);
+  /// Move affected values in the cache for OV to be affected values for NV.
+  void transferAffectedValuesInCache(Value *OV, Value *NV);
 
   /// Flag tracking whether we have scanned the function yet.
   ///
@@ -128,20 +143,20 @@
   /// FIXME: We should replace this with pointee_iterator<filter_iterator<...>>
   /// when we can write that to filter out the null values. Then caller code
   /// will become simpler.
-  MutableArrayRef<WeakTrackingVH> assumptions() {
+  MutableArrayRef<ResultElem> assumptions() {
     if (!Scanned)
       scanFunction();
     return AssumeHandles;
   }
 
   /// Access the list of assumptions which affect this value.
-  MutableArrayRef<WeakTrackingVH> assumptionsFor(const Value *V) {
+  MutableArrayRef<ResultElem> assumptionsFor(const Value *V) {
     if (!Scanned)
       scanFunction();
 
     auto AVI = AffectedValues.find_as(const_cast<Value *>(V));
     if (AVI == AffectedValues.end())
-      return MutableArrayRef<WeakTrackingVH>();
+      return MutableArrayRef<ResultElem>();
 
     return AVI->second;
   }
@@ -234,6 +249,21 @@
   static char ID; // Pass identification, replacement for typeid
 };
 
+template<> struct simplify_type<AssumptionCache::ResultElem> {
+  using SimpleType = Value *;
+
+  static SimpleType getSimplifiedValue(AssumptionCache::ResultElem &Val) {
+    return Val;
+  }
+};
+template<> struct simplify_type<const AssumptionCache::ResultElem> {
+  using SimpleType = /*const*/ Value *;
+
+  static SimpleType getSimplifiedValue(const AssumptionCache::ResultElem &Val) {
+    return Val;
+  }
+};
+
 } // end namespace llvm
 
 #endif // LLVM_ANALYSIS_ASSUMPTIONCACHE_H
diff --git a/linux-x64/clang/include/llvm/Analysis/BasicAliasAnalysis.h b/linux-x64/clang/include/llvm/Analysis/BasicAliasAnalysis.h
index 22e8c4b..635c355 100644
--- a/linux-x64/clang/include/llvm/Analysis/BasicAliasAnalysis.h
+++ b/linux-x64/clang/include/llvm/Analysis/BasicAliasAnalysis.h
@@ -18,9 +18,6 @@
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Analysis/AliasAnalysis.h"
-#include "llvm/Analysis/AssumptionCache.h"
-#include "llvm/Analysis/MemoryLocation.h"
-#include "llvm/IR/InstrTypes.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/Pass.h"
 #include <algorithm>
@@ -120,6 +117,9 @@
 
     APInt Scale;
 
+    // Context instruction to use when querying information about this index.
+    const Instruction *CxtI;
+
     bool operator==(const VariableGEPIndex &Other) const {
       return V == Other.V && ZExtBits == Other.ZExtBits &&
              SExtBits == Other.SExtBits && Scale == Other.Scale;
@@ -128,6 +128,17 @@
     bool operator!=(const VariableGEPIndex &Other) const {
       return !operator==(Other);
     }
+
+    void dump() const {
+      print(dbgs());
+      dbgs() << "\n";
+    }
+    void print(raw_ostream &OS) const {
+      OS << "(V=" << V->getName()
+	 << ", zextbits=" << ZExtBits
+	 << ", sextbits=" << SExtBits
+	 << ", scale=" << Scale << ")";
+    }
   };
 
   // Represents the internal structure of a GEP, decomposed into a base pointer,
@@ -135,13 +146,29 @@
   struct DecomposedGEP {
     // Base pointer of the GEP
     const Value *Base;
-    // Total constant offset w.r.t the base from indexing into structs
-    APInt StructOffset;
-    // Total constant offset w.r.t the base from indexing through
-    // pointers/arrays/vectors
-    APInt OtherOffset;
+    // Total constant offset from base.
+    APInt Offset;
     // Scaled variable (non-constant) indices.
     SmallVector<VariableGEPIndex, 4> VarIndices;
+    // Is GEP index scale compile-time constant.
+    bool HasCompileTimeConstantScale;
+
+    void dump() const {
+      print(dbgs());
+      dbgs() << "\n";
+    }
+    void print(raw_ostream &OS) const {
+      OS << "(DecomposedGEP Base=" << Base->getName()
+	 << ", Offset=" << Offset
+	 << ", VarIndices=[";
+      for (size_t i = 0; i < VarIndices.size(); i++) {
+       if (i != 0)
+         OS << ", ";
+       VarIndices[i].print(OS);
+      }
+      OS << "], HasCompileTimeConstantScale=" << HasCompileTimeConstantScale
+	 << ")";
+    }
   };
 
   /// Tracks phi nodes we have visited.
@@ -163,14 +190,23 @@
   /// Tracks instructions visited by pointsToConstantMemory.
   SmallPtrSet<const Value *, 16> Visited;
 
+  /// How many active NoAlias assumption uses there are.
+  int NumAssumptionUses = 0;
+
+  /// Location pairs for which an assumption based result is currently stored.
+  /// Used to remove all potentially incorrect results from the cache if an
+  /// assumption is disproven.
+  SmallVector<AAQueryInfo::LocPair, 4> AssumptionBasedResults;
+
   static const Value *
   GetLinearExpression(const Value *V, APInt &Scale, APInt &Offset,
                       unsigned &ZExtBits, unsigned &SExtBits,
                       const DataLayout &DL, unsigned Depth, AssumptionCache *AC,
                       DominatorTree *DT, bool &NSW, bool &NUW);
 
-  static bool DecomposeGEPExpression(const Value *V, DecomposedGEP &Decomposed,
-      const DataLayout &DL, AssumptionCache *AC, DominatorTree *DT);
+  static DecomposedGEP
+  DecomposeGEPExpression(const Value *V, const DataLayout &DL,
+                         AssumptionCache *AC, DominatorTree *DT);
 
   static bool isGEPBaseAtNegativeOffset(const GEPOperator *GEPOp,
       const DecomposedGEP &DecompGEP, const DecomposedGEP &DecompObject,
@@ -187,7 +223,7 @@
   bool
   constantOffsetHeuristic(const SmallVectorImpl<VariableGEPIndex> &VarIndices,
                           LocationSize V1Size, LocationSize V2Size,
-                          APInt BaseOffset, AssumptionCache *AC,
+                          const APInt &BaseOffset, AssumptionCache *AC,
                           DominatorTree *DT);
 
   bool isValueEqualInPotentialCycles(const Value *V1, const Value *V2);
@@ -212,10 +248,16 @@
                           const Value *UnderV2, AAQueryInfo &AAQI);
 
   AliasResult aliasCheck(const Value *V1, LocationSize V1Size,
-                         AAMDNodes V1AATag, const Value *V2,
-                         LocationSize V2Size, AAMDNodes V2AATag,
+                         const AAMDNodes &V1AATag, const Value *V2,
+                         LocationSize V2Size, const AAMDNodes &V2AATag,
                          AAQueryInfo &AAQI, const Value *O1 = nullptr,
                          const Value *O2 = nullptr);
+
+  AliasResult aliasCheckRecursive(const Value *V1, LocationSize V1Size,
+                                  const AAMDNodes &V1AATag, const Value *V2,
+                                  LocationSize V2Size, const AAMDNodes &V2AATag,
+                                  AAQueryInfo &AAQI, const Value *O1,
+                                  const Value *O2);
 };
 
 /// Analysis pass providing a never-invalidated alias analysis result.
diff --git a/linux-x64/clang/include/llvm/Analysis/BlockFrequencyInfo.h b/linux-x64/clang/include/llvm/Analysis/BlockFrequencyInfo.h
index 8bcfd7f..4c38cdd 100644
--- a/linux-x64/clang/include/llvm/Analysis/BlockFrequencyInfo.h
+++ b/linux-x64/clang/include/llvm/Analysis/BlockFrequencyInfo.h
@@ -103,6 +103,9 @@
   uint64_t getEntryFreq() const;
   void releaseMemory();
   void print(raw_ostream &OS) const;
+
+  // Compare to the other BFI and verify they match.
+  void verifyMatch(BlockFrequencyInfo &Other) const;
 };
 
 /// Analysis pass which computes \c BlockFrequencyInfo.
diff --git a/linux-x64/clang/include/llvm/Analysis/BlockFrequencyInfoImpl.h b/linux-x64/clang/include/llvm/Analysis/BlockFrequencyInfoImpl.h
index bfe4fb1..c227875 100644
--- a/linux-x64/clang/include/llvm/Analysis/BlockFrequencyInfoImpl.h
+++ b/linux-x64/clang/include/llvm/Analysis/BlockFrequencyInfoImpl.h
@@ -24,8 +24,10 @@
 #include "llvm/ADT/Twine.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/IR/BasicBlock.h"
+#include "llvm/IR/ValueHandle.h"
 #include "llvm/Support/BlockFrequency.h"
 #include "llvm/Support/BranchProbability.h"
+#include "llvm/Support/CommandLine.h"
 #include "llvm/Support/DOTGraphTraits.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorHandling.h"
@@ -46,6 +48,8 @@
 
 #define DEBUG_TYPE "block-freq"
 
+extern llvm::cl::opt<bool> CheckBFIUnknownBlockQueries;
+
 namespace llvm {
 
 class BranchProbabilityInfo;
@@ -165,7 +169,7 @@
 /// algorithms for BlockFrequencyInfoImplBase.  Only algorithms that depend on
 /// the block type (or that call such algorithms) are skipped here.
 ///
-/// Nevertheless, the majority of the overall algorithm documention lives with
+/// Nevertheless, the majority of the overall algorithm documentation lives with
 /// BlockFrequencyInfoImpl.  See there for details.
 class BlockFrequencyInfoImplBase {
 public:
@@ -454,7 +458,7 @@
 
   /// Analyze irreducible SCCs.
   ///
-  /// Separate irreducible SCCs from \c G, which is an explict graph of \c
+  /// Separate irreducible SCCs from \c G, which is an explicit graph of \c
   /// OuterLoop (or the top-level function, if \c OuterLoop is \c nullptr).
   /// Insert them into \a Loops before \c Insert.
   ///
@@ -544,6 +548,7 @@
 template <class BlockT> struct TypeMap {};
 template <> struct TypeMap<BasicBlock> {
   using BlockT = BasicBlock;
+  using BlockKeyT = AssertingVH<const BasicBlock>;
   using FunctionT = Function;
   using BranchProbabilityInfoT = BranchProbabilityInfo;
   using LoopT = Loop;
@@ -551,12 +556,16 @@
 };
 template <> struct TypeMap<MachineBasicBlock> {
   using BlockT = MachineBasicBlock;
+  using BlockKeyT = const MachineBasicBlock *;
   using FunctionT = MachineFunction;
   using BranchProbabilityInfoT = MachineBranchProbabilityInfo;
   using LoopT = MachineLoop;
   using LoopInfoT = MachineLoopInfo;
 };
 
+template <class BlockT, class BFIImplT>
+class BFICallbackVH;
+
 /// Get the name of a MachineBasicBlock.
 ///
 /// Get the name of a MachineBasicBlock.  It's templated so that including from
@@ -697,7 +706,7 @@
 ///
 /// In addition to loops, this algorithm has limited support for irreducible
 /// SCCs, which are SCCs with multiple entry blocks.  Irreducible SCCs are
-/// discovered on they fly, and modelled as loops with multiple headers.
+/// discovered on the fly, and modelled as loops with multiple headers.
 ///
 /// The headers of irreducible sub-SCCs consist of its entry blocks and all
 /// nodes that are targets of a backedge within it (excluding backedges within
@@ -842,6 +851,7 @@
   friend struct bfi_detail::BlockEdgesAdder<BT>;
 
   using BlockT = typename bfi_detail::TypeMap<BT>::BlockT;
+  using BlockKeyT = typename bfi_detail::TypeMap<BT>::BlockKeyT;
   using FunctionT = typename bfi_detail::TypeMap<BT>::FunctionT;
   using BranchProbabilityInfoT =
       typename bfi_detail::TypeMap<BT>::BranchProbabilityInfoT;
@@ -849,6 +859,8 @@
   using LoopInfoT = typename bfi_detail::TypeMap<BT>::LoopInfoT;
   using Successor = GraphTraits<const BlockT *>;
   using Predecessor = GraphTraits<Inverse<const BlockT *>>;
+  using BFICallbackVH =
+      bfi_detail::BFICallbackVH<BlockT, BlockFrequencyInfoImpl>;
 
   const BranchProbabilityInfoT *BPI = nullptr;
   const LoopInfoT *LI = nullptr;
@@ -856,7 +868,7 @@
 
   // All blocks in reverse postorder.
   std::vector<const BlockT *> RPOT;
-  DenseMap<const BlockT *, BlockNode> Nodes;
+  DenseMap<BlockKeyT, std::pair<BlockNode, BFICallbackVH>> Nodes;
 
   using rpot_iterator = typename std::vector<const BlockT *>::const_iterator;
 
@@ -868,7 +880,8 @@
   BlockNode getNode(const rpot_iterator &I) const {
     return BlockNode(getIndex(I));
   }
-  BlockNode getNode(const BlockT *BB) const { return Nodes.lookup(BB); }
+
+  BlockNode getNode(const BlockT *BB) const { return Nodes.lookup(BB).first; }
 
   const BlockT *getBlock(const BlockNode &Node) const {
     assert(Node.Index < RPOT.size());
@@ -989,6 +1002,13 @@
 
   void setBlockFreq(const BlockT *BB, uint64_t Freq);
 
+  void forgetBlock(const BlockT *BB) {
+    // We don't erase corresponding items from `Freqs`, `RPOT` and other to
+    // avoid invalidating indices. Doing so would have saved some memory, but
+    // it's not worth it.
+    Nodes.erase(BB);
+  }
+
   Scaled64 getFloatingBlockFreq(const BlockT *BB) const {
     return BlockFrequencyInfoImplBase::getFloatingBlockFreq(getNode(BB));
   }
@@ -1014,8 +1034,40 @@
   raw_ostream &printBlockFreq(raw_ostream &OS, const BlockT *BB) const {
     return BlockFrequencyInfoImplBase::printBlockFreq(OS, getNode(BB));
   }
+
+  void verifyMatch(BlockFrequencyInfoImpl<BT> &Other) const;
 };
 
+namespace bfi_detail {
+
+template <class BFIImplT>
+class BFICallbackVH<BasicBlock, BFIImplT> : public CallbackVH {
+  BFIImplT *BFIImpl;
+
+public:
+  BFICallbackVH() = default;
+
+  BFICallbackVH(const BasicBlock *BB, BFIImplT *BFIImpl)
+      : CallbackVH(BB), BFIImpl(BFIImpl) {}
+
+  virtual ~BFICallbackVH() = default;
+
+  void deleted() override {
+    BFIImpl->forgetBlock(cast<BasicBlock>(getValPtr()));
+  }
+};
+
+/// Dummy implementation since MachineBasicBlocks aren't Values, so ValueHandles
+/// don't apply to them.
+template <class BFIImplT>
+class BFICallbackVH<MachineBasicBlock, BFIImplT> {
+public:
+  BFICallbackVH() = default;
+  BFICallbackVH(const MachineBasicBlock *, BFIImplT *) {}
+};
+
+} // end namespace bfi_detail
+
 template <class BT>
 void BlockFrequencyInfoImpl<BT>::calculate(const FunctionT &F,
                                            const BranchProbabilityInfoT &BPI,
@@ -1043,6 +1095,15 @@
   computeMassInFunction();
   unwrapLoops();
   finalizeMetrics();
+
+  if (CheckBFIUnknownBlockQueries) {
+    // To detect BFI queries for unknown blocks, add entries for unreachable
+    // blocks, if any. This is to distinguish between known/existing unreachable
+    // blocks and unknown blocks.
+    for (const BlockT &BB : F)
+      if (!Nodes.count(&BB))
+        setBlockFreq(&BB, 0);
+  }
 }
 
 template <class BT>
@@ -1054,7 +1115,7 @@
     // BlockNode for it assigned with a new index. The index can be determined
     // by the size of Freqs.
     BlockNode NewNode(Freqs.size());
-    Nodes[BB] = NewNode;
+    Nodes[BB] = {NewNode, BFICallbackVH(BB, this)};
     Freqs.emplace_back();
     BlockFrequencyInfoImplBase::setBlockFreq(NewNode, Freq);
   }
@@ -1074,7 +1135,7 @@
     BlockNode Node = getNode(I);
     LLVM_DEBUG(dbgs() << " - " << getIndex(I) << ": " << getBlockName(Node)
                       << "\n");
-    Nodes[*I] = Node;
+    Nodes[*I] = {Node, BFICallbackVH(*I, this)};
   }
 
   Working.reserve(RPOT.size());
@@ -1185,7 +1246,7 @@
       }
     }
     // As a heuristic, if some headers don't have a weight, give them the
-    // minimium weight seen (not to disrupt the existing trends too much by
+    // minimum weight seen (not to disrupt the existing trends too much by
     // using a weight that's in the general range of the other headers' weights,
     // and the minimum seems to perform better than the average.)
     // FIXME: better update in the passes that drop the header weight.
@@ -1358,6 +1419,61 @@
   return OS;
 }
 
+template <class BT>
+void BlockFrequencyInfoImpl<BT>::verifyMatch(
+    BlockFrequencyInfoImpl<BT> &Other) const {
+  bool Match = true;
+  DenseMap<const BlockT *, BlockNode> ValidNodes;
+  DenseMap<const BlockT *, BlockNode> OtherValidNodes;
+  for (auto &Entry : Nodes) {
+    const BlockT *BB = Entry.first;
+    if (BB) {
+      ValidNodes[BB] = Entry.second.first;
+    }
+  }
+  for (auto &Entry : Other.Nodes) {
+    const BlockT *BB = Entry.first;
+    if (BB) {
+      OtherValidNodes[BB] = Entry.second.first;
+    }
+  }
+  unsigned NumValidNodes = ValidNodes.size();
+  unsigned NumOtherValidNodes = OtherValidNodes.size();
+  if (NumValidNodes != NumOtherValidNodes) {
+    Match = false;
+    dbgs() << "Number of blocks mismatch: " << NumValidNodes << " vs "
+           << NumOtherValidNodes << "\n";
+  } else {
+    for (auto &Entry : ValidNodes) {
+      const BlockT *BB = Entry.first;
+      BlockNode Node = Entry.second;
+      if (OtherValidNodes.count(BB)) {
+        BlockNode OtherNode = OtherValidNodes[BB];
+        const auto &Freq = Freqs[Node.Index];
+        const auto &OtherFreq = Other.Freqs[OtherNode.Index];
+        if (Freq.Integer != OtherFreq.Integer) {
+          Match = false;
+          dbgs() << "Freq mismatch: " << bfi_detail::getBlockName(BB) << " "
+                 << Freq.Integer << " vs " << OtherFreq.Integer << "\n";
+        }
+      } else {
+        Match = false;
+        dbgs() << "Block " << bfi_detail::getBlockName(BB) << " index "
+               << Node.Index << " does not exist in Other.\n";
+      }
+    }
+    // If there's a valid node in OtherValidNodes that's not in ValidNodes,
+    // either the above num check or the check on OtherValidNodes will fail.
+  }
+  if (!Match) {
+    dbgs() << "This\n";
+    print(dbgs());
+    dbgs() << "Other\n";
+    Other.print(dbgs());
+  }
+  assert(Match && "BFI mismatch");
+}
+
 // Graph trait base class for block frequency information graph
 // viewer.
 
@@ -1375,7 +1491,7 @@
   explicit BFIDOTGraphTraitsBase(bool isSimple = false)
       : DefaultDOTGraphTraits(isSimple) {}
 
-  static std::string getGraphName(const BlockFrequencyInfoT *G) {
+  static StringRef getGraphName(const BlockFrequencyInfoT *G) {
     return G->getFunction()->getName();
   }
 
diff --git a/linux-x64/clang/include/llvm/Analysis/BranchProbabilityInfo.h b/linux-x64/clang/include/llvm/Analysis/BranchProbabilityInfo.h
index 97cb730..6a28623 100644
--- a/linux-x64/clang/include/llvm/Analysis/BranchProbabilityInfo.h
+++ b/linux-x64/clang/include/llvm/Analysis/BranchProbabilityInfo.h
@@ -27,13 +27,17 @@
 #include <algorithm>
 #include <cassert>
 #include <cstdint>
+#include <memory>
 #include <utility>
 
 namespace llvm {
 
 class Function;
+class Loop;
 class LoopInfo;
 class raw_ostream;
+class DominatorTree;
+class PostDominatorTree;
 class TargetLibraryInfo;
 class Value;
 
@@ -49,19 +53,79 @@
 /// identify an edge, since we can have multiple edges from Src to Dst.
 /// As an example, we can have a switch which jumps to Dst with value 0 and
 /// value 10.
+///
+/// Process of computing branch probabilities can be logically viewed as three
+/// step process:
+///
+///   First, if there is a profile information associated with the branch then
+/// it is trivially translated to branch probabilities. There is one exception
+/// from this rule though. Probabilities for edges leading to "unreachable"
+/// blocks (blocks with the estimated weight not greater than
+/// UNREACHABLE_WEIGHT) are evaluated according to static estimation and
+/// override profile information. If no branch probabilities were calculated
+/// on this step then take the next one.
+///
+///   Second, estimate absolute execution weights for each block based on
+/// statically known information. Roots of such information are "cold",
+/// "unreachable", "noreturn" and "unwind" blocks. Those blocks get their
+/// weights set to BlockExecWeight::COLD, BlockExecWeight::UNREACHABLE,
+/// BlockExecWeight::NORETURN and BlockExecWeight::UNWIND respectively. Then the
+/// weights are propagated to the other blocks up the domination line. In
+/// addition, if all successors have estimated weights set then maximum of these
+/// weights assigned to the block itself (while this is not ideal heuristic in
+/// theory it's simple and works reasonably well in most cases) and the process
+/// repeats. Once the process of weights propagation converges branch
+/// probabilities are set for all such branches that have at least one successor
+/// with the weight set. Default execution weight (BlockExecWeight::DEFAULT) is
+/// used for any successors which doesn't have its weight set. For loop back
+/// branches we use their weights scaled by loop trip count equal to
+/// 'LBH_TAKEN_WEIGHT/LBH_NOTTAKEN_WEIGHT'.
+///
+/// Here is a simple example demonstrating how the described algorithm works.
+///
+///          BB1
+///         /   \
+///        v     v
+///      BB2     BB3
+///     /   \
+///    v     v
+///  ColdBB  UnreachBB
+///
+/// Initially, ColdBB is associated with COLD_WEIGHT and UnreachBB with
+/// UNREACHABLE_WEIGHT. COLD_WEIGHT is set to BB2 as maximum between its
+/// successors. BB1 and BB3 has no explicit estimated weights and assumed to
+/// have DEFAULT_WEIGHT. Based on assigned weights branches will have the
+/// following probabilities:
+/// P(BB1->BB2) = COLD_WEIGHT/(COLD_WEIGHT + DEFAULT_WEIGHT) =
+///   0xffff / (0xffff + 0xfffff) = 0.0588(5.9%)
+/// P(BB1->BB3) = DEFAULT_WEIGHT_WEIGHT/(COLD_WEIGHT + DEFAULT_WEIGHT) =
+///          0xfffff / (0xffff + 0xfffff) = 0.941(94.1%)
+/// P(BB2->ColdBB) = COLD_WEIGHT/(COLD_WEIGHT + UNREACHABLE_WEIGHT) = 1(100%)
+/// P(BB2->UnreachBB) =
+///   UNREACHABLE_WEIGHT/(COLD_WEIGHT+UNREACHABLE_WEIGHT) = 0(0%)
+///
+/// If no branch probabilities were calculated on this step then take the next
+/// one.
+///
+///   Third, apply different kinds of local heuristics for each individual
+/// branch until first match. For example probability of a pointer to be null is
+/// estimated as PH_TAKEN_WEIGHT/(PH_TAKEN_WEIGHT + PH_NONTAKEN_WEIGHT). If
+/// no local heuristic has been matched then branch is left with no explicit
+/// probability set and assumed to have default probability.
 class BranchProbabilityInfo {
 public:
   BranchProbabilityInfo() = default;
 
   BranchProbabilityInfo(const Function &F, const LoopInfo &LI,
-                        const TargetLibraryInfo *TLI = nullptr) {
-    calculate(F, LI, TLI);
+                        const TargetLibraryInfo *TLI = nullptr,
+                        DominatorTree *DT = nullptr,
+                        PostDominatorTree *PDT = nullptr) {
+    calculate(F, LI, TLI, DT, PDT);
   }
 
   BranchProbabilityInfo(BranchProbabilityInfo &&Arg)
       : Probs(std::move(Arg.Probs)), LastF(Arg.LastF),
-        PostDominatedByUnreachable(std::move(Arg.PostDominatedByUnreachable)),
-        PostDominatedByColdCall(std::move(Arg.PostDominatedByColdCall)) {}
+        EstimatedBlockWeight(std::move(Arg.EstimatedBlockWeight)) {}
 
   BranchProbabilityInfo(const BranchProbabilityInfo &) = delete;
   BranchProbabilityInfo &operator=(const BranchProbabilityInfo &) = delete;
@@ -69,11 +133,13 @@
   BranchProbabilityInfo &operator=(BranchProbabilityInfo &&RHS) {
     releaseMemory();
     Probs = std::move(RHS.Probs);
-    PostDominatedByColdCall = std::move(RHS.PostDominatedByColdCall);
-    PostDominatedByUnreachable = std::move(RHS.PostDominatedByUnreachable);
+    EstimatedBlockWeight = std::move(RHS.EstimatedBlockWeight);
     return *this;
   }
 
+  bool invalidate(Function &, const PreservedAnalyses &PA,
+                  FunctionAnalysisManager::Invalidator &);
+
   void releaseMemory();
 
   void print(raw_ostream &OS) const;
@@ -94,7 +160,7 @@
                                        const BasicBlock *Dst) const;
 
   BranchProbability getEdgeProbability(const BasicBlock *Src,
-                                       succ_const_iterator Dst) const;
+                                       const_succ_iterator Dst) const;
 
   /// Test if an edge is hot relative to other out-edges of the Src.
   ///
@@ -116,14 +182,20 @@
   raw_ostream &printEdgeProbability(raw_ostream &OS, const BasicBlock *Src,
                                     const BasicBlock *Dst) const;
 
-  /// Set the raw edge probability for the given edge.
+public:
+  /// Set the raw probabilities for all edges from the given block.
   ///
-  /// This allows a pass to explicitly set the edge probability for an edge. It
-  /// can be used when updating the CFG to update and preserve the branch
-  /// probability information. Read the implementation of how these edge
-  /// probabilities are calculated carefully before using!
-  void setEdgeProbability(const BasicBlock *Src, unsigned IndexInSuccessors,
-                          BranchProbability Prob);
+  /// This allows a pass to explicitly set edge probabilities for a block. It
+  /// can be used when updating the CFG to update the branch probability
+  /// information.
+  void setEdgeProbability(const BasicBlock *Src,
+                          const SmallVectorImpl<BranchProbability> &Probs);
+
+  /// Copy outgoing edge probabilities from \p Src to \p Dst.
+  ///
+  /// This allows to keep probabilities unset for the destination if they were
+  /// unset for source.
+  void copyEdgeProbabilities(BasicBlock *Src, BasicBlock *Dst);
 
   static BranchProbability getBranchProbStackProtector(bool IsLikely) {
     static const BranchProbability LikelyProb((1u << 20) - 1, 1u << 20);
@@ -131,18 +203,73 @@
   }
 
   void calculate(const Function &F, const LoopInfo &LI,
-                 const TargetLibraryInfo *TLI = nullptr);
+                 const TargetLibraryInfo *TLI, DominatorTree *DT,
+                 PostDominatorTree *PDT);
 
   /// Forget analysis results for the given basic block.
   void eraseBlock(const BasicBlock *BB);
 
-  // Use to track SCCs for handling irreducible loops.
-  using SccMap = DenseMap<const BasicBlock *, int>;
-  using SccHeaderMap = DenseMap<const BasicBlock *, bool>;
-  using SccHeaderMaps = std::vector<SccHeaderMap>;
-  struct SccInfo {
+  // Data structure to track SCCs for handling irreducible loops.
+  class SccInfo {
+    // Enum of types to classify basic blocks in SCC. Basic block belonging to
+    // SCC is 'Inner' until it is either 'Header' or 'Exiting'. Note that a
+    // basic block can be 'Header' and 'Exiting' at the same time.
+    enum SccBlockType {
+      Inner = 0x0,
+      Header = 0x1,
+      Exiting = 0x2,
+    };
+    // Map of basic blocks to SCC IDs they belong to. If basic block doesn't
+    // belong to any SCC it is not in the map.
+    using SccMap = DenseMap<const BasicBlock *, int>;
+    // Each basic block in SCC is attributed with one or several types from
+    // SccBlockType. Map value has uint32_t type (instead of SccBlockType)
+    // since basic block may be for example "Header" and "Exiting" at the same
+    // time and we need to be able to keep more than one value from
+    // SccBlockType.
+    using SccBlockTypeMap = DenseMap<const BasicBlock *, uint32_t>;
+    // Vector containing classification of basic blocks for all  SCCs where i'th
+    // vector element corresponds to SCC with ID equal to i.
+    using SccBlockTypeMaps = std::vector<SccBlockTypeMap>;
+
     SccMap SccNums;
-    SccHeaderMaps SccHeaders;
+    SccBlockTypeMaps SccBlocks;
+
+  public:
+    explicit SccInfo(const Function &F);
+
+    /// If \p BB belongs to some SCC then ID of that SCC is returned, otherwise
+    /// -1 is returned. If \p BB belongs to more than one SCC at the same time
+    /// result is undefined.
+    int getSCCNum(const BasicBlock *BB) const;
+    /// Returns true if \p BB is a 'header' block in SCC with \p SccNum ID,
+    /// false otherwise.
+    bool isSCCHeader(const BasicBlock *BB, int SccNum) const {
+      return getSccBlockType(BB, SccNum) & Header;
+    }
+    /// Returns true if \p BB is an 'exiting' block in SCC with \p SccNum ID,
+    /// false otherwise.
+    bool isSCCExitingBlock(const BasicBlock *BB, int SccNum) const {
+      return getSccBlockType(BB, SccNum) & Exiting;
+    }
+    /// Fills in \p Enters vector with all such blocks that don't belong to
+    /// SCC with \p SccNum ID but there is an edge to a block belonging to the
+    /// SCC.
+    void getSccEnterBlocks(int SccNum,
+                           SmallVectorImpl<BasicBlock *> &Enters) const;
+    /// Fills in \p Exits vector with all such blocks that don't belong to
+    /// SCC with \p SccNum ID but there is an edge from a block belonging to the
+    /// SCC.
+    void getSccExitBlocks(int SccNum,
+                          SmallVectorImpl<BasicBlock *> &Exits) const;
+
+  private:
+    /// Returns \p BB's type according to classification given by SccBlockType
+    /// enum. Please note that \p BB must belong to SSC with \p SccNum ID.
+    uint32_t getSccBlockType(const BasicBlock *BB, int SccNum) const;
+    /// Calculates \p BB's type and stores it in internal data structures for
+    /// future use. Please note that \p BB must belong to SSC with \p SccNum ID.
+    void calculateSccBlockType(const BasicBlock *BB, int SccNum);
   };
 
 private:
@@ -154,7 +281,6 @@
     void deleted() override {
       assert(BPI != nullptr);
       BPI->eraseBlock(cast<BasicBlock>(getValPtr()));
-      BPI->Handles.erase(*this);
     }
 
   public:
@@ -162,42 +288,132 @@
         : CallbackVH(const_cast<Value *>(V)), BPI(BPI) {}
   };
 
+  /// Pair of Loop and SCC ID number. Used to unify handling of normal and
+  /// SCC based loop representations.
+  using LoopData = std::pair<Loop *, int>;
+  /// Helper class to keep basic block along with its loop data information.
+  class LoopBlock {
+  public:
+    explicit LoopBlock(const BasicBlock *BB, const LoopInfo &LI,
+                       const SccInfo &SccI);
+
+    const BasicBlock *getBlock() const { return BB; }
+    BasicBlock *getBlock() { return const_cast<BasicBlock *>(BB); }
+    LoopData getLoopData() const { return LD; }
+    Loop *getLoop() const { return LD.first; }
+    int getSccNum() const { return LD.second; }
+
+    bool belongsToLoop() const { return getLoop() || getSccNum() != -1; }
+    bool belongsToSameLoop(const LoopBlock &LB) const {
+      return (LB.getLoop() && getLoop() == LB.getLoop()) ||
+             (LB.getSccNum() != -1 && getSccNum() == LB.getSccNum());
+    }
+
+  private:
+    const BasicBlock *const BB = nullptr;
+    LoopData LD = {nullptr, -1};
+  };
+
+  // Pair of LoopBlocks representing an edge from first to second block.
+  using LoopEdge = std::pair<const LoopBlock &, const LoopBlock &>;
+
   DenseSet<BasicBlockCallbackVH, DenseMapInfo<Value*>> Handles;
 
   // Since we allow duplicate edges from one basic block to another, we use
   // a pair (PredBlock and an index in the successors) to specify an edge.
   using Edge = std::pair<const BasicBlock *, unsigned>;
 
-  // Default weight value. Used when we don't have information about the edge.
-  // TODO: DEFAULT_WEIGHT makes sense during static predication, when none of
-  // the successors have a weight yet. But it doesn't make sense when providing
-  // weight to an edge that may have siblings with non-zero weights. This can
-  // be handled various ways, but it's probably fine for an edge with unknown
-  // weight to just "inherit" the non-zero weight of an adjacent successor.
-  static const uint32_t DEFAULT_WEIGHT = 16;
-
   DenseMap<Edge, BranchProbability> Probs;
 
   /// Track the last function we run over for printing.
-  const Function *LastF;
+  const Function *LastF = nullptr;
 
-  /// Track the set of blocks directly succeeded by a returning block.
-  SmallPtrSet<const BasicBlock *, 16> PostDominatedByUnreachable;
+  const LoopInfo *LI = nullptr;
 
-  /// Track the set of blocks that always lead to a cold call.
-  SmallPtrSet<const BasicBlock *, 16> PostDominatedByColdCall;
+  /// Keeps information about all SCCs in a function.
+  std::unique_ptr<const SccInfo> SccI;
 
-  void updatePostDominatedByUnreachable(const BasicBlock *BB);
-  void updatePostDominatedByColdCall(const BasicBlock *BB);
-  bool calcUnreachableHeuristics(const BasicBlock *BB);
+  /// Keeps mapping of a basic block to its estimated weight.
+  SmallDenseMap<const BasicBlock *, uint32_t> EstimatedBlockWeight;
+
+  /// Keeps mapping of a loop to estimated weight to enter the loop.
+  SmallDenseMap<LoopData, uint32_t> EstimatedLoopWeight;
+
+  /// Helper to construct LoopBlock for \p BB.
+  LoopBlock getLoopBlock(const BasicBlock *BB) const {
+    return LoopBlock(BB, *LI, *SccI.get());
+  }
+
+  /// Returns true if destination block belongs to some loop and source block is
+  /// either doesn't belong to any loop or belongs to a loop which is not inner
+  /// relative to the destination block.
+  bool isLoopEnteringEdge(const LoopEdge &Edge) const;
+  /// Returns true if source block belongs to some loop and destination block is
+  /// either doesn't belong to any loop or belongs to a loop which is not inner
+  /// relative to the source block.
+  bool isLoopExitingEdge(const LoopEdge &Edge) const;
+  /// Returns true if \p Edge is either enters to or exits from some loop, false
+  /// in all other cases.
+  bool isLoopEnteringExitingEdge(const LoopEdge &Edge) const;
+  /// Returns true if source and destination blocks belongs to the same loop and
+  /// destination block is loop header.
+  bool isLoopBackEdge(const LoopEdge &Edge) const;
+  // Fills in \p Enters vector with all "enter" blocks to a loop \LB belongs to.
+  void getLoopEnterBlocks(const LoopBlock &LB,
+                          SmallVectorImpl<BasicBlock *> &Enters) const;
+  // Fills in \p Exits vector with all "exit" blocks from a loop \LB belongs to.
+  void getLoopExitBlocks(const LoopBlock &LB,
+                         SmallVectorImpl<BasicBlock *> &Exits) const;
+
+  /// Returns estimated weight for \p BB. None if \p BB has no estimated weight.
+  Optional<uint32_t> getEstimatedBlockWeight(const BasicBlock *BB) const;
+
+  /// Returns estimated weight to enter \p L. In other words it is weight of
+  /// loop's header block not scaled by trip count. Returns None if \p L has no
+  /// no estimated weight.
+  Optional<uint32_t> getEstimatedLoopWeight(const LoopData &L) const;
+
+  /// Return estimated weight for \p Edge. Returns None if estimated weight is
+  /// unknown.
+  Optional<uint32_t> getEstimatedEdgeWeight(const LoopEdge &Edge) const;
+
+  /// Iterates over all edges leading from \p SrcBB to \p Successors and
+  /// returns maximum of all estimated weights. If at least one edge has unknown
+  /// estimated weight None is returned.
+  template <class IterT>
+  Optional<uint32_t>
+  getMaxEstimatedEdgeWeight(const LoopBlock &SrcBB,
+                            iterator_range<IterT> Successors) const;
+
+  /// If \p LoopBB has no estimated weight then set it to \p BBWeight and
+  /// return true. Otherwise \p BB's weight remains unchanged and false is
+  /// returned. In addition all blocks/loops that might need their weight to be
+  /// re-estimated are put into BlockWorkList/LoopWorkList.
+  bool updateEstimatedBlockWeight(LoopBlock &LoopBB, uint32_t BBWeight,
+                                  SmallVectorImpl<BasicBlock *> &BlockWorkList,
+                                  SmallVectorImpl<LoopBlock> &LoopWorkList);
+
+  /// Starting from \p LoopBB (including \p LoopBB itself) propagate \p BBWeight
+  /// up the domination tree.
+  void propagateEstimatedBlockWeight(const LoopBlock &LoopBB, DominatorTree *DT,
+                                     PostDominatorTree *PDT, uint32_t BBWeight,
+                                     SmallVectorImpl<BasicBlock *> &WorkList,
+                                     SmallVectorImpl<LoopBlock> &LoopWorkList);
+
+  /// Returns block's weight encoded in the IR.
+  Optional<uint32_t> getInitialEstimatedBlockWeight(const BasicBlock *BB);
+
+  // Computes estimated weights for all blocks in \p F.
+  void computeEestimateBlockWeight(const Function &F, DominatorTree *DT,
+                                   PostDominatorTree *PDT);
+
+  /// Based on computed weights by \p computeEstimatedBlockWeight set
+  /// probabilities on branches.
+  bool calcEstimatedHeuristics(const BasicBlock *BB);
   bool calcMetadataWeights(const BasicBlock *BB);
-  bool calcColdCallHeuristics(const BasicBlock *BB);
   bool calcPointerHeuristics(const BasicBlock *BB);
-  bool calcLoopBranchHeuristics(const BasicBlock *BB, const LoopInfo &LI,
-                                SccInfo &SccI);
   bool calcZeroHeuristics(const BasicBlock *BB, const TargetLibraryInfo *TLI);
   bool calcFloatingPointHeuristics(const BasicBlock *BB);
-  bool calcInvokeHeuristics(const BasicBlock *BB);
 };
 
 /// Analysis pass which computes \c BranchProbabilityInfo.
@@ -233,10 +449,7 @@
 public:
   static char ID;
 
-  BranchProbabilityInfoWrapperPass() : FunctionPass(ID) {
-    initializeBranchProbabilityInfoWrapperPassPass(
-        *PassRegistry::getPassRegistry());
-  }
+  BranchProbabilityInfoWrapperPass();
 
   BranchProbabilityInfo &getBPI() { return BPI; }
   const BranchProbabilityInfo &getBPI() const { return BPI; }
diff --git a/linux-x64/clang/include/llvm/Analysis/CFG.h b/linux-x64/clang/include/llvm/Analysis/CFG.h
index bb55e76..a36ceb4 100644
--- a/linux-x64/clang/include/llvm/Analysis/CFG.h
+++ b/linux-x64/clang/include/llvm/Analysis/CFG.h
@@ -14,8 +14,9 @@
 #ifndef LLVM_ANALYSIS_CFG_H
 #define LLVM_ANALYSIS_CFG_H
 
-#include "llvm/IR/BasicBlock.h"
-#include "llvm/IR/CFG.h"
+#include "llvm/ADT/GraphTraits.h"
+#include "llvm/ADT/SmallPtrSet.h"
+#include <utility>
 
 namespace llvm {
 
@@ -24,6 +25,7 @@
 class Function;
 class Instruction;
 class LoopInfo;
+template <typename T> class SmallVectorImpl;
 
 /// Analyze the specified function to find all of the loop backedges in the
 /// function and return them.  This is a relatively cheap (compared to
@@ -46,6 +48,8 @@
 ///
 bool isCriticalEdge(const Instruction *TI, unsigned SuccNum,
                     bool AllowIdenticalEdges = false);
+bool isCriticalEdge(const Instruction *TI, const BasicBlock *Succ,
+                    bool AllowIdenticalEdges = false);
 
 /// Determine whether instruction 'To' is reachable from 'From', without passing
 /// through any blocks in ExclusionSet, returning true if uncertain.
diff --git a/linux-x64/clang/include/llvm/Analysis/CFGPrinter.h b/linux-x64/clang/include/llvm/Analysis/CFGPrinter.h
index aaefc11..5370079 100644
--- a/linux-x64/clang/include/llvm/Analysis/CFGPrinter.h
+++ b/linux-x64/clang/include/llvm/Analysis/CFGPrinter.h
@@ -18,49 +18,120 @@
 #ifndef LLVM_ANALYSIS_CFGPRINTER_H
 #define LLVM_ANALYSIS_CFGPRINTER_H
 
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/Analysis/BlockFrequencyInfo.h"
+#include "llvm/Analysis/BranchProbabilityInfo.h"
+#include "llvm/Analysis/HeatUtils.h"
 #include "llvm/IR/CFG.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/PassManager.h"
+#include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/GraphWriter.h"
 
 namespace llvm {
-class CFGViewerPass
-    : public PassInfoMixin<CFGViewerPass> {
+class CFGViewerPass : public PassInfoMixin<CFGViewerPass> {
 public:
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
 };
 
-class CFGOnlyViewerPass
-    : public PassInfoMixin<CFGOnlyViewerPass> {
+class CFGOnlyViewerPass : public PassInfoMixin<CFGOnlyViewerPass> {
 public:
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
 };
 
-class CFGPrinterPass
-    : public PassInfoMixin<CFGPrinterPass> {
+class CFGPrinterPass : public PassInfoMixin<CFGPrinterPass> {
 public:
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
 };
 
-class CFGOnlyPrinterPass
-    : public PassInfoMixin<CFGOnlyPrinterPass> {
+class CFGOnlyPrinterPass : public PassInfoMixin<CFGOnlyPrinterPass> {
 public:
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
 };
 
-template<>
-struct DOTGraphTraits<const Function*> : public DefaultDOTGraphTraits {
+class DOTFuncInfo {
+private:
+  const Function *F;
+  const BlockFrequencyInfo *BFI;
+  const BranchProbabilityInfo *BPI;
+  uint64_t MaxFreq;
+  bool ShowHeat;
+  bool EdgeWeights;
+  bool RawWeights;
 
-  DOTGraphTraits (bool isSimple=false) : DefaultDOTGraphTraits(isSimple) {}
+public:
+  DOTFuncInfo(const Function *F) : DOTFuncInfo(F, nullptr, nullptr, 0) {}
 
-  static std::string getGraphName(const Function *F) {
-    return "CFG for '" + F->getName().str() + "' function";
+  DOTFuncInfo(const Function *F, const BlockFrequencyInfo *BFI,
+              const BranchProbabilityInfo *BPI, uint64_t MaxFreq)
+      : F(F), BFI(BFI), BPI(BPI), MaxFreq(MaxFreq) {
+    ShowHeat = false;
+    EdgeWeights = !!BPI; // Print EdgeWeights when BPI is available.
+    RawWeights = !!BFI;  // Print RawWeights when BFI is available.
   }
 
-  static std::string getSimpleNodeLabel(const BasicBlock *Node,
-                                        const Function *) {
+  const BlockFrequencyInfo *getBFI() { return BFI; }
+
+  const BranchProbabilityInfo *getBPI() { return BPI; }
+
+  const Function *getFunction() { return this->F; }
+
+  uint64_t getMaxFreq() { return MaxFreq; }
+
+  uint64_t getFreq(const BasicBlock *BB) {
+    return BFI->getBlockFreq(BB).getFrequency();
+  }
+
+  void setHeatColors(bool ShowHeat) { this->ShowHeat = ShowHeat; }
+
+  bool showHeatColors() { return ShowHeat; }
+
+  void setRawEdgeWeights(bool RawWeights) { this->RawWeights = RawWeights; }
+
+  bool useRawEdgeWeights() { return RawWeights; }
+
+  void setEdgeWeights(bool EdgeWeights) { this->EdgeWeights = EdgeWeights; }
+
+  bool showEdgeWeights() { return EdgeWeights; }
+};
+
+template <>
+struct GraphTraits<DOTFuncInfo *> : public GraphTraits<const BasicBlock *> {
+  static NodeRef getEntryNode(DOTFuncInfo *CFGInfo) {
+    return &(CFGInfo->getFunction()->getEntryBlock());
+  }
+
+  // nodes_iterator/begin/end - Allow iteration over all nodes in the graph
+  using nodes_iterator = pointer_iterator<Function::const_iterator>;
+
+  static nodes_iterator nodes_begin(DOTFuncInfo *CFGInfo) {
+    return nodes_iterator(CFGInfo->getFunction()->begin());
+  }
+
+  static nodes_iterator nodes_end(DOTFuncInfo *CFGInfo) {
+    return nodes_iterator(CFGInfo->getFunction()->end());
+  }
+
+  static size_t size(DOTFuncInfo *CFGInfo) {
+    return CFGInfo->getFunction()->size();
+  }
+};
+
+template <>
+struct DOTGraphTraits<DOTFuncInfo *> : public DefaultDOTGraphTraits {
+
+  // Cache for is hidden property
+  llvm::DenseMap<const BasicBlock *, bool> isHiddenBasicBlock;
+
+  DOTGraphTraits(bool isSimple = false) : DefaultDOTGraphTraits(isSimple) {}
+
+  static std::string getGraphName(DOTFuncInfo *CFGInfo) {
+    return "CFG for '" + CFGInfo->getFunction()->getName().str() + "' function";
+  }
+
+  static std::string getSimpleNodeLabel(const BasicBlock *Node, DOTFuncInfo *) {
     if (!Node->getName().empty())
       return Node->getName().str();
 
@@ -71,8 +142,18 @@
     return OS.str();
   }
 
-  static std::string getCompleteNodeLabel(const BasicBlock *Node,
-                                          const Function *) {
+  static void eraseComment(std::string &OutStr, unsigned &I, unsigned Idx) {
+    OutStr.erase(OutStr.begin() + I, OutStr.begin() + Idx);
+    --I;
+  }
+
+  static std::string getCompleteNodeLabel(
+      const BasicBlock *Node, DOTFuncInfo *,
+      llvm::function_ref<void(raw_string_ostream &, const BasicBlock &)>
+          HandleBasicBlock = [](raw_string_ostream &OS,
+                                const BasicBlock &Node) -> void { OS << Node; },
+      llvm::function_ref<void(std::string &, unsigned &, unsigned)>
+          HandleComment = eraseComment) {
     enum { MaxColumns = 80 };
     std::string Str;
     raw_string_ostream OS(Str);
@@ -82,24 +163,24 @@
       OS << ":";
     }
 
-    OS << *Node;
+    HandleBasicBlock(OS, *Node);
     std::string OutStr = OS.str();
-    if (OutStr[0] == '\n') OutStr.erase(OutStr.begin());
+    if (OutStr[0] == '\n')
+      OutStr.erase(OutStr.begin());
 
     // Process string output to make it nicer...
     unsigned ColNum = 0;
     unsigned LastSpace = 0;
     for (unsigned i = 0; i != OutStr.length(); ++i) {
-      if (OutStr[i] == '\n') {                            // Left justify
+      if (OutStr[i] == '\n') { // Left justify
         OutStr[i] = '\\';
-        OutStr.insert(OutStr.begin()+i+1, 'l');
+        OutStr.insert(OutStr.begin() + i + 1, 'l');
         ColNum = 0;
         LastSpace = 0;
-      } else if (OutStr[i] == ';') {                      // Delete comments!
-        unsigned Idx = OutStr.find('\n', i+1);            // Find end of line
-        OutStr.erase(OutStr.begin()+i, OutStr.begin()+Idx);
-        --i;
-      } else if (ColNum == MaxColumns) {                  // Wrap lines.
+      } else if (OutStr[i] == ';') {             // Delete comments!
+        unsigned Idx = OutStr.find('\n', i + 1); // Find end of line
+        HandleComment(OutStr, i, Idx);
+      } else if (ColNum == MaxColumns) { // Wrap lines.
         // Wrap very long names even though we can't find a space.
         if (!LastSpace)
           LastSpace = i;
@@ -107,8 +188,7 @@
         ColNum = i - LastSpace;
         LastSpace = 0;
         i += 3; // The loop will advance 'i' again.
-      }
-      else
+      } else
         ++ColNum;
       if (OutStr[i] == ' ')
         LastSpace = i;
@@ -116,16 +196,16 @@
     return OutStr;
   }
 
-  std::string getNodeLabel(const BasicBlock *Node,
-                           const Function *Graph) {
+  std::string getNodeLabel(const BasicBlock *Node, DOTFuncInfo *CFGInfo) {
+
     if (isSimple())
-      return getSimpleNodeLabel(Node, Graph);
+      return getSimpleNodeLabel(Node, CFGInfo);
     else
-      return getCompleteNodeLabel(Node, Graph);
+      return getCompleteNodeLabel(Node, CFGInfo);
   }
 
   static std::string getEdgeSourceLabel(const BasicBlock *Node,
-                                        succ_const_iterator I) {
+                                        const_succ_iterator I) {
     // Label source of conditional branches with "T" or "F"
     if (const BranchInst *BI = dyn_cast<BranchInst>(Node->getTerminator()))
       if (BI->isConditional())
@@ -135,7 +215,8 @@
     if (const SwitchInst *SI = dyn_cast<SwitchInst>(Node->getTerminator())) {
       unsigned SuccNo = I.getSuccessorIndex();
 
-      if (SuccNo == 0) return "def";
+      if (SuccNo == 0)
+        return "def";
 
       std::string Str;
       raw_string_ostream OS(Str);
@@ -147,12 +228,39 @@
   }
 
   /// Display the raw branch weights from PGO.
-  std::string getEdgeAttributes(const BasicBlock *Node, succ_const_iterator I,
-                                const Function *F) {
+  std::string getEdgeAttributes(const BasicBlock *Node, const_succ_iterator I,
+                                DOTFuncInfo *CFGInfo) {
+    if (!CFGInfo->showEdgeWeights())
+      return "";
+
     const Instruction *TI = Node->getTerminator();
     if (TI->getNumSuccessors() == 1)
+      return "penwidth=2";
+
+    unsigned OpNo = I.getSuccessorIndex();
+
+    if (OpNo >= TI->getNumSuccessors())
       return "";
 
+    BasicBlock *SuccBB = TI->getSuccessor(OpNo);
+    auto BranchProb = CFGInfo->getBPI()->getEdgeProbability(Node, SuccBB);
+    double WeightPercent = ((double)BranchProb.getNumerator()) /
+                           ((double)BranchProb.getDenominator());
+    double Width = 1 + WeightPercent;
+
+    if (!CFGInfo->useRawEdgeWeights())
+      return formatv("label=\"{0:P}\" penwidth={1}", WeightPercent, Width)
+          .str();
+
+    // Prepend a 'W' to indicate that this is a weight rather than the actual
+    // profile count (due to scaling).
+
+    uint64_t Freq = CFGInfo->getFreq(Node);
+    std::string Attrs = formatv("label=\"W:{0}\" penwidth={1}",
+                                (uint64_t)(Freq * WeightPercent), Width);
+    if (Attrs.size())
+      return Attrs;
+
     MDNode *WeightsNode = TI->getMetadata(LLVMContext::MD_prof);
     if (!WeightsNode)
       return "";
@@ -161,25 +269,41 @@
     if (MDName->getString() != "branch_weights")
       return "";
 
-    unsigned OpNo = I.getSuccessorIndex() + 1;
+    OpNo = I.getSuccessorIndex() + 1;
     if (OpNo >= WeightsNode->getNumOperands())
       return "";
     ConstantInt *Weight =
         mdconst::dyn_extract<ConstantInt>(WeightsNode->getOperand(OpNo));
     if (!Weight)
       return "";
-
-    // Prepend a 'W' to indicate that this is a weight rather than the actual
-    // profile count (due to scaling).
-    return ("label=\"W:" + Twine(Weight->getZExtValue()) + "\"").str();
+    return ("label=\"W:" + std::to_string(Weight->getZExtValue()) +
+            "\" penwidth=" + std::to_string(Width));
   }
+
+  std::string getNodeAttributes(const BasicBlock *Node, DOTFuncInfo *CFGInfo) {
+
+    if (!CFGInfo->showHeatColors())
+      return "";
+
+    uint64_t Freq = CFGInfo->getFreq(Node);
+    std::string Color = getHeatColor(Freq, CFGInfo->getMaxFreq());
+    std::string EdgeColor = (Freq <= (CFGInfo->getMaxFreq() / 2))
+                                ? (getHeatColor(0))
+                                : (getHeatColor(1));
+
+    std::string Attrs = "color=\"" + EdgeColor + "ff\", style=filled," +
+                        " fillcolor=\"" + Color + "70\"";
+    return Attrs;
+  }
+  bool isNodeHidden(const BasicBlock *Node, const DOTFuncInfo *CFGInfo);
+  void computeHiddenNodes(const Function *F);
 };
 } // End llvm namespace
 
 namespace llvm {
-  class FunctionPass;
-  FunctionPass *createCFGPrinterLegacyPassPass ();
-  FunctionPass *createCFGOnlyPrinterLegacyPassPass ();
+class FunctionPass;
+FunctionPass *createCFGPrinterLegacyPassPass();
+FunctionPass *createCFGOnlyPrinterLegacyPassPass();
 } // End llvm namespace
 
 #endif
diff --git a/linux-x64/clang/include/llvm/Analysis/CFLAndersAliasAnalysis.h b/linux-x64/clang/include/llvm/Analysis/CFLAndersAliasAnalysis.h
index 7c8b42b..5f5e52a 100644
--- a/linux-x64/clang/include/llvm/Analysis/CFLAndersAliasAnalysis.h
+++ b/linux-x64/clang/include/llvm/Analysis/CFLAndersAliasAnalysis.h
@@ -41,7 +41,8 @@
   class FunctionInfo;
 
 public:
-  explicit CFLAndersAAResult(const TargetLibraryInfo &TLI);
+  explicit CFLAndersAAResult(
+      std::function<const TargetLibraryInfo &(Function &F)> GetTLI);
   CFLAndersAAResult(CFLAndersAAResult &&RHS);
   ~CFLAndersAAResult();
 
@@ -74,7 +75,7 @@
   /// Build summary for a given function
   FunctionInfo buildInfoFrom(const Function &);
 
-  const TargetLibraryInfo &TLI;
+  std::function<const TargetLibraryInfo &(Function &F)> GetTLI;
 
   /// Cached mapping of Functions to their StratifiedSets.
   /// If a function's sets are currently being built, it is marked
diff --git a/linux-x64/clang/include/llvm/Analysis/CFLSteensAliasAnalysis.h b/linux-x64/clang/include/llvm/Analysis/CFLSteensAliasAnalysis.h
index cc7a47c..1353216 100644
--- a/linux-x64/clang/include/llvm/Analysis/CFLSteensAliasAnalysis.h
+++ b/linux-x64/clang/include/llvm/Analysis/CFLSteensAliasAnalysis.h
@@ -42,7 +42,8 @@
   class FunctionInfo;
 
 public:
-  explicit CFLSteensAAResult(const TargetLibraryInfo &TLI);
+  explicit CFLSteensAAResult(
+      std::function<const TargetLibraryInfo &(Function &)> GetTLI);
   CFLSteensAAResult(CFLSteensAAResult &&Arg);
   ~CFLSteensAAResult();
 
@@ -90,7 +91,7 @@
   }
 
 private:
-  const TargetLibraryInfo &TLI;
+  std::function<const TargetLibraryInfo &(Function &)> GetTLI;
 
   /// Cached mapping of Functions to their StratifiedSets.
   /// If a function's sets are currently being built, it is marked
diff --git a/linux-x64/clang/include/llvm/Analysis/CGSCCPassManager.h b/linux-x64/clang/include/llvm/Analysis/CGSCCPassManager.h
index 8af5fb8..985424a 100644
--- a/linux-x64/clang/include/llvm/Analysis/CGSCCPassManager.h
+++ b/linux-x64/clang/include/llvm/Analysis/CGSCCPassManager.h
@@ -88,13 +88,14 @@
 #ifndef LLVM_ANALYSIS_CGSCCPASSMANAGER_H
 #define LLVM_ANALYSIS_CGSCCPASSMANAGER_H
 
+#include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseSet.h"
+#include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/PriorityWorklist.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Analysis/LazyCallGraph.h"
-#include "llvm/IR/CallSite.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/InstIterator.h"
 #include "llvm/IR/PassManager.h"
@@ -314,6 +315,16 @@
   /// for a better technique.
   SmallDenseSet<std::pair<LazyCallGraph::Node *, LazyCallGraph::SCC *>, 4>
       &InlinedInternalEdges;
+
+  /// Weak VHs to keep track of indirect calls for the purposes of detecting
+  /// devirtualization.
+  ///
+  /// This is a map to avoid having duplicate entries. If a Value is
+  /// deallocated, its corresponding WeakTrackingVH will be nulled out. When
+  /// checking if a Value is in the map or not, also check if the corresponding
+  /// WeakTrackingVH is null to avoid issues with a new Value sharing the same
+  /// address as a deallocated one.
+  SmallMapVector<Value *, WeakTrackingVH, 16> IndirectVHs;
 };
 
 /// The core module pass which does a post-order walk of the SCCs and
@@ -325,18 +336,15 @@
 /// \c CGSCCAnalysisManagerModuleProxy analysis prior to running the CGSCC
 /// pass over the module to enable a \c FunctionAnalysisManager to be used
 /// within this run safely.
-template <typename CGSCCPassT>
 class ModuleToPostOrderCGSCCPassAdaptor
-    : public PassInfoMixin<ModuleToPostOrderCGSCCPassAdaptor<CGSCCPassT>> {
+    : public PassInfoMixin<ModuleToPostOrderCGSCCPassAdaptor> {
 public:
-  explicit ModuleToPostOrderCGSCCPassAdaptor(CGSCCPassT Pass)
-      : Pass(std::move(Pass)) {}
+  using PassConceptT =
+      detail::PassConcept<LazyCallGraph::SCC, CGSCCAnalysisManager,
+                          LazyCallGraph &, CGSCCUpdateResult &>;
 
-  // We have to explicitly define all the special member functions because MSVC
-  // refuses to generate them.
-  ModuleToPostOrderCGSCCPassAdaptor(
-      const ModuleToPostOrderCGSCCPassAdaptor &Arg)
-      : Pass(Arg.Pass) {}
+  explicit ModuleToPostOrderCGSCCPassAdaptor(std::unique_ptr<PassConceptT> Pass)
+      : Pass(std::move(Pass)) {}
 
   ModuleToPostOrderCGSCCPassAdaptor(ModuleToPostOrderCGSCCPassAdaptor &&Arg)
       : Pass(std::move(Arg.Pass)) {}
@@ -355,16 +363,22 @@
   /// Runs the CGSCC pass across every SCC in the module.
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
 
+  static bool isRequired() { return true; }
+
 private:
-  CGSCCPassT Pass;
+  std::unique_ptr<PassConceptT> Pass;
 };
 
 /// A function to deduce a function pass type and wrap it in the
 /// templated adaptor.
 template <typename CGSCCPassT>
-ModuleToPostOrderCGSCCPassAdaptor<CGSCCPassT>
+ModuleToPostOrderCGSCCPassAdaptor
 createModuleToPostOrderCGSCCPassAdaptor(CGSCCPassT Pass) {
-  return ModuleToPostOrderCGSCCPassAdaptor<CGSCCPassT>(std::move(Pass));
+  using PassModelT = detail::PassModel<LazyCallGraph::SCC, CGSCCPassT,
+                                       PreservedAnalyses, CGSCCAnalysisManager,
+                                       LazyCallGraph &, CGSCCUpdateResult &>;
+  return ModuleToPostOrderCGSCCPassAdaptor(
+      std::make_unique<PassModelT>(std::move(Pass)));
 }
 
 /// A proxy from a \c FunctionAnalysisManager to an \c SCC.
@@ -380,10 +394,15 @@
 public:
   class Result {
   public:
+    explicit Result() : FAM(nullptr) {}
     explicit Result(FunctionAnalysisManager &FAM) : FAM(&FAM) {}
 
+    void updateFAM(FunctionAnalysisManager &FAM) { this->FAM = &FAM; }
     /// Accessor for the analysis manager.
-    FunctionAnalysisManager &getManager() { return *FAM; }
+    FunctionAnalysisManager &getManager() {
+      assert(FAM);
+      return *FAM;
+    }
 
     bool invalidate(LazyCallGraph::SCC &C, const PreservedAnalyses &PA,
                     CGSCCAnalysisManager::Invalidator &Inv);
@@ -415,7 +434,19 @@
 /// update result struct for the overall CGSCC walk.
 LazyCallGraph::SCC &updateCGAndAnalysisManagerForFunctionPass(
     LazyCallGraph &G, LazyCallGraph::SCC &C, LazyCallGraph::Node &N,
-    CGSCCAnalysisManager &AM, CGSCCUpdateResult &UR);
+    CGSCCAnalysisManager &AM, CGSCCUpdateResult &UR,
+    FunctionAnalysisManager &FAM);
+
+/// Helper to update the call graph after running a CGSCC pass.
+///
+/// CGSCC passes can only mutate the call graph in specific ways. This
+/// routine provides a helper that updates the call graph in those ways
+/// including returning whether any changes were made and populating a CG
+/// update result struct for the overall CGSCC walk.
+LazyCallGraph::SCC &updateCGAndAnalysisManagerForCGSCCPass(
+    LazyCallGraph &G, LazyCallGraph::SCC &C, LazyCallGraph::Node &N,
+    CGSCCAnalysisManager &AM, CGSCCUpdateResult &UR,
+    FunctionAnalysisManager &FAM);
 
 /// Adaptor that maps from a SCC to its functions.
 ///
@@ -425,17 +456,13 @@
 /// \c FunctionAnalysisManagerCGSCCProxy analysis prior to running the function
 /// pass over the SCC to enable a \c FunctionAnalysisManager to be used
 /// within this run safely.
-template <typename FunctionPassT>
 class CGSCCToFunctionPassAdaptor
-    : public PassInfoMixin<CGSCCToFunctionPassAdaptor<FunctionPassT>> {
+    : public PassInfoMixin<CGSCCToFunctionPassAdaptor> {
 public:
-  explicit CGSCCToFunctionPassAdaptor(FunctionPassT Pass)
-      : Pass(std::move(Pass)) {}
+  using PassConceptT = detail::PassConcept<Function, FunctionAnalysisManager>;
 
-  // We have to explicitly define all the special member functions because MSVC
-  // refuses to generate them.
-  CGSCCToFunctionPassAdaptor(const CGSCCToFunctionPassAdaptor &Arg)
-      : Pass(Arg.Pass) {}
+  explicit CGSCCToFunctionPassAdaptor(std::unique_ptr<PassConceptT> Pass)
+      : Pass(std::move(Pass)) {}
 
   CGSCCToFunctionPassAdaptor(CGSCCToFunctionPassAdaptor &&Arg)
       : Pass(std::move(Arg.Pass)) {}
@@ -452,86 +479,24 @@
 
   /// Runs the function pass across every function in the module.
   PreservedAnalyses run(LazyCallGraph::SCC &C, CGSCCAnalysisManager &AM,
-                        LazyCallGraph &CG, CGSCCUpdateResult &UR) {
-    // Setup the function analysis manager from its proxy.
-    FunctionAnalysisManager &FAM =
-        AM.getResult<FunctionAnalysisManagerCGSCCProxy>(C, CG).getManager();
+                        LazyCallGraph &CG, CGSCCUpdateResult &UR);
 
-    SmallVector<LazyCallGraph::Node *, 4> Nodes;
-    for (LazyCallGraph::Node &N : C)
-      Nodes.push_back(&N);
-
-    // The SCC may get split while we are optimizing functions due to deleting
-    // edges. If this happens, the current SCC can shift, so keep track of
-    // a pointer we can overwrite.
-    LazyCallGraph::SCC *CurrentC = &C;
-
-    LLVM_DEBUG(dbgs() << "Running function passes across an SCC: " << C
-                      << "\n");
-
-    PreservedAnalyses PA = PreservedAnalyses::all();
-    for (LazyCallGraph::Node *N : Nodes) {
-      // Skip nodes from other SCCs. These may have been split out during
-      // processing. We'll eventually visit those SCCs and pick up the nodes
-      // there.
-      if (CG.lookupSCC(*N) != CurrentC)
-        continue;
-
-      Function &F = N->getFunction();
-
-      PassInstrumentation PI = FAM.getResult<PassInstrumentationAnalysis>(F);
-      if (!PI.runBeforePass<Function>(Pass, F))
-        continue;
-
-      PreservedAnalyses PassPA = Pass.run(F, FAM);
-
-      PI.runAfterPass<Function>(Pass, F);
-
-      // We know that the function pass couldn't have invalidated any other
-      // function's analyses (that's the contract of a function pass), so
-      // directly handle the function analysis manager's invalidation here.
-      FAM.invalidate(F, PassPA);
-
-      // Then intersect the preserved set so that invalidation of module
-      // analyses will eventually occur when the module pass completes.
-      PA.intersect(std::move(PassPA));
-
-      // If the call graph hasn't been preserved, update it based on this
-      // function pass. This may also update the current SCC to point to
-      // a smaller, more refined SCC.
-      auto PAC = PA.getChecker<LazyCallGraphAnalysis>();
-      if (!PAC.preserved() && !PAC.preservedSet<AllAnalysesOn<Module>>()) {
-        CurrentC = &updateCGAndAnalysisManagerForFunctionPass(CG, *CurrentC, *N,
-                                                              AM, UR);
-        assert(
-            CG.lookupSCC(*N) == CurrentC &&
-            "Current SCC not updated to the SCC containing the current node!");
-      }
-    }
-
-    // By definition we preserve the proxy. And we preserve all analyses on
-    // Functions. This precludes *any* invalidation of function analyses by the
-    // proxy, but that's OK because we've taken care to invalidate analyses in
-    // the function analysis manager incrementally above.
-    PA.preserveSet<AllAnalysesOn<Function>>();
-    PA.preserve<FunctionAnalysisManagerCGSCCProxy>();
-
-    // We've also ensured that we updated the call graph along the way.
-    PA.preserve<LazyCallGraphAnalysis>();
-
-    return PA;
-  }
+  static bool isRequired() { return true; }
 
 private:
-  FunctionPassT Pass;
+  std::unique_ptr<PassConceptT> Pass;
 };
 
 /// A function to deduce a function pass type and wrap it in the
 /// templated adaptor.
 template <typename FunctionPassT>
-CGSCCToFunctionPassAdaptor<FunctionPassT>
+CGSCCToFunctionPassAdaptor
 createCGSCCToFunctionPassAdaptor(FunctionPassT Pass) {
-  return CGSCCToFunctionPassAdaptor<FunctionPassT>(std::move(Pass));
+  using PassModelT =
+      detail::PassModel<Function, FunctionPassT, PreservedAnalyses,
+                        FunctionAnalysisManager>;
+  return CGSCCToFunctionPassAdaptor(
+      std::make_unique<PassModelT>(std::move(Pass)));
 }
 
 /// A helper that repeats an SCC pass each time an indirect call is refined to
@@ -548,379 +513,36 @@
 /// This repetition has the potential to be very large however, as each one
 /// might refine a single call site. As a consequence, in practice we use an
 /// upper bound on the number of repetitions to limit things.
-template <typename PassT>
-class DevirtSCCRepeatedPass
-    : public PassInfoMixin<DevirtSCCRepeatedPass<PassT>> {
+class DevirtSCCRepeatedPass : public PassInfoMixin<DevirtSCCRepeatedPass> {
 public:
-  explicit DevirtSCCRepeatedPass(PassT Pass, int MaxIterations)
+  using PassConceptT =
+      detail::PassConcept<LazyCallGraph::SCC, CGSCCAnalysisManager,
+                          LazyCallGraph &, CGSCCUpdateResult &>;
+
+  explicit DevirtSCCRepeatedPass(std::unique_ptr<PassConceptT> Pass,
+                                 int MaxIterations)
       : Pass(std::move(Pass)), MaxIterations(MaxIterations) {}
 
   /// Runs the wrapped pass up to \c MaxIterations on the SCC, iterating
   /// whenever an indirect call is refined.
   PreservedAnalyses run(LazyCallGraph::SCC &InitialC, CGSCCAnalysisManager &AM,
-                        LazyCallGraph &CG, CGSCCUpdateResult &UR) {
-    PreservedAnalyses PA = PreservedAnalyses::all();
-    PassInstrumentation PI =
-        AM.getResult<PassInstrumentationAnalysis>(InitialC, CG);
-
-    // The SCC may be refined while we are running passes over it, so set up
-    // a pointer that we can update.
-    LazyCallGraph::SCC *C = &InitialC;
-
-    // Collect value handles for all of the indirect call sites.
-    SmallVector<WeakTrackingVH, 8> CallHandles;
-
-    // Struct to track the counts of direct and indirect calls in each function
-    // of the SCC.
-    struct CallCount {
-      int Direct;
-      int Indirect;
-    };
-
-    // Put value handles on all of the indirect calls and return the number of
-    // direct calls for each function in the SCC.
-    auto ScanSCC = [](LazyCallGraph::SCC &C,
-                      SmallVectorImpl<WeakTrackingVH> &CallHandles) {
-      assert(CallHandles.empty() && "Must start with a clear set of handles.");
-
-      SmallVector<CallCount, 4> CallCounts;
-      for (LazyCallGraph::Node &N : C) {
-        CallCounts.push_back({0, 0});
-        CallCount &Count = CallCounts.back();
-        for (Instruction &I : instructions(N.getFunction()))
-          if (auto CS = CallSite(&I)) {
-            if (CS.getCalledFunction()) {
-              ++Count.Direct;
-            } else {
-              ++Count.Indirect;
-              CallHandles.push_back(WeakTrackingVH(&I));
-            }
-          }
-      }
-
-      return CallCounts;
-    };
-
-    // Populate the initial call handles and get the initial call counts.
-    auto CallCounts = ScanSCC(*C, CallHandles);
-
-    for (int Iteration = 0;; ++Iteration) {
-
-      if (!PI.runBeforePass<LazyCallGraph::SCC>(Pass, *C))
-        continue;
-
-      PreservedAnalyses PassPA = Pass.run(*C, AM, CG, UR);
-
-      if (UR.InvalidatedSCCs.count(C))
-        PI.runAfterPassInvalidated<LazyCallGraph::SCC>(Pass);
-      else
-        PI.runAfterPass<LazyCallGraph::SCC>(Pass, *C);
-
-      // If the SCC structure has changed, bail immediately and let the outer
-      // CGSCC layer handle any iteration to reflect the refined structure.
-      if (UR.UpdatedC && UR.UpdatedC != C) {
-        PA.intersect(std::move(PassPA));
-        break;
-      }
-
-      // Check that we didn't miss any update scenario.
-      assert(!UR.InvalidatedSCCs.count(C) && "Processing an invalid SCC!");
-      assert(C->begin() != C->end() && "Cannot have an empty SCC!");
-      assert((int)CallCounts.size() == C->size() &&
-             "Cannot have changed the size of the SCC!");
-
-      // Check whether any of the handles were devirtualized.
-      auto IsDevirtualizedHandle = [&](WeakTrackingVH &CallH) {
-        if (!CallH)
-          return false;
-        auto CS = CallSite(CallH);
-        if (!CS)
-          return false;
-
-        // If the call is still indirect, leave it alone.
-        Function *F = CS.getCalledFunction();
-        if (!F)
-          return false;
-
-        LLVM_DEBUG(dbgs() << "Found devirutalized call from "
-                          << CS.getParent()->getParent()->getName() << " to "
-                          << F->getName() << "\n");
-
-        // We now have a direct call where previously we had an indirect call,
-        // so iterate to process this devirtualization site.
-        return true;
-      };
-      bool Devirt = llvm::any_of(CallHandles, IsDevirtualizedHandle);
-
-      // Rescan to build up a new set of handles and count how many direct
-      // calls remain. If we decide to iterate, this also sets up the input to
-      // the next iteration.
-      CallHandles.clear();
-      auto NewCallCounts = ScanSCC(*C, CallHandles);
-
-      // If we haven't found an explicit devirtualization already see if we
-      // have decreased the number of indirect calls and increased the number
-      // of direct calls for any function in the SCC. This can be fooled by all
-      // manner of transformations such as DCE and other things, but seems to
-      // work well in practice.
-      if (!Devirt)
-        for (int i = 0, Size = C->size(); i < Size; ++i)
-          if (CallCounts[i].Indirect > NewCallCounts[i].Indirect &&
-              CallCounts[i].Direct < NewCallCounts[i].Direct) {
-            Devirt = true;
-            break;
-          }
-
-      if (!Devirt) {
-        PA.intersect(std::move(PassPA));
-        break;
-      }
-
-      // Otherwise, if we've already hit our max, we're done.
-      if (Iteration >= MaxIterations) {
-        LLVM_DEBUG(
-            dbgs() << "Found another devirtualization after hitting the max "
-                      "number of repetitions ("
-                   << MaxIterations << ") on SCC: " << *C << "\n");
-        PA.intersect(std::move(PassPA));
-        break;
-      }
-
-      LLVM_DEBUG(
-          dbgs()
-          << "Repeating an SCC pass after finding a devirtualization in: " << *C
-          << "\n");
-
-      // Move over the new call counts in preparation for iterating.
-      CallCounts = std::move(NewCallCounts);
-
-      // Update the analysis manager with each run and intersect the total set
-      // of preserved analyses so we're ready to iterate.
-      AM.invalidate(*C, PassPA);
-      PA.intersect(std::move(PassPA));
-    }
-
-    // Note that we don't add any preserved entries here unlike a more normal
-    // "pass manager" because we only handle invalidation *between* iterations,
-    // not after the last iteration.
-    return PA;
-  }
+                        LazyCallGraph &CG, CGSCCUpdateResult &UR);
 
 private:
-  PassT Pass;
+  std::unique_ptr<PassConceptT> Pass;
   int MaxIterations;
 };
 
 /// A function to deduce a function pass type and wrap it in the
 /// templated adaptor.
-template <typename PassT>
-DevirtSCCRepeatedPass<PassT> createDevirtSCCRepeatedPass(PassT Pass,
-                                                         int MaxIterations) {
-  return DevirtSCCRepeatedPass<PassT>(std::move(Pass), MaxIterations);
-}
-
-// Out-of-line implementation details for templates below this point.
-
 template <typename CGSCCPassT>
-PreservedAnalyses
-ModuleToPostOrderCGSCCPassAdaptor<CGSCCPassT>::run(Module &M,
-                                                   ModuleAnalysisManager &AM) {
-  // Setup the CGSCC analysis manager from its proxy.
-  CGSCCAnalysisManager &CGAM =
-      AM.getResult<CGSCCAnalysisManagerModuleProxy>(M).getManager();
-
-  // Get the call graph for this module.
-  LazyCallGraph &CG = AM.getResult<LazyCallGraphAnalysis>(M);
-
-  // We keep worklists to allow us to push more work onto the pass manager as
-  // the passes are run.
-  SmallPriorityWorklist<LazyCallGraph::RefSCC *, 1> RCWorklist;
-  SmallPriorityWorklist<LazyCallGraph::SCC *, 1> CWorklist;
-
-  // Keep sets for invalidated SCCs and RefSCCs that should be skipped when
-  // iterating off the worklists.
-  SmallPtrSet<LazyCallGraph::RefSCC *, 4> InvalidRefSCCSet;
-  SmallPtrSet<LazyCallGraph::SCC *, 4> InvalidSCCSet;
-
-  SmallDenseSet<std::pair<LazyCallGraph::Node *, LazyCallGraph::SCC *>, 4>
-      InlinedInternalEdges;
-
-  CGSCCUpdateResult UR = {
-      RCWorklist, CWorklist, InvalidRefSCCSet,         InvalidSCCSet,
-      nullptr,    nullptr,   PreservedAnalyses::all(), InlinedInternalEdges};
-
-  // Request PassInstrumentation from analysis manager, will use it to run
-  // instrumenting callbacks for the passes later.
-  PassInstrumentation PI = AM.getResult<PassInstrumentationAnalysis>(M);
-
-  PreservedAnalyses PA = PreservedAnalyses::all();
-  CG.buildRefSCCs();
-  for (auto RCI = CG.postorder_ref_scc_begin(),
-            RCE = CG.postorder_ref_scc_end();
-       RCI != RCE;) {
-    assert(RCWorklist.empty() &&
-           "Should always start with an empty RefSCC worklist");
-    // The postorder_ref_sccs range we are walking is lazily constructed, so
-    // we only push the first one onto the worklist. The worklist allows us
-    // to capture *new* RefSCCs created during transformations.
-    //
-    // We really want to form RefSCCs lazily because that makes them cheaper
-    // to update as the program is simplified and allows us to have greater
-    // cache locality as forming a RefSCC touches all the parts of all the
-    // functions within that RefSCC.
-    //
-    // We also eagerly increment the iterator to the next position because
-    // the CGSCC passes below may delete the current RefSCC.
-    RCWorklist.insert(&*RCI++);
-
-    do {
-      LazyCallGraph::RefSCC *RC = RCWorklist.pop_back_val();
-      if (InvalidRefSCCSet.count(RC)) {
-        LLVM_DEBUG(dbgs() << "Skipping an invalid RefSCC...\n");
-        continue;
-      }
-
-      assert(CWorklist.empty() &&
-             "Should always start with an empty SCC worklist");
-
-      LLVM_DEBUG(dbgs() << "Running an SCC pass across the RefSCC: " << *RC
-                        << "\n");
-
-      // Push the initial SCCs in reverse post-order as we'll pop off the
-      // back and so see this in post-order.
-      for (LazyCallGraph::SCC &C : llvm::reverse(*RC))
-        CWorklist.insert(&C);
-
-      do {
-        LazyCallGraph::SCC *C = CWorklist.pop_back_val();
-        // Due to call graph mutations, we may have invalid SCCs or SCCs from
-        // other RefSCCs in the worklist. The invalid ones are dead and the
-        // other RefSCCs should be queued above, so we just need to skip both
-        // scenarios here.
-        if (InvalidSCCSet.count(C)) {
-          LLVM_DEBUG(dbgs() << "Skipping an invalid SCC...\n");
-          continue;
-        }
-        if (&C->getOuterRefSCC() != RC) {
-          LLVM_DEBUG(dbgs() << "Skipping an SCC that is now part of some other "
-                               "RefSCC...\n");
-          continue;
-        }
-
-        // Ensure we can proxy analysis updates from from the CGSCC analysis
-        // manager into the Function analysis manager by getting a proxy here.
-        // FIXME: This seems like a bit of a hack. We should find a cleaner
-        // or more costructive way to ensure this happens.
-        (void)CGAM.getResult<FunctionAnalysisManagerCGSCCProxy>(*C, CG);
-
-        // Each time we visit a new SCC pulled off the worklist,
-        // a transformation of a child SCC may have also modified this parent
-        // and invalidated analyses. So we invalidate using the update record's
-        // cross-SCC preserved set. This preserved set is intersected by any
-        // CGSCC pass that handles invalidation (primarily pass managers) prior
-        // to marking its SCC as preserved. That lets us track everything that
-        // might need invalidation across SCCs without excessive invalidations
-        // on a single SCC.
-        //
-        // This essentially allows SCC passes to freely invalidate analyses
-        // of any ancestor SCC. If this becomes detrimental to successfully
-        // caching analyses, we could force each SCC pass to manually
-        // invalidate the analyses for any SCCs other than themselves which
-        // are mutated. However, that seems to lose the robustness of the
-        // pass-manager driven invalidation scheme.
-        //
-        // FIXME: This is redundant in one case -- the top of the worklist may
-        // *also* be the same SCC we just ran over (and invalidated for). In
-        // that case, we'll end up doing a redundant invalidation here as
-        // a consequence.
-        CGAM.invalidate(*C, UR.CrossSCCPA);
-
-        do {
-          // Check that we didn't miss any update scenario.
-          assert(!InvalidSCCSet.count(C) && "Processing an invalid SCC!");
-          assert(C->begin() != C->end() && "Cannot have an empty SCC!");
-          assert(&C->getOuterRefSCC() == RC &&
-                 "Processing an SCC in a different RefSCC!");
-
-          UR.UpdatedRC = nullptr;
-          UR.UpdatedC = nullptr;
-
-          // Check the PassInstrumentation's BeforePass callbacks before
-          // running the pass, skip its execution completely if asked to
-          // (callback returns false).
-          if (!PI.runBeforePass<LazyCallGraph::SCC>(Pass, *C))
-            continue;
-
-          PreservedAnalyses PassPA = Pass.run(*C, CGAM, CG, UR);
-
-          if (UR.InvalidatedSCCs.count(C))
-            PI.runAfterPassInvalidated<LazyCallGraph::SCC>(Pass);
-          else
-            PI.runAfterPass<LazyCallGraph::SCC>(Pass, *C);
-
-          // Update the SCC and RefSCC if necessary.
-          C = UR.UpdatedC ? UR.UpdatedC : C;
-          RC = UR.UpdatedRC ? UR.UpdatedRC : RC;
-
-          // If the CGSCC pass wasn't able to provide a valid updated SCC,
-          // the current SCC may simply need to be skipped if invalid.
-          if (UR.InvalidatedSCCs.count(C)) {
-            LLVM_DEBUG(dbgs() << "Skipping invalidated root or island SCC!\n");
-            break;
-          }
-          // Check that we didn't miss any update scenario.
-          assert(C->begin() != C->end() && "Cannot have an empty SCC!");
-
-          // We handle invalidating the CGSCC analysis manager's information
-          // for the (potentially updated) SCC here. Note that any other SCCs
-          // whose structure has changed should have been invalidated by
-          // whatever was updating the call graph. This SCC gets invalidated
-          // late as it contains the nodes that were actively being
-          // processed.
-          CGAM.invalidate(*C, PassPA);
-
-          // Then intersect the preserved set so that invalidation of module
-          // analyses will eventually occur when the module pass completes.
-          // Also intersect with the cross-SCC preserved set to capture any
-          // cross-SCC invalidation.
-          UR.CrossSCCPA.intersect(PassPA);
-          PA.intersect(std::move(PassPA));
-
-          // The pass may have restructured the call graph and refined the
-          // current SCC and/or RefSCC. We need to update our current SCC and
-          // RefSCC pointers to follow these. Also, when the current SCC is
-          // refined, re-run the SCC pass over the newly refined SCC in order
-          // to observe the most precise SCC model available. This inherently
-          // cannot cycle excessively as it only happens when we split SCCs
-          // apart, at most converging on a DAG of single nodes.
-          // FIXME: If we ever start having RefSCC passes, we'll want to
-          // iterate there too.
-          if (UR.UpdatedC)
-            LLVM_DEBUG(dbgs()
-                       << "Re-running SCC passes after a refinement of the "
-                          "current SCC: "
-                       << *UR.UpdatedC << "\n");
-
-          // Note that both `C` and `RC` may at this point refer to deleted,
-          // invalid SCC and RefSCCs respectively. But we will short circuit
-          // the processing when we check them in the loop above.
-        } while (UR.UpdatedC);
-      } while (!CWorklist.empty());
-
-      // We only need to keep internal inlined edge information within
-      // a RefSCC, clear it to save on space and let the next time we visit
-      // any of these functions have a fresh start.
-      InlinedInternalEdges.clear();
-    } while (!RCWorklist.empty());
-  }
-
-  // By definition we preserve the call garph, all SCC analyses, and the
-  // analysis proxies by handling them above and in any nested pass managers.
-  PA.preserveSet<AllAnalysesOn<LazyCallGraph::SCC>>();
-  PA.preserve<LazyCallGraphAnalysis>();
-  PA.preserve<CGSCCAnalysisManagerModuleProxy>();
-  PA.preserve<FunctionAnalysisManagerModuleProxy>();
-  return PA;
+DevirtSCCRepeatedPass createDevirtSCCRepeatedPass(CGSCCPassT Pass,
+                                                  int MaxIterations) {
+  using PassModelT = detail::PassModel<LazyCallGraph::SCC, CGSCCPassT,
+                                       PreservedAnalyses, CGSCCAnalysisManager,
+                                       LazyCallGraph &, CGSCCUpdateResult &>;
+  return DevirtSCCRepeatedPass(std::make_unique<PassModelT>(std::move(Pass)),
+                               MaxIterations);
 }
 
 // Clear out the debug logging macro.
diff --git a/linux-x64/clang/include/llvm/Analysis/CallGraph.h b/linux-x64/clang/include/llvm/Analysis/CallGraph.h
index 7a10183..4da448c 100644
--- a/linux-x64/clang/include/llvm/Analysis/CallGraph.h
+++ b/linux-x64/clang/include/llvm/Analysis/CallGraph.h
@@ -87,17 +87,6 @@
   /// or calling an external function.
   std::unique_ptr<CallGraphNode> CallsExternalNode;
 
-  /// Replace the function represented by this node by another.
-  ///
-  /// This does not rescan the body of the function, so it is suitable when
-  /// splicing the body of one function to another while also updating all
-  /// callers from the old function to the new.
-  void spliceFunction(const Function *From, const Function *To);
-
-  /// Add a function to the call graph, and link the node to all of the
-  /// functions that it calls.
-  void addToCallGraph(Function *F);
-
 public:
   explicit CallGraph(Module &M);
   CallGraph(CallGraph &&Arg);
@@ -112,6 +101,9 @@
   /// Returns the module the call graph corresponds to.
   Module &getModule() const { return M; }
 
+  bool invalidate(Module &, const PreservedAnalyses &PA,
+                  ModuleAnalysisManager::Invalidator &);
+
   inline iterator begin() { return FunctionMap.begin(); }
   inline iterator end() { return FunctionMap.end(); }
   inline const_iterator begin() const { return FunctionMap.begin(); }
@@ -139,6 +131,10 @@
     return CallsExternalNode.get();
   }
 
+  /// Old node has been deleted, and New is to be used in its place, update the
+  /// ExternalCallingNode.
+  void ReplaceExternalCallEdge(CallGraphNode *Old, CallGraphNode *New);
+
   //===---------------------------------------------------------------------
   // Functions to keep a call graph up to date with a function that has been
   // modified.
@@ -155,6 +151,13 @@
   /// Similar to operator[], but this will insert a new CallGraphNode for
   /// \c F if one does not already exist.
   CallGraphNode *getOrInsertFunction(const Function *F);
+
+  /// Populate \p CGN based on the calls inside the associated function.
+  void populateCallGraphNode(CallGraphNode *CGN);
+
+  /// Add a function to the call graph, and link the node to all of the
+  /// functions that it calls.
+  void addToCallGraph(Function *F);
 };
 
 /// A node in the call graph for a module.
@@ -165,13 +168,21 @@
 public:
   /// A pair of the calling instruction (a call or invoke)
   /// and the call graph node being called.
-  using CallRecord = std::pair<WeakTrackingVH, CallGraphNode *>;
+  /// Call graph node may have two types of call records which represent an edge
+  /// in the call graph - reference or a call edge. Reference edges are not
+  /// associated with any call instruction and are created with the first field
+  /// set to `None`, while real call edges have instruction address in this
+  /// field. Therefore, all real call edges are expected to have a value in the
+  /// first field and it is not supposed to be `nullptr`.
+  /// Reference edges, for example, are used for connecting broker function
+  /// caller to the callback function for callback call sites.
+  using CallRecord = std::pair<Optional<WeakTrackingVH>, CallGraphNode *>;
 
 public:
   using CalledFunctionsVector = std::vector<CallRecord>;
 
   /// Creates a node for the specified function.
-  inline CallGraphNode(Function *F) : F(F) {}
+  inline CallGraphNode(CallGraph *CG, Function *F) : CG(CG), F(F) {}
 
   CallGraphNode(const CallGraphNode &) = delete;
   CallGraphNode &operator=(const CallGraphNode &) = delete;
@@ -233,7 +244,8 @@
     assert(!Call || !Call->getCalledFunction() ||
            !Call->getCalledFunction()->isIntrinsic() ||
            !Intrinsic::isLeaf(Call->getCalledFunction()->getIntrinsicID()));
-    CalledFunctions.emplace_back(Call, M);
+    CalledFunctions.emplace_back(
+        Call ? Optional<WeakTrackingVH>(Call) : Optional<WeakTrackingVH>(), M);
     M->AddRef();
   }
 
@@ -269,6 +281,7 @@
 private:
   friend class CallGraph;
 
+  CallGraph *CG;
   Function *F;
 
   std::vector<CallRecord> CalledFunctions;
@@ -402,7 +415,7 @@
 // graphs by the generic graph algorithms.
 //
 
-// Provide graph traits for tranversing call graphs using standard graph
+// Provide graph traits for traversing call graphs using standard graph
 // traversals.
 template <> struct GraphTraits<CallGraphNode *> {
   using NodeRef = CallGraphNode *;
diff --git a/linux-x64/clang/include/llvm/Analysis/CallGraphSCCPass.h b/linux-x64/clang/include/llvm/Analysis/CallGraphSCCPass.h
index 1b5b7e2..d0d8160 100644
--- a/linux-x64/clang/include/llvm/Analysis/CallGraphSCCPass.h
+++ b/linux-x64/clang/include/llvm/Analysis/CallGraphSCCPass.h
@@ -103,6 +103,10 @@
   /// Old node has been deleted, and New is to be used in its place.
   void ReplaceNode(CallGraphNode *Old, CallGraphNode *New);
 
+  /// DeleteNode - This informs the SCC and the pass manager that the specified
+  /// Old node has been deleted.
+  void DeleteNode(CallGraphNode *Old);
+
   using iterator = std::vector<CallGraphNode *>::const_iterator;
 
   iterator begin() const { return Nodes.begin(); }
diff --git a/linux-x64/clang/include/llvm/Analysis/CaptureTracking.h b/linux-x64/clang/include/llvm/Analysis/CaptureTracking.h
index ca7abd3..9da5f18 100644
--- a/linux-x64/clang/include/llvm/Analysis/CaptureTracking.h
+++ b/linux-x64/clang/include/llvm/Analysis/CaptureTracking.h
@@ -13,21 +13,20 @@
 #ifndef LLVM_ANALYSIS_CAPTURETRACKING_H
 #define LLVM_ANALYSIS_CAPTURETRACKING_H
 
+#include "llvm/ADT/DenseMap.h"
+
 namespace llvm {
 
   class Value;
   class Use;
+  class DataLayout;
   class Instruction;
   class DominatorTree;
-  class OrderedBasicBlock;
 
-  /// The default value for MaxUsesToExplore argument. It's relatively small to
-  /// keep the cost of analysis reasonable for clients like BasicAliasAnalysis,
-  /// where the results can't be cached.
-  /// TODO: we should probably introduce a caching CaptureTracking analysis and
-  /// use it where possible. The caching version can use much higher limit or
-  /// don't have this cap at all.
-  unsigned constexpr DefaultMaxUsesToExplore = 20;
+  /// getDefaultMaxUsesToExploreForCaptureTracking - Return default value of
+  /// the maximal number of uses to explore before giving up. It is used by
+  /// PointerMayBeCaptured family analysis.
+  unsigned getDefaultMaxUsesToExploreForCaptureTracking();
 
   /// PointerMayBeCaptured - Return true if this pointer value may be captured
   /// by the enclosing function (which is required to exist).  This routine can
@@ -36,12 +35,12 @@
   /// counts as capturing it or not.  The boolean StoreCaptures specified
   /// whether storing the value (or part of it) into memory anywhere
   /// automatically counts as capturing it or not.
-  /// MaxUsesToExplore specifies how many uses should the analysis explore for
-  /// one value before giving up due too "too many uses".
-  bool PointerMayBeCaptured(const Value *V,
-                            bool ReturnCaptures,
+  /// MaxUsesToExplore specifies how many uses the analysis should explore for
+  /// one value before giving up due too "too many uses". If MaxUsesToExplore
+  /// is zero, a default value is assumed.
+  bool PointerMayBeCaptured(const Value *V, bool ReturnCaptures,
                             bool StoreCaptures,
-                            unsigned MaxUsesToExplore = DefaultMaxUsesToExplore);
+                            unsigned MaxUsesToExplore = 0);
 
   /// PointerMayBeCapturedBefore - Return true if this pointer value may be
   /// captured by the enclosing function (which is required to exist). If a
@@ -52,15 +51,14 @@
   /// it or not.  The boolean StoreCaptures specified whether storing the value
   /// (or part of it) into memory anywhere automatically counts as capturing it
   /// or not. Captures by the provided instruction are considered if the
-  /// final parameter is true. An ordered basic block in \p OBB could be used
-  /// to speed up capture-tracker queries.
-  /// MaxUsesToExplore specifies how many uses should the analysis explore for
-  /// one value before giving up due too "too many uses".
-  bool PointerMayBeCapturedBefore(const Value *V, bool ReturnCaptures,
-                                  bool StoreCaptures, const Instruction *I,
-                                  const DominatorTree *DT, bool IncludeI = false,
-                                  OrderedBasicBlock *OBB = nullptr,
-                                  unsigned MaxUsesToExplore = DefaultMaxUsesToExplore);
+  /// final parameter is true.
+  /// MaxUsesToExplore specifies how many uses the analysis should explore for
+  /// one value before giving up due too "too many uses". If MaxUsesToExplore
+  /// is zero, a default value is assumed.
+  bool PointerMayBeCapturedBefore(
+      const Value *V, bool ReturnCaptures, bool StoreCaptures,
+      const Instruction *I, const DominatorTree *DT, bool IncludeI = false,
+      unsigned MaxUsesToExplore = 0);
 
   /// This callback is used in conjunction with PointerMayBeCaptured. In
   /// addition to the interface here, you'll need to provide your own getters
@@ -83,15 +81,27 @@
     /// use U. Return true to stop the traversal or false to continue looking
     /// for more capturing instructions.
     virtual bool captured(const Use *U) = 0;
+
+    /// isDereferenceableOrNull - Overload to allow clients with additional
+    /// knowledge about pointer dereferenceability to provide it and thereby
+    /// avoid conservative responses when a pointer is compared to null.
+    virtual bool isDereferenceableOrNull(Value *O, const DataLayout &DL);
   };
 
   /// PointerMayBeCaptured - Visit the value and the values derived from it and
   /// find values which appear to be capturing the pointer value. This feeds
   /// results into and is controlled by the CaptureTracker object.
-  /// MaxUsesToExplore specifies how many uses should the analysis explore for
-  /// one value before giving up due too "too many uses".
+  /// MaxUsesToExplore specifies how many uses the analysis should explore for
+  /// one value before giving up due too "too many uses". If MaxUsesToExplore
+  /// is zero, a default value is assumed.
   void PointerMayBeCaptured(const Value *V, CaptureTracker *Tracker,
-                            unsigned MaxUsesToExplore = DefaultMaxUsesToExplore);
+                            unsigned MaxUsesToExplore = 0);
+
+  /// Returns true if the pointer is to a function-local object that never
+  /// escapes from the function.
+  bool isNonEscapingLocalObject(
+      const Value *V,
+      SmallDenseMap<const Value *, bool, 8> *IsCapturedCache = nullptr);
 } // end namespace llvm
 
 #endif
diff --git a/linux-x64/clang/include/llvm/Analysis/CodeMetrics.h b/linux-x64/clang/include/llvm/Analysis/CodeMetrics.h
index 1482b66..eab24c8 100644
--- a/linux-x64/clang/include/llvm/Analysis/CodeMetrics.h
+++ b/linux-x64/clang/include/llvm/Analysis/CodeMetrics.h
@@ -15,15 +15,13 @@
 #define LLVM_ANALYSIS_CODEMETRICS_H
 
 #include "llvm/ADT/DenseMap.h"
-#include "llvm/ADT/SmallPtrSet.h"
 
 namespace llvm {
 class AssumptionCache;
 class BasicBlock;
 class Loop;
 class Function;
-class Instruction;
-class DataLayout;
+template <class T> class SmallPtrSetImpl;
 class TargetTransformInfo;
 class Value;
 
diff --git a/linux-x64/clang/include/llvm/Analysis/ConstantFolding.h b/linux-x64/clang/include/llvm/Analysis/ConstantFolding.h
index 2385b6f..ef6e66b 100644
--- a/linux-x64/clang/include/llvm/Analysis/ConstantFolding.h
+++ b/linux-x64/clang/include/llvm/Analysis/ConstantFolding.h
@@ -25,7 +25,7 @@
 class CallBase;
 class Constant;
 class ConstantExpr;
-class ConstantVector;
+class DSOLocalEquivalent;
 class DataLayout;
 class Function;
 class GlobalValue;
@@ -35,8 +35,11 @@
 
 /// If this constant is a constant offset from a global, return the global and
 /// the constant. Because of constantexprs, this function is recursive.
+/// If the global is part of a dso_local_equivalent constant, return it through
+/// `Equiv` if it is provided.
 bool IsConstantOffsetFromGlobal(Constant *C, GlobalValue *&GV, APInt &Offset,
-                                const DataLayout &DL);
+                                const DataLayout &DL,
+                                DSOLocalEquivalent **DSOEquiv = nullptr);
 
 /// ConstantFoldInstruction - Try to constant fold the specified instruction.
 /// If successful, the constant result is returned, if not, null is returned.
@@ -46,9 +49,9 @@
 Constant *ConstantFoldInstruction(Instruction *I, const DataLayout &DL,
                                   const TargetLibraryInfo *TLI = nullptr);
 
-/// ConstantFoldConstant - Attempt to fold the constant using the
-/// specified DataLayout.
-/// If successful, the constant result is returned, if not, null is returned.
+/// ConstantFoldConstant - Fold the constant using the specified DataLayout.
+/// This function always returns a non-null constant: Either the folding result,
+/// or the original constant if further folding is not possible.
 Constant *ConstantFoldConstant(const Constant *C, const DataLayout &DL,
                                const TargetLibraryInfo *TLI = nullptr);
 
@@ -119,10 +122,11 @@
 Constant *ConstantFoldExtractElementInstruction(Constant *Val, Constant *Idx);
 
 /// Attempt to constant fold a shufflevector instruction with the
-/// specified operands and indices.  The constant result is returned if
-/// successful; if not, null is returned.
+/// specified operands and mask.  See class ShuffleVectorInst for a description
+/// of the mask representation. The constant result is returned if successful;
+/// if not, null is returned.
 Constant *ConstantFoldShuffleVectorInstruction(Constant *V1, Constant *V2,
-                                               Constant *Mask);
+                                               ArrayRef<int> Mask);
 
 /// ConstantFoldLoadFromConstPtr - Return the value that a load from C would
 /// produce if it is constant and determinable.  If this is not determinable,
diff --git a/linux-x64/clang/include/llvm/Analysis/ConstraintSystem.h b/linux-x64/clang/include/llvm/Analysis/ConstraintSystem.h
new file mode 100644
index 0000000..83c1fb4
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Analysis/ConstraintSystem.h
@@ -0,0 +1,88 @@
+//===- ConstraintSystem.h -  A system of linear constraints. --------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_ANALYSIS_CONSTRAINTSYSTEM_H
+#define LLVM_ANALYSIS_CONSTRAINTSYSTEM_H
+
+#include "llvm/ADT/APInt.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/SmallVector.h"
+
+#include <string>
+
+namespace llvm {
+
+class ConstraintSystem {
+  /// Current linear constraints in the system.
+  /// An entry of the form c0, c1, ... cn represents the following constraint:
+  ///   c0 >= v0 * c1 + .... + v{n-1} * cn
+  SmallVector<SmallVector<int64_t, 8>, 4> Constraints;
+
+  /// Current greatest common divisor for all coefficients in the system.
+  uint32_t GCD = 1;
+
+  // Eliminate constraints from the system using Fourier–Motzkin elimination.
+  bool eliminateUsingFM();
+
+  /// Print the constraints in the system, using \p Names as variable names.
+  void dump(ArrayRef<std::string> Names) const;
+
+  /// Print the constraints in the system, using x0...xn as variable names.
+  void dump() const;
+
+  /// Returns true if there may be a solution for the constraints in the system.
+  bool mayHaveSolutionImpl();
+
+public:
+  bool addVariableRow(const SmallVector<int64_t, 8> &R) {
+    assert(Constraints.empty() || R.size() == Constraints.back().size());
+    // If all variable coefficients are 0, the constraint does not provide any
+    // usable information.
+    if (all_of(makeArrayRef(R).drop_front(1), [](int64_t C) { return C == 0; }))
+      return false;
+
+    for (const auto &C : R) {
+      auto A = std::abs(C);
+      GCD = APIntOps::GreatestCommonDivisor({32, (uint32_t)A}, {32, GCD})
+                .getZExtValue();
+    }
+    Constraints.push_back(R);
+    return true;
+  }
+
+  bool addVariableRowFill(const SmallVector<int64_t, 8> &R) {
+    for (auto &CR : Constraints) {
+      while (CR.size() != R.size())
+        CR.push_back(0);
+    }
+    return addVariableRow(R);
+  }
+
+  /// Returns true if there may be a solution for the constraints in the system.
+  bool mayHaveSolution();
+
+  static SmallVector<int64_t, 8> negate(SmallVector<int64_t, 8> R) {
+    // The negated constraint R is obtained by multiplying by -1 and adding 1 to
+    // the constant.
+    R[0] += 1;
+    for (auto &C : R)
+      C *= -1;
+    return R;
+  }
+
+  bool isConditionImplied(SmallVector<int64_t, 8> R);
+
+  void popLastConstraint() { Constraints.pop_back(); }
+
+  /// Returns the number of rows in the constraint system.
+  unsigned size() const { return Constraints.size(); }
+};
+} // namespace llvm
+
+#endif // LLVM_ANALYSIS_CONSTRAINTSYSTEM_H
diff --git a/linux-x64/clang/include/llvm/Analysis/DDG.h b/linux-x64/clang/include/llvm/Analysis/DDG.h
new file mode 100644
index 0000000..e3bef33
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Analysis/DDG.h
@@ -0,0 +1,581 @@
+//===- llvm/Analysis/DDG.h --------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the Data-Dependence Graph (DDG).
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_ANALYSIS_DDG_H
+#define LLVM_ANALYSIS_DDG_H
+
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/DirectedGraph.h"
+#include "llvm/Analysis/DependenceAnalysis.h"
+#include "llvm/Analysis/DependenceGraphBuilder.h"
+#include "llvm/Analysis/LoopAnalysisManager.h"
+#include "llvm/IR/Instructions.h"
+
+namespace llvm {
+class DDGNode;
+class DDGEdge;
+using DDGNodeBase = DGNode<DDGNode, DDGEdge>;
+using DDGEdgeBase = DGEdge<DDGNode, DDGEdge>;
+using DDGBase = DirectedGraph<DDGNode, DDGEdge>;
+class LPMUpdater;
+
+/// Data Dependence Graph Node
+/// The graph can represent the following types of nodes:
+/// 1. Single instruction node containing just one instruction.
+/// 2. Multiple instruction node where two or more instructions from
+///    the same basic block are merged into one node.
+/// 3. Pi-block node which is a group of other DDG nodes that are part of a
+///    strongly-connected component of the graph.
+///    A pi-block node contains more than one single or multiple instruction
+///    nodes. The root node cannot be part of a pi-block.
+/// 4. Root node is a special node that connects to all components such that
+///    there is always a path from it to any node in the graph.
+class DDGNode : public DDGNodeBase {
+public:
+  using InstructionListType = SmallVectorImpl<Instruction *>;
+
+  enum class NodeKind {
+    Unknown,
+    SingleInstruction,
+    MultiInstruction,
+    PiBlock,
+    Root,
+  };
+
+  DDGNode() = delete;
+  DDGNode(const NodeKind K) : DDGNodeBase(), Kind(K) {}
+  DDGNode(const DDGNode &N) : DDGNodeBase(N), Kind(N.Kind) {}
+  DDGNode(DDGNode &&N) : DDGNodeBase(std::move(N)), Kind(N.Kind) {}
+  virtual ~DDGNode() = 0;
+
+  DDGNode &operator=(const DDGNode &N) {
+    DGNode::operator=(N);
+    Kind = N.Kind;
+    return *this;
+  }
+
+  DDGNode &operator=(DDGNode &&N) {
+    DGNode::operator=(std::move(N));
+    Kind = N.Kind;
+    return *this;
+  }
+
+  /// Getter for the kind of this node.
+  NodeKind getKind() const { return Kind; }
+
+  /// Collect a list of instructions, in \p IList, for which predicate \p Pred
+  /// evaluates to true when iterating over instructions of this node. Return
+  /// true if at least one instruction was collected, and false otherwise.
+  bool collectInstructions(llvm::function_ref<bool(Instruction *)> const &Pred,
+                           InstructionListType &IList) const;
+
+protected:
+  /// Setter for the kind of this node.
+  void setKind(NodeKind K) { Kind = K; }
+
+private:
+  NodeKind Kind;
+};
+
+/// Subclass of DDGNode representing the root node of the graph.
+/// There should only be one such node in a given graph.
+class RootDDGNode : public DDGNode {
+public:
+  RootDDGNode() : DDGNode(NodeKind::Root) {}
+  RootDDGNode(const RootDDGNode &N) = delete;
+  RootDDGNode(RootDDGNode &&N) : DDGNode(std::move(N)) {}
+  ~RootDDGNode() {}
+
+  /// Define classof to be able to use isa<>, cast<>, dyn_cast<>, etc.
+  static bool classof(const DDGNode *N) {
+    return N->getKind() == NodeKind::Root;
+  }
+  static bool classof(const RootDDGNode *N) { return true; }
+};
+
+/// Subclass of DDGNode representing single or multi-instruction nodes.
+class SimpleDDGNode : public DDGNode {
+  friend class DDGBuilder;
+
+public:
+  SimpleDDGNode() = delete;
+  SimpleDDGNode(Instruction &I);
+  SimpleDDGNode(const SimpleDDGNode &N);
+  SimpleDDGNode(SimpleDDGNode &&N);
+  ~SimpleDDGNode();
+
+  SimpleDDGNode &operator=(const SimpleDDGNode &N) {
+    DDGNode::operator=(N);
+    InstList = N.InstList;
+    return *this;
+  }
+
+  SimpleDDGNode &operator=(SimpleDDGNode &&N) {
+    DDGNode::operator=(std::move(N));
+    InstList = std::move(N.InstList);
+    return *this;
+  }
+
+  /// Get the list of instructions in this node.
+  const InstructionListType &getInstructions() const {
+    assert(!InstList.empty() && "Instruction List is empty.");
+    return InstList;
+  }
+  InstructionListType &getInstructions() {
+    return const_cast<InstructionListType &>(
+        static_cast<const SimpleDDGNode *>(this)->getInstructions());
+  }
+
+  /// Get the first/last instruction in the node.
+  Instruction *getFirstInstruction() const { return getInstructions().front(); }
+  Instruction *getLastInstruction() const { return getInstructions().back(); }
+
+  /// Define classof to be able to use isa<>, cast<>, dyn_cast<>, etc.
+  static bool classof(const DDGNode *N) {
+    return N->getKind() == NodeKind::SingleInstruction ||
+           N->getKind() == NodeKind::MultiInstruction;
+  }
+  static bool classof(const SimpleDDGNode *N) { return true; }
+
+private:
+  /// Append the list of instructions in \p Input to this node.
+  void appendInstructions(const InstructionListType &Input) {
+    setKind((InstList.size() == 0 && Input.size() == 1)
+                ? NodeKind::SingleInstruction
+                : NodeKind::MultiInstruction);
+    llvm::append_range(InstList, Input);
+  }
+  void appendInstructions(const SimpleDDGNode &Input) {
+    appendInstructions(Input.getInstructions());
+  }
+
+  /// List of instructions associated with a single or multi-instruction node.
+  SmallVector<Instruction *, 2> InstList;
+};
+
+/// Subclass of DDGNode representing a pi-block. A pi-block represents a group
+/// of DDG nodes that are part of a strongly-connected component of the graph.
+/// Replacing all the SCCs with pi-blocks results in an acyclic representation
+/// of the DDG. For example if we have:
+/// {a -> b}, {b -> c, d}, {c -> a}
+/// the cycle a -> b -> c -> a is abstracted into a pi-block "p" as follows:
+/// {p -> d} with "p" containing: {a -> b}, {b -> c}, {c -> a}
+class PiBlockDDGNode : public DDGNode {
+public:
+  using PiNodeList = SmallVector<DDGNode *, 4>;
+
+  PiBlockDDGNode() = delete;
+  PiBlockDDGNode(const PiNodeList &List);
+  PiBlockDDGNode(const PiBlockDDGNode &N);
+  PiBlockDDGNode(PiBlockDDGNode &&N);
+  ~PiBlockDDGNode();
+
+  PiBlockDDGNode &operator=(const PiBlockDDGNode &N) {
+    DDGNode::operator=(N);
+    NodeList = N.NodeList;
+    return *this;
+  }
+
+  PiBlockDDGNode &operator=(PiBlockDDGNode &&N) {
+    DDGNode::operator=(std::move(N));
+    NodeList = std::move(N.NodeList);
+    return *this;
+  }
+
+  /// Get the list of nodes in this pi-block.
+  const PiNodeList &getNodes() const {
+    assert(!NodeList.empty() && "Node list is empty.");
+    return NodeList;
+  }
+  PiNodeList &getNodes() {
+    return const_cast<PiNodeList &>(
+        static_cast<const PiBlockDDGNode *>(this)->getNodes());
+  }
+
+  /// Define classof to be able to use isa<>, cast<>, dyn_cast<>, etc.
+  static bool classof(const DDGNode *N) {
+    return N->getKind() == NodeKind::PiBlock;
+  }
+
+private:
+  /// List of nodes in this pi-block.
+  PiNodeList NodeList;
+};
+
+/// Data Dependency Graph Edge.
+/// An edge in the DDG can represent a def-use relationship or
+/// a memory dependence based on the result of DependenceAnalysis.
+/// A rooted edge connects the root node to one of the components
+/// of the graph.
+class DDGEdge : public DDGEdgeBase {
+public:
+  /// The kind of edge in the DDG
+  enum class EdgeKind {
+    Unknown,
+    RegisterDefUse,
+    MemoryDependence,
+    Rooted,
+    Last = Rooted // Must be equal to the largest enum value.
+  };
+
+  explicit DDGEdge(DDGNode &N) = delete;
+  DDGEdge(DDGNode &N, EdgeKind K) : DDGEdgeBase(N), Kind(K) {}
+  DDGEdge(const DDGEdge &E) : DDGEdgeBase(E), Kind(E.getKind()) {}
+  DDGEdge(DDGEdge &&E) : DDGEdgeBase(std::move(E)), Kind(E.Kind) {}
+  DDGEdge &operator=(const DDGEdge &E) {
+    DDGEdgeBase::operator=(E);
+    Kind = E.Kind;
+    return *this;
+  }
+
+  DDGEdge &operator=(DDGEdge &&E) {
+    DDGEdgeBase::operator=(std::move(E));
+    Kind = E.Kind;
+    return *this;
+  }
+
+  /// Get the edge kind
+  EdgeKind getKind() const { return Kind; };
+
+  /// Return true if this is a def-use edge, and false otherwise.
+  bool isDefUse() const { return Kind == EdgeKind::RegisterDefUse; }
+
+  /// Return true if this is a memory dependence edge, and false otherwise.
+  bool isMemoryDependence() const { return Kind == EdgeKind::MemoryDependence; }
+
+  /// Return true if this is an edge stemming from the root node, and false
+  /// otherwise.
+  bool isRooted() const { return Kind == EdgeKind::Rooted; }
+
+private:
+  EdgeKind Kind;
+};
+
+/// Encapsulate some common data and functionality needed for different
+/// variations of data dependence graphs.
+template <typename NodeType> class DependenceGraphInfo {
+public:
+  using DependenceList = SmallVector<std::unique_ptr<Dependence>, 1>;
+
+  DependenceGraphInfo() = delete;
+  DependenceGraphInfo(const DependenceGraphInfo &G) = delete;
+  DependenceGraphInfo(const std::string &N, const DependenceInfo &DepInfo)
+      : Name(N), DI(DepInfo), Root(nullptr) {}
+  DependenceGraphInfo(DependenceGraphInfo &&G)
+      : Name(std::move(G.Name)), DI(std::move(G.DI)), Root(G.Root) {}
+  virtual ~DependenceGraphInfo() {}
+
+  /// Return the label that is used to name this graph.
+  const StringRef getName() const { return Name; }
+
+  /// Return the root node of the graph.
+  NodeType &getRoot() const {
+    assert(Root && "Root node is not available yet. Graph construction may "
+                   "still be in progress\n");
+    return *Root;
+  }
+
+  /// Collect all the data dependency infos coming from any pair of memory
+  /// accesses from \p Src to \p Dst, and store them into \p Deps. Return true
+  /// if a dependence exists, and false otherwise.
+  bool getDependencies(const NodeType &Src, const NodeType &Dst,
+                       DependenceList &Deps) const;
+
+  /// Return a string representing the type of dependence that the dependence
+  /// analysis identified between the two given nodes. This function assumes
+  /// that there is a memory dependence between the given two nodes.
+  const std::string getDependenceString(const NodeType &Src,
+                                        const NodeType &Dst) const;
+
+protected:
+  // Name of the graph.
+  std::string Name;
+
+  // Store a copy of DependenceInfo in the graph, so that individual memory
+  // dependencies don't need to be stored. Instead when the dependence is
+  // queried it is recomputed using @DI.
+  const DependenceInfo DI;
+
+  // A special node in the graph that has an edge to every connected component of
+  // the graph, to ensure all nodes are reachable in a graph walk.
+  NodeType *Root = nullptr;
+};
+
+using DDGInfo = DependenceGraphInfo<DDGNode>;
+
+/// Data Dependency Graph
+class DataDependenceGraph : public DDGBase, public DDGInfo {
+  friend AbstractDependenceGraphBuilder<DataDependenceGraph>;
+  friend class DDGBuilder;
+
+public:
+  using NodeType = DDGNode;
+  using EdgeType = DDGEdge;
+
+  DataDependenceGraph() = delete;
+  DataDependenceGraph(const DataDependenceGraph &G) = delete;
+  DataDependenceGraph(DataDependenceGraph &&G)
+      : DDGBase(std::move(G)), DDGInfo(std::move(G)) {}
+  DataDependenceGraph(Function &F, DependenceInfo &DI);
+  DataDependenceGraph(Loop &L, LoopInfo &LI, DependenceInfo &DI);
+  ~DataDependenceGraph();
+
+  /// If node \p N belongs to a pi-block return a pointer to the pi-block,
+  /// otherwise return null.
+  const PiBlockDDGNode *getPiBlock(const NodeType &N) const;
+
+protected:
+  /// Add node \p N to the graph, if it's not added yet, and keep track of the
+  /// root node as well as pi-blocks and their members. Return true if node is
+  /// successfully added.
+  bool addNode(NodeType &N);
+
+private:
+  using PiBlockMapType = DenseMap<const NodeType *, const PiBlockDDGNode *>;
+
+  /// Mapping from graph nodes to their containing pi-blocks. If a node is not
+  /// part of a pi-block, it will not appear in this map.
+  PiBlockMapType PiBlockMap;
+};
+
+/// Concrete implementation of a pure data dependence graph builder. This class
+/// provides custom implementation for the pure-virtual functions used in the
+/// generic dependence graph build algorithm.
+///
+/// For information about time complexity of the build algorithm see the
+/// comments near the declaration of AbstractDependenceGraphBuilder.
+class DDGBuilder : public AbstractDependenceGraphBuilder<DataDependenceGraph> {
+public:
+  DDGBuilder(DataDependenceGraph &G, DependenceInfo &D,
+             const BasicBlockListType &BBs)
+      : AbstractDependenceGraphBuilder(G, D, BBs) {}
+  DDGNode &createRootNode() final override {
+    auto *RN = new RootDDGNode();
+    assert(RN && "Failed to allocate memory for DDG root node.");
+    Graph.addNode(*RN);
+    return *RN;
+  }
+  DDGNode &createFineGrainedNode(Instruction &I) final override {
+    auto *SN = new SimpleDDGNode(I);
+    assert(SN && "Failed to allocate memory for simple DDG node.");
+    Graph.addNode(*SN);
+    return *SN;
+  }
+  DDGNode &createPiBlock(const NodeListType &L) final override {
+    auto *Pi = new PiBlockDDGNode(L);
+    assert(Pi && "Failed to allocate memory for pi-block node.");
+    Graph.addNode(*Pi);
+    return *Pi;
+  }
+  DDGEdge &createDefUseEdge(DDGNode &Src, DDGNode &Tgt) final override {
+    auto *E = new DDGEdge(Tgt, DDGEdge::EdgeKind::RegisterDefUse);
+    assert(E && "Failed to allocate memory for edge");
+    Graph.connect(Src, Tgt, *E);
+    return *E;
+  }
+  DDGEdge &createMemoryEdge(DDGNode &Src, DDGNode &Tgt) final override {
+    auto *E = new DDGEdge(Tgt, DDGEdge::EdgeKind::MemoryDependence);
+    assert(E && "Failed to allocate memory for edge");
+    Graph.connect(Src, Tgt, *E);
+    return *E;
+  }
+  DDGEdge &createRootedEdge(DDGNode &Src, DDGNode &Tgt) final override {
+    auto *E = new DDGEdge(Tgt, DDGEdge::EdgeKind::Rooted);
+    assert(E && "Failed to allocate memory for edge");
+    assert(isa<RootDDGNode>(Src) && "Expected root node");
+    Graph.connect(Src, Tgt, *E);
+    return *E;
+  }
+
+  const NodeListType &getNodesInPiBlock(const DDGNode &N) final override {
+    auto *PiNode = dyn_cast<const PiBlockDDGNode>(&N);
+    assert(PiNode && "Expected a pi-block node.");
+    return PiNode->getNodes();
+  }
+
+  /// Return true if the two nodes \pSrc and \pTgt are both simple nodes and
+  /// the consecutive instructions after merging belong to the same basic block.
+  bool areNodesMergeable(const DDGNode &Src,
+                         const DDGNode &Tgt) const final override;
+  void mergeNodes(DDGNode &Src, DDGNode &Tgt) final override;
+  bool shouldSimplify() const final override;
+  bool shouldCreatePiBlocks() const final override;
+};
+
+raw_ostream &operator<<(raw_ostream &OS, const DDGNode &N);
+raw_ostream &operator<<(raw_ostream &OS, const DDGNode::NodeKind K);
+raw_ostream &operator<<(raw_ostream &OS, const DDGEdge &E);
+raw_ostream &operator<<(raw_ostream &OS, const DDGEdge::EdgeKind K);
+raw_ostream &operator<<(raw_ostream &OS, const DataDependenceGraph &G);
+
+//===--------------------------------------------------------------------===//
+// DDG Analysis Passes
+//===--------------------------------------------------------------------===//
+
+/// Analysis pass that builds the DDG for a loop.
+class DDGAnalysis : public AnalysisInfoMixin<DDGAnalysis> {
+public:
+  using Result = std::unique_ptr<DataDependenceGraph>;
+  Result run(Loop &L, LoopAnalysisManager &AM, LoopStandardAnalysisResults &AR);
+
+private:
+  friend AnalysisInfoMixin<DDGAnalysis>;
+  static AnalysisKey Key;
+};
+
+/// Textual printer pass for the DDG of a loop.
+class DDGAnalysisPrinterPass : public PassInfoMixin<DDGAnalysisPrinterPass> {
+public:
+  explicit DDGAnalysisPrinterPass(raw_ostream &OS) : OS(OS) {}
+  PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
+                        LoopStandardAnalysisResults &AR, LPMUpdater &U);
+
+private:
+  raw_ostream &OS;
+};
+
+//===--------------------------------------------------------------------===//
+// DependenceGraphInfo Implementation
+//===--------------------------------------------------------------------===//
+
+template <typename NodeType>
+bool DependenceGraphInfo<NodeType>::getDependencies(
+    const NodeType &Src, const NodeType &Dst, DependenceList &Deps) const {
+  assert(Deps.empty() && "Expected empty output list at the start.");
+
+  // List of memory access instructions from src and dst nodes.
+  SmallVector<Instruction *, 8> SrcIList, DstIList;
+  auto isMemoryAccess = [](const Instruction *I) {
+    return I->mayReadOrWriteMemory();
+  };
+  Src.collectInstructions(isMemoryAccess, SrcIList);
+  Dst.collectInstructions(isMemoryAccess, DstIList);
+
+  for (auto *SrcI : SrcIList)
+    for (auto *DstI : DstIList)
+      if (auto Dep =
+              const_cast<DependenceInfo *>(&DI)->depends(SrcI, DstI, true))
+        Deps.push_back(std::move(Dep));
+
+  return !Deps.empty();
+}
+
+template <typename NodeType>
+const std::string
+DependenceGraphInfo<NodeType>::getDependenceString(const NodeType &Src,
+                                                   const NodeType &Dst) const {
+  std::string Str;
+  raw_string_ostream OS(Str);
+  DependenceList Deps;
+  if (!getDependencies(Src, Dst, Deps))
+    return OS.str();
+  interleaveComma(Deps, OS, [&](const std::unique_ptr<Dependence> &D) {
+    D->dump(OS);
+    // Remove the extra new-line character printed by the dump
+    // method
+    if (OS.str().back() == '\n')
+      OS.str().pop_back();
+  });
+
+  return OS.str();
+}
+
+//===--------------------------------------------------------------------===//
+// GraphTraits specializations for the DDG
+//===--------------------------------------------------------------------===//
+
+/// non-const versions of the grapth trait specializations for DDG
+template <> struct GraphTraits<DDGNode *> {
+  using NodeRef = DDGNode *;
+
+  static DDGNode *DDGGetTargetNode(DGEdge<DDGNode, DDGEdge> *P) {
+    return &P->getTargetNode();
+  }
+
+  // Provide a mapped iterator so that the GraphTrait-based implementations can
+  // find the target nodes without having to explicitly go through the edges.
+  using ChildIteratorType =
+      mapped_iterator<DDGNode::iterator, decltype(&DDGGetTargetNode)>;
+  using ChildEdgeIteratorType = DDGNode::iterator;
+
+  static NodeRef getEntryNode(NodeRef N) { return N; }
+  static ChildIteratorType child_begin(NodeRef N) {
+    return ChildIteratorType(N->begin(), &DDGGetTargetNode);
+  }
+  static ChildIteratorType child_end(NodeRef N) {
+    return ChildIteratorType(N->end(), &DDGGetTargetNode);
+  }
+
+  static ChildEdgeIteratorType child_edge_begin(NodeRef N) {
+    return N->begin();
+  }
+  static ChildEdgeIteratorType child_edge_end(NodeRef N) { return N->end(); }
+};
+
+template <>
+struct GraphTraits<DataDependenceGraph *> : public GraphTraits<DDGNode *> {
+  using nodes_iterator = DataDependenceGraph::iterator;
+  static NodeRef getEntryNode(DataDependenceGraph *DG) {
+    return &DG->getRoot();
+  }
+  static nodes_iterator nodes_begin(DataDependenceGraph *DG) {
+    return DG->begin();
+  }
+  static nodes_iterator nodes_end(DataDependenceGraph *DG) { return DG->end(); }
+};
+
+/// const versions of the grapth trait specializations for DDG
+template <> struct GraphTraits<const DDGNode *> {
+  using NodeRef = const DDGNode *;
+
+  static const DDGNode *DDGGetTargetNode(const DGEdge<DDGNode, DDGEdge> *P) {
+    return &P->getTargetNode();
+  }
+
+  // Provide a mapped iterator so that the GraphTrait-based implementations can
+  // find the target nodes without having to explicitly go through the edges.
+  using ChildIteratorType =
+      mapped_iterator<DDGNode::const_iterator, decltype(&DDGGetTargetNode)>;
+  using ChildEdgeIteratorType = DDGNode::const_iterator;
+
+  static NodeRef getEntryNode(NodeRef N) { return N; }
+  static ChildIteratorType child_begin(NodeRef N) {
+    return ChildIteratorType(N->begin(), &DDGGetTargetNode);
+  }
+  static ChildIteratorType child_end(NodeRef N) {
+    return ChildIteratorType(N->end(), &DDGGetTargetNode);
+  }
+
+  static ChildEdgeIteratorType child_edge_begin(NodeRef N) {
+    return N->begin();
+  }
+  static ChildEdgeIteratorType child_edge_end(NodeRef N) { return N->end(); }
+};
+
+template <>
+struct GraphTraits<const DataDependenceGraph *>
+    : public GraphTraits<const DDGNode *> {
+  using nodes_iterator = DataDependenceGraph::const_iterator;
+  static NodeRef getEntryNode(const DataDependenceGraph *DG) {
+    return &DG->getRoot();
+  }
+  static nodes_iterator nodes_begin(const DataDependenceGraph *DG) {
+    return DG->begin();
+  }
+  static nodes_iterator nodes_end(const DataDependenceGraph *DG) {
+    return DG->end();
+  }
+};
+
+} // namespace llvm
+
+#endif // LLVM_ANALYSIS_DDG_H
diff --git a/linux-x64/clang/include/llvm/Analysis/DDGPrinter.h b/linux-x64/clang/include/llvm/Analysis/DDGPrinter.h
new file mode 100644
index 0000000..4477b38
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Analysis/DDGPrinter.h
@@ -0,0 +1,91 @@
+//===- llvm/Analysis/DDGPrinter.h -------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+//===----------------------------------------------------------------------===//
+//
+// This file defines the DOT printer for the Data-Dependence Graph (DDG).
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_ANALYSIS_DDGPRINTER_H
+#define LLVM_ANALYSIS_DDGPRINTER_H
+
+#include "llvm/Analysis/DDG.h"
+#include "llvm/Pass.h"
+#include "llvm/Support/DOTGraphTraits.h"
+
+namespace llvm {
+
+//===--------------------------------------------------------------------===//
+// Implementation of DDG DOT Printer for a loop.
+//===--------------------------------------------------------------------===//
+class DDGDotPrinterPass : public PassInfoMixin<DDGDotPrinterPass> {
+public:
+  PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
+                        LoopStandardAnalysisResults &AR, LPMUpdater &U);
+};
+
+//===--------------------------------------------------------------------===//
+// Specialization of DOTGraphTraits.
+//===--------------------------------------------------------------------===//
+template <>
+struct DOTGraphTraits<const DataDependenceGraph *>
+    : public DefaultDOTGraphTraits {
+
+  DOTGraphTraits(bool IsSimple = false) : DefaultDOTGraphTraits(IsSimple) {}
+
+  /// Generate a title for the graph in DOT format
+  std::string getGraphName(const DataDependenceGraph *G) {
+    assert(G && "expected a valid pointer to the graph.");
+    return "DDG for '" + std::string(G->getName()) + "'";
+  }
+
+  /// Print a DDG node either in concise form (-ddg-dot-only) or
+  /// verbose mode (-ddg-dot).
+  std::string getNodeLabel(const DDGNode *Node,
+                           const DataDependenceGraph *Graph);
+
+  /// Print attributes of an edge in the DDG graph. If the edge
+  /// is a MemoryDependence edge, then detailed dependence info
+  /// available from DependenceAnalysis is displayed.
+  std::string
+  getEdgeAttributes(const DDGNode *Node,
+                    GraphTraits<const DDGNode *>::ChildIteratorType I,
+                    const DataDependenceGraph *G);
+
+  /// Do not print nodes that are part of a pi-block separately. They
+  /// will be printed when their containing pi-block is being printed.
+  bool isNodeHidden(const DDGNode *Node, const DataDependenceGraph *G);
+
+private:
+  /// Print a DDG node in concise form.
+  static std::string getSimpleNodeLabel(const DDGNode *Node,
+                                        const DataDependenceGraph *G);
+
+  /// Print a DDG node with more information including containing instructions
+  /// and detailed information about the dependence edges.
+  static std::string getVerboseNodeLabel(const DDGNode *Node,
+                                         const DataDependenceGraph *G);
+
+  /// Print a DDG edge in concise form.
+  static std::string getSimpleEdgeAttributes(const DDGNode *Src,
+                                             const DDGEdge *Edge,
+                                             const DataDependenceGraph *G);
+
+  /// Print a DDG edge with more information including detailed information
+  /// about the dependence edges.
+  static std::string getVerboseEdgeAttributes(const DDGNode *Src,
+                                              const DDGEdge *Edge,
+                                              const DataDependenceGraph *G);
+};
+
+using DDGDotGraphTraits = DOTGraphTraits<const DataDependenceGraph *>;
+
+} // namespace llvm
+
+#endif // LLVM_ANALYSIS_DDGPRINTER_H
diff --git a/linux-x64/clang/include/llvm/Analysis/DOTGraphTraitsPass.h b/linux-x64/clang/include/llvm/Analysis/DOTGraphTraitsPass.h
index 0410a33..ecf54cd 100644
--- a/linux-x64/clang/include/llvm/Analysis/DOTGraphTraitsPass.h
+++ b/linux-x64/clang/include/llvm/Analysis/DOTGraphTraitsPass.h
@@ -14,8 +14,6 @@
 #define LLVM_ANALYSIS_DOTGRAPHTRAITSPASS_H
 
 #include "llvm/Analysis/CFGPrinter.h"
-#include "llvm/Pass.h"
-#include "llvm/Support/FileSystem.h"
 
 namespace llvm {
 
@@ -99,7 +97,7 @@
 
     errs() << "Writing '" << Filename << "'...";
 
-    raw_fd_ostream File(Filename, EC, sys::fs::F_Text);
+    raw_fd_ostream File(Filename, EC, sys::fs::OF_Text);
     std::string GraphName = DOTGraphTraits<GraphT>::getGraphName(Graph);
     std::string Title = GraphName + " for '" + F.getName().str() + "' function";
 
@@ -162,7 +160,7 @@
 
     errs() << "Writing '" << Filename << "'...";
 
-    raw_fd_ostream File(Filename, EC, sys::fs::F_Text);
+    raw_fd_ostream File(Filename, EC, sys::fs::OF_Text);
     std::string Title = DOTGraphTraits<GraphT>::getGraphName(Graph);
 
     if (!EC)
diff --git a/linux-x64/clang/include/llvm/Analysis/Delinearization.h b/linux-x64/clang/include/llvm/Analysis/Delinearization.h
new file mode 100644
index 0000000..2658b6b
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Analysis/Delinearization.h
@@ -0,0 +1,33 @@
+//===---- Delinearization.h - MultiDimensional Index Delinearization ------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This implements an analysis pass that tries to delinearize all GEP
+// instructions in all loops using the SCEV analysis functionality. This pass is
+// only used for testing purposes: if your pass needs delinearization, please
+// use the on-demand SCEVAddRecExpr::delinearize() function.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_ANALYSIS_DELINEARIZATION_H
+#define LLVM_ANALYSIS_DELINEARIZATION_H
+
+#include "llvm/IR/PassManager.h"
+#include "llvm/Support/raw_ostream.h"
+
+namespace llvm {
+struct DelinearizationPrinterPass
+    : public PassInfoMixin<DelinearizationPrinterPass> {
+  explicit DelinearizationPrinterPass(raw_ostream &OS);
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+
+private:
+  raw_ostream &OS;
+};
+} // namespace llvm
+
+#endif // LLVM_ANALYSIS_DELINEARIZATION_H
diff --git a/linux-x64/clang/include/llvm/Analysis/DemandedBits.h b/linux-x64/clang/include/llvm/Analysis/DemandedBits.h
index 04db3eb..7a8618a 100644
--- a/linux-x64/clang/include/llvm/Analysis/DemandedBits.h
+++ b/linux-x64/clang/include/llvm/Analysis/DemandedBits.h
@@ -61,6 +61,20 @@
 
   void print(raw_ostream &OS);
 
+  /// Compute alive bits of one addition operand from alive output and known
+  /// operand bits
+  static APInt determineLiveOperandBitsAdd(unsigned OperandNo,
+                                           const APInt &AOut,
+                                           const KnownBits &LHS,
+                                           const KnownBits &RHS);
+
+  /// Compute alive bits of one subtraction operand from alive output and known
+  /// operand bits
+  static APInt determineLiveOperandBitsSub(unsigned OperandNo,
+                                           const APInt &AOut,
+                                           const KnownBits &LHS,
+                                           const KnownBits &RHS);
+
 private:
   void performAnalysis();
   void determineLiveOperandBits(const Instruction *UserI,
diff --git a/linux-x64/clang/include/llvm/Analysis/DependenceAnalysis.h b/linux-x64/clang/include/llvm/Analysis/DependenceAnalysis.h
index 997013a..305c9b1 100644
--- a/linux-x64/clang/include/llvm/Analysis/DependenceAnalysis.h
+++ b/linux-x64/clang/include/llvm/Analysis/DependenceAnalysis.h
@@ -40,12 +40,13 @@
 #define LLVM_ANALYSIS_DEPENDENCEANALYSIS_H
 
 #include "llvm/ADT/SmallBitVector.h"
-#include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/IR/Instructions.h"
+#include "llvm/IR/PassManager.h"
 #include "llvm/Pass.h"
 
 namespace llvm {
-template <typename T> class ArrayRef;
+  class AAResults;
+  template <typename T> class ArrayRef;
   class Loop;
   class LoopInfo;
   class ScalarEvolution;
@@ -270,7 +271,7 @@
   ///
   class DependenceInfo {
   public:
-    DependenceInfo(Function *F, AliasAnalysis *AA, ScalarEvolution *SE,
+    DependenceInfo(Function *F, AAResults *AA, ScalarEvolution *SE,
                    LoopInfo *LI)
         : AA(AA), SE(SE), LI(LI), F(F) {}
 
@@ -333,7 +334,7 @@
     Function *getFunction() const { return F; }
 
   private:
-    AliasAnalysis *AA;
+    AAResults *AA;
     ScalarEvolution *SE;
     LoopInfo *LI;
     Function *F;
@@ -924,8 +925,32 @@
     void updateDirection(Dependence::DVEntry &Level,
                          const Constraint &CurConstraint) const;
 
+    /// Given a linear access function, tries to recover subscripts
+    /// for each dimension of the array element access.
     bool tryDelinearize(Instruction *Src, Instruction *Dst,
                         SmallVectorImpl<Subscript> &Pair);
+
+    /// Tries to delinearize access function for a fixed size multi-dimensional
+    /// array, by deriving subscripts from GEP instructions. Returns true upon
+    /// success and false otherwise.
+    bool tryDelinearizeFixedSize(Instruction *Src, Instruction *Dst,
+                                 const SCEV *SrcAccessFn,
+                                 const SCEV *DstAccessFn,
+                                 SmallVectorImpl<const SCEV *> &SrcSubscripts,
+                                 SmallVectorImpl<const SCEV *> &DstSubscripts);
+
+    /// Tries to delinearize access function for a multi-dimensional array with
+    /// symbolic runtime sizes.
+    /// Returns true upon success and false otherwise.
+    bool tryDelinearizeParametricSize(
+        Instruction *Src, Instruction *Dst, const SCEV *SrcAccessFn,
+        const SCEV *DstAccessFn, SmallVectorImpl<const SCEV *> &SrcSubscripts,
+        SmallVectorImpl<const SCEV *> &DstSubscripts);
+
+    /// checkSubscript - Helper function for checkSrcSubscript and
+    /// checkDstSubscript to avoid duplicate code
+    bool checkSubscript(const SCEV *Expr, const Loop *LoopNest,
+                        SmallBitVector &Loops, bool IsSrc);
   }; // class DependenceInfo
 
   /// AnalysisPass to compute dependence information in a function
@@ -954,10 +979,7 @@
   class DependenceAnalysisWrapperPass : public FunctionPass {
   public:
     static char ID; // Class identification, replacement for typeinfo
-    DependenceAnalysisWrapperPass() : FunctionPass(ID) {
-      initializeDependenceAnalysisWrapperPassPass(
-          *PassRegistry::getPassRegistry());
-    }
+    DependenceAnalysisWrapperPass();
 
     bool runOnFunction(Function &F) override;
     void releaseMemory() override;
diff --git a/linux-x64/clang/include/llvm/Analysis/DependenceGraphBuilder.h b/linux-x64/clang/include/llvm/Analysis/DependenceGraphBuilder.h
new file mode 100644
index 0000000..6f4e1be
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Analysis/DependenceGraphBuilder.h
@@ -0,0 +1,203 @@
+//===- llvm/Analysis/DependenceGraphBuilder.h -------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines a builder interface that can be used to populate dependence
+// graphs such as DDG and PDG.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_ANALYSIS_DEPENDENCE_GRAPH_BUILDER_H
+#define LLVM_ANALYSIS_DEPENDENCE_GRAPH_BUILDER_H
+
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/EquivalenceClasses.h"
+#include "llvm/ADT/SmallVector.h"
+
+namespace llvm {
+
+class BasicBlock;
+class DependenceInfo;
+class Instruction;
+
+/// This abstract builder class defines a set of high-level steps for creating
+/// DDG-like graphs. The client code is expected to inherit from this class and
+/// define concrete implementation for each of the pure virtual functions used
+/// in the high-level algorithm.
+template <class GraphType> class AbstractDependenceGraphBuilder {
+protected:
+  using BasicBlockListType = SmallVectorImpl<BasicBlock *>;
+
+private:
+  using NodeType = typename GraphType::NodeType;
+  using EdgeType = typename GraphType::EdgeType;
+
+public:
+  using ClassesType = EquivalenceClasses<BasicBlock *>;
+  using NodeListType = SmallVector<NodeType *, 4>;
+
+  AbstractDependenceGraphBuilder(GraphType &G, DependenceInfo &D,
+                                 const BasicBlockListType &BBs)
+      : Graph(G), DI(D), BBList(BBs) {}
+  virtual ~AbstractDependenceGraphBuilder() {}
+
+  /// The main entry to the graph construction algorithm. It starts by
+  /// creating nodes in increasing order of granularity and then
+  /// adds def-use and memory edges. As one of the final stages, it
+  /// also creates pi-block nodes to facilitate codegen in transformations
+  /// that use dependence graphs.
+  ///
+  /// The algorithmic complexity of this implementation is O(V^2 * I^2), where V
+  /// is the number of vertecies (nodes) and I is the number of instructions in
+  /// each node. The total number of instructions, N, is equal to V * I,
+  /// therefore the worst-case time complexity is O(N^2). The average time
+  /// complexity is O((N^2)/2).
+  void populate() {
+    computeInstructionOrdinals();
+    createFineGrainedNodes();
+    createDefUseEdges();
+    createMemoryDependencyEdges();
+    simplify();
+    createAndConnectRootNode();
+    createPiBlocks();
+    sortNodesTopologically();
+  }
+
+  /// Compute ordinal numbers for each instruction and store them in a map for
+  /// future look up. These ordinals are used to compute node ordinals which are
+  /// in turn used to order nodes that are part of a cycle.
+  /// Instruction ordinals are assigned based on lexical program order.
+  void computeInstructionOrdinals();
+
+  /// Create fine grained nodes. These are typically atomic nodes that
+  /// consist of a single instruction.
+  void createFineGrainedNodes();
+
+  /// Analyze the def-use chains and create edges from the nodes containing
+  /// definitions to the nodes containing the uses.
+  void createDefUseEdges();
+
+  /// Analyze data dependencies that exist between memory loads or stores,
+  /// in the graph nodes and create edges between them.
+  void createMemoryDependencyEdges();
+
+  /// Create a root node and add edges such that each node in the graph is
+  /// reachable from the root.
+  void createAndConnectRootNode();
+
+  /// Apply graph abstraction to groups of nodes that belong to a strongly
+  /// connected component of the graph to create larger compound nodes
+  /// called pi-blocks. The purpose of this abstraction is to isolate sets of
+  /// program elements that need to stay together during codegen and turn
+  /// the dependence graph into an acyclic graph.
+  void createPiBlocks();
+
+  /// Go through all the nodes in the graph and collapse any two nodes
+  /// 'a' and 'b' if all of the following are true:
+  ///   - the only edge from 'a' is a def-use edge to 'b' and
+  ///   - the only edge to 'b' is a def-use edge from 'a' and
+  ///   - there is no cyclic edge from 'b' to 'a' and
+  ///   - all instructions in 'a' and 'b' belong to the same basic block and
+  ///   - both 'a' and 'b' are simple (single or multi instruction) nodes.
+  void simplify();
+
+  /// Topologically sort the graph nodes.
+  void sortNodesTopologically();
+
+protected:
+  /// Create the root node of the graph.
+  virtual NodeType &createRootNode() = 0;
+
+  /// Create an atomic node in the graph given a single instruction.
+  virtual NodeType &createFineGrainedNode(Instruction &I) = 0;
+
+  /// Create a pi-block node in the graph representing a group of nodes in an
+  /// SCC of the graph.
+  virtual NodeType &createPiBlock(const NodeListType &L) = 0;
+
+  /// Create a def-use edge going from \p Src to \p Tgt.
+  virtual EdgeType &createDefUseEdge(NodeType &Src, NodeType &Tgt) = 0;
+
+  /// Create a memory dependence edge going from \p Src to \p Tgt.
+  virtual EdgeType &createMemoryEdge(NodeType &Src, NodeType &Tgt) = 0;
+
+  /// Create a rooted edge going from \p Src to \p Tgt .
+  virtual EdgeType &createRootedEdge(NodeType &Src, NodeType &Tgt) = 0;
+
+  /// Given a pi-block node, return a vector of all the nodes contained within
+  /// it.
+  virtual const NodeListType &getNodesInPiBlock(const NodeType &N) = 0;
+
+  /// Deallocate memory of edge \p E.
+  virtual void destroyEdge(EdgeType &E) { delete &E; }
+
+  /// Deallocate memory of node \p N.
+  virtual void destroyNode(NodeType &N) { delete &N; }
+
+  /// Return true if creation of pi-blocks are supported and desired,
+  /// and false otherwise.
+  virtual bool shouldCreatePiBlocks() const { return true; }
+
+  /// Return true if graph simplification step is requested, and false
+  /// otherwise.
+  virtual bool shouldSimplify() const { return true; }
+
+  /// Return true if it's safe to merge the two nodes.
+  virtual bool areNodesMergeable(const NodeType &A,
+                                 const NodeType &B) const = 0;
+
+  /// Append the content of node \p B into node \p A and remove \p B and
+  /// the edge between \p A and \p B from the graph.
+  virtual void mergeNodes(NodeType &A, NodeType &B) = 0;
+
+  /// Given an instruction \p I return its associated ordinal number.
+  size_t getOrdinal(Instruction &I) {
+    assert(InstOrdinalMap.find(&I) != InstOrdinalMap.end() &&
+           "No ordinal computed for this instruction.");
+    return InstOrdinalMap[&I];
+  }
+
+  /// Given a node \p N return its associated ordinal number.
+  size_t getOrdinal(NodeType &N) {
+    assert(NodeOrdinalMap.find(&N) != NodeOrdinalMap.end() &&
+           "No ordinal computed for this node.");
+    return NodeOrdinalMap[&N];
+  }
+
+  /// Map types to map instructions to nodes used when populating the graph.
+  using InstToNodeMap = DenseMap<Instruction *, NodeType *>;
+
+  /// Map Types to map instruction/nodes to an ordinal number.
+  using InstToOrdinalMap = DenseMap<Instruction *, size_t>;
+  using NodeToOrdinalMap = DenseMap<NodeType *, size_t>;
+
+  /// Reference to the graph that gets built by a concrete implementation of
+  /// this builder.
+  GraphType &Graph;
+
+  /// Dependence information used to create memory dependence edges in the
+  /// graph.
+  DependenceInfo &DI;
+
+  /// The list of basic blocks to consider when building the graph.
+  const BasicBlockListType &BBList;
+
+  /// A mapping from instructions to the corresponding nodes in the graph.
+  InstToNodeMap IMap;
+
+  /// A mapping from each instruction to an ordinal number. This map is used to
+  /// populate the \p NodeOrdinalMap.
+  InstToOrdinalMap InstOrdinalMap;
+
+  /// A mapping from nodes to an ordinal number. This map is used to sort nodes
+  /// in a pi-block based on program order.
+  NodeToOrdinalMap NodeOrdinalMap;
+};
+
+} // namespace llvm
+
+#endif // LLVM_ANALYSIS_DEPENDENCE_GRAPH_BUILDER_H
diff --git a/linux-x64/clang/include/llvm/Analysis/DivergenceAnalysis.h b/linux-x64/clang/include/llvm/Analysis/DivergenceAnalysis.h
index 3cfb9d1..2e4ae65 100644
--- a/linux-x64/clang/include/llvm/Analysis/DivergenceAnalysis.h
+++ b/linux-x64/clang/include/llvm/Analysis/DivergenceAnalysis.h
@@ -59,8 +59,10 @@
   /// \brief Mark \p UniVal as a value that is always uniform.
   void addUniformOverride(const Value &UniVal);
 
-  /// \brief Mark \p DivVal as a value that is always divergent.
-  void markDivergent(const Value &DivVal);
+  /// \brief Mark \p DivVal as a value that is always divergent. Will not do so
+  /// if `isAlwaysUniform(DivVal)`.
+  /// \returns Whether the tracked divergence state of \p DivVal changed.
+  bool markDivergent(const Value &DivVal);
 
   /// \brief Propagate divergence to all instructions in the region.
   /// Divergence is seeded by calls to \p markDivergent.
@@ -73,45 +75,41 @@
   /// operands
   bool isAlwaysUniform(const Value &Val) const;
 
-  /// \brief Whether \p Val is a divergent value
+  /// \brief Whether \p Val is divergent at its definition.
   bool isDivergent(const Value &Val) const;
 
+  /// \brief Whether \p U is divergent. Uses of a uniform value can be
+  /// divergent.
+  bool isDivergentUse(const Use &U) const;
+
   void print(raw_ostream &OS, const Module *) const;
 
 private:
-  bool updateTerminator(const Instruction &Term) const;
-  bool updatePHINode(const PHINode &Phi) const;
+  /// \brief Mark \p Term as divergent and push all Instructions that become
+  /// divergent as a result on the worklist.
+  void analyzeControlDivergence(const Instruction &Term);
+  /// \brief Mark all phi nodes in \p JoinBlock as divergent and push them on
+  /// the worklist.
+  void taintAndPushPhiNodes(const BasicBlock &JoinBlock);
 
-  /// \brief Computes whether \p Inst is divergent based on the
-  /// divergence of its operands.
-  ///
-  /// \returns Whether \p Inst is divergent.
-  ///
-  /// This should only be called for non-phi, non-terminator instructions.
-  bool updateNormalInstruction(const Instruction &Inst) const;
+  /// \brief Identify all Instructions that become divergent because \p DivExit
+  /// is a divergent loop exit of \p DivLoop. Mark those instructions as
+  /// divergent and push them on the worklist.
+  void propagateLoopExitDivergence(const BasicBlock &DivExit,
+                                   const Loop &DivLoop);
 
-  /// \brief Mark users of live-out users as divergent.
-  ///
-  /// \param LoopHeader the header of the divergent loop.
-  ///
-  /// Marks all users of live-out values of the loop headed by \p LoopHeader
-  /// as divergent and puts them on the worklist.
-  void taintLoopLiveOuts(const BasicBlock &LoopHeader);
+  /// \brief Internal implementation function for propagateLoopExitDivergence.
+  void analyzeLoopExitDivergence(const BasicBlock &DivExit,
+                                 const Loop &OuterDivLoop);
 
-  /// \brief Push all users of \p Val (in the region) to the worklist
+  /// \brief Mark all instruction as divergent that use a value defined in \p
+  /// OuterDivLoop. Push their users on the worklist.
+  void analyzeTemporalDivergence(const Instruction &I,
+                                 const Loop &OuterDivLoop);
+
+  /// \brief Push all users of \p Val (in the region) to the worklist.
   void pushUsers(const Value &I);
 
-  /// \brief Push all phi nodes in @block to the worklist
-  void pushPHINodes(const BasicBlock &Block);
-
-  /// \brief Mark \p Block as join divergent
-  ///
-  /// A block is join divergent if two threads may reach it from different
-  /// incoming blocks at the same time.
-  void markBlockJoinDivergent(const BasicBlock &Block) {
-    DivergentJoinBlocks.insert(&Block);
-  }
-
   /// \brief Whether \p Val is divergent when read in \p ObservingBlock.
   bool isTemporalDivergent(const BasicBlock &ObservingBlock,
                            const Value &Val) const;
@@ -120,31 +118,13 @@
   ///
   /// (see markBlockJoinDivergent).
   bool isJoinDivergent(const BasicBlock &Block) const {
-    return DivergentJoinBlocks.find(&Block) != DivergentJoinBlocks.end();
+    return DivergentJoinBlocks.contains(&Block);
   }
 
-  /// \brief Propagate control-induced divergence to users (phi nodes and
-  /// instructions).
-  //
-  // \param JoinBlock is a divergent loop exit or join point of two disjoint
-  // paths.
-  // \returns Whether \p JoinBlock is a divergent loop exit of \p TermLoop.
-  bool propagateJoinDivergence(const BasicBlock &JoinBlock,
-                               const Loop *TermLoop);
-
-  /// \brief Propagate induced value divergence due to control divergence in \p
-  /// Term.
-  void propagateBranchDivergence(const Instruction &Term);
-
-  /// \brief Propagate divergent caused by a divergent loop exit.
-  ///
-  /// \param ExitingLoop is a divergent loop.
-  void propagateLoopDivergence(const Loop &ExitingLoop);
-
 private:
   const Function &F;
   // If regionLoop != nullptr, analysis is only performed within \p RegionLoop.
-  // Otw, analyze the whole function
+  // Otherwise, analyze the whole function
   const Loop *RegionLoop;
 
   const DominatorTree &DT;
@@ -163,7 +143,7 @@
   DenseSet<const Value *> UniformOverrides;
 
   // Blocks with joining divergent control from different predecessors.
-  DenseSet<const BasicBlock *> DivergentJoinBlocks;
+  DenseSet<const BasicBlock *> DivergentJoinBlocks; // FIXME Deprecated
 
   // Detected/marked divergent values.
   DenseSet<const Value *> DivergentValues;
@@ -189,12 +169,19 @@
   /// The GPU kernel this analysis result is for
   const Function &getFunction() const { return DA.getFunction(); }
 
-  /// Whether \p V is divergent.
+  /// Whether \p V is divergent at its definition.
   bool isDivergent(const Value &V) const;
 
-  /// Whether \p V is uniform/non-divergent
+  /// Whether \p U is divergent. Uses of a uniform value can be divergent.
+  bool isDivergentUse(const Use &U) const;
+
+  /// Whether \p V is uniform/non-divergent.
   bool isUniform(const Value &V) const { return !isDivergent(V); }
 
+  /// Whether \p U is uniform/non-divergent. Uses of a uniform value can be
+  /// divergent.
+  bool isUniformUse(const Use &U) const { return !isDivergentUse(U); }
+
   /// Print all divergent values in the kernel.
   void print(raw_ostream &OS, const Module *) const;
 };
diff --git a/linux-x64/clang/include/llvm/Analysis/DomTreeUpdater.h b/linux-x64/clang/include/llvm/Analysis/DomTreeUpdater.h
index 5ccce2e..d09154d 100644
--- a/linux-x64/clang/include/llvm/Analysis/DomTreeUpdater.h
+++ b/linux-x64/clang/include/llvm/Analysis/DomTreeUpdater.h
@@ -14,15 +14,17 @@
 #ifndef LLVM_ANALYSIS_DOMTREEUPDATER_H
 #define LLVM_ANALYSIS_DOMTREEUPDATER_H
 
-#include "llvm/Analysis/PostDominators.h"
+#include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/IR/Dominators.h"
-#include "llvm/IR/Instructions.h"
 #include "llvm/IR/ValueHandle.h"
-#include "llvm/Support/GenericDomTree.h"
+#include "llvm/Support/Compiler.h"
+#include <cstddef>
 #include <functional>
 #include <vector>
 
 namespace llvm {
+class PostDominatorTree;
+
 class DomTreeUpdater {
 public:
   enum class UpdateStrategy : unsigned char { Eager = 0, Lazy = 1 };
diff --git a/linux-x64/clang/include/llvm/Analysis/DominanceFrontier.h b/linux-x64/clang/include/llvm/Analysis/DominanceFrontier.h
index c0bf30e..cef5e03 100644
--- a/linux-x64/clang/include/llvm/Analysis/DominanceFrontier.h
+++ b/linux-x64/clang/include/llvm/Analysis/DominanceFrontier.h
@@ -26,7 +26,6 @@
 #include <map>
 #include <set>
 #include <utility>
-#include <vector>
 
 namespace llvm {
 
@@ -130,7 +129,7 @@
   using DomSetType = typename DominanceFrontierBase<BlockT, false>::DomSetType;
 
   void analyze(DomTreeT &DT) {
-    assert(DT.getRoots().size() == 1 &&
+    assert(DT.root_size() == 1 &&
            "Only one entry block for forward domfronts!");
     this->Roots = {DT.getRoot()};
     calculate(DT, DT[this->Roots[0]]);
diff --git a/linux-x64/clang/include/llvm/Analysis/EHPersonalities.h b/linux-x64/clang/include/llvm/Analysis/EHPersonalities.h
index d89aa11..eaada66 100644
--- a/linux-x64/clang/include/llvm/Analysis/EHPersonalities.h
+++ b/linux-x64/clang/include/llvm/Analysis/EHPersonalities.h
@@ -11,12 +11,12 @@
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/TinyPtrVector.h"
-#include "llvm/ADT/Triple.h"
 #include "llvm/Support/ErrorHandling.h"
 
 namespace llvm {
 class BasicBlock;
 class Function;
+class Triple;
 class Value;
 
 enum class EHPersonality {
@@ -28,11 +28,12 @@
   GNU_CXX_SjLj,
   GNU_ObjC,
   MSVC_X86SEH,
-  MSVC_Win64SEH,
+  MSVC_TableSEH,
   MSVC_CXX,
   CoreCLR,
   Rust,
-  Wasm_CXX
+  Wasm_CXX,
+  XL_CXX
 };
 
 /// See if the given exception handling personality function is one
@@ -51,7 +52,7 @@
   // unknown personalities don't catch asynch exceptions.
   switch (Pers) {
   case EHPersonality::MSVC_X86SEH:
-  case EHPersonality::MSVC_Win64SEH:
+  case EHPersonality::MSVC_TableSEH:
     return true;
   default:
     return false;
@@ -65,7 +66,7 @@
   switch (Pers) {
   case EHPersonality::MSVC_CXX:
   case EHPersonality::MSVC_X86SEH:
-  case EHPersonality::MSVC_Win64SEH:
+  case EHPersonality::MSVC_TableSEH:
   case EHPersonality::CoreCLR:
     return true;
   default:
@@ -80,7 +81,7 @@
   switch (Pers) {
   case EHPersonality::MSVC_CXX:
   case EHPersonality::MSVC_X86SEH:
-  case EHPersonality::MSVC_Win64SEH:
+  case EHPersonality::MSVC_TableSEH:
   case EHPersonality::CoreCLR:
   case EHPersonality::Wasm_CXX:
     return true;
diff --git a/linux-x64/clang/include/llvm/Analysis/FunctionPropertiesAnalysis.h b/linux-x64/clang/include/llvm/Analysis/FunctionPropertiesAnalysis.h
new file mode 100644
index 0000000..a5f96e7
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Analysis/FunctionPropertiesAnalysis.h
@@ -0,0 +1,86 @@
+//=- FunctionPropertiesAnalysis.h - Function Properties Analysis --*- C++ -*-=//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the FunctionPropertiesInfo and FunctionPropertiesAnalysis
+// classes used to extract function properties.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_FUNCTIONPROPERTIESANALYSIS_H_
+#define LLVM_FUNCTIONPROPERTIESANALYSIS_H_
+
+#include "llvm/Analysis/LoopInfo.h"
+#include "llvm/IR/PassManager.h"
+
+namespace llvm {
+class Function;
+
+class FunctionPropertiesInfo {
+public:
+  static FunctionPropertiesInfo getFunctionPropertiesInfo(const Function &F,
+                                                          const LoopInfo &LI);
+
+  void print(raw_ostream &OS) const;
+
+  /// Number of basic blocks
+  int64_t BasicBlockCount = 0;
+
+  /// Number of blocks reached from a conditional instruction, or that are
+  /// 'cases' of a SwitchInstr.
+  // FIXME: We may want to replace this with a more meaningful metric, like
+  // number of conditionally executed blocks:
+  // 'if (a) s();' would be counted here as 2 blocks, just like
+  // 'if (a) s(); else s2(); s3();' would.
+  int64_t BlocksReachedFromConditionalInstruction = 0;
+
+  /// Number of uses of this function, plus 1 if the function is callable
+  /// outside the module.
+  int64_t Uses = 0;
+
+  /// Number of direct calls made from this function to other functions
+  /// defined in this module.
+  int64_t DirectCallsToDefinedFunctions = 0;
+
+  // Load Instruction Count
+  int64_t LoadInstCount = 0;
+
+  // Store Instruction Count
+  int64_t StoreInstCount = 0;
+
+  // Maximum Loop Depth in the Function
+  int64_t MaxLoopDepth = 0;
+
+  // Number of Top Level Loops in the Function
+  int64_t TopLevelLoopCount = 0;
+};
+
+// Analysis pass
+class FunctionPropertiesAnalysis
+    : public AnalysisInfoMixin<FunctionPropertiesAnalysis> {
+
+public:
+  static AnalysisKey Key;
+
+  using Result = FunctionPropertiesInfo;
+
+  Result run(Function &F, FunctionAnalysisManager &FAM);
+};
+
+/// Printer pass for the FunctionPropertiesAnalysis results.
+class FunctionPropertiesPrinterPass
+    : public PassInfoMixin<FunctionPropertiesPrinterPass> {
+  raw_ostream &OS;
+
+public:
+  explicit FunctionPropertiesPrinterPass(raw_ostream &OS) : OS(OS) {}
+
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+};
+
+} // namespace llvm
+#endif // LLVM_FUNCTIONPROPERTIESANALYSIS_H_
diff --git a/linux-x64/clang/include/llvm/Analysis/GlobalsModRef.h b/linux-x64/clang/include/llvm/Analysis/GlobalsModRef.h
index d3fcfc2..7daaa7f 100644
--- a/linux-x64/clang/include/llvm/Analysis/GlobalsModRef.h
+++ b/linux-x64/clang/include/llvm/Analysis/GlobalsModRef.h
@@ -14,7 +14,6 @@
 #define LLVM_ANALYSIS_GLOBALSMODREF_H
 
 #include "llvm/Analysis/AliasAnalysis.h"
-#include "llvm/Analysis/CallGraph.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/Module.h"
@@ -23,6 +22,7 @@
 #include <list>
 
 namespace llvm {
+class CallGraph;
 
 /// An alias analysis result set for globals.
 ///
@@ -34,11 +34,14 @@
   class FunctionInfo;
 
   const DataLayout &DL;
-  const TargetLibraryInfo &TLI;
+  std::function<const TargetLibraryInfo &(Function &F)> GetTLI;
 
   /// The globals that do not have their addresses taken.
   SmallPtrSet<const GlobalValue *, 8> NonAddressTakenGlobals;
 
+  /// Are there functions with local linkage that may modify globals.
+  bool UnknownFunctionsWithLocalLinkage = false;
+
   /// IndirectGlobals - The memory pointed to by this global is known to be
   /// 'owned' by the global.
   SmallPtrSet<const GlobalValue *, 8> IndirectGlobals;
@@ -72,14 +75,21 @@
   /// could perform to the memory utilization here if this becomes a problem.
   std::list<DeletionCallbackHandle> Handles;
 
-  explicit GlobalsAAResult(const DataLayout &DL, const TargetLibraryInfo &TLI);
+  explicit GlobalsAAResult(
+      const DataLayout &DL,
+      std::function<const TargetLibraryInfo &(Function &F)> GetTLI);
 
 public:
   GlobalsAAResult(GlobalsAAResult &&Arg);
   ~GlobalsAAResult();
 
-  static GlobalsAAResult analyzeModule(Module &M, const TargetLibraryInfo &TLI,
-                                       CallGraph &CG);
+  bool invalidate(Module &M, const PreservedAnalyses &PA,
+                  ModuleAnalysisManager::Invalidator &);
+
+  static GlobalsAAResult
+  analyzeModule(Module &M,
+                std::function<const TargetLibraryInfo &(Function &F)> GetTLI,
+                CallGraph &CG);
 
   //------------------------------------------------
   // Implement the AliasAnalysis API
diff --git a/linux-x64/clang/include/llvm/Analysis/GuardUtils.h b/linux-x64/clang/include/llvm/Analysis/GuardUtils.h
index 41e7b7c..b832115 100644
--- a/linux-x64/clang/include/llvm/Analysis/GuardUtils.h
+++ b/linux-x64/clang/include/llvm/Analysis/GuardUtils.h
@@ -15,6 +15,7 @@
 namespace llvm {
 
 class BasicBlock;
+class Use;
 class User;
 class Value;
 
@@ -22,6 +23,10 @@
 /// of llvm.experimental.guard intrinsic.
 bool isGuard(const User *U);
 
+/// Returns true iff \p U is a widenable branch (that is, parseWidenableBranch
+/// returns true).
+bool isWidenableBranch(const User *U);
+
 /// Returns true iff \p U has semantics of a guard expressed in a form of a
 /// widenable conditional branch to deopt block.
 bool isGuardAsWidenableBranch(const User *U);
@@ -39,6 +44,11 @@
                           Value *&WidenableCondition, BasicBlock *&IfTrueBB,
                           BasicBlock *&IfFalseBB);
 
+/// Analgous to the above, but return the Uses so that that they can be
+/// modified. Unlike previous version, Condition is optional and may be null.
+bool parseWidenableBranch(User *U, Use *&Cond, Use *&WC, BasicBlock *&IfTrueBB,
+                          BasicBlock *&IfFalseBB);
+  
 } // llvm
 
 #endif // LLVM_ANALYSIS_GUARDUTILS_H
diff --git a/linux-x64/clang/include/llvm/Analysis/HeatUtils.h b/linux-x64/clang/include/llvm/Analysis/HeatUtils.h
new file mode 100644
index 0000000..b665e21
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Analysis/HeatUtils.h
@@ -0,0 +1,40 @@
+//===-- HeatUtils.h - Utility for printing heat colors ----------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Utility for printing heat colors based on profiling information.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_ANALYSIS_HEATUTILS_H
+#define LLVM_ANALYSIS_HEATUTILS_H
+
+#include <cstdint>
+#include <string>
+
+namespace llvm {
+
+class BlockFrequencyInfo;
+class Function;
+
+// Returns number of calls of calledFunction by callerFunction.
+uint64_t
+getNumOfCalls(Function &callerFunction, Function &calledFunction);
+
+// Returns the maximum frequency of a BB in a function.
+uint64_t getMaxFreq(const Function &F, const BlockFrequencyInfo *BFI);
+
+// Calculates heat color based on current and maximum frequencies.
+std::string getHeatColor(uint64_t freq, uint64_t maxFreq);
+
+// Calculates heat color based on percent of "hotness".
+std::string getHeatColor(double percent);
+
+} // namespace llvm
+
+#endif
diff --git a/linux-x64/clang/include/llvm/Analysis/IRSimilarityIdentifier.h b/linux-x64/clang/include/llvm/Analysis/IRSimilarityIdentifier.h
new file mode 100644
index 0000000..9e97541
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Analysis/IRSimilarityIdentifier.h
@@ -0,0 +1,789 @@
+//===- IRSimilarityIdentifier.h - Find similarity in a module --------------==//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// \file
+// Interface file for the IRSimilarityIdentifier for identifying similarities in
+// IR including the IRInstructionMapper, which maps an Instruction to unsigned
+// integers.
+//
+// Two sequences of instructions are called "similar" if they perform the same
+// series of operations for all inputs.
+//
+// \code
+// %1 = add i32 %a, 10
+// %2 = add i32 %a, %1
+// %3 = icmp slt icmp %1, %2
+// \endcode
+//
+// and
+//
+// \code
+// %1 = add i32 11, %a
+// %2 = sub i32 %a, %1
+// %3 = icmp sgt icmp %2, %1
+// \endcode
+//
+// ultimately have the same result, even if the inputs, and structure are
+// slightly different.
+//
+// For instructions, we do not worry about operands that do not have fixed
+// semantic meaning to the program.  We consider the opcode that the instruction
+// has, the types, parameters, and extra information such as the function name,
+// or comparison predicate.  These are used to create a hash to map instructions
+// to integers to be used in similarity matching in sequences of instructions
+//
+// Terminology:
+// An IRSimilarityCandidate is a region of IRInstructionData (wrapped
+// Instructions), usually used to denote a region of similarity has been found.
+//
+// A SimilarityGroup is a set of IRSimilarityCandidates that are structurally
+// similar to one another.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_ANALYSIS_IRSIMILARITYIDENTIFIER_H
+#define LLVM_ANALYSIS_IRSIMILARITYIDENTIFIER_H
+
+#include "llvm/IR/InstVisitor.h"
+#include "llvm/IR/Instructions.h"
+#include "llvm/IR/Module.h"
+#include "llvm/IR/PassManager.h"
+#include "llvm/Pass.h"
+#include "llvm/Support/Allocator.h"
+
+namespace llvm {
+namespace IRSimilarity {
+
+struct IRInstructionDataList;
+
+/// This represents what is and is not supported when finding similarity in
+/// Instructions.
+///
+/// Legal Instructions are considered when looking at similarity between
+/// Instructions.
+///
+/// Illegal Instructions cannot be considered when looking for similarity
+/// between Instructions. They act as boundaries between similarity regions.
+///
+/// Invisible Instructions are skipped over during analysis.
+// TODO: Shared with MachineOutliner
+enum InstrType { Legal, Illegal, Invisible };
+
+/// This provides the utilities for hashing an Instruction to an unsigned
+/// integer. Two IRInstructionDatas produce the same hash value when their
+/// underlying Instructions perform the same operation (even if they don't have
+/// the same input operands.)
+/// As a more concrete example, consider the following:
+///
+/// \code
+/// %add1 = add i32 %a, %b
+/// %add2 = add i32 %c, %d
+/// %add3 = add i64 %e, %f
+/// \endcode
+///
+// Then the IRInstructionData wrappers for these Instructions may be hashed like
+/// so:
+///
+/// \code
+/// ; These two adds have the same types and operand types, so they hash to the
+/// ; same number.
+/// %add1 = add i32 %a, %b ; Hash: 1
+/// %add2 = add i32 %c, %d ; Hash: 1
+/// ; This add produces an i64. This differentiates it from %add1 and %add2. So,
+/// ; it hashes to a different number.
+/// %add3 = add i64 %e, %f; Hash: 2
+/// \endcode
+///
+///
+/// This hashing scheme will be used to represent the program as a very long
+/// string. This string can then be placed in a data structure which can be used
+/// for similarity queries.
+///
+/// TODO: Handle types of Instructions which can be equal even with different
+/// operands. (E.g. comparisons with swapped predicates.)
+/// TODO: Handle CallInsts, which are only checked for function type
+/// by \ref isSameOperationAs.
+/// TODO: Handle GetElementPtrInsts, as some of the operands have to be the
+/// exact same, and some do not.
+struct IRInstructionData : ilist_node<IRInstructionData> {
+
+  /// The source Instruction that is being wrapped.
+  Instruction *Inst = nullptr;
+  /// The values of the operands in the Instruction.
+  SmallVector<Value *, 4> OperVals;
+  /// The legality of the wrapped instruction. This is informed by InstrType,
+  /// and is used when checking when two instructions are considered similar.
+  /// If either instruction is not legal, the instructions are automatically not
+  /// considered similar.
+  bool Legal;
+
+  /// This is only relevant if we are wrapping a CmpInst where we needed to
+  /// change the predicate of a compare instruction from a greater than form
+  /// to a less than form.  It is None otherwise.
+  Optional<CmpInst::Predicate> RevisedPredicate;
+
+  /// Gather the information that is difficult to gather for an Instruction, or
+  /// is changed. i.e. the operands of an Instruction and the Types of those
+  /// operands. This extra information allows for similarity matching to make
+  /// assertions that allow for more flexibility when checking for whether an
+  /// Instruction performs the same operation.
+  IRInstructionData(Instruction &I, bool Legality, IRInstructionDataList &IDL);
+
+  /// Get the predicate that the compare instruction is using for hashing the
+  /// instruction. the IRInstructionData must be wrapping a CmpInst.
+  CmpInst::Predicate getPredicate() const;
+
+  /// A function that swaps the predicates to their less than form if they are
+  /// in a greater than form. Otherwise, the predicate is unchanged.
+  ///
+  /// \param CI - The comparison operation to find a consistent preidcate for.
+  /// \return the consistent comparison predicate. 
+  static CmpInst::Predicate predicateForConsistency(CmpInst *CI);
+
+  /// Hashes \p Value based on its opcode, types, and operand types.
+  /// Two IRInstructionData instances produce the same hash when they perform
+  /// the same operation.
+  ///
+  /// As a simple example, consider the following instructions.
+  ///
+  /// \code
+  /// %add1 = add i32 %x1, %y1
+  /// %add2 = add i32 %x2, %y2
+  ///
+  /// %sub = sub i32 %x1, %y1
+  ///
+  /// %add_i64 = add i64 %x2, %y2
+  /// \endcode
+  ///
+  /// Because the first two adds operate the same types, and are performing the
+  /// same action, they will be hashed to the same value.
+  ///
+  /// However, the subtraction instruction is not the same as an addition, and
+  /// will be hashed to a different value.
+  ///
+  /// Finally, the last add has a different type compared to the first two add
+  /// instructions, so it will also be hashed to a different value that any of
+  /// the previous instructions.
+  ///
+  /// \param [in] ID - The IRInstructionData instance to be hashed.
+  /// \returns A hash_value of the IRInstructionData.
+  friend hash_code hash_value(const IRInstructionData &ID) {
+    SmallVector<Type *, 4> OperTypes;
+    for (Value *V : ID.OperVals)
+      OperTypes.push_back(V->getType());
+
+    if (isa<CmpInst>(ID.Inst))
+      return llvm::hash_combine(
+          llvm::hash_value(ID.Inst->getOpcode()),
+          llvm::hash_value(ID.Inst->getType()),
+          llvm::hash_value(ID.getPredicate()),
+          llvm::hash_combine_range(OperTypes.begin(), OperTypes.end()));
+    else if (CallInst *CI = dyn_cast<CallInst>(ID.Inst))
+      return llvm::hash_combine(
+          llvm::hash_value(ID.Inst->getOpcode()),
+          llvm::hash_value(ID.Inst->getType()),
+          llvm::hash_value(CI->getCalledFunction()->getName().str()),
+          llvm::hash_combine_range(OperTypes.begin(), OperTypes.end()));
+    return llvm::hash_combine(
+        llvm::hash_value(ID.Inst->getOpcode()),
+        llvm::hash_value(ID.Inst->getType()),
+        llvm::hash_combine_range(OperTypes.begin(), OperTypes.end()));
+  }
+
+  IRInstructionDataList *IDL = nullptr;
+};
+
+struct IRInstructionDataList : simple_ilist<IRInstructionData> {};
+
+/// Compare one IRInstructionData class to another IRInstructionData class for
+/// whether they are performing a the same operation, and can mapped to the
+/// same value. For regular instructions if the hash value is the same, then
+/// they will also be close.
+///
+/// \param A - The first IRInstructionData class to compare
+/// \param B - The second IRInstructionData class to compare
+/// \returns true if \p A and \p B are similar enough to be mapped to the same
+/// value.
+bool isClose(const IRInstructionData &A, const IRInstructionData &B);
+
+struct IRInstructionDataTraits : DenseMapInfo<IRInstructionData *> {
+  static inline IRInstructionData *getEmptyKey() { return nullptr; }
+  static inline IRInstructionData *getTombstoneKey() {
+    return reinterpret_cast<IRInstructionData *>(-1);
+  }
+
+  static unsigned getHashValue(const IRInstructionData *E) {
+    using llvm::hash_value;
+    assert(E && "IRInstructionData is a nullptr?");
+    return hash_value(*E);
+  }
+
+  static bool isEqual(const IRInstructionData *LHS,
+                      const IRInstructionData *RHS) {
+    if (RHS == getEmptyKey() || RHS == getTombstoneKey() ||
+        LHS == getEmptyKey() || LHS == getTombstoneKey())
+      return LHS == RHS;
+
+    assert(LHS && RHS && "nullptr should have been caught by getEmptyKey?");
+    return isClose(*LHS, *RHS);
+  }
+};
+
+/// Helper struct for converting the Instructions in a Module into a vector of
+/// unsigned integers. This vector of unsigned integers can be thought of as a
+/// "numeric string". This numeric string can then be queried by, for example,
+/// data structures that find repeated substrings.
+///
+/// This hashing is done per BasicBlock in the module. To hash Instructions
+/// based off of their operations, each Instruction is wrapped in an
+/// IRInstructionData struct. The unsigned integer for an IRInstructionData
+/// depends on:
+/// - The hash provided by the IRInstructionData.
+/// - Which member of InstrType the IRInstructionData is classified as.
+// See InstrType for more details on the possible classifications, and how they
+// manifest in the numeric string.
+///
+/// The numeric string for an individual BasicBlock is terminated by an unique
+/// unsigned integer. This prevents data structures which rely on repetition
+/// from matching across BasicBlocks. (For example, the SuffixTree.)
+/// As a concrete example, if we have the following two BasicBlocks:
+/// \code
+/// bb0:
+/// %add1 = add i32 %a, %b
+/// %add2 = add i32 %c, %d
+/// %add3 = add i64 %e, %f
+/// bb1:
+/// %sub = sub i32 %c, %d
+/// \endcode
+/// We may hash the Instructions like this (via IRInstructionData):
+/// \code
+/// bb0:
+/// %add1 = add i32 %a, %b ; Hash: 1
+/// %add2 = add i32 %c, %d; Hash: 1
+/// %add3 = add i64 %e, %f; Hash: 2
+/// bb1:
+/// %sub = sub i32 %c, %d; Hash: 3
+/// %add4 = add i32 %c, %d ; Hash: 1
+/// \endcode
+/// And produce a "numeric string representation" like so:
+/// 1, 1, 2, unique_integer_1, 3, 1, unique_integer_2
+///
+/// TODO: This is very similar to the MachineOutliner, and should be
+/// consolidated into the same interface.
+struct IRInstructionMapper {
+  /// The starting illegal instruction number to map to.
+  ///
+  /// Set to -3 for compatibility with DenseMapInfo<unsigned>.
+  unsigned IllegalInstrNumber = static_cast<unsigned>(-3);
+
+  /// The next available integer to assign to a legal Instruction to.
+  unsigned LegalInstrNumber = 0;
+
+  /// Correspondence from IRInstructionData to unsigned integers.
+  DenseMap<IRInstructionData *, unsigned, IRInstructionDataTraits>
+      InstructionIntegerMap;
+
+  /// Set if we added an illegal number in the previous step.
+  /// Since each illegal number is unique, we only need one of them between
+  /// each range of legal numbers. This lets us make sure we don't add more
+  /// than one illegal number per range.
+  bool AddedIllegalLastTime = false;
+
+  /// Marks whether we found a illegal instruction in the previous step.
+  bool CanCombineWithPrevInstr = false;
+
+  /// Marks whether we have found a set of instructions that is long enough
+  /// to be considered for similarity.
+  bool HaveLegalRange = false;
+
+  /// This allocator pointer is in charge of holding on to the IRInstructionData
+  /// so it is not deallocated until whatever external tool is using it is done
+  /// with the information.
+  SpecificBumpPtrAllocator<IRInstructionData> *InstDataAllocator = nullptr;
+
+  /// This allocator pointer is in charge of creating the IRInstructionDataList
+  /// so it is not deallocated until whatever external tool is using it is done
+  /// with the information.
+  SpecificBumpPtrAllocator<IRInstructionDataList> *IDLAllocator = nullptr;
+
+  /// Get an allocated IRInstructionData struct using the InstDataAllocator.
+  ///
+  /// \param I - The Instruction to wrap with IRInstructionData.
+  /// \param Legality - A boolean value that is true if the instruction is to
+  /// be considered for similarity, and false if not.
+  /// \param IDL - The InstructionDataList that the IRInstructionData is
+  /// inserted into.
+  /// \returns An allocated IRInstructionData struct.
+  IRInstructionData *allocateIRInstructionData(Instruction &I, bool Legality,
+                                               IRInstructionDataList &IDL);
+
+  /// Get an allocated IRInstructionDataList object using the IDLAllocator.
+  ///
+  /// \returns An allocated IRInstructionDataList object.
+  IRInstructionDataList *allocateIRInstructionDataList();
+
+  IRInstructionDataList *IDL = nullptr;
+
+  /// Maps the Instructions in a BasicBlock \p BB to legal or illegal integers
+  /// determined by \p InstrType. Two Instructions are mapped to the same value
+  /// if they are close as defined by the InstructionData class above.
+  ///
+  /// \param [in] BB - The BasicBlock to be mapped to integers.
+  /// \param [in,out] InstrList - Vector of IRInstructionData to append to.
+  /// \param [in,out] IntegerMapping - Vector of unsigned integers to append to.
+  void convertToUnsignedVec(BasicBlock &BB,
+                            std::vector<IRInstructionData *> &InstrList,
+                            std::vector<unsigned> &IntegerMapping);
+
+  /// Maps an Instruction to a legal integer.
+  ///
+  /// \param [in] It - The Instruction to be mapped to an integer.
+  /// \param [in,out] IntegerMappingForBB - Vector of unsigned integers to
+  /// append to.
+  /// \param [in,out] InstrListForBB - Vector of InstructionData to append to.
+  /// \returns The integer \p It was mapped to.
+  unsigned mapToLegalUnsigned(BasicBlock::iterator &It,
+                              std::vector<unsigned> &IntegerMappingForBB,
+                              std::vector<IRInstructionData *> &InstrListForBB);
+
+  /// Maps an Instruction to an illegal integer.
+  ///
+  /// \param [in] It - The \p Instruction to be mapped to an integer.
+  /// \param [in,out] IntegerMappingForBB - Vector of unsigned integers to
+  /// append to.
+  /// \param [in,out] InstrListForBB - Vector of IRInstructionData to append to.
+  /// \param End - true if creating a dummy IRInstructionData at the end of a
+  /// basic block.
+  /// \returns The integer \p It was mapped to.
+  unsigned mapToIllegalUnsigned(
+      BasicBlock::iterator &It, std::vector<unsigned> &IntegerMappingForBB,
+      std::vector<IRInstructionData *> &InstrListForBB, bool End = false);
+
+  IRInstructionMapper(SpecificBumpPtrAllocator<IRInstructionData> *IDA,
+                      SpecificBumpPtrAllocator<IRInstructionDataList> *IDLA)
+      : InstDataAllocator(IDA), IDLAllocator(IDLA) {
+    // Make sure that the implementation of DenseMapInfo<unsigned> hasn't
+    // changed.
+    assert(DenseMapInfo<unsigned>::getEmptyKey() == static_cast<unsigned>(-1) &&
+           "DenseMapInfo<unsigned>'s empty key isn't -1!");
+    assert(DenseMapInfo<unsigned>::getTombstoneKey() ==
+               static_cast<unsigned>(-2) &&
+           "DenseMapInfo<unsigned>'s tombstone key isn't -2!");
+
+    IDL = new (IDLAllocator->Allocate())
+        IRInstructionDataList();
+  }
+
+  /// Custom InstVisitor to classify different instructions for whether it can
+  /// be analyzed for similarity.
+  struct InstructionClassification
+      : public InstVisitor<InstructionClassification, InstrType> {
+    InstructionClassification() {}
+
+    // TODO: Determine a scheme to resolve when the label is similar enough.
+    InstrType visitBranchInst(BranchInst &BI) { return Illegal; }
+    // TODO: Determine a scheme to resolve when the labels are similar enough.
+    InstrType visitPHINode(PHINode &PN) { return Illegal; }
+    // TODO: Handle allocas.
+    InstrType visitAllocaInst(AllocaInst &AI) { return Illegal; }
+    // We exclude variable argument instructions since variable arguments
+    // requires extra checking of the argument list.
+    InstrType visitVAArgInst(VAArgInst &VI) { return Illegal; }
+    // We exclude all exception handling cases since they are so context
+    // dependent.
+    InstrType visitLandingPadInst(LandingPadInst &LPI) { return Illegal; }
+    InstrType visitFuncletPadInst(FuncletPadInst &FPI) { return Illegal; }
+    // DebugInfo should be included in the regions, but should not be
+    // analyzed for similarity as it has no bearing on the outcome of the
+    // program.
+    InstrType visitDbgInfoIntrinsic(DbgInfoIntrinsic &DII) { return Invisible; }
+    // TODO: Handle specific intrinsics.
+    InstrType visitIntrinsicInst(IntrinsicInst &II) { return Illegal; }
+    // We only allow call instructions where the function has a name and
+    // is not an indirect call.
+    InstrType visitCallInst(CallInst &CI) {
+      Function *F = CI.getCalledFunction();
+      if (!F || CI.isIndirectCall() || !F->hasName())
+        return Illegal;
+      return Legal;
+    }
+    // TODO: We do not current handle similarity that changes the control flow.
+    InstrType visitInvokeInst(InvokeInst &II) { return Illegal; }
+    // TODO: We do not current handle similarity that changes the control flow.
+    InstrType visitCallBrInst(CallBrInst &CBI) { return Illegal; }
+    // TODO: Handle interblock similarity.
+    InstrType visitTerminator(Instruction &I) { return Illegal; }
+    InstrType visitInstruction(Instruction &I) { return Legal; }
+  };
+
+  /// Maps an Instruction to a member of InstrType.
+  InstructionClassification InstClassifier;
+};
+
+/// This is a class that wraps a range of IRInstructionData from one point to
+/// another in the vector of IRInstructionData, which is a region of the
+/// program.  It is also responsible for defining the structure within this
+/// region of instructions.
+///
+/// The structure of a region is defined through a value numbering system
+/// assigned to each unique value in a region at the creation of the
+/// IRSimilarityCandidate.
+///
+/// For example, for each Instruction we add a mapping for each new
+/// value seen in that Instruction.
+/// IR:                    Mapping Added:
+/// %add1 = add i32 %a, c1    %add1 -> 3, %a -> 1, c1 -> 2
+/// %add2 = add i32 %a, %1    %add2 -> 4
+/// %add3 = add i32 c2, c1    %add3 -> 6, c2 -> 5
+///
+/// We can compare IRSimilarityCandidates against one another.
+/// The \ref isSimilar function compares each IRInstructionData against one
+/// another and if we have the same sequences of IRInstructionData that would
+/// create the same hash, we have similar IRSimilarityCandidates.
+///
+/// We can also compare the structure of IRSimilarityCandidates. If we can
+/// create a mapping of registers in the region contained by one
+/// IRSimilarityCandidate to the region contained by different
+/// IRSimilarityCandidate, they can be considered structurally similar.
+///
+/// IRSimilarityCandidate1:   IRSimilarityCandidate2:
+/// %add1 = add i32 %a, %b    %add1 = add i32 %d, %e
+/// %add2 = add i32 %a, %c    %add2 = add i32 %d, %f
+/// %add3 = add i32 c1, c2    %add3 = add i32 c3, c4
+///
+/// Can have the following mapping from candidate to candidate of:
+/// %a -> %d, %b -> %e, %c -> %f, c1 -> c3, c2 -> c4
+/// and can be considered similar.
+///
+/// IRSimilarityCandidate1:   IRSimilarityCandidate2:
+/// %add1 = add i32 %a, %b    %add1 = add i32 %d, c4
+/// %add2 = add i32 %a, %c    %add2 = add i32 %d, %f
+/// %add3 = add i32 c1, c2    %add3 = add i32 c3, c4
+///
+/// We cannot create the same mapping since the use of c4 is not used in the
+/// same way as %b or c2.
+class IRSimilarityCandidate {
+private:
+  /// The start index of this IRSimilarityCandidate in the instruction list.
+  unsigned StartIdx = 0;
+
+  /// The number of instructions in this IRSimilarityCandidate.
+  unsigned Len = 0;
+
+  /// The first instruction in this IRSimilarityCandidate.
+  IRInstructionData *FirstInst = nullptr;
+
+  /// The last instruction in this IRSimilarityCandidate.
+  IRInstructionData *LastInst = nullptr;
+
+  /// Global Value Numbering structures
+  /// @{
+  /// Stores the mapping of the value to the number assigned to it in the
+  /// IRSimilarityCandidate.
+  DenseMap<Value *, unsigned> ValueToNumber;
+  /// Stores the mapping of the number to the value assigned this number.
+  DenseMap<unsigned, Value *> NumberToValue;
+  /// @}
+
+public:
+  /// \param StartIdx - The starting location of the region.
+  /// \param Len - The length of the region.
+  /// \param FirstInstIt - The starting IRInstructionData of the region.
+  /// \param LastInstIt - The ending IRInstructionData of the region.
+  IRSimilarityCandidate(unsigned StartIdx, unsigned Len,
+                        IRInstructionData *FirstInstIt,
+                        IRInstructionData *LastInstIt);
+
+  /// \param A - The first IRInstructionCandidate to compare.
+  /// \param B - The second IRInstructionCandidate to compare.
+  /// \returns True when every IRInstructionData in \p A is similar to every
+  /// IRInstructionData in \p B.
+  static bool isSimilar(const IRSimilarityCandidate &A,
+                        const IRSimilarityCandidate &B);
+
+  /// \param A - The first IRInstructionCandidate to compare.
+  /// \param B - The second IRInstructionCandidate to compare.
+  /// \returns True when every IRInstructionData in \p A is structurally similar
+  /// to \p B.
+  static bool compareStructure(const IRSimilarityCandidate &A,
+                               const IRSimilarityCandidate &B);
+
+  struct OperandMapping {
+    /// The IRSimilarityCandidate that holds the instruction the OperVals were
+    /// pulled from.
+    const IRSimilarityCandidate &IRSC;
+
+    /// The operand values to be analyzed.
+    ArrayRef<Value *> &OperVals;
+
+    /// The current mapping of global value numbers from one IRSimilarityCandidate
+    /// to another IRSimilarityCandidate.
+    DenseMap<unsigned, DenseSet<unsigned>> &ValueNumberMapping;
+  };
+
+  /// Compare the operands in \p A and \p B and check that the current mapping
+  /// of global value numbers from \p A to \p B and \p B to \A is consistent.
+  ///
+  /// \param A - The first IRInstructionCandidate, operand values, and current
+  /// operand mappings to compare.
+  /// \param B - The second IRInstructionCandidate, operand values, and current
+  /// operand mappings to compare.
+  /// \returns true if the IRSimilarityCandidates operands are compatible.
+  static bool compareNonCommutativeOperandMapping(OperandMapping A,
+                                                  OperandMapping B);
+
+  /// Compare the operands in \p A and \p B and check that the current mapping
+  /// of global value numbers from \p A to \p B and \p B to \A is consistent
+  /// given that the operands are commutative.
+  ///
+  /// \param A - The first IRInstructionCandidate, operand values, and current
+  /// operand mappings to compare.
+  /// \param B - The second IRInstructionCandidate, operand values, and current
+  /// operand mappings to compare.
+  /// \returns true if the IRSimilarityCandidates operands are compatible.
+  static bool compareCommutativeOperandMapping(OperandMapping A,
+                                               OperandMapping B);
+
+  /// Compare the start and end indices of the two IRSimilarityCandidates for
+  /// whether they overlap. If the start instruction of one
+  /// IRSimilarityCandidate is less than the end instruction of the other, and
+  /// the start instruction of one is greater than the start instruction of the
+  /// other, they overlap.
+  ///
+  /// \returns true if the IRSimilarityCandidates do not have overlapping
+  /// instructions.
+  static bool overlap(const IRSimilarityCandidate &A,
+                      const IRSimilarityCandidate &B);
+
+  /// \returns the number of instructions in this Candidate.
+  unsigned getLength() const { return Len; }
+
+  /// \returns the start index of this IRSimilarityCandidate.
+  unsigned getStartIdx() const { return StartIdx; }
+
+  /// \returns the end index of this IRSimilarityCandidate.
+  unsigned getEndIdx() const { return StartIdx + Len - 1; }
+
+  /// \returns The first IRInstructionData.
+  IRInstructionData *front() const { return FirstInst; }
+  /// \returns The last IRInstructionData.
+  IRInstructionData *back() const { return LastInst; }
+
+  /// \returns The first Instruction.
+  Instruction *frontInstruction() { return FirstInst->Inst; }
+  /// \returns The last Instruction
+  Instruction *backInstruction() { return LastInst->Inst; }
+
+  /// \returns The BasicBlock the IRSimilarityCandidate starts in.
+  BasicBlock *getStartBB() { return FirstInst->Inst->getParent(); }
+  /// \returns The BasicBlock the IRSimilarityCandidate ends in.
+  BasicBlock *getEndBB() { return LastInst->Inst->getParent(); }
+
+  /// \returns The Function that the IRSimilarityCandidate is located in.
+  Function *getFunction() { return getStartBB()->getParent(); }
+
+  /// Finds the positive number associated with \p V if it has been mapped.
+  /// \param [in] V - the Value to find.
+  /// \returns The positive number corresponding to the value.
+  /// \returns None if not present.
+  Optional<unsigned> getGVN(Value *V) {
+    assert(V != nullptr && "Value is a nullptr?");
+    DenseMap<Value *, unsigned>::iterator VNIt = ValueToNumber.find(V);
+    if (VNIt == ValueToNumber.end())
+      return None;
+    return VNIt->second;
+  }
+
+  /// Finds the Value associate with \p Num if it exists.
+  /// \param [in] Num - the number to find.
+  /// \returns The Value associated with the number.
+  /// \returns None if not present.
+  Optional<Value *> fromGVN(unsigned Num) {
+    DenseMap<unsigned, Value *>::iterator VNIt = NumberToValue.find(Num);
+    if (VNIt == NumberToValue.end())
+      return None;
+    assert(VNIt->second != nullptr && "Found value is a nullptr!");
+    return VNIt->second;
+  }
+
+  /// \param RHS -The IRSimilarityCandidate to compare against
+  /// \returns true if the IRSimilarityCandidate is occurs after the
+  /// IRSimilarityCandidate in the program.
+  bool operator<(const IRSimilarityCandidate &RHS) const {
+    return getStartIdx() > RHS.getStartIdx();
+  }
+
+  using iterator = IRInstructionDataList::iterator;
+  iterator begin() const { return iterator(front()); }
+  iterator end() const { return std::next(iterator(back())); }
+};
+
+typedef std::vector<IRSimilarityCandidate> SimilarityGroup;
+typedef std::vector<SimilarityGroup> SimilarityGroupList;
+
+/// This class puts all the pieces of the IRInstructionData,
+/// IRInstructionMapper, IRSimilarityCandidate together.
+///
+/// It first feeds the Module or vector of Modules into the IRInstructionMapper,
+/// and puts all the mapped instructions into a single long list of
+/// IRInstructionData.
+///
+/// The list of unsigned integers is given to the Suffix Tree or similar data
+/// structure to find repeated subsequences.  We construct an
+/// IRSimilarityCandidate for each instance of the subsequence.  We compare them
+/// against one another since  These repeated subsequences can have different
+/// structure.  For each different kind of structure found, we create a
+/// similarity group.
+///
+/// If we had four IRSimilarityCandidates A, B, C, and D where A, B and D are
+/// structurally similar to one another, while C is different we would have two
+/// SimilarityGroups:
+///
+/// SimilarityGroup 1:  SimilarityGroup 2
+/// A, B, D             C
+///
+/// A list of the different similarity groups is then returned after
+/// analyzing the module.
+class IRSimilarityIdentifier {
+public:
+  IRSimilarityIdentifier()
+      : Mapper(&InstDataAllocator, &InstDataListAllocator) {}
+
+  /// \param M the module to find similarity in.
+  explicit IRSimilarityIdentifier(Module &M)
+      : Mapper(&InstDataAllocator, &InstDataListAllocator) {
+    findSimilarity(M);
+  }
+
+private:
+  /// Map the instructions in the module to unsigned integers, using mapping
+  /// already present in the Mapper if possible.
+  ///
+  /// \param [in] M Module - To map to integers.
+  /// \param [in,out] InstrList - The vector to append IRInstructionData to.
+  /// \param [in,out] IntegerMapping - The vector to append integers to.
+  void populateMapper(Module &M, std::vector<IRInstructionData *> &InstrList,
+                      std::vector<unsigned> &IntegerMapping);
+
+  /// Map the instructions in the modules vector to unsigned integers, using
+  /// mapping already present in the mapper if possible.
+  ///
+  /// \param [in] Modules - The list of modules to use to populate the mapper
+  /// \param [in,out] InstrList - The vector to append IRInstructionData to.
+  /// \param [in,out] IntegerMapping - The vector to append integers to.
+  void populateMapper(ArrayRef<std::unique_ptr<Module>> &Modules,
+                      std::vector<IRInstructionData *> &InstrList,
+                      std::vector<unsigned> &IntegerMapping);
+
+  /// Find the similarity candidates in \p InstrList and corresponding
+  /// \p UnsignedVec
+  ///
+  /// \param [in,out] InstrList - The vector to append IRInstructionData to.
+  /// \param [in,out] IntegerMapping - The vector to append integers to.
+  /// candidates found in the program.
+  void findCandidates(std::vector<IRInstructionData *> &InstrList,
+                      std::vector<unsigned> &IntegerMapping);
+
+public:
+  // Find the IRSimilarityCandidates in the \p Modules and group by structural
+  // similarity in a SimilarityGroup, each group is returned in a
+  // SimilarityGroupList.
+  //
+  // \param [in] Modules - the modules to analyze.
+  // \returns The groups of similarity ranges found in the modules.
+  SimilarityGroupList &
+  findSimilarity(ArrayRef<std::unique_ptr<Module>> Modules);
+
+  // Find the IRSimilarityCandidates in the given Module grouped by structural
+  // similarity in a SimilarityGroup, contained inside a SimilarityGroupList.
+  //
+  // \param [in] M - the module to analyze.
+  // \returns The groups of similarity ranges found in the module.
+  SimilarityGroupList &findSimilarity(Module &M);
+
+  // Clears \ref SimilarityCandidates if it is already filled by a previous run.
+  void resetSimilarityCandidates() {
+    // If we've already analyzed a Module or set of Modules, so we must clear
+    // the SimilarityCandidates to make sure we do not have only old values
+    // hanging around.
+    if (SimilarityCandidates.hasValue())
+      SimilarityCandidates->clear();
+    else
+      SimilarityCandidates = SimilarityGroupList();
+  }
+
+  // \returns The groups of similarity ranges found in the most recently passed
+  // set of modules.
+  Optional<SimilarityGroupList> &getSimilarity() {
+    return SimilarityCandidates;
+  }
+
+private:
+  /// The allocator for IRInstructionData.
+  SpecificBumpPtrAllocator<IRInstructionData> InstDataAllocator;
+
+  /// The allocator for IRInstructionDataLists.
+  SpecificBumpPtrAllocator<IRInstructionDataList> InstDataListAllocator;
+
+  /// Map Instructions to unsigned integers and wraps the Instruction in an
+  /// instance of IRInstructionData.
+  IRInstructionMapper Mapper;
+
+  /// The SimilarityGroups found with the most recent run of \ref
+  /// findSimilarity. None if there is no recent run.
+  Optional<SimilarityGroupList> SimilarityCandidates;
+};
+
+} // end namespace IRSimilarity
+
+/// An analysis pass based on legacy pass manager that runs and returns
+/// IRSimilarityIdentifier run on the Module.
+class IRSimilarityIdentifierWrapperPass : public ModulePass {
+  std::unique_ptr<IRSimilarity::IRSimilarityIdentifier> IRSI;
+
+public:
+  static char ID;
+  IRSimilarityIdentifierWrapperPass();
+
+  IRSimilarity::IRSimilarityIdentifier &getIRSI() { return *IRSI; }
+  const IRSimilarity::IRSimilarityIdentifier &getIRSI() const { return *IRSI; }
+
+  bool doInitialization(Module &M) override;
+  bool doFinalization(Module &M) override;
+  bool runOnModule(Module &M) override;
+  void getAnalysisUsage(AnalysisUsage &AU) const override {
+    AU.setPreservesAll();
+  }
+};
+
+/// An analysis pass that runs and returns the IRSimilarityIdentifier run on the
+/// Module.
+class IRSimilarityAnalysis : public AnalysisInfoMixin<IRSimilarityAnalysis> {
+public:
+  typedef IRSimilarity::IRSimilarityIdentifier Result;
+
+  Result run(Module &M, ModuleAnalysisManager &);
+
+private:
+  friend AnalysisInfoMixin<IRSimilarityAnalysis>;
+  static AnalysisKey Key;
+};
+
+/// Printer pass that uses \c IRSimilarityAnalysis.
+class IRSimilarityAnalysisPrinterPass
+    : public PassInfoMixin<IRSimilarityAnalysisPrinterPass> {
+  raw_ostream &OS;
+
+public:
+  explicit IRSimilarityAnalysisPrinterPass(raw_ostream &OS) : OS(OS) {}
+  PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+};
+
+} // end namespace llvm
+
+#endif // LLVM_ANALYSIS_IRSIMILARITYIDENTIFIER_H
diff --git a/linux-x64/clang/include/llvm/Analysis/IVDescriptors.h b/linux-x64/clang/include/llvm/Analysis/IVDescriptors.h
index 7be1fd3..6bb6c4c 100644
--- a/linux-x64/clang/include/llvm/Analysis/IVDescriptors.h
+++ b/linux-x64/clang/include/llvm/Analysis/IVDescriptors.h
@@ -14,38 +14,43 @@
 #define LLVM_ANALYSIS_IVDESCRIPTORS_H
 
 #include "llvm/ADT/DenseMap.h"
-#include "llvm/ADT/Optional.h"
-#include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
-#include "llvm/Analysis/AliasAnalysis.h"
-#include "llvm/Analysis/DemandedBits.h"
-#include "llvm/Analysis/EHPersonalities.h"
-#include "llvm/Analysis/MustExecute.h"
-#include "llvm/Analysis/TargetTransformInfo.h"
-#include "llvm/IR/Dominators.h"
-#include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/InstrTypes.h"
+#include "llvm/IR/Instruction.h"
 #include "llvm/IR/Operator.h"
 #include "llvm/IR/ValueHandle.h"
 #include "llvm/Support/Casting.h"
 
 namespace llvm {
 
-class AliasSet;
-class AliasSetTracker;
-class BasicBlock;
-class DataLayout;
+class DemandedBits;
+class AssumptionCache;
 class Loop;
-class LoopInfo;
-class OptimizationRemarkEmitter;
 class PredicatedScalarEvolution;
-class PredIteratorCache;
 class ScalarEvolution;
 class SCEV;
-class TargetLibraryInfo;
-class TargetTransformInfo;
+class DominatorTree;
+class ICFLoopSafetyInfo;
+
+/// These are the kinds of recurrences that we support.
+enum class RecurKind {
+  None,   ///< Not a recurrence.
+  Add,    ///< Sum of integers.
+  Mul,    ///< Product of integers.
+  Or,     ///< Bitwise or logical OR of integers.
+  And,    ///< Bitwise or logical AND of integers.
+  Xor,    ///< Bitwise or logical XOR of integers.
+  SMin,   ///< Signed integer min implemented in terms of select(cmp()).
+  SMax,   ///< Signed integer max implemented in terms of select(cmp()).
+  UMin,   ///< Unisgned integer min implemented in terms of select(cmp()).
+  UMax,   ///< Unsigned integer max implemented in terms of select(cmp()).
+  FAdd,   ///< Sum of floats.
+  FMul,   ///< Product of floats.
+  FMin,   ///< FP min implemented in terms of select(cmp()).
+  FMax    ///< FP max implemented in terms of select(cmp()).
+};
 
 /// The RecurrenceDescriptor is used to identify recurrences variables in a
 /// loop. Reduction is a special case of recurrence that has uses of the
@@ -61,40 +66,13 @@
 /// This struct holds information about recurrence variables.
 class RecurrenceDescriptor {
 public:
-  /// This enum represents the kinds of recurrences that we support.
-  enum RecurrenceKind {
-    RK_NoRecurrence,  ///< Not a recurrence.
-    RK_IntegerAdd,    ///< Sum of integers.
-    RK_IntegerMult,   ///< Product of integers.
-    RK_IntegerOr,     ///< Bitwise or logical OR of numbers.
-    RK_IntegerAnd,    ///< Bitwise or logical AND of numbers.
-    RK_IntegerXor,    ///< Bitwise or logical XOR of numbers.
-    RK_IntegerMinMax, ///< Min/max implemented in terms of select(cmp()).
-    RK_FloatAdd,      ///< Sum of floats.
-    RK_FloatMult,     ///< Product of floats.
-    RK_FloatMinMax    ///< Min/max implemented in terms of select(cmp()).
-  };
-
-  // This enum represents the kind of minmax recurrence.
-  enum MinMaxRecurrenceKind {
-    MRK_Invalid,
-    MRK_UIntMin,
-    MRK_UIntMax,
-    MRK_SIntMin,
-    MRK_SIntMax,
-    MRK_FloatMin,
-    MRK_FloatMax
-  };
-
   RecurrenceDescriptor() = default;
 
-  RecurrenceDescriptor(Value *Start, Instruction *Exit, RecurrenceKind K,
-                       FastMathFlags FMF, MinMaxRecurrenceKind MK,
-                       Instruction *UAI, Type *RT, bool Signed,
-                       SmallPtrSetImpl<Instruction *> &CI)
+  RecurrenceDescriptor(Value *Start, Instruction *Exit, RecurKind K,
+                       FastMathFlags FMF, Instruction *UAI, Type *RT,
+                       bool Signed, SmallPtrSetImpl<Instruction *> &CI)
       : StartValue(Start), LoopExitInstr(Exit), Kind(K), FMF(FMF),
-        MinMaxKind(MK), UnsafeAlgebraInst(UAI), RecurrenceType(RT),
-        IsSigned(Signed) {
+        UnsafeAlgebraInst(UAI), RecurrenceType(RT), IsSigned(Signed) {
     CastInsts.insert(CI.begin(), CI.end());
   }
 
@@ -102,22 +80,22 @@
   class InstDesc {
   public:
     InstDesc(bool IsRecur, Instruction *I, Instruction *UAI = nullptr)
-        : IsRecurrence(IsRecur), PatternLastInst(I), MinMaxKind(MRK_Invalid),
+        : IsRecurrence(IsRecur), PatternLastInst(I),
+          RecKind(RecurKind::None), UnsafeAlgebraInst(UAI) {}
+
+    InstDesc(Instruction *I, RecurKind K, Instruction *UAI = nullptr)
+        : IsRecurrence(true), PatternLastInst(I), RecKind(K),
           UnsafeAlgebraInst(UAI) {}
 
-    InstDesc(Instruction *I, MinMaxRecurrenceKind K, Instruction *UAI = nullptr)
-        : IsRecurrence(true), PatternLastInst(I), MinMaxKind(K),
-          UnsafeAlgebraInst(UAI) {}
+    bool isRecurrence() const { return IsRecurrence; }
 
-    bool isRecurrence() { return IsRecurrence; }
+    bool hasUnsafeAlgebra() const { return UnsafeAlgebraInst != nullptr; }
 
-    bool hasUnsafeAlgebra() { return UnsafeAlgebraInst != nullptr; }
+    Instruction *getUnsafeAlgebraInst() const { return UnsafeAlgebraInst; }
 
-    Instruction *getUnsafeAlgebraInst() { return UnsafeAlgebraInst; }
+    RecurKind getRecKind() const { return RecKind; }
 
-    MinMaxRecurrenceKind getMinMaxKind() { return MinMaxKind; }
-
-    Instruction *getPatternInst() { return PatternLastInst; }
+    Instruction *getPatternInst() const { return PatternLastInst; }
 
   private:
     // Is this instruction a recurrence candidate.
@@ -125,8 +103,8 @@
     // The last instruction in a min/max pattern (select of the select(icmp())
     // pattern), or the current recurrence instruction otherwise.
     Instruction *PatternLastInst;
-    // If this is a min/max pattern the comparison predicate.
-    MinMaxRecurrenceKind MinMaxKind;
+    // If this is a min/max pattern.
+    RecurKind RecKind;
     // Recurrence has unsafe algebra.
     Instruction *UnsafeAlgebraInst;
   };
@@ -136,7 +114,7 @@
   /// select(icmp()) this function advances the instruction pointer 'I' from the
   /// compare instruction to the select instruction and stores this pointer in
   /// 'PatternLastInst' member of the returned struct.
-  static InstDesc isRecurrenceInstr(Instruction *I, RecurrenceKind Kind,
+  static InstDesc isRecurrenceInstr(Instruction *I, RecurKind Kind,
                                     InstDesc &Prev, bool HasFunNoNaNAttr);
 
   /// Returns true if instruction I has multiple uses in Insts
@@ -147,27 +125,28 @@
   /// Returns true if all uses of the instruction I is within the Set.
   static bool areAllUsesIn(Instruction *I, SmallPtrSetImpl<Instruction *> &Set);
 
-  /// Returns a struct describing if the instruction if the instruction is a
+  /// Returns a struct describing if the instruction is a
   /// Select(ICmp(X, Y), X, Y) instruction pattern corresponding to a min(X, Y)
-  /// or max(X, Y).
-  static InstDesc isMinMaxSelectCmpPattern(Instruction *I, InstDesc &Prev);
+  /// or max(X, Y). \p Prev specifies the description of an already processed
+  /// select instruction, so its corresponding cmp can be matched to it.
+  static InstDesc isMinMaxSelectCmpPattern(Instruction *I,
+                                           const InstDesc &Prev);
 
   /// Returns a struct describing if the instruction is a
   /// Select(FCmp(X, Y), (Z = X op PHINode), PHINode) instruction pattern.
-  static InstDesc isConditionalRdxPattern(RecurrenceKind Kind, Instruction *I);
+  static InstDesc isConditionalRdxPattern(RecurKind Kind, Instruction *I);
 
   /// Returns identity corresponding to the RecurrenceKind.
-  static Constant *getRecurrenceIdentity(RecurrenceKind K, Type *Tp);
+  static Constant *getRecurrenceIdentity(RecurKind K, Type *Tp);
 
-  /// Returns the opcode of binary operation corresponding to the
-  /// RecurrenceKind.
-  static unsigned getRecurrenceBinOp(RecurrenceKind Kind);
+  /// Returns the opcode corresponding to the RecurrenceKind.
+  static unsigned getOpcode(RecurKind Kind);
 
   /// Returns true if Phi is a reduction of type Kind and adds it to the
   /// RecurrenceDescriptor. If either \p DB is non-null or \p AC and \p DT are
   /// non-null, the minimal bit width needed to compute the reduction will be
   /// computed.
-  static bool AddReductionVar(PHINode *Phi, RecurrenceKind Kind, Loop *TheLoop,
+  static bool AddReductionVar(PHINode *Phi, RecurKind Kind, Loop *TheLoop,
                               bool HasFunNoNaNAttr,
                               RecurrenceDescriptor &RedDes,
                               DemandedBits *DB = nullptr,
@@ -196,42 +175,63 @@
                          DenseMap<Instruction *, Instruction *> &SinkAfter,
                          DominatorTree *DT);
 
-  RecurrenceKind getRecurrenceKind() { return Kind; }
+  RecurKind getRecurrenceKind() const { return Kind; }
 
-  MinMaxRecurrenceKind getMinMaxRecurrenceKind() { return MinMaxKind; }
+  unsigned getOpcode() const { return getOpcode(getRecurrenceKind()); }
 
-  FastMathFlags getFastMathFlags() { return FMF; }
+  FastMathFlags getFastMathFlags() const { return FMF; }
 
-  TrackingVH<Value> getRecurrenceStartValue() { return StartValue; }
+  TrackingVH<Value> getRecurrenceStartValue() const { return StartValue; }
 
-  Instruction *getLoopExitInstr() { return LoopExitInstr; }
+  Instruction *getLoopExitInstr() const { return LoopExitInstr; }
 
   /// Returns true if the recurrence has unsafe algebra which requires a relaxed
   /// floating-point model.
-  bool hasUnsafeAlgebra() { return UnsafeAlgebraInst != nullptr; }
+  bool hasUnsafeAlgebra() const { return UnsafeAlgebraInst != nullptr; }
 
   /// Returns first unsafe algebra instruction in the PHI node's use-chain.
-  Instruction *getUnsafeAlgebraInst() { return UnsafeAlgebraInst; }
+  Instruction *getUnsafeAlgebraInst() const { return UnsafeAlgebraInst; }
 
   /// Returns true if the recurrence kind is an integer kind.
-  static bool isIntegerRecurrenceKind(RecurrenceKind Kind);
+  static bool isIntegerRecurrenceKind(RecurKind Kind);
 
   /// Returns true if the recurrence kind is a floating point kind.
-  static bool isFloatingPointRecurrenceKind(RecurrenceKind Kind);
+  static bool isFloatingPointRecurrenceKind(RecurKind Kind);
 
   /// Returns true if the recurrence kind is an arithmetic kind.
-  static bool isArithmeticRecurrenceKind(RecurrenceKind Kind);
+  static bool isArithmeticRecurrenceKind(RecurKind Kind);
+
+  /// Returns true if the recurrence kind is an integer min/max kind.
+  static bool isIntMinMaxRecurrenceKind(RecurKind Kind) {
+    return Kind == RecurKind::UMin || Kind == RecurKind::UMax ||
+           Kind == RecurKind::SMin || Kind == RecurKind::SMax;
+  }
+
+  /// Returns true if the recurrence kind is a floating-point min/max kind.
+  static bool isFPMinMaxRecurrenceKind(RecurKind Kind) {
+    return Kind == RecurKind::FMin || Kind == RecurKind::FMax;
+  }
+
+  /// Returns true if the recurrence kind is any min/max kind.
+  static bool isMinMaxRecurrenceKind(RecurKind Kind) {
+    return isIntMinMaxRecurrenceKind(Kind) || isFPMinMaxRecurrenceKind(Kind);
+  }
 
   /// Returns the type of the recurrence. This type can be narrower than the
   /// actual type of the Phi if the recurrence has been type-promoted.
-  Type *getRecurrenceType() { return RecurrenceType; }
+  Type *getRecurrenceType() const { return RecurrenceType; }
 
   /// Returns a reference to the instructions used for type-promoting the
   /// recurrence.
-  SmallPtrSet<Instruction *, 8> &getCastInsts() { return CastInsts; }
+  const SmallPtrSet<Instruction *, 8> &getCastInsts() const { return CastInsts; }
 
   /// Returns true if all source operands of the recurrence are SExtInsts.
-  bool isSigned() { return IsSigned; }
+  bool isSigned() const { return IsSigned; }
+
+  /// Attempts to find a chain of operations from Phi to LoopExitInst that can
+  /// be treated as a set of reductions instructions for in-loop reductions.
+  SmallVector<Instruction *, 4> getReductionOpChain(PHINode *Phi,
+                                                    Loop *L) const;
 
 private:
   // The starting value of the recurrence.
@@ -240,12 +240,10 @@
   // The instruction who's value is used outside the loop.
   Instruction *LoopExitInstr = nullptr;
   // The kind of the recurrence.
-  RecurrenceKind Kind = RK_NoRecurrence;
+  RecurKind Kind = RecurKind::None;
   // The fast-math flags on the recurrent instructions.  We propagate these
   // fast-math flags into the vectorized FP instructions we generate.
   FastMathFlags FMF;
-  // If this a min/max recurrence the kind of recurrence.
-  MinMaxRecurrenceKind MinMaxKind = MRK_Invalid;
   // First occurrence of unasfe algebra in the PHI's use-chain.
   Instruction *UnsafeAlgebraInst = nullptr;
   // The type of the recurrence.
@@ -271,12 +269,6 @@
   /// Default constructor - creates an invalid induction.
   InductionDescriptor() = default;
 
-  /// Get the consecutive direction. Returns:
-  ///   0 - unknown or non-consecutive.
-  ///   1 - consecutive and increasing.
-  ///  -1 - consecutive and decreasing.
-  int getConsecutiveDirection() const;
-
   Value *getStartValue() const { return StartValue; }
   InductionKind getKind() const { return IK; }
   const SCEV *getStep() const { return Step; }
diff --git a/linux-x64/clang/include/llvm/Analysis/IndirectCallVisitor.h b/linux-x64/clang/include/llvm/Analysis/IndirectCallVisitor.h
index 1d1f3f4..eb72f2c 100644
--- a/linux-x64/clang/include/llvm/Analysis/IndirectCallVisitor.h
+++ b/linux-x64/clang/include/llvm/Analysis/IndirectCallVisitor.h
@@ -18,7 +18,7 @@
 namespace llvm {
 // Visitor class that finds all indirect call.
 struct PGOIndirectCallVisitor : public InstVisitor<PGOIndirectCallVisitor> {
-  std::vector<Instruction *> IndirectCalls;
+  std::vector<CallBase *> IndirectCalls;
   PGOIndirectCallVisitor() {}
 
   void visitCallBase(CallBase &Call) {
@@ -28,7 +28,7 @@
 };
 
 // Helper function that finds all indirect call sites.
-inline std::vector<Instruction *> findIndirectCalls(Function &F) {
+inline std::vector<CallBase *> findIndirectCalls(Function &F) {
   PGOIndirectCallVisitor ICV;
   ICV.visit(F);
   return ICV.IndirectCalls;
diff --git a/linux-x64/clang/include/llvm/Analysis/InlineAdvisor.h b/linux-x64/clang/include/llvm/Analysis/InlineAdvisor.h
new file mode 100644
index 0000000..295e677
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Analysis/InlineAdvisor.h
@@ -0,0 +1,283 @@
+//===- InlineAdvisor.h - Inlining decision making abstraction -*- C++ ---*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+#ifndef LLVM_INLINEADVISOR_H_
+#define LLVM_INLINEADVISOR_H_
+
+#include "llvm/Analysis/InlineCost.h"
+#include "llvm/Config/llvm-config.h"
+#include "llvm/IR/PassManager.h"
+#include <memory>
+#include <unordered_set>
+
+namespace llvm {
+class BasicBlock;
+class CallBase;
+class Function;
+class Module;
+class OptimizationRemarkEmitter;
+
+/// There are 3 scenarios we can use the InlineAdvisor:
+/// - Default - use manual heuristics.
+///
+/// - Release mode, the expected mode for production, day to day deployments.
+/// In this mode, when building the compiler, we also compile a pre-trained ML
+/// model to native code, and link it as a static library. This mode has low
+/// overhead and no additional dependencies for the compiler runtime.
+///
+/// - Development mode, for training new models.
+/// In this mode, we trade off runtime performance for flexibility. This mode
+/// requires the full C Tensorflow API library, and evaluates models
+/// dynamically. This mode also permits generating training logs, for offline
+/// training.
+enum class InliningAdvisorMode : int {
+  Default,
+  Release,
+  Development
+};
+
+class InlineAdvisor;
+/// Capture state between an inlining decision having had been made, and
+/// its impact being observable. When collecting model training data, this
+/// allows recording features/decisions/partial reward data sets.
+///
+/// Derivations of this type are expected to be tightly coupled with their
+/// InliningAdvisors. The base type implements the minimal contractual
+/// obligations.
+class InlineAdvice {
+public:
+  InlineAdvice(InlineAdvisor *Advisor, CallBase &CB,
+               OptimizationRemarkEmitter &ORE, bool IsInliningRecommended);
+
+  InlineAdvice(InlineAdvice &&) = delete;
+  InlineAdvice(const InlineAdvice &) = delete;
+  virtual ~InlineAdvice() {
+    assert(Recorded && "InlineAdvice should have been informed of the "
+                       "inliner's decision in all cases");
+  }
+
+  /// Exactly one of the record* APIs must be called. Implementers may extend
+  /// behavior by implementing the corresponding record*Impl.
+  ///
+  /// Call after inlining succeeded, and did not result in deleting the callee.
+  void recordInlining() {
+    markRecorded();
+    recordInliningImpl();
+  }
+
+  /// Call after inlining succeeded, and resulted in deleting the callee.
+  void recordInliningWithCalleeDeleted();
+
+  /// Call after the decision for a call site was to not inline.
+  void recordUnsuccessfulInlining(const InlineResult &Result) {
+    markRecorded();
+    recordUnsuccessfulInliningImpl(Result);
+  }
+
+  /// Call to indicate inlining was not attempted.
+  void recordUnattemptedInlining() {
+    markRecorded();
+    recordUnattemptedInliningImpl();
+  }
+
+  /// Get the inlining recommendation.
+  bool isInliningRecommended() const { return IsInliningRecommended; }
+  const DebugLoc &getOriginalCallSiteDebugLoc() const { return DLoc; }
+  const BasicBlock *getOriginalCallSiteBasicBlock() const { return Block; }
+
+protected:
+  virtual void recordInliningImpl() {}
+  virtual void recordInliningWithCalleeDeletedImpl() {}
+  virtual void recordUnsuccessfulInliningImpl(const InlineResult &Result) {}
+  virtual void recordUnattemptedInliningImpl() {}
+
+  InlineAdvisor *const Advisor;
+  /// Caller and Callee are pre-inlining.
+  Function *const Caller;
+  Function *const Callee;
+
+  // Capture the context of CB before inlining, as a successful inlining may
+  // change that context, and we want to report success or failure in the
+  // original context.
+  const DebugLoc DLoc;
+  const BasicBlock *const Block;
+  OptimizationRemarkEmitter &ORE;
+  const bool IsInliningRecommended;
+
+private:
+  void markRecorded() {
+    assert(!Recorded && "Recording should happen exactly once");
+    Recorded = true;
+  }
+
+  bool Recorded = false;
+};
+
+class DefaultInlineAdvice : public InlineAdvice {
+public:
+  DefaultInlineAdvice(InlineAdvisor *Advisor, CallBase &CB,
+                      Optional<InlineCost> OIC, OptimizationRemarkEmitter &ORE,
+                      bool EmitRemarks = true)
+      : InlineAdvice(Advisor, CB, ORE, OIC.hasValue()), OriginalCB(&CB),
+        OIC(OIC), EmitRemarks(EmitRemarks) {}
+
+private:
+  void recordUnsuccessfulInliningImpl(const InlineResult &Result) override;
+  void recordInliningWithCalleeDeletedImpl() override;
+  void recordInliningImpl() override;
+
+private:
+  CallBase *const OriginalCB;
+  Optional<InlineCost> OIC;
+  bool EmitRemarks;
+};
+
+/// Interface for deciding whether to inline a call site or not.
+class InlineAdvisor {
+public:
+  InlineAdvisor(InlineAdvisor &&) = delete;
+  virtual ~InlineAdvisor() { freeDeletedFunctions(); }
+
+  /// Get an InlineAdvice containing a recommendation on whether to
+  /// inline or not. \p CB is assumed to be a direct call. \p FAM is assumed to
+  /// be up-to-date wrt previous inlining decisions. \p MandatoryOnly indicates
+  /// only mandatory (always-inline) call sites should be recommended - this
+  /// allows the InlineAdvisor track such inlininings.
+  /// Returns an InlineAdvice with the inlining recommendation.
+  std::unique_ptr<InlineAdvice> getAdvice(CallBase &CB,
+                                          bool MandatoryOnly = false);
+
+  /// This must be called when the Inliner pass is entered, to allow the
+  /// InlineAdvisor update internal state, as result of function passes run
+  /// between Inliner pass runs (for the same module).
+  virtual void onPassEntry() {}
+
+  /// This must be called when the Inliner pass is exited, as function passes
+  /// may be run subsequently. This allows an implementation of InlineAdvisor
+  /// to prepare for a partial update.
+  virtual void onPassExit() {}
+
+protected:
+  InlineAdvisor(FunctionAnalysisManager &FAM) : FAM(FAM) {}
+  virtual std::unique_ptr<InlineAdvice> getAdviceImpl(CallBase &CB) = 0;
+  virtual std::unique_ptr<InlineAdvice> getMandatoryAdvice(CallBase &CB,
+                                                           bool Advice);
+
+  FunctionAnalysisManager &FAM;
+
+  /// We may want to defer deleting functions to after the inlining for a whole
+  /// module has finished. This allows us to reliably use function pointers as
+  /// unique identifiers, as an efficient implementation detail of the
+  /// InlineAdvisor. Otherwise, it is possible the memory allocator
+  /// re-allocate Function objects at the same address of a deleted Function;
+  /// and Functions are potentially created during the function passes called
+  /// after each SCC inlining (e.g. argument promotion does that).
+  void freeDeletedFunctions();
+
+  bool isFunctionDeleted(const Function *F) const {
+    return DeletedFunctions.count(F);
+  }
+
+  enum class MandatoryInliningKind { NotMandatory, Always, Never };
+
+  static MandatoryInliningKind getMandatoryKind(CallBase &CB,
+                                                FunctionAnalysisManager &FAM,
+                                                OptimizationRemarkEmitter &ORE);
+
+  OptimizationRemarkEmitter &getCallerORE(CallBase &CB);
+
+private:
+  friend class InlineAdvice;
+  void markFunctionAsDeleted(Function *F);
+  std::unordered_set<const Function *> DeletedFunctions;
+};
+
+/// The default (manual heuristics) implementation of the InlineAdvisor. This
+/// implementation does not need to keep state between inliner pass runs, and is
+/// reusable as-is for inliner pass test scenarios, as well as for regular use.
+class DefaultInlineAdvisor : public InlineAdvisor {
+public:
+  DefaultInlineAdvisor(FunctionAnalysisManager &FAM, InlineParams Params)
+      : InlineAdvisor(FAM), Params(Params) {}
+
+private:
+  std::unique_ptr<InlineAdvice> getAdviceImpl(CallBase &CB) override;
+
+  void onPassExit() override { freeDeletedFunctions(); }
+
+  InlineParams Params;
+};
+
+/// The InlineAdvisorAnalysis is a module pass because the InlineAdvisor
+/// needs to capture state right before inlining commences over a module.
+class InlineAdvisorAnalysis : public AnalysisInfoMixin<InlineAdvisorAnalysis> {
+public:
+  static AnalysisKey Key;
+  InlineAdvisorAnalysis() = default;
+  struct Result {
+    Result(Module &M, ModuleAnalysisManager &MAM) : M(M), MAM(MAM) {}
+    bool invalidate(Module &, const PreservedAnalyses &,
+                    ModuleAnalysisManager::Invalidator &) {
+      // InlineAdvisor must be preserved across analysis invalidations.
+      return false;
+    }
+    bool tryCreate(InlineParams Params, InliningAdvisorMode Mode);
+    InlineAdvisor *getAdvisor() const { return Advisor.get(); }
+    void clear() { Advisor.reset(); }
+
+  private:
+    Module &M;
+    ModuleAnalysisManager &MAM;
+    std::unique_ptr<InlineAdvisor> Advisor;
+  };
+
+  Result run(Module &M, ModuleAnalysisManager &MAM) { return Result(M, MAM); }
+};
+
+#ifdef LLVM_HAVE_TF_AOT
+std::unique_ptr<InlineAdvisor>
+getReleaseModeAdvisor(Module &M, ModuleAnalysisManager &MAM);
+#endif
+
+#ifdef LLVM_HAVE_TF_API
+std::unique_ptr<InlineAdvisor>
+getDevelopmentModeAdvisor(Module &M, ModuleAnalysisManager &MAM,
+                          std::function<bool(CallBase &)> GetDefaultAdvice);
+#endif
+
+// Default (manual policy) decision making helper APIs. Shared with the legacy
+// pass manager inliner.
+
+/// Return the cost only if the inliner should attempt to inline at the given
+/// CallSite. If we return the cost, we will emit an optimisation remark later
+/// using that cost, so we won't do so from this function. Return None if
+/// inlining should not be attempted.
+Optional<InlineCost>
+shouldInline(CallBase &CB, function_ref<InlineCost(CallBase &CB)> GetInlineCost,
+             OptimizationRemarkEmitter &ORE, bool EnableDeferral = true);
+
+/// Emit ORE message.
+void emitInlinedInto(OptimizationRemarkEmitter &ORE, DebugLoc DLoc,
+                     const BasicBlock *Block, const Function &Callee,
+                     const Function &Caller, const InlineCost &IC,
+                     bool ForProfileContext = false,
+                     const char *PassName = nullptr);
+
+/// get call site location as string
+std::string getCallSiteLocation(DebugLoc DLoc);
+
+/// Add location info to ORE message.
+void addLocationToRemarks(OptimizationRemark &Remark, DebugLoc DLoc);
+
+/// Set the inline-remark attribute.
+void setInlineRemark(CallBase &CB, StringRef Message);
+
+/// Utility for extracting the inline cost message to a string.
+std::string inlineCostStr(const InlineCost &IC);
+} // namespace llvm
+#endif // LLVM_INLINEADVISOR_H_
diff --git a/linux-x64/clang/include/llvm/Analysis/InlineCost.h b/linux-x64/clang/include/llvm/Analysis/InlineCost.h
index 611c9de..7f04a8c 100644
--- a/linux-x64/clang/include/llvm/Analysis/InlineCost.h
+++ b/linux-x64/clang/include/llvm/Analysis/InlineCost.h
@@ -27,6 +27,7 @@
 class Function;
 class ProfileSummaryInfo;
 class TargetTransformInfo;
+class TargetLibraryInfo;
 
 namespace InlineConstants {
 // Various thresholds used by inline cost analysis.
@@ -48,7 +49,10 @@
 /// Do not inline functions which allocate this many bytes on the stack
 /// when the caller is recursive.
 const unsigned TotalAllocaSizeRecursiveCaller = 1024;
-}
+/// Do not inline dynamic allocas that have been constant propagated to be
+/// static allocas above this amount in bytes.
+const uint64_t MaxSimplifiedDynamicAllocaToInline = 65536;
+} // namespace InlineConstants
 
 /// Represents the cost of inlining a function.
 ///
@@ -61,16 +65,13 @@
 /// directly tested to determine if inlining should occur given the cost and
 /// threshold for this cost metric.
 class InlineCost {
-  enum SentinelValues {
-    AlwaysInlineCost = INT_MIN,
-    NeverInlineCost = INT_MAX
-  };
+  enum SentinelValues { AlwaysInlineCost = INT_MIN, NeverInlineCost = INT_MAX };
 
   /// The estimated cost of inlining this callsite.
-  int Cost;
+  int Cost = 0;
 
   /// The adjusted threshold against which this cost was computed.
-  int Threshold;
+  int Threshold = 0;
 
   /// Must be set for Always and Never instances.
   const char *Reason = nullptr;
@@ -96,9 +97,7 @@
   }
 
   /// Test whether the inline cost is low enough for inlining.
-  explicit operator bool() const {
-    return Cost < Threshold;
-  }
+  explicit operator bool() const { return Cost < Threshold; }
 
   bool isAlways() const { return Cost == AlwaysInlineCost; }
   bool isNever() const { return Cost == NeverInlineCost; }
@@ -131,14 +130,22 @@
 };
 
 /// InlineResult is basically true or false. For false results the message
-/// describes a reason why it is decided not to inline.
-struct InlineResult {
-  const char *message = nullptr;
-  InlineResult(bool result, const char *message = nullptr)
-      : message(result ? nullptr : (message ? message : "cost > threshold")) {}
-  InlineResult(const char *message = nullptr) : message(message) {}
-  operator bool() const { return !message; }
-  operator const char *() const { return message; }
+/// describes a reason.
+class InlineResult {
+  const char *Message = nullptr;
+  InlineResult(const char *Message = nullptr) : Message(Message) {}
+
+public:
+  static InlineResult success() { return {}; }
+  static InlineResult failure(const char *Reason) {
+    return InlineResult(Reason);
+  }
+  bool isSuccess() const { return Message == nullptr; }
+  const char *getFailureReason() const {
+    assert(!isSuccess() &&
+           "getFailureReason should only be called in failure cases");
+    return Message;
+  }
 };
 
 /// Thresholds to tune inline cost analysis. The inline cost analysis decides
@@ -152,7 +159,7 @@
 
 struct InlineParams {
   /// The default threshold to start with for a callee.
-  int DefaultThreshold;
+  int DefaultThreshold = -1;
 
   /// Threshold to use for callees with inline hint.
   Optional<int> HintThreshold;
@@ -178,6 +185,9 @@
 
   /// Compute inline cost even when the cost has exceeded the threshold.
   Optional<bool> ComputeFullInlineCost;
+
+  /// Indicate whether we should allow inline deferral.
+  Optional<bool> EnableDeferral = true;
 };
 
 /// Generate the parameters to tune the inline cost analysis based only on the
@@ -212,11 +222,14 @@
 ///
 /// Also note that calling this function *dynamically* computes the cost of
 /// inlining the callsite. It is an expensive, heavyweight call.
-InlineCost getInlineCost(
-    CallBase &Call, const InlineParams &Params, TargetTransformInfo &CalleeTTI,
-    std::function<AssumptionCache &(Function &)> &GetAssumptionCache,
-    Optional<function_ref<BlockFrequencyInfo &(Function &)>> GetBFI,
-    ProfileSummaryInfo *PSI, OptimizationRemarkEmitter *ORE = nullptr);
+InlineCost
+getInlineCost(CallBase &Call, const InlineParams &Params,
+              TargetTransformInfo &CalleeTTI,
+              function_ref<AssumptionCache &(Function &)> GetAssumptionCache,
+              function_ref<const TargetLibraryInfo &(Function &)> GetTLI,
+              function_ref<BlockFrequencyInfo &(Function &)> GetBFI = nullptr,
+              ProfileSummaryInfo *PSI = nullptr,
+              OptimizationRemarkEmitter *ORE = nullptr);
 
 /// Get an InlineCost with the callee explicitly specified.
 /// This allows you to calculate the cost of inlining a function via a
@@ -226,12 +239,51 @@
 InlineCost
 getInlineCost(CallBase &Call, Function *Callee, const InlineParams &Params,
               TargetTransformInfo &CalleeTTI,
-              std::function<AssumptionCache &(Function &)> &GetAssumptionCache,
-              Optional<function_ref<BlockFrequencyInfo &(Function &)>> GetBFI,
-              ProfileSummaryInfo *PSI, OptimizationRemarkEmitter *ORE);
+              function_ref<AssumptionCache &(Function &)> GetAssumptionCache,
+              function_ref<const TargetLibraryInfo &(Function &)> GetTLI,
+              function_ref<BlockFrequencyInfo &(Function &)> GetBFI = nullptr,
+              ProfileSummaryInfo *PSI = nullptr,
+              OptimizationRemarkEmitter *ORE = nullptr);
+
+/// Returns InlineResult::success() if the call site should be always inlined
+/// because of user directives, and the inlining is viable. Returns
+/// InlineResult::failure() if the inlining may never happen because of user
+/// directives or incompatibilities detectable without needing callee traversal.
+/// Otherwise returns None, meaning that inlining should be decided based on
+/// other criteria (e.g. cost modeling).
+Optional<InlineResult> getAttributeBasedInliningDecision(
+    CallBase &Call, Function *Callee, TargetTransformInfo &CalleeTTI,
+    function_ref<const TargetLibraryInfo &(Function &)> GetTLI);
+
+/// Get the cost estimate ignoring thresholds. This is similar to getInlineCost
+/// when passed InlineParams::ComputeFullInlineCost, or a non-null ORE. It
+/// uses default InlineParams otherwise.
+/// Contrary to getInlineCost, which makes a threshold-based final evaluation of
+/// should/shouldn't inline, captured in InlineResult, getInliningCostEstimate
+/// returns:
+/// - None, if the inlining cannot happen (is illegal)
+/// - an integer, representing the cost.
+Optional<int> getInliningCostEstimate(
+    CallBase &Call, TargetTransformInfo &CalleeTTI,
+    function_ref<AssumptionCache &(Function &)> GetAssumptionCache,
+    function_ref<BlockFrequencyInfo &(Function &)> GetBFI = nullptr,
+    ProfileSummaryInfo *PSI = nullptr,
+    OptimizationRemarkEmitter *ORE = nullptr);
 
 /// Minimal filter to detect invalid constructs for inlining.
 InlineResult isInlineViable(Function &Callee);
-}
+
+// This pass is used to annotate instructions during the inline process for
+// debugging and analysis. The main purpose of the pass is to see and test
+// inliner's decisions when creating new optimizations to InlineCost.
+struct InlineCostAnnotationPrinterPass
+    : PassInfoMixin<InlineCostAnnotationPrinterPass> {
+  raw_ostream &OS;
+
+public:
+  explicit InlineCostAnnotationPrinterPass(raw_ostream &OS) : OS(OS) {}
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager &FAM);
+};
+} // namespace llvm
 
 #endif
diff --git a/linux-x64/clang/include/llvm/Analysis/InlineModelFeatureMaps.h b/linux-x64/clang/include/llvm/Analysis/InlineModelFeatureMaps.h
new file mode 100644
index 0000000..8da442c
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Analysis/InlineModelFeatureMaps.h
@@ -0,0 +1,70 @@
+//===- InlineModelFeatureMaps.h - common model runner defs ------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+
+#ifndef LLVM_ANALYSIS_INLINEMODELFEATUREMAPS_H
+#define LLVM_ANALYSIS_INLINEMODELFEATUREMAPS_H
+
+#include <array>
+#include <string>
+#include <vector>
+
+namespace llvm {
+
+// List of features. Each feature is defined through a triple:
+// - the name of an enum member, which will be the feature index
+// - a textual name, used for Tensorflow model binding (so it needs to match the
+// names used by the Tensorflow model)
+// - a documentation description. Currently, that is not used anywhere
+// programmatically, and serves as workaround to inability of inserting comments
+// in macros.
+#define INLINE_FEATURE_ITERATOR(M)                                             \
+  M(CalleeBasicBlockCount, "callee_basic_block_count",                         \
+    "number of basic blocks of the callee")                                    \
+  M(CallSiteHeight, "callsite_height",                                         \
+    "position of the call site in the original call graph - measured from "    \
+    "the farthest SCC")                                                        \
+  M(NodeCount, "node_count",                                                   \
+    "total current number of defined functions in the module")                 \
+  M(NrCtantParams, "nr_ctant_params",                                          \
+    "number of parameters in the call site that are constants")                \
+  M(CostEstimate, "cost_estimate", "total cost estimate (threshold - free)")   \
+  M(EdgeCount, "edge_count",                                                   \
+    "number of module-internal users of the caller, +1 if the caller is "      \
+    "exposed externally")                                                      \
+  M(CallerUsers, "caller_users",                                               \
+    "number of blocks reached from a conditional instruction, in the caller")  \
+  M(CallerConditionallyExecutedBlocks, "caller_conditionally_executed_blocks", \
+    "number of blocks reached from a conditional instruction, in the caller")  \
+  M(CallerBasicBlockCount, "caller_basic_block_count",                         \
+    "number of basic blocks in the caller")                                    \
+  M(CalleeConditionallyExecutedBlocks, "callee_conditionally_executed_blocks", \
+    "number of blocks reached from a conditional instruction, in the callee")  \
+  M(CalleeUsers, "callee_users",                                               \
+    "number of blocks reached from a conditional instruction, in the callee")
+
+enum class FeatureIndex : size_t {
+#define POPULATE_INDICES(INDEX_NAME, NAME, COMMENT) INDEX_NAME,
+  INLINE_FEATURE_ITERATOR(POPULATE_INDICES)
+#undef POPULATE_INDICES
+      NumberOfFeatures
+};
+
+constexpr size_t NumberOfFeatures =
+    static_cast<size_t>(FeatureIndex::NumberOfFeatures);
+
+extern const std::array<std::string, NumberOfFeatures> FeatureNameMap;
+
+extern const char *const DecisionName;
+extern const char *const DefaultDecisionName;
+extern const char *const RewardName;
+
+using InlineFeatures = std::vector<int64_t>;
+
+} // namespace llvm
+#endif // LLVM_ANALYSIS_INLINEMODELFEATUREMAPS_H
diff --git a/linux-x64/clang/include/llvm/Analysis/InlineSizeEstimatorAnalysis.h b/linux-x64/clang/include/llvm/Analysis/InlineSizeEstimatorAnalysis.h
new file mode 100644
index 0000000..ab2cf52
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Analysis/InlineSizeEstimatorAnalysis.h
@@ -0,0 +1,45 @@
+//===- InlineSizeEstimatorAnalysis.h - ML size estimator --------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+
+#ifndef LLVM_ANALYSIS_INLINESIZEESTIMATORANALYSIS_H
+#define LLVM_ANALYSIS_INLINESIZEESTIMATORANALYSIS_H
+
+#include "llvm/IR/PassManager.h"
+
+namespace llvm {
+class Function;
+
+class TFModelEvaluator;
+class InlineSizeEstimatorAnalysis
+    : public AnalysisInfoMixin<InlineSizeEstimatorAnalysis> {
+public:
+  InlineSizeEstimatorAnalysis();
+  InlineSizeEstimatorAnalysis(InlineSizeEstimatorAnalysis &&);
+  ~InlineSizeEstimatorAnalysis();
+
+  static AnalysisKey Key;
+  using Result = Optional<size_t>;
+  Result run(const Function &F, FunctionAnalysisManager &FAM);
+  static bool isEvaluatorRequested();
+
+private:
+  std::unique_ptr<TFModelEvaluator> Evaluator;
+};
+
+class InlineSizeEstimatorAnalysisPrinterPass
+    : public PassInfoMixin<InlineSizeEstimatorAnalysisPrinterPass> {
+  raw_ostream &OS;
+
+public:
+  explicit InlineSizeEstimatorAnalysisPrinterPass(raw_ostream &OS) : OS(OS) {}
+
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+};
+} // namespace llvm
+#endif // LLVM_ANALYSIS_INLINESIZEESTIMATORANALYSIS_H
diff --git a/linux-x64/clang/include/llvm/Analysis/InstCount.h b/linux-x64/clang/include/llvm/Analysis/InstCount.h
new file mode 100644
index 0000000..e5ce822
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Analysis/InstCount.h
@@ -0,0 +1,28 @@
+//===- InstCount.h - Collects the count of all instructions -----*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This pass collects the count of all instructions and reports them
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_ANALYSIS_INSTCOUNT_H
+#define LLVM_ANALYSIS_INSTCOUNT_H
+
+#include "llvm/IR/PassManager.h"
+
+namespace llvm {
+
+class Function;
+
+struct InstCountPass : PassInfoMixin<InstCountPass> {
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager &);
+};
+
+} // end namespace llvm
+
+#endif // LLVM_ANALYSIS_INSTCOUNT_H
diff --git a/linux-x64/clang/include/llvm/Analysis/InstructionPrecedenceTracking.h b/linux-x64/clang/include/llvm/Analysis/InstructionPrecedenceTracking.h
index 3c39810..46bc974 100644
--- a/linux-x64/clang/include/llvm/Analysis/InstructionPrecedenceTracking.h
+++ b/linux-x64/clang/include/llvm/Analysis/InstructionPrecedenceTracking.h
@@ -20,18 +20,18 @@
 #ifndef LLVM_ANALYSIS_INSTRUCTIONPRECEDENCETRACKING_H
 #define LLVM_ANALYSIS_INSTRUCTIONPRECEDENCETRACKING_H
 
-#include "llvm/IR/Dominators.h"
-#include "llvm/Analysis/OrderedInstructions.h"
+#include "llvm/ADT/DenseMap.h"
 
 namespace llvm {
 
+class BasicBlock;
+class Instruction;
+
 class InstructionPrecedenceTracking {
   // Maps a block to the topmost special instruction in it. If the value is
   // nullptr, it means that it is known that this block does not contain any
   // special instructions.
   DenseMap<const BasicBlock *, const Instruction *> FirstSpecialInsts;
-  // Allows to answer queries about precedence of instructions within one block.
-  OrderedInstructions OI;
 
   // Fills information about the given block's special instructions.
   void fill(const BasicBlock *BB);
@@ -49,9 +49,6 @@
 #endif
 
 protected:
-  InstructionPrecedenceTracking(DominatorTree *DT)
-      : OI(OrderedInstructions(DT)) {}
-
   /// Returns the topmost special instruction from the block \p BB. Returns
   /// nullptr if there is no special instructions in the block.
   const Instruction *getFirstSpecialInstruction(const BasicBlock *BB);
@@ -96,9 +93,6 @@
 /// perform PRE moving non-speculable instruction to other place.
 class ImplicitControlFlowTracking : public InstructionPrecedenceTracking {
 public:
-  ImplicitControlFlowTracking(DominatorTree *DT)
-      : InstructionPrecedenceTracking(DT) {}
-
   /// Returns the topmost instruction with implicit control flow from the given
   /// basic block. Returns nullptr if there is no such instructions in the block.
   const Instruction *getFirstICFI(const BasicBlock *BB) {
@@ -116,13 +110,11 @@
     return isPreceededBySpecialInstruction(Insn);
   }
 
-  virtual bool isSpecialInstruction(const Instruction *Insn) const;
+  bool isSpecialInstruction(const Instruction *Insn) const override;
 };
 
 class MemoryWriteTracking : public InstructionPrecedenceTracking {
 public:
-  MemoryWriteTracking(DominatorTree *DT) : InstructionPrecedenceTracking(DT) {}
-
   /// Returns the topmost instruction that may write memory from the given
   /// basic block. Returns nullptr if there is no such instructions in the block.
   const Instruction *getFirstMemoryWrite(const BasicBlock *BB) {
@@ -141,7 +133,7 @@
     return isPreceededBySpecialInstruction(Insn);
   }
 
-  virtual bool isSpecialInstruction(const Instruction *Insn) const;
+  bool isSpecialInstruction(const Instruction *Insn) const override;
 };
 
 } // llvm
diff --git a/linux-x64/clang/include/llvm/Analysis/InstructionSimplify.h b/linux-x64/clang/include/llvm/Analysis/InstructionSimplify.h
index 531000b..17d6f30 100644
--- a/linux-x64/clang/include/llvm/Analysis/InstructionSimplify.h
+++ b/linux-x64/clang/include/llvm/Analysis/InstructionSimplify.h
@@ -26,6 +26,10 @@
 // same call context of that function (and not split between caller and callee
 // contexts of a directly recursive call, for example).
 //
+// Additionally, these routines can't simplify to the instructions that are not
+// def-reachable, meaning we can't just scan the basic block for instructions
+// to simplify to.
+//
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_ANALYSIS_INSTRUCTIONSIMPLIFY_H
@@ -33,25 +37,25 @@
 
 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/Operator.h"
-#include "llvm/IR/User.h"
 
 namespace llvm {
-class Function;
+
 template <typename T, typename... TArgs> class AnalysisManager;
 template <class T> class ArrayRef;
 class AssumptionCache;
+class BinaryOperator;
 class CallBase;
-class DominatorTree;
 class DataLayout;
-class FastMathFlags;
+class DominatorTree;
+class Function;
 struct LoopStandardAnalysisResults;
+class MDNode;
 class OptimizationRemarkEmitter;
 class Pass;
+template <class T, unsigned n> class SmallSetVector;
 class TargetLibraryInfo;
 class Type;
 class Value;
-class MDNode;
-class BinaryOperator;
 
 /// InstrInfoQuery provides an interface to query additional information for
 /// instructions like metadata or keywords like nsw, which provides conservative
@@ -98,19 +102,39 @@
   // be safely used.
   const InstrInfoQuery IIQ;
 
+  /// Controls whether simplifications are allowed to constrain the range of
+  /// possible values for uses of undef. If it is false, simplifications are not
+  /// allowed to assume a particular value for a use of undef for example.
+  bool CanUseUndef = true;
+
   SimplifyQuery(const DataLayout &DL, const Instruction *CXTI = nullptr)
       : DL(DL), CxtI(CXTI) {}
 
   SimplifyQuery(const DataLayout &DL, const TargetLibraryInfo *TLI,
                 const DominatorTree *DT = nullptr,
                 AssumptionCache *AC = nullptr,
-                const Instruction *CXTI = nullptr, bool UseInstrInfo = true)
-      : DL(DL), TLI(TLI), DT(DT), AC(AC), CxtI(CXTI), IIQ(UseInstrInfo) {}
+                const Instruction *CXTI = nullptr, bool UseInstrInfo = true,
+                bool CanUseUndef = true)
+      : DL(DL), TLI(TLI), DT(DT), AC(AC), CxtI(CXTI), IIQ(UseInstrInfo),
+        CanUseUndef(CanUseUndef) {}
   SimplifyQuery getWithInstruction(Instruction *I) const {
     SimplifyQuery Copy(*this);
     Copy.CxtI = I;
     return Copy;
   }
+  SimplifyQuery getWithoutUndef() const {
+    SimplifyQuery Copy(*this);
+    Copy.CanUseUndef = false;
+    return Copy;
+  }
+
+  /// If CanUseUndef is true, returns whether \p V is undef.
+  /// Otherwise always return false.
+  bool isUndefValue(Value *V) const {
+    if (!CanUseUndef)
+      return false;
+    return isa<UndefValue>(V);
+  }
 };
 
 // NOTE: the explicit multiple argument versions of these functions are
@@ -141,6 +165,13 @@
 Value *SimplifyFMulInst(Value *LHS, Value *RHS, FastMathFlags FMF,
                         const SimplifyQuery &Q);
 
+/// Given operands for the multiplication of a FMA, fold the result or return
+/// null. In contrast to SimplifyFMulInst, this function will not perform
+/// simplifications whose unrounded results differ when rounded to the argument
+/// type.
+Value *SimplifyFMAFMul(Value *LHS, Value *RHS, FastMathFlags FMF,
+                       const SimplifyQuery &Q);
+
 /// Given operands for a Mul, fold the result or return null.
 Value *SimplifyMulInst(Value *LHS, Value *RHS, const SimplifyQuery &Q);
 
@@ -222,7 +253,8 @@
                         const SimplifyQuery &Q);
 
 /// Given operands for a ShuffleVectorInst, fold the result or return null.
-Value *SimplifyShuffleVectorInst(Value *Op0, Value *Op1, Constant *Mask,
+/// See class ShuffleVectorInst for a description of the mask representation.
+Value *SimplifyShuffleVectorInst(Value *Op0, Value *Op1, ArrayRef<int> Mask,
                                  Type *RetTy, const SimplifyQuery &Q);
 
 //=== Helper functions for higher up the class hierarchy.
@@ -234,61 +266,52 @@
 /// Given operand for a UnaryOperator, fold the result or return null.
 Value *SimplifyUnOp(unsigned Opcode, Value *Op, const SimplifyQuery &Q);
 
-/// Given operand for an FP UnaryOperator, fold the result or return null.
-/// In contrast to SimplifyUnOp, try to use FastMathFlag when folding the
-/// result. In case we don't need FastMathFlags, simply fall to SimplifyUnOp.
-Value *SimplifyFPUnOp(unsigned Opcode, Value *Op, FastMathFlags FMF,
-                      const SimplifyQuery &Q);
+/// Given operand for a UnaryOperator, fold the result or return null.
+/// Try to use FastMathFlags when folding the result.
+Value *SimplifyUnOp(unsigned Opcode, Value *Op, FastMathFlags FMF,
+                    const SimplifyQuery &Q);
 
 /// Given operands for a BinaryOperator, fold the result or return null.
 Value *SimplifyBinOp(unsigned Opcode, Value *LHS, Value *RHS,
                      const SimplifyQuery &Q);
 
-/// Given operands for an FP BinaryOperator, fold the result or return null.
-/// In contrast to SimplifyBinOp, try to use FastMathFlag when folding the
-/// result. In case we don't need FastMathFlags, simply fall to SimplifyBinOp.
-Value *SimplifyFPBinOp(unsigned Opcode, Value *LHS, Value *RHS,
-                       FastMathFlags FMF, const SimplifyQuery &Q);
+/// Given operands for a BinaryOperator, fold the result or return null.
+/// Try to use FastMathFlags when folding the result.
+Value *SimplifyBinOp(unsigned Opcode, Value *LHS, Value *RHS,
+                     FastMathFlags FMF, const SimplifyQuery &Q);
 
 /// Given a callsite, fold the result or return null.
 Value *SimplifyCall(CallBase *Call, const SimplifyQuery &Q);
 
-/// Given a function and iterators over arguments, fold the result or return
-/// null.
-Value *SimplifyCall(CallBase *Call, Value *V, User::op_iterator ArgBegin,
-                    User::op_iterator ArgEnd, const SimplifyQuery &Q);
-
-/// Given a function and set of arguments, fold the result or return null.
-Value *SimplifyCall(CallBase *Call, Value *V, ArrayRef<Value *> Args,
-                    const SimplifyQuery &Q);
+/// Given an operand for a Freeze, see if we can fold the result.
+/// If not, this returns null.
+Value *SimplifyFreezeInst(Value *Op, const SimplifyQuery &Q);
 
 /// See if we can compute a simplified version of this instruction. If not,
 /// return null.
 Value *SimplifyInstruction(Instruction *I, const SimplifyQuery &Q,
                            OptimizationRemarkEmitter *ORE = nullptr);
 
+/// See if V simplifies when its operand Op is replaced with RepOp. If not,
+/// return null.
+/// AllowRefinement specifies whether the simplification can be a refinement,
+/// or whether it needs to be strictly identical.
+Value *SimplifyWithOpReplaced(Value *V, Value *Op, Value *RepOp,
+                              const SimplifyQuery &Q, bool AllowRefinement);
+
 /// Replace all uses of 'I' with 'SimpleV' and simplify the uses recursively.
 ///
 /// This first performs a normal RAUW of I with SimpleV. It then recursively
 /// attempts to simplify those users updated by the operation. The 'I'
 /// instruction must not be equal to the simplified value 'SimpleV'.
+/// If UnsimplifiedUsers is provided, instructions that could not be simplified
+/// are added to it.
 ///
 /// The function returns true if any simplifications were performed.
-bool replaceAndRecursivelySimplify(Instruction *I, Value *SimpleV,
-                                   const TargetLibraryInfo *TLI = nullptr,
-                                   const DominatorTree *DT = nullptr,
-                                   AssumptionCache *AC = nullptr);
-
-/// Recursively attempt to simplify an instruction.
-///
-/// This routine uses SimplifyInstruction to simplify 'I', and if successful
-/// replaces uses of 'I' with the simplified value. It then recurses on each
-/// of the users impacted. It returns true if any simplifications were
-/// performed.
-bool recursivelySimplifyInstruction(Instruction *I,
-                                    const TargetLibraryInfo *TLI = nullptr,
-                                    const DominatorTree *DT = nullptr,
-                                    AssumptionCache *AC = nullptr);
+bool replaceAndRecursivelySimplify(
+    Instruction *I, Value *SimpleV, const TargetLibraryInfo *TLI = nullptr,
+    const DominatorTree *DT = nullptr, AssumptionCache *AC = nullptr,
+    SmallSetVector<Instruction *, 8> *UnsimplifiedUsers = nullptr);
 
 // These helper functions return a SimplifyQuery structure that contains as
 // many of the optional analysis we use as are currently valid.  This is the
diff --git a/linux-x64/clang/include/llvm/Analysis/Interval.h b/linux-x64/clang/include/llvm/Analysis/Interval.h
index 5c9a453..9afe659 100644
--- a/linux-x64/clang/include/llvm/Analysis/Interval.h
+++ b/linux-x64/clang/include/llvm/Analysis/Interval.h
@@ -89,9 +89,6 @@
     return HeaderNode == I.HeaderNode;
   }
 
-  /// isLoop - Find out if there is a back edge in this interval...
-  bool isLoop() const;
-
   /// print - Show contents in human readable format...
   void print(raw_ostream &O) const;
 };
diff --git a/linux-x64/clang/include/llvm/Analysis/IntervalIterator.h b/linux-x64/clang/include/llvm/Analysis/IntervalIterator.h
index efaaf97..8e22736 100644
--- a/linux-x64/clang/include/llvm/Analysis/IntervalIterator.h
+++ b/linux-x64/clang/include/llvm/Analysis/IntervalIterator.h
@@ -81,7 +81,7 @@
 // BasicBlocks are added to the interval.
 inline void addNodeToInterval(Interval *Int, Interval *I) {
   // Add all of the nodes in I as new nodes in Int.
-  Int->Nodes.insert(Int->Nodes.end(), I->Nodes.begin(), I->Nodes.end());
+  llvm::append_range(Int->Nodes, I->Nodes);
 }
 
 template<class NodeTy, class OrigContainer_t, class GT = GraphTraits<NodeTy *>,
@@ -227,9 +227,7 @@
 
       if (Int->isSuccessor(NodeHeader)) {
         // If we were in the successor list from before... remove from succ list
-        Int->Successors.erase(std::remove(Int->Successors.begin(),
-                                          Int->Successors.end(), NodeHeader),
-                              Int->Successors.end());
+        llvm::erase_value(Int->Successors, NodeHeader);
       }
 
       // Now that we have discovered that Node is in the interval, perhaps some
diff --git a/linux-x64/clang/include/llvm/Analysis/IntervalPartition.h b/linux-x64/clang/include/llvm/Analysis/IntervalPartition.h
index 5b127c2..66a99fb 100644
--- a/linux-x64/clang/include/llvm/Analysis/IntervalPartition.h
+++ b/linux-x64/clang/include/llvm/Analysis/IntervalPartition.h
@@ -50,9 +50,7 @@
 public:
   static char ID; // Pass identification, replacement for typeid
 
-  IntervalPartition() : FunctionPass(ID) {
-    initializeIntervalPartitionPass(*PassRegistry::getPassRegistry());
-  }
+  IntervalPartition();
 
   // run - Calculate the interval partition for this function
   bool runOnFunction(Function &F) override;
diff --git a/linux-x64/clang/include/llvm/Analysis/IteratedDominanceFrontier.h b/linux-x64/clang/include/llvm/Analysis/IteratedDominanceFrontier.h
index 1fa1db5..8166b52 100644
--- a/linux-x64/clang/include/llvm/Analysis/IteratedDominanceFrontier.h
+++ b/linux-x64/clang/include/llvm/Analysis/IteratedDominanceFrontier.h
@@ -9,7 +9,7 @@
 #ifndef LLVM_ANALYSIS_IDF_H
 #define LLVM_ANALYSIS_IDF_H
 
-#include "llvm/IR/CFGDiff.h"
+#include "llvm/Support/CFGDiff.h"
 #include "llvm/Support/GenericIteratedDominanceFrontier.h"
 
 namespace llvm {
@@ -63,8 +63,7 @@
 
 template <bool IsPostDom>
 typename ChildrenGetterTy<BasicBlock, IsPostDom>::ChildrenTy
-ChildrenGetterTy<BasicBlock, IsPostDom>::get(
-    const ChildrenGetterTy<BasicBlock, IsPostDom>::NodeRef &N) {
+ChildrenGetterTy<BasicBlock, IsPostDom>::get(const NodeRef &N) {
 
   using OrderedNodeTy =
       typename IDFCalculatorBase<BasicBlock, IsPostDom>::OrderedNodeTy;
@@ -74,13 +73,7 @@
     return {Children.begin(), Children.end()};
   }
 
-  using SnapShotBBPairTy =
-      std::pair<const GraphDiff<BasicBlock *, IsPostDom> *, OrderedNodeTy>;
-
-  ChildrenTy Ret;
-  for (const auto &SnapShotBBPair : children<SnapShotBBPairTy>({GD, N}))
-    Ret.emplace_back(SnapShotBBPair.second);
-  return Ret;
+  return GD->template getChildren<IsPostDom>(N);
 }
 
 } // end of namespace IDFCalculatorDetail
diff --git a/linux-x64/clang/include/llvm/Analysis/LazyBranchProbabilityInfo.h b/linux-x64/clang/include/llvm/Analysis/LazyBranchProbabilityInfo.h
index cae0778..3c632f0 100644
--- a/linux-x64/clang/include/llvm/Analysis/LazyBranchProbabilityInfo.h
+++ b/linux-x64/clang/include/llvm/Analysis/LazyBranchProbabilityInfo.h
@@ -63,7 +63,7 @@
     BranchProbabilityInfo &getCalculated() {
       if (!Calculated) {
         assert(F && LI && "call setAnalysis");
-        BPI.calculate(*F, *LI, TLI);
+        BPI.calculate(*F, *LI, TLI, nullptr, nullptr);
         Calculated = true;
       }
       return BPI;
diff --git a/linux-x64/clang/include/llvm/Analysis/LazyCallGraph.h b/linux-x64/clang/include/llvm/Analysis/LazyCallGraph.h
index 2d83929..f7a5ada 100644
--- a/linux-x64/clang/include/llvm/Analysis/LazyCallGraph.h
+++ b/linux-x64/clang/include/llvm/Analysis/LazyCallGraph.h
@@ -258,7 +258,6 @@
     iterator begin() { return iterator(Edges.begin(), Edges.end()); }
     iterator end() { return iterator(Edges.end(), Edges.end()); }
 
-    Edge &operator[](int i) { return Edges[i]; }
     Edge &operator[](Node &N) {
       assert(EdgeIndexMap.find(&N) != EdgeIndexMap.end() && "No such edge!");
       auto &E = Edges[EdgeIndexMap.find(&N)->second];
@@ -305,13 +304,6 @@
 
     /// Internal helper to remove the edge to the given function.
     bool removeEdgeInternal(Node &ChildN);
-
-    /// Internal helper to replace an edge key with a new one.
-    ///
-    /// This should be used when the function for a particular node in the
-    /// graph gets replaced and we are updating all of the edges to that node
-    /// to use the new function as the key.
-    void replaceEdgeKey(Function &OldTarget, Function &NewTarget);
   };
 
   /// A node in the call graph.
@@ -606,10 +598,6 @@
     void verify();
 #endif
 
-    /// Handle any necessary parent set updates after inserting a trivial ref
-    /// or call edge.
-    void handleTrivialEdgeInsertion(Node &SourceN, Node &TargetN);
-
   public:
     using iterator = pointee_iterator<SmallVectorImpl<SCC *>::const_iterator>;
     using range = iterator_range<iterator>;
@@ -931,11 +919,15 @@
   /// This sets up the graph and computes all of the entry points of the graph.
   /// No function definitions are scanned until their nodes in the graph are
   /// requested during traversal.
-  LazyCallGraph(Module &M, TargetLibraryInfo &TLI);
+  LazyCallGraph(Module &M,
+                function_ref<TargetLibraryInfo &(Function &)> GetTLI);
 
   LazyCallGraph(LazyCallGraph &&G);
   LazyCallGraph &operator=(LazyCallGraph &&RHS);
 
+  bool invalidate(Module &, const PreservedAnalyses &PA,
+                  ModuleAnalysisManager::Invalidator &);
+
   EdgeSequence::iterator begin() { return EntryEdges.begin(); }
   EdgeSequence::iterator end() { return EntryEdges.end(); }
 
@@ -1054,6 +1046,30 @@
   /// fully visited by the DFS prior to calling this routine.
   void removeDeadFunction(Function &F);
 
+  /// Add a new function split/outlined from an existing function.
+  ///
+  /// The new function may only reference other functions that the original
+  /// function did.
+  ///
+  /// The original function must reference (either directly or indirectly) the
+  /// new function.
+  ///
+  /// The new function may also reference the original function.
+  /// It may end up in a parent SCC in the case that the original function's
+  /// edge to the new function is a ref edge, and the edge back is a call edge.
+  void addSplitFunction(Function &OriginalFunction, Function &NewFunction);
+
+  /// Add new ref-recursive functions split/outlined from an existing function.
+  ///
+  /// The new functions may only reference other functions that the original
+  /// function did. The new functions may reference (not call) the original
+  /// function.
+  ///
+  /// The original function must reference (not call) all new functions.
+  /// All new functions must reference (not call) each other.
+  void addSplitRefRecursiveFunctions(Function &OriginalFunction,
+                                     ArrayRef<Function *> NewFunctions);
+
   ///@}
 
   ///@{
@@ -1157,6 +1173,11 @@
   /// the NodeMap.
   Node &insertInto(Function &F, Node *&MappedN);
 
+  /// Helper to initialize a new node created outside of creating SCCs and add
+  /// it to the NodeMap if necessary. For example, useful when a function is
+  /// split.
+  Node &initNode(Function &F);
+
   /// Helper to update pointers back to the graph object during moves.
   void updateGraphPtrs();
 
@@ -1267,7 +1288,12 @@
   /// This just builds the set of entry points to the call graph. The rest is
   /// built lazily as it is walked.
   LazyCallGraph run(Module &M, ModuleAnalysisManager &AM) {
-    return LazyCallGraph(M, AM.getResult<TargetLibraryAnalysis>(M));
+    FunctionAnalysisManager &FAM =
+        AM.getResult<FunctionAnalysisManagerModuleProxy>(M).getManager();
+    auto GetTLI = [&FAM](Function &F) -> TargetLibraryInfo & {
+      return FAM.getResult<TargetLibraryAnalysis>(F);
+    };
+    return LazyCallGraph(M, GetTLI);
   }
 };
 
diff --git a/linux-x64/clang/include/llvm/Analysis/LazyValueInfo.h b/linux-x64/clang/include/llvm/Analysis/LazyValueInfo.h
index 570a504..363cb49 100644
--- a/linux-x64/clang/include/llvm/Analysis/LazyValueInfo.h
+++ b/linux-x64/clang/include/llvm/Analysis/LazyValueInfo.h
@@ -33,18 +33,17 @@
   AssumptionCache *AC = nullptr;
   const DataLayout *DL = nullptr;
   class TargetLibraryInfo *TLI = nullptr;
-  DominatorTree *DT = nullptr;
   void *PImpl = nullptr;
   LazyValueInfo(const LazyValueInfo&) = delete;
   void operator=(const LazyValueInfo&) = delete;
 public:
   ~LazyValueInfo();
   LazyValueInfo() {}
-  LazyValueInfo(AssumptionCache *AC_, const DataLayout *DL_, TargetLibraryInfo *TLI_,
-                DominatorTree *DT_)
-      : AC(AC_), DL(DL_), TLI(TLI_), DT(DT_) {}
+  LazyValueInfo(AssumptionCache *AC_, const DataLayout *DL_,
+                TargetLibraryInfo *TLI_)
+      : AC(AC_), DL(DL_), TLI(TLI_) {}
   LazyValueInfo(LazyValueInfo &&Arg)
-      : AC(Arg.AC), DL(Arg.DL), TLI(Arg.TLI), DT(Arg.DT), PImpl(Arg.PImpl) {
+      : AC(Arg.AC), DL(Arg.DL), TLI(Arg.TLI), PImpl(Arg.PImpl) {
     Arg.PImpl = nullptr;
   }
   LazyValueInfo &operator=(LazyValueInfo &&Arg) {
@@ -52,7 +51,6 @@
     AC = Arg.AC;
     DL = Arg.DL;
     TLI = Arg.TLI;
-    DT = Arg.DT;
     PImpl = Arg.PImpl;
     Arg.PImpl = nullptr;
     return *this;
@@ -73,19 +71,21 @@
                               Instruction *CxtI = nullptr);
 
   /// Determine whether the specified value comparison with a constant is known
-  /// to be true or false at the specified instruction
-  /// (from an assume intrinsic). Pred is a CmpInst predicate.
+  /// to be true or false at the specified instruction.
+  /// \p Pred is a CmpInst predicate. If \p UseBlockValue is true, the block
+  /// value is also taken into account.
   Tristate getPredicateAt(unsigned Pred, Value *V, Constant *C,
-                          Instruction *CxtI);
+                          Instruction *CxtI, bool UseBlockValue = false);
 
-  /// Determine whether the specified value is known to be a
-  /// constant at the end of the specified block.  Return null if not.
-  Constant *getConstant(Value *V, BasicBlock *BB, Instruction *CxtI = nullptr);
+  /// Determine whether the specified value is known to be a constant at the
+  /// specified instruction. Return null if not.
+  Constant *getConstant(Value *V, Instruction *CxtI);
 
   /// Return the ConstantRange constraint that is known to hold for the
-  /// specified value at the end of the specified block. This may only be called
+  /// specified value at the specified instruction. This may only be called
   /// on integer-typed Values.
-  ConstantRange getConstantRange(Value *V, BasicBlock *BB, Instruction *CxtI = nullptr);
+  ConstantRange getConstantRange(Value *V, Instruction *CxtI,
+                                 bool UndefAllowed = true);
 
   /// Determine whether the specified value is known to be a
   /// constant on the specified edge.  Return null if not.
@@ -108,17 +108,9 @@
 
   /// Print the \LazyValueInfo Analysis.
   /// We pass in the DTree that is required for identifying which basic blocks
-  /// we can solve/print for, in the LVIPrinter. The DT is optional
-  /// in LVI, so we need to pass it here as an argument.
+  /// we can solve/print for, in the LVIPrinter.
   void printLVI(Function &F, DominatorTree &DTree, raw_ostream &OS);
 
-  /// Disables use of the DominatorTree within LVI.
-  void disableDT();
-
-  /// Enables use of the DominatorTree within LVI. Does nothing if the class
-  /// instance was initialized without a DT pointer.
-  void enableDT();
-
   // For old PM pass. Delete once LazyValueInfoWrapperPass is gone.
   void releaseMemory();
 
@@ -144,9 +136,7 @@
   void operator=(const LazyValueInfoWrapperPass&) = delete;
 public:
   static char ID;
-  LazyValueInfoWrapperPass() : FunctionPass(ID) {
-    initializeLazyValueInfoWrapperPassPass(*PassRegistry::getPassRegistry());
-  }
+  LazyValueInfoWrapperPass();
   ~LazyValueInfoWrapperPass() override {
     assert(!Info.PImpl && "releaseMemory not called");
   }
diff --git a/linux-x64/clang/include/llvm/Analysis/LegacyDivergenceAnalysis.h b/linux-x64/clang/include/llvm/Analysis/LegacyDivergenceAnalysis.h
index 0a338b8..15400f5 100644
--- a/linux-x64/clang/include/llvm/Analysis/LegacyDivergenceAnalysis.h
+++ b/linux-x64/clang/include/llvm/Analysis/LegacyDivergenceAnalysis.h
@@ -16,20 +16,23 @@
 #define LLVM_ANALYSIS_LEGACY_DIVERGENCE_ANALYSIS_H
 
 #include "llvm/ADT/DenseSet.h"
-#include "llvm/IR/Function.h"
 #include "llvm/Pass.h"
-#include "llvm/Analysis/DivergenceAnalysis.h"
+#include <memory>
 
 namespace llvm {
-class Value;
+class Function;
 class GPUDivergenceAnalysis;
+class Module;
+class raw_ostream;
+class TargetTransformInfo;
+class Use;
+class Value;
+
 class LegacyDivergenceAnalysis : public FunctionPass {
 public:
   static char ID;
 
-  LegacyDivergenceAnalysis() : FunctionPass(ID) {
-    initializeLegacyDivergenceAnalysisPass(*PassRegistry::getPassRegistry());
-  }
+  LegacyDivergenceAnalysis();
 
   void getAnalysisUsage(AnalysisUsage &AU) const override;
 
@@ -39,29 +42,34 @@
   void print(raw_ostream &OS, const Module *) const override;
 
   // Returns true if V is divergent at its definition.
-  //
-  // Even if this function returns false, V may still be divergent when used
-  // in a different basic block.
   bool isDivergent(const Value *V) const;
 
+  // Returns true if U is divergent. Uses of a uniform value can be divergent.
+  bool isDivergentUse(const Use *U) const;
+
   // Returns true if V is uniform/non-divergent.
-  //
-  // Even if this function returns true, V may still be divergent when used
-  // in a different basic block.
   bool isUniform(const Value *V) const { return !isDivergent(V); }
 
+  // Returns true if U is uniform/non-divergent. Uses of a uniform value can be
+  // divergent.
+  bool isUniformUse(const Use *U) const { return !isDivergentUse(U); }
+
   // Keep the analysis results uptodate by removing an erased value.
   void removeValue(const Value *V) { DivergentValues.erase(V); }
 
 private:
   // Whether analysis should be performed by GPUDivergenceAnalysis.
-  bool shouldUseGPUDivergenceAnalysis(const Function &F) const;
+  bool shouldUseGPUDivergenceAnalysis(const Function &F,
+                                      const TargetTransformInfo &TTI) const;
 
   // (optional) handle to new DivergenceAnalysis
   std::unique_ptr<GPUDivergenceAnalysis> gpuDA;
 
   // Stores all divergent values.
   DenseSet<const Value *> DivergentValues;
+
+  // Stores divergent uses of possibly uniform values.
+  DenseSet<const Use *> DivergentUses;
 };
 } // End llvm namespace
 
diff --git a/linux-x64/clang/include/llvm/Analysis/Lint.h b/linux-x64/clang/include/llvm/Analysis/Lint.h
index 0fea81e..6eb637e 100644
--- a/linux-x64/clang/include/llvm/Analysis/Lint.h
+++ b/linux-x64/clang/include/llvm/Analysis/Lint.h
@@ -19,30 +19,30 @@
 #ifndef LLVM_ANALYSIS_LINT_H
 #define LLVM_ANALYSIS_LINT_H
 
+#include "llvm/IR/PassManager.h"
+
 namespace llvm {
 
 class FunctionPass;
 class Module;
 class Function;
 
-/// Create a lint pass.
-///
-/// Check a module or function.
-FunctionPass *createLintPass();
+FunctionPass *createLintLegacyPassPass();
 
-/// Check a module.
+/// Lint a module.
 ///
 /// This should only be used for debugging, because it plays games with
 /// PassManagers and stuff.
-void lintModule(
-  const Module &M    ///< The module to be checked
-);
+void lintModule(const Module &M);
 
-// lintFunction - Check a function.
-void lintFunction(
-  const Function &F  ///< The function to be checked
-);
+// Lint a function.
+void lintFunction(const Function &F);
 
-} // End llvm namespace
+class LintPass : public PassInfoMixin<LintPass> {
+public:
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+};
 
-#endif
+} // namespace llvm
+
+#endif // LLVM_ANALYSIS_LINT_H
diff --git a/linux-x64/clang/include/llvm/Analysis/Loads.h b/linux-x64/clang/include/llvm/Analysis/Loads.h
index 5df6bb0..24a0561 100644
--- a/linux-x64/clang/include/llvm/Analysis/Loads.h
+++ b/linux-x64/clang/include/llvm/Analysis/Loads.h
@@ -13,14 +13,19 @@
 #ifndef LLVM_ANALYSIS_LOADS_H
 #define LLVM_ANALYSIS_LOADS_H
 
-#include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/Support/CommandLine.h"
 
 namespace llvm {
 
+class AAResults;
 class DataLayout;
+class DominatorTree;
+class Instruction;
+class LoadInst;
+class Loop;
 class MDNode;
+class ScalarEvolution;
 
 /// Return true if this is always a dereferenceable pointer. If the context
 /// instruction is specified perform context-sensitive analysis and return true
@@ -35,7 +40,8 @@
 /// performs context-sensitive analysis and returns true if the pointer is
 /// dereferenceable at the specified instruction.
 bool isDereferenceableAndAlignedPointer(const Value *V, Type *Ty,
-                                        unsigned Align, const DataLayout &DL,
+                                        MaybeAlign Alignment,
+                                        const DataLayout &DL,
                                         const Instruction *CtxI = nullptr,
                                         const DominatorTree *DT = nullptr);
 
@@ -43,7 +49,7 @@
 /// greater or equal than requested. If the context instruction is specified
 /// performs context-sensitive analysis and returns true if the pointer is
 /// dereferenceable at the specified instruction.
-bool isDereferenceableAndAlignedPointer(const Value *V, unsigned Align,
+bool isDereferenceableAndAlignedPointer(const Value *V, Align Alignment,
                                         const APInt &Size, const DataLayout &DL,
                                         const Instruction *CtxI = nullptr,
                                         const DominatorTree *DT = nullptr);
@@ -56,11 +62,22 @@
 /// If it is not obviously safe to load from the specified pointer, we do a
 /// quick local scan of the basic block containing ScanFrom, to determine if
 /// the address is already accessed.
-bool isSafeToLoadUnconditionally(Value *V, unsigned Align, APInt &Size,
+bool isSafeToLoadUnconditionally(Value *V, Align Alignment, APInt &Size,
                                  const DataLayout &DL,
                                  Instruction *ScanFrom = nullptr,
                                  const DominatorTree *DT = nullptr);
 
+/// Return true if we can prove that the given load (which is assumed to be
+/// within the specified loop) would access only dereferenceable memory, and
+/// be properly aligned on every iteration of the specified loop regardless of
+/// its placement within the loop. (i.e. does not require predication beyond
+/// that required by the the header itself and could be hoisted into the header
+/// if desired.)  This is more powerful than the variants above when the
+/// address loaded from is analyzeable by SCEV.  
+bool isDereferenceableAndAlignedInLoop(LoadInst *LI, Loop *L,
+                                       ScalarEvolution &SE,
+                                       DominatorTree &DT);
+
 /// Return true if we know that executing a load from this value cannot trap.
 ///
 /// If DT and ScanFrom are specified this method performs context-sensitive
@@ -69,7 +86,7 @@
 /// If it is not obviously safe to load from the specified pointer, we do a
 /// quick local scan of the basic block containing ScanFrom, to determine if
 /// the address is already accessed.
-bool isSafeToLoadUnconditionally(Value *V, Type *Ty, unsigned Align,
+bool isSafeToLoadUnconditionally(Value *V, Type *Ty, Align Alignment,
                                  const DataLayout &DL,
                                  Instruction *ScanFrom = nullptr,
                                  const DominatorTree *DT = nullptr);
@@ -106,7 +123,7 @@
                                 BasicBlock *ScanBB,
                                 BasicBlock::iterator &ScanFrom,
                                 unsigned MaxInstsToScan = DefMaxInstsToScan,
-                                AliasAnalysis *AA = nullptr,
+                                AAResults *AA = nullptr,
                                 bool *IsLoadCSE = nullptr,
                                 unsigned *NumScanedInst = nullptr);
 
@@ -129,15 +146,24 @@
 /// is zero, the whole block will be scanned.
 /// \param AA Optional pointer to alias analysis, to make the scan more
 /// precise.
-/// \param [out] IsLoad Whether the returned value is a load from the same
+/// \param [out] IsLoadCSE Whether the returned value is a load from the same
 /// location in memory, as opposed to the value operand of a store.
 ///
 /// \returns The found value, or nullptr if no value is found.
 Value *FindAvailablePtrLoadStore(Value *Ptr, Type *AccessTy, bool AtLeastAtomic,
                                  BasicBlock *ScanBB,
                                  BasicBlock::iterator &ScanFrom,
-                                 unsigned MaxInstsToScan, AliasAnalysis *AA,
-                                 bool *IsLoad, unsigned *NumScanedInst);
+                                 unsigned MaxInstsToScan, AAResults *AA,
+                                 bool *IsLoadCSE, unsigned *NumScanedInst);
+
+/// Returns true if a pointer value \p A can be replace with another pointer
+/// value \B if they are deemed equal through some means (e.g. information from
+/// conditions).
+/// NOTE: the current implementations is incomplete and unsound. It does not
+/// reject all invalid cases yet, but will be made stricter in the future. In
+/// particular this means returning true means unknown if replacement is safe.
+bool canReplacePointersIfEqual(Value *A, Value *B, const DataLayout &DL,
+                               Instruction *CtxI);
 }
 
 #endif
diff --git a/linux-x64/clang/include/llvm/Analysis/LoopAccessAnalysis.h b/linux-x64/clang/include/llvm/Analysis/LoopAccessAnalysis.h
index 9e9aaa3..13fbe88 100644
--- a/linux-x64/clang/include/llvm/Analysis/LoopAccessAnalysis.h
+++ b/linux-x64/clang/include/llvm/Analysis/LoopAccessAnalysis.h
@@ -15,27 +15,22 @@
 #define LLVM_ANALYSIS_LOOPACCESSANALYSIS_H
 
 #include "llvm/ADT/EquivalenceClasses.h"
-#include "llvm/ADT/Optional.h"
-#include "llvm/ADT/SetVector.h"
-#include "llvm/Analysis/AliasAnalysis.h"
-#include "llvm/Analysis/AliasSetTracker.h"
 #include "llvm/Analysis/LoopAnalysisManager.h"
 #include "llvm/Analysis/ScalarEvolutionExpressions.h"
 #include "llvm/IR/DiagnosticInfo.h"
-#include "llvm/IR/ValueHandle.h"
 #include "llvm/Pass.h"
-#include "llvm/Support/raw_ostream.h"
 
 namespace llvm {
 
-class Value;
+class AAResults;
 class DataLayout;
-class ScalarEvolution;
 class Loop;
-class SCEV;
-class SCEVUnionPredicate;
 class LoopAccessInfo;
 class OptimizationRemarkEmitter;
+class raw_ostream;
+class SCEV;
+class SCEVUnionPredicate;
+class Value;
 
 /// Collection of parameters shared beetween the Loop Vectorizer and the
 /// Loop Access Analysis.
@@ -175,7 +170,8 @@
   };
 
   MemoryDepChecker(PredicatedScalarEvolution &PSE, const Loop *L)
-      : PSE(PSE), InnermostLoop(L), AccessIdx(0), MaxSafeRegisterWidth(-1U),
+      : PSE(PSE), InnermostLoop(L), AccessIdx(0), MaxSafeDepDistBytes(0),
+        MaxSafeVectorWidthInBits(-1U),
         FoundNonConstantDistanceDependence(false),
         Status(VectorizationSafetyStatus::Safe), RecordDependences(true) {}
 
@@ -209,13 +205,21 @@
     return Status == VectorizationSafetyStatus::Safe;
   }
 
+  /// Return true if the number of elements that are safe to operate on
+  /// simultaneously is not bounded.
+  bool isSafeForAnyVectorWidth() const {
+    return MaxSafeVectorWidthInBits == UINT_MAX;
+  }
+
   /// The maximum number of bytes of a vector register we can vectorize
   /// the accesses safely with.
   uint64_t getMaxSafeDepDistBytes() { return MaxSafeDepDistBytes; }
 
   /// Return the number of elements that are safe to operate on
   /// simultaneously, multiplied by the size of the element in bits.
-  uint64_t getMaxSafeRegisterWidth() const { return MaxSafeRegisterWidth; }
+  uint64_t getMaxSafeVectorWidthInBits() const {
+    return MaxSafeVectorWidthInBits;
+  }
 
   /// In same cases when the dependency check fails we can still
   /// vectorize the loop with a dynamic array access check.
@@ -280,7 +284,7 @@
   /// operate on simultaneously, multiplied by the size of the element in bits.
   /// The size of the element is taken from the memory access that is most
   /// restrictive.
-  uint64_t MaxSafeRegisterWidth;
+  uint64_t MaxSafeVectorWidthInBits;
 
   /// If we see a non-constant dependence distance we can still try to
   /// vectorize this loop with runtime checks.
@@ -329,9 +333,45 @@
   void mergeInStatus(VectorizationSafetyStatus S);
 };
 
+class RuntimePointerChecking;
+/// A grouping of pointers. A single memcheck is required between
+/// two groups.
+struct RuntimeCheckingPtrGroup {
+  /// Create a new pointer checking group containing a single
+  /// pointer, with index \p Index in RtCheck.
+  RuntimeCheckingPtrGroup(unsigned Index, RuntimePointerChecking &RtCheck);
+
+  /// Tries to add the pointer recorded in RtCheck at index
+  /// \p Index to this pointer checking group. We can only add a pointer
+  /// to a checking group if we will still be able to get
+  /// the upper and lower bounds of the check. Returns true in case
+  /// of success, false otherwise.
+  bool addPointer(unsigned Index);
+
+  /// Constitutes the context of this pointer checking group. For each
+  /// pointer that is a member of this group we will retain the index
+  /// at which it appears in RtCheck.
+  RuntimePointerChecking &RtCheck;
+  /// The SCEV expression which represents the upper bound of all the
+  /// pointers in this group.
+  const SCEV *High;
+  /// The SCEV expression which represents the lower bound of all the
+  /// pointers in this group.
+  const SCEV *Low;
+  /// Indices of all the pointers that constitute this grouping.
+  SmallVector<unsigned, 2> Members;
+};
+
+/// A memcheck which made up of a pair of grouped pointers.
+typedef std::pair<const RuntimeCheckingPtrGroup *,
+                  const RuntimeCheckingPtrGroup *>
+    RuntimePointerCheck;
+
 /// Holds information about the memory runtime legality checks to verify
 /// that a group of pointers do not overlap.
 class RuntimePointerChecking {
+  friend struct RuntimeCheckingPtrGroup;
+
 public:
   struct PointerInfo {
     /// Holds the pointer value that we need to check.
@@ -381,59 +421,20 @@
   /// No run-time memory checking is necessary.
   bool empty() const { return Pointers.empty(); }
 
-  /// A grouping of pointers. A single memcheck is required between
-  /// two groups.
-  struct CheckingPtrGroup {
-    /// Create a new pointer checking group containing a single
-    /// pointer, with index \p Index in RtCheck.
-    CheckingPtrGroup(unsigned Index, RuntimePointerChecking &RtCheck)
-        : RtCheck(RtCheck), High(RtCheck.Pointers[Index].End),
-          Low(RtCheck.Pointers[Index].Start) {
-      Members.push_back(Index);
-    }
-
-    /// Tries to add the pointer recorded in RtCheck at index
-    /// \p Index to this pointer checking group. We can only add a pointer
-    /// to a checking group if we will still be able to get
-    /// the upper and lower bounds of the check. Returns true in case
-    /// of success, false otherwise.
-    bool addPointer(unsigned Index);
-
-    /// Constitutes the context of this pointer checking group. For each
-    /// pointer that is a member of this group we will retain the index
-    /// at which it appears in RtCheck.
-    RuntimePointerChecking &RtCheck;
-    /// The SCEV expression which represents the upper bound of all the
-    /// pointers in this group.
-    const SCEV *High;
-    /// The SCEV expression which represents the lower bound of all the
-    /// pointers in this group.
-    const SCEV *Low;
-    /// Indices of all the pointers that constitute this grouping.
-    SmallVector<unsigned, 2> Members;
-  };
-
-  /// A memcheck which made up of a pair of grouped pointers.
-  ///
-  /// These *have* to be const for now, since checks are generated from
-  /// CheckingPtrGroups in LAI::addRuntimeChecks which is a const member
-  /// function.  FIXME: once check-generation is moved inside this class (after
-  /// the PtrPartition hack is removed), we could drop const.
-  typedef std::pair<const CheckingPtrGroup *, const CheckingPtrGroup *>
-      PointerCheck;
-
   /// Generate the checks and store it.  This also performs the grouping
   /// of pointers to reduce the number of memchecks necessary.
   void generateChecks(MemoryDepChecker::DepCandidates &DepCands,
                       bool UseDependencies);
 
   /// Returns the checks that generateChecks created.
-  const SmallVector<PointerCheck, 4> &getChecks() const { return Checks; }
+  const SmallVectorImpl<RuntimePointerCheck> &getChecks() const {
+    return Checks;
+  }
 
   /// Decide if we need to add a check between two groups of pointers,
   /// according to needsChecking.
-  bool needsChecking(const CheckingPtrGroup &M,
-                     const CheckingPtrGroup &N) const;
+  bool needsChecking(const RuntimeCheckingPtrGroup &M,
+                     const RuntimeCheckingPtrGroup &N) const;
 
   /// Returns the number of run-time checks required according to
   /// needsChecking.
@@ -443,7 +444,8 @@
   void print(raw_ostream &OS, unsigned Depth = 0) const;
 
   /// Print \p Checks.
-  void printChecks(raw_ostream &OS, const SmallVectorImpl<PointerCheck> &Checks,
+  void printChecks(raw_ostream &OS,
+                   const SmallVectorImpl<RuntimePointerCheck> &Checks,
                    unsigned Depth = 0) const;
 
   /// This flag indicates if we need to add the runtime check.
@@ -453,7 +455,7 @@
   SmallVector<PointerInfo, 2> Pointers;
 
   /// Holds a partitioning of pointers into "check groups".
-  SmallVector<CheckingPtrGroup, 2> CheckingGroups;
+  SmallVector<RuntimeCheckingPtrGroup, 2> CheckingGroups;
 
   /// Check if pointers are in the same partition
   ///
@@ -472,6 +474,8 @@
     return Pointers[PtrIdx];
   }
 
+  ScalarEvolution *getSE() const { return SE; }
+
 private:
   /// Groups pointers such that a single memcheck is required
   /// between two different groups. This will clear the CheckingGroups vector
@@ -481,15 +485,14 @@
                    bool UseDependencies);
 
   /// Generate the checks and return them.
-  SmallVector<PointerCheck, 4>
-  generateChecks() const;
+  SmallVector<RuntimePointerCheck, 4> generateChecks() const;
 
   /// Holds a pointer to the ScalarEvolution analysis.
   ScalarEvolution *SE;
 
   /// Set of run-time checks required to establish independence of
   /// otherwise may-aliasing pointers in the loop.
-  SmallVector<PointerCheck, 4> Checks;
+  SmallVector<RuntimePointerCheck, 4> Checks;
 };
 
 /// Drive the analysis of memory accesses in the loop
@@ -516,7 +519,7 @@
 class LoopAccessInfo {
 public:
   LoopAccessInfo(Loop *L, ScalarEvolution *SE, const TargetLibraryInfo *TLI,
-                 AliasAnalysis *AA, DominatorTree *DT, LoopInfo *LI);
+                 AAResults *AA, DominatorTree *DT, LoopInfo *LI);
 
   /// Return true we can analyze the memory accesses in the loop and there are
   /// no memory dependence cycles.
@@ -549,24 +552,6 @@
   unsigned getNumStores() const { return NumStores; }
   unsigned getNumLoads() const { return NumLoads;}
 
-  /// Add code that checks at runtime if the accessed arrays overlap.
-  ///
-  /// Returns a pair of instructions where the first element is the first
-  /// instruction generated in possibly a sequence of instructions and the
-  /// second value is the final comparator value or NULL if no check is needed.
-  std::pair<Instruction *, Instruction *>
-  addRuntimeChecks(Instruction *Loc) const;
-
-  /// Generete the instructions for the checks in \p PointerChecks.
-  ///
-  /// Returns a pair of instructions where the first element is the first
-  /// instruction generated in possibly a sequence of instructions and the
-  /// second value is the final comparator value or NULL if no check is needed.
-  std::pair<Instruction *, Instruction *>
-  addRuntimeChecks(Instruction *Loc,
-                   const SmallVectorImpl<RuntimePointerChecking::PointerCheck>
-                       &PointerChecks) const;
-
   /// The diagnostics report generated for the analysis.  E.g. why we
   /// couldn't analyze the loop.
   const OptimizationRemarkAnalysis *getReport() const { return Report.get(); }
@@ -607,7 +592,7 @@
 
 private:
   /// Analyze the loop.
-  void analyzeLoop(AliasAnalysis *AA, LoopInfo *LI,
+  void analyzeLoop(AAResults *AA, LoopInfo *LI,
                    const TargetLibraryInfo *TLI, DominatorTree *DT);
 
   /// Check if the structure of the loop allows it to be analyzed by this
@@ -724,9 +709,7 @@
 public:
   static char ID;
 
-  LoopAccessLegacyAnalysis() : FunctionPass(ID) {
-    initializeLoopAccessLegacyAnalysisPass(*PassRegistry::getPassRegistry());
-  }
+  LoopAccessLegacyAnalysis();
 
   bool runOnFunction(Function &F) override;
 
@@ -750,11 +733,11 @@
   DenseMap<Loop *, std::unique_ptr<LoopAccessInfo>> LoopAccessInfoMap;
 
   // The used analysis passes.
-  ScalarEvolution *SE;
-  const TargetLibraryInfo *TLI;
-  AliasAnalysis *AA;
-  DominatorTree *DT;
-  LoopInfo *LI;
+  ScalarEvolution *SE = nullptr;
+  const TargetLibraryInfo *TLI = nullptr;
+  AAResults *AA = nullptr;
+  DominatorTree *DT = nullptr;
+  LoopInfo *LI = nullptr;
 };
 
 /// This analysis provides dependence information for the memory
diff --git a/linux-x64/clang/include/llvm/Analysis/LoopAnalysisManager.h b/linux-x64/clang/include/llvm/Analysis/LoopAnalysisManager.h
index 368a810..11dbd15 100644
--- a/linux-x64/clang/include/llvm/Analysis/LoopAnalysisManager.h
+++ b/linux-x64/clang/include/llvm/Analysis/LoopAnalysisManager.h
@@ -30,22 +30,21 @@
 #define LLVM_ANALYSIS_LOOPANALYSISMANAGER_H
 
 #include "llvm/ADT/PostOrderIterator.h"
-#include "llvm/ADT/PriorityWorklist.h"
-#include "llvm/ADT/STLExtras.h"
-#include "llvm/Analysis/AliasAnalysis.h"
-#include "llvm/Analysis/BasicAliasAnalysis.h"
-#include "llvm/Analysis/GlobalsModRef.h"
-#include "llvm/Analysis/LoopInfo.h"
-#include "llvm/Analysis/MemorySSA.h"
-#include "llvm/Analysis/ScalarEvolution.h"
-#include "llvm/Analysis/ScalarEvolutionAliasAnalysis.h"
-#include "llvm/Analysis/TargetLibraryInfo.h"
-#include "llvm/Analysis/TargetTransformInfo.h"
-#include "llvm/IR/Dominators.h"
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 
+class AAResults;
+class AssumptionCache;
+class DominatorTree;
+class Function;
+class Loop;
+class LoopInfo;
+class MemorySSA;
+class ScalarEvolution;
+class TargetLibraryInfo;
+class TargetTransformInfo;
+
 /// The adaptor from a function pass to a loop pass computes these analyses and
 /// makes them available to the loop passes "for free". Each loop pass is
 /// expected expected to update these analyses if necessary to ensure they're
@@ -58,6 +57,7 @@
   ScalarEvolution &SE;
   TargetLibraryInfo &TLI;
   TargetTransformInfo &TTI;
+  BlockFrequencyInfo *BFI;
   MemorySSA *MSSA;
 };
 
@@ -86,8 +86,9 @@
 template <> class LoopAnalysisManagerFunctionProxy::Result {
 public:
   explicit Result(LoopAnalysisManager &InnerAM, LoopInfo &LI)
-      : InnerAM(&InnerAM), LI(&LI) {}
-  Result(Result &&Arg) : InnerAM(std::move(Arg.InnerAM)), LI(Arg.LI) {
+      : InnerAM(&InnerAM), LI(&LI), MSSAUsed(false) {}
+  Result(Result &&Arg)
+      : InnerAM(std::move(Arg.InnerAM)), LI(Arg.LI), MSSAUsed(Arg.MSSAUsed) {
     // We have to null out the analysis manager in the moved-from state
     // because we are taking ownership of the responsibilty to clear the
     // analysis state.
@@ -96,6 +97,7 @@
   Result &operator=(Result &&RHS) {
     InnerAM = RHS.InnerAM;
     LI = RHS.LI;
+    MSSAUsed = RHS.MSSAUsed;
     // We have to null out the analysis manager in the moved-from state
     // because we are taking ownership of the responsibilty to clear the
     // analysis state.
@@ -112,6 +114,9 @@
     InnerAM->clear();
   }
 
+  /// Mark MemorySSA as used so we can invalidate self if MSSA is invalidated.
+  void markMSSAUsed() { MSSAUsed = true; }
+
   /// Accessor for the analysis manager.
   LoopAnalysisManager &getManager() { return *InnerAM; }
 
@@ -130,6 +135,7 @@
 private:
   LoopAnalysisManager *InnerAM;
   LoopInfo *LI;
+  bool MSSAUsed;
 };
 
 /// Provide a specialized run method for the \c LoopAnalysisManagerFunctionProxy
diff --git a/linux-x64/clang/include/llvm/Analysis/LoopCacheAnalysis.h b/linux-x64/clang/include/llvm/Analysis/LoopCacheAnalysis.h
new file mode 100644
index 0000000..e8f2205
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Analysis/LoopCacheAnalysis.h
@@ -0,0 +1,282 @@
+//===- llvm/Analysis/LoopCacheAnalysis.h ------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file defines the interface for the loop cache analysis.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_ANALYSIS_LOOPCACHEANALYSIS_H
+#define LLVM_ANALYSIS_LOOPCACHEANALYSIS_H
+
+#include "llvm/Analysis/LoopAnalysisManager.h"
+#include "llvm/IR/Instructions.h"
+#include "llvm/IR/PassManager.h"
+#include "llvm/Support/raw_ostream.h"
+
+namespace llvm {
+
+class AAResults;
+class DependenceInfo;
+class LPMUpdater;
+class ScalarEvolution;
+class SCEV;
+class TargetTransformInfo;
+
+using CacheCostTy = int64_t;
+using LoopVectorTy = SmallVector<Loop *, 8>;
+
+/// Represents a memory reference as a base pointer and a set of indexing
+/// operations. For example given the array reference A[i][2j+1][3k+2] in a
+/// 3-dim loop nest:
+///   for(i=0;i<n;++i)
+///     for(j=0;j<m;++j)
+///       for(k=0;k<o;++k)
+///         ... A[i][2j+1][3k+2] ...
+/// We expect:
+///   BasePointer -> A
+///   Subscripts -> [{0,+,1}<%for.i>][{1,+,2}<%for.j>][{2,+,3}<%for.k>]
+///   Sizes -> [m][o][4]
+class IndexedReference {
+  friend raw_ostream &operator<<(raw_ostream &OS, const IndexedReference &R);
+
+public:
+  /// Construct an indexed reference given a \p StoreOrLoadInst instruction.
+  IndexedReference(Instruction &StoreOrLoadInst, const LoopInfo &LI,
+                   ScalarEvolution &SE);
+
+  bool isValid() const { return IsValid; }
+  const SCEV *getBasePointer() const { return BasePointer; }
+  size_t getNumSubscripts() const { return Subscripts.size(); }
+  const SCEV *getSubscript(unsigned SubNum) const {
+    assert(SubNum < getNumSubscripts() && "Invalid subscript number");
+    return Subscripts[SubNum];
+  }
+  const SCEV *getFirstSubscript() const {
+    assert(!Subscripts.empty() && "Expecting non-empty container");
+    return Subscripts.front();
+  }
+  const SCEV *getLastSubscript() const {
+    assert(!Subscripts.empty() && "Expecting non-empty container");
+    return Subscripts.back();
+  }
+
+  /// Return true/false if the current object and the indexed reference \p Other
+  /// are/aren't in the same cache line of size \p CLS. Two references are in
+  /// the same chace line iff the distance between them in the innermost
+  /// dimension is less than the cache line size. Return None if unsure.
+  Optional<bool> hasSpacialReuse(const IndexedReference &Other, unsigned CLS,
+                                 AAResults &AA) const;
+
+  /// Return true if the current object and the indexed reference \p Other
+  /// have distance smaller than \p MaxDistance in the dimension associated with
+  /// the given loop \p L. Return false if the distance is not smaller than \p
+  /// MaxDistance and None if unsure.
+  Optional<bool> hasTemporalReuse(const IndexedReference &Other,
+                                  unsigned MaxDistance, const Loop &L,
+                                  DependenceInfo &DI, AAResults &AA) const;
+
+  /// Compute the cost of the reference w.r.t. the given loop \p L when it is
+  /// considered in the innermost position in the loop nest.
+  /// The cost is defined as:
+  ///   - equal to one if the reference is loop invariant, or
+  ///   - equal to '(TripCount * stride) / cache_line_size' if:
+  ///     + the reference stride is less than the cache line size, and
+  ///     + the coefficient of this loop's index variable used in all other
+  ///       subscripts is zero
+  ///   - or otherwise equal to 'TripCount'.
+  CacheCostTy computeRefCost(const Loop &L, unsigned CLS) const;
+
+private:
+  /// Attempt to delinearize the indexed reference.
+  bool delinearize(const LoopInfo &LI);
+
+  /// Return true if the index reference is invariant with respect to loop \p L.
+  bool isLoopInvariant(const Loop &L) const;
+
+  /// Return true if the indexed reference is 'consecutive' in loop \p L.
+  /// An indexed reference is 'consecutive' if the only coefficient that uses
+  /// the loop induction variable is the rightmost one, and the access stride is
+  /// smaller than the cache line size \p CLS.
+  bool isConsecutive(const Loop &L, unsigned CLS) const;
+
+  /// Return the coefficient used in the rightmost dimension.
+  const SCEV *getLastCoefficient() const;
+
+  /// Return true if the coefficient corresponding to induction variable of
+  /// loop \p L in the given \p Subscript is zero or is loop invariant in \p L.
+  bool isCoeffForLoopZeroOrInvariant(const SCEV &Subscript,
+                                     const Loop &L) const;
+
+  /// Verify that the given \p Subscript is 'well formed' (must be a simple add
+  /// recurrence).
+  bool isSimpleAddRecurrence(const SCEV &Subscript, const Loop &L) const;
+
+  /// Return true if the given reference \p Other is definetely aliased with
+  /// the indexed reference represented by this class.
+  bool isAliased(const IndexedReference &Other, AAResults &AA) const;
+
+private:
+  /// True if the reference can be delinearized, false otherwise.
+  bool IsValid = false;
+
+  /// Represent the memory reference instruction.
+  Instruction &StoreOrLoadInst;
+
+  /// The base pointer of the memory reference.
+  const SCEV *BasePointer = nullptr;
+
+  /// The subscript (indexes) of the memory reference.
+  SmallVector<const SCEV *, 3> Subscripts;
+
+  /// The dimensions of the memory reference.
+  SmallVector<const SCEV *, 3> Sizes;
+
+  ScalarEvolution &SE;
+};
+
+/// A reference group represents a set of memory references that exhibit
+/// temporal or spacial reuse. Two references belong to the same
+/// reference group with respect to a inner loop L iff:
+/// 1. they have a loop independent dependency, or
+/// 2. they have a loop carried dependence with a small dependence distance
+///    (e.g. less than 2) carried by the inner loop, or
+/// 3. they refer to the same array, and the subscript in their innermost
+///    dimension is less than or equal to 'd' (where 'd' is less than the cache
+///    line size)
+///
+/// Intuitively a reference group represents memory references that access
+/// the same cache line. Conditions 1,2 above account for temporal reuse, while
+/// contition 3 accounts for spacial reuse.
+using ReferenceGroupTy = SmallVector<std::unique_ptr<IndexedReference>, 8>;
+using ReferenceGroupsTy = SmallVector<ReferenceGroupTy, 8>;
+
+/// \c CacheCost represents the estimated cost of a inner loop as the number of
+/// cache lines used by the memory references it contains.
+/// The 'cache cost' of a loop 'L' in a loop nest 'LN' is computed as the sum of
+/// the cache costs of all of its reference groups when the loop is considered
+/// to be in the innermost position in the nest.
+/// A reference group represents memory references that fall into the same cache
+/// line. Each reference group is analysed with respect to the innermost loop in
+/// a loop nest. The cost of a reference is defined as follow:
+///  - one if it is loop invariant w.r.t the innermost loop,
+///  - equal to the loop trip count divided by the cache line times the
+///    reference stride if the reference stride is less than the cache line
+///    size (CLS), and the coefficient of this loop's index variable used in all
+///    other subscripts is zero (e.g. RefCost = TripCount/(CLS/RefStride))
+///  - equal to the innermost loop trip count if the reference stride is greater
+///    or equal to the cache line size CLS.
+class CacheCost {
+  friend raw_ostream &operator<<(raw_ostream &OS, const CacheCost &CC);
+  using LoopTripCountTy = std::pair<const Loop *, unsigned>;
+  using LoopCacheCostTy = std::pair<const Loop *, CacheCostTy>;
+
+public:
+  static CacheCostTy constexpr InvalidCost = -1;
+
+  /// Construct a CacheCost object for the loop nest described by \p Loops.
+  /// The optional parameter \p TRT can be used to specify the max. distance
+  /// between array elements accessed in a loop so that the elements are
+  /// classified to have temporal reuse.
+  CacheCost(const LoopVectorTy &Loops, const LoopInfo &LI, ScalarEvolution &SE,
+            TargetTransformInfo &TTI, AAResults &AA, DependenceInfo &DI,
+            Optional<unsigned> TRT = None);
+
+  /// Create a CacheCost for the loop nest rooted by \p Root.
+  /// The optional parameter \p TRT can be used to specify the max. distance
+  /// between array elements accessed in a loop so that the elements are
+  /// classified to have temporal reuse.
+  static std::unique_ptr<CacheCost>
+  getCacheCost(Loop &Root, LoopStandardAnalysisResults &AR, DependenceInfo &DI,
+               Optional<unsigned> TRT = None);
+
+  /// Return the estimated cost of loop \p L if the given loop is part of the
+  /// loop nest associated with this object. Return -1 otherwise.
+  CacheCostTy getLoopCost(const Loop &L) const {
+    auto IT = llvm::find_if(LoopCosts, [&L](const LoopCacheCostTy &LCC) {
+      return LCC.first == &L;
+    });
+    return (IT != LoopCosts.end()) ? (*IT).second : -1;
+  }
+
+  /// Return the estimated ordered loop costs.
+  const ArrayRef<LoopCacheCostTy> getLoopCosts() const { return LoopCosts; }
+
+private:
+  /// Calculate the cache footprint of each loop in the nest (when it is
+  /// considered to be in the innermost position).
+  void calculateCacheFootprint();
+
+  /// Partition store/load instructions in the loop nest into reference groups.
+  /// Two or more memory accesses belong in the same reference group if they
+  /// share the same cache line.
+  bool populateReferenceGroups(ReferenceGroupsTy &RefGroups) const;
+
+  /// Calculate the cost of the given loop \p L assuming it is the innermost
+  /// loop in nest.
+  CacheCostTy computeLoopCacheCost(const Loop &L,
+                                   const ReferenceGroupsTy &RefGroups) const;
+
+  /// Compute the cost of a representative reference in reference group \p RG
+  /// when the given loop \p L is considered as the innermost loop in the nest.
+  /// The computed cost is an estimate for the number of cache lines used by the
+  /// reference group. The representative reference cost is defined as:
+  ///   - equal to one if the reference is loop invariant, or
+  ///   - equal to '(TripCount * stride) / cache_line_size' if (a) loop \p L's
+  ///     induction variable is used only in the reference subscript associated
+  ///     with loop \p L, and (b) the reference stride is less than the cache
+  ///     line size, or
+  ///   - TripCount otherwise
+  CacheCostTy computeRefGroupCacheCost(const ReferenceGroupTy &RG,
+                                       const Loop &L) const;
+
+  /// Sort the LoopCosts vector by decreasing cache cost.
+  void sortLoopCosts() {
+    sort(LoopCosts, [](const LoopCacheCostTy &A, const LoopCacheCostTy &B) {
+      return A.second > B.second;
+    });
+  }
+
+private:
+  /// Loops in the loop nest associated with this object.
+  LoopVectorTy Loops;
+
+  /// Trip counts for the loops in the loop nest associated with this object.
+  SmallVector<LoopTripCountTy, 3> TripCounts;
+
+  /// Cache costs for the loops in the loop nest associated with this object.
+  SmallVector<LoopCacheCostTy, 3> LoopCosts;
+
+  /// The max. distance between array elements accessed in a loop so that the
+  /// elements are classified to have temporal reuse.
+  Optional<unsigned> TRT;
+
+  const LoopInfo &LI;
+  ScalarEvolution &SE;
+  TargetTransformInfo &TTI;
+  AAResults &AA;
+  DependenceInfo &DI;
+};
+
+raw_ostream &operator<<(raw_ostream &OS, const IndexedReference &R);
+raw_ostream &operator<<(raw_ostream &OS, const CacheCost &CC);
+
+/// Printer pass for the \c CacheCost results.
+class LoopCachePrinterPass : public PassInfoMixin<LoopCachePrinterPass> {
+  raw_ostream &OS;
+
+public:
+  explicit LoopCachePrinterPass(raw_ostream &OS) : OS(OS) {}
+
+  PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
+                        LoopStandardAnalysisResults &AR, LPMUpdater &U);
+};
+
+} // namespace llvm
+
+#endif // LLVM_ANALYSIS_LOOPCACHEANALYSIS_H
diff --git a/linux-x64/clang/include/llvm/Analysis/LoopInfo.h b/linux-x64/clang/include/llvm/Analysis/LoopInfo.h
index 98b3129..a5717ba 100644
--- a/linux-x64/clang/include/llvm/Analysis/LoopInfo.h
+++ b/linux-x64/clang/include/llvm/Analysis/LoopInfo.h
@@ -30,6 +30,9 @@
 // instance.  In particular, a Loop might be inside such a non-loop SCC, or a
 // non-loop SCC might contain a sub-SCC which is a Loop.
 //
+// For an overview of terminology used in this API (and thus all of our loop
+// analyses or transforms), see docs/LoopTerminology.rst.
+//
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_ANALYSIS_LOOPINFO_H
@@ -57,7 +60,6 @@
 class InductionDescriptor;
 class MDNode;
 class MemorySSAUpdater;
-class PHINode;
 class ScalarEvolution;
 class raw_ostream;
 template <class N, bool IsPostDom> class DominatorTreeBase;
@@ -100,6 +102,14 @@
     return D;
   }
   BlockT *getHeader() const { return getBlocks().front(); }
+  /// Return the parent loop if it exists or nullptr for top
+  /// level loops.
+
+  /// A loop is either top-level in a function (that is, it is not
+  /// contained in any other loop) or it is entirely enclosed in
+  /// some other loop.
+  /// If a loop is top-level, it has no parent, otherwise its
+  /// parent is the innermost loop in which it is enclosed.
   LoopT *getParentLoop() const { return ParentLoop; }
 
   /// This is a raw interface for bypassing addChildLoop.
@@ -145,7 +155,17 @@
   iterator end() const { return getSubLoops().end(); }
   reverse_iterator rbegin() const { return getSubLoops().rbegin(); }
   reverse_iterator rend() const { return getSubLoops().rend(); }
-  bool empty() const { return getSubLoops().empty(); }
+
+  // LoopInfo does not detect irreducible control flow, just natural
+  // loops. That is, it is possible that there is cyclic control
+  // flow within the "innermost loop" or around the "outermost
+  // loop".
+
+  /// Return true if the loop does not contain any (natural) loops.
+  bool isInnermost() const { return getSubLoops().empty(); }
+  /// Return true if the loop does not have a parent (natural) loop
+  // (i.e. it is outermost, which is the same as top-level).
+  bool isOutermost() const { return getParentLoop() == nullptr; }
 
   /// Get a list of the basic blocks which make up this loop.
   ArrayRef<BlockT *> getBlocks() const {
@@ -205,7 +225,7 @@
   bool isLoopExiting(const BlockT *BB) const {
     assert(!isInvalid() && "Loop not in a valid state!");
     assert(contains(BB) && "Exiting block must be part of the loop");
-    for (const auto &Succ : children<const BlockT *>(BB)) {
+    for (const auto *Succ : children<const BlockT *>(BB)) {
       if (!contains(Succ))
         return true;
     }
@@ -270,14 +290,21 @@
 
   /// Return all unique successor blocks of this loop.
   /// These are the blocks _outside of the current loop_ which are branched to.
-  /// This assumes that loop exits are in canonical form, i.e. all exits are
-  /// dedicated exits.
   void getUniqueExitBlocks(SmallVectorImpl<BlockT *> &ExitBlocks) const;
 
+  /// Return all unique successor blocks of this loop except successors from
+  /// Latch block are not considered. If the exit comes from Latch has also
+  /// non Latch predecessor in a loop it will be added to ExitBlocks.
+  /// These are the blocks _outside of the current loop_ which are branched to.
+  void getUniqueNonLatchExitBlocks(SmallVectorImpl<BlockT *> &ExitBlocks) const;
+
   /// If getUniqueExitBlocks would return exactly one block, return that block.
   /// Otherwise return null.
   BlockT *getUniqueExitBlock() const;
 
+  /// Return true if this loop does not have any exit blocks.
+  bool hasNoExitBlocks() const;
+
   /// Edge type.
   typedef std::pair<BlockT *, BlockT *> Edge;
 
@@ -566,9 +593,9 @@
   bool getIncomingAndBackEdge(BasicBlock *&Incoming,
                               BasicBlock *&Backedge) const;
 
-  /// Below are some utilities to get loop bounds and induction variable, and
-  /// check if a given phinode is an auxiliary induction variable, as well as
-  /// checking if the loop is canonical.
+  /// Below are some utilities to get the loop guard, loop bounds and induction
+  /// variable, and to check if a given phinode is an auxiliary induction
+  /// variable, if the loop is guarded, and if the loop is canonical.
   ///
   /// Here is an example:
   /// \code
@@ -600,6 +627,9 @@
   ///
   /// - getInductionVariable            --> i_1
   /// - isAuxiliaryInductionVariable(x) --> true if x == i_1
+  /// - getLoopGuardBranch()
+  ///                 --> `if (guardcmp) goto preheader; else goto afterloop`
+  /// - isGuarded()                     --> true
   /// - isCanonical                     --> false
   struct LoopBounds {
     /// Return the LoopBounds object if
@@ -721,15 +751,52 @@
   bool isAuxiliaryInductionVariable(PHINode &AuxIndVar,
                                     ScalarEvolution &SE) const;
 
+  /// Return the loop guard branch, if it exists.
+  ///
+  /// This currently only works on simplified loop, as it requires a preheader
+  /// and a latch to identify the guard. It will work on loops of the form:
+  /// \code
+  /// GuardBB:
+  ///   br cond1, Preheader, ExitSucc <== GuardBranch
+  /// Preheader:
+  ///   br Header
+  /// Header:
+  ///  ...
+  ///   br Latch
+  /// Latch:
+  ///   br cond2, Header, ExitBlock
+  /// ExitBlock:
+  ///   br ExitSucc
+  /// ExitSucc:
+  /// \endcode
+  BranchInst *getLoopGuardBranch() const;
+
+  /// Return true iff the loop is
+  /// - in simplify rotated form, and
+  /// - guarded by a loop guard branch.
+  bool isGuarded() const { return (getLoopGuardBranch() != nullptr); }
+
+  /// Return true if the loop is in rotated form.
+  ///
+  /// This does not check if the loop was rotated by loop rotation, instead it
+  /// only checks if the loop is in rotated form (has a valid latch that exists
+  /// the loop).
+  bool isRotatedForm() const {
+    assert(!isInvalid() && "Loop not in a valid state!");
+    BasicBlock *Latch = getLoopLatch();
+    return Latch && isLoopExiting(Latch);
+  }
+
   /// Return true if the loop induction variable starts at zero and increments
   /// by one each time through the loop.
   bool isCanonical(ScalarEvolution &SE) const;
 
   /// Return true if the Loop is in LCSSA form.
-  bool isLCSSAForm(DominatorTree &DT) const;
+  bool isLCSSAForm(const DominatorTree &DT) const;
 
   /// Return true if this Loop and all inner subloops are in LCSSA form.
-  bool isRecursivelyLCSSAForm(DominatorTree &DT, const LoopInfo &LI) const;
+  bool isRecursivelyLCSSAForm(const DominatorTree &DT,
+                              const LoopInfo &LI) const;
 
   /// Return true if the Loop is in the form that the LoopSimplify form
   /// transforms loops to, which is sometimes called normal form.
@@ -776,6 +843,9 @@
   /// unrolling pass is run more than once (which it generally is).
   void setLoopAlreadyUnrolled();
 
+  /// Add llvm.loop.mustprogress to this loop's loop id metadata.
+  void setLoopMustProgress();
+
   void dump() const;
   void dumpVerbose() const;
 
@@ -908,13 +978,19 @@
     return L && L->getHeader() == BB;
   }
 
+  /// Return the top-level loops.
+  const std::vector<LoopT *> &getTopLevelLoops() const { return TopLevelLoops; }
+
+  /// Return the top-level loops.
+  std::vector<LoopT *> &getTopLevelLoopsVector() { return TopLevelLoops; }
+
   /// This removes the specified top-level loop from this loop info object.
   /// The loop is not deleted, as it will presumably be inserted into
   /// another loop.
   LoopT *removeLoop(iterator I) {
     assert(I != end() && "Cannot remove end iterator!");
     LoopT *L = *I;
-    assert(!L->getParentLoop() && "Not a top-level loop!");
+    assert(L->isOutermost() && "Not a top-level loop!");
     TopLevelLoops.erase(TopLevelLoops.begin() + (I - begin()));
     return L;
   }
@@ -942,7 +1018,7 @@
 
   /// This adds the specified loop to the collection of top-level loops.
   void addTopLevelLoop(LoopT *New) {
-    assert(!New->getParentLoop() && "Loop already in subloop!");
+    assert(New->isOutermost() && "Loop already in subloop!");
     TopLevelLoops.push_back(New);
   }
 
@@ -1176,9 +1252,7 @@
 public:
   static char ID; // Pass identification, replacement for typeid
 
-  LoopInfoWrapperPass() : FunctionPass(ID) {
-    initializeLoopInfoWrapperPassPass(*PassRegistry::getPassRegistry());
-  }
+  LoopInfoWrapperPass();
 
   LoopInfo &getLoopInfo() { return LI; }
   const LoopInfo &getLoopInfo() const { return LI; }
diff --git a/linux-x64/clang/include/llvm/Analysis/LoopInfoImpl.h b/linux-x64/clang/include/llvm/Analysis/LoopInfoImpl.h
index 6ff4837..0730225 100644
--- a/linux-x64/clang/include/llvm/Analysis/LoopInfoImpl.h
+++ b/linux-x64/clang/include/llvm/Analysis/LoopInfoImpl.h
@@ -17,7 +17,6 @@
 #include "llvm/ADT/DepthFirstIterator.h"
 #include "llvm/ADT/PostOrderIterator.h"
 #include "llvm/ADT/STLExtras.h"
-#include "llvm/ADT/SetVector.h"
 #include "llvm/Analysis/LoopInfo.h"
 #include "llvm/IR/Dominators.h"
 
@@ -35,7 +34,7 @@
     SmallVectorImpl<BlockT *> &ExitingBlocks) const {
   assert(!isInvalid() && "Loop not in a valid state!");
   for (const auto BB : blocks())
-    for (const auto &Succ : children<BlockT *>(BB))
+    for (auto *Succ : children<BlockT *>(BB))
       if (!contains(Succ)) {
         // Not in current loop? It must be an exit block.
         ExitingBlocks.push_back(BB);
@@ -63,12 +62,19 @@
     SmallVectorImpl<BlockT *> &ExitBlocks) const {
   assert(!isInvalid() && "Loop not in a valid state!");
   for (const auto BB : blocks())
-    for (const auto &Succ : children<BlockT *>(BB))
+    for (auto *Succ : children<BlockT *>(BB))
       if (!contains(Succ))
         // Not in current loop? It must be an exit block.
         ExitBlocks.push_back(Succ);
 }
 
+template <class BlockT, class LoopT>
+bool LoopBase<BlockT, LoopT>::hasNoExitBlocks() const {
+  SmallVector<BlockT *, 8> ExitBlocks;
+  getExitBlocks(ExitBlocks);
+  return ExitBlocks.empty();
+}
+
 /// getExitBlock - If getExitBlocks would return exactly one block,
 /// return that block. Otherwise return null.
 template <class BlockT, class LoopT>
@@ -85,9 +91,9 @@
 bool LoopBase<BlockT, LoopT>::hasDedicatedExits() const {
   // Each predecessor of each exit block of a normal loop is contained
   // within the loop.
-  SmallVector<BlockT *, 4> ExitBlocks;
-  getExitBlocks(ExitBlocks);
-  for (BlockT *EB : ExitBlocks)
+  SmallVector<BlockT *, 4> UniqueExitBlocks;
+  getUniqueExitBlocks(UniqueExitBlocks);
+  for (BlockT *EB : UniqueExitBlocks)
     for (BlockT *Predecessor : children<Inverse<BlockT *>>(EB))
       if (!contains(Predecessor))
         return false;
@@ -95,49 +101,36 @@
   return true;
 }
 
+// Helper function to get unique loop exits. Pred is a predicate pointing to
+// BasicBlocks in a loop which should be considered to find loop exits.
+template <class BlockT, class LoopT, typename PredicateT>
+void getUniqueExitBlocksHelper(const LoopT *L,
+                               SmallVectorImpl<BlockT *> &ExitBlocks,
+                               PredicateT Pred) {
+  assert(!L->isInvalid() && "Loop not in a valid state!");
+  SmallPtrSet<BlockT *, 32> Visited;
+  auto Filtered = make_filter_range(L->blocks(), Pred);
+  for (BlockT *BB : Filtered)
+    for (BlockT *Successor : children<BlockT *>(BB))
+      if (!L->contains(Successor))
+        if (Visited.insert(Successor).second)
+          ExitBlocks.push_back(Successor);
+}
+
 template <class BlockT, class LoopT>
 void LoopBase<BlockT, LoopT>::getUniqueExitBlocks(
     SmallVectorImpl<BlockT *> &ExitBlocks) const {
-  typedef GraphTraits<BlockT *> BlockTraits;
-  typedef GraphTraits<Inverse<BlockT *>> InvBlockTraits;
+  getUniqueExitBlocksHelper(this, ExitBlocks,
+                            [](const BlockT *BB) { return true; });
+}
 
-  assert(hasDedicatedExits() &&
-         "getUniqueExitBlocks assumes the loop has canonical form exits!");
-
-  SmallVector<BlockT *, 32> SwitchExitBlocks;
-  for (BlockT *Block : this->blocks()) {
-    SwitchExitBlocks.clear();
-    for (BlockT *Successor : children<BlockT *>(Block)) {
-      // If block is inside the loop then it is not an exit block.
-      if (contains(Successor))
-        continue;
-
-      BlockT *FirstPred = *InvBlockTraits::child_begin(Successor);
-
-      // If current basic block is this exit block's first predecessor then only
-      // insert exit block in to the output ExitBlocks vector. This ensures that
-      // same exit block is not inserted twice into ExitBlocks vector.
-      if (Block != FirstPred)
-        continue;
-
-      // If a terminator has more then two successors, for example SwitchInst,
-      // then it is possible that there are multiple edges from current block to
-      // one exit block.
-      if (std::distance(BlockTraits::child_begin(Block),
-                        BlockTraits::child_end(Block)) <= 2) {
-        ExitBlocks.push_back(Successor);
-        continue;
-      }
-
-      // In case of multiple edges from current block to exit block, collect
-      // only one edge in ExitBlocks. Use switchExitBlocks to keep track of
-      // duplicate edges.
-      if (!is_contained(SwitchExitBlocks, Successor)) {
-        SwitchExitBlocks.push_back(Successor);
-        ExitBlocks.push_back(Successor);
-      }
-    }
-  }
+template <class BlockT, class LoopT>
+void LoopBase<BlockT, LoopT>::getUniqueNonLatchExitBlocks(
+    SmallVectorImpl<BlockT *> &ExitBlocks) const {
+  const BlockT *Latch = getLoopLatch();
+  assert(Latch && "Latch block must exists");
+  getUniqueExitBlocksHelper(this, ExitBlocks,
+                            [Latch](const BlockT *BB) { return BB != Latch; });
 }
 
 template <class BlockT, class LoopT>
@@ -155,7 +148,7 @@
     SmallVectorImpl<Edge> &ExitEdges) const {
   assert(!isInvalid() && "Loop not in a valid state!");
   for (const auto BB : blocks())
-    for (const auto &Succ : children<BlockT *>(BB))
+    for (auto *Succ : children<BlockT *>(BB))
       if (!contains(Succ))
         // Not in current loop? It must be an exit block.
         ExitEdges.emplace_back(BB, Succ);
@@ -213,8 +206,6 @@
     }
   }
 
-  // Make sure there is only one exit out of the preheader.
-  assert(Out && "Header of loop has no predecessors from outside loop?");
   return Out;
 }
 
@@ -518,7 +509,7 @@
   if (Subloop && Block == Subloop->getHeader()) {
     // We reach this point once per subloop after processing all the blocks in
     // the subloop.
-    if (Subloop->getParentLoop())
+    if (!Subloop->isOutermost())
       Subloop->getParentLoop()->getSubLoopsVector().push_back(Subloop);
     else
       LI->addTopLevelLoop(Subloop);
@@ -684,10 +675,10 @@
   const SmallPtrSetImpl<const BlockT *> &BlocksSet = L->getBlocksSet();
   const SmallPtrSetImpl<const BlockT *> &OtherBlocksSet = L->getBlocksSet();
   assert(BlocksSet.size() == OtherBlocksSet.size() &&
-         std::all_of(BlocksSet.begin(), BlocksSet.end(),
-                     [&OtherBlocksSet](const BlockT *BB) {
-                       return OtherBlocksSet.count(BB);
-                     }) &&
+         llvm::all_of(BlocksSet,
+                      [&OtherBlocksSet](const BlockT *BB) {
+                        return OtherBlocksSet.count(BB);
+                      }) &&
          "Mismatched basic blocks in BlocksSets!");
 }
 #endif
@@ -697,7 +688,7 @@
     const DomTreeBase<BlockT> &DomTree) const {
   DenseSet<const LoopT *> Loops;
   for (iterator I = begin(), E = end(); I != E; ++I) {
-    assert(!(*I)->getParentLoop() && "Top-level loop has a parent!");
+    assert((*I)->isOutermost() && "Top-level loop has a parent!");
     (*I)->verifyLoopNest(&Loops);
   }
 
diff --git a/linux-x64/clang/include/llvm/Analysis/LoopNestAnalysis.h b/linux-x64/clang/include/llvm/Analysis/LoopNestAnalysis.h
new file mode 100644
index 0000000..9c4fb4d
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Analysis/LoopNestAnalysis.h
@@ -0,0 +1,175 @@
+//===- llvm/Analysis/LoopNestAnalysis.h -------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file defines the interface for the loop nest analysis.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_ANALYSIS_LOOPNESTANALYSIS_H
+#define LLVM_ANALYSIS_LOOPNESTANALYSIS_H
+
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/Analysis/LoopAnalysisManager.h"
+#include "llvm/Analysis/LoopInfo.h"
+
+namespace llvm {
+
+using LoopVectorTy = SmallVector<Loop *, 8>;
+class LPMUpdater;
+
+/// This class represents a loop nest and can be used to query its properties.
+class LoopNest {
+public:
+  /// Construct a loop nest rooted by loop \p Root.
+  LoopNest(Loop &Root, ScalarEvolution &SE);
+
+  LoopNest() = delete;
+  LoopNest &operator=(const LoopNest &) = delete;
+
+  /// Construct a LoopNest object.
+  static std::unique_ptr<LoopNest> getLoopNest(Loop &Root, ScalarEvolution &SE);
+
+  /// Return true if the given loops \p OuterLoop and \p InnerLoop are
+  /// perfectly nested with respect to each other, and false otherwise.
+  /// Example:
+  /// \code
+  ///   for(i)
+  ///     for(j)
+  ///       for(k)
+  /// \endcode
+  /// arePerfectlyNested(loop_i, loop_j, SE) would return true.
+  /// arePerfectlyNested(loop_j, loop_k, SE) would return true.
+  /// arePerfectlyNested(loop_i, loop_k, SE) would return false.
+  static bool arePerfectlyNested(const Loop &OuterLoop, const Loop &InnerLoop,
+                                 ScalarEvolution &SE);
+
+  /// Return the maximum nesting depth of the loop nest rooted by loop \p Root.
+  /// For example given the loop nest:
+  /// \code
+  ///   for(i)     // loop at level 1 and Root of the nest
+  ///     for(j)   // loop at level 2
+  ///       <code>
+  ///       for(k) // loop at level 3
+  /// \endcode
+  /// getMaxPerfectDepth(Loop_i) would return 2.
+  static unsigned getMaxPerfectDepth(const Loop &Root, ScalarEvolution &SE);
+
+  /// Recursivelly traverse all empty 'single successor' basic blocks of \p From
+  /// (if there are any). Return the last basic block found or \p End if it was
+  /// reached during the search.
+  static const BasicBlock &skipEmptyBlockUntil(const BasicBlock *From,
+                                               const BasicBlock *End);
+
+  /// Return the outermost loop in the loop nest.
+  Loop &getOutermostLoop() const { return *Loops.front(); }
+
+  /// Return the innermost loop in the loop nest if the nest has only one
+  /// innermost loop, and a nullptr otherwise.
+  /// Note: the innermost loop returned is not necessarily perfectly nested.
+  Loop *getInnermostLoop() const {
+    if (Loops.size() == 1)
+      return Loops.back();
+
+    // The loops in the 'Loops' vector have been collected in breadth first
+    // order, therefore if the last 2 loops in it have the same nesting depth
+    // there isn't a unique innermost loop in the nest.
+    Loop *LastLoop = Loops.back();
+    auto SecondLastLoopIter = ++Loops.rbegin();
+    return (LastLoop->getLoopDepth() == (*SecondLastLoopIter)->getLoopDepth())
+               ? nullptr
+               : LastLoop;
+  }
+
+  /// Return the loop at the given \p Index.
+  Loop *getLoop(unsigned Index) const {
+    assert(Index < Loops.size() && "Index is out of bounds");
+    return Loops[Index];
+  }
+
+  /// Return the number of loops in the nest.
+  size_t getNumLoops() const { return Loops.size(); }
+
+  /// Get the loops in the nest.
+  ArrayRef<Loop *> getLoops() const { return Loops; }
+
+  /// Retrieve a vector of perfect loop nests contained in the current loop
+  /// nest. For example, given the following  nest containing 4 loops, this
+  /// member function would return {{L1,L2},{L3,L4}}.
+  /// \code
+  ///   for(i) // L1
+  ///     for(j) // L2
+  ///       <code>
+  ///       for(k) // L3
+  ///         for(l) // L4
+  /// \endcode
+  SmallVector<LoopVectorTy, 4> getPerfectLoops(ScalarEvolution &SE) const;
+
+  /// Return the loop nest depth (i.e. the loop depth of the 'deepest' loop)
+  /// For example given the loop nest:
+  /// \code
+  ///   for(i)      // loop at level 1 and Root of the nest
+  ///     for(j1)   // loop at level 2
+  ///       for(k)  // loop at level 3
+  ///     for(j2)   // loop at level 2
+  /// \endcode
+  /// getNestDepth() would return 3.
+  unsigned getNestDepth() const {
+    int NestDepth =
+        Loops.back()->getLoopDepth() - Loops.front()->getLoopDepth() + 1;
+    assert(NestDepth > 0 && "Expecting NestDepth to be at least 1");
+    return NestDepth;
+  }
+
+  /// Return the maximum perfect nesting depth.
+  unsigned getMaxPerfectDepth() const { return MaxPerfectDepth; }
+
+  /// Return true if all loops in the loop nest are in simplify form.
+  bool areAllLoopsSimplifyForm() const {
+    return all_of(Loops, [](const Loop *L) { return L->isLoopSimplifyForm(); });
+  }
+
+  /// Return true if all loops in the loop nest are in rotated form.
+  bool areAllLoopsRotatedForm() const {
+    return all_of(Loops, [](const Loop *L) { return L->isRotatedForm(); });
+  }
+
+  StringRef getName() const { return Loops.front()->getName(); }
+
+protected:
+  const unsigned MaxPerfectDepth; // maximum perfect nesting depth level.
+  LoopVectorTy Loops; // the loops in the nest (in breadth first order).
+};
+
+raw_ostream &operator<<(raw_ostream &, const LoopNest &);
+
+/// This analysis provides information for a loop nest. The analysis runs on
+/// demand and can be initiated via AM.getResult<LoopNestAnalysis>.
+class LoopNestAnalysis : public AnalysisInfoMixin<LoopNestAnalysis> {
+  friend AnalysisInfoMixin<LoopNestAnalysis>;
+  static AnalysisKey Key;
+
+public:
+  using Result = LoopNest;
+  Result run(Loop &L, LoopAnalysisManager &AM, LoopStandardAnalysisResults &AR);
+};
+
+/// Printer pass for the \c LoopNest results.
+class LoopNestPrinterPass : public PassInfoMixin<LoopNestPrinterPass> {
+  raw_ostream &OS;
+
+public:
+  explicit LoopNestPrinterPass(raw_ostream &OS) : OS(OS) {}
+
+  PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
+                        LoopStandardAnalysisResults &AR, LPMUpdater &U);
+};
+
+} // namespace llvm
+
+#endif // LLVM_ANALYSIS_LOOPNESTANALYSIS_H
diff --git a/linux-x64/clang/include/llvm/Analysis/LoopPass.h b/linux-x64/clang/include/llvm/Analysis/LoopPass.h
index 9215ab3..0fd2a39 100644
--- a/linux-x64/clang/include/llvm/Analysis/LoopPass.h
+++ b/linux-x64/clang/include/llvm/Analysis/LoopPass.h
@@ -23,7 +23,6 @@
 
 class LPPassManager;
 class Function;
-class PMStack;
 
 class LoopPass : public Pass {
 public:
@@ -66,26 +65,6 @@
     return PMT_LoopPassManager;
   }
 
-  //===--------------------------------------------------------------------===//
-  /// SimpleAnalysis - Provides simple interface to update analysis info
-  /// maintained by various passes. Note, if required this interface can
-  /// be extracted into a separate abstract class but it would require
-  /// additional use of multiple inheritance in Pass class hierarchy, something
-  /// we are trying to avoid.
-
-  /// Each loop pass can override these simple analysis hooks to update
-  /// desired analysis information.
-  /// cloneBasicBlockAnalysis - Clone analysis info associated with basic block.
-  virtual void cloneBasicBlockAnalysis(BasicBlock *F, BasicBlock *T, Loop *L) {}
-
-  /// deleteAnalysisValue - Delete analysis info associated with value V.
-  virtual void deleteAnalysisValue(Value *V, Loop *L) {}
-
-  /// Delete analysis info associated with Loop L.
-  /// Called to notify a Pass that a loop has been deleted and any
-  /// associated analysis values can be deleted.
-  virtual void deleteAnalysisLoop(Loop *L) {}
-
 protected:
   /// Optional passes call this function to check whether the pass should be
   /// skipped. This is the case when Attribute::OptimizeNone is set or when
@@ -131,25 +110,6 @@
   // Mark \p L as deleted.
   void markLoopAsDeleted(Loop &L);
 
-  //===--------------------------------------------------------------------===//
-  /// SimpleAnalysis - Provides simple interface to update analysis info
-  /// maintained by various passes. Note, if required this interface can
-  /// be extracted into a separate abstract class but it would require
-  /// additional use of multiple inheritance in Pass class hierarchy, something
-  /// we are trying to avoid.
-
-  /// cloneBasicBlockSimpleAnalysis - Invoke cloneBasicBlockAnalysis hook for
-  /// all passes that implement simple analysis interface.
-  void cloneBasicBlockSimpleAnalysis(BasicBlock *From, BasicBlock *To, Loop *L);
-
-  /// deleteSimpleAnalysisValue - Invoke deleteAnalysisValue hook for all passes
-  /// that implement simple analysis interface.
-  void deleteSimpleAnalysisValue(Value *V, Loop *L);
-
-  /// Invoke deleteAnalysisLoop hook for all passes that implement simple
-  /// analysis interface.
-  void deleteSimpleAnalysisLoop(Loop *L);
-
 private:
   std::deque<Loop *> LQ;
   LoopInfo *LI;
@@ -162,9 +122,7 @@
 // pass manager calls lcssa verification for the current loop.
 struct LCSSAVerificationPass : public FunctionPass {
   static char ID;
-  LCSSAVerificationPass() : FunctionPass(ID) {
-    initializeLCSSAVerificationPassPass(*PassRegistry::getPassRegistry());
-  }
+  LCSSAVerificationPass();
 
   bool runOnFunction(Function &F) override { return false; }
 
diff --git a/linux-x64/clang/include/llvm/Analysis/MLInlineAdvisor.h b/linux-x64/clang/include/llvm/Analysis/MLInlineAdvisor.h
new file mode 100644
index 0000000..1afccf8
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Analysis/MLInlineAdvisor.h
@@ -0,0 +1,109 @@
+//===- MLInlineAdvisor.h - ML - based InlineAdvisor factories ---*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_ANALYSIS_MLINLINEADVISOR_H
+#define LLVM_ANALYSIS_MLINLINEADVISOR_H
+
+#include "llvm/Analysis/CallGraph.h"
+#include "llvm/Analysis/InlineAdvisor.h"
+#include "llvm/Analysis/MLModelRunner.h"
+#include "llvm/IR/PassManager.h"
+
+#include <memory>
+#include <unordered_map>
+
+namespace llvm {
+class Module;
+class MLInlineAdvice;
+
+class MLInlineAdvisor : public InlineAdvisor {
+public:
+  MLInlineAdvisor(Module &M, ModuleAnalysisManager &MAM,
+                  std::unique_ptr<MLModelRunner> ModelRunner);
+
+  CallGraph *callGraph() const { return CG.get(); }
+  virtual ~MLInlineAdvisor() = default;
+
+  void onPassEntry() override;
+
+  int64_t getIRSize(const Function &F) const { return F.getInstructionCount(); }
+  void onSuccessfulInlining(const MLInlineAdvice &Advice,
+                            bool CalleeWasDeleted);
+
+  bool isForcedToStop() const { return ForceStop; }
+  int64_t getLocalCalls(Function &F);
+  const MLModelRunner &getModelRunner() const { return *ModelRunner.get(); }
+
+protected:
+  std::unique_ptr<InlineAdvice> getAdviceImpl(CallBase &CB) override;
+
+  std::unique_ptr<InlineAdvice> getMandatoryAdvice(CallBase &CB,
+                                                   bool Advice) override;
+
+  virtual std::unique_ptr<MLInlineAdvice> getMandatoryAdviceImpl(CallBase &CB);
+
+  virtual std::unique_ptr<MLInlineAdvice>
+  getAdviceFromModel(CallBase &CB, OptimizationRemarkEmitter &ORE);
+
+  Module &M;
+  std::unique_ptr<MLModelRunner> ModelRunner;
+
+private:
+  int64_t getModuleIRSize() const;
+
+  std::unique_ptr<CallGraph> CG;
+
+  int64_t NodeCount = 0;
+  int64_t EdgeCount = 0;
+  std::map<const Function *, unsigned> FunctionLevels;
+  const int32_t InitialIRSize = 0;
+  int32_t CurrentIRSize = 0;
+
+  bool ForceStop = false;
+};
+
+/// InlineAdvice that tracks changes post inlining. For that reason, it only
+/// overrides the "successful inlining" extension points.
+class MLInlineAdvice : public InlineAdvice {
+public:
+  MLInlineAdvice(MLInlineAdvisor *Advisor, CallBase &CB,
+                 OptimizationRemarkEmitter &ORE, bool Recommendation)
+      : InlineAdvice(Advisor, CB, ORE, Recommendation),
+        CallerIRSize(Advisor->isForcedToStop() ? 0
+                                               : Advisor->getIRSize(*Caller)),
+        CalleeIRSize(Advisor->isForcedToStop() ? 0
+                                               : Advisor->getIRSize(*Callee)),
+        CallerAndCalleeEdges(Advisor->isForcedToStop()
+                                 ? 0
+                                 : (Advisor->getLocalCalls(*Caller) +
+                                    Advisor->getLocalCalls(*Callee))) {}
+  virtual ~MLInlineAdvice() = default;
+
+  void recordInliningImpl() override;
+  void recordInliningWithCalleeDeletedImpl() override;
+  void recordUnsuccessfulInliningImpl(const InlineResult &Result) override;
+  void recordUnattemptedInliningImpl() override;
+
+  Function *getCaller() const { return Caller; }
+  Function *getCallee() const { return Callee; }
+
+  const int64_t CallerIRSize;
+  const int64_t CalleeIRSize;
+  const int64_t CallerAndCalleeEdges;
+
+private:
+  void reportContextForRemark(DiagnosticInfoOptimizationBase &OR);
+
+  MLInlineAdvisor *getAdvisor() const {
+    return static_cast<MLInlineAdvisor *>(Advisor);
+  };
+};
+
+} // namespace llvm
+
+#endif // LLVM_ANALYSIS_MLINLINEADVISOR_H
diff --git a/linux-x64/clang/include/llvm/Analysis/MLModelRunner.h b/linux-x64/clang/include/llvm/Analysis/MLModelRunner.h
new file mode 100644
index 0000000..7cfa6ef
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Analysis/MLModelRunner.h
@@ -0,0 +1,39 @@
+//===- MLModelRunner.h ---- ML model runner interface -----------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+
+#ifndef LLVM_ANALYSIS_MLMODELRUNNER_H
+#define LLVM_ANALYSIS_MLMODELRUNNER_H
+
+#include "llvm/Analysis/InlineModelFeatureMaps.h"
+#include "llvm/IR/LLVMContext.h"
+#include "llvm/IR/PassManager.h"
+
+namespace llvm {
+
+/// MLModelRunner interface: abstraction of a mechanism for evaluating a
+/// tensorflow "saved model".
+class MLModelRunner {
+public:
+  // Disallows copy and assign.
+  MLModelRunner(const MLModelRunner &) = delete;
+  MLModelRunner &operator=(const MLModelRunner &) = delete;
+  virtual ~MLModelRunner() = default;
+
+  virtual bool run() = 0;
+  virtual void setFeature(FeatureIndex Index, int64_t Value) = 0;
+  virtual int64_t getFeature(int Index) const = 0;
+
+protected:
+  MLModelRunner(LLVMContext &Ctx) : Ctx(Ctx) {}
+
+  LLVMContext &Ctx;
+};
+} // namespace llvm
+
+#endif // LLVM_ANALYSIS_MLMODELRUNNER_H
diff --git a/linux-x64/clang/include/llvm/Analysis/MemDerefPrinter.h b/linux-x64/clang/include/llvm/Analysis/MemDerefPrinter.h
new file mode 100644
index 0000000..bafdc54
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Analysis/MemDerefPrinter.h
@@ -0,0 +1,24 @@
+//===- MemDerefPrinter.h - Printer for isDereferenceablePointer -----------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_ANALYSIS_MEMDEREFPRINTER_H
+#define LLVM_ANALYSIS_MEMDEREFPRINTER_H
+
+#include "llvm/IR/PassManager.h"
+
+namespace llvm {
+class MemDerefPrinterPass : public PassInfoMixin<MemDerefPrinterPass> {
+  raw_ostream &OS;
+
+public:
+  MemDerefPrinterPass(raw_ostream &OS) : OS(OS) {}
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+};
+} // namespace llvm
+
+#endif // LLVM_ANALYSIS_MEMDEREFPRINTER_H
diff --git a/linux-x64/clang/include/llvm/Analysis/MemoryBuiltins.h b/linux-x64/clang/include/llvm/Analysis/MemoryBuiltins.h
index 49f9e58..c542872 100644
--- a/linux-x64/clang/include/llvm/Analysis/MemoryBuiltins.h
+++ b/linux-x64/clang/include/llvm/Analysis/MemoryBuiltins.h
@@ -19,7 +19,6 @@
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/Analysis/TargetFolder.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
-#include "llvm/IR/CallSite.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/InstVisitor.h"
 #include "llvm/IR/ValueHandle.h"
@@ -48,7 +47,6 @@
 class PHINode;
 class PointerType;
 class SelectInst;
-class TargetLibraryInfo;
 class Type;
 class UndefValue;
 class Value;
@@ -58,6 +56,9 @@
 /// like).
 bool isAllocationFn(const Value *V, const TargetLibraryInfo *TLI,
                     bool LookThroughBitCast = false);
+bool isAllocationFn(const Value *V,
+                    function_ref<const TargetLibraryInfo &(Function &)> GetTLI,
+                    bool LookThroughBitCast = false);
 
 /// Tests if a value is a call or invoke to a function that returns a
 /// NoAlias pointer (including malloc/calloc/realloc/strdup-like functions).
@@ -68,6 +69,17 @@
 /// allocates uninitialized memory (such as malloc).
 bool isMallocLikeFn(const Value *V, const TargetLibraryInfo *TLI,
                     bool LookThroughBitCast = false);
+bool isMallocLikeFn(const Value *V,
+                    function_ref<const TargetLibraryInfo &(Function &)> GetTLI,
+                    bool LookThroughBitCast = false);
+
+/// Tests if a value is a call or invoke to a library function that
+/// allocates uninitialized memory with alignment (such as aligned_alloc).
+bool isAlignedAllocLikeFn(const Value *V, const TargetLibraryInfo *TLI,
+                          bool LookThroughBitCast = false);
+bool isAlignedAllocLikeFn(
+    const Value *V, function_ref<const TargetLibraryInfo &(Function &)> GetTLI,
+    bool LookThroughBitCast = false);
 
 /// Tests if a value is a call or invoke to a library function that
 /// allocates zero-filled memory (such as calloc).
@@ -93,6 +105,16 @@
 /// reallocates memory (e.g., realloc).
 bool isReallocLikeFn(const Function *F, const TargetLibraryInfo *TLI);
 
+/// Tests if a value is a call or invoke to a library function that
+/// allocates memory and throws if an allocation failed (e.g., new).
+bool isOpNewLikeFn(const Value *V, const TargetLibraryInfo *TLI,
+                     bool LookThroughBitCast = false);
+
+/// Tests if a value is a call or invoke to a library function that
+/// allocates memory (strdup, strndup).
+bool isStrdupLikeFn(const Value *V, const TargetLibraryInfo *TLI,
+                     bool LookThroughBitCast = false);
+
 //===----------------------------------------------------------------------===//
 //  malloc Call Utility Functions.
 //
@@ -100,9 +122,13 @@
 /// extractMallocCall - Returns the corresponding CallInst if the instruction
 /// is a malloc call.  Since CallInst::CreateMalloc() only creates calls, we
 /// ignore InvokeInst here.
-const CallInst *extractMallocCall(const Value *I, const TargetLibraryInfo *TLI);
-inline CallInst *extractMallocCall(Value *I, const TargetLibraryInfo *TLI) {
-  return const_cast<CallInst*>(extractMallocCall((const Value*)I, TLI));
+const CallInst *
+extractMallocCall(const Value *I,
+                  function_ref<const TargetLibraryInfo &(Function &)> GetTLI);
+inline CallInst *
+extractMallocCall(Value *I,
+                  function_ref<const TargetLibraryInfo &(Function &)> GetTLI) {
+  return const_cast<CallInst *>(extractMallocCall((const Value *)I, GetTLI));
 }
 
 /// getMallocType - Returns the PointerType resulting from the malloc call.
@@ -239,7 +265,7 @@
   // compute() should be used by external users.
   SizeOffsetType visitAllocaInst(AllocaInst &I);
   SizeOffsetType visitArgument(Argument &A);
-  SizeOffsetType visitCallSite(CallSite CS);
+  SizeOffsetType visitCallBase(CallBase &CB);
   SizeOffsetType visitConstantPointerNull(ConstantPointerNull&);
   SizeOffsetType visitExtractElementInst(ExtractElementInst &I);
   SizeOffsetType visitExtractValueInst(ExtractValueInst &I);
@@ -309,7 +335,7 @@
 
   // The individual instruction visitors should be treated as private.
   SizeOffsetEvalType visitAllocaInst(AllocaInst &I);
-  SizeOffsetEvalType visitCallSite(CallSite CS);
+  SizeOffsetEvalType visitCallBase(CallBase &CB);
   SizeOffsetEvalType visitExtractElementInst(ExtractElementInst &I);
   SizeOffsetEvalType visitExtractValueInst(ExtractValueInst &I);
   SizeOffsetEvalType visitGEPOperator(GEPOperator &GEP);
diff --git a/linux-x64/clang/include/llvm/Analysis/MemoryDependenceAnalysis.h b/linux-x64/clang/include/llvm/Analysis/MemoryDependenceAnalysis.h
index e2669c2..efde00f 100644
--- a/linux-x64/clang/include/llvm/Analysis/MemoryDependenceAnalysis.h
+++ b/linux-x64/clang/include/llvm/Analysis/MemoryDependenceAnalysis.h
@@ -19,7 +19,6 @@
 #include "llvm/ADT/PointerIntPair.h"
 #include "llvm/ADT/PointerSumType.h"
 #include "llvm/ADT/SmallPtrSet.h"
-#include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/Analysis/MemoryLocation.h"
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/Metadata.h"
@@ -35,6 +34,7 @@
 
 namespace llvm {
 
+class AAResults;
 class AssumptionCache;
 class DominatorTree;
 class Function;
@@ -302,7 +302,7 @@
     /// The maximum size of the dereferences of the pointer.
     ///
     /// May be UnknownSize if the sizes are unknown.
-    LocationSize Size = LocationSize::unknown();
+    LocationSize Size = LocationSize::afterPointer();
     /// The AA tags associated with dereferences of the pointer.
     ///
     /// The members may be null if there are no tags or conflicting tags.
@@ -355,18 +355,21 @@
   ReverseDepMapType ReverseNonLocalDeps;
 
   /// Current AA implementation, just a cache.
-  AliasAnalysis &AA;
+  AAResults &AA;
   AssumptionCache &AC;
   const TargetLibraryInfo &TLI;
   DominatorTree &DT;
   PhiValues &PV;
   PredIteratorCache PredCache;
 
+  unsigned DefaultBlockScanLimit;
+
 public:
-  MemoryDependenceResults(AliasAnalysis &AA, AssumptionCache &AC,
-                          const TargetLibraryInfo &TLI,
-                          DominatorTree &DT, PhiValues &PV)
-      : AA(AA), AC(AC), TLI(TLI), DT(DT), PV(PV) {}
+  MemoryDependenceResults(AAResults &AA, AssumptionCache &AC,
+                          const TargetLibraryInfo &TLI, DominatorTree &DT,
+                          PhiValues &PV, unsigned DefaultBlockScanLimit)
+      : AA(AA), AC(AC), TLI(TLI), DT(DT), PV(PV),
+        DefaultBlockScanLimit(DefaultBlockScanLimit) {}
 
   /// Handle invalidation in the new PM.
   bool invalidate(Function &F, const PreservedAnalyses &PA,
@@ -381,8 +384,7 @@
   ///
   /// See the class comment for more details. It is illegal to call this on
   /// non-memory instructions.
-  MemDepResult getDependency(Instruction *QueryInst,
-                             OrderedBasicBlock *OBB = nullptr);
+  MemDepResult getDependency(Instruction *QueryInst);
 
   /// Perform a full dependency query for the specified call, returning the set
   /// of blocks that the value is potentially live across.
@@ -448,14 +450,12 @@
                                         BasicBlock::iterator ScanIt,
                                         BasicBlock *BB,
                                         Instruction *QueryInst = nullptr,
-                                        unsigned *Limit = nullptr,
-                                        OrderedBasicBlock *OBB = nullptr);
+                                        unsigned *Limit = nullptr);
 
   MemDepResult
   getSimplePointerDependencyFrom(const MemoryLocation &MemLoc, bool isLoad,
                                  BasicBlock::iterator ScanIt, BasicBlock *BB,
-                                 Instruction *QueryInst, unsigned *Limit,
-                                 OrderedBasicBlock *OBB);
+                                 Instruction *QueryInst, unsigned *Limit);
 
   /// This analysis looks for other loads and stores with invariant.group
   /// metadata and the same pointer operand. Returns Unknown if it does not
@@ -465,18 +465,6 @@
   /// with the same queried instruction.
   MemDepResult getInvariantGroupPointerDependency(LoadInst *LI, BasicBlock *BB);
 
-  /// Looks at a memory location for a load (specified by MemLocBase, Offs, and
-  /// Size) and compares it against a load.
-  ///
-  /// If the specified load could be safely widened to a larger integer load
-  /// that is 1) still efficient, 2) safe for the target, and 3) would provide
-  /// the specified memory location value, then this function returns the size
-  /// in bytes of the load width to use.  If not, this returns zero.
-  static unsigned getLoadLoadClobberFullWidthSize(const Value *MemLocBase,
-                                                  int64_t MemLocOffs,
-                                                  unsigned MemLocSize,
-                                                  const LoadInst *LI);
-
   /// Release memory in caches.
   void releaseMemory();
 
@@ -490,7 +478,8 @@
                                    BasicBlock *BB,
                                    SmallVectorImpl<NonLocalDepResult> &Result,
                                    DenseMap<BasicBlock *, Value *> &Visited,
-                                   bool SkipFirstBlock = false);
+                                   bool SkipFirstBlock = false,
+                                   bool IsIncomplete = false);
   MemDepResult GetNonLocalInfoForBlock(Instruction *QueryInst,
                                        const MemoryLocation &Loc, bool isLoad,
                                        BasicBlock *BB, NonLocalDepInfo *Cache,
@@ -511,9 +500,14 @@
 
   static AnalysisKey Key;
 
+  unsigned DefaultBlockScanLimit;
+
 public:
   using Result = MemoryDependenceResults;
 
+  MemoryDependenceAnalysis();
+  MemoryDependenceAnalysis(unsigned DefaultBlockScanLimit) : DefaultBlockScanLimit(DefaultBlockScanLimit) { }
+
   MemoryDependenceResults run(Function &F, FunctionAnalysisManager &AM);
 };
 
diff --git a/linux-x64/clang/include/llvm/Analysis/MemoryLocation.h b/linux-x64/clang/include/llvm/Analysis/MemoryLocation.h
index 7c26353..3b188d7 100644
--- a/linux-x64/clang/include/llvm/Analysis/MemoryLocation.h
+++ b/linux-x64/clang/include/llvm/Analysis/MemoryLocation.h
@@ -17,20 +17,25 @@
 
 #include "llvm/ADT/DenseMapInfo.h"
 #include "llvm/ADT/Optional.h"
-#include "llvm/IR/Instructions.h"
 #include "llvm/IR/Metadata.h"
+#include "llvm/Support/TypeSize.h"
 
 namespace llvm {
 
+class CallBase;
+class Instruction;
 class LoadInst;
 class StoreInst;
 class MemTransferInst;
 class MemIntrinsic;
+class AtomicCmpXchgInst;
 class AtomicMemTransferInst;
 class AtomicMemIntrinsic;
+class AtomicRMWInst;
 class AnyMemTransferInst;
 class AnyMemIntrinsic;
 class TargetLibraryInfo;
+class VAArgInst;
 
 // Represents the size of a MemoryLocation. Logically, it's an
 // Optional<uint63_t> that also carries a bit to represent whether the integer
@@ -59,10 +64,11 @@
 // None.
 class LocationSize {
   enum : uint64_t {
-    Unknown = ~uint64_t(0),
+    BeforeOrAfterPointer = ~uint64_t(0),
+    AfterPointer = BeforeOrAfterPointer - 1,
+    MapEmpty = BeforeOrAfterPointer - 2,
+    MapTombstone = BeforeOrAfterPointer - 3,
     ImpreciseBit = uint64_t(1) << 63,
-    MapEmpty = Unknown - 1,
-    MapTombstone = Unknown - 2,
 
     // The maximum value we can represent without falling back to 'unknown'.
     MaxValue = (MapTombstone - 1) & ~ImpreciseBit,
@@ -76,7 +82,11 @@
 
   constexpr LocationSize(uint64_t Raw, DirectConstruction): Value(Raw) {}
 
-  static_assert(Unknown & ImpreciseBit, "Unknown is imprecise by definition.");
+  static_assert(AfterPointer & ImpreciseBit,
+                "AfterPointer is imprecise by definition.");
+  static_assert(BeforeOrAfterPointer & ImpreciseBit,
+                "BeforeOrAfterPointer is imprecise by definition.");
+
 public:
   // FIXME: Migrate all users to construct via either `precise` or `upperBound`,
   // to make it more obvious at the callsite the kind of size that they're
@@ -85,21 +95,39 @@
   // Since the overwhelming majority of users of this provide precise values,
   // this assumes the provided value is precise.
   constexpr LocationSize(uint64_t Raw)
-      : Value(Raw > MaxValue ? Unknown : Raw) {}
+      : Value(Raw > MaxValue ? AfterPointer : Raw) {}
 
   static LocationSize precise(uint64_t Value) { return LocationSize(Value); }
+  static LocationSize precise(TypeSize Value) {
+    if (Value.isScalable())
+      return afterPointer();
+    return precise(Value.getFixedSize());
+  }
 
   static LocationSize upperBound(uint64_t Value) {
     // You can't go lower than 0, so give a precise result.
     if (LLVM_UNLIKELY(Value == 0))
       return precise(0);
     if (LLVM_UNLIKELY(Value > MaxValue))
-      return unknown();
+      return afterPointer();
     return LocationSize(Value | ImpreciseBit, Direct);
   }
+  static LocationSize upperBound(TypeSize Value) {
+    if (Value.isScalable())
+      return afterPointer();
+    return upperBound(Value.getFixedSize());
+  }
 
-  constexpr static LocationSize unknown() {
-    return LocationSize(Unknown, Direct);
+  /// Any location after the base pointer (but still within the underlying
+  /// object).
+  constexpr static LocationSize afterPointer() {
+    return LocationSize(AfterPointer, Direct);
+  }
+
+  /// Any location before or after the base pointer (but still within the
+  /// underlying object).
+  constexpr static LocationSize beforeOrAfterPointer() {
+    return LocationSize(BeforeOrAfterPointer, Direct);
   }
 
   // Sentinel values, generally used for maps.
@@ -116,20 +144,24 @@
     if (Other == *this)
       return *this;
 
-    if (!hasValue() || !Other.hasValue())
-      return unknown();
+    if (Value == BeforeOrAfterPointer || Other.Value == BeforeOrAfterPointer)
+      return beforeOrAfterPointer();
+    if (Value == AfterPointer || Other.Value == AfterPointer)
+      return afterPointer();
 
     return upperBound(std::max(getValue(), Other.getValue()));
   }
 
-  bool hasValue() const { return Value != Unknown; }
+  bool hasValue() const {
+    return Value != AfterPointer && Value != BeforeOrAfterPointer;
+  }
   uint64_t getValue() const {
     assert(hasValue() && "Getting value from an unknown LocationSize!");
     return Value & ~ImpreciseBit;
   }
 
   // Returns whether or not this value is precise. Note that if a value is
-  // precise, it's guaranteed to not be `unknown()`.
+  // precise, it's guaranteed to not be unknown.
   bool isPrecise() const {
     return (Value & ImpreciseBit) == 0;
   }
@@ -137,6 +169,9 @@
   // Convenience method to check if this LocationSize's value is 0.
   bool isZero() const { return hasValue() && getValue() == 0; }
 
+  /// Whether accesses before the base pointer are possible.
+  bool mayBeBeforePointer() const { return Value == BeforeOrAfterPointer; }
+
   bool operator==(const LocationSize &Other) const {
     return Value == Other.Value;
   }
@@ -194,6 +229,8 @@
   /// member is null if that kind of information is unavailable).
   AAMDNodes AATags;
 
+  void print(raw_ostream &OS) const { OS << *Ptr << " " << Size << "\n"; }
+
   /// Return a location with information about the memory reference by the given
   /// instruction.
   static MemoryLocation get(const LoadInst *LI);
@@ -204,22 +241,7 @@
   static MemoryLocation get(const Instruction *Inst) {
     return *MemoryLocation::getOrNone(Inst);
   }
-  static Optional<MemoryLocation> getOrNone(const Instruction *Inst) {
-    switch (Inst->getOpcode()) {
-    case Instruction::Load:
-      return get(cast<LoadInst>(Inst));
-    case Instruction::Store:
-      return get(cast<StoreInst>(Inst));
-    case Instruction::VAArg:
-      return get(cast<VAArgInst>(Inst));
-    case Instruction::AtomicCmpXchg:
-      return get(cast<AtomicCmpXchgInst>(Inst));
-    case Instruction::AtomicRMW:
-      return get(cast<AtomicRMWInst>(Inst));
-    default:
-      return None;
-    }
-  }
+  static Optional<MemoryLocation> getOrNone(const Instruction *Inst);
 
   /// Return a location representing the source of a memory transfer.
   static MemoryLocation getForSource(const MemTransferInst *MTI);
@@ -240,8 +262,30 @@
     return getForArgument(Call, ArgIdx, &TLI);
   }
 
-  explicit MemoryLocation(const Value *Ptr = nullptr,
-                          LocationSize Size = LocationSize::unknown(),
+  /// Return a location that may access any location after Ptr, while remaining
+  /// within the underlying object.
+  static MemoryLocation getAfter(const Value *Ptr,
+                                 const AAMDNodes &AATags = AAMDNodes()) {
+    return MemoryLocation(Ptr, LocationSize::afterPointer(), AATags);
+  }
+
+  /// Return a location that may access any location before or after Ptr, while
+  /// remaining within the underlying object.
+  static MemoryLocation
+  getBeforeOrAfter(const Value *Ptr, const AAMDNodes &AATags = AAMDNodes()) {
+    return MemoryLocation(Ptr, LocationSize::beforeOrAfterPointer(), AATags);
+  }
+
+  // Return the exact size if the exact size is known at compiletime,
+  // otherwise return MemoryLocation::UnknownSize.
+  static uint64_t getSizeOrUnknown(const TypeSize &T) {
+    return T.isScalable() ? UnknownSize : T.getFixedSize();
+  }
+
+  MemoryLocation()
+      : Ptr(nullptr), Size(LocationSize::beforeOrAfterPointer()), AATags() {}
+
+  explicit MemoryLocation(const Value *Ptr, LocationSize Size,
                           const AAMDNodes &AATags = AAMDNodes())
       : Ptr(Ptr), Size(Size), AATags(AATags) {}
 
diff --git a/linux-x64/clang/include/llvm/Analysis/MemorySSA.h b/linux-x64/clang/include/llvm/Analysis/MemorySSA.h
index b7730be..63c031b 100644
--- a/linux-x64/clang/include/llvm/Analysis/MemorySSA.h
+++ b/linux-x64/clang/include/llvm/Analysis/MemorySSA.h
@@ -88,6 +88,7 @@
 #include "llvm/IR/DerivedUser.h"
 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/Module.h"
+#include "llvm/IR/Operator.h"
 #include "llvm/IR/Type.h"
 #include "llvm/IR/Use.h"
 #include "llvm/IR/User.h"
@@ -95,6 +96,7 @@
 #include "llvm/IR/ValueHandle.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/Casting.h"
+#include "llvm/Support/CommandLine.h"
 #include <algorithm>
 #include <cassert>
 #include <cstddef>
@@ -107,6 +109,7 @@
 /// Enables memory ssa as a dependency for loop passes.
 extern cl::opt<bool> EnableMSSALoopDependency;
 
+class AllocaInst;
 class Function;
 class Instruction;
 class MemoryAccess;
@@ -269,7 +272,7 @@
   // Retrieve AliasResult type of the optimized access. Ideally this would be
   // returned by the caching walker and may go away in the future.
   Optional<AliasResult> getOptimizedAccessType() const {
-    return OptimizedAccessAlias;
+    return isOptimized() ? OptimizedAccessAlias : None;
   }
 
   /// Reset the ID of what this MemoryUse was optimized to, causing it to
@@ -498,14 +501,11 @@
   using const_block_iterator = BasicBlock *const *;
 
   block_iterator block_begin() {
-    auto *Ref = reinterpret_cast<Use::UserRef *>(op_begin() + ReservedSpace);
-    return reinterpret_cast<block_iterator>(Ref + 1);
+    return reinterpret_cast<block_iterator>(op_begin() + ReservedSpace);
   }
 
   const_block_iterator block_begin() const {
-    const auto *Ref =
-        reinterpret_cast<const Use::UserRef *>(op_begin() + ReservedSpace);
-    return reinterpret_cast<const_block_iterator>(Ref + 1);
+    return reinterpret_cast<const_block_iterator>(op_begin() + ReservedSpace);
   }
 
   block_iterator block_end() { return block_begin() + getNumOperands(); }
@@ -725,6 +725,8 @@
     return cast_or_null<MemoryPhi>(ValueToMemoryAccess.lookup(cast<Value>(BB)));
   }
 
+  DominatorTree &getDomTree() const { return *DT; }
+
   void dump() const;
   void print(raw_ostream &) const;
 
@@ -785,7 +787,7 @@
 
   /// Used in various insertion functions to specify whether we are talking
   /// about the beginning or end of a block.
-  enum InsertionPlace { Beginning, End };
+  enum InsertionPlace { Beginning, End, BeforeTerminator };
 
 protected:
   // Used by Memory SSA annotater, dumpers, and wrapper pass
@@ -793,10 +795,9 @@
   friend class MemorySSAPrinterLegacyPass;
   friend class MemorySSAUpdater;
 
-  void verifyDefUses(Function &F) const;
-  void verifyDomination(Function &F) const;
-  void verifyOrdering(Function &F) const;
+  void verifyOrderingDominationAndDefUses(Function &F) const;
   void verifyDominationNumbers(const Function &F) const;
+  void verifyPrevDefInPhis(Function &F) const;
 
   // This is used by the use optimizer and updater.
   AccessList *getWritableBlockAccesses(const BasicBlock *BB) const {
@@ -830,7 +831,8 @@
   void insertIntoListsBefore(MemoryAccess *, const BasicBlock *,
                              AccessList::iterator);
   MemoryUseOrDef *createDefinedAccess(Instruction *, MemoryAccess *,
-                                      const MemoryUseOrDef *Template = nullptr);
+                                      const MemoryUseOrDef *Template = nullptr,
+                                      bool CreationMustSucceed = true);
 
 private:
   template <class AliasAnalysisType> class ClobberWalkerBase;
@@ -840,7 +842,6 @@
 
   CachingWalker<AliasAnalysis> *getWalkerImpl();
   void buildMemorySSA(BatchAAResults &BAA);
-  void optimizeUses();
 
   void prepareForMoveTo(MemoryAccess *, BasicBlock *);
   void verifyUseInDefs(MemoryAccess *, MemoryAccess *) const;
@@ -848,15 +849,11 @@
   using AccessMap = DenseMap<const BasicBlock *, std::unique_ptr<AccessList>>;
   using DefsMap = DenseMap<const BasicBlock *, std::unique_ptr<DefsList>>;
 
-  void
-  determineInsertionPoint(const SmallPtrSetImpl<BasicBlock *> &DefiningBlocks);
   void markUnreachableAsLiveOnEntry(BasicBlock *BB);
-  bool dominatesUse(const MemoryAccess *, const MemoryAccess *) const;
   MemoryPhi *createMemoryPhi(BasicBlock *BB);
   template <typename AliasAnalysisType>
   MemoryUseOrDef *createNewAccess(Instruction *, AliasAnalysisType *,
                                   const MemoryUseOrDef *Template = nullptr);
-  MemoryAccess *findDominatingDef(BasicBlock *, enum InsertionPlace);
   void placePHINodes(const SmallPtrSetImpl<BasicBlock *> &);
   MemoryAccess *renameBlock(BasicBlock *, MemoryAccess *, bool);
   void renameSuccessorPhis(BasicBlock *, MemoryAccess *, bool);
@@ -1181,9 +1178,11 @@
   using BaseT = upward_defs_iterator::iterator_facade_base;
 
 public:
-  upward_defs_iterator(const MemoryAccessPair &Info)
+  upward_defs_iterator(const MemoryAccessPair &Info, DominatorTree *DT,
+                       bool *PerformedPhiTranslation = nullptr)
       : DefIterator(Info.first), Location(Info.second),
-        OriginalAccess(Info.first) {
+        OriginalAccess(Info.first), DT(DT),
+        PerformedPhiTranslation(PerformedPhiTranslation) {
     CurrentPair.first = nullptr;
 
     WalkingPhi = Info.first && isa<MemoryPhi>(Info.first);
@@ -1215,39 +1214,67 @@
   BasicBlock *getPhiArgBlock() const { return DefIterator.getPhiArgBlock(); }
 
 private:
+  /// Returns true if \p Ptr is guaranteed to be loop invariant for any possible
+  /// loop. In particular, this guarantees that it only references a single
+  /// MemoryLocation during execution of the containing function.
+  bool IsGuaranteedLoopInvariant(Value *Ptr) const;
+
   void fillInCurrentPair() {
     CurrentPair.first = *DefIterator;
+    CurrentPair.second = Location;
     if (WalkingPhi && Location.Ptr) {
+      // Mark size as unknown, if the location is not guaranteed to be
+      // loop-invariant for any possible loop in the function. Setting the size
+      // to unknown guarantees that any memory accesses that access locations
+      // after the pointer are considered as clobbers, which is important to
+      // catch loop carried dependences.
+      if (Location.Ptr &&
+          !IsGuaranteedLoopInvariant(const_cast<Value *>(Location.Ptr)))
+        CurrentPair.second =
+            Location.getWithNewSize(LocationSize::beforeOrAfterPointer());
       PHITransAddr Translator(
           const_cast<Value *>(Location.Ptr),
           OriginalAccess->getBlock()->getModule()->getDataLayout(), nullptr);
+
       if (!Translator.PHITranslateValue(OriginalAccess->getBlock(),
-                                        DefIterator.getPhiArgBlock(), nullptr,
-                                        false))
-        if (Translator.getAddr() != Location.Ptr) {
-          CurrentPair.second = Location.getWithNewPtr(Translator.getAddr());
-          return;
+                                        DefIterator.getPhiArgBlock(), DT,
+                                        true)) {
+        Value *TransAddr = Translator.getAddr();
+        if (TransAddr != Location.Ptr) {
+          CurrentPair.second = CurrentPair.second.getWithNewPtr(TransAddr);
+
+          if (TransAddr &&
+              !IsGuaranteedLoopInvariant(const_cast<Value *>(TransAddr)))
+            CurrentPair.second = CurrentPair.second.getWithNewSize(
+                LocationSize::beforeOrAfterPointer());
+
+          if (PerformedPhiTranslation)
+            *PerformedPhiTranslation = true;
         }
+      }
     }
-    CurrentPair.second = Location;
   }
 
   MemoryAccessPair CurrentPair;
   memoryaccess_def_iterator DefIterator;
   MemoryLocation Location;
   MemoryAccess *OriginalAccess = nullptr;
+  DominatorTree *DT = nullptr;
   bool WalkingPhi = false;
+  bool *PerformedPhiTranslation = nullptr;
 };
 
-inline upward_defs_iterator upward_defs_begin(const MemoryAccessPair &Pair) {
-  return upward_defs_iterator(Pair);
+inline upward_defs_iterator
+upward_defs_begin(const MemoryAccessPair &Pair, DominatorTree &DT,
+                  bool *PerformedPhiTranslation = nullptr) {
+  return upward_defs_iterator(Pair, &DT, PerformedPhiTranslation);
 }
 
 inline upward_defs_iterator upward_defs_end() { return upward_defs_iterator(); }
 
 inline iterator_range<upward_defs_iterator>
-upward_defs(const MemoryAccessPair &Pair) {
-  return make_range(upward_defs_begin(Pair), upward_defs_end());
+upward_defs(const MemoryAccessPair &Pair, DominatorTree &DT) {
+  return make_range(upward_defs_begin(Pair, DT), upward_defs_end());
 }
 
 /// Walks the defining accesses of MemoryDefs. Stops after we hit something that
diff --git a/linux-x64/clang/include/llvm/Analysis/MemorySSAUpdater.h b/linux-x64/clang/include/llvm/Analysis/MemorySSAUpdater.h
index 6467d41..b0bf2e5 100644
--- a/linux-x64/clang/include/llvm/Analysis/MemorySSAUpdater.h
+++ b/linux-x64/clang/include/llvm/Analysis/MemorySSAUpdater.h
@@ -31,40 +31,27 @@
 #ifndef LLVM_ANALYSIS_MEMORYSSAUPDATER_H
 #define LLVM_ANALYSIS_MEMORYSSAUPDATER_H
 
+#include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/SmallVector.h"
-#include "llvm/Analysis/LoopInfo.h"
-#include "llvm/Analysis/LoopIterator.h"
 #include "llvm/Analysis/MemorySSA.h"
-#include "llvm/IR/BasicBlock.h"
-#include "llvm/IR/CFGDiff.h"
-#include "llvm/IR/Dominators.h"
-#include "llvm/IR/Module.h"
-#include "llvm/IR/OperandTraits.h"
-#include "llvm/IR/Type.h"
-#include "llvm/IR/Use.h"
-#include "llvm/IR/User.h"
-#include "llvm/IR/Value.h"
 #include "llvm/IR/ValueHandle.h"
 #include "llvm/IR/ValueMap.h"
-#include "llvm/Pass.h"
-#include "llvm/Support/Casting.h"
-#include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/CFGDiff.h"
+#include <utility>
 
 namespace llvm {
 
-class Function;
+class BasicBlock;
+class BranchInst;
+class DominatorTree;
 class Instruction;
-class MemoryAccess;
-class LLVMContext;
-class raw_ostream;
+class LoopBlocksRPO;
 
 using ValueToValueMapTy = ValueMap<const Value *, WeakTrackingVH>;
 using PhiToDefMap = SmallDenseMap<MemoryPhi *, MemoryAccess *>;
 using CFGUpdate = cfg::Update<BasicBlock *>;
-using GraphDiffInvBBPair =
-    std::pair<const GraphDiff<BasicBlock *> *, Inverse<BasicBlock *>>;
 
 class MemorySSAUpdater {
 private:
@@ -98,7 +85,7 @@
   /// load a
   /// Where a mayalias b, *does* require RenameUses be set to true.
   void insertDef(MemoryDef *Def, bool RenameUses = false);
-  void insertUse(MemoryUse *Use);
+  void insertUse(MemoryUse *Use, bool RenameUses = false);
   /// Update the MemoryPhi in `To` following an edge deletion between `From` and
   /// `To`. If `To` becomes unreachable, a call to removeBlocks should be made.
   void removeEdge(BasicBlock *From, BasicBlock *To);
@@ -132,8 +119,11 @@
       ArrayRef<BasicBlock *> ExitBlocks,
       ArrayRef<std::unique_ptr<ValueToValueMapTy>> VMaps, DominatorTree &DT);
 
-  /// Apply CFG updates, analogous with the DT edge updates.
-  void applyUpdates(ArrayRef<CFGUpdate> Updates, DominatorTree &DT);
+  /// Apply CFG updates, analogous with the DT edge updates. By default, the
+  /// DT is assumed to be already up to date. If UpdateDTFirst is true, first
+  /// update the DT with the same updates.
+  void applyUpdates(ArrayRef<CFGUpdate> Updates, DominatorTree &DT,
+                    bool UpdateDTFirst = false);
   /// Apply CFG insert updates, analogous with the DT edge updates.
   void applyInsertUpdates(ArrayRef<CFGUpdate> Updates, DominatorTree &DT);
 
@@ -243,7 +233,7 @@
   /// Deleted blocks still have successor info, but their predecessor edges and
   /// Phi nodes may already be updated. Instructions in DeadBlocks should be
   /// deleted after this call.
-  void removeBlocks(const SmallPtrSetImpl<BasicBlock *> &DeadBlocks);
+  void removeBlocks(const SmallSetVector<BasicBlock *, 8> &DeadBlocks);
 
   /// Instruction I will be changed to an unreachable. Remove all accesses in
   /// I's block that follow I (inclusive), and update the Phis in the blocks'
@@ -274,6 +264,7 @@
   getPreviousDefRecursive(BasicBlock *,
                           DenseMap<BasicBlock *, TrackingVH<MemoryAccess>> &);
   MemoryAccess *recursePhi(MemoryAccess *Phi);
+  MemoryAccess *tryRemoveTrivialPhi(MemoryPhi *Phi);
   template <class RangeType>
   MemoryAccess *tryRemoveTrivialPhi(MemoryPhi *Phi, RangeType &Operands);
   void tryRemoveTrivialPhis(ArrayRef<WeakVH> UpdatedPHIs);
diff --git a/linux-x64/clang/include/llvm/Analysis/ModuleDebugInfoPrinter.h b/linux-x64/clang/include/llvm/Analysis/ModuleDebugInfoPrinter.h
new file mode 100644
index 0000000..99aa315
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Analysis/ModuleDebugInfoPrinter.h
@@ -0,0 +1,29 @@
+//===- ModuleDebugInfoPrinter.h - -----------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_ANALYSIS_MODULEDEBUGINFOPRINTER_H
+#define LLVM_ANALYSIS_MODULEDEBUGINFOPRINTER_H
+
+#include "llvm/IR/DebugInfo.h"
+#include "llvm/IR/PassManager.h"
+#include "llvm/Support/raw_ostream.h"
+
+namespace llvm {
+
+class ModuleDebugInfoPrinterPass
+    : public PassInfoMixin<ModuleDebugInfoPrinterPass> {
+  DebugInfoFinder Finder;
+  raw_ostream &OS;
+
+public:
+  explicit ModuleDebugInfoPrinterPass(raw_ostream &OS);
+  PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+};
+} // end namespace llvm
+
+#endif // LLVM_ANALYSIS_MODULEDEBUGINFOPRINTER_H
diff --git a/linux-x64/clang/include/llvm/Analysis/ModuleSummaryAnalysis.h b/linux-x64/clang/include/llvm/Analysis/ModuleSummaryAnalysis.h
index 1572a49..eb48ec3 100644
--- a/linux-x64/clang/include/llvm/Analysis/ModuleSummaryAnalysis.h
+++ b/linux-x64/clang/include/llvm/Analysis/ModuleSummaryAnalysis.h
@@ -25,6 +25,7 @@
 class Function;
 class Module;
 class ProfileSummaryInfo;
+class StackSafetyInfo;
 
 /// Direct function to compute a \c ModuleSummaryIndex from a given module.
 ///
@@ -35,7 +36,9 @@
 ModuleSummaryIndex buildModuleSummaryIndex(
     const Module &M,
     std::function<BlockFrequencyInfo *(const Function &F)> GetBFICallback,
-    ProfileSummaryInfo *PSI);
+    ProfileSummaryInfo *PSI,
+    std::function<const StackSafetyInfo *(const Function &F)> GetSSICallback =
+        [](const Function &F) -> const StackSafetyInfo * { return nullptr; });
 
 /// Analysis pass to provide the ModuleSummaryIndex object.
 class ModuleSummaryIndexAnalysis
@@ -75,6 +78,27 @@
 //
 ModulePass *createModuleSummaryIndexWrapperPass();
 
+/// Legacy wrapper pass to provide the ModuleSummaryIndex object.
+class ImmutableModuleSummaryIndexWrapperPass : public ImmutablePass {
+  const ModuleSummaryIndex *Index;
+
+public:
+  static char ID;
+
+  ImmutableModuleSummaryIndexWrapperPass(
+      const ModuleSummaryIndex *Index = nullptr);
+  const ModuleSummaryIndex *getIndex() const { return Index; }
+  void getAnalysisUsage(AnalysisUsage &AU) const override;
+};
+
+//===--------------------------------------------------------------------===//
+//
+// ImmutableModuleSummaryIndexWrapperPass - This pass wrap provided
+// ModuleSummaryIndex object for the module, to be used by other passes.
+//
+ImmutablePass *
+createImmutableModuleSummaryIndexWrapperPass(const ModuleSummaryIndex *Index);
+
 } // end namespace llvm
 
 #endif // LLVM_ANALYSIS_MODULESUMMARYANALYSIS_H
diff --git a/linux-x64/clang/include/llvm/Analysis/MustExecute.h b/linux-x64/clang/include/llvm/Analysis/MustExecute.h
index 3ef539c..df489aa 100644
--- a/linux-x64/clang/include/llvm/Analysis/MustExecute.h
+++ b/linux-x64/clang/include/llvm/Analysis/MustExecute.h
@@ -7,33 +7,46 @@
 //===----------------------------------------------------------------------===//
 /// \file
 /// Contains a collection of routines for determining if a given instruction is
-/// guaranteed to execute if a given point in control flow is reached.  The most
+/// guaranteed to execute if a given point in control flow is reached. The most
 /// common example is an instruction within a loop being provably executed if we
 /// branch to the header of it's containing loop.
 ///
+/// There are two interfaces available to determine if an instruction is
+/// executed once a given point in the control flow is reached:
+/// 1) A loop-centric one derived from LoopSafetyInfo.
+/// 2) A "must be executed context"-based one implemented in the
+///    MustBeExecutedContextExplorer.
+/// Please refer to the class comments for more information.
+///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_ANALYSIS_MUSTEXECUTE_H
 #define LLVM_ANALYSIS_MUSTEXECUTE_H
 
 #include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/DenseSet.h"
 #include "llvm/Analysis/EHPersonalities.h"
 #include "llvm/Analysis/InstructionPrecedenceTracking.h"
-#include "llvm/Analysis/LoopInfo.h"
-#include "llvm/IR/BasicBlock.h"
-#include "llvm/IR/Dominators.h"
-#include "llvm/IR/Instruction.h"
+#include "llvm/IR/PassManager.h"
+#include "llvm/Support/raw_ostream.h"
 
 namespace llvm {
 
-class Instruction;
+namespace {
+template <typename T> using GetterTy = std::function<T *(const Function &F)>;
+}
+
+class BasicBlock;
 class DominatorTree;
+class Instruction;
 class Loop;
+class LoopInfo;
+class PostDominatorTree;
 
 /// Captures loop safety information.
 /// It keep information for loop blocks may throw exception or otherwise
-/// exit abnormaly on any iteration of the loop which might actually execute
-/// at runtime.  The primary way to consume this infromation is via
+/// exit abnormally on any iteration of the loop which might actually execute
+/// at runtime.  The primary way to consume this information is via
 /// isGuaranteedToExecute below, but some callers bailout or fallback to
 /// alternate reasoning if a loop contains any implicit control flow.
 /// NOTE: LoopSafetyInfo contains cached information regarding loops and their
@@ -100,19 +113,15 @@
   bool HeaderMayThrow = false; // Same as previous, but specific to loop header
 
 public:
-  virtual bool blockMayThrow(const BasicBlock *BB) const;
+  bool blockMayThrow(const BasicBlock *BB) const override;
 
-  virtual bool anyBlockMayThrow() const;
+  bool anyBlockMayThrow() const override;
 
-  virtual void computeLoopSafetyInfo(const Loop *CurLoop);
+  void computeLoopSafetyInfo(const Loop *CurLoop) override;
 
-  virtual bool isGuaranteedToExecute(const Instruction &Inst,
-                                     const DominatorTree *DT,
-                                     const Loop *CurLoop) const;
-
-  SimpleLoopSafetyInfo() : LoopSafetyInfo() {};
-
-  virtual ~SimpleLoopSafetyInfo() {};
+  bool isGuaranteedToExecute(const Instruction &Inst,
+                             const DominatorTree *DT,
+                             const Loop *CurLoop) const override;
 };
 
 /// This implementation of LoopSafetyInfo use ImplicitControlFlowTracking to
@@ -129,15 +138,15 @@
   mutable MemoryWriteTracking MW;
 
 public:
-  virtual bool blockMayThrow(const BasicBlock *BB) const;
+  bool blockMayThrow(const BasicBlock *BB) const override;
 
-  virtual bool anyBlockMayThrow() const;
+  bool anyBlockMayThrow() const override;
 
-  virtual void computeLoopSafetyInfo(const Loop *CurLoop);
+  void computeLoopSafetyInfo(const Loop *CurLoop) override;
 
-  virtual bool isGuaranteedToExecute(const Instruction &Inst,
-                                     const DominatorTree *DT,
-                                     const Loop *CurLoop) const;
+  bool isGuaranteedToExecute(const Instruction &Inst,
+                             const DominatorTree *DT,
+                             const Loop *CurLoop) const override;
 
   /// Returns true if we could not execute a memory-modifying instruction before
   /// we enter \p BB under assumption that \p CurLoop is entered.
@@ -158,12 +167,399 @@
   /// from its block. It will make all cache updates to keep it correct after
   /// this removal.
   void removeInstruction(const Instruction *Inst);
-
-  ICFLoopSafetyInfo(DominatorTree *DT) : LoopSafetyInfo(), ICF(DT), MW(DT) {};
-
-  virtual ~ICFLoopSafetyInfo() {};
 };
 
-}
+bool mayContainIrreducibleControl(const Function &F, const LoopInfo *LI);
+
+struct MustBeExecutedContextExplorer;
+
+/// Enum that allows us to spell out the direction.
+enum class ExplorationDirection {
+  BACKWARD = 0,
+  FORWARD = 1,
+};
+
+/// Must be executed iterators visit stretches of instructions that are
+/// guaranteed to be executed together, potentially with other instruction
+/// executed in-between.
+///
+/// Given the following code, and assuming all statements are single
+/// instructions which transfer execution to the successor (see
+/// isGuaranteedToTransferExecutionToSuccessor), there are two possible
+/// outcomes. If we start the iterator at A, B, or E, we will visit only A, B,
+/// and E. If we start at C or D, we will visit all instructions A-E.
+///
+/// \code
+///   A;
+///   B;
+///   if (...) {
+///     C;
+///     D;
+///   }
+///   E;
+/// \endcode
+///
+///
+/// Below is the example extneded with instructions F and G. Now we assume F
+/// might not transfer execution to it's successor G. As a result we get the
+/// following visit sets:
+///
+/// Start Instruction   | Visit Set
+/// A                   | A, B,       E, F
+///    B                | A, B,       E, F
+///       C             | A, B, C, D, E, F
+///          D          | A, B, C, D, E, F
+///             E       | A, B,       E, F
+///                F    | A, B,       E, F
+///                   G | A, B,       E, F, G
+///
+///
+/// \code
+///   A;
+///   B;
+///   if (...) {
+///     C;
+///     D;
+///   }
+///   E;
+///   F;  // Might not transfer execution to its successor G.
+///   G;
+/// \endcode
+///
+///
+/// A more complex example involving conditionals, loops, break, and continue
+/// is shown below. We again assume all instructions will transmit control to
+/// the successor and we assume we can prove the inner loop to be finite. We
+/// omit non-trivial branch conditions as the exploration is oblivious to them.
+/// Constant branches are assumed to be unconditional in the CFG. The resulting
+/// visist sets are shown in the table below.
+///
+/// \code
+///   A;
+///   while (true) {
+///     B;
+///     if (...)
+///       C;
+///     if (...)
+///       continue;
+///     D;
+///     if (...)
+///       break;
+///     do {
+///       if (...)
+///         continue;
+///       E;
+///     } while (...);
+///     F;
+///   }
+///   G;
+/// \endcode
+///
+/// Start Instruction    | Visit Set
+/// A                    | A, B
+///    B                 | A, B
+///       C              | A, B, C
+///          D           | A, B,    D
+///             E        | A, B,    D, E, F
+///                F     | A, B,    D,    F
+///                   G  | A, B,    D,       G
+///
+///
+/// Note that the examples show optimal visist sets but not necessarily the ones
+/// derived by the explorer depending on the available CFG analyses (see
+/// MustBeExecutedContextExplorer). Also note that we, depending on the options,
+/// the visit set can contain instructions from other functions.
+struct MustBeExecutedIterator {
+  /// Type declarations that make his class an input iterator.
+  ///{
+  typedef const Instruction *value_type;
+  typedef std::ptrdiff_t difference_type;
+  typedef const Instruction **pointer;
+  typedef const Instruction *&reference;
+  typedef std::input_iterator_tag iterator_category;
+  ///}
+
+  using ExplorerTy = MustBeExecutedContextExplorer;
+
+  MustBeExecutedIterator(const MustBeExecutedIterator &Other)
+      : Visited(Other.Visited), Explorer(Other.Explorer),
+        CurInst(Other.CurInst), Head(Other.Head), Tail(Other.Tail) {}
+
+  MustBeExecutedIterator(MustBeExecutedIterator &&Other)
+      : Visited(std::move(Other.Visited)), Explorer(Other.Explorer),
+        CurInst(Other.CurInst), Head(Other.Head), Tail(Other.Tail) {}
+
+  MustBeExecutedIterator &operator=(MustBeExecutedIterator &&Other) {
+    if (this != &Other) {
+      std::swap(Visited, Other.Visited);
+      std::swap(CurInst, Other.CurInst);
+      std::swap(Head, Other.Head);
+      std::swap(Tail, Other.Tail);
+    }
+    return *this;
+  }
+
+  ~MustBeExecutedIterator() {}
+
+  /// Pre- and post-increment operators.
+  ///{
+  MustBeExecutedIterator &operator++() {
+    CurInst = advance();
+    return *this;
+  }
+
+  MustBeExecutedIterator operator++(int) {
+    MustBeExecutedIterator tmp(*this);
+    operator++();
+    return tmp;
+  }
+  ///}
+
+  /// Equality and inequality operators. Note that we ignore the history here.
+  ///{
+  bool operator==(const MustBeExecutedIterator &Other) const {
+    return CurInst == Other.CurInst && Head == Other.Head && Tail == Other.Tail;
+  }
+
+  bool operator!=(const MustBeExecutedIterator &Other) const {
+    return !(*this == Other);
+  }
+  ///}
+
+  /// Return the underlying instruction.
+  const Instruction *&operator*() { return CurInst; }
+  const Instruction *getCurrentInst() const { return CurInst; }
+
+  /// Return true if \p I was encountered by this iterator already.
+  bool count(const Instruction *I) const {
+    return Visited.count({I, ExplorationDirection::FORWARD}) ||
+           Visited.count({I, ExplorationDirection::BACKWARD});
+  }
+
+private:
+  using VisitedSetTy =
+      DenseSet<PointerIntPair<const Instruction *, 1, ExplorationDirection>>;
+
+  /// Private constructors.
+  MustBeExecutedIterator(ExplorerTy &Explorer, const Instruction *I);
+
+  /// Reset the iterator to its initial state pointing at \p I.
+  void reset(const Instruction *I);
+
+  /// Reset the iterator to point at \p I, keep cached state.
+  void resetInstruction(const Instruction *I);
+
+  /// Try to advance one of the underlying positions (Head or Tail).
+  ///
+  /// \return The next instruction in the must be executed context, or nullptr
+  ///         if none was found.
+  const Instruction *advance();
+
+  /// A set to track the visited instructions in order to deal with endless
+  /// loops and recursion.
+  VisitedSetTy Visited;
+
+  /// A reference to the explorer that created this iterator.
+  ExplorerTy &Explorer;
+
+  /// The instruction we are currently exposing to the user. There is always an
+  /// instruction that we know is executed with the given program point,
+  /// initially the program point itself.
+  const Instruction *CurInst;
+
+  /// Two positions that mark the program points where this iterator will look
+  /// for the next instruction. Note that the current instruction is either the
+  /// one pointed to by Head, Tail, or both.
+  const Instruction *Head, *Tail;
+
+  friend struct MustBeExecutedContextExplorer;
+};
+
+/// A "must be executed context" for a given program point PP is the set of
+/// instructions, potentially before and after PP, that are executed always when
+/// PP is reached. The MustBeExecutedContextExplorer an interface to explore
+/// "must be executed contexts" in a module through the use of
+/// MustBeExecutedIterator.
+///
+/// The explorer exposes "must be executed iterators" that traverse the must be
+/// executed context. There is little information sharing between iterators as
+/// the expected use case involves few iterators for "far apart" instructions.
+/// If that changes, we should consider caching more intermediate results.
+struct MustBeExecutedContextExplorer {
+
+  /// In the description of the parameters we use PP to denote a program point
+  /// for which the must be executed context is explored, or put differently,
+  /// for which the MustBeExecutedIterator is created.
+  ///
+  /// \param ExploreInterBlock    Flag to indicate if instructions in blocks
+  ///                             other than the parent of PP should be
+  ///                             explored.
+  /// \param ExploreCFGForward    Flag to indicate if instructions located after
+  ///                             PP in the CFG, e.g., post-dominating PP,
+  ///                             should be explored.
+  /// \param ExploreCFGBackward   Flag to indicate if instructions located
+  ///                             before PP in the CFG, e.g., dominating PP,
+  ///                             should be explored.
+  MustBeExecutedContextExplorer(
+      bool ExploreInterBlock, bool ExploreCFGForward, bool ExploreCFGBackward,
+      GetterTy<const LoopInfo> LIGetter =
+          [](const Function &) { return nullptr; },
+      GetterTy<const DominatorTree> DTGetter =
+          [](const Function &) { return nullptr; },
+      GetterTy<const PostDominatorTree> PDTGetter =
+          [](const Function &) { return nullptr; })
+      : ExploreInterBlock(ExploreInterBlock),
+        ExploreCFGForward(ExploreCFGForward),
+        ExploreCFGBackward(ExploreCFGBackward), LIGetter(LIGetter),
+        DTGetter(DTGetter), PDTGetter(PDTGetter), EndIterator(*this, nullptr) {}
+
+  /// Iterator-based interface. \see MustBeExecutedIterator.
+  ///{
+  using iterator = MustBeExecutedIterator;
+  using const_iterator = const MustBeExecutedIterator;
+
+  /// Return an iterator to explore the context around \p PP.
+  iterator &begin(const Instruction *PP) {
+    auto &It = InstructionIteratorMap[PP];
+    if (!It)
+      It.reset(new iterator(*this, PP));
+    return *It;
+  }
+
+  /// Return an iterator to explore the cached context around \p PP.
+  const_iterator &begin(const Instruction *PP) const {
+    return *InstructionIteratorMap.find(PP)->second;
+  }
+
+  /// Return an universal end iterator.
+  ///{
+  iterator &end() { return EndIterator; }
+  iterator &end(const Instruction *) { return EndIterator; }
+
+  const_iterator &end() const { return EndIterator; }
+  const_iterator &end(const Instruction *) const { return EndIterator; }
+  ///}
+
+  /// Return an iterator range to explore the context around \p PP.
+  llvm::iterator_range<iterator> range(const Instruction *PP) {
+    return llvm::make_range(begin(PP), end(PP));
+  }
+
+  /// Return an iterator range to explore the cached context around \p PP.
+  llvm::iterator_range<const_iterator> range(const Instruction *PP) const {
+    return llvm::make_range(begin(PP), end(PP));
+  }
+  ///}
+
+  /// Check \p Pred on all instructions in the context.
+  ///
+  /// This method will evaluate \p Pred and return
+  /// true if \p Pred holds in every instruction.
+  bool checkForAllContext(const Instruction *PP,
+                          function_ref<bool(const Instruction *)> Pred) {
+    for (auto EIt = begin(PP), EEnd = end(PP); EIt != EEnd; ++EIt)
+      if (!Pred(*EIt))
+        return false;
+    return true;
+  }
+
+  /// Helper to look for \p I in the context of \p PP.
+  ///
+  /// The context is expanded until \p I was found or no more expansion is
+  /// possible.
+  ///
+  /// \returns True, iff \p I was found.
+  bool findInContextOf(const Instruction *I, const Instruction *PP) {
+    auto EIt = begin(PP), EEnd = end(PP);
+    return findInContextOf(I, EIt, EEnd);
+  }
+
+  /// Helper to look for \p I in the context defined by \p EIt and \p EEnd.
+  ///
+  /// The context is expanded until \p I was found or no more expansion is
+  /// possible.
+  ///
+  /// \returns True, iff \p I was found.
+  bool findInContextOf(const Instruction *I, iterator &EIt, iterator &EEnd) {
+    bool Found = EIt.count(I);
+    while (!Found && EIt != EEnd)
+      Found = (++EIt).getCurrentInst() == I;
+    return Found;
+  }
+
+  /// Return the next instruction that is guaranteed to be executed after \p PP.
+  ///
+  /// \param It              The iterator that is used to traverse the must be
+  ///                        executed context.
+  /// \param PP              The program point for which the next instruction
+  ///                        that is guaranteed to execute is determined.
+  const Instruction *
+  getMustBeExecutedNextInstruction(MustBeExecutedIterator &It,
+                                   const Instruction *PP);
+  /// Return the previous instr. that is guaranteed to be executed before \p PP.
+  ///
+  /// \param It              The iterator that is used to traverse the must be
+  ///                        executed context.
+  /// \param PP              The program point for which the previous instr.
+  ///                        that is guaranteed to execute is determined.
+  const Instruction *
+  getMustBeExecutedPrevInstruction(MustBeExecutedIterator &It,
+                                   const Instruction *PP);
+
+  /// Find the next join point from \p InitBB in forward direction.
+  const BasicBlock *findForwardJoinPoint(const BasicBlock *InitBB);
+
+  /// Find the next join point from \p InitBB in backward direction.
+  const BasicBlock *findBackwardJoinPoint(const BasicBlock *InitBB);
+
+  /// Parameter that limit the performed exploration. See the constructor for
+  /// their meaning.
+  ///{
+  const bool ExploreInterBlock;
+  const bool ExploreCFGForward;
+  const bool ExploreCFGBackward;
+  ///}
+
+private:
+  /// Getters for common CFG analyses: LoopInfo, DominatorTree, and
+  /// PostDominatorTree.
+  ///{
+  GetterTy<const LoopInfo> LIGetter;
+  GetterTy<const DominatorTree> DTGetter;
+  GetterTy<const PostDominatorTree> PDTGetter;
+  ///}
+
+  /// Map to cache isGuaranteedToTransferExecutionToSuccessor results.
+  DenseMap<const BasicBlock *, Optional<bool>> BlockTransferMap;
+
+  /// Map to cache containsIrreducibleCFG results.
+  DenseMap<const Function*, Optional<bool>> IrreducibleControlMap;
+
+  /// Map from instructions to associated must be executed iterators.
+  DenseMap<const Instruction *, std::unique_ptr<MustBeExecutedIterator>>
+      InstructionIteratorMap;
+
+  /// A unique end iterator.
+  MustBeExecutedIterator EndIterator;
+};
+
+class MustExecutePrinterPass : public PassInfoMixin<MustExecutePrinterPass> {
+  raw_ostream &OS;
+
+public:
+  MustExecutePrinterPass(raw_ostream &OS) : OS(OS) {}
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+};
+
+class MustBeExecutedContextPrinterPass
+    : public PassInfoMixin<MustBeExecutedContextPrinterPass> {
+  raw_ostream &OS;
+
+public:
+  MustBeExecutedContextPrinterPass(raw_ostream &OS) : OS(OS) {}
+  PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+};
+
+} // namespace llvm
 
 #endif
diff --git a/linux-x64/clang/include/llvm/Analysis/ObjCARCAnalysisUtils.h b/linux-x64/clang/include/llvm/Analysis/ObjCARCAnalysisUtils.h
index 522abd7..16c5f67 100644
--- a/linux-x64/clang/include/llvm/Analysis/ObjCARCAnalysisUtils.h
+++ b/linux-x64/clang/include/llvm/Analysis/ObjCARCAnalysisUtils.h
@@ -23,24 +23,16 @@
 #define LLVM_LIB_ANALYSIS_OBJCARCANALYSISUTILS_H
 
 #include "llvm/ADT/Optional.h"
-#include "llvm/ADT/StringSwitch.h"
-#include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/Analysis/ObjCARCInstKind.h"
-#include "llvm/Analysis/Passes.h"
 #include "llvm/Analysis/ValueTracking.h"
-#include "llvm/IR/CallSite.h"
 #include "llvm/IR/Constants.h"
-#include "llvm/IR/InstIterator.h"
-#include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/ValueHandle.h"
-#include "llvm/Pass.h"
 
 namespace llvm {
-class raw_ostream;
-}
 
-namespace llvm {
+class AAResults;
+
 namespace objcarc {
 
 /// A handy option to enable/disable all ARC Optimizations.
@@ -74,10 +66,9 @@
 /// This is a wrapper around getUnderlyingObject which also knows how to
 /// look through objc_retain and objc_autorelease calls, which we know to return
 /// their argument verbatim.
-inline const Value *GetUnderlyingObjCPtr(const Value *V,
-                                                const DataLayout &DL) {
+inline const Value *GetUnderlyingObjCPtr(const Value *V) {
   for (;;) {
-    V = GetUnderlyingObject(V, DL);
+    V = getUnderlyingObject(V);
     if (!IsForwarding(GetBasicARCInstKind(V)))
       break;
     V = cast<CallInst>(V)->getArgOperand(0);
@@ -88,12 +79,12 @@
 
 /// A wrapper for GetUnderlyingObjCPtr used for results memoization.
 inline const Value *
-GetUnderlyingObjCPtrCached(const Value *V, const DataLayout &DL,
+GetUnderlyingObjCPtrCached(const Value *V,
                            DenseMap<const Value *, WeakTrackingVH> &Cache) {
   if (auto InCache = Cache.lookup(V))
     return InCache;
 
-  const Value *Computed = GetUnderlyingObjCPtr(V, DL);
+  const Value *Computed = GetUnderlyingObjCPtr(V);
   Cache[V] = const_cast<Value *>(Computed);
   return Computed;
 }
@@ -156,9 +147,7 @@
     return false;
   // Special arguments can not be a valid retainable object pointer.
   if (const Argument *Arg = dyn_cast<Argument>(Op))
-    if (Arg->hasByValAttr() ||
-        Arg->hasInAllocaAttr() ||
-        Arg->hasNestAttr() ||
+    if (Arg->hasPassPointeeByValueCopyAttr() || Arg->hasNestAttr() ||
         Arg->hasStructRetAttr())
       return false;
   // Only consider values with pointer types.
@@ -174,34 +163,16 @@
   return true;
 }
 
-inline bool IsPotentialRetainableObjPtr(const Value *Op,
-                                               AliasAnalysis &AA) {
-  // First make the rudimentary check.
-  if (!IsPotentialRetainableObjPtr(Op))
-    return false;
-
-  // Objects in constant memory are not reference-counted.
-  if (AA.pointsToConstantMemory(Op))
-    return false;
-
-  // Pointers in constant memory are not pointing to reference-counted objects.
-  if (const LoadInst *LI = dyn_cast<LoadInst>(Op))
-    if (AA.pointsToConstantMemory(LI->getPointerOperand()))
-      return false;
-
-  // Otherwise assume the worst.
-  return true;
-}
+bool IsPotentialRetainableObjPtr(const Value *Op, AAResults &AA);
 
 /// Helper for GetARCInstKind. Determines what kind of construct CS
 /// is.
-inline ARCInstKind GetCallSiteClass(ImmutableCallSite CS) {
-  for (ImmutableCallSite::arg_iterator I = CS.arg_begin(), E = CS.arg_end();
-       I != E; ++I)
+inline ARCInstKind GetCallSiteClass(const CallBase &CB) {
+  for (auto I = CB.arg_begin(), E = CB.arg_end(); I != E; ++I)
     if (IsPotentialRetainableObjPtr(*I))
-      return CS.onlyReadsMemory() ? ARCInstKind::User : ARCInstKind::CallOrUser;
+      return CB.onlyReadsMemory() ? ARCInstKind::User : ARCInstKind::CallOrUser;
 
-  return CS.onlyReadsMemory() ? ARCInstKind::None : ARCInstKind::Call;
+  return CB.onlyReadsMemory() ? ARCInstKind::None : ARCInstKind::Call;
 }
 
 /// Return true if this value refers to a distinct and identifiable
diff --git a/linux-x64/clang/include/llvm/Analysis/ObjCARCInstKind.h b/linux-x64/clang/include/llvm/Analysis/ObjCARCInstKind.h
index dc6093a..84565b9 100644
--- a/linux-x64/clang/include/llvm/Analysis/ObjCARCInstKind.h
+++ b/linux-x64/clang/include/llvm/Analysis/ObjCARCInstKind.h
@@ -9,8 +9,6 @@
 #ifndef LLVM_ANALYSIS_OBJCARCINSTKIND_H
 #define LLVM_ANALYSIS_OBJCARCINSTKIND_H
 
-#include "llvm/IR/Function.h"
-#include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/Instructions.h"
 
 namespace llvm {
diff --git a/linux-x64/clang/include/llvm/Analysis/OptimizationRemarkEmitter.h b/linux-x64/clang/include/llvm/Analysis/OptimizationRemarkEmitter.h
index 7b84044..9815dd0 100644
--- a/linux-x64/clang/include/llvm/Analysis/OptimizationRemarkEmitter.h
+++ b/linux-x64/clang/include/llvm/Analysis/OptimizationRemarkEmitter.h
@@ -17,15 +17,11 @@
 #include "llvm/ADT/Optional.h"
 #include "llvm/Analysis/BlockFrequencyInfo.h"
 #include "llvm/IR/DiagnosticInfo.h"
-#include "llvm/IR/Function.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/Pass.h"
 
 namespace llvm {
-class DebugLoc;
-class Loop;
-class Pass;
-class Twine;
+class Function;
 class Value;
 
 /// The optimization diagnostic interface.
@@ -77,7 +73,7 @@
     // remarks enabled. We can't currently check whether remarks are requested
     // for the calling pass since that requires actually building the remark.
 
-    if (F->getContext().getRemarkStreamer() ||
+    if (F->getContext().getLLVMRemarkStreamer() ||
         F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
       auto R = RemarkBuilder();
       emit((DiagnosticInfoOptimizationBase &)R);
@@ -92,8 +88,14 @@
   /// provide more context so that non-trivial false positives can be quickly
   /// detected by the user.
   bool allowExtraAnalysis(StringRef PassName) const {
-    return (F->getContext().getRemarkStreamer() ||
-            F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled(PassName));
+    return OptimizationRemarkEmitter::allowExtraAnalysis(*F, PassName);
+  }
+  static bool allowExtraAnalysis(const Function &F, StringRef PassName) {
+    return allowExtraAnalysis(F.getContext(), PassName);
+  }
+  static bool allowExtraAnalysis(LLVMContext &Ctx, StringRef PassName) {
+    return Ctx.getLLVMRemarkStreamer() ||
+           Ctx.getDiagHandlerPtr()->isAnyRemarkEnabled(PassName);
   }
 
 private:
diff --git a/linux-x64/clang/include/llvm/Analysis/OrderedBasicBlock.h b/linux-x64/clang/include/llvm/Analysis/OrderedBasicBlock.h
deleted file mode 100644
index ae64c01..0000000
--- a/linux-x64/clang/include/llvm/Analysis/OrderedBasicBlock.h
+++ /dev/null
@@ -1,74 +0,0 @@
-//===- llvm/Analysis/OrderedBasicBlock.h --------------------- -*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// This file defines the OrderedBasicBlock class. OrderedBasicBlock maintains
-// an interface where clients can query if one instruction comes before another
-// in a BasicBlock. Since BasicBlock currently lacks a reliable way to query
-// relative position between instructions one can use OrderedBasicBlock to do
-// such queries. OrderedBasicBlock is lazily built on a source BasicBlock and
-// maintains an internal Instruction -> Position map. A OrderedBasicBlock
-// instance should be discarded whenever the source BasicBlock changes.
-//
-// It's currently used by the CaptureTracker in order to find relative
-// positions of a pair of instructions inside a BasicBlock.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_ANALYSIS_ORDEREDBASICBLOCK_H
-#define LLVM_ANALYSIS_ORDEREDBASICBLOCK_H
-
-#include "llvm/ADT/DenseMap.h"
-#include "llvm/IR/BasicBlock.h"
-
-namespace llvm {
-
-class Instruction;
-class BasicBlock;
-
-class OrderedBasicBlock {
-private:
-  /// Map a instruction to its position in a BasicBlock.
-  SmallDenseMap<const Instruction *, unsigned, 32> NumberedInsts;
-
-  /// Keep track of last instruction inserted into \p NumberedInsts.
-  /// It speeds up queries for uncached instructions by providing a start point
-  /// for new queries in OrderedBasicBlock::comesBefore.
-  BasicBlock::const_iterator LastInstFound;
-
-  /// The position/number to tag the next instruction to be found.
-  unsigned NextInstPos;
-
-  /// The source BasicBlock to map.
-  const BasicBlock *BB;
-
-  /// Given no cached results, find if \p A comes before \p B in \p BB.
-  /// Cache and number out instruction while walking \p BB.
-  bool comesBefore(const Instruction *A, const Instruction *B);
-
-public:
-  OrderedBasicBlock(const BasicBlock *BasicB);
-
-  /// Find out whether \p A dominates \p B, meaning whether \p A
-  /// comes before \p B in \p BB. This is a simplification that considers
-  /// cached instruction positions and ignores other basic blocks, being
-  /// only relevant to compare relative instructions positions inside \p BB.
-  /// Returns false for A == B.
-  bool dominates(const Instruction *A, const Instruction *B);
-
-  /// Remove \p from the ordering, if it is present.
-  void eraseInstruction(const Instruction *I);
-
-  /// Replace \p Old with \p New in the ordering. \p New is assigned the
-  /// numbering of \p Old, so it must be inserted at the same position in the
-  /// IR.
-  void replaceInstruction(const Instruction *Old, const Instruction *New);
-};
-
-} // End llvm namespace
-
-#endif
diff --git a/linux-x64/clang/include/llvm/Analysis/OrderedInstructions.h b/linux-x64/clang/include/llvm/Analysis/OrderedInstructions.h
deleted file mode 100644
index 967b146..0000000
--- a/linux-x64/clang/include/llvm/Analysis/OrderedInstructions.h
+++ /dev/null
@@ -1,64 +0,0 @@
-//===- llvm/Transforms/Utils/OrderedInstructions.h -------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// This file defines an efficient way to check for dominance relation between 2
-// instructions.
-//
-// This interface dispatches to appropriate dominance check given 2
-// instructions, i.e. in case the instructions are in the same basic block,
-// OrderedBasicBlock (with instruction numbering and caching) are used.
-// Otherwise, dominator tree is used.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_ANALYSIS_ORDEREDINSTRUCTIONS_H
-#define LLVM_ANALYSIS_ORDEREDINSTRUCTIONS_H
-
-#include "llvm/ADT/DenseMap.h"
-#include "llvm/Analysis/OrderedBasicBlock.h"
-#include "llvm/IR/Dominators.h"
-#include "llvm/IR/Operator.h"
-
-namespace llvm {
-
-class OrderedInstructions {
-  /// Used to check dominance for instructions in same basic block.
-  mutable DenseMap<const BasicBlock *, std::unique_ptr<OrderedBasicBlock>>
-      OBBMap;
-
-  /// The dominator tree of the parent function.
-  DominatorTree *DT;
-
-  /// Return true if the first instruction comes before the second in the
-  /// same basic block. It will create an ordered basic block, if it does
-  /// not yet exist in OBBMap.
-  bool localDominates(const Instruction *, const Instruction *) const;
-
-public:
-  /// Constructor.
-  OrderedInstructions(DominatorTree *DT) : DT(DT) {}
-
-  /// Return true if first instruction dominates the second.
-  bool dominates(const Instruction *, const Instruction *) const;
-
-  /// Return true if the first instruction comes before the second in the
-  /// dominator tree DFS traversal if they are in different basic blocks,
-  /// or if the first instruction comes before the second in the same basic
-  /// block.
-  bool dfsBefore(const Instruction *, const Instruction *) const;
-
-  /// Invalidate the OrderedBasicBlock cache when its basic block changes.
-  /// i.e. If an instruction is deleted or added to the basic block, the user
-  /// should call this function to invalidate the OrderedBasicBlock cache for
-  /// this basic block.
-  void invalidateBlock(const BasicBlock *BB) { OBBMap.erase(BB); }
-};
-
-} // end namespace llvm
-
-#endif // LLVM_ANALYSIS_ORDEREDINSTRUCTIONS_H
diff --git a/linux-x64/clang/include/llvm/Analysis/Passes.h b/linux-x64/clang/include/llvm/Analysis/Passes.h
index d9c97df..afca4d0 100644
--- a/linux-x64/clang/include/llvm/Analysis/Passes.h
+++ b/linux-x64/clang/include/llvm/Analysis/Passes.h
@@ -17,10 +17,7 @@
 namespace llvm {
   class FunctionPass;
   class ImmutablePass;
-  class LoopPass;
   class ModulePass;
-  class Pass;
-  class PassInfo;
 
   //===--------------------------------------------------------------------===//
   //
@@ -103,6 +100,13 @@
   //
   FunctionPass *createMustExecutePrinter();
 
+  //===--------------------------------------------------------------------===//
+  //
+  // createMustBeExecutedContextPrinter - This pass prints information about which
+  // instructions are guaranteed to execute together (run with -analyze).
+  //
+  ModulePass *createMustBeExecutedContextPrinter();
+
 }
 
 #endif
diff --git a/linux-x64/clang/include/llvm/Analysis/PhiValues.h b/linux-x64/clang/include/llvm/Analysis/PhiValues.h
index 124fa21..c0e91c8 100644
--- a/linux-x64/clang/include/llvm/Analysis/PhiValues.h
+++ b/linux-x64/clang/include/llvm/Analysis/PhiValues.h
@@ -21,7 +21,7 @@
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseSet.h"
-#include "llvm/ADT/SmallPtrSet.h"
+#include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/IR/ValueHandle.h"
@@ -29,7 +29,6 @@
 
 namespace llvm {
 
-class Use;
 class Value;
 class PHINode;
 class Function;
@@ -41,7 +40,7 @@
 /// it is queried.
 class PhiValues {
 public:
-  using ValueSet = SmallPtrSet<Value *, 4>;
+  using ValueSet = SmallSetVector<Value *, 4>;
 
   /// Construct an empty PhiValues.
   PhiValues(const Function &F) : F(F) {}
@@ -71,8 +70,7 @@
                   FunctionAnalysisManager::Invalidator &);
 
 private:
-  using PhiSet = SmallPtrSet<const PHINode *, 4>;
-  using ConstValueSet = SmallPtrSet<const Value *, 4>;
+  using ConstValueSet = SmallSetVector<const Value *, 4>;
 
   /// The next depth number to be used by processPhi.
   unsigned int NextDepthNumber = 1;
@@ -108,7 +106,7 @@
 
   /// Process a phi so that its entries in the depth and reachable maps are
   /// fully populated.
-  void processPhi(const PHINode *PN, SmallVector<const PHINode *, 8> &Stack);
+  void processPhi(const PHINode *PN, SmallVectorImpl<const PHINode *> &Stack);
 };
 
 /// The analysis pass which yields a PhiValues
diff --git a/linux-x64/clang/include/llvm/Analysis/PostDominators.h b/linux-x64/clang/include/llvm/Analysis/PostDominators.h
index 87d2e03..296110d 100644
--- a/linux-x64/clang/include/llvm/Analysis/PostDominators.h
+++ b/linux-x64/clang/include/llvm/Analysis/PostDominators.h
@@ -34,6 +34,13 @@
   /// Handle invalidation explicitly.
   bool invalidate(Function &F, const PreservedAnalyses &PA,
                   FunctionAnalysisManager::Invalidator &);
+
+  // Ensure base-class overloads are visible.
+  using Base::dominates;
+
+  /// Return true if \p I1 dominates \p I2. This checks if \p I2 comes before
+  /// \p I1 if they belongs to the same basic block.
+  bool dominates(const Instruction *I1, const Instruction *I2) const;
 };
 
 /// Analysis pass which computes a \c PostDominatorTree.
@@ -68,9 +75,7 @@
 
   PostDominatorTree DT;
 
-  PostDominatorTreeWrapperPass() : FunctionPass(ID) {
-    initializePostDominatorTreeWrapperPassPass(*PassRegistry::getPassRegistry());
-  }
+  PostDominatorTreeWrapperPass();
 
   PostDominatorTree &getPostDomTree() { return DT; }
   const PostDominatorTree &getPostDomTree() const { return DT; }
@@ -83,9 +88,7 @@
     AU.setPreservesAll();
   }
 
-  void releaseMemory() override {
-    DT.releaseMemory();
-  }
+  void releaseMemory() override { DT.reset(); }
 
   void print(raw_ostream &OS, const Module*) const override;
 };
diff --git a/linux-x64/clang/include/llvm/Analysis/ProfileSummaryInfo.h b/linux-x64/clang/include/llvm/Analysis/ProfileSummaryInfo.h
index f309d34..a4e6ffc 100644
--- a/linux-x64/clang/include/llvm/Analysis/ProfileSummaryInfo.h
+++ b/linux-x64/clang/include/llvm/Analysis/ProfileSummaryInfo.h
@@ -14,22 +14,18 @@
 #ifndef LLVM_ANALYSIS_PROFILE_SUMMARY_INFO_H
 #define LLVM_ANALYSIS_PROFILE_SUMMARY_INFO_H
 
-#include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
-#include "llvm/ADT/SmallSet.h"
-#include "llvm/IR/Function.h"
-#include "llvm/IR/Instructions.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/IR/ProfileSummary.h"
-#include "llvm/IR/ValueHandle.h"
 #include "llvm/Pass.h"
 #include <memory>
 
 namespace llvm {
 class BasicBlock;
 class BlockFrequencyInfo;
-class CallSite;
-class ProfileSummary;
+class CallBase;
+class Function;
+
 /// Analysis providing profile information.
 ///
 /// This is an immutable analysis pass that provides ability to query global
@@ -42,9 +38,8 @@
 // units. This would require making this depend on BFI.
 class ProfileSummaryInfo {
 private:
-  Module &M;
+  const Module &M;
   std::unique_ptr<ProfileSummary> Summary;
-  bool computeSummary();
   void computeThresholds();
   // Count thresholds to answer isHotCount and isColdCount queries.
   Optional<uint64_t> HotCountThreshold, ColdCountThreshold;
@@ -52,29 +47,41 @@
   // because the number of profile counts required to reach the hot
   // percentile is above a huge threshold.
   Optional<bool> HasHugeWorkingSetSize;
+  // True if the working set size of the code is considered large,
+  // because the number of profile counts required to reach the hot
+  // percentile is above a large threshold.
+  Optional<bool> HasLargeWorkingSetSize;
+  // Compute the threshold for a given cutoff.
+  Optional<uint64_t> computeThreshold(int PercentileCutoff) const;
+  // The map that caches the threshold values. The keys are the percentile
+  // cutoff values and the values are the corresponding threshold values.
+  mutable DenseMap<int, uint64_t> ThresholdCache;
 
 public:
-  ProfileSummaryInfo(Module &M) : M(M) {}
-  ProfileSummaryInfo(ProfileSummaryInfo &&Arg)
-      : M(Arg.M), Summary(std::move(Arg.Summary)) {}
+  ProfileSummaryInfo(const Module &M) : M(M) { refresh(); }
+
+  ProfileSummaryInfo(ProfileSummaryInfo &&Arg) = default;
+
+  /// If no summary is present, attempt to refresh.
+  void refresh();
 
   /// Returns true if profile summary is available.
-  bool hasProfileSummary() { return computeSummary(); }
+  bool hasProfileSummary() const { return Summary != nullptr; }
 
   /// Returns true if module \c M has sample profile.
-  bool hasSampleProfile() {
+  bool hasSampleProfile() const {
     return hasProfileSummary() &&
            Summary->getKind() == ProfileSummary::PSK_Sample;
   }
 
   /// Returns true if module \c M has instrumentation profile.
-  bool hasInstrumentationProfile() {
+  bool hasInstrumentationProfile() const {
     return hasProfileSummary() &&
            Summary->getKind() == ProfileSummary::PSK_Instr;
   }
 
   /// Returns true if module \c M has context sensitive instrumentation profile.
-  bool hasCSInstrumentationProfile() {
+  bool hasCSInstrumentationProfile() const {
     return hasProfileSummary() &&
            Summary->getKind() == ProfileSummary::PSK_CSInstr;
   }
@@ -91,45 +98,88 @@
   }
 
   /// Returns the profile count for \p CallInst.
-  Optional<uint64_t> getProfileCount(const Instruction *CallInst,
+  Optional<uint64_t> getProfileCount(const CallBase &CallInst,
                                      BlockFrequencyInfo *BFI,
-                                     bool AllowSynthetic = false);
+                                     bool AllowSynthetic = false) const;
+  /// Returns true if module \c M has partial-profile sample profile.
+  bool hasPartialSampleProfile() const;
   /// Returns true if the working set size of the code is considered huge.
-  bool hasHugeWorkingSetSize();
+  bool hasHugeWorkingSetSize() const;
+  /// Returns true if the working set size of the code is considered large.
+  bool hasLargeWorkingSetSize() const;
   /// Returns true if \p F has hot function entry.
-  bool isFunctionEntryHot(const Function *F);
+  bool isFunctionEntryHot(const Function *F) const;
   /// Returns true if \p F contains hot code.
-  bool isFunctionHotInCallGraph(const Function *F, BlockFrequencyInfo &BFI);
+  bool isFunctionHotInCallGraph(const Function *F,
+                                BlockFrequencyInfo &BFI) const;
   /// Returns true if \p F has cold function entry.
-  bool isFunctionEntryCold(const Function *F);
+  bool isFunctionEntryCold(const Function *F) const;
   /// Returns true if \p F contains only cold code.
-  bool isFunctionColdInCallGraph(const Function *F, BlockFrequencyInfo &BFI);
+  bool isFunctionColdInCallGraph(const Function *F,
+                                 BlockFrequencyInfo &BFI) const;
+  /// Returns true if the hotness of \p F is unknown.
+  bool isFunctionHotnessUnknown(const Function &F) const;
+  /// Returns true if \p F contains hot code with regard to a given hot
+  /// percentile cutoff value.
+  bool isFunctionHotInCallGraphNthPercentile(int PercentileCutoff,
+                                             const Function *F,
+                                             BlockFrequencyInfo &BFI) const;
+  /// Returns true if \p F contains cold code with regard to a given cold
+  /// percentile cutoff value.
+  bool isFunctionColdInCallGraphNthPercentile(int PercentileCutoff,
+                                              const Function *F,
+                                              BlockFrequencyInfo &BFI) const;
   /// Returns true if count \p C is considered hot.
-  bool isHotCount(uint64_t C);
+  bool isHotCount(uint64_t C) const;
   /// Returns true if count \p C is considered cold.
-  bool isColdCount(uint64_t C);
+  bool isColdCount(uint64_t C) const;
+  /// Returns true if count \p C is considered hot with regard to a given
+  /// hot percentile cutoff value.
+  bool isHotCountNthPercentile(int PercentileCutoff, uint64_t C) const;
+  /// Returns true if count \p C is considered cold with regard to a given
+  /// cold percentile cutoff value.
+  bool isColdCountNthPercentile(int PercentileCutoff, uint64_t C) const;
   /// Returns true if BasicBlock \p BB is considered hot.
-  bool isHotBlock(const BasicBlock *BB, BlockFrequencyInfo *BFI);
+  bool isHotBlock(const BasicBlock *BB, BlockFrequencyInfo *BFI) const;
   /// Returns true if BasicBlock \p BB is considered cold.
-  bool isColdBlock(const BasicBlock *BB, BlockFrequencyInfo *BFI);
-  /// Returns true if CallSite \p CS is considered hot.
-  bool isHotCallSite(const CallSite &CS, BlockFrequencyInfo *BFI);
-  /// Returns true if Callsite \p CS is considered cold.
-  bool isColdCallSite(const CallSite &CS, BlockFrequencyInfo *BFI);
+  bool isColdBlock(const BasicBlock *BB, BlockFrequencyInfo *BFI) const;
+  /// Returns true if BasicBlock \p BB is considered hot with regard to a given
+  /// hot percentile cutoff value.
+  bool isHotBlockNthPercentile(int PercentileCutoff, const BasicBlock *BB,
+                               BlockFrequencyInfo *BFI) const;
+  /// Returns true if BasicBlock \p BB is considered cold with regard to a given
+  /// cold percentile cutoff value.
+  bool isColdBlockNthPercentile(int PercentileCutoff, const BasicBlock *BB,
+                                BlockFrequencyInfo *BFI) const;
+  /// Returns true if the call site \p CB is considered hot.
+  bool isHotCallSite(const CallBase &CB, BlockFrequencyInfo *BFI) const;
+  /// Returns true if call site \p CB is considered cold.
+  bool isColdCallSite(const CallBase &CB, BlockFrequencyInfo *BFI) const;
   /// Returns HotCountThreshold if set. Recompute HotCountThreshold
   /// if not set.
-  uint64_t getOrCompHotCountThreshold();
+  uint64_t getOrCompHotCountThreshold() const;
   /// Returns ColdCountThreshold if set. Recompute HotCountThreshold
   /// if not set.
-  uint64_t getOrCompColdCountThreshold();
+  uint64_t getOrCompColdCountThreshold() const;
   /// Returns HotCountThreshold if set.
-  uint64_t getHotCountThreshold() {
+  uint64_t getHotCountThreshold() const {
     return HotCountThreshold ? HotCountThreshold.getValue() : 0;
   }
   /// Returns ColdCountThreshold if set.
-  uint64_t getColdCountThreshold() {
+  uint64_t getColdCountThreshold() const {
     return ColdCountThreshold ? ColdCountThreshold.getValue() : 0;
   }
+
+ private:
+   template <bool isHot>
+   bool isFunctionHotOrColdInCallGraphNthPercentile(
+       int PercentileCutoff, const Function *F, BlockFrequencyInfo &BFI) const;
+   template <bool isHot>
+   bool isHotOrColdCountNthPercentile(int PercentileCutoff, uint64_t C) const;
+   template <bool isHot>
+   bool isHotOrColdBlockNthPercentile(int PercentileCutoff,
+                                      const BasicBlock *BB,
+                                      BlockFrequencyInfo *BFI) const;
 };
 
 /// An analysis pass based on legacy pass manager to deliver ProfileSummaryInfo.
diff --git a/linux-x64/clang/include/llvm/Analysis/PtrUseVisitor.h b/linux-x64/clang/include/llvm/Analysis/PtrUseVisitor.h
index fbf04c8..78e9251 100644
--- a/linux-x64/clang/include/llvm/Analysis/PtrUseVisitor.h
+++ b/linux-x64/clang/include/llvm/Analysis/PtrUseVisitor.h
@@ -26,7 +26,6 @@
 #include "llvm/ADT/PointerIntPair.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
-#include "llvm/IR/CallSite.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/InstVisitor.h"
@@ -222,9 +221,9 @@
     // offsets on this pointer.
     // FIXME: Support a vector of pointers.
     assert(I.getType()->isPointerTy());
-    IntegerType *IntPtrTy = cast<IntegerType>(DL.getIntPtrType(I.getType()));
+    IntegerType *IntIdxTy = cast<IntegerType>(DL.getIndexType(I.getType()));
     IsOffsetKnown = true;
-    Offset = APInt(IntPtrTy->getBitWidth(), 0);
+    Offset = APInt(IntIdxTy->getBitWidth(), 0);
     PI.reset();
 
     // Enqueue the uses of this pointer.
@@ -295,9 +294,9 @@
 
   // Generically, arguments to calls and invokes escape the pointer to some
   // other function. Mark that.
-  void visitCallSite(CallSite CS) {
-    PI.setEscaped(CS.getInstruction());
-    Base::visitCallSite(CS);
+  void visitCallBase(CallBase &CB) {
+    PI.setEscaped(&CB);
+    Base::visitCallBase(CB);
   }
 };
 
diff --git a/linux-x64/clang/include/llvm/Analysis/RegionInfo.h b/linux-x64/clang/include/llvm/Analysis/RegionInfo.h
index 8bcc3e8..f93081d 100644
--- a/linux-x64/clang/include/llvm/Analysis/RegionInfo.h
+++ b/linux-x64/clang/include/llvm/Analysis/RegionInfo.h
@@ -59,7 +59,6 @@
 namespace llvm {
 
 class DominanceFrontier;
-class DominatorTree;
 class Loop;
 class LoopInfo;
 class PostDominatorTree;
@@ -574,10 +573,9 @@
   template <bool IsConst>
   class block_iterator_wrapper
       : public df_iterator<
-            typename std::conditional<IsConst, const BlockT, BlockT>::type *> {
+            std::conditional_t<IsConst, const BlockT, BlockT> *> {
     using super =
-        df_iterator<
-            typename std::conditional<IsConst, const BlockT, BlockT>::type *>;
+        df_iterator<std::conditional_t<IsConst, const BlockT, BlockT> *>;
 
   public:
     using Self = block_iterator_wrapper<IsConst>;
@@ -878,8 +876,6 @@
   void verifyAnalysis() const;
 };
 
-class Region;
-
 class RegionNode : public RegionNodeBase<RegionTraits<Function>> {
 public:
   inline RegionNode(Region *Parent, BasicBlock *Entry, bool isSubRegion = false)
diff --git a/linux-x64/clang/include/llvm/Analysis/RegionInfoImpl.h b/linux-x64/clang/include/llvm/Analysis/RegionInfoImpl.h
index c59c09d..d28aee7 100644
--- a/linux-x64/clang/include/llvm/Analysis/RegionInfoImpl.h
+++ b/linux-x64/clang/include/llvm/Analysis/RegionInfoImpl.h
@@ -236,7 +236,7 @@
 
     getEntry()->printAsOperand(OS, false);
   } else
-    entryName = getEntry()->getName();
+    entryName = std::string(getEntry()->getName());
 
   if (getExit()) {
     if (getExit()->getName().empty()) {
@@ -244,7 +244,7 @@
 
       getExit()->printAsOperand(OS, false);
     } else
-      exitName = getExit()->getName();
+      exitName = std::string(getExit()->getName());
   } else
     exitName = "<Function Return>";
 
@@ -365,7 +365,7 @@
     auto Deconst = const_cast<RegionBase<Tr> *>(this);
     typename BBNodeMapT::value_type V = {
         BB,
-        llvm::make_unique<RegionNodeT>(static_cast<RegionT *>(Deconst), BB)};
+        std::make_unique<RegionNodeT>(static_cast<RegionT *>(Deconst), BB)};
     at = BBNodeMap.insert(std::move(V)).first;
   }
   return at->second.get();
@@ -585,10 +585,8 @@
   // Exit is the header of a loop that contains the entry. In this case,
   // the dominance frontier must only contain the exit.
   if (!DT->dominates(entry, exit)) {
-    for (typename DST::iterator SI = entrySuccs->begin(),
-                                SE = entrySuccs->end();
-         SI != SE; ++SI) {
-      if (*SI != exit && *SI != entry)
+    for (BlockT *successor : *entrySuccs) {
+      if (successor != exit && successor != entry)
         return false;
     }
 
@@ -724,7 +722,7 @@
 
 template <class Tr>
 void RegionInfoBase<Tr>::scanForRegions(FuncT &F, BBtoBBMap *ShortCut) {
-  using FuncPtrT = typename std::add_pointer<FuncT>::type;
+  using FuncPtrT = std::add_pointer_t<FuncT>;
 
   BlockT *entry = GraphTraits<FuncPtrT>::getEntryNode(&F);
   DomTreeNodeT *N = DT->getNode(entry);
@@ -817,8 +815,7 @@
 // Region pass manager support.
 template <class Tr>
 typename Tr::RegionT *RegionInfoBase<Tr>::getRegionFor(BlockT *BB) const {
-  typename BBtoRegionMap::const_iterator I = BBtoRegion.find(BB);
-  return I != BBtoRegion.end() ? I->second : nullptr;
+  return BBtoRegion.lookup(BB);
 }
 
 template <class Tr>
@@ -912,7 +909,7 @@
 
 template <class Tr>
 void RegionInfoBase<Tr>::calculate(FuncT &F) {
-  using FuncPtrT = typename std::add_pointer<FuncT>::type;
+  using FuncPtrT = std::add_pointer_t<FuncT>;
 
   // ShortCut a function where for every BB the exit of the largest region
   // starting with BB is stored. These regions can be threated as single BBS.
diff --git a/linux-x64/clang/include/llvm/Analysis/RegionPass.h b/linux-x64/clang/include/llvm/Analysis/RegionPass.h
index 5b1864a..5c7fa5f 100644
--- a/linux-x64/clang/include/llvm/Analysis/RegionPass.h
+++ b/linux-x64/clang/include/llvm/Analysis/RegionPass.h
@@ -16,15 +16,13 @@
 #define LLVM_ANALYSIS_REGIONPASS_H
 
 #include "llvm/Analysis/RegionInfo.h"
-#include "llvm/IR/Function.h"
 #include "llvm/IR/LegacyPassManagers.h"
 #include "llvm/Pass.h"
 #include <deque>
 
 namespace llvm {
-
-class RGPassManager;
 class Function;
+class RGPassManager;
 
 //===----------------------------------------------------------------------===//
 /// A pass that runs on each Region in a function.
@@ -87,8 +85,6 @@
 /// The pass manager to schedule RegionPasses.
 class RGPassManager : public FunctionPass, public PMDataManager {
   std::deque<Region*> RQ;
-  bool skipThisRegion;
-  bool redoThisRegion;
   RegionInfo *RI;
   Region *CurrentRegion;
 
diff --git a/linux-x64/clang/include/llvm/Analysis/ReplayInlineAdvisor.h b/linux-x64/clang/include/llvm/Analysis/ReplayInlineAdvisor.h
new file mode 100644
index 0000000..7e2b095
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Analysis/ReplayInlineAdvisor.h
@@ -0,0 +1,38 @@
+//===- ReplayInlineAdvisor.h - Replay Inline Advisor interface -*- C++ --*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+#ifndef LLVM_ANALYSIS_REPLAYINLINEADVISOR_H
+#define LLVM_ANALYSIS_REPLAYINLINEADVISOR_H
+
+#include "llvm/ADT/StringSet.h"
+#include "llvm/Analysis/InlineAdvisor.h"
+#include "llvm/IR/LLVMContext.h"
+
+namespace llvm {
+class BasicBlock;
+class CallBase;
+class Function;
+class Module;
+class OptimizationRemarkEmitter;
+
+/// Replay inline advisor that uses optimization remarks from inlining of
+/// previous build to guide current inlining. This is useful for inliner tuning.
+class ReplayInlineAdvisor : public InlineAdvisor {
+public:
+  ReplayInlineAdvisor(FunctionAnalysisManager &FAM, LLVMContext &Context,
+                      StringRef RemarksFile, bool EmitRemarks);
+  std::unique_ptr<InlineAdvice> getAdviceImpl(CallBase &CB) override;
+  bool areReplayRemarksLoaded() const { return HasReplayRemarks; }
+
+private:
+  StringSet<> InlineSitesFromRemarks;
+  bool HasReplayRemarks = false;
+  bool EmitRemarks = false;
+};
+} // namespace llvm
+#endif // LLVM_ANALYSIS_REPLAYINLINEADVISOR_H
diff --git a/linux-x64/clang/include/llvm/Analysis/ScalarEvolution.h b/linux-x64/clang/include/llvm/Analysis/ScalarEvolution.h
index 0bd98ef..b3f199d 100644
--- a/linux-x64/clang/include/llvm/Analysis/ScalarEvolution.h
+++ b/linux-x64/clang/include/llvm/Analysis/ScalarEvolution.h
@@ -31,7 +31,6 @@
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
-#include "llvm/Analysis/LoopInfo.h"
 #include "llvm/IR/ConstantRange.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/InstrTypes.h"
@@ -61,6 +60,8 @@
 class GEPOperator;
 class Instruction;
 class LLVMContext;
+class Loop;
+class LoopInfo;
 class raw_ostream;
 class ScalarEvolution;
 class SCEVAddRecExpr;
@@ -69,6 +70,7 @@
 class TargetLibraryInfo;
 class Type;
 class Value;
+enum SCEVTypes : unsigned short;
 
 /// This class represents an analyzed expression in the program.  These are
 /// opaque objects that the client is not allowed to do much with directly.
@@ -81,7 +83,7 @@
   FoldingSetNodeIDRef FastID;
 
   // The SCEV baseclass this node corresponds to
-  const unsigned short SCEVType;
+  const SCEVTypes SCEVType;
 
 protected:
   // Estimated complexity of this node's expression tree size.
@@ -118,13 +120,13 @@
     NoWrapMask = (1 << 3) - 1
   };
 
-  explicit SCEV(const FoldingSetNodeIDRef ID, unsigned SCEVTy,
+  explicit SCEV(const FoldingSetNodeIDRef ID, SCEVTypes SCEVTy,
                 unsigned short ExpressionSize)
       : FastID(ID), SCEVType(SCEVTy), ExpressionSize(ExpressionSize) {}
   SCEV(const SCEV &) = delete;
   SCEV &operator=(const SCEV &) = delete;
 
-  unsigned getSCEVType() const { return SCEVType; }
+  SCEVTypes getSCEVType() const { return SCEVType; }
 
   /// Return the LLVM type of this SCEV expression.
   Type *getType() const;
@@ -435,39 +437,12 @@
   }
 };
 
-struct ExitLimitQuery {
-  ExitLimitQuery(const Loop *L, BasicBlock *ExitingBlock, bool AllowPredicates)
-      : L(L), ExitingBlock(ExitingBlock), AllowPredicates(AllowPredicates) {}
-
-  const Loop *L;
-  BasicBlock *ExitingBlock;
-  bool AllowPredicates;
-};
-
-template <> struct DenseMapInfo<ExitLimitQuery> {
-  static inline ExitLimitQuery getEmptyKey() {
-    return ExitLimitQuery(nullptr, nullptr, true);
-  }
-
-  static inline ExitLimitQuery getTombstoneKey() {
-    return ExitLimitQuery(nullptr, nullptr, false);
-  }
-
-  static unsigned getHashValue(ExitLimitQuery Val) {
-    return hash_combine(hash_combine(Val.L, Val.ExitingBlock),
-                        Val.AllowPredicates);
-  }
-
-  static bool isEqual(ExitLimitQuery LHS, ExitLimitQuery RHS) {
-    return LHS.L == RHS.L && LHS.ExitingBlock == RHS.ExitingBlock &&
-           LHS.AllowPredicates == RHS.AllowPredicates;
-  }
-};
-
 /// The main scalar evolution driver. Because client code (intentionally)
 /// can't do much with the SCEV objects directly, they must ask this class
 /// for services.
 class ScalarEvolution {
+  friend class ScalarEvolutionsTest;
+
 public:
   /// An enum describing the relationship between a SCEV and a loop.
   enum LoopDisposition {
@@ -537,6 +512,7 @@
   const SCEV *getConstant(ConstantInt *V);
   const SCEV *getConstant(const APInt &Val);
   const SCEV *getConstant(Type *Ty, uint64_t V, bool isSigned = false);
+  const SCEV *getPtrToIntExpr(const SCEV *Op, Type *Ty, unsigned Depth = 0);
   const SCEV *getTruncateExpr(const SCEV *Op, Type *Ty, unsigned Depth = 0);
   const SCEV *getZeroExtendExpr(const SCEV *Op, Type *Ty, unsigned Depth = 0);
   const SCEV *getSignExtendExpr(const SCEV *Op, Type *Ty, unsigned Depth = 0);
@@ -598,7 +574,9 @@
   /// \p IndexExprs The expressions for the indices.
   const SCEV *getGEPExpr(GEPOperator *GEP,
                          const SmallVectorImpl<const SCEV *> &IndexExprs);
-  const SCEV *getMinMaxExpr(unsigned Kind,
+  const SCEV *getAbsExpr(const SCEV *Op, bool IsNSW);
+  const SCEV *getSignumExpr(const SCEV *Op);
+  const SCEV *getMinMaxExpr(SCEVTypes Kind,
                             SmallVectorImpl<const SCEV *> &Operands);
   const SCEV *getSMaxExpr(const SCEV *LHS, const SCEV *RHS);
   const SCEV *getSMaxExpr(SmallVectorImpl<const SCEV *> &Operands);
@@ -617,9 +595,22 @@
   /// Return a SCEV for the constant 1 of a specific type.
   const SCEV *getOne(Type *Ty) { return getConstant(Ty, 1); }
 
-  /// Return an expression for sizeof AllocTy that is type IntTy
+  /// Return a SCEV for the constant -1 of a specific type.
+  const SCEV *getMinusOne(Type *Ty) {
+    return getConstant(Ty, -1, /*isSigned=*/true);
+  }
+
+  /// Return an expression for sizeof ScalableTy that is type IntTy, where
+  /// ScalableTy is a scalable vector type.
+  const SCEV *getSizeOfScalableVectorExpr(Type *IntTy,
+                                          ScalableVectorType *ScalableTy);
+
+  /// Return an expression for the alloc size of AllocTy that is type IntTy
   const SCEV *getSizeOfExpr(Type *IntTy, Type *AllocTy);
 
+  /// Return an expression for the store size of StoreTy that is type IntTy
+  const SCEV *getStoreSizeOfExpr(Type *IntTy, Type *StoreTy);
+
   /// Return an expression for offsetof on the given field with type IntTy
   const SCEV *getOffsetOfExpr(Type *IntTy, StructType *STy, unsigned FieldNo);
 
@@ -703,6 +694,12 @@
   bool isLoopEntryGuardedByCond(const Loop *L, ICmpInst::Predicate Pred,
                                 const SCEV *LHS, const SCEV *RHS);
 
+  /// Test whether entry to the basic block is protected by a conditional
+  /// between LHS and RHS.
+  bool isBasicBlockEntryGuardedByCond(const BasicBlock *BB,
+                                      ICmpInst::Predicate Pred, const SCEV *LHS,
+                                      const SCEV *RHS);
+
   /// Test whether the backedge of the loop is protected by a conditional
   /// between LHS and RHS.  This is used to eliminate casts.
   bool isLoopBackedgeGuardedByCond(const Loop *L, ICmpInst::Predicate Pred,
@@ -722,7 +719,8 @@
   /// before taking the branch. For loops with multiple exits, it may not be
   /// the number times that the loop header executes if the loop exits
   /// prematurely via another branch.
-  unsigned getSmallConstantTripCount(const Loop *L, BasicBlock *ExitingBlock);
+  unsigned getSmallConstantTripCount(const Loop *L,
+                                     const BasicBlock *ExitingBlock);
 
   /// Returns the upper bound of the loop trip count as a normal unsigned
   /// value.
@@ -744,15 +742,29 @@
   /// for getSmallConstantTripCount, this assumes that control exits the loop
   /// via ExitingBlock.
   unsigned getSmallConstantTripMultiple(const Loop *L,
-                                        BasicBlock *ExitingBlock);
+                                        const BasicBlock *ExitingBlock);
+
+  /// The terms "backedge taken count" and "exit count" are used
+  /// interchangeably to refer to the number of times the backedge of a loop 
+  /// has executed before the loop is exited.
+  enum ExitCountKind {
+    /// An expression exactly describing the number of times the backedge has
+    /// executed when a loop is exited.
+    Exact,
+    /// A constant which provides an upper bound on the exact trip count.
+    ConstantMaximum,
+    /// An expression which provides an upper bound on the exact trip count.
+    SymbolicMaximum,
+  };
 
   /// Return the number of times the backedge executes before the given exit
   /// would be taken; if not exactly computable, return SCEVCouldNotCompute. 
   /// For a single exit loop, this value is equivelent to the result of
   /// getBackedgeTakenCount.  The loop is guaranteed to exit (via *some* exit)
   /// before the backedge is executed (ExitCount + 1) times.  Note that there
-  /// is no guarantee about *which* exit is taken on the exiting iteration.  
-  const SCEV *getExitCount(const Loop *L, BasicBlock *ExitingBlock);
+  /// is no guarantee about *which* exit is taken on the exiting iteration.
+  const SCEV *getExitCount(const Loop *L, const BasicBlock *ExitingBlock,
+                           ExitCountKind Kind = Exact);
 
   /// If the specified loop has a predictable backedge-taken count, return it,
   /// otherwise return a SCEVCouldNotCompute object. The backedge-taken count is
@@ -764,7 +776,7 @@
   /// Note that it is not valid to call this method on a loop without a
   /// loop-invariant backedge-taken count (see
   /// hasLoopInvariantBackedgeTakenCount).
-  const SCEV *getBackedgeTakenCount(const Loop *L);
+  const SCEV *getBackedgeTakenCount(const Loop *L, ExitCountKind Kind = Exact);
 
   /// Similar to getBackedgeTakenCount, except it will add a set of
   /// SCEV predicates to Predicates that are required to be true in order for
@@ -777,10 +789,20 @@
   /// to (i.e. a "conservative over-approximation") of the value returend by
   /// getBackedgeTakenCount.  If such a value cannot be computed, it returns the
   /// SCEVCouldNotCompute object.
-  const SCEV *getMaxBackedgeTakenCount(const Loop *L);
+  const SCEV *getConstantMaxBackedgeTakenCount(const Loop *L) {
+    return getBackedgeTakenCount(L, ConstantMaximum);
+  }
+
+  /// When successful, this returns a SCEV that is greater than or equal
+  /// to (i.e. a "conservative over-approximation") of the value returend by
+  /// getBackedgeTakenCount.  If such a value cannot be computed, it returns the
+  /// SCEVCouldNotCompute object.
+  const SCEV *getSymbolicMaxBackedgeTakenCount(const Loop *L) {
+    return getBackedgeTakenCount(L, SymbolicMaximum);
+  }
 
   /// Return true if the backedge taken count is either the value returned by
-  /// getMaxBackedgeTakenCount or zero.
+  /// getConstantMaxBackedgeTakenCount or zero.
   bool isBackedgeTakenCountMaxOrZero(const Loop *L);
 
   /// Return true if the specified loop has an analyzable loop-invariant
@@ -816,7 +838,7 @@
   ///
   /// We don't have a way to invalidate per-loop dispositions. Clear and
   /// recompute is simpler.
-  void forgetLoopDispositions(const Loop *L) { LoopDispositions.clear(); }
+  void forgetLoopDispositions(const Loop *L);
 
   /// Determine the minimum number of zero bits that S is guaranteed to end in
   /// (at every loop iteration).  It is, at the same time, the minimum number
@@ -916,32 +938,61 @@
   bool isKnownPredicate(ICmpInst::Predicate Pred, const SCEV *LHS,
                         const SCEV *RHS);
 
+  /// Test if the given expression is known to satisfy the condition described
+  /// by Pred, LHS, and RHS in the given Context.
+  bool isKnownPredicateAt(ICmpInst::Predicate Pred, const SCEV *LHS,
+                        const SCEV *RHS, const Instruction *Context);
+
   /// Test if the condition described by Pred, LHS, RHS is known to be true on
   /// every iteration of the loop of the recurrency LHS.
   bool isKnownOnEveryIteration(ICmpInst::Predicate Pred,
                                const SCEVAddRecExpr *LHS, const SCEV *RHS);
 
-  /// Return true if, for all loop invariant X, the predicate "LHS `Pred` X"
-  /// is monotonically increasing or decreasing.  In the former case set
-  /// `Increasing` to true and in the latter case set `Increasing` to false.
-  ///
   /// A predicate is said to be monotonically increasing if may go from being
   /// false to being true as the loop iterates, but never the other way
   /// around.  A predicate is said to be monotonically decreasing if may go
   /// from being true to being false as the loop iterates, but never the other
   /// way around.
-  bool isMonotonicPredicate(const SCEVAddRecExpr *LHS, ICmpInst::Predicate Pred,
-                            bool &Increasing);
+  enum MonotonicPredicateType {
+    MonotonicallyIncreasing,
+    MonotonicallyDecreasing
+  };
 
-  /// Return true if the result of the predicate LHS `Pred` RHS is loop
-  /// invariant with respect to L.  Set InvariantPred, InvariantLHS and
-  /// InvariantLHS so that InvariantLHS `InvariantPred` InvariantRHS is the
-  /// loop invariant form of LHS `Pred` RHS.
-  bool isLoopInvariantPredicate(ICmpInst::Predicate Pred, const SCEV *LHS,
-                                const SCEV *RHS, const Loop *L,
-                                ICmpInst::Predicate &InvariantPred,
-                                const SCEV *&InvariantLHS,
-                                const SCEV *&InvariantRHS);
+  /// If, for all loop invariant X, the predicate "LHS `Pred` X" is
+  /// monotonically increasing or decreasing, returns
+  /// Some(MonotonicallyIncreasing) and Some(MonotonicallyDecreasing)
+  /// respectively. If we could not prove either of these facts, returns None.
+  Optional<MonotonicPredicateType>
+  getMonotonicPredicateType(const SCEVAddRecExpr *LHS,
+                            ICmpInst::Predicate Pred);
+
+  struct LoopInvariantPredicate {
+    ICmpInst::Predicate Pred;
+    const SCEV *LHS;
+    const SCEV *RHS;
+
+    LoopInvariantPredicate(ICmpInst::Predicate Pred, const SCEV *LHS,
+                           const SCEV *RHS)
+        : Pred(Pred), LHS(LHS), RHS(RHS) {}
+  };
+  /// If the result of the predicate LHS `Pred` RHS is loop invariant with
+  /// respect to L, return a LoopInvariantPredicate with LHS and RHS being
+  /// invariants, available at L's entry. Otherwise, return None.
+  Optional<LoopInvariantPredicate>
+  getLoopInvariantPredicate(ICmpInst::Predicate Pred, const SCEV *LHS,
+                            const SCEV *RHS, const Loop *L);
+
+  /// If the result of the predicate LHS `Pred` RHS is loop invariant with
+  /// respect to L at given Context during at least first MaxIter iterations,
+  /// return a LoopInvariantPredicate with LHS and RHS being invariants,
+  /// available at L's entry. Otherwise, return None. The predicate should be
+  /// the loop's exit condition.
+  Optional<LoopInvariantPredicate>
+  getLoopInvariantExitCondDuringFirstIterations(ICmpInst::Predicate Pred,
+                                                const SCEV *LHS,
+                                                const SCEV *RHS, const Loop *L,
+                                                const Instruction *Context,
+                                                const SCEV *MaxIter);
 
   /// Simplify LHS and RHS in a comparison with predicate Pred. Return true
   /// iff any changes were made. If the operands are provably equal or
@@ -1010,6 +1061,19 @@
                               SmallVectorImpl<const SCEV *> &Subscripts,
                               SmallVectorImpl<const SCEV *> &Sizes);
 
+  /// Gathers the individual index expressions from a GEP instruction.
+  ///
+  /// This function optimistically assumes the GEP references into a fixed size
+  /// array. If this is actually true, this function returns a list of array
+  /// subscript expressions in \p Subscripts and a list of integers describing
+  /// the size of the individual array dimensions in \p Sizes. Both lists have
+  /// either equal length or the size list is one element shorter in case there
+  /// is no known size available for the outermost array dimension. Returns true
+  /// if successful and false otherwise.
+  bool getIndexExpressionsFromGEP(const GetElementPtrInst *GEP,
+                                  SmallVectorImpl<const SCEV *> &Subscripts,
+                                  SmallVectorImpl<int> &Sizes);
+
   /// Split this SCEVAddRecExpr into two vectors of SCEVs representing the
   /// subscripts and sizes of an array access.
   ///
@@ -1099,6 +1163,20 @@
       const SCEV *S, const Loop *L,
       SmallPtrSetImpl<const SCEVPredicate *> &Preds);
 
+  /// Compute \p LHS - \p RHS and returns the result as an APInt if it is a
+  /// constant, and None if it isn't.
+  ///
+  /// This is intended to be a cheaper version of getMinusSCEV.  We can be
+  /// frugal here since we just bail out of actually constructing and
+  /// canonicalizing an expression in the cases where the result isn't going
+  /// to be a constant.
+  Optional<APInt> computeConstantDifference(const SCEV *LHS, const SCEV *RHS);
+
+  /// Update no-wrap flags of an AddRec. This may drop the cached info about
+  /// this AddRec (such as range info) in case if new flags may potentially
+  /// sharpen it.
+  void setNoWrapFlags(SCEVAddRecExpr *AddRec, SCEV::NoWrapFlags Flags);
+
 private:
   /// A CallbackVH to arrange for ScalarEvolution to be notified whenever a
   /// Value is deleted.
@@ -1179,7 +1257,7 @@
   ValueExprMapType ValueExprMap;
 
   /// Mark predicate values currently being processed by isImpliedCond.
-  SmallPtrSet<Value *, 6> PendingLoopPredicates;
+  SmallPtrSet<const Value *, 6> PendingLoopPredicates;
 
   /// Mark SCEVUnknown Phis currently being processed by getRangeRef.
   SmallPtrSet<const PHINode *, 6> PendingPhiRanges;
@@ -1225,6 +1303,9 @@
       Predicates.insert(P);
     }
 
+    /// Construct either an exact exit limit from a constant, or an unknown
+    /// one from a SCEVCouldNotCompute.  No other types of SCEVs are allowed
+    /// as arguments and asserts enforce that internally.
     /*implicit*/ ExitLimit(const SCEV *E);
 
     ExitLimit(
@@ -1256,13 +1337,15 @@
   struct ExitNotTakenInfo {
     PoisoningVH<BasicBlock> ExitingBlock;
     const SCEV *ExactNotTaken;
+    const SCEV *MaxNotTaken;
     std::unique_ptr<SCEVUnionPredicate> Predicate;
 
     explicit ExitNotTakenInfo(PoisoningVH<BasicBlock> ExitingBlock,
                               const SCEV *ExactNotTaken,
+                              const SCEV *MaxNotTaken,
                               std::unique_ptr<SCEVUnionPredicate> Predicate)
-        : ExitingBlock(ExitingBlock), ExactNotTaken(ExactNotTaken),
-          Predicate(std::move(Predicate)) {}
+      : ExitingBlock(ExitingBlock), ExactNotTaken(ExactNotTaken),
+        MaxNotTaken(ExactNotTaken), Predicate(std::move(Predicate)) {}
 
     bool hasAlwaysTruePredicate() const {
       return !Predicate || Predicate->isAlwaysTrue();
@@ -1277,39 +1360,41 @@
     /// never have more than one computable exit.
     SmallVector<ExitNotTakenInfo, 1> ExitNotTaken;
 
-    /// The pointer part of \c MaxAndComplete is an expression indicating the
-    /// least maximum backedge-taken count of the loop that is known, or a
-    /// SCEVCouldNotCompute. This expression is only valid if the predicates
-    /// associated with all loop exits are true.
-    ///
-    /// The integer part of \c MaxAndComplete is a boolean indicating if \c
-    /// ExitNotTaken has an element for every exiting block in the loop.
-    PointerIntPair<const SCEV *, 1> MaxAndComplete;
+    /// Expression indicating the least constant maximum backedge-taken count of
+    /// the loop that is known, or a SCEVCouldNotCompute. This expression is
+    /// only valid if the redicates associated with all loop exits are true.
+    const SCEV *ConstantMax;
+
+    /// Indicating if \c ExitNotTaken has an element for every exiting block in
+    /// the loop.
+    bool IsComplete;
+
+    /// Expression indicating the least maximum backedge-taken count of the loop
+    /// that is known, or a SCEVCouldNotCompute. Lazily computed on first query.
+    const SCEV *SymbolicMax = nullptr;
 
     /// True iff the backedge is taken either exactly Max or zero times.
     bool MaxOrZero = false;
 
-    /// \name Helper projection functions on \c MaxAndComplete.
-    /// @{
-    bool isComplete() const { return MaxAndComplete.getInt(); }
-    const SCEV *getMax() const { return MaxAndComplete.getPointer(); }
-    /// @}
+    bool isComplete() const { return IsComplete; }
+    const SCEV *getConstantMax() const { return ConstantMax; }
 
   public:
-    BackedgeTakenInfo() : MaxAndComplete(nullptr, 0) {}
+    BackedgeTakenInfo() : ConstantMax(nullptr), IsComplete(false) {}
     BackedgeTakenInfo(BackedgeTakenInfo &&) = default;
     BackedgeTakenInfo &operator=(BackedgeTakenInfo &&) = default;
 
     using EdgeExitInfo = std::pair<BasicBlock *, ExitLimit>;
 
     /// Initialize BackedgeTakenInfo from a list of exact exit counts.
-    BackedgeTakenInfo(ArrayRef<EdgeExitInfo> ExitCounts, bool Complete,
-                      const SCEV *MaxCount, bool MaxOrZero);
+    BackedgeTakenInfo(ArrayRef<EdgeExitInfo> ExitCounts, bool IsComplete,
+                      const SCEV *ConstantMax, bool MaxOrZero);
 
     /// Test whether this BackedgeTakenInfo contains any computed information,
     /// or whether it's all SCEVCouldNotCompute values.
     bool hasAnyInfo() const {
-      return !ExitNotTaken.empty() || !isa<SCEVCouldNotCompute>(getMax());
+      return !ExitNotTaken.empty() ||
+             !isa<SCEVCouldNotCompute>(getConstantMax());
     }
 
     /// Test whether this BackedgeTakenInfo contains complete information.
@@ -1340,14 +1425,22 @@
     /// edge, or SCEVCouldNotCompute. The loop is guaranteed not to exit via
     /// this block before this number of iterations, but may exit via another
     /// block.
-    const SCEV *getExact(BasicBlock *ExitingBlock, ScalarEvolution *SE) const;
+    const SCEV *getExact(const BasicBlock *ExitingBlock,
+                         ScalarEvolution *SE) const;
 
-    /// Get the max backedge taken count for the loop.
-    const SCEV *getMax(ScalarEvolution *SE) const;
+    /// Get the constant max backedge taken count for the loop.
+    const SCEV *getConstantMax(ScalarEvolution *SE) const;
+
+    /// Get the constant max backedge taken count for the particular loop exit.
+    const SCEV *getConstantMax(const BasicBlock *ExitingBlock,
+                               ScalarEvolution *SE) const;
+
+    /// Get the symbolic max backedge taken count for the loop.
+    const SCEV *getSymbolicMax(const Loop *L, ScalarEvolution *SE);
 
     /// Return true if the number of times this backedge is taken is either the
-    /// value returned by getMax or zero.
-    bool isMaxOrZero(ScalarEvolution *SE) const;
+    /// value returned by getConstantMax or zero.
+    bool isConstantMaxOrZero(ScalarEvolution *SE) const;
 
     /// Return true if any backedge taken count expressions refer to the given
     /// subexpression.
@@ -1452,6 +1545,13 @@
   ConstantRange getRangeForAffineAR(const SCEV *Start, const SCEV *Stop,
                                     const SCEV *MaxBECount, unsigned BitWidth);
 
+  /// Determines the range for the affine non-self-wrapping SCEVAddRecExpr {\p
+  /// Start,+,\p Stop}<nw>.
+  ConstantRange getRangeForAffineNoSelfWrappingAR(const SCEVAddRecExpr *AddRec,
+                                                  const SCEV *MaxBECount,
+                                                  unsigned BitWidth,
+                                                  RangeSignHint SignHint);
+
   /// Try to compute a range for the affine SCEVAddRecExpr {\p Start,+,\p
   /// Stop} by "factoring out" a ternary expression from the add recurrence.
   /// Helper called by \c getRange.
@@ -1497,7 +1597,7 @@
   /// Return the BackedgeTakenInfo for the given loop, lazily computing new
   /// values if the loop hasn't been analyzed yet. The returned result is
   /// guaranteed not to be predicated.
-  const BackedgeTakenInfo &getBackedgeTakenInfo(const Loop *L);
+  BackedgeTakenInfo &getBackedgeTakenInfo(const Loop *L);
 
   /// Similar to getBackedgeTakenInfo, but will add predicates as required
   /// with the purpose of returning complete information.
@@ -1530,6 +1630,11 @@
                                      bool ExitIfTrue, bool ControlsExit,
                                      bool AllowPredicates = false);
 
+  /// Return a symbolic upper bound for the backedge taken count of the loop.
+  /// This is more general than getConstantMaxBackedgeTakenCount as it returns
+  /// an arbitrary expression as opposed to only constants.
+  const SCEV *computeSymbolicMaxBackedgeTakenCount(const Loop *L);
+
   // Helper functions for computeExitLimitFromCond to avoid exponential time
   // complexity.
 
@@ -1567,6 +1672,10 @@
                                          Value *ExitCond, bool ExitIfTrue,
                                          bool ControlsExit,
                                          bool AllowPredicates);
+  Optional<ScalarEvolution::ExitLimit>
+  computeExitLimitFromCondFromBinOp(ExitLimitCacheTy &Cache, const Loop *L,
+                                    Value *ExitCond, bool ExitIfTrue,
+                                    bool ControlsExit, bool AllowPredicates);
 
   /// Compute the number of times the backedge of the specified loop will
   /// execute if its exit condition were a conditional branch of the ICmpInst
@@ -1645,27 +1754,44 @@
   /// Return a predecessor of BB (which may not be an immediate predecessor)
   /// which has exactly one successor from which BB is reachable, or null if
   /// no such block is found.
-  std::pair<BasicBlock *, BasicBlock *>
-  getPredecessorWithUniqueSuccessorForBB(BasicBlock *BB);
+  std::pair<const BasicBlock *, const BasicBlock *>
+  getPredecessorWithUniqueSuccessorForBB(const BasicBlock *BB) const;
 
   /// Test whether the condition described by Pred, LHS, and RHS is true
-  /// whenever the given FoundCondValue value evaluates to true.
+  /// whenever the given FoundCondValue value evaluates to true in given
+  /// Context. If Context is nullptr, then the found predicate is true
+  /// everywhere. LHS and FoundLHS may have different type width.
   bool isImpliedCond(ICmpInst::Predicate Pred, const SCEV *LHS, const SCEV *RHS,
-                     Value *FoundCondValue, bool Inverse);
+                     const Value *FoundCondValue, bool Inverse,
+                     const Instruction *Context = nullptr);
+
+  /// Test whether the condition described by Pred, LHS, and RHS is true
+  /// whenever the given FoundCondValue value evaluates to true in given
+  /// Context. If Context is nullptr, then the found predicate is true
+  /// everywhere. LHS and FoundLHS must have same type width.
+  bool isImpliedCondBalancedTypes(ICmpInst::Predicate Pred, const SCEV *LHS,
+                                  const SCEV *RHS,
+                                  ICmpInst::Predicate FoundPred,
+                                  const SCEV *FoundLHS, const SCEV *FoundRHS,
+                                  const Instruction *Context);
 
   /// Test whether the condition described by Pred, LHS, and RHS is true
   /// whenever the condition described by FoundPred, FoundLHS, FoundRHS is
-  /// true.
+  /// true in given Context. If Context is nullptr, then the found predicate is
+  /// true everywhere.
   bool isImpliedCond(ICmpInst::Predicate Pred, const SCEV *LHS, const SCEV *RHS,
                      ICmpInst::Predicate FoundPred, const SCEV *FoundLHS,
-                     const SCEV *FoundRHS);
+                     const SCEV *FoundRHS,
+                     const Instruction *Context = nullptr);
 
   /// Test whether the condition described by Pred, LHS, and RHS is true
   /// whenever the condition described by Pred, FoundLHS, and FoundRHS is
-  /// true.
+  /// true in given Context. If Context is nullptr, then the found predicate is
+  /// true everywhere.
   bool isImpliedCondOperands(ICmpInst::Predicate Pred, const SCEV *LHS,
                              const SCEV *RHS, const SCEV *FoundLHS,
-                             const SCEV *FoundRHS);
+                             const SCEV *FoundRHS,
+                             const Instruction *Context = nullptr);
 
   /// Test whether the condition described by Pred, LHS, and RHS is true
   /// whenever the condition described by Pred, FoundLHS, and FoundRHS is
@@ -1697,8 +1823,8 @@
                                       const SCEV *FoundRHS);
 
   /// Return true if the condition denoted by \p LHS \p Pred \p RHS is implied
-  /// by a call to \c @llvm.experimental.guard in \p BB.
-  bool isImpliedViaGuard(BasicBlock *BB, ICmpInst::Predicate Pred,
+  /// by a call to @llvm.experimental.guard in \p BB.
+  bool isImpliedViaGuard(const BasicBlock *BB, ICmpInst::Predicate Pred,
                          const SCEV *LHS, const SCEV *RHS);
 
   /// Test whether the condition described by Pred, LHS, and RHS is true
@@ -1716,6 +1842,18 @@
   /// whenever the condition described by Pred, FoundLHS, and FoundRHS is
   /// true.
   ///
+  /// This routine tries to weaken the known condition basing on fact that
+  /// FoundLHS is an AddRec.
+  bool isImpliedCondOperandsViaAddRecStart(ICmpInst::Predicate Pred,
+                                           const SCEV *LHS, const SCEV *RHS,
+                                           const SCEV *FoundLHS,
+                                           const SCEV *FoundRHS,
+                                           const Instruction *Context);
+
+  /// Test whether the condition described by Pred, LHS, and RHS is true
+  /// whenever the condition described by Pred, FoundLHS, and FoundRHS is
+  /// true.
+  ///
   /// This routine tries to figure out predicate for Phis which are SCEVUnknown
   /// if it is true for every possible incoming value from their respective
   /// basic blocks.
@@ -1752,15 +1890,6 @@
   bool splitBinaryAdd(const SCEV *Expr, const SCEV *&L, const SCEV *&R,
                       SCEV::NoWrapFlags &Flags);
 
-  /// Compute \p LHS - \p RHS and returns the result as an APInt if it is a
-  /// constant, and None if it isn't.
-  ///
-  /// This is intended to be a cheaper version of getMinusSCEV.  We can be
-  /// frugal here since we just bail out of actually constructing and
-  /// canonicalizing an expression in the cases where the result isn't going
-  /// to be a constant.
-  Optional<APInt> computeConstantDifference(const SCEV *LHS, const SCEV *RHS);
-
   /// Drop memoized information computed for S.
   void forgetMemoizedResults(const SCEV *S);
 
@@ -1783,8 +1912,17 @@
   /// Try to prove NSW or NUW on \p AR relying on ConstantRange manipulation.
   SCEV::NoWrapFlags proveNoWrapViaConstantRanges(const SCEVAddRecExpr *AR);
 
-  bool isMonotonicPredicateImpl(const SCEVAddRecExpr *LHS,
-                                ICmpInst::Predicate Pred, bool &Increasing);
+  /// Try to prove NSW on \p AR by proving facts about conditions known  on
+  /// entry and backedge.
+  SCEV::NoWrapFlags proveNoSignedWrapViaInduction(const SCEVAddRecExpr *AR);
+
+  /// Try to prove NUW on \p AR by proving facts about conditions known on
+  /// entry and backedge.
+  SCEV::NoWrapFlags proveNoUnsignedWrapViaInduction(const SCEVAddRecExpr *AR);
+
+  Optional<MonotonicPredicateType>
+  getMonotonicPredicateTypeImpl(const SCEVAddRecExpr *LHS,
+                                ICmpInst::Predicate Pred);
 
   /// Return SCEV no-wrap flags that can be proven based on reasoning about
   /// how poison produced from no-wrap flags on this value (e.g. a nuw add)
@@ -1883,6 +2021,9 @@
   /// Assign A and B to LHS and RHS, respectively.
   bool matchURem(const SCEV *Expr, const SCEV *&LHS, const SCEV *&RHS);
 
+  /// Try to apply information from loop guards for \p L to \p Expr.
+  const SCEV *applyLoopGuards(const SCEV *Expr, const Loop *L);
+
   /// Look for a SCEV expression with type `SCEVType` and operands `Ops` in
   /// `UniqueSCEVs`.
   ///
@@ -1890,8 +2031,8 @@
   /// otherwise.  The second component is the `FoldingSetNodeID` that was
   /// constructed to look up the SCEV and the third component is the insertion
   /// point.
-  std::tuple<const SCEV *, FoldingSetNodeID, void *>
-  findExistingSCEVInCache(int SCEVType, ArrayRef<const SCEV *> Ops);
+  std::tuple<SCEV *, FoldingSetNodeID, void *>
+  findExistingSCEVInCache(SCEVTypes SCEVType, ArrayRef<const SCEV *> Ops);
 
   FoldingSet<SCEV> UniqueSCEVs;
   FoldingSet<SCEVPredicate> UniquePreds;
@@ -1926,6 +2067,13 @@
   ScalarEvolution run(Function &F, FunctionAnalysisManager &AM);
 };
 
+/// Verifier pass for the \c ScalarEvolutionAnalysis results.
+class ScalarEvolutionVerifierPass
+    : public PassInfoMixin<ScalarEvolutionVerifierPass> {
+public:
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+};
+
 /// Printer pass for the \c ScalarEvolutionAnalysis results.
 class ScalarEvolutionPrinterPass
     : public PassInfoMixin<ScalarEvolutionPrinterPass> {
diff --git a/linux-x64/clang/include/llvm/Analysis/ScalarEvolutionDivision.h b/linux-x64/clang/include/llvm/Analysis/ScalarEvolutionDivision.h
new file mode 100644
index 0000000..24f0c51
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Analysis/ScalarEvolutionDivision.h
@@ -0,0 +1,70 @@
+//===- llvm/Analysis/ScalarEvolutionDivision.h - See below ------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the class that knows how to divide SCEV's.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_ANALYSIS_SCALAREVOLUTIONDIVISION_H
+#define LLVM_ANALYSIS_SCALAREVOLUTIONDIVISION_H
+
+#include "llvm/Analysis/ScalarEvolutionExpressions.h"
+
+namespace llvm {
+
+class SCEV;
+
+class ScalarEvolution;
+
+struct SCEVCouldNotCompute;
+
+struct SCEVDivision : public SCEVVisitor<SCEVDivision, void> {
+public:
+  // Computes the Quotient and Remainder of the division of Numerator by
+  // Denominator.
+  static void divide(ScalarEvolution &SE, const SCEV *Numerator,
+                     const SCEV *Denominator, const SCEV **Quotient,
+                     const SCEV **Remainder);
+
+  // Except in the trivial case described above, we do not know how to divide
+  // Expr by Denominator for the following functions with empty implementation.
+  void visitPtrToIntExpr(const SCEVPtrToIntExpr *Numerator) {}
+  void visitTruncateExpr(const SCEVTruncateExpr *Numerator) {}
+  void visitZeroExtendExpr(const SCEVZeroExtendExpr *Numerator) {}
+  void visitSignExtendExpr(const SCEVSignExtendExpr *Numerator) {}
+  void visitUDivExpr(const SCEVUDivExpr *Numerator) {}
+  void visitSMaxExpr(const SCEVSMaxExpr *Numerator) {}
+  void visitUMaxExpr(const SCEVUMaxExpr *Numerator) {}
+  void visitSMinExpr(const SCEVSMinExpr *Numerator) {}
+  void visitUMinExpr(const SCEVUMinExpr *Numerator) {}
+  void visitUnknown(const SCEVUnknown *Numerator) {}
+  void visitCouldNotCompute(const SCEVCouldNotCompute *Numerator) {}
+
+  void visitConstant(const SCEVConstant *Numerator);
+
+  void visitAddRecExpr(const SCEVAddRecExpr *Numerator);
+
+  void visitAddExpr(const SCEVAddExpr *Numerator);
+
+  void visitMulExpr(const SCEVMulExpr *Numerator);
+
+private:
+  SCEVDivision(ScalarEvolution &S, const SCEV *Numerator,
+               const SCEV *Denominator);
+
+  // Convenience function for giving up on the division. We set the quotient to
+  // be equal to zero and the remainder to be equal to the numerator.
+  void cannotDivide(const SCEV *Numerator);
+
+  ScalarEvolution &SE;
+  const SCEV *Denominator, *Quotient, *Remainder, *Zero, *One;
+};
+
+} // end namespace llvm
+
+#endif // LLVM_ANALYSIS_SCALAREVOLUTIONDIVISION_H
diff --git a/linux-x64/clang/include/llvm/Analysis/ScalarEvolutionExpander.h b/linux-x64/clang/include/llvm/Analysis/ScalarEvolutionExpander.h
deleted file mode 100644
index a519f93..0000000
--- a/linux-x64/clang/include/llvm/Analysis/ScalarEvolutionExpander.h
+++ /dev/null
@@ -1,403 +0,0 @@
-//===---- llvm/Analysis/ScalarEvolutionExpander.h - SCEV Exprs --*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// This file defines the classes used to generate code from scalar expressions.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_ANALYSIS_SCALAREVOLUTIONEXPANDER_H
-#define LLVM_ANALYSIS_SCALAREVOLUTIONEXPANDER_H
-
-#include "llvm/ADT/DenseMap.h"
-#include "llvm/ADT/DenseSet.h"
-#include "llvm/ADT/Optional.h"
-#include "llvm/Analysis/ScalarEvolutionExpressions.h"
-#include "llvm/Analysis/ScalarEvolutionNormalization.h"
-#include "llvm/Analysis/TargetFolder.h"
-#include "llvm/IR/IRBuilder.h"
-#include "llvm/IR/ValueHandle.h"
-
-namespace llvm {
-  class TargetTransformInfo;
-
-  /// Return true if the given expression is safe to expand in the sense that
-  /// all materialized values are safe to speculate anywhere their operands are
-  /// defined.
-  bool isSafeToExpand(const SCEV *S, ScalarEvolution &SE);
-
-  /// Return true if the given expression is safe to expand in the sense that
-  /// all materialized values are defined and safe to speculate at the specified
-  /// location and their operands are defined at this location.
-  bool isSafeToExpandAt(const SCEV *S, const Instruction *InsertionPoint,
-                        ScalarEvolution &SE);
-
-  /// This class uses information about analyze scalars to rewrite expressions
-  /// in canonical form.
-  ///
-  /// Clients should create an instance of this class when rewriting is needed,
-  /// and destroy it when finished to allow the release of the associated
-  /// memory.
-  class SCEVExpander : public SCEVVisitor<SCEVExpander, Value*> {
-    ScalarEvolution &SE;
-    const DataLayout &DL;
-
-    // New instructions receive a name to identify them with the current pass.
-    const char* IVName;
-
-    // InsertedExpressions caches Values for reuse, so must track RAUW.
-    DenseMap<std::pair<const SCEV *, Instruction *>, TrackingVH<Value>>
-        InsertedExpressions;
-
-    // InsertedValues only flags inserted instructions so needs no RAUW.
-    DenseSet<AssertingVH<Value>> InsertedValues;
-    DenseSet<AssertingVH<Value>> InsertedPostIncValues;
-
-    /// A memoization of the "relevant" loop for a given SCEV.
-    DenseMap<const SCEV *, const Loop *> RelevantLoops;
-
-    /// Addrecs referring to any of the given loops are expanded in post-inc
-    /// mode. For example, expanding {1,+,1}<L> in post-inc mode returns the add
-    /// instruction that adds one to the phi for {0,+,1}<L>, as opposed to a new
-    /// phi starting at 1. This is only supported in non-canonical mode.
-    PostIncLoopSet PostIncLoops;
-
-    /// When this is non-null, addrecs expanded in the loop it indicates should
-    /// be inserted with increments at IVIncInsertPos.
-    const Loop *IVIncInsertLoop;
-
-    /// When expanding addrecs in the IVIncInsertLoop loop, insert the IV
-    /// increment at this position.
-    Instruction *IVIncInsertPos;
-
-    /// Phis that complete an IV chain. Reuse
-    DenseSet<AssertingVH<PHINode>> ChainedPhis;
-
-    /// When true, expressions are expanded in "canonical" form. In particular,
-    /// addrecs are expanded as arithmetic based on a canonical induction
-    /// variable. When false, expression are expanded in a more literal form.
-    bool CanonicalMode;
-
-    /// When invoked from LSR, the expander is in "strength reduction" mode. The
-    /// only difference is that phi's are only reused if they are already in
-    /// "expanded" form.
-    bool LSRMode;
-
-    typedef IRBuilder<TargetFolder> BuilderType;
-    BuilderType Builder;
-
-    // RAII object that stores the current insertion point and restores it when
-    // the object is destroyed. This includes the debug location.  Duplicated
-    // from InsertPointGuard to add SetInsertPoint() which is used to updated
-    // InsertPointGuards stack when insert points are moved during SCEV
-    // expansion.
-    class SCEVInsertPointGuard {
-      IRBuilderBase &Builder;
-      AssertingVH<BasicBlock> Block;
-      BasicBlock::iterator Point;
-      DebugLoc DbgLoc;
-      SCEVExpander *SE;
-
-      SCEVInsertPointGuard(const SCEVInsertPointGuard &) = delete;
-      SCEVInsertPointGuard &operator=(const SCEVInsertPointGuard &) = delete;
-
-    public:
-      SCEVInsertPointGuard(IRBuilderBase &B, SCEVExpander *SE)
-          : Builder(B), Block(B.GetInsertBlock()), Point(B.GetInsertPoint()),
-            DbgLoc(B.getCurrentDebugLocation()), SE(SE) {
-        SE->InsertPointGuards.push_back(this);
-      }
-
-      ~SCEVInsertPointGuard() {
-        // These guards should always created/destroyed in FIFO order since they
-        // are used to guard lexically scoped blocks of code in
-        // ScalarEvolutionExpander.
-        assert(SE->InsertPointGuards.back() == this);
-        SE->InsertPointGuards.pop_back();
-        Builder.restoreIP(IRBuilderBase::InsertPoint(Block, Point));
-        Builder.SetCurrentDebugLocation(DbgLoc);
-      }
-
-      BasicBlock::iterator GetInsertPoint() const { return Point; }
-      void SetInsertPoint(BasicBlock::iterator I) { Point = I; }
-    };
-
-    /// Stack of pointers to saved insert points, used to keep insert points
-    /// consistent when instructions are moved.
-    SmallVector<SCEVInsertPointGuard *, 8> InsertPointGuards;
-
-#ifndef NDEBUG
-    const char *DebugType;
-#endif
-
-    friend struct SCEVVisitor<SCEVExpander, Value*>;
-
-  public:
-    /// Construct a SCEVExpander in "canonical" mode.
-    explicit SCEVExpander(ScalarEvolution &se, const DataLayout &DL,
-                          const char *name)
-        : SE(se), DL(DL), IVName(name), IVIncInsertLoop(nullptr),
-          IVIncInsertPos(nullptr), CanonicalMode(true), LSRMode(false),
-          Builder(se.getContext(), TargetFolder(DL)) {
-#ifndef NDEBUG
-      DebugType = "";
-#endif
-    }
-
-    ~SCEVExpander() {
-      // Make sure the insert point guard stack is consistent.
-      assert(InsertPointGuards.empty());
-    }
-
-#ifndef NDEBUG
-    void setDebugType(const char* s) { DebugType = s; }
-#endif
-
-    /// Erase the contents of the InsertedExpressions map so that users trying
-    /// to expand the same expression into multiple BasicBlocks or different
-    /// places within the same BasicBlock can do so.
-    void clear() {
-      InsertedExpressions.clear();
-      InsertedValues.clear();
-      InsertedPostIncValues.clear();
-      ChainedPhis.clear();
-    }
-
-    /// Return true for expressions that may incur non-trivial cost to evaluate
-    /// at runtime.
-    ///
-    /// At is an optional parameter which specifies point in code where user is
-    /// going to expand this expression. Sometimes this knowledge can lead to a
-    /// more accurate cost estimation.
-    bool isHighCostExpansion(const SCEV *Expr, Loop *L,
-                             const Instruction *At = nullptr) {
-      SmallPtrSet<const SCEV *, 8> Processed;
-      return isHighCostExpansionHelper(Expr, L, At, Processed);
-    }
-
-    /// This method returns the canonical induction variable of the specified
-    /// type for the specified loop (inserting one if there is none).  A
-    /// canonical induction variable starts at zero and steps by one on each
-    /// iteration.
-    PHINode *getOrInsertCanonicalInductionVariable(const Loop *L, Type *Ty);
-
-    /// Return the induction variable increment's IV operand.
-    Instruction *getIVIncOperand(Instruction *IncV, Instruction *InsertPos,
-                                 bool allowScale);
-
-    /// Utility for hoisting an IV increment.
-    bool hoistIVInc(Instruction *IncV, Instruction *InsertPos);
-
-    /// replace congruent phis with their most canonical representative. Return
-    /// the number of phis eliminated.
-    unsigned replaceCongruentIVs(Loop *L, const DominatorTree *DT,
-                                 SmallVectorImpl<WeakTrackingVH> &DeadInsts,
-                                 const TargetTransformInfo *TTI = nullptr);
-
-    /// Insert code to directly compute the specified SCEV expression into the
-    /// program.  The inserted code is inserted into the specified block.
-    Value *expandCodeFor(const SCEV *SH, Type *Ty, Instruction *I);
-
-    /// Insert code to directly compute the specified SCEV expression into the
-    /// program.  The inserted code is inserted into the SCEVExpander's current
-    /// insertion point. If a type is specified, the result will be expanded to
-    /// have that type, with a cast if necessary.
-    Value *expandCodeFor(const SCEV *SH, Type *Ty = nullptr);
-
-
-    /// Generates a code sequence that evaluates this predicate.  The inserted
-    /// instructions will be at position \p Loc.  The result will be of type i1
-    /// and will have a value of 0 when the predicate is false and 1 otherwise.
-    Value *expandCodeForPredicate(const SCEVPredicate *Pred, Instruction *Loc);
-
-    /// A specialized variant of expandCodeForPredicate, handling the case when
-    /// we are expanding code for a SCEVEqualPredicate.
-    Value *expandEqualPredicate(const SCEVEqualPredicate *Pred,
-                                Instruction *Loc);
-
-    /// Generates code that evaluates if the \p AR expression will overflow.
-    Value *generateOverflowCheck(const SCEVAddRecExpr *AR, Instruction *Loc,
-                                 bool Signed);
-
-    /// A specialized variant of expandCodeForPredicate, handling the case when
-    /// we are expanding code for a SCEVWrapPredicate.
-    Value *expandWrapPredicate(const SCEVWrapPredicate *P, Instruction *Loc);
-
-    /// A specialized variant of expandCodeForPredicate, handling the case when
-    /// we are expanding code for a SCEVUnionPredicate.
-    Value *expandUnionPredicate(const SCEVUnionPredicate *Pred,
-                                Instruction *Loc);
-
-    /// Set the current IV increment loop and position.
-    void setIVIncInsertPos(const Loop *L, Instruction *Pos) {
-      assert(!CanonicalMode &&
-             "IV increment positions are not supported in CanonicalMode");
-      IVIncInsertLoop = L;
-      IVIncInsertPos = Pos;
-    }
-
-    /// Enable post-inc expansion for addrecs referring to the given
-    /// loops. Post-inc expansion is only supported in non-canonical mode.
-    void setPostInc(const PostIncLoopSet &L) {
-      assert(!CanonicalMode &&
-             "Post-inc expansion is not supported in CanonicalMode");
-      PostIncLoops = L;
-    }
-
-    /// Disable all post-inc expansion.
-    void clearPostInc() {
-      PostIncLoops.clear();
-
-      // When we change the post-inc loop set, cached expansions may no
-      // longer be valid.
-      InsertedPostIncValues.clear();
-    }
-
-    /// Disable the behavior of expanding expressions in canonical form rather
-    /// than in a more literal form. Non-canonical mode is useful for late
-    /// optimization passes.
-    void disableCanonicalMode() { CanonicalMode = false; }
-
-    void enableLSRMode() { LSRMode = true; }
-
-    /// Set the current insertion point. This is useful if multiple calls to
-    /// expandCodeFor() are going to be made with the same insert point and the
-    /// insert point may be moved during one of the expansions (e.g. if the
-    /// insert point is not a block terminator).
-    void setInsertPoint(Instruction *IP) {
-      assert(IP);
-      Builder.SetInsertPoint(IP);
-    }
-
-    /// Clear the current insertion point. This is useful if the instruction
-    /// that had been serving as the insertion point may have been deleted.
-    void clearInsertPoint() {
-      Builder.ClearInsertionPoint();
-    }
-
-    /// Return true if the specified instruction was inserted by the code
-    /// rewriter.  If so, the client should not modify the instruction.
-    bool isInsertedInstruction(Instruction *I) const {
-      return InsertedValues.count(I) || InsertedPostIncValues.count(I);
-    }
-
-    void setChainedPhi(PHINode *PN) { ChainedPhis.insert(PN); }
-
-    /// Try to find existing LLVM IR value for S available at the point At.
-    Value *getExactExistingExpansion(const SCEV *S, const Instruction *At,
-                                     Loop *L);
-
-    /// Try to find the ValueOffsetPair for S. The function is mainly used to
-    /// check whether S can be expanded cheaply.  If this returns a non-None
-    /// value, we know we can codegen the `ValueOffsetPair` into a suitable
-    /// expansion identical with S so that S can be expanded cheaply.
-    ///
-    /// L is a hint which tells in which loop to look for the suitable value.
-    /// On success return value which is equivalent to the expanded S at point
-    /// At. Return nullptr if value was not found.
-    ///
-    /// Note that this function does not perform an exhaustive search. I.e if it
-    /// didn't find any value it does not mean that there is no such value.
-    ///
-    Optional<ScalarEvolution::ValueOffsetPair>
-    getRelatedExistingExpansion(const SCEV *S, const Instruction *At, Loop *L);
-
-  private:
-    LLVMContext &getContext() const { return SE.getContext(); }
-
-    /// Recursive helper function for isHighCostExpansion.
-    bool isHighCostExpansionHelper(const SCEV *S, Loop *L,
-                                   const Instruction *At,
-                                   SmallPtrSetImpl<const SCEV *> &Processed);
-
-    /// Insert the specified binary operator, doing a small amount of work to
-    /// avoid inserting an obviously redundant operation, and hoisting to an
-    /// outer loop when the opportunity is there and it is safe.
-    Value *InsertBinop(Instruction::BinaryOps Opcode, Value *LHS, Value *RHS,
-                       SCEV::NoWrapFlags Flags, bool IsSafeToHoist);
-
-    /// Arrange for there to be a cast of V to Ty at IP, reusing an existing
-    /// cast if a suitable one exists, moving an existing cast if a suitable one
-    /// exists but isn't in the right place, or creating a new one.
-    Value *ReuseOrCreateCast(Value *V, Type *Ty,
-                             Instruction::CastOps Op,
-                             BasicBlock::iterator IP);
-
-    /// Insert a cast of V to the specified type, which must be possible with a
-    /// noop cast, doing what we can to share the casts.
-    Value *InsertNoopCastOfTo(Value *V, Type *Ty);
-
-    /// Expand a SCEVAddExpr with a pointer type into a GEP instead of using
-    /// ptrtoint+arithmetic+inttoptr.
-    Value *expandAddToGEP(const SCEV *const *op_begin,
-                          const SCEV *const *op_end,
-                          PointerType *PTy, Type *Ty, Value *V);
-    Value *expandAddToGEP(const SCEV *Op, PointerType *PTy, Type *Ty, Value *V);
-
-    /// Find a previous Value in ExprValueMap for expand.
-    ScalarEvolution::ValueOffsetPair
-    FindValueInExprValueMap(const SCEV *S, const Instruction *InsertPt);
-
-    Value *expand(const SCEV *S);
-
-    /// Determine the most "relevant" loop for the given SCEV.
-    const Loop *getRelevantLoop(const SCEV *);
-
-    Value *visitConstant(const SCEVConstant *S) {
-      return S->getValue();
-    }
-
-    Value *visitTruncateExpr(const SCEVTruncateExpr *S);
-
-    Value *visitZeroExtendExpr(const SCEVZeroExtendExpr *S);
-
-    Value *visitSignExtendExpr(const SCEVSignExtendExpr *S);
-
-    Value *visitAddExpr(const SCEVAddExpr *S);
-
-    Value *visitMulExpr(const SCEVMulExpr *S);
-
-    Value *visitUDivExpr(const SCEVUDivExpr *S);
-
-    Value *visitAddRecExpr(const SCEVAddRecExpr *S);
-
-    Value *visitSMaxExpr(const SCEVSMaxExpr *S);
-
-    Value *visitUMaxExpr(const SCEVUMaxExpr *S);
-
-    Value *visitSMinExpr(const SCEVSMinExpr *S);
-
-    Value *visitUMinExpr(const SCEVUMinExpr *S);
-
-    Value *visitUnknown(const SCEVUnknown *S) {
-      return S->getValue();
-    }
-
-    void rememberInstruction(Value *I);
-
-    bool isNormalAddRecExprPHI(PHINode *PN, Instruction *IncV, const Loop *L);
-
-    bool isExpandedAddRecExprPHI(PHINode *PN, Instruction *IncV, const Loop *L);
-
-    Value *expandAddRecExprLiterally(const SCEVAddRecExpr *);
-    PHINode *getAddRecExprPHILiterally(const SCEVAddRecExpr *Normalized,
-                                       const Loop *L,
-                                       Type *ExpandTy,
-                                       Type *IntTy,
-                                       Type *&TruncTy,
-                                       bool &InvertStep);
-    Value *expandIVInc(PHINode *PN, Value *StepV, const Loop *L,
-                       Type *ExpandTy, Type *IntTy, bool useSubtract);
-
-    void hoistBeforePos(DominatorTree *DT, Instruction *InstToHoist,
-                        Instruction *Pos, PHINode *LoopPhi);
-
-    void fixupInsertPoints(Instruction *I);
-  };
-}
-
-#endif
diff --git a/linux-x64/clang/include/llvm/Analysis/ScalarEvolutionExpressions.h b/linux-x64/clang/include/llvm/Analysis/ScalarEvolutionExpressions.h
index d008af7..37e675f 100644
--- a/linux-x64/clang/include/llvm/Analysis/ScalarEvolutionExpressions.h
+++ b/linux-x64/clang/include/llvm/Analysis/ScalarEvolutionExpressions.h
@@ -35,12 +35,12 @@
 class Loop;
 class Type;
 
-  enum SCEVTypes {
+  enum SCEVTypes : unsigned short {
     // These should be ordered in terms of increasing complexity to make the
     // folders simpler.
     scConstant, scTruncate, scZeroExtend, scSignExtend, scAddExpr, scMulExpr,
     scUDivExpr, scAddRecExpr, scUMaxExpr, scSMaxExpr, scUMinExpr, scSMinExpr,
-    scUnknown, scCouldNotCompute
+    scPtrToInt, scUnknown, scCouldNotCompute
   };
 
   /// This class represents a constant integer value.
@@ -64,7 +64,7 @@
     }
   };
 
-  static unsigned short computeExpressionSize(ArrayRef<const SCEV *> Args) {
+  inline unsigned short computeExpressionSize(ArrayRef<const SCEV *> Args) {
     APInt Size(16, 1);
     for (auto *Arg : Args)
       Size = Size.uadd_sat(APInt(16, Arg->getExpressionSize()));
@@ -74,18 +74,58 @@
   /// This is the base class for unary cast operator classes.
   class SCEVCastExpr : public SCEV {
   protected:
-    const SCEV *Op;
+    std::array<const SCEV *, 1> Operands;
     Type *Ty;
 
-    SCEVCastExpr(const FoldingSetNodeIDRef ID,
-                 unsigned SCEVTy, const SCEV *op, Type *ty);
+    SCEVCastExpr(const FoldingSetNodeIDRef ID, SCEVTypes SCEVTy, const SCEV *op,
+                 Type *ty);
 
   public:
-    const SCEV *getOperand() const { return Op; }
+    const SCEV *getOperand() const { return Operands[0]; }
+    const SCEV *getOperand(unsigned i) const {
+      assert(i == 0 && "Operand index out of range!");
+      return Operands[0];
+    }
+    using op_iterator = std::array<const SCEV *, 1>::const_iterator;
+    using op_range = iterator_range<op_iterator>;
+
+    op_range operands() const {
+      return make_range(Operands.begin(), Operands.end());
+    }
+    size_t getNumOperands() const { return 1; }
     Type *getType() const { return Ty; }
 
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     static bool classof(const SCEV *S) {
+      return S->getSCEVType() == scPtrToInt || S->getSCEVType() == scTruncate ||
+             S->getSCEVType() == scZeroExtend ||
+             S->getSCEVType() == scSignExtend;
+    }
+  };
+
+  /// This class represents a cast from a pointer to a pointer-sized integer
+  /// value.
+  class SCEVPtrToIntExpr : public SCEVCastExpr {
+    friend class ScalarEvolution;
+
+    SCEVPtrToIntExpr(const FoldingSetNodeIDRef ID, const SCEV *Op, Type *ITy);
+
+  public:
+    /// Methods for support type inquiry through isa, cast, and dyn_cast:
+    static bool classof(const SCEV *S) {
+      return S->getSCEVType() == scPtrToInt;
+    }
+  };
+
+  /// This is the base class for unary integral cast operator classes.
+  class SCEVIntegralCastExpr : public SCEVCastExpr {
+  protected:
+    SCEVIntegralCastExpr(const FoldingSetNodeIDRef ID, SCEVTypes SCEVTy,
+                         const SCEV *op, Type *ty);
+
+  public:
+    /// Methods for support type inquiry through isa, cast, and dyn_cast:
+    static bool classof(const SCEV *S) {
       return S->getSCEVType() == scTruncate ||
              S->getSCEVType() == scZeroExtend ||
              S->getSCEVType() == scSignExtend;
@@ -94,7 +134,7 @@
 
   /// This class represents a truncation of an integer value to a
   /// smaller integer value.
-  class SCEVTruncateExpr : public SCEVCastExpr {
+  class SCEVTruncateExpr : public SCEVIntegralCastExpr {
     friend class ScalarEvolution;
 
     SCEVTruncateExpr(const FoldingSetNodeIDRef ID,
@@ -109,7 +149,7 @@
 
   /// This class represents a zero extension of a small integer value
   /// to a larger integer value.
-  class SCEVZeroExtendExpr : public SCEVCastExpr {
+  class SCEVZeroExtendExpr : public SCEVIntegralCastExpr {
     friend class ScalarEvolution;
 
     SCEVZeroExtendExpr(const FoldingSetNodeIDRef ID,
@@ -124,7 +164,7 @@
 
   /// This class represents a sign extension of a small integer value
   /// to a larger integer value.
-  class SCEVSignExtendExpr : public SCEVCastExpr {
+  class SCEVSignExtendExpr : public SCEVIntegralCastExpr {
     friend class ScalarEvolution;
 
     SCEVSignExtendExpr(const FoldingSetNodeIDRef ID,
@@ -222,17 +262,21 @@
   class SCEVAddExpr : public SCEVCommutativeExpr {
     friend class ScalarEvolution;
 
-    SCEVAddExpr(const FoldingSetNodeIDRef ID,
-                const SCEV *const *O, size_t N)
-      : SCEVCommutativeExpr(ID, scAddExpr, O, N) {}
+    Type *Ty;
+
+    SCEVAddExpr(const FoldingSetNodeIDRef ID, const SCEV *const *O, size_t N)
+        : SCEVCommutativeExpr(ID, scAddExpr, O, N) {
+      auto *FirstPointerTypedOp = find_if(operands(), [](const SCEV *Op) {
+        return Op->getType()->isPointerTy();
+      });
+      if (FirstPointerTypedOp != operands().end())
+        Ty = (*FirstPointerTypedOp)->getType();
+      else
+        Ty = getOperand(0)->getType();
+    }
 
   public:
-    Type *getType() const {
-      // Use the type of the last operand, which is likely to be a pointer
-      // type, if there is one. This doesn't usually matter, but it can help
-      // reduce casts when the expressions are expanded.
-      return getOperand(getNumOperands() - 1)->getType();
-    }
+    Type *getType() const { return Ty; }
 
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     static bool classof(const SCEV *S) {
@@ -259,16 +303,28 @@
   class SCEVUDivExpr : public SCEV {
     friend class ScalarEvolution;
 
-    const SCEV *LHS;
-    const SCEV *RHS;
+    std::array<const SCEV *, 2> Operands;
 
     SCEVUDivExpr(const FoldingSetNodeIDRef ID, const SCEV *lhs, const SCEV *rhs)
-        : SCEV(ID, scUDivExpr, computeExpressionSize({lhs, rhs})), LHS(lhs),
-          RHS(rhs) {}
+        : SCEV(ID, scUDivExpr, computeExpressionSize({lhs, rhs})) {
+        Operands[0] = lhs;
+        Operands[1] = rhs;
+      }
 
   public:
-    const SCEV *getLHS() const { return LHS; }
-    const SCEV *getRHS() const { return RHS; }
+    const SCEV *getLHS() const { return Operands[0]; }
+    const SCEV *getRHS() const { return Operands[1]; }
+    size_t getNumOperands() const { return 2; }
+    const SCEV *getOperand(unsigned i) const {
+      assert((i == 0 || i == 1) && "Operand index out of range!");
+      return i == 0 ? getLHS() : getRHS();
+    }
+
+    using op_iterator = std::array<const SCEV *, 2>::const_iterator;
+    using op_range = iterator_range<op_iterator>;
+    op_range operands() const {
+      return make_range(Operands.begin(), Operands.end());
+    }
 
     Type *getType() const {
       // In most cases the types of LHS and RHS will be the same, but in some
@@ -385,7 +441,7 @@
 
   public:
     static bool classof(const SCEV *S) {
-      return isMinMaxType(static_cast<SCEVTypes>(S->getSCEVType()));
+      return isMinMaxType(S->getSCEVType());
     }
 
     static enum SCEVTypes negate(enum SCEVTypes T) {
@@ -514,6 +570,8 @@
       switch (S->getSCEVType()) {
       case scConstant:
         return ((SC*)this)->visitConstant((const SCEVConstant*)S);
+      case scPtrToInt:
+        return ((SC *)this)->visitPtrToIntExpr((const SCEVPtrToIntExpr *)S);
       case scTruncate:
         return ((SC*)this)->visitTruncateExpr((const SCEVTruncateExpr*)S);
       case scZeroExtend:
@@ -540,9 +598,8 @@
         return ((SC*)this)->visitUnknown((const SCEVUnknown*)S);
       case scCouldNotCompute:
         return ((SC*)this)->visitCouldNotCompute((const SCEVCouldNotCompute*)S);
-      default:
-        llvm_unreachable("Unknown SCEV type!");
       }
+      llvm_unreachable("Unknown SCEV kind!");
     }
 
     RetVal visitCouldNotCompute(const SCEVCouldNotCompute *S) {
@@ -579,12 +636,13 @@
         switch (S->getSCEVType()) {
         case scConstant:
         case scUnknown:
-          break;
+          continue;
+        case scPtrToInt:
         case scTruncate:
         case scZeroExtend:
         case scSignExtend:
           push(cast<SCEVCastExpr>(S)->getOperand());
-          break;
+          continue;
         case scAddExpr:
         case scMulExpr:
         case scSMaxExpr:
@@ -594,18 +652,17 @@
         case scAddRecExpr:
           for (const auto *Op : cast<SCEVNAryExpr>(S)->operands())
             push(Op);
-          break;
+          continue;
         case scUDivExpr: {
           const SCEVUDivExpr *UDiv = cast<SCEVUDivExpr>(S);
           push(UDiv->getLHS());
           push(UDiv->getRHS());
-          break;
+          continue;
         }
         case scCouldNotCompute:
           llvm_unreachable("Attempt to use a SCEVCouldNotCompute object!");
-        default:
-          llvm_unreachable("Unknown SCEV kind!");
         }
+        llvm_unreachable("Unknown SCEV kind!");
       }
     }
   };
@@ -673,6 +730,13 @@
       return Constant;
     }
 
+    const SCEV *visitPtrToIntExpr(const SCEVPtrToIntExpr *Expr) {
+      const SCEV *Operand = ((SC *)this)->visit(Expr->getOperand());
+      return Operand == Expr->getOperand()
+                 ? Expr
+                 : SE.getPtrToIntExpr(Operand, Expr->getType());
+    }
+
     const SCEV *visitTruncateExpr(const SCEVTruncateExpr *Expr) {
       const SCEV *Operand = ((SC*)this)->visit(Expr->getOperand());
       return Operand == Expr->getOperand()
@@ -783,35 +847,30 @@
   };
 
   using ValueToValueMap = DenseMap<const Value *, Value *>;
+  using ValueToSCEVMapTy = DenseMap<const Value *, const SCEV *>;
 
   /// The SCEVParameterRewriter takes a scalar evolution expression and updates
-  /// the SCEVUnknown components following the Map (Value -> Value).
+  /// the SCEVUnknown components following the Map (Value -> SCEV).
   class SCEVParameterRewriter : public SCEVRewriteVisitor<SCEVParameterRewriter> {
   public:
     static const SCEV *rewrite(const SCEV *Scev, ScalarEvolution &SE,
-                               ValueToValueMap &Map,
-                               bool InterpretConsts = false) {
-      SCEVParameterRewriter Rewriter(SE, Map, InterpretConsts);
+                               ValueToSCEVMapTy &Map) {
+      SCEVParameterRewriter Rewriter(SE, Map);
       return Rewriter.visit(Scev);
     }
 
-    SCEVParameterRewriter(ScalarEvolution &SE, ValueToValueMap &M, bool C)
-      : SCEVRewriteVisitor(SE), Map(M), InterpretConsts(C) {}
+    SCEVParameterRewriter(ScalarEvolution &SE, ValueToSCEVMapTy &M)
+        : SCEVRewriteVisitor(SE), Map(M) {}
 
     const SCEV *visitUnknown(const SCEVUnknown *Expr) {
-      Value *V = Expr->getValue();
-      if (Map.count(V)) {
-        Value *NV = Map[V];
-        if (InterpretConsts && isa<ConstantInt>(NV))
-          return SE.getConstant(cast<ConstantInt>(NV));
-        return SE.getUnknown(NV);
-      }
-      return Expr;
+      auto I = Map.find(Expr->getValue());
+      if (I == Map.end())
+        return Expr;
+      return I->second;
     }
 
   private:
-    ValueToValueMap &Map;
-    bool InterpretConsts;
+    ValueToSCEVMapTy &Map;
   };
 
   using LoopToScevMapT = DenseMap<const Loop *, const SCEV *>;
diff --git a/linux-x64/clang/include/llvm/Analysis/ScalarEvolutionNormalization.h b/linux-x64/clang/include/llvm/Analysis/ScalarEvolutionNormalization.h
index 1a05594..6ab92a3 100644
--- a/linux-x64/clang/include/llvm/Analysis/ScalarEvolutionNormalization.h
+++ b/linux-x64/clang/include/llvm/Analysis/ScalarEvolutionNormalization.h
@@ -37,13 +37,13 @@
 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallPtrSet.h"
-#include "llvm/Analysis/ScalarEvolutionExpressions.h"
 
 namespace llvm {
 
 class Loop;
 class ScalarEvolution;
 class SCEV;
+class SCEVAddRecExpr;
 
 typedef SmallPtrSet<const Loop *, 2> PostIncLoopSet;
 
diff --git a/linux-x64/clang/include/llvm/Analysis/ScopedNoAliasAA.h b/linux-x64/clang/include/llvm/Analysis/ScopedNoAliasAA.h
index dae733b..c55228e 100644
--- a/linux-x64/clang/include/llvm/Analysis/ScopedNoAliasAA.h
+++ b/linux-x64/clang/include/llvm/Analysis/ScopedNoAliasAA.h
@@ -15,7 +15,6 @@
 #define LLVM_ANALYSIS_SCOPEDNOALIASAA_H
 
 #include "llvm/Analysis/AliasAnalysis.h"
-#include "llvm/IR/InstrTypes.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/Pass.h"
 #include <memory>
diff --git a/linux-x64/clang/include/llvm/Analysis/StackLifetime.h b/linux-x64/clang/include/llvm/Analysis/StackLifetime.h
new file mode 100644
index 0000000..1c0e103
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Analysis/StackLifetime.h
@@ -0,0 +1,204 @@
+//===- StackLifetime.h - Alloca Lifetime Analysis --------------*- C++ -*--===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_ANALYSIS_STACKLIFETIME_H
+#define LLVM_ANALYSIS_STACKLIFETIME_H
+
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/BitVector.h"
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/IR/IntrinsicInst.h"
+#include "llvm/IR/PassManager.h"
+#include "llvm/Support/raw_ostream.h"
+#include <cassert>
+#include <utility>
+
+namespace llvm {
+
+class AllocaInst;
+class BasicBlock;
+class Function;
+class Instruction;
+
+/// Compute live ranges of allocas.
+/// Live ranges are represented as sets of "interesting" instructions, which are
+/// defined as instructions that may start or end an alloca's lifetime. These
+/// are:
+/// * lifetime.start and lifetime.end intrinsics
+/// * first instruction of any basic block
+/// Interesting instructions are numbered in the depth-first walk of the CFG,
+/// and in the program order inside each basic block.
+class StackLifetime {
+  /// A class representing liveness information for a single basic block.
+  /// Each bit in the BitVector represents the liveness property
+  /// for a different stack slot.
+  struct BlockLifetimeInfo {
+    explicit BlockLifetimeInfo(unsigned Size)
+        : Begin(Size), End(Size), LiveIn(Size), LiveOut(Size) {}
+
+    /// Which slots BEGINs in each basic block.
+    BitVector Begin;
+
+    /// Which slots ENDs in each basic block.
+    BitVector End;
+
+    /// Which slots are marked as LIVE_IN, coming into each basic block.
+    BitVector LiveIn;
+
+    /// Which slots are marked as LIVE_OUT, coming out of each basic block.
+    BitVector LiveOut;
+  };
+
+public:
+  class LifetimeAnnotationWriter;
+
+  /// This class represents a set of interesting instructions where an alloca is
+  /// live.
+  class LiveRange {
+    BitVector Bits;
+    friend raw_ostream &operator<<(raw_ostream &OS,
+                                   const StackLifetime::LiveRange &R);
+
+  public:
+    LiveRange(unsigned Size, bool Set = false) : Bits(Size, Set) {}
+    void addRange(unsigned Start, unsigned End) { Bits.set(Start, End); }
+
+    bool overlaps(const LiveRange &Other) const {
+      return Bits.anyCommon(Other.Bits);
+    }
+
+    void join(const LiveRange &Other) { Bits |= Other.Bits; }
+
+    bool test(unsigned Idx) const { return Bits.test(Idx); }
+  };
+
+  // Controls what is "alive" if control flow may reach the instruction
+  // with a different liveness of the alloca.
+  enum class LivenessType {
+    May,  // May be alive on some path.
+    Must, // Must be alive on every path.
+  };
+
+private:
+  const Function &F;
+  LivenessType Type;
+
+  /// Maps active slots (per bit) for each basic block.
+  using LivenessMap = DenseMap<const BasicBlock *, BlockLifetimeInfo>;
+  LivenessMap BlockLiveness;
+
+  /// Interesting instructions. Instructions of the same block are adjustent
+  /// preserve in-block order.
+  SmallVector<const IntrinsicInst *, 64> Instructions;
+
+  /// A range [Start, End) of instruction ids for each basic block.
+  /// Instructions inside each BB have monotonic and consecutive ids.
+  DenseMap<const BasicBlock *, std::pair<unsigned, unsigned>> BlockInstRange;
+
+  ArrayRef<const AllocaInst *> Allocas;
+  unsigned NumAllocas;
+  DenseMap<const AllocaInst *, unsigned> AllocaNumbering;
+
+  /// LiveRange for allocas.
+  SmallVector<LiveRange, 8> LiveRanges;
+
+  /// The set of allocas that have at least one lifetime.start. All other
+  /// allocas get LiveRange that corresponds to the entire function.
+  BitVector InterestingAllocas;
+
+  struct Marker {
+    unsigned AllocaNo;
+    bool IsStart;
+  };
+
+  /// List of {InstNo, {AllocaNo, IsStart}} for each BB, ordered by InstNo.
+  DenseMap<const BasicBlock *, SmallVector<std::pair<unsigned, Marker>, 4>>
+      BBMarkers;
+
+  bool HasUnknownLifetimeStartOrEnd = false;
+
+  void dumpAllocas() const;
+  void dumpBlockLiveness() const;
+  void dumpLiveRanges() const;
+
+  void collectMarkers();
+  void calculateLocalLiveness();
+  void calculateLiveIntervals();
+
+public:
+  StackLifetime(const Function &F, ArrayRef<const AllocaInst *> Allocas,
+                LivenessType Type);
+
+  void run();
+
+  iterator_range<
+      filter_iterator<ArrayRef<const IntrinsicInst *>::const_iterator,
+                      std::function<bool(const IntrinsicInst *)>>>
+  getMarkers() const {
+    std::function<bool(const IntrinsicInst *)> NotNull(
+        [](const IntrinsicInst *I) -> bool { return I; });
+    return make_filter_range(Instructions, NotNull);
+  }
+
+  /// Returns a set of "interesting" instructions where the given alloca is
+  /// live. Not all instructions in a function are interesting: we pick a set
+  /// that is large enough for LiveRange::Overlaps to be correct.
+  const LiveRange &getLiveRange(const AllocaInst *AI) const;
+
+  /// Returns true if instruction is reachable from entry.
+  bool isReachable(const Instruction *I) const;
+
+  /// Returns true if the alloca is alive after the instruction.
+  bool isAliveAfter(const AllocaInst *AI, const Instruction *I) const;
+
+  /// Returns a live range that represents an alloca that is live throughout the
+  /// entire function.
+  LiveRange getFullLiveRange() const {
+    return LiveRange(Instructions.size(), true);
+  }
+
+  void print(raw_ostream &O);
+};
+
+static inline raw_ostream &operator<<(raw_ostream &OS, const BitVector &V) {
+  OS << "{";
+  int Idx = V.find_first();
+  bool First = true;
+  while (Idx >= 0) {
+    if (!First) {
+      OS << ", ";
+    }
+    First = false;
+    OS << Idx;
+    Idx = V.find_next(Idx);
+  }
+  OS << "}";
+  return OS;
+}
+
+inline raw_ostream &operator<<(raw_ostream &OS,
+                               const StackLifetime::LiveRange &R) {
+  return OS << R.Bits;
+}
+
+/// Printer pass for testing.
+class StackLifetimePrinterPass
+    : public PassInfoMixin<StackLifetimePrinterPass> {
+  StackLifetime::LivenessType Type;
+  raw_ostream &OS;
+
+public:
+  StackLifetimePrinterPass(raw_ostream &OS, StackLifetime::LivenessType Type)
+      : Type(Type), OS(OS) {}
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+};
+
+} // end namespace llvm
+
+#endif // LLVM_ANALYSIS_STACKLIFETIME_H
diff --git a/linux-x64/clang/include/llvm/Analysis/StackSafetyAnalysis.h b/linux-x64/clang/include/llvm/Analysis/StackSafetyAnalysis.h
index f9d8b08..59c1e3e 100644
--- a/linux-x64/clang/include/llvm/Analysis/StackSafetyAnalysis.h
+++ b/linux-x64/clang/include/llvm/Analysis/StackSafetyAnalysis.h
@@ -13,28 +13,71 @@
 #ifndef LLVM_ANALYSIS_STACKSAFETYANALYSIS_H
 #define LLVM_ANALYSIS_STACKSAFETYANALYSIS_H
 
+#include "llvm/IR/ModuleSummaryIndex.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/Pass.h"
 
 namespace llvm {
 
+class AllocaInst;
+class ScalarEvolution;
+
 /// Interface to access stack safety analysis results for single function.
 class StackSafetyInfo {
 public:
-  struct FunctionInfo;
+  struct InfoTy;
 
 private:
-  std::unique_ptr<FunctionInfo> Info;
+  Function *F = nullptr;
+  std::function<ScalarEvolution &()> GetSE;
+  mutable std::unique_ptr<InfoTy> Info;
 
 public:
   StackSafetyInfo();
-  StackSafetyInfo(FunctionInfo &&Info);
+  StackSafetyInfo(Function *F, std::function<ScalarEvolution &()> GetSE);
   StackSafetyInfo(StackSafetyInfo &&);
   StackSafetyInfo &operator=(StackSafetyInfo &&);
   ~StackSafetyInfo();
 
+  const InfoTy &getInfo() const;
+
   // TODO: Add useful for client methods.
   void print(raw_ostream &O) const;
+
+  /// Parameters use for a FunctionSummary.
+  /// Function collects access information of all pointer parameters.
+  /// Information includes a range of direct access of parameters by the
+  /// functions and all call sites accepting the parameter.
+  /// StackSafety assumes that missing parameter information means possibility
+  /// of access to the parameter with any offset, so we can correctly link
+  /// code without StackSafety information, e.g. non-ThinLTO.
+  std::vector<FunctionSummary::ParamAccess>
+  getParamAccesses(ModuleSummaryIndex &Index) const;
+};
+
+class StackSafetyGlobalInfo {
+public:
+  struct InfoTy;
+
+private:
+  Module *M = nullptr;
+  std::function<const StackSafetyInfo &(Function &F)> GetSSI;
+  const ModuleSummaryIndex *Index = nullptr;
+  mutable std::unique_ptr<InfoTy> Info;
+  const InfoTy &getInfo() const;
+
+public:
+  StackSafetyGlobalInfo();
+  StackSafetyGlobalInfo(
+      Module *M, std::function<const StackSafetyInfo &(Function &F)> GetSSI,
+      const ModuleSummaryIndex *Index);
+  StackSafetyGlobalInfo(StackSafetyGlobalInfo &&);
+  StackSafetyGlobalInfo &operator=(StackSafetyGlobalInfo &&);
+  ~StackSafetyGlobalInfo();
+
+  bool isSafe(const AllocaInst &AI) const;
+  void print(raw_ostream &O) const;
+  void dump() const;
 };
 
 /// StackSafetyInfo wrapper for the new pass manager.
@@ -72,8 +115,6 @@
   bool runOnFunction(Function &F) override;
 };
 
-using StackSafetyGlobalInfo = std::map<const GlobalValue *, StackSafetyInfo>;
-
 /// This pass performs the global (interprocedural) stack safety analysis (new
 /// pass manager).
 class StackSafetyGlobalAnalysis
@@ -99,14 +140,15 @@
 /// This pass performs the global (interprocedural) stack safety analysis
 /// (legacy pass manager).
 class StackSafetyGlobalInfoWrapperPass : public ModulePass {
-  StackSafetyGlobalInfo SSI;
+  StackSafetyGlobalInfo SSGI;
 
 public:
   static char ID;
 
   StackSafetyGlobalInfoWrapperPass();
+  ~StackSafetyGlobalInfoWrapperPass();
 
-  const StackSafetyGlobalInfo &getResult() const { return SSI; }
+  const StackSafetyGlobalInfo &getResult() const { return SSGI; }
 
   void print(raw_ostream &O, const Module *M) const override;
   void getAnalysisUsage(AnalysisUsage &AU) const override;
@@ -114,6 +156,10 @@
   bool runOnModule(Module &M) override;
 };
 
+bool needsParamAccessSummary(const Module &M);
+
+void generateParamAccessSummary(ModuleSummaryIndex &Index);
+
 } // end namespace llvm
 
 #endif // LLVM_ANALYSIS_STACKSAFETYANALYSIS_H
diff --git a/linux-x64/clang/include/llvm/Analysis/SyncDependenceAnalysis.h b/linux-x64/clang/include/llvm/Analysis/SyncDependenceAnalysis.h
index 099403b..9838d62 100644
--- a/linux-x64/clang/include/llvm/Analysis/SyncDependenceAnalysis.h
+++ b/linux-x64/clang/include/llvm/Analysis/SyncDependenceAnalysis.h
@@ -21,6 +21,7 @@
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/Analysis/LoopInfo.h"
 #include <memory>
+#include <unordered_map>
 
 namespace llvm {
 
@@ -30,6 +31,26 @@
 class PostDominatorTree;
 
 using ConstBlockSet = SmallPtrSet<const BasicBlock *, 4>;
+struct ControlDivergenceDesc {
+  // Join points of divergent disjoint paths.
+  ConstBlockSet JoinDivBlocks;
+  // Divergent loop exits
+  ConstBlockSet LoopDivBlocks;
+};
+
+struct ModifiedPO {
+  std::vector<const BasicBlock *> LoopPO;
+  std::unordered_map<const BasicBlock *, unsigned> POIndex;
+  void appendBlock(const BasicBlock &BB) {
+    POIndex[&BB] = LoopPO.size();
+    LoopPO.push_back(&BB);
+  }
+  unsigned getIndexOf(const BasicBlock &BB) const {
+    return POIndex.find(&BB)->second;
+  }
+  unsigned size() const { return LoopPO.size(); }
+  const BasicBlock *getBlockAt(unsigned Idx) const { return LoopPO[Idx]; }
+};
 
 /// \brief Relates points of divergent control to join points in
 /// reducible CFGs.
@@ -37,12 +58,7 @@
 /// This analysis relates points of divergent control to points of converging
 /// divergent control. The analysis requires all loops to be reducible.
 class SyncDependenceAnalysis {
-  void visitSuccessor(const BasicBlock &succBlock, const Loop *termLoop,
-                      const BasicBlock *defBlock);
-
 public:
-  bool inRegion(const BasicBlock &BB) const;
-
   ~SyncDependenceAnalysis();
   SyncDependenceAnalysis(const DominatorTree &DT, const PostDominatorTree &PDT,
                          const LoopInfo &LI);
@@ -56,28 +72,19 @@
   /// header. Those exit blocks are added to the returned set.
   /// If L is the parent loop of \p Term and an exit of L is in the returned
   /// set then L is a divergent loop.
-  const ConstBlockSet &join_blocks(const Instruction &Term);
-
-  /// \brief Computes divergent join points and loop exits (in the surrounding
-  /// loop) caused by the divergent loop exits of\p Loop.
-  ///
-  /// The set of blocks which are reachable by disjoint paths from the
-  /// loop exits of \p Loop.
-  /// This treats the loop as a single node in \p Loop's parent loop.
-  /// The returned set has the same properties as for join_blocks(TermInst&).
-  const ConstBlockSet &join_blocks(const Loop &Loop);
+  const ControlDivergenceDesc &getJoinBlocks(const Instruction &Term);
 
 private:
-  static ConstBlockSet EmptyBlockSet;
+  static ControlDivergenceDesc EmptyDivergenceDesc;
 
-  ReversePostOrderTraversal<const Function *> FuncRPOT;
+  ModifiedPO LoopPO;
+
   const DominatorTree &DT;
   const PostDominatorTree &PDT;
   const LoopInfo &LI;
 
-  std::map<const Loop *, std::unique_ptr<ConstBlockSet>> CachedLoopExitJoins;
-  std::map<const Instruction *, std::unique_ptr<ConstBlockSet>>
-      CachedBranchJoins;
+  std::map<const Instruction *, std::unique_ptr<ControlDivergenceDesc>>
+      CachedControlDivDescs;
 };
 
 } // namespace llvm
diff --git a/linux-x64/clang/include/llvm/Analysis/SyntheticCountsUtils.h b/linux-x64/clang/include/llvm/Analysis/SyntheticCountsUtils.h
index b9b4c98..358f757 100644
--- a/linux-x64/clang/include/llvm/Analysis/SyntheticCountsUtils.h
+++ b/linux-x64/clang/include/llvm/Analysis/SyntheticCountsUtils.h
@@ -19,9 +19,6 @@
 
 namespace llvm {
 
-class CallGraph;
-class Function;
-
 /// Class with methods to propagate synthetic entry counts.
 ///
 /// This class is templated on the type of the call graph and designed to work
diff --git a/linux-x64/clang/include/llvm/Analysis/TargetFolder.h b/linux-x64/clang/include/llvm/Analysis/TargetFolder.h
index 7ab6562..b23316a 100644
--- a/linux-x64/clang/include/llvm/Analysis/TargetFolder.h
+++ b/linux-x64/clang/include/llvm/Analysis/TargetFolder.h
@@ -22,22 +22,23 @@
 #include "llvm/Analysis/ConstantFolding.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/InstrTypes.h"
+#include "llvm/IR/IRBuilderFolder.h"
 
 namespace llvm {
 
 class DataLayout;
 
 /// TargetFolder - Create constants with target dependent folding.
-class TargetFolder {
+class TargetFolder final : public IRBuilderFolder {
   const DataLayout &DL;
 
   /// Fold - Fold the constant using target specific information.
   Constant *Fold(Constant *C) const {
-    if (Constant *CF = ConstantFoldConstant(C, DL))
-      return CF;
-    return C;
+    return ConstantFoldConstant(C, DL);
   }
 
+  virtual void anchor();
+
 public:
   explicit TargetFolder(const DataLayout &DL) : DL(DL) {}
 
@@ -46,66 +47,70 @@
   //===--------------------------------------------------------------------===//
 
   Constant *CreateAdd(Constant *LHS, Constant *RHS,
-                      bool HasNUW = false, bool HasNSW = false) const {
+                      bool HasNUW = false, bool HasNSW = false) const override {
     return Fold(ConstantExpr::getAdd(LHS, RHS, HasNUW, HasNSW));
   }
-  Constant *CreateFAdd(Constant *LHS, Constant *RHS) const {
+  Constant *CreateFAdd(Constant *LHS, Constant *RHS) const override {
     return Fold(ConstantExpr::getFAdd(LHS, RHS));
   }
   Constant *CreateSub(Constant *LHS, Constant *RHS,
-                      bool HasNUW = false, bool HasNSW = false) const {
+                      bool HasNUW = false, bool HasNSW = false) const override {
     return Fold(ConstantExpr::getSub(LHS, RHS, HasNUW, HasNSW));
   }
-  Constant *CreateFSub(Constant *LHS, Constant *RHS) const {
+  Constant *CreateFSub(Constant *LHS, Constant *RHS) const override {
     return Fold(ConstantExpr::getFSub(LHS, RHS));
   }
   Constant *CreateMul(Constant *LHS, Constant *RHS,
-                      bool HasNUW = false, bool HasNSW = false) const {
+                      bool HasNUW = false, bool HasNSW = false) const override {
     return Fold(ConstantExpr::getMul(LHS, RHS, HasNUW, HasNSW));
   }
-  Constant *CreateFMul(Constant *LHS, Constant *RHS) const {
+  Constant *CreateFMul(Constant *LHS, Constant *RHS) const override {
     return Fold(ConstantExpr::getFMul(LHS, RHS));
   }
-  Constant *CreateUDiv(Constant *LHS, Constant *RHS, bool isExact = false)const{
+  Constant *CreateUDiv(Constant *LHS, Constant *RHS,
+                       bool isExact = false) const override {
     return Fold(ConstantExpr::getUDiv(LHS, RHS, isExact));
   }
-  Constant *CreateSDiv(Constant *LHS, Constant *RHS, bool isExact = false)const{
+  Constant *CreateSDiv(Constant *LHS, Constant *RHS,
+                       bool isExact = false) const override {
     return Fold(ConstantExpr::getSDiv(LHS, RHS, isExact));
   }
-  Constant *CreateFDiv(Constant *LHS, Constant *RHS) const {
+  Constant *CreateFDiv(Constant *LHS, Constant *RHS) const override {
     return Fold(ConstantExpr::getFDiv(LHS, RHS));
   }
-  Constant *CreateURem(Constant *LHS, Constant *RHS) const {
+  Constant *CreateURem(Constant *LHS, Constant *RHS) const override {
     return Fold(ConstantExpr::getURem(LHS, RHS));
   }
-  Constant *CreateSRem(Constant *LHS, Constant *RHS) const {
+  Constant *CreateSRem(Constant *LHS, Constant *RHS) const override {
     return Fold(ConstantExpr::getSRem(LHS, RHS));
   }
-  Constant *CreateFRem(Constant *LHS, Constant *RHS) const {
+  Constant *CreateFRem(Constant *LHS, Constant *RHS) const override {
     return Fold(ConstantExpr::getFRem(LHS, RHS));
   }
   Constant *CreateShl(Constant *LHS, Constant *RHS,
-                      bool HasNUW = false, bool HasNSW = false) const {
+                      bool HasNUW = false, bool HasNSW = false) const override {
     return Fold(ConstantExpr::getShl(LHS, RHS, HasNUW, HasNSW));
   }
-  Constant *CreateLShr(Constant *LHS, Constant *RHS, bool isExact = false)const{
+  Constant *CreateLShr(Constant *LHS, Constant *RHS,
+                       bool isExact = false) const override {
     return Fold(ConstantExpr::getLShr(LHS, RHS, isExact));
   }
-  Constant *CreateAShr(Constant *LHS, Constant *RHS, bool isExact = false)const{
+  Constant *CreateAShr(Constant *LHS, Constant *RHS,
+                       bool isExact = false) const override {
     return Fold(ConstantExpr::getAShr(LHS, RHS, isExact));
   }
-  Constant *CreateAnd(Constant *LHS, Constant *RHS) const {
+  Constant *CreateAnd(Constant *LHS, Constant *RHS) const override {
     return Fold(ConstantExpr::getAnd(LHS, RHS));
   }
-  Constant *CreateOr(Constant *LHS, Constant *RHS) const {
+  Constant *CreateOr(Constant *LHS, Constant *RHS) const override {
     return Fold(ConstantExpr::getOr(LHS, RHS));
   }
-  Constant *CreateXor(Constant *LHS, Constant *RHS) const {
+  Constant *CreateXor(Constant *LHS, Constant *RHS) const override {
     return Fold(ConstantExpr::getXor(LHS, RHS));
   }
 
   Constant *CreateBinOp(Instruction::BinaryOps Opc,
-                        Constant *LHS, Constant *RHS) const {
+                        Constant *LHS, Constant *RHS) const override {
     return Fold(ConstantExpr::get(Opc, LHS, RHS));
   }
 
@@ -114,17 +119,17 @@
   //===--------------------------------------------------------------------===//
 
   Constant *CreateNeg(Constant *C,
-                      bool HasNUW = false, bool HasNSW = false) const {
+                      bool HasNUW = false, bool HasNSW = false) const override {
     return Fold(ConstantExpr::getNeg(C, HasNUW, HasNSW));
   }
-  Constant *CreateFNeg(Constant *C) const {
+  Constant *CreateFNeg(Constant *C) const override {
     return Fold(ConstantExpr::getFNeg(C));
   }
-  Constant *CreateNot(Constant *C) const {
+  Constant *CreateNot(Constant *C) const override {
     return Fold(ConstantExpr::getNot(C));
   }
 
-  Constant *CreateUnOp(Instruction::UnaryOps Opc, Constant *C) const {
+  Constant *CreateUnOp(Instruction::UnaryOps Opc, Constant *C) const override {
     return Fold(ConstantExpr::get(Opc, C));
   }
 
@@ -133,33 +138,34 @@
   //===--------------------------------------------------------------------===//
 
   Constant *CreateGetElementPtr(Type *Ty, Constant *C,
-                                ArrayRef<Constant *> IdxList) const {
+                                ArrayRef<Constant *> IdxList) const override {
     return Fold(ConstantExpr::getGetElementPtr(Ty, C, IdxList));
   }
-  Constant *CreateGetElementPtr(Type *Ty, Constant *C, Constant *Idx) const {
+  Constant *CreateGetElementPtr(Type *Ty, Constant *C,
+                                Constant *Idx) const override {
     // This form of the function only exists to avoid ambiguous overload
     // warnings about whether to convert Idx to ArrayRef<Constant *> or
     // ArrayRef<Value *>.
     return Fold(ConstantExpr::getGetElementPtr(Ty, C, Idx));
   }
   Constant *CreateGetElementPtr(Type *Ty, Constant *C,
-                                ArrayRef<Value *> IdxList) const {
+                                ArrayRef<Value *> IdxList) const override {
     return Fold(ConstantExpr::getGetElementPtr(Ty, C, IdxList));
   }
 
-  Constant *CreateInBoundsGetElementPtr(Type *Ty, Constant *C,
-                                        ArrayRef<Constant *> IdxList) const {
+  Constant *CreateInBoundsGetElementPtr(
+      Type *Ty, Constant *C, ArrayRef<Constant *> IdxList) const override {
     return Fold(ConstantExpr::getInBoundsGetElementPtr(Ty, C, IdxList));
   }
   Constant *CreateInBoundsGetElementPtr(Type *Ty, Constant *C,
-                                        Constant *Idx) const {
+                                        Constant *Idx) const override {
     // This form of the function only exists to avoid ambiguous overload
     // warnings about whether to convert Idx to ArrayRef<Constant *> or
     // ArrayRef<Value *>.
     return Fold(ConstantExpr::getInBoundsGetElementPtr(Ty, C, Idx));
   }
-  Constant *CreateInBoundsGetElementPtr(Type *Ty, Constant *C,
-                                        ArrayRef<Value *> IdxList) const {
+  Constant *CreateInBoundsGetElementPtr(
+      Type *Ty, Constant *C, ArrayRef<Value *> IdxList) const override {
     return Fold(ConstantExpr::getInBoundsGetElementPtr(Ty, C, IdxList));
   }
 
@@ -168,54 +174,54 @@
   //===--------------------------------------------------------------------===//
 
   Constant *CreateCast(Instruction::CastOps Op, Constant *C,
-                       Type *DestTy) const {
+                       Type *DestTy) const override {
     if (C->getType() == DestTy)
       return C; // avoid calling Fold
     return Fold(ConstantExpr::getCast(Op, C, DestTy));
   }
   Constant *CreateIntCast(Constant *C, Type *DestTy,
-                          bool isSigned) const {
+                          bool isSigned) const override {
     if (C->getType() == DestTy)
       return C; // avoid calling Fold
     return Fold(ConstantExpr::getIntegerCast(C, DestTy, isSigned));
   }
-  Constant *CreatePointerCast(Constant *C, Type *DestTy) const {
+  Constant *CreatePointerCast(Constant *C, Type *DestTy) const override {
     if (C->getType() == DestTy)
       return C; // avoid calling Fold
     return Fold(ConstantExpr::getPointerCast(C, DestTy));
   }
-  Constant *CreateFPCast(Constant *C, Type *DestTy) const {
+  Constant *CreateFPCast(Constant *C, Type *DestTy) const override {
     if (C->getType() == DestTy)
       return C; // avoid calling Fold
     return Fold(ConstantExpr::getFPCast(C, DestTy));
   }
-  Constant *CreateBitCast(Constant *C, Type *DestTy) const {
+  Constant *CreateBitCast(Constant *C, Type *DestTy) const override {
     return CreateCast(Instruction::BitCast, C, DestTy);
   }
-  Constant *CreateIntToPtr(Constant *C, Type *DestTy) const {
+  Constant *CreateIntToPtr(Constant *C, Type *DestTy) const override {
     return CreateCast(Instruction::IntToPtr, C, DestTy);
   }
-  Constant *CreatePtrToInt(Constant *C, Type *DestTy) const {
+  Constant *CreatePtrToInt(Constant *C, Type *DestTy) const override {
     return CreateCast(Instruction::PtrToInt, C, DestTy);
   }
-  Constant *CreateZExtOrBitCast(Constant *C, Type *DestTy) const {
+  Constant *CreateZExtOrBitCast(Constant *C, Type *DestTy) const override {
     if (C->getType() == DestTy)
       return C; // avoid calling Fold
     return Fold(ConstantExpr::getZExtOrBitCast(C, DestTy));
   }
-  Constant *CreateSExtOrBitCast(Constant *C, Type *DestTy) const {
+  Constant *CreateSExtOrBitCast(Constant *C, Type *DestTy) const override {
     if (C->getType() == DestTy)
       return C; // avoid calling Fold
     return Fold(ConstantExpr::getSExtOrBitCast(C, DestTy));
   }
-  Constant *CreateTruncOrBitCast(Constant *C, Type *DestTy) const {
+  Constant *CreateTruncOrBitCast(Constant *C, Type *DestTy) const override {
     if (C->getType() == DestTy)
       return C; // avoid calling Fold
     return Fold(ConstantExpr::getTruncOrBitCast(C, DestTy));
   }
 
   Constant *CreatePointerBitCastOrAddrSpaceCast(Constant *C,
-                                                Type *DestTy) const {
+                                                Type *DestTy) const override {
     if (C->getType() == DestTy)
       return C; // avoid calling Fold
     return Fold(ConstantExpr::getPointerBitCastOrAddrSpaceCast(C, DestTy));
@@ -226,11 +232,11 @@
   //===--------------------------------------------------------------------===//
 
   Constant *CreateICmp(CmpInst::Predicate P, Constant *LHS,
-                       Constant *RHS) const {
+                       Constant *RHS) const override {
     return Fold(ConstantExpr::getCompare(P, LHS, RHS));
   }
   Constant *CreateFCmp(CmpInst::Predicate P, Constant *LHS,
-                       Constant *RHS) const {
+                       Constant *RHS) const override {
     return Fold(ConstantExpr::getCompare(P, LHS, RHS));
   }
 
@@ -238,31 +244,32 @@
   // Other Instructions
   //===--------------------------------------------------------------------===//
 
-  Constant *CreateSelect(Constant *C, Constant *True, Constant *False) const {
+  Constant *CreateSelect(Constant *C, Constant *True,
+                         Constant *False) const override {
     return Fold(ConstantExpr::getSelect(C, True, False));
   }
 
-  Constant *CreateExtractElement(Constant *Vec, Constant *Idx) const {
+  Constant *CreateExtractElement(Constant *Vec, Constant *Idx) const override {
     return Fold(ConstantExpr::getExtractElement(Vec, Idx));
   }
 
   Constant *CreateInsertElement(Constant *Vec, Constant *NewElt,
-                                Constant *Idx) const {
+                                Constant *Idx) const override {
     return Fold(ConstantExpr::getInsertElement(Vec, NewElt, Idx));
   }
 
   Constant *CreateShuffleVector(Constant *V1, Constant *V2,
-                                Constant *Mask) const {
+                                ArrayRef<int> Mask) const override {
     return Fold(ConstantExpr::getShuffleVector(V1, V2, Mask));
   }
 
   Constant *CreateExtractValue(Constant *Agg,
-                               ArrayRef<unsigned> IdxList) const {
+                               ArrayRef<unsigned> IdxList) const override {
     return Fold(ConstantExpr::getExtractValue(Agg, IdxList));
   }
 
   Constant *CreateInsertValue(Constant *Agg, Constant *Val,
-                              ArrayRef<unsigned> IdxList) const {
+                              ArrayRef<unsigned> IdxList) const override {
     return Fold(ConstantExpr::getInsertValue(Agg, Val, IdxList));
   }
 };
diff --git a/linux-x64/clang/include/llvm/Analysis/TargetLibraryInfo.def b/linux-x64/clang/include/llvm/Analysis/TargetLibraryInfo.def
index afed404..7501d1a 100644
--- a/linux-x64/clang/include/llvm/Analysis/TargetLibraryInfo.def
+++ b/linux-x64/clang/include/llvm/Analysis/TargetLibraryInfo.def
@@ -136,9 +136,15 @@
 /// void operator delete[](void*, unsigned int);
 TLI_DEFINE_ENUM_INTERNAL(ZdaPvj)
 TLI_DEFINE_STRING_INTERNAL("_ZdaPvj")
+/// void operator delete[](void*, unsigned int, align_val_t);
+TLI_DEFINE_ENUM_INTERNAL(ZdaPvjSt11align_val_t)
+TLI_DEFINE_STRING_INTERNAL("_ZdaPvjSt11align_val_t")
 /// void operator delete[](void*, unsigned long);
 TLI_DEFINE_ENUM_INTERNAL(ZdaPvm)
 TLI_DEFINE_STRING_INTERNAL("_ZdaPvm")
+/// void operator delete[](void*, unsigned long, align_val_t);
+TLI_DEFINE_ENUM_INTERNAL(ZdaPvmSt11align_val_t)
+TLI_DEFINE_STRING_INTERNAL("_ZdaPvmSt11align_val_t")
 /// void operator delete(void*);
 TLI_DEFINE_ENUM_INTERNAL(ZdlPv)
 TLI_DEFINE_STRING_INTERNAL("_ZdlPv")
@@ -154,9 +160,15 @@
 /// void operator delete(void*, unsigned int);
 TLI_DEFINE_ENUM_INTERNAL(ZdlPvj)
 TLI_DEFINE_STRING_INTERNAL("_ZdlPvj")
+/// void operator delete(void*, unsigned int, align_val_t)
+TLI_DEFINE_ENUM_INTERNAL(ZdlPvjSt11align_val_t)
+TLI_DEFINE_STRING_INTERNAL("_ZdlPvjSt11align_val_t")
 /// void operator delete(void*, unsigned long);
 TLI_DEFINE_ENUM_INTERNAL(ZdlPvm)
 TLI_DEFINE_STRING_INTERNAL("_ZdlPvm")
+/// void operator delete(void*, unsigned long, align_val_t)
+TLI_DEFINE_ENUM_INTERNAL(ZdlPvmSt11align_val_t)
+TLI_DEFINE_STRING_INTERNAL("_ZdlPvmSt11align_val_t")
 /// void *new[](unsigned int);
 TLI_DEFINE_ENUM_INTERNAL(Znaj)
 TLI_DEFINE_STRING_INTERNAL("_Znaj")
@@ -250,6 +262,12 @@
 /// long double __atanhl_finite(long double x);
 TLI_DEFINE_ENUM_INTERNAL(atanhl_finite)
 TLI_DEFINE_STRING_INTERNAL("__atanhl_finite")
+/// void __atomic_load(size_t size, void *mptr, void *vptr, int smodel);
+TLI_DEFINE_ENUM_INTERNAL(atomic_load)
+TLI_DEFINE_STRING_INTERNAL("__atomic_load")
+/// void __atomic_store(size_t size, void *mptr, void *vptr, int smodel);
+TLI_DEFINE_ENUM_INTERNAL(atomic_store)
+TLI_DEFINE_STRING_INTERNAL("__atomic_store")
 /// double __cosh_finite(double x);
 TLI_DEFINE_ENUM_INTERNAL(cosh_finite)
 TLI_DEFINE_STRING_INTERNAL("__cosh_finite")
@@ -348,6 +366,9 @@
 /// void *__memmove_chk(void *s1, const void *s2, size_t n, size_t s1size);
 TLI_DEFINE_ENUM_INTERNAL(memmove_chk)
 TLI_DEFINE_STRING_INTERNAL("__memmove_chk")
+/// void *__mempcpy_chk(void *s1, const void *s2, size_t n, size_t s1size);
+TLI_DEFINE_ENUM_INTERNAL(mempcpy_chk)
+TLI_DEFINE_STRING_INTERNAL("__mempcpy_chk")
 /// void *__memset_chk(void *s, char v, size_t n, size_t s1size);
 TLI_DEFINE_ENUM_INTERNAL(memset_chk)
 TLI_DEFINE_STRING_INTERNAL("__memset_chk")
@@ -434,6 +455,9 @@
 ///                      size_t dstsize);
 TLI_DEFINE_ENUM_INTERNAL(strlcpy_chk)
 TLI_DEFINE_STRING_INTERNAL("__strlcpy_chk")
+/// size_t __strlen_chk(const char *s1, size_t s1size);
+TLI_DEFINE_ENUM_INTERNAL(strlen_chk)
+TLI_DEFINE_STRING_INTERNAL("__strlen_chk")
 /// char *strncat_chk(char *s1, const char *s2, size_t n, size_t s1size);
 TLI_DEFINE_ENUM_INTERNAL(strncat_chk)
 TLI_DEFINE_STRING_INTERNAL("__strncat_chk")
@@ -478,6 +502,9 @@
 /// long double acosl(long double x);
 TLI_DEFINE_ENUM_INTERNAL(acosl)
 TLI_DEFINE_STRING_INTERNAL("acosl")
+/// void *aligned_alloc(size_t alignment, size_t size);
+TLI_DEFINE_ENUM_INTERNAL(aligned_alloc)
+TLI_DEFINE_STRING_INTERNAL("aligned_alloc")
 /// double asin(double x);
 TLI_DEFINE_ENUM_INTERNAL(asin)
 TLI_DEFINE_STRING_INTERNAL("asin")
@@ -1119,6 +1146,15 @@
 /// char *realpath(const char *file_name, char *resolved_name);
 TLI_DEFINE_ENUM_INTERNAL(realpath)
 TLI_DEFINE_STRING_INTERNAL("realpath")
+/// double remainder(double x, double y);
+TLI_DEFINE_ENUM_INTERNAL(remainder)
+TLI_DEFINE_STRING_INTERNAL("remainder")
+/// float remainderf(float x, float y);
+TLI_DEFINE_ENUM_INTERNAL(remainderf)
+TLI_DEFINE_STRING_INTERNAL("remainderf")
+/// long double remainderl(long double x, long double y);
+TLI_DEFINE_ENUM_INTERNAL(remainderl)
+TLI_DEFINE_STRING_INTERNAL("remainderl")
 /// int remove(const char *path);
 TLI_DEFINE_ENUM_INTERNAL(remove)
 TLI_DEFINE_STRING_INTERNAL("remove")
@@ -1143,6 +1179,15 @@
 /// double round(double x);
 TLI_DEFINE_ENUM_INTERNAL(round)
 TLI_DEFINE_STRING_INTERNAL("round")
+/// double roundeven(double x);
+TLI_DEFINE_ENUM_INTERNAL(roundeven)
+TLI_DEFINE_STRING_INTERNAL("roundeven")
+/// float roundevenf(float x);
+TLI_DEFINE_ENUM_INTERNAL(roundevenf)
+TLI_DEFINE_STRING_INTERNAL("roundevenf")
+/// long double roundevenl(long double x);
+TLI_DEFINE_ENUM_INTERNAL(roundevenl)
+TLI_DEFINE_STRING_INTERNAL("roundevenl")
 /// float roundf(float x);
 TLI_DEFINE_ENUM_INTERNAL(roundf)
 TLI_DEFINE_STRING_INTERNAL("roundf")
diff --git a/linux-x64/clang/include/llvm/Analysis/TargetLibraryInfo.h b/linux-x64/clang/include/llvm/Analysis/TargetLibraryInfo.h
index 4b5200f..34a8a1e 100644
--- a/linux-x64/clang/include/llvm/Analysis/TargetLibraryInfo.h
+++ b/linux-x64/clang/include/llvm/Analysis/TargetLibraryInfo.h
@@ -9,17 +9,18 @@
 #ifndef LLVM_ANALYSIS_TARGETLIBRARYINFO_H
 #define LLVM_ANALYSIS_TARGETLIBRARYINFO_H
 
+#include "llvm/ADT/BitVector.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/Optional.h"
-#include "llvm/ADT/Triple.h"
-#include "llvm/IR/CallSite.h"
 #include "llvm/IR/Function.h"
+#include "llvm/IR/InstrTypes.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/Pass.h"
 
 namespace llvm {
 template <typename T> class ArrayRef;
+class Triple;
 
 /// Describes a possible vectorization of a function.
 /// Function 'VectorFnName' is equivalent to 'ScalarFnName' vectorized
@@ -30,11 +31,12 @@
   unsigned VectorizationFactor;
 };
 
-  enum LibFunc {
+  enum LibFunc : unsigned {
 #define TLI_DEFINE_ENUM
 #include "llvm/Analysis/TargetLibraryInfo.def"
 
-    NumLibFuncs
+    NumLibFuncs,
+    NotLibFunc
   };
 
 /// Implementation of the target library information.
@@ -48,7 +50,7 @@
 
   unsigned char AvailableArray[(NumLibFuncs+3)/4];
   llvm::DenseMap<unsigned, std::string> CustomNames;
-  static StringRef const StandardNames[NumLibFuncs];
+  static StringLiteral const StandardNames[NumLibFuncs];
   bool ShouldExtI32Param, ShouldExtI32Return, ShouldSignExtI32Param;
 
   enum AvailabilityState {
@@ -86,6 +88,7 @@
   enum VectorLibrary {
     NoLibrary,  // Don't use any vector library.
     Accelerate, // Use Accelerate framework.
+    LIBMVEC_X86,// GLIBC Vector Math library.
     MASSV,      // IBM MASS vector library.
     SVML        // Intel short vector math library.
   };
@@ -127,7 +130,7 @@
   void setAvailableWithName(LibFunc F, StringRef Name) {
     if (StandardNames[F] != Name) {
       setState(F, CustomName);
-      CustomNames[F] = Name;
+      CustomNames[F] = std::string(Name);
       assert(CustomNames.find(F) != CustomNames.end());
     } else {
       setState(F, StandardName);
@@ -196,6 +199,10 @@
   /// Returns the size of the wchar_t type in bytes or 0 if the size is unknown.
   /// This queries the 'wchar_size' metadata.
   unsigned getWCharSize(const Module &M) const;
+
+  /// Returns the largest vectorization factor used in the list of
+  /// vector functions.
+  unsigned getWidestVF(StringRef ScalarF) const;
 };
 
 /// Provides information about what library functions are available for
@@ -207,23 +214,68 @@
   friend class TargetLibraryAnalysis;
   friend class TargetLibraryInfoWrapperPass;
 
+  /// The global (module level) TLI info.
   const TargetLibraryInfoImpl *Impl;
 
+  /// Support for -fno-builtin* options as function attributes, overrides
+  /// information in global TargetLibraryInfoImpl.
+  BitVector OverrideAsUnavailable;
+
 public:
-  explicit TargetLibraryInfo(const TargetLibraryInfoImpl &Impl) : Impl(&Impl) {}
+  explicit TargetLibraryInfo(const TargetLibraryInfoImpl &Impl,
+                             Optional<const Function *> F = None)
+      : Impl(&Impl), OverrideAsUnavailable(NumLibFuncs) {
+    if (!F)
+      return;
+    if ((*F)->hasFnAttribute("no-builtins"))
+      disableAllFunctions();
+    else {
+      // Disable individual libc/libm calls in TargetLibraryInfo.
+      LibFunc LF;
+      AttributeSet FnAttrs = (*F)->getAttributes().getFnAttributes();
+      for (const Attribute &Attr : FnAttrs) {
+        if (!Attr.isStringAttribute())
+          continue;
+        auto AttrStr = Attr.getKindAsString();
+        if (!AttrStr.consume_front("no-builtin-"))
+          continue;
+        if (getLibFunc(AttrStr, LF))
+          setUnavailable(LF);
+      }
+    }
+  }
 
   // Provide value semantics.
-  TargetLibraryInfo(const TargetLibraryInfo &TLI) : Impl(TLI.Impl) {}
-  TargetLibraryInfo(TargetLibraryInfo &&TLI) : Impl(TLI.Impl) {}
+  TargetLibraryInfo(const TargetLibraryInfo &TLI)
+      : Impl(TLI.Impl), OverrideAsUnavailable(TLI.OverrideAsUnavailable) {}
+  TargetLibraryInfo(TargetLibraryInfo &&TLI)
+      : Impl(TLI.Impl), OverrideAsUnavailable(TLI.OverrideAsUnavailable) {}
   TargetLibraryInfo &operator=(const TargetLibraryInfo &TLI) {
     Impl = TLI.Impl;
+    OverrideAsUnavailable = TLI.OverrideAsUnavailable;
     return *this;
   }
   TargetLibraryInfo &operator=(TargetLibraryInfo &&TLI) {
     Impl = TLI.Impl;
+    OverrideAsUnavailable = TLI.OverrideAsUnavailable;
     return *this;
   }
 
+  /// Determine whether a callee with the given TLI can be inlined into
+  /// caller with this TLI, based on 'nobuiltin' attributes. When requested,
+  /// allow inlining into a caller with a superset of the callee's nobuiltin
+  /// attributes, which is conservatively correct.
+  bool areInlineCompatible(const TargetLibraryInfo &CalleeTLI,
+                           bool AllowCallerSuperset) const {
+    if (!AllowCallerSuperset)
+      return OverrideAsUnavailable == CalleeTLI.OverrideAsUnavailable;
+    BitVector B = OverrideAsUnavailable;
+    B |= CalleeTLI.OverrideAsUnavailable;
+    // We can inline if the union of the caller and callee's nobuiltin
+    // attributes is no stricter than the caller's nobuiltin attributes.
+    return B == OverrideAsUnavailable;
+  }
+
   /// Searches for a particular function name.
   ///
   /// If it is one of the known library functions, return true and set F to the
@@ -236,16 +288,34 @@
     return Impl->getLibFunc(FDecl, F);
   }
 
-  /// If a callsite does not have the 'nobuiltin' attribute, return if the
+  /// If a callbase does not have the 'nobuiltin' attribute, return if the
   /// called function is a known library function and set F to that function.
-  bool getLibFunc(ImmutableCallSite CS, LibFunc &F) const {
-    return !CS.isNoBuiltin() && CS.getCalledFunction() &&
-           getLibFunc(*(CS.getCalledFunction()), F);
+  bool getLibFunc(const CallBase &CB, LibFunc &F) const {
+    return !CB.isNoBuiltin() && CB.getCalledFunction() &&
+           getLibFunc(*(CB.getCalledFunction()), F);
+  }
+
+  /// Disables all builtins.
+  ///
+  /// This can be used for options like -fno-builtin.
+  void disableAllFunctions() LLVM_ATTRIBUTE_UNUSED {
+    OverrideAsUnavailable.set();
+  }
+
+  /// Forces a function to be marked as unavailable.
+  void setUnavailable(LibFunc F) LLVM_ATTRIBUTE_UNUSED {
+    OverrideAsUnavailable.set(F);
+  }
+
+  TargetLibraryInfoImpl::AvailabilityState getState(LibFunc F) const {
+    if (OverrideAsUnavailable[F])
+      return TargetLibraryInfoImpl::Unavailable;
+    return Impl->getState(F);
   }
 
   /// Tests whether a library function is available.
   bool has(LibFunc F) const {
-    return Impl->getState(F) != TargetLibraryInfoImpl::Unavailable;
+    return getState(F) != TargetLibraryInfoImpl::Unavailable;
   }
   bool isFunctionVectorizable(StringRef F, unsigned VF) const {
     return Impl->isFunctionVectorizable(F, VF);
@@ -260,7 +330,7 @@
   /// Tests if the function is both available and a candidate for optimized code
   /// generation.
   bool hasOptimizedCodeGen(LibFunc F) const {
-    if (Impl->getState(F) == TargetLibraryInfoImpl::Unavailable)
+    if (getState(F) == TargetLibraryInfoImpl::Unavailable)
       return false;
     switch (F) {
     default: break;
@@ -281,6 +351,7 @@
     case LibFunc_trunc:        case LibFunc_truncf:     case LibFunc_truncl:
     case LibFunc_log2:         case LibFunc_log2f:      case LibFunc_log2l:
     case LibFunc_exp2:         case LibFunc_exp2f:      case LibFunc_exp2l:
+    case LibFunc_memcpy:       case LibFunc_memset:     case LibFunc_memmove:
     case LibFunc_memcmp:       case LibFunc_bcmp:       case LibFunc_strcmp:
     case LibFunc_strcpy:       case LibFunc_stpcpy:     case LibFunc_strlen:
     case LibFunc_strnlen:      case LibFunc_memchr:     case LibFunc_mempcpy:
@@ -290,7 +361,7 @@
   }
 
   StringRef getName(LibFunc F) const {
-    auto State = Impl->getState(F);
+    auto State = getState(F);
     if (State == TargetLibraryInfoImpl::Unavailable)
       return StringRef();
     if (State == TargetLibraryInfoImpl::StandardName)
@@ -336,6 +407,16 @@
                   FunctionAnalysisManager::Invalidator &) {
     return false;
   }
+  /// Returns the largest vectorization factor used in the list of
+  /// vector functions.
+  unsigned getWidestVF(StringRef ScalarF) const {
+    return Impl->getWidestVF(ScalarF);
+  }
+
+  /// Check if the function "F" is listed in a library known to LLVM.
+  bool isKnownVectorFunctionInLibrary(StringRef F) const {
+    return this->isFunctionVectorizable(F);
+  }
 };
 
 /// Analysis pass providing the \c TargetLibraryInfo.
@@ -352,30 +433,24 @@
   /// module.
   TargetLibraryAnalysis() {}
 
-  /// Construct a library analysis with preset info.
+  /// Construct a library analysis with baseline Module-level info.
   ///
-  /// This will directly copy the preset info into the result without
-  /// consulting the module's triple.
-  TargetLibraryAnalysis(TargetLibraryInfoImpl PresetInfoImpl)
-      : PresetInfoImpl(std::move(PresetInfoImpl)) {}
+  /// This will be supplemented with Function-specific info in the Result.
+  TargetLibraryAnalysis(TargetLibraryInfoImpl BaselineInfoImpl)
+      : BaselineInfoImpl(std::move(BaselineInfoImpl)) {}
 
-  TargetLibraryInfo run(Module &M, ModuleAnalysisManager &);
-  TargetLibraryInfo run(Function &F, FunctionAnalysisManager &);
+  TargetLibraryInfo run(const Function &F, FunctionAnalysisManager &);
 
 private:
   friend AnalysisInfoMixin<TargetLibraryAnalysis>;
   static AnalysisKey Key;
 
-  Optional<TargetLibraryInfoImpl> PresetInfoImpl;
-
-  StringMap<std::unique_ptr<TargetLibraryInfoImpl>> Impls;
-
-  TargetLibraryInfoImpl &lookupInfoImpl(const Triple &T);
+  Optional<TargetLibraryInfoImpl> BaselineInfoImpl;
 };
 
 class TargetLibraryInfoWrapperPass : public ImmutablePass {
-  TargetLibraryInfoImpl TLIImpl;
-  TargetLibraryInfo TLI;
+  TargetLibraryAnalysis TLA;
+  Optional<TargetLibraryInfo> TLI;
 
   virtual void anchor();
 
@@ -385,8 +460,11 @@
   explicit TargetLibraryInfoWrapperPass(const Triple &T);
   explicit TargetLibraryInfoWrapperPass(const TargetLibraryInfoImpl &TLI);
 
-  TargetLibraryInfo &getTLI() { return TLI; }
-  const TargetLibraryInfo &getTLI() const { return TLI; }
+  TargetLibraryInfo &getTLI(const Function &F) {
+    FunctionAnalysisManager DummyFAM;
+    TLI = TLA.run(F, DummyFAM);
+    return *TLI;
+  }
 };
 
 } // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/Analysis/TargetTransformInfo.h b/linux-x64/clang/include/llvm/Analysis/TargetTransformInfo.h
index af1a12d..ee34312 100644
--- a/linux-x64/clang/include/llvm/Analysis/TargetTransformInfo.h
+++ b/linux-x64/clang/include/llvm/Analysis/TargetTransformInfo.h
@@ -21,31 +21,36 @@
 #ifndef LLVM_ANALYSIS_TARGETTRANSFORMINFO_H
 #define LLVM_ANALYSIS_TARGETTRANSFORMINFO_H
 
-#include "llvm/ADT/Optional.h"
+#include "llvm/IR/InstrTypes.h"
 #include "llvm/IR/Operator.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/AtomicOrdering.h"
 #include "llvm/Support/DataTypes.h"
-#include "llvm/Analysis/LoopInfo.h"
-#include "llvm/Analysis/ScalarEvolution.h"
-#include "llvm/IR/Dominators.h"
-#include "llvm/Analysis/AssumptionCache.h"
+#include "llvm/Support/InstructionCost.h"
 #include <functional>
 
 namespace llvm {
 
 namespace Intrinsic {
-enum ID : unsigned;
+typedef unsigned ID;
 }
 
 class AssumptionCache;
+class BlockFrequencyInfo;
+class DominatorTree;
 class BranchInst;
+class CallBase;
+class ExtractElementInst;
 class Function;
 class GlobalValue;
+class InstCombiner;
 class IntrinsicInst;
 class LoadInst;
+class LoopAccessInfo;
 class Loop;
+class LoopInfo;
+class ProfileSummaryInfo;
 class SCEV;
 class ScalarEvolution;
 class StoreInst;
@@ -54,6 +59,8 @@
 class Type;
 class User;
 class Value;
+struct KnownBits;
+template <typename T> class Optional;
 
 /// Information about a load/store intrinsic defined by the target.
 struct MemIntrinsicInfo {
@@ -75,7 +82,8 @@
 
   bool isUnordered() const {
     return (Ordering == AtomicOrdering::NotAtomic ||
-            Ordering == AtomicOrdering::Unordered) && !IsVolatile;
+            Ordering == AtomicOrdering::Unordered) &&
+           !IsVolatile;
   }
 };
 
@@ -86,7 +94,7 @@
   Loop *L = nullptr;
   BasicBlock *ExitBlock = nullptr;
   BranchInst *ExitBranch = nullptr;
-  const SCEV *ExitCount = nullptr;
+  const SCEV *TripCount = nullptr;
   IntegerType *CountType = nullptr;
   Value *LoopDecrement = nullptr; // Decrement the loop counter by this
                                   // value in every iteration.
@@ -103,6 +111,68 @@
   bool canAnalyze(LoopInfo &LI);
 };
 
+class IntrinsicCostAttributes {
+  const IntrinsicInst *II = nullptr;
+  Type *RetTy = nullptr;
+  Intrinsic::ID IID;
+  SmallVector<Type *, 4> ParamTys;
+  SmallVector<const Value *, 4> Arguments;
+  FastMathFlags FMF;
+  ElementCount VF = ElementCount::getFixed(1);
+  // If ScalarizationCost is UINT_MAX, the cost of scalarizing the
+  // arguments and the return value will be computed based on types.
+  unsigned ScalarizationCost = std::numeric_limits<unsigned>::max();
+
+public:
+  IntrinsicCostAttributes(const IntrinsicInst &I);
+
+  IntrinsicCostAttributes(Intrinsic::ID Id, const CallBase &CI);
+
+  IntrinsicCostAttributes(Intrinsic::ID Id, const CallBase &CI,
+                          ElementCount Factor);
+
+  IntrinsicCostAttributes(Intrinsic::ID Id, const CallBase &CI,
+                          ElementCount Factor, unsigned ScalarCost);
+
+  IntrinsicCostAttributes(Intrinsic::ID Id, Type *RTy,
+                          ArrayRef<Type *> Tys, FastMathFlags Flags);
+
+  IntrinsicCostAttributes(Intrinsic::ID Id, Type *RTy,
+                          ArrayRef<Type *> Tys, FastMathFlags Flags,
+                          unsigned ScalarCost);
+
+  IntrinsicCostAttributes(Intrinsic::ID Id, Type *RTy,
+                          ArrayRef<Type *> Tys, FastMathFlags Flags,
+                          unsigned ScalarCost,
+                          const IntrinsicInst *I);
+
+  IntrinsicCostAttributes(Intrinsic::ID Id, Type *RTy,
+                          ArrayRef<Type *> Tys);
+
+  IntrinsicCostAttributes(Intrinsic::ID Id, Type *RTy,
+                          ArrayRef<const Value *> Args);
+
+  Intrinsic::ID getID() const { return IID; }
+  const IntrinsicInst *getInst() const { return II; }
+  Type *getReturnType() const { return RetTy; }
+  ElementCount getVectorFactor() const { return VF; }
+  FastMathFlags getFlags() const { return FMF; }
+  unsigned getScalarizationCost() const { return ScalarizationCost; }
+  const SmallVectorImpl<const Value *> &getArgs() const { return Arguments; }
+  const SmallVectorImpl<Type *> &getArgTypes() const { return ParamTys; }
+
+  bool isTypeBasedOnly() const {
+    return Arguments.empty();
+  }
+
+  bool skipScalarizationCost() const {
+    return ScalarizationCost != std::numeric_limits<unsigned>::max();
+  }
+};
+
+class TargetTransformInfo;
+typedef TargetTransformInfo TTI;
+
 /// This pass provides access to the codegen interfaces that are needed
 /// for IR-level transformations.
 class TargetTransformInfo {
@@ -151,7 +221,8 @@
   enum TargetCostKind {
     TCK_RecipThroughput, ///< Reciprocal throughput.
     TCK_Latency,         ///< The latency of instruction.
-    TCK_CodeSize         ///< Instruction code size.
+    TCK_CodeSize,        ///< Instruction code size.
+    TCK_SizeAndLatency   ///< The weighted sum of size and latency.
   };
 
   /// Query the cost of a specified instruction.
@@ -161,18 +232,24 @@
   ///
   /// Note, this method does not cache the cost calculation and it
   /// can be expensive in some cases.
-  int getInstructionCost(const Instruction *I, enum TargetCostKind kind) const {
-    switch (kind){
+  InstructionCost getInstructionCost(const Instruction *I,
+                                     enum TargetCostKind kind) const {
+    InstructionCost Cost;
+    switch (kind) {
     case TCK_RecipThroughput:
-      return getInstructionThroughput(I);
-
+      Cost = getInstructionThroughput(I);
+      break;
     case TCK_Latency:
-      return getInstructionLatency(I);
-
+      Cost = getInstructionLatency(I);
+      break;
     case TCK_CodeSize:
-      return getUserCost(I);
+    case TCK_SizeAndLatency:
+      Cost = getUserCost(I, kind);
+      break;
     }
-    llvm_unreachable("Unknown instruction cost kind");
+    if (Cost == -1)
+      Cost.setInvalid();
+    return Cost;
   }
 
   /// Underlying constants for 'cost' values in this interface.
@@ -199,61 +276,10 @@
     TCC_Expensive = 4 ///< The cost of a 'div' instruction on x86.
   };
 
-  /// Estimate the cost of a specific operation when lowered.
-  ///
-  /// Note that this is designed to work on an arbitrary synthetic opcode, and
-  /// thus work for hypothetical queries before an instruction has even been
-  /// formed. However, this does *not* work for GEPs, and must not be called
-  /// for a GEP instruction. Instead, use the dedicated getGEPCost interface as
-  /// analyzing a GEP's cost required more information.
-  ///
-  /// Typically only the result type is required, and the operand type can be
-  /// omitted. However, if the opcode is one of the cast instructions, the
-  /// operand type is required.
-  ///
-  /// The returned cost is defined in terms of \c TargetCostConstants, see its
-  /// comments for a detailed explanation of the cost values.
-  int getOperationCost(unsigned Opcode, Type *Ty, Type *OpTy = nullptr) const;
-
   /// Estimate the cost of a GEP operation when lowered.
-  ///
-  /// The contract for this function is the same as \c getOperationCost except
-  /// that it supports an interface that provides extra information specific to
-  /// the GEP operation.
   int getGEPCost(Type *PointeeType, const Value *Ptr,
-                 ArrayRef<const Value *> Operands) const;
-
-  /// Estimate the cost of a EXT operation when lowered.
-  ///
-  /// The contract for this function is the same as \c getOperationCost except
-  /// that it supports an interface that provides extra information specific to
-  /// the EXT operation.
-  int getExtCost(const Instruction *I, const Value *Src) const;
-
-  /// Estimate the cost of a function call when lowered.
-  ///
-  /// The contract for this is the same as \c getOperationCost except that it
-  /// supports an interface that provides extra information specific to call
-  /// instructions.
-  ///
-  /// This is the most basic query for estimating call cost: it only knows the
-  /// function type and (potentially) the number of arguments at the call site.
-  /// The latter is only interesting for varargs function types.
-  int getCallCost(FunctionType *FTy, int NumArgs = -1,
-                  const User *U = nullptr) const;
-
-  /// Estimate the cost of calling a specific function when lowered.
-  ///
-  /// This overload adds the ability to reason about the particular function
-  /// being called in the event it is a library call with special lowering.
-  int getCallCost(const Function *F, int NumArgs = -1,
-                  const User *U = nullptr) const;
-
-  /// Estimate the cost of calling a specific function when lowered.
-  ///
-  /// This overload allows specifying a set of candidate argument values.
-  int getCallCost(const Function *F, ArrayRef<const Value *> Arguments,
-                  const User *U = nullptr) const;
+                 ArrayRef<const Value *> Operands,
+                 TargetCostKind CostKind = TCK_SizeAndLatency) const;
 
   /// \returns A value by which our inlining threshold should be multiplied.
   /// This is primarily used to bump up the inlining threshold wholesale on
@@ -263,19 +289,17 @@
   /// individual classes of instructions would be better.
   unsigned getInliningThresholdMultiplier() const;
 
-  /// Estimate the cost of an intrinsic when lowered.
+  /// \returns Vector bonus in percent.
   ///
-  /// Mirrors the \c getCallCost method but uses an intrinsic identifier.
-  int getIntrinsicCost(Intrinsic::ID IID, Type *RetTy,
-                       ArrayRef<Type *> ParamTys,
-                       const User *U = nullptr) const;
-
-  /// Estimate the cost of an intrinsic when lowered.
-  ///
-  /// Mirrors the \c getCallCost method but uses an intrinsic identifier.
-  int getIntrinsicCost(Intrinsic::ID IID, Type *RetTy,
-                       ArrayRef<const Value *> Arguments,
-                       const User *U = nullptr) const;
+  /// Vector bonuses: We want to more aggressively inline vector-dense kernels
+  /// and apply this bonus based on the percentage of vector instructions. A
+  /// bonus is applied if the vector instructions exceed 50% and half that
+  /// amount is applied if it exceeds 10%. Note that these bonuses are some what
+  /// arbitrary and evolved over time by accident as much as because they are
+  /// principled bonuses.
+  /// FIXME: It would be nice to base the bonus values on something more
+  /// scientific. A target may has no bonus on vector instructions.
+  int getInlinerVectorBonusPercent() const;
 
   /// \return the expected cost of a memcpy, which could e.g. depend on the
   /// source/destination type and alignment and the number of bytes copied.
@@ -285,20 +309,14 @@
   /// \p JTSize Set a jump table size only when \p SI is suitable for a jump
   /// table.
   unsigned getEstimatedNumberOfCaseClusters(const SwitchInst &SI,
-                                            unsigned &JTSize) const;
+                                            unsigned &JTSize,
+                                            ProfileSummaryInfo *PSI,
+                                            BlockFrequencyInfo *BFI) const;
 
   /// Estimate the cost of a given IR user when lowered.
   ///
   /// This can estimate the cost of either a ConstantExpr or Instruction when
-  /// lowered. It has two primary advantages over the \c getOperationCost and
-  /// \c getGEPCost above, and one significant disadvantage: it can only be
-  /// used when the IR construct has already been formed.
-  ///
-  /// The advantages are that it can inspect the SSA use graph to reason more
-  /// accurately about the cost. For example, all-constant-GEPs can often be
-  /// folded into a load or other instruction, but if they are used in some
-  /// other context they may not be folded. This routine can distinguish such
-  /// cases.
+  /// lowered.
   ///
   /// \p Operands is a list of operands which can be a result of transformations
   /// of the current operands. The number of the operands on the list must equal
@@ -308,14 +326,14 @@
   ///
   /// The returned cost is defined in terms of \c TargetCostConstants, see its
   /// comments for a detailed explanation of the cost values.
-  int getUserCost(const User *U, ArrayRef<const Value *> Operands) const;
+  int getUserCost(const User *U, ArrayRef<const Value *> Operands,
+                  TargetCostKind CostKind) const;
 
   /// This is a helper function which calls the two-argument getUserCost
   /// with \p Operands which are the current operands U has.
-  int getUserCost(const User *U) const {
-    SmallVector<const Value *, 4> Operands(U->value_op_begin(),
-                                           U->value_op_end());
-    return getUserCost(U, Operands);
+  int getUserCost(const User *U, TargetCostKind CostKind) const {
+    SmallVector<const Value *, 4> Operands(U->operand_values());
+    return getUserCost(U, Operands, CostKind);
   }
 
   /// Return true if branch divergence exists.
@@ -325,12 +343,16 @@
   /// branches.
   bool hasBranchDivergence() const;
 
+  /// Return true if the target prefers to use GPU divergence analysis to
+  /// replace the legacy version.
+  bool useGPUDivergenceAnalysis() const;
+
   /// Returns whether V is a source of divergence.
   ///
   /// This function provides the target-dependent information for
-  /// the target-independent LegacyDivergenceAnalysis. LegacyDivergenceAnalysis first
-  /// builds the dependency graph, and then runs the reachability algorithm
-  /// starting with the sources of divergence.
+  /// the target-independent LegacyDivergenceAnalysis. LegacyDivergenceAnalysis
+  /// first builds the dependency graph, and then runs the reachability
+  /// algorithm starting with the sources of divergence.
   bool isSourceOfDivergence(const Value *V) const;
 
   // Returns true for the target specific
@@ -356,6 +378,25 @@
   /// optimize away.
   unsigned getFlatAddressSpace() const;
 
+  /// Return any intrinsic address operand indexes which may be rewritten if
+  /// they use a flat address space pointer.
+  ///
+  /// \returns true if the intrinsic was handled.
+  bool collectFlatAddressOperands(SmallVectorImpl<int> &OpIndexes,
+                                  Intrinsic::ID IID) const;
+
+  bool isNoopAddrSpaceCast(unsigned FromAS, unsigned ToAS) const;
+
+  unsigned getAssumedAddrSpace(const Value *V) const;
+
+  /// Rewrite intrinsic call \p II such that \p OldV will be replaced with \p
+  /// NewV, which has a different address space. This should happen for every
+  /// operand index that collectFlatAddressOperands returned for the intrinsic.
+  /// \returns nullptr if the intrinsic was not handled. Otherwise, returns the
+  /// new value (which may be the original \p II with modified operands).
+  Value *rewriteIntrinsicWithAddressSpace(IntrinsicInst *II, Value *OldV,
+                                          Value *NewV) const;
+
   /// Test whether calls to a function lower to actual program function
   /// calls.
   ///
@@ -419,11 +460,6 @@
     /// transformation will select an unrolling factor based on the current cost
     /// threshold and other factors.
     unsigned Count;
-    /// A forced peeling factor (the number of bodied of the original loop
-    /// that should be peeled off before the loop body). When set to 0, the
-    /// unrolling transformation will select a peeling factor based on profile
-    /// information and other factors.
-    unsigned PeelCount;
     /// Default unroll count for loops with run-time trip count.
     unsigned DefaultUnrollRuntimeCount;
     // Set the maximum unrolling factor. The unrolling factor may be selected
@@ -457,8 +493,6 @@
     bool Force;
     /// Allow using trip count upper bound to unroll loops.
     bool UpperBound;
-    /// Allow peeling off loop iterations for loops with low dynamic tripcount.
-    bool AllowPeeling;
     /// Allow unrolling of all the iterations of the runtime loop remainder.
     bool UnrollRemainder;
     /// Allow unroll and jam. Used to enable unroll and jam for the target.
@@ -468,6 +502,9 @@
     /// This value is used in the same manner to limit the size of the inner
     /// loop.
     unsigned UnrollAndJamInnerLoopThreshold;
+    /// Don't allow loop unrolling to simulate more than this number of
+    /// iterations when checking full unroll profitability
+    unsigned MaxIterationsCountToAnalyze;
   };
 
   /// Get target-customized preferences for the generic loop unrolling
@@ -479,10 +516,65 @@
   /// Query the target whether it would be profitable to convert the given loop
   /// into a hardware loop.
   bool isHardwareLoopProfitable(Loop *L, ScalarEvolution &SE,
-                                AssumptionCache &AC,
-                                TargetLibraryInfo *LibInfo,
+                                AssumptionCache &AC, TargetLibraryInfo *LibInfo,
                                 HardwareLoopInfo &HWLoopInfo) const;
 
+  /// Query the target whether it would be prefered to create a predicated
+  /// vector loop, which can avoid the need to emit a scalar epilogue loop.
+  bool preferPredicateOverEpilogue(Loop *L, LoopInfo *LI, ScalarEvolution &SE,
+                                   AssumptionCache &AC, TargetLibraryInfo *TLI,
+                                   DominatorTree *DT,
+                                   const LoopAccessInfo *LAI) const;
+
+  /// Query the target whether lowering of the llvm.get.active.lane.mask
+  /// intrinsic is supported.
+  bool emitGetActiveLaneMask() const;
+
+  // Parameters that control the loop peeling transformation
+  struct PeelingPreferences {
+    /// A forced peeling factor (the number of bodied of the original loop
+    /// that should be peeled off before the loop body). When set to 0, the
+    /// a peeling factor based on profile information and other factors.
+    unsigned PeelCount;
+    /// Allow peeling off loop iterations.
+    bool AllowPeeling;
+    /// Allow peeling off loop iterations for loop nests.
+    bool AllowLoopNestsPeeling;
+    /// Allow peeling basing on profile. Uses to enable peeling off all
+    /// iterations basing on provided profile.
+    /// If the value is true the peeling cost model can decide to peel only
+    /// some iterations and in this case it will set this to false.
+    bool PeelProfiledIterations;
+  };
+
+  /// Get target-customized preferences for the generic loop peeling
+  /// transformation. The caller will initialize \p PP with the current
+  /// target-independent defaults with information from \p L and \p SE.
+  void getPeelingPreferences(Loop *L, ScalarEvolution &SE,
+                             PeelingPreferences &PP) const;
+
+  /// Targets can implement their own combinations for target-specific
+  /// intrinsics. This function will be called from the InstCombine pass every
+  /// time a target-specific intrinsic is encountered.
+  ///
+  /// \returns None to not do anything target specific or a value that will be
+  /// returned from the InstCombiner. It is possible to return null and stop
+  /// further processing of the intrinsic by returning nullptr.
+  Optional<Instruction *> instCombineIntrinsic(InstCombiner &IC,
+                                               IntrinsicInst &II) const;
+  /// Can be used to implement target-specific instruction combining.
+  /// \see instCombineIntrinsic
+  Optional<Value *>
+  simplifyDemandedUseBitsIntrinsic(InstCombiner &IC, IntrinsicInst &II,
+                                   APInt DemandedMask, KnownBits &Known,
+                                   bool &KnownBitsComputed) const;
+  /// Can be used to implement target-specific instruction combining.
+  /// \see instCombineIntrinsic
+  Optional<Value *> simplifyDemandedVectorEltsIntrinsic(
+      InstCombiner &IC, IntrinsicInst &II, APInt DemandedElts, APInt &UndefElts,
+      APInt &UndefElts2, APInt &UndefElts3,
+      std::function<void(Instruction *, unsigned, APInt, APInt &)>
+          SimplifyAndSetOp) const;
   /// @}
 
   /// \name Scalar Target Information
@@ -524,6 +616,14 @@
   bool isLSRCostLess(TargetTransformInfo::LSRCost &C1,
                      TargetTransformInfo::LSRCost &C2) const;
 
+  /// Return true if LSR major cost is number of registers. Targets which
+  /// implement their own isLSRCostLess and unset number of registers as major
+  /// cost should return false, otherwise return true.
+  bool isNumRegsMajorCostOfLSR() const;
+
+  /// \returns true if LSR should not optimize a chain that includes \p I.
+  bool isProfitableLSRChainElement(Instruction *I) const;
+
   /// Return true if the target can fuse a compare and branch.
   /// Loop-strength-reduction (LSR) uses that knowledge to adjust its cost
   /// calculation for the instructions in a loop.
@@ -543,20 +643,20 @@
   /// modes that operate across loop iterations.
   bool shouldFavorBackedgeIndex(const Loop *L) const;
 
-  /// Return true if the target supports masked load.
-  bool isLegalMaskedStore(Type *DataType) const;
   /// Return true if the target supports masked store.
-  bool isLegalMaskedLoad(Type *DataType) const;
+  bool isLegalMaskedStore(Type *DataType, Align Alignment) const;
+  /// Return true if the target supports masked load.
+  bool isLegalMaskedLoad(Type *DataType, Align Alignment) const;
 
   /// Return true if the target supports nontemporal store.
-  bool isLegalNTStore(Type *DataType, unsigned Alignment) const;
+  bool isLegalNTStore(Type *DataType, Align Alignment) const;
   /// Return true if the target supports nontemporal load.
-  bool isLegalNTLoad(Type *DataType, unsigned Alignment) const;
+  bool isLegalNTLoad(Type *DataType, Align Alignment) const;
 
   /// Return true if the target supports masked scatter.
-  bool isLegalMaskedScatter(Type *DataType) const;
+  bool isLegalMaskedScatter(Type *DataType, Align Alignment) const;
   /// Return true if the target supports masked gather.
-  bool isLegalMaskedGather(Type *DataType) const;
+  bool isLegalMaskedGather(Type *DataType, Align Alignment) const;
 
   /// Return true if the target supports masked compress store.
   bool isLegalMaskedCompressStore(Type *DataType) const;
@@ -610,11 +710,8 @@
   /// Return true if this type is legal.
   bool isTypeLegal(Type *Ty) const;
 
-  /// Returns the target's jmp_buf alignment in bytes.
-  unsigned getJumpBufAlignment() const;
-
-  /// Returns the target's jmp_buf size in bytes.
-  unsigned getJumpBufSize() const;
+  /// Returns the estimated number of registers required to represent \p Ty.
+  unsigned getRegUsageForType(Type *Ty) const;
 
   /// Return true if switches should be turned into lookup tables for the
   /// target.
@@ -628,8 +725,15 @@
   ///  should use coldcc calling convention.
   bool useColdCCForColdCall(Function &F) const;
 
-  unsigned getScalarizationOverhead(Type *Ty, bool Insert, bool Extract) const;
+  /// Estimate the overhead of scalarizing an instruction. Insert and Extract
+  /// are set if the demanded result elements need to be inserted and/or
+  /// extracted from vectors.
+  unsigned getScalarizationOverhead(VectorType *Ty, const APInt &DemandedElts,
+                                    bool Insert, bool Extract) const;
 
+  /// Estimate the overhead of scalarizing an instructions unique
+  /// non-constant operands. The types of the arguments are ordinarily
+  /// scalar, in which case the costs are multiplied with VF.
   unsigned getOperandsScalarizationOverhead(ArrayRef<const Value *> Args,
                                             unsigned VF) const;
 
@@ -689,8 +793,8 @@
   bool isFPVectorizationPotentiallyUnsafe() const;
 
   /// Determine if the target supports unaligned memory accesses.
-  bool allowsMisalignedMemoryAccesses(LLVMContext &Context,
-                                      unsigned BitWidth, unsigned AddressSpace = 0,
+  bool allowsMisalignedMemoryAccesses(LLVMContext &Context, unsigned BitWidth,
+                                      unsigned AddressSpace = 0,
                                       unsigned Alignment = 1,
                                       bool *Fast = nullptr) const;
 
@@ -712,15 +816,16 @@
 
   /// Return the expected cost of materializing for the given integer
   /// immediate of the specified type.
-  int getIntImmCost(const APInt &Imm, Type *Ty) const;
+  int getIntImmCost(const APInt &Imm, Type *Ty, TargetCostKind CostKind) const;
 
   /// Return the expected cost of materialization for the given integer
   /// immediate of the specified type for a given instruction. The cost can be
   /// zero if the immediate can be folded into the specified instruction.
-  int getIntImmCost(unsigned Opc, unsigned Idx, const APInt &Imm,
-                    Type *Ty) const;
-  int getIntImmCost(Intrinsic::ID IID, unsigned Idx, const APInt &Imm,
-                    Type *Ty) const;
+  int getIntImmCostInst(unsigned Opc, unsigned Idx, const APInt &Imm, Type *Ty,
+                        TargetCostKind CostKind,
+                        Instruction *Inst = nullptr) const;
+  int getIntImmCostIntrin(Intrinsic::ID IID, unsigned Idx, const APInt &Imm,
+                          Type *Ty, TargetCostKind CostKind) const;
 
   /// Return the expected cost for the given integer when optimising
   /// for size. This is different than the other integer immediate cost
@@ -738,20 +843,54 @@
 
   /// The various kinds of shuffle patterns for vector queries.
   enum ShuffleKind {
-    SK_Broadcast,       ///< Broadcast element 0 to all other elements.
-    SK_Reverse,         ///< Reverse the order of the vector.
-    SK_Select,          ///< Selects elements from the corresponding lane of
-                        ///< either source operand. This is equivalent to a
-                        ///< vector select with a constant condition operand.
-    SK_Transpose,       ///< Transpose two vectors.
-    SK_InsertSubvector, ///< InsertSubvector. Index indicates start offset.
-    SK_ExtractSubvector,///< ExtractSubvector Index indicates start offset.
-    SK_PermuteTwoSrc,   ///< Merge elements from two source vectors into one
-                        ///< with any shuffle mask.
-    SK_PermuteSingleSrc ///< Shuffle elements of single source vector with any
-                        ///< shuffle mask.
+    SK_Broadcast,        ///< Broadcast element 0 to all other elements.
+    SK_Reverse,          ///< Reverse the order of the vector.
+    SK_Select,           ///< Selects elements from the corresponding lane of
+                         ///< either source operand. This is equivalent to a
+                         ///< vector select with a constant condition operand.
+    SK_Transpose,        ///< Transpose two vectors.
+    SK_InsertSubvector,  ///< InsertSubvector. Index indicates start offset.
+    SK_ExtractSubvector, ///< ExtractSubvector Index indicates start offset.
+    SK_PermuteTwoSrc,    ///< Merge elements from two source vectors into one
+                         ///< with any shuffle mask.
+    SK_PermuteSingleSrc  ///< Shuffle elements of single source vector with any
+                         ///< shuffle mask.
   };
 
+  /// Kind of the reduction data.
+  enum ReductionKind {
+    RK_None,           /// Not a reduction.
+    RK_Arithmetic,     /// Binary reduction data.
+    RK_MinMax,         /// Min/max reduction data.
+    RK_UnsignedMinMax, /// Unsigned min/max reduction data.
+  };
+
+  /// Contains opcode + LHS/RHS parts of the reduction operations.
+  struct ReductionData {
+    ReductionData() = delete;
+    ReductionData(ReductionKind Kind, unsigned Opcode, Value *LHS, Value *RHS)
+        : Opcode(Opcode), LHS(LHS), RHS(RHS), Kind(Kind) {
+      assert(Kind != RK_None && "expected binary or min/max reduction only.");
+    }
+    unsigned Opcode = 0;
+    Value *LHS = nullptr;
+    Value *RHS = nullptr;
+    ReductionKind Kind = RK_None;
+    bool hasSameData(ReductionData &RD) const {
+      return Kind == RD.Kind && Opcode == RD.Opcode;
+    }
+  };
+
+  static ReductionKind matchPairwiseReduction(
+    const ExtractElementInst *ReduxRoot, unsigned &Opcode, VectorType *&Ty);
+
+  static ReductionKind matchVectorSplittingReduction(
+    const ExtractElementInst *ReduxRoot, unsigned &Opcode, VectorType *&Ty);
+
+  static ReductionKind matchVectorReduction(const ExtractElementInst *ReduxRoot,
+                                            unsigned &Opcode, VectorType *&Ty,
+                                            bool &IsPairwise);
+
   /// Additional information about an operand's possible values.
   enum OperandValueKind {
     OK_AnyValue,               // Operand can have any value.
@@ -763,10 +902,24 @@
   /// Additional properties of an operand's values.
   enum OperandValueProperties { OP_None = 0, OP_PowerOf2 = 1 };
 
-  /// \return The number of scalar or vector registers that the target has.
-  /// If 'Vectors' is true, it returns the number of vector registers. If it is
-  /// set to false, it returns the number of scalar registers.
-  unsigned getNumberOfRegisters(bool Vector) const;
+  /// \return the number of registers in the target-provided register class.
+  unsigned getNumberOfRegisters(unsigned ClassID) const;
+
+  /// \return the target-provided register class ID for the provided type,
+  /// accounting for type promotion and other type-legalization techniques that
+  /// the target might apply. However, it specifically does not account for the
+  /// scalarization or splitting of vector types. Should a vector type require
+  /// scalarization or splitting into multiple underlying vector registers, that
+  /// type should be mapped to a register class containing no registers.
+  /// Specifically, this is designed to provide a simple, high-level view of the
+  /// register allocation later performed by the backend. These register classes
+  /// don't necessarily map onto the register classes used by the backend.
+  /// FIXME: It's not currently possible to determine how many registers
+  /// are used by the provided type.
+  unsigned getRegisterClassForType(bool Vector, Type *Ty = nullptr) const;
+
+  /// \return the target-provided register class name
+  const char *getRegisterClassName(unsigned ClassID) const;
 
   /// \return The width of the largest scalar or vector register type.
   unsigned getRegisterBitWidth(bool Vector) const;
@@ -774,6 +927,10 @@
   /// \return The width of the smallest vector register type.
   unsigned getMinVectorRegisterBitWidth() const;
 
+  /// \return The maximum value of vscale if the target specifies an
+  ///  architectural maximum vector length, and None otherwise.
+  Optional<unsigned> getMaxVScale() const;
+
   /// \return True if the vectorization factor should be chosen to
   /// make the vector of the smallest element type match the size of a
   /// vector register. For wider element types, this could result in
@@ -787,6 +944,11 @@
   /// applies when shouldMaximizeVectorBandwidth returns true.
   unsigned getMinimumVF(unsigned ElemWidth) const;
 
+  /// \return The maximum vectorization factor for types of given element
+  /// bit width and opcode, or 0 if there is no maximum VF.
+  /// Currently only used by the SLP vectorizer.
+  unsigned getMaximumVF(unsigned ElemWidth, unsigned Opcode) const;
+
   /// \return True if it should be considered for address type promotion.
   /// \p AllowPromotionWithoutCommonHeader Set true if promoting \p I is
   /// profitable without finding other extensions fed by the same input.
@@ -798,8 +960,8 @@
 
   /// The possible cache levels
   enum class CacheLevel {
-    L1D,   // The L1 data cache
-    L2D,   // The L2 data cache
+    L1D, // The L1 data cache
+    L2D, // The L2 data cache
 
     // We currently do not model L3 caches, as their sizes differ widely between
     // microarchitectures. Also, we currently do not have a use for L3 cache
@@ -807,32 +969,52 @@
   };
 
   /// \return The size of the cache level in bytes, if available.
-  llvm::Optional<unsigned> getCacheSize(CacheLevel Level) const;
+  Optional<unsigned> getCacheSize(CacheLevel Level) const;
 
   /// \return The associativity of the cache level, if available.
-  llvm::Optional<unsigned> getCacheAssociativity(CacheLevel Level) const;
+  Optional<unsigned> getCacheAssociativity(CacheLevel Level) const;
 
-  /// \return How much before a load we should place the prefetch instruction.
-  /// This is currently measured in number of instructions.
+  /// \return How much before a load we should place the prefetch
+  /// instruction.  This is currently measured in number of
+  /// instructions.
   unsigned getPrefetchDistance() const;
 
-  /// \return Some HW prefetchers can handle accesses up to a certain constant
-  /// stride.  This is the minimum stride in bytes where it makes sense to start
-  /// adding SW prefetches.  The default is 1, i.e. prefetch with any stride.
-  unsigned getMinPrefetchStride() const;
+  /// Some HW prefetchers can handle accesses up to a certain constant stride.
+  /// Sometimes prefetching is beneficial even below the HW prefetcher limit,
+  /// and the arguments provided are meant to serve as a basis for deciding this
+  /// for a particular loop.
+  ///
+  /// \param NumMemAccesses        Number of memory accesses in the loop.
+  /// \param NumStridedMemAccesses Number of the memory accesses that
+  ///                              ScalarEvolution could find a known stride
+  ///                              for.
+  /// \param NumPrefetches         Number of software prefetches that will be
+  ///                              emitted as determined by the addresses
+  ///                              involved and the cache line size.
+  /// \param HasCall               True if the loop contains a call.
+  ///
+  /// \return This is the minimum stride in bytes where it makes sense to start
+  ///         adding SW prefetches. The default is 1, i.e. prefetch with any
+  ///         stride.
+  unsigned getMinPrefetchStride(unsigned NumMemAccesses,
+                                unsigned NumStridedMemAccesses,
+                                unsigned NumPrefetches, bool HasCall) const;
 
-  /// \return The maximum number of iterations to prefetch ahead.  If the
-  /// required number of iterations is more than this number, no prefetching is
-  /// performed.
+  /// \return The maximum number of iterations to prefetch ahead.  If
+  /// the required number of iterations is more than this number, no
+  /// prefetching is performed.
   unsigned getMaxPrefetchIterationsAhead() const;
 
+  /// \return True if prefetching should also be done for writes.
+  bool enableWritePrefetching() const;
+
   /// \return The maximum interleave factor that any transform should try to
   /// perform for this target. This number depends on the level of parallelism
   /// and the number of execution units in the CPU.
   unsigned getMaxInterleaveFactor(unsigned VF) const;
 
   /// Collect properties of V used in cost analysis, e.g. OP_PowerOf2.
-  static OperandValueKind getOperandInfo(Value *V,
+  static OperandValueKind getOperandInfo(const Value *V,
                                          OperandValueProperties &OpProps);
 
   /// This is an approximation of reciprocal throughput of a math/logic op.
@@ -849,25 +1031,68 @@
   /// \p Args is an optional argument which holds the instruction operands
   /// values so the TTI can analyze those values searching for special
   /// cases or optimizations based on those values.
+  /// \p CxtI is the optional original context instruction, if one exists, to
+  /// provide even more information.
   int getArithmeticInstrCost(
-      unsigned Opcode, Type *Ty, OperandValueKind Opd1Info = OK_AnyValue,
+      unsigned Opcode, Type *Ty,
+      TTI::TargetCostKind CostKind = TTI::TCK_RecipThroughput,
+      OperandValueKind Opd1Info = OK_AnyValue,
       OperandValueKind Opd2Info = OK_AnyValue,
       OperandValueProperties Opd1PropInfo = OP_None,
       OperandValueProperties Opd2PropInfo = OP_None,
-      ArrayRef<const Value *> Args = ArrayRef<const Value *>()) const;
+      ArrayRef<const Value *> Args = ArrayRef<const Value *>(),
+      const Instruction *CxtI = nullptr) const;
 
   /// \return The cost of a shuffle instruction of kind Kind and of type Tp.
   /// The index and subtype parameters are used by the subvector insertion and
   /// extraction shuffle kinds to show the insert/extract point and the type of
   /// the subvector being inserted/extracted.
   /// NOTE: For subvector extractions Tp represents the source type.
-  int getShuffleCost(ShuffleKind Kind, Type *Tp, int Index = 0,
-                     Type *SubTp = nullptr) const;
+  int getShuffleCost(ShuffleKind Kind, VectorType *Tp, int Index = 0,
+                     VectorType *SubTp = nullptr) const;
+
+  /// Represents a hint about the context in which a cast is used.
+  ///
+  /// For zext/sext, the context of the cast is the operand, which must be a
+  /// load of some kind. For trunc, the context is of the cast is the single
+  /// user of the instruction, which must be a store of some kind.
+  ///
+  /// This enum allows the vectorizer to give getCastInstrCost an idea of the
+  /// type of cast it's dealing with, as not every cast is equal. For instance,
+  /// the zext of a load may be free, but the zext of an interleaving load can
+  //// be (very) expensive!
+  ///
+  /// See \c getCastContextHint to compute a CastContextHint from a cast
+  /// Instruction*. Callers can use it if they don't need to override the
+  /// context and just want it to be calculated from the instruction.
+  ///
+  /// FIXME: This handles the types of load/store that the vectorizer can
+  /// produce, which are the cases where the context instruction is most
+  /// likely to be incorrect. There are other situations where that can happen
+  /// too, which might be handled here but in the long run a more general
+  /// solution of costing multiple instructions at the same times may be better.
+  enum class CastContextHint : uint8_t {
+    None,          ///< The cast is not used with a load/store of any kind.
+    Normal,        ///< The cast is used with a normal load/store.
+    Masked,        ///< The cast is used with a masked load/store.
+    GatherScatter, ///< The cast is used with a gather/scatter.
+    Interleave,    ///< The cast is used with an interleaved load/store.
+    Reversed,      ///< The cast is used with a reversed load/store.
+  };
+
+  /// Calculates a CastContextHint from \p I.
+  /// This should be used by callers of getCastInstrCost if they wish to
+  /// determine the context from some instruction.
+  /// \returns the CastContextHint for ZExt/SExt/Trunc, None if \p I is nullptr,
+  /// or if it's another type of cast.
+  static CastContextHint getCastContextHint(const Instruction *I);
 
   /// \return The expected cost of cast instructions, such as bitcast, trunc,
   /// zext, etc. If there is an existing instruction that holds Opcode, it
   /// may be passed in the 'I' parameter.
   int getCastInstrCost(unsigned Opcode, Type *Dst, Type *Src,
+                       TTI::CastContextHint CCH,
+                       TTI::TargetCostKind CostKind = TTI::TCK_SizeAndLatency,
                        const Instruction *I = nullptr) const;
 
   /// \return The expected cost of a sign- or zero-extended vector extract. Use
@@ -877,25 +1102,34 @@
 
   /// \return The expected cost of control-flow related instructions such as
   /// Phi, Ret, Br.
-  int getCFInstrCost(unsigned Opcode) const;
+  int getCFInstrCost(unsigned Opcode,
+                     TTI::TargetCostKind CostKind = TTI::TCK_SizeAndLatency) const;
 
   /// \returns The expected cost of compare and select instructions. If there
   /// is an existing instruction that holds Opcode, it may be passed in the
-  /// 'I' parameter.
-  int getCmpSelInstrCost(unsigned Opcode, Type *ValTy,
-                 Type *CondTy = nullptr, const Instruction *I = nullptr) const;
+  /// 'I' parameter. The \p VecPred parameter can be used to indicate the select
+  /// is using a compare with the specified predicate as condition. When vector
+  /// types are passed, \p VecPred must be used for all lanes.
+  int getCmpSelInstrCost(
+      unsigned Opcode, Type *ValTy, Type *CondTy = nullptr,
+      CmpInst::Predicate VecPred = CmpInst::BAD_ICMP_PREDICATE,
+      TTI::TargetCostKind CostKind = TTI::TCK_RecipThroughput,
+      const Instruction *I = nullptr) const;
 
   /// \return The expected cost of vector Insert and Extract.
   /// Use -1 to indicate that there is no information on the index value.
   int getVectorInstrCost(unsigned Opcode, Type *Val, unsigned Index = -1) const;
 
   /// \return The cost of Load and Store instructions.
-  int getMemoryOpCost(unsigned Opcode, Type *Src, unsigned Alignment,
-                      unsigned AddressSpace, const Instruction *I = nullptr) const;
+  int getMemoryOpCost(unsigned Opcode, Type *Src, Align Alignment,
+                      unsigned AddressSpace,
+                      TTI::TargetCostKind CostKind = TTI::TCK_RecipThroughput,
+                      const Instruction *I = nullptr) const;
 
   /// \return The cost of masked Load and Store instructions.
-  int getMaskedMemoryOpCost(unsigned Opcode, Type *Src, unsigned Alignment,
-                            unsigned AddressSpace) const;
+  int getMaskedMemoryOpCost(
+      unsigned Opcode, Type *Src, Align Alignment, unsigned AddressSpace,
+      TTI::TargetCostKind CostKind = TTI::TCK_RecipThroughput) const;
 
   /// \return The cost of Gather or Scatter operation
   /// \p Opcode - is a type of memory access Load or Store
@@ -904,8 +1138,12 @@
   /// \p VariableMask - true when the memory access is predicated with a mask
   ///                   that is not a compile-time constant
   /// \p Alignment - alignment of single element
-  int getGatherScatterOpCost(unsigned Opcode, Type *DataTy, Value *Ptr,
-                             bool VariableMask, unsigned Alignment) const;
+  /// \p I - the optional original context instruction, if one exists, e.g. the
+  ///        load/store to transform or the call to the gather/scatter intrinsic
+  int getGatherScatterOpCost(
+      unsigned Opcode, Type *DataTy, const Value *Ptr, bool VariableMask,
+      Align Alignment, TTI::TargetCostKind CostKind = TTI::TCK_RecipThroughput,
+      const Instruction *I = nullptr) const;
 
   /// \return The cost of the interleaved memory operation.
   /// \p Opcode is the memory operation code
@@ -917,11 +1155,11 @@
   /// \p AddressSpace is address space of the pointer.
   /// \p UseMaskForCond indicates if the memory access is predicated.
   /// \p UseMaskForGaps indicates if gaps should be masked.
-  int getInterleavedMemoryOpCost(unsigned Opcode, Type *VecTy, unsigned Factor,
-                                 ArrayRef<unsigned> Indices, unsigned Alignment,
-                                 unsigned AddressSpace,
-                                 bool UseMaskForCond = false,
-                                 bool UseMaskForGaps = false) const;
+  int getInterleavedMemoryOpCost(
+      unsigned Opcode, Type *VecTy, unsigned Factor, ArrayRef<unsigned> Indices,
+      Align Alignment, unsigned AddressSpace,
+      TTI::TargetCostKind CostKind = TTI::TCK_RecipThroughput,
+      bool UseMaskForCond = false, bool UseMaskForGaps = false) const;
 
   /// Calculate the cost of performing a vector reduction.
   ///
@@ -936,27 +1174,23 @@
   /// Split:
   ///  (v0, v1, v2, v3)
   ///  ((v0+v2), (v1+v3), undef, undef)
-  int getArithmeticReductionCost(unsigned Opcode, Type *Ty,
-                                 bool IsPairwiseForm) const;
-  int getMinMaxReductionCost(Type *Ty, Type *CondTy, bool IsPairwiseForm,
-                             bool IsUnsigned) const;
+  int getArithmeticReductionCost(
+    unsigned Opcode, VectorType *Ty, bool IsPairwiseForm,
+    TTI::TargetCostKind CostKind = TTI::TCK_RecipThroughput) const;
+
+  int getMinMaxReductionCost(
+    VectorType *Ty, VectorType *CondTy, bool IsPairwiseForm, bool IsUnsigned,
+    TTI::TargetCostKind CostKind = TTI::TCK_RecipThroughput) const;
 
   /// \returns The cost of Intrinsic instructions. Analyses the real arguments.
   /// Three cases are handled: 1. scalar instruction 2. vector instruction
-  /// 3. scalar instruction which is to be vectorized with VF.
-  int getIntrinsicInstrCost(Intrinsic::ID ID, Type *RetTy,
-                            ArrayRef<Value *> Args, FastMathFlags FMF,
-                            unsigned VF = 1) const;
-
-  /// \returns The cost of Intrinsic instructions. Types analysis only.
-  /// If ScalarizationCostPassed is UINT_MAX, the cost of scalarizing the
-  /// arguments and the return value will be computed based on types.
-  int getIntrinsicInstrCost(Intrinsic::ID ID, Type *RetTy,
-                            ArrayRef<Type *> Tys, FastMathFlags FMF,
-                            unsigned ScalarizationCostPassed = UINT_MAX) const;
+  /// 3. scalar instruction which is to be vectorized.
+  int getIntrinsicInstrCost(const IntrinsicCostAttributes &ICA,
+                            TTI::TargetCostKind CostKind) const;
 
   /// \returns The cost of Call instructions.
-  int getCallInstrCost(Function *F, Type *RetTy, ArrayRef<Type *> Tys) const;
+  int getCallInstrCost(Function *F, Type *RetTy, ArrayRef<Type *> Tys,
+                 TTI::TargetCostKind CostKind = TTI::TCK_SizeAndLatency) const;
 
   /// \returns The number of pieces into which the provided type must be
   /// split during legalization. Zero is returned when the answer is unknown.
@@ -998,6 +1232,7 @@
 
   /// \returns The type to use in a loop expansion of a memcpy call.
   Type *getMemcpyLoopLoweringType(LLVMContext &Context, Value *Length,
+                                  unsigned SrcAddrSpace, unsigned DestAddrSpace,
                                   unsigned SrcAlign, unsigned DestAlign) const;
 
   /// \param[out] OpsOut The operand types to copy RemainingBytes of memory.
@@ -1006,11 +1241,10 @@
   /// Calculates the operand types to use when copying \p RemainingBytes of
   /// memory, where source and destination alignments are \p SrcAlign and
   /// \p DestAlign respectively.
-  void getMemcpyLoopResidualLoweringType(SmallVectorImpl<Type *> &OpsOut,
-                                         LLVMContext &Context,
-                                         unsigned RemainingBytes,
-                                         unsigned SrcAlign,
-                                         unsigned DestAlign) const;
+  void getMemcpyLoopResidualLoweringType(
+      SmallVectorImpl<Type *> &OpsOut, LLVMContext &Context,
+      unsigned RemainingBytes, unsigned SrcAddrSpace, unsigned DestAddrSpace,
+      unsigned SrcAlign, unsigned DestAlign) const;
 
   /// \returns True if the two functions have compatible attributes for inlining
   /// purposes.
@@ -1027,11 +1261,11 @@
 
   /// The type of load/store indexing.
   enum MemIndexedMode {
-    MIM_Unindexed,  ///< No indexing.
-    MIM_PreInc,     ///< Pre-incrementing.
-    MIM_PreDec,     ///< Pre-decrementing.
-    MIM_PostInc,    ///< Post-incrementing.
-    MIM_PostDec     ///< Post-decrementing.
+    MIM_Unindexed, ///< No indexing.
+    MIM_PreInc,    ///< Pre-incrementing.
+    MIM_PreDec,    ///< Pre-decrementing.
+    MIM_PostInc,   ///< Post-incrementing.
+    MIM_PostDec    ///< Post-decrementing.
   };
 
   /// \returns True if the specified indexed load for the given type is legal.
@@ -1051,13 +1285,11 @@
   bool isLegalToVectorizeStore(StoreInst *SI) const;
 
   /// \returns True if it is legal to vectorize the given load chain.
-  bool isLegalToVectorizeLoadChain(unsigned ChainSizeInBytes,
-                                   unsigned Alignment,
+  bool isLegalToVectorizeLoadChain(unsigned ChainSizeInBytes, Align Alignment,
                                    unsigned AddrSpace) const;
 
   /// \returns True if it is legal to vectorize the given store chain.
-  bool isLegalToVectorizeStoreChain(unsigned ChainSizeInBytes,
-                                    unsigned Alignment,
+  bool isLegalToVectorizeStoreChain(unsigned ChainSizeInBytes, Align Alignment,
                                     unsigned AddrSpace) const;
 
   /// \returns The new vector factor value if the target doesn't support \p
@@ -1085,6 +1317,24 @@
   bool useReductionIntrinsic(unsigned Opcode, Type *Ty,
                              ReductionFlags Flags) const;
 
+  /// \returns True if the target prefers reductions in loop.
+  bool preferInLoopReduction(unsigned Opcode, Type *Ty,
+                             ReductionFlags Flags) const;
+
+  /// \returns True if the target prefers reductions select kept in the loop
+  /// when tail folding. i.e.
+  /// loop:
+  ///   p = phi (0, s)
+  ///   a = add (p, x)
+  ///   s = select (mask, a, p)
+  /// vecreduce.add(s)
+  ///
+  /// As opposed to the normal scheme of p = phi (0, a) which allows the select
+  /// to be pulled out of the loop. If the select(.., add, ..) can be predicated
+  /// by the target, this can lead to cleaner code generation.
+  bool preferPredicatedReductionSelect(unsigned Opcode, Type *Ty,
+                                       ReductionFlags Flags) const;
+
   /// \returns True if the target wants to expand the given reduction intrinsic
   /// into a shuffle sequence.
   bool shouldExpandReduction(const IntrinsicInst *II) const;
@@ -1093,6 +1343,18 @@
   /// to a stack reload.
   unsigned getGISelRematGlobalCost() const;
 
+  /// \returns True if the target supports scalable vectors.
+  bool supportsScalableVectors() const;
+
+  /// \name Vector Predication Information
+  /// @{
+  /// Whether the target supports the %evl parameter of VP intrinsic efficiently
+  /// in hardware. (see LLVM Language Reference - "Vector Predication
+  /// Intrinsics") Use of %evl is discouraged when that is not the case.
+  bool hasActiveVectorLength() const;
+
+  /// @}
+
   /// @}
 
 private:
@@ -1119,57 +1381,77 @@
 public:
   virtual ~Concept() = 0;
   virtual const DataLayout &getDataLayout() const = 0;
-  virtual int getOperationCost(unsigned Opcode, Type *Ty, Type *OpTy) = 0;
   virtual int getGEPCost(Type *PointeeType, const Value *Ptr,
-                         ArrayRef<const Value *> Operands) = 0;
-  virtual int getExtCost(const Instruction *I, const Value *Src) = 0;
-  virtual int getCallCost(FunctionType *FTy, int NumArgs, const User *U) = 0;
-  virtual int getCallCost(const Function *F, int NumArgs, const User *U) = 0;
-  virtual int getCallCost(const Function *F,
-                          ArrayRef<const Value *> Arguments, const User *U) = 0;
+                         ArrayRef<const Value *> Operands,
+                         TTI::TargetCostKind CostKind) = 0;
   virtual unsigned getInliningThresholdMultiplier() = 0;
-  virtual int getIntrinsicCost(Intrinsic::ID IID, Type *RetTy,
-                               ArrayRef<Type *> ParamTys, const User *U) = 0;
-  virtual int getIntrinsicCost(Intrinsic::ID IID, Type *RetTy,
-                               ArrayRef<const Value *> Arguments,
-                               const User *U) = 0;
+  virtual int getInlinerVectorBonusPercent() = 0;
   virtual int getMemcpyCost(const Instruction *I) = 0;
-  virtual unsigned getEstimatedNumberOfCaseClusters(const SwitchInst &SI,
-                                                    unsigned &JTSize) = 0;
-  virtual int
-  getUserCost(const User *U, ArrayRef<const Value *> Operands) = 0;
+  virtual unsigned
+  getEstimatedNumberOfCaseClusters(const SwitchInst &SI, unsigned &JTSize,
+                                   ProfileSummaryInfo *PSI,
+                                   BlockFrequencyInfo *BFI) = 0;
+  virtual int getUserCost(const User *U, ArrayRef<const Value *> Operands,
+                          TargetCostKind CostKind) = 0;
   virtual bool hasBranchDivergence() = 0;
+  virtual bool useGPUDivergenceAnalysis() = 0;
   virtual bool isSourceOfDivergence(const Value *V) = 0;
   virtual bool isAlwaysUniform(const Value *V) = 0;
   virtual unsigned getFlatAddressSpace() = 0;
+  virtual bool collectFlatAddressOperands(SmallVectorImpl<int> &OpIndexes,
+                                          Intrinsic::ID IID) const = 0;
+  virtual bool isNoopAddrSpaceCast(unsigned FromAS, unsigned ToAS) const = 0;
+  virtual unsigned getAssumedAddrSpace(const Value *V) const = 0;
+  virtual Value *rewriteIntrinsicWithAddressSpace(IntrinsicInst *II,
+                                                  Value *OldV,
+                                                  Value *NewV) const = 0;
   virtual bool isLoweredToCall(const Function *F) = 0;
   virtual void getUnrollingPreferences(Loop *L, ScalarEvolution &,
                                        UnrollingPreferences &UP) = 0;
+  virtual void getPeelingPreferences(Loop *L, ScalarEvolution &SE,
+                                     PeelingPreferences &PP) = 0;
   virtual bool isHardwareLoopProfitable(Loop *L, ScalarEvolution &SE,
                                         AssumptionCache &AC,
                                         TargetLibraryInfo *LibInfo,
                                         HardwareLoopInfo &HWLoopInfo) = 0;
+  virtual bool
+  preferPredicateOverEpilogue(Loop *L, LoopInfo *LI, ScalarEvolution &SE,
+                              AssumptionCache &AC, TargetLibraryInfo *TLI,
+                              DominatorTree *DT, const LoopAccessInfo *LAI) = 0;
+  virtual bool emitGetActiveLaneMask() = 0;
+  virtual Optional<Instruction *> instCombineIntrinsic(InstCombiner &IC,
+                                                       IntrinsicInst &II) = 0;
+  virtual Optional<Value *>
+  simplifyDemandedUseBitsIntrinsic(InstCombiner &IC, IntrinsicInst &II,
+                                   APInt DemandedMask, KnownBits &Known,
+                                   bool &KnownBitsComputed) = 0;
+  virtual Optional<Value *> simplifyDemandedVectorEltsIntrinsic(
+      InstCombiner &IC, IntrinsicInst &II, APInt DemandedElts, APInt &UndefElts,
+      APInt &UndefElts2, APInt &UndefElts3,
+      std::function<void(Instruction *, unsigned, APInt, APInt &)>
+          SimplifyAndSetOp) = 0;
   virtual bool isLegalAddImmediate(int64_t Imm) = 0;
   virtual bool isLegalICmpImmediate(int64_t Imm) = 0;
   virtual bool isLegalAddressingMode(Type *Ty, GlobalValue *BaseGV,
                                      int64_t BaseOffset, bool HasBaseReg,
-                                     int64_t Scale,
-                                     unsigned AddrSpace,
+                                     int64_t Scale, unsigned AddrSpace,
                                      Instruction *I) = 0;
   virtual bool isLSRCostLess(TargetTransformInfo::LSRCost &C1,
                              TargetTransformInfo::LSRCost &C2) = 0;
+  virtual bool isNumRegsMajorCostOfLSR() = 0;
+  virtual bool isProfitableLSRChainElement(Instruction *I) = 0;
   virtual bool canMacroFuseCmp() = 0;
   virtual bool canSaveCmp(Loop *L, BranchInst **BI, ScalarEvolution *SE,
                           LoopInfo *LI, DominatorTree *DT, AssumptionCache *AC,
                           TargetLibraryInfo *LibInfo) = 0;
   virtual bool shouldFavorPostInc() const = 0;
   virtual bool shouldFavorBackedgeIndex(const Loop *L) const = 0;
-  virtual bool isLegalMaskedStore(Type *DataType) = 0;
-  virtual bool isLegalMaskedLoad(Type *DataType) = 0;
-  virtual bool isLegalNTStore(Type *DataType, unsigned Alignment) = 0;
-  virtual bool isLegalNTLoad(Type *DataType, unsigned Alignment) = 0;
-  virtual bool isLegalMaskedScatter(Type *DataType) = 0;
-  virtual bool isLegalMaskedGather(Type *DataType) = 0;
+  virtual bool isLegalMaskedStore(Type *DataType, Align Alignment) = 0;
+  virtual bool isLegalMaskedLoad(Type *DataType, Align Alignment) = 0;
+  virtual bool isLegalNTStore(Type *DataType, Align Alignment) = 0;
+  virtual bool isLegalNTLoad(Type *DataType, Align Alignment) = 0;
+  virtual bool isLegalMaskedScatter(Type *DataType, Align Alignment) = 0;
+  virtual bool isLegalMaskedGather(Type *DataType, Align Alignment) = 0;
   virtual bool isLegalMaskedCompressStore(Type *DataType) = 0;
   virtual bool isLegalMaskedExpandLoad(Type *DataType) = 0;
   virtual bool hasDivRemOp(Type *DataType, bool IsSigned) = 0;
@@ -1183,15 +1465,16 @@
   virtual bool isProfitableToHoist(Instruction *I) = 0;
   virtual bool useAA() = 0;
   virtual bool isTypeLegal(Type *Ty) = 0;
-  virtual unsigned getJumpBufAlignment() = 0;
-  virtual unsigned getJumpBufSize() = 0;
+  virtual unsigned getRegUsageForType(Type *Ty) = 0;
   virtual bool shouldBuildLookupTables() = 0;
   virtual bool shouldBuildLookupTablesForConstant(Constant *C) = 0;
   virtual bool useColdCCForColdCall(Function &F) = 0;
+  virtual unsigned getScalarizationOverhead(VectorType *Ty,
+                                            const APInt &DemandedElts,
+                                            bool Insert, bool Extract) = 0;
   virtual unsigned
-  getScalarizationOverhead(Type *Ty, bool Insert, bool Extract) = 0;
-  virtual unsigned getOperandsScalarizationOverhead(ArrayRef<const Value *> Args,
-                                                    unsigned VF) = 0;
+  getOperandsScalarizationOverhead(ArrayRef<const Value *> Args,
+                                   unsigned VF) = 0;
   virtual bool supportsEfficientVectorElementLoadStore() = 0;
   virtual bool enableAggressiveInterleaving(bool LoopHasReductions) = 0;
   virtual MemCmpExpansionOptions
@@ -1208,70 +1491,108 @@
   virtual bool haveFastSqrt(Type *Ty) = 0;
   virtual bool isFCmpOrdCheaperThanFCmpZero(Type *Ty) = 0;
   virtual int getFPOpCost(Type *Ty) = 0;
-  virtual int getIntImmCodeSizeCost(unsigned Opc, unsigned Idx, const APInt &Imm,
-                                    Type *Ty) = 0;
-  virtual int getIntImmCost(const APInt &Imm, Type *Ty) = 0;
-  virtual int getIntImmCost(unsigned Opc, unsigned Idx, const APInt &Imm,
-                            Type *Ty) = 0;
-  virtual int getIntImmCost(Intrinsic::ID IID, unsigned Idx, const APInt &Imm,
-                            Type *Ty) = 0;
-  virtual unsigned getNumberOfRegisters(bool Vector) = 0;
+  virtual int getIntImmCodeSizeCost(unsigned Opc, unsigned Idx,
+                                    const APInt &Imm, Type *Ty) = 0;
+  virtual int getIntImmCost(const APInt &Imm, Type *Ty,
+                            TargetCostKind CostKind) = 0;
+  virtual int getIntImmCostInst(unsigned Opc, unsigned Idx, const APInt &Imm,
+                                Type *Ty, TargetCostKind CostKind,
+                                Instruction *Inst = nullptr) = 0;
+  virtual int getIntImmCostIntrin(Intrinsic::ID IID, unsigned Idx,
+                                  const APInt &Imm, Type *Ty,
+                                  TargetCostKind CostKind) = 0;
+  virtual unsigned getNumberOfRegisters(unsigned ClassID) const = 0;
+  virtual unsigned getRegisterClassForType(bool Vector,
+                                           Type *Ty = nullptr) const = 0;
+  virtual const char *getRegisterClassName(unsigned ClassID) const = 0;
   virtual unsigned getRegisterBitWidth(bool Vector) const = 0;
   virtual unsigned getMinVectorRegisterBitWidth() = 0;
+  virtual Optional<unsigned> getMaxVScale() const = 0;
   virtual bool shouldMaximizeVectorBandwidth(bool OptSize) const = 0;
   virtual unsigned getMinimumVF(unsigned ElemWidth) const = 0;
+  virtual unsigned getMaximumVF(unsigned ElemWidth, unsigned Opcode) const = 0;
   virtual bool shouldConsiderAddressTypePromotion(
       const Instruction &I, bool &AllowPromotionWithoutCommonHeader) = 0;
-  virtual unsigned getCacheLineSize() = 0;
-  virtual llvm::Optional<unsigned> getCacheSize(CacheLevel Level) = 0;
-  virtual llvm::Optional<unsigned> getCacheAssociativity(CacheLevel Level) = 0;
-  virtual unsigned getPrefetchDistance() = 0;
-  virtual unsigned getMinPrefetchStride() = 0;
-  virtual unsigned getMaxPrefetchIterationsAhead() = 0;
+  virtual unsigned getCacheLineSize() const = 0;
+  virtual Optional<unsigned> getCacheSize(CacheLevel Level) const = 0;
+  virtual Optional<unsigned> getCacheAssociativity(CacheLevel Level) const = 0;
+
+  /// \return How much before a load we should place the prefetch
+  /// instruction.  This is currently measured in number of
+  /// instructions.
+  virtual unsigned getPrefetchDistance() const = 0;
+
+  /// \return Some HW prefetchers can handle accesses up to a certain
+  /// constant stride.  This is the minimum stride in bytes where it
+  /// makes sense to start adding SW prefetches.  The default is 1,
+  /// i.e. prefetch with any stride.  Sometimes prefetching is beneficial
+  /// even below the HW prefetcher limit, and the arguments provided are
+  /// meant to serve as a basis for deciding this for a particular loop.
+  virtual unsigned getMinPrefetchStride(unsigned NumMemAccesses,
+                                        unsigned NumStridedMemAccesses,
+                                        unsigned NumPrefetches,
+                                        bool HasCall) const = 0;
+
+  /// \return The maximum number of iterations to prefetch ahead.  If
+  /// the required number of iterations is more than this number, no
+  /// prefetching is performed.
+  virtual unsigned getMaxPrefetchIterationsAhead() const = 0;
+
+  /// \return True if prefetching should also be done for writes.
+  virtual bool enableWritePrefetching() const = 0;
+
   virtual unsigned getMaxInterleaveFactor(unsigned VF) = 0;
-  virtual unsigned
-  getArithmeticInstrCost(unsigned Opcode, Type *Ty, OperandValueKind Opd1Info,
-                         OperandValueKind Opd2Info,
-                         OperandValueProperties Opd1PropInfo,
-                         OperandValueProperties Opd2PropInfo,
-                         ArrayRef<const Value *> Args) = 0;
-  virtual int getShuffleCost(ShuffleKind Kind, Type *Tp, int Index,
-                             Type *SubTp) = 0;
+  virtual unsigned getArithmeticInstrCost(
+      unsigned Opcode, Type *Ty,
+      TTI::TargetCostKind CostKind,
+      OperandValueKind Opd1Info,
+      OperandValueKind Opd2Info, OperandValueProperties Opd1PropInfo,
+      OperandValueProperties Opd2PropInfo, ArrayRef<const Value *> Args,
+      const Instruction *CxtI = nullptr) = 0;
+  virtual int getShuffleCost(ShuffleKind Kind, VectorType *Tp, int Index,
+                             VectorType *SubTp) = 0;
   virtual int getCastInstrCost(unsigned Opcode, Type *Dst, Type *Src,
+                               CastContextHint CCH,
+                               TTI::TargetCostKind CostKind,
                                const Instruction *I) = 0;
   virtual int getExtractWithExtendCost(unsigned Opcode, Type *Dst,
                                        VectorType *VecTy, unsigned Index) = 0;
-  virtual int getCFInstrCost(unsigned Opcode) = 0;
-  virtual int getCmpSelInstrCost(unsigned Opcode, Type *ValTy,
-                                Type *CondTy, const Instruction *I) = 0;
+  virtual int getCFInstrCost(unsigned Opcode,
+                             TTI::TargetCostKind CostKind) = 0;
+  virtual int getCmpSelInstrCost(unsigned Opcode, Type *ValTy, Type *CondTy,
+                                 CmpInst::Predicate VecPred,
+                                 TTI::TargetCostKind CostKind,
+                                 const Instruction *I) = 0;
   virtual int getVectorInstrCost(unsigned Opcode, Type *Val,
                                  unsigned Index) = 0;
-  virtual int getMemoryOpCost(unsigned Opcode, Type *Src, unsigned Alignment,
-                              unsigned AddressSpace, const Instruction *I) = 0;
-  virtual int getMaskedMemoryOpCost(unsigned Opcode, Type *Src,
-                                    unsigned Alignment,
-                                    unsigned AddressSpace) = 0;
+  virtual int getMemoryOpCost(unsigned Opcode, Type *Src, Align Alignment,
+                              unsigned AddressSpace,
+                              TTI::TargetCostKind CostKind,
+                              const Instruction *I) = 0;
+  virtual int getMaskedMemoryOpCost(unsigned Opcode, Type *Src, Align Alignment,
+                                    unsigned AddressSpace,
+                                    TTI::TargetCostKind CostKind) = 0;
   virtual int getGatherScatterOpCost(unsigned Opcode, Type *DataTy,
-                                     Value *Ptr, bool VariableMask,
-                                     unsigned Alignment) = 0;
-  virtual int getInterleavedMemoryOpCost(unsigned Opcode, Type *VecTy,
-                                         unsigned Factor,
-                                         ArrayRef<unsigned> Indices,
-                                         unsigned Alignment,
-                                         unsigned AddressSpace,
-                                         bool UseMaskForCond = false,
-                                         bool UseMaskForGaps = false) = 0;
-  virtual int getArithmeticReductionCost(unsigned Opcode, Type *Ty,
-                                         bool IsPairwiseForm) = 0;
-  virtual int getMinMaxReductionCost(Type *Ty, Type *CondTy,
-                                     bool IsPairwiseForm, bool IsUnsigned) = 0;
-  virtual int getIntrinsicInstrCost(Intrinsic::ID ID, Type *RetTy,
-                      ArrayRef<Type *> Tys, FastMathFlags FMF,
-                      unsigned ScalarizationCostPassed) = 0;
-  virtual int getIntrinsicInstrCost(Intrinsic::ID ID, Type *RetTy,
-         ArrayRef<Value *> Args, FastMathFlags FMF, unsigned VF) = 0;
+                                     const Value *Ptr, bool VariableMask,
+                                     Align Alignment,
+                                     TTI::TargetCostKind CostKind,
+                                     const Instruction *I = nullptr) = 0;
+
+  virtual int getInterleavedMemoryOpCost(
+      unsigned Opcode, Type *VecTy, unsigned Factor, ArrayRef<unsigned> Indices,
+      Align Alignment, unsigned AddressSpace, TTI::TargetCostKind CostKind,
+      bool UseMaskForCond = false, bool UseMaskForGaps = false) = 0;
+  virtual int getArithmeticReductionCost(unsigned Opcode, VectorType *Ty,
+                                         bool IsPairwiseForm,
+                                         TTI::TargetCostKind CostKind) = 0;
+  virtual int getMinMaxReductionCost(VectorType *Ty, VectorType *CondTy,
+                                     bool IsPairwiseForm, bool IsUnsigned,
+                                     TTI::TargetCostKind CostKind) = 0;
+  virtual int getIntrinsicInstrCost(const IntrinsicCostAttributes &ICA,
+                                    TTI::TargetCostKind CostKind) = 0;
   virtual int getCallInstrCost(Function *F, Type *RetTy,
-                               ArrayRef<Type *> Tys) = 0;
+                               ArrayRef<Type *> Tys,
+                               TTI::TargetCostKind CostKind) = 0;
   virtual unsigned getNumberOfParts(Type *Tp) = 0;
   virtual int getAddressComputationCost(Type *Ty, ScalarEvolution *SE,
                                         const SCEV *Ptr) = 0;
@@ -1282,26 +1603,29 @@
   virtual Value *getOrCreateResultFromMemIntrinsic(IntrinsicInst *Inst,
                                                    Type *ExpectedType) = 0;
   virtual Type *getMemcpyLoopLoweringType(LLVMContext &Context, Value *Length,
+                                          unsigned SrcAddrSpace,
+                                          unsigned DestAddrSpace,
                                           unsigned SrcAlign,
                                           unsigned DestAlign) const = 0;
   virtual void getMemcpyLoopResidualLoweringType(
       SmallVectorImpl<Type *> &OpsOut, LLVMContext &Context,
-      unsigned RemainingBytes, unsigned SrcAlign, unsigned DestAlign) const = 0;
+      unsigned RemainingBytes, unsigned SrcAddrSpace, unsigned DestAddrSpace,
+      unsigned SrcAlign, unsigned DestAlign) const = 0;
   virtual bool areInlineCompatible(const Function *Caller,
                                    const Function *Callee) const = 0;
   virtual bool
   areFunctionArgsABICompatible(const Function *Caller, const Function *Callee,
                                SmallPtrSetImpl<Argument *> &Args) const = 0;
   virtual bool isIndexedLoadLegal(MemIndexedMode Mode, Type *Ty) const = 0;
-  virtual bool isIndexedStoreLegal(MemIndexedMode Mode,Type *Ty) const = 0;
+  virtual bool isIndexedStoreLegal(MemIndexedMode Mode, Type *Ty) const = 0;
   virtual unsigned getLoadStoreVecRegBitWidth(unsigned AddrSpace) const = 0;
   virtual bool isLegalToVectorizeLoad(LoadInst *LI) const = 0;
   virtual bool isLegalToVectorizeStore(StoreInst *SI) const = 0;
   virtual bool isLegalToVectorizeLoadChain(unsigned ChainSizeInBytes,
-                                           unsigned Alignment,
+                                           Align Alignment,
                                            unsigned AddrSpace) const = 0;
   virtual bool isLegalToVectorizeStoreChain(unsigned ChainSizeInBytes,
-                                            unsigned Alignment,
+                                            Align Alignment,
                                             unsigned AddrSpace) const = 0;
   virtual unsigned getLoadVectorFactor(unsigned VF, unsigned LoadSize,
                                        unsigned ChainSizeInBytes,
@@ -1311,8 +1635,14 @@
                                         VectorType *VecTy) const = 0;
   virtual bool useReductionIntrinsic(unsigned Opcode, Type *Ty,
                                      ReductionFlags) const = 0;
+  virtual bool preferInLoopReduction(unsigned Opcode, Type *Ty,
+                                     ReductionFlags) const = 0;
+  virtual bool preferPredicatedReductionSelect(unsigned Opcode, Type *Ty,
+                                               ReductionFlags) const = 0;
   virtual bool shouldExpandReduction(const IntrinsicInst *II) const = 0;
   virtual unsigned getGISelRematGlobalCost() const = 0;
+  virtual bool supportsScalableVectors() const = 0;
+  virtual bool hasActiveVectorLength() const = 0;
   virtual int getInstructionLatency(const Instruction *I) = 0;
 };
 
@@ -1328,45 +1658,28 @@
     return Impl.getDataLayout();
   }
 
-  int getOperationCost(unsigned Opcode, Type *Ty, Type *OpTy) override {
-    return Impl.getOperationCost(Opcode, Ty, OpTy);
-  }
   int getGEPCost(Type *PointeeType, const Value *Ptr,
-                 ArrayRef<const Value *> Operands) override {
+                 ArrayRef<const Value *> Operands,
+                 enum TargetTransformInfo::TargetCostKind CostKind) override {
     return Impl.getGEPCost(PointeeType, Ptr, Operands);
   }
-  int getExtCost(const Instruction *I, const Value *Src) override {
-    return Impl.getExtCost(I, Src);
-  }
-  int getCallCost(FunctionType *FTy, int NumArgs, const User *U) override {
-    return Impl.getCallCost(FTy, NumArgs, U);
-  }
-  int getCallCost(const Function *F, int NumArgs, const User *U) override {
-    return Impl.getCallCost(F, NumArgs, U);
-  }
-  int getCallCost(const Function *F,
-                  ArrayRef<const Value *> Arguments, const User *U) override {
-    return Impl.getCallCost(F, Arguments, U);
-  }
   unsigned getInliningThresholdMultiplier() override {
     return Impl.getInliningThresholdMultiplier();
   }
-  int getIntrinsicCost(Intrinsic::ID IID, Type *RetTy,
-                       ArrayRef<Type *> ParamTys, const User *U = nullptr) override {
-    return Impl.getIntrinsicCost(IID, RetTy, ParamTys, U);
-  }
-  int getIntrinsicCost(Intrinsic::ID IID, Type *RetTy,
-                       ArrayRef<const Value *> Arguments,
-                       const User *U = nullptr) override {
-    return Impl.getIntrinsicCost(IID, RetTy, Arguments, U);
+  int getInlinerVectorBonusPercent() override {
+    return Impl.getInlinerVectorBonusPercent();
   }
   int getMemcpyCost(const Instruction *I) override {
     return Impl.getMemcpyCost(I);
   }
-  int getUserCost(const User *U, ArrayRef<const Value *> Operands) override {
-    return Impl.getUserCost(U, Operands);
+  int getUserCost(const User *U, ArrayRef<const Value *> Operands,
+                  TargetCostKind CostKind) override {
+    return Impl.getUserCost(U, Operands, CostKind);
   }
   bool hasBranchDivergence() override { return Impl.hasBranchDivergence(); }
+  bool useGPUDivergenceAnalysis() override {
+    return Impl.useGPUDivergenceAnalysis();
+  }
   bool isSourceOfDivergence(const Value *V) override {
     return Impl.isSourceOfDivergence(V);
   }
@@ -1375,8 +1688,24 @@
     return Impl.isAlwaysUniform(V);
   }
 
-  unsigned getFlatAddressSpace() override {
-    return Impl.getFlatAddressSpace();
+  unsigned getFlatAddressSpace() override { return Impl.getFlatAddressSpace(); }
+
+  bool collectFlatAddressOperands(SmallVectorImpl<int> &OpIndexes,
+                                  Intrinsic::ID IID) const override {
+    return Impl.collectFlatAddressOperands(OpIndexes, IID);
+  }
+
+  bool isNoopAddrSpaceCast(unsigned FromAS, unsigned ToAS) const override {
+    return Impl.isNoopAddrSpaceCast(FromAS, ToAS);
+  }
+
+  unsigned getAssumedAddrSpace(const Value *V) const override {
+    return Impl.getAssumedAddrSpace(V);
+  }
+
+  Value *rewriteIntrinsicWithAddressSpace(IntrinsicInst *II, Value *OldV,
+                                          Value *NewV) const override {
+    return Impl.rewriteIntrinsicWithAddressSpace(II, OldV, NewV);
   }
 
   bool isLoweredToCall(const Function *F) override {
@@ -1386,12 +1715,44 @@
                                UnrollingPreferences &UP) override {
     return Impl.getUnrollingPreferences(L, SE, UP);
   }
+  void getPeelingPreferences(Loop *L, ScalarEvolution &SE,
+                             PeelingPreferences &PP) override {
+    return Impl.getPeelingPreferences(L, SE, PP);
+  }
   bool isHardwareLoopProfitable(Loop *L, ScalarEvolution &SE,
-                                AssumptionCache &AC,
-                                TargetLibraryInfo *LibInfo,
+                                AssumptionCache &AC, TargetLibraryInfo *LibInfo,
                                 HardwareLoopInfo &HWLoopInfo) override {
     return Impl.isHardwareLoopProfitable(L, SE, AC, LibInfo, HWLoopInfo);
   }
+  bool preferPredicateOverEpilogue(Loop *L, LoopInfo *LI, ScalarEvolution &SE,
+                                   AssumptionCache &AC, TargetLibraryInfo *TLI,
+                                   DominatorTree *DT,
+                                   const LoopAccessInfo *LAI) override {
+    return Impl.preferPredicateOverEpilogue(L, LI, SE, AC, TLI, DT, LAI);
+  }
+  bool emitGetActiveLaneMask() override {
+    return Impl.emitGetActiveLaneMask();
+  }
+  Optional<Instruction *> instCombineIntrinsic(InstCombiner &IC,
+                                               IntrinsicInst &II) override {
+    return Impl.instCombineIntrinsic(IC, II);
+  }
+  Optional<Value *>
+  simplifyDemandedUseBitsIntrinsic(InstCombiner &IC, IntrinsicInst &II,
+                                   APInt DemandedMask, KnownBits &Known,
+                                   bool &KnownBitsComputed) override {
+    return Impl.simplifyDemandedUseBitsIntrinsic(IC, II, DemandedMask, Known,
+                                                 KnownBitsComputed);
+  }
+  Optional<Value *> simplifyDemandedVectorEltsIntrinsic(
+      InstCombiner &IC, IntrinsicInst &II, APInt DemandedElts, APInt &UndefElts,
+      APInt &UndefElts2, APInt &UndefElts3,
+      std::function<void(Instruction *, unsigned, APInt, APInt &)>
+          SimplifyAndSetOp) override {
+    return Impl.simplifyDemandedVectorEltsIntrinsic(
+        IC, II, DemandedElts, UndefElts, UndefElts2, UndefElts3,
+        SimplifyAndSetOp);
+  }
   bool isLegalAddImmediate(int64_t Imm) override {
     return Impl.isLegalAddImmediate(Imm);
   }
@@ -1399,48 +1760,48 @@
     return Impl.isLegalICmpImmediate(Imm);
   }
   bool isLegalAddressingMode(Type *Ty, GlobalValue *BaseGV, int64_t BaseOffset,
-                             bool HasBaseReg, int64_t Scale,
-                             unsigned AddrSpace,
+                             bool HasBaseReg, int64_t Scale, unsigned AddrSpace,
                              Instruction *I) override {
-    return Impl.isLegalAddressingMode(Ty, BaseGV, BaseOffset, HasBaseReg,
-                                      Scale, AddrSpace, I);
+    return Impl.isLegalAddressingMode(Ty, BaseGV, BaseOffset, HasBaseReg, Scale,
+                                      AddrSpace, I);
   }
   bool isLSRCostLess(TargetTransformInfo::LSRCost &C1,
                      TargetTransformInfo::LSRCost &C2) override {
     return Impl.isLSRCostLess(C1, C2);
   }
-  bool canMacroFuseCmp() override {
-    return Impl.canMacroFuseCmp();
+  bool isNumRegsMajorCostOfLSR() override {
+    return Impl.isNumRegsMajorCostOfLSR();
   }
-  bool canSaveCmp(Loop *L, BranchInst **BI,
-                        ScalarEvolution *SE,
-                        LoopInfo *LI, DominatorTree *DT, AssumptionCache *AC,
-                        TargetLibraryInfo *LibInfo) override {
+  bool isProfitableLSRChainElement(Instruction *I) override {
+    return Impl.isProfitableLSRChainElement(I);
+  }
+  bool canMacroFuseCmp() override { return Impl.canMacroFuseCmp(); }
+  bool canSaveCmp(Loop *L, BranchInst **BI, ScalarEvolution *SE, LoopInfo *LI,
+                  DominatorTree *DT, AssumptionCache *AC,
+                  TargetLibraryInfo *LibInfo) override {
     return Impl.canSaveCmp(L, BI, SE, LI, DT, AC, LibInfo);
   }
-  bool shouldFavorPostInc() const override {
-    return Impl.shouldFavorPostInc();
-  }
+  bool shouldFavorPostInc() const override { return Impl.shouldFavorPostInc(); }
   bool shouldFavorBackedgeIndex(const Loop *L) const override {
     return Impl.shouldFavorBackedgeIndex(L);
   }
-  bool isLegalMaskedStore(Type *DataType) override {
-    return Impl.isLegalMaskedStore(DataType);
+  bool isLegalMaskedStore(Type *DataType, Align Alignment) override {
+    return Impl.isLegalMaskedStore(DataType, Alignment);
   }
-  bool isLegalMaskedLoad(Type *DataType) override {
-    return Impl.isLegalMaskedLoad(DataType);
+  bool isLegalMaskedLoad(Type *DataType, Align Alignment) override {
+    return Impl.isLegalMaskedLoad(DataType, Alignment);
   }
-  bool isLegalNTStore(Type *DataType, unsigned Alignment) override {
+  bool isLegalNTStore(Type *DataType, Align Alignment) override {
     return Impl.isLegalNTStore(DataType, Alignment);
   }
-  bool isLegalNTLoad(Type *DataType, unsigned Alignment) override {
+  bool isLegalNTLoad(Type *DataType, Align Alignment) override {
     return Impl.isLegalNTLoad(DataType, Alignment);
   }
-  bool isLegalMaskedScatter(Type *DataType) override {
-    return Impl.isLegalMaskedScatter(DataType);
+  bool isLegalMaskedScatter(Type *DataType, Align Alignment) override {
+    return Impl.isLegalMaskedScatter(DataType, Alignment);
   }
-  bool isLegalMaskedGather(Type *DataType) override {
-    return Impl.isLegalMaskedGather(DataType);
+  bool isLegalMaskedGather(Type *DataType, Align Alignment) override {
+    return Impl.isLegalMaskedGather(DataType, Alignment);
   }
   bool isLegalMaskedCompressStore(Type *DataType) override {
     return Impl.isLegalMaskedCompressStore(DataType);
@@ -1460,12 +1821,10 @@
   int getScalingFactorCost(Type *Ty, GlobalValue *BaseGV, int64_t BaseOffset,
                            bool HasBaseReg, int64_t Scale,
                            unsigned AddrSpace) override {
-    return Impl.getScalingFactorCost(Ty, BaseGV, BaseOffset, HasBaseReg,
-                                     Scale, AddrSpace);
+    return Impl.getScalingFactorCost(Ty, BaseGV, BaseOffset, HasBaseReg, Scale,
+                                     AddrSpace);
   }
-  bool LSRWithInstrQueries() override {
-    return Impl.LSRWithInstrQueries();
-  }
+  bool LSRWithInstrQueries() override { return Impl.LSRWithInstrQueries(); }
   bool isTruncateFree(Type *Ty1, Type *Ty2) override {
     return Impl.isTruncateFree(Ty1, Ty2);
   }
@@ -1474,8 +1833,9 @@
   }
   bool useAA() override { return Impl.useAA(); }
   bool isTypeLegal(Type *Ty) override { return Impl.isTypeLegal(Ty); }
-  unsigned getJumpBufAlignment() override { return Impl.getJumpBufAlignment(); }
-  unsigned getJumpBufSize() override { return Impl.getJumpBufSize(); }
+  unsigned getRegUsageForType(Type *Ty) override {
+    return Impl.getRegUsageForType(Ty);
+  }
   bool shouldBuildLookupTables() override {
     return Impl.shouldBuildLookupTables();
   }
@@ -1486,9 +1846,9 @@
     return Impl.useColdCCForColdCall(F);
   }
 
-  unsigned getScalarizationOverhead(Type *Ty, bool Insert,
-                                    bool Extract) override {
-    return Impl.getScalarizationOverhead(Ty, Insert, Extract);
+  unsigned getScalarizationOverhead(VectorType *Ty, const APInt &DemandedElts,
+                                    bool Insert, bool Extract) override {
+    return Impl.getScalarizationOverhead(Ty, DemandedElts, Insert, Extract);
   }
   unsigned getOperandsScalarizationOverhead(ArrayRef<const Value *> Args,
                                             unsigned VF) override {
@@ -1515,9 +1875,9 @@
   bool isFPVectorizationPotentiallyUnsafe() override {
     return Impl.isFPVectorizationPotentiallyUnsafe();
   }
-  bool allowsMisalignedMemoryAccesses(LLVMContext &Context,
-                                      unsigned BitWidth, unsigned AddressSpace,
-                                      unsigned Alignment, bool *Fast) override {
+  bool allowsMisalignedMemoryAccesses(LLVMContext &Context, unsigned BitWidth,
+                                      unsigned AddressSpace, unsigned Alignment,
+                                      bool *Fast) override {
     return Impl.allowsMisalignedMemoryAccesses(Context, BitWidth, AddressSpace,
                                                Alignment, Fast);
   }
@@ -1536,19 +1896,28 @@
                             Type *Ty) override {
     return Impl.getIntImmCodeSizeCost(Opc, Idx, Imm, Ty);
   }
-  int getIntImmCost(const APInt &Imm, Type *Ty) override {
-    return Impl.getIntImmCost(Imm, Ty);
+  int getIntImmCost(const APInt &Imm, Type *Ty,
+                    TargetCostKind CostKind) override {
+    return Impl.getIntImmCost(Imm, Ty, CostKind);
   }
-  int getIntImmCost(unsigned Opc, unsigned Idx, const APInt &Imm,
-                    Type *Ty) override {
-    return Impl.getIntImmCost(Opc, Idx, Imm, Ty);
+  int getIntImmCostInst(unsigned Opc, unsigned Idx, const APInt &Imm, Type *Ty,
+                        TargetCostKind CostKind,
+                        Instruction *Inst = nullptr) override {
+    return Impl.getIntImmCostInst(Opc, Idx, Imm, Ty, CostKind, Inst);
   }
-  int getIntImmCost(Intrinsic::ID IID, unsigned Idx, const APInt &Imm,
-                    Type *Ty) override {
-    return Impl.getIntImmCost(IID, Idx, Imm, Ty);
+  int getIntImmCostIntrin(Intrinsic::ID IID, unsigned Idx, const APInt &Imm,
+                          Type *Ty, TargetCostKind CostKind) override {
+    return Impl.getIntImmCostIntrin(IID, Idx, Imm, Ty, CostKind);
   }
-  unsigned getNumberOfRegisters(bool Vector) override {
-    return Impl.getNumberOfRegisters(Vector);
+  unsigned getNumberOfRegisters(unsigned ClassID) const override {
+    return Impl.getNumberOfRegisters(ClassID);
+  }
+  unsigned getRegisterClassForType(bool Vector,
+                                   Type *Ty = nullptr) const override {
+    return Impl.getRegisterClassForType(Vector, Ty);
+  }
+  const char *getRegisterClassName(unsigned ClassID) const override {
+    return Impl.getRegisterClassName(ClassID);
   }
   unsigned getRegisterBitWidth(bool Vector) const override {
     return Impl.getRegisterBitWidth(Vector);
@@ -1556,113 +1925,154 @@
   unsigned getMinVectorRegisterBitWidth() override {
     return Impl.getMinVectorRegisterBitWidth();
   }
+  Optional<unsigned> getMaxVScale() const override {
+    return Impl.getMaxVScale();
+  }
   bool shouldMaximizeVectorBandwidth(bool OptSize) const override {
     return Impl.shouldMaximizeVectorBandwidth(OptSize);
   }
   unsigned getMinimumVF(unsigned ElemWidth) const override {
     return Impl.getMinimumVF(ElemWidth);
   }
+  unsigned getMaximumVF(unsigned ElemWidth, unsigned Opcode) const override {
+    return Impl.getMaximumVF(ElemWidth, Opcode);
+  }
   bool shouldConsiderAddressTypePromotion(
       const Instruction &I, bool &AllowPromotionWithoutCommonHeader) override {
     return Impl.shouldConsiderAddressTypePromotion(
         I, AllowPromotionWithoutCommonHeader);
   }
-  unsigned getCacheLineSize() override {
-    return Impl.getCacheLineSize();
-  }
-  llvm::Optional<unsigned> getCacheSize(CacheLevel Level) override {
+  unsigned getCacheLineSize() const override { return Impl.getCacheLineSize(); }
+  Optional<unsigned> getCacheSize(CacheLevel Level) const override {
     return Impl.getCacheSize(Level);
   }
-  llvm::Optional<unsigned> getCacheAssociativity(CacheLevel Level) override {
+  Optional<unsigned> getCacheAssociativity(CacheLevel Level) const override {
     return Impl.getCacheAssociativity(Level);
   }
-  unsigned getPrefetchDistance() override { return Impl.getPrefetchDistance(); }
-  unsigned getMinPrefetchStride() override {
-    return Impl.getMinPrefetchStride();
+
+  /// Return the preferred prefetch distance in terms of instructions.
+  ///
+  unsigned getPrefetchDistance() const override {
+    return Impl.getPrefetchDistance();
   }
-  unsigned getMaxPrefetchIterationsAhead() override {
+
+  /// Return the minimum stride necessary to trigger software
+  /// prefetching.
+  ///
+  unsigned getMinPrefetchStride(unsigned NumMemAccesses,
+                                unsigned NumStridedMemAccesses,
+                                unsigned NumPrefetches,
+                                bool HasCall) const override {
+    return Impl.getMinPrefetchStride(NumMemAccesses, NumStridedMemAccesses,
+                                     NumPrefetches, HasCall);
+  }
+
+  /// Return the maximum prefetch distance in terms of loop
+  /// iterations.
+  ///
+  unsigned getMaxPrefetchIterationsAhead() const override {
     return Impl.getMaxPrefetchIterationsAhead();
   }
+
+  /// \return True if prefetching should also be done for writes.
+  bool enableWritePrefetching() const override {
+    return Impl.enableWritePrefetching();
+  }
+
   unsigned getMaxInterleaveFactor(unsigned VF) override {
     return Impl.getMaxInterleaveFactor(VF);
   }
   unsigned getEstimatedNumberOfCaseClusters(const SwitchInst &SI,
-                                            unsigned &JTSize) override {
-    return Impl.getEstimatedNumberOfCaseClusters(SI, JTSize);
+                                            unsigned &JTSize,
+                                            ProfileSummaryInfo *PSI,
+                                            BlockFrequencyInfo *BFI) override {
+    return Impl.getEstimatedNumberOfCaseClusters(SI, JTSize, PSI, BFI);
   }
-  unsigned
-  getArithmeticInstrCost(unsigned Opcode, Type *Ty, OperandValueKind Opd1Info,
-                         OperandValueKind Opd2Info,
-                         OperandValueProperties Opd1PropInfo,
-                         OperandValueProperties Opd2PropInfo,
-                         ArrayRef<const Value *> Args) override {
-    return Impl.getArithmeticInstrCost(Opcode, Ty, Opd1Info, Opd2Info,
-                                       Opd1PropInfo, Opd2PropInfo, Args);
+  unsigned getArithmeticInstrCost(unsigned Opcode, Type *Ty,
+                                  TTI::TargetCostKind CostKind,
+                                  OperandValueKind Opd1Info,
+                                  OperandValueKind Opd2Info,
+                                  OperandValueProperties Opd1PropInfo,
+                                  OperandValueProperties Opd2PropInfo,
+                                  ArrayRef<const Value *> Args,
+                                  const Instruction *CxtI = nullptr) override {
+    return Impl.getArithmeticInstrCost(Opcode, Ty, CostKind, Opd1Info, Opd2Info,
+                                       Opd1PropInfo, Opd2PropInfo, Args, CxtI);
   }
-  int getShuffleCost(ShuffleKind Kind, Type *Tp, int Index,
-                     Type *SubTp) override {
+  int getShuffleCost(ShuffleKind Kind, VectorType *Tp, int Index,
+                     VectorType *SubTp) override {
     return Impl.getShuffleCost(Kind, Tp, Index, SubTp);
   }
   int getCastInstrCost(unsigned Opcode, Type *Dst, Type *Src,
+                       CastContextHint CCH, TTI::TargetCostKind CostKind,
                        const Instruction *I) override {
-    return Impl.getCastInstrCost(Opcode, Dst, Src, I);
+    return Impl.getCastInstrCost(Opcode, Dst, Src, CCH, CostKind, I);
   }
   int getExtractWithExtendCost(unsigned Opcode, Type *Dst, VectorType *VecTy,
                                unsigned Index) override {
     return Impl.getExtractWithExtendCost(Opcode, Dst, VecTy, Index);
   }
-  int getCFInstrCost(unsigned Opcode) override {
-    return Impl.getCFInstrCost(Opcode);
+  int getCFInstrCost(unsigned Opcode, TTI::TargetCostKind CostKind) override {
+    return Impl.getCFInstrCost(Opcode, CostKind);
   }
   int getCmpSelInstrCost(unsigned Opcode, Type *ValTy, Type *CondTy,
+                         CmpInst::Predicate VecPred,
+                         TTI::TargetCostKind CostKind,
                          const Instruction *I) override {
-    return Impl.getCmpSelInstrCost(Opcode, ValTy, CondTy, I);
+    return Impl.getCmpSelInstrCost(Opcode, ValTy, CondTy, VecPred, CostKind, I);
   }
   int getVectorInstrCost(unsigned Opcode, Type *Val, unsigned Index) override {
     return Impl.getVectorInstrCost(Opcode, Val, Index);
   }
-  int getMemoryOpCost(unsigned Opcode, Type *Src, unsigned Alignment,
-                      unsigned AddressSpace, const Instruction *I) override {
-    return Impl.getMemoryOpCost(Opcode, Src, Alignment, AddressSpace, I);
+  int getMemoryOpCost(unsigned Opcode, Type *Src, Align Alignment,
+                      unsigned AddressSpace, TTI::TargetCostKind CostKind,
+                      const Instruction *I) override {
+    return Impl.getMemoryOpCost(Opcode, Src, Alignment, AddressSpace,
+                                CostKind, I);
   }
-  int getMaskedMemoryOpCost(unsigned Opcode, Type *Src, unsigned Alignment,
-                            unsigned AddressSpace) override {
-    return Impl.getMaskedMemoryOpCost(Opcode, Src, Alignment, AddressSpace);
+  int getMaskedMemoryOpCost(unsigned Opcode, Type *Src, Align Alignment,
+                            unsigned AddressSpace,
+                            TTI::TargetCostKind CostKind) override {
+    return Impl.getMaskedMemoryOpCost(Opcode, Src, Alignment, AddressSpace,
+                                      CostKind);
   }
-  int getGatherScatterOpCost(unsigned Opcode, Type *DataTy,
-                             Value *Ptr, bool VariableMask,
-                             unsigned Alignment) override {
+  int getGatherScatterOpCost(unsigned Opcode, Type *DataTy, const Value *Ptr,
+                             bool VariableMask, Align Alignment,
+                             TTI::TargetCostKind CostKind,
+                             const Instruction *I = nullptr) override {
     return Impl.getGatherScatterOpCost(Opcode, DataTy, Ptr, VariableMask,
-                                       Alignment);
+                                       Alignment, CostKind, I);
   }
   int getInterleavedMemoryOpCost(unsigned Opcode, Type *VecTy, unsigned Factor,
-                                 ArrayRef<unsigned> Indices, unsigned Alignment,
-                                 unsigned AddressSpace, bool UseMaskForCond,
+                                 ArrayRef<unsigned> Indices, Align Alignment,
+                                 unsigned AddressSpace,
+                                 TTI::TargetCostKind CostKind,
+                                 bool UseMaskForCond,
                                  bool UseMaskForGaps) override {
     return Impl.getInterleavedMemoryOpCost(Opcode, VecTy, Factor, Indices,
-                                           Alignment, AddressSpace,
+                                           Alignment, AddressSpace, CostKind,
                                            UseMaskForCond, UseMaskForGaps);
   }
-  int getArithmeticReductionCost(unsigned Opcode, Type *Ty,
-                                 bool IsPairwiseForm) override {
-    return Impl.getArithmeticReductionCost(Opcode, Ty, IsPairwiseForm);
+  int getArithmeticReductionCost(unsigned Opcode, VectorType *Ty,
+                                 bool IsPairwiseForm,
+                                 TTI::TargetCostKind CostKind) override {
+    return Impl.getArithmeticReductionCost(Opcode, Ty, IsPairwiseForm,
+                                           CostKind);
   }
-  int getMinMaxReductionCost(Type *Ty, Type *CondTy,
-                             bool IsPairwiseForm, bool IsUnsigned) override {
-    return Impl.getMinMaxReductionCost(Ty, CondTy, IsPairwiseForm, IsUnsigned);
-   }
-  int getIntrinsicInstrCost(Intrinsic::ID ID, Type *RetTy, ArrayRef<Type *> Tys,
-               FastMathFlags FMF, unsigned ScalarizationCostPassed) override {
-    return Impl.getIntrinsicInstrCost(ID, RetTy, Tys, FMF,
-                                      ScalarizationCostPassed);
+  int getMinMaxReductionCost(VectorType *Ty, VectorType *CondTy,
+                             bool IsPairwiseForm, bool IsUnsigned,
+                             TTI::TargetCostKind CostKind) override {
+    return Impl.getMinMaxReductionCost(Ty, CondTy, IsPairwiseForm, IsUnsigned,
+                                       CostKind);
   }
-  int getIntrinsicInstrCost(Intrinsic::ID ID, Type *RetTy,
-       ArrayRef<Value *> Args, FastMathFlags FMF, unsigned VF) override {
-    return Impl.getIntrinsicInstrCost(ID, RetTy, Args, FMF, VF);
+  int getIntrinsicInstrCost(const IntrinsicCostAttributes &ICA,
+                            TTI::TargetCostKind CostKind) override {
+    return Impl.getIntrinsicInstrCost(ICA, CostKind);
   }
   int getCallInstrCost(Function *F, Type *RetTy,
-                       ArrayRef<Type *> Tys) override {
-    return Impl.getCallInstrCost(F, RetTy, Tys);
+                       ArrayRef<Type *> Tys,
+                       TTI::TargetCostKind CostKind) override {
+    return Impl.getCallInstrCost(F, RetTy, Tys, CostKind);
   }
   unsigned getNumberOfParts(Type *Tp) override {
     return Impl.getNumberOfParts(Tp);
@@ -1686,16 +2096,18 @@
     return Impl.getOrCreateResultFromMemIntrinsic(Inst, ExpectedType);
   }
   Type *getMemcpyLoopLoweringType(LLVMContext &Context, Value *Length,
+                                  unsigned SrcAddrSpace, unsigned DestAddrSpace,
                                   unsigned SrcAlign,
                                   unsigned DestAlign) const override {
-    return Impl.getMemcpyLoopLoweringType(Context, Length, SrcAlign, DestAlign);
+    return Impl.getMemcpyLoopLoweringType(Context, Length, SrcAddrSpace,
+                                          DestAddrSpace, SrcAlign, DestAlign);
   }
-  void getMemcpyLoopResidualLoweringType(SmallVectorImpl<Type *> &OpsOut,
-                                         LLVMContext &Context,
-                                         unsigned RemainingBytes,
-                                         unsigned SrcAlign,
-                                         unsigned DestAlign) const override {
+  void getMemcpyLoopResidualLoweringType(
+      SmallVectorImpl<Type *> &OpsOut, LLVMContext &Context,
+      unsigned RemainingBytes, unsigned SrcAddrSpace, unsigned DestAddrSpace,
+      unsigned SrcAlign, unsigned DestAlign) const override {
     Impl.getMemcpyLoopResidualLoweringType(OpsOut, Context, RemainingBytes,
+                                           SrcAddrSpace, DestAddrSpace,
                                            SrcAlign, DestAlign);
   }
   bool areInlineCompatible(const Function *Caller,
@@ -1722,14 +2134,12 @@
   bool isLegalToVectorizeStore(StoreInst *SI) const override {
     return Impl.isLegalToVectorizeStore(SI);
   }
-  bool isLegalToVectorizeLoadChain(unsigned ChainSizeInBytes,
-                                   unsigned Alignment,
+  bool isLegalToVectorizeLoadChain(unsigned ChainSizeInBytes, Align Alignment,
                                    unsigned AddrSpace) const override {
     return Impl.isLegalToVectorizeLoadChain(ChainSizeInBytes, Alignment,
                                             AddrSpace);
   }
-  bool isLegalToVectorizeStoreChain(unsigned ChainSizeInBytes,
-                                    unsigned Alignment,
+  bool isLegalToVectorizeStoreChain(unsigned ChainSizeInBytes, Align Alignment,
                                     unsigned AddrSpace) const override {
     return Impl.isLegalToVectorizeStoreChain(ChainSizeInBytes, Alignment,
                                              AddrSpace);
@@ -1748,6 +2158,14 @@
                              ReductionFlags Flags) const override {
     return Impl.useReductionIntrinsic(Opcode, Ty, Flags);
   }
+  bool preferInLoopReduction(unsigned Opcode, Type *Ty,
+                             ReductionFlags Flags) const override {
+    return Impl.preferInLoopReduction(Opcode, Ty, Flags);
+  }
+  bool preferPredicatedReductionSelect(unsigned Opcode, Type *Ty,
+                                       ReductionFlags Flags) const override {
+    return Impl.preferPredicatedReductionSelect(Opcode, Ty, Flags);
+  }
   bool shouldExpandReduction(const IntrinsicInst *II) const override {
     return Impl.shouldExpandReduction(II);
   }
@@ -1756,6 +2174,14 @@
     return Impl.getGISelRematGlobalCost();
   }
 
+  bool supportsScalableVectors() const override {
+    return Impl.supportsScalableVectors();
+  }
+
+  bool hasActiveVectorLength() const override {
+    return Impl.hasActiveVectorLength();
+  }
+
   int getInstructionLatency(const Instruction *I) override {
     return Impl.getInstructionLatency(I);
   }
@@ -1858,6 +2284,6 @@
 /// clients.
 ImmutablePass *createTargetTransformInfoWrapperPass(TargetIRAnalysis TIRA);
 
-} // End llvm namespace
+} // namespace llvm
 
 #endif
diff --git a/linux-x64/clang/include/llvm/Analysis/TargetTransformInfoImpl.h b/linux-x64/clang/include/llvm/Analysis/TargetTransformInfoImpl.h
index a9383e7..47de99b 100644
--- a/linux-x64/clang/include/llvm/Analysis/TargetTransformInfoImpl.h
+++ b/linux-x64/clang/include/llvm/Analysis/TargetTransformInfoImpl.h
@@ -17,10 +17,10 @@
 #include "llvm/Analysis/ScalarEvolutionExpressions.h"
 #include "llvm/Analysis/TargetTransformInfo.h"
 #include "llvm/Analysis/VectorUtils.h"
-#include "llvm/IR/CallSite.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/GetElementPtrTypeIterator.h"
+#include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/Operator.h"
 #include "llvm/IR/Type.h"
 
@@ -44,66 +44,9 @@
 
   const DataLayout &getDataLayout() const { return DL; }
 
-  unsigned getOperationCost(unsigned Opcode, Type *Ty, Type *OpTy) {
-    switch (Opcode) {
-    default:
-      // By default, just classify everything as 'basic'.
-      return TTI::TCC_Basic;
-
-    case Instruction::GetElementPtr:
-      llvm_unreachable("Use getGEPCost for GEP operations!");
-
-    case Instruction::BitCast:
-      assert(OpTy && "Cast instructions must provide the operand type");
-      if (Ty == OpTy || (Ty->isPointerTy() && OpTy->isPointerTy()))
-        // Identity and pointer-to-pointer casts are free.
-        return TTI::TCC_Free;
-
-      // Otherwise, the default basic cost is used.
-      return TTI::TCC_Basic;
-
-    case Instruction::FDiv:
-    case Instruction::FRem:
-    case Instruction::SDiv:
-    case Instruction::SRem:
-    case Instruction::UDiv:
-    case Instruction::URem:
-      return TTI::TCC_Expensive;
-
-    case Instruction::IntToPtr: {
-      // An inttoptr cast is free so long as the input is a legal integer type
-      // which doesn't contain values outside the range of a pointer.
-      unsigned OpSize = OpTy->getScalarSizeInBits();
-      if (DL.isLegalInteger(OpSize) &&
-          OpSize <= DL.getPointerTypeSizeInBits(Ty))
-        return TTI::TCC_Free;
-
-      // Otherwise it's not a no-op.
-      return TTI::TCC_Basic;
-    }
-    case Instruction::PtrToInt: {
-      // A ptrtoint cast is free so long as the result is large enough to store
-      // the pointer, and a legal integer type.
-      unsigned DestSize = Ty->getScalarSizeInBits();
-      if (DL.isLegalInteger(DestSize) &&
-          DestSize >= DL.getPointerTypeSizeInBits(OpTy))
-        return TTI::TCC_Free;
-
-      // Otherwise it's not a no-op.
-      return TTI::TCC_Basic;
-    }
-    case Instruction::Trunc:
-      // trunc to a native type is free (assuming the target has compare and
-      // shift-right of the same width).
-      if (DL.isLegalInteger(DL.getTypeSizeInBits(Ty)))
-        return TTI::TCC_Free;
-
-      return TTI::TCC_Basic;
-    }
-  }
-
   int getGEPCost(Type *PointeeType, const Value *Ptr,
-                 ArrayRef<const Value *> Operands) {
+                 ArrayRef<const Value *> Operands,
+                 TTI::TargetCostKind CostKind = TTI::TCK_SizeAndLatency) const {
     // In the basic model, we just assume that all-constant GEPs will be folded
     // into their uses via addressing modes.
     for (unsigned Idx = 0, Size = Operands.size(); Idx != Size; ++Idx)
@@ -114,47 +57,48 @@
   }
 
   unsigned getEstimatedNumberOfCaseClusters(const SwitchInst &SI,
-                                            unsigned &JTSize) {
+                                            unsigned &JTSize,
+                                            ProfileSummaryInfo *PSI,
+                                            BlockFrequencyInfo *BFI) const {
+    (void)PSI;
+    (void)BFI;
     JTSize = 0;
     return SI.getNumCases();
   }
 
-  int getExtCost(const Instruction *I, const Value *Src) {
-    return TTI::TCC_Basic;
-  }
+  unsigned getInliningThresholdMultiplier() const { return 1; }
 
-  unsigned getCallCost(FunctionType *FTy, int NumArgs, const User *U) {
-    assert(FTy && "FunctionType must be provided to this routine.");
+  int getInlinerVectorBonusPercent() const { return 150; }
 
-    // The target-independent implementation just measures the size of the
-    // function by approximating that each argument will take on average one
-    // instruction to prepare.
-
-    if (NumArgs < 0)
-      // Set the argument number to the number of explicit arguments in the
-      // function.
-      NumArgs = FTy->getNumParams();
-
-    return TTI::TCC_Basic * (NumArgs + 1);
-  }
-
-  unsigned getInliningThresholdMultiplier() { return 1; }
-
-  unsigned getMemcpyCost(const Instruction *I) {
+  unsigned getMemcpyCost(const Instruction *I) const {
     return TTI::TCC_Expensive;
   }
 
-  bool hasBranchDivergence() { return false; }
+  bool hasBranchDivergence() const { return false; }
 
-  bool isSourceOfDivergence(const Value *V) { return false; }
+  bool useGPUDivergenceAnalysis() const { return false; }
 
-  bool isAlwaysUniform(const Value *V) { return false; }
+  bool isSourceOfDivergence(const Value *V) const { return false; }
 
-  unsigned getFlatAddressSpace () {
-    return -1;
+  bool isAlwaysUniform(const Value *V) const { return false; }
+
+  unsigned getFlatAddressSpace() const { return -1; }
+
+  bool collectFlatAddressOperands(SmallVectorImpl<int> &OpIndexes,
+                                  Intrinsic::ID IID) const {
+    return false;
   }
 
-  bool isLoweredToCall(const Function *F) {
+  bool isNoopAddrSpaceCast(unsigned, unsigned) const { return false; }
+
+  unsigned getAssumedAddrSpace(const Value *V) const { return -1; }
+
+  Value *rewriteIntrinsicWithAddressSpace(IntrinsicInst *II, Value *OldV,
+                                          Value *NewV) const {
+    return nullptr;
+  }
+
+  bool isLoweredToCall(const Function *F) const {
     assert(F && "A concrete function must be provided to this routine.");
 
     // FIXME: These should almost certainly not be handled here, and instead
@@ -191,39 +135,76 @@
   }
 
   bool isHardwareLoopProfitable(Loop *L, ScalarEvolution &SE,
-                                AssumptionCache &AC,
-                                TargetLibraryInfo *LibInfo,
-                                HardwareLoopInfo &HWLoopInfo) {
+                                AssumptionCache &AC, TargetLibraryInfo *LibInfo,
+                                HardwareLoopInfo &HWLoopInfo) const {
     return false;
   }
 
+  bool preferPredicateOverEpilogue(Loop *L, LoopInfo *LI, ScalarEvolution &SE,
+                                   AssumptionCache &AC, TargetLibraryInfo *TLI,
+                                   DominatorTree *DT,
+                                   const LoopAccessInfo *LAI) const {
+    return false;
+  }
+
+  bool emitGetActiveLaneMask() const {
+    return false;
+  }
+
+  Optional<Instruction *> instCombineIntrinsic(InstCombiner &IC,
+                                               IntrinsicInst &II) const {
+    return None;
+  }
+
+  Optional<Value *>
+  simplifyDemandedUseBitsIntrinsic(InstCombiner &IC, IntrinsicInst &II,
+                                   APInt DemandedMask, KnownBits &Known,
+                                   bool &KnownBitsComputed) const {
+    return None;
+  }
+
+  Optional<Value *> simplifyDemandedVectorEltsIntrinsic(
+      InstCombiner &IC, IntrinsicInst &II, APInt DemandedElts, APInt &UndefElts,
+      APInt &UndefElts2, APInt &UndefElts3,
+      std::function<void(Instruction *, unsigned, APInt, APInt &)>
+          SimplifyAndSetOp) const {
+    return None;
+  }
+
   void getUnrollingPreferences(Loop *, ScalarEvolution &,
-                               TTI::UnrollingPreferences &) {}
+                               TTI::UnrollingPreferences &) const {}
 
-  bool isLegalAddImmediate(int64_t Imm) { return false; }
+  void getPeelingPreferences(Loop *, ScalarEvolution &,
+                             TTI::PeelingPreferences &) const {}
 
-  bool isLegalICmpImmediate(int64_t Imm) { return false; }
+  bool isLegalAddImmediate(int64_t Imm) const { return false; }
+
+  bool isLegalICmpImmediate(int64_t Imm) const { return false; }
 
   bool isLegalAddressingMode(Type *Ty, GlobalValue *BaseGV, int64_t BaseOffset,
-                             bool HasBaseReg, int64_t Scale,
-                             unsigned AddrSpace, Instruction *I = nullptr) {
+                             bool HasBaseReg, int64_t Scale, unsigned AddrSpace,
+                             Instruction *I = nullptr) const {
     // Guess that only reg and reg+reg addressing is allowed. This heuristic is
     // taken from the implementation of LSR.
     return !BaseGV && BaseOffset == 0 && (Scale == 0 || Scale == 1);
   }
 
-  bool isLSRCostLess(TTI::LSRCost &C1, TTI::LSRCost &C2) {
+  bool isLSRCostLess(TTI::LSRCost &C1, TTI::LSRCost &C2) const {
     return std::tie(C1.NumRegs, C1.AddRecCost, C1.NumIVMuls, C1.NumBaseAdds,
                     C1.ScaleCost, C1.ImmCost, C1.SetupCost) <
            std::tie(C2.NumRegs, C2.AddRecCost, C2.NumIVMuls, C2.NumBaseAdds,
                     C2.ScaleCost, C2.ImmCost, C2.SetupCost);
   }
 
-  bool canMacroFuseCmp() { return false; }
+  bool isNumRegsMajorCostOfLSR() const { return true; }
+
+  bool isProfitableLSRChainElement(Instruction *I) const { return false; }
+
+  bool canMacroFuseCmp() const { return false; }
 
   bool canSaveCmp(Loop *L, BranchInst **BI, ScalarEvolution *SE, LoopInfo *LI,
                   DominatorTree *DT, AssumptionCache *AC,
-                  TargetLibraryInfo *LibInfo) {
+                  TargetLibraryInfo *LibInfo) const {
     return false;
   }
 
@@ -231,141 +212,192 @@
 
   bool shouldFavorBackedgeIndex(const Loop *L) const { return false; }
 
-  bool isLegalMaskedStore(Type *DataType) { return false; }
+  bool isLegalMaskedStore(Type *DataType, Align Alignment) const {
+    return false;
+  }
 
-  bool isLegalMaskedLoad(Type *DataType) { return false; }
+  bool isLegalMaskedLoad(Type *DataType, Align Alignment) const {
+    return false;
+  }
 
-  bool isLegalNTStore(Type *DataType, unsigned Alignment) {
+  bool isLegalNTStore(Type *DataType, Align Alignment) const {
     // By default, assume nontemporal memory stores are available for stores
     // that are aligned and have a size that is a power of 2.
     unsigned DataSize = DL.getTypeStoreSize(DataType);
     return Alignment >= DataSize && isPowerOf2_32(DataSize);
   }
 
-  bool isLegalNTLoad(Type *DataType, unsigned Alignment) {
+  bool isLegalNTLoad(Type *DataType, Align Alignment) const {
     // By default, assume nontemporal memory loads are available for loads that
     // are aligned and have a size that is a power of 2.
     unsigned DataSize = DL.getTypeStoreSize(DataType);
     return Alignment >= DataSize && isPowerOf2_32(DataSize);
   }
 
-  bool isLegalMaskedScatter(Type *DataType) { return false; }
+  bool isLegalMaskedScatter(Type *DataType, Align Alignment) const {
+    return false;
+  }
 
-  bool isLegalMaskedGather(Type *DataType) { return false; }
+  bool isLegalMaskedGather(Type *DataType, Align Alignment) const {
+    return false;
+  }
 
-  bool isLegalMaskedCompressStore(Type *DataType) { return false; }
+  bool isLegalMaskedCompressStore(Type *DataType) const { return false; }
 
-  bool isLegalMaskedExpandLoad(Type *DataType) { return false; }
+  bool isLegalMaskedExpandLoad(Type *DataType) const { return false; }
 
-  bool hasDivRemOp(Type *DataType, bool IsSigned) { return false; }
+  bool hasDivRemOp(Type *DataType, bool IsSigned) const { return false; }
 
-  bool hasVolatileVariant(Instruction *I, unsigned AddrSpace) { return false; }
+  bool hasVolatileVariant(Instruction *I, unsigned AddrSpace) const {
+    return false;
+  }
 
-  bool prefersVectorizedAddressing() { return true; }
+  bool prefersVectorizedAddressing() const { return true; }
 
   int getScalingFactorCost(Type *Ty, GlobalValue *BaseGV, int64_t BaseOffset,
-                           bool HasBaseReg, int64_t Scale, unsigned AddrSpace) {
+                           bool HasBaseReg, int64_t Scale,
+                           unsigned AddrSpace) const {
     // Guess that all legal addressing mode are free.
-    if (isLegalAddressingMode(Ty, BaseGV, BaseOffset, HasBaseReg,
-                              Scale, AddrSpace))
+    if (isLegalAddressingMode(Ty, BaseGV, BaseOffset, HasBaseReg, Scale,
+                              AddrSpace))
       return 0;
     return -1;
   }
 
-  bool LSRWithInstrQueries() { return false; }
+  bool LSRWithInstrQueries() const { return false; }
 
-  bool isTruncateFree(Type *Ty1, Type *Ty2) { return false; }
+  bool isTruncateFree(Type *Ty1, Type *Ty2) const { return false; }
 
-  bool isProfitableToHoist(Instruction *I) { return true; }
+  bool isProfitableToHoist(Instruction *I) const { return true; }
 
-  bool useAA() { return false; }
+  bool useAA() const { return false; }
 
-  bool isTypeLegal(Type *Ty) { return false; }
+  bool isTypeLegal(Type *Ty) const { return false; }
 
-  unsigned getJumpBufAlignment() { return 0; }
+  unsigned getRegUsageForType(Type *Ty) const { return 1; }
 
-  unsigned getJumpBufSize() { return 0; }
+  bool shouldBuildLookupTables() const { return true; }
+  bool shouldBuildLookupTablesForConstant(Constant *C) const { return true; }
 
-  bool shouldBuildLookupTables() { return true; }
-  bool shouldBuildLookupTablesForConstant(Constant *C) { return true; }
+  bool useColdCCForColdCall(Function &F) const { return false; }
 
-  bool useColdCCForColdCall(Function &F) { return false; }
-
-  unsigned getScalarizationOverhead(Type *Ty, bool Insert, bool Extract) {
+  unsigned getScalarizationOverhead(VectorType *Ty, const APInt &DemandedElts,
+                                    bool Insert, bool Extract) const {
     return 0;
   }
 
   unsigned getOperandsScalarizationOverhead(ArrayRef<const Value *> Args,
-                                            unsigned VF) { return 0; }
+                                            unsigned VF) const {
+    return 0;
+  }
 
-  bool supportsEfficientVectorElementLoadStore() { return false; }
+  bool supportsEfficientVectorElementLoadStore() const { return false; }
 
-  bool enableAggressiveInterleaving(bool LoopHasReductions) { return false; }
+  bool enableAggressiveInterleaving(bool LoopHasReductions) const {
+    return false;
+  }
 
   TTI::MemCmpExpansionOptions enableMemCmpExpansion(bool OptSize,
                                                     bool IsZeroCmp) const {
     return {};
   }
 
-  bool enableInterleavedAccessVectorization() { return false; }
+  bool enableInterleavedAccessVectorization() const { return false; }
 
-  bool enableMaskedInterleavedAccessVectorization() { return false; }
+  bool enableMaskedInterleavedAccessVectorization() const { return false; }
 
-  bool isFPVectorizationPotentiallyUnsafe() { return false; }
+  bool isFPVectorizationPotentiallyUnsafe() const { return false; }
 
-  bool allowsMisalignedMemoryAccesses(LLVMContext &Context,
-                                      unsigned BitWidth,
-                                      unsigned AddressSpace,
-                                      unsigned Alignment,
-                                      bool *Fast) { return false; }
+  bool allowsMisalignedMemoryAccesses(LLVMContext &Context, unsigned BitWidth,
+                                      unsigned AddressSpace, unsigned Alignment,
+                                      bool *Fast) const {
+    return false;
+  }
 
-  TTI::PopcntSupportKind getPopcntSupport(unsigned IntTyWidthInBit) {
+  TTI::PopcntSupportKind getPopcntSupport(unsigned IntTyWidthInBit) const {
     return TTI::PSK_Software;
   }
 
-  bool haveFastSqrt(Type *Ty) { return false; }
+  bool haveFastSqrt(Type *Ty) const { return false; }
 
-  bool isFCmpOrdCheaperThanFCmpZero(Type *Ty) { return true; }
+  bool isFCmpOrdCheaperThanFCmpZero(Type *Ty) const { return true; }
 
-  unsigned getFPOpCost(Type *Ty) { return TargetTransformInfo::TCC_Basic; }
+  unsigned getFPOpCost(Type *Ty) const {
+    return TargetTransformInfo::TCC_Basic;
+  }
 
   int getIntImmCodeSizeCost(unsigned Opcode, unsigned Idx, const APInt &Imm,
-                            Type *Ty) {
+                            Type *Ty) const {
     return 0;
   }
 
-  unsigned getIntImmCost(const APInt &Imm, Type *Ty) { return TTI::TCC_Basic; }
+  unsigned getIntImmCost(const APInt &Imm, Type *Ty,
+                         TTI::TargetCostKind CostKind) const {
+    return TTI::TCC_Basic;
+  }
 
-  unsigned getIntImmCost(unsigned Opcode, unsigned Idx, const APInt &Imm,
-                         Type *Ty) {
+  unsigned getIntImmCostInst(unsigned Opcode, unsigned Idx, const APInt &Imm,
+                             Type *Ty, TTI::TargetCostKind CostKind,
+                             Instruction *Inst = nullptr) const {
     return TTI::TCC_Free;
   }
 
-  unsigned getIntImmCost(Intrinsic::ID IID, unsigned Idx, const APInt &Imm,
-                         Type *Ty) {
+  unsigned getIntImmCostIntrin(Intrinsic::ID IID, unsigned Idx,
+                               const APInt &Imm, Type *Ty,
+                               TTI::TargetCostKind CostKind) const {
     return TTI::TCC_Free;
   }
 
-  unsigned getNumberOfRegisters(bool Vector) { return 8; }
+  unsigned getNumberOfRegisters(unsigned ClassID) const { return 8; }
+
+  unsigned getRegisterClassForType(bool Vector, Type *Ty = nullptr) const {
+    return Vector ? 1 : 0;
+  };
+
+  const char *getRegisterClassName(unsigned ClassID) const {
+    switch (ClassID) {
+    default:
+      return "Generic::Unknown Register Class";
+    case 0:
+      return "Generic::ScalarRC";
+    case 1:
+      return "Generic::VectorRC";
+    }
+  }
 
   unsigned getRegisterBitWidth(bool Vector) const { return 32; }
 
-  unsigned getMinVectorRegisterBitWidth() { return 128; }
+  unsigned getMinVectorRegisterBitWidth() const { return 128; }
+
+  Optional<unsigned> getMaxVScale() const { return None; }
 
   bool shouldMaximizeVectorBandwidth(bool OptSize) const { return false; }
 
   unsigned getMinimumVF(unsigned ElemWidth) const { return 0; }
 
-  bool
-  shouldConsiderAddressTypePromotion(const Instruction &I,
-                                     bool &AllowPromotionWithoutCommonHeader) {
+  unsigned getMaximumVF(unsigned ElemWidth, unsigned Opcode) const { return 0; }
+
+  bool shouldConsiderAddressTypePromotion(
+      const Instruction &I, bool &AllowPromotionWithoutCommonHeader) const {
     AllowPromotionWithoutCommonHeader = false;
     return false;
   }
 
-  unsigned getCacheLineSize() { return 0; }
+  unsigned getCacheLineSize() const { return 0; }
 
-  llvm::Optional<unsigned> getCacheSize(TargetTransformInfo::CacheLevel Level) {
+  llvm::Optional<unsigned>
+  getCacheSize(TargetTransformInfo::CacheLevel Level) const {
+    switch (Level) {
+    case TargetTransformInfo::CacheLevel::L1D:
+      LLVM_FALLTHROUGH;
+    case TargetTransformInfo::CacheLevel::L2D:
+      return llvm::Optional<unsigned>();
+    }
+    llvm_unreachable("Unknown TargetTransformInfo::CacheLevel");
+  }
+
+  llvm::Optional<unsigned>
+  getCacheAssociativity(TargetTransformInfo::CacheLevel Level) const {
     switch (Level) {
     case TargetTransformInfo::CacheLevel::L1D:
       LLVM_FALLTHROUGH;
@@ -376,112 +408,202 @@
     llvm_unreachable("Unknown TargetTransformInfo::CacheLevel");
   }
 
-  llvm::Optional<unsigned> getCacheAssociativity(
-    TargetTransformInfo::CacheLevel Level) {
-    switch (Level) {
-    case TargetTransformInfo::CacheLevel::L1D:
-      LLVM_FALLTHROUGH;
-    case TargetTransformInfo::CacheLevel::L2D:
-      return llvm::Optional<unsigned>();
-    }
-
-    llvm_unreachable("Unknown TargetTransformInfo::CacheLevel");
+  unsigned getPrefetchDistance() const { return 0; }
+  unsigned getMinPrefetchStride(unsigned NumMemAccesses,
+                                unsigned NumStridedMemAccesses,
+                                unsigned NumPrefetches, bool HasCall) const {
+    return 1;
   }
+  unsigned getMaxPrefetchIterationsAhead() const { return UINT_MAX; }
+  bool enableWritePrefetching() const { return false; }
 
-  unsigned getPrefetchDistance() { return 0; }
-
-  unsigned getMinPrefetchStride() { return 1; }
-
-  unsigned getMaxPrefetchIterationsAhead() { return UINT_MAX; }
-
-  unsigned getMaxInterleaveFactor(unsigned VF) { return 1; }
+  unsigned getMaxInterleaveFactor(unsigned VF) const { return 1; }
 
   unsigned getArithmeticInstrCost(unsigned Opcode, Type *Ty,
+                                  TTI::TargetCostKind CostKind,
                                   TTI::OperandValueKind Opd1Info,
                                   TTI::OperandValueKind Opd2Info,
                                   TTI::OperandValueProperties Opd1PropInfo,
                                   TTI::OperandValueProperties Opd2PropInfo,
-                                  ArrayRef<const Value *> Args) {
+                                  ArrayRef<const Value *> Args,
+                                  const Instruction *CxtI = nullptr) const {
+    // FIXME: A number of transformation tests seem to require these values
+    // which seems a little odd for how arbitary there are.
+    switch (Opcode) {
+    default:
+      break;
+    case Instruction::FDiv:
+    case Instruction::FRem:
+    case Instruction::SDiv:
+    case Instruction::SRem:
+    case Instruction::UDiv:
+    case Instruction::URem:
+      // FIXME: Unlikely to be true for CodeSize.
+      return TTI::TCC_Expensive;
+    }
     return 1;
   }
 
-  unsigned getShuffleCost(TTI::ShuffleKind Kind, Type *Ty, int Index,
-                          Type *SubTp) {
+  unsigned getShuffleCost(TTI::ShuffleKind Kind, VectorType *Ty, int Index,
+                          VectorType *SubTp) const {
     return 1;
   }
 
   unsigned getCastInstrCost(unsigned Opcode, Type *Dst, Type *Src,
-                            const Instruction *I) { return 1; }
+                            TTI::CastContextHint CCH,
+                            TTI::TargetCostKind CostKind,
+                            const Instruction *I) const {
+    switch (Opcode) {
+    default:
+      break;
+    case Instruction::IntToPtr: {
+      unsigned SrcSize = Src->getScalarSizeInBits();
+      if (DL.isLegalInteger(SrcSize) &&
+          SrcSize <= DL.getPointerTypeSizeInBits(Dst))
+        return 0;
+      break;
+    }
+    case Instruction::PtrToInt: {
+      unsigned DstSize = Dst->getScalarSizeInBits();
+      if (DL.isLegalInteger(DstSize) &&
+          DstSize >= DL.getPointerTypeSizeInBits(Src))
+        return 0;
+      break;
+    }
+    case Instruction::BitCast:
+      if (Dst == Src || (Dst->isPointerTy() && Src->isPointerTy()))
+        // Identity and pointer-to-pointer casts are free.
+        return 0;
+      break;
+    case Instruction::Trunc: {
+      // trunc to a native type is free (assuming the target has compare and
+      // shift-right of the same width).
+      TypeSize DstSize = DL.getTypeSizeInBits(Dst);
+      if (!DstSize.isScalable() && DL.isLegalInteger(DstSize.getFixedSize()))
+        return 0;
+      break;
+    }
+    }
+    return 1;
+  }
 
   unsigned getExtractWithExtendCost(unsigned Opcode, Type *Dst,
-                                    VectorType *VecTy, unsigned Index) {
+                                    VectorType *VecTy, unsigned Index) const {
     return 1;
   }
 
-  unsigned getCFInstrCost(unsigned Opcode) { return 1; }
+  unsigned getCFInstrCost(unsigned Opcode, TTI::TargetCostKind CostKind) const {
+    // A phi would be free, unless we're costing the throughput because it
+    // will require a register.
+    if (Opcode == Instruction::PHI && CostKind != TTI::TCK_RecipThroughput)
+      return 0;
+    return 1;
+  }
 
   unsigned getCmpSelInstrCost(unsigned Opcode, Type *ValTy, Type *CondTy,
-                              const Instruction *I) {
+                              CmpInst::Predicate VecPred,
+                              TTI::TargetCostKind CostKind,
+                              const Instruction *I) const {
     return 1;
   }
 
-  unsigned getVectorInstrCost(unsigned Opcode, Type *Val, unsigned Index) {
+  unsigned getVectorInstrCost(unsigned Opcode, Type *Val,
+                              unsigned Index) const {
     return 1;
   }
 
-  unsigned getMemoryOpCost(unsigned Opcode, Type *Src, unsigned Alignment,
-                           unsigned AddressSpace, const Instruction *I) {
+  unsigned getMemoryOpCost(unsigned Opcode, Type *Src, Align Alignment,
+                           unsigned AddressSpace, TTI::TargetCostKind CostKind,
+                           const Instruction *I) const {
     return 1;
   }
 
-  unsigned getMaskedMemoryOpCost(unsigned Opcode, Type *Src, unsigned Alignment,
-                                 unsigned AddressSpace) {
+  unsigned getMaskedMemoryOpCost(unsigned Opcode, Type *Src, Align Alignment,
+                                 unsigned AddressSpace,
+                                 TTI::TargetCostKind CostKind) const {
     return 1;
   }
 
-  unsigned getGatherScatterOpCost(unsigned Opcode, Type *DataTy, Value *Ptr,
-                                  bool VariableMask,
-                                  unsigned Alignment) {
+  unsigned getGatherScatterOpCost(unsigned Opcode, Type *DataTy,
+                                  const Value *Ptr, bool VariableMask,
+                                  Align Alignment, TTI::TargetCostKind CostKind,
+                                  const Instruction *I = nullptr) const {
     return 1;
   }
 
-  unsigned getInterleavedMemoryOpCost(unsigned Opcode, Type *VecTy,
-                                      unsigned Factor,
-                                      ArrayRef<unsigned> Indices,
-                                      unsigned Alignment, unsigned AddressSpace,
-                                      bool UseMaskForCond = false,
-                                      bool UseMaskForGaps = false) {
+  unsigned getInterleavedMemoryOpCost(
+      unsigned Opcode, Type *VecTy, unsigned Factor, ArrayRef<unsigned> Indices,
+      Align Alignment, unsigned AddressSpace, TTI::TargetCostKind CostKind,
+      bool UseMaskForCond, bool UseMaskForGaps) const {
     return 1;
   }
 
-  unsigned getIntrinsicInstrCost(Intrinsic::ID ID, Type *RetTy,
-                                 ArrayRef<Type *> Tys, FastMathFlags FMF,
-                                 unsigned ScalarizationCostPassed) {
-    return 1;
-  }
-  unsigned getIntrinsicInstrCost(Intrinsic::ID ID, Type *RetTy,
-            ArrayRef<Value *> Args, FastMathFlags FMF, unsigned VF) {
+  unsigned getIntrinsicInstrCost(const IntrinsicCostAttributes &ICA,
+                                 TTI::TargetCostKind CostKind) const {
+    switch (ICA.getID()) {
+    default:
+      break;
+    case Intrinsic::annotation:
+    case Intrinsic::assume:
+    case Intrinsic::sideeffect:
+    case Intrinsic::pseudoprobe:
+    case Intrinsic::dbg_declare:
+    case Intrinsic::dbg_value:
+    case Intrinsic::dbg_label:
+    case Intrinsic::invariant_start:
+    case Intrinsic::invariant_end:
+    case Intrinsic::launder_invariant_group:
+    case Intrinsic::strip_invariant_group:
+    case Intrinsic::is_constant:
+    case Intrinsic::lifetime_start:
+    case Intrinsic::lifetime_end:
+    case Intrinsic::objectsize:
+    case Intrinsic::ptr_annotation:
+    case Intrinsic::var_annotation:
+    case Intrinsic::experimental_gc_result:
+    case Intrinsic::experimental_gc_relocate:
+    case Intrinsic::coro_alloc:
+    case Intrinsic::coro_begin:
+    case Intrinsic::coro_free:
+    case Intrinsic::coro_end:
+    case Intrinsic::coro_frame:
+    case Intrinsic::coro_size:
+    case Intrinsic::coro_suspend:
+    case Intrinsic::coro_param:
+    case Intrinsic::coro_subfn_addr:
+      // These intrinsics don't actually represent code after lowering.
+      return 0;
+    }
     return 1;
   }
 
-  unsigned getCallInstrCost(Function *F, Type *RetTy, ArrayRef<Type *> Tys) {
+  unsigned getCallInstrCost(Function *F, Type *RetTy, ArrayRef<Type *> Tys,
+                            TTI::TargetCostKind CostKind) const {
     return 1;
   }
 
-  unsigned getNumberOfParts(Type *Tp) { return 0; }
+  unsigned getNumberOfParts(Type *Tp) const { return 0; }
 
   unsigned getAddressComputationCost(Type *Tp, ScalarEvolution *,
-                                     const SCEV *) {
+                                     const SCEV *) const {
     return 0;
   }
 
-  unsigned getArithmeticReductionCost(unsigned, Type *, bool) { return 1; }
+  unsigned getArithmeticReductionCost(unsigned, VectorType *, bool,
+                                      TTI::TargetCostKind) const {
+    return 1;
+  }
 
-  unsigned getMinMaxReductionCost(Type *, Type *, bool, bool) { return 1; }
+  unsigned getMinMaxReductionCost(VectorType *, VectorType *, bool, bool,
+                                  TTI::TargetCostKind) const {
+    return 1;
+  }
 
-  unsigned getCostOfKeepingLiveOverCall(ArrayRef<Type *> Tys) { return 0; }
+  unsigned getCostOfKeepingLiveOverCall(ArrayRef<Type *> Tys) const {
+    return 0;
+  }
 
-  bool getTgtMemIntrinsic(IntrinsicInst *Inst, MemIntrinsicInfo &Info) {
+  bool getTgtMemIntrinsic(IntrinsicInst *Inst, MemIntrinsicInfo &Info) const {
     return false;
   }
 
@@ -495,20 +617,20 @@
   }
 
   Value *getOrCreateResultFromMemIntrinsic(IntrinsicInst *Inst,
-                                           Type *ExpectedType) {
+                                           Type *ExpectedType) const {
     return nullptr;
   }
 
   Type *getMemcpyLoopLoweringType(LLVMContext &Context, Value *Length,
+                                  unsigned SrcAddrSpace, unsigned DestAddrSpace,
                                   unsigned SrcAlign, unsigned DestAlign) const {
     return Type::getInt8Ty(Context);
   }
 
-  void getMemcpyLoopResidualLoweringType(SmallVectorImpl<Type *> &OpsOut,
-                                         LLVMContext &Context,
-                                         unsigned RemainingBytes,
-                                         unsigned SrcAlign,
-                                         unsigned DestAlign) const {
+  void getMemcpyLoopResidualLoweringType(
+      SmallVectorImpl<Type *> &OpsOut, LLVMContext &Context,
+      unsigned RemainingBytes, unsigned SrcAddrSpace, unsigned DestAddrSpace,
+      unsigned SrcAlign, unsigned DestAlign) const {
     for (unsigned i = 0; i != RemainingBytes; ++i)
       OpsOut.push_back(Type::getInt8Ty(Context));
   }
@@ -521,7 +643,8 @@
             Callee->getFnAttribute("target-features"));
   }
 
-  bool areFunctionArgsABICompatible(const Function *Caller, const Function *Callee,
+  bool areFunctionArgsABICompatible(const Function *Caller,
+                                    const Function *Callee,
                                     SmallPtrSetImpl<Argument *> &Args) const {
     return (Caller->getFnAttribute("target-cpu") ==
             Callee->getFnAttribute("target-cpu")) &&
@@ -545,14 +668,12 @@
 
   bool isLegalToVectorizeStore(StoreInst *SI) const { return true; }
 
-  bool isLegalToVectorizeLoadChain(unsigned ChainSizeInBytes,
-                                   unsigned Alignment,
+  bool isLegalToVectorizeLoadChain(unsigned ChainSizeInBytes, Align Alignment,
                                    unsigned AddrSpace) const {
     return true;
   }
 
-  bool isLegalToVectorizeStoreChain(unsigned ChainSizeInBytes,
-                                    unsigned Alignment,
+  bool isLegalToVectorizeStoreChain(unsigned ChainSizeInBytes, Align Alignment,
                                     unsigned AddrSpace) const {
     return true;
   }
@@ -574,46 +695,55 @@
     return false;
   }
 
-  bool shouldExpandReduction(const IntrinsicInst *II) const {
-    return true;
+  bool preferInLoopReduction(unsigned Opcode, Type *Ty,
+                             TTI::ReductionFlags Flags) const {
+    return false;
   }
 
-  unsigned getGISelRematGlobalCost() const {
-    return 1;
+  bool preferPredicatedReductionSelect(unsigned Opcode, Type *Ty,
+                                       TTI::ReductionFlags Flags) const {
+    return false;
   }
 
+  bool shouldExpandReduction(const IntrinsicInst *II) const { return true; }
+
+  unsigned getGISelRematGlobalCost() const { return 1; }
+
+  bool supportsScalableVectors() const { return false; }
+
+  bool hasActiveVectorLength() const { return false; }
+
 protected:
   // Obtain the minimum required size to hold the value (without the sign)
   // In case of a vector it returns the min required size for one element.
-  unsigned minRequiredElementSize(const Value* Val, bool &isSigned) {
+  unsigned minRequiredElementSize(const Value *Val, bool &isSigned) const {
     if (isa<ConstantDataVector>(Val) || isa<ConstantVector>(Val)) {
-      const auto* VectorValue = cast<Constant>(Val);
+      const auto *VectorValue = cast<Constant>(Val);
 
       // In case of a vector need to pick the max between the min
       // required size for each element
-      auto *VT = cast<VectorType>(Val->getType());
+      auto *VT = cast<FixedVectorType>(Val->getType());
 
       // Assume unsigned elements
       isSigned = false;
 
-      // The max required size is the total vector width divided by num
-      // of elements in the vector
-      unsigned MaxRequiredSize = VT->getBitWidth() / VT->getNumElements();
+      // The max required size is the size of the vector element type
+      unsigned MaxRequiredSize =
+          VT->getElementType()->getPrimitiveSizeInBits().getFixedSize();
 
       unsigned MinRequiredSize = 0;
-      for(unsigned i = 0, e = VT->getNumElements(); i < e; ++i) {
-        if (auto* IntElement =
-              dyn_cast<ConstantInt>(VectorValue->getAggregateElement(i))) {
+      for (unsigned i = 0, e = VT->getNumElements(); i < e; ++i) {
+        if (auto *IntElement =
+                dyn_cast<ConstantInt>(VectorValue->getAggregateElement(i))) {
           bool signedElement = IntElement->getValue().isNegative();
           // Get the element min required size.
           unsigned ElementMinRequiredSize =
-            IntElement->getValue().getMinSignedBits() - 1;
+              IntElement->getValue().getMinSignedBits() - 1;
           // In case one element is signed then all the vector is signed.
           isSigned |= signedElement;
           // Save the max required bit size between all the elements.
           MinRequiredSize = std::max(MinRequiredSize, ElementMinRequiredSize);
-        }
-        else {
+        } else {
           // not an int constant element
           return MaxRequiredSize;
         }
@@ -621,17 +751,17 @@
       return MinRequiredSize;
     }
 
-    if (const auto* CI = dyn_cast<ConstantInt>(Val)) {
+    if (const auto *CI = dyn_cast<ConstantInt>(Val)) {
       isSigned = CI->getValue().isNegative();
       return CI->getValue().getMinSignedBits() - 1;
     }
 
-    if (const auto* Cast = dyn_cast<SExtInst>(Val)) {
+    if (const auto *Cast = dyn_cast<SExtInst>(Val)) {
       isSigned = true;
       return Cast->getSrcTy()->getScalarSizeInBits() - 1;
     }
 
-    if (const auto* Cast = dyn_cast<ZExtInst>(Val)) {
+    if (const auto *Cast = dyn_cast<ZExtInst>(Val)) {
       isSigned = false;
       return Cast->getSrcTy()->getScalarSizeInBits();
     }
@@ -640,12 +770,12 @@
     return Val->getType()->getScalarSizeInBits();
   }
 
-  bool isStridedAccess(const SCEV *Ptr) {
+  bool isStridedAccess(const SCEV *Ptr) const {
     return Ptr && isa<SCEVAddRecExpr>(Ptr);
   }
 
   const SCEVConstant *getConstantStrideStep(ScalarEvolution *SE,
-                                            const SCEV *Ptr) {
+                                            const SCEV *Ptr) const {
     if (!isStridedAccess(Ptr))
       return nullptr;
     const SCEVAddRecExpr *AddRec = cast<SCEVAddRecExpr>(Ptr);
@@ -653,7 +783,7 @@
   }
 
   bool isConstantStridedAccessLessThan(ScalarEvolution *SE, const SCEV *Ptr,
-                                       int64_t MergeDistance) {
+                                       int64_t MergeDistance) const {
     const SCEVConstant *Step = getConstantStrideStep(SE, Ptr);
     if (!Step)
       return false;
@@ -676,42 +806,11 @@
   explicit TargetTransformInfoImplCRTPBase(const DataLayout &DL) : BaseT(DL) {}
 
 public:
-  using BaseT::getCallCost;
-
-  unsigned getCallCost(const Function *F, int NumArgs, const User *U) {
-    assert(F && "A concrete function must be provided to this routine.");
-
-    if (NumArgs < 0)
-      // Set the argument number to the number of explicit arguments in the
-      // function.
-      NumArgs = F->arg_size();
-
-    if (Intrinsic::ID IID = F->getIntrinsicID()) {
-      FunctionType *FTy = F->getFunctionType();
-      SmallVector<Type *, 8> ParamTys(FTy->param_begin(), FTy->param_end());
-      return static_cast<T *>(this)
-          ->getIntrinsicCost(IID, FTy->getReturnType(), ParamTys, U);
-    }
-
-    if (!static_cast<T *>(this)->isLoweredToCall(F))
-      return TTI::TCC_Basic; // Give a basic cost if it will be lowered
-                             // directly.
-
-    return static_cast<T *>(this)->getCallCost(F->getFunctionType(), NumArgs, U);
-  }
-
-  unsigned getCallCost(const Function *F, ArrayRef<const Value *> Arguments,
-                       const User *U) {
-    // Simply delegate to generic handling of the call.
-    // FIXME: We should use instsimplify or something else to catch calls which
-    // will constant fold with these arguments.
-    return static_cast<T *>(this)->getCallCost(F, Arguments.size(), U);
-  }
-
   using BaseT::getGEPCost;
 
   int getGEPCost(Type *PointeeType, const Value *Ptr,
-                 ArrayRef<const Value *> Operands) {
+                 ArrayRef<const Value *> Operands,
+                 TTI::TargetCostKind CostKind = TTI::TCK_SizeAndLatency) {
     assert(PointeeType && Ptr && "can't get GEPCost of nullptr");
     // TODO: will remove this when pointers have an opaque type.
     assert(Ptr->getType()->getScalarType()->getPointerElementType() ==
@@ -746,7 +845,12 @@
         uint64_t Field = ConstIdx->getZExtValue();
         BaseOffset += DL.getStructLayout(STy)->getElementOffset(Field);
       } else {
-        int64_t ElementSize = DL.getTypeAllocSize(GTI.getIndexedType());
+        // If this operand is a scalable type, bail out early.
+        // TODO: handle scalable vectors
+        if (isa<ScalableVectorType>(TargetType))
+          return TTI::TCC_Basic;
+        int64_t ElementSize =
+            DL.getTypeAllocSize(GTI.getIndexedType()).getFixedSize();
         if (ConstIdx) {
           BaseOffset +=
               ConstIdx->getValue().sextOrTrunc(PtrSizeBits) * ElementSize;
@@ -768,105 +872,207 @@
     return TTI::TCC_Basic;
   }
 
-  unsigned getIntrinsicCost(Intrinsic::ID IID, Type *RetTy,
-                            ArrayRef<Type *> ParamTys, const User *U) {
-    switch (IID) {
-    default:
-      // Intrinsics rarely (if ever) have normal argument setup constraints.
-      // Model them as having a basic instruction cost.
-      return TTI::TCC_Basic;
+  int getUserCost(const User *U, ArrayRef<const Value *> Operands,
+                  TTI::TargetCostKind CostKind) {
+    auto *TargetTTI = static_cast<T *>(this);
+    // Handle non-intrinsic calls, invokes, and callbr.
+    // FIXME: Unlikely to be true for anything but CodeSize.
+    auto *CB = dyn_cast<CallBase>(U);
+    if (CB && !isa<IntrinsicInst>(U)) {
+      if (const Function *F = CB->getCalledFunction()) {
+        if (!TargetTTI->isLoweredToCall(F))
+          return TTI::TCC_Basic; // Give a basic cost if it will be lowered
 
-    // TODO: other libc intrinsics.
-    case Intrinsic::memcpy:
-      return static_cast<T *>(this)->getMemcpyCost(dyn_cast<Instruction>(U));
-
-    case Intrinsic::annotation:
-    case Intrinsic::assume:
-    case Intrinsic::sideeffect:
-    case Intrinsic::dbg_declare:
-    case Intrinsic::dbg_value:
-    case Intrinsic::dbg_label:
-    case Intrinsic::invariant_start:
-    case Intrinsic::invariant_end:
-    case Intrinsic::launder_invariant_group:
-    case Intrinsic::strip_invariant_group:
-    case Intrinsic::is_constant:
-    case Intrinsic::lifetime_start:
-    case Intrinsic::lifetime_end:
-    case Intrinsic::objectsize:
-    case Intrinsic::ptr_annotation:
-    case Intrinsic::var_annotation:
-    case Intrinsic::experimental_gc_result:
-    case Intrinsic::experimental_gc_relocate:
-    case Intrinsic::coro_alloc:
-    case Intrinsic::coro_begin:
-    case Intrinsic::coro_free:
-    case Intrinsic::coro_end:
-    case Intrinsic::coro_frame:
-    case Intrinsic::coro_size:
-    case Intrinsic::coro_suspend:
-    case Intrinsic::coro_param:
-    case Intrinsic::coro_subfn_addr:
-      // These intrinsics don't actually represent code after lowering.
-      return TTI::TCC_Free;
-    }
-  }
-
-  unsigned getIntrinsicCost(Intrinsic::ID IID, Type *RetTy,
-                            ArrayRef<const Value *> Arguments, const User *U) {
-    // Delegate to the generic intrinsic handling code. This mostly provides an
-    // opportunity for targets to (for example) special case the cost of
-    // certain intrinsics based on constants used as arguments.
-    SmallVector<Type *, 8> ParamTys;
-    ParamTys.reserve(Arguments.size());
-    for (unsigned Idx = 0, Size = Arguments.size(); Idx != Size; ++Idx)
-      ParamTys.push_back(Arguments[Idx]->getType());
-    return static_cast<T *>(this)->getIntrinsicCost(IID, RetTy, ParamTys, U);
-  }
-
-  unsigned getUserCost(const User *U, ArrayRef<const Value *> Operands) {
-    if (isa<PHINode>(U))
-      return TTI::TCC_Free; // Model all PHI nodes as free.
-
-    // Static alloca doesn't generate target instructions.
-    if (auto *A = dyn_cast<AllocaInst>(U))
-      if (A->isStaticAlloca())
-        return TTI::TCC_Free;
-
-    if (const GEPOperator *GEP = dyn_cast<GEPOperator>(U)) {
-      return static_cast<T *>(this)->getGEPCost(GEP->getSourceElementType(),
-                                                GEP->getPointerOperand(),
-                                                Operands.drop_front());
-    }
-
-    if (auto CS = ImmutableCallSite(U)) {
-      const Function *F = CS.getCalledFunction();
-      if (!F) {
-        // Just use the called value type.
-        Type *FTy = CS.getCalledValue()->getType()->getPointerElementType();
-        return static_cast<T *>(this)
-            ->getCallCost(cast<FunctionType>(FTy), CS.arg_size(), U);
+        return TTI::TCC_Basic * (F->getFunctionType()->getNumParams() + 1);
       }
-
-      SmallVector<const Value *, 8> Arguments(CS.arg_begin(), CS.arg_end());
-      return static_cast<T *>(this)->getCallCost(F, Arguments, U);
+      // For indirect or other calls, scale cost by number of arguments.
+      return TTI::TCC_Basic * (CB->arg_size() + 1);
     }
 
-    if (isa<SExtInst>(U) || isa<ZExtInst>(U) || isa<FPExtInst>(U))
-      // The old behaviour of generally treating extensions of icmp to be free
-      // has been removed. A target that needs it should override getUserCost().
-      return static_cast<T *>(this)->getExtCost(cast<Instruction>(U),
-                                                Operands.back());
+    Type *Ty = U->getType();
+    Type *OpTy =
+      U->getNumOperands() == 1 ? U->getOperand(0)->getType() : nullptr;
+    unsigned Opcode = Operator::getOpcode(U);
+    auto *I = dyn_cast<Instruction>(U);
+    switch (Opcode) {
+    default:
+      break;
+    case Instruction::Call: {
+      assert(isa<IntrinsicInst>(U) && "Unexpected non-intrinsic call");
+      auto *Intrinsic = cast<IntrinsicInst>(U);
+      IntrinsicCostAttributes CostAttrs(Intrinsic->getIntrinsicID(), *CB);
+      return TargetTTI->getIntrinsicInstrCost(CostAttrs, CostKind);
+    }
+    case Instruction::Br:
+    case Instruction::Ret:
+    case Instruction::PHI:
+      return TargetTTI->getCFInstrCost(Opcode, CostKind);
+    case Instruction::ExtractValue:
+    case Instruction::Freeze:
+      return TTI::TCC_Free;
+    case Instruction::Alloca:
+      if (cast<AllocaInst>(U)->isStaticAlloca())
+        return TTI::TCC_Free;
+      break;
+    case Instruction::GetElementPtr: {
+      const GEPOperator *GEP = cast<GEPOperator>(U);
+      return TargetTTI->getGEPCost(GEP->getSourceElementType(),
+                                   GEP->getPointerOperand(),
+                                   Operands.drop_front());
+    }
+    case Instruction::Add:
+    case Instruction::FAdd:
+    case Instruction::Sub:
+    case Instruction::FSub:
+    case Instruction::Mul:
+    case Instruction::FMul:
+    case Instruction::UDiv:
+    case Instruction::SDiv:
+    case Instruction::FDiv:
+    case Instruction::URem:
+    case Instruction::SRem:
+    case Instruction::FRem:
+    case Instruction::Shl:
+    case Instruction::LShr:
+    case Instruction::AShr:
+    case Instruction::And:
+    case Instruction::Or:
+    case Instruction::Xor:
+    case Instruction::FNeg: {
+      TTI::OperandValueProperties Op1VP = TTI::OP_None;
+      TTI::OperandValueProperties Op2VP = TTI::OP_None;
+      TTI::OperandValueKind Op1VK =
+        TTI::getOperandInfo(U->getOperand(0), Op1VP);
+      TTI::OperandValueKind Op2VK = Opcode != Instruction::FNeg ?
+        TTI::getOperandInfo(U->getOperand(1), Op2VP) : TTI::OK_AnyValue;
+      SmallVector<const Value *, 2> Operands(U->operand_values());
+      return TargetTTI->getArithmeticInstrCost(Opcode, Ty, CostKind,
+                                               Op1VK, Op2VK,
+                                               Op1VP, Op2VP, Operands, I);
+    }
+    case Instruction::IntToPtr:
+    case Instruction::PtrToInt:
+    case Instruction::SIToFP:
+    case Instruction::UIToFP:
+    case Instruction::FPToUI:
+    case Instruction::FPToSI:
+    case Instruction::Trunc:
+    case Instruction::FPTrunc:
+    case Instruction::BitCast:
+    case Instruction::FPExt:
+    case Instruction::SExt:
+    case Instruction::ZExt:
+    case Instruction::AddrSpaceCast:
+      return TargetTTI->getCastInstrCost(
+          Opcode, Ty, OpTy, TTI::getCastContextHint(I), CostKind, I);
+    case Instruction::Store: {
+      auto *SI = cast<StoreInst>(U);
+      Type *ValTy = U->getOperand(0)->getType();
+      return TargetTTI->getMemoryOpCost(Opcode, ValTy, SI->getAlign(),
+                                        SI->getPointerAddressSpace(),
+                                        CostKind, I);
+    }
+    case Instruction::Load: {
+      auto *LI = cast<LoadInst>(U);
+      return TargetTTI->getMemoryOpCost(Opcode, U->getType(), LI->getAlign(),
+                                        LI->getPointerAddressSpace(),
+                                        CostKind, I);
+    }
+    case Instruction::Select: {
+      Type *CondTy = U->getOperand(0)->getType();
+      return TargetTTI->getCmpSelInstrCost(Opcode, U->getType(), CondTy,
+                                           CmpInst::BAD_ICMP_PREDICATE,
+                                           CostKind, I);
+    }
+    case Instruction::ICmp:
+    case Instruction::FCmp: {
+      Type *ValTy = U->getOperand(0)->getType();
+      // TODO: Also handle ICmp/FCmp constant expressions.
+      return TargetTTI->getCmpSelInstrCost(Opcode, ValTy, U->getType(),
+                                           I ? cast<CmpInst>(I)->getPredicate()
+                                             : CmpInst::BAD_ICMP_PREDICATE,
+                                           CostKind, I);
+    }
+    case Instruction::InsertElement: {
+      auto *IE = dyn_cast<InsertElementInst>(U);
+      if (!IE)
+        return TTI::TCC_Basic; // FIXME
+      auto *CI = dyn_cast<ConstantInt>(IE->getOperand(2));
+      unsigned Idx = CI ? CI->getZExtValue() : -1;
+      return TargetTTI->getVectorInstrCost(Opcode, Ty, Idx);
+    }
+    case Instruction::ShuffleVector: {
+      auto *Shuffle = dyn_cast<ShuffleVectorInst>(U);
+      if (!Shuffle)
+        return TTI::TCC_Basic; // FIXME
+      auto *VecTy = cast<VectorType>(U->getType());
+      auto *VecSrcTy = cast<VectorType>(U->getOperand(0)->getType());
 
-    return static_cast<T *>(this)->getOperationCost(
-        Operator::getOpcode(U), U->getType(),
-        U->getNumOperands() == 1 ? U->getOperand(0)->getType() : nullptr);
+      // TODO: Identify and add costs for insert subvector, etc.
+      int SubIndex;
+      if (Shuffle->isExtractSubvectorMask(SubIndex))
+        return TargetTTI->getShuffleCost(TTI::SK_ExtractSubvector, VecSrcTy,
+                                         SubIndex, VecTy);
+      else if (Shuffle->changesLength())
+        return CostKind == TTI::TCK_RecipThroughput ? -1 : 1;
+      else if (Shuffle->isIdentity())
+        return 0;
+      else if (Shuffle->isReverse())
+        return TargetTTI->getShuffleCost(TTI::SK_Reverse, VecTy, 0, nullptr);
+      else if (Shuffle->isSelect())
+        return TargetTTI->getShuffleCost(TTI::SK_Select, VecTy, 0, nullptr);
+      else if (Shuffle->isTranspose())
+        return TargetTTI->getShuffleCost(TTI::SK_Transpose, VecTy, 0, nullptr);
+      else if (Shuffle->isZeroEltSplat())
+        return TargetTTI->getShuffleCost(TTI::SK_Broadcast, VecTy, 0, nullptr);
+      else if (Shuffle->isSingleSource())
+        return TargetTTI->getShuffleCost(TTI::SK_PermuteSingleSrc, VecTy, 0,
+                                         nullptr);
+
+      return TargetTTI->getShuffleCost(TTI::SK_PermuteTwoSrc, VecTy, 0,
+                                       nullptr);
+    }
+    case Instruction::ExtractElement: {
+      unsigned Idx = -1;
+      auto *EEI = dyn_cast<ExtractElementInst>(U);
+      if (!EEI)
+        return TTI::TCC_Basic; // FIXME
+
+      auto *CI = dyn_cast<ConstantInt>(EEI->getOperand(1));
+      if (CI)
+        Idx = CI->getZExtValue();
+
+      // Try to match a reduction (a series of shufflevector and vector ops
+      // followed by an extractelement).
+      unsigned RdxOpcode;
+      VectorType *RdxType;
+      bool IsPairwise;
+      switch (TTI::matchVectorReduction(EEI, RdxOpcode, RdxType, IsPairwise)) {
+      case TTI::RK_Arithmetic:
+        return TargetTTI->getArithmeticReductionCost(RdxOpcode, RdxType,
+                                                     IsPairwise, CostKind);
+      case TTI::RK_MinMax:
+        return TargetTTI->getMinMaxReductionCost(
+            RdxType, cast<VectorType>(CmpInst::makeCmpResultType(RdxType)),
+            IsPairwise, /*IsUnsigned=*/false, CostKind);
+      case TTI::RK_UnsignedMinMax:
+        return TargetTTI->getMinMaxReductionCost(
+            RdxType, cast<VectorType>(CmpInst::makeCmpResultType(RdxType)),
+            IsPairwise, /*IsUnsigned=*/true, CostKind);
+      case TTI::RK_None:
+        break;
+      }
+      return TargetTTI->getVectorInstrCost(Opcode, U->getOperand(0)->getType(),
+                                           Idx);
+    }
+    }
+    // By default, just classify everything as 'basic'.
+    return TTI::TCC_Basic;
   }
 
   int getInstructionLatency(const Instruction *I) {
-    SmallVector<const Value *, 4> Operands(I->value_op_begin(),
-                                           I->value_op_end());
-    if (getUserCost(I, Operands) == TTI::TCC_Free)
+    SmallVector<const Value *, 4> Operands(I->operand_values());
+    if (getUserCost(I, Operands, TTI::TCK_Latency) == TTI::TCC_Free)
       return 0;
 
     if (isa<LoadInst>(I))
@@ -882,7 +1088,7 @@
         return 40;
       // Some intrinsics return a value and a flag, we use the value type
       // to decide its latency.
-      if (StructType* StructTy = dyn_cast<StructType>(DstTy))
+      if (StructType *StructTy = dyn_cast<StructType>(DstTy))
         DstTy = StructTy->getElementType(0);
       // Fall through to simple instructions.
     }
@@ -895,6 +1101,6 @@
     return 1;
   }
 };
-}
+} // namespace llvm
 
 #endif
diff --git a/linux-x64/clang/include/llvm/Analysis/TypeBasedAliasAnalysis.h b/linux-x64/clang/include/llvm/Analysis/TypeBasedAliasAnalysis.h
index 344f268..345f11a 100644
--- a/linux-x64/clang/include/llvm/Analysis/TypeBasedAliasAnalysis.h
+++ b/linux-x64/clang/include/llvm/Analysis/TypeBasedAliasAnalysis.h
@@ -16,13 +16,13 @@
 #define LLVM_ANALYSIS_TYPEBASEDALIASANALYSIS_H
 
 #include "llvm/Analysis/AliasAnalysis.h"
-#include "llvm/IR/InstrTypes.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/Pass.h"
 #include <memory>
 
 namespace llvm {
 
+class CallBase;
 class Function;
 class MDNode;
 class MemoryLocation;
@@ -53,7 +53,6 @@
 
 private:
   bool Aliases(const MDNode *A, const MDNode *B) const;
-  bool PathAliases(const MDNode *A, const MDNode *B) const;
 };
 
 /// Analysis pass providing a never-invalidated alias analysis result.
diff --git a/linux-x64/clang/include/llvm/Analysis/TypeMetadataUtils.h b/linux-x64/clang/include/llvm/Analysis/TypeMetadataUtils.h
index 82cf8ef..3f76031 100644
--- a/linux-x64/clang/include/llvm/Analysis/TypeMetadataUtils.h
+++ b/linux-x64/clang/include/llvm/Analysis/TypeMetadataUtils.h
@@ -15,11 +15,16 @@
 #define LLVM_ANALYSIS_TYPEMETADATAUTILS_H
 
 #include "llvm/ADT/SmallVector.h"
-#include "llvm/IR/CallSite.h"
+#include <cstdint>
 
 namespace llvm {
 
+class CallBase;
+class CallInst;
+class Constant;
 class DominatorTree;
+class Instruction;
+class Module;
 
 /// The type of CFI jumptable needed for a function.
 enum CfiFunctionLinkage {
@@ -33,7 +38,7 @@
   /// The offset from the address point to the virtual function.
   uint64_t Offset;
   /// The call site itself.
-  CallSite CS;
+  CallBase &CB;
 };
 
 /// Given a call to the intrinsic \@llvm.type.test, find all devirtualizable
@@ -50,6 +55,8 @@
     SmallVectorImpl<Instruction *> &LoadedPtrs,
     SmallVectorImpl<Instruction *> &Preds, bool &HasNonCallUses,
     const CallInst *CI, DominatorTree &DT);
+
+Constant *getPointerAtOffset(Constant *I, uint64_t Offset, Module &M);
 }
 
 #endif
diff --git a/linux-x64/clang/include/llvm/Analysis/Utils/Local.h b/linux-x64/clang/include/llvm/Analysis/Utils/Local.h
index acbdf5d..bd82b34 100644
--- a/linux-x64/clang/include/llvm/Analysis/Utils/Local.h
+++ b/linux-x64/clang/include/llvm/Analysis/Utils/Local.h
@@ -14,6 +14,7 @@
 #ifndef LLVM_ANALYSIS_UTILS_LOCAL_H
 #define LLVM_ANALYSIS_UTILS_LOCAL_H
 
+#include "llvm/ADT/StringRef.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/GetElementPtrTypeIterator.h"
 
@@ -28,15 +29,15 @@
 Value *EmitGEPOffset(IRBuilderTy *Builder, const DataLayout &DL, User *GEP,
                      bool NoAssumptions = false) {
   GEPOperator *GEPOp = cast<GEPOperator>(GEP);
-  Type *IntPtrTy = DL.getIntPtrType(GEP->getType());
-  Value *Result = Constant::getNullValue(IntPtrTy);
+  Type *IntIdxTy = DL.getIndexType(GEP->getType());
+  Value *Result = nullptr;
 
   // If the GEP is inbounds, we know that none of the addressing operations will
-  // overflow in an unsigned sense.
+  // overflow in a signed sense.
   bool isInBounds = GEPOp->isInBounds() && !NoAssumptions;
 
   // Build a mask for high order bits.
-  unsigned IntPtrWidth = IntPtrTy->getScalarType()->getIntegerBitWidth();
+  unsigned IntPtrWidth = IntIdxTy->getScalarType()->getIntegerBitWidth();
   uint64_t PtrSizeMask =
       std::numeric_limits<uint64_t>::max() >> (64 - IntPtrWidth);
 
@@ -45,44 +46,56 @@
        ++i, ++GTI) {
     Value *Op = *i;
     uint64_t Size = DL.getTypeAllocSize(GTI.getIndexedType()) & PtrSizeMask;
+    Value *Offset;
     if (Constant *OpC = dyn_cast<Constant>(Op)) {
       if (OpC->isZeroValue())
         continue;
 
       // Handle a struct index, which adds its field offset to the pointer.
       if (StructType *STy = GTI.getStructTypeOrNull()) {
-        if (OpC->getType()->isVectorTy())
-          OpC = OpC->getSplatValue();
-
-        uint64_t OpValue = cast<ConstantInt>(OpC)->getZExtValue();
+        uint64_t OpValue = OpC->getUniqueInteger().getZExtValue();
         Size = DL.getStructLayout(STy)->getElementOffset(OpValue);
+        if (!Size)
+          continue;
 
-        if (Size)
-          Result = Builder->CreateAdd(Result, ConstantInt::get(IntPtrTy, Size),
-                                      GEP->getName()+".offs");
-        continue;
+        Offset = ConstantInt::get(IntIdxTy, Size);
+      } else {
+        // Splat the constant if needed.
+        if (IntIdxTy->isVectorTy() && !OpC->getType()->isVectorTy())
+          OpC = ConstantVector::getSplat(
+              cast<VectorType>(IntIdxTy)->getElementCount(), OpC);
+
+        Constant *Scale = ConstantInt::get(IntIdxTy, Size);
+        Constant *OC =
+            ConstantExpr::getIntegerCast(OpC, IntIdxTy, true /*SExt*/);
+        Offset =
+            ConstantExpr::getMul(OC, Scale, false /*NUW*/, isInBounds /*NSW*/);
       }
+    } else {
+      // Splat the index if needed.
+      if (IntIdxTy->isVectorTy() && !Op->getType()->isVectorTy())
+        Op = Builder->CreateVectorSplat(
+            cast<FixedVectorType>(IntIdxTy)->getNumElements(), Op);
 
-      Constant *Scale = ConstantInt::get(IntPtrTy, Size);
-      Constant *OC = ConstantExpr::getIntegerCast(OpC, IntPtrTy, true /*SExt*/);
-      Scale = ConstantExpr::getMul(OC, Scale, isInBounds/*NUW*/);
-      // Emit an add instruction.
-      Result = Builder->CreateAdd(Result, Scale, GEP->getName()+".offs");
-      continue;
-    }
-    // Convert to correct type.
-    if (Op->getType() != IntPtrTy)
-      Op = Builder->CreateIntCast(Op, IntPtrTy, true, Op->getName()+".c");
-    if (Size != 1) {
-      // We'll let instcombine(mul) convert this to a shl if possible.
-      Op = Builder->CreateMul(Op, ConstantInt::get(IntPtrTy, Size),
-                              GEP->getName()+".idx", isInBounds /*NUW*/);
+      // Convert to correct type.
+      if (Op->getType() != IntIdxTy)
+        Op = Builder->CreateIntCast(Op, IntIdxTy, true, Op->getName().str()+".c");
+      if (Size != 1) {
+        // We'll let instcombine(mul) convert this to a shl if possible.
+        Op = Builder->CreateMul(Op, ConstantInt::get(IntIdxTy, Size),
+                                GEP->getName().str() + ".idx", false /*NUW*/,
+                                isInBounds /*NSW*/);
+      }
+      Offset = Op;
     }
 
-    // Emit an add instruction.
-    Result = Builder->CreateAdd(Op, Result, GEP->getName()+".offs");
+    if (Result)
+      Result = Builder->CreateAdd(Result, Offset, GEP->getName().str()+".offs",
+                                  false /*NUW*/, isInBounds /*NSW*/);
+    else
+      Result = Offset;
   }
-  return Result;
+  return Result ? Result : Constant::getNullValue(IntIdxTy);
 }
 
 }
diff --git a/linux-x64/clang/include/llvm/Analysis/Utils/TFUtils.h b/linux-x64/clang/include/llvm/Analysis/Utils/TFUtils.h
new file mode 100644
index 0000000..ea6bc2c
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Analysis/Utils/TFUtils.h
@@ -0,0 +1,266 @@
+//===- TFUtils.h - utilities for tensorflow C API ---------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+#ifndef LLVM_ANALYSIS_UTILS_TFUTILS_H
+#define LLVM_ANALYSIS_UTILS_TFUTILS_H
+
+#include "llvm/Config/llvm-config.h"
+
+#ifdef LLVM_HAVE_TF_API
+#include "llvm/IR/LLVMContext.h"
+#include "llvm/Support/JSON.h"
+
+#include <memory>
+#include <vector>
+
+namespace llvm {
+
+/// Load a SavedModel, find the given inputs and outputs, and setup storage
+/// for input tensors. The user is responsible for correctly dimensioning the
+/// input tensors and setting their values before calling evaluate().
+/// To initialize:
+/// - construct the object
+/// - initialize the input tensors using initInput. Indices must correspond to
+///   indices in the InputNames used at construction.
+/// To use:
+/// - set input values by using getInput to get each input tensor, and then
+///   setting internal scalars, for all dimensions (tensors are row-major:
+///   https://github.com/tensorflow/tensorflow/blob/r1.5/tensorflow/c/c_api.h#L205)
+/// - call evaluate. The input tensors' values are not consumed after this, and
+///   may still be read.
+/// - use the outputs in the output vector
+class TFModelEvaluatorImpl;
+class EvaluationResultImpl;
+
+/// TensorSpec encapsulates the specification of a tensor: its dimensions, or
+/// "shape" (row-major), its type (see TensorSpec::getDataType specializations
+/// for supported types), its name and port (see "TensorFlow: Large-Scale
+/// Machine Learning on Heterogeneous Distributed Systems", section 4.2, para 2:
+/// https://static.googleusercontent.com/media/research.google.com/en//pubs/archive/45166.pdf)
+///
+/// TensorSpec is used to set up a TFModelEvaluator by describing the expected
+/// inputs and outputs.
+class TensorSpec final {
+public:
+  template <typename T>
+  static TensorSpec createSpec(const std::string &Name,
+                               const std::vector<int64_t> &Shape,
+                               int Port = 0) {
+    return TensorSpec(Name, Port, getDataType<T>(), Shape);
+  }
+
+  const std::string &name() const { return Name; }
+  int port() const { return Port; }
+  int typeIndex() const { return TypeIndex; }
+  const std::vector<int64_t> &shape() const { return Shape; }
+
+  bool operator==(const TensorSpec &Other) const {
+    return Name == Other.Name && Port == Other.Port &&
+           TypeIndex == Other.TypeIndex && Shape == Other.Shape;
+  }
+
+  bool operator!=(const TensorSpec &Other) const { return !(*this == Other); }
+
+  /// Get the number of elements in a tensor with this shape.
+  size_t getElementCount() const { return ElementCount; }
+  /// Get the size, in bytes, of one element.
+  size_t getElementByteSize() const;
+
+  template <typename T> bool isElementType() const {
+    return getDataType<T>() == TypeIndex;
+  }
+
+private:
+  TensorSpec(const std::string &Name, int Port, int TypeIndex,
+             const std::vector<int64_t> &Shape);
+
+  template <typename T> static int getDataType() {
+    llvm_unreachable("Undefined tensor type");
+  }
+
+  std::string Name;
+  int Port = 0;
+  int TypeIndex = 0;
+  std::vector<int64_t> Shape;
+  size_t ElementCount = 0;
+};
+
+/// Construct a TensorSpec from a JSON dictionary of the form:
+/// { "name": <string>,
+///   "port": <int>,
+///   "type": <string. Use LLVM's types, e.g. float, double, int64_t>,
+///   "shape": <array of ints> }
+/// For the "type" field, see the C++ primitive types used in
+/// TFUTILS_SUPPORTED_TYPES.
+Optional<TensorSpec> getTensorSpecFromJSON(LLVMContext &Ctx,
+                                           const json::Value &Value);
+
+struct LoggedFeatureSpec {
+  TensorSpec Spec;
+  Optional<std::string> LoggingName;
+};
+
+/// Load the output specs. If SpecFileOverride is not empty, that path is used.
+/// Otherwise, the file is assumed to be called 'output_spec.json' and be found
+/// under ModelPath (the model directory).
+/// The first output tensor name must match ExpectedDecisionName.
+/// In case of error, the return is None and the error is logged.
+Optional<std::vector<LoggedFeatureSpec>>
+loadOutputSpecs(LLVMContext &Ctx, StringRef ExpectedDecisionName,
+                StringRef ModelPath, StringRef SpecFileOverride = StringRef());
+
+/// Logging utility - given an ordered specification of features, and assuming
+/// a scalar reward, allow logging feature values and rewards, and then print
+/// as tf.train.SequenceExample text protobuf.
+/// The assumption is that, for an event to be logged (i.e. a set of feature
+/// values and a reward), the user calls the log* API for each feature exactly
+/// once, providing the index matching the position in the feature spec list
+/// provided at construction:
+/// event 0:
+///   logTensorValue(0, ...)
+///   logTensorValue(1, ...)
+///   ...
+///   logReward(...)
+/// event 1:
+///   logTensorValue(0, ...)
+///   logTensorValue(1, ...)
+///   ...
+///   logReward(...)
+///
+/// At the end, call print to generate the protobuf.
+class Logger final {
+public:
+  /// Construct a Logger. If IncludeReward is false, then logReward shouldn't
+  /// be called, and the reward feature won't be printed out.
+  Logger(const std::vector<LoggedFeatureSpec> &FeatureSpecs,
+         const TensorSpec &RewardSpec, bool IncludeReward)
+      : FeatureSpecs(FeatureSpecs), RewardSpec(RewardSpec),
+        RawLogData(FeatureSpecs.size() + IncludeReward),
+        IncludeReward(IncludeReward) {}
+
+  template <typename T> void logReward(T Value) {
+    assert(IncludeReward);
+    logTensorValue(RawLogData.size() - 1, &Value);
+  }
+
+  template <typename T> void logFinalReward(T Value) {
+    assert(RawLogData.back().empty());
+    logReward(Value);
+  }
+
+  template <typename T>
+  void logTensorValue(size_t FeatureID, const T *Value, size_t Size = 1) {
+    const char *Start = reinterpret_cast<const char *>(Value);
+    const char *End = Start + sizeof(T) * Size;
+    RawLogData[FeatureID].insert(RawLogData[FeatureID].end(), Start, End);
+  }
+
+  void print(raw_ostream &OS);
+
+private:
+  std::vector<LoggedFeatureSpec> FeatureSpecs;
+  TensorSpec RewardSpec;
+  /// RawData has one entry per feature, plus one more for the reward.
+  /// Each feature's values are then stored in a vector, in succession.
+  /// This means the ith event is stored at [*][i]
+  std::vector<std::vector<char>> RawLogData;
+  const bool IncludeReward;
+};
+
+class TFModelEvaluator final {
+public:
+  /// The result of a model evaluation. Handles the lifetime of the output
+  /// tensors, which means that their values need to be used before
+  /// the EvaluationResult's dtor is called.
+  class EvaluationResult {
+  public:
+    EvaluationResult(const EvaluationResult &) = delete;
+    EvaluationResult &operator=(const EvaluationResult &Other) = delete;
+
+    EvaluationResult(EvaluationResult &&Other);
+    EvaluationResult &operator=(EvaluationResult &&Other);
+
+    ~EvaluationResult();
+
+    /// Get a (const) pointer to the first element of the tensor at Index.
+    template <typename T> T *getTensorValue(size_t Index) {
+      return static_cast<T *>(getUntypedTensorValue(Index));
+    }
+
+    template <typename T> const T *getTensorValue(size_t Index) const {
+      return static_cast<T *>(getUntypedTensorValue(Index));
+    }
+
+    /// Get a (const) pointer to the untyped data of the tensor.
+    void *getUntypedTensorValue(size_t Index);
+    const void *getUntypedTensorValue(size_t Index) const;
+
+  private:
+    friend class TFModelEvaluator;
+    EvaluationResult(std::unique_ptr<EvaluationResultImpl> Impl);
+    std::unique_ptr<EvaluationResultImpl> Impl;
+  };
+
+  TFModelEvaluator(StringRef SavedModelPath,
+                   const std::vector<TensorSpec> &InputSpecs,
+                   const std::vector<TensorSpec> &OutputSpecs,
+                   const char *Tags = "serve");
+  TFModelEvaluator(StringRef SavedModelPath,
+                   const std::vector<TensorSpec> &InputSpecs,
+                   function_ref<TensorSpec(size_t)> GetOutputSpecs,
+                   size_t OutputSpecsSize, const char *Tags = "serve");
+
+  ~TFModelEvaluator();
+  TFModelEvaluator(const TFModelEvaluator &) = delete;
+  TFModelEvaluator(TFModelEvaluator &&) = delete;
+
+  /// Evaluate the model, assuming it is valid. Returns None if the evaluation
+  /// fails or the model is invalid, or an EvaluationResult otherwise. The
+  /// inputs are assumed to have been already provided via getInput(). When
+  /// returning None, it also invalidates this object.
+  Optional<EvaluationResult> evaluate();
+
+  /// Provides access to the input vector.
+  template <typename T> T *getInput(size_t Index) {
+    return static_cast<T *>(getUntypedInput(Index));
+  }
+
+  /// Returns true if the tensorflow model was loaded successfully, false
+  /// otherwise.
+  bool isValid() const { return !!Impl; }
+
+private:
+  void *getUntypedInput(size_t Index);
+  std::unique_ptr<TFModelEvaluatorImpl> Impl;
+};
+
+/// List of supported types, as a pair:
+/// - C++ type
+/// - enum name (implementation-specific)
+#define TFUTILS_SUPPORTED_TYPES(M)                                             \
+  M(float, TF_FLOAT)                                                           \
+  M(double, TF_DOUBLE)                                                         \
+  M(int8_t, TF_INT8)                                                           \
+  M(uint8_t, TF_UINT8)                                                         \
+  M(int16_t, TF_INT16)                                                         \
+  M(uint16_t, TF_UINT16)                                                       \
+  M(int32_t, TF_INT32)                                                         \
+  M(uint32_t, TF_UINT32)                                                       \
+  M(int64_t, TF_INT64)                                                         \
+  M(uint64_t, TF_UINT64)
+
+#define TFUTILS_GETDATATYPE_DEF(T, E)                                          \
+  template <> int TensorSpec::getDataType<T>();
+
+TFUTILS_SUPPORTED_TYPES(TFUTILS_GETDATATYPE_DEF)
+
+#undef TFUTILS_GETDATATYPE_DEF
+} // namespace llvm
+
+#endif // LLVM_HAVE_TF_API
+#endif // LLVM_ANALYSIS_UTILS_TFUTILS_H
diff --git a/linux-x64/clang/include/llvm/Analysis/ValueLattice.h b/linux-x64/clang/include/llvm/Analysis/ValueLattice.h
index 56519d7..108d080 100644
--- a/linux-x64/clang/include/llvm/Analysis/ValueLattice.h
+++ b/linux-x64/clang/include/llvm/Analysis/ValueLattice.h
@@ -11,6 +11,7 @@
 
 #include "llvm/IR/ConstantRange.h"
 #include "llvm/IR/Constants.h"
+#include "llvm/IR/Instructions.h"
 //
 //===----------------------------------------------------------------------===//
 //                               ValueLatticeElement
@@ -29,26 +30,55 @@
     /// producing instruction is dead.  Caution: We use this as the starting
     /// state in our local meet rules.  In this usage, it's taken to mean
     /// "nothing known yet".
-    undefined,
+    /// Transition to any other state allowed.
+    unknown,
 
-    /// This Value has a specific constant value.  (For constant integers,
-    /// constantrange is used instead.  Integer typed constantexprs can appear
-    /// as constant.)
+    /// This Value is an UndefValue constant or produces undef. Undefined values
+    /// can be merged with constants (or single element constant ranges),
+    /// assuming all uses of the result will be replaced.
+    /// Transition allowed to the following states:
+    ///  constant
+    ///  constantrange_including_undef
+    ///  overdefined
+    undef,
+
+    /// This Value has a specific constant value.  The constant cannot be undef.
+    /// (For constant integers, constantrange is used instead. Integer typed
+    /// constantexprs can appear as constant.) Note that the constant state
+    /// can be reached by merging undef & constant states.
+    /// Transition allowed to the following states:
+    ///  overdefined
     constant,
 
-    /// This Value is known to not have the specified value.  (For constant
+    /// This Value is known to not have the specified value. (For constant
     /// integers, constantrange is used instead.  As above, integer typed
     /// constantexprs can appear here.)
+    /// Transition allowed to the following states:
+    ///  overdefined
     notconstant,
 
     /// The Value falls within this range. (Used only for integer typed values.)
+    /// Transition allowed to the following states:
+    ///  constantrange (new range must be a superset of the existing range)
+    ///  constantrange_including_undef
+    ///  overdefined
     constantrange,
 
+    /// This Value falls within this range, but also may be undef.
+    /// Merging it with other constant ranges results in
+    /// constantrange_including_undef.
+    /// Transition allowed to the following states:
+    ///  overdefined
+    constantrange_including_undef,
+
     /// We can not precisely model the dynamic values this value might take.
-    overdefined
+    /// No transitions are allowed after reaching overdefined.
+    overdefined,
   };
 
-  ValueLatticeElementTy Tag;
+  ValueLatticeElementTy Tag : 8;
+  /// Number of times a constant range has been extended with widening enabled.
+  unsigned NumRangeExtensions : 8;
 
   /// The union either stores a pointer to a constant or a constant range,
   /// associated to the lattice element. We have to ensure that Range is
@@ -58,79 +88,145 @@
     ConstantRange Range;
   };
 
-public:
-  // Const and Range are initialized on-demand.
-  ValueLatticeElement() : Tag(undefined) {}
-
-  /// Custom destructor to ensure Range is properly destroyed, when the object
-  /// is deallocated.
-  ~ValueLatticeElement() {
+  /// Destroy contents of lattice value, without destructing the object.
+  void destroy() {
     switch (Tag) {
     case overdefined:
-    case undefined:
+    case unknown:
+    case undef:
     case constant:
     case notconstant:
       break;
+    case constantrange_including_undef:
     case constantrange:
       Range.~ConstantRange();
       break;
     };
   }
 
-  /// Custom copy constructor, to ensure Range gets initialized when
-  /// copying a constant range lattice element.
-  ValueLatticeElement(const ValueLatticeElement &Other) : Tag(undefined) {
-    *this = Other;
-  }
+public:
+  /// Struct to control some aspects related to merging constant ranges.
+  struct MergeOptions {
+    /// The merge value may include undef.
+    bool MayIncludeUndef;
 
-  /// Custom assignment operator, to ensure Range gets initialized when
-  /// assigning a constant range lattice element.
-  ValueLatticeElement &operator=(const ValueLatticeElement &Other) {
-    // If we change the state of this from constant range to non constant range,
-    // destroy Range.
-    if (isConstantRange() && !Other.isConstantRange())
-      Range.~ConstantRange();
+    /// Handle repeatedly extending a range by going to overdefined after a
+    /// number of steps.
+    bool CheckWiden;
 
-    // If we change the state of this from a valid ConstVal to another a state
-    // without a valid ConstVal, zero the pointer.
-    if ((isConstant() || isNotConstant()) && !Other.isConstant() &&
-        !Other.isNotConstant())
-      ConstVal = nullptr;
+    /// The number of allowed widening steps (including setting the range
+    /// initially).
+    unsigned MaxWidenSteps;
 
+    MergeOptions() : MergeOptions(false, false) {}
+
+    MergeOptions(bool MayIncludeUndef, bool CheckWiden,
+                 unsigned MaxWidenSteps = 1)
+        : MayIncludeUndef(MayIncludeUndef), CheckWiden(CheckWiden),
+          MaxWidenSteps(MaxWidenSteps) {}
+
+    MergeOptions &setMayIncludeUndef(bool V = true) {
+      MayIncludeUndef = V;
+      return *this;
+    }
+
+    MergeOptions &setCheckWiden(bool V = true) {
+      CheckWiden = V;
+      return *this;
+    }
+
+    MergeOptions &setMaxWidenSteps(unsigned Steps = 1) {
+      CheckWiden = true;
+      MaxWidenSteps = Steps;
+      return *this;
+    }
+  };
+
+  // ConstVal and Range are initialized on-demand.
+  ValueLatticeElement() : Tag(unknown), NumRangeExtensions(0) {}
+
+  ~ValueLatticeElement() { destroy(); }
+
+  ValueLatticeElement(const ValueLatticeElement &Other)
+      : Tag(Other.Tag), NumRangeExtensions(0) {
     switch (Other.Tag) {
     case constantrange:
-      if (!isConstantRange())
-        new (&Range) ConstantRange(Other.Range);
-      else
-        Range = Other.Range;
+    case constantrange_including_undef:
+      new (&Range) ConstantRange(Other.Range);
+      NumRangeExtensions = Other.NumRangeExtensions;
       break;
     case constant:
     case notconstant:
       ConstVal = Other.ConstVal;
       break;
     case overdefined:
-    case undefined:
+    case unknown:
+    case undef:
       break;
     }
-    Tag = Other.Tag;
+  }
+
+  ValueLatticeElement(ValueLatticeElement &&Other)
+      : Tag(Other.Tag), NumRangeExtensions(0) {
+    switch (Other.Tag) {
+    case constantrange:
+    case constantrange_including_undef:
+      new (&Range) ConstantRange(std::move(Other.Range));
+      NumRangeExtensions = Other.NumRangeExtensions;
+      break;
+    case constant:
+    case notconstant:
+      ConstVal = Other.ConstVal;
+      break;
+    case overdefined:
+    case unknown:
+    case undef:
+      break;
+    }
+    Other.Tag = unknown;
+  }
+
+  ValueLatticeElement &operator=(const ValueLatticeElement &Other) {
+    destroy();
+    new (this) ValueLatticeElement(Other);
+    return *this;
+  }
+
+  ValueLatticeElement &operator=(ValueLatticeElement &&Other) {
+    destroy();
+    new (this) ValueLatticeElement(std::move(Other));
     return *this;
   }
 
   static ValueLatticeElement get(Constant *C) {
     ValueLatticeElement Res;
-    if (!isa<UndefValue>(C))
+    if (isa<UndefValue>(C))
+      Res.markUndef();
+    else
       Res.markConstant(C);
     return Res;
   }
   static ValueLatticeElement getNot(Constant *C) {
     ValueLatticeElement Res;
-    if (!isa<UndefValue>(C))
-      Res.markNotConstant(C);
+    assert(!isa<UndefValue>(C) && "!= undef is not supported");
+    Res.markNotConstant(C);
     return Res;
   }
-  static ValueLatticeElement getRange(ConstantRange CR) {
+  static ValueLatticeElement getRange(ConstantRange CR,
+                                      bool MayIncludeUndef = false) {
+    if (CR.isFullSet())
+      return getOverdefined();
+
+    if (CR.isEmptySet()) {
+      ValueLatticeElement Res;
+      if (MayIncludeUndef)
+        Res.markUndef();
+      return Res;
+    }
+
     ValueLatticeElement Res;
-    Res.markConstantRange(std::move(CR));
+    Res.markConstantRange(std::move(CR),
+                          MergeOptions().setMayIncludeUndef(MayIncludeUndef));
     return Res;
   }
   static ValueLatticeElement getOverdefined() {
@@ -139,10 +235,22 @@
     return Res;
   }
 
-  bool isUndefined() const { return Tag == undefined; }
+  bool isUndef() const { return Tag == undef; }
+  bool isUnknown() const { return Tag == unknown; }
+  bool isUnknownOrUndef() const { return Tag == unknown || Tag == undef; }
   bool isConstant() const { return Tag == constant; }
   bool isNotConstant() const { return Tag == notconstant; }
-  bool isConstantRange() const { return Tag == constantrange; }
+  bool isConstantRangeIncludingUndef() const {
+    return Tag == constantrange_including_undef;
+  }
+  /// Returns true if this value is a constant range. Use \p UndefAllowed to
+  /// exclude non-singleton constant ranges that may also be undef. Note that
+  /// this function also returns true if the range may include undef, but only
+  /// contains a single element. In that case, it can be replaced by a constant.
+  bool isConstantRange(bool UndefAllowed = true) const {
+    return Tag == constantrange || (Tag == constantrange_including_undef &&
+                                    (UndefAllowed || Range.isSingleElement()));
+  }
   bool isOverdefined() const { return Tag == overdefined; }
 
   Constant *getConstant() const {
@@ -155,8 +263,12 @@
     return ConstVal;
   }
 
-  const ConstantRange &getConstantRange() const {
-    assert(isConstantRange() &&
+  /// Returns the constant range for this value. Use \p UndefAllowed to exclude
+  /// non-singleton constant ranges that may also be undef. Note that this
+  /// function also returns a range if the range may include undef, but only
+  /// contains a single element. In that case, it can be replaced by a constant.
+  const ConstantRange &getConstantRange(bool UndefAllowed = true) const {
+    assert(isConstantRange(UndefAllowed) &&
            "Cannot get the constant-range of a non-constant-range!");
     return Range;
   }
@@ -170,89 +282,139 @@
     return None;
   }
 
-private:
-  void markOverdefined() {
+  bool markOverdefined() {
     if (isOverdefined())
-      return;
-    if (isConstant() || isNotConstant())
-      ConstVal = nullptr;
-    if (isConstantRange())
-      Range.~ConstantRange();
+      return false;
+    destroy();
     Tag = overdefined;
+    return true;
   }
 
-  void markConstant(Constant *V) {
-    assert(V && "Marking constant with NULL");
-    if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
-      markConstantRange(ConstantRange(CI->getValue()));
-      return;
-    }
-    if (isa<UndefValue>(V))
-      return;
+  bool markUndef() {
+    if (isUndef())
+      return false;
 
-    assert((!isConstant() || getConstant() == V) &&
-           "Marking constant with different value");
-    assert(isUndefined());
+    assert(isUnknown());
+    Tag = undef;
+    return true;
+  }
+
+  bool markConstant(Constant *V, bool MayIncludeUndef = false) {
+    if (isa<UndefValue>(V))
+      return markUndef();
+
+    if (isConstant()) {
+      assert(getConstant() == V && "Marking constant with different value");
+      return false;
+    }
+
+    if (ConstantInt *CI = dyn_cast<ConstantInt>(V))
+      return markConstantRange(
+          ConstantRange(CI->getValue()),
+          MergeOptions().setMayIncludeUndef(MayIncludeUndef));
+
+    assert(isUnknown() || isUndef());
     Tag = constant;
     ConstVal = V;
+    return true;
   }
 
-  void markNotConstant(Constant *V) {
+  bool markNotConstant(Constant *V) {
     assert(V && "Marking constant with NULL");
-    if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
-      markConstantRange(ConstantRange(CI->getValue() + 1, CI->getValue()));
-      return;
-    }
-    if (isa<UndefValue>(V))
-      return;
+    if (ConstantInt *CI = dyn_cast<ConstantInt>(V))
+      return markConstantRange(
+          ConstantRange(CI->getValue() + 1, CI->getValue()));
 
-    assert((!isConstant() || getConstant() != V) &&
-           "Marking constant !constant with same value");
-    assert((!isNotConstant() || getNotConstant() == V) &&
-           "Marking !constant with different value");
-    assert(isUndefined() || isConstant());
+    if (isa<UndefValue>(V))
+      return false;
+
+    if (isNotConstant()) {
+      assert(getNotConstant() == V && "Marking !constant with different value");
+      return false;
+    }
+
+    assert(isUnknown());
     Tag = notconstant;
     ConstVal = V;
+    return true;
   }
 
-  void markConstantRange(ConstantRange NewR) {
+  /// Mark the object as constant range with \p NewR. If the object is already a
+  /// constant range, nothing changes if the existing range is equal to \p
+  /// NewR and the tag. Otherwise \p NewR must be a superset of the existing
+  /// range or the object must be undef. The tag is set to
+  /// constant_range_including_undef if either the existing value or the new
+  /// range may include undef.
+  bool markConstantRange(ConstantRange NewR,
+                         MergeOptions Opts = MergeOptions()) {
+    assert(!NewR.isEmptySet() && "should only be called for non-empty sets");
+
+    if (NewR.isFullSet())
+      return markOverdefined();
+
+    ValueLatticeElementTy OldTag = Tag;
+    ValueLatticeElementTy NewTag =
+        (isUndef() || isConstantRangeIncludingUndef() || Opts.MayIncludeUndef)
+            ? constantrange_including_undef
+            : constantrange;
     if (isConstantRange()) {
-      if (NewR.isEmptySet())
-        markOverdefined();
-      else {
-        Range = std::move(NewR);
-      }
-      return;
+      Tag = NewTag;
+      if (getConstantRange() == NewR)
+        return Tag != OldTag;
+
+      // Simple form of widening. If a range is extended multiple times, go to
+      // overdefined.
+      if (Opts.CheckWiden && ++NumRangeExtensions > Opts.MaxWidenSteps)
+        return markOverdefined();
+
+      assert(NewR.contains(getConstantRange()) &&
+             "Existing range must be a subset of NewR");
+      Range = std::move(NewR);
+      return true;
     }
 
-    assert(isUndefined());
-    if (NewR.isEmptySet())
-      markOverdefined();
-    else {
-      Tag = constantrange;
-      new (&Range) ConstantRange(std::move(NewR));
-    }
+    assert(isUnknown() || isUndef());
+
+    NumRangeExtensions = 0;
+    Tag = NewTag;
+    new (&Range) ConstantRange(std::move(NewR));
+    return true;
   }
 
-public:
   /// Updates this object to approximate both this object and RHS. Returns
   /// true if this object has been changed.
-  bool mergeIn(const ValueLatticeElement &RHS, const DataLayout &DL) {
-    if (RHS.isUndefined() || isOverdefined())
+  bool mergeIn(const ValueLatticeElement &RHS,
+               MergeOptions Opts = MergeOptions()) {
+    if (RHS.isUnknown() || isOverdefined())
       return false;
     if (RHS.isOverdefined()) {
       markOverdefined();
       return true;
     }
 
-    if (isUndefined()) {
+    if (isUndef()) {
+      assert(!RHS.isUnknown());
+      if (RHS.isUndef())
+        return false;
+      if (RHS.isConstant())
+        return markConstant(RHS.getConstant(), true);
+      if (RHS.isConstantRange())
+        return markConstantRange(RHS.getConstantRange(true),
+                                 Opts.setMayIncludeUndef());
+      return markOverdefined();
+    }
+
+    if (isUnknown()) {
+      assert(!RHS.isUnknown() && "Unknow RHS should be handled earlier");
       *this = RHS;
-      return !RHS.isUndefined();
+      return true;
     }
 
     if (isConstant()) {
       if (RHS.isConstant() && getConstant() == RHS.getConstant())
         return false;
+      if (RHS.isUndef())
+        return false;
       markOverdefined();
       return true;
     }
@@ -264,40 +426,47 @@
       return true;
     }
 
+    auto OldTag = Tag;
     assert(isConstantRange() && "New ValueLattice type?");
+    if (RHS.isUndef()) {
+      Tag = constantrange_including_undef;
+      return OldTag != Tag;
+    }
+
     if (!RHS.isConstantRange()) {
       // We can get here if we've encountered a constantexpr of integer type
       // and merge it with a constantrange.
       markOverdefined();
       return true;
     }
+
     ConstantRange NewR = getConstantRange().unionWith(RHS.getConstantRange());
-    if (NewR.isFullSet())
-      markOverdefined();
-    else if (NewR == getConstantRange())
-      return false;
-    else
-      markConstantRange(std::move(NewR));
-    return true;
+    return markConstantRange(
+        std::move(NewR),
+        Opts.setMayIncludeUndef(RHS.isConstantRangeIncludingUndef()));
   }
 
-  ConstantInt *getConstantInt() const {
-    assert(isConstant() && isa<ConstantInt>(getConstant()) &&
-           "No integer constant");
-    return cast<ConstantInt>(getConstant());
-  }
-
-  /// Compares this symbolic value with Other using Pred and returns either
+  // Compares this symbolic value with Other using Pred and returns either
   /// true, false or undef constants, or nullptr if the comparison cannot be
   /// evaluated.
   Constant *getCompare(CmpInst::Predicate Pred, Type *Ty,
                        const ValueLatticeElement &Other) const {
-    if (isUndefined() || Other.isUndefined())
+    if (isUnknownOrUndef() || Other.isUnknownOrUndef())
       return UndefValue::get(Ty);
 
     if (isConstant() && Other.isConstant())
       return ConstantExpr::getCompare(Pred, getConstant(), Other.getConstant());
 
+    if (ICmpInst::isEquality(Pred)) {
+      // not(C) != C => true, not(C) == C => false.
+      if ((isNotConstant() && Other.isConstant() &&
+           getNotConstant() == Other.getConstant()) ||
+          (isConstant() && Other.isNotConstant() &&
+           getConstant() == Other.getNotConstant()))
+        return Pred == ICmpInst::ICMP_NE
+            ? ConstantInt::getTrue(Ty) : ConstantInt::getFalse(Ty);
+    }
+
     // Integer constants are represented as ConstantRanges with single
     // elements.
     if (!isConstantRange() || !Other.isConstantRange())
@@ -314,9 +483,14 @@
 
     return nullptr;
   }
+
+  unsigned getNumRangeExtensions() const { return NumRangeExtensions; }
+  void setNumRangeExtensions(unsigned N) { NumRangeExtensions = N; }
 };
 
-raw_ostream &operator<<(raw_ostream &OS, const ValueLatticeElement &Val);
+static_assert(sizeof(ValueLatticeElement) <= 40,
+              "size of ValueLatticeElement changed unexpectedly");
 
+raw_ostream &operator<<(raw_ostream &OS, const ValueLatticeElement &Val);
 } // end namespace llvm
 #endif
diff --git a/linux-x64/clang/include/llvm/Analysis/ValueTracking.h b/linux-x64/clang/include/llvm/Analysis/ValueTracking.h
index f14c2a4..86c0991 100644
--- a/linux-x64/clang/include/llvm/Analysis/ValueTracking.h
+++ b/linux-x64/clang/include/llvm/Analysis/ValueTracking.h
@@ -17,22 +17,24 @@
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallSet.h"
-#include "llvm/IR/CallSite.h"
 #include "llvm/IR/Constants.h"
-#include "llvm/IR/Instruction.h"
+#include "llvm/IR/DataLayout.h"
+#include "llvm/IR/InstrTypes.h"
 #include "llvm/IR/Intrinsics.h"
+#include "llvm/IR/Operator.h"
 #include <cassert>
 #include <cstdint>
 
 namespace llvm {
 
 class AddOperator;
+class AllocaInst;
 class APInt;
 class AssumptionCache;
-class DataLayout;
 class DominatorTree;
 class GEPOperator;
 class IntrinsicInst;
+class LoadInst;
 class WithOverflowInst;
 struct KnownBits;
 class Loop;
@@ -43,6 +45,8 @@
 class TargetLibraryInfo;
 class Value;
 
+constexpr unsigned MaxAnalysisRecursionDepth = 6;
+
   /// Determine which bits of V are known to be either zero or one and return
   /// them in the KnownZero/KnownOne bit sets.
   ///
@@ -59,6 +63,22 @@
                         OptimizationRemarkEmitter *ORE = nullptr,
                         bool UseInstrInfo = true);
 
+  /// Determine which bits of V are known to be either zero or one and return
+  /// them in the KnownZero/KnownOne bit sets.
+  ///
+  /// This function is defined on values with integer type, values with pointer
+  /// type, and vectors of integers.  In the case
+  /// where V is a vector, the known zero and known one values are the
+  /// same width as the vector element, and the bit is set only if it is true
+  /// for all of the demanded elements in the vector.
+  void computeKnownBits(const Value *V, const APInt &DemandedElts,
+                        KnownBits &Known, const DataLayout &DL,
+                        unsigned Depth = 0, AssumptionCache *AC = nullptr,
+                        const Instruction *CxtI = nullptr,
+                        const DominatorTree *DT = nullptr,
+                        OptimizationRemarkEmitter *ORE = nullptr,
+                        bool UseInstrInfo = true);
+
   /// Returns the known bits rather than passing by reference.
   KnownBits computeKnownBits(const Value *V, const DataLayout &DL,
                              unsigned Depth = 0, AssumptionCache *AC = nullptr,
@@ -67,6 +87,15 @@
                              OptimizationRemarkEmitter *ORE = nullptr,
                              bool UseInstrInfo = true);
 
+  /// Returns the known bits rather than passing by reference.
+  KnownBits computeKnownBits(const Value *V, const APInt &DemandedElts,
+                             const DataLayout &DL, unsigned Depth = 0,
+                             AssumptionCache *AC = nullptr,
+                             const Instruction *CxtI = nullptr,
+                             const DominatorTree *DT = nullptr,
+                             OptimizationRemarkEmitter *ORE = nullptr,
+                             bool UseInstrInfo = true);
+
   /// Compute known bits from the range metadata.
   /// \p KnownZero the set of bits that are known to be zero
   /// \p KnownOne the set of bits that are known to be one
@@ -185,7 +214,7 @@
 
   /// Map a call instruction to an intrinsic ID.  Libcalls which have equivalent
   /// intrinsics are treated as-if they were intrinsics.
-  Intrinsic::ID getIntrinsicForCallSite(ImmutableCallSite ICS,
+  Intrinsic::ID getIntrinsicForCallSite(const CallBase &CB,
                                         const TargetLibraryInfo *TLI);
 
   /// Return true if we can prove that the specified FP value is never equal to
@@ -203,6 +232,12 @@
   ///   x < -0 --> false
   bool CannotBeOrderedLessThanZero(const Value *V, const TargetLibraryInfo *TLI);
 
+  /// Return true if the floating-point scalar value is not an infinity or if
+  /// the floating-point vector value has no infinities. Return false if a value
+  /// could ever be infinity.
+  bool isKnownNeverInfinity(const Value *V, const TargetLibraryInfo *TLI,
+                            unsigned Depth = 0);
+
   /// Return true if the floating-point scalar value is not a NaN or if the
   /// floating-point vector value has no NaN elements. Return false if a value
   /// could ever be NaN.
@@ -224,11 +259,11 @@
   /// 0.0 etc. If the value can't be handled with a repeated byte store (e.g.
   /// i16 0x1234), return null. If the value is entirely undef and padding,
   /// return undef.
-  Value *isBytewiseValue(Value *V);
+  Value *isBytewiseValue(Value *V, const DataLayout &DL);
 
-  /// Given an aggregrate and an sequence of indices, see if the scalar value
+  /// Given an aggregate and an sequence of indices, see if the scalar value
   /// indexed is already around as a register, for example if it were inserted
-  /// directly into the aggregrate.
+  /// directly into the aggregate.
   ///
   /// If InsertBefore is not null, this function will duplicate (modified)
   /// insertvalues when a part of a nested struct is extracted.
@@ -238,13 +273,25 @@
 
   /// Analyze the specified pointer to see if it can be expressed as a base
   /// pointer plus a constant offset. Return the base and offset to the caller.
-  Value *GetPointerBaseWithConstantOffset(Value *Ptr, int64_t &Offset,
-                                          const DataLayout &DL);
-  inline const Value *GetPointerBaseWithConstantOffset(const Value *Ptr,
-                                                       int64_t &Offset,
-                                                       const DataLayout &DL) {
-    return GetPointerBaseWithConstantOffset(const_cast<Value *>(Ptr), Offset,
-                                            DL);
+  ///
+  /// This is a wrapper around Value::stripAndAccumulateConstantOffsets that
+  /// creates and later unpacks the required APInt.
+  inline Value *GetPointerBaseWithConstantOffset(Value *Ptr, int64_t &Offset,
+                                                 const DataLayout &DL,
+                                                 bool AllowNonInbounds = true) {
+    APInt OffsetAPInt(DL.getIndexTypeSizeInBits(Ptr->getType()), 0);
+    Value *Base =
+        Ptr->stripAndAccumulateConstantOffsets(DL, OffsetAPInt, AllowNonInbounds);
+
+    Offset = OffsetAPInt.getSExtValue();
+    return Base;
+  }
+  inline const Value *
+  GetPointerBaseWithConstantOffset(const Value *Ptr, int64_t &Offset,
+                                   const DataLayout &DL,
+                                   bool AllowNonInbounds = true) {
+    return GetPointerBaseWithConstantOffset(const_cast<Value *>(Ptr), Offset, DL,
+                                            AllowNonInbounds);
   }
 
   /// Returns true if the GEP is based on a pointer to a string (array of
@@ -297,34 +344,39 @@
   uint64_t GetStringLength(const Value *V, unsigned CharSize = 8);
 
   /// This function returns call pointer argument that is considered the same by
-  /// aliasing rules. You CAN'T use it to replace one value with another.
-  const Value *getArgumentAliasingToReturnedPointer(const CallBase *Call);
-  inline Value *getArgumentAliasingToReturnedPointer(CallBase *Call) {
+  /// aliasing rules. You CAN'T use it to replace one value with another. If
+  /// \p MustPreserveNullness is true, the call must preserve the nullness of
+  /// the pointer.
+  const Value *getArgumentAliasingToReturnedPointer(const CallBase *Call,
+                                                    bool MustPreserveNullness);
+  inline Value *
+  getArgumentAliasingToReturnedPointer(CallBase *Call,
+                                       bool MustPreserveNullness) {
     return const_cast<Value *>(getArgumentAliasingToReturnedPointer(
-        const_cast<const CallBase *>(Call)));
+        const_cast<const CallBase *>(Call), MustPreserveNullness));
   }
 
-  // {launder,strip}.invariant.group returns pointer that aliases its argument,
-  // and it only captures pointer by returning it.
-  // These intrinsics are not marked as nocapture, because returning is
-  // considered as capture. The arguments are not marked as returned neither,
-  // because it would make it useless.
+  /// {launder,strip}.invariant.group returns pointer that aliases its argument,
+  /// and it only captures pointer by returning it.
+  /// These intrinsics are not marked as nocapture, because returning is
+  /// considered as capture. The arguments are not marked as returned neither,
+  /// because it would make it useless. If \p MustPreserveNullness is true,
+  /// the intrinsic must preserve the nullness of the pointer.
   bool isIntrinsicReturningPointerAliasingArgumentWithoutCapturing(
-      const CallBase *Call);
+      const CallBase *Call, bool MustPreserveNullness);
 
   /// This method strips off any GEP address adjustments and pointer casts from
   /// the specified value, returning the original object being addressed. Note
   /// that the returned value has pointer type if the specified value does. If
   /// the MaxLookup value is non-zero, it limits the number of instructions to
   /// be stripped off.
-  Value *GetUnderlyingObject(Value *V, const DataLayout &DL,
-                             unsigned MaxLookup = 6);
-  inline const Value *GetUnderlyingObject(const Value *V, const DataLayout &DL,
+  Value *getUnderlyingObject(Value *V, unsigned MaxLookup = 6);
+  inline const Value *getUnderlyingObject(const Value *V,
                                           unsigned MaxLookup = 6) {
-    return GetUnderlyingObject(const_cast<Value *>(V), DL, MaxLookup);
+    return getUnderlyingObject(const_cast<Value *>(V), MaxLookup);
   }
 
-  /// This method is similar to GetUnderlyingObject except that it can
+  /// This method is similar to getUnderlyingObject except that it can
   /// look through phi and select instructions and return multiple objects.
   ///
   /// If LoopInfo is passed, loop phis are further analyzed.  If a pointer
@@ -352,20 +404,37 @@
   /// Since A[i] and A[i-1] are independent pointers, getUnderlyingObjects
   /// should not assume that Curr and Prev share the same underlying object thus
   /// it shouldn't look through the phi above.
-  void GetUnderlyingObjects(const Value *V,
+  void getUnderlyingObjects(const Value *V,
                             SmallVectorImpl<const Value *> &Objects,
-                            const DataLayout &DL, LoopInfo *LI = nullptr,
-                            unsigned MaxLookup = 6);
+                            LoopInfo *LI = nullptr, unsigned MaxLookup = 6);
 
-  /// This is a wrapper around GetUnderlyingObjects and adds support for basic
+  /// This is a wrapper around getUnderlyingObjects and adds support for basic
   /// ptrtoint+arithmetic+inttoptr sequences.
   bool getUnderlyingObjectsForCodeGen(const Value *V,
-                            SmallVectorImpl<Value *> &Objects,
-                            const DataLayout &DL);
+                                      SmallVectorImpl<Value *> &Objects);
+
+  /// Returns unique alloca where the value comes from, or nullptr.
+  /// If OffsetZero is true check that V points to the begining of the alloca.
+  AllocaInst *findAllocaForValue(Value *V, bool OffsetZero = false);
+  inline const AllocaInst *findAllocaForValue(const Value *V,
+                                              bool OffsetZero = false) {
+    return findAllocaForValue(const_cast<Value *>(V), OffsetZero);
+  }
 
   /// Return true if the only users of this pointer are lifetime markers.
   bool onlyUsedByLifetimeMarkers(const Value *V);
 
+  /// Return true if the only users of this pointer are lifetime markers or
+  /// droppable instructions.
+  bool onlyUsedByLifetimeMarkersOrDroppableInsts(const Value *V);
+
+  /// Return true if speculation of the given load must be suppressed to avoid
+  /// ordering or interfering with an active sanitizer.  If not suppressed,
+  /// dereferenceability and alignment must be proven separately.  Note: This
+  /// is only needed for raw reasoning; if you use the interface below
+  /// (isSafeToSpeculativelyExecute), this is handled internally.
+  bool mustSuppressSpeculation(const LoadInst &LI);
+
   /// Return true if the instruction does not have any effects besides
   /// calculating the result and does not have undefined behavior.
   ///
@@ -475,7 +544,10 @@
 
   /// Determine the possible constant range of an integer or vector of integer
   /// value. This is intended as a cheap, non-recursive check.
-  ConstantRange computeConstantRange(const Value *V, bool UseInstrInfo = true);
+  ConstantRange computeConstantRange(const Value *V, bool UseInstrInfo = true,
+                                     AssumptionCache *AC = nullptr,
+                                     const Instruction *CtxI = nullptr,
+                                     unsigned Depth = 0);
 
   /// Return true if this function can prove that the instruction I will
   /// always transfer execution to one of its successors (including the next
@@ -506,35 +578,71 @@
   bool isGuaranteedToExecuteForEveryIteration(const Instruction *I,
                                               const Loop *L);
 
-  /// Return true if this function can prove that I is guaranteed to yield
-  /// full-poison (all bits poison) if at least one of its operands are
-  /// full-poison (all bits poison).
-  ///
-  /// The exact rules for how poison propagates through instructions have
-  /// not been settled as of 2015-07-10, so this function is conservative
-  /// and only considers poison to be propagated in uncontroversial
-  /// cases. There is no attempt to track values that may be only partially
+  /// Return true if I yields poison or raises UB if any of its operands is
   /// poison.
-  bool propagatesFullPoison(const Instruction *I);
+  /// Formally, given I = `r = op v1 v2 .. vN`, propagatesPoison returns true
+  /// if, for all i, r is evaluated to poison or op raises UB if vi = poison.
+  /// To filter out operands that raise UB on poison, you can use
+  /// getGuaranteedNonPoisonOp.
+  bool propagatesPoison(const Operator *I);
 
-  /// Return either nullptr or an operand of I such that I will trigger
-  /// undefined behavior if I is executed and that operand has a full-poison
-  /// value (all bits poison).
-  const Value *getGuaranteedNonFullPoisonOp(const Instruction *I);
+  /// Insert operands of I into Ops such that I will trigger undefined behavior
+  /// if I is executed and that operand has a poison value.
+  void getGuaranteedNonPoisonOps(const Instruction *I,
+                                 SmallPtrSetImpl<const Value *> &Ops);
 
-  /// Return true if the given instruction must trigger undefined behavior.
+  /// Return true if the given instruction must trigger undefined behavior
   /// when I is executed with any operands which appear in KnownPoison holding
-  /// a full-poison value at the point of execution.
+  /// a poison value at the point of execution.
   bool mustTriggerUB(const Instruction *I,
                      const SmallSet<const Value *, 16>& KnownPoison);
 
-  /// Return true if this function can prove that if PoisonI is executed
-  /// and yields a full-poison value (all bits poison), then that will
-  /// trigger undefined behavior.
+  /// Return true if this function can prove that if Inst is executed
+  /// and yields a poison value or undef bits, then that will trigger
+  /// undefined behavior.
   ///
   /// Note that this currently only considers the basic block that is
-  /// the parent of I.
-  bool programUndefinedIfFullPoison(const Instruction *PoisonI);
+  /// the parent of Inst.
+  bool programUndefinedIfUndefOrPoison(const Instruction *Inst);
+  bool programUndefinedIfPoison(const Instruction *Inst);
+
+  /// canCreateUndefOrPoison returns true if Op can create undef or poison from
+  /// non-undef & non-poison operands.
+  /// For vectors, canCreateUndefOrPoison returns true if there is potential
+  /// poison or undef in any element of the result when vectors without
+  /// undef/poison poison are given as operands.
+  /// For example, given `Op = shl <2 x i32> %x, <0, 32>`, this function returns
+  /// true. If Op raises immediate UB but never creates poison or undef
+  /// (e.g. sdiv I, 0), canCreatePoison returns false.
+  ///
+  /// canCreatePoison returns true if Op can create poison from non-poison
+  /// operands.
+  bool canCreateUndefOrPoison(const Operator *Op);
+  bool canCreatePoison(const Operator *Op);
+
+  /// Return true if V is poison given that ValAssumedPoison is already poison.
+  /// For example, if ValAssumedPoison is `icmp X, 10` and V is `icmp X, 5`,
+  /// impliesPoison returns true.
+  bool impliesPoison(const Value *ValAssumedPoison, const Value *V);
+
+  /// Return true if this function can prove that V does not have undef bits
+  /// and is never poison. If V is an aggregate value or vector, check whether
+  /// all elements (except padding) are not undef or poison.
+  /// Note that this is different from canCreateUndefOrPoison because the
+  /// function assumes Op's operands are not poison/undef.
+  ///
+  /// If CtxI and DT are specified this method performs flow-sensitive analysis
+  /// and returns true if it is guaranteed to be never undef or poison
+  /// immediately before the CtxI.
+  bool isGuaranteedNotToBeUndefOrPoison(const Value *V,
+                                        AssumptionCache *AC = nullptr,
+                                        const Instruction *CtxI = nullptr,
+                                        const DominatorTree *DT = nullptr,
+                                        unsigned Depth = 0);
+  bool isGuaranteedNotToBePoison(const Value *V, AssumptionCache *AC = nullptr,
+                                 const Instruction *CtxI = nullptr,
+                                 const DominatorTree *DT = nullptr,
+                                 unsigned Depth = 0);
 
   /// Specific patterns of select instructions we can match.
   enum SelectPatternFlavor {
@@ -595,12 +703,12 @@
   SelectPatternResult matchSelectPattern(Value *V, Value *&LHS, Value *&RHS,
                                          Instruction::CastOps *CastOp = nullptr,
                                          unsigned Depth = 0);
+
   inline SelectPatternResult
-  matchSelectPattern(const Value *V, const Value *&LHS, const Value *&RHS,
-                     Instruction::CastOps *CastOp = nullptr) {
-    Value *L = const_cast<Value*>(LHS);
-    Value *R = const_cast<Value*>(RHS);
-    auto Result = matchSelectPattern(const_cast<Value*>(V), L, R);
+  matchSelectPattern(const Value *V, const Value *&LHS, const Value *&RHS) {
+    Value *L = const_cast<Value *>(LHS);
+    Value *R = const_cast<Value *>(RHS);
+    auto Result = matchSelectPattern(const_cast<Value *>(V), L, R);
     LHS = L;
     RHS = R;
     return Result;
@@ -625,6 +733,14 @@
   /// minimum/maximum flavor.
   CmpInst::Predicate getInverseMinMaxPred(SelectPatternFlavor SPF);
 
+  /// Check if the values in \p VL are select instructions that can be converted
+  /// to a min or max (vector) intrinsic. Returns the intrinsic ID, if such a
+  /// conversion is possible, together with a bool indicating whether all select
+  /// conditions are only used by the selects. Otherwise return
+  /// Intrinsic::not_intrinsic.
+  std::pair<Intrinsic::ID, bool>
+  canConvertToMinOrMaxIntrinsic(ArrayRef<Value *> VL);
+
   /// Return true if RHS is known to be implied true by LHS.  Return false if
   /// RHS is known to be implied false by LHS.  Otherwise, return None if no
   /// implication can be made.
@@ -638,12 +754,27 @@
   Optional<bool> isImpliedCondition(const Value *LHS, const Value *RHS,
                                     const DataLayout &DL, bool LHSIsTrue = true,
                                     unsigned Depth = 0);
+  Optional<bool> isImpliedCondition(const Value *LHS,
+                                    CmpInst::Predicate RHSPred,
+                                    const Value *RHSOp0, const Value *RHSOp1,
+                                    const DataLayout &DL, bool LHSIsTrue = true,
+                                    unsigned Depth = 0);
 
   /// Return the boolean condition value in the context of the given instruction
   /// if it is known based on dominating conditions.
   Optional<bool> isImpliedByDomCondition(const Value *Cond,
                                          const Instruction *ContextI,
                                          const DataLayout &DL);
+  Optional<bool> isImpliedByDomCondition(CmpInst::Predicate Pred,
+                                         const Value *LHS, const Value *RHS,
+                                         const Instruction *ContextI,
+                                         const DataLayout &DL);
+
+  /// If Ptr1 is provably equal to Ptr2 plus a constant offset, return that
+  /// offset. For example, Ptr1 might be &A[42], and Ptr2 might be &A[40]. In
+  /// this case offset would be -8.
+  Optional<int64_t> isPointerOffset(const Value *Ptr1, const Value *Ptr2,
+                                    const DataLayout &DL);
 } // end namespace llvm
 
 #endif // LLVM_ANALYSIS_VALUETRACKING_H
diff --git a/linux-x64/clang/include/llvm/Analysis/VecFuncs.def b/linux-x64/clang/include/llvm/Analysis/VecFuncs.def
index 4c92062..cfc3d61 100644
--- a/linux-x64/clang/include/llvm/Analysis/VecFuncs.def
+++ b/linux-x64/clang/include/llvm/Analysis/VecFuncs.def
@@ -8,7 +8,14 @@
 
 // This .def file will create mappings from scalar math functions to vector
 // functions along with their vectorization factor. The current support includes
-// such mappings for Accelerate framework, MASS vector library, and SVML library. 
+// such mappings for Accelerate framework, MASS vector library, and SVML library.
+// This .def file also allows creating an array of vector functions supported in
+// the specified framework or library.
+
+#if defined(TLI_DEFINE_MASSV_VECFUNCS_NAMES)
+#define TLI_DEFINE_MASSV_VECFUNCS
+#define TLI_DEFINE_VECFUNC(SCAL, VEC, VF) VEC,
+#endif
 
 #if !(defined(TLI_DEFINE_VECFUNC))
 #define TLI_DEFINE_VECFUNC(SCAL, VEC, VF) {SCAL, VEC, VF},
@@ -55,6 +62,87 @@
 TLI_DEFINE_VECFUNC("atanhf", "vatanhf", 4)
 
 
+#elif defined(TLI_DEFINE_LIBMVEC_X86_VECFUNCS)
+// GLIBC Vector math Functions
+
+TLI_DEFINE_VECFUNC("sin", "_ZGVbN2v_sin", 2)
+TLI_DEFINE_VECFUNC("sin", "_ZGVdN4v_sin", 4)
+
+TLI_DEFINE_VECFUNC("sinf", "_ZGVbN4v_sinf", 4)
+TLI_DEFINE_VECFUNC("sinf", "_ZGVdN8v_sinf", 8)
+
+TLI_DEFINE_VECFUNC("llvm.sin.f64", "_ZGVbN2v_sin", 2)
+TLI_DEFINE_VECFUNC("llvm.sin.f64", "_ZGVdN4v_sin", 4)
+
+TLI_DEFINE_VECFUNC("llvm.sin.f32", "_ZGVbN4v_sinf", 4)
+TLI_DEFINE_VECFUNC("llvm.sin.f32", "_ZGVdN8v_sinf", 8)
+
+TLI_DEFINE_VECFUNC("cos", "_ZGVbN2v_cos", 2)
+TLI_DEFINE_VECFUNC("cos", "_ZGVdN4v_cos", 4)
+
+TLI_DEFINE_VECFUNC("cosf", "_ZGVbN4v_cosf", 4)
+TLI_DEFINE_VECFUNC("cosf", "_ZGVdN8v_cosf", 8)
+
+TLI_DEFINE_VECFUNC("llvm.cos.f64", "_ZGVbN2v_cos", 2)
+TLI_DEFINE_VECFUNC("llvm.cos.f64", "_ZGVdN4v_cos", 4)
+
+TLI_DEFINE_VECFUNC("llvm.cos.f32", "_ZGVbN4v_cosf", 4)
+TLI_DEFINE_VECFUNC("llvm.cos.f32", "_ZGVdN8v_cosf", 8)
+
+TLI_DEFINE_VECFUNC("pow", "_ZGVbN2vv_pow", 2)
+TLI_DEFINE_VECFUNC("pow", "_ZGVdN4vv_pow", 4)
+
+TLI_DEFINE_VECFUNC("powf", "_ZGVbN4vv_powf", 4)
+TLI_DEFINE_VECFUNC("powf", "_ZGVdN8vv_powf", 8)
+
+TLI_DEFINE_VECFUNC("__pow_finite", "_ZGVbN2vv___pow_finite", 2)
+TLI_DEFINE_VECFUNC("__pow_finite", "_ZGVdN4vv___pow_finite", 4)
+
+TLI_DEFINE_VECFUNC("__powf_finite", "_ZGVbN4vv___powf_finite", 4)
+TLI_DEFINE_VECFUNC("__powf_finite", "_ZGVdN8vv___powf_finite", 8)
+
+TLI_DEFINE_VECFUNC("llvm.pow.f64", "_ZGVbN2vv_pow", 2)
+TLI_DEFINE_VECFUNC("llvm.pow.f64", "_ZGVdN4vv_pow", 4)
+
+TLI_DEFINE_VECFUNC("llvm.pow.f32", "_ZGVbN4vv_powf", 4)
+TLI_DEFINE_VECFUNC("llvm.pow.f32", "_ZGVdN8vv_powf", 8)
+
+TLI_DEFINE_VECFUNC("exp", "_ZGVbN2v_exp", 2)
+TLI_DEFINE_VECFUNC("exp", "_ZGVdN4v_exp", 4)
+
+TLI_DEFINE_VECFUNC("expf", "_ZGVbN4v_expf", 4)
+TLI_DEFINE_VECFUNC("expf", "_ZGVdN8v_expf", 8)
+
+TLI_DEFINE_VECFUNC("__exp_finite", "_ZGVbN2v___exp_finite", 2)
+TLI_DEFINE_VECFUNC("__exp_finite", "_ZGVdN4v___exp_finite", 4)
+
+TLI_DEFINE_VECFUNC("__expf_finite", "_ZGVbN4v___expf_finite", 4)
+TLI_DEFINE_VECFUNC("__expf_finite", "_ZGVdN8v___expf_finite", 8)
+
+TLI_DEFINE_VECFUNC("llvm.exp.f64", "_ZGVbN2v_exp", 2)
+TLI_DEFINE_VECFUNC("llvm.exp.f64", "_ZGVdN4v_exp", 4)
+
+TLI_DEFINE_VECFUNC("llvm.exp.f32", "_ZGVbN4v_expf", 4)
+TLI_DEFINE_VECFUNC("llvm.exp.f32", "_ZGVdN8v_expf", 8)
+
+TLI_DEFINE_VECFUNC("log", "_ZGVbN2v_log", 2)
+TLI_DEFINE_VECFUNC("log", "_ZGVdN4v_log", 4)
+
+TLI_DEFINE_VECFUNC("logf", "_ZGVbN4v_logf", 4)
+TLI_DEFINE_VECFUNC("logf", "_ZGVdN8v_logf", 8)
+
+TLI_DEFINE_VECFUNC("__log_finite", "_ZGVbN2v___log_finite", 2)
+TLI_DEFINE_VECFUNC("__log_finite", "_ZGVdN4v___log_finite", 4)
+
+TLI_DEFINE_VECFUNC("__logf_finite", "_ZGVbN4v___logf_finite", 4)
+TLI_DEFINE_VECFUNC("__logf_finite", "_ZGVdN8v___logf_finite", 8)
+
+TLI_DEFINE_VECFUNC("llvm.log.f64", "_ZGVbN2v_log", 2)
+TLI_DEFINE_VECFUNC("llvm.log.f64", "_ZGVdN4v_log", 4)
+
+TLI_DEFINE_VECFUNC("llvm.log.f32", "_ZGVbN4v_logf", 4)
+TLI_DEFINE_VECFUNC("llvm.log.f32", "_ZGVdN8v_logf", 8)
+
 #elif defined(TLI_DEFINE_MASSV_VECFUNCS)
 // IBM MASS library's vector Functions
 
@@ -238,6 +326,93 @@
 TLI_DEFINE_VECFUNC("llvm.log.f32", "__svml_logf8", 8)
 TLI_DEFINE_VECFUNC("llvm.log.f32", "__svml_logf16", 16)
 
+TLI_DEFINE_VECFUNC("log2", "__svml_log22", 2)
+TLI_DEFINE_VECFUNC("log2", "__svml_log24", 4)
+TLI_DEFINE_VECFUNC("log2", "__svml_log28", 8)
+
+TLI_DEFINE_VECFUNC("log2f", "__svml_log2f4", 4)
+TLI_DEFINE_VECFUNC("log2f", "__svml_log2f8", 8)
+TLI_DEFINE_VECFUNC("log2f", "__svml_log2f16", 16)
+
+TLI_DEFINE_VECFUNC("__log2_finite", "__svml_log22", 2)
+TLI_DEFINE_VECFUNC("__log2_finite", "__svml_log24", 4)
+TLI_DEFINE_VECFUNC("__log2_finite", "__svml_log28", 8)
+
+TLI_DEFINE_VECFUNC("__log2f_finite", "__svml_log2f4", 4)
+TLI_DEFINE_VECFUNC("__log2f_finite", "__svml_log2f8", 8)
+TLI_DEFINE_VECFUNC("__log2f_finite", "__svml_log2f16", 16)
+
+TLI_DEFINE_VECFUNC("llvm.log2.f64", "__svml_log22", 2)
+TLI_DEFINE_VECFUNC("llvm.log2.f64", "__svml_log24", 4)
+TLI_DEFINE_VECFUNC("llvm.log2.f64", "__svml_log28", 8)
+
+TLI_DEFINE_VECFUNC("llvm.log2.f32", "__svml_log2f4", 4)
+TLI_DEFINE_VECFUNC("llvm.log2.f32", "__svml_log2f8", 8)
+TLI_DEFINE_VECFUNC("llvm.log2.f32", "__svml_log2f16", 16)
+
+TLI_DEFINE_VECFUNC("log10", "__svml_log102", 2)
+TLI_DEFINE_VECFUNC("log10", "__svml_log104", 4)
+TLI_DEFINE_VECFUNC("log10", "__svml_log108", 8)
+
+TLI_DEFINE_VECFUNC("log10f", "__svml_log10f4", 4)
+TLI_DEFINE_VECFUNC("log10f", "__svml_log10f8", 8)
+TLI_DEFINE_VECFUNC("log10f", "__svml_log10f16", 16)
+
+TLI_DEFINE_VECFUNC("__log10_finite", "__svml_log102", 2)
+TLI_DEFINE_VECFUNC("__log10_finite", "__svml_log104", 4)
+TLI_DEFINE_VECFUNC("__log10_finite", "__svml_log108", 8)
+
+TLI_DEFINE_VECFUNC("__log10f_finite", "__svml_log10f4", 4)
+TLI_DEFINE_VECFUNC("__log10f_finite", "__svml_log10f8", 8)
+TLI_DEFINE_VECFUNC("__log10f_finite", "__svml_log10f16", 16)
+
+TLI_DEFINE_VECFUNC("llvm.log10.f64", "__svml_log102", 2)
+TLI_DEFINE_VECFUNC("llvm.log10.f64", "__svml_log104", 4)
+TLI_DEFINE_VECFUNC("llvm.log10.f64", "__svml_log108", 8)
+
+TLI_DEFINE_VECFUNC("llvm.log10.f32", "__svml_log10f4", 4)
+TLI_DEFINE_VECFUNC("llvm.log10.f32", "__svml_log10f8", 8)
+TLI_DEFINE_VECFUNC("llvm.log10.f32", "__svml_log10f16", 16)
+
+TLI_DEFINE_VECFUNC("sqrt", "__svml_sqrt2", 2)
+TLI_DEFINE_VECFUNC("sqrt", "__svml_sqrt4", 4)
+TLI_DEFINE_VECFUNC("sqrt", "__svml_sqrt8", 8)
+
+TLI_DEFINE_VECFUNC("sqrtf", "__svml_sqrtf4", 4)
+TLI_DEFINE_VECFUNC("sqrtf", "__svml_sqrtf8", 8)
+TLI_DEFINE_VECFUNC("sqrtf", "__svml_sqrtf16", 16)
+
+TLI_DEFINE_VECFUNC("__sqrt_finite", "__svml_sqrt2", 2)
+TLI_DEFINE_VECFUNC("__sqrt_finite", "__svml_sqrt4", 4)
+TLI_DEFINE_VECFUNC("__sqrt_finite", "__svml_sqrt8", 8)
+
+TLI_DEFINE_VECFUNC("__sqrtf_finite", "__svml_sqrtf4", 4)
+TLI_DEFINE_VECFUNC("__sqrtf_finite", "__svml_sqrtf8", 8)
+TLI_DEFINE_VECFUNC("__sqrtf_finite", "__svml_sqrtf16", 16)
+
+TLI_DEFINE_VECFUNC("exp2", "__svml_exp22", 2)
+TLI_DEFINE_VECFUNC("exp2", "__svml_exp24", 4)
+TLI_DEFINE_VECFUNC("exp2", "__svml_exp28", 8)
+
+TLI_DEFINE_VECFUNC("exp2f", "__svml_exp2f4", 4)
+TLI_DEFINE_VECFUNC("exp2f", "__svml_exp2f8", 8)
+TLI_DEFINE_VECFUNC("exp2f", "__svml_exp2f16", 16)
+
+TLI_DEFINE_VECFUNC("llvm.exp2.f64", "__svml_exp22", 2)
+TLI_DEFINE_VECFUNC("llvm.exp2.f64", "__svml_exp24", 4)
+TLI_DEFINE_VECFUNC("llvm.exp2.f64", "__svml_exp28", 8)
+
+TLI_DEFINE_VECFUNC("llvm.exp2.f32", "__svml_exp2f4", 4)
+TLI_DEFINE_VECFUNC("llvm.exp2.f32", "__svml_exp2f8", 8)
+TLI_DEFINE_VECFUNC("llvm.exp2.f32", "__svml_exp2f16", 16)
+
+TLI_DEFINE_VECFUNC("__exp2_finite", "__svml_exp22", 2)
+TLI_DEFINE_VECFUNC("__exp2_finite", "__svml_exp24", 4)
+TLI_DEFINE_VECFUNC("__exp2_finite", "__svml_exp28", 8)
+
+TLI_DEFINE_VECFUNC("__exp2f_finite", "__svml_exp2f4", 4)
+TLI_DEFINE_VECFUNC("__exp2f_finite", "__svml_exp2f8", 8)
+TLI_DEFINE_VECFUNC("__exp2f_finite", "__svml_exp2f16", 16)
 
 #else
 #error "Must choose which vector library functions are to be defined."
@@ -245,6 +420,7 @@
 
 #undef TLI_DEFINE_VECFUNC
 #undef TLI_DEFINE_ACCELERATE_VECFUNCS
+#undef TLI_DEFINE_LIBMVEC_X86_VECFUNCS
 #undef TLI_DEFINE_MASSV_VECFUNCS
 #undef TLI_DEFINE_SVML_VECFUNCS
-
+#undef TLI_DEFINE_MASSV_VECFUNCS_NAMES
diff --git a/linux-x64/clang/include/llvm/Analysis/VectorUtils.h b/linux-x64/clang/include/llvm/Analysis/VectorUtils.h
index d93d2bc..d8fb970 100644
--- a/linux-x64/clang/include/llvm/Analysis/VectorUtils.h
+++ b/linux-x64/clang/include/llvm/Analysis/VectorUtils.h
@@ -14,17 +14,282 @@
 #define LLVM_ANALYSIS_VECTORUTILS_H
 
 #include "llvm/ADT/MapVector.h"
+#include "llvm/ADT/SmallVector.h"
 #include "llvm/Analysis/LoopAccessAnalysis.h"
-#include "llvm/Analysis/TargetLibraryInfo.h"
-#include "llvm/IR/IRBuilder.h"
 #include "llvm/Support/CheckedArithmetic.h"
 
 namespace llvm {
+class TargetLibraryInfo;
+
+/// Describes the type of Parameters
+enum class VFParamKind {
+  Vector,            // No semantic information.
+  OMP_Linear,        // declare simd linear(i)
+  OMP_LinearRef,     // declare simd linear(ref(i))
+  OMP_LinearVal,     // declare simd linear(val(i))
+  OMP_LinearUVal,    // declare simd linear(uval(i))
+  OMP_LinearPos,     // declare simd linear(i:c) uniform(c)
+  OMP_LinearValPos,  // declare simd linear(val(i:c)) uniform(c)
+  OMP_LinearRefPos,  // declare simd linear(ref(i:c)) uniform(c)
+  OMP_LinearUValPos, // declare simd linear(uval(i:c)) uniform(c
+  OMP_Uniform,       // declare simd uniform(i)
+  GlobalPredicate,   // Global logical predicate that acts on all lanes
+                     // of the input and output mask concurrently. For
+                     // example, it is implied by the `M` token in the
+                     // Vector Function ABI mangled name.
+  Unknown
+};
+
+/// Describes the type of Instruction Set Architecture
+enum class VFISAKind {
+  AdvancedSIMD, // AArch64 Advanced SIMD (NEON)
+  SVE,          // AArch64 Scalable Vector Extension
+  SSE,          // x86 SSE
+  AVX,          // x86 AVX
+  AVX2,         // x86 AVX2
+  AVX512,       // x86 AVX512
+  LLVM,         // LLVM internal ISA for functions that are not
+  // attached to an existing ABI via name mangling.
+  Unknown // Unknown ISA
+};
+
+/// Encapsulates information needed to describe a parameter.
+///
+/// The description of the parameter is not linked directly to
+/// OpenMP or any other vector function description. This structure
+/// is extendible to handle other paradigms that describe vector
+/// functions and their parameters.
+struct VFParameter {
+  unsigned ParamPos;         // Parameter Position in Scalar Function.
+  VFParamKind ParamKind;     // Kind of Parameter.
+  int LinearStepOrPos = 0;   // Step or Position of the Parameter.
+  Align Alignment = Align(); // Optional alignment in bytes, defaulted to 1.
+
+  // Comparison operator.
+  bool operator==(const VFParameter &Other) const {
+    return std::tie(ParamPos, ParamKind, LinearStepOrPos, Alignment) ==
+           std::tie(Other.ParamPos, Other.ParamKind, Other.LinearStepOrPos,
+                    Other.Alignment);
+  }
+};
+
+/// Contains the information about the kind of vectorization
+/// available.
+///
+/// This object in independent on the paradigm used to
+/// represent vector functions. in particular, it is not attached to
+/// any target-specific ABI.
+struct VFShape {
+  unsigned VF;     // Vectorization factor.
+  bool IsScalable; // True if the function is a scalable function.
+  SmallVector<VFParameter, 8> Parameters; // List of parameter information.
+  // Comparison operator.
+  bool operator==(const VFShape &Other) const {
+    return std::tie(VF, IsScalable, Parameters) ==
+           std::tie(Other.VF, Other.IsScalable, Other.Parameters);
+  }
+
+  /// Update the parameter in position P.ParamPos to P.
+  void updateParam(VFParameter P) {
+    assert(P.ParamPos < Parameters.size() && "Invalid parameter position.");
+    Parameters[P.ParamPos] = P;
+    assert(hasValidParameterList() && "Invalid parameter list");
+  }
+
+  // Retrieve the VFShape that can be used to map a (scalar) function to itself,
+  // with VF = 1.
+  static VFShape getScalarShape(const CallInst &CI) {
+    return VFShape::get(CI, ElementCount::getFixed(1),
+                        /*HasGlobalPredicate*/ false);
+  }
+
+  // Retrieve the basic vectorization shape of the function, where all
+  // parameters are mapped to VFParamKind::Vector with \p EC
+  // lanes. Specifies whether the function has a Global Predicate
+  // argument via \p HasGlobalPred.
+  static VFShape get(const CallInst &CI, ElementCount EC, bool HasGlobalPred) {
+    SmallVector<VFParameter, 8> Parameters;
+    for (unsigned I = 0; I < CI.arg_size(); ++I)
+      Parameters.push_back(VFParameter({I, VFParamKind::Vector}));
+    if (HasGlobalPred)
+      Parameters.push_back(
+          VFParameter({CI.arg_size(), VFParamKind::GlobalPredicate}));
+
+    return {EC.getKnownMinValue(), EC.isScalable(), Parameters};
+  }
+  /// Sanity check on the Parameters in the VFShape.
+  bool hasValidParameterList() const;
+};
+
+/// Holds the VFShape for a specific scalar to vector function mapping.
+struct VFInfo {
+  VFShape Shape;          /// Classification of the vector function.
+  std::string ScalarName; /// Scalar Function Name.
+  std::string VectorName; /// Vector Function Name associated to this VFInfo.
+  VFISAKind ISA;          /// Instruction Set Architecture.
+
+  // Comparison operator.
+  bool operator==(const VFInfo &Other) const {
+    return std::tie(Shape, ScalarName, VectorName, ISA) ==
+           std::tie(Shape, Other.ScalarName, Other.VectorName, Other.ISA);
+  }
+};
+
+namespace VFABI {
+/// LLVM Internal VFABI ISA token for vector functions.
+static constexpr char const *_LLVM_ = "_LLVM_";
+/// Prefix for internal name redirection for vector function that
+/// tells the compiler to scalarize the call using the scalar name
+/// of the function. For example, a mangled name like
+/// `_ZGV_LLVM_N2v_foo(_LLVM_Scalarize_foo)` would tell the
+/// vectorizer to vectorize the scalar call `foo`, and to scalarize
+/// it once vectorization is done.
+static constexpr char const *_LLVM_Scalarize_ = "_LLVM_Scalarize_";
+
+/// Function to construct a VFInfo out of a mangled names in the
+/// following format:
+///
+/// <VFABI_name>{(<redirection>)}
+///
+/// where <VFABI_name> is the name of the vector function, mangled according
+/// to the rules described in the Vector Function ABI of the target vector
+/// extension (or <isa> from now on). The <VFABI_name> is in the following
+/// format:
+///
+/// _ZGV<isa><mask><vlen><parameters>_<scalarname>[(<redirection>)]
+///
+/// This methods support demangling rules for the following <isa>:
+///
+/// * AArch64: https://developer.arm.com/docs/101129/latest
+///
+/// * x86 (libmvec): https://sourceware.org/glibc/wiki/libmvec and
+///  https://sourceware.org/glibc/wiki/libmvec?action=AttachFile&do=view&target=VectorABI.txt
+///
+/// \param MangledName -> input string in the format
+/// _ZGV<isa><mask><vlen><parameters>_<scalarname>[(<redirection>)].
+/// \param M -> Module used to retrieve informations about the vector
+/// function that are not possible to retrieve from the mangled
+/// name. At the moment, this parameter is needed only to retrieve the
+/// Vectorization Factor of scalable vector functions from their
+/// respective IR declarations.
+Optional<VFInfo> tryDemangleForVFABI(StringRef MangledName, const Module &M);
+
+/// This routine mangles the given VectorName according to the LangRef
+/// specification for vector-function-abi-variant attribute and is specific to
+/// the TLI mappings. It is the responsibility of the caller to make sure that
+/// this is only used if all parameters in the vector function are vector type.
+/// This returned string holds scalar-to-vector mapping:
+///    _ZGV<isa><mask><vlen><vparams>_<scalarname>(<vectorname>)
+///
+/// where:
+///
+/// <isa> = "_LLVM_"
+/// <mask> = "N". Note: TLI does not support masked interfaces.
+/// <vlen> = Number of concurrent lanes, stored in the `VectorizationFactor`
+///          field of the `VecDesc` struct.
+/// <vparams> = "v", as many as are the numArgs.
+/// <scalarname> = the name of the scalar function.
+/// <vectorname> = the name of the vector function.
+std::string mangleTLIVectorName(StringRef VectorName, StringRef ScalarName,
+                                unsigned numArgs, unsigned VF);
+
+/// Retrieve the `VFParamKind` from a string token.
+VFParamKind getVFParamKindFromString(const StringRef Token);
+
+// Name of the attribute where the variant mappings are stored.
+static constexpr char const *MappingsAttrName = "vector-function-abi-variant";
+
+/// Populates a set of strings representing the Vector Function ABI variants
+/// associated to the CallInst CI. If the CI does not contain the
+/// vector-function-abi-variant attribute, we return without populating
+/// VariantMappings, i.e. callers of getVectorVariantNames need not check for
+/// the presence of the attribute (see InjectTLIMappings).
+void getVectorVariantNames(const CallInst &CI,
+                           SmallVectorImpl<std::string> &VariantMappings);
+} // end namespace VFABI
+
+/// The Vector Function Database.
+///
+/// Helper class used to find the vector functions associated to a
+/// scalar CallInst.
+class VFDatabase {
+  /// The Module of the CallInst CI.
+  const Module *M;
+  /// The CallInst instance being queried for scalar to vector mappings.
+  const CallInst &CI;
+  /// List of vector functions descriptors associated to the call
+  /// instruction.
+  const SmallVector<VFInfo, 8> ScalarToVectorMappings;
+
+  /// Retrieve the scalar-to-vector mappings associated to the rule of
+  /// a vector Function ABI.
+  static void getVFABIMappings(const CallInst &CI,
+                               SmallVectorImpl<VFInfo> &Mappings) {
+    if (!CI.getCalledFunction())
+      return;
+
+    const StringRef ScalarName = CI.getCalledFunction()->getName();
+
+    SmallVector<std::string, 8> ListOfStrings;
+    // The check for the vector-function-abi-variant attribute is done when
+    // retrieving the vector variant names here.
+    VFABI::getVectorVariantNames(CI, ListOfStrings);
+    if (ListOfStrings.empty())
+      return;
+    for (const auto &MangledName : ListOfStrings) {
+      const Optional<VFInfo> Shape =
+          VFABI::tryDemangleForVFABI(MangledName, *(CI.getModule()));
+      // A match is found via scalar and vector names, and also by
+      // ensuring that the variant described in the attribute has a
+      // corresponding definition or declaration of the vector
+      // function in the Module M.
+      if (Shape.hasValue() && (Shape.getValue().ScalarName == ScalarName)) {
+        assert(CI.getModule()->getFunction(Shape.getValue().VectorName) &&
+               "Vector function is missing.");
+        Mappings.push_back(Shape.getValue());
+      }
+    }
+  }
+
+public:
+  /// Retrieve all the VFInfo instances associated to the CallInst CI.
+  static SmallVector<VFInfo, 8> getMappings(const CallInst &CI) {
+    SmallVector<VFInfo, 8> Ret;
+
+    // Get mappings from the Vector Function ABI variants.
+    getVFABIMappings(CI, Ret);
+
+    // Other non-VFABI variants should be retrieved here.
+
+    return Ret;
+  }
+
+  /// Constructor, requires a CallInst instance.
+  VFDatabase(CallInst &CI)
+      : M(CI.getModule()), CI(CI),
+        ScalarToVectorMappings(VFDatabase::getMappings(CI)) {}
+  /// \defgroup VFDatabase query interface.
+  ///
+  /// @{
+  /// Retrieve the Function with VFShape \p Shape.
+  Function *getVectorizedFunction(const VFShape &Shape) const {
+    if (Shape == VFShape::getScalarShape(CI))
+      return CI.getCalledFunction();
+
+    for (const auto &Info : ScalarToVectorMappings)
+      if (Info.Shape == Shape)
+        return M->getFunction(Info.VectorName);
+
+    return nullptr;
+  }
+  /// @}
+};
 
 template <typename T> class ArrayRef;
 class DemandedBits;
 class GetElementPtrInst;
 template <typename InstTy> class InterleaveGroup;
+class IRBuilderBase;
 class Loop;
 class ScalarEvolution;
 class TargetTransformInfo;
@@ -32,7 +297,20 @@
 class Value;
 
 namespace Intrinsic {
-enum ID : unsigned;
+typedef unsigned ID;
+}
+
+/// A helper function for converting Scalar types to vector types. If
+/// the incoming type is void, we return void. If the EC represents a
+/// scalar, we return the scalar type.
+inline Type *ToVectorTy(Type *Scalar, ElementCount EC) {
+  if (Scalar->isVoidTy() || EC.isScalar())
+    return Scalar;
+  return VectorType::get(Scalar, EC);
+}
+
+inline Type *ToVectorTy(Type *Scalar, unsigned VF) {
+  return ToVectorTy(Scalar, ElementCount::getFixed(VF));
 }
 
 /// Identify if the intrinsic is trivially vectorizable.
@@ -72,16 +350,55 @@
 /// from the vector.
 Value *findScalarElement(Value *V, unsigned EltNo);
 
+/// If all non-negative \p Mask elements are the same value, return that value.
+/// If all elements are negative (undefined) or \p Mask contains different
+/// non-negative values, return -1.
+int getSplatIndex(ArrayRef<int> Mask);
+
 /// Get splat value if the input is a splat vector or return nullptr.
 /// The value may be extracted from a splat constants vector or from
 /// a sequence of instructions that broadcast a single value into a vector.
-const Value *getSplatValue(const Value *V);
+Value *getSplatValue(const Value *V);
 
-/// Return true if the input value is known to be a vector with all identical
-/// elements (potentially including undefined elements).
+/// Return true if each element of the vector value \p V is poisoned or equal to
+/// every other non-poisoned element. If an index element is specified, either
+/// every element of the vector is poisoned or the element at that index is not
+/// poisoned and equal to every other non-poisoned element.
 /// This may be more powerful than the related getSplatValue() because it is
 /// not limited by finding a scalar source value to a splatted vector.
-bool isSplatValue(const Value *V, unsigned Depth = 0);
+bool isSplatValue(const Value *V, int Index = -1, unsigned Depth = 0);
+
+/// Replace each shuffle mask index with the scaled sequential indices for an
+/// equivalent mask of narrowed elements. Mask elements that are less than 0
+/// (sentinel values) are repeated in the output mask.
+///
+/// Example with Scale = 4:
+///   <4 x i32> <3, 2, 0, -1> -->
+///   <16 x i8> <12, 13, 14, 15, 8, 9, 10, 11, 0, 1, 2, 3, -1, -1, -1, -1>
+///
+/// This is the reverse process of widening shuffle mask elements, but it always
+/// succeeds because the indexes can always be multiplied (scaled up) to map to
+/// narrower vector elements.
+void narrowShuffleMaskElts(int Scale, ArrayRef<int> Mask,
+                           SmallVectorImpl<int> &ScaledMask);
+
+/// Try to transform a shuffle mask by replacing elements with the scaled index
+/// for an equivalent mask of widened elements. If all mask elements that would
+/// map to a wider element of the new mask are the same negative number
+/// (sentinel value), that element of the new mask is the same value. If any
+/// element in a given slice is negative and some other element in that slice is
+/// not the same value, return false (partial matches with sentinel values are
+/// not allowed).
+///
+/// Example with Scale = 4:
+///   <16 x i8> <12, 13, 14, 15, 8, 9, 10, 11, 0, 1, 2, 3, -1, -1, -1, -1> -->
+///   <4 x i32> <3, 2, 0, -1>
+///
+/// This is the reverse process of narrowing shuffle mask elements if it
+/// succeeds. This transform is not always possible because indexes may not
+/// divide evenly (scale down) to map to wider vector elements.
+bool widenShuffleMaskElts(int Scale, ArrayRef<int> Mask,
+                          SmallVectorImpl<int> &ScaledMask);
 
 /// Compute a map of integer instructions to their minimum legal type
 /// size.
@@ -158,7 +475,7 @@
 /// Note: The result is a mask of 0's and 1's, as opposed to the other
 /// create[*]Mask() utilities which create a shuffle mask (mask that
 /// consists of indices).
-Constant *createBitMaskForGaps(IRBuilder<> &Builder, unsigned VF,
+Constant *createBitMaskForGaps(IRBuilderBase &Builder, unsigned VF,
                                const InterleaveGroup<Instruction> &Group);
 
 /// Create a mask with replicated elements.
@@ -173,8 +490,8 @@
 /// For example, the mask for \p ReplicationFactor=3 and \p VF=4 is:
 ///
 ///   <0,0,0,1,1,1,2,2,2,3,3,3>
-Constant *createReplicatedMask(IRBuilder<> &Builder, unsigned ReplicationFactor,
-                               unsigned VF);
+llvm::SmallVector<int, 16> createReplicatedMask(unsigned ReplicationFactor,
+                                                unsigned VF);
 
 /// Create an interleave shuffle mask.
 ///
@@ -187,8 +504,7 @@
 /// For example, the mask for VF = 4 and NumVecs = 2 is:
 ///
 ///   <0, 4, 1, 5, 2, 6, 3, 7>.
-Constant *createInterleaveMask(IRBuilder<> &Builder, unsigned VF,
-                               unsigned NumVecs);
+llvm::SmallVector<int, 16> createInterleaveMask(unsigned VF, unsigned NumVecs);
 
 /// Create a stride shuffle mask.
 ///
@@ -202,8 +518,8 @@
 /// For example, the mask for Start = 0, Stride = 2, and VF = 4 is:
 ///
 ///   <0, 2, 4, 6>
-Constant *createStrideMask(IRBuilder<> &Builder, unsigned Start,
-                           unsigned Stride, unsigned VF);
+llvm::SmallVector<int, 16> createStrideMask(unsigned Start, unsigned Stride,
+                                            unsigned VF);
 
 /// Create a sequential shuffle mask.
 ///
@@ -216,8 +532,8 @@
 /// For example, the mask for Start = 0, NumInsts = 4, and NumUndefs = 4 is:
 ///
 ///   <0, 1, 2, 3, undef, undef, undef, undef>
-Constant *createSequentialMask(IRBuilder<> &Builder, unsigned Start,
-                               unsigned NumInts, unsigned NumUndefs);
+llvm::SmallVector<int, 16>
+createSequentialMask(unsigned Start, unsigned NumInts, unsigned NumUndefs);
 
 /// Concatenate a list of vectors.
 ///
@@ -226,22 +542,22 @@
 /// their element types should be the same. The number of elements in the
 /// vectors should also be the same; however, if the last vector has fewer
 /// elements, it will be padded with undefs.
-Value *concatenateVectors(IRBuilder<> &Builder, ArrayRef<Value *> Vecs);
+Value *concatenateVectors(IRBuilderBase &Builder, ArrayRef<Value *> Vecs);
 
-/// Given a mask vector of the form <Y x i1>, Return true if all of the
-/// elements of this predicate mask are false or undef.  That is, return true
-/// if all lanes can be assumed inactive. 
+/// Given a mask vector of i1, Return true if all of the elements of this
+/// predicate mask are known to be false or undef.  That is, return true if all
+/// lanes can be assumed inactive.
 bool maskIsAllZeroOrUndef(Value *Mask);
 
-/// Given a mask vector of the form <Y x i1>, Return true if all of the
-/// elements of this predicate mask are true or undef.  That is, return true
-/// if all lanes can be assumed active. 
+/// Given a mask vector of i1, Return true if all of the elements of this
+/// predicate mask are known to be true or undef.  That is, return true if all
+/// lanes can be assumed active.
 bool maskIsAllOneOrUndef(Value *Mask);
 
 /// Given a mask vector of the form <Y x i1>, return an APInt (of bitwidth Y)
 /// for each lane which may be active.
 APInt possiblyDemandedEltsInMask(Value *Mask);
-  
+
 /// The group of interleaved loads/stores sharing the same stride and
 /// close to each other.
 ///
@@ -270,13 +586,12 @@
 /// the interleaved store group doesn't allow gaps.
 template <typename InstTy> class InterleaveGroup {
 public:
-  InterleaveGroup(uint32_t Factor, bool Reverse, uint32_t Align)
-      : Factor(Factor), Reverse(Reverse), Align(Align), InsertPos(nullptr) {}
+  InterleaveGroup(uint32_t Factor, bool Reverse, Align Alignment)
+      : Factor(Factor), Reverse(Reverse), Alignment(Alignment),
+        InsertPos(nullptr) {}
 
-  InterleaveGroup(InstTy *Instr, int32_t Stride, uint32_t Align)
-      : Align(Align), InsertPos(Instr) {
-    assert(Align && "The alignment should be non-zero");
-
+  InterleaveGroup(InstTy *Instr, int32_t Stride, Align Alignment)
+      : Alignment(Alignment), InsertPos(Instr) {
     Factor = std::abs(Stride);
     assert(Factor > 1 && "Invalid interleave factor");
 
@@ -286,7 +601,11 @@
 
   bool isReverse() const { return Reverse; }
   uint32_t getFactor() const { return Factor; }
-  uint32_t getAlignment() const { return Align; }
+  LLVM_ATTRIBUTE_DEPRECATED(uint32_t getAlignment() const,
+                            "Use getAlign instead.") {
+    return Alignment.value();
+  }
+  Align getAlign() const { return Alignment; }
   uint32_t getNumMembers() const { return Members.size(); }
 
   /// Try to insert a new member \p Instr with index \p Index and
@@ -294,9 +613,7 @@
   /// negative if it is the new leader.
   ///
   /// \returns false if the instruction doesn't belong to the group.
-  bool insertMember(InstTy *Instr, int32_t Index, uint32_t NewAlign) {
-    assert(NewAlign && "The new member's alignment should be non-zero");
-
+  bool insertMember(InstTy *Instr, int32_t Index, Align NewAlign) {
     // Make sure the key fits in an int32_t.
     Optional<int32_t> MaybeKey = checkedAdd(Index, SmallestKey);
     if (!MaybeKey)
@@ -328,7 +645,7 @@
     }
 
     // It's always safe to select the minimum alignment.
-    Align = std::min(Align, NewAlign);
+    Alignment = std::min(Alignment, NewAlign);
     Members[Key] = Instr;
     return true;
   }
@@ -338,11 +655,7 @@
   /// \returns nullptr if contains no such member.
   InstTy *getMember(uint32_t Index) const {
     int32_t Key = SmallestKey + Index;
-    auto Member = Members.find(Key);
-    if (Member == Members.end())
-      return nullptr;
-
-    return Member->second;
+    return Members.lookup(Key);
   }
 
   /// Get the index for the given member. Unlike the key in the member
@@ -387,7 +700,7 @@
 private:
   uint32_t Factor; // Interleave Factor.
   bool Reverse;
-  uint32_t Align;
+  Align Alignment;
   DenseMap<int32_t, InstTy *> Members;
   int32_t SmallestKey = 0;
   int32_t LargestKey = 0;
@@ -421,7 +734,7 @@
                         const LoopAccessInfo *LAI)
       : PSE(PSE), TheLoop(L), DT(DT), LI(LI), LAI(LAI) {}
 
-  ~InterleavedAccessInfo() { reset(); }
+  ~InterleavedAccessInfo() { invalidateGroups(); }
 
   /// Analyze the interleaved accesses and collect them in interleave
   /// groups. Substitute symbolic strides using \p Strides.
@@ -432,18 +745,23 @@
   /// Invalidate groups, e.g., in case all blocks in loop will be predicated
   /// contrary to original assumption. Although we currently prevent group
   /// formation for predicated accesses, we may be able to relax this limitation
-  /// in the future once we handle more complicated blocks.
-  void reset() {
-    SmallPtrSet<InterleaveGroup<Instruction> *, 4> DelSet;
-    // Avoid releasing a pointer twice.
-    for (auto &I : InterleaveGroupMap)
-      DelSet.insert(I.second);
-    for (auto *Ptr : DelSet)
-      delete Ptr;
-    InterleaveGroupMap.clear();
-    RequiresScalarEpilogue = false;
-  }
+  /// in the future once we handle more complicated blocks. Returns true if any
+  /// groups were invalidated.
+  bool invalidateGroups() {
+    if (InterleaveGroups.empty()) {
+      assert(
+          !RequiresScalarEpilogue &&
+          "RequiresScalarEpilog should not be set without interleave groups");
+      return false;
+    }
 
+    InterleaveGroupMap.clear();
+    for (auto *Ptr : InterleaveGroups)
+      delete Ptr;
+    InterleaveGroups.clear();
+    RequiresScalarEpilogue = false;
+    return true;
+  }
 
   /// Check if \p Instr belongs to any interleave group.
   bool isInterleaved(Instruction *Instr) const {
@@ -455,9 +773,7 @@
   /// \returns nullptr if doesn't have such group.
   InterleaveGroup<Instruction> *
   getInterleaveGroup(const Instruction *Instr) const {
-    if (InterleaveGroupMap.count(Instr))
-      return InterleaveGroupMap.find(Instr)->second;
-    return nullptr;
+    return InterleaveGroupMap.lookup(Instr);
   }
 
   iterator_range<SmallPtrSetIterator<llvm::InterleaveGroup<Instruction> *>>
@@ -504,8 +820,8 @@
   struct StrideDescriptor {
     StrideDescriptor() = default;
     StrideDescriptor(int64_t Stride, const SCEV *Scev, uint64_t Size,
-                     unsigned Align)
-        : Stride(Stride), Scev(Scev), Size(Size), Align(Align) {}
+                     Align Alignment)
+        : Stride(Stride), Scev(Scev), Size(Size), Alignment(Alignment) {}
 
     // The access's stride. It is negative for a reverse access.
     int64_t Stride = 0;
@@ -517,7 +833,7 @@
     uint64_t Size = 0;
 
     // The alignment of this access.
-    unsigned Align = 0;
+    Align Alignment;
   };
 
   /// A type for holding instructions and their stride descriptors.
@@ -528,11 +844,11 @@
   ///
   /// \returns the newly created interleave group.
   InterleaveGroup<Instruction> *
-  createInterleaveGroup(Instruction *Instr, int Stride, unsigned Align) {
+  createInterleaveGroup(Instruction *Instr, int Stride, Align Alignment) {
     assert(!InterleaveGroupMap.count(Instr) &&
            "Already in an interleaved access group");
     InterleaveGroupMap[Instr] =
-        new InterleaveGroup<Instruction>(Instr, Stride, Align);
+        new InterleaveGroup<Instruction>(Instr, Stride, Alignment);
     InterleaveGroups.insert(InterleaveGroupMap[Instr]);
     return InterleaveGroupMap[Instr];
   }
diff --git a/linux-x64/clang/include/llvm/AsmParser/Parser.h b/linux-x64/clang/include/llvm/AsmParser/Parser.h
index b0c6034..e1c7f74 100644
--- a/linux-x64/clang/include/llvm/AsmParser/Parser.h
+++ b/linux-x64/clang/include/llvm/AsmParser/Parser.h
@@ -13,18 +13,24 @@
 #ifndef LLVM_ASMPARSER_PARSER_H
 #define LLVM_ASMPARSER_PARSER_H
 
-#include "llvm/Support/MemoryBuffer.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/StringRef.h"
+#include <memory>
 
 namespace llvm {
 
 class Constant;
 class LLVMContext;
+class MemoryBufferRef;
 class Module;
 class ModuleSummaryIndex;
 struct SlotMapping;
 class SMDiagnostic;
 class Type;
 
+typedef llvm::function_ref<Optional<std::string>(StringRef)>
+    DataLayoutCallbackTy;
+
 /// This function is a main interface to the LLVM Assembly Parser. It parses
 /// an ASCII file that (presumably) contains LLVM Assembly code. It returns a
 /// Module (intermediate representation) with the corresponding features. Note
@@ -36,14 +42,9 @@
 /// \param Context Context in which to allocate globals info.
 /// \param Slots The optional slot mapping that will be initialized during
 ///              parsing.
-/// \param UpgradeDebugInfo Run UpgradeDebugInfo, which runs the Verifier.
-///                         This option should only be set to false by llvm-as
-///                         for use inside the LLVM testuite!
-/// \param DataLayoutString Override datalayout in the llvm assembly.
-std::unique_ptr<Module>
-parseAssemblyFile(StringRef Filename, SMDiagnostic &Err, LLVMContext &Context,
-                  SlotMapping *Slots = nullptr, bool UpgradeDebugInfo = true,
-                  StringRef DataLayoutString = "");
+std::unique_ptr<Module> parseAssemblyFile(StringRef Filename, SMDiagnostic &Err,
+                                          LLVMContext &Context,
+                                          SlotMapping *Slots = nullptr);
 
 /// The function is a secondary interface to the LLVM Assembly Parser. It parses
 /// an ASCII string that (presumably) contains LLVM Assembly code. It returns a
@@ -56,16 +57,10 @@
 /// \param Context Context in which to allocate globals info.
 /// \param Slots The optional slot mapping that will be initialized during
 ///              parsing.
-/// \param UpgradeDebugInfo Run UpgradeDebugInfo, which runs the Verifier.
-///                         This option should only be set to false by llvm-as
-///                         for use inside the LLVM testuite!
-/// \param DataLayoutString Override datalayout in the llvm assembly.
 std::unique_ptr<Module> parseAssemblyString(StringRef AsmString,
                                             SMDiagnostic &Err,
                                             LLVMContext &Context,
-                                            SlotMapping *Slots = nullptr,
-                                            bool UpgradeDebugInfo = true,
-                                            StringRef DataLayoutString = "");
+                                            SlotMapping *Slots = nullptr);
 
 /// Holds the Module and ModuleSummaryIndex returned by the interfaces
 /// that parse both.
@@ -86,15 +81,16 @@
 /// \param Context Context in which to allocate globals info.
 /// \param Slots The optional slot mapping that will be initialized during
 ///              parsing.
-/// \param UpgradeDebugInfo Run UpgradeDebugInfo, which runs the Verifier.
-///                         This option should only be set to false by llvm-as
-///                         for use inside the LLVM testuite!
-/// \param DataLayoutString Override datalayout in the llvm assembly.
-ParsedModuleAndIndex
-parseAssemblyFileWithIndex(StringRef Filename, SMDiagnostic &Err,
-                           LLVMContext &Context, SlotMapping *Slots = nullptr,
-                           bool UpgradeDebugInfo = true,
-                           StringRef DataLayoutString = "");
+/// \param DataLayoutCallback Override datalayout in the llvm assembly.
+ParsedModuleAndIndex parseAssemblyFileWithIndex(
+    StringRef Filename, SMDiagnostic &Err, LLVMContext &Context,
+    SlotMapping *Slots = nullptr,
+    DataLayoutCallbackTy DataLayoutCallback = [](StringRef) { return None; });
+
+/// Only for use in llvm-as for testing; this does not produce a valid module.
+ParsedModuleAndIndex parseAssemblyFileWithIndexNoUpgradeDebugInfo(
+    StringRef Filename, SMDiagnostic &Err, LLVMContext &Context,
+    SlotMapping *Slots, DataLayoutCallbackTy DataLayoutCallback);
 
 /// This function is a main interface to the LLVM Assembly Parser. It parses
 /// an ASCII file that (presumably) contains LLVM Assembly code for a module
@@ -113,15 +109,11 @@
 /// \param Err Error result info.
 /// \param Slots The optional slot mapping that will be initialized during
 ///              parsing.
-/// \param UpgradeDebugInfo Run UpgradeDebugInfo, which runs the Verifier.
-///                         This option should only be set to false by llvm-as
-///                         for use inside the LLVM testuite!
-/// \param DataLayoutString Override datalayout in the llvm assembly.
-std::unique_ptr<Module> parseAssembly(MemoryBufferRef F, SMDiagnostic &Err,
-                                      LLVMContext &Context,
-                                      SlotMapping *Slots = nullptr,
-                                      bool UpgradeDebugInfo = true,
-                                      StringRef DataLayoutString = "");
+/// \param DataLayoutCallback Override datalayout in the llvm assembly.
+std::unique_ptr<Module> parseAssembly(
+    MemoryBufferRef F, SMDiagnostic &Err, LLVMContext &Context,
+    SlotMapping *Slots = nullptr,
+    DataLayoutCallbackTy DataLayoutCallback = [](StringRef) { return None; });
 
 /// Parse LLVM Assembly including the summary index from a MemoryBuffer.
 ///
@@ -129,18 +121,12 @@
 /// \param Err Error result info.
 /// \param Slots The optional slot mapping that will be initialized during
 ///              parsing.
-/// \param UpgradeDebugInfo Run UpgradeDebugInfo, which runs the Verifier.
-///                         This option should only be set to false by llvm-as
-///                         for use inside the LLVM testuite!
-/// \param DataLayoutString Override datalayout in the llvm assembly.
 ///
 /// parseAssemblyFileWithIndex is a wrapper around this function.
 ParsedModuleAndIndex parseAssemblyWithIndex(MemoryBufferRef F,
                                             SMDiagnostic &Err,
                                             LLVMContext &Context,
-                                            SlotMapping *Slots = nullptr,
-                                            bool UpgradeDebugInfo = true,
-                                            StringRef DataLayoutString = "");
+                                            SlotMapping *Slots = nullptr);
 
 /// Parse LLVM Assembly for summary index from a MemoryBuffer.
 ///
@@ -163,14 +149,11 @@
 /// \param Slots The optional slot mapping that will be initialized during
 ///              parsing.
 /// \return true on error.
-/// \param UpgradeDebugInfo Run UpgradeDebugInfo, which runs the Verifier.
-///                         This option should only be set to false by llvm-as
-///                         for use inside the LLVM testuite!
-/// \param DataLayoutString Override datalayout in the llvm assembly.
-bool parseAssemblyInto(MemoryBufferRef F, Module *M, ModuleSummaryIndex *Index,
-                       SMDiagnostic &Err, SlotMapping *Slots = nullptr,
-                       bool UpgradeDebugInfo = true,
-                       StringRef DataLayoutString = "");
+/// \param DataLayoutCallback Override datalayout in the llvm assembly.
+bool parseAssemblyInto(
+    MemoryBufferRef F, Module *M, ModuleSummaryIndex *Index, SMDiagnostic &Err,
+    SlotMapping *Slots = nullptr,
+    DataLayoutCallbackTy DataLayoutCallback = [](StringRef) { return None; });
 
 /// Parse a type and a constant value in the given string.
 ///
diff --git a/linux-x64/clang/include/llvm/BinaryFormat/COFF.h b/linux-x64/clang/include/llvm/BinaryFormat/COFF.h
index 0fe38a4..716d649 100644
--- a/linux-x64/clang/include/llvm/BinaryFormat/COFF.h
+++ b/linux-x64/clang/include/llvm/BinaryFormat/COFF.h
@@ -311,6 +311,7 @@
   IMAGE_SCN_ALIGN_2048BYTES = 0x00C00000,
   IMAGE_SCN_ALIGN_4096BYTES = 0x00D00000,
   IMAGE_SCN_ALIGN_8192BYTES = 0x00E00000,
+  IMAGE_SCN_ALIGN_MASK = 0x00F00000,
   IMAGE_SCN_LNK_NRELOC_OVFL = 0x01000000,
   IMAGE_SCN_MEM_DISCARDABLE = 0x02000000,
   IMAGE_SCN_MEM_NOT_CACHED = 0x04000000,
@@ -547,7 +548,7 @@
   uint32_t AddressOfEntryPoint; // RVA
   uint32_t BaseOfCode;          // RVA
   uint32_t BaseOfData;          // RVA
-  uint32_t ImageBase;
+  uint64_t ImageBase;
   uint32_t SectionAlignment;
   uint32_t FileAlignment;
   uint16_t MajorOperatingSystemVersion;
@@ -563,10 +564,10 @@
   uint16_t Subsystem;
   // FIXME: This should be DllCharacteristics to match the COFF spec.
   uint16_t DLLCharacteristics;
-  uint32_t SizeOfStackReserve;
-  uint32_t SizeOfStackCommit;
-  uint32_t SizeOfHeapReserve;
-  uint32_t SizeOfHeapCommit;
+  uint64_t SizeOfStackReserve;
+  uint64_t SizeOfStackCommit;
+  uint64_t SizeOfHeapReserve;
+  uint64_t SizeOfHeapCommit;
   uint32_t LoaderFlags;
   // FIXME: This should be NumberOfRvaAndSizes to match the COFF spec.
   uint32_t NumberOfRvaAndSize;
@@ -642,6 +643,11 @@
   IMAGE_DLL_CHARACTERISTICS_TERMINAL_SERVER_AWARE = 0x8000
 };
 
+enum ExtendedDLLCharacteristics : unsigned {
+  /// Image is CET compatible
+  IMAGE_DLL_CHARACTERISTICS_EX_CET_COMPAT = 0x0001
+};
+
 enum DebugType : unsigned {
   IMAGE_DEBUG_TYPE_UNKNOWN = 0,
   IMAGE_DEBUG_TYPE_COFF = 1,
@@ -660,6 +666,7 @@
   IMAGE_DEBUG_TYPE_ILTCG = 14,
   IMAGE_DEBUG_TYPE_MPX = 15,
   IMAGE_DEBUG_TYPE_REPRO = 16,
+  IMAGE_DEBUG_TYPE_EX_DLLCHARACTERISTICS = 20,
 };
 
 enum BaseRelocationType : unsigned {
diff --git a/linux-x64/clang/include/llvm/BinaryFormat/Dwarf.def b/linux-x64/clang/include/llvm/BinaryFormat/Dwarf.def
index b0f78d0..f69877b 100644
--- a/linux-x64/clang/include/llvm/BinaryFormat/Dwarf.def
+++ b/linux-x64/clang/include/llvm/BinaryFormat/Dwarf.def
@@ -17,16 +17,27 @@
     defined HANDLE_DW_VIRTUALITY || defined HANDLE_DW_DEFAULTED ||             \
     defined HANDLE_DW_CC || defined HANDLE_DW_LNS || defined HANDLE_DW_LNE ||  \
     defined HANDLE_DW_LNCT || defined HANDLE_DW_MACRO ||                       \
-    defined HANDLE_DW_RLE ||                                                   \
+    defined HANDLE_DW_MACRO_GNU || defined HANDLE_MACRO_FLAG ||                \
+    defined HANDLE_DW_RLE || defined HANDLE_DW_LLE ||                          \
     (defined HANDLE_DW_CFA && defined HANDLE_DW_CFA_PRED) ||                   \
     defined HANDLE_DW_APPLE_PROPERTY || defined HANDLE_DW_UT ||                \
     defined HANDLE_DWARF_SECTION || defined HANDLE_DW_IDX ||                   \
-    defined HANDLE_DW_END)
+    defined HANDLE_DW_END || defined HANDLE_DW_SECT)
 #error "Missing macro definition of HANDLE_DW*"
 #endif
 
 #ifndef HANDLE_DW_TAG
-#define HANDLE_DW_TAG(ID, NAME, VERSION, VENDOR)
+#define HANDLE_DW_TAG(ID, NAME, VERSION, VENDOR, KIND)
+#endif
+
+// Note that DW_KIND is not a DWARF concept, but rather a way for us to
+// generate a list of tags that belong together.
+#ifndef DW_KIND_NONE
+#define DW_KIND_NONE 0
+#endif
+
+#ifndef DW_KIND_TYPE
+#define DW_KIND_TYPE 1
 #endif
 
 #ifndef HANDLE_DW_AT
@@ -77,10 +88,22 @@
 #define HANDLE_DW_MACRO(ID, NAME)
 #endif
 
+#ifndef HANDLE_DW_MACRO_GNU
+#define HANDLE_DW_MACRO_GNU(ID, NAME)
+#endif
+
+#ifndef HANDLE_MACRO_FLAG
+#define HANDLE_MACRO_FLAG(ID, NAME)
+#endif
+
 #ifndef HANDLE_DW_RLE
 #define HANDLE_DW_RLE(ID, NAME)
 #endif
 
+#ifndef HANDLE_DW_LLE
+#define HANDLE_DW_LLE(ID, NAME)
+#endif
+
 #ifndef HANDLE_DW_CFA
 #define HANDLE_DW_CFA(ID, NAME)
 #endif
@@ -98,7 +121,7 @@
 #endif
 
 #ifndef HANDLE_DWARF_SECTION
-#define HANDLE_DWARF_SECTION(ENUM_NAME, ELF_NAME, CMDLINE_NAME)
+#define HANDLE_DWARF_SECTION(ENUM_NAME, ELF_NAME, CMDLINE_NAME, OPTION)
 #endif
 
 #ifndef HANDLE_DW_IDX
@@ -109,94 +132,98 @@
 #define HANDLE_DW_END(ID, NAME)
 #endif
 
-HANDLE_DW_TAG(0x0000, null, 2, DWARF)
-HANDLE_DW_TAG(0x0001, array_type, 2, DWARF)
-HANDLE_DW_TAG(0x0002, class_type, 2, DWARF)
-HANDLE_DW_TAG(0x0003, entry_point, 2, DWARF)
-HANDLE_DW_TAG(0x0004, enumeration_type, 2, DWARF)
-HANDLE_DW_TAG(0x0005, formal_parameter, 2, DWARF)
-HANDLE_DW_TAG(0x0008, imported_declaration, 2, DWARF)
-HANDLE_DW_TAG(0x000a, label, 2, DWARF)
-HANDLE_DW_TAG(0x000b, lexical_block, 2, DWARF)
-HANDLE_DW_TAG(0x000d, member, 2, DWARF)
-HANDLE_DW_TAG(0x000f, pointer_type, 2, DWARF)
-HANDLE_DW_TAG(0x0010, reference_type, 2, DWARF)
-HANDLE_DW_TAG(0x0011, compile_unit, 2, DWARF)
-HANDLE_DW_TAG(0x0012, string_type, 2, DWARF)
-HANDLE_DW_TAG(0x0013, structure_type, 2, DWARF)
-HANDLE_DW_TAG(0x0015, subroutine_type, 2, DWARF)
-HANDLE_DW_TAG(0x0016, typedef, 2, DWARF)
-HANDLE_DW_TAG(0x0017, union_type, 2, DWARF)
-HANDLE_DW_TAG(0x0018, unspecified_parameters, 2, DWARF)
-HANDLE_DW_TAG(0x0019, variant, 2, DWARF)
-HANDLE_DW_TAG(0x001a, common_block, 2, DWARF)
-HANDLE_DW_TAG(0x001b, common_inclusion, 2, DWARF)
-HANDLE_DW_TAG(0x001c, inheritance, 2, DWARF)
-HANDLE_DW_TAG(0x001d, inlined_subroutine, 2, DWARF)
-HANDLE_DW_TAG(0x001e, module, 2, DWARF)
-HANDLE_DW_TAG(0x001f, ptr_to_member_type, 2, DWARF)
-HANDLE_DW_TAG(0x0020, set_type, 2, DWARF)
-HANDLE_DW_TAG(0x0021, subrange_type, 2, DWARF)
-HANDLE_DW_TAG(0x0022, with_stmt, 2, DWARF)
-HANDLE_DW_TAG(0x0023, access_declaration, 2, DWARF)
-HANDLE_DW_TAG(0x0024, base_type, 2, DWARF)
-HANDLE_DW_TAG(0x0025, catch_block, 2, DWARF)
-HANDLE_DW_TAG(0x0026, const_type, 2, DWARF)
-HANDLE_DW_TAG(0x0027, constant, 2, DWARF)
-HANDLE_DW_TAG(0x0028, enumerator, 2, DWARF)
-HANDLE_DW_TAG(0x0029, file_type, 2, DWARF)
-HANDLE_DW_TAG(0x002a, friend, 2, DWARF)
-HANDLE_DW_TAG(0x002b, namelist, 2, DWARF)
-HANDLE_DW_TAG(0x002c, namelist_item, 2, DWARF)
-HANDLE_DW_TAG(0x002d, packed_type, 2, DWARF)
-HANDLE_DW_TAG(0x002e, subprogram, 2, DWARF)
-HANDLE_DW_TAG(0x002f, template_type_parameter, 2, DWARF)
-HANDLE_DW_TAG(0x0030, template_value_parameter, 2, DWARF)
-HANDLE_DW_TAG(0x0031, thrown_type, 2, DWARF)
-HANDLE_DW_TAG(0x0032, try_block, 2, DWARF)
-HANDLE_DW_TAG(0x0033, variant_part, 2, DWARF)
-HANDLE_DW_TAG(0x0034, variable, 2, DWARF)
-HANDLE_DW_TAG(0x0035, volatile_type, 2, DWARF)
+#ifndef HANDLE_DW_SECT
+#define HANDLE_DW_SECT(ID, NAME)
+#endif
+
+HANDLE_DW_TAG(0x0000, null, 2, DWARF, DW_KIND_NONE)
+HANDLE_DW_TAG(0x0001, array_type, 2, DWARF, DW_KIND_TYPE)
+HANDLE_DW_TAG(0x0002, class_type, 2, DWARF, DW_KIND_TYPE)
+HANDLE_DW_TAG(0x0003, entry_point, 2, DWARF, DW_KIND_NONE)
+HANDLE_DW_TAG(0x0004, enumeration_type, 2, DWARF, DW_KIND_TYPE)
+HANDLE_DW_TAG(0x0005, formal_parameter, 2, DWARF, DW_KIND_NONE)
+HANDLE_DW_TAG(0x0008, imported_declaration, 2, DWARF, DW_KIND_NONE)
+HANDLE_DW_TAG(0x000a, label, 2, DWARF, DW_KIND_NONE)
+HANDLE_DW_TAG(0x000b, lexical_block, 2, DWARF, DW_KIND_NONE)
+HANDLE_DW_TAG(0x000d, member, 2, DWARF, DW_KIND_NONE)
+HANDLE_DW_TAG(0x000f, pointer_type, 2, DWARF, DW_KIND_TYPE)
+HANDLE_DW_TAG(0x0010, reference_type, 2, DWARF, DW_KIND_TYPE)
+HANDLE_DW_TAG(0x0011, compile_unit, 2, DWARF, DW_KIND_NONE)
+HANDLE_DW_TAG(0x0012, string_type, 2, DWARF, DW_KIND_TYPE)
+HANDLE_DW_TAG(0x0013, structure_type, 2, DWARF, DW_KIND_TYPE)
+HANDLE_DW_TAG(0x0015, subroutine_type, 2, DWARF, DW_KIND_TYPE)
+HANDLE_DW_TAG(0x0016, typedef, 2, DWARF, DW_KIND_TYPE)
+HANDLE_DW_TAG(0x0017, union_type, 2, DWARF, DW_KIND_TYPE)
+HANDLE_DW_TAG(0x0018, unspecified_parameters, 2, DWARF, DW_KIND_NONE)
+HANDLE_DW_TAG(0x0019, variant, 2, DWARF, DW_KIND_NONE)
+HANDLE_DW_TAG(0x001a, common_block, 2, DWARF, DW_KIND_NONE)
+HANDLE_DW_TAG(0x001b, common_inclusion, 2, DWARF, DW_KIND_NONE)
+HANDLE_DW_TAG(0x001c, inheritance, 2, DWARF, DW_KIND_NONE)
+HANDLE_DW_TAG(0x001d, inlined_subroutine, 2, DWARF, DW_KIND_NONE)
+HANDLE_DW_TAG(0x001e, module, 2, DWARF, DW_KIND_NONE)
+HANDLE_DW_TAG(0x001f, ptr_to_member_type, 2, DWARF, DW_KIND_TYPE)
+HANDLE_DW_TAG(0x0020, set_type, 2, DWARF, DW_KIND_NONE)
+HANDLE_DW_TAG(0x0021, subrange_type, 2, DWARF, DW_KIND_TYPE)
+HANDLE_DW_TAG(0x0022, with_stmt, 2, DWARF, DW_KIND_NONE)
+HANDLE_DW_TAG(0x0023, access_declaration, 2, DWARF, DW_KIND_NONE)
+HANDLE_DW_TAG(0x0024, base_type, 2, DWARF, DW_KIND_TYPE)
+HANDLE_DW_TAG(0x0025, catch_block, 2, DWARF, DW_KIND_NONE)
+HANDLE_DW_TAG(0x0026, const_type, 2, DWARF, DW_KIND_TYPE)
+HANDLE_DW_TAG(0x0027, constant, 2, DWARF, DW_KIND_NONE)
+HANDLE_DW_TAG(0x0028, enumerator, 2, DWARF, DW_KIND_NONE)
+HANDLE_DW_TAG(0x0029, file_type, 2, DWARF, DW_KIND_TYPE)
+HANDLE_DW_TAG(0x002a, friend, 2, DWARF, DW_KIND_NONE)
+HANDLE_DW_TAG(0x002b, namelist, 2, DWARF, DW_KIND_NONE)
+HANDLE_DW_TAG(0x002c, namelist_item, 2, DWARF, DW_KIND_NONE)
+HANDLE_DW_TAG(0x002d, packed_type, 2, DWARF, DW_KIND_TYPE)
+HANDLE_DW_TAG(0x002e, subprogram, 2, DWARF, DW_KIND_NONE)
+HANDLE_DW_TAG(0x002f, template_type_parameter, 2, DWARF, DW_KIND_NONE)
+HANDLE_DW_TAG(0x0030, template_value_parameter, 2, DWARF, DW_KIND_NONE)
+HANDLE_DW_TAG(0x0031, thrown_type, 2, DWARF, DW_KIND_TYPE)
+HANDLE_DW_TAG(0x0032, try_block, 2, DWARF, DW_KIND_NONE)
+HANDLE_DW_TAG(0x0033, variant_part, 2, DWARF, DW_KIND_NONE)
+HANDLE_DW_TAG(0x0034, variable, 2, DWARF, DW_KIND_NONE)
+HANDLE_DW_TAG(0x0035, volatile_type, 2, DWARF, DW_KIND_TYPE)
 // New in DWARF v3:
-HANDLE_DW_TAG(0x0036, dwarf_procedure, 3, DWARF)
-HANDLE_DW_TAG(0x0037, restrict_type, 3, DWARF)
-HANDLE_DW_TAG(0x0038, interface_type, 3, DWARF)
-HANDLE_DW_TAG(0x0039, namespace, 3, DWARF)
-HANDLE_DW_TAG(0x003a, imported_module, 3, DWARF)
-HANDLE_DW_TAG(0x003b, unspecified_type, 3, DWARF)
-HANDLE_DW_TAG(0x003c, partial_unit, 3, DWARF)
-HANDLE_DW_TAG(0x003d, imported_unit, 3, DWARF)
-HANDLE_DW_TAG(0x003f, condition, 3, DWARF)
-HANDLE_DW_TAG(0x0040, shared_type, 3, DWARF)
+HANDLE_DW_TAG(0x0036, dwarf_procedure, 3, DWARF, DW_KIND_NONE)
+HANDLE_DW_TAG(0x0037, restrict_type, 3, DWARF, DW_KIND_TYPE)
+HANDLE_DW_TAG(0x0038, interface_type, 3, DWARF, DW_KIND_TYPE)
+HANDLE_DW_TAG(0x0039, namespace, 3, DWARF, DW_KIND_NONE)
+HANDLE_DW_TAG(0x003a, imported_module, 3, DWARF, DW_KIND_NONE)
+HANDLE_DW_TAG(0x003b, unspecified_type, 3, DWARF, DW_KIND_TYPE)
+HANDLE_DW_TAG(0x003c, partial_unit, 3, DWARF, DW_KIND_NONE)
+HANDLE_DW_TAG(0x003d, imported_unit, 3, DWARF, DW_KIND_NONE)
+HANDLE_DW_TAG(0x003f, condition, 3, DWARF, DW_KIND_NONE)
+HANDLE_DW_TAG(0x0040, shared_type, 3, DWARF, DW_KIND_TYPE)
 // New in DWARF v4:
-HANDLE_DW_TAG(0x0041, type_unit, 4, DWARF)
-HANDLE_DW_TAG(0x0042, rvalue_reference_type, 4, DWARF)
-HANDLE_DW_TAG(0x0043, template_alias, 4, DWARF)
+HANDLE_DW_TAG(0x0041, type_unit, 4, DWARF, DW_KIND_NONE)
+HANDLE_DW_TAG(0x0042, rvalue_reference_type, 4, DWARF, DW_KIND_TYPE)
+HANDLE_DW_TAG(0x0043, template_alias, 4, DWARF, DW_KIND_NONE)
 // New in DWARF v5:
-HANDLE_DW_TAG(0x0044, coarray_type, 5, DWARF)
-HANDLE_DW_TAG(0x0045, generic_subrange, 5, DWARF)
-HANDLE_DW_TAG(0x0046, dynamic_type, 5, DWARF)
-HANDLE_DW_TAG(0x0047, atomic_type, 5, DWARF)
-HANDLE_DW_TAG(0x0048, call_site, 5, DWARF)
-HANDLE_DW_TAG(0x0049, call_site_parameter, 5, DWARF)
-HANDLE_DW_TAG(0x004a, skeleton_unit, 5, DWARF)
-HANDLE_DW_TAG(0x004b, immutable_type, 5, DWARF)
+HANDLE_DW_TAG(0x0044, coarray_type, 5, DWARF, DW_KIND_TYPE)
+HANDLE_DW_TAG(0x0045, generic_subrange, 5, DWARF, DW_KIND_NONE)
+HANDLE_DW_TAG(0x0046, dynamic_type, 5, DWARF, DW_KIND_TYPE)
+HANDLE_DW_TAG(0x0047, atomic_type, 5, DWARF, DW_KIND_TYPE)
+HANDLE_DW_TAG(0x0048, call_site, 5, DWARF, DW_KIND_NONE)
+HANDLE_DW_TAG(0x0049, call_site_parameter, 5, DWARF, DW_KIND_NONE)
+HANDLE_DW_TAG(0x004a, skeleton_unit, 5, DWARF, DW_KIND_NONE)
+HANDLE_DW_TAG(0x004b, immutable_type, 5, DWARF, DW_KIND_TYPE)
 // Vendor extensions:
-HANDLE_DW_TAG(0x4081, MIPS_loop, 0, MIPS)
-HANDLE_DW_TAG(0x4101, format_label, 0, GNU)
-HANDLE_DW_TAG(0x4102, function_template, 0, GNU)
-HANDLE_DW_TAG(0x4103, class_template, 0, GNU)
-HANDLE_DW_TAG(0x4106, GNU_template_template_param, 0, GNU)
-HANDLE_DW_TAG(0x4107, GNU_template_parameter_pack, 0, GNU)
-HANDLE_DW_TAG(0x4108, GNU_formal_parameter_pack, 0, GNU)
-HANDLE_DW_TAG(0x4109, GNU_call_site, 0, GNU)
-HANDLE_DW_TAG(0x410a, GNU_call_site_parameter, 0, GNU)
-HANDLE_DW_TAG(0x4200, APPLE_property, 0, APPLE)
-HANDLE_DW_TAG(0xb000, BORLAND_property, 0, BORLAND)
-HANDLE_DW_TAG(0xb001, BORLAND_Delphi_string, 0, BORLAND)
-HANDLE_DW_TAG(0xb002, BORLAND_Delphi_dynamic_array, 0, BORLAND)
-HANDLE_DW_TAG(0xb003, BORLAND_Delphi_set, 0, BORLAND)
-HANDLE_DW_TAG(0xb004, BORLAND_Delphi_variant, 0, BORLAND)
+HANDLE_DW_TAG(0x4081, MIPS_loop, 0, MIPS, DW_KIND_NONE)
+HANDLE_DW_TAG(0x4101, format_label, 0, GNU, DW_KIND_NONE)
+HANDLE_DW_TAG(0x4102, function_template, 0, GNU, DW_KIND_NONE)
+HANDLE_DW_TAG(0x4103, class_template, 0, GNU, DW_KIND_NONE)
+HANDLE_DW_TAG(0x4106, GNU_template_template_param, 0, GNU, DW_KIND_NONE)
+HANDLE_DW_TAG(0x4107, GNU_template_parameter_pack, 0, GNU, DW_KIND_NONE)
+HANDLE_DW_TAG(0x4108, GNU_formal_parameter_pack, 0, GNU, DW_KIND_NONE)
+HANDLE_DW_TAG(0x4109, GNU_call_site, 0, GNU, DW_KIND_NONE)
+HANDLE_DW_TAG(0x410a, GNU_call_site_parameter, 0, GNU, DW_KIND_NONE)
+HANDLE_DW_TAG(0x4200, APPLE_property, 0, APPLE, DW_KIND_NONE)
+HANDLE_DW_TAG(0xb000, BORLAND_property, 0, BORLAND, DW_KIND_NONE)
+HANDLE_DW_TAG(0xb001, BORLAND_Delphi_string, 0, BORLAND, DW_KIND_TYPE)
+HANDLE_DW_TAG(0xb002, BORLAND_Delphi_dynamic_array, 0, BORLAND, DW_KIND_TYPE)
+HANDLE_DW_TAG(0xb003, BORLAND_Delphi_set, 0, BORLAND, DW_KIND_TYPE)
+HANDLE_DW_TAG(0xb004, BORLAND_Delphi_variant, 0, BORLAND, DW_KIND_TYPE)
 
 // Attributes.
 HANDLE_DW_AT(0x01, sibling, 2, DWARF)
@@ -391,9 +418,13 @@
 // LLVM project extensions.
 HANDLE_DW_AT(0x3e00, LLVM_include_path, 0, LLVM)
 HANDLE_DW_AT(0x3e01, LLVM_config_macros, 0, LLVM)
-HANDLE_DW_AT(0x3e02, LLVM_isysroot, 0, LLVM)
+HANDLE_DW_AT(0x3e02, LLVM_sysroot, 0, LLVM)
 HANDLE_DW_AT(0x3e03, LLVM_tag_offset, 0, LLVM)
+// The missing numbers here are reserved for ptrauth support.
+HANDLE_DW_AT(0x3e07, LLVM_apinotes, 0, APPLE)
+
 // Apple extensions.
+
 HANDLE_DW_AT(0x3fe1, APPLE_optimized, 0, APPLE)
 HANDLE_DW_AT(0x3fe2, APPLE_flags, 0, APPLE)
 HANDLE_DW_AT(0x3fe3, APPLE_isa, 0, APPLE)
@@ -407,6 +438,8 @@
 HANDLE_DW_AT(0x3feb, APPLE_property_attribute, 0, APPLE)
 HANDLE_DW_AT(0x3fec, APPLE_objc_complete_type, 0, APPLE)
 HANDLE_DW_AT(0x3fed, APPLE_property, 0, APPLE)
+HANDLE_DW_AT(0x3fee, APPLE_objc_direct, 0, APPLE)
+HANDLE_DW_AT(0x3fef, APPLE_sdk, 0, APPLE)
 
 // Attribute form encodings.
 HANDLE_DW_FORM(0x01, addr, 2, DWARF)
@@ -633,6 +666,9 @@
 // Vendor extensions:
 // Extensions for GNU-style thread-local storage.
 HANDLE_DW_OP(0xe0, GNU_push_tls_address, 0, GNU)
+// Extensions for WebAssembly.
+HANDLE_DW_OP(0xed, WASM_location, 0, WASM)
+HANDLE_DW_OP(0xee, WASM_location_int, 0, WASM)
 // The GNU entry value extension.
 HANDLE_DW_OP(0xf3, GNU_entry_value, 0, GNU)
 // Extensions for Fission proposal.
@@ -805,6 +841,23 @@
 HANDLE_DW_MACRO(0x0b, define_strx)
 HANDLE_DW_MACRO(0x0c, undef_strx)
 
+// GNU .debug_macro extension.
+HANDLE_DW_MACRO_GNU(0x01, define)
+HANDLE_DW_MACRO_GNU(0x02, undef)
+HANDLE_DW_MACRO_GNU(0x03, start_file)
+HANDLE_DW_MACRO_GNU(0x04, end_file)
+HANDLE_DW_MACRO_GNU(0x05, define_indirect)
+HANDLE_DW_MACRO_GNU(0x06, undef_indirect)
+HANDLE_DW_MACRO_GNU(0x07, transparent_include)
+HANDLE_DW_MACRO_GNU(0x08, define_indirect_alt)
+HANDLE_DW_MACRO_GNU(0x09, undef_indirect_alt)
+HANDLE_DW_MACRO_GNU(0x0a, transparent_include_alt)
+
+// DWARF v5 Macro header flags.
+HANDLE_MACRO_FLAG(0x01, OFFSET_SIZE)
+HANDLE_MACRO_FLAG(0x02, DEBUG_LINE_OFFSET)
+HANDLE_MACRO_FLAG(0x04, OPCODE_OPERANDS_TABLE)
+
 // DWARF v5 Range List Entry encoding values.
 HANDLE_DW_RLE(0x00, end_of_list)
 HANDLE_DW_RLE(0x01, base_addressx)
@@ -815,6 +868,17 @@
 HANDLE_DW_RLE(0x06, start_end)
 HANDLE_DW_RLE(0x07, start_length)
 
+// DWARF v5 Loc List Entry encoding values.
+HANDLE_DW_LLE(0x00, end_of_list)
+HANDLE_DW_LLE(0x01, base_addressx)
+HANDLE_DW_LLE(0x02, startx_endx)
+HANDLE_DW_LLE(0x03, startx_length)
+HANDLE_DW_LLE(0x04, offset_pair)
+HANDLE_DW_LLE(0x05, default_location)
+HANDLE_DW_LLE(0x06, base_address)
+HANDLE_DW_LLE(0x07, start_end)
+HANDLE_DW_LLE(0x08, start_length)
+
 // Call frame instruction encodings.
 HANDLE_DW_CFA(0x00, nop)
 HANDLE_DW_CFA(0x40, advance_loc)
@@ -850,7 +914,8 @@
 HANDLE_DW_CFA_PRED(0x2e, GNU_args_size, SELECT_X86)
 
 // Apple Objective-C Property Attributes.
-// Keep this list in sync with clang's DeclSpec.h ObjCPropertyAttributeKind!
+// Keep this list in sync with clang's DeclObjCCommon.h
+// ObjCPropertyAttribute::Kind!
 HANDLE_DW_APPLE_PROPERTY(0x01, readonly)
 HANDLE_DW_APPLE_PROPERTY(0x02, getter)
 HANDLE_DW_APPLE_PROPERTY(0x04, assign)
@@ -875,38 +940,38 @@
 HANDLE_DW_UT(0x05, split_compile)
 HANDLE_DW_UT(0x06, split_type)
 
-// DWARF section types. (enum name, ELF name, ELF DWO name, cmdline name)
+// DWARF section types. (enum name, ELF name, ELF DWO name, cmdline name, option)
 // Note that these IDs don't mean anything.
 // TODO: Add Mach-O and COFF names.
 // Official DWARF sections.
-HANDLE_DWARF_SECTION(DebugAbbrev, ".debug_abbrev", "debug-abbrev")
-HANDLE_DWARF_SECTION(DebugAddr, ".debug_addr", "debug-addr")
-HANDLE_DWARF_SECTION(DebugAranges, ".debug_aranges", "debug-aranges")
-HANDLE_DWARF_SECTION(DebugInfo, ".debug_info", "debug-info")
-HANDLE_DWARF_SECTION(DebugTypes, ".debug_types", "debug-types")
-HANDLE_DWARF_SECTION(DebugLine, ".debug_line", "debug-line")
-HANDLE_DWARF_SECTION(DebugLineStr, ".debug_line_str", "debug-line-str")
-HANDLE_DWARF_SECTION(DebugLoc, ".debug_loc", "debug-loc")
-HANDLE_DWARF_SECTION(DebugLoclists, ".debug_loclists", "debug-loclists")
-HANDLE_DWARF_SECTION(DebugFrame, ".debug_frame", "debug-frame")
-HANDLE_DWARF_SECTION(DebugMacro, ".debug_macro", "debug-macro")
-HANDLE_DWARF_SECTION(DebugNames, ".debug_names", "debug-names")
-HANDLE_DWARF_SECTION(DebugPubnames, ".debug_pubnames", "debug-pubnames")
-HANDLE_DWARF_SECTION(DebugPubtypes, ".debug_pubtypes", "debug-pubtypes")
-HANDLE_DWARF_SECTION(DebugGnuPubnames, ".debug_gnu_pubnames", "debug-gnu-pubnames")
-HANDLE_DWARF_SECTION(DebugGnuPubtypes, ".debug_gnu_pubtypes", "debug-gnu-pubtypes")
-HANDLE_DWARF_SECTION(DebugRanges, ".debug_ranges", "debug-ranges")
-HANDLE_DWARF_SECTION(DebugRnglists, ".debug_rnglists", "debug-rnglists")
-HANDLE_DWARF_SECTION(DebugStr, ".debug_str", "debug-str")
-HANDLE_DWARF_SECTION(DebugStrOffsets, ".debug_str_offsets", "debug-str-offsets")
-HANDLE_DWARF_SECTION(DebugCUIndex, ".debug_cu_index", "debug-cu-index")
-HANDLE_DWARF_SECTION(DebugTUIndex, ".debug_tu_index", "debug-tu-index")
+HANDLE_DWARF_SECTION(DebugAbbrev, ".debug_abbrev", "debug-abbrev", BoolOption)
+HANDLE_DWARF_SECTION(DebugAddr, ".debug_addr", "debug-addr", BoolOption)
+HANDLE_DWARF_SECTION(DebugAranges, ".debug_aranges", "debug-aranges", BoolOption)
+HANDLE_DWARF_SECTION(DebugInfo, ".debug_info", "debug-info", OffsetOption)
+HANDLE_DWARF_SECTION(DebugTypes, ".debug_types", "debug-types", OffsetOption)
+HANDLE_DWARF_SECTION(DebugLine, ".debug_line", "debug-line", OffsetOption)
+HANDLE_DWARF_SECTION(DebugLineStr, ".debug_line_str", "debug-line-str", BoolOption)
+HANDLE_DWARF_SECTION(DebugLoc, ".debug_loc", "debug-loc", OffsetOption)
+HANDLE_DWARF_SECTION(DebugLoclists, ".debug_loclists", "debug-loclists", OffsetOption)
+HANDLE_DWARF_SECTION(DebugFrame, ".debug_frame", "debug-frame", OffsetOption)
+HANDLE_DWARF_SECTION(DebugMacro, ".debug_macro", "debug-macro", BoolOption)
+HANDLE_DWARF_SECTION(DebugNames, ".debug_names", "debug-names", BoolOption)
+HANDLE_DWARF_SECTION(DebugPubnames, ".debug_pubnames", "debug-pubnames", BoolOption)
+HANDLE_DWARF_SECTION(DebugPubtypes, ".debug_pubtypes", "debug-pubtypes", BoolOption)
+HANDLE_DWARF_SECTION(DebugGnuPubnames, ".debug_gnu_pubnames", "debug-gnu-pubnames", BoolOption)
+HANDLE_DWARF_SECTION(DebugGnuPubtypes, ".debug_gnu_pubtypes", "debug-gnu-pubtypes", BoolOption)
+HANDLE_DWARF_SECTION(DebugRanges, ".debug_ranges", "debug-ranges", BoolOption)
+HANDLE_DWARF_SECTION(DebugRnglists, ".debug_rnglists", "debug-rnglists", BoolOption)
+HANDLE_DWARF_SECTION(DebugStr, ".debug_str", "debug-str", BoolOption)
+HANDLE_DWARF_SECTION(DebugStrOffsets, ".debug_str_offsets", "debug-str-offsets", BoolOption)
+HANDLE_DWARF_SECTION(DebugCUIndex, ".debug_cu_index", "debug-cu-index", BoolOption)
+HANDLE_DWARF_SECTION(DebugTUIndex, ".debug_tu_index", "debug-tu-index", BoolOption)
 // Vendor extensions.
-HANDLE_DWARF_SECTION(AppleNames, ".apple_names", "apple-names")
-HANDLE_DWARF_SECTION(AppleTypes, ".apple_types", "apple-types")
-HANDLE_DWARF_SECTION(AppleNamespaces, ".apple_namespaces", "apple-namespaces")
-HANDLE_DWARF_SECTION(AppleObjC, ".apple_objc", "apple-objc")
-HANDLE_DWARF_SECTION(GdbIndex, ".gdb_index", "gdb-index")
+HANDLE_DWARF_SECTION(AppleNames, ".apple_names", "apple-names", BoolOption)
+HANDLE_DWARF_SECTION(AppleTypes, ".apple_types", "apple-types", BoolOption)
+HANDLE_DWARF_SECTION(AppleNamespaces, ".apple_namespaces", "apple-namespaces", BoolOption)
+HANDLE_DWARF_SECTION(AppleObjC, ".apple_objc", "apple-objc", BoolOption)
+HANDLE_DWARF_SECTION(GdbIndex, ".gdb_index", "gdb-index", BoolOption)
 
 HANDLE_DW_IDX(0x01, compile_unit)
 HANDLE_DW_IDX(0x02, type_unit)
@@ -914,6 +979,15 @@
 HANDLE_DW_IDX(0x04, parent)
 HANDLE_DW_IDX(0x05, type_hash)
 
+// DWARF package file section identifiers.
+// DWARFv5, section 7.3.5.3, table 7.1.
+HANDLE_DW_SECT(1, INFO)
+HANDLE_DW_SECT(3, ABBREV)
+HANDLE_DW_SECT(4, LINE)
+HANDLE_DW_SECT(5, LOCLISTS)
+HANDLE_DW_SECT(6, STR_OFFSETS)
+HANDLE_DW_SECT(7, MACRO)
+HANDLE_DW_SECT(8, RNGLISTS)
 
 #undef HANDLE_DW_TAG
 #undef HANDLE_DW_AT
@@ -928,7 +1002,10 @@
 #undef HANDLE_DW_LNE
 #undef HANDLE_DW_LNCT
 #undef HANDLE_DW_MACRO
+#undef HANDLE_DW_MACRO_GNU
+#undef HANDLE_MACRO_FLAG
 #undef HANDLE_DW_RLE
+#undef HANDLE_DW_LLE
 #undef HANDLE_DW_CFA
 #undef HANDLE_DW_CFA_PRED
 #undef HANDLE_DW_APPLE_PROPERTY
@@ -936,3 +1013,4 @@
 #undef HANDLE_DWARF_SECTION
 #undef HANDLE_DW_IDX
 #undef HANDLE_DW_END
+#undef HANDLE_DW_SECT
diff --git a/linux-x64/clang/include/llvm/BinaryFormat/Dwarf.h b/linux-x64/clang/include/llvm/BinaryFormat/Dwarf.h
index 76d9c36..cafc5be 100644
--- a/linux-x64/clang/include/llvm/BinaryFormat/Dwarf.h
+++ b/linux-x64/clang/include/llvm/BinaryFormat/Dwarf.h
@@ -27,6 +27,8 @@
 #include "llvm/Support/FormatVariadicDetails.h"
 #include "llvm/ADT/Triple.h"
 
+#include <limits>
+
 namespace llvm {
 class StringRef;
 
@@ -46,6 +48,11 @@
   DW_VIRTUALITY_invalid = ~0U, // Virtuality for invalid results.
   DW_MACINFO_invalid = ~0U,    // Macinfo type for invalid results.
 
+  // Special values for an initial length field.
+  DW_LENGTH_lo_reserved = 0xfffffff0, // Lower bound of the reserved range.
+  DW_LENGTH_DWARF64 = 0xffffffff,     // Indicator of 64-bit DWARF format.
+  DW_LENGTH_hi_reserved = 0xffffffff, // Upper bound of the reserved range.
+
   // Other constants.
   DWARF_VERSION = 4,       // Default dwarf version we output.
   DW_PUBTYPES_VERSION = 2, // Section version number for .debug_pubtypes.
@@ -58,7 +65,8 @@
   DWARF_VENDOR_GNU = 3,
   DWARF_VENDOR_GOOGLE = 4,
   DWARF_VENDOR_LLVM = 5,
-  DWARF_VENDOR_MIPS = 6
+  DWARF_VENDOR_MIPS = 6,
+  DWARF_VENDOR_WASM = 7
 };
 
 /// Constants that define the DWARF format as 32 or 64 bit.
@@ -75,7 +83,7 @@
 const uint32_t DW_INVALID_OFFSET = UINT32_MAX;
 
 enum Tag : uint16_t {
-#define HANDLE_DW_TAG(ID, NAME, VERSION, VENDOR) DW_TAG_##NAME = ID,
+#define HANDLE_DW_TAG(ID, NAME, VERSION, VENDOR, KIND) DW_TAG_##NAME = ID,
 #include "llvm/BinaryFormat/Dwarf.def"
   DW_TAG_lo_user = 0x4080,
   DW_TAG_hi_user = 0xffff,
@@ -84,29 +92,12 @@
 
 inline bool isType(Tag T) {
   switch (T) {
-  case DW_TAG_array_type:
-  case DW_TAG_class_type:
-  case DW_TAG_interface_type:
-  case DW_TAG_enumeration_type:
-  case DW_TAG_pointer_type:
-  case DW_TAG_reference_type:
-  case DW_TAG_rvalue_reference_type:
-  case DW_TAG_string_type:
-  case DW_TAG_structure_type:
-  case DW_TAG_subroutine_type:
-  case DW_TAG_union_type:
-  case DW_TAG_ptr_to_member_type:
-  case DW_TAG_set_type:
-  case DW_TAG_subrange_type:
-  case DW_TAG_base_type:
-  case DW_TAG_const_type:
-  case DW_TAG_file_type:
-  case DW_TAG_packed_type:
-  case DW_TAG_volatile_type:
-  case DW_TAG_typedef:
-    return true;
   default:
     return false;
+#define HANDLE_DW_TAG(ID, NAME, VERSION, VENDOR, KIND)                         \
+  case DW_TAG_##NAME:                                                          \
+    return (KIND == DW_KIND_TYPE);
+#include "llvm/BinaryFormat/Dwarf.def"
   }
 }
 
@@ -129,9 +120,11 @@
 #include "llvm/BinaryFormat/Dwarf.def"
   DW_OP_lo_user = 0xe0,
   DW_OP_hi_user = 0xff,
-  DW_OP_LLVM_fragment = 0x1000,   ///< Only used in LLVM metadata.
-  DW_OP_LLVM_convert = 0x1001,    ///< Only used in LLVM metadata.
-  DW_OP_LLVM_tag_offset = 0x1002, ///< Only used in LLVM metadata.
+  DW_OP_LLVM_fragment = 0x1000,         ///< Only used in LLVM metadata.
+  DW_OP_LLVM_convert = 0x1001,          ///< Only used in LLVM metadata.
+  DW_OP_LLVM_tag_offset = 0x1002,       ///< Only used in LLVM metadata.
+  DW_OP_LLVM_entry_value = 0x1003,      ///< Only used in LLVM metadata.
+  DW_OP_LLVM_implicit_pointer = 0x1004, ///< Only used in LLVM metadata.
 };
 
 enum TypeKind : uint8_t {
@@ -192,6 +185,120 @@
   DW_LANG_hi_user = 0xffff
 };
 
+inline bool isCPlusPlus(SourceLanguage S) {
+  bool result = false;
+  // Deliberately enumerate all the language options so we get a warning when
+  // new language options are added (-Wswitch) that'll hopefully help keep this
+  // switch up-to-date when new C++ versions are added.
+  switch (S) {
+  case DW_LANG_C_plus_plus:
+  case DW_LANG_C_plus_plus_03:
+  case DW_LANG_C_plus_plus_11:
+  case DW_LANG_C_plus_plus_14:
+    result = true;
+    break;
+  case DW_LANG_C89:
+  case DW_LANG_C:
+  case DW_LANG_Ada83:
+  case DW_LANG_Cobol74:
+  case DW_LANG_Cobol85:
+  case DW_LANG_Fortran77:
+  case DW_LANG_Fortran90:
+  case DW_LANG_Pascal83:
+  case DW_LANG_Modula2:
+  case DW_LANG_Java:
+  case DW_LANG_C99:
+  case DW_LANG_Ada95:
+  case DW_LANG_Fortran95:
+  case DW_LANG_PLI:
+  case DW_LANG_ObjC:
+  case DW_LANG_ObjC_plus_plus:
+  case DW_LANG_UPC:
+  case DW_LANG_D:
+  case DW_LANG_Python:
+  case DW_LANG_OpenCL:
+  case DW_LANG_Go:
+  case DW_LANG_Modula3:
+  case DW_LANG_Haskell:
+  case DW_LANG_OCaml:
+  case DW_LANG_Rust:
+  case DW_LANG_C11:
+  case DW_LANG_Swift:
+  case DW_LANG_Julia:
+  case DW_LANG_Dylan:
+  case DW_LANG_Fortran03:
+  case DW_LANG_Fortran08:
+  case DW_LANG_RenderScript:
+  case DW_LANG_BLISS:
+  case DW_LANG_Mips_Assembler:
+  case DW_LANG_GOOGLE_RenderScript:
+  case DW_LANG_BORLAND_Delphi:
+  case DW_LANG_lo_user:
+  case DW_LANG_hi_user:
+    result = false;
+    break;
+  }
+
+  return result;
+}
+
+inline bool isFortran(SourceLanguage S) {
+  bool result = false;
+  // Deliberately enumerate all the language options so we get a warning when
+  // new language options are added (-Wswitch) that'll hopefully help keep this
+  // switch up-to-date when new Fortran versions are added.
+  switch (S) {
+  case DW_LANG_Fortran77:
+  case DW_LANG_Fortran90:
+  case DW_LANG_Fortran95:
+  case DW_LANG_Fortran03:
+  case DW_LANG_Fortran08:
+    result = true;
+    break;
+  case DW_LANG_C89:
+  case DW_LANG_C:
+  case DW_LANG_Ada83:
+  case DW_LANG_C_plus_plus:
+  case DW_LANG_Cobol74:
+  case DW_LANG_Cobol85:
+  case DW_LANG_Pascal83:
+  case DW_LANG_Modula2:
+  case DW_LANG_Java:
+  case DW_LANG_C99:
+  case DW_LANG_Ada95:
+  case DW_LANG_PLI:
+  case DW_LANG_ObjC:
+  case DW_LANG_ObjC_plus_plus:
+  case DW_LANG_UPC:
+  case DW_LANG_D:
+  case DW_LANG_Python:
+  case DW_LANG_OpenCL:
+  case DW_LANG_Go:
+  case DW_LANG_Modula3:
+  case DW_LANG_Haskell:
+  case DW_LANG_C_plus_plus_03:
+  case DW_LANG_C_plus_plus_11:
+  case DW_LANG_OCaml:
+  case DW_LANG_Rust:
+  case DW_LANG_C11:
+  case DW_LANG_Swift:
+  case DW_LANG_Julia:
+  case DW_LANG_Dylan:
+  case DW_LANG_C_plus_plus_14:
+  case DW_LANG_RenderScript:
+  case DW_LANG_BLISS:
+  case DW_LANG_Mips_Assembler:
+  case DW_LANG_GOOGLE_RenderScript:
+  case DW_LANG_BORLAND_Delphi:
+  case DW_LANG_lo_user:
+  case DW_LANG_hi_user:
+    result = false;
+    break;
+  }
+
+  return result;
+}
+
 enum CaseSensitivity {
   // Identifier case codes
   DW_ID_case_sensitive = 0x00,
@@ -266,12 +373,26 @@
   DW_MACRO_hi_user = 0xff
 };
 
+/// GNU .debug_macro macro information entry type encodings.
+enum GnuMacroEntryType {
+#define HANDLE_DW_MACRO_GNU(ID, NAME) DW_MACRO_GNU_##NAME = ID,
+#include "llvm/BinaryFormat/Dwarf.def"
+  DW_MACRO_GNU_lo_user = 0xe0,
+  DW_MACRO_GNU_hi_user = 0xff
+};
+
 /// DWARF v5 range list entry encoding values.
-enum RangeListEntries {
+enum RnglistEntries {
 #define HANDLE_DW_RLE(ID, NAME) DW_RLE_##NAME = ID,
 #include "llvm/BinaryFormat/Dwarf.def"
 };
 
+/// DWARF v5 loc list entry encoding values.
+enum LoclistEntries {
+#define HANDLE_DW_LLE(ID, NAME) DW_LLE_##NAME = ID,
+#include "llvm/BinaryFormat/Dwarf.def"
+};
+
 /// Call frame instruction encodings.
 enum CallFrameInfo {
 #define HANDLE_DW_CFA(ID, NAME) DW_CFA_##NAME = ID,
@@ -307,21 +428,9 @@
   DW_EH_PE_indirect = 0x80
 };
 
-/// Constants for location lists in DWARF v5.
-enum LocationListEntry : unsigned char {
-  DW_LLE_end_of_list = 0x00,
-  DW_LLE_base_addressx = 0x01,
-  DW_LLE_startx_endx = 0x02,
-  DW_LLE_startx_length = 0x03,
-  DW_LLE_offset_pair = 0x04,
-  DW_LLE_default_location = 0x05,
-  DW_LLE_base_address = 0x06,
-  DW_LLE_start_end = 0x07,
-  DW_LLE_start_length = 0x08
-};
-
 /// Constants for the DW_APPLE_PROPERTY_attributes attribute.
-/// Keep this list in sync with clang's DeclSpec.h ObjCPropertyAttributeKind!
+/// Keep this list in sync with clang's DeclObjCCommon.h
+/// ObjCPropertyAttribute::Kind!
 enum ApplePropertyAttributes {
 #define HANDLE_DW_APPLE_PROPERTY(ID, NAME) DW_APPLE_PROPERTY_##NAME = ID,
 #include "llvm/BinaryFormat/Dwarf.def"
@@ -423,6 +532,7 @@
 StringRef DecimalSignString(unsigned Sign);
 StringRef EndianityString(unsigned Endian);
 StringRef AccessibilityString(unsigned Access);
+StringRef DefaultedMemberString(unsigned DefaultedEncodings);
 StringRef VisibilityString(unsigned Visibility);
 StringRef VirtualityString(unsigned Virtuality);
 StringRef LanguageString(unsigned Language);
@@ -433,7 +543,10 @@
 StringRef LNStandardString(unsigned Standard);
 StringRef LNExtendedString(unsigned Encoding);
 StringRef MacinfoString(unsigned Encoding);
+StringRef MacroString(unsigned Encoding);
+StringRef GnuMacroString(unsigned Encoding);
 StringRef RangeListEncodingString(unsigned Encoding);
+StringRef LocListEncodingString(unsigned Encoding);
 StringRef CallFrameString(unsigned Encoding, Triple::ArchType Arch);
 StringRef ApplePropertyString(unsigned);
 StringRef UnitTypeString(unsigned);
@@ -441,6 +554,9 @@
 StringRef GDBIndexEntryKindString(GDBIndexEntryKind Kind);
 StringRef GDBIndexEntryLinkageString(GDBIndexEntryLinkage Linkage);
 StringRef IndexString(unsigned Idx);
+StringRef FormatString(DwarfFormat Format);
+StringRef FormatString(bool IsDWARF64);
+StringRef RLEString(unsigned RLE);
 /// @}
 
 /// \defgroup DwarfConstantsParsing Dwarf constants parsing functions
@@ -460,6 +576,7 @@
 unsigned getCallingConvention(StringRef LanguageString);
 unsigned getAttributeEncoding(StringRef EncodingString);
 unsigned getMacinfo(StringRef MacinfoString);
+unsigned getMacro(StringRef MacroString);
 /// @}
 
 /// \defgroup DwarfConstantsVersioning Dwarf version for constants
@@ -494,6 +611,17 @@
 
 Optional<unsigned> LanguageLowerBound(SourceLanguage L);
 
+/// The size of a reference determined by the DWARF 32/64-bit format.
+inline uint8_t getDwarfOffsetByteSize(DwarfFormat Format) {
+  switch (Format) {
+  case DwarfFormat::DWARF32:
+    return 4;
+  case DwarfFormat::DWARF64:
+    return 8;
+  }
+  llvm_unreachable("Invalid Format value");
+}
+
 /// A helper struct providing information about the byte size of DW_FORM
 /// values that vary in size depending on the DWARF version, address byte
 /// size, or DWARF32/DWARF64.
@@ -513,18 +641,23 @@
 
   /// The size of a reference is determined by the DWARF 32/64-bit format.
   uint8_t getDwarfOffsetByteSize() const {
-    switch (Format) {
-    case DwarfFormat::DWARF32:
-      return 4;
-    case DwarfFormat::DWARF64:
-      return 8;
-    }
-    llvm_unreachable("Invalid Format value");
+    return dwarf::getDwarfOffsetByteSize(Format);
   }
 
   explicit operator bool() const { return Version && AddrSize; }
 };
 
+/// Get the byte size of the unit length field depending on the DWARF format.
+inline uint8_t getUnitLengthFieldByteSize(DwarfFormat Format) {
+  switch (Format) {
+  case DwarfFormat::DWARF32:
+    return 4;
+  case DwarfFormat::DWARF64:
+    return 12;
+  }
+  llvm_unreachable("Invalid Format value");
+}
+
 /// Get the fixed byte size for a given form.
 ///
 /// If the form has a fixed byte size, then an Optional with a value will be
@@ -605,6 +738,21 @@
   static constexpr char Type[4] = "TAG";
   static constexpr StringRef (*StringFn)(unsigned) = &TagString;
 };
+
+template <> struct EnumTraits<LineNumberOps> : public std::true_type {
+  static constexpr char Type[4] = "LNS";
+  static constexpr StringRef (*StringFn)(unsigned) = &LNStandardString;
+};
+
+template <> struct EnumTraits<LocationAtom> : public std::true_type {
+  static constexpr char Type[3] = "OP";
+  static constexpr StringRef (*StringFn)(unsigned) = &OperationEncodingString;
+};
+
+inline uint64_t computeTombstoneAddress(uint8_t AddressByteSize) {
+  return std::numeric_limits<uint64_t>::max() >> (8 - AddressByteSize) * 8;
+}
+
 } // End of namespace dwarf
 
 /// Dwarf constants format_provider
@@ -613,8 +761,7 @@
 /// dumping functions above, these format unknown enumerator values as
 /// DW_TYPE_unknown_1234 (e.g. DW_TAG_unknown_ffff).
 template <typename Enum>
-struct format_provider<
-    Enum, typename std::enable_if<dwarf::EnumTraits<Enum>::value>::type> {
+struct format_provider<Enum, std::enable_if_t<dwarf::EnumTraits<Enum>::value>> {
   static void format(const Enum &E, raw_ostream &OS, StringRef Style) {
     StringRef Str = dwarf::EnumTraits<Enum>::StringFn(E);
     if (Str.empty()) {
diff --git a/linux-x64/clang/include/llvm/BinaryFormat/DynamicTags.def b/linux-x64/clang/include/llvm/BinaryFormat/DynamicTags.def
index aec408b..c08f8a5 100644
--- a/linux-x64/clang/include/llvm/BinaryFormat/DynamicTags.def
+++ b/linux-x64/clang/include/llvm/BinaryFormat/DynamicTags.def
@@ -120,6 +120,7 @@
 // AArch64 specific dynamic table entries
 AARCH64_DYNAMIC_TAG(AARCH64_BTI_PLT, 0x70000001)
 AARCH64_DYNAMIC_TAG(AARCH64_PAC_PLT, 0x70000003)
+AARCH64_DYNAMIC_TAG(AARCH64_VARIANT_PCS, 0x70000005)
 
 // Hexagon specific dynamic table entries
 HEXAGON_DYNAMIC_TAG(HEXAGON_SYMSZ, 0x70000000)
diff --git a/linux-x64/clang/include/llvm/BinaryFormat/ELF.h b/linux-x64/clang/include/llvm/BinaryFormat/ELF.h
index c9cc803..1552303 100644
--- a/linux-x64/clang/include/llvm/BinaryFormat/ELF.h
+++ b/linux-x64/clang/include/llvm/BinaryFormat/ELF.h
@@ -107,13 +107,17 @@
   unsigned char getDataEncoding() const { return e_ident[EI_DATA]; }
 };
 
-// File types
+// File types.
+// See current registered ELF types at:
+//    http://www.sco.com/developers/gabi/latest/ch4.eheader.html
 enum {
   ET_NONE = 0,        // No file type
   ET_REL = 1,         // Relocatable file
   ET_EXEC = 2,        // Executable file
   ET_DYN = 3,         // Shared object file
   ET_CORE = 4,        // Core file
+  ET_LOOS = 0xfe00,   // Beginning of operating system-specific codes
+  ET_HIOS = 0xfeff,   // Operating system-specific
   ET_LOPROC = 0xff00, // Beginning of processor-specific codes
   ET_HIPROC = 0xffff  // Processor-specific
 };
@@ -311,6 +315,8 @@
   EM_RISCV = 243,         // RISC-V
   EM_LANAI = 244,         // Lanai 32-bit processor
   EM_BPF = 247,           // Linux kernel bpf virtual machine
+  EM_VE = 251,            // NEC SX-Aurora VE
+  EM_CSKY = 252,          // C-SKY 32-bit processor
 };
 
 // Object file classes.
@@ -358,6 +364,14 @@
   ELFOSABI_LAST_ARCH = 255     // Last Architecture-specific OS ABI
 };
 
+// AMDGPU OS ABI Version identification.
+enum {
+  // ELFABIVERSION_AMDGPU_HSA_V1 does not exist because OS ABI identification
+  // was never defined for V1.
+  ELFABIVERSION_AMDGPU_HSA_V2 = 0,
+  ELFABIVERSION_AMDGPU_HSA_V3 = 1,
+};
+
 #define ELF_RELOC(name, value) name = value,
 
 // X86_64 relocations.
@@ -393,12 +407,6 @@
   unsigned Val = (Other & STO_PPC64_LOCAL_MASK) >> STO_PPC64_LOCAL_BIT;
   return ((1 << Val) >> 2) << 2;
 }
-static inline unsigned encodePPC64LocalEntryOffset(int64_t Offset) {
-  unsigned Val =
-      (Offset >= 4 * 4 ? (Offset >= 8 * 4 ? (Offset >= 16 * 4 ? 6 : 5) : 4)
-                       : (Offset >= 2 * 4 ? 3 : (Offset >= 1 * 4 ? 2 : 0)));
-  return Val << STO_PPC64_LOCAL_BIT;
-}
 
 // ELF Relocation types for PPC64
 enum {
@@ -410,6 +418,12 @@
 #include "ELFRelocs/AArch64.def"
 };
 
+// Special values for the st_other field in the symbol table entry for AArch64.
+enum {
+  // Symbol may follow different calling convention than base PCS.
+  STO_AARCH64_VARIANT_PCS = 0x80
+};
+
 // ARM Specific e_flags
 enum : unsigned {
   EF_ARM_SOFT_FLOAT = 0x00000200U,     // Legacy pre EABI_VER5
@@ -573,15 +587,17 @@
 // Hexagon-specific e_flags
 enum {
   // Object processor version flags, bits[11:0]
-  EF_HEXAGON_MACH_V2 = 0x00000001,  // Hexagon V2
-  EF_HEXAGON_MACH_V3 = 0x00000002,  // Hexagon V3
-  EF_HEXAGON_MACH_V4 = 0x00000003,  // Hexagon V4
-  EF_HEXAGON_MACH_V5 = 0x00000004,  // Hexagon V5
-  EF_HEXAGON_MACH_V55 = 0x00000005, // Hexagon V55
-  EF_HEXAGON_MACH_V60 = 0x00000060, // Hexagon V60
-  EF_HEXAGON_MACH_V62 = 0x00000062, // Hexagon V62
-  EF_HEXAGON_MACH_V65 = 0x00000065, // Hexagon V65
-  EF_HEXAGON_MACH_V66 = 0x00000066, // Hexagon V66
+  EF_HEXAGON_MACH_V2 = 0x00000001,   // Hexagon V2
+  EF_HEXAGON_MACH_V3 = 0x00000002,   // Hexagon V3
+  EF_HEXAGON_MACH_V4 = 0x00000003,   // Hexagon V4
+  EF_HEXAGON_MACH_V5 = 0x00000004,   // Hexagon V5
+  EF_HEXAGON_MACH_V55 = 0x00000005,  // Hexagon V55
+  EF_HEXAGON_MACH_V60 = 0x00000060,  // Hexagon V60
+  EF_HEXAGON_MACH_V62 = 0x00000062,  // Hexagon V62
+  EF_HEXAGON_MACH_V65 = 0x00000065,  // Hexagon V65
+  EF_HEXAGON_MACH_V66 = 0x00000066,  // Hexagon V66
+  EF_HEXAGON_MACH_V67 = 0x00000067,  // Hexagon V67
+  EF_HEXAGON_MACH_V67T = 0x00008067, // Hexagon V67T
 
   // Highest ISA version flags
   EF_HEXAGON_ISA_MACH = 0x00000000, // Same as specified in bits[11:0]
@@ -595,6 +611,7 @@
   EF_HEXAGON_ISA_V62 = 0x00000062,  // Hexagon V62 ISA
   EF_HEXAGON_ISA_V65 = 0x00000065,  // Hexagon V65 ISA
   EF_HEXAGON_ISA_V66 = 0x00000066,  // Hexagon V66 ISA
+  EF_HEXAGON_ISA_V67 = 0x00000067,  // Hexagon V67 ISA
 };
 
 // Hexagon-specific section indexes for common small data
@@ -682,41 +699,39 @@
   EF_AMDGPU_MACH_R600_LAST = EF_AMDGPU_MACH_R600_TURKS,
 
   // AMDGCN-based processors.
-
-  // AMDGCN GFX6.
-  EF_AMDGPU_MACH_AMDGCN_GFX600 = 0x020,
-  EF_AMDGPU_MACH_AMDGCN_GFX601 = 0x021,
-  // AMDGCN GFX7.
-  EF_AMDGPU_MACH_AMDGCN_GFX700 = 0x022,
-  EF_AMDGPU_MACH_AMDGCN_GFX701 = 0x023,
-  EF_AMDGPU_MACH_AMDGCN_GFX702 = 0x024,
-  EF_AMDGPU_MACH_AMDGCN_GFX703 = 0x025,
-  EF_AMDGPU_MACH_AMDGCN_GFX704 = 0x026,
-  // AMDGCN GFX8.
-  EF_AMDGPU_MACH_AMDGCN_GFX801 = 0x028,
-  EF_AMDGPU_MACH_AMDGCN_GFX802 = 0x029,
-  EF_AMDGPU_MACH_AMDGCN_GFX803 = 0x02a,
-  EF_AMDGPU_MACH_AMDGCN_GFX810 = 0x02b,
-  // AMDGCN GFX9.
-  EF_AMDGPU_MACH_AMDGCN_GFX900 = 0x02c,
-  EF_AMDGPU_MACH_AMDGCN_GFX902 = 0x02d,
-  EF_AMDGPU_MACH_AMDGCN_GFX904 = 0x02e,
-  EF_AMDGPU_MACH_AMDGCN_GFX906 = 0x02f,
-  EF_AMDGPU_MACH_AMDGCN_GFX908 = 0x030,
-  EF_AMDGPU_MACH_AMDGCN_GFX909 = 0x031,
-  // AMDGCN GFX10.
-  EF_AMDGPU_MACH_AMDGCN_GFX1010 = 0x033,
-  EF_AMDGPU_MACH_AMDGCN_GFX1011 = 0x034,
-  EF_AMDGPU_MACH_AMDGCN_GFX1012 = 0x035,
-
-  // Reserved for AMDGCN-based processors.
-  EF_AMDGPU_MACH_AMDGCN_RESERVED0 = 0x027,
-  EF_AMDGPU_MACH_AMDGCN_RESERVED1 = 0x030,
-  EF_AMDGPU_MACH_AMDGCN_RESERVED2 = 0x032,
+  EF_AMDGPU_MACH_AMDGCN_GFX600        = 0x020,
+  EF_AMDGPU_MACH_AMDGCN_GFX601        = 0x021,
+  EF_AMDGPU_MACH_AMDGCN_GFX700        = 0x022,
+  EF_AMDGPU_MACH_AMDGCN_GFX701        = 0x023,
+  EF_AMDGPU_MACH_AMDGCN_GFX702        = 0x024,
+  EF_AMDGPU_MACH_AMDGCN_GFX703        = 0x025,
+  EF_AMDGPU_MACH_AMDGCN_GFX704        = 0x026,
+  EF_AMDGPU_MACH_AMDGCN_RESERVED_0X27 = 0x027,
+  EF_AMDGPU_MACH_AMDGCN_GFX801        = 0x028,
+  EF_AMDGPU_MACH_AMDGCN_GFX802        = 0x029,
+  EF_AMDGPU_MACH_AMDGCN_GFX803        = 0x02a,
+  EF_AMDGPU_MACH_AMDGCN_GFX810        = 0x02b,
+  EF_AMDGPU_MACH_AMDGCN_GFX900        = 0x02c,
+  EF_AMDGPU_MACH_AMDGCN_GFX902        = 0x02d,
+  EF_AMDGPU_MACH_AMDGCN_GFX904        = 0x02e,
+  EF_AMDGPU_MACH_AMDGCN_GFX906        = 0x02f,
+  EF_AMDGPU_MACH_AMDGCN_GFX908        = 0x030,
+  EF_AMDGPU_MACH_AMDGCN_GFX909        = 0x031,
+  EF_AMDGPU_MACH_AMDGCN_GFX90C        = 0x032,
+  EF_AMDGPU_MACH_AMDGCN_GFX1010       = 0x033,
+  EF_AMDGPU_MACH_AMDGCN_GFX1011       = 0x034,
+  EF_AMDGPU_MACH_AMDGCN_GFX1012       = 0x035,
+  EF_AMDGPU_MACH_AMDGCN_GFX1030       = 0x036,
+  EF_AMDGPU_MACH_AMDGCN_GFX1031       = 0x037,
+  EF_AMDGPU_MACH_AMDGCN_GFX1032       = 0x038,
+  EF_AMDGPU_MACH_AMDGCN_GFX1033       = 0x039,
+  EF_AMDGPU_MACH_AMDGCN_GFX602        = 0x03a,
+  EF_AMDGPU_MACH_AMDGCN_GFX705        = 0x03b,
+  EF_AMDGPU_MACH_AMDGCN_GFX805        = 0x03c,
 
   // First/last AMDGCN-based processors.
   EF_AMDGPU_MACH_AMDGCN_FIRST = EF_AMDGPU_MACH_AMDGCN_GFX600,
-  EF_AMDGPU_MACH_AMDGCN_LAST = EF_AMDGPU_MACH_AMDGCN_GFX1012,
+  EF_AMDGPU_MACH_AMDGCN_LAST = EF_AMDGPU_MACH_AMDGCN_GFX805,
 
   // Indicates if the "xnack" target feature is enabled for all code contained
   // in the object.
@@ -768,6 +783,17 @@
 #include "ELFRelocs/MSP430.def"
 };
 
+// ELF Relocation type for VE.
+enum {
+#include "ELFRelocs/VE.def"
+};
+
+
+// ELF Relocation types for CSKY
+enum {
+#include "ELFRelocs/CSKY.def"
+};
+
 #undef ELF_RELOC
 
 // Section header.
@@ -814,50 +840,52 @@
 
 // Section types.
 enum : unsigned {
-  SHT_NULL = 0,                         // No associated section (inactive entry).
-  SHT_PROGBITS = 1,                     // Program-defined contents.
-  SHT_SYMTAB = 2,                       // Symbol table.
-  SHT_STRTAB = 3,                       // String table.
-  SHT_RELA = 4,                         // Relocation entries; explicit addends.
-  SHT_HASH = 5,                         // Symbol hash table.
-  SHT_DYNAMIC = 6,                      // Information for dynamic linking.
-  SHT_NOTE = 7,                         // Information about the file.
-  SHT_NOBITS = 8,                       // Data occupies no space in the file.
-  SHT_REL = 9,                          // Relocation entries; no explicit addends.
-  SHT_SHLIB = 10,                       // Reserved.
-  SHT_DYNSYM = 11,                      // Symbol table.
-  SHT_INIT_ARRAY = 14,                  // Pointers to initialization functions.
-  SHT_FINI_ARRAY = 15,                  // Pointers to termination functions.
-  SHT_PREINIT_ARRAY = 16,               // Pointers to pre-init functions.
-  SHT_GROUP = 17,                       // Section group.
-  SHT_SYMTAB_SHNDX = 18,                // Indices for SHN_XINDEX entries.
+  SHT_NULL = 0,           // No associated section (inactive entry).
+  SHT_PROGBITS = 1,       // Program-defined contents.
+  SHT_SYMTAB = 2,         // Symbol table.
+  SHT_STRTAB = 3,         // String table.
+  SHT_RELA = 4,           // Relocation entries; explicit addends.
+  SHT_HASH = 5,           // Symbol hash table.
+  SHT_DYNAMIC = 6,        // Information for dynamic linking.
+  SHT_NOTE = 7,           // Information about the file.
+  SHT_NOBITS = 8,         // Data occupies no space in the file.
+  SHT_REL = 9,            // Relocation entries; no explicit addends.
+  SHT_SHLIB = 10,         // Reserved.
+  SHT_DYNSYM = 11,        // Symbol table.
+  SHT_INIT_ARRAY = 14,    // Pointers to initialization functions.
+  SHT_FINI_ARRAY = 15,    // Pointers to termination functions.
+  SHT_PREINIT_ARRAY = 16, // Pointers to pre-init functions.
+  SHT_GROUP = 17,         // Section group.
+  SHT_SYMTAB_SHNDX = 18,  // Indices for SHN_XINDEX entries.
   // Experimental support for SHT_RELR sections. For details, see proposal
   // at https://groups.google.com/forum/#!topic/generic-abi/bX460iggiKg
-  SHT_RELR = 19,                        // Relocation entries; only offsets.
-  SHT_LOOS = 0x60000000,                // Lowest operating system-specific type.
+  SHT_RELR = 19,         // Relocation entries; only offsets.
+  SHT_LOOS = 0x60000000, // Lowest operating system-specific type.
   // Android packed relocation section types.
   // https://android.googlesource.com/platform/bionic/+/6f12bfece5dcc01325e0abba56a46b1bcf991c69/tools/relocation_packer/src/elf_file.cc#37
   SHT_ANDROID_REL = 0x60000001,
   SHT_ANDROID_RELA = 0x60000002,
-  SHT_LLVM_ODRTAB = 0x6fff4c00,         // LLVM ODR table.
-  SHT_LLVM_LINKER_OPTIONS = 0x6fff4c01, // LLVM Linker Options.
+  SHT_LLVM_ODRTAB = 0x6fff4c00,             // LLVM ODR table.
+  SHT_LLVM_LINKER_OPTIONS = 0x6fff4c01,     // LLVM Linker Options.
   SHT_LLVM_CALL_GRAPH_PROFILE = 0x6fff4c02, // LLVM Call Graph Profile.
-  SHT_LLVM_ADDRSIG = 0x6fff4c03,        // List of address-significant symbols
-                                        // for safe ICF.
-  SHT_LLVM_DEPENDENT_LIBRARIES = 0x6fff4c04, // LLVM Dependent Library Specifiers.
-  SHT_LLVM_SYMPART = 0x6fff4c05,        // Symbol partition specification.
-  SHT_LLVM_PART_EHDR = 0x6fff4c06,      // ELF header for loadable partition.
-  SHT_LLVM_PART_PHDR = 0x6fff4c07,      // Phdrs for loadable partition.
+  SHT_LLVM_ADDRSIG = 0x6fff4c03, // List of address-significant symbols
+                                 // for safe ICF.
+  SHT_LLVM_DEPENDENT_LIBRARIES =
+      0x6fff4c04,                    // LLVM Dependent Library Specifiers.
+  SHT_LLVM_SYMPART = 0x6fff4c05,     // Symbol partition specification.
+  SHT_LLVM_PART_EHDR = 0x6fff4c06,   // ELF header for loadable partition.
+  SHT_LLVM_PART_PHDR = 0x6fff4c07,   // Phdrs for loadable partition.
+  SHT_LLVM_BB_ADDR_MAP = 0x6fff4c08, // LLVM Basic Block Address Map.
   // Android's experimental support for SHT_RELR sections.
   // https://android.googlesource.com/platform/bionic/+/b7feec74547f84559a1467aca02708ff61346d2a/libc/include/elf.h#512
-  SHT_ANDROID_RELR = 0x6fffff00,        // Relocation entries; only offsets.
-  SHT_GNU_ATTRIBUTES = 0x6ffffff5,      // Object attributes.
-  SHT_GNU_HASH = 0x6ffffff6,            // GNU-style hash table.
-  SHT_GNU_verdef = 0x6ffffffd,          // GNU version definitions.
-  SHT_GNU_verneed = 0x6ffffffe,         // GNU version references.
-  SHT_GNU_versym = 0x6fffffff,          // GNU symbol versions table.
-  SHT_HIOS = 0x6fffffff,                // Highest operating system-specific type.
-  SHT_LOPROC = 0x70000000,              // Lowest processor arch-specific type.
+  SHT_ANDROID_RELR = 0x6fffff00,   // Relocation entries; only offsets.
+  SHT_GNU_ATTRIBUTES = 0x6ffffff5, // Object attributes.
+  SHT_GNU_HASH = 0x6ffffff6,       // GNU-style hash table.
+  SHT_GNU_verdef = 0x6ffffffd,     // GNU version definitions.
+  SHT_GNU_verneed = 0x6ffffffe,    // GNU version references.
+  SHT_GNU_versym = 0x6fffffff,     // GNU symbol versions table.
+  SHT_HIOS = 0x6fffffff,           // Highest operating system-specific type.
+  SHT_LOPROC = 0x70000000,         // Lowest processor arch-specific type.
   // Fixme: All this is duplicated in MCSectionELF. Why??
   // Exception Index table
   SHT_ARM_EXIDX = 0x70000001U,
@@ -867,20 +895,22 @@
   SHT_ARM_ATTRIBUTES = 0x70000003U,
   SHT_ARM_DEBUGOVERLAY = 0x70000004U,
   SHT_ARM_OVERLAYSECTION = 0x70000005U,
-  SHT_HEX_ORDERED = 0x70000000,         // Link editor is to sort the entries in
-                                        // this section based on their sizes
-  SHT_X86_64_UNWIND = 0x70000001,       // Unwind information
+  SHT_HEX_ORDERED = 0x70000000,   // Link editor is to sort the entries in
+                                  // this section based on their sizes
+  SHT_X86_64_UNWIND = 0x70000001, // Unwind information
 
-  SHT_MIPS_REGINFO = 0x70000006,        // Register usage information
-  SHT_MIPS_OPTIONS = 0x7000000d,        // General options
-  SHT_MIPS_DWARF = 0x7000001e,          // DWARF debugging section.
-  SHT_MIPS_ABIFLAGS = 0x7000002a,       // ABI information.
+  SHT_MIPS_REGINFO = 0x70000006,  // Register usage information
+  SHT_MIPS_OPTIONS = 0x7000000d,  // General options
+  SHT_MIPS_DWARF = 0x7000001e,    // DWARF debugging section.
+  SHT_MIPS_ABIFLAGS = 0x7000002a, // ABI information.
 
   SHT_MSP430_ATTRIBUTES = 0x70000003U,
 
-  SHT_HIPROC = 0x7fffffff,              // Highest processor arch-specific type.
-  SHT_LOUSER = 0x80000000,              // Lowest type reserved for applications.
-  SHT_HIUSER = 0xffffffff               // Highest type reserved for applications.
+  SHT_RISCV_ATTRIBUTES = 0x70000003U,
+
+  SHT_HIPROC = 0x7fffffff, // Highest processor arch-specific type.
+  SHT_LOUSER = 0x80000000, // Lowest type reserved for applications.
+  SHT_HIUSER = 0xffffffff  // Highest type reserved for applications.
 };
 
 // Section flags.
@@ -1200,8 +1230,9 @@
   PT_SUNW_EH_FRAME = 0x6474e550,
   PT_SUNW_UNWIND = 0x6464e550,
 
-  PT_GNU_STACK = 0x6474e551, // Indicates stack executability.
-  PT_GNU_RELRO = 0x6474e552, // Read-only after relocation.
+  PT_GNU_STACK = 0x6474e551,    // Indicates stack executability.
+  PT_GNU_RELRO = 0x6474e552,    // Read-only after relocation.
+  PT_GNU_PROPERTY = 0x6474e553, // .note.gnu.property notes sections.
 
   PT_OPENBSD_RANDOMIZE = 0x65a3dbe6, // Fill with random data.
   PT_OPENBSD_WXNEEDED = 0x65a3dbe7,  // Program does W^X violations.
@@ -1290,7 +1321,8 @@
   DF_1_NORELOC = 0x00400000,
   DF_1_SYMINTPOSE = 0x00800000, // Object has individual interposers.
   DF_1_GLOBAUDIT = 0x01000000,  // Global auditing required.
-  DF_1_SINGLETON = 0x02000000   // Singleton symbols are used.
+  DF_1_SINGLETON = 0x02000000,  // Singleton symbols are used.
+  DF_1_PIE = 0x08000000,        // Object is a position-independent executable.
 };
 
 // DT_MIPS_FLAGS values.
@@ -1357,6 +1389,72 @@
   NT_GNU_BUILD_ATTRIBUTE_FUNC = 0x101,
 };
 
+// Core note types
+enum : unsigned {
+  NT_PRSTATUS = 1,
+  NT_FPREGSET = 2,
+  NT_PRPSINFO = 3,
+  NT_TASKSTRUCT = 4,
+  NT_AUXV = 6,
+  NT_PSTATUS = 10,
+  NT_FPREGS = 12,
+  NT_PSINFO = 13,
+  NT_LWPSTATUS = 16,
+  NT_LWPSINFO = 17,
+  NT_WIN32PSTATUS = 18,
+
+  NT_PPC_VMX = 0x100,
+  NT_PPC_VSX = 0x102,
+  NT_PPC_TAR = 0x103,
+  NT_PPC_PPR = 0x104,
+  NT_PPC_DSCR = 0x105,
+  NT_PPC_EBB = 0x106,
+  NT_PPC_PMU = 0x107,
+  NT_PPC_TM_CGPR = 0x108,
+  NT_PPC_TM_CFPR = 0x109,
+  NT_PPC_TM_CVMX = 0x10a,
+  NT_PPC_TM_CVSX = 0x10b,
+  NT_PPC_TM_SPR = 0x10c,
+  NT_PPC_TM_CTAR = 0x10d,
+  NT_PPC_TM_CPPR = 0x10e,
+  NT_PPC_TM_CDSCR = 0x10f,
+
+  NT_386_TLS = 0x200,
+  NT_386_IOPERM = 0x201,
+  NT_X86_XSTATE = 0x202,
+
+  NT_S390_HIGH_GPRS = 0x300,
+  NT_S390_TIMER = 0x301,
+  NT_S390_TODCMP = 0x302,
+  NT_S390_TODPREG = 0x303,
+  NT_S390_CTRS = 0x304,
+  NT_S390_PREFIX = 0x305,
+  NT_S390_LAST_BREAK = 0x306,
+  NT_S390_SYSTEM_CALL = 0x307,
+  NT_S390_TDB = 0x308,
+  NT_S390_VXRS_LOW = 0x309,
+  NT_S390_VXRS_HIGH = 0x30a,
+  NT_S390_GS_CB = 0x30b,
+  NT_S390_GS_BC = 0x30c,
+
+  NT_ARM_VFP = 0x400,
+  NT_ARM_TLS = 0x401,
+  NT_ARM_HW_BREAK = 0x402,
+  NT_ARM_HW_WATCH = 0x403,
+  NT_ARM_SVE = 0x405,
+  NT_ARM_PAC_MASK = 0x406,
+
+  NT_FILE = 0x46494c45,
+  NT_PRXFPREG = 0x46e62b7f,
+  NT_SIGINFO = 0x53494749,
+};
+
+// LLVM-specific notes.
+enum {
+  NT_LLVM_HWASAN_GLOBALS = 3,
+};
+
+// GNU note types
 enum {
   NT_GNU_ABI_TAG = 1,
   NT_GNU_HWCAP = 2,
diff --git a/linux-x64/clang/include/llvm/BinaryFormat/ELFRelocs/AArch64.def b/linux-x64/clang/include/llvm/BinaryFormat/ELFRelocs/AArch64.def
index 4afcd7d..96a4efe 100644
--- a/linux-x64/clang/include/llvm/BinaryFormat/ELFRelocs/AArch64.def
+++ b/linux-x64/clang/include/llvm/BinaryFormat/ELFRelocs/AArch64.def
@@ -58,6 +58,7 @@
 ELF_RELOC(R_AARCH64_ADR_GOT_PAGE,                    0x137)
 ELF_RELOC(R_AARCH64_LD64_GOT_LO12_NC,                0x138)
 ELF_RELOC(R_AARCH64_LD64_GOTPAGE_LO15,               0x139)
+ELF_RELOC(R_AARCH64_PLT32,                           0x13a)
 ELF_RELOC(R_AARCH64_TLSGD_ADR_PREL21,                0x200)
 ELF_RELOC(R_AARCH64_TLSGD_ADR_PAGE21,                0x201)
 ELF_RELOC(R_AARCH64_TLSGD_ADD_LO12_NC,               0x202)
@@ -120,12 +121,16 @@
 ELF_RELOC(R_AARCH64_TLSLE_LDST128_TPREL_LO12_NC,     0x23b)
 ELF_RELOC(R_AARCH64_TLSLD_LDST128_DTPREL_LO12,       0x23c)
 ELF_RELOC(R_AARCH64_TLSLD_LDST128_DTPREL_LO12_NC,    0x23d)
+// Dynamic relocations start
 ELF_RELOC(R_AARCH64_COPY,                            0x400)
 ELF_RELOC(R_AARCH64_GLOB_DAT,                        0x401)
 ELF_RELOC(R_AARCH64_JUMP_SLOT,                       0x402)
 ELF_RELOC(R_AARCH64_RELATIVE,                        0x403)
-ELF_RELOC(R_AARCH64_TLS_DTPREL64,                    0x404)
-ELF_RELOC(R_AARCH64_TLS_DTPMOD64,                    0x405)
+// 0x404 and 0x405 are now R_AARCH64_TLS_IMPDEF1 and R_AARCH64_TLS_IMPDEF2
+// We follow GNU and define TLS_IMPDEF1 as TLS_DTPMOD64 and TLS_IMPDEF2 as
+// TLS_DTPREL64
+ELF_RELOC(R_AARCH64_TLS_DTPMOD64,                    0x404)
+ELF_RELOC(R_AARCH64_TLS_DTPREL64,                    0x405)
 ELF_RELOC(R_AARCH64_TLS_TPREL64,                     0x406)
 ELF_RELOC(R_AARCH64_TLSDESC,                         0x407)
 ELF_RELOC(R_AARCH64_IRELATIVE,                       0x408)
@@ -159,6 +164,7 @@
 ELF_RELOC(R_AARCH64_P32_ADR_GOT_PAGE,                0x01a)
 ELF_RELOC(R_AARCH64_P32_LD32_GOT_LO12_NC,            0x01b)
 ELF_RELOC(R_AARCH64_P32_LD32_GOTPAGE_LO14,           0x01c)
+ELF_RELOC(R_AARCH64_P32_PLT32,                       0x01d)
 ELF_RELOC(R_AARCH64_P32_TLSGD_ADR_PREL21,            0x050)
 ELF_RELOC(R_AARCH64_P32_TLSGD_ADR_PAGE21,            0x051)
 ELF_RELOC(R_AARCH64_P32_TLSGD_ADD_LO12_NC,           0x052)
@@ -207,6 +213,7 @@
 ELF_RELOC(R_AARCH64_P32_TLSDESC_LD32_LO12,           0x07d)
 ELF_RELOC(R_AARCH64_P32_TLSDESC_ADD_LO12,            0x07e)
 ELF_RELOC(R_AARCH64_P32_TLSDESC_CALL,                0x07f)
+// Dynamic relocations start
 ELF_RELOC(R_AARCH64_P32_COPY,                        0x0b4)
 ELF_RELOC(R_AARCH64_P32_GLOB_DAT,                    0x0b5)
 ELF_RELOC(R_AARCH64_P32_JUMP_SLOT,                   0x0b6)
diff --git a/linux-x64/clang/include/llvm/BinaryFormat/ELFRelocs/CSKY.def b/linux-x64/clang/include/llvm/BinaryFormat/ELFRelocs/CSKY.def
new file mode 100644
index 0000000..c5f2dba
--- /dev/null
+++ b/linux-x64/clang/include/llvm/BinaryFormat/ELFRelocs/CSKY.def
@@ -0,0 +1,74 @@
+
+#ifndef ELF_RELOC
+#error "ELF_RELOC must be defined"
+#endif
+
+ELF_RELOC(R_CKCORE_NONE,                        0)
+ELF_RELOC(R_CKCORE_ADDR32,                      1)
+ELF_RELOC(R_CKCORE_PCREL_IMM8_4,                2)
+ELF_RELOC(R_CKCORE_PCREL_IMM11_2,               3)
+ELF_RELOC(R_CKCORE_PCREL_IMM4_2,                4)
+ELF_RELOC(R_CKCORE_PCREL32,                     5)
+ELF_RELOC(R_CKCORE_PCREL_JSR_IMM11_2,           6)
+ELF_RELOC(R_CKCORE_GNU_VTINHERIT,               7)
+ELF_RELOC(R_CKCORE_GNU_VTENTRY,                 8)
+ELF_RELOC(R_CKCORE_RELATIVE,                    9)
+ELF_RELOC(R_CKCORE_COPY,                       10)
+ELF_RELOC(R_CKCORE_GLOB_DAT,                   11)
+ELF_RELOC(R_CKCORE_JUMP_SLOT,                  12)
+ELF_RELOC(R_CKCORE_GOTOFF,                     13)
+ELF_RELOC(R_CKCORE_GOTPC,                      14)
+ELF_RELOC(R_CKCORE_GOT32,                      15)
+ELF_RELOC(R_CKCORE_PLT32,                      16)
+ELF_RELOC(R_CKCORE_ADDRGOT,                    17)
+ELF_RELOC(R_CKCORE_ADDRPLT,                    18)
+ELF_RELOC(R_CKCORE_PCREL_IMM26_2,              19)
+ELF_RELOC(R_CKCORE_PCREL_IMM16_2,              20)
+ELF_RELOC(R_CKCORE_PCREL_IMM16_4,              21)
+ELF_RELOC(R_CKCORE_PCREL_IMM10_2,              22)
+ELF_RELOC(R_CKCORE_PCREL_IMM10_4,              23)
+ELF_RELOC(R_CKCORE_ADDR_HI16,                  24)
+ELF_RELOC(R_CKCORE_ADDR_LO16,                  25)
+ELF_RELOC(R_CKCORE_GOTPC_HI16,                 26)
+ELF_RELOC(R_CKCORE_GOTPC_LO16,                 27)
+ELF_RELOC(R_CKCORE_GOTOFF_HI16,                28)
+ELF_RELOC(R_CKCORE_GOTOFF_LO16,                29)
+ELF_RELOC(R_CKCORE_GOT12,                      30)
+ELF_RELOC(R_CKCORE_GOT_HI16,                   31)
+ELF_RELOC(R_CKCORE_GOT_LO16,                   32)
+ELF_RELOC(R_CKCORE_PLT12,                      33)
+ELF_RELOC(R_CKCORE_PLT_HI16,                   34)
+ELF_RELOC(R_CKCORE_PLT_LO16,                   35)
+ELF_RELOC(R_CKCORE_ADDRGOT_HI16,               36)
+ELF_RELOC(R_CKCORE_ADDRGOT_LO16,               37)
+ELF_RELOC(R_CKCORE_ADDRPLT_HI16,               38)
+ELF_RELOC(R_CKCORE_ADDRPLT_LO16,               39)
+ELF_RELOC(R_CKCORE_PCREL_JSR_IMM26_2,          40)
+ELF_RELOC(R_CKCORE_TOFFSET_LO16,               41)
+ELF_RELOC(R_CKCORE_DOFFSET_LO16,               42)
+ELF_RELOC(R_CKCORE_PCREL_IMM18_2,              43)
+ELF_RELOC(R_CKCORE_DOFFSET_IMM18,              44)
+ELF_RELOC(R_CKCORE_DOFFSET_IMM18_2,            45)
+ELF_RELOC(R_CKCORE_DOFFSET_IMM18_4,            46)
+ELF_RELOC(R_CKCORE_GOTOFF_IMM18,               47)
+ELF_RELOC(R_CKCORE_GOT_IMM18_4,                48)
+ELF_RELOC(R_CKCORE_PLT_IMM18_4,                49)
+ELF_RELOC(R_CKCORE_PCREL_IMM7_4,               50)
+ELF_RELOC(R_CKCORE_TLS_LE32,                   51)
+ELF_RELOC(R_CKCORE_TLS_IE32,                   52)
+ELF_RELOC(R_CKCORE_TLS_GD32,                   53)
+ELF_RELOC(R_CKCORE_TLS_LDM32,                  54)
+ELF_RELOC(R_CKCORE_TLS_LDO32,                  55)
+ELF_RELOC(R_CKCORE_TLS_DTPMOD32,               56)
+ELF_RELOC(R_CKCORE_TLS_DTPOFF32,               57)
+ELF_RELOC(R_CKCORE_TLS_TPOFF32,                58)
+ELF_RELOC(R_CKCORE_PCREL_FLRW_IMM8_4,          59)
+ELF_RELOC(R_CKCORE_NOJSRI,                     60)
+ELF_RELOC(R_CKCORE_CALLGRAPH,                  61)
+ELF_RELOC(R_CKCORE_IRELATIVE,                  62)
+ELF_RELOC(R_CKCORE_PCREL_BLOOP_IMM4_4,         63)
+ELF_RELOC(R_CKCORE_PCREL_BLOOP_IMM12_4,        64)
+ELF_RELOC(R_CKCORE_PCREL_VLRW_IMM12_1,         65)
+ELF_RELOC(R_CKCORE_PCREL_VLRW_IMM12_2,         66)
+ELF_RELOC(R_CKCORE_PCREL_VLRW_IMM12_4,         67)
+ELF_RELOC(R_CKCORE_PCREL_VLRW_IMM12_8,         68)
diff --git a/linux-x64/clang/include/llvm/BinaryFormat/ELFRelocs/PowerPC64.def b/linux-x64/clang/include/llvm/BinaryFormat/ELFRelocs/PowerPC64.def
index 8c5b482..0422aa0 100644
--- a/linux-x64/clang/include/llvm/BinaryFormat/ELFRelocs/PowerPC64.def
+++ b/linux-x64/clang/include/llvm/BinaryFormat/ELFRelocs/PowerPC64.def
@@ -26,6 +26,7 @@
 #undef R_PPC64_GOT16_LO
 #undef R_PPC64_GOT16_HI
 #undef R_PPC64_GOT16_HA
+#undef R_PPC64_COPY
 #undef R_PPC64_GLOB_DAT
 #undef R_PPC64_JMP_SLOT
 #undef R_PPC64_RELATIVE
@@ -95,6 +96,15 @@
 #undef R_PPC64_TPREL16_HIGHA
 #undef R_PPC64_DTPREL16_HIGH
 #undef R_PPC64_DTPREL16_HIGHA
+#undef R_PPC64_REL24_NOTOC
+#undef R_PPC64_PCREL_OPT
+#undef R_PPC64_PCREL34
+#undef R_PPC64_GOT_PCREL34
+#undef R_PPC64_TPREL34
+#undef R_PPC64_DTPREL34
+#undef R_PPC64_GOT_TLSGD_PCREL34
+#undef R_PPC64_GOT_TLSLD_PCREL34
+#undef R_PPC64_GOT_TPREL_PCREL34
 #undef R_PPC64_IRELATIVE
 #undef R_PPC64_REL16
 #undef R_PPC64_REL16_LO
@@ -119,6 +129,7 @@
 ELF_RELOC(R_PPC64_GOT16_LO,             15)
 ELF_RELOC(R_PPC64_GOT16_HI,             16)
 ELF_RELOC(R_PPC64_GOT16_HA,             17)
+ELF_RELOC(R_PPC64_COPY,                 19)
 ELF_RELOC(R_PPC64_GLOB_DAT,             20)
 ELF_RELOC(R_PPC64_JMP_SLOT,             21)
 ELF_RELOC(R_PPC64_RELATIVE,             22)
@@ -188,6 +199,15 @@
 ELF_RELOC(R_PPC64_TPREL16_HIGHA,        113)
 ELF_RELOC(R_PPC64_DTPREL16_HIGH,        114)
 ELF_RELOC(R_PPC64_DTPREL16_HIGHA,       115)
+ELF_RELOC(R_PPC64_REL24_NOTOC,          116)
+ELF_RELOC(R_PPC64_PCREL_OPT,            123)
+ELF_RELOC(R_PPC64_PCREL34,              132)
+ELF_RELOC(R_PPC64_GOT_PCREL34,          133)
+ELF_RELOC(R_PPC64_TPREL34,              146)
+ELF_RELOC(R_PPC64_DTPREL34,             147)
+ELF_RELOC(R_PPC64_GOT_TLSGD_PCREL34,    148)
+ELF_RELOC(R_PPC64_GOT_TLSLD_PCREL34,    149)
+ELF_RELOC(R_PPC64_GOT_TPREL_PCREL34,    150)
 ELF_RELOC(R_PPC64_IRELATIVE,            248)
 ELF_RELOC(R_PPC64_REL16,                249)
 ELF_RELOC(R_PPC64_REL16_LO,             250)
diff --git a/linux-x64/clang/include/llvm/BinaryFormat/ELFRelocs/RISCV.def b/linux-x64/clang/include/llvm/BinaryFormat/ELFRelocs/RISCV.def
index 5cc4c0e..9f2f054 100644
--- a/linux-x64/clang/include/llvm/BinaryFormat/ELFRelocs/RISCV.def
+++ b/linux-x64/clang/include/llvm/BinaryFormat/ELFRelocs/RISCV.def
@@ -57,3 +57,4 @@
 ELF_RELOC(R_RISCV_SET16,             55)
 ELF_RELOC(R_RISCV_SET32,             56)
 ELF_RELOC(R_RISCV_32_PCREL,          57)
+ELF_RELOC(R_RISCV_IRELATIVE,         58)
diff --git a/linux-x64/clang/include/llvm/BinaryFormat/ELFRelocs/VE.def b/linux-x64/clang/include/llvm/BinaryFormat/ELFRelocs/VE.def
new file mode 100644
index 0000000..9bfdbf1
--- /dev/null
+++ b/linux-x64/clang/include/llvm/BinaryFormat/ELFRelocs/VE.def
@@ -0,0 +1,48 @@
+
+#ifndef ELF_RELOC
+#error "ELF_RELOC must be defined"
+#endif
+
+// Relocation types defined in following documents.
+//
+//  - System V Application Binary Interface - VE Architecture
+//    Processor Supplement
+//  - ELF Handling For Thread-Local Storage - VE Architecture
+//    Processor Supplement
+
+ELF_RELOC(R_VE_NONE,         0)
+ELF_RELOC(R_VE_REFLONG,      1)
+ELF_RELOC(R_VE_REFQUAD,      2)
+ELF_RELOC(R_VE_SREL32,       3)
+ELF_RELOC(R_VE_HI32,         4)
+ELF_RELOC(R_VE_LO32,         5)
+ELF_RELOC(R_VE_PC_HI32,      6)
+ELF_RELOC(R_VE_PC_LO32,      7)
+ELF_RELOC(R_VE_GOT32,        8)
+ELF_RELOC(R_VE_GOT_HI32,     9)
+ELF_RELOC(R_VE_GOT_LO32,     10)
+ELF_RELOC(R_VE_GOTOFF32,     11)
+ELF_RELOC(R_VE_GOTOFF_HI32,  12)
+ELF_RELOC(R_VE_GOTOFF_LO32,  13)
+ELF_RELOC(R_VE_PLT32,        14)
+ELF_RELOC(R_VE_PLT_HI32,     15)
+ELF_RELOC(R_VE_PLT_LO32,     16)
+ELF_RELOC(R_VE_RELATIVE,     17)
+ELF_RELOC(R_VE_GLOB_DAT,     18)
+ELF_RELOC(R_VE_JUMP_SLOT,    19)
+ELF_RELOC(R_VE_COPY,         20)
+ELF_RELOC(R_VE_DTPMOD64,     22)
+ELF_RELOC(R_VE_DTPOFF64,     23)
+// ELF_RELOC(R_VE_TPOFF64,     24)
+ELF_RELOC(R_VE_TLS_GD_HI32,  25)
+ELF_RELOC(R_VE_TLS_GD_LO32,  26)
+// ELF_RELOC(R_VE_TLS_LD_HI32,  27)
+// ELF_RELOC(R_VE_TLS_LD_LO32,  28)
+// ELF_RELOC(R_VE_DTPOFF32,     29)
+// ELF_RELOC(R_VE_TLS_IE_HI32,  30)
+// ELF_RELOC(R_VE_TLS_IE_LO32,  31)
+ELF_RELOC(R_VE_TPOFF_HI32,   32)
+ELF_RELOC(R_VE_TPOFF_LO32,   33)
+// ELF_RELOC(R_VE_TPOFF32,      34)
+ELF_RELOC(R_VE_CALL_HI32,    35)
+ELF_RELOC(R_VE_CALL_LO32,    36)
diff --git a/linux-x64/clang/include/llvm/BinaryFormat/MachO.h b/linux-x64/clang/include/llvm/BinaryFormat/MachO.h
index a01393a..f5d5ec3 100644
--- a/linux-x64/clang/include/llvm/BinaryFormat/MachO.h
+++ b/linux-x64/clang/include/llvm/BinaryFormat/MachO.h
@@ -15,9 +15,13 @@
 
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/DataTypes.h"
-#include "llvm/Support/Host.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/SwapByteOrder.h"
 
 namespace llvm {
+
+class Triple;
+
 namespace MachO {
 // Enums from <mach-o/loader.h>
 enum : uint32_t {
@@ -78,7 +82,9 @@
   MH_HAS_TLV_DESCRIPTORS = 0x00800000u,
   MH_NO_HEAP_EXECUTION = 0x01000000u,
   MH_APP_EXTENSION_SAFE = 0x02000000u,
-  MH_NLIST_OUTOFSYNC_WITH_DYLDINFO = 0x04000000u
+  MH_NLIST_OUTOFSYNC_WITH_DYLDINFO = 0x04000000u,
+  MH_SIM_SUPPORT = 0x08000000u,
+  MH_DYLIB_IN_CACHE = 0x80000000u,
 };
 
 enum : uint32_t {
@@ -490,7 +496,8 @@
   PLATFORM_MACCATALYST = 6,
   PLATFORM_IOSSIMULATOR = 7,
   PLATFORM_TVOSSIMULATOR = 8,
-  PLATFORM_WATCHOSSIMULATOR = 9
+  PLATFORM_WATCHOSSIMULATOR = 9,
+  PLATFORM_DRIVERKIT = 10,
 };
 
 // Values for tools enum in build_tool_version.
@@ -581,6 +588,11 @@
   uint32_t reserved3;
 };
 
+inline bool isVirtualSection(uint8_t type) {
+  return (type == MachO::S_ZEROFILL || type == MachO::S_GB_ZEROFILL ||
+          type == MachO::S_THREAD_LOCAL_ZEROFILL);
+}
+
 struct fvmlib {
   uint32_t name;
   uint32_t minor_version;
@@ -943,13 +955,8 @@
 // Structs from <mach-o/reloc.h>
 struct relocation_info {
   int32_t r_address;
-#if defined(BYTE_ORDER) && defined(BIG_ENDIAN) && (BYTE_ORDER == BIG_ENDIAN)
-  uint32_t r_type : 4,  r_extern : 1, r_length : 2, r_pcrel : 1,
-      r_symbolnum : 24;
-#else
   uint32_t r_symbolnum : 24, r_pcrel : 1, r_length : 2, r_extern : 1,
       r_type : 4;
-#endif
 };
 
 struct scattered_relocation_info {
@@ -1487,6 +1494,7 @@
 
 enum CPUSubTypeARM64 {
   CPU_SUBTYPE_ARM64_ALL = 0,
+  CPU_SUBTYPE_ARM64_V8 = 1,
   CPU_SUBTYPE_ARM64E = 2,
 };
 
@@ -1513,6 +1521,9 @@
   CPU_SUBTYPE_MC98601 = CPU_SUBTYPE_POWERPC_601
 };
 
+Expected<uint32_t> getCPUType(const Triple &T);
+Expected<uint32_t> getCPUSubType(const Triple &T);
+
 struct x86_thread_state32_t {
   uint32_t eax;
   uint32_t ebx;
diff --git a/linux-x64/clang/include/llvm/BinaryFormat/Magic.h b/linux-x64/clang/include/llvm/BinaryFormat/Magic.h
index cd9833e..78227dd 100644
--- a/linux-x64/clang/include/llvm/BinaryFormat/Magic.h
+++ b/linux-x64/clang/include/llvm/BinaryFormat/Magic.h
@@ -9,12 +9,12 @@
 #ifndef LLVM_BINARYFORMAT_MAGIC_H
 #define LLVM_BINARYFORMAT_MAGIC_H
 
-#include "llvm/ADT/StringRef.h"
-#include "llvm/ADT/Twine.h"
-
 #include <system_error>
 
 namespace llvm {
+class StringRef;
+class Twine;
+
 /// file_magic - An "enum class" enumeration of file types based on magic (the
 /// first N bytes of the file).
 struct file_magic {
@@ -49,6 +49,7 @@
     xcoff_object_64,     ///< 64-bit XCOFF object file
     wasm_object,         ///< WebAssembly Object file
     pdb,                 ///< Windows PDB debug info file
+    tapi_file,           ///< Text-based Dynamic Library Stub file
   };
 
   bool is_object() const { return V != unknown; }
diff --git a/linux-x64/clang/include/llvm/BinaryFormat/Minidump.h b/linux-x64/clang/include/llvm/BinaryFormat/Minidump.h
index 65c17d1..89cd779 100644
--- a/linux-x64/clang/include/llvm/BinaryFormat/Minidump.h
+++ b/linux-x64/clang/include/llvm/BinaryFormat/Minidump.h
@@ -18,12 +18,15 @@
 #ifndef LLVM_BINARYFORMAT_MINIDUMP_H
 #define LLVM_BINARYFORMAT_MINIDUMP_H
 
+#include "llvm/ADT/BitmaskEnum.h"
 #include "llvm/ADT/DenseMapInfo.h"
 #include "llvm/Support/Endian.h"
 
 namespace llvm {
 namespace minidump {
 
+LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE();
+
 /// The minidump header is the first part of a minidump file. It identifies the
 /// file as a minidump file, and gives the location of the stream directory.
 struct Header {
@@ -67,6 +70,50 @@
 };
 static_assert(sizeof(MemoryDescriptor) == 16, "");
 
+struct MemoryInfoListHeader {
+  support::ulittle32_t SizeOfHeader;
+  support::ulittle32_t SizeOfEntry;
+  support::ulittle64_t NumberOfEntries;
+
+  MemoryInfoListHeader() = default;
+  MemoryInfoListHeader(uint32_t SizeOfHeader, uint32_t SizeOfEntry,
+                       uint64_t NumberOfEntries)
+      : SizeOfHeader(SizeOfHeader), SizeOfEntry(SizeOfEntry),
+        NumberOfEntries(NumberOfEntries) {}
+};
+static_assert(sizeof(MemoryInfoListHeader) == 16, "");
+
+enum class MemoryProtection : uint32_t {
+#define HANDLE_MDMP_PROTECT(CODE, NAME, NATIVENAME) NAME = CODE,
+#include "llvm/BinaryFormat/MinidumpConstants.def"
+  LLVM_MARK_AS_BITMASK_ENUM(/*LargestValue=*/0xffffffffu),
+};
+
+enum class MemoryState : uint32_t {
+#define HANDLE_MDMP_MEMSTATE(CODE, NAME, NATIVENAME) NAME = CODE,
+#include "llvm/BinaryFormat/MinidumpConstants.def"
+  LLVM_MARK_AS_BITMASK_ENUM(/*LargestValue=*/0xffffffffu),
+};
+
+enum class MemoryType : uint32_t {
+#define HANDLE_MDMP_MEMTYPE(CODE, NAME, NATIVENAME) NAME = CODE,
+#include "llvm/BinaryFormat/MinidumpConstants.def"
+  LLVM_MARK_AS_BITMASK_ENUM(/*LargestValue=*/0xffffffffu),
+};
+
+struct MemoryInfo {
+  support::ulittle64_t BaseAddress;
+  support::ulittle64_t AllocationBase;
+  support::little_t<MemoryProtection> AllocationProtect;
+  support::ulittle32_t Reserved0;
+  support::ulittle64_t RegionSize;
+  support::little_t<MemoryState> State;
+  support::little_t<MemoryProtection> Protect;
+  support::little_t<MemoryType> Type;
+  support::ulittle32_t Reserved1;
+};
+static_assert(sizeof(MemoryInfo) == 48, "");
+
 /// Specifies the location and type of a single stream in the minidump file. The
 /// minidump stream directory is an array of entries of this type, with its size
 /// given by Header.NumberOfStreams.
@@ -180,6 +227,27 @@
 };
 static_assert(sizeof(Thread) == 48, "");
 
+struct Exception {
+  static constexpr size_t MaxParameters = 15;
+
+  support::ulittle32_t ExceptionCode;
+  support::ulittle32_t ExceptionFlags;
+  support::ulittle64_t ExceptionRecord;
+  support::ulittle64_t ExceptionAddress;
+  support::ulittle32_t NumberParameters;
+  support::ulittle32_t UnusedAlignment;
+  support::ulittle64_t ExceptionInformation[MaxParameters];
+};
+static_assert(sizeof(Exception) == 152, "");
+
+struct ExceptionStream {
+  support::ulittle32_t ThreadId;
+  support::ulittle32_t UnusedAlignment;
+  Exception ExceptionRecord;
+  LocationDescriptor ThreadContext;
+};
+static_assert(sizeof(ExceptionStream) == 168, "");
+
 } // namespace minidump
 
 template <> struct DenseMapInfo<minidump::StreamType> {
diff --git a/linux-x64/clang/include/llvm/BinaryFormat/MinidumpConstants.def b/linux-x64/clang/include/llvm/BinaryFormat/MinidumpConstants.def
index d4f13dd..543305f 100644
--- a/linux-x64/clang/include/llvm/BinaryFormat/MinidumpConstants.def
+++ b/linux-x64/clang/include/llvm/BinaryFormat/MinidumpConstants.def
@@ -6,8 +6,9 @@
 //
 //===----------------------------------------------------------------------===//
 
-#if !(defined HANDLE_MDMP_STREAM_TYPE || defined HANDLE_MDMP_ARCH ||           \
-      defined HANDLE_MDMP_PLATFORM)
+#if !(defined(HANDLE_MDMP_STREAM_TYPE) || defined(HANDLE_MDMP_ARCH) ||         \
+      defined(HANDLE_MDMP_PLATFORM) || defined(HANDLE_MDMP_PROTECT) ||         \
+      defined(HANDLE_MDMP_MEMSTATE) || defined(HANDLE_MDMP_MEMTYPE))
 #error "Missing HANDLE_MDMP definition"
 #endif
 
@@ -23,6 +24,18 @@
 #define HANDLE_MDMP_PLATFORM(CODE, NAME)
 #endif
 
+#ifndef HANDLE_MDMP_PROTECT
+#define HANDLE_MDMP_PROTECT(CODE, NAME, NATIVENAME)
+#endif
+
+#ifndef HANDLE_MDMP_MEMSTATE
+#define HANDLE_MDMP_MEMSTATE(CODE, NAME, NATIVENAME)
+#endif
+
+#ifndef HANDLE_MDMP_MEMTYPE
+#define HANDLE_MDMP_MEMTYPE(CODE, NAME, NATIVENAME)
+#endif
+
 HANDLE_MDMP_STREAM_TYPE(0x0003, ThreadList)
 HANDLE_MDMP_STREAM_TYPE(0x0004, ModuleList)
 HANDLE_MDMP_STREAM_TYPE(0x0005, MemoryList)
@@ -72,21 +85,22 @@
 HANDLE_MDMP_STREAM_TYPE(0xFACEDEAD, FacebookAbortReason)
 HANDLE_MDMP_STREAM_TYPE(0xFACEE000, FacebookThreadName)
 
-HANDLE_MDMP_ARCH(0x0000, X86)      // PROCESSOR_ARCHITECTURE_INTEL
-HANDLE_MDMP_ARCH(0x0001, MIPS)     // PROCESSOR_ARCHITECTURE_MIPS
-HANDLE_MDMP_ARCH(0x0002, Alpha)    // PROCESSOR_ARCHITECTURE_ALPHA
-HANDLE_MDMP_ARCH(0x0003, PPC)      // PROCESSOR_ARCHITECTURE_PPC
-HANDLE_MDMP_ARCH(0x0004, SHX)      // PROCESSOR_ARCHITECTURE_SHX (Super-H)
-HANDLE_MDMP_ARCH(0x0005, ARM)      // PROCESSOR_ARCHITECTURE_ARM
-HANDLE_MDMP_ARCH(0x0006, IA64)     // PROCESSOR_ARCHITECTURE_IA64
-HANDLE_MDMP_ARCH(0x0007, Alpha64)  // PROCESSOR_ARCHITECTURE_ALPHA64
-HANDLE_MDMP_ARCH(0x0008, MSIL)     // PROCESSOR_ARCHITECTURE_MSIL
-HANDLE_MDMP_ARCH(0x0009, AMD64)    // PROCESSOR_ARCHITECTURE_AMD64
-HANDLE_MDMP_ARCH(0x000a, X86Win64) // PROCESSOR_ARCHITECTURE_IA32_ON_WIN64
-HANDLE_MDMP_ARCH(0x8001, SPARC)    // Breakpad-defined value for SPARC
-HANDLE_MDMP_ARCH(0x8002, PPC64)    // Breakpad-defined value for PPC64
-HANDLE_MDMP_ARCH(0x8003, ARM64)    // Breakpad-defined value for ARM64
-HANDLE_MDMP_ARCH(0x8004, MIPS64)   // Breakpad-defined value for MIPS64
+HANDLE_MDMP_ARCH(0x0000, X86)       // PROCESSOR_ARCHITECTURE_INTEL
+HANDLE_MDMP_ARCH(0x0001, MIPS)      // PROCESSOR_ARCHITECTURE_MIPS
+HANDLE_MDMP_ARCH(0x0002, Alpha)     // PROCESSOR_ARCHITECTURE_ALPHA
+HANDLE_MDMP_ARCH(0x0003, PPC)       // PROCESSOR_ARCHITECTURE_PPC
+HANDLE_MDMP_ARCH(0x0004, SHX)       // PROCESSOR_ARCHITECTURE_SHX (Super-H)
+HANDLE_MDMP_ARCH(0x0005, ARM)       // PROCESSOR_ARCHITECTURE_ARM
+HANDLE_MDMP_ARCH(0x0006, IA64)      // PROCESSOR_ARCHITECTURE_IA64
+HANDLE_MDMP_ARCH(0x0007, Alpha64)   // PROCESSOR_ARCHITECTURE_ALPHA64
+HANDLE_MDMP_ARCH(0x0008, MSIL)      // PROCESSOR_ARCHITECTURE_MSIL
+HANDLE_MDMP_ARCH(0x0009, AMD64)     // PROCESSOR_ARCHITECTURE_AMD64
+HANDLE_MDMP_ARCH(0x000a, X86Win64)  // PROCESSOR_ARCHITECTURE_IA32_ON_WIN64
+HANDLE_MDMP_ARCH(0x000c, ARM64)     // PROCESSOR_ARCHITECTURE_ARM64
+HANDLE_MDMP_ARCH(0x8001, BP_SPARC)  // Breakpad-defined value for SPARC
+HANDLE_MDMP_ARCH(0x8002, BP_PPC64)  // Breakpad-defined value for PPC64
+HANDLE_MDMP_ARCH(0x8003, BP_ARM64)  // Breakpad-defined value for ARM64
+HANDLE_MDMP_ARCH(0x8004, BP_MIPS64) // Breakpad-defined value for MIPS64
 
 HANDLE_MDMP_PLATFORM(0x0000, Win32S) // Win32 on Windows 3.1
 HANDLE_MDMP_PLATFORM(0x0001, Win32Windows) // Windows 95-98-Me
@@ -102,6 +116,30 @@
 HANDLE_MDMP_PLATFORM(0x8204, PS3) // PS3
 HANDLE_MDMP_PLATFORM(0x8205, NaCl) // Native Client (NaCl)
 
+HANDLE_MDMP_PROTECT(0x01, NoAccess, PAGE_NO_ACCESS)
+HANDLE_MDMP_PROTECT(0x02, ReadOnly, PAGE_READ_ONLY)
+HANDLE_MDMP_PROTECT(0x04, ReadWrite, PAGE_READ_WRITE)
+HANDLE_MDMP_PROTECT(0x08, WriteCopy, PAGE_WRITE_COPY)
+HANDLE_MDMP_PROTECT(0x10, Execute, PAGE_EXECUTE)
+HANDLE_MDMP_PROTECT(0x20, ExecuteRead, PAGE_EXECUTE_READ)
+HANDLE_MDMP_PROTECT(0x40, ExecuteReadWrite, PAGE_EXECUTE_READ_WRITE)
+HANDLE_MDMP_PROTECT(0x80, ExeciteWriteCopy, PAGE_EXECUTE_WRITE_COPY)
+HANDLE_MDMP_PROTECT(0x100, Guard, PAGE_GUARD)
+HANDLE_MDMP_PROTECT(0x200, NoCache, PAGE_NOCACHE)
+HANDLE_MDMP_PROTECT(0x400, WriteCombine, PAGE_WRITECOMBINE)
+HANDLE_MDMP_PROTECT(0x40000000, TargetsInvalid, PAGE_TARGETS_INVALID)
+
+HANDLE_MDMP_MEMSTATE(0x01000, Commit, MEM_COMMIT)
+HANDLE_MDMP_MEMSTATE(0x02000, Reserve, MEM_RESERVE)
+HANDLE_MDMP_MEMSTATE(0x10000, Free, MEM_FREE)
+
+HANDLE_MDMP_MEMTYPE(0x0020000, Private, MEM_PRIVATE)
+HANDLE_MDMP_MEMTYPE(0x0040000, Mapped, MEM_MAPPED)
+HANDLE_MDMP_MEMTYPE(0x1000000, Image, MEM_IMAGE)
+
 #undef HANDLE_MDMP_STREAM_TYPE
 #undef HANDLE_MDMP_ARCH
 #undef HANDLE_MDMP_PLATFORM
+#undef HANDLE_MDMP_PROTECT
+#undef HANDLE_MDMP_MEMSTATE
+#undef HANDLE_MDMP_MEMTYPE
diff --git a/linux-x64/clang/include/llvm/BinaryFormat/MsgPackDocument.h b/linux-x64/clang/include/llvm/BinaryFormat/MsgPackDocument.h
index 824ecc3..91778f6 100644
--- a/linux-x64/clang/include/llvm/BinaryFormat/MsgPackDocument.h
+++ b/linux-x64/clang/include/llvm/BinaryFormat/MsgPackDocument.h
@@ -62,6 +62,8 @@
   };
 
 public:
+  // Default constructor gives an empty node with no associated Document. All
+  // you can do with it is "isEmpty()".
   DocNode() : KindAndDoc(nullptr) {}
 
   // Type methods
@@ -70,8 +72,10 @@
   bool isScalar() const { return !isMap() && !isArray(); }
   bool isString() const { return getKind() == Type::String; }
 
-  // Accessors
-  bool isEmpty() const { return !KindAndDoc; }
+  // Accessors. isEmpty() returns true for both a default-constructed DocNode
+  // that has no associated Document, and the result of getEmptyNode(), which
+  // does have an associated document.
+  bool isEmpty() const { return !KindAndDoc || getKind() == Type::Empty; }
   Type getKind() const { return KindAndDoc->Kind; }
   Document *getDocument() const { return KindAndDoc->Doc; }
 
@@ -146,10 +150,10 @@
   friend bool operator<(const DocNode &Lhs, const DocNode &Rhs) {
     // This has to cope with one or both of the nodes being default-constructed,
     // such that KindAndDoc is not set.
+    if (Rhs.isEmpty())
+      return false;
     if (Lhs.KindAndDoc != Rhs.KindAndDoc) {
-      if (!Rhs.KindAndDoc)
-        return false;
-      if (!Lhs.KindAndDoc)
+      if (Lhs.isEmpty())
         return true;
       return (unsigned)Lhs.getKind() < (unsigned)Rhs.getKind();
     }
@@ -177,6 +181,11 @@
     return !(Lhs < Rhs) && !(Rhs < Lhs);
   }
 
+  /// Inequality operator
+  friend bool operator!=(const DocNode &Lhs, const DocNode &Rhs) {
+    return !(Lhs == Rhs);
+  }
+
   /// Convert this node to a string, assuming it is scalar.
   std::string toString() const;
 
@@ -185,6 +194,19 @@
   /// not rely on S having a lifetime beyond this call. Tag is "" or a YAML tag.
   StringRef fromString(StringRef S, StringRef Tag = "");
 
+  /// Convenience assignment operators. This only works if the destination
+  /// DocNode has an associated Document, i.e. it was not constructed using the
+  /// default constructor. The string one does not copy, so the string must
+  /// remain valid for the lifetime of the Document. Use fromString to avoid
+  /// that restriction.
+  DocNode &operator=(const char *Val) { return *this = StringRef(Val); }
+  DocNode &operator=(StringRef Val);
+  DocNode &operator=(bool Val);
+  DocNode &operator=(int Val);
+  DocNode &operator=(unsigned Val);
+  DocNode &operator=(int64_t Val);
+  DocNode &operator=(uint64_t Val);
+
 private:
   // Private constructor setting KindAndDoc, used by methods in Document.
   DocNode(const KindAndDocument *KindAndDoc) : KindAndDoc(KindAndDoc) {}
@@ -206,11 +228,21 @@
   MapTy::iterator end() { return Map->end(); }
   MapTy::iterator find(DocNode Key) { return Map->find(Key); }
   MapTy::iterator find(StringRef Key);
+  MapTy::iterator erase(MapTy::const_iterator I) { return Map->erase(I); }
+  size_t erase(DocNode Key) { return Map->erase(Key); }
+  MapTy::iterator erase(MapTy::const_iterator First,
+                        MapTy::const_iterator Second) {
+    return Map->erase(First, Second);
+  }
   /// Member access. The string data must remain valid for the lifetime of the
   /// Document.
   DocNode &operator[](StringRef S);
-  /// Member access.
+  /// Member access, with convenience versions for an integer key.
   DocNode &operator[](DocNode Key);
+  DocNode &operator[](int Key);
+  DocNode &operator[](unsigned Key);
+  DocNode &operator[](int64_t Key);
+  DocNode &operator[](uint64_t Key);
 };
 
 /// A DocNode that is an array.
@@ -222,14 +254,15 @@
   // Array access methods.
   size_t size() const { return Array->size(); }
   bool empty() const { return !size(); }
+  DocNode &back() const { return Array->back(); }
   ArrayTy::iterator begin() { return Array->begin(); }
   ArrayTy::iterator end() { return Array->end(); }
   void push_back(DocNode N) {
-    assert(N.getDocument() == getDocument());
+    assert(N.isEmpty() || N.getDocument() == getDocument());
     Array->push_back(N);
   }
 
-  /// Element access. This extends the array if necessary.
+  /// Element access. This extends the array if necessary, with empty nodes.
   DocNode &operator[](size_t Index);
 };
 
@@ -247,7 +280,7 @@
   DocNode Root;
 
   // The KindAndDocument structs pointed to by nodes in the document.
-  KindAndDocument KindAndDocs[size_t(Type::Extension) + 1];
+  KindAndDocument KindAndDocs[size_t(Type::Empty) + 1];
 
   // Whether YAML output uses hex for UInt.
   bool HexMode = false;
@@ -255,7 +288,7 @@
 public:
   Document() {
     clear();
-    for (unsigned T = 0; T != size_t(Type::Extension) + 1; ++T)
+    for (unsigned T = 0; T != unsigned(Type::Empty) + 1; ++T)
       KindAndDocs[T] = {this, Type(T)};
   }
 
@@ -263,7 +296,13 @@
   DocNode &getRoot() { return Root; }
 
   /// Restore the Document to an empty state.
-  void clear() { getRoot() = getNode(); }
+  void clear() { getRoot() = getEmptyNode(); }
+
+  /// Create an empty node associated with this Document.
+  DocNode getEmptyNode() {
+    auto N = DocNode(&KindAndDocs[size_t(Type::Empty)]);
+    return N;
+  }
 
   /// Create a nil node associated with this Document.
   DocNode getNode() {
@@ -345,15 +384,35 @@
     return N.getArray();
   }
 
-  /// Read a MsgPack document from a binary MsgPack blob.
-  /// The blob data must remain valid for the lifetime of this Document (because
-  /// a string object in the document contains a StringRef into the original
-  /// blob).
-  /// If Multi, then this sets root to an array and adds top-level objects to
-  /// it. If !Multi, then it only reads a single top-level object, even if there
-  /// are more, and sets root to that.
-  /// Returns false if failed due to illegal format.
-  bool readFromBlob(StringRef Blob, bool Multi);
+  /// Read a document from a binary msgpack blob, merging into anything already
+  /// in the Document. The blob data must remain valid for the lifetime of this
+  /// Document (because a string object in the document contains a StringRef
+  /// into the original blob). If Multi, then this sets root to an array and
+  /// adds top-level objects to it. If !Multi, then it only reads a single
+  /// top-level object, even if there are more, and sets root to that. Returns
+  /// false if failed due to illegal format or merge error.
+  ///
+  /// The Merger arg is a callback function that is called when the merge has a
+  /// conflict, that is, it is trying to set an item that is already set. If the
+  /// conflict cannot be resolved, the callback function returns -1. If the
+  /// conflict can be resolved, the callback returns a non-negative number and
+  /// sets *DestNode to the resolved node. The returned non-negative number is
+  /// significant only for an array node; it is then the array index to start
+  /// populating at. That allows Merger to choose whether to merge array
+  /// elements (returns 0) or append new elements (returns existing size).
+  ///
+  /// If SrcNode is an array or map, the resolution must be that *DestNode is an
+  /// array or map respectively, although it could be the array or map
+  /// (respectively) that was already there. MapKey is the key if *DestNode is a
+  /// map entry, a nil node otherwise.
+  ///
+  /// The default for Merger is to disallow any conflict.
+  bool readFromBlob(
+      StringRef Blob, bool Multi,
+      function_ref<int(DocNode *DestNode, DocNode SrcNode, DocNode MapKey)>
+          Merger = [](DocNode *DestNode, DocNode SrcNode, DocNode MapKey) {
+            return -1;
+          });
 
   /// Write a MsgPack document to a binary MsgPack blob.
   void writeToBlob(std::string &Blob);
diff --git a/linux-x64/clang/include/llvm/BinaryFormat/MsgPackReader.h b/linux-x64/clang/include/llvm/BinaryFormat/MsgPackReader.h
index 2d332f5..a6ae542 100644
--- a/linux-x64/clang/include/llvm/BinaryFormat/MsgPackReader.h
+++ b/linux-x64/clang/include/llvm/BinaryFormat/MsgPackReader.h
@@ -33,6 +33,7 @@
 #ifndef LLVM_SUPPORT_MSGPACKREADER_H
 #define LLVM_SUPPORT_MSGPACKREADER_H
 
+#include "llvm/Support/Error.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cstdint>
@@ -56,6 +57,7 @@
   Array,
   Map,
   Extension,
+  Empty, // Used by MsgPackDocument to represent an empty node
 };
 
 /// Extension types are composed of a user-defined type ID and an uninterpreted
diff --git a/linux-x64/clang/include/llvm/BinaryFormat/Wasm.h b/linux-x64/clang/include/llvm/BinaryFormat/Wasm.h
index 0ff52cb..bdef959 100644
--- a/linux-x64/clang/include/llvm/BinaryFormat/Wasm.h
+++ b/linux-x64/clang/include/llvm/BinaryFormat/Wasm.h
@@ -15,7 +15,9 @@
 #define LLVM_BINARYFORMAT_WASM_H
 
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringRef.h"
 
 namespace llvm {
 namespace wasm {
@@ -39,7 +41,7 @@
   uint32_t MemoryAlignment;  // P2 alignment of memory
   uint32_t TableSize;  // Table size in elements
   uint32_t TableAlignment;  // P2 alignment of table
-  std::vector<StringRef> Needed; // Shared library depenedencies
+  std::vector<StringRef> Needed; // Shared library dependencies
 };
 
 struct WasmProducerInfo {
@@ -61,13 +63,19 @@
 
 struct WasmLimits {
   uint8_t Flags;
-  uint32_t Initial;
-  uint32_t Maximum;
+  uint64_t Initial;
+  uint64_t Maximum;
+};
+
+struct WasmTableType {
+  uint8_t ElemType;
+  WasmLimits Limits;
 };
 
 struct WasmTable {
-  uint8_t ElemType;
-  WasmLimits Limits;
+  uint32_t Index;
+  WasmTableType Type;
+  StringRef SymbolName; // from the "linking" section
 };
 
 struct WasmInitExpr {
@@ -75,8 +83,8 @@
   union {
     int32_t Int32;
     int64_t Int64;
-    int32_t Float32;
-    int64_t Float64;
+    uint32_t Float32;
+    uint64_t Float64;
     uint32_t Global;
   } Value;
 };
@@ -112,7 +120,7 @@
   union {
     uint32_t SigIndex;
     WasmGlobalType Global;
-    WasmTable Table;
+    WasmTableType Table;
     WasmLimits Memory;
     WasmEventType Event;
   };
@@ -130,6 +138,7 @@
   uint32_t CodeSectionOffset;
   uint32_t Size;
   uint32_t CodeOffset;  // start of Locals and Body
+  Optional<StringRef> ExportName; // from the "export" section
   StringRef SymbolName; // from the "linking" section
   StringRef DebugName;  // from the "name" section
   uint32_t Comdat;      // from the "comdat info" section
@@ -156,8 +165,8 @@
 // the index of the segment, and the offset and size within the segment.
 struct WasmDataReference {
   uint32_t Segment;
-  uint32_t Offset;
-  uint32_t Size;
+  uint64_t Offset;
+  uint64_t Size;
 };
 
 struct WasmRelocation {
@@ -176,18 +185,29 @@
   StringRef Name;
   uint8_t Kind;
   uint32_t Flags;
-  StringRef ImportModule; // For undefined symbols the module of the import
-  StringRef ImportName;   // For undefined symbols the name of the import
+  // For undefined symbols the module of the import
+  Optional<StringRef> ImportModule;
+  // For undefined symbols the name of the import
+  Optional<StringRef> ImportName;
+  // For symbols to be exported from the final module
+  Optional<StringRef> ExportName;
   union {
-    // For function or global symbols, the index in function or global index
-    // space.
+    // For function, table, or global symbols, the index in function, table, or
+    // global index space.
     uint32_t ElementIndex;
     // For a data symbols, the address of the data relative to segment.
     WasmDataReference DataRef;
   };
 };
 
-struct WasmFunctionName {
+enum class NameType {
+  FUNCTION,
+  GLOBAL,
+  DATA_SEGMENT,
+};
+
+struct WasmDebugName {
+  NameType Type;
   uint32_t Index;
   StringRef Name;
 };
@@ -224,7 +244,7 @@
   WASM_TYPE_F64 = 0x7C,
   WASM_TYPE_V128 = 0x7B,
   WASM_TYPE_FUNCREF = 0x70,
-  WASM_TYPE_EXCEPT_REF = 0x68,
+  WASM_TYPE_EXTERNREF = 0x6F,
   WASM_TYPE_FUNC = 0x60,
   WASM_TYPE_NORESULT = 0x40, // for blocks with no result values
 };
@@ -242,21 +262,41 @@
 enum : unsigned {
   WASM_OPCODE_END = 0x0b,
   WASM_OPCODE_CALL = 0x10,
+  WASM_OPCODE_LOCAL_GET = 0x20,
+  WASM_OPCODE_LOCAL_SET = 0x21,
   WASM_OPCODE_GLOBAL_GET = 0x23,
+  WASM_OPCODE_GLOBAL_SET = 0x24,
   WASM_OPCODE_I32_STORE = 0x36,
+  WASM_OPCODE_I64_STORE = 0x37,
   WASM_OPCODE_I32_CONST = 0x41,
   WASM_OPCODE_I64_CONST = 0x42,
   WASM_OPCODE_F32_CONST = 0x43,
   WASM_OPCODE_F64_CONST = 0x44,
   WASM_OPCODE_I32_ADD = 0x6a,
+  WASM_OPCODE_I64_ADD = 0x7c,
+  WASM_OPCODE_REF_NULL = 0xd0,
+};
+
+// Opcodes used in synthetic functions.
+enum : unsigned {
+  WASM_OPCODE_IF = 0x04,
+  WASM_OPCODE_ELSE = 0x05,
+  WASM_OPCODE_DROP = 0x1a,
   WASM_OPCODE_MISC_PREFIX = 0xfc,
   WASM_OPCODE_MEMORY_INIT = 0x08,
   WASM_OPCODE_DATA_DROP = 0x09,
+  WASM_OPCODE_ATOMICS_PREFIX = 0xfe,
+  WASM_OPCODE_ATOMIC_NOTIFY = 0x00,
+  WASM_OPCODE_I32_ATOMIC_WAIT = 0x01,
+  WASM_OPCODE_I32_ATOMIC_STORE = 0x17,
+  WASM_OPCODE_I32_RMW_CMPXCHG = 0x48,
 };
 
 enum : unsigned {
+  WASM_LIMITS_FLAG_NONE = 0x0,
   WASM_LIMITS_FLAG_HAS_MAX = 0x1,
   WASM_LIMITS_FLAG_IS_SHARED = 0x2,
+  WASM_LIMITS_FLAG_IS_64 = 0x4,
 };
 
 enum : unsigned {
@@ -273,8 +313,10 @@
 
 // Kind codes used in the custom "name" section
 enum : unsigned {
-  WASM_NAMES_FUNCTION = 0x1,
-  WASM_NAMES_LOCAL = 0x2,
+  WASM_NAMES_FUNCTION = 1,
+  WASM_NAMES_LOCAL = 2,
+  WASM_NAMES_GLOBAL = 7,
+  WASM_NAMES_DATA_SEGMENT = 9,
 };
 
 // Kind codes used in the custom "linking" section
@@ -289,6 +331,8 @@
 enum : unsigned {
   WASM_COMDAT_DATA = 0x0,
   WASM_COMDAT_FUNCTION = 0x1,
+  // GLOBAL, EVENT, and TABLE are in here but LLVM doesn't use them yet.
+  WASM_COMDAT_SECTION = 0x5,
 };
 
 // Kind codes used in the custom "linking" section in the WASM_SYMBOL_TABLE
@@ -298,6 +342,7 @@
   WASM_SYMBOL_TYPE_GLOBAL = 0x2,
   WASM_SYMBOL_TYPE_SECTION = 0x3,
   WASM_SYMBOL_TYPE_EVENT = 0x4,
+  WASM_SYMBOL_TYPE_TABLE = 0x5,
 };
 
 // Kinds of event attributes.
@@ -316,6 +361,7 @@
 const unsigned WASM_SYMBOL_UNDEFINED = 0x10;
 const unsigned WASM_SYMBOL_EXPORTED = 0x20;
 const unsigned WASM_SYMBOL_EXPLICIT_NAME = 0x40;
+const unsigned WASM_SYMBOL_NO_STRIP = 0x80;
 
 #define WASM_RELOC(name, value) name = value,
 
@@ -332,7 +378,8 @@
   F32 = WASM_TYPE_F32,
   F64 = WASM_TYPE_F64,
   V128 = WASM_TYPE_V128,
-  EXCEPT_REF = WASM_TYPE_EXCEPT_REF,
+  FUNCREF = WASM_TYPE_FUNCREF,
+  EXTERNREF = WASM_TYPE_EXTERNREF,
 };
 
 struct WasmSignature {
diff --git a/linux-x64/clang/include/llvm/BinaryFormat/WasmRelocs.def b/linux-x64/clang/include/llvm/BinaryFormat/WasmRelocs.def
index 00dacf7..dca63ec 100644
--- a/linux-x64/clang/include/llvm/BinaryFormat/WasmRelocs.def
+++ b/linux-x64/clang/include/llvm/BinaryFormat/WasmRelocs.def
@@ -2,16 +2,26 @@
 #error "WASM_RELOC must be defined"
 #endif
 
-WASM_RELOC(R_WASM_FUNCTION_INDEX_LEB,    0)
-WASM_RELOC(R_WASM_TABLE_INDEX_SLEB,      1)
-WASM_RELOC(R_WASM_TABLE_INDEX_I32,       2)
-WASM_RELOC(R_WASM_MEMORY_ADDR_LEB,       3)
-WASM_RELOC(R_WASM_MEMORY_ADDR_SLEB,      4)
-WASM_RELOC(R_WASM_MEMORY_ADDR_I32,       5)
-WASM_RELOC(R_WASM_TYPE_INDEX_LEB,        6)
-WASM_RELOC(R_WASM_GLOBAL_INDEX_LEB,      7)
-WASM_RELOC(R_WASM_FUNCTION_OFFSET_I32,   8)
-WASM_RELOC(R_WASM_SECTION_OFFSET_I32,    9)
-WASM_RELOC(R_WASM_EVENT_INDEX_LEB,      10)
-WASM_RELOC(R_WASM_MEMORY_ADDR_REL_SLEB, 11)
-WASM_RELOC(R_WASM_TABLE_INDEX_REL_SLEB, 12)
+WASM_RELOC(R_WASM_FUNCTION_INDEX_LEB,      0)
+WASM_RELOC(R_WASM_TABLE_INDEX_SLEB,        1)
+WASM_RELOC(R_WASM_TABLE_INDEX_I32,         2)
+WASM_RELOC(R_WASM_MEMORY_ADDR_LEB,         3)
+WASM_RELOC(R_WASM_MEMORY_ADDR_SLEB,        4)
+WASM_RELOC(R_WASM_MEMORY_ADDR_I32,         5)
+WASM_RELOC(R_WASM_TYPE_INDEX_LEB,          6)
+WASM_RELOC(R_WASM_GLOBAL_INDEX_LEB,        7)
+WASM_RELOC(R_WASM_FUNCTION_OFFSET_I32,     8)
+WASM_RELOC(R_WASM_SECTION_OFFSET_I32,      9)
+WASM_RELOC(R_WASM_EVENT_INDEX_LEB,        10)
+WASM_RELOC(R_WASM_MEMORY_ADDR_REL_SLEB,   11)
+WASM_RELOC(R_WASM_TABLE_INDEX_REL_SLEB,   12)
+WASM_RELOC(R_WASM_GLOBAL_INDEX_I32,       13)
+WASM_RELOC(R_WASM_MEMORY_ADDR_LEB64,      14)
+WASM_RELOC(R_WASM_MEMORY_ADDR_SLEB64,     15)
+WASM_RELOC(R_WASM_MEMORY_ADDR_I64,        16)
+WASM_RELOC(R_WASM_MEMORY_ADDR_REL_SLEB64, 17)
+WASM_RELOC(R_WASM_TABLE_INDEX_SLEB64,     18)
+WASM_RELOC(R_WASM_TABLE_INDEX_I64,        19)
+WASM_RELOC(R_WASM_TABLE_NUMBER_LEB,       20)
+WASM_RELOC(R_WASM_MEMORY_ADDR_TLS_SLEB,   21)
+WASM_RELOC(R_WASM_FUNCTION_OFFSET_I64,    22)
diff --git a/linux-x64/clang/include/llvm/Object/WasmTraits.h b/linux-x64/clang/include/llvm/BinaryFormat/WasmTraits.h
similarity index 94%
rename from linux-x64/clang/include/llvm/Object/WasmTraits.h
rename to linux-x64/clang/include/llvm/BinaryFormat/WasmTraits.h
index 3eee8e7..e341824 100644
--- a/linux-x64/clang/include/llvm/Object/WasmTraits.h
+++ b/linux-x64/clang/include/llvm/BinaryFormat/WasmTraits.h
@@ -10,8 +10,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_OBJECT_WASMTRAITS_H
-#define LLVM_OBJECT_WASMTRAITS_H
+#ifndef LLVM_BINARYFORMAT_WASMTRAITS_H
+#define LLVM_BINARYFORMAT_WASMTRAITS_H
 
 #include "llvm/ADT/Hashing.h"
 #include "llvm/BinaryFormat/Wasm.h"
@@ -65,4 +65,4 @@
 
 } // end namespace llvm
 
-#endif // LLVM_OBJECT_WASMTRAITS_H
+#endif // LLVM_BINARYFORMAT_WASMTRAITS_H
diff --git a/linux-x64/clang/include/llvm/BinaryFormat/XCOFF.h b/linux-x64/clang/include/llvm/BinaryFormat/XCOFF.h
index 7774ab3..48e1baf 100644
--- a/linux-x64/clang/include/llvm/BinaryFormat/XCOFF.h
+++ b/linux-x64/clang/include/llvm/BinaryFormat/XCOFF.h
@@ -13,18 +13,29 @@
 #ifndef LLVM_BINARYFORMAT_XCOFF_H
 #define LLVM_BINARYFORMAT_XCOFF_H
 
-#include <cstdint>
+#include <stddef.h>
+#include <stdint.h>
 
 namespace llvm {
+class StringRef;
+template <unsigned> class SmallString;
+
 namespace XCOFF {
 
 // Constants used in the XCOFF definition.
-enum { SectionNameSize = 8, SymbolNameSize = 8 };
-enum ReservedSectionNum { N_DEBUG = -2, N_ABS = -1, N_UNDEF = 0 };
+
+constexpr size_t FileNamePadSize = 6;
+constexpr size_t NameSize = 8;
+constexpr size_t SymbolTableEntrySize = 18;
+constexpr size_t RelocationSerializationSize32 = 10;
+constexpr uint16_t RelocOverflow = 65535;
+constexpr uint8_t AllocRegNo = 31;
+
+enum ReservedSectionNum : int16_t { N_DEBUG = -2, N_ABS = -1, N_UNDEF = 0 };
 
 // x_smclas field of x_csect from system header: /usr/include/syms.h
 /// Storage Mapping Class definitions.
-enum StorageMappingClass {
+enum StorageMappingClass : uint8_t {
   //     READ ONLY CLASSES
   XMC_PR = 0,      ///< Program Code
   XMC_RO = 1,      ///< Read Only Constant
@@ -52,9 +63,10 @@
   XMC_TE = 22  ///< Symbol mapped at the end of TOC
 };
 
-// Flags for defining the section type. Used for the s_flags field of
-// the section header structure. Defined in the system header `scnhdr.h`.
-enum SectionTypeFlags {
+// Flags for defining the section type. Masks for use with the (signed, 32-bit)
+// s_flags field of the section header structure, selecting for values in the
+// lower 16 bits. Defined in the system header `scnhdr.h`.
+enum SectionTypeFlags : int32_t {
   STYP_PAD = 0x0008,
   STYP_DWARF = 0x0010,
   STYP_TEXT = 0x0020,
@@ -70,6 +82,24 @@
   STYP_OVRFLO = 0x8000
 };
 
+/// Values for defining the section subtype of sections of type STYP_DWARF as
+/// they would appear in the (signed, 32-bit) s_flags field of the section
+/// header structure, contributing to the 16 most significant bits. Defined in
+/// the system header `scnhdr.h`.
+enum DwarfSectionSubtypeFlags : int32_t {
+  SSUBTYP_DWINFO = 0x1'0000,  ///< DWARF info section
+  SSUBTYP_DWLINE = 0x2'0000,  ///< DWARF line section
+  SSUBTYP_DWPBNMS = 0x3'0000, ///< DWARF pubnames section
+  SSUBTYP_DWPBTYP = 0x4'0000, ///< DWARF pubtypes section
+  SSUBTYP_DWARNGE = 0x5'0000, ///< DWARF aranges section
+  SSUBTYP_DWABREV = 0x6'0000, ///< DWARF abbrev section
+  SSUBTYP_DWSTR = 0x7'0000,   ///< DWARF str section
+  SSUBTYP_DWRNGES = 0x8'0000, ///< DWARF ranges section
+  SSUBTYP_DWLOC = 0x9'0000,   ///< DWARF loc section
+  SSUBTYP_DWFRAME = 0xA'0000, ///< DWARF frame section
+  SSUBTYP_DWMAC = 0xB'0000    ///< DWARF macinfo section
+};
+
 // STORAGE CLASSES, n_sclass field of syment.
 // The values come from `storclass.h` and `dbxstclass.h`.
 enum StorageClass : uint8_t {
@@ -139,6 +169,243 @@
   C_TCSYM = 134 // Reserved
 };
 
+// Flags for defining the symbol type. Values to be encoded into the lower 3
+// bits of the (unsigned, 8-bit) x_smtyp field of csect auxiliary symbol table
+// entries. Defined in the system header `syms.h`.
+enum SymbolType : uint8_t {
+  XTY_ER = 0, ///< External reference.
+  XTY_SD = 1, ///< Csect definition for initialized storage.
+  XTY_LD = 2, ///< Label definition.
+              ///< Defines an entry point to an initialized csect.
+  XTY_CM = 3  ///< Common csect definition. For uninitialized storage.
+};
+
+/// Values for visibility as they would appear when encoded in the high 4 bits
+/// of the 16-bit unsigned n_type field of symbol table entries. Valid for
+/// 32-bit XCOFF only when the vstamp in the auxiliary header is greater than 1.
+enum VisibilityType : uint16_t {
+  SYM_V_UNSPECIFIED = 0x0000,
+  SYM_V_INTERNAL = 0x1000,
+  SYM_V_HIDDEN = 0x2000,
+  SYM_V_PROTECTED = 0x3000,
+  SYM_V_EXPORTED = 0x4000
+};
+
+// Relocation types, defined in `/usr/include/reloc.h`.
+enum RelocationType : uint8_t {
+  R_POS = 0x00, ///< Positive relocation. Provides the address of the referenced
+                ///< symbol.
+  R_RL = 0x0c,  ///< Positive indirect load relocation. Modifiable instruction.
+  R_RLA = 0x0d, ///< Positive load address relocation. Modifiable instruction.
+
+  R_NEG = 0x01, ///< Negative relocation. Provides the negative of the address
+                ///< of the referenced symbol.
+  R_REL = 0x02, ///< Relative to self relocation. Provides a displacement value
+                ///< between the address of the referenced symbol and the
+                ///< address being relocated.
+
+  R_TOC = 0x03, ///< Relative to the TOC relocation. Provides a displacement
+                ///< that is the difference between the address of the
+                ///< referenced symbol and the TOC anchor csect.
+  R_TRL = 0x12, ///< TOC relative indirect load relocation. Similar to R_TOC,
+                ///< but not modifiable instruction.
+
+  R_TRLA =
+      0x13, ///< Relative to the TOC or to the thread-local storage base
+            ///< relocation. Compilers are not permitted to generate this
+            ///< relocation type. It is the result of a reversible
+            ///< transformation by the linker of an R_TOC relation that turned a
+            ///< load instruction into an add-immediate instruction.
+
+  R_GL = 0x05, ///< Global linkage-external TOC address relocation. Provides the
+               ///< address of the external TOC associated with a defined
+               ///< external symbol.
+  R_TCL = 0x06, ///< Local object TOC address relocation. Provides the address
+                ///< of the local TOC entry of a defined external symbol.
+
+  R_REF = 0x0f, ///< A non-relocating relocation. Used to prevent the binder
+                ///< from garbage collecting a csect (such as code used for
+                ///< dynamic initialization of non-local statics) for which
+                ///< another csect has an implicit dependency.
+
+  R_BA = 0x08, ///< Branch absolute relocation. Provides the address of the
+               ///< referenced symbol. References a non-modifiable instruction.
+  R_BR = 0x0a, ///< Branch relative to self relocation. Provides the
+               ///< displacement that is the difference between the address of
+               ///< the referenced symbol and the address of the referenced
+               ///< branch instruction. References a non-modifiable instruction.
+  R_RBA = 0x18, ///< Branch absolute relocation. Similar to R_BA but
+                ///< references a modifiable instruction.
+  R_RBR = 0x1a, ///< Branch relative to self relocation. Similar to the R_BR
+                ///< relocation type, but references a modifiable instruction.
+
+  R_TLS = 0x20,    ///< General-dynamic reference to TLS symbol.
+  R_TLS_IE = 0x21, ///< Initial-exec reference to TLS symbol.
+  R_TLS_LD = 0x22, ///< Local-dynamic reference to TLS symbol.
+  R_TLS_LE = 0x23, ///< Local-exec reference to TLS symbol.
+  R_TLSM = 0x24,  ///< Module reference to TLS. Provides a handle for the module
+                  ///< containing the referenced symbol.
+  R_TLSML = 0x25, ///< Module reference to the local TLS storage.
+
+  R_TOCU = 0x30, ///< Relative to TOC upper. Specifies the high-order 16 bits of
+                 ///< a large code model TOC-relative relocation.
+  R_TOCL = 0x31 ///< Relative to TOC lower. Specifies the low-order 16 bits of a
+                ///< large code model TOC-relative relocation.
+};
+
+struct FileHeader32 {
+  uint16_t Magic;
+  uint16_t NumberOfSections;
+  int32_t TimeStamp;
+  uint32_t SymbolTableFileOffset;
+  int32_t NumberOfSymbolTableEntries;
+  uint16_t AuxiliaryHeaderSize;
+  uint16_t Flags;
+};
+
+struct SectionHeader32 {
+  char Name[XCOFF::NameSize];
+  uint32_t PhysicalAddress;
+  uint32_t VirtualAddress;
+  uint32_t Size;
+  uint32_t FileOffsetToData;
+  uint32_t FileOffsetToRelocations;
+  uint32_t FileOffsetToLineNumbers;
+  uint16_t NumberOfRelocations;
+  uint16_t NumberOfLineNumbers;
+  int32_t Flags;
+};
+
+enum CFileStringType : uint8_t {
+  XFT_FN = 0,  ///< Specifies the source-file name.
+  XFT_CT = 1,  ///< Specifies the compiler time stamp.
+  XFT_CV = 2,  ///< Specifies the compiler version number.
+  XFT_CD = 128 ///< Specifies compiler-defined information.
+};
+
+enum CFileLangId : uint8_t {
+  TB_C = 0,        ///< C language.
+  TB_CPLUSPLUS = 9 ///< C++ language.
+};
+
+enum CFileCpuId : uint8_t {
+  TCPU_PPC64 = 2, ///< PowerPC common architecture 64-bit mode.
+  TCPU_COM = 3,   ///< POWER and PowerPC architecture common.
+  TCPU_970 = 19   ///< PPC970 - PowerPC 64-bit architecture.
+};
+
+StringRef getMappingClassString(XCOFF::StorageMappingClass SMC);
+StringRef getRelocationTypeString(XCOFF::RelocationType Type);
+SmallString<32> parseParmsType(uint32_t Value, unsigned ParmsNum);
+
+struct TracebackTable {
+  enum LanguageID : uint8_t {
+    C,
+    Fortran,
+    Pascal,
+    Ada,
+    PL1,
+    Basic,
+    Lisp,
+    Cobol,
+    Modula2,
+    CPlusPlus,
+    Rpg,
+    PL8,
+    PLIX = PL8,
+    Assembly,
+    Java,
+    ObjectiveC
+  };
+  // Byte 1
+  static constexpr uint32_t VersionMask = 0xFF00'0000;
+  static constexpr uint8_t VersionShift = 24;
+
+  // Byte 2
+  static constexpr uint32_t LanguageIdMask = 0x00FF'0000;
+  static constexpr uint8_t LanguageIdShift = 16;
+
+  // Byte 3
+  static constexpr uint32_t IsGlobaLinkageMask = 0x0000'8000;
+  static constexpr uint32_t IsOutOfLineEpilogOrPrologueMask = 0x0000'4000;
+  static constexpr uint32_t HasTraceBackTableOffsetMask = 0x0000'2000;
+  static constexpr uint32_t IsInternalProcedureMask = 0x0000'1000;
+  static constexpr uint32_t HasControlledStorageMask = 0x0000'0800;
+  static constexpr uint32_t IsTOClessMask = 0x0000'0400;
+  static constexpr uint32_t IsFloatingPointPresentMask = 0x0000'0200;
+  static constexpr uint32_t IsFloatingPointOperationLogOrAbortEnabledMask =
+      0x0000'0100;
+
+  // Byte 4
+  static constexpr uint32_t IsInterruptHandlerMask = 0x0000'0080;
+  static constexpr uint32_t IsFunctionNamePresentMask = 0x0000'0040;
+  static constexpr uint32_t IsAllocaUsedMask = 0x0000'0020;
+  static constexpr uint32_t OnConditionDirectiveMask = 0x0000'001C;
+  static constexpr uint32_t IsCRSavedMask = 0x0000'0002;
+  static constexpr uint32_t IsLRSavedMask = 0x0000'0001;
+  static constexpr uint8_t OnConditionDirectiveShift = 2;
+
+  // Byte 5
+  static constexpr uint32_t IsBackChainStoredMask = 0x8000'0000;
+  static constexpr uint32_t IsFixupMask = 0x4000'0000;
+  static constexpr uint32_t FPRSavedMask = 0x3F00'0000;
+  static constexpr uint32_t FPRSavedShift = 24;
+
+  // Byte 6
+  static constexpr uint32_t HasVectorInfoMask = 0x0080'0000;
+  static constexpr uint32_t HasExtensionTableMask = 0x0040'0000;
+  static constexpr uint32_t GPRSavedMask = 0x003F'0000;
+  static constexpr uint32_t GPRSavedShift = 16;
+
+  // Byte 7
+  static constexpr uint32_t NumberOfFixedParmsMask = 0x0000'FF00;
+  static constexpr uint8_t NumberOfFixedParmsShift = 8;
+
+  // Byte 8
+  static constexpr uint32_t NumberOfFloatingPointParmsMask = 0x0000'00FE;
+  static constexpr uint32_t HasParmsOnStackMask = 0x0000'0001;
+  static constexpr uint8_t NumberOfFloatingPointParmsShift = 1;
+
+  // Masks to select leftmost bits for decoding parameter type information.
+  // Bit to use when vector info is not presented.
+  static constexpr uint32_t ParmTypeIsFloatingBit = 0x8000'0000;
+  static constexpr uint32_t ParmTypeFloatingIsDoubleBit = 0x4000'0000;
+  // Bits to use when vector info is presented.
+  static constexpr uint32_t ParmTypeIsFixedBits = 0x0000'0000;
+  static constexpr uint32_t ParmTypeIsVectorBits = 0x4000'0000;
+  static constexpr uint32_t ParmTypeIsFloatingBits = 0x8000'0000;
+  static constexpr uint32_t ParmTypeIsDoubleBits = 0xC000'0000;
+  static constexpr uint32_t ParmTypeMask = 0xC000'0000;
+
+  // Vector extension
+  static constexpr uint16_t NumberOfVRSavedMask = 0xFC00;
+  static constexpr uint16_t IsVRSavedOnStackMask = 0x0200;
+  static constexpr uint16_t HasVarArgsMask = 0x0100;
+  static constexpr uint8_t NumberOfVRSavedShift = 10;
+
+  static constexpr uint16_t NumberOfVectorParmsMask = 0x00FE;
+  static constexpr uint16_t HasVMXInstructionMask = 0x0001;
+  static constexpr uint8_t NumberOfVectorParmsShift = 1;
+
+  static constexpr uint32_t ParmTypeIsVectorCharBit = 0x0000'0000;
+  static constexpr uint32_t ParmTypeIsVectorShortBit = 0x4000'0000;
+  static constexpr uint32_t ParmTypeIsVectorIntBit = 0x8000'0000;
+  static constexpr uint32_t ParmTypeIsVectorFloatBit = 0xC000'0000;
+};
+
+// Extended Traceback table flags.
+enum ExtendedTBTableFlag : uint8_t {
+  TB_OS1 = 0x80,         ///< Reserved for OS use.
+  TB_RESERVED = 0x40,    ///< Reserved for compiler.
+  TB_SSP_CANARY = 0x20,  ///< stack smasher canary present on stack.
+  TB_OS2 = 0x10,         ///< Reserved for OS use.
+  TB_EH_INFO = 0x08,     ///< Exception handling info present.
+  TB_LONGTBTABLE2 = 0x01 ///< Additional tbtable extension exists.
+};
+
+StringRef getNameForTracebackTableLanguageId(TracebackTable::LanguageID LangId);
+SmallString<32> getExtendedTBTableFlagString(uint8_t Flag);
+
 } // end namespace XCOFF
 } // end namespace llvm
 
diff --git a/linux-x64/clang/include/llvm/Bitcode/BitcodeAnalyzer.h b/linux-x64/clang/include/llvm/Bitcode/BitcodeAnalyzer.h
index cfdebd6..5fb8bb2 100644
--- a/linux-x64/clang/include/llvm/Bitcode/BitcodeAnalyzer.h
+++ b/linux-x64/clang/include/llvm/Bitcode/BitcodeAnalyzer.h
@@ -30,6 +30,7 @@
   LLVMIRBitstream,
   ClangSerializedASTBitstream,
   ClangSerializedDiagnosticsBitstream,
+  LLVMBitstreamRemarks
 };
 
 struct BCDumpOptions {
diff --git a/linux-x64/clang/include/llvm/Bitcode/BitcodeCommon.h b/linux-x64/clang/include/llvm/Bitcode/BitcodeCommon.h
new file mode 100644
index 0000000..6a3e745
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Bitcode/BitcodeCommon.h
@@ -0,0 +1,30 @@
+//===- BitcodeCommon.h - Common code for encode/decode   --------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This header defines common code to be used by BitcodeWriter and
+// BitcodeReader.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_BITCODE_BITCODECOMMON_H
+#define LLVM_BITCODE_BITCODECOMMON_H
+
+#include "llvm/ADT/Bitfields.h"
+
+namespace llvm {
+
+struct AllocaPackedValues {
+  using Align = Bitfield::Element<unsigned, 0, 5>;
+  using UsedWithInAlloca = Bitfield::Element<bool, Align::NextBit, 1>;
+  using ExplicitType = Bitfield::Element<bool, UsedWithInAlloca::NextBit, 1>;
+  using SwiftError = Bitfield::Element<bool, ExplicitType::NextBit, 1>;
+};
+
+} // namespace llvm
+
+#endif // LLVM_BITCODE_BITCODECOMMON_H
diff --git a/linux-x64/clang/include/llvm/Bitcode/BitcodeConvenience.h b/linux-x64/clang/include/llvm/Bitcode/BitcodeConvenience.h
new file mode 100644
index 0000000..0060d01
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Bitcode/BitcodeConvenience.h
@@ -0,0 +1,486 @@
+//===- llvm/Bitcode/BitcodeConvenience.h - Convenience Wrappers -*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file Convenience wrappers for the LLVM bitcode format and bitstream APIs.
+///
+/// This allows you to use a sort of DSL to declare and use bitcode
+/// abbreviations and records. Example:
+///
+/// \code
+///     using Metadata = BCRecordLayout<
+///       METADATA_ID,  // ID
+///       BCFixed<16>,  // Module format major version
+///       BCFixed<16>,  // Module format minor version
+///       BCBlob        // misc. version information
+///     >;
+///     Metadata metadata(Out);
+///     metadata.emit(ScratchRecord, VERSION_MAJOR, VERSION_MINOR, Data);
+/// \endcode
+///
+/// For details on the bitcode format, see
+///   http://llvm.org/docs/BitCodeFormat.html
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_BITCODE_BITCODECONVENIENCE_H
+#define LLVM_BITCODE_BITCODECONVENIENCE_H
+
+#include "llvm/Bitstream/BitCodes.h"
+#include "llvm/Bitstream/BitstreamWriter.h"
+#include <cstdint>
+
+namespace llvm {
+namespace detail {
+/// Convenience base for all kinds of bitcode abbreviation fields.
+///
+/// This just defines common properties queried by the metaprogramming.
+template <bool Compound = false> class BCField {
+public:
+  static const bool IsCompound = Compound;
+
+  /// Asserts that the given data is a valid value for this field.
+  template <typename T> static void assertValid(const T &data) {}
+
+  /// Converts a raw numeric representation of this value to its preferred
+  /// type.
+  template <typename T> static T convert(T rawValue) { return rawValue; }
+};
+} // namespace detail
+
+/// Represents a literal operand in a bitcode record.
+///
+/// The value of a literal operand is the same for all instances of the record,
+/// so it is only emitted in the abbreviation definition.
+///
+/// Note that because this uses a compile-time template, you cannot have a
+/// literal operand that is fixed at run-time without dropping down to the
+/// raw LLVM APIs.
+template <uint64_t Value> class BCLiteral : public detail::BCField<> {
+public:
+  static void emitOp(llvm::BitCodeAbbrev &abbrev) {
+    abbrev.Add(llvm::BitCodeAbbrevOp(Value));
+  }
+
+  template <typename T> static void assertValid(const T &data) {
+    assert(data == Value && "data value does not match declared literal value");
+  }
+};
+
+/// Represents a fixed-width value in a bitcode record.
+///
+/// Note that the LLVM bitcode format only supports unsigned values.
+template <unsigned Width> class BCFixed : public detail::BCField<> {
+public:
+  static_assert(Width <= 64, "fixed-width field is too large");
+
+  static void emitOp(llvm::BitCodeAbbrev &abbrev) {
+    abbrev.Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Fixed, Width));
+  }
+
+  static void assertValid(const bool &data) {
+    assert(llvm::isUInt<Width>(data) &&
+           "data value does not fit in the given bit width");
+  }
+
+  template <typename T> static void assertValid(const T &data) {
+    assert(data >= 0 && "cannot encode signed integers");
+    assert(llvm::isUInt<Width>(data) &&
+           "data value does not fit in the given bit width");
+  }
+};
+
+/// Represents a variable-width value in a bitcode record.
+///
+/// The \p Width parameter should include the continuation bit.
+///
+/// Note that the LLVM bitcode format only supports unsigned values.
+template <unsigned Width> class BCVBR : public detail::BCField<> {
+  static_assert(Width >= 2, "width does not have room for continuation bit");
+
+public:
+  static void emitOp(llvm::BitCodeAbbrev &abbrev) {
+    abbrev.Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::VBR, Width));
+  }
+
+  template <typename T> static void assertValid(const T &data) {
+    assert(data >= 0 && "cannot encode signed integers");
+  }
+};
+
+/// Represents a character encoded in LLVM's Char6 encoding.
+///
+/// This format is suitable for encoding decimal numbers (without signs or
+/// exponents) and C identifiers (without dollar signs), but not much else.
+///
+/// \sa http://llvm.org/docs/BitCodeFormat.html#char6-encoded-value
+class BCChar6 : public detail::BCField<> {
+public:
+  static void emitOp(llvm::BitCodeAbbrev &abbrev) {
+    abbrev.Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Char6));
+  }
+
+  template <typename T> static void assertValid(const T &data) {
+    assert(llvm::BitCodeAbbrevOp::isChar6(data) && "invalid Char6 data");
+  }
+
+  template <typename T> char convert(T rawValue) {
+    return static_cast<char>(rawValue);
+  }
+};
+
+/// Represents an untyped blob of bytes.
+///
+/// If present, this must be the last field in a record.
+class BCBlob : public detail::BCField<true> {
+public:
+  static void emitOp(llvm::BitCodeAbbrev &abbrev) {
+    abbrev.Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob));
+  }
+};
+
+/// Represents an array of some other type.
+///
+/// If present, this must be the last field in a record.
+template <typename ElementTy> class BCArray : public detail::BCField<true> {
+  static_assert(!ElementTy::IsCompound, "arrays can only contain scalar types");
+
+public:
+  static void emitOp(llvm::BitCodeAbbrev &abbrev) {
+    abbrev.Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Array));
+    ElementTy::emitOp(abbrev);
+  }
+};
+
+namespace detail {
+/// Attaches the last field to an abbreviation.
+///
+/// This is the base case for \c emitOps.
+///
+/// \sa BCRecordLayout::emitAbbrev
+template <typename FieldTy> static void emitOps(llvm::BitCodeAbbrev &abbrev) {
+  FieldTy::emitOp(abbrev);
+}
+
+/// Attaches fields to an abbreviation.
+///
+/// This is the recursive case for \c emitOps.
+///
+/// \sa BCRecordLayout::emitAbbrev
+template <typename FieldTy, typename Next, typename... Rest>
+static void emitOps(llvm::BitCodeAbbrev &abbrev) {
+  static_assert(!FieldTy::IsCompound,
+                "arrays and blobs may not appear in the middle of a record");
+  FieldTy::emitOp(abbrev);
+  emitOps<Next, Rest...>(abbrev);
+}
+
+/// Helper class for dealing with a scalar element in the middle of a record.
+///
+/// \sa BCRecordLayout
+template <typename ElementTy, typename... Fields> class BCRecordCoding {
+public:
+  template <typename BufferTy, typename ElementDataTy, typename... DataTy>
+  static void emit(llvm::BitstreamWriter &Stream, BufferTy &buffer,
+                   unsigned code, ElementDataTy element, DataTy &&...data) {
+    static_assert(!ElementTy::IsCompound,
+                  "arrays and blobs may not appear in the middle of a record");
+    ElementTy::assertValid(element);
+    buffer.push_back(element);
+    BCRecordCoding<Fields...>::emit(Stream, buffer, code,
+                                    std::forward<DataTy>(data)...);
+  }
+
+  template <typename T, typename ElementDataTy, typename... DataTy>
+  static void read(ArrayRef<T> buffer, ElementDataTy &element,
+                   DataTy &&...data) {
+    assert(!buffer.empty() && "too few elements in buffer");
+    element = ElementTy::convert(buffer.front());
+    BCRecordCoding<Fields...>::read(buffer.slice(1),
+                                    std::forward<DataTy>(data)...);
+  }
+
+  template <typename T, typename... DataTy>
+  static void read(ArrayRef<T> buffer, NoneType, DataTy &&...data) {
+    assert(!buffer.empty() && "too few elements in buffer");
+    BCRecordCoding<Fields...>::read(buffer.slice(1),
+                                    std::forward<DataTy>(data)...);
+  }
+};
+
+/// Helper class for dealing with a scalar element at the end of a record.
+///
+/// This has a separate implementation because up until now we've only been
+/// \em building the record (into a data buffer), and now we need to hand it
+/// off to the BitstreamWriter to be emitted.
+///
+/// \sa BCRecordLayout
+template <typename ElementTy> class BCRecordCoding<ElementTy> {
+public:
+  template <typename BufferTy, typename DataTy>
+  static void emit(llvm::BitstreamWriter &Stream, BufferTy &buffer,
+                   unsigned code, const DataTy &data) {
+    static_assert(!ElementTy::IsCompound,
+                  "arrays and blobs need special handling");
+    ElementTy::assertValid(data);
+    buffer.push_back(data);
+    Stream.EmitRecordWithAbbrev(code, buffer);
+  }
+
+  template <typename T, typename DataTy>
+  static void read(ArrayRef<T> buffer, DataTy &data) {
+    assert(buffer.size() == 1 && "record data does not match layout");
+    data = ElementTy::convert(buffer.front());
+  }
+
+  template <typename T> static void read(ArrayRef<T> buffer, NoneType) {
+    assert(buffer.size() == 1 && "record data does not match layout");
+    (void)buffer;
+  }
+
+  template <typename T> static void read(ArrayRef<T> buffer) = delete;
+};
+
+/// Helper class for dealing with an array at the end of a record.
+///
+/// \sa BCRecordLayout::emitRecord
+template <typename ElementTy> class BCRecordCoding<BCArray<ElementTy>> {
+public:
+  template <typename BufferTy>
+  static void emit(llvm::BitstreamWriter &Stream, BufferTy &buffer,
+                   unsigned code, StringRef data) {
+    // TODO: validate array data.
+    Stream.EmitRecordWithArray(code, buffer, data);
+  }
+
+  template <typename BufferTy, typename ArrayTy>
+  static void emit(llvm::BitstreamWriter &Stream, BufferTy &buffer,
+                   unsigned code, const ArrayTy &array) {
+#ifndef NDEBUG
+    for (auto &element : array)
+      ElementTy::assertValid(element);
+#endif
+    buffer.reserve(buffer.size() + std::distance(array.begin(), array.end()));
+    std::copy(array.begin(), array.end(), std::back_inserter(buffer));
+    Stream.EmitRecordWithAbbrev(code, buffer);
+  }
+
+  template <typename BufferTy, typename ElementDataTy, typename... DataTy>
+  static void emit(llvm::BitstreamWriter &Stream, BufferTy &buffer,
+                   unsigned code, ElementDataTy element, DataTy... data) {
+    std::array<ElementDataTy, 1 + sizeof...(data)> array{{element, data...}};
+    emit(Stream, buffer, code, array);
+  }
+
+  template <typename BufferTy>
+  static void emit(llvm::BitstreamWriter &Stream, BufferTy &Buffer,
+                   unsigned code, NoneType) {
+    Stream.EmitRecordWithAbbrev(code, Buffer);
+  }
+
+  template <typename T>
+  static void read(ArrayRef<T> Buffer, ArrayRef<T> &rawData) {
+    rawData = Buffer;
+  }
+
+  template <typename T, typename ArrayTy>
+  static void read(ArrayRef<T> buffer, ArrayTy &array) {
+    array.append(llvm::map_iterator(buffer.begin(), T::convert),
+                 llvm::map_iterator(buffer.end(), T::convert));
+  }
+
+  template <typename T> static void read(ArrayRef<T> buffer, NoneType) {
+    (void)buffer;
+  }
+
+  template <typename T> static void read(ArrayRef<T> buffer) = delete;
+};
+
+/// Helper class for dealing with a blob at the end of a record.
+///
+/// \sa BCRecordLayout
+template <> class BCRecordCoding<BCBlob> {
+public:
+  template <typename BufferTy>
+  static void emit(llvm::BitstreamWriter &Stream, BufferTy &buffer,
+                   unsigned code, StringRef data) {
+    Stream.EmitRecordWithBlob(code, buffer, data);
+  }
+
+  template <typename T> static void read(ArrayRef<T> buffer) { (void)buffer; }
+
+  /// Blob data is not stored in the buffer if you are using the correct
+  /// accessor; this method should not be used.
+  template <typename T, typename DataTy>
+  static void read(ArrayRef<T> buffer, DataTy &data) = delete;
+};
+
+/// A type trait whose \c type field is the last of its template parameters.
+template <typename Head, typename... Tail> struct last_type {
+  using type = typename last_type<Tail...>::type;
+};
+
+template <typename Head> struct last_type<Head> { using type = Head; };
+
+/// A type trait whose \c value field is \c true if the last type is BCBlob.
+template <typename... Types>
+using has_blob = std::is_same<BCBlob, typename last_type<int, Types...>::type>;
+
+/// A type trait whose \c value field is \c true if the given type is a
+/// BCArray (of any element kind).
+template <typename T> struct is_array {
+private:
+  template <typename E> static bool check(BCArray<E> *);
+  static int check(...);
+
+public:
+  typedef bool value_type;
+  static constexpr bool value = !std::is_same<decltype(check((T *)nullptr)),
+                                              decltype(check(false))>::value;
+};
+
+/// A type trait whose \c value field is \c true if the last type is a
+/// BCArray (of any element kind).
+template <typename... Types>
+using has_array = is_array<typename last_type<int, Types...>::type>;
+} // namespace detail
+
+/// Represents a single bitcode record type.
+///
+/// This class template is meant to be instantiated and then given a name,
+/// so that from then on that name can be used.
+template <typename IDField, typename... Fields> class BCGenericRecordLayout {
+  llvm::BitstreamWriter &Stream;
+
+public:
+  /// The abbreviation code used for this record in the current block.
+  ///
+  /// Note that this is not the same as the semantic record code, which is the
+  /// first field of the record.
+  const unsigned AbbrevCode;
+
+  /// Create a layout and register it with the given bitstream writer.
+  explicit BCGenericRecordLayout(llvm::BitstreamWriter &Stream)
+      : Stream(Stream), AbbrevCode(emitAbbrev(Stream)) {}
+
+  /// Emit a record to the bitstream writer, using the given buffer for scratch
+  /// space.
+  ///
+  /// Note that even fixed arguments must be specified here.
+  template <typename BufferTy, typename... Data>
+  void emit(BufferTy &buffer, unsigned id, Data &&...data) const {
+    emitRecord(Stream, buffer, AbbrevCode, id, std::forward<Data>(data)...);
+  }
+
+  /// Registers this record's layout with the bitstream reader.
+  ///
+  /// eturns The abbreviation code for the newly-registered record type.
+  static unsigned emitAbbrev(llvm::BitstreamWriter &Stream) {
+    auto Abbrev = std::make_shared<llvm::BitCodeAbbrev>();
+    detail::emitOps<IDField, Fields...>(*Abbrev);
+    return Stream.EmitAbbrev(std::move(Abbrev));
+  }
+
+  /// Emit a record identified by \p abbrCode to bitstream reader \p Stream,
+  /// using \p buffer for scratch space.
+  ///
+  /// Note that even fixed arguments must be specified here. Blobs are passed
+  /// as StringRefs, while arrays can be passed inline, as aggregates, or as
+  /// pre-encoded StringRef data. Skipped values and empty arrays should use
+  /// the special Nothing value.
+  template <typename BufferTy, typename... Data>
+  static void emitRecord(llvm::BitstreamWriter &Stream, BufferTy &buffer,
+                         unsigned abbrCode, unsigned recordID, Data &&...data) {
+    static_assert(sizeof...(data) <= sizeof...(Fields) ||
+                      detail::has_array<Fields...>::value,
+                  "Too many record elements");
+    static_assert(sizeof...(data) >= sizeof...(Fields),
+                  "Too few record elements");
+    buffer.clear();
+    detail::BCRecordCoding<IDField, Fields...>::emit(
+        Stream, buffer, abbrCode, recordID, std::forward<Data>(data)...);
+  }
+
+  /// Extract record data from \p buffer into the given data fields.
+  ///
+  /// Note that even fixed arguments must be specified here. Pass \c Nothing
+  /// if you don't care about a particular parameter. Blob data is not included
+  /// in the buffer and should be handled separately by the caller.
+  template <typename ElementTy, typename... Data>
+  static void readRecord(ArrayRef<ElementTy> buffer, Data &&...data) {
+    static_assert(sizeof...(data) <= sizeof...(Fields),
+                  "Too many record elements");
+    static_assert(sizeof...(Fields) <=
+                      sizeof...(data) + detail::has_blob<Fields...>::value,
+                  "Too few record elements");
+    return detail::BCRecordCoding<Fields...>::read(buffer,
+                                                   std::forward<Data>(data)...);
+  }
+
+  /// Extract record data from \p buffer into the given data fields.
+  ///
+  /// Note that even fixed arguments must be specified here. Pass \c Nothing
+  /// if you don't care about a particular parameter. Blob data is not included
+  /// in the buffer and should be handled separately by the caller.
+  template <typename BufferTy, typename... Data>
+  static void readRecord(BufferTy &buffer, Data &&...data) {
+    return readRecord(llvm::makeArrayRef(buffer), std::forward<Data>(data)...);
+  }
+};
+
+/// A record with a fixed record code.
+template <unsigned RecordCode, typename... Fields>
+class BCRecordLayout
+    : public BCGenericRecordLayout<BCLiteral<RecordCode>, Fields...> {
+  using Base = BCGenericRecordLayout<BCLiteral<RecordCode>, Fields...>;
+
+public:
+  enum : unsigned {
+    /// The record code associated with this layout.
+    Code = RecordCode
+  };
+
+  /// Create a layout and register it with the given bitstream writer.
+  explicit BCRecordLayout(llvm::BitstreamWriter &Stream) : Base(Stream) {}
+
+  /// Emit a record to the bitstream writer, using the given buffer for scratch
+  /// space.
+  ///
+  /// Note that even fixed arguments must be specified here.
+  template <typename BufferTy, typename... Data>
+  void emit(BufferTy &buffer, Data &&...data) const {
+    Base::emit(buffer, RecordCode, std::forward<Data>(data)...);
+  }
+
+  /// Emit a record identified by \p abbrCode to bitstream reader \p Stream,
+  /// using \p buffer for scratch space.
+  ///
+  /// Note that even fixed arguments must be specified here. Currently, arrays
+  /// and blobs can only be passed as StringRefs.
+  template <typename BufferTy, typename... Data>
+  static void emitRecord(llvm::BitstreamWriter &Stream, BufferTy &buffer,
+                         unsigned abbrCode, Data &&...data) {
+    Base::emitRecord(Stream, buffer, abbrCode, RecordCode,
+                     std::forward<Data>(data)...);
+  }
+};
+
+/// RAII object to pair entering and exiting a sub-block.
+class BCBlockRAII {
+  llvm::BitstreamWriter &Stream;
+
+public:
+  BCBlockRAII(llvm::BitstreamWriter &Stream, unsigned block, unsigned abbrev)
+      : Stream(Stream) {
+    Stream.EnterSubblock(block, abbrev);
+  }
+
+  ~BCBlockRAII() { Stream.ExitBlock(); }
+};
+} // namespace llvm
+
+#endif
diff --git a/linux-x64/clang/include/llvm/Bitcode/BitcodeReader.h b/linux-x64/clang/include/llvm/Bitcode/BitcodeReader.h
index ba61da7..a82791c 100644
--- a/linux-x64/clang/include/llvm/Bitcode/BitcodeReader.h
+++ b/linux-x64/clang/include/llvm/Bitcode/BitcodeReader.h
@@ -31,6 +31,9 @@
 class LLVMContext;
 class Module;
 
+typedef llvm::function_ref<Optional<std::string>(StringRef)>
+    DataLayoutCallbackTy;
+
   // These functions are for converting Expected/Error values to
   // ErrorOr/std::error_code for compatibility with legacy clients. FIXME:
   // Remove these functions once no longer needed by the C and libLTO APIs.
@@ -77,10 +80,10 @@
     friend Expected<BitcodeFileContents>
     getBitcodeFileContents(MemoryBufferRef Buffer);
 
-    Expected<std::unique_ptr<Module>> getModuleImpl(LLVMContext &Context,
-                                                    bool MaterializeAll,
-                                                    bool ShouldLazyLoadMetadata,
-                                                    bool IsImporting);
+    Expected<std::unique_ptr<Module>>
+    getModuleImpl(LLVMContext &Context, bool MaterializeAll,
+                  bool ShouldLazyLoadMetadata, bool IsImporting,
+                  DataLayoutCallbackTy DataLayoutCallback);
 
   public:
     StringRef getBuffer() const {
@@ -100,7 +103,9 @@
                                                     bool IsImporting);
 
     /// Read the entire bitcode module and return it.
-    Expected<std::unique_ptr<Module>> parseModule(LLVMContext &Context);
+    Expected<std::unique_ptr<Module>> parseModule(
+        LLVMContext &Context, DataLayoutCallbackTy DataLayoutCallback =
+                                  [](StringRef) { return None; });
 
     /// Returns information about the module to be used for LTO: whether to
     /// compile with ThinLTO, and whether it has a summary.
@@ -163,8 +168,11 @@
   Expected<std::string> getBitcodeProducerString(MemoryBufferRef Buffer);
 
   /// Read the specified bitcode file, returning the module.
-  Expected<std::unique_ptr<Module>> parseBitcodeFile(MemoryBufferRef Buffer,
-                                                     LLVMContext &Context);
+  Expected<std::unique_ptr<Module>> parseBitcodeFile(
+      MemoryBufferRef Buffer, LLVMContext &Context,
+      DataLayoutCallbackTy DataLayoutCallback = [](StringRef) {
+        return None;
+      });
 
   /// Returns LTO information for the specified bitcode file.
   Expected<BitcodeLTOInfo> getBitcodeLTOInfo(MemoryBufferRef Buffer);
@@ -255,6 +263,8 @@
     return false;
   }
 
+  APInt readWideAPInt(ArrayRef<uint64_t> Vals, unsigned TypeBits);
+
   const std::error_category &BitcodeErrorCategory();
   enum class BitcodeError { CorruptedBitcode = 1 };
   inline std::error_code make_error_code(BitcodeError E) {
diff --git a/linux-x64/clang/include/llvm/Bitcode/BitcodeWriter.h b/linux-x64/clang/include/llvm/Bitcode/BitcodeWriter.h
index 39061e0..7ad2d37 100644
--- a/linux-x64/clang/include/llvm/Bitcode/BitcodeWriter.h
+++ b/linux-x64/clang/include/llvm/Bitcode/BitcodeWriter.h
@@ -17,6 +17,7 @@
 #include "llvm/IR/ModuleSummaryIndex.h"
 #include "llvm/MC/StringTableBuilder.h"
 #include "llvm/Support/Allocator.h"
+#include "llvm/Support/MemoryBuffer.h"
 #include <map>
 #include <memory>
 #include <string>
@@ -46,7 +47,7 @@
 
   public:
     /// Create a BitcodeWriter that writes to Buffer.
-    BitcodeWriter(SmallVectorImpl<char> &Buffer);
+    BitcodeWriter(SmallVectorImpl<char> &Buffer, raw_fd_stream *FS = nullptr);
 
     ~BitcodeWriter();
 
@@ -151,6 +152,19 @@
                         const std::map<std::string, GVSummaryMapTy>
                             *ModuleToSummariesForIndex = nullptr);
 
+  /// If EmbedBitcode is set, save a copy of the llvm IR as data in the
+  ///  __LLVM,__bitcode section (.llvmbc on non-MacOS).
+  /// If available, pass the serialized module via the Buf parameter. If not,
+  /// pass an empty (default-initialized) MemoryBufferRef, and the serialization
+  /// will be handled by this API. The same behavior happens if the provided Buf
+  /// is not bitcode (i.e. if it's invalid data or even textual LLVM assembly).
+  /// If EmbedCmdline is set, the command line is also exported in
+  /// the corresponding section (__LLVM,_cmdline / .llvmcmd) - even if CmdArgs
+  /// were empty.
+  void EmbedBitcodeInModule(Module &M, MemoryBufferRef Buf, bool EmbedBitcode,
+                            bool EmbedCmdline,
+                            const std::vector<uint8_t> &CmdArgs);
+
 } // end namespace llvm
 
 #endif // LLVM_BITCODE_BITCODEWRITER_H
diff --git a/linux-x64/clang/include/llvm/Bitcode/LLVMBitCodes.h b/linux-x64/clang/include/llvm/Bitcode/LLVMBitCodes.h
index 3ec0b38..03dac9e 100644
--- a/linux-x64/clang/include/llvm/Bitcode/LLVMBitCodes.h
+++ b/linux-x64/clang/include/llvm/Bitcode/LLVMBitCodes.h
@@ -85,7 +85,7 @@
   MODULE_CODE_ASM = 4,         // ASM:         [strchr x N]
   MODULE_CODE_SECTIONNAME = 5, // SECTIONNAME: [strchr x N]
 
-  // FIXME: Remove DEPLIB in 4.0.
+  // Deprecated, but still needed to read old bitcode files.
   MODULE_CODE_DEPLIB = 6, // DEPLIB:      [strchr x N]
 
   // GLOBALVAR: [pointer type, isconst, initid,
@@ -121,7 +121,7 @@
 
 /// PARAMATTR blocks have code for defining a parameter attribute set.
 enum AttributeCodes {
-  // FIXME: Remove `PARAMATTR_CODE_ENTRY_OLD' in 4.0
+  // Deprecated, but still needed to read old bitcode files.
   PARAMATTR_CODE_ENTRY_OLD = 1, // ENTRY: [paramidx0, attr0,
                                 //         paramidx1, attr1...]
   PARAMATTR_CODE_ENTRY = 2,     // ENTRY: [attrgrp0, attrgrp1, ...]
@@ -166,7 +166,10 @@
 
   TYPE_CODE_FUNCTION = 21, // FUNCTION: [vararg, retty, paramty x N]
 
-  TYPE_CODE_TOKEN = 22 // TOKEN
+  TYPE_CODE_TOKEN = 22, // TOKEN
+
+  TYPE_CODE_BFLOAT = 23, // BRAIN FLOATING POINT
+  TYPE_CODE_X86_AMX = 24 // X86 AMX
 };
 
 enum OperandBundleTagCode {
@@ -288,6 +291,11 @@
   //                                        numrefs, numrefs x valueid,
   //                                        n x (valueid, offset)]
   FS_PERMODULE_VTABLE_GLOBALVAR_INIT_REFS = 23,
+  // The total number of basic blocks in the module.
+  FS_BLOCK_COUNT = 24,
+  // Range information for accessed offsets for every argument.
+  // [n x (paramno, range, numcalls, numcalls x (callee_guid, paramno, range))]
+  FS_PARAM_ACCESS = 25,
 };
 
 enum MetadataCodes {
@@ -331,7 +339,11 @@
   METADATA_INDEX_OFFSET = 38,           // [offset]
   METADATA_INDEX = 39,                  // [bitpos]
   METADATA_LABEL = 40,                  // [distinct, scope, name, file, line]
-  METADATA_COMMON_BLOCK = 44,     // [distinct, scope, name, variable,...]
+  METADATA_STRING_TYPE = 41,            // [distinct, name, size, align,...]
+  // Codes 42 and 43 are reserved for support for Fortran array specific debug
+  // info.
+  METADATA_COMMON_BLOCK = 44,    // [distinct, scope, name, variable,...]
+  METADATA_GENERIC_SUBRANGE = 45 // [distinct, count, lo, up, stride]
 };
 
 // The constants block (CONSTANTS_BLOCK_ID) describes emission for each
@@ -364,6 +376,7 @@
                                  //                 asmdialect,asmstr,conststr]
   CST_CODE_CE_GEP_WITH_INRANGE_INDEX = 24, //      [opty, flags, n x operands]
   CST_CODE_CE_UNOP = 25,         // CE_UNOP:      [opcode, opval]
+  CST_CODE_POISON = 26,          // POISON
 };
 
 /// CastOpcodes - These are values used in the bitcode files to encode which
@@ -391,7 +404,7 @@
 /// have no fixed relation to the LLVM IR enum values.  Changing these will
 /// break compatibility with old files.
 enum UnaryOpcodes {
-  UNOP_NEG = 0
+  UNOP_FNEG = 0
 };
 
 /// BinaryOpcodes - These are values used in the bitcode files to encode which
@@ -529,8 +542,9 @@
 
   FUNC_CODE_DEBUG_LOC = 35,        // DEBUG_LOC:  [Line,Col,ScopeVal, IAVal]
   FUNC_CODE_INST_FENCE = 36,       // FENCE: [ordering, synchscope]
-  FUNC_CODE_INST_CMPXCHG_OLD = 37, // CMPXCHG: [ptrty,ptr,cmp,new, align, vol,
-                                   //           ordering, synchscope]
+  FUNC_CODE_INST_CMPXCHG_OLD = 37, // CMPXCHG: [ptrty, ptr, cmp, val, vol,
+                                   //            ordering, synchscope,
+                                   //            failure_ordering?, weak?]
   FUNC_CODE_INST_ATOMICRMW = 38,   // ATOMICRMW: [ptrty,ptr,val, operation,
                                    //             align, vol,
                                    //             ordering, synchscope]
@@ -544,8 +558,9 @@
   FUNC_CODE_INST_GEP = 43,             // GEP:  [inbounds, n x operands]
   FUNC_CODE_INST_STORE = 44,       // STORE: [ptrty,ptr,valty,val, align, vol]
   FUNC_CODE_INST_STOREATOMIC = 45, // STORE: [ptrty,ptr,val, align, vol
-  FUNC_CODE_INST_CMPXCHG = 46,     // CMPXCHG: [ptrty,ptr,valty,cmp,new, align,
-                                   //           vol,ordering,synchscope]
+  FUNC_CODE_INST_CMPXCHG = 46,     // CMPXCHG: [ptrty, ptr, cmp, val, vol,
+                                   //           success_ordering, synchscope,
+                                   //           failure_ordering, weak]
   FUNC_CODE_INST_LANDINGPAD = 47,  // LANDINGPAD: [ty,val,num,id0,val0...]
   FUNC_CODE_INST_CLEANUPRET = 48,  // CLEANUPRET: [val] or [val,bb#]
   FUNC_CODE_INST_CATCHRET = 49,    // CATCHRET: [val,bb#]
@@ -559,6 +574,7 @@
   FUNC_CODE_INST_UNOP = 56,      // UNOP:       [opcode, ty, opval]
   FUNC_CODE_INST_CALLBR = 57,    // CALLBR:     [attr, cc, norm, transfs,
                                  //              fnty, fnid, args...]
+  FUNC_CODE_INST_FREEZE = 58,    // FREEZE: [opty, opval]
 };
 
 enum UseListCodes {
@@ -629,7 +645,17 @@
   ATTR_KIND_SPECULATIVE_LOAD_HARDENING = 59,
   ATTR_KIND_IMMARG = 60,
   ATTR_KIND_WILLRETURN = 61,
-  ATTR_KIND_NOFREE = 62
+  ATTR_KIND_NOFREE = 62,
+  ATTR_KIND_NOSYNC = 63,
+  ATTR_KIND_SANITIZE_MEMTAG = 64,
+  ATTR_KIND_PREALLOCATED = 65,
+  ATTR_KIND_NO_MERGE = 66,
+  ATTR_KIND_NULL_POINTER_IS_VALID = 67,
+  ATTR_KIND_NOUNDEF = 68,
+  ATTR_KIND_BYREF = 69,
+  ATTR_KIND_MUSTPROGRESS = 70,
+  ATTR_KIND_NO_CALLBACK = 71,
+  ATTR_KIND_HOT = 72,
 };
 
 enum ComdatSelectionKindCodes {
diff --git a/linux-x64/clang/include/llvm/Bitstream/BitCodes.h b/linux-x64/clang/include/llvm/Bitstream/BitCodes.h
index adf54ba..41a3de3 100644
--- a/linux-x64/clang/include/llvm/Bitstream/BitCodes.h
+++ b/linux-x64/clang/include/llvm/Bitstream/BitCodes.h
@@ -168,6 +168,11 @@
   SmallVector<BitCodeAbbrevOp, 32> OperandList;
 
 public:
+  BitCodeAbbrev() = default;
+
+  explicit BitCodeAbbrev(std::initializer_list<BitCodeAbbrevOp> OperandList)
+      : OperandList(OperandList) {}
+
   unsigned getNumOperandInfos() const {
     return static_cast<unsigned>(OperandList.size());
   }
diff --git a/linux-x64/clang/include/llvm/Bitstream/BitstreamReader.h b/linux-x64/clang/include/llvm/Bitstream/BitstreamReader.h
index ccb4a49..0393d1a 100644
--- a/linux-x64/clang/include/llvm/Bitstream/BitstreamReader.h
+++ b/linux-x64/clang/include/llvm/Bitstream/BitstreamReader.h
@@ -18,6 +18,7 @@
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Bitstream/BitCodes.h"
 #include "llvm/Support/Endian.h"
+#include "llvm/Support/Error.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/MemoryBuffer.h"
@@ -39,7 +40,7 @@
   /// This contains information emitted to BLOCKINFO_BLOCK blocks. These
   /// describe abbreviations that all blocks of the specified ID inherit.
   struct BlockInfo {
-    unsigned BlockID;
+    unsigned BlockID = 0;
     std::vector<std::shared_ptr<BitCodeAbbrev>> Abbrevs;
     std::string Name;
     std::vector<std::pair<unsigned, std::string>> RecordNames;
@@ -294,6 +295,9 @@
     BitsInCurWord = 0;
   }
 
+  /// Return the size of the stream in bytes.
+  size_t SizeInBytes() const { return BitcodeBytes.size(); }
+
   /// Skip to the end of the file.
   void skipToEnd() { NextChar = BitcodeBytes.size(); }
 };
@@ -364,17 +368,19 @@
   explicit BitstreamCursor(MemoryBufferRef BitcodeBytes)
       : SimpleBitstreamCursor(BitcodeBytes) {}
 
-  using SimpleBitstreamCursor::canSkipToPos;
   using SimpleBitstreamCursor::AtEndOfStream;
+  using SimpleBitstreamCursor::canSkipToPos;
+  using SimpleBitstreamCursor::fillCurWord;
   using SimpleBitstreamCursor::getBitcodeBytes;
   using SimpleBitstreamCursor::GetCurrentBitNo;
   using SimpleBitstreamCursor::getCurrentByteNo;
   using SimpleBitstreamCursor::getPointerToByte;
   using SimpleBitstreamCursor::JumpToBit;
-  using SimpleBitstreamCursor::fillCurWord;
   using SimpleBitstreamCursor::Read;
   using SimpleBitstreamCursor::ReadVBR;
   using SimpleBitstreamCursor::ReadVBR64;
+  using SimpleBitstreamCursor::SizeInBytes;
+  using SimpleBitstreamCursor::skipToEnd;
 
   /// Return the number of bits used to encode an abbrev #.
   unsigned getAbbrevIDWidth() const { return CurCodeSize; }
diff --git a/linux-x64/clang/include/llvm/Bitstream/BitstreamWriter.h b/linux-x64/clang/include/llvm/Bitstream/BitstreamWriter.h
index c0ead19..3954df4 100644
--- a/linux-x64/clang/include/llvm/Bitstream/BitstreamWriter.h
+++ b/linux-x64/clang/include/llvm/Bitstream/BitstreamWriter.h
@@ -20,17 +20,28 @@
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Bitstream/BitCodes.h"
 #include "llvm/Support/Endian.h"
+#include "llvm/Support/raw_ostream.h"
+#include <algorithm>
 #include <vector>
 
 namespace llvm {
 
 class BitstreamWriter {
+  /// Out - The buffer that keeps unflushed bytes.
   SmallVectorImpl<char> &Out;
 
+  /// FS - The file stream that Out flushes to. If FS is nullptr, it does not
+  /// support read or seek, Out cannot be flushed until all data are written.
+  raw_fd_stream *FS;
+
+  /// FlushThreshold - If FS is valid, this is the threshold (unit B) to flush
+  /// FS.
+  const uint64_t FlushThreshold;
+
   /// CurBit - Always between 0 and 31 inclusive, specifies the next bit to use.
   unsigned CurBit;
 
-  /// CurValue - The current value.  Only bits < CurBit are valid.
+  /// CurValue - The current value. Only bits < CurBit are valid.
   uint32_t CurValue;
 
   /// CurCodeSize - This is the declared size of code values used for the
@@ -64,15 +75,19 @@
 
   void WriteByte(unsigned char Value) {
     Out.push_back(Value);
+    FlushToFile();
   }
 
   void WriteWord(unsigned Value) {
     Value = support::endian::byte_swap<uint32_t, support::little>(Value);
     Out.append(reinterpret_cast<const char *>(&Value),
                reinterpret_cast<const char *>(&Value + 1));
+    FlushToFile();
   }
 
-  size_t GetBufferOffset() const { return Out.size(); }
+  uint64_t GetNumOfFlushedBytes() const { return FS ? FS->tell() : 0; }
+
+  size_t GetBufferOffset() const { return Out.size() + GetNumOfFlushedBytes(); }
 
   size_t GetWordIndex() const {
     size_t Offset = GetBufferOffset();
@@ -80,9 +95,29 @@
     return Offset / 4;
   }
 
+  /// If the related file stream supports reading, seeking and writing, flush
+  /// the buffer if its size is above a threshold.
+  void FlushToFile() {
+    if (!FS)
+      return;
+    if (Out.size() < FlushThreshold)
+      return;
+    FS->write((char *)&Out.front(), Out.size());
+    Out.clear();
+  }
+
 public:
-  explicit BitstreamWriter(SmallVectorImpl<char> &O)
-    : Out(O), CurBit(0), CurValue(0), CurCodeSize(2) {}
+  /// Create a BitstreamWriter that writes to Buffer \p O.
+  ///
+  /// \p FS is the file stream that \p O flushes to incrementally. If \p FS is
+  /// null, \p O does not flush incrementially, but writes to disk at the end.
+  ///
+  /// \p FlushThreshold is the threshold (unit M) to flush \p O if \p FS is
+  /// valid.
+  BitstreamWriter(SmallVectorImpl<char> &O, raw_fd_stream *FS = nullptr,
+                  uint32_t FlushThreshold = 512)
+      : Out(O), FS(FS), FlushThreshold(FlushThreshold << 20), CurBit(0),
+        CurValue(0), CurCodeSize(2) {}
 
   ~BitstreamWriter() {
     assert(CurBit == 0 && "Unflushed data remaining");
@@ -103,12 +138,60 @@
   /// with the specified value.
   void BackpatchWord(uint64_t BitNo, unsigned NewWord) {
     using namespace llvm::support;
-    unsigned ByteNo = BitNo / 8;
-    assert((!endian::readAtBitAlignment<uint32_t, little, unaligned>(
-               &Out[ByteNo], BitNo & 7)) &&
-           "Expected to be patching over 0-value placeholders");
-    endian::writeAtBitAlignment<uint32_t, little, unaligned>(
-        &Out[ByteNo], NewWord, BitNo & 7);
+    uint64_t ByteNo = BitNo / 8;
+    uint64_t StartBit = BitNo & 7;
+    uint64_t NumOfFlushedBytes = GetNumOfFlushedBytes();
+
+    if (ByteNo >= NumOfFlushedBytes) {
+      assert((!endian::readAtBitAlignment<uint32_t, little, unaligned>(
+                 &Out[ByteNo - NumOfFlushedBytes], StartBit)) &&
+             "Expected to be patching over 0-value placeholders");
+      endian::writeAtBitAlignment<uint32_t, little, unaligned>(
+          &Out[ByteNo - NumOfFlushedBytes], NewWord, StartBit);
+      return;
+    }
+
+    // If the byte offset to backpatch is flushed, use seek to backfill data.
+    // First, save the file position to restore later.
+    uint64_t CurPos = FS->tell();
+
+    // Copy data to update into Bytes from the file FS and the buffer Out.
+    char Bytes[9]; // Use one more byte to silence a warning from Visual C++.
+    size_t BytesNum = StartBit ? 8 : 4;
+    size_t BytesFromDisk = std::min(static_cast<uint64_t>(BytesNum), NumOfFlushedBytes - ByteNo);
+    size_t BytesFromBuffer = BytesNum - BytesFromDisk;
+
+    // When unaligned, copy existing data into Bytes from the file FS and the
+    // buffer Out so that it can be updated before writing. For debug builds
+    // read bytes unconditionally in order to check that the existing value is 0
+    // as expected.
+#ifdef NDEBUG
+    if (StartBit)
+#endif
+    {
+      FS->seek(ByteNo);
+      ssize_t BytesRead = FS->read(Bytes, BytesFromDisk);
+      (void)BytesRead; // silence warning
+      assert(BytesRead >= 0 && static_cast<size_t>(BytesRead) == BytesFromDisk);
+      for (size_t i = 0; i < BytesFromBuffer; ++i)
+        Bytes[BytesFromDisk + i] = Out[i];
+      assert((!endian::readAtBitAlignment<uint32_t, little, unaligned>(
+                 Bytes, StartBit)) &&
+             "Expected to be patching over 0-value placeholders");
+    }
+
+    // Update Bytes in terms of bit offset and value.
+    endian::writeAtBitAlignment<uint32_t, little, unaligned>(Bytes, NewWord,
+                                                             StartBit);
+
+    // Copy updated data back to the file FS and the buffer Out.
+    FS->seek(ByteNo);
+    FS->write(Bytes, BytesFromDisk);
+    for (size_t i = 0; i < BytesFromBuffer; ++i)
+      Out[i] = Bytes[BytesFromDisk + i];
+
+    // Restore the file position.
+    FS->seek(CurPos);
   }
 
   void BackpatchWord64(uint64_t BitNo, uint64_t Val) {
diff --git a/linux-x64/clang/include/llvm/CodeGen/AccelTable.h b/linux-x64/clang/include/llvm/CodeGen/AccelTable.h
index 734531a..f8f6b54 100644
--- a/linux-x64/clang/include/llvm/CodeGen/AccelTable.h
+++ b/linux-x64/clang/include/llvm/CodeGen/AccelTable.h
@@ -101,8 +101,6 @@
 ///
 /// An Apple Accelerator Table can be serialized by calling emitAppleAccelTable
 /// function.
-///
-/// TODO: Add DWARF v5 emission code.
 
 namespace llvm {
 
diff --git a/linux-x64/clang/include/llvm/CodeGen/Analysis.h b/linux-x64/clang/include/llvm/CodeGen/Analysis.h
index 0be0ac2..bdfb416 100644
--- a/linux-x64/clang/include/llvm/CodeGen/Analysis.h
+++ b/linux-x64/clang/include/llvm/CodeGen/Analysis.h
@@ -18,7 +18,6 @@
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/CodeGen/ISDOpcodes.h"
-#include "llvm/IR/CallSite.h"
 #include "llvm/IR/InlineAsm.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/Support/CodeGen.h"
@@ -31,9 +30,6 @@
 class TargetLoweringBase;
 class TargetLowering;
 class TargetMachine;
-class SDNode;
-class SDValue;
-class SelectionDAG;
 struct EVT;
 
 /// Compute the linearized index of a member in a nested
@@ -96,11 +92,6 @@
 /// ExtractTypeInfo - Returns the type info, possibly bitcast, encoded in V.
 GlobalValue *ExtractTypeInfo(Value *V);
 
-/// hasInlineAsmMemConstraint - Return true if the inline asm instruction being
-/// processed uses a memory 'm' constraint.
-bool hasInlineAsmMemConstraint(InlineAsm::ConstraintInfoVector &CInfos,
-                               const TargetLowering &TLI);
-
 /// getFCmpCondCode - Return the ISD condition code corresponding to
 /// the given LLVM IR floating-point condition code.  This includes
 /// consideration of global floating-point math flags.
@@ -122,7 +113,7 @@
 /// between it and the return.
 ///
 /// This function only tests target-independent requirements.
-bool isInTailCallPosition(ImmutableCallSite CS, const TargetMachine &TM);
+bool isInTailCallPosition(const CallBase &Call, const TargetMachine &TM);
 
 /// Test if given that the input instruction is in the tail call position, if
 /// there is an attribute mismatch between the caller and the callee that will
diff --git a/linux-x64/clang/include/llvm/CodeGen/AntiDepBreaker.h b/linux-x64/clang/include/llvm/CodeGen/AntiDepBreaker.h
new file mode 100644
index 0000000..0553d7d
--- /dev/null
+++ b/linux-x64/clang/include/llvm/CodeGen/AntiDepBreaker.h
@@ -0,0 +1,96 @@
+//===- llvm/CodeGen/AntiDepBreaker.h - Anti-Dependence Breaking -*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements the AntiDepBreaker class, which implements
+// anti-dependence breaking heuristics for post-register-allocation scheduling.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIB_CODEGEN_ANTIDEPBREAKER_H
+#define LLVM_LIB_CODEGEN_ANTIDEPBREAKER_H
+
+#include "llvm/ADT/iterator_range.h"
+#include "llvm/CodeGen/MachineBasicBlock.h"
+#include "llvm/CodeGen/MachineInstr.h"
+#include "llvm/CodeGen/TargetSubtargetInfo.h"
+#include "llvm/Support/Compiler.h"
+#include <cassert>
+#include <utility>
+#include <vector>
+
+namespace llvm {
+
+class RegisterClassInfo;
+
+/// This class works in conjunction with the post-RA scheduler to rename
+/// registers to break register anti-dependencies (WAR hazards).
+class AntiDepBreaker {
+public:
+  using DbgValueVector =
+      std::vector<std::pair<MachineInstr *, MachineInstr *>>;
+
+  virtual ~AntiDepBreaker();
+
+  /// Initialize anti-dep breaking for a new basic block.
+  virtual void StartBlock(MachineBasicBlock *BB) = 0;
+
+  /// Identifiy anti-dependencies within a basic-block region and break them by
+  /// renaming registers. Return the number of anti-dependencies broken.
+  virtual unsigned BreakAntiDependencies(const std::vector<SUnit> &SUnits,
+                                         MachineBasicBlock::iterator Begin,
+                                         MachineBasicBlock::iterator End,
+                                         unsigned InsertPosIndex,
+                                         DbgValueVector &DbgValues) = 0;
+
+  /// Update liveness information to account for the current
+  /// instruction, which will not be scheduled.
+  virtual void Observe(MachineInstr &MI, unsigned Count,
+                       unsigned InsertPosIndex) = 0;
+
+  /// Finish anti-dep breaking for a basic block.
+  virtual void FinishBlock() = 0;
+
+  /// Update DBG_VALUE if dependency breaker is updating
+  /// other machine instruction to use NewReg.
+  void UpdateDbgValue(MachineInstr &MI, unsigned OldReg, unsigned NewReg) {
+    assert(MI.isDebugValue() && "MI is not DBG_VALUE!");
+    if (MI.getDebugOperand(0).isReg() &&
+        MI.getDebugOperand(0).getReg() == OldReg)
+      MI.getDebugOperand(0).setReg(NewReg);
+  }
+
+  /// Update all DBG_VALUE instructions that may be affected by the dependency
+  /// breaker's update of ParentMI to use NewReg.
+  void UpdateDbgValues(const DbgValueVector &DbgValues, MachineInstr *ParentMI,
+                       unsigned OldReg, unsigned NewReg) {
+    // The following code is dependent on the order in which the DbgValues are
+    // constructed in ScheduleDAGInstrs::buildSchedGraph.
+    MachineInstr *PrevDbgMI = nullptr;
+    for (const auto &DV : make_range(DbgValues.crbegin(), DbgValues.crend())) {
+      MachineInstr *PrevMI = DV.second;
+      if ((PrevMI == ParentMI) || (PrevMI == PrevDbgMI)) {
+        MachineInstr *DbgMI = DV.first;
+        UpdateDbgValue(*DbgMI, OldReg, NewReg);
+        PrevDbgMI = DbgMI;
+      } else if (PrevDbgMI) {
+        break; // If no match and already found a DBG_VALUE, we're done.
+      }
+    }
+  }
+};
+
+AntiDepBreaker *createAggressiveAntiDepBreaker(
+    MachineFunction &MFi, const RegisterClassInfo &RCI,
+    TargetSubtargetInfo::RegClassVector &CriticalPathRCs);
+
+AntiDepBreaker *createCriticalAntiDepBreaker(MachineFunction &MFi,
+                                             const RegisterClassInfo &RCI);
+
+} // end namespace llvm
+
+#endif // LLVM_LIB_CODEGEN_ANTIDEPBREAKER_H
diff --git a/linux-x64/clang/include/llvm/CodeGen/AsmPrinter.h b/linux-x64/clang/include/llvm/CodeGen/AsmPrinter.h
index 9c2097b..76486b0 100644
--- a/linux-x64/clang/include/llvm/CodeGen/AsmPrinter.h
+++ b/linux-x64/clang/include/llvm/CodeGen/AsmPrinter.h
@@ -17,8 +17,6 @@
 
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/SmallVector.h"
-#include "llvm/ADT/StringRef.h"
-#include "llvm/ADT/Twine.h"
 #include "llvm/CodeGen/AsmPrinterHandler.h"
 #include "llvm/CodeGen/DwarfStringPoolEntry.h"
 #include "llvm/CodeGen/MachineFunctionPass.h"
@@ -58,7 +56,6 @@
 class MachineOptimizationRemarkEmitter;
 class MCAsmInfo;
 class MCCFIInstruction;
-struct MCCodePaddingContext;
 class MCContext;
 class MCExpr;
 class MCInst;
@@ -69,10 +66,17 @@
 class MCTargetOptions;
 class MDNode;
 class Module;
+class PseudoProbeHandler;
 class raw_ostream;
 class StackMaps;
+class StringRef;
 class TargetLoweringObjectFile;
 class TargetMachine;
+class Twine;
+
+namespace remarks {
+class RemarkStreamer;
+}
 
 /// This class is intended to be used as a driving class for all asm writers.
 class AsmPrinter : public MachineFunctionPass {
@@ -98,7 +102,7 @@
   /// This is a pointer to the current MachineModuleInfo.
   MachineModuleInfo *MMI = nullptr;
 
-  /// This is a pointer to the current MachineLoopInfo.
+  /// This is a pointer to the current MachineDominatorTree.
   MachineDominatorTree *MDT = nullptr;
 
   /// This is a pointer to the current MachineLoopInfo.
@@ -107,36 +111,37 @@
   /// Optimization remark emitter.
   MachineOptimizationRemarkEmitter *ORE;
 
+  /// The symbol for the entry in __patchable_function_entires.
+  MCSymbol *CurrentPatchableFunctionEntrySym = nullptr;
+
   /// The symbol for the current function. This is recalculated at the beginning
   /// of each call to runOnMachineFunction().
   MCSymbol *CurrentFnSym = nullptr;
 
+  /// The symbol for the current function descriptor on AIX. This is created
+  /// at the beginning of each call to SetupMachineFunction().
+  MCSymbol *CurrentFnDescSym = nullptr;
+
   /// The symbol used to represent the start of the current function for the
   /// purpose of calculating its size (e.g. using the .size directive). By
   /// default, this is equal to CurrentFnSym.
   MCSymbol *CurrentFnSymForSize = nullptr;
 
+  /// Map a basic block section ID to the begin and end symbols of that section
+  ///  which determine the section's range.
+  struct MBBSectionRange {
+    MCSymbol *BeginLabel, *EndLabel;
+  };
+
+  MapVector<unsigned, MBBSectionRange> MBBSectionRanges;
+
   /// Map global GOT equivalent MCSymbols to GlobalVariables and keep track of
   /// its number of uses by other globals.
   using GOTEquivUsePair = std::pair<const GlobalVariable *, unsigned>;
   MapVector<const MCSymbol *, GOTEquivUsePair> GlobalGOTEquivs;
 
-private:
-  MCSymbol *CurrentFnBegin = nullptr;
-  MCSymbol *CurrentFnEnd = nullptr;
-  MCSymbol *CurExceptionSym = nullptr;
-
-  // The garbage collection metadata printer table.
-  void *GCMetadataPrinters = nullptr; // Really a DenseMap.
-
-  /// Emit comments in assembly output if this is true.
-  bool VerboseAsm;
-
-  static char ID;
-
-protected:
-  /// Protected struct HandlerInfo and Handlers permit target extended
-  /// AsmPrinter adds their own handlers.
+  /// struct HandlerInfo and Handlers permit users or target extended
+  /// AsmPrinter to add their own handlers.
   struct HandlerInfo {
     std::unique_ptr<AsmPrinterHandler> Handler;
     const char *TimerName;
@@ -152,9 +157,33 @@
           TimerGroupDescription(TimerGroupDescription) {}
   };
 
+private:
+  MCSymbol *CurrentFnEnd = nullptr;
+
+  /// Map a basic block section ID to the exception symbol associated with that
+  /// section. Map entries are assigned and looked up via
+  /// AsmPrinter::getMBBExceptionSym.
+  DenseMap<unsigned, MCSymbol *> MBBSectionExceptionSyms;
+
+  // The symbol used to represent the start of the current BB section of the
+  // function. This is used to calculate the size of the BB section.
+  MCSymbol *CurrentSectionBeginSym = nullptr;
+
+  // The garbage collection metadata printer table.
+  void *GCMetadataPrinters = nullptr; // Really a DenseMap.
+
+  /// Emit comments in assembly output if this is true.
+  bool VerboseAsm;
+
+  static char ID;
+
+protected:
+  MCSymbol *CurrentFnBegin = nullptr;
+
   /// A vector of all debug/EH info emitters we should use. This vector
   /// maintains ownership of the emitters.
-  SmallVector<HandlerInfo, 1> Handlers;
+  std::vector<HandlerInfo> Handlers;
+  size_t NumUserHandlers = 0;
 
 public:
   struct SrcMgrDiagInfo {
@@ -178,6 +207,10 @@
   /// If the target supports dwarf debug info, this pointer is non-null.
   DwarfDebug *DD = nullptr;
 
+  /// A handler that supports pseudo probe emission with embedded inline
+  /// context.
+  PseudoProbeHandler *PP = nullptr;
+
   /// If the current module uses dwarf CFI annotations strictly for debugging.
   bool isCFIMoveForDebugging = false;
 
@@ -193,6 +226,14 @@
   uint16_t getDwarfVersion() const;
   void setDwarfVersion(uint16_t Version);
 
+  bool isDwarf64() const;
+
+  /// Returns 4 for DWARF32 and 8 for DWARF64.
+  unsigned int getDwarfOffsetByteSize() const;
+
+  /// Returns 4 for DWARF32 and 12 for DWARF64.
+  unsigned int getUnitLengthFieldByteSize() const;
+
   bool isPositionIndependent() const;
 
   /// Return true if assembly output should contain comments.
@@ -207,7 +248,10 @@
 
   MCSymbol *getFunctionBegin() const { return CurrentFnBegin; }
   MCSymbol *getFunctionEnd() const { return CurrentFnEnd; }
-  MCSymbol *getCurExceptionSym();
+
+  // Return the exception symbol associated with the MBB section containing a
+  // given basic block.
+  MCSymbol *getMBBExceptionSym(const MachineBasicBlock &MBB);
 
   /// Return information about object file lowering.
   const TargetLoweringObjectFile &getObjFileLowering() const;
@@ -234,6 +278,11 @@
 
   MCSymbol *getSymbol(const GlobalValue *GV) const;
 
+  /// Similar to getSymbol() but preferred for references. On ELF, this uses a
+  /// local symbol if a reference to GV is guaranteed to be resolved to the
+  /// definition in the same module.
+  MCSymbol *getSymbolPreferLocal(const GlobalValue &GV) const;
+
   //===------------------------------------------------------------------===//
   // XRay instrumentation implementation.
   //===------------------------------------------------------------------===//
@@ -260,15 +309,12 @@
     const class Function *Fn;
     uint8_t Version;
 
-    void emit(int, MCStreamer *, const MCSymbol *) const;
+    void emit(int, MCStreamer *) const;
   };
 
   // All the sleds to be emitted.
   SmallVector<XRayFunctionEntry, 4> Sleds;
 
-  // A unique ID used for ELF sections associated with a particular function.
-  unsigned XRayFnUniqueID = 0;
-
   // Helper function to record a given XRay sled.
   void recordSled(MCSymbol *Sled, const MachineInstr &MI, SledKind Kind,
                   uint8_t Version = 0);
@@ -276,6 +322,8 @@
   /// Emit a table with all XRay instrumentation points.
   void emitXRayTable();
 
+  void emitPatchableFunctionEntries();
+
   //===------------------------------------------------------------------===//
   // MachineFunctionPass Implementation.
   //===------------------------------------------------------------------===//
@@ -294,7 +342,7 @@
   /// Emit the specified function out to the OutStreamer.
   bool runOnMachineFunction(MachineFunction &MF) override {
     SetupMachineFunction(MF);
-    EmitFunctionBody();
+    emitFunctionBody();
     return false;
   }
 
@@ -304,10 +352,10 @@
 
   /// This should be called when a new MachineFunction is being processed from
   /// runOnMachineFunction.
-  void SetupMachineFunction(MachineFunction &MF);
+  virtual void SetupMachineFunction(MachineFunction &MF);
 
   /// This method emits the body and trailer for a function.
-  void EmitFunctionBody();
+  void emitFunctionBody();
 
   void emitCFIInstruction(const MachineInstr &MI);
 
@@ -315,7 +363,11 @@
 
   void emitStackSizeSection(const MachineFunction &MF);
 
-  void emitRemarksSection(Module &M);
+  void emitBBAddrMapSection(const MachineFunction &MF);
+
+  void emitPseudoProbe(const MachineInstr &MI);
+
+  void emitRemarksSection(remarks::RemarkStreamer &RS);
 
   enum CFIMoveType { CFI_M_None, CFI_M_EH, CFI_M_Debug };
   CFIMoveType needsCFIMoves() const;
@@ -329,31 +381,56 @@
   /// Print to the current output stream assembly representations of the
   /// constants in the constant pool MCP. This is used to print out constants
   /// which have been "spilled to memory" by the code generator.
-  virtual void EmitConstantPool();
+  virtual void emitConstantPool();
 
   /// Print assembly representations of the jump tables used by the current
   /// function to the current output stream.
-  virtual void EmitJumpTableInfo();
+  virtual void emitJumpTableInfo();
 
   /// Emit the specified global variable to the .s file.
-  virtual void EmitGlobalVariable(const GlobalVariable *GV);
+  virtual void emitGlobalVariable(const GlobalVariable *GV);
 
   /// Check to see if the specified global is a special global used by LLVM. If
   /// so, emit it and return true, otherwise do nothing and return false.
-  bool EmitSpecialLLVMGlobal(const GlobalVariable *GV);
+  bool emitSpecialLLVMGlobal(const GlobalVariable *GV);
 
-  /// Emit an alignment directive to the specified power of two boundary. For
-  /// example, if you pass in 3 here, you will get an 8 byte alignment. If a
+  /// `llvm.global_ctors` and `llvm.global_dtors` are arrays of Structor
+  /// structs.
+  ///
+  /// Priority - init priority
+  /// Func - global initialization or global clean-up function
+  /// ComdatKey - associated data
+  struct Structor {
+    int Priority = 0;
+    Constant *Func = nullptr;
+    GlobalValue *ComdatKey = nullptr;
+
+    Structor() = default;
+  };
+
+  /// This method gathers an array of Structors and then sorts them out by
+  /// Priority.
+  /// @param List The initializer of `llvm.global_ctors` or `llvm.global_dtors`
+  /// array.
+  /// @param[out] Structors Sorted Structor structs by Priority.
+  void preprocessXXStructorList(const DataLayout &DL, const Constant *List,
+                                SmallVector<Structor, 8> &Structors);
+
+  /// This method emits `llvm.global_ctors` or `llvm.global_dtors` list.
+  virtual void emitXXStructorList(const DataLayout &DL, const Constant *List,
+                                  bool IsCtor);
+
+  /// Emit an alignment directive to the specified power of two boundary. If a
   /// global value is specified, and if that global has an explicit alignment
   /// requested, it will override the alignment request if required for
   /// correctness.
-  void EmitAlignment(unsigned NumBits, const GlobalObject *GV = nullptr) const;
+  void emitAlignment(Align Alignment, const GlobalObject *GV = nullptr) const;
 
   /// Lower the specified LLVM Constant to an MCExpr.
   virtual const MCExpr *lowerConstant(const Constant *CV);
 
   /// Print a general LLVM constant to the .s file.
-  void EmitGlobalConstant(const DataLayout &DL, const Constant *CV);
+  void emitGlobalConstant(const DataLayout &DL, const Constant *CV);
 
   /// Unnamed constant global variables solely contaning a pointer to
   /// another globals variable act like a global variable "proxy", or GOT
@@ -377,50 +454,59 @@
   // Overridable Hooks
   //===------------------------------------------------------------------===//
 
+  void addAsmPrinterHandler(HandlerInfo Handler) {
+    Handlers.insert(Handlers.begin(), std::move(Handler));
+    NumUserHandlers++;
+  }
+
   // Targets can, or in the case of EmitInstruction, must implement these to
   // customize output.
 
   /// This virtual method can be overridden by targets that want to emit
   /// something at the start of their file.
-  virtual void EmitStartOfAsmFile(Module &) {}
+  virtual void emitStartOfAsmFile(Module &) {}
 
   /// This virtual method can be overridden by targets that want to emit
   /// something at the end of their file.
-  virtual void EmitEndOfAsmFile(Module &) {}
+  virtual void emitEndOfAsmFile(Module &) {}
 
   /// Targets can override this to emit stuff before the first basic block in
   /// the function.
-  virtual void EmitFunctionBodyStart() {}
+  virtual void emitFunctionBodyStart() {}
 
   /// Targets can override this to emit stuff after the last basic block in the
   /// function.
-  virtual void EmitFunctionBodyEnd() {}
+  virtual void emitFunctionBodyEnd() {}
 
   /// Targets can override this to emit stuff at the start of a basic block.
   /// By default, this method prints the label for the specified
   /// MachineBasicBlock, an alignment (if present) and a comment describing it
   /// if appropriate.
-  virtual void EmitBasicBlockStart(const MachineBasicBlock &MBB) const;
+  virtual void emitBasicBlockStart(const MachineBasicBlock &MBB);
 
   /// Targets can override this to emit stuff at the end of a basic block.
-  virtual void EmitBasicBlockEnd(const MachineBasicBlock &MBB);
+  virtual void emitBasicBlockEnd(const MachineBasicBlock &MBB);
 
   /// Targets should implement this to emit instructions.
-  virtual void EmitInstruction(const MachineInstr *) {
+  virtual void emitInstruction(const MachineInstr *) {
     llvm_unreachable("EmitInstruction not implemented");
   }
 
   /// Return the symbol for the specified constant pool entry.
   virtual MCSymbol *GetCPISymbol(unsigned CPID) const;
 
-  virtual void EmitFunctionEntryLabel();
+  virtual void emitFunctionEntryLabel();
 
-  virtual void EmitMachineConstantPoolValue(MachineConstantPoolValue *MCPV);
+  virtual void emitFunctionDescriptor() {
+    llvm_unreachable("Function descriptor is target-specific.");
+  }
+
+  virtual void emitMachineConstantPoolValue(MachineConstantPoolValue *MCPV);
 
   /// Targets can override this to change how global constants that are part of
   /// a C++ static/global constructor list are emitted.
-  virtual void EmitXXStructor(const DataLayout &DL, const Constant *CV) {
-    EmitGlobalConstant(DL, CV);
+  virtual void emitXXStructor(const DataLayout &DL, const Constant *CV) {
+    emitGlobalConstant(DL, CV);
   }
 
   /// Return true if the basic block has exactly one predecessor and the control
@@ -433,6 +519,9 @@
   /// instructions in verbose mode.
   virtual void emitImplicitDef(const MachineInstr *MI) const;
 
+  /// Emit N NOP instructions.
+  void emitNops(unsigned N);
+
   //===------------------------------------------------------------------===//
   // Symbol Lowering Routines.
   //===------------------------------------------------------------------===//
@@ -481,49 +570,47 @@
   /// Emit something like ".long Hi-Lo" where the size in bytes of the directive
   /// is specified by Size and Hi/Lo specify the labels.  This implicitly uses
   /// .set if it is available.
-  void EmitLabelDifference(const MCSymbol *Hi, const MCSymbol *Lo,
+  void emitLabelDifference(const MCSymbol *Hi, const MCSymbol *Lo,
                            unsigned Size) const;
 
   /// Emit something like ".uleb128 Hi-Lo".
-  void EmitLabelDifferenceAsULEB128(const MCSymbol *Hi,
+  void emitLabelDifferenceAsULEB128(const MCSymbol *Hi,
                                     const MCSymbol *Lo) const;
 
   /// Emit something like ".long Label+Offset" where the size in bytes of the
   /// directive is specified by Size and Label specifies the label.  This
   /// implicitly uses .set if it is available.
-  void EmitLabelPlusOffset(const MCSymbol *Label, uint64_t Offset,
+  void emitLabelPlusOffset(const MCSymbol *Label, uint64_t Offset,
                            unsigned Size, bool IsSectionRelative = false) const;
 
   /// Emit something like ".long Label" where the size in bytes of the directive
   /// is specified by Size and Label specifies the label.
-  void EmitLabelReference(const MCSymbol *Label, unsigned Size,
+  void emitLabelReference(const MCSymbol *Label, unsigned Size,
                           bool IsSectionRelative = false) const {
-    EmitLabelPlusOffset(Label, 0, Size, IsSectionRelative);
+    emitLabelPlusOffset(Label, 0, Size, IsSectionRelative);
   }
 
-  /// Emit something like ".long Label + Offset".
-  void EmitDwarfOffset(const MCSymbol *Label, uint64_t Offset) const;
-
   //===------------------------------------------------------------------===//
   // Dwarf Emission Helper Routines
   //===------------------------------------------------------------------===//
 
   /// Emit the specified signed leb128 value.
-  void EmitSLEB128(int64_t Value, const char *Desc = nullptr) const;
+  void emitSLEB128(int64_t Value, const char *Desc = nullptr) const;
 
   /// Emit the specified unsigned leb128 value.
-  void EmitULEB128(uint64_t Value, const char *Desc = nullptr, unsigned PadTo = 0) const;
+  void emitULEB128(uint64_t Value, const char *Desc = nullptr,
+                   unsigned PadTo = 0) const;
 
   /// Emit a .byte 42 directive that corresponds to an encoding.  If verbose
   /// assembly output is enabled, we output comments describing the encoding.
   /// Desc is a string saying what the encoding is specifying (e.g. "LSDA").
-  void EmitEncodingByte(unsigned Val, const char *Desc = nullptr) const;
+  void emitEncodingByte(unsigned Val, const char *Desc = nullptr) const;
 
   /// Return the size of the encoding in bytes.
   unsigned GetSizeOfEncodedValue(unsigned Encoding) const;
 
   /// Emit reference to a ttype global with a specified encoding.
-  void EmitTTypeReference(const GlobalValue *GV, unsigned Encoding) const;
+  virtual void emitTTypeReference(const GlobalValue *GV, unsigned Encoding);
 
   /// Emit a reference to a symbol for use in dwarf. Different object formats
   /// represent this in different ways. Some use a relocation others encode
@@ -531,18 +618,45 @@
   void emitDwarfSymbolReference(const MCSymbol *Label,
                                 bool ForceOffset = false) const;
 
-  /// Emit the 4-byte offset of a string from the start of its section.
+  /// Emit the 4- or 8-byte offset of a string from the start of its section.
   ///
   /// When possible, emit a DwarfStringPool section offset without any
   /// relocations, and without using the symbol.  Otherwise, defers to \a
   /// emitDwarfSymbolReference().
+  ///
+  /// The length of the emitted value depends on the DWARF format.
   void emitDwarfStringOffset(DwarfStringPoolEntry S) const;
 
-  /// Emit the 4-byte offset of a string from the start of its section.
+  /// Emit the 4-or 8-byte offset of a string from the start of its section.
   void emitDwarfStringOffset(DwarfStringPoolEntryRef S) const {
     emitDwarfStringOffset(S.getEntry());
   }
 
+  /// Emit something like ".long Label + Offset" or ".quad Label + Offset"
+  /// depending on the DWARF format.
+  void emitDwarfOffset(const MCSymbol *Label, uint64_t Offset) const;
+
+  /// Emit 32- or 64-bit value depending on the DWARF format.
+  void emitDwarfLengthOrOffset(uint64_t Value) const;
+
+  /// Emit a special value of 0xffffffff if producing 64-bit debugging info.
+  void maybeEmitDwarf64Mark() const;
+
+  /// Emit a unit length field. The actual format, DWARF32 or DWARF64, is chosen
+  /// according to the settings.
+  void emitDwarfUnitLength(uint64_t Length, const Twine &Comment) const;
+
+  /// Emit a unit length field. The actual format, DWARF32 or DWARF64, is chosen
+  /// according to the settings.
+  void emitDwarfUnitLength(const MCSymbol *Hi, const MCSymbol *Lo,
+                           const Twine &Comment) const;
+
+  /// Emit reference to a call site with a specified encoding
+  void emitCallSiteOffset(const MCSymbol *Hi, const MCSymbol *Lo,
+                          unsigned Encoding) const;
+  /// Emit an integer value corresponding to the call site encoding
+  void emitCallSiteValue(uint64_t Value, unsigned Encoding) const;
+
   /// Get the value for DW_AT_APPLE_isa. Zero if no isa encoding specified.
   virtual unsigned getISAEncoding() { return 0; }
 
@@ -550,7 +664,7 @@
   ///
   /// \p Value - The value to emit.
   /// \p Size - The size of the integer (in bytes) to emit.
-  virtual void EmitDebugValue(const MCExpr *Value, unsigned Size) const;
+  virtual void emitDebugValue(const MCExpr *Value, unsigned Size) const;
 
   //===------------------------------------------------------------------===//
   // Dwarf Lowering Routines
@@ -566,7 +680,7 @@
       emitDwarfAbbrev(*Abbrev);
 
     // Mark end of abbreviations.
-    EmitULEB128(0, "EOM(3)");
+    emitULEB128(0, "EOM(3)");
   }
 
   void emitDwarfAbbrev(const DIEAbbrev &Abbrev) const;
@@ -622,12 +736,16 @@
 
   /// This emits visibility information about symbol, if this is supported by
   /// the target.
-  void EmitVisibility(MCSymbol *Sym, unsigned Visibility,
+  void emitVisibility(MCSymbol *Sym, unsigned Visibility,
                       bool IsDefinition = true) const;
 
   /// This emits linkage information about \p GVSym based on \p GV, if this is
   /// supported by the target.
-  void EmitLinkage(const GlobalValue *GV, MCSymbol *GVSym) const;
+  virtual void emitLinkage(const GlobalValue *GV, MCSymbol *GVSym) const;
+
+  /// Return the alignment for the specified \p GV.
+  static Align getGVAlignment(const GlobalObject *GV, const DataLayout &DL,
+                              Align InAlign = Align(1));
 
 private:
   /// Private state for PrintSpecial()
@@ -637,18 +755,21 @@
   mutable unsigned Counter = ~0U;
 
   /// This method emits the header for the current function.
-  virtual void EmitFunctionHeader();
+  virtual void emitFunctionHeader();
+
+  /// This method emits a comment next to header for the current function.
+  virtual void emitFunctionHeaderComment();
 
   /// Emit a blob of inline asm to the output streamer.
   void
-  EmitInlineAsm(StringRef Str, const MCSubtargetInfo &STI,
+  emitInlineAsm(StringRef Str, const MCSubtargetInfo &STI,
                 const MCTargetOptions &MCOptions,
                 const MDNode *LocMDNode = nullptr,
                 InlineAsm::AsmDialect AsmDialect = InlineAsm::AD_ATT) const;
 
   /// This method formats and emits the specified machine instruction that is an
   /// inline asm.
-  void EmitInlineAsm(const MachineInstr *MI) const;
+  void emitInlineAsm(const MachineInstr *MI) const;
 
   /// Add inline assembly info to the diagnostics machinery, so we can
   /// emit file and position info. Returns SrcMgr memory buffer position.
@@ -659,21 +780,20 @@
   // Internal Implementation Details
   //===------------------------------------------------------------------===//
 
-  void EmitJumpTableEntry(const MachineJumpTableInfo *MJTI,
+  void emitJumpTableEntry(const MachineJumpTableInfo *MJTI,
                           const MachineBasicBlock *MBB, unsigned uid) const;
-  void EmitLLVMUsedList(const ConstantArray *InitList);
+  void emitLLVMUsedList(const ConstantArray *InitList);
   /// Emit llvm.ident metadata in an '.ident' directive.
-  void EmitModuleIdents(Module &M);
+  void emitModuleIdents(Module &M);
   /// Emit bytes for llvm.commandline metadata.
-  void EmitModuleCommandLines(Module &M);
-  void EmitXXStructorList(const DataLayout &DL, const Constant *List,
-                          bool isCtor);
+  void emitModuleCommandLines(Module &M);
 
   GCMetadataPrinter *GetOrCreateGCPrinter(GCStrategy &S);
   /// Emit GlobalAlias or GlobalIFunc.
   void emitGlobalIndirectSymbol(Module &M, const GlobalIndirectSymbol &GIS);
-  void setupCodePaddingContext(const MachineBasicBlock &MBB,
-                               MCCodePaddingContext &Context) const;
+
+  /// This method decides whether the specified basic block requires a label.
+  bool shouldEmitLabelForBasicBlock(const MachineBasicBlock &MBB) const;
 };
 
 } // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/CodeGen/AsmPrinterHandler.h b/linux-x64/clang/include/llvm/CodeGen/AsmPrinterHandler.h
index affb558..dc81a30 100644
--- a/linux-x64/clang/include/llvm/CodeGen/AsmPrinterHandler.h
+++ b/linux-x64/clang/include/llvm/CodeGen/AsmPrinterHandler.h
@@ -23,8 +23,10 @@
 class MachineFunction;
 class MachineInstr;
 class MCSymbol;
+class Module;
 
-typedef MCSymbol *ExceptionSymbolProvider(AsmPrinter *Asm);
+typedef MCSymbol *ExceptionSymbolProvider(AsmPrinter *Asm,
+                                          const MachineBasicBlock *MBB);
 
 /// Collects and handles AsmPrinter objects required to build debug
 /// or EH information.
@@ -36,6 +38,8 @@
   /// this tracks that size.
   virtual void setSymbolSize(const MCSymbol *Sym, uint64_t Size) = 0;
 
+  virtual void beginModule(Module *M) {}
+
   /// Emit all sections that should come after the content.
   virtual void endModule() = 0;
 
@@ -67,7 +71,14 @@
 
   /// Process end of an instruction.
   virtual void endInstruction() = 0;
+
+  /// Process beginning of a basic block during basic block sections.
+  virtual void beginBasicBlock(const MachineBasicBlock &MBB) {}
+
+  /// Process end of a basic block during basic block sections.
+  virtual void endBasicBlock(const MachineBasicBlock &MBB) {}
 };
+
 } // End of namespace llvm
 
 #endif
diff --git a/linux-x64/clang/include/llvm/CodeGen/BasicBlockSectionUtils.h b/linux-x64/clang/include/llvm/CodeGen/BasicBlockSectionUtils.h
new file mode 100644
index 0000000..d8da3be
--- /dev/null
+++ b/linux-x64/clang/include/llvm/CodeGen/BasicBlockSectionUtils.h
@@ -0,0 +1,30 @@
+//===- BasicBlockSectionUtils.h - Utilities for basic block sections     --===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CODEGEN_BASICBLOCKSECTIONUTILS_H
+#define LLVM_CODEGEN_BASICBLOCKSECTIONUTILS_H
+
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/Support/CommandLine.h"
+
+namespace llvm {
+
+extern cl::opt<std::string> BBSectionsColdTextPrefix;
+
+class MachineFunction;
+class MachineBasicBlock;
+
+using MachineBasicBlockComparator =
+    function_ref<bool(const MachineBasicBlock &, const MachineBasicBlock &)>;
+
+void sortBasicBlocksAndUpdateBranches(MachineFunction &MF,
+                                      MachineBasicBlockComparator MBBCmp);
+
+} // end namespace llvm
+
+#endif // LLVM_CODEGEN_BASICBLOCKSECTIONUTILS_H
diff --git a/linux-x64/clang/include/llvm/CodeGen/BasicTTIImpl.h b/linux-x64/clang/include/llvm/CodeGen/BasicTTIImpl.h
index 173be72..9776c20 100644
--- a/linux-x64/clang/include/llvm/CodeGen/BasicTTIImpl.h
+++ b/linux-x64/clang/include/llvm/CodeGen/BasicTTIImpl.h
@@ -29,7 +29,6 @@
 #include "llvm/CodeGen/TargetSubtargetInfo.h"
 #include "llvm/CodeGen/ValueTypes.h"
 #include "llvm/IR/BasicBlock.h"
-#include "llvm/IR/CallSite.h"
 #include "llvm/IR/Constant.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DataLayout.h"
@@ -41,7 +40,6 @@
 #include "llvm/IR/Operator.h"
 #include "llvm/IR/Type.h"
 #include "llvm/IR/Value.h"
-#include "llvm/MC/MCSchedule.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ErrorHandling.h"
@@ -79,27 +77,26 @@
   using BaseT = TargetTransformInfoImplCRTPBase<T>;
   using TTI = TargetTransformInfo;
 
+  /// Helper function to access this as a T.
+  T *thisT() { return static_cast<T *>(this); }
+
   /// Estimate a cost of Broadcast as an extract and sequence of insert
   /// operations.
-  unsigned getBroadcastShuffleOverhead(Type *Ty) {
-    assert(Ty->isVectorTy() && "Can only shuffle vectors");
+  unsigned getBroadcastShuffleOverhead(FixedVectorType *VTy) {
     unsigned Cost = 0;
     // Broadcast cost is equal to the cost of extracting the zero'th element
     // plus the cost of inserting it into every element of the result vector.
-    Cost += static_cast<T *>(this)->getVectorInstrCost(
-        Instruction::ExtractElement, Ty, 0);
+    Cost += thisT()->getVectorInstrCost(Instruction::ExtractElement, VTy, 0);
 
-    for (int i = 0, e = Ty->getVectorNumElements(); i < e; ++i) {
-      Cost += static_cast<T *>(this)->getVectorInstrCost(
-          Instruction::InsertElement, Ty, i);
+    for (int i = 0, e = VTy->getNumElements(); i < e; ++i) {
+      Cost += thisT()->getVectorInstrCost(Instruction::InsertElement, VTy, i);
     }
     return Cost;
   }
 
   /// Estimate a cost of shuffle as a sequence of extract and insert
   /// operations.
-  unsigned getPermuteShuffleOverhead(Type *Ty) {
-    assert(Ty->isVectorTy() && "Can only shuffle vectors");
+  unsigned getPermuteShuffleOverhead(FixedVectorType *VTy) {
     unsigned Cost = 0;
     // Shuffle cost is equal to the cost of extracting element from its argument
     // plus the cost of inserting them onto the result vector.
@@ -108,22 +105,23 @@
     // index 0 of first vector, index 1 of second vector,index 2 of first
     // vector and finally index 3 of second vector and insert them at index
     // <0,1,2,3> of result vector.
-    for (int i = 0, e = Ty->getVectorNumElements(); i < e; ++i) {
-      Cost += static_cast<T *>(this)
-                  ->getVectorInstrCost(Instruction::InsertElement, Ty, i);
-      Cost += static_cast<T *>(this)
-                  ->getVectorInstrCost(Instruction::ExtractElement, Ty, i);
+    for (int i = 0, e = VTy->getNumElements(); i < e; ++i) {
+      Cost += thisT()->getVectorInstrCost(Instruction::InsertElement, VTy, i);
+      Cost += thisT()->getVectorInstrCost(Instruction::ExtractElement, VTy, i);
     }
     return Cost;
   }
 
   /// Estimate a cost of subvector extraction as a sequence of extract and
   /// insert operations.
-  unsigned getExtractSubvectorOverhead(Type *Ty, int Index, Type *SubTy) {
-    assert(Ty && Ty->isVectorTy() && SubTy && SubTy->isVectorTy() &&
+  unsigned getExtractSubvectorOverhead(VectorType *VTy, int Index,
+                                       FixedVectorType *SubVTy) {
+    assert(VTy && SubVTy &&
            "Can only extract subvectors from vectors");
-    int NumSubElts = SubTy->getVectorNumElements();
-    assert((Index + NumSubElts) <= (int)Ty->getVectorNumElements() &&
+    int NumSubElts = SubVTy->getNumElements();
+    assert((!isa<FixedVectorType>(VTy) ||
+            (Index + NumSubElts) <=
+                (int)cast<FixedVectorType>(VTy)->getNumElements()) &&
            "SK_ExtractSubvector index out of range");
 
     unsigned Cost = 0;
@@ -131,21 +129,24 @@
     // the source type plus the cost of inserting them into the result vector
     // type.
     for (int i = 0; i != NumSubElts; ++i) {
-      Cost += static_cast<T *>(this)->getVectorInstrCost(
-          Instruction::ExtractElement, Ty, i + Index);
-      Cost += static_cast<T *>(this)->getVectorInstrCost(
-          Instruction::InsertElement, SubTy, i);
+      Cost += thisT()->getVectorInstrCost(Instruction::ExtractElement, VTy,
+                                          i + Index);
+      Cost +=
+          thisT()->getVectorInstrCost(Instruction::InsertElement, SubVTy, i);
     }
     return Cost;
   }
 
   /// Estimate a cost of subvector insertion as a sequence of extract and
   /// insert operations.
-  unsigned getInsertSubvectorOverhead(Type *Ty, int Index, Type *SubTy) {
-    assert(Ty && Ty->isVectorTy() && SubTy && SubTy->isVectorTy() &&
+  unsigned getInsertSubvectorOverhead(VectorType *VTy, int Index,
+                                      FixedVectorType *SubVTy) {
+    assert(VTy && SubVTy &&
            "Can only insert subvectors into vectors");
-    int NumSubElts = SubTy->getVectorNumElements();
-    assert((Index + NumSubElts) <= (int)Ty->getVectorNumElements() &&
+    int NumSubElts = SubVTy->getNumElements();
+    assert((!isa<FixedVectorType>(VTy) ||
+            (Index + NumSubElts) <=
+                (int)cast<FixedVectorType>(VTy)->getNumElements()) &&
            "SK_InsertSubvector index out of range");
 
     unsigned Cost = 0;
@@ -153,10 +154,10 @@
     // the source type plus the cost of inserting them into the result vector
     // type.
     for (int i = 0; i != NumSubElts; ++i) {
-      Cost += static_cast<T *>(this)->getVectorInstrCost(
-          Instruction::ExtractElement, SubTy, i);
-      Cost += static_cast<T *>(this)->getVectorInstrCost(
-          Instruction::InsertElement, Ty, i + Index);
+      Cost +=
+          thisT()->getVectorInstrCost(Instruction::ExtractElement, SubVTy, i);
+      Cost += thisT()->getVectorInstrCost(Instruction::InsertElement, VTy,
+                                          i + Index);
     }
     return Cost;
   }
@@ -190,6 +191,7 @@
 protected:
   explicit BasicTTIImplBase(const TargetMachine *TM, const DataLayout &DL)
       : BaseT(DL) {}
+  virtual ~BasicTTIImplBase() = default;
 
   using TargetTransformInfoImplBase::DL;
 
@@ -206,6 +208,8 @@
 
   bool hasBranchDivergence() { return false; }
 
+  bool useGPUDivergenceAnalysis() { return false; }
+
   bool isSourceOfDivergence(const Value *V) { return false; }
 
   bool isAlwaysUniform(const Value *V) { return false; }
@@ -215,6 +219,24 @@
     return -1;
   }
 
+  bool collectFlatAddressOperands(SmallVectorImpl<int> &OpIndexes,
+                                  Intrinsic::ID IID) const {
+    return false;
+  }
+
+  bool isNoopAddrSpaceCast(unsigned FromAS, unsigned ToAS) const {
+    return getTLI()->getTargetMachine().isNoopAddrSpaceCast(FromAS, ToAS);
+  }
+
+  unsigned getAssumedAddrSpace(const Value *V) const {
+    return getTLI()->getTargetMachine().getAssumedAddrSpace(V);
+  }
+
+  Value *rewriteIntrinsicWithAddressSpace(IntrinsicInst *II, Value *OldV,
+                                          Value *NewV) const {
+    return nullptr;
+  }
+
   bool isLegalAddImmediate(int64_t imm) {
     return getTLI()->isLegalAddImmediate(imm);
   }
@@ -250,6 +272,14 @@
     return TargetTransformInfoImplBase::isLSRCostLess(C1, C2);
   }
 
+  bool isNumRegsMajorCostOfLSR() {
+    return TargetTransformInfoImplBase::isNumRegsMajorCostOfLSR();
+  }
+
+  bool isProfitableLSRChainElement(Instruction *I) {
+    return TargetTransformInfoImplBase::isProfitableLSRChainElement(I);
+  }
+
   int getScalingFactorCost(Type *Ty, GlobalValue *BaseGV, int64_t BaseOffset,
                            bool HasBaseReg, int64_t Scale, unsigned AddrSpace) {
     TargetLoweringBase::AddrMode AM;
@@ -275,49 +305,21 @@
     return getTLI()->isTypeLegal(VT);
   }
 
+  unsigned getRegUsageForType(Type *Ty) {
+    return getTLI()->getTypeLegalizationCost(DL, Ty).first;
+  }
+
   int getGEPCost(Type *PointeeType, const Value *Ptr,
                  ArrayRef<const Value *> Operands) {
     return BaseT::getGEPCost(PointeeType, Ptr, Operands);
   }
 
-  int getExtCost(const Instruction *I, const Value *Src) {
-    if (getTLI()->isExtFree(I))
-      return TargetTransformInfo::TCC_Free;
-
-    if (isa<ZExtInst>(I) || isa<SExtInst>(I))
-      if (const LoadInst *LI = dyn_cast<LoadInst>(Src))
-        if (getTLI()->isExtLoad(LI, I, DL))
-          return TargetTransformInfo::TCC_Free;
-
-    return TargetTransformInfo::TCC_Basic;
-  }
-
-  unsigned getIntrinsicCost(Intrinsic::ID IID, Type *RetTy,
-                            ArrayRef<const Value *> Arguments, const User *U) {
-    return BaseT::getIntrinsicCost(IID, RetTy, Arguments, U);
-  }
-
-  unsigned getIntrinsicCost(Intrinsic::ID IID, Type *RetTy,
-                            ArrayRef<Type *> ParamTys, const User *U) {
-    if (IID == Intrinsic::cttz) {
-      if (getTLI()->isCheapToSpeculateCttz())
-        return TargetTransformInfo::TCC_Basic;
-      return TargetTransformInfo::TCC_Expensive;
-    }
-
-    if (IID == Intrinsic::ctlz) {
-      if (getTLI()->isCheapToSpeculateCtlz())
-        return TargetTransformInfo::TCC_Basic;
-      return TargetTransformInfo::TCC_Expensive;
-    }
-
-    return BaseT::getIntrinsicCost(IID, RetTy, ParamTys, U);
-  }
-
   unsigned getEstimatedNumberOfCaseClusters(const SwitchInst &SI,
-                                            unsigned &JumpTableSize) {
+                                            unsigned &JumpTableSize,
+                                            ProfileSummaryInfo *PSI,
+                                            BlockFrequencyInfo *BFI) {
     /// Try to find the estimated number of clusters. Note that the number of
-    /// clusters identified in this function could be different from the actural
+    /// clusters identified in this function could be different from the actual
     /// numbers found in lowering. This function ignore switches that are
     /// lowered with a mix of jump table / bit test / BTree. This function was
     /// initially intended to be used when estimating the cost of switch in
@@ -363,7 +365,7 @@
           (MaxCaseVal - MinCaseVal)
               .getLimitedValue(std::numeric_limits<uint64_t>::max() - 1) + 1;
       // Check whether a range of clusters is dense enough for a jump table
-      if (TLI->isSuitableForJumpTable(&SI, N, Range)) {
+      if (TLI->isSuitableForJumpTable(&SI, N, Range, PSI, BFI)) {
         JumpTableSize = Range;
         return 1;
       }
@@ -371,10 +373,6 @@
     return N;
   }
 
-  unsigned getJumpBufAlignment() { return getTLI()->getJumpBufAlignment(); }
-
-  unsigned getJumpBufSize() { return getTLI()->getJumpBufSize(); }
-
   bool shouldBuildLookupTables() {
     const TargetLoweringBase *TLI = getTLI();
     return TLI->isOperationLegalOrCustom(ISD::BR_JT, MVT::Other) ||
@@ -402,31 +400,10 @@
     return TargetTransformInfo::TCC_Expensive;
   }
 
-  unsigned getOperationCost(unsigned Opcode, Type *Ty, Type *OpTy) {
-    const TargetLoweringBase *TLI = getTLI();
-    switch (Opcode) {
-    default: break;
-    case Instruction::Trunc:
-      if (TLI->isTruncateFree(OpTy, Ty))
-        return TargetTransformInfo::TCC_Free;
-      return TargetTransformInfo::TCC_Basic;
-    case Instruction::ZExt:
-      if (TLI->isZExtFree(OpTy, Ty))
-        return TargetTransformInfo::TCC_Free;
-      return TargetTransformInfo::TCC_Basic;
-
-    case Instruction::AddrSpaceCast:
-      if (TLI->isFreeAddrSpaceCast(OpTy->getPointerAddressSpace(),
-                                   Ty->getPointerAddressSpace()))
-        return TargetTransformInfo::TCC_Free;
-      return TargetTransformInfo::TCC_Basic;
-    }
-
-    return BaseT::getOperationCost(Opcode, Ty, OpTy);
-  }
-
   unsigned getInliningThresholdMultiplier() { return 1; }
 
+  int getInlinerVectorBonusPercent() { return 150; }
+
   void getUnrollingPreferences(Loop *L, ScalarEvolution &SE,
                                TTI::UnrollingPreferences &UP) {
     // This unrolling functionality is target independent, but to provide some
@@ -462,20 +439,17 @@
       return;
 
     // Scan the loop: don't unroll loops with calls.
-    for (Loop::block_iterator I = L->block_begin(), E = L->block_end(); I != E;
-         ++I) {
-      BasicBlock *BB = *I;
-
-      for (BasicBlock::iterator J = BB->begin(), JE = BB->end(); J != JE; ++J)
-        if (isa<CallInst>(J) || isa<InvokeInst>(J)) {
-          ImmutableCallSite CS(&*J);
-          if (const Function *F = CS.getCalledFunction()) {
-            if (!static_cast<T *>(this)->isLoweredToCall(F))
+    for (BasicBlock *BB : L->blocks()) {
+      for (Instruction &I : *BB) {
+        if (isa<CallInst>(I) || isa<InvokeInst>(I)) {
+          if (const Function *F = cast<CallBase>(I).getCalledFunction()) {
+            if (!thisT()->isLoweredToCall(F))
               continue;
           }
 
           return;
         }
+      }
     }
 
     // Enable runtime and partial unrolling up to the specified size.
@@ -492,6 +466,14 @@
     UP.BEInsns = 2;
   }
 
+  void getPeelingPreferences(Loop *L, ScalarEvolution &SE,
+                             TTI::PeelingPreferences &PP) {
+    PP.PeelCount = 0;
+    PP.AllowPeeling = true;
+    PP.AllowLoopNestsPeeling = false;
+    PP.PeelProfiledIterations = true;
+  }
+
   bool isHardwareLoopProfitable(Loop *L, ScalarEvolution &SE,
                                 AssumptionCache &AC,
                                 TargetLibraryInfo *LibInfo,
@@ -499,6 +481,41 @@
     return BaseT::isHardwareLoopProfitable(L, SE, AC, LibInfo, HWLoopInfo);
   }
 
+  bool preferPredicateOverEpilogue(Loop *L, LoopInfo *LI, ScalarEvolution &SE,
+                                   AssumptionCache &AC, TargetLibraryInfo *TLI,
+                                   DominatorTree *DT,
+                                   const LoopAccessInfo *LAI) {
+    return BaseT::preferPredicateOverEpilogue(L, LI, SE, AC, TLI, DT, LAI);
+  }
+
+  bool emitGetActiveLaneMask() {
+    return BaseT::emitGetActiveLaneMask();
+  }
+
+  Optional<Instruction *> instCombineIntrinsic(InstCombiner &IC,
+                                               IntrinsicInst &II) {
+    return BaseT::instCombineIntrinsic(IC, II);
+  }
+
+  Optional<Value *> simplifyDemandedUseBitsIntrinsic(InstCombiner &IC,
+                                                     IntrinsicInst &II,
+                                                     APInt DemandedMask,
+                                                     KnownBits &Known,
+                                                     bool &KnownBitsComputed) {
+    return BaseT::simplifyDemandedUseBitsIntrinsic(IC, II, DemandedMask, Known,
+                                                   KnownBitsComputed);
+  }
+
+  Optional<Value *> simplifyDemandedVectorEltsIntrinsic(
+      InstCombiner &IC, IntrinsicInst &II, APInt DemandedElts, APInt &UndefElts,
+      APInt &UndefElts2, APInt &UndefElts3,
+      std::function<void(Instruction *, unsigned, APInt, APInt &)>
+          SimplifyAndSetOp) {
+    return BaseT::simplifyDemandedVectorEltsIntrinsic(
+        IC, II, DemandedElts, UndefElts, UndefElts2, UndefElts3,
+        SimplifyAndSetOp);
+  }
+
   int getInstructionLatency(const Instruction *I) {
     if (isa<LoadInst>(I))
       return getST()->getSchedModel().DefaultLoadLatency;
@@ -506,34 +523,92 @@
     return BaseT::getInstructionLatency(I);
   }
 
+  virtual Optional<unsigned>
+  getCacheSize(TargetTransformInfo::CacheLevel Level) const {
+    return Optional<unsigned>(
+      getST()->getCacheSize(static_cast<unsigned>(Level)));
+  }
+
+  virtual Optional<unsigned>
+  getCacheAssociativity(TargetTransformInfo::CacheLevel Level) const {
+    Optional<unsigned> TargetResult =
+        getST()->getCacheAssociativity(static_cast<unsigned>(Level));
+
+    if (TargetResult)
+      return TargetResult;
+
+    return BaseT::getCacheAssociativity(Level);
+  }
+
+  virtual unsigned getCacheLineSize() const {
+    return getST()->getCacheLineSize();
+  }
+
+  virtual unsigned getPrefetchDistance() const {
+    return getST()->getPrefetchDistance();
+  }
+
+  virtual unsigned getMinPrefetchStride(unsigned NumMemAccesses,
+                                        unsigned NumStridedMemAccesses,
+                                        unsigned NumPrefetches,
+                                        bool HasCall) const {
+    return getST()->getMinPrefetchStride(NumMemAccesses, NumStridedMemAccesses,
+                                         NumPrefetches, HasCall);
+  }
+
+  virtual unsigned getMaxPrefetchIterationsAhead() const {
+    return getST()->getMaxPrefetchIterationsAhead();
+  }
+
+  virtual bool enableWritePrefetching() const {
+    return getST()->enableWritePrefetching();
+  }
+
   /// @}
 
   /// \name Vector TTI Implementations
   /// @{
 
-  unsigned getNumberOfRegisters(bool Vector) { return Vector ? 0 : 1; }
-
   unsigned getRegisterBitWidth(bool Vector) const { return 32; }
 
+  Optional<unsigned> getMaxVScale() const { return None; }
+
   /// Estimate the overhead of scalarizing an instruction. Insert and Extract
-  /// are set if the result needs to be inserted and/or extracted from vectors.
-  unsigned getScalarizationOverhead(Type *Ty, bool Insert, bool Extract) {
-    assert(Ty->isVectorTy() && "Can only scalarize vectors");
+  /// are set if the demanded result elements need to be inserted and/or
+  /// extracted from vectors.
+  unsigned getScalarizationOverhead(VectorType *InTy, const APInt &DemandedElts,
+                                    bool Insert, bool Extract) {
+    /// FIXME: a bitfield is not a reasonable abstraction for talking about
+    /// which elements are needed from a scalable vector
+    auto *Ty = cast<FixedVectorType>(InTy);
+
+    assert(DemandedElts.getBitWidth() == Ty->getNumElements() &&
+           "Vector size mismatch");
+
     unsigned Cost = 0;
 
-    for (int i = 0, e = Ty->getVectorNumElements(); i < e; ++i) {
+    for (int i = 0, e = Ty->getNumElements(); i < e; ++i) {
+      if (!DemandedElts[i])
+        continue;
       if (Insert)
-        Cost += static_cast<T *>(this)
-                    ->getVectorInstrCost(Instruction::InsertElement, Ty, i);
+        Cost += thisT()->getVectorInstrCost(Instruction::InsertElement, Ty, i);
       if (Extract)
-        Cost += static_cast<T *>(this)
-                    ->getVectorInstrCost(Instruction::ExtractElement, Ty, i);
+        Cost += thisT()->getVectorInstrCost(Instruction::ExtractElement, Ty, i);
     }
 
     return Cost;
   }
 
-  /// Estimate the overhead of scalarizing an instructions unique
+  /// Helper wrapper for the DemandedElts variant of getScalarizationOverhead.
+  unsigned getScalarizationOverhead(VectorType *InTy, bool Insert,
+                                    bool Extract) {
+    auto *Ty = cast<FixedVectorType>(InTy);
+
+    APInt DemandedElts = APInt::getAllOnesValue(Ty->getNumElements());
+    return thisT()->getScalarizationOverhead(Ty, DemandedElts, Insert, Extract);
+  }
+
+  /// Estimate the overhead of scalarizing an instruction's unique
   /// non-constant operands. The types of the arguments are ordinarily
   /// scalar, in which case the costs are multiplied with VF.
   unsigned getOperandsScalarizationOverhead(ArrayRef<const Value *> Args,
@@ -541,16 +616,22 @@
     unsigned Cost = 0;
     SmallPtrSet<const Value*, 4> UniqueOperands;
     for (const Value *A : Args) {
+      // Disregard things like metadata arguments.
+      Type *Ty = A->getType();
+      if (!Ty->isIntOrIntVectorTy() && !Ty->isFPOrFPVectorTy() &&
+          !Ty->isPtrOrPtrVectorTy())
+        continue;
+
       if (!isa<Constant>(A) && UniqueOperands.insert(A).second) {
-        Type *VecTy = nullptr;
-        if (A->getType()->isVectorTy()) {
-          VecTy = A->getType();
+        auto *VecTy = dyn_cast<VectorType>(Ty);
+        if (VecTy) {
           // If A is a vector operand, VF should be 1 or correspond to A.
-          assert((VF == 1 || VF == VecTy->getVectorNumElements()) &&
+          assert((VF == 1 ||
+                  VF == cast<FixedVectorType>(VecTy)->getNumElements()) &&
                  "Vector argument does not match VF");
         }
         else
-          VecTy = VectorType::get(A->getType(), VF);
+          VecTy = FixedVectorType::get(Ty, VF);
 
         Cost += getScalarizationOverhead(VecTy, false, true);
       }
@@ -559,19 +640,19 @@
     return Cost;
   }
 
-  unsigned getScalarizationOverhead(Type *VecTy, ArrayRef<const Value *> Args) {
-    assert(VecTy->isVectorTy());
+  unsigned getScalarizationOverhead(VectorType *InTy,
+                                    ArrayRef<const Value *> Args) {
+    auto *Ty = cast<FixedVectorType>(InTy);
 
     unsigned Cost = 0;
 
-    Cost += getScalarizationOverhead(VecTy, true, false);
+    Cost += getScalarizationOverhead(Ty, true, false);
     if (!Args.empty())
-      Cost += getOperandsScalarizationOverhead(Args,
-                                               VecTy->getVectorNumElements());
+      Cost += getOperandsScalarizationOverhead(Args, Ty->getNumElements());
     else
       // When no information on arguments is provided, we add the cost
       // associated with one argument as a heuristic.
-      Cost += getScalarizationOverhead(VecTy, false, true);
+      Cost += getScalarizationOverhead(Ty, false, true);
 
     return Cost;
   }
@@ -580,16 +661,25 @@
 
   unsigned getArithmeticInstrCost(
       unsigned Opcode, Type *Ty,
+      TTI::TargetCostKind CostKind = TTI::TCK_RecipThroughput,
       TTI::OperandValueKind Opd1Info = TTI::OK_AnyValue,
       TTI::OperandValueKind Opd2Info = TTI::OK_AnyValue,
       TTI::OperandValueProperties Opd1PropInfo = TTI::OP_None,
       TTI::OperandValueProperties Opd2PropInfo = TTI::OP_None,
-      ArrayRef<const Value *> Args = ArrayRef<const Value *>()) {
+      ArrayRef<const Value *> Args = ArrayRef<const Value *>(),
+      const Instruction *CxtI = nullptr) {
     // Check if any of the operands are vector operands.
     const TargetLoweringBase *TLI = getTLI();
     int ISD = TLI->InstructionOpcodeToISD(Opcode);
     assert(ISD && "Invalid opcode");
 
+    // TODO: Handle more cost kinds.
+    if (CostKind != TTI::TCK_RecipThroughput)
+      return BaseT::getArithmeticInstrCost(Opcode, Ty, CostKind,
+                                           Opd1Info, Opd2Info,
+                                           Opd1PropInfo, Opd2PropInfo,
+                                           Args, CxtI);
+
     std::pair<unsigned, MVT> LT = TLI->getTypeLegalizationCost(DL, Ty);
 
     bool IsFloat = Ty->isFPOrFPVectorTy();
@@ -612,91 +702,115 @@
     // Else, assume that we need to scalarize this op.
     // TODO: If one of the types get legalized by splitting, handle this
     // similarly to what getCastInstrCost() does.
-    if (Ty->isVectorTy()) {
-      unsigned Num = Ty->getVectorNumElements();
-      unsigned Cost = static_cast<T *>(this)
-                          ->getArithmeticInstrCost(Opcode, Ty->getScalarType());
+    if (auto *VTy = dyn_cast<VectorType>(Ty)) {
+      unsigned Num = cast<FixedVectorType>(VTy)->getNumElements();
+      unsigned Cost = thisT()->getArithmeticInstrCost(
+          Opcode, VTy->getScalarType(), CostKind, Opd1Info, Opd2Info,
+          Opd1PropInfo, Opd2PropInfo, Args, CxtI);
       // Return the cost of multiple scalar invocation plus the cost of
       // inserting and extracting the values.
-      return getScalarizationOverhead(Ty, Args) + Num * Cost;
+      return getScalarizationOverhead(VTy, Args) + Num * Cost;
     }
 
     // We don't know anything about this scalar instruction.
     return OpCost;
   }
 
-  unsigned getShuffleCost(TTI::ShuffleKind Kind, Type *Tp, int Index,
-                          Type *SubTp) {
+  unsigned getShuffleCost(TTI::ShuffleKind Kind, VectorType *Tp, int Index,
+                          VectorType *SubTp) {
+
     switch (Kind) {
     case TTI::SK_Broadcast:
-      return getBroadcastShuffleOverhead(Tp);
+      return getBroadcastShuffleOverhead(cast<FixedVectorType>(Tp));
     case TTI::SK_Select:
     case TTI::SK_Reverse:
     case TTI::SK_Transpose:
     case TTI::SK_PermuteSingleSrc:
     case TTI::SK_PermuteTwoSrc:
-      return getPermuteShuffleOverhead(Tp);
+      return getPermuteShuffleOverhead(cast<FixedVectorType>(Tp));
     case TTI::SK_ExtractSubvector:
-      return getExtractSubvectorOverhead(Tp, Index, SubTp);
+      return getExtractSubvectorOverhead(Tp, Index,
+                                         cast<FixedVectorType>(SubTp));
     case TTI::SK_InsertSubvector:
-      return getInsertSubvectorOverhead(Tp, Index, SubTp);
+      return getInsertSubvectorOverhead(Tp, Index,
+                                        cast<FixedVectorType>(SubTp));
     }
     llvm_unreachable("Unknown TTI::ShuffleKind");
   }
 
   unsigned getCastInstrCost(unsigned Opcode, Type *Dst, Type *Src,
+                            TTI::CastContextHint CCH,
+                            TTI::TargetCostKind CostKind,
                             const Instruction *I = nullptr) {
+    if (BaseT::getCastInstrCost(Opcode, Dst, Src, CCH, CostKind, I) == 0)
+      return 0;
+
     const TargetLoweringBase *TLI = getTLI();
     int ISD = TLI->InstructionOpcodeToISD(Opcode);
     assert(ISD && "Invalid opcode");
     std::pair<unsigned, MVT> SrcLT = TLI->getTypeLegalizationCost(DL, Src);
     std::pair<unsigned, MVT> DstLT = TLI->getTypeLegalizationCost(DL, Dst);
 
-    // Check for NOOP conversions.
-    if (SrcLT.first == DstLT.first &&
-        SrcLT.second.getSizeInBits() == DstLT.second.getSizeInBits()) {
+    TypeSize SrcSize = SrcLT.second.getSizeInBits();
+    TypeSize DstSize = DstLT.second.getSizeInBits();
+    bool IntOrPtrSrc = Src->isIntegerTy() || Src->isPointerTy();
+    bool IntOrPtrDst = Dst->isIntegerTy() || Dst->isPointerTy();
 
-      // Bitcast between types that are legalized to the same type are free.
-      if (Opcode == Instruction::BitCast || Opcode == Instruction::Trunc)
+    switch (Opcode) {
+    default:
+      break;
+    case Instruction::Trunc:
+      // Check for NOOP conversions.
+      if (TLI->isTruncateFree(SrcLT.second, DstLT.second))
         return 0;
-    }
+      LLVM_FALLTHROUGH;
+    case Instruction::BitCast:
+      // Bitcast between types that are legalized to the same type are free and
+      // assume int to/from ptr of the same size is also free.
+      if (SrcLT.first == DstLT.first && IntOrPtrSrc == IntOrPtrDst &&
+          SrcSize == DstSize)
+        return 0;
+      break;
+    case Instruction::FPExt:
+      if (I && getTLI()->isExtFree(I))
+        return 0;
+      break;
+    case Instruction::ZExt:
+      if (TLI->isZExtFree(SrcLT.second, DstLT.second))
+        return 0;
+      LLVM_FALLTHROUGH;
+    case Instruction::SExt:
+      if (I && getTLI()->isExtFree(I))
+        return 0;
 
-    if (Opcode == Instruction::Trunc &&
-        TLI->isTruncateFree(SrcLT.second, DstLT.second))
-      return 0;
-
-    if (Opcode == Instruction::ZExt &&
-        TLI->isZExtFree(SrcLT.second, DstLT.second))
-      return 0;
-
-    if (Opcode == Instruction::AddrSpaceCast &&
-        TLI->isFreeAddrSpaceCast(Src->getPointerAddressSpace(),
-                                 Dst->getPointerAddressSpace()))
-      return 0;
-
-    // If this is a zext/sext of a load, return 0 if the corresponding
-    // extending load exists on target.
-    if ((Opcode == Instruction::ZExt || Opcode == Instruction::SExt) &&
-        I && isa<LoadInst>(I->getOperand(0))) {
+      // If this is a zext/sext of a load, return 0 if the corresponding
+      // extending load exists on target.
+      if (CCH == TTI::CastContextHint::Normal) {
         EVT ExtVT = EVT::getEVT(Dst);
         EVT LoadVT = EVT::getEVT(Src);
         unsigned LType =
           ((Opcode == Instruction::ZExt) ? ISD::ZEXTLOAD : ISD::SEXTLOAD);
         if (TLI->isLoadExtLegal(LType, ExtVT, LoadVT))
           return 0;
+      }
+      break;
+    case Instruction::AddrSpaceCast:
+      if (TLI->isFreeAddrSpaceCast(Src->getPointerAddressSpace(),
+                                   Dst->getPointerAddressSpace()))
+        return 0;
+      break;
     }
 
+    auto *SrcVTy = dyn_cast<VectorType>(Src);
+    auto *DstVTy = dyn_cast<VectorType>(Dst);
+
     // If the cast is marked as legal (or promote) then assume low cost.
     if (SrcLT.first == DstLT.first &&
         TLI->isOperationLegalOrPromote(ISD, DstLT.second))
-      return 1;
+      return SrcLT.first;
 
     // Handle scalar conversions.
-    if (!Src->isVectorTy() && !Dst->isVectorTy()) {
-      // Scalar bitcasts are usually free.
-      if (Opcode == Instruction::BitCast)
-        return 0;
-
+    if (!SrcVTy && !DstVTy) {
       // Just check the op cost. If the operation is legal then assume it costs
       // 1.
       if (!TLI->isOperationExpand(ISD, DstLT.second))
@@ -707,18 +821,17 @@
     }
 
     // Check vector-to-vector casts.
-    if (Dst->isVectorTy() && Src->isVectorTy()) {
+    if (DstVTy && SrcVTy) {
       // If the cast is between same-sized registers, then the check is simple.
-      if (SrcLT.first == DstLT.first &&
-          SrcLT.second.getSizeInBits() == DstLT.second.getSizeInBits()) {
+      if (SrcLT.first == DstLT.first && SrcSize == DstSize) {
 
         // Assume that Zext is done using AND.
         if (Opcode == Instruction::ZExt)
-          return 1;
+          return SrcLT.first;
 
         // Assume that sext is done using SHL and SRA.
         if (Opcode == Instruction::SExt)
-          return 2;
+          return SrcLT.first * 2;
 
         // Just check the op cost. If the operation is legal then assume it
         // costs
@@ -731,63 +844,75 @@
       // of casting the original vector twice. We also need to factor in the
       // cost of the split itself. Count that as 1, to be consistent with
       // TLI->getTypeLegalizationCost().
-      if ((TLI->getTypeAction(Src->getContext(), TLI->getValueType(DL, Src)) ==
-           TargetLowering::TypeSplitVector) ||
-          (TLI->getTypeAction(Dst->getContext(), TLI->getValueType(DL, Dst)) ==
-           TargetLowering::TypeSplitVector)) {
-        Type *SplitDst = VectorType::get(Dst->getVectorElementType(),
-                                         Dst->getVectorNumElements() / 2);
-        Type *SplitSrc = VectorType::get(Src->getVectorElementType(),
-                                         Src->getVectorNumElements() / 2);
+      bool SplitSrc =
+          TLI->getTypeAction(Src->getContext(), TLI->getValueType(DL, Src)) ==
+          TargetLowering::TypeSplitVector;
+      bool SplitDst =
+          TLI->getTypeAction(Dst->getContext(), TLI->getValueType(DL, Dst)) ==
+          TargetLowering::TypeSplitVector;
+      if ((SplitSrc || SplitDst) &&
+          cast<FixedVectorType>(SrcVTy)->getNumElements() > 1 &&
+          cast<FixedVectorType>(DstVTy)->getNumElements() > 1) {
+        Type *SplitDstTy = VectorType::getHalfElementsVectorType(DstVTy);
+        Type *SplitSrcTy = VectorType::getHalfElementsVectorType(SrcVTy);
         T *TTI = static_cast<T *>(this);
-        return TTI->getVectorSplitCost() +
-               (2 * TTI->getCastInstrCost(Opcode, SplitDst, SplitSrc, I));
+        // If both types need to be split then the split is free.
+        unsigned SplitCost =
+            (!SplitSrc || !SplitDst) ? TTI->getVectorSplitCost() : 0;
+        return SplitCost +
+               (2 * TTI->getCastInstrCost(Opcode, SplitDstTy, SplitSrcTy, CCH,
+                                          CostKind, I));
       }
 
       // In other cases where the source or destination are illegal, assume
       // the operation will get scalarized.
-      unsigned Num = Dst->getVectorNumElements();
-      unsigned Cost = static_cast<T *>(this)->getCastInstrCost(
-          Opcode, Dst->getScalarType(), Src->getScalarType(), I);
+      unsigned Num = cast<FixedVectorType>(DstVTy)->getNumElements();
+      unsigned Cost = thisT()->getCastInstrCost(
+          Opcode, Dst->getScalarType(), Src->getScalarType(), CCH, CostKind, I);
 
       // Return the cost of multiple scalar invocation plus the cost of
       // inserting and extracting the values.
-      return getScalarizationOverhead(Dst, true, true) + Num * Cost;
+      return getScalarizationOverhead(DstVTy, true, true) + Num * Cost;
     }
 
     // We already handled vector-to-vector and scalar-to-scalar conversions.
     // This
     // is where we handle bitcast between vectors and scalars. We need to assume
     //  that the conversion is scalarized in one way or another.
-    if (Opcode == Instruction::BitCast)
+    if (Opcode == Instruction::BitCast) {
       // Illegal bitcasts are done by storing and loading from a stack slot.
-      return (Src->isVectorTy() ? getScalarizationOverhead(Src, false, true)
-                                : 0) +
-             (Dst->isVectorTy() ? getScalarizationOverhead(Dst, true, false)
-                                : 0);
+      return (SrcVTy ? getScalarizationOverhead(SrcVTy, false, true) : 0) +
+             (DstVTy ? getScalarizationOverhead(DstVTy, true, false) : 0);
+    }
 
     llvm_unreachable("Unhandled cast");
   }
 
   unsigned getExtractWithExtendCost(unsigned Opcode, Type *Dst,
                                     VectorType *VecTy, unsigned Index) {
-    return static_cast<T *>(this)->getVectorInstrCost(
-               Instruction::ExtractElement, VecTy, Index) +
-           static_cast<T *>(this)->getCastInstrCost(Opcode, Dst,
-                                                    VecTy->getElementType());
+    return thisT()->getVectorInstrCost(Instruction::ExtractElement, VecTy,
+                                       Index) +
+           thisT()->getCastInstrCost(Opcode, Dst, VecTy->getElementType(),
+                                     TTI::CastContextHint::None, TTI::TCK_RecipThroughput);
   }
 
-  unsigned getCFInstrCost(unsigned Opcode) {
-    // Branches are assumed to be predicted.
-    return 0;
+  unsigned getCFInstrCost(unsigned Opcode, TTI::TargetCostKind CostKind) {
+    return BaseT::getCFInstrCost(Opcode, CostKind);
   }
 
   unsigned getCmpSelInstrCost(unsigned Opcode, Type *ValTy, Type *CondTy,
-                              const Instruction *I) {
+                              CmpInst::Predicate VecPred,
+                              TTI::TargetCostKind CostKind,
+                              const Instruction *I = nullptr) {
     const TargetLoweringBase *TLI = getTLI();
     int ISD = TLI->InstructionOpcodeToISD(Opcode);
     assert(ISD && "Invalid opcode");
 
+    // TODO: Handle other cost kinds.
+    if (CostKind != TTI::TCK_RecipThroughput)
+      return BaseT::getCmpSelInstrCost(Opcode, ValTy, CondTy, VecPred, CostKind,
+                                       I);
+
     // Selects on vectors are actually vector selects.
     if (ISD == ISD::SELECT) {
       assert(CondTy && "CondTy must exist");
@@ -806,16 +931,16 @@
     // Otherwise, assume that the cast is scalarized.
     // TODO: If one of the types get legalized by splitting, handle this
     // similarly to what getCastInstrCost() does.
-    if (ValTy->isVectorTy()) {
-      unsigned Num = ValTy->getVectorNumElements();
+    if (auto *ValVTy = dyn_cast<VectorType>(ValTy)) {
+      unsigned Num = cast<FixedVectorType>(ValVTy)->getNumElements();
       if (CondTy)
         CondTy = CondTy->getScalarType();
-      unsigned Cost = static_cast<T *>(this)->getCmpSelInstrCost(
-          Opcode, ValTy->getScalarType(), CondTy, I);
+      unsigned Cost = thisT()->getCmpSelInstrCost(
+          Opcode, ValVTy->getScalarType(), CondTy, VecPred, CostKind, I);
 
       // Return the cost of multiple scalar invocation plus the cost of
       // inserting and extracting the values.
-      return getScalarizationOverhead(ValTy, true, false) + Num * Cost;
+      return getScalarizationOverhead(ValVTy, true, false) + Num * Cost;
     }
 
     // Unknown scalar opcode.
@@ -829,16 +954,27 @@
     return LT.first;
   }
 
-  unsigned getMemoryOpCost(unsigned Opcode, Type *Src, unsigned Alignment,
-                       unsigned AddressSpace, const Instruction *I = nullptr) {
+  unsigned getMemoryOpCost(unsigned Opcode, Type *Src, MaybeAlign Alignment,
+                           unsigned AddressSpace,
+                           TTI::TargetCostKind CostKind,
+                           const Instruction *I = nullptr) {
     assert(!Src->isVoidTy() && "Invalid type");
+    // Assume types, such as structs, are expensive.
+    if (getTLI()->getValueType(DL, Src,  true) == MVT::Other)
+      return 4;
     std::pair<unsigned, MVT> LT = getTLI()->getTypeLegalizationCost(DL, Src);
 
     // Assuming that all loads of legal types cost 1.
     unsigned Cost = LT.first;
+    if (CostKind != TTI::TCK_RecipThroughput)
+      return Cost;
 
     if (Src->isVectorTy() &&
-        Src->getPrimitiveSizeInBits() < LT.second.getSizeInBits()) {
+        // In practice it's not currently possible to have a change in lane
+        // length for extending loads or truncating stores so both types should
+        // have the same scalable property.
+        TypeSize::isKnownLT(Src->getPrimitiveSizeInBits(),
+                            LT.second.getSizeInBits())) {
       // This is a vector load that legalizes to a larger type than the vector
       // itself. Unless the corresponding extending load or truncating store is
       // legal, then this will scalarize.
@@ -852,7 +988,8 @@
       if (LA != TargetLowering::Legal && LA != TargetLowering::Custom) {
         // This is a vector load/store for some illegal type that is scalarized.
         // We must account for the cost of building or decomposing the vector.
-        Cost += getScalarizationOverhead(Src, Opcode != Instruction::Store,
+        Cost += getScalarizationOverhead(cast<VectorType>(Src),
+                                         Opcode != Instruction::Store,
                                          Opcode == Instruction::Store);
       }
     }
@@ -860,35 +997,76 @@
     return Cost;
   }
 
-  unsigned getInterleavedMemoryOpCost(unsigned Opcode, Type *VecTy,
-                                      unsigned Factor,
-                                      ArrayRef<unsigned> Indices,
-                                      unsigned Alignment, unsigned AddressSpace,
-                                      bool UseMaskForCond = false,
-                                      bool UseMaskForGaps = false) {
-    VectorType *VT = dyn_cast<VectorType>(VecTy);
-    assert(VT && "Expect a vector type for interleaved memory op");
+  unsigned getGatherScatterOpCost(unsigned Opcode, Type *DataTy,
+                                  const Value *Ptr, bool VariableMask,
+                                  Align Alignment, TTI::TargetCostKind CostKind,
+                                  const Instruction *I = nullptr) {
+    auto *VT = cast<FixedVectorType>(DataTy);
+    // Assume the target does not have support for gather/scatter operations
+    // and provide a rough estimate.
+    //
+    // First, compute the cost of extracting the individual addresses and the
+    // individual memory operations.
+    int LoadCost =
+        VT->getNumElements() *
+        (getVectorInstrCost(
+             Instruction::ExtractElement,
+             FixedVectorType::get(PointerType::get(VT->getElementType(), 0),
+                                  VT->getNumElements()),
+             -1) +
+         getMemoryOpCost(Opcode, VT->getElementType(), Alignment, 0, CostKind));
+
+    // Next, compute the cost of packing the result in a vector.
+    int PackingCost = getScalarizationOverhead(VT, Opcode != Instruction::Store,
+                                               Opcode == Instruction::Store);
+
+    int ConditionalCost = 0;
+    if (VariableMask) {
+      // Compute the cost of conditionally executing the memory operations with
+      // variable masks. This includes extracting the individual conditions, a
+      // branches and PHIs to combine the results.
+      // NOTE: Estimating the cost of conditionally executing the memory
+      // operations accurately is quite difficult and the current solution
+      // provides a very rough estimate only.
+      ConditionalCost =
+          VT->getNumElements() *
+          (getVectorInstrCost(
+               Instruction::ExtractElement,
+               FixedVectorType::get(Type::getInt1Ty(DataTy->getContext()),
+                                    VT->getNumElements()),
+               -1) +
+           getCFInstrCost(Instruction::Br, CostKind) +
+           getCFInstrCost(Instruction::PHI, CostKind));
+    }
+
+    return LoadCost + PackingCost + ConditionalCost;
+  }
+
+  unsigned getInterleavedMemoryOpCost(
+      unsigned Opcode, Type *VecTy, unsigned Factor, ArrayRef<unsigned> Indices,
+      Align Alignment, unsigned AddressSpace, TTI::TargetCostKind CostKind,
+      bool UseMaskForCond = false, bool UseMaskForGaps = false) {
+    auto *VT = cast<FixedVectorType>(VecTy);
 
     unsigned NumElts = VT->getNumElements();
     assert(Factor > 1 && NumElts % Factor == 0 && "Invalid interleave factor");
 
     unsigned NumSubElts = NumElts / Factor;
-    VectorType *SubVT = VectorType::get(VT->getElementType(), NumSubElts);
+    auto *SubVT = FixedVectorType::get(VT->getElementType(), NumSubElts);
 
     // Firstly, the cost of load/store operation.
     unsigned Cost;
     if (UseMaskForCond || UseMaskForGaps)
-      Cost = static_cast<T *>(this)->getMaskedMemoryOpCost(
-          Opcode, VecTy, Alignment, AddressSpace);
+      Cost = thisT()->getMaskedMemoryOpCost(Opcode, VecTy, Alignment,
+                                            AddressSpace, CostKind);
     else
-      Cost = static_cast<T *>(this)->getMemoryOpCost(Opcode, VecTy, Alignment,
-                                                     AddressSpace);
+      Cost = thisT()->getMemoryOpCost(Opcode, VecTy, Alignment, AddressSpace,
+                                      CostKind);
 
     // Legalize the vector type, and get the legalized and unlegalized type
     // sizes.
     MVT VecTyLT = getTLI()->getTypeLegalizationCost(DL, VecTy).second;
-    unsigned VecTySize =
-        static_cast<T *>(this)->getDataLayout().getTypeStoreSize(VecTy);
+    unsigned VecTySize = thisT()->getDataLayout().getTypeStoreSize(VecTy);
     unsigned VecTyLTSize = VecTyLT.getStoreSize();
 
     // Return the ceiling of dividing A by B.
@@ -947,14 +1125,14 @@
 
         // Extract elements from loaded vector for each sub vector.
         for (unsigned i = 0; i < NumSubElts; i++)
-          Cost += static_cast<T *>(this)->getVectorInstrCost(
-              Instruction::ExtractElement, VT, Index + i * Factor);
+          Cost += thisT()->getVectorInstrCost(Instruction::ExtractElement, VT,
+                                              Index + i * Factor);
       }
 
       unsigned InsSubCost = 0;
       for (unsigned i = 0; i < NumSubElts; i++)
-        InsSubCost += static_cast<T *>(this)->getVectorInstrCost(
-            Instruction::InsertElement, SubVT, i);
+        InsSubCost +=
+            thisT()->getVectorInstrCost(Instruction::InsertElement, SubVT, i);
 
       Cost += Indices.size() * InsSubCost;
     } else {
@@ -969,8 +1147,8 @@
 
       unsigned ExtSubCost = 0;
       for (unsigned i = 0; i < NumSubElts; i++)
-        ExtSubCost += static_cast<T *>(this)->getVectorInstrCost(
-            Instruction::ExtractElement, SubVT, i);
+        ExtSubCost +=
+            thisT()->getVectorInstrCost(Instruction::ExtractElement, SubVT, i);
       Cost += ExtSubCost * Factor;
 
       for (unsigned i = 0; i < NumElts; i++)
@@ -982,8 +1160,8 @@
       return Cost;
 
     Type *I8Type = Type::getInt8Ty(VT->getContext());
-    VectorType *MaskVT = VectorType::get(I8Type, NumElts);
-    SubVT = VectorType::get(I8Type, NumSubElts);
+    auto *MaskVT = FixedVectorType::get(I8Type, NumElts);
+    SubVT = FixedVectorType::get(I8Type, NumSubElts);
 
     // The Mask shuffling cost is extract all the elements of the Mask
     // and insert each of them Factor times into the wide vector:
@@ -996,12 +1174,12 @@
     // vector and insert them factor times into the <24xi1> shuffled mask
     // vector.
     for (unsigned i = 0; i < NumSubElts; i++)
-      Cost += static_cast<T *>(this)->getVectorInstrCost(
-          Instruction::ExtractElement, SubVT, i);
+      Cost +=
+          thisT()->getVectorInstrCost(Instruction::ExtractElement, SubVT, i);
 
     for (unsigned i = 0; i < NumElts; i++)
-      Cost += static_cast<T *>(this)->getVectorInstrCost(
-          Instruction::InsertElement, MaskVT, i);
+      Cost +=
+          thisT()->getVectorInstrCost(Instruction::InsertElement, MaskVT, i);
 
     // The Gaps mask is invariant and created outside the loop, therefore the
     // cost of creating it is not accounted for here. However if we have both
@@ -1009,82 +1187,127 @@
     // memory access, we need to account for the cost of And-ing the two masks
     // inside the loop.
     if (UseMaskForGaps)
-      Cost += static_cast<T *>(this)->getArithmeticInstrCost(
-          BinaryOperator::And, MaskVT);
+      Cost += thisT()->getArithmeticInstrCost(BinaryOperator::And, MaskVT,
+                                              CostKind);
 
     return Cost;
   }
 
   /// Get intrinsic cost based on arguments.
-  unsigned getIntrinsicInstrCost(Intrinsic::ID IID, Type *RetTy,
-                                 ArrayRef<Value *> Args, FastMathFlags FMF,
-                                 unsigned VF = 1) {
-    unsigned RetVF = (RetTy->isVectorTy() ? RetTy->getVectorNumElements() : 1);
-    assert((RetVF == 1 || VF == 1) && "VF > 1 and RetVF is a vector type");
-    auto *ConcreteTTI = static_cast<T *>(this);
+  unsigned getIntrinsicInstrCost(const IntrinsicCostAttributes &ICA,
+                                 TTI::TargetCostKind CostKind) {
+    // Check for generically free intrinsics.
+    if (BaseT::getIntrinsicInstrCost(ICA, CostKind) == 0)
+      return 0;
 
+    // Assume that target intrinsics are cheap.
+    Intrinsic::ID IID = ICA.getID();
+    if (Function::isTargetIntrinsic(IID))
+      return TargetTransformInfo::TCC_Basic;
+
+    if (ICA.isTypeBasedOnly())
+      return getTypeBasedIntrinsicInstrCost(ICA, CostKind);
+
+    Type *RetTy = ICA.getReturnType();
+
+    ElementCount VF = ICA.getVectorFactor();
+    ElementCount RetVF =
+        (RetTy->isVectorTy() ? cast<VectorType>(RetTy)->getElementCount()
+                             : ElementCount::getFixed(1));
+    assert((RetVF.isScalar() || VF.isScalar()) &&
+           "VF > 1 and RetVF is a vector type");
+    const IntrinsicInst *I = ICA.getInst();
+    const SmallVectorImpl<const Value *> &Args = ICA.getArgs();
+    FastMathFlags FMF = ICA.getFlags();
     switch (IID) {
-    default: {
-      // Assume that we need to scalarize this intrinsic.
-      SmallVector<Type *, 4> Types;
-      for (Value *Op : Args) {
-        Type *OpTy = Op->getType();
-        assert(VF == 1 || !OpTy->isVectorTy());
-        Types.push_back(VF == 1 ? OpTy : VectorType::get(OpTy, VF));
-      }
+    default:
+      break;
 
-      if (VF > 1 && !RetTy->isVoidTy())
-        RetTy = VectorType::get(RetTy, VF);
+    case Intrinsic::cttz:
+      // FIXME: If necessary, this should go in target-specific overrides.
+      if (VF.isScalar() && RetVF.isScalar() &&
+          getTLI()->isCheapToSpeculateCttz())
+        return TargetTransformInfo::TCC_Basic;
+      break;
 
-      // Compute the scalarization overhead based on Args for a vector
-      // intrinsic. A vectorizer will pass a scalar RetTy and VF > 1, while
-      // CostModel will pass a vector RetTy and VF is 1.
-      unsigned ScalarizationCost = std::numeric_limits<unsigned>::max();
-      if (RetVF > 1 || VF > 1) {
-        ScalarizationCost = 0;
-        if (!RetTy->isVoidTy())
-          ScalarizationCost += getScalarizationOverhead(RetTy, true, false);
-        ScalarizationCost += getOperandsScalarizationOverhead(Args, VF);
-      }
+    case Intrinsic::ctlz:
+      // FIXME: If necessary, this should go in target-specific overrides.
+      if (VF.isScalar() && RetVF.isScalar() &&
+          getTLI()->isCheapToSpeculateCtlz())
+        return TargetTransformInfo::TCC_Basic;
+      break;
 
-      return ConcreteTTI->getIntrinsicInstrCost(IID, RetTy, Types, FMF,
-                                                ScalarizationCost);
-    }
+    case Intrinsic::memcpy:
+      return thisT()->getMemcpyCost(ICA.getInst());
+
     case Intrinsic::masked_scatter: {
-      assert(VF == 1 && "Can't vectorize types here.");
-      Value *Mask = Args[3];
+      assert(VF.isScalar() && "Can't vectorize types here.");
+      const Value *Mask = Args[3];
       bool VarMask = !isa<Constant>(Mask);
-      unsigned Alignment = cast<ConstantInt>(Args[2])->getZExtValue();
-      return ConcreteTTI->getGatherScatterOpCost(
-          Instruction::Store, Args[0]->getType(), Args[1], VarMask, Alignment);
+      Align Alignment = cast<ConstantInt>(Args[2])->getAlignValue();
+      return thisT()->getGatherScatterOpCost(Instruction::Store,
+                                             Args[0]->getType(), Args[1],
+                                             VarMask, Alignment, CostKind, I);
     }
     case Intrinsic::masked_gather: {
-      assert(VF == 1 && "Can't vectorize types here.");
-      Value *Mask = Args[2];
+      assert(VF.isScalar() && "Can't vectorize types here.");
+      const Value *Mask = Args[2];
       bool VarMask = !isa<Constant>(Mask);
-      unsigned Alignment = cast<ConstantInt>(Args[1])->getZExtValue();
-      return ConcreteTTI->getGatherScatterOpCost(Instruction::Load, RetTy,
-                                                 Args[0], VarMask, Alignment);
+      Align Alignment = cast<ConstantInt>(Args[1])->getAlignValue();
+      return thisT()->getGatherScatterOpCost(Instruction::Load, RetTy, Args[0],
+                                             VarMask, Alignment, CostKind, I);
     }
-    case Intrinsic::experimental_vector_reduce_add:
-    case Intrinsic::experimental_vector_reduce_mul:
-    case Intrinsic::experimental_vector_reduce_and:
-    case Intrinsic::experimental_vector_reduce_or:
-    case Intrinsic::experimental_vector_reduce_xor:
-    case Intrinsic::experimental_vector_reduce_v2_fadd:
-    case Intrinsic::experimental_vector_reduce_v2_fmul:
-    case Intrinsic::experimental_vector_reduce_smax:
-    case Intrinsic::experimental_vector_reduce_smin:
-    case Intrinsic::experimental_vector_reduce_fmax:
-    case Intrinsic::experimental_vector_reduce_fmin:
-    case Intrinsic::experimental_vector_reduce_umax:
-    case Intrinsic::experimental_vector_reduce_umin:
-      return getIntrinsicInstrCost(IID, RetTy, Args[0]->getType(), FMF);
+    case Intrinsic::experimental_vector_extract: {
+      // FIXME: Handle case where a scalable vector is extracted from a scalable
+      // vector
+      if (isa<ScalableVectorType>(RetTy))
+        return BaseT::getIntrinsicInstrCost(ICA, CostKind);
+      unsigned Index = cast<ConstantInt>(Args[1])->getZExtValue();
+      return thisT()->getShuffleCost(TTI::SK_ExtractSubvector,
+                                     cast<VectorType>(Args[0]->getType()),
+                                     Index, cast<VectorType>(RetTy));
+    }
+    case Intrinsic::experimental_vector_insert: {
+      // FIXME: Handle case where a scalable vector is inserted into a scalable
+      // vector
+      if (isa<ScalableVectorType>(Args[1]->getType()))
+        return BaseT::getIntrinsicInstrCost(ICA, CostKind);
+      unsigned Index = cast<ConstantInt>(Args[2])->getZExtValue();
+      return thisT()->getShuffleCost(
+          TTI::SK_InsertSubvector, cast<VectorType>(Args[0]->getType()), Index,
+          cast<VectorType>(Args[1]->getType()));
+    }
+    case Intrinsic::vector_reduce_add:
+    case Intrinsic::vector_reduce_mul:
+    case Intrinsic::vector_reduce_and:
+    case Intrinsic::vector_reduce_or:
+    case Intrinsic::vector_reduce_xor:
+    case Intrinsic::vector_reduce_smax:
+    case Intrinsic::vector_reduce_smin:
+    case Intrinsic::vector_reduce_fmax:
+    case Intrinsic::vector_reduce_fmin:
+    case Intrinsic::vector_reduce_umax:
+    case Intrinsic::vector_reduce_umin: {
+      if (isa<ScalableVectorType>(RetTy))
+        return BaseT::getIntrinsicInstrCost(ICA, CostKind);
+      IntrinsicCostAttributes Attrs(IID, RetTy, Args[0]->getType(), FMF, 1, I);
+      return getTypeBasedIntrinsicInstrCost(Attrs, CostKind);
+    }
+    case Intrinsic::vector_reduce_fadd:
+    case Intrinsic::vector_reduce_fmul: {
+      if (isa<ScalableVectorType>(RetTy))
+        return BaseT::getIntrinsicInstrCost(ICA, CostKind);
+      IntrinsicCostAttributes Attrs(
+          IID, RetTy, {Args[0]->getType(), Args[1]->getType()}, FMF, 1, I);
+      return getTypeBasedIntrinsicInstrCost(Attrs, CostKind);
+    }
     case Intrinsic::fshl:
     case Intrinsic::fshr: {
-      Value *X = Args[0];
-      Value *Y = Args[1];
-      Value *Z = Args[2];
+      if (isa<ScalableVectorType>(RetTy))
+        return BaseT::getIntrinsicInstrCost(ICA, CostKind);
+      const Value *X = Args[0];
+      const Value *Y = Args[1];
+      const Value *Z = Args[2];
       TTI::OperandValueProperties OpPropsX, OpPropsY, OpPropsZ, OpPropsBW;
       TTI::OperandValueKind OpKindX = TTI::getOperandInfo(X, OpPropsX);
       TTI::OperandValueKind OpKindY = TTI::getOperandInfo(Y, OpPropsY);
@@ -1095,64 +1318,116 @@
       // fshl: (X << (Z % BW)) | (Y >> (BW - (Z % BW)))
       // fshr: (X << (BW - (Z % BW))) | (Y >> (Z % BW))
       unsigned Cost = 0;
-      Cost += ConcreteTTI->getArithmeticInstrCost(BinaryOperator::Or, RetTy);
-      Cost += ConcreteTTI->getArithmeticInstrCost(BinaryOperator::Sub, RetTy);
-      Cost += ConcreteTTI->getArithmeticInstrCost(BinaryOperator::Shl, RetTy,
-                                                  OpKindX, OpKindZ, OpPropsX);
-      Cost += ConcreteTTI->getArithmeticInstrCost(BinaryOperator::LShr, RetTy,
-                                                  OpKindY, OpKindZ, OpPropsY);
+      Cost +=
+          thisT()->getArithmeticInstrCost(BinaryOperator::Or, RetTy, CostKind);
+      Cost +=
+          thisT()->getArithmeticInstrCost(BinaryOperator::Sub, RetTy, CostKind);
+      Cost += thisT()->getArithmeticInstrCost(
+          BinaryOperator::Shl, RetTy, CostKind, OpKindX, OpKindZ, OpPropsX);
+      Cost += thisT()->getArithmeticInstrCost(
+          BinaryOperator::LShr, RetTy, CostKind, OpKindY, OpKindZ, OpPropsY);
       // Non-constant shift amounts requires a modulo.
       if (OpKindZ != TTI::OK_UniformConstantValue &&
           OpKindZ != TTI::OK_NonUniformConstantValue)
-        Cost += ConcreteTTI->getArithmeticInstrCost(BinaryOperator::URem, RetTy,
-                                                    OpKindZ, OpKindBW, OpPropsZ,
-                                                    OpPropsBW);
+        Cost += thisT()->getArithmeticInstrCost(BinaryOperator::URem, RetTy,
+                                                CostKind, OpKindZ, OpKindBW,
+                                                OpPropsZ, OpPropsBW);
       // For non-rotates (X != Y) we must add shift-by-zero handling costs.
       if (X != Y) {
-        Type *CondTy = Type::getInt1Ty(RetTy->getContext());
-        if (RetVF > 1)
-          CondTy = VectorType::get(CondTy, RetVF);
-        Cost += ConcreteTTI->getCmpSelInstrCost(BinaryOperator::ICmp, RetTy,
-                                                CondTy, nullptr);
-        Cost += ConcreteTTI->getCmpSelInstrCost(BinaryOperator::Select, RetTy,
-                                                CondTy, nullptr);
+        Type *CondTy = RetTy->getWithNewBitWidth(1);
+        Cost +=
+            thisT()->getCmpSelInstrCost(BinaryOperator::ICmp, RetTy, CondTy,
+                                        CmpInst::BAD_ICMP_PREDICATE, CostKind);
+        Cost +=
+            thisT()->getCmpSelInstrCost(BinaryOperator::Select, RetTy, CondTy,
+                                        CmpInst::BAD_ICMP_PREDICATE, CostKind);
       }
       return Cost;
     }
     }
+    // TODO: Handle the remaining intrinsic with scalable vector type
+    if (isa<ScalableVectorType>(RetTy))
+      return BaseT::getIntrinsicInstrCost(ICA, CostKind);
+
+    // Assume that we need to scalarize this intrinsic.
+    SmallVector<Type *, 4> Types;
+    for (const Value *Op : Args) {
+      Type *OpTy = Op->getType();
+      assert(VF.isScalar() || !OpTy->isVectorTy());
+      Types.push_back(VF.isScalar()
+                          ? OpTy
+                          : FixedVectorType::get(OpTy, VF.getKnownMinValue()));
+    }
+
+    if (VF.isVector() && !RetTy->isVoidTy())
+      RetTy = FixedVectorType::get(RetTy, VF.getKnownMinValue());
+
+    // Compute the scalarization overhead based on Args for a vector
+    // intrinsic. A vectorizer will pass a scalar RetTy and VF > 1, while
+    // CostModel will pass a vector RetTy and VF is 1.
+    unsigned ScalarizationCost = std::numeric_limits<unsigned>::max();
+    if (RetVF.isVector() || VF.isVector()) {
+      ScalarizationCost = 0;
+      if (!RetTy->isVoidTy())
+        ScalarizationCost +=
+            getScalarizationOverhead(cast<VectorType>(RetTy), true, false);
+      ScalarizationCost +=
+          getOperandsScalarizationOverhead(Args, VF.getKnownMinValue());
+    }
+
+    IntrinsicCostAttributes Attrs(IID, RetTy, Types, FMF, ScalarizationCost, I);
+    return thisT()->getTypeBasedIntrinsicInstrCost(Attrs, CostKind);
   }
 
   /// Get intrinsic cost based on argument types.
   /// If ScalarizationCostPassed is std::numeric_limits<unsigned>::max(), the
   /// cost of scalarizing the arguments and the return value will be computed
   /// based on types.
-  unsigned getIntrinsicInstrCost(
-      Intrinsic::ID IID, Type *RetTy, ArrayRef<Type *> Tys, FastMathFlags FMF,
-      unsigned ScalarizationCostPassed = std::numeric_limits<unsigned>::max()) {
-    unsigned RetVF = (RetTy->isVectorTy() ? RetTy->getVectorNumElements() : 1);
-    auto *ConcreteTTI = static_cast<T *>(this);
+  unsigned getTypeBasedIntrinsicInstrCost(const IntrinsicCostAttributes &ICA,
+                                          TTI::TargetCostKind CostKind) {
+    Intrinsic::ID IID = ICA.getID();
+    Type *RetTy = ICA.getReturnType();
+    const SmallVectorImpl<Type *> &Tys = ICA.getArgTypes();
+    FastMathFlags FMF = ICA.getFlags();
+    unsigned ScalarizationCostPassed = ICA.getScalarizationCost();
+    bool SkipScalarizationCost = ICA.skipScalarizationCost();
 
+    VectorType *VecOpTy = nullptr;
+    if (!Tys.empty()) {
+      // The vector reduction operand is operand 0 except for fadd/fmul.
+      // Their operand 0 is a scalar start value, so the vector op is operand 1.
+      unsigned VecTyIndex = 0;
+      if (IID == Intrinsic::vector_reduce_fadd ||
+          IID == Intrinsic::vector_reduce_fmul)
+        VecTyIndex = 1;
+      assert(Tys.size() > VecTyIndex && "Unexpected IntrinsicCostAttributes");
+      VecOpTy = dyn_cast<VectorType>(Tys[VecTyIndex]);
+    }
+
+    // Library call cost - other than size, make it expensive.
+    unsigned SingleCallCost = CostKind == TTI::TCK_CodeSize ? 1 : 10;
     SmallVector<unsigned, 2> ISDs;
-    unsigned SingleCallCost = 10; // Library call cost. Make it expensive.
     switch (IID) {
     default: {
       // Assume that we need to scalarize this intrinsic.
       unsigned ScalarizationCost = ScalarizationCostPassed;
       unsigned ScalarCalls = 1;
       Type *ScalarRetTy = RetTy;
-      if (RetTy->isVectorTy()) {
-        if (ScalarizationCostPassed == std::numeric_limits<unsigned>::max())
-          ScalarizationCost = getScalarizationOverhead(RetTy, true, false);
-        ScalarCalls = std::max(ScalarCalls, RetTy->getVectorNumElements());
+      if (auto *RetVTy = dyn_cast<VectorType>(RetTy)) {
+        if (!SkipScalarizationCost)
+          ScalarizationCost = getScalarizationOverhead(RetVTy, true, false);
+        ScalarCalls = std::max(ScalarCalls,
+                               cast<FixedVectorType>(RetVTy)->getNumElements());
         ScalarRetTy = RetTy->getScalarType();
       }
       SmallVector<Type *, 4> ScalarTys;
       for (unsigned i = 0, ie = Tys.size(); i != ie; ++i) {
         Type *Ty = Tys[i];
-        if (Ty->isVectorTy()) {
-          if (ScalarizationCostPassed == std::numeric_limits<unsigned>::max())
-            ScalarizationCost += getScalarizationOverhead(Ty, false, true);
-          ScalarCalls = std::max(ScalarCalls, Ty->getVectorNumElements());
+        if (auto *VTy = dyn_cast<VectorType>(Ty)) {
+          if (!SkipScalarizationCost)
+            ScalarizationCost += getScalarizationOverhead(VTy, false, true);
+          ScalarCalls = std::max(ScalarCalls,
+                                 cast<FixedVectorType>(VTy)->getNumElements());
           Ty = Ty->getScalarType();
         }
         ScalarTys.push_back(Ty);
@@ -1160,8 +1435,9 @@
       if (ScalarCalls == 1)
         return 1; // Return cost of a scalar intrinsic. Assume it to be cheap.
 
+      IntrinsicCostAttributes ScalarAttrs(IID, ScalarRetTy, ScalarTys, FMF);
       unsigned ScalarCost =
-          ConcreteTTI->getIntrinsicInstrCost(IID, ScalarRetTy, ScalarTys, FMF);
+          thisT()->getIntrinsicInstrCost(ScalarAttrs, CostKind);
 
       return ScalarCalls * ScalarCost + ScalarizationCost;
     }
@@ -1199,13 +1475,15 @@
       break;
     case Intrinsic::minnum:
       ISDs.push_back(ISD::FMINNUM);
-      if (FMF.noNaNs())
-        ISDs.push_back(ISD::FMINIMUM);
       break;
     case Intrinsic::maxnum:
       ISDs.push_back(ISD::FMAXNUM);
-      if (FMF.noNaNs())
-        ISDs.push_back(ISD::FMAXIMUM);
+      break;
+    case Intrinsic::minimum:
+      ISDs.push_back(ISD::FMINIMUM);
+      break;
+    case Intrinsic::maximum:
+      ISDs.push_back(ISD::FMAXIMUM);
       break;
     case Intrinsic::copysign:
       ISDs.push_back(ISD::FCOPYSIGN);
@@ -1228,6 +1506,9 @@
     case Intrinsic::round:
       ISDs.push_back(ISD::FROUND);
       break;
+    case Intrinsic::roundeven:
+      ISDs.push_back(ISD::FROUNDEVEN);
+      break;
     case Intrinsic::pow:
       ISDs.push_back(ISD::FPOW);
       break;
@@ -1237,58 +1518,96 @@
     case Intrinsic::fmuladd:
       ISDs.push_back(ISD::FMA);
       break;
+    case Intrinsic::experimental_constrained_fmuladd:
+      ISDs.push_back(ISD::STRICT_FMA);
+      break;
     // FIXME: We should return 0 whenever getIntrinsicCost == TCC_Free.
     case Intrinsic::lifetime_start:
     case Intrinsic::lifetime_end:
     case Intrinsic::sideeffect:
+    case Intrinsic::pseudoprobe:
       return 0;
-    case Intrinsic::masked_store:
-      return ConcreteTTI->getMaskedMemoryOpCost(Instruction::Store, Tys[0], 0,
-                                                0);
-    case Intrinsic::masked_load:
-      return ConcreteTTI->getMaskedMemoryOpCost(Instruction::Load, RetTy, 0, 0);
-    case Intrinsic::experimental_vector_reduce_add:
-      return ConcreteTTI->getArithmeticReductionCost(Instruction::Add, Tys[0],
-                                                     /*IsPairwiseForm=*/false);
-    case Intrinsic::experimental_vector_reduce_mul:
-      return ConcreteTTI->getArithmeticReductionCost(Instruction::Mul, Tys[0],
-                                                     /*IsPairwiseForm=*/false);
-    case Intrinsic::experimental_vector_reduce_and:
-      return ConcreteTTI->getArithmeticReductionCost(Instruction::And, Tys[0],
-                                                     /*IsPairwiseForm=*/false);
-    case Intrinsic::experimental_vector_reduce_or:
-      return ConcreteTTI->getArithmeticReductionCost(Instruction::Or, Tys[0],
-                                                     /*IsPairwiseForm=*/false);
-    case Intrinsic::experimental_vector_reduce_xor:
-      return ConcreteTTI->getArithmeticReductionCost(Instruction::Xor, Tys[0],
-                                                     /*IsPairwiseForm=*/false);
-    case Intrinsic::experimental_vector_reduce_v2_fadd:
-      return ConcreteTTI->getArithmeticReductionCost(
-          Instruction::FAdd, Tys[0],
-          /*IsPairwiseForm=*/false); // FIXME: Add new flag for cost of strict
-                                     // reductions.
-    case Intrinsic::experimental_vector_reduce_v2_fmul:
-      return ConcreteTTI->getArithmeticReductionCost(
-          Instruction::FMul, Tys[0],
-          /*IsPairwiseForm=*/false); // FIXME: Add new flag for cost of strict
-                                     // reductions.
-    case Intrinsic::experimental_vector_reduce_smax:
-    case Intrinsic::experimental_vector_reduce_smin:
-    case Intrinsic::experimental_vector_reduce_fmax:
-    case Intrinsic::experimental_vector_reduce_fmin:
-      return ConcreteTTI->getMinMaxReductionCost(
-          Tys[0], CmpInst::makeCmpResultType(Tys[0]), /*IsPairwiseForm=*/false,
-          /*IsSigned=*/true);
-    case Intrinsic::experimental_vector_reduce_umax:
-    case Intrinsic::experimental_vector_reduce_umin:
-      return ConcreteTTI->getMinMaxReductionCost(
-          Tys[0], CmpInst::makeCmpResultType(Tys[0]), /*IsPairwiseForm=*/false,
-          /*IsSigned=*/false);
+    case Intrinsic::masked_store: {
+      Type *Ty = Tys[0];
+      Align TyAlign = thisT()->DL.getABITypeAlign(Ty);
+      return thisT()->getMaskedMemoryOpCost(Instruction::Store, Ty, TyAlign, 0,
+                                            CostKind);
+    }
+    case Intrinsic::masked_load: {
+      Type *Ty = RetTy;
+      Align TyAlign = thisT()->DL.getABITypeAlign(Ty);
+      return thisT()->getMaskedMemoryOpCost(Instruction::Load, Ty, TyAlign, 0,
+                                            CostKind);
+    }
+    case Intrinsic::vector_reduce_add:
+      return thisT()->getArithmeticReductionCost(Instruction::Add, VecOpTy,
+                                                 /*IsPairwiseForm=*/false,
+                                                 CostKind);
+    case Intrinsic::vector_reduce_mul:
+      return thisT()->getArithmeticReductionCost(Instruction::Mul, VecOpTy,
+                                                 /*IsPairwiseForm=*/false,
+                                                 CostKind);
+    case Intrinsic::vector_reduce_and:
+      return thisT()->getArithmeticReductionCost(Instruction::And, VecOpTy,
+                                                 /*IsPairwiseForm=*/false,
+                                                 CostKind);
+    case Intrinsic::vector_reduce_or:
+      return thisT()->getArithmeticReductionCost(Instruction::Or, VecOpTy,
+                                                 /*IsPairwiseForm=*/false,
+                                                 CostKind);
+    case Intrinsic::vector_reduce_xor:
+      return thisT()->getArithmeticReductionCost(Instruction::Xor, VecOpTy,
+                                                 /*IsPairwiseForm=*/false,
+                                                 CostKind);
+    case Intrinsic::vector_reduce_fadd:
+      // FIXME: Add new flag for cost of strict reductions.
+      return thisT()->getArithmeticReductionCost(Instruction::FAdd, VecOpTy,
+                                                 /*IsPairwiseForm=*/false,
+                                                 CostKind);
+    case Intrinsic::vector_reduce_fmul:
+      // FIXME: Add new flag for cost of strict reductions.
+      return thisT()->getArithmeticReductionCost(Instruction::FMul, VecOpTy,
+                                                 /*IsPairwiseForm=*/false,
+                                                 CostKind);
+    case Intrinsic::vector_reduce_smax:
+    case Intrinsic::vector_reduce_smin:
+    case Intrinsic::vector_reduce_fmax:
+    case Intrinsic::vector_reduce_fmin:
+      return thisT()->getMinMaxReductionCost(
+          VecOpTy, cast<VectorType>(CmpInst::makeCmpResultType(VecOpTy)),
+          /*IsPairwiseForm=*/false,
+          /*IsUnsigned=*/false, CostKind);
+    case Intrinsic::vector_reduce_umax:
+    case Intrinsic::vector_reduce_umin:
+      return thisT()->getMinMaxReductionCost(
+          VecOpTy, cast<VectorType>(CmpInst::makeCmpResultType(VecOpTy)),
+          /*IsPairwiseForm=*/false,
+          /*IsUnsigned=*/true, CostKind);
+    case Intrinsic::abs:
+    case Intrinsic::smax:
+    case Intrinsic::smin:
+    case Intrinsic::umax:
+    case Intrinsic::umin: {
+      // abs(X) = select(icmp(X,0),X,sub(0,X))
+      // minmax(X,Y) = select(icmp(X,Y),X,Y)
+      Type *CondTy = RetTy->getWithNewBitWidth(1);
+      unsigned Cost = 0;
+      // TODO: Ideally getCmpSelInstrCost would accept an icmp condition code.
+      Cost +=
+          thisT()->getCmpSelInstrCost(BinaryOperator::ICmp, RetTy, CondTy,
+                                      CmpInst::BAD_ICMP_PREDICATE, CostKind);
+      Cost +=
+          thisT()->getCmpSelInstrCost(BinaryOperator::Select, RetTy, CondTy,
+                                      CmpInst::BAD_ICMP_PREDICATE, CostKind);
+      // TODO: Should we add an OperandValueProperties::OP_Zero property?
+      if (IID == Intrinsic::abs)
+        Cost += thisT()->getArithmeticInstrCost(
+            BinaryOperator::Sub, RetTy, CostKind, TTI::OK_UniformConstantValue);
+      return Cost;
+    }
     case Intrinsic::sadd_sat:
     case Intrinsic::ssub_sat: {
-      Type *CondTy = Type::getInt1Ty(RetTy->getContext());
-      if (RetVF > 1)
-        CondTy = VectorType::get(CondTy, RetVF);
+      Type *CondTy = RetTy->getWithNewBitWidth(1);
 
       Type *OpTy = StructType::create({RetTy, CondTy});
       Intrinsic::ID OverflowOp = IID == Intrinsic::sadd_sat
@@ -1298,19 +1617,20 @@
       // SatMax -> Overflow && SumDiff < 0
       // SatMin -> Overflow && SumDiff >= 0
       unsigned Cost = 0;
-      Cost += ConcreteTTI->getIntrinsicInstrCost(
-          OverflowOp, OpTy, {RetTy, RetTy}, FMF, ScalarizationCostPassed);
-      Cost += ConcreteTTI->getCmpSelInstrCost(BinaryOperator::ICmp, RetTy,
-                                              CondTy, nullptr);
-      Cost += 2 * ConcreteTTI->getCmpSelInstrCost(BinaryOperator::Select, RetTy,
-                                                  CondTy, nullptr);
+      IntrinsicCostAttributes Attrs(OverflowOp, OpTy, {RetTy, RetTy}, FMF,
+                                    ScalarizationCostPassed);
+      Cost += thisT()->getIntrinsicInstrCost(Attrs, CostKind);
+      Cost +=
+          thisT()->getCmpSelInstrCost(BinaryOperator::ICmp, RetTy, CondTy,
+                                      CmpInst::BAD_ICMP_PREDICATE, CostKind);
+      Cost += 2 * thisT()->getCmpSelInstrCost(
+                      BinaryOperator::Select, RetTy, CondTy,
+                      CmpInst::BAD_ICMP_PREDICATE, CostKind);
       return Cost;
     }
     case Intrinsic::uadd_sat:
     case Intrinsic::usub_sat: {
-      Type *CondTy = Type::getInt1Ty(RetTy->getContext());
-      if (RetVF > 1)
-        CondTy = VectorType::get(CondTy, RetVF);
+      Type *CondTy = RetTy->getWithNewBitWidth(1);
 
       Type *OpTy = StructType::create({RetTy, CondTy});
       Intrinsic::ID OverflowOp = IID == Intrinsic::uadd_sat
@@ -1318,34 +1638,36 @@
                                      : Intrinsic::usub_with_overflow;
 
       unsigned Cost = 0;
-      Cost += ConcreteTTI->getIntrinsicInstrCost(
-          OverflowOp, OpTy, {RetTy, RetTy}, FMF, ScalarizationCostPassed);
-      Cost += ConcreteTTI->getCmpSelInstrCost(BinaryOperator::Select, RetTy,
-                                              CondTy, nullptr);
+      IntrinsicCostAttributes Attrs(OverflowOp, OpTy, {RetTy, RetTy}, FMF,
+                                    ScalarizationCostPassed);
+      Cost += thisT()->getIntrinsicInstrCost(Attrs, CostKind);
+      Cost +=
+          thisT()->getCmpSelInstrCost(BinaryOperator::Select, RetTy, CondTy,
+                                      CmpInst::BAD_ICMP_PREDICATE, CostKind);
       return Cost;
     }
     case Intrinsic::smul_fix:
     case Intrinsic::umul_fix: {
       unsigned ExtSize = RetTy->getScalarSizeInBits() * 2;
-      Type *ExtTy = Type::getIntNTy(RetTy->getContext(), ExtSize);
-      if (RetVF > 1)
-        ExtTy = VectorType::get(ExtTy, RetVF);
+      Type *ExtTy = RetTy->getWithNewBitWidth(ExtSize);
 
       unsigned ExtOp =
           IID == Intrinsic::smul_fix ? Instruction::SExt : Instruction::ZExt;
+      TTI::CastContextHint CCH = TTI::CastContextHint::None;
 
       unsigned Cost = 0;
-      Cost += 2 * ConcreteTTI->getCastInstrCost(ExtOp, ExtTy, RetTy);
-      Cost += ConcreteTTI->getArithmeticInstrCost(Instruction::Mul, ExtTy);
+      Cost += 2 * thisT()->getCastInstrCost(ExtOp, ExtTy, RetTy, CCH, CostKind);
       Cost +=
-          2 * ConcreteTTI->getCastInstrCost(Instruction::Trunc, RetTy, ExtTy);
-      Cost += ConcreteTTI->getArithmeticInstrCost(Instruction::LShr, RetTy,
-                                                  TTI::OK_AnyValue,
-                                                  TTI::OK_UniformConstantValue);
-      Cost += ConcreteTTI->getArithmeticInstrCost(Instruction::Shl, RetTy,
-                                                  TTI::OK_AnyValue,
-                                                  TTI::OK_UniformConstantValue);
-      Cost += ConcreteTTI->getArithmeticInstrCost(Instruction::Or, RetTy);
+          thisT()->getArithmeticInstrCost(Instruction::Mul, ExtTy, CostKind);
+      Cost += 2 * thisT()->getCastInstrCost(Instruction::Trunc, RetTy, ExtTy,
+                                            CCH, CostKind);
+      Cost += thisT()->getArithmeticInstrCost(Instruction::LShr, RetTy,
+                                              CostKind, TTI::OK_AnyValue,
+                                              TTI::OK_UniformConstantValue);
+      Cost += thisT()->getArithmeticInstrCost(Instruction::Shl, RetTy, CostKind,
+                                              TTI::OK_AnyValue,
+                                              TTI::OK_UniformConstantValue);
+      Cost += thisT()->getArithmeticInstrCost(Instruction::Or, RetTy, CostKind);
       return Cost;
     }
     case Intrinsic::sadd_with_overflow:
@@ -1365,13 +1687,15 @@
       //   Sub:
       //   Overflow -> (LHSSign != RHSSign) && (LHSSign != SumSign)
       unsigned Cost = 0;
-      Cost += ConcreteTTI->getArithmeticInstrCost(Opcode, SumTy);
-      Cost += 3 * ConcreteTTI->getCmpSelInstrCost(BinaryOperator::ICmp, SumTy,
-                                                  OverflowTy, nullptr);
-      Cost += 2 * ConcreteTTI->getCmpSelInstrCost(
-                      BinaryOperator::ICmp, OverflowTy, OverflowTy, nullptr);
-      Cost +=
-          ConcreteTTI->getArithmeticInstrCost(BinaryOperator::And, OverflowTy);
+      Cost += thisT()->getArithmeticInstrCost(Opcode, SumTy, CostKind);
+      Cost += 3 * thisT()->getCmpSelInstrCost(
+                      Instruction::ICmp, SumTy, OverflowTy,
+                      CmpInst::BAD_ICMP_PREDICATE, CostKind);
+      Cost += 2 * thisT()->getCmpSelInstrCost(
+                      Instruction::Select, OverflowTy, OverflowTy,
+                      CmpInst::BAD_ICMP_PREDICATE, CostKind);
+      Cost += thisT()->getArithmeticInstrCost(BinaryOperator::And, OverflowTy,
+                                              CostKind);
       return Cost;
     }
     case Intrinsic::uadd_with_overflow:
@@ -1383,9 +1707,10 @@
                             : BinaryOperator::Sub;
 
       unsigned Cost = 0;
-      Cost += ConcreteTTI->getArithmeticInstrCost(Opcode, SumTy);
-      Cost += ConcreteTTI->getCmpSelInstrCost(BinaryOperator::ICmp, SumTy,
-                                              OverflowTy, nullptr);
+      Cost += thisT()->getArithmeticInstrCost(Opcode, SumTy, CostKind);
+      Cost +=
+          thisT()->getCmpSelInstrCost(BinaryOperator::ICmp, SumTy, OverflowTy,
+                                      CmpInst::BAD_ICMP_PREDICATE, CostKind);
       return Cost;
     }
     case Intrinsic::smul_with_overflow:
@@ -1393,29 +1718,30 @@
       Type *MulTy = RetTy->getContainedType(0);
       Type *OverflowTy = RetTy->getContainedType(1);
       unsigned ExtSize = MulTy->getScalarSizeInBits() * 2;
-      Type *ExtTy = Type::getIntNTy(RetTy->getContext(), ExtSize);
-      if (MulTy->isVectorTy())
-        ExtTy = VectorType::get(ExtTy, MulTy->getVectorNumElements() );
+      Type *ExtTy = MulTy->getWithNewBitWidth(ExtSize);
 
       unsigned ExtOp =
           IID == Intrinsic::smul_fix ? Instruction::SExt : Instruction::ZExt;
+      TTI::CastContextHint CCH = TTI::CastContextHint::None;
 
       unsigned Cost = 0;
-      Cost += 2 * ConcreteTTI->getCastInstrCost(ExtOp, ExtTy, MulTy);
-      Cost += ConcreteTTI->getArithmeticInstrCost(Instruction::Mul, ExtTy);
+      Cost += 2 * thisT()->getCastInstrCost(ExtOp, ExtTy, MulTy, CCH, CostKind);
       Cost +=
-          2 * ConcreteTTI->getCastInstrCost(Instruction::Trunc, MulTy, ExtTy);
-      Cost += ConcreteTTI->getArithmeticInstrCost(Instruction::LShr, MulTy,
-                                                  TTI::OK_AnyValue,
-                                                  TTI::OK_UniformConstantValue);
+          thisT()->getArithmeticInstrCost(Instruction::Mul, ExtTy, CostKind);
+      Cost += 2 * thisT()->getCastInstrCost(Instruction::Trunc, MulTy, ExtTy,
+                                            CCH, CostKind);
+      Cost += thisT()->getArithmeticInstrCost(Instruction::LShr, MulTy,
+                                              CostKind, TTI::OK_AnyValue,
+                                              TTI::OK_UniformConstantValue);
 
       if (IID == Intrinsic::smul_with_overflow)
-        Cost += ConcreteTTI->getArithmeticInstrCost(
-            Instruction::AShr, MulTy, TTI::OK_AnyValue,
-            TTI::OK_UniformConstantValue);
+        Cost += thisT()->getArithmeticInstrCost(Instruction::AShr, MulTy,
+                                                CostKind, TTI::OK_AnyValue,
+                                                TTI::OK_UniformConstantValue);
 
-      Cost += ConcreteTTI->getCmpSelInstrCost(BinaryOperator::ICmp, MulTy,
-                                              OverflowTy, nullptr);
+      Cost +=
+          thisT()->getCmpSelInstrCost(BinaryOperator::ICmp, MulTy, OverflowTy,
+                                      CmpInst::BAD_ICMP_PREDICATE, CostKind);
       return Cost;
     }
     case Intrinsic::ctpop:
@@ -1425,6 +1751,12 @@
       SingleCallCost = TargetTransformInfo::TCC_Expensive;
       break;
     // FIXME: ctlz, cttz, ...
+    case Intrinsic::bswap:
+      ISDs.push_back(ISD::BSWAP);
+      break;
+    case Intrinsic::bitreverse:
+      ISDs.push_back(ISD::BITREVERSE);
+      break;
     }
 
     const TargetLoweringBase *TLI = getTLI();
@@ -1454,7 +1786,7 @@
       }
     }
 
-    auto MinLegalCostI = std::min_element(LegalCost.begin(), LegalCost.end());
+    auto *MinLegalCostI = std::min_element(LegalCost.begin(), LegalCost.end());
     if (MinLegalCostI != LegalCost.end())
       return *MinLegalCostI;
 
@@ -1466,18 +1798,27 @@
     // If we can't lower fmuladd into an FMA estimate the cost as a floating
     // point mul followed by an add.
     if (IID == Intrinsic::fmuladd)
-      return ConcreteTTI->getArithmeticInstrCost(BinaryOperator::FMul, RetTy) +
-             ConcreteTTI->getArithmeticInstrCost(BinaryOperator::FAdd, RetTy);
+      return thisT()->getArithmeticInstrCost(BinaryOperator::FMul, RetTy,
+                                             CostKind) +
+             thisT()->getArithmeticInstrCost(BinaryOperator::FAdd, RetTy,
+                                             CostKind);
+    if (IID == Intrinsic::experimental_constrained_fmuladd) {
+      IntrinsicCostAttributes FMulAttrs(
+        Intrinsic::experimental_constrained_fmul, RetTy, Tys);
+      IntrinsicCostAttributes FAddAttrs(
+        Intrinsic::experimental_constrained_fadd, RetTy, Tys);
+      return thisT()->getIntrinsicInstrCost(FMulAttrs, CostKind) +
+             thisT()->getIntrinsicInstrCost(FAddAttrs, CostKind);
+    }
 
     // Else, assume that we need to scalarize this intrinsic. For math builtins
     // this will emit a costly libcall, adding call overhead and spills. Make it
     // very expensive.
-    if (RetTy->isVectorTy()) {
-      unsigned ScalarizationCost =
-          ((ScalarizationCostPassed != std::numeric_limits<unsigned>::max())
-               ? ScalarizationCostPassed
-               : getScalarizationOverhead(RetTy, true, false));
-      unsigned ScalarCalls = RetTy->getVectorNumElements();
+    if (auto *RetVTy = dyn_cast<VectorType>(RetTy)) {
+      unsigned ScalarizationCost = SkipScalarizationCost ?
+        ScalarizationCostPassed : getScalarizationOverhead(RetVTy, true, false);
+
+      unsigned ScalarCalls = cast<FixedVectorType>(RetVTy)->getNumElements();
       SmallVector<Type *, 4> ScalarTys;
       for (unsigned i = 0, ie = Tys.size(); i != ie; ++i) {
         Type *Ty = Tys[i];
@@ -1485,16 +1826,16 @@
           Ty = Ty->getScalarType();
         ScalarTys.push_back(Ty);
       }
-      unsigned ScalarCost = ConcreteTTI->getIntrinsicInstrCost(
-          IID, RetTy->getScalarType(), ScalarTys, FMF);
+      IntrinsicCostAttributes Attrs(IID, RetTy->getScalarType(), ScalarTys, FMF);
+      unsigned ScalarCost = thisT()->getIntrinsicInstrCost(Attrs, CostKind);
       for (unsigned i = 0, ie = Tys.size(); i != ie; ++i) {
-        if (Tys[i]->isVectorTy()) {
-          if (ScalarizationCostPassed == std::numeric_limits<unsigned>::max())
-            ScalarizationCost += getScalarizationOverhead(Tys[i], false, true);
-          ScalarCalls = std::max(ScalarCalls, Tys[i]->getVectorNumElements());
+        if (auto *VTy = dyn_cast<VectorType>(Tys[i])) {
+          if (!ICA.skipScalarizationCost())
+            ScalarizationCost += getScalarizationOverhead(VTy, false, true);
+          ScalarCalls = std::max(ScalarCalls,
+                                 cast<FixedVectorType>(VTy)->getNumElements());
         }
       }
-
       return ScalarCalls * ScalarCost + ScalarizationCost;
     }
 
@@ -1513,7 +1854,8 @@
   /// \param RetTy Return value types.
   /// \param Tys Argument types.
   /// \returns The cost of Call instruction.
-  unsigned getCallInstrCost(Function *F, Type *RetTy, ArrayRef<Type *> Tys) {
+  unsigned getCallInstrCost(Function *F, Type *RetTy, ArrayRef<Type *> Tys,
+                     TTI::TargetCostKind CostKind = TTI::TCK_SizeAndLatency) {
     return 10;
   }
 
@@ -1562,28 +1904,27 @@
   ///
   /// The cost model should take into account that the actual length of the
   /// vector is reduced on each iteration.
-  unsigned getArithmeticReductionCost(unsigned Opcode, Type *Ty,
-                                      bool IsPairwise) {
-    assert(Ty->isVectorTy() && "Expect a vector type");
-    Type *ScalarTy = Ty->getVectorElementType();
-    unsigned NumVecElts = Ty->getVectorNumElements();
+  unsigned getArithmeticReductionCost(unsigned Opcode, VectorType *Ty,
+                                      bool IsPairwise,
+                                      TTI::TargetCostKind CostKind) {
+    Type *ScalarTy = Ty->getElementType();
+    unsigned NumVecElts = cast<FixedVectorType>(Ty)->getNumElements();
     unsigned NumReduxLevels = Log2_32(NumVecElts);
     unsigned ArithCost = 0;
     unsigned ShuffleCost = 0;
-    auto *ConcreteTTI = static_cast<T *>(this);
     std::pair<unsigned, MVT> LT =
-        ConcreteTTI->getTLI()->getTypeLegalizationCost(DL, Ty);
+        thisT()->getTLI()->getTypeLegalizationCost(DL, Ty);
     unsigned LongVectorCount = 0;
     unsigned MVTLen =
         LT.second.isVector() ? LT.second.getVectorNumElements() : 1;
     while (NumVecElts > MVTLen) {
       NumVecElts /= 2;
-      Type *SubTy = VectorType::get(ScalarTy, NumVecElts);
+      VectorType *SubTy = FixedVectorType::get(ScalarTy, NumVecElts);
       // Assume the pairwise shuffles add a cost.
-      ShuffleCost += (IsPairwise + 1) *
-                     ConcreteTTI->getShuffleCost(TTI::SK_ExtractSubvector, Ty,
-                                                 NumVecElts, SubTy);
-      ArithCost += ConcreteTTI->getArithmeticInstrCost(Opcode, SubTy);
+      ShuffleCost +=
+          (IsPairwise + 1) * thisT()->getShuffleCost(TTI::SK_ExtractSubvector,
+                                                     Ty, NumVecElts, SubTy);
+      ArithCost += thisT()->getArithmeticInstrCost(Opcode, SubTy, CostKind);
       Ty = SubTy;
       ++LongVectorCount;
     }
@@ -1602,22 +1943,20 @@
     if (IsPairwise && NumReduxLevels >= 1)
       NumShuffles += NumReduxLevels - 1;
     ShuffleCost += NumShuffles *
-                   ConcreteTTI->getShuffleCost(TTI::SK_PermuteSingleSrc, Ty,
-                                               0, Ty);
-    ArithCost += NumReduxLevels *
-                 ConcreteTTI->getArithmeticInstrCost(Opcode, Ty);
+                   thisT()->getShuffleCost(TTI::SK_PermuteSingleSrc, Ty, 0, Ty);
+    ArithCost += NumReduxLevels * thisT()->getArithmeticInstrCost(Opcode, Ty);
     return ShuffleCost + ArithCost +
-           ConcreteTTI->getVectorInstrCost(Instruction::ExtractElement, Ty, 0);
+           thisT()->getVectorInstrCost(Instruction::ExtractElement, Ty, 0);
   }
 
   /// Try to calculate op costs for min/max reduction operations.
   /// \param CondTy Conditional type for the Select instruction.
-  unsigned getMinMaxReductionCost(Type *Ty, Type *CondTy, bool IsPairwise,
-                                  bool) {
-    assert(Ty->isVectorTy() && "Expect a vector type");
-    Type *ScalarTy = Ty->getVectorElementType();
-    Type *ScalarCondTy = CondTy->getVectorElementType();
-    unsigned NumVecElts = Ty->getVectorNumElements();
+  unsigned getMinMaxReductionCost(VectorType *Ty, VectorType *CondTy,
+                                  bool IsPairwise, bool IsUnsigned,
+                                  TTI::TargetCostKind CostKind) {
+    Type *ScalarTy = Ty->getElementType();
+    Type *ScalarCondTy = CondTy->getElementType();
+    unsigned NumVecElts = cast<FixedVectorType>(Ty)->getNumElements();
     unsigned NumReduxLevels = Log2_32(NumVecElts);
     unsigned CmpOpcode;
     if (Ty->isFPOrFPVectorTy()) {
@@ -1629,25 +1968,25 @@
     }
     unsigned MinMaxCost = 0;
     unsigned ShuffleCost = 0;
-    auto *ConcreteTTI = static_cast<T *>(this);
     std::pair<unsigned, MVT> LT =
-        ConcreteTTI->getTLI()->getTypeLegalizationCost(DL, Ty);
+        thisT()->getTLI()->getTypeLegalizationCost(DL, Ty);
     unsigned LongVectorCount = 0;
     unsigned MVTLen =
         LT.second.isVector() ? LT.second.getVectorNumElements() : 1;
     while (NumVecElts > MVTLen) {
       NumVecElts /= 2;
-      Type *SubTy = VectorType::get(ScalarTy, NumVecElts);
-      CondTy = VectorType::get(ScalarCondTy, NumVecElts);
+      auto *SubTy = FixedVectorType::get(ScalarTy, NumVecElts);
+      CondTy = FixedVectorType::get(ScalarCondTy, NumVecElts);
 
       // Assume the pairwise shuffles add a cost.
-      ShuffleCost += (IsPairwise + 1) *
-                     ConcreteTTI->getShuffleCost(TTI::SK_ExtractSubvector, Ty,
-                                                 NumVecElts, SubTy);
+      ShuffleCost +=
+          (IsPairwise + 1) * thisT()->getShuffleCost(TTI::SK_ExtractSubvector,
+                                                     Ty, NumVecElts, SubTy);
       MinMaxCost +=
-          ConcreteTTI->getCmpSelInstrCost(CmpOpcode, SubTy, CondTy, nullptr) +
-          ConcreteTTI->getCmpSelInstrCost(Instruction::Select, SubTy, CondTy,
-                                          nullptr);
+          thisT()->getCmpSelInstrCost(CmpOpcode, SubTy, CondTy,
+                                      CmpInst::BAD_ICMP_PREDICATE, CostKind) +
+          thisT()->getCmpSelInstrCost(Instruction::Select, SubTy, CondTy,
+                                      CmpInst::BAD_ICMP_PREDICATE, CostKind);
       Ty = SubTy;
       ++LongVectorCount;
     }
@@ -1666,17 +2005,17 @@
     if (IsPairwise && NumReduxLevels >= 1)
       NumShuffles += NumReduxLevels - 1;
     ShuffleCost += NumShuffles *
-                   ConcreteTTI->getShuffleCost(TTI::SK_PermuteSingleSrc, Ty,
-                                               0, Ty);
+                   thisT()->getShuffleCost(TTI::SK_PermuteSingleSrc, Ty, 0, Ty);
     MinMaxCost +=
         NumReduxLevels *
-        (ConcreteTTI->getCmpSelInstrCost(CmpOpcode, Ty, CondTy, nullptr) +
-         ConcreteTTI->getCmpSelInstrCost(Instruction::Select, Ty, CondTy,
-                                         nullptr));
+        (thisT()->getCmpSelInstrCost(CmpOpcode, Ty, CondTy,
+                                     CmpInst::BAD_ICMP_PREDICATE, CostKind) +
+         thisT()->getCmpSelInstrCost(Instruction::Select, Ty, CondTy,
+                                     CmpInst::BAD_ICMP_PREDICATE, CostKind));
     // The last min/max should be in vector registers and we counted it above.
     // So just need a single extractelement.
     return ShuffleCost + MinMaxCost +
-           ConcreteTTI->getVectorInstrCost(Instruction::ExtractElement, Ty, 0);
+           thisT()->getVectorInstrCost(Instruction::ExtractElement, Ty, 0);
   }
 
   unsigned getVectorSplitCost() { return 1; }
diff --git a/linux-x64/clang/include/llvm/CodeGen/CalcSpillWeights.h b/linux-x64/clang/include/llvm/CodeGen/CalcSpillWeights.h
index 9b8b732..78dae81 100644
--- a/linux-x64/clang/include/llvm/CodeGen/CalcSpillWeights.h
+++ b/linux-x64/clang/include/llvm/CodeGen/CalcSpillWeights.h
@@ -44,64 +44,60 @@
   /// Calculate auxiliary information for a virtual register such as its
   /// spill weight and allocation hint.
   class VirtRegAuxInfo {
-  public:
-    using NormalizingFn = float (*)(float, unsigned, unsigned);
-
-  private:
     MachineFunction &MF;
     LiveIntervals &LIS;
-    VirtRegMap *VRM;
+    const VirtRegMap &VRM;
     const MachineLoopInfo &Loops;
     const MachineBlockFrequencyInfo &MBFI;
-    DenseMap<unsigned, float> Hint;
-    NormalizingFn normalize;
 
   public:
-    VirtRegAuxInfo(MachineFunction &mf, LiveIntervals &lis,
-                   VirtRegMap *vrm, const MachineLoopInfo &loops,
-                   const MachineBlockFrequencyInfo &mbfi,
-                   NormalizingFn norm = normalizeSpillWeight)
-        : MF(mf), LIS(lis), VRM(vrm), Loops(loops), MBFI(mbfi), normalize(norm) {}
+    VirtRegAuxInfo(MachineFunction &MF, LiveIntervals &LIS,
+                   const VirtRegMap &VRM, const MachineLoopInfo &Loops,
+                   const MachineBlockFrequencyInfo &MBFI)
+        : MF(MF), LIS(LIS), VRM(VRM), Loops(Loops), MBFI(MBFI) {}
+
+    virtual ~VirtRegAuxInfo() = default;
 
     /// (re)compute li's spill weight and allocation hint.
-    void calculateSpillWeightAndHint(LiveInterval &li);
+    void calculateSpillWeightAndHint(LiveInterval &LI);
 
-    /// Compute future expected spill weight of a split artifact of li
+    /// Compute future expected spill weight of a split artifact of LI
     /// that will span between start and end slot indexes.
-    /// \param li     The live interval to be split.
-    /// \param start  The expected begining of the split artifact. Instructions
+    /// \param LI     The live interval to be split.
+    /// \param Start  The expected beginning of the split artifact. Instructions
     ///               before start will not affect the weight.
-    /// \param end    The expected end of the split artifact. Instructions
+    /// \param End    The expected end of the split artifact. Instructions
     ///               after end will not affect the weight.
     /// \return The expected spill weight of the split artifact. Returns
-    /// negative weight for unspillable li.
-    float futureWeight(LiveInterval &li, SlotIndex start, SlotIndex end);
+    /// negative weight for unspillable LI.
+    float futureWeight(LiveInterval &LI, SlotIndex Start, SlotIndex End);
 
+    /// Compute spill weights and allocation hints for all virtual register
+    /// live intervals.
+    void calculateSpillWeightsAndHints();
+
+  protected:
     /// Helper function for weight calculations.
-    /// (Re)compute li's spill weight and allocation hint, or, for non null
+    /// (Re)compute LI's spill weight and allocation hint, or, for non null
     /// start and end - compute future expected spill weight of a split
-    /// artifact of li that will span between start and end slot indexes.
-    /// \param li     The live interval for which to compute the weight.
-    /// \param start  The expected begining of the split artifact. Instructions
+    /// artifact of LI that will span between start and end slot indexes.
+    /// \param LI     The live interval for which to compute the weight.
+    /// \param Start  The expected beginning of the split artifact. Instructions
     ///               before start will not affect the weight. Relevant for
     ///               weight calculation of future split artifact.
-    /// \param end    The expected end of the split artifact. Instructions
+    /// \param End    The expected end of the split artifact. Instructions
     ///               after end will not affect the weight. Relevant for
     ///               weight calculation of future split artifact.
-    /// \return The spill weight. Returns negative weight for unspillable li.
-    float weightCalcHelper(LiveInterval &li, SlotIndex *start = nullptr,
-                           SlotIndex *end = nullptr);
+    /// \return The spill weight. Returns negative weight for unspillable LI.
+    float weightCalcHelper(LiveInterval &LI, SlotIndex *Start = nullptr,
+                           SlotIndex *End = nullptr);
+
+    /// Weight normalization function.
+    virtual float normalize(float UseDefFreq, unsigned Size,
+                            unsigned NumInstr) {
+      return normalizeSpillWeight(UseDefFreq, Size, NumInstr);
+    }
   };
-
-  /// Compute spill weights and allocation hints for all virtual register
-  /// live intervals.
-  void calculateSpillWeightsAndHints(LiveIntervals &LIS, MachineFunction &MF,
-                                     VirtRegMap *VRM,
-                                     const MachineLoopInfo &MLI,
-                                     const MachineBlockFrequencyInfo &MBFI,
-                                     VirtRegAuxInfo::NormalizingFn norm =
-                                         normalizeSpillWeight);
-
 } // end namespace llvm
 
 #endif // LLVM_CODEGEN_CALCSPILLWEIGHTS_H
diff --git a/linux-x64/clang/include/llvm/CodeGen/CallingConvLower.h b/linux-x64/clang/include/llvm/CodeGen/CallingConvLower.h
index aa339e1..2fe4e37 100644
--- a/linux-x64/clang/include/llvm/CodeGen/CallingConvLower.h
+++ b/linux-x64/clang/include/llvm/CodeGen/CallingConvLower.h
@@ -16,16 +16,17 @@
 
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/CodeGen/MachineFrameInfo.h"
-#include "llvm/CodeGen/MachineFunction.h"
+#include "llvm/CodeGen/Register.h"
 #include "llvm/CodeGen/TargetCallingConv.h"
 #include "llvm/IR/CallingConv.h"
 #include "llvm/MC/MCRegisterInfo.h"
+#include "llvm/Support/Alignment.h"
 
 namespace llvm {
 
 class CCState;
+class MachineFunction;
 class MVT;
-class TargetMachine;
 class TargetRegisterInfo;
 
 /// CCValAssign - Represent assignment of one arg/retval to a location.
@@ -43,6 +44,7 @@
     AExtUpper, // The value is in the upper bits of the location and should be
                // extended with undefined upper bits when retrieved.
     BCvt,      // The value is bit-converted in the location.
+    Trunc,     // The value is truncated in the location.
     VExt,      // The value is vector-widened in the location.
                // FIXME: Not implemented yet. Code that uses AExt to mean
                // vector-widen should be fixed to use VExt instead.
@@ -163,9 +165,9 @@
 /// Describes a register that needs to be forwarded from the prologue to a
 /// musttail call.
 struct ForwardedRegister {
-  ForwardedRegister(unsigned VReg, MCPhysReg PReg, MVT VT)
+  ForwardedRegister(Register VReg, MCPhysReg PReg, MVT VT)
       : VReg(VReg), PReg(PReg), VT(VT) {}
-  unsigned VReg;
+  Register VReg;
   MCPhysReg PReg;
   MVT VT;
 };
@@ -197,7 +199,7 @@
   LLVMContext &Context;
 
   unsigned StackOffset;
-  unsigned MaxStackArgAlign;
+  Align MaxStackArgAlign;
   SmallVector<uint32_t, 16> UsedRegs;
   SmallVector<CCValAssign, 4> PendingLocs;
   SmallVector<ISD::ArgFlagsTy, 4> PendingArgFlags;
@@ -220,9 +222,7 @@
   // ByValRegs[1] describes how "%t" is stored (Begin == r3, End == r4).
   //
   // In case of 8 bytes stack alignment,
-  // ByValRegs may also contain information about wasted registers.
   // In function shown above, r3 would be wasted according to AAPCS rules.
-  // And in that case ByValRegs[1].Waste would be "true".
   // ByValRegs vector size still would be 2,
   // while "%t" goes to the stack: it wouldn't be described in ByValRegs.
   //
@@ -232,19 +232,13 @@
   // 3. Argument analysis (LowerFormatArguments, for example). After
   // some byval argument was analyzed, InRegsParamsProcessed is increased.
   struct ByValInfo {
-    ByValInfo(unsigned B, unsigned E, bool IsWaste = false) :
-      Begin(B), End(E), Waste(IsWaste) {}
+    ByValInfo(unsigned B, unsigned E) : Begin(B), End(E) {}
+
     // First register allocated for current parameter.
     unsigned Begin;
 
     // First after last register allocated for current parameter.
     unsigned End;
-
-    // Means that current range of registers doesn't belong to any
-    // parameters. It was wasted due to stack alignment rules.
-    // For more information see:
-    // AAPCS, 5.5 Parameter Passing, Stage C, C.3.
-    bool Waste;
   };
   SmallVector<ByValInfo, 4 > ByValRegs;
 
@@ -280,8 +274,8 @@
 
   /// isAllocated - Return true if the specified register (or an alias) is
   /// allocated.
-  bool isAllocated(unsigned Reg) const {
-    return UsedRegs[Reg/32] & (1 << (Reg&31));
+  bool isAllocated(MCRegister Reg) const {
+    return UsedRegs[Reg / 32] & (1 << (Reg & 31));
   }
 
   /// AnalyzeFormalArguments - Analyze an array of argument values,
@@ -331,7 +325,7 @@
   /// A shadow allocated register is a register that was allocated
   /// but wasn't added to the location list (Locs).
   /// \returns true if the register was allocated as shadow or false otherwise.
-  bool IsShadowAllocatedReg(unsigned Reg) const;
+  bool IsShadowAllocatedReg(MCRegister Reg) const;
 
   /// AnalyzeCallResult - Same as above except it's specialized for calls which
   /// produce a single value.
@@ -346,18 +340,25 @@
     return Regs.size();
   }
 
+  void DeallocateReg(MCPhysReg Reg) {
+    assert(isAllocated(Reg) && "Trying to deallocate an unallocated register");
+    MarkUnallocated(Reg);
+  }
+
   /// AllocateReg - Attempt to allocate one register.  If it is not available,
   /// return zero.  Otherwise, return the register, marking it and any aliases
   /// as allocated.
-  unsigned AllocateReg(unsigned Reg) {
-    if (isAllocated(Reg)) return 0;
+  MCRegister AllocateReg(MCPhysReg Reg) {
+    if (isAllocated(Reg))
+      return MCRegister();
     MarkAllocated(Reg);
     return Reg;
   }
 
   /// Version of AllocateReg with extra register to be shadowed.
-  unsigned AllocateReg(unsigned Reg, unsigned ShadowReg) {
-    if (isAllocated(Reg)) return 0;
+  MCRegister AllocateReg(MCPhysReg Reg, MCPhysReg ShadowReg) {
+    if (isAllocated(Reg))
+      return MCRegister();
     MarkAllocated(Reg);
     MarkAllocated(ShadowReg);
     return Reg;
@@ -366,13 +367,13 @@
   /// AllocateReg - Attempt to allocate one of the specified registers.  If none
   /// are available, return zero.  Otherwise, return the first one available,
   /// marking it and any aliases as allocated.
-  unsigned AllocateReg(ArrayRef<MCPhysReg> Regs) {
+  MCPhysReg AllocateReg(ArrayRef<MCPhysReg> Regs) {
     unsigned FirstUnalloc = getFirstUnallocated(Regs);
     if (FirstUnalloc == Regs.size())
-      return 0;    // Didn't find the reg.
+      return MCRegister();    // Didn't find the reg.
 
     // Mark the register and any aliases as allocated.
-    unsigned Reg = Regs[FirstUnalloc];
+    MCPhysReg Reg = Regs[FirstUnalloc];
     MarkAllocated(Reg);
     return Reg;
   }
@@ -380,7 +381,7 @@
   /// AllocateRegBlock - Attempt to allocate a block of RegsRequired consecutive
   /// registers. If this is not possible, return zero. Otherwise, return the first
   /// register of the block that were allocated, marking the entire block as allocated.
-  unsigned AllocateRegBlock(ArrayRef<MCPhysReg> Regs, unsigned RegsRequired) {
+  MCPhysReg AllocateRegBlock(ArrayRef<MCPhysReg> Regs, unsigned RegsRequired) {
     if (RegsRequired > Regs.size())
       return 0;
 
@@ -407,13 +408,13 @@
   }
 
   /// Version of AllocateReg with list of registers to be shadowed.
-  unsigned AllocateReg(ArrayRef<MCPhysReg> Regs, const MCPhysReg *ShadowRegs) {
+  MCRegister AllocateReg(ArrayRef<MCPhysReg> Regs, const MCPhysReg *ShadowRegs) {
     unsigned FirstUnalloc = getFirstUnallocated(Regs);
     if (FirstUnalloc == Regs.size())
-      return 0;    // Didn't find the reg.
+      return MCRegister();    // Didn't find the reg.
 
     // Mark the register and any aliases as allocated.
-    unsigned Reg = Regs[FirstUnalloc], ShadowReg = ShadowRegs[FirstUnalloc];
+    MCRegister Reg = Regs[FirstUnalloc], ShadowReg = ShadowRegs[FirstUnalloc];
     MarkAllocated(Reg);
     MarkAllocated(ShadowReg);
     return Reg;
@@ -421,42 +422,48 @@
 
   /// AllocateStack - Allocate a chunk of stack space with the specified size
   /// and alignment.
-  unsigned AllocateStack(unsigned Size, unsigned Align) {
-    assert(Align && ((Align - 1) & Align) == 0); // Align is power of 2.
-    StackOffset = alignTo(StackOffset, Align);
+  unsigned AllocateStack(unsigned Size, Align Alignment) {
+    StackOffset = alignTo(StackOffset, Alignment);
     unsigned Result = StackOffset;
     StackOffset += Size;
-    MaxStackArgAlign = std::max(Align, MaxStackArgAlign);
-    ensureMaxAlignment(Align);
+    MaxStackArgAlign = std::max(Alignment, MaxStackArgAlign);
+    ensureMaxAlignment(Alignment);
     return Result;
   }
 
-  void ensureMaxAlignment(unsigned Align) {
-    if (!AnalyzingMustTailForwardedRegs)
-      MF.getFrameInfo().ensureMaxAlignment(Align);
+  // FIXME: Deprecate this function when transition to Align is over.
+  LLVM_ATTRIBUTE_DEPRECATED(unsigned AllocateStack(unsigned Size,
+                                                   unsigned Alignment),
+                            "Use the version that takes Align instead.") {
+    return AllocateStack(Size, Align(Alignment));
   }
 
+  void ensureMaxAlignment(Align Alignment);
+
   /// Version of AllocateStack with extra register to be shadowed.
-  unsigned AllocateStack(unsigned Size, unsigned Align, unsigned ShadowReg) {
+  LLVM_ATTRIBUTE_DEPRECATED(unsigned AllocateStack(unsigned Size,
+                                                   unsigned Alignment,
+                                                   unsigned ShadowReg),
+                            "Use the version that takes Align instead.") {
     MarkAllocated(ShadowReg);
-    return AllocateStack(Size, Align);
+    return AllocateStack(Size, Align(Alignment));
   }
 
   /// Version of AllocateStack with list of extra registers to be shadowed.
   /// Note that, unlike AllocateReg, this shadows ALL of the shadow registers.
-  unsigned AllocateStack(unsigned Size, unsigned Align,
+  unsigned AllocateStack(unsigned Size, Align Alignment,
                          ArrayRef<MCPhysReg> ShadowRegs) {
     for (unsigned i = 0; i < ShadowRegs.size(); ++i)
       MarkAllocated(ShadowRegs[i]);
-    return AllocateStack(Size, Align);
+    return AllocateStack(Size, Alignment);
   }
 
   // HandleByVal - Allocate a stack slot large enough to pass an argument by
   // value. The size and alignment information of the argument is encoded in its
   // parameter attribute.
-  void HandleByVal(unsigned ValNo, MVT ValVT,
-                   MVT LocVT, CCValAssign::LocInfo LocInfo,
-                   int MinSize, int MinAlign, ISD::ArgFlagsTy ArgFlags);
+  void HandleByVal(unsigned ValNo, MVT ValVT, MVT LocVT,
+                   CCValAssign::LocInfo LocInfo, int MinSize, Align MinAlign,
+                   ISD::ArgFlagsTy ArgFlags);
 
   // Returns count of byval arguments that are to be stored (even partly)
   // in registers.
@@ -567,7 +574,9 @@
 
 private:
   /// MarkAllocated - Mark a register and all of its aliases as allocated.
-  void MarkAllocated(unsigned Reg);
+  void MarkAllocated(MCPhysReg Reg);
+
+  void MarkUnallocated(MCPhysReg Reg);
 };
 
 } // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/CodeGen/CodeGenPassBuilder.h b/linux-x64/clang/include/llvm/CodeGen/CodeGenPassBuilder.h
new file mode 100644
index 0000000..893bc6e
--- /dev/null
+++ b/linux-x64/clang/include/llvm/CodeGen/CodeGenPassBuilder.h
@@ -0,0 +1,1144 @@
+//===- Construction of codegen pass pipelines ------------------*- C++ -*--===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+/// \file
+///
+/// Interfaces for registering analysis passes, producing common pass manager
+/// configurations, and parsing of pass pipelines.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CODEGEN_CODEGENPASSBUILDER_H
+#define LLVM_CODEGEN_CODEGENPASSBUILDER_H
+
+#include "llvm/ADT/FunctionExtras.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Analysis/AliasAnalysis.h"
+#include "llvm/Analysis/BasicAliasAnalysis.h"
+#include "llvm/Analysis/CFLAndersAliasAnalysis.h"
+#include "llvm/Analysis/CFLSteensAliasAnalysis.h"
+#include "llvm/Analysis/ScopedNoAliasAA.h"
+#include "llvm/Analysis/TargetTransformInfo.h"
+#include "llvm/Analysis/TypeBasedAliasAnalysis.h"
+#include "llvm/CodeGen/ExpandReductions.h"
+#include "llvm/CodeGen/MachineModuleInfo.h"
+#include "llvm/CodeGen/MachinePassManager.h"
+#include "llvm/CodeGen/PreISelIntrinsicLowering.h"
+#include "llvm/CodeGen/UnreachableBlockElim.h"
+#include "llvm/IR/IRPrintingPasses.h"
+#include "llvm/IR/PassManager.h"
+#include "llvm/IR/Verifier.h"
+#include "llvm/MC/MCAsmInfo.h"
+#include "llvm/MC/MCStreamer.h"
+#include "llvm/MC/MCTargetOptions.h"
+#include "llvm/Support/CodeGen.h"
+#include "llvm/Support/Debug.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/ErrorHandling.h"
+#include "llvm/Target/CGPassBuilderOption.h"
+#include "llvm/Target/TargetMachine.h"
+#include "llvm/Transforms/Scalar.h"
+#include "llvm/Transforms/Scalar/ConstantHoisting.h"
+#include "llvm/Transforms/Scalar/LoopPassManager.h"
+#include "llvm/Transforms/Scalar/LoopStrengthReduce.h"
+#include "llvm/Transforms/Scalar/LowerConstantIntrinsics.h"
+#include "llvm/Transforms/Scalar/MergeICmps.h"
+#include "llvm/Transforms/Scalar/PartiallyInlineLibCalls.h"
+#include "llvm/Transforms/Scalar/ScalarizeMaskedMemIntrin.h"
+#include "llvm/Transforms/Utils.h"
+#include "llvm/Transforms/Utils/EntryExitInstrumenter.h"
+#include "llvm/Transforms/Utils/LowerInvoke.h"
+#include <cassert>
+#include <string>
+#include <type_traits>
+#include <utility>
+
+namespace llvm {
+
+// FIXME: Dummy target independent passes definitions that have not yet been
+// ported to new pass manager. Once they do, remove these.
+#define DUMMY_FUNCTION_PASS(NAME, PASS_NAME, CONSTRUCTOR)                      \
+  struct PASS_NAME : public PassInfoMixin<PASS_NAME> {                         \
+    template <typename... Ts> PASS_NAME(Ts &&...) {}                           \
+    PreservedAnalyses run(Function &, FunctionAnalysisManager &) {             \
+      return PreservedAnalyses::all();                                         \
+    }                                                                          \
+  };
+#define DUMMY_MODULE_PASS(NAME, PASS_NAME, CONSTRUCTOR)                        \
+  struct PASS_NAME : public PassInfoMixin<PASS_NAME> {                         \
+    template <typename... Ts> PASS_NAME(Ts &&...) {}                           \
+    PreservedAnalyses run(Module &, ModuleAnalysisManager &) {                 \
+      return PreservedAnalyses::all();                                         \
+    }                                                                          \
+  };
+#define DUMMY_MACHINE_MODULE_PASS(NAME, PASS_NAME, CONSTRUCTOR)                \
+  struct PASS_NAME : public PassInfoMixin<PASS_NAME> {                         \
+    template <typename... Ts> PASS_NAME(Ts &&...) {}                           \
+    Error run(Module &, MachineFunctionAnalysisManager &) {                    \
+      return Error::success();                                                 \
+    }                                                                          \
+    PreservedAnalyses run(MachineFunction &,                                   \
+                          MachineFunctionAnalysisManager &) {                  \
+      llvm_unreachable("this api is to make new PM api happy");                \
+    }                                                                          \
+    static AnalysisKey Key;                                                    \
+  };
+#define DUMMY_MACHINE_FUNCTION_PASS(NAME, PASS_NAME, CONSTRUCTOR)              \
+  struct PASS_NAME : public PassInfoMixin<PASS_NAME> {                         \
+    template <typename... Ts> PASS_NAME(Ts &&...) {}                           \
+    PreservedAnalyses run(MachineFunction &,                                   \
+                          MachineFunctionAnalysisManager &) {                  \
+      return PreservedAnalyses::all();                                         \
+    }                                                                          \
+    static AnalysisKey Key;                                                    \
+  };
+#include "MachinePassRegistry.def"
+
+/// This class provides access to building LLVM's passes.
+///
+/// Its members provide the baseline state available to passes during their
+/// construction. The \c MachinePassRegistry.def file specifies how to construct
+/// all of the built-in passes, and those may reference these members during
+/// construction.
+template <typename DerivedT> class CodeGenPassBuilder {
+public:
+  explicit CodeGenPassBuilder(LLVMTargetMachine &TM, CGPassBuilderOption Opts,
+                              PassInstrumentationCallbacks *PIC)
+      : TM(TM), Opt(Opts), PIC(PIC) {
+    // Target could set CGPassBuilderOption::MISchedPostRA to true to achieve
+    //     substitutePass(&PostRASchedulerID, &PostMachineSchedulerID)
+
+    // Target should override TM.Options.EnableIPRA in their target-specific
+    // LLVMTM ctor. See TargetMachine::setGlobalISel for example.
+    if (Opt.EnableIPRA)
+      TM.Options.EnableIPRA = *Opt.EnableIPRA;
+
+    if (Opt.EnableGlobalISelAbort)
+      TM.Options.GlobalISelAbort = *Opt.EnableGlobalISelAbort;
+
+    if (!Opt.OptimizeRegAlloc)
+      Opt.OptimizeRegAlloc = getOptLevel() != CodeGenOpt::None;
+  }
+
+  Error buildPipeline(ModulePassManager &MPM, MachineFunctionPassManager &MFPM,
+                      raw_pwrite_stream &Out, raw_pwrite_stream *DwoOut,
+                      CodeGenFileType FileType) const;
+
+  void registerModuleAnalyses(ModuleAnalysisManager &) const;
+  void registerFunctionAnalyses(FunctionAnalysisManager &) const;
+  void registerMachineFunctionAnalyses(MachineFunctionAnalysisManager &) const;
+  std::pair<StringRef, bool> getPassNameFromLegacyName(StringRef) const;
+
+  void registerAnalyses(MachineFunctionAnalysisManager &MFAM) const {
+    registerModuleAnalyses(*MFAM.MAM);
+    registerFunctionAnalyses(*MFAM.FAM);
+    registerMachineFunctionAnalyses(MFAM);
+  }
+
+  PassInstrumentationCallbacks *getPassInstrumentationCallbacks() const {
+    return PIC;
+  }
+
+protected:
+  template <typename PassT> using has_key_t = decltype(PassT::Key);
+
+  template <typename PassT>
+  using is_module_pass_t = decltype(std::declval<PassT &>().run(
+      std::declval<Module &>(), std::declval<ModuleAnalysisManager &>()));
+
+  template <typename PassT>
+  using is_function_pass_t = decltype(std::declval<PassT &>().run(
+      std::declval<Function &>(), std::declval<FunctionAnalysisManager &>()));
+
+  // Function object to maintain state while adding codegen IR passes.
+  class AddIRPass {
+  public:
+    AddIRPass(ModulePassManager &MPM, bool DebugPM, bool Check = true)
+        : MPM(MPM), FPM(DebugPM) {
+      if (Check)
+        AddingFunctionPasses = false;
+    }
+    ~AddIRPass() {
+      MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
+    }
+
+    // Add Function Pass
+    template <typename PassT>
+    std::enable_if_t<is_detected<is_function_pass_t, PassT>::value>
+    operator()(PassT &&Pass) {
+      if (AddingFunctionPasses && !*AddingFunctionPasses)
+        AddingFunctionPasses = true;
+      FPM.addPass(std::forward<PassT>(Pass));
+    }
+
+    // Add Module Pass
+    template <typename PassT>
+    std::enable_if_t<is_detected<is_module_pass_t, PassT>::value &&
+                     !is_detected<is_function_pass_t, PassT>::value>
+    operator()(PassT &&Pass) {
+      assert((!AddingFunctionPasses || !*AddingFunctionPasses) &&
+             "could not add module pass after adding function pass");
+      MPM.addPass(std::forward<PassT>(Pass));
+    }
+
+  private:
+    ModulePassManager &MPM;
+    FunctionPassManager FPM;
+    // The codegen IR pipeline are mostly function passes with the exceptions of
+    // a few loop and module passes. `AddingFunctionPasses` make sures that
+    // we could only add module passes at the beginning of the pipeline. Once
+    // we begin adding function passes, we could no longer add module passes.
+    // This special-casing introduces less adaptor passes. If we have the need
+    // of adding module passes after function passes, we could change the
+    // implementation to accommodate that.
+    Optional<bool> AddingFunctionPasses;
+  };
+
+  // Function object to maintain state while adding codegen machine passes.
+  class AddMachinePass {
+  public:
+    AddMachinePass(MachineFunctionPassManager &PM) : PM(PM) {}
+
+    template <typename PassT> void operator()(PassT &&Pass) {
+      static_assert(
+          is_detected<has_key_t, PassT>::value,
+          "Machine function pass must define a static member variable `Key`.");
+      for (auto &C : BeforeCallbacks)
+        if (!C(&PassT::Key))
+          return;
+      PM.addPass(std::forward<PassT>(Pass));
+      for (auto &C : AfterCallbacks)
+        C(&PassT::Key);
+    }
+
+    template <typename PassT> void insertPass(AnalysisKey *ID, PassT Pass) {
+      AfterCallbacks.emplace_back(
+          [this, ID, Pass = std::move(Pass)](AnalysisKey *PassID) {
+            if (PassID == ID)
+              this->PM.addPass(std::move(Pass));
+          });
+    }
+
+    void disablePass(AnalysisKey *ID) {
+      BeforeCallbacks.emplace_back(
+          [ID](AnalysisKey *PassID) { return PassID != ID; });
+    }
+
+    MachineFunctionPassManager releasePM() { return std::move(PM); }
+
+  private:
+    MachineFunctionPassManager &PM;
+    SmallVector<llvm::unique_function<bool(AnalysisKey *)>, 4> BeforeCallbacks;
+    SmallVector<llvm::unique_function<void(AnalysisKey *)>, 4> AfterCallbacks;
+  };
+
+  LLVMTargetMachine &TM;
+  CGPassBuilderOption Opt;
+  PassInstrumentationCallbacks *PIC;
+
+  /// Target override these hooks to parse target-specific analyses.
+  void registerTargetAnalysis(ModuleAnalysisManager &) const {}
+  void registerTargetAnalysis(FunctionAnalysisManager &) const {}
+  void registerTargetAnalysis(MachineFunctionAnalysisManager &) const {}
+  std::pair<StringRef, bool> getTargetPassNameFromLegacyName(StringRef) const {
+    return {"", false};
+  }
+
+  template <typename TMC> TMC &getTM() const { return static_cast<TMC &>(TM); }
+  CodeGenOpt::Level getOptLevel() const { return TM.getOptLevel(); }
+
+  /// Check whether or not GlobalISel should abort on error.
+  /// When this is disabled, GlobalISel will fall back on SDISel instead of
+  /// erroring out.
+  bool isGlobalISelAbortEnabled() const {
+    return TM.Options.GlobalISelAbort == GlobalISelAbortMode::Enable;
+  }
+
+  /// Check whether or not a diagnostic should be emitted when GlobalISel
+  /// uses the fallback path. In other words, it will emit a diagnostic
+  /// when GlobalISel failed and isGlobalISelAbortEnabled is false.
+  bool reportDiagnosticWhenGlobalISelFallback() const {
+    return TM.Options.GlobalISelAbort == GlobalISelAbortMode::DisableWithDiag;
+  }
+
+  /// addInstSelector - This method should install an instruction selector pass,
+  /// which converts from LLVM code to machine instructions.
+  Error addInstSelector(AddMachinePass &) const {
+    return make_error<StringError>("addInstSelector is not overridden",
+                                   inconvertibleErrorCode());
+  }
+
+  /// Add passes that optimize instruction level parallelism for out-of-order
+  /// targets. These passes are run while the machine code is still in SSA
+  /// form, so they can use MachineTraceMetrics to control their heuristics.
+  ///
+  /// All passes added here should preserve the MachineDominatorTree,
+  /// MachineLoopInfo, and MachineTraceMetrics analyses.
+  void addILPOpts(AddMachinePass &) const {}
+
+  /// This method may be implemented by targets that want to run passes
+  /// immediately before register allocation.
+  void addPreRegAlloc(AddMachinePass &) const {}
+
+  /// addPreRewrite - Add passes to the optimized register allocation pipeline
+  /// after register allocation is complete, but before virtual registers are
+  /// rewritten to physical registers.
+  ///
+  /// These passes must preserve VirtRegMap and LiveIntervals, and when running
+  /// after RABasic or RAGreedy, they should take advantage of LiveRegMatrix.
+  /// When these passes run, VirtRegMap contains legal physreg assignments for
+  /// all virtual registers.
+  ///
+  /// Note if the target overloads addRegAssignAndRewriteOptimized, this may not
+  /// be honored. This is also not generally used for the the fast variant,
+  /// where the allocation and rewriting are done in one pass.
+  void addPreRewrite(AddMachinePass &) const {}
+
+  /// Add passes to be run immediately after virtual registers are rewritten
+  /// to physical registers.
+  void addPostRewrite(AddMachinePass &) const {}
+
+  /// This method may be implemented by targets that want to run passes after
+  /// register allocation pass pipeline but before prolog-epilog insertion.
+  void addPostRegAlloc(AddMachinePass &) const {}
+
+  /// This method may be implemented by targets that want to run passes after
+  /// prolog-epilog insertion and before the second instruction scheduling pass.
+  void addPreSched2(AddMachinePass &) const {}
+
+  /// This pass may be implemented by targets that want to run passes
+  /// immediately before machine code is emitted.
+  void addPreEmitPass(AddMachinePass &) const {}
+
+  /// Targets may add passes immediately before machine code is emitted in this
+  /// callback. This is called even later than `addPreEmitPass`.
+  // FIXME: Rename `addPreEmitPass` to something more sensible given its actual
+  // position and remove the `2` suffix here as this callback is what
+  // `addPreEmitPass` *should* be but in reality isn't.
+  void addPreEmitPass2(AddMachinePass &) const {}
+
+  /// {{@ For GlobalISel
+  ///
+
+  /// addPreISel - This method should add any "last minute" LLVM->LLVM
+  /// passes (which are run just before instruction selector).
+  void addPreISel(AddIRPass &) const {
+    llvm_unreachable("addPreISel is not overridden");
+  }
+
+  /// This method should install an IR translator pass, which converts from
+  /// LLVM code to machine instructions with possibly generic opcodes.
+  Error addIRTranslator(AddMachinePass &) const {
+    return make_error<StringError>("addIRTranslator is not overridden",
+                                   inconvertibleErrorCode());
+  }
+
+  /// This method may be implemented by targets that want to run passes
+  /// immediately before legalization.
+  void addPreLegalizeMachineIR(AddMachinePass &) const {}
+
+  /// This method should install a legalize pass, which converts the instruction
+  /// sequence into one that can be selected by the target.
+  Error addLegalizeMachineIR(AddMachinePass &) const {
+    return make_error<StringError>("addLegalizeMachineIR is not overridden",
+                                   inconvertibleErrorCode());
+  }
+
+  /// This method may be implemented by targets that want to run passes
+  /// immediately before the register bank selection.
+  void addPreRegBankSelect(AddMachinePass &) const {}
+
+  /// This method should install a register bank selector pass, which
+  /// assigns register banks to virtual registers without a register
+  /// class or register banks.
+  Error addRegBankSelect(AddMachinePass &) const {
+    return make_error<StringError>("addRegBankSelect is not overridden",
+                                   inconvertibleErrorCode());
+  }
+
+  /// This method may be implemented by targets that want to run passes
+  /// immediately before the (global) instruction selection.
+  void addPreGlobalInstructionSelect(AddMachinePass &) const {}
+
+  /// This method should install a (global) instruction selector pass, which
+  /// converts possibly generic instructions to fully target-specific
+  /// instructions, thereby constraining all generic virtual registers to
+  /// register classes.
+  Error addGlobalInstructionSelect(AddMachinePass &) const {
+    return make_error<StringError>(
+        "addGlobalInstructionSelect is not overridden",
+        inconvertibleErrorCode());
+  }
+  /// @}}
+
+  /// High level function that adds all passes necessary to go from llvm IR
+  /// representation to the MI representation.
+  /// Adds IR based lowering and target specific optimization passes and finally
+  /// the core instruction selection passes.
+  /// \returns true if an error occurred, false otherwise.
+  void addISelPasses(AddIRPass &) const;
+
+  /// Add the actual instruction selection passes. This does not include
+  /// preparation passes on IR.
+  Error addCoreISelPasses(AddMachinePass &) const;
+
+  /// Add the complete, standard set of LLVM CodeGen passes.
+  /// Fully developed targets will not generally override this.
+  Error addMachinePasses(AddMachinePass &) const;
+
+  /// Add passes to lower exception handling for the code generator.
+  void addPassesToHandleExceptions(AddIRPass &) const;
+
+  /// Add common target configurable passes that perform LLVM IR to IR
+  /// transforms following machine independent optimization.
+  void addIRPasses(AddIRPass &) const;
+
+  /// Add pass to prepare the LLVM IR for code generation. This should be done
+  /// before exception handling preparation passes.
+  void addCodeGenPrepare(AddIRPass &) const;
+
+  /// Add common passes that perform LLVM IR to IR transforms in preparation for
+  /// instruction selection.
+  void addISelPrepare(AddIRPass &) const;
+
+  /// Methods with trivial inline returns are convenient points in the common
+  /// codegen pass pipeline where targets may insert passes. Methods with
+  /// out-of-line standard implementations are major CodeGen stages called by
+  /// addMachinePasses. Some targets may override major stages when inserting
+  /// passes is insufficient, but maintaining overriden stages is more work.
+  ///
+
+  /// addMachineSSAOptimization - Add standard passes that optimize machine
+  /// instructions in SSA form.
+  void addMachineSSAOptimization(AddMachinePass &) const;
+
+  /// addFastRegAlloc - Add the minimum set of target-independent passes that
+  /// are required for fast register allocation.
+  Error addFastRegAlloc(AddMachinePass &) const;
+
+  /// addOptimizedRegAlloc - Add passes related to register allocation.
+  /// LLVMTargetMachine provides standard regalloc passes for most targets.
+  void addOptimizedRegAlloc(AddMachinePass &) const;
+
+  /// Add passes that optimize machine instructions after register allocation.
+  void addMachineLateOptimization(AddMachinePass &) const;
+
+  /// addGCPasses - Add late codegen passes that analyze code for garbage
+  /// collection. This should return true if GC info should be printed after
+  /// these passes.
+  void addGCPasses(AddMachinePass &) const {}
+
+  /// Add standard basic block placement passes.
+  void addBlockPlacement(AddMachinePass &) const;
+
+  using CreateMCStreamer =
+      std::function<Expected<std::unique_ptr<MCStreamer>>(MCContext &)>;
+  void addAsmPrinter(AddMachinePass &, CreateMCStreamer) const {
+    llvm_unreachable("addAsmPrinter is not overridden");
+  }
+
+  /// Utilities for targets to add passes to the pass manager.
+  ///
+
+  /// createTargetRegisterAllocator - Create the register allocator pass for
+  /// this target at the current optimization level.
+  void addTargetRegisterAllocator(AddMachinePass &, bool Optimized) const;
+
+  /// addMachinePasses helper to create the target-selected or overriden
+  /// regalloc pass.
+  void addRegAllocPass(AddMachinePass &, bool Optimized) const;
+
+  /// Add core register alloator passes which do the actual register assignment
+  /// and rewriting. \returns true if any passes were added.
+  Error addRegAssignmentFast(AddMachinePass &) const;
+  Error addRegAssignmentOptimized(AddMachinePass &) const;
+
+private:
+  DerivedT &derived() { return static_cast<DerivedT &>(*this); }
+  const DerivedT &derived() const {
+    return static_cast<const DerivedT &>(*this);
+  }
+};
+
+template <typename Derived>
+Error CodeGenPassBuilder<Derived>::buildPipeline(
+    ModulePassManager &MPM, MachineFunctionPassManager &MFPM,
+    raw_pwrite_stream &Out, raw_pwrite_stream *DwoOut,
+    CodeGenFileType FileType) const {
+  AddIRPass addIRPass(MPM, Opt.DebugPM);
+  addISelPasses(addIRPass);
+
+  AddMachinePass addPass(MFPM);
+  if (auto Err = addCoreISelPasses(addPass))
+    return std::move(Err);
+
+  if (auto Err = derived().addMachinePasses(addPass))
+    return std::move(Err);
+
+  derived().addAsmPrinter(
+      addPass, [this, &Out, DwoOut, FileType](MCContext &Ctx) {
+        return this->TM.createMCStreamer(Out, DwoOut, FileType, Ctx);
+      });
+
+  addPass(FreeMachineFunctionPass());
+  return Error::success();
+}
+
+static inline AAManager registerAAAnalyses(CFLAAType UseCFLAA) {
+  AAManager AA;
+
+  // The order in which these are registered determines their priority when
+  // being queried.
+
+  switch (UseCFLAA) {
+  case CFLAAType::Steensgaard:
+    AA.registerFunctionAnalysis<CFLSteensAA>();
+    break;
+  case CFLAAType::Andersen:
+    AA.registerFunctionAnalysis<CFLAndersAA>();
+    break;
+  case CFLAAType::Both:
+    AA.registerFunctionAnalysis<CFLAndersAA>();
+    AA.registerFunctionAnalysis<CFLSteensAA>();
+    break;
+  default:
+    break;
+  }
+
+  // Basic AliasAnalysis support.
+  // Add TypeBasedAliasAnalysis before BasicAliasAnalysis so that
+  // BasicAliasAnalysis wins if they disagree. This is intended to help
+  // support "obvious" type-punning idioms.
+  AA.registerFunctionAnalysis<TypeBasedAA>();
+  AA.registerFunctionAnalysis<ScopedNoAliasAA>();
+  AA.registerFunctionAnalysis<BasicAA>();
+
+  return AA;
+}
+
+template <typename Derived>
+void CodeGenPassBuilder<Derived>::registerModuleAnalyses(
+    ModuleAnalysisManager &MAM) const {
+#define MODULE_ANALYSIS(NAME, PASS_NAME, CONSTRUCTOR)                          \
+  MAM.registerPass([&] { return PASS_NAME CONSTRUCTOR; });
+#include "MachinePassRegistry.def"
+  derived().registerTargetAnalysis(MAM);
+}
+
+template <typename Derived>
+void CodeGenPassBuilder<Derived>::registerFunctionAnalyses(
+    FunctionAnalysisManager &FAM) const {
+  FAM.registerPass([this] { return registerAAAnalyses(this->Opt.UseCFLAA); });
+
+#define FUNCTION_ANALYSIS(NAME, PASS_NAME, CONSTRUCTOR)                        \
+  FAM.registerPass([&] { return PASS_NAME CONSTRUCTOR; });
+#include "MachinePassRegistry.def"
+  derived().registerTargetAnalysis(FAM);
+}
+
+template <typename Derived>
+void CodeGenPassBuilder<Derived>::registerMachineFunctionAnalyses(
+    MachineFunctionAnalysisManager &MFAM) const {
+#define MACHINE_FUNCTION_ANALYSIS(NAME, PASS_NAME, CONSTRUCTOR)                \
+  MFAM.registerPass([&] { return PASS_NAME CONSTRUCTOR; });
+#include "MachinePassRegistry.def"
+  derived().registerTargetAnalysis(MFAM);
+}
+
+// FIXME: For new PM, use pass name directly in commandline seems good.
+// Translate stringfied pass name to its old commandline name. Returns the
+// matching legacy name and a boolean value indicating if the pass is a machine
+// pass.
+template <typename Derived>
+std::pair<StringRef, bool>
+CodeGenPassBuilder<Derived>::getPassNameFromLegacyName(StringRef Name) const {
+  std::pair<StringRef, bool> Ret;
+  if (Name.empty())
+    return Ret;
+
+#define FUNCTION_PASS(NAME, PASS_NAME, CONSTRUCTOR)                            \
+  if (Name == NAME)                                                            \
+    Ret = {#PASS_NAME, false};
+#define DUMMY_FUNCTION_PASS(NAME, PASS_NAME, CONSTRUCTOR)                      \
+  if (Name == NAME)                                                            \
+    Ret = {#PASS_NAME, false};
+#define MODULE_PASS(NAME, PASS_NAME, CONSTRUCTOR)                              \
+  if (Name == NAME)                                                            \
+    Ret = {#PASS_NAME, false};
+#define DUMMY_MODULE_PASS(NAME, PASS_NAME, CONSTRUCTOR)                        \
+  if (Name == NAME)                                                            \
+    Ret = {#PASS_NAME, false};
+#define MACHINE_MODULE_PASS(NAME, PASS_NAME, CONSTRUCTOR)                      \
+  if (Name == NAME)                                                            \
+    Ret = {#PASS_NAME, true};
+#define DUMMY_MACHINE_MODULE_PASS(NAME, PASS_NAME, CONSTRUCTOR)                \
+  if (Name == NAME)                                                            \
+    Ret = {#PASS_NAME, true};
+#define MACHINE_FUNCTION_PASS(NAME, PASS_NAME, CONSTRUCTOR)                    \
+  if (Name == NAME)                                                            \
+    Ret = {#PASS_NAME, true};
+#define DUMMY_MACHINE_FUNCTION_PASS(NAME, PASS_NAME, CONSTRUCTOR)              \
+  if (Name == NAME)                                                            \
+    Ret = {#PASS_NAME, true};
+#include "llvm/CodeGen/MachinePassRegistry.def"
+
+  if (Ret.first.empty())
+    Ret = derived().getTargetPassNameFromLegacyName(Name);
+
+  if (Ret.first.empty())
+    report_fatal_error(Twine('\"') + Twine(Name) +
+                       Twine("\" pass could not be found."));
+
+  return Ret;
+}
+
+template <typename Derived>
+void CodeGenPassBuilder<Derived>::addISelPasses(AddIRPass &addPass) const {
+  if (TM.useEmulatedTLS())
+    addPass(LowerEmuTLSPass());
+
+  addPass(PreISelIntrinsicLoweringPass());
+
+  derived().addIRPasses(addPass);
+  derived().addCodeGenPrepare(addPass);
+  addPassesToHandleExceptions(addPass);
+  derived().addISelPrepare(addPass);
+}
+
+/// Add common target configurable passes that perform LLVM IR to IR transforms
+/// following machine independent optimization.
+template <typename Derived>
+void CodeGenPassBuilder<Derived>::addIRPasses(AddIRPass &addPass) const {
+  // Before running any passes, run the verifier to determine if the input
+  // coming from the front-end and/or optimizer is valid.
+  if (!Opt.DisableVerify)
+    addPass(VerifierPass());
+
+  // Run loop strength reduction before anything else.
+  if (getOptLevel() != CodeGenOpt::None && !Opt.DisableLSR) {
+    addPass(createFunctionToLoopPassAdaptor(
+        LoopStrengthReducePass(), /*UseMemorySSA*/ true, Opt.DebugPM));
+    // FIXME: use -stop-after so we could remove PrintLSR
+    if (Opt.PrintLSR)
+      addPass(PrintFunctionPass(dbgs(), "\n\n*** Code after LSR ***\n"));
+  }
+
+  if (getOptLevel() != CodeGenOpt::None) {
+    // The MergeICmpsPass tries to create memcmp calls by grouping sequences of
+    // loads and compares. ExpandMemCmpPass then tries to expand those calls
+    // into optimally-sized loads and compares. The transforms are enabled by a
+    // target lowering hook.
+    if (!Opt.DisableMergeICmps)
+      addPass(MergeICmpsPass());
+    addPass(ExpandMemCmpPass());
+  }
+
+  // Run GC lowering passes for builtin collectors
+  // TODO: add a pass insertion point here
+  addPass(GCLoweringPass());
+  addPass(ShadowStackGCLoweringPass());
+  addPass(LowerConstantIntrinsicsPass());
+
+  // Make sure that no unreachable blocks are instruction selected.
+  addPass(UnreachableBlockElimPass());
+
+  // Prepare expensive constants for SelectionDAG.
+  if (getOptLevel() != CodeGenOpt::None && !Opt.DisableConstantHoisting)
+    addPass(ConstantHoistingPass());
+
+  if (getOptLevel() != CodeGenOpt::None && !Opt.DisablePartialLibcallInlining)
+    addPass(PartiallyInlineLibCallsPass());
+
+  // Instrument function entry and exit, e.g. with calls to mcount().
+  addPass(EntryExitInstrumenterPass(/*PostInlining=*/true));
+
+  // Add scalarization of target's unsupported masked memory intrinsics pass.
+  // the unsupported intrinsic will be replaced with a chain of basic blocks,
+  // that stores/loads element one-by-one if the appropriate mask bit is set.
+  addPass(ScalarizeMaskedMemIntrinPass());
+
+  // Expand reduction intrinsics into shuffle sequences if the target wants to.
+  addPass(ExpandReductionsPass());
+}
+
+/// Turn exception handling constructs into something the code generators can
+/// handle.
+template <typename Derived>
+void CodeGenPassBuilder<Derived>::addPassesToHandleExceptions(
+    AddIRPass &addPass) const {
+  const MCAsmInfo *MCAI = TM.getMCAsmInfo();
+  assert(MCAI && "No MCAsmInfo");
+  switch (MCAI->getExceptionHandlingType()) {
+  case ExceptionHandling::SjLj:
+    // SjLj piggy-backs on dwarf for this bit. The cleanups done apply to both
+    // Dwarf EH prepare needs to be run after SjLj prepare. Otherwise,
+    // catch info can get misplaced when a selector ends up more than one block
+    // removed from the parent invoke(s). This could happen when a landing
+    // pad is shared by multiple invokes and is also a target of a normal
+    // edge from elsewhere.
+    addPass(SjLjEHPreparePass());
+    LLVM_FALLTHROUGH;
+  case ExceptionHandling::DwarfCFI:
+  case ExceptionHandling::ARM:
+  case ExceptionHandling::AIX:
+    addPass(DwarfEHPass(getOptLevel()));
+    break;
+  case ExceptionHandling::WinEH:
+    // We support using both GCC-style and MSVC-style exceptions on Windows, so
+    // add both preparation passes. Each pass will only actually run if it
+    // recognizes the personality function.
+    addPass(WinEHPass());
+    addPass(DwarfEHPass(getOptLevel()));
+    break;
+  case ExceptionHandling::Wasm:
+    // Wasm EH uses Windows EH instructions, but it does not need to demote PHIs
+    // on catchpads and cleanuppads because it does not outline them into
+    // funclets. Catchswitch blocks are not lowered in SelectionDAG, so we
+    // should remove PHIs there.
+    addPass(WinEHPass(/*DemoteCatchSwitchPHIOnly=*/false));
+    addPass(WasmEHPass());
+    break;
+  case ExceptionHandling::None:
+    addPass(LowerInvokePass());
+
+    // The lower invoke pass may create unreachable code. Remove it.
+    addPass(UnreachableBlockElimPass());
+    break;
+  }
+}
+
+/// Add pass to prepare the LLVM IR for code generation. This should be done
+/// before exception handling preparation passes.
+template <typename Derived>
+void CodeGenPassBuilder<Derived>::addCodeGenPrepare(AddIRPass &addPass) const {
+  if (getOptLevel() != CodeGenOpt::None && !Opt.DisableCGP)
+    addPass(CodeGenPreparePass());
+  // TODO: Default ctor'd RewriteSymbolPass is no-op.
+  // addPass(RewriteSymbolPass());
+}
+
+/// Add common passes that perform LLVM IR to IR transforms in preparation for
+/// instruction selection.
+template <typename Derived>
+void CodeGenPassBuilder<Derived>::addISelPrepare(AddIRPass &addPass) const {
+  derived().addPreISel(addPass);
+
+  // Add both the safe stack and the stack protection passes: each of them will
+  // only protect functions that have corresponding attributes.
+  addPass(SafeStackPass());
+  addPass(StackProtectorPass());
+
+  if (Opt.PrintISelInput)
+    addPass(PrintFunctionPass(dbgs(),
+                              "\n\n*** Final LLVM Code input to ISel ***\n"));
+
+  // All passes which modify the LLVM IR are now complete; run the verifier
+  // to ensure that the IR is valid.
+  if (!Opt.DisableVerify)
+    addPass(VerifierPass());
+}
+
+template <typename Derived>
+Error CodeGenPassBuilder<Derived>::addCoreISelPasses(
+    AddMachinePass &addPass) const {
+  // Enable FastISel with -fast-isel, but allow that to be overridden.
+  TM.setO0WantsFastISel(Opt.EnableFastISelOption.getValueOr(true));
+
+  // Determine an instruction selector.
+  enum class SelectorType { SelectionDAG, FastISel, GlobalISel };
+  SelectorType Selector;
+
+  if (Opt.EnableFastISelOption && *Opt.EnableFastISelOption == true)
+    Selector = SelectorType::FastISel;
+  else if ((Opt.EnableGlobalISelOption &&
+            *Opt.EnableGlobalISelOption == true) ||
+           (TM.Options.EnableGlobalISel &&
+            (!Opt.EnableGlobalISelOption ||
+             *Opt.EnableGlobalISelOption == false)))
+    Selector = SelectorType::GlobalISel;
+  else if (TM.getOptLevel() == CodeGenOpt::None && TM.getO0WantsFastISel())
+    Selector = SelectorType::FastISel;
+  else
+    Selector = SelectorType::SelectionDAG;
+
+  // Set consistently TM.Options.EnableFastISel and EnableGlobalISel.
+  if (Selector == SelectorType::FastISel) {
+    TM.setFastISel(true);
+    TM.setGlobalISel(false);
+  } else if (Selector == SelectorType::GlobalISel) {
+    TM.setFastISel(false);
+    TM.setGlobalISel(true);
+  }
+
+  // Add instruction selector passes.
+  if (Selector == SelectorType::GlobalISel) {
+    if (auto Err = derived().addIRTranslator(addPass))
+      return std::move(Err);
+
+    derived().addPreLegalizeMachineIR(addPass);
+
+    if (auto Err = derived().addLegalizeMachineIR(addPass))
+      return std::move(Err);
+
+    // Before running the register bank selector, ask the target if it
+    // wants to run some passes.
+    derived().addPreRegBankSelect(addPass);
+
+    if (auto Err = derived().addRegBankSelect(addPass))
+      return std::move(Err);
+
+    derived().addPreGlobalInstructionSelect(addPass);
+
+    if (auto Err = derived().addGlobalInstructionSelect(addPass))
+      return std::move(Err);
+
+    // Pass to reset the MachineFunction if the ISel failed.
+    addPass(ResetMachineFunctionPass(reportDiagnosticWhenGlobalISelFallback(),
+                                     isGlobalISelAbortEnabled()));
+
+    // Provide a fallback path when we do not want to abort on
+    // not-yet-supported input.
+    if (!isGlobalISelAbortEnabled())
+      if (auto Err = derived().addInstSelector(addPass))
+        return std::move(Err);
+
+  } else if (auto Err = derived().addInstSelector(addPass))
+    return std::move(Err);
+
+  // Expand pseudo-instructions emitted by ISel. Don't run the verifier before
+  // FinalizeISel.
+  addPass(FinalizeISelPass());
+
+  // // Print the instruction selected machine code...
+  // printAndVerify("After Instruction Selection");
+
+  return Error::success();
+}
+
+/// Add the complete set of target-independent postISel code generator passes.
+///
+/// This can be read as the standard order of major LLVM CodeGen stages. Stages
+/// with nontrivial configuration or multiple passes are broken out below in
+/// add%Stage routines.
+///
+/// Any CodeGenPassBuilder<Derived>::addXX routine may be overriden by the
+/// Target. The addPre/Post methods with empty header implementations allow
+/// injecting target-specific fixups just before or after major stages.
+/// Additionally, targets have the flexibility to change pass order within a
+/// stage by overriding default implementation of add%Stage routines below. Each
+/// technique has maintainability tradeoffs because alternate pass orders are
+/// not well supported. addPre/Post works better if the target pass is easily
+/// tied to a common pass. But if it has subtle dependencies on multiple passes,
+/// the target should override the stage instead.
+template <typename Derived>
+Error CodeGenPassBuilder<Derived>::addMachinePasses(
+    AddMachinePass &addPass) const {
+  // Add passes that optimize machine instructions in SSA form.
+  if (getOptLevel() != CodeGenOpt::None) {
+    derived().addMachineSSAOptimization(addPass);
+  } else {
+    // If the target requests it, assign local variables to stack slots relative
+    // to one another and simplify frame index references where possible.
+    addPass(LocalStackSlotPass());
+  }
+
+  if (TM.Options.EnableIPRA)
+    addPass(RegUsageInfoPropagationPass());
+
+  // Run pre-ra passes.
+  derived().addPreRegAlloc(addPass);
+
+  // Run register allocation and passes that are tightly coupled with it,
+  // including phi elimination and scheduling.
+  if (*Opt.OptimizeRegAlloc) {
+    derived().addOptimizedRegAlloc(addPass);
+  } else {
+    if (auto Err = derived().addFastRegAlloc(addPass))
+      return Err;
+  }
+
+  // Run post-ra passes.
+  derived().addPostRegAlloc(addPass);
+
+  // Insert prolog/epilog code.  Eliminate abstract frame index references...
+  if (getOptLevel() != CodeGenOpt::None) {
+    addPass(PostRAMachineSinkingPass());
+    addPass(ShrinkWrapPass());
+  }
+
+  addPass(PrologEpilogInserterPass());
+
+  /// Add passes that optimize machine instructions after register allocation.
+  if (getOptLevel() != CodeGenOpt::None)
+    derived().addMachineLateOptimization(addPass);
+
+  // Expand pseudo instructions before second scheduling pass.
+  addPass(ExpandPostRAPseudosPass());
+
+  // Run pre-sched2 passes.
+  derived().addPreSched2(addPass);
+
+  if (Opt.EnableImplicitNullChecks)
+    addPass(ImplicitNullChecksPass());
+
+  // Second pass scheduler.
+  // Let Target optionally insert this pass by itself at some other
+  // point.
+  if (getOptLevel() != CodeGenOpt::None &&
+      !TM.targetSchedulesPostRAScheduling()) {
+    if (Opt.MISchedPostRA)
+      addPass(PostMachineSchedulerPass());
+    else
+      addPass(PostRASchedulerPass());
+  }
+
+  // GC
+  derived().addGCPasses(addPass);
+
+  // Basic block placement.
+  if (getOptLevel() != CodeGenOpt::None)
+    derived().addBlockPlacement(addPass);
+
+  // Insert before XRay Instrumentation.
+  addPass(FEntryInserterPass());
+
+  addPass(XRayInstrumentationPass());
+  addPass(PatchableFunctionPass());
+
+  derived().addPreEmitPass(addPass);
+
+  if (TM.Options.EnableIPRA)
+    // Collect register usage information and produce a register mask of
+    // clobbered registers, to be used to optimize call sites.
+    addPass(RegUsageInfoCollectorPass());
+
+  addPass(FuncletLayoutPass());
+
+  addPass(StackMapLivenessPass());
+  addPass(LiveDebugValuesPass());
+
+  if (TM.Options.EnableMachineOutliner && getOptLevel() != CodeGenOpt::None &&
+      Opt.EnableMachineOutliner != RunOutliner::NeverOutline) {
+    bool RunOnAllFunctions =
+        (Opt.EnableMachineOutliner == RunOutliner::AlwaysOutline);
+    bool AddOutliner = RunOnAllFunctions || TM.Options.SupportsDefaultOutlining;
+    if (AddOutliner)
+      addPass(MachineOutlinerPass(RunOnAllFunctions));
+  }
+
+  // Add passes that directly emit MI after all other MI passes.
+  derived().addPreEmitPass2(addPass);
+
+  return Error::success();
+}
+
+/// Add passes that optimize machine instructions in SSA form.
+template <typename Derived>
+void CodeGenPassBuilder<Derived>::addMachineSSAOptimization(
+    AddMachinePass &addPass) const {
+  // Pre-ra tail duplication.
+  addPass(EarlyTailDuplicatePass());
+
+  // Optimize PHIs before DCE: removing dead PHI cycles may make more
+  // instructions dead.
+  addPass(OptimizePHIsPass());
+
+  // This pass merges large allocas. StackSlotColoring is a different pass
+  // which merges spill slots.
+  addPass(StackColoringPass());
+
+  // If the target requests it, assign local variables to stack slots relative
+  // to one another and simplify frame index references where possible.
+  addPass(LocalStackSlotPass());
+
+  // With optimization, dead code should already be eliminated. However
+  // there is one known exception: lowered code for arguments that are only
+  // used by tail calls, where the tail calls reuse the incoming stack
+  // arguments directly (see t11 in test/CodeGen/X86/sibcall.ll).
+  addPass(DeadMachineInstructionElimPass());
+
+  // Allow targets to insert passes that improve instruction level parallelism,
+  // like if-conversion. Such passes will typically need dominator trees and
+  // loop info, just like LICM and CSE below.
+  derived().addILPOpts(addPass);
+
+  addPass(EarlyMachineLICMPass());
+  addPass(MachineCSEPass());
+
+  addPass(MachineSinkingPass());
+
+  addPass(PeepholeOptimizerPass());
+  // Clean-up the dead code that may have been generated by peephole
+  // rewriting.
+  addPass(DeadMachineInstructionElimPass());
+}
+
+//===---------------------------------------------------------------------===//
+/// Register Allocation Pass Configuration
+//===---------------------------------------------------------------------===//
+
+/// Instantiate the default register allocator pass for this target for either
+/// the optimized or unoptimized allocation path. This will be added to the pass
+/// manager by addFastRegAlloc in the unoptimized case or addOptimizedRegAlloc
+/// in the optimized case.
+///
+/// A target that uses the standard regalloc pass order for fast or optimized
+/// allocation may still override this for per-target regalloc
+/// selection. But -regalloc=... always takes precedence.
+template <typename Derived>
+void CodeGenPassBuilder<Derived>::addTargetRegisterAllocator(
+    AddMachinePass &addPass, bool Optimized) const {
+  if (Optimized)
+    addPass(RAGreedyPass());
+  else
+    addPass(RAFastPass());
+}
+
+/// Find and instantiate the register allocation pass requested by this target
+/// at the current optimization level.  Different register allocators are
+/// defined as separate passes because they may require different analysis.
+template <typename Derived>
+void CodeGenPassBuilder<Derived>::addRegAllocPass(AddMachinePass &addPass,
+                                                  bool Optimized) const {
+  if (Opt.RegAlloc == RegAllocType::Default)
+    // With no -regalloc= override, ask the target for a regalloc pass.
+    derived().addTargetRegisterAllocator(addPass, Optimized);
+  else if (Opt.RegAlloc == RegAllocType::Basic)
+    addPass(RABasicPass());
+  else if (Opt.RegAlloc == RegAllocType::Fast)
+    addPass(RAFastPass());
+  else if (Opt.RegAlloc == RegAllocType::Greedy)
+    addPass(RAGreedyPass());
+  else if (Opt.RegAlloc == RegAllocType::PBQP)
+    addPass(RAPBQPPass());
+  else
+    llvm_unreachable("unknonwn register allocator type");
+}
+
+template <typename Derived>
+Error CodeGenPassBuilder<Derived>::addRegAssignmentFast(
+    AddMachinePass &addPass) const {
+  if (Opt.RegAlloc != RegAllocType::Default &&
+      Opt.RegAlloc != RegAllocType::Fast)
+    return make_error<StringError>(
+        "Must use fast (default) register allocator for unoptimized regalloc.",
+        inconvertibleErrorCode());
+
+  addRegAllocPass(addPass, false);
+  return Error::success();
+}
+
+template <typename Derived>
+Error CodeGenPassBuilder<Derived>::addRegAssignmentOptimized(
+    AddMachinePass &addPass) const {
+  // Add the selected register allocation pass.
+  addRegAllocPass(addPass, true);
+
+  // Allow targets to change the register assignments before rewriting.
+  derived().addPreRewrite(addPass);
+
+  // Finally rewrite virtual registers.
+  addPass(VirtRegRewriterPass());
+  // Perform stack slot coloring and post-ra machine LICM.
+  //
+  // FIXME: Re-enable coloring with register when it's capable of adding
+  // kill markers.
+  addPass(StackSlotColoringPass());
+
+  return Error::success();
+}
+
+/// Add the minimum set of target-independent passes that are required for
+/// register allocation. No coalescing or scheduling.
+template <typename Derived>
+Error CodeGenPassBuilder<Derived>::addFastRegAlloc(
+    AddMachinePass &addPass) const {
+  addPass(PHIEliminationPass());
+  addPass(TwoAddressInstructionPass());
+  return derived().addRegAssignmentFast(addPass);
+}
+
+/// Add standard target-independent passes that are tightly coupled with
+/// optimized register allocation, including coalescing, machine instruction
+/// scheduling, and register allocation itself.
+template <typename Derived>
+void CodeGenPassBuilder<Derived>::addOptimizedRegAlloc(
+    AddMachinePass &addPass) const {
+  addPass(DetectDeadLanesPass());
+
+  addPass(ProcessImplicitDefsPass());
+
+  // Edge splitting is smarter with machine loop info.
+  addPass(PHIEliminationPass());
+
+  // Eventually, we want to run LiveIntervals before PHI elimination.
+  if (Opt.EarlyLiveIntervals)
+    addPass(LiveIntervalsPass());
+
+  addPass(TwoAddressInstructionPass());
+  addPass(RegisterCoalescerPass());
+
+  // The machine scheduler may accidentally create disconnected components
+  // when moving subregister definitions around, avoid this by splitting them to
+  // separate vregs before. Splitting can also improve reg. allocation quality.
+  addPass(RenameIndependentSubregsPass());
+
+  // PreRA instruction scheduling.
+  addPass(MachineSchedulerPass());
+
+  if (derived().addRegAssignmentOptimized(addPass)) {
+    // Allow targets to expand pseudo instructions depending on the choice of
+    // registers before MachineCopyPropagation.
+    derived().addPostRewrite(addPass);
+
+    // Copy propagate to forward register uses and try to eliminate COPYs that
+    // were not coalesced.
+    addPass(MachineCopyPropagationPass());
+
+    // Run post-ra machine LICM to hoist reloads / remats.
+    //
+    // FIXME: can this move into MachineLateOptimization?
+    addPass(MachineLICMPass());
+  }
+}
+
+//===---------------------------------------------------------------------===//
+/// Post RegAlloc Pass Configuration
+//===---------------------------------------------------------------------===//
+
+/// Add passes that optimize machine instructions after register allocation.
+template <typename Derived>
+void CodeGenPassBuilder<Derived>::addMachineLateOptimization(
+    AddMachinePass &addPass) const {
+  // Branch folding must be run after regalloc and prolog/epilog insertion.
+  addPass(BranchFolderPass());
+
+  // Tail duplication.
+  // Note that duplicating tail just increases code size and degrades
+  // performance for targets that require Structured Control Flow.
+  // In addition it can also make CFG irreducible. Thus we disable it.
+  if (!TM.requiresStructuredCFG())
+    addPass(TailDuplicatePass());
+
+  // Copy propagation.
+  addPass(MachineCopyPropagationPass());
+}
+
+/// Add standard basic block placement passes.
+template <typename Derived>
+void CodeGenPassBuilder<Derived>::addBlockPlacement(
+    AddMachinePass &addPass) const {
+  addPass(MachineBlockPlacementPass());
+  // Run a separate pass to collect block placement statistics.
+  if (Opt.EnableBlockPlacementStats)
+    addPass(MachineBlockPlacementStatsPass());
+}
+
+} // namespace llvm
+
+#endif // LLVM_CODEGEN_CODEGENPASSBUILDER_H
diff --git a/linux-x64/clang/include/llvm/CodeGen/CommandFlags.h b/linux-x64/clang/include/llvm/CodeGen/CommandFlags.h
new file mode 100644
index 0000000..e6c64cd
--- /dev/null
+++ b/linux-x64/clang/include/llvm/CodeGen/CommandFlags.h
@@ -0,0 +1,175 @@
+//===-- CommandFlags.h - Command Line Flags Interface -----------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains codegen-specific flags that are shared between different
+// command line tools. The tools "llc" and "opt" both use this file to prevent
+// flag duplication.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/ADT/FloatingPointMode.h"
+#include "llvm/ADT/StringExtras.h"
+#include "llvm/ADT/Triple.h"
+#include "llvm/IR/Instructions.h"
+#include "llvm/IR/Intrinsics.h"
+#include "llvm/MC/MCTargetOptionsCommandFlags.h"
+#include "llvm/Support/CodeGen.h"
+#include "llvm/Target/TargetOptions.h"
+#include <string>
+#include <vector>
+
+namespace llvm {
+
+class Module;
+
+namespace codegen {
+
+std::string getMArch();
+
+std::string getMCPU();
+
+std::vector<std::string> getMAttrs();
+
+Reloc::Model getRelocModel();
+Optional<Reloc::Model> getExplicitRelocModel();
+
+ThreadModel::Model getThreadModel();
+
+CodeModel::Model getCodeModel();
+Optional<CodeModel::Model> getExplicitCodeModel();
+
+llvm::ExceptionHandling getExceptionModel();
+
+CodeGenFileType getFileType();
+Optional<CodeGenFileType> getExplicitFileType();
+
+CodeGenFileType getFileType();
+
+llvm::FramePointer::FP getFramePointerUsage();
+
+bool getEnableUnsafeFPMath();
+
+bool getEnableNoInfsFPMath();
+
+bool getEnableNoNaNsFPMath();
+
+bool getEnableNoSignedZerosFPMath();
+
+bool getEnableNoTrappingFPMath();
+
+DenormalMode::DenormalModeKind getDenormalFPMath();
+DenormalMode::DenormalModeKind getDenormalFP32Math();
+
+bool getEnableHonorSignDependentRoundingFPMath();
+
+llvm::FloatABI::ABIType getFloatABIForCalls();
+
+llvm::FPOpFusion::FPOpFusionMode getFuseFPOps();
+
+bool getDontPlaceZerosInBSS();
+
+bool getEnableGuaranteedTailCallOpt();
+
+bool getEnableAIXExtendedAltivecABI();
+
+bool getDisableTailCalls();
+
+bool getStackSymbolOrdering();
+
+unsigned getOverrideStackAlignment();
+
+bool getStackRealign();
+
+std::string getTrapFuncName();
+
+bool getUseCtors();
+
+bool getRelaxELFRelocations();
+
+bool getDataSections();
+Optional<bool> getExplicitDataSections();
+
+bool getFunctionSections();
+Optional<bool> getExplicitFunctionSections();
+
+bool getIgnoreXCOFFVisibility();
+
+bool getXCOFFTracebackTable();
+
+std::string getBBSections();
+
+std::string getStackProtectorGuard();
+unsigned getStackProtectorGuardOffset();
+std::string getStackProtectorGuardReg();
+
+unsigned getTLSSize();
+
+bool getEmulatedTLS();
+
+bool getUniqueSectionNames();
+
+bool getUniqueBasicBlockSectionNames();
+
+llvm::EABI getEABIVersion();
+
+llvm::DebuggerKind getDebuggerTuningOpt();
+
+bool getEnableStackSizeSection();
+
+bool getEnableAddrsig();
+
+bool getEmitCallSiteInfo();
+
+bool getEnableMachineFunctionSplitter();
+
+bool getEnableDebugEntryValues();
+
+bool getPseudoProbeForProfiling();
+
+bool getValueTrackingVariableLocations();
+
+bool getForceDwarfFrameSection();
+
+bool getXRayOmitFunctionIndex();
+
+/// Create this object with static storage to register codegen-related command
+/// line options.
+struct RegisterCodeGenFlags {
+  RegisterCodeGenFlags();
+};
+
+llvm::BasicBlockSection getBBSectionsMode(llvm::TargetOptions &Options);
+
+llvm::StackProtectorGuards
+getStackProtectorGuardMode(llvm::TargetOptions &Options);
+
+/// Common utility function tightly tied to the options listed here. Initializes
+/// a TargetOptions object with CodeGen flags and returns it.
+/// \p TheTriple is used to determine the default value for options if
+///    options are not explicitly specified. If those triple dependant options
+///    value do not have effect for your component, a default Triple() could be
+///    passed in.
+TargetOptions InitTargetOptionsFromCodeGenFlags(const llvm::Triple &TheTriple);
+
+std::string getCPUStr();
+
+std::string getFeaturesStr();
+
+std::vector<std::string> getFeatureList();
+
+void renderBoolStringAttr(AttrBuilder &B, StringRef Name, bool Val);
+
+/// Set function attributes of function \p F based on CPU, Features, and command
+/// line flags.
+void setFunctionAttributes(StringRef CPU, StringRef Features, Function &F);
+
+/// Set function attributes of functions in Module M based on CPU,
+/// Features, and command line flags.
+void setFunctionAttributes(StringRef CPU, StringRef Features, Module &M);
+} // namespace codegen
+} // namespace llvm
diff --git a/linux-x64/clang/include/llvm/CodeGen/CommandFlags.inc b/linux-x64/clang/include/llvm/CodeGen/CommandFlags.inc
deleted file mode 100644
index cb69e9f..0000000
--- a/linux-x64/clang/include/llvm/CodeGen/CommandFlags.inc
+++ /dev/null
@@ -1,411 +0,0 @@
-//===-- CommandFlags.h - Command Line Flags Interface -----------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// This file contains codegen-specific flags that are shared between different
-// command line tools. The tools "llc" and "opt" both use this file to prevent
-// flag duplication.
-//
-//===----------------------------------------------------------------------===//
-
-#include "llvm/ADT/StringExtras.h"
-#include "llvm/IR/Instructions.h"
-#include "llvm/IR/Intrinsics.h"
-#include "llvm/IR/Module.h"
-#include "llvm/MC/MCTargetOptionsCommandFlags.inc"
-#include "llvm/MC/SubtargetFeature.h"
-#include "llvm/Support/CodeGen.h"
-#include "llvm/Support/CommandLine.h"
-#include "llvm/Support/Host.h"
-#include "llvm/Target/TargetMachine.h"
-#include "llvm/Target/TargetOptions.h"
-#include <string>
-using namespace llvm;
-
-static cl::opt<std::string>
-    MArch("march",
-          cl::desc("Architecture to generate code for (see --version)"));
-
-static cl::opt<std::string>
-    MCPU("mcpu",
-         cl::desc("Target a specific cpu type (-mcpu=help for details)"),
-         cl::value_desc("cpu-name"), cl::init(""));
-
-static cl::list<std::string>
-    MAttrs("mattr", cl::CommaSeparated,
-           cl::desc("Target specific attributes (-mattr=help for details)"),
-           cl::value_desc("a1,+a2,-a3,..."));
-
-static cl::opt<Reloc::Model> RelocModel(
-    "relocation-model", cl::desc("Choose relocation model"),
-    cl::values(
-        clEnumValN(Reloc::Static, "static", "Non-relocatable code"),
-        clEnumValN(Reloc::PIC_, "pic",
-                   "Fully relocatable, position independent code"),
-        clEnumValN(Reloc::DynamicNoPIC, "dynamic-no-pic",
-                   "Relocatable external references, non-relocatable code"),
-        clEnumValN(Reloc::ROPI, "ropi",
-                   "Code and read-only data relocatable, accessed PC-relative"),
-        clEnumValN(
-            Reloc::RWPI, "rwpi",
-            "Read-write data relocatable, accessed relative to static base"),
-        clEnumValN(Reloc::ROPI_RWPI, "ropi-rwpi",
-                   "Combination of ropi and rwpi")));
-
-LLVM_ATTRIBUTE_UNUSED static Optional<Reloc::Model> getRelocModel() {
-  if (RelocModel.getNumOccurrences()) {
-    Reloc::Model R = RelocModel;
-    return R;
-  }
-  return None;
-}
-
-static cl::opt<ThreadModel::Model> TMModel(
-    "thread-model", cl::desc("Choose threading model"),
-    cl::init(ThreadModel::POSIX),
-    cl::values(clEnumValN(ThreadModel::POSIX, "posix", "POSIX thread model"),
-               clEnumValN(ThreadModel::Single, "single",
-                          "Single thread model")));
-
-static cl::opt<llvm::CodeModel::Model> CMModel(
-    "code-model", cl::desc("Choose code model"),
-    cl::values(clEnumValN(CodeModel::Tiny, "tiny", "Tiny code model"),
-               clEnumValN(CodeModel::Small, "small", "Small code model"),
-               clEnumValN(CodeModel::Kernel, "kernel", "Kernel code model"),
-               clEnumValN(CodeModel::Medium, "medium", "Medium code model"),
-               clEnumValN(CodeModel::Large, "large", "Large code model")));
-
-LLVM_ATTRIBUTE_UNUSED static Optional<CodeModel::Model> getCodeModel() {
-  if (CMModel.getNumOccurrences()) {
-    CodeModel::Model M = CMModel;
-    return M;
-  }
-  return None;
-}
-
-static cl::opt<llvm::ExceptionHandling> ExceptionModel(
-    "exception-model", cl::desc("exception model"),
-    cl::init(ExceptionHandling::None),
-    cl::values(
-        clEnumValN(ExceptionHandling::None, "default",
-                   "default exception handling model"),
-        clEnumValN(ExceptionHandling::DwarfCFI, "dwarf",
-                   "DWARF-like CFI based exception handling"),
-        clEnumValN(ExceptionHandling::SjLj, "sjlj", "SjLj exception handling"),
-        clEnumValN(ExceptionHandling::ARM, "arm", "ARM EHABI exceptions"),
-        clEnumValN(ExceptionHandling::WinEH, "wineh",
-                   "Windows exception model"),
-        clEnumValN(ExceptionHandling::Wasm, "wasm",
-                   "WebAssembly exception handling")));
-
-static cl::opt<TargetMachine::CodeGenFileType> FileType(
-    "filetype", cl::init(TargetMachine::CGFT_AssemblyFile),
-    cl::desc(
-        "Choose a file type (not all types are supported by all targets):"),
-    cl::values(clEnumValN(TargetMachine::CGFT_AssemblyFile, "asm",
-                          "Emit an assembly ('.s') file"),
-               clEnumValN(TargetMachine::CGFT_ObjectFile, "obj",
-                          "Emit a native object ('.o') file"),
-               clEnumValN(TargetMachine::CGFT_Null, "null",
-                          "Emit nothing, for performance testing")));
-
-static cl::opt<llvm::FramePointer::FP> FramePointerUsage(
-    "frame-pointer", cl::desc("Specify frame pointer elimination optimization"),
-    cl::init(llvm::FramePointer::None),
-    cl::values(
-        clEnumValN(llvm::FramePointer::All, "all",
-                   "Disable frame pointer elimination"),
-        clEnumValN(llvm::FramePointer::NonLeaf, "non-leaf",
-                   "Disable frame pointer elimination for non-leaf frame"),
-        clEnumValN(llvm::FramePointer::None, "none",
-                   "Enable frame pointer elimination")));
-
-static cl::opt<bool> EnableUnsafeFPMath(
-    "enable-unsafe-fp-math",
-    cl::desc("Enable optimizations that may decrease FP precision"),
-    cl::init(false));
-
-static cl::opt<bool> EnableNoInfsFPMath(
-    "enable-no-infs-fp-math",
-    cl::desc("Enable FP math optimizations that assume no +-Infs"),
-    cl::init(false));
-
-static cl::opt<bool> EnableNoNaNsFPMath(
-    "enable-no-nans-fp-math",
-    cl::desc("Enable FP math optimizations that assume no NaNs"),
-    cl::init(false));
-
-static cl::opt<bool> EnableNoSignedZerosFPMath(
-    "enable-no-signed-zeros-fp-math",
-    cl::desc("Enable FP math optimizations that assume "
-             "the sign of 0 is insignificant"),
-    cl::init(false));
-
-static cl::opt<bool>
-    EnableNoTrappingFPMath("enable-no-trapping-fp-math",
-                           cl::desc("Enable setting the FP exceptions build "
-                                    "attribute not to use exceptions"),
-                           cl::init(false));
-
-static cl::opt<llvm::FPDenormal::DenormalMode> DenormalMode(
-    "denormal-fp-math",
-    cl::desc("Select which denormal numbers the code is permitted to require"),
-    cl::init(FPDenormal::IEEE),
-    cl::values(clEnumValN(FPDenormal::IEEE, "ieee",
-                          "IEEE 754 denormal numbers"),
-               clEnumValN(FPDenormal::PreserveSign, "preserve-sign",
-                          "the sign of a  flushed-to-zero number is preserved "
-                          "in the sign of 0"),
-               clEnumValN(FPDenormal::PositiveZero, "positive-zero",
-                          "denormals are flushed to positive zero")));
-
-static cl::opt<bool> EnableHonorSignDependentRoundingFPMath(
-    "enable-sign-dependent-rounding-fp-math", cl::Hidden,
-    cl::desc("Force codegen to assume rounding mode can change dynamically"),
-    cl::init(false));
-
-static cl::opt<llvm::FloatABI::ABIType> FloatABIForCalls(
-    "float-abi", cl::desc("Choose float ABI type"), cl::init(FloatABI::Default),
-    cl::values(clEnumValN(FloatABI::Default, "default",
-                          "Target default float ABI type"),
-               clEnumValN(FloatABI::Soft, "soft",
-                          "Soft float ABI (implied by -soft-float)"),
-               clEnumValN(FloatABI::Hard, "hard",
-                          "Hard float ABI (uses FP registers)")));
-
-static cl::opt<llvm::FPOpFusion::FPOpFusionMode> FuseFPOps(
-    "fp-contract", cl::desc("Enable aggressive formation of fused FP ops"),
-    cl::init(FPOpFusion::Standard),
-    cl::values(
-        clEnumValN(FPOpFusion::Fast, "fast", "Fuse FP ops whenever profitable"),
-        clEnumValN(FPOpFusion::Standard, "on", "Only fuse 'blessed' FP ops."),
-        clEnumValN(FPOpFusion::Strict, "off",
-                   "Only fuse FP ops when the result won't be affected.")));
-
-static cl::opt<bool> DontPlaceZerosInBSS(
-    "nozero-initialized-in-bss",
-    cl::desc("Don't place zero-initialized symbols into bss section"),
-    cl::init(false));
-
-static cl::opt<bool> EnableGuaranteedTailCallOpt(
-    "tailcallopt",
-    cl::desc(
-        "Turn fastcc calls into tail calls by (potentially) changing ABI."),
-    cl::init(false));
-
-static cl::opt<bool> DisableTailCalls("disable-tail-calls",
-                                      cl::desc("Never emit tail calls"),
-                                      cl::init(false));
-
-static cl::opt<bool> StackSymbolOrdering("stack-symbol-ordering",
-                                         cl::desc("Order local stack symbols."),
-                                         cl::init(true));
-
-static cl::opt<unsigned>
-    OverrideStackAlignment("stack-alignment",
-                           cl::desc("Override default stack alignment"),
-                           cl::init(0));
-
-static cl::opt<bool>
-    StackRealign("stackrealign",
-                 cl::desc("Force align the stack to the minimum alignment"),
-                 cl::init(false));
-
-static cl::opt<std::string> TrapFuncName(
-    "trap-func", cl::Hidden,
-    cl::desc("Emit a call to trap function rather than a trap instruction"),
-    cl::init(""));
-
-static cl::opt<bool> UseCtors("use-ctors",
-                              cl::desc("Use .ctors instead of .init_array."),
-                              cl::init(false));
-
-static cl::opt<bool> RelaxELFRelocations(
-    "relax-elf-relocations",
-    cl::desc("Emit GOTPCRELX/REX_GOTPCRELX instead of GOTPCREL on x86-64 ELF"),
-    cl::init(false));
-
-static cl::opt<bool> DataSections("data-sections",
-                                  cl::desc("Emit data into separate sections"),
-                                  cl::init(false));
-
-static cl::opt<bool>
-    FunctionSections("function-sections",
-                     cl::desc("Emit functions into separate sections"),
-                     cl::init(false));
-
-static cl::opt<bool> EmulatedTLS("emulated-tls",
-                                 cl::desc("Use emulated TLS model"),
-                                 cl::init(false));
-
-static cl::opt<bool>
-    UniqueSectionNames("unique-section-names",
-                       cl::desc("Give unique names to every section"),
-                       cl::init(true));
-
-static cl::opt<llvm::EABI>
-    EABIVersion("meabi", cl::desc("Set EABI type (default depends on triple):"),
-                cl::init(EABI::Default),
-                cl::values(clEnumValN(EABI::Default, "default",
-                                      "Triple default EABI version"),
-                           clEnumValN(EABI::EABI4, "4", "EABI version 4"),
-                           clEnumValN(EABI::EABI5, "5", "EABI version 5"),
-                           clEnumValN(EABI::GNU, "gnu", "EABI GNU")));
-
-static cl::opt<DebuggerKind> DebuggerTuningOpt(
-    "debugger-tune", cl::desc("Tune debug info for a particular debugger"),
-    cl::init(DebuggerKind::Default),
-    cl::values(clEnumValN(DebuggerKind::GDB, "gdb", "gdb"),
-               clEnumValN(DebuggerKind::LLDB, "lldb", "lldb"),
-               clEnumValN(DebuggerKind::SCE, "sce", "SCE targets (e.g. PS4)")));
-
-static cl::opt<bool> EnableStackSizeSection(
-    "stack-size-section",
-    cl::desc("Emit a section containing stack size metadata"), cl::init(false));
-
-static cl::opt<bool>
-    EnableAddrsig("addrsig", cl::desc("Emit an address-significance table"),
-                  cl::init(false));
-
-static cl::opt<bool>
-    EnableDebugEntryValues("debug-entry-values",
-                           cl::desc("Emit debug info about parameter's entry values"),
-                           cl::init(false));
-
-// Common utility function tightly tied to the options listed here. Initializes
-// a TargetOptions object with CodeGen flags and returns it.
-static TargetOptions InitTargetOptionsFromCodeGenFlags() {
-  TargetOptions Options;
-  Options.AllowFPOpFusion = FuseFPOps;
-  Options.UnsafeFPMath = EnableUnsafeFPMath;
-  Options.NoInfsFPMath = EnableNoInfsFPMath;
-  Options.NoNaNsFPMath = EnableNoNaNsFPMath;
-  Options.NoSignedZerosFPMath = EnableNoSignedZerosFPMath;
-  Options.NoTrappingFPMath = EnableNoTrappingFPMath;
-  Options.FPDenormalMode = DenormalMode;
-  Options.HonorSignDependentRoundingFPMathOption =
-      EnableHonorSignDependentRoundingFPMath;
-  if (FloatABIForCalls != FloatABI::Default)
-    Options.FloatABIType = FloatABIForCalls;
-  Options.NoZerosInBSS = DontPlaceZerosInBSS;
-  Options.GuaranteedTailCallOpt = EnableGuaranteedTailCallOpt;
-  Options.StackAlignmentOverride = OverrideStackAlignment;
-  Options.StackSymbolOrdering = StackSymbolOrdering;
-  Options.UseInitArray = !UseCtors;
-  Options.RelaxELFRelocations = RelaxELFRelocations;
-  Options.DataSections = DataSections;
-  Options.FunctionSections = FunctionSections;
-  Options.UniqueSectionNames = UniqueSectionNames;
-  Options.EmulatedTLS = EmulatedTLS;
-  Options.ExplicitEmulatedTLS = EmulatedTLS.getNumOccurrences() > 0;
-  Options.ExceptionModel = ExceptionModel;
-  Options.EmitStackSizeSection = EnableStackSizeSection;
-  Options.EmitAddrsig = EnableAddrsig;
-  Options.EnableDebugEntryValues = EnableDebugEntryValues;
-
-  Options.MCOptions = InitMCTargetOptionsFromFlags();
-
-  Options.ThreadModel = TMModel;
-  Options.EABIVersion = EABIVersion;
-  Options.DebuggerTuning = DebuggerTuningOpt;
-
-  return Options;
-}
-
-LLVM_ATTRIBUTE_UNUSED static std::string getCPUStr() {
-  // If user asked for the 'native' CPU, autodetect here. If autodection fails,
-  // this will set the CPU to an empty string which tells the target to
-  // pick a basic default.
-  if (MCPU == "native")
-    return sys::getHostCPUName();
-
-  return MCPU;
-}
-
-LLVM_ATTRIBUTE_UNUSED static std::string getFeaturesStr() {
-  SubtargetFeatures Features;
-
-  // If user asked for the 'native' CPU, we need to autodetect features.
-  // This is necessary for x86 where the CPU might not support all the
-  // features the autodetected CPU name lists in the target. For example,
-  // not all Sandybridge processors support AVX.
-  if (MCPU == "native") {
-    StringMap<bool> HostFeatures;
-    if (sys::getHostCPUFeatures(HostFeatures))
-      for (auto &F : HostFeatures)
-        Features.AddFeature(F.first(), F.second);
-  }
-
-  for (unsigned i = 0; i != MAttrs.size(); ++i)
-    Features.AddFeature(MAttrs[i]);
-
-  return Features.getString();
-}
-
-LLVM_ATTRIBUTE_UNUSED static std::vector<std::string> getFeatureList() {
-  SubtargetFeatures Features;
-
-  // If user asked for the 'native' CPU, we need to autodetect features.
-  // This is necessary for x86 where the CPU might not support all the
-  // features the autodetected CPU name lists in the target. For example,
-  // not all Sandybridge processors support AVX.
-  if (MCPU == "native") {
-    StringMap<bool> HostFeatures;
-    if (sys::getHostCPUFeatures(HostFeatures))
-      for (auto &F : HostFeatures)
-        Features.AddFeature(F.first(), F.second);
-  }
-
-  for (unsigned i = 0; i != MAttrs.size(); ++i)
-    Features.AddFeature(MAttrs[i]);
-
-  return Features.getFeatures();
-}
-
-/// Set function attributes of functions in Module M based on CPU,
-/// Features, and command line flags.
-LLVM_ATTRIBUTE_UNUSED static void
-setFunctionAttributes(StringRef CPU, StringRef Features, Module &M) {
-  for (auto &F : M) {
-    auto &Ctx = F.getContext();
-    AttributeList Attrs = F.getAttributes();
-    AttrBuilder NewAttrs;
-
-    if (!CPU.empty())
-      NewAttrs.addAttribute("target-cpu", CPU);
-    if (!Features.empty())
-      NewAttrs.addAttribute("target-features", Features);
-    if (FramePointerUsage.getNumOccurrences() > 0) {
-      if (FramePointerUsage == llvm::FramePointer::All)
-        NewAttrs.addAttribute("frame-pointer", "all");
-      else if (FramePointerUsage == llvm::FramePointer::NonLeaf)
-        NewAttrs.addAttribute("frame-pointer", "non-leaf");
-      else if (FramePointerUsage == llvm::FramePointer::None)
-        NewAttrs.addAttribute("frame-pointer", "none");
-    }
-    if (DisableTailCalls.getNumOccurrences() > 0)
-      NewAttrs.addAttribute("disable-tail-calls",
-                            toStringRef(DisableTailCalls));
-    if (StackRealign)
-      NewAttrs.addAttribute("stackrealign");
-
-    if (TrapFuncName.getNumOccurrences() > 0)
-      for (auto &B : F)
-        for (auto &I : B)
-          if (auto *Call = dyn_cast<CallInst>(&I))
-            if (const auto *F = Call->getCalledFunction())
-              if (F->getIntrinsicID() == Intrinsic::debugtrap ||
-                  F->getIntrinsicID() == Intrinsic::trap)
-                Call->addAttribute(
-                    llvm::AttributeList::FunctionIndex,
-                    Attribute::get(Ctx, "trap-func-name", TrapFuncName));
-
-    // Let NewAttrs override Attrs.
-    F.setAttributes(
-        Attrs.addAttributes(Ctx, AttributeList::FunctionIndex, NewAttrs));
-  }
-}
diff --git a/linux-x64/clang/include/llvm/CodeGen/DFAPacketizer.h b/linux-x64/clang/include/llvm/CodeGen/DFAPacketizer.h
index cf58ee0..9cdaedc 100644
--- a/linux-x64/clang/include/llvm/CodeGen/DFAPacketizer.h
+++ b/linux-x64/clang/include/llvm/CodeGen/DFAPacketizer.h
@@ -28,6 +28,7 @@
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/CodeGen/MachineBasicBlock.h"
 #include "llvm/CodeGen/ScheduleDAGMutation.h"
+#include "llvm/Support/Automaton.h"
 #include <cstdint>
 #include <map>
 #include <memory>
@@ -45,64 +46,33 @@
 class SUnit;
 class TargetInstrInfo;
 
-// --------------------------------------------------------------------
-// Definitions shared between DFAPacketizer.cpp and DFAPacketizerEmitter.cpp
-
-// DFA_MAX_RESTERMS * DFA_MAX_RESOURCES must fit within sizeof DFAInput.
-// This is verified in DFAPacketizer.cpp:DFAPacketizer::DFAPacketizer.
-//
-// e.g. terms x resource bit combinations that fit in uint32_t:
-//      4 terms x 8  bits = 32 bits
-//      3 terms x 10 bits = 30 bits
-//      2 terms x 16 bits = 32 bits
-//
-// e.g. terms x resource bit combinations that fit in uint64_t:
-//      8 terms x 8  bits = 64 bits
-//      7 terms x 9  bits = 63 bits
-//      6 terms x 10 bits = 60 bits
-//      5 terms x 12 bits = 60 bits
-//      4 terms x 16 bits = 64 bits <--- current
-//      3 terms x 21 bits = 63 bits
-//      2 terms x 32 bits = 64 bits
-//
-#define DFA_MAX_RESTERMS        4   // The max # of AND'ed resource terms.
-#define DFA_MAX_RESOURCES       16  // The max # of resource bits in one term.
-
-using DFAInput = uint64_t;
-using DFAStateInput = int64_t;
-
-#define DFA_TBLTYPE             "int64_t" // For generating DFAStateInputTable.
-// --------------------------------------------------------------------
-
 class DFAPacketizer {
 private:
-  using UnsignPair = std::pair<unsigned, DFAInput>;
-
   const InstrItineraryData *InstrItins;
-  int CurrentState = 0;
-  const DFAStateInput (*DFAStateInputTable)[2];
-  const unsigned *DFAStateEntryTable;
-
-  // CachedTable is a map from <FromState, Input> to ToState.
-  DenseMap<UnsignPair, unsigned> CachedTable;
-
-  // Read the DFA transition table and update CachedTable.
-  void ReadTable(unsigned state);
+  Automaton<uint64_t> A;
+  /// For every itinerary, an "action" to apply to the automaton. This removes
+  /// the redundancy in actions between itinerary classes.
+  ArrayRef<unsigned> ItinActions;
 
 public:
-  DFAPacketizer(const InstrItineraryData *I, const DFAStateInput (*SIT)[2],
-                const unsigned *SET);
+  DFAPacketizer(const InstrItineraryData *InstrItins, Automaton<uint64_t> a,
+                ArrayRef<unsigned> ItinActions)
+      : InstrItins(InstrItins), A(std::move(a)), ItinActions(ItinActions) {
+    // Start off with resource tracking disabled.
+    A.enableTranscription(false);
+  }
 
   // Reset the current state to make all resources available.
   void clearResources() {
-    CurrentState = 0;
+    A.reset();
   }
 
-  // Return the DFAInput for an instruction class.
-  DFAInput getInsnInput(unsigned InsnClass);
-
-  // Return the DFAInput for an instruction class input vector.
-  static DFAInput getInsnInput(const std::vector<unsigned> &InsnClass);
+  // Set whether this packetizer should track not just whether instructions
+  // can be packetized, but also which functional units each instruction ends up
+  // using after packetization.
+  void setTrackResources(bool Track) {
+    A.enableTranscription(Track);
+  }
 
   // Check if the resources occupied by a MCInstrDesc are available in
   // the current state.
@@ -120,6 +90,15 @@
   // current state to reflect that change.
   void reserveResources(MachineInstr &MI);
 
+  // Return the resources used by the InstIdx'th instruction added to this
+  // packet. The resources are returned as a bitvector of functional units.
+  //
+  // Note that a bundle may be packed in multiple valid ways. This function
+  // returns one arbitary valid packing.
+  //
+  // Requires setTrackResources(true) to have been called.
+  unsigned getUsedResources(unsigned InstIdx);
+
   const InstrItineraryData *getInstrItins() const { return InstrItins; }
 };
 
@@ -134,7 +113,7 @@
 protected:
   MachineFunction &MF;
   const TargetInstrInfo *TII;
-  AliasAnalysis *AA;
+  AAResults *AA;
 
   // The VLIW Scheduler.
   DefaultVLIWScheduler *VLIWScheduler;
@@ -146,9 +125,9 @@
   std::map<MachineInstr*, SUnit*> MIToSUnit;
 
 public:
-  // The AliasAnalysis parameter can be nullptr.
+  // The AAResults parameter can be nullptr.
   VLIWPacketizerList(MachineFunction &MF, MachineLoopInfo &MLI,
-                     AliasAnalysis *AA);
+                     AAResults *AA);
 
   virtual ~VLIWPacketizerList();
 
diff --git a/linux-x64/clang/include/llvm/CodeGen/DIE.h b/linux-x64/clang/include/llvm/CodeGen/DIE.h
index 684f9e4..3efef6e 100644
--- a/linux-x64/clang/include/llvm/CodeGen/DIE.h
+++ b/linux-x64/clang/include/llvm/CodeGen/DIE.h
@@ -78,7 +78,7 @@
 /// object.
 class DIEAbbrev : public FoldingSetNode {
   /// Unique number for node.
-  unsigned Number;
+  unsigned Number = 0;
 
   /// Dwarf tag code.
   dwarf::Tag Tag;
@@ -190,7 +190,7 @@
   uint64_t getValue() const { return Integer; }
   void setValue(uint64_t Val) { Integer = Val; }
 
-  void EmitValue(const AsmPrinter *Asm, dwarf::Form Form) const;
+  void emitValue(const AsmPrinter *Asm, dwarf::Form Form) const;
   unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
 
   void print(raw_ostream &O) const;
@@ -207,7 +207,7 @@
   /// Get MCExpr.
   const MCExpr *getValue() const { return Expr; }
 
-  void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
+  void emitValue(const AsmPrinter *AP, dwarf::Form Form) const;
   unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
 
   void print(raw_ostream &O) const;
@@ -224,7 +224,7 @@
   /// Get MCSymbol.
   const MCSymbol *getValue() const { return Label; }
 
-  void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
+  void emitValue(const AsmPrinter *AP, dwarf::Form Form) const;
   unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
 
   void print(raw_ostream &O) const;
@@ -242,11 +242,12 @@
     : CU(TheCU), Index(Idx) {}
 
   /// EmitValue - Emit base type reference.
-  void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
+  void emitValue(const AsmPrinter *AP, dwarf::Form Form) const;
   /// SizeOf - Determine size of the base type reference in bytes.
   unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
 
   void print(raw_ostream &O) const;
+  uint64_t getIndex() const { return Index; }
 };
 
 //===--------------------------------------------------------------------===//
@@ -259,7 +260,7 @@
 public:
   DIEDelta(const MCSymbol *Hi, const MCSymbol *Lo) : LabelHi(Hi), LabelLo(Lo) {}
 
-  void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
+  void emitValue(const AsmPrinter *AP, dwarf::Form Form) const;
   unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
 
   void print(raw_ostream &O) const;
@@ -278,7 +279,7 @@
   /// Grab the string out of the object.
   StringRef getString() const { return S.getString(); }
 
-  void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
+  void emitValue(const AsmPrinter *AP, dwarf::Form Form) const;
   unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
 
   void print(raw_ostream &O) const;
@@ -300,7 +301,7 @@
   /// Grab the string out of the object.
   StringRef getString() const { return S; }
 
-  void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
+  void emitValue(const AsmPrinter *AP, dwarf::Form Form) const;
   unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
 
   void print(raw_ostream &O) const;
@@ -319,7 +320,7 @@
 
   DIE &getEntry() const { return *Entry; }
 
-  void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
+  void emitValue(const AsmPrinter *AP, dwarf::Form Form) const;
   unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
 
   void print(raw_ostream &O) const;
@@ -338,7 +339,7 @@
   /// Grab the current index out.
   size_t getValue() const { return Index; }
 
-  void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
+  void emitValue(const AsmPrinter *AP, dwarf::Form Form) const;
   unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
 
   void print(raw_ostream &O) const;
@@ -382,12 +383,12 @@
     static_assert(std::is_standard_layout<T>::value ||
                       std::is_pointer<T>::value,
                   "Expected standard layout or pointer");
-    new (reinterpret_cast<void *>(Val.buffer)) T(V);
+    new (reinterpret_cast<void *>(&Val)) T(V);
   }
 
-  template <class T> T *get() { return reinterpret_cast<T *>(Val.buffer); }
+  template <class T> T *get() { return reinterpret_cast<T *>(&Val); }
   template <class T> const T *get() const {
-    return reinterpret_cast<const T *>(Val.buffer);
+    return reinterpret_cast<const T *>(&Val);
   }
   template <class T> void destruct() { get<T>()->~T(); }
 
@@ -485,7 +486,7 @@
 #include "llvm/CodeGen/DIEValue.def"
 
   /// Emit value via the Dwarf writer.
-  void EmitValue(const AsmPrinter *AP) const;
+  void emitValue(const AsmPrinter *AP) const;
 
   /// Return the size of a value in bytes.
   unsigned SizeOf(const AsmPrinter *AP) const;
@@ -550,6 +551,25 @@
     return *static_cast<T *>(Last ? Last->Next.getPointer() : nullptr);
   }
 
+  void takeNodes(IntrusiveBackList<T> &Other) {
+    if (Other.empty())
+      return;
+
+    T *FirstNode = static_cast<T *>(Other.Last->Next.getPointer());
+    T *IterNode = FirstNode;
+    do {
+      // Keep a pointer to the node and increment the iterator.
+      T *TmpNode = IterNode;
+      IterNode = static_cast<T *>(IterNode->Next.getPointer());
+
+      // Unlink the node and push it back to this list.
+      TmpNode->Next.setPointerAndInt(TmpNode, true);
+      push_back(*TmpNode);
+    } while (IterNode != FirstNode);
+
+    Other.Last = nullptr;
+  }
+
   class const_iterator;
   class iterator
       : public iterator_facade_base<iterator, std::forward_iterator_tag, T> {
@@ -570,7 +590,6 @@
     T &operator*() const { return *static_cast<T *>(N); }
 
     bool operator==(const iterator &X) const { return N == X.N; }
-    bool operator!=(const iterator &X) const { return N != X.N; }
   };
 
   class const_iterator
@@ -593,7 +612,6 @@
     const T &operator*() const { return *static_cast<const T *>(N); }
 
     bool operator==(const const_iterator &X) const { return N == X.N; }
-    bool operator!=(const const_iterator &X) const { return N != X.N; }
   };
 
   iterator begin() {
@@ -685,6 +703,10 @@
     return addValue(Alloc, DIEValue(Attribute, Form, std::forward<T>(Value)));
   }
 
+  /// Take ownership of the nodes in \p Other, and append them to the back of
+  /// the list.
+  void takeValues(DIEValueList &Other) { List.takeNodes(Other.List); }
+
   value_range values() {
     return make_range(value_iterator(List.begin()), value_iterator(List.end()));
   }
@@ -765,7 +787,7 @@
 
   /// Get the absolute offset within the .debug_info or .debug_types section
   /// for this DIE.
-  unsigned getDebugSectionOffset() const;
+  uint64_t getDebugSectionOffset() const;
 
   /// Compute the offset of this DIE and all its children.
   ///
@@ -841,14 +863,11 @@
   /// a valid section depending on the client that is emitting DWARF.
   MCSection *Section;
   uint64_t Offset; /// .debug_info or .debug_types absolute section offset.
-  uint32_t Length; /// The length in bytes of all of the DIEs in this unit.
-  const uint16_t Version; /// The Dwarf version number for this unit.
-  const uint8_t AddrSize; /// The size in bytes of an address for this unit.
 protected:
   virtual ~DIEUnit() = default;
 
 public:
-  DIEUnit(uint16_t Version, uint8_t AddrSize, dwarf::Tag UnitTag);
+  explicit DIEUnit(dwarf::Tag UnitTag);
   DIEUnit(const DIEUnit &RHS) = delete;
   DIEUnit(DIEUnit &&RHS) = delete;
   void operator=(const DIEUnit &RHS) = delete;
@@ -870,19 +889,14 @@
   ///
   /// \returns Section pointer which can be NULL.
   MCSection *getSection() const { return Section; }
-  void setDebugSectionOffset(unsigned O) { Offset = O; }
-  unsigned getDebugSectionOffset() const { return Offset; }
-  void setLength(uint64_t L) { Length = L; }
-  uint64_t getLength() const { return Length; }
-  uint16_t getDwarfVersion() const { return Version; }
-  uint16_t getAddressSize() const { return AddrSize; }
+  void setDebugSectionOffset(uint64_t O) { Offset = O; }
+  uint64_t getDebugSectionOffset() const { return Offset; }
   DIE &getUnitDie() { return Die; }
   const DIE &getUnitDie() const { return Die; }
 };
 
 struct BasicDIEUnit final : DIEUnit {
-  BasicDIEUnit(uint16_t Version, uint8_t AddrSize, dwarf::Tag UnitTag)
-      : DIEUnit(Version, AddrSize, UnitTag) {}
+  explicit BasicDIEUnit(dwarf::Tag UnitTag) : DIEUnit(UnitTag) {}
 };
 
 //===--------------------------------------------------------------------===//
@@ -898,6 +912,9 @@
   ///
   unsigned ComputeSize(const AsmPrinter *AP) const;
 
+  // TODO: move setSize() and Size to DIEValueList.
+  void setSize(unsigned size) { Size = size; }
+
   /// BestForm - Choose the best form for data.
   ///
   dwarf::Form BestForm(unsigned DwarfVersion) const {
@@ -913,7 +930,7 @@
     return dwarf::DW_FORM_block;
   }
 
-  void EmitValue(const AsmPrinter *Asm, dwarf::Form Form) const;
+  void emitValue(const AsmPrinter *Asm, dwarf::Form Form) const;
   unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
 
   void print(raw_ostream &O) const;
@@ -932,6 +949,9 @@
   ///
   unsigned ComputeSize(const AsmPrinter *AP) const;
 
+  // TODO: move setSize() and Size to DIEValueList.
+  void setSize(unsigned size) { Size = size; }
+
   /// BestForm - Choose the best form for data.
   ///
   dwarf::Form BestForm() const {
@@ -944,7 +964,7 @@
     return dwarf::DW_FORM_block;
   }
 
-  void EmitValue(const AsmPrinter *Asm, dwarf::Form Form) const;
+  void emitValue(const AsmPrinter *Asm, dwarf::Form Form) const;
   unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
 
   void print(raw_ostream &O) const;
diff --git a/linux-x64/clang/include/llvm/CodeGen/DbgEntityHistoryCalculator.h b/linux-x64/clang/include/llvm/CodeGen/DbgEntityHistoryCalculator.h
index 7eec75b..bca6065 100644
--- a/linux-x64/clang/include/llvm/CodeGen/DbgEntityHistoryCalculator.h
+++ b/linux-x64/clang/include/llvm/CodeGen/DbgEntityHistoryCalculator.h
@@ -12,16 +12,36 @@
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/PointerIntPair.h"
 #include "llvm/ADT/SmallVector.h"
-#include "llvm/IR/DebugInfoMetadata.h"
+#include "llvm/CodeGen/LexicalScopes.h"
 #include <utility>
 
 namespace llvm {
 
 class DILocalVariable;
+class DILocation;
+class DINode;
 class MachineFunction;
 class MachineInstr;
 class TargetRegisterInfo;
 
+/// Record instruction ordering so we can query their relative positions within
+/// a function. Meta instructions are given the same ordinal as the preceding
+/// non-meta instruction. Class state is invalid if MF is modified after
+/// calling initialize.
+class InstructionOrdering {
+public:
+  void initialize(const MachineFunction &MF);
+  void clear() { InstNumberMap.clear(); }
+
+  /// Check if instruction \p A comes before \p B, where \p A and \p B both
+  /// belong to the MachineFunction passed to initialize().
+  bool isBefore(const MachineInstr *A, const MachineInstr *B) const;
+
+private:
+  /// Each instruction is assigned an order number.
+  DenseMap<const MachineInstr *, unsigned> InstNumberMap;
+};
+
 /// For each user variable, keep a list of instruction ranges where this
 /// variable is accessible. The variables are listed in order of appearance.
 class DbgValueHistoryMap {
@@ -51,6 +71,8 @@
   ///   register-described debug values that have their end index
   ///   set to this entry's position in the entry vector.
   class Entry {
+    friend DbgValueHistoryMap;
+
   public:
     enum EntryKind { DbgValue, Clobber };
 
@@ -88,6 +110,9 @@
     return Entries[Index];
   }
 
+  /// Drop location ranges which exist entirely outside each variable's scope.
+  void trimLocationRanges(const MachineFunction &MF, LexicalScopes &LScopes,
+                          const InstructionOrdering &Ordering);
   bool empty() const { return VarEntries.empty(); }
   void clear() { VarEntries.clear(); }
   EntriesMap::const_iterator begin() const { return VarEntries.begin(); }
diff --git a/linux-x64/clang/include/llvm/CodeGen/DebugHandlerBase.h b/linux-x64/clang/include/llvm/CodeGen/DebugHandlerBase.h
index 4008d59..45823b2 100644
--- a/linux-x64/clang/include/llvm/CodeGen/DebugHandlerBase.h
+++ b/linux-x64/clang/include/llvm/CodeGen/DebugHandlerBase.h
@@ -18,8 +18,8 @@
 #include "llvm/CodeGen/AsmPrinterHandler.h"
 #include "llvm/CodeGen/DbgEntityHistoryCalculator.h"
 #include "llvm/CodeGen/LexicalScopes.h"
-#include "llvm/CodeGen/MachineInstr.h"
 #include "llvm/IR/DebugInfoMetadata.h"
+#include "llvm/IR/DebugLoc.h"
 
 namespace llvm {
 
@@ -110,28 +110,37 @@
   virtual void endFunctionImpl(const MachineFunction *MF) = 0;
   virtual void skippedNonDebugFunction() {}
 
+private:
+  InstructionOrdering InstOrdering;
+
   // AsmPrinterHandler overrides.
 public:
+  void beginModule(Module *M) override;
+
   void beginInstruction(const MachineInstr *MI) override;
   void endInstruction() override;
 
   void beginFunction(const MachineFunction *MF) override;
   void endFunction(const MachineFunction *MF) override;
 
+  void beginBasicBlock(const MachineBasicBlock &MBB) override;
+  void endBasicBlock(const MachineBasicBlock &MBB) override;
+
   /// Return Label preceding the instruction.
   MCSymbol *getLabelBeforeInsn(const MachineInstr *MI);
 
   /// Return Label immediately following the instruction.
   MCSymbol *getLabelAfterInsn(const MachineInstr *MI);
 
-  /// Return the function-local offset of an instruction. A label for the
-  /// instruction \p MI should exist (\ref getLabelAfterInsn).
-  const MCExpr *getFunctionLocalOffsetAfterInsn(const MachineInstr *MI);
-
   /// If this type is derived from a base type then return base type size.
   static uint64_t getBaseTypeSize(const DIType *Ty);
+
+  /// Return true if type encoding is unsigned.
+  static bool isUnsignedDIType(const DIType *Ty);
+
+  const InstructionOrdering &getInstOrdering() const { return InstOrdering; }
 };
 
-}
+} // namespace llvm
 
 #endif
diff --git a/linux-x64/clang/include/llvm/CodeGen/DwarfStringPoolEntry.h b/linux-x64/clang/include/llvm/CodeGen/DwarfStringPoolEntry.h
index e189352..abeba62 100644
--- a/linux-x64/clang/include/llvm/CodeGen/DwarfStringPoolEntry.h
+++ b/linux-x64/clang/include/llvm/CodeGen/DwarfStringPoolEntry.h
@@ -21,7 +21,7 @@
   static constexpr unsigned NotIndexed = -1;
 
   MCSymbol *Symbol;
-  unsigned Offset;
+  uint64_t Offset;
   unsigned Index;
 
   bool isIndexed() const { return Index != NotIndexed; }
@@ -47,7 +47,7 @@
     assert(getMapEntry()->second.Symbol && "No symbol available!");
     return getMapEntry()->second.Symbol;
   }
-  unsigned getOffset() const { return getMapEntry()->second.Offset; }
+  uint64_t getOffset() const { return getMapEntry()->second.Offset; }
   bool isIndexed() const { return MapEntryAndIndexed.getInt(); }
   unsigned getIndex() const {
     assert(isIndexed());
diff --git a/linux-x64/clang/include/llvm/CodeGen/EdgeBundles.h b/linux-x64/clang/include/llvm/CodeGen/EdgeBundles.h
index 28cdf54..b269560 100644
--- a/linux-x64/clang/include/llvm/CodeGen/EdgeBundles.h
+++ b/linux-x64/clang/include/llvm/CodeGen/EdgeBundles.h
@@ -17,7 +17,6 @@
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/IntEqClasses.h"
-#include "llvm/ADT/Twine.h"
 #include "llvm/CodeGen/MachineFunctionPass.h"
 
 namespace llvm {
diff --git a/linux-x64/clang/include/llvm/CodeGen/ExecutionDomainFix.h b/linux-x64/clang/include/llvm/CodeGen/ExecutionDomainFix.h
index 6836678..c87d4f9 100644
--- a/linux-x64/clang/include/llvm/CodeGen/ExecutionDomainFix.h
+++ b/linux-x64/clang/include/llvm/CodeGen/ExecutionDomainFix.h
@@ -30,7 +30,6 @@
 
 namespace llvm {
 
-class MachineBasicBlock;
 class MachineInstr;
 class TargetInstrInfo;
 
@@ -81,10 +80,20 @@
   }
 
   /// Mark domain as available.
-  void addDomain(unsigned domain) { AvailableDomains |= 1u << domain; }
+  void addDomain(unsigned domain) {
+    assert(domain <
+               static_cast<unsigned>(std::numeric_limits<unsigned>::digits) &&
+           "undefined behavior");
+    AvailableDomains |= 1u << domain;
+  }
 
   // Restrict to a single domain available.
-  void setSingleDomain(unsigned domain) { AvailableDomains = 1u << domain; }
+  void setSingleDomain(unsigned domain) {
+    assert(domain <
+               static_cast<unsigned>(std::numeric_limits<unsigned>::digits) &&
+           "undefined behavior");
+    AvailableDomains = 1u << domain;
+  }
 
   /// Return bitmask of domains that are available and in mask.
   unsigned getCommonDomains(unsigned mask) const {
diff --git a/linux-x64/clang/include/llvm/CodeGen/FastISel.h b/linux-x64/clang/include/llvm/CodeGen/FastISel.h
index f09b59d..81c1d6a 100644
--- a/linux-x64/clang/include/llvm/CodeGen/FastISel.h
+++ b/linux-x64/clang/include/llvm/CodeGen/FastISel.h
@@ -20,7 +20,6 @@
 #include "llvm/CodeGen/MachineBasicBlock.h"
 #include "llvm/CodeGen/TargetLowering.h"
 #include "llvm/IR/Attributes.h"
-#include "llvm/IR/CallSite.h"
 #include "llvm/IR/CallingConv.h"
 #include "llvm/IR/DebugLoc.h"
 #include "llvm/IR/DerivedTypes.h"
@@ -86,16 +85,16 @@
     const Value *Callee = nullptr;
     MCSymbol *Symbol = nullptr;
     ArgListTy Args;
-    ImmutableCallSite *CS = nullptr;
+    const CallBase *CB = nullptr;
     MachineInstr *Call = nullptr;
-    unsigned ResultReg = 0;
+    Register ResultReg;
     unsigned NumResultRegs = 0;
 
     SmallVector<Value *, 16> OutVals;
     SmallVector<ISD::ArgFlagsTy, 16> OutFlags;
-    SmallVector<unsigned, 16> OutRegs;
+    SmallVector<Register, 16> OutRegs;
     SmallVector<ISD::InputArg, 4> Ins;
-    SmallVector<unsigned, 4> InRegs;
+    SmallVector<Register, 4> InRegs;
 
     CallLoweringInfo()
         : RetSExt(false), RetZExt(false), IsVarArg(false), IsInReg(false),
@@ -103,14 +102,14 @@
 
     CallLoweringInfo &setCallee(Type *ResultTy, FunctionType *FuncTy,
                                 const Value *Target, ArgListTy &&ArgsList,
-                                ImmutableCallSite &Call) {
+                                const CallBase &Call) {
       RetTy = ResultTy;
       Callee = Target;
 
       IsInReg = Call.hasRetAttr(Attribute::InReg);
       DoesNotReturn = Call.doesNotReturn();
       IsVarArg = FuncTy->isVarArg();
-      IsReturnValueUsed = !Call.getInstruction()->use_empty();
+      IsReturnValueUsed = !Call.use_empty();
       RetSExt = Call.hasRetAttr(Attribute::SExt);
       RetZExt = Call.hasRetAttr(Attribute::ZExt);
 
@@ -118,23 +117,23 @@
       Args = std::move(ArgsList);
       NumFixedArgs = FuncTy->getNumParams();
 
-      CS = &Call;
+      CB = &Call;
 
       return *this;
     }
 
     CallLoweringInfo &setCallee(Type *ResultTy, FunctionType *FuncTy,
                                 MCSymbol *Target, ArgListTy &&ArgsList,
-                                ImmutableCallSite &Call,
+                                const CallBase &Call,
                                 unsigned FixedArgs = ~0U) {
       RetTy = ResultTy;
-      Callee = Call.getCalledValue();
+      Callee = Call.getCalledOperand();
       Symbol = Target;
 
       IsInReg = Call.hasRetAttr(Attribute::InReg);
       DoesNotReturn = Call.doesNotReturn();
       IsVarArg = FuncTy->isVarArg();
-      IsReturnValueUsed = !Call.getInstruction()->use_empty();
+      IsReturnValueUsed = !Call.use_empty();
       RetSExt = Call.hasRetAttr(Attribute::SExt);
       RetZExt = Call.hasRetAttr(Attribute::ZExt);
 
@@ -142,7 +141,7 @@
       Args = std::move(ArgsList);
       NumFixedArgs = (FixedArgs == ~0U) ? FuncTy->getNumParams() : FixedArgs;
 
-      CS = &Call;
+      CB = &Call;
 
       return *this;
     }
@@ -199,7 +198,7 @@
   };
 
 protected:
-  DenseMap<const Value *, unsigned> LocalValueMap;
+  DenseMap<const Value *, Register> LocalValueMap;
   FunctionLoweringInfo &FuncInfo;
   MachineFunction *MF;
   MachineRegisterInfo &MRI;
@@ -225,10 +224,6 @@
   /// makes sense (for example, on function calls)
   MachineInstr *EmitStartPt;
 
-  /// Last local value flush point. On a subsequent flush, no local value will
-  /// sink past this point.
-  MachineBasicBlock::iterator LastFlushPoint;
-
 public:
   virtual ~FastISel();
 
@@ -247,7 +242,7 @@
   /// be appended.
   void startNewBlock();
 
-  /// Flush the local value map and sink local values if possible.
+  /// Flush the local value map.
   void finishBasicBlock();
 
   /// Return current debug location information.
@@ -270,16 +265,16 @@
 
   /// Create a virtual register and arrange for it to be assigned the
   /// value for the given LLVM value.
-  unsigned getRegForValue(const Value *V);
+  Register getRegForValue(const Value *V);
 
   /// Look up the value to see if its value is already cached in a
   /// register. It may be defined by instructions across blocks or defined
   /// locally.
-  unsigned lookUpRegForValue(const Value *V);
+  Register lookUpRegForValue(const Value *V);
 
   /// This is a wrapper around getRegForValue that also takes care of
   /// truncating or sign-extending the given getelementptr index value.
-  std::pair<unsigned, bool> getRegForGEPIndex(const Value *Idx);
+  std::pair<Register, bool> getRegForGEPIndex(const Value *Idx);
 
   /// We're checking to see if we can fold \p LI into \p FoldInst. Note
   /// that we could have a sequence where multiple LLVM IR instructions are
@@ -314,10 +309,7 @@
   void removeDeadCode(MachineBasicBlock::iterator I,
                       MachineBasicBlock::iterator E);
 
-  struct SavePoint {
-    MachineBasicBlock::iterator InsertPt;
-    DebugLoc DL;
-  };
+  using SavePoint = MachineBasicBlock::iterator;
 
   /// Prepare InsertPt to begin inserting instructions into the local
   /// value area and return the old insert position.
@@ -374,7 +366,7 @@
   /// It first tries to emit an instruction with an immediate operand using
   /// fastEmit_ri.  If that fails, it materializes the immediate into a register
   /// and try fastEmit_rr instead.
-  unsigned fastEmit_ri_(MVT VT, unsigned Opcode, unsigned Op0, bool Op0IsKill,
+  Register fastEmit_ri_(MVT VT, unsigned Opcode, unsigned Op0, bool Op0IsKill,
                         uint64_t Imm, MVT ImmType);
 
   /// This method is called by target-independent code to request that an
@@ -389,66 +381,66 @@
 
   /// Emit a MachineInstr with no operands and a result register in the
   /// given register class.
-  unsigned fastEmitInst_(unsigned MachineInstOpcode,
+  Register fastEmitInst_(unsigned MachineInstOpcode,
                          const TargetRegisterClass *RC);
 
   /// Emit a MachineInstr with one register operand and a result register
   /// in the given register class.
-  unsigned fastEmitInst_r(unsigned MachineInstOpcode,
+  Register fastEmitInst_r(unsigned MachineInstOpcode,
                           const TargetRegisterClass *RC, unsigned Op0,
                           bool Op0IsKill);
 
   /// Emit a MachineInstr with two register operands and a result
   /// register in the given register class.
-  unsigned fastEmitInst_rr(unsigned MachineInstOpcode,
+  Register fastEmitInst_rr(unsigned MachineInstOpcode,
                            const TargetRegisterClass *RC, unsigned Op0,
                            bool Op0IsKill, unsigned Op1, bool Op1IsKill);
 
   /// Emit a MachineInstr with three register operands and a result
   /// register in the given register class.
-  unsigned fastEmitInst_rrr(unsigned MachineInstOpcode,
+  Register fastEmitInst_rrr(unsigned MachineInstOpcode,
                             const TargetRegisterClass *RC, unsigned Op0,
                             bool Op0IsKill, unsigned Op1, bool Op1IsKill,
                             unsigned Op2, bool Op2IsKill);
 
   /// Emit a MachineInstr with a register operand, an immediate, and a
   /// result register in the given register class.
-  unsigned fastEmitInst_ri(unsigned MachineInstOpcode,
+  Register fastEmitInst_ri(unsigned MachineInstOpcode,
                            const TargetRegisterClass *RC, unsigned Op0,
                            bool Op0IsKill, uint64_t Imm);
 
   /// Emit a MachineInstr with one register operand and two immediate
   /// operands.
-  unsigned fastEmitInst_rii(unsigned MachineInstOpcode,
+  Register fastEmitInst_rii(unsigned MachineInstOpcode,
                             const TargetRegisterClass *RC, unsigned Op0,
                             bool Op0IsKill, uint64_t Imm1, uint64_t Imm2);
 
   /// Emit a MachineInstr with a floating point immediate, and a result
   /// register in the given register class.
-  unsigned fastEmitInst_f(unsigned MachineInstOpcode,
+  Register fastEmitInst_f(unsigned MachineInstOpcode,
                           const TargetRegisterClass *RC,
                           const ConstantFP *FPImm);
 
   /// Emit a MachineInstr with two register operands, an immediate, and a
   /// result register in the given register class.
-  unsigned fastEmitInst_rri(unsigned MachineInstOpcode,
+  Register fastEmitInst_rri(unsigned MachineInstOpcode,
                             const TargetRegisterClass *RC, unsigned Op0,
                             bool Op0IsKill, unsigned Op1, bool Op1IsKill,
                             uint64_t Imm);
 
   /// Emit a MachineInstr with a single immediate operand, and a result
   /// register in the given register class.
-  unsigned fastEmitInst_i(unsigned MachineInstOpcode,
+  Register fastEmitInst_i(unsigned MachineInstOpcode,
                           const TargetRegisterClass *RC, uint64_t Imm);
 
   /// Emit a MachineInstr for an extract_subreg from a specified index of
   /// a superregister to a specified type.
-  unsigned fastEmitInst_extractsubreg(MVT RetVT, unsigned Op0, bool Op0IsKill,
+  Register fastEmitInst_extractsubreg(MVT RetVT, unsigned Op0, bool Op0IsKill,
                                       uint32_t Idx);
 
   /// Emit MachineInstrs to compute the value of Op with all but the
   /// least significant bit set to zero.
-  unsigned fastEmitZExtFromI1(MVT VT, unsigned Op0, bool Op0IsKill);
+  Register fastEmitZExtFromI1(MVT VT, unsigned Op0, bool Op0IsKill);
 
   /// Emit an unconditional branch to the given block, unless it is the
   /// immediate (fall-through) successor, and update the CFG.
@@ -466,14 +458,14 @@
   /// NOTE: This is only necessary because we might select a block that uses a
   /// value before we select the block that defines the value. It might be
   /// possible to fix this by selecting blocks in reverse postorder.
-  void updateValueMap(const Value *I, unsigned Reg, unsigned NumRegs = 1);
+  void updateValueMap(const Value *I, Register Reg, unsigned NumRegs = 1);
 
-  unsigned createResultReg(const TargetRegisterClass *RC);
+  Register createResultReg(const TargetRegisterClass *RC);
 
   /// Try to constrain Op so that it is usable by argument OpNum of the
   /// provided MCInstrDesc. If this fails, create a new virtual register in the
   /// correct class and COPY the value there.
-  unsigned constrainOperandRegClass(const MCInstrDesc &II, unsigned Op,
+  Register constrainOperandRegClass(const MCInstrDesc &II, Register Op,
                                     unsigned OpNum);
 
   /// Emit a constant in a register using target-specific logic, such as
@@ -511,18 +503,6 @@
                    unsigned NumArgs);
   bool lowerCallTo(CallLoweringInfo &CLI);
 
-  bool isCommutativeIntrinsic(IntrinsicInst const *II) {
-    switch (II->getIntrinsicID()) {
-    case Intrinsic::sadd_with_overflow:
-    case Intrinsic::uadd_with_overflow:
-    case Intrinsic::smul_with_overflow:
-    case Intrinsic::umul_with_overflow:
-      return true;
-    default:
-      return false;
-    }
-  }
-
   bool lowerCall(const CallInst *I);
   /// Select and emit code for a binary operator instruction, which has
   /// an opcode which directly corresponds to the given ISD opcode.
@@ -534,12 +514,17 @@
   bool selectCall(const User *I);
   bool selectIntrinsicCall(const IntrinsicInst *II);
   bool selectBitCast(const User *I);
+  bool selectFreeze(const User *I);
   bool selectCast(const User *I, unsigned Opcode);
   bool selectExtractValue(const User *U);
-  bool selectInsertValue(const User *I);
   bool selectXRayCustomEvent(const CallInst *II);
   bool selectXRayTypedEvent(const CallInst *II);
 
+  bool shouldOptForSize(const MachineFunction *MF) const {
+    // TODO: Implement PGSO.
+    return MF->getFunction().hasOptSize();
+  }
+
 private:
   /// Handle PHI nodes in successor blocks.
   ///
@@ -552,12 +537,12 @@
 
   /// Helper for materializeRegForValue to materialize a constant in a
   /// target-independent way.
-  unsigned materializeConstant(const Value *V, MVT VT);
+  Register materializeConstant(const Value *V, MVT VT);
 
   /// Helper for getRegForVale. This function is called when the value
   /// isn't already available in a register and must be materialized with new
   /// instructions.
-  unsigned materializeRegForValue(const Value *V, MVT VT);
+  Register materializeRegForValue(const Value *V, MVT VT);
 
   /// Clears LocalValueMap and moves the area for the new local variables
   /// to the beginning of the block. It helps to avoid spilling cached variables
@@ -567,20 +552,6 @@
   /// Removes dead local value instructions after SavedLastLocalvalue.
   void removeDeadLocalValueCode(MachineInstr *SavedLastLocalValue);
 
-  struct InstOrderMap {
-    DenseMap<MachineInstr *, unsigned> Orders;
-    MachineInstr *FirstTerminator = nullptr;
-    unsigned FirstTerminatorOrder = std::numeric_limits<unsigned>::max();
-
-    void initialize(MachineBasicBlock *MBB,
-                    MachineBasicBlock::iterator LastFlushPoint);
-  };
-
-  /// Sinks the local value materialization instruction LocalMI to its first use
-  /// in the basic block, or deletes it if it is not used.
-  void sinkLocalValueMaterialization(MachineInstr &LocalMI, unsigned DefReg,
-                                     InstOrderMap &OrderMap);
-
   /// Insertion point before trying to select the current instruction.
   MachineBasicBlock::iterator SavedInsertPt;
 
diff --git a/linux-x64/clang/include/llvm/CodeGen/FaultMaps.h b/linux-x64/clang/include/llvm/CodeGen/FaultMaps.h
index a1e2349..da56c4d 100644
--- a/linux-x64/clang/include/llvm/CodeGen/FaultMaps.h
+++ b/linux-x64/clang/include/llvm/CodeGen/FaultMaps.h
@@ -36,7 +36,8 @@
 
   static const char *faultTypeToString(FaultKind);
 
-  void recordFaultingOp(FaultKind FaultTy, const MCSymbol *HandlerLabel);
+  void recordFaultingOp(FaultKind FaultTy, const MCSymbol *FaultingLabel,
+                        const MCSymbol *HandlerLabel);
   void serializeToFaultMapSection();
   void reset() {
     FunctionInfos.clear();
diff --git a/linux-x64/clang/include/llvm/CodeGen/FunctionLoweringInfo.h b/linux-x64/clang/include/llvm/CodeGen/FunctionLoweringInfo.h
index fb60191..b6bde02 100644
--- a/linux-x64/clang/include/llvm/CodeGen/FunctionLoweringInfo.h
+++ b/linux-x64/clang/include/llvm/CodeGen/FunctionLoweringInfo.h
@@ -13,14 +13,13 @@
 
 #ifndef LLVM_CODEGEN_FUNCTIONLOWERINGINFO_H
 #define LLVM_CODEGEN_FUNCTIONLOWERINGINFO_H
-#include "llvm/ADT/APInt.h"
+
 #include "llvm/ADT/BitVector.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/IndexedMap.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
-#include "llvm/Analysis/LegacyDivergenceAnalysis.h"
 #include "llvm/CodeGen/ISDOpcodes.h"
 #include "llvm/CodeGen/MachineBasicBlock.h"
 #include "llvm/CodeGen/TargetRegisterInfo.h"
@@ -37,6 +36,7 @@
 class Argument;
 class BasicBlock;
 class BranchProbabilityInfo;
+class LegacyDivergenceAnalysis;
 class Function;
 class Instruction;
 class MachineFunction;
@@ -67,7 +67,7 @@
 
   /// DemoteRegister - if CanLowerReturn is false, DemoteRegister is a vreg
   /// allocated to hold a pointer to the hidden sret parameter.
-  unsigned DemoteRegister;
+  Register DemoteRegister;
 
   /// MBBMap - A mapping from LLVM basic blocks to their machine code entry.
   DenseMap<const BasicBlock*, MachineBasicBlock *> MBBMap;
@@ -75,52 +75,49 @@
   /// ValueMap - Since we emit code for the function a basic block at a time,
   /// we must remember which virtual registers hold the values for
   /// cross-basic-block values.
-  DenseMap<const Value *, unsigned> ValueMap;
+  DenseMap<const Value *, Register> ValueMap;
 
   /// VirtReg2Value map is needed by the Divergence Analysis driven
   /// instruction selection. It is reverted ValueMap. It is computed
   /// in lazy style - on demand. It is used to get the Value corresponding
   /// to the live in virtual register and is called from the
   /// TargetLowerinInfo::isSDNodeSourceOfDivergence.
-  DenseMap<unsigned, const Value*> VirtReg2Value;
+  DenseMap<Register, const Value*> VirtReg2Value;
 
   /// This method is called from TargetLowerinInfo::isSDNodeSourceOfDivergence
   /// to get the Value corresponding to the live-in virtual register.
-  const Value * getValueFromVirtualReg(unsigned Vreg);
+  const Value *getValueFromVirtualReg(Register Vreg);
 
   /// Track virtual registers created for exception pointers.
-  DenseMap<const Value *, unsigned> CatchPadExceptionPointers;
+  DenseMap<const Value *, Register> CatchPadExceptionPointers;
 
-  /// Keep track of frame indices allocated for statepoints as they could be
-  /// used across basic block boundaries.  This struct is more complex than a
-  /// simple map because the stateopint lowering code de-duplicates gc pointers
-  /// based on their SDValue (so %p and (bitcast %p to T) will get the same
-  /// slot), and we track that here.
-
-  struct StatepointSpillMap {
-    using SlotMapTy = DenseMap<const Value *, Optional<int>>;
-
-    /// Maps uniqued llvm IR values to the slots they were spilled in.  If a
-    /// value is mapped to None it means we visited the value but didn't spill
-    /// it (because it was a constant, for instance).
-    SlotMapTy SlotMap;
-
-    /// Maps llvm IR values to the values they were de-duplicated to.
-    DenseMap<const Value *, const Value *> DuplicateMap;
-
-    SlotMapTy::const_iterator find(const Value *V) const {
-      auto DuplIt = DuplicateMap.find(V);
-      if (DuplIt != DuplicateMap.end())
-        V = DuplIt->second;
-      return SlotMap.find(V);
-    }
-
-    SlotMapTy::const_iterator end() const { return SlotMap.end(); }
+  /// Helper object to track which of three possible relocation mechanisms are
+  /// used for a particular value being relocated over a statepoint.
+  struct StatepointRelocationRecord {
+    enum RelocType {
+      // Value did not need to be relocated and can be used directly.
+      NoRelocate,
+      // Value was spilled to stack and needs filled at the gc.relocate.
+      Spill,
+      // Value was lowered to tied def and gc.relocate should be replaced with
+      // copy from vreg.
+      VReg,
+    } type = NoRelocate;
+    // Payload contains either frame index of the stack slot in which the value
+    // was spilled, or virtual register which contains the re-definition.
+    union payload_t {
+      payload_t() : FI(-1) {}
+      int FI;
+      Register Reg;
+    } payload;
   };
 
-  /// Maps gc.statepoint instructions to their corresponding StatepointSpillMap
-  /// instances.
-  DenseMap<const Instruction *, StatepointSpillMap> StatepointSpillMaps;
+  /// Keep track of each value which was relocated and the strategy used to
+  /// relocate that value.  This information is required when visiting
+  /// gc.relocates which may appear in following blocks.
+  using StatepointSpillMapTy =
+    DenseMap<const Value *, StatepointRelocationRecord>;
+  DenseMap<const Instruction *, StatepointSpillMapTy> StatepointRelocationMaps;
 
   /// StaticAllocaMap - Keep track of frame indices for fixed sized allocas in
   /// the entry block.  This allows the allocas to be efficiently referenced
@@ -139,9 +136,9 @@
   BitVector DescribedArgs;
 
   /// RegFixups - Registers which need to be replaced after isel is done.
-  DenseMap<unsigned, unsigned> RegFixups;
+  DenseMap<Register, Register> RegFixups;
 
-  DenseSet<unsigned> RegsWithFixups;
+  DenseSet<Register> RegsWithFixups;
 
   /// StatepointStackSlots - A list of temporary stack slots (frame indices)
   /// used to spill values at a statepoint.  We store them here to enable
@@ -195,21 +192,21 @@
 
   /// isExportedInst - Return true if the specified value is an instruction
   /// exported from its block.
-  bool isExportedInst(const Value *V) {
+  bool isExportedInst(const Value *V) const {
     return ValueMap.count(V);
   }
 
-  unsigned CreateReg(MVT VT, bool isDivergent = false);
+  Register CreateReg(MVT VT, bool isDivergent = false);
 
-  unsigned CreateRegs(const Value *V);
+  Register CreateRegs(const Value *V);
 
-  unsigned CreateRegs(Type *Ty, bool isDivergent = false);
+  Register CreateRegs(Type *Ty, bool isDivergent = false);
 
-  unsigned InitializeRegForValue(const Value *V) {
+  Register InitializeRegForValue(const Value *V) {
     // Tokens never live in vregs.
     if (V->getType()->isTokenTy())
       return 0;
-    unsigned &R = ValueMap[V];
+    Register &R = ValueMap[V];
     assert(R == 0 && "Already initialized this value register!");
     assert(VirtReg2Value.empty());
     return R = CreateRegs(V);
@@ -217,7 +214,7 @@
 
   /// GetLiveOutRegInfo - Gets LiveOutInfo for a register, returning NULL if the
   /// register is a PHI destination and the PHI's LiveOutInfo is not valid.
-  const LiveOutInfo *GetLiveOutRegInfo(unsigned Reg) {
+  const LiveOutInfo *GetLiveOutRegInfo(Register Reg) {
     if (!LiveOutRegInfo.inBounds(Reg))
       return nullptr;
 
@@ -233,10 +230,10 @@
   /// the register's LiveOutInfo is for a smaller bit width, it is extended to
   /// the larger bit width by zero extension. The bit width must be no smaller
   /// than the LiveOutInfo's existing bit width.
-  const LiveOutInfo *GetLiveOutRegInfo(unsigned Reg, unsigned BitWidth);
+  const LiveOutInfo *GetLiveOutRegInfo(Register Reg, unsigned BitWidth);
 
   /// AddLiveOutRegInfo - Adds LiveOutInfo for a register.
-  void AddLiveOutRegInfo(unsigned Reg, unsigned NumSignBits,
+  void AddLiveOutRegInfo(Register Reg, unsigned NumSignBits,
                          const KnownBits &Known) {
     // Only install this information if it tells us something.
     if (NumSignBits == 1 && Known.isUnknown())
@@ -257,11 +254,11 @@
   /// called when a block is visited before all of its predecessors.
   void InvalidatePHILiveOutRegInfo(const PHINode *PN) {
     // PHIs with no uses have no ValueMap entry.
-    DenseMap<const Value*, unsigned>::const_iterator It = ValueMap.find(PN);
+    DenseMap<const Value*, Register>::const_iterator It = ValueMap.find(PN);
     if (It == ValueMap.end())
       return;
 
-    unsigned Reg = It->second;
+    Register Reg = It->second;
     if (Reg == 0)
       return;
 
@@ -276,12 +273,10 @@
   /// getArgumentFrameIndex - Get frame index for the byval argument.
   int getArgumentFrameIndex(const Argument *A);
 
-  unsigned getCatchPadExceptionPointerVReg(const Value *CPI,
+  Register getCatchPadExceptionPointerVReg(const Value *CPI,
                                            const TargetRegisterClass *RC);
 
 private:
-  void addSEHHandlersForLPads(ArrayRef<const LandingPadInst *> LPads);
-
   /// LiveOutRegInfo - Information about live out vregs.
   IndexedMap<LiveOutInfo, VirtReg2IndexFunctor> LiveOutRegInfo;
 };
diff --git a/linux-x64/clang/include/llvm/CodeGen/GlobalISel/CSEInfo.h b/linux-x64/clang/include/llvm/CodeGen/GlobalISel/CSEInfo.h
index 5a44e67..f76dec5 100644
--- a/linux-x64/clang/include/llvm/CodeGen/GlobalISel/CSEInfo.h
+++ b/linux-x64/clang/include/llvm/CodeGen/GlobalISel/CSEInfo.h
@@ -16,14 +16,12 @@
 #include "llvm/CodeGen/CSEConfigBase.h"
 #include "llvm/CodeGen/GlobalISel/GISelChangeObserver.h"
 #include "llvm/CodeGen/GlobalISel/GISelWorkList.h"
-#include "llvm/CodeGen/GlobalISel/Utils.h"
-#include "llvm/CodeGen/MachineBasicBlock.h"
 #include "llvm/CodeGen/MachineFunctionPass.h"
-#include "llvm/IR/PassManager.h"
-#include "llvm/Pass.h"
 #include "llvm/Support/Allocator.h"
+#include "llvm/Support/CodeGen.h"
 
 namespace llvm {
+class MachineBasicBlock;
 
 /// A class that wraps MachineInstrs and derives from FoldingSetNode in order to
 /// be uniqued in a CSEMap. The tradeoff here is extra memory allocations for
@@ -120,6 +118,8 @@
 
   void setMF(MachineFunction &MF);
 
+  Error verify();
+
   /// Records a newly created inst in a list and lazily insert it to the CSEMap.
   /// Sometimes, this method might be called with a partially constructed
   /// MachineInstr,
@@ -173,14 +173,16 @@
       : ID(ID), MRI(MRI) {}
   // Profiling methods.
   const GISelInstProfileBuilder &addNodeIDOpcode(unsigned Opc) const;
-  const GISelInstProfileBuilder &addNodeIDRegType(const LLT &Ty) const;
-  const GISelInstProfileBuilder &addNodeIDRegType(const unsigned) const;
+  const GISelInstProfileBuilder &addNodeIDRegType(const LLT Ty) const;
+  const GISelInstProfileBuilder &addNodeIDRegType(const Register) const;
 
   const GISelInstProfileBuilder &
   addNodeIDRegType(const TargetRegisterClass *RC) const;
   const GISelInstProfileBuilder &addNodeIDRegType(const RegisterBank *RB) const;
 
-  const GISelInstProfileBuilder &addNodeIDRegNum(unsigned Reg) const;
+  const GISelInstProfileBuilder &addNodeIDRegNum(Register Reg) const;
+
+  const GISelInstProfileBuilder &addNodeIDReg(Register Reg) const;
 
   const GISelInstProfileBuilder &addNodeIDImmediate(int64_t Imm) const;
   const GISelInstProfileBuilder &
@@ -220,9 +222,7 @@
 
 public:
   static char ID;
-  GISelCSEAnalysisWrapperPass() : MachineFunctionPass(ID) {
-    initializeGISelCSEAnalysisWrapperPassPass(*PassRegistry::getPassRegistry());
-  }
+  GISelCSEAnalysisWrapperPass();
 
   void getAnalysisUsage(AnalysisUsage &AU) const override;
 
diff --git a/linux-x64/clang/include/llvm/CodeGen/GlobalISel/CallLowering.h b/linux-x64/clang/include/llvm/CodeGen/GlobalISel/CallLowering.h
index d8d15bd..57ff390 100644
--- a/linux-x64/clang/include/llvm/CodeGen/GlobalISel/CallLowering.h
+++ b/linux-x64/clang/include/llvm/CodeGen/GlobalISel/CallLowering.h
@@ -17,9 +17,11 @@
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/CodeGen/CallingConvLower.h"
+#include "llvm/CodeGen/MachineOperand.h"
 #include "llvm/CodeGen/TargetCallingConv.h"
-#include "llvm/IR/CallSite.h"
+#include "llvm/IR/Attributes.h"
 #include "llvm/IR/CallingConv.h"
+#include "llvm/IR/Type.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MachineValueType.h"
 #include <cstdint>
@@ -27,14 +29,14 @@
 
 namespace llvm {
 
+class CallBase;
 class DataLayout;
 class Function;
+class FunctionLoweringInfo;
 class MachineIRBuilder;
-class MachineOperand;
 struct MachinePointerInfo;
 class MachineRegisterInfo;
 class TargetLowering;
-class Type;
 class Value;
 
 class CallLowering {
@@ -42,38 +44,104 @@
 
   virtual void anchor();
 public:
-  struct ArgInfo {
-    SmallVector<Register, 4> Regs;
+  struct BaseArgInfo {
     Type *Ty;
-    ISD::ArgFlagsTy Flags;
+    SmallVector<ISD::ArgFlagsTy, 4> Flags;
     bool IsFixed;
 
+    BaseArgInfo(Type *Ty,
+                ArrayRef<ISD::ArgFlagsTy> Flags = ArrayRef<ISD::ArgFlagsTy>(),
+                bool IsFixed = true)
+        : Ty(Ty), Flags(Flags.begin(), Flags.end()), IsFixed(IsFixed) {}
+
+    BaseArgInfo() : Ty(nullptr), IsFixed(false) {}
+  };
+
+  struct ArgInfo : public BaseArgInfo {
+    SmallVector<Register, 4> Regs;
+    // If the argument had to be split into multiple parts according to the
+    // target calling convention, then this contains the original vregs
+    // if the argument was an incoming arg.
+    SmallVector<Register, 2> OrigRegs;
+
     ArgInfo(ArrayRef<Register> Regs, Type *Ty,
-            ISD::ArgFlagsTy Flags = ISD::ArgFlagsTy{}, bool IsFixed = true)
-        : Regs(Regs.begin(), Regs.end()), Ty(Ty), Flags(Flags),
-          IsFixed(IsFixed) {
+            ArrayRef<ISD::ArgFlagsTy> Flags = ArrayRef<ISD::ArgFlagsTy>(),
+            bool IsFixed = true)
+        : BaseArgInfo(Ty, Flags, IsFixed), Regs(Regs.begin(), Regs.end()) {
+      if (!Regs.empty() && Flags.empty())
+        this->Flags.push_back(ISD::ArgFlagsTy());
       // FIXME: We should have just one way of saying "no register".
-      assert((Ty->isVoidTy() == (Regs.empty() || Regs[0] == 0)) &&
+      assert(((Ty->isVoidTy() || Ty->isEmptyTy()) ==
+              (Regs.empty() || Regs[0] == 0)) &&
              "only void types should have no register");
     }
+
+    ArgInfo() : BaseArgInfo() {}
+  };
+
+  struct CallLoweringInfo {
+    /// Calling convention to be used for the call.
+    CallingConv::ID CallConv = CallingConv::C;
+
+    /// Destination of the call. It should be either a register, globaladdress,
+    /// or externalsymbol.
+    MachineOperand Callee = MachineOperand::CreateImm(0);
+
+    /// Descriptor for the return type of the function.
+    ArgInfo OrigRet;
+
+    /// List of descriptors of the arguments passed to the function.
+    SmallVector<ArgInfo, 8> OrigArgs;
+
+    /// Valid if the call has a swifterror inout parameter, and contains the
+    /// vreg that the swifterror should be copied into after the call.
+    Register SwiftErrorVReg;
+
+    MDNode *KnownCallees = nullptr;
+
+    /// True if the call must be tail call optimized.
+    bool IsMustTailCall = false;
+
+    /// True if the call passes all target-independent checks for tail call
+    /// optimization.
+    bool IsTailCall = false;
+
+    /// True if the call was lowered as a tail call. This is consumed by the
+    /// legalizer. This allows the legalizer to lower libcalls as tail calls.
+    bool LoweredTailCall = false;
+
+    /// True if the call is to a vararg function.
+    bool IsVarArg = false;
+
+    /// True if the function's return value can be lowered to registers.
+    bool CanLowerReturn = true;
+
+    /// VReg to hold the hidden sret parameter.
+    Register DemoteRegister;
+
+    /// The stack index for sret demotion.
+    int DemoteStackIndex;
   };
 
   /// Argument handling is mostly uniform between the four places that
   /// make these decisions: function formal arguments, call
   /// instruction args, call instruction returns and function
   /// returns. However, once a decision has been made on where an
-  /// arugment should go, exactly what happens can vary slightly. This
+  /// argument should go, exactly what happens can vary slightly. This
   /// class abstracts the differences.
   struct ValueHandler {
-    ValueHandler(MachineIRBuilder &MIRBuilder, MachineRegisterInfo &MRI,
-                 CCAssignFn *AssignFn)
-      : MIRBuilder(MIRBuilder), MRI(MRI), AssignFn(AssignFn) {}
+    ValueHandler(bool IsIncoming, MachineIRBuilder &MIRBuilder,
+                 MachineRegisterInfo &MRI, CCAssignFn *AssignFn)
+        : MIRBuilder(MIRBuilder), MRI(MRI), AssignFn(AssignFn),
+          IsIncomingArgumentHandler(IsIncoming) {}
 
     virtual ~ValueHandler() = default;
 
-    /// Returns true if the handler is dealing with formal arguments,
-    /// not with return values etc.
-    virtual bool isArgumentHandler() const { return false; }
+    /// Returns true if the handler is dealing with incoming arguments,
+    /// i.e. those that move values from some physical location to vregs.
+    bool isIncomingArgumentHandler() const {
+      return IsIncomingArgumentHandler;
+    }
 
     /// Materialize a VReg containing the address of the specified
     /// stack-based object. This is either based on a FrameIndex or
@@ -96,6 +164,15 @@
                                       uint64_t Size, MachinePointerInfo &MPO,
                                       CCValAssign &VA) = 0;
 
+    /// An overload which takes an ArgInfo if additional information about
+    /// the arg is needed.
+    virtual void assignValueToAddress(const ArgInfo &Arg, Register Addr,
+                                      uint64_t Size, MachinePointerInfo &MPO,
+                                      CCValAssign &VA) {
+      assert(Arg.Regs.size() == 1);
+      assignValueToAddress(Arg.Regs[0], Addr, Size, MPO, VA);
+    }
+
     /// Handle custom values, which may be passed into one or more of \p VAs.
     /// \return The number of \p VAs that have been assigned after the first
     ///         one, and which should therefore be skipped from further
@@ -107,12 +184,15 @@
       llvm_unreachable("Custom values not supported");
     }
 
-    Register extendRegister(Register ValReg, CCValAssign &VA);
+    /// Extend a register to the location type given in VA, capped at extending
+    /// to at most MaxSize bits. If MaxSizeBits is 0 then no maximum is set.
+    Register extendRegister(Register ValReg, CCValAssign &VA,
+                            unsigned MaxSizeBits = 0);
 
     virtual bool assignArg(unsigned ValNo, MVT ValVT, MVT LocVT,
                            CCValAssign::LocInfo LocInfo, const ArgInfo &Info,
-                           CCState &State) {
-      return AssignFn(ValNo, ValVT, LocVT, LocInfo, Info.Flags, State);
+                           ISD::ArgFlagsTy Flags, CCState &State) {
+      return AssignFn(ValNo, ValVT, LocVT, LocInfo, Flags, State);
     }
 
     MachineIRBuilder &MIRBuilder;
@@ -120,9 +200,22 @@
     CCAssignFn *AssignFn;
 
   private:
+    bool IsIncomingArgumentHandler;
     virtual void anchor();
   };
 
+  struct IncomingValueHandler : public ValueHandler {
+    IncomingValueHandler(MachineIRBuilder &MIRBuilder, MachineRegisterInfo &MRI,
+                         CCAssignFn *AssignFn)
+        : ValueHandler(true, MIRBuilder, MRI, AssignFn) {}
+  };
+
+  struct OutgoingValueHandler : public ValueHandler {
+    OutgoingValueHandler(MachineIRBuilder &MIRBuilder, MachineRegisterInfo &MRI,
+                         CCAssignFn *AssignFn)
+        : ValueHandler(false, MIRBuilder, MRI, AssignFn) {}
+  };
+
 protected:
   /// Getter for generic TargetLowering class.
   const TargetLowering *getTLI() const {
@@ -135,6 +228,17 @@
     return static_cast<const XXXTargetLowering *>(TLI);
   }
 
+  /// \returns Flags corresponding to the attributes on the \p ArgIdx-th
+  /// parameter of \p Call.
+  ISD::ArgFlagsTy getAttributesForArgIdx(const CallBase &Call,
+                                         unsigned ArgIdx) const;
+
+  /// Adds flags to \p Flags based off of the attributes in \p Attrs.
+  /// \p OpIdx is the index in \p Attrs to add flags from.
+  void addArgFlagsFromAttributes(ISD::ArgFlagsTy &Flags,
+                                 const AttributeList &Attrs,
+                                 unsigned OpIdx) const;
+
   template <typename FuncInfoTy>
   void setArgFlags(ArgInfo &Arg, unsigned OpIdx, const DataLayout &DL,
                    const FuncInfoTy &FuncInfo) const;
@@ -158,11 +262,44 @@
                   MachineIRBuilder &MIRBuilder) const;
 
   /// Invoke Handler::assignArg on each of the given \p Args and then use
-  /// \p Callback to move them to the assigned locations.
+  /// \p Handler to move them to the assigned locations.
   ///
   /// \return True if everything has succeeded, false otherwise.
-  bool handleAssignments(MachineIRBuilder &MIRBuilder, ArrayRef<ArgInfo> Args,
+  bool handleAssignments(MachineIRBuilder &MIRBuilder,
+                         SmallVectorImpl<ArgInfo> &Args,
                          ValueHandler &Handler) const;
+  bool handleAssignments(CCState &CCState,
+                         SmallVectorImpl<CCValAssign> &ArgLocs,
+                         MachineIRBuilder &MIRBuilder,
+                         SmallVectorImpl<ArgInfo> &Args,
+                         ValueHandler &Handler) const;
+
+  /// Analyze passed or returned values from a call, supplied in \p ArgInfo,
+  /// incorporating info about the passed values into \p CCState.
+  ///
+  /// Used to check if arguments are suitable for tail call lowering.
+  bool analyzeArgInfo(CCState &CCState, SmallVectorImpl<ArgInfo> &Args,
+                      CCAssignFn &AssignFnFixed,
+                      CCAssignFn &AssignFnVarArg) const;
+
+  /// \returns True if the calling convention for a callee and its caller pass
+  /// results in the same way. Typically used for tail call eligibility checks.
+  ///
+  /// \p Info is the CallLoweringInfo for the call.
+  /// \p MF is the MachineFunction for the caller.
+  /// \p InArgs contains the results of the call.
+  /// \p CalleeAssignFnFixed is the CCAssignFn to be used for the callee for
+  /// fixed arguments.
+  /// \p CalleeAssignFnVarArg is similar, but for varargs.
+  /// \p CallerAssignFnFixed is the CCAssignFn to be used for the caller for
+  /// fixed arguments.
+  /// \p CallerAssignFnVarArg is similar, but for varargs.
+  bool resultsCompatible(CallLoweringInfo &Info, MachineFunction &MF,
+                         SmallVectorImpl<ArgInfo> &InArgs,
+                         CCAssignFn &CalleeAssignFnFixed,
+                         CCAssignFn &CalleeAssignFnVarArg,
+                         CCAssignFn &CallerAssignFnFixed,
+                         CCAssignFn &CallerAssignFnVarArg) const;
 
 public:
   CallLowering(const TargetLowering *TLI) : TLI(TLI) {}
@@ -175,20 +312,73 @@
     return false;
   }
 
+  /// Load the returned value from the stack into virtual registers in \p VRegs.
+  /// It uses the frame index \p FI and the start offset from \p DemoteReg.
+  /// The loaded data size will be determined from \p RetTy.
+  void insertSRetLoads(MachineIRBuilder &MIRBuilder, Type *RetTy,
+                       ArrayRef<Register> VRegs, Register DemoteReg,
+                       int FI) const;
+
+  /// Store the return value given by \p VRegs into stack starting at the offset
+  /// specified in \p DemoteReg.
+  void insertSRetStores(MachineIRBuilder &MIRBuilder, Type *RetTy,
+                        ArrayRef<Register> VRegs, Register DemoteReg) const;
+
+  /// Insert the hidden sret ArgInfo to the beginning of \p SplitArgs.
+  /// This function should be called from the target specific
+  /// lowerFormalArguments when \p F requires the sret demotion.
+  void insertSRetIncomingArgument(const Function &F,
+                                  SmallVectorImpl<ArgInfo> &SplitArgs,
+                                  Register &DemoteReg, MachineRegisterInfo &MRI,
+                                  const DataLayout &DL) const;
+
+  /// For the call-base described by \p CB, insert the hidden sret ArgInfo to
+  /// the OrigArgs field of \p Info.
+  void insertSRetOutgoingArgument(MachineIRBuilder &MIRBuilder,
+                                  const CallBase &CB,
+                                  CallLoweringInfo &Info) const;
+
+  /// \return True if the return type described by \p Outs can be returned
+  /// without performing sret demotion.
+  bool checkReturn(CCState &CCInfo, SmallVectorImpl<BaseArgInfo> &Outs,
+                   CCAssignFn *Fn) const;
+
+  /// Get the type and the ArgFlags for the split components of \p RetTy as
+  /// returned by \c ComputeValueVTs.
+  void getReturnInfo(CallingConv::ID CallConv, Type *RetTy, AttributeList Attrs,
+                     SmallVectorImpl<BaseArgInfo> &Outs,
+                     const DataLayout &DL) const;
+
+  /// Toplevel function to check the return type based on the target calling
+  /// convention. \return True if the return value of \p MF can be returned
+  /// without performing sret demotion.
+  bool checkReturnTypeForCallConv(MachineFunction &MF) const;
+
+  /// This hook must be implemented to check whether the return values
+  /// described by \p Outs can fit into the return registers. If false
+  /// is returned, an sret-demotion is performed.
+  virtual bool canLowerReturn(MachineFunction &MF, CallingConv::ID CallConv,
+                              SmallVectorImpl<BaseArgInfo> &Outs,
+                              bool IsVarArg) const {
+    return true;
+  }
+
   /// This hook must be implemented to lower outgoing return values, described
   /// by \p Val, into the specified virtual registers \p VRegs.
   /// This hook is used by GlobalISel.
   ///
+  /// \p FLI is required for sret demotion.
+  ///
   /// \p SwiftErrorVReg is non-zero if the function has a swifterror parameter
   /// that needs to be implicitly returned.
   ///
   /// \return True if the lowering succeeds, false otherwise.
   virtual bool lowerReturn(MachineIRBuilder &MIRBuilder, const Value *Val,
-                           ArrayRef<Register> VRegs,
+                           ArrayRef<Register> VRegs, FunctionLoweringInfo &FLI,
                            Register SwiftErrorVReg) const {
     if (!supportSwiftError()) {
       assert(SwiftErrorVReg == 0 && "attempt to use unsupported swifterror");
-      return lowerReturn(MIRBuilder, Val, VRegs);
+      return lowerReturn(MIRBuilder, Val, VRegs, FLI);
     }
     return false;
   }
@@ -196,10 +386,13 @@
   /// This hook behaves as the extended lowerReturn function, but for targets
   /// that do not support swifterror value promotion.
   virtual bool lowerReturn(MachineIRBuilder &MIRBuilder, const Value *Val,
-                           ArrayRef<Register> VRegs) const {
+                           ArrayRef<Register> VRegs,
+                           FunctionLoweringInfo &FLI) const {
     return false;
   }
 
+  virtual bool fallBackToDAGISel(const Function &F) const { return false; }
+
   /// This hook must be implemented to lower the incoming (formal)
   /// arguments, described by \p VRegs, for GlobalISel. Each argument
   /// must end up in the related virtual registers described by \p VRegs.
@@ -207,49 +400,23 @@
   /// the second in \c VRegs[1], and so on. For each argument, there will be one
   /// register for each non-aggregate type, as returned by \c computeValueLLTs.
   /// \p MIRBuilder is set to the proper insertion for the argument
-  /// lowering.
+  /// lowering. \p FLI is required for sret demotion.
   ///
   /// \return True if the lowering succeeded, false otherwise.
   virtual bool lowerFormalArguments(MachineIRBuilder &MIRBuilder,
                                     const Function &F,
-                                    ArrayRef<ArrayRef<Register>> VRegs) const {
+                                    ArrayRef<ArrayRef<Register>> VRegs,
+                                    FunctionLoweringInfo &FLI) const {
     return false;
   }
 
   /// This hook must be implemented to lower the given call instruction,
   /// including argument and return value marshalling.
   ///
-  /// \p CallConv is the calling convention to be used for the call.
-  ///
-  /// \p Callee is the destination of the call. It should be either a register,
-  /// globaladdress, or externalsymbol.
-  ///
-  /// \p OrigRet is a descriptor for the return type of the function.
-  ///
-  /// \p OrigArgs is a list of descriptors of the arguments passed to the
-  /// function.
-  ///
-  /// \p SwiftErrorVReg is non-zero if the call has a swifterror inout
-  /// parameter, and contains the vreg that the swifterror should be copied into
-  /// after the call.
   ///
   /// \return true if the lowering succeeded, false otherwise.
-  virtual bool lowerCall(MachineIRBuilder &MIRBuilder, CallingConv::ID CallConv,
-                         const MachineOperand &Callee, const ArgInfo &OrigRet,
-                         ArrayRef<ArgInfo> OrigArgs,
-                         Register SwiftErrorVReg) const {
-    if (!supportSwiftError()) {
-      assert(SwiftErrorVReg == 0 && "trying to use unsupported swifterror");
-      return lowerCall(MIRBuilder, CallConv, Callee, OrigRet, OrigArgs);
-    }
-    return false;
-  }
-
-  /// This hook behaves as the extended lowerCall function, but for targets that
-  /// do not support swifterror value promotion.
-  virtual bool lowerCall(MachineIRBuilder &MIRBuilder, CallingConv::ID CallConv,
-                         const MachineOperand &Callee, const ArgInfo &OrigRet,
-                         ArrayRef<ArgInfo> OrigArgs) const {
+  virtual bool lowerCall(MachineIRBuilder &MIRBuilder,
+                         CallLoweringInfo &Info) const {
     return false;
   }
 
@@ -277,7 +444,7 @@
   /// range of an immediate jump.
   ///
   /// \return true if the lowering succeeded, false otherwise.
-  bool lowerCall(MachineIRBuilder &MIRBuilder, ImmutableCallSite CS,
+  bool lowerCall(MachineIRBuilder &MIRBuilder, const CallBase &Call,
                  ArrayRef<Register> ResRegs,
                  ArrayRef<ArrayRef<Register>> ArgRegs, Register SwiftErrorVReg,
                  std::function<unsigned()> GetCalleeReg) const;
diff --git a/linux-x64/clang/include/llvm/CodeGen/GlobalISel/Combiner.h b/linux-x64/clang/include/llvm/CodeGen/GlobalISel/Combiner.h
index 12a1f97..efe8bdf 100644
--- a/linux-x64/clang/include/llvm/CodeGen/GlobalISel/Combiner.h
+++ b/linux-x64/clang/include/llvm/CodeGen/GlobalISel/Combiner.h
@@ -1,4 +1,4 @@
-//== ----- llvm/CodeGen/GlobalISel/Combiner.h --------------------- == //
+//== ----- llvm/CodeGen/GlobalISel/Combiner.h -------------------*- C++ -*-== //
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/linux-x64/clang/include/llvm/CodeGen/GlobalISel/CombinerHelper.h b/linux-x64/clang/include/llvm/CodeGen/GlobalISel/CombinerHelper.h
index 0c50c9c..0d240e9 100644
--- a/linux-x64/clang/include/llvm/CodeGen/GlobalISel/CombinerHelper.h
+++ b/linux-x64/clang/include/llvm/CodeGen/GlobalISel/CombinerHelper.h
@@ -17,16 +17,24 @@
 #ifndef LLVM_CODEGEN_GLOBALISEL_COMBINER_HELPER_H
 #define LLVM_CODEGEN_GLOBALISEL_COMBINER_HELPER_H
 
+#include "llvm/ADT/APFloat.h"
 #include "llvm/CodeGen/LowLevelType.h"
 #include "llvm/CodeGen/Register.h"
+#include "llvm/Support/Alignment.h"
 
 namespace llvm {
 
 class GISelChangeObserver;
 class MachineIRBuilder;
+class MachineInstrBuilder;
 class MachineRegisterInfo;
 class MachineInstr;
 class MachineOperand;
+class GISelKnownBits;
+class MachineDominatorTree;
+class LegalizerInfo;
+struct LegalityQuery;
+class TargetLowering;
 
 struct PreferredTuple {
   LLT Ty;                // The result type of the extend.
@@ -34,13 +42,73 @@
   MachineInstr *MI;
 };
 
+struct IndexedLoadStoreMatchInfo {
+  Register Addr;
+  Register Base;
+  Register Offset;
+  bool IsPre;
+};
+
+struct PtrAddChain {
+  int64_t Imm;
+  Register Base;
+};
+
+struct RegisterImmPair {
+  Register Reg;
+  int64_t Imm;
+};
+
+struct ShiftOfShiftedLogic {
+  MachineInstr *Logic;
+  MachineInstr *Shift2;
+  Register LogicNonShiftReg;
+  uint64_t ValSum;
+};
+
+using OperandBuildSteps =
+    SmallVector<std::function<void(MachineInstrBuilder &)>, 4>;
+struct InstructionBuildSteps {
+  unsigned Opcode = 0;          /// The opcode for the produced instruction.
+  OperandBuildSteps OperandFns; /// Operands to be added to the instruction.
+  InstructionBuildSteps() = default;
+  InstructionBuildSteps(unsigned Opcode, const OperandBuildSteps &OperandFns)
+      : Opcode(Opcode), OperandFns(OperandFns) {}
+};
+
+struct InstructionStepsMatchInfo {
+  /// Describes instructions to be built during a combine.
+  SmallVector<InstructionBuildSteps, 2> InstrsToBuild;
+  InstructionStepsMatchInfo() = default;
+  InstructionStepsMatchInfo(
+      std::initializer_list<InstructionBuildSteps> InstrsToBuild)
+      : InstrsToBuild(InstrsToBuild) {}
+};
+
 class CombinerHelper {
+protected:
   MachineIRBuilder &Builder;
   MachineRegisterInfo &MRI;
   GISelChangeObserver &Observer;
+  GISelKnownBits *KB;
+  MachineDominatorTree *MDT;
+  const LegalizerInfo *LI;
 
 public:
-  CombinerHelper(GISelChangeObserver &Observer, MachineIRBuilder &B);
+  CombinerHelper(GISelChangeObserver &Observer, MachineIRBuilder &B,
+                 GISelKnownBits *KB = nullptr,
+                 MachineDominatorTree *MDT = nullptr,
+                 const LegalizerInfo *LI = nullptr);
+
+  GISelKnownBits *getKnownBits() const {
+    return KB;
+  }
+
+  const TargetLowering &getTargetLowering() const;
+
+  /// \return true if the combine is running prior to legalization, or if \p
+  /// Query is legal on the target.
+  bool isLegalOrBeforeLegalizer(const LegalityQuery &Query) const;
 
   /// MachineRegisterInfo::replaceRegWith() and inform the observer of the changes
   void replaceRegWith(MachineRegisterInfo &MRI, Register FromReg, Register ToReg) const;
@@ -56,18 +124,381 @@
   bool matchCombineCopy(MachineInstr &MI);
   void applyCombineCopy(MachineInstr &MI);
 
+  /// Returns true if \p DefMI precedes \p UseMI or they are the same
+  /// instruction. Both must be in the same basic block.
+  bool isPredecessor(const MachineInstr &DefMI, const MachineInstr &UseMI);
+
+  /// Returns true if \p DefMI dominates \p UseMI. By definition an
+  /// instruction dominates itself.
+  ///
+  /// If we haven't been provided with a MachineDominatorTree during
+  /// construction, this function returns a conservative result that tracks just
+  /// a single basic block.
+  bool dominates(const MachineInstr &DefMI, const MachineInstr &UseMI);
+
   /// If \p MI is extend that consumes the result of a load, try to combine it.
   /// Returns true if MI changed.
   bool tryCombineExtendingLoads(MachineInstr &MI);
   bool matchCombineExtendingLoads(MachineInstr &MI, PreferredTuple &MatchInfo);
   void applyCombineExtendingLoads(MachineInstr &MI, PreferredTuple &MatchInfo);
 
-  bool matchCombineBr(MachineInstr &MI);
-  bool tryCombineBr(MachineInstr &MI);
+  /// Combine \p MI into a pre-indexed or post-indexed load/store operation if
+  /// legal and the surrounding code makes it useful.
+  bool tryCombineIndexedLoadStore(MachineInstr &MI);
+  bool matchCombineIndexedLoadStore(MachineInstr &MI, IndexedLoadStoreMatchInfo &MatchInfo);
+  void applyCombineIndexedLoadStore(MachineInstr &MI, IndexedLoadStoreMatchInfo &MatchInfo);
+
+  bool matchSextTruncSextLoad(MachineInstr &MI);
+  bool applySextTruncSextLoad(MachineInstr &MI);
+
+  /// Match sext_inreg(load p), imm -> sextload p
+  bool matchSextInRegOfLoad(MachineInstr &MI, std::tuple<Register, unsigned> &MatchInfo);
+  bool applySextInRegOfLoad(MachineInstr &MI, std::tuple<Register, unsigned> &MatchInfo);
+
+  /// If a brcond's true block is not the fallthrough, make it so by inverting
+  /// the condition and swapping operands.
+  bool matchOptBrCondByInvertingCond(MachineInstr &MI);
+  void applyOptBrCondByInvertingCond(MachineInstr &MI);
+
+  /// If \p MI is G_CONCAT_VECTORS, try to combine it.
+  /// Returns true if MI changed.
+  /// Right now, we support:
+  /// - concat_vector(undef, undef) => undef
+  /// - concat_vector(build_vector(A, B), build_vector(C, D)) =>
+  ///   build_vector(A, B, C, D)
+  ///
+  /// \pre MI.getOpcode() == G_CONCAT_VECTORS.
+  bool tryCombineConcatVectors(MachineInstr &MI);
+  /// Check if the G_CONCAT_VECTORS \p MI is undef or if it
+  /// can be flattened into a build_vector.
+  /// In the first case \p IsUndef will be true.
+  /// In the second case \p Ops will contain the operands needed
+  /// to produce the flattened build_vector.
+  ///
+  /// \pre MI.getOpcode() == G_CONCAT_VECTORS.
+  bool matchCombineConcatVectors(MachineInstr &MI, bool &IsUndef,
+                                 SmallVectorImpl<Register> &Ops);
+  /// Replace \p MI with a flattened build_vector with \p Ops or an
+  /// implicit_def if IsUndef is true.
+  void applyCombineConcatVectors(MachineInstr &MI, bool IsUndef,
+                                 const ArrayRef<Register> Ops);
+
+  /// Try to combine G_SHUFFLE_VECTOR into G_CONCAT_VECTORS.
+  /// Returns true if MI changed.
+  ///
+  /// \pre MI.getOpcode() == G_SHUFFLE_VECTOR.
+  bool tryCombineShuffleVector(MachineInstr &MI);
+  /// Check if the G_SHUFFLE_VECTOR \p MI can be replaced by a
+  /// concat_vectors.
+  /// \p Ops will contain the operands needed to produce the flattened
+  /// concat_vectors.
+  ///
+  /// \pre MI.getOpcode() == G_SHUFFLE_VECTOR.
+  bool matchCombineShuffleVector(MachineInstr &MI,
+                                 SmallVectorImpl<Register> &Ops);
+  /// Replace \p MI with a concat_vectors with \p Ops.
+  void applyCombineShuffleVector(MachineInstr &MI,
+                                 const ArrayRef<Register> Ops);
+
+  /// Optimize memcpy intrinsics et al, e.g. constant len calls.
+  /// /p MaxLen if non-zero specifies the max length of a mem libcall to inline.
+  ///
+  /// For example (pre-indexed):
+  ///
+  ///     $addr = G_PTR_ADD $base, $offset
+  ///     [...]
+  ///     $val = G_LOAD $addr
+  ///     [...]
+  ///     $whatever = COPY $addr
+  ///
+  /// -->
+  ///
+  ///     $val, $addr = G_INDEXED_LOAD $base, $offset, 1 (IsPre)
+  ///     [...]
+  ///     $whatever = COPY $addr
+  ///
+  /// or (post-indexed):
+  ///
+  ///     G_STORE $val, $base
+  ///     [...]
+  ///     $addr = G_PTR_ADD $base, $offset
+  ///     [...]
+  ///     $whatever = COPY $addr
+  ///
+  /// -->
+  ///
+  ///     $addr = G_INDEXED_STORE $val, $base, $offset
+  ///     [...]
+  ///     $whatever = COPY $addr
+  bool tryCombineMemCpyFamily(MachineInstr &MI, unsigned MaxLen = 0);
+
+  bool matchPtrAddImmedChain(MachineInstr &MI, PtrAddChain &MatchInfo);
+  bool applyPtrAddImmedChain(MachineInstr &MI, PtrAddChain &MatchInfo);
+
+  /// Fold (shift (shift base, x), y) -> (shift base (x+y))
+  bool matchShiftImmedChain(MachineInstr &MI, RegisterImmPair &MatchInfo);
+  bool applyShiftImmedChain(MachineInstr &MI, RegisterImmPair &MatchInfo);
+
+  /// If we have a shift-by-constant of a bitwise logic op that itself has a
+  /// shift-by-constant operand with identical opcode, we may be able to convert
+  /// that into 2 independent shifts followed by the logic op.
+  bool matchShiftOfShiftedLogic(MachineInstr &MI,
+                                ShiftOfShiftedLogic &MatchInfo);
+  bool applyShiftOfShiftedLogic(MachineInstr &MI,
+                                ShiftOfShiftedLogic &MatchInfo);
+
+  /// Transform a multiply by a power-of-2 value to a left shift.
+  bool matchCombineMulToShl(MachineInstr &MI, unsigned &ShiftVal);
+  bool applyCombineMulToShl(MachineInstr &MI, unsigned &ShiftVal);
+
+  // Transform a G_SHL with an extended source into a narrower shift if
+  // possible.
+  bool matchCombineShlOfExtend(MachineInstr &MI, RegisterImmPair &MatchData);
+  bool applyCombineShlOfExtend(MachineInstr &MI,
+                               const RegisterImmPair &MatchData);
+
+  /// Reduce a shift by a constant to an unmerge and a shift on a half sized
+  /// type. This will not produce a shift smaller than \p TargetShiftSize.
+  bool matchCombineShiftToUnmerge(MachineInstr &MI, unsigned TargetShiftSize,
+                                 unsigned &ShiftVal);
+  bool applyCombineShiftToUnmerge(MachineInstr &MI, const unsigned &ShiftVal);
+  bool tryCombineShiftToUnmerge(MachineInstr &MI, unsigned TargetShiftAmount);
+
+  /// Transform <ty,...> G_UNMERGE(G_MERGE ty X, Y, Z) -> ty X, Y, Z.
+  bool
+  matchCombineUnmergeMergeToPlainValues(MachineInstr &MI,
+                                        SmallVectorImpl<Register> &Operands);
+  bool
+  applyCombineUnmergeMergeToPlainValues(MachineInstr &MI,
+                                        SmallVectorImpl<Register> &Operands);
+
+  /// Transform G_UNMERGE Constant -> Constant1, Constant2, ...
+  bool matchCombineUnmergeConstant(MachineInstr &MI,
+                                   SmallVectorImpl<APInt> &Csts);
+  bool applyCombineUnmergeConstant(MachineInstr &MI,
+                                   SmallVectorImpl<APInt> &Csts);
+
+  /// Transform X, Y<dead> = G_UNMERGE Z -> X = G_TRUNC Z.
+  bool matchCombineUnmergeWithDeadLanesToTrunc(MachineInstr &MI);
+  bool applyCombineUnmergeWithDeadLanesToTrunc(MachineInstr &MI);
+
+  /// Transform X, Y = G_UNMERGE(G_ZEXT(Z)) -> X = G_ZEXT(Z); Y = G_CONSTANT 0
+  bool matchCombineUnmergeZExtToZExt(MachineInstr &MI);
+  bool applyCombineUnmergeZExtToZExt(MachineInstr &MI);
+
+  /// Transform fp_instr(cst) to constant result of the fp operation.
+  bool matchCombineConstantFoldFpUnary(MachineInstr &MI,
+                                       Optional<APFloat> &Cst);
+  bool applyCombineConstantFoldFpUnary(MachineInstr &MI,
+                                       Optional<APFloat> &Cst);
+
+  /// Transform IntToPtr(PtrToInt(x)) to x if cast is in the same address space.
+  bool matchCombineI2PToP2I(MachineInstr &MI, Register &Reg);
+  bool applyCombineI2PToP2I(MachineInstr &MI, Register &Reg);
+
+  /// Transform PtrToInt(IntToPtr(x)) to x.
+  bool matchCombineP2IToI2P(MachineInstr &MI, Register &Reg);
+  bool applyCombineP2IToI2P(MachineInstr &MI, Register &Reg);
+
+  /// Transform G_ADD (G_PTRTOINT x), y -> G_PTRTOINT (G_PTR_ADD x, y)
+  /// Transform G_ADD y, (G_PTRTOINT x) -> G_PTRTOINT (G_PTR_ADD x, y)
+  bool matchCombineAddP2IToPtrAdd(MachineInstr &MI,
+                                  std::pair<Register, bool> &PtrRegAndCommute);
+  bool applyCombineAddP2IToPtrAdd(MachineInstr &MI,
+                                  std::pair<Register, bool> &PtrRegAndCommute);
+
+  // Transform G_PTR_ADD (G_PTRTOINT C1), C2 -> C1 + C2
+  bool matchCombineConstPtrAddToI2P(MachineInstr &MI, int64_t &NewCst);
+  bool applyCombineConstPtrAddToI2P(MachineInstr &MI, int64_t &NewCst);
+
+  /// Transform anyext(trunc(x)) to x.
+  bool matchCombineAnyExtTrunc(MachineInstr &MI, Register &Reg);
+  bool applyCombineAnyExtTrunc(MachineInstr &MI, Register &Reg);
+
+  /// Transform [asz]ext([asz]ext(x)) to [asz]ext x.
+  bool matchCombineExtOfExt(MachineInstr &MI,
+                            std::tuple<Register, unsigned> &MatchInfo);
+  bool applyCombineExtOfExt(MachineInstr &MI,
+                            std::tuple<Register, unsigned> &MatchInfo);
+
+  /// Transform fneg(fneg(x)) to x.
+  bool matchCombineFNegOfFNeg(MachineInstr &MI, Register &Reg);
+
+  /// Match fabs(fabs(x)) to fabs(x).
+  bool matchCombineFAbsOfFAbs(MachineInstr &MI, Register &Src);
+  bool applyCombineFAbsOfFAbs(MachineInstr &MI, Register &Src);
+
+  /// Transform trunc ([asz]ext x) to x or ([asz]ext x) or (trunc x).
+  bool matchCombineTruncOfExt(MachineInstr &MI,
+                              std::pair<Register, unsigned> &MatchInfo);
+  bool applyCombineTruncOfExt(MachineInstr &MI,
+                              std::pair<Register, unsigned> &MatchInfo);
+
+  /// Transform trunc (shl x, K) to shl (trunc x),
+  /// K => K < VT.getScalarSizeInBits().
+  bool matchCombineTruncOfShl(MachineInstr &MI,
+                              std::pair<Register, Register> &MatchInfo);
+  bool applyCombineTruncOfShl(MachineInstr &MI,
+                              std::pair<Register, Register> &MatchInfo);
+
+  /// Transform G_MUL(x, -1) to G_SUB(0, x)
+  bool applyCombineMulByNegativeOne(MachineInstr &MI);
+
+  /// Return true if any explicit use operand on \p MI is defined by a
+  /// G_IMPLICIT_DEF.
+  bool matchAnyExplicitUseIsUndef(MachineInstr &MI);
+
+  /// Return true if all register explicit use operands on \p MI are defined by
+  /// a G_IMPLICIT_DEF.
+  bool matchAllExplicitUsesAreUndef(MachineInstr &MI);
+
+  /// Return true if a G_SHUFFLE_VECTOR instruction \p MI has an undef mask.
+  bool matchUndefShuffleVectorMask(MachineInstr &MI);
+
+  /// Return true if a G_STORE instruction \p MI is storing an undef value.
+  bool matchUndefStore(MachineInstr &MI);
+
+  /// Return true if a G_SELECT instruction \p MI has an undef comparison.
+  bool matchUndefSelectCmp(MachineInstr &MI);
+
+  /// Return true if a G_SELECT instruction \p MI has a constant comparison. If
+  /// true, \p OpIdx will store the operand index of the known selected value.
+  bool matchConstantSelectCmp(MachineInstr &MI, unsigned &OpIdx);
+
+  /// Replace an instruction with a G_FCONSTANT with value \p C.
+  bool replaceInstWithFConstant(MachineInstr &MI, double C);
+
+  /// Replace an instruction with a G_CONSTANT with value \p C.
+  bool replaceInstWithConstant(MachineInstr &MI, int64_t C);
+
+  /// Replace an instruction with a G_IMPLICIT_DEF.
+  bool replaceInstWithUndef(MachineInstr &MI);
+
+  /// Delete \p MI and replace all of its uses with its \p OpIdx-th operand.
+  bool replaceSingleDefInstWithOperand(MachineInstr &MI, unsigned OpIdx);
+
+  /// Delete \p MI and replace all of its uses with \p Replacement.
+  bool replaceSingleDefInstWithReg(MachineInstr &MI, Register Replacement);
+
+  /// Return true if \p MOP1 and \p MOP2 are register operands are defined by
+  /// equivalent instructions.
+  bool matchEqualDefs(const MachineOperand &MOP1, const MachineOperand &MOP2);
+
+  /// Return true if \p MOP is defined by a G_CONSTANT with a value equal to
+  /// \p C.
+  bool matchConstantOp(const MachineOperand &MOP, int64_t C);
+
+  /// Optimize (cond ? x : x) -> x
+  bool matchSelectSameVal(MachineInstr &MI);
+
+  /// Optimize (x op x) -> x
+  bool matchBinOpSameVal(MachineInstr &MI);
+
+  /// Check if operand \p OpIdx is zero.
+  bool matchOperandIsZero(MachineInstr &MI, unsigned OpIdx);
+
+  /// Check if operand \p OpIdx is undef.
+  bool matchOperandIsUndef(MachineInstr &MI, unsigned OpIdx);
+
+  /// Check if operand \p OpIdx is known to be a power of 2.
+  bool matchOperandIsKnownToBeAPowerOfTwo(MachineInstr &MI, unsigned OpIdx);
+
+  /// Erase \p MI
+  bool eraseInst(MachineInstr &MI);
+
+  /// Return true if MI is a G_ADD which can be simplified to a G_SUB.
+  bool matchSimplifyAddToSub(MachineInstr &MI,
+                             std::tuple<Register, Register> &MatchInfo);
+  bool applySimplifyAddToSub(MachineInstr &MI,
+                             std::tuple<Register, Register> &MatchInfo);
+
+  /// Match (logic_op (op x...), (op y...)) -> (op (logic_op x, y))
+  bool
+  matchHoistLogicOpWithSameOpcodeHands(MachineInstr &MI,
+                                       InstructionStepsMatchInfo &MatchInfo);
+
+  /// Replace \p MI with a series of instructions described in \p MatchInfo.
+  bool applyBuildInstructionSteps(MachineInstr &MI,
+                                  InstructionStepsMatchInfo &MatchInfo);
+
+  /// Match ashr (shl x, C), C -> sext_inreg (C)
+  bool matchAshrShlToSextInreg(MachineInstr &MI,
+                               std::tuple<Register, int64_t> &MatchInfo);
+  bool applyAshShlToSextInreg(MachineInstr &MI,
+                              std::tuple<Register, int64_t> &MatchInfo);
+  /// \return true if \p MI is a G_AND instruction whose operands are x and y
+  /// where x & y == x or x & y == y. (E.g., one of operands is all-ones value.)
+  ///
+  /// \param [in] MI - The G_AND instruction.
+  /// \param [out] Replacement - A register the G_AND should be replaced with on
+  /// success.
+  bool matchRedundantAnd(MachineInstr &MI, Register &Replacement);
+
+  /// \return true if \p MI is a G_OR instruction whose operands are x and y
+  /// where x | y == x or x | y == y. (E.g., one of operands is all-zeros
+  /// value.)
+  ///
+  /// \param [in] MI - The G_OR instruction.
+  /// \param [out] Replacement - A register the G_OR should be replaced with on
+  /// success.
+  bool matchRedundantOr(MachineInstr &MI, Register &Replacement);
+
+  /// \return true if \p MI is a G_SEXT_INREG that can be erased.
+  bool matchRedundantSExtInReg(MachineInstr &MI);
+
+  /// Combine inverting a result of a compare into the opposite cond code.
+  bool matchNotCmp(MachineInstr &MI, SmallVectorImpl<Register> &RegsToNegate);
+  bool applyNotCmp(MachineInstr &MI, SmallVectorImpl<Register> &RegsToNegate);
+
+  /// Fold (xor (and x, y), y) -> (and (not x), y)
+  ///{
+  bool matchXorOfAndWithSameReg(MachineInstr &MI,
+                                std::pair<Register, Register> &MatchInfo);
+  bool applyXorOfAndWithSameReg(MachineInstr &MI,
+                                std::pair<Register, Register> &MatchInfo);
+  ///}
+
+  /// Combine G_PTR_ADD with nullptr to G_INTTOPTR
+  bool matchPtrAddZero(MachineInstr &MI);
+  bool applyPtrAddZero(MachineInstr &MI);
+
+  /// Combine G_UREM x, (known power of 2) to an add and bitmasking.
+  bool applySimplifyURemByPow2(MachineInstr &MI);
+
+  bool matchCombineInsertVecElts(MachineInstr &MI,
+                                 SmallVectorImpl<Register> &MatchInfo);
+
+  bool applyCombineInsertVecElts(MachineInstr &MI,
+                             SmallVectorImpl<Register> &MatchInfo);
 
   /// Try to transform \p MI by using all of the above
   /// combine functions. Returns true if changed.
   bool tryCombine(MachineInstr &MI);
+
+private:
+  // Memcpy family optimization helpers.
+  bool optimizeMemcpy(MachineInstr &MI, Register Dst, Register Src,
+                      unsigned KnownLen, Align DstAlign, Align SrcAlign,
+                      bool IsVolatile);
+  bool optimizeMemmove(MachineInstr &MI, Register Dst, Register Src,
+                       unsigned KnownLen, Align DstAlign, Align SrcAlign,
+                       bool IsVolatile);
+  bool optimizeMemset(MachineInstr &MI, Register Dst, Register Val,
+                      unsigned KnownLen, Align DstAlign, bool IsVolatile);
+
+  /// Given a non-indexed load or store instruction \p MI, find an offset that
+  /// can be usefully and legally folded into it as a post-indexing operation.
+  ///
+  /// \returns true if a candidate is found.
+  bool findPostIndexCandidate(MachineInstr &MI, Register &Addr, Register &Base,
+                              Register &Offset);
+
+  /// Given a non-indexed load or store instruction \p MI, find an offset that
+  /// can be usefully and legally folded into it as a pre-indexing operation.
+  ///
+  /// \returns true if a candidate is found.
+  bool findPreIndexCandidate(MachineInstr &MI, Register &Addr, Register &Base,
+                             Register &Offset);
 };
 } // namespace llvm
 
diff --git a/linux-x64/clang/include/llvm/CodeGen/GlobalISel/CombinerInfo.h b/linux-x64/clang/include/llvm/CodeGen/GlobalISel/CombinerInfo.h
index 3b09a8e..e95a5e2 100644
--- a/linux-x64/clang/include/llvm/CodeGen/GlobalISel/CombinerInfo.h
+++ b/linux-x64/clang/include/llvm/CodeGen/GlobalISel/CombinerInfo.h
@@ -27,9 +27,11 @@
 class CombinerInfo {
 public:
   CombinerInfo(bool AllowIllegalOps, bool ShouldLegalizeIllegal,
-               LegalizerInfo *LInfo)
+               const LegalizerInfo *LInfo, bool OptEnabled, bool OptSize,
+               bool MinSize)
       : IllegalOpsAllowed(AllowIllegalOps),
-        LegalizeIllegalOps(ShouldLegalizeIllegal), LInfo(LInfo) {
+        LegalizeIllegalOps(ShouldLegalizeIllegal), LInfo(LInfo),
+        EnableOpt(OptEnabled), EnableOptSize(OptSize), EnableMinSize(MinSize) {
     assert(((AllowIllegalOps || !LegalizeIllegalOps) || LInfo) &&
            "Expecting legalizerInfo when illegalops not allowed");
   }
@@ -43,6 +45,15 @@
   bool LegalizeIllegalOps; // TODO: Make use of this.
   const LegalizerInfo *LInfo;
 
+  /// Whether optimizations should be enabled. This is to distinguish between
+  /// uses of the combiner unconditionally and only when optimizations are
+  /// specifically enabled/
+  bool EnableOpt;
+  /// Whether we're optimizing for size.
+  bool EnableOptSize;
+  /// Whether we're optimizing for minsize (-Oz).
+  bool EnableMinSize;
+
   /// Attempt to combine instructions using MI as the root.
   ///
   /// Use Observer to report the creation, modification, and erasure of
diff --git a/linux-x64/clang/include/llvm/CodeGen/GlobalISel/ConstantFoldingMIRBuilder.h b/linux-x64/clang/include/llvm/CodeGen/GlobalISel/ConstantFoldingMIRBuilder.h
index e817d9b..df196bf 100644
--- a/linux-x64/clang/include/llvm/CodeGen/GlobalISel/ConstantFoldingMIRBuilder.h
+++ b/linux-x64/clang/include/llvm/CodeGen/GlobalISel/ConstantFoldingMIRBuilder.h
@@ -54,6 +54,17 @@
         return buildConstant(Dst, MaybeCst->getSExtValue());
       break;
     }
+    case TargetOpcode::G_SEXT_INREG: {
+      assert(DstOps.size() == 1 && "Invalid dst ops");
+      assert(SrcOps.size() == 2 && "Invalid src ops");
+      const DstOp &Dst = DstOps[0];
+      const SrcOp &Src0 = SrcOps[0];
+      const SrcOp &Src1 = SrcOps[1];
+      if (auto MaybeCst =
+              ConstantFoldExtOp(Opc, Src0.getReg(), Src1.getImm(), *getMRI()))
+        return buildConstant(Dst, MaybeCst->getSExtValue());
+      break;
+    }
     }
     return MachineIRBuilder::buildInstr(Opc, DstOps, SrcOps);
   }
diff --git a/linux-x64/clang/include/llvm/CodeGen/GlobalISel/GISelChangeObserver.h b/linux-x64/clang/include/llvm/CodeGen/GlobalISel/GISelChangeObserver.h
index e5691cb..dd7f04a 100644
--- a/linux-x64/clang/include/llvm/CodeGen/GlobalISel/GISelChangeObserver.h
+++ b/linux-x64/clang/include/llvm/CodeGen/GlobalISel/GISelChangeObserver.h
@@ -51,7 +51,7 @@
   /// For convenience, finishedChangingAllUsesOfReg() will report the completion
   /// of the changes. The use list may change between this call and
   /// finishedChangingAllUsesOfReg().
-  void changingAllUsesOfReg(const MachineRegisterInfo &MRI, unsigned Reg);
+  void changingAllUsesOfReg(const MachineRegisterInfo &MRI, Register Reg);
   /// All instructions reported as changing by changingAllUsesOfReg() have
   /// finished being changed.
   void finishedChangingAllUsesOfReg();
@@ -101,7 +101,7 @@
   void MF_HandleRemoval(MachineInstr &MI) override { erasingInstr(MI); }
 };
 
-/// A simple RAII based CSEInfo installer.
+/// A simple RAII based Delegate installer.
 /// Use this in a scope to install a delegate to the MachineFunction and reset
 /// it at the end of the scope.
 class RAIIDelegateInstaller {
@@ -113,5 +113,27 @@
   ~RAIIDelegateInstaller();
 };
 
+/// A simple RAII based Observer installer.
+/// Use this in a scope to install the Observer to the MachineFunction and reset
+/// it at the end of the scope.
+class RAIIMFObserverInstaller {
+  MachineFunction &MF;
+
+public:
+  RAIIMFObserverInstaller(MachineFunction &MF, GISelChangeObserver &Observer);
+  ~RAIIMFObserverInstaller();
+};
+
+/// Class to install both of the above.
+class RAIIMFObsDelInstaller {
+  RAIIDelegateInstaller DelI;
+  RAIIMFObserverInstaller ObsI;
+
+public:
+  RAIIMFObsDelInstaller(MachineFunction &MF, GISelObserverWrapper &Wrapper)
+      : DelI(MF, &Wrapper), ObsI(MF, Wrapper) {}
+  ~RAIIMFObsDelInstaller() = default;
+};
+
 } // namespace llvm
 #endif
diff --git a/linux-x64/clang/include/llvm/CodeGen/GlobalISel/GISelKnownBits.h b/linux-x64/clang/include/llvm/CodeGen/GlobalISel/GISelKnownBits.h
new file mode 100644
index 0000000..eafed37
--- /dev/null
+++ b/linux-x64/clang/include/llvm/CodeGen/GlobalISel/GISelKnownBits.h
@@ -0,0 +1,131 @@
+//===- llvm/CodeGen/GlobalISel/GISelKnownBits.h ---------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+/// Provides analysis for querying information about KnownBits during GISel
+/// passes.
+//
+//===----------------------------------------------------------------------===//
+#ifndef LLVM_CODEGEN_GLOBALISEL_KNOWNBITSINFO_H
+#define LLVM_CODEGEN_GLOBALISEL_KNOWNBITSINFO_H
+
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/CodeGen/GlobalISel/GISelChangeObserver.h"
+#include "llvm/CodeGen/MachineFunctionPass.h"
+#include "llvm/CodeGen/Register.h"
+#include "llvm/InitializePasses.h"
+#include "llvm/Support/KnownBits.h"
+
+namespace llvm {
+
+class TargetLowering;
+class DataLayout;
+
+class GISelKnownBits : public GISelChangeObserver {
+  MachineFunction &MF;
+  MachineRegisterInfo &MRI;
+  const TargetLowering &TL;
+  const DataLayout &DL;
+  unsigned MaxDepth;
+  /// Cache maintained during a computeKnownBits request.
+  SmallDenseMap<Register, KnownBits, 16> ComputeKnownBitsCache;
+
+  void computeKnownBitsMin(Register Src0, Register Src1, KnownBits &Known,
+                           const APInt &DemandedElts,
+                           unsigned Depth = 0);
+
+  unsigned computeNumSignBitsMin(Register Src0, Register Src1,
+                                 const APInt &DemandedElts, unsigned Depth = 0);
+
+public:
+  GISelKnownBits(MachineFunction &MF, unsigned MaxDepth = 6);
+  virtual ~GISelKnownBits() = default;
+
+  const MachineFunction &getMachineFunction() const {
+    return MF;
+  }
+
+  const DataLayout &getDataLayout() const {
+    return DL;
+  }
+
+  virtual void computeKnownBitsImpl(Register R, KnownBits &Known,
+                                    const APInt &DemandedElts,
+                                    unsigned Depth = 0);
+
+  unsigned computeNumSignBits(Register R, const APInt &DemandedElts,
+                              unsigned Depth = 0);
+  unsigned computeNumSignBits(Register R, unsigned Depth = 0);
+
+  // KnownBitsAPI
+  KnownBits getKnownBits(Register R);
+  KnownBits getKnownBits(Register R, const APInt &DemandedElts,
+                         unsigned Depth = 0);
+
+  // Calls getKnownBits for first operand def of MI.
+  KnownBits getKnownBits(MachineInstr &MI);
+  APInt getKnownZeroes(Register R);
+  APInt getKnownOnes(Register R);
+
+  /// \return true if 'V & Mask' is known to be zero in DemandedElts. We use
+  /// this predicate to simplify operations downstream.
+  /// Mask is known to be zero for bits that V cannot have.
+  bool maskedValueIsZero(Register Val, const APInt &Mask) {
+    return Mask.isSubsetOf(getKnownBits(Val).Zero);
+  }
+
+  /// \return true if the sign bit of Op is known to be zero.  We use this
+  /// predicate to simplify operations downstream.
+  bool signBitIsZero(Register Op);
+
+  static void computeKnownBitsForAlignment(KnownBits &Known,
+                                           Align Alignment) {
+    // The low bits are known zero if the pointer is aligned.
+    Known.Zero.setLowBits(Log2(Alignment));
+  }
+
+  /// \return The known alignment for the pointer-like value \p R.
+  Align computeKnownAlignment(Register R, unsigned Depth = 0);
+
+  // Observer API. No-op for non-caching implementation.
+  void erasingInstr(MachineInstr &MI) override{};
+  void createdInstr(MachineInstr &MI) override{};
+  void changingInstr(MachineInstr &MI) override{};
+  void changedInstr(MachineInstr &MI) override{};
+
+protected:
+  unsigned getMaxDepth() const { return MaxDepth; }
+};
+
+/// To use KnownBitsInfo analysis in a pass,
+/// KnownBitsInfo &Info = getAnalysis<GISelKnownBitsInfoAnalysis>().get(MF);
+/// Add to observer if the Info is caching.
+/// WrapperObserver.addObserver(Info);
+
+/// Eventually add other features such as caching/ser/deserializing
+/// to MIR etc. Those implementations can derive from GISelKnownBits
+/// and override computeKnownBitsImpl.
+class GISelKnownBitsAnalysis : public MachineFunctionPass {
+  std::unique_ptr<GISelKnownBits> Info;
+
+public:
+  static char ID;
+  GISelKnownBitsAnalysis() : MachineFunctionPass(ID) {
+    initializeGISelKnownBitsAnalysisPass(*PassRegistry::getPassRegistry());
+  }
+  GISelKnownBits &get(MachineFunction &MF) {
+    if (!Info)
+      Info = std::make_unique<GISelKnownBits>(MF);
+    return *Info.get();
+  }
+  void getAnalysisUsage(AnalysisUsage &AU) const override;
+  bool runOnMachineFunction(MachineFunction &MF) override;
+  void releaseMemory() override { Info.reset(); }
+};
+} // namespace llvm
+
+#endif // ifdef
diff --git a/linux-x64/clang/include/llvm/CodeGen/GlobalISel/GISelWorkList.h b/linux-x64/clang/include/llvm/CodeGen/GlobalISel/GISelWorkList.h
index b0bb519..9e7ade3 100644
--- a/linux-x64/clang/include/llvm/CodeGen/GlobalISel/GISelWorkList.h
+++ b/linux-x64/clang/include/llvm/CodeGen/GlobalISel/GISelWorkList.h
@@ -11,9 +11,6 @@
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallVector.h"
-#include "llvm/CodeGen/MachineBasicBlock.h"
-#include "llvm/CodeGen/MachineInstr.h"
-#include "llvm/Support/Debug.h"
 
 namespace llvm {
 
diff --git a/linux-x64/clang/include/llvm/CodeGen/GlobalISel/IRTranslator.h b/linux-x64/clang/include/llvm/CodeGen/GlobalISel/IRTranslator.h
index 8654ba8..8eab8a5 100644
--- a/linux-x64/clang/include/llvm/CodeGen/GlobalISel/IRTranslator.h
+++ b/linux-x64/clang/include/llvm/CodeGen/GlobalISel/IRTranslator.h
@@ -20,13 +20,14 @@
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallVector.h"
+#include "llvm/CodeGen/FunctionLoweringInfo.h"
 #include "llvm/CodeGen/GlobalISel/CSEMIRBuilder.h"
-#include "llvm/CodeGen/GlobalISel/Types.h"
-#include "llvm/CodeGen/SwiftErrorValueTracking.h"
 #include "llvm/CodeGen/MachineFunctionPass.h"
+#include "llvm/CodeGen/SwiftErrorValueTracking.h"
 #include "llvm/CodeGen/SwitchLoweringUtils.h"
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/Support/Allocator.h"
+#include "llvm/Support/CodeGen.h"
 #include <memory>
 #include <utility>
 
@@ -37,8 +38,8 @@
 class CallInst;
 class CallLowering;
 class Constant;
+class ConstrainedFPIntrinsic;
 class DataLayout;
-class FunctionLoweringInfo;
 class Instruction;
 class MachineBasicBlock;
 class MachineFunction;
@@ -202,6 +203,10 @@
   /// \return true if the materialization succeeded.
   bool translate(const Constant &C, Register Reg);
 
+  // Translate U as a copy of V.
+  bool translateCopy(const User &U, const Value &V,
+                     MachineIRBuilder &MIRBuilder);
+
   /// Translate an LLVM bitcast into generic IR. Either a COPY or a G_BITCAST is
   /// emitted.
   bool translateBitCast(const User &U, MachineIRBuilder &MIRBuilder);
@@ -213,13 +218,15 @@
   bool translateStore(const User &U, MachineIRBuilder &MIRBuilder);
 
   /// Translate an LLVM string intrinsic (memcpy, memset, ...).
-  bool translateMemfunc(const CallInst &CI, MachineIRBuilder &MIRBuilder,
-                        unsigned ID);
+  bool translateMemFunc(const CallInst &CI, MachineIRBuilder &MIRBuilder,
+                        unsigned Opcode);
 
   void getStackGuard(Register DstReg, MachineIRBuilder &MIRBuilder);
 
   bool translateOverflowIntrinsic(const CallInst &CI, unsigned Op,
                                   MachineIRBuilder &MIRBuilder);
+  bool translateFixedPointIntrinsic(unsigned Op, const CallInst &CI,
+                                    MachineIRBuilder &MIRBuilder);
 
   /// Helper function for translateSimpleIntrinsic.
   /// \return The generic opcode for \p IntrinsicID if \p IntrinsicID is a
@@ -232,10 +239,13 @@
   bool translateSimpleIntrinsic(const CallInst &CI, Intrinsic::ID ID,
                                 MachineIRBuilder &MIRBuilder);
 
+  bool translateConstrainedFPIntrinsic(const ConstrainedFPIntrinsic &FPI,
+                                       MachineIRBuilder &MIRBuilder);
+
   bool translateKnownIntrinsic(const CallInst &CI, Intrinsic::ID ID,
                                MachineIRBuilder &MIRBuilder);
 
-  bool translateInlineAsm(const CallInst &CI, MachineIRBuilder &MIRBuilder);
+  bool translateInlineAsm(const CallBase &CB, MachineIRBuilder &MIRBuilder);
 
   /// Returns true if the value should be split into multiple LLTs.
   /// If \p Offsets is given then the split type's offsets will be stored in it.
@@ -243,10 +253,26 @@
   bool valueIsSplit(const Value &V,
                     SmallVectorImpl<uint64_t> *Offsets = nullptr);
 
+  /// Common code for translating normal calls or invokes.
+  bool translateCallBase(const CallBase &CB, MachineIRBuilder &MIRBuilder);
+
   /// Translate call instruction.
   /// \pre \p U is a call instruction.
   bool translateCall(const User &U, MachineIRBuilder &MIRBuilder);
 
+  /// When an invoke or a cleanupret unwinds to the next EH pad, there are
+  /// many places it could ultimately go. In the IR, we have a single unwind
+  /// destination, but in the machine CFG, we enumerate all the possible blocks.
+  /// This function skips over imaginary basic blocks that hold catchswitch
+  /// instructions, and finds all the "real" machine
+  /// basic block destinations. As those destinations may not be successors of
+  /// EHPadBB, here we also calculate the edge probability to those
+  /// destinations. The passed-in Prob is the edge probability to EHPadBB.
+  bool findUnwindDestinations(
+      const BasicBlock *EHPadBB, BranchProbability Prob,
+      SmallVectorImpl<std::pair<MachineBasicBlock *, BranchProbability>>
+          &UnwindDests);
+
   bool translateInvoke(const User &U, MachineIRBuilder &MIRBuilder);
 
   bool translateCallBr(const User &U, MachineIRBuilder &MIRBuilder);
@@ -278,11 +304,37 @@
   /// MachineBasicBlocks for the function have been created.
   void finishPendingPhis();
 
+  /// Translate \p Inst into a unary operation \p Opcode.
+  /// \pre \p U is a unary operation.
+  bool translateUnaryOp(unsigned Opcode, const User &U,
+                        MachineIRBuilder &MIRBuilder);
+
   /// Translate \p Inst into a binary operation \p Opcode.
   /// \pre \p U is a binary operation.
   bool translateBinaryOp(unsigned Opcode, const User &U,
                          MachineIRBuilder &MIRBuilder);
 
+  /// If the set of cases should be emitted as a series of branches, return
+  /// true. If we should emit this as a bunch of and/or'd together conditions,
+  /// return false.
+  bool shouldEmitAsBranches(const std::vector<SwitchCG::CaseBlock> &Cases);
+  /// Helper method for findMergedConditions.
+  /// This function emits a branch and is used at the leaves of an OR or an
+  /// AND operator tree.
+  void emitBranchForMergedCondition(const Value *Cond, MachineBasicBlock *TBB,
+                                    MachineBasicBlock *FBB,
+                                    MachineBasicBlock *CurBB,
+                                    MachineBasicBlock *SwitchBB,
+                                    BranchProbability TProb,
+                                    BranchProbability FProb, bool InvertCond);
+  /// Used during condbr translation to find trees of conditions that can be
+  /// optimized.
+  void findMergedConditions(const Value *Cond, MachineBasicBlock *TBB,
+                            MachineBasicBlock *FBB, MachineBasicBlock *CurBB,
+                            MachineBasicBlock *SwitchBB,
+                            Instruction::BinaryOps Opc, BranchProbability TProb,
+                            BranchProbability FProb, bool InvertCond);
+
   /// Translate branch (br) instruction.
   /// \pre \p U is a branch instruction.
   bool translateBr(const User &U, MachineIRBuilder &MIRBuilder);
@@ -296,19 +348,23 @@
   void emitSwitchCase(SwitchCG::CaseBlock &CB, MachineBasicBlock *SwitchBB,
                       MachineIRBuilder &MIB);
 
-  bool lowerJumpTableWorkItem(SwitchCG::SwitchWorkListItem W,
-                              MachineBasicBlock *SwitchMBB,
-                              MachineBasicBlock *CurMBB,
-                              MachineBasicBlock *DefaultMBB,
-                              MachineIRBuilder &MIB,
-                              MachineFunction::iterator BBI,
-                              BranchProbability UnhandledProbs,
-                              SwitchCG::CaseClusterIt I,
-                              MachineBasicBlock *Fallthrough,
-                              bool FallthroughUnreachable);
+  /// Generate for for the BitTest header block, which precedes each sequence of
+  /// BitTestCases.
+  void emitBitTestHeader(SwitchCG::BitTestBlock &BTB,
+                         MachineBasicBlock *SwitchMBB);
+  /// Generate code to produces one "bit test" for a given BitTestCase \p B.
+  void emitBitTestCase(SwitchCG::BitTestBlock &BB, MachineBasicBlock *NextMBB,
+                       BranchProbability BranchProbToNext, Register Reg,
+                       SwitchCG::BitTestCase &B, MachineBasicBlock *SwitchBB);
 
-  bool lowerSwitchRangeWorkItem(SwitchCG::CaseClusterIt I,
-                                Value *Cond,
+  bool lowerJumpTableWorkItem(
+      SwitchCG::SwitchWorkListItem W, MachineBasicBlock *SwitchMBB,
+      MachineBasicBlock *CurMBB, MachineBasicBlock *DefaultMBB,
+      MachineIRBuilder &MIB, MachineFunction::iterator BBI,
+      BranchProbability UnhandledProbs, SwitchCG::CaseClusterIt I,
+      MachineBasicBlock *Fallthrough, bool FallthroughUnreachable);
+
+  bool lowerSwitchRangeWorkItem(SwitchCG::CaseClusterIt I, Value *Cond,
                                 MachineBasicBlock *Fallthrough,
                                 bool FallthroughUnreachable,
                                 BranchProbability UnhandledProbs,
@@ -316,6 +372,14 @@
                                 MachineIRBuilder &MIB,
                                 MachineBasicBlock *SwitchMBB);
 
+  bool lowerBitTestWorkItem(
+      SwitchCG::SwitchWorkListItem W, MachineBasicBlock *SwitchMBB,
+      MachineBasicBlock *CurMBB, MachineBasicBlock *DefaultMBB,
+      MachineIRBuilder &MIB, MachineFunction::iterator BBI,
+      BranchProbability DefaultProb, BranchProbability UnhandledProbs,
+      SwitchCG::CaseClusterIt I, MachineBasicBlock *Fallthrough,
+      bool FallthroughUnreachable);
+
   bool lowerSwitchWorkItem(SwitchCG::SwitchWorkListItem W, Value *Cond,
                            MachineBasicBlock *SwitchMBB,
                            MachineBasicBlock *DefaultMBB,
@@ -342,8 +406,6 @@
   /// \pre \p U is a return instruction.
   bool translateRet(const User &U, MachineIRBuilder &MIRBuilder);
 
-  bool translateFSub(const User &U, MachineIRBuilder &MIRBuilder);
-
   bool translateFNeg(const User &U, MachineIRBuilder &MIRBuilder);
 
   bool translateAdd(const User &U, MachineIRBuilder &MIRBuilder) {
@@ -428,6 +490,9 @@
   bool translateFAdd(const User &U, MachineIRBuilder &MIRBuilder) {
     return translateBinaryOp(TargetOpcode::G_FADD, U, MIRBuilder);
   }
+  bool translateFSub(const User &U, MachineIRBuilder &MIRBuilder) {
+    return translateBinaryOp(TargetOpcode::G_FSUB, U, MIRBuilder);
+  }
   bool translateFMul(const User &U, MachineIRBuilder &MIRBuilder) {
     return translateBinaryOp(TargetOpcode::G_FMUL, U, MIRBuilder);
   }
@@ -449,6 +514,7 @@
   bool translateAtomicCmpXchg(const User &U, MachineIRBuilder &MIRBuilder);
   bool translateAtomicRMW(const User &U, MachineIRBuilder &MIRBuilder);
   bool translateFence(const User &U, MachineIRBuilder &MIRBuilder);
+  bool translateFreeze(const User &U, MachineIRBuilder &MIRBuilder);
 
   // Stubs to keep the compiler happy while we implement the rest of the
   // translation.
@@ -505,6 +571,8 @@
   /// Current target configuration. Controls how the pass handles errors.
   const TargetPassConfig *TPC;
 
+  CodeGenOpt::Level OptLevel;
+
   /// Current optimization remark emitter. Used to report failures.
   std::unique_ptr<OptimizationRemarkEmitter> ORE;
 
@@ -514,6 +582,10 @@
   // function has the optnone attribute.
   bool EnableOpts = false;
 
+  /// True when the block contains a tail call. This allows the IRTranslator to
+  /// stop translating such blocks early.
+  bool HasTailCall = false;
+
   /// Switch analysis and optimization.
   class GISelSwitchLowering : public SwitchCG::SwitchLowering {
   public:
@@ -571,7 +643,7 @@
   /// Get the alignment of the given memory operation instruction. This will
   /// either be the explicitly specified value or the ABI-required alignment for
   /// the type being accessed (according to the Module's DataLayout).
-  unsigned getMemOpAlignment(const Instruction &I);
+  Align getMemOpAlign(const Instruction &I);
 
   /// Get the MachineBasicBlock that represents \p BB. Specifically, the block
   /// returned will be the head of the translated block (suitable for branch
@@ -600,12 +672,12 @@
   BranchProbability getEdgeProbability(const MachineBasicBlock *Src,
                                        const MachineBasicBlock *Dst) const;
 
-  void addSuccessorWithProb(MachineBasicBlock *Src, MachineBasicBlock *Dst,
-                            BranchProbability Prob);
+  void addSuccessorWithProb(
+      MachineBasicBlock *Src, MachineBasicBlock *Dst,
+      BranchProbability Prob = BranchProbability::getUnknown());
 
 public:
-  // Ctor, nothing fancy.
-  IRTranslator();
+  IRTranslator(CodeGenOpt::Level OptLevel = CodeGenOpt::None);
 
   StringRef getPassName() const override { return "IRTranslator"; }
 
diff --git a/linux-x64/clang/include/llvm/CodeGen/GlobalISel/InlineAsmLowering.h b/linux-x64/clang/include/llvm/CodeGen/GlobalISel/InlineAsmLowering.h
new file mode 100644
index 0000000..ac61848
--- /dev/null
+++ b/linux-x64/clang/include/llvm/CodeGen/GlobalISel/InlineAsmLowering.h
@@ -0,0 +1,67 @@
+//===- llvm/CodeGen/GlobalISel/InlineAsmLowering.h --------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file describes how to lower LLVM inline asm to machine code INLINEASM.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CODEGEN_GLOBALISEL_INLINEASMLOWERING_H
+#define LLVM_CODEGEN_GLOBALISEL_INLINEASMLOWERING_H
+
+#include "llvm/ADT/ArrayRef.h"
+#include <functional>
+
+namespace llvm {
+class CallBase;
+class MachineIRBuilder;
+class MachineOperand;
+class Register;
+class TargetLowering;
+class Value;
+
+class InlineAsmLowering {
+  const TargetLowering *TLI;
+
+  virtual void anchor();
+
+public:
+  /// Lower the given inline asm call instruction
+  /// \p GetOrCreateVRegs is a callback to materialize a register for the
+  /// input and output operands of the inline asm
+  /// \return True if the lowering succeeds, false otherwise.
+  bool lowerInlineAsm(MachineIRBuilder &MIRBuilder, const CallBase &CB,
+                      std::function<ArrayRef<Register>(const Value &Val)>
+                          GetOrCreateVRegs) const;
+
+  /// Lower the specified operand into the Ops vector.
+  /// \p Val is the IR input value to be lowered
+  /// \p Constraint is the user supplied constraint string
+  /// \p Ops is the vector to be filled with the lowered operands
+  /// \return True if the lowering succeeds, false otherwise.
+  virtual bool lowerAsmOperandForConstraint(Value *Val, StringRef Constraint,
+                                            std::vector<MachineOperand> &Ops,
+                                            MachineIRBuilder &MIRBuilder) const;
+
+protected:
+  /// Getter for generic TargetLowering class.
+  const TargetLowering *getTLI() const { return TLI; }
+
+  /// Getter for target specific TargetLowering class.
+  template <class XXXTargetLowering> const XXXTargetLowering *getTLI() const {
+    return static_cast<const XXXTargetLowering *>(TLI);
+  }
+
+public:
+  InlineAsmLowering(const TargetLowering *TLI) : TLI(TLI) {}
+  virtual ~InlineAsmLowering() = default;
+};
+
+} // end namespace llvm
+
+#endif // LLVM_CODEGEN_GLOBALISEL_INLINEASMLOWERING_H
diff --git a/linux-x64/clang/include/llvm/CodeGen/GlobalISel/InstructionSelector.h b/linux-x64/clang/include/llvm/CodeGen/GlobalISel/InstructionSelector.h
index e4d05a5..bf9991e 100644
--- a/linux-x64/clang/include/llvm/CodeGen/GlobalISel/InstructionSelector.h
+++ b/linux-x64/clang/include/llvm/CodeGen/GlobalISel/InstructionSelector.h
@@ -31,6 +31,7 @@
 
 class APInt;
 class APFloat;
+class GISelKnownBits;
 class MachineInstr;
 class MachineInstrBuilder;
 class MachineFunction;
@@ -111,6 +112,14 @@
   /// - InsnID - Instruction ID
   /// - Expected opcode
   GIM_CheckOpcode,
+
+  /// Check the opcode on the specified instruction, checking 2 acceptable
+  /// alternatives.
+  /// - InsnID - Instruction ID
+  /// - Expected opcode
+  /// - Alternative expected opcode
+  GIM_CheckOpcodeIsEither,
+
   /// Check the instruction has the right number of operands
   /// - InsnID - Instruction ID
   /// - Expected number of operands
@@ -138,6 +147,23 @@
   /// - MMOIdx - MMO index
   /// - Size - The size in bytes of the memory access
   GIM_CheckMemorySizeEqualTo,
+
+  /// Check the address space of the memory access for the given machine memory
+  /// operand.
+  /// - InsnID - Instruction ID
+  /// - MMOIdx - MMO index
+  /// - NumAddrSpace - Number of valid address spaces
+  /// - AddrSpaceN - An allowed space of the memory access
+  /// - AddrSpaceN+1 ...
+  GIM_CheckMemoryAddressSpace,
+
+  /// Check the minimum alignment of the memory access for the given machine
+  /// memory operand.
+  /// - InsnID - Instruction ID
+  /// - MMOIdx - MMO index
+  /// - MinAlign - Minimum acceptable alignment
+  GIM_CheckMemoryAlignment,
+
   /// Check the size of the memory access for the given machine memory operand
   /// against the size of an operand.
   /// - InsnID - Instruction ID
@@ -146,6 +172,15 @@
   GIM_CheckMemorySizeEqualToLLT,
   GIM_CheckMemorySizeLessThanLLT,
   GIM_CheckMemorySizeGreaterThanLLT,
+
+  /// Check if this is a vector that can be treated as a vector splat
+  /// constant. This is valid for both G_BUILD_VECTOR as well as
+  /// G_BUILD_VECTOR_TRUNC. For AllOnes refers to individual bits, so a -1
+  /// element.
+  /// - InsnID - Instruction ID
+  GIM_CheckIsBuildVectorAllOnes,
+  GIM_CheckIsBuildVectorAllZeros,
+
   /// Check a generic C++ instruction predicate
   /// - InsnID - Instruction ID
   /// - PredicateID - The ID of the predicate function to call
@@ -191,11 +226,22 @@
   /// - Expected Intrinsic ID
   GIM_CheckIntrinsicID,
 
+  /// Check the operand is a specific predicate
+  /// - InsnID - Instruction ID
+  /// - OpIdx - Operand index
+  /// - Expected predicate
+  GIM_CheckCmpPredicate,
+
   /// Check the specified operand is an MBB
   /// - InsnID - Instruction ID
   /// - OpIdx - Operand index
   GIM_CheckIsMBB,
 
+  /// Check the specified operand is an Imm
+  /// - InsnID - Instruction ID
+  /// - OpIdx - Operand index
+  GIM_CheckIsImm,
+
   /// Check if the specified operand is safe to fold into the current
   /// instruction.
   /// - InsnID - Instruction ID
@@ -208,6 +254,15 @@
   /// - OtherOpIdx - Other operand index
   GIM_CheckIsSameOperand,
 
+  /// Predicates with 'let PredicateCodeUsesOperands = 1' need to examine some
+  /// named operands that will be recorded in RecordedOperands. Names of these
+  /// operands are referenced in predicate argument list. Emitter determines
+  /// StoreIdx(corresponds to the order in which names appear in argument list).
+  /// - InsnID - Instruction ID
+  /// - OpIdx - Operand index
+  /// - StoreIdx - Store location in RecordedOperands.
+  GIM_RecordNamedOperand,
+
   /// Fail the current try-block, or completely fail to match if there is no
   /// current try-block.
   GIM_Reject,
@@ -264,6 +319,13 @@
   /// - TempRegFlags - The register flags to set
   GIR_AddTempRegister,
 
+  /// Add a temporary register to the specified instruction
+  /// - InsnID - Instruction ID to modify
+  /// - TempRegID - The temporary register ID to add
+  /// - TempRegFlags - The register flags to set
+  /// - SubRegIndex - The subregister index to set
+  GIR_AddTempSubRegister,
+
   /// Add an immediate to the specified instruction
   /// - InsnID - Instruction ID to modify
   /// - Imm - The immediate to add
@@ -284,6 +346,14 @@
   /// - RendererFnID - Custom renderer function to call
   GIR_CustomRenderer,
 
+  /// Render operands to the specified instruction using a custom function,
+  /// reading from a specific operand.
+  /// - InsnID - Instruction ID to modify
+  /// - OldInsnID - Instruction ID to get the matched operand from
+  /// - OpIdx - Operand index in OldInsnID the render function should read from..
+  /// - RendererFnID - Custom renderer function to call
+  GIR_CustomOperandRenderer,
+
   /// Render a G_CONSTANT operator as a sign-extended immediate.
   /// - NewInsnID - Instruction ID to modify
   /// - OldInsnID - Instruction ID to copy from
@@ -355,7 +425,25 @@
   ///   if returns true:
   ///     for I in all mutated/inserted instructions:
   ///       !isPreISelGenericOpcode(I.getOpcode())
-  virtual bool select(MachineInstr &I, CodeGenCoverage &CoverageInfo) const = 0;
+  virtual bool select(MachineInstr &I) = 0;
+
+  CodeGenCoverage *CoverageInfo = nullptr;
+  GISelKnownBits *KnownBits = nullptr;
+  MachineFunction *MF = nullptr;
+
+  virtual void setupGeneratedPerFunctionState(MachineFunction &MF) {
+    llvm_unreachable("TableGen should have emitted implementation");
+  }
+
+  /// Setup per-MF selector state.
+  virtual void setupMF(MachineFunction &mf,
+                       GISelKnownBits &KB,
+                       CodeGenCoverage &covinfo) {
+    CoverageInfo = &covinfo;
+    KnownBits = &KB;
+    MF = &mf;
+    setupGeneratedPerFunctionState(mf);
+  }
 
 protected:
   using ComplexRendererFns =
@@ -367,6 +455,11 @@
     std::vector<ComplexRendererFns::value_type> Renderers;
     RecordedMIVector MIs;
     DenseMap<unsigned, unsigned> TempRegisters;
+    /// Named operands that predicate with 'let PredicateCodeUsesOperands = 1'
+    /// referenced in its argument list. Operands are inserted at index set by
+    /// emitter, it corresponds to the order in which names appear in argument
+    /// list. Currently such predicates don't have more then 3 arguments.
+    std::array<const MachineOperand *, 3> RecordedOperands;
 
     MatcherState(unsigned MaxRenderers);
   };
@@ -427,7 +520,9 @@
     llvm_unreachable(
         "Subclasses must override this with a tablegen-erated function");
   }
-  virtual bool testMIPredicate_MI(unsigned, const MachineInstr &) const {
+  virtual bool testMIPredicate_MI(
+      unsigned, const MachineInstr &,
+      const std::array<const MachineOperand *, 3> &Operands) const {
     llvm_unreachable(
         "Subclasses must override this with a tablegen-erated function");
   }
@@ -445,7 +540,7 @@
   bool isOperandImmEqual(const MachineOperand &MO, int64_t Value,
                          const MachineRegisterInfo &MRI) const;
 
-  /// Return true if the specified operand is a G_GEP with a G_CONSTANT on the
+  /// Return true if the specified operand is a G_PTR_ADD with a G_CONSTANT on the
   /// right-hand side. GlobalISel's separation of pointer and integer types
   /// means that we don't need to worry about G_OR with equivalent semantics.
   bool isBaseWithConstantOffset(const MachineOperand &Root,
diff --git a/linux-x64/clang/include/llvm/CodeGen/GlobalISel/InstructionSelectorImpl.h b/linux-x64/clang/include/llvm/CodeGen/GlobalISel/InstructionSelectorImpl.h
index e010180..bcb84c3 100644
--- a/linux-x64/clang/include/llvm/CodeGen/GlobalISel/InstructionSelectorImpl.h
+++ b/linux-x64/clang/include/llvm/CodeGen/GlobalISel/InstructionSelectorImpl.h
@@ -26,6 +26,7 @@
 #include "llvm/CodeGen/TargetOpcodes.h"
 #include "llvm/CodeGen/TargetRegisterInfo.h"
 #include "llvm/IR/Constants.h"
+#include "llvm/IR/DataLayout.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/raw_ostream.h"
@@ -57,6 +58,11 @@
   uint64_t CurrentIdx = 0;
   SmallVector<uint64_t, 4> OnFailResumeAt;
 
+  // Bypass the flag check on the instruction, and only look at the MCInstrDesc.
+  bool NoFPException = !State.MIs[0]->getDesc().mayRaiseFPException();
+
+  const uint16_t Flags = State.MIs[0]->getFlags();
+
   enum RejectAction { RejectAndGiveUp, RejectAndResume };
   auto handleReject = [&]() -> RejectAction {
     DEBUG_WITH_TYPE(TgtInstructionSelector::getName(),
@@ -70,6 +76,19 @@
     return RejectAndResume;
   };
 
+  auto propagateFlags = [=](NewMIVector &OutMIs) {
+    for (auto MIB : OutMIs) {
+      // Set the NoFPExcept flag when no original matched instruction could
+      // raise an FP exception, but the new instruction potentially might.
+      uint16_t MIBFlags = Flags;
+      if (NoFPException && MIB->mayRaiseFPException())
+        MIBFlags |= MachineInstr::NoFPExcept;
+      MIB.setMIFlags(MIBFlags);
+    }
+
+    return true;
+  };
+
   while (true) {
     assert(CurrentIdx != ~0u && "Invalid MatchTable index");
     int64_t MatcherOpcode = MatchTable[CurrentIdx++];
@@ -98,7 +117,7 @@
           return false;
         break;
       }
-      if (TRI.isPhysicalRegister(MO.getReg())) {
+      if (Register::isPhysicalRegister(MO.getReg())) {
         DEBUG_WITH_TYPE(TgtInstructionSelector::getName(),
                         dbgs() << CurrentIdx << ": Is a physical register\n");
         if (handleReject() == RejectAndGiveUp)
@@ -135,24 +154,31 @@
       break;
     }
 
-    case GIM_CheckOpcode: {
+    case GIM_CheckOpcode:
+    case GIM_CheckOpcodeIsEither: {
       int64_t InsnID = MatchTable[CurrentIdx++];
-      int64_t Expected = MatchTable[CurrentIdx++];
+      int64_t Expected0 = MatchTable[CurrentIdx++];
+      int64_t Expected1 = -1;
+      if (MatcherOpcode == GIM_CheckOpcodeIsEither)
+        Expected1 = MatchTable[CurrentIdx++];
 
       assert(State.MIs[InsnID] != nullptr && "Used insn before defined");
       unsigned Opcode = State.MIs[InsnID]->getOpcode();
 
       DEBUG_WITH_TYPE(TgtInstructionSelector::getName(),
-                      dbgs() << CurrentIdx << ": GIM_CheckOpcode(MIs[" << InsnID
-                             << "], ExpectedOpcode=" << Expected
-                             << ") // Got=" << Opcode << "\n");
-      if (Opcode != Expected) {
+        dbgs() << CurrentIdx << ": GIM_CheckOpcode(MIs[" << InsnID
+        << "], ExpectedOpcode=" << Expected0;
+        if (MatcherOpcode == GIM_CheckOpcodeIsEither)
+          dbgs() << " || " << Expected1;
+        dbgs() << ") // Got=" << Opcode << "\n";
+      );
+
+      if (Opcode != Expected0 && Opcode != Expected1) {
         if (handleReject() == RejectAndGiveUp)
           return false;
       }
       break;
     }
-
     case GIM_SwitchOpcode: {
       int64_t InsnID = MatchTable[CurrentIdx++];
       int64_t LowerBound = MatchTable[CurrentIdx++];
@@ -174,7 +200,7 @@
       CurrentIdx = MatchTable[CurrentIdx + (Opcode - LowerBound)];
       if (!CurrentIdx) {
         CurrentIdx = Default;
-	break;
+        break;
       }
       OnFailResumeAt.push_back(Default);
       break;
@@ -302,6 +328,35 @@
           return false;
       break;
     }
+    case GIM_CheckIsBuildVectorAllOnes:
+    case GIM_CheckIsBuildVectorAllZeros: {
+      int64_t InsnID = MatchTable[CurrentIdx++];
+
+      DEBUG_WITH_TYPE(TgtInstructionSelector::getName(),
+                      dbgs() << CurrentIdx
+                             << ": GIM_CheckBuildVectorAll{Zeros|Ones}(MIs["
+                             << InsnID << "])\n");
+      assert(State.MIs[InsnID] != nullptr && "Used insn before defined");
+
+      const MachineInstr *MI = State.MIs[InsnID];
+      assert((MI->getOpcode() == TargetOpcode::G_BUILD_VECTOR ||
+              MI->getOpcode() == TargetOpcode::G_BUILD_VECTOR_TRUNC) &&
+             "Expected G_BUILD_VECTOR or G_BUILD_VECTOR_TRUNC");
+
+      if (MatcherOpcode == GIM_CheckIsBuildVectorAllOnes) {
+        if (!isBuildVectorAllOnes(*MI, MRI)) {
+          if (handleReject() == RejectAndGiveUp)
+            return false;
+        }
+      } else {
+        if (!isBuildVectorAllZeros(*MI, MRI)) {
+          if (handleReject() == RejectAndGiveUp)
+            return false;
+        }
+      }
+
+      break;
+    }
     case GIM_CheckCxxInsnPredicate: {
       int64_t InsnID = MatchTable[CurrentIdx++];
       int64_t Predicate = MatchTable[CurrentIdx++];
@@ -312,7 +367,8 @@
       assert(State.MIs[InsnID] != nullptr && "Used insn before defined");
       assert(Predicate > GIPFP_MI_Invalid && "Expected a valid predicate");
 
-      if (!testMIPredicate_MI(Predicate, *State.MIs[InsnID]))
+      if (!testMIPredicate_MI(Predicate, *State.MIs[InsnID],
+                              State.RecordedOperands))
         if (handleReject() == RejectAndGiveUp)
           return false;
       break;
@@ -370,6 +426,69 @@
             return false;
       break;
     }
+    case GIM_CheckMemoryAddressSpace: {
+      int64_t InsnID = MatchTable[CurrentIdx++];
+      int64_t MMOIdx = MatchTable[CurrentIdx++];
+      // This accepts a list of possible address spaces.
+      const int NumAddrSpace = MatchTable[CurrentIdx++];
+
+      if (State.MIs[InsnID]->getNumMemOperands() <= MMOIdx) {
+        if (handleReject() == RejectAndGiveUp)
+          return false;
+        break;
+      }
+
+      // Need to still jump to the end of the list of address spaces if we find
+      // a match earlier.
+      const uint64_t LastIdx = CurrentIdx + NumAddrSpace;
+
+      const MachineMemOperand *MMO
+        = *(State.MIs[InsnID]->memoperands_begin() + MMOIdx);
+      const unsigned MMOAddrSpace = MMO->getAddrSpace();
+
+      bool Success = false;
+      for (int I = 0; I != NumAddrSpace; ++I) {
+        unsigned AddrSpace = MatchTable[CurrentIdx++];
+        DEBUG_WITH_TYPE(
+          TgtInstructionSelector::getName(),
+          dbgs() << "addrspace(" << MMOAddrSpace << ") vs "
+                 << AddrSpace << '\n');
+
+        if (AddrSpace == MMOAddrSpace) {
+          Success = true;
+          break;
+        }
+      }
+
+      CurrentIdx = LastIdx;
+      if (!Success && handleReject() == RejectAndGiveUp)
+        return false;
+      break;
+    }
+    case GIM_CheckMemoryAlignment: {
+      int64_t InsnID = MatchTable[CurrentIdx++];
+      int64_t MMOIdx = MatchTable[CurrentIdx++];
+      unsigned MinAlign = MatchTable[CurrentIdx++];
+
+      assert(State.MIs[InsnID] != nullptr && "Used insn before defined");
+
+      if (State.MIs[InsnID]->getNumMemOperands() <= MMOIdx) {
+        if (handleReject() == RejectAndGiveUp)
+          return false;
+        break;
+      }
+
+      MachineMemOperand *MMO
+        = *(State.MIs[InsnID]->memoperands_begin() + MMOIdx);
+      DEBUG_WITH_TYPE(TgtInstructionSelector::getName(),
+                      dbgs() << CurrentIdx << ": GIM_CheckMemoryAlignment"
+                      << "(MIs[" << InsnID << "]->memoperands() + " << MMOIdx
+                      << ")->getAlignment() >= " << MinAlign << ")\n");
+      if (MMO->getAlign() < MinAlign && handleReject() == RejectAndGiveUp)
+        return false;
+
+      break;
+    }
     case GIM_CheckMemorySizeEqualTo: {
       int64_t InsnID = MatchTable[CurrentIdx++];
       int64_t MMOIdx = MatchTable[CurrentIdx++];
@@ -499,6 +618,20 @@
 
       break;
     }
+    case GIM_RecordNamedOperand: {
+      int64_t InsnID = MatchTable[CurrentIdx++];
+      int64_t OpIdx = MatchTable[CurrentIdx++];
+      uint64_t StoreIdx = MatchTable[CurrentIdx++];
+
+      DEBUG_WITH_TYPE(TgtInstructionSelector::getName(),
+                      dbgs() << CurrentIdx << ": GIM_RecordNamedOperand(MIs["
+                             << InsnID << "]->getOperand(" << OpIdx
+                             << "), StoreIdx=" << StoreIdx << ")\n");
+      assert(State.MIs[InsnID] != nullptr && "Used insn before defined");
+      assert(StoreIdx < State.RecordedOperands.size() && "Index out of range");
+      State.RecordedOperands[StoreIdx] = &State.MIs[InsnID]->getOperand(OpIdx);
+      break;
+    }
     case GIM_CheckRegBankForClass: {
       int64_t InsnID = MatchTable[CurrentIdx++];
       int64_t OpIdx = MatchTable[CurrentIdx++];
@@ -510,7 +643,8 @@
       assert(State.MIs[InsnID] != nullptr && "Used insn before defined");
       MachineOperand &MO = State.MIs[InsnID]->getOperand(OpIdx);
       if (!MO.isReg() ||
-          &RBI.getRegBankFromRegClass(*TRI.getRegClass(RCEnum)) !=
+          &RBI.getRegBankFromRegClass(*TRI.getRegClass(RCEnum),
+                                      MRI.getType(MO.getReg())) !=
               RBI.getRegBank(MO.getReg(), MRI, TRI)) {
         if (handleReject() == RejectAndGiveUp)
           return false;
@@ -577,10 +711,15 @@
                              << "), Value=" << Value << ")\n");
       assert(State.MIs[InsnID] != nullptr && "Used insn before defined");
       MachineOperand &MO = State.MIs[InsnID]->getOperand(OpIdx);
-      if (!MO.isCImm() || !MO.getCImm()->equalsInt(Value)) {
-        if (handleReject() == RejectAndGiveUp)
-          return false;
-      }
+      if (MO.isImm() && MO.getImm() == Value)
+        break;
+
+      if (MO.isCImm() && MO.getCImm()->equalsInt(Value))
+        break;
+
+      if (handleReject() == RejectAndGiveUp)
+        return false;
+
       break;
     }
 
@@ -599,7 +738,21 @@
           return false;
       break;
     }
-
+    case GIM_CheckCmpPredicate: {
+      int64_t InsnID = MatchTable[CurrentIdx++];
+      int64_t OpIdx = MatchTable[CurrentIdx++];
+      int64_t Value = MatchTable[CurrentIdx++];
+      DEBUG_WITH_TYPE(TgtInstructionSelector::getName(),
+                      dbgs() << CurrentIdx << ": GIM_CheckCmpPredicate(MIs["
+                             << InsnID << "]->getOperand(" << OpIdx
+                             << "), Value=" << Value << ")\n");
+      assert(State.MIs[InsnID] != nullptr && "Used insn before defined");
+      MachineOperand &MO = State.MIs[InsnID]->getOperand(OpIdx);
+      if (!MO.isPredicate() || MO.getPredicate() != Value)
+        if (handleReject() == RejectAndGiveUp)
+          return false;
+      break;
+    }
     case GIM_CheckIsMBB: {
       int64_t InsnID = MatchTable[CurrentIdx++];
       int64_t OpIdx = MatchTable[CurrentIdx++];
@@ -613,7 +766,19 @@
       }
       break;
     }
-
+    case GIM_CheckIsImm: {
+      int64_t InsnID = MatchTable[CurrentIdx++];
+      int64_t OpIdx = MatchTable[CurrentIdx++];
+      DEBUG_WITH_TYPE(TgtInstructionSelector::getName(),
+                      dbgs() << CurrentIdx << ": GIM_CheckIsImm(MIs[" << InsnID
+                             << "]->getOperand(" << OpIdx << "))\n");
+      assert(State.MIs[InsnID] != nullptr && "Used insn before defined");
+      if (!State.MIs[InsnID]->getOperand(OpIdx).isImm()) {
+        if (handleReject() == RejectAndGiveUp)
+          return false;
+      }
+      break;
+    }
     case GIM_CheckIsSafeToFold: {
       int64_t InsnID = MatchTable[CurrentIdx++];
       DEBUG_WITH_TYPE(TgtInstructionSelector::getName(),
@@ -753,24 +918,35 @@
     case GIR_AddRegister: {
       int64_t InsnID = MatchTable[CurrentIdx++];
       int64_t RegNum = MatchTable[CurrentIdx++];
+      uint64_t RegFlags = MatchTable[CurrentIdx++];
       assert(OutMIs[InsnID] && "Attempted to add to undefined instruction");
-      OutMIs[InsnID].addReg(RegNum);
-      DEBUG_WITH_TYPE(TgtInstructionSelector::getName(),
-                      dbgs() << CurrentIdx << ": GIR_AddRegister(OutMIs["
-                             << InsnID << "], " << RegNum << ")\n");
+      OutMIs[InsnID].addReg(RegNum, RegFlags);
+      DEBUG_WITH_TYPE(
+        TgtInstructionSelector::getName(),
+        dbgs() << CurrentIdx << ": GIR_AddRegister(OutMIs["
+        << InsnID << "], " << RegNum << ", " << RegFlags << ")\n");
       break;
     }
 
-    case GIR_AddTempRegister: {
+    case GIR_AddTempRegister:
+    case GIR_AddTempSubRegister: {
       int64_t InsnID = MatchTable[CurrentIdx++];
       int64_t TempRegID = MatchTable[CurrentIdx++];
       uint64_t TempRegFlags = MatchTable[CurrentIdx++];
+      unsigned SubReg = 0;
+      if (MatcherOpcode == GIR_AddTempSubRegister)
+        SubReg = MatchTable[CurrentIdx++];
+
       assert(OutMIs[InsnID] && "Attempted to add to undefined instruction");
-      OutMIs[InsnID].addReg(State.TempRegisters[TempRegID], TempRegFlags);
+
+      OutMIs[InsnID].addReg(State.TempRegisters[TempRegID], TempRegFlags, SubReg);
       DEBUG_WITH_TYPE(TgtInstructionSelector::getName(),
                       dbgs() << CurrentIdx << ": GIR_AddTempRegister(OutMIs["
                              << InsnID << "], TempRegisters[" << TempRegID
-                             << "], " << TempRegFlags << ")\n");
+                             << "]";
+                      if (SubReg)
+                        dbgs() << '.' << TRI.getSubRegIndexName(SubReg);
+                      dbgs() << ", " << TempRegFlags << ")\n");
       break;
     }
 
@@ -854,8 +1030,27 @@
                       dbgs() << CurrentIdx << ": GIR_CustomRenderer(OutMIs["
                              << InsnID << "], MIs[" << OldInsnID << "], "
                              << RendererFnID << ")\n");
+      (ISel.*ISelInfo.CustomRenderers[RendererFnID])(
+        OutMIs[InsnID], *State.MIs[OldInsnID],
+        -1); // Not a source operand of the old instruction.
+      break;
+    }
+    case GIR_CustomOperandRenderer: {
+      int64_t InsnID = MatchTable[CurrentIdx++];
+      int64_t OldInsnID = MatchTable[CurrentIdx++];
+      int64_t OpIdx = MatchTable[CurrentIdx++];
+      int64_t RendererFnID = MatchTable[CurrentIdx++];
+      assert(OutMIs[InsnID] && "Attempted to add to undefined instruction");
+
+      DEBUG_WITH_TYPE(
+        TgtInstructionSelector::getName(),
+        dbgs() << CurrentIdx << ": GIR_CustomOperandRenderer(OutMIs["
+               << InsnID << "], MIs[" << OldInsnID << "]->getOperand("
+               << OpIdx << "), "
+        << RendererFnID << ")\n");
       (ISel.*ISelInfo.CustomRenderers[RendererFnID])(OutMIs[InsnID],
-                                                     *State.MIs[OldInsnID]);
+                                                     *State.MIs[OldInsnID],
+                                                     OpIdx);
       break;
     }
     case GIR_ConstrainOperandRC: {
@@ -939,6 +1134,7 @@
     case GIR_Done:
       DEBUG_WITH_TYPE(TgtInstructionSelector::getName(),
                       dbgs() << CurrentIdx << ": GIR_Done\n");
+      propagateFlags(OutMIs);
       return true;
 
     default:
diff --git a/linux-x64/clang/include/llvm/CodeGen/GlobalISel/LegalizationArtifactCombiner.h b/linux-x64/clang/include/llvm/CodeGen/GlobalISel/LegalizationArtifactCombiner.h
index a22778b..e7bda3b 100644
--- a/linux-x64/clang/include/llvm/CodeGen/GlobalISel/LegalizationArtifactCombiner.h
+++ b/linux-x64/clang/include/llvm/CodeGen/GlobalISel/LegalizationArtifactCombiner.h
@@ -46,11 +46,11 @@
       : Builder(B), MRI(MRI), LI(LI) {}
 
   bool tryCombineAnyExt(MachineInstr &MI,
-                        SmallVectorImpl<MachineInstr *> &DeadInsts) {
-    if (MI.getOpcode() != TargetOpcode::G_ANYEXT)
-      return false;
+                        SmallVectorImpl<MachineInstr *> &DeadInsts,
+                        SmallVectorImpl<Register> &UpdatedDefs) {
+    assert(MI.getOpcode() == TargetOpcode::G_ANYEXT);
 
-    Builder.setInstr(MI);
+    Builder.setInstrAndDebugLoc(MI);
     Register DstReg = MI.getOperand(0).getReg();
     Register SrcReg = lookThroughCopyInstrs(MI.getOperand(1).getReg());
 
@@ -59,6 +59,7 @@
     if (mi_match(SrcReg, MRI, m_GTrunc(m_Reg(TruncSrc)))) {
       LLVM_DEBUG(dbgs() << ".. Combine MI: " << MI;);
       Builder.buildAnyExtOrTrunc(DstReg, TruncSrc);
+      UpdatedDefs.push_back(DstReg);
       markInstAndDefDead(MI, *MRI.getVRegDef(SrcReg), DeadInsts);
       return true;
     }
@@ -71,6 +72,7 @@
                                                     m_GSExt(m_Reg(ExtSrc)),
                                                     m_GZExt(m_Reg(ExtSrc)))))) {
       Builder.buildInstr(ExtMI->getOpcode(), {DstReg}, {ExtSrc});
+      UpdatedDefs.push_back(DstReg);
       markInstAndDefDead(MI, *ExtMI, DeadInsts);
       return true;
     }
@@ -79,102 +81,231 @@
     // Can't use MIPattern because we don't have a specific constant in mind.
     auto *SrcMI = MRI.getVRegDef(SrcReg);
     if (SrcMI->getOpcode() == TargetOpcode::G_CONSTANT) {
-      const LLT &DstTy = MRI.getType(DstReg);
+      const LLT DstTy = MRI.getType(DstReg);
       if (isInstLegal({TargetOpcode::G_CONSTANT, {DstTy}})) {
         auto &CstVal = SrcMI->getOperand(1);
         Builder.buildConstant(
             DstReg, CstVal.getCImm()->getValue().sext(DstTy.getSizeInBits()));
+        UpdatedDefs.push_back(DstReg);
         markInstAndDefDead(MI, *SrcMI, DeadInsts);
         return true;
       }
     }
-    return tryFoldImplicitDef(MI, DeadInsts);
+    return tryFoldImplicitDef(MI, DeadInsts, UpdatedDefs);
   }
 
   bool tryCombineZExt(MachineInstr &MI,
-                      SmallVectorImpl<MachineInstr *> &DeadInsts) {
+                      SmallVectorImpl<MachineInstr *> &DeadInsts,
+                      SmallVectorImpl<Register> &UpdatedDefs,
+                      GISelObserverWrapper &Observer) {
+    assert(MI.getOpcode() == TargetOpcode::G_ZEXT);
 
-    if (MI.getOpcode() != TargetOpcode::G_ZEXT)
-      return false;
-
-    Builder.setInstr(MI);
+    Builder.setInstrAndDebugLoc(MI);
     Register DstReg = MI.getOperand(0).getReg();
     Register SrcReg = lookThroughCopyInstrs(MI.getOperand(1).getReg());
 
     // zext(trunc x) - > and (aext/copy/trunc x), mask
+    // zext(sext x) -> and (sext x), mask
     Register TruncSrc;
-    if (mi_match(SrcReg, MRI, m_GTrunc(m_Reg(TruncSrc)))) {
+    Register SextSrc;
+    if (mi_match(SrcReg, MRI, m_GTrunc(m_Reg(TruncSrc))) ||
+        mi_match(SrcReg, MRI, m_GSExt(m_Reg(SextSrc)))) {
       LLT DstTy = MRI.getType(DstReg);
       if (isInstUnsupported({TargetOpcode::G_AND, {DstTy}}) ||
           isConstantUnsupported(DstTy))
         return false;
       LLVM_DEBUG(dbgs() << ".. Combine MI: " << MI;);
       LLT SrcTy = MRI.getType(SrcReg);
-      APInt Mask = APInt::getAllOnesValue(SrcTy.getScalarSizeInBits());
-      auto MIBMask = Builder.buildConstant(DstTy, Mask.getZExtValue());
-      Builder.buildAnd(DstReg, Builder.buildAnyExtOrTrunc(DstTy, TruncSrc),
-                       MIBMask);
+      APInt MaskVal = APInt::getAllOnesValue(SrcTy.getScalarSizeInBits());
+      auto Mask = Builder.buildConstant(
+        DstTy, MaskVal.zext(DstTy.getScalarSizeInBits()));
+      auto Extended = SextSrc ? Builder.buildSExtOrTrunc(DstTy, SextSrc) :
+                                Builder.buildAnyExtOrTrunc(DstTy, TruncSrc);
+      Builder.buildAnd(DstReg, Extended, Mask);
       markInstAndDefDead(MI, *MRI.getVRegDef(SrcReg), DeadInsts);
       return true;
     }
 
+    // zext(zext x) -> (zext x)
+    Register ZextSrc;
+    if (mi_match(SrcReg, MRI, m_GZExt(m_Reg(ZextSrc)))) {
+      LLVM_DEBUG(dbgs() << ".. Combine MI: " << MI);
+      Observer.changingInstr(MI);
+      MI.getOperand(1).setReg(ZextSrc);
+      Observer.changedInstr(MI);
+      UpdatedDefs.push_back(DstReg);
+      markDefDead(MI, *MRI.getVRegDef(SrcReg), DeadInsts);
+      return true;
+    }
+
     // Try to fold zext(g_constant) when the larger constant type is legal.
     // Can't use MIPattern because we don't have a specific constant in mind.
     auto *SrcMI = MRI.getVRegDef(SrcReg);
     if (SrcMI->getOpcode() == TargetOpcode::G_CONSTANT) {
-      const LLT &DstTy = MRI.getType(DstReg);
+      const LLT DstTy = MRI.getType(DstReg);
       if (isInstLegal({TargetOpcode::G_CONSTANT, {DstTy}})) {
         auto &CstVal = SrcMI->getOperand(1);
         Builder.buildConstant(
             DstReg, CstVal.getCImm()->getValue().zext(DstTy.getSizeInBits()));
+        UpdatedDefs.push_back(DstReg);
         markInstAndDefDead(MI, *SrcMI, DeadInsts);
         return true;
       }
     }
-    return tryFoldImplicitDef(MI, DeadInsts);
+    return tryFoldImplicitDef(MI, DeadInsts, UpdatedDefs);
   }
 
   bool tryCombineSExt(MachineInstr &MI,
-                      SmallVectorImpl<MachineInstr *> &DeadInsts) {
+                      SmallVectorImpl<MachineInstr *> &DeadInsts,
+                      SmallVectorImpl<Register> &UpdatedDefs) {
+    assert(MI.getOpcode() == TargetOpcode::G_SEXT);
 
-    if (MI.getOpcode() != TargetOpcode::G_SEXT)
-      return false;
+    Builder.setInstrAndDebugLoc(MI);
+    Register DstReg = MI.getOperand(0).getReg();
+    Register SrcReg = lookThroughCopyInstrs(MI.getOperand(1).getReg());
+
+    // sext(trunc x) - > (sext_inreg (aext/copy/trunc x), c)
+    Register TruncSrc;
+    if (mi_match(SrcReg, MRI, m_GTrunc(m_Reg(TruncSrc)))) {
+      LLT DstTy = MRI.getType(DstReg);
+      if (isInstUnsupported({TargetOpcode::G_SEXT_INREG, {DstTy}}))
+        return false;
+      LLVM_DEBUG(dbgs() << ".. Combine MI: " << MI;);
+      LLT SrcTy = MRI.getType(SrcReg);
+      uint64_t SizeInBits = SrcTy.getScalarSizeInBits();
+      Builder.buildInstr(
+          TargetOpcode::G_SEXT_INREG, {DstReg},
+          {Builder.buildAnyExtOrTrunc(DstTy, TruncSrc), SizeInBits});
+      markInstAndDefDead(MI, *MRI.getVRegDef(SrcReg), DeadInsts);
+      return true;
+    }
+
+    // sext(zext x) -> (zext x)
+    // sext(sext x) -> (sext x)
+    Register ExtSrc;
+    MachineInstr *ExtMI;
+    if (mi_match(SrcReg, MRI,
+                 m_all_of(m_MInstr(ExtMI), m_any_of(m_GZExt(m_Reg(ExtSrc)),
+                                                    m_GSExt(m_Reg(ExtSrc)))))) {
+      LLVM_DEBUG(dbgs() << ".. Combine MI: " << MI);
+      Builder.buildInstr(ExtMI->getOpcode(), {DstReg}, {ExtSrc});
+      UpdatedDefs.push_back(DstReg);
+      markInstAndDefDead(MI, *MRI.getVRegDef(SrcReg), DeadInsts);
+      return true;
+    }
+
+    return tryFoldImplicitDef(MI, DeadInsts, UpdatedDefs);
+  }
+
+  bool tryCombineTrunc(MachineInstr &MI,
+                       SmallVectorImpl<MachineInstr *> &DeadInsts,
+                       SmallVectorImpl<Register> &UpdatedDefs,
+                       GISelObserverWrapper &Observer) {
+    assert(MI.getOpcode() == TargetOpcode::G_TRUNC);
 
     Builder.setInstr(MI);
     Register DstReg = MI.getOperand(0).getReg();
     Register SrcReg = lookThroughCopyInstrs(MI.getOperand(1).getReg());
 
-    // sext(trunc x) - > ashr (shl (aext/copy/trunc x), c), c
-    Register TruncSrc;
-    if (mi_match(SrcReg, MRI, m_GTrunc(m_Reg(TruncSrc)))) {
-      LLT DstTy = MRI.getType(DstReg);
-      // Guess on the RHS shift amount type, which should be re-legalized if
-      // applicable.
-      if (isInstUnsupported({TargetOpcode::G_SHL, {DstTy, DstTy}}) ||
-          isInstUnsupported({TargetOpcode::G_ASHR, {DstTy, DstTy}}) ||
-          isConstantUnsupported(DstTy))
+    // Try to fold trunc(g_constant) when the smaller constant type is legal.
+    // Can't use MIPattern because we don't have a specific constant in mind.
+    auto *SrcMI = MRI.getVRegDef(SrcReg);
+    if (SrcMI->getOpcode() == TargetOpcode::G_CONSTANT) {
+      const LLT DstTy = MRI.getType(DstReg);
+      if (isInstLegal({TargetOpcode::G_CONSTANT, {DstTy}})) {
+        auto &CstVal = SrcMI->getOperand(1);
+        Builder.buildConstant(
+            DstReg, CstVal.getCImm()->getValue().trunc(DstTy.getSizeInBits()));
+        UpdatedDefs.push_back(DstReg);
+        markInstAndDefDead(MI, *SrcMI, DeadInsts);
+        return true;
+      }
+    }
+
+    // Try to fold trunc(merge) to directly use the source of the merge.
+    // This gets rid of large, difficult to legalize, merges
+    if (SrcMI->getOpcode() == TargetOpcode::G_MERGE_VALUES) {
+      const Register MergeSrcReg = SrcMI->getOperand(1).getReg();
+      const LLT MergeSrcTy = MRI.getType(MergeSrcReg);
+      const LLT DstTy = MRI.getType(DstReg);
+
+      // We can only fold if the types are scalar
+      const unsigned DstSize = DstTy.getSizeInBits();
+      const unsigned MergeSrcSize = MergeSrcTy.getSizeInBits();
+      if (!DstTy.isScalar() || !MergeSrcTy.isScalar())
         return false;
-      LLVM_DEBUG(dbgs() << ".. Combine MI: " << MI;);
-      LLT SrcTy = MRI.getType(SrcReg);
-      unsigned ShAmt = DstTy.getScalarSizeInBits() - SrcTy.getScalarSizeInBits();
-      auto MIBShAmt = Builder.buildConstant(DstTy, ShAmt);
-      auto MIBShl = Builder.buildInstr(
-          TargetOpcode::G_SHL, {DstTy},
-          {Builder.buildAnyExtOrTrunc(DstTy, TruncSrc), MIBShAmt});
-      Builder.buildInstr(TargetOpcode::G_ASHR, {DstReg}, {MIBShl, MIBShAmt});
-      markInstAndDefDead(MI, *MRI.getVRegDef(SrcReg), DeadInsts);
+
+      if (DstSize < MergeSrcSize) {
+        // When the merge source is larger than the destination, we can just
+        // truncate the merge source directly
+        if (isInstUnsupported({TargetOpcode::G_TRUNC, {DstTy, MergeSrcTy}}))
+          return false;
+
+        LLVM_DEBUG(dbgs() << "Combining G_TRUNC(G_MERGE_VALUES) to G_TRUNC: "
+                          << MI);
+
+        Builder.buildTrunc(DstReg, MergeSrcReg);
+        UpdatedDefs.push_back(DstReg);
+      } else if (DstSize == MergeSrcSize) {
+        // If the sizes match we can simply try to replace the register
+        LLVM_DEBUG(
+            dbgs() << "Replacing G_TRUNC(G_MERGE_VALUES) with merge input: "
+                   << MI);
+        replaceRegOrBuildCopy(DstReg, MergeSrcReg, MRI, Builder, UpdatedDefs,
+                              Observer);
+      } else if (DstSize % MergeSrcSize == 0) {
+        // If the trunc size is a multiple of the merge source size we can use
+        // a smaller merge instead
+        if (isInstUnsupported(
+                {TargetOpcode::G_MERGE_VALUES, {DstTy, MergeSrcTy}}))
+          return false;
+
+        LLVM_DEBUG(
+            dbgs() << "Combining G_TRUNC(G_MERGE_VALUES) to G_MERGE_VALUES: "
+                   << MI);
+
+        const unsigned NumSrcs = DstSize / MergeSrcSize;
+        assert(NumSrcs < SrcMI->getNumOperands() - 1 &&
+               "trunc(merge) should require less inputs than merge");
+        SmallVector<Register, 8> SrcRegs(NumSrcs);
+        for (unsigned i = 0; i < NumSrcs; ++i)
+          SrcRegs[i] = SrcMI->getOperand(i + 1).getReg();
+
+        Builder.buildMerge(DstReg, SrcRegs);
+        UpdatedDefs.push_back(DstReg);
+      } else {
+        // Unable to combine
+        return false;
+      }
+
+      markInstAndDefDead(MI, *SrcMI, DeadInsts);
       return true;
     }
-    return tryFoldImplicitDef(MI, DeadInsts);
+
+    // trunc(trunc) -> trunc
+    Register TruncSrc;
+    if (mi_match(SrcReg, MRI, m_GTrunc(m_Reg(TruncSrc)))) {
+      // Always combine trunc(trunc) since the eventual resulting trunc must be
+      // legal anyway as it must be legal for all outputs of the consumer type
+      // set.
+      LLVM_DEBUG(dbgs() << ".. Combine G_TRUNC(G_TRUNC): " << MI);
+
+      Builder.buildTrunc(DstReg, TruncSrc);
+      UpdatedDefs.push_back(DstReg);
+      markInstAndDefDead(MI, *MRI.getVRegDef(TruncSrc), DeadInsts);
+      return true;
+    }
+
+    return false;
   }
 
   /// Try to fold G_[ASZ]EXT (G_IMPLICIT_DEF).
   bool tryFoldImplicitDef(MachineInstr &MI,
-                          SmallVectorImpl<MachineInstr *> &DeadInsts) {
+                          SmallVectorImpl<MachineInstr *> &DeadInsts,
+                          SmallVectorImpl<Register> &UpdatedDefs) {
     unsigned Opcode = MI.getOpcode();
-    if (Opcode != TargetOpcode::G_ANYEXT && Opcode != TargetOpcode::G_ZEXT &&
-        Opcode != TargetOpcode::G_SEXT)
-      return false;
+    assert(Opcode == TargetOpcode::G_ANYEXT || Opcode == TargetOpcode::G_ZEXT ||
+           Opcode == TargetOpcode::G_SEXT);
 
     if (MachineInstr *DefMI = getOpcodeDef(TargetOpcode::G_IMPLICIT_DEF,
                                            MI.getOperand(1).getReg(), MRI)) {
@@ -184,10 +315,11 @@
 
       if (Opcode == TargetOpcode::G_ANYEXT) {
         // G_ANYEXT (G_IMPLICIT_DEF) -> G_IMPLICIT_DEF
-        if (isInstUnsupported({TargetOpcode::G_IMPLICIT_DEF, {DstTy}}))
+        if (!isInstLegal({TargetOpcode::G_IMPLICIT_DEF, {DstTy}}))
           return false;
         LLVM_DEBUG(dbgs() << ".. Combine G_ANYEXT(G_IMPLICIT_DEF): " << MI;);
         Builder.buildInstr(TargetOpcode::G_IMPLICIT_DEF, {DstReg}, {});
+        UpdatedDefs.push_back(DstReg);
       } else {
         // G_[SZ]EXT (G_IMPLICIT_DEF) -> G_CONSTANT 0 because the top
         // bits will be 0 for G_ZEXT and 0/1 for the G_SEXT.
@@ -195,6 +327,7 @@
           return false;
         LLVM_DEBUG(dbgs() << ".. Combine G_[SZ]EXT(G_IMPLICIT_DEF): " << MI;);
         Builder.buildConstant(DstReg, 0);
+        UpdatedDefs.push_back(DstReg);
       }
 
       markInstAndDefDead(MI, *DefMI, DeadInsts);
@@ -203,30 +336,248 @@
     return false;
   }
 
-  static unsigned getMergeOpcode(LLT OpTy, LLT DestTy) {
-    if (OpTy.isVector() && DestTy.isVector())
-      return TargetOpcode::G_CONCAT_VECTORS;
+  bool tryFoldUnmergeCast(MachineInstr &MI, MachineInstr &CastMI,
+                          SmallVectorImpl<MachineInstr *> &DeadInsts,
+                          SmallVectorImpl<Register> &UpdatedDefs) {
 
-    if (OpTy.isVector() && !DestTy.isVector())
-      return TargetOpcode::G_BUILD_VECTOR;
+    assert(MI.getOpcode() == TargetOpcode::G_UNMERGE_VALUES);
 
-    return TargetOpcode::G_MERGE_VALUES;
-  }
+    const unsigned CastOpc = CastMI.getOpcode();
 
-  bool tryCombineMerges(MachineInstr &MI,
-                        SmallVectorImpl<MachineInstr *> &DeadInsts) {
-
-    if (MI.getOpcode() != TargetOpcode::G_UNMERGE_VALUES)
+    if (!isArtifactCast(CastOpc))
       return false;
 
+    const unsigned NumDefs = MI.getNumOperands() - 1;
+
+    const Register CastSrcReg = CastMI.getOperand(1).getReg();
+    const LLT CastSrcTy = MRI.getType(CastSrcReg);
+    const LLT DestTy = MRI.getType(MI.getOperand(0).getReg());
+    const LLT SrcTy = MRI.getType(MI.getOperand(NumDefs).getReg());
+
+    const unsigned CastSrcSize = CastSrcTy.getSizeInBits();
+    const unsigned DestSize = DestTy.getSizeInBits();
+
+    if (CastOpc == TargetOpcode::G_TRUNC) {
+      if (SrcTy.isVector() && SrcTy.getScalarType() == DestTy.getScalarType()) {
+        //  %1:_(<4 x s8>) = G_TRUNC %0(<4 x s32>)
+        //  %2:_(s8), %3:_(s8), %4:_(s8), %5:_(s8) = G_UNMERGE_VALUES %1
+        // =>
+        //  %6:_(s32), %7:_(s32), %8:_(s32), %9:_(s32) = G_UNMERGE_VALUES %0
+        //  %2:_(s8) = G_TRUNC %6
+        //  %3:_(s8) = G_TRUNC %7
+        //  %4:_(s8) = G_TRUNC %8
+        //  %5:_(s8) = G_TRUNC %9
+
+        unsigned UnmergeNumElts =
+            DestTy.isVector() ? CastSrcTy.getNumElements() / NumDefs : 1;
+        LLT UnmergeTy = CastSrcTy.changeNumElements(UnmergeNumElts);
+
+        if (isInstUnsupported(
+                {TargetOpcode::G_UNMERGE_VALUES, {UnmergeTy, CastSrcTy}}))
+          return false;
+
+        Builder.setInstr(MI);
+        auto NewUnmerge = Builder.buildUnmerge(UnmergeTy, CastSrcReg);
+
+        for (unsigned I = 0; I != NumDefs; ++I) {
+          Register DefReg = MI.getOperand(I).getReg();
+          UpdatedDefs.push_back(DefReg);
+          Builder.buildTrunc(DefReg, NewUnmerge.getReg(I));
+        }
+
+        markInstAndDefDead(MI, CastMI, DeadInsts);
+        return true;
+      }
+
+      if (CastSrcTy.isScalar() && SrcTy.isScalar() && !DestTy.isVector()) {
+        //  %1:_(s16) = G_TRUNC %0(s32)
+        //  %2:_(s8), %3:_(s8) = G_UNMERGE_VALUES %1
+        // =>
+        //  %2:_(s8), %3:_(s8), %4:_(s8), %5:_(s8) = G_UNMERGE_VALUES %0
+
+        // Unmerge(trunc) can be combined if the trunc source size is a multiple
+        // of the unmerge destination size
+        if (CastSrcSize % DestSize != 0)
+          return false;
+
+        // Check if the new unmerge is supported
+        if (isInstUnsupported(
+                {TargetOpcode::G_UNMERGE_VALUES, {DestTy, CastSrcTy}}))
+          return false;
+
+        // Gather the original destination registers and create new ones for the
+        // unused bits
+        const unsigned NewNumDefs = CastSrcSize / DestSize;
+        SmallVector<Register, 8> DstRegs(NewNumDefs);
+        for (unsigned Idx = 0; Idx < NewNumDefs; ++Idx) {
+          if (Idx < NumDefs)
+            DstRegs[Idx] = MI.getOperand(Idx).getReg();
+          else
+            DstRegs[Idx] = MRI.createGenericVirtualRegister(DestTy);
+        }
+
+        // Build new unmerge
+        Builder.setInstr(MI);
+        Builder.buildUnmerge(DstRegs, CastSrcReg);
+        UpdatedDefs.append(DstRegs.begin(), DstRegs.begin() + NewNumDefs);
+        markInstAndDefDead(MI, CastMI, DeadInsts);
+        return true;
+      }
+    }
+
+    // TODO: support combines with other casts as well
+    return false;
+  }
+
+  static bool canFoldMergeOpcode(unsigned MergeOp, unsigned ConvertOp,
+                                 LLT OpTy, LLT DestTy) {
+    // Check if we found a definition that is like G_MERGE_VALUES.
+    switch (MergeOp) {
+    default:
+      return false;
+    case TargetOpcode::G_BUILD_VECTOR:
+    case TargetOpcode::G_MERGE_VALUES:
+      // The convert operation that we will need to insert is
+      // going to convert the input of that type of instruction (scalar)
+      // to the destination type (DestTy).
+      // The conversion needs to stay in the same domain (scalar to scalar
+      // and vector to vector), so if we were to allow to fold the merge
+      // we would need to insert some bitcasts.
+      // E.g.,
+      // <2 x s16> = build_vector s16, s16
+      // <2 x s32> = zext <2 x s16>
+      // <2 x s16>, <2 x s16> = unmerge <2 x s32>
+      //
+      // As is the folding would produce:
+      // <2 x s16> = zext s16  <-- scalar to vector
+      // <2 x s16> = zext s16  <-- scalar to vector
+      // Which is invalid.
+      // Instead we would want to generate:
+      // s32 = zext s16
+      // <2 x s16> = bitcast s32
+      // s32 = zext s16
+      // <2 x s16> = bitcast s32
+      //
+      // That is not done yet.
+      if (ConvertOp == 0)
+        return true;
+      return !DestTy.isVector() && OpTy.isVector();
+    case TargetOpcode::G_CONCAT_VECTORS: {
+      if (ConvertOp == 0)
+        return true;
+      if (!DestTy.isVector())
+        return false;
+
+      const unsigned OpEltSize = OpTy.getElementType().getSizeInBits();
+
+      // Don't handle scalarization with a cast that isn't in the same
+      // direction as the vector cast. This could be handled, but it would
+      // require more intermediate unmerges.
+      if (ConvertOp == TargetOpcode::G_TRUNC)
+        return DestTy.getSizeInBits() <= OpEltSize;
+      return DestTy.getSizeInBits() >= OpEltSize;
+    }
+    }
+  }
+
+  /// Try to replace DstReg with SrcReg or build a COPY instruction
+  /// depending on the register constraints.
+  static void replaceRegOrBuildCopy(Register DstReg, Register SrcReg,
+                                    MachineRegisterInfo &MRI,
+                                    MachineIRBuilder &Builder,
+                                    SmallVectorImpl<Register> &UpdatedDefs,
+                                    GISelChangeObserver &Observer) {
+    if (!llvm::canReplaceReg(DstReg, SrcReg, MRI)) {
+      Builder.buildCopy(DstReg, SrcReg);
+      UpdatedDefs.push_back(DstReg);
+      return;
+    }
+    SmallVector<MachineInstr *, 4> UseMIs;
+    // Get the users and notify the observer before replacing.
+    for (auto &UseMI : MRI.use_instructions(DstReg)) {
+      UseMIs.push_back(&UseMI);
+      Observer.changingInstr(UseMI);
+    }
+    // Replace the registers.
+    MRI.replaceRegWith(DstReg, SrcReg);
+    UpdatedDefs.push_back(SrcReg);
+    // Notify the observer that we changed the instructions.
+    for (auto *UseMI : UseMIs)
+      Observer.changedInstr(*UseMI);
+  }
+
+  /// Return the operand index in \p MI that defines \p Def
+  static unsigned getDefIndex(const MachineInstr &MI, Register SearchDef) {
+    unsigned DefIdx = 0;
+    for (const MachineOperand &Def : MI.defs()) {
+      if (Def.getReg() == SearchDef)
+        break;
+      ++DefIdx;
+    }
+
+    return DefIdx;
+  }
+
+  bool tryCombineUnmergeValues(MachineInstr &MI,
+                               SmallVectorImpl<MachineInstr *> &DeadInsts,
+                               SmallVectorImpl<Register> &UpdatedDefs,
+                               GISelChangeObserver &Observer) {
+    assert(MI.getOpcode() == TargetOpcode::G_UNMERGE_VALUES);
+
     unsigned NumDefs = MI.getNumOperands() - 1;
-    MachineInstr *SrcDef =
-        getDefIgnoringCopies(MI.getOperand(NumDefs).getReg(), MRI);
+    Register SrcReg = MI.getOperand(NumDefs).getReg();
+    MachineInstr *SrcDef = getDefIgnoringCopies(SrcReg, MRI);
     if (!SrcDef)
       return false;
 
     LLT OpTy = MRI.getType(MI.getOperand(NumDefs).getReg());
     LLT DestTy = MRI.getType(MI.getOperand(0).getReg());
+
+    if (SrcDef->getOpcode() == TargetOpcode::G_UNMERGE_VALUES) {
+      // %0:_(<4 x s16>) = G_FOO
+      // %1:_(<2 x s16>), %2:_(<2 x s16>) = G_UNMERGE_VALUES %0
+      // %3:_(s16), %4:_(s16) = G_UNMERGE_VALUES %1
+      //
+      // %3:_(s16), %4:_(s16), %5:_(s16), %6:_(s16) = G_UNMERGE_VALUES %0
+      const unsigned NumSrcOps = SrcDef->getNumOperands();
+      Register SrcUnmergeSrc = SrcDef->getOperand(NumSrcOps - 1).getReg();
+      LLT SrcUnmergeSrcTy = MRI.getType(SrcUnmergeSrc);
+
+      // If we need to decrease the number of vector elements in the result type
+      // of an unmerge, this would involve the creation of an equivalent unmerge
+      // to copy back to the original result registers.
+      LegalizeActionStep ActionStep = LI.getAction(
+          {TargetOpcode::G_UNMERGE_VALUES, {OpTy, SrcUnmergeSrcTy}});
+      switch (ActionStep.Action) {
+      case LegalizeActions::Lower:
+      case LegalizeActions::Unsupported:
+        break;
+      case LegalizeActions::FewerElements:
+      case LegalizeActions::NarrowScalar:
+        if (ActionStep.TypeIdx == 1)
+          return false;
+        break;
+      default:
+        return false;
+      }
+
+      Builder.setInstrAndDebugLoc(MI);
+      auto NewUnmerge = Builder.buildUnmerge(DestTy, SrcUnmergeSrc);
+
+      // TODO: Should we try to process out the other defs now? If the other
+      // defs of the source unmerge are also unmerged, we end up with a separate
+      // unmerge for each one.
+      unsigned SrcDefIdx = getDefIndex(*SrcDef, SrcReg);
+      for (unsigned I = 0; I != NumDefs; ++I) {
+        Register Def = MI.getOperand(I).getReg();
+        replaceRegOrBuildCopy(Def, NewUnmerge.getReg(SrcDefIdx * NumDefs + I),
+                              MRI, Builder, UpdatedDefs, Observer);
+      }
+
+      markInstAndDefDead(MI, *SrcDef, DeadInsts, SrcDefIdx);
+      return true;
+    }
+
     MachineInstr *MergeI = SrcDef;
     unsigned ConvertOp = 0;
 
@@ -237,16 +588,17 @@
       MergeI = getDefIgnoringCopies(SrcDef->getOperand(1).getReg(), MRI);
     }
 
-    // FIXME: Handle scalarizing concat_vectors (scalar result type with vector
-    // source)
-    unsigned MergingOpcode = getMergeOpcode(OpTy, DestTy);
-    if (!MergeI || MergeI->getOpcode() != MergingOpcode)
-      return false;
+    if (!MergeI || !canFoldMergeOpcode(MergeI->getOpcode(),
+                                       ConvertOp, OpTy, DestTy)) {
+      // We might have a chance to combine later by trying to combine
+      // unmerge(cast) first
+      return tryFoldUnmergeCast(MI, *SrcDef, DeadInsts, UpdatedDefs);
+    }
 
     const unsigned NumMergeRegs = MergeI->getNumOperands() - 1;
 
     if (NumMergeRegs < NumDefs) {
-      if (ConvertOp != 0 || NumDefs % NumMergeRegs != 0)
+      if (NumDefs % NumMergeRegs != 0)
         return false;
 
       Builder.setInstr(MI);
@@ -259,12 +611,45 @@
 
       const unsigned NewNumDefs = NumDefs / NumMergeRegs;
       for (unsigned Idx = 0; Idx < NumMergeRegs; ++Idx) {
-        SmallVector<Register, 2> DstRegs;
+        SmallVector<Register, 8> DstRegs;
         for (unsigned j = 0, DefIdx = Idx * NewNumDefs; j < NewNumDefs;
              ++j, ++DefIdx)
           DstRegs.push_back(MI.getOperand(DefIdx).getReg());
 
-        Builder.buildUnmerge(DstRegs, MergeI->getOperand(Idx + 1).getReg());
+        if (ConvertOp) {
+          LLT MergeSrcTy = MRI.getType(MergeI->getOperand(1).getReg());
+
+          // This is a vector that is being split and casted. Extract to the
+          // element type, and do the conversion on the scalars (or smaller
+          // vectors).
+          LLT MergeEltTy = MergeSrcTy.divide(NewNumDefs);
+
+          // Handle split to smaller vectors, with conversions.
+          // %2(<8 x s8>) = G_CONCAT_VECTORS %0(<4 x s8>), %1(<4 x s8>)
+          // %3(<8 x s16>) = G_SEXT %2
+          // %4(<2 x s16>), %5(<2 x s16>), %6(<2 x s16>), %7(<2 x s16>) = G_UNMERGE_VALUES %3
+          //
+          // =>
+          //
+          // %8(<2 x s8>), %9(<2 x s8>) = G_UNMERGE_VALUES %0
+          // %10(<2 x s8>), %11(<2 x s8>) = G_UNMERGE_VALUES %1
+          // %4(<2 x s16>) = G_SEXT %8
+          // %5(<2 x s16>) = G_SEXT %9
+          // %6(<2 x s16>) = G_SEXT %10
+          // %7(<2 x s16>)= G_SEXT %11
+
+          SmallVector<Register, 4> TmpRegs(NewNumDefs);
+          for (unsigned k = 0; k < NewNumDefs; ++k)
+            TmpRegs[k] = MRI.createGenericVirtualRegister(MergeEltTy);
+
+          Builder.buildUnmerge(TmpRegs, MergeI->getOperand(Idx + 1).getReg());
+
+          for (unsigned k = 0; k < NewNumDefs; ++k)
+            Builder.buildInstr(ConvertOp, {DstRegs[k]}, {TmpRegs[k]});
+        } else {
+          Builder.buildUnmerge(DstRegs, MergeI->getOperand(Idx + 1).getReg());
+        }
+        UpdatedDefs.append(DstRegs.begin(), DstRegs.end());
       }
 
     } else if (NumMergeRegs > NumDefs) {
@@ -281,36 +666,47 @@
 
       const unsigned NumRegs = NumMergeRegs / NumDefs;
       for (unsigned DefIdx = 0; DefIdx < NumDefs; ++DefIdx) {
-        SmallVector<Register, 2> Regs;
+        SmallVector<Register, 8> Regs;
         for (unsigned j = 0, Idx = NumRegs * DefIdx + 1; j < NumRegs;
              ++j, ++Idx)
           Regs.push_back(MergeI->getOperand(Idx).getReg());
 
-        Builder.buildMerge(MI.getOperand(DefIdx).getReg(), Regs);
+        Register DefReg = MI.getOperand(DefIdx).getReg();
+        Builder.buildMerge(DefReg, Regs);
+        UpdatedDefs.push_back(DefReg);
       }
 
     } else {
       LLT MergeSrcTy = MRI.getType(MergeI->getOperand(1).getReg());
+
+      if (!ConvertOp && DestTy != MergeSrcTy)
+        ConvertOp = TargetOpcode::G_BITCAST;
+
       if (ConvertOp) {
         Builder.setInstr(MI);
 
         for (unsigned Idx = 0; Idx < NumDefs; ++Idx) {
           Register MergeSrc = MergeI->getOperand(Idx + 1).getReg();
-          Builder.buildInstr(ConvertOp, {MI.getOperand(Idx).getReg()},
-                             {MergeSrc});
+          Register DefReg = MI.getOperand(Idx).getReg();
+          Builder.buildInstr(ConvertOp, {DefReg}, {MergeSrc});
+          UpdatedDefs.push_back(DefReg);
         }
 
         markInstAndDefDead(MI, *MergeI, DeadInsts);
         return true;
       }
-      // FIXME: is a COPY appropriate if the types mismatch? We know both
-      // registers are allocatable by now.
-      if (DestTy != MergeSrcTy)
-        return false;
 
-      for (unsigned Idx = 0; Idx < NumDefs; ++Idx)
-        MRI.replaceRegWith(MI.getOperand(Idx).getReg(),
-                           MergeI->getOperand(Idx + 1).getReg());
+      assert(DestTy == MergeSrcTy &&
+             "Bitcast and the other kinds of conversions should "
+             "have happened earlier");
+
+      Builder.setInstr(MI);
+      for (unsigned Idx = 0; Idx < NumDefs; ++Idx) {
+        Register DstReg = MI.getOperand(Idx).getReg();
+        Register SrcReg = MergeI->getOperand(Idx + 1).getReg();
+        replaceRegOrBuildCopy(DstReg, SrcReg, MRI, Builder, UpdatedDefs,
+                              Observer);
+      }
     }
 
     markInstAndDefDead(MI, *MergeI, DeadInsts);
@@ -329,7 +725,8 @@
   }
 
   bool tryCombineExtract(MachineInstr &MI,
-                         SmallVectorImpl<MachineInstr *> &DeadInsts) {
+                         SmallVectorImpl<MachineInstr *> &DeadInsts,
+                         SmallVectorImpl<Register> &UpdatedDefs) {
     assert(MI.getOpcode() == TargetOpcode::G_EXTRACT);
 
     // Try to use the source registers from a G_MERGE_VALUES
@@ -344,13 +741,14 @@
     // for N >= %2.getSizeInBits() / 2
     //    %3 = G_EXTRACT %1, (N - %0.getSizeInBits()
 
-    unsigned Src = lookThroughCopyInstrs(MI.getOperand(1).getReg());
-    MachineInstr *MergeI = MRI.getVRegDef(Src);
+    Register SrcReg = lookThroughCopyInstrs(MI.getOperand(1).getReg());
+    MachineInstr *MergeI = MRI.getVRegDef(SrcReg);
     if (!MergeI || !isMergeLikeOpcode(MergeI->getOpcode()))
       return false;
 
-    LLT DstTy = MRI.getType(MI.getOperand(0).getReg());
-    LLT SrcTy = MRI.getType(Src);
+    Register DstReg = MI.getOperand(0).getReg();
+    LLT DstTy = MRI.getType(DstReg);
+    LLT SrcTy = MRI.getType(SrcReg);
 
     // TODO: Do we need to check if the resulting extract is supported?
     unsigned ExtractDstSize = DstTy.getSizeInBits();
@@ -368,10 +766,9 @@
 
     // TODO: We could modify MI in place in most cases.
     Builder.setInstr(MI);
-    Builder.buildExtract(
-      MI.getOperand(0).getReg(),
-      MergeI->getOperand(MergeSrcIdx + 1).getReg(),
-      Offset - MergeSrcIdx * MergeSrcSize);
+    Builder.buildExtract(DstReg, MergeI->getOperand(MergeSrcIdx + 1).getReg(),
+                         Offset - MergeSrcIdx * MergeSrcSize);
+    UpdatedDefs.push_back(DstReg);
     markInstAndDefDead(MI, *MergeI, DeadInsts);
     return true;
   }
@@ -388,55 +785,117 @@
     // etc, process the dead instructions now if any.
     if (!DeadInsts.empty())
       deleteMarkedDeadInsts(DeadInsts, WrapperObserver);
+
+    // Put here every vreg that was redefined in such a way that it's at least
+    // possible that one (or more) of its users (immediate or COPY-separated)
+    // could become artifact combinable with the new definition (or the
+    // instruction reachable from it through a chain of copies if any).
+    SmallVector<Register, 4> UpdatedDefs;
+    bool Changed = false;
     switch (MI.getOpcode()) {
     default:
       return false;
     case TargetOpcode::G_ANYEXT:
-      return tryCombineAnyExt(MI, DeadInsts);
+      Changed = tryCombineAnyExt(MI, DeadInsts, UpdatedDefs);
+      break;
     case TargetOpcode::G_ZEXT:
-      return tryCombineZExt(MI, DeadInsts);
+      Changed = tryCombineZExt(MI, DeadInsts, UpdatedDefs, WrapperObserver);
+      break;
     case TargetOpcode::G_SEXT:
-      return tryCombineSExt(MI, DeadInsts);
+      Changed = tryCombineSExt(MI, DeadInsts, UpdatedDefs);
+      break;
     case TargetOpcode::G_UNMERGE_VALUES:
-      return tryCombineMerges(MI, DeadInsts);
+      Changed =
+          tryCombineUnmergeValues(MI, DeadInsts, UpdatedDefs, WrapperObserver);
+      break;
+    case TargetOpcode::G_MERGE_VALUES:
+    case TargetOpcode::G_BUILD_VECTOR:
+    case TargetOpcode::G_CONCAT_VECTORS:
+      // If any of the users of this merge are an unmerge, then add them to the
+      // artifact worklist in case there's folding that can be done looking up.
+      for (MachineInstr &U : MRI.use_instructions(MI.getOperand(0).getReg())) {
+        if (U.getOpcode() == TargetOpcode::G_UNMERGE_VALUES ||
+            U.getOpcode() == TargetOpcode::G_TRUNC) {
+          UpdatedDefs.push_back(MI.getOperand(0).getReg());
+          break;
+        }
+      }
+      break;
     case TargetOpcode::G_EXTRACT:
-      return tryCombineExtract(MI, DeadInsts);
-    case TargetOpcode::G_TRUNC: {
-      bool Changed = false;
-      for (auto &Use : MRI.use_instructions(MI.getOperand(0).getReg()))
-        Changed |= tryCombineInstruction(Use, DeadInsts, WrapperObserver);
-      return Changed;
+      Changed = tryCombineExtract(MI, DeadInsts, UpdatedDefs);
+      break;
+    case TargetOpcode::G_TRUNC:
+      Changed = tryCombineTrunc(MI, DeadInsts, UpdatedDefs, WrapperObserver);
+      if (!Changed) {
+        // Try to combine truncates away even if they are legal. As all artifact
+        // combines at the moment look only "up" the def-use chains, we achieve
+        // that by throwing truncates' users (with look through copies) into the
+        // ArtifactList again.
+        UpdatedDefs.push_back(MI.getOperand(0).getReg());
+      }
+      break;
     }
+    // If the main loop through the ArtifactList found at least one combinable
+    // pair of artifacts, not only combine it away (as done above), but also
+    // follow the def-use chain from there to combine everything that can be
+    // combined within this def-use chain of artifacts.
+    while (!UpdatedDefs.empty()) {
+      Register NewDef = UpdatedDefs.pop_back_val();
+      assert(NewDef.isVirtual() && "Unexpected redefinition of a physreg");
+      for (MachineInstr &Use : MRI.use_instructions(NewDef)) {
+        switch (Use.getOpcode()) {
+        // Keep this list in sync with the list of all artifact combines.
+        case TargetOpcode::G_ANYEXT:
+        case TargetOpcode::G_ZEXT:
+        case TargetOpcode::G_SEXT:
+        case TargetOpcode::G_UNMERGE_VALUES:
+        case TargetOpcode::G_EXTRACT:
+        case TargetOpcode::G_TRUNC:
+          // Adding Use to ArtifactList.
+          WrapperObserver.changedInstr(Use);
+          break;
+        case TargetOpcode::COPY: {
+          Register Copy = Use.getOperand(0).getReg();
+          if (Copy.isVirtual())
+            UpdatedDefs.push_back(Copy);
+          break;
+        }
+        default:
+          // If we do not have an artifact combine for the opcode, there is no
+          // point in adding it to the ArtifactList as nothing interesting will
+          // be done to it anyway.
+          break;
+        }
+      }
     }
+    return Changed;
   }
 
 private:
-
-  static unsigned getArtifactSrcReg(const MachineInstr &MI) {
+  static Register getArtifactSrcReg(const MachineInstr &MI) {
     switch (MI.getOpcode()) {
     case TargetOpcode::COPY:
     case TargetOpcode::G_TRUNC:
     case TargetOpcode::G_ZEXT:
     case TargetOpcode::G_ANYEXT:
     case TargetOpcode::G_SEXT:
-    case TargetOpcode::G_UNMERGE_VALUES:
-      return MI.getOperand(MI.getNumOperands() - 1).getReg();
     case TargetOpcode::G_EXTRACT:
       return MI.getOperand(1).getReg();
+    case TargetOpcode::G_UNMERGE_VALUES:
+      return MI.getOperand(MI.getNumOperands() - 1).getReg();
     default:
       llvm_unreachable("Not a legalization artifact happen");
     }
   }
 
-  /// Mark MI as dead. If a def of one of MI's operands, DefMI, would also be
-  /// dead due to MI being killed, then mark DefMI as dead too.
-  /// Some of the combines (extends(trunc)), try to walk through redundant
-  /// copies in between the extends and the truncs, and this attempts to collect
-  /// the in between copies if they're dead.
-  void markInstAndDefDead(MachineInstr &MI, MachineInstr &DefMI,
-                          SmallVectorImpl<MachineInstr *> &DeadInsts) {
-    DeadInsts.push_back(&MI);
-
+  /// Mark a def of one of MI's original operands, DefMI, as dead if changing MI
+  /// (either by killing it or changing operands) results in DefMI being dead
+  /// too. In-between COPYs or artifact-casts are also collected if they are
+  /// dead.
+  /// MI is not marked dead.
+  void markDefDead(MachineInstr &MI, MachineInstr &DefMI,
+                   SmallVectorImpl<MachineInstr *> &DeadInsts,
+                   unsigned DefIdx = 0) {
     // Collect all the copy instructions that are made dead, due to deleting
     // this instruction. Collect all of them until the Trunc(DefMI).
     // Eg,
@@ -448,7 +907,7 @@
     // and as a result, %3, %2, %1 are dead.
     MachineInstr *PrevMI = &MI;
     while (PrevMI != &DefMI) {
-      unsigned PrevRegSrc = getArtifactSrcReg(*PrevMI);
+      Register PrevRegSrc = getArtifactSrcReg(*PrevMI);
 
       MachineInstr *TmpDef = MRI.getVRegDef(PrevRegSrc);
       if (MRI.hasOneUse(PrevRegSrc)) {
@@ -463,8 +922,39 @@
         break;
       PrevMI = TmpDef;
     }
-    if (PrevMI == &DefMI && MRI.hasOneUse(DefMI.getOperand(0).getReg()))
-      DeadInsts.push_back(&DefMI);
+
+    if (PrevMI == &DefMI) {
+      unsigned I = 0;
+      bool IsDead = true;
+      for (MachineOperand &Def : DefMI.defs()) {
+        if (I != DefIdx) {
+          if (!MRI.use_empty(Def.getReg())) {
+            IsDead = false;
+            break;
+          }
+        } else {
+          if (!MRI.hasOneUse(DefMI.getOperand(DefIdx).getReg()))
+            break;
+        }
+
+        ++I;
+      }
+
+      if (IsDead)
+        DeadInsts.push_back(&DefMI);
+    }
+  }
+
+  /// Mark MI as dead. If a def of one of MI's operands, DefMI, would also be
+  /// dead due to MI being killed, then mark DefMI as dead too.
+  /// Some of the combines (extends(trunc)), try to walk through redundant
+  /// copies in between the extends and the truncs, and this attempts to collect
+  /// the in between copies if they're dead.
+  void markInstAndDefDead(MachineInstr &MI, MachineInstr &DefMI,
+                          SmallVectorImpl<MachineInstr *> &DeadInsts,
+                          unsigned DefIdx = 0) {
+    DeadInsts.push_back(&MI);
+    markDefDead(MI, DefMI, DeadInsts, DefIdx);
   }
 
   /// Erase the dead instructions in the list and call the observer hooks.
@@ -506,7 +996,7 @@
 
   /// Looks through copy instructions and returns the actual
   /// source register.
-  unsigned lookThroughCopyInstrs(Register Reg) {
+  Register lookThroughCopyInstrs(Register Reg) {
     Register TmpReg;
     while (mi_match(Reg, MRI, m_Copy(m_Reg(TmpReg)))) {
       if (MRI.getType(TmpReg).isValid())
diff --git a/linux-x64/clang/include/llvm/CodeGen/GlobalISel/Legalizer.h b/linux-x64/clang/include/llvm/CodeGen/GlobalISel/Legalizer.h
index 13cf3f7..690e84f 100644
--- a/linux-x64/clang/include/llvm/CodeGen/GlobalISel/Legalizer.h
+++ b/linux-x64/clang/include/llvm/CodeGen/GlobalISel/Legalizer.h
@@ -26,13 +26,18 @@
 namespace llvm {
 
 class MachineRegisterInfo;
+class LostDebugLocObserver;
 
 class Legalizer : public MachineFunctionPass {
 public:
   static char ID;
 
-private:
+  struct MFResult {
+    bool Changed;
+    const MachineInstr *FailedOn;
+  };
 
+private:
   /// Initialize the field members using \p MF.
   void init(MachineFunction &MF);
 
@@ -55,14 +60,17 @@
   }
 
   MachineFunctionProperties getClearedProperties() const override {
-    return MachineFunctionProperties()
-      .set(MachineFunctionProperties::Property::NoPHIs);
+    return MachineFunctionProperties().set(
+        MachineFunctionProperties::Property::NoPHIs);
   }
 
-  bool combineExtracts(MachineInstr &MI, MachineRegisterInfo &MRI,
-                       const TargetInstrInfo &TII);
-
   bool runOnMachineFunction(MachineFunction &MF) override;
+
+  static MFResult
+  legalizeMachineFunction(MachineFunction &MF, const LegalizerInfo &LI,
+                          ArrayRef<GISelChangeObserver *> AuxObservers,
+                          LostDebugLocObserver &LocObserver,
+                          MachineIRBuilder &MIRBuilder);
 };
 } // End namespace llvm.
 
diff --git a/linux-x64/clang/include/llvm/CodeGen/GlobalISel/LegalizerHelper.h b/linux-x64/clang/include/llvm/CodeGen/GlobalISel/LegalizerHelper.h
index e8cb65f..2e9c7d8 100644
--- a/linux-x64/clang/include/llvm/CodeGen/GlobalISel/LegalizerHelper.h
+++ b/linux-x64/clang/include/llvm/CodeGen/GlobalISel/LegalizerHelper.h
@@ -32,9 +32,23 @@
 class Legalizer;
 class MachineRegisterInfo;
 class GISelChangeObserver;
+class TargetLowering;
 
 class LegalizerHelper {
 public:
+  /// Expose MIRBuilder so clients can set their own RecordInsertInstruction
+  /// functions
+  MachineIRBuilder &MIRBuilder;
+
+  /// To keep track of changes made by the LegalizerHelper.
+  GISelChangeObserver &Observer;
+
+private:
+  MachineRegisterInfo &MRI;
+  const LegalizerInfo &LI;
+  const TargetLowering &TLI;
+
+public:
   enum LegalizeResult {
     /// Instruction was already legal and no change was made to the
     /// MachineFunction.
@@ -48,6 +62,10 @@
     UnableToLegalize,
   };
 
+  /// Expose LegalizerInfo so the clients can re-use.
+  const LegalizerInfo &getLegalizerInfo() const { return LI; }
+  const TargetLowering &getTargetLowering() const { return TLI; }
+
   LegalizerHelper(MachineFunction &MF, GISelChangeObserver &Observer,
                   MachineIRBuilder &B);
   LegalizerHelper(MachineFunction &MF, const LegalizerInfo &LI,
@@ -74,6 +92,9 @@
   /// precision, ignoring the unused bits).
   LegalizeResult widenScalar(MachineInstr &MI, unsigned TypeIdx, LLT WideTy);
 
+  /// Legalize an instruction by replacing the value type
+  LegalizeResult bitcast(MachineInstr &MI, unsigned TypeIdx, LLT Ty);
+
   /// Legalize an instruction by splitting it into simpler parts, hopefully
   /// understood by the target.
   LegalizeResult lower(MachineInstr &MI, unsigned TypeIdx, LLT Ty);
@@ -88,14 +109,13 @@
   LegalizeResult moreElementsVector(MachineInstr &MI, unsigned TypeIdx,
                                     LLT MoreTy);
 
-  /// Expose MIRBuilder so clients can set their own RecordInsertInstruction
-  /// functions
-  MachineIRBuilder &MIRBuilder;
+  /// Cast the given value to an LLT::scalar with an equivalent size. Returns
+  /// the register to use if an instruction was inserted. Returns the original
+  /// register if no coercion was necessary.
+  //
+  // This may also fail and return Register() if there is no legal way to cast.
+  Register coerceToScalar(Register Val);
 
-  /// Expose LegalizerInfo so the clients can re-use.
-  const LegalizerInfo &getLegalizerInfo() const { return LI; }
-
-private:
   /// Legalize a single operand \p OpIdx of the machine instruction \p MI as a
   /// Use by extending the operand's type to \p WideTy using the specified \p
   /// ExtOpcode for the extension instruction, and replacing the vreg of the
@@ -129,6 +149,19 @@
   /// original vector type, and replacing the vreg of the operand in place.
   void moreElementsVectorSrc(MachineInstr &MI, LLT MoreTy, unsigned OpIdx);
 
+  /// Legalize a single operand \p OpIdx of the machine instruction \p MI as a
+  /// use by inserting a G_BITCAST to \p CastTy
+  void bitcastSrc(MachineInstr &MI, LLT CastTy, unsigned OpIdx);
+
+  /// Legalize a single operand \p OpIdx of the machine instruction \p MI as a
+  /// def by inserting a G_BITCAST from \p CastTy
+  void bitcastDst(MachineInstr &MI, LLT CastTy, unsigned OpIdx);
+
+  /// Widen \p OrigReg to \p WideTy by merging to a wider type, padding with
+  /// G_IMPLICIT_DEF, and producing dead results.
+  Register widenWithUnmerge(LLT WideTy, Register OrigReg);
+
+private:
   LegalizeResult
   widenScalarMergeValues(MachineInstr &MI, unsigned TypeIdx, LLT WideTy);
   LegalizeResult
@@ -137,6 +170,8 @@
   widenScalarExtract(MachineInstr &MI, unsigned TypeIdx, LLT WideTy);
   LegalizeResult
   widenScalarInsert(MachineInstr &MI, unsigned TypeIdx, LLT WideTy);
+  LegalizeResult
+  widenScalarAddSubShlSat(MachineInstr &MI, unsigned TypeIdx, LLT WideTy);
 
   /// Helper function to split a wide generic register into bitwise blocks with
   /// the given Type (which implies the number of blocks needed). The generic
@@ -163,6 +198,44 @@
                    LLT PartTy, ArrayRef<Register> PartRegs,
                    LLT LeftoverTy = LLT(), ArrayRef<Register> LeftoverRegs = {});
 
+  /// Unmerge \p SrcReg into smaller sized values, and append them to \p
+  /// Parts. The elements of \p Parts will be the greatest common divisor type
+  /// of \p DstTy, \p NarrowTy and the type of \p SrcReg. This will compute and
+  /// return the GCD type.
+  LLT extractGCDType(SmallVectorImpl<Register> &Parts, LLT DstTy,
+                     LLT NarrowTy, Register SrcReg);
+
+  /// Unmerge \p SrcReg into \p GCDTy typed registers. This will append all of
+  /// the unpacked registers to \p Parts. This version is if the common unmerge
+  /// type is already known.
+  void extractGCDType(SmallVectorImpl<Register> &Parts, LLT GCDTy,
+                      Register SrcReg);
+
+  /// Produce a merge of values in \p VRegs to define \p DstReg. Perform a merge
+  /// from the least common multiple type, and convert as appropriate to \p
+  /// DstReg.
+  ///
+  /// \p VRegs should each have type \p GCDTy. This type should be greatest
+  /// common divisor type of \p DstReg, \p NarrowTy, and an undetermined source
+  /// type.
+  ///
+  /// \p NarrowTy is the desired result merge source type. If the source value
+  /// needs to be widened to evenly cover \p DstReg, inserts high bits
+  /// corresponding to the extension opcode \p PadStrategy.
+  ///
+  /// \p VRegs will be cleared, and the the result \p NarrowTy register pieces
+  /// will replace it. Returns The complete LCMTy that \p VRegs will cover when
+  /// merged.
+  LLT buildLCMMergePieces(LLT DstTy, LLT NarrowTy, LLT GCDTy,
+                          SmallVectorImpl<Register> &VRegs,
+                          unsigned PadStrategy = TargetOpcode::G_ANYEXT);
+
+  /// Merge the values in \p RemergeRegs to an \p LCMTy typed value. Extract the
+  /// low bits into \p DstReg. This is intended to use the outputs from
+  /// buildLCMMergePieces after processing.
+  void buildWidenedRemergeToDst(Register DstReg, LLT LCMTy,
+                                ArrayRef<Register> RemergeRegs);
+
   /// Perform generic multiplication of values held in multiple registers.
   /// Generated instructions use only types NarrowTy and i1.
   /// Destination can be same or two times size of the source.
@@ -170,14 +243,26 @@
                          ArrayRef<Register> Src1Regs,
                          ArrayRef<Register> Src2Regs, LLT NarrowTy);
 
+  void changeOpcode(MachineInstr &MI, unsigned NewOpcode);
+
+public:
+  /// Return the alignment to use for a stack temporary object with the given
+  /// type.
+  Align getStackTemporaryAlignment(LLT Type, Align MinAlign = Align()) const;
+
+  /// Create a stack temporary based on the size in bytes and the alignment
+  MachineInstrBuilder createStackTemporary(TypeSize Bytes, Align Alignment,
+                                           MachinePointerInfo &PtrInfo);
+
+  /// Get a pointer to vector element \p Index located in memory for a vector of
+  /// type \p VecTy starting at a base address of \p VecPtr. If \p Index is out
+  /// of bounds the returned pointer is unspecified, but will be within the
+  /// vector bounds.
+  Register getVectorElementPointer(Register VecPtr, LLT VecTy, Register Index);
+
   LegalizeResult fewerElementsVectorImplicitDef(MachineInstr &MI,
                                                 unsigned TypeIdx, LLT NarrowTy);
 
-  /// Legalize a simple vector instruction where all operands are the same type
-  /// by splitting into multiple components.
-  LegalizeResult fewerElementsVectorBasic(MachineInstr &MI, unsigned TypeIdx,
-                                          LLT NarrowTy);
-
   /// Legalize a instruction with a vector type where each operand may have a
   /// different element type. All type indexes must have the same number of
   /// elements.
@@ -199,9 +284,31 @@
   LegalizeResult moreElementsVectorPhi(MachineInstr &MI, unsigned TypeIdx,
                                        LLT MoreTy);
 
+  LegalizeResult fewerElementsVectorUnmergeValues(MachineInstr &MI,
+                                                  unsigned TypeIdx,
+                                                  LLT NarrowTy);
+  LegalizeResult fewerElementsVectorMerge(MachineInstr &MI, unsigned TypeIdx,
+                                          LLT NarrowTy);
+  LegalizeResult fewerElementsVectorExtractInsertVectorElt(MachineInstr &MI,
+                                                           unsigned TypeIdx,
+                                                           LLT NarrowTy);
+
   LegalizeResult
   reduceLoadStoreWidth(MachineInstr &MI, unsigned TypeIdx, LLT NarrowTy);
 
+  /// Legalize an instruction by reducing the operation width, either by
+  /// narrowing the type of the operation or by reducing the number of elements
+  /// of a vector.
+  /// The used strategy (narrow vs. fewerElements) is decided by \p NarrowTy.
+  /// Narrow is used if the scalar type of \p NarrowTy and \p DstTy differ,
+  /// fewerElements is used when the scalar type is the same but the number of
+  /// elements between \p NarrowTy and \p DstTy differ.
+  LegalizeResult reduceOperationWidth(MachineInstr &MI, unsigned TypeIdx,
+                                      LLT NarrowTy);
+
+  LegalizeResult fewerElementsVectorSextInReg(MachineInstr &MI, unsigned TypeIdx,
+                                              LLT NarrowTy);
+
   LegalizeResult narrowScalarShiftByConstant(MachineInstr &MI, const APInt &Amt,
                                              LLT HalfTy, LLT ShiftAmtTy);
 
@@ -211,28 +318,78 @@
   LegalizeResult narrowScalarInsert(MachineInstr &MI, unsigned TypeIdx, LLT Ty);
 
   LegalizeResult narrowScalarBasic(MachineInstr &MI, unsigned TypeIdx, LLT Ty);
+  LegalizeResult narrowScalarExt(MachineInstr &MI, unsigned TypeIdx, LLT Ty);
   LegalizeResult narrowScalarSelect(MachineInstr &MI, unsigned TypeIdx, LLT Ty);
+  LegalizeResult narrowScalarCTLZ(MachineInstr &MI, unsigned TypeIdx, LLT Ty);
+  LegalizeResult narrowScalarCTTZ(MachineInstr &MI, unsigned TypeIdx, LLT Ty);
+  LegalizeResult narrowScalarCTPOP(MachineInstr &MI, unsigned TypeIdx, LLT Ty);
 
-  LegalizeResult lowerBitCount(MachineInstr &MI, unsigned TypeIdx, LLT Ty);
+  /// Perform Bitcast legalize action on G_EXTRACT_VECTOR_ELT.
+  LegalizeResult bitcastExtractVectorElt(MachineInstr &MI, unsigned TypeIdx,
+                                         LLT CastTy);
+
+  /// Perform Bitcast legalize action on G_INSERT_VECTOR_ELT.
+  LegalizeResult bitcastInsertVectorElt(MachineInstr &MI, unsigned TypeIdx,
+                                        LLT CastTy);
+
+  LegalizeResult lowerBitcast(MachineInstr &MI);
+  LegalizeResult lowerLoad(MachineInstr &MI);
+  LegalizeResult lowerStore(MachineInstr &MI);
+  LegalizeResult lowerBitCount(MachineInstr &MI);
 
   LegalizeResult lowerU64ToF32BitOps(MachineInstr &MI);
-  LegalizeResult lowerUITOFP(MachineInstr &MI, unsigned TypeIdx, LLT Ty);
-  LegalizeResult lowerSITOFP(MachineInstr &MI, unsigned TypeIdx, LLT Ty);
-  LegalizeResult lowerMinMax(MachineInstr &MI, unsigned TypeIdx, LLT Ty);
-  LegalizeResult lowerFCopySign(MachineInstr &MI, unsigned TypeIdx, LLT Ty);
+  LegalizeResult lowerUITOFP(MachineInstr &MI);
+  LegalizeResult lowerSITOFP(MachineInstr &MI);
+  LegalizeResult lowerFPTOUI(MachineInstr &MI);
+  LegalizeResult lowerFPTOSI(MachineInstr &MI);
 
-  MachineRegisterInfo &MRI;
-  const LegalizerInfo &LI;
-  /// To keep track of changes made by the LegalizerHelper.
-  GISelChangeObserver &Observer;
+  LegalizeResult lowerFPTRUNC_F64_TO_F16(MachineInstr &MI);
+  LegalizeResult lowerFPTRUNC(MachineInstr &MI);
+  LegalizeResult lowerFPOWI(MachineInstr &MI);
+
+  LegalizeResult lowerMinMax(MachineInstr &MI);
+  LegalizeResult lowerFCopySign(MachineInstr &MI);
+  LegalizeResult lowerFMinNumMaxNum(MachineInstr &MI);
+  LegalizeResult lowerFMad(MachineInstr &MI);
+  LegalizeResult lowerIntrinsicRound(MachineInstr &MI);
+  LegalizeResult lowerFFloor(MachineInstr &MI);
+  LegalizeResult lowerMergeValues(MachineInstr &MI);
+  LegalizeResult lowerUnmergeValues(MachineInstr &MI);
+  LegalizeResult lowerExtractInsertVectorElt(MachineInstr &MI);
+  LegalizeResult lowerShuffleVector(MachineInstr &MI);
+  LegalizeResult lowerDynStackAlloc(MachineInstr &MI);
+  LegalizeResult lowerExtract(MachineInstr &MI);
+  LegalizeResult lowerInsert(MachineInstr &MI);
+  LegalizeResult lowerSADDO_SSUBO(MachineInstr &MI);
+  LegalizeResult lowerAddSubSatToMinMax(MachineInstr &MI);
+  LegalizeResult lowerAddSubSatToAddoSubo(MachineInstr &MI);
+  LegalizeResult lowerShlSat(MachineInstr &MI);
+  LegalizeResult lowerBswap(MachineInstr &MI);
+  LegalizeResult lowerBitreverse(MachineInstr &MI);
+  LegalizeResult lowerReadWriteRegister(MachineInstr &MI);
+  LegalizeResult lowerSMULH_UMULH(MachineInstr &MI);
+  LegalizeResult lowerSelect(MachineInstr &MI);
+
 };
 
+/// Helper function that creates a libcall to the given \p Name using the given
+/// calling convention \p CC.
+LegalizerHelper::LegalizeResult
+createLibcall(MachineIRBuilder &MIRBuilder, const char *Name,
+              const CallLowering::ArgInfo &Result,
+              ArrayRef<CallLowering::ArgInfo> Args, CallingConv::ID CC);
+
 /// Helper function that creates the given libcall.
 LegalizerHelper::LegalizeResult
 createLibcall(MachineIRBuilder &MIRBuilder, RTLIB::Libcall Libcall,
               const CallLowering::ArgInfo &Result,
               ArrayRef<CallLowering::ArgInfo> Args);
 
+/// Create a libcall to memcpy et al.
+LegalizerHelper::LegalizeResult createMemLibcall(MachineIRBuilder &MIRBuilder,
+                                                 MachineRegisterInfo &MRI,
+                                                 MachineInstr &MI);
+
 } // End namespace llvm.
 
 #endif
diff --git a/linux-x64/clang/include/llvm/CodeGen/GlobalISel/LegalizerInfo.h b/linux-x64/clang/include/llvm/CodeGen/GlobalISel/LegalizerInfo.h
index 513c98f..c8a54b8 100644
--- a/linux-x64/clang/include/llvm/CodeGen/GlobalISel/LegalizerInfo.h
+++ b/linux-x64/clang/include/llvm/CodeGen/GlobalISel/LegalizerInfo.h
@@ -22,8 +22,9 @@
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/CodeGen/TargetOpcodes.h"
-#include "llvm/Support/raw_ostream.h"
+#include "llvm/Support/CommandLine.h"
 #include "llvm/Support/LowLevelTypeImpl.h"
+#include "llvm/Support/raw_ostream.h"
 #include <cassert>
 #include <cstdint>
 #include <tuple>
@@ -34,6 +35,7 @@
 
 extern cl::opt<bool> DisableGISelLegalityCheck;
 
+class LegalizerHelper;
 class MachineInstr;
 class MachineIRBuilder;
 class MachineRegisterInfo;
@@ -67,6 +69,9 @@
   /// the first two results.
   MoreElements,
 
+  /// Perform the operation on a different, but equivalently sized type.
+  Bitcast,
+
   /// The operation itself must be expressed in terms of simpler actions on
   /// this target. E.g. a SREM replaced by an SDIV and subtraction.
   Lower,
@@ -152,7 +157,7 @@
   LLT NewType;
 
   LegalizeActionStep(LegalizeAction Action, unsigned TypeIdx,
-                     const LLT &NewType)
+                     const LLT NewType)
       : Action(Action), TypeIdx(TypeIdx), NewType(NewType) {}
 
   bool operator==(const LegalizeActionStep &RHS) const {
@@ -178,7 +183,7 @@
            MemSize == Other.MemSize;
   }
 
-  /// \returns true if this memory access is legal with for the acecss described
+  /// \returns true if this memory access is legal with for the access described
   /// by \p Other (The alignment is sufficient for the size and result type).
   bool isCompatible(const TypePairAndMemDesc &Other) const {
     return Type0 == Other.Type0 && Type1 == Other.Type1 &&
@@ -199,11 +204,33 @@
 Predicate all(Predicate P0, Predicate P1, Args... args) {
   return all(all(P0, P1), args...);
 }
-/// True iff the given type index is the specified types.
+
+/// True iff P0 or P1 are true.
+template<typename Predicate>
+Predicate any(Predicate P0, Predicate P1) {
+  return [=](const LegalityQuery &Query) {
+    return P0(Query) || P1(Query);
+  };
+}
+/// True iff any given predicates are true.
+template<typename Predicate, typename... Args>
+Predicate any(Predicate P0, Predicate P1, Args... args) {
+  return any(any(P0, P1), args...);
+}
+
+/// True iff the given type index is the specified type.
 LegalityPredicate typeIs(unsigned TypeIdx, LLT TypesInit);
 /// True iff the given type index is one of the specified types.
 LegalityPredicate typeInSet(unsigned TypeIdx,
                             std::initializer_list<LLT> TypesInit);
+
+/// True iff the given type index is not the specified type.
+inline LegalityPredicate typeIsNot(unsigned TypeIdx, LLT Type) {
+  return [=](const LegalityQuery &Query) {
+           return Query.Types[TypeIdx] != Type;
+         };
+}
+
 /// True iff the given types for the given pair of type indexes is one of the
 /// specified type pairs.
 LegalityPredicate
@@ -224,13 +251,16 @@
 /// space.
 LegalityPredicate isPointer(unsigned TypeIdx, unsigned AddrSpace);
 
+/// True if the type index is a vector with element type \p EltTy
+LegalityPredicate elementTypeIs(unsigned TypeIdx, LLT EltTy);
+
 /// True iff the specified type index is a scalar that's narrower than the given
 /// size.
-LegalityPredicate narrowerThan(unsigned TypeIdx, unsigned Size);
+LegalityPredicate scalarNarrowerThan(unsigned TypeIdx, unsigned Size);
 
 /// True iff the specified type index is a scalar that's wider than the given
 /// size.
-LegalityPredicate widerThan(unsigned TypeIdx, unsigned Size);
+LegalityPredicate scalarWiderThan(unsigned TypeIdx, unsigned Size);
 
 /// True iff the specified type index is a scalar or vector with an element type
 /// that's narrower than the given size.
@@ -248,8 +278,20 @@
 /// is not a power of 2.
 LegalityPredicate scalarOrEltSizeNotPow2(unsigned TypeIdx);
 
+/// True if the total bitwidth of the specified type index is \p Size bits.
+LegalityPredicate sizeIs(unsigned TypeIdx, unsigned Size);
+
 /// True iff the specified type indices are both the same bit size.
 LegalityPredicate sameSize(unsigned TypeIdx0, unsigned TypeIdx1);
+
+/// True iff the first type index has a larger total bit size than second type
+/// index.
+LegalityPredicate largerThan(unsigned TypeIdx0, unsigned TypeIdx1);
+
+/// True iff the first type index has a smaller total bit size than second type
+/// index.
+LegalityPredicate smallerThan(unsigned TypeIdx0, unsigned TypeIdx1);
+
 /// True iff the specified MMO index has a size that is not a power of 2
 LegalityPredicate memSizeInBytesNotPow2(unsigned MMOIdx);
 /// True iff the specified type index is a vector whose element count is not a
@@ -274,6 +316,11 @@
 /// Keep the same scalar or element type as the given type.
 LegalizeMutation changeElementTo(unsigned TypeIdx, LLT Ty);
 
+/// Change the scalar size or element size to have the same scalar size as type
+/// index \p FromIndex. Unlike changeElementTo, this discards pointer types and
+/// only changes the size.
+LegalizeMutation changeElementSizeTo(unsigned TypeIdx, unsigned FromTypeIdx);
+
 /// Widen the scalar type or vector element type for the given type index to the
 /// next power of 2.
 LegalizeMutation widenScalarOrEltToNextPow2(unsigned TypeIdx, unsigned Min = 0);
@@ -331,6 +378,8 @@
   /// individually handled.
   SmallBitVector TypeIdxsCovered{MCOI::OPERAND_LAST_GENERIC -
                                  MCOI::OPERAND_FIRST_GENERIC + 2};
+  SmallBitVector ImmIdxsCovered{MCOI::OPERAND_LAST_GENERIC_IMM -
+                                MCOI::OPERAND_FIRST_GENERIC_IMM + 2};
 #endif
 
   unsigned typeIdx(unsigned TypeIdx) {
@@ -342,9 +391,21 @@
 #endif
     return TypeIdx;
   }
-  void markAllTypeIdxsAsCovered() {
+
+  unsigned immIdx(unsigned ImmIdx) {
+    assert(ImmIdx <= (MCOI::OPERAND_LAST_GENERIC_IMM -
+                      MCOI::OPERAND_FIRST_GENERIC_IMM) &&
+           "Imm Index is out of bounds");
+#ifndef NDEBUG
+    ImmIdxsCovered.set(ImmIdx);
+#endif
+    return ImmIdx;
+  }
+
+  void markAllIdxsAsCovered() {
 #ifndef NDEBUG
     TypeIdxsCovered.set();
+    ImmIdxsCovered.set();
 #endif
   }
 
@@ -403,6 +464,23 @@
     return actionIf(Action, typePairInSet(typeIdx(0), typeIdx(1), Types),
                     Mutation);
   }
+  /// Use the given action when type index 0 is any type in the given list and
+  /// imm index 0 is anything. Action should not be an action that requires
+  /// mutation.
+  LegalizeRuleSet &actionForTypeWithAnyImm(LegalizeAction Action,
+                                           std::initializer_list<LLT> Types) {
+    using namespace LegalityPredicates;
+    immIdx(0); // Inform verifier imm idx 0 is handled.
+    return actionIf(Action, typeInSet(typeIdx(0), Types));
+  }
+
+  LegalizeRuleSet &actionForTypeWithAnyImm(
+    LegalizeAction Action, std::initializer_list<std::pair<LLT, LLT>> Types) {
+    using namespace LegalityPredicates;
+    immIdx(0); // Inform verifier imm idx 0 is handled.
+    return actionIf(Action, typePairInSet(typeIdx(0), typeIdx(1), Types));
+  }
+
   /// Use the given action when type indexes 0 and 1 are both in the given list.
   /// That is, the type pair is in the cartesian product of the list.
   /// Action should not be an action that requires mutation.
@@ -454,7 +532,7 @@
   LegalizeRuleSet &legalIf(LegalityPredicate Predicate) {
     // We have no choice but conservatively assume that the free-form
     // user-provided Predicate properly handles all type indices:
-    markAllTypeIdxsAsCovered();
+    markAllIdxsAsCovered();
     return actionIf(LegalizeAction::Legal, Predicate);
   }
   /// The instruction is legal when type index 0 is any type in the given list.
@@ -466,6 +544,19 @@
   LegalizeRuleSet &legalFor(std::initializer_list<std::pair<LLT, LLT>> Types) {
     return actionFor(LegalizeAction::Legal, Types);
   }
+  /// The instruction is legal when type index 0 is any type in the given list
+  /// and imm index 0 is anything.
+  LegalizeRuleSet &legalForTypeWithAnyImm(std::initializer_list<LLT> Types) {
+    markAllIdxsAsCovered();
+    return actionForTypeWithAnyImm(LegalizeAction::Legal, Types);
+  }
+
+  LegalizeRuleSet &legalForTypeWithAnyImm(
+    std::initializer_list<std::pair<LLT, LLT>> Types) {
+    markAllIdxsAsCovered();
+    return actionForTypeWithAnyImm(LegalizeAction::Legal, Types);
+  }
+
   /// The instruction is legal when type indexes 0 and 1 along with the memory
   /// size and minimum alignment is any type and size tuple in the given list.
   LegalizeRuleSet &legalForTypesWithMemDesc(
@@ -497,16 +588,25 @@
 
   LegalizeRuleSet &alwaysLegal() {
     using namespace LegalizeMutations;
-    markAllTypeIdxsAsCovered();
+    markAllIdxsAsCovered();
     return actionIf(LegalizeAction::Legal, always);
   }
 
+  /// The specified type index is coerced if predicate is true.
+  LegalizeRuleSet &bitcastIf(LegalityPredicate Predicate,
+                             LegalizeMutation Mutation) {
+    // We have no choice but conservatively assume that lowering with a
+    // free-form user provided Predicate properly handles all type indices:
+    markAllIdxsAsCovered();
+    return actionIf(LegalizeAction::Bitcast, Predicate, Mutation);
+  }
+
   /// The instruction is lowered.
   LegalizeRuleSet &lower() {
     using namespace LegalizeMutations;
     // We have no choice but conservatively assume that predicate-less lowering
     // properly handles all type indices by design:
-    markAllTypeIdxsAsCovered();
+    markAllIdxsAsCovered();
     return actionIf(LegalizeAction::Lower, always);
   }
   /// The instruction is lowered if predicate is true. Keep type index 0 as the
@@ -515,7 +615,7 @@
     using namespace LegalizeMutations;
     // We have no choice but conservatively assume that lowering with a
     // free-form user provided Predicate properly handles all type indices:
-    markAllTypeIdxsAsCovered();
+    markAllIdxsAsCovered();
     return actionIf(LegalizeAction::Lower, Predicate);
   }
   /// The instruction is lowered if predicate is true.
@@ -523,14 +623,13 @@
                            LegalizeMutation Mutation) {
     // We have no choice but conservatively assume that lowering with a
     // free-form user provided Predicate properly handles all type indices:
-    markAllTypeIdxsAsCovered();
+    markAllIdxsAsCovered();
     return actionIf(LegalizeAction::Lower, Predicate, Mutation);
   }
   /// The instruction is lowered when type index 0 is any type in the given
   /// list. Keep type index 0 as the same type.
   LegalizeRuleSet &lowerFor(std::initializer_list<LLT> Types) {
-    return actionFor(LegalizeAction::Lower, Types,
-                     LegalizeMutations::changeTo(0, 0));
+    return actionFor(LegalizeAction::Lower, Types);
   }
   /// The instruction is lowered when type index 0 is any type in the given
   /// list.
@@ -541,8 +640,7 @@
   /// The instruction is lowered when type indexes 0 and 1 is any type pair in
   /// the given list. Keep type index 0 as the same type.
   LegalizeRuleSet &lowerFor(std::initializer_list<std::pair<LLT, LLT>> Types) {
-    return actionFor(LegalizeAction::Lower, Types,
-                     LegalizeMutations::changeTo(0, 0));
+    return actionFor(LegalizeAction::Lower, Types);
   }
   /// The instruction is lowered when type indexes 0 and 1 is any type pair in
   /// the given list.
@@ -567,11 +665,20 @@
                                      Types2);
   }
 
+  /// The instruction is emitted as a library call.
+  LegalizeRuleSet &libcall() {
+    using namespace LegalizeMutations;
+    // We have no choice but conservatively assume that predicate-less lowering
+    // properly handles all type indices by design:
+    markAllIdxsAsCovered();
+    return actionIf(LegalizeAction::Libcall, always);
+  }
+
   /// Like legalIf, but for the Libcall action.
   LegalizeRuleSet &libcallIf(LegalityPredicate Predicate) {
     // We have no choice but conservatively assume that a libcall with a
     // free-form user provided Predicate properly handles all type indices:
-    markAllTypeIdxsAsCovered();
+    markAllIdxsAsCovered();
     return actionIf(LegalizeAction::Libcall, Predicate);
   }
   LegalizeRuleSet &libcallFor(std::initializer_list<LLT> Types) {
@@ -597,7 +704,7 @@
                                  LegalizeMutation Mutation) {
     // We have no choice but conservatively assume that an action with a
     // free-form user provided Predicate properly handles all type indices:
-    markAllTypeIdxsAsCovered();
+    markAllIdxsAsCovered();
     return actionIf(LegalizeAction::WidenScalar, Predicate, Mutation);
   }
   /// Narrow the scalar to the one selected by the mutation if the predicate is
@@ -606,9 +713,16 @@
                                   LegalizeMutation Mutation) {
     // We have no choice but conservatively assume that an action with a
     // free-form user provided Predicate properly handles all type indices:
-    markAllTypeIdxsAsCovered();
+    markAllIdxsAsCovered();
     return actionIf(LegalizeAction::NarrowScalar, Predicate, Mutation);
   }
+  /// Narrow the scalar, specified in mutation, when type indexes 0 and 1 is any
+  /// type pair in the given list.
+  LegalizeRuleSet &
+  narrowScalarFor(std::initializer_list<std::pair<LLT, LLT>> Types,
+                  LegalizeMutation Mutation) {
+    return actionFor(LegalizeAction::NarrowScalar, Types, Mutation);
+  }
 
   /// Add more elements to reach the type selected by the mutation if the
   /// predicate is true.
@@ -616,7 +730,7 @@
                                   LegalizeMutation Mutation) {
     // We have no choice but conservatively assume that an action with a
     // free-form user provided Predicate properly handles all type indices:
-    markAllTypeIdxsAsCovered();
+    markAllIdxsAsCovered();
     return actionIf(LegalizeAction::MoreElements, Predicate, Mutation);
   }
   /// Remove elements to reach the type selected by the mutation if the
@@ -625,26 +739,36 @@
                                    LegalizeMutation Mutation) {
     // We have no choice but conservatively assume that an action with a
     // free-form user provided Predicate properly handles all type indices:
-    markAllTypeIdxsAsCovered();
+    markAllIdxsAsCovered();
     return actionIf(LegalizeAction::FewerElements, Predicate, Mutation);
   }
 
   /// The instruction is unsupported.
   LegalizeRuleSet &unsupported() {
+    markAllIdxsAsCovered();
     return actionIf(LegalizeAction::Unsupported, always);
   }
   LegalizeRuleSet &unsupportedIf(LegalityPredicate Predicate) {
     return actionIf(LegalizeAction::Unsupported, Predicate);
   }
+
+  LegalizeRuleSet &unsupportedFor(std::initializer_list<LLT> Types) {
+    return actionFor(LegalizeAction::Unsupported, Types);
+  }
+
   LegalizeRuleSet &unsupportedIfMemSizeNotPow2() {
     return actionIf(LegalizeAction::Unsupported,
                     LegalityPredicates::memSizeInBytesNotPow2(0));
   }
+  LegalizeRuleSet &lowerIfMemSizeNotPow2() {
+    return actionIf(LegalizeAction::Lower,
+                    LegalityPredicates::memSizeInBytesNotPow2(0));
+  }
 
   LegalizeRuleSet &customIf(LegalityPredicate Predicate) {
     // We have no choice but conservatively assume that a custom action with a
     // free-form user provided Predicate properly handles all type indices:
-    markAllTypeIdxsAsCovered();
+    markAllIdxsAsCovered();
     return actionIf(LegalizeAction::Custom, Predicate);
   }
   LegalizeRuleSet &customFor(std::initializer_list<LLT> Types) {
@@ -703,8 +827,15 @@
                     LegalizeMutations::scalarize(TypeIdx));
   }
 
+  LegalizeRuleSet &scalarizeIf(LegalityPredicate Predicate, unsigned TypeIdx) {
+    using namespace LegalityPredicates;
+    return actionIf(LegalizeAction::FewerElements,
+                    all(Predicate, isVector(typeIdx(TypeIdx))),
+                    LegalizeMutations::scalarize(TypeIdx));
+  }
+
   /// Ensure the scalar or element is at least as wide as Ty.
-  LegalizeRuleSet &minScalarOrElt(unsigned TypeIdx, const LLT &Ty) {
+  LegalizeRuleSet &minScalarOrElt(unsigned TypeIdx, const LLT Ty) {
     using namespace LegalityPredicates;
     using namespace LegalizeMutations;
     return actionIf(LegalizeAction::WidenScalar,
@@ -714,7 +845,7 @@
 
   /// Ensure the scalar or element is at least as wide as Ty.
   LegalizeRuleSet &minScalarOrEltIf(LegalityPredicate Predicate,
-                                    unsigned TypeIdx, const LLT &Ty) {
+                                    unsigned TypeIdx, const LLT Ty) {
     using namespace LegalityPredicates;
     using namespace LegalizeMutations;
     return actionIf(LegalizeAction::WidenScalar,
@@ -724,16 +855,16 @@
   }
 
   /// Ensure the scalar is at least as wide as Ty.
-  LegalizeRuleSet &minScalar(unsigned TypeIdx, const LLT &Ty) {
+  LegalizeRuleSet &minScalar(unsigned TypeIdx, const LLT Ty) {
     using namespace LegalityPredicates;
     using namespace LegalizeMutations;
     return actionIf(LegalizeAction::WidenScalar,
-                    narrowerThan(TypeIdx, Ty.getSizeInBits()),
+                    scalarNarrowerThan(TypeIdx, Ty.getSizeInBits()),
                     changeTo(typeIdx(TypeIdx), Ty));
   }
 
   /// Ensure the scalar is at most as wide as Ty.
-  LegalizeRuleSet &maxScalarOrElt(unsigned TypeIdx, const LLT &Ty) {
+  LegalizeRuleSet &maxScalarOrElt(unsigned TypeIdx, const LLT Ty) {
     using namespace LegalityPredicates;
     using namespace LegalizeMutations;
     return actionIf(LegalizeAction::NarrowScalar,
@@ -742,11 +873,11 @@
   }
 
   /// Ensure the scalar is at most as wide as Ty.
-  LegalizeRuleSet &maxScalar(unsigned TypeIdx, const LLT &Ty) {
+  LegalizeRuleSet &maxScalar(unsigned TypeIdx, const LLT Ty) {
     using namespace LegalityPredicates;
     using namespace LegalizeMutations;
     return actionIf(LegalizeAction::NarrowScalar,
-                    widerThan(TypeIdx, Ty.getSizeInBits()),
+                    scalarWiderThan(TypeIdx, Ty.getSizeInBits()),
                     changeTo(typeIdx(TypeIdx), Ty));
   }
 
@@ -754,27 +885,30 @@
   /// For example, when the maximum size of one type depends on the size of
   /// another such as extracting N bits from an M bit container.
   LegalizeRuleSet &maxScalarIf(LegalityPredicate Predicate, unsigned TypeIdx,
-                               const LLT &Ty) {
+                               const LLT Ty) {
     using namespace LegalityPredicates;
     using namespace LegalizeMutations;
     return actionIf(
         LegalizeAction::NarrowScalar,
         [=](const LegalityQuery &Query) {
-          return widerThan(TypeIdx, Ty.getSizeInBits()) && Predicate(Query);
+          const LLT QueryTy = Query.Types[TypeIdx];
+          return QueryTy.isScalar() &&
+                 QueryTy.getSizeInBits() > Ty.getSizeInBits() &&
+                 Predicate(Query);
         },
         changeElementTo(typeIdx(TypeIdx), Ty));
   }
 
   /// Limit the range of scalar sizes to MinTy and MaxTy.
-  LegalizeRuleSet &clampScalar(unsigned TypeIdx, const LLT &MinTy,
-                               const LLT &MaxTy) {
+  LegalizeRuleSet &clampScalar(unsigned TypeIdx, const LLT MinTy,
+                               const LLT MaxTy) {
     assert(MinTy.isScalar() && MaxTy.isScalar() && "Expected scalar types");
     return minScalar(TypeIdx, MinTy).maxScalar(TypeIdx, MaxTy);
   }
 
   /// Limit the range of scalar sizes to MinTy and MaxTy.
-  LegalizeRuleSet &clampScalarOrElt(unsigned TypeIdx, const LLT &MinTy,
-                                    const LLT &MaxTy) {
+  LegalizeRuleSet &clampScalarOrElt(unsigned TypeIdx, const LLT MinTy,
+                                    const LLT MaxTy) {
     return minScalarOrElt(TypeIdx, MinTy).maxScalarOrElt(TypeIdx, MaxTy);
   }
 
@@ -786,11 +920,25 @@
           return Query.Types[LargeTypeIdx].getScalarSizeInBits() >
                  Query.Types[TypeIdx].getSizeInBits();
         },
+        LegalizeMutations::changeElementSizeTo(TypeIdx, LargeTypeIdx));
+  }
+
+  /// Narrow the scalar to match the size of another.
+  LegalizeRuleSet &maxScalarSameAs(unsigned TypeIdx, unsigned NarrowTypeIdx) {
+    typeIdx(TypeIdx);
+    return narrowScalarIf(
         [=](const LegalityQuery &Query) {
-          LLT T = Query.Types[LargeTypeIdx];
-          return std::make_pair(TypeIdx,
-                                T.isVector() ? T.getElementType() : T);
-        });
+          return Query.Types[NarrowTypeIdx].getScalarSizeInBits() <
+                 Query.Types[TypeIdx].getSizeInBits();
+        },
+        LegalizeMutations::changeElementSizeTo(TypeIdx, NarrowTypeIdx));
+  }
+
+  /// Change the type \p TypeIdx to have the same scalar size as type \p
+  /// SameSizeIdx.
+  LegalizeRuleSet &scalarSameSizeAs(unsigned TypeIdx, unsigned SameSizeIdx) {
+    return minScalarSameAs(TypeIdx, SameSizeIdx)
+          .maxScalarSameAs(TypeIdx, SameSizeIdx);
   }
 
   /// Conditionally widen the scalar or elt to match the size of another.
@@ -820,7 +968,7 @@
   }
 
   /// Limit the number of elements in EltTy vectors to at least MinElements.
-  LegalizeRuleSet &clampMinNumElements(unsigned TypeIdx, const LLT &EltTy,
+  LegalizeRuleSet &clampMinNumElements(unsigned TypeIdx, const LLT EltTy,
                                        unsigned MinElements) {
     // Mark the type index as covered:
     typeIdx(TypeIdx);
@@ -838,7 +986,7 @@
         });
   }
   /// Limit the number of elements in EltTy vectors to at most MaxElements.
-  LegalizeRuleSet &clampMaxNumElements(unsigned TypeIdx, const LLT &EltTy,
+  LegalizeRuleSet &clampMaxNumElements(unsigned TypeIdx, const LLT EltTy,
                                        unsigned MaxElements) {
     // Mark the type index as covered:
     typeIdx(TypeIdx);
@@ -861,12 +1009,12 @@
   /// No effect if the type is not a vector or does not have the same element
   /// type as the constraints.
   /// The element type of MinTy and MaxTy must match.
-  LegalizeRuleSet &clampNumElements(unsigned TypeIdx, const LLT &MinTy,
-                                    const LLT &MaxTy) {
+  LegalizeRuleSet &clampNumElements(unsigned TypeIdx, const LLT MinTy,
+                                    const LLT MaxTy) {
     assert(MinTy.getElementType() == MaxTy.getElementType() &&
            "Expected element types to agree");
 
-    const LLT &EltTy = MinTy.getElementType();
+    const LLT EltTy = MinTy.getElementType();
     return clampMinNumElements(TypeIdx, EltTy, MinTy.getNumElements())
         .clampMaxNumElements(TypeIdx, EltTy, MaxTy.getNumElements());
   }
@@ -882,6 +1030,10 @@
   /// LegalizeRuleSet in any way at all.
   /// \pre Type indices of the opcode form a dense [0, \p NumTypeIdxs) set.
   bool verifyTypeIdxsCoverage(unsigned NumTypeIdxs) const;
+  /// Check if there is no imm index which is obviously not handled by the
+  /// LegalizeRuleSet in any way at all.
+  /// \pre Type indices of the opcode form a dense [0, \p NumTypeIdxs) set.
+  bool verifyImmIdxsCoverage(unsigned NumImmIdxs) const;
 
   /// Apply the ruleset to the given LegalityQuery.
   LegalizeActionStep apply(const LegalityQuery &Query) const;
@@ -1106,18 +1258,36 @@
   bool isLegal(const LegalityQuery &Query) const {
     return getAction(Query).Action == LegalizeAction::Legal;
   }
+
+  bool isLegalOrCustom(const LegalityQuery &Query) const {
+    auto Action = getAction(Query).Action;
+    return Action == LegalizeAction::Legal || Action == LegalizeAction::Custom;
+  }
+
   bool isLegal(const MachineInstr &MI, const MachineRegisterInfo &MRI) const;
   bool isLegalOrCustom(const MachineInstr &MI,
                        const MachineRegisterInfo &MRI) const;
 
-  virtual bool legalizeCustom(MachineInstr &MI, MachineRegisterInfo &MRI,
-                              MachineIRBuilder &MIRBuilder,
-                              GISelChangeObserver &Observer) const;
+  /// Called for instructions with the Custom LegalizationAction.
+  virtual bool legalizeCustom(LegalizerHelper &Helper,
+                              MachineInstr &MI) const {
+    llvm_unreachable("must implement this if custom action is used");
+  }
 
+  /// \returns true if MI is either legal or has been legalized and false if not
+  /// legal.
   /// Return true if MI is either legal or has been legalized and false
   /// if not legal.
-  virtual bool legalizeIntrinsic(MachineInstr &MI, MachineRegisterInfo &MRI,
-                                 MachineIRBuilder &MIRBuilder) const;
+  virtual bool legalizeIntrinsic(LegalizerHelper &Helper,
+                                 MachineInstr &MI) const {
+    return true;
+  }
+
+  /// Return the opcode (SEXT/ZEXT/ANYEXT) that should be performed while
+  /// widening a constant of type SmallTy which targets can override.
+  /// For eg, the DAG does (SmallTy.isByteSized() ? G_SEXT : G_ZEXT) which
+  /// will be the default.
+  virtual unsigned getExtOpcodeForWideningConstant(LLT SmallTy) const;
 
 private:
   /// Determine what action should be taken to legalize the given generic
@@ -1141,7 +1311,7 @@
   ///            {65, NarrowScalar} // bit sizes [65, +inf[
   ///           });
   /// It may be that only 64-bit pointers are supported on your target:
-  /// setPointerAction(G_GEP, 0, LLT:pointer(1),
+  /// setPointerAction(G_PTR_ADD, 0, LLT:pointer(1),
   ///           {{1, Unsupported},  // bit sizes [ 1, 63[
   ///            {64, Legal},       // bit sizes [64, 65[
   ///            {65, Unsupported}, // bit sizes [65, +inf[
diff --git a/linux-x64/clang/include/llvm/CodeGen/GlobalISel/Localizer.h b/linux-x64/clang/include/llvm/CodeGen/GlobalISel/Localizer.h
index 06de580..57f6c03 100644
--- a/linux-x64/clang/include/llvm/CodeGen/GlobalISel/Localizer.h
+++ b/linux-x64/clang/include/llvm/CodeGen/GlobalISel/Localizer.h
@@ -42,15 +42,16 @@
   static char ID;
 
 private:
+  /// An input function to decide if the pass should run or not
+  /// on the given MachineFunction.
+  std::function<bool(const MachineFunction &)> DoNotRunPass;
+
   /// MRI contains all the register class/bank information that this
   /// pass uses and updates.
   MachineRegisterInfo *MRI;
   /// TTI used for getting remat costs for instructions.
   TargetTransformInfo *TTI;
 
-  /// Check whether or not \p MI needs to be moved close to its uses.
-  bool shouldLocalize(const MachineInstr &MI);
-
   /// Check if \p MOUse is used in the same basic block as \p Def.
   /// If the use is in the same block, we say it is local.
   /// When the use is not local, \p InsertMBB will contain the basic
@@ -72,14 +73,13 @@
 
 public:
   Localizer();
+  Localizer(std::function<bool(const MachineFunction &)>);
 
   StringRef getPassName() const override { return "Localizer"; }
 
   MachineFunctionProperties getRequiredProperties() const override {
     return MachineFunctionProperties()
-        .set(MachineFunctionProperties::Property::IsSSA)
-        .set(MachineFunctionProperties::Property::Legalized)
-        .set(MachineFunctionProperties::Property::RegBankSelected);
+        .set(MachineFunctionProperties::Property::IsSSA);
   }
 
   void getAnalysisUsage(AnalysisUsage &AU) const override;
diff --git a/linux-x64/clang/include/llvm/CodeGen/GlobalISel/LostDebugLocObserver.h b/linux-x64/clang/include/llvm/CodeGen/GlobalISel/LostDebugLocObserver.h
new file mode 100644
index 0000000..cd2a871
--- /dev/null
+++ b/linux-x64/clang/include/llvm/CodeGen/GlobalISel/LostDebugLocObserver.h
@@ -0,0 +1,50 @@
+//===----- llvm/CodeGen/GlobalISel/LostDebugLocObserver.h -------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+/// Tracks DebugLocs between checkpoints and verifies that they are transferred.
+//
+//===----------------------------------------------------------------------===//
+#ifndef LLVM_CODEGEN_GLOBALISEL_LOSTDEBUGLOCOBSERVER_H
+#define LLVM_CODEGEN_GLOBALISEL_LOSTDEBUGLOCOBSERVER_H
+
+#include "llvm/ADT/SmallSet.h"
+#include "llvm/CodeGen/GlobalISel/GISelChangeObserver.h"
+
+namespace llvm {
+class LostDebugLocObserver : public GISelChangeObserver {
+  StringRef DebugType;
+  SmallSet<DebugLoc, 4> LostDebugLocs;
+  SmallPtrSet<MachineInstr *, 4> PotentialMIsForDebugLocs;
+  unsigned NumLostDebugLocs = 0;
+
+public:
+  LostDebugLocObserver(StringRef DebugType) : DebugType(DebugType) {}
+
+  unsigned getNumLostDebugLocs() const { return NumLostDebugLocs; }
+
+  /// Call this to indicate that it's a good point to assess whether locations
+  /// have been lost. Typically this will be when a logical change has been
+  /// completed such as the caller has finished replacing some instructions with
+  /// alternatives. When CheckDebugLocs is true, the locations will be checked
+  /// to see if any have been lost since the last checkpoint. When
+  /// CheckDebugLocs is false, it will just reset ready for the next checkpoint
+  /// without checking anything. This can be helpful to limit the detection to
+  /// easy-to-fix portions of an algorithm before allowing more difficult ones.
+  void checkpoint(bool CheckDebugLocs = true);
+
+  void createdInstr(MachineInstr &MI) override;
+  void erasingInstr(MachineInstr &MI) override;
+  void changingInstr(MachineInstr &MI) override;
+  void changedInstr(MachineInstr &MI) override;
+
+private:
+  void analyzeDebugLocations();
+};
+
+} // namespace llvm
+#endif // ifndef LLVM_CODEGEN_GLOBALISEL_LOSTDEBUGLOCOBSERVER_H
diff --git a/linux-x64/clang/include/llvm/CodeGen/GlobalISel/MIPatternMatch.h b/linux-x64/clang/include/llvm/CodeGen/GlobalISel/MIPatternMatch.h
index 13eddd9..55d6d36 100644
--- a/linux-x64/clang/include/llvm/CodeGen/GlobalISel/MIPatternMatch.h
+++ b/linux-x64/clang/include/llvm/CodeGen/GlobalISel/MIPatternMatch.h
@@ -12,16 +12,15 @@
 #ifndef LLVM_GMIR_PATTERNMATCH_H
 #define LLVM_GMIR_PATTERNMATCH_H
 
-#include "llvm/ADT/APFloat.h"
-#include "llvm/ADT/APInt.h"
 #include "llvm/CodeGen/GlobalISel/Utils.h"
 #include "llvm/CodeGen/MachineRegisterInfo.h"
+#include "llvm/IR/InstrTypes.h"
 
 namespace llvm {
 namespace MIPatternMatch {
 
 template <typename Reg, typename Pattern>
-bool mi_match(Reg R, MachineRegisterInfo &MRI, Pattern &&P) {
+bool mi_match(Reg R, const MachineRegisterInfo &MRI, Pattern &&P) {
   return P.match(MRI, R);
 }
 
@@ -30,7 +29,7 @@
   SubPatternT SubPat;
   OneUse_match(const SubPatternT &SP) : SubPat(SP) {}
 
-  bool match(MachineRegisterInfo &MRI, unsigned Reg) {
+  bool match(const MachineRegisterInfo &MRI, Register Reg) {
     return MRI.hasOneUse(Reg) && SubPat.match(MRI, Reg);
   }
 };
@@ -40,11 +39,25 @@
   return SP;
 }
 
+template <typename SubPatternT> struct OneNonDBGUse_match {
+  SubPatternT SubPat;
+  OneNonDBGUse_match(const SubPatternT &SP) : SubPat(SP) {}
+
+  bool match(const MachineRegisterInfo &MRI, Register Reg) {
+    return MRI.hasOneNonDBGUse(Reg) && SubPat.match(MRI, Reg);
+  }
+};
+
+template <typename SubPat>
+inline OneNonDBGUse_match<SubPat> m_OneNonDBGUse(const SubPat &SP) {
+  return SP;
+}
+
 struct ConstantMatch {
   int64_t &CR;
   ConstantMatch(int64_t &C) : CR(C) {}
-  bool match(const MachineRegisterInfo &MRI, unsigned Reg) {
-    if (auto MaybeCst = getConstantVRegVal(Reg, MRI)) {
+  bool match(const MachineRegisterInfo &MRI, Register Reg) {
+    if (auto MaybeCst = getConstantVRegSExtVal(Reg, MRI)) {
       CR = *MaybeCst;
       return true;
     }
@@ -54,13 +67,36 @@
 
 inline ConstantMatch m_ICst(int64_t &Cst) { return ConstantMatch(Cst); }
 
+/// Matcher for a specific constant value.
+struct SpecificConstantMatch {
+  int64_t RequestedVal;
+  SpecificConstantMatch(int64_t RequestedVal) : RequestedVal(RequestedVal) {}
+  bool match(const MachineRegisterInfo &MRI, Register Reg) {
+    int64_t MatchedVal;
+    return mi_match(Reg, MRI, m_ICst(MatchedVal)) && MatchedVal == RequestedVal;
+  }
+};
+
+/// Matches a constant equal to \p RequestedValue.
+inline SpecificConstantMatch m_SpecificICst(int64_t RequestedValue) {
+  return SpecificConstantMatch(RequestedValue);
+}
+
+///{
+/// Convenience matchers for specific integer values.
+inline SpecificConstantMatch m_ZeroInt() { return SpecificConstantMatch(0); }
+inline SpecificConstantMatch m_AllOnesInt() {
+  return SpecificConstantMatch(-1);
+}
+///}
+
 // TODO: Rework this for different kinds of MachineOperand.
 // Currently assumes the Src for a match is a register.
 // We might want to support taking in some MachineOperands and call getReg on
 // that.
 
 struct operand_type_match {
-  bool match(const MachineRegisterInfo &MRI, unsigned Reg) { return true; }
+  bool match(const MachineRegisterInfo &MRI, Register Reg) { return true; }
   bool match(const MachineRegisterInfo &MRI, MachineOperand *MO) {
     return MO->isReg();
   }
@@ -71,7 +107,7 @@
 /// Matching combinators.
 template <typename... Preds> struct And {
   template <typename MatchSrc>
-  bool match(MachineRegisterInfo &MRI, MatchSrc &&src) {
+  bool match(const MachineRegisterInfo &MRI, MatchSrc &&src) {
     return true;
   }
 };
@@ -83,14 +119,14 @@
       : And<Preds...>(std::forward<Preds>(preds)...), P(std::forward<Pred>(p)) {
   }
   template <typename MatchSrc>
-  bool match(MachineRegisterInfo &MRI, MatchSrc &&src) {
+  bool match(const MachineRegisterInfo &MRI, MatchSrc &&src) {
     return P.match(MRI, src) && And<Preds...>::match(MRI, src);
   }
 };
 
 template <typename... Preds> struct Or {
   template <typename MatchSrc>
-  bool match(MachineRegisterInfo &MRI, MatchSrc &&src) {
+  bool match(const MachineRegisterInfo &MRI, MatchSrc &&src) {
     return false;
   }
 };
@@ -101,7 +137,7 @@
   Or(Pred &&p, Preds &&... preds)
       : Or<Preds...>(std::forward<Preds>(preds)...), P(std::forward<Pred>(p)) {}
   template <typename MatchSrc>
-  bool match(MachineRegisterInfo &MRI, MatchSrc &&src) {
+  bool match(const MachineRegisterInfo &MRI, MatchSrc &&src) {
     return P.match(MRI, src) || Or<Preds...>::match(MRI, src);
   }
 };
@@ -123,7 +159,7 @@
 
 template <> struct bind_helper<MachineInstr *> {
   static bool bind(const MachineRegisterInfo &MRI, MachineInstr *&MI,
-                   unsigned Reg) {
+                   Register Reg) {
     MI = MRI.getVRegDef(Reg);
     if (MI)
       return true;
@@ -132,7 +168,7 @@
 };
 
 template <> struct bind_helper<LLT> {
-  static bool bind(const MachineRegisterInfo &MRI, LLT &Ty, unsigned Reg) {
+  static bool bind(const MachineRegisterInfo &MRI, LLT Ty, Register Reg) {
     Ty = MRI.getType(Reg);
     if (Ty.isValid())
       return true;
@@ -142,7 +178,7 @@
 
 template <> struct bind_helper<const ConstantFP *> {
   static bool bind(const MachineRegisterInfo &MRI, const ConstantFP *&F,
-                   unsigned Reg) {
+                   Register Reg) {
     F = getConstantFPVRegVal(Reg, MRI);
     if (F)
       return true;
@@ -162,7 +198,9 @@
 
 inline bind_ty<Register> m_Reg(Register &R) { return R; }
 inline bind_ty<MachineInstr *> m_MInstr(MachineInstr *&MI) { return MI; }
-inline bind_ty<LLT> m_Type(LLT &Ty) { return Ty; }
+inline bind_ty<LLT> m_Type(LLT Ty) { return Ty; }
+inline bind_ty<CmpInst::Predicate> m_Pred(CmpInst::Predicate &P) { return P; }
+inline operand_type_match m_Pred() { return operand_type_match(); }
 
 // Helper for matching G_FCONSTANT
 inline bind_ty<const ConstantFP *> m_GFCst(const ConstantFP *&C) { return C; }
@@ -175,7 +213,8 @@
   RHS_P R;
 
   BinaryOp_match(const LHS_P &LHS, const RHS_P &RHS) : L(LHS), R(RHS) {}
-  template <typename OpTy> bool match(MachineRegisterInfo &MRI, OpTy &&Op) {
+  template <typename OpTy>
+  bool match(const MachineRegisterInfo &MRI, OpTy &&Op) {
     MachineInstr *TmpMI;
     if (mi_match(Op, MRI, m_MInstr(TmpMI))) {
       if (TmpMI->getOpcode() == Opcode && TmpMI->getNumOperands() == 3) {
@@ -196,6 +235,12 @@
 }
 
 template <typename LHS, typename RHS>
+inline BinaryOp_match<LHS, RHS, TargetOpcode::G_PTR_ADD, true>
+m_GPtrAdd(const LHS &L, const RHS &R) {
+  return BinaryOp_match<LHS, RHS, TargetOpcode::G_PTR_ADD, true>(L, R);
+}
+
+template <typename LHS, typename RHS>
 inline BinaryOp_match<LHS, RHS, TargetOpcode::G_SUB> m_GSub(const LHS &L,
                                                             const RHS &R) {
   return BinaryOp_match<LHS, RHS, TargetOpcode::G_SUB>(L, R);
@@ -232,17 +277,42 @@
 }
 
 template <typename LHS, typename RHS>
+inline BinaryOp_match<LHS, RHS, TargetOpcode::G_XOR, true>
+m_GXor(const LHS &L, const RHS &R) {
+  return BinaryOp_match<LHS, RHS, TargetOpcode::G_XOR, true>(L, R);
+}
+
+template <typename LHS, typename RHS>
 inline BinaryOp_match<LHS, RHS, TargetOpcode::G_OR, true> m_GOr(const LHS &L,
                                                                 const RHS &R) {
   return BinaryOp_match<LHS, RHS, TargetOpcode::G_OR, true>(L, R);
 }
 
+template <typename LHS, typename RHS>
+inline BinaryOp_match<LHS, RHS, TargetOpcode::G_SHL, false>
+m_GShl(const LHS &L, const RHS &R) {
+  return BinaryOp_match<LHS, RHS, TargetOpcode::G_SHL, false>(L, R);
+}
+
+template <typename LHS, typename RHS>
+inline BinaryOp_match<LHS, RHS, TargetOpcode::G_LSHR, false>
+m_GLShr(const LHS &L, const RHS &R) {
+  return BinaryOp_match<LHS, RHS, TargetOpcode::G_LSHR, false>(L, R);
+}
+
+template <typename LHS, typename RHS>
+inline BinaryOp_match<LHS, RHS, TargetOpcode::G_ASHR, false>
+m_GAShr(const LHS &L, const RHS &R) {
+  return BinaryOp_match<LHS, RHS, TargetOpcode::G_ASHR, false>(L, R);
+}
+
 // Helper for unary instructions (G_[ZSA]EXT/G_TRUNC) etc
 template <typename SrcTy, unsigned Opcode> struct UnaryOp_match {
   SrcTy L;
 
   UnaryOp_match(const SrcTy &LHS) : L(LHS) {}
-  template <typename OpTy> bool match(MachineRegisterInfo &MRI, OpTy &&Op) {
+  template <typename OpTy>
+  bool match(const MachineRegisterInfo &MRI, OpTy &&Op) {
     MachineInstr *TmpMI;
     if (mi_match(Op, MRI, m_MInstr(TmpMI))) {
       if (TmpMI->getOpcode() == Opcode && TmpMI->getNumOperands() == 2) {
@@ -318,18 +388,102 @@
   return UnaryOp_match<SrcTy, TargetOpcode::COPY>(std::forward<SrcTy>(Src));
 }
 
+// General helper for generic MI compares, i.e. G_ICMP and G_FCMP
+// TODO: Allow checking a specific predicate.
+template <typename Pred_P, typename LHS_P, typename RHS_P, unsigned Opcode>
+struct CompareOp_match {
+  Pred_P P;
+  LHS_P L;
+  RHS_P R;
+
+  CompareOp_match(const Pred_P &Pred, const LHS_P &LHS, const RHS_P &RHS)
+      : P(Pred), L(LHS), R(RHS) {}
+
+  template <typename OpTy>
+  bool match(const MachineRegisterInfo &MRI, OpTy &&Op) {
+    MachineInstr *TmpMI;
+    if (!mi_match(Op, MRI, m_MInstr(TmpMI)) || TmpMI->getOpcode() != Opcode)
+      return false;
+
+    auto TmpPred =
+        static_cast<CmpInst::Predicate>(TmpMI->getOperand(1).getPredicate());
+    if (!P.match(MRI, TmpPred))
+      return false;
+
+    return L.match(MRI, TmpMI->getOperand(2).getReg()) &&
+           R.match(MRI, TmpMI->getOperand(3).getReg());
+  }
+};
+
+template <typename Pred, typename LHS, typename RHS>
+inline CompareOp_match<Pred, LHS, RHS, TargetOpcode::G_ICMP>
+m_GICmp(const Pred &P, const LHS &L, const RHS &R) {
+  return CompareOp_match<Pred, LHS, RHS, TargetOpcode::G_ICMP>(P, L, R);
+}
+
+template <typename Pred, typename LHS, typename RHS>
+inline CompareOp_match<Pred, LHS, RHS, TargetOpcode::G_FCMP>
+m_GFCmp(const Pred &P, const LHS &L, const RHS &R) {
+  return CompareOp_match<Pred, LHS, RHS, TargetOpcode::G_FCMP>(P, L, R);
+}
+
 // Helper for checking if a Reg is of specific type.
 struct CheckType {
   LLT Ty;
-  CheckType(const LLT &Ty) : Ty(Ty) {}
+  CheckType(const LLT Ty) : Ty(Ty) {}
 
-  bool match(MachineRegisterInfo &MRI, unsigned Reg) {
+  bool match(const MachineRegisterInfo &MRI, Register Reg) {
     return MRI.getType(Reg) == Ty;
   }
 };
 
 inline CheckType m_SpecificType(LLT Ty) { return Ty; }
 
+template <typename Src0Ty, typename Src1Ty, typename Src2Ty, unsigned Opcode>
+struct TernaryOp_match {
+  Src0Ty Src0;
+  Src1Ty Src1;
+  Src2Ty Src2;
+
+  TernaryOp_match(const Src0Ty &Src0, const Src1Ty &Src1, const Src2Ty &Src2)
+      : Src0(Src0), Src1(Src1), Src2(Src2) {}
+  template <typename OpTy>
+  bool match(const MachineRegisterInfo &MRI, OpTy &&Op) {
+    MachineInstr *TmpMI;
+    if (mi_match(Op, MRI, m_MInstr(TmpMI))) {
+      if (TmpMI->getOpcode() == Opcode && TmpMI->getNumOperands() == 4) {
+        return (Src0.match(MRI, TmpMI->getOperand(1).getReg()) &&
+                Src1.match(MRI, TmpMI->getOperand(2).getReg()) &&
+                Src2.match(MRI, TmpMI->getOperand(3).getReg()));
+      }
+    }
+    return false;
+  }
+};
+template <typename Src0Ty, typename Src1Ty, typename Src2Ty>
+inline TernaryOp_match<Src0Ty, Src1Ty, Src2Ty,
+                       TargetOpcode::G_INSERT_VECTOR_ELT>
+m_GInsertVecElt(const Src0Ty &Src0, const Src1Ty &Src1, const Src2Ty &Src2) {
+  return TernaryOp_match<Src0Ty, Src1Ty, Src2Ty,
+                         TargetOpcode::G_INSERT_VECTOR_ELT>(Src0, Src1, Src2);
+}
+
+/// Matches a register negated by a G_SUB.
+/// G_SUB 0, %negated_reg
+template <typename SrcTy>
+inline BinaryOp_match<SpecificConstantMatch, SrcTy, TargetOpcode::G_SUB>
+m_Neg(const SrcTy &&Src) {
+  return m_GSub(m_ZeroInt(), Src);
+}
+
+/// Matches a register not-ed by a G_XOR.
+/// G_XOR %not_reg, -1
+template <typename SrcTy>
+inline BinaryOp_match<SrcTy, SpecificConstantMatch, TargetOpcode::G_XOR, true>
+m_Not(const SrcTy &&Src) {
+  return m_GXor(Src, m_AllOnesInt());
+}
+
 } // namespace GMIPatternMatch
 } // namespace llvm
 
diff --git a/linux-x64/clang/include/llvm/CodeGen/GlobalISel/MachineIRBuilder.h b/linux-x64/clang/include/llvm/CodeGen/GlobalISel/MachineIRBuilder.h
index da3c478..1ab4cd7 100644
--- a/linux-x64/clang/include/llvm/CodeGen/GlobalISel/MachineIRBuilder.h
+++ b/linux-x64/clang/include/llvm/CodeGen/GlobalISel/MachineIRBuilder.h
@@ -14,15 +14,14 @@
 #define LLVM_CODEGEN_GLOBALISEL_MACHINEIRBUILDER_H
 
 #include "llvm/CodeGen/GlobalISel/CSEInfo.h"
-#include "llvm/CodeGen/GlobalISel/Types.h"
-
 #include "llvm/CodeGen/LowLevelType.h"
 #include "llvm/CodeGen/MachineBasicBlock.h"
 #include "llvm/CodeGen/MachineInstrBuilder.h"
 #include "llvm/CodeGen/MachineRegisterInfo.h"
+#include "llvm/CodeGen/TargetOpcodes.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DebugLoc.h"
-
+#include "llvm/IR/Module.h"
 
 namespace llvm {
 
@@ -37,23 +36,23 @@
 /// to transfer BuilderState between different kinds of MachineIRBuilders.
 struct MachineIRBuilderState {
   /// MachineFunction under construction.
-  MachineFunction *MF;
+  MachineFunction *MF = nullptr;
   /// Information used to access the description of the opcodes.
-  const TargetInstrInfo *TII;
+  const TargetInstrInfo *TII = nullptr;
   /// Information used to verify types are consistent and to create virtual registers.
-  MachineRegisterInfo *MRI;
+  MachineRegisterInfo *MRI = nullptr;
   /// Debug location to be set to any instruction we create.
   DebugLoc DL;
 
   /// \name Fields describing the insertion point.
   /// @{
-  MachineBasicBlock *MBB;
+  MachineBasicBlock *MBB = nullptr;
   MachineBasicBlock::iterator II;
   /// @}
 
-  GISelChangeObserver *Observer;
+  GISelChangeObserver *Observer = nullptr;
 
-  GISelCSEInfo *CSEInfo;
+  GISelCSEInfo *CSEInfo = nullptr;
 };
 
 class DstOp {
@@ -68,7 +67,7 @@
   DstOp(unsigned R) : Reg(R), Ty(DstType::Ty_Reg) {}
   DstOp(Register R) : Reg(R), Ty(DstType::Ty_Reg) {}
   DstOp(const MachineOperand &Op) : Reg(Op.getReg()), Ty(DstType::Ty_Reg) {}
-  DstOp(const LLT &T) : LLTTy(T), Ty(DstType::Ty_LLT) {}
+  DstOp(const LLT T) : LLTTy(T), Ty(DstType::Ty_LLT) {}
   DstOp(const TargetRegisterClass *TRC) : RC(TRC), Ty(DstType::Ty_RC) {}
 
   void addDefToMIB(MachineRegisterInfo &MRI, MachineInstrBuilder &MIB) const {
@@ -122,14 +121,22 @@
     MachineInstrBuilder SrcMIB;
     Register Reg;
     CmpInst::Predicate Pred;
+    int64_t Imm;
   };
 
 public:
-  enum class SrcType { Ty_Reg, Ty_MIB, Ty_Predicate };
+  enum class SrcType { Ty_Reg, Ty_MIB, Ty_Predicate, Ty_Imm };
   SrcOp(Register R) : Reg(R), Ty(SrcType::Ty_Reg) {}
   SrcOp(const MachineOperand &Op) : Reg(Op.getReg()), Ty(SrcType::Ty_Reg) {}
   SrcOp(const MachineInstrBuilder &MIB) : SrcMIB(MIB), Ty(SrcType::Ty_MIB) {}
   SrcOp(const CmpInst::Predicate P) : Pred(P), Ty(SrcType::Ty_Predicate) {}
+  /// Use of registers held in unsigned integer variables (or more rarely signed
+  /// integers) is no longer permitted to avoid ambiguity with upcoming support
+  /// for immediates.
+  SrcOp(unsigned) = delete;
+  SrcOp(int) = delete;
+  SrcOp(uint64_t V) : Imm(V), Ty(SrcType::Ty_Imm) {}
+  SrcOp(int64_t V) : Imm(V), Ty(SrcType::Ty_Imm) {}
 
   void addSrcToMIB(MachineInstrBuilder &MIB) const {
     switch (Ty) {
@@ -142,12 +149,16 @@
     case SrcType::Ty_MIB:
       MIB.addUse(SrcMIB->getOperand(0).getReg());
       break;
+    case SrcType::Ty_Imm:
+      MIB.addImm(Imm);
+      break;
     }
   }
 
   LLT getLLTTy(const MachineRegisterInfo &MRI) const {
     switch (Ty) {
     case SrcType::Ty_Predicate:
+    case SrcType::Ty_Imm:
       llvm_unreachable("Not a register operand");
     case SrcType::Ty_Reg:
       return MRI.getType(Reg);
@@ -160,6 +171,7 @@
   Register getReg() const {
     switch (Ty) {
     case SrcType::Ty_Predicate:
+    case SrcType::Ty_Imm:
       llvm_unreachable("Not a register operand");
     case SrcType::Ty_Reg:
       return Reg;
@@ -178,6 +190,15 @@
     }
   }
 
+  int64_t getImm() const {
+    switch (Ty) {
+    case SrcType::Ty_Imm:
+      return Imm;
+    default:
+      llvm_unreachable("Not an immediate");
+    }
+  }
+
   SrcType getSrcOpKind() const { return Ty; }
 
 private:
@@ -201,21 +222,39 @@
   MachineIRBuilderState State;
 
 protected:
-  void validateTruncExt(const LLT &Dst, const LLT &Src, bool IsExtend);
+  void validateTruncExt(const LLT Dst, const LLT Src, bool IsExtend);
 
-  void validateBinaryOp(const LLT &Res, const LLT &Op0, const LLT &Op1);
-  void validateShiftOp(const LLT &Res, const LLT &Op0, const LLT &Op1);
+  void validateUnaryOp(const LLT Res, const LLT Op0);
+  void validateBinaryOp(const LLT Res, const LLT Op0, const LLT Op1);
+  void validateShiftOp(const LLT Res, const LLT Op0, const LLT Op1);
 
-  void validateSelectOp(const LLT &ResTy, const LLT &TstTy, const LLT &Op0Ty,
-                        const LLT &Op1Ty);
-  void recordInsertion(MachineInstr *MI) const;
+  void validateSelectOp(const LLT ResTy, const LLT TstTy, const LLT Op0Ty,
+                        const LLT Op1Ty);
+
+  void recordInsertion(MachineInstr *InsertedInstr) const {
+    if (State.Observer)
+      State.Observer->createdInstr(*InsertedInstr);
+  }
 
 public:
   /// Some constructors for easy use.
   MachineIRBuilder() = default;
   MachineIRBuilder(MachineFunction &MF) { setMF(MF); }
-  MachineIRBuilder(MachineInstr &MI) : MachineIRBuilder(*MI.getMF()) {
+
+  MachineIRBuilder(MachineBasicBlock &MBB, MachineBasicBlock::iterator InsPt) {
+    setMF(*MBB.getParent());
+    setInsertPt(MBB, InsPt);
+  }
+
+  MachineIRBuilder(MachineInstr &MI) :
+    MachineIRBuilder(*MI.getParent(), MI.getIterator()) {
     setInstr(MI);
+    setDebugLoc(MI.getDebugLoc());
+  }
+
+  MachineIRBuilder(MachineInstr &MI, GISelChangeObserver &Observer) :
+    MachineIRBuilder(MI) {
+    setChangeObserver(Observer);
   }
 
   virtual ~MachineIRBuilder() = default;
@@ -272,10 +311,16 @@
   /// Set the insertion point before the specified position.
   /// \pre MBB must be in getMF().
   /// \pre II must be a valid iterator in MBB.
-  void setInsertPt(MachineBasicBlock &MBB, MachineBasicBlock::iterator II);
+  void setInsertPt(MachineBasicBlock &MBB, MachineBasicBlock::iterator II) {
+    assert(MBB.getParent() == &getMF() &&
+           "Basic block is in a different function");
+    State.MBB = &MBB;
+    State.II = II;
+  }
+
   /// @}
 
-  void setCSEInfo(GISelCSEInfo *Info);
+  void setCSEInfo(GISelCSEInfo *Info) { State.CSEInfo = Info; }
 
   /// \name Setters for the insertion point.
   /// @{
@@ -284,15 +329,34 @@
 
   /// Set the insertion point to the  end of \p MBB.
   /// \pre \p MBB must be contained by getMF().
-  void setMBB(MachineBasicBlock &MBB);
+  void setMBB(MachineBasicBlock &MBB) {
+    State.MBB = &MBB;
+    State.II = MBB.end();
+    assert(&getMF() == MBB.getParent() &&
+           "Basic block is in a different function");
+  }
 
   /// Set the insertion point to before MI.
   /// \pre MI must be in getMF().
-  void setInstr(MachineInstr &MI);
+  void setInstr(MachineInstr &MI) {
+    assert(MI.getParent() && "Instruction is not part of a basic block");
+    setMBB(*MI.getParent());
+    State.II = MI.getIterator();
+  }
   /// @}
 
-  void setChangeObserver(GISelChangeObserver &Observer);
-  void stopObservingChanges();
+  /// Set the insertion point to before MI, and set the debug loc to MI's loc.
+  /// \pre MI must be in getMF().
+  void setInstrAndDebugLoc(MachineInstr &MI) {
+    setInstr(MI);
+    setDebugLoc(MI.getDebugLoc());
+  }
+
+  void setChangeObserver(GISelChangeObserver &Observer) {
+    State.Observer = &Observer;
+  }
+
+  void stopObservingChanges() { State.Observer = nullptr; }
   /// @}
 
   /// Set the debug location to \p DL for all the next build instructions.
@@ -308,7 +372,9 @@
   /// \pre setBasicBlock or setMI must have been called.
   ///
   /// \return a MachineInstrBuilder for the newly created instruction.
-  MachineInstrBuilder buildInstr(unsigned Opcode);
+  MachineInstrBuilder buildInstr(unsigned Opcode) {
+    return insertInstr(buildInstrNoInsert(Opcode));
+  }
 
   /// Build but don't insert <empty> = \p Opcode <empty>.
   ///
@@ -348,6 +414,17 @@
   /// given. Convert "llvm.dbg.label Label" to "DBG_LABEL Label".
   MachineInstrBuilder buildDbgLabel(const MDNode *Label);
 
+  /// Build and insert \p Res = G_DYN_STACKALLOC \p Size, \p Align
+  ///
+  /// G_DYN_STACKALLOC does a dynamic stack allocation and writes the address of
+  /// the allocated memory into \p Res.
+  /// \pre setBasicBlock or setMI must have been called.
+  /// \pre \p Res must be a generic virtual register with pointer type.
+  ///
+  /// \return a MachineInstrBuilder for the newly created instruction.
+  MachineInstrBuilder buildDynStackAlloc(const DstOp &Res, const SrcOp &Size,
+                                         Align Alignment);
+
   /// Build and insert \p Res = G_FRAME_INDEX \p Idx
   ///
   /// G_FRAME_INDEX materializes the address of an alloca value or other
@@ -371,10 +448,11 @@
   /// \return a MachineInstrBuilder for the newly created instruction.
   MachineInstrBuilder buildGlobalValue(const DstOp &Res, const GlobalValue *GV);
 
-  /// Build and insert \p Res = G_GEP \p Op0, \p Op1
+  /// Build and insert \p Res = G_PTR_ADD \p Op0, \p Op1
   ///
-  /// G_GEP adds \p Op1 bytes to the pointer specified by \p Op0,
-  /// storing the resulting pointer in \p Res.
+  /// G_PTR_ADD adds \p Op1 addressible units to the pointer specified by \p Op0,
+  /// storing the resulting pointer in \p Res. Addressible units are typically
+  /// bytes but this can vary between targets.
   ///
   /// \pre setBasicBlock or setMI must have been called.
   /// \pre \p Res and \p Op0 must be generic virtual registers with pointer
@@ -382,32 +460,38 @@
   /// \pre \p Op1 must be a generic virtual register with scalar type.
   ///
   /// \return a MachineInstrBuilder for the newly created instruction.
-  MachineInstrBuilder buildGEP(const DstOp &Res, const SrcOp &Op0,
-                               const SrcOp &Op1);
+  MachineInstrBuilder buildPtrAdd(const DstOp &Res, const SrcOp &Op0,
+                                  const SrcOp &Op1);
 
-  /// Materialize and insert \p Res = G_GEP \p Op0, (G_CONSTANT \p Value)
+  /// Materialize and insert \p Res = G_PTR_ADD \p Op0, (G_CONSTANT \p Value)
   ///
-  /// G_GEP adds \p Value bytes to the pointer specified by \p Op0,
+  /// G_PTR_ADD adds \p Value bytes to the pointer specified by \p Op0,
   /// storing the resulting pointer in \p Res. If \p Value is zero then no
-  /// G_GEP or G_CONSTANT will be created and \pre Op0 will be assigned to
+  /// G_PTR_ADD or G_CONSTANT will be created and \pre Op0 will be assigned to
   /// \p Res.
   ///
   /// \pre setBasicBlock or setMI must have been called.
   /// \pre \p Op0 must be a generic virtual register with pointer type.
   /// \pre \p ValueTy must be a scalar type.
   /// \pre \p Res must be 0. This is to detect confusion between
-  ///      materializeGEP() and buildGEP().
+  ///      materializePtrAdd() and buildPtrAdd().
   /// \post \p Res will either be a new generic virtual register of the same
   ///       type as \p Op0 or \p Op0 itself.
   ///
   /// \return a MachineInstrBuilder for the newly created instruction.
-  Optional<MachineInstrBuilder> materializeGEP(Register &Res, Register Op0,
-                                               const LLT &ValueTy,
-                                               uint64_t Value);
+  Optional<MachineInstrBuilder> materializePtrAdd(Register &Res, Register Op0,
+                                                  const LLT ValueTy,
+                                                  uint64_t Value);
 
-  /// Build and insert \p Res = G_PTR_MASK \p Op0, \p NumBits
+  /// Build and insert \p Res = G_PTRMASK \p Op0, \p Op1
+  MachineInstrBuilder buildPtrMask(const DstOp &Res, const SrcOp &Op0,
+                                   const SrcOp &Op1) {
+    return buildInstr(TargetOpcode::G_PTRMASK, {Res}, {Op0, Op1});
+  }
+
+  /// Build and insert \p Res = G_PTRMASK \p Op0, \p G_CONSTANT (1 << NumBits) - 1
   ///
-  /// G_PTR_MASK clears the low bits of a pointer operand without destroying its
+  /// This clears the low bits of a pointer operand without destroying its
   /// pointer properties. This has the effect of rounding the address *down* to
   /// a specified alignment in bits.
   ///
@@ -418,8 +502,8 @@
   ///      be cleared in \p Op0.
   ///
   /// \return a MachineInstrBuilder for the newly created instruction.
-  MachineInstrBuilder buildPtrMask(const DstOp &Res, const SrcOp &Op0,
-                                   uint32_t NumBits);
+  MachineInstrBuilder buildMaskLowPtrBits(const DstOp &Res, const SrcOp &Op0,
+                                          uint32_t NumBits);
 
   /// Build and insert \p Res, \p CarryOut = G_UADDO \p Op0, \p Op1
   ///
@@ -434,7 +518,27 @@
   ///
   /// \return The newly created instruction.
   MachineInstrBuilder buildUAddo(const DstOp &Res, const DstOp &CarryOut,
-                                 const SrcOp &Op0, const SrcOp &Op1);
+                                 const SrcOp &Op0, const SrcOp &Op1) {
+    return buildInstr(TargetOpcode::G_UADDO, {Res, CarryOut}, {Op0, Op1});
+  }
+
+  /// Build and insert \p Res, \p CarryOut = G_USUBO \p Op0, \p Op1
+  MachineInstrBuilder buildUSubo(const DstOp &Res, const DstOp &CarryOut,
+                                 const SrcOp &Op0, const SrcOp &Op1) {
+    return buildInstr(TargetOpcode::G_USUBO, {Res, CarryOut}, {Op0, Op1});
+  }
+
+  /// Build and insert \p Res, \p CarryOut = G_SADDO \p Op0, \p Op1
+  MachineInstrBuilder buildSAddo(const DstOp &Res, const DstOp &CarryOut,
+                                 const SrcOp &Op0, const SrcOp &Op1) {
+    return buildInstr(TargetOpcode::G_SADDO, {Res, CarryOut}, {Op0, Op1});
+  }
+
+  /// Build and insert \p Res, \p CarryOut = G_SUBO \p Op0, \p Op1
+  MachineInstrBuilder buildSSubo(const DstOp &Res, const DstOp &CarryOut,
+                                 const SrcOp &Op0, const SrcOp &Op1) {
+    return buildInstr(TargetOpcode::G_SSUBO, {Res, CarryOut}, {Op0, Op1});
+  }
 
   /// Build and insert \p Res, \p CarryOut = G_UADDE \p Op0,
   /// \p Op1, \p CarryIn
@@ -452,7 +556,34 @@
   /// \return The newly created instruction.
   MachineInstrBuilder buildUAdde(const DstOp &Res, const DstOp &CarryOut,
                                  const SrcOp &Op0, const SrcOp &Op1,
-                                 const SrcOp &CarryIn);
+                                 const SrcOp &CarryIn) {
+    return buildInstr(TargetOpcode::G_UADDE, {Res, CarryOut},
+                                             {Op0, Op1, CarryIn});
+  }
+
+  /// Build and insert \p Res, \p CarryOut = G_USUBE \p Op0, \p Op1, \p CarryInp
+  MachineInstrBuilder buildUSube(const DstOp &Res, const DstOp &CarryOut,
+                                 const SrcOp &Op0, const SrcOp &Op1,
+                                 const SrcOp &CarryIn) {
+    return buildInstr(TargetOpcode::G_USUBE, {Res, CarryOut},
+                                             {Op0, Op1, CarryIn});
+  }
+
+  /// Build and insert \p Res, \p CarryOut = G_SADDE \p Op0, \p Op1, \p CarryInp
+  MachineInstrBuilder buildSAdde(const DstOp &Res, const DstOp &CarryOut,
+                                 const SrcOp &Op0, const SrcOp &Op1,
+                                 const SrcOp &CarryIn) {
+    return buildInstr(TargetOpcode::G_SADDE, {Res, CarryOut},
+                                             {Op0, Op1, CarryIn});
+  }
+
+  /// Build and insert \p Res, \p CarryOut = G_SSUBE \p Op0, \p Op1, \p CarryInp
+  MachineInstrBuilder buildSSube(const DstOp &Res, const DstOp &CarryOut,
+                                 const SrcOp &Op0, const SrcOp &Op1,
+                                 const SrcOp &CarryIn) {
+    return buildInstr(TargetOpcode::G_SSUBE, {Res, CarryOut},
+                                             {Op0, Op1, CarryIn});
+  }
 
   /// Build and insert \p Res = G_ANYEXT \p Op0
   ///
@@ -484,16 +615,38 @@
   /// \return The newly created instruction.
   MachineInstrBuilder buildSExt(const DstOp &Res, const SrcOp &Op);
 
+  /// Build and insert \p Res = G_SEXT_INREG \p Op, ImmOp
+  MachineInstrBuilder buildSExtInReg(const DstOp &Res, const SrcOp &Op, int64_t ImmOp) {
+    return buildInstr(TargetOpcode::G_SEXT_INREG, {Res}, {Op, SrcOp(ImmOp)});
+  }
+
+  /// Build and insert \p Res = G_FPEXT \p Op
+  MachineInstrBuilder buildFPExt(const DstOp &Res, const SrcOp &Op,
+                                 Optional<unsigned> Flags = None) {
+    return buildInstr(TargetOpcode::G_FPEXT, {Res}, {Op}, Flags);
+  }
+
+
   /// Build and insert a G_PTRTOINT instruction.
   MachineInstrBuilder buildPtrToInt(const DstOp &Dst, const SrcOp &Src) {
     return buildInstr(TargetOpcode::G_PTRTOINT, {Dst}, {Src});
   }
 
+  /// Build and insert a G_INTTOPTR instruction.
+  MachineInstrBuilder buildIntToPtr(const DstOp &Dst, const SrcOp &Src) {
+    return buildInstr(TargetOpcode::G_INTTOPTR, {Dst}, {Src});
+  }
+
   /// Build and insert \p Dst = G_BITCAST \p Src
   MachineInstrBuilder buildBitcast(const DstOp &Dst, const SrcOp &Src) {
     return buildInstr(TargetOpcode::G_BITCAST, {Dst}, {Src});
   }
 
+    /// Build and insert \p Dst = G_ADDRSPACE_CAST \p Src
+  MachineInstrBuilder buildAddrSpaceCast(const DstOp &Dst, const SrcOp &Src) {
+    return buildInstr(TargetOpcode::G_ADDRSPACE_CAST, {Dst}, {Src});
+  }
+
   /// \return The opcode of the extension the target wants to use for boolean
   /// values.
   unsigned getBoolExtOp(bool IsVec, bool IsFP) const;
@@ -583,7 +736,7 @@
   ///      depend on bit 0 (for now).
   ///
   /// \return The newly created instruction.
-  MachineInstrBuilder buildBrCond(Register Tst, MachineBasicBlock &Dest);
+  MachineInstrBuilder buildBrCond(const SrcOp &Tst, MachineBasicBlock &Dest);
 
   /// Build and insert G_BRINDIRECT \p Tgt
   ///
@@ -667,7 +820,17 @@
   ///
   /// \return a MachineInstrBuilder for the newly created instruction.
   MachineInstrBuilder buildLoad(const DstOp &Res, const SrcOp &Addr,
-                                MachineMemOperand &MMO);
+                                MachineMemOperand &MMO) {
+    return buildLoadInstr(TargetOpcode::G_LOAD, Res, Addr, MMO);
+  }
+
+  /// Build and insert a G_LOAD instruction, while constructing the
+  /// MachineMemOperand.
+  MachineInstrBuilder
+  buildLoad(const DstOp &Res, const SrcOp &Addr, MachinePointerInfo PtrInfo,
+            Align Alignment,
+            MachineMemOperand::Flags MMOFlags = MachineMemOperand::MONone,
+            const AAMDNodes &AAInfo = AAMDNodes());
 
   /// Build and insert `Res = <opcode> Addr, MMO`.
   ///
@@ -681,6 +844,14 @@
   MachineInstrBuilder buildLoadInstr(unsigned Opcode, const DstOp &Res,
                                      const SrcOp &Addr, MachineMemOperand &MMO);
 
+  /// Helper to create a load from a constant offset given a base address. Load
+  /// the type of \p Dst from \p Offset from the given base address and memory
+  /// operand.
+  MachineInstrBuilder buildLoadFromOffset(const DstOp &Dst,
+                                          const SrcOp &BasePtr,
+                                          MachineMemOperand &BaseMMO,
+                                          int64_t Offset);
+
   /// Build and insert `G_STORE Val, Addr, MMO`.
   ///
   /// Stores the value \p Val to \p Addr.
@@ -693,6 +864,14 @@
   MachineInstrBuilder buildStore(const SrcOp &Val, const SrcOp &Addr,
                                  MachineMemOperand &MMO);
 
+  /// Build and insert a G_STORE instruction, while constructing the
+  /// MachineMemOperand.
+  MachineInstrBuilder
+  buildStore(const SrcOp &Val, const SrcOp &Addr, MachinePointerInfo PtrInfo,
+             Align Alignment,
+             MachineMemOperand::Flags MMOFlags = MachineMemOperand::MONone,
+             const AAMDNodes &AAInfo = AAMDNodes());
+
   /// Build and insert `Res0, ... = G_EXTRACT Src, Idx0`.
   ///
   /// \pre setBasicBlock or setMI must have been called.
@@ -732,6 +911,8 @@
   ///
   /// \return a MachineInstrBuilder for the newly created instruction.
   MachineInstrBuilder buildMerge(const DstOp &Res, ArrayRef<Register> Ops);
+  MachineInstrBuilder buildMerge(const DstOp &Res,
+                                 std::initializer_list<SrcOp> Ops);
 
   /// Build and insert \p Res0, ... = G_UNMERGE_VALUES \p Op
   ///
@@ -782,6 +963,23 @@
   MachineInstrBuilder buildBuildVectorTrunc(const DstOp &Res,
                                             ArrayRef<Register> Ops);
 
+  /// Build and insert a vector splat of a scalar \p Src using a
+  /// G_INSERT_VECTOR_ELT and G_SHUFFLE_VECTOR idiom.
+  ///
+  /// \pre setBasicBlock or setMI must have been called.
+  /// \pre \p Src must have the same type as the element type of \p Dst
+  ///
+  /// \return a MachineInstrBuilder for the newly created instruction.
+  MachineInstrBuilder buildShuffleSplat(const DstOp &Res, const SrcOp &Src);
+
+  /// Build and insert \p Res = G_SHUFFLE_VECTOR \p Src1, \p Src2, \p Mask
+  ///
+  /// \pre setBasicBlock or setMI must have been called.
+  ///
+  /// \return a MachineInstrBuilder for the newly created instruction.
+  MachineInstrBuilder buildShuffleVector(const DstOp &Res, const SrcOp &Src1,
+                                         const SrcOp &Src2, ArrayRef<int> Mask);
+
   /// Build and insert \p Res = G_CONCAT_VECTORS \p Op0, ...
   ///
   /// G_CONCAT_VECTORS creates a vector from the concatenation of 2 or more
@@ -796,8 +994,8 @@
   MachineInstrBuilder buildConcatVectors(const DstOp &Res,
                                          ArrayRef<Register> Ops);
 
-  MachineInstrBuilder buildInsert(Register Res, Register Src,
-                                  Register Op, unsigned Index);
+  MachineInstrBuilder buildInsert(const DstOp &Res, const SrcOp &Src,
+                                  const SrcOp &Op, unsigned Index);
 
   /// Build and insert either a G_INTRINSIC (if \p HasSideEffects is false) or
   /// G_INTRINSIC_W_SIDE_EFFECTS instruction. Its first operand will be the
@@ -824,7 +1022,8 @@
   /// \pre \p Res must be smaller than \p Op
   ///
   /// \return The newly created instruction.
-  MachineInstrBuilder buildFPTrunc(const DstOp &Res, const SrcOp &Op);
+  MachineInstrBuilder buildFPTrunc(const DstOp &Res, const SrcOp &Op,
+                                   Optional<unsigned> Flags = None);
 
   /// Build and insert \p Res = G_TRUNC \p Op
   ///
@@ -867,7 +1066,8 @@
   ///
   /// \return a MachineInstrBuilder for the newly created instruction.
   MachineInstrBuilder buildFCmp(CmpInst::Predicate Pred, const DstOp &Res,
-                                const SrcOp &Op0, const SrcOp &Op1);
+                                const SrcOp &Op0, const SrcOp &Op1,
+                                Optional<unsigned> Flags = None);
 
   /// Build and insert a \p Res = G_SELECT \p Tst, \p Op0, \p Op1
   ///
@@ -880,7 +1080,8 @@
   ///
   /// \return a MachineInstrBuilder for the newly created instruction.
   MachineInstrBuilder buildSelect(const DstOp &Res, const SrcOp &Tst,
-                                  const SrcOp &Op0, const SrcOp &Op1);
+                                  const SrcOp &Op0, const SrcOp &Op1,
+                                  Optional<unsigned> Flags = None);
 
   /// Build and insert \p Res = G_INSERT_VECTOR_ELT \p Val,
   /// \p Elt, \p Idx
@@ -961,8 +1162,8 @@
   ///      same type.
   ///
   /// \return a MachineInstrBuilder for the newly created instruction.
-  MachineInstrBuilder buildAtomicRMW(unsigned Opcode, Register OldValRes,
-                                     Register Addr, Register Val,
+  MachineInstrBuilder buildAtomicRMW(unsigned Opcode, const DstOp &OldValRes,
+                                     const SrcOp &Addr, const SrcOp &Val,
                                      MachineMemOperand &MMO);
 
   /// Build and insert `OldValRes<def> = G_ATOMICRMW_XCHG Addr, Val, MMO`.
@@ -1135,9 +1336,24 @@
   MachineInstrBuilder buildAtomicRMWUmin(Register OldValRes, Register Addr,
                                          Register Val, MachineMemOperand &MMO);
 
+  /// Build and insert `OldValRes<def> = G_ATOMICRMW_FADD Addr, Val, MMO`.
+  MachineInstrBuilder buildAtomicRMWFAdd(
+    const DstOp &OldValRes, const SrcOp &Addr, const SrcOp &Val,
+    MachineMemOperand &MMO);
+
+  /// Build and insert `OldValRes<def> = G_ATOMICRMW_FSUB Addr, Val, MMO`.
+  MachineInstrBuilder buildAtomicRMWFSub(
+        const DstOp &OldValRes, const SrcOp &Addr, const SrcOp &Val,
+        MachineMemOperand &MMO);
+
   /// Build and insert `G_FENCE Ordering, Scope`.
   MachineInstrBuilder buildFence(unsigned Ordering, unsigned Scope);
 
+  /// Build and insert \p Dst = G_FREEZE \p Src
+  MachineInstrBuilder buildFreeze(const DstOp &Dst, const SrcOp &Src) {
+    return buildInstr(TargetOpcode::G_FREEZE, {Dst}, {Src});
+  }
+
   /// Build and insert \p Res = G_BLOCK_ADDR \p BA
   ///
   /// G_BLOCK_ADDR computes the address of a basic block.
@@ -1210,6 +1426,36 @@
     return buildInstr(TargetOpcode::G_SMULH, {Dst}, {Src0, Src1}, Flags);
   }
 
+  MachineInstrBuilder buildFMul(const DstOp &Dst, const SrcOp &Src0,
+                                const SrcOp &Src1,
+                                Optional<unsigned> Flags = None) {
+    return buildInstr(TargetOpcode::G_FMUL, {Dst}, {Src0, Src1}, Flags);
+  }
+
+  MachineInstrBuilder buildFMinNum(const DstOp &Dst, const SrcOp &Src0,
+                                   const SrcOp &Src1,
+                                   Optional<unsigned> Flags = None) {
+    return buildInstr(TargetOpcode::G_FMINNUM, {Dst}, {Src0, Src1}, Flags);
+  }
+
+  MachineInstrBuilder buildFMaxNum(const DstOp &Dst, const SrcOp &Src0,
+                                   const SrcOp &Src1,
+                                   Optional<unsigned> Flags = None) {
+    return buildInstr(TargetOpcode::G_FMAXNUM, {Dst}, {Src0, Src1}, Flags);
+  }
+
+  MachineInstrBuilder buildFMinNumIEEE(const DstOp &Dst, const SrcOp &Src0,
+                                       const SrcOp &Src1,
+                                       Optional<unsigned> Flags = None) {
+    return buildInstr(TargetOpcode::G_FMINNUM_IEEE, {Dst}, {Src0, Src1}, Flags);
+  }
+
+  MachineInstrBuilder buildFMaxNumIEEE(const DstOp &Dst, const SrcOp &Src0,
+                                       const SrcOp &Src1,
+                                       Optional<unsigned> Flags = None) {
+    return buildInstr(TargetOpcode::G_FMAXNUM_IEEE, {Dst}, {Src0, Src1}, Flags);
+  }
+
   MachineInstrBuilder buildShl(const DstOp &Dst, const SrcOp &Src0,
                                const SrcOp &Src1,
                                Optional<unsigned> Flags = None) {
@@ -1298,32 +1544,99 @@
     return buildInstr(TargetOpcode::G_CTTZ_ZERO_UNDEF, {Dst}, {Src0});
   }
 
+  /// Build and insert \p Dst = G_BSWAP \p Src0
+  MachineInstrBuilder buildBSwap(const DstOp &Dst, const SrcOp &Src0) {
+    return buildInstr(TargetOpcode::G_BSWAP, {Dst}, {Src0});
+  }
+
   /// Build and insert \p Res = G_FADD \p Op0, \p Op1
   MachineInstrBuilder buildFAdd(const DstOp &Dst, const SrcOp &Src0,
-                                const SrcOp &Src1) {
-    return buildInstr(TargetOpcode::G_FADD, {Dst}, {Src0, Src1});
+                                const SrcOp &Src1,
+                                Optional<unsigned> Flags = None) {
+    return buildInstr(TargetOpcode::G_FADD, {Dst}, {Src0, Src1}, Flags);
   }
 
   /// Build and insert \p Res = G_FSUB \p Op0, \p Op1
   MachineInstrBuilder buildFSub(const DstOp &Dst, const SrcOp &Src0,
-                                const SrcOp &Src1) {
-    return buildInstr(TargetOpcode::G_FSUB, {Dst}, {Src0, Src1});
+                                const SrcOp &Src1,
+                                Optional<unsigned> Flags = None) {
+    return buildInstr(TargetOpcode::G_FSUB, {Dst}, {Src0, Src1}, Flags);
+  }
+
+  /// Build and insert \p Res = G_FDIV \p Op0, \p Op1
+  MachineInstrBuilder buildFDiv(const DstOp &Dst, const SrcOp &Src0,
+                                const SrcOp &Src1,
+                                Optional<unsigned> Flags = None) {
+    return buildInstr(TargetOpcode::G_FDIV, {Dst}, {Src0, Src1}, Flags);
   }
 
   /// Build and insert \p Res = G_FMA \p Op0, \p Op1, \p Op2
   MachineInstrBuilder buildFMA(const DstOp &Dst, const SrcOp &Src0,
-                               const SrcOp &Src1, const SrcOp &Src2) {
-    return buildInstr(TargetOpcode::G_FMA, {Dst}, {Src0, Src1, Src2});
+                               const SrcOp &Src1, const SrcOp &Src2,
+                               Optional<unsigned> Flags = None) {
+    return buildInstr(TargetOpcode::G_FMA, {Dst}, {Src0, Src1, Src2}, Flags);
+  }
+
+  /// Build and insert \p Res = G_FMAD \p Op0, \p Op1, \p Op2
+  MachineInstrBuilder buildFMAD(const DstOp &Dst, const SrcOp &Src0,
+                                const SrcOp &Src1, const SrcOp &Src2,
+                                Optional<unsigned> Flags = None) {
+    return buildInstr(TargetOpcode::G_FMAD, {Dst}, {Src0, Src1, Src2}, Flags);
   }
 
   /// Build and insert \p Res = G_FNEG \p Op0
-  MachineInstrBuilder buildFNeg(const DstOp &Dst, const SrcOp &Src0) {
-    return buildInstr(TargetOpcode::G_FNEG, {Dst}, {Src0});
+  MachineInstrBuilder buildFNeg(const DstOp &Dst, const SrcOp &Src0,
+                                Optional<unsigned> Flags = None) {
+    return buildInstr(TargetOpcode::G_FNEG, {Dst}, {Src0}, Flags);
   }
 
   /// Build and insert \p Res = G_FABS \p Op0
-  MachineInstrBuilder buildFAbs(const DstOp &Dst, const SrcOp &Src0) {
-    return buildInstr(TargetOpcode::G_FABS, {Dst}, {Src0});
+  MachineInstrBuilder buildFAbs(const DstOp &Dst, const SrcOp &Src0,
+                                Optional<unsigned> Flags = None) {
+    return buildInstr(TargetOpcode::G_FABS, {Dst}, {Src0}, Flags);
+  }
+
+  /// Build and insert \p Dst = G_FCANONICALIZE \p Src0
+  MachineInstrBuilder buildFCanonicalize(const DstOp &Dst, const SrcOp &Src0,
+                                         Optional<unsigned> Flags = None) {
+    return buildInstr(TargetOpcode::G_FCANONICALIZE, {Dst}, {Src0}, Flags);
+  }
+
+  /// Build and insert \p Dst = G_INTRINSIC_TRUNC \p Src0
+  MachineInstrBuilder buildIntrinsicTrunc(const DstOp &Dst, const SrcOp &Src0,
+                                         Optional<unsigned> Flags = None) {
+    return buildInstr(TargetOpcode::G_INTRINSIC_TRUNC, {Dst}, {Src0}, Flags);
+  }
+
+  /// Build and insert \p Res = GFFLOOR \p Op0, \p Op1
+  MachineInstrBuilder buildFFloor(const DstOp &Dst, const SrcOp &Src0,
+                                          Optional<unsigned> Flags = None) {
+    return buildInstr(TargetOpcode::G_FFLOOR, {Dst}, {Src0}, Flags);
+  }
+
+  /// Build and insert \p Dst = G_FLOG \p Src
+  MachineInstrBuilder buildFLog(const DstOp &Dst, const SrcOp &Src,
+                                Optional<unsigned> Flags = None) {
+    return buildInstr(TargetOpcode::G_FLOG, {Dst}, {Src}, Flags);
+  }
+
+  /// Build and insert \p Dst = G_FLOG2 \p Src
+  MachineInstrBuilder buildFLog2(const DstOp &Dst, const SrcOp &Src,
+                                Optional<unsigned> Flags = None) {
+    return buildInstr(TargetOpcode::G_FLOG2, {Dst}, {Src}, Flags);
+  }
+
+  /// Build and insert \p Dst = G_FEXP2 \p Src
+  MachineInstrBuilder buildFExp2(const DstOp &Dst, const SrcOp &Src,
+                                Optional<unsigned> Flags = None) {
+    return buildInstr(TargetOpcode::G_FEXP2, {Dst}, {Src}, Flags);
+  }
+
+  /// Build and insert \p Dst = G_FPOW \p Src0, \p Src1
+  MachineInstrBuilder buildFPow(const DstOp &Dst, const SrcOp &Src0,
+                                const SrcOp &Src1,
+                                Optional<unsigned> Flags = None) {
+    return buildInstr(TargetOpcode::G_FPOW, {Dst}, {Src0, Src1}, Flags);
   }
 
   /// Build and insert \p Res = G_FCOPYSIGN \p Op0, \p Op1
@@ -1376,6 +1689,11 @@
     return buildInstr(TargetOpcode::G_UMAX, {Dst}, {Src0, Src1});
   }
 
+  /// Build and insert \p Dst = G_ABS \p Src
+  MachineInstrBuilder buildAbs(const DstOp &Dst, const SrcOp &Src) {
+    return buildInstr(TargetOpcode::G_ABS, {Dst}, {Src});
+  }
+
   /// Build and insert \p Res = G_JUMP_TABLE \p JTI
   ///
   /// G_JUMP_TABLE sets \p Res to the address of the jump table specified by
@@ -1384,6 +1702,101 @@
   /// \return a MachineInstrBuilder for the newly created instruction.
   MachineInstrBuilder buildJumpTable(const LLT PtrTy, unsigned JTI);
 
+  /// Build and insert \p Res = G_VECREDUCE_SEQ_FADD \p ScalarIn, \p VecIn
+  ///
+  /// \p ScalarIn is the scalar accumulator input to start the sequential
+  /// reduction operation of \p VecIn.
+  MachineInstrBuilder buildVecReduceSeqFAdd(const DstOp &Dst,
+                                            const SrcOp &ScalarIn,
+                                            const SrcOp &VecIn) {
+    return buildInstr(TargetOpcode::G_VECREDUCE_SEQ_FADD, {Dst},
+                      {ScalarIn, {VecIn}});
+  }
+
+  /// Build and insert \p Res = G_VECREDUCE_SEQ_FMUL \p ScalarIn, \p VecIn
+  ///
+  /// \p ScalarIn is the scalar accumulator input to start the sequential
+  /// reduction operation of \p VecIn.
+  MachineInstrBuilder buildVecReduceSeqFMul(const DstOp &Dst,
+                                            const SrcOp &ScalarIn,
+                                            const SrcOp &VecIn) {
+    return buildInstr(TargetOpcode::G_VECREDUCE_SEQ_FMUL, {Dst},
+                      {ScalarIn, {VecIn}});
+  }
+
+  /// Build and insert \p Res = G_VECREDUCE_FADD \p Src
+  ///
+  /// \p ScalarIn is the scalar accumulator input to the reduction operation of
+  /// \p VecIn.
+  MachineInstrBuilder buildVecReduceFAdd(const DstOp &Dst,
+                                         const SrcOp &ScalarIn,
+                                         const SrcOp &VecIn) {
+    return buildInstr(TargetOpcode::G_VECREDUCE_FADD, {Dst}, {ScalarIn, VecIn});
+  }
+
+  /// Build and insert \p Res = G_VECREDUCE_FMUL \p Src
+  ///
+  /// \p ScalarIn is the scalar accumulator input to the reduction operation of
+  /// \p VecIn.
+  MachineInstrBuilder buildVecReduceFMul(const DstOp &Dst,
+                                         const SrcOp &ScalarIn,
+                                         const SrcOp &VecIn) {
+    return buildInstr(TargetOpcode::G_VECREDUCE_FMUL, {Dst}, {ScalarIn, VecIn});
+  }
+
+  /// Build and insert \p Res = G_VECREDUCE_FMAX \p Src
+  MachineInstrBuilder buildVecReduceFMax(const DstOp &Dst, const SrcOp &Src) {
+    return buildInstr(TargetOpcode::G_VECREDUCE_FMAX, {Dst}, {Src});
+  }
+
+  /// Build and insert \p Res = G_VECREDUCE_FMIN \p Src
+  MachineInstrBuilder buildVecReduceFMin(const DstOp &Dst, const SrcOp &Src) {
+    return buildInstr(TargetOpcode::G_VECREDUCE_FMIN, {Dst}, {Src});
+  }
+  /// Build and insert \p Res = G_VECREDUCE_ADD \p Src
+  MachineInstrBuilder buildVecReduceAdd(const DstOp &Dst, const SrcOp &Src) {
+    return buildInstr(TargetOpcode::G_VECREDUCE_ADD, {Dst}, {Src});
+  }
+
+  /// Build and insert \p Res = G_VECREDUCE_MUL \p Src
+  MachineInstrBuilder buildVecReduceMul(const DstOp &Dst, const SrcOp &Src) {
+    return buildInstr(TargetOpcode::G_VECREDUCE_MUL, {Dst}, {Src});
+  }
+
+  /// Build and insert \p Res = G_VECREDUCE_AND \p Src
+  MachineInstrBuilder buildVecReduceAnd(const DstOp &Dst, const SrcOp &Src) {
+    return buildInstr(TargetOpcode::G_VECREDUCE_AND, {Dst}, {Src});
+  }
+
+  /// Build and insert \p Res = G_VECREDUCE_OR \p Src
+  MachineInstrBuilder buildVecReduceOr(const DstOp &Dst, const SrcOp &Src) {
+    return buildInstr(TargetOpcode::G_VECREDUCE_OR, {Dst}, {Src});
+  }
+
+  /// Build and insert \p Res = G_VECREDUCE_XOR \p Src
+  MachineInstrBuilder buildVecReduceXor(const DstOp &Dst, const SrcOp &Src) {
+    return buildInstr(TargetOpcode::G_VECREDUCE_XOR, {Dst}, {Src});
+  }
+
+  /// Build and insert \p Res = G_VECREDUCE_SMAX \p Src
+  MachineInstrBuilder buildVecReduceSMax(const DstOp &Dst, const SrcOp &Src) {
+    return buildInstr(TargetOpcode::G_VECREDUCE_SMAX, {Dst}, {Src});
+  }
+
+  /// Build and insert \p Res = G_VECREDUCE_SMIN \p Src
+  MachineInstrBuilder buildVecReduceSMin(const DstOp &Dst, const SrcOp &Src) {
+    return buildInstr(TargetOpcode::G_VECREDUCE_SMIN, {Dst}, {Src});
+  }
+
+  /// Build and insert \p Res = G_VECREDUCE_UMAX \p Src
+  MachineInstrBuilder buildVecReduceUMax(const DstOp &Dst, const SrcOp &Src) {
+    return buildInstr(TargetOpcode::G_VECREDUCE_UMAX, {Dst}, {Src});
+  }
+
+  /// Build and insert \p Res = G_VECREDUCE_UMIN \p Src
+  MachineInstrBuilder buildVecReduceUMin(const DstOp &Dst, const SrcOp &Src) {
+    return buildInstr(TargetOpcode::G_VECREDUCE_UMIN, {Dst}, {Src});
+  }
   virtual MachineInstrBuilder buildInstr(unsigned Opc, ArrayRef<DstOp> DstOps,
                                          ArrayRef<SrcOp> SrcOps,
                                          Optional<unsigned> Flags = None);
diff --git a/linux-x64/clang/include/llvm/CodeGen/GlobalISel/RegisterBankInfo.h b/linux-x64/clang/include/llvm/CodeGen/GlobalISel/RegisterBankInfo.h
index e84b1c3..da78540 100644
--- a/linux-x64/clang/include/llvm/CodeGen/GlobalISel/RegisterBankInfo.h
+++ b/linux-x64/clang/include/llvm/CodeGen/GlobalISel/RegisterBankInfo.h
@@ -20,6 +20,7 @@
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/CodeGen/Register.h"
 #include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/LowLevelTypeImpl.h"
 #include <cassert>
 #include <initializer_list>
 #include <memory>
@@ -103,36 +104,37 @@
   /// Currently the TableGen-like file would look like:
   /// \code
   /// PartialMapping[] = {
-  /// /*32-bit add*/    {0, 32, GPR}, // Scalar entry repeated for first vec elt.
-  /// /*2x32-bit add*/  {0, 32, GPR}, {32, 32, GPR},
-  /// /*<2x32-bit> vadd {0, 64, VPR}
+  /// /*32-bit add*/      {0, 32, GPR}, // Scalar entry repeated for first
+  ///                                   // vec elt.
+  /// /*2x32-bit add*/    {0, 32, GPR}, {32, 32, GPR},
+  /// /*<2x32-bit> vadd*/ {0, 64, VPR}
   /// }; // PartialMapping duplicated.
   ///
   /// ValueMapping[] {
-  ///   /*plain 32-bit add*/ {&PartialMapping[0], 1},
+  ///   /*plain 32-bit add*/       {&PartialMapping[0], 1},
   ///   /*expanded vadd on 2xadd*/ {&PartialMapping[1], 2},
-  ///   /*plain <2x32-bit> vadd*/ {&PartialMapping[3], 1}
+  ///   /*plain <2x32-bit> vadd*/  {&PartialMapping[3], 1}
   /// };
   /// \endcode
   ///
   /// With the array of pointer, we would have:
   /// \code
   /// PartialMapping[] = {
-  /// /*32-bit add lower */ {0, 32, GPR},
+  /// /*32-bit add lower */ { 0, 32, GPR},
   /// /*32-bit add upper */ {32, 32, GPR},
-  /// /*<2x32-bit> vadd {0, 64, VPR}
+  /// /*<2x32-bit> vadd */  { 0, 64, VPR}
   /// }; // No more duplication.
   ///
   /// BreakDowns[] = {
-  /// /*AddBreakDown*/ &PartialMapping[0],
+  /// /*AddBreakDown*/   &PartialMapping[0],
   /// /*2xAddBreakDown*/ &PartialMapping[0], &PartialMapping[1],
-  /// /*VAddBreakDown*/ &PartialMapping[2]
+  /// /*VAddBreakDown*/  &PartialMapping[2]
   /// }; // Addresses of PartialMapping duplicated (smaller).
   ///
   /// ValueMapping[] {
-  ///   /*plain 32-bit add*/ {&BreakDowns[0], 1},
+  ///   /*plain 32-bit add*/       {&BreakDowns[0], 1},
   ///   /*expanded vadd on 2xadd*/ {&BreakDowns[1], 2},
-  ///   /*plain <2x32-bit> vadd*/ {&BreakDowns[3], 1}
+  ///   /*plain <2x32-bit> vadd*/  {&BreakDowns[3], 1}
   /// };
   /// \endcode
   ///
@@ -543,7 +545,7 @@
   const RegisterBank *
   getRegBankFromConstraints(const MachineInstr &MI, unsigned OpIdx,
                             const TargetInstrInfo &TII,
-                            const TargetRegisterInfo &TRI) const;
+                            const MachineRegisterInfo &MRI) const;
 
   /// Helper method to apply something that is like the default mapping.
   /// Basically, that means that \p OpdMapper.getMI() is left untouched
@@ -599,7 +601,7 @@
   ///
   /// \todo This should be TableGen'ed.
   virtual const RegisterBank &
-  getRegBankFromRegClass(const TargetRegisterClass &RC) const {
+  getRegBankFromRegClass(const TargetRegisterClass &RC, LLT Ty) const {
     llvm_unreachable("The target must override this method");
   }
 
diff --git a/linux-x64/clang/include/llvm/CodeGen/GlobalISel/Types.h b/linux-x64/clang/include/llvm/CodeGen/GlobalISel/Types.h
deleted file mode 100644
index 4fd7043..0000000
--- a/linux-x64/clang/include/llvm/CodeGen/GlobalISel/Types.h
+++ /dev/null
@@ -1,33 +0,0 @@
-//===- llvm/CodeGen/GlobalISel/Types.h - Types used by GISel ----*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-///
-/// \file
-/// This file describes high level types that are used by several passes or
-/// APIs involved in the GlobalISel pipeline.
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_CODEGEN_GLOBALISEL_TYPES_H
-#define LLVM_CODEGEN_GLOBALISEL_TYPES_H
-
-#include "llvm/ADT/DenseMap.h"
-
-namespace llvm {
-
-class Value;
-
-/// Map a value to a virtual register.
-/// For now, we chose to map aggregate types to on single virtual
-/// register. This might be revisited if it turns out to be inefficient.
-/// PR26161 tracks that.
-/// Note: We need to expose this type to the target hooks for thing like
-/// ABI lowering that would be used during IRTranslation.
-using ValueToVReg = DenseMap<const Value *, unsigned>;
-
-} // end namespace llvm
-
-#endif // LLVM_CODEGEN_GLOBALISEL_TYPES_H
diff --git a/linux-x64/clang/include/llvm/CodeGen/GlobalISel/Utils.h b/linux-x64/clang/include/llvm/CodeGen/GlobalISel/Utils.h
index 6946aad..9bd5180 100644
--- a/linux-x64/clang/include/llvm/CodeGen/GlobalISel/Utils.h
+++ b/linux-x64/clang/include/llvm/CodeGen/GlobalISel/Utils.h
@@ -16,23 +16,28 @@
 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/CodeGen/Register.h"
+#include "llvm/Support/Alignment.h"
+#include "llvm/Support/LowLevelTypeImpl.h"
+#include <cstdint>
 
 namespace llvm {
 
 class AnalysisUsage;
+class GISelKnownBits;
 class MachineFunction;
 class MachineInstr;
 class MachineOperand;
 class MachineOptimizationRemarkEmitter;
 class MachineOptimizationRemarkMissed;
+struct MachinePointerInfo;
 class MachineRegisterInfo;
 class MCInstrDesc;
 class RegisterBankInfo;
 class TargetInstrInfo;
+class TargetLowering;
 class TargetPassConfig;
 class TargetRegisterInfo;
 class TargetRegisterClass;
-class Twine;
 class ConstantFP;
 class APFloat;
 
@@ -40,9 +45,9 @@
 /// create a new virtual register in the correct class.
 ///
 /// \return The virtual register constrained to the right register class.
-unsigned constrainRegToClass(MachineRegisterInfo &MRI,
+Register constrainRegToClass(MachineRegisterInfo &MRI,
                              const TargetInstrInfo &TII,
-                             const RegisterBankInfo &RBI, unsigned Reg,
+                             const RegisterBankInfo &RBI, Register Reg,
                              const TargetRegisterClass &RegClass);
 
 /// Constrain the Register operand OpIdx, so that it is now constrained to the
@@ -52,14 +57,14 @@
 /// definition. The debug location of \p InsertPt is used for the new copy.
 ///
 /// \return The virtual register constrained to the right register class.
-unsigned constrainOperandRegClass(const MachineFunction &MF,
+Register constrainOperandRegClass(const MachineFunction &MF,
                                   const TargetRegisterInfo &TRI,
                                   MachineRegisterInfo &MRI,
                                   const TargetInstrInfo &TII,
                                   const RegisterBankInfo &RBI,
                                   MachineInstr &InsertPt,
                                   const TargetRegisterClass &RegClass,
-                                  const MachineOperand &RegMO, unsigned OpIdx);
+                                  const MachineOperand &RegMO);
 
 /// Try to constrain Reg so that it is usable by argument OpIdx of the
 /// provided MCInstrDesc \p II. If this fails, create a new virtual
@@ -70,7 +75,7 @@
 /// InsertPt is used for the new copy.
 ///
 /// \return The virtual register constrained to the right register class.
-unsigned constrainOperandRegClass(const MachineFunction &MF,
+Register constrainOperandRegClass(const MachineFunction &MF,
                                   const TargetRegisterInfo &TRI,
                                   MachineRegisterInfo &MRI,
                                   const TargetInstrInfo &TII,
@@ -91,6 +96,11 @@
                                       const TargetInstrInfo &TII,
                                       const TargetRegisterInfo &TRI,
                                       const RegisterBankInfo &RBI);
+
+/// Check if DstReg can be replaced with SrcReg depending on the register
+/// constraints.
+bool canReplaceReg(Register DstReg, Register SrcReg, MachineRegisterInfo &MRI);
+
 /// Check whether an instruction \p MI is dead: it only defines dead virtual
 /// registers, and doesn't have other side effects.
 bool isTriviallyDead(const MachineInstr &MI, const MachineRegisterInfo &MRI);
@@ -106,26 +116,39 @@
                         const char *PassName, StringRef Msg,
                         const MachineInstr &MI);
 
+/// Report an ISel warning as a missed optimization remark to the LLVMContext's
+/// diagnostic stream.
+void reportGISelWarning(MachineFunction &MF, const TargetPassConfig &TPC,
+                        MachineOptimizationRemarkEmitter &MORE,
+                        MachineOptimizationRemarkMissed &R);
+
+/// If \p VReg is defined by a G_CONSTANT, return the corresponding value.
+Optional<APInt> getConstantVRegVal(Register VReg,
+                                   const MachineRegisterInfo &MRI);
+
 /// If \p VReg is defined by a G_CONSTANT fits in int64_t
 /// returns it.
-Optional<int64_t> getConstantVRegVal(unsigned VReg,
-                                     const MachineRegisterInfo &MRI);
+Optional<int64_t> getConstantVRegSExtVal(Register VReg,
+                                         const MachineRegisterInfo &MRI);
+
 /// Simple struct used to hold a constant integer value and a virtual
 /// register.
 struct ValueAndVReg {
-  int64_t Value;
-  unsigned VReg;
+  APInt Value;
+  Register VReg;
 };
 /// If \p VReg is defined by a statically evaluable chain of
-/// instructions rooted on a G_CONSTANT (\p LookThroughInstrs == true)
-/// and that constant fits in int64_t, returns its value as well as
-/// the virtual register defined by this G_CONSTANT.
-/// When \p LookThroughInstrs == false, this function behaves like
+/// instructions rooted on a G_F/CONSTANT (\p LookThroughInstrs == true)
+/// and that constant fits in int64_t, returns its value as well as the
+/// virtual register defined by this G_F/CONSTANT.
+/// When \p LookThroughInstrs == false this function behaves like
 /// getConstantVRegVal.
+/// When \p HandleFConstants == false the function bails on G_FCONSTANTs.
 Optional<ValueAndVReg>
-getConstantVRegValWithLookThrough(unsigned VReg, const MachineRegisterInfo &MRI,
-                                  bool LookThroughInstrs = true);
-const ConstantFP* getConstantFPVRegVal(unsigned VReg,
+getConstantVRegValWithLookThrough(Register VReg, const MachineRegisterInfo &MRI,
+                                  bool LookThroughInstrs = true,
+                                  bool HandleFConstants = true);
+const ConstantFP* getConstantFPVRegVal(Register VReg,
                                        const MachineRegisterInfo &MRI);
 
 /// See if Reg is defined by an single def instruction that is
@@ -134,12 +157,30 @@
 MachineInstr *getOpcodeDef(unsigned Opcode, Register Reg,
                            const MachineRegisterInfo &MRI);
 
-/// Find the def instruction for \p Reg, folding away any trivial copies. Note
-/// it may still return a COPY, if it changes the type. May return nullptr if \p
-/// Reg is not a generic virtual register.
+/// Simple struct used to hold a Register value and the instruction which
+/// defines it.
+struct DefinitionAndSourceRegister {
+  MachineInstr *MI;
+  Register Reg;
+};
+
+/// Find the def instruction for \p Reg, and underlying value Register folding
+/// away any copies.
+Optional<DefinitionAndSourceRegister>
+getDefSrcRegIgnoringCopies(Register Reg, const MachineRegisterInfo &MRI);
+
+/// Find the def instruction for \p Reg, folding away any trivial copies. May
+/// return nullptr if \p Reg is not a generic virtual register.
 MachineInstr *getDefIgnoringCopies(Register Reg,
                                    const MachineRegisterInfo &MRI);
 
+/// Find the source register for \p Reg, folding away any trivial copies. It
+/// will be an output register of the instruction that getDefIgnoringCopies
+/// returns. May return an invalid register if \p Reg is not a generic virtual
+/// register.
+Register getSrcRegIgnoringCopies(Register Reg,
+                                 const MachineRegisterInfo &MRI);
+
 /// Returns an APFloat from Val converted to the appropriate size.
 APFloat getAPFloatFromSize(double Val, unsigned Size);
 
@@ -147,8 +188,90 @@
 /// fallback.
 void getSelectionDAGFallbackAnalysisUsage(AnalysisUsage &AU);
 
-Optional<APInt> ConstantFoldBinOp(unsigned Opcode, const unsigned Op1,
-                                  const unsigned Op2,
+Optional<APInt> ConstantFoldBinOp(unsigned Opcode, const Register Op1,
+                                  const Register Op2,
                                   const MachineRegisterInfo &MRI);
+
+Optional<APInt> ConstantFoldExtOp(unsigned Opcode, const Register Op1,
+                                  uint64_t Imm, const MachineRegisterInfo &MRI);
+
+/// Test if the given value is known to have exactly one bit set. This differs
+/// from computeKnownBits in that it doesn't necessarily determine which bit is
+/// set.
+bool isKnownToBeAPowerOfTwo(Register Val, const MachineRegisterInfo &MRI,
+                            GISelKnownBits *KnownBits = nullptr);
+
+/// Returns true if \p Val can be assumed to never be a NaN. If \p SNaN is true,
+/// this returns if \p Val can be assumed to never be a signaling NaN.
+bool isKnownNeverNaN(Register Val, const MachineRegisterInfo &MRI,
+                     bool SNaN = false);
+
+/// Returns true if \p Val can be assumed to never be a signaling NaN.
+inline bool isKnownNeverSNaN(Register Val, const MachineRegisterInfo &MRI) {
+  return isKnownNeverNaN(Val, MRI, true);
+}
+
+Align inferAlignFromPtrInfo(MachineFunction &MF, const MachinePointerInfo &MPO);
+
+/// Return a virtual register corresponding to the incoming argument register \p
+/// PhysReg. This register is expected to have class \p RC, and optional type \p
+/// RegTy. This assumes all references to the register will use the same type.
+///
+/// If there is an existing live-in argument register, it will be returned.
+/// This will also ensure there is a valid copy
+Register getFunctionLiveInPhysReg(MachineFunction &MF, const TargetInstrInfo &TII,
+                                  MCRegister PhysReg,
+                                  const TargetRegisterClass &RC,
+                                  LLT RegTy = LLT());
+
+/// Return the least common multiple type of \p OrigTy and \p TargetTy, by changing the
+/// number of vector elements or scalar bitwidth. The intent is a
+/// G_MERGE_VALUES, G_BUILD_VECTOR, or G_CONCAT_VECTORS can be constructed from
+/// \p OrigTy elements, and unmerged into \p TargetTy
+LLVM_READNONE
+LLT getLCMType(LLT OrigTy, LLT TargetTy);
+
+/// Return a type where the total size is the greatest common divisor of \p
+/// OrigTy and \p TargetTy. This will try to either change the number of vector
+/// elements, or bitwidth of scalars. The intent is the result type can be used
+/// as the result of a G_UNMERGE_VALUES from \p OrigTy, and then some
+/// combination of G_MERGE_VALUES, G_BUILD_VECTOR and G_CONCAT_VECTORS (possibly
+/// with intermediate casts) can re-form \p TargetTy.
+///
+/// If these are vectors with different element types, this will try to produce
+/// a vector with a compatible total size, but the element type of \p OrigTy. If
+/// this can't be satisfied, this will produce a scalar smaller than the
+/// original vector elements.
+///
+/// In the worst case, this returns LLT::scalar(1)
+LLVM_READNONE
+LLT getGCDType(LLT OrigTy, LLT TargetTy);
+
+/// \returns The splat index of a G_SHUFFLE_VECTOR \p MI when \p MI is a splat.
+/// If \p MI is not a splat, returns None.
+Optional<int> getSplatIndex(MachineInstr &MI);
+
+/// Returns a scalar constant of a G_BUILD_VECTOR splat if it exists.
+Optional<int64_t> getBuildVectorConstantSplat(const MachineInstr &MI,
+                                              const MachineRegisterInfo &MRI);
+
+/// Return true if the specified instruction is a G_BUILD_VECTOR or
+/// G_BUILD_VECTOR_TRUNC where all of the elements are 0 or undef.
+bool isBuildVectorAllZeros(const MachineInstr &MI,
+                           const MachineRegisterInfo &MRI);
+
+/// Return true if the specified instruction is a G_BUILD_VECTOR or
+/// G_BUILD_VECTOR_TRUNC where all of the elements are ~0 or undef.
+bool isBuildVectorAllOnes(const MachineInstr &MI,
+                          const MachineRegisterInfo &MRI);
+
+/// Returns true if given the TargetLowering's boolean contents information,
+/// the value \p Val contains a true value.
+bool isConstTrueVal(const TargetLowering &TLI, int64_t Val, bool IsVector,
+                    bool IsFP);
+
+/// Returns an integer representing true, as defined by the
+/// TargetBooleanContents.
+int64_t getICmpTrueVal(const TargetLowering &TLI, bool IsVector, bool IsFP);
 } // End namespace llvm.
 #endif
diff --git a/linux-x64/clang/include/llvm/CodeGen/ISDOpcodes.h b/linux-x64/clang/include/llvm/CodeGen/ISDOpcodes.h
index acf27dc..5358b15 100644
--- a/linux-x64/clang/include/llvm/CodeGen/ISDOpcodes.h
+++ b/linux-x64/clang/include/llvm/CodeGen/ISDOpcodes.h
@@ -13,6 +13,8 @@
 #ifndef LLVM_CODEGEN_ISDOPCODES_H
 #define LLVM_CODEGEN_ISDOPCODES_H
 
+#include "llvm/CodeGen/ValueTypes.h"
+
 namespace llvm {
 
 /// ISD namespace - This namespace contains an enum which represents all of the
@@ -20,1055 +22,1358 @@
 ///
 namespace ISD {
 
-  //===--------------------------------------------------------------------===//
-  /// ISD::NodeType enum - This enum defines the target-independent operators
-  /// for a SelectionDAG.
+//===--------------------------------------------------------------------===//
+/// ISD::NodeType enum - This enum defines the target-independent operators
+/// for a SelectionDAG.
+///
+/// Targets may also define target-dependent operator codes for SDNodes. For
+/// example, on x86, these are the enum values in the X86ISD namespace.
+/// Targets should aim to use target-independent operators to model their
+/// instruction sets as much as possible, and only use target-dependent
+/// operators when they have special requirements.
+///
+/// Finally, during and after selection proper, SNodes may use special
+/// operator codes that correspond directly with MachineInstr opcodes. These
+/// are used to represent selected instructions. See the isMachineOpcode()
+/// and getMachineOpcode() member functions of SDNode.
+///
+enum NodeType {
+
+  /// DELETED_NODE - This is an illegal value that is used to catch
+  /// errors.  This opcode is not a legal opcode for any node.
+  DELETED_NODE,
+
+  /// EntryToken - This is the marker used to indicate the start of a region.
+  EntryToken,
+
+  /// TokenFactor - This node takes multiple tokens as input and produces a
+  /// single token result. This is used to represent the fact that the operand
+  /// operators are independent of each other.
+  TokenFactor,
+
+  /// AssertSext, AssertZext - These nodes record if a register contains a
+  /// value that has already been zero or sign extended from a narrower type.
+  /// These nodes take two operands.  The first is the node that has already
+  /// been extended, and the second is a value type node indicating the width
+  /// of the extension
+  AssertSext,
+  AssertZext,
+  AssertAlign,
+
+  /// Various leaf nodes.
+  BasicBlock,
+  VALUETYPE,
+  CONDCODE,
+  Register,
+  RegisterMask,
+  Constant,
+  ConstantFP,
+  GlobalAddress,
+  GlobalTLSAddress,
+  FrameIndex,
+  JumpTable,
+  ConstantPool,
+  ExternalSymbol,
+  BlockAddress,
+
+  /// The address of the GOT
+  GLOBAL_OFFSET_TABLE,
+
+  /// FRAMEADDR, RETURNADDR - These nodes represent llvm.frameaddress and
+  /// llvm.returnaddress on the DAG.  These nodes take one operand, the index
+  /// of the frame or return address to return.  An index of zero corresponds
+  /// to the current function's frame or return address, an index of one to
+  /// the parent's frame or return address, and so on.
+  FRAMEADDR,
+  RETURNADDR,
+
+  /// ADDROFRETURNADDR - Represents the llvm.addressofreturnaddress intrinsic.
+  /// This node takes no operand, returns a target-specific pointer to the
+  /// place in the stack frame where the return address of the current
+  /// function is stored.
+  ADDROFRETURNADDR,
+
+  /// SPONENTRY - Represents the llvm.sponentry intrinsic. Takes no argument
+  /// and returns the stack pointer value at the entry of the current
+  /// function calling this intrinsic.
+  SPONENTRY,
+
+  /// LOCAL_RECOVER - Represents the llvm.localrecover intrinsic.
+  /// Materializes the offset from the local object pointer of another
+  /// function to a particular local object passed to llvm.localescape. The
+  /// operand is the MCSymbol label used to represent this offset, since
+  /// typically the offset is not known until after code generation of the
+  /// parent.
+  LOCAL_RECOVER,
+
+  /// READ_REGISTER, WRITE_REGISTER - This node represents llvm.register on
+  /// the DAG, which implements the named register global variables extension.
+  READ_REGISTER,
+  WRITE_REGISTER,
+
+  /// FRAME_TO_ARGS_OFFSET - This node represents offset from frame pointer to
+  /// first (possible) on-stack argument. This is needed for correct stack
+  /// adjustment during unwind.
+  FRAME_TO_ARGS_OFFSET,
+
+  /// EH_DWARF_CFA - This node represents the pointer to the DWARF Canonical
+  /// Frame Address (CFA), generally the value of the stack pointer at the
+  /// call site in the previous frame.
+  EH_DWARF_CFA,
+
+  /// OUTCHAIN = EH_RETURN(INCHAIN, OFFSET, HANDLER) - This node represents
+  /// 'eh_return' gcc dwarf builtin, which is used to return from
+  /// exception. The general meaning is: adjust stack by OFFSET and pass
+  /// execution to HANDLER. Many platform-related details also :)
+  EH_RETURN,
+
+  /// RESULT, OUTCHAIN = EH_SJLJ_SETJMP(INCHAIN, buffer)
+  /// This corresponds to the eh.sjlj.setjmp intrinsic.
+  /// It takes an input chain and a pointer to the jump buffer as inputs
+  /// and returns an outchain.
+  EH_SJLJ_SETJMP,
+
+  /// OUTCHAIN = EH_SJLJ_LONGJMP(INCHAIN, buffer)
+  /// This corresponds to the eh.sjlj.longjmp intrinsic.
+  /// It takes an input chain and a pointer to the jump buffer as inputs
+  /// and returns an outchain.
+  EH_SJLJ_LONGJMP,
+
+  /// OUTCHAIN = EH_SJLJ_SETUP_DISPATCH(INCHAIN)
+  /// The target initializes the dispatch table here.
+  EH_SJLJ_SETUP_DISPATCH,
+
+  /// TargetConstant* - Like Constant*, but the DAG does not do any folding,
+  /// simplification, or lowering of the constant. They are used for constants
+  /// which are known to fit in the immediate fields of their users, or for
+  /// carrying magic numbers which are not values which need to be
+  /// materialized in registers.
+  TargetConstant,
+  TargetConstantFP,
+
+  /// TargetGlobalAddress - Like GlobalAddress, but the DAG does no folding or
+  /// anything else with this node, and this is valid in the target-specific
+  /// dag, turning into a GlobalAddress operand.
+  TargetGlobalAddress,
+  TargetGlobalTLSAddress,
+  TargetFrameIndex,
+  TargetJumpTable,
+  TargetConstantPool,
+  TargetExternalSymbol,
+  TargetBlockAddress,
+
+  MCSymbol,
+
+  /// TargetIndex - Like a constant pool entry, but with completely
+  /// target-dependent semantics. Holds target flags, a 32-bit index, and a
+  /// 64-bit index. Targets can use this however they like.
+  TargetIndex,
+
+  /// RESULT = INTRINSIC_WO_CHAIN(INTRINSICID, arg1, arg2, ...)
+  /// This node represents a target intrinsic function with no side effects.
+  /// The first operand is the ID number of the intrinsic from the
+  /// llvm::Intrinsic namespace.  The operands to the intrinsic follow.  The
+  /// node returns the result of the intrinsic.
+  INTRINSIC_WO_CHAIN,
+
+  /// RESULT,OUTCHAIN = INTRINSIC_W_CHAIN(INCHAIN, INTRINSICID, arg1, ...)
+  /// This node represents a target intrinsic function with side effects that
+  /// returns a result.  The first operand is a chain pointer.  The second is
+  /// the ID number of the intrinsic from the llvm::Intrinsic namespace.  The
+  /// operands to the intrinsic follow.  The node has two results, the result
+  /// of the intrinsic and an output chain.
+  INTRINSIC_W_CHAIN,
+
+  /// OUTCHAIN = INTRINSIC_VOID(INCHAIN, INTRINSICID, arg1, arg2, ...)
+  /// This node represents a target intrinsic function with side effects that
+  /// does not return a result.  The first operand is a chain pointer.  The
+  /// second is the ID number of the intrinsic from the llvm::Intrinsic
+  /// namespace.  The operands to the intrinsic follow.
+  INTRINSIC_VOID,
+
+  /// CopyToReg - This node has three operands: a chain, a register number to
+  /// set to this value, and a value.
+  CopyToReg,
+
+  /// CopyFromReg - This node indicates that the input value is a virtual or
+  /// physical register that is defined outside of the scope of this
+  /// SelectionDAG.  The register is available from the RegisterSDNode object.
+  CopyFromReg,
+
+  /// UNDEF - An undefined node.
+  UNDEF,
+
+  // FREEZE - FREEZE(VAL) returns an arbitrary value if VAL is UNDEF (or
+  // is evaluated to UNDEF), or returns VAL otherwise. Note that each
+  // read of UNDEF can yield different value, but FREEZE(UNDEF) cannot.
+  FREEZE,
+
+  /// EXTRACT_ELEMENT - This is used to get the lower or upper (determined by
+  /// a Constant, which is required to be operand #1) half of the integer or
+  /// float value specified as operand #0.  This is only for use before
+  /// legalization, for values that will be broken into multiple registers.
+  EXTRACT_ELEMENT,
+
+  /// BUILD_PAIR - This is the opposite of EXTRACT_ELEMENT in some ways.
+  /// Given two values of the same integer value type, this produces a value
+  /// twice as big.  Like EXTRACT_ELEMENT, this can only be used before
+  /// legalization. The lower part of the composite value should be in
+  /// element 0 and the upper part should be in element 1.
+  BUILD_PAIR,
+
+  /// MERGE_VALUES - This node takes multiple discrete operands and returns
+  /// them all as its individual results.  This nodes has exactly the same
+  /// number of inputs and outputs. This node is useful for some pieces of the
+  /// code generator that want to think about a single node with multiple
+  /// results, not multiple nodes.
+  MERGE_VALUES,
+
+  /// Simple integer binary arithmetic operators.
+  ADD,
+  SUB,
+  MUL,
+  SDIV,
+  UDIV,
+  SREM,
+  UREM,
+
+  /// SMUL_LOHI/UMUL_LOHI - Multiply two integers of type iN, producing
+  /// a signed/unsigned value of type i[2*N], and return the full value as
+  /// two results, each of type iN.
+  SMUL_LOHI,
+  UMUL_LOHI,
+
+  /// SDIVREM/UDIVREM - Divide two integers and produce both a quotient and
+  /// remainder result.
+  SDIVREM,
+  UDIVREM,
+
+  /// CARRY_FALSE - This node is used when folding other nodes,
+  /// like ADDC/SUBC, which indicate the carry result is always false.
+  CARRY_FALSE,
+
+  /// Carry-setting nodes for multiple precision addition and subtraction.
+  /// These nodes take two operands of the same value type, and produce two
+  /// results.  The first result is the normal add or sub result, the second
+  /// result is the carry flag result.
+  /// FIXME: These nodes are deprecated in favor of ADDCARRY and SUBCARRY.
+  /// They are kept around for now to provide a smooth transition path
+  /// toward the use of ADDCARRY/SUBCARRY and will eventually be removed.
+  ADDC,
+  SUBC,
+
+  /// Carry-using nodes for multiple precision addition and subtraction. These
+  /// nodes take three operands: The first two are the normal lhs and rhs to
+  /// the add or sub, and the third is the input carry flag.  These nodes
+  /// produce two results; the normal result of the add or sub, and the output
+  /// carry flag.  These nodes both read and write a carry flag to allow them
+  /// to them to be chained together for add and sub of arbitrarily large
+  /// values.
+  ADDE,
+  SUBE,
+
+  /// Carry-using nodes for multiple precision addition and subtraction.
+  /// These nodes take three operands: The first two are the normal lhs and
+  /// rhs to the add or sub, and the third is a boolean indicating if there
+  /// is an incoming carry. These nodes produce two results: the normal
+  /// result of the add or sub, and the output carry so they can be chained
+  /// together. The use of this opcode is preferable to adde/sube if the
+  /// target supports it, as the carry is a regular value rather than a
+  /// glue, which allows further optimisation.
+  ADDCARRY,
+  SUBCARRY,
+
+  /// Carry-using overflow-aware nodes for multiple precision addition and
+  /// subtraction. These nodes take three operands: The first two are normal lhs
+  /// and rhs to the add or sub, and the third is a boolean indicating if there
+  /// is an incoming carry. They produce two results: the normal result of the
+  /// add or sub, and a boolean that indicates if an overflow occured (*not*
+  /// flag, because it may be a store to memory, etc.). If the type of the
+  /// boolean is not i1 then the high bits conform to getBooleanContents.
+  SADDO_CARRY,
+  SSUBO_CARRY,
+
+  /// RESULT, BOOL = [SU]ADDO(LHS, RHS) - Overflow-aware nodes for addition.
+  /// These nodes take two operands: the normal LHS and RHS to the add. They
+  /// produce two results: the normal result of the add, and a boolean that
+  /// indicates if an overflow occurred (*not* a flag, because it may be store
+  /// to memory, etc.).  If the type of the boolean is not i1 then the high
+  /// bits conform to getBooleanContents.
+  /// These nodes are generated from llvm.[su]add.with.overflow intrinsics.
+  SADDO,
+  UADDO,
+
+  /// Same for subtraction.
+  SSUBO,
+  USUBO,
+
+  /// Same for multiplication.
+  SMULO,
+  UMULO,
+
+  /// RESULT = [US]ADDSAT(LHS, RHS) - Perform saturation addition on 2
+  /// integers with the same bit width (W). If the true value of LHS + RHS
+  /// exceeds the largest value that can be represented by W bits, the
+  /// resulting value is this maximum value. Otherwise, if this value is less
+  /// than the smallest value that can be represented by W bits, the
+  /// resulting value is this minimum value.
+  SADDSAT,
+  UADDSAT,
+
+  /// RESULT = [US]SUBSAT(LHS, RHS) - Perform saturation subtraction on 2
+  /// integers with the same bit width (W). If the true value of LHS - RHS
+  /// exceeds the largest value that can be represented by W bits, the
+  /// resulting value is this maximum value. Otherwise, if this value is less
+  /// than the smallest value that can be represented by W bits, the
+  /// resulting value is this minimum value.
+  SSUBSAT,
+  USUBSAT,
+
+  /// RESULT = [US]SHLSAT(LHS, RHS) - Perform saturation left shift. The first
+  /// operand is the value to be shifted, and the second argument is the amount
+  /// to shift by. Both must be integers of the same bit width (W). If the true
+  /// value of LHS << RHS exceeds the largest value that can be represented by
+  /// W bits, the resulting value is this maximum value, Otherwise, if this
+  /// value is less than the smallest value that can be represented by W bits,
+  /// the resulting value is this minimum value.
+  SSHLSAT,
+  USHLSAT,
+
+  /// RESULT = [US]MULFIX(LHS, RHS, SCALE) - Perform fixed point multiplication
+  /// on
+  /// 2 integers with the same width and scale. SCALE represents the scale of
+  /// both operands as fixed point numbers. This SCALE parameter must be a
+  /// constant integer. A scale of zero is effectively performing
+  /// multiplication on 2 integers.
+  SMULFIX,
+  UMULFIX,
+
+  /// Same as the corresponding unsaturated fixed point instructions, but the
+  /// result is clamped between the min and max values representable by the
+  /// bits of the first 2 operands.
+  SMULFIXSAT,
+  UMULFIXSAT,
+
+  /// RESULT = [US]DIVFIX(LHS, RHS, SCALE) - Perform fixed point division on
+  /// 2 integers with the same width and scale. SCALE represents the scale
+  /// of both operands as fixed point numbers. This SCALE parameter must be a
+  /// constant integer.
+  SDIVFIX,
+  UDIVFIX,
+
+  /// Same as the corresponding unsaturated fixed point instructions, but the
+  /// result is clamped between the min and max values representable by the
+  /// bits of the first 2 operands.
+  SDIVFIXSAT,
+  UDIVFIXSAT,
+
+  /// Simple binary floating point operators.
+  FADD,
+  FSUB,
+  FMUL,
+  FDIV,
+  FREM,
+
+  /// Constrained versions of the binary floating point operators.
+  /// These will be lowered to the simple operators before final selection.
+  /// They are used to limit optimizations while the DAG is being
+  /// optimized.
+  STRICT_FADD,
+  STRICT_FSUB,
+  STRICT_FMUL,
+  STRICT_FDIV,
+  STRICT_FREM,
+  STRICT_FMA,
+
+  /// Constrained versions of libm-equivalent floating point intrinsics.
+  /// These will be lowered to the equivalent non-constrained pseudo-op
+  /// (or expanded to the equivalent library call) before final selection.
+  /// They are used to limit optimizations while the DAG is being optimized.
+  STRICT_FSQRT,
+  STRICT_FPOW,
+  STRICT_FPOWI,
+  STRICT_FSIN,
+  STRICT_FCOS,
+  STRICT_FEXP,
+  STRICT_FEXP2,
+  STRICT_FLOG,
+  STRICT_FLOG10,
+  STRICT_FLOG2,
+  STRICT_FRINT,
+  STRICT_FNEARBYINT,
+  STRICT_FMAXNUM,
+  STRICT_FMINNUM,
+  STRICT_FCEIL,
+  STRICT_FFLOOR,
+  STRICT_FROUND,
+  STRICT_FROUNDEVEN,
+  STRICT_FTRUNC,
+  STRICT_LROUND,
+  STRICT_LLROUND,
+  STRICT_LRINT,
+  STRICT_LLRINT,
+  STRICT_FMAXIMUM,
+  STRICT_FMINIMUM,
+
+  /// STRICT_FP_TO_[US]INT - Convert a floating point value to a signed or
+  /// unsigned integer. These have the same semantics as fptosi and fptoui
+  /// in IR.
+  /// They are used to limit optimizations while the DAG is being optimized.
+  STRICT_FP_TO_SINT,
+  STRICT_FP_TO_UINT,
+
+  /// STRICT_[US]INT_TO_FP - Convert a signed or unsigned integer to
+  /// a floating point value. These have the same semantics as sitofp and
+  /// uitofp in IR.
+  /// They are used to limit optimizations while the DAG is being optimized.
+  STRICT_SINT_TO_FP,
+  STRICT_UINT_TO_FP,
+
+  /// X = STRICT_FP_ROUND(Y, TRUNC) - Rounding 'Y' from a larger floating
+  /// point type down to the precision of the destination VT.  TRUNC is a
+  /// flag, which is always an integer that is zero or one.  If TRUNC is 0,
+  /// this is a normal rounding, if it is 1, this FP_ROUND is known to not
+  /// change the value of Y.
   ///
-  /// Targets may also define target-dependent operator codes for SDNodes. For
-  /// example, on x86, these are the enum values in the X86ISD namespace.
-  /// Targets should aim to use target-independent operators to model their
-  /// instruction sets as much as possible, and only use target-dependent
-  /// operators when they have special requirements.
+  /// The TRUNC = 1 case is used in cases where we know that the value will
+  /// not be modified by the node, because Y is not using any of the extra
+  /// precision of source type.  This allows certain transformations like
+  /// STRICT_FP_EXTEND(STRICT_FP_ROUND(X,1)) -> X which are not safe for
+  /// STRICT_FP_EXTEND(STRICT_FP_ROUND(X,0)) because the extra bits aren't
+  /// removed.
+  /// It is used to limit optimizations while the DAG is being optimized.
+  STRICT_FP_ROUND,
+
+  /// X = STRICT_FP_EXTEND(Y) - Extend a smaller FP type into a larger FP
+  /// type.
+  /// It is used to limit optimizations while the DAG is being optimized.
+  STRICT_FP_EXTEND,
+
+  /// STRICT_FSETCC/STRICT_FSETCCS - Constrained versions of SETCC, used
+  /// for floating-point operands only.  STRICT_FSETCC performs a quiet
+  /// comparison operation, while STRICT_FSETCCS performs a signaling
+  /// comparison operation.
+  STRICT_FSETCC,
+  STRICT_FSETCCS,
+
+  /// FMA - Perform a * b + c with no intermediate rounding step.
+  FMA,
+
+  /// FMAD - Perform a * b + c, while getting the same result as the
+  /// separately rounded operations.
+  FMAD,
+
+  /// FCOPYSIGN(X, Y) - Return the value of X with the sign of Y.  NOTE: This
+  /// DAG node does not require that X and Y have the same type, just that
+  /// they are both floating point.  X and the result must have the same type.
+  /// FCOPYSIGN(f32, f64) is allowed.
+  FCOPYSIGN,
+
+  /// INT = FGETSIGN(FP) - Return the sign bit of the specified floating point
+  /// value as an integer 0/1 value.
+  FGETSIGN,
+
+  /// Returns platform specific canonical encoding of a floating point number.
+  FCANONICALIZE,
+
+  /// BUILD_VECTOR(ELT0, ELT1, ELT2, ELT3,...) - Return a fixed-width vector
+  /// with the specified, possibly variable, elements. The types of the
+  /// operands must match the vector element type, except that integer types
+  /// are allowed to be larger than the element type, in which case the
+  /// operands are implicitly truncated. The types of the operands must all
+  /// be the same.
+  BUILD_VECTOR,
+
+  /// INSERT_VECTOR_ELT(VECTOR, VAL, IDX) - Returns VECTOR with the element
+  /// at IDX replaced with VAL. If the type of VAL is larger than the vector
+  /// element type then VAL is truncated before replacement.
   ///
-  /// Finally, during and after selection proper, SNodes may use special
-  /// operator codes that correspond directly with MachineInstr opcodes. These
-  /// are used to represent selected instructions. See the isMachineOpcode()
-  /// and getMachineOpcode() member functions of SDNode.
+  /// If VECTOR is a scalable vector, then IDX may be larger than the minimum
+  /// vector width. IDX is not first scaled by the runtime scaling factor of
+  /// VECTOR.
+  INSERT_VECTOR_ELT,
+
+  /// EXTRACT_VECTOR_ELT(VECTOR, IDX) - Returns a single element from VECTOR
+  /// identified by the (potentially variable) element number IDX. If the return
+  /// type is an integer type larger than the element type of the vector, the
+  /// result is extended to the width of the return type. In that case, the high
+  /// bits are undefined.
   ///
-  enum NodeType {
-    /// DELETED_NODE - This is an illegal value that is used to catch
-    /// errors.  This opcode is not a legal opcode for any node.
-    DELETED_NODE,
+  /// If VECTOR is a scalable vector, then IDX may be larger than the minimum
+  /// vector width. IDX is not first scaled by the runtime scaling factor of
+  /// VECTOR.
+  EXTRACT_VECTOR_ELT,
 
-    /// EntryToken - This is the marker used to indicate the start of a region.
-    EntryToken,
+  /// CONCAT_VECTORS(VECTOR0, VECTOR1, ...) - Given a number of values of
+  /// vector type with the same length and element type, this produces a
+  /// concatenated vector result value, with length equal to the sum of the
+  /// lengths of the input vectors. If VECTOR0 is a fixed-width vector, then
+  /// VECTOR1..VECTORN must all be fixed-width vectors. Similarly, if VECTOR0
+  /// is a scalable vector, then VECTOR1..VECTORN must all be scalable vectors.
+  CONCAT_VECTORS,
 
-    /// TokenFactor - This node takes multiple tokens as input and produces a
-    /// single token result. This is used to represent the fact that the operand
-    /// operators are independent of each other.
-    TokenFactor,
-
-    /// AssertSext, AssertZext - These nodes record if a register contains a
-    /// value that has already been zero or sign extended from a narrower type.
-    /// These nodes take two operands.  The first is the node that has already
-    /// been extended, and the second is a value type node indicating the width
-    /// of the extension
-    AssertSext, AssertZext,
-
-    /// Various leaf nodes.
-    BasicBlock, VALUETYPE, CONDCODE, Register, RegisterMask,
-    Constant, ConstantFP,
-    GlobalAddress, GlobalTLSAddress, FrameIndex,
-    JumpTable, ConstantPool, ExternalSymbol, BlockAddress,
-
-    /// The address of the GOT
-    GLOBAL_OFFSET_TABLE,
-
-    /// FRAMEADDR, RETURNADDR - These nodes represent llvm.frameaddress and
-    /// llvm.returnaddress on the DAG.  These nodes take one operand, the index
-    /// of the frame or return address to return.  An index of zero corresponds
-    /// to the current function's frame or return address, an index of one to
-    /// the parent's frame or return address, and so on.
-    FRAMEADDR, RETURNADDR, ADDROFRETURNADDR, SPONENTRY,
-
-    /// LOCAL_RECOVER - Represents the llvm.localrecover intrinsic.
-    /// Materializes the offset from the local object pointer of another
-    /// function to a particular local object passed to llvm.localescape. The
-    /// operand is the MCSymbol label used to represent this offset, since
-    /// typically the offset is not known until after code generation of the
-    /// parent.
-    LOCAL_RECOVER,
-
-    /// READ_REGISTER, WRITE_REGISTER - This node represents llvm.register on
-    /// the DAG, which implements the named register global variables extension.
-    READ_REGISTER,
-    WRITE_REGISTER,
-
-    /// FRAME_TO_ARGS_OFFSET - This node represents offset from frame pointer to
-    /// first (possible) on-stack argument. This is needed for correct stack
-    /// adjustment during unwind.
-    FRAME_TO_ARGS_OFFSET,
-
-    /// EH_DWARF_CFA - This node represents the pointer to the DWARF Canonical
-    /// Frame Address (CFA), generally the value of the stack pointer at the
-    /// call site in the previous frame.
-    EH_DWARF_CFA,
-
-    /// OUTCHAIN = EH_RETURN(INCHAIN, OFFSET, HANDLER) - This node represents
-    /// 'eh_return' gcc dwarf builtin, which is used to return from
-    /// exception. The general meaning is: adjust stack by OFFSET and pass
-    /// execution to HANDLER. Many platform-related details also :)
-    EH_RETURN,
-
-    /// RESULT, OUTCHAIN = EH_SJLJ_SETJMP(INCHAIN, buffer)
-    /// This corresponds to the eh.sjlj.setjmp intrinsic.
-    /// It takes an input chain and a pointer to the jump buffer as inputs
-    /// and returns an outchain.
-    EH_SJLJ_SETJMP,
-
-    /// OUTCHAIN = EH_SJLJ_LONGJMP(INCHAIN, buffer)
-    /// This corresponds to the eh.sjlj.longjmp intrinsic.
-    /// It takes an input chain and a pointer to the jump buffer as inputs
-    /// and returns an outchain.
-    EH_SJLJ_LONGJMP,
-
-    /// OUTCHAIN = EH_SJLJ_SETUP_DISPATCH(INCHAIN)
-    /// The target initializes the dispatch table here.
-    EH_SJLJ_SETUP_DISPATCH,
-
-    /// TargetConstant* - Like Constant*, but the DAG does not do any folding,
-    /// simplification, or lowering of the constant. They are used for constants
-    /// which are known to fit in the immediate fields of their users, or for
-    /// carrying magic numbers which are not values which need to be
-    /// materialized in registers.
-    TargetConstant,
-    TargetConstantFP,
-
-    /// TargetGlobalAddress - Like GlobalAddress, but the DAG does no folding or
-    /// anything else with this node, and this is valid in the target-specific
-    /// dag, turning into a GlobalAddress operand.
-    TargetGlobalAddress,
-    TargetGlobalTLSAddress,
-    TargetFrameIndex,
-    TargetJumpTable,
-    TargetConstantPool,
-    TargetExternalSymbol,
-    TargetBlockAddress,
-
-    MCSymbol,
-
-    /// TargetIndex - Like a constant pool entry, but with completely
-    /// target-dependent semantics. Holds target flags, a 32-bit index, and a
-    /// 64-bit index. Targets can use this however they like.
-    TargetIndex,
-
-    /// RESULT = INTRINSIC_WO_CHAIN(INTRINSICID, arg1, arg2, ...)
-    /// This node represents a target intrinsic function with no side effects.
-    /// The first operand is the ID number of the intrinsic from the
-    /// llvm::Intrinsic namespace.  The operands to the intrinsic follow.  The
-    /// node returns the result of the intrinsic.
-    INTRINSIC_WO_CHAIN,
-
-    /// RESULT,OUTCHAIN = INTRINSIC_W_CHAIN(INCHAIN, INTRINSICID, arg1, ...)
-    /// This node represents a target intrinsic function with side effects that
-    /// returns a result.  The first operand is a chain pointer.  The second is
-    /// the ID number of the intrinsic from the llvm::Intrinsic namespace.  The
-    /// operands to the intrinsic follow.  The node has two results, the result
-    /// of the intrinsic and an output chain.
-    INTRINSIC_W_CHAIN,
-
-    /// OUTCHAIN = INTRINSIC_VOID(INCHAIN, INTRINSICID, arg1, arg2, ...)
-    /// This node represents a target intrinsic function with side effects that
-    /// does not return a result.  The first operand is a chain pointer.  The
-    /// second is the ID number of the intrinsic from the llvm::Intrinsic
-    /// namespace.  The operands to the intrinsic follow.
-    INTRINSIC_VOID,
-
-    /// CopyToReg - This node has three operands: a chain, a register number to
-    /// set to this value, and a value.
-    CopyToReg,
-
-    /// CopyFromReg - This node indicates that the input value is a virtual or
-    /// physical register that is defined outside of the scope of this
-    /// SelectionDAG.  The register is available from the RegisterSDNode object.
-    CopyFromReg,
-
-    /// UNDEF - An undefined node.
-    UNDEF,
-
-    /// EXTRACT_ELEMENT - This is used to get the lower or upper (determined by
-    /// a Constant, which is required to be operand #1) half of the integer or
-    /// float value specified as operand #0.  This is only for use before
-    /// legalization, for values that will be broken into multiple registers.
-    EXTRACT_ELEMENT,
-
-    /// BUILD_PAIR - This is the opposite of EXTRACT_ELEMENT in some ways.
-    /// Given two values of the same integer value type, this produces a value
-    /// twice as big.  Like EXTRACT_ELEMENT, this can only be used before
-    /// legalization. The lower part of the composite value should be in
-    /// element 0 and the upper part should be in element 1.
-    BUILD_PAIR,
-
-    /// MERGE_VALUES - This node takes multiple discrete operands and returns
-    /// them all as its individual results.  This nodes has exactly the same
-    /// number of inputs and outputs. This node is useful for some pieces of the
-    /// code generator that want to think about a single node with multiple
-    /// results, not multiple nodes.
-    MERGE_VALUES,
-
-    /// Simple integer binary arithmetic operators.
-    ADD, SUB, MUL, SDIV, UDIV, SREM, UREM,
-
-    /// SMUL_LOHI/UMUL_LOHI - Multiply two integers of type iN, producing
-    /// a signed/unsigned value of type i[2*N], and return the full value as
-    /// two results, each of type iN.
-    SMUL_LOHI, UMUL_LOHI,
-
-    /// SDIVREM/UDIVREM - Divide two integers and produce both a quotient and
-    /// remainder result.
-    SDIVREM, UDIVREM,
-
-    /// CARRY_FALSE - This node is used when folding other nodes,
-    /// like ADDC/SUBC, which indicate the carry result is always false.
-    CARRY_FALSE,
-
-    /// Carry-setting nodes for multiple precision addition and subtraction.
-    /// These nodes take two operands of the same value type, and produce two
-    /// results.  The first result is the normal add or sub result, the second
-    /// result is the carry flag result.
-    /// FIXME: These nodes are deprecated in favor of ADDCARRY and SUBCARRY.
-    /// They are kept around for now to provide a smooth transition path
-    /// toward the use of ADDCARRY/SUBCARRY and will eventually be removed.
-    ADDC, SUBC,
-
-    /// Carry-using nodes for multiple precision addition and subtraction. These
-    /// nodes take three operands: The first two are the normal lhs and rhs to
-    /// the add or sub, and the third is the input carry flag.  These nodes
-    /// produce two results; the normal result of the add or sub, and the output
-    /// carry flag.  These nodes both read and write a carry flag to allow them
-    /// to them to be chained together for add and sub of arbitrarily large
-    /// values.
-    ADDE, SUBE,
-
-    /// Carry-using nodes for multiple precision addition and subtraction.
-    /// These nodes take three operands: The first two are the normal lhs and
-    /// rhs to the add or sub, and the third is a boolean indicating if there
-    /// is an incoming carry. These nodes produce two results: the normal
-    /// result of the add or sub, and the output carry so they can be chained
-    /// together. The use of this opcode is preferable to adde/sube if the
-    /// target supports it, as the carry is a regular value rather than a
-    /// glue, which allows further optimisation.
-    ADDCARRY, SUBCARRY,
-
-    /// RESULT, BOOL = [SU]ADDO(LHS, RHS) - Overflow-aware nodes for addition.
-    /// These nodes take two operands: the normal LHS and RHS to the add. They
-    /// produce two results: the normal result of the add, and a boolean that
-    /// indicates if an overflow occurred (*not* a flag, because it may be store
-    /// to memory, etc.).  If the type of the boolean is not i1 then the high
-    /// bits conform to getBooleanContents.
-    /// These nodes are generated from llvm.[su]add.with.overflow intrinsics.
-    SADDO, UADDO,
-
-    /// Same for subtraction.
-    SSUBO, USUBO,
-
-    /// Same for multiplication.
-    SMULO, UMULO,
-
-    /// RESULT = [US]ADDSAT(LHS, RHS) - Perform saturation addition on 2
-    /// integers with the same bit width (W). If the true value of LHS + RHS
-    /// exceeds the largest value that can be represented by W bits, the
-    /// resulting value is this maximum value. Otherwise, if this value is less
-    /// than the smallest value that can be represented by W bits, the
-    /// resulting value is this minimum value.
-    SADDSAT, UADDSAT,
-
-    /// RESULT = [US]SUBSAT(LHS, RHS) - Perform saturation subtraction on 2
-    /// integers with the same bit width (W). If the true value of LHS - RHS
-    /// exceeds the largest value that can be represented by W bits, the
-    /// resulting value is this maximum value. Otherwise, if this value is less
-    /// than the smallest value that can be represented by W bits, the
-    /// resulting value is this minimum value.
-    SSUBSAT, USUBSAT,
-
-    /// RESULT = [US]MULFIX(LHS, RHS, SCALE) - Perform fixed point multiplication on
-    /// 2 integers with the same width and scale. SCALE represents the scale of
-    /// both operands as fixed point numbers. This SCALE parameter must be a
-    /// constant integer. A scale of zero is effectively performing
-    /// multiplication on 2 integers.
-    SMULFIX, UMULFIX,
-
-    /// Same as the corresponding unsaturated fixed point instructions, but the
-    /// result is clamped between the min and max values representable by the
-    /// bits of the first 2 operands.
-    SMULFIXSAT,
-
-    /// Simple binary floating point operators.
-    FADD, FSUB, FMUL, FDIV, FREM,
-
-    /// Constrained versions of the binary floating point operators.
-    /// These will be lowered to the simple operators before final selection.
-    /// They are used to limit optimizations while the DAG is being
-    /// optimized.
-    STRICT_FADD, STRICT_FSUB, STRICT_FMUL, STRICT_FDIV, STRICT_FREM,
-    STRICT_FMA,
-
-    /// Constrained versions of libm-equivalent floating point intrinsics.
-    /// These will be lowered to the equivalent non-constrained pseudo-op
-    /// (or expanded to the equivalent library call) before final selection.
-    /// They are used to limit optimizations while the DAG is being optimized.
-    STRICT_FSQRT, STRICT_FPOW, STRICT_FPOWI, STRICT_FSIN, STRICT_FCOS,
-    STRICT_FEXP, STRICT_FEXP2, STRICT_FLOG, STRICT_FLOG10, STRICT_FLOG2,
-    STRICT_FRINT, STRICT_FNEARBYINT, STRICT_FMAXNUM, STRICT_FMINNUM,
-    STRICT_FCEIL, STRICT_FFLOOR, STRICT_FROUND, STRICT_FTRUNC,
-
-    /// X = STRICT_FP_ROUND(Y, TRUNC) - Rounding 'Y' from a larger floating 
-    /// point type down to the precision of the destination VT.  TRUNC is a 
-    /// flag, which is always an integer that is zero or one.  If TRUNC is 0,
-    /// this is a normal rounding, if it is 1, this FP_ROUND is known to not
-    /// change the value of Y.
-    ///
-    /// The TRUNC = 1 case is used in cases where we know that the value will
-    /// not be modified by the node, because Y is not using any of the extra
-    /// precision of source type.  This allows certain transformations like
-    /// STRICT_FP_EXTEND(STRICT_FP_ROUND(X,1)) -> X which are not safe for
-    /// STRICT_FP_EXTEND(STRICT_FP_ROUND(X,0)) because the extra bits aren't
-    /// removed.
-    /// It is used to limit optimizations while the DAG is being optimized.
-    STRICT_FP_ROUND,
-
-    /// X = STRICT_FP_EXTEND(Y) - Extend a smaller FP type into a larger FP
-    /// type.
-    /// It is used to limit optimizations while the DAG is being optimized.
-    STRICT_FP_EXTEND,
-
-    /// FMA - Perform a * b + c with no intermediate rounding step.
-    FMA,
-
-    /// FMAD - Perform a * b + c, while getting the same result as the
-    /// separately rounded operations.
-    FMAD,
-
-    /// FCOPYSIGN(X, Y) - Return the value of X with the sign of Y.  NOTE: This
-    /// DAG node does not require that X and Y have the same type, just that
-    /// they are both floating point.  X and the result must have the same type.
-    /// FCOPYSIGN(f32, f64) is allowed.
-    FCOPYSIGN,
-
-    /// INT = FGETSIGN(FP) - Return the sign bit of the specified floating point
-    /// value as an integer 0/1 value.
-    FGETSIGN,
-
-    /// Returns platform specific canonical encoding of a floating point number.
-    FCANONICALIZE,
-
-    /// BUILD_VECTOR(ELT0, ELT1, ELT2, ELT3,...) - Return a vector with the
-    /// specified, possibly variable, elements.  The number of elements is
-    /// required to be a power of two.  The types of the operands must all be
-    /// the same and must match the vector element type, except that integer
-    /// types are allowed to be larger than the element type, in which case
-    /// the operands are implicitly truncated.
-    BUILD_VECTOR,
-
-    /// INSERT_VECTOR_ELT(VECTOR, VAL, IDX) - Returns VECTOR with the element
-    /// at IDX replaced with VAL.  If the type of VAL is larger than the vector
-    /// element type then VAL is truncated before replacement.
-    INSERT_VECTOR_ELT,
-
-    /// EXTRACT_VECTOR_ELT(VECTOR, IDX) - Returns a single element from VECTOR
-    /// identified by the (potentially variable) element number IDX.  If the
-    /// return type is an integer type larger than the element type of the
-    /// vector, the result is extended to the width of the return type. In
-    /// that case, the high bits are undefined.
-    EXTRACT_VECTOR_ELT,
-
-    /// CONCAT_VECTORS(VECTOR0, VECTOR1, ...) - Given a number of values of
-    /// vector type with the same length and element type, this produces a
-    /// concatenated vector result value, with length equal to the sum of the
-    /// lengths of the input vectors.
-    CONCAT_VECTORS,
-
-    /// INSERT_SUBVECTOR(VECTOR1, VECTOR2, IDX) - Returns a vector
-    /// with VECTOR2 inserted into VECTOR1 at the (potentially
-    /// variable) element number IDX, which must be a multiple of the
-    /// VECTOR2 vector length.  The elements of VECTOR1 starting at
-    /// IDX are overwritten with VECTOR2.  Elements IDX through
-    /// vector_length(VECTOR2) must be valid VECTOR1 indices.
-    INSERT_SUBVECTOR,
-
-    /// EXTRACT_SUBVECTOR(VECTOR, IDX) - Returns a subvector from VECTOR (an
-    /// vector value) starting with the element number IDX, which must be a
-    /// constant multiple of the result vector length.
-    EXTRACT_SUBVECTOR,
-
-    /// VECTOR_SHUFFLE(VEC1, VEC2) - Returns a vector, of the same type as
-    /// VEC1/VEC2.  A VECTOR_SHUFFLE node also contains an array of constant int
-    /// values that indicate which value (or undef) each result element will
-    /// get.  These constant ints are accessible through the
-    /// ShuffleVectorSDNode class.  This is quite similar to the Altivec
-    /// 'vperm' instruction, except that the indices must be constants and are
-    /// in terms of the element size of VEC1/VEC2, not in terms of bytes.
-    VECTOR_SHUFFLE,
-
-    /// SCALAR_TO_VECTOR(VAL) - This represents the operation of loading a
-    /// scalar value into element 0 of the resultant vector type.  The top
-    /// elements 1 to N-1 of the N-element vector are undefined.  The type
-    /// of the operand must match the vector element type, except when they
-    /// are integer types.  In this case the operand is allowed to be wider
-    /// than the vector element type, and is implicitly truncated to it.
-    SCALAR_TO_VECTOR,
-
-    /// MULHU/MULHS - Multiply high - Multiply two integers of type iN,
-    /// producing an unsigned/signed value of type i[2*N], then return the top
-    /// part.
-    MULHU, MULHS,
-
-    /// [US]{MIN/MAX} - Binary minimum or maximum or signed or unsigned
-    /// integers.
-    SMIN, SMAX, UMIN, UMAX,
-
-    /// Bitwise operators - logical and, logical or, logical xor.
-    AND, OR, XOR,
-
-    /// ABS - Determine the unsigned absolute value of a signed integer value of
-    /// the same bitwidth.
-    /// Note: A value of INT_MIN will return INT_MIN, no saturation or overflow
-    /// is performed.
-    ABS,
-
-    /// Shift and rotation operations.  After legalization, the type of the
-    /// shift amount is known to be TLI.getShiftAmountTy().  Before legalization
-    /// the shift amount can be any type, but care must be taken to ensure it is
-    /// large enough.  TLI.getShiftAmountTy() is i8 on some targets, but before
-    /// legalization, types like i1024 can occur and i8 doesn't have enough bits
-    /// to represent the shift amount.
-    /// When the 1st operand is a vector, the shift amount must be in the same
-    /// type. (TLI.getShiftAmountTy() will return the same type when the input
-    /// type is a vector.)
-    /// For rotates and funnel shifts, the shift amount is treated as an unsigned
-    /// amount modulo the element size of the first operand.
-    ///
-    /// Funnel 'double' shifts take 3 operands, 2 inputs and the shift amount.
-    /// fshl(X,Y,Z): (X << (Z % BW)) | (Y >> (BW - (Z % BW)))
-    /// fshr(X,Y,Z): (X << (BW - (Z % BW))) | (Y >> (Z % BW))
-    SHL, SRA, SRL, ROTL, ROTR, FSHL, FSHR,
-
-    /// Byte Swap and Counting operators.
-    BSWAP, CTTZ, CTLZ, CTPOP, BITREVERSE,
-
-    /// Bit counting operators with an undefined result for zero inputs.
-    CTTZ_ZERO_UNDEF, CTLZ_ZERO_UNDEF,
-
-    /// Select(COND, TRUEVAL, FALSEVAL).  If the type of the boolean COND is not
-    /// i1 then the high bits must conform to getBooleanContents.
-    SELECT,
-
-    /// Select with a vector condition (op #0) and two vector operands (ops #1
-    /// and #2), returning a vector result.  All vectors have the same length.
-    /// Much like the scalar select and setcc, each bit in the condition selects
-    /// whether the corresponding result element is taken from op #1 or op #2.
-    /// At first, the VSELECT condition is of vXi1 type. Later, targets may
-    /// change the condition type in order to match the VSELECT node using a
-    /// pattern. The condition follows the BooleanContent format of the target.
-    VSELECT,
-
-    /// Select with condition operator - This selects between a true value and
-    /// a false value (ops #2 and #3) based on the boolean result of comparing
-    /// the lhs and rhs (ops #0 and #1) of a conditional expression with the
-    /// condition code in op #4, a CondCodeSDNode.
-    SELECT_CC,
-
-    /// SetCC operator - This evaluates to a true value iff the condition is
-    /// true.  If the result value type is not i1 then the high bits conform
-    /// to getBooleanContents.  The operands to this are the left and right
-    /// operands to compare (ops #0, and #1) and the condition code to compare
-    /// them with (op #2) as a CondCodeSDNode. If the operands are vector types
-    /// then the result type must also be a vector type.
-    SETCC,
-
-    /// Like SetCC, ops #0 and #1 are the LHS and RHS operands to compare, but
-    /// op #2 is a boolean indicating if there is an incoming carry. This
-    /// operator checks the result of "LHS - RHS - Carry", and can be used to
-    /// compare two wide integers:
-    /// (setcccarry lhshi rhshi (subcarry lhslo rhslo) cc).
-    /// Only valid for integers.
-    SETCCCARRY,
-
-    /// SHL_PARTS/SRA_PARTS/SRL_PARTS - These operators are used for expanded
-    /// integer shift operations.  The operation ordering is:
-    ///       [Lo,Hi] = op [LoLHS,HiLHS], Amt
-    SHL_PARTS, SRA_PARTS, SRL_PARTS,
-
-    /// Conversion operators.  These are all single input single output
-    /// operations.  For all of these, the result type must be strictly
-    /// wider or narrower (depending on the operation) than the source
-    /// type.
-
-    /// SIGN_EXTEND - Used for integer types, replicating the sign bit
-    /// into new bits.
-    SIGN_EXTEND,
-
-    /// ZERO_EXTEND - Used for integer types, zeroing the new bits.
-    ZERO_EXTEND,
-
-    /// ANY_EXTEND - Used for integer types.  The high bits are undefined.
-    ANY_EXTEND,
-
-    /// TRUNCATE - Completely drop the high bits.
-    TRUNCATE,
-
-    /// [SU]INT_TO_FP - These operators convert integers (whose interpreted sign
-    /// depends on the first letter) to floating point.
-    SINT_TO_FP,
-    UINT_TO_FP,
-
-    /// SIGN_EXTEND_INREG - This operator atomically performs a SHL/SRA pair to
-    /// sign extend a small value in a large integer register (e.g. sign
-    /// extending the low 8 bits of a 32-bit register to fill the top 24 bits
-    /// with the 7th bit).  The size of the smaller type is indicated by the 1th
-    /// operand, a ValueType node.
-    SIGN_EXTEND_INREG,
-
-    /// ANY_EXTEND_VECTOR_INREG(Vector) - This operator represents an
-    /// in-register any-extension of the low lanes of an integer vector. The
-    /// result type must have fewer elements than the operand type, and those
-    /// elements must be larger integer types such that the total size of the
-    /// operand type is less than or equal to the size of the result type. Each
-    /// of the low operand elements is any-extended into the corresponding,
-    /// wider result elements with the high bits becoming undef.
-    /// NOTE: The type legalizer prefers to make the operand and result size
-    /// the same to allow expansion to shuffle vector during op legalization.
-    ANY_EXTEND_VECTOR_INREG,
-
-    /// SIGN_EXTEND_VECTOR_INREG(Vector) - This operator represents an
-    /// in-register sign-extension of the low lanes of an integer vector. The
-    /// result type must have fewer elements than the operand type, and those
-    /// elements must be larger integer types such that the total size of the
-    /// operand type is less than or equal to the size of the result type. Each
-    /// of the low operand elements is sign-extended into the corresponding,
-    /// wider result elements.
-    /// NOTE: The type legalizer prefers to make the operand and result size
-    /// the same to allow expansion to shuffle vector during op legalization.
-    SIGN_EXTEND_VECTOR_INREG,
-
-    /// ZERO_EXTEND_VECTOR_INREG(Vector) - This operator represents an
-    /// in-register zero-extension of the low lanes of an integer vector. The
-    /// result type must have fewer elements than the operand type, and those
-    /// elements must be larger integer types such that the total size of the
-    /// operand type is less than or equal to the size of the result type. Each
-    /// of the low operand elements is zero-extended into the corresponding,
-    /// wider result elements.
-    /// NOTE: The type legalizer prefers to make the operand and result size
-    /// the same to allow expansion to shuffle vector during op legalization.
-    ZERO_EXTEND_VECTOR_INREG,
-
-    /// FP_TO_[US]INT - Convert a floating point value to a signed or unsigned
-    /// integer. These have the same semantics as fptosi and fptoui in IR. If
-    /// the FP value cannot fit in the integer type, the results are undefined.
-    FP_TO_SINT,
-    FP_TO_UINT,
-
-    /// X = FP_ROUND(Y, TRUNC) - Rounding 'Y' from a larger floating point type
-    /// down to the precision of the destination VT.  TRUNC is a flag, which is
-    /// always an integer that is zero or one.  If TRUNC is 0, this is a
-    /// normal rounding, if it is 1, this FP_ROUND is known to not change the
-    /// value of Y.
-    ///
-    /// The TRUNC = 1 case is used in cases where we know that the value will
-    /// not be modified by the node, because Y is not using any of the extra
-    /// precision of source type.  This allows certain transformations like
-    /// FP_EXTEND(FP_ROUND(X,1)) -> X which are not safe for
-    /// FP_EXTEND(FP_ROUND(X,0)) because the extra bits aren't removed.
-    FP_ROUND,
-
-    /// FLT_ROUNDS_ - Returns current rounding mode:
-    /// -1 Undefined
-    ///  0 Round to 0
-    ///  1 Round to nearest
-    ///  2 Round to +inf
-    ///  3 Round to -inf
-    FLT_ROUNDS_,
-
-    /// X = FP_ROUND_INREG(Y, VT) - This operator takes an FP register, and
-    /// rounds it to a floating point value.  It then promotes it and returns it
-    /// in a register of the same size.  This operation effectively just
-    /// discards excess precision.  The type to round down to is specified by
-    /// the VT operand, a VTSDNode.
-    FP_ROUND_INREG,
-
-    /// X = FP_EXTEND(Y) - Extend a smaller FP type into a larger FP type.
-    FP_EXTEND,
-
-    /// BITCAST - This operator converts between integer, vector and FP
-    /// values, as if the value was stored to memory with one type and loaded
-    /// from the same address with the other type (or equivalently for vector
-    /// format conversions, etc).  The source and result are required to have
-    /// the same bit size (e.g.  f32 <-> i32).  This can also be used for
-    /// int-to-int or fp-to-fp conversions, but that is a noop, deleted by
-    /// getNode().
-    ///
-    /// This operator is subtly different from the bitcast instruction from
-    /// LLVM-IR since this node may change the bits in the register. For
-    /// example, this occurs on big-endian NEON and big-endian MSA where the
-    /// layout of the bits in the register depends on the vector type and this
-    /// operator acts as a shuffle operation for some vector type combinations.
-    BITCAST,
-
-    /// ADDRSPACECAST - This operator converts between pointers of different
-    /// address spaces.
-    ADDRSPACECAST,
-
-    /// FP16_TO_FP, FP_TO_FP16 - These operators are used to perform promotions
-    /// and truncation for half-precision (16 bit) floating numbers. These nodes
-    /// form a semi-softened interface for dealing with f16 (as an i16), which
-    /// is often a storage-only type but has native conversions.
-    FP16_TO_FP, FP_TO_FP16,
-
-    /// Perform various unary floating-point operations inspired by libm. For
-    /// FPOWI, the result is undefined if if the integer operand doesn't fit
-    /// into 32 bits.
-    FNEG, FABS, FSQRT, FCBRT, FSIN, FCOS, FPOWI, FPOW,
-    FLOG, FLOG2, FLOG10, FEXP, FEXP2,
-    FCEIL, FTRUNC, FRINT, FNEARBYINT, FROUND, FFLOOR,
-    LROUND, LLROUND, LRINT, LLRINT,
-
-    /// FMINNUM/FMAXNUM - Perform floating-point minimum or maximum on two
-    /// values.
-    //
-    /// In the case where a single input is a NaN (either signaling or quiet),
-    /// the non-NaN input is returned.
-    ///
-    /// The return value of (FMINNUM 0.0, -0.0) could be either 0.0 or -0.0.
-    FMINNUM, FMAXNUM,
-
-    /// FMINNUM_IEEE/FMAXNUM_IEEE - Perform floating-point minimum or maximum on
-    /// two values, following the IEEE-754 2008 definition. This differs from
-    /// FMINNUM/FMAXNUM in the handling of signaling NaNs. If one input is a
-    /// signaling NaN, returns a quiet NaN.
-    FMINNUM_IEEE, FMAXNUM_IEEE,
-
-    /// FMINIMUM/FMAXIMUM - NaN-propagating minimum/maximum that also treat -0.0
-    /// as less than 0.0. While FMINNUM_IEEE/FMAXNUM_IEEE follow IEEE 754-2008
-    /// semantics, FMINIMUM/FMAXIMUM follow IEEE 754-2018 draft semantics.
-    FMINIMUM, FMAXIMUM,
-
-    /// FSINCOS - Compute both fsin and fcos as a single operation.
-    FSINCOS,
-
-    /// LOAD and STORE have token chains as their first operand, then the same
-    /// operands as an LLVM load/store instruction, then an offset node that
-    /// is added / subtracted from the base pointer to form the address (for
-    /// indexed memory ops).
-    LOAD, STORE,
-
-    /// DYNAMIC_STACKALLOC - Allocate some number of bytes on the stack aligned
-    /// to a specified boundary.  This node always has two return values: a new
-    /// stack pointer value and a chain. The first operand is the token chain,
-    /// the second is the number of bytes to allocate, and the third is the
-    /// alignment boundary.  The size is guaranteed to be a multiple of the
-    /// stack alignment, and the alignment is guaranteed to be bigger than the
-    /// stack alignment (if required) or 0 to get standard stack alignment.
-    DYNAMIC_STACKALLOC,
-
-    /// Control flow instructions.  These all have token chains.
-
-    /// BR - Unconditional branch.  The first operand is the chain
-    /// operand, the second is the MBB to branch to.
-    BR,
-
-    /// BRIND - Indirect branch.  The first operand is the chain, the second
-    /// is the value to branch to, which must be of the same type as the
-    /// target's pointer type.
-    BRIND,
-
-    /// BR_JT - Jumptable branch. The first operand is the chain, the second
-    /// is the jumptable index, the last one is the jumptable entry index.
-    BR_JT,
-
-    /// BRCOND - Conditional branch.  The first operand is the chain, the
-    /// second is the condition, the third is the block to branch to if the
-    /// condition is true.  If the type of the condition is not i1, then the
-    /// high bits must conform to getBooleanContents.
-    BRCOND,
-
-    /// BR_CC - Conditional branch.  The behavior is like that of SELECT_CC, in
-    /// that the condition is represented as condition code, and two nodes to
-    /// compare, rather than as a combined SetCC node.  The operands in order
-    /// are chain, cc, lhs, rhs, block to branch to if condition is true.
-    BR_CC,
-
-    /// INLINEASM - Represents an inline asm block.  This node always has two
-    /// return values: a chain and a flag result.  The inputs are as follows:
-    ///   Operand #0  : Input chain.
-    ///   Operand #1  : a ExternalSymbolSDNode with a pointer to the asm string.
-    ///   Operand #2  : a MDNodeSDNode with the !srcloc metadata.
-    ///   Operand #3  : HasSideEffect, IsAlignStack bits.
-    ///   After this, it is followed by a list of operands with this format:
-    ///     ConstantSDNode: Flags that encode whether it is a mem or not, the
-    ///                     of operands that follow, etc.  See InlineAsm.h.
-    ///     ... however many operands ...
-    ///   Operand #last: Optional, an incoming flag.
-    ///
-    /// The variable width operands are required to represent target addressing
-    /// modes as a single "operand", even though they may have multiple
-    /// SDOperands.
-    INLINEASM,
-
-    /// INLINEASM_BR - Terminator version of inline asm. Used by asm-goto.
-    INLINEASM_BR,
-
-    /// EH_LABEL - Represents a label in mid basic block used to track
-    /// locations needed for debug and exception handling tables.  These nodes
-    /// take a chain as input and return a chain.
-    EH_LABEL,
-
-    /// ANNOTATION_LABEL - Represents a mid basic block label used by
-    /// annotations. This should remain within the basic block and be ordered
-    /// with respect to other call instructions, but loads and stores may float
-    /// past it.
-    ANNOTATION_LABEL,
-
-    /// CATCHPAD - Represents a catchpad instruction.
-    CATCHPAD,
-
-    /// CATCHRET - Represents a return from a catch block funclet. Used for
-    /// MSVC compatible exception handling. Takes a chain operand and a
-    /// destination basic block operand.
-    CATCHRET,
-
-    /// CLEANUPRET - Represents a return from a cleanup block funclet.  Used for
-    /// MSVC compatible exception handling. Takes only a chain operand.
-    CLEANUPRET,
-
-    /// STACKSAVE - STACKSAVE has one operand, an input chain.  It produces a
-    /// value, the same type as the pointer type for the system, and an output
-    /// chain.
-    STACKSAVE,
-
-    /// STACKRESTORE has two operands, an input chain and a pointer to restore
-    /// to it returns an output chain.
-    STACKRESTORE,
-
-    /// CALLSEQ_START/CALLSEQ_END - These operators mark the beginning and end
-    /// of a call sequence, and carry arbitrary information that target might
-    /// want to know.  The first operand is a chain, the rest are specified by
-    /// the target and not touched by the DAG optimizers.
-    /// Targets that may use stack to pass call arguments define additional
-    /// operands:
-    /// - size of the call frame part that must be set up within the
-    ///   CALLSEQ_START..CALLSEQ_END pair,
-    /// - part of the call frame prepared prior to CALLSEQ_START.
-    /// Both these parameters must be constants, their sum is the total call
-    /// frame size.
-    /// CALLSEQ_START..CALLSEQ_END pairs may not be nested.
-    CALLSEQ_START,  // Beginning of a call sequence
-    CALLSEQ_END,    // End of a call sequence
-
-    /// VAARG - VAARG has four operands: an input chain, a pointer, a SRCVALUE,
-    /// and the alignment. It returns a pair of values: the vaarg value and a
-    /// new chain.
-    VAARG,
-
-    /// VACOPY - VACOPY has 5 operands: an input chain, a destination pointer,
-    /// a source pointer, a SRCVALUE for the destination, and a SRCVALUE for the
-    /// source.
-    VACOPY,
-
-    /// VAEND, VASTART - VAEND and VASTART have three operands: an input chain,
-    /// pointer, and a SRCVALUE.
-    VAEND, VASTART,
-
-    /// SRCVALUE - This is a node type that holds a Value* that is used to
-    /// make reference to a value in the LLVM IR.
-    SRCVALUE,
-
-    /// MDNODE_SDNODE - This is a node that holdes an MDNode*, which is used to
-    /// reference metadata in the IR.
-    MDNODE_SDNODE,
-
-    /// PCMARKER - This corresponds to the pcmarker intrinsic.
-    PCMARKER,
-
-    /// READCYCLECOUNTER - This corresponds to the readcyclecounter intrinsic.
-    /// It produces a chain and one i64 value. The only operand is a chain.
-    /// If i64 is not legal, the result will be expanded into smaller values.
-    /// Still, it returns an i64, so targets should set legality for i64.
-    /// The result is the content of the architecture-specific cycle
-    /// counter-like register (or other high accuracy low latency clock source).
-    READCYCLECOUNTER,
-
-    /// HANDLENODE node - Used as a handle for various purposes.
-    HANDLENODE,
-
-    /// INIT_TRAMPOLINE - This corresponds to the init_trampoline intrinsic.  It
-    /// takes as input a token chain, the pointer to the trampoline, the pointer
-    /// to the nested function, the pointer to pass for the 'nest' parameter, a
-    /// SRCVALUE for the trampoline and another for the nested function
-    /// (allowing targets to access the original Function*).
-    /// It produces a token chain as output.
-    INIT_TRAMPOLINE,
-
-    /// ADJUST_TRAMPOLINE - This corresponds to the adjust_trampoline intrinsic.
-    /// It takes a pointer to the trampoline and produces a (possibly) new
-    /// pointer to the same trampoline with platform-specific adjustments
-    /// applied.  The pointer it returns points to an executable block of code.
-    ADJUST_TRAMPOLINE,
-
-    /// TRAP - Trapping instruction
-    TRAP,
-
-    /// DEBUGTRAP - Trap intended to get the attention of a debugger.
-    DEBUGTRAP,
-
-    /// PREFETCH - This corresponds to a prefetch intrinsic. The first operand
-    /// is the chain.  The other operands are the address to prefetch,
-    /// read / write specifier, locality specifier and instruction / data cache
-    /// specifier.
-    PREFETCH,
-
-    /// OUTCHAIN = ATOMIC_FENCE(INCHAIN, ordering, scope)
-    /// This corresponds to the fence instruction. It takes an input chain, and
-    /// two integer constants: an AtomicOrdering and a SynchronizationScope.
-    ATOMIC_FENCE,
-
-    /// Val, OUTCHAIN = ATOMIC_LOAD(INCHAIN, ptr)
-    /// This corresponds to "load atomic" instruction.
-    ATOMIC_LOAD,
-
-    /// OUTCHAIN = ATOMIC_STORE(INCHAIN, ptr, val)
-    /// This corresponds to "store atomic" instruction.
-    ATOMIC_STORE,
-
-    /// Val, OUTCHAIN = ATOMIC_CMP_SWAP(INCHAIN, ptr, cmp, swap)
-    /// For double-word atomic operations:
-    /// ValLo, ValHi, OUTCHAIN = ATOMIC_CMP_SWAP(INCHAIN, ptr, cmpLo, cmpHi,
-    ///                                          swapLo, swapHi)
-    /// This corresponds to the cmpxchg instruction.
-    ATOMIC_CMP_SWAP,
-
-    /// Val, Success, OUTCHAIN
-    ///     = ATOMIC_CMP_SWAP_WITH_SUCCESS(INCHAIN, ptr, cmp, swap)
-    /// N.b. this is still a strong cmpxchg operation, so
-    /// Success == "Val == cmp".
-    ATOMIC_CMP_SWAP_WITH_SUCCESS,
-
-    /// Val, OUTCHAIN = ATOMIC_SWAP(INCHAIN, ptr, amt)
-    /// Val, OUTCHAIN = ATOMIC_LOAD_[OpName](INCHAIN, ptr, amt)
-    /// For double-word atomic operations:
-    /// ValLo, ValHi, OUTCHAIN = ATOMIC_SWAP(INCHAIN, ptr, amtLo, amtHi)
-    /// ValLo, ValHi, OUTCHAIN = ATOMIC_LOAD_[OpName](INCHAIN, ptr, amtLo, amtHi)
-    /// These correspond to the atomicrmw instruction.
-    ATOMIC_SWAP,
-    ATOMIC_LOAD_ADD,
-    ATOMIC_LOAD_SUB,
-    ATOMIC_LOAD_AND,
-    ATOMIC_LOAD_CLR,
-    ATOMIC_LOAD_OR,
-    ATOMIC_LOAD_XOR,
-    ATOMIC_LOAD_NAND,
-    ATOMIC_LOAD_MIN,
-    ATOMIC_LOAD_MAX,
-    ATOMIC_LOAD_UMIN,
-    ATOMIC_LOAD_UMAX,
-    ATOMIC_LOAD_FADD,
-    ATOMIC_LOAD_FSUB,
-
-    // Masked load and store - consecutive vector load and store operations
-    // with additional mask operand that prevents memory accesses to the
-    // masked-off lanes.
-    //
-    // Val, OutChain = MLOAD(BasePtr, Mask, PassThru)
-    // OutChain = MSTORE(Value, BasePtr, Mask)
-    MLOAD, MSTORE,
-
-    // Masked gather and scatter - load and store operations for a vector of
-    // random addresses with additional mask operand that prevents memory
-    // accesses to the masked-off lanes.
-    //
-    // Val, OutChain = GATHER(InChain, PassThru, Mask, BasePtr, Index, Scale)
-    // OutChain = SCATTER(InChain, Value, Mask, BasePtr, Index, Scale)
-    //
-    // The Index operand can have more vector elements than the other operands
-    // due to type legalization. The extra elements are ignored.
-    MGATHER, MSCATTER,
-
-    /// This corresponds to the llvm.lifetime.* intrinsics. The first operand
-    /// is the chain and the second operand is the alloca pointer.
-    LIFETIME_START, LIFETIME_END,
-
-    /// GC_TRANSITION_START/GC_TRANSITION_END - These operators mark the
-    /// beginning and end of GC transition  sequence, and carry arbitrary
-    /// information that target might need for lowering.  The first operand is
-    /// a chain, the rest are specified by the target and not touched by the DAG
-    /// optimizers. GC_TRANSITION_START..GC_TRANSITION_END pairs may not be
-    /// nested.
-    GC_TRANSITION_START,
-    GC_TRANSITION_END,
-
-    /// GET_DYNAMIC_AREA_OFFSET - get offset from native SP to the address of
-    /// the most recent dynamic alloca. For most targets that would be 0, but
-    /// for some others (e.g. PowerPC, PowerPC64) that would be compile-time
-    /// known nonzero constant. The only operand here is the chain.
-    GET_DYNAMIC_AREA_OFFSET,
-
-    /// Generic reduction nodes. These nodes represent horizontal vector
-    /// reduction operations, producing a scalar result.
-    /// The STRICT variants perform reductions in sequential order. The first
-    /// operand is an initial scalar accumulator value, and the second operand
-    /// is the vector to reduce.
-    VECREDUCE_STRICT_FADD, VECREDUCE_STRICT_FMUL,
-    /// These reductions are non-strict, and have a single vector operand.
-    VECREDUCE_FADD, VECREDUCE_FMUL,
-    /// FMIN/FMAX nodes can have flags, for NaN/NoNaN variants.
-    VECREDUCE_FMAX, VECREDUCE_FMIN,
-    /// Integer reductions may have a result type larger than the vector element
-    /// type. However, the reduction is performed using the vector element type
-    /// and the value in the top bits is unspecified.
-    VECREDUCE_ADD, VECREDUCE_MUL,
-    VECREDUCE_AND, VECREDUCE_OR, VECREDUCE_XOR,
-    VECREDUCE_SMAX, VECREDUCE_SMIN, VECREDUCE_UMAX, VECREDUCE_UMIN,
-
-    /// BUILTIN_OP_END - This must be the last enum value in this list.
-    /// The target-specific pre-isel opcode values start here.
-    BUILTIN_OP_END
-  };
-
-  /// FIRST_TARGET_MEMORY_OPCODE - Target-specific pre-isel operations
-  /// which do not reference a specific memory location should be less than
-  /// this value. Those that do must not be less than this value, and can
-  /// be used with SelectionDAG::getMemIntrinsicNode.
-  static const int FIRST_TARGET_MEMORY_OPCODE = BUILTIN_OP_END+400;
-
-  //===--------------------------------------------------------------------===//
-  /// MemIndexedMode enum - This enum defines the load / store indexed
-  /// addressing modes.
+  /// INSERT_SUBVECTOR(VECTOR1, VECTOR2, IDX) - Returns a vector with VECTOR2
+  /// inserted into VECTOR1. IDX represents the starting element number at which
+  /// VECTOR2 will be inserted. IDX must be a constant multiple of T's known
+  /// minimum vector length. Let the type of VECTOR2 be T, then if T is a
+  /// scalable vector, IDX is first scaled by the runtime scaling factor of T.
+  /// The elements of VECTOR1 starting at IDX are overwritten with VECTOR2.
+  /// Elements IDX through (IDX + num_elements(T) - 1) must be valid VECTOR1
+  /// indices. If this condition cannot be determined statically but is false at
+  /// runtime, then the result vector is undefined.
   ///
-  /// UNINDEXED    "Normal" load / store. The effective address is already
-  ///              computed and is available in the base pointer. The offset
-  ///              operand is always undefined. In addition to producing a
-  ///              chain, an unindexed load produces one value (result of the
-  ///              load); an unindexed store does not produce a value.
+  /// This operation supports inserting a fixed-width vector into a scalable
+  /// vector, but not the other way around.
+  INSERT_SUBVECTOR,
+
+  /// EXTRACT_SUBVECTOR(VECTOR, IDX) - Returns a subvector from VECTOR.
+  /// Let the result type be T, then IDX represents the starting element number
+  /// from which a subvector of type T is extracted. IDX must be a constant
+  /// multiple of T's known minimum vector length. If T is a scalable vector,
+  /// IDX is first scaled by the runtime scaling factor of T. Elements IDX
+  /// through (IDX + num_elements(T) - 1) must be valid VECTOR indices. If this
+  /// condition cannot be determined statically but is false at runtime, then
+  /// the result vector is undefined. The IDX parameter must be a vector index
+  /// constant type, which for most targets will be an integer pointer type.
   ///
-  /// PRE_INC      Similar to the unindexed mode where the effective address is
-  /// PRE_DEC      the value of the base pointer add / subtract the offset.
-  ///              It considers the computation as being folded into the load /
-  ///              store operation (i.e. the load / store does the address
-  ///              computation as well as performing the memory transaction).
-  ///              The base operand is always undefined. In addition to
-  ///              producing a chain, pre-indexed load produces two values
-  ///              (result of the load and the result of the address
-  ///              computation); a pre-indexed store produces one value (result
-  ///              of the address computation).
+  /// This operation supports extracting a fixed-width vector from a scalable
+  /// vector, but not the other way around.
+  EXTRACT_SUBVECTOR,
+
+  /// VECTOR_SHUFFLE(VEC1, VEC2) - Returns a vector, of the same type as
+  /// VEC1/VEC2.  A VECTOR_SHUFFLE node also contains an array of constant int
+  /// values that indicate which value (or undef) each result element will
+  /// get.  These constant ints are accessible through the
+  /// ShuffleVectorSDNode class.  This is quite similar to the Altivec
+  /// 'vperm' instruction, except that the indices must be constants and are
+  /// in terms of the element size of VEC1/VEC2, not in terms of bytes.
+  VECTOR_SHUFFLE,
+
+  /// SCALAR_TO_VECTOR(VAL) - This represents the operation of loading a
+  /// scalar value into element 0 of the resultant vector type.  The top
+  /// elements 1 to N-1 of the N-element vector are undefined.  The type
+  /// of the operand must match the vector element type, except when they
+  /// are integer types.  In this case the operand is allowed to be wider
+  /// than the vector element type, and is implicitly truncated to it.
+  SCALAR_TO_VECTOR,
+
+  /// SPLAT_VECTOR(VAL) - Returns a vector with the scalar value VAL
+  /// duplicated in all lanes. The type of the operand must match the vector
+  /// element type, except when they are integer types.  In this case the
+  /// operand is allowed to be wider than the vector element type, and is
+  /// implicitly truncated to it.
+  SPLAT_VECTOR,
+
+  /// MULHU/MULHS - Multiply high - Multiply two integers of type iN,
+  /// producing an unsigned/signed value of type i[2*N], then return the top
+  /// part.
+  MULHU,
+  MULHS,
+
+  /// [US]{MIN/MAX} - Binary minimum or maximum or signed or unsigned
+  /// integers.
+  SMIN,
+  SMAX,
+  UMIN,
+  UMAX,
+
+  /// Bitwise operators - logical and, logical or, logical xor.
+  AND,
+  OR,
+  XOR,
+
+  /// ABS - Determine the unsigned absolute value of a signed integer value of
+  /// the same bitwidth.
+  /// Note: A value of INT_MIN will return INT_MIN, no saturation or overflow
+  /// is performed.
+  ABS,
+
+  /// Shift and rotation operations.  After legalization, the type of the
+  /// shift amount is known to be TLI.getShiftAmountTy().  Before legalization
+  /// the shift amount can be any type, but care must be taken to ensure it is
+  /// large enough.  TLI.getShiftAmountTy() is i8 on some targets, but before
+  /// legalization, types like i1024 can occur and i8 doesn't have enough bits
+  /// to represent the shift amount.
+  /// When the 1st operand is a vector, the shift amount must be in the same
+  /// type. (TLI.getShiftAmountTy() will return the same type when the input
+  /// type is a vector.)
+  /// For rotates and funnel shifts, the shift amount is treated as an unsigned
+  /// amount modulo the element size of the first operand.
   ///
-  /// POST_INC     The effective address is the value of the base pointer. The
-  /// POST_DEC     value of the offset operand is then added to / subtracted
-  ///              from the base after memory transaction. In addition to
-  ///              producing a chain, post-indexed load produces two values
-  ///              (the result of the load and the result of the base +/- offset
-  ///              computation); a post-indexed store produces one value (the
-  ///              the result of the base +/- offset computation).
-  enum MemIndexedMode {
-    UNINDEXED = 0,
-    PRE_INC,
-    PRE_DEC,
-    POST_INC,
-    POST_DEC
-  };
+  /// Funnel 'double' shifts take 3 operands, 2 inputs and the shift amount.
+  /// fshl(X,Y,Z): (X << (Z % BW)) | (Y >> (BW - (Z % BW)))
+  /// fshr(X,Y,Z): (X << (BW - (Z % BW))) | (Y >> (Z % BW))
+  SHL,
+  SRA,
+  SRL,
+  ROTL,
+  ROTR,
+  FSHL,
+  FSHR,
 
-  static const int LAST_INDEXED_MODE = POST_DEC + 1;
+  /// Byte Swap and Counting operators.
+  BSWAP,
+  CTTZ,
+  CTLZ,
+  CTPOP,
+  BITREVERSE,
+  PARITY,
 
-  //===--------------------------------------------------------------------===//
-  /// LoadExtType enum - This enum defines the three variants of LOADEXT
-  /// (load with extension).
+  /// Bit counting operators with an undefined result for zero inputs.
+  CTTZ_ZERO_UNDEF,
+  CTLZ_ZERO_UNDEF,
+
+  /// Select(COND, TRUEVAL, FALSEVAL).  If the type of the boolean COND is not
+  /// i1 then the high bits must conform to getBooleanContents.
+  SELECT,
+
+  /// Select with a vector condition (op #0) and two vector operands (ops #1
+  /// and #2), returning a vector result.  All vectors have the same length.
+  /// Much like the scalar select and setcc, each bit in the condition selects
+  /// whether the corresponding result element is taken from op #1 or op #2.
+  /// At first, the VSELECT condition is of vXi1 type. Later, targets may
+  /// change the condition type in order to match the VSELECT node using a
+  /// pattern. The condition follows the BooleanContent format of the target.
+  VSELECT,
+
+  /// Select with condition operator - This selects between a true value and
+  /// a false value (ops #2 and #3) based on the boolean result of comparing
+  /// the lhs and rhs (ops #0 and #1) of a conditional expression with the
+  /// condition code in op #4, a CondCodeSDNode.
+  SELECT_CC,
+
+  /// SetCC operator - This evaluates to a true value iff the condition is
+  /// true.  If the result value type is not i1 then the high bits conform
+  /// to getBooleanContents.  The operands to this are the left and right
+  /// operands to compare (ops #0, and #1) and the condition code to compare
+  /// them with (op #2) as a CondCodeSDNode. If the operands are vector types
+  /// then the result type must also be a vector type.
+  SETCC,
+
+  /// Like SetCC, ops #0 and #1 are the LHS and RHS operands to compare, but
+  /// op #2 is a boolean indicating if there is an incoming carry. This
+  /// operator checks the result of "LHS - RHS - Carry", and can be used to
+  /// compare two wide integers:
+  /// (setcccarry lhshi rhshi (subcarry lhslo rhslo) cc).
+  /// Only valid for integers.
+  SETCCCARRY,
+
+  /// SHL_PARTS/SRA_PARTS/SRL_PARTS - These operators are used for expanded
+  /// integer shift operations.  The operation ordering is:
+  ///       [Lo,Hi] = op [LoLHS,HiLHS], Amt
+  SHL_PARTS,
+  SRA_PARTS,
+  SRL_PARTS,
+
+  /// Conversion operators.  These are all single input single output
+  /// operations.  For all of these, the result type must be strictly
+  /// wider or narrower (depending on the operation) than the source
+  /// type.
+
+  /// SIGN_EXTEND - Used for integer types, replicating the sign bit
+  /// into new bits.
+  SIGN_EXTEND,
+
+  /// ZERO_EXTEND - Used for integer types, zeroing the new bits.
+  ZERO_EXTEND,
+
+  /// ANY_EXTEND - Used for integer types.  The high bits are undefined.
+  ANY_EXTEND,
+
+  /// TRUNCATE - Completely drop the high bits.
+  TRUNCATE,
+
+  /// [SU]INT_TO_FP - These operators convert integers (whose interpreted sign
+  /// depends on the first letter) to floating point.
+  SINT_TO_FP,
+  UINT_TO_FP,
+
+  /// SIGN_EXTEND_INREG - This operator atomically performs a SHL/SRA pair to
+  /// sign extend a small value in a large integer register (e.g. sign
+  /// extending the low 8 bits of a 32-bit register to fill the top 24 bits
+  /// with the 7th bit).  The size of the smaller type is indicated by the 1th
+  /// operand, a ValueType node.
+  SIGN_EXTEND_INREG,
+
+  /// ANY_EXTEND_VECTOR_INREG(Vector) - This operator represents an
+  /// in-register any-extension of the low lanes of an integer vector. The
+  /// result type must have fewer elements than the operand type, and those
+  /// elements must be larger integer types such that the total size of the
+  /// operand type is less than or equal to the size of the result type. Each
+  /// of the low operand elements is any-extended into the corresponding,
+  /// wider result elements with the high bits becoming undef.
+  /// NOTE: The type legalizer prefers to make the operand and result size
+  /// the same to allow expansion to shuffle vector during op legalization.
+  ANY_EXTEND_VECTOR_INREG,
+
+  /// SIGN_EXTEND_VECTOR_INREG(Vector) - This operator represents an
+  /// in-register sign-extension of the low lanes of an integer vector. The
+  /// result type must have fewer elements than the operand type, and those
+  /// elements must be larger integer types such that the total size of the
+  /// operand type is less than or equal to the size of the result type. Each
+  /// of the low operand elements is sign-extended into the corresponding,
+  /// wider result elements.
+  /// NOTE: The type legalizer prefers to make the operand and result size
+  /// the same to allow expansion to shuffle vector during op legalization.
+  SIGN_EXTEND_VECTOR_INREG,
+
+  /// ZERO_EXTEND_VECTOR_INREG(Vector) - This operator represents an
+  /// in-register zero-extension of the low lanes of an integer vector. The
+  /// result type must have fewer elements than the operand type, and those
+  /// elements must be larger integer types such that the total size of the
+  /// operand type is less than or equal to the size of the result type. Each
+  /// of the low operand elements is zero-extended into the corresponding,
+  /// wider result elements.
+  /// NOTE: The type legalizer prefers to make the operand and result size
+  /// the same to allow expansion to shuffle vector during op legalization.
+  ZERO_EXTEND_VECTOR_INREG,
+
+  /// FP_TO_[US]INT - Convert a floating point value to a signed or unsigned
+  /// integer. These have the same semantics as fptosi and fptoui in IR. If
+  /// the FP value cannot fit in the integer type, the results are undefined.
+  FP_TO_SINT,
+  FP_TO_UINT,
+
+  /// FP_TO_[US]INT_SAT - Convert floating point value in operand 0 to a
+  /// signed or unsigned integer type with the bit width given in operand 1 with
+  /// the following semantics:
   ///
-  /// SEXTLOAD loads the integer operand and sign extends it to a larger
-  ///          integer result type.
-  /// ZEXTLOAD loads the integer operand and zero extends it to a larger
-  ///          integer result type.
-  /// EXTLOAD  is used for two things: floating point extending loads and
-  ///          integer extending loads [the top bits are undefined].
-  enum LoadExtType {
-    NON_EXTLOAD = 0,
-    EXTLOAD,
-    SEXTLOAD,
-    ZEXTLOAD
-  };
-
-  static const int LAST_LOADEXT_TYPE = ZEXTLOAD + 1;
-
-  NodeType getExtForLoadExtType(bool IsFP, LoadExtType);
-
-  //===--------------------------------------------------------------------===//
-  /// ISD::CondCode enum - These are ordered carefully to make the bitfields
-  /// below work out, when considering SETFALSE (something that never exists
-  /// dynamically) as 0.  "U" -> Unsigned (for integer operands) or Unordered
-  /// (for floating point), "L" -> Less than, "G" -> Greater than, "E" -> Equal
-  /// to.  If the "N" column is 1, the result of the comparison is undefined if
-  /// the input is a NAN.
+  ///  * If the value is NaN, zero is returned.
+  ///  * If the value is larger/smaller than the largest/smallest integer,
+  ///    the largest/smallest integer is returned (saturation).
+  ///  * Otherwise the result of rounding the value towards zero is returned.
   ///
-  /// All of these (except for the 'always folded ops') should be handled for
-  /// floating point.  For integer, only the SETEQ,SETNE,SETLT,SETLE,SETGT,
-  /// SETGE,SETULT,SETULE,SETUGT, and SETUGE opcodes are used.
+  /// The width given in operand 1 must be equal to, or smaller than, the scalar
+  /// result type width. It may end up being smaller than the result witdh as a
+  /// result of integer type legalization.
+  FP_TO_SINT_SAT,
+  FP_TO_UINT_SAT,
+
+  /// X = FP_ROUND(Y, TRUNC) - Rounding 'Y' from a larger floating point type
+  /// down to the precision of the destination VT.  TRUNC is a flag, which is
+  /// always an integer that is zero or one.  If TRUNC is 0, this is a
+  /// normal rounding, if it is 1, this FP_ROUND is known to not change the
+  /// value of Y.
   ///
-  /// Note that these are laid out in a specific order to allow bit-twiddling
-  /// to transform conditions.
-  enum CondCode {
-    // Opcode          N U L G E       Intuitive operation
-    SETFALSE,      //    0 0 0 0       Always false (always folded)
-    SETOEQ,        //    0 0 0 1       True if ordered and equal
-    SETOGT,        //    0 0 1 0       True if ordered and greater than
-    SETOGE,        //    0 0 1 1       True if ordered and greater than or equal
-    SETOLT,        //    0 1 0 0       True if ordered and less than
-    SETOLE,        //    0 1 0 1       True if ordered and less than or equal
-    SETONE,        //    0 1 1 0       True if ordered and operands are unequal
-    SETO,          //    0 1 1 1       True if ordered (no nans)
-    SETUO,         //    1 0 0 0       True if unordered: isnan(X) | isnan(Y)
-    SETUEQ,        //    1 0 0 1       True if unordered or equal
-    SETUGT,        //    1 0 1 0       True if unordered or greater than
-    SETUGE,        //    1 0 1 1       True if unordered, greater than, or equal
-    SETULT,        //    1 1 0 0       True if unordered or less than
-    SETULE,        //    1 1 0 1       True if unordered, less than, or equal
-    SETUNE,        //    1 1 1 0       True if unordered or not equal
-    SETTRUE,       //    1 1 1 1       Always true (always folded)
-    // Don't care operations: undefined if the input is a nan.
-    SETFALSE2,     //  1 X 0 0 0       Always false (always folded)
-    SETEQ,         //  1 X 0 0 1       True if equal
-    SETGT,         //  1 X 0 1 0       True if greater than
-    SETGE,         //  1 X 0 1 1       True if greater than or equal
-    SETLT,         //  1 X 1 0 0       True if less than
-    SETLE,         //  1 X 1 0 1       True if less than or equal
-    SETNE,         //  1 X 1 1 0       True if not equal
-    SETTRUE2,      //  1 X 1 1 1       Always true (always folded)
+  /// The TRUNC = 1 case is used in cases where we know that the value will
+  /// not be modified by the node, because Y is not using any of the extra
+  /// precision of source type.  This allows certain transformations like
+  /// FP_EXTEND(FP_ROUND(X,1)) -> X which are not safe for
+  /// FP_EXTEND(FP_ROUND(X,0)) because the extra bits aren't removed.
+  FP_ROUND,
 
-    SETCC_INVALID       // Marker value.
-  };
+  /// FLT_ROUNDS_ - Returns current rounding mode:
+  /// -1 Undefined
+  ///  0 Round to 0
+  ///  1 Round to nearest
+  ///  2 Round to +inf
+  ///  3 Round to -inf
+  /// Result is rounding mode and chain. Input is a chain.
+  FLT_ROUNDS_,
 
-  /// Return true if this is a setcc instruction that performs a signed
-  /// comparison when used with integer operands.
-  inline bool isSignedIntSetCC(CondCode Code) {
-    return Code == SETGT || Code == SETGE || Code == SETLT || Code == SETLE;
-  }
+  /// X = FP_EXTEND(Y) - Extend a smaller FP type into a larger FP type.
+  FP_EXTEND,
 
-  /// Return true if this is a setcc instruction that performs an unsigned
-  /// comparison when used with integer operands.
-  inline bool isUnsignedIntSetCC(CondCode Code) {
-    return Code == SETUGT || Code == SETUGE || Code == SETULT || Code == SETULE;
-  }
+  /// BITCAST - This operator converts between integer, vector and FP
+  /// values, as if the value was stored to memory with one type and loaded
+  /// from the same address with the other type (or equivalently for vector
+  /// format conversions, etc).  The source and result are required to have
+  /// the same bit size (e.g.  f32 <-> i32).  This can also be used for
+  /// int-to-int or fp-to-fp conversions, but that is a noop, deleted by
+  /// getNode().
+  ///
+  /// This operator is subtly different from the bitcast instruction from
+  /// LLVM-IR since this node may change the bits in the register. For
+  /// example, this occurs on big-endian NEON and big-endian MSA where the
+  /// layout of the bits in the register depends on the vector type and this
+  /// operator acts as a shuffle operation for some vector type combinations.
+  BITCAST,
 
-  /// Return true if the specified condition returns true if the two operands to
-  /// the condition are equal. Note that if one of the two operands is a NaN,
-  /// this value is meaningless.
-  inline bool isTrueWhenEqual(CondCode Cond) {
-    return ((int)Cond & 1) != 0;
-  }
+  /// ADDRSPACECAST - This operator converts between pointers of different
+  /// address spaces.
+  ADDRSPACECAST,
 
-  /// This function returns 0 if the condition is always false if an operand is
-  /// a NaN, 1 if the condition is always true if the operand is a NaN, and 2 if
-  /// the condition is undefined if the operand is a NaN.
-  inline unsigned getUnorderedFlavor(CondCode Cond) {
-    return ((int)Cond >> 3) & 3;
-  }
+  /// FP16_TO_FP, FP_TO_FP16 - These operators are used to perform promotions
+  /// and truncation for half-precision (16 bit) floating numbers. These nodes
+  /// form a semi-softened interface for dealing with f16 (as an i16), which
+  /// is often a storage-only type but has native conversions.
+  FP16_TO_FP,
+  FP_TO_FP16,
+  STRICT_FP16_TO_FP,
+  STRICT_FP_TO_FP16,
 
-  /// Return the operation corresponding to !(X op Y), where 'op' is a valid
-  /// SetCC operation.
-  CondCode getSetCCInverse(CondCode Operation, bool isInteger);
+  /// Perform various unary floating-point operations inspired by libm. For
+  /// FPOWI, the result is undefined if if the integer operand doesn't fit
+  /// into 32 bits.
+  FNEG,
+  FABS,
+  FSQRT,
+  FCBRT,
+  FSIN,
+  FCOS,
+  FPOWI,
+  FPOW,
+  FLOG,
+  FLOG2,
+  FLOG10,
+  FEXP,
+  FEXP2,
+  FCEIL,
+  FTRUNC,
+  FRINT,
+  FNEARBYINT,
+  FROUND,
+  FROUNDEVEN,
+  FFLOOR,
+  LROUND,
+  LLROUND,
+  LRINT,
+  LLRINT,
 
-  /// Return the operation corresponding to (Y op X) when given the operation
-  /// for (X op Y).
-  CondCode getSetCCSwappedOperands(CondCode Operation);
+  /// FMINNUM/FMAXNUM - Perform floating-point minimum or maximum on two
+  /// values.
+  //
+  /// In the case where a single input is a NaN (either signaling or quiet),
+  /// the non-NaN input is returned.
+  ///
+  /// The return value of (FMINNUM 0.0, -0.0) could be either 0.0 or -0.0.
+  FMINNUM,
+  FMAXNUM,
 
-  /// Return the result of a logical OR between different comparisons of
-  /// identical values: ((X op1 Y) | (X op2 Y)). This function returns
-  /// SETCC_INVALID if it is not possible to represent the resultant comparison.
-  CondCode getSetCCOrOperation(CondCode Op1, CondCode Op2, bool isInteger);
+  /// FMINNUM_IEEE/FMAXNUM_IEEE - Perform floating-point minimum or maximum on
+  /// two values, following the IEEE-754 2008 definition. This differs from
+  /// FMINNUM/FMAXNUM in the handling of signaling NaNs. If one input is a
+  /// signaling NaN, returns a quiet NaN.
+  FMINNUM_IEEE,
+  FMAXNUM_IEEE,
 
-  /// Return the result of a logical AND between different comparisons of
-  /// identical values: ((X op1 Y) & (X op2 Y)). This function returns
-  /// SETCC_INVALID if it is not possible to represent the resultant comparison.
-  CondCode getSetCCAndOperation(CondCode Op1, CondCode Op2, bool isInteger);
+  /// FMINIMUM/FMAXIMUM - NaN-propagating minimum/maximum that also treat -0.0
+  /// as less than 0.0. While FMINNUM_IEEE/FMAXNUM_IEEE follow IEEE 754-2008
+  /// semantics, FMINIMUM/FMAXIMUM follow IEEE 754-2018 draft semantics.
+  FMINIMUM,
+  FMAXIMUM,
 
-} // end llvm::ISD namespace
+  /// FSINCOS - Compute both fsin and fcos as a single operation.
+  FSINCOS,
 
-} // end llvm namespace
+  /// LOAD and STORE have token chains as their first operand, then the same
+  /// operands as an LLVM load/store instruction, then an offset node that
+  /// is added / subtracted from the base pointer to form the address (for
+  /// indexed memory ops).
+  LOAD,
+  STORE,
+
+  /// DYNAMIC_STACKALLOC - Allocate some number of bytes on the stack aligned
+  /// to a specified boundary.  This node always has two return values: a new
+  /// stack pointer value and a chain. The first operand is the token chain,
+  /// the second is the number of bytes to allocate, and the third is the
+  /// alignment boundary.  The size is guaranteed to be a multiple of the
+  /// stack alignment, and the alignment is guaranteed to be bigger than the
+  /// stack alignment (if required) or 0 to get standard stack alignment.
+  DYNAMIC_STACKALLOC,
+
+  /// Control flow instructions.  These all have token chains.
+
+  /// BR - Unconditional branch.  The first operand is the chain
+  /// operand, the second is the MBB to branch to.
+  BR,
+
+  /// BRIND - Indirect branch.  The first operand is the chain, the second
+  /// is the value to branch to, which must be of the same type as the
+  /// target's pointer type.
+  BRIND,
+
+  /// BR_JT - Jumptable branch. The first operand is the chain, the second
+  /// is the jumptable index, the last one is the jumptable entry index.
+  BR_JT,
+
+  /// BRCOND - Conditional branch.  The first operand is the chain, the
+  /// second is the condition, the third is the block to branch to if the
+  /// condition is true.  If the type of the condition is not i1, then the
+  /// high bits must conform to getBooleanContents. If the condition is undef,
+  /// it nondeterministically jumps to the block.
+  /// TODO: Its semantics w.r.t undef requires further discussion; we need to
+  /// make it sure that it is consistent with optimizations in MIR & the
+  /// meaning of IMPLICIT_DEF. See https://reviews.llvm.org/D92015
+  BRCOND,
+
+  /// BR_CC - Conditional branch.  The behavior is like that of SELECT_CC, in
+  /// that the condition is represented as condition code, and two nodes to
+  /// compare, rather than as a combined SetCC node.  The operands in order
+  /// are chain, cc, lhs, rhs, block to branch to if condition is true. If
+  /// condition is undef, it nondeterministically jumps to the block.
+  BR_CC,
+
+  /// INLINEASM - Represents an inline asm block.  This node always has two
+  /// return values: a chain and a flag result.  The inputs are as follows:
+  ///   Operand #0  : Input chain.
+  ///   Operand #1  : a ExternalSymbolSDNode with a pointer to the asm string.
+  ///   Operand #2  : a MDNodeSDNode with the !srcloc metadata.
+  ///   Operand #3  : HasSideEffect, IsAlignStack bits.
+  ///   After this, it is followed by a list of operands with this format:
+  ///     ConstantSDNode: Flags that encode whether it is a mem or not, the
+  ///                     of operands that follow, etc.  See InlineAsm.h.
+  ///     ... however many operands ...
+  ///   Operand #last: Optional, an incoming flag.
+  ///
+  /// The variable width operands are required to represent target addressing
+  /// modes as a single "operand", even though they may have multiple
+  /// SDOperands.
+  INLINEASM,
+
+  /// INLINEASM_BR - Branching version of inline asm. Used by asm-goto.
+  INLINEASM_BR,
+
+  /// EH_LABEL - Represents a label in mid basic block used to track
+  /// locations needed for debug and exception handling tables.  These nodes
+  /// take a chain as input and return a chain.
+  EH_LABEL,
+
+  /// ANNOTATION_LABEL - Represents a mid basic block label used by
+  /// annotations. This should remain within the basic block and be ordered
+  /// with respect to other call instructions, but loads and stores may float
+  /// past it.
+  ANNOTATION_LABEL,
+
+  /// CATCHRET - Represents a return from a catch block funclet. Used for
+  /// MSVC compatible exception handling. Takes a chain operand and a
+  /// destination basic block operand.
+  CATCHRET,
+
+  /// CLEANUPRET - Represents a return from a cleanup block funclet.  Used for
+  /// MSVC compatible exception handling. Takes only a chain operand.
+  CLEANUPRET,
+
+  /// STACKSAVE - STACKSAVE has one operand, an input chain.  It produces a
+  /// value, the same type as the pointer type for the system, and an output
+  /// chain.
+  STACKSAVE,
+
+  /// STACKRESTORE has two operands, an input chain and a pointer to restore
+  /// to it returns an output chain.
+  STACKRESTORE,
+
+  /// CALLSEQ_START/CALLSEQ_END - These operators mark the beginning and end
+  /// of a call sequence, and carry arbitrary information that target might
+  /// want to know.  The first operand is a chain, the rest are specified by
+  /// the target and not touched by the DAG optimizers.
+  /// Targets that may use stack to pass call arguments define additional
+  /// operands:
+  /// - size of the call frame part that must be set up within the
+  ///   CALLSEQ_START..CALLSEQ_END pair,
+  /// - part of the call frame prepared prior to CALLSEQ_START.
+  /// Both these parameters must be constants, their sum is the total call
+  /// frame size.
+  /// CALLSEQ_START..CALLSEQ_END pairs may not be nested.
+  CALLSEQ_START, // Beginning of a call sequence
+  CALLSEQ_END,   // End of a call sequence
+
+  /// VAARG - VAARG has four operands: an input chain, a pointer, a SRCVALUE,
+  /// and the alignment. It returns a pair of values: the vaarg value and a
+  /// new chain.
+  VAARG,
+
+  /// VACOPY - VACOPY has 5 operands: an input chain, a destination pointer,
+  /// a source pointer, a SRCVALUE for the destination, and a SRCVALUE for the
+  /// source.
+  VACOPY,
+
+  /// VAEND, VASTART - VAEND and VASTART have three operands: an input chain,
+  /// pointer, and a SRCVALUE.
+  VAEND,
+  VASTART,
+
+  // PREALLOCATED_SETUP - This has 2 operands: an input chain and a SRCVALUE
+  // with the preallocated call Value.
+  PREALLOCATED_SETUP,
+  // PREALLOCATED_ARG - This has 3 operands: an input chain, a SRCVALUE
+  // with the preallocated call Value, and a constant int.
+  PREALLOCATED_ARG,
+
+  /// SRCVALUE - This is a node type that holds a Value* that is used to
+  /// make reference to a value in the LLVM IR.
+  SRCVALUE,
+
+  /// MDNODE_SDNODE - This is a node that holdes an MDNode*, which is used to
+  /// reference metadata in the IR.
+  MDNODE_SDNODE,
+
+  /// PCMARKER - This corresponds to the pcmarker intrinsic.
+  PCMARKER,
+
+  /// READCYCLECOUNTER - This corresponds to the readcyclecounter intrinsic.
+  /// It produces a chain and one i64 value. The only operand is a chain.
+  /// If i64 is not legal, the result will be expanded into smaller values.
+  /// Still, it returns an i64, so targets should set legality for i64.
+  /// The result is the content of the architecture-specific cycle
+  /// counter-like register (or other high accuracy low latency clock source).
+  READCYCLECOUNTER,
+
+  /// HANDLENODE node - Used as a handle for various purposes.
+  HANDLENODE,
+
+  /// INIT_TRAMPOLINE - This corresponds to the init_trampoline intrinsic.  It
+  /// takes as input a token chain, the pointer to the trampoline, the pointer
+  /// to the nested function, the pointer to pass for the 'nest' parameter, a
+  /// SRCVALUE for the trampoline and another for the nested function
+  /// (allowing targets to access the original Function*).
+  /// It produces a token chain as output.
+  INIT_TRAMPOLINE,
+
+  /// ADJUST_TRAMPOLINE - This corresponds to the adjust_trampoline intrinsic.
+  /// It takes a pointer to the trampoline and produces a (possibly) new
+  /// pointer to the same trampoline with platform-specific adjustments
+  /// applied.  The pointer it returns points to an executable block of code.
+  ADJUST_TRAMPOLINE,
+
+  /// TRAP - Trapping instruction
+  TRAP,
+
+  /// DEBUGTRAP - Trap intended to get the attention of a debugger.
+  DEBUGTRAP,
+
+  /// UBSANTRAP - Trap with an immediate describing the kind of sanitizer failure.
+  UBSANTRAP,
+
+  /// PREFETCH - This corresponds to a prefetch intrinsic. The first operand
+  /// is the chain.  The other operands are the address to prefetch,
+  /// read / write specifier, locality specifier and instruction / data cache
+  /// specifier.
+  PREFETCH,
+
+  /// OUTCHAIN = ATOMIC_FENCE(INCHAIN, ordering, scope)
+  /// This corresponds to the fence instruction. It takes an input chain, and
+  /// two integer constants: an AtomicOrdering and a SynchronizationScope.
+  ATOMIC_FENCE,
+
+  /// Val, OUTCHAIN = ATOMIC_LOAD(INCHAIN, ptr)
+  /// This corresponds to "load atomic" instruction.
+  ATOMIC_LOAD,
+
+  /// OUTCHAIN = ATOMIC_STORE(INCHAIN, ptr, val)
+  /// This corresponds to "store atomic" instruction.
+  ATOMIC_STORE,
+
+  /// Val, OUTCHAIN = ATOMIC_CMP_SWAP(INCHAIN, ptr, cmp, swap)
+  /// For double-word atomic operations:
+  /// ValLo, ValHi, OUTCHAIN = ATOMIC_CMP_SWAP(INCHAIN, ptr, cmpLo, cmpHi,
+  ///                                          swapLo, swapHi)
+  /// This corresponds to the cmpxchg instruction.
+  ATOMIC_CMP_SWAP,
+
+  /// Val, Success, OUTCHAIN
+  ///     = ATOMIC_CMP_SWAP_WITH_SUCCESS(INCHAIN, ptr, cmp, swap)
+  /// N.b. this is still a strong cmpxchg operation, so
+  /// Success == "Val == cmp".
+  ATOMIC_CMP_SWAP_WITH_SUCCESS,
+
+  /// Val, OUTCHAIN = ATOMIC_SWAP(INCHAIN, ptr, amt)
+  /// Val, OUTCHAIN = ATOMIC_LOAD_[OpName](INCHAIN, ptr, amt)
+  /// For double-word atomic operations:
+  /// ValLo, ValHi, OUTCHAIN = ATOMIC_SWAP(INCHAIN, ptr, amtLo, amtHi)
+  /// ValLo, ValHi, OUTCHAIN = ATOMIC_LOAD_[OpName](INCHAIN, ptr, amtLo, amtHi)
+  /// These correspond to the atomicrmw instruction.
+  ATOMIC_SWAP,
+  ATOMIC_LOAD_ADD,
+  ATOMIC_LOAD_SUB,
+  ATOMIC_LOAD_AND,
+  ATOMIC_LOAD_CLR,
+  ATOMIC_LOAD_OR,
+  ATOMIC_LOAD_XOR,
+  ATOMIC_LOAD_NAND,
+  ATOMIC_LOAD_MIN,
+  ATOMIC_LOAD_MAX,
+  ATOMIC_LOAD_UMIN,
+  ATOMIC_LOAD_UMAX,
+  ATOMIC_LOAD_FADD,
+  ATOMIC_LOAD_FSUB,
+
+  // Masked load and store - consecutive vector load and store operations
+  // with additional mask operand that prevents memory accesses to the
+  // masked-off lanes.
+  //
+  // Val, OutChain = MLOAD(BasePtr, Mask, PassThru)
+  // OutChain = MSTORE(Value, BasePtr, Mask)
+  MLOAD,
+  MSTORE,
+
+  // Masked gather and scatter - load and store operations for a vector of
+  // random addresses with additional mask operand that prevents memory
+  // accesses to the masked-off lanes.
+  //
+  // Val, OutChain = GATHER(InChain, PassThru, Mask, BasePtr, Index, Scale)
+  // OutChain = SCATTER(InChain, Value, Mask, BasePtr, Index, Scale)
+  //
+  // The Index operand can have more vector elements than the other operands
+  // due to type legalization. The extra elements are ignored.
+  MGATHER,
+  MSCATTER,
+
+  /// This corresponds to the llvm.lifetime.* intrinsics. The first operand
+  /// is the chain and the second operand is the alloca pointer.
+  LIFETIME_START,
+  LIFETIME_END,
+
+  /// GC_TRANSITION_START/GC_TRANSITION_END - These operators mark the
+  /// beginning and end of GC transition  sequence, and carry arbitrary
+  /// information that target might need for lowering.  The first operand is
+  /// a chain, the rest are specified by the target and not touched by the DAG
+  /// optimizers. GC_TRANSITION_START..GC_TRANSITION_END pairs may not be
+  /// nested.
+  GC_TRANSITION_START,
+  GC_TRANSITION_END,
+
+  /// GET_DYNAMIC_AREA_OFFSET - get offset from native SP to the address of
+  /// the most recent dynamic alloca. For most targets that would be 0, but
+  /// for some others (e.g. PowerPC, PowerPC64) that would be compile-time
+  /// known nonzero constant. The only operand here is the chain.
+  GET_DYNAMIC_AREA_OFFSET,
+
+  /// Pseudo probe for AutoFDO, as a place holder in a basic block to improve
+  /// the sample counts quality.
+  PSEUDO_PROBE,
+
+  /// VSCALE(IMM) - Returns the runtime scaling factor used to calculate the
+  /// number of elements within a scalable vector. IMM is a constant integer
+  /// multiplier that is applied to the runtime value.
+  VSCALE,
+
+  /// Generic reduction nodes. These nodes represent horizontal vector
+  /// reduction operations, producing a scalar result.
+  /// The SEQ variants perform reductions in sequential order. The first
+  /// operand is an initial scalar accumulator value, and the second operand
+  /// is the vector to reduce.
+  /// E.g. RES = VECREDUCE_SEQ_FADD f32 ACC, <4 x f32> SRC_VEC
+  ///  ... is equivalent to
+  /// RES = (((ACC + SRC_VEC[0]) + SRC_VEC[1]) + SRC_VEC[2]) + SRC_VEC[3]
+  VECREDUCE_SEQ_FADD,
+  VECREDUCE_SEQ_FMUL,
+
+  /// These reductions have relaxed evaluation order semantics, and have a
+  /// single vector operand. The order of evaluation is unspecified. For
+  /// pow-of-2 vectors, one valid legalizer expansion is to use a tree
+  /// reduction, i.e.:
+  /// For RES = VECREDUCE_FADD <8 x f16> SRC_VEC
+  ///   PART_RDX = FADD SRC_VEC[0:3], SRC_VEC[4:7]
+  ///   PART_RDX2 = FADD PART_RDX[0:1], PART_RDX[2:3]
+  ///   RES = FADD PART_RDX2[0], PART_RDX2[1]
+  /// For non-pow-2 vectors, this can be computed by extracting each element
+  /// and performing the operation as if it were scalarized.
+  VECREDUCE_FADD,
+  VECREDUCE_FMUL,
+  /// FMIN/FMAX nodes can have flags, for NaN/NoNaN variants.
+  VECREDUCE_FMAX,
+  VECREDUCE_FMIN,
+  /// Integer reductions may have a result type larger than the vector element
+  /// type. However, the reduction is performed using the vector element type
+  /// and the value in the top bits is unspecified.
+  VECREDUCE_ADD,
+  VECREDUCE_MUL,
+  VECREDUCE_AND,
+  VECREDUCE_OR,
+  VECREDUCE_XOR,
+  VECREDUCE_SMAX,
+  VECREDUCE_SMIN,
+  VECREDUCE_UMAX,
+  VECREDUCE_UMIN,
+
+// Vector Predication
+#define BEGIN_REGISTER_VP_SDNODE(VPSDID, ...) VPSDID,
+#include "llvm/IR/VPIntrinsics.def"
+
+  /// BUILTIN_OP_END - This must be the last enum value in this list.
+  /// The target-specific pre-isel opcode values start here.
+  BUILTIN_OP_END
+};
+
+/// FIRST_TARGET_STRICTFP_OPCODE - Target-specific pre-isel operations
+/// which cannot raise FP exceptions should be less than this value.
+/// Those that do must not be less than this value.
+static const int FIRST_TARGET_STRICTFP_OPCODE = BUILTIN_OP_END + 400;
+
+/// FIRST_TARGET_MEMORY_OPCODE - Target-specific pre-isel operations
+/// which do not reference a specific memory location should be less than
+/// this value. Those that do must not be less than this value, and can
+/// be used with SelectionDAG::getMemIntrinsicNode.
+static const int FIRST_TARGET_MEMORY_OPCODE = BUILTIN_OP_END + 500;
+
+/// Get underlying scalar opcode for VECREDUCE opcode.
+/// For example ISD::AND for ISD::VECREDUCE_AND.
+NodeType getVecReduceBaseOpcode(unsigned VecReduceOpcode);
+
+/// Whether this is a vector-predicated Opcode.
+bool isVPOpcode(unsigned Opcode);
+
+/// The operand position of the vector mask.
+Optional<unsigned> getVPMaskIdx(unsigned Opcode);
+
+/// The operand position of the explicit vector length parameter.
+Optional<unsigned> getVPExplicitVectorLengthIdx(unsigned Opcode);
+
+//===--------------------------------------------------------------------===//
+/// MemIndexedMode enum - This enum defines the load / store indexed
+/// addressing modes.
+///
+/// UNINDEXED    "Normal" load / store. The effective address is already
+///              computed and is available in the base pointer. The offset
+///              operand is always undefined. In addition to producing a
+///              chain, an unindexed load produces one value (result of the
+///              load); an unindexed store does not produce a value.
+///
+/// PRE_INC      Similar to the unindexed mode where the effective address is
+/// PRE_DEC      the value of the base pointer add / subtract the offset.
+///              It considers the computation as being folded into the load /
+///              store operation (i.e. the load / store does the address
+///              computation as well as performing the memory transaction).
+///              The base operand is always undefined. In addition to
+///              producing a chain, pre-indexed load produces two values
+///              (result of the load and the result of the address
+///              computation); a pre-indexed store produces one value (result
+///              of the address computation).
+///
+/// POST_INC     The effective address is the value of the base pointer. The
+/// POST_DEC     value of the offset operand is then added to / subtracted
+///              from the base after memory transaction. In addition to
+///              producing a chain, post-indexed load produces two values
+///              (the result of the load and the result of the base +/- offset
+///              computation); a post-indexed store produces one value (the
+///              the result of the base +/- offset computation).
+enum MemIndexedMode { UNINDEXED = 0, PRE_INC, PRE_DEC, POST_INC, POST_DEC };
+
+static const int LAST_INDEXED_MODE = POST_DEC + 1;
+
+//===--------------------------------------------------------------------===//
+/// MemIndexType enum - This enum defines how to interpret MGATHER/SCATTER's
+/// index parameter when calculating addresses.
+///
+/// SIGNED_SCALED     Addr = Base + ((signed)Index * sizeof(element))
+/// SIGNED_UNSCALED   Addr = Base + (signed)Index
+/// UNSIGNED_SCALED   Addr = Base + ((unsigned)Index * sizeof(element))
+/// UNSIGNED_UNSCALED Addr = Base + (unsigned)Index
+enum MemIndexType {
+  SIGNED_SCALED = 0,
+  SIGNED_UNSCALED,
+  UNSIGNED_SCALED,
+  UNSIGNED_UNSCALED
+};
+
+static const int LAST_MEM_INDEX_TYPE = UNSIGNED_UNSCALED + 1;
+
+//===--------------------------------------------------------------------===//
+/// LoadExtType enum - This enum defines the three variants of LOADEXT
+/// (load with extension).
+///
+/// SEXTLOAD loads the integer operand and sign extends it to a larger
+///          integer result type.
+/// ZEXTLOAD loads the integer operand and zero extends it to a larger
+///          integer result type.
+/// EXTLOAD  is used for two things: floating point extending loads and
+///          integer extending loads [the top bits are undefined].
+enum LoadExtType { NON_EXTLOAD = 0, EXTLOAD, SEXTLOAD, ZEXTLOAD };
+
+static const int LAST_LOADEXT_TYPE = ZEXTLOAD + 1;
+
+NodeType getExtForLoadExtType(bool IsFP, LoadExtType);
+
+//===--------------------------------------------------------------------===//
+/// ISD::CondCode enum - These are ordered carefully to make the bitfields
+/// below work out, when considering SETFALSE (something that never exists
+/// dynamically) as 0.  "U" -> Unsigned (for integer operands) or Unordered
+/// (for floating point), "L" -> Less than, "G" -> Greater than, "E" -> Equal
+/// to.  If the "N" column is 1, the result of the comparison is undefined if
+/// the input is a NAN.
+///
+/// All of these (except for the 'always folded ops') should be handled for
+/// floating point.  For integer, only the SETEQ,SETNE,SETLT,SETLE,SETGT,
+/// SETGE,SETULT,SETULE,SETUGT, and SETUGE opcodes are used.
+///
+/// Note that these are laid out in a specific order to allow bit-twiddling
+/// to transform conditions.
+enum CondCode {
+  // Opcode       N U L G E       Intuitive operation
+  SETFALSE, //      0 0 0 0       Always false (always folded)
+  SETOEQ,   //      0 0 0 1       True if ordered and equal
+  SETOGT,   //      0 0 1 0       True if ordered and greater than
+  SETOGE,   //      0 0 1 1       True if ordered and greater than or equal
+  SETOLT,   //      0 1 0 0       True if ordered and less than
+  SETOLE,   //      0 1 0 1       True if ordered and less than or equal
+  SETONE,   //      0 1 1 0       True if ordered and operands are unequal
+  SETO,     //      0 1 1 1       True if ordered (no nans)
+  SETUO,    //      1 0 0 0       True if unordered: isnan(X) | isnan(Y)
+  SETUEQ,   //      1 0 0 1       True if unordered or equal
+  SETUGT,   //      1 0 1 0       True if unordered or greater than
+  SETUGE,   //      1 0 1 1       True if unordered, greater than, or equal
+  SETULT,   //      1 1 0 0       True if unordered or less than
+  SETULE,   //      1 1 0 1       True if unordered, less than, or equal
+  SETUNE,   //      1 1 1 0       True if unordered or not equal
+  SETTRUE,  //      1 1 1 1       Always true (always folded)
+  // Don't care operations: undefined if the input is a nan.
+  SETFALSE2, //   1 X 0 0 0       Always false (always folded)
+  SETEQ,     //   1 X 0 0 1       True if equal
+  SETGT,     //   1 X 0 1 0       True if greater than
+  SETGE,     //   1 X 0 1 1       True if greater than or equal
+  SETLT,     //   1 X 1 0 0       True if less than
+  SETLE,     //   1 X 1 0 1       True if less than or equal
+  SETNE,     //   1 X 1 1 0       True if not equal
+  SETTRUE2,  //   1 X 1 1 1       Always true (always folded)
+
+  SETCC_INVALID // Marker value.
+};
+
+/// Return true if this is a setcc instruction that performs a signed
+/// comparison when used with integer operands.
+inline bool isSignedIntSetCC(CondCode Code) {
+  return Code == SETGT || Code == SETGE || Code == SETLT || Code == SETLE;
+}
+
+/// Return true if this is a setcc instruction that performs an unsigned
+/// comparison when used with integer operands.
+inline bool isUnsignedIntSetCC(CondCode Code) {
+  return Code == SETUGT || Code == SETUGE || Code == SETULT || Code == SETULE;
+}
+
+/// Return true if the specified condition returns true if the two operands to
+/// the condition are equal. Note that if one of the two operands is a NaN,
+/// this value is meaningless.
+inline bool isTrueWhenEqual(CondCode Cond) { return ((int)Cond & 1) != 0; }
+
+/// This function returns 0 if the condition is always false if an operand is
+/// a NaN, 1 if the condition is always true if the operand is a NaN, and 2 if
+/// the condition is undefined if the operand is a NaN.
+inline unsigned getUnorderedFlavor(CondCode Cond) {
+  return ((int)Cond >> 3) & 3;
+}
+
+/// Return the operation corresponding to !(X op Y), where 'op' is a valid
+/// SetCC operation.
+CondCode getSetCCInverse(CondCode Operation, EVT Type);
+
+namespace GlobalISel {
+/// Return the operation corresponding to !(X op Y), where 'op' is a valid
+/// SetCC operation. The U bit of the condition code has different meanings
+/// between floating point and integer comparisons and LLT's don't provide
+/// this distinction. As such we need to be told whether the comparison is
+/// floating point or integer-like. Pointers should use integer-like
+/// comparisons.
+CondCode getSetCCInverse(CondCode Operation, bool isIntegerLike);
+} // end namespace GlobalISel
+
+/// Return the operation corresponding to (Y op X) when given the operation
+/// for (X op Y).
+CondCode getSetCCSwappedOperands(CondCode Operation);
+
+/// Return the result of a logical OR between different comparisons of
+/// identical values: ((X op1 Y) | (X op2 Y)). This function returns
+/// SETCC_INVALID if it is not possible to represent the resultant comparison.
+CondCode getSetCCOrOperation(CondCode Op1, CondCode Op2, EVT Type);
+
+/// Return the result of a logical AND between different comparisons of
+/// identical values: ((X op1 Y) & (X op2 Y)). This function returns
+/// SETCC_INVALID if it is not possible to represent the resultant comparison.
+CondCode getSetCCAndOperation(CondCode Op1, CondCode Op2, EVT Type);
+
+} // namespace ISD
+
+} // namespace llvm
 
 #endif
diff --git a/linux-x64/clang/include/llvm/CodeGen/IndirectThunks.h b/linux-x64/clang/include/llvm/CodeGen/IndirectThunks.h
new file mode 100644
index 0000000..810acc0
--- /dev/null
+++ b/linux-x64/clang/include/llvm/CodeGen/IndirectThunks.h
@@ -0,0 +1,110 @@
+//===---- IndirectThunks.h - Indirect Thunk Base Class ----------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// Contains a base class for Passes that inject an MI thunk.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_INDIRECTTHUNKS_H
+#define LLVM_INDIRECTTHUNKS_H
+
+#include "llvm/CodeGen/MachineFunction.h"
+#include "llvm/CodeGen/MachineModuleInfo.h"
+#include "llvm/IR/IRBuilder.h"
+#include "llvm/IR/Module.h"
+
+namespace llvm {
+
+template <typename Derived> class ThunkInserter {
+  Derived &getDerived() { return *static_cast<Derived *>(this); }
+
+protected:
+  bool InsertedThunks;
+  void doInitialization(Module &M) {}
+  void createThunkFunction(MachineModuleInfo &MMI, StringRef Name);
+
+public:
+  void init(Module &M) {
+    InsertedThunks = false;
+    getDerived().doInitialization(M);
+  }
+  // return `true` if `MMI` or `MF` was modified
+  bool run(MachineModuleInfo &MMI, MachineFunction &MF);
+};
+
+template <typename Derived>
+void ThunkInserter<Derived>::createThunkFunction(MachineModuleInfo &MMI,
+                                                 StringRef Name) {
+  assert(Name.startswith(getDerived().getThunkPrefix()) &&
+         "Created a thunk with an unexpected prefix!");
+
+  Module &M = const_cast<Module &>(*MMI.getModule());
+  LLVMContext &Ctx = M.getContext();
+  auto Type = FunctionType::get(Type::getVoidTy(Ctx), false);
+  Function *F =
+      Function::Create(Type, GlobalValue::LinkOnceODRLinkage, Name, &M);
+  F->setVisibility(GlobalValue::HiddenVisibility);
+  F->setComdat(M.getOrInsertComdat(Name));
+
+  // Add Attributes so that we don't create a frame, unwind information, or
+  // inline.
+  AttrBuilder B;
+  B.addAttribute(llvm::Attribute::NoUnwind);
+  B.addAttribute(llvm::Attribute::Naked);
+  F->addAttributes(llvm::AttributeList::FunctionIndex, B);
+
+  // Populate our function a bit so that we can verify.
+  BasicBlock *Entry = BasicBlock::Create(Ctx, "entry", F);
+  IRBuilder<> Builder(Entry);
+
+  Builder.CreateRetVoid();
+
+  // MachineFunctions aren't created automatically for the IR-level constructs
+  // we already made. Create them and insert them into the module.
+  MachineFunction &MF = MMI.getOrCreateMachineFunction(*F);
+  // A MachineBasicBlock must not be created for the Entry block; code
+  // generation from an empty naked function in C source code also does not
+  // generate one.  At least GlobalISel asserts if this invariant isn't
+  // respected.
+
+  // Set MF properties. We never use vregs...
+  MF.getProperties().set(MachineFunctionProperties::Property::NoVRegs);
+}
+
+template <typename Derived>
+bool ThunkInserter<Derived>::run(MachineModuleInfo &MMI, MachineFunction &MF) {
+  // If MF is not a thunk, check to see if we need to insert a thunk.
+  if (!MF.getName().startswith(getDerived().getThunkPrefix())) {
+    // If we've already inserted a thunk, nothing else to do.
+    if (InsertedThunks)
+      return false;
+
+    // Only add a thunk if one of the functions has the corresponding feature
+    // enabled in its subtarget, and doesn't enable external thunks.
+    // FIXME: Conditionalize on indirect calls so we don't emit a thunk when
+    // nothing will end up calling it.
+    // FIXME: It's a little silly to look at every function just to enumerate
+    // the subtargets, but eventually we'll want to look at them for indirect
+    // calls, so maybe this is OK.
+    if (!getDerived().mayUseThunk(MF))
+      return false;
+
+    getDerived().insertThunks(MMI);
+    InsertedThunks = true;
+    return true;
+  }
+
+  // If this *is* a thunk function, we need to populate it with the correct MI.
+  getDerived().populateThunk(MF);
+  return true;
+}
+
+} // namespace llvm
+
+#endif
diff --git a/linux-x64/clang/include/llvm/CodeGen/IntrinsicLowering.h b/linux-x64/clang/include/llvm/CodeGen/IntrinsicLowering.h
index daf2d9a..8593f54 100644
--- a/linux-x64/clang/include/llvm/CodeGen/IntrinsicLowering.h
+++ b/linux-x64/clang/include/llvm/CodeGen/IntrinsicLowering.h
@@ -19,7 +19,6 @@
 
 namespace llvm {
 class CallInst;
-class Module;
 class DataLayout;
 
 class IntrinsicLowering {
diff --git a/linux-x64/clang/include/llvm/CodeGen/LexicalScopes.h b/linux-x64/clang/include/llvm/CodeGen/LexicalScopes.h
index 253d473..9617ba8 100644
--- a/linux-x64/clang/include/llvm/CodeGen/LexicalScopes.h
+++ b/linux-x64/clang/include/llvm/CodeGen/LexicalScopes.h
@@ -163,8 +163,8 @@
   void getMachineBasicBlocks(const DILocation *DL,
                              SmallPtrSetImpl<const MachineBasicBlock *> &MBBs);
 
-  /// dominates - Return true if DebugLoc's lexical scope dominates at least one
-  /// machine instruction's lexical scope in a given machine basic block.
+  /// Return true if DebugLoc's lexical scope dominates at least one machine
+  /// instruction's lexical scope in a given machine basic block.
   bool dominates(const DILocation *DL, MachineBasicBlock *MBB);
 
   /// findLexicalScope - Find lexical scope, either regular or inlined, for the
@@ -194,9 +194,6 @@
     return I != LexicalScopeMap.end() ? &I->second : nullptr;
   }
 
-  /// dump - Print data structures to dbgs().
-  void dump() const;
-
   /// getOrCreateAbstractScope - Find or create an abstract lexical scope.
   LexicalScope *getOrCreateAbstractScope(const DILocalScope *Scope);
 
@@ -250,6 +247,11 @@
   /// CurrentFnLexicalScope - Top level scope for the current function.
   ///
   LexicalScope *CurrentFnLexicalScope = nullptr;
+
+  /// Map a location to the set of basic blocks it dominates. This is a cache
+  /// for \ref LexicalScopes::getMachineBasicBlocks results.
+  using BlockSetT = SmallPtrSet<const MachineBasicBlock *, 4>;
+  DenseMap<const DILocation *, std::unique_ptr<BlockSetT>> DominatedBlocks;
 };
 
 } // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/CodeGen/LiveInterval.h b/linux-x64/clang/include/llvm/CodeGen/LiveInterval.h
index 8bb8816..c2b158a 100644
--- a/linux-x64/clang/include/llvm/CodeGen/LiveInterval.h
+++ b/linux-x64/clang/include/llvm/CodeGen/LiveInterval.h
@@ -25,6 +25,7 @@
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/iterator_range.h"
+#include "llvm/CodeGen/Register.h"
 #include "llvm/CodeGen/SlotIndexes.h"
 #include "llvm/MC/LaneBitmask.h"
 #include "llvm/Support/Allocator.h"
@@ -189,6 +190,10 @@
         return start == Other.start && end == Other.end;
       }
 
+      bool operator!=(const Segment &Other) const {
+        return !(*this == Other);
+      }
+
       void dump() const;
     };
 
@@ -224,7 +229,7 @@
 
     /// Constructs a new LiveRange object.
     LiveRange(bool UseSegmentSet = false)
-        : segmentSet(UseSegmentSet ? llvm::make_unique<SegmentSet>()
+        : segmentSet(UseSegmentSet ? std::make_unique<SegmentSet>()
                                    : nullptr) {}
 
     /// Constructs a new LiveRange object by copying segments and valnos from
@@ -593,10 +598,9 @@
     /// @p End.
     bool isUndefIn(ArrayRef<SlotIndex> Undefs, SlotIndex Begin,
                    SlotIndex End) const {
-      return std::any_of(Undefs.begin(), Undefs.end(),
-                [Begin,End] (SlotIndex Idx) -> bool {
-                  return Begin <= Idx && Idx < End;
-                });
+      return llvm::any_of(Undefs, [Begin, End](SlotIndex Idx) -> bool {
+        return Begin <= Idx && Idx < End;
+      });
     }
 
     /// Flush segment set into the regular segment vector.
@@ -613,7 +617,7 @@
     /// subranges). Returns true if found at least one index.
     template <typename Range, typename OutputIt>
     bool findIndexesLiveAt(Range &&R, OutputIt O) const {
-      assert(std::is_sorted(R.begin(), R.end()));
+      assert(llvm::is_sorted(R));
       auto Idx = R.begin(), EndIdx = R.end();
       auto Seg = segments.begin(), EndSeg = segments.end();
       bool Found = false;
@@ -621,11 +625,12 @@
         // if the Seg is lower find first segment that is above Idx using binary
         // search
         if (Seg->end <= *Idx) {
-          Seg = std::upper_bound(++Seg, EndSeg, *Idx,
-            [=](typename std::remove_reference<decltype(*Idx)>::type V,
-                const typename std::remove_reference<decltype(*Seg)>::type &S) {
-              return V < S.end;
-            });
+          Seg = std::upper_bound(
+              ++Seg, EndSeg, *Idx,
+              [=](std::remove_reference_t<decltype(*Idx)> V,
+                  const std::remove_reference_t<decltype(*Seg)> &S) {
+                return V < S.end;
+              });
           if (Seg == EndSeg)
             break;
         }
@@ -699,12 +704,16 @@
   private:
     SubRange *SubRanges = nullptr; ///< Single linked list of subregister live
                                    /// ranges.
+    const Register Reg; // the register or stack slot of this interval.
+    float Weight = 0.0; // weight of this interval
 
   public:
-    const unsigned reg;  // the register or stack slot of this interval.
-    float weight;        // weight of this interval
+    Register reg() const { return Reg; }
+    float weight() const { return Weight; }
+    void incrementWeight(float Inc) { Weight += Inc; }
+    void setWeight(float Value) { Weight = Value; }
 
-    LiveInterval(unsigned Reg, float Weight) : reg(Reg), weight(Weight) {}
+    LiveInterval(unsigned Reg, float Weight) : Reg(Reg), Weight(Weight) {}
 
     ~LiveInterval() {
       clearSubRanges();
@@ -726,10 +735,10 @@
         ++*this;
         return res;
       }
-      bool operator!=(const SingleLinkedListIterator<T> &Other) {
+      bool operator!=(const SingleLinkedListIterator<T> &Other) const {
         return P != Other.operator->();
       }
-      bool operator==(const SingleLinkedListIterator<T> &Other) {
+      bool operator==(const SingleLinkedListIterator<T> &Other) const {
         return P == Other.operator->();
       }
       T &operator*() const {
@@ -801,14 +810,10 @@
     unsigned getSize() const;
 
     /// isSpillable - Can this interval be spilled?
-    bool isSpillable() const {
-      return weight != huge_valf;
-    }
+    bool isSpillable() const { return Weight != huge_valf; }
 
     /// markNotSpillable - Mark interval as not spillable
-    void markNotSpillable() {
-      weight = huge_valf;
-    }
+    void markNotSpillable() { Weight = huge_valf; }
 
     /// For a given lane mask @p LaneMask, compute indexes at which the
     /// lane is marked undefined by subregister <def,read-undef> definitions.
@@ -829,18 +834,43 @@
     ///    function will be applied to the L0010 and L0008 subranges.
     ///
     /// \p Indexes and \p TRI are required to clean up the VNIs that
-    /// don't defne the related lane masks after they get shrunk. E.g.,
+    /// don't define the related lane masks after they get shrunk. E.g.,
     /// when L000F gets split into L0007 and L0008 maybe only a subset
     /// of the VNIs that defined L000F defines L0007.
+    ///
+    /// The clean up of the VNIs need to look at the actual instructions
+    /// to decide what is or is not live at a definition point. If the
+    /// update of the subranges occurs while the IR does not reflect these
+    /// changes, \p ComposeSubRegIdx can be used to specify how the
+    /// definition are going to be rewritten.
+    /// E.g., let say we want to merge:
+    ///     V1.sub1:<2 x s32> = COPY V2.sub3:<4 x s32>
+    /// We do that by choosing a class where sub1:<2 x s32> and sub3:<4 x s32>
+    /// overlap, i.e., by choosing a class where we can find "offset + 1 == 3".
+    /// Put differently we align V2's sub3 with V1's sub1:
+    /// V2: sub0 sub1 sub2 sub3
+    /// V1: <offset>  sub0 sub1
+    ///
+    /// This offset will look like a composed subregidx in the the class:
+    ///     V1.(composed sub2 with sub1):<4 x s32> = COPY V2.sub3:<4 x s32>
+    /// =>  V1.(composed sub2 with sub1):<4 x s32> = COPY V2.sub3:<4 x s32>
+    ///
+    /// Now if we didn't rewrite the uses and def of V1, all the checks for V1
+    /// need to account for this offset.
+    /// This happens during coalescing where we update the live-ranges while
+    /// still having the old IR around because updating the IR on-the-fly
+    /// would actually clobber some information on how the live-ranges that
+    /// are being updated look like.
     void refineSubRanges(BumpPtrAllocator &Allocator, LaneBitmask LaneMask,
                          std::function<void(LiveInterval::SubRange &)> Apply,
                          const SlotIndexes &Indexes,
-                         const TargetRegisterInfo &TRI);
+                         const TargetRegisterInfo &TRI,
+                         unsigned ComposeSubRegIdx = 0);
 
     bool operator<(const LiveInterval& other) const {
       const SlotIndex &thisIndex = beginIndex();
       const SlotIndex &otherIndex = other.beginIndex();
-      return std::tie(thisIndex, reg) < std::tie(otherIndex, other.reg);
+      return std::tie(thisIndex, Reg) < std::tie(otherIndex, other.Reg);
     }
 
     void print(raw_ostream &OS) const;
diff --git a/linux-x64/clang/include/llvm/CodeGen/LiveIntervalCalc.h b/linux-x64/clang/include/llvm/CodeGen/LiveIntervalCalc.h
new file mode 100644
index 0000000..76005e8
--- /dev/null
+++ b/linux-x64/clang/include/llvm/CodeGen/LiveIntervalCalc.h
@@ -0,0 +1,71 @@
+//===- LiveIntervalCalc.h - Calculate live intervals -----------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// The LiveIntervalCalc class is an extension of LiveRangeCalc targeted to the
+// computation and modification of the LiveInterval variants of LiveRanges.
+// LiveIntervals are meant to track liveness of registers and stack slots and
+// LiveIntervalCalc adds to LiveRangeCalc all the machinery requied to
+// construct the liveness of virtual registers tracked by a LiveInterval.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIB_CODEGEN_LIVEINTERVALCALC_H
+#define LLVM_LIB_CODEGEN_LIVEINTERVALCALC_H
+
+#include "llvm/CodeGen/LiveRangeCalc.h"
+
+namespace llvm {
+
+template <class NodeT> class DomTreeNodeBase;
+
+using MachineDomTreeNode = DomTreeNodeBase<MachineBasicBlock>;
+
+class LiveIntervalCalc : public LiveRangeCalc {
+  /// Extend the live range of @p LR to reach all uses of Reg.
+  ///
+  /// If @p LR is a main range, or if @p LI is null, then all uses must be
+  /// jointly dominated by the definitions from @p LR. If @p LR is a subrange
+  /// of the live interval @p LI, corresponding to lane mask @p LaneMask,
+  /// all uses must be jointly dominated by the definitions from @p LR
+  /// together with definitions of other lanes where @p LR becomes undefined
+  /// (via <def,read-undef> operands).
+  /// If @p LR is a main range, the @p LaneMask should be set to ~0, i.e.
+  /// LaneBitmask::getAll().
+  void extendToUses(LiveRange &LR, Register Reg, LaneBitmask LaneMask,
+                    LiveInterval *LI = nullptr);
+
+public:
+  LiveIntervalCalc() = default;
+
+  /// createDeadDefs - Create a dead def in LI for every def operand of Reg.
+  /// Each instruction defining Reg gets a new VNInfo with a corresponding
+  /// minimal live range.
+  void createDeadDefs(LiveRange &LR, Register Reg);
+
+  /// Extend the live range of @p LR to reach all uses of Reg.
+  ///
+  /// All uses must be jointly dominated by existing liveness.  PHI-defs are
+  /// inserted as needed to preserve SSA form.
+  void extendToUses(LiveRange &LR, MCRegister PhysReg) {
+    extendToUses(LR, PhysReg, LaneBitmask::getAll());
+  }
+
+  /// Calculates liveness for the register specified in live interval @p LI.
+  /// Creates subregister live ranges as needed if subreg liveness tracking is
+  /// enabled.
+  void calculate(LiveInterval &LI, bool TrackSubRegs);
+
+  /// For live interval \p LI with correct SubRanges construct matching
+  /// information for the main live range. Expects the main live range to not
+  /// have any segments or value numbers.
+  void constructMainRangeFromSubranges(LiveInterval &LI);
+};
+
+} // end namespace llvm
+
+#endif // LLVM_LIB_CODEGEN_LIVEINTERVALCALC_H
diff --git a/linux-x64/clang/include/llvm/CodeGen/LiveIntervalUnion.h b/linux-x64/clang/include/llvm/CodeGen/LiveIntervalUnion.h
index 05506d2..ad9e06d 100644
--- a/linux-x64/clang/include/llvm/CodeGen/LiveIntervalUnion.h
+++ b/linux-x64/clang/include/llvm/CodeGen/LiveIntervalUnion.h
@@ -75,6 +75,7 @@
 
   bool empty() const { return Segments.empty(); }
   SlotIndex startIndex() const { return Segments.start(); }
+  SlotIndex endIndex() const { return Segments.stop(); }
 
   // Provide public access to the underlying map to allow overlap iteration.
   using Map = LiveSegments;
@@ -103,6 +104,9 @@
   void verify(LiveVirtRegBitSet& VisitedVRegs);
 #endif
 
+  // Get any virtual register that is assign to this physical unit
+  LiveInterval *getOneVReg() const;
+
   /// Query interferences between a single live virtual register and a live
   /// interval union.
   class Query {
diff --git a/linux-x64/clang/include/llvm/CodeGen/LiveIntervals.h b/linux-x64/clang/include/llvm/CodeGen/LiveIntervals.h
index 588b0f9..fa08166 100644
--- a/linux-x64/clang/include/llvm/CodeGen/LiveIntervals.h
+++ b/linux-x64/clang/include/llvm/CodeGen/LiveIntervals.h
@@ -22,7 +22,6 @@
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/IndexedMap.h"
 #include "llvm/ADT/SmallVector.h"
-#include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/CodeGen/LiveInterval.h"
 #include "llvm/CodeGen/MachineBasicBlock.h"
 #include "llvm/CodeGen/MachineFunctionPass.h"
@@ -40,8 +39,9 @@
 
 extern cl::opt<bool> UseSegmentSetForPhysRegs;
 
+class AAResults;
 class BitVector;
-class LiveRangeCalc;
+class LiveIntervalCalc;
 class MachineBlockFrequencyInfo;
 class MachineDominatorTree;
 class MachineFunction;
@@ -56,10 +56,10 @@
     MachineRegisterInfo* MRI;
     const TargetRegisterInfo* TRI;
     const TargetInstrInfo* TII;
-    AliasAnalysis *AA;
+    AAResults *AA;
     SlotIndexes* Indexes;
     MachineDominatorTree *DomTree = nullptr;
-    LiveRangeCalc *LRCalc = nullptr;
+    LiveIntervalCalc *LICalc = nullptr;
 
     /// Special pool allocator for VNInfo's (LiveInterval val#).
     VNInfo::Allocator VNInfoAllocator;
@@ -111,44 +111,45 @@
                                 const MachineBlockFrequencyInfo *MBFI,
                                 const MachineBasicBlock *MBB);
 
-    LiveInterval &getInterval(unsigned Reg) {
+    LiveInterval &getInterval(Register Reg) {
       if (hasInterval(Reg))
-        return *VirtRegIntervals[Reg];
-      else
-        return createAndComputeVirtRegInterval(Reg);
+        return *VirtRegIntervals[Reg.id()];
+
+      return createAndComputeVirtRegInterval(Reg);
     }
 
-    const LiveInterval &getInterval(unsigned Reg) const {
+    const LiveInterval &getInterval(Register Reg) const {
       return const_cast<LiveIntervals*>(this)->getInterval(Reg);
     }
 
-    bool hasInterval(unsigned Reg) const {
-      return VirtRegIntervals.inBounds(Reg) && VirtRegIntervals[Reg];
+    bool hasInterval(Register Reg) const {
+      return VirtRegIntervals.inBounds(Reg.id()) &&
+             VirtRegIntervals[Reg.id()];
     }
 
     /// Interval creation.
-    LiveInterval &createEmptyInterval(unsigned Reg) {
+    LiveInterval &createEmptyInterval(Register Reg) {
       assert(!hasInterval(Reg) && "Interval already exists!");
-      VirtRegIntervals.grow(Reg);
-      VirtRegIntervals[Reg] = createInterval(Reg);
-      return *VirtRegIntervals[Reg];
+      VirtRegIntervals.grow(Reg.id());
+      VirtRegIntervals[Reg.id()] = createInterval(Reg);
+      return *VirtRegIntervals[Reg.id()];
     }
 
-    LiveInterval &createAndComputeVirtRegInterval(unsigned Reg) {
+    LiveInterval &createAndComputeVirtRegInterval(Register Reg) {
       LiveInterval &LI = createEmptyInterval(Reg);
       computeVirtRegInterval(LI);
       return LI;
     }
 
     /// Interval removal.
-    void removeInterval(unsigned Reg) {
+    void removeInterval(Register Reg) {
       delete VirtRegIntervals[Reg];
       VirtRegIntervals[Reg] = nullptr;
     }
 
     /// Given a register and an instruction, adds a live segment from that
     /// instruction to the end of its MBB.
-    LiveInterval::Segment addSegmentToEndOfBlock(unsigned reg,
+    LiveInterval::Segment addSegmentToEndOfBlock(Register Reg,
                                                  MachineInstr &startInst);
 
     /// After removing some uses of a register, shrink its live range to just
@@ -166,7 +167,7 @@
     /// the lane mask of the subregister range.
     /// This may leave the subrange empty which needs to be cleaned up with
     /// LiveInterval::removeEmptySubranges() afterwards.
-    void shrinkToUses(LiveInterval::SubRange &SR, unsigned Reg);
+    void shrinkToUses(LiveInterval::SubRange &SR, Register Reg);
 
     /// Extend the live range \p LR to reach all points in \p Indices. The
     /// points in the \p Indices array must be jointly dominated by the union
@@ -211,7 +212,7 @@
       return Indexes;
     }
 
-    AliasAnalysis *getAliasAnalysis() const {
+    AAResults *getAliasAnalysis() const {
       return AA;
     }
 
@@ -309,16 +310,16 @@
     /// \param UpdateFlags Update live intervals for nonallocatable physregs.
     void handleMove(MachineInstr &MI, bool UpdateFlags = false);
 
-    /// Update intervals for operands of \p MI so that they begin/end on the
-    /// SlotIndex for \p BundleStart.
+    /// Update intervals of operands of all instructions in the newly
+    /// created bundle specified by \p BundleStart.
     ///
     /// \param UpdateFlags Update live intervals for nonallocatable physregs.
     ///
-    /// Requires MI and BundleStart to have SlotIndexes, and assumes
-    /// existing liveness is accurate. BundleStart should be the first
-    /// instruction in the Bundle.
-    void handleMoveIntoBundle(MachineInstr &MI, MachineInstr &BundleStart,
-                              bool UpdateFlags = false);
+    /// Assumes existing liveness is accurate.
+    /// \pre BundleStart should be the first instruction in the Bundle.
+    /// \pre BundleStart should not have a have SlotIndex as one will be assigned.
+    void handleMoveIntoNewBundle(MachineInstr &BundleStart,
+                                 bool UpdateFlags = false);
 
     /// Update live intervals for instructions in a range of iterators. It is
     /// intended for use after target hooks that may insert or remove
@@ -332,7 +333,7 @@
     void repairIntervalsInRange(MachineBasicBlock *MBB,
                                 MachineBasicBlock::iterator Begin,
                                 MachineBasicBlock::iterator End,
-                                ArrayRef<unsigned> OrigRegs);
+                                ArrayRef<Register> OrigRegs);
 
     // Register mask functions.
     //
@@ -421,7 +422,7 @@
     /// Reg. Subsequent uses should rely on on-demand recomputation.  \note This
     /// method can result in inconsistent liveness tracking if multiple phyical
     /// registers share a regunit, and should be used cautiously.
-    void removeAllRegUnitsForPhysReg(unsigned Reg) {
+    void removeAllRegUnitsForPhysReg(MCRegister Reg) {
       for (MCRegUnitIterator Units(Reg, TRI); Units.isValid(); ++Units)
         removeRegUnit(*Units);
     }
@@ -429,7 +430,7 @@
     /// Remove value numbers and related live segments starting at position
     /// \p Pos that are part of any liverange of physical register \p Reg or one
     /// of its subregisters.
-    void removePhysRegDefAt(unsigned Reg, SlotIndex Pos);
+    void removePhysRegDefAt(MCRegister Reg, SlotIndex Pos);
 
     /// Remove value number and related live segments of \p LI and its subranges
     /// that start at position \p Pos.
@@ -461,18 +462,18 @@
     bool computeDeadValues(LiveInterval &LI,
                            SmallVectorImpl<MachineInstr*> *dead);
 
-    static LiveInterval* createInterval(unsigned Reg);
+    static LiveInterval *createInterval(Register Reg);
 
     void printInstrs(raw_ostream &O) const;
     void dumpInstrs() const;
 
     void computeLiveInRegUnits();
     void computeRegUnitRange(LiveRange&, unsigned Unit);
-    void computeVirtRegInterval(LiveInterval&);
+    bool computeVirtRegInterval(LiveInterval&);
 
     using ShrinkToUsesWorkList = SmallVector<std::pair<SlotIndex, VNInfo*>, 16>;
     void extendSegmentsToUses(LiveRange &Segments,
-                              ShrinkToUsesWorkList &WorkList, unsigned Reg,
+                              ShrinkToUsesWorkList &WorkList, Register Reg,
                               LaneBitmask LaneMask);
 
     /// Helper function for repairIntervalsInRange(), walks backwards and
@@ -482,7 +483,7 @@
     void repairOldRegInRange(MachineBasicBlock::iterator Begin,
                              MachineBasicBlock::iterator End,
                              const SlotIndex endIdx, LiveRange &LR,
-                             unsigned Reg,
+                             Register Reg,
                              LaneBitmask LaneMask = LaneBitmask::getAll());
 
     class HMEditor;
diff --git a/linux-x64/clang/include/llvm/CodeGen/LivePhysRegs.h b/linux-x64/clang/include/llvm/CodeGen/LivePhysRegs.h
index 50da0b3..0858934 100644
--- a/linux-x64/clang/include/llvm/CodeGen/LivePhysRegs.h
+++ b/linux-x64/clang/include/llvm/CodeGen/LivePhysRegs.h
@@ -137,6 +137,9 @@
   /// Live out registers are the union of the live-in registers of the successor
   /// blocks and pristine registers. Live out registers of the end block are the
   /// callee saved registers.
+  /// If a register is not added by this method, it is guaranteed to not be
+  /// live out from MBB, although a sub-register may be. This is true
+  /// both before and after regalloc.
   void addLiveOuts(const MachineBasicBlock &MBB);
 
   /// Adds all live-out registers of basic block \p MBB but skips pristine
diff --git a/linux-x64/clang/include/llvm/CodeGen/LiveRangeCalc.h b/linux-x64/clang/include/llvm/CodeGen/LiveRangeCalc.h
new file mode 100644
index 0000000..bbb6f2d
--- /dev/null
+++ b/linux-x64/clang/include/llvm/CodeGen/LiveRangeCalc.h
@@ -0,0 +1,270 @@
+//===- LiveRangeCalc.h - Calculate live ranges -----------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// The LiveRangeCalc class can be used to implement the computation of
+// live ranges from scratch.
+// It caches information about values in the CFG to speed up repeated
+// operations on the same live range.  The cache can be shared by
+// non-overlapping live ranges. SplitKit uses that when computing the live
+// range of split products.
+//
+// A low-level interface is available to clients that know where a variable is
+// live, but don't know which value it has as every point.  LiveRangeCalc will
+// propagate values down the dominator tree, and even insert PHI-defs where
+// needed. SplitKit uses this faster interface when possible.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIB_CODEGEN_LIVERANGECALC_H
+#define LLVM_LIB_CODEGEN_LIVERANGECALC_H
+
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/BitVector.h"
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/IndexedMap.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/CodeGen/LiveInterval.h"
+#include "llvm/CodeGen/MachineBasicBlock.h"
+#include "llvm/CodeGen/SlotIndexes.h"
+#include "llvm/MC/LaneBitmask.h"
+#include <utility>
+
+namespace llvm {
+
+template <class NodeT> class DomTreeNodeBase;
+class MachineDominatorTree;
+class MachineFunction;
+class MachineRegisterInfo;
+
+using MachineDomTreeNode = DomTreeNodeBase<MachineBasicBlock>;
+
+class LiveRangeCalc {
+  const MachineFunction *MF = nullptr;
+  const MachineRegisterInfo *MRI = nullptr;
+  SlotIndexes *Indexes = nullptr;
+  MachineDominatorTree *DomTree = nullptr;
+  VNInfo::Allocator *Alloc = nullptr;
+
+  /// LiveOutPair - A value and the block that defined it.  The domtree node is
+  /// redundant, it can be computed as: MDT[Indexes.getMBBFromIndex(VNI->def)].
+  using LiveOutPair = std::pair<VNInfo *, MachineDomTreeNode *>;
+
+  /// LiveOutMap - Map basic blocks to the value leaving the block.
+  using LiveOutMap = IndexedMap<LiveOutPair, MBB2NumberFunctor>;
+
+  /// Bit vector of active entries in LiveOut, also used as a visited set by
+  /// findReachingDefs.  One entry per basic block, indexed by block number.
+  /// This is kept as a separate bit vector because it can be cleared quickly
+  /// when switching live ranges.
+  BitVector Seen;
+
+  /// Map LiveRange to sets of blocks (represented by bit vectors) that
+  /// in the live range are defined on entry and undefined on entry.
+  /// A block is defined on entry if there is a path from at least one of
+  /// the defs in the live range to the entry of the block, and conversely,
+  /// a block is undefined on entry, if there is no such path (i.e. no
+  /// definition reaches the entry of the block). A single LiveRangeCalc
+  /// object is used to track live-out information for multiple registers
+  /// in live range splitting (which is ok, since the live ranges of these
+  /// registers do not overlap), but the defined/undefined information must
+  /// be kept separate for each individual range.
+  /// By convention, EntryInfoMap[&LR] = { Defined, Undefined }.
+  using EntryInfoMap = DenseMap<LiveRange *, std::pair<BitVector, BitVector>>;
+  EntryInfoMap EntryInfos;
+
+  /// Map each basic block where a live range is live out to the live-out value
+  /// and its defining block.
+  ///
+  /// For every basic block, MBB, one of these conditions shall be true:
+  ///
+  ///  1. !Seen.count(MBB->getNumber())
+  ///     Blocks without a Seen bit are ignored.
+  ///  2. LiveOut[MBB].second.getNode() == MBB
+  ///     The live-out value is defined in MBB.
+  ///  3. forall P in preds(MBB): LiveOut[P] == LiveOut[MBB]
+  ///     The live-out value passses through MBB. All predecessors must carry
+  ///     the same value.
+  ///
+  /// The domtree node may be null, it can be computed.
+  ///
+  /// The map can be shared by multiple live ranges as long as no two are
+  /// live-out of the same block.
+  LiveOutMap Map;
+
+  /// LiveInBlock - Information about a basic block where a live range is known
+  /// to be live-in, but the value has not yet been determined.
+  struct LiveInBlock {
+    // The live range set that is live-in to this block.  The algorithms can
+    // handle multiple non-overlapping live ranges simultaneously.
+    LiveRange &LR;
+
+    // DomNode - Dominator tree node for the block.
+    // Cleared when the final value has been determined and LI has been updated.
+    MachineDomTreeNode *DomNode;
+
+    // Position in block where the live-in range ends, or SlotIndex() if the
+    // range passes through the block.  When the final value has been
+    // determined, the range from the block start to Kill will be added to LI.
+    SlotIndex Kill;
+
+    // Live-in value filled in by updateSSA once it is known.
+    VNInfo *Value = nullptr;
+
+    LiveInBlock(LiveRange &LR, MachineDomTreeNode *node, SlotIndex kill)
+        : LR(LR), DomNode(node), Kill(kill) {}
+  };
+
+  /// LiveIn - Work list of blocks where the live-in value has yet to be
+  /// determined.  This list is typically computed by findReachingDefs() and
+  /// used as a work list by updateSSA().  The low-level interface may also be
+  /// used to add entries directly.
+  SmallVector<LiveInBlock, 16> LiveIn;
+
+  /// Check if the entry to block @p MBB can be reached by any of the defs
+  /// in @p LR. Return true if none of the defs reach the entry to @p MBB.
+  bool isDefOnEntry(LiveRange &LR, ArrayRef<SlotIndex> Undefs,
+                    MachineBasicBlock &MBB, BitVector &DefOnEntry,
+                    BitVector &UndefOnEntry);
+
+  /// Find the set of defs that can reach @p Kill. @p Kill must belong to
+  /// @p UseMBB.
+  ///
+  /// If exactly one def can reach @p UseMBB, and the def dominates @p Kill,
+  /// all paths from the def to @p UseMBB are added to @p LR, and the function
+  /// returns true.
+  ///
+  /// If multiple values can reach @p UseMBB, the blocks that need @p LR to be
+  /// live in are added to the LiveIn array, and the function returns false.
+  ///
+  /// The array @p Undef provides the locations where the range @p LR becomes
+  /// undefined by <def,read-undef> operands on other subranges. If @p Undef
+  /// is non-empty and @p Kill is jointly dominated only by the entries of
+  /// @p Undef, the function returns false.
+  ///
+  /// PhysReg, when set, is used to verify live-in lists on basic blocks.
+  bool findReachingDefs(LiveRange &LR, MachineBasicBlock &UseMBB, SlotIndex Use,
+                        unsigned PhysReg, ArrayRef<SlotIndex> Undefs);
+
+  /// updateSSA - Compute the values that will be live in to all requested
+  /// blocks in LiveIn.  Create PHI-def values as required to preserve SSA form.
+  ///
+  /// Every live-in block must be jointly dominated by the added live-out
+  /// blocks.  No values are read from the live ranges.
+  void updateSSA();
+
+  /// Transfer information from the LiveIn vector to the live ranges and update
+  /// the given @p LiveOuts.
+  void updateFromLiveIns();
+
+protected:
+  /// Some getters to expose in a read-only way some private fields to
+  /// subclasses.
+  const MachineFunction *getMachineFunction() { return MF; }
+  const MachineRegisterInfo *getRegInfo() const { return MRI; }
+  SlotIndexes *getIndexes() { return Indexes; }
+  MachineDominatorTree *getDomTree() { return DomTree; }
+  VNInfo::Allocator *getVNAlloc() { return Alloc; }
+
+  /// Reset Map and Seen fields.
+  void resetLiveOutMap();
+
+public:
+  LiveRangeCalc() = default;
+
+  //===--------------------------------------------------------------------===//
+  // High-level interface.
+  //===--------------------------------------------------------------------===//
+  //
+  // Calculate live ranges from scratch.
+  //
+
+  /// reset - Prepare caches for a new set of non-overlapping live ranges.  The
+  /// caches must be reset before attempting calculations with a live range
+  /// that may overlap a previously computed live range, and before the first
+  /// live range in a function.  If live ranges are not known to be
+  /// non-overlapping, call reset before each.
+  void reset(const MachineFunction *mf, SlotIndexes *SI,
+             MachineDominatorTree *MDT, VNInfo::Allocator *VNIA);
+
+  //===--------------------------------------------------------------------===//
+  // Mid-level interface.
+  //===--------------------------------------------------------------------===//
+  //
+  // Modify existing live ranges.
+  //
+
+  /// Extend the live range of @p LR to reach @p Use.
+  ///
+  /// The existing values in @p LR must be live so they jointly dominate @p Use.
+  /// If @p Use is not dominated by a single existing value, PHI-defs are
+  /// inserted as required to preserve SSA form.
+  ///
+  /// PhysReg, when set, is used to verify live-in lists on basic blocks.
+  void extend(LiveRange &LR, SlotIndex Use, unsigned PhysReg,
+              ArrayRef<SlotIndex> Undefs);
+
+  //===--------------------------------------------------------------------===//
+  // Low-level interface.
+  //===--------------------------------------------------------------------===//
+  //
+  // These functions can be used to compute live ranges where the live-in and
+  // live-out blocks are already known, but the SSA value in each block is
+  // unknown.
+  //
+  // After calling reset(), add known live-out values and known live-in blocks.
+  // Then call calculateValues() to compute the actual value that is
+  // live-in to each block, and add liveness to the live ranges.
+  //
+
+  /// setLiveOutValue - Indicate that VNI is live out from MBB.  The
+  /// calculateValues() function will not add liveness for MBB, the caller
+  /// should take care of that.
+  ///
+  /// VNI may be null only if MBB is a live-through block also passed to
+  /// addLiveInBlock().
+  void setLiveOutValue(MachineBasicBlock *MBB, VNInfo *VNI) {
+    Seen.set(MBB->getNumber());
+    Map[MBB] = LiveOutPair(VNI, nullptr);
+  }
+
+  /// addLiveInBlock - Add a block with an unknown live-in value.  This
+  /// function can only be called once per basic block.  Once the live-in value
+  /// has been determined, calculateValues() will add liveness to LI.
+  ///
+  /// @param LR      The live range that is live-in to the block.
+  /// @param DomNode The domtree node for the block.
+  /// @param Kill    Index in block where LI is killed.  If the value is
+  ///                live-through, set Kill = SLotIndex() and also call
+  ///                setLiveOutValue(MBB, 0).
+  void addLiveInBlock(LiveRange &LR, MachineDomTreeNode *DomNode,
+                      SlotIndex Kill = SlotIndex()) {
+    LiveIn.push_back(LiveInBlock(LR, DomNode, Kill));
+  }
+
+  /// calculateValues - Calculate the value that will be live-in to each block
+  /// added with addLiveInBlock.  Add PHI-def values as needed to preserve SSA
+  /// form.  Add liveness to all live-in blocks up to the Kill point, or the
+  /// whole block for live-through blocks.
+  ///
+  /// Every predecessor of a live-in block must have been given a value with
+  /// setLiveOutValue, the value may be null for live-trough blocks.
+  void calculateValues();
+
+  /// A diagnostic function to check if the end of the block @p MBB is
+  /// jointly dominated by the blocks corresponding to the slot indices
+  /// in @p Defs. This function is mainly for use in self-verification
+  /// checks.
+  LLVM_ATTRIBUTE_UNUSED
+  static bool isJointlyDominated(const MachineBasicBlock *MBB,
+                                 ArrayRef<SlotIndex> Defs,
+                                 const SlotIndexes &Indexes);
+};
+
+} // end namespace llvm
+
+#endif // LLVM_LIB_CODEGEN_LIVERANGECALC_H
diff --git a/linux-x64/clang/include/llvm/CodeGen/LiveRangeEdit.h b/linux-x64/clang/include/llvm/CodeGen/LiveRangeEdit.h
index 6519937..87d48ad 100644
--- a/linux-x64/clang/include/llvm/CodeGen/LiveRangeEdit.h
+++ b/linux-x64/clang/include/llvm/CodeGen/LiveRangeEdit.h
@@ -22,7 +22,6 @@
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
-#include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/CodeGen/LiveInterval.h"
 #include "llvm/CodeGen/MachineBasicBlock.h"
 #include "llvm/CodeGen/MachineFunction.h"
@@ -33,6 +32,7 @@
 
 namespace llvm {
 
+class AAResults;
 class LiveIntervals;
 class MachineBlockFrequencyInfo;
 class MachineInstr;
@@ -56,19 +56,19 @@
 
     /// Called when a virtual register is no longer used. Return false to defer
     /// its deletion from LiveIntervals.
-    virtual bool LRE_CanEraseVirtReg(unsigned) { return true; }
+    virtual bool LRE_CanEraseVirtReg(Register) { return true; }
 
     /// Called before shrinking the live range of a virtual register.
-    virtual void LRE_WillShrinkVirtReg(unsigned) {}
+    virtual void LRE_WillShrinkVirtReg(Register) {}
 
     /// Called after cloning a virtual register.
     /// This is used for new registers representing connected components of Old.
-    virtual void LRE_DidCloneVirtReg(unsigned New, unsigned Old) {}
+    virtual void LRE_DidCloneVirtReg(Register New, Register Old) {}
   };
 
 private:
   LiveInterval *Parent;
-  SmallVectorImpl<unsigned> &NewRegs;
+  SmallVectorImpl<Register> &NewRegs;
   MachineRegisterInfo &MRI;
   LiveIntervals &LIS;
   VirtRegMap *VRM;
@@ -94,7 +94,7 @@
   SmallPtrSet<const VNInfo *, 4> Rematted;
 
   /// scanRemattable - Identify the Parent values that may rematerialize.
-  void scanRemattable(AliasAnalysis *aa);
+  void scanRemattable(AAResults *aa);
 
   /// allUsesAvailableAt - Return true if all registers used by OrigMI at
   /// OrigIdx are also available with the same value at UseIdx.
@@ -110,18 +110,18 @@
 
   /// Helper for eliminateDeadDefs.
   void eliminateDeadDef(MachineInstr *MI, ToShrinkSet &ToShrink,
-                        AliasAnalysis *AA);
+                        AAResults *AA);
 
   /// MachineRegisterInfo callback to notify when new virtual
   /// registers are created.
-  void MRI_NoteNewVirtualRegister(unsigned VReg) override;
+  void MRI_NoteNewVirtualRegister(Register VReg) override;
 
   /// Check if MachineOperand \p MO is a last use/kill either in the
   /// main live range of \p LI or in one of the matching subregister ranges.
   bool useIsKill(const LiveInterval &LI, const MachineOperand &MO) const;
 
   /// Create a new empty interval based on OldReg.
-  LiveInterval &createEmptyIntervalFrom(unsigned OldReg, bool createSubRanges);
+  LiveInterval &createEmptyIntervalFrom(Register OldReg, bool createSubRanges);
 
 public:
   /// Create a LiveRangeEdit for breaking down parent into smaller pieces.
@@ -135,7 +135,7 @@
   ///            be done.  This could be the case if called before Regalloc.
   /// @param deadRemats The collection of all the instructions defining an
   ///                   original reg and are dead after remat.
-  LiveRangeEdit(LiveInterval *parent, SmallVectorImpl<unsigned> &newRegs,
+  LiveRangeEdit(LiveInterval *parent, SmallVectorImpl<Register> &newRegs,
                 MachineFunction &MF, LiveIntervals &lis, VirtRegMap *vrm,
                 Delegate *delegate = nullptr,
                 SmallPtrSet<MachineInstr *, 32> *deadRemats = nullptr)
@@ -152,15 +152,15 @@
     return *Parent;
   }
 
-  unsigned getReg() const { return getParent().reg; }
+  Register getReg() const { return getParent().reg(); }
 
   /// Iterator for accessing the new registers added by this edit.
-  using iterator = SmallVectorImpl<unsigned>::const_iterator;
+  using iterator = SmallVectorImpl<Register>::const_iterator;
   iterator begin() const { return NewRegs.begin() + FirstNew; }
   iterator end() const { return NewRegs.end(); }
   unsigned size() const { return NewRegs.size() - FirstNew; }
   bool empty() const { return size() == 0; }
-  unsigned get(unsigned idx) const { return NewRegs[idx + FirstNew]; }
+  Register get(unsigned idx) const { return NewRegs[idx + FirstNew]; }
 
   /// pop_back - It allows LiveRangeEdit users to drop new registers.
   /// The context is when an original def instruction of a register is
@@ -172,12 +172,12 @@
   /// we want to drop it from the NewRegs set.
   void pop_back() { NewRegs.pop_back(); }
 
-  ArrayRef<unsigned> regs() const {
+  ArrayRef<Register> regs() const {
     return makeArrayRef(NewRegs).slice(FirstNew);
   }
 
   /// createFrom - Create a new virtual register based on OldReg.
-  unsigned createFrom(unsigned OldReg);
+  Register createFrom(Register OldReg);
 
   /// create - Create a new register with the same class and original slot as
   /// parent.
@@ -185,17 +185,17 @@
     return createEmptyIntervalFrom(getReg(), true);
   }
 
-  unsigned create() { return createFrom(getReg()); }
+  Register create() { return createFrom(getReg()); }
 
   /// anyRematerializable - Return true if any parent values may be
   /// rematerializable.
   /// This function must be called before any rematerialization is attempted.
-  bool anyRematerializable(AliasAnalysis *);
+  bool anyRematerializable(AAResults *);
 
   /// checkRematerializable - Manually add VNI to the list of rematerializable
   /// values if DefMI may be rematerializable.
   bool checkRematerializable(VNInfo *VNI, const MachineInstr *DefMI,
-                             AliasAnalysis *);
+                             AAResults *);
 
   /// Remat - Information needed to rematerialize at a specific location.
   struct Remat {
@@ -234,7 +234,7 @@
 
   /// eraseVirtReg - Notify the delegate that Reg is no longer in use, and try
   /// to erase it from LIS.
-  void eraseVirtReg(unsigned Reg);
+  void eraseVirtReg(Register Reg);
 
   /// eliminateDeadDefs - Try to delete machine instructions that are now dead
   /// (allDefsAreDead returns true). This may cause live intervals to be trimmed
@@ -243,8 +243,8 @@
   /// allocator.  These registers should not be split into new intervals
   /// as currently those new intervals are not guaranteed to spill.
   void eliminateDeadDefs(SmallVectorImpl<MachineInstr *> &Dead,
-                         ArrayRef<unsigned> RegsBeingSpilled = None,
-                         AliasAnalysis *AA = nullptr);
+                         ArrayRef<Register> RegsBeingSpilled = None,
+                         AAResults *AA = nullptr);
 
   /// calculateRegClassAndHint - Recompute register class and hint for each new
   /// register.
diff --git a/linux-x64/clang/include/llvm/CodeGen/LiveRegMatrix.h b/linux-x64/clang/include/llvm/CodeGen/LiveRegMatrix.h
index ab4d44f..fc67bce 100644
--- a/linux-x64/clang/include/llvm/CodeGen/LiveRegMatrix.h
+++ b/linux-x64/clang/include/llvm/CodeGen/LiveRegMatrix.h
@@ -104,19 +104,19 @@
   /// If this function returns IK_Free, it is legal to assign(VirtReg, PhysReg).
   /// When there is more than one kind of interference, the InterferenceKind
   /// with the highest enum value is returned.
-  InterferenceKind checkInterference(LiveInterval &VirtReg, unsigned PhysReg);
+  InterferenceKind checkInterference(LiveInterval &VirtReg, MCRegister PhysReg);
 
   /// Check for interference in the segment [Start, End) that may prevent
   /// assignment to PhysReg. If this function returns true, there is
   /// interference in the segment [Start, End) of some other interval already
   /// assigned to PhysReg. If this function returns false, PhysReg is free at
   /// the segment [Start, End).
-  bool checkInterference(SlotIndex Start, SlotIndex End, unsigned PhysReg);
+  bool checkInterference(SlotIndex Start, SlotIndex End, MCRegister PhysReg);
 
   /// Assign VirtReg to PhysReg.
   /// This will mark VirtReg's live range as occupied in the LiveRegMatrix and
   /// update VirtRegMap. The live range is expected to be available in PhysReg.
-  void assign(LiveInterval &VirtReg, unsigned PhysReg);
+  void assign(LiveInterval &VirtReg, MCRegister PhysReg);
 
   /// Unassign VirtReg from its PhysReg.
   /// Assuming that VirtReg was previously assigned to a PhysReg, this undoes
@@ -124,7 +124,7 @@
   void unassign(LiveInterval &VirtReg);
 
   /// Returns true if the given \p PhysReg has any live intervals assigned.
-  bool isPhysRegUsed(unsigned PhysReg) const;
+  bool isPhysRegUsed(MCRegister PhysReg) const;
 
   //===--------------------------------------------------------------------===//
   // Low-level interface.
@@ -136,22 +136,25 @@
   /// Check for regmask interference only.
   /// Return true if VirtReg crosses a regmask operand that clobbers PhysReg.
   /// If PhysReg is null, check if VirtReg crosses any regmask operands.
-  bool checkRegMaskInterference(LiveInterval &VirtReg, unsigned PhysReg = 0);
+  bool checkRegMaskInterference(LiveInterval &VirtReg,
+                                MCRegister PhysReg = MCRegister::NoRegister);
 
   /// Check for regunit interference only.
   /// Return true if VirtReg overlaps a fixed assignment of one of PhysRegs's
   /// register units.
-  bool checkRegUnitInterference(LiveInterval &VirtReg, unsigned PhysReg);
+  bool checkRegUnitInterference(LiveInterval &VirtReg, MCRegister PhysReg);
 
   /// Query a line of the assigned virtual register matrix directly.
   /// Use MCRegUnitIterator to enumerate all regunits in the desired PhysReg.
   /// This returns a reference to an internal Query data structure that is only
   /// valid until the next query() call.
-  LiveIntervalUnion::Query &query(const LiveRange &LR, unsigned RegUnit);
+  LiveIntervalUnion::Query &query(const LiveRange &LR, MCRegister RegUnit);
 
   /// Directly access the live interval unions per regunit.
   /// This returns an array indexed by the regunit number.
   LiveIntervalUnion *getLiveUnions() { return &Matrix[0]; }
+
+  Register getOneVReg(unsigned PhysReg) const;
 };
 
 } // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/CodeGen/LiveRegUnits.h b/linux-x64/clang/include/llvm/CodeGen/LiveRegUnits.h
index 7dbb2fe..39a1ec4 100644
--- a/linux-x64/clang/include/llvm/CodeGen/LiveRegUnits.h
+++ b/linux-x64/clang/include/llvm/CodeGen/LiveRegUnits.h
@@ -15,7 +15,7 @@
 #define LLVM_CODEGEN_LIVEREGUNITS_H
 
 #include "llvm/ADT/BitVector.h"
-#include "llvm/CodeGen/MachineRegisterInfo.h"
+#include "llvm/CodeGen/MachineInstrBundle.h"
 #include "llvm/CodeGen/TargetRegisterInfo.h"
 #include "llvm/MC/LaneBitmask.h"
 #include "llvm/MC/MCRegisterInfo.h"
@@ -53,8 +53,8 @@
         ModifiedRegUnits.addRegsInMask(O->getRegMask());
       if (!O->isReg())
         continue;
-      unsigned Reg = O->getReg();
-      if (!TargetRegisterInfo::isPhysicalRegister(Reg))
+      Register Reg = O->getReg();
+      if (!Reg.isPhysical())
         continue;
       if (O->isDef()) {
         // Some architectures (e.g. AArch64 XZR/WZR) have registers that are
@@ -67,7 +67,6 @@
         UsedRegUnits.addReg(Reg);
       }
     }
-    return;
   }
 
   /// Initialize and clear the set.
@@ -160,6 +159,19 @@
   void addPristines(const MachineFunction &MF);
 };
 
+/// Returns an iterator range over all physical register and mask operands for
+/// \p MI and bundled instructions. This also skips any debug operands.
+inline iterator_range<filter_iterator<
+    ConstMIBundleOperands, std::function<bool(const MachineOperand &)>>>
+phys_regs_and_masks(const MachineInstr &MI) {
+  std::function<bool(const MachineOperand &)> Pred =
+      [](const MachineOperand &MOP) {
+        return MOP.isRegMask() || (MOP.isReg() && !MOP.isDebug() &&
+                                   Register::isPhysicalRegister(MOP.getReg()));
+      };
+  return make_filter_range(const_mi_bundle_ops(MI), Pred);
+}
+
 } // end namespace llvm
 
 #endif // LLVM_CODEGEN_LIVEREGUNITS_H
diff --git a/linux-x64/clang/include/llvm/CodeGen/LiveStacks.h b/linux-x64/clang/include/llvm/CodeGen/LiveStacks.h
index 7c4c64d..1cbdb8b 100644
--- a/linux-x64/clang/include/llvm/CodeGen/LiveStacks.h
+++ b/linux-x64/clang/include/llvm/CodeGen/LiveStacks.h
@@ -17,6 +17,7 @@
 
 #include "llvm/CodeGen/LiveInterval.h"
 #include "llvm/CodeGen/MachineFunctionPass.h"
+#include "llvm/InitializePasses.h"
 #include "llvm/Pass.h"
 #include <cassert>
 #include <map>
diff --git a/linux-x64/clang/include/llvm/CodeGen/LiveVariables.h b/linux-x64/clang/include/llvm/CodeGen/LiveVariables.h
index 71de306..9b0667b 100644
--- a/linux-x64/clang/include/llvm/CodeGen/LiveVariables.h
+++ b/linux-x64/clang/include/llvm/CodeGen/LiveVariables.h
@@ -36,6 +36,7 @@
 #include "llvm/CodeGen/MachineFunctionPass.h"
 #include "llvm/CodeGen/MachineInstr.h"
 #include "llvm/CodeGen/TargetRegisterInfo.h"
+#include "llvm/InitializePasses.h"
 
 namespace llvm {
 
@@ -104,8 +105,7 @@
     /// isLiveIn - Is Reg live in to MBB? This means that Reg is live through
     /// MBB, or it is killed in MBB. If Reg is only used by PHI instructions in
     /// MBB, it is not considered live in.
-    bool isLiveIn(const MachineBasicBlock &MBB,
-                  unsigned Reg,
+    bool isLiveIn(const MachineBasicBlock &MBB, Register Reg,
                   MachineRegisterInfo &MRI);
 
     void dump() const;
@@ -148,25 +148,25 @@
   /// HandlePhysRegKill - Add kills of Reg and its sub-registers to the
   /// uses. Pay special attention to the sub-register uses which may come below
   /// the last use of the whole register.
-  bool HandlePhysRegKill(unsigned Reg, MachineInstr *MI);
+  bool HandlePhysRegKill(Register Reg, MachineInstr *MI);
 
   /// HandleRegMask - Call HandlePhysRegKill for all registers clobbered by Mask.
   void HandleRegMask(const MachineOperand&);
 
-  void HandlePhysRegUse(unsigned Reg, MachineInstr &MI);
-  void HandlePhysRegDef(unsigned Reg, MachineInstr *MI,
+  void HandlePhysRegUse(Register Reg, MachineInstr &MI);
+  void HandlePhysRegDef(Register Reg, MachineInstr *MI,
                         SmallVectorImpl<unsigned> &Defs);
   void UpdatePhysRegDefs(MachineInstr &MI, SmallVectorImpl<unsigned> &Defs);
 
   /// FindLastRefOrPartRef - Return the last reference or partial reference of
   /// the specified register.
-  MachineInstr *FindLastRefOrPartRef(unsigned Reg);
+  MachineInstr *FindLastRefOrPartRef(Register Reg);
 
   /// FindLastPartialDef - Return the last partial def of the specified
   /// register. Also returns the sub-registers that're defined by the
   /// instruction.
-  MachineInstr *FindLastPartialDef(unsigned Reg,
-                                   SmallSet<unsigned,4> &PartDefRegs);
+  MachineInstr *FindLastPartialDef(Register Reg,
+                                   SmallSet<unsigned, 4> &PartDefRegs);
 
   /// analyzePHINodes - Gather information about the PHI nodes in here. In
   /// particular, we want to map the variable information of a virtual
@@ -183,21 +183,21 @@
 
   /// RegisterDefIsDead - Return true if the specified instruction defines the
   /// specified register, but that definition is dead.
-  bool RegisterDefIsDead(MachineInstr &MI, unsigned Reg) const;
+  bool RegisterDefIsDead(MachineInstr &MI, Register Reg) const;
 
   //===--------------------------------------------------------------------===//
   //  API to update live variable information
 
   /// replaceKillInstruction - Update register kill info by replacing a kill
   /// instruction with a new one.
-  void replaceKillInstruction(unsigned Reg, MachineInstr &OldMI,
+  void replaceKillInstruction(Register Reg, MachineInstr &OldMI,
                               MachineInstr &NewMI);
 
   /// addVirtualRegisterKilled - Add information about the fact that the
   /// specified register is killed after being used by the specified
   /// instruction. If AddIfNotFound is true, add a implicit operand if it's
   /// not found.
-  void addVirtualRegisterKilled(unsigned IncomingReg, MachineInstr &MI,
+  void addVirtualRegisterKilled(Register IncomingReg, MachineInstr &MI,
                                 bool AddIfNotFound = false) {
     if (MI.addRegisterKilled(IncomingReg, TRI, AddIfNotFound))
       getVarInfo(IncomingReg).Kills.push_back(&MI);
@@ -207,14 +207,14 @@
   /// register from the live variable information. Returns true if the
   /// variable was marked as killed by the specified instruction,
   /// false otherwise.
-  bool removeVirtualRegisterKilled(unsigned reg, MachineInstr &MI) {
-    if (!getVarInfo(reg).removeKill(MI))
+  bool removeVirtualRegisterKilled(Register Reg, MachineInstr &MI) {
+    if (!getVarInfo(Reg).removeKill(MI))
       return false;
 
     bool Removed = false;
     for (unsigned i = 0, e = MI.getNumOperands(); i != e; ++i) {
       MachineOperand &MO = MI.getOperand(i);
-      if (MO.isReg() && MO.isKill() && MO.getReg() == reg) {
+      if (MO.isReg() && MO.isKill() && MO.getReg() == Reg) {
         MO.setIsKill(false);
         Removed = true;
         break;
@@ -233,7 +233,7 @@
   /// addVirtualRegisterDead - Add information about the fact that the specified
   /// register is dead after being used by the specified instruction. If
   /// AddIfNotFound is true, add a implicit operand if it's not found.
-  void addVirtualRegisterDead(unsigned IncomingReg, MachineInstr &MI,
+  void addVirtualRegisterDead(Register IncomingReg, MachineInstr &MI,
                               bool AddIfNotFound = false) {
     if (MI.addRegisterDead(IncomingReg, TRI, AddIfNotFound))
       getVarInfo(IncomingReg).Kills.push_back(&MI);
@@ -243,14 +243,14 @@
   /// register from the live variable information. Returns true if the
   /// variable was marked dead at the specified instruction, false
   /// otherwise.
-  bool removeVirtualRegisterDead(unsigned reg, MachineInstr &MI) {
-    if (!getVarInfo(reg).removeKill(MI))
+  bool removeVirtualRegisterDead(Register Reg, MachineInstr &MI) {
+    if (!getVarInfo(Reg).removeKill(MI))
       return false;
 
     bool Removed = false;
     for (unsigned i = 0, e = MI.getNumOperands(); i != e; ++i) {
       MachineOperand &MO = MI.getOperand(i);
-      if (MO.isReg() && MO.isDef() && MO.getReg() == reg) {
+      if (MO.isReg() && MO.isDef() && MO.getReg() == Reg) {
         MO.setIsDead(false);
         Removed = true;
         break;
@@ -269,24 +269,25 @@
 
   /// getVarInfo - Return the VarInfo structure for the specified VIRTUAL
   /// register.
-  VarInfo &getVarInfo(unsigned RegIdx);
+  VarInfo &getVarInfo(Register Reg);
 
   void MarkVirtRegAliveInBlock(VarInfo& VRInfo, MachineBasicBlock* DefBlock,
                                MachineBasicBlock *BB);
-  void MarkVirtRegAliveInBlock(VarInfo& VRInfo, MachineBasicBlock* DefBlock,
+  void MarkVirtRegAliveInBlock(VarInfo &VRInfo, MachineBasicBlock *DefBlock,
                                MachineBasicBlock *BB,
-                               std::vector<MachineBasicBlock*> &WorkList);
-  void HandleVirtRegDef(unsigned reg, MachineInstr &MI);
-  void HandleVirtRegUse(unsigned reg, MachineBasicBlock *MBB, MachineInstr &MI);
+                               SmallVectorImpl<MachineBasicBlock *> &WorkList);
 
-  bool isLiveIn(unsigned Reg, const MachineBasicBlock &MBB) {
+  void HandleVirtRegDef(Register reg, MachineInstr &MI);
+  void HandleVirtRegUse(Register reg, MachineBasicBlock *MBB, MachineInstr &MI);
+
+  bool isLiveIn(Register Reg, const MachineBasicBlock &MBB) {
     return getVarInfo(Reg).isLiveIn(MBB, Reg, *MRI);
   }
 
   /// isLiveOut - Determine if Reg is live out from MBB, when not considering
   /// PHI nodes. This means that Reg is either killed by a successor block or
   /// passed through one.
-  bool isLiveOut(unsigned Reg, const MachineBasicBlock &MBB);
+  bool isLiveOut(Register Reg, const MachineBasicBlock &MBB);
 
   /// addNewBlock - Add a new basic block BB between DomBB and SuccBB. All
   /// variables that are live out of DomBB and live into SuccBB will be marked
@@ -296,11 +297,16 @@
                    MachineBasicBlock *DomBB,
                    MachineBasicBlock *SuccBB);
 
+  void addNewBlock(MachineBasicBlock *BB,
+                   MachineBasicBlock *DomBB,
+                   MachineBasicBlock *SuccBB,
+                   std::vector<SparseBitVector<>> &LiveInSets);
+
   /// isPHIJoin - Return true if Reg is a phi join register.
-  bool isPHIJoin(unsigned Reg) { return PHIJoins.test(Reg); }
+  bool isPHIJoin(Register Reg) { return PHIJoins.test(Reg.id()); }
 
   /// setPHIJoin - Mark Reg as a phi join register.
-  void setPHIJoin(unsigned Reg) { PHIJoins.set(Reg); }
+  void setPHIJoin(Register Reg) { PHIJoins.set(Reg.id()); }
 };
 
 } // End llvm namespace
diff --git a/linux-x64/clang/include/llvm/CodeGen/LowLevelType.h b/linux-x64/clang/include/llvm/CodeGen/LowLevelType.h
index 687233e..402fa2c 100644
--- a/linux-x64/clang/include/llvm/CodeGen/LowLevelType.h
+++ b/linux-x64/clang/include/llvm/CodeGen/LowLevelType.h
@@ -17,15 +17,28 @@
 #define LLVM_CODEGEN_LOWLEVELTYPE_H
 
 #include "llvm/Support/LowLevelTypeImpl.h"
+#include "llvm/Support/MachineValueType.h"
 
 namespace llvm {
 
 class DataLayout;
 class Type;
+struct fltSemantics;
 
 /// Construct a low-level type based on an LLVM type.
 LLT getLLTForType(Type &Ty, const DataLayout &DL);
 
+/// Get a rough equivalent of an MVT for a given LLT. MVT can't distinguish
+/// pointers, so these will convert to a plain integer.
+MVT getMVTForLLT(LLT Ty);
+
+/// Get a rough equivalent of an LLT for a given MVT. LLT does not yet support
+/// scalarable vector types, and will assert if used.
+LLT getLLTForMVT(MVT Ty);
+
+/// Get the appropriate floating point arithmetic semantic based on the bit size
+/// of the given scalar LLT.
+const llvm::fltSemantics &getFltSemanticForLLT(LLT Ty);
 }
 
 #endif // LLVM_CODEGEN_LOWLEVELTYPE_H
diff --git a/linux-x64/clang/include/llvm/CodeGen/MBFIWrapper.h b/linux-x64/clang/include/llvm/CodeGen/MBFIWrapper.h
new file mode 100644
index 0000000..bcbf3ee
--- /dev/null
+++ b/linux-x64/clang/include/llvm/CodeGen/MBFIWrapper.h
@@ -0,0 +1,48 @@
+//===- llvm/CodeGen/MBFIWrapper.h -------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This class keeps track of branch frequencies of newly created blocks and
+// tail-merged blocks. Used by the TailDuplication and MachineBlockPlacement.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CODEGEN_MBFIWRAPPER_H
+#define LLVM_CODEGEN_MBFIWRAPPER_H
+
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/Support/BlockFrequency.h"
+
+namespace llvm {
+
+class MachineBasicBlock;
+class MachineBlockFrequencyInfo;
+
+class MBFIWrapper {
+ public:
+  MBFIWrapper(const MachineBlockFrequencyInfo &I) : MBFI(I) {}
+
+  BlockFrequency getBlockFreq(const MachineBasicBlock *MBB) const;
+  void setBlockFreq(const MachineBasicBlock *MBB, BlockFrequency F);
+  Optional<uint64_t> getBlockProfileCount(const MachineBasicBlock *MBB) const;
+
+  raw_ostream &printBlockFreq(raw_ostream &OS,
+                              const MachineBasicBlock *MBB) const;
+  raw_ostream &printBlockFreq(raw_ostream &OS,
+                              const BlockFrequency Freq) const;
+  void view(const Twine &Name, bool isSimple = true);
+  uint64_t getEntryFreq() const;
+  const MachineBlockFrequencyInfo &getMBFI() { return MBFI; }
+
+ private:
+  const MachineBlockFrequencyInfo &MBFI;
+  DenseMap<const MachineBasicBlock *, BlockFrequency> MergedBBFreq;
+};
+
+} // end namespace llvm
+
+#endif // LLVM_CODEGEN_MBFIWRAPPER_H
diff --git a/linux-x64/clang/include/llvm/CodeGen/MIRFormatter.h b/linux-x64/clang/include/llvm/CodeGen/MIRFormatter.h
new file mode 100644
index 0000000..9cb9209
--- /dev/null
+++ b/linux-x64/clang/include/llvm/CodeGen/MIRFormatter.h
@@ -0,0 +1,87 @@
+//===-- llvm/CodeGen/MIRFormatter.h -----------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains the declaration of the MIRFormatter class.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CODEGEN_MIRFORMATTER_H
+#define LLVM_CODEGEN_MIRFORMATTER_H
+
+#include "llvm/ADT/Optional.h"
+#include "llvm/CodeGen/PseudoSourceValue.h"
+#include "llvm/Support/raw_ostream.h"
+#include <cstdint>
+
+namespace llvm {
+
+class MachineFunction;
+class MachineInstr;
+struct PerFunctionMIParsingState;
+struct SlotMapping;
+
+/// MIRFormater - Interface to format MIR operand based on target
+class MIRFormatter {
+public:
+  typedef function_ref<bool(StringRef::iterator Loc, const Twine &)>
+      ErrorCallbackType;
+
+  MIRFormatter() {}
+  virtual ~MIRFormatter() = default;
+
+  /// Implement target specific printing for machine operand immediate value, so
+  /// that we can have more meaningful mnemonic than a 64-bit integer. Passing
+  /// None to OpIdx means the index is unknown.
+  virtual void printImm(raw_ostream &OS, const MachineInstr &MI,
+                        Optional<unsigned> OpIdx, int64_t Imm) const {
+    OS << Imm;
+  }
+
+  /// Implement target specific parsing of immediate mnemonics. The mnemonic is
+  /// dot seperated strings.
+  virtual bool parseImmMnemonic(const unsigned OpCode, const unsigned OpIdx,
+                                StringRef Src, int64_t &Imm,
+                                ErrorCallbackType ErrorCallback) const {
+    llvm_unreachable("target did not implement parsing MIR immediate mnemonic");
+  }
+
+  /// Implement target specific printing of target custom pseudo source value.
+  /// Default implementation is not necessarily the correct MIR serialization
+  /// format.
+  virtual void
+  printCustomPseudoSourceValue(raw_ostream &OS, ModuleSlotTracker &MST,
+                               const PseudoSourceValue &PSV) const {
+    PSV.printCustom(OS);
+  }
+
+  /// Implement target specific parsing of target custom pseudo source value.
+  virtual bool parseCustomPseudoSourceValue(
+      StringRef Src, MachineFunction &MF, PerFunctionMIParsingState &PFS,
+      const PseudoSourceValue *&PSV, ErrorCallbackType ErrorCallback) const {
+    llvm_unreachable(
+        "target did not implement parsing MIR custom pseudo source value");
+  }
+
+  /// Helper functions to print IR value as MIR serialization format which will
+  /// be useful for target specific printer, e.g. for printing IR value in
+  /// custom pseudo source value.
+  static void printIRValue(raw_ostream &OS, const Value &V,
+                           ModuleSlotTracker &MST);
+
+  /// Helper functions to parse IR value from MIR serialization format which
+  /// will be useful for target specific parser, e.g. for parsing IR value for
+  /// custom pseudo source value.
+  static bool parseIRValue(StringRef Src, MachineFunction &MF,
+                           PerFunctionMIParsingState &PFS, const Value *&V,
+                           ErrorCallbackType ErrorCallback);
+};
+
+} // end namespace llvm
+
+#endif
diff --git a/linux-x64/clang/include/llvm/CodeGen/MIRParser/MIParser.h b/linux-x64/clang/include/llvm/CodeGen/MIRParser/MIParser.h
index 4e32a04..590b3dc 100644
--- a/linux-x64/clang/include/llvm/CodeGen/MIRParser/MIParser.h
+++ b/linux-x64/clang/include/llvm/CodeGen/MIRParser/MIParser.h
@@ -16,6 +16,7 @@
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/CodeGen/MachineMemOperand.h"
+#include "llvm/CodeGen/Register.h"
 #include "llvm/Support/Allocator.h"
 
 namespace llvm {
@@ -40,8 +41,8 @@
     const TargetRegisterClass *RC;
     const RegisterBank *RegBank;
   } D;
-  unsigned VReg;
-  unsigned PreferredReg = 0;
+  Register VReg;
+  Register PreferredReg;
 };
 
 using Name2RegClassMap = StringMap<const TargetRegisterClass *>;
@@ -55,7 +56,7 @@
   StringMap<unsigned> Names2InstrOpCodes;
 
   /// Maps from register names to registers.
-  StringMap<unsigned> Names2Regs;
+  StringMap<Register> Names2Regs;
 
   /// Maps from register mask names to register masks.
   StringMap<const uint32_t *> Names2RegMasks;
@@ -100,7 +101,7 @@
 
   /// Try to convert a register name to a register number. Return true if the
   /// register name is invalid.
-  bool getRegisterByName(StringRef RegName, unsigned &Reg);
+  bool getRegisterByName(StringRef RegName, Register &Reg);
 
   /// Check if the given identifier is a name of a register mask.
   ///
@@ -164,19 +165,23 @@
   PerTargetMIParsingState &Target;
 
   DenseMap<unsigned, MachineBasicBlock *> MBBSlots;
-  DenseMap<unsigned, VRegInfo *> VRegInfos;
+  DenseMap<Register, VRegInfo *> VRegInfos;
   StringMap<VRegInfo *> VRegInfosNamed;
   DenseMap<unsigned, int> FixedStackObjectSlots;
   DenseMap<unsigned, int> StackObjectSlots;
   DenseMap<unsigned, unsigned> ConstantPoolSlots;
   DenseMap<unsigned, unsigned> JumpTableSlots;
 
+  /// Maps from slot numbers to function's unnamed values.
+  DenseMap<unsigned, const Value *> Slots2Values;
+
   PerFunctionMIParsingState(MachineFunction &MF, SourceMgr &SM,
                             const SlotMapping &IRSlots,
                             PerTargetMIParsingState &Target);
 
-  VRegInfo &getVRegInfo(unsigned Num);
+  VRegInfo &getVRegInfo(Register Num);
   VRegInfo &getVRegInfoNamed(StringRef RegName);
+  const Value *getIRValue(unsigned Slot);
 };
 
 /// Parse the machine basic block definitions, and skip the machine
@@ -212,10 +217,10 @@
                        SMDiagnostic &Error);
 
 bool parseRegisterReference(PerFunctionMIParsingState &PFS,
-                            unsigned &Reg, StringRef Src,
+                            Register &Reg, StringRef Src,
                             SMDiagnostic &Error);
 
-bool parseNamedRegisterReference(PerFunctionMIParsingState &PFS, unsigned &Reg,
+bool parseNamedRegisterReference(PerFunctionMIParsingState &PFS, Register &Reg,
                                  StringRef Src, SMDiagnostic &Error);
 
 bool parseVirtualRegisterReference(PerFunctionMIParsingState &PFS,
diff --git a/linux-x64/clang/include/llvm/CodeGen/MIRParser/MIRParser.h b/linux-x64/clang/include/llvm/CodeGen/MIRParser/MIRParser.h
index 6a04e48..a7c69e2 100644
--- a/linux-x64/clang/include/llvm/CodeGen/MIRParser/MIRParser.h
+++ b/linux-x64/clang/include/llvm/CodeGen/MIRParser/MIRParser.h
@@ -23,10 +23,14 @@
 
 namespace llvm {
 
-class StringRef;
+class Function;
 class MIRParserImpl;
 class MachineModuleInfo;
 class SMDiagnostic;
+class StringRef;
+
+typedef llvm::function_ref<Optional<std::string>(StringRef)>
+    DataLayoutCallbackTy;
 
 /// This class initializes machine functions by applying the state loaded from
 /// a MIR file.
@@ -42,7 +46,8 @@
   ///
   /// A new, empty module is created if the LLVM IR isn't present.
   /// \returns nullptr if a parsing error occurred.
-  std::unique_ptr<Module> parseIRModule();
+  std::unique_ptr<Module> parseIRModule(
+      DataLayoutCallbackTy DataLayoutCallback = [](StringRef) { return None; });
 
   /// Parses MachineFunctions in the MIR file and add them to the given
   /// MachineModuleInfo \p MMI.
@@ -60,9 +65,11 @@
 /// \param Filename - The name of the file to parse.
 /// \param Error - Error result info.
 /// \param Context - Context which will be used for the parsed LLVM IR module.
-std::unique_ptr<MIRParser> createMIRParserFromFile(StringRef Filename,
-                                                   SMDiagnostic &Error,
-                                                   LLVMContext &Context);
+/// \param ProcessIRFunction - function to run on every IR function or stub
+/// loaded from the MIR file.
+std::unique_ptr<MIRParser> createMIRParserFromFile(
+    StringRef Filename, SMDiagnostic &Error, LLVMContext &Context,
+    std::function<void(Function &)> ProcessIRFunction = nullptr);
 
 /// This function is another interface to the MIR serialization format parser.
 ///
@@ -73,7 +80,8 @@
 /// \param Contents - The MemoryBuffer containing the machine level IR.
 /// \param Context - Context which will be used for the parsed LLVM IR module.
 std::unique_ptr<MIRParser>
-createMIRParser(std::unique_ptr<MemoryBuffer> Contents, LLVMContext &Context);
+createMIRParser(std::unique_ptr<MemoryBuffer> Contents, LLVMContext &Context,
+                std::function<void(Function &)> ProcessIRFunction = nullptr);
 
 } // end namespace llvm
 
diff --git a/linux-x64/clang/include/llvm/CodeGen/MIRYamlMapping.h b/linux-x64/clang/include/llvm/CodeGen/MIRYamlMapping.h
index 94e76a7..4a74064 100644
--- a/linux-x64/clang/include/llvm/CodeGen/MIRYamlMapping.h
+++ b/linux-x64/clang/include/llvm/CodeGen/MIRYamlMapping.h
@@ -142,6 +142,39 @@
   }
 };
 
+template <> struct ScalarTraits<MaybeAlign> {
+  static void output(const MaybeAlign &Alignment, void *,
+                     llvm::raw_ostream &out) {
+    out << uint64_t(Alignment ? Alignment->value() : 0U);
+  }
+  static StringRef input(StringRef Scalar, void *, MaybeAlign &Alignment) {
+    unsigned long long n;
+    if (getAsUnsignedInteger(Scalar, 10, n))
+      return "invalid number";
+    if (n > 0 && !isPowerOf2_64(n))
+      return "must be 0 or a power of two";
+    Alignment = MaybeAlign(n);
+    return StringRef();
+  }
+  static QuotingType mustQuote(StringRef) { return QuotingType::None; }
+};
+
+template <> struct ScalarTraits<Align> {
+  static void output(const Align &Alignment, void *, llvm::raw_ostream &OS) {
+    OS << Alignment.value();
+  }
+  static StringRef input(StringRef Scalar, void *, Align &Alignment) {
+    unsigned long long N;
+    if (getAsUnsignedInteger(Scalar, 10, N))
+      return "invalid number";
+    if (!isPowerOf2_64(N))
+      return "must be a power of two";
+    Alignment = Align(N);
+    return StringRef();
+  }
+  static QuotingType mustQuote(StringRef) { return QuotingType::None; }
+};
+
 } // end namespace yaml
 } // end namespace llvm
 
@@ -212,7 +245,7 @@
   ObjectType Type = DefaultType;
   int64_t Offset = 0;
   uint64_t Size = 0;
-  unsigned Alignment = 0;
+  MaybeAlign Alignment = None;
   TargetStackID::Value StackID;
   StringValue CalleeSavedRegister;
   bool CalleeSavedRestored = true;
@@ -252,7 +285,7 @@
     YamlIO.mapOptional("offset", Object.Offset, (int64_t)0);
     if (Object.Type != MachineStackObject::VariableSized)
       YamlIO.mapRequired("size", Object.Size);
-    YamlIO.mapOptional("alignment", Object.Alignment, (unsigned)0);
+    YamlIO.mapOptional("alignment", Object.Alignment, None);
     YamlIO.mapOptional("stack-id", Object.StackID, TargetStackID::Default);
     YamlIO.mapOptional("callee-saved-register", Object.CalleeSavedRegister,
                        StringValue()); // Don't print it out when it's empty.
@@ -278,7 +311,7 @@
   ObjectType Type = DefaultType;
   int64_t Offset = 0;
   uint64_t Size = 0;
-  unsigned Alignment = 0;
+  MaybeAlign Alignment = None;
   TargetStackID::Value StackID;
   bool IsImmutable = false;
   bool IsAliased = false;
@@ -314,6 +347,7 @@
   static void enumeration(yaml::IO &IO, TargetStackID::Value &ID) {
     IO.enumCase(ID, "default", TargetStackID::Default);
     IO.enumCase(ID, "sgpr-spill", TargetStackID::SGPRSpill);
+    IO.enumCase(ID, "scalable-vector", TargetStackID::ScalableVector);
     IO.enumCase(ID, "noalloc", TargetStackID::NoAlloc);
   }
 };
@@ -326,7 +360,7 @@
         FixedMachineStackObject::DefaultType); // Don't print the default type.
     YamlIO.mapOptional("offset", Object.Offset, (int64_t)0);
     YamlIO.mapOptional("size", Object.Size, (uint64_t)0);
-    YamlIO.mapOptional("alignment", Object.Alignment, (unsigned)0);
+    YamlIO.mapOptional("alignment", Object.Alignment, None);
     YamlIO.mapOptional("stack-id", Object.StackID, TargetStackID::Default);
     if (Object.Type != FixedMachineStackObject::SpillSlot) {
       YamlIO.mapOptional("isImmutable", Object.IsImmutable, false);
@@ -407,10 +441,40 @@
   static const bool flow = true;
 };
 
+/// Serializable representation of debug value substitutions.
+struct DebugValueSubstitution {
+  unsigned SrcInst;
+  unsigned SrcOp;
+  unsigned DstInst;
+  unsigned DstOp;
+
+  bool operator==(const DebugValueSubstitution &Other) const {
+    return std::tie(SrcInst, SrcOp, DstInst, DstOp) ==
+           std::tie(Other.SrcInst, Other.SrcOp, Other.DstInst, Other.DstOp);
+  }
+};
+
+template <> struct MappingTraits<DebugValueSubstitution> {
+  static void mapping(IO &YamlIO, DebugValueSubstitution &Sub) {
+    YamlIO.mapRequired("srcinst", Sub.SrcInst);
+    YamlIO.mapRequired("srcop", Sub.SrcOp);
+    YamlIO.mapRequired("dstinst", Sub.DstInst);
+    YamlIO.mapRequired("dstop", Sub.DstOp);
+  }
+
+  static const bool flow = true;
+};
+} // namespace yaml
+} // namespace llvm
+
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::yaml::DebugValueSubstitution)
+
+namespace llvm {
+namespace yaml {
 struct MachineConstantPoolValue {
   UnsignedValue ID;
   StringValue Value;
-  unsigned Alignment = 0;
+  MaybeAlign Alignment = None;
   bool IsTargetSpecific = false;
 
   bool operator==(const MachineConstantPoolValue &Other) const {
@@ -424,7 +488,7 @@
   static void mapping(IO &YamlIO, MachineConstantPoolValue &Constant) {
     YamlIO.mapRequired("id", Constant.ID);
     YamlIO.mapOptional("value", Constant.Value, StringValue());
-    YamlIO.mapOptional("alignment", Constant.Alignment, (unsigned)0);
+    YamlIO.mapOptional("alignment", Constant.Alignment, None);
     YamlIO.mapOptional("isTargetSpecific", Constant.IsTargetSpecific, false);
   }
 };
@@ -570,7 +634,7 @@
 
 struct MachineFunction {
   StringRef Name;
-  unsigned Alignment = 0;
+  MaybeAlign Alignment = None;
   bool ExposesReturnsTwice = false;
   // GISel MachineFunctionProperties.
   bool Legalized = false;
@@ -591,6 +655,7 @@
   std::vector<MachineConstantPoolValue> Constants; /// Constant pool.
   std::unique_ptr<MachineFunctionInfo> MachineFuncInfo;
   std::vector<CallSiteInfo> CallSitesInfo;
+  std::vector<DebugValueSubstitution> DebugValueSubstitutions;
   MachineJumpTable JumpTableInfo;
   BlockStringValue Body;
 };
@@ -598,7 +663,7 @@
 template <> struct MappingTraits<MachineFunction> {
   static void mapping(IO &YamlIO, MachineFunction &MF) {
     YamlIO.mapRequired("name", MF.Name);
-    YamlIO.mapOptional("alignment", MF.Alignment, (unsigned)0);
+    YamlIO.mapOptional("alignment", MF.Alignment, None);
     YamlIO.mapOptional("exposesReturnsTwice", MF.ExposesReturnsTwice, false);
     YamlIO.mapOptional("legalized", MF.Legalized, false);
     YamlIO.mapOptional("regBankSelected", MF.RegBankSelected, false);
@@ -619,6 +684,8 @@
                        std::vector<MachineStackObject>());
     YamlIO.mapOptional("callSites", MF.CallSitesInfo,
                        std::vector<CallSiteInfo>());
+    YamlIO.mapOptional("debugValueSubstitutions", MF.DebugValueSubstitutions,
+                       std::vector<DebugValueSubstitution>());
     YamlIO.mapOptional("constants", MF.Constants,
                        std::vector<MachineConstantPoolValue>());
     YamlIO.mapOptional("machineFunctionInfo", MF.MachineFuncInfo);
diff --git a/linux-x64/clang/include/llvm/CodeGen/MachineBasicBlock.h b/linux-x64/clang/include/llvm/CodeGen/MachineBasicBlock.h
index 333d0a7..2bad64c 100644
--- a/linux-x64/clang/include/llvm/CodeGen/MachineBasicBlock.h
+++ b/linux-x64/clang/include/llvm/CodeGen/MachineBasicBlock.h
@@ -15,16 +15,13 @@
 
 #include "llvm/ADT/GraphTraits.h"
 #include "llvm/ADT/ilist.h"
-#include "llvm/ADT/ilist_node.h"
 #include "llvm/ADT/iterator_range.h"
-#include "llvm/ADT/simple_ilist.h"
+#include "llvm/ADT/SparseBitVector.h"
 #include "llvm/CodeGen/MachineInstr.h"
 #include "llvm/CodeGen/MachineInstrBundleIterator.h"
 #include "llvm/IR/DebugLoc.h"
 #include "llvm/MC/LaneBitmask.h"
-#include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/Support/BranchProbability.h"
-#include "llvm/Support/Printable.h"
 #include <cassert>
 #include <cstdint>
 #include <functional>
@@ -39,12 +36,45 @@
 class MCSymbol;
 class ModuleSlotTracker;
 class Pass;
+class Printable;
 class SlotIndexes;
 class StringRef;
 class raw_ostream;
+class LiveIntervals;
 class TargetRegisterClass;
 class TargetRegisterInfo;
 
+// This structure uniquely identifies a basic block section.
+// Possible values are
+//  {Type: Default, Number: (unsigned)} (These are regular section IDs)
+//  {Type: Exception, Number: 0}  (ExceptionSectionID)
+//  {Type: Cold, Number: 0}  (ColdSectionID)
+struct MBBSectionID {
+  enum SectionType {
+    Default = 0, // Regular section (these sections are distinguished by the
+                 // Number field).
+    Exception,   // Special section type for exception handling blocks
+    Cold,        // Special section type for cold blocks
+  } Type;
+  unsigned Number;
+
+  MBBSectionID(unsigned N) : Type(Default), Number(N) {}
+
+  // Special unique sections for cold and exception blocks.
+  const static MBBSectionID ColdSectionID;
+  const static MBBSectionID ExceptionSectionID;
+
+  bool operator==(const MBBSectionID &Other) const {
+    return Type == Other.Type && Number == Other.Number;
+  }
+
+  bool operator!=(const MBBSectionID &Other) const { return !(*this == Other); }
+
+private:
+  // This is only used to construct the special cold and exception sections.
+  MBBSectionID(SectionType T) : Type(T), Number(0) {}
+};
+
 template <> struct ilist_traits<MachineInstr> {
 private:
   friend class MachineBasicBlock; // Set by the owning MachineBasicBlock.
@@ -103,9 +133,9 @@
   using LiveInVector = std::vector<RegisterMaskPair>;
   LiveInVector LiveIns;
 
-  /// Alignment of the basic block. Zero if the basic block does not need to be
-  /// aligned. The alignment is specified as log2(bytes).
-  unsigned Alignment = 0;
+  /// Alignment of the basic block. One if the basic block does not need to be
+  /// aligned.
+  Align Alignment;
 
   /// Indicate that this basic block is entered via an exception handler.
   bool IsEHPad = false;
@@ -129,10 +159,26 @@
   /// Indicate that this basic block is the entry block of a cleanup funclet.
   bool IsCleanupFuncletEntry = false;
 
+  /// With basic block sections, this stores the Section ID of the basic block.
+  MBBSectionID SectionID{0};
+
+  // Indicate that this basic block begins a section.
+  bool IsBeginSection = false;
+
+  // Indicate that this basic block ends a section.
+  bool IsEndSection = false;
+
+  /// Indicate that this basic block is the indirect dest of an INLINEASM_BR.
+  bool IsInlineAsmBrIndirectTarget = false;
+
   /// since getSymbol is a relatively heavy-weight operation, the symbol
   /// is only computed once and is cached.
   mutable MCSymbol *CachedMCSymbol = nullptr;
 
+  /// Marks the end of the basic block. Used during basic block sections to
+  /// calculate the size of the basic block, or the BB section ending with it.
+  mutable MCSymbol *CachedEndMCSymbol = nullptr;
+
   // Intrusive list support
   MachineBasicBlock() = default;
 
@@ -312,7 +358,7 @@
   /// Adds the specified register as a live in. Note that it is an error to add
   /// the same register to the same set more than once unless the intention is
   /// to call sortUniqueLiveIns after all registers are added.
-  void addLiveIn(MCPhysReg PhysReg,
+  void addLiveIn(MCRegister PhysReg,
                  LaneBitmask LaneMask = LaneBitmask::getAll()) {
     LiveIns.push_back(RegisterMaskPair(PhysReg, LaneMask));
   }
@@ -331,7 +377,7 @@
   /// Add PhysReg as live in to this block, and ensure that there is a copy of
   /// PhysReg to a virtual register of class RC. Return the virtual register
   /// that is a copy of the live in PhysReg.
-  unsigned addLiveIn(MCPhysReg PhysReg, const TargetRegisterClass *RC);
+  Register addLiveIn(MCRegister PhysReg, const TargetRegisterClass *RC);
 
   /// Remove the specified register from the live in set.
   void removeLiveIn(MCPhysReg Reg,
@@ -372,13 +418,11 @@
   /// \see getBeginClobberMask()
   const uint32_t *getEndClobberMask(const TargetRegisterInfo *TRI) const;
 
-  /// Return alignment of the basic block. The alignment is specified as
-  /// log2(bytes).
-  unsigned getAlignment() const { return Alignment; }
+  /// Return alignment of the basic block.
+  Align getAlignment() const { return Alignment; }
 
-  /// Set alignment of the basic block. The alignment is specified as
-  /// log2(bytes).
-  void setAlignment(unsigned Align) { Alignment = Align; }
+  /// Set alignment of the basic block.
+  void setAlignment(Align A) { Alignment = A; }
 
   /// Returns true if the block is a landing pad. That is this basic block is
   /// entered via an exception handler.
@@ -390,6 +434,9 @@
 
   bool hasEHPadSuccessor() const;
 
+  /// Returns true if this is the entry block of the function.
+  bool isEntryBlock() const;
+
   /// Returns true if this is the entry block of an EH scope, i.e., the block
   /// that used to have a catchpad or cleanuppad instruction in the LLVM IR.
   bool isEHScopeEntry() const { return IsEHScopeEntry; }
@@ -410,6 +457,46 @@
   /// Indicates if this is the entry block of a cleanup funclet.
   void setIsCleanupFuncletEntry(bool V = true) { IsCleanupFuncletEntry = V; }
 
+  /// Returns true if this block begins any section.
+  bool isBeginSection() const { return IsBeginSection; }
+
+  /// Returns true if this block ends any section.
+  bool isEndSection() const { return IsEndSection; }
+
+  void setIsBeginSection(bool V = true) { IsBeginSection = V; }
+
+  void setIsEndSection(bool V = true) { IsEndSection = V; }
+
+  /// Returns the section ID of this basic block.
+  MBBSectionID getSectionID() const { return SectionID; }
+
+  /// Returns the unique section ID number of this basic block.
+  unsigned getSectionIDNum() const {
+    return ((unsigned)MBBSectionID::SectionType::Cold) -
+           ((unsigned)SectionID.Type) + SectionID.Number;
+  }
+
+  /// Sets the section ID for this basic block.
+  void setSectionID(MBBSectionID V) { SectionID = V; }
+
+  /// Returns the MCSymbol marking the end of this basic block.
+  MCSymbol *getEndSymbol() const;
+
+  /// Returns true if this block may have an INLINEASM_BR (overestimate, by
+  /// checking if any of the successors are indirect targets of any inlineasm_br
+  /// in the function).
+  bool mayHaveInlineAsmBr() const;
+
+  /// Returns true if this is the indirect dest of an INLINEASM_BR.
+  bool isInlineAsmBrIndirectTarget() const {
+    return IsInlineAsmBrIndirectTarget;
+  }
+
+  /// Indicates if this is the indirect dest of an INLINEASM_BR.
+  void setIsInlineAsmBrIndirectTarget(bool V = true) {
+    IsInlineAsmBrIndirectTarget = V;
+  }
+
   /// Returns true if it is legal to hoist instructions into this block.
   bool isLegalToHoistInto() const;
 
@@ -421,11 +508,18 @@
   void moveBefore(MachineBasicBlock *NewAfter);
   void moveAfter(MachineBasicBlock *NewBefore);
 
-  /// Update the terminator instructions in block to account for changes to the
-  /// layout. If the block previously used a fallthrough, it may now need a
-  /// branch, and if it previously used branching it may now be able to use a
-  /// fallthrough.
-  void updateTerminator();
+  /// Returns true if this and MBB belong to the same section.
+  bool sameSection(const MachineBasicBlock *MBB) const {
+    return getSectionID() == MBB->getSectionID();
+  }
+
+  /// Update the terminator instructions in block to account for changes to
+  /// block layout which may have been made. PreviousLayoutSuccessor should be
+  /// set to the block which may have been used as fallthrough before the block
+  /// layout was modified.  If the block previously fell through to that block,
+  /// it may now need a branch. If it previously branched to another block, it
+  /// may now be able to fallthrough to the current layout successor.
+  void updateTerminator(MachineBasicBlock *PreviousLayoutSuccessor);
 
   // Machine-CFG mutators
 
@@ -585,12 +679,25 @@
     return !empty() && back().isEHScopeReturn();
   }
 
+  /// Split a basic block into 2 pieces at \p SplitPoint. A new block will be
+  /// inserted after this block, and all instructions after \p SplitInst moved
+  /// to it (\p SplitInst will be in the original block). If \p LIS is provided,
+  /// LiveIntervals will be appropriately updated. \return the newly inserted
+  /// block.
+  ///
+  /// If \p UpdateLiveIns is true, this will ensure the live ins list is
+  /// accurate, including for physreg uses/defs in the original block.
+  MachineBasicBlock *splitAt(MachineInstr &SplitInst, bool UpdateLiveIns = true,
+                             LiveIntervals *LIS = nullptr);
+
   /// Split the critical edge from this block to the given successor block, and
   /// return the newly created block, or null if splitting is not possible.
   ///
   /// This function updates LiveVariables, MachineDominatorTree, and
   /// MachineLoopInfo, as applicable.
-  MachineBasicBlock *SplitCriticalEdge(MachineBasicBlock *Succ, Pass &P);
+  MachineBasicBlock *
+  SplitCriticalEdge(MachineBasicBlock *Succ, Pass &P,
+                    std::vector<SparseBitVector<>> *LiveInSets = nullptr);
 
   /// Check if the edge between this block and the given successor \p
   /// Succ, can be split. If this returns true a subsequent call to
@@ -636,6 +743,18 @@
     return Insts.insertAfter(I.getInstrIterator(), MI);
   }
 
+  /// If I is bundled then insert MI into the instruction list after the end of
+  /// the bundle, otherwise insert MI immediately after I.
+  instr_iterator insertAfterBundle(instr_iterator I, MachineInstr *MI) {
+    assert((I == instr_end() || I->getParent() == this) &&
+           "iterator points outside of basic block");
+    assert(!MI->isBundledWithPred() && !MI->isBundledWithSucc() &&
+           "Cannot insert instruction with bundle flags");
+    while (I->isBundledWithSucc())
+      ++I;
+    return Insts.insertAfter(I, MI);
+  }
+
   /// Remove an instruction from the instruction list and delete it.
   ///
   /// If the instruction is part of a bundle, the other instructions in the
@@ -723,15 +842,9 @@
   /// CFG so that it branches to 'New' instead.
   void ReplaceUsesOfBlockWith(MachineBasicBlock *Old, MachineBasicBlock *New);
 
-  /// Various pieces of code can cause excess edges in the CFG to be inserted.
-  /// If we have proven that MBB can only branch to DestA and DestB, remove any
-  /// other MBB successors from the CFG. DestA and DestB can be null. Besides
-  /// DestA and DestB, retain other edges leading to LandingPads (currently
-  /// there can be only one; we don't check or require that here). Note it is
-  /// possible that DestA and/or DestB are LandingPads.
-  bool CorrectExtraCFGEdges(MachineBasicBlock *DestA,
-                            MachineBasicBlock *DestB,
-                            bool IsCond);
+  /// Update all phi nodes in this basic block to refer to basic block \p New
+  /// instead of basic block \p Old.
+  void replacePhiUsesWith(MachineBasicBlock *Old, MachineBasicBlock *New);
 
   /// Find the next valid DebugLoc starting at MBBI, skipping any DBG_VALUE
   /// and DBG_LABEL instructions.  Return UnknownLoc if there is none.
@@ -767,7 +880,7 @@
   ///
   /// \p Reg must be a physical register.
   LivenessQueryResult computeRegisterLiveness(const TargetRegisterInfo *TRI,
-                                              unsigned Reg,
+                                              MCRegister Reg,
                                               const_iterator Before,
                                               unsigned Neighborhood = 10) const;
 
@@ -778,6 +891,14 @@
   void print(raw_ostream &OS, ModuleSlotTracker &MST,
              const SlotIndexes * = nullptr, bool IsStandalone = true) const;
 
+  enum PrintNameFlag {
+    PrintNameIr = (1 << 0), ///< Add IR name where available
+    PrintNameAttributes = (1 << 1), ///< Print attributes
+  };
+
+  void printName(raw_ostream &os, unsigned printNameFlags = PrintNameIr,
+                 ModuleSlotTracker *moduleSlotTracker = nullptr) const;
+
   // Printing method used by LoopInfo.
   void printAsOperand(raw_ostream &OS, bool PrintType = true) const;
 
@@ -932,7 +1053,7 @@
 template<typename IterT>
 inline IterT skipDebugInstructionsForward(IterT It, IterT End) {
   while (It != End && It->isDebugInstr())
-    It++;
+    ++It;
   return It;
 }
 
@@ -943,10 +1064,31 @@
 template<class IterT>
 inline IterT skipDebugInstructionsBackward(IterT It, IterT Begin) {
   while (It != Begin && It->isDebugInstr())
-    It--;
+    --It;
   return It;
 }
 
+/// Increment \p It, then continue incrementing it while it points to a debug
+/// instruction. A replacement for std::next.
+template <typename IterT> inline IterT next_nodbg(IterT It, IterT End) {
+  return skipDebugInstructionsForward(std::next(It), End);
+}
+
+/// Decrement \p It, then continue decrementing it while it points to a debug
+/// instruction. A replacement for std::prev.
+template <typename IterT> inline IterT prev_nodbg(IterT It, IterT Begin) {
+  return skipDebugInstructionsBackward(std::prev(It), Begin);
+}
+
+/// Construct a range iterator which begins at \p It and moves forwards until
+/// \p End is reached, skipping any debug instructions.
+template <typename IterT>
+inline auto instructionsWithoutDebug(IterT It, IterT End) {
+  return make_filter_range(make_range(It, End), [](const MachineInstr &MI) {
+    return !MI.isDebugInstr();
+  });
+}
+
 } // end namespace llvm
 
 #endif // LLVM_CODEGEN_MACHINEBASICBLOCK_H
diff --git a/linux-x64/clang/include/llvm/CodeGen/MachineBlockFrequencyInfo.h b/linux-x64/clang/include/llvm/CodeGen/MachineBlockFrequencyInfo.h
index a438ecf..6c442d3 100644
--- a/linux-x64/clang/include/llvm/CodeGen/MachineBlockFrequencyInfo.h
+++ b/linux-x64/clang/include/llvm/CodeGen/MachineBlockFrequencyInfo.h
@@ -38,6 +38,9 @@
   static char ID;
 
   MachineBlockFrequencyInfo();
+  explicit MachineBlockFrequencyInfo(MachineFunction &F,
+                                     MachineBranchProbabilityInfo &MBPI,
+                                     MachineLoopInfo &MLI);
   ~MachineBlockFrequencyInfo() override;
 
   void getAnalysisUsage(AnalysisUsage &AU) const override;
@@ -55,16 +58,33 @@
   /// information. Please note that initial frequency is equal to 1024. It means
   /// that we should not rely on the value itself, but only on the comparison to
   /// the other block frequencies. We do this to avoid using of floating points.
-  ///
+  /// For example, to get the frequency of a block relative to the entry block,
+  /// divide the integral value returned by this function (the
+  /// BlockFrequency::getFrequency() value) by getEntryFreq().
   BlockFrequency getBlockFreq(const MachineBasicBlock *MBB) const;
 
+  /// Compute the frequency of the block, relative to the entry block.
+  /// This API assumes getEntryFreq() is non-zero.
+  float getBlockFreqRelativeToEntryBlock(const MachineBasicBlock *MBB) const {
+    return getBlockFreq(MBB).getFrequency() * (1.0f / getEntryFreq());
+  }
+
   Optional<uint64_t> getBlockProfileCount(const MachineBasicBlock *MBB) const;
   Optional<uint64_t> getProfileCountFromFreq(uint64_t Freq) const;
 
-  bool isIrrLoopHeader(const MachineBasicBlock *MBB);
+  bool isIrrLoopHeader(const MachineBasicBlock *MBB) const;
+
+  /// incrementally calculate block frequencies when we split edges, to avoid
+  /// full CFG traversal.
+  void onEdgeSplit(const MachineBasicBlock &NewPredecessor,
+                   const MachineBasicBlock &NewSuccessor,
+                   const MachineBranchProbabilityInfo &MBPI);
 
   const MachineFunction *getFunction() const;
   const MachineBranchProbabilityInfo *getMBPI() const;
+
+  /// Pop up a ghostview window with the current block frequency propagation
+  /// rendered using dot.
   void view(const Twine &Name, bool isSimple = true) const;
 
   // Print the block frequency Freq to OS using the current functions entry
@@ -76,6 +96,8 @@
   raw_ostream &printBlockFreq(raw_ostream &OS,
                               const MachineBasicBlock *MBB) const;
 
+  /// Divide a block's BlockFrequency::getFrequency() value by this value to
+  /// obtain the entry block - relative frequency of said block.
   uint64_t getEntryFreq() const;
 };
 
diff --git a/linux-x64/clang/include/llvm/CodeGen/MachineBranchProbabilityInfo.h b/linux-x64/clang/include/llvm/CodeGen/MachineBranchProbabilityInfo.h
index 2b9b203..cde3bc0 100644
--- a/linux-x64/clang/include/llvm/CodeGen/MachineBranchProbabilityInfo.h
+++ b/linux-x64/clang/include/llvm/CodeGen/MachineBranchProbabilityInfo.h
@@ -35,10 +35,7 @@
 public:
   static char ID;
 
-  MachineBranchProbabilityInfo() : ImmutablePass(ID) {
-    PassRegistry &Registry = *PassRegistry::getPassRegistry();
-    initializeMachineBranchProbabilityInfoPass(Registry);
-  }
+  MachineBranchProbabilityInfo();
 
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.setPreservesAll();
diff --git a/linux-x64/clang/include/llvm/CodeGen/MachineCombinerPattern.h b/linux-x64/clang/include/llvm/CodeGen/MachineCombinerPattern.h
index 4f4034b..e9f52fb 100644
--- a/linux-x64/clang/include/llvm/CodeGen/MachineCombinerPattern.h
+++ b/linux-x64/clang/include/llvm/CodeGen/MachineCombinerPattern.h
@@ -25,6 +25,10 @@
   REASSOC_XA_BY,
   REASSOC_XA_YB,
 
+  // These are patterns matched by the PowerPC to reassociate FMA chains.
+  REASSOC_XY_AMM_BMM,
+  REASSOC_XMM_AMM_BMM,
+
   // These are multiply-add patterns matched by the AArch64 machine combiner.
   MULADDW_OP1,
   MULADDW_OP2,
@@ -38,7 +42,56 @@
   MULSUBX_OP2,
   MULADDXI_OP1,
   MULSUBXI_OP1,
+  // NEON integers vectors
+  MULADDv8i8_OP1,
+  MULADDv8i8_OP2,
+  MULADDv16i8_OP1,
+  MULADDv16i8_OP2,
+  MULADDv4i16_OP1,
+  MULADDv4i16_OP2,
+  MULADDv8i16_OP1,
+  MULADDv8i16_OP2,
+  MULADDv2i32_OP1,
+  MULADDv2i32_OP2,
+  MULADDv4i32_OP1,
+  MULADDv4i32_OP2,
+
+  MULSUBv8i8_OP1,
+  MULSUBv8i8_OP2,
+  MULSUBv16i8_OP1,
+  MULSUBv16i8_OP2,
+  MULSUBv4i16_OP1,
+  MULSUBv4i16_OP2,
+  MULSUBv8i16_OP1,
+  MULSUBv8i16_OP2,
+  MULSUBv2i32_OP1,
+  MULSUBv2i32_OP2,
+  MULSUBv4i32_OP1,
+  MULSUBv4i32_OP2,
+
+  MULADDv4i16_indexed_OP1,
+  MULADDv4i16_indexed_OP2,
+  MULADDv8i16_indexed_OP1,
+  MULADDv8i16_indexed_OP2,
+  MULADDv2i32_indexed_OP1,
+  MULADDv2i32_indexed_OP2,
+  MULADDv4i32_indexed_OP1,
+  MULADDv4i32_indexed_OP2,
+
+  MULSUBv4i16_indexed_OP1,
+  MULSUBv4i16_indexed_OP2,
+  MULSUBv8i16_indexed_OP1,
+  MULSUBv8i16_indexed_OP2,
+  MULSUBv2i32_indexed_OP1,
+  MULSUBv2i32_indexed_OP2,
+  MULSUBv4i32_indexed_OP1,
+  MULSUBv4i32_indexed_OP2,
+
   // Floating Point
+  FMULADDH_OP1,
+  FMULADDH_OP2,
+  FMULSUBH_OP1,
+  FMULSUBH_OP2,
   FMULADDS_OP1,
   FMULADDS_OP2,
   FMULSUBS_OP1,
@@ -47,16 +100,25 @@
   FMULADDD_OP2,
   FMULSUBD_OP1,
   FMULSUBD_OP2,
+  FNMULSUBH_OP1,
   FNMULSUBS_OP1,
   FNMULSUBD_OP1,
   FMLAv1i32_indexed_OP1,
   FMLAv1i32_indexed_OP2,
   FMLAv1i64_indexed_OP1,
   FMLAv1i64_indexed_OP2,
+  FMLAv4f16_OP1,
+  FMLAv4f16_OP2,
+  FMLAv8f16_OP1,
+  FMLAv8f16_OP2,
   FMLAv2f32_OP2,
   FMLAv2f32_OP1,
   FMLAv2f64_OP1,
   FMLAv2f64_OP2,
+  FMLAv4i16_indexed_OP1,
+  FMLAv4i16_indexed_OP2,
+  FMLAv8i16_indexed_OP1,
+  FMLAv8i16_indexed_OP2,
   FMLAv2i32_indexed_OP1,
   FMLAv2i32_indexed_OP2,
   FMLAv2i64_indexed_OP1,
@@ -67,10 +129,18 @@
   FMLAv4i32_indexed_OP2,
   FMLSv1i32_indexed_OP2,
   FMLSv1i64_indexed_OP2,
+  FMLSv4f16_OP1,
+  FMLSv4f16_OP2,
+  FMLSv8f16_OP1,
+  FMLSv8f16_OP2,
   FMLSv2f32_OP1,
   FMLSv2f32_OP2,
   FMLSv2f64_OP1,
   FMLSv2f64_OP2,
+  FMLSv4i16_indexed_OP1,
+  FMLSv4i16_indexed_OP2,
+  FMLSv8i16_indexed_OP1,
+  FMLSv8i16_indexed_OP2,
   FMLSv2i32_indexed_OP1,
   FMLSv2i32_indexed_OP2,
   FMLSv2i64_indexed_OP1,
diff --git a/linux-x64/clang/include/llvm/CodeGen/MachineConstantPool.h b/linux-x64/clang/include/llvm/CodeGen/MachineConstantPool.h
index 4d07b62..a9bc0ce 100644
--- a/linux-x64/clang/include/llvm/CodeGen/MachineConstantPool.h
+++ b/linux-x64/clang/include/llvm/CodeGen/MachineConstantPool.h
@@ -17,6 +17,7 @@
 
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/MC/SectionKind.h"
+#include "llvm/Support/Alignment.h"
 #include <climits>
 #include <vector>
 
@@ -40,12 +41,12 @@
   explicit MachineConstantPoolValue(Type *ty) : Ty(ty) {}
   virtual ~MachineConstantPoolValue() = default;
 
-  /// getType - get type of this MachineConstantPoolValue.
-  ///
   Type *getType() const { return Ty; }
 
+  virtual unsigned getSizeInBytes(const DataLayout &DL) const;
+
   virtual int getExistingMachineCPValue(MachineConstantPool *CP,
-                                        unsigned Alignment) = 0;
+                                        Align Alignment) = 0;
 
   virtual void addSelectionDAGCSEId(FoldingSetNodeID &ID) = 0;
 
@@ -71,33 +72,29 @@
     MachineConstantPoolValue *MachineCPVal;
   } Val;
 
-  /// The required alignment for this entry. The top bit is set when Val is
-  /// a target specific MachineConstantPoolValue.
-  unsigned Alignment;
+  /// The required alignment for this entry.
+  Align Alignment;
 
-  MachineConstantPoolEntry(const Constant *V, unsigned A)
-    : Alignment(A) {
+  bool IsMachineConstantPoolEntry;
+
+  MachineConstantPoolEntry(const Constant *V, Align A)
+      : Alignment(A), IsMachineConstantPoolEntry(false) {
     Val.ConstVal = V;
   }
 
-  MachineConstantPoolEntry(MachineConstantPoolValue *V, unsigned A)
-      : Alignment(A) {
+  MachineConstantPoolEntry(MachineConstantPoolValue *V, Align A)
+      : Alignment(A), IsMachineConstantPoolEntry(true) {
     Val.MachineCPVal = V;
-    Alignment |= 1U << (sizeof(unsigned) * CHAR_BIT - 1);
   }
 
   /// isMachineConstantPoolEntry - Return true if the MachineConstantPoolEntry
   /// is indeed a target specific constantpool entry, not a wrapper over a
   /// Constant.
-  bool isMachineConstantPoolEntry() const {
-    return (int)Alignment < 0;
-  }
+  bool isMachineConstantPoolEntry() const { return IsMachineConstantPoolEntry; }
 
-  int getAlignment() const {
-    return Alignment & ~(1 << (sizeof(unsigned) * CHAR_BIT - 1));
-  }
+  Align getAlign() const { return Alignment; }
 
-  Type *getType() const;
+  unsigned getSizeInBytes(const DataLayout &DL) const;
 
   /// This method classifies the entry according to whether or not it may
   /// generate a relocation entry.  This must be conservative, so if it might
@@ -118,7 +115,7 @@
 /// address of the function constant pool values.
 /// The machine constant pool.
 class MachineConstantPool {
-  unsigned PoolAlignment;       ///< The alignment for the pool.
+  Align PoolAlignment; ///< The alignment for the pool.
   std::vector<MachineConstantPoolEntry> Constants; ///< The pool of constants.
   /// MachineConstantPoolValues that use an existing MachineConstantPoolEntry.
   DenseSet<MachineConstantPoolValue*> MachineCPVsSharingEntries;
@@ -132,16 +129,15 @@
       : PoolAlignment(1), DL(DL) {}
   ~MachineConstantPool();
 
-  /// getConstantPoolAlignment - Return the alignment required by
-  /// the whole constant pool, of which the first element must be aligned.
-  unsigned getConstantPoolAlignment() const { return PoolAlignment; }
+  /// Return the alignment required by the whole constant pool, of which the
+  /// first element must be aligned.
+  Align getConstantPoolAlign() const { return PoolAlignment; }
 
   /// getConstantPoolIndex - Create a new entry in the constant pool or return
   /// an existing one.  User must specify the minimum required alignment for
   /// the object.
-  unsigned getConstantPoolIndex(const Constant *C, unsigned Alignment);
-  unsigned getConstantPoolIndex(MachineConstantPoolValue *V,
-                                unsigned Alignment);
+  unsigned getConstantPoolIndex(const Constant *C, Align Alignment);
+  unsigned getConstantPoolIndex(MachineConstantPoolValue *V, Align Alignment);
 
   /// isEmpty - Return true if this constant pool contains no constants.
   bool isEmpty() const { return Constants.empty(); }
diff --git a/linux-x64/clang/include/llvm/CodeGen/MachineDominanceFrontier.h b/linux-x64/clang/include/llvm/CodeGen/MachineDominanceFrontier.h
index f7bbd07..e3e6796 100644
--- a/linux-x64/clang/include/llvm/CodeGen/MachineDominanceFrontier.h
+++ b/linux-x64/clang/include/llvm/CodeGen/MachineDominanceFrontier.h
@@ -14,7 +14,6 @@
 #include "llvm/CodeGen/MachineBasicBlock.h"
 #include "llvm/CodeGen/MachineFunctionPass.h"
 #include "llvm/Support/GenericDomTree.h"
-#include <vector>
 
 namespace llvm {
 
diff --git a/linux-x64/clang/include/llvm/CodeGen/MachineDominators.h b/linux-x64/clang/include/llvm/CodeGen/MachineDominators.h
index d220008..46bf73c 100644
--- a/linux-x64/clang/include/llvm/CodeGen/MachineDominators.h
+++ b/linux-x64/clang/include/llvm/CodeGen/MachineDominators.h
@@ -23,7 +23,6 @@
 #include "llvm/Support/GenericDomTreeConstruction.h"
 #include <cassert>
 #include <memory>
-#include <vector>
 
 namespace llvm {
 
@@ -44,6 +43,8 @@
 /// compute a normal dominator tree.
 ///
 class MachineDominatorTree : public MachineFunctionPass {
+  using DomTreeT = DomTreeBase<MachineBasicBlock>;
+
   /// Helper structure used to hold all the basic blocks
   /// involved in the split of a critical edge.
   struct CriticalEdge {
@@ -65,8 +66,8 @@
   /// such as BB == elt.NewBB.
   mutable SmallSet<MachineBasicBlock *, 32> NewBBs;
 
-  /// The DominatorTreeBase that is used to compute a normal dominator tree
-  std::unique_ptr<DomTreeBase<MachineBasicBlock>> DT;
+  /// The DominatorTreeBase that is used to compute a normal dominator tree.
+  std::unique_ptr<DomTreeT> DT;
 
   /// Apply all the recorded critical edges to the DT.
   /// This updates the underlying DT information in a way that uses
@@ -79,44 +80,39 @@
   static char ID; // Pass ID, replacement for typeid
 
   MachineDominatorTree();
+  explicit MachineDominatorTree(MachineFunction &MF) : MachineFunctionPass(ID) {
+    calculate(MF);
+  }
 
-  DomTreeBase<MachineBasicBlock> &getBase() {
-    if (!DT) DT.reset(new DomTreeBase<MachineBasicBlock>());
+  DomTreeT &getBase() {
+    if (!DT) DT.reset(new DomTreeT());
     applySplitCriticalEdges();
     return *DT;
   }
 
   void getAnalysisUsage(AnalysisUsage &AU) const override;
 
-  /// getRoots -  Return the root blocks of the current CFG.  This may include
-  /// multiple blocks if we are computing post dominators.  For forward
-  /// dominators, this will always be a single block (the entry node).
-  ///
-  inline const SmallVectorImpl<MachineBasicBlock*> &getRoots() const {
-    applySplitCriticalEdges();
-    return DT->getRoots();
-  }
-
-  inline MachineBasicBlock *getRoot() const {
+  MachineBasicBlock *getRoot() const {
     applySplitCriticalEdges();
     return DT->getRoot();
   }
 
-  inline MachineDomTreeNode *getRootNode() const {
+  MachineDomTreeNode *getRootNode() const {
     applySplitCriticalEdges();
     return DT->getRootNode();
   }
 
   bool runOnMachineFunction(MachineFunction &F) override;
 
-  inline bool dominates(const MachineDomTreeNode* A,
-                        const MachineDomTreeNode* B) const {
+  void calculate(MachineFunction &F);
+
+  bool dominates(const MachineDomTreeNode *A,
+                 const MachineDomTreeNode *B) const {
     applySplitCriticalEdges();
     return DT->dominates(A, B);
   }
 
-  inline bool dominates(const MachineBasicBlock* A,
-                        const MachineBasicBlock* B) const {
+  bool dominates(const MachineBasicBlock *A, const MachineBasicBlock *B) const {
     applySplitCriticalEdges();
     return DT->dominates(A, B);
   }
@@ -133,36 +129,30 @@
     for (; &*I != A && &*I != B; ++I)
       /*empty*/ ;
 
-    //if(!DT.IsPostDominators) {
-      // A dominates B if it is found first in the basic block.
-      return &*I == A;
-    //} else {
-    //  // A post-dominates B if B is found first in the basic block.
-    //  return &*I == B;
-    //}
+    return &*I == A;
   }
 
-  inline bool properlyDominates(const MachineDomTreeNode* A,
-                                const MachineDomTreeNode* B) const {
+  bool properlyDominates(const MachineDomTreeNode *A,
+                         const MachineDomTreeNode *B) const {
     applySplitCriticalEdges();
     return DT->properlyDominates(A, B);
   }
 
-  inline bool properlyDominates(const MachineBasicBlock* A,
-                                const MachineBasicBlock* B) const {
+  bool properlyDominates(const MachineBasicBlock *A,
+                         const MachineBasicBlock *B) const {
     applySplitCriticalEdges();
     return DT->properlyDominates(A, B);
   }
 
   /// findNearestCommonDominator - Find nearest common dominator basic block
   /// for basic block A and B. If there is no such block then return NULL.
-  inline MachineBasicBlock *findNearestCommonDominator(MachineBasicBlock *A,
-                                                       MachineBasicBlock *B) {
+  MachineBasicBlock *findNearestCommonDominator(MachineBasicBlock *A,
+                                                MachineBasicBlock *B) {
     applySplitCriticalEdges();
     return DT->findNearestCommonDominator(A, B);
   }
 
-  inline MachineDomTreeNode *operator[](MachineBasicBlock *BB) const {
+  MachineDomTreeNode *operator[](MachineBasicBlock *BB) const {
     applySplitCriticalEdges();
     return DT->getNode(BB);
   }
@@ -170,7 +160,7 @@
   /// getNode - return the (Post)DominatorTree node for the specified basic
   /// block.  This is the same as using operator[] on this class.
   ///
-  inline MachineDomTreeNode *getNode(MachineBasicBlock *BB) const {
+  MachineDomTreeNode *getNode(MachineBasicBlock *BB) const {
     applySplitCriticalEdges();
     return DT->getNode(BB);
   }
@@ -178,8 +168,8 @@
   /// addNewBlock - Add a new node to the dominator tree information.  This
   /// creates a new node as a child of DomBB dominator node,linking it into
   /// the children list of the immediate dominator.
-  inline MachineDomTreeNode *addNewBlock(MachineBasicBlock *BB,
-                                         MachineBasicBlock *DomBB) {
+  MachineDomTreeNode *addNewBlock(MachineBasicBlock *BB,
+                                  MachineBasicBlock *DomBB) {
     applySplitCriticalEdges();
     return DT->addNewBlock(BB, DomBB);
   }
@@ -187,14 +177,14 @@
   /// changeImmediateDominator - This method is used to update the dominator
   /// tree information when a node's immediate dominator changes.
   ///
-  inline void changeImmediateDominator(MachineBasicBlock *N,
-                                       MachineBasicBlock* NewIDom) {
+  void changeImmediateDominator(MachineBasicBlock *N,
+                                MachineBasicBlock *NewIDom) {
     applySplitCriticalEdges();
     DT->changeImmediateDominator(N, NewIDom);
   }
 
-  inline void changeImmediateDominator(MachineDomTreeNode *N,
-                                       MachineDomTreeNode* NewIDom) {
+  void changeImmediateDominator(MachineDomTreeNode *N,
+                                MachineDomTreeNode *NewIDom) {
     applySplitCriticalEdges();
     DT->changeImmediateDominator(N, NewIDom);
   }
@@ -202,14 +192,14 @@
   /// eraseNode - Removes a node from  the dominator tree. Block must not
   /// dominate any other blocks. Removes node from its immediate dominator's
   /// children list. Deletes dominator node associated with basic block BB.
-  inline void eraseNode(MachineBasicBlock *BB) {
+  void eraseNode(MachineBasicBlock *BB) {
     applySplitCriticalEdges();
     DT->eraseNode(BB);
   }
 
   /// splitBlock - BB is split and now it has one successor. Update dominator
   /// tree to reflect this change.
-  inline void splitBlock(MachineBasicBlock* NewBB) {
+  void splitBlock(MachineBasicBlock* NewBB) {
     applySplitCriticalEdges();
     DT->splitBlock(NewBB);
   }
@@ -270,7 +260,8 @@
 template <>
 struct GraphTraits<MachineDomTreeNode *>
     : public MachineDomTreeGraphTraitsBase<MachineDomTreeNode,
-                                           MachineDomTreeNode::iterator> {};
+                                           MachineDomTreeNode::const_iterator> {
+};
 
 template <>
 struct GraphTraits<const MachineDomTreeNode *>
diff --git a/linux-x64/clang/include/llvm/CodeGen/MachineFrameInfo.h b/linux-x64/clang/include/llvm/CodeGen/MachineFrameInfo.h
index 7617351..7f0ec0d 100644
--- a/linux-x64/clang/include/llvm/CodeGen/MachineFrameInfo.h
+++ b/linux-x64/clang/include/llvm/CodeGen/MachineFrameInfo.h
@@ -14,6 +14,8 @@
 #define LLVM_CODEGEN_MACHINEFRAMEINFO_H
 
 #include "llvm/ADT/SmallVector.h"
+#include "llvm/CodeGen/Register.h"
+#include "llvm/Support/Alignment.h"
 #include "llvm/Support/DataTypes.h"
 #include <cassert>
 #include <vector>
@@ -30,7 +32,7 @@
 /// Callee saved reg can also be saved to a different register rather than
 /// on the stack by setting DstReg instead of FrameIdx.
 class CalleeSavedInfo {
-  unsigned Reg;
+  Register Reg;
   union {
     int FrameIdx;
     unsigned DstReg;
@@ -57,14 +59,14 @@
   : Reg(R), FrameIdx(FI), Restored(true), SpilledToReg(false) {}
 
   // Accessors.
-  unsigned getReg()                        const { return Reg; }
+  Register getReg()                        const { return Reg; }
   int getFrameIdx()                        const { return FrameIdx; }
   unsigned getDstReg()                     const { return DstReg; }
   void setFrameIdx(int FI) {
     FrameIdx = FI;
     SpilledToReg = false;
   }
-  void setDstReg(unsigned SpillReg) {
+  void setDstReg(Register SpillReg) {
     DstReg = SpillReg;
     SpilledToReg = true;
   }
@@ -129,7 +131,7 @@
     uint64_t Size;
 
     // The required alignment of this stack slot.
-    unsigned Alignment;
+    Align Alignment;
 
     // If true, the value of the stack object is set before
     // entering the function and is not modified inside the function. By
@@ -180,17 +182,16 @@
 
     uint8_t SSPLayout;
 
-    StackObject(uint64_t Size, unsigned Alignment, int64_t SPOffset,
+    StackObject(uint64_t Size, Align Alignment, int64_t SPOffset,
                 bool IsImmutable, bool IsSpillSlot, const AllocaInst *Alloca,
                 bool IsAliased, uint8_t StackID = 0)
-      : SPOffset(SPOffset), Size(Size), Alignment(Alignment),
-        isImmutable(IsImmutable), isSpillSlot(IsSpillSlot),
-        StackID(StackID), Alloca(Alloca), isAliased(IsAliased),
-        SSPLayout(SSPLK_None) {}
+        : SPOffset(SPOffset), Size(Size), Alignment(Alignment),
+          isImmutable(IsImmutable), isSpillSlot(IsSpillSlot), StackID(StackID),
+          Alloca(Alloca), isAliased(IsAliased), SSPLayout(SSPLK_None) {}
   };
 
   /// The alignment of the stack.
-  unsigned StackAlignment;
+  Align StackAlignment;
 
   /// Can the stack be realigned. This can be false if the target does not
   /// support stack realignment, or if the user asks us not to realign the
@@ -260,7 +261,7 @@
   /// native alignment maintained by the compiler, dynamic alignment code will
   /// be needed.
   ///
-  unsigned MaxAlignment = 0;
+  Align MaxAlignment;
 
   /// Set to true if this function adjusts the stack -- e.g.,
   /// when calling another function. This is only valid during and after
@@ -304,7 +305,7 @@
 
   /// Required alignment of the local object blob, which is the strictest
   /// alignment of any object in it.
-  unsigned LocalFrameMaxAlign = 0;
+  Align LocalFrameMaxAlign;
 
   /// Whether the local object blob needs to be allocated together. If not,
   /// PEI should ignore the isPreAllocated flags on the stack objects and
@@ -338,8 +339,8 @@
 public:
   explicit MachineFrameInfo(unsigned StackAlignment, bool StackRealignable,
                             bool ForcedRealign)
-      : StackAlignment(StackAlignment), StackRealignable(StackRealignable),
-        ForcedRealign(ForcedRealign) {}
+      : StackAlignment(assumeAligned(StackAlignment)),
+        StackRealignable(StackRealignable), ForcedRealign(ForcedRealign) {}
 
   /// Return true if there are any stack objects in this function.
   bool hasStackObjects() const { return !Objects.empty(); }
@@ -419,10 +420,12 @@
 
   /// Required alignment of the local object blob,
   /// which is the strictest alignment of any object in it.
-  void setLocalFrameMaxAlign(unsigned Align) { LocalFrameMaxAlign = Align; }
+  void setLocalFrameMaxAlign(Align Alignment) {
+    LocalFrameMaxAlign = Alignment;
+  }
 
   /// Return the required alignment of the local object blob.
-  unsigned getLocalFrameMaxAlign() const { return LocalFrameMaxAlign; }
+  Align getLocalFrameMaxAlign() const { return LocalFrameMaxAlign; }
 
   /// Get whether the local allocation blob should be allocated together or
   /// let PEI allocate the locals in it directly.
@@ -458,22 +461,34 @@
     Objects[ObjectIdx+NumFixedObjects].Size = Size;
   }
 
+  LLVM_ATTRIBUTE_DEPRECATED(inline unsigned getObjectAlignment(int ObjectIdx)
+                                const,
+                            "Use getObjectAlign instead") {
+    return getObjectAlign(ObjectIdx).value();
+  }
+
   /// Return the alignment of the specified stack object.
-  unsigned getObjectAlignment(int ObjectIdx) const {
-    assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() &&
+  Align getObjectAlign(int ObjectIdx) const {
+    assert(unsigned(ObjectIdx + NumFixedObjects) < Objects.size() &&
            "Invalid Object Idx!");
-    return Objects[ObjectIdx+NumFixedObjects].Alignment;
+    return Objects[ObjectIdx + NumFixedObjects].Alignment;
   }
 
   /// setObjectAlignment - Change the alignment of the specified stack object.
-  void setObjectAlignment(int ObjectIdx, unsigned Align) {
-    assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() &&
+  void setObjectAlignment(int ObjectIdx, Align Alignment) {
+    assert(unsigned(ObjectIdx + NumFixedObjects) < Objects.size() &&
            "Invalid Object Idx!");
-    Objects[ObjectIdx+NumFixedObjects].Alignment = Align;
+    Objects[ObjectIdx + NumFixedObjects].Alignment = Alignment;
 
     // Only ensure max alignment for the default stack.
     if (getStackID(ObjectIdx) == 0)
-      ensureMaxAlignment(Align);
+      ensureMaxAlignment(Alignment);
+  }
+
+  LLVM_ATTRIBUTE_DEPRECATED(inline void setObjectAlignment(int ObjectIdx,
+                                                           unsigned Align),
+                            "Use the version that takes Align instead") {
+    setObjectAlignment(ObjectIdx, assumeAligned(Align));
   }
 
   /// Return the underlying Alloca of the specified
@@ -551,7 +566,7 @@
   void setStackSize(uint64_t Size) { StackSize = Size; }
 
   /// Estimate and return the size of the stack frame.
-  unsigned estimateStackSize(const MachineFunction &MF) const;
+  uint64_t estimateStackSize(const MachineFunction &MF) const;
 
   /// Return the correction for frame offsets.
   int getOffsetAdjustment() const { return OffsetAdjustment; }
@@ -561,10 +576,21 @@
 
   /// Return the alignment in bytes that this function must be aligned to,
   /// which is greater than the default stack alignment provided by the target.
-  unsigned getMaxAlignment() const { return MaxAlignment; }
+  LLVM_ATTRIBUTE_DEPRECATED(unsigned getMaxAlignment() const,
+                            "Use getMaxAlign instead") {
+    return MaxAlignment.value();
+  }
+  /// Return the alignment in bytes that this function must be aligned to,
+  /// which is greater than the default stack alignment provided by the target.
+  Align getMaxAlign() const { return MaxAlignment; }
 
   /// Make sure the function is at least Align bytes aligned.
-  void ensureMaxAlignment(unsigned Align);
+  void ensureMaxAlignment(Align Alignment);
+
+  LLVM_ATTRIBUTE_DEPRECATED(inline void ensureMaxAlignment(unsigned Align),
+                            "Use the version that uses Align instead") {
+    ensureMaxAlignment(assumeAligned(Align));
+  }
 
   /// Return true if this function adjusts the stack -- e.g.,
   /// when calling another function. This is only valid during and after
@@ -728,12 +754,26 @@
 
   /// Create a new statically sized stack object, returning
   /// a nonnegative identifier to represent it.
-  int CreateStackObject(uint64_t Size, unsigned Alignment, bool isSpillSlot,
+  int CreateStackObject(uint64_t Size, Align Alignment, bool isSpillSlot,
                         const AllocaInst *Alloca = nullptr, uint8_t ID = 0);
+  LLVM_ATTRIBUTE_DEPRECATED(
+      inline int CreateStackObject(uint64_t Size, unsigned Alignment,
+                                   bool isSpillSlot,
+                                   const AllocaInst *Alloca = nullptr,
+                                   uint8_t ID = 0),
+      "Use CreateStackObject that takes an Align instead") {
+    return CreateStackObject(Size, assumeAligned(Alignment), isSpillSlot,
+                             Alloca, ID);
+  }
 
   /// Create a new statically sized stack object that represents a spill slot,
   /// returning a nonnegative identifier to represent it.
-  int CreateSpillStackObject(uint64_t Size, unsigned Alignment);
+  int CreateSpillStackObject(uint64_t Size, Align Alignment);
+  LLVM_ATTRIBUTE_DEPRECATED(
+      inline int CreateSpillStackObject(uint64_t Size, unsigned Alignment),
+      "Use CreateSpillStackObject that takes an Align instead") {
+    return CreateSpillStackObject(Size, assumeAligned(Alignment));
+  }
 
   /// Remove or mark dead a statically sized stack object.
   void RemoveStackObject(int ObjectIdx) {
@@ -744,7 +784,13 @@
   /// Notify the MachineFrameInfo object that a variable sized object has been
   /// created.  This must be created whenever a variable sized object is
   /// created, whether or not the index returned is actually used.
-  int CreateVariableSizedObject(unsigned Alignment, const AllocaInst *Alloca);
+  int CreateVariableSizedObject(Align Alignment, const AllocaInst *Alloca);
+  /// FIXME: Remove this function when transition to Align is over.
+  LLVM_ATTRIBUTE_DEPRECATED(int CreateVariableSizedObject(
+                                unsigned Alignment, const AllocaInst *Alloca),
+                            "Use the version that takes an Align instead") {
+    return CreateVariableSizedObject(assumeAligned(Alignment), Alloca);
+  }
 
   /// Returns a reference to call saved info vector for the current function.
   const std::vector<CalleeSavedInfo> &getCalleeSavedInfo() const {
@@ -755,8 +801,8 @@
 
   /// Used by prolog/epilog inserter to set the function's callee saved
   /// information.
-  void setCalleeSavedInfo(const std::vector<CalleeSavedInfo> &CSI) {
-    CSInfo = CSI;
+  void setCalleeSavedInfo(std::vector<CalleeSavedInfo> CSI) {
+    CSInfo = std::move(CSI);
   }
 
   /// Has the callee saved info been calculated yet?
diff --git a/linux-x64/clang/include/llvm/CodeGen/MachineFunction.h b/linux-x64/clang/include/llvm/CodeGen/MachineFunction.h
index 201c126..e9979c7 100644
--- a/linux-x64/clang/include/llvm/CodeGen/MachineFunction.h
+++ b/linux-x64/clang/include/llvm/CodeGen/MachineFunction.h
@@ -21,9 +21,7 @@
 #include "llvm/ADT/BitVector.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/GraphTraits.h"
-#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallVector.h"
-#include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/ilist.h"
 #include "llvm/ADT/iterator.h"
 #include "llvm/Analysis/EHPersonalities.h"
@@ -34,8 +32,8 @@
 #include "llvm/Support/ArrayRecycler.h"
 #include "llvm/Support/AtomicOrdering.h"
 #include "llvm/Support/Compiler.h"
-#include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Recycler.h"
+#include "llvm/Target/TargetOptions.h"
 #include <cassert>
 #include <cstdint>
 #include <memory>
@@ -48,10 +46,12 @@
 class BlockAddress;
 class DataLayout;
 class DebugLoc;
+struct DenormalMode;
 class DIExpression;
 class DILocalVariable;
 class DILocation;
 class Function;
+class GISelChangeObserver;
 class GlobalValue;
 class LLVMTargetMachine;
 class MachineConstantPool;
@@ -63,10 +63,12 @@
 class MCContext;
 class MCInstrDesc;
 class MCSymbol;
+class MCSection;
 class Pass;
 class PseudoSourceValueManager;
 class raw_ostream;
 class SlotIndexes;
+class StringRef;
 class TargetRegisterClass;
 class TargetSubtargetInfo;
 struct WasmEHFuncInfo;
@@ -142,6 +144,8 @@
   //  operands, this also means that all generic virtual registers have been
   //  constrained to virtual registers (assigned to register classes) and that
   //  all sizes attached to them have been eliminated.
+  // TiedOpsRewritten: The twoaddressinstruction pass will set this flag, it
+  //  means that tied-def have been rewritten to meet the RegConstraint.
   enum class Property : unsigned {
     IsSSA,
     NoPHIs,
@@ -151,7 +155,8 @@
     Legalized,
     RegBankSelected,
     Selected,
-    LastProperty = Selected,
+    TiedOpsRewritten,
+    LastProperty = TiedOpsRewritten,
   };
 
   bool hasProperty(Property P) const {
@@ -220,7 +225,7 @@
 };
 
 class MachineFunction {
-  const Function &F;
+  Function &F;
   const LLVMTargetMachine &Target;
   const TargetSubtargetInfo *STI;
   MCContext &Ctx;
@@ -242,6 +247,9 @@
   // Keep track of jump tables for switch instructions
   MachineJumpTableInfo *JumpTableInfo;
 
+  // Keep track of the function section.
+  MCSection *Section = nullptr;
+
   // Keeps track of Wasm exception handling related data. This will be null for
   // functions that aren't using a wasm EH personality.
   WasmEHFuncInfo *WasmEHInfo = nullptr;
@@ -255,6 +263,12 @@
   // numbered and this vector keeps track of the mapping from ID's to MBB's.
   std::vector<MachineBasicBlock*> MBBNumbering;
 
+  // Unary encoding of basic block symbols is used to reduce size of ".strtab".
+  // Basic block number 'i' gets a prefix of length 'i'.  The ith character also
+  // denotes the type of basic block number 'i'.  Return blocks are marked with
+  // 'r', landing pads with 'l' and regular blocks with 'a'.
+  std::vector<char> BBSectionsSymbolPrefix;
+
   // Pool-allocate MachineFunction-lifetime and IR objects.
   BumpPtrAllocator Allocator;
 
@@ -277,7 +291,7 @@
   unsigned FunctionNumber;
 
   /// Alignment - The alignment of the function.
-  unsigned Alignment;
+  Align Alignment;
 
   /// ExposesReturnsTwice - True if the function calls setjmp or related
   /// functions with attribute "returns twice", but doesn't have
@@ -303,6 +317,10 @@
   /// by debug and exception handling consumers.
   std::vector<MCCFIInstruction> FrameInstructions;
 
+  /// List of basic blocks immediately following calls to _setjmp. Used to
+  /// construct a table of valid longjmp targets for Windows Control Flow Guard.
+  std::vector<MCSymbol *> LongjmpTargets;
+
   /// \name Exception Handling
   /// \{
 
@@ -321,15 +339,14 @@
   /// CodeView label annotations.
   std::vector<std::pair<MCSymbol *, MDNode *>> CodeViewAnnotations;
 
-  /// CodeView heapallocsites.
-  std::vector<std::tuple<MCSymbol*, MCSymbol*, DIType*>>
-      CodeViewHeapAllocSites;
-
   bool CallsEHReturn = false;
   bool CallsUnwindInit = false;
   bool HasEHScopes = false;
   bool HasEHFunclets = false;
 
+  /// Section Type for basic blocks, only relevant with basic block sections.
+  BasicBlockSection BBSectionsType = BasicBlockSection::None;
+
   /// List of C++ TypeInfo used.
   std::vector<const GlobalValue *> TypeInfos;
 
@@ -383,9 +400,9 @@
   /// For now we support only cases when argument is transferred through one
   /// register.
   struct ArgRegPair {
-    unsigned Reg;
+    Register Reg;
     uint16_t ArgNo;
-    ArgRegPair(unsigned R, unsigned Arg) : Reg(R), ArgNo(Arg) {
+    ArgRegPair(Register R, unsigned Arg) : Reg(R), ArgNo(Arg) {
       assert(Arg < (1 << 16) && "Arg out of range");
     }
   };
@@ -395,11 +412,16 @@
 
 private:
   Delegate *TheDelegate = nullptr;
+  GISelChangeObserver *Observer = nullptr;
 
   using CallSiteInfoMap = DenseMap<const MachineInstr *, CallSiteInfo>;
   /// Map a call instruction to call site arguments forwarding info.
   CallSiteInfoMap CallSitesInfo;
 
+  /// A helper function that returns call site info for a give call
+  /// instruction if debug entry value support is enabled.
+  CallSiteInfoMap::iterator getCallSiteInfo(const MachineInstr *MI);
+
   // Callbacks for insertion and removal.
   void handleInsertion(MachineInstr &MI);
   void handleRemoval(MachineInstr &MI);
@@ -409,7 +431,40 @@
   using VariableDbgInfoMapTy = SmallVector<VariableDbgInfo, 4>;
   VariableDbgInfoMapTy VariableDbgInfos;
 
-  MachineFunction(const Function &F, const LLVMTargetMachine &Target,
+  /// A count of how many instructions in the function have had numbers
+  /// assigned to them. Used for debug value tracking, to determine the
+  /// next instruction number.
+  unsigned DebugInstrNumberingCount = 0;
+
+  /// Set value of DebugInstrNumberingCount field. Avoid using this unless
+  /// you're deserializing this data.
+  void setDebugInstrNumberingCount(unsigned Num);
+
+  /// Pair of instruction number and operand number.
+  using DebugInstrOperandPair = std::pair<unsigned, unsigned>;
+
+  /// Substitution map: from one <inst,operand> pair to another. Used to
+  /// record changes in where a value is defined, so that debug variable
+  /// locations can find it later.
+  std::map<DebugInstrOperandPair, DebugInstrOperandPair>
+      DebugValueSubstitutions;
+
+  /// Create a substitution between one <instr,operand> value to a different,
+  /// new value.
+  void makeDebugValueSubstitution(DebugInstrOperandPair, DebugInstrOperandPair);
+
+  /// Create substitutions for any tracked values in \p Old, to point at
+  /// \p New. Needed when we re-create an instruction during optimization,
+  /// which has the same signature (i.e., def operands in the same place) but
+  /// a modified instruction type, flags, or otherwise. An example: X86 moves
+  /// are sometimes transformed into equivalent LEAs.
+  /// If the two instructions are not the same opcode, limit which operands to
+  /// examine for substitutions to the first N operands by setting
+  /// \p MaxOperand.
+  void substituteDebugValuesForInst(const MachineInstr &Old, MachineInstr &New,
+                                    unsigned MaxOperand = UINT_MAX);
+
+  MachineFunction(Function &F, const LLVMTargetMachine &Target,
                   const TargetSubtargetInfo &STI, unsigned FunctionNum,
                   MachineModuleInfo &MMI);
   MachineFunction(const MachineFunction &) = delete;
@@ -439,15 +494,28 @@
     TheDelegate = delegate;
   }
 
+  void setObserver(GISelChangeObserver *O) { Observer = O; }
+
+  GISelChangeObserver *getObserver() const { return Observer; }
+
   MachineModuleInfo &getMMI() const { return MMI; }
   MCContext &getContext() const { return Ctx; }
 
+  /// Returns the Section this function belongs to.
+  MCSection *getSection() const { return Section; }
+
+  /// Indicates the Section this function belongs to.
+  void setSection(MCSection *S) { Section = S; }
+
   PseudoSourceValueManager &getPSVManager() const { return *PSVManager; }
 
   /// Return the DataLayout attached to the Module associated to this MF.
   const DataLayout &getDataLayout() const;
 
   /// Return the LLVM function that this machine code represents
+  Function &getFunction() { return F; }
+
+  /// Return the LLVM function that this machine code represents
   const Function &getFunction() const { return F; }
 
   /// getName - Return the name of the corresponding LLVM function.
@@ -456,6 +524,24 @@
   /// getFunctionNumber - Return a unique ID for the current function.
   unsigned getFunctionNumber() const { return FunctionNumber; }
 
+  /// Returns true if this function has basic block sections enabled.
+  bool hasBBSections() const {
+    return (BBSectionsType == BasicBlockSection::All ||
+            BBSectionsType == BasicBlockSection::List ||
+            BBSectionsType == BasicBlockSection::Preset);
+  }
+
+  /// Returns true if basic block labels are to be generated for this function.
+  bool hasBBLabels() const {
+    return BBSectionsType == BasicBlockSection::Labels;
+  }
+
+  void setBBSectionsType(BasicBlockSection V) { BBSectionsType = V; }
+
+  /// Assign IsBeginSection IsEndSection fields for basic blocks in this
+  /// function.
+  void assignBeginEndSections();
+
   /// getTarget - Return the target machine this machine code is compiled with
   const LLVMTargetMachine &getTarget() const { return Target; }
 
@@ -508,15 +594,16 @@
   const WinEHFuncInfo *getWinEHFuncInfo() const { return WinEHInfo; }
   WinEHFuncInfo *getWinEHFuncInfo() { return WinEHInfo; }
 
-  /// getAlignment - Return the alignment (log2, not bytes) of the function.
-  unsigned getAlignment() const { return Alignment; }
+  /// getAlignment - Return the alignment of the function.
+  Align getAlignment() const { return Alignment; }
 
-  /// setAlignment - Set the alignment (log2, not bytes) of the function.
-  void setAlignment(unsigned A) { Alignment = A; }
+  /// setAlignment - Set the alignment of the function.
+  void setAlignment(Align A) { Alignment = A; }
 
-  /// ensureAlignment - Make sure the function is at least 1 << A bytes aligned.
-  void ensureAlignment(unsigned A) {
-    if (Alignment < A) Alignment = A;
+  /// ensureAlignment - Make sure the function is at least A bytes aligned.
+  void ensureAlignment(Align A) {
+    if (Alignment < A)
+      Alignment = A;
   }
 
   /// exposesReturnsTwice - Returns true if the function calls setjmp or
@@ -547,6 +634,9 @@
   }
   void setHasWinCFI(bool v) { HasWinCFI = v; }
 
+  /// True if this function needs frame moves for debug or exceptions.
+  bool needsFrameMoves() const;
+
   /// Get the function properties
   const MachineFunctionProperties &getProperties() const { return Properties; }
   MachineFunctionProperties &getProperties() { return Properties; }
@@ -566,6 +656,10 @@
      return const_cast<MachineFunction*>(this)->getInfo<Ty>();
   }
 
+  /// Returns the denormal handling type for the default rounding mode of the
+  /// function.
+  DenormalMode getDenormalMode(const fltSemantics &FPType) const;
+
   /// getBlockNumbered - MachineBasicBlocks are automatically numbered when they
   /// are inserted into the machine function.  The block number for a machine
   /// basic block can be found by using the MBB::getNumber method, this method
@@ -630,7 +724,7 @@
 
   /// addLiveIn - Add the specified physical register as a live-in value and
   /// create a corresponding virtual register for it.
-  unsigned addLiveIn(unsigned PReg, const TargetRegisterClass *RC);
+  Register addLiveIn(MCRegister PReg, const TargetRegisterClass *RC);
 
   //===--------------------------------------------------------------------===//
   // BasicBlock accessor functions.
@@ -706,7 +800,7 @@
   /// CreateMachineInstr - Allocate a new MachineInstr. Use this instead
   /// of `new MachineInstr'.
   MachineInstr *CreateMachineInstr(const MCInstrDesc &MCID, const DebugLoc &DL,
-                                   bool NoImp = false);
+                                   bool NoImplicit = false);
 
   /// Create a new MachineInstr which is a copy of \p Orig, identical in all
   /// ways except the instruction has no parent, prev, or next. Bundling flags
@@ -740,9 +834,8 @@
   /// explicitly deallocated.
   MachineMemOperand *getMachineMemOperand(
       MachinePointerInfo PtrInfo, MachineMemOperand::Flags f, uint64_t s,
-      unsigned base_alignment, const AAMDNodes &AAInfo = AAMDNodes(),
-      const MDNode *Ranges = nullptr,
-      SyncScope::ID SSID = SyncScope::System,
+      Align base_alignment, const AAMDNodes &AAInfo = AAMDNodes(),
+      const MDNode *Ranges = nullptr, SyncScope::ID SSID = SyncScope::System,
       AtomicOrdering Ordering = AtomicOrdering::NotAtomic,
       AtomicOrdering FailureOrdering = AtomicOrdering::NotAtomic);
 
@@ -753,6 +846,14 @@
   MachineMemOperand *getMachineMemOperand(const MachineMemOperand *MMO,
                                           int64_t Offset, uint64_t Size);
 
+  /// getMachineMemOperand - Allocate a new MachineMemOperand by copying
+  /// an existing one, replacing only the MachinePointerInfo and size.
+  /// MachineMemOperands are owned by the MachineFunction and need not be
+  /// explicitly deallocated.
+  MachineMemOperand *getMachineMemOperand(const MachineMemOperand *MMO,
+                                          MachinePointerInfo &PtrInfo,
+                                          uint64_t Size);
+
   /// Allocate a new MachineMemOperand by copying an existing one,
   /// replacing only AliasAnalysis information. MachineMemOperands are owned
   /// by the MachineFunction and need not be explicitly deallocated.
@@ -783,14 +884,15 @@
   /// Allocate and initialize a register mask with @p NumRegister bits.
   uint32_t *allocateRegMask();
 
+  ArrayRef<int> allocateShuffleMask(ArrayRef<int> Mask);
+
   /// Allocate and construct an extra info structure for a `MachineInstr`.
   ///
   /// This is allocated on the function's allocator and so lives the life of
   /// the function.
-  MachineInstr::ExtraInfo *
-  createMIExtraInfo(ArrayRef<MachineMemOperand *> MMOs,
-                    MCSymbol *PreInstrSymbol = nullptr,
-                    MCSymbol *PostInstrSymbol = nullptr);
+  MachineInstr::ExtraInfo *createMIExtraInfo(
+      ArrayRef<MachineMemOperand *> MMOs, MCSymbol *PreInstrSymbol = nullptr,
+      MCSymbol *PostInstrSymbol = nullptr, MDNode *HeapAllocMarker = nullptr);
 
   /// Allocate a string and populate it with the given external symbol name.
   const char *createExternalSymbolName(StringRef Name);
@@ -817,6 +919,17 @@
 
   LLVM_NODISCARD unsigned addFrameInst(const MCCFIInstruction &Inst);
 
+  /// Returns a reference to a list of symbols immediately following calls to
+  /// _setjmp in the function. Used to construct the longjmp target table used
+  /// by Windows Control Flow Guard.
+  const std::vector<MCSymbol *> &getLongjmpTargets() const {
+    return LongjmpTargets;
+  }
+
+  /// Add the specified symbol to the list of valid longjmp targets for Windows
+  /// Control Flow Guard.
+  void addLongjmpTarget(MCSymbol *Target) { LongjmpTargets.push_back(Target); }
+
   /// \name Exception Handling
   /// \{
 
@@ -934,14 +1047,6 @@
     return CodeViewAnnotations;
   }
 
-  /// Record heapallocsites
-  void addCodeViewHeapAllocSite(MachineInstr *I, MDNode *MD);
-
-  ArrayRef<std::tuple<MCSymbol*, MCSymbol*, DIType*>>
-      getCodeViewHeapAllocSites() const {
-    return CodeViewHeapAllocSites;
-  }
-
   /// Return a reference to the C++ typeinfo for the current function.
   const std::vector<const GlobalValue *> &getTypeInfos() const {
     return TypeInfos;
@@ -966,22 +1071,45 @@
     return VariableDbgInfos;
   }
 
+  /// Start tracking the arguments passed to the call \p CallI.
   void addCallArgsForwardingRegs(const MachineInstr *CallI,
                                  CallSiteInfoImpl &&CallInfo) {
-    assert(CallI->isCall());
-    CallSitesInfo[CallI] = std::move(CallInfo);
+    assert(CallI->isCandidateForCallSiteEntry());
+    bool Inserted =
+        CallSitesInfo.try_emplace(CallI, std::move(CallInfo)).second;
+    (void)Inserted;
+    assert(Inserted && "Call site info not unique");
   }
 
   const CallSiteInfoMap &getCallSitesInfo() const {
     return CallSitesInfo;
   }
 
-  /// Update call sites info by deleting entry for \p Old call instruction.
-  /// If \p New is present then transfer \p Old call info to it. This function
-  /// should be called before removing call instruction or before replacing
-  /// call instruction with new one.
-  void updateCallSiteInfo(const MachineInstr *Old,
-                          const MachineInstr *New = nullptr);
+  /// Following functions update call site info. They should be called before
+  /// removing, replacing or copying call instruction.
+
+  /// Erase the call site info for \p MI. It is used to remove a call
+  /// instruction from the instruction stream.
+  void eraseCallSiteInfo(const MachineInstr *MI);
+  /// Copy the call site info from \p Old to \ New. Its usage is when we are
+  /// making a copy of the instruction that will be inserted at different point
+  /// of the instruction stream.
+  void copyCallSiteInfo(const MachineInstr *Old,
+                        const MachineInstr *New);
+
+  const std::vector<char> &getBBSectionsSymbolPrefix() const {
+    return BBSectionsSymbolPrefix;
+  }
+
+  /// Move the call site info from \p Old to \New call site info. This function
+  /// is used when we are replacing one call instruction with another one to
+  /// the same callee.
+  void moveCallSiteInfo(const MachineInstr *Old,
+                        const MachineInstr *New);
+
+  unsigned getNewDebugInstrNum() {
+    return ++DebugInstrNumberingCount;
+  }
 };
 
 //===--------------------------------------------------------------------===//
@@ -1048,6 +1176,11 @@
   }
 };
 
+class MachineFunctionAnalysisManager;
+void verifyMachineFunction(MachineFunctionAnalysisManager *,
+                           const std::string &Banner,
+                           const MachineFunction &MF);
+
 } // end namespace llvm
 
 #endif // LLVM_CODEGEN_MACHINEFUNCTION_H
diff --git a/linux-x64/clang/include/llvm/CodeGen/MachineInstr.h b/linux-x64/clang/include/llvm/CodeGen/MachineInstr.h
index c82c5b1..6bbe2d0 100644
--- a/linux-x64/clang/include/llvm/CodeGen/MachineInstr.h
+++ b/linux-x64/clang/include/llvm/CodeGen/MachineInstr.h
@@ -20,11 +20,9 @@
 #include "llvm/ADT/ilist.h"
 #include "llvm/ADT/ilist_node.h"
 #include "llvm/ADT/iterator_range.h"
-#include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/CodeGen/MachineMemOperand.h"
 #include "llvm/CodeGen/MachineOperand.h"
 #include "llvm/CodeGen/TargetOpcodes.h"
-#include "llvm/IR/DebugInfoMetadata.h"
 #include "llvm/IR/DebugLoc.h"
 #include "llvm/IR/InlineAsm.h"
 #include "llvm/MC/MCInstrDesc.h"
@@ -38,12 +36,12 @@
 
 namespace llvm {
 
+class AAResults;
 template <typename T> class ArrayRef;
 class DIExpression;
 class DILocalVariable;
 class MachineBasicBlock;
 class MachineFunction;
-class MachineMemOperand;
 class MachineRegisterInfo;
 class ModuleSlotTracker;
 class raw_ostream;
@@ -105,8 +103,11 @@
                                         // no signed wrap.
     IsExact      = 1 << 13,             // Instruction supports division is
                                         // known to be exact.
-    FPExcept     = 1 << 14,             // Instruction may raise floating-point
-                                        // exceptions.
+    NoFPExcept   = 1 << 14,             // Instruction does not raise
+                                        // floatint-point exceptions.
+    NoMerge      = 1 << 15,             // Passes that drop source location info
+                                        // (e.g. branch folding) should skip
+                                        // this instruction.
   };
 
 private:
@@ -116,8 +117,6 @@
   // Operands are allocated by an ArrayRecycler.
   MachineOperand *Operands = nullptr;   // Pointer to the first operand.
   unsigned NumOperands = 0;             // Number of operands on instruction.
-  using OperandCapacity = ArrayRecycler<MachineOperand>::Capacity;
-  OperandCapacity CapOperands;          // Capacity of the Operands array.
 
   uint16_t Flags = 0;                   // Various bits of additional
                                         // information about machine
@@ -130,6 +129,11 @@
                                         // anything other than to convey comment
                                         // information to AsmPrinter.
 
+  // OperandCapacity has uint8_t size, so it should be next to AsmPrinterFlags
+  // to properly pack.
+  using OperandCapacity = ArrayRecycler<MachineOperand>::Capacity;
+  OperandCapacity CapOperands;          // Capacity of the Operands array.
+
   /// Internal implementation detail class that provides out-of-line storage for
   /// extra info used by the machine instruction when this info cannot be stored
   /// in-line within the instruction itself.
@@ -137,19 +141,23 @@
   /// This has to be defined eagerly due to the implementation constraints of
   /// `PointerSumType` where it is used.
   class ExtraInfo final
-      : TrailingObjects<ExtraInfo, MachineMemOperand *, MCSymbol *> {
+      : TrailingObjects<ExtraInfo, MachineMemOperand *, MCSymbol *, MDNode *> {
   public:
     static ExtraInfo *create(BumpPtrAllocator &Allocator,
                              ArrayRef<MachineMemOperand *> MMOs,
                              MCSymbol *PreInstrSymbol = nullptr,
-                             MCSymbol *PostInstrSymbol = nullptr) {
+                             MCSymbol *PostInstrSymbol = nullptr,
+                             MDNode *HeapAllocMarker = nullptr) {
       bool HasPreInstrSymbol = PreInstrSymbol != nullptr;
       bool HasPostInstrSymbol = PostInstrSymbol != nullptr;
+      bool HasHeapAllocMarker = HeapAllocMarker != nullptr;
       auto *Result = new (Allocator.Allocate(
-          totalSizeToAlloc<MachineMemOperand *, MCSymbol *>(
-              MMOs.size(), HasPreInstrSymbol + HasPostInstrSymbol),
+          totalSizeToAlloc<MachineMemOperand *, MCSymbol *, MDNode *>(
+              MMOs.size(), HasPreInstrSymbol + HasPostInstrSymbol,
+              HasHeapAllocMarker),
           alignof(ExtraInfo)))
-          ExtraInfo(MMOs.size(), HasPreInstrSymbol, HasPostInstrSymbol);
+          ExtraInfo(MMOs.size(), HasPreInstrSymbol, HasPostInstrSymbol,
+                    HasHeapAllocMarker);
 
       // Copy the actual data into the trailing objects.
       std::copy(MMOs.begin(), MMOs.end(),
@@ -160,6 +168,8 @@
       if (HasPostInstrSymbol)
         Result->getTrailingObjects<MCSymbol *>()[HasPreInstrSymbol] =
             PostInstrSymbol;
+      if (HasHeapAllocMarker)
+        Result->getTrailingObjects<MDNode *>()[0] = HeapAllocMarker;
 
       return Result;
     }
@@ -178,6 +188,10 @@
                  : nullptr;
     }
 
+    MDNode *getHeapAllocMarker() const {
+      return HasHeapAllocMarker ? getTrailingObjects<MDNode *>()[0] : nullptr;
+    }
+
   private:
     friend TrailingObjects;
 
@@ -189,6 +203,7 @@
     const int NumMMOs;
     const bool HasPreInstrSymbol;
     const bool HasPostInstrSymbol;
+    const bool HasHeapAllocMarker;
 
     // Implement the `TrailingObjects` internal API.
     size_t numTrailingObjects(OverloadToken<MachineMemOperand *>) const {
@@ -197,12 +212,17 @@
     size_t numTrailingObjects(OverloadToken<MCSymbol *>) const {
       return HasPreInstrSymbol + HasPostInstrSymbol;
     }
+    size_t numTrailingObjects(OverloadToken<MDNode *>) const {
+      return HasHeapAllocMarker;
+    }
 
     // Just a boring constructor to allow us to initialize the sizes. Always use
     // the `create` routine above.
-    ExtraInfo(int NumMMOs, bool HasPreInstrSymbol, bool HasPostInstrSymbol)
+    ExtraInfo(int NumMMOs, bool HasPreInstrSymbol, bool HasPostInstrSymbol,
+              bool HasHeapAllocMarker)
         : NumMMOs(NumMMOs), HasPreInstrSymbol(HasPreInstrSymbol),
-          HasPostInstrSymbol(HasPostInstrSymbol) {}
+          HasPostInstrSymbol(HasPostInstrSymbol),
+          HasHeapAllocMarker(HasHeapAllocMarker) {}
   };
 
   /// Enumeration of the kinds of inline extra info available. It is important
@@ -229,6 +249,10 @@
 
   DebugLoc debugLoc;                    // Source line information.
 
+  /// Unique instruction number. Used by DBG_INSTR_REFs to refer to the values
+  /// defined by this instruction.
+  unsigned DebugInstrNum;
+
   // Intrusive list support
   friend struct ilist_traits<MachineInstr>;
   friend struct ilist_callback_traits<MachineBasicBlock>;
@@ -247,6 +271,10 @@
   // MachineInstrs are pool-allocated and owned by MachineFunction.
   friend class MachineFunction;
 
+  void
+  dumprImpl(const MachineRegisterInfo &MRI, unsigned Depth, unsigned MaxDepth,
+            SmallPtrSetImpl<const MachineInstr *> &AlreadySeenInstrs) const;
+
 public:
   MachineInstr(const MachineInstr &) = delete;
   MachineInstr &operator=(const MachineInstr &) = delete;
@@ -256,6 +284,9 @@
   const MachineBasicBlock* getParent() const { return Parent; }
   MachineBasicBlock* getParent() { return Parent; }
 
+  /// Move the instruction before \p MovePos.
+  void moveBefore(MachineInstr *MovePos);
+
   /// Return the function that contains the basic block that this instruction
   /// belongs to.
   ///
@@ -384,10 +415,31 @@
   /// Returns the debug location id of this MachineInstr.
   const DebugLoc &getDebugLoc() const { return debugLoc; }
 
+  /// Return the operand containing the offset to be used if this DBG_VALUE
+  /// instruction is indirect; will be an invalid register if this value is
+  /// not indirect, and an immediate with value 0 otherwise.
+  const MachineOperand &getDebugOffset() const {
+    assert(isDebugValue() && "not a DBG_VALUE");
+    return getOperand(1);
+  }
+  MachineOperand &getDebugOffset() {
+    assert(isDebugValue() && "not a DBG_VALUE");
+    return getOperand(1);
+  }
+
+  /// Return the operand for the debug variable referenced by
+  /// this DBG_VALUE instruction.
+  const MachineOperand &getDebugVariableOp() const;
+  MachineOperand &getDebugVariableOp();
+
   /// Return the debug variable referenced by
   /// this DBG_VALUE instruction.
   const DILocalVariable *getDebugVariable() const;
 
+  /// Return the operand for the complex address expression referenced by
+  /// this DBG_VALUE instruction.
+  MachineOperand &getDebugExpressionOp();
+
   /// Return the complex address expression referenced by
   /// this DBG_VALUE instruction.
   const DIExpression *getDebugExpression() const;
@@ -396,6 +448,18 @@
   /// this DBG_LABEL instruction.
   const DILabel *getDebugLabel() const;
 
+  /// Fetch the instruction number of this MachineInstr. If it does not have
+  /// one already, a new and unique number will be assigned.
+  unsigned getDebugInstrNum();
+
+  /// Examine the instruction number of this MachineInstr. May be zero if
+  /// it hasn't been assigned a number yet.
+  unsigned peekDebugInstrNum() const { return DebugInstrNum; }
+
+  /// Set instruction number of this MachineInstr. Avoid using unless you're
+  /// deserializing this information.
+  void setDebugInstrNum(unsigned Num) { DebugInstrNum = Num; }
+
   /// Emit an error referring to the source location of this instruction.
   /// This should only be used for inline assembly that is somehow
   /// impossible to compile. Other errors should have been handled much
@@ -413,6 +477,11 @@
   /// Retuns the total number of operands.
   unsigned getNumOperands() const { return NumOperands; }
 
+  /// Returns the total number of operands which are debug locations.
+  unsigned getNumDebugOperands() const {
+    return std::distance(debug_operands().begin(), debug_operands().end());
+  }
+
   const MachineOperand& getOperand(unsigned i) const {
     assert(i < getNumOperands() && "getOperand() out of range!");
     return Operands[i];
@@ -422,11 +491,59 @@
     return Operands[i];
   }
 
+  MachineOperand &getDebugOperand(unsigned Index) {
+    assert(Index < getNumDebugOperands() && "getDebugOperand() out of range!");
+    return *(debug_operands().begin() + Index);
+  }
+  const MachineOperand &getDebugOperand(unsigned Index) const {
+    assert(Index < getNumDebugOperands() && "getDebugOperand() out of range!");
+    return *(debug_operands().begin() + Index);
+  }
+
+  /// Returns a pointer to the operand corresponding to a debug use of Reg, or
+  /// nullptr if Reg is not used in any debug operand.
+  const MachineOperand *getDebugOperandForReg(Register Reg) const {
+    const MachineOperand *RegOp =
+        find_if(debug_operands(), [Reg](const MachineOperand &Op) {
+          return Op.isReg() && Op.getReg() == Reg;
+        });
+    return RegOp == adl_end(debug_operands()) ? nullptr : RegOp;
+  }
+  MachineOperand *getDebugOperandForReg(Register Reg) {
+    MachineOperand *RegOp =
+        find_if(debug_operands(), [Reg](const MachineOperand &Op) {
+          return Op.isReg() && Op.getReg() == Reg;
+        });
+    return RegOp == adl_end(debug_operands()) ? nullptr : RegOp;
+  }
+
+  unsigned getDebugOperandIndex(const MachineOperand *Op) const {
+    assert(Op >= adl_begin(debug_operands()) &&
+           Op <= adl_end(debug_operands()) && "Expected a debug operand.");
+    return std::distance(adl_begin(debug_operands()), Op);
+  }
+
   /// Returns the total number of definitions.
   unsigned getNumDefs() const {
     return getNumExplicitDefs() + MCID->getNumImplicitDefs();
   }
 
+  /// Returns true if the instruction has implicit definition.
+  bool hasImplicitDef() const {
+    for (unsigned I = getNumExplicitOperands(), E = getNumOperands();
+      I != E; ++I) {
+      const MachineOperand &MO = getOperand(I);
+      if (MO.isDef() && MO.isImplicit())
+        return true;
+    }
+    return false;
+  }
+
+  /// Returns the implicit operands number.
+  unsigned getNumImplicitOperands() const {
+    return getNumOperands() - getNumExplicitOperands();
+  }
+
   /// Return true if operand \p OpIdx is a subregister index.
   bool isOperandSubregIdx(unsigned OpIdx) const {
     assert(getOperand(OpIdx).getType() == MachineOperand::MO_Immediate &&
@@ -478,6 +595,17 @@
   iterator_range<const_mop_iterator> implicit_operands() const {
     return make_range(explicit_operands().end(), operands_end());
   }
+  /// Returns a range over all operands that are used to determine the variable
+  /// location for this DBG_VALUE instruction.
+  iterator_range<mop_iterator> debug_operands() {
+    assert(isDebugValue() && "Must be a debug value instruction.");
+    return make_range(operands_begin(), operands_begin() + 1);
+  }
+  /// \copydoc debug_operands()
+  iterator_range<const_mop_iterator> debug_operands() const {
+    assert(isDebugValue() && "Must be a debug value instruction.");
+    return make_range(operands_begin(), operands_begin() + 1);
+  }
   /// Returns a range over all explicit operands that are register definitions.
   /// Implicit definition are not included!
   iterator_range<mop_iterator> defs() {
@@ -577,6 +705,16 @@
     return nullptr;
   }
 
+  /// Helper to extract a heap alloc marker if one has been added.
+  MDNode *getHeapAllocMarker() const {
+    if (!Info)
+      return nullptr;
+    if (ExtraInfo *EI = Info.get<EIIK_OutOfLine>())
+      return EI->getHeapAllocMarker();
+
+    return nullptr;
+  }
+
   /// API for querying MachineInstr properties. They are the same as MCInstrDesc
   /// queries but they are bundle aware.
 
@@ -602,6 +740,12 @@
     return hasPropertyInBundle(1ULL << MCFlag, Type);
   }
 
+  /// Return true if this is an instruction that should go through the usual
+  /// legalization steps.
+  bool isPreISelOpcode(QueryType Type = IgnoreBundle) const {
+    return hasProperty(MCID::PreISelOpcode, Type);
+  }
+
   /// Return true if this instruction can have a variable number of operands.
   /// In this case, the variable operands will be after the normal
   /// operands but before the implicit definitions and uses (if any are
@@ -636,6 +780,14 @@
     return hasProperty(MCID::Call, Type);
   }
 
+  /// Return true if this is a call instruction that may have an associated
+  /// call site entry in the debug info.
+  bool isCandidateForCallSiteEntry(QueryType Type = IgnoreBundle) const;
+  /// Return true if copying, moving, or erasing this instruction requires
+  /// updating Call Site Info (see \ref copyCallSiteInfo, \ref moveCallSiteInfo,
+  /// \ref eraseCallSiteInfo).
+  bool shouldUpdateCallSiteInfo() const;
+
   /// Returns true if the specified instruction stops control flow
   /// from executing the instruction immediately following it.  Examples include
   /// unconditional branches and return instructions.
@@ -654,7 +806,7 @@
 
   /// Returns true if this is a conditional, unconditional, or indirect branch.
   /// Predicates below can be used to discriminate between
-  /// these cases, and the TargetInstrInfo::AnalyzeBranch method can be used to
+  /// these cases, and the TargetInstrInfo::analyzeBranch method can be used to
   /// get more information.
   bool isBranch(QueryType Type = AnyInBundle) const {
     return hasProperty(MCID::Branch, Type);
@@ -668,18 +820,18 @@
 
   /// Return true if this is a branch which may fall
   /// through to the next instruction or may transfer control flow to some other
-  /// block.  The TargetInstrInfo::AnalyzeBranch method can be used to get more
+  /// block.  The TargetInstrInfo::analyzeBranch method can be used to get more
   /// information about this branch.
   bool isConditionalBranch(QueryType Type = AnyInBundle) const {
-    return isBranch(Type) & !isBarrier(Type) & !isIndirectBranch(Type);
+    return isBranch(Type) && !isBarrier(Type) && !isIndirectBranch(Type);
   }
 
   /// Return true if this is a branch which always
   /// transfers control flow to some other block.  The
-  /// TargetInstrInfo::AnalyzeBranch method can be used to get more information
+  /// TargetInstrInfo::analyzeBranch method can be used to get more information
   /// about this branch.
   bool isUnconditionalBranch(QueryType Type = AnyInBundle) const {
-    return isBranch(Type) & isBarrier(Type) & !isIndirectBranch(Type);
+    return isBranch(Type) && isBarrier(Type) && !isIndirectBranch(Type);
   }
 
   /// Return true if this instruction has a predicate operand that
@@ -838,10 +990,10 @@
   /// instruction that can in principle raise an exception, as indicated
   /// by the MCID::MayRaiseFPException property, *and* at the same time,
   /// the instruction is used in a context where we expect floating-point
-  /// exceptions might be enabled, as indicated by the FPExcept MI flag.
+  /// exceptions are not disabled, as indicated by the NoFPExcept MI flag.
   bool mayRaiseFPException() const {
     return hasProperty(MCID::MayRaiseFPException) &&
-           getFlag(MachineInstr::MIFlag::FPExcept);
+           !getFlag(MachineInstr::MIFlag::NoFPExcept);
   }
 
   //===--------------------------------------------------------------------===//
@@ -1009,26 +1161,28 @@
 
   bool isDebugValue() const { return getOpcode() == TargetOpcode::DBG_VALUE; }
   bool isDebugLabel() const { return getOpcode() == TargetOpcode::DBG_LABEL; }
-  bool isDebugInstr() const { return isDebugValue() || isDebugLabel(); }
+  bool isDebugRef() const { return getOpcode() == TargetOpcode::DBG_INSTR_REF; }
+  bool isDebugInstr() const {
+    return isDebugValue() || isDebugLabel() || isDebugRef();
+  }
 
-  /// A DBG_VALUE is indirect iff the first operand is a register and
-  /// the second operand is an immediate.
+  bool isDebugOffsetImm() const { return getDebugOffset().isImm(); }
+
+  /// A DBG_VALUE is indirect iff the location operand is a register and
+  /// the offset operand is an immediate.
   bool isIndirectDebugValue() const {
-    return isDebugValue()
-      && getOperand(0).isReg()
-      && getOperand(1).isImm();
+    return isDebugValue() && getDebugOperand(0).isReg() && isDebugOffsetImm();
   }
 
   /// A DBG_VALUE is an entry value iff its debug expression contains the
-  /// DW_OP_entry_value DWARF operation.
-  bool isDebugEntryValue() const {
-    return isDebugValue() && getDebugExpression()->isEntryValue();
-  }
+  /// DW_OP_LLVM_entry_value operation.
+  bool isDebugEntryValue() const;
 
   /// Return true if the instruction is a debug value which describes a part of
   /// a variable as unavailable.
   bool isUndefDebugValue() const {
-    return isDebugValue() && getOperand(0).isReg() && !getOperand(0).getReg();
+    return isDebugValue() && getDebugOperand(0).isReg() &&
+           !getDebugOperand(0).getReg().isValid();
   }
 
   bool isPHI() const {
@@ -1103,9 +1257,11 @@
     case TargetOpcode::EH_LABEL:
     case TargetOpcode::GC_LABEL:
     case TargetOpcode::DBG_VALUE:
+    case TargetOpcode::DBG_INSTR_REF:
     case TargetOpcode::DBG_LABEL:
     case TargetOpcode::LIFETIME_START:
     case TargetOpcode::LIFETIME_END:
+    case TargetOpcode::PSEUDO_PROBE:
       return true;
     }
   }
@@ -1140,7 +1296,7 @@
   /// is a read of a super-register.
   /// This does not count partial redefines of virtual registers as reads:
   ///   %reg1024:6 = OP.
-  bool readsRegister(unsigned Reg,
+  bool readsRegister(Register Reg,
                      const TargetRegisterInfo *TRI = nullptr) const {
     return findRegisterUseOperandIdx(Reg, false, TRI) != -1;
   }
@@ -1148,20 +1304,20 @@
   /// Return true if the MachineInstr reads the specified virtual register.
   /// Take into account that a partial define is a
   /// read-modify-write operation.
-  bool readsVirtualRegister(unsigned Reg) const {
+  bool readsVirtualRegister(Register Reg) const {
     return readsWritesVirtualRegister(Reg).first;
   }
 
   /// Return a pair of bools (reads, writes) indicating if this instruction
   /// reads or writes Reg. This also considers partial defines.
   /// If Ops is not null, all operand indices for Reg are added.
-  std::pair<bool,bool> readsWritesVirtualRegister(unsigned Reg,
+  std::pair<bool,bool> readsWritesVirtualRegister(Register Reg,
                                 SmallVectorImpl<unsigned> *Ops = nullptr) const;
 
   /// Return true if the MachineInstr kills the specified register.
   /// If TargetRegisterInfo is passed, then it also checks if there is
   /// a kill of a super-register.
-  bool killsRegister(unsigned Reg,
+  bool killsRegister(Register Reg,
                      const TargetRegisterInfo *TRI = nullptr) const {
     return findRegisterUseOperandIdx(Reg, true, TRI) != -1;
   }
@@ -1170,7 +1326,7 @@
   /// If TargetRegisterInfo is passed, then it also checks
   /// if there is a def of a super-register.
   /// NOTE: It's ignoring subreg indices on virtual registers.
-  bool definesRegister(unsigned Reg,
+  bool definesRegister(Register Reg,
                        const TargetRegisterInfo *TRI = nullptr) const {
     return findRegisterDefOperandIdx(Reg, false, false, TRI) != -1;
   }
@@ -1178,38 +1334,39 @@
   /// Return true if the MachineInstr modifies (fully define or partially
   /// define) the specified register.
   /// NOTE: It's ignoring subreg indices on virtual registers.
-  bool modifiesRegister(unsigned Reg, const TargetRegisterInfo *TRI) const {
+  bool modifiesRegister(Register Reg,
+                        const TargetRegisterInfo *TRI = nullptr) const {
     return findRegisterDefOperandIdx(Reg, false, true, TRI) != -1;
   }
 
   /// Returns true if the register is dead in this machine instruction.
   /// If TargetRegisterInfo is passed, then it also checks
   /// if there is a dead def of a super-register.
-  bool registerDefIsDead(unsigned Reg,
+  bool registerDefIsDead(Register Reg,
                          const TargetRegisterInfo *TRI = nullptr) const {
     return findRegisterDefOperandIdx(Reg, true, false, TRI) != -1;
   }
 
   /// Returns true if the MachineInstr has an implicit-use operand of exactly
   /// the given register (not considering sub/super-registers).
-  bool hasRegisterImplicitUseOperand(unsigned Reg) const;
+  bool hasRegisterImplicitUseOperand(Register Reg) const;
 
   /// Returns the operand index that is a use of the specific register or -1
   /// if it is not found. It further tightens the search criteria to a use
   /// that kills the register if isKill is true.
-  int findRegisterUseOperandIdx(unsigned Reg, bool isKill = false,
+  int findRegisterUseOperandIdx(Register Reg, bool isKill = false,
                                 const TargetRegisterInfo *TRI = nullptr) const;
 
   /// Wrapper for findRegisterUseOperandIdx, it returns
   /// a pointer to the MachineOperand rather than an index.
-  MachineOperand *findRegisterUseOperand(unsigned Reg, bool isKill = false,
+  MachineOperand *findRegisterUseOperand(Register Reg, bool isKill = false,
                                       const TargetRegisterInfo *TRI = nullptr) {
     int Idx = findRegisterUseOperandIdx(Reg, isKill, TRI);
     return (Idx == -1) ? nullptr : &getOperand(Idx);
   }
 
   const MachineOperand *findRegisterUseOperand(
-    unsigned Reg, bool isKill = false,
+    Register Reg, bool isKill = false,
     const TargetRegisterInfo *TRI = nullptr) const {
     return const_cast<MachineInstr *>(this)->
       findRegisterUseOperand(Reg, isKill, TRI);
@@ -1221,14 +1378,14 @@
   /// overlap the specified register. If TargetRegisterInfo is non-null,
   /// then it also checks if there is a def of a super-register.
   /// This may also return a register mask operand when Overlap is true.
-  int findRegisterDefOperandIdx(unsigned Reg,
+  int findRegisterDefOperandIdx(Register Reg,
                                 bool isDead = false, bool Overlap = false,
                                 const TargetRegisterInfo *TRI = nullptr) const;
 
   /// Wrapper for findRegisterDefOperandIdx, it returns
   /// a pointer to the MachineOperand rather than an index.
   MachineOperand *
-  findRegisterDefOperand(unsigned Reg, bool isDead = false,
+  findRegisterDefOperand(Register Reg, bool isDead = false,
                          bool Overlap = false,
                          const TargetRegisterInfo *TRI = nullptr) {
     int Idx = findRegisterDefOperandIdx(Reg, isDead, Overlap, TRI);
@@ -1236,7 +1393,7 @@
   }
 
   const MachineOperand *
-  findRegisterDefOperand(unsigned Reg, bool isDead = false,
+  findRegisterDefOperand(Register Reg, bool isDead = false,
                          bool Overlap = false,
                          const TargetRegisterInfo *TRI = nullptr) const {
     return const_cast<MachineInstr *>(this)->findRegisterDefOperand(
@@ -1283,7 +1440,7 @@
   ///
   /// \pre CurRC must not be NULL.
   const TargetRegisterClass *getRegClassConstraintEffectForVReg(
-      unsigned Reg, const TargetRegisterClass *CurRC,
+      Register Reg, const TargetRegisterClass *CurRC,
       const TargetInstrInfo *TII, const TargetRegisterInfo *TRI,
       bool ExploreBundle = false) const;
 
@@ -1346,39 +1503,39 @@
 
   /// Replace all occurrences of FromReg with ToReg:SubIdx,
   /// properly composing subreg indices where necessary.
-  void substituteRegister(unsigned FromReg, unsigned ToReg, unsigned SubIdx,
+  void substituteRegister(Register FromReg, Register ToReg, unsigned SubIdx,
                           const TargetRegisterInfo &RegInfo);
 
   /// We have determined MI kills a register. Look for the
   /// operand that uses it and mark it as IsKill. If AddIfNotFound is true,
   /// add a implicit operand if it's not found. Returns true if the operand
   /// exists / is added.
-  bool addRegisterKilled(unsigned IncomingReg,
+  bool addRegisterKilled(Register IncomingReg,
                          const TargetRegisterInfo *RegInfo,
                          bool AddIfNotFound = false);
 
   /// Clear all kill flags affecting Reg.  If RegInfo is provided, this includes
   /// all aliasing registers.
-  void clearRegisterKills(unsigned Reg, const TargetRegisterInfo *RegInfo);
+  void clearRegisterKills(Register Reg, const TargetRegisterInfo *RegInfo);
 
   /// We have determined MI defined a register without a use.
   /// Look for the operand that defines it and mark it as IsDead. If
   /// AddIfNotFound is true, add a implicit operand if it's not found. Returns
   /// true if the operand exists / is added.
-  bool addRegisterDead(unsigned Reg, const TargetRegisterInfo *RegInfo,
+  bool addRegisterDead(Register Reg, const TargetRegisterInfo *RegInfo,
                        bool AddIfNotFound = false);
 
   /// Clear all dead flags on operands defining register @p Reg.
-  void clearRegisterDeads(unsigned Reg);
+  void clearRegisterDeads(Register Reg);
 
   /// Mark all subregister defs of register @p Reg with the undef flag.
   /// This function is used when we determined to have a subregister def in an
   /// otherwise undefined super register.
-  void setRegisterDefReadUndef(unsigned Reg, bool IsUndef = true);
+  void setRegisterDefReadUndef(Register Reg, bool IsUndef = true);
 
   /// We have determined MI defines a register. Make sure there is an operand
   /// defining Reg.
-  void addRegisterDefined(unsigned Reg,
+  void addRegisterDefined(Register Reg,
                           const TargetRegisterInfo *RegInfo = nullptr);
 
   /// Mark every physreg used by this instruction as
@@ -1386,13 +1543,13 @@
   ///
   /// On instructions with register mask operands, also add implicit-def
   /// operands for all registers in UsedRegs.
-  void setPhysRegsDeadExcept(ArrayRef<unsigned> UsedRegs,
+  void setPhysRegsDeadExcept(ArrayRef<Register> UsedRegs,
                              const TargetRegisterInfo &TRI);
 
   /// Return true if it is safe to move this instruction. If
   /// SawStore is set to true, it means that there is a store (or call) between
   /// the instruction's location and its intended destination.
-  bool isSafeToMove(AliasAnalysis *AA, bool &SawStore) const;
+  bool isSafeToMove(AAResults *AA, bool &SawStore) const;
 
   /// Returns true if this instruction's memory access aliases the memory
   /// access of Other.
@@ -1404,7 +1561,7 @@
   /// @param AA Optional alias analysis, used to compare memory operands.
   /// @param Other MachineInstr to check aliasing against.
   /// @param UseTBAA Whether to pass TBAA information to alias analysis.
-  bool mayAlias(AliasAnalysis *AA, const MachineInstr &Other, bool UseTBAA) const;
+  bool mayAlias(AAResults *AA, const MachineInstr &Other, bool UseTBAA) const;
 
   /// Return true if this instruction may have an ordered
   /// or volatile memory reference, or if the information describing the memory
@@ -1419,7 +1576,7 @@
   /// argument area of a function (if it does not change).  If the instruction
   /// does multiple loads, this returns true only if all of the loads are
   /// dereferenceable and invariant.
-  bool isDereferenceableInvariantLoad(AliasAnalysis *AA) const;
+  bool isDereferenceableInvariantLoad(AAResults *AA) const;
 
   /// If the specified instruction is a PHI that always merges together the
   /// same virtual register, return the register, otherwise return 0.
@@ -1485,6 +1642,10 @@
              bool AddNewLine = true,
              const TargetInstrInfo *TII = nullptr) const;
   void dump() const;
+  /// Print on dbgs() the current instruction and the instructions defining its
+  /// operands and so on until we reach \p MaxDepth.
+  void dumpr(const MachineRegisterInfo &MRI,
+             unsigned MaxDepth = UINT_MAX) const;
   /// @}
 
   //===--------------------------------------------------------------------===//
@@ -1578,6 +1739,12 @@
   /// replace ours with it.
   void cloneInstrSymbols(MachineFunction &MF, const MachineInstr &MI);
 
+  /// Set a marker on instructions that denotes where we should create and emit
+  /// heap alloc site labels. This waits until after instruction selection and
+  /// optimizations to create the label, so it should still work if the
+  /// instruction is removed or duplicated.
+  void setHeapAllocMarker(MachineFunction &MF, MDNode *MD);
+
   /// Return the MIFlags which represent both MachineInstrs. This
   /// should be used when merging two MachineInstrs into one. This routine does
   /// not modify the MIFlags of this MachineInstr.
@@ -1600,12 +1767,31 @@
   /// Add all implicit def and use operands to this instruction.
   void addImplicitDefUseOperands(MachineFunction &MF);
 
-  /// Scan instructions following MI and collect any matching DBG_VALUEs.
+  /// Scan instructions immediately following MI and collect any matching
+  /// DBG_VALUEs.
   void collectDebugValues(SmallVectorImpl<MachineInstr *> &DbgValues);
 
-  /// Find all DBG_VALUEs immediately following this instruction that point
-  /// to a register def in this instruction and point them to \p Reg instead.
-  void changeDebugValuesDefReg(unsigned Reg);
+  /// Find all DBG_VALUEs that point to the register def in this instruction
+  /// and point them to \p Reg instead.
+  void changeDebugValuesDefReg(Register Reg);
+
+  /// Returns the Intrinsic::ID for this instruction.
+  /// \pre Must have an intrinsic ID operand.
+  unsigned getIntrinsicID() const {
+    return getOperand(getNumExplicitDefs()).getIntrinsicID();
+  }
+
+  /// Sets all register debug operands in this debug value instruction to be
+  /// undef.
+  void setDebugValueUndef() {
+    assert(isDebugValue() && "Must be a debug value instruction.");
+    for (MachineOperand &MO : debug_operands()) {
+      if (MO.isReg()) {
+        MO.setReg(0);
+        MO.setSubReg(0);
+      }
+    }
+  }
 
 private:
   /// If this instruction is embedded into a MachineFunction, return the
@@ -1630,8 +1816,14 @@
   /// this MI and the given operand index \p OpIdx.
   /// If the related operand does not constrained Reg, this returns CurRC.
   const TargetRegisterClass *getRegClassConstraintEffectForVRegImpl(
-      unsigned OpIdx, unsigned Reg, const TargetRegisterClass *CurRC,
+      unsigned OpIdx, Register Reg, const TargetRegisterClass *CurRC,
       const TargetInstrInfo *TII, const TargetRegisterInfo *TRI) const;
+
+  /// Stores extra instruction information inline or allocates as ExtraInfo
+  /// based on the number of pointers.
+  void setExtraInfo(MachineFunction &MF, ArrayRef<MachineMemOperand *> MMOs,
+                    MCSymbol *PreInstrSymbol, MCSymbol *PostInstrSymbol,
+                    MDNode *HeapAllocMarker);
 };
 
 /// Special DenseMapInfo traits to compare MachineInstr* by *value* of the
diff --git a/linux-x64/clang/include/llvm/CodeGen/MachineInstrBuilder.h b/linux-x64/clang/include/llvm/CodeGen/MachineInstrBuilder.h
index 6d7fb72..115c501 100644
--- a/linux-x64/clang/include/llvm/CodeGen/MachineInstrBuilder.h
+++ b/linux-x64/clang/include/llvm/CodeGen/MachineInstrBuilder.h
@@ -40,20 +40,30 @@
 
 namespace RegState {
 
-  enum {
-    Define         = 0x2,
-    Implicit       = 0x4,
-    Kill           = 0x8,
-    Dead           = 0x10,
-    Undef          = 0x20,
-    EarlyClobber   = 0x40,
-    Debug          = 0x80,
-    InternalRead   = 0x100,
-    Renamable      = 0x200,
-    DefineNoRead   = Define | Undef,
-    ImplicitDefine = Implicit | Define,
-    ImplicitKill   = Implicit | Kill
-  };
+enum {
+  /// Register definition.
+  Define = 0x2,
+  /// Not emitted register (e.g. carry, or temporary result).
+  Implicit = 0x4,
+  /// The last use of a register.
+  Kill = 0x8,
+  /// Unused definition.
+  Dead = 0x10,
+  /// Value of the register doesn't matter.
+  Undef = 0x20,
+  /// Register definition happens before uses.
+  EarlyClobber = 0x40,
+  /// Register 'use' is for debugging purpose.
+  Debug = 0x80,
+  /// Register reads a value that is defined inside the same instruction or
+  /// bundle.
+  InternalRead = 0x100,
+  /// Register that may be renamed.
+  Renamable = 0x200,
+  DefineNoRead = Define | Undef,
+  ImplicitDefine = Implicit | Define,
+  ImplicitKill = Implicit | Kill
+};
 
 } // end namespace RegState
 
@@ -85,7 +95,7 @@
   Register getReg(unsigned Idx) const { return MI->getOperand(Idx).getReg(); }
 
   /// Add a new virtual register operand.
-  const MachineInstrBuilder &addReg(unsigned RegNo, unsigned flags = 0,
+  const MachineInstrBuilder &addReg(Register RegNo, unsigned flags = 0,
                                     unsigned SubReg = 0) const {
     assert((flags & 0x1) == 0 &&
            "Passing in 'true' to addReg is forbidden! Use enums instead.");
@@ -104,14 +114,14 @@
   }
 
   /// Add a virtual register definition operand.
-  const MachineInstrBuilder &addDef(unsigned RegNo, unsigned Flags = 0,
+  const MachineInstrBuilder &addDef(Register RegNo, unsigned Flags = 0,
                                     unsigned SubReg = 0) const {
     return addReg(RegNo, Flags | RegState::Define, SubReg);
   }
 
   /// Add a virtual register use operand. It is an error for Flags to contain
   /// `RegState::Define` when calling this function.
-  const MachineInstrBuilder &addUse(unsigned RegNo, unsigned Flags = 0,
+  const MachineInstrBuilder &addUse(Register RegNo, unsigned Flags = 0,
                                     unsigned SubReg = 0) const {
     assert(!(Flags & RegState::Define) &&
            "Misleading addUse defines register, use addReg instead.");
@@ -135,7 +145,7 @@
   }
 
   const MachineInstrBuilder &addMBB(MachineBasicBlock *MBB,
-                                    unsigned char TargetFlags = 0) const {
+                                    unsigned TargetFlags = 0) const {
     MI->addOperand(*MF, MachineOperand::CreateMBB(MBB, TargetFlags));
     return *this;
   }
@@ -145,42 +155,42 @@
     return *this;
   }
 
-  const MachineInstrBuilder &addConstantPoolIndex(unsigned Idx,
-                                                  int Offset = 0,
-                                          unsigned char TargetFlags = 0) const {
+  const MachineInstrBuilder &
+  addConstantPoolIndex(unsigned Idx, int Offset = 0,
+                       unsigned TargetFlags = 0) const {
     MI->addOperand(*MF, MachineOperand::CreateCPI(Idx, Offset, TargetFlags));
     return *this;
   }
 
   const MachineInstrBuilder &addTargetIndex(unsigned Idx, int64_t Offset = 0,
-                                          unsigned char TargetFlags = 0) const {
+                                          unsigned TargetFlags = 0) const {
     MI->addOperand(*MF, MachineOperand::CreateTargetIndex(Idx, Offset,
                                                           TargetFlags));
     return *this;
   }
 
   const MachineInstrBuilder &addJumpTableIndex(unsigned Idx,
-                                          unsigned char TargetFlags = 0) const {
+                                               unsigned TargetFlags = 0) const {
     MI->addOperand(*MF, MachineOperand::CreateJTI(Idx, TargetFlags));
     return *this;
   }
 
   const MachineInstrBuilder &addGlobalAddress(const GlobalValue *GV,
                                               int64_t Offset = 0,
-                                          unsigned char TargetFlags = 0) const {
+                                              unsigned TargetFlags = 0) const {
     MI->addOperand(*MF, MachineOperand::CreateGA(GV, Offset, TargetFlags));
     return *this;
   }
 
   const MachineInstrBuilder &addExternalSymbol(const char *FnName,
-                                          unsigned char TargetFlags = 0) const {
+                                               unsigned TargetFlags = 0) const {
     MI->addOperand(*MF, MachineOperand::CreateES(FnName, TargetFlags));
     return *this;
   }
 
   const MachineInstrBuilder &addBlockAddress(const BlockAddress *BA,
                                              int64_t Offset = 0,
-                                          unsigned char TargetFlags = 0) const {
+                                             unsigned TargetFlags = 0) const {
     MI->addOperand(*MF, MachineOperand::CreateBA(BA, Offset, TargetFlags));
     return *this;
   }
@@ -250,6 +260,11 @@
     return *this;
   }
 
+  const MachineInstrBuilder &addShuffleMask(ArrayRef<int> Val) const {
+    MI->addOperand(*MF, MachineOperand::CreateShuffleMask(Val));
+    return *this;
+  }
+
   const MachineInstrBuilder &addSym(MCSymbol *Sym,
                                     unsigned char TargetFlags = 0) const {
     MI->addOperand(*MF, MachineOperand::CreateMCSymbol(Sym, TargetFlags));
@@ -290,6 +305,9 @@
       case MachineOperand::MO_BlockAddress:
         return addBlockAddress(Disp.getBlockAddress(), Disp.getOffset() + off,
                                TargetFlags);
+      case MachineOperand::MO_JumpTableIndex:
+        assert(off == 0 && "cannot create offset into jump tables");
+        return addJumpTableIndex(Disp.getIndex(), TargetFlags);
     }
   }
 
@@ -316,7 +334,7 @@
 /// This version of the builder sets up the first operand as a
 /// destination virtual register.
 inline MachineInstrBuilder BuildMI(MachineFunction &MF, const DebugLoc &DL,
-                                   const MCInstrDesc &MCID, unsigned DestReg) {
+                                   const MCInstrDesc &MCID, Register DestReg) {
   return MachineInstrBuilder(MF, MF.CreateMachineInstr(MCID, DL))
            .addReg(DestReg, RegState::Define);
 }
@@ -327,7 +345,7 @@
 inline MachineInstrBuilder BuildMI(MachineBasicBlock &BB,
                                    MachineBasicBlock::iterator I,
                                    const DebugLoc &DL, const MCInstrDesc &MCID,
-                                   unsigned DestReg) {
+                                   Register DestReg) {
   MachineFunction &MF = *BB.getParent();
   MachineInstr *MI = MF.CreateMachineInstr(MCID, DL);
   BB.insert(I, MI);
@@ -343,7 +361,7 @@
 inline MachineInstrBuilder BuildMI(MachineBasicBlock &BB,
                                    MachineBasicBlock::instr_iterator I,
                                    const DebugLoc &DL, const MCInstrDesc &MCID,
-                                   unsigned DestReg) {
+                                   Register DestReg) {
   MachineFunction &MF = *BB.getParent();
   MachineInstr *MI = MF.CreateMachineInstr(MCID, DL);
   BB.insert(I, MI);
@@ -352,7 +370,7 @@
 
 inline MachineInstrBuilder BuildMI(MachineBasicBlock &BB, MachineInstr &I,
                                    const DebugLoc &DL, const MCInstrDesc &MCID,
-                                   unsigned DestReg) {
+                                   Register DestReg) {
   // Calling the overload for instr_iterator is always correct.  However, the
   // definition is not available in headers, so inline the check.
   if (I.isInsideBundle())
@@ -362,7 +380,7 @@
 
 inline MachineInstrBuilder BuildMI(MachineBasicBlock &BB, MachineInstr *I,
                                    const DebugLoc &DL, const MCInstrDesc &MCID,
-                                   unsigned DestReg) {
+                                   Register DestReg) {
   return BuildMI(BB, *I, DL, MCID, DestReg);
 }
 
@@ -416,7 +434,7 @@
 /// end of the given MachineBasicBlock, and sets up the first operand as a
 /// destination virtual register.
 inline MachineInstrBuilder BuildMI(MachineBasicBlock *BB, const DebugLoc &DL,
-                                   const MCInstrDesc &MCID, unsigned DestReg) {
+                                   const MCInstrDesc &MCID, Register DestReg) {
   return BuildMI(*BB, BB->end(), DL, MCID, DestReg);
 }
 
@@ -426,7 +444,7 @@
 /// second operand is an immediate.
 MachineInstrBuilder BuildMI(MachineFunction &MF, const DebugLoc &DL,
                             const MCInstrDesc &MCID, bool IsIndirect,
-                            unsigned Reg, const MDNode *Variable,
+                            Register Reg, const MDNode *Variable,
                             const MDNode *Expr);
 
 /// This version of the builder builds a DBG_VALUE intrinsic
@@ -442,7 +460,7 @@
 MachineInstrBuilder BuildMI(MachineBasicBlock &BB,
                             MachineBasicBlock::iterator I, const DebugLoc &DL,
                             const MCInstrDesc &MCID, bool IsIndirect,
-                            unsigned Reg, const MDNode *Variable,
+                            Register Reg, const MDNode *Variable,
                             const MDNode *Expr);
 
 /// This version of the builder builds a DBG_VALUE intrinsic
@@ -490,16 +508,13 @@
 /// Get all register state flags from machine operand \p RegOp.
 inline unsigned getRegState(const MachineOperand &RegOp) {
   assert(RegOp.isReg() && "Not a register operand");
-  return getDefRegState(RegOp.isDef())                    |
-         getImplRegState(RegOp.isImplicit())              |
-         getKillRegState(RegOp.isKill())                  |
-         getDeadRegState(RegOp.isDead())                  |
-         getUndefRegState(RegOp.isUndef())                |
-         getInternalReadRegState(RegOp.isInternalRead())  |
-         getDebugRegState(RegOp.isDebug())                |
-         getRenamableRegState(
-             TargetRegisterInfo::isPhysicalRegister(RegOp.getReg()) &&
-             RegOp.isRenamable());
+  return getDefRegState(RegOp.isDef()) | getImplRegState(RegOp.isImplicit()) |
+         getKillRegState(RegOp.isKill()) | getDeadRegState(RegOp.isDead()) |
+         getUndefRegState(RegOp.isUndef()) |
+         getInternalReadRegState(RegOp.isInternalRead()) |
+         getDebugRegState(RegOp.isDebug()) |
+         getRenamableRegState(Register::isPhysicalRegister(RegOp.getReg()) &&
+                              RegOp.isRenamable());
 }
 
 /// Helper class for constructing bundles of MachineInstrs.
diff --git a/linux-x64/clang/include/llvm/CodeGen/MachineInstrBundle.h b/linux-x64/clang/include/llvm/CodeGen/MachineInstrBundle.h
index 1810d23..8a73f9a 100644
--- a/linux-x64/clang/include/llvm/CodeGen/MachineInstrBundle.h
+++ b/linux-x64/clang/include/llvm/CodeGen/MachineInstrBundle.h
@@ -75,12 +75,12 @@
 }
 
 //===----------------------------------------------------------------------===//
-// MachineOperand iterator
+// MachineBundleOperand iterator
 //
 
-/// MachineOperandIteratorBase - Iterator that can visit all operands on a
-/// MachineInstr, or all operands on a bundle of MachineInstrs.  This class is
-/// not intended to be used directly, use one of the sub-classes instead.
+/// MIBundleOperandIteratorBase - Iterator that visits all operands in a bundle
+/// of MachineInstrs. This class is not intended to be used directly, use one
+/// of the sub-classes instead.
 ///
 /// Intended use:
 ///
@@ -90,7 +90,10 @@
 ///     ...
 ///   }
 ///
-class MachineOperandIteratorBase {
+template <typename ValueT>
+class MIBundleOperandIteratorBase
+    : public iterator_facade_base<MIBundleOperandIteratorBase<ValueT>,
+                                  std::forward_iterator_tag, ValueT> {
   MachineBasicBlock::instr_iterator InstrI, InstrE;
   MachineInstr::mop_iterator OpI, OpE;
 
@@ -99,35 +102,34 @@
   void advance() {
     while (OpI == OpE) {
       // Don't advance off the basic block, or into a new bundle.
-      if (++InstrI == InstrE || !InstrI->isInsideBundle())
+      if (++InstrI == InstrE || !InstrI->isInsideBundle()) {
+        InstrI = InstrE;
         break;
+      }
       OpI = InstrI->operands_begin();
       OpE = InstrI->operands_end();
     }
   }
 
 protected:
-  /// MachineOperandIteratorBase - Create an iterator that visits all operands
+  /// MIBundleOperandIteratorBase - Create an iterator that visits all operands
   /// on MI, or all operands on every instruction in the bundle containing MI.
   ///
   /// @param MI The instruction to examine.
-  /// @param WholeBundle When true, visit all operands on the entire bundle.
   ///
-  explicit MachineOperandIteratorBase(MachineInstr &MI, bool WholeBundle) {
-    if (WholeBundle) {
-      InstrI = getBundleStart(MI.getIterator());
-      InstrE = MI.getParent()->instr_end();
-    } else {
-      InstrI = InstrE = MI.getIterator();
-      ++InstrE;
-    }
+  explicit MIBundleOperandIteratorBase(MachineInstr &MI) {
+    InstrI = getBundleStart(MI.getIterator());
+    InstrE = MI.getParent()->instr_end();
     OpI = InstrI->operands_begin();
     OpE = InstrI->operands_end();
-    if (WholeBundle)
-      advance();
+    advance();
   }
 
-  MachineOperand &deref() const { return *OpI; }
+  /// Constructor for an iterator past the last iteration: both instruction
+  /// iterators point to the end of the BB and OpI == OpE.
+  explicit MIBundleOperandIteratorBase(MachineBasicBlock::instr_iterator InstrE,
+                                       MachineInstr::mop_iterator OpE)
+      : InstrI(InstrE), InstrE(InstrE), OpI(OpE), OpE(OpE) {}
 
 public:
   /// isValid - Returns true until all the operands have been visited.
@@ -140,123 +142,148 @@
     advance();
   }
 
+  ValueT &operator*() const { return *OpI; }
+  ValueT *operator->() const { return &*OpI; }
+
+  bool operator==(const MIBundleOperandIteratorBase &Arg) const {
+    // Iterators are equal, if InstrI matches and either OpIs match or OpI ==
+    // OpE match for both. The second condition allows us to construct an 'end'
+    // iterator, without finding the last instruction in a bundle up-front.
+    return InstrI == Arg.InstrI &&
+           (OpI == Arg.OpI || (OpI == OpE && Arg.OpI == Arg.OpE));
+  }
   /// getOperandNo - Returns the number of the current operand relative to its
   /// instruction.
   ///
   unsigned getOperandNo() const {
     return OpI - InstrI->operands_begin();
   }
-
-  /// VirtRegInfo - Information about a virtual register used by a set of operands.
-  ///
-  struct VirtRegInfo {
-    /// Reads - One of the operands read the virtual register.  This does not
-    /// include undef or internal use operands, see MO::readsReg().
-    bool Reads;
-
-    /// Writes - One of the operands writes the virtual register.
-    bool Writes;
-
-    /// Tied - Uses and defs must use the same register. This can be because of
-    /// a two-address constraint, or there may be a partial redefinition of a
-    /// sub-register.
-    bool Tied;
-  };
-
-  /// Information about how a physical register Reg is used by a set of
-  /// operands.
-  struct PhysRegInfo {
-    /// There is a regmask operand indicating Reg is clobbered.
-    /// \see MachineOperand::CreateRegMask().
-    bool Clobbered;
-
-    /// Reg or one of its aliases is defined. The definition may only cover
-    /// parts of the register.
-    bool Defined;
-    /// Reg or a super-register is defined. The definition covers the full
-    /// register.
-    bool FullyDefined;
-
-    /// Reg or one of its aliases is read. The register may only be read
-    /// partially.
-    bool Read;
-    /// Reg or a super-register is read. The full register is read.
-    bool FullyRead;
-
-    /// Either:
-    /// - Reg is FullyDefined and all defs of reg or an overlapping
-    ///   register are dead, or
-    /// - Reg is completely dead because "defined" by a clobber.
-    bool DeadDef;
-
-    /// Reg is Defined and all defs of reg or an overlapping register are
-    /// dead.
-    bool PartialDeadDef;
-
-    /// There is a use operand of reg or a super-register with kill flag set.
-    bool Killed;
-  };
-
-  /// analyzeVirtReg - Analyze how the current instruction or bundle uses a
-  /// virtual register.  This function should not be called after operator++(),
-  /// it expects a fresh iterator.
-  ///
-  /// @param Reg The virtual register to analyze.
-  /// @param Ops When set, this vector will receive an (MI, OpNum) entry for
-  ///            each operand referring to Reg.
-  /// @returns A filled-in RegInfo struct.
-  VirtRegInfo analyzeVirtReg(unsigned Reg,
-           SmallVectorImpl<std::pair<MachineInstr*, unsigned> > *Ops = nullptr);
-
-  /// analyzePhysReg - Analyze how the current instruction or bundle uses a
-  /// physical register.  This function should not be called after operator++(),
-  /// it expects a fresh iterator.
-  ///
-  /// @param Reg The physical register to analyze.
-  /// @returns A filled-in PhysRegInfo struct.
-  PhysRegInfo analyzePhysReg(unsigned Reg, const TargetRegisterInfo *TRI);
-};
-
-/// MIOperands - Iterate over operands of a single instruction.
-///
-class MIOperands : public MachineOperandIteratorBase {
-public:
-  MIOperands(MachineInstr &MI) : MachineOperandIteratorBase(MI, false) {}
-  MachineOperand &operator* () const { return deref(); }
-  MachineOperand *operator->() const { return &deref(); }
-};
-
-/// ConstMIOperands - Iterate over operands of a single const instruction.
-///
-class ConstMIOperands : public MachineOperandIteratorBase {
-public:
-  ConstMIOperands(const MachineInstr &MI)
-      : MachineOperandIteratorBase(const_cast<MachineInstr &>(MI), false) {}
-  const MachineOperand &operator* () const { return deref(); }
-  const MachineOperand *operator->() const { return &deref(); }
 };
 
 /// MIBundleOperands - Iterate over all operands in a bundle of machine
 /// instructions.
 ///
-class MIBundleOperands : public MachineOperandIteratorBase {
+class MIBundleOperands : public MIBundleOperandIteratorBase<MachineOperand> {
+  /// Constructor for an iterator past the last iteration.
+  MIBundleOperands(MachineBasicBlock::instr_iterator InstrE,
+                   MachineInstr::mop_iterator OpE)
+      : MIBundleOperandIteratorBase(InstrE, OpE) {}
+
 public:
-  MIBundleOperands(MachineInstr &MI) : MachineOperandIteratorBase(MI, true) {}
-  MachineOperand &operator* () const { return deref(); }
-  MachineOperand *operator->() const { return &deref(); }
+  MIBundleOperands(MachineInstr &MI) : MIBundleOperandIteratorBase(MI) {}
+
+  /// Returns an iterator past the last iteration.
+  static MIBundleOperands end(const MachineBasicBlock &MBB) {
+    return {const_cast<MachineBasicBlock &>(MBB).instr_end(),
+            const_cast<MachineBasicBlock &>(MBB).instr_begin()->operands_end()};
+  }
 };
 
 /// ConstMIBundleOperands - Iterate over all operands in a const bundle of
 /// machine instructions.
 ///
-class ConstMIBundleOperands : public MachineOperandIteratorBase {
+class ConstMIBundleOperands
+    : public MIBundleOperandIteratorBase<const MachineOperand> {
+
+  /// Constructor for an iterator past the last iteration.
+  ConstMIBundleOperands(MachineBasicBlock::instr_iterator InstrE,
+                        MachineInstr::mop_iterator OpE)
+      : MIBundleOperandIteratorBase(InstrE, OpE) {}
+
 public:
   ConstMIBundleOperands(const MachineInstr &MI)
-      : MachineOperandIteratorBase(const_cast<MachineInstr &>(MI), true) {}
-  const MachineOperand &operator* () const { return deref(); }
-  const MachineOperand *operator->() const { return &deref(); }
+      : MIBundleOperandIteratorBase(const_cast<MachineInstr &>(MI)) {}
+
+  /// Returns an iterator past the last iteration.
+  static ConstMIBundleOperands end(const MachineBasicBlock &MBB) {
+    return {const_cast<MachineBasicBlock &>(MBB).instr_end(),
+            const_cast<MachineBasicBlock &>(MBB).instr_begin()->operands_end()};
+  }
 };
 
+inline iterator_range<ConstMIBundleOperands>
+const_mi_bundle_ops(const MachineInstr &MI) {
+  return make_range(ConstMIBundleOperands(MI),
+                    ConstMIBundleOperands::end(*MI.getParent()));
+}
+
+inline iterator_range<MIBundleOperands> mi_bundle_ops(MachineInstr &MI) {
+  return make_range(MIBundleOperands(MI),
+                    MIBundleOperands::end(*MI.getParent()));
+}
+
+/// VirtRegInfo - Information about a virtual register used by a set of
+/// operands.
+///
+struct VirtRegInfo {
+  /// Reads - One of the operands read the virtual register.  This does not
+  /// include undef or internal use operands, see MO::readsReg().
+  bool Reads;
+
+  /// Writes - One of the operands writes the virtual register.
+  bool Writes;
+
+  /// Tied - Uses and defs must use the same register. This can be because of
+  /// a two-address constraint, or there may be a partial redefinition of a
+  /// sub-register.
+  bool Tied;
+};
+
+/// AnalyzeVirtRegInBundle - Analyze how the current instruction or bundle uses
+/// a virtual register.  This function should not be called after operator++(),
+/// it expects a fresh iterator.
+///
+/// @param Reg The virtual register to analyze.
+/// @param Ops When set, this vector will receive an (MI, OpNum) entry for
+///            each operand referring to Reg.
+/// @returns A filled-in RegInfo struct.
+VirtRegInfo AnalyzeVirtRegInBundle(
+    MachineInstr &MI, Register Reg,
+    SmallVectorImpl<std::pair<MachineInstr *, unsigned>> *Ops = nullptr);
+
+/// Information about how a physical register Reg is used by a set of
+/// operands.
+struct PhysRegInfo {
+  /// There is a regmask operand indicating Reg is clobbered.
+  /// \see MachineOperand::CreateRegMask().
+  bool Clobbered;
+
+  /// Reg or one of its aliases is defined. The definition may only cover
+  /// parts of the register.
+  bool Defined;
+  /// Reg or a super-register is defined. The definition covers the full
+  /// register.
+  bool FullyDefined;
+
+  /// Reg or one of its aliases is read. The register may only be read
+  /// partially.
+  bool Read;
+  /// Reg or a super-register is read. The full register is read.
+  bool FullyRead;
+
+  /// Either:
+  /// - Reg is FullyDefined and all defs of reg or an overlapping
+  ///   register are dead, or
+  /// - Reg is completely dead because "defined" by a clobber.
+  bool DeadDef;
+
+  /// Reg is Defined and all defs of reg or an overlapping register are
+  /// dead.
+  bool PartialDeadDef;
+
+  /// There is a use operand of reg or a super-register with kill flag set.
+  bool Killed;
+};
+
+/// AnalyzePhysRegInBundle - Analyze how the current instruction or bundle uses
+/// a physical register.  This function should not be called after operator++(),
+/// it expects a fresh iterator.
+///
+/// @param Reg The physical register to analyze.
+/// @returns A filled-in PhysRegInfo struct.
+PhysRegInfo AnalyzePhysRegInBundle(const MachineInstr &MI, Register Reg,
+                                   const TargetRegisterInfo *TRI);
+
 } // End llvm namespace
 
 #endif
diff --git a/linux-x64/clang/include/llvm/CodeGen/MachineInstrBundleIterator.h b/linux-x64/clang/include/llvm/CodeGen/MachineInstrBundleIterator.h
index 0f59563..250cb0d 100644
--- a/linux-x64/clang/include/llvm/CodeGen/MachineInstrBundleIterator.h
+++ b/linux-x64/clang/include/llvm/CodeGen/MachineInstrBundleIterator.h
@@ -152,8 +152,8 @@
   template <class OtherTy>
   MachineInstrBundleIterator(
       const MachineInstrBundleIterator<OtherTy, IsReverse> &I,
-      typename std::enable_if<std::is_convertible<OtherTy *, Ty *>::value,
-                              void *>::type = nullptr)
+      std::enable_if_t<std::is_convertible<OtherTy *, Ty *>::value, void *> =
+          nullptr)
       : MII(I.getInstrIterator()) {}
 
   MachineInstrBundleIterator() : MII(nullptr) {}
diff --git a/linux-x64/clang/include/llvm/CodeGen/MachineJumpTableInfo.h b/linux-x64/clang/include/llvm/CodeGen/MachineJumpTableInfo.h
index 1178114..1d082bd 100644
--- a/linux-x64/clang/include/llvm/CodeGen/MachineJumpTableInfo.h
+++ b/linux-x64/clang/include/llvm/CodeGen/MachineJumpTableInfo.h
@@ -106,6 +106,9 @@
     JumpTables[Idx].MBBs.clear();
   }
 
+  /// RemoveMBBFromJumpTables - If MBB is present in any jump tables, remove it.
+  bool RemoveMBBFromJumpTables(MachineBasicBlock *MBB);
+
   /// ReplaceMBBInJumpTables - If Old is the target of any jump tables, update
   /// the jump tables to branch to New instead.
   bool ReplaceMBBInJumpTables(MachineBasicBlock *Old, MachineBasicBlock *New);
diff --git a/linux-x64/clang/include/llvm/CodeGen/MachineLoopInfo.h b/linux-x64/clang/include/llvm/CodeGen/MachineLoopInfo.h
index da6df59..c7491d4 100644
--- a/linux-x64/clang/include/llvm/CodeGen/MachineLoopInfo.h
+++ b/linux-x64/clang/include/llvm/CodeGen/MachineLoopInfo.h
@@ -37,6 +37,7 @@
 
 namespace llvm {
 
+class MachineDominatorTree;
 // Implementation in LoopInfoImpl.h
 class MachineLoop;
 extern template class LoopBase<MachineBasicBlock, MachineLoop>;
@@ -66,6 +67,12 @@
   /// it returns an unknown location.
   DebugLoc getStartLoc() const;
 
+  /// Returns true if the instruction is loop invariant.
+  /// I.e., all virtual register operands are defined outside of the loop,
+  /// physical registers aren't accessed explicitly, and there are no side
+  /// effects that aren't captured by the operands or other flags.
+  bool isLoopInvariant(MachineInstr &I) const;
+
   void dump() const;
 
 private:
@@ -88,8 +95,10 @@
 public:
   static char ID; // Pass identification, replacement for typeid
 
-  MachineLoopInfo() : MachineFunctionPass(ID) {
-    initializeMachineLoopInfoPass(*PassRegistry::getPassRegistry());
+  MachineLoopInfo();
+  explicit MachineLoopInfo(MachineDominatorTree &MDT)
+      : MachineFunctionPass(ID) {
+    calculate(MDT);
   }
   MachineLoopInfo(const MachineLoopInfo &) = delete;
   MachineLoopInfo &operator=(const MachineLoopInfo &) = delete;
@@ -133,6 +142,7 @@
 
   /// Calculate the natural loop information.
   bool runOnMachineFunction(MachineFunction &F) override;
+  void calculate(MachineDominatorTree &MDT);
 
   void releaseMemory() override { LI.releaseMemory(); }
 
diff --git a/linux-x64/clang/include/llvm/CodeGen/MachineLoopUtils.h b/linux-x64/clang/include/llvm/CodeGen/MachineLoopUtils.h
new file mode 100644
index 0000000..ec0b352
--- /dev/null
+++ b/linux-x64/clang/include/llvm/CodeGen/MachineLoopUtils.h
@@ -0,0 +1,42 @@
+//=- MachineLoopUtils.h - Helper functions for manipulating loops -*- C++ -*-=//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIB_CODEGEN_MACHINELOOPUTILS_H
+#define LLVM_LIB_CODEGEN_MACHINELOOPUTILS_H
+
+namespace llvm {
+class MachineLoop;
+class MachineBasicBlock;
+class MachineRegisterInfo;
+class TargetInstrInfo;
+
+enum LoopPeelDirection {
+  LPD_Front, ///< Peel the first iteration of the loop.
+  LPD_Back   ///< Peel the last iteration of the loop.
+};
+
+/// Peels a single block loop. Loop must have two successors, one of which
+/// must be itself. Similarly it must have two predecessors, one of which must
+/// be itself.
+///
+/// The loop block is copied and inserted into the CFG such that two copies of
+/// the loop follow on from each other. The copy is inserted either before or
+/// after the loop based on Direction.
+///
+/// Phis are updated and an unconditional branch inserted at the end of the
+/// clone so as to execute a single iteration.
+///
+/// The trip count of Loop is not updated.
+MachineBasicBlock *PeelSingleBlockLoop(LoopPeelDirection Direction,
+                                       MachineBasicBlock *Loop,
+                                       MachineRegisterInfo &MRI,
+                                       const TargetInstrInfo *TII);
+
+} // namespace llvm
+
+#endif // LLVM_LIB_CODEGEN_MACHINELOOPUTILS_H
diff --git a/linux-x64/clang/include/llvm/CodeGen/MachineMemOperand.h b/linux-x64/clang/include/llvm/CodeGen/MachineMemOperand.h
index 65f7063..1befe93 100644
--- a/linux-x64/clang/include/llvm/CodeGen/MachineMemOperand.h
+++ b/linux-x64/clang/include/llvm/CodeGen/MachineMemOperand.h
@@ -18,6 +18,7 @@
 #include "llvm/ADT/BitmaskEnum.h"
 #include "llvm/ADT/PointerUnion.h"
 #include "llvm/CodeGen/PseudoSourceValue.h"
+#include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Value.h" // PointerLikeTypeTraits<Value*>
 #include "llvm/Support/AtomicOrdering.h"
 #include "llvm/Support/DataTypes.h"
@@ -58,8 +59,8 @@
     AddrSpace = v ? v->getAddressSpace() : 0;
   }
 
-  explicit MachinePointerInfo(unsigned AddressSpace = 0)
-      : V((const Value *)nullptr), Offset(0), StackID(0),
+  explicit MachinePointerInfo(unsigned AddressSpace = 0, int64_t offset = 0)
+      : V((const Value *)nullptr), Offset(offset), StackID(0),
         AddrSpace(AddressSpace) {}
 
   explicit MachinePointerInfo(
@@ -77,10 +78,10 @@
 
   MachinePointerInfo getWithOffset(int64_t O) const {
     if (V.isNull())
-      return MachinePointerInfo(AddrSpace);
+      return MachinePointerInfo(AddrSpace, Offset + O);
     if (V.is<const Value*>())
-      return MachinePointerInfo(V.get<const Value*>(), Offset+O, StackID);
-    return MachinePointerInfo(V.get<const PseudoSourceValue*>(), Offset+O,
+      return MachinePointerInfo(V.get<const Value*>(), Offset + O, StackID);
+    return MachinePointerInfo(V.get<const PseudoSourceValue*>(), Offset + O,
                               StackID);
   }
 
@@ -169,7 +170,7 @@
   MachinePointerInfo PtrInfo;
   uint64_t Size;
   Flags FlagVals;
-  uint16_t BaseAlignLog2; // log_2(base_alignment) + 1
+  Align BaseAlign;
   MachineAtomicInfo AtomicInfo;
   AAMDNodes AAInfo;
   const MDNode *Ranges;
@@ -181,8 +182,7 @@
   /// atomic operations the atomic ordering requirements when store does not
   /// occur must also be specified.
   MachineMemOperand(MachinePointerInfo PtrInfo, Flags flags, uint64_t s,
-                    uint64_t a,
-                    const AAMDNodes &AAInfo = AAMDNodes(),
+                    Align a, const AAMDNodes &AAInfo = AAMDNodes(),
                     const MDNode *Ranges = nullptr,
                     SyncScope::ID SSID = SyncScope::System,
                     AtomicOrdering Ordering = AtomicOrdering::NotAtomic,
@@ -223,13 +223,21 @@
   /// Return the size in bits of the memory reference.
   uint64_t getSizeInBits() const { return Size * 8; }
 
+  LLVM_ATTRIBUTE_DEPRECATED(uint64_t getAlignment() const,
+                            "Use getAlign instead");
+
   /// Return the minimum known alignment in bytes of the actual memory
   /// reference.
-  uint64_t getAlignment() const;
+  Align getAlign() const;
+
+  LLVM_ATTRIBUTE_DEPRECATED(uint64_t getBaseAlignment() const,
+                            "Use getBaseAlign instead") {
+    return BaseAlign.value();
+  }
 
   /// Return the minimum known alignment in bytes of the base address, without
   /// the offset.
-  uint64_t getBaseAlignment() const { return (1u << BaseAlignLog2) >> 1; }
+  Align getBaseAlign() const { return BaseAlign; }
 
   /// Return the AA tags for the memory reference.
   AAMDNodes getAAInfo() const { return AAInfo; }
@@ -293,8 +301,6 @@
 
   /// Support for operator<<.
   /// @{
-  void print(raw_ostream &OS) const;
-  void print(raw_ostream &OS, ModuleSlotTracker &MST) const;
   void print(raw_ostream &OS, ModuleSlotTracker &MST,
              SmallVectorImpl<StringRef> &SSNs, const LLVMContext &Context,
              const MachineFrameInfo *MFI, const TargetInstrInfo *TII) const;
@@ -309,7 +315,7 @@
            LHS.getFlags() == RHS.getFlags() &&
            LHS.getAAInfo() == RHS.getAAInfo() &&
            LHS.getRanges() == RHS.getRanges() &&
-           LHS.getAlignment() == RHS.getAlignment() &&
+           LHS.getAlign() == RHS.getAlign() &&
            LHS.getAddrSpace() == RHS.getAddrSpace();
   }
 
@@ -319,11 +325,6 @@
   }
 };
 
-inline raw_ostream &operator<<(raw_ostream &OS, const MachineMemOperand &MRO) {
-  MRO.print(OS);
-  return OS;
-}
-
 } // End llvm namespace
 
 #endif
diff --git a/linux-x64/clang/include/llvm/CodeGen/MachineModuleInfo.h b/linux-x64/clang/include/llvm/CodeGen/MachineModuleInfo.h
index 4ff5c7f..fa900af 100644
--- a/linux-x64/clang/include/llvm/CodeGen/MachineModuleInfo.h
+++ b/linux-x64/clang/include/llvm/CodeGen/MachineModuleInfo.h
@@ -33,6 +33,7 @@
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/PointerIntPair.h"
+#include "llvm/IR/PassManager.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/Pass.h"
@@ -53,8 +54,8 @@
 //===----------------------------------------------------------------------===//
 /// This class can be derived from and used by targets to hold private
 /// target-specific information for each Module.  Objects of type are
-/// accessed/created with MMI::getInfo and destroyed when the MachineModuleInfo
-/// is destroyed.
+/// accessed/created with MachineModuleInfo::getObjFileInfo and destroyed when
+/// the MachineModuleInfo is destroyed.
 ///
 class MachineModuleInfoImpl {
 public:
@@ -74,11 +75,17 @@
 /// made by different debugging and exception handling schemes and reformated
 /// for specific use.
 ///
-class MachineModuleInfo : public ImmutablePass {
+class MachineModuleInfo {
+  friend class MachineModuleInfoWrapperPass;
+  friend class MachineModuleAnalysis;
+
   const LLVMTargetMachine &TM;
 
   /// This is the MCContext used for the entire code generator.
   MCContext Context;
+  // This is an external context, that if assigned, will be used instead of the
+  // internal context.
+  MCContext *ExternalContext = nullptr;
 
   /// This is the LLVM Module being worked on.
   const Module *TheModule;
@@ -140,28 +147,37 @@
   const Function *LastRequest = nullptr; ///< Used for shortcut/cache.
   MachineFunction *LastResult = nullptr; ///< Used for shortcut/cache.
 
+  MachineModuleInfo &operator=(MachineModuleInfo &&MMII) = delete;
+
 public:
-  static char ID; // Pass identification, replacement for typeid
-
   explicit MachineModuleInfo(const LLVMTargetMachine *TM = nullptr);
-  ~MachineModuleInfo() override;
 
-  // Initialization and Finalization
-  bool doInitialization(Module &) override;
-  bool doFinalization(Module &) override;
+  explicit MachineModuleInfo(const LLVMTargetMachine *TM,
+                             MCContext *ExtContext);
+
+  MachineModuleInfo(MachineModuleInfo &&MMII);
+
+  ~MachineModuleInfo();
+
+  void initialize();
+  void finalize();
 
   const LLVMTargetMachine &getTarget() const { return TM; }
 
-  const MCContext &getContext() const { return Context; }
-  MCContext &getContext() { return Context; }
+  const MCContext &getContext() const {
+    return ExternalContext ? *ExternalContext : Context;
+  }
+  MCContext &getContext() {
+    return ExternalContext ? *ExternalContext : Context;
+  }
 
   const Module *getModule() const { return TheModule; }
 
   /// Returns the MachineFunction constructed for the IR function \p F.
   /// Creates a new MachineFunction if none exists yet.
-  MachineFunction &getOrCreateMachineFunction(const Function &F);
+  MachineFunction &getOrCreateMachineFunction(Function &F);
 
-  /// \bried Returns the MachineFunction associated to IR function \p F if there
+  /// \brief Returns the MachineFunction associated to IR function \p F if there
   /// is one, otherwise nullptr.
   MachineFunction *getMachineFunction(const Function &F) const;
 
@@ -227,13 +243,6 @@
   /// to emit them as well, return the whole set.
   ArrayRef<MCSymbol *> getAddrLabelSymbolToEmit(const BasicBlock *BB);
 
-  /// If the specified function has had any references to address-taken blocks
-  /// generated, but the block got deleted, return the symbol now so we can
-  /// emit it.  This prevents emitting a reference to a symbol that has no
-  /// definition.
-  void takeDeletedSymbolsForFunction(const Function *F,
-                                     std::vector<MCSymbol*> &Result);
-
   /// \name Exception Handling
   /// \{
 
@@ -252,8 +261,49 @@
     return Personalities;
   }
   /// \}
+
+  // MMI owes MCContext. It should never be invalidated.
+  bool invalidate(Module &, const PreservedAnalyses &,
+                  ModuleAnalysisManager::Invalidator &) {
+    return false;
+  }
 }; // End class MachineModuleInfo
 
+class MachineModuleInfoWrapperPass : public ImmutablePass {
+  MachineModuleInfo MMI;
+
+public:
+  static char ID; // Pass identification, replacement for typeid
+  explicit MachineModuleInfoWrapperPass(const LLVMTargetMachine *TM = nullptr);
+
+  explicit MachineModuleInfoWrapperPass(const LLVMTargetMachine *TM,
+                                        MCContext *ExtContext);
+
+  // Initialization and Finalization
+  bool doInitialization(Module &) override;
+  bool doFinalization(Module &) override;
+
+  MachineModuleInfo &getMMI() { return MMI; }
+  const MachineModuleInfo &getMMI() const { return MMI; }
+};
+
+/// An analysis that produces \c MachineInfo for a module.
+class MachineModuleAnalysis : public AnalysisInfoMixin<MachineModuleAnalysis> {
+  friend AnalysisInfoMixin<MachineModuleAnalysis>;
+  static AnalysisKey Key;
+
+  const LLVMTargetMachine *TM;
+
+public:
+  /// Provide the result type for this analysis pass.
+  using Result = MachineModuleInfo;
+
+  MachineModuleAnalysis(const LLVMTargetMachine *TM) : TM(TM) {}
+
+  /// Run the analysis pass and produce machine module information.
+  MachineModuleInfo run(Module &M, ModuleAnalysisManager &);
+};
+
 } // end namespace llvm
 
 #endif // LLVM_CODEGEN_MACHINEMODULEINFO_H
diff --git a/linux-x64/clang/include/llvm/CodeGen/MachineOperand.h b/linux-x64/clang/include/llvm/CodeGen/MachineOperand.h
index 2152c75..b7e89cf 100644
--- a/linux-x64/clang/include/llvm/CodeGen/MachineOperand.h
+++ b/linux-x64/clang/include/llvm/CodeGen/MachineOperand.h
@@ -23,6 +23,7 @@
 namespace llvm {
 
 class BlockAddress;
+class Constant;
 class ConstantFP;
 class ConstantInt;
 class GlobalValue;
@@ -68,7 +69,8 @@
     MO_CFIIndex,          ///< MCCFIInstruction index.
     MO_IntrinsicID,       ///< Intrinsic ID for ISel
     MO_Predicate,         ///< Generic predicate for ISel
-    MO_Last = MO_Predicate,
+    MO_ShuffleMask,       ///< Other IR Constant for ISel (shuffle masks)
+    MO_Last = MO_ShuffleMask
   };
 
 private:
@@ -161,7 +163,8 @@
   MachineInstr *ParentMI;
 
   /// Contents union - This contains the payload for the various operand types.
-  union {
+  union ContentsUnion {
+    ContentsUnion() {}
     MachineBasicBlock *MBB;  // For MO_MachineBasicBlock.
     const ConstantFP *CFP;   // For MO_FPImmediate.
     const ConstantInt *CI;   // For MO_CImmediate. Integers > 64bit.
@@ -172,6 +175,7 @@
     unsigned CFIIndex;       // For MO_CFI.
     Intrinsic::ID IntrinsicID; // For MO_IntrinsicID.
     unsigned Pred;           // For MO_Predicate
+    ArrayRef<int> ShuffleMask; // For MO_ShuffleMask
 
     struct {                  // For MO_Register.
       // Register number is in SmallContents.RegNo.
@@ -275,6 +279,9 @@
   /// More complex way of printing a MachineOperand.
   /// \param TypeToPrint specifies the generic type to be printed on uses and
   /// defs. It can be determined using MachineInstr::getTypeToPrint.
+  /// \param OpIdx - specifies the index of the operand in machine instruction.
+  /// This will be used by target dependent MIR formatter. Could be None if the
+  /// index is unknown, e.g. called by dump().
   /// \param PrintDef - whether we want to print `def` on an operand which
   /// isDef. Sometimes, if the operand is printed before '=', we don't print
   /// `def`.
@@ -291,8 +298,9 @@
   /// information from it's parent.
   /// \param IntrinsicInfo - same as \p TRI.
   void print(raw_ostream &os, ModuleSlotTracker &MST, LLT TypeToPrint,
-             bool PrintDef, bool IsStandalone, bool ShouldPrintRegisterTies,
-             unsigned TiedOperandIdx, const TargetRegisterInfo *TRI,
+             Optional<unsigned> OpIdx, bool PrintDef, bool IsStandalone,
+             bool ShouldPrintRegisterTies, unsigned TiedOperandIdx,
+             const TargetRegisterInfo *TRI,
              const TargetIntrinsicInfo *IntrinsicInfo) const;
 
   /// Same as print(os, TRI, IntrinsicInfo), but allows to specify the low-level
@@ -341,6 +349,7 @@
   bool isCFIIndex() const { return OpKind == MO_CFIIndex; }
   bool isIntrinsicID() const { return OpKind == MO_IntrinsicID; }
   bool isPredicate() const { return OpKind == MO_Predicate; }
+  bool isShuffleMask() const { return OpKind == MO_ShuffleMask; }
   //===--------------------------------------------------------------------===//
   // Accessors for Register Operands
   //===--------------------------------------------------------------------===//
@@ -455,7 +464,7 @@
 
   /// Change the register this operand corresponds to.
   ///
-  void setReg(unsigned Reg);
+  void setReg(Register Reg);
 
   void setSubReg(unsigned subReg) {
     assert(isReg() && "Wrong MachineOperand mutator");
@@ -468,13 +477,13 @@
   /// using TargetRegisterInfo to compose the subreg indices if necessary.
   /// Reg must be a virtual register, SubIdx can be 0.
   ///
-  void substVirtReg(unsigned Reg, unsigned SubIdx, const TargetRegisterInfo&);
+  void substVirtReg(Register Reg, unsigned SubIdx, const TargetRegisterInfo&);
 
   /// substPhysReg - Substitute the current register with the physical register
   /// Reg, taking any existing SubReg into account. For instance,
   /// substPhysReg(%eax) will change %reg1024:sub_8bit to %al.
   ///
-  void substPhysReg(unsigned Reg, const TargetRegisterInfo&);
+  void substPhysReg(MCRegister Reg, const TargetRegisterInfo&);
 
   void setIsUse(bool Val = true) { setIsDef(!Val); }
 
@@ -579,6 +588,11 @@
     return Contents.Pred;
   }
 
+  ArrayRef<int> getShuffleMask() const {
+    assert(isShuffleMask() && "Wrong MachineOperand accessor");
+    return Contents.ShuffleMask;
+  }
+
   /// Return the offset from the symbol in this operand. This always returns 0
   /// for ExternalSymbol operands.
   int64_t getOffset() const {
@@ -598,14 +612,14 @@
   /// It is sometimes necessary to detach the register mask pointer from its
   /// machine operand. This static method can be used for such detached bit
   /// mask pointers.
-  static bool clobbersPhysReg(const uint32_t *RegMask, unsigned PhysReg) {
+  static bool clobbersPhysReg(const uint32_t *RegMask, MCRegister PhysReg) {
     // See TargetRegisterInfo.h.
     assert(PhysReg < (1u << 30) && "Not a physical register");
     return !(RegMask[PhysReg / 32] & (1u << PhysReg % 32));
   }
 
   /// clobbersPhysReg - Returns true if this RegMask operand clobbers PhysReg.
-  bool clobbersPhysReg(unsigned PhysReg) const {
+  bool clobbersPhysReg(MCRegister PhysReg) const {
      return clobbersPhysReg(getRegMask(), PhysReg);
   }
 
@@ -684,6 +698,11 @@
     Contents.RegMask = RegMaskPtr;
   }
 
+  void setIntrinsicID(Intrinsic::ID IID) {
+    assert(isIntrinsicID() && "Wrong MachineOperand mutator");
+    Contents.IntrinsicID = IID;
+  }
+
   void setPredicate(unsigned Predicate) {
     assert(isPredicate() && "Wrong MachineOperand mutator");
     Contents.Pred = Predicate;
@@ -709,37 +728,42 @@
   /// ChangeToImmediate - Replace this operand with a new immediate operand of
   /// the specified value.  If an operand is known to be an immediate already,
   /// the setImm method should be used.
-  void ChangeToImmediate(int64_t ImmVal);
+  void ChangeToImmediate(int64_t ImmVal, unsigned TargetFlags = 0);
 
   /// ChangeToFPImmediate - Replace this operand with a new FP immediate operand
   /// of the specified value.  If an operand is known to be an FP immediate
   /// already, the setFPImm method should be used.
-  void ChangeToFPImmediate(const ConstantFP *FPImm);
+  void ChangeToFPImmediate(const ConstantFP *FPImm, unsigned TargetFlags = 0);
 
   /// ChangeToES - Replace this operand with a new external symbol operand.
-  void ChangeToES(const char *SymName, unsigned char TargetFlags = 0);
+  void ChangeToES(const char *SymName, unsigned TargetFlags = 0);
 
   /// ChangeToGA - Replace this operand with a new global address operand.
   void ChangeToGA(const GlobalValue *GV, int64_t Offset,
-                  unsigned char TargetFlags = 0);
+                  unsigned TargetFlags = 0);
 
   /// ChangeToMCSymbol - Replace this operand with a new MC symbol operand.
-  void ChangeToMCSymbol(MCSymbol *Sym);
+  void ChangeToMCSymbol(MCSymbol *Sym, unsigned TargetFlags = 0);
 
   /// Replace this operand with a frame index.
-  void ChangeToFrameIndex(int Idx);
+  void ChangeToFrameIndex(int Idx, unsigned TargetFlags = 0);
 
   /// Replace this operand with a target index.
   void ChangeToTargetIndex(unsigned Idx, int64_t Offset,
-                           unsigned char TargetFlags = 0);
+                           unsigned TargetFlags = 0);
 
   /// ChangeToRegister - Replace this operand with a new register operand of
   /// the specified value.  If an operand is known to be an register already,
   /// the setReg method should be used.
-  void ChangeToRegister(unsigned Reg, bool isDef, bool isImp = false,
+  void ChangeToRegister(Register Reg, bool isDef, bool isImp = false,
                         bool isKill = false, bool isDead = false,
                         bool isUndef = false, bool isDebug = false);
 
+  /// getTargetIndexName - If this MachineOperand is a TargetIndex that has a
+  /// name, attempt to get the name. Returns nullptr if the TargetIndex does not
+  /// have a name. Asserts if MO is not a TargetIndex.
+  const char *getTargetIndexName() const;
+
   //===--------------------------------------------------------------------===//
   // Construction methods.
   //===--------------------------------------------------------------------===//
@@ -762,7 +786,7 @@
     return Op;
   }
 
-  static MachineOperand CreateReg(unsigned Reg, bool isDef, bool isImp = false,
+  static MachineOperand CreateReg(Register Reg, bool isDef, bool isImp = false,
                                   bool isKill = false, bool isDead = false,
                                   bool isUndef = false,
                                   bool isEarlyClobber = false,
@@ -788,7 +812,7 @@
     return Op;
   }
   static MachineOperand CreateMBB(MachineBasicBlock *MBB,
-                                  unsigned char TargetFlags = 0) {
+                                  unsigned TargetFlags = 0) {
     MachineOperand Op(MachineOperand::MO_MachineBasicBlock);
     Op.setMBB(MBB);
     Op.setTargetFlags(TargetFlags);
@@ -800,7 +824,7 @@
     return Op;
   }
   static MachineOperand CreateCPI(unsigned Idx, int Offset,
-                                  unsigned char TargetFlags = 0) {
+                                  unsigned TargetFlags = 0) {
     MachineOperand Op(MachineOperand::MO_ConstantPoolIndex);
     Op.setIndex(Idx);
     Op.setOffset(Offset);
@@ -808,21 +832,21 @@
     return Op;
   }
   static MachineOperand CreateTargetIndex(unsigned Idx, int64_t Offset,
-                                          unsigned char TargetFlags = 0) {
+                                          unsigned TargetFlags = 0) {
     MachineOperand Op(MachineOperand::MO_TargetIndex);
     Op.setIndex(Idx);
     Op.setOffset(Offset);
     Op.setTargetFlags(TargetFlags);
     return Op;
   }
-  static MachineOperand CreateJTI(unsigned Idx, unsigned char TargetFlags = 0) {
+  static MachineOperand CreateJTI(unsigned Idx, unsigned TargetFlags = 0) {
     MachineOperand Op(MachineOperand::MO_JumpTableIndex);
     Op.setIndex(Idx);
     Op.setTargetFlags(TargetFlags);
     return Op;
   }
   static MachineOperand CreateGA(const GlobalValue *GV, int64_t Offset,
-                                 unsigned char TargetFlags = 0) {
+                                 unsigned TargetFlags = 0) {
     MachineOperand Op(MachineOperand::MO_GlobalAddress);
     Op.Contents.OffsetedInfo.Val.GV = GV;
     Op.setOffset(Offset);
@@ -830,7 +854,7 @@
     return Op;
   }
   static MachineOperand CreateES(const char *SymName,
-                                 unsigned char TargetFlags = 0) {
+                                 unsigned TargetFlags = 0) {
     MachineOperand Op(MachineOperand::MO_ExternalSymbol);
     Op.Contents.OffsetedInfo.Val.SymbolName = SymName;
     Op.setOffset(0); // Offset is always 0.
@@ -838,7 +862,7 @@
     return Op;
   }
   static MachineOperand CreateBA(const BlockAddress *BA, int64_t Offset,
-                                 unsigned char TargetFlags = 0) {
+                                 unsigned TargetFlags = 0) {
     MachineOperand Op(MachineOperand::MO_BlockAddress);
     Op.Contents.OffsetedInfo.Val.BA = BA;
     Op.setOffset(Offset);
@@ -876,7 +900,7 @@
   }
 
   static MachineOperand CreateMCSymbol(MCSymbol *Sym,
-                                       unsigned char TargetFlags = 0) {
+                                       unsigned TargetFlags = 0) {
     MachineOperand Op(MachineOperand::MO_MCSymbol);
     Op.Contents.Sym = Sym;
     Op.setOffset(0);
@@ -902,6 +926,12 @@
     return Op;
   }
 
+  static MachineOperand CreateShuffleMask(ArrayRef<int> Mask) {
+    MachineOperand Op(MachineOperand::MO_ShuffleMask);
+    Op.Contents.ShuffleMask = Mask;
+    return Op;
+  }
+
   friend class MachineInstr;
   friend class MachineRegisterInfo;
 
diff --git a/linux-x64/clang/include/llvm/CodeGen/MachineOptimizationRemarkEmitter.h b/linux-x64/clang/include/llvm/CodeGen/MachineOptimizationRemarkEmitter.h
index a461a29..8cc5909 100644
--- a/linux-x64/clang/include/llvm/CodeGen/MachineOptimizationRemarkEmitter.h
+++ b/linux-x64/clang/include/llvm/CodeGen/MachineOptimizationRemarkEmitter.h
@@ -159,7 +159,7 @@
   /// that non-trivial false positives can be quickly detected by the user.
   bool allowExtraAnalysis(StringRef PassName) const {
     return (
-        MF.getFunction().getContext().getRemarkStreamer() ||
+        MF.getFunction().getContext().getLLVMRemarkStreamer() ||
         MF.getFunction().getContext().getDiagHandlerPtr()->isAnyRemarkEnabled(
             PassName));
   }
@@ -172,7 +172,7 @@
     // remarks enabled. We can't currently check whether remarks are requested
     // for the calling pass since that requires actually building the remark.
 
-    if (MF.getFunction().getContext().getRemarkStreamer() ||
+    if (MF.getFunction().getContext().getLLVMRemarkStreamer() ||
         MF.getFunction()
             .getContext()
             .getDiagHandlerPtr()
@@ -182,6 +182,10 @@
     }
   }
 
+  MachineBlockFrequencyInfo *getBFI() {
+    return MBFI;
+  }
+
 private:
   MachineFunction &MF;
 
diff --git a/linux-x64/clang/include/llvm/CodeGen/MachineOutliner.h b/linux-x64/clang/include/llvm/CodeGen/MachineOutliner.h
index 377df4e..a5dbbdb 100644
--- a/linux-x64/clang/include/llvm/CodeGen/MachineOutliner.h
+++ b/linux-x64/clang/include/llvm/CodeGen/MachineOutliner.h
@@ -15,10 +15,11 @@
 #ifndef LLVM_MACHINEOUTLINER_H
 #define LLVM_MACHINEOUTLINER_H
 
+#include "llvm/CodeGen/LivePhysRegs.h"
 #include "llvm/CodeGen/LiveRegUnits.h"
 #include "llvm/CodeGen/MachineFunction.h"
+#include "llvm/CodeGen/MachineRegisterInfo.h"
 #include "llvm/CodeGen/TargetRegisterInfo.h"
-#include "llvm/CodeGen/LivePhysRegs.h"
 
 namespace llvm {
 namespace outliner {
@@ -37,10 +38,10 @@
 struct Candidate {
 private:
   /// The start index of this \p Candidate in the instruction list.
-  unsigned StartIdx;
+  unsigned StartIdx = 0;
 
   /// The number of instructions in this \p Candidate.
-  unsigned Len;
+  unsigned Len = 0;
 
   // The first instruction in this \p Candidate.
   MachineBasicBlock::iterator FirstInst;
@@ -49,20 +50,20 @@
   MachineBasicBlock::iterator LastInst;
 
   // The basic block that contains this Candidate.
-  MachineBasicBlock *MBB;
+  MachineBasicBlock *MBB = nullptr;
 
   /// Cost of calling an outlined function from this point as defined by the
   /// target.
-  unsigned CallOverhead;
+  unsigned CallOverhead = 0;
 
 public:
   /// The index of this \p Candidate's \p OutlinedFunction in the list of
   /// \p OutlinedFunctions.
-  unsigned FunctionIdx;
+  unsigned FunctionIdx = 0;
 
   /// Identifier denoting the instructions to emit to call an outlined function
   /// from this point. Defined by the target.
-  unsigned CallConstructionID;
+  unsigned CallConstructionID = 0;
 
   /// Contains physical register liveness information for the MBB containing
   /// this \p Candidate.
@@ -171,13 +172,13 @@
 
   /// Represents the size of a sequence in bytes. (Some instructions vary
   /// widely in size, so just counting the instructions isn't very useful.)
-  unsigned SequenceSize;
+  unsigned SequenceSize = 0;
 
   /// Target-defined overhead of constructing a frame for this function.
-  unsigned FrameOverhead;
+  unsigned FrameOverhead = 0;
 
   /// Target-defined identifier for constructing a frame for this function.
-  unsigned FrameConstructionID;
+  unsigned FrameConstructionID = 0;
 
   /// Return the number of candidates for this \p OutlinedFunction.
   unsigned getOccurrenceCount() const { return Candidates.size(); }
diff --git a/linux-x64/clang/include/llvm/CodeGen/MachinePassManager.h b/linux-x64/clang/include/llvm/CodeGen/MachinePassManager.h
new file mode 100644
index 0000000..1489177
--- /dev/null
+++ b/linux-x64/clang/include/llvm/CodeGen/MachinePassManager.h
@@ -0,0 +1,256 @@
+//===- PassManager.h --- Pass management for CodeGen ------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This header defines the pass manager interface for codegen. The codegen
+// pipeline consists of only machine function passes. There is no container
+// relationship between IR module/function and machine function in terms of pass
+// manager organization. So there is no need for adaptor classes (for example
+// ModuleToMachineFunctionAdaptor). Since invalidation could only happen among
+// machine function passes, there is no proxy classes to handle cross-IR-unit
+// invalidation. IR analysis results are provided for machine function passes by
+// their respective analysis managers such as ModuleAnalysisManager and
+// FunctionAnalysisManager.
+//
+// TODO: Add MachineFunctionProperties support.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CODEGEN_MACHINEPASSMANAGER_H
+#define LLVM_CODEGEN_MACHINEPASSMANAGER_H
+
+#include "llvm/ADT/FunctionExtras.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/CodeGen/MachineFunction.h"
+#include "llvm/IR/PassManager.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/type_traits.h"
+
+namespace llvm {
+class Module;
+
+extern template class AnalysisManager<MachineFunction>;
+
+/// An AnalysisManager<MachineFunction> that also exposes IR analysis results.
+class MachineFunctionAnalysisManager : public AnalysisManager<MachineFunction> {
+public:
+  using Base = AnalysisManager<MachineFunction>;
+
+  MachineFunctionAnalysisManager() : Base(false), FAM(nullptr), MAM(nullptr) {}
+  MachineFunctionAnalysisManager(FunctionAnalysisManager &FAM,
+                                 ModuleAnalysisManager &MAM,
+                                 bool DebugLogging = false)
+      : Base(DebugLogging), FAM(&FAM), MAM(&MAM) {}
+  MachineFunctionAnalysisManager(MachineFunctionAnalysisManager &&) = default;
+  MachineFunctionAnalysisManager &
+  operator=(MachineFunctionAnalysisManager &&) = default;
+
+  /// Get the result of an analysis pass for a Function.
+  ///
+  /// Runs the analysis if a cached result is not available.
+  template <typename PassT> typename PassT::Result &getResult(Function &F) {
+    return FAM->getResult<PassT>(F);
+  }
+
+  /// Get the cached result of an analysis pass for a Function.
+  ///
+  /// This method never runs the analysis.
+  ///
+  /// \returns null if there is no cached result.
+  template <typename PassT>
+  typename PassT::Result *getCachedResult(Function &F) {
+    return FAM->getCachedResult<PassT>(F);
+  }
+
+  /// Get the result of an analysis pass for a Module.
+  ///
+  /// Runs the analysis if a cached result is not available.
+  template <typename PassT> typename PassT::Result &getResult(Module &M) {
+    return MAM->getResult<PassT>(M);
+  }
+
+  /// Get the cached result of an analysis pass for a Module.
+  ///
+  /// This method never runs the analysis.
+  ///
+  /// \returns null if there is no cached result.
+  template <typename PassT> typename PassT::Result *getCachedResult(Module &M) {
+    return MAM->getCachedResult<PassT>(M);
+  }
+
+  /// Get the result of an analysis pass for a MachineFunction.
+  ///
+  /// Runs the analysis if a cached result is not available.
+  using Base::getResult;
+
+  /// Get the cached result of an analysis pass for a MachineFunction.
+  ///
+  /// This method never runs the analysis.
+  ///
+  /// returns null if there is no cached result.
+  using Base::getCachedResult;
+
+  // FIXME: Add LoopAnalysisManager or CGSCCAnalysisManager if needed.
+  FunctionAnalysisManager *FAM;
+  ModuleAnalysisManager *MAM;
+};
+
+extern template class PassManager<MachineFunction>;
+
+/// MachineFunctionPassManager adds/removes below features to/from the base
+/// PassManager template instantiation.
+///
+/// - Support passes that implement doInitialization/doFinalization. This is for
+///   machine function passes to work on module level constructs. One such pass
+///   is AsmPrinter.
+///
+/// - Support machine module pass which runs over the module (for example,
+///   MachineOutliner). A machine module pass needs to define the method:
+///
+///   ```Error run(Module &, MachineFunctionAnalysisManager &)```
+///
+///   FIXME: machine module passes still need to define the usual machine
+///          function pass interface, namely,
+///          `PreservedAnalyses run(MachineFunction &,
+///                                 MachineFunctionAnalysisManager &)`
+///          But this interface wouldn't be executed. It is just a placeholder
+///          to satisfy the pass manager type-erased inteface. This
+///          special-casing of machine module pass is due to its limited use
+///          cases and the unnecessary complexity it may bring to the machine
+///          pass manager.
+///
+/// - The base class `run` method is replaced by an alternative `run` method.
+///   See details below.
+///
+/// - Support codegening in the SCC order. Users include interprocedural
+///   register allocation (IPRA).
+class MachineFunctionPassManager
+    : public PassManager<MachineFunction, MachineFunctionAnalysisManager> {
+  using Base = PassManager<MachineFunction, MachineFunctionAnalysisManager>;
+
+public:
+  MachineFunctionPassManager(bool DebugLogging = false,
+                             bool RequireCodeGenSCCOrder = false,
+                             bool VerifyMachineFunction = false)
+      : Base(DebugLogging), RequireCodeGenSCCOrder(RequireCodeGenSCCOrder),
+        VerifyMachineFunction(VerifyMachineFunction) {}
+  MachineFunctionPassManager(MachineFunctionPassManager &&) = default;
+  MachineFunctionPassManager &
+  operator=(MachineFunctionPassManager &&) = default;
+
+  /// Run machine passes for a Module.
+  ///
+  /// The intended use is to start the codegen pipeline for a Module. The base
+  /// class's `run` method is deliberately hidden by this due to the observation
+  /// that we don't yet have the use cases of compositing two instances of
+  /// machine pass managers, or compositing machine pass managers with other
+  /// types of pass managers.
+  Error run(Module &M, MachineFunctionAnalysisManager &MFAM);
+
+  template <typename PassT> void addPass(PassT &&Pass) {
+    Base::addPass(std::forward<PassT>(Pass));
+    PassConceptT *P = Passes.back().get();
+    addDoInitialization<PassT>(P);
+    addDoFinalization<PassT>(P);
+
+    // Add machine module pass.
+    addRunOnModule<PassT>(P);
+  }
+
+private:
+  template <typename PassT>
+  using has_init_t = decltype(std::declval<PassT &>().doInitialization(
+      std::declval<Module &>(),
+      std::declval<MachineFunctionAnalysisManager &>()));
+
+  template <typename PassT>
+  std::enable_if_t<!is_detected<has_init_t, PassT>::value>
+  addDoInitialization(PassConceptT *Pass) {}
+
+  template <typename PassT>
+  std::enable_if_t<is_detected<has_init_t, PassT>::value>
+  addDoInitialization(PassConceptT *Pass) {
+    using PassModelT =
+        detail::PassModel<MachineFunction, PassT, PreservedAnalyses,
+                          MachineFunctionAnalysisManager>;
+    auto *P = static_cast<PassModelT *>(Pass);
+    InitializationFuncs.emplace_back(
+        [=](Module &M, MachineFunctionAnalysisManager &MFAM) {
+          return P->Pass.doInitialization(M, MFAM);
+        });
+  }
+
+  template <typename PassT>
+  using has_fini_t = decltype(std::declval<PassT &>().doFinalization(
+      std::declval<Module &>(),
+      std::declval<MachineFunctionAnalysisManager &>()));
+
+  template <typename PassT>
+  std::enable_if_t<!is_detected<has_fini_t, PassT>::value>
+  addDoFinalization(PassConceptT *Pass) {}
+
+  template <typename PassT>
+  std::enable_if_t<is_detected<has_fini_t, PassT>::value>
+  addDoFinalization(PassConceptT *Pass) {
+    using PassModelT =
+        detail::PassModel<MachineFunction, PassT, PreservedAnalyses,
+                          MachineFunctionAnalysisManager>;
+    auto *P = static_cast<PassModelT *>(Pass);
+    FinalizationFuncs.emplace_back(
+        [=](Module &M, MachineFunctionAnalysisManager &MFAM) {
+          return P->Pass.doFinalization(M, MFAM);
+        });
+  }
+
+  template <typename PassT>
+  using is_machine_module_pass_t = decltype(std::declval<PassT &>().run(
+      std::declval<Module &>(),
+      std::declval<MachineFunctionAnalysisManager &>()));
+
+  template <typename PassT>
+  using is_machine_function_pass_t = decltype(std::declval<PassT &>().run(
+      std::declval<MachineFunction &>(),
+      std::declval<MachineFunctionAnalysisManager &>()));
+
+  template <typename PassT>
+  std::enable_if_t<!is_detected<is_machine_module_pass_t, PassT>::value>
+  addRunOnModule(PassConceptT *Pass) {}
+
+  template <typename PassT>
+  std::enable_if_t<is_detected<is_machine_module_pass_t, PassT>::value>
+  addRunOnModule(PassConceptT *Pass) {
+    static_assert(is_detected<is_machine_function_pass_t, PassT>::value,
+                  "machine module pass needs to define machine function pass "
+                  "api. sorry.");
+
+    using PassModelT =
+        detail::PassModel<MachineFunction, PassT, PreservedAnalyses,
+                          MachineFunctionAnalysisManager>;
+    auto *P = static_cast<PassModelT *>(Pass);
+    MachineModulePasses.emplace(
+        Passes.size() - 1,
+        [=](Module &M, MachineFunctionAnalysisManager &MFAM) {
+          return P->Pass.run(M, MFAM);
+        });
+  }
+
+  using FuncTy = Error(Module &, MachineFunctionAnalysisManager &);
+  SmallVector<llvm::unique_function<FuncTy>, 4> InitializationFuncs;
+  SmallVector<llvm::unique_function<FuncTy>, 4> FinalizationFuncs;
+
+  using PassIndex = decltype(Passes)::size_type;
+  std::map<PassIndex, llvm::unique_function<FuncTy>> MachineModulePasses;
+
+  // Run codegen in the SCC order.
+  bool RequireCodeGenSCCOrder;
+
+  bool VerifyMachineFunction;
+};
+
+} // end namespace llvm
+
+#endif // LLVM_CODEGEN_MACHINEPASSMANAGER_H
diff --git a/linux-x64/clang/include/llvm/CodeGen/MachinePassRegistry.def b/linux-x64/clang/include/llvm/CodeGen/MachinePassRegistry.def
new file mode 100644
index 0000000..e9eaa5f
--- /dev/null
+++ b/linux-x64/clang/include/llvm/CodeGen/MachinePassRegistry.def
@@ -0,0 +1,197 @@
+//===- MachinePassRegistry.def - Registry of passes -------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is used as the registry of passes that are for target-independent
+// code generator.
+//
+//===----------------------------------------------------------------------===//
+
+// NOTE: NO INCLUDE GUARD DESIRED!
+
+#ifndef MODULE_ANALYSIS
+#define MODULE_ANALYSIS(NAME, PASS_NAME, CONSTRUCTOR)
+#endif
+MODULE_ANALYSIS("pass-instrumentation", PassInstrumentationAnalysis, (PIC))
+#undef MODULE_ANALYSIS
+
+#ifndef MODULE_PASS
+#define MODULE_PASS(NAME, PASS_NAME, CONSTRUCTOR)
+#endif
+MODULE_PASS("pre-isel-intrinsic-lowering", PreISelIntrinsicLoweringPass, ())
+#undef MODULE_PASS
+
+#ifndef FUNCTION_ANALYSIS
+#define FUNCTION_ANALYSIS(NAME, PASS_NAME, CONSTRUCTOR)
+#endif
+FUNCTION_ANALYSIS("pass-instrumentation", PassInstrumentationAnalysis, (PIC))
+FUNCTION_ANALYSIS("targetir", TargetIRAnalysis, (std::move(TM.getTargetIRAnalysis())))
+#undef FUNCTION_ANALYSIS
+
+#ifndef FUNCTION_PASS
+#define FUNCTION_PASS(NAME, PASS_NAME, CONSTRUCTOR)
+#endif
+FUNCTION_PASS("mergeicmps", MergeICmpsPass, ())
+FUNCTION_PASS("lower-constant-intrinsics", LowerConstantIntrinsicsPass, ())
+FUNCTION_PASS("unreachableblockelim", UnreachableBlockElimPass, ())
+FUNCTION_PASS("consthoist", ConstantHoistingPass, ())
+FUNCTION_PASS("partially-inline-libcalls", PartiallyInlineLibCallsPass, ())
+FUNCTION_PASS("ee-instrument", EntryExitInstrumenterPass, (false))
+FUNCTION_PASS("post-inline-ee-instrument", EntryExitInstrumenterPass, (true))
+FUNCTION_PASS("expand-reductions", ExpandReductionsPass, ())
+FUNCTION_PASS("lowerinvoke", LowerInvokePass, ())
+FUNCTION_PASS("scalarize-masked-mem-intrin", ScalarizeMaskedMemIntrinPass, ())
+FUNCTION_PASS("verify", VerifierPass, ())
+#undef FUNCTION_PASS
+
+#ifndef LOOP_PASS
+#define LOOP_PASS(NAME, PASS_NAME, CONSTRUCTOR)
+#endif
+LOOP_PASS("loop-reduce", LoopStrengthReducePass, ())
+#undef LOOP_PASS
+
+#ifndef MACHINE_MODULE_PASS
+#define MACHINE_MODULE_PASS(NAME, PASS_NAME, CONSTRUCTOR)
+#endif
+#undef MACHINE_MODULE_PASS
+
+#ifndef MACHINE_FUNCTION_ANALYSIS
+#define MACHINE_FUNCTION_ANALYSIS(NAME, PASS_NAME, CONSTRUCTOR)
+#endif
+MACHINE_FUNCTION_ANALYSIS("pass-instrumentation", PassInstrumentationAnalysis, (PIC))
+// LiveVariables currently requires pure SSA form.
+// FIXME: Once TwoAddressInstruction pass no longer uses kill flags,
+// LiveVariables can be removed completely, and LiveIntervals can be directly
+// computed. (We still either need to regenerate kill flags after regalloc, or
+// preferably fix the scavenger to not depend on them).
+// MACHINE_FUNCTION_ANALYSIS("live-vars", LiveVariablesAnalysis())
+
+// MACHINE_FUNCTION_ANALYSIS("live-stacks", LiveStacksPass())
+// MACHINE_FUNCTION_ANALYSIS("slot-indexes", SlotIndexesAnalysis())
+// MACHINE_FUNCTION_ANALYSIS("edge-bundles", EdgeBundlesAnalysis())
+// MACHINE_FUNCTION_ANALYSIS("lazy-machine-bfi", LazyMachineBlockFrequencyInfoAnalysis())
+// MACHINE_FUNCTION_ANALYSIS("machine-bfi", MachineBlockFrequencyInfoAnalysis())
+// MACHINE_FUNCTION_ANALYSIS("machine-loops", MachineLoopInfoAnalysis())
+// MACHINE_FUNCTION_ANALYSIS("machine-dom-frontier", MachineDominanceFrontierAnalysis())
+// MACHINE_FUNCTION_ANALYSIS("machine-dom-tree", MachineDominatorTreeAnalysis())
+// MACHINE_FUNCTION_ANALYSIS("machine-ore", MachineOptimizationRemarkEmitterPassAnalysis())
+// MACHINE_FUNCTION_ANALYSIS("machine-post-dom-tree", MachinePostDominatorTreeAnalysis())
+// MACHINE_FUNCTION_ANALYSIS("machine-region-info", MachineRegionInfoPassAnalysis())
+// MACHINE_FUNCTION_ANALYSIS("machine-trace-metrics", MachineTraceMetricsAnalysis())
+// MACHINE_FUNCTION_ANALYSIS("reaching-def", ReachingDefAnalysisAnalysis())
+// MACHINE_FUNCTION_ANALYSIS("live-reg-matrix", LiveRegMatrixAnalysis())
+// MACHINE_FUNCTION_ANALYSIS("gc-analysis", GCMachineCodeAnalysisPass())
+#undef MACHINE_FUNCTION_ANALYSIS
+
+#ifndef MACHINE_FUNCTION_PASS
+#define MACHINE_FUNCTION_PASS(NAME, PASS_NAME, CONSTRUCTOR)
+#endif
+// MACHINE_FUNCTION_PASS("mir-printer", PrintMIRPass, ())
+// MACHINE_FUNCTION_PASS("free-machine-function", FreeMachineFunctionPass, ())
+#undef MACHINE_FUNCTION_PASS
+
+// After a pass is converted to new pass manager, its entry should be moved from
+// dummy table to the normal one. For example, for a machine function pass,
+// DUMMY_MACHINE_FUNCTION_PASS to MACHINE_FUNCTION_PASS.
+
+#ifndef DUMMY_FUNCTION_PASS
+#define DUMMY_FUNCTION_PASS(NAME, PASS_NAME, CONSTRUCTOR)
+#endif
+DUMMY_FUNCTION_PASS("expandmemcmp", ExpandMemCmpPass, ())
+DUMMY_FUNCTION_PASS("gc-lowering", GCLoweringPass, ())
+DUMMY_FUNCTION_PASS("shadow-stack-gc-lowering", ShadowStackGCLoweringPass, ())
+DUMMY_FUNCTION_PASS("sjljehprepare", SjLjEHPreparePass, ())
+DUMMY_FUNCTION_PASS("dwarfehprepare", DwarfEHPass, ())
+DUMMY_FUNCTION_PASS("winehprepare", WinEHPass, ())
+DUMMY_FUNCTION_PASS("wasmehprepare", WasmEHPass, ())
+DUMMY_FUNCTION_PASS("codegenprepare", CodeGenPreparePass, ())
+DUMMY_FUNCTION_PASS("safe-stack", SafeStackPass, ())
+DUMMY_FUNCTION_PASS("stack-protector", StackProtectorPass, ())
+DUMMY_FUNCTION_PASS("atomic-expand", AtomicExpandPass, ())
+DUMMY_FUNCTION_PASS("interleaved-access", InterleavedAccessPass, ())
+DUMMY_FUNCTION_PASS("indirectbr-expand", IndirectBrExpandPass, ())
+DUMMY_FUNCTION_PASS("cfguard-dispatch", CFGuardDispatchPass, ())
+DUMMY_FUNCTION_PASS("cfguard-check", CFGuardCheckPass, ())
+DUMMY_FUNCTION_PASS("gc-info-printer", GCInfoPrinterPass, ())
+#undef DUMMY_FUNCTION_PASS
+
+#ifndef DUMMY_MODULE_PASS
+#define DUMMY_MODULE_PASS(NAME, PASS_NAME, CONSTRUCTOR)
+#endif
+DUMMY_MODULE_PASS("lower-emutls", LowerEmuTLSPass, ())
+#undef DUMMY_MODULE_PASS
+
+#ifndef DUMMY_MACHINE_MODULE_PASS
+#define DUMMY_MACHINE_MODULE_PASS(NAME, PASS_NAME, CONSTRUCTOR)
+#endif
+DUMMY_MACHINE_MODULE_PASS("machine-outliner", MachineOutlinerPass, ())
+#undef DUMMY_MACHINE_MODULE_PASS
+
+#ifndef DUMMY_MACHINE_FUNCTION_PASS
+#define DUMMY_MACHINE_FUNCTION_PASS(NAME, PASS_NAME, CONSTRUCTOR)
+#endif
+DUMMY_MACHINE_FUNCTION_PASS("mir-printer", PrintMIRPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("free-machine-function", FreeMachineFunctionPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("finalize-isel", FinalizeISelPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("localstackalloc", LocalStackSlotPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("shrink-wrap", ShrinkWrapPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("prologepilog", PrologEpilogInserterPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("postrapseudos", ExpandPostRAPseudosPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("implicit-null-checks", ImplicitNullChecksPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("postmisched", PostMachineSchedulerPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("machine-scheduler", MachineSchedulerPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("machine-cp", MachineCopyPropagationPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("post-RA-sched", PostRASchedulerPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("fentry-insert", FEntryInserterPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("xray-instrumentation", XRayInstrumentationPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("patchable-function", PatchableFunctionPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("reg-usage-propagation", RegUsageInfoPropagationPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("reg-usage-collector", RegUsageInfoCollectorPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("funclet-layout", FuncletLayoutPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("stackmap-liveness", StackMapLivenessPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("livedebugvalues", LiveDebugValuesPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("early-tailduplication", EarlyTailDuplicatePass, ())
+DUMMY_MACHINE_FUNCTION_PASS("opt-phis", OptimizePHIsPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("stack-coloring", StackColoringPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("dead-mi-elimination", DeadMachineInstructionElimPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("early-machinelicm", EarlyMachineLICMPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("machinelicm", MachineLICMPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("machine-cse", MachineCSEPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("machine-sink", MachineSinkingPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("postra-machine-sink", PostRAMachineSinkingPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("peephole-opt", PeepholeOptimizerPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("regalloc", RegAllocPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("virtregrewriter", VirtRegRewriterPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("stack-slot-coloring", StackSlotColoringPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("phi-node-elimination", PHIEliminationPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("twoaddressinstruction", TwoAddressInstructionPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("detect-dead-lanes", DetectDeadLanesPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("processimpdefs", ProcessImplicitDefsPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("liveintervals", LiveIntervalsPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("simple-register-coalescing", RegisterCoalescerPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("rename-independent-subregs", RenameIndependentSubregsPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("branch-folder", BranchFolderPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("tailduplication", TailDuplicatePass, ())
+DUMMY_MACHINE_FUNCTION_PASS("block-placement", MachineBlockPlacementPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("block-placement-stats", MachineBlockPlacementStatsPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("early-ifcvt", EarlyIfConverterPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("machine-combiner", MachineCombinerPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("lrshrink", LiveRangeShrinkPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("break-false-deps", BreakFalseDepsPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("cfi-instr-inserter", CFIInstrInserterPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("cfguard-longjmp", CFGuardLongjmpPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("ra-basic", RABasicPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("ra-fast", RAFastPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("ra-greedy", RAGreedyPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("ra-pbqp", RAPBQPPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("legalizer", LegalizerPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("irtranslator", IRTranslatorPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("regbankselect", RegBankSelectPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("instruction-select", InstructionSelectPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("reset-machine-function", ResetMachineFunctionPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("machineverifier", MachineVerifierPass, ())
+#undef DUMMY_MACHINE_FUNCTION_PASS
diff --git a/linux-x64/clang/include/llvm/CodeGen/MachinePipeliner.h b/linux-x64/clang/include/llvm/CodeGen/MachinePipeliner.h
index 03ca530..f89a453 100644
--- a/linux-x64/clang/include/llvm/CodeGen/MachinePipeliner.h
+++ b/linux-x64/clang/include/llvm/CodeGen/MachinePipeliner.h
@@ -41,12 +41,15 @@
 #define LLVM_LIB_CODEGEN_MACHINEPIPELINER_H
 
 #include "llvm/CodeGen/MachineDominators.h"
+#include "llvm/CodeGen/MachineOptimizationRemarkEmitter.h"
 #include "llvm/CodeGen/RegisterClassInfo.h"
 #include "llvm/CodeGen/ScheduleDAGInstrs.h"
 #include "llvm/CodeGen/TargetInstrInfo.h"
+#include "llvm/InitializePasses.h"
 
 namespace llvm {
 
+class AAResults;
 class NodeSet;
 class SMSchedule;
 
@@ -57,6 +60,7 @@
 class MachinePipeliner : public MachineFunctionPass {
 public:
   MachineFunction *MF = nullptr;
+  MachineOptimizationRemarkEmitter *ORE = nullptr;
   const MachineLoopInfo *MLI = nullptr;
   const MachineDominatorTree *MDT = nullptr;
   const InstrItineraryData *InstrItins;
@@ -87,14 +91,7 @@
 
   bool runOnMachineFunction(MachineFunction &MF) override;
 
-  void getAnalysisUsage(AnalysisUsage &AU) const override {
-    AU.addRequired<AAResultsWrapperPass>();
-    AU.addPreserved<AAResultsWrapperPass>();
-    AU.addRequired<MachineLoopInfo>();
-    AU.addRequired<MachineDominatorTree>();
-    AU.addRequired<LiveIntervals>();
-    MachineFunctionPass::getAnalysisUsage(AU);
-  }
+  void getAnalysisUsage(AnalysisUsage &AU) const override;
 
 private:
   void preprocessPhiNodes(MachineBasicBlock &B);
@@ -148,7 +145,7 @@
 
   /// We may create a new instruction, so remember it because it
   /// must be deleted when the pass is finished.
-  SmallPtrSet<MachineInstr *, 4> NewMIs;
+  DenseMap<MachineInstr*, MachineInstr *> NewMIs;
 
   /// Ordered list of DAG postprocessing steps.
   std::vector<std::unique_ptr<ScheduleDAGMutation>> Mutations;
@@ -200,7 +197,7 @@
         RegClassInfo(rci), II_setByPragma(II), Topo(SUnits, &ExitSU) {
     P.MF->getSubtarget().getSMSMutations(Mutations);
     if (SwpEnableCopyToPhi)
-      Mutations.push_back(llvm::make_unique<CopyToPhiMutation>());
+      Mutations.push_back(std::make_unique<CopyToPhiMutation>());
   }
 
   void schedule() override;
@@ -279,7 +276,7 @@
   static bool classof(const ScheduleDAGInstrs *DAG) { return true; }
 
 private:
-  void addLoopCarriedDependences(AliasAnalysis *AA);
+  void addLoopCarriedDependences(AAResults *AA);
   void updatePhiDependences();
   void changeDependences();
   unsigned calculateResMII();
@@ -297,53 +294,8 @@
   void computeNodeOrder(NodeSetType &NodeSets);
   void checkValidNodeOrder(const NodeSetType &Circuits) const;
   bool schedulePipeline(SMSchedule &Schedule);
-  void generatePipelinedLoop(SMSchedule &Schedule);
-  void generateProlog(SMSchedule &Schedule, unsigned LastStage,
-                      MachineBasicBlock *KernelBB, ValueMapTy *VRMap,
-                      MBBVectorTy &PrologBBs);
-  void generateEpilog(SMSchedule &Schedule, unsigned LastStage,
-                      MachineBasicBlock *KernelBB, ValueMapTy *VRMap,
-                      MBBVectorTy &EpilogBBs, MBBVectorTy &PrologBBs);
-  void generateExistingPhis(MachineBasicBlock *NewBB, MachineBasicBlock *BB1,
-                            MachineBasicBlock *BB2, MachineBasicBlock *KernelBB,
-                            SMSchedule &Schedule, ValueMapTy *VRMap,
-                            InstrMapTy &InstrMap, unsigned LastStageNum,
-                            unsigned CurStageNum, bool IsLast);
-  void generatePhis(MachineBasicBlock *NewBB, MachineBasicBlock *BB1,
-                    MachineBasicBlock *BB2, MachineBasicBlock *KernelBB,
-                    SMSchedule &Schedule, ValueMapTy *VRMap,
-                    InstrMapTy &InstrMap, unsigned LastStageNum,
-                    unsigned CurStageNum, bool IsLast);
-  void removeDeadInstructions(MachineBasicBlock *KernelBB,
-                              MBBVectorTy &EpilogBBs);
-  void splitLifetimes(MachineBasicBlock *KernelBB, MBBVectorTy &EpilogBBs,
-                      SMSchedule &Schedule);
-  void addBranches(MachineBasicBlock &PreheaderBB, MBBVectorTy &PrologBBs,
-                   MachineBasicBlock *KernelBB, MBBVectorTy &EpilogBBs,
-                   SMSchedule &Schedule, ValueMapTy *VRMap);
   bool computeDelta(MachineInstr &MI, unsigned &Delta);
-  void updateMemOperands(MachineInstr &NewMI, MachineInstr &OldMI,
-                         unsigned Num);
-  MachineInstr *cloneInstr(MachineInstr *OldMI, unsigned CurStageNum,
-                           unsigned InstStageNum);
-  MachineInstr *cloneAndChangeInstr(MachineInstr *OldMI, unsigned CurStageNum,
-                                    unsigned InstStageNum,
-                                    SMSchedule &Schedule);
-  void updateInstruction(MachineInstr *NewMI, bool LastDef,
-                         unsigned CurStageNum, unsigned InstrStageNum,
-                         SMSchedule &Schedule, ValueMapTy *VRMap);
-  MachineInstr *findDefInLoop(unsigned Reg);
-  unsigned getPrevMapVal(unsigned StageNum, unsigned PhiStage, unsigned LoopVal,
-                         unsigned LoopStage, ValueMapTy *VRMap,
-                         MachineBasicBlock *BB);
-  void rewritePhiValues(MachineBasicBlock *NewBB, unsigned StageNum,
-                        SMSchedule &Schedule, ValueMapTy *VRMap,
-                        InstrMapTy &InstrMap);
-  void rewriteScheduledInstr(MachineBasicBlock *BB, SMSchedule &Schedule,
-                             InstrMapTy &InstrMap, unsigned CurStageNum,
-                             unsigned PhiNum, MachineInstr *Phi,
-                             unsigned OldReg, unsigned NewReg,
-                             unsigned PrevReg = 0);
+  MachineInstr *findDefInLoop(Register Reg);
   bool canUseLastOffsetValue(MachineInstr *MI, unsigned &BasePos,
                              unsigned &OffsetPos, unsigned &NewBase,
                              int64_t &NewOffset);
@@ -372,10 +324,22 @@
   NodeSet() = default;
   NodeSet(iterator S, iterator E) : Nodes(S, E), HasRecurrence(true) {
     Latency = 0;
-    for (unsigned i = 0, e = Nodes.size(); i < e; ++i)
-      for (const SDep &Succ : Nodes[i]->Succs)
-        if (Nodes.count(Succ.getSUnit()))
-          Latency += Succ.getLatency();
+    for (unsigned i = 0, e = Nodes.size(); i < e; ++i) {
+      DenseMap<SUnit *, unsigned> SuccSUnitLatency;
+      for (const SDep &Succ : Nodes[i]->Succs) {
+        auto SuccSUnit = Succ.getSUnit();
+        if (!Nodes.count(SuccSUnit))
+          continue;
+        unsigned CurLatency = Succ.getLatency();
+        unsigned MaxLatency = 0;
+        if (SuccSUnitLatency.count(SuccSUnit))
+          MaxLatency = SuccSUnitLatency[SuccSUnit];
+        if (CurLatency > MaxLatency)
+          SuccSUnitLatency[SuccSUnit] = CurLatency;
+      }
+      for (auto SUnitLatency : SuccSUnitLatency)
+        Latency += SUnitLatency.second;
+    }
   }
 
   bool insert(SUnit *SU) { return Nodes.insert(SU); }
@@ -529,12 +493,6 @@
   /// Map from instruction to execution cycle.
   std::map<SUnit *, int> InstrToCycle;
 
-  /// Map for each register and the max difference between its uses and def.
-  /// The first element in the pair is the max difference in stages. The
-  /// second is true if the register defines a Phi value and loop value is
-  /// scheduled before the Phi.
-  std::map<unsigned, std::pair<unsigned, bool>> RegToStageDiff;
-
   /// Keep track of the first cycle value in the schedule.  It starts
   /// as zero, but the algorithm allows negative values.
   int FirstCycle = 0;
@@ -560,7 +518,6 @@
   void reset() {
     ScheduledInstrs.clear();
     InstrToCycle.clear();
-    RegToStageDiff.clear();
     FirstCycle = 0;
     LastCycle = 0;
     InitiationInterval = 0;
@@ -620,28 +577,6 @@
     return (LastCycle - FirstCycle) / InitiationInterval;
   }
 
-  /// Return the max. number of stages/iterations that can occur between a
-  /// register definition and its uses.
-  unsigned getStagesForReg(int Reg, unsigned CurStage) {
-    std::pair<unsigned, bool> Stages = RegToStageDiff[Reg];
-    if (CurStage > getMaxStageCount() && Stages.first == 0 && Stages.second)
-      return 1;
-    return Stages.first;
-  }
-
-  /// The number of stages for a Phi is a little different than other
-  /// instructions. The minimum value computed in RegToStageDiff is 1
-  /// because we assume the Phi is needed for at least 1 iteration.
-  /// This is not the case if the loop value is scheduled prior to the
-  /// Phi in the same stage.  This function returns the number of stages
-  /// or iterations needed between the Phi definition and any uses.
-  unsigned getStagesForPhi(int Reg) {
-    std::pair<unsigned, bool> Stages = RegToStageDiff[Reg];
-    if (Stages.second)
-      return Stages.first;
-    return Stages.first - 1;
-  }
-
   /// Return the instructions that are scheduled at the specified cycle.
   std::deque<SUnit *> &getInstructions(int cycle) {
     return ScheduledInstrs[cycle];
diff --git a/linux-x64/clang/include/llvm/CodeGen/MachinePostDominators.h b/linux-x64/clang/include/llvm/CodeGen/MachinePostDominators.h
index b67e6b5..cee4294 100644
--- a/linux-x64/clang/include/llvm/CodeGen/MachinePostDominators.h
+++ b/linux-x64/clang/include/llvm/CodeGen/MachinePostDominators.h
@@ -16,68 +16,78 @@
 
 #include "llvm/CodeGen/MachineDominators.h"
 #include "llvm/CodeGen/MachineFunctionPass.h"
+#include <memory>
 
 namespace llvm {
 
 ///
-/// PostDominatorTree Class - Concrete subclass of DominatorTree that is used
-/// to compute the post-dominator tree.
+/// MachinePostDominatorTree - an analysis pass wrapper for DominatorTree
+/// used to compute the post-dominator tree for MachineFunctions.
 ///
-struct MachinePostDominatorTree : public MachineFunctionPass {
-private:
- PostDomTreeBase<MachineBasicBlock> *DT;
+class MachinePostDominatorTree : public MachineFunctionPass {
+  using PostDomTreeT = PostDomTreeBase<MachineBasicBlock>;
+  std::unique_ptr<PostDomTreeT> PDT;
 
 public:
   static char ID;
 
   MachinePostDominatorTree();
 
-  ~MachinePostDominatorTree() override;
+  PostDomTreeT &getBase() {
+    if (!PDT)
+      PDT.reset(new PostDomTreeT());
+    return *PDT;
+  }
 
   FunctionPass *createMachinePostDominatorTreePass();
 
-  const SmallVectorImpl<MachineBasicBlock *> &getRoots() const {
-    return DT->getRoots();
-  }
-
-  MachineDomTreeNode *getRootNode() const {
-    return DT->getRootNode();
-  }
+  MachineDomTreeNode *getRootNode() const { return PDT->getRootNode(); }
 
   MachineDomTreeNode *operator[](MachineBasicBlock *BB) const {
-    return DT->getNode(BB);
+    return PDT->getNode(BB);
   }
 
   MachineDomTreeNode *getNode(MachineBasicBlock *BB) const {
-    return DT->getNode(BB);
+    return PDT->getNode(BB);
   }
 
   bool dominates(const MachineDomTreeNode *A,
                  const MachineDomTreeNode *B) const {
-    return DT->dominates(A, B);
+    return PDT->dominates(A, B);
   }
 
   bool dominates(const MachineBasicBlock *A, const MachineBasicBlock *B) const {
-    return DT->dominates(A, B);
+    return PDT->dominates(A, B);
   }
 
   bool properlyDominates(const MachineDomTreeNode *A,
                          const MachineDomTreeNode *B) const {
-    return DT->properlyDominates(A, B);
+    return PDT->properlyDominates(A, B);
   }
 
   bool properlyDominates(const MachineBasicBlock *A,
                          const MachineBasicBlock *B) const {
-    return DT->properlyDominates(A, B);
+    return PDT->properlyDominates(A, B);
+  }
+
+  bool isVirtualRoot(const MachineDomTreeNode *Node) const {
+    return PDT->isVirtualRoot(Node);
   }
 
   MachineBasicBlock *findNearestCommonDominator(MachineBasicBlock *A,
-                                                MachineBasicBlock *B) {
-    return DT->findNearestCommonDominator(A, B);
+                                                MachineBasicBlock *B) const {
+    return PDT->findNearestCommonDominator(A, B);
   }
 
+  /// Returns the nearest common dominator of the given blocks.
+  /// If that tree node is a virtual root, a nullptr will be returned.
+  MachineBasicBlock *
+  findNearestCommonDominator(ArrayRef<MachineBasicBlock *> Blocks) const;
+
   bool runOnMachineFunction(MachineFunction &MF) override;
   void getAnalysisUsage(AnalysisUsage &AU) const override;
+  void releaseMemory() override { PDT.reset(nullptr); }
+  void verifyAnalysis() const override;
   void print(llvm::raw_ostream &OS, const Module *M = nullptr) const override;
 };
 } //end of namespace llvm
diff --git a/linux-x64/clang/include/llvm/CodeGen/MachineRegionInfo.h b/linux-x64/clang/include/llvm/CodeGen/MachineRegionInfo.h
index 6d9fb9b..eeb69fe 100644
--- a/linux-x64/clang/include/llvm/CodeGen/MachineRegionInfo.h
+++ b/linux-x64/clang/include/llvm/CodeGen/MachineRegionInfo.h
@@ -22,7 +22,7 @@
 
 namespace llvm {
 
-struct MachinePostDominatorTree;
+class MachinePostDominatorTree;
 class MachineRegion;
 class MachineRegionNode;
 class MachineRegionInfo;
diff --git a/linux-x64/clang/include/llvm/CodeGen/MachineRegisterInfo.h b/linux-x64/clang/include/llvm/CodeGen/MachineRegisterInfo.h
index b5deed1..a1a6705 100644
--- a/linux-x64/clang/include/llvm/CodeGen/MachineRegisterInfo.h
+++ b/linux-x64/clang/include/llvm/CodeGen/MachineRegisterInfo.h
@@ -57,7 +57,7 @@
   public:
     virtual ~Delegate() = default;
 
-    virtual void MRI_NoteNewVirtualRegister(unsigned Reg) = 0;
+    virtual void MRI_NoteNewVirtualRegister(Register Reg) = 0;
   };
 
 private:
@@ -98,7 +98,7 @@
   /// first member of the pair being non-zero. If the hinted register is
   /// virtual, it means the allocator should prefer the physical register
   /// allocated to it if any.
-  IndexedMap<std::pair<unsigned, SmallVector<unsigned, 4>>,
+  IndexedMap<std::pair<Register, SmallVector<Register, 4>>,
              VirtReg2IndexFunctor> RegAllocHints;
 
   /// PhysRegUseDefLists - This is an array of the head of the use/def list for
@@ -107,16 +107,16 @@
 
   /// getRegUseDefListHead - Return the head pointer for the register use/def
   /// list for the specified virtual or physical register.
-  MachineOperand *&getRegUseDefListHead(unsigned RegNo) {
-    if (TargetRegisterInfo::isVirtualRegister(RegNo))
-      return VRegInfo[RegNo].second;
-    return PhysRegUseDefLists[RegNo];
+  MachineOperand *&getRegUseDefListHead(Register RegNo) {
+    if (RegNo.isVirtual())
+      return VRegInfo[RegNo.id()].second;
+    return PhysRegUseDefLists[RegNo.id()];
   }
 
-  MachineOperand *getRegUseDefListHead(unsigned RegNo) const {
-    if (TargetRegisterInfo::isVirtualRegister(RegNo))
-      return VRegInfo[RegNo].second;
-    return PhysRegUseDefLists[RegNo];
+  MachineOperand *getRegUseDefListHead(Register RegNo) const {
+    if (RegNo.isVirtual())
+      return VRegInfo[RegNo.id()].second;
+    return PhysRegUseDefLists[RegNo.id()];
   }
 
   /// Get the next element in the use-def chain.
@@ -143,7 +143,7 @@
   /// Live in values are typically arguments in registers.  LiveIn values are
   /// allowed to have virtual registers associated with them, stored in the
   /// second element.
-  std::vector<std::pair<unsigned, unsigned>> LiveIns;
+  std::vector<std::pair<MCRegister, Register>> LiveIns;
 
 public:
   explicit MachineRegisterInfo(MachineFunction *MF);
@@ -214,8 +214,8 @@
   bool shouldTrackSubRegLiveness(const TargetRegisterClass &RC) const {
     return subRegLivenessEnabled() && RC.HasDisjunctSubRegs;
   }
-  bool shouldTrackSubRegLiveness(unsigned VReg) const {
-    assert(TargetRegisterInfo::isVirtualRegister(VReg) && "Must pass a VReg");
+  bool shouldTrackSubRegLiveness(Register VReg) const {
+    assert(VReg.isVirtual() && "Must pass a VReg");
     return shouldTrackSubRegLiveness(*getRegClass(VReg));
   }
   bool subRegLivenessEnabled() const {
@@ -232,7 +232,7 @@
   /// Disables the register from the list of CSRs.
   /// I.e. the register will not appear as part of the CSR mask.
   /// \see UpdatedCalleeSavedRegs.
-  void disableCalleeSavedRegister(unsigned Reg);
+  void disableCalleeSavedRegister(MCRegister Reg);
 
   /// Returns list of callee saved registers.
   /// The function returns the updated CSR list (after taking into account
@@ -253,7 +253,7 @@
   void moveOperands(MachineOperand *Dst, MachineOperand *Src, unsigned NumOps);
 
   /// Verify the sanity of the use list for Reg.
-  void verifyUseList(unsigned Reg) const;
+  void verifyUseList(Register Reg) const;
 
   /// Verify the use list of all registers.
   void verifyUseLists() const;
@@ -278,12 +278,12 @@
   /// register.
   using reg_iterator =
       defusechain_iterator<true, true, false, true, false, false>;
-  reg_iterator reg_begin(unsigned RegNo) const {
+  reg_iterator reg_begin(Register RegNo) const {
     return reg_iterator(getRegUseDefListHead(RegNo));
   }
   static reg_iterator reg_end() { return reg_iterator(nullptr); }
 
-  inline iterator_range<reg_iterator>  reg_operands(unsigned Reg) const {
+  inline iterator_range<reg_iterator> reg_operands(Register Reg) const {
     return make_range(reg_begin(Reg), reg_end());
   }
 
@@ -291,7 +291,7 @@
   /// of the specified register, stepping by MachineInstr.
   using reg_instr_iterator =
       defusechain_instr_iterator<true, true, false, false, true, false>;
-  reg_instr_iterator reg_instr_begin(unsigned RegNo) const {
+  reg_instr_iterator reg_instr_begin(Register RegNo) const {
     return reg_instr_iterator(getRegUseDefListHead(RegNo));
   }
   static reg_instr_iterator reg_instr_end() {
@@ -299,7 +299,7 @@
   }
 
   inline iterator_range<reg_instr_iterator>
-  reg_instructions(unsigned Reg) const {
+  reg_instructions(Register Reg) const {
     return make_range(reg_instr_begin(Reg), reg_instr_end());
   }
 
@@ -307,26 +307,26 @@
   /// of the specified register, stepping by bundle.
   using reg_bundle_iterator =
       defusechain_instr_iterator<true, true, false, false, false, true>;
-  reg_bundle_iterator reg_bundle_begin(unsigned RegNo) const {
+  reg_bundle_iterator reg_bundle_begin(Register RegNo) const {
     return reg_bundle_iterator(getRegUseDefListHead(RegNo));
   }
   static reg_bundle_iterator reg_bundle_end() {
     return reg_bundle_iterator(nullptr);
   }
 
-  inline iterator_range<reg_bundle_iterator> reg_bundles(unsigned Reg) const {
+  inline iterator_range<reg_bundle_iterator> reg_bundles(Register Reg) const {
     return make_range(reg_bundle_begin(Reg), reg_bundle_end());
   }
 
   /// reg_empty - Return true if there are no instructions using or defining the
   /// specified register (it may be live-in).
-  bool reg_empty(unsigned RegNo) const { return reg_begin(RegNo) == reg_end(); }
+  bool reg_empty(Register RegNo) const { return reg_begin(RegNo) == reg_end(); }
 
   /// reg_nodbg_iterator/reg_nodbg_begin/reg_nodbg_end - Walk all defs and uses
   /// of the specified register, skipping those marked as Debug.
   using reg_nodbg_iterator =
       defusechain_iterator<true, true, true, true, false, false>;
-  reg_nodbg_iterator reg_nodbg_begin(unsigned RegNo) const {
+  reg_nodbg_iterator reg_nodbg_begin(Register RegNo) const {
     return reg_nodbg_iterator(getRegUseDefListHead(RegNo));
   }
   static reg_nodbg_iterator reg_nodbg_end() {
@@ -334,7 +334,7 @@
   }
 
   inline iterator_range<reg_nodbg_iterator>
-  reg_nodbg_operands(unsigned Reg) const {
+  reg_nodbg_operands(Register Reg) const {
     return make_range(reg_nodbg_begin(Reg), reg_nodbg_end());
   }
 
@@ -343,7 +343,7 @@
   /// skipping those marked as Debug.
   using reg_instr_nodbg_iterator =
       defusechain_instr_iterator<true, true, true, false, true, false>;
-  reg_instr_nodbg_iterator reg_instr_nodbg_begin(unsigned RegNo) const {
+  reg_instr_nodbg_iterator reg_instr_nodbg_begin(Register RegNo) const {
     return reg_instr_nodbg_iterator(getRegUseDefListHead(RegNo));
   }
   static reg_instr_nodbg_iterator reg_instr_nodbg_end() {
@@ -351,7 +351,7 @@
   }
 
   inline iterator_range<reg_instr_nodbg_iterator>
-  reg_nodbg_instructions(unsigned Reg) const {
+  reg_nodbg_instructions(Register Reg) const {
     return make_range(reg_instr_nodbg_begin(Reg), reg_instr_nodbg_end());
   }
 
@@ -360,7 +360,7 @@
   /// skipping those marked as Debug.
   using reg_bundle_nodbg_iterator =
       defusechain_instr_iterator<true, true, true, false, false, true>;
-  reg_bundle_nodbg_iterator reg_bundle_nodbg_begin(unsigned RegNo) const {
+  reg_bundle_nodbg_iterator reg_bundle_nodbg_begin(Register RegNo) const {
     return reg_bundle_nodbg_iterator(getRegUseDefListHead(RegNo));
   }
   static reg_bundle_nodbg_iterator reg_bundle_nodbg_end() {
@@ -368,25 +368,25 @@
   }
 
   inline iterator_range<reg_bundle_nodbg_iterator>
-  reg_nodbg_bundles(unsigned Reg) const {
+  reg_nodbg_bundles(Register Reg) const {
     return make_range(reg_bundle_nodbg_begin(Reg), reg_bundle_nodbg_end());
   }
 
   /// reg_nodbg_empty - Return true if the only instructions using or defining
   /// Reg are Debug instructions.
-  bool reg_nodbg_empty(unsigned RegNo) const {
+  bool reg_nodbg_empty(Register RegNo) const {
     return reg_nodbg_begin(RegNo) == reg_nodbg_end();
   }
 
   /// def_iterator/def_begin/def_end - Walk all defs of the specified register.
   using def_iterator =
       defusechain_iterator<false, true, false, true, false, false>;
-  def_iterator def_begin(unsigned RegNo) const {
+  def_iterator def_begin(Register RegNo) const {
     return def_iterator(getRegUseDefListHead(RegNo));
   }
   static def_iterator def_end() { return def_iterator(nullptr); }
 
-  inline iterator_range<def_iterator> def_operands(unsigned Reg) const {
+  inline iterator_range<def_iterator> def_operands(Register Reg) const {
     return make_range(def_begin(Reg), def_end());
   }
 
@@ -394,7 +394,7 @@
   /// specified register, stepping by MachineInst.
   using def_instr_iterator =
       defusechain_instr_iterator<false, true, false, false, true, false>;
-  def_instr_iterator def_instr_begin(unsigned RegNo) const {
+  def_instr_iterator def_instr_begin(Register RegNo) const {
     return def_instr_iterator(getRegUseDefListHead(RegNo));
   }
   static def_instr_iterator def_instr_end() {
@@ -402,7 +402,7 @@
   }
 
   inline iterator_range<def_instr_iterator>
-  def_instructions(unsigned Reg) const {
+  def_instructions(Register Reg) const {
     return make_range(def_instr_begin(Reg), def_instr_end());
   }
 
@@ -410,26 +410,26 @@
   /// specified register, stepping by bundle.
   using def_bundle_iterator =
       defusechain_instr_iterator<false, true, false, false, false, true>;
-  def_bundle_iterator def_bundle_begin(unsigned RegNo) const {
+  def_bundle_iterator def_bundle_begin(Register RegNo) const {
     return def_bundle_iterator(getRegUseDefListHead(RegNo));
   }
   static def_bundle_iterator def_bundle_end() {
     return def_bundle_iterator(nullptr);
   }
 
-  inline iterator_range<def_bundle_iterator> def_bundles(unsigned Reg) const {
+  inline iterator_range<def_bundle_iterator> def_bundles(Register Reg) const {
     return make_range(def_bundle_begin(Reg), def_bundle_end());
   }
 
   /// def_empty - Return true if there are no instructions defining the
   /// specified register (it may be live-in).
-  bool def_empty(unsigned RegNo) const { return def_begin(RegNo) == def_end(); }
+  bool def_empty(Register RegNo) const { return def_begin(RegNo) == def_end(); }
 
-  StringRef getVRegName(unsigned Reg) const {
+  StringRef getVRegName(Register Reg) const {
     return VReg2Name.inBounds(Reg) ? StringRef(VReg2Name[Reg]) : "";
   }
 
-  void insertVRegByName(StringRef Name, unsigned Reg) {
+  void insertVRegByName(StringRef Name, Register Reg) {
     assert((Name.empty() || VRegNames.find(Name) == VRegNames.end()) &&
            "Named VRegs Must be Unique.");
     if (!Name.empty()) {
@@ -441,22 +441,35 @@
 
   /// Return true if there is exactly one operand defining the specified
   /// register.
-  bool hasOneDef(unsigned RegNo) const {
+  bool hasOneDef(Register RegNo) const {
     def_iterator DI = def_begin(RegNo);
     if (DI == def_end())
       return false;
     return ++DI == def_end();
   }
 
+  /// Returns the defining operand if there is exactly one operand defining the
+  /// specified register, otherwise nullptr.
+  MachineOperand *getOneDef(Register Reg) const {
+    def_iterator DI = def_begin(Reg);
+    if (DI == def_end()) // No defs.
+      return nullptr;
+
+    def_iterator OneDef = DI;
+    if (++DI == def_end())
+      return &*OneDef;
+    return nullptr; // Multiple defs.
+  }
+
   /// use_iterator/use_begin/use_end - Walk all uses of the specified register.
   using use_iterator =
       defusechain_iterator<true, false, false, true, false, false>;
-  use_iterator use_begin(unsigned RegNo) const {
+  use_iterator use_begin(Register RegNo) const {
     return use_iterator(getRegUseDefListHead(RegNo));
   }
   static use_iterator use_end() { return use_iterator(nullptr); }
 
-  inline iterator_range<use_iterator> use_operands(unsigned Reg) const {
+  inline iterator_range<use_iterator> use_operands(Register Reg) const {
     return make_range(use_begin(Reg), use_end());
   }
 
@@ -464,7 +477,7 @@
   /// specified register, stepping by MachineInstr.
   using use_instr_iterator =
       defusechain_instr_iterator<true, false, false, false, true, false>;
-  use_instr_iterator use_instr_begin(unsigned RegNo) const {
+  use_instr_iterator use_instr_begin(Register RegNo) const {
     return use_instr_iterator(getRegUseDefListHead(RegNo));
   }
   static use_instr_iterator use_instr_end() {
@@ -472,7 +485,7 @@
   }
 
   inline iterator_range<use_instr_iterator>
-  use_instructions(unsigned Reg) const {
+  use_instructions(Register Reg) const {
     return make_range(use_instr_begin(Reg), use_instr_end());
   }
 
@@ -480,24 +493,24 @@
   /// specified register, stepping by bundle.
   using use_bundle_iterator =
       defusechain_instr_iterator<true, false, false, false, false, true>;
-  use_bundle_iterator use_bundle_begin(unsigned RegNo) const {
+  use_bundle_iterator use_bundle_begin(Register RegNo) const {
     return use_bundle_iterator(getRegUseDefListHead(RegNo));
   }
   static use_bundle_iterator use_bundle_end() {
     return use_bundle_iterator(nullptr);
   }
 
-  inline iterator_range<use_bundle_iterator> use_bundles(unsigned Reg) const {
+  inline iterator_range<use_bundle_iterator> use_bundles(Register Reg) const {
     return make_range(use_bundle_begin(Reg), use_bundle_end());
   }
 
   /// use_empty - Return true if there are no instructions using the specified
   /// register.
-  bool use_empty(unsigned RegNo) const { return use_begin(RegNo) == use_end(); }
+  bool use_empty(Register RegNo) const { return use_begin(RegNo) == use_end(); }
 
   /// hasOneUse - Return true if there is exactly one instruction using the
   /// specified register.
-  bool hasOneUse(unsigned RegNo) const {
+  bool hasOneUse(Register RegNo) const {
     use_iterator UI = use_begin(RegNo);
     if (UI == use_end())
       return false;
@@ -508,7 +521,7 @@
   /// specified register, skipping those marked as Debug.
   using use_nodbg_iterator =
       defusechain_iterator<true, false, true, true, false, false>;
-  use_nodbg_iterator use_nodbg_begin(unsigned RegNo) const {
+  use_nodbg_iterator use_nodbg_begin(Register RegNo) const {
     return use_nodbg_iterator(getRegUseDefListHead(RegNo));
   }
   static use_nodbg_iterator use_nodbg_end() {
@@ -516,7 +529,7 @@
   }
 
   inline iterator_range<use_nodbg_iterator>
-  use_nodbg_operands(unsigned Reg) const {
+  use_nodbg_operands(Register Reg) const {
     return make_range(use_nodbg_begin(Reg), use_nodbg_end());
   }
 
@@ -525,7 +538,7 @@
   /// those marked as Debug.
   using use_instr_nodbg_iterator =
       defusechain_instr_iterator<true, false, true, false, true, false>;
-  use_instr_nodbg_iterator use_instr_nodbg_begin(unsigned RegNo) const {
+  use_instr_nodbg_iterator use_instr_nodbg_begin(Register RegNo) const {
     return use_instr_nodbg_iterator(getRegUseDefListHead(RegNo));
   }
   static use_instr_nodbg_iterator use_instr_nodbg_end() {
@@ -533,7 +546,7 @@
   }
 
   inline iterator_range<use_instr_nodbg_iterator>
-  use_nodbg_instructions(unsigned Reg) const {
+  use_nodbg_instructions(Register Reg) const {
     return make_range(use_instr_nodbg_begin(Reg), use_instr_nodbg_end());
   }
 
@@ -542,7 +555,7 @@
   /// those marked as Debug.
   using use_bundle_nodbg_iterator =
       defusechain_instr_iterator<true, false, true, false, false, true>;
-  use_bundle_nodbg_iterator use_bundle_nodbg_begin(unsigned RegNo) const {
+  use_bundle_nodbg_iterator use_bundle_nodbg_begin(Register RegNo) const {
     return use_bundle_nodbg_iterator(getRegUseDefListHead(RegNo));
   }
   static use_bundle_nodbg_iterator use_bundle_nodbg_end() {
@@ -550,25 +563,25 @@
   }
 
   inline iterator_range<use_bundle_nodbg_iterator>
-  use_nodbg_bundles(unsigned Reg) const {
+  use_nodbg_bundles(Register Reg) const {
     return make_range(use_bundle_nodbg_begin(Reg), use_bundle_nodbg_end());
   }
 
   /// use_nodbg_empty - Return true if there are no non-Debug instructions
   /// using the specified register.
-  bool use_nodbg_empty(unsigned RegNo) const {
+  bool use_nodbg_empty(Register RegNo) const {
     return use_nodbg_begin(RegNo) == use_nodbg_end();
   }
 
   /// hasOneNonDBGUse - Return true if there is exactly one non-Debug
   /// use of the specified register.
-  bool hasOneNonDBGUse(unsigned RegNo) const;
+  bool hasOneNonDBGUse(Register RegNo) const;
 
   /// hasOneNonDBGUse - Return true if there is exactly one non-Debug
   /// instruction using the specified register. Said instruction may have
   /// multiple uses.
-  bool hasOneNonDBGUser(unsigned RegNo) const;
-  
+  bool hasOneNonDBGUser(Register RegNo) const;
+
   /// replaceRegWith - Replace all instances of FromReg with ToReg in the
   /// machine function.  This is like llvm-level X->replaceAllUsesWith(Y),
   /// except that it also changes any definitions of the register as well.
@@ -588,38 +601,34 @@
   /// Note that if ToReg is a physical register the function will replace and
   /// apply sub registers to ToReg in order to obtain a final/proper physical
   /// register.
-  void replaceRegWith(unsigned FromReg, unsigned ToReg);
+  void replaceRegWith(Register FromReg, Register ToReg);
 
   /// getVRegDef - Return the machine instr that defines the specified virtual
   /// register or null if none is found.  This assumes that the code is in SSA
   /// form, so there should only be one definition.
-  MachineInstr *getVRegDef(unsigned Reg) const;
+  MachineInstr *getVRegDef(Register Reg) const;
 
   /// getUniqueVRegDef - Return the unique machine instr that defines the
   /// specified virtual register or null if none is found.  If there are
   /// multiple definitions or no definition, return null.
-  MachineInstr *getUniqueVRegDef(unsigned Reg) const;
+  MachineInstr *getUniqueVRegDef(Register Reg) const;
 
   /// clearKillFlags - Iterate over all the uses of the given register and
   /// clear the kill flag from the MachineOperand. This function is used by
   /// optimization passes which extend register lifetimes and need only
   /// preserve conservative kill flag information.
-  void clearKillFlags(unsigned Reg) const;
+  void clearKillFlags(Register Reg) const;
 
-  void dumpUses(unsigned RegNo) const;
+  void dumpUses(Register RegNo) const;
 
   /// Returns true if PhysReg is unallocatable and constant throughout the
   /// function. Writing to a constant register has no effect.
-  bool isConstantPhysReg(unsigned PhysReg) const;
-
-  /// Returns true if either isConstantPhysReg or TRI->isCallerPreservedPhysReg
-  /// returns true. This is a utility member function.
-  bool isCallerPreservedOrConstPhysReg(unsigned PhysReg) const;
+  bool isConstantPhysReg(MCRegister PhysReg) const;
 
   /// Get an iterator over the pressure sets affected by the given physical or
   /// virtual register. If RegUnit is physical, it must be a register unit (from
   /// MCRegUnitIterator).
-  PSetIterator getPressureSets(unsigned RegUnit) const;
+  PSetIterator getPressureSets(Register RegUnit) const;
 
   //===--------------------------------------------------------------------===//
   // Virtual Register Info
@@ -628,10 +637,10 @@
   /// Return the register class of the specified virtual register.
   /// This shouldn't be used directly unless \p Reg has a register class.
   /// \see getRegClassOrNull when this might happen.
-  const TargetRegisterClass *getRegClass(unsigned Reg) const {
-    assert(VRegInfo[Reg].first.is<const TargetRegisterClass *>() &&
+  const TargetRegisterClass *getRegClass(Register Reg) const {
+    assert(VRegInfo[Reg.id()].first.is<const TargetRegisterClass *>() &&
            "Register class not set, wrong accessor");
-    return VRegInfo[Reg].first.get<const TargetRegisterClass *>();
+    return VRegInfo[Reg.id()].first.get<const TargetRegisterClass *>();
   }
 
   /// Return the register class of \p Reg, or null if Reg has not been assigned
@@ -645,7 +654,7 @@
   /// None of this condition is possible without GlobalISel for now.
   /// In other words, if GlobalISel is not used or if the query happens after
   /// the select pass, using getRegClass is safe.
-  const TargetRegisterClass *getRegClassOrNull(unsigned Reg) const {
+  const TargetRegisterClass *getRegClassOrNull(Register Reg) const {
     const RegClassOrRegBank &Val = VRegInfo[Reg].first;
     return Val.dyn_cast<const TargetRegisterClass *>();
   }
@@ -654,7 +663,7 @@
   /// a register bank or has been assigned a register class.
   /// \note It is possible to get the register bank from the register class via
   /// RegisterBankInfo::getRegBankFromRegClass.
-  const RegisterBank *getRegBankOrNull(unsigned Reg) const {
+  const RegisterBank *getRegBankOrNull(Register Reg) const {
     const RegClassOrRegBank &Val = VRegInfo[Reg].first;
     return Val.dyn_cast<const RegisterBank *>();
   }
@@ -662,17 +671,17 @@
   /// Return the register bank or register class of \p Reg.
   /// \note Before the register bank gets assigned (i.e., before the
   /// RegBankSelect pass) \p Reg may not have either.
-  const RegClassOrRegBank &getRegClassOrRegBank(unsigned Reg) const {
+  const RegClassOrRegBank &getRegClassOrRegBank(Register Reg) const {
     return VRegInfo[Reg].first;
   }
 
   /// setRegClass - Set the register class of the specified virtual register.
-  void setRegClass(unsigned Reg, const TargetRegisterClass *RC);
+  void setRegClass(Register Reg, const TargetRegisterClass *RC);
 
   /// Set the register bank to \p RegBank for \p Reg.
-  void setRegBank(unsigned Reg, const RegisterBank &RegBank);
+  void setRegBank(Register Reg, const RegisterBank &RegBank);
 
-  void setRegClassOrRegBank(unsigned Reg,
+  void setRegClassOrRegBank(Register Reg,
                             const RegClassOrRegBank &RCOrRB){
     VRegInfo[Reg].first = RCOrRB;
   }
@@ -688,7 +697,7 @@
   /// Use RegisterBankInfo::constrainGenericRegister in GlobalISel's
   /// InstructionSelect pass and constrainRegAttrs in every other pass,
   /// including non-select passes of GlobalISel, instead.
-  const TargetRegisterClass *constrainRegClass(unsigned Reg,
+  const TargetRegisterClass *constrainRegClass(Register Reg,
                                                const TargetRegisterClass *RC,
                                                unsigned MinNumRegs = 0);
 
@@ -703,7 +712,7 @@
   /// \note Use this method instead of constrainRegClass and
   /// RegisterBankInfo::constrainGenericRegister everywhere but SelectionDAG
   /// ISel / FastISel and GlobalISel's InstructionSelect pass respectively.
-  bool constrainRegAttrs(unsigned Reg, unsigned ConstrainingReg,
+  bool constrainRegAttrs(Register Reg, Register ConstrainingReg,
                          unsigned MinNumRegs = 0);
 
   /// recomputeRegClass - Try to find a legal super-class of Reg's register
@@ -713,7 +722,7 @@
   /// This method can be used after constraints have been removed from a
   /// virtual register, for example after removing instructions or splitting
   /// the live range.
-  bool recomputeRegClass(unsigned Reg);
+  bool recomputeRegClass(Register Reg);
 
   /// createVirtualRegister - Create and return a new virtual register in the
   /// function with the specified register class.
@@ -726,14 +735,14 @@
 
   /// Get the low-level type of \p Reg or LLT{} if Reg is not a generic
   /// (target independent) virtual register.
-  LLT getType(unsigned Reg) const {
-    if (TargetRegisterInfo::isVirtualRegister(Reg) && VRegToType.inBounds(Reg))
+  LLT getType(Register Reg) const {
+    if (Register::isVirtualRegister(Reg) && VRegToType.inBounds(Reg))
       return VRegToType[Reg];
     return LLT{};
   }
 
   /// Set the low-level type of \p VReg to \p Ty.
-  void setType(unsigned VReg, LLT Ty);
+  void setType(Register VReg, LLT Ty);
 
   /// Create and return a new generic virtual register with low-level
   /// type \p Ty.
@@ -748,7 +757,7 @@
   /// temporarily while constructing machine instructions. Most operations are
   /// undefined on an incomplete register until one of setRegClass(),
   /// setRegBank() or setSize() has been called on it.
-  unsigned createIncompleteVirtualRegister(StringRef Name = "");
+  Register createIncompleteVirtualRegister(StringRef Name = "");
 
   /// getNumVirtRegs - Return the number of virtual registers created.
   unsigned getNumVirtRegs() const { return VRegInfo.size(); }
@@ -759,8 +768,8 @@
   /// setRegAllocationHint - Specify a register allocation hint for the
   /// specified virtual register. This is typically used by target, and in case
   /// of an earlier hint it will be overwritten.
-  void setRegAllocationHint(unsigned VReg, unsigned Type, unsigned PrefReg) {
-    assert(TargetRegisterInfo::isVirtualRegister(VReg));
+  void setRegAllocationHint(Register VReg, unsigned Type, Register PrefReg) {
+    assert(VReg.isVirtual());
     RegAllocHints[VReg].first  = Type;
     RegAllocHints[VReg].second.clear();
     RegAllocHints[VReg].second.push_back(PrefReg);
@@ -768,19 +777,19 @@
 
   /// addRegAllocationHint - Add a register allocation hint to the hints
   /// vector for VReg.
-  void addRegAllocationHint(unsigned VReg, unsigned PrefReg) {
-    assert(TargetRegisterInfo::isVirtualRegister(VReg));
+  void addRegAllocationHint(Register VReg, Register PrefReg) {
+    assert(Register::isVirtualRegister(VReg));
     RegAllocHints[VReg].second.push_back(PrefReg);
   }
 
   /// Specify the preferred (target independent) register allocation hint for
   /// the specified virtual register.
-  void setSimpleHint(unsigned VReg, unsigned PrefReg) {
+  void setSimpleHint(Register VReg, Register PrefReg) {
     setRegAllocationHint(VReg, /*Type=*/0, PrefReg);
   }
 
-  void clearSimpleHint(unsigned VReg) {
-    assert (RegAllocHints[VReg].first == 0 &&
+  void clearSimpleHint(Register VReg) {
+    assert (!RegAllocHints[VReg].first &&
             "Expected to clear a non-target hint!");
     RegAllocHints[VReg].second.clear();
   }
@@ -788,34 +797,46 @@
   /// getRegAllocationHint - Return the register allocation hint for the
   /// specified virtual register. If there are many hints, this returns the
   /// one with the greatest weight.
-  std::pair<unsigned, unsigned>
-  getRegAllocationHint(unsigned VReg) const {
-    assert(TargetRegisterInfo::isVirtualRegister(VReg));
-    unsigned BestHint = (RegAllocHints[VReg].second.size() ?
-                         RegAllocHints[VReg].second[0] : 0);
-    return std::pair<unsigned, unsigned>(RegAllocHints[VReg].first, BestHint);
+  std::pair<Register, Register>
+  getRegAllocationHint(Register VReg) const {
+    assert(VReg.isVirtual());
+    Register BestHint = (RegAllocHints[VReg.id()].second.size() ?
+                         RegAllocHints[VReg.id()].second[0] : Register());
+    return std::pair<Register, Register>(RegAllocHints[VReg.id()].first,
+                                         BestHint);
   }
 
   /// getSimpleHint - same as getRegAllocationHint except it will only return
   /// a target independent hint.
-  unsigned getSimpleHint(unsigned VReg) const {
-    assert(TargetRegisterInfo::isVirtualRegister(VReg));
-    std::pair<unsigned, unsigned> Hint = getRegAllocationHint(VReg);
-    return Hint.first ? 0 : Hint.second;
+  Register getSimpleHint(Register VReg) const {
+    assert(VReg.isVirtual());
+    std::pair<Register, Register> Hint = getRegAllocationHint(VReg);
+    return Hint.first ? Register() : Hint.second;
   }
 
   /// getRegAllocationHints - Return a reference to the vector of all
   /// register allocation hints for VReg.
-  const std::pair<unsigned, SmallVector<unsigned, 4>>
-  &getRegAllocationHints(unsigned VReg) const {
-    assert(TargetRegisterInfo::isVirtualRegister(VReg));
+  const std::pair<Register, SmallVector<Register, 4>>
+  &getRegAllocationHints(Register VReg) const {
+    assert(VReg.isVirtual());
     return RegAllocHints[VReg];
   }
 
   /// markUsesInDebugValueAsUndef - Mark every DBG_VALUE referencing the
   /// specified register as undefined which causes the DBG_VALUE to be
   /// deleted during LiveDebugVariables analysis.
-  void markUsesInDebugValueAsUndef(unsigned Reg) const;
+  void markUsesInDebugValueAsUndef(Register Reg) const;
+
+  /// updateDbgUsersToReg - Update a collection of DBG_VALUE instructions
+  /// to refer to the designated register.
+  void updateDbgUsersToReg(Register Reg,
+                           ArrayRef<MachineInstr*> Users) const {
+    for (MachineInstr *MI : Users) {
+      assert(MI->isDebugInstr());
+      assert(MI->getOperand(0).isReg());
+      MI->getOperand(0).setReg(Reg);
+    }
+  }
 
   /// Return true if the specified register is modified in this function.
   /// This checks that no defining machine operands exist for the register or
@@ -823,13 +844,13 @@
   /// ignored, to consider them pass 'true' for optional parameter
   /// SkipNoReturnDef. The register is also considered modified when it is set
   /// in the UsedPhysRegMask.
-  bool isPhysRegModified(unsigned PhysReg, bool SkipNoReturnDef = false) const;
+  bool isPhysRegModified(MCRegister PhysReg, bool SkipNoReturnDef = false) const;
 
   /// Return true if the specified register is modified or read in this
   /// function. This checks that no machine operands exist for the register or
   /// any of its aliases. The register is also considered used when it is set
   /// in the UsedPhysRegMask.
-  bool isPhysRegUsed(unsigned PhysReg) const;
+  bool isPhysRegUsed(MCRegister PhysReg) const;
 
   /// addPhysRegsUsedFromRegMask - Mark any registers not in RegMask as used.
   /// This corresponds to the bit mask attached to register mask operands.
@@ -864,7 +885,7 @@
   /// canReserveReg - Returns true if PhysReg can be used as a reserved
   /// register.  Any register can be reserved before freezeReservedRegs() is
   /// called.
-  bool canReserveReg(unsigned PhysReg) const {
+  bool canReserveReg(MCRegister PhysReg) const {
     return !reservedRegsFrozen() || ReservedRegs.test(PhysReg);
   }
 
@@ -882,8 +903,8 @@
   ///
   /// Reserved registers may belong to an allocatable register class, but the
   /// target has explicitly requested that they are not used.
-  bool isReserved(unsigned PhysReg) const {
-    return getReservedRegs().test(PhysReg);
+  bool isReserved(MCRegister PhysReg) const {
+    return getReservedRegs().test(PhysReg.id());
   }
 
   /// Returns true when the given register unit is considered reserved.
@@ -900,7 +921,7 @@
   /// Allocatable registers may show up in the allocation order of some virtual
   /// register, so a register allocator needs to track its liveness and
   /// availability.
-  bool isAllocatable(unsigned PhysReg) const {
+  bool isAllocatable(MCRegister PhysReg) const {
     return getTargetRegisterInfo()->isInAllocatableClass(PhysReg) &&
       !isReserved(PhysReg);
   }
@@ -911,31 +932,31 @@
 
   /// addLiveIn - Add the specified register as a live-in.  Note that it
   /// is an error to add the same register to the same set more than once.
-  void addLiveIn(unsigned Reg, unsigned vreg = 0) {
+  void addLiveIn(MCRegister Reg, Register vreg = Register()) {
     LiveIns.push_back(std::make_pair(Reg, vreg));
   }
 
   // Iteration support for the live-ins set.  It's kept in sorted order
   // by register number.
   using livein_iterator =
-      std::vector<std::pair<unsigned,unsigned>>::const_iterator;
+      std::vector<std::pair<MCRegister,Register>>::const_iterator;
   livein_iterator livein_begin() const { return LiveIns.begin(); }
   livein_iterator livein_end()   const { return LiveIns.end(); }
   bool            livein_empty() const { return LiveIns.empty(); }
 
-  ArrayRef<std::pair<unsigned, unsigned>> liveins() const {
+  ArrayRef<std::pair<MCRegister, Register>> liveins() const {
     return LiveIns;
   }
 
-  bool isLiveIn(unsigned Reg) const;
+  bool isLiveIn(Register Reg) const;
 
   /// getLiveInPhysReg - If VReg is a live-in virtual register, return the
   /// corresponding live-in physical register.
-  unsigned getLiveInPhysReg(unsigned VReg) const;
+  MCRegister getLiveInPhysReg(Register VReg) const;
 
   /// getLiveInVirtReg - If PReg is a live-in physical register, return the
   /// corresponding live-in physical register.
-  unsigned getLiveInVirtReg(unsigned PReg) const;
+  Register getLiveInVirtReg(MCRegister PReg) const;
 
   /// EmitLiveInCopies - Emit copies to initialize livein virtual registers
   /// into the given entry block.
@@ -945,7 +966,7 @@
 
   /// Returns a mask covering all bits that can appear in lane masks of
   /// subregisters of the virtual register @p Reg.
-  LaneBitmask getMaxLaneMaskForVReg(unsigned Reg) const;
+  LaneBitmask getMaxLaneMaskForVReg(Register Reg) const;
 
   /// defusechain_iterator - This class provides iterator support for machine
   /// operands in the function that use or define a specific register.  If
@@ -1162,14 +1183,13 @@
 public:
   PSetIterator() = default;
 
-  PSetIterator(unsigned RegUnit, const MachineRegisterInfo *MRI) {
+  PSetIterator(Register RegUnit, const MachineRegisterInfo *MRI) {
     const TargetRegisterInfo *TRI = MRI->getTargetRegisterInfo();
-    if (TargetRegisterInfo::isVirtualRegister(RegUnit)) {
+    if (RegUnit.isVirtual()) {
       const TargetRegisterClass *RC = MRI->getRegClass(RegUnit);
       PSet = TRI->getRegClassPressureSets(RC);
       Weight = TRI->getRegClassWeight(RC).RegWeight;
-    }
-    else {
+    } else {
       PSet = TRI->getRegUnitPressureSets(RegUnit);
       Weight = TRI->getRegUnitWeight(RegUnit);
     }
@@ -1191,8 +1211,8 @@
   }
 };
 
-inline PSetIterator MachineRegisterInfo::
-getPressureSets(unsigned RegUnit) const {
+inline PSetIterator
+MachineRegisterInfo::getPressureSets(Register RegUnit) const {
   return PSetIterator(RegUnit, this);
 }
 
diff --git a/linux-x64/clang/include/llvm/CodeGen/MachineSSAUpdater.h b/linux-x64/clang/include/llvm/CodeGen/MachineSSAUpdater.h
index 0319ec7..0af356e 100644
--- a/linux-x64/clang/include/llvm/CodeGen/MachineSSAUpdater.h
+++ b/linux-x64/clang/include/llvm/CodeGen/MachineSSAUpdater.h
@@ -13,6 +13,8 @@
 #ifndef LLVM_CODEGEN_MACHINESSAUPDATER_H
 #define LLVM_CODEGEN_MACHINESSAUPDATER_H
 
+#include "llvm/CodeGen/Register.h"
+
 namespace llvm {
 
 class MachineBasicBlock;
@@ -35,12 +37,9 @@
 private:
   /// AvailableVals - This keeps track of which value to use on a per-block
   /// basis.  When we insert PHI nodes, we keep track of them here.
-  //typedef DenseMap<MachineBasicBlock*, unsigned > AvailableValsTy;
+  //typedef DenseMap<MachineBasicBlock*, Register> AvailableValsTy;
   void *AV = nullptr;
 
-  /// VR - Current virtual register whose uses are being updated.
-  unsigned VR;
-
   /// VRC - Register class of the current virtual register.
   const TargetRegisterClass *VRC;
 
@@ -62,11 +61,12 @@
 
   /// Initialize - Reset this object to get ready for a new set of SSA
   /// updates.
-  void Initialize(unsigned V);
+  void Initialize(Register V);
+  void Initialize(const TargetRegisterClass *RC);
 
   /// AddAvailableValue - Indicate that a rewritten value is available at the
   /// end of the specified block with the specified value.
-  void AddAvailableValue(MachineBasicBlock *BB, unsigned V);
+  void AddAvailableValue(MachineBasicBlock *BB, Register V);
 
   /// HasValueForBlock - Return true if the MachineSSAUpdater already has a
   /// value for the specified block.
@@ -74,7 +74,7 @@
 
   /// GetValueAtEndOfBlock - Construct SSA form, materializing a value that is
   /// live at the end of the specified block.
-  unsigned GetValueAtEndOfBlock(MachineBasicBlock *BB);
+  Register GetValueAtEndOfBlock(MachineBasicBlock *BB);
 
   /// GetValueInMiddleOfBlock - Construct SSA form, materializing a value that
   /// is live in the middle of the specified block.
@@ -94,7 +94,7 @@
   /// their respective blocks.  However, the use of X happens in the *middle* of
   /// a block.  Because of this, we need to insert a new PHI node in SomeBB to
   /// merge the appropriate values, and this value isn't live out of the block.
-  unsigned GetValueInMiddleOfBlock(MachineBasicBlock *BB);
+  Register GetValueInMiddleOfBlock(MachineBasicBlock *BB);
 
   /// RewriteUse - Rewrite a use of the symbolic value.  This handles PHI nodes,
   /// which use their value in the corresponding predecessor.  Note that this
@@ -104,7 +104,7 @@
   void RewriteUse(MachineOperand &U);
 
 private:
-  unsigned GetValueAtEndOfBlockInternal(MachineBasicBlock *BB);
+  Register GetValueAtEndOfBlockInternal(MachineBasicBlock *BB);
 };
 
 } // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/CodeGen/MachineScheduler.h b/linux-x64/clang/include/llvm/CodeGen/MachineScheduler.h
index 75a334f..a7edaaa 100644
--- a/linux-x64/clang/include/llvm/CodeGen/MachineScheduler.h
+++ b/linux-x64/clang/include/llvm/CodeGen/MachineScheduler.h
@@ -80,7 +80,6 @@
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
-#include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/CodeGen/MachineBasicBlock.h"
 #include "llvm/CodeGen/MachinePassRegistry.h"
 #include "llvm/CodeGen/RegisterPressure.h"
@@ -100,7 +99,9 @@
 
 extern cl::opt<bool> ForceTopDown;
 extern cl::opt<bool> ForceBottomUp;
+extern cl::opt<bool> VerifyScheduling;
 
+class AAResults;
 class LiveIntervals;
 class MachineDominatorTree;
 class MachineFunction;
@@ -120,7 +121,7 @@
   const MachineLoopInfo *MLI = nullptr;
   const MachineDominatorTree *MDT = nullptr;
   const TargetPassConfig *PassConfig = nullptr;
-  AliasAnalysis *AA = nullptr;
+  AAResults *AA = nullptr;
   LiveIntervals *LIS = nullptr;
 
   RegisterClassInfo *RegClassInfo;
@@ -185,6 +186,9 @@
   // first.
   bool DisableLatencyHeuristic = false;
 
+  // Compute DFSResult for use in scheduling heuristics.
+  bool ComputeDFSResult = false;
+
   MachineSchedPolicy() = default;
 };
 
@@ -260,7 +264,7 @@
 /// PreRA and PostRA MachineScheduler.
 class ScheduleDAGMI : public ScheduleDAGInstrs {
 protected:
-  AliasAnalysis *AA;
+  AAResults *AA;
   LiveIntervals *LIS;
   std::unique_ptr<MachineSchedStrategy> SchedImpl;
 
@@ -756,7 +760,16 @@
 
   unsigned getOtherResourceCount(unsigned &OtherCritIdx);
 
-  void releaseNode(SUnit *SU, unsigned ReadyCycle);
+  /// Release SU to make it ready. If it's not in hazard, remove it from
+  /// pending queue (if already in) and push into available queue.
+  /// Otherwise, push the SU into pending queue.
+  ///
+  /// @param SU The unit to be released.
+  /// @param ReadyCycle Until which cycle the unit is ready.
+  /// @param InPQueue Whether SU is already in pending queue.
+  /// @param Idx Position offset in pending queue (if in it).
+  void releaseNode(SUnit *SU, unsigned ReadyCycle, bool InPQueue,
+                   unsigned Idx = 0);
 
   void bumpCycle(unsigned NextCycle);
 
@@ -954,7 +967,7 @@
     if (SU->isScheduled)
       return;
 
-    Top.releaseNode(SU, SU->TopReadyCycle);
+    Top.releaseNode(SU, SU->TopReadyCycle, false);
     TopCand.SU = nullptr;
   }
 
@@ -962,7 +975,7 @@
     if (SU->isScheduled)
       return;
 
-    Bot.releaseNode(SU, SU->BotReadyCycle);
+    Bot.releaseNode(SU, SU->BotReadyCycle, false);
     BotCand.SU = nullptr;
   }
 
@@ -1008,7 +1021,7 @@
 ///   initPolicy -> initialize(DAG) -> registerRoots -> pickNode ...
 class PostGenericScheduler : public GenericSchedulerBase {
 protected:
-  ScheduleDAGMI *DAG;
+  ScheduleDAGMI *DAG = nullptr;
   SchedBoundary Top;
   SmallVector<SUnit*, 8> BotRoots;
 
@@ -1042,7 +1055,7 @@
   void releaseTopNode(SUnit *SU) override {
     if (SU->isScheduled)
       return;
-    Top.releaseNode(SU, SU->TopReadyCycle);
+    Top.releaseNode(SU, SU->TopReadyCycle, false);
   }
 
   // Only called for roots.
@@ -1051,7 +1064,7 @@
   }
 
 protected:
-  void tryCandidate(SchedCandidate &Cand, SchedCandidate &TryCand);
+  virtual void tryCandidate(SchedCandidate &Cand, SchedCandidate &TryCand);
 
   void pickNodeFromQueue(SchedCandidate &Cand);
 };
diff --git a/linux-x64/clang/include/llvm/CodeGen/MachineSizeOpts.h b/linux-x64/clang/include/llvm/CodeGen/MachineSizeOpts.h
new file mode 100644
index 0000000..07bbbad
--- /dev/null
+++ b/linux-x64/clang/include/llvm/CodeGen/MachineSizeOpts.h
@@ -0,0 +1,46 @@
+//===- MachineSizeOpts.h - machine size optimization ------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains some shared machine IR code size optimization related
+// code.
+//
+//===----------------------------------------------------------------------===//
+#ifndef LLVM_CODEGEN_MACHINE_SIZEOPTS_H
+#define LLVM_CODEGEN_MACHINE_SIZEOPTS_H
+
+#include "llvm/Transforms/Utils/SizeOpts.h"
+
+namespace llvm {
+
+class ProfileSummaryInfo;
+class MachineBasicBlock;
+class MachineBlockFrequencyInfo;
+class MachineFunction;
+class MBFIWrapper;
+
+/// Returns true if machine function \p MF is suggested to be size-optimized
+/// based on the profile.
+bool shouldOptimizeForSize(const MachineFunction *MF, ProfileSummaryInfo *PSI,
+                           const MachineBlockFrequencyInfo *BFI,
+                           PGSOQueryType QueryType = PGSOQueryType::Other);
+/// Returns true if machine basic block \p MBB is suggested to be size-optimized
+/// based on the profile.
+bool shouldOptimizeForSize(const MachineBasicBlock *MBB,
+                           ProfileSummaryInfo *PSI,
+                           const MachineBlockFrequencyInfo *MBFI,
+                           PGSOQueryType QueryType = PGSOQueryType::Other);
+/// Returns true if machine basic block \p MBB is suggested to be size-optimized
+/// based on the profile.
+bool shouldOptimizeForSize(const MachineBasicBlock *MBB,
+                           ProfileSummaryInfo *PSI,
+                           MBFIWrapper *MBFIWrapper,
+                           PGSOQueryType QueryType = PGSOQueryType::Other);
+
+} // end namespace llvm
+
+#endif // LLVM_CODEGEN_MACHINE_SIZEOPTS_H
diff --git a/linux-x64/clang/include/llvm/CodeGen/MachineStableHash.h b/linux-x64/clang/include/llvm/CodeGen/MachineStableHash.h
new file mode 100644
index 0000000..8423b2d
--- /dev/null
+++ b/linux-x64/clang/include/llvm/CodeGen/MachineStableHash.h
@@ -0,0 +1,30 @@
+//===------------ MachineStableHash.h - MIR Stable Hashing Utilities ------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Stable hashing for MachineInstr and MachineOperand. Useful or getting a
+// hash across runs, modules, etc.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CODEGEN_MACHINESTABLEHASH_H
+#define LLVM_CODEGEN_MACHINESTABLEHASH_H
+
+#include "llvm/CodeGen/StableHashing.h"
+
+namespace llvm {
+class MachineInstr;
+class MachineOperand;
+
+stable_hash stableHashValue(const MachineOperand &MO);
+stable_hash stableHashValue(const MachineInstr &MI, bool HashVRegs = false,
+                            bool HashConstantPoolIndices = false,
+                            bool HashMemOperands = false);
+
+} // namespace llvm
+
+#endif
diff --git a/linux-x64/clang/include/llvm/CodeGen/MachineTraceMetrics.h b/linux-x64/clang/include/llvm/CodeGen/MachineTraceMetrics.h
index 0259895..46b5736 100644
--- a/linux-x64/clang/include/llvm/CodeGen/MachineTraceMetrics.h
+++ b/linux-x64/clang/include/llvm/CodeGen/MachineTraceMetrics.h
@@ -140,13 +140,13 @@
   /// successors.
   struct LiveInReg {
     /// The virtual register required, or a register unit.
-    unsigned Reg;
+    Register Reg;
 
     /// For virtual registers: Minimum height of the defining instruction.
     /// For regunits: Height of the highest user in the trace.
     unsigned Height;
 
-    LiveInReg(unsigned Reg, unsigned Height = 0) : Reg(Reg), Height(Height) {}
+    LiveInReg(Register Reg, unsigned Height = 0) : Reg(Reg), Height(Height) {}
   };
 
   /// Per-basic block information that relates to a specific trace through the
diff --git a/linux-x64/clang/include/llvm/CodeGen/ModuloSchedule.h b/linux-x64/clang/include/llvm/CodeGen/ModuloSchedule.h
new file mode 100644
index 0000000..1aa2320
--- /dev/null
+++ b/linux-x64/clang/include/llvm/CodeGen/ModuloSchedule.h
@@ -0,0 +1,389 @@
+//===- ModuloSchedule.h - Software pipeline schedule expansion ------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Software pipelining (SWP) is an instruction scheduling technique for loops
+// that overlaps loop iterations and exploits ILP via compiler transformations.
+//
+// There are multiple methods for analyzing a loop and creating a schedule.
+// An example algorithm is Swing Modulo Scheduling (implemented by the
+// MachinePipeliner). The details of how a schedule is arrived at are irrelevant
+// for the task of actually rewriting a loop to adhere to the schedule, which
+// is what this file does.
+//
+// A schedule is, for every instruction in a block, a Cycle and a Stage. Note
+// that we only support single-block loops, so "block" and "loop" can be used
+// interchangably.
+//
+// The Cycle of an instruction defines a partial order of the instructions in
+// the remapped loop. Instructions within a cycle must not consume the output
+// of any instruction in the same cycle. Cycle information is assumed to have
+// been calculated such that the processor will execute instructions in
+// lock-step (for example in a VLIW ISA).
+//
+// The Stage of an instruction defines the mapping between logical loop
+// iterations and pipelined loop iterations. An example (unrolled) pipeline
+// may look something like:
+//
+//  I0[0]                      Execute instruction I0 of iteration 0
+//  I1[0], I0[1]               Execute I0 of iteration 1 and I1 of iteration 1
+//         I1[1], I0[2]
+//                I1[2], I0[3]
+//
+// In the schedule for this unrolled sequence we would say that I0 was scheduled
+// in stage 0 and I1 in stage 1:
+//
+//  loop:
+//    [stage 0] x = I0
+//    [stage 1] I1 x (from stage 0)
+//
+// And to actually generate valid code we must insert a phi:
+//
+//  loop:
+//    x' = phi(x)
+//    x = I0
+//    I1 x'
+//
+// This is a simple example; the rules for how to generate correct code given
+// an arbitrary schedule containing loop-carried values are complex.
+//
+// Note that these examples only mention the steady-state kernel of the
+// generated loop; prologs and epilogs must be generated also that prime and
+// flush the pipeline. Doing so is nontrivial.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIB_CODEGEN_MODULOSCHEDULE_H
+#define LLVM_LIB_CODEGEN_MODULOSCHEDULE_H
+
+#include "llvm/CodeGen/MachineFunction.h"
+#include "llvm/CodeGen/MachineLoopInfo.h"
+#include "llvm/CodeGen/MachineLoopUtils.h"
+#include "llvm/CodeGen/TargetInstrInfo.h"
+#include "llvm/CodeGen/TargetSubtargetInfo.h"
+#include <deque>
+#include <vector>
+
+namespace llvm {
+class MachineBasicBlock;
+class MachineInstr;
+class LiveIntervals;
+
+/// Represents a schedule for a single-block loop. For every instruction we
+/// maintain a Cycle and Stage.
+class ModuloSchedule {
+private:
+  /// The block containing the loop instructions.
+  MachineLoop *Loop;
+
+  /// The instructions to be generated, in total order. Cycle provides a partial
+  /// order; the total order within cycles has been decided by the schedule
+  /// producer.
+  std::vector<MachineInstr *> ScheduledInstrs;
+
+  /// The cycle for each instruction.
+  DenseMap<MachineInstr *, int> Cycle;
+
+  /// The stage for each instruction.
+  DenseMap<MachineInstr *, int> Stage;
+
+  /// The number of stages in this schedule (Max(Stage) + 1).
+  int NumStages;
+
+public:
+  /// Create a new ModuloSchedule.
+  /// \arg ScheduledInstrs The new loop instructions, in total resequenced
+  ///    order.
+  /// \arg Cycle Cycle index for all instructions in ScheduledInstrs. Cycle does
+  ///    not need to start at zero. ScheduledInstrs must be partially ordered by
+  ///    Cycle.
+  /// \arg Stage Stage index for all instructions in ScheduleInstrs.
+  ModuloSchedule(MachineFunction &MF, MachineLoop *Loop,
+                 std::vector<MachineInstr *> ScheduledInstrs,
+                 DenseMap<MachineInstr *, int> Cycle,
+                 DenseMap<MachineInstr *, int> Stage)
+      : Loop(Loop), ScheduledInstrs(ScheduledInstrs), Cycle(std::move(Cycle)),
+        Stage(std::move(Stage)) {
+    NumStages = 0;
+    for (auto &KV : this->Stage)
+      NumStages = std::max(NumStages, KV.second);
+    ++NumStages;
+  }
+
+  /// Return the single-block loop being scheduled.
+  MachineLoop *getLoop() const { return Loop; }
+
+  /// Return the number of stages contained in this schedule, which is the
+  /// largest stage index + 1.
+  int getNumStages() const { return NumStages; }
+
+  /// Return the first cycle in the schedule, which is the cycle index of the
+  /// first instruction.
+  int getFirstCycle() { return Cycle[ScheduledInstrs.front()]; }
+
+  /// Return the final cycle in the schedule, which is the cycle index of the
+  /// last instruction.
+  int getFinalCycle() { return Cycle[ScheduledInstrs.back()]; }
+
+  /// Return the stage that MI is scheduled in, or -1.
+  int getStage(MachineInstr *MI) {
+    auto I = Stage.find(MI);
+    return I == Stage.end() ? -1 : I->second;
+  }
+
+  /// Return the cycle that MI is scheduled at, or -1.
+  int getCycle(MachineInstr *MI) {
+    auto I = Cycle.find(MI);
+    return I == Cycle.end() ? -1 : I->second;
+  }
+
+  /// Set the stage of a newly created instruction.
+  void setStage(MachineInstr *MI, int MIStage) {
+    assert(Stage.count(MI) == 0);
+    Stage[MI] = MIStage;
+  }
+
+  /// Return the rescheduled instructions in order.
+  ArrayRef<MachineInstr *> getInstructions() { return ScheduledInstrs; }
+
+  void dump() { print(dbgs()); }
+  void print(raw_ostream &OS);
+};
+
+/// The ModuloScheduleExpander takes a ModuloSchedule and expands it in-place,
+/// rewriting the old loop and inserting prologs and epilogs as required.
+class ModuloScheduleExpander {
+public:
+  using InstrChangesTy = DenseMap<MachineInstr *, std::pair<unsigned, int64_t>>;
+
+private:
+  using ValueMapTy = DenseMap<unsigned, unsigned>;
+  using MBBVectorTy = SmallVectorImpl<MachineBasicBlock *>;
+  using InstrMapTy = DenseMap<MachineInstr *, MachineInstr *>;
+
+  ModuloSchedule &Schedule;
+  MachineFunction &MF;
+  const TargetSubtargetInfo &ST;
+  MachineRegisterInfo &MRI;
+  const TargetInstrInfo *TII;
+  LiveIntervals &LIS;
+
+  MachineBasicBlock *BB;
+  MachineBasicBlock *Preheader;
+  MachineBasicBlock *NewKernel = nullptr;
+  std::unique_ptr<TargetInstrInfo::PipelinerLoopInfo> LoopInfo;
+
+  /// Map for each register and the max difference between its uses and def.
+  /// The first element in the pair is the max difference in stages. The
+  /// second is true if the register defines a Phi value and loop value is
+  /// scheduled before the Phi.
+  std::map<unsigned, std::pair<unsigned, bool>> RegToStageDiff;
+
+  /// Instructions to change when emitting the final schedule.
+  InstrChangesTy InstrChanges;
+
+  void generatePipelinedLoop();
+  void generateProlog(unsigned LastStage, MachineBasicBlock *KernelBB,
+                      ValueMapTy *VRMap, MBBVectorTy &PrologBBs);
+  void generateEpilog(unsigned LastStage, MachineBasicBlock *KernelBB,
+                      ValueMapTy *VRMap, MBBVectorTy &EpilogBBs,
+                      MBBVectorTy &PrologBBs);
+  void generateExistingPhis(MachineBasicBlock *NewBB, MachineBasicBlock *BB1,
+                            MachineBasicBlock *BB2, MachineBasicBlock *KernelBB,
+                            ValueMapTy *VRMap, InstrMapTy &InstrMap,
+                            unsigned LastStageNum, unsigned CurStageNum,
+                            bool IsLast);
+  void generatePhis(MachineBasicBlock *NewBB, MachineBasicBlock *BB1,
+                    MachineBasicBlock *BB2, MachineBasicBlock *KernelBB,
+                    ValueMapTy *VRMap, InstrMapTy &InstrMap,
+                    unsigned LastStageNum, unsigned CurStageNum, bool IsLast);
+  void removeDeadInstructions(MachineBasicBlock *KernelBB,
+                              MBBVectorTy &EpilogBBs);
+  void splitLifetimes(MachineBasicBlock *KernelBB, MBBVectorTy &EpilogBBs);
+  void addBranches(MachineBasicBlock &PreheaderBB, MBBVectorTy &PrologBBs,
+                   MachineBasicBlock *KernelBB, MBBVectorTy &EpilogBBs,
+                   ValueMapTy *VRMap);
+  bool computeDelta(MachineInstr &MI, unsigned &Delta);
+  void updateMemOperands(MachineInstr &NewMI, MachineInstr &OldMI,
+                         unsigned Num);
+  MachineInstr *cloneInstr(MachineInstr *OldMI, unsigned CurStageNum,
+                           unsigned InstStageNum);
+  MachineInstr *cloneAndChangeInstr(MachineInstr *OldMI, unsigned CurStageNum,
+                                    unsigned InstStageNum);
+  void updateInstruction(MachineInstr *NewMI, bool LastDef,
+                         unsigned CurStageNum, unsigned InstrStageNum,
+                         ValueMapTy *VRMap);
+  MachineInstr *findDefInLoop(unsigned Reg);
+  unsigned getPrevMapVal(unsigned StageNum, unsigned PhiStage, unsigned LoopVal,
+                         unsigned LoopStage, ValueMapTy *VRMap,
+                         MachineBasicBlock *BB);
+  void rewritePhiValues(MachineBasicBlock *NewBB, unsigned StageNum,
+                        ValueMapTy *VRMap, InstrMapTy &InstrMap);
+  void rewriteScheduledInstr(MachineBasicBlock *BB, InstrMapTy &InstrMap,
+                             unsigned CurStageNum, unsigned PhiNum,
+                             MachineInstr *Phi, unsigned OldReg,
+                             unsigned NewReg, unsigned PrevReg = 0);
+  bool isLoopCarried(MachineInstr &Phi);
+
+  /// Return the max. number of stages/iterations that can occur between a
+  /// register definition and its uses.
+  unsigned getStagesForReg(int Reg, unsigned CurStage) {
+    std::pair<unsigned, bool> Stages = RegToStageDiff[Reg];
+    if ((int)CurStage > Schedule.getNumStages() - 1 && Stages.first == 0 &&
+        Stages.second)
+      return 1;
+    return Stages.first;
+  }
+
+  /// The number of stages for a Phi is a little different than other
+  /// instructions. The minimum value computed in RegToStageDiff is 1
+  /// because we assume the Phi is needed for at least 1 iteration.
+  /// This is not the case if the loop value is scheduled prior to the
+  /// Phi in the same stage.  This function returns the number of stages
+  /// or iterations needed between the Phi definition and any uses.
+  unsigned getStagesForPhi(int Reg) {
+    std::pair<unsigned, bool> Stages = RegToStageDiff[Reg];
+    if (Stages.second)
+      return Stages.first;
+    return Stages.first - 1;
+  }
+
+public:
+  /// Create a new ModuloScheduleExpander.
+  /// \arg InstrChanges Modifications to make to instructions with memory
+  ///   operands.
+  /// FIXME: InstrChanges is opaque and is an implementation detail of an
+  ///   optimization in MachinePipeliner that crosses abstraction boundaries.
+  ModuloScheduleExpander(MachineFunction &MF, ModuloSchedule &S,
+                         LiveIntervals &LIS, InstrChangesTy InstrChanges)
+      : Schedule(S), MF(MF), ST(MF.getSubtarget()), MRI(MF.getRegInfo()),
+        TII(ST.getInstrInfo()), LIS(LIS),
+        InstrChanges(std::move(InstrChanges)) {}
+
+  /// Performs the actual expansion.
+  void expand();
+  /// Performs final cleanup after expansion.
+  void cleanup();
+
+  /// Returns the newly rewritten kernel block, or nullptr if this was
+  /// optimized away.
+  MachineBasicBlock *getRewrittenKernel() { return NewKernel; }
+};
+
+/// A reimplementation of ModuloScheduleExpander. It works by generating a
+/// standalone kernel loop and peeling out the prologs and epilogs.
+class PeelingModuloScheduleExpander {
+public:
+  PeelingModuloScheduleExpander(MachineFunction &MF, ModuloSchedule &S,
+                                LiveIntervals *LIS)
+      : Schedule(S), MF(MF), ST(MF.getSubtarget()), MRI(MF.getRegInfo()),
+        TII(ST.getInstrInfo()), LIS(LIS) {}
+
+  void expand();
+
+  /// Runs ModuloScheduleExpander and treats it as a golden input to validate
+  /// aspects of the code generated by PeelingModuloScheduleExpander.
+  void validateAgainstModuloScheduleExpander();
+
+protected:
+  ModuloSchedule &Schedule;
+  MachineFunction &MF;
+  const TargetSubtargetInfo &ST;
+  MachineRegisterInfo &MRI;
+  const TargetInstrInfo *TII;
+  LiveIntervals *LIS;
+
+  /// The original loop block that gets rewritten in-place.
+  MachineBasicBlock *BB;
+  /// The original loop preheader.
+  MachineBasicBlock *Preheader;
+  /// All prolog and epilog blocks.
+  SmallVector<MachineBasicBlock *, 4> Prologs, Epilogs;
+  /// For every block, the stages that are produced.
+  DenseMap<MachineBasicBlock *, BitVector> LiveStages;
+  /// For every block, the stages that are available. A stage can be available
+  /// but not produced (in the epilog) or produced but not available (in the
+  /// prolog).
+  DenseMap<MachineBasicBlock *, BitVector> AvailableStages;
+  /// When peeling the epilogue keep track of the distance between the phi
+  /// nodes and the kernel.
+  DenseMap<MachineInstr *, unsigned> PhiNodeLoopIteration;
+
+  /// CanonicalMIs and BlockMIs form a bidirectional map between any of the
+  /// loop kernel clones.
+  DenseMap<MachineInstr *, MachineInstr *> CanonicalMIs;
+  DenseMap<std::pair<MachineBasicBlock *, MachineInstr *>, MachineInstr *>
+      BlockMIs;
+
+  /// State passed from peelKernel to peelPrologAndEpilogs().
+  std::deque<MachineBasicBlock *> PeeledFront, PeeledBack;
+  /// Illegal phis that need to be deleted once we re-link stages.
+  SmallVector<MachineInstr *, 4> IllegalPhisToDelete;
+
+  /// Converts BB from the original loop body to the rewritten, pipelined
+  /// steady-state.
+  void rewriteKernel();
+
+  /// Peels one iteration of the rewritten kernel (BB) in the specified
+  /// direction.
+  MachineBasicBlock *peelKernel(LoopPeelDirection LPD);
+  // Delete instructions whose stage is less than MinStage in the given basic
+  // block.
+  void filterInstructions(MachineBasicBlock *MB, int MinStage);
+  // Move instructions of the given stage from sourceBB to DestBB. Remap the phi
+  // instructions to keep a valid IR.
+  void moveStageBetweenBlocks(MachineBasicBlock *DestBB,
+                              MachineBasicBlock *SourceBB, unsigned Stage);
+  /// Peel the kernel forwards and backwards to produce prologs and epilogs,
+  /// and stitch them together.
+  void peelPrologAndEpilogs();
+  /// All prolog and epilog blocks are clones of the kernel, so any produced
+  /// register in one block has an corollary in all other blocks.
+  Register getEquivalentRegisterIn(Register Reg, MachineBasicBlock *BB);
+  /// Change all users of MI, if MI is predicated out
+  /// (LiveStages[MI->getParent()] == false).
+  void rewriteUsesOf(MachineInstr *MI);
+  /// Insert branches between prologs, kernel and epilogs.
+  void fixupBranches();
+  /// Create a poor-man's LCSSA by cloning only the PHIs from the kernel block
+  /// to a block dominated by all prologs and epilogs. This allows us to treat
+  /// the loop exiting block as any other kernel clone.
+  MachineBasicBlock *CreateLCSSAExitingBlock();
+  /// Helper to get the stage of an instruction in the schedule.
+  unsigned getStage(MachineInstr *MI) {
+    if (CanonicalMIs.count(MI))
+      MI = CanonicalMIs[MI];
+    return Schedule.getStage(MI);
+  }
+  /// Helper function to find the right canonical register for a phi instruction
+  /// coming from a peeled out prologue.
+  Register getPhiCanonicalReg(MachineInstr* CanonicalPhi, MachineInstr* Phi);
+  /// Target loop info before kernel peeling.
+  std::unique_ptr<TargetInstrInfo::PipelinerLoopInfo> LoopInfo;
+};
+
+/// Expander that simply annotates each scheduled instruction with a post-instr
+/// symbol that can be consumed by the ModuloScheduleTest pass.
+///
+/// The post-instr symbol is a way of annotating an instruction that can be
+/// roundtripped in MIR. The syntax is:
+///   MYINST %0, post-instr-symbol <mcsymbol Stage-1_Cycle-5>
+class ModuloScheduleTestAnnotater {
+  MachineFunction &MF;
+  ModuloSchedule &S;
+
+public:
+  ModuloScheduleTestAnnotater(MachineFunction &MF, ModuloSchedule &S)
+      : MF(MF), S(S) {}
+
+  /// Performs the annotation.
+  void annotate();
+};
+
+} // end namespace llvm
+
+#endif // LLVM_LIB_CODEGEN_MODULOSCHEDULE_H
diff --git a/linux-x64/clang/include/llvm/CodeGen/MultiHazardRecognizer.h b/linux-x64/clang/include/llvm/CodeGen/MultiHazardRecognizer.h
new file mode 100644
index 0000000..9846045
--- /dev/null
+++ b/linux-x64/clang/include/llvm/CodeGen/MultiHazardRecognizer.h
@@ -0,0 +1,47 @@
+//=- llvm/CodeGen/MultiHazardRecognizer.h - Scheduling Support ----*- C++ -*-=//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements the MultiHazardRecognizer class, which is a wrapper
+// for a set of ScheduleHazardRecognizer instances
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CODEGEN_MULTIHAZARDRECOGNIZER_H
+#define LLVM_CODEGEN_MULTIHAZARDRECOGNIZER_H
+
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/CodeGen/ScheduleHazardRecognizer.h"
+
+namespace llvm {
+
+class MachineInstr;
+class SUnit;
+
+class MultiHazardRecognizer : public ScheduleHazardRecognizer {
+  SmallVector<std::unique_ptr<ScheduleHazardRecognizer>, 4> Recognizers;
+
+public:
+  MultiHazardRecognizer() = default;
+  void AddHazardRecognizer(std::unique_ptr<ScheduleHazardRecognizer> &&);
+
+  bool atIssueLimit() const override;
+  HazardType getHazardType(SUnit *, int Stalls = 0) override;
+  void Reset() override;
+  void EmitInstruction(SUnit *) override;
+  void EmitInstruction(MachineInstr *) override;
+  unsigned PreEmitNoops(SUnit *) override;
+  unsigned PreEmitNoops(MachineInstr *) override;
+  bool ShouldPreferAnother(SUnit *) override;
+  void AdvanceCycle() override;
+  void RecedeCycle() override;
+  void EmitNoop() override;
+};
+
+} // end namespace llvm
+
+#endif // LLVM_CODEGEN_MULTIHAZARDRECOGNIZER_H
diff --git a/linux-x64/clang/include/llvm/CodeGen/NonRelocatableStringpool.h b/linux-x64/clang/include/llvm/CodeGen/NonRelocatableStringpool.h
new file mode 100644
index 0000000..fe07c70
--- /dev/null
+++ b/linux-x64/clang/include/llvm/CodeGen/NonRelocatableStringpool.h
@@ -0,0 +1,83 @@
+//===- NonRelocatableStringpool.h -------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CODEGEN_NONRELOCATABLESTRINGPOOL_H
+#define LLVM_CODEGEN_NONRELOCATABLESTRINGPOOL_H
+
+#include "llvm/CodeGen/DwarfStringPoolEntry.h"
+#include "llvm/Support/Allocator.h"
+#include <cstdint>
+#include <vector>
+
+namespace llvm {
+
+/// A string table that doesn't need relocations.
+///
+/// Use this class when a string table doesn't need relocations.
+/// This class provides this ability by just associating offsets with strings.
+class NonRelocatableStringpool {
+public:
+  /// Entries are stored into the StringMap and simply linked together through
+  /// the second element of this pair in order to keep track of insertion
+  /// order.
+  using MapTy = StringMap<DwarfStringPoolEntry, BumpPtrAllocator>;
+
+  NonRelocatableStringpool(
+      std::function<StringRef(StringRef Input)> Translator = nullptr,
+      bool PutEmptyString = false)
+      : Translator(Translator) {
+    if (PutEmptyString)
+      EmptyString = getEntry("");
+  }
+
+  DwarfStringPoolEntryRef getEntry(StringRef S);
+
+  /// Get the offset of string \p S in the string table. This can insert a new
+  /// element or return the offset of a pre-existing one.
+  uint64_t getStringOffset(StringRef S) { return getEntry(S).getOffset(); }
+
+  /// Get permanent storage for \p S (but do not necessarily emit \p S in the
+  /// output section). A latter call to getStringOffset() with the same string
+  /// will chain it though.
+  ///
+  /// \returns The StringRef that points to permanent storage to use
+  /// in place of \p S.
+  StringRef internString(StringRef S);
+
+  uint64_t getSize() { return CurrentEndOffset; }
+
+  /// Return the list of strings to be emitted. This does not contain the
+  /// strings which were added via internString only.
+  std::vector<DwarfStringPoolEntryRef> getEntriesForEmission() const;
+
+private:
+  MapTy Strings;
+  uint64_t CurrentEndOffset = 0;
+  unsigned NumEntries = 0;
+  DwarfStringPoolEntryRef EmptyString;
+  std::function<StringRef(StringRef Input)> Translator;
+};
+
+/// Helper for making strong types.
+template <typename T, typename S> class StrongType : public T {
+public:
+  template <typename... Args>
+  explicit StrongType(Args... A) : T(std::forward<Args>(A)...) {}
+};
+
+/// It's very easy to introduce bugs by passing the wrong string pool.
+/// By using strong types the interface enforces that the right
+/// kind of pool is used.
+struct UniqueTag {};
+struct OffsetsTag {};
+using UniquingStringPool = StrongType<NonRelocatableStringpool, UniqueTag>;
+using OffsetsStringPool = StrongType<NonRelocatableStringpool, OffsetsTag>;
+
+} // end namespace llvm
+
+#endif // LLVM_CODEGEN_NONRELOCATABLESTRINGPOOL_H
diff --git a/linux-x64/clang/include/llvm/CodeGen/PBQP/Math.h b/linux-x64/clang/include/llvm/CodeGen/PBQP/Math.h
index 8b014cc..099ba78 100644
--- a/linux-x64/clang/include/llvm/CodeGen/PBQP/Math.h
+++ b/linux-x64/clang/include/llvm/CodeGen/PBQP/Math.h
@@ -28,17 +28,17 @@
 public:
   /// Construct a PBQP vector of the given size.
   explicit Vector(unsigned Length)
-    : Length(Length), Data(llvm::make_unique<PBQPNum []>(Length)) {}
+    : Length(Length), Data(std::make_unique<PBQPNum []>(Length)) {}
 
   /// Construct a PBQP vector with initializer.
   Vector(unsigned Length, PBQPNum InitVal)
-    : Length(Length), Data(llvm::make_unique<PBQPNum []>(Length)) {
+    : Length(Length), Data(std::make_unique<PBQPNum []>(Length)) {
     std::fill(Data.get(), Data.get() + Length, InitVal);
   }
 
   /// Copy construct a PBQP vector.
   Vector(const Vector &V)
-    : Length(V.Length), Data(llvm::make_unique<PBQPNum []>(Length)) {
+    : Length(V.Length), Data(std::make_unique<PBQPNum []>(Length)) {
     std::copy(V.Data.get(), V.Data.get() + Length, Data.get());
   }
 
@@ -125,21 +125,21 @@
 public:
   /// Construct a PBQP Matrix with the given dimensions.
   Matrix(unsigned Rows, unsigned Cols) :
-    Rows(Rows), Cols(Cols), Data(llvm::make_unique<PBQPNum []>(Rows * Cols)) {
+    Rows(Rows), Cols(Cols), Data(std::make_unique<PBQPNum []>(Rows * Cols)) {
   }
 
   /// Construct a PBQP Matrix with the given dimensions and initial
   /// value.
   Matrix(unsigned Rows, unsigned Cols, PBQPNum InitVal)
     : Rows(Rows), Cols(Cols),
-      Data(llvm::make_unique<PBQPNum []>(Rows * Cols)) {
+      Data(std::make_unique<PBQPNum []>(Rows * Cols)) {
     std::fill(Data.get(), Data.get() + (Rows * Cols), InitVal);
   }
 
   /// Copy construct a PBQP matrix.
   Matrix(const Matrix &M)
     : Rows(M.Rows), Cols(M.Cols),
-      Data(llvm::make_unique<PBQPNum []>(Rows * Cols)) {
+      Data(std::make_unique<PBQPNum []>(Rows * Cols)) {
     std::copy(M.Data.get(), M.Data.get() + (Rows * Cols), Data.get());
   }
 
diff --git a/linux-x64/clang/include/llvm/CodeGen/ParallelCG.h b/linux-x64/clang/include/llvm/CodeGen/ParallelCG.h
index a44715d..5504baa 100644
--- a/linux-x64/clang/include/llvm/CodeGen/ParallelCG.h
+++ b/linux-x64/clang/include/llvm/CodeGen/ParallelCG.h
@@ -14,15 +14,14 @@
 #define LLVM_CODEGEN_PARALLELCG_H
 
 #include "llvm/Support/CodeGen.h"
-#include "llvm/Target/TargetMachine.h"
-
 #include <functional>
+#include <memory>
 
 namespace llvm {
 
 template <typename T> class ArrayRef;
 class Module;
-class TargetOptions;
+class TargetMachine;
 class raw_pwrite_stream;
 
 /// Split M into OSs.size() partitions, and generate code for each. Takes a
@@ -39,7 +38,7 @@
 splitCodeGen(std::unique_ptr<Module> M, ArrayRef<raw_pwrite_stream *> OSs,
              ArrayRef<llvm::raw_pwrite_stream *> BCOSs,
              const std::function<std::unique_ptr<TargetMachine>()> &TMFactory,
-             TargetMachine::CodeGenFileType FileType = TargetMachine::CGFT_ObjectFile,
+             CodeGenFileType FileType = CGFT_ObjectFile,
              bool PreserveLocals = false);
 
 } // namespace llvm
diff --git a/linux-x64/clang/include/llvm/CodeGen/Passes.h b/linux-x64/clang/include/llvm/CodeGen/Passes.h
index d92ee93..676ed2c 100644
--- a/linux-x64/clang/include/llvm/CodeGen/Passes.h
+++ b/linux-x64/clang/include/llvm/CodeGen/Passes.h
@@ -14,6 +14,7 @@
 #ifndef LLVM_CODEGEN_PASSES_H
 #define LLVM_CODEGEN_PASSES_H
 
+#include "llvm/Support/CodeGen.h"
 #include <functional>
 #include <string>
 
@@ -22,6 +23,7 @@
 class FunctionPass;
 class MachineFunction;
 class MachineFunctionPass;
+class MemoryBuffer;
 class ModulePass;
 class Pass;
 class TargetMachine;
@@ -42,6 +44,16 @@
   /// the entry block.
   FunctionPass *createUnreachableBlockEliminationPass();
 
+  /// createBasicBlockSections Pass - This pass assigns sections to machine
+  /// basic blocks and is enabled with -fbasic-block-sections. Buf is a memory
+  /// buffer that contains the list of functions and basic block ids to
+  /// selectively enable basic block sections.
+  MachineFunctionPass *createBasicBlockSectionsPass(const MemoryBuffer *Buf);
+
+  /// createMachineFunctionSplitterPass - This pass splits machine functions
+  /// using profile information.
+  MachineFunctionPass *createMachineFunctionSplitterPass();
+
   /// MachineFunctionPrinter pass - This pass prints out the machine function to
   /// the given stream as a debugging tool.
   MachineFunctionPass *
@@ -64,10 +76,6 @@
   /// matching during instruction selection.
   FunctionPass *createCodeGenPreparePass();
 
-  /// createScalarizeMaskedMemIntrinPass - Replace masked load, store, gather
-  /// and scatter intrinsics with scalar code when target doesn't support them.
-  FunctionPass *createScalarizeMaskedMemIntrinPass();
-
   /// AtomicExpandID -- Lowers atomic operations in terms of either cmpxchg
   /// load-linked/store-conditional loops.
   extern char &AtomicExpandID;
@@ -185,11 +193,11 @@
   /// register allocation.
   extern char &ExpandPostRAPseudosID;
 
-  /// createPostRAHazardRecognizer - This pass runs the post-ra hazard
+  /// PostRAHazardRecognizer - This pass runs the post-ra hazard
   /// recognizer.
   extern char &PostRAHazardRecognizerID;
 
-  /// createPostRAScheduler - This pass performs post register allocation
+  /// PostRAScheduler - This pass performs post register allocation
   /// scheduling.
   extern char &PostRASchedulerID;
 
@@ -226,6 +234,10 @@
   /// inserting cmov instructions.
   extern char &EarlyIfConverterID;
 
+  /// EarlyIfPredicator - This pass performs if-conversion on SSA form by
+  /// predicating if/else block and insert select at the join point.
+  extern char &EarlyIfPredicatorID;
+
   /// This pass performs instruction combining using trace metrics to estimate
   /// critical-path and resource depth.
   extern char &MachineCombinerID;
@@ -271,6 +283,11 @@
   /// MachineCSE - This pass performs global CSE on machine instructions.
   extern char &MachineCSEID;
 
+  /// MIRCanonicalizer - This pass canonicalizes MIR by renaming vregs
+  /// according to the semantics of the instruction as well as hoists
+  /// code.
+  extern char &MIRCanonicalizerID;
+
   /// ImplicitNullChecks - This pass folds null pointer checks into nearby
   /// memory operations.
   extern char &ImplicitNullChecksID;
@@ -324,7 +341,7 @@
 
   /// createDwarfEHPass - This pass mulches exception handling code into a form
   /// adapted to code generation.  Required if using dwarf exception handling.
-  FunctionPass *createDwarfEHPass();
+  FunctionPass *createDwarfEHPass(CodeGenOpt::Level OptLevel);
 
   /// createWinEHPass - Prepares personality functions used by MSVC on Windows,
   /// in addition to the Itanium LSDA based personalities.
@@ -333,7 +350,7 @@
   /// createSjLjEHPreparePass - This pass adapts exception handling code to use
   /// the GCC-style builtin setjmp/longjmp (sjlj) to handling EH control flow.
   ///
-  FunctionPass *createSjLjEHPreparePass();
+  FunctionPass *createSjLjEHPreparePass(const TargetMachine *TM);
 
   /// createWasmEHPass - This pass adapts exception handling code to use
   /// WebAssembly's exception handling scheme.
@@ -370,10 +387,6 @@
   /// createJumpInstrTables - This pass creates jump-instruction tables.
   ModulePass *createJumpInstrTablesPass();
 
-  /// createForwardControlFlowIntegrityPass - This pass adds control-flow
-  /// integrity.
-  ModulePass *createForwardControlFlowIntegrityPass();
-
   /// InterleavedAccess Pass - This pass identifies and matches interleaved
   /// memory accesses to target specific intrinsics.
   ///
@@ -447,9 +460,38 @@
   /// Creates CFI Instruction Inserter pass. \see CFIInstrInserter.cpp
   FunctionPass *createCFIInstrInserter();
 
+  /// Creates CFGuard longjmp target identification pass.
+  /// \see CFGuardLongjmp.cpp
+  FunctionPass *createCFGuardLongjmpPass();
+
   /// Create Hardware Loop pass. \see HardwareLoops.cpp
   FunctionPass *createHardwareLoopsPass();
 
+  /// This pass inserts pseudo probe annotation for callsite profiling.
+  FunctionPass *createPseudoProbeInserter();
+
+  /// Create IR Type Promotion pass. \see TypePromotion.cpp
+  FunctionPass *createTypePromotionPass();
+
+  /// Creates MIR Debugify pass. \see MachineDebugify.cpp
+  ModulePass *createDebugifyMachineModulePass();
+
+  /// Creates MIR Strip Debug pass. \see MachineStripDebug.cpp
+  /// If OnlyDebugified is true then it will only strip debug info if it was
+  /// added by a Debugify pass. The module will be left unchanged if the debug
+  /// info was generated by another source such as clang.
+  ModulePass *createStripDebugMachineModulePass(bool OnlyDebugified);
+
+  /// Creates MIR Check Debug pass. \see MachineCheckDebugify.cpp
+  ModulePass *createCheckDebugMachineModulePass();
+
+  /// The pass fixups statepoint machine instruction to replace usage of
+  /// caller saved registers with stack slots.
+  extern char &FixupStatepointCallerSavedID;
+
+  /// The pass transform load/store <256 x i32> to AMX load/store intrinsics
+  /// or split the data to two <128 x i32>.
+  FunctionPass *createX86LowerAMXTypePass();
 } // End llvm namespace
 
 #endif
diff --git a/linux-x64/clang/include/llvm/CodeGen/PseudoSourceValue.h b/linux-x64/clang/include/llvm/CodeGen/PseudoSourceValue.h
index 4b3cc91..f148701 100644
--- a/linux-x64/clang/include/llvm/CodeGen/PseudoSourceValue.h
+++ b/linux-x64/clang/include/llvm/CodeGen/PseudoSourceValue.h
@@ -14,19 +14,19 @@
 #define LLVM_CODEGEN_PSEUDOSOURCEVALUE_H
 
 #include "llvm/ADT/StringMap.h"
-#include "llvm/IR/GlobalValue.h"
 #include "llvm/IR/ValueMap.h"
 #include <map>
 
 namespace llvm {
 
+class GlobalValue;
 class MachineFrameInfo;
 class MachineMemOperand;
+class MIRFormatter;
+class PseudoSourceValue;
 class raw_ostream;
 class TargetInstrInfo;
 
-raw_ostream &operator<<(raw_ostream &OS, const MachineMemOperand &MMO);
-class PseudoSourceValue;
 raw_ostream &operator<<(raw_ostream &OS, const PseudoSourceValue* PSV);
 
 /// Special value supplied for machine level alias analysis. It indicates that
@@ -52,6 +52,7 @@
                                        const PseudoSourceValue* PSV);
 
   friend class MachineMemOperand; // For printCustom().
+  friend class MIRFormatter;      // For printCustom().
 
   /// Implement printing for PseudoSourceValue. This is called from
   /// Value::print or Value's operator<<.
diff --git a/linux-x64/clang/include/llvm/CodeGen/RDFGraph.h b/linux-x64/clang/include/llvm/CodeGen/RDFGraph.h
new file mode 100644
index 0000000..00d6ec9
--- /dev/null
+++ b/linux-x64/clang/include/llvm/CodeGen/RDFGraph.h
@@ -0,0 +1,964 @@
+//===- RDFGraph.h -----------------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Target-independent, SSA-based data flow graph for register data flow (RDF)
+// for a non-SSA program representation (e.g. post-RA machine code).
+//
+//
+// *** Introduction
+//
+// The RDF graph is a collection of nodes, each of which denotes some element
+// of the program. There are two main types of such elements: code and refe-
+// rences. Conceptually, "code" is something that represents the structure
+// of the program, e.g. basic block or a statement, while "reference" is an
+// instance of accessing a register, e.g. a definition or a use. Nodes are
+// connected with each other based on the structure of the program (such as
+// blocks, instructions, etc.), and based on the data flow (e.g. reaching
+// definitions, reached uses, etc.). The single-reaching-definition principle
+// of SSA is generally observed, although, due to the non-SSA representation
+// of the program, there are some differences between the graph and a "pure"
+// SSA representation.
+//
+//
+// *** Implementation remarks
+//
+// Since the graph can contain a large number of nodes, memory consumption
+// was one of the major design considerations. As a result, there is a single
+// base class NodeBase which defines all members used by all possible derived
+// classes. The members are arranged in a union, and a derived class cannot
+// add any data members of its own. Each derived class only defines the
+// functional interface, i.e. member functions. NodeBase must be a POD,
+// which implies that all of its members must also be PODs.
+// Since nodes need to be connected with other nodes, pointers have been
+// replaced with 32-bit identifiers: each node has an id of type NodeId.
+// There are mapping functions in the graph that translate between actual
+// memory addresses and the corresponding identifiers.
+// A node id of 0 is equivalent to nullptr.
+//
+//
+// *** Structure of the graph
+//
+// A code node is always a collection of other nodes. For example, a code
+// node corresponding to a basic block will contain code nodes corresponding
+// to instructions. In turn, a code node corresponding to an instruction will
+// contain a list of reference nodes that correspond to the definitions and
+// uses of registers in that instruction. The members are arranged into a
+// circular list, which is yet another consequence of the effort to save
+// memory: for each member node it should be possible to obtain its owner,
+// and it should be possible to access all other members. There are other
+// ways to accomplish that, but the circular list seemed the most natural.
+//
+// +- CodeNode -+
+// |            | <---------------------------------------------------+
+// +-+--------+-+                                                     |
+//   |FirstM  |LastM                                                  |
+//   |        +-------------------------------------+                 |
+//   |                                              |                 |
+//   V                                              V                 |
+//  +----------+ Next +----------+ Next       Next +----------+ Next  |
+//  |          |----->|          |-----> ... ----->|          |----->-+
+//  +- Member -+      +- Member -+                 +- Member -+
+//
+// The order of members is such that related reference nodes (see below)
+// should be contiguous on the member list.
+//
+// A reference node is a node that encapsulates an access to a register,
+// in other words, data flowing into or out of a register. There are two
+// major kinds of reference nodes: defs and uses. A def node will contain
+// the id of the first reached use, and the id of the first reached def.
+// Each def and use will contain the id of the reaching def, and also the
+// id of the next reached def (for def nodes) or use (for use nodes).
+// The "next node sharing the same reaching def" is denoted as "sibling".
+// In summary:
+// - Def node contains: reaching def, sibling, first reached def, and first
+// reached use.
+// - Use node contains: reaching def and sibling.
+//
+// +-- DefNode --+
+// | R2 = ...    | <---+--------------------+
+// ++---------+--+     |                    |
+//  |Reached  |Reached |                    |
+//  |Def      |Use     |                    |
+//  |         |        |Reaching            |Reaching
+//  |         V        |Def                 |Def
+//  |      +-- UseNode --+ Sib  +-- UseNode --+ Sib       Sib
+//  |      | ... = R2    |----->| ... = R2    |----> ... ----> 0
+//  |      +-------------+      +-------------+
+//  V
+// +-- DefNode --+ Sib
+// | R2 = ...    |----> ...
+// ++---------+--+
+//  |         |
+//  |         |
+// ...       ...
+//
+// To get a full picture, the circular lists connecting blocks within a
+// function, instructions within a block, etc. should be superimposed with
+// the def-def, def-use links shown above.
+// To illustrate this, consider a small example in a pseudo-assembly:
+// foo:
+//   add r2, r0, r1   ; r2 = r0+r1
+//   addi r0, r2, 1   ; r0 = r2+1
+//   ret r0           ; return value in r0
+//
+// The graph (in a format used by the debugging functions) would look like:
+//
+//   DFG dump:[
+//   f1: Function foo
+//   b2: === %bb.0 === preds(0), succs(0):
+//   p3: phi [d4<r0>(,d12,u9):]
+//   p5: phi [d6<r1>(,,u10):]
+//   s7: add [d8<r2>(,,u13):, u9<r0>(d4):, u10<r1>(d6):]
+//   s11: addi [d12<r0>(d4,,u15):, u13<r2>(d8):]
+//   s14: ret [u15<r0>(d12):]
+//   ]
+//
+// The f1, b2, p3, etc. are node ids. The letter is prepended to indicate the
+// kind of the node (i.e. f - function, b - basic block, p - phi, s - state-
+// ment, d - def, u - use).
+// The format of a def node is:
+//   dN<R>(rd,d,u):sib,
+// where
+//   N   - numeric node id,
+//   R   - register being defined
+//   rd  - reaching def,
+//   d   - reached def,
+//   u   - reached use,
+//   sib - sibling.
+// The format of a use node is:
+//   uN<R>[!](rd):sib,
+// where
+//   N   - numeric node id,
+//   R   - register being used,
+//   rd  - reaching def,
+//   sib - sibling.
+// Possible annotations (usually preceding the node id):
+//   +   - preserving def,
+//   ~   - clobbering def,
+//   "   - shadow ref (follows the node id),
+//   !   - fixed register (appears after register name).
+//
+// The circular lists are not explicit in the dump.
+//
+//
+// *** Node attributes
+//
+// NodeBase has a member "Attrs", which is the primary way of determining
+// the node's characteristics. The fields in this member decide whether
+// the node is a code node or a reference node (i.e. node's "type"), then
+// within each type, the "kind" determines what specifically this node
+// represents. The remaining bits, "flags", contain additional information
+// that is even more detailed than the "kind".
+// CodeNode's kinds are:
+// - Phi:   Phi node, members are reference nodes.
+// - Stmt:  Statement, members are reference nodes.
+// - Block: Basic block, members are instruction nodes (i.e. Phi or Stmt).
+// - Func:  The whole function. The members are basic block nodes.
+// RefNode's kinds are:
+// - Use.
+// - Def.
+//
+// Meaning of flags:
+// - Preserving: applies only to defs. A preserving def is one that can
+//   preserve some of the original bits among those that are included in
+//   the register associated with that def. For example, if R0 is a 32-bit
+//   register, but a def can only change the lower 16 bits, then it will
+//   be marked as preserving.
+// - Shadow: a reference that has duplicates holding additional reaching
+//   defs (see more below).
+// - Clobbering: applied only to defs, indicates that the value generated
+//   by this def is unspecified. A typical example would be volatile registers
+//   after function calls.
+// - Fixed: the register in this def/use cannot be replaced with any other
+//   register. A typical case would be a parameter register to a call, or
+//   the register with the return value from a function.
+// - Undef: the register in this reference the register is assumed to have
+//   no pre-existing value, even if it appears to be reached by some def.
+//   This is typically used to prevent keeping registers artificially live
+//   in cases when they are defined via predicated instructions. For example:
+//     r0 = add-if-true cond, r10, r11                (1)
+//     r0 = add-if-false cond, r12, r13, implicit r0  (2)
+//     ... = r0                                       (3)
+//   Before (1), r0 is not intended to be live, and the use of r0 in (3) is
+//   not meant to be reached by any def preceding (1). However, since the
+//   defs in (1) and (2) are both preserving, these properties alone would
+//   imply that the use in (3) may indeed be reached by some prior def.
+//   Adding Undef flag to the def in (1) prevents that. The Undef flag
+//   may be applied to both defs and uses.
+// - Dead: applies only to defs. The value coming out of a "dead" def is
+//   assumed to be unused, even if the def appears to be reaching other defs
+//   or uses. The motivation for this flag comes from dead defs on function
+//   calls: there is no way to determine if such a def is dead without
+//   analyzing the target's ABI. Hence the graph should contain this info,
+//   as it is unavailable otherwise. On the other hand, a def without any
+//   uses on a typical instruction is not the intended target for this flag.
+//
+// *** Shadow references
+//
+// It may happen that a super-register can have two (or more) non-overlapping
+// sub-registers. When both of these sub-registers are defined and followed
+// by a use of the super-register, the use of the super-register will not
+// have a unique reaching def: both defs of the sub-registers need to be
+// accounted for. In such cases, a duplicate use of the super-register is
+// added and it points to the extra reaching def. Both uses are marked with
+// a flag "shadow". Example:
+// Assume t0 is a super-register of r0 and r1, r0 and r1 do not overlap:
+//   set r0, 1        ; r0 = 1
+//   set r1, 1        ; r1 = 1
+//   addi t1, t0, 1   ; t1 = t0+1
+//
+// The DFG:
+//   s1: set [d2<r0>(,,u9):]
+//   s3: set [d4<r1>(,,u10):]
+//   s5: addi [d6<t1>(,,):, u7"<t0>(d2):, u8"<t0>(d4):]
+//
+// The statement s5 has two use nodes for t0: u7" and u9". The quotation
+// mark " indicates that the node is a shadow.
+//
+
+#ifndef LLVM_LIB_TARGET_HEXAGON_RDFGRAPH_H
+#define LLVM_LIB_TARGET_HEXAGON_RDFGRAPH_H
+
+#include "RDFRegisters.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/MC/LaneBitmask.h"
+#include "llvm/Support/Allocator.h"
+#include "llvm/Support/MathExtras.h"
+#include <cassert>
+#include <cstdint>
+#include <cstring>
+#include <map>
+#include <set>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+// RDF uses uint32_t to refer to registers. This is to ensure that the type
+// size remains specific. In other places, registers are often stored using
+// unsigned.
+static_assert(sizeof(uint32_t) == sizeof(unsigned), "Those should be equal");
+
+namespace llvm {
+
+class MachineBasicBlock;
+class MachineDominanceFrontier;
+class MachineDominatorTree;
+class MachineFunction;
+class MachineInstr;
+class MachineOperand;
+class raw_ostream;
+class TargetInstrInfo;
+class TargetRegisterInfo;
+
+namespace rdf {
+
+  using NodeId = uint32_t;
+
+  struct DataFlowGraph;
+
+  struct NodeAttrs {
+    enum : uint16_t {
+      None          = 0x0000,   // Nothing
+
+      // Types: 2 bits
+      TypeMask      = 0x0003,
+      Code          = 0x0001,   // 01, Container
+      Ref           = 0x0002,   // 10, Reference
+
+      // Kind: 3 bits
+      KindMask      = 0x0007 << 2,
+      Def           = 0x0001 << 2,  // 001
+      Use           = 0x0002 << 2,  // 010
+      Phi           = 0x0003 << 2,  // 011
+      Stmt          = 0x0004 << 2,  // 100
+      Block         = 0x0005 << 2,  // 101
+      Func          = 0x0006 << 2,  // 110
+
+      // Flags: 7 bits for now
+      FlagMask      = 0x007F << 5,
+      Shadow        = 0x0001 << 5,  // 0000001, Has extra reaching defs.
+      Clobbering    = 0x0002 << 5,  // 0000010, Produces unspecified values.
+      PhiRef        = 0x0004 << 5,  // 0000100, Member of PhiNode.
+      Preserving    = 0x0008 << 5,  // 0001000, Def can keep original bits.
+      Fixed         = 0x0010 << 5,  // 0010000, Fixed register.
+      Undef         = 0x0020 << 5,  // 0100000, Has no pre-existing value.
+      Dead          = 0x0040 << 5,  // 1000000, Does not define a value.
+    };
+
+    static uint16_t type(uint16_t T)  { return T & TypeMask; }
+    static uint16_t kind(uint16_t T)  { return T & KindMask; }
+    static uint16_t flags(uint16_t T) { return T & FlagMask; }
+
+    static uint16_t set_type(uint16_t A, uint16_t T) {
+      return (A & ~TypeMask) | T;
+    }
+
+    static uint16_t set_kind(uint16_t A, uint16_t K) {
+      return (A & ~KindMask) | K;
+    }
+
+    static uint16_t set_flags(uint16_t A, uint16_t F) {
+      return (A & ~FlagMask) | F;
+    }
+
+    // Test if A contains B.
+    static bool contains(uint16_t A, uint16_t B) {
+      if (type(A) != Code)
+        return false;
+      uint16_t KB = kind(B);
+      switch (kind(A)) {
+        case Func:
+          return KB == Block;
+        case Block:
+          return KB == Phi || KB == Stmt;
+        case Phi:
+        case Stmt:
+          return type(B) == Ref;
+      }
+      return false;
+    }
+  };
+
+  struct BuildOptions {
+    enum : unsigned {
+      None          = 0x00,
+      KeepDeadPhis  = 0x01,   // Do not remove dead phis during build.
+    };
+  };
+
+  template <typename T> struct NodeAddr {
+    NodeAddr() = default;
+    NodeAddr(T A, NodeId I) : Addr(A), Id(I) {}
+
+    // Type cast (casting constructor). The reason for having this class
+    // instead of std::pair.
+    template <typename S> NodeAddr(const NodeAddr<S> &NA)
+      : Addr(static_cast<T>(NA.Addr)), Id(NA.Id) {}
+
+    bool operator== (const NodeAddr<T> &NA) const {
+      assert((Addr == NA.Addr) == (Id == NA.Id));
+      return Addr == NA.Addr;
+    }
+    bool operator!= (const NodeAddr<T> &NA) const {
+      return !operator==(NA);
+    }
+
+    T Addr = nullptr;
+    NodeId Id = 0;
+  };
+
+  struct NodeBase;
+
+  // Fast memory allocation and translation between node id and node address.
+  // This is really the same idea as the one underlying the "bump pointer
+  // allocator", the difference being in the translation. A node id is
+  // composed of two components: the index of the block in which it was
+  // allocated, and the index within the block. With the default settings,
+  // where the number of nodes per block is 4096, the node id (minus 1) is:
+  //
+  // bit position:                11             0
+  // +----------------------------+--------------+
+  // | Index of the block         |Index in block|
+  // +----------------------------+--------------+
+  //
+  // The actual node id is the above plus 1, to avoid creating a node id of 0.
+  //
+  // This method significantly improved the build time, compared to using maps
+  // (std::unordered_map or DenseMap) to translate between pointers and ids.
+  struct NodeAllocator {
+    // Amount of storage for a single node.
+    enum { NodeMemSize = 32 };
+
+    NodeAllocator(uint32_t NPB = 4096)
+        : NodesPerBlock(NPB), BitsPerIndex(Log2_32(NPB)),
+          IndexMask((1 << BitsPerIndex)-1) {
+      assert(isPowerOf2_32(NPB));
+    }
+
+    NodeBase *ptr(NodeId N) const {
+      uint32_t N1 = N-1;
+      uint32_t BlockN = N1 >> BitsPerIndex;
+      uint32_t Offset = (N1 & IndexMask) * NodeMemSize;
+      return reinterpret_cast<NodeBase*>(Blocks[BlockN]+Offset);
+    }
+
+    NodeId id(const NodeBase *P) const;
+    NodeAddr<NodeBase*> New();
+    void clear();
+
+  private:
+    void startNewBlock();
+    bool needNewBlock();
+
+    uint32_t makeId(uint32_t Block, uint32_t Index) const {
+      // Add 1 to the id, to avoid the id of 0, which is treated as "null".
+      return ((Block << BitsPerIndex) | Index) + 1;
+    }
+
+    const uint32_t NodesPerBlock;
+    const uint32_t BitsPerIndex;
+    const uint32_t IndexMask;
+    char *ActiveEnd = nullptr;
+    std::vector<char*> Blocks;
+    using AllocatorTy = BumpPtrAllocatorImpl<MallocAllocator, 65536>;
+    AllocatorTy MemPool;
+  };
+
+  using RegisterSet = std::set<RegisterRef>;
+
+  struct TargetOperandInfo {
+    TargetOperandInfo(const TargetInstrInfo &tii) : TII(tii) {}
+    virtual ~TargetOperandInfo() = default;
+
+    virtual bool isPreserving(const MachineInstr &In, unsigned OpNum) const;
+    virtual bool isClobbering(const MachineInstr &In, unsigned OpNum) const;
+    virtual bool isFixedReg(const MachineInstr &In, unsigned OpNum) const;
+
+    const TargetInstrInfo &TII;
+  };
+
+  // Packed register reference. Only used for storage.
+  struct PackedRegisterRef {
+    RegisterId Reg;
+    uint32_t MaskId;
+  };
+
+  struct LaneMaskIndex : private IndexedSet<LaneBitmask> {
+    LaneMaskIndex() = default;
+
+    LaneBitmask getLaneMaskForIndex(uint32_t K) const {
+      return K == 0 ? LaneBitmask::getAll() : get(K);
+    }
+
+    uint32_t getIndexForLaneMask(LaneBitmask LM) {
+      assert(LM.any());
+      return LM.all() ? 0 : insert(LM);
+    }
+
+    uint32_t getIndexForLaneMask(LaneBitmask LM) const {
+      assert(LM.any());
+      return LM.all() ? 0 : find(LM);
+    }
+  };
+
+  struct NodeBase {
+  public:
+    // Make sure this is a POD.
+    NodeBase() = default;
+
+    uint16_t getType()  const { return NodeAttrs::type(Attrs); }
+    uint16_t getKind()  const { return NodeAttrs::kind(Attrs); }
+    uint16_t getFlags() const { return NodeAttrs::flags(Attrs); }
+    NodeId   getNext()  const { return Next; }
+
+    uint16_t getAttrs() const { return Attrs; }
+    void setAttrs(uint16_t A) { Attrs = A; }
+    void setFlags(uint16_t F) { setAttrs(NodeAttrs::set_flags(getAttrs(), F)); }
+
+    // Insert node NA after "this" in the circular chain.
+    void append(NodeAddr<NodeBase*> NA);
+
+    // Initialize all members to 0.
+    void init() { memset(this, 0, sizeof *this); }
+
+    void setNext(NodeId N) { Next = N; }
+
+  protected:
+    uint16_t Attrs;
+    uint16_t Reserved;
+    NodeId Next;                // Id of the next node in the circular chain.
+    // Definitions of nested types. Using anonymous nested structs would make
+    // this class definition clearer, but unnamed structs are not a part of
+    // the standard.
+    struct Def_struct  {
+      NodeId DD, DU;          // Ids of the first reached def and use.
+    };
+    struct PhiU_struct  {
+      NodeId PredB;           // Id of the predecessor block for a phi use.
+    };
+    struct Code_struct {
+      void *CP;               // Pointer to the actual code.
+      NodeId FirstM, LastM;   // Id of the first member and last.
+    };
+    struct Ref_struct {
+      NodeId RD, Sib;         // Ids of the reaching def and the sibling.
+      union {
+        Def_struct Def;
+        PhiU_struct PhiU;
+      };
+      union {
+        MachineOperand *Op;   // Non-phi refs point to a machine operand.
+        PackedRegisterRef PR; // Phi refs store register info directly.
+      };
+    };
+
+    // The actual payload.
+    union {
+      Ref_struct Ref;
+      Code_struct Code;
+    };
+  };
+  // The allocator allocates chunks of 32 bytes for each node. The fact that
+  // each node takes 32 bytes in memory is used for fast translation between
+  // the node id and the node address.
+  static_assert(sizeof(NodeBase) <= NodeAllocator::NodeMemSize,
+        "NodeBase must be at most NodeAllocator::NodeMemSize bytes");
+
+  using NodeList = SmallVector<NodeAddr<NodeBase *>, 4>;
+  using NodeSet = std::set<NodeId>;
+
+  struct RefNode : public NodeBase {
+    RefNode() = default;
+
+    RegisterRef getRegRef(const DataFlowGraph &G) const;
+
+    MachineOperand &getOp() {
+      assert(!(getFlags() & NodeAttrs::PhiRef));
+      return *Ref.Op;
+    }
+
+    void setRegRef(RegisterRef RR, DataFlowGraph &G);
+    void setRegRef(MachineOperand *Op, DataFlowGraph &G);
+
+    NodeId getReachingDef() const {
+      return Ref.RD;
+    }
+    void setReachingDef(NodeId RD) {
+      Ref.RD = RD;
+    }
+
+    NodeId getSibling() const {
+      return Ref.Sib;
+    }
+    void setSibling(NodeId Sib) {
+      Ref.Sib = Sib;
+    }
+
+    bool isUse() const {
+      assert(getType() == NodeAttrs::Ref);
+      return getKind() == NodeAttrs::Use;
+    }
+
+    bool isDef() const {
+      assert(getType() == NodeAttrs::Ref);
+      return getKind() == NodeAttrs::Def;
+    }
+
+    template <typename Predicate>
+    NodeAddr<RefNode*> getNextRef(RegisterRef RR, Predicate P, bool NextOnly,
+        const DataFlowGraph &G);
+    NodeAddr<NodeBase*> getOwner(const DataFlowGraph &G);
+  };
+
+  struct DefNode : public RefNode {
+    NodeId getReachedDef() const {
+      return Ref.Def.DD;
+    }
+    void setReachedDef(NodeId D) {
+      Ref.Def.DD = D;
+    }
+    NodeId getReachedUse() const {
+      return Ref.Def.DU;
+    }
+    void setReachedUse(NodeId U) {
+      Ref.Def.DU = U;
+    }
+
+    void linkToDef(NodeId Self, NodeAddr<DefNode*> DA);
+  };
+
+  struct UseNode : public RefNode {
+    void linkToDef(NodeId Self, NodeAddr<DefNode*> DA);
+  };
+
+  struct PhiUseNode : public UseNode {
+    NodeId getPredecessor() const {
+      assert(getFlags() & NodeAttrs::PhiRef);
+      return Ref.PhiU.PredB;
+    }
+    void setPredecessor(NodeId B) {
+      assert(getFlags() & NodeAttrs::PhiRef);
+      Ref.PhiU.PredB = B;
+    }
+  };
+
+  struct CodeNode : public NodeBase {
+    template <typename T> T getCode() const {
+      return static_cast<T>(Code.CP);
+    }
+    void setCode(void *C) {
+      Code.CP = C;
+    }
+
+    NodeAddr<NodeBase*> getFirstMember(const DataFlowGraph &G) const;
+    NodeAddr<NodeBase*> getLastMember(const DataFlowGraph &G) const;
+    void addMember(NodeAddr<NodeBase*> NA, const DataFlowGraph &G);
+    void addMemberAfter(NodeAddr<NodeBase*> MA, NodeAddr<NodeBase*> NA,
+        const DataFlowGraph &G);
+    void removeMember(NodeAddr<NodeBase*> NA, const DataFlowGraph &G);
+
+    NodeList members(const DataFlowGraph &G) const;
+    template <typename Predicate>
+    NodeList members_if(Predicate P, const DataFlowGraph &G) const;
+  };
+
+  struct InstrNode : public CodeNode {
+    NodeAddr<NodeBase*> getOwner(const DataFlowGraph &G);
+  };
+
+  struct PhiNode : public InstrNode {
+    MachineInstr *getCode() const {
+      return nullptr;
+    }
+  };
+
+  struct StmtNode : public InstrNode {
+    MachineInstr *getCode() const {
+      return CodeNode::getCode<MachineInstr*>();
+    }
+  };
+
+  struct BlockNode : public CodeNode {
+    MachineBasicBlock *getCode() const {
+      return CodeNode::getCode<MachineBasicBlock*>();
+    }
+
+    void addPhi(NodeAddr<PhiNode*> PA, const DataFlowGraph &G);
+  };
+
+  struct FuncNode : public CodeNode {
+    MachineFunction *getCode() const {
+      return CodeNode::getCode<MachineFunction*>();
+    }
+
+    NodeAddr<BlockNode*> findBlock(const MachineBasicBlock *BB,
+        const DataFlowGraph &G) const;
+    NodeAddr<BlockNode*> getEntryBlock(const DataFlowGraph &G);
+  };
+
+  struct DataFlowGraph {
+    DataFlowGraph(MachineFunction &mf, const TargetInstrInfo &tii,
+        const TargetRegisterInfo &tri, const MachineDominatorTree &mdt,
+        const MachineDominanceFrontier &mdf, const TargetOperandInfo &toi);
+
+    NodeBase *ptr(NodeId N) const;
+    template <typename T> T ptr(NodeId N) const {
+      return static_cast<T>(ptr(N));
+    }
+
+    NodeId id(const NodeBase *P) const;
+
+    template <typename T> NodeAddr<T> addr(NodeId N) const {
+      return { ptr<T>(N), N };
+    }
+
+    NodeAddr<FuncNode*> getFunc() const { return Func; }
+    MachineFunction &getMF() const { return MF; }
+    const TargetInstrInfo &getTII() const { return TII; }
+    const TargetRegisterInfo &getTRI() const { return TRI; }
+    const PhysicalRegisterInfo &getPRI() const { return PRI; }
+    const MachineDominatorTree &getDT() const { return MDT; }
+    const MachineDominanceFrontier &getDF() const { return MDF; }
+    const RegisterAggr &getLiveIns() const { return LiveIns; }
+
+    struct DefStack {
+      DefStack() = default;
+
+      bool empty() const { return Stack.empty() || top() == bottom(); }
+
+    private:
+      using value_type = NodeAddr<DefNode *>;
+      struct Iterator {
+        using value_type = DefStack::value_type;
+
+        Iterator &up() { Pos = DS.nextUp(Pos); return *this; }
+        Iterator &down() { Pos = DS.nextDown(Pos); return *this; }
+
+        value_type operator*() const {
+          assert(Pos >= 1);
+          return DS.Stack[Pos-1];
+        }
+        const value_type *operator->() const {
+          assert(Pos >= 1);
+          return &DS.Stack[Pos-1];
+        }
+        bool operator==(const Iterator &It) const { return Pos == It.Pos; }
+        bool operator!=(const Iterator &It) const { return Pos != It.Pos; }
+
+      private:
+        friend struct DefStack;
+
+        Iterator(const DefStack &S, bool Top);
+
+        // Pos-1 is the index in the StorageType object that corresponds to
+        // the top of the DefStack.
+        const DefStack &DS;
+        unsigned Pos;
+      };
+
+    public:
+      using iterator = Iterator;
+
+      iterator top() const { return Iterator(*this, true); }
+      iterator bottom() const { return Iterator(*this, false); }
+      unsigned size() const;
+
+      void push(NodeAddr<DefNode*> DA) { Stack.push_back(DA); }
+      void pop();
+      void start_block(NodeId N);
+      void clear_block(NodeId N);
+
+    private:
+      friend struct Iterator;
+
+      using StorageType = std::vector<value_type>;
+
+      bool isDelimiter(const StorageType::value_type &P, NodeId N = 0) const {
+        return (P.Addr == nullptr) && (N == 0 || P.Id == N);
+      }
+
+      unsigned nextUp(unsigned P) const;
+      unsigned nextDown(unsigned P) const;
+
+      StorageType Stack;
+    };
+
+    // Make this std::unordered_map for speed of accessing elements.
+    // Map: Register (physical or virtual) -> DefStack
+    using DefStackMap = std::unordered_map<RegisterId, DefStack>;
+
+    void build(unsigned Options = BuildOptions::None);
+    void pushAllDefs(NodeAddr<InstrNode*> IA, DefStackMap &DM);
+    void markBlock(NodeId B, DefStackMap &DefM);
+    void releaseBlock(NodeId B, DefStackMap &DefM);
+
+    PackedRegisterRef pack(RegisterRef RR) {
+      return { RR.Reg, LMI.getIndexForLaneMask(RR.Mask) };
+    }
+    PackedRegisterRef pack(RegisterRef RR) const {
+      return { RR.Reg, LMI.getIndexForLaneMask(RR.Mask) };
+    }
+    RegisterRef unpack(PackedRegisterRef PR) const {
+      return RegisterRef(PR.Reg, LMI.getLaneMaskForIndex(PR.MaskId));
+    }
+
+    RegisterRef makeRegRef(unsigned Reg, unsigned Sub) const;
+    RegisterRef makeRegRef(const MachineOperand &Op) const;
+    RegisterRef restrictRef(RegisterRef AR, RegisterRef BR) const;
+
+    NodeAddr<RefNode*> getNextRelated(NodeAddr<InstrNode*> IA,
+        NodeAddr<RefNode*> RA) const;
+    NodeAddr<RefNode*> getNextShadow(NodeAddr<InstrNode*> IA,
+        NodeAddr<RefNode*> RA, bool Create);
+    NodeAddr<RefNode*> getNextShadow(NodeAddr<InstrNode*> IA,
+        NodeAddr<RefNode*> RA) const;
+
+    NodeList getRelatedRefs(NodeAddr<InstrNode*> IA,
+        NodeAddr<RefNode*> RA) const;
+
+    NodeAddr<BlockNode*> findBlock(MachineBasicBlock *BB) const {
+      return BlockNodes.at(BB);
+    }
+
+    void unlinkUse(NodeAddr<UseNode*> UA, bool RemoveFromOwner) {
+      unlinkUseDF(UA);
+      if (RemoveFromOwner)
+        removeFromOwner(UA);
+    }
+
+    void unlinkDef(NodeAddr<DefNode*> DA, bool RemoveFromOwner) {
+      unlinkDefDF(DA);
+      if (RemoveFromOwner)
+        removeFromOwner(DA);
+    }
+
+    // Some useful filters.
+    template <uint16_t Kind>
+    static bool IsRef(const NodeAddr<NodeBase*> BA) {
+      return BA.Addr->getType() == NodeAttrs::Ref &&
+             BA.Addr->getKind() == Kind;
+    }
+
+    template <uint16_t Kind>
+    static bool IsCode(const NodeAddr<NodeBase*> BA) {
+      return BA.Addr->getType() == NodeAttrs::Code &&
+             BA.Addr->getKind() == Kind;
+    }
+
+    static bool IsDef(const NodeAddr<NodeBase*> BA) {
+      return BA.Addr->getType() == NodeAttrs::Ref &&
+             BA.Addr->getKind() == NodeAttrs::Def;
+    }
+
+    static bool IsUse(const NodeAddr<NodeBase*> BA) {
+      return BA.Addr->getType() == NodeAttrs::Ref &&
+             BA.Addr->getKind() == NodeAttrs::Use;
+    }
+
+    static bool IsPhi(const NodeAddr<NodeBase*> BA) {
+      return BA.Addr->getType() == NodeAttrs::Code &&
+             BA.Addr->getKind() == NodeAttrs::Phi;
+    }
+
+    static bool IsPreservingDef(const NodeAddr<DefNode*> DA) {
+      uint16_t Flags = DA.Addr->getFlags();
+      return (Flags & NodeAttrs::Preserving) && !(Flags & NodeAttrs::Undef);
+    }
+
+  private:
+    void reset();
+
+    RegisterSet getLandingPadLiveIns() const;
+
+    NodeAddr<NodeBase*> newNode(uint16_t Attrs);
+    NodeAddr<NodeBase*> cloneNode(const NodeAddr<NodeBase*> B);
+    NodeAddr<UseNode*> newUse(NodeAddr<InstrNode*> Owner,
+        MachineOperand &Op, uint16_t Flags = NodeAttrs::None);
+    NodeAddr<PhiUseNode*> newPhiUse(NodeAddr<PhiNode*> Owner,
+        RegisterRef RR, NodeAddr<BlockNode*> PredB,
+        uint16_t Flags = NodeAttrs::PhiRef);
+    NodeAddr<DefNode*> newDef(NodeAddr<InstrNode*> Owner,
+        MachineOperand &Op, uint16_t Flags = NodeAttrs::None);
+    NodeAddr<DefNode*> newDef(NodeAddr<InstrNode*> Owner,
+        RegisterRef RR, uint16_t Flags = NodeAttrs::PhiRef);
+    NodeAddr<PhiNode*> newPhi(NodeAddr<BlockNode*> Owner);
+    NodeAddr<StmtNode*> newStmt(NodeAddr<BlockNode*> Owner,
+        MachineInstr *MI);
+    NodeAddr<BlockNode*> newBlock(NodeAddr<FuncNode*> Owner,
+        MachineBasicBlock *BB);
+    NodeAddr<FuncNode*> newFunc(MachineFunction *MF);
+
+    template <typename Predicate>
+    std::pair<NodeAddr<RefNode*>,NodeAddr<RefNode*>>
+    locateNextRef(NodeAddr<InstrNode*> IA, NodeAddr<RefNode*> RA,
+        Predicate P) const;
+
+    using BlockRefsMap = std::map<NodeId, RegisterSet>;
+
+    void buildStmt(NodeAddr<BlockNode*> BA, MachineInstr &In);
+    void recordDefsForDF(BlockRefsMap &PhiM, NodeAddr<BlockNode*> BA);
+    void buildPhis(BlockRefsMap &PhiM, RegisterSet &AllRefs,
+        NodeAddr<BlockNode*> BA);
+    void removeUnusedPhis();
+
+    void pushClobbers(NodeAddr<InstrNode*> IA, DefStackMap &DM);
+    void pushDefs(NodeAddr<InstrNode*> IA, DefStackMap &DM);
+    template <typename T> void linkRefUp(NodeAddr<InstrNode*> IA,
+        NodeAddr<T> TA, DefStack &DS);
+    template <typename Predicate> void linkStmtRefs(DefStackMap &DefM,
+        NodeAddr<StmtNode*> SA, Predicate P);
+    void linkBlockRefs(DefStackMap &DefM, NodeAddr<BlockNode*> BA);
+
+    void unlinkUseDF(NodeAddr<UseNode*> UA);
+    void unlinkDefDF(NodeAddr<DefNode*> DA);
+
+    void removeFromOwner(NodeAddr<RefNode*> RA) {
+      NodeAddr<InstrNode*> IA = RA.Addr->getOwner(*this);
+      IA.Addr->removeMember(RA, *this);
+    }
+
+    MachineFunction &MF;
+    const TargetInstrInfo &TII;
+    const TargetRegisterInfo &TRI;
+    const PhysicalRegisterInfo PRI;
+    const MachineDominatorTree &MDT;
+    const MachineDominanceFrontier &MDF;
+    const TargetOperandInfo &TOI;
+
+    RegisterAggr LiveIns;
+    NodeAddr<FuncNode*> Func;
+    NodeAllocator Memory;
+    // Local map:  MachineBasicBlock -> NodeAddr<BlockNode*>
+    std::map<MachineBasicBlock*,NodeAddr<BlockNode*>> BlockNodes;
+    // Lane mask map.
+    LaneMaskIndex LMI;
+  };  // struct DataFlowGraph
+
+  template <typename Predicate>
+  NodeAddr<RefNode*> RefNode::getNextRef(RegisterRef RR, Predicate P,
+        bool NextOnly, const DataFlowGraph &G) {
+    // Get the "Next" reference in the circular list that references RR and
+    // satisfies predicate "Pred".
+    auto NA = G.addr<NodeBase*>(getNext());
+
+    while (NA.Addr != this) {
+      if (NA.Addr->getType() == NodeAttrs::Ref) {
+        NodeAddr<RefNode*> RA = NA;
+        if (RA.Addr->getRegRef(G) == RR && P(NA))
+          return NA;
+        if (NextOnly)
+          break;
+        NA = G.addr<NodeBase*>(NA.Addr->getNext());
+      } else {
+        // We've hit the beginning of the chain.
+        assert(NA.Addr->getType() == NodeAttrs::Code);
+        NodeAddr<CodeNode*> CA = NA;
+        NA = CA.Addr->getFirstMember(G);
+      }
+    }
+    // Return the equivalent of "nullptr" if such a node was not found.
+    return NodeAddr<RefNode*>();
+  }
+
+  template <typename Predicate>
+  NodeList CodeNode::members_if(Predicate P, const DataFlowGraph &G) const {
+    NodeList MM;
+    auto M = getFirstMember(G);
+    if (M.Id == 0)
+      return MM;
+
+    while (M.Addr != this) {
+      if (P(M))
+        MM.push_back(M);
+      M = G.addr<NodeBase*>(M.Addr->getNext());
+    }
+    return MM;
+  }
+
+  template <typename T>
+  struct Print {
+    Print(const T &x, const DataFlowGraph &g) : Obj(x), G(g) {}
+
+    const T &Obj;
+    const DataFlowGraph &G;
+  };
+
+  template <typename T>
+  struct PrintNode : Print<NodeAddr<T>> {
+    PrintNode(const NodeAddr<T> &x, const DataFlowGraph &g)
+      : Print<NodeAddr<T>>(x, g) {}
+  };
+
+  raw_ostream &operator<<(raw_ostream &OS, const Print<RegisterRef> &P);
+  raw_ostream &operator<<(raw_ostream &OS, const Print<NodeId> &P);
+  raw_ostream &operator<<(raw_ostream &OS, const Print<NodeAddr<DefNode *>> &P);
+  raw_ostream &operator<<(raw_ostream &OS, const Print<NodeAddr<UseNode *>> &P);
+  raw_ostream &operator<<(raw_ostream &OS,
+                          const Print<NodeAddr<PhiUseNode *>> &P);
+  raw_ostream &operator<<(raw_ostream &OS, const Print<NodeAddr<RefNode *>> &P);
+  raw_ostream &operator<<(raw_ostream &OS, const Print<NodeList> &P);
+  raw_ostream &operator<<(raw_ostream &OS, const Print<NodeSet> &P);
+  raw_ostream &operator<<(raw_ostream &OS, const Print<NodeAddr<PhiNode *>> &P);
+  raw_ostream &operator<<(raw_ostream &OS,
+                          const Print<NodeAddr<StmtNode *>> &P);
+  raw_ostream &operator<<(raw_ostream &OS,
+                          const Print<NodeAddr<InstrNode *>> &P);
+  raw_ostream &operator<<(raw_ostream &OS,
+                          const Print<NodeAddr<BlockNode *>> &P);
+  raw_ostream &operator<<(raw_ostream &OS,
+                          const Print<NodeAddr<FuncNode *>> &P);
+  raw_ostream &operator<<(raw_ostream &OS, const Print<RegisterSet> &P);
+  raw_ostream &operator<<(raw_ostream &OS, const Print<RegisterAggr> &P);
+  raw_ostream &operator<<(raw_ostream &OS,
+                          const Print<DataFlowGraph::DefStack> &P);
+
+} // end namespace rdf
+
+} // end namespace llvm
+
+#endif // LLVM_LIB_TARGET_HEXAGON_RDFGRAPH_H
diff --git a/linux-x64/clang/include/llvm/CodeGen/RDFLiveness.h b/linux-x64/clang/include/llvm/CodeGen/RDFLiveness.h
new file mode 100644
index 0000000..d39d358
--- /dev/null
+++ b/linux-x64/clang/include/llvm/CodeGen/RDFLiveness.h
@@ -0,0 +1,175 @@
+//===- RDFLiveness.h --------------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Recalculate the liveness information given a data flow graph.
+// This includes block live-ins and kill flags.
+
+#ifndef LLVM_LIB_TARGET_HEXAGON_RDFLIVENESS_H
+#define LLVM_LIB_TARGET_HEXAGON_RDFLIVENESS_H
+
+#include "RDFGraph.h"
+#include "RDFRegisters.h"
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/MC/LaneBitmask.h"
+#include <map>
+#include <set>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+
+namespace llvm {
+
+class MachineBasicBlock;
+class MachineDominanceFrontier;
+class MachineDominatorTree;
+class MachineRegisterInfo;
+class TargetRegisterInfo;
+
+} // namespace llvm
+
+namespace llvm {
+namespace rdf {
+namespace detail {
+
+using NodeRef = std::pair<NodeId, LaneBitmask>;
+
+} // namespace detail
+} // namespace rdf
+} // namespace llvm
+
+namespace std {
+
+template <> struct hash<llvm::rdf::detail::NodeRef> {
+  std::size_t operator()(llvm::rdf::detail::NodeRef R) const {
+    return std::hash<llvm::rdf::NodeId>{}(R.first) ^
+           std::hash<llvm::LaneBitmask::Type>{}(R.second.getAsInteger());
+  }
+};
+
+} // namespace std
+
+namespace llvm {
+namespace rdf {
+
+  struct Liveness {
+  public:
+    // This is really a std::map, except that it provides a non-trivial
+    // default constructor to the element accessed via [].
+    struct LiveMapType {
+      LiveMapType(const PhysicalRegisterInfo &pri) : Empty(pri) {}
+
+      RegisterAggr &operator[] (MachineBasicBlock *B) {
+        return Map.emplace(B, Empty).first->second;
+      }
+
+    private:
+      RegisterAggr Empty;
+      std::map<MachineBasicBlock*,RegisterAggr> Map;
+    };
+
+    using NodeRef = detail::NodeRef;
+    using NodeRefSet = std::unordered_set<NodeRef>;
+    using RefMap = std::unordered_map<RegisterId, NodeRefSet>;
+
+    Liveness(MachineRegisterInfo &mri, const DataFlowGraph &g)
+        : DFG(g), TRI(g.getTRI()), PRI(g.getPRI()), MDT(g.getDT()),
+          MDF(g.getDF()), LiveMap(g.getPRI()), Empty(), NoRegs(g.getPRI()) {}
+
+    NodeList getAllReachingDefs(RegisterRef RefRR, NodeAddr<RefNode*> RefA,
+        bool TopShadows, bool FullChain, const RegisterAggr &DefRRs);
+
+    NodeList getAllReachingDefs(NodeAddr<RefNode*> RefA) {
+      return getAllReachingDefs(RefA.Addr->getRegRef(DFG), RefA, false,
+                                false, NoRegs);
+    }
+
+    NodeList getAllReachingDefs(RegisterRef RefRR, NodeAddr<RefNode*> RefA) {
+      return getAllReachingDefs(RefRR, RefA, false, false, NoRegs);
+    }
+
+    NodeSet getAllReachedUses(RegisterRef RefRR, NodeAddr<DefNode*> DefA,
+        const RegisterAggr &DefRRs);
+
+    NodeSet getAllReachedUses(RegisterRef RefRR, NodeAddr<DefNode*> DefA) {
+      return getAllReachedUses(RefRR, DefA, NoRegs);
+    }
+
+    std::pair<NodeSet,bool> getAllReachingDefsRec(RegisterRef RefRR,
+        NodeAddr<RefNode*> RefA, NodeSet &Visited, const NodeSet &Defs);
+
+    NodeAddr<RefNode*> getNearestAliasedRef(RegisterRef RefRR,
+        NodeAddr<InstrNode*> IA);
+
+    LiveMapType &getLiveMap() { return LiveMap; }
+    const LiveMapType &getLiveMap() const { return LiveMap; }
+
+    const RefMap &getRealUses(NodeId P) const {
+      auto F = RealUseMap.find(P);
+      return F == RealUseMap.end() ? Empty : F->second;
+    }
+
+    void computePhiInfo();
+    void computeLiveIns();
+    void resetLiveIns();
+    void resetKills();
+    void resetKills(MachineBasicBlock *B);
+
+    void trace(bool T) { Trace = T; }
+
+  private:
+    const DataFlowGraph &DFG;
+    const TargetRegisterInfo &TRI;
+    const PhysicalRegisterInfo &PRI;
+    const MachineDominatorTree &MDT;
+    const MachineDominanceFrontier &MDF;
+    LiveMapType LiveMap;
+    const RefMap Empty;
+    const RegisterAggr NoRegs;
+    bool Trace = false;
+
+    // Cache of mapping from node ids (for RefNodes) to the containing
+    // basic blocks. Not computing it each time for each node reduces
+    // the liveness calculation time by a large fraction.
+    DenseMap<NodeId, MachineBasicBlock *> NBMap;
+
+    // Phi information:
+    //
+    // RealUseMap
+    // map: NodeId -> (map: RegisterId -> NodeRefSet)
+    //      phi id -> (map: register -> set of reached non-phi uses)
+    DenseMap<NodeId, RefMap> RealUseMap;
+
+    // Inverse iterated dominance frontier.
+    std::map<MachineBasicBlock*,std::set<MachineBasicBlock*>> IIDF;
+
+    // Live on entry.
+    std::map<MachineBasicBlock*,RefMap> PhiLON;
+
+    // Phi uses are considered to be located at the end of the block that
+    // they are associated with. The reaching def of a phi use dominates the
+    // block that the use corresponds to, but not the block that contains
+    // the phi itself. To include these uses in the liveness propagation (up
+    // the dominator tree), create a map: block -> set of uses live on exit.
+    std::map<MachineBasicBlock*,RefMap> PhiLOX;
+
+    MachineBasicBlock *getBlockWithRef(NodeId RN) const;
+    void traverse(MachineBasicBlock *B, RefMap &LiveIn);
+    void emptify(RefMap &M);
+
+    std::pair<NodeSet,bool> getAllReachingDefsRecImpl(RegisterRef RefRR,
+        NodeAddr<RefNode*> RefA, NodeSet &Visited, const NodeSet &Defs,
+        unsigned Nest, unsigned MaxNest);
+  };
+
+  raw_ostream &operator<<(raw_ostream &OS, const Print<Liveness::RefMap> &P);
+
+} // end namespace rdf
+
+} // end namespace llvm
+
+#endif // LLVM_LIB_TARGET_HEXAGON_RDFLIVENESS_H
diff --git a/linux-x64/clang/include/llvm/CodeGen/RDFRegisters.h b/linux-x64/clang/include/llvm/CodeGen/RDFRegisters.h
new file mode 100644
index 0000000..c49b488
--- /dev/null
+++ b/linux-x64/clang/include/llvm/CodeGen/RDFRegisters.h
@@ -0,0 +1,279 @@
+//===- RDFRegisters.h -------------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIB_TARGET_HEXAGON_RDFREGISTERS_H
+#define LLVM_LIB_TARGET_HEXAGON_RDFREGISTERS_H
+
+#include "llvm/ADT/BitVector.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/CodeGen/TargetRegisterInfo.h"
+#include "llvm/MC/LaneBitmask.h"
+#include <cassert>
+#include <cstdint>
+#include <map>
+#include <set>
+#include <vector>
+
+namespace llvm {
+
+class MachineFunction;
+class raw_ostream;
+
+namespace rdf {
+
+  using RegisterId = uint32_t;
+
+  // Template class for a map translating uint32_t into arbitrary types.
+  // The map will act like an indexed set: upon insertion of a new object,
+  // it will automatically assign a new index to it. Index of 0 is treated
+  // as invalid and is never allocated.
+  template <typename T, unsigned N = 32>
+  struct IndexedSet {
+    IndexedSet() { Map.reserve(N); }
+
+    T get(uint32_t Idx) const {
+      // Index Idx corresponds to Map[Idx-1].
+      assert(Idx != 0 && !Map.empty() && Idx-1 < Map.size());
+      return Map[Idx-1];
+    }
+
+    uint32_t insert(T Val) {
+      // Linear search.
+      auto F = llvm::find(Map, Val);
+      if (F != Map.end())
+        return F - Map.begin() + 1;
+      Map.push_back(Val);
+      return Map.size();  // Return actual_index + 1.
+    }
+
+    uint32_t find(T Val) const {
+      auto F = llvm::find(Map, Val);
+      assert(F != Map.end());
+      return F - Map.begin() + 1;
+    }
+
+    uint32_t size() const { return Map.size(); }
+
+    using const_iterator = typename std::vector<T>::const_iterator;
+
+    const_iterator begin() const { return Map.begin(); }
+    const_iterator end() const { return Map.end(); }
+
+  private:
+    std::vector<T> Map;
+  };
+
+  struct RegisterRef {
+    RegisterId Reg = 0;
+    LaneBitmask Mask = LaneBitmask::getNone();
+
+    RegisterRef() = default;
+    explicit RegisterRef(RegisterId R, LaneBitmask M = LaneBitmask::getAll())
+      : Reg(R), Mask(R != 0 ? M : LaneBitmask::getNone()) {}
+
+    operator bool() const {
+      return Reg != 0 && Mask.any();
+    }
+
+    bool operator== (const RegisterRef &RR) const {
+      return Reg == RR.Reg && Mask == RR.Mask;
+    }
+
+    bool operator!= (const RegisterRef &RR) const {
+      return !operator==(RR);
+    }
+
+    bool operator< (const RegisterRef &RR) const {
+      return Reg < RR.Reg || (Reg == RR.Reg && Mask < RR.Mask);
+    }
+
+    size_t hash() const {
+      return std::hash<RegisterId>{}(Reg) ^
+             std::hash<LaneBitmask::Type>{}(Mask.getAsInteger());
+    }
+  };
+
+
+  struct PhysicalRegisterInfo {
+    PhysicalRegisterInfo(const TargetRegisterInfo &tri,
+                         const MachineFunction &mf);
+
+    static bool isRegMaskId(RegisterId R) {
+      return Register::isStackSlot(R);
+    }
+
+    RegisterId getRegMaskId(const uint32_t *RM) const {
+      return Register::index2StackSlot(RegMasks.find(RM));
+    }
+
+    const uint32_t *getRegMaskBits(RegisterId R) const {
+      return RegMasks.get(Register::stackSlot2Index(R));
+    }
+
+    bool alias(RegisterRef RA, RegisterRef RB) const {
+      if (!isRegMaskId(RA.Reg))
+        return !isRegMaskId(RB.Reg) ? aliasRR(RA, RB) : aliasRM(RA, RB);
+      return !isRegMaskId(RB.Reg) ? aliasRM(RB, RA) : aliasMM(RA, RB);
+    }
+
+    std::set<RegisterId> getAliasSet(RegisterId Reg) const;
+
+    RegisterRef getRefForUnit(uint32_t U) const {
+      return RegisterRef(UnitInfos[U].Reg, UnitInfos[U].Mask);
+    }
+
+    const BitVector &getMaskUnits(RegisterId MaskId) const {
+      return MaskInfos[Register::stackSlot2Index(MaskId)].Units;
+    }
+
+    const BitVector &getUnitAliases(uint32_t U) const {
+      return AliasInfos[U].Regs;
+    }
+
+    RegisterRef mapTo(RegisterRef RR, unsigned R) const;
+    const TargetRegisterInfo &getTRI() const { return TRI; }
+
+  private:
+    struct RegInfo {
+      const TargetRegisterClass *RegClass = nullptr;
+    };
+    struct UnitInfo {
+      RegisterId Reg = 0;
+      LaneBitmask Mask;
+    };
+    struct MaskInfo {
+      BitVector Units;
+    };
+    struct AliasInfo {
+      BitVector Regs;
+    };
+
+    const TargetRegisterInfo &TRI;
+    IndexedSet<const uint32_t*> RegMasks;
+    std::vector<RegInfo> RegInfos;
+    std::vector<UnitInfo> UnitInfos;
+    std::vector<MaskInfo> MaskInfos;
+    std::vector<AliasInfo> AliasInfos;
+
+    bool aliasRR(RegisterRef RA, RegisterRef RB) const;
+    bool aliasRM(RegisterRef RR, RegisterRef RM) const;
+    bool aliasMM(RegisterRef RM, RegisterRef RN) const;
+  };
+
+  struct RegisterAggr {
+    RegisterAggr(const PhysicalRegisterInfo &pri)
+        : Units(pri.getTRI().getNumRegUnits()), PRI(pri) {}
+    RegisterAggr(const RegisterAggr &RG) = default;
+
+    unsigned count() const { return Units.count(); }
+    bool empty() const { return Units.none(); }
+    bool hasAliasOf(RegisterRef RR) const;
+    bool hasCoverOf(RegisterRef RR) const;
+
+    bool operator==(const RegisterAggr &A) const {
+      return DenseMapInfo<BitVector>::isEqual(Units, A.Units);
+    }
+
+    static bool isCoverOf(RegisterRef RA, RegisterRef RB,
+                          const PhysicalRegisterInfo &PRI) {
+      return RegisterAggr(PRI).insert(RA).hasCoverOf(RB);
+    }
+
+    RegisterAggr &insert(RegisterRef RR);
+    RegisterAggr &insert(const RegisterAggr &RG);
+    RegisterAggr &intersect(RegisterRef RR);
+    RegisterAggr &intersect(const RegisterAggr &RG);
+    RegisterAggr &clear(RegisterRef RR);
+    RegisterAggr &clear(const RegisterAggr &RG);
+
+    RegisterRef intersectWith(RegisterRef RR) const;
+    RegisterRef clearIn(RegisterRef RR) const;
+    RegisterRef makeRegRef() const;
+
+    size_t hash() const {
+      return DenseMapInfo<BitVector>::getHashValue(Units);
+    }
+
+    void print(raw_ostream &OS) const;
+
+    struct rr_iterator {
+      using MapType = std::map<RegisterId, LaneBitmask>;
+
+    private:
+      MapType Masks;
+      MapType::iterator Pos;
+      unsigned Index;
+      const RegisterAggr *Owner;
+
+    public:
+      rr_iterator(const RegisterAggr &RG, bool End);
+
+      RegisterRef operator*() const {
+        return RegisterRef(Pos->first, Pos->second);
+      }
+
+      rr_iterator &operator++() {
+        ++Pos;
+        ++Index;
+        return *this;
+      }
+
+      bool operator==(const rr_iterator &I) const {
+        assert(Owner == I.Owner);
+        (void)Owner;
+        return Index == I.Index;
+      }
+
+      bool operator!=(const rr_iterator &I) const {
+        return !(*this == I);
+      }
+    };
+
+    rr_iterator rr_begin() const {
+      return rr_iterator(*this, false);
+    }
+    rr_iterator rr_end() const {
+      return rr_iterator(*this, true);
+    }
+
+  private:
+    BitVector Units;
+    const PhysicalRegisterInfo &PRI;
+  };
+
+  // Optionally print the lane mask, if it is not ~0.
+  struct PrintLaneMaskOpt {
+    PrintLaneMaskOpt(LaneBitmask M) : Mask(M) {}
+    LaneBitmask Mask;
+  };
+  raw_ostream &operator<< (raw_ostream &OS, const PrintLaneMaskOpt &P);
+
+  raw_ostream &operator<< (raw_ostream &OS, const RegisterAggr &A);
+} // end namespace rdf
+
+} // end namespace llvm
+
+namespace std {
+  template <> struct hash<llvm::rdf::RegisterRef> {
+    size_t operator()(llvm::rdf::RegisterRef A) const {
+      return A.hash();
+    }
+  };
+  template <> struct hash<llvm::rdf::RegisterAggr> {
+    size_t operator()(const llvm::rdf::RegisterAggr &A) const {
+      return A.hash();
+    }
+  };
+  template <> struct equal_to<llvm::rdf::RegisterAggr> {
+    bool operator()(const llvm::rdf::RegisterAggr &A,
+                    const llvm::rdf::RegisterAggr &B) const {
+      return A == B;
+    }
+  };
+}
+#endif // LLVM_LIB_TARGET_HEXAGON_RDFREGISTERS_H
diff --git a/linux-x64/clang/include/llvm/CodeGen/ReachingDefAnalysis.h b/linux-x64/clang/include/llvm/CodeGen/ReachingDefAnalysis.h
index a599fb6..bcb48de 100644
--- a/linux-x64/clang/include/llvm/CodeGen/ReachingDefAnalysis.h
+++ b/linux-x64/clang/include/llvm/CodeGen/ReachingDefAnalysis.h
@@ -23,19 +23,54 @@
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/TinyPtrVector.h"
 #include "llvm/CodeGen/LoopTraversal.h"
 #include "llvm/CodeGen/MachineFunctionPass.h"
+#include "llvm/InitializePasses.h"
 
 namespace llvm {
 
 class MachineBasicBlock;
 class MachineInstr;
 
+/// Thin wrapper around "int" used to store reaching definitions,
+/// using an encoding that makes it compatible with TinyPtrVector.
+/// The 0th LSB is forced zero (and will be used for pointer union tagging),
+/// The 1st LSB is forced one (to make sure the value is non-zero).
+class ReachingDef {
+  uintptr_t Encoded;
+  friend struct PointerLikeTypeTraits<ReachingDef>;
+  explicit ReachingDef(uintptr_t Encoded) : Encoded(Encoded) {}
+
+public:
+  ReachingDef(std::nullptr_t) : Encoded(0) {}
+  ReachingDef(int Instr) : Encoded(((uintptr_t) Instr << 2) | 2) {}
+  operator int() const { return ((int) Encoded) >> 2; }
+};
+
+template<>
+struct PointerLikeTypeTraits<ReachingDef> {
+  static constexpr int NumLowBitsAvailable = 1;
+
+  static inline void *getAsVoidPointer(const ReachingDef &RD) {
+    return reinterpret_cast<void *>(RD.Encoded);
+  }
+
+  static inline ReachingDef getFromVoidPointer(void *P) {
+    return ReachingDef(reinterpret_cast<uintptr_t>(P));
+  }
+
+  static inline ReachingDef getFromVoidPointer(const void *P) {
+    return ReachingDef(reinterpret_cast<uintptr_t>(P));
+  }
+};
+
 /// This class provides the reaching def analysis.
 class ReachingDefAnalysis : public MachineFunctionPass {
 private:
   MachineFunction *MF;
   const TargetRegisterInfo *TRI;
+  LoopTraversal::TraversalOrder TraversedMBBOrder;
   unsigned NumRegUnits;
   /// Instruction that defined each register, relative to the beginning of the
   /// current basic block.  When a LiveRegsDefInfo is used to represent a
@@ -54,12 +89,12 @@
   /// The first instruction in each basic block is 0.
   int CurInstr;
 
-  /// Maps instructions to their instruction Ids, relative to the begining of
+  /// Maps instructions to their instruction Ids, relative to the beginning of
   /// their basic blocks.
   DenseMap<MachineInstr *, int> InstIds;
 
   /// All reaching defs of a given RegUnit for a given MBB.
-  using MBBRegUnitDefs = SmallVector<int, 1>;
+  using MBBRegUnitDefs = TinyPtrVector<ReachingDef>;
   /// All reaching defs of all reg units for a given MBB
   using MBBDefsInfo = std::vector<MBBRegUnitDefs>;
   /// All reaching defs of all reg units for a all MBBs
@@ -69,6 +104,9 @@
   /// Default values are 'nothing happened a long time ago'.
   const int ReachingDefDefaultVal = -(1 << 20);
 
+  using InstSet = SmallPtrSetImpl<MachineInstr*>;
+  using BlockSet = SmallPtrSetImpl<MachineBasicBlock*>;
+
 public:
   static char ID; // Pass identification, replacement for typeid
 
@@ -86,30 +124,156 @@
 
   MachineFunctionProperties getRequiredProperties() const override {
     return MachineFunctionProperties().set(
-        MachineFunctionProperties::Property::NoVRegs);
+        MachineFunctionProperties::Property::NoVRegs).set(
+          MachineFunctionProperties::Property::TracksLiveness);
   }
 
+  /// Re-run the analysis.
+  void reset();
+
+  /// Initialize data structures.
+  void init();
+
+  /// Traverse the machine function, mapping definitions.
+  void traverse();
+
   /// Provides the instruction id of the closest reaching def instruction of
   /// PhysReg that reaches MI, relative to the begining of MI's basic block.
-  int getReachingDef(MachineInstr *MI, int PhysReg);
+  int getReachingDef(MachineInstr *MI, MCRegister PhysReg) const;
+
+  /// Return whether A and B use the same def of PhysReg.
+  bool hasSameReachingDef(MachineInstr *A, MachineInstr *B,
+                          MCRegister PhysReg) const;
+
+  /// Return whether the reaching def for MI also is live out of its parent
+  /// block.
+  bool isReachingDefLiveOut(MachineInstr *MI, MCRegister PhysReg) const;
+
+  /// Return the local MI that produces the live out value for PhysReg, or
+  /// nullptr for a non-live out or non-local def.
+  MachineInstr *getLocalLiveOutMIDef(MachineBasicBlock *MBB,
+                                     MCRegister PhysReg) const;
+
+  /// If a single MachineInstr creates the reaching definition, then return it.
+  /// Otherwise return null.
+  MachineInstr *getUniqueReachingMIDef(MachineInstr *MI,
+                                       MCRegister PhysReg) const;
+
+  /// If a single MachineInstr creates the reaching definition, for MIs operand
+  /// at Idx, then return it. Otherwise return null.
+  MachineInstr *getMIOperand(MachineInstr *MI, unsigned Idx) const;
+
+  /// If a single MachineInstr creates the reaching definition, for MIs MO,
+  /// then return it. Otherwise return null.
+  MachineInstr *getMIOperand(MachineInstr *MI, MachineOperand &MO) const;
+
+  /// Provide whether the register has been defined in the same basic block as,
+  /// and before, MI.
+  bool hasLocalDefBefore(MachineInstr *MI, MCRegister PhysReg) const;
+
+  /// Return whether the given register is used after MI, whether it's a local
+  /// use or a live out.
+  bool isRegUsedAfter(MachineInstr *MI, MCRegister PhysReg) const;
+
+  /// Return whether the given register is defined after MI.
+  bool isRegDefinedAfter(MachineInstr *MI, MCRegister PhysReg) const;
 
   /// Provides the clearance - the number of instructions since the closest
   /// reaching def instuction of PhysReg that reaches MI.
-  int getClearance(MachineInstr *MI, MCPhysReg PhysReg);
+  int getClearance(MachineInstr *MI, MCRegister PhysReg) const;
+
+  /// Provides the uses, in the same block as MI, of register that MI defines.
+  /// This does not consider live-outs.
+  void getReachingLocalUses(MachineInstr *MI, MCRegister PhysReg,
+                            InstSet &Uses) const;
+
+  /// Search MBB for a definition of PhysReg and insert it into Defs. If no
+  /// definition is found, recursively search the predecessor blocks for them.
+  void getLiveOuts(MachineBasicBlock *MBB, MCRegister PhysReg, InstSet &Defs,
+                   BlockSet &VisitedBBs) const;
+  void getLiveOuts(MachineBasicBlock *MBB, MCRegister PhysReg,
+                   InstSet &Defs) const;
+
+  /// For the given block, collect the instructions that use the live-in
+  /// value of the provided register. Return whether the value is still
+  /// live on exit.
+  bool getLiveInUses(MachineBasicBlock *MBB, MCRegister PhysReg,
+                     InstSet &Uses) const;
+
+  /// Collect the users of the value stored in PhysReg, which is defined
+  /// by MI.
+  void getGlobalUses(MachineInstr *MI, MCRegister PhysReg, InstSet &Uses) const;
+
+  /// Collect all possible definitions of the value stored in PhysReg, which is
+  /// used by MI.
+  void getGlobalReachingDefs(MachineInstr *MI, MCRegister PhysReg,
+                             InstSet &Defs) const;
+
+  /// Return whether From can be moved forwards to just before To.
+  bool isSafeToMoveForwards(MachineInstr *From, MachineInstr *To) const;
+
+  /// Return whether From can be moved backwards to just after To.
+  bool isSafeToMoveBackwards(MachineInstr *From, MachineInstr *To) const;
+
+  /// Assuming MI is dead, recursively search the incoming operands which are
+  /// killed by MI and collect those that would become dead.
+  void collectKilledOperands(MachineInstr *MI, InstSet &Dead) const;
+
+  /// Return whether removing this instruction will have no effect on the
+  /// program, returning the redundant use-def chain.
+  bool isSafeToRemove(MachineInstr *MI, InstSet &ToRemove) const;
+
+  /// Return whether removing this instruction will have no effect on the
+  /// program, ignoring the possible effects on some instructions, returning
+  /// the redundant use-def chain.
+  bool isSafeToRemove(MachineInstr *MI, InstSet &ToRemove,
+                      InstSet &Ignore) const;
+
+  /// Return whether a MachineInstr could be inserted at MI and safely define
+  /// the given register without affecting the program.
+  bool isSafeToDefRegAt(MachineInstr *MI, MCRegister PhysReg) const;
+
+  /// Return whether a MachineInstr could be inserted at MI and safely define
+  /// the given register without affecting the program, ignoring any effects
+  /// on the provided instructions.
+  bool isSafeToDefRegAt(MachineInstr *MI, MCRegister PhysReg,
+                        InstSet &Ignore) const;
 
 private:
   /// Set up LiveRegs by merging predecessor live-out values.
-  void enterBasicBlock(const LoopTraversal::TraversedMBBInfo &TraversedMBB);
+  void enterBasicBlock(MachineBasicBlock *MBB);
 
   /// Update live-out values.
-  void leaveBasicBlock(const LoopTraversal::TraversedMBBInfo &TraversedMBB);
+  void leaveBasicBlock(MachineBasicBlock *MBB);
 
   /// Process he given basic block.
   void processBasicBlock(const LoopTraversal::TraversedMBBInfo &TraversedMBB);
 
+  /// Process block that is part of a loop again.
+  void reprocessBasicBlock(MachineBasicBlock *MBB);
+
   /// Update def-ages for registers defined by MI.
   /// Also break dependencies on partial defs and undef uses.
   void processDefs(MachineInstr *);
+
+  /// Utility function for isSafeToMoveForwards/Backwards.
+  template<typename Iterator>
+  bool isSafeToMove(MachineInstr *From, MachineInstr *To) const;
+
+  /// Return whether removing this instruction will have no effect on the
+  /// program, ignoring the possible effects on some instructions, returning
+  /// the redundant use-def chain.
+  bool isSafeToRemove(MachineInstr *MI, InstSet &Visited,
+                      InstSet &ToRemove, InstSet &Ignore) const;
+
+  /// Provides the MI, from the given block, corresponding to the Id or a
+  /// nullptr if the id does not refer to the block.
+  MachineInstr *getInstFromId(MachineBasicBlock *MBB, int InstId) const;
+
+  /// Provides the instruction of the closest reaching def instruction of
+  /// PhysReg that reaches MI, relative to the begining of MI's basic block.
+  MachineInstr *getReachingLocalMIDef(MachineInstr *MI,
+                                      MCRegister PhysReg) const;
 };
 
 } // namespace llvm
diff --git a/linux-x64/clang/include/llvm/CodeGen/RegAllocPBQP.h b/linux-x64/clang/include/llvm/CodeGen/RegAllocPBQP.h
index f7f9224..1ed5508 100644
--- a/linux-x64/clang/include/llvm/CodeGen/RegAllocPBQP.h
+++ b/linux-x64/clang/include/llvm/CodeGen/RegAllocPBQP.h
@@ -22,6 +22,8 @@
 #include "llvm/CodeGen/PBQP/Math.h"
 #include "llvm/CodeGen/PBQP/ReductionRules.h"
 #include "llvm/CodeGen/PBQP/Solution.h"
+#include "llvm/CodeGen/Register.h"
+#include "llvm/MC/MCRegister.h"
 #include "llvm/Support/ErrorHandling.h"
 #include <algorithm>
 #include <cassert>
@@ -96,13 +98,13 @@
   AllowedRegVector() = default;
   AllowedRegVector(AllowedRegVector &&) = default;
 
-  AllowedRegVector(const std::vector<unsigned> &OptVec)
-    : NumOpts(OptVec.size()), Opts(new unsigned[NumOpts]) {
+  AllowedRegVector(const std::vector<MCRegister> &OptVec)
+      : NumOpts(OptVec.size()), Opts(new MCRegister[NumOpts]) {
     std::copy(OptVec.begin(), OptVec.end(), Opts.get());
   }
 
   unsigned size() const { return NumOpts; }
-  unsigned operator[](size_t I) const { return Opts[I]; }
+  MCRegister operator[](size_t I) const { return Opts[I]; }
 
   bool operator==(const AllowedRegVector &Other) const {
     if (NumOpts != Other.NumOpts)
@@ -116,12 +118,12 @@
 
 private:
   unsigned NumOpts = 0;
-  std::unique_ptr<unsigned[]> Opts;
+  std::unique_ptr<MCRegister[]> Opts;
 };
 
 inline hash_code hash_value(const AllowedRegVector &OptRegs) {
-  unsigned *OStart = OptRegs.Opts.get();
-  unsigned *OEnd = OptRegs.Opts.get() + OptRegs.NumOpts;
+  MCRegister *OStart = OptRegs.Opts.get();
+  MCRegister *OEnd = OptRegs.Opts.get() + OptRegs.NumOpts;
   return hash_combine(OptRegs.NumOpts,
                       hash_combine_range(OStart, OEnd));
 }
@@ -143,11 +145,11 @@
   LiveIntervals &LIS;
   MachineBlockFrequencyInfo &MBFI;
 
-  void setNodeIdForVReg(unsigned VReg, GraphBase::NodeId NId) {
-    VRegToNodeId[VReg] = NId;
+  void setNodeIdForVReg(Register VReg, GraphBase::NodeId NId) {
+    VRegToNodeId[VReg.id()] = NId;
   }
 
-  GraphBase::NodeId getNodeIdForVReg(unsigned VReg) const {
+  GraphBase::NodeId getNodeIdForVReg(Register VReg) const {
     auto VRegItr = VRegToNodeId.find(VReg);
     if (VRegItr == VRegToNodeId.end())
       return GraphBase::invalidNodeId();
@@ -159,7 +161,7 @@
   }
 
 private:
-  DenseMap<unsigned, GraphBase::NodeId> VRegToNodeId;
+  DenseMap<Register, GraphBase::NodeId> VRegToNodeId;
   AllowedRegVecPool AllowedRegVecs;
 };
 
@@ -197,8 +199,8 @@
   NodeMetadata(NodeMetadata &&) = default;
   NodeMetadata& operator=(NodeMetadata &&) = default;
 
-  void setVReg(unsigned VReg) { this->VReg = VReg; }
-  unsigned getVReg() const { return VReg; }
+  void setVReg(Register VReg) { this->VReg = VReg; }
+  Register getVReg() const { return VReg; }
 
   void setAllowedRegs(GraphMetadata::AllowedRegVecRef AllowedRegs) {
     this->AllowedRegs = std::move(AllowedRegs);
@@ -256,7 +258,7 @@
   unsigned NumOpts = 0;
   unsigned DeniedOpts = 0;
   std::unique_ptr<unsigned[]> OptUnsafeEdges;
-  unsigned VReg = 0;
+  Register VReg;
   GraphMetadata::AllowedRegVecRef AllowedRegs;
 
 #ifndef NDEBUG
diff --git a/linux-x64/clang/include/llvm/CodeGen/Register.h b/linux-x64/clang/include/llvm/CodeGen/Register.h
index 907c1a9..d7057cf 100644
--- a/linux-x64/clang/include/llvm/CodeGen/Register.h
+++ b/linux-x64/clang/include/llvm/CodeGen/Register.h
@@ -9,6 +9,7 @@
 #ifndef LLVM_CODEGEN_REGISTER_H
 #define LLVM_CODEGEN_REGISTER_H
 
+#include "llvm/MC/MCRegister.h"
 #include <cassert>
 
 namespace llvm {
@@ -19,42 +20,146 @@
   unsigned Reg;
 
 public:
-  Register(unsigned Val = 0): Reg(Val) {}
+  constexpr Register(unsigned Val = 0): Reg(Val) {}
+  constexpr Register(MCRegister Val): Reg(Val) {}
 
-  /// Return true if the specified register number is in the virtual register
-  /// namespace.
-  bool isVirtual() const {
-    return int(Reg) < 0;
+  // Register numbers can represent physical registers, virtual registers, and
+  // sometimes stack slots. The unsigned values are divided into these ranges:
+  //
+  //   0           Not a register, can be used as a sentinel.
+  //   [1;2^30)    Physical registers assigned by TableGen.
+  //   [2^30;2^31) Stack slots. (Rarely used.)
+  //   [2^31;2^32) Virtual registers assigned by MachineRegisterInfo.
+  //
+  // Further sentinels can be allocated from the small negative integers.
+  // DenseMapInfo<unsigned> uses -1u and -2u.
+  static_assert(std::numeric_limits<decltype(Reg)>::max() >= 0xFFFFFFFF,
+                "Reg isn't large enough to hold full range.");
+
+  /// isStackSlot - Sometimes it is useful the be able to store a non-negative
+  /// frame index in a variable that normally holds a register. isStackSlot()
+  /// returns true if Reg is in the range used for stack slots.
+  ///
+  /// FIXME: remove in favor of member.
+  static bool isStackSlot(unsigned Reg) {
+    return MCRegister::isStackSlot(Reg);
   }
 
-  /// Return true if the specified register number is in the physical register
-  /// namespace.
-  bool isPhysical() const {
-    return int(Reg) > 0;
+  /// Return true if this is a stack slot.
+  bool isStack() const { return MCRegister::isStackSlot(Reg); }
+
+  /// Compute the frame index from a register value representing a stack slot.
+  static int stackSlot2Index(Register Reg) {
+    assert(Reg.isStack() && "Not a stack slot");
+    return int(Reg - MCRegister::FirstStackSlot);
   }
 
-  /// Convert a virtual register number to a 0-based index. The first virtual
-  /// register in a function will get the index 0.
-  unsigned virtRegIndex() const {
-    assert(isVirtual() && "Not a virtual register");
-    return Reg & ~(1u << 31);
+  /// Convert a non-negative frame index to a stack slot register value.
+  static Register index2StackSlot(int FI) {
+    assert(FI >= 0 && "Cannot hold a negative frame index.");
+    return Register(FI + MCRegister::FirstStackSlot);
+  }
+
+  /// Return true if the specified register number is in
+  /// the physical register namespace.
+  static bool isPhysicalRegister(unsigned Reg) {
+    return MCRegister::isPhysicalRegister(Reg);
+  }
+
+  /// Return true if the specified register number is in
+  /// the virtual register namespace.
+  static bool isVirtualRegister(unsigned Reg) {
+    return Reg & MCRegister::VirtualRegFlag && !isStackSlot(Reg);
+  }
+
+  /// Convert a virtual register number to a 0-based index.
+  /// The first virtual register in a function will get the index 0.
+  static unsigned virtReg2Index(Register Reg) {
+    assert(isVirtualRegister(Reg) && "Not a virtual register");
+    return Reg & ~MCRegister::VirtualRegFlag;
   }
 
   /// Convert a 0-based index to a virtual register number.
   /// This is the inverse operation of VirtReg2IndexFunctor below.
   static Register index2VirtReg(unsigned Index) {
-    return Register(Index | (1u << 31));
+    assert(Index < (1u << 31) && "Index too large for virtual register range.");
+    return Index | MCRegister::VirtualRegFlag;
   }
 
-  operator unsigned() const {
+  /// Return true if the specified register number is in the virtual register
+  /// namespace.
+  bool isVirtual() const {
+    return isVirtualRegister(Reg);
+  }
+
+  /// Return true if the specified register number is in the physical register
+  /// namespace.
+  bool isPhysical() const {
+    return isPhysicalRegister(Reg);
+  }
+
+  /// Convert a virtual register number to a 0-based index. The first virtual
+  /// register in a function will get the index 0.
+  unsigned virtRegIndex() const {
+    return virtReg2Index(Reg);
+  }
+
+  constexpr operator unsigned() const {
     return Reg;
   }
 
-  bool isValid() const {
-    return Reg != 0;
+  unsigned id() const { return Reg; }
+
+  operator MCRegister() const {
+    return MCRegister(Reg);
+  }
+
+  /// Utility to check-convert this value to a MCRegister. The caller is
+  /// expected to have already validated that this Register is, indeed,
+  /// physical.
+  MCRegister asMCReg() const {
+    assert(Reg == MCRegister::NoRegister ||
+           MCRegister::isPhysicalRegister(Reg));
+    return MCRegister(Reg);
+  }
+
+  bool isValid() const { return Reg != MCRegister::NoRegister; }
+
+  /// Comparisons between register objects
+  bool operator==(const Register &Other) const { return Reg == Other.Reg; }
+  bool operator!=(const Register &Other) const { return Reg != Other.Reg; }
+  bool operator==(const MCRegister &Other) const { return Reg == Other.id(); }
+  bool operator!=(const MCRegister &Other) const { return Reg != Other.id(); }
+
+  /// Comparisons against register constants. E.g.
+  /// * R == AArch64::WZR
+  /// * R == 0
+  /// * R == VirtRegMap::NO_PHYS_REG
+  bool operator==(unsigned Other) const { return Reg == Other; }
+  bool operator!=(unsigned Other) const { return Reg != Other; }
+  bool operator==(int Other) const { return Reg == unsigned(Other); }
+  bool operator!=(int Other) const { return Reg != unsigned(Other); }
+  // MSVC requires that we explicitly declare these two as well.
+  bool operator==(MCPhysReg Other) const { return Reg == unsigned(Other); }
+  bool operator!=(MCPhysReg Other) const { return Reg != unsigned(Other); }
+};
+
+// Provide DenseMapInfo for Register
+template<> struct DenseMapInfo<Register> {
+  static inline unsigned getEmptyKey() {
+    return DenseMapInfo<unsigned>::getEmptyKey();
+  }
+  static inline unsigned getTombstoneKey() {
+    return DenseMapInfo<unsigned>::getTombstoneKey();
+  }
+  static unsigned getHashValue(const Register &Val) {
+    return DenseMapInfo<unsigned>::getHashValue(Val.id());
+  }
+  static bool isEqual(const Register &LHS, const Register &RHS) {
+    return DenseMapInfo<unsigned>::isEqual(LHS.id(), RHS.id());
   }
 };
 
 }
 
-#endif
+#endif // ifndef LLVM_CODEGEN_REGISTER_H
diff --git a/linux-x64/clang/include/llvm/CodeGen/RegisterClassInfo.h b/linux-x64/clang/include/llvm/CodeGen/RegisterClassInfo.h
index 14af5c4..25b310c 100644
--- a/linux-x64/clang/include/llvm/CodeGen/RegisterClassInfo.h
+++ b/linux-x64/clang/include/llvm/CodeGen/RegisterClassInfo.h
@@ -110,7 +110,7 @@
   /// getLastCalleeSavedAlias - Returns the last callee saved register that
   /// overlaps PhysReg, or 0 if Reg doesn't overlap a CalleeSavedAliases.
   unsigned getLastCalleeSavedAlias(unsigned PhysReg) const {
-    assert(TargetRegisterInfo::isPhysicalRegister(PhysReg));
+    assert(Register::isPhysicalRegister(PhysReg));
     if (PhysReg < CalleeSavedAliases.size())
       return CalleeSavedAliases[PhysReg];
     return 0;
diff --git a/linux-x64/clang/include/llvm/CodeGen/RegisterPressure.h b/linux-x64/clang/include/llvm/CodeGen/RegisterPressure.h
index 5bbaa03..1deeb4d 100644
--- a/linux-x64/clang/include/llvm/CodeGen/RegisterPressure.h
+++ b/linux-x64/clang/include/llvm/CodeGen/RegisterPressure.h
@@ -37,10 +37,10 @@
 class RegisterClassInfo;
 
 struct RegisterMaskPair {
-  unsigned RegUnit; ///< Virtual register or register unit.
+  Register RegUnit; ///< Virtual register or register unit.
   LaneBitmask LaneMask;
 
-  RegisterMaskPair(unsigned RegUnit, LaneBitmask LaneMask)
+  RegisterMaskPair(Register RegUnit, LaneBitmask LaneMask)
       : RegUnit(RegUnit), LaneMask(LaneMask) {}
 };
 
@@ -129,6 +129,8 @@
   bool operator==(const PressureChange &RHS) const {
     return PSetID == RHS.PSetID && UnitInc == RHS.UnitInc;
   }
+
+  void dump() const;
 };
 
 /// List of PressureChanges in order of increasing, unique PSetID.
@@ -155,7 +157,7 @@
   const_iterator begin() const { return &PressureChanges[0]; }
   const_iterator end() const { return &PressureChanges[MaxPSets]; }
 
-  void addPressureChange(unsigned RegUnit, bool IsDec,
+  void addPressureChange(Register RegUnit, bool IsDec,
                          const MachineRegisterInfo *MRI);
 
   void dump(const TargetRegisterInfo &TRI) const;
@@ -248,6 +250,7 @@
   bool operator!=(const RegPressureDelta &RHS) const {
     return !operator==(RHS);
   }
+  void dump() const;
 };
 
 /// A set of live virtual registers and physical register units.
@@ -272,24 +275,24 @@
   RegSet Regs;
   unsigned NumRegUnits;
 
-  unsigned getSparseIndexFromReg(unsigned Reg) const {
-    if (TargetRegisterInfo::isVirtualRegister(Reg))
-      return TargetRegisterInfo::virtReg2Index(Reg) + NumRegUnits;
+  unsigned getSparseIndexFromReg(Register Reg) const {
+    if (Reg.isVirtual())
+      return Register::virtReg2Index(Reg) + NumRegUnits;
     assert(Reg < NumRegUnits);
     return Reg;
   }
 
-  unsigned getRegFromSparseIndex(unsigned SparseIndex) const {
+  Register getRegFromSparseIndex(unsigned SparseIndex) const {
     if (SparseIndex >= NumRegUnits)
-      return TargetRegisterInfo::index2VirtReg(SparseIndex-NumRegUnits);
-    return SparseIndex;
+      return Register::index2VirtReg(SparseIndex - NumRegUnits);
+    return Register(SparseIndex);
   }
 
 public:
   void clear();
   void init(const MachineRegisterInfo &MRI);
 
-  LaneBitmask contains(unsigned Reg) const {
+  LaneBitmask contains(Register Reg) const {
     unsigned SparseIndex = getSparseIndexFromReg(Reg);
     RegSet::const_iterator I = Regs.find(SparseIndex);
     if (I == Regs.end())
@@ -329,7 +332,7 @@
   template<typename ContainerT>
   void appendTo(ContainerT &To) const {
     for (const IndexMaskPair &P : Regs) {
-      unsigned Reg = getRegFromSparseIndex(P.Index);
+      Register Reg = getRegFromSparseIndex(P.Index);
       if (P.LaneMask.any())
         To.push_back(RegisterMaskPair(Reg, P.LaneMask));
     }
@@ -387,7 +390,7 @@
   LiveRegSet LiveRegs;
 
   /// Set of vreg defs that start a live range.
-  SparseSet<unsigned, VirtReg2IndexFunctor> UntiedDefs;
+  SparseSet<Register, VirtReg2IndexFunctor> UntiedDefs;
   /// Live-through pressure.
   std::vector<unsigned> LiveThruPressure;
 
@@ -529,7 +532,7 @@
     return getDownwardPressure(MI, PressureResult, MaxPressureResult);
   }
 
-  bool hasUntiedDef(unsigned VirtReg) const {
+  bool hasUntiedDef(Register VirtReg) const {
     return UntiedDefs.count(VirtReg);
   }
 
@@ -545,9 +548,9 @@
   /// after the current position.
   SlotIndex getCurrSlot() const;
 
-  void increaseRegPressure(unsigned RegUnit, LaneBitmask PreviousMask,
+  void increaseRegPressure(Register RegUnit, LaneBitmask PreviousMask,
                            LaneBitmask NewMask);
-  void decreaseRegPressure(unsigned RegUnit, LaneBitmask PreviousMask,
+  void decreaseRegPressure(Register RegUnit, LaneBitmask PreviousMask,
                            LaneBitmask NewMask);
 
   void bumpDeadDefs(ArrayRef<RegisterMaskPair> DeadDefs);
@@ -558,9 +561,9 @@
   void discoverLiveInOrOut(RegisterMaskPair Pair,
                            SmallVectorImpl<RegisterMaskPair> &LiveInOrOut);
 
-  LaneBitmask getLastUsedLanes(unsigned RegUnit, SlotIndex Pos) const;
-  LaneBitmask getLiveLanesAt(unsigned RegUnit, SlotIndex Pos) const;
-  LaneBitmask getLiveThroughAt(unsigned RegUnit, SlotIndex Pos) const;
+  LaneBitmask getLastUsedLanes(Register RegUnit, SlotIndex Pos) const;
+  LaneBitmask getLiveLanesAt(Register RegUnit, SlotIndex Pos) const;
+  LaneBitmask getLiveThroughAt(Register RegUnit, SlotIndex Pos) const;
 };
 
 void dumpRegSetPressure(ArrayRef<unsigned> SetPressure,
diff --git a/linux-x64/clang/include/llvm/CodeGen/RegisterScavenging.h b/linux-x64/clang/include/llvm/CodeGen/RegisterScavenging.h
index 9c48df8..4f48ea2 100644
--- a/linux-x64/clang/include/llvm/CodeGen/RegisterScavenging.h
+++ b/linux-x64/clang/include/llvm/CodeGen/RegisterScavenging.h
@@ -51,7 +51,7 @@
 
     /// If non-zero, the specific register is currently being
     /// scavenged. That is, it is spilled to this scavenging stack slot.
-    unsigned Reg = 0;
+    Register Reg;
 
     /// The instruction that restores the scavenged register from stack.
     const MachineInstr *Restore = nullptr;
@@ -89,15 +89,6 @@
     while (MBBI != I) forward();
   }
 
-  /// Invert the behavior of forward() on the current instruction (undo the
-  /// changes to the available registers made by forward()).
-  void unprocess();
-
-  /// Unprocess instructions until you reach the provided iterator.
-  void unprocess(MachineBasicBlock::iterator I) {
-    while (MBBI != I) unprocess();
-  }
-
   /// Update internal register state and move MBB iterator backwards.
   /// Contrary to unprocess() this method gives precise results even in the
   /// absence of kill flags.
@@ -119,14 +110,14 @@
   MachineBasicBlock::iterator getCurrentPosition() const { return MBBI; }
 
   /// Return if a specific register is currently used.
-  bool isRegUsed(unsigned Reg, bool includeReserved = true) const;
+  bool isRegUsed(Register Reg, bool includeReserved = true) const;
 
   /// Return all available registers in the register class in Mask.
   BitVector getRegsAvailable(const TargetRegisterClass *RC);
 
   /// Find an unused register of the specified register class.
   /// Return 0 if none is found.
-  unsigned FindUnusedReg(const TargetRegisterClass *RC) const;
+  Register FindUnusedReg(const TargetRegisterClass *RC) const;
 
   /// Add a scavenging frame index.
   void addScavengingFrameIndex(int FI) {
@@ -160,10 +151,10 @@
   ///
   /// If \p AllowSpill is false, fail if a spill is required to make the
   /// register available, and return NoRegister.
-  unsigned scavengeRegister(const TargetRegisterClass *RC,
+  Register scavengeRegister(const TargetRegisterClass *RC,
                             MachineBasicBlock::iterator I, int SPAdj,
                             bool AllowSpill = true);
-  unsigned scavengeRegister(const TargetRegisterClass *RegClass, int SPAdj,
+  Register scavengeRegister(const TargetRegisterClass *RegClass, int SPAdj,
                             bool AllowSpill = true) {
     return scavengeRegister(RegClass, MBBI, SPAdj, AllowSpill);
   }
@@ -177,17 +168,17 @@
   ///
   /// If \p AllowSpill is false, fail if a spill is required to make the
   /// register available, and return NoRegister.
-  unsigned scavengeRegisterBackwards(const TargetRegisterClass &RC,
+  Register scavengeRegisterBackwards(const TargetRegisterClass &RC,
                                      MachineBasicBlock::iterator To,
                                      bool RestoreAfter, int SPAdj,
                                      bool AllowSpill = true);
 
   /// Tell the scavenger a register is used.
-  void setRegUsed(unsigned Reg, LaneBitmask LaneMask = LaneBitmask::getAll());
+  void setRegUsed(Register Reg, LaneBitmask LaneMask = LaneBitmask::getAll());
 
 private:
   /// Returns true if a register is reserved. It is never "unused".
-  bool isReserved(unsigned Reg) const { return MRI->isReserved(Reg); }
+  bool isReserved(Register Reg) const { return MRI->isReserved(Reg); }
 
   /// setUsed / setUnused - Mark the state of one or a number of register units.
   ///
@@ -203,16 +194,16 @@
   void determineKillsAndDefs();
 
   /// Add all Reg Units that Reg contains to BV.
-  void addRegUnits(BitVector &BV, unsigned Reg);
+  void addRegUnits(BitVector &BV, MCRegister Reg);
 
   /// Remove all Reg Units that \p Reg contains from \p BV.
-  void removeRegUnits(BitVector &BV, unsigned Reg);
+  void removeRegUnits(BitVector &BV, MCRegister Reg);
 
   /// Return the candidate register that is unused for the longest after
   /// StartMI. UseMI is set to the instruction where the search stopped.
   ///
   /// No more than InstrLimit instructions are inspected.
-  unsigned findSurvivorReg(MachineBasicBlock::iterator StartMI,
+  Register findSurvivorReg(MachineBasicBlock::iterator StartMI,
                            BitVector &Candidates,
                            unsigned InstrLimit,
                            MachineBasicBlock::iterator &UseMI);
@@ -225,7 +216,7 @@
 
   /// Spill a register after position \p After and reload it before position
   /// \p UseMI.
-  ScavengedInfo &spill(unsigned Reg, const TargetRegisterClass &RC, int SPAdj,
+  ScavengedInfo &spill(Register Reg, const TargetRegisterClass &RC, int SPAdj,
                        MachineBasicBlock::iterator Before,
                        MachineBasicBlock::iterator &UseMI);
 };
diff --git a/linux-x64/clang/include/llvm/CodeGen/RegisterUsageInfo.h b/linux-x64/clang/include/llvm/CodeGen/RegisterUsageInfo.h
index 3355455..53982ce 100644
--- a/linux-x64/clang/include/llvm/CodeGen/RegisterUsageInfo.h
+++ b/linux-x64/clang/include/llvm/CodeGen/RegisterUsageInfo.h
@@ -21,6 +21,7 @@
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/IR/Instructions.h"
+#include "llvm/InitializePasses.h"
 #include "llvm/Pass.h"
 #include <cstdint>
 #include <vector>
diff --git a/linux-x64/clang/include/llvm/CodeGen/ResourcePriorityQueue.h b/linux-x64/clang/include/llvm/CodeGen/ResourcePriorityQueue.h
index 81587a3..bd63dd8 100644
--- a/linux-x64/clang/include/llvm/CodeGen/ResourcePriorityQueue.h
+++ b/linux-x64/clang/include/llvm/CodeGen/ResourcePriorityQueue.h
@@ -16,15 +16,15 @@
 #ifndef LLVM_CODEGEN_RESOURCEPRIORITYQUEUE_H
 #define LLVM_CODEGEN_RESOURCEPRIORITYQUEUE_H
 
-#include "llvm/CodeGen/DFAPacketizer.h"
 #include "llvm/CodeGen/ScheduleDAG.h"
-#include "llvm/CodeGen/SelectionDAGISel.h"
-#include "llvm/CodeGen/TargetInstrInfo.h"
-#include "llvm/CodeGen/TargetRegisterInfo.h"
-#include "llvm/MC/MCInstrItineraries.h"
 
 namespace llvm {
+  class DFAPacketizer;
+  class InstrItineraryData;
   class ResourcePriorityQueue;
+  class SelectionDAGISel;
+  class TargetInstrInfo;
+  class TargetRegisterInfo;
 
   /// Sorting functions for the Available queue.
   struct resource_sort {
@@ -107,7 +107,6 @@
     /// InitNumRegDefsLeft - Determine the # of regs defined by this node.
     ///
     void initNumRegDefsLeft(SUnit *SU);
-    void updateNumRegDefsLeft(SUnit *SU);
     int regPressureDelta(SUnit *SU, bool RawPressure = false);
     int rawRegPressureDelta (SUnit *SU, unsigned RCId);
 
diff --git a/linux-x64/clang/include/llvm/CodeGen/RuntimeLibcalls.h b/linux-x64/clang/include/llvm/CodeGen/RuntimeLibcalls.h
index f71f39e..86e24ca 100644
--- a/linux-x64/clang/include/llvm/CodeGen/RuntimeLibcalls.h
+++ b/linux-x64/clang/include/llvm/CodeGen/RuntimeLibcalls.h
@@ -15,6 +15,7 @@
 #define LLVM_CODEGEN_RUNTIMELIBCALLS_H
 
 #include "llvm/CodeGen/ValueTypes.h"
+#include "llvm/Support/AtomicOrdering.h"
 
 namespace llvm {
 namespace RTLIB {
@@ -60,6 +61,10 @@
   /// UNKNOWN_LIBCALL if there is none.
   Libcall getSYNC(unsigned Opc, MVT VT);
 
+  /// Return the outline atomics value for the given opcode, atomic ordering
+  /// and type, or UNKNOWN_LIBCALL if there is none.
+  Libcall getOUTLINE_ATOMIC(unsigned Opc, AtomicOrdering Order, MVT VT);
+
   /// getMEMCPY_ELEMENT_UNORDERED_ATOMIC - Return
   /// MEMCPY_ELEMENT_UNORDERED_ATOMIC_* value for the given element size or
   /// UNKNOW_LIBCALL if there is none.
diff --git a/linux-x64/clang/include/llvm/CodeGen/ScheduleDAG.h b/linux-x64/clang/include/llvm/CodeGen/ScheduleDAG.h
index e004f3b..4c8d047 100644
--- a/linux-x64/clang/include/llvm/CodeGen/ScheduleDAG.h
+++ b/linux-x64/clang/include/llvm/CodeGen/ScheduleDAG.h
@@ -724,6 +724,10 @@
   public:
     ScheduleDAGTopologicalSort(std::vector<SUnit> &SUnits, SUnit *ExitSU);
 
+    /// Add a SUnit without predecessors to the end of the topological order. It
+    /// also must be the first new node added to the DAG.
+    void AddSUnitWithoutPredecessors(const SUnit *SU);
+
     /// Creates the initial topological ordering from the DAG to be scheduled.
     void InitDAGTopologicalSorting();
 
diff --git a/linux-x64/clang/include/llvm/CodeGen/ScheduleDAGInstrs.h b/linux-x64/clang/include/llvm/CodeGen/ScheduleDAGInstrs.h
index 3e3b604..50b186d 100644
--- a/linux-x64/clang/include/llvm/CodeGen/ScheduleDAGInstrs.h
+++ b/linux-x64/clang/include/llvm/CodeGen/ScheduleDAGInstrs.h
@@ -34,6 +34,7 @@
 
 namespace llvm {
 
+  class AAResults;
   class LiveIntervals;
   class MachineFrameInfo;
   class MachineFunction;
@@ -57,7 +58,7 @@
       : VirtReg(VReg), LaneMask(LaneMask), SU(SU) {}
 
     unsigned getSparseSetIndex() const {
-      return TargetRegisterInfo::virtReg2Index(VirtReg);
+      return Register::virtReg2Index(VirtReg);
     }
   };
 
@@ -173,7 +174,7 @@
     /// Tracks the last instructions in this region using each virtual register.
     VReg2SUnitOperIdxMultiMap CurrentVRegUses;
 
-    AliasAnalysis *AAForDep = nullptr;
+    AAResults *AAForDep = nullptr;
 
     /// Remember a generic side-effecting instruction as we proceed.
     /// No other SU ever gets scheduled around it (except in the special
@@ -201,7 +202,7 @@
                                Value2SUsMap &loads, unsigned N);
 
     /// Adds a chain edge between SUa and SUb, but only if both
-    /// AliasAnalysis and Target fail to deny the dependency.
+    /// AAResults and Target fail to deny the dependency.
     void addChainDependency(SUnit *SUa, SUnit *SUb,
                             unsigned Latency = 0);
 
@@ -267,6 +268,11 @@
       return SU->SchedClass;
     }
 
+    /// IsReachable - Checks if SU is reachable from TargetSU.
+    bool IsReachable(SUnit *SU, SUnit *TargetSU) {
+      return Topo.IsReachable(SU, TargetSU);
+    }
+
     /// Returns an iterator to the top of the current scheduling region.
     MachineBasicBlock::iterator begin() const { return RegionBegin; }
 
@@ -306,7 +312,7 @@
     /// If \p RPTracker is non-null, compute register pressure as a side effect.
     /// The DAG builder is an efficient place to do it because it already visits
     /// operands.
-    void buildSchedGraph(AliasAnalysis *AA,
+    void buildSchedGraph(AAResults *AA,
                          RegPressureTracker *RPTracker = nullptr,
                          PressureDiffs *PDiffs = nullptr,
                          LiveIntervals *LIS = nullptr,
@@ -361,19 +367,12 @@
     void addVRegDefDeps(SUnit *SU, unsigned OperIdx);
     void addVRegUseDeps(SUnit *SU, unsigned OperIdx);
 
-    /// Initializes register live-range state for updating kills.
-    /// PostRA helper for rewriting kill flags.
-    void startBlockForKills(MachineBasicBlock *BB);
-
-    /// Toggles a register operand kill flag.
-    ///
-    /// Other adjustments may be made to the instruction if necessary. Return
-    /// true if the operand has been deleted, false if not.
-    void toggleKillFlag(MachineInstr &MI, MachineOperand &MO);
-
     /// Returns a mask for which lanes get read/written by the given (register)
     /// machine operand.
     LaneBitmask getLaneMaskForMO(const MachineOperand &MO) const;
+
+    /// Returns true if the def register in \p MO has no uses.
+    bool deadDefHasNoUse(const MachineOperand &MO);
   };
 
   /// Creates a new SUnit and return a ptr to it.
@@ -389,10 +388,7 @@
 
   /// Returns an existing SUnit for this MI, or nullptr.
   inline SUnit *ScheduleDAGInstrs::getSUnit(MachineInstr *MI) const {
-    DenseMap<MachineInstr*, SUnit*>::const_iterator I = MISUnitMap.find(MI);
-    if (I == MISUnitMap.end())
-      return nullptr;
-    return I->second;
+    return MISUnitMap.lookup(MI);
   }
 
 } // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/CodeGen/ScheduleDFS.h b/linux-x64/clang/include/llvm/CodeGen/ScheduleDFS.h
index d60deab..2e0a30c 100644
--- a/linux-x64/clang/include/llvm/CodeGen/ScheduleDFS.h
+++ b/linux-x64/clang/include/llvm/CodeGen/ScheduleDFS.h
@@ -13,7 +13,6 @@
 #ifndef LLVM_CODEGEN_SCHEDULEDFS_H
 #define LLVM_CODEGEN_SCHEDULEDFS_H
 
-#include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/CodeGen/ScheduleDAG.h"
 #include <cassert>
@@ -22,6 +21,7 @@
 
 namespace llvm {
 
+template <typename T> class ArrayRef;
 class raw_ostream;
 
 /// Represent the ILP of the subDAG rooted at a DAG node.
diff --git a/linux-x64/clang/include/llvm/CodeGen/ScheduleHazardRecognizer.h b/linux-x64/clang/include/llvm/CodeGen/ScheduleHazardRecognizer.h
index 37590f4..9f1101b 100644
--- a/linux-x64/clang/include/llvm/CodeGen/ScheduleHazardRecognizer.h
+++ b/linux-x64/clang/include/llvm/CodeGen/ScheduleHazardRecognizer.h
@@ -57,7 +57,7 @@
   ///     other instruction is available, issue it first.
   ///  * NoopHazard: issuing this instruction would break the program.  If
   ///     some other instruction can be issued, do so, otherwise issue a noop.
-  virtual HazardType getHazardType(SUnit *m, int Stalls = 0) {
+  virtual HazardType getHazardType(SUnit *, int Stalls = 0) {
     return NoHazard;
   }
 
@@ -114,6 +114,14 @@
     // Default implementation: count it as a cycle.
     AdvanceCycle();
   }
+
+  /// EmitNoops - This callback is invoked when noops were added to the
+  /// instruction stream.
+  virtual void EmitNoops(unsigned Quantity) {
+    // Default implementation: count it as a cycle.
+    for (unsigned i = 0; i < Quantity; ++i)
+      EmitNoop();
+  }
 };
 
 } // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/CodeGen/ScoreboardHazardRecognizer.h b/linux-x64/clang/include/llvm/CodeGen/ScoreboardHazardRecognizer.h
index ac67f30..cefafe8 100644
--- a/linux-x64/clang/include/llvm/CodeGen/ScoreboardHazardRecognizer.h
+++ b/linux-x64/clang/include/llvm/CodeGen/ScoreboardHazardRecognizer.h
@@ -16,13 +16,13 @@
 #define LLVM_CODEGEN_SCOREBOARDHAZARDRECOGNIZER_H
 
 #include "llvm/CodeGen/ScheduleHazardRecognizer.h"
+#include "llvm/MC/MCInstrItineraries.h"
 #include <cassert>
 #include <cstddef>
 #include <cstring>
 
 namespace llvm {
 
-class InstrItineraryData;
 class ScheduleDAG;
 class SUnit;
 
@@ -37,7 +37,7 @@
   // bottom-up scheduler, then the scoreboard cycles are the inverse of the
   // scheduler's cycles.
   class Scoreboard {
-    unsigned *Data = nullptr;
+    InstrStage::FuncUnits *Data = nullptr;
 
     // The maximum number of cycles monitored by the Scoreboard. This
     // value is determined based on the target itineraries to ensure
@@ -56,7 +56,7 @@
 
     size_t getDepth() const { return Depth; }
 
-    unsigned& operator[](size_t idx) const {
+    InstrStage::FuncUnits& operator[](size_t idx) const {
       // Depth is expected to be a power-of-2.
       assert(Depth && !(Depth & (Depth - 1)) &&
              "Scoreboard was not initialized properly!");
@@ -67,7 +67,7 @@
     void reset(size_t d = 1) {
       if (!Data) {
         Depth = d;
-        Data = new unsigned[Depth];
+        Data = new InstrStage::FuncUnits[Depth];
       }
 
       memset(Data, 0, Depth * sizeof(Data[0]));
diff --git a/linux-x64/clang/include/llvm/CodeGen/SelectionDAG.h b/linux-x64/clang/include/llvm/CodeGen/SelectionDAG.h
index 12a9708..aeb488d 100644
--- a/linux-x64/clang/include/llvm/CodeGen/SelectionDAG.h
+++ b/linux-x64/clang/include/llvm/CodeGen/SelectionDAG.h
@@ -26,10 +26,7 @@
 #include "llvm/ADT/ilist.h"
 #include "llvm/ADT/iterator.h"
 #include "llvm/ADT/iterator_range.h"
-#include "llvm/Analysis/AliasAnalysis.h"
-#include "llvm/Analysis/LegacyDivergenceAnalysis.h"
 #include "llvm/CodeGen/DAGCombine.h"
-#include "llvm/CodeGen/FunctionLoweringInfo.h"
 #include "llvm/CodeGen/ISDOpcodes.h"
 #include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/CodeGen/MachineMemOperand.h"
@@ -58,19 +55,24 @@
 
 namespace llvm {
 
+class AAResults;
 class BlockAddress;
+class BlockFrequencyInfo;
 class Constant;
 class ConstantFP;
 class ConstantInt;
 class DataLayout;
 struct fltSemantics;
+class FunctionLoweringInfo;
 class GlobalValue;
 struct KnownBits;
+class LegacyDivergenceAnalysis;
 class LLVMContext;
 class MachineBasicBlock;
 class MachineConstantPoolValue;
 class MCSymbol;
 class OptimizationRemarkEmitter;
+class ProfileSummaryInfo;
 class SDDbgValue;
 class SDDbgLabel;
 class SelectionDAG;
@@ -235,6 +237,9 @@
   /// whenever manipulating the DAG.
   OptimizationRemarkEmitter *ORE;
 
+  ProfileSummaryInfo *PSI = nullptr;
+  BlockFrequencyInfo *BFI = nullptr;
+
   /// The starting token.
   SDNode EntryNode;
 
@@ -269,7 +274,14 @@
 
   using CallSiteInfo = MachineFunction::CallSiteInfo;
   using CallSiteInfoImpl = MachineFunction::CallSiteInfoImpl;
-  DenseMap<const SDNode *, CallSiteInfo> SDCallSiteInfo;
+
+  struct CallSiteDbgInfo {
+    CallSiteInfo CSInfo;
+    MDNode *HeapAllocSite = nullptr;
+    bool NoMerge = false;
+  };
+
+  DenseMap<const SDNode *, CallSiteDbgInfo> SDCallSiteDbgInfo;
 
   uint16_t NextPersistentId = 0;
 
@@ -319,6 +331,29 @@
     virtual void anchor();
   };
 
+  /// Help to insert SDNodeFlags automatically in transforming. Use
+  /// RAII to save and resume flags in current scope.
+  class FlagInserter {
+    SelectionDAG &DAG;
+    SDNodeFlags Flags;
+    FlagInserter *LastInserter;
+
+  public:
+    FlagInserter(SelectionDAG &SDAG, SDNodeFlags Flags)
+        : DAG(SDAG), Flags(Flags),
+          LastInserter(SDAG.getFlagInserter()) {
+      SDAG.setFlagInserter(this);
+    }
+    FlagInserter(SelectionDAG &SDAG, SDNode *N)
+        : FlagInserter(SDAG, N->getFlags()) {}
+
+    FlagInserter(const FlagInserter &) = delete;
+    FlagInserter &operator=(const FlagInserter &) = delete;
+    ~FlagInserter() { DAG.setFlagInserter(LastInserter); }
+
+    const SDNodeFlags getFlags() const { return Flags; }
+  };
+
   /// When true, additional steps are taken to
   /// ensure that getConstant() and similar functions return DAG nodes that
   /// have legal types. This is important after type legalization since
@@ -382,7 +417,11 @@
     Node->OperandList = nullptr;
   }
   void CreateTopologicalOrder(std::vector<SDNode*>& Order);
+
 public:
+  // Maximum depth for recursive analysis such as computeKnownBits, etc.
+  static constexpr unsigned MaxRecursionDepth = 6;
+
   explicit SelectionDAG(const TargetMachine &TM, CodeGenOpt::Level);
   SelectionDAG(const SelectionDAG &) = delete;
   SelectionDAG &operator=(const SelectionDAG &) = delete;
@@ -391,7 +430,8 @@
   /// Prepare this SelectionDAG to process code in the given MachineFunction.
   void init(MachineFunction &NewMF, OptimizationRemarkEmitter &NewORE,
             Pass *PassPtr, const TargetLibraryInfo *LibraryInfo,
-            LegacyDivergenceAnalysis * Divergence);
+            LegacyDivergenceAnalysis * Divergence,
+            ProfileSummaryInfo *PSIin, BlockFrequencyInfo *BFIin);
 
   void setFunctionLoweringInfo(FunctionLoweringInfo * FuncInfo) {
     FLI = FuncInfo;
@@ -411,8 +451,24 @@
   const TargetLibraryInfo &getLibInfo() const { return *LibInfo; }
   const SelectionDAGTargetInfo &getSelectionDAGInfo() const { return *TSI; }
   const LegacyDivergenceAnalysis *getDivergenceAnalysis() const { return DA; }
-  LLVMContext *getContext() const {return Context; }
+  LLVMContext *getContext() const { return Context; }
   OptimizationRemarkEmitter &getORE() const { return *ORE; }
+  ProfileSummaryInfo *getPSI() const { return PSI; }
+  BlockFrequencyInfo *getBFI() const { return BFI; }
+
+  FlagInserter *getFlagInserter() { return Inserter; }
+  void setFlagInserter(FlagInserter *FI) { Inserter = FI; }
+
+  /// Just dump dot graph to a user-provided path and title.
+  /// This doesn't open the dot viewer program and
+  /// helps visualization when outside debugging session.
+  /// FileName expects absolute path. If provided
+  /// without any path separators then the file
+  /// will be created in the current directory.
+  /// Error will be emitted if the path is insane.
+#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+  LLVM_DUMP_METHOD void dumpDotGraph(const Twine &FileName, const Twine &Title);
+#endif
 
   /// Pop up a GraphViz/gv window with the DAG rendered using 'dot'.
   void viewGraph(const std::string &Title);
@@ -489,7 +545,7 @@
   /// certain types of nodes together, or eliminating superfluous nodes.  The
   /// Level argument controls whether Combine is allowed to produce nodes and
   /// types that are illegal on the target.
-  void Combine(CombineLevel Level, AliasAnalysis *AA,
+  void Combine(CombineLevel Level, AAResults *AA,
                CodeGenOpt::Level OptLevel);
 
   /// This transforms the SelectionDAG into a SelectionDAG that
@@ -582,6 +638,8 @@
                             bool isTarget = false);
   SDValue getShiftAmountConstant(uint64_t Val, EVT VT, const SDLoc &DL,
                                  bool LegalTypes = true);
+  SDValue getVectorIdxConstant(uint64_t Val, const SDLoc &DL,
+                               bool isTarget = false);
 
   SDValue getTargetConstant(uint64_t Val, const SDLoc &DL, EVT VT,
                             bool isOpaque = false) {
@@ -628,10 +686,9 @@
 
   SDValue getGlobalAddress(const GlobalValue *GV, const SDLoc &DL, EVT VT,
                            int64_t offset = 0, bool isTargetGA = false,
-                           unsigned char TargetFlags = 0);
+                           unsigned TargetFlags = 0);
   SDValue getTargetGlobalAddress(const GlobalValue *GV, const SDLoc &DL, EVT VT,
-                                 int64_t offset = 0,
-                                 unsigned char TargetFlags = 0) {
+                                 int64_t offset = 0, unsigned TargetFlags = 0) {
     return getGlobalAddress(GV, DL, VT, offset, true, TargetFlags);
   }
   SDValue getFrameIndex(int FI, EVT VT, bool isTarget = false);
@@ -639,36 +696,34 @@
     return getFrameIndex(FI, VT, true);
   }
   SDValue getJumpTable(int JTI, EVT VT, bool isTarget = false,
-                       unsigned char TargetFlags = 0);
-  SDValue getTargetJumpTable(int JTI, EVT VT, unsigned char TargetFlags = 0) {
+                       unsigned TargetFlags = 0);
+  SDValue getTargetJumpTable(int JTI, EVT VT, unsigned TargetFlags = 0) {
     return getJumpTable(JTI, VT, true, TargetFlags);
   }
-  SDValue getConstantPool(const Constant *C, EVT VT,
-                          unsigned Align = 0, int Offs = 0, bool isT=false,
-                          unsigned char TargetFlags = 0);
+  SDValue getConstantPool(const Constant *C, EVT VT, MaybeAlign Align = None,
+                          int Offs = 0, bool isT = false,
+                          unsigned TargetFlags = 0);
   SDValue getTargetConstantPool(const Constant *C, EVT VT,
-                                unsigned Align = 0, int Offset = 0,
-                                unsigned char TargetFlags = 0) {
+                                MaybeAlign Align = None, int Offset = 0,
+                                unsigned TargetFlags = 0) {
     return getConstantPool(C, VT, Align, Offset, true, TargetFlags);
   }
   SDValue getConstantPool(MachineConstantPoolValue *C, EVT VT,
-                          unsigned Align = 0, int Offs = 0, bool isT=false,
-                          unsigned char TargetFlags = 0);
-  SDValue getTargetConstantPool(MachineConstantPoolValue *C,
-                                  EVT VT, unsigned Align = 0,
-                                  int Offset = 0, unsigned char TargetFlags=0) {
+                          MaybeAlign Align = None, int Offs = 0,
+                          bool isT = false, unsigned TargetFlags = 0);
+  SDValue getTargetConstantPool(MachineConstantPoolValue *C, EVT VT,
+                                MaybeAlign Align = None, int Offset = 0,
+                                unsigned TargetFlags = 0) {
     return getConstantPool(C, VT, Align, Offset, true, TargetFlags);
   }
   SDValue getTargetIndex(int Index, EVT VT, int64_t Offset = 0,
-                         unsigned char TargetFlags = 0);
+                         unsigned TargetFlags = 0);
   // When generating a branch to a BB, we don't in general know enough
   // to provide debug info for the BB at that time, so keep this one around.
   SDValue getBasicBlock(MachineBasicBlock *MBB);
-  SDValue getBasicBlock(MachineBasicBlock *MBB, SDLoc dl);
   SDValue getExternalSymbol(const char *Sym, EVT VT);
-  SDValue getExternalSymbol(const char *Sym, const SDLoc &dl, EVT VT);
   SDValue getTargetExternalSymbol(const char *Sym, EVT VT,
-                                  unsigned char TargetFlags = 0);
+                                  unsigned TargetFlags = 0);
   SDValue getMCSymbol(MCSymbol *Sym, EVT VT);
 
   SDValue getValueType(EVT);
@@ -677,12 +732,10 @@
   SDValue getEHLabel(const SDLoc &dl, SDValue Root, MCSymbol *Label);
   SDValue getLabelNode(unsigned Opcode, const SDLoc &dl, SDValue Root,
                        MCSymbol *Label);
-  SDValue getBlockAddress(const BlockAddress *BA, EVT VT,
-                          int64_t Offset = 0, bool isTarget = false,
-                          unsigned char TargetFlags = 0);
+  SDValue getBlockAddress(const BlockAddress *BA, EVT VT, int64_t Offset = 0,
+                          bool isTarget = false, unsigned TargetFlags = 0);
   SDValue getTargetBlockAddress(const BlockAddress *BA, EVT VT,
-                                int64_t Offset = 0,
-                                unsigned char TargetFlags = 0) {
+                                int64_t Offset = 0, unsigned TargetFlags = 0) {
     return getBlockAddress(BA, VT, Offset, true, TargetFlags);
   }
 
@@ -773,6 +826,20 @@
     return getNode(ISD::BUILD_VECTOR, DL, VT, Ops);
   }
 
+  // Return a splat ISD::SPLAT_VECTOR node, consisting of Op splatted to all
+  // elements.
+  SDValue getSplatVector(EVT VT, const SDLoc &DL, SDValue Op) {
+    if (Op.getOpcode() == ISD::UNDEF) {
+      assert((VT.getVectorElementType() == Op.getValueType() ||
+              (VT.isInteger() &&
+               VT.getVectorElementType().bitsLE(Op.getValueType()))) &&
+             "A splatted value must have a width equal or (for integers) "
+             "greater than the vector element type!");
+      return getNode(ISD::UNDEF, SDLoc(), VT);
+    }
+    return getNode(ISD::SPLAT_VECTOR, DL, VT, Op);
+  }
+
   /// Returns an ISD::VECTOR_SHUFFLE node semantically equivalent to
   /// the shuffle node in input but with swapped operands.
   ///
@@ -783,6 +850,11 @@
   /// float type VT, by either extending or rounding (by truncation).
   SDValue getFPExtendOrRound(SDValue Op, const SDLoc &DL, EVT VT);
 
+  /// Convert Op, which must be a STRICT operation of float type, to the
+  /// float type VT, by either extending or rounding (by truncation).
+  std::pair<SDValue, SDValue>
+  getStrictFPExtendOrRound(SDValue Op, SDValue Chain, const SDLoc &DL, EVT VT);
+
   /// Convert Op, which must be of integer type, to the
   /// integer type VT, by either any-extending or truncating it.
   SDValue getAnyExtOrTrunc(SDValue Op, const SDLoc &DL, EVT VT);
@@ -820,22 +892,28 @@
   /// Create a logical NOT operation as (XOR Val, BooleanOne).
   SDValue getLogicalNOT(const SDLoc &DL, SDValue Val, EVT VT);
 
+  /// Returns sum of the base pointer and offset.
+  /// Unlike getObjectPtrOffset this does not set NoUnsignedWrap by default.
+  SDValue getMemBasePlusOffset(SDValue Base, TypeSize Offset, const SDLoc &DL,
+                               const SDNodeFlags Flags = SDNodeFlags());
+  SDValue getMemBasePlusOffset(SDValue Base, SDValue Offset, const SDLoc &DL,
+                               const SDNodeFlags Flags = SDNodeFlags());
+
   /// Create an add instruction with appropriate flags when used for
   /// addressing some offset of an object. i.e. if a load is split into multiple
   /// components, create an add nuw from the base pointer to the offset.
-  SDValue getObjectPtrOffset(const SDLoc &SL, SDValue Op, int64_t Offset) {
-    EVT VT = Op.getValueType();
-    return getObjectPtrOffset(SL, Op, getConstant(Offset, SL, VT));
+  SDValue getObjectPtrOffset(const SDLoc &SL, SDValue Ptr, TypeSize Offset) {
+    SDNodeFlags Flags;
+    Flags.setNoUnsignedWrap(true);
+    return getMemBasePlusOffset(Ptr, Offset, SL, Flags);
   }
 
-  SDValue getObjectPtrOffset(const SDLoc &SL, SDValue Op, SDValue Offset) {
-    EVT VT = Op.getValueType();
-
+  SDValue getObjectPtrOffset(const SDLoc &SL, SDValue Ptr, SDValue Offset) {
     // The object itself can't wrap around the address space, so it shouldn't be
     // possible for the adds of the offsets to the split parts to overflow.
     SDNodeFlags Flags;
     Flags.setNoUnsignedWrap(true);
-    return getNode(ISD::ADD, SL, VT, Op, Offset, Flags);
+    return getMemBasePlusOffset(Ptr, Offset, SL, Flags);
   }
 
   /// Return a new CALLSEQ_START node, that starts new call frame, in which
@@ -873,6 +951,14 @@
     return getNode(ISD::UNDEF, SDLoc(), VT);
   }
 
+  /// Return a node that represents the runtime scaling 'MulImm * RuntimeVL'.
+  SDValue getVScale(const SDLoc &DL, EVT VT, APInt MulImm) {
+    assert(MulImm.getMinSignedBits() <= VT.getSizeInBits() &&
+           "Immediate does not fit VT");
+    return getNode(ISD::VSCALE, DL, VT,
+                   getConstant(MulImm.sextOrTrunc(VT.getSizeInBits()), DL, VT));
+  }
+
   /// Return a GLOBAL_OFFSET_TABLE node. This does not have a useful SDLoc.
   SDValue getGLOBAL_OFFSET_TABLE(EVT VT) {
     return getNode(ISD::GLOBAL_OFFSET_TABLE, SDLoc(), VT);
@@ -883,21 +969,31 @@
   SDValue getNode(unsigned Opcode, const SDLoc &DL, EVT VT,
                   ArrayRef<SDUse> Ops);
   SDValue getNode(unsigned Opcode, const SDLoc &DL, EVT VT,
-                  ArrayRef<SDValue> Ops, const SDNodeFlags Flags = SDNodeFlags());
+                  ArrayRef<SDValue> Ops, const SDNodeFlags Flags);
   SDValue getNode(unsigned Opcode, const SDLoc &DL, ArrayRef<EVT> ResultTys,
                   ArrayRef<SDValue> Ops);
   SDValue getNode(unsigned Opcode, const SDLoc &DL, SDVTList VTList,
+                  ArrayRef<SDValue> Ops, const SDNodeFlags Flags);
+
+  // Use flags from current flag inserter.
+  SDValue getNode(unsigned Opcode, const SDLoc &DL, EVT VT,
                   ArrayRef<SDValue> Ops);
+  SDValue getNode(unsigned Opcode, const SDLoc &DL, SDVTList VTList,
+                  ArrayRef<SDValue> Ops);
+  SDValue getNode(unsigned Opcode, const SDLoc &DL, EVT VT, SDValue Operand);
+  SDValue getNode(unsigned Opcode, const SDLoc &DL, EVT VT, SDValue N1,
+                  SDValue N2);
+  SDValue getNode(unsigned Opcode, const SDLoc &DL, EVT VT, SDValue N1,
+                  SDValue N2, SDValue N3);
 
   // Specialize based on number of operands.
   SDValue getNode(unsigned Opcode, const SDLoc &DL, EVT VT);
   SDValue getNode(unsigned Opcode, const SDLoc &DL, EVT VT, SDValue Operand,
-                  const SDNodeFlags Flags = SDNodeFlags());
+                  const SDNodeFlags Flags);
   SDValue getNode(unsigned Opcode, const SDLoc &DL, EVT VT, SDValue N1,
-                  SDValue N2, const SDNodeFlags Flags = SDNodeFlags());
+                  SDValue N2, const SDNodeFlags Flags);
   SDValue getNode(unsigned Opcode, const SDLoc &DL, EVT VT, SDValue N1,
-                  SDValue N2, SDValue N3,
-                  const SDNodeFlags Flags = SDNodeFlags());
+                  SDValue N2, SDValue N3, const SDNodeFlags Flags);
   SDValue getNode(unsigned Opcode, const SDLoc &DL, EVT VT, SDValue N1,
                   SDValue N2, SDValue N3, SDValue N4);
   SDValue getNode(unsigned Opcode, const SDLoc &DL, EVT VT, SDValue N1,
@@ -921,18 +1017,50 @@
   /// stack arguments from being clobbered.
   SDValue getStackArgumentTokenFactor(SDValue Chain);
 
+  LLVM_ATTRIBUTE_DEPRECATED(SDValue getMemcpy(SDValue Chain, const SDLoc &dl,
+                                              SDValue Dst, SDValue Src,
+                                              SDValue Size, unsigned Align,
+                                              bool isVol, bool AlwaysInline,
+                                              bool isTailCall,
+                                              MachinePointerInfo DstPtrInfo,
+                                              MachinePointerInfo SrcPtrInfo),
+                            "Use the version that takes Align instead") {
+    return getMemcpy(Chain, dl, Dst, Src, Size, llvm::Align(Align), isVol,
+                     AlwaysInline, isTailCall, DstPtrInfo, SrcPtrInfo);
+  }
+
   SDValue getMemcpy(SDValue Chain, const SDLoc &dl, SDValue Dst, SDValue Src,
-                    SDValue Size, unsigned Align, bool isVol, bool AlwaysInline,
-                    bool isTailCall, MachinePointerInfo DstPtrInfo,
+                    SDValue Size, Align Alignment, bool isVol,
+                    bool AlwaysInline, bool isTailCall,
+                    MachinePointerInfo DstPtrInfo,
                     MachinePointerInfo SrcPtrInfo);
 
+  LLVM_ATTRIBUTE_DEPRECATED(SDValue getMemmove(SDValue Chain, const SDLoc &dl,
+                                               SDValue Dst, SDValue Src,
+                                               SDValue Size, unsigned Align,
+                                               bool isVol, bool isTailCall,
+                                               MachinePointerInfo DstPtrInfo,
+                                               MachinePointerInfo SrcPtrInfo),
+                            "Use the version that takes Align instead") {
+    return getMemmove(Chain, dl, Dst, Src, Size, llvm::Align(Align), isVol,
+                      isTailCall, DstPtrInfo, SrcPtrInfo);
+  }
   SDValue getMemmove(SDValue Chain, const SDLoc &dl, SDValue Dst, SDValue Src,
-                     SDValue Size, unsigned Align, bool isVol, bool isTailCall,
+                     SDValue Size, Align Alignment, bool isVol, bool isTailCall,
                      MachinePointerInfo DstPtrInfo,
                      MachinePointerInfo SrcPtrInfo);
 
+  LLVM_ATTRIBUTE_DEPRECATED(SDValue getMemset(SDValue Chain, const SDLoc &dl,
+                                              SDValue Dst, SDValue Src,
+                                              SDValue Size, unsigned Align,
+                                              bool isVol, bool isTailCall,
+                                              MachinePointerInfo DstPtrInfo),
+                            "Use the version that takes Align instead") {
+    return getMemset(Chain, dl, Dst, Src, Size, llvm::Align(Align), isVol,
+                     isTailCall, DstPtrInfo);
+  }
   SDValue getMemset(SDValue Chain, const SDLoc &dl, SDValue Dst, SDValue Src,
-                    SDValue Size, unsigned Align, bool isVol, bool isTailCall,
+                    SDValue Size, Align Alignment, bool isVol, bool isTailCall,
                     MachinePointerInfo DstPtrInfo);
 
   SDValue getAtomicMemcpy(SDValue Chain, const SDLoc &dl, SDValue Dst,
@@ -955,13 +1083,17 @@
   /// Helper function to make it easier to build SetCC's if you just have an
   /// ISD::CondCode instead of an SDValue.
   SDValue getSetCC(const SDLoc &DL, EVT VT, SDValue LHS, SDValue RHS,
-                   ISD::CondCode Cond) {
+                   ISD::CondCode Cond, SDValue Chain = SDValue(),
+                   bool IsSignaling = false) {
     assert(LHS.getValueType().isVector() == RHS.getValueType().isVector() &&
            "Cannot compare scalars to vectors");
     assert(LHS.getValueType().isVector() == VT.isVector() &&
            "Cannot compare scalars to vectors");
     assert(Cond != ISD::SETCC_INVALID &&
            "Cannot create a setCC of an invalid node.");
+    if (Chain)
+      return getNode(IsSignaling ? ISD::STRICT_FSETCCS : ISD::STRICT_FSETCC, DL,
+                     {VT, MVT::Other}, {Chain, LHS, RHS, getCondCode(Cond)});
     return getNode(ISD::SETCC, DL, VT, LHS, RHS, getCondCode(Cond));
   }
 
@@ -993,7 +1125,8 @@
 
   /// Try to simplify a floating-point binary operation into 1 of its operands
   /// or a constant.
-  SDValue simplifyFPBinop(unsigned Opcode, SDValue X, SDValue Y);
+  SDValue simplifyFPBinop(unsigned Opcode, SDValue X, SDValue Y,
+                          SDNodeFlags Flags);
 
   /// VAArg produces a result and token chain, and takes a pointer
   /// and a source value as input.
@@ -1029,14 +1162,36 @@
   /// INTRINSIC_W_CHAIN, or a target-specific opcode with a value not
   /// less than FIRST_TARGET_MEMORY_OPCODE.
   SDValue getMemIntrinsicNode(
-    unsigned Opcode, const SDLoc &dl, SDVTList VTList,
-    ArrayRef<SDValue> Ops, EVT MemVT,
-    MachinePointerInfo PtrInfo,
-    unsigned Align = 0,
-    MachineMemOperand::Flags Flags
-    = MachineMemOperand::MOLoad | MachineMemOperand::MOStore,
-    unsigned Size = 0,
-    const AAMDNodes &AAInfo = AAMDNodes());
+      unsigned Opcode, const SDLoc &dl, SDVTList VTList, ArrayRef<SDValue> Ops,
+      EVT MemVT, MachinePointerInfo PtrInfo, Align Alignment,
+      MachineMemOperand::Flags Flags = MachineMemOperand::MOLoad |
+                                       MachineMemOperand::MOStore,
+      uint64_t Size = 0, const AAMDNodes &AAInfo = AAMDNodes());
+
+  inline SDValue getMemIntrinsicNode(
+      unsigned Opcode, const SDLoc &dl, SDVTList VTList, ArrayRef<SDValue> Ops,
+      EVT MemVT, MachinePointerInfo PtrInfo, MaybeAlign Alignment = None,
+      MachineMemOperand::Flags Flags = MachineMemOperand::MOLoad |
+                                       MachineMemOperand::MOStore,
+      uint64_t Size = 0, const AAMDNodes &AAInfo = AAMDNodes()) {
+    // Ensure that codegen never sees alignment 0
+    return getMemIntrinsicNode(Opcode, dl, VTList, Ops, MemVT, PtrInfo,
+                               Alignment.getValueOr(getEVTAlign(MemVT)), Flags,
+                               Size, AAInfo);
+  }
+
+  LLVM_ATTRIBUTE_DEPRECATED(
+      inline SDValue getMemIntrinsicNode(
+          unsigned Opcode, const SDLoc &dl, SDVTList VTList,
+          ArrayRef<SDValue> Ops, EVT MemVT, MachinePointerInfo PtrInfo,
+          unsigned Alignment,
+          MachineMemOperand::Flags Flags = MachineMemOperand::MOLoad |
+                                           MachineMemOperand::MOStore,
+          uint64_t Size = 0, const AAMDNodes &AAInfo = AAMDNodes()),
+      "") {
+    return getMemIntrinsicNode(Opcode, dl, VTList, Ops, MemVT, PtrInfo,
+                               MaybeAlign(Alignment), Flags, Size, AAInfo);
+  }
 
   SDValue getMemIntrinsicNode(unsigned Opcode, const SDLoc &dl, SDVTList VTList,
                               ArrayRef<SDValue> Ops, EVT MemVT,
@@ -1048,6 +1203,12 @@
   SDValue getLifetimeNode(bool IsStart, const SDLoc &dl, SDValue Chain,
                           int FrameIndex, int64_t Size, int64_t Offset = -1);
 
+  /// Creates a PseudoProbeSDNode with function GUID `Guid` and
+  /// the index of the block `Index` it is probing, as well as the attributes
+  /// `attr` of the probe.
+  SDValue getPseudoProbeNode(const SDLoc &Dl, SDValue Chain, uint64_t Guid,
+                             uint64_t Index, uint32_t Attr);
+
   /// Create a MERGE_VALUES node from the given operands.
   SDValue getMergeValues(ArrayRef<SDValue> Ops, const SDLoc &dl);
 
@@ -1057,18 +1218,39 @@
   /// This function will set the MOLoad flag on MMOFlags, but you can set it if
   /// you want.  The MOStore flag must not be set.
   SDValue getLoad(EVT VT, const SDLoc &dl, SDValue Chain, SDValue Ptr,
-                  MachinePointerInfo PtrInfo, unsigned Alignment = 0,
+                  MachinePointerInfo PtrInfo,
+                  MaybeAlign Alignment = MaybeAlign(),
                   MachineMemOperand::Flags MMOFlags = MachineMemOperand::MONone,
                   const AAMDNodes &AAInfo = AAMDNodes(),
                   const MDNode *Ranges = nullptr);
+  /// FIXME: Remove once transition to Align is over.
+  inline SDValue
+  getLoad(EVT VT, const SDLoc &dl, SDValue Chain, SDValue Ptr,
+          MachinePointerInfo PtrInfo, unsigned Alignment,
+          MachineMemOperand::Flags MMOFlags = MachineMemOperand::MONone,
+          const AAMDNodes &AAInfo = AAMDNodes(),
+          const MDNode *Ranges = nullptr) {
+    return getLoad(VT, dl, Chain, Ptr, PtrInfo, MaybeAlign(Alignment), MMOFlags,
+                   AAInfo, Ranges);
+  }
   SDValue getLoad(EVT VT, const SDLoc &dl, SDValue Chain, SDValue Ptr,
                   MachineMemOperand *MMO);
   SDValue
   getExtLoad(ISD::LoadExtType ExtType, const SDLoc &dl, EVT VT, SDValue Chain,
              SDValue Ptr, MachinePointerInfo PtrInfo, EVT MemVT,
-             unsigned Alignment = 0,
+             MaybeAlign Alignment = MaybeAlign(),
              MachineMemOperand::Flags MMOFlags = MachineMemOperand::MONone,
              const AAMDNodes &AAInfo = AAMDNodes());
+  /// FIXME: Remove once transition to Align is over.
+  inline SDValue
+  getExtLoad(ISD::LoadExtType ExtType, const SDLoc &dl, EVT VT, SDValue Chain,
+             SDValue Ptr, MachinePointerInfo PtrInfo, EVT MemVT,
+             unsigned Alignment,
+             MachineMemOperand::Flags MMOFlags = MachineMemOperand::MONone,
+             const AAMDNodes &AAInfo = AAMDNodes()) {
+    return getExtLoad(ExtType, dl, VT, Chain, Ptr, PtrInfo, MemVT,
+                      MaybeAlign(Alignment), MMOFlags, AAInfo);
+  }
   SDValue getExtLoad(ISD::LoadExtType ExtType, const SDLoc &dl, EVT VT,
                      SDValue Chain, SDValue Ptr, EVT MemVT,
                      MachineMemOperand *MMO);
@@ -1076,10 +1258,32 @@
                          SDValue Offset, ISD::MemIndexedMode AM);
   SDValue getLoad(ISD::MemIndexedMode AM, ISD::LoadExtType ExtType, EVT VT,
                   const SDLoc &dl, SDValue Chain, SDValue Ptr, SDValue Offset,
-                  MachinePointerInfo PtrInfo, EVT MemVT, unsigned Alignment = 0,
+                  MachinePointerInfo PtrInfo, EVT MemVT, Align Alignment,
                   MachineMemOperand::Flags MMOFlags = MachineMemOperand::MONone,
                   const AAMDNodes &AAInfo = AAMDNodes(),
                   const MDNode *Ranges = nullptr);
+  inline SDValue getLoad(
+      ISD::MemIndexedMode AM, ISD::LoadExtType ExtType, EVT VT, const SDLoc &dl,
+      SDValue Chain, SDValue Ptr, SDValue Offset, MachinePointerInfo PtrInfo,
+      EVT MemVT, MaybeAlign Alignment = MaybeAlign(),
+      MachineMemOperand::Flags MMOFlags = MachineMemOperand::MONone,
+      const AAMDNodes &AAInfo = AAMDNodes(), const MDNode *Ranges = nullptr) {
+    // Ensures that codegen never sees a None Alignment.
+    return getLoad(AM, ExtType, VT, dl, Chain, Ptr, Offset, PtrInfo, MemVT,
+                   Alignment.getValueOr(getEVTAlign(MemVT)), MMOFlags, AAInfo,
+                   Ranges);
+  }
+  /// FIXME: Remove once transition to Align is over.
+  inline SDValue
+  getLoad(ISD::MemIndexedMode AM, ISD::LoadExtType ExtType, EVT VT,
+          const SDLoc &dl, SDValue Chain, SDValue Ptr, SDValue Offset,
+          MachinePointerInfo PtrInfo, EVT MemVT, unsigned Alignment,
+          MachineMemOperand::Flags MMOFlags = MachineMemOperand::MONone,
+          const AAMDNodes &AAInfo = AAMDNodes(),
+          const MDNode *Ranges = nullptr) {
+    return getLoad(AM, ExtType, VT, dl, Chain, Ptr, Offset, PtrInfo, MemVT,
+                   MaybeAlign(Alignment), MMOFlags, AAInfo, Ranges);
+  }
   SDValue getLoad(ISD::MemIndexedMode AM, ISD::LoadExtType ExtType, EVT VT,
                   const SDLoc &dl, SDValue Chain, SDValue Ptr, SDValue Offset,
                   EVT MemVT, MachineMemOperand *MMO);
@@ -1088,45 +1292,81 @@
   ///
   /// This function will set the MOStore flag on MMOFlags, but you can set it if
   /// you want.  The MOLoad and MOInvariant flags must not be set.
+
   SDValue
   getStore(SDValue Chain, const SDLoc &dl, SDValue Val, SDValue Ptr,
-           MachinePointerInfo PtrInfo, unsigned Alignment = 0,
+           MachinePointerInfo PtrInfo, Align Alignment,
            MachineMemOperand::Flags MMOFlags = MachineMemOperand::MONone,
            const AAMDNodes &AAInfo = AAMDNodes());
+  inline SDValue
+  getStore(SDValue Chain, const SDLoc &dl, SDValue Val, SDValue Ptr,
+           MachinePointerInfo PtrInfo, MaybeAlign Alignment = MaybeAlign(),
+           MachineMemOperand::Flags MMOFlags = MachineMemOperand::MONone,
+           const AAMDNodes &AAInfo = AAMDNodes()) {
+    return getStore(Chain, dl, Val, Ptr, PtrInfo,
+                    Alignment.getValueOr(getEVTAlign(Val.getValueType())),
+                    MMOFlags, AAInfo);
+  }
+  /// FIXME: Remove once transition to Align is over.
+  inline SDValue
+  getStore(SDValue Chain, const SDLoc &dl, SDValue Val, SDValue Ptr,
+           MachinePointerInfo PtrInfo, unsigned Alignment,
+           MachineMemOperand::Flags MMOFlags = MachineMemOperand::MONone,
+           const AAMDNodes &AAInfo = AAMDNodes()) {
+    return getStore(Chain, dl, Val, Ptr, PtrInfo, MaybeAlign(Alignment),
+                    MMOFlags, AAInfo);
+  }
   SDValue getStore(SDValue Chain, const SDLoc &dl, SDValue Val, SDValue Ptr,
                    MachineMemOperand *MMO);
   SDValue
   getTruncStore(SDValue Chain, const SDLoc &dl, SDValue Val, SDValue Ptr,
-                MachinePointerInfo PtrInfo, EVT SVT, unsigned Alignment = 0,
+                MachinePointerInfo PtrInfo, EVT SVT, Align Alignment,
                 MachineMemOperand::Flags MMOFlags = MachineMemOperand::MONone,
                 const AAMDNodes &AAInfo = AAMDNodes());
+  inline SDValue
+  getTruncStore(SDValue Chain, const SDLoc &dl, SDValue Val, SDValue Ptr,
+                MachinePointerInfo PtrInfo, EVT SVT,
+                MaybeAlign Alignment = MaybeAlign(),
+                MachineMemOperand::Flags MMOFlags = MachineMemOperand::MONone,
+                const AAMDNodes &AAInfo = AAMDNodes()) {
+    return getTruncStore(Chain, dl, Val, Ptr, PtrInfo, SVT,
+                         Alignment.getValueOr(getEVTAlign(SVT)), MMOFlags,
+                         AAInfo);
+  }
+  /// FIXME: Remove once transition to Align is over.
+  inline SDValue
+  getTruncStore(SDValue Chain, const SDLoc &dl, SDValue Val, SDValue Ptr,
+                MachinePointerInfo PtrInfo, EVT SVT, unsigned Alignment,
+                MachineMemOperand::Flags MMOFlags = MachineMemOperand::MONone,
+                const AAMDNodes &AAInfo = AAMDNodes()) {
+    return getTruncStore(Chain, dl, Val, Ptr, PtrInfo, SVT,
+                         MaybeAlign(Alignment), MMOFlags, AAInfo);
+  }
   SDValue getTruncStore(SDValue Chain, const SDLoc &dl, SDValue Val,
                         SDValue Ptr, EVT SVT, MachineMemOperand *MMO);
   SDValue getIndexedStore(SDValue OrigStore, const SDLoc &dl, SDValue Base,
                           SDValue Offset, ISD::MemIndexedMode AM);
 
-  /// Returns sum of the base pointer and offset.
-  SDValue getMemBasePlusOffset(SDValue Base, unsigned Offset, const SDLoc &DL);
-
-  SDValue getMaskedLoad(EVT VT, const SDLoc &dl, SDValue Chain, SDValue Ptr,
-                        SDValue Mask, SDValue Src0, EVT MemVT,
-                        MachineMemOperand *MMO, ISD::LoadExtType,
-                        bool IsExpanding = false);
+  SDValue getMaskedLoad(EVT VT, const SDLoc &dl, SDValue Chain, SDValue Base,
+                        SDValue Offset, SDValue Mask, SDValue Src0, EVT MemVT,
+                        MachineMemOperand *MMO, ISD::MemIndexedMode AM,
+                        ISD::LoadExtType, bool IsExpanding = false);
+  SDValue getIndexedMaskedLoad(SDValue OrigLoad, const SDLoc &dl, SDValue Base,
+                               SDValue Offset, ISD::MemIndexedMode AM);
   SDValue getMaskedStore(SDValue Chain, const SDLoc &dl, SDValue Val,
-                         SDValue Ptr, SDValue Mask, EVT MemVT,
-                         MachineMemOperand *MMO, bool IsTruncating = false,
-                         bool IsCompressing = false);
+                         SDValue Base, SDValue Offset, SDValue Mask, EVT MemVT,
+                         MachineMemOperand *MMO, ISD::MemIndexedMode AM,
+                         bool IsTruncating = false, bool IsCompressing = false);
+  SDValue getIndexedMaskedStore(SDValue OrigStore, const SDLoc &dl,
+                                SDValue Base, SDValue Offset,
+                                ISD::MemIndexedMode AM);
   SDValue getMaskedGather(SDVTList VTs, EVT VT, const SDLoc &dl,
-                          ArrayRef<SDValue> Ops, MachineMemOperand *MMO);
+                          ArrayRef<SDValue> Ops, MachineMemOperand *MMO,
+                          ISD::MemIndexType IndexType, ISD::LoadExtType ExtTy);
   SDValue getMaskedScatter(SDVTList VTs, EVT VT, const SDLoc &dl,
-                           ArrayRef<SDValue> Ops, MachineMemOperand *MMO);
-
-  /// Return (create a new or find existing) a target-specific node.
-  /// TargetMemSDNode should be derived class from MemSDNode.
-  template <class TargetMemSDNode>
-  SDValue getTargetMemSDNode(SDVTList VTs, ArrayRef<SDValue> Ops,
-                             const SDLoc &dl, EVT MemVT,
-                             MachineMemOperand *MMO);
+                           ArrayRef<SDValue> Ops, MachineMemOperand *MMO,
+                           ISD::MemIndexType IndexType,
+                           bool IsTruncating = false);
 
   /// Construct a node to track a Value* through the backend.
   SDValue getSrcValue(const Value *v);
@@ -1142,6 +1382,12 @@
   SDValue getAddrSpaceCast(const SDLoc &dl, EVT VT, SDValue Ptr, unsigned SrcAS,
                            unsigned DestAS);
 
+  /// Return a freeze using the SDLoc of the value operand.
+  SDValue getFreeze(SDValue V);
+
+  /// Return an AssertAlignSDNode.
+  SDValue getAssertAlign(const SDLoc &DL, SDValue V, Align A);
+
   /// Return the specified value casted to
   /// the target's desired shift amount type.
   SDValue getShiftAmountOperand(EVT LHSTy, SDValue Op);
@@ -1185,6 +1431,9 @@
   void setNodeMemRefs(MachineSDNode *N,
                       ArrayRef<MachineMemOperand *> NewMemRefs);
 
+  // Calculate divergence of node \p N based on its operands.
+  bool calculateDivergence(SDNode *N);
+
   // Propagates the change in divergence to users
   void updateDivergence(SDNode * N);
 
@@ -1205,8 +1454,6 @@
                        EVT VT2, ArrayRef<SDValue> Ops);
   SDNode *SelectNodeTo(SDNode *N, unsigned MachineOpc, EVT VT1,
                        EVT VT2, EVT VT3, ArrayRef<SDValue> Ops);
-  SDNode *SelectNodeTo(SDNode *N, unsigned TargetOpc, EVT VT1,
-                       EVT VT2, SDValue Op1);
   SDNode *SelectNodeTo(SDNode *N, unsigned MachineOpc, EVT VT1,
                        EVT VT2, SDValue Op1, SDValue Op2);
   SDNode *SelectNodeTo(SDNode *N, unsigned MachineOpc, SDVTList VTs,
@@ -1264,8 +1511,13 @@
                                 SDValue Operand, SDValue Subreg);
 
   /// Get the specified node if it's already available, or else return NULL.
-  SDNode *getNodeIfExists(unsigned Opcode, SDVTList VTList, ArrayRef<SDValue> Ops,
-                          const SDNodeFlags Flags = SDNodeFlags());
+  SDNode *getNodeIfExists(unsigned Opcode, SDVTList VTList,
+                          ArrayRef<SDValue> Ops, const SDNodeFlags Flags);
+  SDNode *getNodeIfExists(unsigned Opcode, SDVTList VTList,
+                          ArrayRef<SDValue> Ops);
+
+  /// Check if a node exists without modifying its flags.
+  bool doesNodeExist(unsigned Opcode, SDVTList VTList, ArrayRef<SDValue> Ops);
 
   /// Creates a SDDbgValue node.
   SDDbgValue *getDbgValue(DIVariable *Var, DIExpression *Expr, SDNode *N,
@@ -1339,7 +1591,14 @@
   /// chain to the token factor. This ensures that the new memory node will have
   /// the same relative memory dependency position as the old load. Returns the
   /// new merged load chain.
-  SDValue makeEquivalentMemoryOrdering(LoadSDNode *Old, SDValue New);
+  SDValue makeEquivalentMemoryOrdering(SDValue OldChain, SDValue NewMemOpChain);
+
+  /// If an existing load has uses of its chain, create a token factor node with
+  /// that chain and the new memory node's chain and update users of the old
+  /// chain to the token factor. This ensures that the new memory node will have
+  /// the same relative memory dependency position as the old load. Returns the
+  /// new merged load chain.
+  SDValue makeEquivalentMemoryOrdering(LoadSDNode *OldLoad, SDValue NewMemOp);
 
   /// Topological-sort the AllNodes list and a
   /// assign a unique node id for each node in the DAG based on their
@@ -1359,6 +1618,7 @@
     switch (VT.getScalarType().getSimpleVT().SimpleTy) {
     default: llvm_unreachable("Unknown FP format");
     case MVT::f16:     return APFloat::IEEEhalf();
+    case MVT::bf16:    return APFloat::BFloat();
     case MVT::f32:     return APFloat::IEEEsingle();
     case MVT::f64:     return APFloat::IEEEdouble();
     case MVT::f80:     return APFloat::x87DoubleExtended();
@@ -1407,6 +1667,15 @@
 
   void dump() const;
 
+  /// In most cases this function returns the ABI alignment for a given type,
+  /// except for illegal vector types where the alignment exceeds that of the
+  /// stack. In such cases we attempt to break the vector down to a legal type
+  /// and return the ABI alignment for that instead.
+  Align getReducedAlign(EVT VT, bool UseABI);
+
+  /// Create a stack temporary based on the size in bytes and the alignment
+  SDValue CreateStackTemporary(TypeSize Bytes, Align Alignment);
+
   /// Create a stack temporary, suitable for holding the specified value type.
   /// If minAlign is specified, the slot size will have at least that alignment.
   SDValue CreateStackTemporary(EVT VT, unsigned minAlign = 1);
@@ -1420,11 +1689,7 @@
                            const SDNode *N2);
 
   SDValue FoldConstantArithmetic(unsigned Opcode, const SDLoc &DL, EVT VT,
-                                 SDNode *N1, SDNode *N2);
-
-  SDValue FoldConstantArithmetic(unsigned Opcode, const SDLoc &DL, EVT VT,
-                                 const ConstantSDNode *C1,
-                                 const ConstantSDNode *C2);
+                                 ArrayRef<SDValue> Ops);
 
   SDValue FoldConstantVectorArithmetic(unsigned Opcode, const SDLoc &DL, EVT VT,
                                        ArrayRef<SDValue> Ops,
@@ -1571,7 +1836,8 @@
   /// for \p DemandedElts.
   ///
   /// NOTE: The function will return true for a demanded splat of UNDEF values.
-  bool isSplatValue(SDValue V, const APInt &DemandedElts, APInt &UndefElts);
+  bool isSplatValue(SDValue V, const APInt &DemandedElts, APInt &UndefElts,
+                    unsigned Depth = 0);
 
   /// Test whether \p V has a splatted value.
   bool isSplatValue(SDValue V, bool AllowUndefs = false);
@@ -1583,14 +1849,34 @@
   /// that element from the source vector.
   SDValue getSplatValue(SDValue V);
 
+  /// If a SHL/SRA/SRL node \p V has a constant or splat constant shift amount
+  /// that is less than the element bit-width of the shift node, return it.
+  const APInt *getValidShiftAmountConstant(SDValue V,
+                                           const APInt &DemandedElts) const;
+
+  /// If a SHL/SRA/SRL node \p V has constant shift amounts that are all less
+  /// than the element bit-width of the shift node, return the minimum value.
+  const APInt *
+  getValidMinimumShiftAmountConstant(SDValue V,
+                                     const APInt &DemandedElts) const;
+
+  /// If a SHL/SRA/SRL node \p V has constant shift amounts that are all less
+  /// than the element bit-width of the shift node, return the maximum value.
+  const APInt *
+  getValidMaximumShiftAmountConstant(SDValue V,
+                                     const APInt &DemandedElts) const;
+
   /// Match a binop + shuffle pyramid that represents a horizontal reduction
   /// over the elements of a vector starting from the EXTRACT_VECTOR_ELT node /p
   /// Extract. The reduction must use one of the opcodes listed in /p
   /// CandidateBinOps and on success /p BinOp will contain the matching opcode.
   /// Returns the vector that is being reduced on, or SDValue() if a reduction
-  /// was not matched.
+  /// was not matched. If \p AllowPartials is set then in the case of a
+  /// reduction pattern that only matches the first few stages, the extracted
+  /// subvector of the start of the reduction is returned.
   SDValue matchBinOpReduction(SDNode *Extract, ISD::NodeType &BinOp,
-                              ArrayRef<ISD::NodeType> CandidateBinOps);
+                              ArrayRef<ISD::NodeType> CandidateBinOps,
+                              bool AllowPartials = false);
 
   /// Utility function used by legalize and lowering to
   /// "unroll" a vector operation by splitting out the scalars and operating
@@ -1612,14 +1898,28 @@
   bool areNonVolatileConsecutiveLoads(LoadSDNode *LD, LoadSDNode *Base,
                                       unsigned Bytes, int Dist) const;
 
-  /// Infer alignment of a load / store address. Return 0 if
-  /// it cannot be inferred.
-  unsigned InferPtrAlignment(SDValue Ptr) const;
+  /// Infer alignment of a load / store address. Return None if it cannot be
+  /// inferred.
+  MaybeAlign InferPtrAlign(SDValue Ptr) const;
+
+  LLVM_ATTRIBUTE_DEPRECATED(inline unsigned InferPtrAlignment(SDValue Ptr)
+                                const,
+                            "Use InferPtrAlign instead") {
+    if (auto A = InferPtrAlign(Ptr))
+      return A->value();
+    return 0;
+  }
 
   /// Compute the VTs needed for the low/hi parts of a type
   /// which is split (or expanded) into two not necessarily identical pieces.
   std::pair<EVT, EVT> GetSplitDestVTs(const EVT &VT) const;
 
+  /// Compute the VTs needed for the low/hi parts of a type, dependent on an
+  /// enveloping VT that has been split into two identical pieces. Sets the
+  /// HisIsEmpty flag when hi type has zero storage size.
+  std::pair<EVT, EVT> GetDependentSplitDestVTs(const EVT &VT, const EVT &EnvVT,
+                                               bool *HiIsEmpty) const;
+
   /// Split the vector with EXTRACT_SUBVECTOR using the provides
   /// VTs and return the low/high part.
   std::pair<SDValue, SDValue> SplitVector(const SDValue &N, const SDLoc &DL,
@@ -1642,38 +1942,82 @@
   /// Widen the vector up to the next power of two using INSERT_SUBVECTOR.
   SDValue WidenVector(const SDValue &N, const SDLoc &DL);
 
-  /// Append the extracted elements from Start to Count out of the vector Op
-  /// in Args. If Count is 0, all of the elements will be extracted.
+  /// Append the extracted elements from Start to Count out of the vector Op in
+  /// Args. If Count is 0, all of the elements will be extracted. The extracted
+  /// elements will have type EVT if it is provided, and otherwise their type
+  /// will be Op's element type.
   void ExtractVectorElements(SDValue Op, SmallVectorImpl<SDValue> &Args,
-                             unsigned Start = 0, unsigned Count = 0);
+                             unsigned Start = 0, unsigned Count = 0,
+                             EVT EltVT = EVT());
 
   /// Compute the default alignment value for the given type.
-  unsigned getEVTAlignment(EVT MemoryVT) const;
+  Align getEVTAlign(EVT MemoryVT) const;
+  /// Compute the default alignment value for the given type.
+  /// FIXME: Remove once transition to Align is over.
+  inline unsigned getEVTAlignment(EVT MemoryVT) const {
+    return getEVTAlign(MemoryVT).value();
+  }
 
   /// Test whether the given value is a constant int or similar node.
-  SDNode *isConstantIntBuildVectorOrConstantInt(SDValue N);
+  SDNode *isConstantIntBuildVectorOrConstantInt(SDValue N) const;
 
   /// Test whether the given value is a constant FP or similar node.
-  SDNode *isConstantFPBuildVectorOrConstantFP(SDValue N);
+  SDNode *isConstantFPBuildVectorOrConstantFP(SDValue N) const ;
 
   /// \returns true if \p N is any kind of constant or build_vector of
   /// constants, int or float. If a vector, it may not necessarily be a splat.
-  inline bool isConstantValueOfAnyType(SDValue N) {
+  inline bool isConstantValueOfAnyType(SDValue N) const {
     return isConstantIntBuildVectorOrConstantInt(N) ||
            isConstantFPBuildVectorOrConstantFP(N);
   }
 
   void addCallSiteInfo(const SDNode *CallNode, CallSiteInfoImpl &&CallInfo) {
-    SDCallSiteInfo[CallNode] = std::move(CallInfo);
+    SDCallSiteDbgInfo[CallNode].CSInfo = std::move(CallInfo);
   }
 
   CallSiteInfo getSDCallSiteInfo(const SDNode *CallNode) {
-    auto I = SDCallSiteInfo.find(CallNode);
-    if (I != SDCallSiteInfo.end())
-      return std::move(I->second);
+    auto I = SDCallSiteDbgInfo.find(CallNode);
+    if (I != SDCallSiteDbgInfo.end())
+      return std::move(I->second).CSInfo;
     return CallSiteInfo();
   }
 
+  void addHeapAllocSite(const SDNode *Node, MDNode *MD) {
+    SDCallSiteDbgInfo[Node].HeapAllocSite = MD;
+  }
+
+  /// Return the HeapAllocSite type associated with the SDNode, if it exists.
+  MDNode *getHeapAllocSite(const SDNode *Node) {
+    auto It = SDCallSiteDbgInfo.find(Node);
+    if (It == SDCallSiteDbgInfo.end())
+      return nullptr;
+    return It->second.HeapAllocSite;
+  }
+
+  void addNoMergeSiteInfo(const SDNode *Node, bool NoMerge) {
+    if (NoMerge)
+      SDCallSiteDbgInfo[Node].NoMerge = NoMerge;
+  }
+
+  bool getNoMergeSiteInfo(const SDNode *Node) {
+    auto I = SDCallSiteDbgInfo.find(Node);
+    if (I == SDCallSiteDbgInfo.end())
+      return false;
+    return I->second.NoMerge;
+  }
+
+  /// Return the current function's default denormal handling kind for the given
+  /// floating point type.
+  DenormalMode getDenormalMode(EVT VT) const {
+    return MF->getDenormalMode(EVTToAPFloatSemantics(VT));
+  }
+
+  bool shouldOptForSize() const;
+
+  /// Get the (commutative) neutral element for the given opcode, if it exists.
+  SDValue getNeutralElement(unsigned Opcode, const SDLoc &DL, EVT VT,
+                            SDNodeFlags Flags);
+
 private:
   void InsertNode(SDNode *N);
   bool RemoveNodeFromCSEMaps(SDNode *N);
@@ -1712,8 +2056,10 @@
   std::map<EVT, SDNode*, EVT::compareRawBits> ExtendedValueTypeNodes;
   StringMap<SDNode*> ExternalSymbols;
 
-  std::map<std::pair<std::string, unsigned char>,SDNode*> TargetExternalSymbols;
+  std::map<std::pair<std::string, unsigned>, SDNode *> TargetExternalSymbols;
   DenseMap<MCSymbol *, SDNode *> MCSymbols;
+
+  FlagInserter *Inserter = nullptr;
 };
 
 template <> struct GraphTraits<SelectionDAG*> : public GraphTraits<SDNode*> {
@@ -1728,41 +2074,6 @@
   }
 };
 
-template <class TargetMemSDNode>
-SDValue SelectionDAG::getTargetMemSDNode(SDVTList VTs,
-                                         ArrayRef<SDValue> Ops,
-                                         const SDLoc &dl, EVT MemVT,
-                                         MachineMemOperand *MMO) {
-  /// Compose node ID and try to find an existing node.
-  FoldingSetNodeID ID;
-  unsigned Opcode =
-    TargetMemSDNode(dl.getIROrder(), DebugLoc(), VTs, MemVT, MMO).getOpcode();
-  ID.AddInteger(Opcode);
-  ID.AddPointer(VTs.VTs);
-  for (auto& Op : Ops) {
-    ID.AddPointer(Op.getNode());
-    ID.AddInteger(Op.getResNo());
-  }
-  ID.AddInteger(MemVT.getRawBits());
-  ID.AddInteger(MMO->getPointerInfo().getAddrSpace());
-  ID.AddInteger(getSyntheticNodeSubclassData<TargetMemSDNode>(
-    dl.getIROrder(), VTs, MemVT, MMO));
-
-  void *IP = nullptr;
-  if (SDNode *E = FindNodeOrInsertPos(ID, dl, IP)) {
-    cast<TargetMemSDNode>(E)->refineAlignment(MMO);
-    return SDValue(E, 0);
-  }
-
-  /// Existing node was not found. Create a new one.
-  auto *N = newSDNode<TargetMemSDNode>(dl.getIROrder(), dl.getDebugLoc(), VTs,
-                                       MemVT, MMO);
-  createOperands(N, Ops);
-  CSEMap.InsertNode(N, IP);
-  InsertNode(N);
-  return SDValue(N, 0);
-}
-
 } // end namespace llvm
 
 #endif // LLVM_CODEGEN_SELECTIONDAG_H
diff --git a/linux-x64/clang/include/llvm/CodeGen/SelectionDAGISel.h b/linux-x64/clang/include/llvm/CodeGen/SelectionDAGISel.h
index 147c325..84bb11e 100644
--- a/linux-x64/clang/include/llvm/CodeGen/SelectionDAGISel.h
+++ b/linux-x64/clang/include/llvm/CodeGen/SelectionDAGISel.h
@@ -18,26 +18,21 @@
 #include "llvm/CodeGen/SelectionDAG.h"
 #include "llvm/CodeGen/TargetSubtargetInfo.h"
 #include "llvm/IR/BasicBlock.h"
-#include "llvm/Pass.h"
 #include <memory>
 
 namespace llvm {
-  class FastISel;
-  class SelectionDAGBuilder;
-  class SDValue;
-  class MachineRegisterInfo;
-  class MachineBasicBlock;
-  class MachineFunction;
-  class MachineInstr;
-  class OptimizationRemarkEmitter;
-  class TargetLowering;
-  class TargetLibraryInfo;
-  class FunctionLoweringInfo;
-  class ScheduleHazardRecognizer;
-  class SwiftErrorValueTracking;
-  class GCFunctionInfo;
-  class ScheduleDAGSDNodes;
-  class LoadInst;
+class AAResults;
+class SelectionDAGBuilder;
+class SDValue;
+class MachineRegisterInfo;
+class MachineFunction;
+class OptimizationRemarkEmitter;
+class TargetLowering;
+class TargetLibraryInfo;
+class FunctionLoweringInfo;
+class SwiftErrorValueTracking;
+class GCFunctionInfo;
+class ScheduleDAGSDNodes;
 
 /// SelectionDAGISel - This is the common base class used for SelectionDAG-based
 /// pattern-matching instruction selectors.
@@ -45,13 +40,13 @@
 public:
   TargetMachine &TM;
   const TargetLibraryInfo *LibInfo;
-  FunctionLoweringInfo *FuncInfo;
+  std::unique_ptr<FunctionLoweringInfo> FuncInfo;
   SwiftErrorValueTracking *SwiftError;
   MachineFunction *MF;
   MachineRegisterInfo *RegInfo;
   SelectionDAG *CurDAG;
-  SelectionDAGBuilder *SDB;
-  AliasAnalysis *AA;
+  std::unique_ptr<SelectionDAGBuilder> SDB;
+  AAResults *AA;
   GCFunctionInfo *GFI;
   CodeGenOpt::Level OptLevel;
   const TargetInstrInfo *TII;
@@ -75,7 +70,7 @@
 
   bool runOnMachineFunction(MachineFunction &MF) override;
 
-  virtual void EmitFunctionEntryCode() {}
+  virtual void emitFunctionEntryCode() {}
 
   /// PreprocessISelDAG - This hook allows targets to hack on the graph before
   /// instruction selection starts.
@@ -162,6 +157,7 @@
     OPC_EmitMergeInputChains1_1,
     OPC_EmitMergeInputChains1_2,
     OPC_EmitCopyToReg,
+    OPC_EmitCopyToReg2,
     OPC_EmitNodeXForm,
     OPC_EmitNode,
     // Space-optimized forms that implicitly encode number of result VTs.
@@ -247,6 +243,11 @@
   virtual StringRef getIncludePathForIndex(unsigned index) {
     llvm_unreachable("Tblgen should generate the implementation of this!");
   }
+
+  bool shouldOptForSize(const MachineFunction *MF) const {
+    return CurDAG->shouldOptForSize();
+  }
+
 public:
   // Calls to these predicates are generated by tblgen.
   bool CheckAndMask(SDValue LHS, ConstantSDNode *RHS,
@@ -301,24 +302,27 @@
     return false;
   }
 
+  /// Return whether the node may raise an FP exception.
+  bool mayRaiseFPException(SDNode *Node) const;
+
   bool isOrEquivalentToAdd(const SDNode *N) const;
 
 private:
 
   // Calls to these functions are generated by tblgen.
-  void Select_INLINEASM(SDNode *N, bool Branch);
+  void Select_INLINEASM(SDNode *N);
   void Select_READ_REGISTER(SDNode *Op);
   void Select_WRITE_REGISTER(SDNode *Op);
   void Select_UNDEF(SDNode *N);
   void CannotYetSelect(SDNode *N);
 
+  void Select_FREEZE(SDNode *N);
+
 private:
   void DoInstructionSelection();
   SDNode *MorphNode(SDNode *Node, unsigned TargetOpc, SDVTList VTList,
                     ArrayRef<SDValue> Ops, unsigned EmitNodeInfo);
 
-  SDNode *MutateStrictFPToFP(SDNode *Node, unsigned NewOpc);
-
   /// Prepares the landing pad to take incoming values or do other EH
   /// personality specific tasks. Returns true if the block should be
   /// instruction selected, false if no code should be emitted for it.
diff --git a/linux-x64/clang/include/llvm/CodeGen/SelectionDAGNodes.h b/linux-x64/clang/include/llvm/CodeGen/SelectionDAGNodes.h
index 5aab964..3d12240 100644
--- a/linux-x64/clang/include/llvm/CodeGen/SelectionDAGNodes.h
+++ b/linux-x64/clang/include/llvm/CodeGen/SelectionDAGNodes.h
@@ -30,6 +30,7 @@
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/CodeGen/ISDOpcodes.h"
 #include "llvm/CodeGen/MachineMemOperand.h"
+#include "llvm/CodeGen/Register.h"
 #include "llvm/CodeGen/ValueTypes.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DebugLoc.h"
@@ -42,6 +43,7 @@
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MachineValueType.h"
+#include "llvm/Support/TypeSize.h"
 #include <algorithm>
 #include <cassert>
 #include <climits>
@@ -83,29 +85,42 @@
 
   /// Node predicates
 
-  /// If N is a BUILD_VECTOR node whose elements are all the same constant or
-  /// undefined, return true and return the constant value in \p SplatValue.
-  bool isConstantSplatVector(const SDNode *N, APInt &SplatValue);
+/// If N is a BUILD_VECTOR or SPLAT_VECTOR node whose elements are all the
+/// same constant or undefined, return true and return the constant value in
+/// \p SplatValue.
+bool isConstantSplatVector(const SDNode *N, APInt &SplatValue);
 
-  /// Return true if the specified node is a BUILD_VECTOR where all of the
-  /// elements are ~0 or undef.
-  bool isBuildVectorAllOnes(const SDNode *N);
+/// Return true if the specified node is a BUILD_VECTOR or SPLAT_VECTOR where
+/// all of the elements are ~0 or undef. If \p BuildVectorOnly is set to
+/// true, it only checks BUILD_VECTOR.
+bool isConstantSplatVectorAllOnes(const SDNode *N,
+                                  bool BuildVectorOnly = false);
 
-  /// Return true if the specified node is a BUILD_VECTOR where all of the
-  /// elements are 0 or undef.
-  bool isBuildVectorAllZeros(const SDNode *N);
+/// Return true if the specified node is a BUILD_VECTOR or SPLAT_VECTOR where
+/// all of the elements are 0 or undef. If \p BuildVectorOnly is set to true, it
+/// only checks BUILD_VECTOR.
+bool isConstantSplatVectorAllZeros(const SDNode *N,
+                                   bool BuildVectorOnly = false);
 
-  /// Return true if the specified node is a BUILD_VECTOR node of all
-  /// ConstantSDNode or undef.
-  bool isBuildVectorOfConstantSDNodes(const SDNode *N);
+/// Return true if the specified node is a BUILD_VECTOR where all of the
+/// elements are ~0 or undef.
+bool isBuildVectorAllOnes(const SDNode *N);
 
-  /// Return true if the specified node is a BUILD_VECTOR node of all
-  /// ConstantFPSDNode or undef.
-  bool isBuildVectorOfConstantFPSDNodes(const SDNode *N);
+/// Return true if the specified node is a BUILD_VECTOR where all of the
+/// elements are 0 or undef.
+bool isBuildVectorAllZeros(const SDNode *N);
 
-  /// Return true if the node has at least one operand and all operands of the
-  /// specified node are ISD::UNDEF.
-  bool allOperandsUndef(const SDNode *N);
+/// Return true if the specified node is a BUILD_VECTOR node of all
+/// ConstantSDNode or undef.
+bool isBuildVectorOfConstantSDNodes(const SDNode *N);
+
+/// Return true if the specified node is a BUILD_VECTOR node of all
+/// ConstantFPSDNode or undef.
+bool isBuildVectorOfConstantFPSDNodes(const SDNode *N);
+
+/// Return true if the node has at least one operand and all operands of the
+/// specified node are ISD::UNDEF.
+bool allOperandsUndef(const SDNode *N);
 
 } // end namespace ISD
 
@@ -170,12 +185,16 @@
   }
 
   /// Returns the size of the value in bits.
-  unsigned getValueSizeInBits() const {
+  ///
+  /// If the value type is a scalable vector type, the scalable property will
+  /// be set and the runtime size will be a positive integer multiple of the
+  /// base size.
+  TypeSize getValueSizeInBits() const {
     return getValueType().getSizeInBits();
   }
 
-  unsigned getScalarValueSizeInBits() const {
-    return getValueType().getScalarType().getSizeInBits();
+  uint64_t getScalarValueSizeInBits() const {
+    return getValueType().getScalarType().getFixedSizeInBits();
   }
 
   // Forwarding methods - These forward to the corresponding methods in SDNode.
@@ -351,11 +370,6 @@
 /// the backend.
 struct SDNodeFlags {
 private:
-  // This bit is used to determine if the flags are in a defined state.
-  // Flag bits can only be masked out during intersection if the masking flags
-  // are defined.
-  bool AnyDefined : 1;
-
   bool NoUnsignedWrap : 1;
   bool NoSignedWrap : 1;
   bool Exact : 1;
@@ -363,7 +377,6 @@
   bool NoInfs : 1;
   bool NoSignedZeros : 1;
   bool AllowReciprocal : 1;
-  bool VectorReduction : 1;
   bool AllowContract : 1;
   bool ApproximateFuncs : 1;
   bool AllowReassociation : 1;
@@ -378,11 +391,10 @@
 public:
   /// Default constructor turns off all optimization flags.
   SDNodeFlags()
-      : AnyDefined(false), NoUnsignedWrap(false), NoSignedWrap(false),
-        Exact(false), NoNaNs(false), NoInfs(false),
-        NoSignedZeros(false), AllowReciprocal(false), VectorReduction(false),
+      : NoUnsignedWrap(false), NoSignedWrap(false), Exact(false), NoNaNs(false),
+        NoInfs(false), NoSignedZeros(false), AllowReciprocal(false),
         AllowContract(false), ApproximateFuncs(false),
-        AllowReassociation(false), NoFPExcept(true) {}
+        AllowReassociation(false), NoFPExcept(false) {}
 
   /// Propagate the fast-math-flags from an IR FPMathOperator.
   void copyFMF(const FPMathOperator &FPMO) {
@@ -395,60 +407,18 @@
     setAllowReassociation(FPMO.hasAllowReassoc());
   }
 
-  /// Sets the state of the flags to the defined state.
-  void setDefined() { AnyDefined = true; }
-  /// Returns true if the flags are in a defined state.
-  bool isDefined() const { return AnyDefined; }
-
   // These are mutators for each flag.
-  void setNoUnsignedWrap(bool b) {
-    setDefined();
-    NoUnsignedWrap = b;
-  }
-  void setNoSignedWrap(bool b) {
-    setDefined();
-    NoSignedWrap = b;
-  }
-  void setExact(bool b) {
-    setDefined();
-    Exact = b;
-  }
-  void setNoNaNs(bool b) {
-    setDefined();
-    NoNaNs = b;
-  }
-  void setNoInfs(bool b) {
-    setDefined();
-    NoInfs = b;
-  }
-  void setNoSignedZeros(bool b) {
-    setDefined();
-    NoSignedZeros = b;
-  }
-  void setAllowReciprocal(bool b) {
-    setDefined();
-    AllowReciprocal = b;
-  }
-  void setVectorReduction(bool b) {
-    setDefined();
-    VectorReduction = b;
-  }
-  void setAllowContract(bool b) {
-    setDefined();
-    AllowContract = b;
-  }
-  void setApproximateFuncs(bool b) {
-    setDefined();
-    ApproximateFuncs = b;
-  }
-  void setAllowReassociation(bool b) {
-    setDefined();
-    AllowReassociation = b;
-  }
-  void setFPExcept(bool b) {
-    setDefined();
-    NoFPExcept = !b;
-  }
+  void setNoUnsignedWrap(bool b) { NoUnsignedWrap = b; }
+  void setNoSignedWrap(bool b) { NoSignedWrap = b; }
+  void setExact(bool b) { Exact = b; }
+  void setNoNaNs(bool b) { NoNaNs = b; }
+  void setNoInfs(bool b) { NoInfs = b; }
+  void setNoSignedZeros(bool b) { NoSignedZeros = b; }
+  void setAllowReciprocal(bool b) { AllowReciprocal = b; }
+  void setAllowContract(bool b) { AllowContract = b; }
+  void setApproximateFuncs(bool b) { ApproximateFuncs = b; }
+  void setAllowReassociation(bool b) { AllowReassociation = b; }
+  void setNoFPExcept(bool b) { NoFPExcept = b; }
 
   // These are accessors for each flag.
   bool hasNoUnsignedWrap() const { return NoUnsignedWrap; }
@@ -458,22 +428,14 @@
   bool hasNoInfs() const { return NoInfs; }
   bool hasNoSignedZeros() const { return NoSignedZeros; }
   bool hasAllowReciprocal() const { return AllowReciprocal; }
-  bool hasVectorReduction() const { return VectorReduction; }
   bool hasAllowContract() const { return AllowContract; }
   bool hasApproximateFuncs() const { return ApproximateFuncs; }
   bool hasAllowReassociation() const { return AllowReassociation; }
-  bool hasFPExcept() const { return !NoFPExcept; }
+  bool hasNoFPExcept() const { return NoFPExcept; }
 
-  bool isFast() const {
-    return NoSignedZeros && AllowReciprocal && NoNaNs && NoInfs && NoFPExcept &&
-           AllowContract && ApproximateFuncs && AllowReassociation;
-  }
-
-  /// Clear any flags in this flag set that aren't also set in Flags.
-  /// If the given Flags are undefined then don't do anything.
+  /// Clear any flags in this flag set that aren't also set in Flags. All
+  /// flags will be cleared if Flags are undefined.
   void intersectWith(const SDNodeFlags Flags) {
-    if (!Flags.isDefined())
-      return;
     NoUnsignedWrap &= Flags.NoUnsignedWrap;
     NoSignedWrap &= Flags.NoSignedWrap;
     Exact &= Flags.Exact;
@@ -481,7 +443,6 @@
     NoInfs &= Flags.NoInfs;
     NoSignedZeros &= Flags.NoSignedZeros;
     AllowReciprocal &= Flags.AllowReciprocal;
-    VectorReduction &= Flags.VectorReduction;
     AllowContract &= Flags.AllowContract;
     ApproximateFuncs &= Flags.ApproximateFuncs;
     AllowReassociation &= Flags.AllowReassociation;
@@ -548,16 +509,24 @@
 
   class LSBaseSDNodeBitfields {
     friend class LSBaseSDNode;
+    friend class MaskedLoadStoreSDNode;
+    friend class MaskedGatherScatterSDNode;
 
     uint16_t : NumMemSDNodeBits;
 
-    uint16_t AddressingMode : 3; // enum ISD::MemIndexedMode
+    // This storage is shared between disparate class hierarchies to hold an
+    // enumeration specific to the class hierarchy in use.
+    //   LSBaseSDNode => enum ISD::MemIndexedMode
+    //   MaskedLoadStoreBaseSDNode => enum ISD::MemIndexedMode
+    //   MaskedGatherScatterSDNode => enum ISD::MemIndexType
+    uint16_t AddressingMode : 3;
   };
   enum { NumLSBaseSDNodeBits = NumMemSDNodeBits + 3 };
 
   class LoadSDNodeBitfields {
     friend class LoadSDNode;
     friend class MaskedLoadSDNode;
+    friend class MaskedGatherSDNode;
 
     uint16_t : NumLSBaseSDNodeBits;
 
@@ -568,6 +537,7 @@
   class StoreSDNodeBitfields {
     friend class StoreSDNode;
     friend class MaskedStoreSDNode;
+    friend class MaskedScatterSDNode;
 
     uint16_t : NumLSBaseSDNodeBits;
 
@@ -654,6 +624,15 @@
   /// \<target\>ISD namespace).
   bool isTargetOpcode() const { return NodeType >= ISD::BUILTIN_OP_END; }
 
+  /// Test if this node has a target-specific opcode that may raise
+  /// FP exceptions (in the \<target\>ISD namespace and greater than
+  /// FIRST_TARGET_STRICTFP_OPCODE).  Note that all target memory
+  /// opcode are currently automatically considered to possibly raise
+  /// FP exceptions as well.
+  bool isTargetStrictFPOpcode() const {
+    return NodeType >= ISD::FIRST_TARGET_STRICTFP_OPCODE;
+  }
+
   /// Test if this node has a target-specific
   /// memory-referencing opcode (in the \<target\>ISD namespace and
   /// greater than FIRST_TARGET_MEMORY_OPCODE).
@@ -680,32 +659,11 @@
     switch (NodeType) {
       default:
         return false;
-      case ISD::STRICT_FADD:
-      case ISD::STRICT_FSUB:
-      case ISD::STRICT_FMUL:
-      case ISD::STRICT_FDIV:
-      case ISD::STRICT_FREM:
-      case ISD::STRICT_FMA:
-      case ISD::STRICT_FSQRT:
-      case ISD::STRICT_FPOW:
-      case ISD::STRICT_FPOWI:
-      case ISD::STRICT_FSIN:
-      case ISD::STRICT_FCOS:
-      case ISD::STRICT_FEXP:
-      case ISD::STRICT_FEXP2:
-      case ISD::STRICT_FLOG:
-      case ISD::STRICT_FLOG10:
-      case ISD::STRICT_FLOG2:
-      case ISD::STRICT_FRINT:
-      case ISD::STRICT_FNEARBYINT:
-      case ISD::STRICT_FMAXNUM:
-      case ISD::STRICT_FMINNUM:
-      case ISD::STRICT_FCEIL:
-      case ISD::STRICT_FFLOOR:
-      case ISD::STRICT_FROUND:
-      case ISD::STRICT_FTRUNC:
-      case ISD::STRICT_FP_ROUND:
-      case ISD::STRICT_FP_EXTEND:
+      case ISD::STRICT_FP16_TO_FP:
+      case ISD::STRICT_FP_TO_FP16:
+#define DAG_INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC, DAGN)               \
+      case ISD::STRICT_##DAGN:
+#include "llvm/IR/ConstrainedOps.def"
         return true;
     }
   }
@@ -990,7 +948,6 @@
 
   const SDNodeFlags getFlags() const { return Flags; }
   void setFlags(SDNodeFlags NewFlags) { Flags = NewFlags; }
-  bool isFast() { return Flags.isFast(); }
 
   /// Clear any flags in this node that aren't also set in Flags.
   /// If Flags is not in a defined state then this has no effect.
@@ -1011,7 +968,11 @@
   }
 
   /// Returns MVT::getSizeInBits(getValueType(ResNo)).
-  unsigned getValueSizeInBits(unsigned ResNo) const {
+  ///
+  /// If the value type is a scalable vector type, the scalable property will
+  /// be set and the runtime size will be a positive integer multiple of the
+  /// base size.
+  TypeSize getValueSizeInBits(unsigned ResNo) const {
     return getValueType(ResNo).getSizeInBits();
   }
 
@@ -1019,6 +980,9 @@
 
   value_iterator value_begin() const { return ValueList; }
   value_iterator value_end() const { return ValueList+NumValues; }
+  iterator_range<value_iterator> values() const {
+    return llvm::make_range(value_begin(), value_end());
+  }
 
   /// Return the opcode of this operation for printing.
   std::string getOperationName(const SelectionDAG *G = nullptr) const;
@@ -1298,12 +1262,14 @@
   bool writeMem() const { return MMO->isStore(); }
 
   /// Returns alignment and volatility of the memory access
-  unsigned getOriginalAlignment() const {
-    return MMO->getBaseAlignment();
+  Align getOriginalAlign() const { return MMO->getBaseAlign(); }
+  Align getAlign() const { return MMO->getAlign(); }
+  LLVM_ATTRIBUTE_DEPRECATED(unsigned getOriginalAlignment() const,
+                            "Use getOriginalAlign() instead") {
+    return MMO->getBaseAlign().value();
   }
-  unsigned getAlignment() const {
-    return MMO->getAlignment();
-  }
+  // FIXME: Remove once transition to getAlign is over.
+  unsigned getAlignment() const { return MMO->getAlign().value(); }
 
   /// Return the SubclassData value, without HasDebugValue. This contains an
   /// encoding of the volatile flag, as well as bits used by subclasses. This
@@ -1346,6 +1312,17 @@
   /// store occurs.
   AtomicOrdering getOrdering() const { return MMO->getOrdering(); }
 
+  /// Return true if the memory operation ordering is Unordered or higher.
+  bool isAtomic() const { return MMO->isAtomic(); }
+
+  /// Returns true if the memory operation doesn't imply any ordering
+  /// constraints on surrounding memory operations beyond the normal memory
+  /// aliasing rules.
+  bool isUnordered() const { return MMO->isUnordered(); }
+
+  /// Returns true if the memory operation is neither atomic or volatile.
+  bool isSimple() const { return !isAtomic() && !isVolatile(); }
+
   /// Return the type of the in-memory value.
   EVT getMemoryVT() const { return MemoryVT; }
 
@@ -1371,8 +1348,18 @@
   }
 
   const SDValue &getChain() const { return getOperand(0); }
+
   const SDValue &getBasePtr() const {
-    return getOperand(getOpcode() == ISD::STORE ? 2 : 1);
+    switch (getOpcode()) {
+    case ISD::STORE:
+    case ISD::MSTORE:
+      return getOperand(2);
+    case ISD::MGATHER:
+    case ISD::MSCATTER:
+      return getOperand(3);
+    default:
+      return getOperand(1);
+    }
   }
 
   // Methods to support isa and dyn_cast
@@ -1568,6 +1555,8 @@
   uint64_t getLimitedValue(uint64_t Limit = UINT64_MAX) {
     return Value->getLimitedValue(Limit);
   }
+  MaybeAlign getMaybeAlignValue() const { return Value->getMaybeAlignValue(); }
+  Align getAlignValue() const { return Value->getAlignValue(); }
 
   bool isOne() const { return Value->isOne(); }
   bool isNullValue() const { return Value->isZero(); }
@@ -1702,16 +1691,16 @@
 
   const GlobalValue *TheGlobal;
   int64_t Offset;
-  unsigned char TargetFlags;
+  unsigned TargetFlags;
 
   GlobalAddressSDNode(unsigned Opc, unsigned Order, const DebugLoc &DL,
                       const GlobalValue *GA, EVT VT, int64_t o,
-                      unsigned char TF);
+                      unsigned TF);
 
 public:
   const GlobalValue *getGlobal() const { return TheGlobal; }
   int64_t getOffset() const { return Offset; }
-  unsigned char getTargetFlags() const { return TargetFlags; }
+  unsigned getTargetFlags() const { return TargetFlags; }
   // Return the address space this GlobalAddress belongs to.
   unsigned getAddressSpace() const;
 
@@ -1774,20 +1763,46 @@
   }
 };
 
+/// This SDNode is used for PSEUDO_PROBE values, which are the function guid and
+/// the index of the basic block being probed. A pseudo probe serves as a place
+/// holder and will be removed at the end of compilation. It does not have any
+/// operand because we do not want the instruction selection to deal with any.
+class PseudoProbeSDNode : public SDNode {
+  friend class SelectionDAG;
+  uint64_t Guid;
+  uint64_t Index;
+  uint32_t Attributes;
+
+  PseudoProbeSDNode(unsigned Opcode, unsigned Order, const DebugLoc &Dl,
+                    SDVTList VTs, uint64_t Guid, uint64_t Index, uint32_t Attr)
+      : SDNode(Opcode, Order, Dl, VTs), Guid(Guid), Index(Index),
+        Attributes(Attr) {}
+
+public:
+  uint64_t getGuid() const { return Guid; }
+  uint64_t getIndex() const { return Index; }
+  uint32_t getAttributes() const { return Attributes; }
+
+  // Methods to support isa and dyn_cast
+  static bool classof(const SDNode *N) {
+    return N->getOpcode() == ISD::PSEUDO_PROBE;
+  }
+};
+
 class JumpTableSDNode : public SDNode {
   friend class SelectionDAG;
 
   int JTI;
-  unsigned char TargetFlags;
+  unsigned TargetFlags;
 
-  JumpTableSDNode(int jti, EVT VT, bool isTarg, unsigned char TF)
+  JumpTableSDNode(int jti, EVT VT, bool isTarg, unsigned TF)
     : SDNode(isTarg ? ISD::TargetJumpTable : ISD::JumpTable,
       0, DebugLoc(), getSDVTList(VT)), JTI(jti), TargetFlags(TF) {
   }
 
 public:
   int getIndex() const { return JTI; }
-  unsigned char getTargetFlags() const { return TargetFlags; }
+  unsigned getTargetFlags() const { return TargetFlags; }
 
   static bool classof(const SDNode *N) {
     return N->getOpcode() == ISD::JumpTable ||
@@ -1803,23 +1818,23 @@
     MachineConstantPoolValue *MachineCPVal;
   } Val;
   int Offset;  // It's a MachineConstantPoolValue if top bit is set.
-  unsigned Alignment;  // Minimum alignment requirement of CP (not log2 value).
-  unsigned char TargetFlags;
+  Align Alignment; // Minimum alignment requirement of CP.
+  unsigned TargetFlags;
 
   ConstantPoolSDNode(bool isTarget, const Constant *c, EVT VT, int o,
-                     unsigned Align, unsigned char TF)
-    : SDNode(isTarget ? ISD::TargetConstantPool : ISD::ConstantPool, 0,
-             DebugLoc(), getSDVTList(VT)), Offset(o), Alignment(Align),
-             TargetFlags(TF) {
+                     Align Alignment, unsigned TF)
+      : SDNode(isTarget ? ISD::TargetConstantPool : ISD::ConstantPool, 0,
+               DebugLoc(), getSDVTList(VT)),
+        Offset(o), Alignment(Alignment), TargetFlags(TF) {
     assert(Offset >= 0 && "Offset is too large");
     Val.ConstVal = c;
   }
 
-  ConstantPoolSDNode(bool isTarget, MachineConstantPoolValue *v,
-                     EVT VT, int o, unsigned Align, unsigned char TF)
-    : SDNode(isTarget ? ISD::TargetConstantPool : ISD::ConstantPool, 0,
-             DebugLoc(), getSDVTList(VT)), Offset(o), Alignment(Align),
-             TargetFlags(TF) {
+  ConstantPoolSDNode(bool isTarget, MachineConstantPoolValue *v, EVT VT, int o,
+                     Align Alignment, unsigned TF)
+      : SDNode(isTarget ? ISD::TargetConstantPool : ISD::ConstantPool, 0,
+               DebugLoc(), getSDVTList(VT)),
+        Offset(o), Alignment(Alignment), TargetFlags(TF) {
     assert(Offset >= 0 && "Offset is too large");
     Val.MachineCPVal = v;
     Offset |= 1 << (sizeof(unsigned)*CHAR_BIT-1);
@@ -1846,8 +1861,8 @@
 
   // Return the alignment of this constant pool object, which is either 0 (for
   // default alignment) or the desired value.
-  unsigned getAlignment() const { return Alignment; }
-  unsigned char getTargetFlags() const { return TargetFlags; }
+  Align getAlign() const { return Alignment; }
+  unsigned getTargetFlags() const { return TargetFlags; }
 
   Type *getType() const;
 
@@ -1861,16 +1876,16 @@
 class TargetIndexSDNode : public SDNode {
   friend class SelectionDAG;
 
-  unsigned char TargetFlags;
+  unsigned TargetFlags;
   int Index;
   int64_t Offset;
 
 public:
-  TargetIndexSDNode(int Idx, EVT VT, int64_t Ofs, unsigned char TF)
-    : SDNode(ISD::TargetIndex, 0, DebugLoc(), getSDVTList(VT)),
-      TargetFlags(TF), Index(Idx), Offset(Ofs) {}
+  TargetIndexSDNode(int Idx, EVT VT, int64_t Ofs, unsigned TF)
+      : SDNode(ISD::TargetIndex, 0, DebugLoc(), getSDVTList(VT)),
+        TargetFlags(TF), Index(Idx), Offset(Ofs) {}
 
-  unsigned char getTargetFlags() const { return TargetFlags; }
+  unsigned getTargetFlags() const { return TargetFlags; }
   int getIndex() const { return Index; }
   int64_t getOffset() const { return Offset; }
 
@@ -1934,6 +1949,33 @@
   /// the vector width and set the bits where elements are undef.
   SDValue getSplatValue(BitVector *UndefElements = nullptr) const;
 
+  /// Find the shortest repeating sequence of values in the build vector.
+  ///
+  /// e.g. { u, X, u, X, u, u, X, u } -> { X }
+  ///      { X, Y, u, Y, u, u, X, u } -> { X, Y }
+  ///
+  /// Currently this must be a power-of-2 build vector.
+  /// The DemandedElts mask indicates the elements that must be present,
+  /// undemanded elements in Sequence may be null (SDValue()). If passed a
+  /// non-null UndefElements bitvector, it will resize it to match the original
+  /// vector width and set the bits where elements are undef. If result is
+  /// false, Sequence will be empty.
+  bool getRepeatedSequence(const APInt &DemandedElts,
+                           SmallVectorImpl<SDValue> &Sequence,
+                           BitVector *UndefElements = nullptr) const;
+
+  /// Find the shortest repeating sequence of values in the build vector.
+  ///
+  /// e.g. { u, X, u, X, u, u, X, u } -> { X }
+  ///      { X, Y, u, Y, u, u, X, u } -> { X, Y }
+  ///
+  /// Currently this must be a power-of-2 build vector.
+  /// If passed a non-null UndefElements bitvector, it will resize it to match
+  /// the original vector width and set the bits where elements are undef.
+  /// If result is false, Sequence will be empty.
+  bool getRepeatedSequence(SmallVectorImpl<SDValue> &Sequence,
+                           BitVector *UndefElements = nullptr) const;
+
   /// Returns the demanded splatted constant or null if this is not a constant
   /// splat.
   ///
@@ -2027,13 +2069,13 @@
 class RegisterSDNode : public SDNode {
   friend class SelectionDAG;
 
-  unsigned Reg;
+  Register Reg;
 
-  RegisterSDNode(unsigned reg, EVT VT)
+  RegisterSDNode(Register reg, EVT VT)
     : SDNode(ISD::Register, 0, DebugLoc(), getSDVTList(VT)), Reg(reg) {}
 
 public:
-  unsigned getReg() const { return Reg; }
+  Register getReg() const { return Reg; }
 
   static bool classof(const SDNode *N) {
     return N->getOpcode() == ISD::Register;
@@ -2063,17 +2105,17 @@
 
   const BlockAddress *BA;
   int64_t Offset;
-  unsigned char TargetFlags;
+  unsigned TargetFlags;
 
   BlockAddressSDNode(unsigned NodeTy, EVT VT, const BlockAddress *ba,
-                     int64_t o, unsigned char Flags)
+                     int64_t o, unsigned Flags)
     : SDNode(NodeTy, 0, DebugLoc(), getSDVTList(VT)),
              BA(ba), Offset(o), TargetFlags(Flags) {}
 
 public:
   const BlockAddress *getBlockAddress() const { return BA; }
   int64_t getOffset() const { return Offset; }
-  unsigned char getTargetFlags() const { return TargetFlags; }
+  unsigned getTargetFlags() const { return TargetFlags; }
 
   static bool classof(const SDNode *N) {
     return N->getOpcode() == ISD::BlockAddress ||
@@ -2104,15 +2146,16 @@
   friend class SelectionDAG;
 
   const char *Symbol;
-  unsigned char TargetFlags;
+  unsigned TargetFlags;
 
-  ExternalSymbolSDNode(bool isTarget, const char *Sym, unsigned char TF, EVT VT)
-    : SDNode(isTarget ? ISD::TargetExternalSymbol : ISD::ExternalSymbol,
-             0, DebugLoc(), getSDVTList(VT)), Symbol(Sym), TargetFlags(TF) {}
+  ExternalSymbolSDNode(bool isTarget, const char *Sym, unsigned TF, EVT VT)
+      : SDNode(isTarget ? ISD::TargetExternalSymbol : ISD::ExternalSymbol, 0,
+               DebugLoc(), getSDVTList(VT)),
+        Symbol(Sym), TargetFlags(TF) {}
 
 public:
   const char *getSymbol() const { return Symbol; }
-  unsigned char getTargetFlags() const { return TargetFlags; }
+  unsigned getTargetFlags() const { return TargetFlags; }
 
   static bool classof(const SDNode *N) {
     return N->getOpcode() == ISD::ExternalSymbol ||
@@ -2181,8 +2224,6 @@
       : MemSDNode(NodeTy, Order, dl, VTs, MemVT, MMO) {
     LSBaseSDNodeBits.AddressingMode = AM;
     assert(getAddressingMode() == AM && "Value truncated");
-    assert((!MMO->isAtomic() || MMO->isVolatile()) &&
-           "use an AtomicSDNode instead for non-volatile atomics");
   }
 
   const SDValue &getOffset() const {
@@ -2272,19 +2313,35 @@
   friend class SelectionDAG;
 
   MaskedLoadStoreSDNode(ISD::NodeType NodeTy, unsigned Order,
-                        const DebugLoc &dl, SDVTList VTs, EVT MemVT,
+                        const DebugLoc &dl, SDVTList VTs,
+                        ISD::MemIndexedMode AM, EVT MemVT,
                         MachineMemOperand *MMO)
-      : MemSDNode(NodeTy, Order, dl, VTs, MemVT, MMO) {}
-
-  // MaskedLoadSDNode (Chain, ptr, mask, passthru)
-  // MaskedStoreSDNode (Chain, data, ptr, mask)
-  // Mask is a vector of i1 elements
-  const SDValue &getBasePtr() const {
-    return getOperand(getOpcode() == ISD::MLOAD ? 1 : 2);
+      : MemSDNode(NodeTy, Order, dl, VTs, MemVT, MMO) {
+    LSBaseSDNodeBits.AddressingMode = AM;
+    assert(getAddressingMode() == AM && "Value truncated");
   }
-  const SDValue &getMask() const {
+
+  // MaskedLoadSDNode (Chain, ptr, offset, mask, passthru)
+  // MaskedStoreSDNode (Chain, data, ptr, offset, mask)
+  // Mask is a vector of i1 elements
+  const SDValue &getOffset() const {
     return getOperand(getOpcode() == ISD::MLOAD ? 2 : 3);
   }
+  const SDValue &getMask() const {
+    return getOperand(getOpcode() == ISD::MLOAD ? 3 : 4);
+  }
+
+  /// Return the addressing mode for this load or store:
+  /// unindexed, pre-inc, pre-dec, post-inc, or post-dec.
+  ISD::MemIndexedMode getAddressingMode() const {
+    return static_cast<ISD::MemIndexedMode>(LSBaseSDNodeBits.AddressingMode);
+  }
+
+  /// Return true if this is a pre/post inc/dec load/store.
+  bool isIndexed() const { return getAddressingMode() != ISD::UNINDEXED; }
+
+  /// Return true if this is NOT a pre/post inc/dec load/store.
+  bool isUnindexed() const { return getAddressingMode() == ISD::UNINDEXED; }
 
   static bool classof(const SDNode *N) {
     return N->getOpcode() == ISD::MLOAD ||
@@ -2298,9 +2355,9 @@
   friend class SelectionDAG;
 
   MaskedLoadSDNode(unsigned Order, const DebugLoc &dl, SDVTList VTs,
-                   ISD::LoadExtType ETy, bool IsExpanding, EVT MemVT,
-                   MachineMemOperand *MMO)
-      : MaskedLoadStoreSDNode(ISD::MLOAD, Order, dl, VTs, MemVT, MMO) {
+                   ISD::MemIndexedMode AM, ISD::LoadExtType ETy,
+                   bool IsExpanding, EVT MemVT, MachineMemOperand *MMO)
+      : MaskedLoadStoreSDNode(ISD::MLOAD, Order, dl, VTs, AM, MemVT, MMO) {
     LoadSDNodeBits.ExtTy = ETy;
     LoadSDNodeBits.IsExpanding = IsExpanding;
   }
@@ -2310,8 +2367,9 @@
   }
 
   const SDValue &getBasePtr() const { return getOperand(1); }
-  const SDValue &getMask() const    { return getOperand(2); }
-  const SDValue &getPassThru() const { return getOperand(3); }
+  const SDValue &getOffset() const { return getOperand(2); }
+  const SDValue &getMask() const { return getOperand(3); }
+  const SDValue &getPassThru() const { return getOperand(4); }
 
   static bool classof(const SDNode *N) {
     return N->getOpcode() == ISD::MLOAD;
@@ -2326,9 +2384,9 @@
   friend class SelectionDAG;
 
   MaskedStoreSDNode(unsigned Order, const DebugLoc &dl, SDVTList VTs,
-                    bool isTrunc, bool isCompressing, EVT MemVT,
-                    MachineMemOperand *MMO)
-      : MaskedLoadStoreSDNode(ISD::MSTORE, Order, dl, VTs, MemVT, MMO) {
+                    ISD::MemIndexedMode AM, bool isTrunc, bool isCompressing,
+                    EVT MemVT, MachineMemOperand *MMO)
+      : MaskedLoadStoreSDNode(ISD::MSTORE, Order, dl, VTs, AM, MemVT, MMO) {
     StoreSDNodeBits.IsTruncating = isTrunc;
     StoreSDNodeBits.IsCompressing = isCompressing;
   }
@@ -2344,9 +2402,10 @@
   /// memory at base_addr.
   bool isCompressingStore() const { return StoreSDNodeBits.IsCompressing; }
 
-  const SDValue &getValue() const   { return getOperand(1); }
+  const SDValue &getValue() const { return getOperand(1); }
   const SDValue &getBasePtr() const { return getOperand(2); }
-  const SDValue &getMask() const    { return getOperand(3); }
+  const SDValue &getOffset() const { return getOperand(3); }
+  const SDValue &getMask() const { return getOperand(4); }
 
   static bool classof(const SDNode *N) {
     return N->getOpcode() == ISD::MSTORE;
@@ -2362,8 +2421,27 @@
 
   MaskedGatherScatterSDNode(ISD::NodeType NodeTy, unsigned Order,
                             const DebugLoc &dl, SDVTList VTs, EVT MemVT,
-                            MachineMemOperand *MMO)
-      : MemSDNode(NodeTy, Order, dl, VTs, MemVT, MMO) {}
+                            MachineMemOperand *MMO, ISD::MemIndexType IndexType)
+      : MemSDNode(NodeTy, Order, dl, VTs, MemVT, MMO) {
+    LSBaseSDNodeBits.AddressingMode = IndexType;
+    assert(getIndexType() == IndexType && "Value truncated");
+  }
+
+  /// How is Index applied to BasePtr when computing addresses.
+  ISD::MemIndexType getIndexType() const {
+    return static_cast<ISD::MemIndexType>(LSBaseSDNodeBits.AddressingMode);
+  }
+  void setIndexType(ISD::MemIndexType IndexType) {
+    LSBaseSDNodeBits.AddressingMode = IndexType;
+  }
+  bool isIndexScaled() const {
+    return (getIndexType() == ISD::SIGNED_SCALED) ||
+           (getIndexType() == ISD::UNSIGNED_SCALED);
+  }
+  bool isIndexSigned() const {
+    return (getIndexType() == ISD::SIGNED_SCALED) ||
+           (getIndexType() == ISD::SIGNED_UNSCALED);
+  }
 
   // In the both nodes address is Op1, mask is Op2:
   // MaskedGatherSDNode  (Chain, passthru, mask, base, index, scale)
@@ -2387,11 +2465,19 @@
   friend class SelectionDAG;
 
   MaskedGatherSDNode(unsigned Order, const DebugLoc &dl, SDVTList VTs,
-                     EVT MemVT, MachineMemOperand *MMO)
-      : MaskedGatherScatterSDNode(ISD::MGATHER, Order, dl, VTs, MemVT, MMO) {}
+                     EVT MemVT, MachineMemOperand *MMO,
+                     ISD::MemIndexType IndexType, ISD::LoadExtType ETy)
+      : MaskedGatherScatterSDNode(ISD::MGATHER, Order, dl, VTs, MemVT, MMO,
+                                  IndexType) {
+    LoadSDNodeBits.ExtTy = ETy;
+  }
 
   const SDValue &getPassThru() const { return getOperand(1); }
 
+  ISD::LoadExtType getExtensionType() const {
+    return ISD::LoadExtType(LoadSDNodeBits.ExtTy);
+  }
+
   static bool classof(const SDNode *N) {
     return N->getOpcode() == ISD::MGATHER;
   }
@@ -2404,8 +2490,17 @@
   friend class SelectionDAG;
 
   MaskedScatterSDNode(unsigned Order, const DebugLoc &dl, SDVTList VTs,
-                      EVT MemVT, MachineMemOperand *MMO)
-      : MaskedGatherScatterSDNode(ISD::MSCATTER, Order, dl, VTs, MemVT, MMO) {}
+                      EVT MemVT, MachineMemOperand *MMO,
+                      ISD::MemIndexType IndexType, bool IsTrunc)
+      : MaskedGatherScatterSDNode(ISD::MSCATTER, Order, dl, VTs, MemVT, MMO,
+                                  IndexType) {
+    StoreSDNodeBits.IsTruncating = IsTrunc;
+  }
+
+  /// Return true if the op does a truncation before store.
+  /// For integers this is the same as doing a TRUNCATE and storing the result.
+  /// For floats, it is the same as doing an FP_ROUND and storing the result.
+  bool isTruncatingStore() const { return StoreSDNodeBits.IsTruncating; }
 
   const SDValue &getValue() const { return getOperand(1); }
 
@@ -2478,6 +2573,22 @@
   }
 };
 
+/// An SDNode that records if a register contains a value that is guaranteed to
+/// be aligned accordingly.
+class AssertAlignSDNode : public SDNode {
+  Align Alignment;
+
+public:
+  AssertAlignSDNode(unsigned Order, const DebugLoc &DL, EVT VT, Align A)
+      : SDNode(ISD::AssertAlign, Order, DL, getSDVTList(VT)), Alignment(A) {}
+
+  Align getAlign() const { return Alignment; }
+
+  static bool classof(const SDNode *N) {
+    return N->getOpcode() == ISD::AssertAlign;
+  }
+};
+
 class SDNodeIterator : public std::iterator<std::forward_iterator_tag,
                                             SDNode, ptrdiff_t> {
   const SDNode *Node;
@@ -2539,7 +2650,8 @@
 /// with 4 and 8 byte pointer alignment, respectively.
 using LargestSDNode = AlignedCharArrayUnion<AtomicSDNode, TargetIndexSDNode,
                                             BlockAddressSDNode,
-                                            GlobalAddressSDNode>;
+                                            GlobalAddressSDNode,
+                                            PseudoProbeSDNode>;
 
 /// The SDNode class with the greatest alignment requirement.
 using MostAlignedSDNode = GlobalAddressSDNode;
@@ -2622,6 +2734,16 @@
       SDValue LHS, SDValue RHS,
       std::function<bool(ConstantSDNode *, ConstantSDNode *)> Match,
       bool AllowUndefs = false, bool AllowTypeMismatch = false);
+
+  /// Returns true if the specified value is the overflow result from one
+  /// of the overflow intrinsic nodes.
+  inline bool isOverflowIntrOpRes(SDValue Op) {
+    unsigned Opc = Op.getOpcode();
+    return (Op.getResNo() == 1 &&
+            (Opc == ISD::SADDO || Opc == ISD::UADDO || Opc == ISD::SSUBO ||
+             Opc == ISD::USUBO || Opc == ISD::SMULO || Opc == ISD::UMULO));
+  }
+
 } // end namespace ISD
 
 } // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/CodeGen/SelectionDAGTargetInfo.h b/linux-x64/clang/include/llvm/CodeGen/SelectionDAGTargetInfo.h
index 7c9f57b..78f6fc6 100644
--- a/linux-x64/clang/include/llvm/CodeGen/SelectionDAGTargetInfo.h
+++ b/linux-x64/clang/include/llvm/CodeGen/SelectionDAGTargetInfo.h
@@ -51,7 +51,7 @@
   virtual SDValue EmitTargetCodeForMemcpy(SelectionDAG &DAG, const SDLoc &dl,
                                           SDValue Chain, SDValue Op1,
                                           SDValue Op2, SDValue Op3,
-                                          unsigned Align, bool isVolatile,
+                                          Align Alignment, bool isVolatile,
                                           bool AlwaysInline,
                                           MachinePointerInfo DstPtrInfo,
                                           MachinePointerInfo SrcPtrInfo) const {
@@ -66,7 +66,7 @@
   /// lowering strategy should be used.
   virtual SDValue EmitTargetCodeForMemmove(
       SelectionDAG &DAG, const SDLoc &dl, SDValue Chain, SDValue Op1,
-      SDValue Op2, SDValue Op3, unsigned Align, bool isVolatile,
+      SDValue Op2, SDValue Op3, Align Alignment, bool isVolatile,
       MachinePointerInfo DstPtrInfo, MachinePointerInfo SrcPtrInfo) const {
     return SDValue();
   }
@@ -80,12 +80,12 @@
   virtual SDValue EmitTargetCodeForMemset(SelectionDAG &DAG, const SDLoc &dl,
                                           SDValue Chain, SDValue Op1,
                                           SDValue Op2, SDValue Op3,
-                                          unsigned Align, bool isVolatile,
+                                          Align Alignment, bool isVolatile,
                                           MachinePointerInfo DstPtrInfo) const {
     return SDValue();
   }
 
-  /// Emit target-specific code that performs a memcmp, in cases where that is
+  /// Emit target-specific code that performs a memcmp/bcmp, in cases where that is
   /// faster than a libcall. The first returned SDValue is the result of the
   /// memcmp and the second is the chain. Both SDValues can be null if a normal
   /// libcall should be used.
@@ -147,11 +147,24 @@
     return std::make_pair(SDValue(), SDValue());
   }
 
+  virtual SDValue EmitTargetCodeForSetTag(SelectionDAG &DAG, const SDLoc &dl,
+                                          SDValue Chain, SDValue Addr,
+                                          SDValue Size,
+                                          MachinePointerInfo DstPtrInfo,
+                                          bool ZeroData) const {
+    return SDValue();
+  }
+
   // Return true when the decision to generate FMA's (or FMS, FMLA etc) rather
   // than FMUL and ADD is delegated to the machine combiner.
   virtual bool generateFMAsInMachineCombiner(CodeGenOpt::Level OptLevel) const {
     return false;
   }
+
+  // Return true if the DAG Combiner should disable generic combines.
+  virtual bool disableGenericCombines(CodeGenOpt::Level OptLevel) const {
+    return false;
+  }
 };
 
 } // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/CodeGen/SlotIndexes.h b/linux-x64/clang/include/llvm/CodeGen/SlotIndexes.h
index 10ab4cc..b2133de 100644
--- a/linux-x64/clang/include/llvm/CodeGen/SlotIndexes.h
+++ b/linux-x64/clang/include/llvm/CodeGen/SlotIndexes.h
@@ -347,14 +347,9 @@
   public:
     static char ID;
 
-    SlotIndexes() : MachineFunctionPass(ID) {
-      initializeSlotIndexesPass(*PassRegistry::getPassRegistry());
-    }
+    SlotIndexes();
 
-    ~SlotIndexes() override {
-      // The indexList's nodes are all allocated in the BumpPtrAllocator.
-      indexList.clearAndLeakNodesUnsafely();
-    }
+    ~SlotIndexes() override;
 
     void getAnalysisUsage(AnalysisUsage &au) const override;
     void releaseMemory() override;
@@ -387,13 +382,15 @@
     }
 
     /// Returns the base index for the given instruction.
-    SlotIndex getInstructionIndex(const MachineInstr &MI) const {
+    SlotIndex getInstructionIndex(const MachineInstr &MI,
+                                  bool IgnoreBundle = false) const {
       // Instructions inside a bundle have the same number as the bundle itself.
       auto BundleStart = getBundleStart(MI.getIterator());
       auto BundleEnd = getBundleEnd(MI.getIterator());
       // Use the first non-debug instruction in the bundle to get SlotIndex.
       const MachineInstr &BundleNonDebug =
-          *skipDebugInstructionsForward(BundleStart, BundleEnd);
+          IgnoreBundle ? MI
+                       : *skipDebugInstructionsForward(BundleStart, BundleEnd);
       assert(!BundleNonDebug.isDebugInstr() &&
              "Could not use a debug instruction to query mi2iMap.");
       Mi2IndexMap::const_iterator itr = mi2iMap.find(&BundleNonDebug);
@@ -578,7 +575,11 @@
     /// Removes machine instruction (bundle) \p MI from the mapping.
     /// This should be called before MachineInstr::eraseFromParent() is used to
     /// remove a whole bundle or an unbundled instruction.
-    void removeMachineInstrFromMaps(MachineInstr &MI);
+    /// If \p AllowBundled is set then this can be used on a bundled
+    /// instruction; however, this exists to support handleMoveIntoBundle,
+    /// and in general removeSingleMachineInstrFromMaps should be used instead.
+    void removeMachineInstrFromMaps(MachineInstr &MI,
+                                    bool AllowBundled = false);
 
     /// Removes a single machine instruction \p MI from the mapping.
     /// This should be called before MachineInstr::eraseFromBundle() is used to
@@ -603,30 +604,27 @@
     }
 
     /// Add the given MachineBasicBlock into the maps.
+    /// If it contains any instructions then they must already be in the maps.
+    /// This is used after a block has been split by moving some suffix of its
+    /// instructions into a newly created block.
     void insertMBBInMaps(MachineBasicBlock *mbb) {
-      MachineFunction::iterator nextMBB =
-        std::next(MachineFunction::iterator(mbb));
+      assert(mbb != &mbb->getParent()->front() &&
+             "Can't insert a new block at the beginning of a function.");
+      auto prevMBB = std::prev(MachineFunction::iterator(mbb));
 
-      IndexListEntry *startEntry = nullptr;
-      IndexListEntry *endEntry = nullptr;
-      IndexList::iterator newItr;
-      if (nextMBB == mbb->getParent()->end()) {
-        startEntry = &indexList.back();
-        endEntry = createEntry(nullptr, 0);
-        newItr = indexList.insertAfter(startEntry->getIterator(), endEntry);
-      } else {
-        startEntry = createEntry(nullptr, 0);
-        endEntry = getMBBStartIdx(&*nextMBB).listEntry();
-        newItr = indexList.insert(endEntry->getIterator(), startEntry);
-      }
+      // Create a new entry to be used for the start of mbb and the end of
+      // prevMBB.
+      IndexListEntry *startEntry = createEntry(nullptr, 0);
+      IndexListEntry *endEntry = getMBBEndIdx(&*prevMBB).listEntry();
+      IndexListEntry *insEntry =
+          mbb->empty() ? endEntry
+                       : getInstructionIndex(mbb->front()).listEntry();
+      IndexList::iterator newItr =
+          indexList.insert(insEntry->getIterator(), startEntry);
 
       SlotIndex startIdx(startEntry, SlotIndex::Slot_Block);
       SlotIndex endIdx(endEntry, SlotIndex::Slot_Block);
 
-      MachineFunction::iterator prevMBB(mbb);
-      assert(prevMBB != mbb->getParent()->end() &&
-             "Can't insert a new block at the beginning of a function.");
-      --prevMBB;
       MBBRanges[prevMBB->getNumber()].second = startIdx;
 
       assert(unsigned(mbb->getNumber()) == MBBRanges.size() &&
diff --git a/linux-x64/clang/include/llvm/CodeGen/Spiller.h b/linux-x64/clang/include/llvm/CodeGen/Spiller.h
new file mode 100644
index 0000000..a693d64
--- /dev/null
+++ b/linux-x64/clang/include/llvm/CodeGen/Spiller.h
@@ -0,0 +1,42 @@
+//===- llvm/CodeGen/Spiller.h - Spiller -------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIB_CODEGEN_SPILLER_H
+#define LLVM_LIB_CODEGEN_SPILLER_H
+
+namespace llvm {
+
+class LiveRangeEdit;
+class MachineFunction;
+class MachineFunctionPass;
+class VirtRegMap;
+
+/// Spiller interface.
+///
+/// Implementations are utility classes which insert spill or remat code on
+/// demand.
+class Spiller {
+  virtual void anchor();
+
+public:
+  virtual ~Spiller() = 0;
+
+  /// spill - Spill the LRE.getParent() live interval.
+  virtual void spill(LiveRangeEdit &LRE) = 0;
+
+  virtual void postOptimization() {}
+};
+
+/// Create and return a spiller that will insert spill code directly instead
+/// of deferring though VirtRegMap.
+Spiller *createInlineSpiller(MachineFunctionPass &pass, MachineFunction &mf,
+                             VirtRegMap &vrm);
+
+} // end namespace llvm
+
+#endif // LLVM_LIB_CODEGEN_SPILLER_H
diff --git a/linux-x64/clang/include/llvm/CodeGen/StableHashing.h b/linux-x64/clang/include/llvm/CodeGen/StableHashing.h
new file mode 100644
index 0000000..caf27e1
--- /dev/null
+++ b/linux-x64/clang/include/llvm/CodeGen/StableHashing.h
@@ -0,0 +1,112 @@
+//===- llvm/CodeGen/StableHashing.h - Utilities for stable hashing * C++ *-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file provides types and functions for computing and combining stable
+// hashes. Stable hashes can be useful for hashing across different modules,
+// processes, or compiler runs.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CODEGEN_STABLEHASHING_H
+#define LLVM_CODEGEN_STABLEHASHING_H
+
+#include "llvm/ADT/StringRef.h"
+
+namespace llvm {
+
+/// An opaque object representing a stable hash code. It can be serialized,
+/// deserialized, and is stable across processes and executions.
+using stable_hash = uint64_t;
+
+// Implementation details
+namespace hashing {
+namespace detail {
+
+// Stable hashes are based on the 64-bit FNV-1 hash:
+// https://en.wikipedia.org/wiki/Fowler-Noll-Vo_hash_function
+
+const uint64_t FNV_PRIME_64 = 1099511628211u;
+const uint64_t FNV_OFFSET_64 = 14695981039346656037u;
+
+inline void stable_hash_append(stable_hash &Hash, const char Value) {
+  Hash = Hash ^ (Value & 0xFF);
+  Hash = Hash * FNV_PRIME_64;
+}
+
+inline void stable_hash_append(stable_hash &Hash, stable_hash Value) {
+  for (unsigned I = 0; I < 8; ++I) {
+    stable_hash_append(Hash, static_cast<char>(Value));
+    Value >>= 8;
+  }
+}
+
+} // namespace detail
+} // namespace hashing
+
+inline stable_hash stable_hash_combine(stable_hash A, stable_hash B) {
+  stable_hash Hash = hashing::detail::FNV_OFFSET_64;
+  hashing::detail::stable_hash_append(Hash, A);
+  hashing::detail::stable_hash_append(Hash, B);
+  return Hash;
+}
+
+inline stable_hash stable_hash_combine(stable_hash A, stable_hash B,
+                                       stable_hash C) {
+  stable_hash Hash = hashing::detail::FNV_OFFSET_64;
+  hashing::detail::stable_hash_append(Hash, A);
+  hashing::detail::stable_hash_append(Hash, B);
+  hashing::detail::stable_hash_append(Hash, C);
+  return Hash;
+}
+
+inline stable_hash stable_hash_combine(stable_hash A, stable_hash B,
+                                       stable_hash C, stable_hash D) {
+  stable_hash Hash = hashing::detail::FNV_OFFSET_64;
+  hashing::detail::stable_hash_append(Hash, A);
+  hashing::detail::stable_hash_append(Hash, B);
+  hashing::detail::stable_hash_append(Hash, C);
+  hashing::detail::stable_hash_append(Hash, D);
+  return Hash;
+}
+
+/// Compute a stable_hash for a sequence of values.
+///
+/// This hashes a sequence of values. It produces the same stable_hash as
+/// 'stable_hash_combine(a, b, c, ...)', but can run over arbitrary sized
+/// sequences and is significantly faster given pointers and types which
+/// can be hashed as a sequence of bytes.
+template <typename InputIteratorT>
+stable_hash stable_hash_combine_range(InputIteratorT First,
+                                      InputIteratorT Last) {
+  stable_hash Hash = hashing::detail::FNV_OFFSET_64;
+  for (auto I = First; I != Last; ++I)
+    hashing::detail::stable_hash_append(Hash, *I);
+  return Hash;
+}
+
+inline stable_hash stable_hash_combine_array(const stable_hash *P, size_t C) {
+  stable_hash Hash = hashing::detail::FNV_OFFSET_64;
+  for (size_t I = 0; I < C; ++I)
+    hashing::detail::stable_hash_append(Hash, P[I]);
+  return Hash;
+}
+
+inline stable_hash stable_hash_combine_string(const StringRef &S) {
+  return stable_hash_combine_range(S.begin(), S.end());
+}
+
+inline stable_hash stable_hash_combine_string(const char *C) {
+  stable_hash Hash = hashing::detail::FNV_OFFSET_64;
+  while (*C)
+    hashing::detail::stable_hash_append(Hash, *(C++));
+  return Hash;
+}
+
+} // namespace llvm
+
+#endif
diff --git a/linux-x64/clang/include/llvm/CodeGen/StackMaps.h b/linux-x64/clang/include/llvm/CodeGen/StackMaps.h
index d7d88de..928d7cc 100644
--- a/linux-x64/clang/include/llvm/CodeGen/StackMaps.h
+++ b/linux-x64/clang/include/llvm/CodeGen/StackMaps.h
@@ -148,46 +148,104 @@
 ///   <StackMaps::ConstantOp>, <calling convention>,
 ///   <StackMaps::ConstantOp>, <statepoint flags>,
 ///   <StackMaps::ConstantOp>, <num deopt args>, [deopt args...],
-///   <gc base/derived pairs...> <gc allocas...>
-/// Note that the last two sets of arguments are not currently length
-///   prefixed.
+///   <StackMaps::ConstantOp>, <num gc pointer args>, [gc pointer args...],
+///   <StackMaps::ConstantOp>, <num gc allocas>, [gc allocas args...],
+///   <StackMaps::ConstantOp>, <num  entries in gc map>, [base/derived pairs]
+///   base/derived pairs in gc map are logical indices into <gc pointer args>
+///   section.
+///   All gc pointers assigned to VRegs produce new value (in form of MI Def
+///   operand) and are tied to it.
 class StatepointOpers {
   // TODO:: we should change the STATEPOINT representation so that CC and
   // Flags should be part of meta operands, with args and deopt operands, and
   // gc operands all prefixed by their length and a type code. This would be
   // much more consistent.
-public:
-  // These values are aboolute offsets into the operands of the statepoint
+
+  // These values are absolute offsets into the operands of the statepoint
   // instruction.
   enum { IDPos, NBytesPos, NCallArgsPos, CallTargetPos, MetaEnd };
 
-  // These values are relative offests from the start of the statepoint meta
+  // These values are relative offsets from the start of the statepoint meta
   // arguments (i.e. the end of the call arguments).
   enum { CCOffset = 1, FlagsOffset = 3, NumDeoptOperandsOffset = 5 };
 
-  explicit StatepointOpers(const MachineInstr *MI) : MI(MI) {}
+public:
+  explicit StatepointOpers(const MachineInstr *MI) : MI(MI) {
+    NumDefs = MI->getNumDefs();
+  }
+
+  /// Get index of statepoint ID operand.
+  unsigned getIDPos() const { return NumDefs + IDPos; }
+
+  /// Get index of Num Patch Bytes operand.
+  unsigned getNBytesPos() const { return NumDefs + NBytesPos; }
+
+  /// Get index of Num Call Arguments operand.
+  unsigned getNCallArgsPos() const { return NumDefs + NCallArgsPos; }
 
   /// Get starting index of non call related arguments
   /// (calling convention, statepoint flags, vm state and gc state).
   unsigned getVarIdx() const {
-    return MI->getOperand(NCallArgsPos).getImm() + MetaEnd;
+    return MI->getOperand(NumDefs + NCallArgsPos).getImm() + MetaEnd + NumDefs;
+  }
+
+  /// Get index of Calling Convention operand.
+  unsigned getCCIdx() const { return getVarIdx() + CCOffset; }
+
+  /// Get index of Flags operand.
+  unsigned getFlagsIdx() const { return getVarIdx() + FlagsOffset; }
+
+  /// Get index of Number Deopt Arguments operand.
+  unsigned getNumDeoptArgsIdx() const {
+    return getVarIdx() + NumDeoptOperandsOffset;
   }
 
   /// Return the ID for the given statepoint.
-  uint64_t getID() const { return MI->getOperand(IDPos).getImm(); }
+  uint64_t getID() const { return MI->getOperand(NumDefs + IDPos).getImm(); }
 
   /// Return the number of patchable bytes the given statepoint should emit.
   uint32_t getNumPatchBytes() const {
-    return MI->getOperand(NBytesPos).getImm();
+    return MI->getOperand(NumDefs + NBytesPos).getImm();
   }
 
-  /// Returns the target of the underlying call.
+  /// Return the target of the underlying call.
   const MachineOperand &getCallTarget() const {
-    return MI->getOperand(CallTargetPos);
+    return MI->getOperand(NumDefs + CallTargetPos);
   }
 
+  /// Return the calling convention.
+  CallingConv::ID getCallingConv() const {
+    return MI->getOperand(getCCIdx()).getImm();
+  }
+
+  /// Return the statepoint flags.
+  uint64_t getFlags() const { return MI->getOperand(getFlagsIdx()).getImm(); }
+
+  uint64_t getNumDeoptArgs() const {
+    return MI->getOperand(getNumDeoptArgsIdx()).getImm();
+  }
+
+  /// Get index of number of gc map entries.
+  unsigned getNumGcMapEntriesIdx();
+
+  /// Get index of number of gc allocas.
+  unsigned getNumAllocaIdx();
+
+  /// Get index of number of GC pointers.
+  unsigned getNumGCPtrIdx();
+
+  /// Get index of first GC pointer operand of -1 if there are none.
+  int getFirstGCPtrIdx();
+
+  /// Get vector of base/derived pairs from statepoint.
+  /// Elements are indices into GC Pointer operand list (logical).
+  /// Returns number of elements in GCMap.
+  unsigned
+  getGCPointerMap(SmallVectorImpl<std::pair<unsigned, unsigned>> &GCMap);
+
 private:
   const MachineInstr *MI;
+  unsigned NumDefs;
 };
 
 class StackMaps {
@@ -229,6 +287,10 @@
 
   StackMaps(AsmPrinter &AP);
 
+  /// Get index of next meta operand.
+  /// Similar to parseOperand, but does not actually parses operand meaning.
+  static unsigned getNextMetaArgIdx(const MachineInstr *MI, unsigned CurIdx);
+
   void reset() {
     CSInfos.clear();
     ConstPool.clear();
@@ -266,13 +328,16 @@
   /// Generate a stackmap record for a stackmap instruction.
   ///
   /// MI must be a raw STACKMAP, not a PATCHPOINT.
-  void recordStackMap(const MachineInstr &MI);
+  void recordStackMap(const MCSymbol &L,
+                      const MachineInstr &MI);
 
   /// Generate a stackmap record for a patchpoint instruction.
-  void recordPatchPoint(const MachineInstr &MI);
+  void recordPatchPoint(const MCSymbol &L,
+                        const MachineInstr &MI);
 
   /// Generate a stackmap record for a statepoint instruction.
-  void recordStatepoint(const MachineInstr &MI);
+  void recordStatepoint(const MCSymbol &L,
+                        const MachineInstr &MI);
 
   /// If there is any stack map data, create a stack map section and serialize
   /// the map info into it. This clears the stack map data structures
@@ -298,6 +363,13 @@
                MachineInstr::const_mop_iterator MOE, LocationVec &Locs,
                LiveOutVec &LiveOuts) const;
 
+  /// Specialized parser of statepoint operands.
+  /// They do not directly correspond to StackMap record entries.
+  void parseStatepointOpers(const MachineInstr &MI,
+                            MachineInstr::const_mop_iterator MOI,
+                            MachineInstr::const_mop_iterator MOE,
+                            LocationVec &Locations, LiveOutVec &LiveOuts);
+
   /// Create a live-out register record for the given register @p Reg.
   LiveOutReg createLiveOutReg(unsigned Reg,
                               const TargetRegisterInfo *TRI) const;
@@ -306,12 +378,15 @@
   /// registers that need to be recorded in the stackmap.
   LiveOutVec parseRegisterLiveOutMask(const uint32_t *Mask) const;
 
-  /// This should be called by the MC lowering code _immediately_ before
-  /// lowering the MI to an MCInst. It records where the operands for the
-  /// instruction are stored, and outputs a label to record the offset of
-  /// the call from the start of the text section. In special cases (e.g. AnyReg
-  /// calling convention) the return register is also recorded if requested.
-  void recordStackMapOpers(const MachineInstr &MI, uint64_t ID,
+  /// Record the locations of the operands of the provided instruction in a
+  /// record keyed by the provided label.  For instructions w/AnyReg calling
+  /// convention the return register is also recorded if requested.  For
+  /// STACKMAP, and PATCHPOINT the label is expected to immediately *preceed*
+  /// lowering of the MI to MCInsts.  For STATEPOINT, it expected to
+  /// immediately *follow*.  It's not clear this difference was intentional,
+  /// but it exists today.  
+  void recordStackMapOpers(const MCSymbol &L,
+                           const MachineInstr &MI, uint64_t ID,
                            MachineInstr::const_mop_iterator MOI,
                            MachineInstr::const_mop_iterator MOE,
                            bool recordResult = false);
diff --git a/linux-x64/clang/include/llvm/CodeGen/StackProtector.h b/linux-x64/clang/include/llvm/CodeGen/StackProtector.h
index 2bdf442..f6513e8 100644
--- a/linux-x64/clang/include/llvm/CodeGen/StackProtector.h
+++ b/linux-x64/clang/include/llvm/CodeGen/StackProtector.h
@@ -61,6 +61,12 @@
   /// protection when -fstack-protection is used.
   unsigned SSPBufferSize = 0;
 
+  /// VisitedPHIs - The set of PHI nodes visited when determining
+  /// if a variable's reference has been taken.  This set
+  /// is maintained to ensure we don't visit the same PHI node multiple
+  /// times.
+  SmallPtrSet<const PHINode *, 16> VisitedPHIs;
+
   // A prologue is generated.
   bool HasPrologue = false;
 
@@ -89,7 +95,7 @@
                                 bool InStruct = false) const;
 
   /// Check whether a stack allocation has its address taken.
-  bool HasAddressTaken(const Instruction *AI);
+  bool HasAddressTaken(const Instruction *AI, uint64_t AllocSize);
 
   /// RequiresStackProtector - Check whether or not this function needs a
   /// stack protector based upon the stack protector level.
@@ -98,9 +104,7 @@
 public:
   static char ID; // Pass identification, replacement for typeid.
 
-  StackProtector() : FunctionPass(ID), SSPBufferSize(8) {
-    initializeStackProtectorPass(*PassRegistry::getPassRegistry());
-  }
+  StackProtector();
 
   void getAnalysisUsage(AnalysisUsage &AU) const override;
 
diff --git a/linux-x64/clang/include/llvm/CodeGen/SwitchLoweringUtils.h b/linux-x64/clang/include/llvm/CodeGen/SwitchLoweringUtils.h
index 62134dc..51f1d7d 100644
--- a/linux-x64/clang/include/llvm/CodeGen/SwitchLoweringUtils.h
+++ b/linux-x64/clang/include/llvm/CodeGen/SwitchLoweringUtils.h
@@ -10,15 +10,21 @@
 #define LLVM_CODEGEN_SWITCHLOWERINGUTILS_H
 
 #include "llvm/ADT/SmallVector.h"
+#include "llvm/CodeGen/ISDOpcodes.h"
 #include "llvm/CodeGen/SelectionDAGNodes.h"
-#include "llvm/CodeGen/TargetLowering.h"
-#include "llvm/IR/Constants.h"
+#include "llvm/IR/InstrTypes.h"
 #include "llvm/Support/BranchProbability.h"
+#include <vector>
 
 namespace llvm {
 
+class BlockFrequencyInfo;
+class ConstantInt;
 class FunctionLoweringInfo;
 class MachineBasicBlock;
+class ProfileSummaryInfo;
+class TargetLowering;
+class TargetMachine;
 
 namespace SwitchCG {
 
@@ -212,16 +218,17 @@
   BitTestInfo Cases;
   BranchProbability Prob;
   BranchProbability DefaultProb;
+  bool OmitRangeCheck;
 
   BitTestBlock(APInt F, APInt R, const Value *SV, unsigned Rg, MVT RgVT, bool E,
                bool CR, MachineBasicBlock *P, MachineBasicBlock *D,
                BitTestInfo C, BranchProbability Pr)
       : First(std::move(F)), Range(std::move(R)), SValue(SV), Reg(Rg),
         RegVT(RgVT), Emitted(E), ContiguousRange(CR), Parent(P), Default(D),
-        Cases(std::move(C)), Prob(Pr) {}
+        Cases(std::move(C)), Prob(Pr), OmitRangeCheck(false) {}
 };
 
-/// Return the range of value within a range.
+/// Return the range of values within a range.
 uint64_t getJumpTableRange(const CaseClusterVector &Clusters, unsigned First,
                            unsigned Last);
 
@@ -263,7 +270,8 @@
   std::vector<BitTestBlock> BitTestCases;
 
   void findJumpTables(CaseClusterVector &Clusters, const SwitchInst *SI,
-                      MachineBasicBlock *DefaultMBB);
+                      MachineBasicBlock *DefaultMBB,
+                      ProfileSummaryInfo *PSI, BlockFrequencyInfo *BFI);
 
   bool buildJumpTable(const CaseClusterVector &Clusters, unsigned First,
                       unsigned Last, const SwitchInst *SI,
@@ -294,4 +302,3 @@
 } // namespace llvm
 
 #endif // LLVM_CODEGEN_SWITCHLOWERINGUTILS_H
-
diff --git a/linux-x64/clang/include/llvm/CodeGen/TailDuplicator.h b/linux-x64/clang/include/llvm/CodeGen/TailDuplicator.h
index 358798d..6862bb2 100644
--- a/linux-x64/clang/include/llvm/CodeGen/TailDuplicator.h
+++ b/linux-x64/clang/include/llvm/CodeGen/TailDuplicator.h
@@ -18,6 +18,7 @@
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallVector.h"
+#include "llvm/CodeGen/MBFIWrapper.h"
 #include "llvm/CodeGen/TargetInstrInfo.h"
 #include <utility>
 #include <vector>
@@ -25,11 +26,13 @@
 namespace llvm {
 
 class MachineBasicBlock;
+class MachineBlockFrequencyInfo;
 class MachineBranchProbabilityInfo;
 class MachineFunction;
 class MachineInstr;
 class MachineModuleInfo;
 class MachineRegisterInfo;
+class ProfileSummaryInfo;
 class TargetRegisterInfo;
 
 /// Utility class to perform tail duplication.
@@ -40,18 +43,20 @@
   const MachineModuleInfo *MMI;
   MachineRegisterInfo *MRI;
   MachineFunction *MF;
+  MBFIWrapper *MBFI;
+  ProfileSummaryInfo *PSI;
   bool PreRegAlloc;
   bool LayoutMode;
   unsigned TailDupSize;
 
   // A list of virtual registers for which to update SSA form.
-  SmallVector<unsigned, 16> SSAUpdateVRs;
+  SmallVector<Register, 16> SSAUpdateVRs;
 
   // For each virtual register in SSAUpdateVals keep a list of source virtual
   // registers.
-  using AvailableValsTy = std::vector<std::pair<MachineBasicBlock *, unsigned>>;
+  using AvailableValsTy = std::vector<std::pair<MachineBasicBlock *, Register>>;
 
-  DenseMap<unsigned, AvailableValsTy> SSAUpdateVals;
+  DenseMap<Register, AvailableValsTy> SSAUpdateVals;
 
 public:
   /// Prepare to run on a specific machine function.
@@ -65,6 +70,8 @@
   ///     default implies using the command line value TailDupSize.
   void initMF(MachineFunction &MF, bool PreRegAlloc,
               const MachineBranchProbabilityInfo *MBPI,
+              MBFIWrapper *MBFI,
+              ProfileSummaryInfo *PSI,
               bool LayoutMode, unsigned TailDupSize = 0);
 
   bool tailDuplicateBlocks();
@@ -80,41 +87,44 @@
   /// of predecessors that received a copy of \p MBB.
   /// If \p RemovalCallback is non-null. It will be called before MBB is
   /// deleted.
+  /// If \p CandidatePtr is not null, duplicate into these blocks only.
   bool tailDuplicateAndUpdate(
       bool IsSimple, MachineBasicBlock *MBB,
       MachineBasicBlock *ForcedLayoutPred,
       SmallVectorImpl<MachineBasicBlock*> *DuplicatedPreds = nullptr,
-      function_ref<void(MachineBasicBlock *)> *RemovalCallback = nullptr);
+      function_ref<void(MachineBasicBlock *)> *RemovalCallback = nullptr,
+      SmallVectorImpl<MachineBasicBlock *> *CandidatePtr = nullptr);
 
 private:
   using RegSubRegPair = TargetInstrInfo::RegSubRegPair;
 
-  void addSSAUpdateEntry(unsigned OrigReg, unsigned NewReg,
+  void addSSAUpdateEntry(Register OrigReg, Register NewReg,
                          MachineBasicBlock *BB);
   void processPHI(MachineInstr *MI, MachineBasicBlock *TailBB,
                   MachineBasicBlock *PredBB,
-                  DenseMap<unsigned, RegSubRegPair> &LocalVRMap,
-                  SmallVectorImpl<std::pair<unsigned, RegSubRegPair>> &Copies,
-                  const DenseSet<unsigned> &UsedByPhi, bool Remove);
+                  DenseMap<Register, RegSubRegPair> &LocalVRMap,
+                  SmallVectorImpl<std::pair<Register, RegSubRegPair>> &Copies,
+                  const DenseSet<Register> &UsedByPhi, bool Remove);
   void duplicateInstruction(MachineInstr *MI, MachineBasicBlock *TailBB,
                             MachineBasicBlock *PredBB,
-                            DenseMap<unsigned, RegSubRegPair> &LocalVRMap,
-                            const DenseSet<unsigned> &UsedByPhi);
+                            DenseMap<Register, RegSubRegPair> &LocalVRMap,
+                            const DenseSet<Register> &UsedByPhi);
   void updateSuccessorsPHIs(MachineBasicBlock *FromBB, bool isDead,
                             SmallVectorImpl<MachineBasicBlock *> &TDBBs,
                             SmallSetVector<MachineBasicBlock *, 8> &Succs);
   bool canCompletelyDuplicateBB(MachineBasicBlock &BB);
   bool duplicateSimpleBB(MachineBasicBlock *TailBB,
                          SmallVectorImpl<MachineBasicBlock *> &TDBBs,
-                         const DenseSet<unsigned> &RegsUsedByPhi,
+                         const DenseSet<Register> &RegsUsedByPhi,
                          SmallVectorImpl<MachineInstr *> &Copies);
   bool tailDuplicate(bool IsSimple,
                      MachineBasicBlock *TailBB,
                      MachineBasicBlock *ForcedLayoutPred,
                      SmallVectorImpl<MachineBasicBlock *> &TDBBs,
-                     SmallVectorImpl<MachineInstr *> &Copies);
+                     SmallVectorImpl<MachineInstr *> &Copies,
+                     SmallVectorImpl<MachineBasicBlock *> *CandidatePtr);
   void appendCopies(MachineBasicBlock *MBB,
-                 SmallVectorImpl<std::pair<unsigned,RegSubRegPair>> &CopyInfos,
+                 SmallVectorImpl<std::pair<Register, RegSubRegPair>> &CopyInfos,
                  SmallVectorImpl<MachineInstr *> &Copies);
 
   void removeDeadBlock(
diff --git a/linux-x64/clang/include/llvm/CodeGen/TargetCallingConv.h b/linux-x64/clang/include/llvm/CodeGen/TargetCallingConv.h
index aebeeec..df974b4 100644
--- a/linux-x64/clang/include/llvm/CodeGen/TargetCallingConv.h
+++ b/linux-x64/clang/include/llvm/CodeGen/TargetCallingConv.h
@@ -14,6 +14,7 @@
 #define LLVM_CODEGEN_TARGETCALLINGCONV_H
 
 #include "llvm/CodeGen/ValueTypes.h"
+#include "llvm/Support/Alignment.h"
 #include "llvm/Support/MachineValueType.h"
 #include "llvm/Support/MathExtras.h"
 #include <cassert>
@@ -30,35 +31,44 @@
     unsigned IsInReg : 1;    ///< Passed in register
     unsigned IsSRet : 1;     ///< Hidden struct-ret ptr
     unsigned IsByVal : 1;    ///< Struct passed by value
+    unsigned IsByRef : 1;    ///< Passed in memory
     unsigned IsNest : 1;     ///< Nested fn static chain
     unsigned IsReturned : 1; ///< Always returned
     unsigned IsSplit : 1;
     unsigned IsInAlloca : 1;   ///< Passed with inalloca
+    unsigned IsPreallocated : 1; ///< ByVal without the copy
     unsigned IsSplitEnd : 1;   ///< Last part of a split
     unsigned IsSwiftSelf : 1;  ///< Swift self parameter
     unsigned IsSwiftError : 1; ///< Swift error parameter
+    unsigned IsCFGuardTarget : 1; ///< Control Flow Guard target
     unsigned IsHva : 1;        ///< HVA field for
     unsigned IsHvaStart : 1;   ///< HVA structure start
     unsigned IsSecArgPass : 1; ///< Second argument
-    unsigned ByValAlign : 4;   ///< Log 2 of byval alignment
+    unsigned ByValOrByRefAlign : 4; ///< Log 2 of byval/byref alignment
     unsigned OrigAlign : 5;    ///< Log 2 of original alignment
     unsigned IsInConsecutiveRegsLast : 1;
     unsigned IsInConsecutiveRegs : 1;
     unsigned IsCopyElisionCandidate : 1; ///< Argument copy elision candidate
     unsigned IsPointer : 1;
 
-    unsigned ByValSize; ///< Byval struct size
+    unsigned ByValOrByRefSize; ///< Byval or byref struct size
 
     unsigned PointerAddrSpace; ///< Address space of pointer argument
 
+    /// Set the alignment used by byref or byval parameters.
+    void setAlignImpl(Align A) {
+      ByValOrByRefAlign = encode(A);
+      assert(getNonZeroByValAlign() == A && "bitfield overflow");
+    }
+
   public:
     ArgFlagsTy()
-        : IsZExt(0), IsSExt(0), IsInReg(0), IsSRet(0), IsByVal(0), IsNest(0),
-          IsReturned(0), IsSplit(0), IsInAlloca(0), IsSplitEnd(0),
-          IsSwiftSelf(0), IsSwiftError(0), IsHva(0), IsHvaStart(0),
-          IsSecArgPass(0), ByValAlign(0), OrigAlign(0),
-          IsInConsecutiveRegsLast(0), IsInConsecutiveRegs(0),
-          IsCopyElisionCandidate(0), IsPointer(0), ByValSize(0),
+      : IsZExt(0), IsSExt(0), IsInReg(0), IsSRet(0), IsByVal(0), IsByRef(0),
+          IsNest(0), IsReturned(0), IsSplit(0), IsInAlloca(0), IsPreallocated(0),
+          IsSplitEnd(0), IsSwiftSelf(0), IsSwiftError(0), IsCFGuardTarget(0),
+          IsHva(0), IsHvaStart(0), IsSecArgPass(0), ByValOrByRefAlign(0),
+          OrigAlign(0), IsInConsecutiveRegsLast(0), IsInConsecutiveRegs(0),
+          IsCopyElisionCandidate(0), IsPointer(0), ByValOrByRefSize(0),
           PointerAddrSpace(0) {
       static_assert(sizeof(*this) == 3 * sizeof(unsigned), "flags are too big");
     }
@@ -78,15 +88,24 @@
     bool isByVal() const { return IsByVal; }
     void setByVal() { IsByVal = 1; }
 
+    bool isByRef() const { return IsByRef; }
+    void setByRef() { IsByRef = 1; }
+
     bool isInAlloca() const { return IsInAlloca; }
     void setInAlloca() { IsInAlloca = 1; }
 
+    bool isPreallocated() const { return IsPreallocated; }
+    void setPreallocated() { IsPreallocated = 1; }
+
     bool isSwiftSelf() const { return IsSwiftSelf; }
     void setSwiftSelf() { IsSwiftSelf = 1; }
 
     bool isSwiftError() const { return IsSwiftError; }
     void setSwiftError() { IsSwiftError = 1; }
 
+    bool isCFGuardTarget() const { return IsCFGuardTarget; }
+    void setCFGuardTarget() { IsCFGuardTarget = 1; }
+
     bool isHva() const { return IsHva; }
     void setHva() { IsHva = 1; }
 
@@ -103,10 +122,12 @@
     void setReturned() { IsReturned = 1; }
 
     bool isInConsecutiveRegs()  const { return IsInConsecutiveRegs; }
-    void setInConsecutiveRegs() { IsInConsecutiveRegs = 1; }
+    void setInConsecutiveRegs(bool Flag = true) { IsInConsecutiveRegs = Flag; }
 
     bool isInConsecutiveRegsLast() const { return IsInConsecutiveRegsLast; }
-    void setInConsecutiveRegsLast() { IsInConsecutiveRegsLast = 1; }
+    void setInConsecutiveRegsLast(bool Flag = true) {
+      IsInConsecutiveRegsLast = Flag;
+    }
 
     bool isSplit()   const { return IsSplit; }
     void setSplit()  { IsSplit = 1; }
@@ -120,20 +141,56 @@
     bool isPointer()  const { return IsPointer; }
     void setPointer() { IsPointer = 1; }
 
-    unsigned getByValAlign() const { return (1U << ByValAlign) / 2; }
-    void setByValAlign(unsigned A) {
-      ByValAlign = Log2_32(A) + 1;
-      assert(getByValAlign() == A && "bitfield overflow");
+    LLVM_ATTRIBUTE_DEPRECATED(unsigned getByValAlign() const,
+                              "Use getNonZeroByValAlign() instead") {
+      MaybeAlign A = decodeMaybeAlign(ByValOrByRefAlign);
+      return A ? A->value() : 0;
+    }
+    Align getNonZeroByValAlign() const {
+      MaybeAlign A = decodeMaybeAlign(ByValOrByRefAlign);
+      assert(A && "ByValAlign must be defined");
+      return *A;
+    }
+    void setByValAlign(Align A) {
+      assert(isByVal() && !isByRef());
+      setAlignImpl(A);
     }
 
-    unsigned getOrigAlign() const { return (1U << OrigAlign) / 2; }
-    void setOrigAlign(unsigned A) {
-      OrigAlign = Log2_32(A) + 1;
-      assert(getOrigAlign() == A && "bitfield overflow");
+    void setByRefAlign(Align A) {
+      assert(!isByVal() && isByRef());
+      setAlignImpl(A);
     }
 
-    unsigned getByValSize() const { return ByValSize; }
-    void setByValSize(unsigned S) { ByValSize = S; }
+    LLVM_ATTRIBUTE_DEPRECATED(unsigned getOrigAlign() const,
+                              "Use getNonZeroOrigAlign() instead") {
+      MaybeAlign A = decodeMaybeAlign(OrigAlign);
+      return A ? A->value() : 0;
+    }
+    Align getNonZeroOrigAlign() const {
+      return decodeMaybeAlign(OrigAlign).valueOrOne();
+    }
+    void setOrigAlign(Align A) {
+      OrigAlign = encode(A);
+      assert(getNonZeroOrigAlign() == A && "bitfield overflow");
+    }
+
+    unsigned getByValSize() const {
+      assert(isByVal() && !isByRef());
+      return ByValOrByRefSize;
+    }
+    void setByValSize(unsigned S) {
+      assert(isByVal() && !isByRef());
+      ByValOrByRefSize = S;
+    }
+
+    unsigned getByRefSize() const {
+      assert(!isByVal() && isByRef());
+      return ByValOrByRefSize;
+    }
+    void setByRefSize(unsigned S) {
+      assert(!isByVal() && isByRef());
+      ByValOrByRefSize = S;
+    }
 
     unsigned getPointerAddrSpace() const { return PointerAddrSpace; }
     void setPointerAddrSpace(unsigned AS) { PointerAddrSpace = AS; }
diff --git a/linux-x64/clang/include/llvm/CodeGen/TargetFrameLowering.h b/linux-x64/clang/include/llvm/CodeGen/TargetFrameLowering.h
index 878c9ff..792452f 100644
--- a/linux-x64/clang/include/llvm/CodeGen/TargetFrameLowering.h
+++ b/linux-x64/clang/include/llvm/CodeGen/TargetFrameLowering.h
@@ -14,8 +14,7 @@
 #define LLVM_CODEGEN_TARGETFRAMELOWERING_H
 
 #include "llvm/CodeGen/MachineBasicBlock.h"
-#include "llvm/ADT/StringSwitch.h"
-#include <utility>
+#include "llvm/Support/TypeSize.h"
 #include <vector>
 
 namespace llvm {
@@ -28,6 +27,7 @@
   enum Value {
     Default = 0,
     SGPRSpill = 1,
+    ScalableVector = 2,
     NoAlloc = 255
   };
 }
@@ -51,17 +51,32 @@
     unsigned Reg;
     int Offset; // Offset relative to stack pointer on function entry.
   };
+
+  struct DwarfFrameBase {
+    // The frame base may be either a register (the default), the CFA,
+    // or a WebAssembly-specific location description.
+    enum FrameBaseKind { Register, CFA, WasmFrameBase } Kind;
+    struct WasmFrameBase {
+      unsigned Kind; // Wasm local, global, or value stack
+      unsigned Index;
+    };
+    union {
+      unsigned Reg;
+      struct WasmFrameBase WasmLoc;
+    } Location;
+  };
+
 private:
   StackDirection StackDir;
-  unsigned StackAlignment;
-  unsigned TransientStackAlignment;
+  Align StackAlignment;
+  Align TransientStackAlignment;
   int LocalAreaOffset;
   bool StackRealignable;
 public:
-  TargetFrameLowering(StackDirection D, unsigned StackAl, int LAO,
-                      unsigned TransAl = 1, bool StackReal = true)
-    : StackDir(D), StackAlignment(StackAl), TransientStackAlignment(TransAl),
-      LocalAreaOffset(LAO), StackRealignable(StackReal) {}
+  TargetFrameLowering(StackDirection D, Align StackAl, int LAO,
+                      Align TransAl = Align(1), bool StackReal = true)
+      : StackDir(D), StackAlignment(StackAl), TransientStackAlignment(TransAl),
+        LocalAreaOffset(LAO), StackRealignable(StackReal) {}
 
   virtual ~TargetFrameLowering();
 
@@ -76,7 +91,12 @@
   /// stack pointer must be aligned on entry to a function.  Typically, this
   /// is the largest alignment for any data object in the target.
   ///
-  unsigned getStackAlignment() const { return StackAlignment; }
+  unsigned getStackAlignment() const { return StackAlignment.value(); }
+  /// getStackAlignment - This method returns the number of bytes to which the
+  /// stack pointer must be aligned on entry to a function.  Typically, this
+  /// is the largest alignment for any data object in the target.
+  ///
+  Align getStackAlign() const { return StackAlignment; }
 
   /// alignSPAdjust - This method aligns the stack adjustment to the correct
   /// alignment.
@@ -94,9 +114,15 @@
   /// which the stack pointer must be aligned at all times, even between
   /// calls.
   ///
-  unsigned getTransientStackAlignment() const {
-    return TransientStackAlignment;
+  LLVM_ATTRIBUTE_DEPRECATED(unsigned getTransientStackAlignment() const,
+                            "Use getTransientStackAlign instead") {
+    return TransientStackAlignment.value();
   }
+  /// getTransientStackAlignment - This method returns the number of bytes to
+  /// which the stack pointer must be aligned at all times, even between
+  /// calls.
+  ///
+  Align getTransientStackAlign() const { return TransientStackAlignment; }
 
   /// isStackRealignable - This method returns whether the stack can be
   /// realigned.
@@ -109,6 +135,12 @@
   /// was called).
   virtual unsigned getStackAlignmentSkew(const MachineFunction &MF) const;
 
+  /// This method returns whether or not it is safe for an object with the
+  /// given stack id to be bundled into the local area.
+  virtual bool isStackIdSafeForLocalArea(unsigned StackId) const {
+    return true;
+  }
+
   /// getOffsetOfLocalArea - This method returns the offset of the local area
   /// from the stack pointer on entrance to a function.
   ///
@@ -177,6 +209,17 @@
   virtual void emitEpilogue(MachineFunction &MF,
                             MachineBasicBlock &MBB) const = 0;
 
+  /// With basic block sections, emit callee saved frame moves for basic blocks
+  /// that are in a different section.
+  virtual void
+  emitCalleeSavedFrameMoves(MachineBasicBlock &MBB,
+                            MachineBasicBlock::iterator MBBI) const {}
+
+  virtual void emitCalleeSavedFrameMoves(MachineBasicBlock &MBB,
+                                         MachineBasicBlock::iterator MBBI,
+                                         const DebugLoc &DL,
+                                         bool IsPrologue) const {}
+
   /// Replace a StackProbe stub (if any) with the actual probe code inline
   virtual void inlineStackProbe(MachineFunction &MF,
                                 MachineBasicBlock &PrologueMBB) const {}
@@ -197,7 +240,7 @@
   /// storeRegToStackSlot(). Returns false otherwise.
   virtual bool spillCalleeSavedRegisters(MachineBasicBlock &MBB,
                                          MachineBasicBlock::iterator MI,
-                                        const std::vector<CalleeSavedInfo> &CSI,
+                                         ArrayRef<CalleeSavedInfo> CSI,
                                          const TargetRegisterInfo *TRI) const {
     return false;
   }
@@ -208,10 +251,11 @@
   /// If it returns true, and any of the registers in CSI is not restored,
   /// it sets the corresponding Restored flag in CSI to false.
   /// Returns false otherwise.
-  virtual bool restoreCalleeSavedRegisters(MachineBasicBlock &MBB,
-                                           MachineBasicBlock::iterator MI,
-                                           std::vector<CalleeSavedInfo> &CSI,
-                                        const TargetRegisterInfo *TRI) const {
+  virtual bool
+  restoreCalleeSavedRegisters(MachineBasicBlock &MBB,
+                              MachineBasicBlock::iterator MI,
+                              MutableArrayRef<CalleeSavedInfo> CSI,
+                              const TargetRegisterInfo *TRI) const {
     return false;
   }
 
@@ -254,8 +298,8 @@
   /// getFrameIndexReference - This method should return the base register
   /// and offset used to reference a frame index location. The offset is
   /// returned directly, and the base register is returned via FrameReg.
-  virtual int getFrameIndexReference(const MachineFunction &MF, int FI,
-                                     unsigned &FrameReg) const;
+  virtual StackOffset getFrameIndexReference(const MachineFunction &MF, int FI,
+                                             Register &FrameReg) const;
 
   /// Same as \c getFrameIndexReference, except that the stack pointer (as
   /// opposed to the frame pointer) will be the preferred value for \p
@@ -263,9 +307,10 @@
   /// use offsets from RSP.  If \p IgnoreSPUpdates is true, the returned
   /// offset is only guaranteed to be valid with respect to the value of SP at
   /// the end of the prologue.
-  virtual int getFrameIndexReferencePreferSP(const MachineFunction &MF, int FI,
-                                             unsigned &FrameReg,
-                                             bool IgnoreSPUpdates) const {
+  virtual StackOffset
+  getFrameIndexReferencePreferSP(const MachineFunction &MF, int FI,
+                                 Register &FrameReg,
+                                 bool IgnoreSPUpdates) const {
     // Always safe to dispatch to getFrameIndexReference.
     return getFrameIndexReference(MF, FI, FrameReg);
   }
@@ -273,14 +318,19 @@
   /// getNonLocalFrameIndexReference - This method returns the offset used to
   /// reference a frame index location. The offset can be from either FP/BP/SP
   /// based on which base register is returned by llvm.localaddress.
-  virtual int getNonLocalFrameIndexReference(const MachineFunction &MF,
-                                       int FI) const {
+  virtual StackOffset getNonLocalFrameIndexReference(const MachineFunction &MF,
+                                                     int FI) const {
     // By default, dispatch to getFrameIndexReference. Interested targets can
     // override this.
-    unsigned FrameReg;
+    Register FrameReg;
     return getFrameIndexReference(MF, FI, FrameReg);
   }
 
+  /// Returns the callee-saved registers as computed by determineCalleeSaves
+  /// in the BitVector \p SavedRegs.
+  virtual void getCalleeSaves(const MachineFunction &MF,
+                                  BitVector &SavedRegs) const;
+
   /// This method determines which of the registers reported by
   /// TargetRegisterInfo::getCalleeSavedRegs() should actually get saved.
   /// The default implementation checks populates the \p SavedRegs bitset with
@@ -288,6 +338,9 @@
   /// this function to save additional registers.
   /// This method also sets up the register scavenger ensuring there is a free
   /// register or a frameindex available.
+  /// This method should not be called by any passes outside of PEI, because
+  /// it may change state passed in by \p MF and \p RS. The preferred
+  /// interface outside PEI is getCalleeSaves.
   virtual void determineCalleeSaves(MachineFunction &MF, BitVector &SavedRegs,
                                     RegScavenger *RS = nullptr) const;
 
@@ -300,6 +353,13 @@
                                              RegScavenger *RS = nullptr) const {
   }
 
+  /// processFunctionBeforeFrameIndicesReplaced - This method is called
+  /// immediately before MO_FrameIndex operands are eliminated, but after the
+  /// frame is finalized. This method is optional.
+  virtual void
+  processFunctionBeforeFrameIndicesReplaced(MachineFunction &MF,
+                                            RegScavenger *RS = nullptr) const {}
+
   virtual unsigned getWinEHParentFrameOffset(const MachineFunction &MF) const {
     report_fatal_error("WinEH not implemented for this target");
   }
@@ -354,6 +414,11 @@
     return true;
   }
 
+  /// Returns the StackID that scalable vectors should be associated with.
+  virtual TargetStackID::Value getStackIDForScalableVectors() const {
+    return TargetStackID::Default;
+  }
+
   virtual bool isSupportedStackID(TargetStackID::Value ID) const {
     switch (ID) {
     default:
@@ -366,15 +431,10 @@
 
   /// Check if given function is safe for not having callee saved registers.
   /// This is used when interprocedural register allocation is enabled.
-  static bool isSafeForNoCSROpt(const Function &F) {
-    if (!F.hasLocalLinkage() || F.hasAddressTaken() ||
-        !F.hasFnAttribute(Attribute::NoRecurse))
-      return false;
-    // Function should not be optimized as tail call.
-    for (const User *U : F.users())
-      if (auto CS = ImmutableCallSite(U))
-        if (CS.isTailCall())
-          return false;
+  static bool isSafeForNoCSROpt(const Function &F);
+
+  /// Check if the no-CSR optimisation is profitable for the given function.
+  virtual bool isProfitableForNoCSROpt(const Function &F) const {
     return true;
   }
 
@@ -384,7 +444,11 @@
 
   /// Return initial CFA register value i.e. the one valid at the beginning of
   /// the function (before any stack operations).
-  virtual unsigned getInitialCFARegister(const MachineFunction &MF) const;
+  virtual Register getInitialCFARegister(const MachineFunction &MF) const;
+
+  /// Return the frame base information to be encoded in the DWARF subprogram
+  /// debug info.
+  virtual DwarfFrameBase getDwarfFrameBase(const MachineFunction &MF) const;
 };
 
 } // End llvm namespace
diff --git a/linux-x64/clang/include/llvm/CodeGen/TargetInstrInfo.h b/linux-x64/clang/include/llvm/CodeGen/TargetInstrInfo.h
index 314bb72..36afdef 100644
--- a/linux-x64/clang/include/llvm/CodeGen/TargetInstrInfo.h
+++ b/linux-x64/clang/include/llvm/CodeGen/TargetInstrInfo.h
@@ -17,15 +17,15 @@
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseMapInfo.h"
 #include "llvm/ADT/None.h"
-#include "llvm/CodeGen/LiveRegUnits.h"
+#include "llvm/CodeGen/MIRFormatter.h"
 #include "llvm/CodeGen/MachineBasicBlock.h"
 #include "llvm/CodeGen/MachineCombinerPattern.h"
 #include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/CodeGen/MachineInstr.h"
-#include "llvm/CodeGen/MachineLoopInfo.h"
+#include "llvm/CodeGen/MachineInstrBuilder.h"
 #include "llvm/CodeGen/MachineOperand.h"
 #include "llvm/CodeGen/MachineOutliner.h"
-#include "llvm/CodeGen/PseudoSourceValue.h"
+#include "llvm/CodeGen/RegisterClassInfo.h"
 #include "llvm/CodeGen/VirtRegMap.h"
 #include "llvm/MC/MCInstrInfo.h"
 #include "llvm/Support/BranchProbability.h"
@@ -38,10 +38,12 @@
 
 namespace llvm {
 
+class AAResults;
 class DFAPacketizer;
 class InstrItineraryData;
 class LiveIntervals;
 class LiveVariables;
+class MachineLoop;
 class MachineMemOperand;
 class MachineRegisterInfo;
 class MCAsmInfo;
@@ -49,6 +51,7 @@
 struct MCSchedModel;
 class Module;
 class ScheduleDAG;
+class ScheduleDAGMI;
 class ScheduleHazardRecognizer;
 class SDNode;
 class SelectionDAG;
@@ -60,7 +63,32 @@
 
 template <class T> class SmallVectorImpl;
 
-using ParamLoadedValue = std::pair<const MachineOperand*, DIExpression*>;
+using ParamLoadedValue = std::pair<MachineOperand, DIExpression*>;
+
+struct DestSourcePair {
+  const MachineOperand *Destination;
+  const MachineOperand *Source;
+
+  DestSourcePair(const MachineOperand &Dest, const MachineOperand &Src)
+      : Destination(&Dest), Source(&Src) {}
+};
+
+/// Used to describe a register and immediate addition.
+struct RegImmPair {
+  Register Reg;
+  int64_t Imm;
+
+  RegImmPair(Register Reg, int64_t Imm) : Reg(Reg), Imm(Imm) {}
+};
+
+/// Used to describe addressing mode similar to ExtAddrMode in CodeGenPrepare.
+/// It holds the register values, the scale value and the displacement.
+struct ExtAddrMode {
+  Register BaseReg;
+  Register ScaledReg;
+  int64_t Scale;
+  int64_t Displacement;
+};
 
 //---------------------------------------------------------------------------
 ///
@@ -94,7 +122,7 @@
   /// registers so that the instructions result is independent of the place
   /// in the function.
   bool isTriviallyReMaterializable(const MachineInstr &MI,
-                                   AliasAnalysis *AA = nullptr) const {
+                                   AAResults *AA = nullptr) const {
     return MI.getOpcode() == TargetOpcode::IMPLICIT_DEF ||
            (MI.getDesc().isRematerializable() &&
             (isReallyTriviallyReMaterializable(MI, AA) ||
@@ -110,7 +138,7 @@
   /// not always available.
   /// Requirements must be check as stated in isTriviallyReMaterializable() .
   virtual bool isReallyTriviallyReMaterializable(const MachineInstr &MI,
-                                                 AliasAnalysis *AA) const {
+                                                 AAResults *AA) const {
     return false;
   }
 
@@ -153,7 +181,7 @@
   /// this function does target-independent tests to determine if the
   /// instruction is really trivially rematerializable.
   bool isReallyTriviallyReMaterializableGeneric(const MachineInstr &MI,
-                                                AliasAnalysis *AA) const;
+                                                AAResults *AA) const;
 
 public:
   /// These methods return the opcode of the frame setup/destroy instructions
@@ -215,8 +243,8 @@
   /// destination. e.g. X86::MOVSX64rr32. If this returns true, then it's
   /// expected the pre-extension value is available as a subreg of the result
   /// register. This also returns the sub-register index in SubIdx.
-  virtual bool isCoalescableExtInstr(const MachineInstr &MI, unsigned &SrcReg,
-                                     unsigned &DstReg, unsigned &SubIdx) const {
+  virtual bool isCoalescableExtInstr(const MachineInstr &MI, Register &SrcReg,
+                                     Register &DstReg, unsigned &SubIdx) const {
     return false;
   }
 
@@ -321,6 +349,12 @@
                                  unsigned &Size, unsigned &Offset,
                                  const MachineFunction &MF) const;
 
+  /// Return true if the given instruction is terminator that is unspillable,
+  /// according to isUnspillableTerminatorImpl.
+  bool isUnspillableTerminator(const MachineInstr *MI) const {
+    return MI->isTerminator() && isUnspillableTerminatorImpl(MI);
+  }
+
   /// Returns the size in bytes of the specified MachineInstr, or ~0U
   /// when this function is not implemented by a target.
   virtual unsigned getInstSizeInBytes(const MachineInstr &MI) const {
@@ -348,7 +382,7 @@
   /// DestReg:SubIdx. Any existing subreg index is preserved or composed with
   /// SubIdx.
   virtual void reMaterialize(MachineBasicBlock &MBB,
-                             MachineBasicBlock::iterator MI, unsigned DestReg,
+                             MachineBasicBlock::iterator MI, Register DestReg,
                              unsigned SubIdx, const MachineInstr &Orig,
                              const TargetRegisterInfo &TRI) const;
 
@@ -421,16 +455,17 @@
   ///     findCommutedOpIndices(MI, Op1, Op2);
   /// can be interpreted as a query asking to find an operand that would be
   /// commutable with the operand#1.
-  virtual bool findCommutedOpIndices(MachineInstr &MI, unsigned &SrcOpIdx1,
+  virtual bool findCommutedOpIndices(const MachineInstr &MI,
+                                     unsigned &SrcOpIdx1,
                                      unsigned &SrcOpIdx2) const;
 
   /// A pair composed of a register and a sub-register index.
   /// Used to give some type checking when modeling Reg:SubReg.
   struct RegSubRegPair {
-    unsigned Reg;
+    Register Reg;
     unsigned SubReg;
 
-    RegSubRegPair(unsigned Reg = 0, unsigned SubReg = 0)
+    RegSubRegPair(Register Reg = Register(), unsigned SubReg = 0)
         : Reg(Reg), SubReg(SubReg) {}
 
     bool operator==(const RegSubRegPair& P) const {
@@ -447,7 +482,7 @@
   struct RegSubRegPairAndIdx : RegSubRegPair {
     unsigned SubIdx;
 
-    RegSubRegPairAndIdx(unsigned Reg = 0, unsigned SubReg = 0,
+    RegSubRegPairAndIdx(Register Reg = Register(), unsigned SubReg = 0,
                         unsigned SubIdx = 0)
         : RegSubRegPair(Reg, SubReg), SubIdx(SubIdx) {}
   };
@@ -623,7 +658,7 @@
   }
 
   /// Remove the branching code at the end of the specific MBB.
-  /// This is only invoked in cases where AnalyzeBranch returns success. It
+  /// This is only invoked in cases where analyzeBranch returns success. It
   /// returns the number of instructions that were removed.
   /// If \p BytesRemoved is non-null, report the change in code size from the
   /// removed instructions.
@@ -633,13 +668,13 @@
   }
 
   /// Insert branch code into the end of the specified MachineBasicBlock. The
-  /// operands to this method are the same as those returned by AnalyzeBranch.
-  /// This is only invoked in cases where AnalyzeBranch returns success. It
+  /// operands to this method are the same as those returned by analyzeBranch.
+  /// This is only invoked in cases where analyzeBranch returns success. It
   /// returns the number of instructions inserted. If \p BytesAdded is non-null,
   /// report the change in code size from the added instructions.
   ///
   /// It is also invoked by tail merging to add unconditional branches in
-  /// cases where AnalyzeBranch doesn't apply because there was no original
+  /// cases where analyzeBranch doesn't apply because there was no original
   /// branch to analyze.  At least this much must be implemented, else tail
   /// merging needs to be disabled.
   ///
@@ -661,7 +696,51 @@
                         BytesAdded);
   }
 
-  /// Analyze the loop code, return true if it cannot be understoo. Upon
+  /// Object returned by analyzeLoopForPipelining. Allows software pipelining
+  /// implementations to query attributes of the loop being pipelined and to
+  /// apply target-specific updates to the loop once pipelining is complete.
+  class PipelinerLoopInfo {
+  public:
+    virtual ~PipelinerLoopInfo();
+    /// Return true if the given instruction should not be pipelined and should
+    /// be ignored. An example could be a loop comparison, or induction variable
+    /// update with no users being pipelined.
+    virtual bool shouldIgnoreForPipelining(const MachineInstr *MI) const = 0;
+
+    /// Create a condition to determine if the trip count of the loop is greater
+    /// than TC.
+    ///
+    /// If the trip count is statically known to be greater than TC, return
+    /// true. If the trip count is statically known to be not greater than TC,
+    /// return false. Otherwise return nullopt and fill out Cond with the test
+    /// condition.
+    virtual Optional<bool>
+    createTripCountGreaterCondition(int TC, MachineBasicBlock &MBB,
+                                    SmallVectorImpl<MachineOperand> &Cond) = 0;
+
+    /// Modify the loop such that the trip count is
+    /// OriginalTC + TripCountAdjust.
+    virtual void adjustTripCount(int TripCountAdjust) = 0;
+
+    /// Called when the loop's preheader has been modified to NewPreheader.
+    virtual void setPreheader(MachineBasicBlock *NewPreheader) = 0;
+
+    /// Called when the loop is being removed. Any instructions in the preheader
+    /// should be removed.
+    ///
+    /// Once this function is called, no other functions on this object are
+    /// valid; the loop has been removed.
+    virtual void disposed() = 0;
+  };
+
+  /// Analyze loop L, which must be a single-basic-block loop, and if the
+  /// conditions can be understood enough produce a PipelinerLoopInfo object.
+  virtual std::unique_ptr<PipelinerLoopInfo>
+  analyzeLoopForPipelining(MachineBasicBlock *LoopBB) const {
+    return nullptr;
+  }
+
+  /// Analyze the loop code, return true if it cannot be understood. Upon
   /// success, this function returns false and returns information about the
   /// induction variable and compare instruction used at the end.
   virtual bool analyzeLoop(MachineLoop &L, MachineInstr *&IndVarInst,
@@ -708,7 +787,7 @@
 
   /// Second variant of isProfitableToIfCvt. This one
   /// checks for the case where two basic blocks from true and false path
-  /// of a if-then-else (diamond) are predicated on mutally exclusive
+  /// of a if-then-else (diamond) are predicated on mutually exclusive
   /// predicates, where the probability of the true path being taken is given
   /// by Probability, and Confidence is a measure of our confidence that it
   /// will be properly predicted.
@@ -732,6 +811,19 @@
     return false;
   }
 
+  /// Return the increase in code size needed to predicate a contiguous run of
+  /// NumInsts instructions.
+  virtual unsigned extraSizeToPredicateInstructions(const MachineFunction &MF,
+                                                    unsigned NumInsts) const {
+    return 0;
+  }
+
+  /// Return an estimate for the code size reduction (in bytes) which will be
+  /// caused by removing the given branch instruction during if-conversion.
+  virtual unsigned predictBranchSizeForIfCvt(MachineInstr &MI) const {
+    return getInstSizeInBytes(MI);
+  }
+
   /// Return true if it's profitable to unpredicate
   /// one side of a 'diamond', i.e. two sides of if-else predicated on mutually
   /// exclusive predicates.
@@ -759,16 +851,18 @@
   /// Some x86 implementations have 2-cycle cmov instructions.
   ///
   /// @param MBB         Block where select instruction would be inserted.
-  /// @param Cond        Condition returned by AnalyzeBranch.
+  /// @param Cond        Condition returned by analyzeBranch.
+  /// @param DstReg      Virtual dest register that the result should write to.
   /// @param TrueReg     Virtual register to select when Cond is true.
   /// @param FalseReg    Virtual register to select when Cond is false.
   /// @param CondCycles  Latency from Cond+Branch to select output.
   /// @param TrueCycles  Latency from TrueReg to select output.
   /// @param FalseCycles Latency from FalseReg to select output.
   virtual bool canInsertSelect(const MachineBasicBlock &MBB,
-                               ArrayRef<MachineOperand> Cond, unsigned TrueReg,
-                               unsigned FalseReg, int &CondCycles,
-                               int &TrueCycles, int &FalseCycles) const {
+                               ArrayRef<MachineOperand> Cond, Register DstReg,
+                               Register TrueReg, Register FalseReg,
+                               int &CondCycles, int &TrueCycles,
+                               int &FalseCycles) const {
     return false;
   }
 
@@ -776,7 +870,7 @@
   /// DstReg when Cond is true, and FalseReg to DstReg when Cond is false.
   ///
   /// This function can only be called after canInsertSelect() returned true.
-  /// The condition in Cond comes from AnalyzeBranch, and it can be assumed
+  /// The condition in Cond comes from analyzeBranch, and it can be assumed
   /// that the same flags or registers required by Cond are available at the
   /// insertion point.
   ///
@@ -784,13 +878,13 @@
   /// @param I        Insertion point.
   /// @param DL       Source location for debugging.
   /// @param DstReg   Virtual register to be defined by select instruction.
-  /// @param Cond     Condition as computed by AnalyzeBranch.
+  /// @param Cond     Condition as computed by analyzeBranch.
   /// @param TrueReg  Virtual register to copy when Cond is true.
   /// @param FalseReg Virtual register to copy when Cons is false.
   virtual void insertSelect(MachineBasicBlock &MBB,
                             MachineBasicBlock::iterator I, const DebugLoc &DL,
-                            unsigned DstReg, ArrayRef<MachineOperand> Cond,
-                            unsigned TrueReg, unsigned FalseReg) const {
+                            Register DstReg, ArrayRef<MachineOperand> Cond,
+                            Register TrueReg, Register FalseReg) const {
     llvm_unreachable("Target didn't implement TargetInstrInfo::insertSelect!");
   }
 
@@ -852,36 +946,62 @@
   /// large registers. See for example the ARM target.
   virtual void copyPhysReg(MachineBasicBlock &MBB,
                            MachineBasicBlock::iterator MI, const DebugLoc &DL,
-                           unsigned DestReg, unsigned SrcReg,
+                           MCRegister DestReg, MCRegister SrcReg,
                            bool KillSrc) const {
     llvm_unreachable("Target didn't implement TargetInstrInfo::copyPhysReg!");
   }
 
 protected:
-  /// Target-dependent implemenation for IsCopyInstr.
+  /// Target-dependent implementation for IsCopyInstr.
   /// If the specific machine instruction is a instruction that moves/copies
-  /// value from one register to another register return true along with
-  /// @Source machine operand and @Destination machine operand.
-  virtual bool isCopyInstrImpl(const MachineInstr &MI,
-                               const MachineOperand *&Source,
-                               const MachineOperand *&Destination) const {
+  /// value from one register to another register return destination and source
+  /// registers as machine operands.
+  virtual Optional<DestSourcePair>
+  isCopyInstrImpl(const MachineInstr &MI) const {
+    return None;
+  }
+
+  /// Return true if the given terminator MI is not expected to spill. This
+  /// sets the live interval as not spillable and adjusts phi node lowering to
+  /// not introduce copies after the terminator. Use with care, these are
+  /// currently used for hardware loop intrinsics in very controlled situations,
+  /// created prior to registry allocation in loops that only have single phi
+  /// users for the terminators value. They may run out of registers if not used
+  /// carefully.
+  virtual bool isUnspillableTerminatorImpl(const MachineInstr *MI) const {
     return false;
   }
 
 public:
   /// If the specific machine instruction is a instruction that moves/copies
-  /// value from one register to another register return true along with
-  /// @Source machine operand and @Destination machine operand.
-  /// For COPY-instruction the method naturally returns true, for all other
-  /// instructions the method calls target-dependent implementation.
-  bool isCopyInstr(const MachineInstr &MI, const MachineOperand *&Source,
-                   const MachineOperand *&Destination) const {
+  /// value from one register to another register return destination and source
+  /// registers as machine operands.
+  /// For COPY-instruction the method naturally returns destination and source
+  /// registers as machine operands, for all other instructions the method calls
+  /// target-dependent implementation.
+  Optional<DestSourcePair> isCopyInstr(const MachineInstr &MI) const {
     if (MI.isCopy()) {
-      Destination = &MI.getOperand(0);
-      Source = &MI.getOperand(1);
-      return true;
+      return DestSourcePair{MI.getOperand(0), MI.getOperand(1)};
     }
-    return isCopyInstrImpl(MI, Source, Destination);
+    return isCopyInstrImpl(MI);
+  }
+
+  /// If the specific machine instruction is an instruction that adds an
+  /// immediate value and a physical register, and stores the result in
+  /// the given physical register \c Reg, return a pair of the source
+  /// register and the offset which has been added.
+  virtual Optional<RegImmPair> isAddImmediate(const MachineInstr &MI,
+                                              Register Reg) const {
+    return None;
+  }
+
+  /// Returns true if MI is an instruction that defines Reg to have a constant
+  /// value and the value is recorded in ImmVal. The ImmVal is a result that
+  /// should be interpreted as modulo size of Reg.
+  virtual bool getConstValDefinedInReg(const MachineInstr &MI,
+                                       const Register Reg,
+                                       int64_t &ImmVal) const {
+    return false;
   }
 
   /// Store the specified register of the given register class to the specified
@@ -890,7 +1010,7 @@
   /// is true, the register operand is the last use and must be marked kill.
   virtual void storeRegToStackSlot(MachineBasicBlock &MBB,
                                    MachineBasicBlock::iterator MI,
-                                   unsigned SrcReg, bool isKill, int FrameIndex,
+                                   Register SrcReg, bool isKill, int FrameIndex,
                                    const TargetRegisterClass *RC,
                                    const TargetRegisterInfo *TRI) const {
     llvm_unreachable("Target didn't implement "
@@ -902,7 +1022,7 @@
   /// machine basic block before the specified machine instruction.
   virtual void loadRegFromStackSlot(MachineBasicBlock &MBB,
                                     MachineBasicBlock::iterator MI,
-                                    unsigned DestReg, int FrameIndex,
+                                    Register DestReg, int FrameIndex,
                                     const TargetRegisterClass *RC,
                                     const TargetRegisterInfo *TRI) const {
     llvm_unreachable("Target didn't implement "
@@ -957,9 +1077,23 @@
   /// faster sequence.
   /// \param Root - Instruction that could be combined with one of its operands
   /// \param Patterns - Vector of possible combination patterns
-  virtual bool getMachineCombinerPatterns(
-      MachineInstr &Root,
-      SmallVectorImpl<MachineCombinerPattern> &Patterns) const;
+  virtual bool
+  getMachineCombinerPatterns(MachineInstr &Root,
+                             SmallVectorImpl<MachineCombinerPattern> &Patterns,
+                             bool DoRegPressureReduce) const;
+
+  /// Return true if target supports reassociation of instructions in machine
+  /// combiner pass to reduce register pressure for a given BB.
+  virtual bool
+  shouldReduceRegisterPressure(MachineBasicBlock *MBB,
+                               RegisterClassInfo *RegClassInfo) const {
+    return false;
+  }
+
+  /// Fix up the placeholder we may add in genAlternativeCodeSequence().
+  virtual void
+  finalizeInsInstrs(MachineInstr &Root, MachineCombinerPattern &P,
+                    SmallVectorImpl<MachineInstr *> &InsInstrs) const {}
 
   /// Return true when a code sequence can improve throughput. It
   /// should be called only for instructions in loops.
@@ -1009,12 +1143,17 @@
                       SmallVectorImpl<MachineInstr *> &DelInstrs,
                       DenseMap<unsigned, unsigned> &InstrIdxForVirtReg) const;
 
+  /// The limit on resource length extension we accept in MachineCombiner Pass.
+  virtual int getExtendResourceLenLimit() const { return 0; }
+
   /// This is an architecture-specific helper function of reassociateOps.
   /// Set special operand attributes for new instructions after reassociation.
   virtual void setSpecialOperandAttr(MachineInstr &OldMI1, MachineInstr &OldMI2,
                                      MachineInstr &NewMI1,
                                      MachineInstr &NewMI2) const {}
 
+  virtual void setSpecialOperandAttr(MachineInstr &MI, uint16_t Flags) const {}
+
   /// Return true when a target supports MachineCombiner.
   virtual bool useMachineCombiner() const { return false; }
 
@@ -1152,11 +1291,24 @@
   }
 
   /// Get the base operand and byte offset of an instruction that reads/writes
-  /// memory.
-  virtual bool getMemOperandWithOffset(const MachineInstr &MI,
-                                       const MachineOperand *&BaseOp,
-                                       int64_t &Offset,
-                                       const TargetRegisterInfo *TRI) const {
+  /// memory. This is a convenience function for callers that are only prepared
+  /// to handle a single base operand.
+  bool getMemOperandWithOffset(const MachineInstr &MI,
+                               const MachineOperand *&BaseOp, int64_t &Offset,
+                               bool &OffsetIsScalable,
+                               const TargetRegisterInfo *TRI) const;
+
+  /// Get zero or more base operands and the byte offset of an instruction that
+  /// reads/writes memory. Note that there may be zero base operands if the
+  /// instruction accesses a constant address.
+  /// It returns false if MI does not read/write memory.
+  /// It returns false if base operands and offset could not be determined.
+  /// It is not guaranteed to always recognize base operands and offsets in all
+  /// cases.
+  virtual bool getMemOperandsWithOffsetWidth(
+      const MachineInstr &MI, SmallVectorImpl<const MachineOperand *> &BaseOps,
+      int64_t &Offset, bool &OffsetIsScalable, unsigned &Width,
+      const TargetRegisterInfo *TRI) const {
     return false;
   }
 
@@ -1169,6 +1321,27 @@
     return false;
   }
 
+  /// Target dependent implementation to get the values constituting the address
+  /// MachineInstr that is accessing memory. These values are returned as a
+  /// struct ExtAddrMode which contains all relevant information to make up the
+  /// address.
+  virtual Optional<ExtAddrMode>
+  getAddrModeFromMemoryOp(const MachineInstr &MemI,
+                          const TargetRegisterInfo *TRI) const {
+    return None;
+  }
+
+  /// Returns true if MI's Def is NullValueReg, and the MI
+  /// does not change the Zero value. i.e. cases such as rax = shr rax, X where
+  /// NullValueReg = rax. Note that if the NullValueReg is non-zero, this
+  /// function can return true even if becomes zero. Specifically cases such as
+  /// NullValueReg = shl NullValueReg, 63.
+  virtual bool preservesZeroValueInReg(const MachineInstr *MI,
+                                       const Register NullValueReg,
+                                       const TargetRegisterInfo *TRI) const {
+    return false;
+  }
+
   /// If the instruction is an increment of a constant value, return the amount.
   virtual bool getIncrementValue(const MachineInstr &MI, int &Value) const {
     return false;
@@ -1180,9 +1353,15 @@
   /// or
   ///   DAG->addMutation(createStoreClusterDAGMutation(DAG->TII, DAG->TRI));
   /// to TargetPassConfig::createMachineScheduler() to have an effect.
-  virtual bool shouldClusterMemOps(const MachineOperand &BaseOp1,
-                                   const MachineOperand &BaseOp2,
-                                   unsigned NumLoads) const {
+  ///
+  /// \p BaseOps1 and \p BaseOps2 are memory operands of two memory operations.
+  /// \p NumLoads is the number of loads that will be in the cluster if this
+  /// hook returns true.
+  /// \p NumBytes is the number of bytes that will be loaded from all the
+  /// clustered loads if this hook returns true.
+  virtual bool shouldClusterMemOps(ArrayRef<const MachineOperand *> BaseOps1,
+                                   ArrayRef<const MachineOperand *> BaseOps2,
+                                   unsigned NumLoads, unsigned NumBytes) const {
     llvm_unreachable("target did not implement shouldClusterMemOps()");
   }
 
@@ -1197,6 +1376,11 @@
   virtual void insertNoop(MachineBasicBlock &MBB,
                           MachineBasicBlock::iterator MI) const;
 
+  /// Insert noops into the instruction stream at the specified point.
+  virtual void insertNoops(MachineBasicBlock &MBB,
+                           MachineBasicBlock::iterator MI,
+                           unsigned Quantity) const;
+
   /// Return the noop instruction to use for a noop.
   virtual void getNoop(MCInst &NopInst) const;
 
@@ -1206,9 +1390,14 @@
   /// Returns true if the instruction is already predicated.
   virtual bool isPredicated(const MachineInstr &MI) const { return false; }
 
+  // Returns a MIRPrinter comment for this machine operand.
+  virtual std::string
+  createMIROperandComment(const MachineInstr &MI, const MachineOperand &Op,
+                          unsigned OpIdx, const TargetRegisterInfo *TRI) const;
+
   /// Returns true if the instruction is a
   /// terminator instruction that has not been predicated.
-  virtual bool isUnpredicatedTerminator(const MachineInstr &MI) const;
+  bool isUnpredicatedTerminator(const MachineInstr &MI) const;
 
   /// Returns true if MI is an unconditional tail call.
   virtual bool isUnconditionalTailCall(const MachineInstr &MI) const {
@@ -1243,8 +1432,13 @@
   /// If the specified instruction defines any predicate
   /// or condition code register(s) used for predication, returns true as well
   /// as the definition predicate(s) by reference.
-  virtual bool DefinesPredicate(MachineInstr &MI,
-                                std::vector<MachineOperand> &Pred) const {
+  /// SkipDead should be set to false at any point that dead
+  /// predicate instructions should be considered as being defined.
+  /// A dead predicate instruction is one that is guaranteed to be removed
+  /// after a call to PredicateInstruction.
+  virtual bool ClobbersPredicate(MachineInstr &MI,
+                                 std::vector<MachineOperand> &Pred,
+                                 bool SkipDead) const {
     return false;
   }
 
@@ -1283,7 +1477,7 @@
   /// scheduling the machine instructions before register allocation.
   virtual ScheduleHazardRecognizer *
   CreateTargetMIHazardRecognizer(const InstrItineraryData *,
-                                 const ScheduleDAG *DAG) const;
+                                 const ScheduleDAGMI *DAG) const;
 
   /// Allocate and return a hazard recognizer to use for this target when
   /// scheduling the machine instructions after register allocation.
@@ -1306,16 +1500,16 @@
   /// in SrcReg and SrcReg2 if having two register operands, and the value it
   /// compares against in CmpValue. Return true if the comparison instruction
   /// can be analyzed.
-  virtual bool analyzeCompare(const MachineInstr &MI, unsigned &SrcReg,
-                              unsigned &SrcReg2, int &Mask, int &Value) const {
+  virtual bool analyzeCompare(const MachineInstr &MI, Register &SrcReg,
+                              Register &SrcReg2, int &Mask, int &Value) const {
     return false;
   }
 
   /// See if the comparison instruction can be converted
   /// into something more efficient. E.g., on ARM most instructions can set the
   /// flags register, obviating the need for a separate CMP.
-  virtual bool optimizeCompareInstr(MachineInstr &CmpInstr, unsigned SrcReg,
-                                    unsigned SrcReg2, int Mask, int Value,
+  virtual bool optimizeCompareInstr(MachineInstr &CmpInstr, Register SrcReg,
+                                    Register SrcReg2, int Mask, int Value,
                                     const MachineRegisterInfo *MRI) const {
     return false;
   }
@@ -1330,7 +1524,7 @@
   /// the machine instruction generated due to folding.
   virtual MachineInstr *optimizeLoadInstr(MachineInstr &MI,
                                           const MachineRegisterInfo *MRI,
-                                          unsigned &FoldAsLoadDefReg,
+                                          Register &FoldAsLoadDefReg,
                                           MachineInstr *&DefMI) const {
     return nullptr;
   }
@@ -1342,7 +1536,7 @@
   /// block. The caller may assume that it will not be erased by this
   /// function otherwise.
   virtual bool FoldImmediate(MachineInstr &UseMI, MachineInstr &DefMI,
-                             unsigned Reg, MachineRegisterInfo *MRI) const {
+                             Register Reg, MachineRegisterInfo *MRI) const {
     return false;
   }
 
@@ -1515,7 +1709,7 @@
   /// This hook works similarly to getPartialRegUpdateClearance, except that it
   /// does not take an operand index. Instead sets \p OpNum to the index of the
   /// unused register.
-  virtual unsigned getUndefRegClearance(const MachineInstr &MI, unsigned &OpNum,
+  virtual unsigned getUndefRegClearance(const MachineInstr &MI, unsigned OpNum,
                                         const TargetRegisterInfo *TRI) const {
     // The default implementation returns 0 for no undef register dependency.
     return 0;
@@ -1560,11 +1754,10 @@
   /// function.
   virtual bool
   areMemAccessesTriviallyDisjoint(const MachineInstr &MIa,
-                                  const MachineInstr &MIb,
-                                  AliasAnalysis *AA = nullptr) const {
-    assert((MIa.mayLoad() || MIa.mayStore()) &&
+                                  const MachineInstr &MIb) const {
+    assert(MIa.mayLoadOrStore() &&
            "MIa must load from or modify a memory location");
-    assert((MIb.mayLoad() || MIb.mayStore()) &&
+    assert(MIb.mayLoadOrStore() &&
            "MIb must load from or modify a memory location");
     return false;
   }
@@ -1577,6 +1770,21 @@
     return 5;
   }
 
+  /// Return the maximal number of alias checks on memory operands. For
+  /// instructions with more than one memory operands, the alias check on a
+  /// single MachineInstr pair has quadratic overhead and results in
+  /// unacceptable performance in the worst case. The limit here is to clamp
+  /// that maximal checks performed. Usually, that's the product of memory
+  /// operand numbers from that pair of MachineInstr to be checked. For
+  /// instance, with two MachineInstrs with 4 and 5 memory operands
+  /// correspondingly, a total of 20 checks are required. With this limit set to
+  /// 16, their alias check is skipped. We choose to limit the product instead
+  /// of the individual instruction as targets may have special MachineInstrs
+  /// with a considerably high number of memory operands, such as `ldm` in ARM.
+  /// Setting this limit per MachineInstr would result in either too high
+  /// overhead or too rigid restriction.
+  virtual unsigned getMemOperandAACheckLimit() const { return 16; }
+
   /// Return an array that contains the ids of the target indices (used for the
   /// TargetIndex machine operand) and their names.
   ///
@@ -1638,6 +1846,28 @@
     return false;
   }
 
+  /// During PHI eleimination lets target to make necessary checks and
+  /// insert the copy to the PHI destination register in a target specific
+  /// manner.
+  virtual MachineInstr *createPHIDestinationCopy(
+      MachineBasicBlock &MBB, MachineBasicBlock::iterator InsPt,
+      const DebugLoc &DL, Register Src, Register Dst) const {
+    return BuildMI(MBB, InsPt, DL, get(TargetOpcode::COPY), Dst)
+        .addReg(Src);
+  }
+
+  /// During PHI eleimination lets target to make necessary checks and
+  /// insert the copy to the PHI destination register in a target specific
+  /// manner.
+  virtual MachineInstr *createPHISourceCopy(MachineBasicBlock &MBB,
+                                            MachineBasicBlock::iterator InsPt,
+                                            const DebugLoc &DL, Register Src,
+                                            unsigned SrcSubReg,
+                                            Register Dst) const {
+    return BuildMI(MBB, InsPt, DL, get(TargetOpcode::COPY), Dst)
+        .addReg(Src, 0, SrcSubReg);
+  }
+
   /// Returns a \p outliner::OutlinedFunction struct containing target-specific
   /// information for a set of outlining candidates.
   virtual outliner::OutlinedFunction getOutliningCandidateInfo(
@@ -1693,11 +1923,22 @@
     return false;
   }
 
-  /// Produce RHS description of parameter's loading instruction \p MI.
-  virtual Optional<ParamLoadedValue>
-  describeLoadedValue(const MachineInstr &MI) const;
+  /// Produce the expression describing the \p MI loading a value into
+  /// the physical register \p Reg. This hook should only be used with
+  /// \p MIs belonging to VReg-less functions.
+  virtual Optional<ParamLoadedValue> describeLoadedValue(const MachineInstr &MI,
+                                                         Register Reg) const;
+
+  /// Return MIR formatter to format/parse MIR operands.  Target can override
+  /// this virtual function and return target specific MIR formatter.
+  virtual const MIRFormatter *getMIRFormatter() const {
+    if (!Formatter.get())
+      Formatter = std::make_unique<MIRFormatter>();
+    return Formatter.get();
+  }
 
 private:
+  mutable std::unique_ptr<MIRFormatter> Formatter;
   unsigned CallFrameSetupOpcode, CallFrameDestroyOpcode;
   unsigned CatchRetOpcode;
   unsigned ReturnOpcode;
diff --git a/linux-x64/clang/include/llvm/CodeGen/TargetLowering.h b/linux-x64/clang/include/llvm/CodeGen/TargetLowering.h
index d5cca60..305107c 100644
--- a/linux-x64/clang/include/llvm/CodeGen/TargetLowering.h
+++ b/linux-x64/clang/include/llvm/CodeGen/TargetLowering.h
@@ -28,7 +28,6 @@
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
-#include "llvm/Analysis/LegacyDivergenceAnalysis.h"
 #include "llvm/CodeGen/DAGCombine.h"
 #include "llvm/CodeGen/ISDOpcodes.h"
 #include "llvm/CodeGen/RuntimeLibcalls.h"
@@ -37,7 +36,6 @@
 #include "llvm/CodeGen/TargetCallingConv.h"
 #include "llvm/CodeGen/ValueTypes.h"
 #include "llvm/IR/Attributes.h"
-#include "llvm/IR/CallSite.h"
 #include "llvm/IR/CallingConv.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/DerivedTypes.h"
@@ -47,12 +45,11 @@
 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/Type.h"
-#include "llvm/MC/MCRegisterInfo.h"
+#include "llvm/Support/Alignment.h"
 #include "llvm/Support/AtomicOrdering.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MachineValueType.h"
-#include "llvm/Target/TargetMachine.h"
 #include <algorithm>
 #include <cassert>
 #include <climits>
@@ -72,8 +69,10 @@
 class FastISel;
 class FunctionLoweringInfo;
 class GlobalValue;
+class GISelKnownBits;
 class IntrinsicInst;
 struct KnownBits;
+class LegacyDivergenceAnalysis;
 class LLVMContext;
 class MachineBasicBlock;
 class MachineFunction;
@@ -84,9 +83,12 @@
 class MCContext;
 class MCExpr;
 class Module;
-class TargetRegisterClass;
+class ProfileSummaryInfo;
 class TargetLibraryInfo;
+class TargetMachine;
+class TargetRegisterClass;
 class TargetRegisterInfo;
+class TargetTransformInfo;
 class Value;
 
 namespace Sched {
@@ -102,6 +104,85 @@
 
 } // end namespace Sched
 
+// MemOp models a memory operation, either memset or memcpy/memmove.
+struct MemOp {
+private:
+  // Shared
+  uint64_t Size;
+  bool DstAlignCanChange; // true if destination alignment can satisfy any
+                          // constraint.
+  Align DstAlign;         // Specified alignment of the memory operation.
+
+  bool AllowOverlap;
+  // memset only
+  bool IsMemset;   // If setthis memory operation is a memset.
+  bool ZeroMemset; // If set clears out memory with zeros.
+  // memcpy only
+  bool MemcpyStrSrc; // Indicates whether the memcpy source is an in-register
+                     // constant so it does not need to be loaded.
+  Align SrcAlign;    // Inferred alignment of the source or default value if the
+                     // memory operation does not need to load the value.
+public:
+  static MemOp Copy(uint64_t Size, bool DstAlignCanChange, Align DstAlign,
+                    Align SrcAlign, bool IsVolatile,
+                    bool MemcpyStrSrc = false) {
+    MemOp Op;
+    Op.Size = Size;
+    Op.DstAlignCanChange = DstAlignCanChange;
+    Op.DstAlign = DstAlign;
+    Op.AllowOverlap = !IsVolatile;
+    Op.IsMemset = false;
+    Op.ZeroMemset = false;
+    Op.MemcpyStrSrc = MemcpyStrSrc;
+    Op.SrcAlign = SrcAlign;
+    return Op;
+  }
+
+  static MemOp Set(uint64_t Size, bool DstAlignCanChange, Align DstAlign,
+                   bool IsZeroMemset, bool IsVolatile) {
+    MemOp Op;
+    Op.Size = Size;
+    Op.DstAlignCanChange = DstAlignCanChange;
+    Op.DstAlign = DstAlign;
+    Op.AllowOverlap = !IsVolatile;
+    Op.IsMemset = true;
+    Op.ZeroMemset = IsZeroMemset;
+    Op.MemcpyStrSrc = false;
+    return Op;
+  }
+
+  uint64_t size() const { return Size; }
+  Align getDstAlign() const {
+    assert(!DstAlignCanChange);
+    return DstAlign;
+  }
+  bool isFixedDstAlign() const { return !DstAlignCanChange; }
+  bool allowOverlap() const { return AllowOverlap; }
+  bool isMemset() const { return IsMemset; }
+  bool isMemcpy() const { return !IsMemset; }
+  bool isMemcpyWithFixedDstAlign() const {
+    return isMemcpy() && !DstAlignCanChange;
+  }
+  bool isZeroMemset() const { return isMemset() && ZeroMemset; }
+  bool isMemcpyStrSrc() const {
+    assert(isMemcpy() && "Must be a memcpy");
+    return MemcpyStrSrc;
+  }
+  Align getSrcAlign() const {
+    assert(isMemcpy() && "Must be a memcpy");
+    return SrcAlign;
+  }
+  bool isSrcAligned(Align AlignCheck) const {
+    return isMemset() || llvm::isAligned(AlignCheck, SrcAlign.value());
+  }
+  bool isDstAligned(Align AlignCheck) const {
+    return DstAlignCanChange || llvm::isAligned(AlignCheck, DstAlign.value());
+  }
+  bool isAligned(Align AlignCheck) const {
+    return isSrcAligned(AlignCheck) && isDstAligned(AlignCheck);
+  }
+};
+
 /// This base class for TargetLowering contains the SelectionDAG-independent
 /// parts that can be used from the rest of CodeGen.
 class TargetLoweringBase {
@@ -122,13 +203,20 @@
     TypeLegal,           // The target natively supports this type.
     TypePromoteInteger,  // Replace this integer with a larger one.
     TypeExpandInteger,   // Split this integer into two of half the size.
-    TypeSoftenFloat,     // Convert this float to a same size integer type,
-                         // if an operation is not supported in target HW.
+    TypeSoftenFloat,     // Convert this float to a same size integer type.
     TypeExpandFloat,     // Split this float into two of half the size.
     TypeScalarizeVector, // Replace this one-element vector with its element.
     TypeSplitVector,     // Split this vector into two of half the size.
     TypeWidenVector,     // This vector should be widened into a larger vector.
-    TypePromoteFloat     // Replace this float with a larger one.
+    TypePromoteFloat,    // Replace this float with a larger one.
+    TypeSoftPromoteHalf, // Soften half to i16 and use float to do arithmetic.
+    TypeScalarizeScalableVector, // This action is explicitly left unimplemented.
+                                 // While it is theoretically possible to
+                                 // legalize operations on scalable types with a
+                                 // loop that handles the vscale * #lanes of the
+                                 // vector, this is non-trivial at SelectionDAG
+                                 // level and these types are better to be
+                                 // widened or promoted.
   };
 
   /// LegalizeKind holds the legalization kind that needs to happen to EVT
@@ -172,6 +260,13 @@
                        // or custom.
   };
 
+  /// Enum that specifies when a float negation is beneficial.
+  enum class NegatibleCost {
+    Cheaper = 0,    // Negated expression is cheaper.
+    Neutral = 1,    // Negated expression has the same cost.
+    Expensive = 2   // Negated expression is more expensive.
+  };
+
   class ArgListEntry {
   public:
     Value *Val = nullptr;
@@ -183,23 +278,24 @@
     bool IsSRet : 1;
     bool IsNest : 1;
     bool IsByVal : 1;
+    bool IsByRef : 1;
     bool IsInAlloca : 1;
+    bool IsPreallocated : 1;
     bool IsReturned : 1;
     bool IsSwiftSelf : 1;
     bool IsSwiftError : 1;
-    uint16_t Alignment = 0;
+    bool IsCFGuardTarget : 1;
+    MaybeAlign Alignment = None;
     Type *ByValType = nullptr;
+    Type *PreallocatedType = nullptr;
 
     ArgListEntry()
         : IsSExt(false), IsZExt(false), IsInReg(false), IsSRet(false),
-          IsNest(false), IsByVal(false), IsInAlloca(false), IsReturned(false),
-          IsSwiftSelf(false), IsSwiftError(false) {}
+          IsNest(false), IsByVal(false), IsByRef(false), IsInAlloca(false),
+          IsPreallocated(false), IsReturned(false), IsSwiftSelf(false),
+          IsSwiftError(false), IsCFGuardTarget(false) {}
 
     void setAttributes(const CallBase *Call, unsigned ArgIdx);
-
-    void setAttributes(ImmutableCallSite *CS, unsigned ArgIdx) {
-      return setAttributes(cast<CallBase>(CS->getInstruction()), ArgIdx);
-    }
   };
   using ArgListTy = std::vector<ArgListEntry>;
 
@@ -221,12 +317,16 @@
     llvm_unreachable("Invalid content kind");
   }
 
-  /// NOTE: The TargetMachine owns TLOF.
   explicit TargetLoweringBase(const TargetMachine &TM);
   TargetLoweringBase(const TargetLoweringBase &) = delete;
   TargetLoweringBase &operator=(const TargetLoweringBase &) = delete;
   virtual ~TargetLoweringBase() = default;
 
+  /// Return true if the target support strict float operation
+  bool isStrictFPEnabled() const {
+    return IsStrictFPEnabled;
+  }
+
 protected:
   /// Initialize all of the actions to default values.
   void initActions();
@@ -256,6 +356,12 @@
     return getPointerTy(DL, DL.getAllocaAddrSpace());
   }
 
+  /// Return the type for code pointers, which is determined by the program
+  /// address space specified through the data layout.
+  MVT getProgramPointerTy(const DataLayout &DL) const {
+    return getPointerTy(DL, DL.getProgramAddressSpace());
+  }
+
   /// Return the type for operands of fence.
   /// TODO: Let fence operands be of i32 type and remove this.
   virtual MVT getFenceOperandTy(const DataLayout &DL) const {
@@ -269,6 +375,13 @@
   EVT getShiftAmountTy(EVT LHSTy, const DataLayout &DL,
                        bool LegalTypes = true) const;
 
+  /// Return the preferred type to use for a shift opcode, given the shifted
+  /// amount type is \p ShiftValueTy.
+  LLVM_READONLY
+  virtual LLT getPreferredShiftAmountTy(LLT ShiftValueTy) const {
+    return ShiftValueTy;
+  }
+
   /// Returns the type to be used for the index operand of:
   /// ISD::INSERT_VECTOR_ELT, ISD::EXTRACT_VECTOR_ELT,
   /// ISD::INSERT_SUBVECTOR, and ISD::EXTRACT_SUBVECTOR
@@ -276,6 +389,20 @@
     return getPointerTy(DL);
   }
 
+  /// This callback is used to inspect load/store instructions and add
+  /// target-specific MachineMemOperand flags to them.  The default
+  /// implementation does nothing.
+  virtual MachineMemOperand::Flags getTargetMMOFlags(const Instruction &I) const {
+    return MachineMemOperand::MONone;
+  }
+
+  MachineMemOperand::Flags getLoadMemOperandFlags(const LoadInst &LI,
+                                                  const DataLayout &DL) const;
+  MachineMemOperand::Flags getStoreMemOperandFlags(const StoreInst &SI,
+                                                   const DataLayout &DL) const;
+  MachineMemOperand::Flags getAtomicMemOperandFlags(const Instruction &AI,
+                                                    const DataLayout &DL) const;
+
   virtual bool isSelectSupported(SelectSupportKind /*kind*/) const {
     return true;
   }
@@ -284,7 +411,7 @@
   /// a constant pool load whose address depends on the select condition. The
   /// parameter may be used to differentiate a select with FP compare from
   /// integer compare.
-  virtual bool reduceSelectOfFPConstantLoads(bool IsFPSetCC) const {
+  virtual bool reduceSelectOfFPConstantLoads(EVT CmpOpVT) const {
     return true;
   }
 
@@ -300,7 +427,7 @@
   virtual TargetLoweringBase::LegalizeTypeAction
   getPreferredVectorAction(MVT VT) const {
     // The default action for one element vectors is to scalarize
-    if (VT.getVectorNumElements() == 1)
+    if (VT.getVectorElementCount().isScalar())
       return TypeScalarizeVector;
     // The default action for an odd-width vector is to widen.
     if (!VT.isPow2VectorType())
@@ -309,6 +436,12 @@
     return TypePromoteInteger;
   }
 
+  // Return true if the half type should be passed around as i16, but promoted
+  // to float around arithmetic. The default behavior is to pass around as
+  // float and convert around loads/stores/bitcasts and other places where
+  // the size matters.
+  virtual bool softPromoteHalfType() const { return false; }
+
   // There are two general methods for expanding a BUILD_VECTOR node:
   //  1. Use SCALAR_TO_VECTOR on the defined scalar values and then shuffle
   //     them together.
@@ -391,6 +524,10 @@
     return PredictableSelectIsExpensive;
   }
 
+  virtual bool fallBackToDAGISel(const Instruction &Inst) const {
+    return false;
+  }
+
   /// If a branch or a select condition is skewed in one direction by more than
   /// this factor, it is very likely to be predicted correctly.
   virtual BranchProbability getPredictableBranchThreshold() const;
@@ -468,6 +605,16 @@
     return false;
   }
 
+  /// Return the maximum number of "x & (x - 1)" operations that can be done
+  /// instead of deferring to a custom CTPOP.
+  virtual unsigned getCustomCtpopCost(EVT VT, ISD::CondCode Cond) const {
+    return 1;
+  }
+
+  /// Return true if instruction generated for equality comparison is folded
+  /// with instruction generated for signed comparison.
+  virtual bool isEqualityCmpFoldedWithSignedCmp() const { return true; }
+
   /// Return true if it is safe to transform an integer-domain bitwise operation
   /// into the equivalent floating-point operation. This should be set to true
   /// if the target has IEEE-754-compliant fabs/fneg operations for the input
@@ -539,6 +686,12 @@
     return hasAndNotCompare(X);
   }
 
+  /// Return true if the target has a bit-test instruction:
+  ///   (X & (1 << Y)) ==/!= 0
+  /// This knowledge can be used to prevent breaking the pattern,
+  /// or creating it if it could be recognized.
+  virtual bool hasBitTest(SDValue X, SDValue Y) const { return false; }
+
   /// There are two ways to clear extreme bits (either low or high):
   /// Mask:    x &  (-1 << y)  (the instcombine canonical form)
   /// Shifts:  x >> y << y
@@ -571,6 +724,38 @@
     return false;
   }
 
+  /// Given the pattern
+  ///   (X & (C l>>/<< Y)) ==/!= 0
+  /// return true if it should be transformed into:
+  ///   ((X <</l>> Y) & C) ==/!= 0
+  /// WARNING: if 'X' is a constant, the fold may deadlock!
+  /// FIXME: we could avoid passing XC, but we can't use isConstOrConstSplat()
+  ///        here because it can end up being not linked in.
+  virtual bool shouldProduceAndByConstByHoistingConstFromShiftsLHSOfAnd(
+      SDValue X, ConstantSDNode *XC, ConstantSDNode *CC, SDValue Y,
+      unsigned OldShiftOpcode, unsigned NewShiftOpcode,
+      SelectionDAG &DAG) const {
+    if (hasBitTest(X, Y)) {
+      // One interesting pattern that we'd want to form is 'bit test':
+      //   ((1 << Y) & C) ==/!= 0
+      // But we also need to be careful not to try to reverse that fold.
+
+      // Is this '1 << Y' ?
+      if (OldShiftOpcode == ISD::SHL && CC->isOne())
+        return false; // Keep the 'bit test' pattern.
+
+      // Will it be '1 << Y' after the transform ?
+      if (XC && NewShiftOpcode == ISD::SHL && XC->isOne())
+        return true; // Do form the 'bit test' pattern.
+    }
+
+    // If 'X' is a constant, and we transform, then we will immediately
+    // try to undo the fold, thus causing endless combine loop.
+    // So by default, let's assume everyone prefers the fold
+    // iff 'X' is not a constant.
+    return !XC;
+  }
+
   /// These two forms are equivalent:
   ///   sub %y, (xor %x, -1)
   ///   add (add %x, 1), %y
@@ -798,9 +983,9 @@
     PointerUnion<const Value *, const PseudoSourceValue *> ptrVal;
 
     int          offset = 0;       // offset off of ptrVal
-    unsigned     size = 0;         // the size of the memory location
+    uint64_t     size = 0;         // the size of the memory location
                                    // (taken from memVT if zero)
-    unsigned     align = 1;        // alignment
+    MaybeAlign align = Align(1);   // alignment
 
     MachineMemOperand::Flags flags = MachineMemOperand::MONone;
     IntrinsicInfo() = default;
@@ -884,6 +1069,11 @@
     case ISD::SMULFIX:
     case ISD::SMULFIXSAT:
     case ISD::UMULFIX:
+    case ISD::UMULFIXSAT:
+    case ISD::SDIVFIX:
+    case ISD::SDIVFIXSAT:
+    case ISD::UDIVFIX:
+    case ISD::UDIVFIXSAT:
       Supported = isSupportedFixedPointOperation(Op, VT, Scale);
       break;
     }
@@ -891,52 +1081,31 @@
     return Supported ? Action : Expand;
   }
 
+  // If Op is a strict floating-point operation, return the result
+  // of getOperationAction for the equivalent non-strict operation.
   LegalizeAction getStrictFPOperationAction(unsigned Op, EVT VT) const {
     unsigned EqOpc;
     switch (Op) {
       default: llvm_unreachable("Unexpected FP pseudo-opcode");
-      case ISD::STRICT_FADD: EqOpc = ISD::FADD; break;
-      case ISD::STRICT_FSUB: EqOpc = ISD::FSUB; break;
-      case ISD::STRICT_FMUL: EqOpc = ISD::FMUL; break;
-      case ISD::STRICT_FDIV: EqOpc = ISD::FDIV; break;
-      case ISD::STRICT_FREM: EqOpc = ISD::FREM; break;
-      case ISD::STRICT_FSQRT: EqOpc = ISD::FSQRT; break;
-      case ISD::STRICT_FPOW: EqOpc = ISD::FPOW; break;
-      case ISD::STRICT_FPOWI: EqOpc = ISD::FPOWI; break;
-      case ISD::STRICT_FMA: EqOpc = ISD::FMA; break;
-      case ISD::STRICT_FSIN: EqOpc = ISD::FSIN; break;
-      case ISD::STRICT_FCOS: EqOpc = ISD::FCOS; break;
-      case ISD::STRICT_FEXP: EqOpc = ISD::FEXP; break;
-      case ISD::STRICT_FEXP2: EqOpc = ISD::FEXP2; break;
-      case ISD::STRICT_FLOG: EqOpc = ISD::FLOG; break;
-      case ISD::STRICT_FLOG10: EqOpc = ISD::FLOG10; break;
-      case ISD::STRICT_FLOG2: EqOpc = ISD::FLOG2; break;
-      case ISD::STRICT_FRINT: EqOpc = ISD::FRINT; break;
-      case ISD::STRICT_FNEARBYINT: EqOpc = ISD::FNEARBYINT; break;
-      case ISD::STRICT_FMAXNUM: EqOpc = ISD::FMAXNUM; break;
-      case ISD::STRICT_FMINNUM: EqOpc = ISD::FMINNUM; break;
-      case ISD::STRICT_FCEIL: EqOpc = ISD::FCEIL; break;
-      case ISD::STRICT_FFLOOR: EqOpc = ISD::FFLOOR; break;
-      case ISD::STRICT_FROUND: EqOpc = ISD::FROUND; break;
-      case ISD::STRICT_FTRUNC: EqOpc = ISD::FTRUNC; break;
-      case ISD::STRICT_FP_ROUND: EqOpc = ISD::FP_ROUND; break;
-      case ISD::STRICT_FP_EXTEND: EqOpc = ISD::FP_EXTEND; break;
+#define DAG_INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC, DAGN)               \
+      case ISD::STRICT_##DAGN: EqOpc = ISD::DAGN; break;
+#define CMP_INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC, DAGN)               \
+      case ISD::STRICT_##DAGN: EqOpc = ISD::SETCC; break;
+#include "llvm/IR/ConstrainedOps.def"
     }
 
-    auto Action = getOperationAction(EqOpc, VT);
-
-    // We don't currently handle Custom or Promote for strict FP pseudo-ops.
-    // For now, we just expand for those cases.
-    if (Action != Legal)
-      Action = Expand;
-
-    return Action;
+    return getOperationAction(EqOpc, VT);
   }
 
   /// Return true if the specified operation is legal on this target or can be
   /// made legal with custom lowering. This is used to help guide high-level
-  /// lowering decisions.
-  bool isOperationLegalOrCustom(unsigned Op, EVT VT) const {
+  /// lowering decisions. LegalOnly is an optional convenience for code paths
+  /// traversed pre and post legalisation.
+  bool isOperationLegalOrCustom(unsigned Op, EVT VT,
+                                bool LegalOnly = false) const {
+    if (LegalOnly)
+      return isOperationLegal(Op, VT);
+
     return (VT == MVT::Other || isTypeLegal(VT)) &&
       (getOperationAction(Op, VT) == Legal ||
        getOperationAction(Op, VT) == Custom);
@@ -944,8 +1113,13 @@
 
   /// Return true if the specified operation is legal on this target or can be
   /// made legal using promotion. This is used to help guide high-level lowering
-  /// decisions.
-  bool isOperationLegalOrPromote(unsigned Op, EVT VT) const {
+  /// decisions. LegalOnly is an optional convenience for code paths traversed
+  /// pre and post legalisation.
+  bool isOperationLegalOrPromote(unsigned Op, EVT VT,
+                                 bool LegalOnly = false) const {
+    if (LegalOnly)
+      return isOperationLegal(Op, VT);
+
     return (VT == MVT::Other || isTypeLegal(VT)) &&
       (getOperationAction(Op, VT) == Legal ||
        getOperationAction(Op, VT) == Promote);
@@ -953,8 +1127,13 @@
 
   /// Return true if the specified operation is legal on this target or can be
   /// made legal with custom lowering or using promotion. This is used to help
-  /// guide high-level lowering decisions.
-  bool isOperationLegalOrCustomOrPromote(unsigned Op, EVT VT) const {
+  /// guide high-level lowering decisions. LegalOnly is an optional convenience
+  /// for code paths traversed pre and post legalisation.
+  bool isOperationLegalOrCustomOrPromote(unsigned Op, EVT VT,
+                                         bool LegalOnly = false) const {
+    if (LegalOnly)
+      return isOperationLegal(Op, VT);
+
     return (VT == MVT::Other || isTypeLegal(VT)) &&
       (getOperationAction(Op, VT) == Legal ||
        getOperationAction(Op, VT) == Custom ||
@@ -988,24 +1167,8 @@
   /// Return true if lowering to a jump table is suitable for a set of case
   /// clusters which may contain \p NumCases cases, \p Range range of values.
   virtual bool isSuitableForJumpTable(const SwitchInst *SI, uint64_t NumCases,
-                                      uint64_t Range) const {
-    // FIXME: This function check the maximum table size and density, but the
-    // minimum size is not checked. It would be nice if the minimum size is
-    // also combined within this function. Currently, the minimum size check is
-    // performed in findJumpTable() in SelectionDAGBuiler and
-    // getEstimatedNumberOfCaseClusters() in BasicTTIImpl.
-    const bool OptForSize = SI->getParent()->getParent()->hasOptSize();
-    const unsigned MinDensity = getMinimumJumpTableDensity(OptForSize);
-    const unsigned MaxJumpTableSize = getMaximumJumpTableSize();
-    
-    // Check whether the number of cases is small enough and
-    // the range is dense enough for a jump table.
-    if ((OptForSize || Range <= MaxJumpTableSize) &&
-        (NumCases * 100 >= Range * MinDensity)) {
-      return true;
-    }
-    return false;
-  }
+                                      uint64_t Range, ProfileSummaryInfo *PSI,
+                                      BlockFrequencyInfo *BFI) const;
 
   /// Return true if lowering to a bit test is suitable for a set of case
   /// clusters which contains \p NumDests unique destinations, \p Low and
@@ -1102,12 +1265,8 @@
   /// Return how the indexed load should be treated: either it is legal, needs
   /// to be promoted to a larger size, needs to be expanded to some other code
   /// sequence, or the target has a custom expander for it.
-  LegalizeAction
-  getIndexedLoadAction(unsigned IdxMode, MVT VT) const {
-    assert(IdxMode < ISD::LAST_INDEXED_MODE && VT.isValid() &&
-           "Table isn't big enough!");
-    unsigned Ty = (unsigned)VT.SimpleTy;
-    return (LegalizeAction)((IndexedModeActions[Ty][IdxMode] & 0xf0) >> 4);
+  LegalizeAction getIndexedLoadAction(unsigned IdxMode, MVT VT) const {
+    return getIndexedModeAction(IdxMode, VT, IMAB_Load);
   }
 
   /// Return true if the specified indexed load is legal on this target.
@@ -1120,12 +1279,8 @@
   /// Return how the indexed store should be treated: either it is legal, needs
   /// to be promoted to a larger size, needs to be expanded to some other code
   /// sequence, or the target has a custom expander for it.
-  LegalizeAction
-  getIndexedStoreAction(unsigned IdxMode, MVT VT) const {
-    assert(IdxMode < ISD::LAST_INDEXED_MODE && VT.isValid() &&
-           "Table isn't big enough!");
-    unsigned Ty = (unsigned)VT.SimpleTy;
-    return (LegalizeAction)(IndexedModeActions[Ty][IdxMode] & 0x0f);
+  LegalizeAction getIndexedStoreAction(unsigned IdxMode, MVT VT) const {
+    return getIndexedModeAction(IdxMode, VT, IMAB_Store);
   }
 
   /// Return true if the specified indexed load is legal on this target.
@@ -1135,6 +1290,38 @@
        getIndexedStoreAction(IdxMode, VT.getSimpleVT()) == Custom);
   }
 
+  /// Return how the indexed load should be treated: either it is legal, needs
+  /// to be promoted to a larger size, needs to be expanded to some other code
+  /// sequence, or the target has a custom expander for it.
+  LegalizeAction getIndexedMaskedLoadAction(unsigned IdxMode, MVT VT) const {
+    return getIndexedModeAction(IdxMode, VT, IMAB_MaskedLoad);
+  }
+
+  /// Return true if the specified indexed load is legal on this target.
+  bool isIndexedMaskedLoadLegal(unsigned IdxMode, EVT VT) const {
+    return VT.isSimple() &&
+           (getIndexedMaskedLoadAction(IdxMode, VT.getSimpleVT()) == Legal ||
+            getIndexedMaskedLoadAction(IdxMode, VT.getSimpleVT()) == Custom);
+  }
+
+  /// Return how the indexed store should be treated: either it is legal, needs
+  /// to be promoted to a larger size, needs to be expanded to some other code
+  /// sequence, or the target has a custom expander for it.
+  LegalizeAction getIndexedMaskedStoreAction(unsigned IdxMode, MVT VT) const {
+    return getIndexedModeAction(IdxMode, VT, IMAB_MaskedStore);
+  }
+
+  /// Return true if the specified indexed load is legal on this target.
+  bool isIndexedMaskedStoreLegal(unsigned IdxMode, EVT VT) const {
+    return VT.isSimple() &&
+           (getIndexedMaskedStoreAction(IdxMode, VT.getSimpleVT()) == Legal ||
+            getIndexedMaskedStoreAction(IdxMode, VT.getSimpleVT()) == Custom);
+  }
+
+  // Returns true if VT is a legal index type for masked gathers/scatters
+  // on this target
+  virtual bool shouldRemoveExtendFromGSIndex(EVT VT) const { return false; }
+
   /// Return how the condition code should be treated: either it is legal, needs
   /// to be expanded to some other code sequence, or the target has a custom
   /// expander for it.
@@ -1206,7 +1393,7 @@
         EltTy = PointerTy.getTypeForEVT(Ty->getContext());
       }
       return EVT::getVectorVT(Ty->getContext(), EVT::getEVT(EltTy, false),
-                              VTy->getNumElements());
+                              VTy->getElementCount());
     }
 
     return EVT::getEVT(Ty, AllowUnknown);
@@ -1224,7 +1411,7 @@
         Elm = PointerTy.getTypeForEVT(Ty->getContext());
       }
       return EVT::getVectorVT(Ty->getContext(), EVT::getEVT(Elm, false),
-                       VTy->getNumElements());
+                              VTy->getElementCount());
     }
 
     return getValueType(DL, Ty, AllowUnknown);
@@ -1316,9 +1503,9 @@
 
   /// Certain targets have context senstive alignment requirements, where one
   /// type has the alignment requirement of another type.
-  virtual unsigned getABIAlignmentForCallingConv(Type *ArgTy,
-                                                 DataLayout DL) const {
-    return DL.getABITypeAlignment(ArgTy);
+  virtual Align getABIAlignmentForCallingConv(Type *ArgTy,
+                                              DataLayout DL) const {
+    return DL.getABITypeAlign(ArgTy);
   }
 
   /// If true, then instruction selection should seek to shrink the FP constant
@@ -1426,13 +1613,40 @@
     return false;
   }
 
+  /// LLT handling variant.
+  virtual bool allowsMisalignedMemoryAccesses(
+      LLT, unsigned AddrSpace = 0, Align Alignment = Align(1),
+      MachineMemOperand::Flags Flags = MachineMemOperand::MONone,
+      bool * /*Fast*/ = nullptr) const {
+    return false;
+  }
+
+  /// This function returns true if the memory access is aligned or if the
+  /// target allows this specific unaligned memory access. If the access is
+  /// allowed, the optional final parameter returns if the access is also fast
+  /// (as defined by the target).
+  bool allowsMemoryAccessForAlignment(
+      LLVMContext &Context, const DataLayout &DL, EVT VT,
+      unsigned AddrSpace = 0, Align Alignment = Align(1),
+      MachineMemOperand::Flags Flags = MachineMemOperand::MONone,
+      bool *Fast = nullptr) const;
+
+  /// Return true if the memory access of this type is aligned or if the target
+  /// allows this specific unaligned access for the given MachineMemOperand.
+  /// If the access is allowed, the optional final parameter returns if the
+  /// access is also fast (as defined by the target).
+  bool allowsMemoryAccessForAlignment(LLVMContext &Context,
+                                      const DataLayout &DL, EVT VT,
+                                      const MachineMemOperand &MMO,
+                                      bool *Fast = nullptr) const;
+
   /// Return true if the target supports a memory access of this type for the
   /// given address space and alignment. If the access is allowed, the optional
   /// final parameter returns if the access is also fast (as defined by the
   /// target).
-  bool
+  virtual bool
   allowsMemoryAccess(LLVMContext &Context, const DataLayout &DL, EVT VT,
-                     unsigned AddrSpace = 0, unsigned Alignment = 1,
+                     unsigned AddrSpace = 0, Align Alignment = Align(1),
                      MachineMemOperand::Flags Flags = MachineMemOperand::MONone,
                      bool *Fast = nullptr) const;
 
@@ -1446,23 +1660,21 @@
 
   /// Returns the target specific optimal type for load and store operations as
   /// a result of memset, memcpy, and memmove lowering.
-  ///
-  /// If DstAlign is zero that means it's safe to destination alignment can
-  /// satisfy any constraint. Similarly if SrcAlign is zero it means there isn't
-  /// a need to check it against alignment requirement, probably because the
-  /// source does not need to be loaded. If 'IsMemset' is true, that means it's
-  /// expanding a memset. If 'ZeroMemset' is true, that means it's a memset of
-  /// zero. 'MemcpyStrSrc' indicates whether the memcpy source is constant so it
-  /// does not need to be loaded.  It returns EVT::Other if the type should be
-  /// determined using generic target-independent logic.
+  /// It returns EVT::Other if the type should be determined using generic
+  /// target-independent logic.
   virtual EVT
-  getOptimalMemOpType(uint64_t /*Size*/, unsigned /*DstAlign*/,
-                      unsigned /*SrcAlign*/, bool /*IsMemset*/,
-                      bool /*ZeroMemset*/, bool /*MemcpyStrSrc*/,
+  getOptimalMemOpType(const MemOp &Op,
                       const AttributeList & /*FuncAttributes*/) const {
     return MVT::Other;
   }
 
+  /// LLT returning variant.
+  virtual LLT
+  getOptimalMemOpLLT(const MemOp &Op,
+                     const AttributeList & /*FuncAttributes*/) const {
+    return LLT();
+  }
+
   /// Returns true if it's safe to use load / store of the specified type to
   /// expand memcpy / memset inline.
   ///
@@ -1472,16 +1684,6 @@
   /// have to be legal as the hook is used before type legalization.
   virtual bool isSafeMemOpType(MVT /*VT*/) const { return true; }
 
-  /// Determine if we should use _setjmp or setjmp to implement llvm.setjmp.
-  bool usesUnderscoreSetJmp() const {
-    return UseUnderscoreSetJmp;
-  }
-
-  /// Determine if we should use _longjmp or longjmp to implement llvm.longjmp.
-  bool usesUnderscoreLongJmp() const {
-    return UseUnderscoreLongJmp;
-  }
-
   /// Return lower limit for number of blocks in a jump table.
   virtual unsigned getMinimumJumpTableEntries() const;
 
@@ -1492,65 +1694,45 @@
   /// Zero if no limit.
   unsigned getMaximumJumpTableSize() const;
 
-  virtual bool isJumpTableRelative() const {
-    return TM.isPositionIndependent();
-  }
+  virtual bool isJumpTableRelative() const;
 
   /// If a physical register, this specifies the register that
   /// llvm.savestack/llvm.restorestack should save and restore.
-  unsigned getStackPointerRegisterToSaveRestore() const {
+  Register getStackPointerRegisterToSaveRestore() const {
     return StackPointerRegisterToSaveRestore;
   }
 
   /// If a physical register, this returns the register that receives the
   /// exception address on entry to an EH pad.
-  virtual unsigned
+  virtual Register
   getExceptionPointerRegister(const Constant *PersonalityFn) const {
-    // 0 is guaranteed to be the NoRegister value on all targets
-    return 0;
+    return Register();
   }
 
   /// If a physical register, this returns the register that receives the
   /// exception typeid on entry to a landing pad.
-  virtual unsigned
+  virtual Register
   getExceptionSelectorRegister(const Constant *PersonalityFn) const {
-    // 0 is guaranteed to be the NoRegister value on all targets
-    return 0;
+    return Register();
   }
 
   virtual bool needsFixedCatchObjects() const {
     report_fatal_error("Funclet EH is not implemented for this target");
   }
 
-  /// Returns the target's jmp_buf size in bytes (if never set, the default is
-  /// 200)
-  unsigned getJumpBufSize() const {
-    return JumpBufSize;
-  }
-
-  /// Returns the target's jmp_buf alignment in bytes (if never set, the default
-  /// is 0)
-  unsigned getJumpBufAlignment() const {
-    return JumpBufAlignment;
-  }
-
   /// Return the minimum stack alignment of an argument.
-  unsigned getMinStackArgumentAlignment() const {
+  Align getMinStackArgumentAlignment() const {
     return MinStackArgumentAlignment;
   }
 
   /// Return the minimum function alignment.
-  unsigned getMinFunctionAlignment() const {
-    return MinFunctionAlignment;
-  }
+  Align getMinFunctionAlignment() const { return MinFunctionAlignment; }
 
   /// Return the preferred function alignment.
-  unsigned getPrefFunctionAlignment() const {
-    return PrefFunctionAlignment;
-  }
+  Align getPrefFunctionAlignment() const { return PrefFunctionAlignment; }
 
   /// Return the preferred loop alignment.
-  virtual unsigned getPrefLoopAlignment(MachineLoop *ML = nullptr) const {
+  virtual Align getPrefLoopAlignment(MachineLoop *ML = nullptr) const {
     return PrefLoopAlignment;
   }
 
@@ -1597,21 +1779,18 @@
 
   /// Returns the name of the symbol used to emit stack probes or the empty
   /// string if not applicable.
+  virtual bool hasStackProbeSymbol(MachineFunction &MF) const { return false; }
+
+  virtual bool hasInlineStackProbe(MachineFunction &MF) const { return false; }
+
   virtual StringRef getStackProbeSymbolName(MachineFunction &MF) const {
     return "";
   }
 
-  /// Returns true if a cast between SrcAS and DestAS is a noop.
-  virtual bool isNoopAddrSpaceCast(unsigned SrcAS, unsigned DestAS) const {
-    return false;
-  }
-
   /// Returns true if a cast from SrcAS to DestAS is "cheap", such that e.g. we
   /// are happy to sink it into basic blocks. A cast may be free, but not
   /// necessarily a no-op. e.g. a free truncate from a 64-bit to 32-bit pointer.
-  virtual bool isFreeAddrSpaceCast(unsigned SrcAS, unsigned DestAS) const {
-    return isNoopAddrSpaceCast(SrcAS, DestAS);
-  }
+  virtual bool isFreeAddrSpaceCast(unsigned SrcAS, unsigned DestAS) const;
 
   /// Return true if the pointer arguments to CI should be aligned by aligning
   /// the object whose address is being passed. If so then MinSize is set to the
@@ -1772,6 +1951,11 @@
     return IsSigned;
   }
 
+  /// Returns true if arguments should be extended in lib calls.
+  virtual bool shouldExtendTypeInLibCall(EVT Type) const {
+    return true;
+  }
+
   /// Returns how the given (atomic) load should be expanded by the
   /// IR-level AtomicExpand pass.
   virtual AtomicExpansionKind shouldExpandAtomicLoadInIR(LoadInst *LI) const {
@@ -1814,6 +1998,18 @@
     return ISD::ZERO_EXTEND;
   }
 
+  /// Returns how the platform's atomic compare and swap expects its comparison
+  /// value to be extended (ZERO_EXTEND, SIGN_EXTEND, or ANY_EXTEND). This is
+  /// separate from getExtendForAtomicOps, which is concerned with the
+  /// sign-extension of the instruction's output, whereas here we are concerned
+  /// with the sign-extension of the input. For targets with compare-and-swap
+  /// instructions (or sub-word comparisons in their LL/SC loop expansions),
+  /// the input can be ANY_EXTEND, but the output will still have a specific
+  /// extension.
+  virtual ISD::NodeType getExtendForAtomicCmpSwapArg() const {
+    return ISD::ANY_EXTEND;
+  }
+
   /// @}
 
   /// Returns true if we should normalize
@@ -1848,7 +2044,8 @@
   /// This may be true if the target does not directly support the
   /// multiplication operation for the specified type or the sequence of simpler
   /// ops is faster than the multiply.
-  virtual bool decomposeMulByConstant(EVT VT, SDValue C) const {
+  virtual bool decomposeMulByConstant(LLVMContext &Context,
+                                      EVT VT, SDValue C) const {
     return false;
   }
 
@@ -1892,18 +2089,6 @@
     SchedPreferenceInfo = Pref;
   }
 
-  /// Indicate whether this target prefers to use _setjmp to implement
-  /// llvm.setjmp or the version without _.  Defaults to false.
-  void setUseUnderscoreSetJmp(bool Val) {
-    UseUnderscoreSetJmp = Val;
-  }
-
-  /// Indicate whether this target prefers to use _longjmp to implement
-  /// llvm.longjmp or the version without _.  Defaults to false.
-  void setUseUnderscoreLongJmp(bool Val) {
-    UseUnderscoreLongJmp = Val;
-  }
-
   /// Indicate the minimum number of blocks to generate jump tables.
   void setMinimumJumpTableEntries(unsigned Val);
 
@@ -1913,7 +2098,7 @@
 
   /// If set to a physical register, this specifies the register that
   /// llvm.savestack/llvm.restorestack should save and restore.
-  void setStackPointerRegisterToSaveRestore(unsigned R) {
+  void setStackPointerRegisterToSaveRestore(Register R) {
     StackPointerRegisterToSaveRestore = R;
   }
 
@@ -1995,13 +2180,8 @@
   ///
   /// NOTE: All indexed mode loads are initialized to Expand in
   /// TargetLowering.cpp
-  void setIndexedLoadAction(unsigned IdxMode, MVT VT,
-                            LegalizeAction Action) {
-    assert(VT.isValid() && IdxMode < ISD::LAST_INDEXED_MODE &&
-           (unsigned)Action < 0xf && "Table isn't big enough!");
-    // Load action are kept in the upper half.
-    IndexedModeActions[(unsigned)VT.SimpleTy][IdxMode] &= ~0xf0;
-    IndexedModeActions[(unsigned)VT.SimpleTy][IdxMode] |= ((uint8_t)Action) <<4;
+  void setIndexedLoadAction(unsigned IdxMode, MVT VT, LegalizeAction Action) {
+    setIndexedModeAction(IdxMode, VT, IMAB_Load, Action);
   }
 
   /// Indicate that the specified indexed store does or does not work with the
@@ -2009,13 +2189,28 @@
   ///
   /// NOTE: All indexed mode stores are initialized to Expand in
   /// TargetLowering.cpp
-  void setIndexedStoreAction(unsigned IdxMode, MVT VT,
-                             LegalizeAction Action) {
-    assert(VT.isValid() && IdxMode < ISD::LAST_INDEXED_MODE &&
-           (unsigned)Action < 0xf && "Table isn't big enough!");
-    // Store action are kept in the lower half.
-    IndexedModeActions[(unsigned)VT.SimpleTy][IdxMode] &= ~0x0f;
-    IndexedModeActions[(unsigned)VT.SimpleTy][IdxMode] |= ((uint8_t)Action);
+  void setIndexedStoreAction(unsigned IdxMode, MVT VT, LegalizeAction Action) {
+    setIndexedModeAction(IdxMode, VT, IMAB_Store, Action);
+  }
+
+  /// Indicate that the specified indexed masked load does or does not work with
+  /// the specified type and indicate what to do about it.
+  ///
+  /// NOTE: All indexed mode masked loads are initialized to Expand in
+  /// TargetLowering.cpp
+  void setIndexedMaskedLoadAction(unsigned IdxMode, MVT VT,
+                                  LegalizeAction Action) {
+    setIndexedModeAction(IdxMode, VT, IMAB_MaskedLoad, Action);
+  }
+
+  /// Indicate that the specified indexed masked store does or does not work
+  /// with the specified type and indicate what to do about it.
+  ///
+  /// NOTE: All indexed mode masked stores are initialized to Expand in
+  /// TargetLowering.cpp
+  void setIndexedMaskedStoreAction(unsigned IdxMode, MVT VT,
+                                   LegalizeAction Action) {
+    setIndexedModeAction(IdxMode, VT, IMAB_MaskedStore, Action);
   }
 
   /// Indicate that the specified condition code is or isn't supported on the
@@ -2056,40 +2251,25 @@
     TargetDAGCombineArray[NT >> 3] |= 1 << (NT&7);
   }
 
-  /// Set the target's required jmp_buf buffer size (in bytes); default is 200
-  void setJumpBufSize(unsigned Size) {
-    JumpBufSize = Size;
-  }
-
-  /// Set the target's required jmp_buf buffer alignment (in bytes); default is
-  /// 0
-  void setJumpBufAlignment(unsigned Align) {
-    JumpBufAlignment = Align;
-  }
-
-  /// Set the target's minimum function alignment (in log2(bytes))
-  void setMinFunctionAlignment(unsigned Align) {
-    MinFunctionAlignment = Align;
+  /// Set the target's minimum function alignment.
+  void setMinFunctionAlignment(Align Alignment) {
+    MinFunctionAlignment = Alignment;
   }
 
   /// Set the target's preferred function alignment.  This should be set if
-  /// there is a performance benefit to higher-than-minimum alignment (in
-  /// log2(bytes))
-  void setPrefFunctionAlignment(unsigned Align) {
-    PrefFunctionAlignment = Align;
+  /// there is a performance benefit to higher-than-minimum alignment
+  void setPrefFunctionAlignment(Align Alignment) {
+    PrefFunctionAlignment = Alignment;
   }
 
-  /// Set the target's preferred loop alignment. Default alignment is zero, it
-  /// means the target does not care about loop alignment.  The alignment is
-  /// specified in log2(bytes). The target may also override
-  /// getPrefLoopAlignment to provide per-loop values.
-  void setPrefLoopAlignment(unsigned Align) {
-    PrefLoopAlignment = Align;
-  }
+  /// Set the target's preferred loop alignment. Default alignment is one, it
+  /// means the target does not care about loop alignment. The target may also
+  /// override getPrefLoopAlignment to provide per-loop values.
+  void setPrefLoopAlignment(Align Alignment) { PrefLoopAlignment = Alignment; }
 
-  /// Set the minimum stack alignment of an argument (in log2(bytes)).
-  void setMinStackArgumentAlignment(unsigned Align) {
-    MinStackArgumentAlignment = Align;
+  /// Set the minimum stack alignment of an argument.
+  void setMinStackArgumentAlignment(Align Alignment) {
+    MinStackArgumentAlignment = Alignment;
   }
 
   /// Set the maximum atomic operation size supported by the
@@ -2193,13 +2373,31 @@
   }
 
   /// Return true if it's significantly cheaper to shift a vector by a uniform
-  /// scalar than by an amount which will vary across each lane. On x86, for
-  /// example, there is a "psllw" instruction for the former case, but no simple
-  /// instruction for a general "a << b" operation on vectors.
+  /// scalar than by an amount which will vary across each lane. On x86 before
+  /// AVX2 for example, there is a "psllw" instruction for the former case, but
+  /// no simple instruction for a general "a << b" operation on vectors.
+  /// This should also apply to lowering for vector funnel shifts (rotates).
   virtual bool isVectorShiftByScalarCheap(Type *Ty) const {
     return false;
   }
 
+  /// Given a shuffle vector SVI representing a vector splat, return a new
+  /// scalar type of size equal to SVI's scalar type if the new type is more
+  /// profitable. Returns nullptr otherwise. For example under MVE float splats
+  /// are converted to integer to prevent the need to move from SPR to GPR
+  /// registers.
+  virtual Type* shouldConvertSplatType(ShuffleVectorInst* SVI) const {
+    return nullptr;
+  }
+
+  /// Given a set in interconnected phis of type 'From' that are loaded/stored
+  /// or bitcast to type 'To', return true if the set should be converted to
+  /// 'To'.
+  virtual bool shouldConvertPhiType(Type *From, Type *To) const {
+    return (From->isIntegerTy() || From->isFloatingPointTy()) &&
+           (To->isIntegerTy() || To->isFloatingPointTy());
+  }
+
   /// Returns true if the opcode is a commutative binary operation.
   virtual bool isCommutativeBinOp(unsigned Opcode) const {
     // FIXME: This should get its info from the td file.
@@ -2396,7 +2594,7 @@
   /// this information should not be provided because it will generate more
   /// loads.
   virtual bool hasPairedLoad(EVT /*LoadedType*/,
-                             unsigned & /*RequiredAlignment*/) const {
+                             Align & /*RequiredAlignment*/) const {
     return false;
   }
 
@@ -2451,7 +2649,8 @@
   /// Return true if an fpext operation input to an \p Opcode operation is free
   /// (for instance, because half-precision floating-point numbers are
   /// implicitly extended to float-precision) for an FMA instruction.
-  virtual bool isFPExtFoldable(unsigned Opcode, EVT DestVT, EVT SrcVT) const {
+  virtual bool isFPExtFoldable(const SelectionDAG &DAG, unsigned Opcode,
+                               EVT DestVT, EVT SrcVT) const {
     assert(DestVT.isFloatingPoint() && SrcVT.isFloatingPoint() &&
            "invalid fpext types");
     return isFPExtFree(DestVT, SrcVT);
@@ -2483,10 +2682,26 @@
   /// not legal, but should return true if those types will eventually legalize
   /// to types that support FMAs. After legalization, it will only be called on
   /// types that support FMAs (via Legal or Custom actions)
-  virtual bool isFMAFasterThanFMulAndFAdd(EVT) const {
+  virtual bool isFMAFasterThanFMulAndFAdd(const MachineFunction &MF,
+                                          EVT) const {
     return false;
   }
 
+  /// IR version
+  virtual bool isFMAFasterThanFMulAndFAdd(const Function &F, Type *) const {
+    return false;
+  }
+
+  /// Returns true if be combined with to form an ISD::FMAD. \p N may be an
+  /// ISD::FADD, ISD::FSUB, or an ISD::FMUL which will be distributed into an
+  /// fadd/fsub.
+  virtual bool isFMADLegal(const SelectionDAG &DAG, const SDNode *N) const {
+    assert((N->getOpcode() == ISD::FADD || N->getOpcode() == ISD::FSUB ||
+            N->getOpcode() == ISD::FMUL) &&
+           "unexpected node in FMAD forming combine");
+    return isOperationLegal(ISD::FMAD, N->getValueType(0));
+  }
+
   /// Return true if it's profitable to narrow operations of type VT1 to
   /// VT2. e.g. on x86, it's profitable to narrow from i32 to i8 but not from
   /// i32 to i16.
@@ -2531,17 +2746,21 @@
   /// node operation. Targets may want to override this independently of whether
   /// the operation is legal/custom for the given type because it may obscure
   /// matching of other patterns.
-  virtual bool shouldFormOverflowOp(unsigned Opcode, EVT VT) const {
+  virtual bool shouldFormOverflowOp(unsigned Opcode, EVT VT,
+                                    bool MathUsed) const {
     // TODO: The default logic is inherited from code in CodeGenPrepare.
     // The opcode should not make a difference by default?
     if (Opcode != ISD::UADDO)
       return false;
 
     // Allow the transform as long as we have an integer type that is not
-    // obviously illegal and unsupported.
+    // obviously illegal and unsupported and if the math result is used
+    // besides the overflow check. On some targets (e.g. SPARC), it is
+    // not profitable to form on overflow op if the math result has no
+    // concrete users.
     if (VT.isVector())
       return false;
-    return VT.isSimple() || !isOperationExpand(Opcode, VT);
+    return MathUsed && (VT.isSimple() || !isOperationExpand(Opcode, VT));
   }
 
   // Return true if it is profitable to use a scalar input to a BUILD_VECTOR
@@ -2555,6 +2774,12 @@
   // same blocks of its users.
   virtual bool shouldConsiderGEPOffsetSplit() const { return false; }
 
+  /// Return true if creating a shift of the type by the given
+  /// amount is not profitable.
+  virtual bool shouldAvoidTransformToShift(EVT VT, unsigned Amount) const {
+    return false;
+  }
+
   //===--------------------------------------------------------------------===//
   // Runtime Library hooks
   //
@@ -2597,6 +2822,13 @@
   /// The default implementation just freezes the set of reserved registers.
   virtual void finalizeLowering(MachineFunction &MF) const;
 
+  //===----------------------------------------------------------------------===//
+  //  GlobalISel Hooks
+  //===----------------------------------------------------------------------===//
+  /// Check whether or not \p MI needs to be moved close to its uses.
+  virtual bool shouldLocalize(const MachineInstr &MI, const TargetTransformInfo *TTI) const;
+
+
 private:
   const TargetMachine &TM;
 
@@ -2624,16 +2856,6 @@
   /// predication.
   bool JumpIsExpensive;
 
-  /// This target prefers to use _setjmp to implement llvm.setjmp.
-  ///
-  /// Defaults to false.
-  bool UseUnderscoreSetJmp;
-
-  /// This target prefers to use _longjmp to implement llvm.longjmp.
-  ///
-  /// Defaults to false.
-  bool UseUnderscoreLongJmp;
-
   /// Information about the contents of the high-bits in boolean values held in
   /// a type wider than i1. See getBooleanContents.
   BooleanContent BooleanContents;
@@ -2650,25 +2872,19 @@
   /// register usage.
   Sched::Preference SchedPreferenceInfo;
 
-  /// The size, in bytes, of the target's jmp_buf buffers
-  unsigned JumpBufSize;
-
-  /// The alignment, in bytes, of the target's jmp_buf buffers
-  unsigned JumpBufAlignment;
-
   /// The minimum alignment that any argument on the stack needs to have.
-  unsigned MinStackArgumentAlignment;
+  Align MinStackArgumentAlignment;
 
   /// The minimum function alignment (used when optimizing for size, and to
   /// prevent explicitly provided alignment from leading to incorrect code).
-  unsigned MinFunctionAlignment;
+  Align MinFunctionAlignment;
 
   /// The preferred function alignment (used when alignment unspecified and
   /// optimizing for speed).
-  unsigned PrefFunctionAlignment;
+  Align PrefFunctionAlignment;
 
-  /// The preferred loop alignment.
-  unsigned PrefLoopAlignment;
+  /// The preferred loop alignment (in log2 bot in bytes).
+  Align PrefLoopAlignment;
 
   /// Size in bits of the maximum atomics size the backend supports.
   /// Accesses larger than this will be expanded by AtomicExpandPass.
@@ -2683,12 +2899,12 @@
 
   /// If set to a physical register, this specifies the register that
   /// llvm.savestack/llvm.restorestack should save and restore.
-  unsigned StackPointerRegisterToSaveRestore;
+  Register StackPointerRegisterToSaveRestore;
 
   /// This indicates the default register class to use for each ValueType the
   /// target supports natively.
   const TargetRegisterClass *RegClassForVT[MVT::LAST_VALUETYPE];
-  unsigned char NumRegistersForVT[MVT::LAST_VALUETYPE];
+  uint16_t NumRegistersForVT[MVT::LAST_VALUETYPE];
   MVT RegisterTypeForVT[MVT::LAST_VALUETYPE];
 
   /// This indicates the "representative" register class to use for each
@@ -2728,13 +2944,13 @@
   /// truncating store of a specific value type and truncating type is legal.
   LegalizeAction TruncStoreActions[MVT::LAST_VALUETYPE][MVT::LAST_VALUETYPE];
 
-  /// For each indexed mode and each value type, keep a pair of LegalizeAction
+  /// For each indexed mode and each value type, keep a quad of LegalizeAction
   /// that indicates how instruction selection should deal with the load /
-  /// store.
+  /// store / maskedload / maskedstore.
   ///
   /// The first dimension is the value_type for the reference. The second
   /// dimension represents the various modes for load store.
-  uint8_t IndexedModeActions[MVT::LAST_VALUETYPE][ISD::LAST_INDEXED_MODE];
+  uint16_t IndexedModeActions[MVT::LAST_VALUETYPE][ISD::LAST_INDEXED_MODE];
 
   /// For each condition code (ISD::CondCode) keep a LegalizeAction that
   /// indicates how instruction selection should deal with the condition code.
@@ -2744,7 +2960,6 @@
   /// up the MVT::LAST_VALUETYPE value to the next multiple of 8.
   uint32_t CondCodeActions[ISD::SETCC_INVALID][(MVT::LAST_VALUETYPE + 7) / 8];
 
-protected:
   ValueTypeActionImpl ValueTypeActions;
 
 private:
@@ -2778,6 +2993,32 @@
   /// Set default libcall names and calling conventions.
   void InitLibcalls(const Triple &TT);
 
+  /// The bits of IndexedModeActions used to store the legalisation actions
+  /// We store the data as   | ML | MS |  L |  S | each taking 4 bits.
+  enum IndexedModeActionsBits {
+    IMAB_Store = 0,
+    IMAB_Load = 4,
+    IMAB_MaskedStore = 8,
+    IMAB_MaskedLoad = 12
+  };
+
+  void setIndexedModeAction(unsigned IdxMode, MVT VT, unsigned Shift,
+                            LegalizeAction Action) {
+    assert(VT.isValid() && IdxMode < ISD::LAST_INDEXED_MODE &&
+           (unsigned)Action < 0xf && "Table isn't big enough!");
+    unsigned Ty = (unsigned)VT.SimpleTy;
+    IndexedModeActions[Ty][IdxMode] &= ~(0xf << Shift);
+    IndexedModeActions[Ty][IdxMode] |= ((uint16_t)Action) << Shift;
+  }
+
+  LegalizeAction getIndexedModeAction(unsigned IdxMode, MVT VT,
+                                      unsigned Shift) const {
+    assert(IdxMode < ISD::LAST_INDEXED_MODE && VT.isValid() &&
+           "Table isn't big enough!");
+    unsigned Ty = (unsigned)VT.SimpleTy;
+    return (LegalizeAction)((IndexedModeActions[Ty][IdxMode] >> Shift) & 0xf);
+  }
+
 protected:
   /// Return true if the extension represented by \p I is free.
   /// \pre \p I is a sign, zero, or fp extension and
@@ -2790,7 +3031,7 @@
   /// expected to be merged.
   unsigned GatherAllAliasesMaxDepth;
 
-  /// Specify maximum number of store instructions per memset call.
+  /// \brief Specify maximum number of store instructions per memset call.
   ///
   /// When lowering \@llvm.memset this field specifies the maximum number of
   /// store operations that may be substituted for the call to memset. Targets
@@ -2801,12 +3042,10 @@
   /// with 16-bit alignment would result in four 2-byte stores and one 1-byte
   /// store.  This only applies to setting a constant array of a constant size.
   unsigned MaxStoresPerMemset;
-
-  /// Maximum number of stores operations that may be substituted for the call
-  /// to memset, used for functions with OptSize attribute.
+  /// Likewise for functions with the OptSize attribute.
   unsigned MaxStoresPerMemsetOptSize;
 
-  /// Specify maximum bytes of store instructions per memcpy call.
+  /// \brief Specify maximum number of store instructions per memcpy call.
   ///
   /// When lowering \@llvm.memcpy this field specifies the maximum number of
   /// store operations that may be substituted for a call to memcpy. Targets
@@ -2818,8 +3057,8 @@
   /// and one 1-byte store. This only applies to copying a constant array of
   /// constant size.
   unsigned MaxStoresPerMemcpy;
-
-
+  /// Likewise for functions with the OptSize attribute.
+  unsigned MaxStoresPerMemcpyOptSize;
   /// \brief Specify max number of store instructions to glue in inlined memcpy.
   ///
   /// When memcpy is inlined based on MaxStoresPerMemcpy, specify maximum number
@@ -2827,13 +3066,22 @@
   //  vectorization later on.
   unsigned MaxGluedStoresPerMemcpy = 0;
 
-  /// Maximum number of store operations that may be substituted for a call to
-  /// memcpy, used for functions with OptSize attribute.
-  unsigned MaxStoresPerMemcpyOptSize;
+  /// \brief Specify maximum number of load instructions per memcmp call.
+  ///
+  /// When lowering \@llvm.memcmp this field specifies the maximum number of
+  /// pairs of load operations that may be substituted for a call to memcmp.
+  /// Targets must set this value based on the cost threshold for that target.
+  /// Targets should assume that the memcmp will be done using as many of the
+  /// largest load operations first, followed by smaller ones, if necessary, per
+  /// alignment restrictions. For example, loading 7 bytes on a 32-bit machine
+  /// with 32-bit alignment would result in one 4-byte load, a one 2-byte load
+  /// and one 1-byte load. This only applies to copying a constant array of
+  /// constant size.
   unsigned MaxLoadsPerMemcmp;
+  /// Likewise for functions with the OptSize attribute.
   unsigned MaxLoadsPerMemcmpOptSize;
 
-  /// Specify maximum bytes of store instructions per memmove call.
+  /// \brief Specify maximum number of store instructions per memmove call.
   ///
   /// When lowering \@llvm.memmove this field specifies the maximum number of
   /// store instructions that may be substituted for a call to memmove. Targets
@@ -2844,9 +3092,7 @@
   /// with 8-bit alignment would result in nine 1-byte stores.  This only
   /// applies to copying a constant array of constant size.
   unsigned MaxStoresPerMemmove;
-
-  /// Maximum number of store instructions that may be substituted for a call to
-  /// memmove, used for functions with OptSize attribute.
+  /// Likewise for functions with the OptSize attribute.
   unsigned MaxStoresPerMemmoveOptSize;
 
   /// Tells the code generator that select is more expensive than a branch if
@@ -2875,6 +3121,8 @@
   /// details.
   MachineBasicBlock *emitXRayTypedEvent(MachineInstr &MI,
                                         MachineBasicBlock *MBB) const;
+
+  bool IsStrictFPEnabled;
 };
 
 /// This class defines information used to lower LLVM code to legal SelectionDAG
@@ -2885,11 +3133,11 @@
 class TargetLowering : public TargetLoweringBase {
 public:
   struct DAGCombinerInfo;
+  struct MakeLibCallOptions;
 
   TargetLowering(const TargetLowering &) = delete;
   TargetLowering &operator=(const TargetLowering &) = delete;
 
-  /// NOTE: The TargetMachine owns TLOF.
   explicit TargetLowering(const TargetMachine &TM);
 
   bool isPositionIndependent() const;
@@ -2925,6 +3173,14 @@
     return false;
   }
 
+  /// Returns true if the specified base+offset is a legal indexed addressing
+  /// mode for this target. \p MI is the load or store instruction that is being
+  /// considered for transformation.
+  virtual bool isIndexingLegal(MachineInstr &MI, Register Base, Register Offset,
+                               bool IsPre, MachineRegisterInfo &MRI) const {
+    return false;
+  }
+
   /// Return the entry encoding for a jump table in the current function.  The
   /// returned value is a member of the MachineJumpTableInfo::JTEntryKind enum.
   virtual unsigned getJumpTableEncoding() const;
@@ -2955,14 +3211,22 @@
 
   void softenSetCCOperands(SelectionDAG &DAG, EVT VT, SDValue &NewLHS,
                            SDValue &NewRHS, ISD::CondCode &CCCode,
-                           const SDLoc &DL) const;
+                           const SDLoc &DL, const SDValue OldLHS,
+                           const SDValue OldRHS) const;
+
+  void softenSetCCOperands(SelectionDAG &DAG, EVT VT, SDValue &NewLHS,
+                           SDValue &NewRHS, ISD::CondCode &CCCode,
+                           const SDLoc &DL, const SDValue OldLHS,
+                           const SDValue OldRHS, SDValue &Chain,
+                           bool IsSignaling = false) const;
 
   /// Returns a pair of (return value, chain).
   /// It is an error to pass RTLIB::UNKNOWN_LIBCALL as \p LC.
-  std::pair<SDValue, SDValue> makeLibCall(
-      SelectionDAG &DAG, RTLIB::Libcall LC, EVT RetVT, ArrayRef<SDValue> Ops,
-      bool isSigned, const SDLoc &dl, bool doesNotReturn = false,
-      bool isReturnValueUsed = true, bool isPostTypeLegalization = false) const;
+  std::pair<SDValue, SDValue> makeLibCall(SelectionDAG &DAG, RTLIB::Libcall LC,
+                                          EVT RetVT, ArrayRef<SDValue> Ops,
+                                          MakeLibCallOptions CallOptions,
+                                          const SDLoc &dl,
+                                          SDValue Chain = SDValue()) const;
 
   /// Check whether parameters to a call that are passed in callee saved
   /// registers are the same as from the calling function.  This needs to be
@@ -3004,27 +3268,28 @@
   /// Return true if the number of memory ops is below the threshold (Limit).
   /// It returns the types of the sequence of memory ops to perform
   /// memset / memcpy by reference.
-  bool findOptimalMemOpLowering(std::vector<EVT> &MemOps,
-                                unsigned Limit, uint64_t Size,
-                                unsigned DstAlign, unsigned SrcAlign,
-                                bool IsMemset,
-                                bool ZeroMemset,
-                                bool MemcpyStrSrc,
-                                bool AllowOverlap,
-                                unsigned DstAS, unsigned SrcAS,
+  bool findOptimalMemOpLowering(std::vector<EVT> &MemOps, unsigned Limit,
+                                const MemOp &Op, unsigned DstAS, unsigned SrcAS,
                                 const AttributeList &FuncAttributes) const;
 
   /// Check to see if the specified operand of the specified instruction is a
   /// constant integer.  If so, check to see if there are any bits set in the
   /// constant that are not demanded.  If so, shrink the constant and return
   /// true.
-  bool ShrinkDemandedConstant(SDValue Op, const APInt &Demanded,
+  bool ShrinkDemandedConstant(SDValue Op, const APInt &DemandedBits,
+                              const APInt &DemandedElts,
+                              TargetLoweringOpt &TLO) const;
+
+  /// Helper wrapper around ShrinkDemandedConstant, demanding all elements.
+  bool ShrinkDemandedConstant(SDValue Op, const APInt &DemandedBits,
                               TargetLoweringOpt &TLO) const;
 
   // Target hook to do target-specific const optimization, which is called by
   // ShrinkDemandedConstant. This function should return true if the target
   // doesn't want ShrinkDemandedConstant to further optimize the constant.
-  virtual bool targetShrinkDemandedConstant(SDValue Op, const APInt &Demanded,
+  virtual bool targetShrinkDemandedConstant(SDValue Op,
+                                            const APInt &DemandedBits,
+                                            const APInt &DemandedElts,
                                             TargetLoweringOpt &TLO) const {
     return false;
   }
@@ -3062,9 +3327,30 @@
 
   /// Helper wrapper around SimplifyDemandedBits.
   /// Adds Op back to the worklist upon success.
-  bool SimplifyDemandedBits(SDValue Op, const APInt &DemandedMask,
+  bool SimplifyDemandedBits(SDValue Op, const APInt &DemandedBits,
                             DAGCombinerInfo &DCI) const;
 
+  /// More limited version of SimplifyDemandedBits that can be used to "look
+  /// through" ops that don't contribute to the DemandedBits/DemandedElts -
+  /// bitwise ops etc.
+  SDValue SimplifyMultipleUseDemandedBits(SDValue Op, const APInt &DemandedBits,
+                                          const APInt &DemandedElts,
+                                          SelectionDAG &DAG,
+                                          unsigned Depth) const;
+
+  /// Helper wrapper around SimplifyMultipleUseDemandedBits, demanding all
+  /// elements.
+  SDValue SimplifyMultipleUseDemandedBits(SDValue Op, const APInt &DemandedBits,
+                                          SelectionDAG &DAG,
+                                          unsigned Depth = 0) const;
+
+  /// Helper wrapper around SimplifyMultipleUseDemandedBits, demanding all
+  /// bits from only some vector elements.
+  SDValue SimplifyMultipleUseDemandedVectorElts(SDValue Op,
+                                                const APInt &DemandedElts,
+                                                SelectionDAG &DAG,
+                                                unsigned Depth = 0) const;
+
   /// Look at Vector Op. At this point, we know that only the DemandedElts
   /// elements of the result of Op are ever used downstream.  If we can use
   /// this information to simplify Op, create a new simplified DAG node and
@@ -3100,14 +3386,31 @@
                                              const SelectionDAG &DAG,
                                              unsigned Depth = 0) const;
 
+  /// Determine which of the bits specified in Mask are known to be either zero
+  /// or one and return them in the KnownZero/KnownOne bitsets. The DemandedElts
+  /// argument allows us to only collect the known bits that are shared by the
+  /// requested vector elements. This is for GISel.
+  virtual void computeKnownBitsForTargetInstr(GISelKnownBits &Analysis,
+                                              Register R, KnownBits &Known,
+                                              const APInt &DemandedElts,
+                                              const MachineRegisterInfo &MRI,
+                                              unsigned Depth = 0) const;
+
+  /// Determine the known alignment for the pointer value \p R. This is can
+  /// typically be inferred from the number of low known 0 bits. However, for a
+  /// pointer with a non-integral address space, the alignment value may be
+  /// independent from the known low bits.
+  virtual Align computeKnownAlignForTargetInstr(GISelKnownBits &Analysis,
+                                                Register R,
+                                                const MachineRegisterInfo &MRI,
+                                                unsigned Depth = 0) const;
+
   /// Determine which of the bits of FrameIndex \p FIOp are known to be 0.
   /// Default implementation computes low bits based on alignment
   /// information. This should preserve known bits passed into it.
-  virtual void computeKnownBitsForFrameIndex(const SDValue FIOp,
+  virtual void computeKnownBitsForFrameIndex(int FIOp,
                                              KnownBits &Known,
-                                             const APInt &DemandedElts,
-                                             const SelectionDAG &DAG,
-                                             unsigned Depth = 0) const;
+                                             const MachineFunction &MF) const;
 
   /// This method can be implemented by targets that want to expose additional
   /// information about sign bits to the DAG Combiner. The DemandedElts
@@ -3118,6 +3421,16 @@
                                                    const SelectionDAG &DAG,
                                                    unsigned Depth = 0) const;
 
+  /// This method can be implemented by targets that want to expose additional
+  /// information about sign bits to GlobalISel combiners. The DemandedElts
+  /// argument allows us to only collect the minimum sign bits that are shared
+  /// by the requested vector elements.
+  virtual unsigned computeNumSignBitsForTargetInstr(GISelKnownBits &Analysis,
+                                                    Register R,
+                                                    const APInt &DemandedElts,
+                                                    const MachineRegisterInfo &MRI,
+                                                    unsigned Depth = 0) const;
+
   /// Attempt to simplify any target nodes based on the demanded vector
   /// elements, returning true on success. Otherwise, analyze the expression and
   /// return a mask of KnownUndef and KnownZero elements for the expression
@@ -3139,6 +3452,21 @@
                                                  TargetLoweringOpt &TLO,
                                                  unsigned Depth = 0) const;
 
+  /// More limited version of SimplifyDemandedBits that can be used to "look
+  /// through" ops that don't contribute to the DemandedBits/DemandedElts -
+  /// bitwise ops etc.
+  virtual SDValue SimplifyMultipleUseDemandedBitsForTargetNode(
+      SDValue Op, const APInt &DemandedBits, const APInt &DemandedElts,
+      SelectionDAG &DAG, unsigned Depth) const;
+
+  /// Tries to build a legal vector shuffle using the provided parameters
+  /// or equivalent variations. The Mask argument maybe be modified as the
+  /// function tries different variations.
+  /// Returns an empty SDValue if the operation fails.
+  SDValue buildLegalVectorShuffle(EVT VT, const SDLoc &DL, SDValue N0,
+                                  SDValue N1, MutableArrayRef<int> Mask,
+                                  SelectionDAG &DAG) const;
+
   /// This method returns the constant pool value that will be loaded by LD.
   /// NOTE: You must check for implicit extensions of the constant by LD.
   virtual const Constant *getTargetConstantFromLoad(LoadSDNode *LD) const;
@@ -3163,9 +3491,7 @@
 
     bool isBeforeLegalize() const { return Level == BeforeLegalizeTypes; }
     bool isBeforeLegalizeOps() const { return Level < AfterLegalizeVectorOps; }
-    bool isAfterLegalizeDAG() const {
-      return Level == AfterLegalizeDAG;
-    }
+    bool isAfterLegalizeDAG() const { return Level >= AfterLegalizeDAG; }
     CombineLevel getDAGCombineLevel() { return Level; }
     bool isCalledByLegalizer() const { return CalledByLegalizer; }
 
@@ -3174,6 +3500,8 @@
     SDValue CombineTo(SDNode *N, SDValue Res, bool AddTo = true);
     SDValue CombineTo(SDNode *N, SDValue Res0, SDValue Res1, bool AddTo = true);
 
+    bool recursivelyDeleteUnusedNodes(SDNode *N);
+
     void CommitTargetLoweringOpt(const TargetLoweringOpt &TLO);
   };
 
@@ -3230,20 +3558,6 @@
     return true;
   }
 
-  // Return true if it is profitable to combine a BUILD_VECTOR with a stride-pattern
-  // to a shuffle and a truncate.
-  // Example of such a combine:
-  // v4i32 build_vector((extract_elt V, 1),
-  //                    (extract_elt V, 3),
-  //                    (extract_elt V, 5),
-  //                    (extract_elt V, 7))
-  //  -->
-  // v4i32 truncate (bitcast (shuffle<1,u,3,u,5,u,7,u> V, u) to v4i64)
-  virtual bool isDesirableToCombineBuildVectorToShuffleTruncate(
-      ArrayRef<int> ShuffleMask, EVT SrcVT, EVT TruncVT) const {
-    return false;
-  }
-
   /// Return true if the target has native support for the specified value type
   /// and it is 'desirable' to use the type for the given node type. e.g. On x86
   /// i16 is legal, but undesirable since i16 instruction encodings are longer
@@ -3297,11 +3611,61 @@
     llvm_unreachable("Not Implemented");
   }
 
+  /// Return the newly negated expression if the cost is not expensive and
+  /// set the cost in \p Cost to indicate that if it is cheaper or neutral to
+  /// do the negation.
+  virtual SDValue getNegatedExpression(SDValue Op, SelectionDAG &DAG,
+                                       bool LegalOps, bool OptForSize,
+                                       NegatibleCost &Cost,
+                                       unsigned Depth = 0) const;
+
+  /// This is the helper function to return the newly negated expression only
+  /// when the cost is cheaper.
+  SDValue getCheaperNegatedExpression(SDValue Op, SelectionDAG &DAG,
+                                      bool LegalOps, bool OptForSize,
+                                      unsigned Depth = 0) const {
+    NegatibleCost Cost = NegatibleCost::Expensive;
+    SDValue Neg =
+        getNegatedExpression(Op, DAG, LegalOps, OptForSize, Cost, Depth);
+    if (Neg && Cost == NegatibleCost::Cheaper)
+      return Neg;
+    // Remove the new created node to avoid the side effect to the DAG.
+    if (Neg && Neg.getNode()->use_empty())
+      DAG.RemoveDeadNode(Neg.getNode());
+    return SDValue();
+  }
+
+  /// This is the helper function to return the newly negated expression if
+  /// the cost is not expensive.
+  SDValue getNegatedExpression(SDValue Op, SelectionDAG &DAG, bool LegalOps,
+                               bool OptForSize, unsigned Depth = 0) const {
+    NegatibleCost Cost = NegatibleCost::Expensive;
+    return getNegatedExpression(Op, DAG, LegalOps, OptForSize, Cost, Depth);
+  }
+
   //===--------------------------------------------------------------------===//
   // Lowering methods - These methods must be implemented by targets so that
   // the SelectionDAGBuilder code knows how to lower these.
   //
 
+  /// Target-specific splitting of values into parts that fit a register
+  /// storing a legal type
+  virtual bool splitValueIntoRegisterParts(SelectionDAG &DAG, const SDLoc &DL,
+                                           SDValue Val, SDValue *Parts,
+                                           unsigned NumParts, MVT PartVT,
+                                           Optional<CallingConv::ID> CC) const {
+    return false;
+  }
+
+  /// Target-specific combining of register parts into its original value
+  virtual SDValue
+  joinRegisterPartsIntoValue(SelectionDAG &DAG, const SDLoc &DL,
+                             const SDValue *Parts, unsigned NumParts,
+                             MVT PartVT, EVT ValueVT,
+                             Optional<CallingConv::ID> CC) const {
+    return SDValue();
+  }
+
   /// This hook must be implemented to lower the incoming (formal) arguments,
   /// described by the Ins array, into the specified DAG. The implementation
   /// should fill in the InVals array with legal-type argument values, and
@@ -3328,6 +3692,8 @@
     bool IsReturnValueUsed : 1;
     bool IsConvergent      : 1;
     bool IsPatchPoint      : 1;
+    bool IsPreallocated : 1;
+    bool NoMerge           : 1;
 
     // IsTailCall should be modified by implementations of
     // TargetLowering::LowerCall that perform tail call conversions.
@@ -3342,7 +3708,7 @@
     ArgListTy Args;
     SelectionDAG &DAG;
     SDLoc DL;
-    ImmutableCallSite CS;
+    const CallBase *CB = nullptr;
     SmallVector<ISD::OutputArg, 32> Outs;
     SmallVector<SDValue, 32> OutVals;
     SmallVector<ISD::InputArg, 32> Ins;
@@ -3351,7 +3717,8 @@
     CallLoweringInfo(SelectionDAG &DAG)
         : RetSExt(false), RetZExt(false), IsVarArg(false), IsInReg(false),
           DoesNotReturn(false), IsReturnValueUsed(true), IsConvergent(false),
-          IsPatchPoint(false), DAG(DAG) {}
+          IsPatchPoint(false), IsPreallocated(false), NoMerge(false),
+          DAG(DAG) {}
 
     CallLoweringInfo &setDebugLoc(const SDLoc &dl) {
       DL = dl;
@@ -3389,26 +3756,26 @@
 
     CallLoweringInfo &setCallee(Type *ResultType, FunctionType *FTy,
                                 SDValue Target, ArgListTy &&ArgsList,
-                                ImmutableCallSite Call) {
+                                const CallBase &Call) {
       RetTy = ResultType;
 
       IsInReg = Call.hasRetAttr(Attribute::InReg);
       DoesNotReturn =
           Call.doesNotReturn() ||
-          (!Call.isInvoke() &&
-           isa<UnreachableInst>(Call.getInstruction()->getNextNode()));
+          (!isa<InvokeInst>(Call) && isa<UnreachableInst>(Call.getNextNode()));
       IsVarArg = FTy->isVarArg();
-      IsReturnValueUsed = !Call.getInstruction()->use_empty();
+      IsReturnValueUsed = !Call.use_empty();
       RetSExt = Call.hasRetAttr(Attribute::SExt);
       RetZExt = Call.hasRetAttr(Attribute::ZExt);
-
+      NoMerge = Call.hasFnAttr(Attribute::NoMerge);
+      
       Callee = Target;
 
       CallConv = Call.getCallingConv();
       NumFixedArgs = FTy->getNumParams();
       Args = std::move(ArgsList);
 
-      CS = Call;
+      CB = &Call;
 
       return *this;
     }
@@ -3458,6 +3825,11 @@
       return *this;
     }
 
+    CallLoweringInfo &setIsPreallocated(bool Value = true) {
+      IsPreallocated = Value;
+      return *this;
+    }
+
     CallLoweringInfo &setIsPostTypeLegalization(bool Value=true) {
       IsPostTypeLegalization = Value;
       return *this;
@@ -3468,6 +3840,51 @@
     }
   };
 
+  /// This structure is used to pass arguments to makeLibCall function.
+  struct MakeLibCallOptions {
+    // By passing type list before soften to makeLibCall, the target hook
+    // shouldExtendTypeInLibCall can get the original type before soften.
+    ArrayRef<EVT> OpsVTBeforeSoften;
+    EVT RetVTBeforeSoften;
+    bool IsSExt : 1;
+    bool DoesNotReturn : 1;
+    bool IsReturnValueUsed : 1;
+    bool IsPostTypeLegalization : 1;
+    bool IsSoften : 1;
+
+    MakeLibCallOptions()
+        : IsSExt(false), DoesNotReturn(false), IsReturnValueUsed(true),
+          IsPostTypeLegalization(false), IsSoften(false) {}
+
+    MakeLibCallOptions &setSExt(bool Value = true) {
+      IsSExt = Value;
+      return *this;
+    }
+
+    MakeLibCallOptions &setNoReturn(bool Value = true) {
+      DoesNotReturn = Value;
+      return *this;
+    }
+
+    MakeLibCallOptions &setDiscardResult(bool Value = true) {
+      IsReturnValueUsed = !Value;
+      return *this;
+    }
+
+    MakeLibCallOptions &setIsPostTypeLegalization(bool Value = true) {
+      IsPostTypeLegalization = Value;
+      return *this;
+    }
+
+    MakeLibCallOptions &setTypeListBeforeSoften(ArrayRef<EVT> OpsVT, EVT RetVT,
+                                                bool Value = true) {
+      OpsVTBeforeSoften = OpsVT;
+      RetVTBeforeSoften = RetVT;
+      IsSoften = Value;
+      return *this;
+    }
+  };
+
   /// This function lowers an abstract call to a function into an actual call.
   /// This returns a pair of operands.  The first element is the return value
   /// for the function (if RetTy is not VoidTy).  The second element is the
@@ -3486,7 +3903,7 @@
   }
 
   /// Target-specific cleanup for formal ByVal parameters.
-  virtual void HandleByVal(CCState *, unsigned &, unsigned) const {}
+  virtual void HandleByVal(CCState *, unsigned &, Align) const {}
 
   /// This hook should be implemented to check whether the return values
   /// described by the Outs array can fit into the return registers.  If false
@@ -3537,8 +3954,8 @@
   /// Return the register ID of the name passed in. Used by named register
   /// global variables extension. There is no target-independent behaviour
   /// so the default action is to bail.
-  virtual unsigned getRegisterByName(const char* RegName, EVT VT,
-                                     SelectionDAG &DAG) const {
+  virtual Register getRegisterByName(const char* RegName, LLT Ty,
+                                     const MachineFunction &MF) const {
     report_fatal_error("Named registers not implemented for this target");
   }
 
@@ -3590,13 +4007,25 @@
     return Chain;
   }
 
-  /// This callback is used to inspect load/store instructions and add
-  /// target-specific MachineMemOperand flags to them.  The default
-  /// implementation does nothing.
-  virtual MachineMemOperand::Flags getMMOFlags(const Instruction &I) const {
-    return MachineMemOperand::MONone;
+  /// Should SelectionDAG lower an atomic store of the given kind as a normal
+  /// StoreSDNode (as opposed to an AtomicSDNode)?  NOTE: The intention is to
+  /// eventually migrate all targets to the using StoreSDNodes, but porting is
+  /// being done target at a time.
+  virtual bool lowerAtomicStoreAsStoreSDNode(const StoreInst &SI) const {
+    assert(SI.isAtomic() && "violated precondition");
+    return false;
   }
 
+  /// Should SelectionDAG lower an atomic load of the given kind as a normal
+  /// LoadSDNode (as opposed to an AtomicSDNode)?  NOTE: The intention is to
+  /// eventually migrate all targets to the using LoadSDNodes, but porting is
+  /// being done target at a time.
+  virtual bool lowerAtomicLoadAsLoadSDNode(const LoadInst &LI) const {
+    assert(LI.isAtomic() && "violated precondition");
+    return false;
+  }
+
+
   /// This callback is invoked by the type legalizer to legalize nodes with an
   /// illegal operand type but legal result types.  It replaces the
   /// LowerOperation callback in the type Legalizer.  The reason we can not do
@@ -3665,6 +4094,7 @@
     C_Register,            // Constraint represents specific register(s).
     C_RegisterClass,       // Constraint represents any of register(s) in class.
     C_Memory,              // Memory constraint.
+    C_Immediate,           // Requires an immediate.
     C_Other,               // Something else.
     C_Unknown              // Unsupported constraint.
   };
@@ -3725,7 +4155,7 @@
   /// string itself isn't empty, there was an error parsing.
   virtual AsmOperandInfoVector ParseConstraints(const DataLayout &DL,
                                                 const TargetRegisterInfo *TRI,
-                                                ImmutableCallSite CS) const;
+                                                const CallBase &Call) const;
 
   /// Examine constraint type and operand type and determine a weight value.
   /// The operand object must already have been set up with the operand type.
@@ -3762,9 +4192,7 @@
                                StringRef Constraint, MVT VT) const;
 
   virtual unsigned getInlineAsmMemConstraint(StringRef ConstraintCode) const {
-    if (ConstraintCode == "i")
-      return InlineAsm::Constraint_i;
-    else if (ConstraintCode == "m")
+    if (ConstraintCode == "m")
       return InlineAsm::Constraint_m;
     return InlineAsm::Constraint_Unknown;
   }
@@ -3782,7 +4210,7 @@
 
   // Lower custom output constraints. If invalid, return SDValue().
   virtual SDValue LowerAsmOutputForConstraint(SDValue &Chain, SDValue &Flag,
-                                              SDLoc DL,
+                                              const SDLoc &DL,
                                               const AsmOperandInfo &OpInfo,
                                               SelectionDAG &DAG) const;
 
@@ -3849,6 +4277,22 @@
     return SDValue();
   }
 
+  /// Return a target-dependent comparison result if the input operand is
+  /// suitable for use with a square root estimate calculation. For example, the
+  /// comparison may check if the operand is NAN, INF, zero, normal, etc. The
+  /// result should be used as the condition operand for a select or branch.
+  virtual SDValue getSqrtInputTest(SDValue Operand, SelectionDAG &DAG,
+                                   const DenormalMode &Mode) const {
+    return SDValue();
+  }
+
+  /// Return a target-dependent result if the input operand is not suitable for
+  /// use with a square root estimate calculation.
+  virtual SDValue getSqrtResultForDenormInput(SDValue Operand,
+                                              SelectionDAG &DAG) const {
+    return DAG.getConstantFP(0.0, SDLoc(Operand), Operand.getValueType());
+  }
+
   //===--------------------------------------------------------------------===//
   // Legalization utility functions
   //
@@ -3863,7 +4307,7 @@
   /// \param RL Low bits of the RHS of the MUL.  See LL for meaning
   /// \param RH High bits of the RHS of the MUL.  See LL for meaning.
   /// \returns true if the node has been expanded, false if it has not
-  bool expandMUL_LOHI(unsigned Opcode, EVT VT, SDLoc dl, SDValue LHS,
+  bool expandMUL_LOHI(unsigned Opcode, EVT VT, const SDLoc &dl, SDValue LHS,
                       SDValue RHS, SmallVectorImpl<SDValue> &Result, EVT HiLoVT,
                       SelectionDAG &DAG, MulExpansionKind Kind,
                       SDValue LL = SDValue(), SDValue LH = SDValue(),
@@ -3891,9 +4335,12 @@
 
   /// Expand rotations.
   /// \param N Node to expand
+  /// \param AllowVectorOps expand vector rotate, this should only be performed
+  ///        if the legalization is happening outside of LegalizeVectorOps
   /// \param Result output after conversion
   /// \returns True, if the expansion was successful, false otherwise
-  bool expandROT(SDNode *N, SDValue &Result, SelectionDAG &DAG) const;
+  bool expandROT(SDNode *N, bool AllowVectorOps, SDValue &Result,
+                 SelectionDAG &DAG) const;
 
   /// Expand float(f32) to SINT(i64) conversion
   /// \param N Node to expand
@@ -3904,18 +4351,27 @@
   /// Expand float to UINT conversion
   /// \param N Node to expand
   /// \param Result output after conversion
+  /// \param Chain output chain after conversion
   /// \returns True, if the expansion was successful, false otherwise
-  bool expandFP_TO_UINT(SDNode *N, SDValue &Result, SelectionDAG &DAG) const;
+  bool expandFP_TO_UINT(SDNode *N, SDValue &Result, SDValue &Chain,
+                        SelectionDAG &DAG) const;
 
   /// Expand UINT(i64) to double(f64) conversion
   /// \param N Node to expand
   /// \param Result output after conversion
+  /// \param Chain output chain after conversion
   /// \returns True, if the expansion was successful, false otherwise
-  bool expandUINT_TO_FP(SDNode *N, SDValue &Result, SelectionDAG &DAG) const;
+  bool expandUINT_TO_FP(SDNode *N, SDValue &Result, SDValue &Chain,
+                        SelectionDAG &DAG) const;
 
   /// Expand fminnum/fmaxnum into fminnum_ieee/fmaxnum_ieee with quieted inputs.
   SDValue expandFMINNUM_FMAXNUM(SDNode *N, SelectionDAG &DAG) const;
 
+  /// Expand FP_TO_[US]INT_SAT into FP_TO_[US]INT and selects or min/max.
+  /// \param N Node to expand
+  /// \returns The expansion result
+  SDValue expandFP_TO_INT_SAT(SDNode *N, SelectionDAG &DAG) const;
+
   /// Expand CTPOP nodes. Expands vector/scalar CTPOP nodes,
   /// vector nodes can only succeed if all operations are legal/custom.
   /// \param N Node to expand
@@ -3942,17 +4398,20 @@
   /// (ABS x) -> (XOR (ADD x, (SRA x, type_size)), (SRA x, type_size))
   /// \param N Node to expand
   /// \param Result output after conversion
+  /// \param IsNegative indicate negated abs
   /// \returns True, if the expansion was successful, false otherwise
-  bool expandABS(SDNode *N, SDValue &Result, SelectionDAG &DAG) const;
+  bool expandABS(SDNode *N, SDValue &Result, SelectionDAG &DAG,
+                 bool IsNegative = false) const;
 
   /// Turn load of vector type into a load of the individual elements.
   /// \param LD load to expand
-  /// \returns MERGE_VALUEs of the scalar loads with their chains.
-  SDValue scalarizeVectorLoad(LoadSDNode *LD, SelectionDAG &DAG) const;
+  /// \returns BUILD_VECTOR and TokenFactor nodes.
+  std::pair<SDValue, SDValue> scalarizeVectorLoad(LoadSDNode *LD,
+                                                  SelectionDAG &DAG) const;
 
   // Turn a store of a vector type into stores of the individual elements.
   /// \param ST Store with a vector value type
-  /// \returns MERGE_VALUs of the individual store chains.
+  /// \returns TokenFactor of the individual store chains.
   SDValue scalarizeVectorStore(StoreSDNode *ST, SelectionDAG &DAG) const;
 
   /// Expands an unaligned load to 2 half-size loads for an integer, and
@@ -3982,14 +4441,30 @@
   SDValue getVectorElementPointer(SelectionDAG &DAG, SDValue VecPtr, EVT VecVT,
                                   SDValue Index) const;
 
+  /// Method for building the DAG expansion of ISD::[US][MIN|MAX]. This
+  /// method accepts integers as its arguments.
+  SDValue expandIntMINMAX(SDNode *Node, SelectionDAG &DAG) const;
+
   /// Method for building the DAG expansion of ISD::[US][ADD|SUB]SAT. This
   /// method accepts integers as its arguments.
   SDValue expandAddSubSat(SDNode *Node, SelectionDAG &DAG) const;
 
-  /// Method for building the DAG expansion of ISD::SMULFIX. This method accepts
-  /// integers as its arguments.
+  /// Method for building the DAG expansion of ISD::[US]SHLSAT. This
+  /// method accepts integers as its arguments.
+  SDValue expandShlSat(SDNode *Node, SelectionDAG &DAG) const;
+
+  /// Method for building the DAG expansion of ISD::[U|S]MULFIX[SAT]. This
+  /// method accepts integers as its arguments.
   SDValue expandFixedPointMul(SDNode *Node, SelectionDAG &DAG) const;
 
+  /// Method for building the DAG expansion of ISD::[US]DIVFIX[SAT]. This
+  /// method accepts integers as its arguments.
+  /// Note: This method may fail if the division could not be performed
+  /// within the type. Clients must retry with a wider type if this happens.
+  SDValue expandFixedPointDiv(unsigned Opcode, const SDLoc &dl,
+                              SDValue LHS, SDValue RHS,
+                              unsigned Scale, SelectionDAG &DAG) const;
+
   /// Method for building the DAG expansion of ISD::U(ADD|SUB)O. Expansion
   /// always suceeds and populates the Result and Overflow arguments.
   void expandUADDSUBO(SDNode *Node, SDValue &Result, SDValue &Overflow,
@@ -4009,6 +4484,13 @@
   /// only the first Count elements of the vector are used.
   SDValue expandVecReduce(SDNode *Node, SelectionDAG &DAG) const;
 
+  /// Expand a VECREDUCE_SEQ_* into an explicit ordered calculation.
+  SDValue expandVecReduceSeq(SDNode *Node, SelectionDAG &DAG) const;
+
+  /// Expand an SREM or UREM using SDIV/UDIV or SDIVREM/UDIVREM, if legal.
+  /// Returns true if the expansion was successful.
+  bool expandREM(SDNode *Node, SDValue &Result, SelectionDAG &DAG) const;
+
   //===--------------------------------------------------------------------===//
   // Instruction Emitting Hooks
   //
@@ -4059,6 +4541,10 @@
   // combiner can fold the new nodes.
   SDValue lowerCmpEqZeroToCtlzSrl(SDValue Op, SelectionDAG &DAG) const;
 
+  /// Give targets the chance to reduce the number of distinct addresing modes.
+  ISD::MemIndexType getCanonicalIndexType(ISD::MemIndexType IndexType,
+                                          EVT MemVT, SDValue Offsets) const;
+
 private:
   SDValue foldSetCCWithAnd(EVT VT, SDValue N0, SDValue N1, ISD::CondCode Cond,
                            const SDLoc &DL, DAGCombinerInfo &DCI) const;
@@ -4070,6 +4556,11 @@
                                                DAGCombinerInfo &DCI,
                                                const SDLoc &DL) const;
 
+  // (X & (C l>>/<< Y)) ==/!= 0  -->  ((X <</l>> Y) & C) ==/!= 0
+  SDValue optimizeSetCCByHoistingAndByConstFromLogicalShift(
+      EVT SCCVT, SDValue N0, SDValue N1C, ISD::CondCode Cond,
+      DAGCombinerInfo &DCI, const SDLoc &DL) const;
+
   SDValue prepareUREMEqFold(EVT SETCCVT, SDValue REMNode,
                             SDValue CompTargetNode, ISD::CondCode Cond,
                             DAGCombinerInfo &DCI, const SDLoc &DL,
@@ -4077,6 +4568,14 @@
   SDValue buildUREMEqFold(EVT SETCCVT, SDValue REMNode, SDValue CompTargetNode,
                           ISD::CondCode Cond, DAGCombinerInfo &DCI,
                           const SDLoc &DL) const;
+
+  SDValue prepareSREMEqFold(EVT SETCCVT, SDValue REMNode,
+                            SDValue CompTargetNode, ISD::CondCode Cond,
+                            DAGCombinerInfo &DCI, const SDLoc &DL,
+                            SmallVectorImpl<SDNode *> &Created) const;
+  SDValue buildSREMEqFold(EVT SETCCVT, SDValue REMNode, SDValue CompTargetNode,
+                          ISD::CondCode Cond, DAGCombinerInfo &DCI,
+                          const SDLoc &DL) const;
 };
 
 /// Given an LLVM IR type and return type attributes, compute the return value
diff --git a/linux-x64/clang/include/llvm/CodeGen/TargetLoweringObjectFileImpl.h b/linux-x64/clang/include/llvm/CodeGen/TargetLoweringObjectFileImpl.h
index a1fb81c..31e08b7 100644
--- a/linux-x64/clang/include/llvm/CodeGen/TargetLoweringObjectFileImpl.h
+++ b/linux-x64/clang/include/llvm/CodeGen/TargetLoweringObjectFileImpl.h
@@ -14,18 +14,19 @@
 #ifndef LLVM_CODEGEN_TARGETLOWERINGOBJECTFILEIMPL_H
 #define LLVM_CODEGEN_TARGETLOWERINGOBJECTFILEIMPL_H
 
-#include "llvm/IR/Module.h"
-#include "llvm/MC/MCExpr.h"
+#include "llvm/BinaryFormat/XCOFF.h"
 #include "llvm/Target/TargetLoweringObjectFile.h"
 
 namespace llvm {
 
 class GlobalValue;
 class MachineModuleInfo;
-class Mangler;
+class MachineFunction;
 class MCContext;
+class MCExpr;
 class MCSection;
 class MCSymbol;
+class Module;
 class TargetMachine;
 
 class TargetLoweringObjectFileELF : public TargetLoweringObjectFile {
@@ -35,10 +36,9 @@
 protected:
   MCSymbolRefExpr::VariantKind PLTRelativeVariantKind =
       MCSymbolRefExpr::VK_None;
-  const TargetMachine *TM;
 
 public:
-  TargetLoweringObjectFileELF() = default;
+  TargetLoweringObjectFileELF();
   ~TargetLoweringObjectFileELF() override = default;
 
   void Initialize(MCContext &Ctx, const TargetMachine &TM) override;
@@ -53,7 +53,7 @@
   /// placed in.
   MCSection *getSectionForConstant(const DataLayout &DL, SectionKind Kind,
                                    const Constant *C,
-                                   unsigned &Align) const override;
+                                   Align &Alignment) const override;
 
   MCSection *getExplicitSectionGlobal(const GlobalObject *GO, SectionKind Kind,
                                       const TargetMachine &TM) const override;
@@ -63,6 +63,13 @@
 
   MCSection *getSectionForJumpTable(const Function &F,
                                     const TargetMachine &TM) const override;
+  MCSection *getSectionForLSDA(const Function &F,
+                               const TargetMachine &TM) const override;
+
+  MCSection *
+  getSectionForMachineBasicBlock(const Function &F,
+                                 const MachineBasicBlock &MBB,
+                                 const TargetMachine &TM) const override;
 
   bool shouldPutJumpTableInFunctionSection(bool UsesLabelDifference,
                                            const Function &F) const override;
@@ -90,6 +97,9 @@
                                        const GlobalValue *RHS,
                                        const TargetMachine &TM) const override;
 
+  const MCExpr *lowerDSOLocalEquivalent(const DSOLocalEquivalent *Equiv,
+                                        const TargetMachine &TM) const override;
+
   MCSection *getSectionForCommandLines() const override;
 };
 
@@ -111,7 +121,7 @@
 
   MCSection *getSectionForConstant(const DataLayout &DL, SectionKind Kind,
                                    const Constant *C,
-                                   unsigned &Align) const override;
+                                   Align &Alignment) const override;
 
   /// The mach-o version of this method defaults to returning a stub reference.
   const MCExpr *getTTypeGlobalReference(const GlobalValue *GV,
@@ -126,7 +136,8 @@
                                     MachineModuleInfo *MMI) const override;
 
   /// Get MachO PC relative GOT entry relocation
-  const MCExpr *getIndirectSymViaGOTPCRel(const MCSymbol *Sym,
+  const MCExpr *getIndirectSymViaGOTPCRel(const GlobalValue *GV,
+                                          const MCSymbol *Sym,
                                           const MCValue &MV, int64_t Offset,
                                           MachineModuleInfo *MMI,
                                           MCStreamer &Streamer) const override;
@@ -137,6 +148,7 @@
 
 class TargetLoweringObjectFileCOFF : public TargetLoweringObjectFile {
   mutable unsigned NextUniqueID = 0;
+  const TargetMachine *TM = nullptr;
 
 public:
   ~TargetLoweringObjectFileCOFF() override = default;
@@ -162,12 +174,6 @@
   MCSection *getStaticDtorSection(unsigned Priority,
                                   const MCSymbol *KeySym) const override;
 
-  void emitLinkerFlagsForGlobal(raw_ostream &OS,
-                                const GlobalValue *GV) const override;
-
-  void emitLinkerFlagsForUsed(raw_ostream &OS,
-                              const GlobalValue *GV) const override;
-
   const MCExpr *lowerRelativeReference(const GlobalValue *LHS,
                                        const GlobalValue *RHS,
                                        const TargetMachine &TM) const override;
@@ -176,7 +182,10 @@
   /// information, return a section that it should be placed in.
   MCSection *getSectionForConstant(const DataLayout &DL, SectionKind Kind,
                                    const Constant *C,
-                                   unsigned &Align) const override;
+                                   Align &Alignment) const override;
+
+private:
+  void emitLinkerDirectives(MCStreamer &Streamer, Module &M) const;
 };
 
 class TargetLoweringObjectFileWasm : public TargetLoweringObjectFile {
@@ -206,6 +215,66 @@
                                        const TargetMachine &TM) const override;
 };
 
+class TargetLoweringObjectFileXCOFF : public TargetLoweringObjectFile {
+public:
+  TargetLoweringObjectFileXCOFF() = default;
+  ~TargetLoweringObjectFileXCOFF() override = default;
+
+  static bool ShouldEmitEHBlock(const MachineFunction *MF);
+
+  static MCSymbol *getEHInfoTableSymbol(const MachineFunction *MF);
+
+  void Initialize(MCContext &Ctx, const TargetMachine &TM) override;
+
+  bool shouldPutJumpTableInFunctionSection(bool UsesLabelDifference,
+                                           const Function &F) const override;
+
+  MCSection *getExplicitSectionGlobal(const GlobalObject *GO, SectionKind Kind,
+                                      const TargetMachine &TM) const override;
+
+  MCSection *getStaticCtorSection(unsigned Priority,
+                                  const MCSymbol *KeySym) const override;
+  MCSection *getStaticDtorSection(unsigned Priority,
+                                  const MCSymbol *KeySym) const override;
+
+  const MCExpr *lowerRelativeReference(const GlobalValue *LHS,
+                                       const GlobalValue *RHS,
+                                       const TargetMachine &TM) const override;
+
+  MCSection *SelectSectionForGlobal(const GlobalObject *GO, SectionKind Kind,
+                                    const TargetMachine &TM) const override;
+
+  MCSection *getSectionForJumpTable(const Function &F,
+                                    const TargetMachine &TM) const override;
+
+  /// Given a constant with the SectionKind, return a section that it should be
+  /// placed in.
+  MCSection *getSectionForConstant(const DataLayout &DL, SectionKind Kind,
+                                   const Constant *C,
+                                   Align &Alignment) const override;
+
+  static XCOFF::StorageClass getStorageClassForGlobal(const GlobalValue *GV);
+
+  MCSection *
+  getSectionForFunctionDescriptor(const Function *F,
+                                  const TargetMachine &TM) const override;
+  MCSection *getSectionForTOCEntry(const MCSymbol *Sym,
+                                   const TargetMachine &TM) const override;
+
+  /// For external functions, this will always return a function descriptor
+  /// csect.
+  MCSection *
+  getSectionForExternalReference(const GlobalObject *GO,
+                                 const TargetMachine &TM) const override;
+
+  /// For functions, this will always return a function descriptor symbol.
+  MCSymbol *getTargetSymbol(const GlobalValue *GV,
+                            const TargetMachine &TM) const override;
+
+  MCSymbol *getFunctionEntryPointSymbol(const GlobalValue *Func,
+                                        const TargetMachine &TM) const override;
+};
+
 } // end namespace llvm
 
 #endif // LLVM_CODEGEN_TARGETLOWERINGOBJECTFILEIMPL_H
diff --git a/linux-x64/clang/include/llvm/CodeGen/TargetPassConfig.h b/linux-x64/clang/include/llvm/CodeGen/TargetPassConfig.h
index 0bd82aa..b478771 100644
--- a/linux-x64/clang/include/llvm/CodeGen/TargetPassConfig.h
+++ b/linux-x64/clang/include/llvm/CodeGen/TargetPassConfig.h
@@ -25,6 +25,7 @@
 class PassConfigImpl;
 class ScheduleDAGInstrs;
 class CSEConfigBase;
+class PassInstrumentationCallbacks;
 
 // The old pass manager infrastructure is hidden in a legacy namespace now.
 namespace legacy {
@@ -103,6 +104,7 @@
   bool Started = true;
   bool Stopped = false;
   bool AddingMachinePasses = false;
+  bool DebugifyIsSafe = true;
 
   /// Set the StartAfter, StartBefore and StopAfter passes to allow running only
   /// a portion of the normal code-gen pass sequence.
@@ -166,8 +168,8 @@
   /// If hasLimitedCodeGenPipeline is true, this method
   /// returns a string with the name of the options, separated
   /// by \p Separator that caused this pipeline to be limited.
-  std::string
-  getLimitedCodeGenPipelineReason(const char *Separator = "/") const;
+  static std::string
+  getLimitedCodeGenPipelineReason(const char *Separator = "/");
 
   void setDisableVerify(bool Disable) { setOpt(DisableVerify, Disable); }
 
@@ -186,7 +188,7 @@
 
   /// Insert InsertedPassID pass after TargetPassID pass.
   void insertPass(AnalysisID TargetPassID, IdentifyingPassPtr InsertedPassID,
-                  bool VerifyAfter = true, bool PrintAfter = true);
+                  bool VerifyAfter = true);
 
   /// Allow the target to enable a specific standard pass by default.
   void enablePass(AnalysisID PassID) { substitutePass(PassID, PassID); }
@@ -280,7 +282,7 @@
   ///
   /// This can also be used to plug a new MachineSchedStrategy into an instance
   /// of the standard ScheduleDAGMI:
-  ///   return new ScheduleDAGMI(C, make_unique<MyStrategy>(C), /*RemoveKillFlags=*/false)
+  ///   return new ScheduleDAGMI(C, std::make_unique<MyStrategy>(C), /*RemoveKillFlags=*/false)
   ///
   /// Return NULL to select the default (generic) machine scheduler.
   virtual ScheduleDAGInstrs *
@@ -306,6 +308,24 @@
   /// verification is enabled.
   void addVerifyPass(const std::string &Banner);
 
+  /// Add a pass to add synthesized debug info to the MIR.
+  void addDebugifyPass();
+
+  /// Add a pass to remove debug info from the MIR.
+  void addStripDebugPass();
+
+  /// Add a pass to check synthesized debug info for MIR.
+  void addCheckDebugPass();
+
+  /// Add standard passes before a pass that's about to be added. For example,
+  /// the DebugifyMachineModulePass if it is enabled.
+  void addMachinePrePasses(bool AllowDebugify = true);
+
+  /// Add standard passes after a pass that has just been added. For example,
+  /// the MachineVerifier if it is enabled.
+  void addMachinePostPasses(const std::string &Banner, bool AllowVerify = true,
+                            bool AllowStrip = true);
+
   /// Check whether or not GlobalISel should abort on error.
   /// When this is disabled, GlobalISel will fall back on SDISel instead of
   /// erroring out.
@@ -425,32 +445,30 @@
 
   /// Add a CodeGen pass at this point in the pipeline after checking overrides.
   /// Return the pass that was added, or zero if no pass was added.
-  /// @p printAfter    if true and adding a machine function pass add an extra
-  ///                  machine printer pass afterwards
   /// @p verifyAfter   if true and adding a machine function pass add an extra
   ///                  machine verification pass afterwards.
-  AnalysisID addPass(AnalysisID PassID, bool verifyAfter = true,
-                     bool printAfter = true);
+  AnalysisID addPass(AnalysisID PassID, bool verifyAfter = true);
 
   /// Add a pass to the PassManager if that pass is supposed to be run, as
   /// determined by the StartAfter and StopAfter options. Takes ownership of the
   /// pass.
-  /// @p printAfter    if true and adding a machine function pass add an extra
-  ///                  machine printer pass afterwards
   /// @p verifyAfter   if true and adding a machine function pass add an extra
   ///                  machine verification pass afterwards.
-  void addPass(Pass *P, bool verifyAfter = true, bool printAfter = true);
+  void addPass(Pass *P, bool verifyAfter = true);
 
   /// addMachinePasses helper to create the target-selected or overriden
   /// regalloc pass.
   virtual FunctionPass *createRegAllocPass(bool Optimized);
 
-  /// Add core register alloator passes which do the actual register assignment
+  /// Add core register allocator passes which do the actual register assignment
   /// and rewriting. \returns true if any passes were added.
-  virtual bool addRegAssignmentFast();
-  virtual bool addRegAssignmentOptimized();
+  virtual bool addRegAssignAndRewriteFast();
+  virtual bool addRegAssignAndRewriteOptimized();
 };
 
+void registerCodeGenCallback(PassInstrumentationCallbacks &PIC,
+                             LLVMTargetMachine &);
+
 } // end namespace llvm
 
 #endif // LLVM_CODEGEN_TARGETPASSCONFIG_H
diff --git a/linux-x64/clang/include/llvm/CodeGen/TargetRegisterInfo.h b/linux-x64/clang/include/llvm/CodeGen/TargetRegisterInfo.h
index 9a3ab47..6f32729 100644
--- a/linux-x64/clang/include/llvm/CodeGen/TargetRegisterInfo.h
+++ b/linux-x64/clang/include/llvm/CodeGen/TargetRegisterInfo.h
@@ -34,12 +34,14 @@
 namespace llvm {
 
 class BitVector;
+class DIExpression;
 class LiveRegMatrix;
 class MachineFunction;
 class MachineInstr;
 class RegScavenger;
 class VirtRegMap;
 class LiveIntervals;
+class LiveInterval;
 
 class TargetRegisterClass {
 public:
@@ -80,19 +82,27 @@
   }
 
   /// Return the specified register in the class.
-  unsigned getRegister(unsigned i) const {
+  MCRegister getRegister(unsigned i) const {
     return MC->getRegister(i);
   }
 
   /// Return true if the specified register is included in this register class.
   /// This does not include virtual registers.
-  bool contains(unsigned Reg) const {
-    return MC->contains(Reg);
+  bool contains(Register Reg) const {
+    /// FIXME: Historically this function has returned false when given vregs
+    ///        but it should probably only receive physical registers
+    if (!Reg.isPhysical())
+      return false;
+    return MC->contains(Reg.asMCReg());
   }
 
   /// Return true if both registers are in this class.
-  bool contains(unsigned Reg1, unsigned Reg2) const {
-    return MC->contains(Reg1, Reg2);
+  bool contains(Register Reg1, Register Reg2) const {
+    /// FIXME: Historically this function has returned false when given a vregs
+    ///        but it should probably only receive physical registers
+    if (!Reg1.isPhysical() || !Reg2.isPhysical())
+      return false;
+    return MC->contains(Reg1.asMCReg(), Reg2.asMCReg());
   }
 
   /// Return the cost of copying a value between two registers in this class.
@@ -258,57 +268,6 @@
   // Further sentinels can be allocated from the small negative integers.
   // DenseMapInfo<unsigned> uses -1u and -2u.
 
-  /// isStackSlot - Sometimes it is useful the be able to store a non-negative
-  /// frame index in a variable that normally holds a register. isStackSlot()
-  /// returns true if Reg is in the range used for stack slots.
-  ///
-  /// Note that isVirtualRegister() and isPhysicalRegister() cannot handle stack
-  /// slots, so if a variable may contains a stack slot, always check
-  /// isStackSlot() first.
-  ///
-  static bool isStackSlot(unsigned Reg) {
-    return int(Reg) >= (1 << 30);
-  }
-
-  /// Compute the frame index from a register value representing a stack slot.
-  static int stackSlot2Index(unsigned Reg) {
-    assert(isStackSlot(Reg) && "Not a stack slot");
-    return int(Reg - (1u << 30));
-  }
-
-  /// Convert a non-negative frame index to a stack slot register value.
-  static unsigned index2StackSlot(int FI) {
-    assert(FI >= 0 && "Cannot hold a negative frame index.");
-    return FI + (1u << 30);
-  }
-
-  /// Return true if the specified register number is in
-  /// the physical register namespace.
-  static bool isPhysicalRegister(unsigned Reg) {
-    assert(!isStackSlot(Reg) && "Not a register! Check isStackSlot() first.");
-    return int(Reg) > 0;
-  }
-
-  /// Return true if the specified register number is in
-  /// the virtual register namespace.
-  static bool isVirtualRegister(unsigned Reg) {
-    assert(!isStackSlot(Reg) && "Not a register! Check isStackSlot() first.");
-    return int(Reg) < 0;
-  }
-
-  /// Convert a virtual register number to a 0-based index.
-  /// The first virtual register in a function will get the index 0.
-  static unsigned virtReg2Index(unsigned Reg) {
-    assert(isVirtualRegister(Reg) && "Not a virtual register");
-    return Reg & ~(1u << 31);
-  }
-
-  /// Convert a 0-based index to a virtual register number.
-  /// This is the inverse operation of VirtReg2IndexFunctor below.
-  static unsigned index2VirtReg(unsigned Index) {
-    return Index | (1u << 31);
-  }
-
   /// Return the size in bits of a register from class RC.
   unsigned getRegSizeInBits(const TargetRegisterClass &RC) const {
     return getRegClassInfo(RC).RegSize;
@@ -326,6 +285,12 @@
     return getRegClassInfo(RC).SpillAlignment / 8;
   }
 
+  /// Return the minimum required alignment in bytes for a spill slot for
+  /// a register of this class.
+  Align getSpillAlign(const TargetRegisterClass &RC) const {
+    return Align(getRegClassInfo(RC).SpillAlignment / 8);
+  }
+
   /// Return true if the given TargetRegisterClass has the ValueType T.
   bool isTypeLegalForClass(const TargetRegisterClass &RC, MVT T) const {
     for (auto I = legalclasstypes_begin(RC); *I != MVT::Other; ++I)
@@ -350,8 +315,8 @@
   /// Returns the Register Class of a physical register of the given type,
   /// picking the most sub register class of the right type that contains this
   /// physreg.
-  const TargetRegisterClass *
-    getMinimalPhysRegClass(unsigned Reg, MVT VT = MVT::Other) const;
+  const TargetRegisterClass *getMinimalPhysRegClass(MCRegister Reg,
+                                                    MVT VT = MVT::Other) const;
 
   /// Return the maximal subclass of the given register class that is
   /// allocatable or NULL.
@@ -366,12 +331,12 @@
 
   /// Return the additional cost of using this register instead
   /// of other registers in its class.
-  unsigned getCostPerUse(unsigned RegNo) const {
+  unsigned getCostPerUse(MCRegister RegNo) const {
     return InfoDesc[RegNo].CostPerUse;
   }
 
   /// Return true if the register is in the allocation of any register class.
-  bool isInAllocatableClass(unsigned RegNo) const {
+  bool isInAllocatableClass(MCRegister RegNo) const {
     return InfoDesc[RegNo].inAllocatableClass;
   }
 
@@ -419,14 +384,14 @@
 
   /// Returns true if the two registers are equal or alias each other.
   /// The registers may be virtual registers.
-  bool regsOverlap(unsigned regA, unsigned regB) const {
+  bool regsOverlap(Register regA, Register regB) const {
     if (regA == regB) return true;
-    if (isVirtualRegister(regA) || isVirtualRegister(regB))
+    if (!regA.isPhysical() || !regB.isPhysical())
       return false;
 
     // Regunits are numerically ordered. Find a common unit.
-    MCRegUnitIterator RUA(regA, this);
-    MCRegUnitIterator RUB(regB, this);
+    MCRegUnitIterator RUA(regA.asMCReg(), this);
+    MCRegUnitIterator RUB(regB.asMCReg(), this);
     do {
       if (*RUA == *RUB) return true;
       if (*RUA < *RUB) ++RUA;
@@ -436,9 +401,9 @@
   }
 
   /// Returns true if Reg contains RegUnit.
-  bool hasRegUnit(unsigned Reg, unsigned RegUnit) const {
+  bool hasRegUnit(MCRegister Reg, Register RegUnit) const {
     for (MCRegUnitIterator Units(Reg, this); Units.isValid(); ++Units)
-      if (*Units == RegUnit)
+      if (Register(*Units) == RegUnit)
         return true;
     return false;
   }
@@ -447,7 +412,7 @@
   /// operation, in which case we chain backwards through all such operations
   /// to the ultimate source register.  If a physical register is encountered,
   /// we stop the search.
-  virtual unsigned lookThruCopyLike(unsigned SrcReg,
+  virtual Register lookThruCopyLike(Register SrcReg,
                                     const MachineRegisterInfo *MRI) const;
 
   /// Return a null-terminated list of all of the callee-saved registers on
@@ -484,11 +449,26 @@
     return nullptr;
   }
 
+  /// Return a register mask for the registers preserved by the unwinder,
+  /// or nullptr if no custom mask is needed.
+  virtual const uint32_t *
+  getCustomEHPadPreservedMask(const MachineFunction &MF) const {
+    return nullptr;
+  }
+
   /// Return a register mask that clobbers everything.
   virtual const uint32_t *getNoPreservedMask() const {
     llvm_unreachable("target does not provide no preserved mask");
   }
 
+  /// Return a list of all of the registers which are clobbered "inside" a call
+  /// to the given function. For example, these might be needed for PLT
+  /// sequences of long-branch veneers.
+  virtual ArrayRef<MCPhysReg>
+  getIntraCallClobberedRegs(const MachineFunction *MF) const {
+    return {};
+  }
+
   /// Return true if all bits that are set in mask \p mask0 are also set in
   /// \p mask1.
   bool regmaskSubsetEqual(const uint32_t *mask0, const uint32_t *mask1) const;
@@ -512,13 +492,19 @@
   /// Returns false if we can't guarantee that Physreg, specified as an IR asm
   /// clobber constraint, will be preserved across the statement.
   virtual bool isAsmClobberable(const MachineFunction &MF,
-                               unsigned PhysReg) const {
+                                MCRegister PhysReg) const {
     return true;
   }
 
+  /// Returns true if PhysReg cannot be written to in inline asm statements.
+  virtual bool isInlineAsmReadOnlyReg(const MachineFunction &MF,
+                                      unsigned PhysReg) const {
+    return false;
+  }
+
   /// Returns true if PhysReg is unallocatable and constant throughout the
   /// function.  Used by MachineRegisterInfo::isConstantPhysReg().
-  virtual bool isConstantPhysReg(unsigned PhysReg) const { return false; }
+  virtual bool isConstantPhysReg(MCRegister PhysReg) const { return false; }
 
   /// Returns true if the register class is considered divergent.
   virtual bool isDivergentRegClass(const TargetRegisterClass *RC) const {
@@ -530,8 +516,15 @@
   /// have call sequences where a GOT register may be updated by the caller
   /// prior to a call and is guaranteed to be restored (also by the caller)
   /// after the call.
-  virtual bool isCallerPreservedPhysReg(unsigned PhysReg,
-                                        const MachineFunction &MF) const;
+  virtual bool isCallerPreservedPhysReg(MCRegister PhysReg,
+                                        const MachineFunction &MF) const {
+    return false;
+  }
+
+  /// This is a wrapper around getCallPreservedMask().
+  /// Return true if the register is preserved after the call.
+  virtual bool isCalleeSavedPhysReg(MCRegister PhysReg,
+                                    const MachineFunction &MF) const;
 
   /// Prior to adding the live-out mask to a stackmap or patchpoint
   /// instruction, provide the target the opportunity to adjust it (mainly to
@@ -540,8 +533,8 @@
 
   /// Return a super-register of the specified register
   /// Reg so its sub-register of index SubIdx is Reg.
-  unsigned getMatchingSuperReg(unsigned Reg, unsigned SubIdx,
-                               const TargetRegisterClass *RC) const {
+  MCRegister getMatchingSuperReg(MCRegister Reg, unsigned SubIdx,
+                                 const TargetRegisterClass *RC) const {
     return MCRegisterInfo::getMatchingSuperReg(Reg, SubIdx, RC->MC);
   }
 
@@ -625,8 +618,8 @@
   }
 
   /// Debugging helper: dump register in human readable form to dbgs() stream.
-  static void dumpReg(unsigned Reg, unsigned SubRegIndex = 0,
-                      const TargetRegisterInfo* TRI = nullptr);
+  static void dumpReg(Register Reg, unsigned SubRegIndex = 0,
+                      const TargetRegisterInfo *TRI = nullptr);
 
 protected:
   /// Overridden by TableGen in targets that have sub-registers.
@@ -707,13 +700,9 @@
 
   /// Find the largest common subclass of A and B.
   /// Return NULL if there is no common subclass.
-  /// The common subclass should contain
-  /// simple value type SVT if it is not the Any type.
   const TargetRegisterClass *
   getCommonSubClass(const TargetRegisterClass *A,
-                    const TargetRegisterClass *B,
-                    const MVT::SimpleValueType SVT =
-                    MVT::SimpleValueType::Any) const;
+                    const TargetRegisterClass *B) const;
 
   /// Returns a TargetRegisterClass used for pointer values.
   /// If a target supports multiple different pointer register classes,
@@ -769,7 +758,7 @@
     const TargetRegisterClass *RC) const = 0;
 
   /// Returns size in bits of a phys/virtual/generic register.
-  unsigned getRegSizeInBits(unsigned Reg, const MachineRegisterInfo &MRI) const;
+  unsigned getRegSizeInBits(Register Reg, const MachineRegisterInfo &MRI) const;
 
   /// Get the weight in units of pressure for this register unit.
   virtual unsigned getRegUnitWeight(unsigned RegUnit) const = 0;
@@ -808,20 +797,19 @@
   /// independent register allocation hints. Targets that override this
   /// function should typically call this default implementation as well and
   /// expect to see generic copy hints added.
-  virtual bool getRegAllocationHints(unsigned VirtReg,
-                                     ArrayRef<MCPhysReg> Order,
-                                     SmallVectorImpl<MCPhysReg> &Hints,
-                                     const MachineFunction &MF,
-                                     const VirtRegMap *VRM = nullptr,
-                                     const LiveRegMatrix *Matrix = nullptr)
-    const;
+  virtual bool
+  getRegAllocationHints(Register VirtReg, ArrayRef<MCPhysReg> Order,
+                        SmallVectorImpl<MCPhysReg> &Hints,
+                        const MachineFunction &MF,
+                        const VirtRegMap *VRM = nullptr,
+                        const LiveRegMatrix *Matrix = nullptr) const;
 
   /// A callback to allow target a chance to update register allocation hints
   /// when a register is "changed" (e.g. coalesced) to another register.
   /// e.g. On ARM, some virtual registers should target register pairs,
   /// if one of pair is coalesced to another register, the allocation hint of
   /// the other half of the pair should be changed to point to the new register.
-  virtual void updateRegAllocHint(unsigned Reg, unsigned NewReg,
+  virtual void updateRegAllocHint(Register Reg, Register NewReg,
                                   MachineFunction &MF) const {
     // Do nothing.
   }
@@ -879,14 +867,14 @@
   /// spill slot. This tells PEI not to create a new stack frame
   /// object for the given register. It should be called only after
   /// determineCalleeSaves().
-  virtual bool hasReservedSpillSlot(const MachineFunction &MF, unsigned Reg,
+  virtual bool hasReservedSpillSlot(const MachineFunction &MF, Register Reg,
                                     int &FrameIdx) const {
     return false;
   }
 
   /// Returns true if the live-ins should be tracked after register allocation.
   virtual bool trackLivenessAfterRegAlloc(const MachineFunction &MF) const {
-    return false;
+    return true;
   }
 
   /// True if the stack can be realigned for the target.
@@ -916,7 +904,7 @@
   /// Insert defining instruction(s) for BaseReg to be a pointer to FrameIdx
   /// before insertion point I.
   virtual void materializeFrameBaseRegister(MachineBasicBlock *MBB,
-                                            unsigned BaseReg, int FrameIdx,
+                                            Register BaseReg, int FrameIdx,
                                             int64_t Offset) const {
     llvm_unreachable("materializeFrameBaseRegister does not exist on this "
                      "target");
@@ -924,18 +912,27 @@
 
   /// Resolve a frame index operand of an instruction
   /// to reference the indicated base register plus offset instead.
-  virtual void resolveFrameIndex(MachineInstr &MI, unsigned BaseReg,
+  virtual void resolveFrameIndex(MachineInstr &MI, Register BaseReg,
                                  int64_t Offset) const {
     llvm_unreachable("resolveFrameIndex does not exist on this target");
   }
 
   /// Determine whether a given base register plus offset immediate is
   /// encodable to resolve a frame index.
-  virtual bool isFrameOffsetLegal(const MachineInstr *MI, unsigned BaseReg,
+  virtual bool isFrameOffsetLegal(const MachineInstr *MI, Register BaseReg,
                                   int64_t Offset) const {
     llvm_unreachable("isFrameOffsetLegal does not exist on this target");
   }
 
+  /// Gets the DWARF expression opcodes for \p Offset.
+  virtual void getOffsetOpcodes(const StackOffset &Offset,
+                                SmallVectorImpl<uint64_t> &Ops) const;
+
+  /// Prepends a DWARF expression for \p Offset to DIExpression \p Expr.
+  DIExpression *
+  prependOffsetExpression(const DIExpression *Expr, unsigned PrependFlags,
+                          const StackOffset &Offset) const;
+
   /// Spill the register so it can be used by the register scavenger.
   /// Return true if the register was spilled, false otherwise.
   /// If this function does not spill the register, the scavenger
@@ -944,7 +941,7 @@
                                      MachineBasicBlock::iterator I,
                                      MachineBasicBlock::iterator &UseMI,
                                      const TargetRegisterClass *RC,
-                                     unsigned Reg) const {
+                                     Register Reg) const {
     return false;
   }
 
@@ -960,7 +957,7 @@
                                    RegScavenger *RS = nullptr) const = 0;
 
   /// Return the assembly name for \p Reg.
-  virtual StringRef getRegAsmName(unsigned Reg) const {
+  virtual StringRef getRegAsmName(MCRegister Reg) const {
     // FIXME: We are assuming that the assembly name is equal to the TableGen
     // name converted to lower case
     //
@@ -983,6 +980,42 @@
                               LiveIntervals &LIS) const
   { return true; }
 
+  /// Region split has a high compile time cost especially for large live range.
+  /// This method is used to decide whether or not \p VirtReg should
+  /// go through this expensive splitting heuristic.
+  virtual bool shouldRegionSplitForVirtReg(const MachineFunction &MF,
+                                           const LiveInterval &VirtReg) const;
+
+  /// Last chance recoloring has a high compile time cost especially for
+  /// targets with a lot of registers.
+  /// This method is used to decide whether or not \p VirtReg should
+  /// go through this expensive heuristic.
+  /// When this target hook is hit, by returning false, there is a high
+  /// chance that the register allocation will fail altogether (usually with
+  /// "ran out of registers").
+  /// That said, this error usually points to another problem in the
+  /// optimization pipeline.
+  virtual bool
+  shouldUseLastChanceRecoloringForVirtReg(const MachineFunction &MF,
+                                          const LiveInterval &VirtReg) const {
+    return true;
+  }
+
+  /// Deferred spilling delays the spill insertion of a virtual register
+  /// after every other allocation. By deferring the spilling, it is
+  /// sometimes possible to eliminate that spilling altogether because
+  /// something else could have been eliminated, thus leaving some space
+  /// for the virtual register.
+  /// However, this comes with a compile time impact because it adds one
+  /// more stage to the greedy register allocator.
+  /// This method is used to decide whether \p VirtReg should use the deferred
+  /// spilling stage instead of being spilled right away.
+  virtual bool
+  shouldUseDeferredSpillingForVirtReg(const MachineFunction &MF,
+                                      const LiveInterval &VirtReg) const {
+    return false;
+  }
+
   //===--------------------------------------------------------------------===//
   /// Debug information queries.
 
@@ -991,7 +1024,7 @@
   virtual Register getFrameRegister(const MachineFunction &MF) const = 0;
 
   /// Mark a register and all its aliases as reserved in the given set.
-  void markSuperRegs(BitVector &RegisterSet, unsigned Reg) const;
+  void markSuperRegs(BitVector &RegisterSet, MCRegister Reg) const;
 
   /// Returns true if for every register in the set all super registers are part
   /// of the set as well.
@@ -1003,6 +1036,13 @@
                                    const MachineRegisterInfo &MRI) const {
     return nullptr;
   }
+
+  /// Returns the physical register number of sub-register "Index"
+  /// for physical register RegNo. Return zero if the sub-register does not
+  /// exist.
+  inline MCRegister getSubReg(MCRegister Reg, unsigned Idx) const {
+    return static_cast<const MCRegisterInfo *>(this)->getSubReg(Reg, Idx);
+  }
 };
 
 //===----------------------------------------------------------------------===//
@@ -1152,9 +1192,9 @@
 
 // This is useful when building IndexedMaps keyed on virtual registers
 struct VirtReg2IndexFunctor {
-  using argument_type = unsigned;
-  unsigned operator()(unsigned Reg) const {
-    return TargetRegisterInfo::virtReg2Index(Reg);
+  using argument_type = Register;
+  unsigned operator()(Register Reg) const {
+    return Register::virtReg2Index(Reg);
   }
 };
 
@@ -1168,7 +1208,7 @@
 ///   %physreg17      - a physical register when no TRI instance given.
 ///
 /// Usage: OS << printReg(Reg, TRI, SubRegIdx) << '\n';
-Printable printReg(unsigned Reg, const TargetRegisterInfo *TRI = nullptr,
+Printable printReg(Register Reg, const TargetRegisterInfo *TRI = nullptr,
                    unsigned SubIdx = 0,
                    const MachineRegisterInfo *MRI = nullptr);
 
@@ -1188,7 +1228,7 @@
 
 /// Create Printable object to print register classes or register banks
 /// on a \ref raw_ostream.
-Printable printRegClassOrBank(unsigned Reg, const MachineRegisterInfo &RegInfo,
+Printable printRegClassOrBank(Register Reg, const MachineRegisterInfo &RegInfo,
                               const TargetRegisterInfo *TRI);
 
 } // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/CodeGen/TargetSchedule.h b/linux-x64/clang/include/llvm/CodeGen/TargetSchedule.h
index cce85c8..aa6b82e 100644
--- a/linux-x64/clang/include/llvm/CodeGen/TargetSchedule.h
+++ b/linux-x64/clang/include/llvm/CodeGen/TargetSchedule.h
@@ -37,8 +37,12 @@
   const TargetInstrInfo *TII = nullptr;
 
   SmallVector<unsigned, 16> ResourceFactors;
-  unsigned MicroOpFactor; // Multiply to normalize microops to resource units.
-  unsigned ResourceLCM;   // Resource units per cycle. Latency normalization factor.
+
+  // Multiply to normalize microops to resource units.
+  unsigned MicroOpFactor = 0;
+
+  // Resource units per cycle. Latency normalization factor.
+  unsigned ResourceLCM = 0;
 
   unsigned computeInstrLatency(const MCSchedClassDesc &SCDesc) const;
 
diff --git a/linux-x64/clang/include/llvm/CodeGen/TargetSubtargetInfo.h b/linux-x64/clang/include/llvm/CodeGen/TargetSubtargetInfo.h
index 037fc3e..3fac2f6 100644
--- a/linux-x64/clang/include/llvm/CodeGen/TargetSubtargetInfo.h
+++ b/linux-x64/clang/include/llvm/CodeGen/TargetSubtargetInfo.h
@@ -25,10 +25,10 @@
 #include <memory>
 #include <vector>
 
-
 namespace llvm {
 
 class CallLowering;
+class InlineAsmLowering;
 class InstrItineraryData;
 struct InstrStage;
 class InstructionSelector;
@@ -41,9 +41,6 @@
 class RegisterBankInfo;
 class SDep;
 class SelectionDAGTargetInfo;
-struct SubtargetFeatureKV;
-struct SubtargetSubTypeKV;
-struct SubtargetInfoKV;
 class SUnit;
 class TargetFrameLowering;
 class TargetInstrInfo;
@@ -61,8 +58,8 @@
 ///
 class TargetSubtargetInfo : public MCSubtargetInfo {
 protected: // Can only create subclasses...
-  TargetSubtargetInfo(const Triple &TT, StringRef CPU, StringRef FS,
-                      ArrayRef<SubtargetFeatureKV> PF,
+  TargetSubtargetInfo(const Triple &TT, StringRef CPU, StringRef TuneCPU,
+                      StringRef FS, ArrayRef<SubtargetFeatureKV> PF,
                       ArrayRef<SubtargetSubTypeKV> PD,
                       const MCWriteProcResEntry *WPR,
                       const MCWriteLatencyEntry *WL,
@@ -102,16 +99,18 @@
   }
   virtual const CallLowering *getCallLowering() const { return nullptr; }
 
+  virtual const InlineAsmLowering *getInlineAsmLowering() const {
+    return nullptr;
+  }
+
   // FIXME: This lets targets specialize the selector by subtarget (which lets
   // us do things like a dedicated avx512 selector).  However, we might want
   // to also specialize selectors by MachineFunction, which would let us be
   // aware of optsize/optnone and such.
-  virtual const InstructionSelector *getInstructionSelector() const {
+  virtual InstructionSelector *getInstructionSelector() const {
     return nullptr;
   }
 
-  virtual unsigned getHwMode() const { return 0; }
-
   /// Target can subclass this hook to select a different DAG scheduler.
   virtual RegisterScheduler::FunctionPassCtor
       getDAGScheduler(CodeGenOpt::Level) const {
@@ -208,6 +207,10 @@
   /// which is the preferred way to influence this.
   virtual bool enablePostRAScheduler() const;
 
+  /// True if the subtarget should run a machine scheduler after register
+  /// allocation.
+  virtual bool enablePostRAMachineScheduler() const;
+
   /// True if the subtarget should run the atomic expansion pass.
   virtual bool enableAtomicExpand() const;
 
@@ -222,9 +225,13 @@
   virtual void overrideSchedPolicy(MachineSchedPolicy &Policy,
                                    unsigned NumRegionInstrs) const {}
 
-  // Perform target specific adjustments to the latency of a schedule
+  // Perform target-specific adjustments to the latency of a schedule
   // dependency.
-  virtual void adjustSchedDependency(SUnit *def, SUnit *use, SDep &dep) const {}
+  // If a pair of operands is associated with the schedule dependency, DefOpIdx
+  // and UseOpIdx are the indices of the operands in Def and Use, respectively.
+  // Otherwise, either may be -1.
+  virtual void adjustSchedDependency(SUnit *Def, int DefOpIdx, SUnit *Use,
+                                     int UseOpIdx, SDep &Dep) const {}
 
   // For use with PostRAScheduling: get the anti-dependence breaking that should
   // be performed before post-RA scheduling.
@@ -274,6 +281,12 @@
   /// scheduling, DAGCombine, etc.).
   virtual bool useAA() const;
 
+  /// \brief Sink addresses into blocks using GEP instructions rather than
+  /// pointer casts and arithmetic.
+  virtual bool addrSinkUsingGEPs() const {
+    return useAA();
+  }
+
   /// Enable the use of the early if conversion pass.
   virtual bool enableEarlyIfConversion() const { return false; }
 
diff --git a/linux-x64/clang/include/llvm/CodeGen/TileShapeInfo.h b/linux-x64/clang/include/llvm/CodeGen/TileShapeInfo.h
new file mode 100644
index 0000000..031d235
--- /dev/null
+++ b/linux-x64/clang/include/llvm/CodeGen/TileShapeInfo.h
@@ -0,0 +1,97 @@
+//===- llvm/CodeGen/TileShapeInfo.h - ---------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+/// \file Shape utility for AMX.
+/// AMX hardware requires to config the shape of tile data register before use.
+/// The 2D shape includes row and column. In AMX intrinsics interface the shape
+/// is passed as 1st and 2nd parameter and they are lowered as the 1st and 2nd
+/// machine operand of AMX pseudo instructions. ShapeT class is to facilitate
+/// tile config and register allocator. The row and column are machine operand
+/// of AMX pseudo instructions.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CODEGEN_TILESHAPEINFO_H
+#define LLVM_CODEGEN_TILESHAPEINFO_H
+
+#include "llvm/ADT/DenseMapInfo.h"
+#include "llvm/CodeGen/MachineInstr.h"
+#include "llvm/CodeGen/MachineOperand.h"
+#include "llvm/CodeGen/MachineRegisterInfo.h"
+#include "llvm/CodeGen/Register.h"
+#include <utility>
+
+namespace llvm {
+
+class ShapeT {
+public:
+  ShapeT(MachineOperand *Row, MachineOperand *Col,
+         const MachineRegisterInfo *MRI = nullptr)
+      : Row(Row), Col(Col) {
+    if (MRI)
+      deduceImm(MRI);
+  }
+  ShapeT()
+      : Row(nullptr), Col(nullptr), RowImm(InvalidImmShape),
+        ColImm(InvalidImmShape) {}
+  bool operator==(const ShapeT &Shape) {
+    MachineOperand *R = Shape.Row;
+    MachineOperand *C = Shape.Col;
+    if (!R || !C)
+      return false;
+    if (!Row || !Col)
+      return false;
+    if (Row->getReg() == R->getReg() && Col->getReg() == C->getReg())
+      return true;
+    if ((RowImm != InvalidImmShape) && (ColImm != InvalidImmShape))
+      return RowImm == Shape.getRowImm() && ColImm == Shape.getColImm();
+    return false;
+  }
+
+  bool operator!=(const ShapeT &Shape) { return !(*this == Shape); }
+
+  MachineOperand *getRow() const { return Row; }
+
+  MachineOperand *getCol() const { return Col; }
+
+  int64_t getRowImm() const { return RowImm; }
+
+  int64_t getColImm() const { return ColImm; }
+
+  bool isValid() { return (Row != nullptr) && (Col != nullptr); }
+
+  void deduceImm(const MachineRegisterInfo *MRI) {
+    // All def must be the same value, otherwise it is invalid MIs.
+    // Find the immediate.
+    // TODO copy propagation.
+    auto GetImm = [&](Register Reg) {
+      int64_t Imm = InvalidImmShape;
+      for (const MachineOperand &DefMO : MRI->def_operands(Reg)) {
+        const auto *MI = DefMO.getParent();
+        if (MI->isMoveImmediate()) {
+          Imm = MI->getOperand(1).getImm();
+          break;
+        }
+      }
+      return Imm;
+    };
+    RowImm = GetImm(Row->getReg());
+    ColImm = GetImm(Col->getReg());
+  }
+
+private:
+  static constexpr int64_t InvalidImmShape = -1;
+  MachineOperand *Row;
+  MachineOperand *Col;
+  int64_t RowImm;
+  int64_t ColImm;
+};
+
+} // namespace llvm
+
+#endif
diff --git a/linux-x64/clang/include/llvm/CodeGen/ValueTypes.h b/linux-x64/clang/include/llvm/CodeGen/ValueTypes.h
index c540c94..888b83d 100644
--- a/linux-x64/clang/include/llvm/CodeGen/ValueTypes.h
+++ b/linux-x64/clang/include/llvm/CodeGen/ValueTypes.h
@@ -18,6 +18,8 @@
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/MachineValueType.h"
 #include "llvm/Support/MathExtras.h"
+#include "llvm/Support/TypeSize.h"
+#include "llvm/Support/WithColor.h"
 #include <cassert>
 #include <cstdint>
 #include <string>
@@ -74,38 +76,33 @@
       MVT M = MVT::getVectorVT(VT.V, NumElements, IsScalable);
       if (M.SimpleTy != MVT::INVALID_SIMPLE_VALUE_TYPE)
         return M;
-
-      assert(!IsScalable && "We don't support extended scalable types yet");
-      return getExtendedVectorVT(Context, VT, NumElements);
+      return getExtendedVectorVT(Context, VT, NumElements, IsScalable);
     }
 
     /// Returns the EVT that represents a vector EC.Min elements in length,
     /// where each element is of type VT.
-    static EVT getVectorVT(LLVMContext &Context, EVT VT, MVT::ElementCount EC) {
+    static EVT getVectorVT(LLVMContext &Context, EVT VT, ElementCount EC) {
       MVT M = MVT::getVectorVT(VT.V, EC);
       if (M.SimpleTy != MVT::INVALID_SIMPLE_VALUE_TYPE)
         return M;
-      assert (!EC.Scalable && "We don't support extended scalable types yet");
-      return getExtendedVectorVT(Context, VT, EC.Min);
+      return getExtendedVectorVT(Context, VT, EC);
     }
 
     /// Return a vector with the same number of elements as this vector, but
     /// with the element type converted to an integer type with the same
     /// bitwidth.
     EVT changeVectorElementTypeToInteger() const {
-      if (!isSimple()) {
-        assert (!isScalableVector() &&
-                "We don't support extended scalable types yet");
-        return changeExtendedVectorElementTypeToInteger();
-      }
-      MVT EltTy = getSimpleVT().getVectorElementType();
-      unsigned BitWidth = EltTy.getSizeInBits();
-      MVT IntTy = MVT::getIntegerVT(BitWidth);
-      MVT VecTy = MVT::getVectorVT(IntTy, getVectorNumElements(),
-                                   isScalableVector());
-      assert(VecTy.SimpleTy != MVT::INVALID_SIMPLE_VALUE_TYPE &&
-             "Simple vector VT not representable by simple integer vector VT!");
-      return VecTy;
+      if (isSimple())
+        return getSimpleVT().changeVectorElementTypeToInteger();
+      return changeExtendedVectorElementTypeToInteger();
+    }
+
+    /// Return a VT for a vector type whose attributes match ourselves
+    /// with the exception of the element type that is chosen by the caller.
+    EVT changeVectorElementType(EVT EltVT) const {
+      if (isSimple() && EltVT.isSimple())
+        return getSimpleVT().changeVectorElementType(EltVT.getSimpleVT());
+      return changeExtendedVectorElementType(EltVT);
     }
 
     /// Return the type converted to an equivalently sized integer or vector
@@ -116,8 +113,7 @@
         return changeVectorElementTypeToInteger();
 
       if (isSimple())
-        return MVT::getIntegerVT(getSizeInBits());
-
+        return getSimpleVT().changeTypeToInteger();
       return changeExtendedTypeToInteger();
     }
 
@@ -154,12 +150,12 @@
     /// Return true if this is a vector type where the runtime
     /// length is machine dependent
     bool isScalableVector() const {
-      // FIXME: We don't support extended scalable types yet, because the
-      // matching IR type doesn't exist. Once it has been added, this can
-      // be changed to call isExtendedScalableVector.
-      if (!isSimple())
-        return false;
-      return V.isScalableVector();
+      return isSimple() ? V.isScalableVector() : isExtendedScalableVector();
+    }
+
+    bool isFixedLengthVector() const {
+      return isSimple() ? V.isFixedLengthVector()
+                        : isExtendedFixedLengthVector();
     }
 
     /// Return true if this is a 16-bit vector type.
@@ -208,12 +204,12 @@
     }
 
     /// Return true if the bit size is a multiple of 8.
-    bool isByteSized() const {
-      return (getSizeInBits() & 7) == 0;
-    }
+    bool isByteSized() const { return getSizeInBits().isKnownMultipleOf(8); }
 
     /// Return true if the size is a power-of-two number of bytes.
     bool isRound() const {
+      if (isScalableVector())
+        return false;
       unsigned BitSize = getSizeInBits();
       return BitSize >= 8 && !(BitSize & (BitSize - 1));
     }
@@ -224,28 +220,58 @@
       return getSizeInBits() == VT.getSizeInBits();
     }
 
+    /// Return true if we know at compile time this has more bits than VT.
+    bool knownBitsGT(EVT VT) const {
+      return TypeSize::isKnownGT(getSizeInBits(), VT.getSizeInBits());
+    }
+
+    /// Return true if we know at compile time this has more than or the same
+    /// bits as VT.
+    bool knownBitsGE(EVT VT) const {
+      return TypeSize::isKnownGE(getSizeInBits(), VT.getSizeInBits());
+    }
+
+    /// Return true if we know at compile time this has fewer bits than VT.
+    bool knownBitsLT(EVT VT) const {
+      return TypeSize::isKnownLT(getSizeInBits(), VT.getSizeInBits());
+    }
+
+    /// Return true if we know at compile time this has fewer than or the same
+    /// bits as VT.
+    bool knownBitsLE(EVT VT) const {
+      return TypeSize::isKnownLE(getSizeInBits(), VT.getSizeInBits());
+    }
+
     /// Return true if this has more bits than VT.
     bool bitsGT(EVT VT) const {
       if (EVT::operator==(VT)) return false;
-      return getSizeInBits() > VT.getSizeInBits();
+      assert(isScalableVector() == VT.isScalableVector() &&
+             "Comparison between scalable and fixed types");
+      return knownBitsGT(VT);
     }
 
     /// Return true if this has no less bits than VT.
     bool bitsGE(EVT VT) const {
       if (EVT::operator==(VT)) return true;
-      return getSizeInBits() >= VT.getSizeInBits();
+      assert(isScalableVector() == VT.isScalableVector() &&
+             "Comparison between scalable and fixed types");
+      return knownBitsGE(VT);
     }
 
     /// Return true if this has less bits than VT.
     bool bitsLT(EVT VT) const {
       if (EVT::operator==(VT)) return false;
-      return getSizeInBits() < VT.getSizeInBits();
+      assert(isScalableVector() == VT.isScalableVector() &&
+             "Comparison between scalable and fixed types");
+      return knownBitsLT(VT);
     }
 
     /// Return true if this has no more bits than VT.
     bool bitsLE(EVT VT) const {
       if (EVT::operator==(VT)) return true;
-      return getSizeInBits() <= VT.getSizeInBits();
+      assert(isScalableVector() == VT.isScalableVector() &&
+             "Comparison between scalable and fixed types");
+      return knownBitsLE(VT);
     }
 
     /// Return the SimpleValueType held in the specified simple EVT.
@@ -270,43 +296,74 @@
 
     /// Given a vector type, return the number of elements it contains.
     unsigned getVectorNumElements() const {
+#ifdef STRICT_FIXED_SIZE_VECTORS
+      assert(isFixedLengthVector() && "Invalid vector type!");
+#else
       assert(isVector() && "Invalid vector type!");
+      if (isScalableVector())
+        WithColor::warning()
+            << "Possible incorrect use of EVT::getVectorNumElements() for "
+               "scalable vector. Scalable flag may be dropped, use "
+               "EVT::getVectorElementCount() instead\n";
+#endif
       if (isSimple())
         return V.getVectorNumElements();
       return getExtendedVectorNumElements();
     }
 
     // Given a (possibly scalable) vector type, return the ElementCount
-    MVT::ElementCount getVectorElementCount() const {
+    ElementCount getVectorElementCount() const {
       assert((isVector()) && "Invalid vector type!");
       if (isSimple())
         return V.getVectorElementCount();
 
-      assert(!isScalableVector() &&
-             "We don't support extended scalable types yet");
-      return {getExtendedVectorNumElements(), false};
+      return getExtendedVectorElementCount();
+    }
+
+    /// Given a vector type, return the minimum number of elements it contains.
+    unsigned getVectorMinNumElements() const {
+      return getVectorElementCount().getKnownMinValue();
     }
 
     /// Return the size of the specified value type in bits.
-    unsigned getSizeInBits() const {
+    ///
+    /// If the value type is a scalable vector type, the scalable property will
+    /// be set and the runtime size will be a positive integer multiple of the
+    /// base size.
+    TypeSize getSizeInBits() const {
       if (isSimple())
         return V.getSizeInBits();
       return getExtendedSizeInBits();
     }
 
-    unsigned getScalarSizeInBits() const {
-      return getScalarType().getSizeInBits();
+    /// Return the size of the specified fixed width value type in bits. The
+    /// function will assert if the type is scalable.
+    uint64_t getFixedSizeInBits() const {
+      return getSizeInBits().getFixedSize();
+    }
+
+    uint64_t getScalarSizeInBits() const {
+      return getScalarType().getSizeInBits().getFixedSize();
     }
 
     /// Return the number of bytes overwritten by a store of the specified value
     /// type.
-    unsigned getStoreSize() const {
-      return (getSizeInBits() + 7) / 8;
+    ///
+    /// If the value type is a scalable vector type, the scalable property will
+    /// be set and the runtime size will be a positive integer multiple of the
+    /// base size.
+    TypeSize getStoreSize() const {
+      TypeSize BaseSize = getSizeInBits();
+      return {(BaseSize.getKnownMinSize() + 7) / 8, BaseSize.isScalable()};
     }
 
     /// Return the number of bits overwritten by a store of the specified value
     /// type.
-    unsigned getStoreSizeInBits() const {
+    ///
+    /// If the value type is a scalable vector type, the scalable property will
+    /// be set and the runtime size will be a positive integer multiple of the
+    /// base size.
+    TypeSize getStoreSizeInBits() const {
       return getStoreSize() * 8;
     }
 
@@ -350,13 +407,22 @@
     EVT getHalfNumVectorElementsVT(LLVMContext &Context) const {
       EVT EltVT = getVectorElementType();
       auto EltCnt = getVectorElementCount();
-      assert(!(EltCnt.Min & 1) && "Splitting vector, but not in half!");
-      return EVT::getVectorVT(Context, EltVT, EltCnt / 2);
+      assert(EltCnt.isKnownEven() && "Splitting vector, but not in half!");
+      return EVT::getVectorVT(Context, EltVT, EltCnt.divideCoefficientBy(2));
+    }
+
+    // Return a VT for a vector type with the same element type but
+    // double the number of elements. The type returned may be an
+    // extended type.
+    EVT getDoubleNumVectorElementsVT(LLVMContext &Context) const {
+      EVT EltVT = getVectorElementType();
+      auto EltCnt = getVectorElementCount();
+      return EVT::getVectorVT(Context, EltVT, EltCnt * 2);
     }
 
     /// Returns true if the given vector is a power of 2.
     bool isPow2VectorType() const {
-      unsigned NElts = getVectorNumElements();
+      unsigned NElts = getVectorMinNumElements();
       return !(NElts & (NElts - 1));
     }
 
@@ -364,10 +430,10 @@
     /// and returns that type.
     EVT getPow2VectorType(LLVMContext &Context) const {
       if (!isPow2VectorType()) {
-        unsigned NElts = getVectorNumElements();
-        unsigned Pow2NElts = 1 <<  Log2_32_Ceil(NElts);
-        return EVT::getVectorVT(Context, getVectorElementType(), Pow2NElts,
-                                isScalableVector());
+        ElementCount NElts = getVectorElementCount();
+        unsigned NewMinCount = 1 << Log2_32_Ceil(NElts.getKnownMinValue());
+        NElts = ElementCount::get(NewMinCount, NElts.isScalable());
+        return EVT::getVectorVT(Context, getVectorElementType(), NElts);
       }
       else {
         return *this;
@@ -410,10 +476,13 @@
     // These are all out-of-line to prevent users of this header file
     // from having a dependency on Type.h.
     EVT changeExtendedTypeToInteger() const;
+    EVT changeExtendedVectorElementType(EVT EltVT) const;
     EVT changeExtendedVectorElementTypeToInteger() const;
     static EVT getExtendedIntegerVT(LLVMContext &C, unsigned BitWidth);
-    static EVT getExtendedVectorVT(LLVMContext &C, EVT VT,
-                                   unsigned NumElements);
+    static EVT getExtendedVectorVT(LLVMContext &C, EVT VT, unsigned NumElements,
+                                   bool IsScalable);
+    static EVT getExtendedVectorVT(LLVMContext &Context, EVT VT,
+                                   ElementCount EC);
     bool isExtendedFloatingPoint() const LLVM_READONLY;
     bool isExtendedInteger() const LLVM_READONLY;
     bool isExtendedScalarInteger() const LLVM_READONLY;
@@ -426,9 +495,12 @@
     bool isExtended512BitVector() const LLVM_READONLY;
     bool isExtended1024BitVector() const LLVM_READONLY;
     bool isExtended2048BitVector() const LLVM_READONLY;
+    bool isExtendedFixedLengthVector() const LLVM_READONLY;
+    bool isExtendedScalableVector() const LLVM_READONLY;
     EVT getExtendedVectorElementType() const;
     unsigned getExtendedVectorNumElements() const LLVM_READONLY;
-    unsigned getExtendedSizeInBits() const LLVM_READONLY;
+    ElementCount getExtendedVectorElementCount() const LLVM_READONLY;
+    TypeSize getExtendedSizeInBits() const LLVM_READONLY;
   };
 
 } // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/CodeGen/ValueTypes.td b/linux-x64/clang/include/llvm/CodeGen/ValueTypes.td
index feea7e5..d13d0a7 100644
--- a/linux-x64/clang/include/llvm/CodeGen/ValueTypes.td
+++ b/linux-x64/clang/include/llvm/CodeGen/ValueTypes.td
@@ -25,142 +25,179 @@
 def i32    : ValueType<32 ,  5>;   // 32-bit integer value
 def i64    : ValueType<64 ,  6>;   // 64-bit integer value
 def i128   : ValueType<128,  7>;   // 128-bit integer value
-def f16    : ValueType<16 ,  8>;   // 16-bit floating point value
-def f32    : ValueType<32 ,  9>;   // 32-bit floating point value
-def f64    : ValueType<64 , 10>;   // 64-bit floating point value
-def f80    : ValueType<80 , 11>;   // 80-bit floating point value
-def f128   : ValueType<128, 12>;   // 128-bit floating point value
-def ppcf128: ValueType<128, 13>;   // PPC 128-bit floating point value
 
-def v1i1   : ValueType<1 ,  14>;   //   1 x i1 vector value
-def v2i1   : ValueType<2 ,  15>;   //   2 x i1 vector value
-def v4i1   : ValueType<4 ,  16>;   //   4 x i1 vector value
-def v8i1   : ValueType<8 ,  17>;   //   8 x i1 vector value
-def v16i1  : ValueType<16,  18>;   //  16 x i1 vector value
-def v32i1  : ValueType<32 , 19>;   //  32 x i1 vector value
-def v64i1  : ValueType<64 , 20>;   //  64 x i1 vector value
-def v128i1 : ValueType<128, 21>;   // 128 x i1 vector value
-def v512i1 : ValueType<512, 22>;   // 512 x i1 vector value
-def v1024i1: ValueType<1024,23>;   //1024 x i1 vector value
+def bf16   : ValueType<16 ,  8>;   // 16-bit brain floating point value
+def f16    : ValueType<16 ,  9>;   // 16-bit floating point value
+def f32    : ValueType<32 , 10>;   // 32-bit floating point value
+def f64    : ValueType<64 , 11>;   // 64-bit floating point value
+def f80    : ValueType<80 , 12>;   // 80-bit floating point value
+def f128   : ValueType<128, 13>;   // 128-bit floating point value
+def ppcf128: ValueType<128, 14>;   // PPC 128-bit floating point value
 
-def v1i8   : ValueType<8,   24>;   //  1 x i8  vector value
-def v2i8   : ValueType<16 , 25>;   //  2 x i8  vector value
-def v4i8   : ValueType<32 , 26>;   //  4 x i8  vector value
-def v8i8   : ValueType<64 , 27>;   //  8 x i8  vector value
-def v16i8  : ValueType<128, 28>;   // 16 x i8  vector value
-def v32i8  : ValueType<256, 29>;   // 32 x i8  vector value
-def v64i8  : ValueType<512, 30>;   // 64 x i8  vector value
-def v128i8 : ValueType<1024,31>;   //128 x i8  vector value
-def v256i8 : ValueType<2048,32>;   //256 x i8  vector value
+def v1i1   : ValueType<1 ,  15>;   //   1 x i1 vector value
+def v2i1   : ValueType<2 ,  16>;   //   2 x i1 vector value
+def v4i1   : ValueType<4 ,  17>;   //   4 x i1 vector value
+def v8i1   : ValueType<8 ,  18>;   //   8 x i1 vector value
+def v16i1  : ValueType<16,  19>;   //  16 x i1 vector value
+def v32i1  : ValueType<32 , 20>;   //  32 x i1 vector value
+def v64i1  : ValueType<64 , 21>;   //  64 x i1 vector value
+def v128i1 : ValueType<128, 22>;   // 128 x i1 vector value
+def v256i1 : ValueType<256, 23>;   // 256 x i1 vector value
+def v512i1 : ValueType<512, 24>;   // 512 x i1 vector value
+def v1024i1: ValueType<1024,25>;   //1024 x i1 vector value
 
-def v1i16  : ValueType<16 , 33>;   //  1 x i16 vector value
-def v2i16  : ValueType<32 , 34>;   //  2 x i16 vector value
-def v4i16  : ValueType<64 , 35>;   //  4 x i16 vector value
-def v8i16  : ValueType<128, 36>;   //  8 x i16 vector value
-def v16i16 : ValueType<256, 37>;   // 16 x i16 vector value
-def v32i16 : ValueType<512, 38>;   // 32 x i16 vector value
-def v64i16 : ValueType<1024,39>;   // 64 x i16 vector value
-def v128i16: ValueType<2048,40>;   //128 x i16 vector value
+def v1i8   : ValueType<8,   26>;   //  1 x i8  vector value
+def v2i8   : ValueType<16 , 27>;   //  2 x i8  vector value
+def v4i8   : ValueType<32 , 28>;   //  4 x i8  vector value
+def v8i8   : ValueType<64 , 29>;   //  8 x i8  vector value
+def v16i8  : ValueType<128, 30>;   // 16 x i8  vector value
+def v32i8  : ValueType<256, 31>;   // 32 x i8  vector value
+def v64i8  : ValueType<512, 32>;   // 64 x i8  vector value
+def v128i8 : ValueType<1024,33>;   //128 x i8  vector value
+def v256i8 : ValueType<2048,34>;   //256 x i8  vector value
 
-def v1i32    : ValueType<32 , 41>;   //  1 x i32 vector value
-def v2i32    : ValueType<64 , 42>;   //  2 x i32 vector value
-def v3i32    : ValueType<96 , 43>;   //  3 x i32 vector value
-def v4i32    : ValueType<128, 44>;   //  4 x i32 vector value
-def v5i32    : ValueType<160, 45>;   //  5 x i32 vector value
-def v8i32    : ValueType<256, 46>;   //  8 x i32 vector value
-def v16i32   : ValueType<512, 47>;   // 16 x i32 vector value
-def v32i32   : ValueType<1024,48>;   // 32 x i32 vector value
-def v64i32   : ValueType<2048,49>;   // 64 x i32 vector value
-def v128i32  : ValueType<4096,50>;   // 128 x i32 vector value
-def v256i32  : ValueType<8182,51>;   // 256 x i32 vector value
-def v512i32  : ValueType<16384,52>;  // 512 x i32 vector value
-def v1024i32 : ValueType<32768,53>;  // 1024 x i32 vector value
-def v2048i32 : ValueType<65536,54>;  // 2048 x i32 vector value
+def v1i16  : ValueType<16 , 35>;   //  1 x i16 vector value
+def v2i16  : ValueType<32 , 36>;   //  2 x i16 vector value
+def v3i16  : ValueType<48 , 37>;   //  3 x i16 vector value
+def v4i16  : ValueType<64 , 38>;   //  4 x i16 vector value
+def v8i16  : ValueType<128, 39>;   //  8 x i16 vector value
+def v16i16 : ValueType<256, 40>;   // 16 x i16 vector value
+def v32i16 : ValueType<512, 41>;   // 32 x i16 vector value
+def v64i16 : ValueType<1024,42>;   // 64 x i16 vector value
+def v128i16: ValueType<2048,43>;   //128 x i16 vector value
 
-def v1i64  : ValueType<64 , 55>;   //  1 x i64 vector value
-def v2i64  : ValueType<128, 56>;   //  2 x i64 vector value
-def v4i64  : ValueType<256, 57>;   //  4 x i64 vector value
-def v8i64  : ValueType<512, 58>;   //  8 x i64 vector value
-def v16i64 : ValueType<1024,59>;   // 16 x i64 vector value
-def v32i64 : ValueType<2048,60>;   // 32 x i64 vector value
+def v1i32    : ValueType<32 , 44>;   //  1 x i32 vector value
+def v2i32    : ValueType<64 , 45>;   //  2 x i32 vector value
+def v3i32    : ValueType<96 , 46>;   //  3 x i32 vector value
+def v4i32    : ValueType<128, 47>;   //  4 x i32 vector value
+def v5i32    : ValueType<160, 48>;   //  5 x i32 vector value
+def v8i32    : ValueType<256, 49>;   //  8 x i32 vector value
+def v16i32   : ValueType<512, 50>;   // 16 x i32 vector value
+def v32i32   : ValueType<1024,51>;   // 32 x i32 vector value
+def v64i32   : ValueType<2048,52>;   // 64 x i32 vector value
+def v128i32  : ValueType<4096,53>;   // 128 x i32 vector value
+def v256i32  : ValueType<8182,54>;   // 256 x i32 vector value
+def v512i32  : ValueType<16384,55>;  // 512 x i32 vector value
+def v1024i32 : ValueType<32768,56>;  // 1024 x i32 vector value
+def v2048i32 : ValueType<65536,57>;  // 2048 x i32 vector value
 
-def v1i128 : ValueType<128, 61>;   //  1 x i128 vector value
+def v1i64  : ValueType<64 , 58>;   //  1 x i64 vector value
+def v2i64  : ValueType<128, 59>;   //  2 x i64 vector value
+def v4i64  : ValueType<256, 60>;   //  4 x i64 vector value
+def v8i64  : ValueType<512, 61>;   //  8 x i64 vector value
+def v16i64 : ValueType<1024,62>;   // 16 x i64 vector value
+def v32i64 : ValueType<2048,63>;   // 32 x i64 vector value
+def v64i64 : ValueType<4096,64>;   // 64 x i64 vector value
+def v128i64: ValueType<8192,65>;   // 128 x i64 vector value
+def v256i64: ValueType<16384,66>;  // 256 x i64 vector value
 
-def nxv1i1  : ValueType<1,   62>;  // n x  1 x i1  vector value
-def nxv2i1  : ValueType<2,   63>;  // n x  2 x i1  vector value
-def nxv4i1  : ValueType<4,   64>;  // n x  4 x i1  vector value
-def nxv8i1  : ValueType<8,   65>;  // n x  8 x i1  vector value
-def nxv16i1 : ValueType<16,  66>;  // n x 16 x i1  vector value
-def nxv32i1 : ValueType<32,  67>;  // n x 32 x i1  vector value
+def v1i128 : ValueType<128, 67>;   //  1 x i128 vector value
 
-def nxv1i8  : ValueType<8,   68>;  // n x  1 x i8  vector value
-def nxv2i8  : ValueType<16,  69>;  // n x  2 x i8  vector value
-def nxv4i8  : ValueType<32,  70>;  // n x  4 x i8  vector value
-def nxv8i8  : ValueType<64,  71>;  // n x  8 x i8  vector value
-def nxv16i8 : ValueType<128, 72>;  // n x 16 x i8  vector value
-def nxv32i8 : ValueType<256, 73>;  // n x 32 x i8  vector value
+def v2f16    : ValueType<32 , 68>;    //    2 x f16 vector value
+def v3f16    : ValueType<48 , 69>;    //    3 x f16 vector value
+def v4f16    : ValueType<64 , 70>;    //    4 x f16 vector value
+def v8f16    : ValueType<128, 71>;    //    8 x f16 vector value
+def v16f16   : ValueType<256, 72>;    //   16 x f16 vector value
+def v32f16   : ValueType<512, 73>;    //   32 x f16 vector value
+def v64f16   : ValueType<1024, 74>;   //   64 x f16 vector value
+def v128f16  : ValueType<2048, 75>;   //  128 x f16 vector value
+def v2bf16   : ValueType<32 , 76>;    //    2 x bf16 vector value
+def v3bf16   : ValueType<48 , 77>;    //    3 x bf16 vector value
+def v4bf16   : ValueType<64 , 78>;    //    4 x bf16 vector value
+def v8bf16   : ValueType<128, 79>;    //    8 x bf16 vector value
+def v16bf16  : ValueType<256, 80>;    //   16 x bf16 vector value
+def v32bf16  : ValueType<512, 81>;    //   32 x bf16 vector value
+def v64bf16  : ValueType<1024, 82>;   //   64 x bf16 vector value
+def v128bf16 : ValueType<2048, 83>;   //  128 x bf16 vector value
+def v1f32    : ValueType<32 , 84>;    //    1 x f32 vector value
+def v2f32    : ValueType<64 , 85>;    //    2 x f32 vector value
+def v3f32    : ValueType<96 , 86>;    //    3 x f32 vector value
+def v4f32    : ValueType<128, 87>;    //    4 x f32 vector value
+def v5f32    : ValueType<160, 88>;    //    5 x f32 vector value
+def v8f32    : ValueType<256, 89>;    //    8 x f32 vector value
+def v16f32   : ValueType<512,  90>;   //   16 x f32 vector value
+def v32f32   : ValueType<1024, 91>;   //   32 x f32 vector value
+def v64f32   : ValueType<2048, 92>;   //   64 x f32 vector value
+def v128f32  : ValueType<4096, 93>;   //  128 x f32 vector value
+def v256f32  : ValueType<8182, 94>;   //  256 x f32 vector value
+def v512f32  : ValueType<16384, 95>;  //  512 x f32 vector value
+def v1024f32 : ValueType<32768, 96>;  // 1024 x f32 vector value
+def v2048f32 : ValueType<65536, 97>;  // 2048 x f32 vector value
+def v1f64    : ValueType<64, 98>;     //    1 x f64 vector value
+def v2f64    : ValueType<128, 99>;    //    2 x f64 vector value
+def v4f64    : ValueType<256, 100>;    //    4 x f64 vector value
+def v8f64    : ValueType<512, 101>;    //    8 x f64 vector value
+def v16f64   : ValueType<1024, 102>;   //   16 x f64 vector value
+def v32f64   : ValueType<2048, 103>;  //   32 x f64 vector value
+def v64f64   : ValueType<4096, 104>;  //   64 x f64 vector value
+def v128f64  : ValueType<8192, 105>;  //  128 x f64 vector value
+def v256f64  : ValueType<16384, 106>; //  256 x f64 vector value
 
-def nxv1i16 : ValueType<16,  74>;  // n x  1 x i16 vector value
-def nxv2i16 : ValueType<32,  75>;  // n x  2 x i16 vector value
-def nxv4i16 : ValueType<64,  76>;  // n x  4 x i16 vector value
-def nxv8i16 : ValueType<128, 77>;  // n x  8 x i16 vector value
-def nxv16i16: ValueType<256, 78>;  // n x 16 x i16 vector value
-def nxv32i16: ValueType<512, 79>;  // n x 32 x i16 vector value
+def nxv1i1  : ValueType<1,  107>;  // n x  1 x i1  vector value
+def nxv2i1  : ValueType<2,  108>;  // n x  2 x i1  vector value
+def nxv4i1  : ValueType<4,  109>;  // n x  4 x i1  vector value
+def nxv8i1  : ValueType<8,  110>;  // n x  8 x i1  vector value
+def nxv16i1 : ValueType<16, 111>;  // n x 16 x i1  vector value
+def nxv32i1 : ValueType<32, 112>;  // n x 32 x i1  vector value
+def nxv64i1  : ValueType<64,113>;  // n x  64 x i1  vector value
 
-def nxv1i32 : ValueType<32,  80>;  // n x  1 x i32 vector value
-def nxv2i32 : ValueType<64,  81>;  // n x  2 x i32 vector value
-def nxv4i32 : ValueType<128, 82>;  // n x  4 x i32 vector value
-def nxv8i32 : ValueType<256, 83>;  // n x  8 x i32 vector value
-def nxv16i32: ValueType<512, 84>;  // n x 16 x i32 vector value
-def nxv32i32: ValueType<1024,85>;  // n x 32 x i32 vector value
+def nxv1i8  : ValueType<8,   114>;  // n x  1 x i8  vector value
+def nxv2i8  : ValueType<16,  115>;  // n x  2 x i8  vector value
+def nxv4i8  : ValueType<32,  116>;  // n x  4 x i8  vector value
+def nxv8i8  : ValueType<64,  117>;  // n x  8 x i8  vector value
+def nxv16i8 : ValueType<128, 118>;  // n x 16 x i8  vector value
+def nxv32i8 : ValueType<256, 119>;  // n x 32 x i8  vector value
+def nxv64i8  : ValueType<512,  120>;  // n x  64 x i8  vector value
 
-def nxv1i64 : ValueType<64,  86>;  // n x  1 x i64 vector value
-def nxv2i64 : ValueType<128, 87>;  // n x  2 x i64 vector value
-def nxv4i64 : ValueType<256, 88>;  // n x  4 x i64 vector value
-def nxv8i64 : ValueType<512, 89>;  // n x  8 x i64 vector value
-def nxv16i64: ValueType<1024,90>;  // n x 16 x i64 vector value
-def nxv32i64: ValueType<2048,91>;  // n x 32 x i64 vector value
+def nxv1i16 : ValueType<16,  121>; // n x  1 x i16 vector value
+def nxv2i16 : ValueType<32,  122>; // n x  2 x i16 vector value
+def nxv4i16 : ValueType<64,  123>; // n x  4 x i16 vector value
+def nxv8i16 : ValueType<128, 124>; // n x  8 x i16 vector value
+def nxv16i16: ValueType<256, 125>; // n x 16 x i16 vector value
+def nxv32i16: ValueType<512, 126>; // n x 32 x i16 vector value
 
-def v2f16    : ValueType<32 , 92>;    //    2 x f16 vector value
-def v4f16    : ValueType<64 , 93>;    //    4 x f16 vector value
-def v8f16    : ValueType<128, 94>;    //    8 x f16 vector value
-def v1f32    : ValueType<32 , 95>;    //    1 x f32 vector value
-def v2f32    : ValueType<64 , 96>;    //    2 x f32 vector value
-def v3f32    : ValueType<96 , 97>;    //    3 x f32 vector value
-def v4f32    : ValueType<128, 98>;    //    4 x f32 vector value
-def v5f32    : ValueType<160, 99>;    //    5 x f32 vector value
-def v8f32    : ValueType<256, 100>;   //    8 x f32 vector value
-def v16f32   : ValueType<512,  101>;  //   16 x f32 vector value
-def v32f32   : ValueType<1024, 102>;  //   32 x f32 vector value
-def v64f32   : ValueType<2048, 103>;  //   64 x f32 vector value
-def v128f32  : ValueType<4096, 104>;  //  128 x f32 vector value
-def v256f32  : ValueType<8182, 105>;  //  256 x f32 vector value
-def v512f32  : ValueType<16384, 106>; //  512 x f32 vector value
-def v1024f32 : ValueType<32768, 107>; // 1024 x f32 vector value
-def v2048f32 : ValueType<65536, 108>; // 2048 x f32 vector value
-def v1f64    : ValueType<64, 109>;    //    1 x f64 vector value
-def v2f64    : ValueType<128, 110>;   //    2 x f64 vector value
-def v4f64    : ValueType<256, 111>;   //    4 x f64 vector value
-def v8f64    : ValueType<512, 112>;   //    8 x f64 vector value
+def nxv1i32 : ValueType<32,  127>; // n x  1 x i32 vector value
+def nxv2i32 : ValueType<64,  128>; // n x  2 x i32 vector value
+def nxv4i32 : ValueType<128, 129>; // n x  4 x i32 vector value
+def nxv8i32 : ValueType<256, 130>; // n x  8 x i32 vector value
+def nxv16i32: ValueType<512, 131>; // n x 16 x i32 vector value
+def nxv32i32: ValueType<1024,132>; // n x 32 x i32 vector value
 
-def nxv2f16  : ValueType<32 , 113>; // n x  2 x f16 vector value
-def nxv4f16  : ValueType<64 , 114>; // n x  4 x f16 vector value
-def nxv8f16  : ValueType<128, 115>; // n x  8 x f16 vector value
-def nxv1f32  : ValueType<32 , 116>; // n x  1 x f32 vector value
-def nxv2f32  : ValueType<64 , 117>; // n x  2 x f32 vector value
-def nxv4f32  : ValueType<128, 118>; // n x  4 x f32 vector value
-def nxv8f32  : ValueType<256, 119>; // n x  8 x f32 vector value
-def nxv16f32 : ValueType<512, 120>; // n x 16 x f32 vector value
-def nxv1f64  : ValueType<64,  121>; // n x  1 x f64 vector value
-def nxv2f64  : ValueType<128, 122>; // n x  2 x f64 vector value
-def nxv4f64  : ValueType<256, 123>; // n x  4 x f64 vector value
-def nxv8f64  : ValueType<512, 124>; // n x  8 x f64 vector value
+def nxv1i64 : ValueType<64,  133>; // n x  1 x i64 vector value
+def nxv2i64 : ValueType<128, 134>; // n x  2 x i64 vector value
+def nxv4i64 : ValueType<256, 135>; // n x  4 x i64 vector value
+def nxv8i64 : ValueType<512, 136>; // n x  8 x i64 vector value
+def nxv16i64: ValueType<1024,137>; // n x 16 x i64 vector value
+def nxv32i64: ValueType<2048,138>; // n x 32 x i64 vector value
 
-def x86mmx : ValueType<64 , 125>;   // X86 MMX value
-def FlagVT : ValueType<0  , 126>;   // Pre-RA sched glue
-def isVoid : ValueType<0  , 127>;   // Produces no value
-def untyped: ValueType<8  , 128>;   // Produces an untyped value
-def ExceptRef: ValueType<0, 129>;   // WebAssembly's except_ref type
+def nxv1f16   : ValueType<32, 139>; // n x   1 x f16 vector value
+def nxv2f16  : ValueType<32 , 140>; // n x  2 x f16 vector value
+def nxv4f16  : ValueType<64 , 141>; // n x  4 x f16 vector value
+def nxv8f16  : ValueType<128, 142>; // n x  8 x f16 vector value
+def nxv16f16  : ValueType<256,143>; // n x  16 x f16 vector value
+def nxv32f16  : ValueType<512,144>; // n x  32 x f16 vector value
+def nxv2bf16 : ValueType<32 , 145>; // n x  2 x bf16 vector value
+def nxv4bf16 : ValueType<64 , 146>; // n x  4 x bf16 vector value
+def nxv8bf16 : ValueType<128, 147>; // n x  8 x bf16 vector value
+def nxv1f32  : ValueType<32 , 148>; // n x  1 x f32 vector value
+def nxv2f32  : ValueType<64 , 149>; // n x  2 x f32 vector value
+def nxv4f32  : ValueType<128, 150>; // n x  4 x f32 vector value
+def nxv8f32  : ValueType<256, 151>; // n x  8 x f32 vector value
+def nxv16f32 : ValueType<512, 152>; // n x 16 x f32 vector value
+def nxv1f64  : ValueType<64,  153>; // n x  1 x f64 vector value
+def nxv2f64  : ValueType<128, 154>; // n x  2 x f64 vector value
+def nxv4f64  : ValueType<256, 155>; // n x  4 x f64 vector value
+def nxv8f64  : ValueType<512, 156>; // n x  8 x f64 vector value
+
+def x86mmx : ValueType<64 , 157>;   // X86 MMX value
+def FlagVT : ValueType<0  , 158>;   // Pre-RA sched glue
+def isVoid : ValueType<0  , 159>;   // Produces no value
+def untyped: ValueType<8  , 160>;   // Produces an untyped value
+def funcref : ValueType<0  , 161>;   // WebAssembly's funcref type
+def externref : ValueType<0  , 162>;   // WebAssembly's externref type
+def x86amx : ValueType<8192, 163>;   // X86 AMX value
+
+
 def token  : ValueType<0  , 248>;   // TokenTy
 def MetadataVT: ValueType<0, 249>;  // Metadata
 
diff --git a/linux-x64/clang/include/llvm/CodeGen/VirtRegMap.h b/linux-x64/clang/include/llvm/CodeGen/VirtRegMap.h
index 7a64d67..deef4b9 100644
--- a/linux-x64/clang/include/llvm/CodeGen/VirtRegMap.h
+++ b/linux-x64/clang/include/llvm/CodeGen/VirtRegMap.h
@@ -19,7 +19,7 @@
 #include "llvm/ADT/IndexedMap.h"
 #include "llvm/CodeGen/MachineFunctionPass.h"
 #include "llvm/CodeGen/TargetRegisterInfo.h"
-#include "llvm/MC/MCRegisterInfo.h"
+#include "llvm/CodeGen/TileShapeInfo.h"
 #include "llvm/Pass.h"
 #include <cassert>
 
@@ -49,7 +49,7 @@
     /// it; even spilled virtual registers (the register mapped to a
     /// spilled register is the temporary used to load it from the
     /// stack).
-    IndexedMap<unsigned, VirtReg2IndexFunctor> Virt2PhysMap;
+    IndexedMap<Register, VirtReg2IndexFunctor> Virt2PhysMap;
 
     /// Virt2StackSlotMap - This is virtual register to stack slot
     /// mapping. Each spilled virtual register has an entry in it
@@ -61,14 +61,20 @@
     /// mapping.
     IndexedMap<unsigned, VirtReg2IndexFunctor> Virt2SplitMap;
 
+    /// Virt2ShapeMap - For X86 AMX register whose register is bound shape
+    /// information.
+    DenseMap<unsigned, ShapeT> Virt2ShapeMap;
+
     /// createSpillSlot - Allocate a spill slot for RC from MFI.
     unsigned createSpillSlot(const TargetRegisterClass *RC);
 
   public:
     static char ID;
 
-    VirtRegMap() : MachineFunctionPass(ID), Virt2PhysMap(NO_PHYS_REG),
-                   Virt2StackSlotMap(NO_STACK_SLOT), Virt2SplitMap(0) {}
+    VirtRegMap()
+        : MachineFunctionPass(ID), MRI(nullptr), TII(nullptr), TRI(nullptr),
+          MF(nullptr), Virt2PhysMap(NO_PHYS_REG),
+          Virt2StackSlotMap(NO_STACK_SLOT), Virt2SplitMap(0) {}
     VirtRegMap(const VirtRegMap &) = delete;
     VirtRegMap &operator=(const VirtRegMap &) = delete;
 
@@ -91,28 +97,43 @@
 
     /// returns true if the specified virtual register is
     /// mapped to a physical register
-    bool hasPhys(unsigned virtReg) const {
+    bool hasPhys(Register virtReg) const {
       return getPhys(virtReg) != NO_PHYS_REG;
     }
 
     /// returns the physical register mapped to the specified
     /// virtual register
-    Register getPhys(Register virtReg) const {
+    MCRegister getPhys(Register virtReg) const {
       assert(virtReg.isVirtual());
-      return Virt2PhysMap[virtReg];
+      return MCRegister::from(Virt2PhysMap[virtReg.id()]);
     }
 
     /// creates a mapping for the specified virtual register to
     /// the specified physical register
-    void assignVirt2Phys(unsigned virtReg, MCPhysReg physReg);
+    void assignVirt2Phys(Register virtReg, MCPhysReg physReg);
+
+    bool isShapeMapEmpty() const { return Virt2ShapeMap.empty(); }
+
+    bool hasShape(Register virtReg) const {
+      return getShape(virtReg).isValid();
+    }
+
+    ShapeT getShape(Register virtReg) const {
+      assert(virtReg.isVirtual());
+      return Virt2ShapeMap.lookup(virtReg);
+    }
+
+    void assignVirt2Shape(Register virtReg, ShapeT shape) {
+      Virt2ShapeMap[virtReg.id()] = shape;
+    }
 
     /// clears the specified virtual register's, physical
     /// register mapping
-    void clearVirt(unsigned virtReg) {
-      assert(TargetRegisterInfo::isVirtualRegister(virtReg));
-      assert(Virt2PhysMap[virtReg] != NO_PHYS_REG &&
+    void clearVirt(Register virtReg) {
+      assert(virtReg.isVirtual());
+      assert(Virt2PhysMap[virtReg.id()] != NO_PHYS_REG &&
              "attempt to clear a not assigned virtual register");
-      Virt2PhysMap[virtReg] = NO_PHYS_REG;
+      Virt2PhysMap[virtReg.id()] = NO_PHYS_REG;
     }
 
     /// clears all virtual to physical register mappings
@@ -122,56 +143,60 @@
     }
 
     /// returns true if VirtReg is assigned to its preferred physreg.
-    bool hasPreferredPhys(unsigned VirtReg);
+    bool hasPreferredPhys(Register VirtReg);
 
     /// returns true if VirtReg has a known preferred register.
     /// This returns false if VirtReg has a preference that is a virtual
     /// register that hasn't been assigned yet.
-    bool hasKnownPreference(unsigned VirtReg);
+    bool hasKnownPreference(Register VirtReg);
 
     /// records virtReg is a split live interval from SReg.
-    void setIsSplitFromReg(unsigned virtReg, unsigned SReg) {
-      Virt2SplitMap[virtReg] = SReg;
+    void setIsSplitFromReg(Register virtReg, Register SReg) {
+      Virt2SplitMap[virtReg.id()] = SReg;
+      if (hasShape(SReg)) {
+        Virt2ShapeMap[virtReg.id()] = getShape(SReg);
+      }
     }
 
     /// returns the live interval virtReg is split from.
-    unsigned getPreSplitReg(unsigned virtReg) const {
-      return Virt2SplitMap[virtReg];
+    Register getPreSplitReg(Register virtReg) const {
+      return Virt2SplitMap[virtReg.id()];
     }
 
     /// getOriginal - Return the original virtual register that VirtReg descends
     /// from through splitting.
     /// A register that was not created by splitting is its own original.
     /// This operation is idempotent.
-    unsigned getOriginal(unsigned VirtReg) const {
-      unsigned Orig = getPreSplitReg(VirtReg);
+    Register getOriginal(Register VirtReg) const {
+      Register Orig = getPreSplitReg(VirtReg);
       return Orig ? Orig : VirtReg;
     }
 
     /// returns true if the specified virtual register is not
     /// mapped to a stack slot or rematerialized.
-    bool isAssignedReg(unsigned virtReg) const {
+    bool isAssignedReg(Register virtReg) const {
       if (getStackSlot(virtReg) == NO_STACK_SLOT)
         return true;
       // Split register can be assigned a physical register as well as a
       // stack slot or remat id.
-      return (Virt2SplitMap[virtReg] && Virt2PhysMap[virtReg] != NO_PHYS_REG);
+      return (Virt2SplitMap[virtReg.id()] &&
+              Virt2PhysMap[virtReg.id()] != NO_PHYS_REG);
     }
 
     /// returns the stack slot mapped to the specified virtual
     /// register
-    int getStackSlot(unsigned virtReg) const {
-      assert(TargetRegisterInfo::isVirtualRegister(virtReg));
-      return Virt2StackSlotMap[virtReg];
+    int getStackSlot(Register virtReg) const {
+      assert(virtReg.isVirtual());
+      return Virt2StackSlotMap[virtReg.id()];
     }
 
     /// create a mapping for the specifed virtual register to
     /// the next available stack slot
-    int assignVirt2StackSlot(unsigned virtReg);
+    int assignVirt2StackSlot(Register virtReg);
 
     /// create a mapping for the specified virtual register to
     /// the specified stack slot
-    void assignVirt2StackSlot(unsigned virtReg, int SS);
+    void assignVirt2StackSlot(Register virtReg, int SS);
 
     void print(raw_ostream &OS, const Module* M = nullptr) const override;
     void dump() const;
diff --git a/linux-x64/clang/include/llvm/CodeGen/WasmEHFuncInfo.h b/linux-x64/clang/include/llvm/CodeGen/WasmEHFuncInfo.h
index 887a146..54e8c40 100644
--- a/linux-x64/clang/include/llvm/CodeGen/WasmEHFuncInfo.h
+++ b/linux-x64/clang/include/llvm/CodeGen/WasmEHFuncInfo.h
@@ -15,12 +15,16 @@
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/PointerUnion.h"
-#include "llvm/CodeGen/MachineBasicBlock.h"
-#include "llvm/IR/BasicBlock.h"
 
 namespace llvm {
 
+class BasicBlock;
+class Function;
+class MachineBasicBlock;
+
+namespace WebAssembly {
 enum EventTag { CPP_EXCEPTION = 0, C_LONGJMP = 1 };
+}
 
 using BBOrMBB = PointerUnion<const BasicBlock *, MachineBasicBlock *>;
 
diff --git a/linux-x64/clang/include/llvm/Config/abi-breaking.h b/linux-x64/clang/include/llvm/Config/abi-breaking.h
index fd32bf3..c501cc3 100644
--- a/linux-x64/clang/include/llvm/Config/abi-breaking.h
+++ b/linux-x64/clang/include/llvm/Config/abi-breaking.h
@@ -20,7 +20,7 @@
 
 /* Allow selectively disabling link-time mismatch checking so that header-only
    ADT content from LLVM can be used without linking libSupport. */
-#if !LLVM_DISABLE_ABI_BREAKING_CHECKS_ENFORCING
+#if !defined(LLVM_DISABLE_ABI_BREAKING_CHECKS_ENFORCING) || !LLVM_DISABLE_ABI_BREAKING_CHECKS_ENFORCING
 
 // ABI_BREAKING_CHECKS protection: provides link-time failure when clients build
 // mismatch with LLVM
diff --git a/linux-x64/clang/include/llvm/Config/llvm-config.h b/linux-x64/clang/include/llvm/Config/llvm-config.h
index 55f10fc..6f696ec 100644
--- a/linux-x64/clang/include/llvm/Config/llvm-config.h
+++ b/linux-x64/clang/include/llvm/Config/llvm-config.h
@@ -17,9 +17,6 @@
 /* Define if LLVM_ENABLE_DUMP is enabled */
 /* #undef LLVM_ENABLE_DUMP */
 
-/* Define if we link Polly to the tools */
-/* #undef LINK_POLLY_INTO_TOOLS */
-
 /* Target triple LLVM will generate code for by default */
 #define LLVM_DEFAULT_TARGET_TRIPLE "x86_64-unknown-linux-gnu"
 
@@ -66,20 +63,35 @@
 #define LLVM_USE_PERF 0
 
 /* Major version of the LLVM API */
-#define LLVM_VERSION_MAJOR 9
+#define LLVM_VERSION_MAJOR 12
 
 /* Minor version of the LLVM API */
 #define LLVM_VERSION_MINOR 0
 
 /* Patch version of the LLVM API */
-#define LLVM_VERSION_PATCH 8
+#define LLVM_VERSION_PATCH 5
 
 /* LLVM version string */
-#define LLVM_VERSION_STRING "9.0.8svn"
+#define LLVM_VERSION_STRING "12.0.5git"
 
 /* Whether LLVM records statistics for use with GetStatistics(),
  * PrintStatistics() or PrintStatisticsJSON()
  */
 #define LLVM_FORCE_ENABLE_STATS 0
 
+/* Define if we have z3 and want to build it */
+/* #undef LLVM_WITH_Z3 */
+
+/* Define if LLVM was built with a dependency to the libtensorflow dynamic library */
+/* #undef LLVM_HAVE_TF_API */
+
+/* Define if LLVM was built with a dependency to the tensorflow compiler */
+/* #undef LLVM_HAVE_TF_AOT */
+
+/* Define to 1 if you have the <sysexits.h> header file. */
+#define HAVE_SYSEXITS_H 1
+
+/* Define to 1 to enable the experimental new pass manager by default */
+#define LLVM_ENABLE_NEW_PASS_MANAGER 0
+
 #endif
diff --git a/linux-x64/clang/include/llvm/DWARFLinker/DWARFLinker.h b/linux-x64/clang/include/llvm/DWARFLinker/DWARFLinker.h
new file mode 100644
index 0000000..7281966
--- /dev/null
+++ b/linux-x64/clang/include/llvm/DWARFLinker/DWARFLinker.h
@@ -0,0 +1,813 @@
+//===- DWARFLinker.h --------------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_DWARFLINKER_DWARFLINKER_H
+#define LLVM_DWARFLINKER_DWARFLINKER_H
+
+#include "llvm/CodeGen/AccelTable.h"
+#include "llvm/CodeGen/NonRelocatableStringpool.h"
+#include "llvm/DWARFLinker/DWARFLinkerDeclContext.h"
+#include "llvm/DebugInfo/DWARF/DWARFCompileUnit.h"
+#include "llvm/DebugInfo/DWARF/DWARFContext.h"
+#include "llvm/MC/MCDwarf.h"
+#include <map>
+
+namespace llvm {
+
+enum class DwarfLinkerClient { Dsymutil, LLD, General };
+
+/// The kind of accelerator tables we should emit.
+enum class AccelTableKind {
+  Apple,   ///< .apple_names, .apple_namespaces, .apple_types, .apple_objc.
+  Dwarf,   ///< DWARF v5 .debug_names.
+  Default, ///< Dwarf for DWARF5 or later, Apple otherwise.
+};
+
+/// Partial address range. Besides an offset, only the
+/// HighPC is stored. The structure is stored in a map where the LowPC is the
+/// key.
+struct ObjFileAddressRange {
+  /// Function HighPC.
+  uint64_t HighPC;
+  /// Offset to apply to the linked address.
+  /// should be 0 for not-linked object file.
+  int64_t Offset;
+
+  ObjFileAddressRange(uint64_t EndPC, int64_t Offset)
+      : HighPC(EndPC), Offset(Offset) {}
+
+  ObjFileAddressRange() : HighPC(0), Offset(0) {}
+};
+
+/// Map LowPC to ObjFileAddressRange.
+using RangesTy = std::map<uint64_t, ObjFileAddressRange>;
+
+/// AddressesMap represents information about valid addresses used
+/// by debug information. Valid addresses are those which points to
+/// live code sections. i.e. relocations for these addresses point
+/// into sections which would be/are placed into resulting binary.
+class AddressesMap {
+public:
+  virtual ~AddressesMap();
+
+  /// Returns true if represented addresses are from linked file.
+  /// Returns false if represented addresses are from not-linked
+  /// object file.
+  virtual bool areRelocationsResolved() const = 0;
+
+  /// Checks that there are valid relocations against a .debug_info
+  /// section. Reset current relocation pointer if neccessary.
+  virtual bool hasValidRelocs(bool ResetRelocsPtr = true) = 0;
+
+  /// Checks that the specified DIE has a DW_AT_Location attribute
+  /// that references into a live code section. This function
+  /// must be called with DIE offsets in strictly ascending order.
+  virtual bool hasLiveMemoryLocation(const DWARFDie &DIE,
+                                     CompileUnit::DIEInfo &Info) = 0;
+
+  /// Checks that the specified DIE has a DW_AT_Low_pc attribute
+  /// that references into a live code section. This function
+  /// must be called with DIE offsets in strictly ascending order.
+  virtual bool hasLiveAddressRange(const DWARFDie &DIE,
+                                   CompileUnit::DIEInfo &Info) = 0;
+
+  /// Apply the valid relocations to the buffer \p Data, taking into
+  /// account that Data is at \p BaseOffset in the debug_info section.
+  ///
+  /// This function must be called with monotonic \p BaseOffset values.
+  ///
+  /// \returns true whether any reloc has been applied.
+  virtual bool applyValidRelocs(MutableArrayRef<char> Data, uint64_t BaseOffset,
+                                bool IsLittleEndian) = 0;
+
+  /// Relocate the given address offset if a valid relocation exists.
+  virtual llvm::Expected<uint64_t> relocateIndexedAddr(uint64_t Offset) = 0;
+
+  /// Returns all valid functions address ranges(i.e., those ranges
+  /// which points to sections with code).
+  virtual RangesTy &getValidAddressRanges() = 0;
+
+  /// Erases all data.
+  virtual void clear() = 0;
+};
+
+/// DwarfEmitter presents interface to generate all debug info tables.
+class DwarfEmitter {
+public:
+  virtual ~DwarfEmitter();
+
+  /// Emit DIE containing warnings.
+  virtual void emitPaperTrailWarningsDie(DIE &Die) = 0;
+
+  /// Emit section named SecName with data SecData.
+  virtual void emitSectionContents(StringRef SecData, StringRef SecName) = 0;
+
+  /// Emit the abbreviation table \p Abbrevs to the debug_abbrev section.
+  virtual void
+  emitAbbrevs(const std::vector<std::unique_ptr<DIEAbbrev>> &Abbrevs,
+              unsigned DwarfVersion) = 0;
+
+  /// Emit the string table described by \p Pool.
+  virtual void emitStrings(const NonRelocatableStringpool &Pool) = 0;
+
+  /// Emit DWARF debug names.
+  virtual void
+  emitDebugNames(AccelTable<DWARF5AccelTableStaticData> &Table) = 0;
+
+  /// Emit Apple namespaces accelerator table.
+  virtual void
+  emitAppleNamespaces(AccelTable<AppleAccelTableStaticOffsetData> &Table) = 0;
+
+  /// Emit Apple names accelerator table.
+  virtual void
+  emitAppleNames(AccelTable<AppleAccelTableStaticOffsetData> &Table) = 0;
+
+  /// Emit Apple Objective-C accelerator table.
+  virtual void
+  emitAppleObjc(AccelTable<AppleAccelTableStaticOffsetData> &Table) = 0;
+
+  /// Emit Apple type accelerator table.
+  virtual void
+  emitAppleTypes(AccelTable<AppleAccelTableStaticTypeData> &Table) = 0;
+
+  /// Emit debug_ranges for \p FuncRange by translating the
+  /// original \p Entries.
+  virtual void emitRangesEntries(
+      int64_t UnitPcOffset, uint64_t OrigLowPc,
+      const FunctionIntervals::const_iterator &FuncRange,
+      const std::vector<DWARFDebugRangeList::RangeListEntry> &Entries,
+      unsigned AddressSize) = 0;
+
+  /// Emit debug_aranges entries for \p Unit and if \p DoRangesSection is true,
+  /// also emit the debug_ranges entries for the DW_TAG_compile_unit's
+  /// DW_AT_ranges attribute.
+  virtual void emitUnitRangesEntries(CompileUnit &Unit,
+                                     bool DoRangesSection) = 0;
+
+  /// Copy the debug_line over to the updated binary while unobfuscating the
+  /// file names and directories.
+  virtual void translateLineTable(DataExtractor LineData, uint64_t Offset) = 0;
+
+  /// Emit the line table described in \p Rows into the debug_line section.
+  virtual void emitLineTableForUnit(MCDwarfLineTableParams Params,
+                                    StringRef PrologueBytes,
+                                    unsigned MinInstLength,
+                                    std::vector<DWARFDebugLine::Row> &Rows,
+                                    unsigned AdddressSize) = 0;
+
+  /// Emit the .debug_pubnames contribution for \p Unit.
+  virtual void emitPubNamesForUnit(const CompileUnit &Unit) = 0;
+
+  /// Emit the .debug_pubtypes contribution for \p Unit.
+  virtual void emitPubTypesForUnit(const CompileUnit &Unit) = 0;
+
+  /// Emit a CIE.
+  virtual void emitCIE(StringRef CIEBytes) = 0;
+
+  /// Emit an FDE with data \p Bytes.
+  virtual void emitFDE(uint32_t CIEOffset, uint32_t AddreSize, uint32_t Address,
+                       StringRef Bytes) = 0;
+
+  /// Emit the debug_loc contribution for \p Unit by copying the entries from
+  /// \p Dwarf and offsetting them. Update the location attributes to point to
+  /// the new entries.
+  virtual void emitLocationsForUnit(
+      const CompileUnit &Unit, DWARFContext &Dwarf,
+      std::function<void(StringRef, SmallVectorImpl<uint8_t> &)>
+          ProcessExpr) = 0;
+
+  /// Emit the compilation unit header for \p Unit in the
+  /// debug_info section.
+  ///
+  /// As a side effect, this also switches the current Dwarf version
+  /// of the MC layer to the one of U.getOrigUnit().
+  virtual void emitCompileUnitHeader(CompileUnit &Unit,
+                                     unsigned DwarfVersion) = 0;
+
+  /// Recursively emit the DIE tree rooted at \p Die.
+  virtual void emitDIE(DIE &Die) = 0;
+
+  /// Returns size of generated .debug_line section.
+  virtual uint64_t getLineSectionSize() const = 0;
+
+  /// Returns size of generated .debug_frame section.
+  virtual uint64_t getFrameSectionSize() const = 0;
+
+  /// Returns size of generated .debug_ranges section.
+  virtual uint64_t getRangesSectionSize() const = 0;
+
+  /// Returns size of generated .debug_info section.
+  virtual uint64_t getDebugInfoSectionSize() const = 0;
+};
+
+using UnitListTy = std::vector<std::unique_ptr<CompileUnit>>;
+
+/// this class represents DWARF information for source file
+/// and it`s address map.
+class DWARFFile {
+public:
+  DWARFFile(StringRef Name, DWARFContext *Dwarf, AddressesMap *Addresses,
+            const std::vector<std::string> &Warnings)
+      : FileName(Name), Dwarf(Dwarf), Addresses(Addresses), Warnings(Warnings) {
+  }
+
+  /// object file name.
+  StringRef FileName;
+  /// source DWARF information.
+  DWARFContext *Dwarf = nullptr;
+  /// helpful address information(list of valid address ranges, relocations).
+  AddressesMap *Addresses = nullptr;
+  /// warnings for object file.
+  const std::vector<std::string> &Warnings;
+};
+
+typedef std::function<void(const Twine &Warning, StringRef Context,
+                           const DWARFDie *DIE)>
+    messageHandler;
+typedef std::function<ErrorOr<DWARFFile &>(StringRef ContainerName,
+                                           StringRef Path)>
+    objFileLoader;
+typedef std::map<std::string, std::string> swiftInterfacesMap;
+typedef std::map<std::string, std::string> objectPrefixMap;
+
+/// The core of the Dwarf linking logic.
+///
+/// The generation of the dwarf information from the object files will be
+/// driven by the selection of 'root DIEs', which are DIEs that
+/// describe variables or functions that resolves to the corresponding
+/// code section(and thus have entries in the Addresses map). All the debug
+/// information that will be generated(the DIEs, but also the line
+/// tables, ranges, ...) is derived from that set of root DIEs.
+///
+/// The root DIEs are identified because they contain relocations that
+/// points to code section(the low_pc for a function, the location for
+/// a variable). These relocations are called ValidRelocs in the
+/// AddressesInfo and are gathered as a very first step when we start
+/// processing a object file.
+class DWARFLinker {
+public:
+  DWARFLinker(DwarfEmitter *Emitter,
+              DwarfLinkerClient ClientID = DwarfLinkerClient::General)
+      : TheDwarfEmitter(Emitter), DwarfLinkerClientID(ClientID) {}
+
+  /// Add object file to be linked.
+  void addObjectFile(DWARFFile &File);
+
+  /// Link debug info for added objFiles. Object
+  /// files are linked all together.
+  bool link();
+
+  /// A number of methods setting various linking options:
+
+  /// Allows to generate log of linking process to the standard output.
+  void setVerbosity(bool Verbose) { Options.Verbose = Verbose; }
+
+  /// Print statistics to standard output.
+  void setStatistics(bool Statistics) { Options.Statistics = Statistics; }
+
+  /// Do not emit linked dwarf info.
+  void setNoOutput(bool NoOut) { Options.NoOutput = NoOut; }
+
+  /// Do not unique types according to ODR.
+  void setNoODR(bool NoODR) { Options.NoODR = NoODR; }
+
+  /// update existing DWARF info(for the linked binary).
+  void setUpdate(bool Update) { Options.Update = Update; }
+
+  /// Use specified number of threads for parallel files linking.
+  void setNumThreads(unsigned NumThreads) { Options.Threads = NumThreads; }
+
+  /// Set kind of accelerator tables to be generated.
+  void setAccelTableKind(AccelTableKind Kind) {
+    Options.TheAccelTableKind = Kind;
+  }
+
+  /// Set prepend path for clang modules.
+  void setPrependPath(const std::string &Ppath) { Options.PrependPath = Ppath; }
+
+  /// Set translator which would be used for strings.
+  void
+  setStringsTranslator(std::function<StringRef(StringRef)> StringsTranslator) {
+    this->StringsTranslator = StringsTranslator;
+  }
+
+  /// Set estimated objects files amount, for preliminary data allocation.
+  void setEstimatedObjfilesAmount(unsigned ObjFilesNum) {
+    ObjectContexts.reserve(ObjFilesNum);
+  }
+
+  /// Set warning handler which would be used to report warnings.
+  void setWarningHandler(messageHandler Handler) {
+    Options.WarningHandler = Handler;
+  }
+
+  /// Set error handler which would be used to report errors.
+  void setErrorHandler(messageHandler Handler) {
+    Options.ErrorHandler = Handler;
+  }
+
+  /// Set object files loader which would be used to load
+  /// additional objects for splitted dwarf.
+  void setObjFileLoader(objFileLoader Loader) {
+    Options.ObjFileLoader = Loader;
+  }
+
+  /// Set map for Swift interfaces.
+  void setSwiftInterfacesMap(swiftInterfacesMap *Map) {
+    Options.ParseableSwiftInterfaces = Map;
+  }
+
+  /// Set prefix map for objects.
+  void setObjectPrefixMap(objectPrefixMap *Map) {
+    Options.ObjectPrefixMap = Map;
+  }
+
+private:
+  /// Flags passed to DwarfLinker::lookForDIEsToKeep
+  enum TraversalFlags {
+    TF_Keep = 1 << 0,            ///< Mark the traversed DIEs as kept.
+    TF_InFunctionScope = 1 << 1, ///< Current scope is a function scope.
+    TF_DependencyWalk = 1 << 2,  ///< Walking the dependencies of a kept DIE.
+    TF_ParentWalk = 1 << 3,      ///< Walking up the parents of a kept DIE.
+    TF_ODR = 1 << 4,             ///< Use the ODR while keeping dependents.
+    TF_SkipPC = 1 << 5,          ///< Skip all location attributes.
+  };
+
+  /// The  distinct types of work performed by the work loop.
+  enum class WorklistItemType {
+    /// Given a DIE, look for DIEs to be kept.
+    LookForDIEsToKeep,
+    /// Given a DIE, look for children of this DIE to be kept.
+    LookForChildDIEsToKeep,
+    /// Given a DIE, look for DIEs referencing this DIE to be kept.
+    LookForRefDIEsToKeep,
+    /// Given a DIE, look for parent DIEs to be kept.
+    LookForParentDIEsToKeep,
+    /// Given a DIE, update its incompleteness based on whether its children are
+    /// incomplete.
+    UpdateChildIncompleteness,
+    /// Given a DIE, update its incompleteness based on whether the DIEs it
+    /// references are incomplete.
+    UpdateRefIncompleteness,
+  };
+
+  /// This class represents an item in the work list. The type defines what kind
+  /// of work needs to be performed when processing the current item. The flags
+  /// and info fields are optional based on the type.
+  struct WorklistItem {
+    DWARFDie Die;
+    WorklistItemType Type;
+    CompileUnit &CU;
+    unsigned Flags;
+    union {
+      const unsigned AncestorIdx;
+      CompileUnit::DIEInfo *OtherInfo;
+    };
+
+    WorklistItem(DWARFDie Die, CompileUnit &CU, unsigned Flags,
+                 WorklistItemType T = WorklistItemType::LookForDIEsToKeep)
+        : Die(Die), Type(T), CU(CU), Flags(Flags), AncestorIdx(0) {}
+
+    WorklistItem(DWARFDie Die, CompileUnit &CU, WorklistItemType T,
+                 CompileUnit::DIEInfo *OtherInfo = nullptr)
+        : Die(Die), Type(T), CU(CU), Flags(0), OtherInfo(OtherInfo) {}
+
+    WorklistItem(unsigned AncestorIdx, CompileUnit &CU, unsigned Flags)
+        : Die(), Type(WorklistItemType::LookForParentDIEsToKeep), CU(CU),
+          Flags(Flags), AncestorIdx(AncestorIdx) {}
+  };
+
+  /// returns true if we need to translate strings.
+  bool needToTranslateStrings() { return StringsTranslator != nullptr; }
+
+  void reportWarning(const Twine &Warning, const DWARFFile &File,
+                     const DWARFDie *DIE = nullptr) const {
+    if (Options.WarningHandler != nullptr)
+      Options.WarningHandler(Warning, File.FileName, DIE);
+  }
+
+  void reportError(const Twine &Warning, const DWARFFile &File,
+                   const DWARFDie *DIE = nullptr) const {
+    if (Options.ErrorHandler != nullptr)
+      Options.ErrorHandler(Warning, File.FileName, DIE);
+  }
+
+  /// Remembers the oldest and newest DWARF version we've seen in a unit.
+  void updateDwarfVersion(unsigned Version) {
+    MaxDwarfVersion = std::max(MaxDwarfVersion, Version);
+    MinDwarfVersion = std::min(MinDwarfVersion, Version);
+  }
+
+  /// Remembers the kinds of accelerator tables we've seen in a unit.
+  void updateAccelKind(DWARFContext &Dwarf);
+
+  /// Emit warnings as Dwarf compile units to leave a trail after linking.
+  bool emitPaperTrailWarnings(const DWARFFile &File,
+                              OffsetsStringPool &StringPool);
+
+  void copyInvariantDebugSection(DWARFContext &Dwarf);
+
+  /// Keeps track of data associated with one object during linking.
+  struct LinkContext {
+    DWARFFile &File;
+    UnitListTy CompileUnits;
+    bool Skip = false;
+
+    LinkContext(DWARFFile &File) : File(File) {}
+
+    /// Clear part of the context that's no longer needed when we're done with
+    /// the debug object.
+    void clear() {
+      CompileUnits.clear();
+      File.Addresses->clear();
+    }
+  };
+
+  /// Called before emitting object data
+  void cleanupAuxiliarryData(LinkContext &Context);
+
+  /// Look at the parent of the given DIE and decide whether they should be
+  /// kept.
+  void lookForParentDIEsToKeep(unsigned AncestorIdx, CompileUnit &CU,
+                               unsigned Flags,
+                               SmallVectorImpl<WorklistItem> &Worklist);
+
+  /// Look at the children of the given DIE and decide whether they should be
+  /// kept.
+  void lookForChildDIEsToKeep(const DWARFDie &Die, CompileUnit &CU,
+                              unsigned Flags,
+                              SmallVectorImpl<WorklistItem> &Worklist);
+
+  /// Look at DIEs referenced by the given DIE and decide whether they should be
+  /// kept. All DIEs referenced though attributes should be kept.
+  void lookForRefDIEsToKeep(const DWARFDie &Die, CompileUnit &CU,
+                            unsigned Flags, const UnitListTy &Units,
+                            const DWARFFile &File,
+                            SmallVectorImpl<WorklistItem> &Worklist);
+
+  /// \defgroup FindRootDIEs Find DIEs corresponding to Address map entries.
+  ///
+  /// @{
+  /// Recursively walk the \p DIE tree and look for DIEs to
+  /// keep. Store that information in \p CU's DIEInfo.
+  ///
+  /// The return value indicates whether the DIE is incomplete.
+  void lookForDIEsToKeep(AddressesMap &RelocMgr, RangesTy &Ranges,
+                         const UnitListTy &Units, const DWARFDie &DIE,
+                         const DWARFFile &File, CompileUnit &CU,
+                         unsigned Flags);
+
+  /// If this compile unit is really a skeleton CU that points to a
+  /// clang module, register it in ClangModules and return true.
+  ///
+  /// A skeleton CU is a CU without children, a DW_AT_gnu_dwo_name
+  /// pointing to the module, and a DW_AT_gnu_dwo_id with the module
+  /// hash.
+  bool registerModuleReference(DWARFDie CUDie, const DWARFUnit &Unit,
+                               const DWARFFile &File,
+                               OffsetsStringPool &OffsetsStringPool,
+                               DeclContextTree &ODRContexts,
+                               uint64_t ModulesEndOffset, unsigned &UnitID,
+                               bool IsLittleEndian, unsigned Indent = 0,
+                               bool Quiet = false);
+
+  /// Recursively add the debug info in this clang module .pcm
+  /// file (and all the modules imported by it in a bottom-up fashion)
+  /// to Units.
+  Error loadClangModule(DWARFDie CUDie, StringRef FilePath,
+                        StringRef ModuleName, uint64_t DwoId,
+                        const DWARFFile &File,
+                        OffsetsStringPool &OffsetsStringPool,
+                        DeclContextTree &ODRContexts, uint64_t ModulesEndOffset,
+                        unsigned &UnitID, bool IsLittleEndian,
+                        unsigned Indent = 0, bool Quiet = false);
+
+  /// Mark the passed DIE as well as all the ones it depends on as kept.
+  void keepDIEAndDependencies(AddressesMap &RelocMgr, RangesTy &Ranges,
+                              const UnitListTy &Units, const DWARFDie &DIE,
+                              CompileUnit::DIEInfo &MyInfo,
+                              const DWARFFile &File, CompileUnit &CU,
+                              bool UseODR);
+
+  unsigned shouldKeepDIE(AddressesMap &RelocMgr, RangesTy &Ranges,
+                         const DWARFDie &DIE, const DWARFFile &File,
+                         CompileUnit &Unit, CompileUnit::DIEInfo &MyInfo,
+                         unsigned Flags);
+
+  /// Check if a variable describing DIE should be kept.
+  /// \returns updated TraversalFlags.
+  unsigned shouldKeepVariableDIE(AddressesMap &RelocMgr, const DWARFDie &DIE,
+                                 CompileUnit::DIEInfo &MyInfo, unsigned Flags);
+
+  unsigned shouldKeepSubprogramDIE(AddressesMap &RelocMgr, RangesTy &Ranges,
+                                   const DWARFDie &DIE, const DWARFFile &File,
+                                   CompileUnit &Unit,
+                                   CompileUnit::DIEInfo &MyInfo,
+                                   unsigned Flags);
+
+  /// Resolve the DIE attribute reference that has been extracted in \p
+  /// RefValue. The resulting DIE might be in another CompileUnit which is
+  /// stored into \p ReferencedCU. \returns null if resolving fails for any
+  /// reason.
+  DWARFDie resolveDIEReference(const DWARFFile &File, const UnitListTy &Units,
+                               const DWARFFormValue &RefValue,
+                               const DWARFDie &DIE, CompileUnit *&RefCU);
+
+  /// @}
+
+  /// \defgroup Methods used to link the debug information
+  ///
+  /// @{
+
+  struct DWARFLinkerOptions;
+
+  class DIECloner {
+    DWARFLinker &Linker;
+    DwarfEmitter *Emitter;
+    DWARFFile &ObjFile;
+
+    /// Allocator used for all the DIEValue objects.
+    BumpPtrAllocator &DIEAlloc;
+
+    std::vector<std::unique_ptr<CompileUnit>> &CompileUnits;
+
+    bool Update;
+
+  public:
+    DIECloner(DWARFLinker &Linker, DwarfEmitter *Emitter, DWARFFile &ObjFile,
+              BumpPtrAllocator &DIEAlloc,
+              std::vector<std::unique_ptr<CompileUnit>> &CompileUnits,
+              bool Update)
+        : Linker(Linker), Emitter(Emitter), ObjFile(ObjFile),
+          DIEAlloc(DIEAlloc), CompileUnits(CompileUnits), Update(Update) {}
+
+    /// Recursively clone \p InputDIE into an tree of DIE objects
+    /// where useless (as decided by lookForDIEsToKeep()) bits have been
+    /// stripped out and addresses have been rewritten according to the
+    /// address map.
+    ///
+    /// \param OutOffset is the offset the cloned DIE in the output
+    /// compile unit.
+    /// \param PCOffset (while cloning a function scope) is the offset
+    /// applied to the entry point of the function to get the linked address.
+    /// \param Die the output DIE to use, pass NULL to create one.
+    /// \returns the root of the cloned tree or null if nothing was selected.
+    DIE *cloneDIE(const DWARFDie &InputDIE, const DWARFFile &File,
+                  CompileUnit &U, OffsetsStringPool &StringPool,
+                  int64_t PCOffset, uint32_t OutOffset, unsigned Flags,
+                  bool IsLittleEndian, DIE *Die = nullptr);
+
+    /// Construct the output DIE tree by cloning the DIEs we
+    /// chose to keep above. If there are no valid relocs, then there's
+    /// nothing to clone/emit.
+    uint64_t cloneAllCompileUnits(DWARFContext &DwarfContext,
+                                  const DWARFFile &File,
+                                  OffsetsStringPool &StringPool,
+                                  bool IsLittleEndian);
+
+  private:
+    using AttributeSpec = DWARFAbbreviationDeclaration::AttributeSpec;
+
+    /// Information gathered and exchanged between the various
+    /// clone*Attributes helpers about the attributes of a particular DIE.
+    struct AttributesInfo {
+      /// Names.
+      DwarfStringPoolEntryRef Name, MangledName, NameWithoutTemplate;
+
+      /// Offsets in the string pool.
+      uint32_t NameOffset = 0;
+      uint32_t MangledNameOffset = 0;
+
+      /// Value of AT_low_pc in the input DIE
+      uint64_t OrigLowPc = std::numeric_limits<uint64_t>::max();
+
+      /// Value of AT_high_pc in the input DIE
+      uint64_t OrigHighPc = 0;
+
+      /// Value of DW_AT_call_return_pc in the input DIE
+      uint64_t OrigCallReturnPc = 0;
+
+      /// Value of DW_AT_call_pc in the input DIE
+      uint64_t OrigCallPc = 0;
+
+      /// Offset to apply to PC addresses inside a function.
+      int64_t PCOffset = 0;
+
+      /// Does the DIE have a low_pc attribute?
+      bool HasLowPc = false;
+
+      /// Does the DIE have a ranges attribute?
+      bool HasRanges = false;
+
+      /// Is this DIE only a declaration?
+      bool IsDeclaration = false;
+
+      AttributesInfo() = default;
+    };
+
+    /// Helper for cloneDIE.
+    unsigned cloneAttribute(DIE &Die, const DWARFDie &InputDIE,
+                            const DWARFFile &File, CompileUnit &U,
+                            OffsetsStringPool &StringPool,
+                            const DWARFFormValue &Val,
+                            const AttributeSpec AttrSpec, unsigned AttrSize,
+                            AttributesInfo &AttrInfo, bool IsLittleEndian);
+
+    /// Clone a string attribute described by \p AttrSpec and add
+    /// it to \p Die.
+    /// \returns the size of the new attribute.
+    unsigned cloneStringAttribute(DIE &Die, AttributeSpec AttrSpec,
+                                  const DWARFFormValue &Val, const DWARFUnit &U,
+                                  OffsetsStringPool &StringPool,
+                                  AttributesInfo &Info);
+
+    /// Clone an attribute referencing another DIE and add
+    /// it to \p Die.
+    /// \returns the size of the new attribute.
+    unsigned cloneDieReferenceAttribute(DIE &Die, const DWARFDie &InputDIE,
+                                        AttributeSpec AttrSpec,
+                                        unsigned AttrSize,
+                                        const DWARFFormValue &Val,
+                                        const DWARFFile &File,
+                                        CompileUnit &Unit);
+
+    /// Clone a DWARF expression that may be referencing another DIE.
+    void cloneExpression(DataExtractor &Data, DWARFExpression Expression,
+                         const DWARFFile &File, CompileUnit &Unit,
+                         SmallVectorImpl<uint8_t> &OutputBuffer);
+
+    /// Clone an attribute referencing another DIE and add
+    /// it to \p Die.
+    /// \returns the size of the new attribute.
+    unsigned cloneBlockAttribute(DIE &Die, const DWARFFile &File,
+                                 CompileUnit &Unit, AttributeSpec AttrSpec,
+                                 const DWARFFormValue &Val, unsigned AttrSize,
+                                 bool IsLittleEndian);
+
+    /// Clone an attribute referencing another DIE and add
+    /// it to \p Die.
+    /// \returns the size of the new attribute.
+    unsigned cloneAddressAttribute(DIE &Die, AttributeSpec AttrSpec,
+                                   const DWARFFormValue &Val,
+                                   const CompileUnit &Unit,
+                                   AttributesInfo &Info);
+
+    /// Clone a scalar attribute  and add it to \p Die.
+    /// \returns the size of the new attribute.
+    unsigned cloneScalarAttribute(DIE &Die, const DWARFDie &InputDIE,
+                                  const DWARFFile &File, CompileUnit &U,
+                                  AttributeSpec AttrSpec,
+                                  const DWARFFormValue &Val, unsigned AttrSize,
+                                  AttributesInfo &Info);
+
+    /// Get the potential name and mangled name for the entity
+    /// described by \p Die and store them in \Info if they are not
+    /// already there.
+    /// \returns is a name was found.
+    bool getDIENames(const DWARFDie &Die, AttributesInfo &Info,
+                     OffsetsStringPool &StringPool, bool StripTemplate = false);
+
+    /// Create a copy of abbreviation Abbrev.
+    void copyAbbrev(const DWARFAbbreviationDeclaration &Abbrev, bool hasODR);
+
+    uint32_t hashFullyQualifiedName(DWARFDie DIE, CompileUnit &U,
+                                    const DWARFFile &File,
+                                    int RecurseDepth = 0);
+
+    /// Helper for cloneDIE.
+    void addObjCAccelerator(CompileUnit &Unit, const DIE *Die,
+                            DwarfStringPoolEntryRef Name,
+                            OffsetsStringPool &StringPool, bool SkipPubSection);
+  };
+
+  /// Assign an abbreviation number to \p Abbrev
+  void assignAbbrev(DIEAbbrev &Abbrev);
+
+  /// Compute and emit debug_ranges section for \p Unit, and
+  /// patch the attributes referencing it.
+  void patchRangesForUnit(const CompileUnit &Unit, DWARFContext &Dwarf,
+                          const DWARFFile &File) const;
+
+  /// Generate and emit the DW_AT_ranges attribute for a compile_unit if it had
+  /// one.
+  void generateUnitRanges(CompileUnit &Unit) const;
+
+  /// Extract the line tables from the original dwarf, extract the relevant
+  /// parts according to the linked function ranges and emit the result in the
+  /// debug_line section.
+  void patchLineTableForUnit(CompileUnit &Unit, DWARFContext &OrigDwarf,
+                             const DWARFFile &File);
+
+  /// Emit the accelerator entries for \p Unit.
+  void emitAcceleratorEntriesForUnit(CompileUnit &Unit);
+  void emitDwarfAcceleratorEntriesForUnit(CompileUnit &Unit);
+  void emitAppleAcceleratorEntriesForUnit(CompileUnit &Unit);
+
+  /// Patch the frame info for an object file and emit it.
+  void patchFrameInfoForObject(const DWARFFile &, RangesTy &Ranges,
+                               DWARFContext &, unsigned AddressSize);
+
+  /// FoldingSet that uniques the abbreviations.
+  FoldingSet<DIEAbbrev> AbbreviationsSet;
+
+  /// Storage for the unique Abbreviations.
+  /// This is passed to AsmPrinter::emitDwarfAbbrevs(), thus it cannot be
+  /// changed to a vector of unique_ptrs.
+  std::vector<std::unique_ptr<DIEAbbrev>> Abbreviations;
+
+  /// DIELoc objects that need to be destructed (but not freed!).
+  std::vector<DIELoc *> DIELocs;
+
+  /// DIEBlock objects that need to be destructed (but not freed!).
+  std::vector<DIEBlock *> DIEBlocks;
+
+  /// Allocator used for all the DIEValue objects.
+  BumpPtrAllocator DIEAlloc;
+  /// @}
+
+  DwarfEmitter *TheDwarfEmitter;
+  std::vector<LinkContext> ObjectContexts;
+
+  unsigned MaxDwarfVersion = 0;
+  unsigned MinDwarfVersion = std::numeric_limits<unsigned>::max();
+
+  bool AtLeastOneAppleAccelTable = false;
+  bool AtLeastOneDwarfAccelTable = false;
+
+  /// The CIEs that have been emitted in the output section. The actual CIE
+  /// data serves a the key to this StringMap, this takes care of comparing the
+  /// semantics of CIEs defined in different object files.
+  StringMap<uint32_t> EmittedCIEs;
+
+  /// Offset of the last CIE that has been emitted in the output
+  /// debug_frame section.
+  uint32_t LastCIEOffset = 0;
+
+  /// Apple accelerator tables.
+  AccelTable<DWARF5AccelTableStaticData> DebugNames;
+  AccelTable<AppleAccelTableStaticOffsetData> AppleNames;
+  AccelTable<AppleAccelTableStaticOffsetData> AppleNamespaces;
+  AccelTable<AppleAccelTableStaticOffsetData> AppleObjc;
+  AccelTable<AppleAccelTableStaticTypeData> AppleTypes;
+
+  /// Mapping the PCM filename to the DwoId.
+  StringMap<uint64_t> ClangModules;
+
+  DwarfLinkerClient DwarfLinkerClientID;
+
+  std::function<StringRef(StringRef)> StringsTranslator = nullptr;
+
+  /// linking options
+  struct DWARFLinkerOptions {
+    /// Generate processing log to the standard output.
+    bool Verbose = false;
+
+    /// Print statistics.
+    bool Statistics = false;
+
+    /// Skip emitting output
+    bool NoOutput = false;
+
+    /// Do not unique types according to ODR
+    bool NoODR = false;
+
+    /// Update
+    bool Update = false;
+
+    /// Number of threads.
+    unsigned Threads = 1;
+
+    /// The accelerator table kind
+    AccelTableKind TheAccelTableKind = AccelTableKind::Default;
+
+    /// Prepend path for the clang modules.
+    std::string PrependPath;
+
+    // warning handler
+    messageHandler WarningHandler = nullptr;
+
+    // error handler
+    messageHandler ErrorHandler = nullptr;
+
+    objFileLoader ObjFileLoader = nullptr;
+
+    /// A list of all .swiftinterface files referenced by the debug
+    /// info, mapping Module name to path on disk. The entries need to
+    /// be uniqued and sorted and there are only few entries expected
+    /// per compile unit, which is why this is a std::map.
+    /// this is dsymutil specific fag.
+    swiftInterfacesMap *ParseableSwiftInterfaces = nullptr;
+
+    /// A list of remappings to apply to file paths.
+    objectPrefixMap *ObjectPrefixMap = nullptr;
+  } Options;
+};
+
+} // end namespace llvm
+
+#endif // LLVM_DWARFLINKER_DWARFLINKER_H
diff --git a/linux-x64/clang/include/llvm/DWARFLinker/DWARFLinkerCompileUnit.h b/linux-x64/clang/include/llvm/DWARFLinker/DWARFLinkerCompileUnit.h
new file mode 100644
index 0000000..a6310bc
--- /dev/null
+++ b/linux-x64/clang/include/llvm/DWARFLinker/DWARFLinkerCompileUnit.h
@@ -0,0 +1,316 @@
+//===- DWARFLinkerCompileUnit.h ---------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_DWARFLINKER_DWARFLINKERCOMPILEUNIT_H
+#define LLVM_DWARFLINKER_DWARFLINKERCOMPILEUNIT_H
+
+#include "llvm/ADT/IntervalMap.h"
+#include "llvm/CodeGen/DIE.h"
+#include "llvm/DebugInfo/DWARF/DWARFUnit.h"
+#include "llvm/Support/DataExtractor.h"
+
+namespace llvm {
+
+class DeclContext;
+
+template <typename KeyT, typename ValT>
+using HalfOpenIntervalMap =
+    IntervalMap<KeyT, ValT, IntervalMapImpl::NodeSizer<KeyT, ValT>::LeafSize,
+                IntervalMapHalfOpenInfo<KeyT>>;
+
+using FunctionIntervals = HalfOpenIntervalMap<uint64_t, int64_t>;
+
+// FIXME: Delete this structure.
+struct PatchLocation {
+  DIE::value_iterator I;
+
+  PatchLocation() = default;
+  PatchLocation(DIE::value_iterator I) : I(I) {}
+
+  void set(uint64_t New) const {
+    assert(I);
+    const auto &Old = *I;
+    assert(Old.getType() == DIEValue::isInteger);
+    *I = DIEValue(Old.getAttribute(), Old.getForm(), DIEInteger(New));
+  }
+
+  uint64_t get() const {
+    assert(I);
+    return I->getDIEInteger().getValue();
+  }
+};
+
+/// Stores all information relating to a compile unit, be it in its original
+/// instance in the object file to its brand new cloned and generated DIE tree.
+class CompileUnit {
+public:
+  /// Information gathered about a DIE in the object file.
+  struct DIEInfo {
+    /// Address offset to apply to the described entity.
+    int64_t AddrAdjust;
+
+    /// ODR Declaration context.
+    DeclContext *Ctxt;
+
+    /// Cloned version of that DIE.
+    DIE *Clone;
+
+    /// The index of this DIE's parent.
+    uint32_t ParentIdx;
+
+    /// Is the DIE part of the linked output?
+    bool Keep : 1;
+
+    /// Was this DIE's entity found in the map?
+    bool InDebugMap : 1;
+
+    /// Is this a pure forward declaration we can strip?
+    bool Prune : 1;
+
+    /// Does DIE transitively refer an incomplete decl?
+    bool Incomplete : 1;
+  };
+
+  CompileUnit(DWARFUnit &OrigUnit, unsigned ID, bool CanUseODR,
+              StringRef ClangModuleName)
+      : OrigUnit(OrigUnit), ID(ID), Ranges(RangeAlloc),
+        ClangModuleName(ClangModuleName) {
+    Info.resize(OrigUnit.getNumDIEs());
+
+    auto CUDie = OrigUnit.getUnitDIE(false);
+    if (!CUDie) {
+      HasODR = false;
+      return;
+    }
+    if (auto Lang = dwarf::toUnsigned(CUDie.find(dwarf::DW_AT_language)))
+      HasODR = CanUseODR && (*Lang == dwarf::DW_LANG_C_plus_plus ||
+                             *Lang == dwarf::DW_LANG_C_plus_plus_03 ||
+                             *Lang == dwarf::DW_LANG_C_plus_plus_11 ||
+                             *Lang == dwarf::DW_LANG_C_plus_plus_14 ||
+                             *Lang == dwarf::DW_LANG_ObjC_plus_plus);
+    else
+      HasODR = false;
+  }
+
+  DWARFUnit &getOrigUnit() const { return OrigUnit; }
+
+  unsigned getUniqueID() const { return ID; }
+
+  void createOutputDIE() { NewUnit.emplace(OrigUnit.getUnitDIE().getTag()); }
+
+  DIE *getOutputUnitDIE() const {
+    if (NewUnit)
+      return &const_cast<BasicDIEUnit &>(*NewUnit).getUnitDie();
+    return nullptr;
+  }
+
+  bool hasODR() const { return HasODR; }
+  bool isClangModule() const { return !ClangModuleName.empty(); }
+  uint16_t getLanguage();
+  /// Return the DW_AT_LLVM_sysroot of the compile unit or an empty StringRef.
+  StringRef getSysRoot();
+
+  const std::string &getClangModuleName() const { return ClangModuleName; }
+
+  DIEInfo &getInfo(unsigned Idx) { return Info[Idx]; }
+  const DIEInfo &getInfo(unsigned Idx) const { return Info[Idx]; }
+
+  DIEInfo &getInfo(const DWARFDie &Die) {
+    unsigned Idx = getOrigUnit().getDIEIndex(Die);
+    return Info[Idx];
+  }
+
+  uint64_t getStartOffset() const { return StartOffset; }
+  uint64_t getNextUnitOffset() const { return NextUnitOffset; }
+  void setStartOffset(uint64_t DebugInfoSize) { StartOffset = DebugInfoSize; }
+
+  uint64_t getLowPc() const { return LowPc; }
+  uint64_t getHighPc() const { return HighPc; }
+  bool hasLabelAt(uint64_t Addr) const { return Labels.count(Addr); }
+
+  Optional<PatchLocation> getUnitRangesAttribute() const {
+    return UnitRangeAttribute;
+  }
+
+  const FunctionIntervals &getFunctionRanges() const { return Ranges; }
+
+  const std::vector<PatchLocation> &getRangesAttributes() const {
+    return RangeAttributes;
+  }
+
+  const std::vector<std::pair<PatchLocation, int64_t>> &
+  getLocationAttributes() const {
+    return LocationAttributes;
+  }
+
+  void setHasInterestingContent() { HasInterestingContent = true; }
+  bool hasInterestingContent() { return HasInterestingContent; }
+
+  /// Mark every DIE in this unit as kept. This function also
+  /// marks variables as InDebugMap so that they appear in the
+  /// reconstructed accelerator tables.
+  void markEverythingAsKept();
+
+  /// Compute the end offset for this unit. Must be called after the CU's DIEs
+  /// have been cloned.  \returns the next unit offset (which is also the
+  /// current debug_info section size).
+  uint64_t computeNextUnitOffset(uint16_t DwarfVersion);
+
+  /// Keep track of a forward reference to DIE \p Die in \p RefUnit by \p
+  /// Attr. The attribute should be fixed up later to point to the absolute
+  /// offset of \p Die in the debug_info section or to the canonical offset of
+  /// \p Ctxt if it is non-null.
+  void noteForwardReference(DIE *Die, const CompileUnit *RefUnit,
+                            DeclContext *Ctxt, PatchLocation Attr);
+
+  /// Apply all fixups recorded by noteForwardReference().
+  void fixupForwardReferences();
+
+  /// Add the low_pc of a label that is relocated by applying
+  /// offset \p PCOffset.
+  void addLabelLowPc(uint64_t LabelLowPc, int64_t PcOffset);
+
+  /// Add a function range [\p LowPC, \p HighPC) that is relocated by applying
+  /// offset \p PCOffset.
+  void addFunctionRange(uint64_t LowPC, uint64_t HighPC, int64_t PCOffset);
+
+  /// Keep track of a DW_AT_range attribute that we will need to patch up later.
+  void noteRangeAttribute(const DIE &Die, PatchLocation Attr);
+
+  /// Keep track of a location attribute pointing to a location list in the
+  /// debug_loc section.
+  void noteLocationAttribute(PatchLocation Attr, int64_t PcOffset);
+
+  /// Add a name accelerator entry for \a Die with \a Name.
+  void addNamespaceAccelerator(const DIE *Die, DwarfStringPoolEntryRef Name);
+
+  /// Add a name accelerator entry for \a Die with \a Name.
+  void addNameAccelerator(const DIE *Die, DwarfStringPoolEntryRef Name,
+                          bool SkipPubnamesSection = false);
+
+  /// Add various accelerator entries for \p Die with \p Name which is stored
+  /// in the string table at \p Offset. \p Name must be an Objective-C
+  /// selector.
+  void addObjCAccelerator(const DIE *Die, DwarfStringPoolEntryRef Name,
+                          bool SkipPubnamesSection = false);
+
+  /// Add a type accelerator entry for \p Die with \p Name which is stored in
+  /// the string table at \p Offset.
+  void addTypeAccelerator(const DIE *Die, DwarfStringPoolEntryRef Name,
+                          bool ObjcClassImplementation,
+                          uint32_t QualifiedNameHash);
+
+  struct AccelInfo {
+    /// Name of the entry.
+    DwarfStringPoolEntryRef Name;
+
+    /// DIE this entry describes.
+    const DIE *Die;
+
+    /// Hash of the fully qualified name.
+    uint32_t QualifiedNameHash;
+
+    /// Emit this entry only in the apple_* sections.
+    bool SkipPubSection;
+
+    /// Is this an ObjC class implementation?
+    bool ObjcClassImplementation;
+
+    AccelInfo(DwarfStringPoolEntryRef Name, const DIE *Die,
+              bool SkipPubSection = false)
+        : Name(Name), Die(Die), SkipPubSection(SkipPubSection) {}
+
+    AccelInfo(DwarfStringPoolEntryRef Name, const DIE *Die,
+              uint32_t QualifiedNameHash, bool ObjCClassIsImplementation)
+        : Name(Name), Die(Die), QualifiedNameHash(QualifiedNameHash),
+          SkipPubSection(false),
+          ObjcClassImplementation(ObjCClassIsImplementation) {}
+  };
+
+  const std::vector<AccelInfo> &getPubnames() const { return Pubnames; }
+  const std::vector<AccelInfo> &getPubtypes() const { return Pubtypes; }
+  const std::vector<AccelInfo> &getNamespaces() const { return Namespaces; }
+  const std::vector<AccelInfo> &getObjC() const { return ObjC; }
+
+  MCSymbol *getLabelBegin() { return LabelBegin; }
+  void setLabelBegin(MCSymbol *S) { LabelBegin = S; }
+
+private:
+  DWARFUnit &OrigUnit;
+  unsigned ID;
+  std::vector<DIEInfo> Info; ///< DIE info indexed by DIE index.
+  Optional<BasicDIEUnit> NewUnit;
+  MCSymbol *LabelBegin = nullptr;
+
+  uint64_t StartOffset;
+  uint64_t NextUnitOffset;
+
+  uint64_t LowPc = std::numeric_limits<uint64_t>::max();
+  uint64_t HighPc = 0;
+
+  /// A list of attributes to fixup with the absolute offset of
+  /// a DIE in the debug_info section.
+  ///
+  /// The offsets for the attributes in this array couldn't be set while
+  /// cloning because for cross-cu forward references the target DIE's offset
+  /// isn't known you emit the reference attribute.
+  std::vector<
+      std::tuple<DIE *, const CompileUnit *, DeclContext *, PatchLocation>>
+      ForwardDIEReferences;
+
+  FunctionIntervals::Allocator RangeAlloc;
+
+  /// The ranges in that interval map are the PC ranges for
+  /// functions in this unit, associated with the PC offset to apply
+  /// to the addresses to get the linked address.
+  FunctionIntervals Ranges;
+
+  /// The DW_AT_low_pc of each DW_TAG_label.
+  SmallDenseMap<uint64_t, uint64_t, 1> Labels;
+
+  /// DW_AT_ranges attributes to patch after we have gathered
+  /// all the unit's function addresses.
+  /// @{
+  std::vector<PatchLocation> RangeAttributes;
+  Optional<PatchLocation> UnitRangeAttribute;
+  /// @}
+
+  /// Location attributes that need to be transferred from the
+  /// original debug_loc section to the liked one. They are stored
+  /// along with the PC offset that is to be applied to their
+  /// function's address.
+  std::vector<std::pair<PatchLocation, int64_t>> LocationAttributes;
+
+  /// Accelerator entries for the unit, both for the pub*
+  /// sections and the apple* ones.
+  /// @{
+  std::vector<AccelInfo> Pubnames;
+  std::vector<AccelInfo> Pubtypes;
+  std::vector<AccelInfo> Namespaces;
+  std::vector<AccelInfo> ObjC;
+  /// @}
+
+  /// Is this unit subject to the ODR rule?
+  bool HasODR;
+
+  /// Did a DIE actually contain a valid reloc?
+  bool HasInterestingContent;
+
+  /// The DW_AT_language of this unit.
+  uint16_t Language = 0;
+
+  /// The DW_AT_LLVM_sysroot of this unit.
+  std::string SysRoot;
+
+  /// If this is a Clang module, this holds the module's name.
+  std::string ClangModuleName;
+};
+
+} // end namespace llvm
+
+#endif // LLVM_DWARFLINKER_DWARFLINKERCOMPILEUNIT_H
diff --git a/linux-x64/clang/include/llvm/DWARFLinker/DWARFLinkerDeclContext.h b/linux-x64/clang/include/llvm/DWARFLinker/DWARFLinkerDeclContext.h
new file mode 100644
index 0000000..d227448
--- /dev/null
+++ b/linux-x64/clang/include/llvm/DWARFLinker/DWARFLinkerDeclContext.h
@@ -0,0 +1,183 @@
+//===- DWARFLinkerDeclContext.h ---------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_DWARFLINKER_DWARFLINKERDECLCONTEXT_H
+#define LLVM_DWARFLINKER_DWARFLINKERDECLCONTEXT_H
+
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/DenseMapInfo.h"
+#include "llvm/ADT/DenseSet.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/CodeGen/NonRelocatableStringpool.h"
+#include "llvm/DWARFLinker/DWARFLinkerCompileUnit.h"
+#include "llvm/DebugInfo/DWARF/DWARFDebugLine.h"
+#include "llvm/DebugInfo/DWARF/DWARFDie.h"
+#include "llvm/Support/FileSystem.h"
+#include "llvm/Support/Path.h"
+
+namespace llvm {
+
+struct DeclMapInfo;
+
+/// Small helper that resolves and caches file paths. This helps reduce the
+/// number of calls to realpath which is expensive. We assume the input are
+/// files, and cache the realpath of their parent. This way we can quickly
+/// resolve different files under the same path.
+class CachedPathResolver {
+public:
+  /// Resolve a path by calling realpath and cache its result. The returned
+  /// StringRef is interned in the given \p StringPool.
+  StringRef resolve(const std::string &Path,
+                    NonRelocatableStringpool &StringPool) {
+    StringRef FileName = sys::path::filename(Path);
+    StringRef ParentPath = sys::path::parent_path(Path);
+
+    // If the ParentPath has not yet been resolved, resolve and cache it for
+    // future look-ups.
+    if (!ResolvedPaths.count(ParentPath)) {
+      SmallString<256> RealPath;
+      sys::fs::real_path(ParentPath, RealPath);
+      ResolvedPaths.insert(
+          {ParentPath, std::string(RealPath.c_str(), RealPath.size())});
+    }
+
+    // Join the file name again with the resolved path.
+    SmallString<256> ResolvedPath(ResolvedPaths[ParentPath]);
+    sys::path::append(ResolvedPath, FileName);
+    return StringPool.internString(ResolvedPath);
+  }
+
+private:
+  StringMap<std::string> ResolvedPaths;
+};
+
+/// A DeclContext is a named program scope that is used for ODR uniquing of
+/// types.
+///
+/// The set of DeclContext for the ODR-subject parts of a Dwarf link is
+/// expanded (and uniqued) with each new object file processed. We need to
+/// determine the context of each DIE in an linked object file to see if the
+/// corresponding type has already been emitted.
+///
+/// The contexts are conceptually organized as a tree (eg. a function scope is
+/// contained in a namespace scope that contains other scopes), but
+/// storing/accessing them in an actual tree is too inefficient: we need to be
+/// able to very quickly query a context for a given child context by name.
+/// Storing a StringMap in each DeclContext would be too space inefficient.
+///
+/// The solution here is to give each DeclContext a link to its parent (this
+/// allows to walk up the tree), but to query the existence of a specific
+/// DeclContext using a separate DenseMap keyed on the hash of the fully
+/// qualified name of the context.
+class DeclContext {
+public:
+  using Map = DenseSet<DeclContext *, DeclMapInfo>;
+
+  DeclContext() : DefinedInClangModule(0), Parent(*this) {}
+
+  DeclContext(unsigned Hash, uint32_t Line, uint32_t ByteSize, uint16_t Tag,
+              StringRef Name, StringRef File, const DeclContext &Parent,
+              DWARFDie LastSeenDIE = DWARFDie(), unsigned CUId = 0)
+      : QualifiedNameHash(Hash), Line(Line), ByteSize(ByteSize), Tag(Tag),
+        DefinedInClangModule(0), Name(Name), File(File), Parent(Parent),
+        LastSeenDIE(LastSeenDIE), LastSeenCompileUnitID(CUId) {}
+
+  uint32_t getQualifiedNameHash() const { return QualifiedNameHash; }
+
+  bool setLastSeenDIE(CompileUnit &U, const DWARFDie &Die);
+
+  uint32_t getCanonicalDIEOffset() const { return CanonicalDIEOffset; }
+  void setCanonicalDIEOffset(uint32_t Offset) { CanonicalDIEOffset = Offset; }
+
+  bool isDefinedInClangModule() const { return DefinedInClangModule; }
+  void setDefinedInClangModule(bool Val) { DefinedInClangModule = Val; }
+
+  uint16_t getTag() const { return Tag; }
+
+private:
+  friend DeclMapInfo;
+
+  unsigned QualifiedNameHash = 0;
+  uint32_t Line = 0;
+  uint32_t ByteSize = 0;
+  uint16_t Tag = dwarf::DW_TAG_compile_unit;
+  unsigned DefinedInClangModule : 1;
+  StringRef Name;
+  StringRef File;
+  const DeclContext &Parent;
+  DWARFDie LastSeenDIE;
+  uint32_t LastSeenCompileUnitID = 0;
+  uint32_t CanonicalDIEOffset = 0;
+};
+
+/// This class gives a tree-like API to the DenseMap that stores the
+/// DeclContext objects. It holds the BumpPtrAllocator where these objects will
+/// be allocated.
+class DeclContextTree {
+public:
+  /// Get the child of \a Context described by \a DIE in \a Unit. The
+  /// required strings will be interned in \a StringPool.
+  /// \returns The child DeclContext along with one bit that is set if
+  /// this context is invalid.
+  ///
+  /// An invalid context means it shouldn't be considered for uniquing, but its
+  /// not returning null, because some children of that context might be
+  /// uniquing candidates.
+  ///
+  /// FIXME: The invalid bit along the return value is to emulate some
+  /// dsymutil-classic functionality.
+  PointerIntPair<DeclContext *, 1> getChildDeclContext(DeclContext &Context,
+                                                       const DWARFDie &DIE,
+                                                       CompileUnit &Unit,
+                                                       bool InClangModule);
+
+  DeclContext &getRoot() { return Root; }
+
+private:
+  BumpPtrAllocator Allocator;
+  DeclContext Root;
+  DeclContext::Map Contexts;
+
+  /// Cached resolved paths from the line table.
+  /// The key is <UniqueUnitID, FileIdx>.
+  using ResolvedPathsMap = DenseMap<std::pair<unsigned, unsigned>, StringRef>;
+  ResolvedPathsMap ResolvedPaths;
+
+  /// Helper that resolves and caches fragments of file paths.
+  CachedPathResolver PathResolver;
+
+  /// String pool keeping real path bodies.
+  NonRelocatableStringpool StringPool;
+
+  StringRef getResolvedPath(CompileUnit &CU, unsigned FileNum,
+                            const DWARFDebugLine::LineTable &LineTable);
+};
+
+/// Info type for the DenseMap storing the DeclContext pointers.
+struct DeclMapInfo : private DenseMapInfo<DeclContext *> {
+  using DenseMapInfo<DeclContext *>::getEmptyKey;
+  using DenseMapInfo<DeclContext *>::getTombstoneKey;
+
+  static unsigned getHashValue(const DeclContext *Ctxt) {
+    return Ctxt->QualifiedNameHash;
+  }
+
+  static bool isEqual(const DeclContext *LHS, const DeclContext *RHS) {
+    if (RHS == getEmptyKey() || RHS == getTombstoneKey())
+      return RHS == LHS;
+    return LHS->QualifiedNameHash == RHS->QualifiedNameHash &&
+           LHS->Line == RHS->Line && LHS->ByteSize == RHS->ByteSize &&
+           LHS->Name.data() == RHS->Name.data() &&
+           LHS->File.data() == RHS->File.data() &&
+           LHS->Parent.QualifiedNameHash == RHS->Parent.QualifiedNameHash;
+  }
+};
+
+} // end namespace llvm
+
+#endif // LLVM_DWARFLINKER_DWARFLINKERDECLCONTEXT_H
diff --git a/linux-x64/clang/include/llvm/DWARFLinker/DWARFStreamer.h b/linux-x64/clang/include/llvm/DWARFLinker/DWARFStreamer.h
new file mode 100644
index 0000000..7b08511
--- /dev/null
+++ b/linux-x64/clang/include/llvm/DWARFLinker/DWARFStreamer.h
@@ -0,0 +1,219 @@
+//===- DwarfStreamer.h ------------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_DWARFLINKER_DWARFSTREAMER_H
+#define LLVM_DWARFLINKER_DWARFSTREAMER_H
+
+#include "llvm/CodeGen/AccelTable.h"
+#include "llvm/CodeGen/AsmPrinter.h"
+#include "llvm/DWARFLinker/DWARFLinker.h"
+#include "llvm/MC/MCAsmInfo.h"
+#include "llvm/MC/MCContext.h"
+#include "llvm/MC/MCInstrInfo.h"
+#include "llvm/MC/MCObjectFileInfo.h"
+#include "llvm/MC/MCRegisterInfo.h"
+#include "llvm/Target/TargetMachine.h"
+
+namespace llvm {
+
+enum class OutputFileType {
+  Object,
+  Assembly,
+};
+
+///   User of DwarfStreamer should call initialization code
+///   for AsmPrinter:
+///
+///   InitializeAllTargetInfos();
+///   InitializeAllTargetMCs();
+///   InitializeAllTargets();
+///   InitializeAllAsmPrinters();
+
+class MCCodeEmitter;
+
+/// The Dwarf streaming logic.
+///
+/// All interactions with the MC layer that is used to build the debug
+/// information binary representation are handled in this class.
+class DwarfStreamer : public DwarfEmitter {
+public:
+  DwarfStreamer(OutputFileType OutFileType, raw_pwrite_stream &OutFile,
+                std::function<StringRef(StringRef Input)> Translator,
+                bool Minimize, messageHandler Error, messageHandler Warning)
+      : OutFile(OutFile), OutFileType(OutFileType), Translator(Translator),
+        Minimize(Minimize), ErrorHandler(Error), WarningHandler(Warning) {}
+
+  bool init(Triple TheTriple);
+
+  /// Dump the file to the disk.
+  void finish();
+
+  AsmPrinter &getAsmPrinter() const { return *Asm; }
+
+  /// Set the current output section to debug_info and change
+  /// the MC Dwarf version to \p DwarfVersion.
+  void switchToDebugInfoSection(unsigned DwarfVersion);
+
+  /// Emit the compilation unit header for \p Unit in the
+  /// debug_info section.
+  ///
+  /// As a side effect, this also switches the current Dwarf version
+  /// of the MC layer to the one of U.getOrigUnit().
+  void emitCompileUnitHeader(CompileUnit &Unit, unsigned DwarfVersion) override;
+
+  /// Recursively emit the DIE tree rooted at \p Die.
+  void emitDIE(DIE &Die) override;
+
+  /// Emit the abbreviation table \p Abbrevs to the debug_abbrev section.
+  void emitAbbrevs(const std::vector<std::unique_ptr<DIEAbbrev>> &Abbrevs,
+                   unsigned DwarfVersion) override;
+
+  /// Emit DIE containing warnings.
+  void emitPaperTrailWarningsDie(DIE &Die) override;
+
+  /// Emit contents of section SecName From Obj.
+  void emitSectionContents(StringRef SecData, StringRef SecName) override;
+
+  /// Emit the string table described by \p Pool.
+  void emitStrings(const NonRelocatableStringpool &Pool) override;
+
+  /// Emit the swift_ast section stored in \p Buffer.
+  void emitSwiftAST(StringRef Buffer);
+
+  /// Emit debug_ranges for \p FuncRange by translating the
+  /// original \p Entries.
+  void emitRangesEntries(
+      int64_t UnitPcOffset, uint64_t OrigLowPc,
+      const FunctionIntervals::const_iterator &FuncRange,
+      const std::vector<DWARFDebugRangeList::RangeListEntry> &Entries,
+      unsigned AddressSize) override;
+
+  /// Emit debug_aranges entries for \p Unit and if \p DoRangesSection is true,
+  /// also emit the debug_ranges entries for the DW_TAG_compile_unit's
+  /// DW_AT_ranges attribute.
+  void emitUnitRangesEntries(CompileUnit &Unit, bool DoRangesSection) override;
+
+  uint64_t getRangesSectionSize() const override { return RangesSectionSize; }
+
+  /// Emit the debug_loc contribution for \p Unit by copying the entries from
+  /// \p Dwarf and offsetting them. Update the location attributes to point to
+  /// the new entries.
+  void emitLocationsForUnit(
+      const CompileUnit &Unit, DWARFContext &Dwarf,
+      std::function<void(StringRef, SmallVectorImpl<uint8_t> &)> ProcessExpr)
+      override;
+
+  /// Emit the line table described in \p Rows into the debug_line section.
+  void emitLineTableForUnit(MCDwarfLineTableParams Params,
+                            StringRef PrologueBytes, unsigned MinInstLength,
+                            std::vector<DWARFDebugLine::Row> &Rows,
+                            unsigned AdddressSize) override;
+
+  /// Copy the debug_line over to the updated binary while unobfuscating the
+  /// file names and directories.
+  void translateLineTable(DataExtractor LineData, uint64_t Offset) override;
+
+  uint64_t getLineSectionSize() const override { return LineSectionSize; }
+
+  /// Emit the .debug_pubnames contribution for \p Unit.
+  void emitPubNamesForUnit(const CompileUnit &Unit) override;
+
+  /// Emit the .debug_pubtypes contribution for \p Unit.
+  void emitPubTypesForUnit(const CompileUnit &Unit) override;
+
+  /// Emit a CIE.
+  void emitCIE(StringRef CIEBytes) override;
+
+  /// Emit an FDE with data \p Bytes.
+  void emitFDE(uint32_t CIEOffset, uint32_t AddreSize, uint32_t Address,
+               StringRef Bytes) override;
+
+  /// Emit DWARF debug names.
+  void emitDebugNames(AccelTable<DWARF5AccelTableStaticData> &Table) override;
+
+  /// Emit Apple namespaces accelerator table.
+  void emitAppleNamespaces(
+      AccelTable<AppleAccelTableStaticOffsetData> &Table) override;
+
+  /// Emit Apple names accelerator table.
+  void
+  emitAppleNames(AccelTable<AppleAccelTableStaticOffsetData> &Table) override;
+
+  /// Emit Apple Objective-C accelerator table.
+  void
+  emitAppleObjc(AccelTable<AppleAccelTableStaticOffsetData> &Table) override;
+
+  /// Emit Apple type accelerator table.
+  void
+  emitAppleTypes(AccelTable<AppleAccelTableStaticTypeData> &Table) override;
+
+  uint64_t getFrameSectionSize() const override { return FrameSectionSize; }
+
+  uint64_t getDebugInfoSectionSize() const override {
+    return DebugInfoSectionSize;
+  }
+
+private:
+  inline void error(const Twine &Error, StringRef Context = "") {
+    if (ErrorHandler)
+      ErrorHandler(Error, Context, nullptr);
+  }
+
+  inline void warn(const Twine &Warning, StringRef Context = "") {
+    if (WarningHandler)
+      WarningHandler(Warning, Context, nullptr);
+  }
+
+  /// \defgroup MCObjects MC layer objects constructed by the streamer
+  /// @{
+  std::unique_ptr<MCRegisterInfo> MRI;
+  std::unique_ptr<MCAsmInfo> MAI;
+  std::unique_ptr<MCObjectFileInfo> MOFI;
+  std::unique_ptr<MCContext> MC;
+  MCAsmBackend *MAB; // Owned by MCStreamer
+  std::unique_ptr<MCInstrInfo> MII;
+  std::unique_ptr<MCSubtargetInfo> MSTI;
+  MCInstPrinter *MIP; // Owned by AsmPrinter
+  MCCodeEmitter *MCE; // Owned by MCStreamer
+  MCStreamer *MS;     // Owned by AsmPrinter
+  std::unique_ptr<TargetMachine> TM;
+  std::unique_ptr<AsmPrinter> Asm;
+  /// @}
+
+  /// The output file we stream the linked Dwarf to.
+  raw_pwrite_stream &OutFile;
+  OutputFileType OutFileType = OutputFileType::Object;
+  std::function<StringRef(StringRef Input)> Translator;
+  bool Minimize = true;
+
+  uint64_t RangesSectionSize = 0;
+  uint64_t LocSectionSize = 0;
+  uint64_t LineSectionSize = 0;
+  uint64_t FrameSectionSize = 0;
+  uint64_t DebugInfoSectionSize = 0;
+
+  /// Keep track of emitted CUs and their Unique ID.
+  struct EmittedUnit {
+    unsigned ID;
+    MCSymbol *LabelBegin;
+  };
+  std::vector<EmittedUnit> EmittedUnits;
+
+  /// Emit the pubnames or pubtypes section contribution for \p
+  /// Unit into \p Sec. The data is provided in \p Names.
+  void emitPubSectionForUnit(MCSection *Sec, StringRef Name,
+                             const CompileUnit &Unit,
+                             const std::vector<CompileUnit::AccelInfo> &Names);
+
+  messageHandler ErrorHandler = nullptr;
+  messageHandler WarningHandler = nullptr;
+};
+
+} // end namespace llvm
+
+#endif // LLVM_DWARFLINKER_DWARFSTREAMER_H
diff --git a/linux-x64/clang/include/llvm/DebugInfo/CodeView/AppendingTypeTableBuilder.h b/linux-x64/clang/include/llvm/DebugInfo/CodeView/AppendingTypeTableBuilder.h
index 0ac8b65..3867d78 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/CodeView/AppendingTypeTableBuilder.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/CodeView/AppendingTypeTableBuilder.h
@@ -38,7 +38,7 @@
   explicit AppendingTypeTableBuilder(BumpPtrAllocator &Storage);
   ~AppendingTypeTableBuilder();
 
-  // TypeTableCollection overrides
+  // TypeCollection overrides
   Optional<TypeIndex> getFirst() override;
   Optional<TypeIndex> getNext(TypeIndex Prev) override;
   CVType getType(TypeIndex Index) override;
@@ -46,6 +46,7 @@
   bool contains(TypeIndex Index) override;
   uint32_t size() override;
   uint32_t capacity() override;
+  bool replaceType(TypeIndex &Index, CVType Data, bool Stabilize) override;
 
   // public interface
   void reset();
diff --git a/linux-x64/clang/include/llvm/DebugInfo/CodeView/CVRecord.h b/linux-x64/clang/include/llvm/DebugInfo/CodeView/CVRecord.h
index 784c47e..bb29ef5 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/CodeView/CVRecord.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/CodeView/CVRecord.h
@@ -11,9 +11,9 @@
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Optional.h"
+#include "llvm/DebugInfo/CodeView/CodeView.h"
 #include "llvm/DebugInfo/CodeView/CodeViewError.h"
 #include "llvm/DebugInfo/CodeView/RecordSerialization.h"
-#include "llvm/DebugInfo/CodeView/TypeIndex.h"
 #include "llvm/Support/BinaryStreamReader.h"
 #include "llvm/Support/BinaryStreamRef.h"
 #include "llvm/Support/Endian.h"
@@ -61,12 +61,9 @@
   ArrayRef<uint8_t> RecordData;
 };
 
-template <typename Kind> struct RemappedRecord {
-  explicit RemappedRecord(const CVRecord<Kind> &R) : OriginalRecord(R) {}
-
-  CVRecord<Kind> OriginalRecord;
-  SmallVector<std::pair<uint32_t, TypeIndex>, 8> Mappings;
-};
+// There are two kinds of codeview records: type and symbol records.
+using CVType = CVRecord<TypeLeafKind>;
+using CVSymbol = CVRecord<SymbolKind>;
 
 template <typename Record, typename Func>
 Error forEachCodeViewRecord(ArrayRef<uint8_t> StreamBuffer, Func F) {
@@ -126,6 +123,12 @@
   }
 };
 
+namespace codeview {
+using CVSymbolArray = VarStreamArray<CVSymbol>;
+using CVTypeArray = VarStreamArray<CVType>;
+using CVTypeRange = iterator_range<CVTypeArray::Iterator>;
+} // namespace codeview
+
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_CODEVIEW_RECORDITERATOR_H
diff --git a/linux-x64/clang/include/llvm/DebugInfo/CodeView/CVSymbolVisitor.h b/linux-x64/clang/include/llvm/DebugInfo/CodeView/CVSymbolVisitor.h
index 1615ff4..82ef8c1 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/CodeView/CVSymbolVisitor.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/CodeView/CVSymbolVisitor.h
@@ -10,9 +10,6 @@
 #define LLVM_DEBUGINFO_CODEVIEW_CVSYMBOLVISITOR_H
 
 #include "llvm/DebugInfo/CodeView/CVRecord.h"
-#include "llvm/DebugInfo/CodeView/CodeView.h"
-#include "llvm/DebugInfo/CodeView/SymbolRecord.h"
-#include "llvm/DebugInfo/CodeView/SymbolVisitorDelegate.h"
 #include "llvm/Support/ErrorOr.h"
 
 namespace llvm {
diff --git a/linux-x64/clang/include/llvm/DebugInfo/CodeView/CVTypeVisitor.h b/linux-x64/clang/include/llvm/DebugInfo/CodeView/CVTypeVisitor.h
index 7d20bb0..7538cb2 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/CodeView/CVTypeVisitor.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/CodeView/CVTypeVisitor.h
@@ -11,7 +11,6 @@
 
 #include "llvm/DebugInfo/CodeView/CVRecord.h"
 #include "llvm/DebugInfo/CodeView/TypeRecord.h"
-#include "llvm/DebugInfo/CodeView/TypeVisitorCallbackPipeline.h"
 #include "llvm/Support/Error.h"
 
 namespace llvm {
@@ -31,9 +30,6 @@
 Error visitTypeRecord(CVType &Record, TypeIndex Index,
                       TypeVisitorCallbacks &Callbacks,
                       VisitorDataSource Source = VDS_BytesPresent);
-Error visitTypeRecord(CVType &Record, TypeIndex Index,
-                      TypeVisitorCallbackPipeline &Callbacks,
-                      VisitorDataSource Source = VDS_BytesPresent);
 Error visitTypeRecord(CVType &Record, TypeVisitorCallbacks &Callbacks,
                       VisitorDataSource Source = VDS_BytesPresent);
 
diff --git a/linux-x64/clang/include/llvm/DebugInfo/CodeView/CodeViewRecordIO.h b/linux-x64/clang/include/llvm/DebugInfo/CodeView/CodeViewRecordIO.h
index d3bad4c..d851dea 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/CodeView/CodeViewRecordIO.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/CodeView/CodeViewRecordIO.h
@@ -15,7 +15,8 @@
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/DebugInfo/CodeView/CodeViewError.h"
-#include "llvm/DebugInfo/CodeView/TypeRecord.h"
+#include "llvm/DebugInfo/CodeView/GUID.h"
+#include "llvm/DebugInfo/CodeView/TypeIndex.h"
 #include "llvm/Support/BinaryStreamReader.h"
 #include "llvm/Support/BinaryStreamWriter.h"
 #include "llvm/Support/Error.h"
@@ -29,9 +30,13 @@
 
 class CodeViewRecordStreamer {
 public:
-  virtual void EmitBytes(StringRef Data) = 0;
-  virtual void EmitIntValue(uint64_t Value, unsigned Size) = 0;
-  virtual void EmitBinaryData(StringRef Data) = 0;
+  virtual void emitBytes(StringRef Data) = 0;
+  virtual void emitIntValue(uint64_t Value, unsigned Size) = 0;
+  virtual void emitBinaryData(StringRef Data) = 0;
+  virtual void AddComment(const Twine &T) = 0;
+  virtual void AddRawComment(const Twine &T) = 0;
+  virtual bool isVerboseAsm() = 0;
+  virtual std::string getTypeName(TypeIndex TI) = 0;
   virtual ~CodeViewRecordStreamer() = default;
 };
 
@@ -59,7 +64,7 @@
   Error beginRecord(Optional<uint32_t> MaxLength);
   Error endRecord();
 
-  Error mapInteger(TypeIndex &TypeInd);
+  Error mapInteger(TypeIndex &TypeInd, const Twine &Comment = "");
 
   bool isStreaming() const {
     return (Streamer != nullptr) && (Reader == nullptr) && (Writer == nullptr);
@@ -77,7 +82,7 @@
     if (isStreaming()) {
       StringRef BytesSR =
           StringRef((reinterpret_cast<const char *>(&Value)), sizeof(Value));
-      Streamer->EmitBytes(BytesSR);
+      Streamer->emitBytes(BytesSR);
       incrStreamedLen(sizeof(T));
       return Error::success();
     }
@@ -92,9 +97,10 @@
     return Error::success();
   }
 
-  template <typename T> Error mapInteger(T &Value) {
+  template <typename T> Error mapInteger(T &Value, const Twine &Comment = "") {
     if (isStreaming()) {
-      Streamer->EmitIntValue((int)Value, sizeof(T));
+      emitComment(Comment);
+      Streamer->emitIntValue((int)Value, sizeof(T));
       incrStreamedLen(sizeof(T));
       return Error::success();
     }
@@ -105,17 +111,17 @@
     return Reader->readInteger(Value);
   }
 
-  template <typename T> Error mapEnum(T &Value) {
+  template <typename T> Error mapEnum(T &Value, const Twine &Comment = "") {
     if (!isStreaming() && sizeof(Value) > maxFieldLength())
       return make_error<CodeViewError>(cv_error_code::insufficient_buffer);
 
-    using U = typename std::underlying_type<T>::type;
+    using U = std::underlying_type_t<T>;
     U X;
 
     if (isWriting() || isStreaming())
       X = static_cast<U>(Value);
 
-    if (auto EC = mapInteger(X))
+    if (auto EC = mapInteger(X, Comment))
       return EC;
 
     if (isReading())
@@ -124,20 +130,23 @@
     return Error::success();
   }
 
-  Error mapEncodedInteger(int64_t &Value);
-  Error mapEncodedInteger(uint64_t &Value);
-  Error mapEncodedInteger(APSInt &Value);
-  Error mapStringZ(StringRef &Value);
-  Error mapGuid(GUID &Guid);
+  Error mapEncodedInteger(int64_t &Value, const Twine &Comment = "");
+  Error mapEncodedInteger(uint64_t &Value, const Twine &Comment = "");
+  Error mapEncodedInteger(APSInt &Value, const Twine &Comment = "");
+  Error mapStringZ(StringRef &Value, const Twine &Comment = "");
+  Error mapGuid(GUID &Guid, const Twine &Comment = "");
 
-  Error mapStringZVectorZ(std::vector<StringRef> &Value);
+  Error mapStringZVectorZ(std::vector<StringRef> &Value,
+                          const Twine &Comment = "");
 
   template <typename SizeType, typename T, typename ElementMapper>
-  Error mapVectorN(T &Items, const ElementMapper &Mapper) {
+  Error mapVectorN(T &Items, const ElementMapper &Mapper,
+                   const Twine &Comment = "") {
     SizeType Size;
     if (isStreaming()) {
       Size = static_cast<SizeType>(Items.size());
-      Streamer->EmitIntValue(Size, sizeof(Size));
+      emitComment(Comment);
+      Streamer->emitIntValue(Size, sizeof(Size));
       incrStreamedLen(sizeof(Size)); // add 1 for the delimiter
 
       for (auto &X : Items) {
@@ -168,7 +177,9 @@
   }
 
   template <typename T, typename ElementMapper>
-  Error mapVectorTail(T &Items, const ElementMapper &Mapper) {
+  Error mapVectorTail(T &Items, const ElementMapper &Mapper,
+                      const Twine &Comment = "") {
+    emitComment(Comment);
     if (isStreaming() || isWriting()) {
       for (auto &Item : Items) {
         if (auto EC = Mapper(*this, Item))
@@ -186,8 +197,9 @@
     return Error::success();
   }
 
-  Error mapByteVectorTail(ArrayRef<uint8_t> &Bytes);
-  Error mapByteVectorTail(std::vector<uint8_t> &Bytes);
+  Error mapByteVectorTail(ArrayRef<uint8_t> &Bytes, const Twine &Comment = "");
+  Error mapByteVectorTail(std::vector<uint8_t> &Bytes,
+                          const Twine &Comment = "");
 
   Error padToAlignment(uint32_t Align);
   Error skipPadding();
@@ -198,9 +210,16 @@
     return 0;
   }
 
+  void emitRawComment(const Twine &T) {
+    if (isStreaming() && Streamer->isVerboseAsm())
+      Streamer->AddRawComment(T);
+  }
+
 private:
-  void emitEncodedSignedInteger(const int64_t &Value);
-  void emitEncodedUnsignedInteger(const uint64_t &Value);
+  void emitEncodedSignedInteger(const int64_t &Value,
+                                const Twine &Comment = "");
+  void emitEncodedUnsignedInteger(const uint64_t &Value,
+                                  const Twine &Comment = "");
   Error writeEncodedSignedInteger(const int64_t &Value);
   Error writeEncodedUnsignedInteger(const uint64_t &Value);
 
@@ -214,6 +233,14 @@
       StreamedLen = 4; // The record prefix is 4 bytes long
   }
 
+  void emitComment(const Twine &Comment) {
+    if (isStreaming() && Streamer->isVerboseAsm()) {
+      Twine TComment(Comment);
+      if (!TComment.isTriviallyEmpty())
+        Streamer->AddComment(TComment);
+    }
+  }
+
   struct RecordLimit {
     uint32_t BeginOffset;
     Optional<uint32_t> MaxLength;
diff --git a/linux-x64/clang/include/llvm/DebugInfo/CodeView/CodeViewRegisters.def b/linux-x64/clang/include/llvm/DebugInfo/CodeView/CodeViewRegisters.def
index 9767e49..48ea7e5 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/CodeView/CodeViewRegisters.def
+++ b/linux-x64/clang/include/llvm/DebugInfo/CodeView/CodeViewRegisters.def
@@ -15,6 +15,7 @@
 #endif
 
 #if !defined(CV_REGISTERS_ALL) && !defined(CV_REGISTERS_X86) &&                \
+    !defined(CV_REGISTERS_ARM) &&                                              \
     !defined(CV_REGISTERS_ARM64)
 #error Need include at least one register set.
 #endif
@@ -366,8 +367,167 @@
 
 #endif // defined(CV_REGISTERS_ALL) || defined(CV_REGISTERS_X86)
 
+#if defined(CV_REGISTERS_ALL) || defined(CV_REGISTERS_ARM)
+
+// ARM registers
+
+CV_REGISTER(ARM_NOREG, 0)
+
+// General purpose 32-bit integer regisers
+
+CV_REGISTER(ARM_R0, 10)
+CV_REGISTER(ARM_R1, 11)
+CV_REGISTER(ARM_R2, 12)
+CV_REGISTER(ARM_R3, 13)
+CV_REGISTER(ARM_R4, 14)
+CV_REGISTER(ARM_R5, 15)
+CV_REGISTER(ARM_R6, 16)
+CV_REGISTER(ARM_R7, 17)
+CV_REGISTER(ARM_R8, 18)
+CV_REGISTER(ARM_R9, 19)
+CV_REGISTER(ARM_R10, 20)
+CV_REGISTER(ARM_R11, 21)
+CV_REGISTER(ARM_R12, 22)
+CV_REGISTER(ARM_SP, 23)
+CV_REGISTER(ARM_LR, 24)
+CV_REGISTER(ARM_PC, 25)
+
+// Status register
+
+CV_REGISTER(ARM_CPSR, 26)
+
+// ARM VFPv1 registers
+
+CV_REGISTER(ARM_FPSCR, 40)
+CV_REGISTER(ARM_FPEXC, 41)
+
+CV_REGISTER(ARM_FS0, 50)
+CV_REGISTER(ARM_FS1, 51)
+CV_REGISTER(ARM_FS2, 52)
+CV_REGISTER(ARM_FS3, 53)
+CV_REGISTER(ARM_FS4, 54)
+CV_REGISTER(ARM_FS5, 55)
+CV_REGISTER(ARM_FS6, 56)
+CV_REGISTER(ARM_FS7, 57)
+CV_REGISTER(ARM_FS8, 58)
+CV_REGISTER(ARM_FS9, 59)
+CV_REGISTER(ARM_FS10, 60)
+CV_REGISTER(ARM_FS11, 61)
+CV_REGISTER(ARM_FS12, 62)
+CV_REGISTER(ARM_FS13, 63)
+CV_REGISTER(ARM_FS14, 64)
+CV_REGISTER(ARM_FS15, 65)
+CV_REGISTER(ARM_FS16, 66)
+CV_REGISTER(ARM_FS17, 67)
+CV_REGISTER(ARM_FS18, 68)
+CV_REGISTER(ARM_FS19, 69)
+CV_REGISTER(ARM_FS20, 70)
+CV_REGISTER(ARM_FS21, 71)
+CV_REGISTER(ARM_FS22, 72)
+CV_REGISTER(ARM_FS23, 73)
+CV_REGISTER(ARM_FS24, 74)
+CV_REGISTER(ARM_FS25, 75)
+CV_REGISTER(ARM_FS26, 76)
+CV_REGISTER(ARM_FS27, 77)
+CV_REGISTER(ARM_FS28, 78)
+CV_REGISTER(ARM_FS29, 79)
+CV_REGISTER(ARM_FS30, 80)
+CV_REGISTER(ARM_FS31, 81)
+
+// ARM VFPv3/NEON registers
+
+CV_REGISTER(ARM_FS32, 200)
+CV_REGISTER(ARM_FS33, 201)
+CV_REGISTER(ARM_FS34, 202)
+CV_REGISTER(ARM_FS35, 203)
+CV_REGISTER(ARM_FS36, 204)
+CV_REGISTER(ARM_FS37, 205)
+CV_REGISTER(ARM_FS38, 206)
+CV_REGISTER(ARM_FS39, 207)
+CV_REGISTER(ARM_FS40, 208)
+CV_REGISTER(ARM_FS41, 209)
+CV_REGISTER(ARM_FS42, 210)
+CV_REGISTER(ARM_FS43, 211)
+CV_REGISTER(ARM_FS44, 212)
+CV_REGISTER(ARM_FS45, 213)
+CV_REGISTER(ARM_FS46, 214)
+CV_REGISTER(ARM_FS47, 215)
+CV_REGISTER(ARM_FS48, 216)
+CV_REGISTER(ARM_FS49, 217)
+CV_REGISTER(ARM_FS50, 218)
+CV_REGISTER(ARM_FS51, 219)
+CV_REGISTER(ARM_FS52, 220)
+CV_REGISTER(ARM_FS53, 221)
+CV_REGISTER(ARM_FS54, 222)
+CV_REGISTER(ARM_FS55, 223)
+CV_REGISTER(ARM_FS56, 224)
+CV_REGISTER(ARM_FS57, 225)
+CV_REGISTER(ARM_FS58, 226)
+CV_REGISTER(ARM_FS59, 227)
+CV_REGISTER(ARM_FS60, 228)
+CV_REGISTER(ARM_FS61, 229)
+CV_REGISTER(ARM_FS62, 230)
+CV_REGISTER(ARM_FS63, 231)
+
+CV_REGISTER(ARM_ND0, 300)
+CV_REGISTER(ARM_ND1, 301)
+CV_REGISTER(ARM_ND2, 302)
+CV_REGISTER(ARM_ND3, 303)
+CV_REGISTER(ARM_ND4, 304)
+CV_REGISTER(ARM_ND5, 305)
+CV_REGISTER(ARM_ND6, 306)
+CV_REGISTER(ARM_ND7, 307)
+CV_REGISTER(ARM_ND8, 308)
+CV_REGISTER(ARM_ND9, 309)
+CV_REGISTER(ARM_ND10, 310)
+CV_REGISTER(ARM_ND11, 311)
+CV_REGISTER(ARM_ND12, 312)
+CV_REGISTER(ARM_ND13, 313)
+CV_REGISTER(ARM_ND14, 314)
+CV_REGISTER(ARM_ND15, 315)
+CV_REGISTER(ARM_ND16, 316)
+CV_REGISTER(ARM_ND17, 317)
+CV_REGISTER(ARM_ND18, 318)
+CV_REGISTER(ARM_ND19, 319)
+CV_REGISTER(ARM_ND20, 320)
+CV_REGISTER(ARM_ND21, 321)
+CV_REGISTER(ARM_ND22, 322)
+CV_REGISTER(ARM_ND23, 323)
+CV_REGISTER(ARM_ND24, 324)
+CV_REGISTER(ARM_ND25, 325)
+CV_REGISTER(ARM_ND26, 326)
+CV_REGISTER(ARM_ND27, 327)
+CV_REGISTER(ARM_ND28, 328)
+CV_REGISTER(ARM_ND29, 329)
+CV_REGISTER(ARM_ND30, 330)
+CV_REGISTER(ARM_ND31, 331)
+
+CV_REGISTER(ARM_NQ0, 400)
+CV_REGISTER(ARM_NQ1, 401)
+CV_REGISTER(ARM_NQ2, 402)
+CV_REGISTER(ARM_NQ3, 403)
+CV_REGISTER(ARM_NQ4, 404)
+CV_REGISTER(ARM_NQ5, 405)
+CV_REGISTER(ARM_NQ6, 406)
+CV_REGISTER(ARM_NQ7, 407)
+CV_REGISTER(ARM_NQ8, 408)
+CV_REGISTER(ARM_NQ9, 409)
+CV_REGISTER(ARM_NQ10, 410)
+CV_REGISTER(ARM_NQ11, 411)
+CV_REGISTER(ARM_NQ12, 412)
+CV_REGISTER(ARM_NQ13, 413)
+CV_REGISTER(ARM_NQ14, 414)
+CV_REGISTER(ARM_NQ15, 415)
+
+#endif // defined(CV_REGISTERS_ALL) || defined(CV_REGISTERS_ARM)
+
 #if defined(CV_REGISTERS_ALL) || defined(CV_REGISTERS_ARM64)
 
+// arm64intr.h from MSVC defines ARM64_FPSR, which conflicts with
+// these declarations.
+#pragma push_macro("ARM64_FPSR")
+#undef ARM64_FPSR
+
 // ARM64 registers
 
 CV_REGISTER(ARM64_NOREG, 0)
@@ -556,4 +716,6 @@
 
 CV_REGISTER(ARM64_FPSR, 220)
 
+#pragma pop_macro("ARM64_FPSR")
+
 #endif // defined(CV_REGISTERS_ALL) || defined(CV_REGISTERS_ARM64)
diff --git a/linux-x64/clang/include/llvm/DebugInfo/CodeView/ContinuationRecordBuilder.h b/linux-x64/clang/include/llvm/DebugInfo/CodeView/ContinuationRecordBuilder.h
index cd67f78..0e2f5d9 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/CodeView/ContinuationRecordBuilder.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/CodeView/ContinuationRecordBuilder.h
@@ -18,7 +18,6 @@
 #include "llvm/DebugInfo/CodeView/TypeRecord.h"
 #include "llvm/DebugInfo/CodeView/TypeRecordMapping.h"
 #include "llvm/DebugInfo/CodeView/TypeVisitorCallbacks.h"
-#include "llvm/Support/Allocator.h"
 #include "llvm/Support/BinaryByteStream.h"
 #include "llvm/Support/BinaryStreamWriter.h"
 #include "llvm/Support/Error.h"
@@ -61,4 +60,4 @@
 } // namespace codeview
 } // namespace llvm
 
-#endif
\ No newline at end of file
+#endif
diff --git a/linux-x64/clang/include/llvm/DebugInfo/CodeView/DebugSubsectionRecord.h b/linux-x64/clang/include/llvm/DebugInfo/CodeView/DebugSubsectionRecord.h
index bcb379f..e915d8a 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/CodeView/DebugSubsectionRecord.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/CodeView/DebugSubsectionRecord.h
@@ -35,44 +35,38 @@
 class DebugSubsectionRecord {
 public:
   DebugSubsectionRecord();
-  DebugSubsectionRecord(DebugSubsectionKind Kind, BinaryStreamRef Data,
-                        CodeViewContainer Container);
+  DebugSubsectionRecord(DebugSubsectionKind Kind, BinaryStreamRef Data);
 
-  static Error initialize(BinaryStreamRef Stream, DebugSubsectionRecord &Info,
-                          CodeViewContainer Container);
+  static Error initialize(BinaryStreamRef Stream, DebugSubsectionRecord &Info);
 
   uint32_t getRecordLength() const;
   DebugSubsectionKind kind() const;
   BinaryStreamRef getRecordData() const;
 
 private:
-  CodeViewContainer Container = CodeViewContainer::ObjectFile;
   DebugSubsectionKind Kind = DebugSubsectionKind::None;
   BinaryStreamRef Data;
 };
 
 class DebugSubsectionRecordBuilder {
 public:
-  DebugSubsectionRecordBuilder(std::shared_ptr<DebugSubsection> Subsection,
-                               CodeViewContainer Container);
+  DebugSubsectionRecordBuilder(std::shared_ptr<DebugSubsection> Subsection);
 
   /// Use this to copy existing subsections directly from source to destination.
   /// For example, line table subsections in an object file only need to be
   /// relocated before being copied into the PDB.
-  DebugSubsectionRecordBuilder(const DebugSubsectionRecord &Contents,
-                               CodeViewContainer Container);
+  DebugSubsectionRecordBuilder(const DebugSubsectionRecord &Contents);
 
-  uint32_t calculateSerializedLength();
-  Error commit(BinaryStreamWriter &Writer) const;
+  uint32_t calculateSerializedLength() const;
+  Error commit(BinaryStreamWriter &Writer, CodeViewContainer Container) const;
 
 private:
   /// The subsection to build. Will be null if Contents is non-empty.
   std::shared_ptr<DebugSubsection> Subsection;
 
   /// The bytes of the subsection. Only non-empty if Subsection is null.
+  /// FIXME: Reduce the size of this.
   DebugSubsectionRecord Contents;
-
-  CodeViewContainer Container;
 };
 
 } // end namespace codeview
@@ -83,8 +77,7 @@
     // FIXME: We need to pass the container type through to this function.  In
     // practice this isn't super important since the subsection header describes
     // its length and we can just skip it.  It's more important when writing.
-    if (auto EC = codeview::DebugSubsectionRecord::initialize(
-            Stream, Info, codeview::CodeViewContainer::Pdb))
+    if (auto EC = codeview::DebugSubsectionRecord::initialize(Stream, Info))
       return EC;
     Length = alignTo(Info.getRecordLength(), 4);
     return Error::success();
diff --git a/linux-x64/clang/include/llvm/DebugInfo/CodeView/DebugSubsectionVisitor.h b/linux-x64/clang/include/llvm/DebugInfo/CodeView/DebugSubsectionVisitor.h
index 720b1b4..624a623 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/CodeView/DebugSubsectionVisitor.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/CodeView/DebugSubsectionVisitor.h
@@ -10,10 +10,8 @@
 #define LLVM_DEBUGINFO_CODEVIEW_MODULEDEBUGFRAGMENTVISITOR_H
 
 #include "llvm/DebugInfo/CodeView/CodeView.h"
-#include "llvm/DebugInfo/CodeView/DebugSubsectionRecord.h"
 #include "llvm/DebugInfo/CodeView/StringsAndChecksums.h"
 #include "llvm/Support/Error.h"
-#include <cstdint>
 
 namespace llvm {
 
@@ -30,7 +28,6 @@
 class DebugSymbolRVASubsectionRef;
 class DebugSymbolsSubsectionRef;
 class DebugUnknownSubsectionRef;
-class StringsAndChecksumsRef;
 
 class DebugSubsectionVisitor {
 public:
diff --git a/linux-x64/clang/include/llvm/DebugInfo/CodeView/DebugSymbolsSubsection.h b/linux-x64/clang/include/llvm/DebugInfo/CodeView/DebugSymbolsSubsection.h
index 784fc59..51b8523 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/CodeView/DebugSymbolsSubsection.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/CodeView/DebugSymbolsSubsection.h
@@ -9,8 +9,8 @@
 #ifndef LLVM_DEBUGINFO_CODEVIEW_DEBUGSYMBOLSSUBSECTION_H
 #define LLVM_DEBUGINFO_CODEVIEW_DEBUGSYMBOLSSUBSECTION_H
 
+#include "llvm/DebugInfo/CodeView/CVRecord.h"
 #include "llvm/DebugInfo/CodeView/DebugSubsection.h"
-#include "llvm/DebugInfo/CodeView/SymbolRecord.h"
 #include "llvm/Support/Error.h"
 
 namespace llvm {
diff --git a/linux-x64/clang/include/llvm/DebugInfo/CodeView/EnumTables.h b/linux-x64/clang/include/llvm/DebugInfo/CodeView/EnumTables.h
index ed126ed..270cd4b 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/CodeView/EnumTables.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/CodeView/EnumTables.h
@@ -37,6 +37,17 @@
 ArrayRef<EnumEntry<uint16_t>> getTrampolineNames();
 ArrayRef<EnumEntry<COFF::SectionCharacteristics>>
 getImageSectionCharacteristicNames();
+ArrayRef<EnumEntry<uint16_t>> getClassOptionNames();
+ArrayRef<EnumEntry<uint8_t>> getMemberAccessNames();
+ArrayRef<EnumEntry<uint16_t>> getMethodOptionNames();
+ArrayRef<EnumEntry<uint16_t>> getMemberKindNames();
+ArrayRef<EnumEntry<uint8_t>> getPtrKindNames();
+ArrayRef<EnumEntry<uint8_t>> getPtrModeNames();
+ArrayRef<EnumEntry<uint16_t>> getPtrMemberRepNames();
+ArrayRef<EnumEntry<uint16_t>> getTypeModifierNames();
+ArrayRef<EnumEntry<uint8_t>> getCallingConventions();
+ArrayRef<EnumEntry<uint8_t>> getFunctionOptionEnum();
+ArrayRef<EnumEntry<uint16_t>> getLabelTypeEnum();
 
 } // end namespace codeview
 } // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/DebugInfo/CodeView/GlobalTypeTableBuilder.h b/linux-x64/clang/include/llvm/DebugInfo/CodeView/GlobalTypeTableBuilder.h
index a43ce20..8c22eaf 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/CodeView/GlobalTypeTableBuilder.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/CodeView/GlobalTypeTableBuilder.h
@@ -43,14 +43,14 @@
   /// Contains a list of all records indexed by TypeIndex.toArrayIndex().
   SmallVector<ArrayRef<uint8_t>, 2> SeenRecords;
 
-  /// Contains a list of all hash values inexed by TypeIndex.toArrayIndex().
+  /// Contains a list of all hash values indexed by TypeIndex.toArrayIndex().
   SmallVector<GloballyHashedType, 2> SeenHashes;
 
 public:
   explicit GlobalTypeTableBuilder(BumpPtrAllocator &Storage);
   ~GlobalTypeTableBuilder();
 
-  // TypeTableCollection overrides
+  // TypeCollection overrides
   Optional<TypeIndex> getFirst() override;
   Optional<TypeIndex> getNext(TypeIndex Prev) override;
   CVType getType(TypeIndex Index) override;
@@ -58,6 +58,7 @@
   bool contains(TypeIndex Index) override;
   uint32_t size() override;
   uint32_t capacity() override;
+  bool replaceType(TypeIndex &Index, CVType Data, bool Stabilize) override;
 
   // public interface
   void reset();
@@ -71,6 +72,11 @@
   template <typename CreateFunc>
   TypeIndex insertRecordAs(GloballyHashedType Hash, size_t RecordSize,
                            CreateFunc Create) {
+    assert(RecordSize < UINT32_MAX && "Record too big");
+    assert(RecordSize % 4 == 0 &&
+           "RecordSize is not a multiple of 4 bytes which will cause "
+           "misalignment in the output TPI stream!");
+
     auto Result = HashedRecords.try_emplace(Hash, nextTypeIndex());
 
     if (LLVM_UNLIKELY(Result.second /*inserted*/ ||
diff --git a/linux-x64/clang/include/llvm/DebugInfo/CodeView/LazyRandomTypeCollection.h b/linux-x64/clang/include/llvm/DebugInfo/CodeView/LazyRandomTypeCollection.h
index 4e03627..ddbb4e3 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/CodeView/LazyRandomTypeCollection.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/CodeView/LazyRandomTypeCollection.h
@@ -14,7 +14,6 @@
 #include "llvm/ADT/StringRef.h"
 #include "llvm/DebugInfo/CodeView/TypeCollection.h"
 #include "llvm/DebugInfo/CodeView/TypeIndex.h"
-#include "llvm/DebugInfo/CodeView/TypeRecord.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/BinaryStreamArray.h"
 #include "llvm/Support/Error.h"
@@ -79,6 +78,7 @@
   uint32_t capacity() override;
   Optional<TypeIndex> getFirst() override;
   Optional<TypeIndex> getNext(TypeIndex Prev) override;
+  bool replaceType(TypeIndex &Index, CVType Data, bool Stabilize) override;
 
 private:
   Error ensureTypeExists(TypeIndex Index);
diff --git a/linux-x64/clang/include/llvm/DebugInfo/CodeView/MergingTypeTableBuilder.h b/linux-x64/clang/include/llvm/DebugInfo/CodeView/MergingTypeTableBuilder.h
index 1b2f6d2..2f3d7a9 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/CodeView/MergingTypeTableBuilder.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/CodeView/MergingTypeTableBuilder.h
@@ -47,7 +47,7 @@
   explicit MergingTypeTableBuilder(BumpPtrAllocator &Storage);
   ~MergingTypeTableBuilder();
 
-  // TypeTableCollection overrides
+  // TypeCollection overrides
   Optional<TypeIndex> getFirst() override;
   Optional<TypeIndex> getNext(TypeIndex Prev) override;
   CVType getType(TypeIndex Index) override;
@@ -55,6 +55,7 @@
   bool contains(TypeIndex Index) override;
   uint32_t size() override;
   uint32_t capacity() override;
+  bool replaceType(TypeIndex &Index, CVType Data, bool Stabilize) override;
 
   // public interface
   void reset();
diff --git a/linux-x64/clang/include/llvm/DebugInfo/CodeView/RecordName.h b/linux-x64/clang/include/llvm/DebugInfo/CodeView/RecordName.h
index cc09db8..8e06be9 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/CodeView/RecordName.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/CodeView/RecordName.h
@@ -9,7 +9,6 @@
 #ifndef LLVM_DEBUGINFO_CODEVIEW_RECORDNAME_H
 #define LLVM_DEBUGINFO_CODEVIEW_RECORDNAME_H
 
-#include "llvm/DebugInfo/CodeView/SymbolRecord.h"
 #include "llvm/DebugInfo/CodeView/TypeCollection.h"
 #include "llvm/DebugInfo/CodeView/TypeIndex.h"
 
diff --git a/linux-x64/clang/include/llvm/DebugInfo/CodeView/SimpleTypeSerializer.h b/linux-x64/clang/include/llvm/DebugInfo/CodeView/SimpleTypeSerializer.h
index 3ca09b4..fcc0452 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/CodeView/SimpleTypeSerializer.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/CodeView/SimpleTypeSerializer.h
@@ -10,25 +10,11 @@
 #define LLVM_DEBUGINFO_CODEVIEW_SIMPLETYPESERIALIZER_H
 
 #include "llvm/ADT/ArrayRef.h"
-#include "llvm/ADT/Optional.h"
-#include "llvm/ADT/SmallVector.h"
-#include "llvm/DebugInfo/CodeView/CodeView.h"
-#include "llvm/DebugInfo/CodeView/RecordSerialization.h"
-#include "llvm/DebugInfo/CodeView/TypeIndex.h"
-#include "llvm/DebugInfo/CodeView/TypeRecord.h"
-#include "llvm/DebugInfo/CodeView/TypeRecordMapping.h"
-#include "llvm/DebugInfo/CodeView/TypeVisitorCallbacks.h"
-#include "llvm/Support/Allocator.h"
-#include "llvm/Support/BinaryByteStream.h"
-#include "llvm/Support/BinaryStreamWriter.h"
-#include "llvm/Support/Error.h"
-#include <cassert>
-#include <cstdint>
-#include <memory>
 #include <vector>
 
 namespace llvm {
 namespace codeview {
+class FieldListRecord;
 
 class SimpleTypeSerializer {
   std::vector<uint8_t> ScratchBuffer;
diff --git a/linux-x64/clang/include/llvm/DebugInfo/CodeView/SymbolDeserializer.h b/linux-x64/clang/include/llvm/DebugInfo/CodeView/SymbolDeserializer.h
index 62761cb..108abb2 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/CodeView/SymbolDeserializer.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/CodeView/SymbolDeserializer.h
@@ -62,7 +62,7 @@
 
   Error visitSymbolBegin(CVSymbol &Record) override {
     assert(!Mapping && "Already in a symbol mapping!");
-    Mapping = llvm::make_unique<MappingInfo>(Record.content(), Container);
+    Mapping = std::make_unique<MappingInfo>(Record.content(), Container);
     return Mapping->Mapping.visitSymbolBegin(Record);
   }
   Error visitSymbolEnd(CVSymbol &Record) override {
diff --git a/linux-x64/clang/include/llvm/DebugInfo/CodeView/SymbolDumper.h b/linux-x64/clang/include/llvm/DebugInfo/CodeView/SymbolDumper.h
index d832a48..aaeffb2 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/CodeView/SymbolDumper.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/CodeView/SymbolDumper.h
@@ -11,8 +11,8 @@
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringSet.h"
+#include "llvm/DebugInfo/CodeView/CVRecord.h"
 #include "llvm/DebugInfo/CodeView/SymbolDumpDelegate.h"
-#include "llvm/DebugInfo/CodeView/SymbolRecord.h"
 #include "llvm/DebugInfo/CodeView/TypeIndex.h"
 
 namespace llvm {
diff --git a/linux-x64/clang/include/llvm/DebugInfo/CodeView/SymbolRecord.h b/linux-x64/clang/include/llvm/DebugInfo/CodeView/SymbolRecord.h
index 5e9a743..c37f6b4 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/CodeView/SymbolRecord.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/CodeView/SymbolRecord.h
@@ -73,17 +73,17 @@
   Thunk32Sym(SymbolRecordKind Kind, uint32_t RecordOffset)
       : SymbolRecord(Kind), RecordOffset(RecordOffset) {}
 
-  uint32_t Parent;
-  uint32_t End;
-  uint32_t Next;
-  uint32_t Offset;
-  uint16_t Segment;
-  uint16_t Length;
-  ThunkOrdinal Thunk;
+  uint32_t Parent = 0;
+  uint32_t End = 0;
+  uint32_t Next = 0;
+  uint32_t Offset = 0;
+  uint16_t Segment = 0;
+  uint16_t Length = 0;
+  ThunkOrdinal Thunk = ThunkOrdinal::Standard;
   StringRef Name;
   ArrayRef<uint8_t> VariantData;
 
-  uint32_t RecordOffset;
+  uint32_t RecordOffset = 0;
 };
 
 // S_TRAMPOLINE
@@ -94,13 +94,13 @@
       : SymbolRecord(Kind), RecordOffset(RecordOffset) {}
 
   TrampolineType Type;
-  uint16_t Size;
-  uint32_t ThunkOffset;
-  uint32_t TargetOffset;
-  uint16_t ThunkSection;
-  uint16_t TargetSection;
+  uint16_t Size = 0;
+  uint32_t ThunkOffset = 0;
+  uint32_t TargetOffset = 0;
+  uint16_t ThunkSection = 0;
+  uint16_t TargetSection = 0;
 
-  uint32_t RecordOffset;
+  uint32_t RecordOffset = 0;
 };
 
 // S_SECTION
@@ -110,14 +110,14 @@
   SectionSym(SymbolRecordKind Kind, uint32_t RecordOffset)
       : SymbolRecord(Kind), RecordOffset(RecordOffset) {}
 
-  uint16_t SectionNumber;
-  uint8_t Alignment;
-  uint32_t Rva;
-  uint32_t Length;
-  uint32_t Characteristics;
+  uint16_t SectionNumber = 0;
+  uint8_t Alignment = 0;
+  uint32_t Rva = 0;
+  uint32_t Length = 0;
+  uint32_t Characteristics = 0;
   StringRef Name;
 
-  uint32_t RecordOffset;
+  uint32_t RecordOffset = 0;
 };
 
 // S_COFFGROUP
@@ -127,13 +127,13 @@
   CoffGroupSym(SymbolRecordKind Kind, uint32_t RecordOffset)
       : SymbolRecord(Kind), RecordOffset(RecordOffset) {}
 
-  uint32_t Size;
-  uint32_t Characteristics;
-  uint32_t Offset;
-  uint16_t Segment;
+  uint32_t Size = 0;
+  uint32_t Characteristics = 0;
+  uint32_t Offset = 0;
+  uint16_t Segment = 0;
   StringRef Name;
 
-  uint32_t RecordOffset;
+  uint32_t RecordOffset = 0;
 };
 
 class ScopeEndSym : public SymbolRecord {
@@ -142,7 +142,7 @@
   ScopeEndSym(SymbolRecordKind Kind, uint32_t RecordOffset)
       : SymbolRecord(Kind), RecordOffset(RecordOffset) {}
 
-  uint32_t RecordOffset;
+  uint32_t RecordOffset = 0;
 };
 
 class CallerSym : public SymbolRecord {
@@ -153,13 +153,13 @@
 
   std::vector<TypeIndex> Indices;
 
-  uint32_t RecordOffset;
+  uint32_t RecordOffset = 0;
 };
 
 struct DecodedAnnotation {
   StringRef Name;
   ArrayRef<uint8_t> Bytes;
-  BinaryAnnotationsOpCode OpCode;
+  BinaryAnnotationsOpCode OpCode = BinaryAnnotationsOpCode::Invalid;
   uint32_t U1 = 0;
   uint32_t U2 = 0;
   int32_t S1 = 0;
@@ -333,7 +333,7 @@
 class InlineSiteSym : public SymbolRecord {
 public:
   explicit InlineSiteSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
-  InlineSiteSym(uint32_t RecordOffset)
+  explicit InlineSiteSym(uint32_t RecordOffset)
       : SymbolRecord(SymbolRecordKind::InlineSiteSym),
         RecordOffset(RecordOffset) {}
 
@@ -342,12 +342,19 @@
                       BinaryAnnotationIterator());
   }
 
-  uint32_t Parent;
-  uint32_t End;
+  uint32_t Parent = 0;
+  uint32_t End = 0;
   TypeIndex Inlinee;
   std::vector<uint8_t> AnnotationData;
 
-  uint32_t RecordOffset;
+  uint32_t RecordOffset = 0;
+};
+
+struct PublicSym32Header {
+  ulittle32_t Flags;
+  ulittle32_t Offset;
+  ulittle16_t Segment;
+  // char Name[];
 };
 
 // S_PUB32
@@ -371,7 +378,7 @@
 class RegisterSym : public SymbolRecord {
 public:
   explicit RegisterSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
-  RegisterSym(uint32_t RecordOffset)
+  explicit RegisterSym(uint32_t RecordOffset)
       : SymbolRecord(SymbolRecordKind::RegisterSym),
         RecordOffset(RecordOffset) {}
 
@@ -379,7 +386,7 @@
   RegisterId Register;
   StringRef Name;
 
-  uint32_t RecordOffset;
+  uint32_t RecordOffset = 0;
 };
 
 // S_PROCREF, S_LPROCREF
@@ -390,13 +397,13 @@
       : SymbolRecord(SymbolRecordKind::ProcRefSym), RecordOffset(RecordOffset) {
   }
 
-  uint32_t SumName;
-  uint32_t SymOffset;
-  uint16_t Module;
+  uint32_t SumName = 0;
+  uint32_t SymOffset = 0;
+  uint16_t Module = 0;
   StringRef Name;
 
   uint16_t modi() const { return Module - 1; }
-  uint32_t RecordOffset;
+  uint32_t RecordOffset = 0;
 };
 
 // S_LOCAL
@@ -407,21 +414,21 @@
       : SymbolRecord(SymbolRecordKind::LocalSym), RecordOffset(RecordOffset) {}
 
   TypeIndex Type;
-  LocalSymFlags Flags;
+  LocalSymFlags Flags = LocalSymFlags::None;
   StringRef Name;
 
-  uint32_t RecordOffset;
+  uint32_t RecordOffset = 0;
 };
 
 struct LocalVariableAddrRange {
-  uint32_t OffsetStart;
-  uint16_t ISectStart;
-  uint16_t Range;
+  uint32_t OffsetStart = 0;
+  uint16_t ISectStart = 0;
+  uint16_t Range = 0;
 };
 
 struct LocalVariableAddrGap {
-  uint16_t GapStartOffset;
-  uint16_t Range;
+  uint16_t GapStartOffset = 0;
+  uint16_t Range = 0;
 };
 
 enum : uint16_t { MaxDefRange = 0xf000 };
@@ -440,11 +447,11 @@
     return RecordOffset + RelocationOffset;
   }
 
-  uint32_t Program;
+  uint32_t Program = 0;
   LocalVariableAddrRange Range;
   std::vector<LocalVariableAddrGap> Gaps;
 
-  uint32_t RecordOffset;
+  uint32_t RecordOffset = 0;
 };
 
 // S_DEFRANGE_SUBFIELD
@@ -453,7 +460,7 @@
 
 public:
   explicit DefRangeSubfieldSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
-  DefRangeSubfieldSym(uint32_t RecordOffset)
+  explicit DefRangeSubfieldSym(uint32_t RecordOffset)
       : SymbolRecord(SymbolRecordKind::DefRangeSubfieldSym),
         RecordOffset(RecordOffset) {}
 
@@ -461,58 +468,62 @@
     return RecordOffset + RelocationOffset;
   }
 
-  uint32_t Program;
-  uint16_t OffsetInParent;
+  uint32_t Program = 0;
+  uint16_t OffsetInParent = 0;
   LocalVariableAddrRange Range;
   std::vector<LocalVariableAddrGap> Gaps;
 
-  uint32_t RecordOffset;
+  uint32_t RecordOffset = 0;
+};
+
+struct DefRangeRegisterHeader {
+  ulittle16_t Register;
+  ulittle16_t MayHaveNoName;
 };
 
 // S_DEFRANGE_REGISTER
 class DefRangeRegisterSym : public SymbolRecord {
 public:
-  struct Header {
-    ulittle16_t Register;
-    ulittle16_t MayHaveNoName;
-  };
-
   explicit DefRangeRegisterSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
-  DefRangeRegisterSym(uint32_t RecordOffset)
+  explicit DefRangeRegisterSym(uint32_t RecordOffset)
       : SymbolRecord(SymbolRecordKind::DefRangeRegisterSym),
         RecordOffset(RecordOffset) {}
 
-  uint32_t getRelocationOffset() const { return RecordOffset + sizeof(Header); }
+  uint32_t getRelocationOffset() const { return RecordOffset + sizeof(DefRangeRegisterHeader); }
 
-  Header Hdr;
+  DefRangeRegisterHeader Hdr;
   LocalVariableAddrRange Range;
   std::vector<LocalVariableAddrGap> Gaps;
 
-  uint32_t RecordOffset;
+  uint32_t RecordOffset = 0;
+};
+
+struct DefRangeSubfieldRegisterHeader {
+  ulittle16_t Register;
+  ulittle16_t MayHaveNoName;
+  ulittle32_t OffsetInParent;
 };
 
 // S_DEFRANGE_SUBFIELD_REGISTER
 class DefRangeSubfieldRegisterSym : public SymbolRecord {
 public:
-  struct Header {
-    ulittle16_t Register;
-    ulittle16_t MayHaveNoName;
-    ulittle32_t OffsetInParent;
-  };
-
   explicit DefRangeSubfieldRegisterSym(SymbolRecordKind Kind)
       : SymbolRecord(Kind) {}
-  DefRangeSubfieldRegisterSym(uint32_t RecordOffset)
+  explicit DefRangeSubfieldRegisterSym(uint32_t RecordOffset)
       : SymbolRecord(SymbolRecordKind::DefRangeSubfieldRegisterSym),
         RecordOffset(RecordOffset) {}
 
-  uint32_t getRelocationOffset() const { return RecordOffset + sizeof(Header); }
+  uint32_t getRelocationOffset() const { return RecordOffset + sizeof(DefRangeSubfieldRegisterHeader); }
 
-  Header Hdr;
+  DefRangeSubfieldRegisterHeader Hdr;
   LocalVariableAddrRange Range;
   std::vector<LocalVariableAddrGap> Gaps;
 
-  uint32_t RecordOffset;
+  uint32_t RecordOffset = 0;
+};
+
+struct DefRangeFramePointerRelHeader {
+  little32_t Offset;
 };
 
 // S_DEFRANGE_FRAMEPOINTER_REL
@@ -522,7 +533,7 @@
 public:
   explicit DefRangeFramePointerRelSym(SymbolRecordKind Kind)
       : SymbolRecord(Kind) {}
-  DefRangeFramePointerRelSym(uint32_t RecordOffset)
+  explicit DefRangeFramePointerRelSym(uint32_t RecordOffset)
       : SymbolRecord(SymbolRecordKind::DefRangeFramePointerRelSym),
         RecordOffset(RecordOffset) {}
 
@@ -530,22 +541,22 @@
     return RecordOffset + RelocationOffset;
   }
 
-  int32_t Offset;
+  DefRangeFramePointerRelHeader Hdr;
   LocalVariableAddrRange Range;
   std::vector<LocalVariableAddrGap> Gaps;
 
-  uint32_t RecordOffset;
+  uint32_t RecordOffset = 0;
+};
+
+struct DefRangeRegisterRelHeader {
+  ulittle16_t Register;
+  ulittle16_t Flags;
+  little32_t BasePointerOffset;
 };
 
 // S_DEFRANGE_REGISTER_REL
 class DefRangeRegisterRelSym : public SymbolRecord {
 public:
-  struct Header {
-    ulittle16_t Register;
-    ulittle16_t Flags;
-    little32_t BasePointerOffset;
-  };
-
   explicit DefRangeRegisterRelSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   explicit DefRangeRegisterRelSym(uint32_t RecordOffset)
       : SymbolRecord(SymbolRecordKind::DefRangeRegisterRelSym),
@@ -563,13 +574,13 @@
   bool hasSpilledUDTMember() const { return Hdr.Flags & IsSubfieldFlag; }
   uint16_t offsetInParent() const { return Hdr.Flags >> OffsetInParentShift; }
 
-  uint32_t getRelocationOffset() const { return RecordOffset + sizeof(Header); }
+  uint32_t getRelocationOffset() const { return RecordOffset + sizeof(DefRangeRegisterRelHeader); }
 
-  Header Hdr;
+  DefRangeRegisterRelHeader Hdr;
   LocalVariableAddrRange Range;
   std::vector<LocalVariableAddrGap> Gaps;
 
-  uint32_t RecordOffset;
+  uint32_t RecordOffset = 0;
 };
 
 // S_DEFRANGE_FRAMEPOINTER_REL_FULL_SCOPE
@@ -581,9 +592,9 @@
       : SymbolRecord(SymbolRecordKind::DefRangeFramePointerRelFullScopeSym),
         RecordOffset(RecordOffset) {}
 
-  int32_t Offset;
+  int32_t Offset = 0;
 
-  uint32_t RecordOffset;
+  uint32_t RecordOffset = 0;
 };
 
 // S_BLOCK32
@@ -599,14 +610,14 @@
     return RecordOffset + RelocationOffset;
   }
 
-  uint32_t Parent;
-  uint32_t End;
-  uint32_t CodeSize;
-  uint32_t CodeOffset;
-  uint16_t Segment;
+  uint32_t Parent = 0;
+  uint32_t End = 0;
+  uint32_t CodeSize = 0;
+  uint32_t CodeOffset = 0;
+  uint16_t Segment = 0;
   StringRef Name;
 
-  uint32_t RecordOffset;
+  uint32_t RecordOffset = 0;
 };
 
 // S_LABEL32
@@ -622,12 +633,12 @@
     return RecordOffset + RelocationOffset;
   }
 
-  uint32_t CodeOffset;
-  uint16_t Segment;
-  ProcSymFlags Flags;
+  uint32_t CodeOffset = 0;
+  uint16_t Segment = 0;
+  ProcSymFlags Flags = ProcSymFlags::None;
   StringRef Name;
 
-  uint32_t RecordOffset;
+  uint32_t RecordOffset = 0;
 };
 
 // S_OBJNAME
@@ -635,82 +646,82 @@
 public:
   explicit ObjNameSym() : SymbolRecord(SymbolRecordKind::ObjNameSym) {}
   explicit ObjNameSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
-  ObjNameSym(uint32_t RecordOffset)
+  explicit ObjNameSym(uint32_t RecordOffset)
       : SymbolRecord(SymbolRecordKind::ObjNameSym), RecordOffset(RecordOffset) {
   }
 
-  uint32_t Signature;
+  uint32_t Signature = 0;
   StringRef Name;
 
-  uint32_t RecordOffset;
+  uint32_t RecordOffset = 0;
 };
 
 // S_ENVBLOCK
 class EnvBlockSym : public SymbolRecord {
 public:
   explicit EnvBlockSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
-  EnvBlockSym(uint32_t RecordOffset)
+  explicit EnvBlockSym(uint32_t RecordOffset)
       : SymbolRecord(SymbolRecordKind::EnvBlockSym),
         RecordOffset(RecordOffset) {}
 
   std::vector<StringRef> Fields;
 
-  uint32_t RecordOffset;
+  uint32_t RecordOffset = 0;
 };
 
 // S_EXPORT
 class ExportSym : public SymbolRecord {
 public:
   explicit ExportSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
-  ExportSym(uint32_t RecordOffset)
+  explicit ExportSym(uint32_t RecordOffset)
       : SymbolRecord(SymbolRecordKind::ExportSym), RecordOffset(RecordOffset) {}
 
-  uint16_t Ordinal;
-  ExportFlags Flags;
+  uint16_t Ordinal = 0;
+  ExportFlags Flags = ExportFlags::None;
   StringRef Name;
 
-  uint32_t RecordOffset;
+  uint32_t RecordOffset = 0;
 };
 
 // S_FILESTATIC
 class FileStaticSym : public SymbolRecord {
 public:
   explicit FileStaticSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
-  FileStaticSym(uint32_t RecordOffset)
+  explicit FileStaticSym(uint32_t RecordOffset)
       : SymbolRecord(SymbolRecordKind::FileStaticSym),
         RecordOffset(RecordOffset) {}
 
   TypeIndex Index;
-  uint32_t ModFilenameOffset;
-  LocalSymFlags Flags;
+  uint32_t ModFilenameOffset = 0;
+  LocalSymFlags Flags = LocalSymFlags::None;
   StringRef Name;
 
-  uint32_t RecordOffset;
+  uint32_t RecordOffset = 0;
 };
 
 // S_COMPILE2
 class Compile2Sym : public SymbolRecord {
 public:
   explicit Compile2Sym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
-  Compile2Sym(uint32_t RecordOffset)
+  explicit Compile2Sym(uint32_t RecordOffset)
       : SymbolRecord(SymbolRecordKind::Compile2Sym),
         RecordOffset(RecordOffset) {}
 
-  CompileSym2Flags Flags;
+  CompileSym2Flags Flags = CompileSym2Flags::None;
   CPUType Machine;
-  uint16_t VersionFrontendMajor;
-  uint16_t VersionFrontendMinor;
-  uint16_t VersionFrontendBuild;
-  uint16_t VersionBackendMajor;
-  uint16_t VersionBackendMinor;
-  uint16_t VersionBackendBuild;
+  uint16_t VersionFrontendMajor = 0;
+  uint16_t VersionFrontendMinor = 0;
+  uint16_t VersionFrontendBuild = 0;
+  uint16_t VersionBackendMajor = 0;
+  uint16_t VersionBackendMinor = 0;
+  uint16_t VersionBackendBuild = 0;
   StringRef Version;
   std::vector<StringRef> ExtraStrings;
 
   uint8_t getLanguage() const { return static_cast<uint32_t>(Flags) & 0xFF; }
   uint32_t getFlags() const { return static_cast<uint32_t>(Flags) & ~0xFF; }
 
-  uint32_t RecordOffset;
+  uint32_t RecordOffset = 0;
 };
 
 // S_COMPILE3
@@ -718,20 +729,20 @@
 public:
   Compile3Sym() : SymbolRecord(SymbolRecordKind::Compile3Sym) {}
   explicit Compile3Sym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
-  Compile3Sym(uint32_t RecordOffset)
+  explicit Compile3Sym(uint32_t RecordOffset)
       : SymbolRecord(SymbolRecordKind::Compile3Sym),
         RecordOffset(RecordOffset) {}
 
-  CompileSym3Flags Flags;
+  CompileSym3Flags Flags = CompileSym3Flags::None;
   CPUType Machine;
-  uint16_t VersionFrontendMajor;
-  uint16_t VersionFrontendMinor;
-  uint16_t VersionFrontendBuild;
-  uint16_t VersionFrontendQFE;
-  uint16_t VersionBackendMajor;
-  uint16_t VersionBackendMinor;
-  uint16_t VersionBackendBuild;
-  uint16_t VersionBackendQFE;
+  uint16_t VersionFrontendMajor = 0;
+  uint16_t VersionFrontendMinor = 0;
+  uint16_t VersionFrontendBuild = 0;
+  uint16_t VersionFrontendQFE = 0;
+  uint16_t VersionBackendMajor = 0;
+  uint16_t VersionBackendMinor = 0;
+  uint16_t VersionBackendBuild = 0;
+  uint16_t VersionBackendQFE = 0;
   StringRef Version;
 
   void setLanguage(SourceLanguage Lang) {
@@ -750,7 +761,7 @@
            (getFlags() & (CompileSym3Flags::PGO | CompileSym3Flags::LTCG));
   }
 
-  uint32_t RecordOffset;
+  uint32_t RecordOffset = 0;
 };
 
 // S_FRAMEPROC
@@ -761,13 +772,13 @@
       : SymbolRecord(SymbolRecordKind::FrameProcSym),
         RecordOffset(RecordOffset) {}
 
-  uint32_t TotalFrameBytes;
-  uint32_t PaddingFrameBytes;
-  uint32_t OffsetToPadding;
-  uint32_t BytesOfCalleeSavedRegisters;
-  uint32_t OffsetOfExceptionHandler;
-  uint16_t SectionIdOfExceptionHandler;
-  FrameProcedureOptions Flags;
+  uint32_t TotalFrameBytes = 0;
+  uint32_t PaddingFrameBytes = 0;
+  uint32_t OffsetToPadding = 0;
+  uint32_t BytesOfCalleeSavedRegisters = 0;
+  uint32_t OffsetOfExceptionHandler = 0;
+  uint16_t SectionIdOfExceptionHandler = 0;
+  FrameProcedureOptions Flags = FrameProcedureOptions::None;
 
   /// Extract the register this frame uses to refer to local variables.
   RegisterId getLocalFramePtrReg(CPUType CPU) const {
@@ -781,7 +792,7 @@
         EncodedFramePtrReg((uint32_t(Flags) >> 16U) & 0x3U), CPU);
   }
 
-  uint32_t RecordOffset;
+  uint32_t RecordOffset = 0;
 
 private:
 };
@@ -799,11 +810,11 @@
     return RecordOffset + RelocationOffset;
   }
 
-  uint32_t CodeOffset;
-  uint16_t Segment;
+  uint32_t CodeOffset = 0;
+  uint16_t Segment = 0;
   TypeIndex Type;
 
-  uint32_t RecordOffset;
+  uint32_t RecordOffset = 0;
 };
 
 // S_HEAPALLOCSITE
@@ -820,12 +831,12 @@
     return RecordOffset + RelocationOffset;
   }
 
-  uint32_t CodeOffset;
-  uint16_t Segment;
-  uint16_t CallInstructionSize;
+  uint32_t CodeOffset = 0;
+  uint16_t Segment = 0;
+  uint16_t CallInstructionSize = 0;
   TypeIndex Type;
 
-  uint32_t RecordOffset;
+  uint32_t RecordOffset = 0;
 };
 
 // S_FRAMECOOKIE
@@ -841,12 +852,12 @@
     return RecordOffset + RelocationOffset;
   }
 
-  uint32_t CodeOffset;
-  uint16_t Register;
+  uint32_t CodeOffset = 0;
+  uint16_t Register = 0;
   FrameCookieKind CookieKind;
-  uint8_t Flags;
+  uint8_t Flags = 0;
 
-  uint32_t RecordOffset;
+  uint32_t RecordOffset = 0;
 };
 
 // S_UDT, S_COBOLUDT
@@ -859,20 +870,20 @@
   TypeIndex Type;
   StringRef Name;
 
-  uint32_t RecordOffset;
+  uint32_t RecordOffset = 0;
 };
 
 // S_BUILDINFO
 class BuildInfoSym : public SymbolRecord {
 public:
   explicit BuildInfoSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
-  BuildInfoSym(uint32_t RecordOffset)
+  explicit BuildInfoSym(uint32_t RecordOffset)
       : SymbolRecord(SymbolRecordKind::BuildInfoSym),
         RecordOffset(RecordOffset) {}
 
   TypeIndex BuildId;
 
-  uint32_t RecordOffset;
+  uint32_t RecordOffset = 0;
 };
 
 // S_BPREL32
@@ -883,11 +894,11 @@
       : SymbolRecord(SymbolRecordKind::BPRelativeSym),
         RecordOffset(RecordOffset) {}
 
-  int32_t Offset;
+  int32_t Offset = 0;
   TypeIndex Type;
   StringRef Name;
 
-  uint32_t RecordOffset;
+  uint32_t RecordOffset = 0;
 };
 
 // S_REGREL32
@@ -898,19 +909,19 @@
       : SymbolRecord(SymbolRecordKind::RegRelativeSym),
         RecordOffset(RecordOffset) {}
 
-  uint32_t Offset;
+  uint32_t Offset = 0;
   TypeIndex Type;
   RegisterId Register;
   StringRef Name;
 
-  uint32_t RecordOffset;
+  uint32_t RecordOffset = 0;
 };
 
 // S_CONSTANT, S_MANCONSTANT
 class ConstantSym : public SymbolRecord {
 public:
   explicit ConstantSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
-  ConstantSym(uint32_t RecordOffset)
+  explicit ConstantSym(uint32_t RecordOffset)
       : SymbolRecord(SymbolRecordKind::ConstantSym),
         RecordOffset(RecordOffset) {}
 
@@ -918,7 +929,7 @@
   APSInt Value;
   StringRef Name;
 
-  uint32_t RecordOffset;
+  uint32_t RecordOffset = 0;
 };
 
 // S_LDATA32, S_GDATA32, S_LMANDATA, S_GMANDATA
@@ -927,7 +938,7 @@
 
 public:
   explicit DataSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
-  DataSym(uint32_t RecordOffset)
+  explicit DataSym(uint32_t RecordOffset)
       : SymbolRecord(SymbolRecordKind::DataSym), RecordOffset(RecordOffset) {}
 
   uint32_t getRelocationOffset() const {
@@ -935,11 +946,11 @@
   }
 
   TypeIndex Type;
-  uint32_t DataOffset;
-  uint16_t Segment;
+  uint32_t DataOffset = 0;
+  uint16_t Segment = 0;
   StringRef Name;
 
-  uint32_t RecordOffset;
+  uint32_t RecordOffset = 0;
 };
 
 // S_LTHREAD32, S_GTHREAD32
@@ -957,11 +968,11 @@
   }
 
   TypeIndex Type;
-  uint32_t DataOffset;
-  uint16_t Segment;
+  uint32_t DataOffset = 0;
+  uint16_t Segment = 0;
   StringRef Name;
 
-  uint32_t RecordOffset;
+  uint32_t RecordOffset = 0;
 };
 
 // S_UNAMESPACE
@@ -974,7 +985,7 @@
 
   StringRef Name;
 
-  uint32_t RecordOffset;
+  uint32_t RecordOffset = 0;
 };
 
 // S_ANNOTATION
@@ -989,12 +1000,9 @@
   uint16_t Segment = 0;
   std::vector<StringRef> Strings;
 
-  uint32_t RecordOffset;
+  uint32_t RecordOffset = 0;
 };
 
-using CVSymbol = CVRecord<SymbolKind>;
-using CVSymbolArray = VarStreamArray<CVSymbol>;
-
 Expected<CVSymbol> readSymbolFromStream(BinaryStreamRef Stream,
                                         uint32_t Offset);
 
diff --git a/linux-x64/clang/include/llvm/DebugInfo/CodeView/SymbolRecordHelpers.h b/linux-x64/clang/include/llvm/DebugInfo/CodeView/SymbolRecordHelpers.h
index 57dbc56..71bc70d 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/CodeView/SymbolRecordHelpers.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/CodeView/SymbolRecordHelpers.h
@@ -9,7 +9,8 @@
 #ifndef LLVM_DEBUGINFO_CODEVIEW_SYMBOLRECORDHELPERS_H
 #define LLVM_DEBUGINFO_CODEVIEW_SYMBOLRECORDHELPERS_H
 
-#include "llvm/DebugInfo/CodeView/SymbolRecord.h"
+#include "llvm/DebugInfo/CodeView/CVRecord.h"
+#include "llvm/DebugInfo/CodeView/CodeView.h"
 
 namespace llvm {
 namespace codeview {
diff --git a/linux-x64/clang/include/llvm/DebugInfo/CodeView/TypeCollection.h b/linux-x64/clang/include/llvm/DebugInfo/CodeView/TypeCollection.h
index 58b1dd0..bde5a8b 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/CodeView/TypeCollection.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/CodeView/TypeCollection.h
@@ -10,9 +10,8 @@
 #define LLVM_DEBUGINFO_CODEVIEW_TYPECOLLECTION_H
 
 #include "llvm/ADT/StringRef.h"
-
+#include "llvm/DebugInfo/CodeView/CVRecord.h"
 #include "llvm/DebugInfo/CodeView/TypeIndex.h"
-#include "llvm/DebugInfo/CodeView/TypeRecord.h"
 
 namespace llvm {
 namespace codeview {
@@ -30,6 +29,7 @@
   virtual bool contains(TypeIndex Index) = 0;
   virtual uint32_t size() = 0;
   virtual uint32_t capacity() = 0;
+  virtual bool replaceType(TypeIndex &Index, CVType Data, bool Stabilize) = 0;
 
   template <typename TFunc> void ForEachRecord(TFunc Func) {
     Optional<TypeIndex> Next = getFirst();
diff --git a/linux-x64/clang/include/llvm/DebugInfo/CodeView/TypeDeserializer.h b/linux-x64/clang/include/llvm/DebugInfo/CodeView/TypeDeserializer.h
index 081de32..2b17f5c 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/CodeView/TypeDeserializer.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/CodeView/TypeDeserializer.h
@@ -66,7 +66,7 @@
 
   Error visitTypeBegin(CVType &Record) override {
     assert(!Mapping && "Already in a type mapping!");
-    Mapping = llvm::make_unique<MappingInfo>(Record.content());
+    Mapping = std::make_unique<MappingInfo>(Record.content());
     return Mapping->Mapping.visitTypeBegin(Record);
   }
 
diff --git a/linux-x64/clang/include/llvm/DebugInfo/CodeView/TypeHashing.h b/linux-x64/clang/include/llvm/DebugInfo/CodeView/TypeHashing.h
index b0a16cc..9f34d02 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/CodeView/TypeHashing.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/CodeView/TypeHashing.h
@@ -86,6 +86,16 @@
 
   bool empty() const { return *(const uint64_t*)Hash.data() == 0; }
 
+  friend inline bool operator==(const GloballyHashedType &L,
+                                const GloballyHashedType &R) {
+    return L.Hash == R.Hash;
+  }
+
+  friend inline bool operator!=(const GloballyHashedType &L,
+                                const GloballyHashedType &R) {
+    return !(L.Hash == R.Hash);
+  }
+
   /// Given a sequence of bytes representing a record, compute a global hash for
   /// this record.  Due to the nature of global hashes incorporating the hashes
   /// of referenced records, this function requires a list of types and ids
@@ -161,15 +171,10 @@
     return Hashes;
   }
 };
-#if defined(_MSC_VER)
-// is_trivially_copyable is not available in older versions of libc++, but it is
-// available in all supported versions of MSVC, so at least this gives us some
-// coverage.
 static_assert(std::is_trivially_copyable<GloballyHashedType>::value,
               "GloballyHashedType must be trivially copyable so that we can "
               "reinterpret_cast arrays of hash data to arrays of "
               "GloballyHashedType");
-#endif
 } // namespace codeview
 
 template <> struct DenseMapInfo<codeview::LocallyHashedType> {
@@ -206,7 +211,7 @@
 
   static bool isEqual(codeview::GloballyHashedType LHS,
                       codeview::GloballyHashedType RHS) {
-    return LHS.Hash == RHS.Hash;
+    return LHS == RHS;
   }
 };
 
diff --git a/linux-x64/clang/include/llvm/DebugInfo/CodeView/TypeIndex.h b/linux-x64/clang/include/llvm/DebugInfo/CodeView/TypeIndex.h
index b9e2562..bdc6cf4 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/CodeView/TypeIndex.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/CodeView/TypeIndex.h
@@ -116,13 +116,22 @@
 
   uint32_t toArrayIndex() const {
     assert(!isSimple());
-    return getIndex() - FirstNonSimpleIndex;
+    return (getIndex() & ~DecoratedItemIdMask) - FirstNonSimpleIndex;
   }
 
   static TypeIndex fromArrayIndex(uint32_t Index) {
     return TypeIndex(Index + FirstNonSimpleIndex);
   }
 
+  static TypeIndex fromDecoratedArrayIndex(bool IsItem, uint32_t Index) {
+    return TypeIndex((Index + FirstNonSimpleIndex) |
+                     (IsItem ? DecoratedItemIdMask : 0));
+  }
+
+  TypeIndex removeDecoration() {
+    return TypeIndex(Index & ~DecoratedItemIdMask);
+  }
+
   SimpleTypeKind getSimpleKind() const {
     assert(isSimple());
     return static_cast<SimpleTypeKind>(Index & SimpleKindMask);
diff --git a/linux-x64/clang/include/llvm/DebugInfo/CodeView/TypeIndexDiscovery.h b/linux-x64/clang/include/llvm/DebugInfo/CodeView/TypeIndexDiscovery.h
index 4697687..f4f5835 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/CodeView/TypeIndexDiscovery.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/CodeView/TypeIndexDiscovery.h
@@ -10,8 +10,8 @@
 #define LLVM_DEBUGINFO_CODEVIEW_TYPEINDEXDISCOVERY_H
 
 #include "llvm/ADT/SmallVector.h"
-#include "llvm/DebugInfo/CodeView/SymbolRecord.h"
-#include "llvm/DebugInfo/CodeView/TypeRecord.h"
+#include "llvm/DebugInfo/CodeView/CVRecord.h"
+#include "llvm/DebugInfo/CodeView/TypeIndex.h"
 #include "llvm/Support/Error.h"
 
 namespace llvm {
diff --git a/linux-x64/clang/include/llvm/DebugInfo/CodeView/TypeRecord.h b/linux-x64/clang/include/llvm/DebugInfo/CodeView/TypeRecord.h
index b147dd6..3b6d1b0 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/CodeView/TypeRecord.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/CodeView/TypeRecord.h
@@ -14,7 +14,6 @@
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
-#include "llvm/ADT/iterator_range.h"
 #include "llvm/DebugInfo/CodeView/CVRecord.h"
 #include "llvm/DebugInfo/CodeView/CodeView.h"
 #include "llvm/DebugInfo/CodeView/GUID.h"
@@ -32,15 +31,10 @@
 using support::ulittle16_t;
 using support::ulittle32_t;
 
-using CVType = CVRecord<TypeLeafKind>;
-using RemappedType = RemappedRecord<TypeLeafKind>;
-
 struct CVMemberRecord {
   TypeLeafKind Kind;
   ArrayRef<uint8_t> Data;
 };
-using CVTypeArray = VarStreamArray<CVType>;
-using CVTypeRange = iterator_range<CVTypeArray::Iterator>;
 
 /// Equvalent to CV_fldattr_t in cvinfo.h.
 struct MemberAttributes {
@@ -144,7 +138,7 @@
   ModifierOptions getModifiers() const { return Modifiers; }
 
   TypeIndex ModifiedType;
-  ModifierOptions Modifiers;
+  ModifierOptions Modifiers = ModifierOptions::None;
 };
 
 // LF_PROCEDURE
@@ -168,7 +162,7 @@
   TypeIndex ReturnType;
   CallingConvention CallConv;
   FunctionOptions Options;
-  uint16_t ParameterCount;
+  uint16_t ParameterCount = 0;
   TypeIndex ArgumentList;
 };
 
@@ -202,9 +196,9 @@
   TypeIndex ThisType;
   CallingConvention CallConv;
   FunctionOptions Options;
-  uint16_t ParameterCount;
+  uint16_t ParameterCount = 0;
   TypeIndex ArgumentList;
-  int32_t ThisPointerAdjustment;
+  int32_t ThisPointerAdjustment = 0;
 };
 
 // LF_LABEL
@@ -351,7 +345,7 @@
   }
 
   TypeIndex ReferentType;
-  uint32_t Attrs;
+  uint32_t Attrs = 0;
   Optional<MemberPointerInfo> MemberInfo;
 
   void setAttrs(PointerKind PK, PointerMode PM, PointerOptions PO,
@@ -414,7 +408,7 @@
 
   TypeIndex ElementType;
   TypeIndex IndexType;
-  uint64_t Size;
+  uint64_t Size = 0;
   StringRef Name;
 };
 
@@ -459,7 +453,7 @@
   StringRef getName() const { return Name; }
   StringRef getUniqueName() const { return UniqueName; }
 
-  uint16_t MemberCount;
+  uint16_t MemberCount = 0;
   ClassOptions Options;
   TypeIndex FieldList;
   StringRef Name;
@@ -496,7 +490,7 @@
 
   TypeIndex DerivationList;
   TypeIndex VTableShape;
-  uint64_t Size;
+  uint64_t Size = 0;
 };
 
 // LF_UNION
@@ -517,7 +511,7 @@
 
   uint64_t getSize() const { return Size; }
 
-  uint64_t Size;
+  uint64_t Size = 0;
 };
 
 // LF_ENUM
@@ -550,8 +544,8 @@
   uint8_t getBitSize() const { return BitSize; }
 
   TypeIndex Type;
-  uint8_t BitSize;
-  uint8_t BitOffset;
+  uint8_t BitSize = 0;
+  uint8_t BitOffset = 0;
 };
 
 // LF_VTSHAPE
@@ -592,7 +586,7 @@
   StringRef getName() const { return Name; }
 
   GUID Guid;
-  uint32_t Age;
+  uint32_t Age = 0;
   StringRef Name;
 };
 
@@ -644,7 +638,7 @@
 
   TypeIndex UDT;
   TypeIndex SourceFile;
-  uint32_t LineNumber;
+  uint32_t LineNumber = 0;
 };
 
 // LF_UDT_MOD_SRC_LINE
@@ -664,8 +658,8 @@
 
   TypeIndex UDT;
   TypeIndex SourceFile;
-  uint32_t LineNumber;
-  uint16_t Module;
+  uint32_t LineNumber = 0;
+  uint16_t Module = 0;
 };
 
 // LF_BUILDINFO
@@ -703,7 +697,7 @@
       : TypeRecord(TypeRecordKind::VFTable), CompleteClass(CompleteClass),
         OverriddenVFTable(OverriddenVFTable), VFPtrOffset(VFPtrOffset) {
     MethodNames.push_back(Name);
-    MethodNames.insert(MethodNames.end(), Methods.begin(), Methods.end());
+    llvm::append_range(MethodNames, Methods);
   }
 
   TypeIndex getCompleteClass() const { return CompleteClass; }
@@ -717,7 +711,7 @@
 
   TypeIndex CompleteClass;
   TypeIndex OverriddenVFTable;
-  uint32_t VFPtrOffset;
+  uint32_t VFPtrOffset = 0;
   std::vector<StringRef> MethodNames;
 };
 
@@ -749,7 +743,7 @@
 
   TypeIndex Type;
   MemberAttributes Attrs;
-  int32_t VFTableOffset;
+  int32_t VFTableOffset = 0;
   StringRef Name;
 };
 
@@ -780,7 +774,7 @@
   TypeIndex getMethodList() const { return MethodList; }
   StringRef getName() const { return Name; }
 
-  uint16_t NumOverloads;
+  uint16_t NumOverloads = 0;
   TypeIndex MethodList;
   StringRef Name;
 };
@@ -806,7 +800,7 @@
 
   MemberAttributes Attrs;
   TypeIndex Type;
-  uint64_t FieldOffset;
+  uint64_t FieldOffset = 0;
   StringRef Name;
 };
 
@@ -883,7 +877,7 @@
 
   MemberAttributes Attrs;
   TypeIndex Type;
-  uint64_t Offset;
+  uint64_t Offset = 0;
 };
 
 // LF_VBCLASS, LF_IVBCLASS
@@ -911,8 +905,8 @@
   MemberAttributes Attrs;
   TypeIndex BaseType;
   TypeIndex VBPtrType;
-  uint64_t VBPtrOffset;
-  uint64_t VTableIndex;
+  uint64_t VBPtrOffset = 0;
+  uint64_t VTableIndex = 0;
 };
 
 /// LF_INDEX - Used to chain two large LF_FIELDLIST or LF_METHODLIST records
@@ -941,9 +935,9 @@
   uint32_t getSignature() const { return Signature; }
   StringRef getPrecompFilePath() const { return PrecompFilePath; }
 
-  uint32_t StartTypeIndex;
-  uint32_t TypesCount;
-  uint32_t Signature;
+  uint32_t StartTypeIndex = 0;
+  uint32_t TypesCount = 0;
+  uint32_t Signature = 0;
   StringRef PrecompFilePath;
 };
 
@@ -955,7 +949,7 @@
 
   uint32_t getSignature() const { return Signature; }
 
-  uint32_t Signature;
+  uint32_t Signature = 0;
 };
 
 } // end namespace codeview
diff --git a/linux-x64/clang/include/llvm/DebugInfo/CodeView/TypeRecordHelpers.h b/linux-x64/clang/include/llvm/DebugInfo/CodeView/TypeRecordHelpers.h
index e84704d..041f521 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/CodeView/TypeRecordHelpers.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/CodeView/TypeRecordHelpers.h
@@ -9,19 +9,39 @@
 #ifndef LLVM_DEBUGINFO_CODEVIEW_TYPERECORDHELPERS_H
 #define LLVM_DEBUGINFO_CODEVIEW_TYPERECORDHELPERS_H
 
-#include "llvm/DebugInfo/CodeView/TypeRecord.h"
+#include "llvm/DebugInfo/CodeView/CVRecord.h"
+#include "llvm/DebugInfo/CodeView/TypeIndex.h"
 
 namespace llvm {
-  namespace codeview {
-    /// Given an arbitrary codeview type, determine if it is an LF_STRUCTURE,
-    /// LF_CLASS, LF_INTERFACE, LF_UNION, or LF_ENUM with the forward ref class
-    /// option.
-    bool isUdtForwardRef(CVType CVT);
+namespace codeview {
 
-    /// Given a CVType which is assumed to be an LF_MODIFIER, return the
-    /// TypeIndex of the type that the LF_MODIFIER modifies.
-    TypeIndex getModifiedType(const CVType &CVT);
+/// Given an arbitrary codeview type, determine if it is an LF_STRUCTURE,
+/// LF_CLASS, LF_INTERFACE, LF_UNION, or LF_ENUM with the forward ref class
+/// option.
+bool isUdtForwardRef(CVType CVT);
+
+/// Given a CVType which is assumed to be an LF_MODIFIER, return the
+/// TypeIndex of the type that the LF_MODIFIER modifies.
+TypeIndex getModifiedType(const CVType &CVT);
+
+/// Return true if this record should be in the IPI stream of a PDB. In an
+/// object file, these record kinds will appear mixed into the .debug$T section.
+inline bool isIdRecord(TypeLeafKind K) {
+  switch (K) {
+  case TypeLeafKind::LF_FUNC_ID:
+  case TypeLeafKind::LF_MFUNC_ID:
+  case TypeLeafKind::LF_STRING_ID:
+  case TypeLeafKind::LF_SUBSTR_LIST:
+  case TypeLeafKind::LF_BUILDINFO:
+  case TypeLeafKind::LF_UDT_SRC_LINE:
+  case TypeLeafKind::LF_UDT_MOD_SRC_LINE:
+    return true;
+  default:
+    return false;
   }
 }
 
+} // namespace codeview
+} // namespace llvm
+
 #endif
diff --git a/linux-x64/clang/include/llvm/DebugInfo/CodeView/TypeRecordMapping.h b/linux-x64/clang/include/llvm/DebugInfo/CodeView/TypeRecordMapping.h
index 4c309c1..c6044d5 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/CodeView/TypeRecordMapping.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/CodeView/TypeRecordMapping.h
@@ -10,6 +10,7 @@
 #define LLVM_DEBUGINFO_CODEVIEW_TYPERECORDMAPPING_H
 
 #include "llvm/ADT/Optional.h"
+#include "llvm/DebugInfo/CodeView/CVTypeVisitor.h"
 #include "llvm/DebugInfo/CodeView/CodeViewRecordIO.h"
 #include "llvm/DebugInfo/CodeView/TypeVisitorCallbacks.h"
 #include "llvm/Support/Error.h"
diff --git a/linux-x64/clang/include/llvm/DebugInfo/CodeView/TypeStreamMerger.h b/linux-x64/clang/include/llvm/DebugInfo/CodeView/TypeStreamMerger.h
index d0506cc..04d7c7b 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/CodeView/TypeStreamMerger.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/CodeView/TypeStreamMerger.h
@@ -11,7 +11,7 @@
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/SmallVector.h"
-#include "llvm/DebugInfo/CodeView/TypeRecord.h"
+#include "llvm/DebugInfo/CodeView/CVRecord.h"
 #include "llvm/Support/Error.h"
 
 namespace llvm {
diff --git a/linux-x64/clang/include/llvm/DebugInfo/CodeView/TypeSymbolEmitter.h b/linux-x64/clang/include/llvm/DebugInfo/CodeView/TypeSymbolEmitter.h
index 4f2e5de..01525d0 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/CodeView/TypeSymbolEmitter.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/CodeView/TypeSymbolEmitter.h
@@ -9,13 +9,11 @@
 #ifndef LLVM_DEBUGINFO_CODEVIEW_TYPESYMBOLEMITTER_H
 #define LLVM_DEBUGINFO_CODEVIEW_TYPESYMBOLEMITTER_H
 
-#include "llvm/DebugInfo/CodeView/CodeView.h"
-#include "llvm/DebugInfo/CodeView/TypeIndex.h"
-
 namespace llvm {
 class StringRef;
 
 namespace codeview {
+class TypeIndex;
 
 class TypeSymbolEmitter {
 private:
diff --git a/linux-x64/clang/include/llvm/DebugInfo/CodeView/TypeTableCollection.h b/linux-x64/clang/include/llvm/DebugInfo/CodeView/TypeTableCollection.h
index 5cbe340..c300874 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/CodeView/TypeTableCollection.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/CodeView/TypeTableCollection.h
@@ -29,6 +29,7 @@
   bool contains(TypeIndex Index) override;
   uint32_t size() override;
   uint32_t capacity() override;
+  bool replaceType(TypeIndex &Index, CVType Data, bool Stabilize) override;
 
 private:
   BumpPtrAllocator Allocator;
diff --git a/linux-x64/clang/include/llvm/DebugInfo/CodeView/TypeVisitorCallbackPipeline.h b/linux-x64/clang/include/llvm/DebugInfo/CodeView/TypeVisitorCallbackPipeline.h
index 169715b..fb0b579 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/CodeView/TypeVisitorCallbackPipeline.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/CodeView/TypeVisitorCallbackPipeline.h
@@ -82,11 +82,6 @@
     Pipeline.push_back(&Callbacks);
   }
 
-  void addCallbackToPipelineFront(TypeVisitorCallbacks &Callbacks) {
-    auto CallBackItr = Pipeline.begin();
-    Pipeline.insert(CallBackItr, &Callbacks);
-  }
-
 #define TYPE_RECORD(EnumName, EnumVal, Name)                                   \
   Error visitKnownRecord(CVType &CVR, Name##Record &Record) override {         \
     return visitKnownRecordImpl(CVR, Record);                                  \
diff --git a/linux-x64/clang/include/llvm/DebugInfo/DIContext.h b/linux-x64/clang/include/llvm/DebugInfo/DIContext.h
index d2a5318..ae78fe9 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/DIContext.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/DIContext.h
@@ -16,6 +16,7 @@
 
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Object/ObjectFile.h"
+#include "llvm/Support/WithColor.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cassert>
 #include <cstdint>
@@ -28,8 +29,13 @@
 
 /// A format-neutral container for source line information.
 struct DILineInfo {
+  // DILineInfo contains "<invalid>" for function/filename it cannot fetch.
+  static constexpr const char *const BadString = "<invalid>";
+  // Use "??" instead of "<invalid>" to make our output closer to addr2line.
+  static constexpr const char *const Addr2LineBadString = "??";
   std::string FileName;
   std::string FunctionName;
+  std::string StartFileName;
   Optional<StringRef> Source;
   uint32_t Line = 0;
   uint32_t Column = 0;
@@ -38,12 +44,15 @@
   // DWARF-specific.
   uint32_t Discriminator = 0;
 
-  DILineInfo() : FileName("<invalid>"), FunctionName("<invalid>") {}
+  DILineInfo()
+      : FileName(BadString), FunctionName(BadString), StartFileName(BadString) {
+  }
 
   bool operator==(const DILineInfo &RHS) const {
     return Line == RHS.Line && Column == RHS.Column &&
            FileName == RHS.FileName && FunctionName == RHS.FunctionName &&
-           StartLine == RHS.StartLine && Discriminator == RHS.Discriminator;
+           StartFileName == RHS.StartFileName && StartLine == RHS.StartLine &&
+           Discriminator == RHS.Discriminator;
   }
 
   bool operator!=(const DILineInfo &RHS) const {
@@ -51,22 +60,24 @@
   }
 
   bool operator<(const DILineInfo &RHS) const {
-    return std::tie(FileName, FunctionName, Line, Column, StartLine,
-                    Discriminator) <
-           std::tie(RHS.FileName, RHS.FunctionName, RHS.Line, RHS.Column,
-                    RHS.StartLine, RHS.Discriminator);
+    return std::tie(FileName, FunctionName, StartFileName, Line, Column,
+                    StartLine, Discriminator) <
+           std::tie(RHS.FileName, RHS.FunctionName, RHS.StartFileName, RHS.Line,
+                    RHS.Column, RHS.StartLine, RHS.Discriminator);
   }
 
   explicit operator bool() const { return *this != DILineInfo(); }
 
   void dump(raw_ostream &OS) {
     OS << "Line info: ";
-    if (FileName != "<invalid>")
+    if (FileName != BadString)
       OS << "file '" << FileName << "', ";
-    if (FunctionName != "<invalid>")
+    if (FunctionName != BadString)
       OS << "function '" << FunctionName << "', ";
     OS << "line " << Line << ", ";
     OS << "column " << Column << ", ";
+    if (StartFileName != BadString)
+      OS << "start file '" << StartFileName << "', ";
     OS << "start line " << StartLine << '\n';
   }
 };
@@ -109,7 +120,7 @@
   uint64_t Start = 0;
   uint64_t Size = 0;
 
-  DIGlobal() : Name("<invalid>") {}
+  DIGlobal() : Name(DILineInfo::BadString) {}
 };
 
 struct DILocal {
@@ -129,20 +140,29 @@
 /// Controls which fields of DILineInfo container should be filled
 /// with data.
 struct DILineInfoSpecifier {
-  enum class FileLineInfoKind { None, Default, AbsoluteFilePath };
+  enum class FileLineInfoKind {
+    None,
+    // RawValue is whatever the compiler stored in the filename table.  Could be
+    // a full path, could be something else.
+    RawValue,
+    BaseNameOnly,
+    // Relative to the compilation directory.
+    RelativeFilePath,
+    AbsoluteFilePath
+  };
   using FunctionNameKind = DINameKind;
 
   FileLineInfoKind FLIKind;
   FunctionNameKind FNKind;
 
-  DILineInfoSpecifier(FileLineInfoKind FLIKind = FileLineInfoKind::Default,
+  DILineInfoSpecifier(FileLineInfoKind FLIKind = FileLineInfoKind::RawValue,
                       FunctionNameKind FNKind = FunctionNameKind::None)
       : FLIKind(FLIKind), FNKind(FNKind) {}
 };
 
 /// This is just a helper to programmatically construct DIDumpType.
 enum DIDumpTypeCounter {
-#define HANDLE_DWARF_SECTION(ENUM_NAME, ELF_NAME, CMDLINE_NAME) \
+#define HANDLE_DWARF_SECTION(ENUM_NAME, ELF_NAME, CMDLINE_NAME, OPTION)        \
   DIDT_ID_##ENUM_NAME,
 #include "llvm/BinaryFormat/Dwarf.def"
 #undef HANDLE_DWARF_SECTION
@@ -155,7 +175,7 @@
 enum DIDumpType : unsigned {
   DIDT_Null,
   DIDT_All             = ~0U,
-#define HANDLE_DWARF_SECTION(ENUM_NAME, ELF_NAME, CMDLINE_NAME) \
+#define HANDLE_DWARF_SECTION(ENUM_NAME, ELF_NAME, CMDLINE_NAME, OPTION)        \
   DIDT_##ENUM_NAME = 1U << DIDT_ID_##ENUM_NAME,
 #include "llvm/BinaryFormat/Dwarf.def"
 #undef HANDLE_DWARF_SECTION
@@ -195,6 +215,10 @@
       Opts.ParentRecurseDepth = 0;
     return Opts;
   }
+
+  std::function<void(Error)> RecoverableErrorHandler =
+      WithColor::defaultErrorHandler;
+  std::function<void(Error)> WarningHandler = WithColor::defaultWarningHandler;
 };
 
 class DIContext {
@@ -289,7 +313,7 @@
   LoadedObjectInfoHelper(Ts &&... Args) : Base(std::forward<Ts>(Args)...) {}
 
   std::unique_ptr<llvm::LoadedObjectInfo> clone() const override {
-    return llvm::make_unique<Derived>(static_cast<const Derived &>(*this));
+    return std::make_unique<Derived>(static_cast<const Derived &>(*this));
   }
 };
 
diff --git a/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFAbbreviationDeclaration.h b/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFAbbreviationDeclaration.h
index ccf2891..39ae53c 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFAbbreviationDeclaration.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFAbbreviationDeclaration.h
@@ -130,11 +130,11 @@
   /// \param Attr DWARF attribute to search for.
   /// \param U the DWARFUnit the contains the DIE.
   /// \returns Optional DWARF form value if the attribute was extracted.
-  Optional<DWARFFormValue> getAttributeValue(const uint32_t DIEOffset,
+  Optional<DWARFFormValue> getAttributeValue(const uint64_t DIEOffset,
                                              const dwarf::Attribute Attr,
                                              const DWARFUnit &U) const;
 
-  bool extract(DataExtractor Data, uint32_t* OffsetPtr);
+  bool extract(DataExtractor Data, uint64_t* OffsetPtr);
   void dump(raw_ostream &OS) const;
 
   // Return an optional byte size of all attribute data in this abbreviation
diff --git a/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFAcceleratorTable.h b/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFAcceleratorTable.h
index 3033757..961a8d8 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFAcceleratorTable.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFAcceleratorTable.h
@@ -96,7 +96,7 @@
     using AtomType = uint16_t;
     using Form = dwarf::Form;
 
-    uint32_t DIEOffsetBase;
+    uint64_t DIEOffsetBase;
     SmallVector<std::pair<AtomType, Form>, 3> Atoms;
 
     Optional<uint64_t> extractOffset(Optional<DWARFFormValue> Value) const;
@@ -109,7 +109,7 @@
   /// Returns true if we should continue scanning for entries or false if we've
   /// reached the last (sentinel) entry of encountered a parsing error.
   bool dumpName(ScopedPrinter &W, SmallVectorImpl<DWARFFormValue> &AtomForms,
-                uint32_t *DataOffset) const;
+                uint64_t *DataOffset) const;
 
 public:
   /// Apple-specific implementation of an Accelerator Entry.
@@ -119,7 +119,7 @@
     Entry(const HeaderData &Data);
     Entry() = default;
 
-    void extract(const AppleAcceleratorTable &AccelTable, uint32_t *Offset);
+    void extract(const AppleAcceleratorTable &AccelTable, uint64_t *Offset);
 
   public:
     Optional<uint64_t> getCUOffset() const override;
@@ -143,7 +143,7 @@
   class ValueIterator : public std::iterator<std::input_iterator_tag, Entry> {
     const AppleAcceleratorTable *AccelTable = nullptr;
     Entry Current;           ///< The current entry.
-    unsigned DataOffset = 0; ///< Offset into the section.
+    uint64_t DataOffset = 0; ///< Offset into the section.
     unsigned Data = 0; ///< Current data entry.
     unsigned NumData = 0; ///< Number of data entries.
 
@@ -151,7 +151,7 @@
     void Next();
   public:
     /// Construct a new iterator for the entries at \p DataOffset.
-    ValueIterator(const AppleAcceleratorTable &AccelTable, unsigned DataOffset);
+    ValueIterator(const AppleAcceleratorTable &AccelTable, uint64_t DataOffset);
     /// End marker.
     ValueIterator() = default;
 
@@ -193,7 +193,7 @@
   /// DieOffset is the offset into the .debug_info section for the DIE
   /// related to the input hash data offset.
   /// DieTag is the tag of the DIE
-  std::pair<uint32_t, dwarf::Tag> readAtoms(uint32_t &HashDataOffset);
+  std::pair<uint64_t, dwarf::Tag> readAtoms(uint64_t *HashDataOffset);
   void dump(raw_ostream &OS) const override;
 
   /// Look up all entries in the accelerator table matching \c Key.
@@ -222,11 +222,16 @@
 /// referenced by the name table and interpreted with the help of the
 /// abbreviation table.
 class DWARFDebugNames : public DWARFAcceleratorTable {
-  /// The fixed-size part of a DWARF v5 Name Index header
-  struct HeaderPOD {
-    uint32_t UnitLength;
+public:
+  class NameIndex;
+  class NameIterator;
+  class ValueIterator;
+
+  /// DWARF v5 Name Index header.
+  struct Header {
+    uint64_t UnitLength;
+    dwarf::DwarfFormat Format;
     uint16_t Version;
-    uint16_t Padding;
     uint32_t CompUnitCount;
     uint32_t LocalTypeUnitCount;
     uint32_t ForeignTypeUnitCount;
@@ -234,18 +239,9 @@
     uint32_t NameCount;
     uint32_t AbbrevTableSize;
     uint32_t AugmentationStringSize;
-  };
-
-public:
-  class NameIndex;
-  class NameIterator;
-  class ValueIterator;
-
-  /// DWARF v5 Name Index header.
-  struct Header : public HeaderPOD {
     SmallString<8> AugmentationString;
 
-    Error extract(const DWARFDataExtractor &AS, uint32_t *Offset);
+    Error extract(const DWARFDataExtractor &AS, uint64_t *Offset);
     void dump(ScopedPrinter &W) const;
   };
 
@@ -354,12 +350,12 @@
     DataExtractor StrData;
 
     uint32_t Index;
-    uint32_t StringOffset;
-    uint32_t EntryOffset;
+    uint64_t StringOffset;
+    uint64_t EntryOffset;
 
   public:
     NameTableEntry(const DataExtractor &StrData, uint32_t Index,
-                   uint32_t StringOffset, uint32_t EntryOffset)
+                   uint64_t StringOffset, uint64_t EntryOffset)
         : StrData(StrData), Index(Index), StringOffset(StringOffset),
           EntryOffset(EntryOffset) {}
 
@@ -367,17 +363,17 @@
     uint32_t getIndex() const { return Index; }
 
     /// Returns the offset of the name of the described entities.
-    uint32_t getStringOffset() const { return StringOffset; }
+    uint64_t getStringOffset() const { return StringOffset; }
 
     /// Return the string referenced by this name table entry or nullptr if the
     /// string offset is not valid.
     const char *getString() const {
-      uint32_t Off = StringOffset;
+      uint64_t Off = StringOffset;
       return StrData.getCStr(&Off);
     }
 
     /// Returns the offset of the first Entry in the list.
-    uint32_t getEntryOffset() const { return EntryOffset; }
+    uint64_t getEntryOffset() const { return EntryOffset; }
   };
 
   /// Represents a single accelerator table within the DWARF v5 .debug_names
@@ -389,40 +385,40 @@
 
     // Base of the whole unit and of various important tables, as offsets from
     // the start of the section.
-    uint32_t Base;
-    uint32_t CUsBase;
-    uint32_t BucketsBase;
-    uint32_t HashesBase;
-    uint32_t StringOffsetsBase;
-    uint32_t EntryOffsetsBase;
-    uint32_t EntriesBase;
+    uint64_t Base;
+    uint64_t CUsBase;
+    uint64_t BucketsBase;
+    uint64_t HashesBase;
+    uint64_t StringOffsetsBase;
+    uint64_t EntryOffsetsBase;
+    uint64_t EntriesBase;
 
     void dumpCUs(ScopedPrinter &W) const;
     void dumpLocalTUs(ScopedPrinter &W) const;
     void dumpForeignTUs(ScopedPrinter &W) const;
     void dumpAbbreviations(ScopedPrinter &W) const;
-    bool dumpEntry(ScopedPrinter &W, uint32_t *Offset) const;
+    bool dumpEntry(ScopedPrinter &W, uint64_t *Offset) const;
     void dumpName(ScopedPrinter &W, const NameTableEntry &NTE,
                   Optional<uint32_t> Hash) const;
     void dumpBucket(ScopedPrinter &W, uint32_t Bucket) const;
 
-    Expected<AttributeEncoding> extractAttributeEncoding(uint32_t *Offset);
+    Expected<AttributeEncoding> extractAttributeEncoding(uint64_t *Offset);
 
     Expected<std::vector<AttributeEncoding>>
-    extractAttributeEncodings(uint32_t *Offset);
+    extractAttributeEncodings(uint64_t *Offset);
 
-    Expected<Abbrev> extractAbbrev(uint32_t *Offset);
+    Expected<Abbrev> extractAbbrev(uint64_t *Offset);
 
   public:
-    NameIndex(const DWARFDebugNames &Section, uint32_t Base)
+    NameIndex(const DWARFDebugNames &Section, uint64_t Base)
         : Section(Section), Base(Base) {}
 
     /// Reads offset of compilation unit CU. CU is 0-based.
-    uint32_t getCUOffset(uint32_t CU) const;
+    uint64_t getCUOffset(uint32_t CU) const;
     uint32_t getCUCount() const { return Hdr.CompUnitCount; }
 
     /// Reads offset of local type unit TU, TU is 0-based.
-    uint32_t getLocalTUOffset(uint32_t TU) const;
+    uint64_t getLocalTUOffset(uint32_t TU) const;
     uint32_t getLocalTUCount() const { return Hdr.LocalTypeUnitCount; }
 
     /// Reads signature of foreign type unit TU. TU is 0-based.
@@ -451,7 +447,7 @@
       return Abbrevs;
     }
 
-    Expected<Entry> getEntry(uint32_t *Offset) const;
+    Expected<Entry> getEntry(uint64_t *Offset) const;
 
     /// Look up all entries in this Name Index matching \c Key.
     iterator_range<ValueIterator> equal_range(StringRef Key) const;
@@ -460,8 +456,11 @@
     NameIterator end() const { return NameIterator(this, getNameCount() + 1); }
 
     Error extract();
-    uint32_t getUnitOffset() const { return Base; }
-    uint32_t getNextUnitOffset() const { return Base + 4 + Hdr.UnitLength; }
+    uint64_t getUnitOffset() const { return Base; }
+    uint64_t getNextUnitOffset() const {
+      return Base + dwarf::getUnitLengthFieldByteSize(Hdr.Format) +
+             Hdr.UnitLength;
+    }
     void dump(ScopedPrinter &W) const;
 
     friend class DWARFDebugNames;
@@ -479,12 +478,12 @@
     bool IsLocal;
 
     Optional<Entry> CurrentEntry;
-    unsigned DataOffset = 0; ///< Offset into the section.
+    uint64_t DataOffset = 0; ///< Offset into the section.
     std::string Key;         ///< The Key we are searching for.
     Optional<uint32_t> Hash; ///< Hash of Key, if it has been computed.
 
     bool getEntryAtCurrentOffset();
-    Optional<uint32_t> findEntryOffsetInCurrentIndex();
+    Optional<uint64_t> findEntryOffsetInCurrentIndex();
     bool findInCurrentIndex();
     void searchFromStartOfCurrentIndex();
     void next();
@@ -572,7 +571,7 @@
 
 private:
   SmallVector<NameIndex, 0> NameIndices;
-  DenseMap<uint32_t, const NameIndex *> CUToNameIndex;
+  DenseMap<uint64_t, const NameIndex *> CUToNameIndex;
 
 public:
   DWARFDebugNames(const DWARFDataExtractor &AccelSection,
@@ -591,7 +590,7 @@
 
   /// Return the Name Index covering the compile unit at CUOffset, or nullptr if
   /// there is no Name Index covering that unit.
-  const NameIndex *getCUNameIndex(uint32_t CUOffset);
+  const NameIndex *getCUNameIndex(uint64_t CUOffset);
 };
 
 } // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFAddressRange.h b/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFAddressRange.h
index 2d5f9f3..154f789 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFAddressRange.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFAddressRange.h
@@ -17,6 +17,7 @@
 namespace llvm {
 
 class raw_ostream;
+class DWARFObject;
 
 struct DWARFAddressRange {
   uint64_t LowPC;
@@ -26,7 +27,9 @@
   DWARFAddressRange() = default;
 
   /// Used for unit testing.
-  DWARFAddressRange(uint64_t LowPC, uint64_t HighPC, uint64_t SectionIndex = 0)
+  DWARFAddressRange(
+      uint64_t LowPC, uint64_t HighPC,
+      uint64_t SectionIndex = object::SectionedAddress::UndefSection)
       : LowPC(LowPC), HighPC(HighPC), SectionIndex(SectionIndex) {}
 
   /// Returns true if LowPC is smaller or equal to HighPC. This accounts for
@@ -42,15 +45,38 @@
     return LowPC < RHS.HighPC && RHS.LowPC < HighPC;
   }
 
-  void dump(raw_ostream &OS, uint32_t AddressSize,
-            DIDumpOptions DumpOpts = {}) const;
+  /// Union two address ranges if they intersect.
+  ///
+  /// This function will union two address ranges if they intersect by
+  /// modifying this range to be the union of both ranges. If the two ranges
+  /// don't intersect this range will be left alone.
+  ///
+  /// \param RHS Another address range to combine with.
+  ///
+  /// \returns false if the ranges don't intersect, true if they do and the
+  /// ranges were combined.
+  bool merge(const DWARFAddressRange &RHS) {
+    if (!intersects(RHS))
+      return false;
+    LowPC = std::min<uint64_t>(LowPC, RHS.LowPC);
+    HighPC = std::max<uint64_t>(HighPC, RHS.HighPC);
+    return true;
+  }
+
+  void dump(raw_ostream &OS, uint32_t AddressSize, DIDumpOptions DumpOpts = {},
+            const DWARFObject *Obj = nullptr) const;
 };
 
-static inline bool operator<(const DWARFAddressRange &LHS,
-                             const DWARFAddressRange &RHS) {
+inline bool operator<(const DWARFAddressRange &LHS,
+                      const DWARFAddressRange &RHS) {
   return std::tie(LHS.LowPC, LHS.HighPC) < std::tie(RHS.LowPC, RHS.HighPC);
 }
 
+inline bool operator==(const DWARFAddressRange &LHS,
+                       const DWARFAddressRange &RHS) {
+  return std::tie(LHS.LowPC, LHS.HighPC) == std::tie(RHS.LowPC, RHS.HighPC);
+}
+
 raw_ostream &operator<<(raw_ostream &OS, const DWARFAddressRange &R);
 
 /// DWARFAddressRangesVector - represents a set of absolute address ranges.
diff --git a/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFAttribute.h b/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFAttribute.h
index 96e622c..dfc7783 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFAttribute.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFAttribute.h
@@ -23,17 +23,14 @@
 /// attributes in a DWARFDie.
 struct DWARFAttribute {
   /// The debug info/types offset for this attribute.
-  uint32_t Offset = 0;
+  uint64_t Offset = 0;
   /// The debug info/types section byte size of the data for this attribute.
   uint32_t ByteSize = 0;
   /// The attribute enumeration of this attribute.
-  dwarf::Attribute Attr;
+  dwarf::Attribute Attr = dwarf::Attribute(0);
   /// The form and value for this attribute.
   DWARFFormValue Value;
 
-  DWARFAttribute(uint32_t O, dwarf::Attribute A = dwarf::Attribute(0),
-                 dwarf::Form F = dwarf::Form(0)) : Attr(A), Value(F) {}
-
   bool isValid() const {
     return Offset != 0 && Attr != dwarf::Attribute(0);
   }
@@ -45,13 +42,6 @@
   /// Identifies DWARF attributes that may contain a reference to a
   /// DWARF expression.
   static bool mayHaveLocationDescription(dwarf::Attribute Attr);
-
-  void clear() {
-    Offset = 0;
-    ByteSize = 0;
-    Attr = dwarf::Attribute(0);
-    Value = DWARFFormValue();
-  }
 };
 
 } // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFContext.h b/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFContext.h
index 23cf21c..7d88e14 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFContext.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFContext.h
@@ -47,11 +47,6 @@
 class MemoryBuffer;
 class raw_ostream;
 
-/// Used as a return value for a error callback passed to DWARF context.
-/// Callback should return Halt if client application wants to stop
-/// object parsing, or should return Continue otherwise.
-enum class ErrorPolicy { Halt, Continue };
-
 /// DWARFContext
 /// This data structure is the top level entity that deals with dwarf debug
 /// information parsing. The actual data is supplied through DWARFObj.
@@ -67,6 +62,7 @@
   std::unique_ptr<DWARFDebugFrame> DebugFrame;
   std::unique_ptr<DWARFDebugFrame> EHFrame;
   std::unique_ptr<DWARFDebugMacro> Macro;
+  std::unique_ptr<DWARFDebugMacro> Macinfo;
   std::unique_ptr<DWARFDebugNames> Names;
   std::unique_ptr<AppleAcceleratorTable> AppleNames;
   std::unique_ptr<AppleAcceleratorTable> AppleTypes;
@@ -75,7 +71,8 @@
 
   DWARFUnitVector DWOUnits;
   std::unique_ptr<DWARFDebugAbbrev> AbbrevDWO;
-  std::unique_ptr<DWARFDebugLoclists> LocDWO;
+  std::unique_ptr<DWARFDebugMacro> MacinfoDWO;
+  std::unique_ptr<DWARFDebugMacro> MacroDWO;
 
   /// The maximum DWARF version of all units.
   unsigned MaxVersion = 0;
@@ -91,6 +88,10 @@
 
   std::unique_ptr<MCRegisterInfo> RegInfo;
 
+  std::function<void(Error)> RecoverableErrorHandler =
+      WithColor::defaultErrorHandler;
+  std::function<void(Error)> WarningHandler = WithColor::defaultWarningHandler;
+
   /// Read compile units from the debug_info section (if necessary)
   /// and type units from the debug_types sections (if necessary)
   /// and store them in NormalUnits.
@@ -105,9 +106,22 @@
 
   std::unique_ptr<const DWARFObject> DObj;
 
+  /// Helper enum to distinguish between macro[.dwo] and macinfo[.dwo]
+  /// section.
+  enum MacroSecType {
+    MacinfoSection,
+    MacinfoDwoSection,
+    MacroSection,
+    MacroDwoSection
+  };
+
 public:
   DWARFContext(std::unique_ptr<const DWARFObject> DObj,
-               std::string DWPName = "");
+               std::string DWPName = "",
+               std::function<void(Error)> RecoverableErrorHandler =
+                   WithColor::defaultErrorHandler,
+               std::function<void(Error)> WarningHandler =
+                   WithColor::defaultWarningHandler);
   ~DWARFContext();
 
   DWARFContext(DWARFContext &) = delete;
@@ -132,6 +146,7 @@
   bool verify(raw_ostream &OS, DIDumpOptions DumpOpts = {}) override;
 
   using unit_iterator_range = DWARFUnitVector::iterator_range;
+  using compile_unit_range = DWARFUnitVector::compile_unit_range;
 
   /// Get units from .debug_info in this context.
   unit_iterator_range info_section_units() {
@@ -149,10 +164,12 @@
   }
 
   /// Get compile units in this context.
-  unit_iterator_range compile_units() { return info_section_units(); }
+  compile_unit_range compile_units() {
+    return make_filter_range(info_section_units(), isCompileUnit);
+  }
 
-  /// Get type units in this context.
-  unit_iterator_range type_units() { return types_section_units(); }
+  // If you want type_units(), it'll need to be a concat iterator of a filter of
+  // TUs in info_section + all the (all type) units in types_section
 
   /// Get all normal compile/type units in this context.
   unit_iterator_range normal_units() {
@@ -175,10 +192,13 @@
   }
 
   /// Get compile units in the DWO context.
-  unit_iterator_range dwo_compile_units() { return dwo_info_section_units(); }
+  compile_unit_range dwo_compile_units() {
+    return make_filter_range(dwo_info_section_units(), isCompileUnit);
+  }
 
-  /// Get type units in the DWO context.
-  unit_iterator_range dwo_type_units() { return dwo_types_section_units(); }
+  // If you want dwo_type_units(), it'll need to be a concat iterator of a
+  // filter of TUs in dwo_info_section + all the (all type) units in
+  // dwo_types_section.
 
   /// Get all units in the DWO context.
   unit_iterator_range dwo_units() {
@@ -225,10 +245,10 @@
   DWARFCompileUnit *getDWOCompileUnitForHash(uint64_t Hash);
 
   /// Return the compile unit that includes an offset (relative to .debug_info).
-  DWARFCompileUnit *getCompileUnitForOffset(uint32_t Offset);
+  DWARFCompileUnit *getCompileUnitForOffset(uint64_t Offset);
 
   /// Get a DIE given an exact offset.
-  DWARFDie getDIEForOffset(uint32_t Offset);
+  DWARFDie getDIEForOffset(uint64_t Offset);
 
   unsigned getMaxVersion() {
     // Ensure info units have been parsed to discover MaxVersion
@@ -260,21 +280,27 @@
   /// Get a pointer to the parsed dwo abbreviations object.
   const DWARFDebugAbbrev *getDebugAbbrevDWO();
 
-  /// Get a pointer to the parsed DebugLoc object.
-  const DWARFDebugLoclists *getDebugLocDWO();
-
   /// Get a pointer to the parsed DebugAranges object.
   const DWARFDebugAranges *getDebugAranges();
 
   /// Get a pointer to the parsed frame information object.
-  const DWARFDebugFrame *getDebugFrame();
+  Expected<const DWARFDebugFrame *> getDebugFrame();
 
   /// Get a pointer to the parsed eh frame information object.
-  const DWARFDebugFrame *getEHFrame();
+  Expected<const DWARFDebugFrame *> getEHFrame();
 
-  /// Get a pointer to the parsed DebugMacro object.
+  /// Get a pointer to the parsed DebugMacinfo information object.
+  const DWARFDebugMacro *getDebugMacinfo();
+
+  /// Get a pointer to the parsed DebugMacinfoDWO information object.
+  const DWARFDebugMacro *getDebugMacinfoDWO();
+
+  /// Get a pointer to the parsed DebugMacro information object.
   const DWARFDebugMacro *getDebugMacro();
 
+  /// Get a pointer to the parsed DebugMacroDWO information object.
+  const DWARFDebugMacro *getDebugMacroDWO();
+
   /// Get a reference to the parsed accelerator table object.
   const DWARFDebugNames &getDebugNames();
 
@@ -295,16 +321,19 @@
   const DWARFDebugLine::LineTable *getLineTableForUnit(DWARFUnit *U);
 
   /// Get a pointer to a parsed line table corresponding to a compile unit.
-  /// Report any recoverable parsing problems using the callback.
+  /// Report any recoverable parsing problems using the handler.
   Expected<const DWARFDebugLine::LineTable *>
   getLineTableForUnit(DWARFUnit *U,
-                      std::function<void(Error)> RecoverableErrorCallback);
+                      function_ref<void(Error)> RecoverableErrorHandler);
 
   DataExtractor getStringExtractor() const {
-    return DataExtractor(DObj->getStringSection(), false, 0);
+    return DataExtractor(DObj->getStrSection(), false, 0);
+  }
+  DataExtractor getStringDWOExtractor() const {
+    return DataExtractor(DObj->getStrDWOSection(), false, 0);
   }
   DataExtractor getLineStringExtractor() const {
-    return DataExtractor(DObj->getLineStringSection(), false, 0);
+    return DataExtractor(DObj->getLineStrSection(), false, 0);
   }
 
   /// Wraps the returned DIEs for a given address.
@@ -339,21 +368,35 @@
     return version == 2 || version == 3 || version == 4 || version == 5;
   }
 
+  static bool isAddressSizeSupported(unsigned AddressSize) {
+    return AddressSize == 2 || AddressSize == 4 || AddressSize == 8;
+  }
+
   std::shared_ptr<DWARFContext> getDWOContext(StringRef AbsolutePath);
 
   const MCRegisterInfo *getRegisterInfo() const { return RegInfo.get(); }
 
-  /// Function used to handle default error reporting policy. Prints a error
-  /// message and returns Continue, so DWARF context ignores the error.
-  static ErrorPolicy defaultErrorHandler(Error E);
+  function_ref<void(Error)> getRecoverableErrorHandler() {
+    return RecoverableErrorHandler;
+  }
+
+  function_ref<void(Error)> getWarningHandler() { return WarningHandler; }
+
   static std::unique_ptr<DWARFContext>
   create(const object::ObjectFile &Obj, const LoadedObjectInfo *L = nullptr,
-         function_ref<ErrorPolicy(Error)> HandleError = defaultErrorHandler,
-         std::string DWPName = "");
+         std::string DWPName = "",
+         std::function<void(Error)> RecoverableErrorHandler =
+             WithColor::defaultErrorHandler,
+         std::function<void(Error)> WarningHandler =
+             WithColor::defaultWarningHandler);
 
   static std::unique_ptr<DWARFContext>
   create(const StringMap<std::unique_ptr<MemoryBuffer>> &Sections,
-         uint8_t AddrSize, bool isLittleEndian = sys::IsLittleEndianHost);
+         uint8_t AddrSize, bool isLittleEndian = sys::IsLittleEndianHost,
+         std::function<void(Error)> RecoverableErrorHandler =
+             WithColor::defaultErrorHandler,
+         std::function<void(Error)> WarningHandler =
+             WithColor::defaultWarningHandler);
 
   /// Loads register info for the architecture of the provided object file.
   /// Improves readability of dumped DWARF expressions. Requires the caller to
@@ -364,19 +407,21 @@
   /// TODO: refactor compile_units() to make this const.
   uint8_t getCUAddrSize();
 
-  /// Dump Error as warning message to stderr.
-  static void dumpWarning(Error Warning);
-
   Triple::ArchType getArch() const {
     return getDWARFObj().getFile()->getArch();
   }
 
-private:
   /// Return the compile unit which contains instruction with provided
   /// address.
   /// TODO: change input parameter from "uint64_t Address"
   ///       into "SectionedAddress Address"
   DWARFCompileUnit *getCompileUnitForAddress(uint64_t Address);
+
+private:
+  /// Parse a macro[.dwo] or macinfo[.dwo] section.
+  std::unique_ptr<DWARFDebugMacro>
+  parseMacroOrMacinfo(MacroSecType SectionType);
+
   void addLocalsForDie(DWARFCompileUnit *CU, DWARFDie Subprogram, DWARFDie Die,
                        std::vector<DILocal> &Result);
 };
diff --git a/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFDataExtractor.h b/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFDataExtractor.h
index 7c2a159..34329ec 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFDataExtractor.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFDataExtractor.h
@@ -9,6 +9,7 @@
 #ifndef LLVM_DEBUGINFO_DWARFDATAEXTRACTOR_H
 #define LLVM_DEBUGINFO_DWARFDATAEXTRACTOR_H
 
+#include "llvm/BinaryFormat/Dwarf.h"
 #include "llvm/DebugInfo/DWARF/DWARFSection.h"
 #include "llvm/Support/DataExtractor.h"
 
@@ -32,26 +33,56 @@
   /// Constructor for cases when there are no relocations.
   DWARFDataExtractor(StringRef Data, bool IsLittleEndian, uint8_t AddressSize)
     : DataExtractor(Data, IsLittleEndian, AddressSize) {}
+  DWARFDataExtractor(ArrayRef<uint8_t> Data, bool IsLittleEndian,
+                     uint8_t AddressSize)
+      : DataExtractor(
+            StringRef(reinterpret_cast<const char *>(Data.data()), Data.size()),
+            IsLittleEndian, AddressSize) {}
+
+  /// Truncating constructor
+  DWARFDataExtractor(const DWARFDataExtractor &Other, size_t Length)
+      : DataExtractor(Other.getData().substr(0, Length), Other.isLittleEndian(),
+                      Other.getAddressSize()),
+        Obj(Other.Obj), Section(Other.Section) {}
+
+  /// Extracts the DWARF "initial length" field, which can either be a 32-bit
+  /// value smaller than 0xfffffff0, or the value 0xffffffff followed by a
+  /// 64-bit length. Returns the actual length, and the DWARF format which is
+  /// encoded in the field. In case of errors, it returns {0, DWARF32} and
+  /// leaves the offset unchanged.
+  std::pair<uint64_t, dwarf::DwarfFormat>
+  getInitialLength(uint64_t *Off, Error *Err = nullptr) const;
+
+  std::pair<uint64_t, dwarf::DwarfFormat> getInitialLength(Cursor &C) const {
+    return getInitialLength(&getOffset(C), &getError(C));
+  }
 
   /// Extracts a value and applies a relocation to the result if
   /// one exists for the given offset.
-  uint64_t getRelocatedValue(uint32_t Size, uint32_t *Off,
-                             uint64_t *SectionIndex = nullptr) const;
+  uint64_t getRelocatedValue(uint32_t Size, uint64_t *Off,
+                             uint64_t *SectionIndex = nullptr,
+                             Error *Err = nullptr) const;
+  uint64_t getRelocatedValue(Cursor &C, uint32_t Size,
+                             uint64_t *SectionIndex = nullptr) const {
+    return getRelocatedValue(Size, &getOffset(C), SectionIndex, &getError(C));
+  }
 
   /// Extracts an address-sized value and applies a relocation to the result if
   /// one exists for the given offset.
-  uint64_t getRelocatedAddress(uint32_t *Off, uint64_t *SecIx = nullptr) const {
+  uint64_t getRelocatedAddress(uint64_t *Off, uint64_t *SecIx = nullptr) const {
     return getRelocatedValue(getAddressSize(), Off, SecIx);
   }
+  uint64_t getRelocatedAddress(Cursor &C, uint64_t *SecIx = nullptr) const {
+    return getRelocatedValue(getAddressSize(), &getOffset(C), SecIx,
+                             &getError(C));
+  }
 
   /// Extracts a DWARF-encoded pointer in \p Offset using \p Encoding.
   /// There is a DWARF encoding that uses a PC-relative adjustment.
   /// For these values, \p AbsPosOffset is used to fix them, which should
   /// reflect the absolute address of this pointer.
-  Optional<uint64_t> getEncodedPointer(uint32_t *Offset, uint8_t Encoding,
+  Optional<uint64_t> getEncodedPointer(uint64_t *Offset, uint8_t Encoding,
                                        uint64_t AbsPosOffset = 0) const;
-
-  size_t size() const { return Section == nullptr ? 0 : Section->Data.size(); }
 };
 
 } // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFDebugAbbrev.h b/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFDebugAbbrev.h
index 28fd848..1398e16 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFDebugAbbrev.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFDebugAbbrev.h
@@ -20,7 +20,7 @@
 class raw_ostream;
 
 class DWARFAbbreviationDeclarationSet {
-  uint32_t Offset;
+  uint64_t Offset;
   /// Code of the first abbreviation, if all abbreviations in the set have
   /// consecutive codes. UINT32_MAX otherwise.
   uint32_t FirstAbbrCode;
@@ -32,9 +32,9 @@
 public:
   DWARFAbbreviationDeclarationSet();
 
-  uint32_t getOffset() const { return Offset; }
+  uint64_t getOffset() const { return Offset; }
   void dump(raw_ostream &OS) const;
-  bool extract(DataExtractor Data, uint32_t *OffsetPtr);
+  bool extract(DataExtractor Data, uint64_t *OffsetPtr);
 
   const DWARFAbbreviationDeclaration *
   getAbbreviationDeclaration(uint32_t AbbrCode) const;
diff --git a/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFDebugAddr.h b/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFDebugAddr.h
index a98bf28..69e6786 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFDebugAddr.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFDebugAddr.h
@@ -27,69 +27,71 @@
 /// The table consists of a header followed by an array of address values from
 /// .debug_addr section.
 class DWARFDebugAddrTable {
-public:
-  struct Header {
-    /// The total length of the entries for this table, not including the length
-    /// field itself.
-    uint32_t Length = 0;
-    /// The DWARF version number.
-    uint16_t Version = 5;
-    /// The size in bytes of an address on the target architecture. For
-    /// segmented addressing, this is the size of the offset portion of the
-    /// address.
-    uint8_t AddrSize;
-    /// The size in bytes of a segment selector on the target architecture.
-    /// If the target system uses a flat address space, this value is 0.
-    uint8_t SegSize = 0;
-  };
-
-private:
   dwarf::DwarfFormat Format;
-  uint32_t HeaderOffset;
-  Header HeaderData;
-  uint32_t DataSize = 0;
+  uint64_t Offset;
+  /// The total length of the entries for this table, not including the length
+  /// field itself.
+  uint64_t Length = 0;
+  /// The DWARF version number.
+  uint16_t Version;
+  /// The size in bytes of an address on the target architecture. For
+  /// segmented addressing, this is the size of the offset portion of the
+  /// address.
+  uint8_t AddrSize;
+  /// The size in bytes of a segment selector on the target architecture.
+  /// If the target system uses a flat address space, this value is 0.
+  uint8_t SegSize;
   std::vector<uint64_t> Addrs;
 
-public:
-  void clear();
+  /// Invalidate Length field to stop further processing.
+  void invalidateLength() { Length = 0; }
 
-  /// Extract an entire table, including all addresses.
-  Error extract(DWARFDataExtractor Data, uint32_t *OffsetPtr,
-                uint16_t Version, uint8_t AddrSize,
+  Error extractAddresses(const DWARFDataExtractor &Data, uint64_t *OffsetPtr,
+                         uint64_t EndOffset);
+
+public:
+
+  /// Extract the entire table, including all addresses.
+  Error extract(const DWARFDataExtractor &Data, uint64_t *OffsetPtr,
+                uint16_t CUVersion, uint8_t CUAddrSize,
                 std::function<void(Error)> WarnCallback);
 
-  uint32_t getHeaderOffset() const { return HeaderOffset; }
-  uint8_t getAddrSize() const { return HeaderData.AddrSize; }
+  /// Extract a DWARFv5 address table.
+  Error extractV5(const DWARFDataExtractor &Data, uint64_t *OffsetPtr,
+                  uint8_t CUAddrSize, std::function<void(Error)> WarnCallback);
+
+  /// Extract a pre-DWARFv5 address table. Such tables do not have a header
+  /// and consist only of a series of addresses.
+  /// See https://gcc.gnu.org/wiki/DebugFission for details.
+  Error extractPreStandard(const DWARFDataExtractor &Data, uint64_t *OffsetPtr,
+                           uint16_t CUVersion, uint8_t CUAddrSize);
+
   void dump(raw_ostream &OS, DIDumpOptions DumpOpts = {}) const;
 
   /// Return the address based on a given index.
   Expected<uint64_t> getAddrEntry(uint32_t Index) const;
 
-  /// Return the size of the table header including the length
-  /// but not including the addresses.
-  uint8_t getHeaderSize() const {
-    switch (Format) {
-    case dwarf::DwarfFormat::DWARF32:
-      return 8; // 4 + 2 + 1 + 1
-    case dwarf::DwarfFormat::DWARF64:
-      return 16; // 12 + 2 + 1 + 1
-    }
-    llvm_unreachable("Invalid DWARF format (expected DWARF32 or DWARF64)");
-  }
+  /// Return the full length of this table, including the length field.
+  /// Return None if the length cannot be identified reliably.
+  Optional<uint64_t> getFullLength() const;
 
-  /// Returns the length of this table, including the length field, or 0 if the
-  /// length has not been determined (e.g. because the table has not yet been
-  /// parsed, or there was a problem in parsing).
-  uint32_t getLength() const;
+  /// Return the DWARF format of this table.
+  dwarf::DwarfFormat getFormat() const { return Format; }
 
-  /// Verify that the given length is valid for this table.
-  bool hasValidLength() const { return getLength() != 0; }
+  /// Return the length of this table.
+  uint64_t getLength() const { return Length; }
 
-  /// Invalidate Length field to stop further processing.
-  void invalidateLength() { HeaderData.Length = 0; }
+  /// Return the version of this table.
+  uint16_t getVersion() const { return Version; }
 
-  /// Returns the length of the array of addresses.
-  uint32_t getDataSize() const;
+  /// Return the address size of this table.
+  uint8_t getAddressSize() const { return AddrSize; }
+
+  /// Return the segment selector size of this table.
+  uint8_t getSegmentSelectorSize() const { return SegSize; }
+
+  /// Return the parsed addresses of this table.
+  ArrayRef<uint64_t> getAddressEntries() const { return Addrs; }
 };
 
 } // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFDebugArangeSet.h b/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFDebugArangeSet.h
index 5b6c578..3d5852e 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFDebugArangeSet.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFDebugArangeSet.h
@@ -10,7 +10,8 @@
 #define LLVM_DEBUGINFO_DWARFDEBUGARANGESET_H
 
 #include "llvm/ADT/iterator_range.h"
-#include "llvm/Support/DataExtractor.h"
+#include "llvm/DebugInfo/DWARF/DWARFDataExtractor.h"
+#include "llvm/Support/Error.h"
 #include <cstdint>
 #include <vector>
 
@@ -23,10 +24,12 @@
   struct Header {
     /// The total length of the entries for that set, not including the length
     /// field itself.
-    uint32_t Length;
+    uint64_t Length;
+    /// The DWARF format of the set.
+    dwarf::DwarfFormat Format;
     /// The offset from the beginning of the .debug_info section of the
     /// compilation unit entry referenced by the table.
-    uint32_t CuOffset;
+    uint64_t CuOffset;
     /// The DWARF version number.
     uint16_t Version;
     /// The size in bytes of an address on the target architecture. For segmented
@@ -49,7 +52,7 @@
   using DescriptorColl = std::vector<Descriptor>;
   using desc_iterator_range = iterator_range<DescriptorColl::const_iterator>;
 
-  uint32_t Offset;
+  uint64_t Offset;
   Header HeaderData;
   DescriptorColl ArangeDescriptors;
 
@@ -57,10 +60,11 @@
   DWARFDebugArangeSet() { clear(); }
 
   void clear();
-  bool extract(DataExtractor data, uint32_t *offset_ptr);
+  Error extract(DWARFDataExtractor data, uint64_t *offset_ptr,
+                function_ref<void(Error)> WarningHandler);
   void dump(raw_ostream &OS) const;
 
-  uint32_t getCompileUnitDIEOffset() const { return HeaderData.CuOffset; }
+  uint64_t getCompileUnitDIEOffset() const { return HeaderData.CuOffset; }
 
   const Header &getHeader() const { return HeaderData; }
 
diff --git a/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFDebugAranges.h b/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFDebugAranges.h
index 03223fb..31a8b46 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFDebugAranges.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFDebugAranges.h
@@ -10,7 +10,7 @@
 #define LLVM_DEBUGINFO_DWARFDEBUGARANGES_H
 
 #include "llvm/ADT/DenseSet.h"
-#include "llvm/Support/DataExtractor.h"
+#include "llvm/DebugInfo/DWARF/DWARFDataExtractor.h"
 #include <cstdint>
 #include <vector>
 
@@ -21,19 +21,19 @@
 class DWARFDebugAranges {
 public:
   void generate(DWARFContext *CTX);
-  uint32_t findAddress(uint64_t Address) const;
+  uint64_t findAddress(uint64_t Address) const;
 
 private:
   void clear();
-  void extract(DataExtractor DebugArangesData);
+  void extract(DWARFDataExtractor DebugArangesData,
+               function_ref<void(Error)> RecoverableErrorHandler);
 
   /// Call appendRange multiple times and then call construct.
-  void appendRange(uint32_t CUOffset, uint64_t LowPC, uint64_t HighPC);
+  void appendRange(uint64_t CUOffset, uint64_t LowPC, uint64_t HighPC);
   void construct();
 
   struct Range {
-    explicit Range(uint64_t LowPC = -1ULL, uint64_t HighPC = -1ULL,
-                   uint32_t CUOffset = -1U)
+    explicit Range(uint64_t LowPC, uint64_t HighPC, uint64_t CUOffset)
       : LowPC(LowPC), Length(HighPC - LowPC), CUOffset(CUOffset) {}
 
     void setHighPC(uint64_t HighPC) {
@@ -54,16 +54,16 @@
     }
 
     uint64_t LowPC; /// Start of address range.
-    uint32_t Length; /// End of address range (not including this address).
-    uint32_t CUOffset; /// Offset of the compile unit or die.
+    uint64_t Length; /// End of address range (not including this address).
+    uint64_t CUOffset; /// Offset of the compile unit or die.
   };
 
   struct RangeEndpoint {
     uint64_t Address;
-    uint32_t CUOffset;
+    uint64_t CUOffset;
     bool IsRangeStart;
 
-    RangeEndpoint(uint64_t Address, uint32_t CUOffset, bool IsRangeStart)
+    RangeEndpoint(uint64_t Address, uint64_t CUOffset, bool IsRangeStart)
         : Address(Address), CUOffset(CUOffset), IsRangeStart(IsRangeStart) {}
 
     bool operator<(const RangeEndpoint &Other) const {
@@ -76,7 +76,7 @@
 
   std::vector<RangeEndpoint> Endpoints;
   RangeColl Aranges;
-  DenseSet<uint32_t> ParsedCUOffsets;
+  DenseSet<uint64_t> ParsedCUOffsets;
 };
 
 } // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFDebugFrame.h b/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFDebugFrame.h
index d960f4b..af87811 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFDebugFrame.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFDebugFrame.h
@@ -69,10 +69,10 @@
   /// starting at *Offset and ending at EndOffset. *Offset is updated
   /// to EndOffset upon successful parsing, or indicates the offset
   /// where a problem occurred in case an error is returned.
-  Error parse(DataExtractor Data, uint32_t *Offset, uint32_t EndOffset);
+  Error parse(DWARFDataExtractor Data, uint64_t *Offset, uint64_t EndOffset);
 
-  void dump(raw_ostream &OS, const MCRegisterInfo *MRI, bool IsEH,
-            unsigned IndentLevel = 1) const;
+  void dump(raw_ostream &OS, DIDumpOptions DumpOpts, const MCRegisterInfo *MRI,
+            bool IsEH, unsigned IndentLevel = 1) const;
 
 private:
   std::vector<Instruction> Instructions;
@@ -121,7 +121,8 @@
   static ArrayRef<OperandType[2]> getOperandTypes();
 
   /// Print \p Opcode's operand number \p OperandIdx which has value \p Operand.
-  void printOperand(raw_ostream &OS, const MCRegisterInfo *MRI, bool IsEH,
+  void printOperand(raw_ostream &OS, DIDumpOptions DumpOpts,
+                    const MCRegisterInfo *MRI, bool IsEH,
                     const Instruction &Instr, unsigned OperandIdx,
                     uint64_t Operand) const;
 };
@@ -132,9 +133,9 @@
 public:
   enum FrameKind { FK_CIE, FK_FDE };
 
-  FrameEntry(FrameKind K, uint64_t Offset, uint64_t Length, uint64_t CodeAlign,
-             int64_t DataAlign, Triple::ArchType Arch)
-      : Kind(K), Offset(Offset), Length(Length),
+  FrameEntry(FrameKind K, bool IsDWARF64, uint64_t Offset, uint64_t Length,
+             uint64_t CodeAlign, int64_t DataAlign, Triple::ArchType Arch)
+      : Kind(K), IsDWARF64(IsDWARF64), Offset(Offset), Length(Length),
         CFIs(CodeAlign, DataAlign, Arch) {}
 
   virtual ~FrameEntry() {}
@@ -146,12 +147,14 @@
   CFIProgram &cfis() { return CFIs; }
 
   /// Dump the instructions in this CFI fragment
-  virtual void dump(raw_ostream &OS, const MCRegisterInfo *MRI,
-                    bool IsEH) const = 0;
+  virtual void dump(raw_ostream &OS, DIDumpOptions DumpOpts,
+                    const MCRegisterInfo *MRI, bool IsEH) const = 0;
 
 protected:
   const FrameKind Kind;
 
+  const bool IsDWARF64;
+
   /// Offset of this entry in the section.
   const uint64_t Offset;
 
@@ -166,14 +169,14 @@
 public:
   // CIEs (and FDEs) are simply container classes, so the only sensible way to
   // create them is by providing the full parsed contents in the constructor.
-  CIE(uint64_t Offset, uint64_t Length, uint8_t Version,
+  CIE(bool IsDWARF64, uint64_t Offset, uint64_t Length, uint8_t Version,
       SmallString<8> Augmentation, uint8_t AddressSize,
       uint8_t SegmentDescriptorSize, uint64_t CodeAlignmentFactor,
       int64_t DataAlignmentFactor, uint64_t ReturnAddressRegister,
       SmallString<8> AugmentationData, uint32_t FDEPointerEncoding,
       uint32_t LSDAPointerEncoding, Optional<uint64_t> Personality,
       Optional<uint32_t> PersonalityEnc, Triple::ArchType Arch)
-      : FrameEntry(FK_CIE, Offset, Length, CodeAlignmentFactor,
+      : FrameEntry(FK_CIE, IsDWARF64, Offset, Length, CodeAlignmentFactor,
                    DataAlignmentFactor, Arch),
         Version(Version), Augmentation(std::move(Augmentation)),
         AddressSize(AddressSize), SegmentDescriptorSize(SegmentDescriptorSize),
@@ -199,7 +202,7 @@
 
   uint32_t getLSDAPointerEncoding() const { return LSDAPointerEncoding; }
 
-  void dump(raw_ostream &OS, const MCRegisterInfo *MRI,
+  void dump(raw_ostream &OS, DIDumpOptions DumpOpts, const MCRegisterInfo *MRI,
             bool IsEH) const override;
 
 private:
@@ -223,17 +226,14 @@
 /// DWARF Frame Description Entry (FDE)
 class FDE : public FrameEntry {
 public:
-  // Each FDE has a CIE it's "linked to". Our FDE contains is constructed with
-  // an offset to the CIE (provided by parsing the FDE header). The CIE itself
-  // is obtained lazily once it's actually required.
-  FDE(uint64_t Offset, uint64_t Length, int64_t LinkedCIEOffset,
+  FDE(bool IsDWARF64, uint64_t Offset, uint64_t Length, uint64_t CIEPointer,
       uint64_t InitialLocation, uint64_t AddressRange, CIE *Cie,
       Optional<uint64_t> LSDAAddress, Triple::ArchType Arch)
-      : FrameEntry(FK_FDE, Offset, Length,
+      : FrameEntry(FK_FDE, IsDWARF64, Offset, Length,
                    Cie ? Cie->getCodeAlignmentFactor() : 0,
                    Cie ? Cie->getDataAlignmentFactor() : 0,
                    Arch),
-        LinkedCIEOffset(LinkedCIEOffset), InitialLocation(InitialLocation),
+        CIEPointer(CIEPointer), InitialLocation(InitialLocation),
         AddressRange(AddressRange), LinkedCIE(Cie), LSDAAddress(LSDAAddress) {}
 
   ~FDE() override = default;
@@ -243,14 +243,17 @@
   uint64_t getAddressRange() const { return AddressRange; }
   Optional<uint64_t> getLSDAAddress() const { return LSDAAddress; }
 
-  void dump(raw_ostream &OS, const MCRegisterInfo *MRI,
+  void dump(raw_ostream &OS, DIDumpOptions DumpOpts, const MCRegisterInfo *MRI,
             bool IsEH) const override;
 
   static bool classof(const FrameEntry *FE) { return FE->getKind() == FK_FDE; }
 
 private:
-  /// The following fields are defined in section 6.4.1 of the DWARF standard v3
-  const uint64_t LinkedCIEOffset;
+  /// The following fields are defined in section 6.4.1 of the DWARFv3 standard.
+  /// Note that CIE pointers in EH FDEs, unlike DWARF FDEs, contain relative
+  /// offsets to the linked CIEs. See the following link for more info:
+  /// https://refspecs.linuxfoundation.org/LSB_5.0.0/LSB-Core-generic/LSB-Core-generic/ehframechpt.html
+  const uint64_t CIEPointer;
   const uint64_t InitialLocation;
   const uint64_t AddressRange;
   const CIE *LinkedCIE;
@@ -283,12 +286,12 @@
   ~DWARFDebugFrame();
 
   /// Dump the section data into the given stream.
-  void dump(raw_ostream &OS, const MCRegisterInfo *MRI,
+  void dump(raw_ostream &OS, DIDumpOptions DumpOpts, const MCRegisterInfo *MRI,
             Optional<uint64_t> Offset) const;
 
   /// Parse the section from raw data. \p Data is assumed to contain the whole
   /// frame section contents to be parsed.
-  void parse(DWARFDataExtractor Data);
+  Error parse(DWARFDataExtractor Data);
 
   /// Return whether the section has any entries.
   bool empty() const { return Entries.empty(); }
diff --git a/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFDebugInfoEntry.h b/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFDebugInfoEntry.h
index f50063b..ded9603 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFDebugInfoEntry.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFDebugInfoEntry.h
@@ -22,7 +22,7 @@
 /// DWARFDebugInfoEntry - A DIE with only the minimum required data.
 class DWARFDebugInfoEntry {
   /// Offset within the .debug_info of the start of this entry.
-  uint32_t Offset = 0;
+  uint64_t Offset = 0;
 
   /// The integer depth of this DIE within the compile unit DIEs where the
   /// compile/type unit DIE has a depth of zero.
@@ -36,14 +36,14 @@
   /// Extracts a debug info entry, which is a child of a given unit,
   /// starting at a given offset. If DIE can't be extracted, returns false and
   /// doesn't change OffsetPtr.
-  bool extractFast(const DWARFUnit &U, uint32_t *OffsetPtr);
+  bool extractFast(const DWARFUnit &U, uint64_t *OffsetPtr);
 
   /// High performance extraction should use this call.
-  bool extractFast(const DWARFUnit &U, uint32_t *OffsetPtr,
-                   const DWARFDataExtractor &DebugInfoData, uint32_t UEndOffset,
+  bool extractFast(const DWARFUnit &U, uint64_t *OffsetPtr,
+                   const DWARFDataExtractor &DebugInfoData, uint64_t UEndOffset,
                    uint32_t Depth);
 
-  uint32_t getOffset() const { return Offset; }
+  uint64_t getOffset() const { return Offset; }
   uint32_t getDepth() const { return Depth; }
 
   dwarf::Tag getTag() const {
diff --git a/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFDebugLine.h b/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFDebugLine.h
index 9a3ad2b..bc6c67a 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFDebugLine.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFDebugLine.h
@@ -18,6 +18,7 @@
 #include "llvm/DebugInfo/DWARF/DWARFRelocMap.h"
 #include "llvm/DebugInfo/DWARF/DWARFTypeUnit.h"
 #include "llvm/Support/MD5.h"
+#include "llvm/Support/Path.h"
 #include <cstdint>
 #include <map>
 #include <string>
@@ -107,23 +108,31 @@
     bool totalLengthIsValid() const;
 
     /// Length of the prologue in bytes.
-    uint32_t getLength() const {
-      return PrologueLength + sizeofTotalLength() + sizeof(getVersion()) +
-             sizeofPrologueLength();
-    }
-
-    /// Length of the line table data in bytes (not including the prologue).
-    uint32_t getStatementTableLength() const {
-      return TotalLength + sizeofTotalLength() - getLength();
-    }
+    uint64_t getLength() const;
 
     int32_t getMaxLineIncrementForSpecialOpcode() const {
       return LineBase + (int8_t)LineRange - 1;
     }
 
+    /// Get DWARF-version aware access to the file name entry at the provided
+    /// index.
+    const llvm::DWARFDebugLine::FileNameEntry &
+    getFileNameEntry(uint64_t Index) const;
+
+    bool hasFileAtIndex(uint64_t FileIndex) const;
+
+    Optional<uint64_t> getLastValidFileIndex() const;
+
+    bool
+    getFileNameByIndex(uint64_t FileIndex, StringRef CompDir,
+                       DILineInfoSpecifier::FileLineInfoKind Kind,
+                       std::string &Result,
+                       sys::path::Style Style = sys::path::Style::native) const;
+
     void clear();
     void dump(raw_ostream &OS, DIDumpOptions DumpOptions) const;
-    Error parse(const DWARFDataExtractor &DebugLineData, uint32_t *OffsetPtr,
+    Error parse(DWARFDataExtractor Data, uint64_t *OffsetPtr,
+                function_ref<void(Error)> RecoverableErrorHandler,
                 const DWARFContext &Ctx, const DWARFUnit *U = nullptr);
   };
 
@@ -136,7 +145,7 @@
     void reset(bool DefaultIsStmt);
     void dump(raw_ostream &OS) const;
 
-    static void dumpTableHeader(raw_ostream &OS);
+    static void dumpTableHeader(raw_ostream &OS, unsigned Indent);
 
     static bool orderByAddress(const Row &LHS, const Row &RHS) {
       return std::tie(LHS.Address.SectionIndex, LHS.Address.Address) <
@@ -240,16 +249,24 @@
     bool lookupAddressRange(object::SectionedAddress Address, uint64_t Size,
                             std::vector<uint32_t> &Result) const;
 
-    bool hasFileAtIndex(uint64_t FileIndex) const;
+    bool hasFileAtIndex(uint64_t FileIndex) const {
+      return Prologue.hasFileAtIndex(FileIndex);
+    }
+
+    Optional<uint64_t> getLastValidFileIndex() const {
+      return Prologue.getLastValidFileIndex();
+    }
 
     /// Extracts filename by its index in filename table in prologue.
     /// In Dwarf 4, the files are 1-indexed and the current compilation file
     /// name is not represented in the list. In DWARF v5, the files are
     /// 0-indexed and the primary source file has the index 0.
     /// Returns true on success.
-    bool getFileNameByIndex(uint64_t FileIndex, const char *CompDir,
+    bool getFileNameByIndex(uint64_t FileIndex, StringRef CompDir,
                             DILineInfoSpecifier::FileLineInfoKind Kind,
-                            std::string &Result) const;
+                            std::string &Result) const {
+      return Prologue.getFileNameByIndex(FileIndex, CompDir, Kind, Result);
+    }
 
     /// Fills the Result argument with the file and line information
     /// corresponding to Address. Returns true on success.
@@ -262,16 +279,10 @@
     void clear();
 
     /// Parse prologue and all rows.
-    Error parse(
-        DWARFDataExtractor &DebugLineData, uint32_t *OffsetPtr,
-        const DWARFContext &Ctx, const DWARFUnit *U,
-        std::function<void(Error)> RecoverableErrorCallback,
-        raw_ostream *OS = nullptr);
-
-    /// Get DWARF-version aware access to the file name entry at the provided
-    /// index.
-    const llvm::DWARFDebugLine::FileNameEntry &
-        getFileNameEntry(uint64_t Index) const;
+    Error parse(DWARFDataExtractor &DebugLineData, uint64_t *OffsetPtr,
+                const DWARFContext &Ctx, const DWARFUnit *U,
+                function_ref<void(Error)> RecoverableErrorHandler,
+                raw_ostream *OS = nullptr, bool Verbose = false);
 
     using RowVector = std::vector<Row>;
     using RowIter = RowVector::const_iterator;
@@ -295,43 +306,44 @@
                                 std::vector<uint32_t> &Result) const;
   };
 
-  const LineTable *getLineTable(uint32_t Offset) const;
-  Expected<const LineTable *> getOrParseLineTable(
-      DWARFDataExtractor &DebugLineData, uint32_t Offset,
-      const DWARFContext &Ctx, const DWARFUnit *U,
-      std::function<void(Error)> RecoverableErrorCallback);
+  const LineTable *getLineTable(uint64_t Offset) const;
+  Expected<const LineTable *>
+  getOrParseLineTable(DWARFDataExtractor &DebugLineData, uint64_t Offset,
+                      const DWARFContext &Ctx, const DWARFUnit *U,
+                      function_ref<void(Error)> RecoverableErrorHandler);
 
   /// Helper to allow for parsing of an entire .debug_line section in sequence.
   class SectionParser {
   public:
-    using cu_range = DWARFUnitVector::iterator_range;
-    using tu_range = DWARFUnitVector::iterator_range;
     using LineToUnitMap = std::map<uint64_t, DWARFUnit *>;
 
-    SectionParser(DWARFDataExtractor &Data, const DWARFContext &C, cu_range CUs,
-                  tu_range TUs);
+    SectionParser(DWARFDataExtractor &Data, const DWARFContext &C,
+                  DWARFUnitVector::iterator_range Units);
 
     /// Get the next line table from the section. Report any issues via the
-    /// callbacks.
+    /// handlers.
     ///
-    /// \param RecoverableErrorCallback - any issues that don't prevent further
-    /// parsing of the table will be reported through this callback.
-    /// \param UnrecoverableErrorCallback - any issues that prevent further
-    /// parsing of the table will be reported through this callback.
+    /// \param RecoverableErrorHandler - any issues that don't prevent further
+    /// parsing of the table will be reported through this handler.
+    /// \param UnrecoverableErrorHandler - any issues that prevent further
+    /// parsing of the table will be reported through this handler.
     /// \param OS - if not null, the parser will print information about the
     /// table as it parses it.
-    LineTable
-    parseNext(
-        function_ref<void(Error)> RecoverableErrorCallback,
-        function_ref<void(Error)> UnrecoverableErrorCallback,
-        raw_ostream *OS = nullptr);
+    /// \param Verbose - if true, the parser will print verbose information when
+    /// printing to the output.
+    LineTable parseNext(function_ref<void(Error)> RecoverableErrorHandler,
+                        function_ref<void(Error)> UnrecoverableErrorHandler,
+                        raw_ostream *OS = nullptr, bool Verbose = false);
 
     /// Skip the current line table and go to the following line table (if
     /// present) immediately.
     ///
-    /// \param ErrorCallback - report any prologue parsing issues via this
-    /// callback.
-    void skip(function_ref<void(Error)> ErrorCallback);
+    /// \param RecoverableErrorHandler - report any recoverable prologue
+    /// parsing issues via this handler.
+    /// \param UnrecoverableErrorHandler - report any unrecoverable prologue
+    /// parsing issues via this handler.
+    void skip(function_ref<void(Error)> RecoverableErrorHandler,
+              function_ref<void(Error)> UnrecoverableErrorHandler);
 
     /// Indicates if the parser has parsed as much as possible.
     ///
@@ -340,34 +352,66 @@
     bool done() const { return Done; }
 
     /// Get the offset the parser has reached.
-    uint32_t getOffset() const { return Offset; }
+    uint64_t getOffset() const { return Offset; }
 
   private:
-    DWARFUnit *prepareToParse(uint32_t Offset);
-    void moveToNextTable(uint32_t OldOffset, const Prologue &P);
+    DWARFUnit *prepareToParse(uint64_t Offset);
+    void moveToNextTable(uint64_t OldOffset, const Prologue &P);
 
     LineToUnitMap LineToUnit;
 
     DWARFDataExtractor &DebugLineData;
     const DWARFContext &Context;
-    uint32_t Offset = 0;
+    uint64_t Offset = 0;
     bool Done = false;
   };
 
 private:
   struct ParsingState {
-    ParsingState(struct LineTable *LT);
+    ParsingState(struct LineTable *LT, uint64_t TableOffset,
+                 function_ref<void(Error)> ErrorHandler);
 
     void resetRowAndSequence();
     void appendRowToMatrix();
 
+    /// Advance the address by the \p OperationAdvance value. \returns the
+    /// amount advanced by.
+    uint64_t advanceAddr(uint64_t OperationAdvance, uint8_t Opcode,
+                         uint64_t OpcodeOffset);
+
+    struct AddrAndAdjustedOpcode {
+      uint64_t AddrDelta;
+      uint8_t AdjustedOpcode;
+    };
+
+    /// Advance the address as required by the specified \p Opcode.
+    /// \returns the amount advanced by and the calculated adjusted opcode.
+    AddrAndAdjustedOpcode advanceAddrForOpcode(uint8_t Opcode,
+                                               uint64_t OpcodeOffset);
+
+    struct AddrAndLineDelta {
+      uint64_t Address;
+      int32_t Line;
+    };
+
+    /// Advance the line and address as required by the specified special \p
+    /// Opcode. \returns the address and line delta.
+    AddrAndLineDelta handleSpecialOpcode(uint8_t Opcode, uint64_t OpcodeOffset);
+
     /// Line table we're currently parsing.
     struct LineTable *LineTable;
     struct Row Row;
     struct Sequence Sequence;
+
+  private:
+    uint64_t LineTableOffset;
+
+    bool ReportAdvanceAddrProblem = true;
+    bool ReportBadLineRange = true;
+    function_ref<void(Error)> ErrorHandler;
   };
 
-  using LineTableMapTy = std::map<uint32_t, LineTable>;
+  using LineTableMapTy = std::map<uint64_t, LineTable>;
   using LineTableIter = LineTableMapTy::iterator;
   using LineTableConstIter = LineTableMapTy::const_iterator;
 
diff --git a/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFDebugLoc.h b/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFDebugLoc.h
index cced604..dbc11c5 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFDebugLoc.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFDebugLoc.h
@@ -11,7 +11,9 @@
 
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallVector.h"
+#include "llvm/DebugInfo/DIContext.h"
 #include "llvm/DebugInfo/DWARF/DWARFDataExtractor.h"
+#include "llvm/DebugInfo/DWARF/DWARFLocationExpression.h"
 #include "llvm/DebugInfo/DWARF/DWARFRelocMap.h"
 #include <cstdint>
 
@@ -20,29 +22,75 @@
 class MCRegisterInfo;
 class raw_ostream;
 
-class DWARFDebugLoc {
-public:
-  /// A single location within a location list.
-  struct Entry {
-    /// The beginning address of the instruction range.
-    uint64_t Begin;
-    /// The ending address of the instruction range.
-    uint64_t End;
-    /// The location of the variable within the specified range.
-    SmallVector<char, 4> Loc;
-  };
+/// A single location within a location list. Entries are stored in the DWARF5
+/// form even if they originally come from a DWARF<=4 location list.
+struct DWARFLocationEntry {
+  /// The entry kind (DW_LLE_***).
+  uint8_t Kind;
 
+  /// The first value of the location entry (if applicable).
+  uint64_t Value0;
+
+  /// The second value of the location entry (if applicable).
+  uint64_t Value1;
+
+  /// The index of the section this entry is relative to (if applicable).
+  uint64_t SectionIndex;
+
+  /// The location expression itself (if applicable).
+  SmallVector<uint8_t, 4> Loc;
+};
+
+/// An abstract base class for various kinds of location tables (.debug_loc,
+/// .debug_loclists, and their dwo variants).
+class DWARFLocationTable {
+public:
+  DWARFLocationTable(DWARFDataExtractor Data) : Data(std::move(Data)) {}
+  virtual ~DWARFLocationTable() = default;
+
+  /// Call the user-provided callback for each entry (including the end-of-list
+  /// entry) in the location list starting at \p Offset. The callback can return
+  /// false to terminate the iteration early. Returns an error if it was unable
+  /// to parse the entire location list correctly. Upon successful termination
+  /// \p Offset will be updated point past the end of the list.
+  virtual Error visitLocationList(
+      uint64_t *Offset,
+      function_ref<bool(const DWARFLocationEntry &)> Callback) const = 0;
+
+  /// Dump the location list at the given \p Offset. The function returns true
+  /// iff it has successfully reched the end of the list. This means that one
+  /// can attempt to parse another list after the current one (\p Offset will be
+  /// updated to point past the end of the current list).
+  bool dumpLocationList(uint64_t *Offset, raw_ostream &OS,
+                        Optional<object::SectionedAddress> BaseAddr,
+                        const MCRegisterInfo *MRI, const DWARFObject &Obj,
+                        DWARFUnit *U, DIDumpOptions DumpOpts,
+                        unsigned Indent) const;
+
+  Error visitAbsoluteLocationList(
+      uint64_t Offset, Optional<object::SectionedAddress> BaseAddr,
+      std::function<Optional<object::SectionedAddress>(uint32_t)> LookupAddr,
+      function_ref<bool(Expected<DWARFLocationExpression>)> Callback) const;
+
+  const DWARFDataExtractor &getData() { return Data; }
+
+protected:
+  DWARFDataExtractor Data;
+
+  virtual void dumpRawEntry(const DWARFLocationEntry &Entry, raw_ostream &OS,
+                            unsigned Indent, DIDumpOptions DumpOpts,
+                            const DWARFObject &Obj) const = 0;
+};
+
+class DWARFDebugLoc final : public DWARFLocationTable {
+public:
   /// A list of locations that contain one variable.
   struct LocationList {
     /// The beginning offset where this location list is stored in the debug_loc
     /// section.
-    unsigned Offset;
+    uint64_t Offset;
     /// All the locations in which the variable is stored.
-    SmallVector<Entry, 2> Entries;
-    /// Dump this list on OS.
-    void dump(raw_ostream &OS, bool IsLittleEndian, unsigned AddressSize,
-              const MCRegisterInfo *MRI, DWARFUnit *U, uint64_t BaseAddress,
-              unsigned Indent) const;
+    SmallVector<DWARFLocationEntry, 2> Entries;
   };
 
 private:
@@ -52,62 +100,46 @@
   /// the locations in which the variable is stored.
   LocationLists Locations;
 
-  unsigned AddressSize;
-
-  bool IsLittleEndian;
-
 public:
+  DWARFDebugLoc(DWARFDataExtractor Data)
+      : DWARFLocationTable(std::move(Data)) {}
+
   /// Print the location lists found within the debug_loc section.
   void dump(raw_ostream &OS, const MCRegisterInfo *RegInfo,
+            const DWARFObject &Obj, DIDumpOptions DumpOpts,
             Optional<uint64_t> Offset) const;
 
-  /// Parse the debug_loc section accessible via the 'data' parameter using the
-  /// address size also given in 'data' to interpret the address ranges.
-  void parse(const DWARFDataExtractor &data);
+  Error visitLocationList(
+      uint64_t *Offset,
+      function_ref<bool(const DWARFLocationEntry &)> Callback) const override;
 
-  /// Return the location list at the given offset or nullptr.
-  LocationList const *getLocationListAtOffset(uint64_t Offset) const;
-
-  Optional<LocationList> parseOneLocationList(DWARFDataExtractor Data,
-                                              uint32_t *Offset);
+protected:
+  void dumpRawEntry(const DWARFLocationEntry &Entry, raw_ostream &OS,
+                    unsigned Indent, DIDumpOptions DumpOpts,
+                    const DWARFObject &Obj) const override;
 };
 
-class DWARFDebugLoclists {
+class DWARFDebugLoclists final : public DWARFLocationTable {
 public:
-  struct Entry {
-    uint8_t Kind;
-    uint64_t Value0;
-    uint64_t Value1;
-    SmallVector<char, 4> Loc;
-  };
+  DWARFDebugLoclists(DWARFDataExtractor Data, uint16_t Version)
+      : DWARFLocationTable(std::move(Data)), Version(Version) {}
 
-  struct LocationList {
-    unsigned Offset;
-    SmallVector<Entry, 2> Entries;
-    void dump(raw_ostream &OS, uint64_t BaseAddr, bool IsLittleEndian,
-              unsigned AddressSize, const MCRegisterInfo *RegInfo,
-              DWARFUnit *U, unsigned Indent) const;
-  };
+  Error visitLocationList(
+      uint64_t *Offset,
+      function_ref<bool(const DWARFLocationEntry &)> Callback) const override;
+
+  /// Dump all location lists within the given range.
+  void dumpRange(uint64_t StartOffset, uint64_t Size, raw_ostream &OS,
+                 const MCRegisterInfo *MRI, const DWARFObject &Obj,
+                 DIDumpOptions DumpOpts);
+
+protected:
+  void dumpRawEntry(const DWARFLocationEntry &Entry, raw_ostream &OS,
+                    unsigned Indent, DIDumpOptions DumpOpts,
+                    const DWARFObject &Obj) const override;
 
 private:
-  using LocationLists = SmallVector<LocationList, 4>;
-
-  LocationLists Locations;
-
-  unsigned AddressSize;
-
-  bool IsLittleEndian;
-
-public:
-  void parse(DataExtractor data, unsigned Version);
-  void dump(raw_ostream &OS, uint64_t BaseAddr, const MCRegisterInfo *RegInfo,
-            Optional<uint64_t> Offset) const;
-
-  /// Return the location list at the given offset or nullptr.
-  LocationList const *getLocationListAtOffset(uint64_t Offset) const;
-
-  static Optional<LocationList>
-  parseOneLocationList(DataExtractor Data, unsigned *Offset, unsigned Version);
+  uint16_t Version;
 };
 
 } // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFDebugMacro.h b/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFDebugMacro.h
index a6c1259..f1768a1 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFDebugMacro.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFDebugMacro.h
@@ -10,7 +10,10 @@
 #define LLVM_DEBUGINFO_DWARF_DWARFDEBUGMACRO_H
 
 #include "llvm/ADT/SmallVector.h"
-#include "llvm/Support/DataExtractor.h"
+#include "llvm/DebugInfo/DWARF/DWARFDataExtractor.h"
+#include "llvm/DebugInfo/DWARF/DWARFUnit.h"
+#include "llvm/Support/Errc.h"
+#include "llvm/Support/Error.h"
 #include <cstdint>
 
 namespace llvm {
@@ -18,6 +21,51 @@
 class raw_ostream;
 
 class DWARFDebugMacro {
+  /// DWARFv5 section 6.3.1 Macro Information Header.
+  enum HeaderFlagMask {
+#define HANDLE_MACRO_FLAG(ID, NAME) MACRO_##NAME = ID,
+#include "llvm/BinaryFormat/Dwarf.def"
+  };
+  struct MacroHeader {
+    /// Macro version information number.
+    uint16_t Version = 0;
+
+    /// The bits of the flags field are interpreted as a set of flags, some of
+    /// which may indicate that additional fields follow. The following flags,
+    /// beginning with the least significant bit, are defined:
+    /// offset_size_flag:
+    ///   If the offset_size_flag is zero, the header is for a 32-bit DWARF
+    ///   format macro section and all offsets are 4 bytes long; if it is one,
+    ///   the header is for a 64-bit DWARF format macro section and all offsets
+    ///   are 8 bytes long.
+    /// debug_line_offset_flag:
+    ///   If the debug_line_offset_flag is one, the debug_line_offset field (see
+    ///   below) is present. If zero, that field is omitted.
+    /// opcode_operands_table_flag:
+    ///   If the opcode_operands_table_flag is one, the opcode_operands_table
+    ///   field (see below) is present. If zero, that field is omitted.
+    uint8_t Flags = 0;
+
+    /// debug_line_offset
+    ///   An offset in the .debug_line section of the beginning of the line
+    ///   number information in the containing compilation unit, encoded as a
+    ///   4-byte offset for a 32-bit DWARF format macro section and an 8-byte
+    ///   offset for a 64-bit DWARF format macro section.
+    uint64_t DebugLineOffset;
+
+    /// Print the macro header from the debug_macro section.
+    void dumpMacroHeader(raw_ostream &OS) const;
+
+    /// Parse the debug_macro header.
+    Error parseMacroHeader(DWARFDataExtractor Data, uint64_t *Offset);
+
+    /// Get the DWARF format according to the flags.
+    dwarf::DwarfFormat getDwarfFormat() const;
+
+    /// Get the size of a reference according to the DWARF format.
+    uint8_t getOffsetByteSize() const;
+  };
+
   /// A single macro entry within a macro list.
   struct Entry {
     /// The type of the macro entry.
@@ -27,6 +75,8 @@
       uint64_t Line;
       /// Vendor extension constant value.
       uint64_t ExtConstant;
+      /// Macro unit import offset.
+      uint64_t ImportOffset;
     };
 
     union {
@@ -39,22 +89,46 @@
     };
   };
 
-  using MacroList = SmallVector<Entry, 4>;
+  struct MacroList {
+    // A value 0 in the `Header.Version` field indicates that we're parsing
+    // a macinfo[.dwo] section which doesn't have header itself, hence
+    // for that case other fields in the `Header` are uninitialized.
+    MacroHeader Header;
+    SmallVector<Entry, 4> Macros;
+    uint64_t Offset;
+
+    /// Whether or not this is a .debug_macro section.
+    bool IsDebugMacro;
+  };
 
   /// A list of all the macro entries in the debug_macinfo section.
-  MacroList Macros;
+  std::vector<MacroList> MacroLists;
 
 public:
   DWARFDebugMacro() = default;
 
-  /// Print the macro list found within the debug_macinfo section.
+  /// Print the macro list found within the debug_macinfo/debug_macro section.
   void dump(raw_ostream &OS) const;
 
-  /// Parse the debug_macinfo section accessible via the 'data' parameter.
-  void parse(DataExtractor data);
+  Error parseMacro(DWARFUnitVector::compile_unit_range Units,
+                   DataExtractor StringExtractor,
+                   DWARFDataExtractor MacroData) {
+    return parseImpl(Units, StringExtractor, MacroData, /*IsMacro=*/true);
+  }
+
+  Error parseMacinfo(DWARFDataExtractor MacroData) {
+    return parseImpl(None, None, MacroData, /*IsMacro=*/false);
+  }
 
   /// Return whether the section has any entries.
-  bool empty() const { return Macros.empty(); }
+  bool empty() const { return MacroLists.empty(); }
+
+private:
+  /// Parse the debug_macinfo/debug_macro section accessible via the 'MacroData'
+  /// parameter.
+  Error parseImpl(Optional<DWARFUnitVector::compile_unit_range> Units,
+                  Optional<DataExtractor> StringExtractor,
+                  DWARFDataExtractor Data, bool IsMacro);
 };
 
 } // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFDebugPubTable.h b/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFDebugPubTable.h
index 99e91ca..cb34761 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFDebugPubTable.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFDebugPubTable.h
@@ -12,6 +12,7 @@
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/BinaryFormat/Dwarf.h"
+#include "llvm/DebugInfo/DWARF/DWARFDataExtractor.h"
 #include "llvm/DebugInfo/DWARF/DWARFObject.h"
 #include <cstdint>
 #include <vector>
@@ -25,7 +26,7 @@
 public:
   struct Entry {
     /// Section offset from the beginning of the compilation unit.
-    uint32_t SecOffset;
+    uint64_t SecOffset;
 
     /// An entry of the various gnu_pub* debug sections.
     dwarf::PubIndexEntryDescriptor Descriptor;
@@ -42,7 +43,10 @@
   struct Set {
     /// The total length of the entries for that set, not including the length
     /// field itself.
-    uint32_t Length;
+    uint64_t Length;
+
+    /// The DWARF format of the set.
+    dwarf::DwarfFormat Format;
 
     /// This number is specific to the name lookup table and is independent of
     /// the DWARF version number.
@@ -50,11 +54,11 @@
 
     /// The offset from the beginning of the .debug_info section of the
     /// compilation unit header referenced by the set.
-    uint32_t Offset;
+    uint64_t Offset;
 
     /// The size in bytes of the contents of the .debug_info section generated
     /// to represent that compilation unit.
-    uint32_t Size;
+    uint64_t Size;
 
     std::vector<Entry> Entries;
   };
@@ -64,11 +68,13 @@
 
   /// gnu styled tables contains additional information.
   /// This flag determines whether or not section we parse is debug_gnu* table.
-  bool GnuStyle;
+  bool GnuStyle = false;
 
 public:
-  DWARFDebugPubTable(const DWARFObject &Obj, const DWARFSection &Sec,
-                     bool LittleEndian, bool GnuStyle);
+  DWARFDebugPubTable() = default;
+
+  void extract(DWARFDataExtractor Data, bool GnuStyle,
+               function_ref<void(Error)> RecoverableErrorHandler);
 
   void dump(raw_ostream &OS) const;
 
diff --git a/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFDebugRangeList.h b/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFDebugRangeList.h
index a66f602..2f72c64 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFDebugRangeList.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFDebugRangeList.h
@@ -53,14 +53,13 @@
       assert(AddressSize == 4 || AddressSize == 8);
       if (AddressSize == 4)
         return StartAddress == -1U;
-      else
-        return StartAddress == -1ULL;
+      return StartAddress == -1ULL;
     }
   };
 
 private:
   /// Offset in .debug_ranges section.
-  uint32_t Offset;
+  uint64_t Offset;
   uint8_t AddressSize;
   std::vector<RangeListEntry> Entries;
 
@@ -69,7 +68,7 @@
 
   void clear();
   void dump(raw_ostream &OS) const;
-  Error extract(const DWARFDataExtractor &data, uint32_t *offset_ptr);
+  Error extract(const DWARFDataExtractor &data, uint64_t *offset_ptr);
   const std::vector<RangeListEntry> &getEntries() { return Entries; }
 
   /// getAbsoluteRanges - Returns absolute address ranges defined by this range
diff --git a/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFDebugRnglists.h b/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFDebugRnglists.h
index 167ddde..4d28bdc 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFDebugRnglists.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFDebugRnglists.h
@@ -34,7 +34,7 @@
   uint64_t Value0;
   uint64_t Value1;
 
-  Error extract(DWARFDataExtractor Data, uint32_t End, uint32_t *OffsetPtr);
+  Error extract(DWARFDataExtractor Data, uint64_t *OffsetPtr);
   void dump(raw_ostream &OS, uint8_t AddrSize, uint8_t MaxEncodingStringLength,
             uint64_t &CurrentBase, DIDumpOptions DumpOpts,
             llvm::function_ref<Optional<object::SectionedAddress>(uint32_t)>
@@ -47,6 +47,13 @@
 public:
   /// Build a DWARFAddressRangesVector from a rangelist.
   DWARFAddressRangesVector
+  getAbsoluteRanges(Optional<object::SectionedAddress> BaseAddr,
+                    uint8_t AddressByteSize,
+                    function_ref<Optional<object::SectionedAddress>(uint32_t)>
+                        LookupPooledAddress) const;
+
+  /// Build a DWARFAddressRangesVector from a rangelist.
+  DWARFAddressRangesVector
   getAbsoluteRanges(llvm::Optional<object::SectionedAddress> BaseAddr,
                     DWARFUnit &U) const;
 };
diff --git a/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFDie.h b/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFDie.h
index 21e68f9..0f76d7f 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFDie.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFDie.h
@@ -18,6 +18,7 @@
 #include "llvm/DebugInfo/DWARF/DWARFAddressRange.h"
 #include "llvm/DebugInfo/DWARF/DWARFAttribute.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugInfoEntry.h"
+#include "llvm/DebugInfo/DWARF/DWARFDebugLoc.h"
 #include <cassert>
 #include <cstdint>
 #include <iterator>
@@ -63,7 +64,7 @@
   /// Get the absolute offset into the debug info or types section.
   ///
   /// \returns the DIE offset or -1U if invalid.
-  uint32_t getOffset() const {
+  uint64_t getOffset() const {
     assert(isValid() && "must check validity prior to calling");
     return Die->getOffset();
   }
@@ -188,6 +189,7 @@
   ///
   /// \returns anm optional absolute section offset value for the attribute.
   Optional<uint64_t> getRangesBaseAttribute() const;
+  Optional<uint64_t> getLocBaseAttribute() const;
 
   /// Get the DW_AT_high_pc attribute value as an address.
   ///
@@ -230,21 +232,37 @@
 
   bool addressRangeContainsAddress(const uint64_t Address) const;
 
+  Expected<DWARFLocationExpressionsVector>
+  getLocations(dwarf::Attribute Attr) const;
+
   /// If a DIE represents a subprogram (or inlined subroutine), returns its
   /// mangled name (or short name, if mangled is missing). This name may be
   /// fetched from specification or abstract origin for this subprogram.
   /// Returns null if no name is found.
   const char *getSubroutineName(DINameKind Kind) const;
 
-  /// Return the DIE name resolving DW_AT_sepcification or DW_AT_abstract_origin
-  /// references if necessary. Returns null if no name is found.
+  /// Return the DIE name resolving DW_AT_specification or DW_AT_abstract_origin
+  /// references if necessary. For the LinkageName case it additionaly searches
+  /// for ShortName if LinkageName is not found.
+  /// Returns null if no name is found.
   const char *getName(DINameKind Kind) const;
 
+  /// Return the DIE short name resolving DW_AT_specification or
+  /// DW_AT_abstract_origin references if necessary. Returns null if no name
+  /// is found.
+  const char *getShortName() const;
+
+  /// Return the DIE linkage name resolving DW_AT_specification or
+  /// DW_AT_abstract_origin references if necessary. Returns null if no name
+  /// is found.
+  const char *getLinkageName() const;
+
   /// Returns the declaration line (start line) for a DIE, assuming it specifies
   /// a subprogram. This may be fetched from specification or abstract origin
   /// for this subprogram by resolving DW_AT_sepcification or
   /// DW_AT_abstract_origin references if necessary.
   uint64_t getDeclLine() const;
+  std::string getDeclFile(DILineInfoSpecifier::FileLineInfoKind Kind) const;
 
   /// Retrieves values of DW_AT_call_file, DW_AT_call_line and DW_AT_call_column
   /// from DIE (or zeroes if they are missing). This function looks for
@@ -364,11 +382,6 @@
   return LHS.Die == RHS.Die;
 }
 
-inline bool operator!=(const DWARFDie::iterator &LHS,
-                       const DWARFDie::iterator &RHS) {
-  return !(LHS == RHS);
-}
-
 // These inline functions must follow the DWARFDie::iterator definition above
 // as they use functions from that class.
 inline DWARFDie::iterator DWARFDie::begin() const {
diff --git a/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFExpression.h b/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFExpression.h
index f066dd5..447ad66 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFExpression.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFExpression.h
@@ -10,8 +10,11 @@
 #define LLVM_DEBUGINFO_DWARFEXPRESSION_H
 
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/iterator.h"
 #include "llvm/ADT/iterator_range.h"
+#include "llvm/BinaryFormat/Dwarf.h"
+#include "llvm/DebugInfo/DIContext.h"
 #include "llvm/Support/DataExtractor.h"
 
 namespace llvm {
@@ -42,6 +45,7 @@
       SizeRefAddr = 6,
       SizeBlock = 7, ///< Preceding operand contains block size
       BaseTypeRef = 8,
+      WasmLocationArg = 30,
       SignBit = 0x80,
       SignedSize1 = SignBit | Size1,
       SignedSize2 = SignBit | Size2,
@@ -77,21 +81,22 @@
     uint8_t Opcode; ///< The Op Opcode, DW_OP_<something>.
     Description Desc;
     bool Error;
-    uint32_t EndOffset;
+    uint64_t EndOffset;
     uint64_t Operands[2];
-    uint32_t OperandEndOffsets[2];
+    uint64_t OperandEndOffsets[2];
 
   public:
     Description &getDescription() { return Desc; }
     uint8_t getCode() { return Opcode; }
     uint64_t getRawOperand(unsigned Idx) { return Operands[Idx]; }
-    uint32_t getOperandEndOffset(unsigned Idx) { return OperandEndOffsets[Idx]; }
-    uint32_t getEndOffset() { return EndOffset; }
-    bool extract(DataExtractor Data, uint16_t Version, uint8_t AddressSize,
-                 uint32_t Offset);
+    uint64_t getOperandEndOffset(unsigned Idx) { return OperandEndOffsets[Idx]; }
+    uint64_t getEndOffset() { return EndOffset; }
+    bool extract(DataExtractor Data, uint8_t AddressSize, uint64_t Offset,
+                 Optional<dwarf::DwarfFormat> Format);
     bool isError() { return Error; }
-    bool print(raw_ostream &OS, const DWARFExpression *Expr,
-               const MCRegisterInfo *RegInfo, DWARFUnit *U, bool isEH);
+    bool print(raw_ostream &OS, DIDumpOptions DumpOpts,
+               const DWARFExpression *Expr, const MCRegisterInfo *RegInfo,
+               DWARFUnit *U, bool isEH);
     bool verify(DWARFUnit *U);
   };
 
@@ -101,13 +106,13 @@
                                     Operation> {
     friend class DWARFExpression;
     const DWARFExpression *Expr;
-    uint32_t Offset;
+    uint64_t Offset;
     Operation Op;
-    iterator(const DWARFExpression *Expr, uint32_t Offset)
+    iterator(const DWARFExpression *Expr, uint64_t Offset)
         : Expr(Expr), Offset(Offset) {
       Op.Error =
           Offset >= Expr->Data.getData().size() ||
-          !Op.extract(Expr->Data, Expr->Version, Expr->AddressSize, Offset);
+          !Op.extract(Expr->Data, Expr->AddressSize, Offset, Expr->Format);
     }
 
   public:
@@ -115,7 +120,7 @@
       Offset = Op.isError() ? Expr->Data.getData().size() : Op.EndOffset;
       Op.Error =
           Offset >= Expr->Data.getData().size() ||
-          !Op.extract(Expr->Data, Expr->Version, Expr->AddressSize, Offset);
+          !Op.extract(Expr->Data, Expr->AddressSize, Offset, Expr->Format);
       return Op;
     }
 
@@ -123,37 +128,44 @@
       return Op;
     }
 
+    iterator skipBytes(uint64_t Add) {
+      return iterator(Expr, Op.EndOffset + Add);
+    }
+
     // Comparison operators are provided out of line.
     friend bool operator==(const iterator &, const iterator &);
   };
 
-  DWARFExpression(DataExtractor Data, uint16_t Version, uint8_t AddressSize)
-      : Data(Data), Version(Version), AddressSize(AddressSize) {
+  DWARFExpression(DataExtractor Data, uint8_t AddressSize,
+                  Optional<dwarf::DwarfFormat> Format = None)
+      : Data(Data), AddressSize(AddressSize), Format(Format) {
     assert(AddressSize == 8 || AddressSize == 4 || AddressSize == 2);
   }
 
   iterator begin() const { return iterator(this, 0); }
   iterator end() const { return iterator(this, Data.getData().size()); }
 
-  void print(raw_ostream &OS, const MCRegisterInfo *RegInfo, DWARFUnit *U,
+  void print(raw_ostream &OS, DIDumpOptions DumpOpts,
+             const MCRegisterInfo *RegInfo, DWARFUnit *U,
              bool IsEH = false) const;
 
+  /// Print the expression in a format intended to be compact and useful to a
+  /// user, but not perfectly unambiguous, or capable of representing every
+  /// valid DWARF expression. Returns true if the expression was sucessfully
+  /// printed.
+  bool printCompact(raw_ostream &OS, const MCRegisterInfo &RegInfo);
+
   bool verify(DWARFUnit *U);
 
 private:
   DataExtractor Data;
-  uint16_t Version;
   uint8_t AddressSize;
+  Optional<dwarf::DwarfFormat> Format;
 };
 
 inline bool operator==(const DWARFExpression::iterator &LHS,
                        const DWARFExpression::iterator &RHS) {
   return LHS.Expr == RHS.Expr && LHS.Offset == RHS.Offset;
 }
-
-inline bool operator!=(const DWARFExpression::iterator &LHS,
-                       const DWARFExpression::iterator &RHS) {
-  return !(LHS == RHS);
-}
 }
 #endif
diff --git a/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFFormValue.h b/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFFormValue.h
index 731e71e..1342e64 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFFormValue.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFFormValue.h
@@ -55,6 +55,8 @@
   };
 
   dwarf::Form Form;             /// Form for this value.
+  dwarf::DwarfFormat Format =
+      dwarf::DWARF32;           /// Remember the DWARF format at extract time.
   ValueType Value;              /// Contains all data for the form.
   const DWARFUnit *U = nullptr; /// Remember the DWARFUnit at extract time.
   const DWARFContext *C = nullptr; /// Context for extract time.
@@ -70,7 +72,7 @@
   static DWARFFormValue createFromBlockValue(dwarf::Form F,
                                              ArrayRef<uint8_t> D);
   static DWARFFormValue createFromUnit(dwarf::Form F, const DWARFUnit *Unit,
-                                       uint32_t *OffsetPtr);
+                                       uint64_t *OffsetPtr);
 
   dwarf::Form getForm() const { return Form; }
   uint64_t getRawUValue() const { return Value.uval; }
@@ -80,6 +82,9 @@
   void dump(raw_ostream &OS, DIDumpOptions DumpOpts = DIDumpOptions()) const;
   void dumpSectionedAddress(raw_ostream &OS, DIDumpOptions DumpOpts,
                             object::SectionedAddress SA) const;
+  void dumpAddress(raw_ostream &OS, uint64_t Address) const;
+  static void dumpAddress(raw_ostream &OS, uint8_t AddressSize,
+                          uint64_t Address);
   static void dumpAddressSection(const DWARFObject &Obj, raw_ostream &OS,
                                  DIDumpOptions DumpOpts, uint64_t SectionIndex);
 
@@ -87,12 +92,12 @@
   /// in \p FormParams is needed to interpret some forms. The optional
   /// \p Context and \p Unit allows extracting information if the form refers
   /// to other sections (e.g., .debug_str).
-  bool extractValue(const DWARFDataExtractor &Data, uint32_t *OffsetPtr,
+  bool extractValue(const DWARFDataExtractor &Data, uint64_t *OffsetPtr,
                     dwarf::FormParams FormParams,
                     const DWARFContext *Context = nullptr,
                     const DWARFUnit *Unit = nullptr);
 
-  bool extractValue(const DWARFDataExtractor &Data, uint32_t *OffsetPtr,
+  bool extractValue(const DWARFDataExtractor &Data, uint64_t *OffsetPtr,
                     dwarf::FormParams FormParams, const DWARFUnit *U) {
     return extractValue(Data, OffsetPtr, FormParams, nullptr, U);
   }
@@ -128,7 +133,7 @@
   /// \param OffsetPtr A reference to the offset that will be updated.
   /// \param Params DWARF parameters to help interpret forms.
   /// \returns true on success, false if the form was not skipped.
-  bool skipValue(DataExtractor DebugInfoData, uint32_t *OffsetPtr,
+  bool skipValue(DataExtractor DebugInfoData, uint64_t *OffsetPtr,
                  const dwarf::FormParams Params) const {
     return DWARFFormValue::skipValue(Form, DebugInfoData, OffsetPtr, Params);
   }
@@ -144,7 +149,7 @@
   /// \param FormParams DWARF parameters to help interpret forms.
   /// \returns true on success, false if the form was not skipped.
   static bool skipValue(dwarf::Form Form, DataExtractor DebugInfoData,
-                        uint32_t *OffsetPtr,
+                        uint64_t *OffsetPtr,
                         const dwarf::FormParams FormParams);
 
 private:
diff --git a/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFListTable.h b/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFListTable.h
index a1ea69b..8f58b4e 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFListTable.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFListTable.h
@@ -26,7 +26,7 @@
 /// entries.
 struct DWARFListEntryBase {
   /// The offset at which the entry is located in the section.
-  uint32_t Offset;
+  uint64_t Offset;
   /// The DWARF encoding (DW_RLE_* or DW_LLE_*).
   uint8_t EntryKind;
   /// The index of the section this entry belongs to.
@@ -46,8 +46,8 @@
   const ListEntries &getEntries() const { return Entries; }
   bool empty() const { return Entries.empty(); }
   void clear() { Entries.clear(); }
-  Error extract(DWARFDataExtractor Data, uint32_t HeaderOffset, uint32_t End,
-                uint32_t *OffsetPtr, StringRef SectionName,
+  Error extract(DWARFDataExtractor Data, uint64_t HeaderOffset,
+                uint64_t *OffsetPtr, StringRef SectionName,
                 StringRef ListStringName);
 };
 
@@ -57,7 +57,7 @@
   struct Header {
     /// The total length of the entries for this table, not including the length
     /// field itself.
-    uint32_t Length = 0;
+    uint64_t Length = 0;
     /// The DWARF version number.
     uint16_t Version;
     /// The size in bytes of an address on the target architecture. For
@@ -72,15 +72,11 @@
   };
 
   Header HeaderData;
-  /// The offset table, which contains offsets to the individual list entries.
-  /// It is used by forms such as DW_FORM_rnglistx.
-  /// FIXME: Generate the table and use the appropriate forms.
-  std::vector<uint32_t> Offsets;
   /// The table's format, either DWARF32 or DWARF64.
   dwarf::DwarfFormat Format;
   /// The offset at which the header (and hence the table) is located within
   /// its section.
-  uint32_t HeaderOffset;
+  uint64_t HeaderOffset;
   /// The name of the section the list is located in.
   StringRef SectionName;
   /// A characterization of the list for dumping purposes, e.g. "range" or
@@ -93,30 +89,53 @@
 
   void clear() {
     HeaderData = {};
-    Offsets.clear();
   }
-  uint32_t getHeaderOffset() const { return HeaderOffset; }
+  uint64_t getHeaderOffset() const { return HeaderOffset; }
   uint8_t getAddrSize() const { return HeaderData.AddrSize; }
-  uint32_t getLength() const { return HeaderData.Length; }
+  uint64_t getLength() const { return HeaderData.Length; }
   uint16_t getVersion() const { return HeaderData.Version; }
   StringRef getSectionName() const { return SectionName; }
   StringRef getListTypeString() const { return ListTypeString; }
   dwarf::DwarfFormat getFormat() const { return Format; }
 
-  void dump(raw_ostream &OS, DIDumpOptions DumpOpts = {}) const;
-  Optional<uint32_t> getOffsetEntry(uint32_t Index) const {
-    if (Index < Offsets.size())
-      return Offsets[Index];
-    return None;
+  /// Return the size of the table header including the length but not including
+  /// the offsets.
+  static uint8_t getHeaderSize(dwarf::DwarfFormat Format) {
+    switch (Format) {
+    case dwarf::DwarfFormat::DWARF32:
+      return 12;
+    case dwarf::DwarfFormat::DWARF64:
+      return 20;
+    }
+    llvm_unreachable("Invalid DWARF format (expected DWARF32 or DWARF64");
+  }
+
+  void dump(DataExtractor Data, raw_ostream &OS,
+            DIDumpOptions DumpOpts = {}) const;
+  Optional<uint64_t> getOffsetEntry(DataExtractor Data, uint32_t Index) const {
+    if (Index > HeaderData.OffsetEntryCount)
+      return None;
+
+    return getOffsetEntry(Data, getHeaderOffset() + getHeaderSize(Format), Format, Index);
+  }
+
+  static Optional<uint64_t> getOffsetEntry(DataExtractor Data,
+                                           uint64_t OffsetTableOffset,
+                                           dwarf::DwarfFormat Format,
+                                           uint32_t Index) {
+    uint8_t OffsetByteSize = Format == dwarf::DWARF64 ? 8 : 4;
+    uint64_t Offset = OffsetTableOffset + OffsetByteSize * Index;
+    auto R = Data.getUnsigned(&Offset, OffsetByteSize);
+    return R;
   }
 
   /// Extract the table header and the array of offsets.
-  Error extract(DWARFDataExtractor Data, uint32_t *OffsetPtr);
+  Error extract(DWARFDataExtractor Data, uint64_t *OffsetPtr);
 
   /// Returns the length of the table, including the length field, or 0 if the
   /// length has not been determined (e.g. because the table has not yet been
   /// parsed, or there was a problem in parsing).
-  uint32_t length() const;
+  uint64_t length() const;
 };
 
 /// A class representing a table of lists as specified in the DWARF v5
@@ -128,7 +147,7 @@
   DWARFListTableHeader Header;
   /// A mapping between file offsets and lists. It is used to find a particular
   /// list based on an offset (obtained from DW_AT_ranges, for example).
-  std::map<uint32_t, DWARFListType> ListMap;
+  std::map<uint64_t, DWARFListType> ListMap;
   /// This string is displayed as a heading before the list is dumped
   /// (e.g. "ranges:").
   StringRef HeaderString;
@@ -144,63 +163,58 @@
     ListMap.clear();
   }
   /// Extract the table header and the array of offsets.
-  Error extractHeaderAndOffsets(DWARFDataExtractor Data, uint32_t *OffsetPtr) {
+  Error extractHeaderAndOffsets(DWARFDataExtractor Data, uint64_t *OffsetPtr) {
     return Header.extract(Data, OffsetPtr);
   }
   /// Extract an entire table, including all list entries.
-  Error extract(DWARFDataExtractor Data, uint32_t *OffsetPtr);
+  Error extract(DWARFDataExtractor Data, uint64_t *OffsetPtr);
   /// Look up a list based on a given offset. Extract it and enter it into the
   /// list map if necessary.
-  Expected<DWARFListType> findList(DWARFDataExtractor Data, uint32_t Offset);
+  Expected<DWARFListType> findList(DWARFDataExtractor Data, uint64_t Offset);
 
-  uint32_t getHeaderOffset() const { return Header.getHeaderOffset(); }
+  uint64_t getHeaderOffset() const { return Header.getHeaderOffset(); }
   uint8_t getAddrSize() const { return Header.getAddrSize(); }
+  dwarf::DwarfFormat getFormat() const { return Header.getFormat(); }
 
-  void dump(raw_ostream &OS,
+  void dump(DWARFDataExtractor Data, raw_ostream &OS,
             llvm::function_ref<Optional<object::SectionedAddress>(uint32_t)>
                 LookupPooledAddress,
             DIDumpOptions DumpOpts = {}) const;
 
   /// Return the contents of the offset entry designated by a given index.
-  Optional<uint32_t> getOffsetEntry(uint32_t Index) const {
-    return Header.getOffsetEntry(Index);
+  Optional<uint64_t> getOffsetEntry(DataExtractor Data, uint32_t Index) const {
+    return Header.getOffsetEntry(Data, Index);
   }
   /// Return the size of the table header including the length but not including
   /// the offsets. This is dependent on the table format, which is unambiguously
   /// derived from parsing the table.
   uint8_t getHeaderSize() const {
-    switch (Header.getFormat()) {
-    case dwarf::DwarfFormat::DWARF32:
-      return 12;
-    case dwarf::DwarfFormat::DWARF64:
-      return 20;
-    }
-    llvm_unreachable("Invalid DWARF format (expected DWARF32 or DWARF64");
+    return DWARFListTableHeader::getHeaderSize(getFormat());
   }
 
-  uint32_t length() { return Header.length(); }
+  uint64_t length() { return Header.length(); }
 };
 
 template <typename DWARFListType>
 Error DWARFListTableBase<DWARFListType>::extract(DWARFDataExtractor Data,
-                                                 uint32_t *OffsetPtr) {
+                                                 uint64_t *OffsetPtr) {
   clear();
   if (Error E = extractHeaderAndOffsets(Data, OffsetPtr))
     return E;
 
   Data.setAddressSize(Header.getAddrSize());
-  uint32_t End = getHeaderOffset() + Header.length();
-  while (*OffsetPtr < End) {
+  Data = DWARFDataExtractor(Data, getHeaderOffset() + Header.length());
+  while (Data.isValidOffset(*OffsetPtr)) {
     DWARFListType CurrentList;
-    uint32_t Off = *OffsetPtr;
-    if (Error E = CurrentList.extract(Data, getHeaderOffset(), End, OffsetPtr,
+    uint64_t Off = *OffsetPtr;
+    if (Error E = CurrentList.extract(Data, getHeaderOffset(), OffsetPtr,
                                       Header.getSectionName(),
                                       Header.getListTypeString()))
       return E;
     ListMap[Off] = CurrentList;
   }
 
-  assert(*OffsetPtr == End &&
+  assert(*OffsetPtr == Data.size() &&
          "mismatch between expected length of table and length "
          "of extracted data");
   return Error::success();
@@ -208,18 +222,18 @@
 
 template <typename ListEntryType>
 Error DWARFListType<ListEntryType>::extract(DWARFDataExtractor Data,
-                                            uint32_t HeaderOffset, uint32_t End,
-                                            uint32_t *OffsetPtr,
+                                            uint64_t HeaderOffset,
+                                            uint64_t *OffsetPtr,
                                             StringRef SectionName,
                                             StringRef ListTypeString) {
-  if (*OffsetPtr < HeaderOffset || *OffsetPtr >= End)
+  if (*OffsetPtr < HeaderOffset || *OffsetPtr >= Data.size())
     return createStringError(errc::invalid_argument,
-                       "invalid %s list offset 0x%" PRIx32,
+                       "invalid %s list offset 0x%" PRIx64,
                        ListTypeString.data(), *OffsetPtr);
   Entries.clear();
-  while (*OffsetPtr < End) {
+  while (Data.isValidOffset(*OffsetPtr)) {
     ListEntryType Entry;
-    if (Error E = Entry.extract(Data, End, OffsetPtr))
+    if (Error E = Entry.extract(Data, OffsetPtr))
       return E;
     Entries.push_back(Entry);
     if (Entry.isSentinel())
@@ -227,17 +241,17 @@
   }
   return createStringError(errc::illegal_byte_sequence,
                      "no end of list marker detected at end of %s table "
-                     "starting at offset 0x%" PRIx32,
+                     "starting at offset 0x%" PRIx64,
                      SectionName.data(), HeaderOffset);
 }
 
 template <typename DWARFListType>
 void DWARFListTableBase<DWARFListType>::dump(
-    raw_ostream &OS,
+    DWARFDataExtractor Data, raw_ostream &OS,
     llvm::function_ref<Optional<object::SectionedAddress>(uint32_t)>
         LookupPooledAddress,
     DIDumpOptions DumpOpts) const {
-  Header.dump(OS, DumpOpts);
+  Header.dump(Data, OS, DumpOpts);
   OS << HeaderString << "\n";
 
   // Determine the length of the longest encoding string we have in the table,
@@ -261,20 +275,15 @@
 template <typename DWARFListType>
 Expected<DWARFListType>
 DWARFListTableBase<DWARFListType>::findList(DWARFDataExtractor Data,
-                                            uint32_t Offset) {
-  auto Entry = ListMap.find(Offset);
-  if (Entry != ListMap.end())
-    return Entry->second;
-
+                                            uint64_t Offset) {
   // Extract the list from the section and enter it into the list map.
   DWARFListType List;
-  uint32_t End = getHeaderOffset() + Header.length();
-  uint32_t StartingOffset = Offset;
+  if (Header.length())
+    Data = DWARFDataExtractor(Data, getHeaderOffset() + Header.length());
   if (Error E =
-          List.extract(Data, getHeaderOffset(), End, &Offset,
+          List.extract(Data, Header.length() ? getHeaderOffset() : 0, &Offset,
                        Header.getSectionName(), Header.getListTypeString()))
     return std::move(E);
-  ListMap[StartingOffset] = List;
   return List;
 }
 
diff --git a/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFLocationExpression.h b/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFLocationExpression.h
new file mode 100644
index 0000000..35aa1a7
--- /dev/null
+++ b/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFLocationExpression.h
@@ -0,0 +1,49 @@
+//===- DWARFLocationExpression.h --------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_DEBUGINFO_DWARF_DWARFLOCATIONEXPRESSION_H
+#define LLVM_DEBUGINFO_DWARF_DWARFLOCATIONEXPRESSION_H
+
+#include "llvm/ADT/Optional.h"
+#include "llvm/DebugInfo/DWARF/DWARFAddressRange.h"
+
+namespace llvm {
+
+class raw_ostream;
+
+/// Represents a single DWARF expression, whose value is location-dependent.
+/// Typically used in DW_AT_location attributes to describe the location of
+/// objects.
+struct DWARFLocationExpression {
+  /// The address range in which this expression is valid. None denotes a
+  /// default entry which is valid in addresses not covered by other location
+  /// expressions, or everywhere if there are no other expressions.
+  Optional<DWARFAddressRange> Range;
+
+  /// The expression itself.
+  SmallVector<uint8_t, 4> Expr;
+};
+
+inline bool operator==(const DWARFLocationExpression &L,
+                       const DWARFLocationExpression &R) {
+  return L.Range == R.Range && L.Expr == R.Expr;
+}
+
+inline bool operator!=(const DWARFLocationExpression &L,
+                       const DWARFLocationExpression &R) {
+  return !(L == R);
+}
+
+raw_ostream &operator<<(raw_ostream &OS, const DWARFLocationExpression &Loc);
+
+/// Represents a set of absolute location expressions.
+using DWARFLocationExpressionsVector = std::vector<DWARFLocationExpression>;
+
+} // end namespace llvm
+
+#endif // LLVM_DEBUGINFO_DWARF_DWARFLOCATIONEXPRESSION_H
diff --git a/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFObject.h b/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFObject.h
index 1bba74a..60fcd3d 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFObject.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFObject.h
@@ -39,20 +39,23 @@
   virtual StringRef getAbbrevSection() const { return ""; }
   virtual const DWARFSection &getLocSection() const { return Dummy; }
   virtual const DWARFSection &getLoclistsSection() const { return Dummy; }
-  virtual StringRef getARangeSection() const { return ""; }
-  virtual StringRef getDebugFrameSection() const { return ""; }
-  virtual StringRef getEHFrameSection() const { return ""; }
+  virtual StringRef getArangesSection() const { return ""; }
+  virtual const DWARFSection &getFrameSection() const { return Dummy; }
+  virtual const DWARFSection &getEHFrameSection() const { return Dummy; }
   virtual const DWARFSection &getLineSection() const { return Dummy; }
-  virtual StringRef getLineStringSection() const { return ""; }
-  virtual StringRef getStringSection() const { return ""; }
-  virtual const DWARFSection &getRangeSection() const { return Dummy; }
+  virtual StringRef getLineStrSection() const { return ""; }
+  virtual StringRef getStrSection() const { return ""; }
+  virtual const DWARFSection &getRangesSection() const { return Dummy; }
   virtual const DWARFSection &getRnglistsSection() const { return Dummy; }
+  virtual const DWARFSection &getMacroSection() const { return Dummy; }
+  virtual StringRef getMacroDWOSection() const { return ""; }
   virtual StringRef getMacinfoSection() const { return ""; }
-  virtual const DWARFSection &getPubNamesSection() const { return Dummy; }
-  virtual const DWARFSection &getPubTypesSection() const { return Dummy; }
-  virtual const DWARFSection &getGnuPubNamesSection() const { return Dummy; }
-  virtual const DWARFSection &getGnuPubTypesSection() const { return Dummy; }
-  virtual const DWARFSection &getStringOffsetSection() const { return Dummy; }
+  virtual StringRef getMacinfoDWOSection() const { return ""; }
+  virtual const DWARFSection &getPubnamesSection() const { return Dummy; }
+  virtual const DWARFSection &getPubtypesSection() const { return Dummy; }
+  virtual const DWARFSection &getGnuPubnamesSection() const { return Dummy; }
+  virtual const DWARFSection &getGnuPubtypesSection() const { return Dummy; }
+  virtual const DWARFSection &getStrOffsetsSection() const { return Dummy; }
   virtual void
   forEachInfoDWOSections(function_ref<void(const DWARFSection &)> F) const {}
   virtual void
@@ -60,11 +63,12 @@
   virtual StringRef getAbbrevDWOSection() const { return ""; }
   virtual const DWARFSection &getLineDWOSection() const { return Dummy; }
   virtual const DWARFSection &getLocDWOSection() const { return Dummy; }
-  virtual StringRef getStringDWOSection() const { return ""; }
-  virtual const DWARFSection &getStringOffsetDWOSection() const {
+  virtual const DWARFSection &getLoclistsDWOSection() const { return Dummy; }
+  virtual StringRef getStrDWOSection() const { return ""; }
+  virtual const DWARFSection &getStrOffsetsDWOSection() const {
     return Dummy;
   }
-  virtual const DWARFSection &getRangeDWOSection() const { return Dummy; }
+  virtual const DWARFSection &getRangesDWOSection() const { return Dummy; }
   virtual const DWARFSection &getRnglistsDWOSection() const { return Dummy; }
   virtual const DWARFSection &getAddrSection() const { return Dummy; }
   virtual const DWARFSection &getAppleNamesSection() const { return Dummy; }
@@ -72,7 +76,7 @@
   virtual const DWARFSection &getAppleNamespacesSection() const {
     return Dummy;
   }
-  virtual const DWARFSection &getDebugNamesSection() const { return Dummy; }
+  virtual const DWARFSection &getNamesSection() const { return Dummy; }
   virtual const DWARFSection &getAppleObjCSection() const { return Dummy; }
   virtual StringRef getCUIndexSection() const { return ""; }
   virtual StringRef getGdbIndexSection() const { return ""; }
diff --git a/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFRelocMap.h b/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFRelocMap.h
index cd022e7..3add711 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFRelocMap.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFRelocMap.h
@@ -20,8 +20,10 @@
 struct RelocAddrEntry {
   uint64_t SectionIndex;
   object::RelocationRef Reloc;
-  object::RelocationResolver Resolver;
   uint64_t SymbolValue;
+  Optional<object::RelocationRef> Reloc2;
+  uint64_t SymbolValue2;
+  object::RelocationResolver Resolver;
 };
 
 /// In place of applying the relocations to the data we've read from disk we use
diff --git a/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFTypeUnit.h b/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFTypeUnit.h
index 90d8937..c95bdcb 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFTypeUnit.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFTypeUnit.h
@@ -34,7 +34,7 @@
                   LS, LE, IsDWO, UnitVector) {}
 
   uint64_t getTypeHash() const { return getHeader().getTypeHash(); }
-  uint32_t getTypeOffset() const { return getHeader().getTypeOffset(); }
+  uint64_t getTypeOffset() const { return getHeader().getTypeOffset(); }
 
   void dump(raw_ostream &OS, DIDumpOptions DumpOpts = {}) override;
   // Enable LLVM-style RTTI.
diff --git a/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFUnit.h b/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFUnit.h
index f9f90db..369cbdc 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFUnit.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFUnit.h
@@ -16,6 +16,7 @@
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/BinaryFormat/Dwarf.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugInfoEntry.h"
+#include "llvm/DebugInfo/DWARF/DWARFDebugLoc.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugRangeList.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugRnglists.h"
 #include "llvm/DebugInfo/DWARF/DWARFDie.h"
@@ -45,7 +46,7 @@
 /// parse the header before deciding what specific kind of unit to construct.
 class DWARFUnitHeader {
   // Offset within section.
-  uint32_t Offset = 0;
+  uint64_t Offset = 0;
   // Version, address size, and DWARF format.
   dwarf::FormParams FormParams;
   uint64_t Length = 0;
@@ -56,7 +57,7 @@
 
   // For type units only.
   uint64_t TypeHash = 0;
-  uint32_t TypeOffset = 0;
+  uint64_t TypeOffset = 0;
 
   // For v5 split or skeleton compile units only.
   Optional<uint64_t> DWOId;
@@ -69,11 +70,15 @@
 
 public:
   /// Parse a unit header from \p debug_info starting at \p offset_ptr.
+  /// Note that \p SectionKind is used as a hint to guess the unit type
+  /// for DWARF formats prior to DWARFv5. In DWARFv5 the unit type is
+  /// explicitly defined in the header and the hint is ignored.
   bool extract(DWARFContext &Context, const DWARFDataExtractor &debug_info,
-               uint32_t *offset_ptr, DWARFSectionKind Kind = DW_SECT_INFO,
-               const DWARFUnitIndex *Index = nullptr,
-               const DWARFUnitIndex::Entry *Entry = nullptr);
-  uint32_t getOffset() const { return Offset; }
+               uint64_t *offset_ptr, DWARFSectionKind SectionKind);
+  // For units in DWARF Package File, remember the index entry and update
+  // the abbreviation offset read by extract().
+  bool applyIndexEntry(const DWARFUnitIndex::Entry *Entry);
+  uint64_t getOffset() const { return Offset; }
   const dwarf::FormParams &getFormParams() const { return FormParams; }
   uint16_t getVersion() const { return FormParams.Version; }
   dwarf::DwarfFormat getFormat() const { return FormParams.Format; }
@@ -91,26 +96,29 @@
   }
   const DWARFUnitIndex::Entry *getIndexEntry() const { return IndexEntry; }
   uint64_t getTypeHash() const { return TypeHash; }
-  uint32_t getTypeOffset() const { return TypeOffset; }
+  uint64_t getTypeOffset() const { return TypeOffset; }
   uint8_t getUnitType() const { return UnitType; }
   bool isTypeUnit() const {
     return UnitType == dwarf::DW_UT_type || UnitType == dwarf::DW_UT_split_type;
   }
   uint8_t getSize() const { return Size; }
-  uint32_t getNextUnitOffset() const {
-    return Offset + Length +
-           (FormParams.Format == llvm::dwarf::DwarfFormat::DWARF64 ? 4 : 0) +
-           FormParams.getDwarfOffsetByteSize();
+  uint8_t getUnitLengthFieldByteSize() const {
+    return dwarf::getUnitLengthFieldByteSize(FormParams.Format);
+  }
+  uint64_t getNextUnitOffset() const {
+    return Offset + Length + getUnitLengthFieldByteSize();
   }
 };
 
 const DWARFUnitIndex &getDWARFUnitIndex(DWARFContext &Context,
                                         DWARFSectionKind Kind);
 
+bool isCompileUnit(const std::unique_ptr<DWARFUnit> &U);
+
 /// Describe a collection of units. Intended to hold all units either from
 /// .debug_info and .debug_types, or from .debug_info.dwo and .debug_types.dwo.
 class DWARFUnitVector final : public SmallVector<std::unique_ptr<DWARFUnit>, 1> {
-  std::function<std::unique_ptr<DWARFUnit>(uint32_t, DWARFSectionKind,
+  std::function<std::unique_ptr<DWARFUnit>(uint64_t, DWARFSectionKind,
                                            const DWARFSection *,
                                            const DWARFUnitIndex::Entry *)>
       Parser;
@@ -121,7 +129,10 @@
   using iterator = typename UnitVector::iterator;
   using iterator_range = llvm::iterator_range<typename UnitVector::iterator>;
 
-  DWARFUnit *getUnitForOffset(uint32_t Offset) const;
+  using compile_unit_range =
+      decltype(make_filter_range(std::declval<iterator_range>(), isCompileUnit));
+
+  DWARFUnit *getUnitForOffset(uint64_t Offset) const;
   DWARFUnit *getUnitForIndexEntry(const DWARFUnitIndex::Entry &E);
 
   /// Read units from a .debug_info or .debug_types section.  Calls made
@@ -197,18 +208,17 @@
   DWARFUnitHeader Header;
   const DWARFDebugAbbrev *Abbrev;
   const DWARFSection *RangeSection;
-  uint32_t RangeSectionBase;
-  /// We either keep track of the location list section or its data, depending
-  /// on whether we are handling a split DWARF section or not.
-  union {
-    const DWARFSection *LocSection;
-    StringRef LocSectionData;
-  };
+  uint64_t RangeSectionBase;
+  uint64_t LocSectionBase;
+
+  /// Location table of this unit.
+  std::unique_ptr<DWARFLocationTable> LocTable;
+
   const DWARFSection &LineSection;
   StringRef StringSection;
   const DWARFSection &StringOffsetSection;
   const DWARFSection *AddrOffsetSection;
-  uint32_t AddrOffsetSectionBase = 0;
+  Optional<uint64_t> AddrOffsetSectionBase;
   bool isLittleEndian;
   bool IsDWO;
   const DWARFUnitVector &UnitVector;
@@ -217,9 +227,6 @@
   /// offsets table (DWARF v5).
   Optional<StrOffsetsContributionDescriptor> StringOffsetsTableContribution;
 
-  /// A table of range lists (DWARF v5 and later).
-  Optional<DWARFDebugRnglistTable> RngListTable;
-
   mutable const DWARFAbbreviationDeclarationSet *Abbrevs;
   llvm::Optional<object::SectionedAddress> BaseAddr;
   /// The compile unit debug information entry items.
@@ -273,9 +280,7 @@
   bool isDWOUnit() const { return IsDWO; }
   DWARFContext& getContext() const { return Context; }
   const DWARFSection &getInfoSection() const { return InfoSection; }
-  const DWARFSection *getLocSection() const { return LocSection; }
-  StringRef getLocSectionData() const { return LocSectionData; }
-  uint32_t getOffset() const { return Header.getOffset(); }
+  uint64_t getOffset() const { return Header.getOffset(); }
   const dwarf::FormParams &getFormParams() const {
     return Header.getFormParams();
   }
@@ -285,17 +290,19 @@
   uint8_t getDwarfOffsetByteSize() const {
     return Header.getDwarfOffsetByteSize();
   }
-  uint32_t getLength() const { return Header.getLength(); }
+  uint64_t getLength() const { return Header.getLength(); }
+  dwarf::DwarfFormat getFormat() const { return Header.getFormat(); }
   uint8_t getUnitType() const { return Header.getUnitType(); }
   bool isTypeUnit() const { return Header.isTypeUnit(); }
-  uint32_t getNextUnitOffset() const { return Header.getNextUnitOffset(); }
+  uint64_t getAbbrOffset() const { return Header.getAbbrOffset(); }
+  uint64_t getNextUnitOffset() const { return Header.getNextUnitOffset(); }
   const DWARFSection &getLineSection() const { return LineSection; }
   StringRef getStringSection() const { return StringSection; }
   const DWARFSection &getStringOffsetSection() const {
     return StringOffsetSection;
   }
 
-  void setAddrOffsetSection(const DWARFSection *AOS, uint32_t Base) {
+  void setAddrOffsetSection(const DWARFSection *AOS, uint64_t Base) {
     AddrOffsetSection = AOS;
     AddrOffsetSectionBase = Base;
   }
@@ -303,11 +310,15 @@
   /// Recursively update address to Die map.
   void updateAddressDieMap(DWARFDie Die);
 
-  void setRangesSection(const DWARFSection *RS, uint32_t Base) {
+  void setRangesSection(const DWARFSection *RS, uint64_t Base) {
     RangeSection = RS;
     RangeSectionBase = Base;
   }
 
+  uint64_t getLocSectionBase() const {
+    return LocSectionBase;
+  }
+
   Optional<object::SectionedAddress>
   getAddrOffsetSectionItem(uint32_t Index) const;
   Optional<uint64_t> getStringOffsetSectionItem(uint32_t Index) const;
@@ -318,11 +329,13 @@
     return DataExtractor(StringSection, false, 0);
   }
 
+  const DWARFLocationTable &getLocationTable() { return *LocTable; }
+
   /// Extract the range list referenced by this compile unit from the
   /// .debug_ranges section. If the extraction is unsuccessful, an error
   /// is returned. Successful extraction requires that the compile unit
   /// has already been extracted.
-  Error extractRangeList(uint32_t RangeListOffset,
+  Error extractRangeList(uint64_t RangeListOffset,
                          DWARFDebugRangeList &RangeList) const;
   void clear();
 
@@ -360,26 +373,6 @@
     return false;
   }
 
-  /// Return the number of bytes for the header of a unit of
-  /// UnitType type.
-  ///
-  /// This function must be called with a valid unit type which in
-  /// DWARF5 is defined as one of the following six types.
-  static uint32_t getDWARF5HeaderSize(uint8_t UnitType) {
-    switch (UnitType) {
-    case dwarf::DW_UT_compile:
-    case dwarf::DW_UT_partial:
-      return 12;
-    case dwarf::DW_UT_skeleton:
-    case dwarf::DW_UT_split_compile:
-      return 20;
-    case dwarf::DW_UT_type:
-    case dwarf::DW_UT_split_type:
-      return 24;
-    }
-    llvm_unreachable("Invalid UnitType.");
-  }
-
   llvm::Optional<object::SectionedAddress> getBaseAddress();
 
   DWARFDie getUnitDIE(bool ExtractUnitDIEOnly = true) {
@@ -405,7 +398,7 @@
 
   /// Return a vector of address ranges resulting from a (possibly encoded)
   /// range list starting at a given offset in the appropriate ranges section.
-  Expected<DWARFAddressRangesVector> findRnglistFromOffset(uint32_t Offset);
+  Expected<DWARFAddressRangesVector> findRnglistFromOffset(uint64_t Offset);
 
   /// Return a vector of address ranges retrieved from an encoded range
   /// list whose offset is found via a table lookup given an index (DWARF v5
@@ -415,14 +408,15 @@
   /// Return a rangelist's offset based on an index. The index designates
   /// an entry in the rangelist table's offset array and is supplied by
   /// DW_FORM_rnglistx.
-  Optional<uint32_t> getRnglistOffset(uint32_t Index) {
-    if (RngListTable)
-      return RngListTable->getOffsetEntry(Index);
-    return None;
-  }
+  Optional<uint64_t> getRnglistOffset(uint32_t Index);
+
+  Optional<uint64_t> getLoclistOffset(uint32_t Index);
 
   Expected<DWARFAddressRangesVector> collectAddressRanges();
 
+  Expected<DWARFLocationExpressionsVector>
+  findLoclistFromOffset(uint64_t Offset);
+
   /// Returns subprogram DIE with address range encompassing the provided
   /// address. The pointer is alive as long as parsed compile unit DIEs are not
   /// cleared.
@@ -470,9 +464,8 @@
   /// unit's DIE vector.
   ///
   /// The unit needs to have its DIEs extracted for this method to work.
-  DWARFDie getDIEForOffset(uint32_t Offset) {
+  DWARFDie getDIEForOffset(uint64_t Offset) {
     extractDIEsIfNeeded(false);
-    assert(!DieArray.empty());
     auto It =
         llvm::partition_point(DieArray, [=](const DWARFDebugInfoEntry &DIE) {
           return DIE.getOffset() < Offset;
@@ -484,7 +477,7 @@
 
   uint32_t getLineTableOffset() const {
     if (auto IndexEntry = Header.getIndexEntry())
-      if (const auto *Contrib = IndexEntry->getOffset(DW_SECT_LINE))
+      if (const auto *Contrib = IndexEntry->getContribution(DW_SECT_LINE))
         return Contrib->Offset;
     return 0;
   }
@@ -495,15 +488,19 @@
   }
 
   virtual void dump(raw_ostream &OS, DIDumpOptions DumpOpts) = 0;
+
+  Error tryExtractDIEsIfNeeded(bool CUDieOnly);
+
 private:
   /// Size in bytes of the .debug_info data associated with this compile unit.
   size_t getDebugInfoSize() const {
-    return Header.getLength() + 4 - getHeaderSize();
+    return Header.getLength() + Header.getUnitLengthFieldByteSize() -
+           getHeaderSize();
   }
 
   /// extractDIEsIfNeeded - Parses a compile unit and indexes its DIEs if it
-  /// hasn't already been done. Returns the number of DIEs parsed at this call.
-  size_t extractDIEsIfNeeded(bool CUDieOnly);
+  /// hasn't already been done
+  void extractDIEsIfNeeded(bool CUDieOnly);
 
   /// extractDIEsToVector - Appends all parsed DIEs to a vector.
   void extractDIEsToVector(bool AppendCUDie, bool AppendNonCUDIEs,
@@ -517,6 +514,10 @@
   bool parseDWO();
 };
 
+inline bool isCompileUnit(const std::unique_ptr<DWARFUnit> &U) {
+  return !U->isTypeUnit();
+}
+
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_DWARF_DWARFUNIT_H
diff --git a/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFUnitIndex.h b/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFUnitIndex.h
index fc8c707..edea59e 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFUnitIndex.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFUnitIndex.h
@@ -19,17 +19,64 @@
 
 class raw_ostream;
 
+/// The enum of section identifiers to be used in internal interfaces.
+///
+/// Pre-standard implementation of package files defined a number of section
+/// identifiers with values that clash definitions in the DWARFv5 standard.
+/// See https://gcc.gnu.org/wiki/DebugFissionDWP and Section 7.3.5.3 in DWARFv5.
+///
+/// The following identifiers are the same in the proposal and in DWARFv5:
+/// - DW_SECT_INFO         = 1 (.debug_info.dwo)
+/// - DW_SECT_ABBREV       = 3 (.debug_abbrev.dwo)
+/// - DW_SECT_LINE         = 4 (.debug_line.dwo)
+/// - DW_SECT_STR_OFFSETS  = 6 (.debug_str_offsets.dwo)
+///
+/// The following identifiers are defined only in DWARFv5:
+/// - DW_SECT_LOCLISTS     = 5 (.debug_loclists.dwo)
+/// - DW_SECT_RNGLISTS     = 8 (.debug_rnglists.dwo)
+///
+/// The following identifiers are defined only in the GNU proposal:
+/// - DW_SECT_TYPES        = 2 (.debug_types.dwo)
+/// - DW_SECT_LOC          = 5 (.debug_loc.dwo)
+/// - DW_SECT_MACINFO      = 7 (.debug_macinfo.dwo)
+///
+/// DW_SECT_MACRO for the .debug_macro.dwo section is defined in both standards,
+/// but with different values, 8 in GNU and 7 in DWARFv5.
+///
+/// This enum defines constants to represent the identifiers of both sets.
+/// For DWARFv5 ones, the values are the same as defined in the standard.
+/// For pre-standard ones that correspond to sections being deprecated in
+/// DWARFv5, the values are chosen arbitrary and a tag "_EXT_" is added to
+/// the names.
+///
+/// The enum is for internal use only. The user should not expect the values
+/// to correspond to any input/output constants. Special conversion functions,
+/// serializeSectionKind() and deserializeSectionKind(), should be used for
+/// the translation.
 enum DWARFSectionKind {
-  DW_SECT_INFO = 1,
-  DW_SECT_TYPES,
-  DW_SECT_ABBREV,
-  DW_SECT_LINE,
-  DW_SECT_LOC,
-  DW_SECT_STR_OFFSETS,
-  DW_SECT_MACINFO,
-  DW_SECT_MACRO,
+  /// Denotes a value read from an index section that does not correspond
+  /// to any of the supported standards.
+  DW_SECT_EXT_unknown = 0,
+#define HANDLE_DW_SECT(ID, NAME) DW_SECT_##NAME = ID,
+#include "llvm/BinaryFormat/Dwarf.def"
+  DW_SECT_EXT_TYPES = 2,
+  DW_SECT_EXT_LOC = 9,
+  DW_SECT_EXT_MACINFO = 10,
 };
 
+/// Convert the internal value for a section kind to an on-disk value.
+///
+/// The conversion depends on the version of the index section.
+/// IndexVersion is expected to be either 2 for pre-standard GNU proposal
+/// or 5 for DWARFv5 package file.
+uint32_t serializeSectionKind(DWARFSectionKind Kind, unsigned IndexVersion);
+
+/// Convert a value read from an index section to the internal representation.
+///
+/// The conversion depends on the index section version, which is expected
+/// to be either 2 for pre-standard GNU proposal or 5 for DWARFv5 package file.
+DWARFSectionKind deserializeSectionKind(uint32_t Value, unsigned IndexVersion);
+
 class DWARFUnitIndex {
   struct Header {
     uint32_t Version;
@@ -37,7 +84,7 @@
     uint32_t NumUnits;
     uint32_t NumBuckets = 0;
 
-    bool parse(DataExtractor IndexData, uint32_t *OffsetPtr);
+    bool parse(DataExtractor IndexData, uint64_t *OffsetPtr);
     void dump(raw_ostream &OS) const;
   };
 
@@ -56,10 +103,10 @@
     friend class DWARFUnitIndex;
 
   public:
-    const SectionContribution *getOffset(DWARFSectionKind Sec) const;
-    const SectionContribution *getOffset() const;
+    const SectionContribution *getContribution(DWARFSectionKind Sec) const;
+    const SectionContribution *getContribution() const;
 
-    const SectionContribution *getOffsets() const {
+    const SectionContribution *getContributions() const {
       return Contributions.get();
     }
 
@@ -72,6 +119,10 @@
   DWARFSectionKind InfoColumnKind;
   int InfoColumn = -1;
   std::unique_ptr<DWARFSectionKind[]> ColumnKinds;
+  // This is a parallel array of section identifiers as they read from the input
+  // file. The mapping from raw values to DWARFSectionKind is not revertable in
+  // case of unknown identifiers, so we keep them here.
+  std::unique_ptr<uint32_t[]> RawSectionIds;
   std::unique_ptr<Entry[]> Rows;
   mutable std::vector<Entry *> OffsetLookup;
 
@@ -88,6 +139,8 @@
   bool parse(DataExtractor IndexData);
   void dump(raw_ostream &OS) const;
 
+  uint32_t getVersion() const { return Header.Version; }
+
   const Entry *getFromOffset(uint32_t Offset) const;
   const Entry *getFromHash(uint64_t Offset) const;
 
diff --git a/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFVerifier.h b/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFVerifier.h
index f1268f2..18d889f 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFVerifier.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/DWARF/DWARFVerifier.h
@@ -9,27 +9,25 @@
 #ifndef LLVM_DEBUGINFO_DWARF_DWARFVERIFIER_H
 #define LLVM_DEBUGINFO_DWARF_DWARFVERIFIER_H
 
+#include "llvm/ADT/Optional.h"
 #include "llvm/DebugInfo/DIContext.h"
 #include "llvm/DebugInfo/DWARF/DWARFAcceleratorTable.h"
-#include "llvm/DebugInfo/DWARF/DWARFAddressRange.h"
 #include "llvm/DebugInfo/DWARF/DWARFDie.h"
 #include "llvm/DebugInfo/DWARF/DWARFUnitIndex.h"
-
 #include <cstdint>
 #include <map>
 #include <set>
 
 namespace llvm {
 class raw_ostream;
+struct DWARFAddressRange;
 struct DWARFAttribute;
 class DWARFContext;
-class DWARFDie;
-class DWARFUnit;
-class DWARFCompileUnit;
 class DWARFDataExtractor;
 class DWARFDebugAbbrev;
 class DataExtractor;
 struct DWARFSection;
+class DWARFUnit;
 
 /// A class that verifies DWARF debug information given a DWARF Context.
 class DWARFVerifier {
@@ -56,11 +54,13 @@
     typedef std::set<DieRangeInfo>::const_iterator die_range_info_iterator;
 
     /// Inserts the address range. If the range overlaps with an existing
-    /// range, the range is *not* added and an iterator to the overlapping
-    /// range is returned.
+    /// range, the range that it overlaps with will be returned and the two
+    /// address ranges will be unioned together in "Ranges".
     ///
-    /// This is used for finding overlapping ranges within the same DIE.
-    address_range_iterator insert(const DWARFAddressRange &R);
+    /// This is used for finding overlapping ranges in the DW_AT_ranges
+    /// attribute of a DIE. It is also used as a set of address ranges that
+    /// children address ranges must all be contained in.
+    Optional<DWARFAddressRange> insert(const DWARFAddressRange &R);
 
     /// Finds an address range in the sorted vector of ranges.
     address_range_iterator findRange(const DWARFAddressRange &R) const {
@@ -94,7 +94,7 @@
   /// A map that tracks all references (converted absolute references) so we
   /// can verify each reference points to a valid DIE and not an offset that
   /// lies between to valid DIEs.
-  std::map<uint64_t, std::set<uint32_t>> ReferenceToDIEOffsets;
+  std::map<uint64_t, std::set<uint64_t>> ReferenceToDIEOffsets;
   uint32_t NumDebugLineErrors = 0;
   // Used to relax some checks that do not currently work portably
   bool IsObjectFile;
@@ -138,7 +138,7 @@
   ///
   /// \returns true if the header is verified successfully, false otherwise.
   bool verifyUnitHeader(const DWARFDataExtractor DebugInfoData,
-                        uint32_t *Offset, unsigned UnitIndex, uint8_t &UnitType,
+                        uint64_t *Offset, unsigned UnitIndex, uint8_t &UnitType,
                         bool &isUnitDWARF64);
 
   /// Verifies the header of a unit in a .debug_info or .debug_types section.
diff --git a/linux-x64/clang/include/llvm/DebugInfo/GSYM/DwarfTransformer.h b/linux-x64/clang/include/llvm/DebugInfo/GSYM/DwarfTransformer.h
new file mode 100644
index 0000000..a5d07fb
--- /dev/null
+++ b/linux-x64/clang/include/llvm/DebugInfo/GSYM/DwarfTransformer.h
@@ -0,0 +1,91 @@
+//===- DwarfTransformer.h ---------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_DEBUGINFO_GSYM_DWARFTRANSFORMER_H
+#define LLVM_DEBUGINFO_GSYM_DWARFTRANSFORMER_H
+
+#include "llvm/ADT/StringRef.h"
+#include "llvm/DebugInfo/GSYM/Range.h"
+#include "llvm/Support/Error.h"
+
+namespace llvm {
+
+class raw_ostream;
+
+namespace gsym {
+
+struct CUInfo;
+struct FunctionInfo;
+class GsymCreator;
+
+/// A class that transforms the DWARF in a DWARFContext into GSYM information
+/// by populating the GsymCreator object that it is constructed with. This
+/// class supports converting all DW_TAG_subprogram DIEs into
+/// gsym::FunctionInfo objects that includes line table information and inline
+/// function information. Creating a separate class to transform this data
+/// allows this class to be unit tested.
+class DwarfTransformer {
+public:
+
+  /// Create a DWARF transformer.
+  ///
+  /// \param D The DWARF to use when converting to GSYM.
+  ///
+  /// \param OS The stream to log warnings and non fatal issues to.
+  ///
+  /// \param G The GSYM creator to populate with the function information
+  /// from the debug info.
+  DwarfTransformer(DWARFContext &D, raw_ostream &OS, GsymCreator &G) :
+      DICtx(D), Log(OS), Gsym(G) {}
+
+  /// Extract the DWARF from the supplied object file and convert it into the
+  /// Gsym format in the GsymCreator object that is passed in. Returns an
+  /// error if something fatal is encountered.
+  ///
+  /// \returns An error indicating any fatal issues that happen when parsing
+  /// the DWARF, or Error::success() if all goes well.
+  llvm::Error convert(uint32_t NumThreads);
+
+  llvm::Error verify(StringRef GsymPath);
+
+
+private:
+
+  /// Parse the DWARF in the object file and convert it into the GsymCreator.
+  Error parse();
+
+  /// Handle any DIE (debug info entry) from the DWARF.
+  ///
+  /// This function will find all DW_TAG_subprogram DIEs that convert them into
+  /// GSYM FuntionInfo objects and add them to the GsymCreator supplied during
+  /// construction. The DIE and all its children will be recursively parsed
+  /// with calls to this function.
+  ///
+  /// \param Strm The thread specific log stream for any non fatal errors and
+  /// warnings. Once a thread has finished parsing an entire compile unit, all
+  /// information in this temporary stream will be forwarded to the member
+  /// variable log. This keeps logging thread safe.
+  ///
+  /// \param CUI The compile unit specific information that contains the DWARF
+  /// line table, cached file list, and other compile unit specific
+  /// information.
+  ///
+  /// \param Die The DWARF debug info entry to parse.
+  void handleDie(raw_ostream &Strm, CUInfo &CUI, DWARFDie Die);
+
+  DWARFContext &DICtx;
+  raw_ostream &Log;
+  GsymCreator &Gsym;
+
+  friend class DwarfTransformerTest;
+};
+
+} // namespace gsym
+} // namespace llvm
+
+#endif // #ifndef LLVM_DEBUGINFO_GSYM_DWARFTRANSFORMER_H
diff --git a/linux-x64/clang/include/llvm/DebugInfo/GSYM/FileEntry.h b/linux-x64/clang/include/llvm/DebugInfo/GSYM/FileEntry.h
index 228b4ef..49e7fc9 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/GSYM/FileEntry.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/GSYM/FileEntry.h
@@ -1,9 +1,8 @@
 //===- FileEntry.h ----------------------------------------------*- C++ -*-===//
 //
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/linux-x64/clang/include/llvm/DebugInfo/GSYM/FileWriter.h b/linux-x64/clang/include/llvm/DebugInfo/GSYM/FileWriter.h
new file mode 100644
index 0000000..cd56876
--- /dev/null
+++ b/linux-x64/clang/include/llvm/DebugInfo/GSYM/FileWriter.h
@@ -0,0 +1,124 @@
+//===- FileWriter.h ---------------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_DEBUGINFO_GSYM_FILEWRITER_H
+#define LLVM_DEBUGINFO_GSYM_FILEWRITER_H
+
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/Support/Endian.h"
+
+#include <stddef.h>
+#include <stdint.h>
+#include <sys/types.h>
+
+namespace llvm {
+class raw_pwrite_stream;
+
+namespace gsym {
+
+/// A simplified binary data writer class that doesn't require targets, target
+/// definitions, architectures, or require any other optional compile time
+/// libraries to be enabled via the build process. This class needs the ability
+/// to seek to different spots in the binary stream that is produces to fixup
+/// offsets and sizes.
+class FileWriter {
+  llvm::raw_pwrite_stream &OS;
+  llvm::support::endianness ByteOrder;
+public:
+  FileWriter(llvm::raw_pwrite_stream &S, llvm::support::endianness B)
+      : OS(S), ByteOrder(B) {}
+  ~FileWriter();
+  /// Write a single uint8_t value into the stream at the current file
+  /// position.
+  ///
+  /// \param   Value The value to write into the stream.
+  void writeU8(uint8_t Value);
+
+  /// Write a single uint16_t value into the stream at the current file
+  /// position. The value will be byte swapped if needed to match the byte
+  /// order specified during construction.
+  ///
+  /// \param   Value The value to write into the stream.
+  void writeU16(uint16_t Value);
+
+  /// Write a single uint32_t value into the stream at the current file
+  /// position. The value will be byte swapped if needed to match the byte
+  /// order specified during construction.
+  ///
+  /// \param   Value The value to write into the stream.
+  void writeU32(uint32_t Value);
+
+  /// Write a single uint64_t value into the stream at the current file
+  /// position. The value will be byte swapped if needed to match the byte
+  /// order specified during construction.
+  ///
+  /// \param   Value The value to write into the stream.
+  void writeU64(uint64_t Value);
+
+  /// Write the value into the stream encoded using signed LEB128 at the
+  /// current file position.
+  ///
+  /// \param   Value The value to write into the stream.
+  void writeSLEB(int64_t Value);
+
+  /// Write the value into the stream encoded using unsigned LEB128 at the
+  /// current file position.
+  ///
+  /// \param   Value The value to write into the stream.
+  void writeULEB(uint64_t Value);
+
+  /// Write an array of uint8_t values into the stream at the current file
+  /// position.
+  ///
+  /// \param   Data An array of values to write into the stream.
+  void writeData(llvm::ArrayRef<uint8_t> Data);
+
+  /// Write a NULL terminated C string into the stream at the current file
+  /// position. The entire contents of Str will be written into the steam at
+  /// the current file position and then an extra NULL termation byte will be
+  /// written. It is up to the user to ensure that Str doesn't contain any NULL
+  /// characters unless the additional NULL characters are desired.
+  ///
+  /// \param   Str The value to write into the stream.
+  void writeNullTerminated(llvm::StringRef Str);
+
+  /// Fixup a uint32_t value at the specified offset in the stream. This
+  /// function will save the current file position, seek to the specified
+  /// offset, overwrite the data using Value, and then restore the file
+  /// position to the previous file position.
+  ///
+  /// \param   Value The value to write into the stream.
+  /// \param   Offset The offset at which to write the Value within the stream.
+  void fixup32(uint32_t Value, uint64_t Offset);
+
+  /// Pad with zeroes at the current file position until the current file
+  /// position matches the specified alignment.
+  ///
+  /// \param  Align An integer speciying the desired alignment. This does not
+  ///         need to be a power of two.
+  void alignTo(size_t Align);
+
+  /// Return the current offset within the file.
+  ///
+  /// \return The unsigned offset from the start of the file of the current
+  ///         file position.
+  uint64_t tell();
+
+  llvm::raw_pwrite_stream &get_stream() {
+    return OS;
+  }
+
+private:
+  FileWriter(const FileWriter &rhs) = delete;
+  void operator=(const FileWriter &rhs) = delete;
+};
+
+} // namespace gsym
+} // namespace llvm
+
+#endif // #ifndef LLVM_DEBUGINFO_GSYM_FILEWRITER_H
diff --git a/linux-x64/clang/include/llvm/DebugInfo/GSYM/FunctionInfo.h b/linux-x64/clang/include/llvm/DebugInfo/GSYM/FunctionInfo.h
index eedb1e6..893cfc1 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/GSYM/FunctionInfo.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/GSYM/FunctionInfo.h
@@ -1,17 +1,18 @@
 //===- FunctionInfo.h -------------------------------------------*- C++ -*-===//
 //
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_GSYM_FUNCTIONINFO_H
 #define LLVM_DEBUGINFO_GSYM_FUNCTIONINFO_H
 
+#include "llvm/ADT/Optional.h"
 #include "llvm/DebugInfo/GSYM/InlineInfo.h"
-#include "llvm/DebugInfo/GSYM/LineEntry.h"
+#include "llvm/DebugInfo/GSYM/LineTable.h"
+#include "llvm/DebugInfo/GSYM/LookupResult.h"
 #include "llvm/DebugInfo/GSYM/Range.h"
 #include "llvm/DebugInfo/GSYM/StringTable.h"
 #include <tuple>
@@ -21,41 +22,153 @@
 class raw_ostream;
 namespace gsym {
 
-/// Function information in GSYM files encodes information for one
-/// contiguous address range. The name of the function is encoded as
-/// a string table offset and allows multiple functions with the same
-/// name to share the name string in the string table. Line tables are
-/// stored in a sorted vector of gsym::LineEntry objects and are split
-/// into line tables for each function. If a function has a discontiguous
-/// range, it will be split into two gsym::FunctionInfo objects. If the
-/// function has inline functions, the information will be encoded in
-/// the "Inline" member, see gsym::InlineInfo for more information.
+class GsymReader;
+/// Function information in GSYM files encodes information for one contiguous
+/// address range. If a function has discontiguous address ranges, they will
+/// need to be encoded using multiple FunctionInfo objects.
+///
+/// ENCODING
+///
+/// The function information gets the function start address as an argument
+/// to the FunctionInfo::decode(...) function. This information is calculated
+/// from the GSYM header and an address offset from the GSYM address offsets
+/// table. The encoded FunctionInfo information must be aligned to a 4 byte
+/// boundary.
+///
+/// The encoded data for a FunctionInfo starts with fixed data that all
+/// function info objects have:
+///
+/// ENCODING  NAME        DESCRIPTION
+/// ========= =========== ====================================================
+/// uint32_t  Size        The size in bytes of this function.
+/// uint32_t  Name        The string table offset of the function name.
+///
+/// The optional data in a FunctionInfo object follows this fixed information
+/// and consists of a stream of tuples that consist of:
+///
+/// ENCODING  NAME        DESCRIPTION
+/// ========= =========== ====================================================
+/// uint32_t  InfoType    An "InfoType" enumeration that describes the type
+///                       of optional data that is encoded.
+/// uint32_t  InfoLength  The size in bytes of the encoded data that
+///                       immediately follows this length if this value is
+///                       greater than zero.
+/// uint8_t[] InfoData    Encoded bytes that represent the data for the
+///                       "InfoType". These bytes are only present if
+///                       "InfoLength" is greater than zero.
+///
+/// The "InfoType" is an enumeration:
+///
+///   enum InfoType {
+///     EndOfList = 0u,
+///     LineTableInfo = 1u,
+///     InlineInfo = 2u
+///   };
+///
+/// This stream of tuples is terminated by a "InfoType" whose value is
+/// InfoType::EndOfList and a zero for "InfoLength". This signifies the end of
+/// the optional information list. This format allows us to add new optional
+/// information data to a FunctionInfo object over time and allows older
+/// clients to still parse the format and skip over any data that they don't
+/// understand or want to parse.
+///
+/// So the function information encoding essientially looks like:
+///
+/// struct {
+///   uint32_t Size;
+///   uint32_t Name;
+///   struct {
+///     uint32_t InfoType;
+///     uint32_t InfoLength;
+///     uint8_t InfoData[InfoLength];
+///   }[N];
+/// }
+///
+/// Where "N" is the number of tuples.
 struct FunctionInfo {
   AddressRange Range;
   uint32_t Name; ///< String table offset in the string table.
-  std::vector<gsym::LineEntry> Lines;
-  InlineInfo Inline;
+  llvm::Optional<LineTable> OptLineTable;
+  llvm::Optional<InlineInfo> Inline;
 
   FunctionInfo(uint64_t Addr = 0, uint64_t Size = 0, uint32_t N = 0)
       : Range(Addr, Addr + Size), Name(N) {}
 
+  /// Query if a FunctionInfo has rich debug info.
+  ///
+  /// \returns A bool that indicates if this object has something else than
+  /// range and name. When converting information from a symbol table and from
+  /// debug info, we might end up with multiple FunctionInfo objects for the
+  /// same range and we need to be able to tell which one is the better object
+  /// to use.
   bool hasRichInfo() const {
-    /// Returns whether we have something else than range and name. When
-    /// converting information from a symbol table and from debug info, we
-    /// might end up with multiple FunctionInfo objects for the same range
-    /// and we need to be able to tell which one is the better object to use.
-    return !Lines.empty() || Inline.isValid();
+    return OptLineTable.hasValue() || Inline.hasValue();
   }
 
+  /// Query if a FunctionInfo object is valid.
+  ///
+  /// Address and size can be zero and there can be no line entries for a
+  /// symbol so the only indication this entry is valid is if the name is
+  /// not zero. This can happen when extracting information from symbol
+  /// tables that do not encode symbol sizes. In that case only the
+  /// address and name will be filled in.
+  ///
+  /// \returns A boolean indicating if this FunctionInfo is valid.
   bool isValid() const {
-    /// Address and size can be zero and there can be no line entries for a
-    /// symbol so the only indication this entry is valid is if the name is
-    /// not zero. This can happen when extracting information from symbol
-    /// tables that do not encode symbol sizes. In that case only the
-    /// address and name will be filled in.
     return Name != 0;
   }
 
+  /// Decode an object from a binary data stream.
+  ///
+  /// \param Data The binary stream to read the data from. This object must
+  /// have the data for the object starting at offset zero. The data
+  /// can contain more data than needed.
+  ///
+  /// \param BaseAddr The FunctionInfo's start address and will be used as the
+  /// base address when decoding any contained information like the line table
+  /// and the inline info.
+  ///
+  /// \returns An FunctionInfo or an error describing the issue that was
+  /// encountered during decoding.
+  static llvm::Expected<FunctionInfo> decode(DataExtractor &Data,
+                                             uint64_t BaseAddr);
+
+  /// Encode this object into FileWriter stream.
+  ///
+  /// \param O The binary stream to write the data to at the current file
+  /// position.
+  ///
+  /// \returns An error object that indicates failure or the offset of the
+  /// function info that was successfully written into the stream.
+  llvm::Expected<uint64_t> encode(FileWriter &O) const;
+
+
+  /// Lookup an address within a FunctionInfo object's data stream.
+  ///
+  /// Instead of decoding an entire FunctionInfo object when doing lookups,
+  /// we can decode only the information we need from the FunctionInfo's data
+  /// for the specific address. The lookup result information is returned as
+  /// a LookupResult.
+  ///
+  /// \param Data The binary stream to read the data from. This object must
+  /// have the data for the object starting at offset zero. The data
+  /// can contain more data than needed.
+  ///
+  /// \param GR The GSYM reader that contains the string and file table that
+  /// will be used to fill in information in the returned result.
+  ///
+  /// \param FuncAddr The function start address decoded from the GsymReader.
+  ///
+  /// \param Addr The address to lookup.
+  ///
+  /// \returns An LookupResult or an error describing the issue that was
+  /// encountered during decoding. An error should only be returned if the
+  /// address is not contained in the FunctionInfo or if the data is corrupted.
+  static llvm::Expected<LookupResult> lookup(DataExtractor &Data,
+                                             const GsymReader &GR,
+                                             uint64_t FuncAddr,
+                                             uint64_t Addr);
+
   uint64_t startAddress() const { return Range.Start; }
   uint64_t endAddress() const { return Range.End; }
   uint64_t size() const { return Range.size(); }
@@ -66,14 +179,14 @@
   void clear() {
     Range = {0, 0};
     Name = 0;
-    Lines.clear();
-    Inline.clear();
+    OptLineTable = None;
+    Inline = None;
   }
 };
 
 inline bool operator==(const FunctionInfo &LHS, const FunctionInfo &RHS) {
   return LHS.Range == RHS.Range && LHS.Name == RHS.Name &&
-         LHS.Lines == RHS.Lines && LHS.Inline == RHS.Inline;
+         LHS.OptLineTable == RHS.OptLineTable && LHS.Inline == RHS.Inline;
 }
 inline bool operator!=(const FunctionInfo &LHS, const FunctionInfo &RHS) {
   return !(LHS == RHS);
@@ -89,14 +202,10 @@
     return LHS.Range < RHS.Range;
 
   // Then sort by inline
-  if (LHS.Inline.isValid() != RHS.Inline.isValid())
-    return RHS.Inline.isValid();
+  if (LHS.Inline.hasValue() != RHS.Inline.hasValue())
+    return RHS.Inline.hasValue();
 
-  // If the number of lines is the same, then compare line table entries
-  if (LHS.Lines.size() == RHS.Lines.size())
-    return LHS.Lines < RHS.Lines;
-  // Then sort by number of line table entries (more is better)
-  return LHS.Lines.size() < RHS.Lines.size();
+  return LHS.OptLineTable < RHS.OptLineTable;
 }
 
 raw_ostream &operator<<(raw_ostream &OS, const FunctionInfo &R);
diff --git a/linux-x64/clang/include/llvm/DebugInfo/GSYM/GsymCreator.h b/linux-x64/clang/include/llvm/DebugInfo/GSYM/GsymCreator.h
new file mode 100644
index 0000000..f29a147
--- /dev/null
+++ b/linux-x64/clang/include/llvm/DebugInfo/GSYM/GsymCreator.h
@@ -0,0 +1,297 @@
+//===- GsymCreator.h --------------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_DEBUGINFO_GSYM_GSYMCREATOR_H
+#define LLVM_DEBUGINFO_GSYM_GSYMCREATOR_H
+
+#include <functional>
+#include <memory>
+#include <mutex>
+#include <string>
+#include <thread>
+
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/StringSet.h"
+#include "llvm/DebugInfo/GSYM/FileEntry.h"
+#include "llvm/DebugInfo/GSYM/FunctionInfo.h"
+#include "llvm/DebugInfo/GSYM/Range.h"
+#include "llvm/MC/StringTableBuilder.h"
+#include "llvm/Support/Endian.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/Path.h"
+
+namespace llvm {
+
+namespace gsym {
+class FileWriter;
+
+/// GsymCreator is used to emit GSYM data to a stand alone file or section
+/// within a file.
+///
+/// The GsymCreator is designed to be used in 3 stages:
+/// - Create FunctionInfo objects and add them
+/// - Finalize the GsymCreator object
+/// - Save to file or section
+///
+/// The first stage involves creating FunctionInfo objects from another source
+/// of information like compiler debug info metadata, DWARF or Breakpad files.
+/// Any strings in the FunctionInfo or contained information, like InlineInfo
+/// or LineTable objects, should get the string table offsets by calling
+/// GsymCreator::insertString(...). Any file indexes that are needed should be
+/// obtained by calling GsymCreator::insertFile(...). All of the function calls
+/// in GsymCreator are thread safe. This allows multiple threads to create and
+/// add FunctionInfo objects while parsing debug information.
+///
+/// Once all of the FunctionInfo objects have been added, the
+/// GsymCreator::finalize(...) must be called prior to saving. This function
+/// will sort the FunctionInfo objects, finalize the string table, and do any
+/// other passes on the information needed to prepare the information to be
+/// saved.
+///
+/// Once the object has been finalized, it can be saved to a file or section.
+///
+/// ENCODING
+///
+/// GSYM files are designed to be memory mapped into a process as shared, read
+/// only data, and used as is.
+///
+/// The GSYM file format when in a stand alone file consists of:
+///   - Header
+///   - Address Table
+///   - Function Info Offsets
+///   - File Table
+///   - String Table
+///   - Function Info Data
+///
+/// HEADER
+///
+/// The header is fully described in "llvm/DebugInfo/GSYM/Header.h".
+///
+/// ADDRESS TABLE
+///
+/// The address table immediately follows the header in the file and consists
+/// of Header.NumAddresses address offsets. These offsets are sorted and can be
+/// binary searched for efficient lookups. Addresses in the address table are
+/// stored as offsets from a 64 bit base address found in Header.BaseAddress.
+/// This allows the address table to contain 8, 16, or 32 offsets. This allows
+/// the address table to not require full 64 bit addresses for each address.
+/// The resulting GSYM size is smaller and causes fewer pages to be touched
+/// during address lookups when the address table is smaller. The size of the
+/// address offsets in the address table is specified in the header in
+/// Header.AddrOffSize. The first offset in the address table is aligned to
+/// Header.AddrOffSize alignment to ensure efficient access when loaded into
+/// memory.
+///
+/// FUNCTION INFO OFFSETS TABLE
+///
+/// The function info offsets table immediately follows the address table and
+/// consists of Header.NumAddresses 32 bit file offsets: one for each address
+/// in the address table. This data is aligned to a 4 byte boundary. The
+/// offsets in this table are the relative offsets from the start offset of the
+/// GSYM header and point to the function info data for each address in the
+/// address table. Keeping this data separate from the address table helps to
+/// reduce the number of pages that are touched when address lookups occur on a
+/// GSYM file.
+///
+/// FILE TABLE
+///
+/// The file table immediately follows the function info offsets table. The
+/// encoding of the FileTable is:
+///
+/// struct FileTable {
+///   uint32_t Count;
+///   FileEntry Files[];
+/// };
+///
+/// The file table starts with a 32 bit count of the number of files that are
+/// used in all of the function info, followed by that number of FileEntry
+/// structures. The file table is aligned to a 4 byte boundary, Each file in
+/// the file table is represented with a FileEntry structure.
+/// See "llvm/DebugInfo/GSYM/FileEntry.h" for details.
+///
+/// STRING TABLE
+///
+/// The string table follows the file table in stand alone GSYM files and
+/// contains all strings for everything contained in the GSYM file. Any string
+/// data should be added to the string table and any references to strings
+/// inside GSYM information must be stored as 32 bit string table offsets into
+/// this string table. The string table always starts with an empty string at
+/// offset zero and is followed by any strings needed by the GSYM information.
+/// The start of the string table is not aligned to any boundary.
+///
+/// FUNCTION INFO DATA
+///
+/// The function info data is the payload that contains information about the
+/// address that is being looked up. It contains all of the encoded
+/// FunctionInfo objects. Each encoded FunctionInfo's data is pointed to by an
+/// entry in the Function Info Offsets Table. For details on the exact encoding
+/// of FunctionInfo objects, see "llvm/DebugInfo/GSYM/FunctionInfo.h".
+class GsymCreator {
+  // Private member variables require Mutex protections
+  mutable std::recursive_mutex Mutex;
+  std::vector<FunctionInfo> Funcs;
+  StringTableBuilder StrTab;
+  StringSet<> StringStorage;
+  DenseMap<llvm::gsym::FileEntry, uint32_t> FileEntryToIndex;
+  std::vector<llvm::gsym::FileEntry> Files;
+  std::vector<uint8_t> UUID;
+  Optional<AddressRanges> ValidTextRanges;
+  AddressRanges Ranges;
+  llvm::Optional<uint64_t> BaseAddress;
+  bool Finalized = false;
+
+public:
+
+  GsymCreator();
+
+  /// Save a GSYM file to a stand alone file.
+  ///
+  /// \param Path The file path to save the GSYM file to.
+  /// \param ByteOrder The endianness to use when saving the file.
+  /// \returns An error object that indicates success or failure of the save.
+  llvm::Error save(StringRef Path, llvm::support::endianness ByteOrder) const;
+
+  /// Encode a GSYM into the file writer stream at the current position.
+  ///
+  /// \param O The stream to save the binary data to
+  /// \returns An error object that indicates success or failure of the save.
+  llvm::Error encode(FileWriter &O) const;
+
+  /// Insert a string into the GSYM string table.
+  ///
+  /// All strings used by GSYM files must be uniqued by adding them to this
+  /// string pool and using the returned offset for any string values.
+  ///
+  /// \param S The string to insert into the string table.
+  /// \param Copy If true, then make a backing copy of the string. If false,
+  ///             the string is owned by another object that will stay around
+  ///             long enough for the GsymCreator to save the GSYM file.
+  /// \returns The unique 32 bit offset into the string table.
+  uint32_t insertString(StringRef S, bool Copy = true);
+
+  /// Insert a file into this GSYM creator.
+  ///
+  /// Inserts a file by adding a FileEntry into the "Files" member variable if
+  /// the file has not already been added. The file path is split into
+  /// directory and filename which are both added to the string table. This
+  /// allows paths to be stored efficiently by reusing the directories that are
+  /// common between multiple files.
+  ///
+  /// \param   Path The path to the file to insert.
+  /// \param   Style The path style for the "Path" parameter.
+  /// \returns The unique file index for the inserted file.
+  uint32_t insertFile(StringRef Path,
+                      sys::path::Style Style = sys::path::Style::native);
+
+  /// Add a function info to this GSYM creator.
+  ///
+  /// All information in the FunctionInfo object must use the
+  /// GsymCreator::insertString(...) function when creating string table
+  /// offsets for names and other strings.
+  ///
+  /// \param   FI The function info object to emplace into our functions list.
+  void addFunctionInfo(FunctionInfo &&FI);
+
+  /// Finalize the data in the GSYM creator prior to saving the data out.
+  ///
+  /// Finalize must be called after all FunctionInfo objects have been added
+  /// and before GsymCreator::save() is called.
+  ///
+  /// \param  OS Output stream to report duplicate function infos, overlapping
+  ///         function infos, and function infos that were merged or removed.
+  /// \returns An error object that indicates success or failure of the
+  ///          finalize.
+  llvm::Error finalize(llvm::raw_ostream &OS);
+
+  /// Set the UUID value.
+  ///
+  /// \param UUIDBytes The new UUID bytes.
+  void setUUID(llvm::ArrayRef<uint8_t> UUIDBytes) {
+    UUID.assign(UUIDBytes.begin(), UUIDBytes.end());
+  }
+
+  /// Thread safe iteration over all function infos.
+  ///
+  /// \param  Callback A callback function that will get called with each
+  ///         FunctionInfo. If the callback returns false, stop iterating.
+  void forEachFunctionInfo(
+      std::function<bool(FunctionInfo &)> const &Callback);
+
+  /// Thread safe const iteration over all function infos.
+  ///
+  /// \param  Callback A callback function that will get called with each
+  ///         FunctionInfo. If the callback returns false, stop iterating.
+  void forEachFunctionInfo(
+      std::function<bool(const FunctionInfo &)> const &Callback) const;
+
+  /// Get the current number of FunctionInfo objects contained in this
+  /// object.
+  size_t getNumFunctionInfos() const;
+
+  /// Check if an address has already been added as a function info.
+  ///
+  /// FunctionInfo data can come from many sources: debug info, symbol tables,
+  /// exception information, and more. Symbol tables should be added after
+  /// debug info and can use this function to see if a symbol's start address
+  /// has already been added to the GsymReader. Calling this before adding
+  /// a function info from a source other than debug info avoids clients adding
+  /// many redundant FunctionInfo objects from many sources only for them to be
+  /// removed during the finalize() call.
+  bool hasFunctionInfoForAddress(uint64_t Addr) const;
+
+  /// Set valid .text address ranges that all functions must be contained in.
+  void SetValidTextRanges(AddressRanges &TextRanges) {
+    ValidTextRanges = TextRanges;
+  }
+
+  /// Get the valid text ranges.
+  const Optional<AddressRanges> GetValidTextRanges() const {
+    return ValidTextRanges;
+  }
+
+  /// Check if an address is a valid code address.
+  ///
+  /// Any functions whose addresses do not exist within these function bounds
+  /// will not be converted into the final GSYM. This allows the object file
+  /// to figure out the valid file address ranges of all the code sections
+  /// and ensure we don't add invalid functions to the final output. Many
+  /// linkers have issues when dead stripping functions from DWARF debug info
+  /// where they set the DW_AT_low_pc to zero, but newer DWARF has the
+  /// DW_AT_high_pc as an offset from the DW_AT_low_pc and these size
+  /// attributes have no relocations that can be applied. This results in DWARF
+  /// where many functions have an DW_AT_low_pc of zero and a valid offset size
+  /// for DW_AT_high_pc. If we extract all valid ranges from an object file
+  /// that are marked with executable permissions, we can properly ensure that
+  /// these functions are removed.
+  ///
+  /// \param Addr An address to check.
+  ///
+  /// \returns True if the address is in the valid text ranges or if no valid
+  ///          text ranges have been set, false otherwise.
+  bool IsValidTextAddress(uint64_t Addr) const;
+
+  /// Set the base address to use for the GSYM file.
+  ///
+  /// Setting the base address to use for the GSYM file. Object files typically
+  /// get loaded from a base address when the OS loads them into memory. Using
+  /// GSYM files for symbolication becomes easier if the base address in the
+  /// GSYM header is the same address as it allows addresses to be easily slid
+  /// and allows symbolication without needing to find the original base
+  /// address in the original object file.
+  ///
+  /// \param  Addr The address to use as the base address of the GSYM file
+  ///              when it is saved to disk.
+  void setBaseAddress(uint64_t Addr) {
+    BaseAddress = Addr;
+  }
+};
+
+} // namespace gsym
+} // namespace llvm
+
+#endif // #ifndef LLVM_DEBUGINFO_GSYM_GSYMCREATOR_H
diff --git a/linux-x64/clang/include/llvm/DebugInfo/GSYM/GsymReader.h b/linux-x64/clang/include/llvm/DebugInfo/GSYM/GsymReader.h
new file mode 100644
index 0000000..2a4eac7
--- /dev/null
+++ b/linux-x64/clang/include/llvm/DebugInfo/GSYM/GsymReader.h
@@ -0,0 +1,313 @@
+//===- GsymReader.h ---------------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_DEBUGINFO_GSYM_GSYMREADER_H
+#define LLVM_DEBUGINFO_GSYM_GSYMREADER_H
+
+
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/DebugInfo/GSYM/FileEntry.h"
+#include "llvm/DebugInfo/GSYM/FunctionInfo.h"
+#include "llvm/DebugInfo/GSYM/Header.h"
+#include "llvm/DebugInfo/GSYM/LineEntry.h"
+#include "llvm/DebugInfo/GSYM/StringTable.h"
+#include "llvm/Support/DataExtractor.h"
+#include "llvm/Support/Endian.h"
+#include "llvm/Support/ErrorOr.h"
+
+#include <inttypes.h>
+#include <memory>
+#include <stdint.h>
+#include <string>
+#include <vector>
+
+namespace llvm {
+class MemoryBuffer;
+class raw_ostream;
+
+namespace gsym {
+
+/// GsymReader is used to read GSYM data from a file or buffer.
+///
+/// This class is optimized for very quick lookups when the endianness matches
+/// the host system. The Header, address table, address info offsets, and file
+/// table is designed to be mmap'ed as read only into memory and used without
+/// any parsing needed. If the endianness doesn't match, we swap these objects
+/// and tables into GsymReader::SwappedData and then point our header and
+/// ArrayRefs to this swapped internal data.
+///
+/// GsymReader objects must use one of the static functions to create an
+/// instance: GsymReader::openFile(...) and GsymReader::copyBuffer(...).
+
+class GsymReader {
+  GsymReader(std::unique_ptr<MemoryBuffer> Buffer);
+  llvm::Error parse();
+
+  std::unique_ptr<MemoryBuffer> MemBuffer;
+  StringRef GsymBytes;
+  llvm::support::endianness Endian;
+  const Header *Hdr = nullptr;
+  ArrayRef<uint8_t> AddrOffsets;
+  ArrayRef<uint32_t> AddrInfoOffsets;
+  ArrayRef<FileEntry> Files;
+  StringTable StrTab;
+  /// When the GSYM file's endianness doesn't match the host system then
+  /// we must decode all data structures that need to be swapped into
+  /// local storage and set point the ArrayRef objects above to these swapped
+  /// copies.
+  struct SwappedData {
+    Header Hdr;
+    std::vector<uint8_t> AddrOffsets;
+    std::vector<uint32_t> AddrInfoOffsets;
+    std::vector<FileEntry> Files;
+  };
+  std::unique_ptr<SwappedData> Swap;
+
+public:
+  GsymReader(GsymReader &&RHS);
+  ~GsymReader();
+
+  /// Construct a GsymReader from a file on disk.
+  ///
+  /// \param Path The file path the GSYM file to read.
+  /// \returns An expected GsymReader that contains the object or an error
+  /// object that indicates reason for failing to read the GSYM.
+  static llvm::Expected<GsymReader> openFile(StringRef Path);
+
+  /// Construct a GsymReader from a buffer.
+  ///
+  /// \param Bytes A set of bytes that will be copied and owned by the
+  /// returned object on success.
+  /// \returns An expected GsymReader that contains the object or an error
+  /// object that indicates reason for failing to read the GSYM.
+  static llvm::Expected<GsymReader> copyBuffer(StringRef Bytes);
+
+  /// Access the GSYM header.
+  /// \returns A native endian version of the GSYM header.
+  const Header &getHeader() const;
+
+  /// Get the full function info for an address.
+  ///
+  /// This should be called when a client will store a copy of the complete
+  /// FunctionInfo for a given address. For one off lookups, use the lookup()
+  /// function below.
+  ///
+  /// Symbolication server processes might want to parse the entire function
+  /// info for a given address and cache it if the process stays around to
+  /// service many symbolication addresses, like for parsing profiling
+  /// information.
+  ///
+  /// \param Addr A virtual address from the orignal object file to lookup.
+  ///
+  /// \returns An expected FunctionInfo that contains the function info object
+  /// or an error object that indicates reason for failing to lookup the
+  /// address.
+  llvm::Expected<FunctionInfo> getFunctionInfo(uint64_t Addr) const;
+
+  /// Lookup an address in the a GSYM.
+  ///
+  /// Lookup just the information needed for a specific address \a Addr. This
+  /// function is faster that calling getFunctionInfo() as it will only return
+  /// information that pertains to \a Addr and allows the parsing to skip any
+  /// extra information encoded for other addresses. For example the line table
+  /// parsing can stop when a matching LineEntry has been fouhnd, and the
+  /// InlineInfo can stop parsing early once a match has been found and also
+  /// skip information that doesn't match. This avoids memory allocations and
+  /// is much faster for lookups.
+  ///
+  /// \param Addr A virtual address from the orignal object file to lookup.
+  /// \returns An expected LookupResult that contains only the information
+  /// needed for the current address, or an error object that indicates reason
+  /// for failing to lookup the address.
+  llvm::Expected<LookupResult> lookup(uint64_t Addr) const;
+
+  /// Get a string from the string table.
+  ///
+  /// \param Offset The string table offset for the string to retrieve.
+  /// \returns The string from the strin table.
+  StringRef getString(uint32_t Offset) const { return StrTab[Offset]; }
+
+  /// Get the a file entry for the suppplied file index.
+  ///
+  /// Used to convert any file indexes in the FunctionInfo data back into
+  /// files. This function can be used for iteration, but is more commonly used
+  /// for random access when doing lookups.
+  ///
+  /// \param Index An index into the file table.
+  /// \returns An optional FileInfo that will be valid if the file index is
+  /// valid, or llvm::None if the file index is out of bounds,
+  Optional<FileEntry> getFile(uint32_t Index) const {
+    if (Index < Files.size())
+      return Files[Index];
+    return llvm::None;
+  }
+
+  /// Dump the entire Gsym data contained in this object.
+  ///
+  /// \param  OS The output stream to dump to.
+  void dump(raw_ostream &OS);
+
+  /// Dump a FunctionInfo object.
+  ///
+  /// This function will convert any string table indexes and file indexes
+  /// into human readable format.
+  ///
+  /// \param  OS The output stream to dump to.
+  ///
+  /// \param FI The object to dump.
+  void dump(raw_ostream &OS, const FunctionInfo &FI);
+
+  /// Dump a LineTable object.
+  ///
+  /// This function will convert any string table indexes and file indexes
+  /// into human readable format.
+  ///
+  ///
+  /// \param  OS The output stream to dump to.
+  ///
+  /// \param LT The object to dump.
+  void dump(raw_ostream &OS, const LineTable &LT);
+
+  /// Dump a InlineInfo object.
+  ///
+  /// This function will convert any string table indexes and file indexes
+  /// into human readable format.
+  ///
+  /// \param  OS The output stream to dump to.
+  ///
+  /// \param II The object to dump.
+  ///
+  /// \param Indent The indentation as number of spaces. Used for recurive
+  /// dumping.
+  void dump(raw_ostream &OS, const InlineInfo &II, uint32_t Indent = 0);
+
+  /// Dump a FileEntry object.
+  ///
+  /// This function will convert any string table indexes into human readable
+  /// format.
+  ///
+  /// \param  OS The output stream to dump to.
+  ///
+  /// \param FE The object to dump.
+  void dump(raw_ostream &OS, Optional<FileEntry> FE);
+
+  /// Get the number of addresses in this Gsym file.
+  uint32_t getNumAddresses() const {
+    return Hdr->NumAddresses;
+  }
+
+  /// Gets an address from the address table.
+  ///
+  /// Addresses are stored as offsets frrom the gsym::Header::BaseAddress.
+  ///
+  /// \param Index A index into the address table.
+  /// \returns A resolved virtual address for adddress in the address table
+  /// or llvm::None if Index is out of bounds.
+  Optional<uint64_t> getAddress(size_t Index) const;
+
+protected:
+
+  /// Get an appropriate address info offsets array.
+  ///
+  /// The address table in the GSYM file is stored as array of 1, 2, 4 or 8
+  /// byte offsets from the The gsym::Header::BaseAddress. The table is stored
+  /// internally as a array of bytes that are in the correct endianness. When
+  /// we access this table we must get an array that matches those sizes. This
+  /// templatized helper function is used when accessing address offsets in the
+  /// AddrOffsets member variable.
+  ///
+  /// \returns An ArrayRef of an appropriate address offset size.
+  template <class T> ArrayRef<T>
+  getAddrOffsets() const {
+    return ArrayRef<T>(reinterpret_cast<const T *>(AddrOffsets.data()),
+                       AddrOffsets.size()/sizeof(T));
+  }
+
+  /// Get an appropriate address from the address table.
+  ///
+  /// The address table in the GSYM file is stored as array of 1, 2, 4 or 8
+  /// byte address offsets from the The gsym::Header::BaseAddress. The table is
+  /// stored internally as a array of bytes that are in the correct endianness.
+  /// In order to extract an address from the address table we must access the
+  /// address offset using the correct size and then add it to the BaseAddress
+  /// in the header.
+  ///
+  /// \param Index An index into the AddrOffsets array.
+  /// \returns An virtual address that matches the original object file for the
+  /// address as the specified index, or llvm::None if Index is out of bounds.
+  template <class T> Optional<uint64_t>
+  addressForIndex(size_t Index) const {
+    ArrayRef<T> AIO = getAddrOffsets<T>();
+    if (Index < AIO.size())
+      return AIO[Index] + Hdr->BaseAddress;
+    return llvm::None;
+  }
+  /// Lookup an address offset in the AddrOffsets table.
+  ///
+  /// Given an address offset, look it up using a binary search of the
+  /// AddrOffsets table.
+  ///
+  /// \param AddrOffset An address offset, that has already been computed by
+  /// subtracting the gsym::Header::BaseAddress.
+  /// \returns The matching address offset index. This index will be used to
+  /// extract the FunctionInfo data's offset from the AddrInfoOffsets array.
+  template <class T>
+  llvm::Optional<uint64_t> getAddressOffsetIndex(const uint64_t AddrOffset) const {
+    ArrayRef<T> AIO = getAddrOffsets<T>();
+    const auto Begin = AIO.begin();
+    const auto End = AIO.end();
+    auto Iter = std::lower_bound(Begin, End, AddrOffset);
+    // Watch for addresses that fall between the gsym::Header::BaseAddress and
+    // the first address offset.
+    if (Iter == Begin && AddrOffset < *Begin)
+      return llvm::None;
+    if (Iter == End || AddrOffset < *Iter)
+      --Iter;
+    return std::distance(Begin, Iter);
+  }
+
+  /// Create a GSYM from a memory buffer.
+  ///
+  /// Called by both openFile() and copyBuffer(), this function does all of the
+  /// work of parsing the GSYM file and returning an error.
+  ///
+  /// \param MemBuffer A memory buffer that will transfer ownership into the
+  /// GsymReader.
+  /// \returns An expected GsymReader that contains the object or an error
+  /// object that indicates reason for failing to read the GSYM.
+  static llvm::Expected<llvm::gsym::GsymReader>
+  create(std::unique_ptr<MemoryBuffer> &MemBuffer);
+
+
+  /// Given an address, find the address index.
+  ///
+  /// Binary search the address table and find the matching address index.
+  ///
+  /// \param Addr A virtual address that matches the original object file
+  /// to lookup.
+  /// \returns An index into the address table. This index can be used to
+  /// extract the FunctionInfo data's offset from the AddrInfoOffsets array.
+  /// Returns an error if the address isn't in the GSYM with details of why.
+  Expected<uint64_t> getAddressIndex(const uint64_t Addr) const;
+
+  /// Given an address index, get the offset for the FunctionInfo.
+  ///
+  /// Looking up an address is done by finding the corresponding address
+  /// index for the address. This index is then used to get the offset of the
+  /// FunctionInfo data that we will decode using this function.
+  ///
+  /// \param Index An index into the address table.
+  /// \returns An optional GSYM data offset for the offset of the FunctionInfo
+  /// that needs to be decoded.
+  Optional<uint64_t> getAddressInfoOffset(size_t Index) const;
+};
+
+} // namespace gsym
+} // namespace llvm
+
+#endif // #ifndef LLVM_DEBUGINFO_GSYM_GSYMREADER_H
diff --git a/linux-x64/clang/include/llvm/DebugInfo/GSYM/Header.h b/linux-x64/clang/include/llvm/DebugInfo/GSYM/Header.h
new file mode 100644
index 0000000..6652c59
--- /dev/null
+++ b/linux-x64/clang/include/llvm/DebugInfo/GSYM/Header.h
@@ -0,0 +1,129 @@
+//===- Header.h -------------------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_DEBUGINFO_GSYM_HEADER_H
+#define LLVM_DEBUGINFO_GSYM_HEADER_H
+
+#include "llvm/Support/Error.h"
+
+#include <cstddef>
+#include <cstdint>
+
+namespace llvm {
+class raw_ostream;
+class DataExtractor;
+
+namespace gsym {
+class FileWriter;
+
+constexpr uint32_t GSYM_MAGIC = 0x4753594d; // 'GSYM'
+constexpr uint32_t GSYM_CIGAM = 0x4d595347; // 'MYSG'
+constexpr uint32_t GSYM_VERSION = 1;
+constexpr size_t GSYM_MAX_UUID_SIZE = 20;
+
+/// The GSYM header.
+///
+/// The GSYM header is found at the start of a stand alone GSYM file, or as
+/// the first bytes in a section when GSYM is contained in a section of an
+/// executable file (ELF, mach-o, COFF).
+///
+/// The structure is encoded exactly as it appears in the structure definition
+/// with no gaps between members. Alignment should not change from system to
+/// system as the members were laid out so that they shouldn't align
+/// differently on different architectures.
+///
+/// When endianness of the system loading a GSYM file matches, the file can
+/// be mmap'ed in and a pointer to the header can be cast to the first bytes
+/// of the file (stand alone GSYM file) or section data (GSYM in a section).
+/// When endianness is swapped, the Header::decode() function should be used to
+/// decode the header.
+struct Header {
+  /// The magic bytes should be set to GSYM_MAGIC. This helps detect if a file
+  /// is a GSYM file by scanning the first 4 bytes of a file or section.
+  /// This value might appear byte swapped
+  uint32_t Magic;
+  /// The version can number determines how the header is decoded and how each
+  /// InfoType in FunctionInfo is encoded/decoded. As version numbers increase,
+  /// "Magic" and "Version" members should always appear at offset zero and 4
+  /// respectively to ensure clients figure out if they can parse the format.
+  uint16_t Version;
+  /// The size in bytes of each address offset in the address offsets table.
+  uint8_t AddrOffSize;
+  /// The size in bytes of the UUID encoded in the "UUID" member.
+  uint8_t UUIDSize;
+  /// The 64 bit base address that all address offsets in the address offsets
+  /// table are relative to. Storing a full 64 bit address allows our address
+  /// offsets table to be smaller on disk.
+  uint64_t BaseAddress;
+  /// The number of addresses stored in the address offsets table.
+  uint32_t NumAddresses;
+  /// The file relative offset of the start of the string table for strings
+  /// contained in the GSYM file. If the GSYM in contained in a stand alone
+  /// file this will be the file offset of the start of the string table. If
+  /// the GSYM is contained in a section within an executable file, this can
+  /// be the offset of the first string used in the GSYM file and can possibly
+  /// span one or more executable string tables. This allows the strings to
+  /// share string tables in an ELF or mach-o file.
+  uint32_t StrtabOffset;
+  /// The size in bytes of the string table. For a stand alone GSYM file, this
+  /// will be the exact size in bytes of the string table. When the GSYM data
+  /// is in a section within an executable file, this size can span one or more
+  /// sections that contains strings. This allows any strings that are already
+  /// stored in the executable file to be re-used, and any extra strings could
+  /// be added to another string table and the string table offset and size
+  /// can be set to span all needed string tables.
+  uint32_t StrtabSize;
+  /// The UUID of the original executable file. This is stored to allow
+  /// matching a GSYM file to an executable file when symbolication is
+  /// required. Only the first "UUIDSize" bytes of the UUID are valid. Any
+  /// bytes in the UUID value that appear after the first UUIDSize bytes should
+  /// be set to zero.
+  uint8_t UUID[GSYM_MAX_UUID_SIZE];
+
+  /// Check if a header is valid and return an error if anything is wrong.
+  ///
+  /// This function can be used prior to encoding a header to ensure it is
+  /// valid, or after decoding a header to ensure it is valid and supported.
+  ///
+  /// Check a correctly byte swapped header for errors:
+  ///   - check magic value
+  ///   - check that version number is supported
+  ///   - check that the address offset size is supported
+  ///   - check that the UUID size is valid
+  ///
+  /// \returns An error if anything is wrong in the header, or Error::success()
+  /// if there are no errors.
+  llvm::Error checkForError() const;
+
+  /// Decode an object from a binary data stream.
+  ///
+  /// \param Data The binary stream to read the data from. This object must
+  /// have the data for the object starting at offset zero. The data
+  /// can contain more data than needed.
+  ///
+  /// \returns A Header or an error describing the issue that was
+  /// encountered during decoding.
+  static llvm::Expected<Header> decode(DataExtractor &Data);
+
+  /// Encode this object into FileWriter stream.
+  ///
+  /// \param O The binary stream to write the data to at the current file
+  /// position.
+  ///
+  /// \returns An error object that indicates success or failure of the
+  /// encoding process.
+  llvm::Error encode(FileWriter &O) const;
+};
+
+bool operator==(const Header &LHS, const Header &RHS);
+raw_ostream &operator<<(raw_ostream &OS, const llvm::gsym::Header &H);
+
+} // namespace gsym
+} // namespace llvm
+
+#endif // #ifndef LLVM_DEBUGINFO_GSYM_HEADER_H
diff --git a/linux-x64/clang/include/llvm/DebugInfo/GSYM/InlineInfo.h b/linux-x64/clang/include/llvm/DebugInfo/GSYM/InlineInfo.h
index 2224306..06126da 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/GSYM/InlineInfo.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/GSYM/InlineInfo.h
@@ -1,9 +1,8 @@
 //===- InlineInfo.h ---------------------------------------------*- C++ -*-===//
 //
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
@@ -11,7 +10,10 @@
 #define LLVM_DEBUGINFO_GSYM_INLINEINFO_H
 
 #include "llvm/ADT/Optional.h"
+#include "llvm/DebugInfo/GSYM/LineEntry.h"
+#include "llvm/DebugInfo/GSYM/LookupResult.h"
 #include "llvm/DebugInfo/GSYM/Range.h"
+#include "llvm/Support/Error.h"
 #include <stdint.h>
 #include <vector>
 
@@ -21,6 +23,7 @@
 
 namespace gsym {
 
+class GsymReader;
 /// Inline information stores the name of the inline function along with
 /// an array of address ranges. It also stores the call file and call line
 /// that called this inline function. This allows us to unwind inline call
@@ -31,6 +34,30 @@
 /// Any clients that encode information will need to ensure the ranges are
 /// all contined correctly or lookups could fail. Add ranges in these objects
 /// must be contained in the top level FunctionInfo address ranges as well.
+///
+/// ENCODING
+///
+/// When saved to disk, the inline info encodes all ranges to be relative to
+/// a parent address range. This will be the FunctionInfo's start address if
+/// the InlineInfo is directly contained in a FunctionInfo, or a the start
+/// address of the containing parent InlineInfo's first "Ranges" member. This
+/// allows address ranges to be efficiently encoded using ULEB128 encodings as
+/// we encode the offset and size of each range instead of full addresses. This
+/// also makes any encoded addresses easy to relocate as we just need to
+/// relocate the FunctionInfo's start address.
+///
+/// - The AddressRanges member "Ranges" is encoded using an appropriate base
+///   address as described above.
+/// - UINT8 boolean value that specifies if the InlineInfo object has children.
+/// - UINT32 string table offset that points to the name of the inline
+///   function.
+/// - ULEB128 integer that specifies the file of the call site that called
+///   this function.
+/// - ULEB128 integer that specifies the source line of the call site that
+///   called this function.
+/// - if this object has children, enocode each child InlineInfo using the
+///   the first address range's start address as the base address.
+///
 struct InlineInfo {
 
   uint32_t Name; ///< String table offset in the string table.
@@ -50,6 +77,52 @@
 
   using InlineArray = std::vector<const InlineInfo *>;
 
+  /// Lookup a single address within the inline info data.
+  ///
+  /// Clients have the option to decode an entire InlineInfo object (using
+  /// InlineInfo::decode() ) or just find the matching inline info using this
+  /// function. The benefit of using this function is that only the information
+  /// needed for the lookup will be extracted, other info can be skipped and
+  /// parsing can stop as soon as the deepest match is found. This allows
+  /// symbolication tools to be fast and efficient and avoid allocation costs
+  /// when doing lookups.
+  ///
+  /// This function will augment the SourceLocations array \a SrcLocs with any
+  /// inline information that pertains to \a Addr. If no inline information
+  /// exists for \a Addr, then \a SrcLocs will be left untouched. If there is
+  /// inline information for \a Addr, then \a SrcLocs will be modifiied to
+  /// contain the deepest most inline function's SourceLocation at index zero
+  /// in the array and proceed up the the concrete function source file and
+  /// line at the end of the array.
+  ///
+  /// \param GR The GSYM reader that contains the string and file table that
+  /// will be used to fill in the source locations.
+  ///
+  /// \param Data The binary stream to read the data from. This object must
+  /// have the data for the LineTable object starting at offset zero. The data
+  /// can contain more data than needed.
+  ///
+  /// \param BaseAddr The base address to use when decoding the line table.
+  /// This will be the FunctionInfo's start address and will be used to
+  /// decode the correct addresses for the inline information.
+  ///
+  /// \param Addr The address to lookup.
+  ///
+  /// \param SrcLocs The inline source locations that matches \a Addr. This
+  ///                array must be initialized with the matching line entry
+  ///                from the line table upon entry. The name of the concrete
+  ///                function must be supplied since it will get pushed to
+  ///                the last SourceLocation entry and the inline information
+  ///                will fill in the source file and line from the inline
+  ///                information.
+  ///
+  /// \returns An error if the inline information is corrupt, or
+  ///          Error::success() for all other cases, even when no information
+  ///          is added to \a SrcLocs.
+  static llvm::Error lookup(const GsymReader &GR, DataExtractor &Data,
+                            uint64_t BaseAddr, uint64_t Addr,
+                            SourceLocations &SrcLocs);
+
   /// Lookup an address in the InlineInfo object
   ///
   /// This function is used to symbolicate an inline call stack and can
@@ -62,6 +135,37 @@
   /// \returns optional vector of InlineInfo objects that describe the
   /// inline call stack for a given address, false otherwise.
   llvm::Optional<InlineArray> getInlineStack(uint64_t Addr) const;
+
+  /// Decode an InlineInfo object from a binary data stream.
+  ///
+  /// \param Data The binary stream to read the data from. This object must
+  /// have the data for the InlineInfo object starting at offset zero. The data
+  /// can contain more data than needed.
+  ///
+  /// \param BaseAddr The base address to use when decoding all address ranges.
+  /// This will be the FunctionInfo's start address if this object is directly
+  /// contained in a FunctionInfo object, or the start address of the first
+  /// address range in an InlineInfo object of this object is a child of
+  /// another InlineInfo object.
+  /// \returns An InlineInfo or an error describing the issue that was
+  /// encountered during decoding.
+  static llvm::Expected<InlineInfo> decode(DataExtractor &Data,
+                                           uint64_t BaseAddr);
+
+  /// Encode this InlineInfo object into FileWriter stream.
+  ///
+  /// \param O The binary stream to write the data to at the current file
+  /// position.
+  ///
+  /// \param BaseAddr The base address to use when encoding all address ranges.
+  /// This will be the FunctionInfo's start address if this object is directly
+  /// contained in a FunctionInfo object, or the start address of the first
+  /// address range in an InlineInfo object of this object is a child of
+  /// another InlineInfo object.
+  ///
+  /// \returns An error object that indicates success or failure or the
+  /// encoding process.
+  llvm::Error encode(FileWriter &O, uint64_t BaseAddr) const;
 };
 
 inline bool operator==(const InlineInfo &LHS, const InlineInfo &RHS) {
diff --git a/linux-x64/clang/include/llvm/DebugInfo/GSYM/LineEntry.h b/linux-x64/clang/include/llvm/DebugInfo/GSYM/LineEntry.h
index 6b93809..aac7c48 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/GSYM/LineEntry.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/GSYM/LineEntry.h
@@ -1,9 +1,8 @@
 //===- LineEntry.h ----------------------------------------------*- C++ -*-===//
 //
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/linux-x64/clang/include/llvm/DebugInfo/GSYM/LineTable.h b/linux-x64/clang/include/llvm/DebugInfo/GSYM/LineTable.h
new file mode 100644
index 0000000..fba9b2c
--- /dev/null
+++ b/linux-x64/clang/include/llvm/DebugInfo/GSYM/LineTable.h
@@ -0,0 +1,233 @@
+//===- LineTable.h ----------------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_DEBUGINFO_GSYM_LINETABLE_H
+#define LLVM_DEBUGINFO_GSYM_LINETABLE_H
+
+#include "llvm/DebugInfo/GSYM/LineEntry.h"
+#include "llvm/Support/Error.h"
+#include <cstdint>
+#include <vector>
+
+namespace llvm {
+namespace gsym {
+
+struct FunctionInfo;
+class FileWriter;
+
+/// LineTable class contains deserialized versions of line tables for each
+/// function's address ranges.
+///
+/// When saved to disk, the line table is encoded using a modified version of
+/// the DWARF line tables that only tracks address to source file and line.
+///
+/// ENCODING
+///
+/// The line table starts with a small prolog that contains the following
+/// values:
+///
+/// ENCODING NAME        DESCRIPTION
+/// ======== =========== ====================================================
+/// SLEB     MinDelta    The min line delta for special opcodes that  advance
+///                      the address and line number.
+/// SLEB     MaxDelta    The max line delta for single byte opcodes that
+///                      advance the address and line number.
+/// ULEB     FirstLine   The value of the first source line number to
+///                      initialize the LineEntry with.
+///
+/// Once these prolog items are read, we initialize a LineEntry struct with
+/// the start address of the function from the FunctionInfo's address range,
+/// a default file index of 1, and the line number set to "FirstLine" from
+/// the prolog above:
+///
+///   LineEntry Row(BaseAddr, 1, FirstLine);
+///
+/// The line table state machine is now initialized and ready to be parsed.
+/// The stream that follows this encodes the line entries in a compact
+/// form. Some opcodes cause "Row" to be modified and some opcodes may also
+/// push "Row" onto the end of the "LineTable.Lines" vector. The end result
+/// is a vector of LineEntry structs that is sorted in ascending address
+/// order.
+///
+/// NORMAL OPCODES
+///
+/// The opcodes 0 through 3 are normal in opcodes. Their encoding and
+/// descriptions are listed below:
+///
+/// ENCODING ENUMERATION       VALUE DESCRIPTION
+/// ======== ================  ===== ========================================
+///          LTOC_EndSequence  0x00  Parsing is done.
+/// ULEB     LTOC_SetFile      0x01  Row.File = ULEB
+/// ULEB     LTOC_AdvancePC    0x02  Row.Addr += ULEB, push "Row".
+/// SLEB     LTOC_AdvanceLine  0x03  Row.Line += SLEB
+///          LTOC_FirstSpecial 0x04  First special opcode (see SPECIAL
+///                                  OPCODES below).
+///
+/// SPECIAL OPCODES
+///
+/// Opcodes LTOC_FirstSpecial through 255 are special opcodes that always
+/// increment both the Row.Addr and Row.Line and push "Row" onto the
+/// LineEntry.Lines array. They do this by using some of the bits to
+/// increment/decrement the source line number, and some of the bits to
+/// increment the address. Line numbers can go up or down when making line
+/// tables, where addresses always only increase since line tables are sorted
+/// by address.
+///
+/// In order to calculate the amount to increment the line and address for
+/// these special opcodes, we calculate the number of values reserved for the
+/// line increment/decrement using the "MinDelta" and "MaxDelta" from the
+/// prolog:
+///
+///     const int64_t LineRange = MaxDelta - MinDelta + 1;
+///
+/// Then we can adjust the opcode to not include any of the normal opcodes:
+///
+///     const uint8_t AdjustedOp = Opcode - LTOC_FirstSpecial;
+///
+/// And we can calculate the line offset, and address offset:
+///
+///     const int64_t LineDelta = MinDelta + (AdjustedOp % LineRange);
+///     const uint64_t AddrDelta = (AdjustedOp / LineRange);
+///
+/// And use these to modify our "Row":
+///
+///     Row.Line += LineDelta;
+///     Row.Addr += AddrDelta;
+///
+/// And push a row onto the line table:
+///
+///     Lines.push_back(Row);
+///
+/// This is verify similar to the way that DWARF encodes its line tables. The
+/// only difference is the DWARF line tables have more normal opcodes and the
+/// "Row" contains more members, like source column number, bools for end of
+/// prologue, beginnging of epilogue, is statement and many others. There are
+/// also more complex rules that happen for the extra normal opcodes. By
+/// leaving these extra opcodes out, we leave more bits for the special
+/// opcodes that allows us to encode line tables in fewer bytes than standard
+/// DWARF encodings.
+///
+/// Opcodes that will push "Row" onto the LineEntry.Lines include the
+/// LTOC_AdvancePC opcode and all special opcodes. All other opcodes
+/// only modify the current "Row", or cause the line table to end.
+class LineTable {
+  typedef std::vector<gsym::LineEntry> Collection;
+  Collection Lines; ///< All line entries in the line table.
+public:
+  /// Lookup a single address within a line table's data.
+  ///
+  /// Clients have the option to decode an entire line table using
+  /// LineTable::decode() or just find a single matching entry using this
+  /// function. The benefit of using this function is that parsed LineEntry
+  /// objects that do not match will not be stored in an array. This will avoid
+  /// memory allocation costs and parsing can stop once a match has been found.
+  ///
+  /// \param Data The binary stream to read the data from. This object must
+  /// have the data for the LineTable object starting at offset zero. The data
+  /// can contain more data than needed.
+  ///
+  /// \param BaseAddr The base address to use when decoding the line table.
+  /// This will be the FunctionInfo's start address and will be used to
+  /// initialize the line table row prior to parsing any opcodes.
+  ///
+  /// \returns An LineEntry object if a match is found, error otherwise.
+  static Expected<LineEntry> lookup(DataExtractor &Data, uint64_t BaseAddr,
+                                    uint64_t Addr);
+
+  /// Decode an LineTable object from a binary data stream.
+  ///
+  /// \param Data The binary stream to read the data from. This object must
+  /// have the data for the LineTable object starting at offset zero. The data
+  /// can contain more data than needed.
+  ///
+  /// \param BaseAddr The base address to use when decoding the line table.
+  /// This will be the FunctionInfo's start address and will be used to
+  /// initialize the line table row prior to parsing any opcodes.
+  ///
+  /// \returns An LineTable or an error describing the issue that was
+  /// encountered during decoding.
+  static llvm::Expected<LineTable> decode(DataExtractor &Data,
+                                          uint64_t BaseAddr);
+  /// Encode this LineTable object into FileWriter stream.
+  ///
+  /// \param O The binary stream to write the data to at the current file
+  /// position.
+  ///
+  /// \param BaseAddr The base address to use when decoding the line table.
+  /// This will be the FunctionInfo's start address.
+  ///
+  /// \returns An error object that indicates success or failure or the
+  /// encoding process.
+  llvm::Error encode(FileWriter &O, uint64_t BaseAddr) const;
+  bool empty() const { return Lines.empty(); }
+  void clear() { Lines.clear(); }
+  /// Return the first line entry if the line table isn't empty.
+  ///
+  /// \returns An optional line entry with the first line entry if the line
+  /// table isn't empty, or llvm::None if the line table is emtpy.
+  Optional<LineEntry> first() const {
+    if (Lines.empty())
+      return llvm::None;
+    return Lines.front();
+  }
+  /// Return the last line entry if the line table isn't empty.
+  ///
+  /// \returns An optional line entry with the last line entry if the line
+  /// table isn't empty, or llvm::None if the line table is emtpy.
+  Optional<LineEntry> last() const {
+    if (Lines.empty())
+      return llvm::None;
+    return Lines.back();
+  }
+  void push(const LineEntry &LE) {
+    Lines.push_back(LE);
+  }
+  size_t isValid() const {
+    return !Lines.empty();
+  }
+  size_t size() const {
+    return Lines.size();
+  }
+  LineEntry &get(size_t i) {
+    assert(i < Lines.size());
+    return Lines[i];
+  }
+  const LineEntry &get(size_t i) const {
+    assert(i < Lines.size());
+    return Lines[i];
+  }
+  LineEntry &operator[](size_t i) {
+    return get(i);
+  }
+  const LineEntry &operator[](size_t i) const {
+    return get(i);
+  }
+  bool operator==(const LineTable &RHS) const {
+    return Lines == RHS.Lines;
+  }
+  bool operator!=(const LineTable &RHS) const {
+    return Lines != RHS.Lines;
+  }
+  bool operator<(const LineTable &RHS) const {
+    const auto LHSSize = Lines.size();
+    const auto RHSSize = RHS.Lines.size();
+    if (LHSSize == RHSSize)
+      return Lines < RHS.Lines;
+    return LHSSize < RHSSize;
+  }
+  Collection::const_iterator begin() const { return Lines.begin(); }
+  Collection::const_iterator end() const { return Lines.end(); }
+
+};
+
+raw_ostream &operator<<(raw_ostream &OS, const gsym::LineTable &LT);
+
+} // namespace gsym
+} // namespace llvm
+
+#endif // #ifndef LLVM_DEBUGINFO_GSYM_LINETABLE_H
diff --git a/linux-x64/clang/include/llvm/DebugInfo/GSYM/LookupResult.h b/linux-x64/clang/include/llvm/DebugInfo/GSYM/LookupResult.h
new file mode 100644
index 0000000..693a02c
--- /dev/null
+++ b/linux-x64/clang/include/llvm/DebugInfo/GSYM/LookupResult.h
@@ -0,0 +1,63 @@
+//===- LookupResult.h -------------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_DEBUGINFO_GSYM_LOOKUPRESULT_H
+#define LLVM_DEBUGINFO_GSYM_LOOKUPRESULT_H
+
+#include "llvm/DebugInfo/GSYM/Range.h"
+#include "llvm/ADT/StringRef.h"
+#include <inttypes.h>
+#include <vector>
+
+namespace llvm {
+class raw_ostream;
+namespace gsym {
+struct FileEntry;
+
+struct SourceLocation {
+  StringRef Name; ///< Function or symbol name.
+  StringRef Dir; ///< Line entry source file directory path.
+  StringRef Base; ///< Line entry source file basename.
+  uint32_t Line = 0; ///< Source file line number.
+  uint32_t Offset = 0; ///< Byte size offset within the named function.
+};
+
+inline bool operator==(const SourceLocation &LHS, const SourceLocation &RHS) {
+  return LHS.Name == RHS.Name && LHS.Dir == RHS.Dir &&
+         LHS.Base == RHS.Base && LHS.Line == RHS.Line &&
+         LHS.Offset == RHS.Offset;
+}
+
+raw_ostream &operator<<(raw_ostream &OS, const SourceLocation &R);
+
+using SourceLocations = std::vector<SourceLocation>;
+
+
+struct LookupResult {
+  uint64_t LookupAddr = 0; ///< The address that this lookup pertains to.
+  AddressRange FuncRange; ///< The concrete function address range.
+  StringRef FuncName; ///< The concrete function name that contains LookupAddr.
+  /// The source locations that match this address. This information will only
+  /// be filled in if the FunctionInfo contains a line table. If an address is
+  /// for a concrete function with no inlined functions, this array will have
+  /// one entry. If an address points to an inline function, there will be one
+  /// SourceLocation for each inlined function with the last entry pointing to
+  /// the concrete function itself. This allows one address to generate
+  /// multiple locations and allows unwinding of inline call stacks. The
+  /// deepest inline function will appear at index zero in the source locations
+  /// array, and the concrete function will appear at the end of the array.
+  SourceLocations Locations;
+  std::string getSourceFile(uint32_t Index) const;
+};
+
+raw_ostream &operator<<(raw_ostream &OS, const LookupResult &R);
+
+} // namespace gsym
+} // namespace llvm
+
+#endif // #ifndef LLVM_DEBUGINFO_GSYM_LOOKUPRESULT_H
diff --git a/linux-x64/clang/include/llvm/DebugInfo/GSYM/ObjectFileTransformer.h b/linux-x64/clang/include/llvm/DebugInfo/GSYM/ObjectFileTransformer.h
new file mode 100644
index 0000000..84a8d98
--- /dev/null
+++ b/linux-x64/clang/include/llvm/DebugInfo/GSYM/ObjectFileTransformer.h
@@ -0,0 +1,51 @@
+//===- ObjectFileTransformer.h ----------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_DEBUGINFO_GSYM_OBJECTFILETRANSFORMER_H
+#define LLVM_DEBUGINFO_GSYM_OBJECTFILETRANSFORMER_H
+
+#include "llvm/Support/Error.h"
+
+namespace llvm {
+
+class raw_ostream;
+
+namespace object {
+class ObjectFile;
+}
+
+namespace gsym {
+
+struct CUInfo;
+class GsymCreator;
+
+class ObjectFileTransformer {
+public:
+  /// Extract any object file data that is needed by the GsymCreator.
+  ///
+  /// The extracted information includes the UUID of the binary and converting
+  /// all function symbols from any symbol tables into FunctionInfo objects.
+  ///
+  /// \param Obj The object file that contains the DWARF debug info.
+  ///
+  /// \param Log The stream to log warnings and non fatal issues to.
+  ///
+  /// \param Gsym The GSYM creator to populate with the function information
+  /// from the debug info.
+  ///
+  /// \returns An error indicating any fatal issues that happen when parsing
+  /// the DWARF, or Error::success() if all goes well.
+  static llvm::Error convert(const object::ObjectFile &Obj,
+                             raw_ostream &Log,
+                             GsymCreator &Gsym);
+};
+
+} // namespace gsym
+} // namespace llvm
+
+#endif // #ifndef LLVM_DEBUGINFO_GSYM_OBJECTFILETRANSFORMER_H
diff --git a/linux-x64/clang/include/llvm/DebugInfo/GSYM/Range.h b/linux-x64/clang/include/llvm/DebugInfo/GSYM/Range.h
index 772ff24..b3e7692 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/GSYM/Range.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/GSYM/Range.h
@@ -1,15 +1,15 @@
-//===- AddressRange.h -------------------------------------------*- C++ -*-===//
+//===- Range.h --------------------------------------------------*- C++ -*-===//
 //
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_GSYM_RANGE_H
 #define LLVM_DEBUGINFO_GSYM_RANGE_H
 
+#include "llvm/ADT/Optional.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/raw_ostream.h"
 #include <stdint.h>
@@ -21,10 +21,13 @@
 #define HEX64(v) llvm::format_hex(v, 18)
 
 namespace llvm {
+class DataExtractor;
 class raw_ostream;
 
 namespace gsym {
 
+class FileWriter;
+
 /// A class that represents an address range. The range is specified using
 /// a start and an end address.
 struct AddressRange {
@@ -47,6 +50,26 @@
   bool operator<(const AddressRange &R) const {
     return std::make_pair(Start, End) < std::make_pair(R.Start, R.End);
   }
+  /// AddressRange objects are encoded and decoded to be relative to a base
+  /// address. This will be the FunctionInfo's start address if the AddressRange
+  /// is directly contained in a FunctionInfo, or a base address of the
+  /// containing parent AddressRange or AddressRanges. This allows address
+  /// ranges to be efficiently encoded using ULEB128 encodings as we encode the
+  /// offset and size of each range instead of full addresses. This also makes
+  /// encoded addresses easy to relocate as we just need to relocate one base
+  /// address.
+  /// @{
+  void decode(DataExtractor &Data, uint64_t BaseAddr, uint64_t &Offset);
+  void encode(FileWriter &O, uint64_t BaseAddr) const;
+  /// @}
+
+  /// Skip an address range object in the specified data a the specified
+  /// offset.
+  ///
+  /// \param Data The binary stream to read the data from.
+  ///
+  /// \param Offset The byte offset within \a Data.
+  static void skip(DataExtractor &Data, uint64_t &Offset);
 };
 
 raw_ostream &operator<<(raw_ostream &OS, const AddressRange &R);
@@ -66,6 +89,8 @@
   void clear() { Ranges.clear(); }
   bool empty() const { return Ranges.empty(); }
   bool contains(uint64_t Addr) const;
+  bool contains(AddressRange Range) const;
+  Optional<AddressRange> getRangeThatContains(uint64_t Addr) const;
   void insert(AddressRange Range);
   size_t size() const { return Ranges.size(); }
   bool operator==(const AddressRanges &RHS) const {
@@ -77,6 +102,24 @@
   }
   Collection::const_iterator begin() const { return Ranges.begin(); }
   Collection::const_iterator end() const { return Ranges.end(); }
+
+  /// Address ranges are decoded and encoded to be relative to a base address.
+  /// See the AddressRange comment for the encode and decode methods for full
+  /// details.
+  /// @{
+  void decode(DataExtractor &Data, uint64_t BaseAddr, uint64_t &Offset);
+  void encode(FileWriter &O, uint64_t BaseAddr) const;
+  /// @}
+
+  /// Skip an address range object in the specified data a the specified
+  /// offset.
+  ///
+  /// \param Data The binary stream to read the data from.
+  ///
+  /// \param Offset The byte offset within \a Data.
+  ///
+  /// \returns The number of address ranges that were skipped.
+  static uint64_t skip(DataExtractor &Data, uint64_t &Offset);
 };
 
 raw_ostream &operator<<(raw_ostream &OS, const AddressRanges &AR);
diff --git a/linux-x64/clang/include/llvm/DebugInfo/GSYM/StringTable.h b/linux-x64/clang/include/llvm/DebugInfo/GSYM/StringTable.h
index 0001b8b..a96ae58 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/GSYM/StringTable.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/GSYM/StringTable.h
@@ -1,9 +1,8 @@
 //===- StringTable.h --------------------------------------------*- C++ -*-===//
 //
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/linux-x64/clang/include/llvm/DebugInfo/MSF/MappedBlockStream.h b/linux-x64/clang/include/llvm/DebugInfo/MSF/MappedBlockStream.h
index 593d781..473c89e 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/MSF/MappedBlockStream.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/MSF/MappedBlockStream.h
@@ -24,8 +24,6 @@
 namespace llvm {
 namespace msf {
 
-struct MSFLayout;
-
 /// MappedBlockStream represents data stored in an MSF file into chunks of a
 /// particular size (called the Block Size), and whose chunks may not be
 /// necessarily contiguous.  The arrangement of these chunks MSF the file
diff --git a/linux-x64/clang/include/llvm/DebugInfo/PDB/DIA/DIAInjectedSource.h b/linux-x64/clang/include/llvm/DebugInfo/PDB/DIA/DIAInjectedSource.h
index 8be06f8..67963a0 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/PDB/DIA/DIAInjectedSource.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/PDB/DIA/DIAInjectedSource.h
@@ -25,7 +25,7 @@
   std::string getFileName() const override;
   std::string getObjectFileName() const override;
   std::string getVirtualFileName() const override;
-  PDB_SourceCompression getCompression() const override;
+  uint32_t getCompression() const override;
   std::string getCode() const override;
 
 private:
diff --git a/linux-x64/clang/include/llvm/DebugInfo/PDB/DIA/DIASession.h b/linux-x64/clang/include/llvm/DebugInfo/PDB/DIA/DIASession.h
index 6f62e60..09ab9e2 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/PDB/DIA/DIASession.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/PDB/DIA/DIASession.h
@@ -38,13 +38,13 @@
   bool addressForRVA(uint32_t RVA, uint32_t &Section,
                      uint32_t &Offset) const override;
 
-  std::unique_ptr<PDBSymbol>
-  findSymbolByAddress(uint64_t Address, PDB_SymType Type) const override;
+  std::unique_ptr<PDBSymbol> findSymbolByAddress(uint64_t Address,
+                                                 PDB_SymType Type) override;
   std::unique_ptr<PDBSymbol> findSymbolByRVA(uint32_t RVA,
-                                             PDB_SymType Type) const override;
-  std::unique_ptr<PDBSymbol>
-  findSymbolBySectOffset(uint32_t Section, uint32_t Offset,
-                         PDB_SymType Type) const override;
+                                             PDB_SymType Type) override;
+  std::unique_ptr<PDBSymbol> findSymbolBySectOffset(uint32_t Section,
+                                                    uint32_t Offset,
+                                                    PDB_SymType Type) override;
 
   std::unique_ptr<IPDBEnumLineNumbers>
   findLineNumbers(const PDBSymbolCompiland &Compiland,
diff --git a/linux-x64/clang/include/llvm/DebugInfo/PDB/GenericError.h b/linux-x64/clang/include/llvm/DebugInfo/PDB/GenericError.h
index ec85d92..1ef9b36 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/PDB/GenericError.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/PDB/GenericError.h
@@ -9,7 +9,6 @@
 #ifndef LLVM_DEBUGINFO_PDB_ERROR_H
 #define LLVM_DEBUGINFO_PDB_ERROR_H
 
-#include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Error.h"
 
 namespace llvm {
@@ -20,7 +19,7 @@
   dia_sdk_not_present,
   dia_failed_loading,
   signature_out_of_date,
-  external_cmdline_ref,
+  no_matching_pch,
   unspecified,
 };
 } // namespace pdb
diff --git a/linux-x64/clang/include/llvm/DebugInfo/PDB/IPDBInjectedSource.h b/linux-x64/clang/include/llvm/DebugInfo/PDB/IPDBInjectedSource.h
index 56e85d1..6ee6c7c 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/PDB/IPDBInjectedSource.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/PDB/IPDBInjectedSource.h
@@ -9,16 +9,11 @@
 #ifndef LLVM_DEBUGINFO_PDB_IPDBINJECTEDSOURCE_H
 #define LLVM_DEBUGINFO_PDB_IPDBINJECTEDSOURCE_H
 
-#include "PDBTypes.h"
-#include "llvm/Support/raw_ostream.h"
-#include <memory>
+#include <cstdint>
 #include <string>
 
 namespace llvm {
-class raw_ostream;
-
 namespace pdb {
-
 /// IPDBInjectedSource defines an interface used to represent source files
 /// which were injected directly into the PDB file during the compilation
 /// process.  This is used, for example, to add natvis files to a PDB, but
@@ -32,7 +27,10 @@
   virtual std::string getFileName() const = 0;
   virtual std::string getObjectFileName() const = 0;
   virtual std::string getVirtualFileName() const = 0;
-  virtual PDB_SourceCompression getCompression() const = 0;
+  // The returned value depends on the PDB producer,
+  // but 0 is guaranteed to mean "no compression".
+  // The enum PDB_SourceCompression lists known return values.
+  virtual uint32_t getCompression() const = 0;
   virtual std::string getCode() const = 0;
 };
 } // namespace pdb
diff --git a/linux-x64/clang/include/llvm/DebugInfo/PDB/IPDBLineNumber.h b/linux-x64/clang/include/llvm/DebugInfo/PDB/IPDBLineNumber.h
index 77e8899..47b6397 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/PDB/IPDBLineNumber.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/PDB/IPDBLineNumber.h
@@ -9,7 +9,7 @@
 #ifndef LLVM_DEBUGINFO_PDB_IPDBLINENUMBER_H
 #define LLVM_DEBUGINFO_PDB_IPDBLINENUMBER_H
 
-#include "PDBTypes.h"
+#include <cstdint>
 
 namespace llvm {
 namespace pdb {
diff --git a/linux-x64/clang/include/llvm/DebugInfo/PDB/IPDBRawSymbol.h b/linux-x64/clang/include/llvm/DebugInfo/PDB/IPDBRawSymbol.h
index b24e712..f59e933 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/PDB/IPDBRawSymbol.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/PDB/IPDBRawSymbol.h
@@ -12,19 +12,15 @@
 #include "PDBTypes.h"
 #include "llvm/ADT/BitmaskEnum.h"
 #include "llvm/ADT/SmallVector.h"
-#include "llvm/ADT/StringRef.h"
 #include "llvm/DebugInfo/CodeView/CodeView.h"
 #include <memory>
 
 namespace llvm {
 class raw_ostream;
+class StringRef;
 
 namespace pdb {
 
-class IPDBSession;
-class PDBSymbolTypeVTable;
-class PDBSymbolTypeVTableShape;
-
 enum class PdbSymbolIdField : uint32_t {
   None = 0,
   SymIndexId = 1 << 0,
diff --git a/linux-x64/clang/include/llvm/DebugInfo/PDB/IPDBSession.h b/linux-x64/clang/include/llvm/DebugInfo/PDB/IPDBSession.h
index aa8d9c7..7e38654 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/PDB/IPDBSession.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/PDB/IPDBSession.h
@@ -42,13 +42,12 @@
     return unique_dyn_cast_or_null<T>(getSymbolById(SymbolId));
   }
 
+  virtual std::unique_ptr<PDBSymbol> findSymbolByAddress(uint64_t Address,
+                                                         PDB_SymType Type) = 0;
+  virtual std::unique_ptr<PDBSymbol> findSymbolByRVA(uint32_t RVA,
+                                                     PDB_SymType Type) = 0;
   virtual std::unique_ptr<PDBSymbol>
-  findSymbolByAddress(uint64_t Address, PDB_SymType Type) const = 0;
-  virtual std::unique_ptr<PDBSymbol>
-  findSymbolByRVA(uint32_t RVA, PDB_SymType Type) const = 0;
-  virtual std::unique_ptr<PDBSymbol>
-  findSymbolBySectOffset(uint32_t Sect, uint32_t Offset,
-                         PDB_SymType Type) const = 0;
+  findSymbolBySectOffset(uint32_t Sect, uint32_t Offset, PDB_SymType Type) = 0;
 
   virtual std::unique_ptr<IPDBEnumLineNumbers>
   findLineNumbers(const PDBSymbolCompiland &Compiland,
diff --git a/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/DbiModuleDescriptor.h b/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/DbiModuleDescriptor.h
index 568f0c9..7b7337f 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/DbiModuleDescriptor.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/DbiModuleDescriptor.h
@@ -25,9 +25,9 @@
   friend class DbiStreamBuilder;
 
 public:
-  DbiModuleDescriptor();
-  DbiModuleDescriptor(const DbiModuleDescriptor &Info);
-  ~DbiModuleDescriptor();
+  DbiModuleDescriptor() = default;
+  DbiModuleDescriptor(const DbiModuleDescriptor &Info) = default;
+  DbiModuleDescriptor &operator=(const DbiModuleDescriptor &Info) = default;
 
   static Error initialize(BinaryStreamRef Stream, DbiModuleDescriptor &Info);
 
diff --git a/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/DbiModuleDescriptorBuilder.h b/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/DbiModuleDescriptorBuilder.h
index 4f5d28b..82b63d7 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/DbiModuleDescriptorBuilder.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/DbiModuleDescriptorBuilder.h
@@ -34,6 +34,34 @@
 }
 namespace pdb {
 
+// Represents merged or unmerged symbols. Merged symbols can be written to the
+// output file as is, but unmerged symbols must be rewritten first. In either
+// case, the size must be known up front.
+struct SymbolListWrapper {
+  explicit SymbolListWrapper(ArrayRef<uint8_t> Syms)
+      : SymPtr(const_cast<uint8_t *>(Syms.data())), SymSize(Syms.size()),
+        NeedsToBeMerged(false) {}
+  explicit SymbolListWrapper(void *SymSrc, uint32_t Length)
+      : SymPtr(SymSrc), SymSize(Length), NeedsToBeMerged(true) {}
+
+  ArrayRef<uint8_t> asArray() const {
+    return ArrayRef<uint8_t>(static_cast<const uint8_t *>(SymPtr), SymSize);
+  }
+
+  uint32_t size() const { return SymSize; }
+
+  void *SymPtr = nullptr;
+  uint32_t SymSize = 0;
+  bool NeedsToBeMerged = false;
+};
+
+/// Represents a string table reference at some offset in the module symbol
+/// stream.
+struct StringTableFixup {
+  uint32_t StrTabOffset = 0;
+  uint32_t SymOffsetOfReference = 0;
+};
+
 class DbiModuleDescriptorBuilder {
   friend class DbiStreamBuilder;
 
@@ -48,10 +76,28 @@
 
   void setPdbFilePathNI(uint32_t NI);
   void setObjFileName(StringRef Name);
+
+  // Callback to merge one source of unmerged symbols.
+  using MergeSymbolsCallback = Error (*)(void *Ctx, void *Symbols,
+                                         BinaryStreamWriter &Writer);
+
+  void setMergeSymbolsCallback(void *Ctx, MergeSymbolsCallback Callback) {
+    MergeSymsCtx = Ctx;
+    MergeSymsCallback = Callback;
+  }
+
+  void setStringTableFixups(std::vector<StringTableFixup> &&Fixups) {
+    StringTableFixups = std::move(Fixups);
+  }
+
   void setFirstSectionContrib(const SectionContrib &SC);
   void addSymbol(codeview::CVSymbol Symbol);
   void addSymbolsInBulk(ArrayRef<uint8_t> BulkSymbols);
 
+  // Add symbols of known size which will be merged (rewritten) when committing
+  // the PDB to disk.
+  void addUnmergedSymbols(void *SymSrc, uint32_t SymLength);
+
   void
   addDebugSubsection(std::shared_ptr<codeview::DebugSubsection> Subsection);
 
@@ -77,8 +123,14 @@
   void finalize();
   Error finalizeMsfLayout();
 
-  Error commit(BinaryStreamWriter &ModiWriter, const msf::MSFLayout &MsfLayout,
-               WritableBinaryStreamRef MsfBuffer);
+  /// Commit the DBI descriptor to the DBI stream.
+  Error commit(BinaryStreamWriter &ModiWriter);
+
+  /// Commit the accumulated symbols to the module symbol stream. Safe to call
+  /// in parallel on different DbiModuleDescriptorBuilder objects. Only modifies
+  /// the pre-allocated stream in question.
+  Error commitSymbolStream(const msf::MSFLayout &MsfLayout,
+                           WritableBinaryStreamRef MsfBuffer);
 
 private:
   uint32_t calculateC13DebugInfoSize() const;
@@ -91,10 +143,14 @@
   std::string ModuleName;
   std::string ObjFileName;
   std::vector<std::string> SourceFiles;
-  std::vector<ArrayRef<uint8_t>> Symbols;
+  std::vector<SymbolListWrapper> Symbols;
 
-  std::vector<std::unique_ptr<codeview::DebugSubsectionRecordBuilder>>
-      C13Builders;
+  void *MergeSymsCtx = nullptr;
+  MergeSymbolsCallback MergeSymsCallback = nullptr;
+
+  std::vector<StringTableFixup> StringTableFixups;
+
+  std::vector<codeview::DebugSubsectionRecordBuilder> C13Builders;
 
   ModuleInfoHeader Layout;
 };
diff --git a/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/DbiModuleList.h b/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/DbiModuleList.h
index 1422327..5fb13ad 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/DbiModuleList.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/DbiModuleList.h
@@ -39,6 +39,7 @@
   DbiModuleSourceFilesIterator(const DbiModuleList &Modules, uint32_t Modi,
                                uint16_t Filei);
   DbiModuleSourceFilesIterator() = default;
+  DbiModuleSourceFilesIterator(const DbiModuleSourceFilesIterator &R) = default;
   DbiModuleSourceFilesIterator &
   operator=(const DbiModuleSourceFilesIterator &R) = default;
 
diff --git a/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/DbiStreamBuilder.h b/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/DbiStreamBuilder.h
index d9be238..24664c3 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/DbiStreamBuilder.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/DbiStreamBuilder.h
@@ -57,7 +57,6 @@
   void setFlags(uint16_t F);
   void setMachineType(PDB_Machine M);
   void setMachineType(COFF::MachineTypes M);
-  void setSectionMap(ArrayRef<SecMapEntry> SecMap);
 
   // Add given bytes as a new stream.
   Error addDbgStream(pdb::DbgHeaderType Type, ArrayRef<uint8_t> Data);
@@ -84,9 +83,8 @@
     SectionContribs.emplace_back(SC);
   }
 
-  // A helper function to create a Section Map from a COFF section header.
-  static std::vector<SecMapEntry>
-  createSectionMap(ArrayRef<llvm::object::coff_section> SecHdrs);
+  // Populate the Section Map from COFF section headers.
+  void createSectionMap(ArrayRef<llvm::object::coff_section> SecHdrs);
 
 private:
   struct DebugStream {
@@ -133,7 +131,7 @@
   WritableBinaryStreamRef NamesBuffer;
   MutableBinaryByteStream FileInfoBuffer;
   std::vector<SectionContrib> SectionContribs;
-  ArrayRef<SecMapEntry> SectionMap;
+  std::vector<SecMapEntry> SectionMap;
   std::array<Optional<DebugStream>, (int)DbgHeaderType::Max> DbgStreams;
 };
 }
diff --git a/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/GSIStreamBuilder.h b/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/GSIStreamBuilder.h
index a497956..378d4cd 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/GSIStreamBuilder.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/GSIStreamBuilder.h
@@ -9,6 +9,7 @@
 #ifndef LLVM_DEBUGINFO_PDB_RAW_GSISTREAMBUILDER_H
 #define LLVM_DEBUGINFO_PDB_RAW_GSISTREAMBUILDER_H
 
+#include "llvm/ADT/DenseSet.h"
 #include "llvm/DebugInfo/CodeView/SymbolRecord.h"
 #include "llvm/DebugInfo/PDB/Native/GlobalsStream.h"
 #include "llvm/DebugInfo/PDB/Native/RawConstants.h"
@@ -37,6 +38,8 @@
 } // namespace msf
 namespace pdb {
 struct GSIHashStreamBuilder;
+struct BulkPublic;
+struct SymbolDenseMapInfo;
 
 class GSIStreamBuilder {
 
@@ -51,29 +54,94 @@
 
   Error commit(const msf::MSFLayout &Layout, WritableBinaryStreamRef Buffer);
 
-  uint32_t getPublicsStreamIndex() const;
-  uint32_t getGlobalsStreamIndex() const;
-  uint32_t getRecordStreamIdx() const { return RecordStreamIdx; }
+  uint32_t getPublicsStreamIndex() const { return PublicsStreamIndex; }
+  uint32_t getGlobalsStreamIndex() const { return GlobalsStreamIndex; }
+  uint32_t getRecordStreamIndex() const { return RecordStreamIndex; }
 
-  void addPublicSymbol(const codeview::PublicSym32 &Pub);
+  // Add public symbols in bulk.
+  void addPublicSymbols(std::vector<BulkPublic> &&PublicsIn);
 
   void addGlobalSymbol(const codeview::ProcRefSym &Sym);
   void addGlobalSymbol(const codeview::DataSym &Sym);
   void addGlobalSymbol(const codeview::ConstantSym &Sym);
+
+  // Add a pre-serialized global symbol record. The caller must ensure that the
+  // symbol data remains alive until the global stream is committed to disk.
   void addGlobalSymbol(const codeview::CVSymbol &Sym);
 
 private:
+  void finalizePublicBuckets();
+  void finalizeGlobalBuckets(uint32_t RecordZeroOffset);
+
+  template <typename T> void serializeAndAddGlobal(const T &Symbol);
+
   uint32_t calculatePublicsHashStreamSize() const;
   uint32_t calculateGlobalsHashStreamSize() const;
   Error commitSymbolRecordStream(WritableBinaryStreamRef Stream);
   Error commitPublicsHashStream(WritableBinaryStreamRef Stream);
   Error commitGlobalsHashStream(WritableBinaryStreamRef Stream);
 
-  uint32_t RecordStreamIdx = kInvalidStreamIndex;
+  uint32_t PublicsStreamIndex = kInvalidStreamIndex;
+  uint32_t GlobalsStreamIndex = kInvalidStreamIndex;
+  uint32_t RecordStreamIndex = kInvalidStreamIndex;
   msf::MSFBuilder &Msf;
   std::unique_ptr<GSIHashStreamBuilder> PSH;
   std::unique_ptr<GSIHashStreamBuilder> GSH;
+
+  // List of all of the public records. These are stored unserialized so that we
+  // can defer copying the names until we are ready to commit the PDB.
+  std::vector<BulkPublic> Publics;
+
+  // List of all of the global records.
+  std::vector<codeview::CVSymbol> Globals;
+
+  // Hash table for deduplicating global typedef and constant records. Only used
+  // for globals.
+  llvm::DenseSet<codeview::CVSymbol, SymbolDenseMapInfo> GlobalsSeen;
 };
+
+/// This struct is equivalent to codeview::PublicSym32, but it has been
+/// optimized for size to speed up bulk serialization and sorting operations
+/// during PDB writing.
+struct BulkPublic {
+  BulkPublic() : Flags(0), BucketIdx(0) {}
+
+  const char *Name = nullptr;
+  uint32_t NameLen = 0;
+
+  // Offset of the symbol record in the publics stream.
+  uint32_t SymOffset = 0;
+
+  // Section offset of the symbol in the image.
+  uint32_t Offset = 0;
+
+  // Section index of the section containing the symbol.
+  uint16_t Segment = 0;
+
+  // PublicSymFlags.
+  uint16_t Flags : 4;
+
+  // GSI hash table bucket index. The maximum value is IPHR_HASH.
+  uint16_t BucketIdx : 12;
+  static_assert(IPHR_HASH <= 1 << 12, "bitfield too small");
+
+  void setFlags(codeview::PublicSymFlags F) {
+    Flags = uint32_t(F);
+    assert(Flags == uint32_t(F) && "truncated");
+  }
+
+  void setBucketIdx(uint16_t B) {
+    assert(B < IPHR_HASH);
+    BucketIdx = B;
+  }
+
+  StringRef getName() const { return StringRef(Name, NameLen); }
+};
+
+static_assert(sizeof(BulkPublic) <= 24, "unexpected size increase");
+static_assert(std::is_trivially_copyable<BulkPublic>::value,
+              "should be trivial");
+
 } // namespace pdb
 } // namespace llvm
 
diff --git a/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/HashTable.h b/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/HashTable.h
index 86c43a4..95c0a89 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/HashTable.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/HashTable.h
@@ -31,21 +31,21 @@
 Error readSparseBitVector(BinaryStreamReader &Stream, SparseBitVector<> &V);
 Error writeSparseBitVector(BinaryStreamWriter &Writer, SparseBitVector<> &Vec);
 
-template <typename ValueT, typename TraitsT> class HashTable;
+template <typename ValueT> class HashTable;
 
-template <typename ValueT, typename TraitsT>
+template <typename ValueT>
 class HashTableIterator
-    : public iterator_facade_base<HashTableIterator<ValueT, TraitsT>,
+    : public iterator_facade_base<HashTableIterator<ValueT>,
                                   std::forward_iterator_tag,
-                                  std::pair<uint32_t, ValueT>> {
-  friend HashTable<ValueT, TraitsT>;
+                                  const std::pair<uint32_t, ValueT>> {
+  friend HashTable<ValueT>;
 
-  HashTableIterator(const HashTable<ValueT, TraitsT> &Map, uint32_t Index,
+  HashTableIterator(const HashTable<ValueT> &Map, uint32_t Index,
                     bool IsEnd)
       : Map(&Map), Index(Index), IsEnd(IsEnd) {}
 
 public:
-  HashTableIterator(const HashTable<ValueT, TraitsT> &Map) : Map(&Map) {
+  HashTableIterator(const HashTable<ValueT> &Map) : Map(&Map) {
     int I = Map.Present.find_first();
     if (I == -1) {
       Index = 0;
@@ -56,6 +56,7 @@
     }
   }
 
+  HashTableIterator(const HashTableIterator &R) = default;
   HashTableIterator &operator=(const HashTableIterator &R) {
     Map = R.Map;
     return *this;
@@ -72,6 +73,12 @@
     assert(Map->Present.test(Index));
     return Map->Buckets[Index];
   }
+
+  // Implement postfix op++ in terms of prefix op++ by using the superclass
+  // implementation.
+  using iterator_facade_base<HashTableIterator<ValueT>,
+                             std::forward_iterator_tag,
+                             const std::pair<uint32_t, ValueT>>::operator++;
   HashTableIterator &operator++() {
     while (Index < Map->Buckets.size()) {
       ++Index;
@@ -87,24 +94,13 @@
   bool isEnd() const { return IsEnd; }
   uint32_t index() const { return Index; }
 
-  const HashTable<ValueT, TraitsT> *Map;
+  const HashTable<ValueT> *Map;
   uint32_t Index;
   bool IsEnd;
 };
 
-template <typename T> struct PdbHashTraits {};
-
-template <> struct PdbHashTraits<uint32_t> {
-  uint32_t hashLookupKey(uint32_t N) const { return N; }
-  uint32_t storageKeyToLookupKey(uint32_t N) const { return N; }
-  uint32_t lookupKeyToStorageKey(uint32_t N) { return N; }
-};
-
-template <typename ValueT, typename TraitsT = PdbHashTraits<ValueT>>
+template <typename ValueT>
 class HashTable {
-  using iterator = HashTableIterator<ValueT, TraitsT>;
-  friend iterator;
-
   struct Header {
     support::ulittle32_t Size;
     support::ulittle32_t Capacity;
@@ -113,10 +109,11 @@
   using BucketList = std::vector<std::pair<uint32_t, ValueT>>;
 
 public:
-  HashTable() { Buckets.resize(8); }
+  using const_iterator = HashTableIterator<ValueT>;
+  friend const_iterator;
 
-  explicit HashTable(TraitsT Traits) : HashTable(8, std::move(Traits)) {}
-  HashTable(uint32_t Capacity, TraitsT Traits) : Traits(Traits) {
+  HashTable() { Buckets.resize(8); }
+  explicit HashTable(uint32_t Capacity) {
     Buckets.resize(Capacity);
   }
 
@@ -216,19 +213,20 @@
   uint32_t capacity() const { return Buckets.size(); }
   uint32_t size() const { return Present.count(); }
 
-  iterator begin() const { return iterator(*this); }
-  iterator end() const { return iterator(*this, 0, true); }
+  const_iterator begin() const { return const_iterator(*this); }
+  const_iterator end() const { return const_iterator(*this, 0, true); }
 
   /// Find the entry whose key has the specified hash value, using the specified
   /// traits defining hash function and equality.
-  template <typename Key> iterator find_as(const Key &K) const {
+  template <typename Key, typename TraitsT>
+  const_iterator find_as(const Key &K, TraitsT &Traits) const {
     uint32_t H = Traits.hashLookupKey(K) % capacity();
     uint32_t I = H;
     Optional<uint32_t> FirstUnused;
     do {
       if (isPresent(I)) {
         if (Traits.storageKeyToLookupKey(Buckets[I].first) == K)
-          return iterator(*this, I, false);
+          return const_iterator(*this, I, false);
       } else {
         if (!FirstUnused)
           FirstUnused = I;
@@ -247,17 +245,19 @@
     // table were Present.  But this would violate the load factor constraints
     // that we impose, so it should never happen.
     assert(FirstUnused);
-    return iterator(*this, *FirstUnused, true);
+    return const_iterator(*this, *FirstUnused, true);
   }
 
   /// Set the entry using a key type that the specified Traits can convert
   /// from a real key to an internal key.
-  template <typename Key> bool set_as(const Key &K, ValueT V) {
-    return set_as_internal(K, std::move(V), None);
+  template <typename Key, typename TraitsT>
+  bool set_as(const Key &K, ValueT V, TraitsT &Traits) {
+    return set_as_internal(K, std::move(V), Traits, None);
   }
 
-  template <typename Key> ValueT get(const Key &K) const {
-    auto Iter = find_as(K);
+  template <typename Key, typename TraitsT>
+  ValueT get(const Key &K, TraitsT &Traits) const {
+    auto Iter = find_as(K, Traits);
     assert(Iter != end());
     return (*Iter).second;
   }
@@ -266,7 +266,6 @@
   bool isPresent(uint32_t K) const { return Present.test(K); }
   bool isDeleted(uint32_t K) const { return Deleted.test(K); }
 
-  TraitsT Traits;
   BucketList Buckets;
   mutable SparseBitVector<> Present;
   mutable SparseBitVector<> Deleted;
@@ -274,9 +273,10 @@
 private:
   /// Set the entry using a key type that the specified Traits can convert
   /// from a real key to an internal key.
-  template <typename Key>
-  bool set_as_internal(const Key &K, ValueT V, Optional<uint32_t> InternalKey) {
-    auto Entry = find_as(K);
+  template <typename Key, typename TraitsT>
+  bool set_as_internal(const Key &K, ValueT V, TraitsT &Traits,
+                       Optional<uint32_t> InternalKey) {
+    auto Entry = find_as(K, Traits);
     if (Entry != end()) {
       assert(isPresent(Entry.index()));
       assert(Traits.storageKeyToLookupKey(Buckets[Entry.index()].first) == K);
@@ -293,15 +293,16 @@
     Present.set(Entry.index());
     Deleted.reset(Entry.index());
 
-    grow();
+    grow(Traits);
 
-    assert((find_as(K)) != end());
+    assert((find_as(K, Traits)) != end());
     return true;
   }
 
   static uint32_t maxLoad(uint32_t capacity) { return capacity * 2 / 3 + 1; }
 
-  void grow() {
+  template <typename TraitsT>
+  void grow(TraitsT &Traits) {
     uint32_t S = size();
     uint32_t MaxLoad = maxLoad(capacity());
     if (S < maxLoad(capacity()))
@@ -313,10 +314,11 @@
     // Growing requires rebuilding the table and re-hashing every item.  Make a
     // copy with a larger capacity, insert everything into the copy, then swap
     // it in.
-    HashTable NewMap(NewCapacity, Traits);
+    HashTable NewMap(NewCapacity);
     for (auto I : Present) {
       auto LookupKey = Traits.storageKeyToLookupKey(Buckets[I].first);
-      NewMap.set_as_internal(LookupKey, Buckets[I].second, Buckets[I].first);
+      NewMap.set_as_internal(LookupKey, Buckets[I].second, Traits,
+                             Buckets[I].first);
     }
 
     Buckets.swap(NewMap.Buckets);
diff --git a/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/InjectedSourceStream.h b/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/InjectedSourceStream.h
new file mode 100644
index 0000000..d0cac37
--- /dev/null
+++ b/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/InjectedSourceStream.h
@@ -0,0 +1,44 @@
+//===- InjectedSourceStream.h - PDB Headerblock Stream Access ---*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_DEBUGINFO_PDB_RAW_PDBINJECTEDSOURCESTREAM_H
+#define LLVM_DEBUGINFO_PDB_RAW_PDBINJECTEDSOURCESTREAM_H
+
+#include "llvm/DebugInfo/PDB/Native/HashTable.h"
+#include "llvm/DebugInfo/PDB/Native/RawTypes.h"
+#include "llvm/Support/Error.h"
+
+namespace llvm {
+namespace msf {
+class MappedBlockStream;
+}
+namespace pdb {
+class PDBFile;
+class PDBStringTable;
+
+class InjectedSourceStream {
+public:
+  InjectedSourceStream(std::unique_ptr<msf::MappedBlockStream> Stream);
+  Error reload(const PDBStringTable &Strings);
+
+  using const_iterator = HashTable<SrcHeaderBlockEntry>::const_iterator;
+  const_iterator begin() const { return InjectedSourceTable.begin(); }
+  const_iterator end() const { return InjectedSourceTable.end(); }
+
+  uint32_t size() const { return InjectedSourceTable.size(); }
+
+private:
+  std::unique_ptr<msf::MappedBlockStream> Stream;
+
+  const SrcHeaderBlockHeader* Header;
+  HashTable<SrcHeaderBlockEntry> InjectedSourceTable;
+};
+}
+}
+
+#endif
diff --git a/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/NamedStreamMap.h b/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/NamedStreamMap.h
index c49d796..1df059f 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/NamedStreamMap.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/NamedStreamMap.h
@@ -59,7 +59,7 @@
   NamedStreamMapTraits HashTraits;
   /// Closed hash table from Offset -> StreamNumber, where Offset is the offset
   /// of the stream name in NamesBuffer.
-  HashTable<support::ulittle32_t, NamedStreamMapTraits> OffsetIndexMap;
+  HashTable<support::ulittle32_t> OffsetIndexMap;
 
   /// Buffer of string data.
   std::vector<char> NamesBuffer;
diff --git a/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/NativeEnumInjectedSources.h b/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/NativeEnumInjectedSources.h
new file mode 100644
index 0000000..ca1e22b
--- /dev/null
+++ b/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/NativeEnumInjectedSources.h
@@ -0,0 +1,43 @@
+//==- NativeEnumInjectedSources.cpp - Native Injected Source Enumerator --*-==//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_DEBUGINFO_PDB_NATIVE_NATIVEENUMINJECTEDSOURCES_H
+#define LLVM_DEBUGINFO_PDB_NATIVE_NATIVEENUMINJECTEDSOURCES_H
+
+#include "llvm/DebugInfo/PDB/IPDBEnumChildren.h"
+#include "llvm/DebugInfo/PDB/IPDBInjectedSource.h"
+#include "llvm/DebugInfo/PDB/Native/InjectedSourceStream.h"
+
+namespace llvm {
+namespace pdb {
+
+class InjectedSourceStream;
+class PDBStringTable;
+
+class NativeEnumInjectedSources : public IPDBEnumChildren<IPDBInjectedSource> {
+public:
+  NativeEnumInjectedSources(PDBFile &File, const InjectedSourceStream &IJS,
+                            const PDBStringTable &Strings);
+
+  uint32_t getChildCount() const override;
+  std::unique_ptr<IPDBInjectedSource>
+  getChildAtIndex(uint32_t Index) const override;
+  std::unique_ptr<IPDBInjectedSource> getNext() override;
+  void reset() override;
+
+private:
+  PDBFile &File;
+  const InjectedSourceStream &Stream;
+  const PDBStringTable &Strings;
+  InjectedSourceStream::const_iterator Cur;
+};
+
+} // namespace pdb
+} // namespace llvm
+
+#endif
diff --git a/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/NativeEnumLineNumbers.h b/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/NativeEnumLineNumbers.h
new file mode 100644
index 0000000..32a4515
--- /dev/null
+++ b/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/NativeEnumLineNumbers.h
@@ -0,0 +1,39 @@
+//==- NativeEnumLineNumbers.h - Native Line Number Enumerator ------------*-==//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_DEBUGINFO_PDB_NATIVE_NATIVEENUMLINENUMBERS_H
+#define LLVM_DEBUGINFO_PDB_NATIVE_NATIVEENUMLINENUMBERS_H
+
+#include "llvm/DebugInfo/CodeView/DebugLinesSubsection.h"
+#include "llvm/DebugInfo/CodeView/DebugSubsectionRecord.h"
+#include "llvm/DebugInfo/CodeView/StringsAndChecksums.h"
+#include "llvm/DebugInfo/PDB/IPDBEnumChildren.h"
+#include "llvm/DebugInfo/PDB/IPDBLineNumber.h"
+#include "llvm/DebugInfo/PDB/Native/NativeLineNumber.h"
+
+namespace llvm {
+namespace pdb {
+class IPDBLineNumber;
+
+class NativeEnumLineNumbers : public IPDBEnumChildren<IPDBLineNumber> {
+public:
+  explicit NativeEnumLineNumbers(std::vector<NativeLineNumber> LineNums);
+
+  uint32_t getChildCount() const override;
+  ChildTypePtr getChildAtIndex(uint32_t Index) const override;
+  ChildTypePtr getNext() override;
+  void reset() override;
+
+private:
+  std::vector<NativeLineNumber> Lines;
+  uint32_t Index;
+};
+} // namespace pdb
+} // namespace llvm
+
+#endif
diff --git a/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/NativeEnumSymbols.h b/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/NativeEnumSymbols.h
new file mode 100644
index 0000000..480b3fb
--- /dev/null
+++ b/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/NativeEnumSymbols.h
@@ -0,0 +1,41 @@
+//==- NativeEnumSymbols.h - Native Symbols Enumerator impl -------*- C++ -*-==//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_DEBUGINFO_PDB_NATIVE_NATIVEENUMSYMBOLS_H
+#define LLVM_DEBUGINFO_PDB_NATIVE_NATIVEENUMSYMBOLS_H
+
+#include "llvm/DebugInfo/CodeView/TypeRecord.h"
+#include "llvm/DebugInfo/PDB/IPDBEnumChildren.h"
+#include "llvm/DebugInfo/PDB/PDBSymbol.h"
+
+#include <vector>
+
+namespace llvm {
+namespace pdb {
+
+class NativeSession;
+
+class NativeEnumSymbols : public IPDBEnumChildren<PDBSymbol> {
+public:
+  NativeEnumSymbols(NativeSession &Session, std::vector<SymIndexId> Symbols);
+
+  uint32_t getChildCount() const override;
+  std::unique_ptr<PDBSymbol> getChildAtIndex(uint32_t Index) const override;
+  std::unique_ptr<PDBSymbol> getNext() override;
+  void reset() override;
+
+private:
+  std::vector<SymIndexId> Symbols;
+  uint32_t Index;
+  NativeSession &Session;
+};
+
+} // namespace pdb
+} // namespace llvm
+
+#endif
diff --git a/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/NativeFunctionSymbol.h b/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/NativeFunctionSymbol.h
new file mode 100644
index 0000000..b219055
--- /dev/null
+++ b/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/NativeFunctionSymbol.h
@@ -0,0 +1,47 @@
+//===- NativeFunctionSymbol.h - info about function symbols -----*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_DEBUGINFO_PDB_NATIVE_NATIVEFUNCTIONSYMBOL_H
+#define LLVM_DEBUGINFO_PDB_NATIVE_NATIVEFUNCTIONSYMBOL_H
+
+#include "llvm/DebugInfo/CodeView/CodeView.h"
+#include "llvm/DebugInfo/CodeView/SymbolRecord.h"
+#include "llvm/DebugInfo/PDB/Native/NativeRawSymbol.h"
+#include "llvm/DebugInfo/PDB/Native/NativeSession.h"
+
+namespace llvm {
+namespace pdb {
+
+class NativeFunctionSymbol : public NativeRawSymbol {
+public:
+  NativeFunctionSymbol(NativeSession &Session, SymIndexId Id,
+                       const codeview::ProcSym &Sym, uint32_t RecordOffset);
+
+  ~NativeFunctionSymbol() override;
+
+  void dump(raw_ostream &OS, int Indent, PdbSymbolIdField ShowIdFields,
+            PdbSymbolIdField RecurseIdFields) const override;
+
+  uint32_t getAddressOffset() const override;
+  uint32_t getAddressSection() const override;
+  std::string getName() const override;
+  uint64_t getLength() const override;
+  uint32_t getRelativeVirtualAddress() const override;
+  uint64_t getVirtualAddress() const override;
+  std::unique_ptr<IPDBEnumSymbols>
+  findInlineFramesByVA(uint64_t VA) const override;
+
+protected:
+  const codeview::ProcSym Sym;
+  uint32_t RecordOffset = 0;
+};
+
+} // namespace pdb
+} // namespace llvm
+
+#endif // LLVM_DEBUGINFO_PDB_NATIVE_NATIVEFUNCTIONSYMBOL_H
diff --git a/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/NativeInlineSiteSymbol.h b/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/NativeInlineSiteSymbol.h
new file mode 100644
index 0000000..2f6aba0
--- /dev/null
+++ b/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/NativeInlineSiteSymbol.h
@@ -0,0 +1,46 @@
+//===- NativeInlineSiteSymbol.h - info about inline sites -------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_DEBUGINFO_PDB_NATIVE_NATIVEINLINESITESYMBOL_H
+#define LLVM_DEBUGINFO_PDB_NATIVE_NATIVEINLINESITESYMBOL_H
+
+#include "llvm/DebugInfo/CodeView/CodeView.h"
+#include "llvm/DebugInfo/CodeView/SymbolRecord.h"
+#include "llvm/DebugInfo/PDB/Native/NativeRawSymbol.h"
+#include "llvm/DebugInfo/PDB/Native/NativeSession.h"
+
+namespace llvm {
+namespace pdb {
+
+class NativeInlineSiteSymbol : public NativeRawSymbol {
+public:
+  NativeInlineSiteSymbol(NativeSession &Session, SymIndexId Id,
+                         const codeview::InlineSiteSym &Sym,
+                         uint64_t ParentAddr);
+
+  ~NativeInlineSiteSymbol() override;
+
+  void dump(raw_ostream &OS, int Indent, PdbSymbolIdField ShowIdFields,
+            PdbSymbolIdField RecurseIdFields) const override;
+
+  std::string getName() const override;
+  std::unique_ptr<IPDBEnumLineNumbers>
+  findInlineeLinesByVA(uint64_t VA, uint32_t Length) const override;
+
+private:
+  const codeview::InlineSiteSym Sym;
+  uint64_t ParentAddr;
+
+  void getLineOffset(uint32_t OffsetInFunc, uint32_t &LineOffset,
+                     uint32_t &FileOffset) const;
+};
+
+} // namespace pdb
+} // namespace llvm
+
+#endif // LLVM_DEBUGINFO_PDB_NATIVE_NATIVEINLINESITESYMBOL_H
diff --git a/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/NativeLineNumber.h b/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/NativeLineNumber.h
new file mode 100644
index 0000000..5dedc70
--- /dev/null
+++ b/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/NativeLineNumber.h
@@ -0,0 +1,52 @@
+//===- NativeLineNumber.h - Native line number implementation ---*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_DEBUGINFO_PDB_NATIVE_NATIVELINENUMBER_H
+#define LLVM_DEBUGINFO_PDB_NATIVE_NATIVELINENUMBER_H
+
+#include "llvm/ADT/Optional.h"
+#include "llvm/DebugInfo/CodeView/Line.h"
+#include "llvm/DebugInfo/PDB/IPDBLineNumber.h"
+#include "llvm/DebugInfo/PDB/Native/NativeSession.h"
+
+namespace llvm {
+namespace pdb {
+class NativeLineNumber : public IPDBLineNumber {
+public:
+  explicit NativeLineNumber(const NativeSession &Session,
+                            const codeview::LineInfo Line,
+                            uint32_t ColumnNumber, uint32_t Length,
+                            uint32_t Section, uint32_t Offset,
+                            uint32_t SrcFileId, uint32_t CompilandId);
+
+  uint32_t getLineNumber() const override;
+  uint32_t getLineNumberEnd() const override;
+  uint32_t getColumnNumber() const override;
+  uint32_t getColumnNumberEnd() const override;
+  uint32_t getAddressSection() const override;
+  uint32_t getAddressOffset() const override;
+  uint32_t getRelativeVirtualAddress() const override;
+  uint64_t getVirtualAddress() const override;
+  uint32_t getLength() const override;
+  uint32_t getSourceFileId() const override;
+  uint32_t getCompilandId() const override;
+  bool isStatement() const override;
+
+private:
+  const NativeSession &Session;
+  const codeview::LineInfo Line;
+  uint32_t ColumnNumber;
+  uint32_t Section;
+  uint32_t Offset;
+  uint32_t Length;
+  uint32_t SrcFileId;
+  uint32_t CompilandId;
+};
+} // namespace pdb
+} // namespace llvm
+#endif
diff --git a/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/NativePublicSymbol.h b/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/NativePublicSymbol.h
new file mode 100644
index 0000000..9f410e2
--- /dev/null
+++ b/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/NativePublicSymbol.h
@@ -0,0 +1,43 @@
+//===- NativePublicSymbol.h - info about public symbols ---------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_DEBUGINFO_PDB_NATIVE_NATIVEPUBLICSYMBOL_H
+#define LLVM_DEBUGINFO_PDB_NATIVE_NATIVEPUBLICSYMBOL_H
+
+#include "llvm/DebugInfo/CodeView/CodeView.h"
+#include "llvm/DebugInfo/CodeView/SymbolRecord.h"
+#include "llvm/DebugInfo/PDB/Native/NativeRawSymbol.h"
+#include "llvm/DebugInfo/PDB/Native/NativeSession.h"
+
+namespace llvm {
+namespace pdb {
+
+class NativePublicSymbol : public NativeRawSymbol {
+public:
+  NativePublicSymbol(NativeSession &Session, SymIndexId Id,
+                     const codeview::PublicSym32 &Sym);
+
+  ~NativePublicSymbol() override;
+
+  void dump(raw_ostream &OS, int Indent, PdbSymbolIdField ShowIdFields,
+            PdbSymbolIdField RecurseIdFields) const override;
+
+  uint32_t getAddressOffset() const override;
+  uint32_t getAddressSection() const override;
+  std::string getName() const override;
+  uint32_t getRelativeVirtualAddress() const override;
+  uint64_t getVirtualAddress() const override;
+
+protected:
+  const codeview::PublicSym32 Sym;
+};
+
+} // namespace pdb
+} // namespace llvm
+
+#endif // LLVM_DEBUGINFO_PDB_NATIVE_NATIVEPUBLICSYMBOL_H
diff --git a/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/NativeSession.h b/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/NativeSession.h
index ee7d8cd..5f8fc58 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/NativeSession.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/NativeSession.h
@@ -26,6 +26,11 @@
 class NativeExeSymbol;
 
 class NativeSession : public IPDBSession {
+  struct PdbSearchOptions {
+    StringRef ExePath;
+    // FIXME: Add other PDB search options (_NT_SYMBOL_PATH, symsrv)
+  };
+
 public:
   NativeSession(std::unique_ptr<PDBFile> PdbFile,
                 std::unique_ptr<BumpPtrAllocator> Allocator);
@@ -33,8 +38,11 @@
 
   static Error createFromPdb(std::unique_ptr<MemoryBuffer> MB,
                              std::unique_ptr<IPDBSession> &Session);
+  static Error createFromPdbPath(StringRef PdbPath,
+                                 std::unique_ptr<IPDBSession> &Session);
   static Error createFromExe(StringRef Path,
                              std::unique_ptr<IPDBSession> &Session);
+  static Expected<std::string> searchForPdb(const PdbSearchOptions &Opts);
 
   uint64_t getLoadAddress() const override;
   bool setLoadAddress(uint64_t Address) override;
@@ -46,13 +54,13 @@
   bool addressForRVA(uint32_t RVA, uint32_t &Section,
                      uint32_t &Offset) const override;
 
-  std::unique_ptr<PDBSymbol>
-  findSymbolByAddress(uint64_t Address, PDB_SymType Type) const override;
+  std::unique_ptr<PDBSymbol> findSymbolByAddress(uint64_t Address,
+                                                 PDB_SymType Type) override;
   std::unique_ptr<PDBSymbol> findSymbolByRVA(uint32_t RVA,
-                                             PDB_SymType Type) const override;
-  std::unique_ptr<PDBSymbol>
-  findSymbolBySectOffset(uint32_t Sect, uint32_t Offset,
-                         PDB_SymType Type) const override;
+                                             PDB_SymType Type) override;
+  std::unique_ptr<PDBSymbol> findSymbolBySectOffset(uint32_t Sect,
+                                                    uint32_t Offset,
+                                                    PDB_SymType Type) override;
 
   std::unique_ptr<IPDBEnumLineNumbers>
   findLineNumbers(const PDBSymbolCompiland &Compiland,
@@ -100,15 +108,29 @@
   NativeExeSymbol &getNativeGlobalScope() const;
   SymbolCache &getSymbolCache() { return Cache; }
   const SymbolCache &getSymbolCache() const { return Cache; }
+  uint32_t getRVAFromSectOffset(uint32_t Section, uint32_t Offset) const;
+  uint64_t getVAFromSectOffset(uint32_t Section, uint32_t Offset) const;
+  bool moduleIndexForVA(uint64_t VA, uint16_t &ModuleIndex) const;
+  bool moduleIndexForSectOffset(uint32_t Sect, uint32_t Offset,
+                                uint16_t &ModuleIndex) const;
+  Expected<ModuleDebugStreamRef> getModuleDebugStream(uint32_t Index) const;
 
 private:
   void initializeExeSymbol();
+  void parseSectionContribs();
 
   std::unique_ptr<PDBFile> Pdb;
   std::unique_ptr<BumpPtrAllocator> Allocator;
 
   SymbolCache Cache;
   SymIndexId ExeSymbol = 0;
+  uint64_t LoadAddress = 0;
+
+  /// Map from virtual address to module index.
+  using IMap =
+      IntervalMap<uint64_t, uint16_t, 8, IntervalMapHalfOpenInfo<uint64_t>>;
+  IMap::Allocator IMapAllocator;
+  IMap AddrToModuleIndex;
 };
 } // namespace pdb
 } // namespace llvm
diff --git a/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/NativeSourceFile.h b/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/NativeSourceFile.h
new file mode 100644
index 0000000..eb6336f
--- /dev/null
+++ b/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/NativeSourceFile.h
@@ -0,0 +1,40 @@
+//===- NativeSourceFile.h - Native source file implementation ---*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_DEBUGINFO_PDB_NATIVE_NATIVESOURCEFILE_H
+#define LLVM_DEBUGINFO_PDB_NATIVE_NATIVESOURCEFILE_H
+
+#include "llvm/DebugInfo/CodeView/DebugChecksumsSubsection.h"
+#include "llvm/DebugInfo/PDB/IPDBSourceFile.h"
+#include "llvm/DebugInfo/PDB/Native/PDBFile.h"
+#include "llvm/DebugInfo/PDB/Native/PDBStringTable.h"
+
+namespace llvm {
+namespace pdb {
+class NativeSession;
+
+class NativeSourceFile : public IPDBSourceFile {
+public:
+  explicit NativeSourceFile(NativeSession &Session, uint32_t FileId,
+                            const codeview::FileChecksumEntry &Checksum);
+
+  std::string getFileName() const override;
+  uint32_t getUniqueId() const override;
+  std::string getChecksum() const override;
+  PDB_Checksum getChecksumType() const override;
+  std::unique_ptr<IPDBEnumChildren<PDBSymbolCompiland>>
+  getCompilands() const override;
+
+private:
+  NativeSession &Session;
+  uint32_t FileId;
+  const codeview::FileChecksumEntry Checksum;
+};
+} // namespace pdb
+} // namespace llvm
+#endif
diff --git a/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/NativeTypeFunctionSig.h b/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/NativeTypeFunctionSig.h
index a7ea287..358ddf5 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/NativeTypeFunctionSig.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/NativeTypeFunctionSig.h
@@ -70,4 +70,4 @@
 } // namespace pdb
 } // namespace llvm
 
-#endif // LLVM_DEBUGINFO_PDB_NATIVE_NATIVETYPEPOINTER_H
\ No newline at end of file
+#endif // LLVM_DEBUGINFO_PDB_NATIVE_NATIVETYPEPOINTER_H
diff --git a/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/NativeTypePointer.h b/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/NativeTypePointer.h
index 446f77d..7a3dfae 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/NativeTypePointer.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/NativeTypePointer.h
@@ -57,4 +57,4 @@
 } // namespace pdb
 } // namespace llvm
 
-#endif // LLVM_DEBUGINFO_PDB_NATIVE_NATIVETYPEPOINTER_H
\ No newline at end of file
+#endif // LLVM_DEBUGINFO_PDB_NATIVE_NATIVETYPEPOINTER_H
diff --git a/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/NativeTypeTypedef.h b/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/NativeTypeTypedef.h
index fe8a6f7..e7fb41b 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/NativeTypeTypedef.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/NativeTypeTypedef.h
@@ -38,4 +38,4 @@
 } // namespace pdb
 } // namespace llvm
 
-#endif // LLVM_DEBUGINFO_PDB_NATIVE_NATIVETYPEPOINTER_H
\ No newline at end of file
+#endif // LLVM_DEBUGINFO_PDB_NATIVE_NATIVETYPEPOINTER_H
diff --git a/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/NativeTypeUDT.h b/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/NativeTypeUDT.h
index 8f4dee3..e1b31a2 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/NativeTypeUDT.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/NativeTypeUDT.h
@@ -70,4 +70,4 @@
 } // namespace pdb
 } // namespace llvm
 
-#endif // LLVM_DEBUGINFO_PDB_NATIVE_NATIVETYPEUDT_H
\ No newline at end of file
+#endif // LLVM_DEBUGINFO_PDB_NATIVE_NATIVETYPEUDT_H
diff --git a/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/NativeTypeVTShape.h b/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/NativeTypeVTShape.h
index 4ec0f9b..4ae8f14 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/NativeTypeVTShape.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/NativeTypeVTShape.h
@@ -42,4 +42,4 @@
 } // namespace pdb
 } // namespace llvm
 
-#endif // LLVM_DEBUGINFO_PDB_NATIVE_NATIVETYPEVTSHAPE_H
\ No newline at end of file
+#endif // LLVM_DEBUGINFO_PDB_NATIVE_NATIVETYPEVTSHAPE_H
diff --git a/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/PDBFile.h b/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/PDBFile.h
index cb9bd07..56de403 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/PDBFile.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/PDBFile.h
@@ -32,6 +32,7 @@
 class DbiStream;
 class GlobalsStream;
 class InfoStream;
+class InjectedSourceStream;
 class PDBStringTable;
 class PDBFileBuilder;
 class PublicsStream;
@@ -83,7 +84,12 @@
 
   ArrayRef<support::ulittle32_t> getDirectoryBlockArray() const;
 
-  std::unique_ptr<msf::MappedBlockStream> createIndexedStream(uint16_t SN);
+  std::unique_ptr<msf::MappedBlockStream>
+  createIndexedStream(uint16_t SN) const;
+  Expected<std::unique_ptr<msf::MappedBlockStream>>
+  safelyCreateIndexedStream(uint32_t StreamIndex) const;
+  Expected<std::unique_ptr<msf::MappedBlockStream>>
+  safelyCreateNamedStream(StringRef Name);
 
   msf::MSFStreamLayout getStreamLayout(uint32_t StreamIdx) const;
   msf::MSFStreamLayout getFpmStreamLayout() const;
@@ -99,6 +105,7 @@
   Expected<PublicsStream &> getPDBPublicsStream();
   Expected<SymbolStream &> getPDBSymbolStream();
   Expected<PDBStringTable &> getStringTable();
+  Expected<InjectedSourceStream &> getInjectedSourceStream();
 
   BumpPtrAllocator &getAllocator() { return Allocator; }
 
@@ -110,15 +117,11 @@
   bool hasPDBSymbolStream();
   bool hasPDBTpiStream() const;
   bool hasPDBStringTable();
+  bool hasPDBInjectedSourceStream();
 
   uint32_t getPointerSize();
 
 private:
-  Expected<std::unique_ptr<msf::MappedBlockStream>>
-  safelyCreateIndexedStream(const msf::MSFLayout &Layout,
-                            BinaryStreamRef MsfData,
-                            uint32_t StreamIndex) const;
-
   std::string FilePath;
   BumpPtrAllocator &Allocator;
 
@@ -135,6 +138,7 @@
   std::unique_ptr<SymbolStream> Symbols;
   std::unique_ptr<msf::MappedBlockStream> DirectoryStream;
   std::unique_ptr<msf::MappedBlockStream> StringTableStream;
+  std::unique_ptr<InjectedSourceStream> InjectedSources;
   std::unique_ptr<PDBStringTable> Strings;
 };
 }
diff --git a/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/PDBFileBuilder.h b/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/PDBFileBuilder.h
index 72000bd..87ba049 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/PDBFileBuilder.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/PDBFileBuilder.h
@@ -80,7 +80,6 @@
   Error finalizeMsfLayout();
   Expected<uint32_t> allocateNamedStream(StringRef Name, uint32_t Size);
 
-  void commitFpm(WritableBinaryStream &MsfBuffer, const msf::MSFLayout &Layout);
   void commitInjectedSources(WritableBinaryStream &MsfBuffer,
                              const msf::MSFLayout &Layout);
   void commitSrcHeaderBlock(WritableBinaryStream &MsfBuffer,
@@ -97,7 +96,7 @@
 
   PDBStringTableBuilder Strings;
   StringTableHashTraits InjectedSourceHashTraits;
-  HashTable<SrcHeaderBlockEntry, StringTableHashTraits> InjectedSourceTable;
+  HashTable<SrcHeaderBlockEntry> InjectedSourceTable;
 
   SmallVector<InjectedSourceDescriptor, 2> InjectedSources;
 
diff --git a/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/SymbolCache.h b/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/SymbolCache.h
index 0b15ab4..1ff6ca1 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/SymbolCache.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/SymbolCache.h
@@ -10,11 +10,15 @@
 #define LLVM_DEBUGINFO_PDB_NATIVE_SYMBOLCACHE_H
 
 #include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/IntervalMap.h"
+#include "llvm/DebugInfo/CodeView/Line.h"
+#include "llvm/DebugInfo/CodeView/SymbolRecord.h"
 #include "llvm/DebugInfo/CodeView/TypeDeserializer.h"
 #include "llvm/DebugInfo/CodeView/TypeIndex.h"
 #include "llvm/DebugInfo/CodeView/TypeRecord.h"
+#include "llvm/DebugInfo/PDB/Native/ModuleDebugStream.h"
 #include "llvm/DebugInfo/PDB/Native/NativeRawSymbol.h"
-#include "llvm/Support/Allocator.h"
+#include "llvm/DebugInfo/PDB/Native/NativeSourceFile.h"
 
 #include <memory>
 #include <vector>
@@ -33,26 +37,53 @@
   /// an Id.  Id allocation is an implementation, with the only guarantee
   /// being that once an Id is allocated, the symbol can be assumed to be
   /// cached.
-  std::vector<std::unique_ptr<NativeRawSymbol>> Cache;
+  mutable std::vector<std::unique_ptr<NativeRawSymbol>> Cache;
 
   /// For type records from the TPI stream which have been paresd and cached,
   /// stores a mapping to SymIndexId of the cached symbol.
-  DenseMap<codeview::TypeIndex, SymIndexId> TypeIndexToSymbolId;
+  mutable DenseMap<codeview::TypeIndex, SymIndexId> TypeIndexToSymbolId;
 
   /// For field list members which have been parsed and cached, stores a mapping
   /// from (IndexOfClass, MemberIndex) to the corresponding SymIndexId of the
   /// cached symbol.
-  DenseMap<std::pair<codeview::TypeIndex, uint32_t>, SymIndexId>
+  mutable DenseMap<std::pair<codeview::TypeIndex, uint32_t>, SymIndexId>
       FieldListMembersToSymbolId;
 
   /// List of SymIndexIds for each compiland, indexed by compiland index as they
   /// appear in the PDB file.
-  std::vector<SymIndexId> Compilands;
+  mutable std::vector<SymIndexId> Compilands;
+
+  /// List of source files, indexed by unique source file index.
+  mutable std::vector<std::unique_ptr<NativeSourceFile>> SourceFiles;
+
+  /// Map from string table offset to source file Id.
+  mutable DenseMap<uint32_t, SymIndexId> FileNameOffsetToId;
 
   /// Map from global symbol offset to SymIndexId.
-  DenseMap<uint32_t, SymIndexId> GlobalOffsetToSymbolId;
+  mutable DenseMap<uint32_t, SymIndexId> GlobalOffsetToSymbolId;
 
-  SymIndexId createSymbolPlaceholder() {
+  /// Map from segment and code offset to function symbols.
+  mutable DenseMap<std::pair<uint32_t, uint32_t>, SymIndexId> AddressToSymbolId;
+  /// Map from segment and code offset to public symbols.
+  mutable DenseMap<std::pair<uint32_t, uint32_t>, SymIndexId>
+      AddressToPublicSymId;
+
+  /// Map from module index and symbol table offset to SymIndexId.
+  mutable DenseMap<std::pair<uint16_t, uint32_t>, SymIndexId>
+      SymTabOffsetToSymbolId;
+
+  struct LineTableEntry {
+    uint64_t Addr;
+    codeview::LineInfo Line;
+    uint32_t ColumnNumber;
+    uint32_t FileNameIndex;
+    bool IsTerminalEntry;
+  };
+
+  std::vector<LineTableEntry> findLineTable(uint16_t Modi) const;
+  mutable DenseMap<uint16_t, std::vector<LineTableEntry>> LineTable;
+
+  SymIndexId createSymbolPlaceholder() const {
     SymIndexId Id = Cache.size();
     Cache.push_back(nullptr);
     return Id;
@@ -60,7 +91,7 @@
 
   template <typename ConcreteSymbolT, typename CVRecordT, typename... Args>
   SymIndexId createSymbolForType(codeview::TypeIndex TI, codeview::CVType CVT,
-                                 Args &&... ConstructorArgs) {
+                                 Args &&...ConstructorArgs) const {
     CVRecordT Record;
     if (auto EC =
             codeview::TypeDeserializer::deserializeAs<CVRecordT>(CVT, Record)) {
@@ -73,21 +104,26 @@
   }
 
   SymIndexId createSymbolForModifiedType(codeview::TypeIndex ModifierTI,
-                                         codeview::CVType CVT);
+                                         codeview::CVType CVT) const;
 
   SymIndexId createSimpleType(codeview::TypeIndex TI,
-                              codeview::ModifierOptions Mods);
+                              codeview::ModifierOptions Mods) const;
+
+  std::unique_ptr<PDBSymbol> findFunctionSymbolBySectOffset(uint32_t Sect,
+                                                            uint32_t Offset);
+  std::unique_ptr<PDBSymbol> findPublicSymbolBySectOffset(uint32_t Sect,
+                                                          uint32_t Offset);
 
 public:
   SymbolCache(NativeSession &Session, DbiStream *Dbi);
 
   template <typename ConcreteSymbolT, typename... Args>
-  SymIndexId createSymbol(Args &&... ConstructorArgs) {
+  SymIndexId createSymbol(Args &&...ConstructorArgs) const {
     SymIndexId Id = Cache.size();
 
     // Initial construction must not access the cache, since it must be done
     // atomically.
-    auto Result = llvm::make_unique<ConcreteSymbolT>(
+    auto Result = std::make_unique<ConcreteSymbolT>(
         Session, Id, std::forward<Args>(ConstructorArgs)...);
     Result->SymbolId = Id;
 
@@ -109,7 +145,7 @@
   std::unique_ptr<IPDBEnumSymbols>
   createGlobalsEnumerator(codeview::SymbolKind Kind);
 
-  SymIndexId findSymbolByTypeIndex(codeview::TypeIndex TI);
+  SymIndexId findSymbolByTypeIndex(codeview::TypeIndex TI) const;
 
   template <typename ConcreteSymbolT, typename... Args>
   SymIndexId getOrCreateFieldListMember(codeview::TypeIndex FieldListTI,
@@ -127,6 +163,15 @@
   }
 
   SymIndexId getOrCreateGlobalSymbolByOffset(uint32_t Offset);
+  SymIndexId getOrCreateInlineSymbol(codeview::InlineSiteSym Sym,
+                                     uint64_t ParentAddr, uint16_t Modi,
+                                     uint32_t RecordOffset) const;
+
+  std::unique_ptr<PDBSymbol>
+  findSymbolBySectOffset(uint32_t Sect, uint32_t Offset, PDB_SymType Type);
+
+  std::unique_ptr<IPDBEnumLineNumbers>
+  findLineNumbersByVA(uint64_t VA, uint32_t Length) const;
 
   std::unique_ptr<PDBSymbolCompiland> getOrCreateCompiland(uint32_t Index);
   uint32_t getNumCompilands() const;
@@ -139,6 +184,10 @@
   ConcreteT &getNativeSymbolById(SymIndexId SymbolId) const {
     return static_cast<ConcreteT &>(getNativeSymbolById(SymbolId));
   }
+
+  std::unique_ptr<IPDBSourceFile> getSourceFileById(SymIndexId FileId) const;
+  SymIndexId
+  getOrCreateSourceFile(const codeview::FileChecksumEntry &Checksum) const;
 };
 
 } // namespace pdb
diff --git a/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/TpiStream.h b/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/TpiStream.h
index 1b7fd2d..7028886 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/TpiStream.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/TpiStream.h
@@ -9,7 +9,7 @@
 #ifndef LLVM_DEBUGINFO_PDB_RAW_PDBTPISTREAM_H
 #define LLVM_DEBUGINFO_PDB_RAW_PDBTPISTREAM_H
 
-#include "llvm/DebugInfo/CodeView/TypeRecord.h"
+#include "llvm/DebugInfo/CodeView/CVRecord.h"
 #include "llvm/DebugInfo/PDB/Native/HashTable.h"
 #include "llvm/DebugInfo/PDB/Native/RawConstants.h"
 #include "llvm/DebugInfo/PDB/Native/RawTypes.h"
diff --git a/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/TpiStreamBuilder.h b/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/TpiStreamBuilder.h
index 72d98e9..9ef2ee6 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/TpiStreamBuilder.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/PDB/Native/TpiStreamBuilder.h
@@ -54,16 +54,20 @@
 
   void setVersionHeader(PdbRaw_TpiVer Version);
   void addTypeRecord(ArrayRef<uint8_t> Type, Optional<uint32_t> Hash);
+  void addTypeRecords(ArrayRef<uint8_t> Types, ArrayRef<uint16_t> Sizes,
+                      ArrayRef<uint32_t> Hashes);
 
   Error finalizeMsfLayout();
 
-  uint32_t getRecordCount() const { return TypeRecords.size(); }
+  uint32_t getRecordCount() const { return TypeRecordCount; }
 
   Error commit(const msf::MSFLayout &Layout, WritableBinaryStreamRef Buffer);
 
   uint32_t calculateSerializedLength();
 
 private:
+  void updateTypeIndexOffsets(ArrayRef<uint16_t> Sizes);
+
   uint32_t calculateHashBufferSize() const;
   uint32_t calculateIndexOffsetSize() const;
   Error finalize();
@@ -71,10 +75,11 @@
   msf::MSFBuilder &Msf;
   BumpPtrAllocator &Allocator;
 
+  uint32_t TypeRecordCount = 0;
   size_t TypeRecordBytes = 0;
 
   PdbRaw_TpiVer VerHeader = PdbRaw_TpiVer::PdbTpiV80;
-  std::vector<ArrayRef<uint8_t>> TypeRecords;
+  std::vector<ArrayRef<uint8_t>> TypeRecBuffers;
   std::vector<uint32_t> TypeHashes;
   std::vector<codeview::TypeIndexOffset> TypeIndexOffsets;
   uint32_t HashStreamIndex = kInvalidStreamIndex;
diff --git a/linux-x64/clang/include/llvm/DebugInfo/PDB/PDBExtras.h b/linux-x64/clang/include/llvm/DebugInfo/PDB/PDBExtras.h
index f5c3a5f..802d18a 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/PDB/PDBExtras.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/PDB/PDBExtras.h
@@ -9,16 +9,15 @@
 #ifndef LLVM_DEBUGINFO_PDB_PDBEXTRAS_H
 #define LLVM_DEBUGINFO_PDB_PDBEXTRAS_H
 
+#include "llvm/ADT/StringRef.h"
 #include "llvm/DebugInfo/CodeView/CodeView.h"
 #include "llvm/DebugInfo/PDB/PDBTypes.h"
 #include "llvm/Support/raw_ostream.h"
-
+#include <cstdint>
 #include <unordered_map>
 
 namespace llvm {
 
-class raw_ostream;
-
 namespace pdb {
 
 using TagStats = std::unordered_map<PDB_SymType, int>;
@@ -37,13 +36,12 @@
 raw_ostream &operator<<(raw_ostream &OS, const PDB_MemberAccess &Access);
 raw_ostream &operator<<(raw_ostream &OS, const PDB_UdtType &Type);
 raw_ostream &operator<<(raw_ostream &OS, const PDB_Machine &Machine);
-raw_ostream &operator<<(raw_ostream &OS,
-                        const PDB_SourceCompression &Compression);
 
 raw_ostream &operator<<(raw_ostream &OS, const Variant &Value);
 raw_ostream &operator<<(raw_ostream &OS, const VersionInfo &Version);
 raw_ostream &operator<<(raw_ostream &OS, const TagStats &Stats);
 
+raw_ostream& dumpPDBSourceCompression(raw_ostream& OS, uint32_t Compression);
 
 template <typename T>
 void dumpSymbolField(raw_ostream &OS, StringRef Name, T Value, int Indent) {
@@ -52,7 +50,6 @@
   OS << Name << ": " << Value;
 }
 
-
 } // end namespace pdb
 
 } // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/DebugInfo/PDB/PDBSymbol.h b/linux-x64/clang/include/llvm/DebugInfo/PDB/PDBSymbol.h
index d9004a8..24cf1e4 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/PDB/PDBSymbol.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/PDB/PDBSymbol.h
@@ -17,13 +17,11 @@
 #include "llvm/Support/Casting.h"
 
 #define FORWARD_SYMBOL_METHOD(MethodName)                                      \
-  auto MethodName() const->decltype(RawSymbol->MethodName()) {                 \
-    return RawSymbol->MethodName();                                            \
-  }
+  decltype(auto) MethodName() const { return RawSymbol->MethodName(); }
 
 #define FORWARD_CONCRETE_SYMBOL_ID_METHOD_WITH_NAME(ConcreteType, PrivateName, \
                                                     PublicName)                \
-  auto PublicName##Id() const->decltype(RawSymbol->PrivateName##Id()) {        \
+  decltype(auto) PublicName##Id() const {                                      \
     return RawSymbol->PrivateName##Id();                                       \
   }                                                                            \
   std::unique_ptr<ConcreteType> PublicName() const {                           \
@@ -44,7 +42,6 @@
 class raw_ostream;
 
 namespace pdb {
-class IPDBRawSymbol;
 class IPDBSession;
 
 #define DECLARE_PDB_SYMBOL_CONCRETE_TYPE(TagValue)                             \
@@ -131,7 +128,7 @@
     auto BaseIter = RawSymbol->findChildren(T::Tag);
     if (!BaseIter)
       return nullptr;
-    return llvm::make_unique<ConcreteSymbolEnumerator<T>>(std::move(BaseIter));
+    return std::make_unique<ConcreteSymbolEnumerator<T>>(std::move(BaseIter));
   }
   std::unique_ptr<IPDBEnumSymbols> findAllChildren(PDB_SymType Type) const;
   std::unique_ptr<IPDBEnumSymbols> findAllChildren() const;
@@ -143,7 +140,14 @@
                                                      StringRef Name,
                                                      PDB_NameSearchFlags Flags,
                                                      uint32_t RVA) const;
+  std::unique_ptr<IPDBEnumSymbols> findInlineFramesByVA(uint64_t VA) const;
   std::unique_ptr<IPDBEnumSymbols> findInlineFramesByRVA(uint32_t RVA) const;
+  std::unique_ptr<IPDBEnumLineNumbers>
+  findInlineeLinesByVA(uint64_t VA, uint32_t Length) const;
+  std::unique_ptr<IPDBEnumLineNumbers>
+  findInlineeLinesByRVA(uint32_t RVA, uint32_t Length) const;
+
+  std::string getName() const;
 
   const IPDBRawSymbol &getRawSymbol() const { return *RawSymbol; }
   IPDBRawSymbol &getRawSymbol() { return *RawSymbol; }
diff --git a/linux-x64/clang/include/llvm/DebugInfo/PDB/PDBTypes.h b/linux-x64/clang/include/llvm/DebugInfo/PDB/PDBTypes.h
index 742cb85..e7c2ded 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/PDB/PDBTypes.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/PDB/PDBTypes.h
@@ -9,6 +9,7 @@
 #ifndef LLVM_DEBUGINFO_PDB_PDBTYPES_H
 #define LLVM_DEBUGINFO_PDB_PDBTYPES_H
 
+#include "llvm/ADT/APFloat.h"
 #include "llvm/DebugInfo/CodeView/CodeView.h"
 #include "llvm/DebugInfo/PDB/IPDBEnumChildren.h"
 #include "llvm/DebugInfo/PDB/IPDBFrameData.h"
@@ -28,6 +29,7 @@
 class IPDBInjectedSource;
 class IPDBLineNumber;
 class IPDBSectionContrib;
+class IPDBSession;
 class IPDBSourceFile;
 class IPDBTable;
 class PDBSymDumper;
@@ -146,11 +148,69 @@
   WceMipsV2 = 0x169
 };
 
-enum class PDB_SourceCompression {
-  None,
-  RunLengthEncoded,
-  Huffman,
-  LZ,
+// A struct with an inner unnamed enum with explicit underlying type resuls
+// in an enum class that can implicitly convert to the underlying type, which
+// is convenient for this enum.
+struct PDB_SourceCompression {
+  enum : uint32_t {
+    // No compression. Produced e.g. by `link.exe /natvis:foo.natvis`.
+    None,
+    // Not known what produces this.
+    RunLengthEncoded,
+    // Not known what produces this.
+    Huffman,
+    // Not known what produces this.
+    LZ,
+    // Produced e.g. by `csc /debug`. The encoded data is its own mini-stream
+    // with the following layout (in little endian):
+    //   GUID LanguageTypeGuid;
+    //   GUID LanguageVendorGuid;
+    //   GUID DocumentTypeGuid;
+    //   GUID HashFunctionGuid;
+    //   uint32_t HashDataSize;
+    //   uint32_t CompressedDataSize;
+    // Followed by HashDataSize bytes containing a hash checksum,
+    // followed by CompressedDataSize bytes containing source contents.
+    //
+    // CompressedDataSize can be 0, in this case only the hash data is present.
+    // (CompressedDataSize is != 0 e.g. if `/embed` is passed to csc.exe.)
+    // The compressed data format is:
+    //   uint32_t UncompressedDataSize;
+    // If UncompressedDataSize is 0, the data is stored uncompressed and
+    // CompressedDataSize stores the uncompressed size.
+    // If UncompressedDataSize is != 0, then the data is in raw deflate
+    // encoding as described in rfc1951.
+    //
+    // A GUID is 16 bytes, stored in the usual
+    //   uint32_t
+    //   uint16_t
+    //   uint16_t
+    //   uint8_t[24]
+    // layout.
+    //
+    // Well-known GUIDs for LanguageTypeGuid are:
+    //   63a08714-fc37-11d2-904c-00c04fa302a1 C
+    //   3a12d0b7-c26c-11d0-b442-00a0244a1dd2 C++
+    //   3f5162f8-07c6-11d3-9053-00c04fa302a1 C#
+    //   af046cd1-d0e1-11d2-977c-00a0c9b4d50c Cobol
+    //   ab4f38c9-b6e6-43ba-be3b-58080b2ccce3 F#
+    //   3a12d0b4-c26c-11d0-b442-00a0244a1dd2 Java
+    //   3a12d0b6-c26c-11d0-b442-00a0244a1dd2 JScript
+    //   af046cd2-d0e1-11d2-977c-00a0c9b4d50c Pascal
+    //   3a12d0b8-c26c-11d0-b442-00a0244a1dd2 Visual Basic
+    //
+    // Well-known GUIDs for LanguageVendorGuid are:
+    //   994b45c4-e6e9-11d2-903f-00c04fa302a1 Microsoft
+    //
+    // Well-known GUIDs for DocumentTypeGuid are:
+    //   5a869d0b-6611-11d3-bd2a-0000f80849bd Text
+    //
+    // Well-known GUIDs for HashFunctionGuid are:
+    //   406ea660-64cf-4c82-b6f0-42d48172a799 MD5    (HashDataSize is 16)
+    //   ff1816ec-aa5e-4d10-87f7-6f4963833460 SHA1   (HashDataSize is 20)
+    //   8829d00f-11b8-4213-878b-770e8597ac16 SHA256 (HashDataSize is 32)
+    DotNet = 101,
+  };
 };
 
 /// These values correspond to the CV_call_e enumeration, and are documented
@@ -405,6 +465,88 @@
     char *String;
   } Value;
 
+  bool isIntegralType() const {
+    switch (Type) {
+    case Bool:
+    case Int8:
+    case Int16:
+    case Int32:
+    case Int64:
+    case UInt8:
+    case UInt16:
+    case UInt32:
+    case UInt64:
+      return true;
+    default:
+      return false;
+    }
+  }
+
+#define VARIANT_WIDTH(Enum, NumBits)                                           \
+  case PDB_VariantType::Enum:                                                  \
+    return NumBits;
+
+  unsigned getBitWidth() const {
+    switch (Type) {
+      VARIANT_WIDTH(Bool, 1u)
+      VARIANT_WIDTH(Int8, 8u)
+      VARIANT_WIDTH(Int16, 16u)
+      VARIANT_WIDTH(Int32, 32u)
+      VARIANT_WIDTH(Int64, 64u)
+      VARIANT_WIDTH(Single, 32u)
+      VARIANT_WIDTH(Double, 64u)
+      VARIANT_WIDTH(UInt8, 8u)
+      VARIANT_WIDTH(UInt16, 16u)
+      VARIANT_WIDTH(UInt32, 32u)
+      VARIANT_WIDTH(UInt64, 64u)
+    default:
+      assert(false && "Variant::toAPSInt called on non-numeric type");
+      return 0u;
+    }
+  }
+
+#undef VARIANT_WIDTH
+
+#define VARIANT_APSINT(Enum, NumBits, IsUnsigned)                              \
+  case PDB_VariantType::Enum:                                                  \
+    return APSInt(APInt(NumBits, Value.Enum), IsUnsigned);
+
+  APSInt toAPSInt() const {
+    switch (Type) {
+      VARIANT_APSINT(Bool, 1u, true)
+      VARIANT_APSINT(Int8, 8u, false)
+      VARIANT_APSINT(Int16, 16u, false)
+      VARIANT_APSINT(Int32, 32u, false)
+      VARIANT_APSINT(Int64, 64u, false)
+      VARIANT_APSINT(UInt8, 8u, true)
+      VARIANT_APSINT(UInt16, 16u, true)
+      VARIANT_APSINT(UInt32, 32u, true)
+      VARIANT_APSINT(UInt64, 64u, true)
+    default:
+      assert(false && "Variant::toAPSInt called on non-integral type");
+      return APSInt();
+    }
+  }
+
+#undef VARIANT_APSINT
+
+  APFloat toAPFloat() const {
+    // Float constants may be tagged as integers.
+    switch (Type) {
+    case PDB_VariantType::Single:
+    case PDB_VariantType::UInt32:
+    case PDB_VariantType::Int32:
+      return APFloat(Value.Single);
+    case PDB_VariantType::Double:
+    case PDB_VariantType::UInt64:
+    case PDB_VariantType::Int64:
+      return APFloat(Value.Double);
+    default:
+      assert(false && "Variant::toAPFloat called on non-floating-point type");
+      return APFloat::getZero(APFloat::IEEEsingle());
+    }
+  }
+
 #define VARIANT_EQUAL_CASE(Enum)                                               \
   case PDB_VariantType::Enum:                                                  \
     return Value.Enum == Other.Value.Enum;
diff --git a/linux-x64/clang/include/llvm/DebugInfo/Symbolize/DIPrinter.h b/linux-x64/clang/include/llvm/DebugInfo/Symbolize/DIPrinter.h
index db7a61a..3d7e069 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/Symbolize/DIPrinter.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/Symbolize/DIPrinter.h
@@ -14,13 +14,14 @@
 #ifndef LLVM_DEBUGINFO_SYMBOLIZE_DIPRINTER_H
 #define LLVM_DEBUGINFO_SYMBOLIZE_DIPRINTER_H
 
-#include "llvm/Support/raw_ostream.h"
+#include <string>
 
 namespace llvm {
 struct DILineInfo;
 class DIInliningInfo;
 struct DIGlobal;
 struct DILocal;
+class raw_ostream;
 
 namespace symbolize {
 
@@ -34,7 +35,6 @@
   bool PrintPretty;
   int PrintSourceContext;
   bool Verbose;
-  bool Basenames;
   OutputStyle Style;
 
   void print(const DILineInfo &Info, bool Inlined);
@@ -43,11 +43,10 @@
 public:
   DIPrinter(raw_ostream &OS, bool PrintFunctionNames = true,
             bool PrintPretty = false, int PrintSourceContext = 0,
-            bool Verbose = false, bool Basenames = false,
-            OutputStyle Style = OutputStyle::LLVM)
+            bool Verbose = false, OutputStyle Style = OutputStyle::LLVM)
       : OS(OS), PrintFunctionNames(PrintFunctionNames),
         PrintPretty(PrintPretty), PrintSourceContext(PrintSourceContext),
-        Verbose(Verbose), Basenames(Basenames), Style(Style) {}
+        Verbose(Verbose), Style(Style) {}
 
   DIPrinter &operator<<(const DILineInfo &Info);
   DIPrinter &operator<<(const DIInliningInfo &Info);
@@ -58,4 +57,3 @@
 }
 
 #endif
-
diff --git a/linux-x64/clang/include/llvm/DebugInfo/Symbolize/SymbolizableModule.h b/linux-x64/clang/include/llvm/DebugInfo/Symbolize/SymbolizableModule.h
index 506ecc4..51e92b8 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/Symbolize/SymbolizableModule.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/Symbolize/SymbolizableModule.h
@@ -25,11 +25,12 @@
   virtual ~SymbolizableModule() = default;
 
   virtual DILineInfo symbolizeCode(object::SectionedAddress ModuleOffset,
-                                   FunctionNameKind FNKind,
+                                   DILineInfoSpecifier LineInfoSpecifier,
                                    bool UseSymbolTable) const = 0;
   virtual DIInliningInfo
   symbolizeInlinedCode(object::SectionedAddress ModuleOffset,
-                       FunctionNameKind FNKind, bool UseSymbolTable) const = 0;
+                       DILineInfoSpecifier LineInfoSpecifier,
+                       bool UseSymbolTable) const = 0;
   virtual DIGlobal
   symbolizeData(object::SectionedAddress ModuleOffset) const = 0;
   virtual std::vector<DILocal>
diff --git a/linux-x64/clang/include/llvm/DebugInfo/Symbolize/Symbolize.h b/linux-x64/clang/include/llvm/DebugInfo/Symbolize/Symbolize.h
index d3da28c..1c8fa11 100644
--- a/linux-x64/clang/include/llvm/DebugInfo/Symbolize/Symbolize.h
+++ b/linux-x64/clang/include/llvm/DebugInfo/Symbolize/Symbolize.h
@@ -16,6 +16,7 @@
 #include "llvm/DebugInfo/Symbolize/SymbolizableModule.h"
 #include "llvm/Object/Binary.h"
 #include "llvm/Object/ObjectFile.h"
+#include "llvm/Object/ELFObjectFile.h"
 #include "llvm/Support/Error.h"
 #include <algorithm>
 #include <cstdint>
@@ -31,18 +32,23 @@
 using namespace object;
 
 using FunctionNameKind = DILineInfoSpecifier::FunctionNameKind;
+using FileLineInfoKind = DILineInfoSpecifier::FileLineInfoKind;
 
 class LLVMSymbolizer {
 public:
   struct Options {
     FunctionNameKind PrintFunctions = FunctionNameKind::LinkageName;
+    FileLineInfoKind PathStyle = FileLineInfoKind::AbsoluteFilePath;
     bool UseSymbolTable = true;
     bool Demangle = true;
     bool RelativeAddresses = false;
+    bool UntagAddresses = false;
+    bool UseDIA = false;
     std::string DefaultArch;
     std::vector<std::string> DsymHints;
     std::string FallbackDebugPath;
     std::string DWPName;
+    std::vector<std::string> DebugFileDirectory;
   };
 
   LLVMSymbolizer() = default;
@@ -97,6 +103,9 @@
   ObjectFile *lookUpDebuglinkObject(const std::string &Path,
                                     const ObjectFile *Obj,
                                     const std::string &ArchName);
+  ObjectFile *lookUpBuildIDObject(const std::string &Path,
+                                  const ELFObjectFileBase *Obj,
+                                  const std::string &ArchName);
 
   /// Returns pair of pointers to object and debug object.
   Expected<ObjectPair> getOrCreateObjectPair(const std::string &Path,
@@ -108,7 +117,8 @@
   Expected<ObjectFile *> getOrCreateObject(const std::string &Path,
                                           const std::string &ArchName);
 
-  std::map<std::string, std::unique_ptr<SymbolizableModule>> Modules;
+  std::map<std::string, std::unique_ptr<SymbolizableModule>, std::less<>>
+      Modules;
 
   /// Contains cached results of getOrCreateObjectPair().
   std::map<std::pair<std::string, std::string>, ObjectPair>
diff --git a/linux-x64/clang/include/llvm/Demangle/Demangle.h b/linux-x64/clang/include/llvm/Demangle/Demangle.h
index 6fea7ef..b4006a0 100644
--- a/linux-x64/clang/include/llvm/Demangle/Demangle.h
+++ b/linux-x64/clang/include/llvm/Demangle/Demangle.h
@@ -32,8 +32,29 @@
                       int *status);
 
 
-enum MSDemangleFlags { MSDF_None = 0, MSDF_DumpBackrefs = 1 << 0 };
-char *microsoftDemangle(const char *mangled_name, char *buf, size_t *n,
+enum MSDemangleFlags {
+  MSDF_None = 0,
+  MSDF_DumpBackrefs = 1 << 0,
+  MSDF_NoAccessSpecifier = 1 << 1,
+  MSDF_NoCallingConvention = 1 << 2,
+  MSDF_NoReturnType = 1 << 3,
+  MSDF_NoMemberType = 1 << 4,
+};
+
+/// Demangles the Microsoft symbol pointed at by mangled_name and returns it.
+/// Returns a pointer to the start of a null-terminated demangled string on
+/// success, or nullptr on error.
+/// If n_read is non-null and demangling was successful, it receives how many
+/// bytes of the input string were consumed.
+/// buf can point to a *n_buf bytes large buffer where the demangled name is
+/// stored. If the buffer is too small, it is grown with realloc(). If buf is
+/// nullptr, then this malloc()s memory for the result.
+/// *n_buf stores the size of buf on input if buf is non-nullptr, and it
+/// receives the size of the demangled string on output if n_buf is not nullptr.
+/// status receives one of the demangle_ enum entries above if it's not nullptr.
+/// Flags controls various details of the demangled representation.
+char *microsoftDemangle(const char *mangled_name, size_t *n_read,
+                        char *buf, size_t *n_buf,
                         int *status, MSDemangleFlags Flags = MSDF_None);
 
 /// Attempt to demangle a string using different demangling schemes.
diff --git a/linux-x64/clang/include/llvm/Demangle/DemangleConfig.h b/linux-x64/clang/include/llvm/Demangle/DemangleConfig.h
index 73f89d3..b7b7dbd 100644
--- a/linux-x64/clang/include/llvm/Demangle/DemangleConfig.h
+++ b/linux-x64/clang/include/llvm/Demangle/DemangleConfig.h
@@ -15,13 +15,6 @@
 #ifndef LLVM_DEMANGLE_COMPILER_H
 #define LLVM_DEMANGLE_COMPILER_H
 
-#ifdef _MSC_VER
-// snprintf is implemented in VS 2015
-#if _MSC_VER < 1900
-#define snprintf _snprintf_s
-#endif
-#endif
-
 #ifndef __has_feature
 #define __has_feature(x) 0
 #endif
diff --git a/linux-x64/clang/include/llvm/Demangle/ItaniumDemangle.h b/linux-x64/clang/include/llvm/Demangle/ItaniumDemangle.h
index aaccb27..6bfc02d 100644
--- a/linux-x64/clang/include/llvm/Demangle/ItaniumDemangle.h
+++ b/linux-x64/clang/include/llvm/Demangle/ItaniumDemangle.h
@@ -57,6 +57,11 @@
     X(LocalName) \
     X(VectorType) \
     X(PixelVectorType) \
+    X(SyntheticTemplateParamName) \
+    X(TypeTemplateParamDecl) \
+    X(NonTypeTemplateParamDecl) \
+    X(TemplateTemplateParamDecl) \
+    X(TemplateParamPackDecl) \
     X(ParameterPack) \
     X(TemplateArgumentPack) \
     X(ParameterPackExpansion) \
@@ -77,6 +82,7 @@
     X(PostfixExpr) \
     X(ConditionalExpr) \
     X(MemberExpr) \
+    X(SubobjectExpr) \
     X(EnclosingExpr) \
     X(CastExpr) \
     X(SizeofParamPackExpr) \
@@ -86,12 +92,15 @@
     X(PrefixExpr) \
     X(FunctionParam) \
     X(ConversionExpr) \
+    X(PointerToMemberConversionExpr) \
     X(InitListExpr) \
     X(FoldExpr) \
     X(ThrowExpr) \
     X(UUIDOfExpr) \
     X(BoolExpr) \
-    X(IntegerCastExpr) \
+    X(StringLiteral) \
+    X(LambdaExpr) \
+    X(EnumLiteral)    \
     X(IntegerLiteral) \
     X(FloatLiteral) \
     X(DoubleLiteral) \
@@ -303,7 +312,7 @@
   return Q1 = static_cast<Qualifiers>(Q1 | Q2);
 }
 
-class QualType : public Node {
+class QualType final : public Node {
 protected:
   const Qualifiers Quals;
   const Node *Child;
@@ -600,48 +609,12 @@
   }
 };
 
-class NodeOrString {
-  const void *First;
-  const void *Second;
-
-public:
-  /* implicit */ NodeOrString(StringView Str) {
-    const char *FirstChar = Str.begin();
-    const char *SecondChar = Str.end();
-    if (SecondChar == nullptr) {
-      assert(FirstChar == SecondChar);
-      ++FirstChar, ++SecondChar;
-    }
-    First = static_cast<const void *>(FirstChar);
-    Second = static_cast<const void *>(SecondChar);
-  }
-
-  /* implicit */ NodeOrString(Node *N)
-      : First(static_cast<const void *>(N)), Second(nullptr) {}
-  NodeOrString() : First(nullptr), Second(nullptr) {}
-
-  bool isString() const { return Second && First; }
-  bool isNode() const { return First && !Second; }
-  bool isEmpty() const { return !First && !Second; }
-
-  StringView asString() const {
-    assert(isString());
-    return StringView(static_cast<const char *>(First),
-                      static_cast<const char *>(Second));
-  }
-
-  const Node *asNode() const {
-    assert(isNode());
-    return static_cast<const Node *>(First);
-  }
-};
-
 class ArrayType final : public Node {
   const Node *Base;
-  NodeOrString Dimension;
+  Node *Dimension;
 
 public:
-  ArrayType(const Node *Base_, NodeOrString Dimension_)
+  ArrayType(const Node *Base_, Node *Dimension_)
       : Node(KArrayType,
              /*RHSComponentCache=*/Cache::Yes,
              /*ArrayCache=*/Cache::Yes),
@@ -658,10 +631,8 @@
     if (S.back() != ']')
       S += " ";
     S += "[";
-    if (Dimension.isString())
-      S += Dimension.asString();
-    else if (Dimension.isNode())
-      Dimension.asNode()->print(S);
+    if (Dimension)
+      Dimension->print(S);
     S += "]";
     Base->printRight(S);
   }
@@ -927,10 +898,10 @@
 
 class VectorType final : public Node {
   const Node *BaseType;
-  const NodeOrString Dimension;
+  const Node *Dimension;
 
 public:
-  VectorType(const Node *BaseType_, NodeOrString Dimension_)
+  VectorType(const Node *BaseType_, Node *Dimension_)
       : Node(KVectorType), BaseType(BaseType_),
         Dimension(Dimension_) {}
 
@@ -939,19 +910,17 @@
   void printLeft(OutputStream &S) const override {
     BaseType->print(S);
     S += " vector[";
-    if (Dimension.isNode())
-      Dimension.asNode()->print(S);
-    else if (Dimension.isString())
-      S += Dimension.asString();
+    if (Dimension)
+      Dimension->print(S);
     S += "]";
   }
 };
 
 class PixelVectorType final : public Node {
-  const NodeOrString Dimension;
+  const Node *Dimension;
 
 public:
-  PixelVectorType(NodeOrString Dimension_)
+  PixelVectorType(const Node *Dimension_)
       : Node(KPixelVectorType), Dimension(Dimension_) {}
 
   template<typename Fn> void match(Fn F) const { F(Dimension); }
@@ -959,11 +928,132 @@
   void printLeft(OutputStream &S) const override {
     // FIXME: This should demangle as "vector pixel".
     S += "pixel vector[";
-    S += Dimension.asString();
+    Dimension->print(S);
     S += "]";
   }
 };
 
+enum class TemplateParamKind { Type, NonType, Template };
+
+/// An invented name for a template parameter for which we don't have a
+/// corresponding template argument.
+///
+/// This node is created when parsing the <lambda-sig> for a lambda with
+/// explicit template arguments, which might be referenced in the parameter
+/// types appearing later in the <lambda-sig>.
+class SyntheticTemplateParamName final : public Node {
+  TemplateParamKind Kind;
+  unsigned Index;
+
+public:
+  SyntheticTemplateParamName(TemplateParamKind Kind_, unsigned Index_)
+      : Node(KSyntheticTemplateParamName), Kind(Kind_), Index(Index_) {}
+
+  template<typename Fn> void match(Fn F) const { F(Kind, Index); }
+
+  void printLeft(OutputStream &S) const override {
+    switch (Kind) {
+    case TemplateParamKind::Type:
+      S += "$T";
+      break;
+    case TemplateParamKind::NonType:
+      S += "$N";
+      break;
+    case TemplateParamKind::Template:
+      S += "$TT";
+      break;
+    }
+    if (Index > 0)
+      S << Index - 1;
+  }
+};
+
+/// A template type parameter declaration, 'typename T'.
+class TypeTemplateParamDecl final : public Node {
+  Node *Name;
+
+public:
+  TypeTemplateParamDecl(Node *Name_)
+      : Node(KTypeTemplateParamDecl, Cache::Yes), Name(Name_) {}
+
+  template<typename Fn> void match(Fn F) const { F(Name); }
+
+  void printLeft(OutputStream &S) const override {
+    S += "typename ";
+  }
+
+  void printRight(OutputStream &S) const override {
+    Name->print(S);
+  }
+};
+
+/// A non-type template parameter declaration, 'int N'.
+class NonTypeTemplateParamDecl final : public Node {
+  Node *Name;
+  Node *Type;
+
+public:
+  NonTypeTemplateParamDecl(Node *Name_, Node *Type_)
+      : Node(KNonTypeTemplateParamDecl, Cache::Yes), Name(Name_), Type(Type_) {}
+
+  template<typename Fn> void match(Fn F) const { F(Name, Type); }
+
+  void printLeft(OutputStream &S) const override {
+    Type->printLeft(S);
+    if (!Type->hasRHSComponent(S))
+      S += " ";
+  }
+
+  void printRight(OutputStream &S) const override {
+    Name->print(S);
+    Type->printRight(S);
+  }
+};
+
+/// A template template parameter declaration,
+/// 'template<typename T> typename N'.
+class TemplateTemplateParamDecl final : public Node {
+  Node *Name;
+  NodeArray Params;
+
+public:
+  TemplateTemplateParamDecl(Node *Name_, NodeArray Params_)
+      : Node(KTemplateTemplateParamDecl, Cache::Yes), Name(Name_),
+        Params(Params_) {}
+
+  template<typename Fn> void match(Fn F) const { F(Name, Params); }
+
+  void printLeft(OutputStream &S) const override {
+    S += "template<";
+    Params.printWithComma(S);
+    S += "> typename ";
+  }
+
+  void printRight(OutputStream &S) const override {
+    Name->print(S);
+  }
+};
+
+/// A template parameter pack declaration, 'typename ...T'.
+class TemplateParamPackDecl final : public Node {
+  Node *Param;
+
+public:
+  TemplateParamPackDecl(Node *Param_)
+      : Node(KTemplateParamPackDecl, Cache::Yes), Param(Param_) {}
+
+  template<typename Fn> void match(Fn F) const { F(Param); }
+
+  void printLeft(OutputStream &S) const override {
+    Param->printLeft(S);
+    S += "...";
+  }
+
+  void printRight(OutputStream &S) const override {
+    Param->printRight(S);
+  }
+};
+
 /// An unexpanded parameter pack (either in the expression or type context). If
 /// this AST is correct, this node will have a ParameterPackExpansion node above
 /// it.
@@ -1410,21 +1500,36 @@
 };
 
 class ClosureTypeName : public Node {
+  NodeArray TemplateParams;
   NodeArray Params;
   StringView Count;
 
 public:
-  ClosureTypeName(NodeArray Params_, StringView Count_)
-      : Node(KClosureTypeName), Params(Params_), Count(Count_) {}
+  ClosureTypeName(NodeArray TemplateParams_, NodeArray Params_,
+                  StringView Count_)
+      : Node(KClosureTypeName), TemplateParams(TemplateParams_),
+        Params(Params_), Count(Count_) {}
 
-  template<typename Fn> void match(Fn F) const { F(Params, Count); }
+  template<typename Fn> void match(Fn F) const {
+    F(TemplateParams, Params, Count);
+  }
+
+  void printDeclarator(OutputStream &S) const {
+    if (!TemplateParams.empty()) {
+      S += "<";
+      TemplateParams.printWithComma(S);
+      S += ">";
+    }
+    S += "(";
+    Params.printWithComma(S);
+    S += ")";
+  }
 
   void printLeft(OutputStream &S) const override {
     S += "\'lambda";
     S += Count;
-    S += "\'(";
-    Params.printWithComma(S);
-    S += ")";
+    S += "\'";
+    printDeclarator(S);
   }
 };
 
@@ -1553,6 +1658,40 @@
   }
 };
 
+class SubobjectExpr : public Node {
+  const Node *Type;
+  const Node *SubExpr;
+  StringView Offset;
+  NodeArray UnionSelectors;
+  bool OnePastTheEnd;
+
+public:
+  SubobjectExpr(const Node *Type_, const Node *SubExpr_, StringView Offset_,
+                NodeArray UnionSelectors_, bool OnePastTheEnd_)
+      : Node(KSubobjectExpr), Type(Type_), SubExpr(SubExpr_), Offset(Offset_),
+        UnionSelectors(UnionSelectors_), OnePastTheEnd(OnePastTheEnd_) {}
+
+  template<typename Fn> void match(Fn F) const {
+    F(Type, SubExpr, Offset, UnionSelectors, OnePastTheEnd);
+  }
+
+  void printLeft(OutputStream &S) const override {
+    SubExpr->print(S);
+    S += ".<";
+    Type->print(S);
+    S += " at offset ";
+    if (Offset.empty()) {
+      S += "0";
+    } else if (Offset[0] == 'n') {
+      S += "-";
+      S += Offset.dropFront();
+    } else {
+      S += Offset;
+    }
+    S += ">";
+  }
+};
+
 class EnclosingExpr : public Node {
   const StringView Prefix;
   const Node *Infix;
@@ -1740,6 +1879,28 @@
   }
 };
 
+class PointerToMemberConversionExpr : public Node {
+  const Node *Type;
+  const Node *SubExpr;
+  StringView Offset;
+
+public:
+  PointerToMemberConversionExpr(const Node *Type_, const Node *SubExpr_,
+                                StringView Offset_)
+      : Node(KPointerToMemberConversionExpr), Type(Type_), SubExpr(SubExpr_),
+        Offset(Offset_) {}
+
+  template<typename Fn> void match(Fn F) const { F(Type, SubExpr, Offset); }
+
+  void printLeft(OutputStream &S) const override {
+    S += "(";
+    Type->print(S);
+    S += ")(";
+    SubExpr->print(S);
+    S += ")";
+  }
+};
+
 class InitListExpr : public Node {
   const Node *Ty;
   NodeArray Inits;
@@ -1902,22 +2063,57 @@
   }
 };
 
-class IntegerCastExpr : public Node {
+class StringLiteral : public Node {
+  const Node *Type;
+
+public:
+  StringLiteral(const Node *Type_) : Node(KStringLiteral), Type(Type_) {}
+
+  template<typename Fn> void match(Fn F) const { F(Type); }
+
+  void printLeft(OutputStream &S) const override {
+    S += "\"<";
+    Type->print(S);
+    S += ">\"";
+  }
+};
+
+class LambdaExpr : public Node {
+  const Node *Type;
+
+public:
+  LambdaExpr(const Node *Type_) : Node(KLambdaExpr), Type(Type_) {}
+
+  template<typename Fn> void match(Fn F) const { F(Type); }
+
+  void printLeft(OutputStream &S) const override {
+    S += "[]";
+    if (Type->getKind() == KClosureTypeName)
+      static_cast<const ClosureTypeName *>(Type)->printDeclarator(S);
+    S += "{...}";
+  }
+};
+
+class EnumLiteral : public Node {
   // ty(integer)
   const Node *Ty;
   StringView Integer;
 
 public:
-  IntegerCastExpr(const Node *Ty_, StringView Integer_)
-      : Node(KIntegerCastExpr), Ty(Ty_), Integer(Integer_) {}
+  EnumLiteral(const Node *Ty_, StringView Integer_)
+      : Node(KEnumLiteral), Ty(Ty_), Integer(Integer_) {}
 
   template<typename Fn> void match(Fn F) const { F(Ty, Integer); }
 
   void printLeft(OutputStream &S) const override {
-    S += "(";
+    S << "(";
     Ty->print(S);
-    S += ")";
-    S += Integer;
+    S << ")";
+
+    if (Integer[0] == 'n')
+      S << "-" << Integer.dropFront(1);
+    else
+      S << Integer;
   }
 };
 
@@ -2039,10 +2235,10 @@
   static_assert(std::is_pod<T>::value,
                 "T is required to be a plain old data type");
 
-  T* First;
-  T* Last;
-  T* Cap;
-  T Inline[N];
+  T* First = nullptr;
+  T* Last = nullptr;
+  T* Cap = nullptr;
+  T Inline[N] = {0};
 
   bool isInline() const { return First == Inline; }
 
@@ -2167,10 +2363,36 @@
   // table.
   PODSmallVector<Node *, 32> Subs;
 
+  using TemplateParamList = PODSmallVector<Node *, 8>;
+
+  class ScopedTemplateParamList {
+    AbstractManglingParser *Parser;
+    size_t OldNumTemplateParamLists;
+    TemplateParamList Params;
+
+  public:
+    ScopedTemplateParamList(AbstractManglingParser *TheParser)
+        : Parser(TheParser),
+          OldNumTemplateParamLists(TheParser->TemplateParams.size()) {
+      Parser->TemplateParams.push_back(&Params);
+    }
+    ~ScopedTemplateParamList() {
+      assert(Parser->TemplateParams.size() >= OldNumTemplateParamLists);
+      Parser->TemplateParams.dropBack(OldNumTemplateParamLists);
+    }
+  };
+
   // Template parameter table. Like the above, but referenced like "T42_".
   // This has a smaller size compared to Subs and Names because it can be
   // stored on the stack.
-  PODSmallVector<Node *, 8> TemplateParams;
+  TemplateParamList OuterTemplateParams;
+
+  // Lists of template parameters indexed by template parameter depth,
+  // referenced like "TL2_4_". If nonempty, element 0 is always
+  // OuterTemplateParams; inner elements are always template parameter lists of
+  // lambda expressions. For a generic lambda with no explicit template
+  // parameter list, the corresponding parameter list pointer will be null.
+  PODSmallVector<TemplateParamList *, 4> TemplateParams;
 
   // Set of unresolved forward <template-param> references. These can occur in a
   // conversion operator's type, and are resolved in the enclosing <encoding>.
@@ -2178,7 +2400,9 @@
 
   bool TryToParseTemplateArgs = true;
   bool PermitForwardTemplateReferences = false;
-  bool ParsingLambdaParams = false;
+  size_t ParsingLambdaParamsAtLevel = (size_t)-1;
+
+  unsigned NumSyntheticTemplateParameters[3] = {};
 
   Alloc ASTAllocator;
 
@@ -2193,9 +2417,11 @@
     Names.clear();
     Subs.clear();
     TemplateParams.clear();
-    ParsingLambdaParams = false;
+    ParsingLambdaParamsAtLevel = (size_t)-1;
     TryToParseTemplateArgs = true;
     PermitForwardTemplateReferences = false;
+    for (int I = 0; I != 3; ++I)
+      NumSyntheticTemplateParameters[I] = 0;
     ASTAllocator.reset();
   }
 
@@ -2253,6 +2479,7 @@
   bool parseSeqId(size_t *Out);
   Node *parseSubstitution();
   Node *parseTemplateParam();
+  Node *parseTemplateParamDecl();
   Node *parseTemplateArgs(bool TagTemplates = false);
   Node *parseTemplateArg();
 
@@ -2268,6 +2495,8 @@
   Node *parseConversionExpr();
   Node *parseBracedExpr();
   Node *parseFoldExpr();
+  Node *parsePointerToMemberConversionExpr();
+  Node *parseSubobjectExpr();
 
   /// Parse the <type> production.
   Node *parseType();
@@ -2301,9 +2530,10 @@
     size_t E = ForwardTemplateRefs.size();
     for (; I < E; ++I) {
       size_t Idx = ForwardTemplateRefs[I]->Index;
-      if (Idx >= TemplateParams.size())
+      if (TemplateParams.empty() || !TemplateParams[0] ||
+          Idx >= TemplateParams[0]->size())
         return true;
-      ForwardTemplateRefs[I]->Ref = TemplateParams[Idx];
+      ForwardTemplateRefs[I]->Ref = (*TemplateParams[0])[Idx];
     }
     ForwardTemplateRefs.dropBack(State.ForwardTemplateRefsBegin);
     return false;
@@ -2470,7 +2700,12 @@
 // <lambda-sig> ::= <parameter type>+  # Parameter types or "v" if the lambda has no parameters
 template <typename Derived, typename Alloc>
 Node *
-AbstractManglingParser<Derived, Alloc>::parseUnnamedTypeName(NameState *) {
+AbstractManglingParser<Derived, Alloc>::parseUnnamedTypeName(NameState *State) {
+  // <template-params> refer to the innermost <template-args>. Clear out any
+  // outer args that we may have inserted into TemplateParams.
+  if (State != nullptr)
+    TemplateParams.clear();
+
   if (consumeIf("Ut")) {
     StringView Count = parseNumber();
     if (!consumeIf('_'))
@@ -2478,22 +2713,59 @@
     return make<UnnamedTypeName>(Count);
   }
   if (consumeIf("Ul")) {
-    NodeArray Params;
-    SwapAndRestore<bool> SwapParams(ParsingLambdaParams, true);
+    SwapAndRestore<size_t> SwapParams(ParsingLambdaParamsAtLevel,
+                                      TemplateParams.size());
+    ScopedTemplateParamList LambdaTemplateParams(this);
+
+    size_t ParamsBegin = Names.size();
+    while (look() == 'T' &&
+           StringView("yptn").find(look(1)) != StringView::npos) {
+      Node *T = parseTemplateParamDecl();
+      if (!T)
+        return nullptr;
+      Names.push_back(T);
+    }
+    NodeArray TempParams = popTrailingNodeArray(ParamsBegin);
+
+    // FIXME: If TempParams is empty and none of the function parameters
+    // includes 'auto', we should remove LambdaTemplateParams from the
+    // TemplateParams list. Unfortunately, we don't find out whether there are
+    // any 'auto' parameters until too late in an example such as:
+    //
+    //   template<typename T> void f(
+    //       decltype([](decltype([]<typename T>(T v) {}),
+    //                   auto) {})) {}
+    //   template<typename T> void f(
+    //       decltype([](decltype([]<typename T>(T w) {}),
+    //                   int) {})) {}
+    //
+    // Here, the type of v is at level 2 but the type of w is at level 1. We
+    // don't find this out until we encounter the type of the next parameter.
+    //
+    // However, compilers can't actually cope with the former example in
+    // practice, and it's likely to be made ill-formed in future, so we don't
+    // need to support it here.
+    //
+    // If we encounter an 'auto' in the function parameter types, we will
+    // recreate a template parameter scope for it, but any intervening lambdas
+    // will be parsed in the 'wrong' template parameter depth.
+    if (TempParams.empty())
+      TemplateParams.pop_back();
+
     if (!consumeIf("vE")) {
-      size_t ParamsBegin = Names.size();
       do {
         Node *P = getDerived().parseType();
         if (P == nullptr)
           return nullptr;
         Names.push_back(P);
       } while (!consumeIf('E'));
-      Params = popTrailingNodeArray(ParamsBegin);
     }
+    NodeArray Params = popTrailingNodeArray(ParamsBegin);
+
     StringView Count = parseNumber();
     if (!consumeIf('_'))
       return nullptr;
-    return make<ClosureTypeName>(Params, Count);
+    return make<ClosureTypeName>(TempParams, Params, Count);
   }
   if (consumeIf("Ub")) {
     (void)parseNumber();
@@ -3300,7 +3572,9 @@
   if (!consumeIf("Dv"))
     return nullptr;
   if (look() >= '1' && look() <= '9') {
-    StringView DimensionNumber = parseNumber();
+    Node *DimensionNumber = make<NameType>(parseNumber());
+    if (!DimensionNumber)
+      return nullptr;
     if (!consumeIf('_'))
       return nullptr;
     if (consumeIf('p'))
@@ -3325,7 +3599,7 @@
   Node *ElemType = getDerived().parseType();
   if (!ElemType)
     return nullptr;
-  return make<VectorType>(ElemType, StringView());
+  return make<VectorType>(ElemType, /*Dimension=*/nullptr);
 }
 
 // <decltype>  ::= Dt <expression> E  # decltype of an id-expression or class member access (C++0x)
@@ -3351,10 +3625,12 @@
   if (!consumeIf('A'))
     return nullptr;
 
-  NodeOrString Dimension;
+  Node *Dimension = nullptr;
 
   if (std::isdigit(look())) {
-    Dimension = parseNumber();
+    Dimension = make<NameType>(parseNumber());
+    if (!Dimension)
+      return nullptr;
     if (!consumeIf('_'))
       return nullptr;
   } else if (!consumeIf('_')) {
@@ -3852,8 +4128,11 @@
 //                  ::= fp <top-level CV-Qualifiers> <parameter-2 non-negative number> _   # L == 0, second and later parameters
 //                  ::= fL <L-1 non-negative number> p <top-level CV-Qualifiers> _         # L > 0, first parameter
 //                  ::= fL <L-1 non-negative number> p <top-level CV-Qualifiers> <parameter-2 non-negative number> _   # L > 0, second and later parameters
+//                  ::= fpT      # 'this' expression (not part of standard?)
 template <typename Derived, typename Alloc>
 Node *AbstractManglingParser<Derived, Alloc>::parseFunctionParam() {
+  if (consumeIf("fpT"))
+    return make<NameType>("this");
   if (consumeIf("fp")) {
     parseCVQualifiers();
     StringView Num = parseNumber();
@@ -3949,6 +4228,7 @@
 //                ::= L <type> <value float> E                           # floating literal
 //                ::= L <string type> E                                  # string literal
 //                ::= L <nullptr type> E                                 # nullptr literal (i.e., "LDnE")
+//                ::= L <lambda type> E                                  # lambda expression
 // FIXME:         ::= L <type> <real-part float> _ <imag-part float> E   # complex floating point literal (C 2000)
 //                ::= L <mangled-name> E                                 # external name
 template <typename Derived, typename Alloc>
@@ -4012,7 +4292,13 @@
     return getDerived().template parseFloatingLiteral<double>();
   case 'e':
     ++First;
+#if defined(__powerpc__) || defined(__s390__)
+    // Handle cases where long doubles encoded with e have the same size
+    // and representation as doubles.
+    return getDerived().template parseFloatingLiteral<double>();
+#else
     return getDerived().template parseFloatingLiteral<long double>();
+#endif
   case '_':
     if (consumeIf("_Z")) {
       Node *R = getDerived().parseEncoding();
@@ -4020,24 +4306,43 @@
         return R;
     }
     return nullptr;
+  case 'A': {
+    Node *T = getDerived().parseType();
+    if (T == nullptr)
+      return nullptr;
+    // FIXME: We need to include the string contents in the mangling.
+    if (consumeIf('E'))
+      return make<StringLiteral>(T);
+    return nullptr;
+  }
+  case 'D':
+    if (consumeIf("DnE"))
+      return make<NameType>("nullptr");
+    return nullptr;
   case 'T':
     // Invalid mangled name per
     //   http://sourcerytools.com/pipermail/cxx-abi-dev/2011-August/002422.html
     return nullptr;
+  case 'U': {
+    // FIXME: Should we support LUb... for block literals?
+    if (look(1) != 'l')
+      return nullptr;
+    Node *T = parseUnnamedTypeName(nullptr);
+    if (!T || !consumeIf('E'))
+      return nullptr;
+    return make<LambdaExpr>(T);
+  }
   default: {
     // might be named type
     Node *T = getDerived().parseType();
     if (T == nullptr)
       return nullptr;
-    StringView N = parseNumber();
-    if (!N.empty()) {
-      if (!consumeIf('E'))
-        return nullptr;
-      return make<IntegerCastExpr>(T, N);
-    }
-    if (consumeIf('E'))
-      return T;
-    return nullptr;
+    StringView N = parseNumber(/*AllowNegative=*/true);
+    if (N.empty())
+      return nullptr;
+    if (!consumeIf('E'))
+      return nullptr;
+    return make<EnumLiteral>(T, N);
   }
   }
 }
@@ -4159,6 +4464,50 @@
   return make<FoldExpr>(IsLeftFold, OperatorName, Pack, Init);
 }
 
+// <expression> ::= mc <parameter type> <expr> [<offset number>] E
+//
+// Not yet in the spec: https://github.com/itanium-cxx-abi/cxx-abi/issues/47
+template <typename Derived, typename Alloc>
+Node *AbstractManglingParser<Derived, Alloc>::parsePointerToMemberConversionExpr() {
+  Node *Ty = getDerived().parseType();
+  if (!Ty)
+    return nullptr;
+  Node *Expr = getDerived().parseExpr();
+  if (!Expr)
+    return nullptr;
+  StringView Offset = getDerived().parseNumber(true);
+  if (!consumeIf('E'))
+    return nullptr;
+  return make<PointerToMemberConversionExpr>(Ty, Expr, Offset);
+}
+
+// <expression> ::= so <referent type> <expr> [<offset number>] <union-selector>* [p] E
+// <union-selector> ::= _ [<number>]
+//
+// Not yet in the spec: https://github.com/itanium-cxx-abi/cxx-abi/issues/47
+template <typename Derived, typename Alloc>
+Node *AbstractManglingParser<Derived, Alloc>::parseSubobjectExpr() {
+  Node *Ty = getDerived().parseType();
+  if (!Ty)
+    return nullptr;
+  Node *Expr = getDerived().parseExpr();
+  if (!Expr)
+    return nullptr;
+  StringView Offset = getDerived().parseNumber(true);
+  size_t SelectorsBegin = Names.size();
+  while (consumeIf('_')) {
+    Node *Selector = make<NameType>(parseNumber());
+    if (!Selector)
+      return nullptr;
+    Names.push_back(Selector);
+  }
+  bool OnePastTheEnd = consumeIf('p');
+  if (!consumeIf('E'))
+    return nullptr;
+  return make<SubobjectExpr>(
+      Ty, Expr, Offset, popTrailingNodeArray(SelectorsBegin), OnePastTheEnd);
+}
+
 // <expression> ::= <unary operator-name> <expression>
 //              ::= <binary operator-name> <expression> <expression>
 //              ::= <ternary operator-name> <expression> <expression> <expression>
@@ -4416,6 +4765,9 @@
     return nullptr;
   case 'm':
     switch (First[1]) {
+    case 'c':
+      First += 2;
+      return parsePointerToMemberConversionExpr();
     case 'i':
       First += 2;
       return getDerived().parseBinaryExpr("-");
@@ -4563,6 +4915,9 @@
         return Ex;
       return make<CastExpr>("static_cast", T, Ex);
     }
+    case 'o':
+      First += 2;
+      return parseSubobjectExpr();
     case 'p': {
       First += 2;
       Node *Child = getDerived().parseExpr();
@@ -4730,6 +5085,16 @@
   switch (look()) {
   case 'T':
     switch (look(1)) {
+    // TA <template-arg>    # template parameter object
+    //
+    // Not yet in the spec: https://github.com/itanium-cxx-abi/cxx-abi/issues/63
+    case 'A': {
+      First += 2;
+      Node *Arg = getDerived().parseTemplateArg();
+      if (Arg == nullptr)
+        return nullptr;
+      return make<SpecialName>("template parameter object for ", Arg);
+    }
     // TV <type>    # virtual table
     case 'V': {
       First += 2;
@@ -4851,6 +5216,22 @@
 //            ::= <special-name>
 template <typename Derived, typename Alloc>
 Node *AbstractManglingParser<Derived, Alloc>::parseEncoding() {
+  // The template parameters of an encoding are unrelated to those of the
+  // enclosing context.
+  class SaveTemplateParams {
+    AbstractManglingParser *Parser;
+    decltype(TemplateParams) OldParams;
+
+  public:
+    SaveTemplateParams(AbstractManglingParser *TheParser) : Parser(TheParser) {
+      OldParams = std::move(Parser->TemplateParams);
+      Parser->TemplateParams.clear();
+    }
+    ~SaveTemplateParams() {
+      Parser->TemplateParams = std::move(OldParams);
+    }
+  } SaveTemplateParams(this);
+
   if (look() == 'G' || look() == 'T')
     return getDerived().parseSpecialName();
 
@@ -4942,7 +5323,12 @@
 #else
     static const size_t mangled_size = 20;  // May need to be adjusted to 16 or 24 on other platforms
 #endif
-    static const size_t max_demangled_size = 40;
+    // `-0x1.ffffffffffffffffffffffffffffp+16383` + 'L' + '\0' == 42 bytes.
+    // 28 'f's * 4 bits == 112 bits, which is the number of mantissa bits.
+    // Negatives are one character longer than positives.
+    // `0x1.` and `p` are constant, and exponents `+16383` and `-16382` are the
+    // same length. 1 sign bit, 112 mantissa bits, and 15 exponent bits == 128.
+    static const size_t max_demangled_size = 42;
     static constexpr const char *spec = "%LaL";
 };
 
@@ -5062,11 +5448,22 @@
 
 // <template-param> ::= T_    # first template parameter
 //                  ::= T <parameter-2 non-negative number> _
+//                  ::= TL <level-1> __
+//                  ::= TL <level-1> _ <parameter-2 non-negative number> _
 template <typename Derived, typename Alloc>
 Node *AbstractManglingParser<Derived, Alloc>::parseTemplateParam() {
   if (!consumeIf('T'))
     return nullptr;
 
+  size_t Level = 0;
+  if (consumeIf('L')) {
+    if (parsePositiveInteger(&Level))
+      return nullptr;
+    ++Level;
+    if (!consumeIf('_'))
+      return nullptr;
+  }
+
   size_t Index = 0;
   if (!consumeIf('_')) {
     if (parsePositiveInteger(&Index))
@@ -5076,15 +5473,11 @@
       return nullptr;
   }
 
-  // Itanium ABI 5.1.8: In a generic lambda, uses of auto in the parameter list
-  // are mangled as the corresponding artificial template type parameter.
-  if (ParsingLambdaParams)
-    return make<NameType>("auto");
-
   // If we're in a context where this <template-param> refers to a
   // <template-arg> further ahead in the mangled name (currently just conversion
   // operator types), then we should only look it up in the right context.
-  if (PermitForwardTemplateReferences) {
+  // This can only happen at the outermost level.
+  if (PermitForwardTemplateReferences && Level == 0) {
     Node *ForwardRef = make<ForwardTemplateReference>(Index);
     if (!ForwardRef)
       return nullptr;
@@ -5094,9 +5487,78 @@
     return ForwardRef;
   }
 
-  if (Index >= TemplateParams.size())
+  if (Level >= TemplateParams.size() || !TemplateParams[Level] ||
+      Index >= TemplateParams[Level]->size()) {
+    // Itanium ABI 5.1.8: In a generic lambda, uses of auto in the parameter
+    // list are mangled as the corresponding artificial template type parameter.
+    if (ParsingLambdaParamsAtLevel == Level && Level <= TemplateParams.size()) {
+      // This will be popped by the ScopedTemplateParamList in
+      // parseUnnamedTypeName.
+      if (Level == TemplateParams.size())
+        TemplateParams.push_back(nullptr);
+      return make<NameType>("auto");
+    }
+
     return nullptr;
-  return TemplateParams[Index];
+  }
+
+  return (*TemplateParams[Level])[Index];
+}
+
+// <template-param-decl> ::= Ty                          # type parameter
+//                       ::= Tn <type>                   # non-type parameter
+//                       ::= Tt <template-param-decl>* E # template parameter
+//                       ::= Tp <template-param-decl>    # parameter pack
+template <typename Derived, typename Alloc>
+Node *AbstractManglingParser<Derived, Alloc>::parseTemplateParamDecl() {
+  auto InventTemplateParamName = [&](TemplateParamKind Kind) {
+    unsigned Index = NumSyntheticTemplateParameters[(int)Kind]++;
+    Node *N = make<SyntheticTemplateParamName>(Kind, Index);
+    if (N) TemplateParams.back()->push_back(N);
+    return N;
+  };
+
+  if (consumeIf("Ty")) {
+    Node *Name = InventTemplateParamName(TemplateParamKind::Type);
+    if (!Name)
+      return nullptr;
+    return make<TypeTemplateParamDecl>(Name);
+  }
+
+  if (consumeIf("Tn")) {
+    Node *Name = InventTemplateParamName(TemplateParamKind::NonType);
+    if (!Name)
+      return nullptr;
+    Node *Type = parseType();
+    if (!Type)
+      return nullptr;
+    return make<NonTypeTemplateParamDecl>(Name, Type);
+  }
+
+  if (consumeIf("Tt")) {
+    Node *Name = InventTemplateParamName(TemplateParamKind::Template);
+    if (!Name)
+      return nullptr;
+    size_t ParamsBegin = Names.size();
+    ScopedTemplateParamList TemplateTemplateParamParams(this);
+    while (!consumeIf("E")) {
+      Node *P = parseTemplateParamDecl();
+      if (!P)
+        return nullptr;
+      Names.push_back(P);
+    }
+    NodeArray Params = popTrailingNodeArray(ParamsBegin);
+    return make<TemplateTemplateParamDecl>(Name, Params);
+  }
+
+  if (consumeIf("Tp")) {
+    Node *P = parseTemplateParamDecl();
+    if (!P)
+      return nullptr;
+    return make<TemplateParamPackDecl>(P);
+  }
+
+  return nullptr;
 }
 
 // <template-arg> ::= <type>                    # type or template
@@ -5153,8 +5615,11 @@
 
   // <template-params> refer to the innermost <template-args>. Clear out any
   // outer args that we may have inserted into TemplateParams.
-  if (TagTemplates)
+  if (TagTemplates) {
     TemplateParams.clear();
+    TemplateParams.push_back(&OuterTemplateParams);
+    OuterTemplateParams.clear();
+  }
 
   size_t ArgsBegin = Names.size();
   while (!consumeIf('E')) {
@@ -5172,7 +5637,7 @@
         if (!TableEntry)
           return nullptr;
       }
-      TemplateParams.push_back(TableEntry);
+      TemplateParams.back()->push_back(TableEntry);
     } else {
       Node *Arg = getDerived().parseTemplateArg();
       if (Arg == nullptr)
diff --git a/linux-x64/clang/include/llvm/Demangle/MicrosoftDemangle.h b/linux-x64/clang/include/llvm/Demangle/MicrosoftDemangle.h
index 382e794..c6f2606 100644
--- a/linux-x64/clang/include/llvm/Demangle/MicrosoftDemangle.h
+++ b/linux-x64/clang/include/llvm/Demangle/MicrosoftDemangle.h
@@ -158,6 +158,7 @@
                                     QualifiedNameNode *QN);
   SymbolNode *demangleDeclarator(StringView &MangledName);
   SymbolNode *demangleMD5Name(StringView &MangledName);
+  SymbolNode *demangleTypeinfoName(StringView &MangledName);
 
   VariableSymbolNode *demangleVariableEncoding(StringView &MangledName,
                                                StorageClass SC);
diff --git a/linux-x64/clang/include/llvm/Demangle/MicrosoftDemangleNodes.h b/linux-x64/clang/include/llvm/Demangle/MicrosoftDemangleNodes.h
index da9d9d5..62e0f47 100644
--- a/linux-x64/clang/include/llvm/Demangle/MicrosoftDemangleNodes.h
+++ b/linux-x64/clang/include/llvm/Demangle/MicrosoftDemangleNodes.h
@@ -16,6 +16,8 @@
 #include "llvm/Demangle/DemangleConfig.h"
 #include "llvm/Demangle/StringView.h"
 #include <array>
+#include <cstdint>
+#include <string>
 
 namespace llvm {
 namespace itanium_demangle {
@@ -73,6 +75,9 @@
   OF_Default = 0,
   OF_NoCallingConvention = 1,
   OF_NoTagSpecifier = 2,
+  OF_NoAccessSpecifier = 4,
+  OF_NoMemberType = 8,
+  OF_NoReturnType = 16,
 };
 
 // Types
@@ -301,8 +306,6 @@
     outputPost(OS, Flags);
   }
 
-  void outputQuals(bool SpaceBefore, bool SpaceAfter) const;
-
   Qualifiers Quals = Q_None;
 };
 
@@ -310,8 +313,8 @@
   explicit PrimitiveTypeNode(PrimitiveKind K)
       : TypeNode(NodeKind::PrimitiveType), PrimKind(K) {}
 
-  void outputPre(OutputStream &OS, OutputFlags Flags) const;
-  void outputPost(OutputStream &OS, OutputFlags Flags) const {}
+  void outputPre(OutputStream &OS, OutputFlags Flags) const override;
+  void outputPost(OutputStream &OS, OutputFlags Flags) const override {}
 
   PrimitiveKind PrimKind;
 };
@@ -471,8 +474,8 @@
 struct TagTypeNode : public TypeNode {
   explicit TagTypeNode(TagKind Tag) : TypeNode(NodeKind::TagType), Tag(Tag) {}
 
-  void outputPre(OutputStream &OS, OutputFlags Flags) const;
-  void outputPost(OutputStream &OS, OutputFlags Flags) const;
+  void outputPre(OutputStream &OS, OutputFlags Flags) const override;
+  void outputPost(OutputStream &OS, OutputFlags Flags) const override;
 
   QualifiedNameNode *QualifiedName = nullptr;
   TagKind Tag;
@@ -481,8 +484,8 @@
 struct ArrayTypeNode : public TypeNode {
   ArrayTypeNode() : TypeNode(NodeKind::ArrayType) {}
 
-  void outputPre(OutputStream &OS, OutputFlags Flags) const;
-  void outputPost(OutputStream &OS, OutputFlags Flags) const;
+  void outputPre(OutputStream &OS, OutputFlags Flags) const override;
+  void outputPost(OutputStream &OS, OutputFlags Flags) const override;
 
   void outputDimensionsImpl(OutputStream &OS, OutputFlags Flags) const;
   void outputOneDimension(OutputStream &OS, OutputFlags Flags, Node *N) const;
@@ -505,7 +508,7 @@
   void outputPre(OutputStream &OS, OutputFlags Flags) const override;
   void outputPost(OutputStream &OS, OutputFlags Flags) const override;
 
-  IdentifierNode *Identifier;
+  IdentifierNode *Identifier = nullptr;
 };
 
 struct NodeArrayNode : public Node {
@@ -581,7 +584,7 @@
 
   void output(OutputStream &OS, OutputFlags Flags) const override;
   QualifiedNameNode *TargetName = nullptr;
-  Qualifiers Quals;
+  Qualifiers Quals = Qualifiers::Q_None;
 };
 
 struct LocalStaticGuardVariableNode : public SymbolNode {
diff --git a/linux-x64/clang/include/llvm/Demangle/Utility.h b/linux-x64/clang/include/llvm/Demangle/Utility.h
index ec23859..846a5f0 100644
--- a/linux-x64/clang/include/llvm/Demangle/Utility.h
+++ b/linux-x64/clang/include/llvm/Demangle/Utility.h
@@ -25,9 +25,9 @@
 // Stream that AST nodes write their string representation into after the AST
 // has been parsed.
 class OutputStream {
-  char *Buffer;
-  size_t CurrentPosition;
-  size_t BufferCapacity;
+  char *Buffer = nullptr;
+  size_t CurrentPosition = 0;
+  size_t BufferCapacity = 0;
 
   // Ensure there is at least n more positions in buffer.
   void grow(size_t N) {
@@ -52,7 +52,7 @@
     char *TempPtr = std::end(Temp);
 
     while (N) {
-      *--TempPtr = '0' + char(N % 10);
+      *--TempPtr = char('0' + N % 10);
       N /= 10;
     }
 
@@ -137,7 +137,7 @@
 
   char *getBuffer() { return Buffer; }
   char *getBufferEnd() { return Buffer + CurrentPosition - 1; }
-  size_t getBufferCapacity() { return BufferCapacity; }
+  size_t getBufferCapacity() const { return BufferCapacity; }
 };
 
 template <class T> class SwapAndRestore {
diff --git a/linux-x64/clang/include/llvm/ExecutionEngine/ExecutionEngine.h b/linux-x64/clang/include/llvm/ExecutionEngine/ExecutionEngine.h
index 68cc920..2e38651 100644
--- a/linux-x64/clang/include/llvm/ExecutionEngine/ExecutionEngine.h
+++ b/linux-x64/clang/include/llvm/ExecutionEngine/ExecutionEngine.h
@@ -21,6 +21,7 @@
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ExecutionEngine/JITSymbol.h"
+#include "llvm/ExecutionEngine/OrcV1Deprecation.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Object/Binary.h"
@@ -141,11 +142,6 @@
       std::shared_ptr<LegacyJITSymbolResolver> SR,
       std::unique_ptr<TargetMachine> TM);
 
-  static ExecutionEngine *(*OrcMCJITReplacementCtor)(
-      std::string *ErrorStr, std::shared_ptr<MCJITMemoryManager> MM,
-      std::shared_ptr<LegacyJITSymbolResolver> SR,
-      std::unique_ptr<TargetMachine> TM);
-
   static ExecutionEngine *(*InterpCtor)(std::unique_ptr<Module> M,
                                         std::string *ErrorStr);
 
@@ -157,6 +153,8 @@
   /// getMangledName - Get mangled name.
   std::string getMangledName(const GlobalValue *GV);
 
+  std::string ErrMsg;
+
 public:
   /// lock - This lock protects the ExecutionEngine and MCJIT classes. It must
   /// be held while changing the internal state of any of those classes.
@@ -274,8 +272,20 @@
   /// object have been relocated using mapSectionAddress.  When this method is
   /// called the MCJIT execution engine will reapply relocations for a loaded
   /// object.  This method has no effect for the interpeter.
+  ///
+  /// Returns true on success, false on failure. Error messages can be retrieved
+  /// by calling getError();
   virtual void finalizeObject() {}
 
+  /// Returns true if an error has been recorded.
+  bool hasError() const { return !ErrMsg.empty(); }
+
+  /// Clear the error message.
+  void clearErrorMessage() { ErrMsg.clear(); }
+
+  /// Returns the most recent error message.
+  const std::string &getErrorMessage() const { return ErrMsg; }
+
   /// runStaticConstructorsDestructors - This method is used to execute all of
   /// the static constructors or destructors for a program.
   ///
@@ -498,7 +508,7 @@
 
   void emitGlobals();
 
-  void EmitGlobalVariable(const GlobalVariable *GV);
+  void emitGlobalVariable(const GlobalVariable *GV);
 
   GenericValue getConstantValue(const Constant *C);
   void LoadValueFromMemory(GenericValue &Result, GenericValue *Ptr,
@@ -537,7 +547,6 @@
   std::string MCPU;
   SmallVector<std::string, 4> MAttrs;
   bool VerifyModules;
-  bool UseOrcMCJITReplacement;
   bool EmulatedTLS = true;
 
 public:
@@ -633,11 +642,6 @@
     return *this;
   }
 
-  // Use OrcMCJITReplacement instead of MCJIT. Off by default.
-  void setUseOrcMCJITReplacement(bool UseOrcMCJITReplacement) {
-    this->UseOrcMCJITReplacement = UseOrcMCJITReplacement;
-  }
-
   void setEmulatedTLS(bool EmulatedTLS) {
     this->EmulatedTLS = EmulatedTLS;
   }
diff --git a/linux-x64/clang/include/llvm/ExecutionEngine/JITEventListener.h b/linux-x64/clang/include/llvm/ExecutionEngine/JITEventListener.h
index 606b6f7..4eefd99 100644
--- a/linux-x64/clang/include/llvm/ExecutionEngine/JITEventListener.h
+++ b/linux-x64/clang/include/llvm/ExecutionEngine/JITEventListener.h
@@ -20,7 +20,6 @@
 #include "llvm/IR/DebugLoc.h"
 #include "llvm/Support/CBindingWrapping.h"
 #include <cstdint>
-#include <vector>
 
 namespace llvm {
 
diff --git a/linux-x64/clang/include/llvm/ExecutionEngine/JITLink/EHFrameSupport.h b/linux-x64/clang/include/llvm/ExecutionEngine/JITLink/EHFrameSupport.h
index 8d2f641..ec78d9d 100644
--- a/linux-x64/clang/include/llvm/ExecutionEngine/JITLink/EHFrameSupport.h
+++ b/linux-x64/clang/include/llvm/ExecutionEngine/JITLink/EHFrameSupport.h
@@ -21,58 +21,40 @@
 namespace llvm {
 namespace jitlink {
 
-/// Registers all FDEs in the given eh-frame section with the current process.
-Error registerEHFrameSection(const void *EHFrameSectionAddr);
-
-/// Deregisters all FDEs in the given eh-frame section with the current process.
-Error deregisterEHFrameSection(const void *EHFrameSectionAddr);
-
 /// Supports registration/deregistration of EH-frames in a target process.
 class EHFrameRegistrar {
 public:
   virtual ~EHFrameRegistrar();
-  virtual Error registerEHFrames(JITTargetAddress EHFrameSectionAddr) = 0;
-  virtual Error deregisterEHFrames(JITTargetAddress EHFrameSectionAddr) = 0;
+  virtual Error registerEHFrames(JITTargetAddress EHFrameSectionAddr,
+                                 size_t EHFrameSectionSize) = 0;
+  virtual Error deregisterEHFrames(JITTargetAddress EHFrameSectionAddr,
+                                   size_t EHFrameSectionSize) = 0;
 };
 
 /// Registers / Deregisters EH-frames in the current process.
 class InProcessEHFrameRegistrar final : public EHFrameRegistrar {
 public:
-  /// Get a reference to the InProcessEHFrameRegistrar singleton.
-  static InProcessEHFrameRegistrar &getInstance();
+  Error registerEHFrames(JITTargetAddress EHFrameSectionAddr,
+                         size_t EHFrameSectionSize) override;
 
-  InProcessEHFrameRegistrar(const InProcessEHFrameRegistrar &) = delete;
-  InProcessEHFrameRegistrar &
-  operator=(const InProcessEHFrameRegistrar &) = delete;
-
-  InProcessEHFrameRegistrar(InProcessEHFrameRegistrar &&) = delete;
-  InProcessEHFrameRegistrar &operator=(InProcessEHFrameRegistrar &&) = delete;
-
-  Error registerEHFrames(JITTargetAddress EHFrameSectionAddr) override {
-    return registerEHFrameSection(
-        jitTargetAddressToPointer<void *>(EHFrameSectionAddr));
-  }
-
-  Error deregisterEHFrames(JITTargetAddress EHFrameSectionAddr) override {
-    return deregisterEHFrameSection(
-        jitTargetAddressToPointer<void *>(EHFrameSectionAddr));
-  }
-
-private:
-  InProcessEHFrameRegistrar();
+  Error deregisterEHFrames(JITTargetAddress EHFrameSectionAddr,
+                           size_t EHFrameSectionSize) override;
 };
 
-using StoreFrameAddressFunction = std::function<void(JITTargetAddress)>;
+using StoreFrameRangeFunction =
+  std::function<void(JITTargetAddress EHFrameSectionAddr,
+                     size_t EHFrameSectionSize)>;
 
-/// Creates a pass that records the address of the EH frame section. If no
-/// eh-frame section is found, it will set EHFrameAddr to zero.
+/// Creates a pass that records the address and size of the EH frame section.
+/// If no eh-frame section is found then the address and size will both be given
+/// as zero.
 ///
 /// Authors of JITLinkContexts can use this function to register a post-fixup
-/// pass that records the address of the eh-frame section. This address can
+/// pass that records the range of the eh-frame section. This range can
 /// be used after finalization to register and deregister the frame.
-AtomGraphPassFunction
+LinkGraphPassFunction
 createEHFrameRecorderPass(const Triple &TT,
-                          StoreFrameAddressFunction StoreFrameAddress);
+                          StoreFrameRangeFunction StoreFrameRange);
 
 } // end namespace jitlink
 } // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/ExecutionEngine/JITLink/ELF.h b/linux-x64/clang/include/llvm/ExecutionEngine/JITLink/ELF.h
new file mode 100644
index 0000000..8912f3a
--- /dev/null
+++ b/linux-x64/clang/include/llvm/ExecutionEngine/JITLink/ELF.h
@@ -0,0 +1,40 @@
+//===------- ELF.h - Generic JIT link function for ELF ------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Generic jit-link functions for ELF.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_EXECUTIONENGINE_JITLINK_ELF_H
+#define LLVM_EXECUTIONENGINE_JITLINK_ELF_H
+
+#include "llvm/ExecutionEngine/JITLink/ELF.h"
+#include "llvm/ExecutionEngine/JITLink/JITLink.h"
+
+namespace llvm {
+namespace jitlink {
+
+/// Create a LinkGraph from an ELF relocatable object.
+///
+/// Note: The graph does not take ownership of the underlying buffer, nor copy
+/// its contents. The caller is responsible for ensuring that the object buffer
+/// outlives the graph.
+Expected<std::unique_ptr<LinkGraph>>
+createLinkGraphFromELFObject(MemoryBufferRef ObjectBuffer);
+
+/// Link the given graph.
+///
+/// Uses conservative defaults for GOT and stub handling based on the target
+/// platform.
+void link_ELF(std::unique_ptr<LinkGraph> G,
+              std::unique_ptr<JITLinkContext> Ctx);
+
+} // end namespace jitlink
+} // end namespace llvm
+
+#endif // LLVM_EXECUTIONENGINE_JITLINK_ELF_H
diff --git a/linux-x64/clang/include/llvm/ExecutionEngine/JITLink/ELF_x86_64.h b/linux-x64/clang/include/llvm/ExecutionEngine/JITLink/ELF_x86_64.h
new file mode 100644
index 0000000..1423b0c
--- /dev/null
+++ b/linux-x64/clang/include/llvm/ExecutionEngine/JITLink/ELF_x86_64.h
@@ -0,0 +1,64 @@
+//===--- ELF_x86_64.h - JIT link functions for ELF/x86-64 ---*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// jit-link functions for ELF/x86-64.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_EXECUTIONENGINE_JITLINK_ELF_X86_64_H
+#define LLVM_EXECUTIONENGINE_JITLINK_ELF_X86_64_H
+
+#include "llvm/ExecutionEngine/JITLink/JITLink.h"
+
+namespace llvm {
+namespace jitlink {
+
+namespace ELF_x86_64_Edges {
+enum ELFX86RelocationKind : Edge::Kind {
+  Branch32 = Edge::FirstRelocation,
+  Branch32ToStub,
+  Pointer32,
+  Pointer64,
+  Pointer64Anon,
+  PCRel32,
+  PCRel32Minus1,
+  PCRel32Minus2,
+  PCRel32Minus4,
+  PCRel32Anon,
+  PCRel32Minus1Anon,
+  PCRel32Minus2Anon,
+  PCRel32Minus4Anon,
+  PCRel32GOTLoad,
+  PCRel32GOT,
+  PCRel32TLV,
+  Delta32,
+  Delta64,
+  NegDelta32,
+  NegDelta64,
+};
+
+} // end namespace ELF_x86_64_Edges
+
+/// Create a LinkGraph from an ELF/x86-64 relocatable object.
+///
+/// Note: The graph does not take ownership of the underlying buffer, nor copy
+/// its contents. The caller is responsible for ensuring that the object buffer
+/// outlives the graph.
+Expected<std::unique_ptr<LinkGraph>>
+createLinkGraphFromELFObject_x86_64(MemoryBufferRef ObjectBuffer);
+
+/// jit-link the given object buffer, which must be a ELF x86-64 object file.
+void link_ELF_x86_64(std::unique_ptr<LinkGraph> G,
+                     std::unique_ptr<JITLinkContext> Ctx);
+
+/// Return the string name of the given ELF x86-64 edge kind.
+StringRef getELFX86RelocationKindName(Edge::Kind R);
+} // end namespace jitlink
+} // end namespace llvm
+
+#endif // LLVM_EXECUTIONENGINE_JITLINK_ELF_X86_64_H
diff --git a/linux-x64/clang/include/llvm/ExecutionEngine/JITLink/JITLink.h b/linux-x64/clang/include/llvm/ExecutionEngine/JITLink/JITLink.h
index be80d44..e8c0e28 100644
--- a/linux-x64/clang/include/llvm/ExecutionEngine/JITLink/JITLink.h
+++ b/linux-x64/clang/include/llvm/ExecutionEngine/JITLink/JITLink.h
@@ -17,6 +17,7 @@
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/Optional.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/ExecutionEngine/JITSymbol.h"
 #include "llvm/Support/Allocator.h"
@@ -34,6 +35,9 @@
 namespace llvm {
 namespace jitlink {
 
+class Symbol;
+class Section;
+
 /// Base class for errors originating in JIT linker, e.g. missing relocation
 /// support.
 class JITLinkError : public ErrorInfo<JITLinkError> {
@@ -50,30 +54,26 @@
   std::string ErrMsg;
 };
 
-// Forward declare the Atom class.
-class Atom;
-
-/// Edge class. Represents both object file relocations, as well as layout and
-/// keep-alive constraints.
+/// Represents fixups and constraints in the LinkGraph.
 class Edge {
 public:
   using Kind = uint8_t;
 
-  using GenericEdgeKind = enum : Kind {
+  enum GenericEdgeKind : Kind {
     Invalid,                    // Invalid edge value.
     FirstKeepAlive,             // Keeps target alive. Offset/addend zero.
     KeepAlive = FirstKeepAlive, // Tag first edge kind that preserves liveness.
-    LayoutNext,                 // Layout constraint. Offset/Addend zero.
     FirstRelocation             // First architecture specific relocation.
   };
 
   using OffsetT = uint32_t;
   using AddendT = int64_t;
 
-  Edge(Kind K, OffsetT Offset, Atom &Target, AddendT Addend)
+  Edge(Kind K, OffsetT Offset, Symbol &Target, AddendT Addend)
       : Target(&Target), Offset(Offset), Addend(Addend), K(K) {}
 
   OffsetT getOffset() const { return Offset; }
+  void setOffset(OffsetT Offset) { this->Offset = Offset; }
   Kind getKind() const { return K; }
   void setKind(Kind K) { this->K = K; }
   bool isRelocation() const { return K >= FirstRelocation; }
@@ -82,169 +82,563 @@
     return K - FirstRelocation;
   }
   bool isKeepAlive() const { return K >= FirstKeepAlive; }
-  Atom &getTarget() const { return *Target; }
-  void setTarget(Atom &Target) { this->Target = &Target; }
+  Symbol &getTarget() const { return *Target; }
+  void setTarget(Symbol &Target) { this->Target = &Target; }
   AddendT getAddend() const { return Addend; }
   void setAddend(AddendT Addend) { this->Addend = Addend; }
 
 private:
-  Atom *Target;
-  OffsetT Offset;
-  AddendT Addend;
+  Symbol *Target = nullptr;
+  OffsetT Offset = 0;
+  AddendT Addend = 0;
   Kind K = 0;
 };
 
-using EdgeVector = std::vector<Edge>;
+/// Returns the string name of the given generic edge kind, or "unknown"
+/// otherwise. Useful for debugging.
+const char *getGenericEdgeKindName(Edge::Kind K);
 
-const StringRef getGenericEdgeKindName(Edge::Kind K);
-
-/// Base Atom class. Used by absolute and undefined atoms.
-class Atom {
-  friend class AtomGraph;
+/// Base class for Addressable entities (externals, absolutes, blocks).
+class Addressable {
+  friend class LinkGraph;
 
 protected:
-  /// Create a named (as yet unresolved) atom.
-  Atom(StringRef Name)
-      : Name(Name), IsDefined(false), IsLive(false), ShouldDiscard(false),
-        IsGlobal(false), IsAbsolute(false), IsCallable(false),
-        IsExported(false), IsWeak(false), HasLayoutNext(false),
-        IsCommon(false) {}
+  Addressable(JITTargetAddress Address, bool IsDefined)
+      : Address(Address), IsDefined(IsDefined), IsAbsolute(false) {}
 
-  /// Create an absolute symbol atom.
-  Atom(StringRef Name, JITTargetAddress Address)
-      : Name(Name), Address(Address), IsDefined(true), IsLive(false),
-        ShouldDiscard(false), IsGlobal(false), IsAbsolute(false),
-        IsCallable(false), IsExported(false), IsWeak(false),
-        HasLayoutNext(false), IsCommon(false) {}
+  Addressable(JITTargetAddress Address)
+      : Address(Address), IsDefined(false), IsAbsolute(true) {
+    assert(!(IsDefined && IsAbsolute) &&
+           "Block cannot be both defined and absolute");
+  }
 
 public:
-  /// Returns true if this atom has a name.
-  bool hasName() const { return Name != StringRef(); }
+  Addressable(const Addressable &) = delete;
+  Addressable &operator=(const Addressable &) = default;
+  Addressable(Addressable &&) = delete;
+  Addressable &operator=(Addressable &&) = default;
 
-  /// Returns the name of this atom.
-  StringRef getName() const { return Name; }
-
-  /// Returns the current target address of this atom.
-  /// The initial target address (for atoms that have one) will be taken from
-  /// the input object file's virtual address space. During the layout phase
-  /// of JIT linking the atom's address will be updated to point to its final
-  /// address in the JIT'd process.
   JITTargetAddress getAddress() const { return Address; }
-
-  /// Set the current target address of this atom.
   void setAddress(JITTargetAddress Address) { this->Address = Address; }
 
-  /// Returns true if this is a defined atom.
-  bool isDefined() const { return IsDefined; }
-
-  /// Returns true if this atom is marked as live.
-  bool isLive() const { return IsLive; }
-
-  /// Mark this atom as live.
-  ///
-  /// Note: Only defined and absolute atoms can be marked live.
-  void setLive(bool IsLive) {
-    assert((IsDefined || IsAbsolute || !IsLive) &&
-           "Only defined and absolute atoms can be marked live");
-    this->IsLive = IsLive;
-  }
-
-  /// Returns true if this atom should be discarded during pruning.
-  bool shouldDiscard() const { return ShouldDiscard; }
-
-  /// Mark this atom to be discarded.
-  ///
-  /// Note: Only defined and absolute atoms can be marked live.
-  void setShouldDiscard(bool ShouldDiscard) {
-    assert((IsDefined || IsAbsolute || !ShouldDiscard) &&
-           "Only defined and absolute atoms can be marked live");
-    this->ShouldDiscard = ShouldDiscard;
-  }
-
-  /// Returns true if this definition is global (i.e. visible outside this
-  /// linkage unit).
-  ///
-  /// Note: This is distict from Exported, which means visibile outside the
-  /// JITDylib that this graph is being linked in to.
-  bool isGlobal() const { return IsGlobal; }
-
-  /// Mark this atom as global.
-  void setGlobal(bool IsGlobal) { this->IsGlobal = IsGlobal; }
-
-  /// Returns true if this atom represents an absolute symbol.
-  bool isAbsolute() const { return IsAbsolute; }
-
-  /// Returns true if this atom is known to be callable.
-  ///
-  /// Primarily provided for easy interoperability with ORC, which uses the
-  /// JITSymbolFlags::Common flag to identify symbols that can be interposed
-  /// with stubs.
-  bool isCallable() const { return IsCallable; }
-
-  /// Mark this atom as callable.
-  void setCallable(bool IsCallable) {
-    assert((IsDefined || IsAbsolute || !IsCallable) &&
-           "Callable atoms must be defined or absolute");
-    this->IsCallable = IsCallable;
-  }
-
-  /// Returns true if this atom should appear in the symbol table of a final
-  /// linked image.
-  bool isExported() const { return IsExported; }
-
-  /// Mark this atom as exported.
-  void setExported(bool IsExported) {
-    assert((!IsExported || ((IsDefined || IsAbsolute) && hasName())) &&
-           "Exported atoms must have names");
-    this->IsExported = IsExported;
-  }
-
-  /// Returns true if this is a weak symbol.
-  bool isWeak() const { return IsWeak; }
-
-  /// Mark this atom as weak.
-  void setWeak(bool IsWeak) { this->IsWeak = IsWeak; }
+  /// Returns true if this is a defined addressable, in which case you
+  /// can downcast this to a .
+  bool isDefined() const { return static_cast<bool>(IsDefined); }
+  bool isAbsolute() const { return static_cast<bool>(IsAbsolute); }
 
 private:
-  StringRef Name;
   JITTargetAddress Address = 0;
-
-  bool IsDefined : 1;
-  bool IsLive : 1;
-  bool ShouldDiscard : 1;
-
-  bool IsGlobal : 1;
-  bool IsAbsolute : 1;
-  bool IsCallable : 1;
-  bool IsExported : 1;
-  bool IsWeak : 1;
-
-protected:
-  // These flags only make sense for DefinedAtom, but we can minimize the size
-  // of DefinedAtom by defining them here.
-  bool HasLayoutNext : 1;
-  bool IsCommon : 1;
+  uint64_t IsDefined : 1;
+  uint64_t IsAbsolute : 1;
 };
 
-// Forward declare DefinedAtom.
-class DefinedAtom;
+using SectionOrdinal = unsigned;
 
-raw_ostream &operator<<(raw_ostream &OS, const Atom &A);
-void printEdge(raw_ostream &OS, const Atom &FixupAtom, const Edge &E,
+/// An Addressable with content and edges.
+class Block : public Addressable {
+  friend class LinkGraph;
+
+private:
+  /// Create a zero-fill defined addressable.
+  Block(Section &Parent, JITTargetAddress Size, JITTargetAddress Address,
+        uint64_t Alignment, uint64_t AlignmentOffset)
+      : Addressable(Address, true), Parent(Parent), Size(Size) {
+    assert(isPowerOf2_64(Alignment) && "Alignment must be power of 2");
+    assert(AlignmentOffset < Alignment &&
+           "Alignment offset cannot exceed alignment");
+    assert(AlignmentOffset <= MaxAlignmentOffset &&
+           "Alignment offset exceeds maximum");
+    P2Align = Alignment ? countTrailingZeros(Alignment) : 0;
+    this->AlignmentOffset = AlignmentOffset;
+  }
+
+  /// Create a defined addressable for the given content.
+  Block(Section &Parent, StringRef Content, JITTargetAddress Address,
+        uint64_t Alignment, uint64_t AlignmentOffset)
+      : Addressable(Address, true), Parent(Parent), Data(Content.data()),
+        Size(Content.size()) {
+    assert(isPowerOf2_64(Alignment) && "Alignment must be power of 2");
+    assert(AlignmentOffset < Alignment &&
+           "Alignment offset cannot exceed alignment");
+    assert(AlignmentOffset <= MaxAlignmentOffset &&
+           "Alignment offset exceeds maximum");
+    P2Align = Alignment ? countTrailingZeros(Alignment) : 0;
+    this->AlignmentOffset = AlignmentOffset;
+  }
+
+public:
+  using EdgeVector = std::vector<Edge>;
+  using edge_iterator = EdgeVector::iterator;
+  using const_edge_iterator = EdgeVector::const_iterator;
+
+  Block(const Block &) = delete;
+  Block &operator=(const Block &) = delete;
+  Block(Block &&) = delete;
+  Block &operator=(Block &&) = delete;
+
+  /// Return the parent section for this block.
+  Section &getSection() const { return Parent; }
+
+  /// Returns true if this is a zero-fill block.
+  ///
+  /// If true, getSize is callable but getContent is not (the content is
+  /// defined to be a sequence of zero bytes of length Size).
+  bool isZeroFill() const { return !Data; }
+
+  /// Returns the size of this defined addressable.
+  size_t getSize() const { return Size; }
+
+  /// Get the content for this block. Block must not be a zero-fill block.
+  StringRef getContent() const {
+    assert(Data && "Section does not contain content");
+    return StringRef(Data, Size);
+  }
+
+  /// Set the content for this block.
+  /// Caller is responsible for ensuring the underlying bytes are not
+  /// deallocated while pointed to by this block.
+  void setContent(StringRef Content) {
+    Data = Content.data();
+    Size = Content.size();
+  }
+
+  /// Get the alignment for this content.
+  uint64_t getAlignment() const { return 1ull << P2Align; }
+
+  /// Set the alignment for this content.
+  void setAlignment(uint64_t Alignment) {
+    assert(isPowerOf2_64(Alignment) && "Alignment must be a power of two");
+    P2Align = Alignment ? countTrailingZeros(Alignment) : 0;
+  }
+
+  /// Get the alignment offset for this content.
+  uint64_t getAlignmentOffset() const { return AlignmentOffset; }
+
+  /// Set the alignment offset for this content.
+  void setAlignmentOffset(uint64_t AlignmentOffset) {
+    assert(AlignmentOffset < (1ull << P2Align) &&
+           "Alignment offset can't exceed alignment");
+    this->AlignmentOffset = AlignmentOffset;
+  }
+
+  /// Add an edge to this block.
+  void addEdge(Edge::Kind K, Edge::OffsetT Offset, Symbol &Target,
+               Edge::AddendT Addend) {
+    Edges.push_back(Edge(K, Offset, Target, Addend));
+  }
+
+  /// Add an edge by copying an existing one. This is typically used when
+  /// moving edges between blocks.
+  void addEdge(const Edge &E) { Edges.push_back(E); }
+
+  /// Return the list of edges attached to this content.
+  iterator_range<edge_iterator> edges() {
+    return make_range(Edges.begin(), Edges.end());
+  }
+
+  /// Returns the list of edges attached to this content.
+  iterator_range<const_edge_iterator> edges() const {
+    return make_range(Edges.begin(), Edges.end());
+  }
+
+  /// Return the size of the edges list.
+  size_t edges_size() const { return Edges.size(); }
+
+  /// Returns true if the list of edges is empty.
+  bool edges_empty() const { return Edges.empty(); }
+
+  /// Remove the edge pointed to by the given iterator.
+  /// Returns an iterator to the new next element.
+  edge_iterator removeEdge(edge_iterator I) { return Edges.erase(I); }
+
+private:
+  static constexpr uint64_t MaxAlignmentOffset = (1ULL << 57) - 1;
+
+  uint64_t P2Align : 5;
+  uint64_t AlignmentOffset : 57;
+  Section &Parent;
+  const char *Data = nullptr;
+  size_t Size = 0;
+  std::vector<Edge> Edges;
+};
+
+/// Describes symbol linkage. This can be used to make resolve definition
+/// clashes.
+enum class Linkage : uint8_t {
+  Strong,
+  Weak,
+};
+
+/// For errors and debugging output.
+const char *getLinkageName(Linkage L);
+
+/// Defines the scope in which this symbol should be visible:
+///   Default -- Visible in the public interface of the linkage unit.
+///   Hidden -- Visible within the linkage unit, but not exported from it.
+///   Local -- Visible only within the LinkGraph.
+enum class Scope : uint8_t { Default, Hidden, Local };
+
+/// For debugging output.
+const char *getScopeName(Scope S);
+
+raw_ostream &operator<<(raw_ostream &OS, const Block &B);
+
+/// Symbol representation.
+///
+/// Symbols represent locations within Addressable objects.
+/// They can be either Named or Anonymous.
+/// Anonymous symbols have neither linkage nor visibility, and must point at
+/// ContentBlocks.
+/// Named symbols may be in one of four states:
+///   - Null: Default initialized. Assignable, but otherwise unusable.
+///   - Defined: Has both linkage and visibility and points to a ContentBlock
+///   - Common: Has both linkage and visibility, points to a null Addressable.
+///   - External: Has neither linkage nor visibility, points to an external
+///     Addressable.
+///
+class Symbol {
+  friend class LinkGraph;
+
+private:
+  Symbol(Addressable &Base, JITTargetAddress Offset, StringRef Name,
+         JITTargetAddress Size, Linkage L, Scope S, bool IsLive,
+         bool IsCallable)
+      : Name(Name), Base(&Base), Offset(Offset), Size(Size) {
+    assert(Offset <= MaxOffset && "Offset out of range");
+    setLinkage(L);
+    setScope(S);
+    setLive(IsLive);
+    setCallable(IsCallable);
+  }
+
+  static Symbol &constructCommon(void *SymStorage, Block &Base, StringRef Name,
+                                 JITTargetAddress Size, Scope S, bool IsLive) {
+    assert(SymStorage && "Storage cannot be null");
+    assert(!Name.empty() && "Common symbol name cannot be empty");
+    assert(Base.isDefined() &&
+           "Cannot create common symbol from undefined block");
+    assert(static_cast<Block &>(Base).getSize() == Size &&
+           "Common symbol size should match underlying block size");
+    auto *Sym = reinterpret_cast<Symbol *>(SymStorage);
+    new (Sym) Symbol(Base, 0, Name, Size, Linkage::Weak, S, IsLive, false);
+    return *Sym;
+  }
+
+  static Symbol &constructExternal(void *SymStorage, Addressable &Base,
+                                   StringRef Name, JITTargetAddress Size,
+                                   Linkage L) {
+    assert(SymStorage && "Storage cannot be null");
+    assert(!Base.isDefined() &&
+           "Cannot create external symbol from defined block");
+    assert(!Name.empty() && "External symbol name cannot be empty");
+    auto *Sym = reinterpret_cast<Symbol *>(SymStorage);
+    new (Sym) Symbol(Base, 0, Name, Size, L, Scope::Default, false, false);
+    return *Sym;
+  }
+
+  static Symbol &constructAbsolute(void *SymStorage, Addressable &Base,
+                                   StringRef Name, JITTargetAddress Size,
+                                   Linkage L, Scope S, bool IsLive) {
+    assert(SymStorage && "Storage cannot be null");
+    assert(!Base.isDefined() &&
+           "Cannot create absolute symbol from a defined block");
+    auto *Sym = reinterpret_cast<Symbol *>(SymStorage);
+    new (Sym) Symbol(Base, 0, Name, Size, L, S, IsLive, false);
+    return *Sym;
+  }
+
+  static Symbol &constructAnonDef(void *SymStorage, Block &Base,
+                                  JITTargetAddress Offset,
+                                  JITTargetAddress Size, bool IsCallable,
+                                  bool IsLive) {
+    assert(SymStorage && "Storage cannot be null");
+    assert((Offset + Size) <= Base.getSize() &&
+           "Symbol extends past end of block");
+    auto *Sym = reinterpret_cast<Symbol *>(SymStorage);
+    new (Sym) Symbol(Base, Offset, StringRef(), Size, Linkage::Strong,
+                     Scope::Local, IsLive, IsCallable);
+    return *Sym;
+  }
+
+  static Symbol &constructNamedDef(void *SymStorage, Block &Base,
+                                   JITTargetAddress Offset, StringRef Name,
+                                   JITTargetAddress Size, Linkage L, Scope S,
+                                   bool IsLive, bool IsCallable) {
+    assert(SymStorage && "Storage cannot be null");
+    assert((Offset + Size) <= Base.getSize() &&
+           "Symbol extends past end of block");
+    assert(!Name.empty() && "Name cannot be empty");
+    auto *Sym = reinterpret_cast<Symbol *>(SymStorage);
+    new (Sym) Symbol(Base, Offset, Name, Size, L, S, IsLive, IsCallable);
+    return *Sym;
+  }
+
+public:
+  /// Create a null Symbol. This allows Symbols to be default initialized for
+  /// use in containers (e.g. as map values). Null symbols are only useful for
+  /// assigning to.
+  Symbol() = default;
+
+  // Symbols are not movable or copyable.
+  Symbol(const Symbol &) = delete;
+  Symbol &operator=(const Symbol &) = delete;
+  Symbol(Symbol &&) = delete;
+  Symbol &operator=(Symbol &&) = delete;
+
+  /// Returns true if this symbol has a name.
+  bool hasName() const { return !Name.empty(); }
+
+  /// Returns the name of this symbol (empty if the symbol is anonymous).
+  StringRef getName() const {
+    assert((!Name.empty() || getScope() == Scope::Local) &&
+           "Anonymous symbol has non-local scope");
+    return Name;
+  }
+
+  /// Rename this symbol. The client is responsible for updating scope and
+  /// linkage if this name-change requires it.
+  void setName(StringRef Name) { this->Name = Name; }
+
+  /// Returns true if this Symbol has content (potentially) defined within this
+  /// object file (i.e. is anything but an external or absolute symbol).
+  bool isDefined() const {
+    assert(Base && "Attempt to access null symbol");
+    return Base->isDefined();
+  }
+
+  /// Returns true if this symbol is live (i.e. should be treated as a root for
+  /// dead stripping).
+  bool isLive() const {
+    assert(Base && "Attempting to access null symbol");
+    return IsLive;
+  }
+
+  /// Set this symbol's live bit.
+  void setLive(bool IsLive) { this->IsLive = IsLive; }
+
+  /// Returns true is this symbol is callable.
+  bool isCallable() const { return IsCallable; }
+
+  /// Set this symbol's callable bit.
+  void setCallable(bool IsCallable) { this->IsCallable = IsCallable; }
+
+  /// Returns true if the underlying addressable is an unresolved external.
+  bool isExternal() const {
+    assert(Base && "Attempt to access null symbol");
+    return !Base->isDefined() && !Base->isAbsolute();
+  }
+
+  /// Returns true if the underlying addressable is an absolute symbol.
+  bool isAbsolute() const {
+    assert(Base && "Attempt to access null symbol");
+    return !Base->isDefined() && Base->isAbsolute();
+  }
+
+  /// Return the addressable that this symbol points to.
+  Addressable &getAddressable() {
+    assert(Base && "Cannot get underlying addressable for null symbol");
+    return *Base;
+  }
+
+  /// Return the addressable that thsi symbol points to.
+  const Addressable &getAddressable() const {
+    assert(Base && "Cannot get underlying addressable for null symbol");
+    return *Base;
+  }
+
+  /// Return the Block for this Symbol (Symbol must be defined).
+  Block &getBlock() {
+    assert(Base && "Cannot get block for null symbol");
+    assert(Base->isDefined() && "Not a defined symbol");
+    return static_cast<Block &>(*Base);
+  }
+
+  /// Return the Block for this Symbol (Symbol must be defined).
+  const Block &getBlock() const {
+    assert(Base && "Cannot get block for null symbol");
+    assert(Base->isDefined() && "Not a defined symbol");
+    return static_cast<const Block &>(*Base);
+  }
+
+  /// Returns the offset for this symbol within the underlying addressable.
+  JITTargetAddress getOffset() const { return Offset; }
+
+  /// Returns the address of this symbol.
+  JITTargetAddress getAddress() const { return Base->getAddress() + Offset; }
+
+  /// Returns the size of this symbol.
+  JITTargetAddress getSize() const { return Size; }
+
+  /// Returns true if this symbol is backed by a zero-fill block.
+  /// This method may only be called on defined symbols.
+  bool isSymbolZeroFill() const { return getBlock().isZeroFill(); }
+
+  /// Returns the content in the underlying block covered by this symbol.
+  /// This method may only be called on defined non-zero-fill symbols.
+  StringRef getSymbolContent() const {
+    return getBlock().getContent().substr(Offset, Size);
+  }
+
+  /// Get the linkage for this Symbol.
+  Linkage getLinkage() const { return static_cast<Linkage>(L); }
+
+  /// Set the linkage for this Symbol.
+  void setLinkage(Linkage L) {
+    assert((L == Linkage::Strong || (!Base->isAbsolute() && !Name.empty())) &&
+           "Linkage can only be applied to defined named symbols");
+    this->L = static_cast<uint8_t>(L);
+  }
+
+  /// Get the visibility for this Symbol.
+  Scope getScope() const { return static_cast<Scope>(S); }
+
+  /// Set the visibility for this Symbol.
+  void setScope(Scope S) {
+    assert((!Name.empty() || S == Scope::Local) &&
+           "Can not set anonymous symbol to non-local scope");
+    assert((S == Scope::Default || Base->isDefined() || Base->isAbsolute()) &&
+           "Invalid visibility for symbol type");
+    this->S = static_cast<uint8_t>(S);
+  }
+
+private:
+  void makeExternal(Addressable &A) {
+    assert(!A.isDefined() && "Attempting to make external with defined block");
+    Base = &A;
+    Offset = 0;
+    setLinkage(Linkage::Strong);
+    setScope(Scope::Default);
+    IsLive = 0;
+    // note: Size and IsCallable fields left unchanged.
+  }
+
+  void setBlock(Block &B) { Base = &B; }
+
+  void setOffset(uint64_t NewOffset) {
+    assert(NewOffset <= MaxOffset && "Offset out of range");
+    Offset = NewOffset;
+  }
+
+  static constexpr uint64_t MaxOffset = (1ULL << 59) - 1;
+
+  // FIXME: A char* or SymbolStringPtr may pack better.
+  StringRef Name;
+  Addressable *Base = nullptr;
+  uint64_t Offset : 59;
+  uint64_t L : 1;
+  uint64_t S : 2;
+  uint64_t IsLive : 1;
+  uint64_t IsCallable : 1;
+  JITTargetAddress Size = 0;
+};
+
+raw_ostream &operator<<(raw_ostream &OS, const Symbol &A);
+
+void printEdge(raw_ostream &OS, const Block &B, const Edge &E,
                StringRef EdgeKindName);
 
-/// Represents a section address range via a pair of DefinedAtom pointers to
-/// the first and last atoms in the section.
+/// Represents an object file section.
+class Section {
+  friend class LinkGraph;
+
+private:
+  Section(StringRef Name, sys::Memory::ProtectionFlags Prot,
+          SectionOrdinal SecOrdinal)
+      : Name(Name), Prot(Prot), SecOrdinal(SecOrdinal) {}
+
+  using SymbolSet = DenseSet<Symbol *>;
+  using BlockSet = DenseSet<Block *>;
+
+public:
+  using symbol_iterator = SymbolSet::iterator;
+  using const_symbol_iterator = SymbolSet::const_iterator;
+
+  using block_iterator = BlockSet::iterator;
+  using const_block_iterator = BlockSet::const_iterator;
+
+  ~Section();
+
+  /// Returns the name of this section.
+  StringRef getName() const { return Name; }
+
+  /// Returns the protection flags for this section.
+  sys::Memory::ProtectionFlags getProtectionFlags() const { return Prot; }
+
+  /// Returns the ordinal for this section.
+  SectionOrdinal getOrdinal() const { return SecOrdinal; }
+
+  /// Returns an iterator over the blocks defined in this section.
+  iterator_range<block_iterator> blocks() {
+    return make_range(Blocks.begin(), Blocks.end());
+  }
+
+  /// Returns an iterator over the blocks defined in this section.
+  iterator_range<const_block_iterator> blocks() const {
+    return make_range(Blocks.begin(), Blocks.end());
+  }
+
+  /// Returns an iterator over the symbols defined in this section.
+  iterator_range<symbol_iterator> symbols() {
+    return make_range(Symbols.begin(), Symbols.end());
+  }
+
+  /// Returns an iterator over the symbols defined in this section.
+  iterator_range<const_symbol_iterator> symbols() const {
+    return make_range(Symbols.begin(), Symbols.end());
+  }
+
+  /// Return the number of symbols in this section.
+  SymbolSet::size_type symbols_size() { return Symbols.size(); }
+
+private:
+  void addSymbol(Symbol &Sym) {
+    assert(!Symbols.count(&Sym) && "Symbol is already in this section");
+    Symbols.insert(&Sym);
+  }
+
+  void removeSymbol(Symbol &Sym) {
+    assert(Symbols.count(&Sym) && "symbol is not in this section");
+    Symbols.erase(&Sym);
+  }
+
+  void addBlock(Block &B) {
+    assert(!Blocks.count(&B) && "Block is already in this section");
+    Blocks.insert(&B);
+  }
+
+  void removeBlock(Block &B) {
+    assert(Blocks.count(&B) && "Block is not in this section");
+    Blocks.erase(&B);
+  }
+
+  StringRef Name;
+  sys::Memory::ProtectionFlags Prot;
+  SectionOrdinal SecOrdinal = 0;
+  BlockSet Blocks;
+  SymbolSet Symbols;
+};
+
+/// Represents a section address range via a pair of Block pointers
+/// to the first and last Blocks in the section.
 class SectionRange {
 public:
   SectionRange() = default;
-  SectionRange(DefinedAtom *First, DefinedAtom *Last)
-      : First(First), Last(Last) {}
-  DefinedAtom *getFirstAtom() const {
+  SectionRange(const Section &Sec) {
+    if (llvm::empty(Sec.blocks()))
+      return;
+    First = Last = *Sec.blocks().begin();
+    for (auto *B : Sec.blocks()) {
+      if (B->getAddress() < First->getAddress())
+        First = B;
+      if (B->getAddress() > Last->getAddress())
+        Last = B;
+    }
+  }
+  Block *getFirstBlock() const {
     assert((!Last || First) && "First can not be null if end is non-null");
     return First;
   }
-  DefinedAtom *getLastAtom() const {
+  Block *getLastBlock() const {
     assert((First || !Last) && "Last can not be null if start is non-null");
     return Last;
   }
@@ -252,376 +646,294 @@
     assert((First || !Last) && "Last can not be null if start is non-null");
     return !First;
   }
-  JITTargetAddress getStart() const;
-  JITTargetAddress getEnd() const;
-  uint64_t getSize() const;
+  JITTargetAddress getStart() const {
+    return First ? First->getAddress() : 0;
+  }
+  JITTargetAddress getEnd() const {
+    return Last ? Last->getAddress() + Last->getSize() : 0;
+  }
+  uint64_t getSize() const { return getEnd() - getStart(); }
 
 private:
-  DefinedAtom *First = nullptr;
-  DefinedAtom *Last = nullptr;
+  Block *First = nullptr;
+  Block *Last = nullptr;
 };
 
-/// Represents an object file section.
-class Section {
-  friend class AtomGraph;
-
-private:
-  Section(StringRef Name, uint32_t Alignment, sys::Memory::ProtectionFlags Prot,
-          unsigned Ordinal, bool IsZeroFill)
-      : Name(Name), Alignment(Alignment), Prot(Prot), Ordinal(Ordinal),
-        IsZeroFill(IsZeroFill) {
-    assert(isPowerOf2_32(Alignment) && "Alignments must be a power of 2");
-  }
-
-  using DefinedAtomSet = DenseSet<DefinedAtom *>;
-
-public:
-  using atom_iterator = DefinedAtomSet::iterator;
-  using const_atom_iterator = DefinedAtomSet::const_iterator;
-
-  ~Section();
-  StringRef getName() const { return Name; }
-  uint32_t getAlignment() const { return Alignment; }
-  sys::Memory::ProtectionFlags getProtectionFlags() const { return Prot; }
-  unsigned getSectionOrdinal() const { return Ordinal; }
-  size_t getNextAtomOrdinal() { return ++NextAtomOrdinal; }
-
-  bool isZeroFill() const { return IsZeroFill; }
-
-  /// Returns an iterator over the atoms in the section (in no particular
-  /// order).
-  iterator_range<atom_iterator> atoms() {
-    return make_range(DefinedAtoms.begin(), DefinedAtoms.end());
-  }
-
-  /// Returns an iterator over the atoms in the section (in no particular
-  /// order).
-  iterator_range<const_atom_iterator> atoms() const {
-    return make_range(DefinedAtoms.begin(), DefinedAtoms.end());
-  }
-
-  /// Return the number of atoms in this section.
-  DefinedAtomSet::size_type atoms_size() { return DefinedAtoms.size(); }
-
-  /// Return true if this section contains no atoms.
-  bool atoms_empty() const { return DefinedAtoms.empty(); }
-
-  /// Returns the range of this section as the pair of atoms with the lowest
-  /// and highest target address. This operation is expensive, as it
-  /// must traverse all atoms in the section.
-  ///
-  /// Note: If the section is empty, both values will be null. The section
-  /// address will evaluate to null, and the size to zero. If the section
-  /// contains a single atom both values will point to it, the address will
-  /// evaluate to the address of that atom, and the size will be the size of
-  /// that atom.
-  SectionRange getRange() const;
-
-private:
-  void addAtom(DefinedAtom &DA) {
-    assert(!DefinedAtoms.count(&DA) && "Atom is already in this section");
-    DefinedAtoms.insert(&DA);
-  }
-
-  void removeAtom(DefinedAtom &DA) {
-    assert(DefinedAtoms.count(&DA) && "Atom is not in this section");
-    DefinedAtoms.erase(&DA);
-  }
-
-  StringRef Name;
-  uint32_t Alignment = 0;
-  sys::Memory::ProtectionFlags Prot;
-  unsigned Ordinal = 0;
-  unsigned NextAtomOrdinal = 0;
-  bool IsZeroFill = false;
-  DefinedAtomSet DefinedAtoms;
-};
-
-/// Defined atom class. Suitable for use by defined named and anonymous
-/// atoms.
-class DefinedAtom : public Atom {
-  friend class AtomGraph;
-
-private:
-  DefinedAtom(Section &Parent, JITTargetAddress Address, uint32_t Alignment)
-      : Atom("", Address), Parent(Parent), Ordinal(Parent.getNextAtomOrdinal()),
-        Alignment(Alignment) {
-    assert(isPowerOf2_32(Alignment) && "Alignments must be a power of two");
-  }
-
-  DefinedAtom(Section &Parent, StringRef Name, JITTargetAddress Address,
-              uint32_t Alignment)
-      : Atom(Name, Address), Parent(Parent),
-        Ordinal(Parent.getNextAtomOrdinal()), Alignment(Alignment) {
-    assert(isPowerOf2_32(Alignment) && "Alignments must be a power of two");
-  }
-
-public:
-  using edge_iterator = EdgeVector::iterator;
-
-  Section &getSection() const { return Parent; }
-
-  uint64_t getSize() const { return Size; }
-
-  StringRef getContent() const {
-    assert(!Parent.isZeroFill() && "Trying to get content for zero-fill atom");
-    assert(Size <= std::numeric_limits<size_t>::max() &&
-           "Content size too large");
-    return {ContentPtr, static_cast<size_t>(Size)};
-  }
-  void setContent(StringRef Content) {
-    assert(!Parent.isZeroFill() && "Calling setContent on zero-fill atom?");
-    ContentPtr = Content.data();
-    Size = Content.size();
-  }
-
-  bool isZeroFill() const { return Parent.isZeroFill(); }
-
-  void setZeroFill(uint64_t Size) {
-    assert(Parent.isZeroFill() && !ContentPtr &&
-           "Can't set zero-fill length of a non zero-fill atom");
-    this->Size = Size;
-  }
-
-  uint64_t getZeroFillSize() const {
-    assert(Parent.isZeroFill() &&
-           "Can't get zero-fill length of a non zero-fill atom");
-    return Size;
-  }
-
-  uint32_t getAlignment() const { return Alignment; }
-
-  bool hasLayoutNext() const { return HasLayoutNext; }
-  void setLayoutNext(DefinedAtom &Next) {
-    assert(!HasLayoutNext && "Atom already has layout-next constraint");
-    HasLayoutNext = true;
-    Edges.push_back(Edge(Edge::LayoutNext, 0, Next, 0));
-  }
-  DefinedAtom &getLayoutNext() {
-    assert(HasLayoutNext && "Atom does not have a layout-next constraint");
-    DefinedAtom *Next = nullptr;
-    for (auto &E : edges())
-      if (E.getKind() == Edge::LayoutNext) {
-        assert(E.getTarget().isDefined() &&
-               "layout-next target atom must be a defined atom");
-        Next = static_cast<DefinedAtom *>(&E.getTarget());
-        break;
-      }
-    assert(Next && "Missing LayoutNext edge");
-    return *Next;
-  }
-
-  bool isCommon() const { return IsCommon; }
-
-  void addEdge(Edge::Kind K, Edge::OffsetT Offset, Atom &Target,
-               Edge::AddendT Addend) {
-    assert(K != Edge::LayoutNext &&
-           "Layout edges should be added via setLayoutNext");
-    Edges.push_back(Edge(K, Offset, Target, Addend));
-  }
-
-  iterator_range<edge_iterator> edges() {
-    return make_range(Edges.begin(), Edges.end());
-  }
-  size_t edges_size() const { return Edges.size(); }
-  bool edges_empty() const { return Edges.empty(); }
-
-  unsigned getOrdinal() const { return Ordinal; }
-
-private:
-  void setCommon(uint64_t Size) {
-    assert(ContentPtr == 0 && "Atom already has content?");
-    IsCommon = true;
-    setZeroFill(Size);
-  }
-
-  EdgeVector Edges;
-  uint64_t Size = 0;
-  Section &Parent;
-  const char *ContentPtr = nullptr;
-  unsigned Ordinal = 0;
-  uint32_t Alignment = 0;
-};
-
-inline JITTargetAddress SectionRange::getStart() const {
-  return First ? First->getAddress() : 0;
-}
-
-inline JITTargetAddress SectionRange::getEnd() const {
-  return Last ? Last->getAddress() + Last->getSize() : 0;
-}
-
-inline uint64_t SectionRange::getSize() const { return getEnd() - getStart(); }
-
-inline SectionRange Section::getRange() const {
-  if (atoms_empty())
-    return SectionRange();
-  DefinedAtom *First = *DefinedAtoms.begin(), *Last = *DefinedAtoms.begin();
-  for (auto *DA : atoms()) {
-    if (DA->getAddress() < First->getAddress())
-      First = DA;
-    if (DA->getAddress() > Last->getAddress())
-      Last = DA;
-  }
-  return SectionRange(First, Last);
-}
-
-class AtomGraph {
+class LinkGraph {
 private:
   using SectionList = std::vector<std::unique_ptr<Section>>;
-  using AddressToAtomMap = std::map<JITTargetAddress, DefinedAtom *>;
-  using NamedAtomMap = DenseMap<StringRef, Atom *>;
-  using ExternalAtomSet = DenseSet<Atom *>;
+  using ExternalSymbolSet = DenseSet<Symbol *>;
+  using BlockSet = DenseSet<Block *>;
+
+  template <typename... ArgTs>
+  Addressable &createAddressable(ArgTs &&... Args) {
+    Addressable *A =
+        reinterpret_cast<Addressable *>(Allocator.Allocate<Addressable>());
+    new (A) Addressable(std::forward<ArgTs>(Args)...);
+    return *A;
+  }
+
+  void destroyAddressable(Addressable &A) {
+    A.~Addressable();
+    Allocator.Deallocate(&A);
+  }
+
+  template <typename... ArgTs> Block &createBlock(ArgTs &&... Args) {
+    Block *B = reinterpret_cast<Block *>(Allocator.Allocate<Block>());
+    new (B) Block(std::forward<ArgTs>(Args)...);
+    B->getSection().addBlock(*B);
+    return *B;
+  }
+
+  void destroyBlock(Block &B) {
+    B.~Block();
+    Allocator.Deallocate(&B);
+  }
+
+  void destroySymbol(Symbol &S) {
+    S.~Symbol();
+    Allocator.Deallocate(&S);
+  }
+
+  static iterator_range<Section::block_iterator> getSectionBlocks(Section &S) {
+    return S.blocks();
+  }
+
+  static iterator_range<Section::const_block_iterator>
+  getSectionConstBlocks(Section &S) {
+    return S.blocks();
+  }
+
+  static iterator_range<Section::symbol_iterator>
+  getSectionSymbols(Section &S) {
+    return S.symbols();
+  }
+
+  static iterator_range<Section::const_symbol_iterator>
+  getSectionConstSymbols(Section &S) {
+    return S.symbols();
+  }
 
 public:
-  using external_atom_iterator = ExternalAtomSet::iterator;
+  using external_symbol_iterator = ExternalSymbolSet::iterator;
 
   using section_iterator = pointee_iterator<SectionList::iterator>;
   using const_section_iterator = pointee_iterator<SectionList::const_iterator>;
 
-  template <typename SecItrT, typename AtomItrT, typename T>
-  class defined_atom_iterator_impl
+  template <typename OuterItrT, typename InnerItrT, typename T,
+            iterator_range<InnerItrT> getInnerRange(
+                typename OuterItrT::reference)>
+  class nested_collection_iterator
       : public iterator_facade_base<
-            defined_atom_iterator_impl<SecItrT, AtomItrT, T>,
+            nested_collection_iterator<OuterItrT, InnerItrT, T, getInnerRange>,
             std::forward_iterator_tag, T> {
   public:
-    defined_atom_iterator_impl() = default;
+    nested_collection_iterator() = default;
 
-    defined_atom_iterator_impl(SecItrT SI, SecItrT SE)
-        : SI(SI), SE(SE),
-          AI(SI != SE ? SI->atoms().begin() : Section::atom_iterator()) {
-      moveToNextAtomOrEnd();
+    nested_collection_iterator(OuterItrT OuterI, OuterItrT OuterE)
+        : OuterI(OuterI), OuterE(OuterE),
+          InnerI(getInnerBegin(OuterI, OuterE)) {
+      moveToNonEmptyInnerOrEnd();
     }
 
-    bool operator==(const defined_atom_iterator_impl &RHS) const {
-      return (SI == RHS.SI) && (AI == RHS.AI);
+    bool operator==(const nested_collection_iterator &RHS) const {
+      return (OuterI == RHS.OuterI) && (InnerI == RHS.InnerI);
     }
 
     T operator*() const {
-      assert(AI != SI->atoms().end() && "Dereferencing end?");
-      return *AI;
+      assert(InnerI != getInnerRange(*OuterI).end() && "Dereferencing end?");
+      return *InnerI;
     }
 
-    defined_atom_iterator_impl operator++() {
-      ++AI;
-      moveToNextAtomOrEnd();
+    nested_collection_iterator operator++() {
+      ++InnerI;
+      moveToNonEmptyInnerOrEnd();
       return *this;
     }
 
   private:
-    void moveToNextAtomOrEnd() {
-      while (SI != SE && AI == SI->atoms().end()) {
-        ++SI;
-        if (SI == SE)
-          AI = Section::atom_iterator();
-        else
-          AI = SI->atoms().begin();
+    static InnerItrT getInnerBegin(OuterItrT OuterI, OuterItrT OuterE) {
+      return OuterI != OuterE ? getInnerRange(*OuterI).begin() : InnerItrT();
+    }
+
+    void moveToNonEmptyInnerOrEnd() {
+      while (OuterI != OuterE && InnerI == getInnerRange(*OuterI).end()) {
+        ++OuterI;
+        InnerI = getInnerBegin(OuterI, OuterE);
       }
     }
 
-    SecItrT SI, SE;
-    AtomItrT AI;
+    OuterItrT OuterI, OuterE;
+    InnerItrT InnerI;
   };
 
-  using defined_atom_iterator =
-      defined_atom_iterator_impl<section_iterator, Section::atom_iterator,
-                                 DefinedAtom *>;
+  using defined_symbol_iterator =
+      nested_collection_iterator<const_section_iterator,
+                                 Section::symbol_iterator, Symbol *,
+                                 getSectionSymbols>;
 
-  using const_defined_atom_iterator =
-      defined_atom_iterator_impl<const_section_iterator,
-                                 Section::const_atom_iterator,
-                                 const DefinedAtom *>;
+  using const_defined_symbol_iterator =
+      nested_collection_iterator<const_section_iterator,
+                                 Section::const_symbol_iterator, const Symbol *,
+                                 getSectionConstSymbols>;
 
-  AtomGraph(std::string Name, unsigned PointerSize,
+  using block_iterator = nested_collection_iterator<const_section_iterator,
+                                                    Section::block_iterator,
+                                                    Block *, getSectionBlocks>;
+
+  using const_block_iterator =
+      nested_collection_iterator<const_section_iterator,
+                                 Section::const_block_iterator, const Block *,
+                                 getSectionConstBlocks>;
+
+  LinkGraph(std::string Name, const Triple &TT, unsigned PointerSize,
             support::endianness Endianness)
-      : Name(std::move(Name)), PointerSize(PointerSize),
+      : Name(std::move(Name)), TT(TT), PointerSize(PointerSize),
         Endianness(Endianness) {}
 
   /// Returns the name of this graph (usually the name of the original
   /// underlying MemoryBuffer).
   const std::string &getName() { return Name; }
 
+  /// Returns the target triple for this Graph.
+  const Triple &getTargetTriple() const { return TT; }
+
   /// Returns the pointer size for use in this graph.
   unsigned getPointerSize() const { return PointerSize; }
 
-  /// Returns the endianness of atom-content in this graph.
+  /// Returns the endianness of content in this graph.
   support::endianness getEndianness() const { return Endianness; }
 
+  /// Allocate a copy of the given string using the LinkGraph's allocator.
+  /// This can be useful when renaming symbols or adding new content to the
+  /// graph.
+  StringRef allocateString(StringRef Source) {
+    auto *AllocatedBuffer = Allocator.Allocate<char>(Source.size());
+    llvm::copy(Source, AllocatedBuffer);
+    return StringRef(AllocatedBuffer, Source.size());
+  }
+
+  /// Allocate a copy of the given string using the LinkGraph's allocator.
+  /// This can be useful when renaming symbols or adding new content to the
+  /// graph.
+  ///
+  /// Note: This Twine-based overload requires an extra string copy and an
+  /// extra heap allocation for large strings. The StringRef overload should
+  /// be preferred where possible.
+  StringRef allocateString(Twine Source) {
+    SmallString<256> TmpBuffer;
+    auto SourceStr = Source.toStringRef(TmpBuffer);
+    auto *AllocatedBuffer = Allocator.Allocate<char>(SourceStr.size());
+    llvm::copy(SourceStr, AllocatedBuffer);
+    return StringRef(AllocatedBuffer, SourceStr.size());
+  }
+
   /// Create a section with the given name, protection flags, and alignment.
-  Section &createSection(StringRef Name, uint32_t Alignment,
-                         sys::Memory::ProtectionFlags Prot, bool IsZeroFill) {
-    std::unique_ptr<Section> Sec(
-        new Section(Name, Alignment, Prot, Sections.size(), IsZeroFill));
+  Section &createSection(StringRef Name, sys::Memory::ProtectionFlags Prot) {
+    std::unique_ptr<Section> Sec(new Section(Name, Prot, Sections.size()));
     Sections.push_back(std::move(Sec));
     return *Sections.back();
   }
 
-  /// Add an external atom representing an undefined symbol in this graph.
-  Atom &addExternalAtom(StringRef Name) {
-    assert(!NamedAtoms.count(Name) && "Duplicate named atom inserted");
-    Atom *A = reinterpret_cast<Atom *>(
-        AtomAllocator.Allocate(sizeof(Atom), alignof(Atom)));
-    new (A) Atom(Name);
-    ExternalAtoms.insert(A);
-    NamedAtoms[Name] = A;
-    return *A;
+  /// Create a content block.
+  Block &createContentBlock(Section &Parent, StringRef Content,
+                            uint64_t Address, uint64_t Alignment,
+                            uint64_t AlignmentOffset) {
+    return createBlock(Parent, Content, Address, Alignment, AlignmentOffset);
   }
 
-  /// Add an external atom representing an absolute symbol.
-  Atom &addAbsoluteAtom(StringRef Name, JITTargetAddress Addr) {
-    assert(!NamedAtoms.count(Name) && "Duplicate named atom inserted");
-    Atom *A = reinterpret_cast<Atom *>(
-        AtomAllocator.Allocate(sizeof(Atom), alignof(Atom)));
-    new (A) Atom(Name, Addr);
-    AbsoluteAtoms.insert(A);
-    NamedAtoms[Name] = A;
-    return *A;
+  /// Create a zero-fill block.
+  Block &createZeroFillBlock(Section &Parent, uint64_t Size, uint64_t Address,
+                             uint64_t Alignment, uint64_t AlignmentOffset) {
+    return createBlock(Parent, Size, Address, Alignment, AlignmentOffset);
   }
 
-  /// Add an anonymous defined atom to the graph.
+  /// Cache type for the splitBlock function.
+  using SplitBlockCache = Optional<SmallVector<Symbol *, 8>>;
+
+  /// Splits block B at the given index which must be greater than zero.
+  /// If SplitIndex == B.getSize() then this function is a no-op and returns B.
+  /// If SplitIndex < B.getSize() then this function returns a new block
+  /// covering the range [ 0, SplitIndex ), and B is modified to cover the range
+  /// [ SplitIndex, B.size() ).
   ///
-  /// Anonymous atoms have content but no name. They must have an address.
-  DefinedAtom &addAnonymousAtom(Section &Parent, JITTargetAddress Address,
-                                uint32_t Alignment) {
-    DefinedAtom *A = reinterpret_cast<DefinedAtom *>(
-        AtomAllocator.Allocate(sizeof(DefinedAtom), alignof(DefinedAtom)));
-    new (A) DefinedAtom(Parent, Address, Alignment);
-    Parent.addAtom(*A);
-    getAddrToAtomMap()[A->getAddress()] = A;
-    return *A;
+  /// The optional Cache parameter can be used to speed up repeated calls to
+  /// splitBlock for a single block. If the value is None the cache will be
+  /// treated as uninitialized and splitBlock will populate it. Otherwise it
+  /// is assumed to contain the list of Symbols pointing at B, sorted in
+  /// descending order of offset.
+  ///
+  /// Notes:
+  ///
+  /// 1. The newly introduced block will have a new ordinal which will be
+  ///    higher than any other ordinals in the section. Clients are responsible
+  ///    for re-assigning block ordinals to restore a compatible order if
+  ///    needed.
+  ///
+  /// 2. The cache is not automatically updated if new symbols are introduced
+  ///    between calls to splitBlock. Any newly introduced symbols may be
+  ///    added to the cache manually (descending offset order must be
+  ///    preserved), or the cache can be set to None and rebuilt by
+  ///    splitBlock on the next call.
+  Block &splitBlock(Block &B, size_t SplitIndex,
+                    SplitBlockCache *Cache = nullptr);
+
+  /// Add an external symbol.
+  /// Some formats (e.g. ELF) allow Symbols to have sizes. For Symbols whose
+  /// size is not known, you should substitute '0'.
+  /// For external symbols Linkage determines whether the symbol must be
+  /// present during lookup: Externals with strong linkage must be found or
+  /// an error will be emitted. Externals with weak linkage are permitted to
+  /// be undefined, in which case they are assigned a value of 0.
+  Symbol &addExternalSymbol(StringRef Name, uint64_t Size, Linkage L) {
+    auto &Sym =
+        Symbol::constructExternal(Allocator.Allocate<Symbol>(),
+                                  createAddressable(0, false), Name, Size, L);
+    ExternalSymbols.insert(&Sym);
+    return Sym;
   }
 
-  /// Add a defined atom to the graph.
-  ///
-  /// Allocates and constructs a DefinedAtom instance with the given parent,
-  /// name, address, and alignment.
-  DefinedAtom &addDefinedAtom(Section &Parent, StringRef Name,
-                              JITTargetAddress Address, uint32_t Alignment) {
-    assert(!NamedAtoms.count(Name) && "Duplicate named atom inserted");
-    DefinedAtom *A = reinterpret_cast<DefinedAtom *>(
-        AtomAllocator.Allocate(sizeof(DefinedAtom), alignof(DefinedAtom)));
-    new (A) DefinedAtom(Parent, Name, Address, Alignment);
-    Parent.addAtom(*A);
-    getAddrToAtomMap()[A->getAddress()] = A;
-    NamedAtoms[Name] = A;
-    return *A;
+  /// Add an absolute symbol.
+  Symbol &addAbsoluteSymbol(StringRef Name, JITTargetAddress Address,
+                            uint64_t Size, Linkage L, Scope S, bool IsLive) {
+    auto &Sym = Symbol::constructAbsolute(Allocator.Allocate<Symbol>(),
+                                          createAddressable(Address), Name,
+                                          Size, L, S, IsLive);
+    AbsoluteSymbols.insert(&Sym);
+    return Sym;
   }
 
-  /// Add a common symbol atom to the graph.
-  ///
-  /// Adds a common-symbol atom to the graph with the given parent, name,
-  /// address, alignment and size.
-  DefinedAtom &addCommonAtom(Section &Parent, StringRef Name,
-                             JITTargetAddress Address, uint32_t Alignment,
-                             uint64_t Size) {
-    assert(!NamedAtoms.count(Name) && "Duplicate named atom inserted");
-    DefinedAtom *A = reinterpret_cast<DefinedAtom *>(
-        AtomAllocator.Allocate(sizeof(DefinedAtom), alignof(DefinedAtom)));
-    new (A) DefinedAtom(Parent, Name, Address, Alignment);
-    A->setCommon(Size);
-    Parent.addAtom(*A);
-    NamedAtoms[Name] = A;
-    return *A;
+  /// Convenience method for adding a weak zero-fill symbol.
+  Symbol &addCommonSymbol(StringRef Name, Scope S, Section &Section,
+                          JITTargetAddress Address, uint64_t Size,
+                          uint64_t Alignment, bool IsLive) {
+    auto &Sym = Symbol::constructCommon(
+        Allocator.Allocate<Symbol>(),
+        createBlock(Section, Size, Address, Alignment, 0), Name, Size, S,
+        IsLive);
+    Section.addSymbol(Sym);
+    return Sym;
+  }
+
+  /// Add an anonymous symbol.
+  Symbol &addAnonymousSymbol(Block &Content, JITTargetAddress Offset,
+                             JITTargetAddress Size, bool IsCallable,
+                             bool IsLive) {
+    auto &Sym = Symbol::constructAnonDef(Allocator.Allocate<Symbol>(), Content,
+                                         Offset, Size, IsCallable, IsLive);
+    Content.getSection().addSymbol(Sym);
+    return Sym;
+  }
+
+  /// Add a named symbol.
+  Symbol &addDefinedSymbol(Block &Content, JITTargetAddress Offset,
+                           StringRef Name, JITTargetAddress Size, Linkage L,
+                           Scope S, bool IsCallable, bool IsLive) {
+    auto &Sym =
+        Symbol::constructNamedDef(Allocator.Allocate<Symbol>(), Content, Offset,
+                                  Name, Size, L, S, IsLive, IsCallable);
+    Content.getSection().addSymbol(Sym);
+    return Sym;
   }
 
   iterator_range<section_iterator> sections() {
@@ -638,135 +950,90 @@
     return nullptr;
   }
 
-  iterator_range<external_atom_iterator> external_atoms() {
-    return make_range(ExternalAtoms.begin(), ExternalAtoms.end());
+  iterator_range<block_iterator> blocks() {
+    return make_range(block_iterator(Sections.begin(), Sections.end()),
+                      block_iterator(Sections.end(), Sections.end()));
   }
 
-  iterator_range<external_atom_iterator> absolute_atoms() {
-    return make_range(AbsoluteAtoms.begin(), AbsoluteAtoms.end());
+  iterator_range<const_block_iterator> blocks() const {
+    return make_range(const_block_iterator(Sections.begin(), Sections.end()),
+                      const_block_iterator(Sections.end(), Sections.end()));
   }
 
-  iterator_range<defined_atom_iterator> defined_atoms() {
-    return make_range(defined_atom_iterator(Sections.begin(), Sections.end()),
-                      defined_atom_iterator(Sections.end(), Sections.end()));
+  iterator_range<external_symbol_iterator> external_symbols() {
+    return make_range(ExternalSymbols.begin(), ExternalSymbols.end());
   }
 
-  iterator_range<const_defined_atom_iterator> defined_atoms() const {
+  iterator_range<external_symbol_iterator> absolute_symbols() {
+    return make_range(AbsoluteSymbols.begin(), AbsoluteSymbols.end());
+  }
+
+  iterator_range<defined_symbol_iterator> defined_symbols() {
+    return make_range(defined_symbol_iterator(Sections.begin(), Sections.end()),
+                      defined_symbol_iterator(Sections.end(), Sections.end()));
+  }
+
+  iterator_range<const_defined_symbol_iterator> defined_symbols() const {
     return make_range(
-        const_defined_atom_iterator(Sections.begin(), Sections.end()),
-        const_defined_atom_iterator(Sections.end(), Sections.end()));
+        const_defined_symbol_iterator(Sections.begin(), Sections.end()),
+        const_defined_symbol_iterator(Sections.end(), Sections.end()));
   }
 
-  /// Returns the atom with the given name, which must exist in this graph.
-  Atom &getAtomByName(StringRef Name) {
-    auto I = NamedAtoms.find(Name);
-    assert(I != NamedAtoms.end() && "Name not in NamedAtoms map");
-    return *I->second;
-  }
-
-  /// Returns the atom with the given name, which must exist in this graph and
-  /// be a DefinedAtom.
-  DefinedAtom &getDefinedAtomByName(StringRef Name) {
-    auto &A = getAtomByName(Name);
-    assert(A.isDefined() && "Atom is not a defined atom");
-    return static_cast<DefinedAtom &>(A);
-  }
-
-  /// Search for the given atom by name.
-  /// Returns the atom (if found) or an error (if no atom with this name
-  /// exists).
-  Expected<Atom &> findAtomByName(StringRef Name) {
-    auto I = NamedAtoms.find(Name);
-    if (I == NamedAtoms.end())
-      return make_error<JITLinkError>("No atom named " + Name);
-    return *I->second;
-  }
-
-  /// Search for the given defined atom by name.
-  /// Returns the defined atom (if found) or an error (if no atom with this
-  /// name exists, or if one exists but is not a defined atom).
-  Expected<DefinedAtom &> findDefinedAtomByName(StringRef Name) {
-    auto I = NamedAtoms.find(Name);
-    if (I == NamedAtoms.end())
-      return make_error<JITLinkError>("No atom named " + Name);
-    if (!I->second->isDefined())
-      return make_error<JITLinkError>("Atom " + Name +
-                                      " exists but is not a "
-                                      "defined atom");
-    return static_cast<DefinedAtom &>(*I->second);
-  }
-
-  /// Returns the atom covering the given address, or an error if no such atom
-  /// exists.
-  ///
-  /// Returns null if no atom exists at the given address.
-  DefinedAtom *getAtomByAddress(JITTargetAddress Address) {
-    refreshAddrToAtomCache();
-
-    // If there are no defined atoms, bail out early.
-    if (AddrToAtomCache->empty())
-      return nullptr;
-
-    // Find the atom *after* the given address.
-    auto I = AddrToAtomCache->upper_bound(Address);
-
-    // If this address falls before any known atom, bail out.
-    if (I == AddrToAtomCache->begin())
-      return nullptr;
-
-    // The atom we're looking for is the one before the atom we found.
-    --I;
-
-    // Otherwise range check the atom that was found.
-    assert(!I->second->getContent().empty() && "Atom content not set");
-    if (Address >= I->second->getAddress() + I->second->getContent().size())
-      return nullptr;
-
-    return I->second;
-  }
-
-  /// Like getAtomByAddress, but returns an Error if the given address is not
-  /// covered by an atom, rather than a null pointer.
-  Expected<DefinedAtom &> findAtomByAddress(JITTargetAddress Address) {
-    if (auto *DA = getAtomByAddress(Address))
-      return *DA;
-    return make_error<JITLinkError>("No atom at address " +
-                                    formatv("{0:x16}", Address));
-  }
-
-  // Remove the given external atom from the graph.
-  void removeExternalAtom(Atom &A) {
-    assert(!A.isDefined() && !A.isAbsolute() && "A is not an external atom");
-    assert(ExternalAtoms.count(&A) && "A is not in the external atoms set");
-    ExternalAtoms.erase(&A);
-    A.~Atom();
-  }
-
-  /// Remove the given absolute atom from the graph.
-  void removeAbsoluteAtom(Atom &A) {
-    assert(A.isAbsolute() && "A is not an absolute atom");
-    assert(AbsoluteAtoms.count(&A) && "A is not in the absolute atoms set");
-    AbsoluteAtoms.erase(&A);
-    A.~Atom();
-  }
-
-  /// Remove the given defined atom from the graph.
-  void removeDefinedAtom(DefinedAtom &DA) {
-    if (AddrToAtomCache) {
-      assert(AddrToAtomCache->count(DA.getAddress()) &&
-             "Cache exists, but does not contain atom");
-      AddrToAtomCache->erase(DA.getAddress());
+  /// Turn a defined symbol into an external one.
+  void makeExternal(Symbol &Sym) {
+    if (Sym.getAddressable().isAbsolute()) {
+      assert(AbsoluteSymbols.count(&Sym) &&
+             "Sym is not in the absolute symbols set");
+      AbsoluteSymbols.erase(&Sym);
+    } else {
+      assert(Sym.isDefined() && "Sym is not a defined symbol");
+      Section &Sec = Sym.getBlock().getSection();
+      Sec.removeSymbol(Sym);
     }
-    if (DA.hasName()) {
-      assert(NamedAtoms.count(DA.getName()) && "Named atom not in map");
-      NamedAtoms.erase(DA.getName());
-    }
-    DA.getSection().removeAtom(DA);
-    DA.~DefinedAtom();
+    Sym.makeExternal(createAddressable(0, false));
+    ExternalSymbols.insert(&Sym);
   }
 
-  /// Invalidate the atom-to-address map.
-  void invalidateAddrToAtomMap() { AddrToAtomCache = None; }
+  /// Removes an external symbol. Also removes the underlying Addressable.
+  void removeExternalSymbol(Symbol &Sym) {
+    assert(!Sym.isDefined() && !Sym.isAbsolute() &&
+           "Sym is not an external symbol");
+    assert(ExternalSymbols.count(&Sym) && "Symbol is not in the externals set");
+    ExternalSymbols.erase(&Sym);
+    Addressable &Base = *Sym.Base;
+    destroySymbol(Sym);
+    destroyAddressable(Base);
+  }
+
+  /// Remove an absolute symbol. Also removes the underlying Addressable.
+  void removeAbsoluteSymbol(Symbol &Sym) {
+    assert(!Sym.isDefined() && Sym.isAbsolute() &&
+           "Sym is not an absolute symbol");
+    assert(AbsoluteSymbols.count(&Sym) &&
+           "Symbol is not in the absolute symbols set");
+    AbsoluteSymbols.erase(&Sym);
+    Addressable &Base = *Sym.Base;
+    destroySymbol(Sym);
+    destroyAddressable(Base);
+  }
+
+  /// Removes defined symbols. Does not remove the underlying block.
+  void removeDefinedSymbol(Symbol &Sym) {
+    assert(Sym.isDefined() && "Sym is not a defined symbol");
+    Sym.getBlock().getSection().removeSymbol(Sym);
+    destroySymbol(Sym);
+  }
+
+  /// Remove a block.
+  void removeBlock(Block &B) {
+    assert(llvm::none_of(B.getSection().symbols(),
+                         [&](const Symbol *Sym) {
+                           return &Sym->getBlock() == &B;
+                         }) &&
+           "Block still has symbols attached");
+    B.getSection().removeBlock(B);
+    destroyBlock(B);
+  }
 
   /// Dump the graph.
   ///
@@ -778,101 +1045,276 @@
                 std::function<StringRef(Edge::Kind)>());
 
 private:
-  AddressToAtomMap &getAddrToAtomMap() {
-    refreshAddrToAtomCache();
-    return *AddrToAtomCache;
-  }
-
-  const AddressToAtomMap &getAddrToAtomMap() const {
-    refreshAddrToAtomCache();
-    return *AddrToAtomCache;
-  }
-
-  void refreshAddrToAtomCache() const {
-    if (!AddrToAtomCache) {
-      AddrToAtomCache = AddressToAtomMap();
-      for (auto *DA : defined_atoms())
-        (*AddrToAtomCache)[DA->getAddress()] = const_cast<DefinedAtom *>(DA);
-    }
-  }
-
-  // Put the BumpPtrAllocator first so that we don't free any of the atoms in
-  // it until all of their destructors have been run.
-  BumpPtrAllocator AtomAllocator;
+  // Put the BumpPtrAllocator first so that we don't free any of the underlying
+  // memory until the Symbol/Addressable destructors have been run.
+  BumpPtrAllocator Allocator;
 
   std::string Name;
+  Triple TT;
   unsigned PointerSize;
   support::endianness Endianness;
   SectionList Sections;
-  NamedAtomMap NamedAtoms;
-  ExternalAtomSet ExternalAtoms;
-  ExternalAtomSet AbsoluteAtoms;
-  mutable Optional<AddressToAtomMap> AddrToAtomCache;
+  ExternalSymbolSet ExternalSymbols;
+  ExternalSymbolSet AbsoluteSymbols;
 };
 
-/// A function for mutating AtomGraphs.
-using AtomGraphPassFunction = std::function<Error(AtomGraph &)>;
+/// Enables easy lookup of blocks by addresses.
+class BlockAddressMap {
+public:
+  using AddrToBlockMap = std::map<JITTargetAddress, Block *>;
+  using const_iterator = AddrToBlockMap::const_iterator;
 
-/// A list of atom graph passes.
-using AtomGraphPassList = std::vector<AtomGraphPassFunction>;
+  /// A block predicate that always adds all blocks.
+  static bool includeAllBlocks(const Block &B) { return true; }
 
-/// An atom graph pass configuration, consisting of a list of pre-prune,
+  /// A block predicate that always includes blocks with non-null addresses.
+  static bool includeNonNull(const Block &B) { return B.getAddress(); }
+
+  BlockAddressMap() = default;
+
+  /// Add a block to the map. Returns an error if the block overlaps with any
+  /// existing block.
+  template <typename PredFn = decltype(includeAllBlocks)>
+  Error addBlock(Block &B, PredFn Pred = includeAllBlocks) {
+    if (!Pred(B))
+      return Error::success();
+
+    auto I = AddrToBlock.upper_bound(B.getAddress());
+
+    // If we're not at the end of the map, check for overlap with the next
+    // element.
+    if (I != AddrToBlock.end()) {
+      if (B.getAddress() + B.getSize() > I->second->getAddress())
+        return overlapError(B, *I->second);
+    }
+
+    // If we're not at the start of the map, check for overlap with the previous
+    // element.
+    if (I != AddrToBlock.begin()) {
+      auto &PrevBlock = *std::prev(I)->second;
+      if (PrevBlock.getAddress() + PrevBlock.getSize() > B.getAddress())
+        return overlapError(B, PrevBlock);
+    }
+
+    AddrToBlock.insert(I, std::make_pair(B.getAddress(), &B));
+    return Error::success();
+  }
+
+  /// Add a block to the map without checking for overlap with existing blocks.
+  /// The client is responsible for ensuring that the block added does not
+  /// overlap with any existing block.
+  void addBlockWithoutChecking(Block &B) { AddrToBlock[B.getAddress()] = &B; }
+
+  /// Add a range of blocks to the map. Returns an error if any block in the
+  /// range overlaps with any other block in the range, or with any existing
+  /// block in the map.
+  template <typename BlockPtrRange,
+            typename PredFn = decltype(includeAllBlocks)>
+  Error addBlocks(BlockPtrRange &&Blocks, PredFn Pred = includeAllBlocks) {
+    for (auto *B : Blocks)
+      if (auto Err = addBlock(*B, Pred))
+        return Err;
+    return Error::success();
+  }
+
+  /// Add a range of blocks to the map without checking for overlap with
+  /// existing blocks. The client is responsible for ensuring that the block
+  /// added does not overlap with any existing block.
+  template <typename BlockPtrRange>
+  void addBlocksWithoutChecking(BlockPtrRange &&Blocks) {
+    for (auto *B : Blocks)
+      addBlockWithoutChecking(*B);
+  }
+
+  /// Iterates over (Address, Block*) pairs in ascending order of address.
+  const_iterator begin() const { return AddrToBlock.begin(); }
+  const_iterator end() const { return AddrToBlock.end(); }
+
+  /// Returns the block starting at the given address, or nullptr if no such
+  /// block exists.
+  Block *getBlockAt(JITTargetAddress Addr) const {
+    auto I = AddrToBlock.find(Addr);
+    if (I == AddrToBlock.end())
+      return nullptr;
+    return I->second;
+  }
+
+  /// Returns the block covering the given address, or nullptr if no such block
+  /// exists.
+  Block *getBlockCovering(JITTargetAddress Addr) const {
+    auto I = AddrToBlock.upper_bound(Addr);
+    if (I == AddrToBlock.begin())
+      return nullptr;
+    auto *B = std::prev(I)->second;
+    if (Addr < B->getAddress() + B->getSize())
+      return B;
+    return nullptr;
+  }
+
+private:
+  Error overlapError(Block &NewBlock, Block &ExistingBlock) {
+    auto NewBlockEnd = NewBlock.getAddress() + NewBlock.getSize();
+    auto ExistingBlockEnd =
+        ExistingBlock.getAddress() + ExistingBlock.getSize();
+    return make_error<JITLinkError>(
+        "Block at " +
+        formatv("{0:x16} -- {1:x16}", NewBlock.getAddress(), NewBlockEnd) +
+        " overlaps " +
+        formatv("{0:x16} -- {1:x16}", ExistingBlock.getAddress(),
+                ExistingBlockEnd));
+  }
+
+  AddrToBlockMap AddrToBlock;
+};
+
+/// A map of addresses to Symbols.
+class SymbolAddressMap {
+public:
+  using SymbolVector = SmallVector<Symbol *, 1>;
+
+  /// Add a symbol to the SymbolAddressMap.
+  void addSymbol(Symbol &Sym) {
+    AddrToSymbols[Sym.getAddress()].push_back(&Sym);
+  }
+
+  /// Add all symbols in a given range to the SymbolAddressMap.
+  template <typename SymbolPtrCollection>
+  void addSymbols(SymbolPtrCollection &&Symbols) {
+    for (auto *Sym : Symbols)
+      addSymbol(*Sym);
+  }
+
+  /// Returns the list of symbols that start at the given address, or nullptr if
+  /// no such symbols exist.
+  const SymbolVector *getSymbolsAt(JITTargetAddress Addr) const {
+    auto I = AddrToSymbols.find(Addr);
+    if (I == AddrToSymbols.end())
+      return nullptr;
+    return &I->second;
+  }
+
+private:
+  std::map<JITTargetAddress, SymbolVector> AddrToSymbols;
+};
+
+/// A function for mutating LinkGraphs.
+using LinkGraphPassFunction = std::function<Error(LinkGraph &)>;
+
+/// A list of LinkGraph passes.
+using LinkGraphPassList = std::vector<LinkGraphPassFunction>;
+
+/// An LinkGraph pass configuration, consisting of a list of pre-prune,
 /// post-prune, and post-fixup passes.
 struct PassConfiguration {
 
   /// Pre-prune passes.
   ///
   /// These passes are called on the graph after it is built, and before any
-  /// atoms have been pruned.
+  /// symbols have been pruned. Graph nodes still have their original vmaddrs.
   ///
-  /// Notable use cases: Marking atoms live or should-discard.
-  AtomGraphPassList PrePrunePasses;
+  /// Notable use cases: Marking symbols live or should-discard.
+  LinkGraphPassList PrePrunePasses;
 
   /// Post-prune passes.
   ///
-  /// These passes are called on the graph after dead and should-discard atoms
-  /// have been removed, but before fixups are applied.
+  /// These passes are called on the graph after dead stripping, but before
+  /// memory is allocated or nodes assigned their final addresses.
   ///
-  /// Notable use cases: Building GOT, stub, and TLV atoms.
-  AtomGraphPassList PostPrunePasses;
+  /// Notable use cases: Building GOT, stub, and TLV symbols.
+  LinkGraphPassList PostPrunePasses;
+
+  /// Post-allocation passes.
+  ///
+  /// These passes are called on the graph after memory has been allocated and
+  /// defined nodes have been assigned their final addresses, but before the
+  /// context has been notified of these addresses. At this point externals
+  /// have not been resolved, and symbol content has not yet been copied into
+  /// working memory.
+  ///
+  /// Notable use cases: Setting up data structures associated with addresses
+  /// of defined symbols (e.g. a mapping of __dso_handle to JITDylib* for the
+  /// JIT runtime) -- using a PostAllocationPass for this ensures that the
+  /// data structures are in-place before any query for resolved symbols
+  /// can complete.
+  LinkGraphPassList PostAllocationPasses;
+
+  /// Pre-fixup passes.
+  ///
+  /// These passes are called on the graph after memory has been allocated,
+  /// content copied into working memory, and all nodes (including externals)
+  /// have been assigned their final addresses, but before any fixups have been
+  /// applied.
+  ///
+  /// Notable use cases: Late link-time optimizations like GOT and stub
+  /// elimination.
+  LinkGraphPassList PreFixupPasses;
 
   /// Post-fixup passes.
   ///
-  /// These passes are called on the graph after atom contents has been copied
-  /// to working memory, and fixups applied.
+  /// These passes are called on the graph after block contents has been copied
+  /// to working memory, and fixups applied. Graph nodes have been updated to
+  /// their final target vmaddrs.
   ///
   /// Notable use cases: Testing and validation.
-  AtomGraphPassList PostFixupPasses;
+  LinkGraphPassList PostFixupPasses;
 };
 
+/// Flags for symbol lookup.
+///
+/// FIXME: These basically duplicate orc::SymbolLookupFlags -- We should merge
+///        the two types once we have an OrcSupport library.
+enum class SymbolLookupFlags { RequiredSymbol, WeaklyReferencedSymbol };
+
+raw_ostream &operator<<(raw_ostream &OS, const SymbolLookupFlags &LF);
+
 /// A map of symbol names to resolved addresses.
 using AsyncLookupResult = DenseMap<StringRef, JITEvaluatedSymbol>;
 
-/// A function to call with a resolved symbol map (See AsyncLookupResult) or an
-/// error if resolution failed.
-using JITLinkAsyncLookupContinuation =
-    std::function<void(Expected<AsyncLookupResult> LR)>;
+/// A function object to call with a resolved symbol map (See AsyncLookupResult)
+/// or an error if resolution failed.
+class JITLinkAsyncLookupContinuation {
+public:
+  virtual ~JITLinkAsyncLookupContinuation() {}
+  virtual void run(Expected<AsyncLookupResult> LR) = 0;
 
-/// An asynchronous symbol lookup. Performs a search (possibly asynchronously)
-/// for the given symbols, calling the given continuation with either the result
-/// (if the lookup succeeds), or an error (if the lookup fails).
-using JITLinkAsyncLookupFunction =
-    std::function<void(const DenseSet<StringRef> &Symbols,
-                       JITLinkAsyncLookupContinuation LookupContinuation)>;
+private:
+  virtual void anchor();
+};
+
+/// Create a lookup continuation from a function object.
+template <typename Continuation>
+std::unique_ptr<JITLinkAsyncLookupContinuation>
+createLookupContinuation(Continuation Cont) {
+
+  class Impl final : public JITLinkAsyncLookupContinuation {
+  public:
+    Impl(Continuation C) : C(std::move(C)) {}
+    void run(Expected<AsyncLookupResult> LR) override { C(std::move(LR)); }
+
+  private:
+    Continuation C;
+  };
+
+  return std::make_unique<Impl>(std::move(Cont));
+}
 
 /// Holds context for a single jitLink invocation.
 class JITLinkContext {
 public:
+  using LookupMap = DenseMap<StringRef, SymbolLookupFlags>;
+
+  /// Create a JITLinkContext.
+  JITLinkContext(const JITLinkDylib *JD) : JD(JD) {}
+
   /// Destroy a JITLinkContext.
   virtual ~JITLinkContext();
 
+  /// Return the JITLinkDylib that this link is targeting, if any.
+  const JITLinkDylib *getJITLinkDylib() const { return JD; }
+
   /// Return the MemoryManager to be used for this link.
   virtual JITLinkMemoryManager &getMemoryManager() = 0;
 
-  /// Returns a StringRef for the object buffer.
-  /// This method can not be called once takeObjectBuffer has been called.
-  virtual MemoryBufferRef getObjectBuffer() const = 0;
-
   /// Notify this context that linking failed.
   /// Called by JITLink if linking cannot be completed.
   virtual void notifyFailed(Error Err) = 0;
@@ -880,14 +1322,18 @@
   /// Called by JITLink to resolve external symbols. This method is passed a
   /// lookup continutation which it must call with a result to continue the
   /// linking process.
-  virtual void lookup(const DenseSet<StringRef> &Symbols,
-                      JITLinkAsyncLookupContinuation LookupContinuation) = 0;
+  virtual void lookup(const LookupMap &Symbols,
+                      std::unique_ptr<JITLinkAsyncLookupContinuation> LC) = 0;
 
-  /// Called by JITLink once all defined atoms in the graph have been assigned
-  /// their final memory locations in the target process. At this point he
-  /// atom graph can be, inspected to build a symbol table however the atom
+  /// Called by JITLink once all defined symbols in the graph have been assigned
+  /// their final memory locations in the target process. At this point the
+  /// LinkGraph can be inspected to build a symbol table, however the block
   /// content will not generally have been copied to the target location yet.
-  virtual void notifyResolved(AtomGraph &G) = 0;
+  ///
+  /// If the client detects an error in the LinkGraph state (e.g. unexpected or
+  /// missing symbols) they may return an error here. The error will be
+  /// propagated to notifyFailed and the linker will bail out.
+  virtual Error notifyResolved(LinkGraph &G) = 0;
 
   /// Called by JITLink to notify the context that the object has been
   /// finalized (i.e. emitted to memory and memory permissions set). If all of
@@ -904,25 +1350,34 @@
 
   /// Returns the mark-live pass to be used for this link. If no pass is
   /// returned (the default) then the target-specific linker implementation will
-  /// choose a conservative default (usually marking all atoms live).
+  /// choose a conservative default (usually marking all symbols live).
   /// This function is only called if shouldAddDefaultTargetPasses returns true,
   /// otherwise the JITContext is responsible for adding a mark-live pass in
   /// modifyPassConfig.
-  virtual AtomGraphPassFunction getMarkLivePass(const Triple &TT) const;
+  virtual LinkGraphPassFunction getMarkLivePass(const Triple &TT) const;
 
   /// Called by JITLink to modify the pass pipeline prior to linking.
   /// The default version performs no modification.
   virtual Error modifyPassConfig(const Triple &TT, PassConfiguration &Config);
+
+private:
+  const JITLinkDylib *JD = nullptr;
 };
 
-/// Marks all atoms in a graph live. This can be used as a default, conservative
-/// mark-live implementation.
-Error markAllAtomsLive(AtomGraph &G);
+/// Marks all symbols in a graph live. This can be used as a default,
+/// conservative mark-live implementation.
+Error markAllSymbolsLive(LinkGraph &G);
 
-/// Basic JITLink implementation.
+/// Create a LinkGraph from the given object buffer.
 ///
-/// This function will use sensible defaults for GOT and Stub handling.
-void jitLink(std::unique_ptr<JITLinkContext> Ctx);
+/// Note: The graph does not take ownership of the underlying buffer, nor copy
+/// its contents. The caller is responsible for ensuring that the object buffer
+/// outlives the graph.
+Expected<std::unique_ptr<LinkGraph>>
+createLinkGraphFromObject(MemoryBufferRef ObjectBuffer);
+
+/// Link the given graph.
+void link(std::unique_ptr<LinkGraph> G, std::unique_ptr<JITLinkContext> Ctx);
 
 } // end namespace jitlink
 } // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/ExecutionEngine/JITLink/JITLinkDylib.h b/linux-x64/clang/include/llvm/ExecutionEngine/JITLink/JITLinkDylib.h
new file mode 100644
index 0000000..2aa88cb
--- /dev/null
+++ b/linux-x64/clang/include/llvm/ExecutionEngine/JITLink/JITLinkDylib.h
@@ -0,0 +1,24 @@
+//===-- JITLinkDylib.h - JITLink Dylib type ---------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Defines the JITLinkDylib API.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_EXECUTIONENGINE_JITLINK_JITLINKDYLIB_H
+#define LLVM_EXECUTIONENGINE_JITLINK_JITLINKDYLIB_H
+
+namespace llvm {
+namespace jitlink {
+
+class JITLinkDylib {};
+
+} // end namespace jitlink
+} // end namespace llvm
+
+#endif // LLVM_EXECUTIONENGINE_JITLINK_JITLINKDYLIB_H
diff --git a/linux-x64/clang/include/llvm/ExecutionEngine/JITLink/JITLinkMemoryManager.h b/linux-x64/clang/include/llvm/ExecutionEngine/JITLink/JITLinkMemoryManager.h
index 9d0b37f..cee7d6b 100644
--- a/linux-x64/clang/include/llvm/ExecutionEngine/JITLink/JITLinkMemoryManager.h
+++ b/linux-x64/clang/include/llvm/ExecutionEngine/JITLink/JITLinkMemoryManager.h
@@ -14,10 +14,14 @@
 #define LLVM_EXECUTIONENGINE_JITLINK_JITLINKMEMORYMANAGER_H
 
 #include "llvm/ADT/DenseMap.h"
+#include "llvm/ExecutionEngine/JITLink/JITLinkDylib.h"
 #include "llvm/ExecutionEngine/JITSymbol.h"
 #include "llvm/Support/Error.h"
+#include "llvm/Support/MSVCErrorWorkarounds.h"
 #include "llvm/Support/Memory.h"
+
 #include <cstdint>
+#include <future>
 
 namespace llvm {
 namespace jitlink {
@@ -33,20 +37,19 @@
   class SegmentRequest {
   public:
     SegmentRequest() = default;
-    SegmentRequest(size_t ContentSize, unsigned ContentAlign,
-                   uint64_t ZeroFillSize, unsigned ZeroFillAlign)
-        : ContentSize(ContentSize), ZeroFillSize(ZeroFillSize),
-          ContentAlign(ContentAlign), ZeroFillAlign(ZeroFillAlign) {}
+    SegmentRequest(uint64_t Alignment, size_t ContentSize,
+                   uint64_t ZeroFillSize)
+        : Alignment(Alignment), ContentSize(ContentSize),
+          ZeroFillSize(ZeroFillSize) {
+      assert(isPowerOf2_32(Alignment) && "Alignment must be power of 2");
+    }
+    uint64_t getAlignment() const { return Alignment; }
     size_t getContentSize() const { return ContentSize; }
-    unsigned getContentAlignment() const { return ContentAlign; }
     uint64_t getZeroFillSize() const { return ZeroFillSize; }
-    unsigned getZeroFillAlignment() const { return ZeroFillAlign; }
-
   private:
+    uint64_t Alignment = 0;
     size_t ContentSize = 0;
     uint64_t ZeroFillSize = 0;
-    unsigned ContentAlign = 0;
-    unsigned ZeroFillAlign = 0;
   };
 
   using SegmentsRequestMap = DenseMap<unsigned, SegmentRequest>;
@@ -75,6 +78,15 @@
     /// working memory.
     virtual void finalizeAsync(FinalizeContinuation OnFinalize) = 0;
 
+    /// Calls finalizeAsync and waits for completion.
+    Error finalize() {
+      std::promise<MSVCPError> FinalizeResultP;
+      auto FinalizeResultF = FinalizeResultP.get_future();
+      finalizeAsync(
+          [&](Error Err) { FinalizeResultP.set_value(std::move(Err)); });
+      return FinalizeResultF.get();
+    }
+
     /// Should deallocate target memory.
     virtual Error deallocate() = 0;
   };
@@ -82,18 +94,28 @@
   virtual ~JITLinkMemoryManager();
 
   /// Create an Allocation object.
+  ///
+  /// The JD argument represents the target JITLinkDylib, and can be used by
+  /// JITLinkMemoryManager implementers to manage per-dylib allocation pools
+  /// (e.g. one pre-reserved address space slab per dylib to ensure that all
+  /// allocations for the dylib are within a certain range). The JD argument
+  /// may be null (representing an allocation not associated with any
+  /// JITDylib.
+  ///
+  /// The request argument describes the segment sizes and permisssions being
+  /// requested.
   virtual Expected<std::unique_ptr<Allocation>>
-  allocate(const SegmentsRequestMap &Request) = 0;
+  allocate(const JITLinkDylib *JD, const SegmentsRequestMap &Request) = 0;
 };
 
 /// A JITLinkMemoryManager that allocates in-process memory.
 class InProcessMemoryManager : public JITLinkMemoryManager {
 public:
   Expected<std::unique_ptr<Allocation>>
-  allocate(const SegmentsRequestMap &Request) override;
+  allocate(const JITLinkDylib *JD, const SegmentsRequestMap &Request) override;
 };
 
 } // end namespace jitlink
 } // end namespace llvm
 
-#endif // LLVM_EXECUTIONENGINE_JITLINK_JITLINK_H
+#endif // LLVM_EXECUTIONENGINE_JITLINK_JITLINKMEMORYMANAGER_H
diff --git a/linux-x64/clang/include/llvm/ExecutionEngine/JITLink/MachO.h b/linux-x64/clang/include/llvm/ExecutionEngine/JITLink/MachO.h
index 7facb65..b8432c4 100644
--- a/linux-x64/clang/include/llvm/ExecutionEngine/JITLink/MachO.h
+++ b/linux-x64/clang/include/llvm/ExecutionEngine/JITLink/MachO.h
@@ -18,11 +18,20 @@
 namespace llvm {
 namespace jitlink {
 
+/// Create a LinkGraph from a MachO relocatable object.
+///
+/// Note: The graph does not take ownership of the underlying buffer, nor copy
+/// its contents. The caller is responsible for ensuring that the object buffer
+/// outlives the graph.
+Expected<std::unique_ptr<LinkGraph>>
+createLinkGraphFromMachOObject(MemoryBufferRef ObjectBuffer);
+
 /// jit-link the given ObjBuffer, which must be a MachO object file.
 ///
 /// Uses conservative defaults for GOT and stub handling based on the target
 /// platform.
-void jitLink_MachO(std::unique_ptr<JITLinkContext> Ctx);
+void link_MachO(std::unique_ptr<LinkGraph> G,
+                std::unique_ptr<JITLinkContext> Ctx);
 
 } // end namespace jitlink
 } // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/ExecutionEngine/JITLink/MachO_arm64.h b/linux-x64/clang/include/llvm/ExecutionEngine/JITLink/MachO_arm64.h
new file mode 100644
index 0000000..c6aed2b
--- /dev/null
+++ b/linux-x64/clang/include/llvm/ExecutionEngine/JITLink/MachO_arm64.h
@@ -0,0 +1,69 @@
+//===---- MachO_arm64.h - JIT link functions for MachO/arm64 ----*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// jit-link functions for MachO/arm64.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_EXECUTIONENGINE_JITLINK_MACHO_ARM64_H
+#define LLVM_EXECUTIONENGINE_JITLINK_MACHO_ARM64_H
+
+#include "llvm/ExecutionEngine/JITLink/JITLink.h"
+
+namespace llvm {
+namespace jitlink {
+
+namespace MachO_arm64_Edges {
+
+enum MachOARM64RelocationKind : Edge::Kind {
+  Branch26 = Edge::FirstRelocation,
+  Pointer32,
+  Pointer64,
+  Pointer64Anon,
+  Page21,
+  PageOffset12,
+  GOTPage21,
+  GOTPageOffset12,
+  PointerToGOT,
+  PairedAddend,
+  LDRLiteral19,
+  Delta32,
+  Delta64,
+  NegDelta32,
+  NegDelta64,
+};
+
+} // namespace MachO_arm64_Edges
+
+/// Create a LinkGraph from a MachO/arm64 relocatable object.
+///
+/// Note: The graph does not take ownership of the underlying buffer, nor copy
+/// its contents. The caller is responsible for ensuring that the object buffer
+/// outlives the graph.
+Expected<std::unique_ptr<LinkGraph>>
+createLinkGraphFromMachOObject_arm64(MemoryBufferRef ObjectBuffer);
+
+/// jit-link the given object buffer, which must be a MachO arm64 object file.
+///
+/// If PrePrunePasses is empty then a default mark-live pass will be inserted
+/// that will mark all exported atoms live. If PrePrunePasses is not empty, the
+/// caller is responsible for including a pass to mark atoms as live.
+///
+/// If PostPrunePasses is empty then a default GOT-and-stubs insertion pass will
+/// be inserted. If PostPrunePasses is not empty then the caller is responsible
+/// for including a pass to insert GOT and stub edges.
+void link_MachO_arm64(std::unique_ptr<LinkGraph> G,
+                      std::unique_ptr<JITLinkContext> Ctx);
+
+/// Return the string name of the given MachO arm64 edge kind.
+StringRef getMachOARM64RelocationKindName(Edge::Kind R);
+
+} // end namespace jitlink
+} // end namespace llvm
+
+#endif // LLVM_EXECUTIONENGINE_JITLINK_MACHO_ARM64_H
diff --git a/linux-x64/clang/include/llvm/ExecutionEngine/JITLink/MachO_x86_64.h b/linux-x64/clang/include/llvm/ExecutionEngine/JITLink/MachO_x86_64.h
index 1d5b586..66c53d8 100644
--- a/linux-x64/clang/include/llvm/ExecutionEngine/JITLink/MachO_x86_64.h
+++ b/linux-x64/clang/include/llvm/ExecutionEngine/JITLink/MachO_x86_64.h
@@ -22,6 +22,8 @@
 
 enum MachOX86RelocationKind : Edge::Kind {
   Branch32 = Edge::FirstRelocation,
+  Branch32ToStub,
+  Pointer32,
   Pointer64,
   Pointer64Anon,
   PCRel32,
@@ -43,7 +45,15 @@
 
 } // namespace MachO_x86_64_Edges
 
-/// jit-link the given object buffer, which must be a MachO x86-64 object file.
+/// Create a LinkGraph from a MachO/x86-64 relocatable object.
+///
+/// Note: The graph does not take ownership of the underlying buffer, nor copy
+/// its contents. The caller is responsible for ensuring that the object buffer
+/// outlives the graph.
+Expected<std::unique_ptr<LinkGraph>>
+createLinkGraphFromMachOObject_x86_64(MemoryBufferRef ObjectBuffer);
+
+/// jit-link the given LinkGraph.
 ///
 /// If PrePrunePasses is empty then a default mark-live pass will be inserted
 /// that will mark all exported atoms live. If PrePrunePasses is not empty, the
@@ -52,7 +62,8 @@
 /// If PostPrunePasses is empty then a default GOT-and-stubs insertion pass will
 /// be inserted. If PostPrunePasses is not empty then the caller is responsible
 /// for including a pass to insert GOT and stub edges.
-void jitLink_MachO_x86_64(std::unique_ptr<JITLinkContext> Ctx);
+void link_MachO_x86_64(std::unique_ptr<LinkGraph> G,
+                       std::unique_ptr<JITLinkContext> Ctx);
 
 /// Return the string name of the given MachO x86-64 edge kind.
 StringRef getMachOX86RelocationKindName(Edge::Kind R);
diff --git a/linux-x64/clang/include/llvm/ExecutionEngine/JITSymbol.h b/linux-x64/clang/include/llvm/ExecutionEngine/JITSymbol.h
index b14154c..9bbdd21 100644
--- a/linux-x64/clang/include/llvm/ExecutionEngine/JITSymbol.h
+++ b/linux-x64/clang/include/llvm/ExecutionEngine/JITSymbol.h
@@ -23,12 +23,14 @@
 #include <string>
 
 #include "llvm/ADT/BitmaskEnum.h"
+#include "llvm/ADT/FunctionExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Error.h"
 
 namespace llvm {
 
 class GlobalValue;
+class GlobalValueSummary;
 
 namespace object {
 
@@ -40,6 +42,11 @@
 using JITTargetAddress = uint64_t;
 
 /// Convert a JITTargetAddress to a pointer.
+///
+/// Note: This is a raw cast of the address bit pattern to the given pointer
+/// type. When casting to a function pointer in order to execute JIT'd code
+/// jitTargetAddressToFunction should be preferred, as it will also perform
+/// pointer signing on targets that require it.
 template <typename T> T jitTargetAddressToPointer(JITTargetAddress Addr) {
   static_assert(std::is_pointer<T>::value, "T must be a pointer type");
   uintptr_t IntPtr = static_cast<uintptr_t>(Addr);
@@ -47,6 +54,18 @@
   return reinterpret_cast<T>(IntPtr);
 }
 
+/// Convert a JITTargetAddress to a callable function pointer.
+///
+/// Casts the given address to a callable function pointer. This operation
+/// will perform pointer signing for platforms that require it (e.g. arm64e).
+template <typename T> T jitTargetAddressToFunction(JITTargetAddress Addr) {
+  static_assert(std::is_pointer<T>::value &&
+                    std::is_function<std::remove_pointer_t<T>>::value,
+                "T must be a function pointer type");
+  return jitTargetAddressToPointer<T>(Addr);
+}
+
+/// Convert a pointer to a JITTargetAddress.
 template <typename T> JITTargetAddress pointerToJITTargetAddress(T *Ptr) {
   return static_cast<JITTargetAddress>(reinterpret_cast<uintptr_t>(Ptr));
 }
@@ -65,7 +84,9 @@
     Absolute = 1U << 3,
     Exported = 1U << 4,
     Callable = 1U << 5,
-    LLVM_MARK_AS_BITMASK_ENUM(/* LargestValue = */ Callable)
+    MaterializationSideEffectsOnly = 1U << 6,
+    LLVM_MARK_AS_BITMASK_ENUM( // LargestValue =
+        MaterializationSideEffectsOnly)
   };
 
   /// Default-construct a JITSymbolFlags instance.
@@ -127,6 +148,21 @@
   /// Returns true if the given symbol is known to be callable.
   bool isCallable() const { return (Flags & Callable) == Callable; }
 
+  /// Returns true if this symbol is a materialization-side-effects-only
+  /// symbol. Such symbols do not have a real address. They exist to trigger
+  /// and support synchronization of materialization side effects, e.g. for
+  /// collecting initialization information. These symbols will vanish from
+  /// the symbol table immediately upon reaching the ready state, and will
+  /// appear to queries as if they were never defined (except that query
+  /// callback execution will be delayed until they reach the ready state).
+  /// MaterializationSideEffectOnly symbols should only be queried using the
+  /// SymbolLookupFlags::WeaklyReferencedSymbol flag (see
+  /// llvm/include/llvm/ExecutionEngine/Orc/Core.h).
+  bool hasMaterializationSideEffectsOnly() const {
+    return (Flags & MaterializationSideEffectsOnly) ==
+           MaterializationSideEffectsOnly;
+  }
+
   /// Get the underlying flags value as an integer.
   UnderlyingType getRawFlagsValue() const {
     return static_cast<UnderlyingType>(Flags);
@@ -142,6 +178,10 @@
   /// value.
   static JITSymbolFlags fromGlobalValue(const GlobalValue &GV);
 
+  /// Construct a JITSymbolFlags value based on the flags of the given global
+  /// value summary.
+  static JITSymbolFlags fromSummary(GlobalValueSummary *S);
+
   /// Construct a JITSymbolFlags value based on the flags of the given libobject
   /// symbol.
   static Expected<JITSymbolFlags>
@@ -197,6 +237,13 @@
   JITEvaluatedSymbol(JITTargetAddress Address, JITSymbolFlags Flags)
       : Address(Address), Flags(Flags) {}
 
+  /// Create a symbol from the given pointer with the given flags.
+  template <typename T>
+  static JITEvaluatedSymbol
+  fromPointer(T *P, JITSymbolFlags Flags = JITSymbolFlags::Exported) {
+    return JITEvaluatedSymbol(pointerToJITTargetAddress(P), Flags);
+  }
+
   /// An evaluated symbol converts to 'true' if its address is non-zero.
   explicit operator bool() const { return Address != 0; }
 
@@ -217,7 +264,7 @@
 /// Represents a symbol in the JIT.
 class JITSymbol {
 public:
-  using GetAddressFtor = std::function<Expected<JITTargetAddress>()>;
+  using GetAddressFtor = unique_function<Expected<JITTargetAddress>()>;
 
   /// Create a 'null' symbol, used to represent a "symbol not found"
   ///        result from a successful (non-erroneous) lookup.
@@ -325,7 +372,7 @@
 public:
   using LookupSet = std::set<StringRef>;
   using LookupResult = std::map<StringRef, JITEvaluatedSymbol>;
-  using OnResolvedFunction = std::function<void(Expected<LookupResult>)>;
+  using OnResolvedFunction = unique_function<void(Expected<LookupResult>)>;
 
   virtual ~JITSymbolResolver() = default;
 
@@ -382,7 +429,7 @@
   virtual JITSymbol findSymbol(const std::string &Name) = 0;
 
 private:
-  virtual void anchor();
+  void anchor() override;
 };
 
 } // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/ExecutionEngine/ObjectCache.h b/linux-x64/clang/include/llvm/ExecutionEngine/ObjectCache.h
index 47e94f1..1c72ca3 100644
--- a/linux-x64/clang/include/llvm/ExecutionEngine/ObjectCache.h
+++ b/linux-x64/clang/include/llvm/ExecutionEngine/ObjectCache.h
@@ -9,11 +9,12 @@
 #ifndef LLVM_EXECUTIONENGINE_OBJECTCACHE_H
 #define LLVM_EXECUTIONENGINE_OBJECTCACHE_H
 
-#include "llvm/Support/MemoryBuffer.h"
 #include <memory>
 
 namespace llvm {
 
+class MemoryBuffer;
+class MemoryBufferRef;
 class Module;
 
 /// This is the base ObjectCache type which can be provided to an
diff --git a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h
index ca1ce40..67aa09b 100644
--- a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h
+++ b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h
@@ -18,14 +18,12 @@
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringRef.h"
-#include "llvm/ADT/Twine.h"
 #include "llvm/ExecutionEngine/JITSymbol.h"
 #include "llvm/ExecutionEngine/Orc/IndirectionUtils.h"
-#include "llvm/ExecutionEngine/Orc/LambdaResolver.h"
 #include "llvm/ExecutionEngine/Orc/Layer.h"
 #include "llvm/ExecutionEngine/Orc/LazyReexports.h"
-#include "llvm/ExecutionEngine/Orc/Legacy.h"
 #include "llvm/ExecutionEngine/Orc/OrcError.h"
+#include "llvm/ExecutionEngine/Orc/Speculation.h"
 #include "llvm/ExecutionEngine/RuntimeDyld.h"
 #include "llvm/IR/Attributes.h"
 #include "llvm/IR/Constant.h"
@@ -91,9 +89,13 @@
   /// Sets the partition function.
   void setPartitionFunction(PartitionFunction Partition);
 
+  /// Sets the ImplSymbolMap
+  void setImplMap(ImplSymbolMap *Imp);
+
   /// Emits the given module. This should not be called by clients: it will be
   /// called by the JIT when a definition added via the add method is requested.
-  void emit(MaterializationResponsibility R, ThreadSafeModule TSM) override;
+  void emit(std::unique_ptr<MaterializationResponsibility> R,
+            ThreadSafeModule TSM) override;
 
 private:
   struct PerDylibResources {
@@ -117,7 +119,8 @@
 
   void expandPartition(GlobalValueSet &Partition);
 
-  void emitPartition(MaterializationResponsibility R, ThreadSafeModule TSM,
+  void emitPartition(std::unique_ptr<MaterializationResponsibility> R,
+                     ThreadSafeModule TSM,
                      IRMaterializationUnit::SymbolNameToDefinitionMap Defs);
 
   mutable std::mutex CODLayerMutex;
@@ -128,609 +131,10 @@
   PerDylibResourcesMap DylibResources;
   PartitionFunction Partition = compileRequested;
   SymbolLinkagePromoter PromoteSymbols;
-};
-
-/// Compile-on-demand layer.
-///
-///   When a module is added to this layer a stub is created for each of its
-/// function definitions. The stubs and other global values are immediately
-/// added to the layer below. When a stub is called it triggers the extraction
-/// of the function body from the original module. The extracted body is then
-/// compiled and executed.
-template <typename BaseLayerT,
-          typename CompileCallbackMgrT = JITCompileCallbackManager,
-          typename IndirectStubsMgrT = IndirectStubsManager>
-class LegacyCompileOnDemandLayer {
-private:
-  template <typename MaterializerFtor>
-  class LambdaMaterializer final : public ValueMaterializer {
-  public:
-    LambdaMaterializer(MaterializerFtor M) : M(std::move(M)) {}
-
-    Value *materialize(Value *V) final { return M(V); }
-
-  private:
-    MaterializerFtor M;
-  };
-
-  template <typename MaterializerFtor>
-  LambdaMaterializer<MaterializerFtor>
-  createLambdaMaterializer(MaterializerFtor M) {
-    return LambdaMaterializer<MaterializerFtor>(std::move(M));
-  }
-
-  // Provide type-erasure for the Modules and MemoryManagers.
-  template <typename ResourceT>
-  class ResourceOwner {
-  public:
-    ResourceOwner() = default;
-    ResourceOwner(const ResourceOwner &) = delete;
-    ResourceOwner &operator=(const ResourceOwner &) = delete;
-    virtual ~ResourceOwner() = default;
-
-    virtual ResourceT& getResource() const = 0;
-  };
-
-  template <typename ResourceT, typename ResourcePtrT>
-  class ResourceOwnerImpl : public ResourceOwner<ResourceT> {
-  public:
-    ResourceOwnerImpl(ResourcePtrT ResourcePtr)
-      : ResourcePtr(std::move(ResourcePtr)) {}
-
-    ResourceT& getResource() const override { return *ResourcePtr; }
-
-  private:
-    ResourcePtrT ResourcePtr;
-  };
-
-  template <typename ResourceT, typename ResourcePtrT>
-  std::unique_ptr<ResourceOwner<ResourceT>>
-  wrapOwnership(ResourcePtrT ResourcePtr) {
-    using RO = ResourceOwnerImpl<ResourceT, ResourcePtrT>;
-    return llvm::make_unique<RO>(std::move(ResourcePtr));
-  }
-
-  struct LogicalDylib {
-    struct SourceModuleEntry {
-      std::unique_ptr<Module> SourceMod;
-      std::set<Function*> StubsToClone;
-    };
-
-    using SourceModulesList = std::vector<SourceModuleEntry>;
-    using SourceModuleHandle = typename SourceModulesList::size_type;
-
-    LogicalDylib() = default;
-
-    LogicalDylib(VModuleKey K, std::shared_ptr<SymbolResolver> BackingResolver,
-                 std::unique_ptr<IndirectStubsMgrT> StubsMgr)
-        : K(std::move(K)), BackingResolver(std::move(BackingResolver)),
-          StubsMgr(std::move(StubsMgr)) {}
-
-    SourceModuleHandle addSourceModule(std::unique_ptr<Module> M) {
-      SourceModuleHandle H = SourceModules.size();
-      SourceModules.push_back(SourceModuleEntry());
-      SourceModules.back().SourceMod = std::move(M);
-      return H;
-    }
-
-    Module& getSourceModule(SourceModuleHandle H) {
-      return *SourceModules[H].SourceMod;
-    }
-
-    std::set<Function*>& getStubsToClone(SourceModuleHandle H) {
-      return SourceModules[H].StubsToClone;
-    }
-
-    JITSymbol findSymbol(BaseLayerT &BaseLayer, const std::string &Name,
-                         bool ExportedSymbolsOnly) {
-      if (auto Sym = StubsMgr->findStub(Name, ExportedSymbolsOnly))
-        return Sym;
-      for (auto BLK : BaseLayerVModuleKeys)
-        if (auto Sym = BaseLayer.findSymbolIn(BLK, Name, ExportedSymbolsOnly))
-          return Sym;
-        else if (auto Err = Sym.takeError())
-          return std::move(Err);
-      return nullptr;
-    }
-
-    Error removeModulesFromBaseLayer(BaseLayerT &BaseLayer) {
-      for (auto &BLK : BaseLayerVModuleKeys)
-        if (auto Err = BaseLayer.removeModule(BLK))
-          return Err;
-      return Error::success();
-    }
-
-    VModuleKey K;
-    std::shared_ptr<SymbolResolver> BackingResolver;
-    std::unique_ptr<IndirectStubsMgrT> StubsMgr;
-    SymbolLinkagePromoter PromoteSymbols;
-    SourceModulesList SourceModules;
-    std::vector<VModuleKey> BaseLayerVModuleKeys;
-  };
-
-public:
-
-  /// Module partitioning functor.
-  using PartitioningFtor = std::function<std::set<Function*>(Function&)>;
-
-  /// Builder for IndirectStubsManagers.
-  using IndirectStubsManagerBuilderT =
-      std::function<std::unique_ptr<IndirectStubsMgrT>()>;
-
-  using SymbolResolverGetter =
-      std::function<std::shared_ptr<SymbolResolver>(VModuleKey K)>;
-
-  using SymbolResolverSetter =
-      std::function<void(VModuleKey K, std::shared_ptr<SymbolResolver> R)>;
-
-  /// Construct a compile-on-demand layer instance.
-  LegacyCompileOnDemandLayer(ExecutionSession &ES, BaseLayerT &BaseLayer,
-                             SymbolResolverGetter GetSymbolResolver,
-                             SymbolResolverSetter SetSymbolResolver,
-                             PartitioningFtor Partition,
-                             CompileCallbackMgrT &CallbackMgr,
-                             IndirectStubsManagerBuilderT CreateIndirectStubsManager,
-                             bool CloneStubsIntoPartitions = true)
-      : ES(ES), BaseLayer(BaseLayer),
-        GetSymbolResolver(std::move(GetSymbolResolver)),
-        SetSymbolResolver(std::move(SetSymbolResolver)),
-        Partition(std::move(Partition)), CompileCallbackMgr(CallbackMgr),
-        CreateIndirectStubsManager(std::move(CreateIndirectStubsManager)),
-        CloneStubsIntoPartitions(CloneStubsIntoPartitions) {}
-
-  ~LegacyCompileOnDemandLayer() {
-    // FIXME: Report error on log.
-    while (!LogicalDylibs.empty())
-      consumeError(removeModule(LogicalDylibs.begin()->first));
-  }
-
-  /// Add a module to the compile-on-demand layer.
-  Error addModule(VModuleKey K, std::unique_ptr<Module> M) {
-
-    assert(!LogicalDylibs.count(K) && "VModuleKey K already in use");
-    auto I = LogicalDylibs.insert(
-        LogicalDylibs.end(),
-        std::make_pair(K, LogicalDylib(K, GetSymbolResolver(K),
-                                       CreateIndirectStubsManager())));
-
-    return addLogicalModule(I->second, std::move(M));
-  }
-
-  /// Add extra modules to an existing logical module.
-  Error addExtraModule(VModuleKey K, std::unique_ptr<Module> M) {
-    return addLogicalModule(LogicalDylibs[K], std::move(M));
-  }
-
-  /// Remove the module represented by the given key.
-  ///
-  ///   This will remove all modules in the layers below that were derived from
-  /// the module represented by K.
-  Error removeModule(VModuleKey K) {
-    auto I = LogicalDylibs.find(K);
-    assert(I != LogicalDylibs.end() && "VModuleKey K not valid here");
-    auto Err = I->second.removeModulesFromBaseLayer(BaseLayer);
-    LogicalDylibs.erase(I);
-    return Err;
-  }
-
-  /// Search for the given named symbol.
-  /// @param Name The name of the symbol to search for.
-  /// @param ExportedSymbolsOnly If true, search only for exported symbols.
-  /// @return A handle for the given named symbol, if it exists.
-  JITSymbol findSymbol(StringRef Name, bool ExportedSymbolsOnly) {
-    for (auto &KV : LogicalDylibs) {
-      if (auto Sym = KV.second.StubsMgr->findStub(Name, ExportedSymbolsOnly))
-        return Sym;
-      if (auto Sym = findSymbolIn(KV.first, Name, ExportedSymbolsOnly))
-        return Sym;
-      else if (auto Err = Sym.takeError())
-        return std::move(Err);
-    }
-    return BaseLayer.findSymbol(Name, ExportedSymbolsOnly);
-  }
-
-  /// Get the address of a symbol provided by this layer, or some layer
-  ///        below this one.
-  JITSymbol findSymbolIn(VModuleKey K, const std::string &Name,
-                         bool ExportedSymbolsOnly) {
-    assert(LogicalDylibs.count(K) && "VModuleKey K is not valid here");
-    return LogicalDylibs[K].findSymbol(BaseLayer, Name, ExportedSymbolsOnly);
-  }
-
-  /// Update the stub for the given function to point at FnBodyAddr.
-  /// This can be used to support re-optimization.
-  /// @return true if the function exists and the stub is updated, false
-  ///         otherwise.
-  //
-  // FIXME: We should track and free associated resources (unused compile
-  //        callbacks, uncompiled IR, and no-longer-needed/reachable function
-  //        implementations).
-  Error updatePointer(std::string FuncName, JITTargetAddress FnBodyAddr) {
-    //Find out which logical dylib contains our symbol
-    auto LDI = LogicalDylibs.begin();
-    for (auto LDE = LogicalDylibs.end(); LDI != LDE; ++LDI) {
-      if (auto LMResources =
-            LDI->getLogicalModuleResourcesForSymbol(FuncName, false)) {
-        Module &SrcM = LMResources->SourceModule->getResource();
-        std::string CalledFnName = mangle(FuncName, SrcM.getDataLayout());
-        if (auto Err = LMResources->StubsMgr->updatePointer(CalledFnName,
-                                                            FnBodyAddr))
-          return Err;
-        return Error::success();
-      }
-    }
-    return make_error<JITSymbolNotFound>(FuncName);
-  }
-
-private:
-  Error addLogicalModule(LogicalDylib &LD, std::unique_ptr<Module> SrcMPtr) {
-
-    // Rename anonymous globals and promote linkage to ensure that everything
-    // will resolve properly after we partition SrcM.
-    LD.PromoteSymbols(*SrcMPtr);
-
-    // Create a logical module handle for SrcM within the logical dylib.
-    Module &SrcM = *SrcMPtr;
-    auto LMId = LD.addSourceModule(std::move(SrcMPtr));
-
-    // Create stub functions.
-    const DataLayout &DL = SrcM.getDataLayout();
-    {
-      typename IndirectStubsMgrT::StubInitsMap StubInits;
-      for (auto &F : SrcM) {
-        // Skip declarations.
-        if (F.isDeclaration())
-          continue;
-
-        // Skip weak functions for which we already have definitions.
-        auto MangledName = mangle(F.getName(), DL);
-        if (F.hasWeakLinkage() || F.hasLinkOnceLinkage()) {
-          if (auto Sym = LD.findSymbol(BaseLayer, MangledName, false))
-            continue;
-          else if (auto Err = Sym.takeError())
-            return std::move(Err);
-        }
-
-        // Record all functions defined by this module.
-        if (CloneStubsIntoPartitions)
-          LD.getStubsToClone(LMId).insert(&F);
-
-        // Create a callback, associate it with the stub for the function,
-        // and set the compile action to compile the partition containing the
-        // function.
-        auto CompileAction = [this, &LD, LMId, &F]() -> JITTargetAddress {
-          if (auto FnImplAddrOrErr = this->extractAndCompile(LD, LMId, F))
-            return *FnImplAddrOrErr;
-          else {
-            // FIXME: Report error, return to 'abort' or something similar.
-            consumeError(FnImplAddrOrErr.takeError());
-            return 0;
-          }
-        };
-        if (auto CCAddr =
-                CompileCallbackMgr.getCompileCallback(std::move(CompileAction)))
-          StubInits[MangledName] =
-              std::make_pair(*CCAddr, JITSymbolFlags::fromGlobalValue(F));
-        else
-          return CCAddr.takeError();
-      }
-
-      if (auto Err = LD.StubsMgr->createStubs(StubInits))
-        return Err;
-    }
-
-    // If this module doesn't contain any globals, aliases, or module flags then
-    // we can bail out early and avoid the overhead of creating and managing an
-    // empty globals module.
-    if (SrcM.global_empty() && SrcM.alias_empty() &&
-        !SrcM.getModuleFlagsMetadata())
-      return Error::success();
-
-    // Create the GlobalValues module.
-    auto GVsM = llvm::make_unique<Module>((SrcM.getName() + ".globals").str(),
-                                          SrcM.getContext());
-    GVsM->setDataLayout(DL);
-
-    ValueToValueMapTy VMap;
-
-    // Clone global variable decls.
-    for (auto &GV : SrcM.globals())
-      if (!GV.isDeclaration() && !VMap.count(&GV))
-        cloneGlobalVariableDecl(*GVsM, GV, &VMap);
-
-    // And the aliases.
-    for (auto &A : SrcM.aliases())
-      if (!VMap.count(&A))
-        cloneGlobalAliasDecl(*GVsM, A, VMap);
-
-    // Clone the module flags.
-    cloneModuleFlagsMetadata(*GVsM, SrcM, VMap);
-
-    // Now we need to clone the GV and alias initializers.
-
-    // Initializers may refer to functions declared (but not defined) in this
-    // module. Build a materializer to clone decls on demand.
-    auto Materializer = createLambdaMaterializer(
-      [&LD, &GVsM](Value *V) -> Value* {
-        if (auto *F = dyn_cast<Function>(V)) {
-          // Decls in the original module just get cloned.
-          if (F->isDeclaration())
-            return cloneFunctionDecl(*GVsM, *F);
-
-          // Definitions in the original module (which we have emitted stubs
-          // for at this point) get turned into a constant alias to the stub
-          // instead.
-          const DataLayout &DL = GVsM->getDataLayout();
-          std::string FName = mangle(F->getName(), DL);
-          unsigned PtrBitWidth = DL.getPointerTypeSizeInBits(F->getType());
-          JITTargetAddress StubAddr =
-            LD.StubsMgr->findStub(FName, false).getAddress();
-
-          ConstantInt *StubAddrCI =
-            ConstantInt::get(GVsM->getContext(), APInt(PtrBitWidth, StubAddr));
-          Constant *Init = ConstantExpr::getCast(Instruction::IntToPtr,
-                                                 StubAddrCI, F->getType());
-          return GlobalAlias::create(F->getFunctionType(),
-                                     F->getType()->getAddressSpace(),
-                                     F->getLinkage(), F->getName(),
-                                     Init, GVsM.get());
-        }
-        // else....
-        return nullptr;
-      });
-
-    // Clone the global variable initializers.
-    for (auto &GV : SrcM.globals())
-      if (!GV.isDeclaration())
-        moveGlobalVariableInitializer(GV, VMap, &Materializer);
-
-    // Clone the global alias initializers.
-    for (auto &A : SrcM.aliases()) {
-      auto *NewA = cast<GlobalAlias>(VMap[&A]);
-      assert(NewA && "Alias not cloned?");
-      Value *Init = MapValue(A.getAliasee(), VMap, RF_None, nullptr,
-                             &Materializer);
-      NewA->setAliasee(cast<Constant>(Init));
-    }
-
-    // Build a resolver for the globals module and add it to the base layer.
-    auto LegacyLookup = [this, &LD](const std::string &Name) -> JITSymbol {
-      if (auto Sym = LD.StubsMgr->findStub(Name, false))
-        return Sym;
-
-      if (auto Sym = LD.findSymbol(BaseLayer, Name, false))
-        return Sym;
-      else if (auto Err = Sym.takeError())
-        return std::move(Err);
-
-      return nullptr;
-    };
-
-    auto GVsResolver = createSymbolResolver(
-        [&LD, LegacyLookup](const SymbolNameSet &Symbols) {
-          auto RS = getResponsibilitySetWithLegacyFn(Symbols, LegacyLookup);
-
-          if (!RS) {
-            logAllUnhandledErrors(
-                RS.takeError(), errs(),
-                "CODLayer/GVsResolver responsibility set lookup failed: ");
-            return SymbolNameSet();
-          }
-
-          if (RS->size() == Symbols.size())
-            return *RS;
-
-          SymbolNameSet NotFoundViaLegacyLookup;
-          for (auto &S : Symbols)
-            if (!RS->count(S))
-              NotFoundViaLegacyLookup.insert(S);
-          auto RS2 =
-              LD.BackingResolver->getResponsibilitySet(NotFoundViaLegacyLookup);
-
-          for (auto &S : RS2)
-            (*RS).insert(S);
-
-          return *RS;
-        },
-        [this, &LD,
-         LegacyLookup](std::shared_ptr<AsynchronousSymbolQuery> Query,
-                       SymbolNameSet Symbols) {
-          auto NotFoundViaLegacyLookup =
-              lookupWithLegacyFn(ES, *Query, Symbols, LegacyLookup);
-          return LD.BackingResolver->lookup(Query, NotFoundViaLegacyLookup);
-        });
-
-    SetSymbolResolver(LD.K, std::move(GVsResolver));
-
-    if (auto Err = BaseLayer.addModule(LD.K, std::move(GVsM)))
-      return Err;
-
-    LD.BaseLayerVModuleKeys.push_back(LD.K);
-
-    return Error::success();
-  }
-
-  static std::string mangle(StringRef Name, const DataLayout &DL) {
-    std::string MangledName;
-    {
-      raw_string_ostream MangledNameStream(MangledName);
-      Mangler::getNameWithPrefix(MangledNameStream, Name, DL);
-    }
-    return MangledName;
-  }
-
-  Expected<JITTargetAddress>
-  extractAndCompile(LogicalDylib &LD,
-                    typename LogicalDylib::SourceModuleHandle LMId,
-                    Function &F) {
-    Module &SrcM = LD.getSourceModule(LMId);
-
-    // If F is a declaration we must already have compiled it.
-    if (F.isDeclaration())
-      return 0;
-
-    // Grab the name of the function being called here.
-    std::string CalledFnName = mangle(F.getName(), SrcM.getDataLayout());
-
-    JITTargetAddress CalledAddr = 0;
-    auto Part = Partition(F);
-    if (auto PartKeyOrErr = emitPartition(LD, LMId, Part)) {
-      auto &PartKey = *PartKeyOrErr;
-      for (auto *SubF : Part) {
-        std::string FnName = mangle(SubF->getName(), SrcM.getDataLayout());
-        if (auto FnBodySym = BaseLayer.findSymbolIn(PartKey, FnName, false)) {
-          if (auto FnBodyAddrOrErr = FnBodySym.getAddress()) {
-            JITTargetAddress FnBodyAddr = *FnBodyAddrOrErr;
-
-            // If this is the function we're calling record the address so we can
-            // return it from this function.
-            if (SubF == &F)
-              CalledAddr = FnBodyAddr;
-
-            // Update the function body pointer for the stub.
-            if (auto EC = LD.StubsMgr->updatePointer(FnName, FnBodyAddr))
-              return 0;
-
-          } else
-            return FnBodyAddrOrErr.takeError();
-        } else if (auto Err = FnBodySym.takeError())
-          return std::move(Err);
-        else
-          llvm_unreachable("Function not emitted for partition");
-      }
-
-      LD.BaseLayerVModuleKeys.push_back(PartKey);
-    } else
-      return PartKeyOrErr.takeError();
-
-    return CalledAddr;
-  }
-
-  template <typename PartitionT>
-  Expected<VModuleKey>
-  emitPartition(LogicalDylib &LD,
-                typename LogicalDylib::SourceModuleHandle LMId,
-                const PartitionT &Part) {
-    Module &SrcM = LD.getSourceModule(LMId);
-
-    // Create the module.
-    std::string NewName = SrcM.getName();
-    for (auto *F : Part) {
-      NewName += ".";
-      NewName += F->getName();
-    }
-
-    auto M = llvm::make_unique<Module>(NewName, SrcM.getContext());
-    M->setDataLayout(SrcM.getDataLayout());
-    ValueToValueMapTy VMap;
-
-    auto Materializer = createLambdaMaterializer([&LD, &LMId,
-                                                  &M](Value *V) -> Value * {
-      if (auto *GV = dyn_cast<GlobalVariable>(V))
-        return cloneGlobalVariableDecl(*M, *GV);
-
-      if (auto *F = dyn_cast<Function>(V)) {
-        // Check whether we want to clone an available_externally definition.
-        if (!LD.getStubsToClone(LMId).count(F))
-          return cloneFunctionDecl(*M, *F);
-
-        // Ok - we want an inlinable stub. For that to work we need a decl
-        // for the stub pointer.
-        auto *StubPtr = createImplPointer(*F->getType(), *M,
-                                          F->getName() + "$stub_ptr", nullptr);
-        auto *ClonedF = cloneFunctionDecl(*M, *F);
-        makeStub(*ClonedF, *StubPtr);
-        ClonedF->setLinkage(GlobalValue::AvailableExternallyLinkage);
-        ClonedF->addFnAttr(Attribute::AlwaysInline);
-        return ClonedF;
-      }
-
-      if (auto *A = dyn_cast<GlobalAlias>(V)) {
-        auto *Ty = A->getValueType();
-        if (Ty->isFunctionTy())
-          return Function::Create(cast<FunctionType>(Ty),
-                                  GlobalValue::ExternalLinkage, A->getName(),
-                                  M.get());
-
-        return new GlobalVariable(*M, Ty, false, GlobalValue::ExternalLinkage,
-                                  nullptr, A->getName(), nullptr,
-                                  GlobalValue::NotThreadLocal,
-                                  A->getType()->getAddressSpace());
-      }
-
-      return nullptr;
-    });
-
-    // Create decls in the new module.
-    for (auto *F : Part)
-      cloneFunctionDecl(*M, *F, &VMap);
-
-    // Move the function bodies.
-    for (auto *F : Part)
-      moveFunctionBody(*F, VMap, &Materializer);
-
-    auto K = ES.allocateVModule();
-
-    auto LegacyLookup = [this, &LD](const std::string &Name) -> JITSymbol {
-      return LD.findSymbol(BaseLayer, Name, false);
-    };
-
-    // Create memory manager and symbol resolver.
-    auto Resolver = createSymbolResolver(
-        [&LD, LegacyLookup](const SymbolNameSet &Symbols) {
-          auto RS = getResponsibilitySetWithLegacyFn(Symbols, LegacyLookup);
-          if (!RS) {
-            logAllUnhandledErrors(
-                RS.takeError(), errs(),
-                "CODLayer/SubResolver responsibility set lookup failed: ");
-            return SymbolNameSet();
-          }
-
-          if (RS->size() == Symbols.size())
-            return *RS;
-
-          SymbolNameSet NotFoundViaLegacyLookup;
-          for (auto &S : Symbols)
-            if (!RS->count(S))
-              NotFoundViaLegacyLookup.insert(S);
-
-          auto RS2 =
-              LD.BackingResolver->getResponsibilitySet(NotFoundViaLegacyLookup);
-
-          for (auto &S : RS2)
-            (*RS).insert(S);
-
-          return *RS;
-        },
-        [this, &LD, LegacyLookup](std::shared_ptr<AsynchronousSymbolQuery> Q,
-                                  SymbolNameSet Symbols) {
-          auto NotFoundViaLegacyLookup =
-              lookupWithLegacyFn(ES, *Q, Symbols, LegacyLookup);
-          return LD.BackingResolver->lookup(Q,
-                                            std::move(NotFoundViaLegacyLookup));
-        });
-    SetSymbolResolver(K, std::move(Resolver));
-
-    if (auto Err = BaseLayer.addModule(std::move(K), std::move(M)))
-      return std::move(Err);
-
-    return K;
-  }
-
-  ExecutionSession &ES;
-  BaseLayerT &BaseLayer;
-  SymbolResolverGetter GetSymbolResolver;
-  SymbolResolverSetter SetSymbolResolver;
-  PartitioningFtor Partition;
-  CompileCallbackMgrT &CompileCallbackMgr;
-  IndirectStubsManagerBuilderT CreateIndirectStubsManager;
-
-  std::map<VModuleKey, LogicalDylib> LogicalDylibs;
-  bool CloneStubsIntoPartitions;
+  ImplSymbolMap *AliaseeImpls = nullptr;
 };
 
 } // end namespace orc
-
 } // end namespace llvm
 
 #endif // LLVM_EXECUTIONENGINE_ORC_COMPILEONDEMANDLAYER_H
diff --git a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/CompileUtils.h b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/CompileUtils.h
index 1585925..c7ba572 100644
--- a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/CompileUtils.h
+++ b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/CompileUtils.h
@@ -13,12 +13,13 @@
 #ifndef LLVM_EXECUTIONENGINE_ORC_COMPILEUTILS_H
 #define LLVM_EXECUTIONENGINE_ORC_COMPILEUTILS_H
 
+#include "llvm/ExecutionEngine/Orc/IRCompileLayer.h"
 #include "llvm/ExecutionEngine/Orc/JITTargetMachineBuilder.h"
+#include "llvm/ExecutionEngine/Orc/Layer.h"
 #include <memory>
 
 namespace llvm {
 
-class JITTargetMachineBuilder;
 class MCContext;
 class MemoryBuffer;
 class Module;
@@ -27,24 +28,31 @@
 
 namespace orc {
 
+IRSymbolMapper::ManglingOptions
+irManglingOptionsFromTargetOptions(const TargetOptions &Opts);
+
 /// Simple compile functor: Takes a single IR module and returns an ObjectFile.
 /// This compiler supports a single compilation thread and LLVMContext only.
 /// For multithreaded compilation, use ConcurrentIRCompiler below.
-class SimpleCompiler {
+class SimpleCompiler : public IRCompileLayer::IRCompiler {
 public:
   using CompileResult = std::unique_ptr<MemoryBuffer>;
 
   /// Construct a simple compile functor with the given target.
   SimpleCompiler(TargetMachine &TM, ObjectCache *ObjCache = nullptr)
-    : TM(TM), ObjCache(ObjCache) {}
+      : IRCompiler(irManglingOptionsFromTargetOptions(TM.Options)), TM(TM),
+        ObjCache(ObjCache) {}
 
   /// Set an ObjectCache to query before compiling.
   void setObjectCache(ObjectCache *NewCache) { ObjCache = NewCache; }
 
   /// Compile a Module to an ObjectFile.
-  CompileResult operator()(Module &M);
+  Expected<CompileResult> operator()(Module &M) override;
 
 private:
+  IRSymbolMapper::ManglingOptions
+  manglingOptionsForTargetMachine(const TargetMachine &TM);
+
   CompileResult tryToLoadFromObjectCache(const Module &M);
   void notifyObjectCompiled(const Module &M, const MemoryBuffer &ObjBuffer);
 
@@ -52,18 +60,34 @@
   ObjectCache *ObjCache = nullptr;
 };
 
+/// A SimpleCompiler that owns its TargetMachine.
+///
+/// This convenient for clients who don't want to own their TargetMachines,
+/// e.g. LLJIT.
+class TMOwningSimpleCompiler : public SimpleCompiler {
+public:
+  TMOwningSimpleCompiler(std::unique_ptr<TargetMachine> TM,
+                         ObjectCache *ObjCache = nullptr)
+      : SimpleCompiler(*TM, ObjCache), TM(std::move(TM)) {}
+
+private:
+  // FIXME: shared because std::functions (and consequently
+  // IRCompileLayer::CompileFunction) are not moveable.
+  std::shared_ptr<llvm::TargetMachine> TM;
+};
+
 /// A thread-safe version of SimpleCompiler.
 ///
 /// This class creates a new TargetMachine and SimpleCompiler instance for each
 /// compile.
-class ConcurrentIRCompiler {
+class ConcurrentIRCompiler : public IRCompileLayer::IRCompiler {
 public:
   ConcurrentIRCompiler(JITTargetMachineBuilder JTMB,
                        ObjectCache *ObjCache = nullptr);
 
   void setObjectCache(ObjectCache *ObjCache) { this->ObjCache = ObjCache; }
 
-  std::unique_ptr<MemoryBuffer> operator()(Module &M);
+  Expected<std::unique_ptr<MemoryBuffer>> operator()(Module &M) override;
 
 private:
   JITTargetMachineBuilder JTMB;
diff --git a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/Core.h b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/Core.h
index 016fd82..4a4b58e 100644
--- a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/Core.h
+++ b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/Core.h
@@ -14,16 +14,19 @@
 #define LLVM_EXECUTIONENGINE_ORC_CORE_H
 
 #include "llvm/ADT/BitmaskEnum.h"
+#include "llvm/ADT/DenseSet.h"
+#include "llvm/ADT/FunctionExtras.h"
+#include "llvm/ADT/IntrusiveRefCntPtr.h"
+#include "llvm/ExecutionEngine/JITLink/JITLinkDylib.h"
 #include "llvm/ExecutionEngine/JITSymbol.h"
 #include "llvm/ExecutionEngine/Orc/SymbolStringPool.h"
-#include "llvm/IR/Module.h"
+#include "llvm/ExecutionEngine/OrcV1Deprecation.h"
 #include "llvm/Support/Debug.h"
 
+#include <atomic>
 #include <memory>
 #include <vector>
 
-#define DEBUG_TYPE "orc"
-
 namespace llvm {
 namespace orc {
 
@@ -33,29 +36,333 @@
 class MaterializationUnit;
 class MaterializationResponsibility;
 class JITDylib;
+class ResourceTracker;
+class InProgressLookupState;
+
 enum class SymbolState : uint8_t;
 
-/// VModuleKey provides a unique identifier (allocated and managed by
-/// ExecutionSessions) for a module added to the JIT.
-using VModuleKey = uint64_t;
+using ResourceTrackerSP = IntrusiveRefCntPtr<ResourceTracker>;
+using JITDylibSP = IntrusiveRefCntPtr<JITDylib>;
+
+using ResourceKey = uintptr_t;
+
+/// API to remove / transfer ownership of JIT resources.
+class ResourceTracker : public ThreadSafeRefCountedBase<ResourceTracker> {
+private:
+  friend class ExecutionSession;
+  friend class JITDylib;
+  friend class MaterializationResponsibility;
+
+public:
+  ResourceTracker(const ResourceTracker &) = delete;
+  ResourceTracker &operator=(const ResourceTracker &) = delete;
+  ResourceTracker(ResourceTracker &&) = delete;
+  ResourceTracker &operator=(ResourceTracker &&) = delete;
+
+  ~ResourceTracker();
+
+  /// Return the JITDylib targeted by this tracker.
+  JITDylib &getJITDylib() const {
+    return *reinterpret_cast<JITDylib *>(JDAndFlag.load() &
+                                         ~static_cast<uintptr_t>(1));
+  }
+
+  /// Remove all resources associated with this key.
+  Error remove();
+
+  /// Transfer all resources associated with this key to the given
+  /// tracker, which must target the same JITDylib as this one.
+  void transferTo(ResourceTracker &DstRT);
+
+  /// Return true if this tracker has become defunct.
+  bool isDefunct() const { return JDAndFlag.load() & 0x1; }
+
+  /// Returns the key associated with this tracker.
+  /// This method should not be used except for debug logging: there is no
+  /// guarantee that the returned value will remain valid.
+  ResourceKey getKeyUnsafe() const { return reinterpret_cast<uintptr_t>(this); }
+
+private:
+  ResourceTracker(JITDylibSP JD);
+
+  void makeDefunct();
+
+  std::atomic_uintptr_t JDAndFlag;
+};
+
+/// Listens for ResourceTracker operations.
+class ResourceManager {
+public:
+  virtual ~ResourceManager();
+  virtual Error handleRemoveResources(ResourceKey K) = 0;
+  virtual void handleTransferResources(ResourceKey DstK, ResourceKey SrcK) = 0;
+};
 
 /// A set of symbol names (represented by SymbolStringPtrs for
 //         efficiency).
 using SymbolNameSet = DenseSet<SymbolStringPtr>;
 
+/// A vector of symbol names.
+using SymbolNameVector = std::vector<SymbolStringPtr>;
+
 /// A map from symbol names (as SymbolStringPtrs) to JITSymbols
-///        (address/flags pairs).
+/// (address/flags pairs).
 using SymbolMap = DenseMap<SymbolStringPtr, JITEvaluatedSymbol>;
 
 /// A map from symbol names (as SymbolStringPtrs) to JITSymbolFlags.
 using SymbolFlagsMap = DenseMap<SymbolStringPtr, JITSymbolFlags>;
 
-/// A base class for materialization failures that allows the failing
-///        symbols to be obtained for logging.
+/// A map from JITDylibs to sets of symbols.
 using SymbolDependenceMap = DenseMap<JITDylib *, SymbolNameSet>;
 
-/// A list of (JITDylib*, bool) pairs.
-using JITDylibSearchList = std::vector<std::pair<JITDylib *, bool>>;
+/// Lookup flags that apply to each dylib in the search order for a lookup.
+///
+/// If MatchHiddenSymbolsOnly is used (the default) for a given dylib, then
+/// only symbols in that Dylib's interface will be searched. If
+/// MatchHiddenSymbols is used then symbols with hidden visibility will match
+/// as well.
+enum class JITDylibLookupFlags { MatchExportedSymbolsOnly, MatchAllSymbols };
+
+/// Lookup flags that apply to each symbol in a lookup.
+///
+/// If RequiredSymbol is used (the default) for a given symbol then that symbol
+/// must be found during the lookup or the lookup will fail returning a
+/// SymbolNotFound error. If WeaklyReferencedSymbol is used and the given
+/// symbol is not found then the query will continue, and no result for the
+/// missing symbol will be present in the result (assuming the rest of the
+/// lookup succeeds).
+enum class SymbolLookupFlags { RequiredSymbol, WeaklyReferencedSymbol };
+
+/// Describes the kind of lookup being performed. The lookup kind is passed to
+/// symbol generators (if they're invoked) to help them determine what
+/// definitions to generate.
+///
+/// Static -- Lookup is being performed as-if at static link time (e.g.
+///           generators representing static archives should pull in new
+///           definitions).
+///
+/// DLSym -- Lookup is being performed as-if at runtime (e.g. generators
+///          representing static archives should not pull in new definitions).
+enum class LookupKind { Static, DLSym };
+
+/// A list of (JITDylib*, JITDylibLookupFlags) pairs to be used as a search
+/// order during symbol lookup.
+using JITDylibSearchOrder =
+    std::vector<std::pair<JITDylib *, JITDylibLookupFlags>>;
+
+/// Convenience function for creating a search order from an ArrayRef of
+/// JITDylib*, all with the same flags.
+inline JITDylibSearchOrder makeJITDylibSearchOrder(
+    ArrayRef<JITDylib *> JDs,
+    JITDylibLookupFlags Flags = JITDylibLookupFlags::MatchExportedSymbolsOnly) {
+  JITDylibSearchOrder O;
+  O.reserve(JDs.size());
+  for (auto *JD : JDs)
+    O.push_back(std::make_pair(JD, Flags));
+  return O;
+}
+
+/// A set of symbols to look up, each associated with a SymbolLookupFlags
+/// value.
+///
+/// This class is backed by a vector and optimized for fast insertion,
+/// deletion and iteration. It does not guarantee a stable order between
+/// operations, and will not automatically detect duplicate elements (they
+/// can be manually checked by calling the validate method).
+class SymbolLookupSet {
+public:
+  using value_type = std::pair<SymbolStringPtr, SymbolLookupFlags>;
+  using UnderlyingVector = std::vector<value_type>;
+  using iterator = UnderlyingVector::iterator;
+  using const_iterator = UnderlyingVector::const_iterator;
+
+  SymbolLookupSet() = default;
+
+  explicit SymbolLookupSet(
+      SymbolStringPtr Name,
+      SymbolLookupFlags Flags = SymbolLookupFlags::RequiredSymbol) {
+    add(std::move(Name), Flags);
+  }
+
+  /// Construct a SymbolLookupSet from an initializer list of SymbolStringPtrs.
+  explicit SymbolLookupSet(
+      std::initializer_list<SymbolStringPtr> Names,
+      SymbolLookupFlags Flags = SymbolLookupFlags::RequiredSymbol) {
+    Symbols.reserve(Names.size());
+    for (auto &Name : Names)
+      add(std::move(Name), Flags);
+  }
+
+  /// Construct a SymbolLookupSet from a SymbolNameSet with the given
+  /// Flags used for each value.
+  explicit SymbolLookupSet(
+      const SymbolNameSet &Names,
+      SymbolLookupFlags Flags = SymbolLookupFlags::RequiredSymbol) {
+    Symbols.reserve(Names.size());
+    for (const auto &Name : Names)
+      add(Name, Flags);
+  }
+
+  /// Construct a SymbolLookupSet from a vector of symbols with the given Flags
+  /// used for each value.
+  /// If the ArrayRef contains duplicates it is up to the client to remove these
+  /// before using this instance for lookup.
+  explicit SymbolLookupSet(
+      ArrayRef<SymbolStringPtr> Names,
+      SymbolLookupFlags Flags = SymbolLookupFlags::RequiredSymbol) {
+    Symbols.reserve(Names.size());
+    for (const auto &Name : Names)
+      add(Name, Flags);
+  }
+
+  /// Add an element to the set. The client is responsible for checking that
+  /// duplicates are not added.
+  SymbolLookupSet &
+  add(SymbolStringPtr Name,
+      SymbolLookupFlags Flags = SymbolLookupFlags::RequiredSymbol) {
+    Symbols.push_back(std::make_pair(std::move(Name), Flags));
+    return *this;
+  }
+
+  /// Quickly append one lookup set to another.
+  SymbolLookupSet &append(SymbolLookupSet Other) {
+    Symbols.reserve(Symbols.size() + Other.size());
+    for (auto &KV : Other)
+      Symbols.push_back(std::move(KV));
+    return *this;
+  }
+
+  bool empty() const { return Symbols.empty(); }
+  UnderlyingVector::size_type size() const { return Symbols.size(); }
+  iterator begin() { return Symbols.begin(); }
+  iterator end() { return Symbols.end(); }
+  const_iterator begin() const { return Symbols.begin(); }
+  const_iterator end() const { return Symbols.end(); }
+
+  /// Removes the Ith element of the vector, replacing it with the last element.
+  void remove(UnderlyingVector::size_type I) {
+    std::swap(Symbols[I], Symbols.back());
+    Symbols.pop_back();
+  }
+
+  /// Removes the element pointed to by the given iterator. This iterator and
+  /// all subsequent ones (including end()) are invalidated.
+  void remove(iterator I) { remove(I - begin()); }
+
+  /// Removes all elements matching the given predicate, which must be callable
+  /// as bool(const SymbolStringPtr &, SymbolLookupFlags Flags).
+  template <typename PredFn> void remove_if(PredFn &&Pred) {
+    UnderlyingVector::size_type I = 0;
+    while (I != Symbols.size()) {
+      const auto &Name = Symbols[I].first;
+      auto Flags = Symbols[I].second;
+      if (Pred(Name, Flags))
+        remove(I);
+      else
+        ++I;
+    }
+  }
+
+  /// Loop over the elements of this SymbolLookupSet, applying the Body function
+  /// to each one. Body must be callable as
+  /// bool(const SymbolStringPtr &, SymbolLookupFlags).
+  /// If Body returns true then the element just passed in is removed from the
+  /// set. If Body returns false then the element is retained.
+  template <typename BodyFn>
+  auto forEachWithRemoval(BodyFn &&Body) -> std::enable_if_t<
+      std::is_same<decltype(Body(std::declval<const SymbolStringPtr &>(),
+                                 std::declval<SymbolLookupFlags>())),
+                   bool>::value> {
+    UnderlyingVector::size_type I = 0;
+    while (I != Symbols.size()) {
+      const auto &Name = Symbols[I].first;
+      auto Flags = Symbols[I].second;
+      if (Body(Name, Flags))
+        remove(I);
+      else
+        ++I;
+    }
+  }
+
+  /// Loop over the elements of this SymbolLookupSet, applying the Body function
+  /// to each one. Body must be callable as
+  /// Expected<bool>(const SymbolStringPtr &, SymbolLookupFlags).
+  /// If Body returns a failure value, the loop exits immediately. If Body
+  /// returns true then the element just passed in is removed from the set. If
+  /// Body returns false then the element is retained.
+  template <typename BodyFn>
+  auto forEachWithRemoval(BodyFn &&Body) -> std::enable_if_t<
+      std::is_same<decltype(Body(std::declval<const SymbolStringPtr &>(),
+                                 std::declval<SymbolLookupFlags>())),
+                   Expected<bool>>::value,
+      Error> {
+    UnderlyingVector::size_type I = 0;
+    while (I != Symbols.size()) {
+      const auto &Name = Symbols[I].first;
+      auto Flags = Symbols[I].second;
+      auto Remove = Body(Name, Flags);
+      if (!Remove)
+        return Remove.takeError();
+      if (*Remove)
+        remove(I);
+      else
+        ++I;
+    }
+    return Error::success();
+  }
+
+  /// Construct a SymbolNameVector from this instance by dropping the Flags
+  /// values.
+  SymbolNameVector getSymbolNames() const {
+    SymbolNameVector Names;
+    Names.reserve(Symbols.size());
+    for (auto &KV : Symbols)
+      Names.push_back(KV.first);
+    return Names;
+  }
+
+  /// Sort the lookup set by pointer value. This sort is fast but sensitive to
+  /// allocation order and so should not be used where a consistent order is
+  /// required.
+  void sortByAddress() {
+    llvm::sort(Symbols, [](const value_type &LHS, const value_type &RHS) {
+      return LHS.first < RHS.first;
+    });
+  }
+
+  /// Sort the lookup set lexicographically. This sort is slow but the order
+  /// is unaffected by allocation order.
+  void sortByName() {
+    llvm::sort(Symbols, [](const value_type &LHS, const value_type &RHS) {
+      return *LHS.first < *RHS.first;
+    });
+  }
+
+  /// Remove any duplicate elements. If a SymbolLookupSet is not duplicate-free
+  /// by construction, this method can be used to turn it into a proper set.
+  void removeDuplicates() {
+    sortByAddress();
+    auto LastI = std::unique(Symbols.begin(), Symbols.end());
+    Symbols.erase(LastI, Symbols.end());
+  }
+
+#ifndef NDEBUG
+  /// Returns true if this set contains any duplicates. This should only be used
+  /// in assertions.
+  bool containsDuplicates() {
+    if (Symbols.size() < 2)
+      return false;
+    sortByAddress();
+    for (UnderlyingVector::size_type I = 1; I != Symbols.size(); ++I)
+      if (Symbols[I].first == Symbols[I - 1].first)
+        return true;
+    return false;
+  }
+#endif
+
+private:
+  UnderlyingVector Symbols;
+};
 
 struct SymbolAliasMapEntry {
   SymbolAliasMapEntry() = default;
@@ -69,45 +376,8 @@
 /// A map of Symbols to (Symbol, Flags) pairs.
 using SymbolAliasMap = DenseMap<SymbolStringPtr, SymbolAliasMapEntry>;
 
-/// Render a SymbolStringPtr.
-raw_ostream &operator<<(raw_ostream &OS, const SymbolStringPtr &Sym);
-
-/// Render a SymbolNameSet.
-raw_ostream &operator<<(raw_ostream &OS, const SymbolNameSet &Symbols);
-
-/// Render a SymbolFlagsMap entry.
-raw_ostream &operator<<(raw_ostream &OS, const SymbolFlagsMap::value_type &KV);
-
-/// Render a SymbolMap entry.
-raw_ostream &operator<<(raw_ostream &OS, const SymbolMap::value_type &KV);
-
-/// Render a SymbolFlagsMap.
-raw_ostream &operator<<(raw_ostream &OS, const SymbolFlagsMap &SymbolFlags);
-
-/// Render a SymbolMap.
-raw_ostream &operator<<(raw_ostream &OS, const SymbolMap &Symbols);
-
-/// Render a SymbolDependenceMap entry.
-raw_ostream &operator<<(raw_ostream &OS,
-                        const SymbolDependenceMap::value_type &KV);
-
-/// Render a SymbolDependendeMap.
-raw_ostream &operator<<(raw_ostream &OS, const SymbolDependenceMap &Deps);
-
-/// Render a MaterializationUnit.
-raw_ostream &operator<<(raw_ostream &OS, const MaterializationUnit &MU);
-
-/// Render a JITDylibSearchList.
-raw_ostream &operator<<(raw_ostream &OS, const JITDylibSearchList &JDs);
-
-/// Render a SymbolAliasMap.
-raw_ostream &operator<<(raw_ostream &OS, const SymbolAliasMap &Aliases);
-
-/// Render a SymbolState.
-raw_ostream &operator<<(raw_ostream &OS, const SymbolState &S);
-
 /// Callback to notify client that symbols have been resolved.
-using SymbolsResolvedCallback = std::function<void(Expected<SymbolMap>)>;
+using SymbolsResolvedCallback = unique_function<void(Expected<SymbolMap>)>;
 
 /// Callback to register the dependencies for a given query.
 using RegisterDependenciesFunction =
@@ -117,19 +387,31 @@
 /// are no dependants to register with.
 extern RegisterDependenciesFunction NoDependenciesToRegister;
 
+class ResourceTrackerDefunct : public ErrorInfo<ResourceTrackerDefunct> {
+public:
+  static char ID;
+
+  ResourceTrackerDefunct(ResourceTrackerSP RT);
+  std::error_code convertToErrorCode() const override;
+  void log(raw_ostream &OS) const override;
+
+private:
+  ResourceTrackerSP RT;
+};
+
 /// Used to notify a JITDylib that the given set of symbols failed to
 /// materialize.
 class FailedToMaterialize : public ErrorInfo<FailedToMaterialize> {
 public:
   static char ID;
 
-  FailedToMaterialize(SymbolNameSet Symbols);
+  FailedToMaterialize(std::shared_ptr<SymbolDependenceMap> Symbols);
   std::error_code convertToErrorCode() const override;
   void log(raw_ostream &OS) const override;
-  const SymbolNameSet &getSymbols() const { return Symbols; }
+  const SymbolDependenceMap &getSymbols() const { return *Symbols; }
 
 private:
-  SymbolNameSet Symbols;
+  std::shared_ptr<SymbolDependenceMap> Symbols;
 };
 
 /// Used to notify clients when symbols can not be found during a lookup.
@@ -138,12 +420,13 @@
   static char ID;
 
   SymbolsNotFound(SymbolNameSet Symbols);
+  SymbolsNotFound(SymbolNameVector Symbols);
   std::error_code convertToErrorCode() const override;
   void log(raw_ostream &OS) const override;
-  const SymbolNameSet &getSymbols() const { return Symbols; }
+  const SymbolNameVector &getSymbols() const { return Symbols; }
 
 private:
-  SymbolNameSet Symbols;
+  SymbolNameVector Symbols;
 };
 
 /// Used to notify clients that a set of symbols could not be removed.
@@ -160,6 +443,44 @@
   SymbolNameSet Symbols;
 };
 
+/// Errors of this type should be returned if a module fails to include
+/// definitions that are claimed by the module's associated
+/// MaterializationResponsibility. If this error is returned it is indicative of
+/// a broken transformation / compiler / object cache.
+class MissingSymbolDefinitions : public ErrorInfo<MissingSymbolDefinitions> {
+public:
+  static char ID;
+
+  MissingSymbolDefinitions(std::string ModuleName, SymbolNameVector Symbols)
+    : ModuleName(std::move(ModuleName)), Symbols(std::move(Symbols)) {}
+  std::error_code convertToErrorCode() const override;
+  void log(raw_ostream &OS) const override;
+  const std::string &getModuleName() const { return ModuleName; }
+  const SymbolNameVector &getSymbols() const { return Symbols; }
+private:
+  std::string ModuleName;
+  SymbolNameVector Symbols;
+};
+
+/// Errors of this type should be returned if a module contains definitions for
+/// symbols that are not claimed by the module's associated
+/// MaterializationResponsibility. If this error is returned it is indicative of
+/// a broken transformation / compiler / object cache.
+class UnexpectedSymbolDefinitions : public ErrorInfo<UnexpectedSymbolDefinitions> {
+public:
+  static char ID;
+
+  UnexpectedSymbolDefinitions(std::string ModuleName, SymbolNameVector Symbols)
+    : ModuleName(std::move(ModuleName)), Symbols(std::move(Symbols)) {}
+  std::error_code convertToErrorCode() const override;
+  void log(raw_ostream &OS) const override;
+  const std::string &getModuleName() const { return ModuleName; }
+  const SymbolNameVector &getSymbols() const { return Symbols; }
+private:
+  std::string ModuleName;
+  SymbolNameVector Symbols;
+};
+
 /// Tracks responsibility for materialization, and mediates interactions between
 /// MaterializationUnits and JDs.
 ///
@@ -168,9 +489,10 @@
 /// emit symbols, or abandon materialization by notifying any unmaterialized
 /// symbols of an error.
 class MaterializationResponsibility {
-  friend class MaterializationUnit;
+  friend class ExecutionSession;
+
 public:
-  MaterializationResponsibility(MaterializationResponsibility &&) = default;
+  MaterializationResponsibility(MaterializationResponsibility &&) = delete;
   MaterializationResponsibility &
   operator=(MaterializationResponsibility &&) = delete;
 
@@ -179,12 +501,15 @@
   ///        emitted or notified of an error.
   ~MaterializationResponsibility();
 
+  /// Returns the ResourceTracker for this instance.
+  template <typename Func> Error withResourceKeyDo(Func &&F) const;
+
   /// Returns the target JITDylib that these symbols are being materialized
   ///        into.
-  JITDylib &getTargetJITDylib() const { return JD; }
+  JITDylib &getTargetJITDylib() const { return *JD; }
 
-  /// Returns the VModuleKey for this instance.
-  VModuleKey getVModuleKey() const { return K; }
+  /// Returns the ExecutionSession for this instance.
+  ExecutionSession &getExecutionSession();
 
   /// Returns the symbol flags map for this responsibility instance.
   /// Note: The returned flags may have transient flags (Lazy, Materializing)
@@ -192,6 +517,11 @@
   /// before using.
   const SymbolFlagsMap &getSymbols() const { return SymbolFlags; }
 
+  /// Returns the initialization pseudo-symbol, if any. This symbol will also
+  /// be present in the SymbolFlagsMap for this MaterializationResponsibility
+  /// object.
+  const SymbolStringPtr &getInitializerSymbol() const { return InitSymbol; }
+
   /// Returns the names of any symbols covered by this
   /// MaterializationResponsibility object that have queries pending. This
   /// information can be used to return responsibility for unrequested symbols
@@ -204,20 +534,53 @@
   /// symbols must be ones covered by this MaterializationResponsibility
   /// instance. Individual calls to this method may resolve a subset of the
   /// symbols, but all symbols must have been resolved prior to calling emit.
-  void notifyResolved(const SymbolMap &Symbols);
+  ///
+  /// This method will return an error if any symbols being resolved have been
+  /// moved to the error state due to the failure of a dependency. If this
+  /// method returns an error then clients should log it and call
+  /// failMaterialize. If no dependencies have been registered for the
+  /// symbols covered by this MaterializationResponsibiility then this method
+  /// is guaranteed to return Error::success() and can be wrapped with cantFail.
+  Error notifyResolved(const SymbolMap &Symbols);
 
   /// Notifies the target JITDylib (and any pending queries on that JITDylib)
   /// that all symbols covered by this MaterializationResponsibility instance
   /// have been emitted.
-  void notifyEmitted();
+  ///
+  /// This method will return an error if any symbols being resolved have been
+  /// moved to the error state due to the failure of a dependency. If this
+  /// method returns an error then clients should log it and call
+  /// failMaterialize. If no dependencies have been registered for the
+  /// symbols covered by this MaterializationResponsibiility then this method
+  /// is guaranteed to return Error::success() and can be wrapped with cantFail.
+  Error notifyEmitted();
 
-  /// Adds new symbols to the JITDylib and this responsibility instance.
-  ///        JITDylib entries start out in the materializing state.
+  /// Attempt to claim responsibility for new definitions. This method can be
+  /// used to claim responsibility for symbols that are added to a
+  /// materialization unit during the compilation process (e.g. literal pool
+  /// symbols). Symbol linkage rules are the same as for symbols that are
+  /// defined up front: duplicate strong definitions will result in errors.
+  /// Duplicate weak definitions will be discarded (in which case they will
+  /// not be added to this responsibility instance).
   ///
   ///   This method can be used by materialization units that want to add
   /// additional symbols at materialization time (e.g. stubs, compile
   /// callbacks, metadata).
-  Error defineMaterializing(const SymbolFlagsMap &SymbolFlags);
+  Error defineMaterializing(SymbolFlagsMap SymbolFlags);
+
+  /// Define the given symbols as non-existent, removing it from the symbol
+  /// table and notifying any pending queries. Queries that lookup up the
+  /// symbol using the SymbolLookupFlags::WeaklyReferencedSymbol flag will
+  /// behave as if the symbol had not been matched in the first place. Queries
+  /// that required this symbol will fail with a missing symbol definition
+  /// error.
+  ///
+  /// This method is intended to support cleanup of special symbols like
+  /// initializer symbols: Queries using
+  /// SymbolLookupFlags::WeaklyReferencedSymbol can be used to trigger their
+  /// emission, and this method can be used to remove them from the JITDylib
+  /// once materialization is complete.
+  void defineNonExistent(ArrayRef<SymbolStringPtr> Symbols);
 
   /// Notify all not-yet-emitted covered by this MaterializationResponsibility
   /// instance that an error has occurred.
@@ -231,13 +594,13 @@
   /// materializers to break up work based on run-time information (e.g.
   /// by introspecting which symbols have actually been looked up and
   /// materializing only those).
-  void replace(std::unique_ptr<MaterializationUnit> MU);
+  Error replace(std::unique_ptr<MaterializationUnit> MU);
 
   /// Delegates responsibility for the given symbols to the returned
   /// materialization responsibility. Useful for breaking up work between
   /// threads, or different kinds of materialization processes.
-  MaterializationResponsibility delegate(const SymbolNameSet &Symbols,
-                                         VModuleKey NewKey = VModuleKey());
+  Expected<std::unique_ptr<MaterializationResponsibility>>
+  delegate(const SymbolNameSet &Symbols);
 
   void addDependencies(const SymbolStringPtr &Name,
                        const SymbolDependenceMap &Dependencies);
@@ -248,12 +611,17 @@
 private:
   /// Create a MaterializationResponsibility for the given JITDylib and
   ///        initial symbols.
-  MaterializationResponsibility(JITDylib &JD, SymbolFlagsMap SymbolFlags,
-                                VModuleKey K);
+  MaterializationResponsibility(JITDylibSP JD, SymbolFlagsMap SymbolFlags,
+                                SymbolStringPtr InitSymbol)
+      : JD(std::move(JD)), SymbolFlags(std::move(SymbolFlags)),
+        InitSymbol(std::move(InitSymbol)) {
+    assert(this->JD && "Cannot initialize with null JITDylib");
+    assert(!this->SymbolFlags.empty() && "Materializing nothing?");
+  }
 
-  JITDylib &JD;
+  JITDylibSP JD;
   SymbolFlagsMap SymbolFlags;
-  VModuleKey K;
+  SymbolStringPtr InitSymbol;
 };
 
 /// A MaterializationUnit represents a set of symbol definitions that can
@@ -265,9 +633,17 @@
 /// is requested via the lookup method. The JITDylib will call discard if a
 /// stronger definition is added or already present.
 class MaterializationUnit {
+  friend class ExecutionSession;
+  friend class JITDylib;
+
 public:
-  MaterializationUnit(SymbolFlagsMap InitalSymbolFlags, VModuleKey K)
-      : SymbolFlags(std::move(InitalSymbolFlags)), K(std::move(K)) {}
+  MaterializationUnit(SymbolFlagsMap InitalSymbolFlags,
+                      SymbolStringPtr InitSymbol)
+      : SymbolFlags(std::move(InitalSymbolFlags)),
+        InitSymbol(std::move(InitSymbol)) {
+    assert((!this->InitSymbol || this->SymbolFlags.count(this->InitSymbol)) &&
+           "If set, InitSymbol should appear in InitialSymbolFlags map");
+  }
 
   virtual ~MaterializationUnit() {}
 
@@ -278,13 +654,14 @@
   /// Return the set of symbols that this source provides.
   const SymbolFlagsMap &getSymbols() const { return SymbolFlags; }
 
-  /// Called by materialization dispatchers (see
-  /// ExecutionSession::DispatchMaterializationFunction) to trigger
-  /// materialization of this MaterializationUnit.
-  void doMaterialize(JITDylib &JD) {
-    materialize(MaterializationResponsibility(JD, std::move(SymbolFlags),
-                                              std::move(K)));
-  }
+  /// Returns the initialization symbol for this MaterializationUnit (if any).
+  const SymbolStringPtr &getInitializerSymbol() const { return InitSymbol; }
+
+  /// Implementations of this method should materialize all symbols
+  ///        in the materialzation unit, except for those that have been
+  ///        previously discarded.
+  virtual void
+  materialize(std::unique_ptr<MaterializationResponsibility> R) = 0;
 
   /// Called by JITDylibs to notify MaterializationUnits that the given symbol
   /// has been overridden.
@@ -295,16 +672,11 @@
 
 protected:
   SymbolFlagsMap SymbolFlags;
-  VModuleKey K;
+  SymbolStringPtr InitSymbol;
 
 private:
   virtual void anchor();
 
-  /// Implementations of this method should materialize all symbols
-  ///        in the materialzation unit, except for those that have been
-  ///        previously discarded.
-  virtual void materialize(MaterializationResponsibility R) = 0;
-
   /// Implementations of this method should discard the given symbol
   ///        from the source (e.g. if the source is an LLVM IR Module and the
   ///        symbol is a function, delete the function body or mark it available
@@ -312,21 +684,18 @@
   virtual void discard(const JITDylib &JD, const SymbolStringPtr &Name) = 0;
 };
 
-using MaterializationUnitList =
-    std::vector<std::unique_ptr<MaterializationUnit>>;
-
 /// A MaterializationUnit implementation for pre-existing absolute symbols.
 ///
 /// All symbols will be resolved and marked ready as soon as the unit is
 /// materialized.
 class AbsoluteSymbolsMaterializationUnit : public MaterializationUnit {
 public:
-  AbsoluteSymbolsMaterializationUnit(SymbolMap Symbols, VModuleKey K);
+  AbsoluteSymbolsMaterializationUnit(SymbolMap Symbols);
 
   StringRef getName() const override;
 
 private:
-  void materialize(MaterializationResponsibility R) override;
+  void materialize(std::unique_ptr<MaterializationResponsibility> R) override;
   void discard(const JITDylib &JD, const SymbolStringPtr &Name) override;
   static SymbolFlagsMap extractFlags(const SymbolMap &Symbols);
 
@@ -344,9 +713,9 @@
 /// \endcode
 ///
 inline std::unique_ptr<AbsoluteSymbolsMaterializationUnit>
-absoluteSymbols(SymbolMap Symbols, VModuleKey K = VModuleKey()) {
-  return llvm::make_unique<AbsoluteSymbolsMaterializationUnit>(
-      std::move(Symbols), std::move(K));
+absoluteSymbols(SymbolMap Symbols) {
+  return std::make_unique<AbsoluteSymbolsMaterializationUnit>(
+      std::move(Symbols));
 }
 
 /// A materialization unit for symbol aliases. Allows existing symbols to be
@@ -361,18 +730,19 @@
   /// Note: Care must be taken that no sets of aliases form a cycle, as such
   ///       a cycle will result in a deadlock when any symbol in the cycle is
   ///       resolved.
-  ReExportsMaterializationUnit(JITDylib *SourceJD, bool MatchNonExported,
-                               SymbolAliasMap Aliases, VModuleKey K);
+  ReExportsMaterializationUnit(JITDylib *SourceJD,
+                               JITDylibLookupFlags SourceJDLookupFlags,
+                               SymbolAliasMap Aliases);
 
   StringRef getName() const override;
 
 private:
-  void materialize(MaterializationResponsibility R) override;
+  void materialize(std::unique_ptr<MaterializationResponsibility> R) override;
   void discard(const JITDylib &JD, const SymbolStringPtr &Name) override;
   static SymbolFlagsMap extractFlags(const SymbolAliasMap &Aliases);
 
   JITDylib *SourceJD = nullptr;
-  bool MatchNonExported = false;
+  JITDylibLookupFlags SourceJDLookupFlags;
   SymbolAliasMap Aliases;
 };
 
@@ -388,47 +758,26 @@
 ///     return Err;
 /// \endcode
 inline std::unique_ptr<ReExportsMaterializationUnit>
-symbolAliases(SymbolAliasMap Aliases, VModuleKey K = VModuleKey()) {
-  return llvm::make_unique<ReExportsMaterializationUnit>(
-      nullptr, true, std::move(Aliases), std::move(K));
+symbolAliases(SymbolAliasMap Aliases) {
+  return std::make_unique<ReExportsMaterializationUnit>(
+      nullptr, JITDylibLookupFlags::MatchAllSymbols, std::move(Aliases));
 }
 
 /// Create a materialization unit for re-exporting symbols from another JITDylib
 /// with alternative names/flags.
-/// If MatchNonExported is true then non-exported symbols from SourceJD can be
-/// re-exported. If it is false, attempts to re-export a non-exported symbol
-/// will result in a "symbol not found" error.
+/// SourceJD will be searched using the given JITDylibLookupFlags.
 inline std::unique_ptr<ReExportsMaterializationUnit>
 reexports(JITDylib &SourceJD, SymbolAliasMap Aliases,
-          bool MatchNonExported = false, VModuleKey K = VModuleKey()) {
-  return llvm::make_unique<ReExportsMaterializationUnit>(
-      &SourceJD, MatchNonExported, std::move(Aliases), std::move(K));
+          JITDylibLookupFlags SourceJDLookupFlags =
+              JITDylibLookupFlags::MatchExportedSymbolsOnly) {
+  return std::make_unique<ReExportsMaterializationUnit>(
+      &SourceJD, SourceJDLookupFlags, std::move(Aliases));
 }
 
 /// Build a SymbolAliasMap for the common case where you want to re-export
 /// symbols from another JITDylib with the same linkage/flags.
 Expected<SymbolAliasMap>
-buildSimpleReexportsAliasMap(JITDylib &SourceJD, const SymbolNameSet &Symbols);
-
-/// ReexportsGenerator can be used with JITDylib::setGenerator to automatically
-/// re-export a subset of the source JITDylib's symbols in the target.
-class ReexportsGenerator {
-public:
-  using SymbolPredicate = std::function<bool(SymbolStringPtr)>;
-
-  /// Create a reexports generator. If an Allow predicate is passed, only
-  /// symbols for which the predicate returns true will be reexported. If no
-  /// Allow predicate is passed, all symbols will be exported.
-  ReexportsGenerator(JITDylib &SourceJD, bool MatchNonExported = false,
-                     SymbolPredicate Allow = SymbolPredicate());
-
-  Expected<SymbolNameSet> operator()(JITDylib &JD, const SymbolNameSet &Names);
-
-private:
-  JITDylib &SourceJD;
-  bool MatchNonExported = false;
-  SymbolPredicate Allow;
-};
+buildSimpleReexportsAAliasMap(JITDylib &SourceJD, const SymbolNameSet &Symbols);
 
 /// Represents the state that a symbol has reached during materialization.
 enum class SymbolState : uint8_t {
@@ -436,6 +785,7 @@
   NeverSearched, /// Added to the symbol table, never queried.
   Materializing, /// Queried, materialization begun.
   Resolved,      /// Assigned address, still materializing.
+  Emitted,       /// Emitted to memory, but waiting on transitive dependencies.
   Ready = 0x3f   /// Ready and safe for clients to access.
 };
 
@@ -445,14 +795,16 @@
 /// makes a callback when all symbols are available.
 class AsynchronousSymbolQuery {
   friend class ExecutionSession;
+  friend class InProgressFullLookupState;
   friend class JITDylib;
   friend class JITSymbolResolverAdapter;
+  friend class MaterializationResponsibility;
 
 public:
   /// Create a query for the given symbols. The NotifyComplete
   /// callback will be called once all queried symbols reach the given
   /// minimum state.
-  AsynchronousSymbolQuery(const SymbolNameSet &Symbols,
+  AsynchronousSymbolQuery(const SymbolLookupSet &Symbols,
                           SymbolState RequiredState,
                           SymbolsResolvedCallback NotifyComplete);
 
@@ -477,7 +829,7 @@
 
   void removeQueryDependence(JITDylib &JD, const SymbolStringPtr &Name);
 
-  bool canStillFail();
+  void dropSymbol(const SymbolStringPtr &Name);
 
   void handleFailed(Error Err);
 
@@ -490,19 +842,62 @@
   SymbolState RequiredState;
 };
 
+/// Wraps state for a lookup-in-progress.
+/// DefinitionGenerators can optionally take ownership of a LookupState object
+/// to suspend a lookup-in-progress while they search for definitions.
+class LookupState {
+  friend class OrcV2CAPIHelper;
+  friend class ExecutionSession;
+
+public:
+  LookupState();
+  LookupState(LookupState &&);
+  LookupState &operator=(LookupState &&);
+  ~LookupState();
+
+  /// Continue the lookup. This can be called by DefinitionGenerators
+  /// to re-start a captured query-application operation.
+  void continueLookup(Error Err);
+
+private:
+  LookupState(std::unique_ptr<InProgressLookupState> IPLS);
+
+  // For C API.
+  void reset(InProgressLookupState *IPLS);
+
+  std::unique_ptr<InProgressLookupState> IPLS;
+};
+
+/// Definition generators can be attached to JITDylibs to generate new
+/// definitions for otherwise unresolved symbols during lookup.
+class DefinitionGenerator {
+public:
+  virtual ~DefinitionGenerator();
+
+  /// DefinitionGenerators should override this method to insert new
+  /// definitions into the parent JITDylib. K specifies the kind of this
+  /// lookup. JD specifies the target JITDylib being searched, and
+  /// JDLookupFlags specifies whether the search should match against
+  /// hidden symbols. Finally, Symbols describes the set of unresolved
+  /// symbols and their associated lookup flags.
+  virtual Error tryToGenerate(LookupState &LS, LookupKind K, JITDylib &JD,
+                              JITDylibLookupFlags JDLookupFlags,
+                              const SymbolLookupSet &LookupSet) = 0;
+};
+
 /// A symbol table that supports asynchoronous symbol queries.
 ///
 /// Represents a virtual shared object. Instances can not be copied or moved, so
 /// their addresses may be used as keys for resource management.
 /// JITDylib state changes must be made via an ExecutionSession to guarantee
 /// that they are synchronized with respect to other JITDylib operations.
-class JITDylib {
+class JITDylib : public ThreadSafeRefCountedBase<JITDylib>,
+                 public jitlink::JITLinkDylib {
   friend class AsynchronousSymbolQuery;
   friend class ExecutionSession;
+  friend class Platform;
   friend class MaterializationResponsibility;
 public:
-  using GeneratorFunction = std::function<Expected<SymbolNameSet>(
-      JITDylib &Parent, const SymbolNameSet &Names)>;
 
   using AsynchronousSymbolQuerySet =
     std::set<std::shared_ptr<AsynchronousSymbolQuery>>;
@@ -518,62 +913,88 @@
   /// Get a reference to the ExecutionSession for this JITDylib.
   ExecutionSession &getExecutionSession() const { return ES; }
 
-  /// Set a definition generator. If set, whenever a symbol fails to resolve
-  /// within this JITDylib, lookup and lookupFlags will pass the unresolved
-  /// symbols set to the definition generator. The generator can optionally
-  /// add a definition for the unresolved symbols to the dylib.
-  void setGenerator(GeneratorFunction DefGenerator) {
-    this->DefGenerator = std::move(DefGenerator);
-  }
+  /// Calls remove on all trackers currently associated with this JITDylib.
+  /// Does not run static deinits.
+  ///
+  /// Note that removal happens outside the session lock, so new code may be
+  /// added concurrently while the clear is underway, and the newly added
+  /// code will *not* be cleared. Adding new code concurrently with a clear
+  /// is usually a bug and should be avoided.
+  Error clear();
 
-  /// Set the search order to be used when fixing up definitions in JITDylib.
-  /// This will replace the previous search order, and apply to any symbol
+  /// Get the default resource tracker for this JITDylib.
+  ResourceTrackerSP getDefaultResourceTracker();
+
+  /// Create a resource tracker for this JITDylib.
+  ResourceTrackerSP createResourceTracker();
+
+  /// Adds a definition generator to this JITDylib and returns a referenece to
+  /// it.
+  ///
+  /// When JITDylibs are searched during lookup, if no existing definition of
+  /// a symbol is found, then any generators that have been added are run (in
+  /// the order that they were added) to potentially generate a definition.
+  template <typename GeneratorT>
+  GeneratorT &addGenerator(std::unique_ptr<GeneratorT> DefGenerator);
+
+  /// Remove a definition generator from this JITDylib.
+  ///
+  /// The given generator must exist in this JITDylib's generators list (i.e.
+  /// have been added and not yet removed).
+  void removeGenerator(DefinitionGenerator &G);
+
+  /// Set the link order to be used when fixing up definitions in JITDylib.
+  /// This will replace the previous link order, and apply to any symbol
   /// resolutions made for definitions in this JITDylib after the call to
-  /// setSearchOrder (even if the definition itself was added before the
+  /// setLinkOrder (even if the definition itself was added before the
   /// call).
   ///
-  /// If SearchThisJITDylibFirst is set, which by default it is, then this
-  /// JITDylib will add itself to the beginning of the SearchOrder (Clients
-  /// should *not* put this JITDylib in the list in this case, to avoid
-  /// redundant lookups).
+  /// If LinkAgainstThisJITDylibFirst is true (the default) then this JITDylib
+  /// will add itself to the beginning of the LinkOrder (Clients should not
+  /// put this JITDylib in the list in this case, to avoid redundant lookups).
   ///
-  /// If SearchThisJITDylibFirst is false then the search order will be used as
-  /// given. The main motivation for this feature is to support deliberate
+  /// If LinkAgainstThisJITDylibFirst is false then the link order will be used
+  /// as-is. The primary motivation for this feature is to support deliberate
   /// shadowing of symbols in this JITDylib by a facade JITDylib. For example,
   /// the facade may resolve function names to stubs, and the stubs may compile
   /// lazily by looking up symbols in this dylib. Adding the facade dylib
-  /// as the first in the search order (instead of this dylib) ensures that
+  /// as the first in the link order (instead of this dylib) ensures that
   /// definitions within this dylib resolve to the lazy-compiling stubs,
   /// rather than immediately materializing the definitions in this dylib.
-  void setSearchOrder(JITDylibSearchList NewSearchOrder,
-                      bool SearchThisJITDylibFirst = true,
-                      bool MatchNonExportedInThisDylib = true);
+  void setLinkOrder(JITDylibSearchOrder NewSearchOrder,
+                    bool LinkAgainstThisJITDylibFirst = true);
 
-  /// Add the given JITDylib to the search order for definitions in this
+  /// Add the given JITDylib to the link order for definitions in this
   /// JITDylib.
-  void addToSearchOrder(JITDylib &JD, bool MatcNonExported = false);
+  void addToLinkOrder(JITDylib &JD,
+                      JITDylibLookupFlags JDLookupFlags =
+                          JITDylibLookupFlags::MatchExportedSymbolsOnly);
 
-  /// Replace OldJD with NewJD in the search order if OldJD is present.
+  /// Replace OldJD with NewJD in the link order if OldJD is present.
   /// Otherwise this operation is a no-op.
-  void replaceInSearchOrder(JITDylib &OldJD, JITDylib &NewJD,
-                            bool MatchNonExported = false);
+  void replaceInLinkOrder(JITDylib &OldJD, JITDylib &NewJD,
+                          JITDylibLookupFlags JDLookupFlags =
+                              JITDylibLookupFlags::MatchExportedSymbolsOnly);
 
-  /// Remove the given JITDylib from the search order for this JITDylib if it is
+  /// Remove the given JITDylib from the link order for this JITDylib if it is
   /// present. Otherwise this operation is a no-op.
-  void removeFromSearchOrder(JITDylib &JD);
+  void removeFromLinkOrder(JITDylib &JD);
 
-  /// Do something with the search order (run under the session lock).
+  /// Do something with the link order (run under the session lock).
   template <typename Func>
-  auto withSearchOrderDo(Func &&F)
-      -> decltype(F(std::declval<const JITDylibSearchList &>()));
+  auto withLinkOrderDo(Func &&F)
+      -> decltype(F(std::declval<const JITDylibSearchOrder &>()));
 
   /// Define all symbols provided by the materialization unit to be part of this
   /// JITDylib.
   ///
+  /// If RT is not specified then the default resource tracker will be used.
+  ///
   /// This overload always takes ownership of the MaterializationUnit. If any
   /// errors occur, the MaterializationUnit consumed.
   template <typename MaterializationUnitType>
-  Error define(std::unique_ptr<MaterializationUnitType> &&MU);
+  Error define(std::unique_ptr<MaterializationUnitType> &&MU,
+               ResourceTrackerSP RT = nullptr);
 
   /// Define all symbols provided by the materialization unit to be part of this
   /// JITDylib.
@@ -583,7 +1004,8 @@
   /// may allow the caller to modify the MaterializationUnit to correct the
   /// issue, then re-call define.
   template <typename MaterializationUnitType>
-  Error define(std::unique_ptr<MaterializationUnitType> &MU);
+  Error define(std::unique_ptr<MaterializationUnitType> &MU,
+               ResourceTrackerSP RT = nullptr);
 
   /// Tries to remove the given symbols.
   ///
@@ -597,52 +1019,61 @@
   /// left unmodified (no symbols are removed).
   Error remove(const SymbolNameSet &Names);
 
-  /// Search the given JITDylib for the symbols in Symbols. If found, store
-  ///        the flags for each symbol in Flags. Returns any unresolved symbols.
-  Expected<SymbolFlagsMap> lookupFlags(const SymbolNameSet &Names);
-
   /// Dump current JITDylib state to OS.
   void dump(raw_ostream &OS);
 
-  /// FIXME: Remove this when we remove the old ORC layers.
-  /// Search the given JITDylibs in order for the symbols in Symbols. Results
-  ///        (once they become available) will be returned via the given Query.
-  ///
-  /// If any symbol is not found then the unresolved symbols will be returned,
-  /// and the query will not be applied. The Query is not failed and can be
-  /// re-used in a subsequent lookup once the symbols have been added, or
-  /// manually failed.
-  Expected<SymbolNameSet>
-  legacyLookup(std::shared_ptr<AsynchronousSymbolQuery> Q, SymbolNameSet Names);
+  /// Returns the given JITDylibs and all of their transitive dependencies in
+  /// DFS order (based on linkage relationships). Each JITDylib will appear
+  /// only once.
+  static std::vector<JITDylibSP> getDFSLinkOrder(ArrayRef<JITDylibSP> JDs);
+
+  /// Returns the given JITDylibs and all of their transitive dependensies in
+  /// reverse DFS order (based on linkage relationships). Each JITDylib will
+  /// appear only once.
+  static std::vector<JITDylibSP>
+  getReverseDFSLinkOrder(ArrayRef<JITDylibSP> JDs);
+
+  /// Return this JITDylib and its transitive dependencies in DFS order
+  /// based on linkage relationships.
+  std::vector<JITDylibSP> getDFSLinkOrder();
+
+  /// Rteurn this JITDylib and its transitive dependencies in reverse DFS order
+  /// based on linkage relationships.
+  std::vector<JITDylibSP> getReverseDFSLinkOrder();
 
 private:
   using AsynchronousSymbolQueryList =
       std::vector<std::shared_ptr<AsynchronousSymbolQuery>>;
 
   struct UnmaterializedInfo {
-    UnmaterializedInfo(std::unique_ptr<MaterializationUnit> MU)
-        : MU(std::move(MU)) {}
+    UnmaterializedInfo(std::unique_ptr<MaterializationUnit> MU,
+                       ResourceTracker *RT)
+        : MU(std::move(MU)), RT(RT) {}
 
     std::unique_ptr<MaterializationUnit> MU;
+    ResourceTracker *RT;
   };
 
   using UnmaterializedInfosMap =
       DenseMap<SymbolStringPtr, std::shared_ptr<UnmaterializedInfo>>;
 
+  using UnmaterializedInfosList =
+      std::vector<std::shared_ptr<UnmaterializedInfo>>;
+
   struct MaterializingInfo {
     SymbolDependenceMap Dependants;
     SymbolDependenceMap UnemittedDependencies;
-    bool IsEmitted = false;
 
     void addQuery(std::shared_ptr<AsynchronousSymbolQuery> Q);
     void removeQuery(const AsynchronousSymbolQuery &Q);
     AsynchronousSymbolQueryList takeQueriesMeeting(SymbolState RequiredState);
-    AsynchronousSymbolQueryList takeAllQueries();
+    AsynchronousSymbolQueryList takeAllPendingQueries() {
+      return std::move(PendingQueries);
+    }
     bool hasQueriesPending() const { return !PendingQueries.empty(); }
     const AsynchronousSymbolQueryList &pendingQueries() const {
       return PendingQueries;
     }
-
   private:
     AsynchronousSymbolQueryList PendingQueries;
   };
@@ -660,11 +1091,6 @@
     JITSymbolFlags getFlags() const { return Flags; }
     SymbolState getState() const { return static_cast<SymbolState>(State); }
 
-    bool isInMaterializationPhase() const {
-      return getState() == SymbolState::Materializing ||
-             getState() == SymbolState::Resolved;
-    }
-
     bool hasMaterializerAttached() const { return MaterializerAttached; }
     bool isPendingRemoval() const { return PendingRemoval; }
 
@@ -700,22 +1126,16 @@
 
   JITDylib(ExecutionSession &ES, std::string Name);
 
+  ResourceTrackerSP getTracker(MaterializationResponsibility &MR);
+  std::pair<AsynchronousSymbolQuerySet, std::shared_ptr<SymbolDependenceMap>>
+  removeTracker(ResourceTracker &RT);
+
+  void transferTracker(ResourceTracker &DstRT, ResourceTracker &SrcRT);
+
   Error defineImpl(MaterializationUnit &MU);
 
-  Expected<SymbolNameSet> lookupFlagsImpl(SymbolFlagsMap &Flags,
-                                          const SymbolNameSet &Names);
-
-  Error lodgeQuery(std::shared_ptr<AsynchronousSymbolQuery> &Q,
-                   SymbolNameSet &Unresolved, bool MatchNonExported,
-                   MaterializationUnitList &MUs);
-
-  void lodgeQueryImpl(std::shared_ptr<AsynchronousSymbolQuery> &Q,
-                      SymbolNameSet &Unresolved, bool MatchNonExported,
-                      MaterializationUnitList &MUs);
-
-  bool lookupImpl(std::shared_ptr<AsynchronousSymbolQuery> &Q,
-                  std::vector<std::unique_ptr<MaterializationUnit>> &MUs,
-                  SymbolNameSet &Unresolved);
+  void installMaterializationUnit(std::unique_ptr<MaterializationUnit> MU,
+                                  ResourceTracker &RT);
 
   void detachQueryHelper(AsynchronousSymbolQuery &Q,
                          const SymbolNameSet &QuerySymbols);
@@ -724,86 +1144,156 @@
                                        const SymbolStringPtr &DependantName,
                                        MaterializingInfo &EmittedMI);
 
-  Error defineMaterializing(const SymbolFlagsMap &SymbolFlags);
+  Expected<SymbolFlagsMap> defineMaterializing(SymbolFlagsMap SymbolFlags);
 
-  void replace(std::unique_ptr<MaterializationUnit> MU);
+  Error replace(MaterializationResponsibility &FromMR,
+                std::unique_ptr<MaterializationUnit> MU);
+
+  Expected<std::unique_ptr<MaterializationResponsibility>>
+  delegate(MaterializationResponsibility &FromMR, SymbolFlagsMap SymbolFlags,
+           SymbolStringPtr InitSymbol);
 
   SymbolNameSet getRequestedSymbols(const SymbolFlagsMap &SymbolFlags) const;
 
   void addDependencies(const SymbolStringPtr &Name,
                        const SymbolDependenceMap &Dependants);
 
-  void resolve(const SymbolMap &Resolved);
+  Error resolve(MaterializationResponsibility &MR, const SymbolMap &Resolved);
 
-  void emit(const SymbolFlagsMap &Emitted);
+  Error emit(MaterializationResponsibility &MR, const SymbolFlagsMap &Emitted);
 
-  void notifyFailed(const SymbolNameSet &FailedSymbols);
+  void unlinkMaterializationResponsibility(MaterializationResponsibility &MR);
+
+  using FailedSymbolsWorklist =
+      std::vector<std::pair<JITDylib *, SymbolStringPtr>>;
+
+  static std::pair<AsynchronousSymbolQuerySet,
+                   std::shared_ptr<SymbolDependenceMap>>
+      failSymbols(FailedSymbolsWorklist);
 
   ExecutionSession &ES;
   std::string JITDylibName;
+  std::mutex GeneratorsMutex;
+  bool Open = true;
   SymbolTable Symbols;
   UnmaterializedInfosMap UnmaterializedInfos;
   MaterializingInfosMap MaterializingInfos;
-  GeneratorFunction DefGenerator;
-  JITDylibSearchList SearchOrder;
+  std::vector<std::shared_ptr<DefinitionGenerator>> DefGenerators;
+  JITDylibSearchOrder LinkOrder;
+  ResourceTrackerSP DefaultTracker;
+
+  // Map trackers to sets of symbols tracked.
+  DenseMap<ResourceTracker *, SymbolNameVector> TrackerSymbols;
+  DenseMap<MaterializationResponsibility *, ResourceTracker *> MRTrackers;
+};
+
+/// Platforms set up standard symbols and mediate interactions between dynamic
+/// initializers (e.g. C++ static constructors) and ExecutionSession state.
+/// Note that Platforms do not automatically run initializers: clients are still
+/// responsible for doing this.
+class Platform {
+public:
+  virtual ~Platform();
+
+  /// This method will be called outside the session lock each time a JITDylib
+  /// is created (unless it is created with EmptyJITDylib set) to allow the
+  /// Platform to install any JITDylib specific standard symbols (e.g
+  /// __dso_handle).
+  virtual Error setupJITDylib(JITDylib &JD) = 0;
+
+  /// This method will be called under the ExecutionSession lock each time a
+  /// MaterializationUnit is added to a JITDylib.
+  virtual Error notifyAdding(ResourceTracker &RT,
+                             const MaterializationUnit &MU) = 0;
+
+  /// This method will be called under the ExecutionSession lock when a
+  /// ResourceTracker is removed.
+  virtual Error notifyRemoving(ResourceTracker &RT) = 0;
+
+  /// A utility function for looking up initializer symbols. Performs a blocking
+  /// lookup for the given symbols in each of the given JITDylibs.
+  static Expected<DenseMap<JITDylib *, SymbolMap>>
+  lookupInitSymbols(ExecutionSession &ES,
+                    const DenseMap<JITDylib *, SymbolLookupSet> &InitSyms);
 };
 
 /// An ExecutionSession represents a running JIT program.
 class ExecutionSession {
-  // FIXME: Remove this when we remove the old ORC layers.
+  friend class InProgressLookupFlagsState;
+  friend class InProgressFullLookupState;
   friend class JITDylib;
+  friend class LookupState;
+  friend class MaterializationResponsibility;
+  friend class ResourceTracker;
 
 public:
   /// For reporting errors.
   using ErrorReporter = std::function<void(Error)>;
 
   /// For dispatching MaterializationUnit::materialize calls.
-  using DispatchMaterializationFunction = std::function<void(
-      JITDylib &JD, std::unique_ptr<MaterializationUnit> MU)>;
+  using DispatchMaterializationFunction =
+      std::function<void(std::unique_ptr<MaterializationUnit> MU,
+                         std::unique_ptr<MaterializationResponsibility> MR)>;
 
   /// Construct an ExecutionSession.
   ///
   /// SymbolStringPools may be shared between ExecutionSessions.
   ExecutionSession(std::shared_ptr<SymbolStringPool> SSP = nullptr);
 
+  /// End the session. Closes all JITDylibs.
+  Error endSession();
+
   /// Add a symbol name to the SymbolStringPool and return a pointer to it.
   SymbolStringPtr intern(StringRef SymName) { return SSP->intern(SymName); }
 
   /// Returns a shared_ptr to the SymbolStringPool for this ExecutionSession.
   std::shared_ptr<SymbolStringPool> getSymbolStringPool() const { return SSP; }
 
+  /// Set the Platform for this ExecutionSession.
+  void setPlatform(std::unique_ptr<Platform> P) { this->P = std::move(P); }
+
+  /// Get the Platform for this session.
+  /// Will return null if no Platform has been set for this ExecutionSession.
+  Platform *getPlatform() { return P.get(); }
+
   /// Run the given lambda with the session mutex locked.
-  template <typename Func> auto runSessionLocked(Func &&F) -> decltype(F()) {
+  template <typename Func> decltype(auto) runSessionLocked(Func &&F) {
     std::lock_guard<std::recursive_mutex> Lock(SessionMutex);
     return F();
   }
 
-  /// Get the "main" JITDylib, which is created automatically on construction of
-  /// the ExecutionSession.
-  JITDylib &getMainJITDylib();
+  /// Register the given ResourceManager with this ExecutionSession.
+  /// Managers will be notified of events in reverse order of registration.
+  void registerResourceManager(ResourceManager &RM);
+
+  /// Deregister the given ResourceManager with this ExecutionSession.
+  /// Manager must have been previously registered.
+  void deregisterResourceManager(ResourceManager &RM);
 
   /// Return a pointer to the "name" JITDylib.
   /// Ownership of JITDylib remains within Execution Session
   JITDylib *getJITDylibByName(StringRef Name);
 
+  /// Add a new bare JITDylib to this ExecutionSession.
+  ///
+  /// The JITDylib Name is required to be unique. Clients should verify that
+  /// names are not being re-used (E.g. by calling getJITDylibByName) if names
+  /// are based on user input.
+  ///
+  /// This call does not install any library code or symbols into the newly
+  /// created JITDylib. The client is responsible for all configuration.
+  JITDylib &createBareJITDylib(std::string Name);
+
   /// Add a new JITDylib to this ExecutionSession.
   ///
   /// The JITDylib Name is required to be unique. Clients should verify that
   /// names are not being re-used (e.g. by calling getJITDylibByName) if names
   /// are based on user input.
-  JITDylib &createJITDylib(std::string Name,
-                           bool AddToMainDylibSearchOrder = true);
-
-  /// Allocate a module key for a new module to add to the JIT.
-  VModuleKey allocateVModule() {
-    return runSessionLocked([this]() { return ++LastKey; });
-  }
-
-  /// Return a module key to the ExecutionSession so that it can be
-  ///        re-used. This should only be done once all resources associated
-  ///        with the original key have been released.
-  void releaseVModule(VModuleKey Key) { /* FIXME: Recycle keys */
-  }
+  ///
+  /// If a Platform is attached then Platform::setupJITDylib will be called to
+  /// install standard platform symbols (e.g. standard library interposes).
+  /// If no Platform is attached this call is equivalent to createBareJITDylib.
+  Expected<JITDylib &> createJITDylib(std::string Name);
 
   /// Set the error reporter function.
   ExecutionSession &setErrorReporter(ErrorReporter ReportError) {
@@ -823,19 +1313,18 @@
     return *this;
   }
 
-  void legacyFailQuery(AsynchronousSymbolQuery &Q, Error Err);
+  /// Search the given JITDylibs to find the flags associated with each of the
+  /// given symbols.
+  void lookupFlags(LookupKind K, JITDylibSearchOrder SearchOrder,
+                   SymbolLookupSet Symbols,
+                   unique_function<void(Expected<SymbolFlagsMap>)> OnComplete);
 
-  using LegacyAsyncLookupFunction = std::function<SymbolNameSet(
-      std::shared_ptr<AsynchronousSymbolQuery> Q, SymbolNameSet Names)>;
+  /// Blocking version of lookupFlags.
+  Expected<SymbolFlagsMap> lookupFlags(LookupKind K,
+                                       JITDylibSearchOrder SearchOrder,
+                                       SymbolLookupSet Symbols);
 
-  /// A legacy lookup function for JITSymbolResolverAdapter.
-  /// Do not use -- this will be removed soon.
-  Expected<SymbolMap>
-  legacyLookup(LegacyAsyncLookupFunction AsyncLookup, SymbolNameSet Names,
-               SymbolState RequiredState,
-               RegisterDependenciesFunction RegisterDependencies);
-
-  /// Search the given JITDylib list for the given symbols.
+  /// Search the given JITDylibs for the given symbols.
   ///
   /// SearchOrder lists the JITDylibs to search. For each dylib, the associated
   /// boolean indicates whether the search should match against non-exported
@@ -854,8 +1343,9 @@
   /// dependenant symbols for this query (e.g. it is being made by a top level
   /// client to get an address to call) then the value NoDependenciesToRegister
   /// can be used.
-  void lookup(const JITDylibSearchList &SearchOrder, SymbolNameSet Symbols,
-              SymbolState RequiredState, SymbolsResolvedCallback NotifyComplete,
+  void lookup(LookupKind K, const JITDylibSearchOrder &SearchOrder,
+              SymbolLookupSet Symbols, SymbolState RequiredState,
+              SymbolsResolvedCallback NotifyComplete,
               RegisterDependenciesFunction RegisterDependencies);
 
   /// Blocking version of lookup above. Returns the resolved symbol map.
@@ -865,8 +1355,9 @@
   /// or an error occurs. If WaitUntilReady is false and an error occurs
   /// after resolution, the function will return a success value, but the
   /// error will be reported via reportErrors.
-  Expected<SymbolMap> lookup(const JITDylibSearchList &SearchOrder,
-                             const SymbolNameSet &Symbols,
+  Expected<SymbolMap> lookup(const JITDylibSearchOrder &SearchOrder,
+                             const SymbolLookupSet &Symbols,
+                             LookupKind K = LookupKind::Static,
                              SymbolState RequiredState = SymbolState::Ready,
                              RegisterDependenciesFunction RegisterDependencies =
                                  NoDependenciesToRegister);
@@ -874,30 +1365,31 @@
   /// Convenience version of blocking lookup.
   /// Searches each of the JITDylibs in the search order in turn for the given
   /// symbol.
-  Expected<JITEvaluatedSymbol> lookup(const JITDylibSearchList &SearchOrder,
-                                      SymbolStringPtr Symbol);
+  Expected<JITEvaluatedSymbol>
+  lookup(const JITDylibSearchOrder &SearchOrder, SymbolStringPtr Symbol,
+         SymbolState RequiredState = SymbolState::Ready);
 
   /// Convenience version of blocking lookup.
   /// Searches each of the JITDylibs in the search order in turn for the given
   /// symbol. The search will not find non-exported symbols.
-  Expected<JITEvaluatedSymbol> lookup(ArrayRef<JITDylib *> SearchOrder,
-                                      SymbolStringPtr Symbol);
+  Expected<JITEvaluatedSymbol>
+  lookup(ArrayRef<JITDylib *> SearchOrder, SymbolStringPtr Symbol,
+         SymbolState RequiredState = SymbolState::Ready);
 
   /// Convenience version of blocking lookup.
   /// Searches each of the JITDylibs in the search order in turn for the given
   /// symbol. The search will not find non-exported symbols.
-  Expected<JITEvaluatedSymbol> lookup(ArrayRef<JITDylib *> SearchOrder,
-                                      StringRef Symbol);
+  Expected<JITEvaluatedSymbol>
+  lookup(ArrayRef<JITDylib *> SearchOrder, StringRef Symbol,
+         SymbolState RequiredState = SymbolState::Ready);
 
   /// Materialize the given unit.
-  void dispatchMaterialization(JITDylib &JD,
-                               std::unique_ptr<MaterializationUnit> MU) {
-    LLVM_DEBUG({
-      runSessionLocked([&]() {
-        dbgs() << "Dispatching " << *MU << " for " << JD.getName() << "\n";
-      });
-    });
-    DispatchMaterialization(JD, std::move(MU));
+  void
+  dispatchMaterialization(std::unique_ptr<MaterializationUnit> MU,
+                          std::unique_ptr<MaterializationResponsibility> MR) {
+    assert(MU && "MU must be non-null");
+    DEBUG_WITH_TYPE("orc", dumpDispatchInfo(MR->getTargetJITDylib(), *MU));
+    DispatchMaterialization(std::move(MU), std::move(MR));
   }
 
   /// Dump the state of all the JITDylibs in this session.
@@ -908,84 +1400,290 @@
     logAllUnhandledErrors(std::move(Err), errs(), "JIT session error: ");
   }
 
-  static void
-  materializeOnCurrentThread(JITDylib &JD,
-                             std::unique_ptr<MaterializationUnit> MU) {
-    MU->doMaterialize(JD);
+  static void materializeOnCurrentThread(
+      std::unique_ptr<MaterializationUnit> MU,
+      std::unique_ptr<MaterializationResponsibility> MR) {
+    MU->materialize(std::move(MR));
   }
 
-  void runOutstandingMUs();
+  void dispatchOutstandingMUs();
+
+  static std::unique_ptr<MaterializationResponsibility>
+  createMaterializationResponsibility(ResourceTracker &RT,
+                                      SymbolFlagsMap Symbols,
+                                      SymbolStringPtr InitSymbol) {
+    auto &JD = RT.getJITDylib();
+    std::unique_ptr<MaterializationResponsibility> MR(
+        new MaterializationResponsibility(&JD, std::move(Symbols),
+                                          std::move(InitSymbol)));
+    JD.MRTrackers[MR.get()] = &RT;
+    return MR;
+  }
+
+  Error removeResourceTracker(ResourceTracker &RT);
+  void transferResourceTracker(ResourceTracker &DstRT, ResourceTracker &SrcRT);
+  void destroyResourceTracker(ResourceTracker &RT);
+
+  // State machine functions for query application..
+
+  /// IL_updateCandidatesFor is called to remove already-defined symbols that
+  /// match a given query from the set of candidate symbols to generate
+  /// definitions for (no need to generate a definition if one already exists).
+  Error IL_updateCandidatesFor(JITDylib &JD, JITDylibLookupFlags JDLookupFlags,
+                               SymbolLookupSet &Candidates,
+                               SymbolLookupSet *NonCandidates);
+
+  /// OL_applyQueryPhase1 is an optionally re-startable loop for triggering
+  /// definition generation. It is called when a lookup is performed, and again
+  /// each time that LookupState::continueLookup is called.
+  void OL_applyQueryPhase1(std::unique_ptr<InProgressLookupState> IPLS,
+                           Error Err);
+
+  /// OL_completeLookup is run once phase 1 successfully completes for a lookup
+  /// call. It attempts to attach the symbol to all symbol table entries and
+  /// collect all MaterializationUnits to dispatch. If this method fails then
+  /// all MaterializationUnits will be left un-materialized.
+  void OL_completeLookup(std::unique_ptr<InProgressLookupState> IPLS,
+                         std::shared_ptr<AsynchronousSymbolQuery> Q,
+                         RegisterDependenciesFunction RegisterDependencies);
+
+  /// OL_completeLookupFlags is run once phase 1 successfully completes for a
+  /// lookupFlags call.
+  void OL_completeLookupFlags(
+      std::unique_ptr<InProgressLookupState> IPLS,
+      unique_function<void(Expected<SymbolFlagsMap>)> OnComplete);
+
+  // State machine functions for MaterializationResponsibility.
+  void OL_destroyMaterializationResponsibility(
+      MaterializationResponsibility &MR);
+  SymbolNameSet OL_getRequestedSymbols(const MaterializationResponsibility &MR);
+  Error OL_notifyResolved(MaterializationResponsibility &MR,
+                          const SymbolMap &Symbols);
+  Error OL_notifyEmitted(MaterializationResponsibility &MR);
+  Error OL_defineMaterializing(MaterializationResponsibility &MR,
+                               SymbolFlagsMap SymbolFlags);
+  void OL_notifyFailed(MaterializationResponsibility &MR);
+  Error OL_replace(MaterializationResponsibility &MR,
+                   std::unique_ptr<MaterializationUnit> MU);
+  Expected<std::unique_ptr<MaterializationResponsibility>>
+  OL_delegate(MaterializationResponsibility &MR, const SymbolNameSet &Symbols);
+  void OL_addDependencies(MaterializationResponsibility &MR,
+                          const SymbolStringPtr &Name,
+                          const SymbolDependenceMap &Dependencies);
+  void OL_addDependenciesForAll(MaterializationResponsibility &MR,
+                                const SymbolDependenceMap &Dependencies);
+
+#ifndef NDEBUG
+  void dumpDispatchInfo(JITDylib &JD, MaterializationUnit &MU);
+#endif // NDEBUG
 
   mutable std::recursive_mutex SessionMutex;
+  bool SessionOpen = true;
   std::shared_ptr<SymbolStringPool> SSP;
-  VModuleKey LastKey = 0;
+  std::unique_ptr<Platform> P;
   ErrorReporter ReportError = logErrorsToStdErr;
   DispatchMaterializationFunction DispatchMaterialization =
       materializeOnCurrentThread;
 
-  std::vector<std::unique_ptr<JITDylib>> JDs;
+  std::vector<ResourceManager *> ResourceManagers;
+
+  std::vector<JITDylibSP> JDs;
 
   // FIXME: Remove this (and runOutstandingMUs) once the linking layer works
   //        with callbacks from asynchronous queries.
   mutable std::recursive_mutex OutstandingMUsMutex;
-  std::vector<std::pair<JITDylib *, std::unique_ptr<MaterializationUnit>>>
+  std::vector<std::pair<std::unique_ptr<MaterializationUnit>,
+                        std::unique_ptr<MaterializationResponsibility>>>
       OutstandingMUs;
 };
 
+inline ExecutionSession &MaterializationResponsibility::getExecutionSession() {
+  return JD->getExecutionSession();
+}
+
 template <typename Func>
-auto JITDylib::withSearchOrderDo(Func &&F)
-    -> decltype(F(std::declval<const JITDylibSearchList &>())) {
-  return ES.runSessionLocked([&]() { return F(SearchOrder); });
-}
-
-template <typename MaterializationUnitType>
-Error JITDylib::define(std::unique_ptr<MaterializationUnitType> &&MU) {
-  assert(MU && "Can not define with a null MU");
-  return ES.runSessionLocked([&, this]() -> Error {
-    if (auto Err = defineImpl(*MU))
-      return Err;
-
-    /// defineImpl succeeded.
-    auto UMI = std::make_shared<UnmaterializedInfo>(std::move(MU));
-    for (auto &KV : UMI->MU->getSymbols())
-      UnmaterializedInfos[KV.first] = UMI;
-
+Error MaterializationResponsibility::withResourceKeyDo(Func &&F) const {
+  return JD->getExecutionSession().runSessionLocked([&]() -> Error {
+    auto I = JD->MRTrackers.find(this);
+    assert(I != JD->MRTrackers.end() && "No tracker for this MR");
+    if (I->second->isDefunct())
+      return make_error<ResourceTrackerDefunct>(I->second);
+    F(I->second->getKeyUnsafe());
     return Error::success();
   });
 }
 
+template <typename GeneratorT>
+GeneratorT &JITDylib::addGenerator(std::unique_ptr<GeneratorT> DefGenerator) {
+  auto &G = *DefGenerator;
+  std::lock_guard<std::mutex> Lock(GeneratorsMutex);
+  DefGenerators.push_back(std::move(DefGenerator));
+  return G;
+}
+
+template <typename Func>
+auto JITDylib::withLinkOrderDo(Func &&F)
+    -> decltype(F(std::declval<const JITDylibSearchOrder &>())) {
+  return ES.runSessionLocked([&]() { return F(LinkOrder); });
+}
+
 template <typename MaterializationUnitType>
-Error JITDylib::define(std::unique_ptr<MaterializationUnitType> &MU) {
+Error JITDylib::define(std::unique_ptr<MaterializationUnitType> &&MU,
+                       ResourceTrackerSP RT) {
   assert(MU && "Can not define with a null MU");
 
+  if (MU->getSymbols().empty()) {
+    // Empty MUs are allowable but pathological, so issue a warning.
+    DEBUG_WITH_TYPE("orc", {
+      dbgs() << "Warning: Discarding empty MU " << MU->getName() << " for "
+             << getName() << "\n";
+    });
+    return Error::success();
+  } else
+    DEBUG_WITH_TYPE("orc", {
+      dbgs() << "Defining MU " << MU->getName() << " for " << getName()
+             << " (tracker: ";
+      if (RT == getDefaultResourceTracker())
+        dbgs() << "default)";
+      else if (RT)
+        dbgs() << RT.get() << ")\n";
+      else
+        dbgs() << "0x0, default will be used)\n";
+    });
+
   return ES.runSessionLocked([&, this]() -> Error {
     if (auto Err = defineImpl(*MU))
       return Err;
 
-    /// defineImpl succeeded.
-    auto UMI = std::make_shared<UnmaterializedInfo>(std::move(MU));
-    for (auto &KV : UMI->MU->getSymbols())
-      UnmaterializedInfos[KV.first] = UMI;
+    if (!RT)
+      RT = getDefaultResourceTracker();
 
+    if (auto *P = ES.getPlatform()) {
+      if (auto Err = P->notifyAdding(*RT, *MU))
+        return Err;
+    }
+
+    installMaterializationUnit(std::move(MU), *RT);
     return Error::success();
   });
 }
 
-/// Mangles symbol names then uniques them in the context of an
-/// ExecutionSession.
-class MangleAndInterner {
+template <typename MaterializationUnitType>
+Error JITDylib::define(std::unique_ptr<MaterializationUnitType> &MU,
+                       ResourceTrackerSP RT) {
+  assert(MU && "Can not define with a null MU");
+
+  if (MU->getSymbols().empty()) {
+    // Empty MUs are allowable but pathological, so issue a warning.
+    DEBUG_WITH_TYPE("orc", {
+      dbgs() << "Warning: Discarding empty MU " << MU->getName() << getName()
+             << "\n";
+    });
+    return Error::success();
+  } else
+    DEBUG_WITH_TYPE("orc", {
+      dbgs() << "Defining MU " << MU->getName() << " for " << getName()
+             << " (tracker: ";
+      if (RT == getDefaultResourceTracker())
+        dbgs() << "default)";
+      else if (RT)
+        dbgs() << RT.get() << ")\n";
+      else
+        dbgs() << "0x0, default will be used)\n";
+    });
+
+  return ES.runSessionLocked([&, this]() -> Error {
+    if (auto Err = defineImpl(*MU))
+      return Err;
+
+    if (!RT)
+      RT = getDefaultResourceTracker();
+
+    if (auto *P = ES.getPlatform()) {
+      if (auto Err = P->notifyAdding(*RT, *MU))
+        return Err;
+    }
+
+    installMaterializationUnit(std::move(MU), *RT);
+    return Error::success();
+  });
+}
+
+/// ReexportsGenerator can be used with JITDylib::addGenerator to automatically
+/// re-export a subset of the source JITDylib's symbols in the target.
+class ReexportsGenerator : public DefinitionGenerator {
 public:
-  MangleAndInterner(ExecutionSession &ES, const DataLayout &DL);
-  SymbolStringPtr operator()(StringRef Name);
+  using SymbolPredicate = std::function<bool(SymbolStringPtr)>;
+
+  /// Create a reexports generator. If an Allow predicate is passed, only
+  /// symbols for which the predicate returns true will be reexported. If no
+  /// Allow predicate is passed, all symbols will be exported.
+  ReexportsGenerator(JITDylib &SourceJD,
+                     JITDylibLookupFlags SourceJDLookupFlags,
+                     SymbolPredicate Allow = SymbolPredicate());
+
+  Error tryToGenerate(LookupState &LS, LookupKind K, JITDylib &JD,
+                      JITDylibLookupFlags JDLookupFlags,
+                      const SymbolLookupSet &LookupSet) override;
 
 private:
-  ExecutionSession &ES;
-  const DataLayout &DL;
+  JITDylib &SourceJD;
+  JITDylibLookupFlags SourceJDLookupFlags;
+  SymbolPredicate Allow;
 };
 
+// --------------- IMPLEMENTATION --------------
+// Implementations for inline functions/methods.
+// ---------------------------------------------
+
+inline MaterializationResponsibility::~MaterializationResponsibility() {
+  JD->getExecutionSession().OL_destroyMaterializationResponsibility(*this);
+}
+
+inline SymbolNameSet MaterializationResponsibility::getRequestedSymbols() const {
+  return JD->getExecutionSession().OL_getRequestedSymbols(*this);
+}
+
+inline Error MaterializationResponsibility::notifyResolved(
+    const SymbolMap &Symbols) {
+  return JD->getExecutionSession().OL_notifyResolved(*this, Symbols);
+}
+
+inline Error MaterializationResponsibility::notifyEmitted() {
+  return JD->getExecutionSession().OL_notifyEmitted(*this);
+}
+
+inline Error MaterializationResponsibility::defineMaterializing(
+    SymbolFlagsMap SymbolFlags) {
+  return JD->getExecutionSession().OL_defineMaterializing(
+      *this, std::move(SymbolFlags));
+}
+
+inline void MaterializationResponsibility::failMaterialization() {
+  JD->getExecutionSession().OL_notifyFailed(*this);
+}
+
+inline Error MaterializationResponsibility::replace(
+    std::unique_ptr<MaterializationUnit> MU) {
+  return JD->getExecutionSession().OL_replace(*this, std::move(MU));
+}
+
+inline Expected<std::unique_ptr<MaterializationResponsibility>>
+MaterializationResponsibility::delegate(const SymbolNameSet &Symbols) {
+  return JD->getExecutionSession().OL_delegate(*this, Symbols);
+}
+
+inline void MaterializationResponsibility::addDependencies(
+    const SymbolStringPtr &Name, const SymbolDependenceMap &Dependencies) {
+  JD->getExecutionSession().OL_addDependencies(*this, Name, Dependencies);
+}
+
+inline void MaterializationResponsibility::addDependenciesForAll(
+    const SymbolDependenceMap &Dependencies) {
+  JD->getExecutionSession().OL_addDependenciesForAll(*this, Dependencies);
+}
+
 } // End namespace orc
 } // End namespace llvm
 
-#undef DEBUG_TYPE // "orc"
-
 #endif // LLVM_EXECUTIONENGINE_ORC_CORE_H
diff --git a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/DebugUtils.h b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/DebugUtils.h
new file mode 100644
index 0000000..4b4472e
--- /dev/null
+++ b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/DebugUtils.h
@@ -0,0 +1,130 @@
+//===----- DebugUtils.h - Utilities for debugging ORC JITs ------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Utilities for debugging ORC-based JITs.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_EXECUTIONENGINE_ORC_DEBUGUTILS_H
+#define LLVM_EXECUTIONENGINE_ORC_DEBUGUTILS_H
+
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ExecutionEngine/Orc/Core.h"
+#include "llvm/ExecutionEngine/Orc/SymbolStringPool.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/raw_ostream.h"
+#include <memory>
+#include <string>
+
+namespace llvm {
+
+class MemoryBuffer;
+
+namespace orc {
+
+// --raw_ostream operators for ORC types--
+
+/// Render a SymbolStringPtr.
+raw_ostream &operator<<(raw_ostream &OS, const SymbolStringPtr &Sym);
+
+/// Render a SymbolNameSet.
+raw_ostream &operator<<(raw_ostream &OS, const SymbolNameSet &Symbols);
+
+/// Render a SymbolNameVector.
+raw_ostream &operator<<(raw_ostream &OS, const SymbolNameVector &Symbols);
+
+/// Render an array of SymbolStringPtrs.
+raw_ostream &operator<<(raw_ostream &OS, ArrayRef<SymbolStringPtr> Symbols);
+
+/// Render JITSymbolFlags.
+raw_ostream &operator<<(raw_ostream &OS, const JITSymbolFlags &Flags);
+
+/// Render a SymbolFlagsMap entry.
+raw_ostream &operator<<(raw_ostream &OS, const SymbolFlagsMap::value_type &KV);
+
+/// Render a SymbolMap entry.
+raw_ostream &operator<<(raw_ostream &OS, const SymbolMap::value_type &KV);
+
+/// Render a SymbolFlagsMap.
+raw_ostream &operator<<(raw_ostream &OS, const SymbolFlagsMap &SymbolFlags);
+
+/// Render a SymbolMap.
+raw_ostream &operator<<(raw_ostream &OS, const SymbolMap &Symbols);
+
+/// Render a SymbolDependenceMap entry.
+raw_ostream &operator<<(raw_ostream &OS,
+                        const SymbolDependenceMap::value_type &KV);
+
+/// Render a SymbolDependendeMap.
+raw_ostream &operator<<(raw_ostream &OS, const SymbolDependenceMap &Deps);
+
+/// Render a MaterializationUnit.
+raw_ostream &operator<<(raw_ostream &OS, const MaterializationUnit &MU);
+
+//// Render a JITDylibLookupFlags instance.
+raw_ostream &operator<<(raw_ostream &OS,
+                        const JITDylibLookupFlags &JDLookupFlags);
+
+/// Rendar a SymbolLookupFlags instance.
+raw_ostream &operator<<(raw_ostream &OS, const SymbolLookupFlags &LookupFlags);
+
+/// Render a JITDylibLookupFlags instance.
+raw_ostream &operator<<(raw_ostream &OS, const LookupKind &K);
+
+/// Render a SymbolLookupSet entry.
+raw_ostream &operator<<(raw_ostream &OS, const SymbolLookupSet::value_type &KV);
+
+/// Render a SymbolLookupSet.
+raw_ostream &operator<<(raw_ostream &OS, const SymbolLookupSet &LookupSet);
+
+/// Render a JITDylibSearchOrder.
+raw_ostream &operator<<(raw_ostream &OS,
+                        const JITDylibSearchOrder &SearchOrder);
+
+/// Render a SymbolAliasMap.
+raw_ostream &operator<<(raw_ostream &OS, const SymbolAliasMap &Aliases);
+
+/// Render a SymbolState.
+raw_ostream &operator<<(raw_ostream &OS, const SymbolState &S);
+
+/// Render a LookupKind.
+raw_ostream &operator<<(raw_ostream &OS, const LookupKind &K);
+
+/// A function object that can be used as an ObjectTransformLayer transform
+/// to dump object files to disk at a specified path.
+class DumpObjects {
+public:
+  /// Construct a DumpObjects transform that will dump objects to disk.
+  ///
+  /// @param DumpDir specifies the path to write dumped objects to. DumpDir may
+  /// be empty, in which case files will be dumped to the working directory. If
+  /// DumpDir is non-empty then any trailing separators will be discarded.
+  ///
+  /// @param IdentifierOverride specifies a file name stem to use when dumping
+  /// objects. If empty, each MemoryBuffer's identifier will be used (with a .o
+  /// suffix added if not already present). If an identifier override is
+  /// supplied it will be used instead (since all buffers will use the same
+  /// identifier, the resulting files will be named <ident>.o, <ident>.2.o,
+  /// <ident>.3.o, and so on). IdentifierOverride should not contain an
+  /// extension, as a .o suffix will be added by DumpObjects.
+  DumpObjects(std::string DumpDir = "", std::string IdentifierOverride = "");
+
+  /// Dumps the given buffer to disk.
+  Expected<std::unique_ptr<MemoryBuffer>>
+  operator()(std::unique_ptr<MemoryBuffer> Obj);
+
+private:
+  StringRef getBufferIdentifier(MemoryBuffer &B);
+  std::string DumpDir;
+  std::string IdentifierOverride;
+};
+
+} // End namespace orc
+} // End namespace llvm
+
+#endif // LLVM_EXECUTIONENGINE_ORC_DEBUGUTILS_H
diff --git a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/ExecutionUtils.h b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/ExecutionUtils.h
index ae3ab8c..1dc2af4 100644
--- a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/ExecutionUtils.h
+++ b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/ExecutionUtils.h
@@ -17,8 +17,10 @@
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/ExecutionEngine/JITSymbol.h"
 #include "llvm/ExecutionEngine/Orc/Core.h"
+#include "llvm/ExecutionEngine/Orc/Mangling.h"
 #include "llvm/ExecutionEngine/Orc/OrcError.h"
 #include "llvm/ExecutionEngine/RuntimeDyld.h"
+#include "llvm/Object/Archive.h"
 #include "llvm/Support/DynamicLibrary.h"
 #include <algorithm>
 #include <cstdint>
@@ -37,6 +39,8 @@
 
 namespace orc {
 
+class ObjectLayer;
+
 /// This iterator provides a convenient way to iterate over the elements
 ///        of an llvm.global_ctors/llvm.global_dtors instance.
 ///
@@ -90,44 +94,53 @@
 ///        array.
 iterator_range<CtorDtorIterator> getDestructors(const Module &M);
 
-/// Convenience class for recording constructor/destructor names for
-///        later execution.
-template <typename JITLayerT>
-class LegacyCtorDtorRunner {
+/// This iterator provides a convenient way to iterate over GlobalValues that
+/// have initialization effects.
+class StaticInitGVIterator {
 public:
-  /// Construct a CtorDtorRunner for the given range using the given
-  ///        name mangling function.
-  LegacyCtorDtorRunner(std::vector<std::string> CtorDtorNames, VModuleKey K)
-      : CtorDtorNames(std::move(CtorDtorNames)), K(K) {}
+  StaticInitGVIterator() = default;
 
-  /// Run the recorded constructors/destructors through the given JIT
-  ///        layer.
-  Error runViaLayer(JITLayerT &JITLayer) const {
-    using CtorDtorTy = void (*)();
-
-    for (const auto &CtorDtorName : CtorDtorNames) {
-      if (auto CtorDtorSym = JITLayer.findSymbolIn(K, CtorDtorName, false)) {
-        if (auto AddrOrErr = CtorDtorSym.getAddress()) {
-          CtorDtorTy CtorDtor =
-            reinterpret_cast<CtorDtorTy>(static_cast<uintptr_t>(*AddrOrErr));
-          CtorDtor();
-        } else
-          return AddrOrErr.takeError();
-      } else {
-        if (auto Err = CtorDtorSym.takeError())
-          return Err;
-        else
-          return make_error<JITSymbolNotFound>(CtorDtorName);
-      }
-    }
-    return Error::success();
+  StaticInitGVIterator(Module &M)
+      : I(M.global_values().begin()), E(M.global_values().end()),
+        ObjFmt(Triple(M.getTargetTriple()).getObjectFormat()) {
+    if (I != E) {
+      if (!isStaticInitGlobal(*I))
+        moveToNextStaticInitGlobal();
+    } else
+      I = E = Module::global_value_iterator();
   }
 
+  bool operator==(const StaticInitGVIterator &O) const { return I == O.I; }
+  bool operator!=(const StaticInitGVIterator &O) const { return I != O.I; }
+
+  StaticInitGVIterator &operator++() {
+    assert(I != E && "Increment past end of range");
+    moveToNextStaticInitGlobal();
+    return *this;
+  }
+
+  GlobalValue &operator*() { return *I; }
+
 private:
-  std::vector<std::string> CtorDtorNames;
-  orc::VModuleKey K;
+  bool isStaticInitGlobal(GlobalValue &GV);
+  void moveToNextStaticInitGlobal() {
+    ++I;
+    while (I != E && !isStaticInitGlobal(*I))
+      ++I;
+    if (I == E)
+      I = E = Module::global_value_iterator();
+  }
+
+  Module::global_value_iterator I, E;
+  Triple::ObjectFormatType ObjFmt;
 };
 
+/// Create an iterator range over the GlobalValues that contribute to static
+/// initialization.
+inline iterator_range<StaticInitGVIterator> getStaticInitGVs(Module &M) {
+  return make_range(StaticInitGVIterator(M), StaticInitGVIterator());
+}
+
 class CtorDtorRunner {
 public:
   CtorDtorRunner(JITDylib &JD) : JD(JD) {}
@@ -176,44 +189,35 @@
                                void *DSOHandle);
 };
 
-class LegacyLocalCXXRuntimeOverrides : public LocalCXXRuntimeOverridesBase {
-public:
-  /// Create a runtime-overrides class.
-  template <typename MangleFtorT>
-  LegacyLocalCXXRuntimeOverrides(const MangleFtorT &Mangle) {
-    addOverride(Mangle("__dso_handle"), toTargetAddress(&DSOHandleOverride));
-    addOverride(Mangle("__cxa_atexit"), toTargetAddress(&CXAAtExitOverride));
-  }
-
-  /// Search overrided symbols.
-  JITEvaluatedSymbol searchOverrides(const std::string &Name) {
-    auto I = CXXRuntimeOverrides.find(Name);
-    if (I != CXXRuntimeOverrides.end())
-      return JITEvaluatedSymbol(I->second, JITSymbolFlags::Exported);
-    return nullptr;
-  }
-
-private:
-  void addOverride(const std::string &Name, JITTargetAddress Addr) {
-    CXXRuntimeOverrides.insert(std::make_pair(Name, Addr));
-  }
-
-  StringMap<JITTargetAddress> CXXRuntimeOverrides;
-};
-
 class LocalCXXRuntimeOverrides : public LocalCXXRuntimeOverridesBase {
 public:
   Error enable(JITDylib &JD, MangleAndInterner &Mangler);
 };
 
+/// An interface for Itanium __cxa_atexit interposer implementations.
+class ItaniumCXAAtExitSupport {
+public:
+  struct AtExitRecord {
+    void (*F)(void *);
+    void *Ctx;
+  };
+
+  void registerAtExit(void (*F)(void *), void *Ctx, void *DSOHandle);
+  void runAtExits(void *DSOHandle);
+
+private:
+  std::mutex AtExitsMutex;
+  DenseMap<void *, std::vector<AtExitRecord>> AtExitRecords;
+};
+
 /// A utility class to expose symbols found via dlsym to the JIT.
 ///
 /// If an instance of this class is attached to a JITDylib as a fallback
 /// definition generator, then any symbol found in the given DynamicLibrary that
 /// passes the 'Allow' predicate will be added to the JITDylib.
-class DynamicLibrarySearchGenerator {
+class DynamicLibrarySearchGenerator : public DefinitionGenerator {
 public:
-  using SymbolPredicate = std::function<bool(SymbolStringPtr)>;
+  using SymbolPredicate = std::function<bool(const SymbolStringPtr &)>;
 
   /// Create a DynamicLibrarySearchGenerator that searches for symbols in the
   /// given sys::DynamicLibrary.
@@ -227,19 +231,21 @@
   /// Permanently loads the library at the given path and, on success, returns
   /// a DynamicLibrarySearchGenerator that will search it for symbol definitions
   /// in the library. On failure returns the reason the library failed to load.
-  static Expected<DynamicLibrarySearchGenerator>
+  static Expected<std::unique_ptr<DynamicLibrarySearchGenerator>>
   Load(const char *FileName, char GlobalPrefix,
        SymbolPredicate Allow = SymbolPredicate());
 
   /// Creates a DynamicLibrarySearchGenerator that searches for symbols in
   /// the current process.
-  static Expected<DynamicLibrarySearchGenerator>
+  static Expected<std::unique_ptr<DynamicLibrarySearchGenerator>>
   GetForCurrentProcess(char GlobalPrefix,
                        SymbolPredicate Allow = SymbolPredicate()) {
     return Load(nullptr, GlobalPrefix, std::move(Allow));
   }
 
-  Expected<SymbolNameSet> operator()(JITDylib &JD, const SymbolNameSet &Names);
+  Error tryToGenerate(LookupState &LS, LookupKind K, JITDylib &JD,
+                      JITDylibLookupFlags JDLookupFlags,
+                      const SymbolLookupSet &Symbols) override;
 
 private:
   sys::DynamicLibrary Dylib;
@@ -247,6 +253,48 @@
   char GlobalPrefix;
 };
 
+/// A utility class to expose symbols from a static library.
+///
+/// If an instance of this class is attached to a JITDylib as a fallback
+/// definition generator, then any symbol found in the archive will result in
+/// the containing object being added to the JITDylib.
+class StaticLibraryDefinitionGenerator : public DefinitionGenerator {
+public:
+  /// Try to create a StaticLibraryDefinitionGenerator from the given path.
+  ///
+  /// This call will succeed if the file at the given path is a static library
+  /// is a valid archive, otherwise it will return an error.
+  static Expected<std::unique_ptr<StaticLibraryDefinitionGenerator>>
+  Load(ObjectLayer &L, const char *FileName);
+
+  /// Try to create a StaticLibraryDefinitionGenerator from the given path.
+  ///
+  /// This call will succeed if the file at the given path is a static library
+  /// or a MachO universal binary containing a static library that is compatible
+  /// with the given triple. Otherwise it will return an error.
+  static Expected<std::unique_ptr<StaticLibraryDefinitionGenerator>>
+  Load(ObjectLayer &L, const char *FileName, const Triple &TT);
+
+  /// Try to create a StaticLibrarySearchGenerator from the given memory buffer.
+  /// This call will succeed if the buffer contains a valid archive, otherwise
+  /// it will return an error.
+  static Expected<std::unique_ptr<StaticLibraryDefinitionGenerator>>
+  Create(ObjectLayer &L, std::unique_ptr<MemoryBuffer> ArchiveBuffer);
+
+  Error tryToGenerate(LookupState &LS, LookupKind K, JITDylib &JD,
+                      JITDylibLookupFlags JDLookupFlags,
+                      const SymbolLookupSet &Symbols) override;
+
+private:
+  StaticLibraryDefinitionGenerator(ObjectLayer &L,
+                                   std::unique_ptr<MemoryBuffer> ArchiveBuffer,
+                                   Error &Err);
+
+  ObjectLayer &L;
+  std::unique_ptr<MemoryBuffer> ArchiveBuffer;
+  std::unique_ptr<object::Archive> Archive;
+};
+
 } // end namespace orc
 } // end namespace llvm
 
diff --git a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/GlobalMappingLayer.h b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/GlobalMappingLayer.h
deleted file mode 100644
index a4e43d4..0000000
--- a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/GlobalMappingLayer.h
+++ /dev/null
@@ -1,111 +0,0 @@
-//===- GlobalMappingLayer.h - Run all IR through a functor ------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// Convenience layer for injecting symbols that will appear in calls to
-// findSymbol.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_EXECUTIONENGINE_ORC_GLOBALMAPPINGLAYER_H
-#define LLVM_EXECUTIONENGINE_ORC_GLOBALMAPPINGLAYER_H
-
-#include "llvm/ExecutionEngine/JITSymbol.h"
-#include <map>
-#include <memory>
-#include <string>
-
-namespace llvm {
-
-class Module;
-class JITSymbolResolver;
-
-namespace orc {
-
-/// Global mapping layer.
-///
-///   This layer overrides the findSymbol method to first search a local symbol
-/// table that the client can define. It can be used to inject new symbol
-/// mappings into the JIT. Beware, however: symbols within a single IR module or
-/// object file will still resolve locally (via RuntimeDyld's symbol table) -
-/// such internal references cannot be overriden via this layer.
-template <typename BaseLayerT>
-class GlobalMappingLayer {
-public:
-
-  /// Handle to an added module.
-  using ModuleHandleT = typename BaseLayerT::ModuleHandleT;
-
-  /// Construct an GlobalMappingLayer with the given BaseLayer
-  GlobalMappingLayer(BaseLayerT &BaseLayer) : BaseLayer(BaseLayer) {}
-
-  /// Add the given module to the JIT.
-  /// @return A handle for the added modules.
-  Expected<ModuleHandleT>
-  addModule(std::shared_ptr<Module> M,
-            std::shared_ptr<JITSymbolResolver> Resolver) {
-    return BaseLayer.addModule(std::move(M), std::move(Resolver));
-  }
-
-  /// Remove the module set associated with the handle H.
-  Error removeModule(ModuleHandleT H) { return BaseLayer.removeModule(H); }
-
-  /// Manually set the address to return for the given symbol.
-  void setGlobalMapping(const std::string &Name, JITTargetAddress Addr) {
-    SymbolTable[Name] = Addr;
-  }
-
-  /// Remove the given symbol from the global mapping.
-  void eraseGlobalMapping(const std::string &Name) {
-    SymbolTable.erase(Name);
-  }
-
-  /// Search for the given named symbol.
-  ///
-  ///          This method will first search the local symbol table, returning
-  ///        any symbol found there. If the symbol is not found in the local
-  ///        table then this call will be passed through to the base layer.
-  ///
-  /// @param Name The name of the symbol to search for.
-  /// @param ExportedSymbolsOnly If true, search only for exported symbols.
-  /// @return A handle for the given named symbol, if it exists.
-  JITSymbol findSymbol(const std::string &Name, bool ExportedSymbolsOnly) {
-    auto I = SymbolTable.find(Name);
-    if (I != SymbolTable.end())
-      return JITSymbol(I->second, JITSymbolFlags::Exported);
-    return BaseLayer.findSymbol(Name, ExportedSymbolsOnly);
-  }
-
-  /// Get the address of the given symbol in the context of the of the
-  ///        module represented by the handle H. This call is forwarded to the
-  ///        base layer's implementation.
-  /// @param H The handle for the module to search in.
-  /// @param Name The name of the symbol to search for.
-  /// @param ExportedSymbolsOnly If true, search only for exported symbols.
-  /// @return A handle for the given named symbol, if it is found in the
-  ///         given module.
-  JITSymbol findSymbolIn(ModuleHandleT H, const std::string &Name,
-                         bool ExportedSymbolsOnly) {
-    return BaseLayer.findSymbolIn(H, Name, ExportedSymbolsOnly);
-  }
-
-  /// Immediately emit and finalize the module set represented by the
-  ///        given handle.
-  /// @param H Handle for module set to emit/finalize.
-  Error emitAndFinalize(ModuleHandleT H) {
-    return BaseLayer.emitAndFinalize(H);
-  }
-
-private:
-  BaseLayerT &BaseLayer;
-  std::map<std::string, JITTargetAddress> SymbolTable;
-};
-
-} // end namespace orc
-} // end namespace llvm
-
-#endif // LLVM_EXECUTIONENGINE_ORC_GLOBALMAPPINGLAYER_H
diff --git a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/IRCompileLayer.h b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/IRCompileLayer.h
index ecff09b..f8fdb17 100644
--- a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/IRCompileLayer.h
+++ b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/IRCompileLayer.h
@@ -29,101 +29,44 @@
 
 class IRCompileLayer : public IRLayer {
 public:
-  using CompileFunction =
-      std::function<Expected<std::unique_ptr<MemoryBuffer>>(Module &)>;
+  class IRCompiler {
+  public:
+    IRCompiler(IRSymbolMapper::ManglingOptions MO) : MO(std::move(MO)) {}
+    virtual ~IRCompiler();
+    const IRSymbolMapper::ManglingOptions &getManglingOptions() const {
+      return MO;
+    }
+    virtual Expected<std::unique_ptr<MemoryBuffer>> operator()(Module &M) = 0;
 
-  using NotifyCompiledFunction =
-      std::function<void(VModuleKey K, ThreadSafeModule TSM)>;
+  protected:
+    IRSymbolMapper::ManglingOptions &manglingOptions() { return MO; }
+
+  private:
+    IRSymbolMapper::ManglingOptions MO;
+  };
+
+  using NotifyCompiledFunction = std::function<void(
+      MaterializationResponsibility &R, ThreadSafeModule TSM)>;
 
   IRCompileLayer(ExecutionSession &ES, ObjectLayer &BaseLayer,
-                 CompileFunction Compile);
+                 std::unique_ptr<IRCompiler> Compile);
+
+  IRCompiler &getCompiler() { return *Compile; }
 
   void setNotifyCompiled(NotifyCompiledFunction NotifyCompiled);
 
-  void emit(MaterializationResponsibility R, ThreadSafeModule TSM) override;
+  void emit(std::unique_ptr<MaterializationResponsibility> R,
+            ThreadSafeModule TSM) override;
 
 private:
   mutable std::mutex IRLayerMutex;
   ObjectLayer &BaseLayer;
-  CompileFunction Compile;
+  std::unique_ptr<IRCompiler> Compile;
+  const IRSymbolMapper::ManglingOptions *ManglingOpts;
   NotifyCompiledFunction NotifyCompiled = NotifyCompiledFunction();
 };
 
-/// Eager IR compiling layer.
-///
-///   This layer immediately compiles each IR module added via addModule to an
-/// object file and adds this module file to the layer below, which must
-/// implement the object layer concept.
-template <typename BaseLayerT, typename CompileFtor>
-class LegacyIRCompileLayer {
-public:
-  /// Callback type for notifications when modules are compiled.
-  using NotifyCompiledCallback =
-      std::function<void(VModuleKey K, std::unique_ptr<Module>)>;
-
-  /// Construct an LegacyIRCompileLayer with the given BaseLayer, which must
-  ///        implement the ObjectLayer concept.
-  LegacyIRCompileLayer(
-      BaseLayerT &BaseLayer, CompileFtor Compile,
-      NotifyCompiledCallback NotifyCompiled = NotifyCompiledCallback())
-      : BaseLayer(BaseLayer), Compile(std::move(Compile)),
-        NotifyCompiled(std::move(NotifyCompiled)) {}
-
-  /// Get a reference to the compiler functor.
-  CompileFtor& getCompiler() { return Compile; }
-
-  /// (Re)set the NotifyCompiled callback.
-  void setNotifyCompiled(NotifyCompiledCallback NotifyCompiled) {
-    this->NotifyCompiled = std::move(NotifyCompiled);
-  }
-
-  /// Compile the module, and add the resulting object to the base layer
-  ///        along with the given memory manager and symbol resolver.
-  Error addModule(VModuleKey K, std::unique_ptr<Module> M) {
-    if (auto Err = BaseLayer.addObject(std::move(K), Compile(*M)))
-      return Err;
-    if (NotifyCompiled)
-      NotifyCompiled(std::move(K), std::move(M));
-    return Error::success();
-  }
-
-  /// Remove the module associated with the VModuleKey K.
-  Error removeModule(VModuleKey K) { return BaseLayer.removeObject(K); }
-
-  /// Search for the given named symbol.
-  /// @param Name The name of the symbol to search for.
-  /// @param ExportedSymbolsOnly If true, search only for exported symbols.
-  /// @return A handle for the given named symbol, if it exists.
-  JITSymbol findSymbol(const std::string &Name, bool ExportedSymbolsOnly) {
-    return BaseLayer.findSymbol(Name, ExportedSymbolsOnly);
-  }
-
-  /// Get the address of the given symbol in compiled module represented
-  ///        by the handle H. This call is forwarded to the base layer's
-  ///        implementation.
-  /// @param K The VModuleKey for the module to search in.
-  /// @param Name The name of the symbol to search for.
-  /// @param ExportedSymbolsOnly If true, search only for exported symbols.
-  /// @return A handle for the given named symbol, if it is found in the
-  ///         given module.
-  JITSymbol findSymbolIn(VModuleKey K, const std::string &Name,
-                         bool ExportedSymbolsOnly) {
-    return BaseLayer.findSymbolIn(K, Name, ExportedSymbolsOnly);
-  }
-
-  /// Immediately emit and finalize the module represented by the given
-  ///        handle.
-  /// @param K The VModuleKey for the module to emit/finalize.
-  Error emitAndFinalize(VModuleKey K) { return BaseLayer.emitAndFinalize(K); }
-
-private:
-  BaseLayerT &BaseLayer;
-  CompileFtor Compile;
-  NotifyCompiledCallback NotifyCompiled;
-};
-
 } // end namespace orc
-
 } // end namespace llvm
 
 #endif // LLVM_EXECUTIONENGINE_ORC_IRCOMPILINGLAYER_H
diff --git a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/IRTransformLayer.h b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/IRTransformLayer.h
index 8890a57..66966a0 100644
--- a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/IRTransformLayer.h
+++ b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/IRTransformLayer.h
@@ -13,6 +13,7 @@
 #ifndef LLVM_EXECUTIONENGINE_ORC_IRTRANSFORMLAYER_H
 #define LLVM_EXECUTIONENGINE_ORC_IRTRANSFORMLAYER_H
 
+#include "llvm/ADT/FunctionExtras.h"
 #include "llvm/ExecutionEngine/JITSymbol.h"
 #include "llvm/ExecutionEngine/Orc/Layer.h"
 #include <memory>
@@ -22,10 +23,13 @@
 class Module;
 namespace orc {
 
+/// A layer that applies a transform to emitted modules.
+/// The transform function is responsible for locking the ThreadSafeContext
+/// before operating on the module.
 class IRTransformLayer : public IRLayer {
 public:
-  using TransformFunction = std::function<Expected<ThreadSafeModule>(
-      ThreadSafeModule, const MaterializationResponsibility &R)>;
+  using TransformFunction = unique_function<Expected<ThreadSafeModule>(
+      ThreadSafeModule, MaterializationResponsibility &R)>;
 
   IRTransformLayer(ExecutionSession &ES, IRLayer &BaseLayer,
                    TransformFunction Transform = identityTransform);
@@ -34,11 +38,11 @@
     this->Transform = std::move(Transform);
   }
 
-  void emit(MaterializationResponsibility R, ThreadSafeModule TSM) override;
+  void emit(std::unique_ptr<MaterializationResponsibility> R,
+            ThreadSafeModule TSM) override;
 
-  static ThreadSafeModule
-  identityTransform(ThreadSafeModule TSM,
-                    const MaterializationResponsibility &R) {
+  static ThreadSafeModule identityTransform(ThreadSafeModule TSM,
+                                            MaterializationResponsibility &R) {
     return TSM;
   }
 
@@ -47,67 +51,6 @@
   TransformFunction Transform;
 };
 
-/// IR mutating layer.
-///
-///   This layer applies a user supplied transform to each module that is added,
-/// then adds the transformed module to the layer below.
-template <typename BaseLayerT, typename TransformFtor>
-class LegacyIRTransformLayer {
-public:
-
-  /// Construct an LegacyIRTransformLayer with the given BaseLayer
-  LegacyIRTransformLayer(BaseLayerT &BaseLayer,
-                   TransformFtor Transform = TransformFtor())
-    : BaseLayer(BaseLayer), Transform(std::move(Transform)) {}
-
-  /// Apply the transform functor to the module, then add the module to
-  ///        the layer below, along with the memory manager and symbol resolver.
-  ///
-  /// @return A handle for the added modules.
-  Error addModule(VModuleKey K, std::unique_ptr<Module> M) {
-    return BaseLayer.addModule(std::move(K), Transform(std::move(M)));
-  }
-
-  /// Remove the module associated with the VModuleKey K.
-  Error removeModule(VModuleKey K) { return BaseLayer.removeModule(K); }
-
-  /// Search for the given named symbol.
-  /// @param Name The name of the symbol to search for.
-  /// @param ExportedSymbolsOnly If true, search only for exported symbols.
-  /// @return A handle for the given named symbol, if it exists.
-  JITSymbol findSymbol(const std::string &Name, bool ExportedSymbolsOnly) {
-    return BaseLayer.findSymbol(Name, ExportedSymbolsOnly);
-  }
-
-  /// Get the address of the given symbol in the context of the module
-  ///        represented by the VModuleKey K. This call is forwarded to the base
-  ///        layer's implementation.
-  /// @param K The VModuleKey for the module to search in.
-  /// @param Name The name of the symbol to search for.
-  /// @param ExportedSymbolsOnly If true, search only for exported symbols.
-  /// @return A handle for the given named symbol, if it is found in the
-  ///         given module.
-  JITSymbol findSymbolIn(VModuleKey K, const std::string &Name,
-                         bool ExportedSymbolsOnly) {
-    return BaseLayer.findSymbolIn(K, Name, ExportedSymbolsOnly);
-  }
-
-  /// Immediately emit and finalize the module represented by the given
-  ///        VModuleKey.
-  /// @param K The VModuleKey for the module to emit/finalize.
-  Error emitAndFinalize(VModuleKey K) { return BaseLayer.emitAndFinalize(K); }
-
-  /// Access the transform functor directly.
-  TransformFtor& getTransform() { return Transform; }
-
-  /// Access the mumate functor directly.
-  const TransformFtor& getTransform() const { return Transform; }
-
-private:
-  BaseLayerT &BaseLayer;
-  TransformFtor Transform;
-};
-
 } // end namespace orc
 } // end namespace llvm
 
diff --git a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h
index a7ed537..78e3cee 100644
--- a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h
+++ b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h
@@ -15,9 +15,9 @@
 
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
-#include "llvm/ADT/Twine.h"
 #include "llvm/ExecutionEngine/JITSymbol.h"
 #include "llvm/ExecutionEngine/Orc/Core.h"
+#include "llvm/ExecutionEngine/Orc/OrcABISupport.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/Memory.h"
 #include "llvm/Support/Process.h"
@@ -26,6 +26,7 @@
 #include <cassert>
 #include <cstdint>
 #include <functional>
+#include <future>
 #include <map>
 #include <memory>
 #include <system_error>
@@ -42,6 +43,7 @@
 class Module;
 class PointerType;
 class Triple;
+class Twine;
 class Value;
 
 namespace orc {
@@ -53,41 +55,19 @@
 /// are used by various ORC APIs to support lazy compilation
 class TrampolinePool {
 public:
-  virtual ~TrampolinePool() {}
+  using NotifyLandingResolvedFunction =
+      unique_function<void(JITTargetAddress) const>;
+
+  using ResolveLandingFunction = unique_function<void(
+      JITTargetAddress TrampolineAddr,
+      NotifyLandingResolvedFunction OnLandingResolved) const>;
+
+  virtual ~TrampolinePool();
 
   /// Get an available trampoline address.
   /// Returns an error if no trampoline can be created.
-  virtual Expected<JITTargetAddress> getTrampoline() = 0;
-
-private:
-  virtual void anchor();
-};
-
-/// A trampoline pool for trampolines within the current process.
-template <typename ORCABI> class LocalTrampolinePool : public TrampolinePool {
-public:
-  using GetTrampolineLandingFunction =
-      std::function<JITTargetAddress(JITTargetAddress TrampolineAddr)>;
-
-  /// Creates a LocalTrampolinePool with the given RunCallback function.
-  /// Returns an error if this function is unable to correctly allocate, write
-  /// and protect the resolver code block.
-  static Expected<std::unique_ptr<LocalTrampolinePool>>
-  Create(GetTrampolineLandingFunction GetTrampolineLanding) {
-    Error Err = Error::success();
-
-    auto LTP = std::unique_ptr<LocalTrampolinePool>(
-        new LocalTrampolinePool(std::move(GetTrampolineLanding), Err));
-
-    if (Err)
-      return std::move(Err);
-    return std::move(LTP);
-  }
-
-  /// Get a free trampoline. Returns an error if one can not be provide (e.g.
-  /// because the pool is empty and can not be grown).
-  Expected<JITTargetAddress> getTrampoline() override {
-    std::lock_guard<std::mutex> Lock(LTPMutex);
+  Expected<JITTargetAddress> getTrampoline() {
+    std::lock_guard<std::mutex> Lock(TPMutex);
     if (AvailableTrampolines.empty()) {
       if (auto Err = grow())
         return std::move(Err);
@@ -100,21 +80,52 @@
 
   /// Returns the given trampoline to the pool for re-use.
   void releaseTrampoline(JITTargetAddress TrampolineAddr) {
-    std::lock_guard<std::mutex> Lock(LTPMutex);
+    std::lock_guard<std::mutex> Lock(TPMutex);
     AvailableTrampolines.push_back(TrampolineAddr);
   }
 
+protected:
+  virtual Error grow() = 0;
+
+  std::mutex TPMutex;
+  std::vector<JITTargetAddress> AvailableTrampolines;
+};
+
+/// A trampoline pool for trampolines within the current process.
+template <typename ORCABI> class LocalTrampolinePool : public TrampolinePool {
+public:
+  /// Creates a LocalTrampolinePool with the given RunCallback function.
+  /// Returns an error if this function is unable to correctly allocate, write
+  /// and protect the resolver code block.
+  static Expected<std::unique_ptr<LocalTrampolinePool>>
+  Create(ResolveLandingFunction ResolveLanding) {
+    Error Err = Error::success();
+
+    auto LTP = std::unique_ptr<LocalTrampolinePool>(
+        new LocalTrampolinePool(std::move(ResolveLanding), Err));
+
+    if (Err)
+      return std::move(Err);
+    return std::move(LTP);
+  }
+
 private:
   static JITTargetAddress reenter(void *TrampolinePoolPtr, void *TrampolineId) {
     LocalTrampolinePool<ORCABI> *TrampolinePool =
         static_cast<LocalTrampolinePool *>(TrampolinePoolPtr);
-    return TrampolinePool->GetTrampolineLanding(static_cast<JITTargetAddress>(
-        reinterpret_cast<uintptr_t>(TrampolineId)));
+
+    std::promise<JITTargetAddress> LandingAddressP;
+    auto LandingAddressF = LandingAddressP.get_future();
+
+    TrampolinePool->ResolveLanding(pointerToJITTargetAddress(TrampolineId),
+                                   [&](JITTargetAddress LandingAddress) {
+                                     LandingAddressP.set_value(LandingAddress);
+                                   });
+    return LandingAddressF.get();
   }
 
-  LocalTrampolinePool(GetTrampolineLandingFunction GetTrampolineLanding,
-                      Error &Err)
-      : GetTrampolineLanding(std::move(GetTrampolineLanding)) {
+  LocalTrampolinePool(ResolveLandingFunction ResolveLanding, Error &Err)
+      : ResolveLanding(std::move(ResolveLanding)) {
 
     ErrorAsOutParameter _(&Err);
 
@@ -128,8 +139,10 @@
       return;
     }
 
-    ORCABI::writeResolverCode(static_cast<uint8_t *>(ResolverBlock.base()),
-                              &reenter, this);
+    ORCABI::writeResolverCode(static_cast<char *>(ResolverBlock.base()),
+                              pointerToJITTargetAddress(ResolverBlock.base()),
+                              pointerToJITTargetAddress(&reenter),
+                              pointerToJITTargetAddress(this));
 
     EC = sys::Memory::protectMappedMemory(ResolverBlock.getMemoryBlock(),
                                           sys::Memory::MF_READ |
@@ -140,8 +153,8 @@
     }
   }
 
-  Error grow() {
-    assert(this->AvailableTrampolines.empty() && "Growing prematurely?");
+  Error grow() override {
+    assert(AvailableTrampolines.empty() && "Growing prematurely?");
 
     std::error_code EC;
     auto TrampolineBlock =
@@ -155,14 +168,14 @@
         (sys::Process::getPageSizeEstimate() - ORCABI::PointerSize) /
         ORCABI::TrampolineSize;
 
-    uint8_t *TrampolineMem = static_cast<uint8_t *>(TrampolineBlock.base());
-    ORCABI::writeTrampolines(TrampolineMem, ResolverBlock.base(),
-                             NumTrampolines);
+    char *TrampolineMem = static_cast<char *>(TrampolineBlock.base());
+    ORCABI::writeTrampolines(
+        TrampolineMem, pointerToJITTargetAddress(TrampolineMem),
+        pointerToJITTargetAddress(ResolverBlock.base()), NumTrampolines);
 
     for (unsigned I = 0; I < NumTrampolines; ++I)
-      this->AvailableTrampolines.push_back(
-          static_cast<JITTargetAddress>(reinterpret_cast<uintptr_t>(
-              TrampolineMem + (I * ORCABI::TrampolineSize))));
+      AvailableTrampolines.push_back(pointerToJITTargetAddress(
+          TrampolineMem + (I * ORCABI::TrampolineSize)));
 
     if (auto EC = sys::Memory::protectMappedMemory(
                     TrampolineBlock.getMemoryBlock(),
@@ -173,12 +186,10 @@
     return Error::success();
   }
 
-  GetTrampolineLandingFunction GetTrampolineLanding;
+  ResolveLandingFunction ResolveLanding;
 
-  std::mutex LTPMutex;
   sys::OwningMemoryBlock ResolverBlock;
   std::vector<sys::OwningMemoryBlock> TrampolineBlocks;
-  std::vector<JITTargetAddress> AvailableTrampolines;
 };
 
 /// Target-independent base class for compile callback management.
@@ -201,7 +212,7 @@
                             ExecutionSession &ES,
                             JITTargetAddress ErrorHandlerAddress)
       : TP(std::move(TP)), ES(ES),
-        CallbacksJD(ES.createJITDylib("<Callbacks>")),
+        CallbacksJD(ES.createBareJITDylib("<Callbacks>")),
         ErrorHandlerAddress(ErrorHandlerAddress) {}
 
   void setTrampolinePool(std::unique_ptr<TrampolinePool> TP) {
@@ -241,10 +252,14 @@
                                  JITTargetAddress ErrorHandlerAddress,
                                  Error &Err)
       : JITCompileCallbackManager(nullptr, ES, ErrorHandlerAddress) {
+    using NotifyLandingResolvedFunction =
+        TrampolinePool::NotifyLandingResolvedFunction;
+
     ErrorAsOutParameter _(&Err);
     auto TP = LocalTrampolinePool<ORCABI>::Create(
-        [this](JITTargetAddress TrampolineAddr) {
-          return executeCompileCallback(TrampolineAddr);
+        [this](JITTargetAddress TrampolineAddr,
+               NotifyLandingResolvedFunction NotifyLandingResolved) {
+          NotifyLandingResolved(executeCompileCallback(TrampolineAddr));
         });
 
     if (!TP) {
@@ -287,6 +302,61 @@
   virtual void anchor();
 };
 
+template <typename ORCABI> class LocalIndirectStubsInfo {
+public:
+  LocalIndirectStubsInfo(unsigned NumStubs, sys::OwningMemoryBlock StubsMem)
+      : NumStubs(NumStubs), StubsMem(std::move(StubsMem)) {}
+
+  static Expected<LocalIndirectStubsInfo> create(unsigned MinStubs,
+                                                 unsigned PageSize) {
+    auto ISAS = getIndirectStubsBlockSizes<ORCABI>(MinStubs, PageSize);
+
+    assert((ISAS.StubBytes % PageSize == 0) &&
+           "StubBytes is not a page size multiple");
+    uint64_t PointerAlloc = alignTo(ISAS.PointerBytes, PageSize);
+
+    // Allocate memory for stubs and pointers in one call.
+    std::error_code EC;
+    auto StubsAndPtrsMem =
+        sys::OwningMemoryBlock(sys::Memory::allocateMappedMemory(
+            ISAS.StubBytes + PointerAlloc, nullptr,
+            sys::Memory::MF_READ | sys::Memory::MF_WRITE, EC));
+    if (EC)
+      return errorCodeToError(EC);
+
+    sys::MemoryBlock StubsBlock(StubsAndPtrsMem.base(), ISAS.StubBytes);
+    auto StubsBlockMem = static_cast<char *>(StubsAndPtrsMem.base());
+    auto PtrBlockAddress =
+        pointerToJITTargetAddress(StubsBlockMem) + ISAS.StubBytes;
+
+    ORCABI::writeIndirectStubsBlock(StubsBlockMem,
+                                    pointerToJITTargetAddress(StubsBlockMem),
+                                    PtrBlockAddress, ISAS.NumStubs);
+
+    if (auto EC = sys::Memory::protectMappedMemory(
+            StubsBlock, sys::Memory::MF_READ | sys::Memory::MF_EXEC))
+      return errorCodeToError(EC);
+
+    return LocalIndirectStubsInfo(ISAS.NumStubs, std::move(StubsAndPtrsMem));
+  }
+
+  unsigned getNumStubs() const { return NumStubs; }
+
+  void *getStub(unsigned Idx) const {
+    return static_cast<char *>(StubsMem.base()) + Idx * ORCABI::StubSize;
+  }
+
+  void **getPtr(unsigned Idx) const {
+    char *PtrsBase =
+        static_cast<char *>(StubsMem.base()) + NumStubs * ORCABI::StubSize;
+    return reinterpret_cast<void **>(PtrsBase) + Idx;
+  }
+
+private:
+  unsigned NumStubs = 0;
+  sys::OwningMemoryBlock StubsMem;
+};
+
 /// IndirectStubsManager implementation for the host architecture, e.g.
 ///        OrcX86_64. (See OrcArchitectureSupport.h).
 template <typename TargetT>
@@ -364,13 +434,13 @@
 
     unsigned NewStubsRequired = NumStubs - FreeStubs.size();
     unsigned NewBlockId = IndirectStubsInfos.size();
-    typename TargetT::IndirectStubsInfo ISI;
-    if (auto Err =
-            TargetT::emitIndirectStubsBlock(ISI, NewStubsRequired, nullptr))
-      return Err;
-    for (unsigned I = 0; I < ISI.getNumStubs(); ++I)
+    auto ISI =
+        LocalIndirectStubsInfo<TargetT>::create(NewStubsRequired, PageSize);
+    if (!ISI)
+      return ISI.takeError();
+    for (unsigned I = 0; I < ISI->getNumStubs(); ++I)
       FreeStubs.push_back(std::make_pair(NewBlockId, I));
-    IndirectStubsInfos.push_back(std::move(ISI));
+    IndirectStubsInfos.push_back(std::move(*ISI));
     return Error::success();
   }
 
@@ -379,12 +449,13 @@
     auto Key = FreeStubs.back();
     FreeStubs.pop_back();
     *IndirectStubsInfos[Key.first].getPtr(Key.second) =
-        reinterpret_cast<void *>(static_cast<uintptr_t>(InitAddr));
+        jitTargetAddressToPointer<void *>(InitAddr);
     StubIndexes[StubName] = std::make_pair(Key, StubFlags);
   }
 
+  unsigned PageSize = sys::Process::getPageSizeEstimate();
   std::mutex StubsMutex;
-  std::vector<typename TargetT::IndirectStubsInfo> IndirectStubsInfos;
+  std::vector<LocalIndirectStubsInfo<TargetT>> IndirectStubsInfos;
   using StubKey = std::pair<uint16_t, uint16_t>;
   std::vector<StubKey> FreeStubs;
   StringMap<std::pair<StubKey, JITSymbolFlags>> StubIndexes;
diff --git a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/JITTargetMachineBuilder.h b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/JITTargetMachineBuilder.h
index bcbd72e..c4109a8 100644
--- a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/JITTargetMachineBuilder.h
+++ b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/JITTargetMachineBuilder.h
@@ -25,6 +25,9 @@
 #include <vector>
 
 namespace llvm {
+
+class raw_ostream;
+
 namespace orc {
 
 /// A utility class for building TargetMachines for JITs.
@@ -79,18 +82,30 @@
     return *this;
   }
 
+  /// Get the relocation model.
+  const Optional<Reloc::Model> &getRelocationModel() const { return RM; }
+
   /// Set the code model.
   JITTargetMachineBuilder &setCodeModel(Optional<CodeModel::Model> CM) {
     this->CM = std::move(CM);
     return *this;
   }
 
+  /// Get the code model.
+  const Optional<CodeModel::Model> &getCodeModel() const { return CM; }
+
   /// Set the LLVM CodeGen optimization level.
   JITTargetMachineBuilder &setCodeGenOptLevel(CodeGenOpt::Level OptLevel) {
     this->OptLevel = OptLevel;
     return *this;
   }
 
+  /// Set subtarget features.
+  JITTargetMachineBuilder &setFeatures(StringRef FeatureString) {
+    Features = SubtargetFeatures(FeatureString);
+    return *this;
+  }
+
   /// Add subtarget features.
   JITTargetMachineBuilder &
   addFeatures(const std::vector<std::string> &FeatureVec);
@@ -101,6 +116,17 @@
   /// Access subtarget features.
   const SubtargetFeatures &getFeatures() const { return Features; }
 
+  /// Set TargetOptions.
+  ///
+  /// Note: This operation will overwrite any previously configured options,
+  /// including EmulatedTLS and ExplicitEmulatedTLS which
+  /// the JITTargetMachineBuilder sets by default. Clients are responsible
+  /// for re-enabling these overwritten options.
+  JITTargetMachineBuilder &setOptions(TargetOptions Options) {
+    this->Options = std::move(Options);
+    return *this;
+  }
+
   /// Access TargetOptions.
   TargetOptions &getOptions() { return Options; }
 
@@ -113,6 +139,12 @@
   /// Access Triple.
   const Triple &getTargetTriple() const { return TT; }
 
+#ifndef NDEBUG
+  /// Debug-dump a JITTargetMachineBuilder.
+  friend raw_ostream &operator<<(raw_ostream &OS,
+                                 const JITTargetMachineBuilder &JTMB);
+#endif
+
 private:
   Triple TT;
   std::string CPU;
@@ -120,7 +152,7 @@
   TargetOptions Options;
   Optional<Reloc::Model> RM;
   Optional<CodeModel::Model> CM;
-  CodeGenOpt::Level OptLevel = CodeGenOpt::None;
+  CodeGenOpt::Level OptLevel = CodeGenOpt::Default;
 };
 
 } // end namespace orc
diff --git a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/LLJIT.h b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/LLJIT.h
index b54c7d8..ff0aa02 100644
--- a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/LLJIT.h
+++ b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/LLJIT.h
@@ -19,8 +19,8 @@
 #include "llvm/ExecutionEngine/Orc/IRCompileLayer.h"
 #include "llvm/ExecutionEngine/Orc/IRTransformLayer.h"
 #include "llvm/ExecutionEngine/Orc/JITTargetMachineBuilder.h"
-#include "llvm/ExecutionEngine/Orc/ObjectTransformLayer.h"
 #include "llvm/ExecutionEngine/Orc/ThreadSafeModule.h"
+#include "llvm/Support/Debug.h"
 #include "llvm/Support/ThreadPool.h"
 
 namespace llvm {
@@ -28,6 +28,8 @@
 
 class LLJITBuilderState;
 class LLLazyJITBuilderState;
+class ObjectTransformLayer;
+class TargetProcessControl;
 
 /// A pre-fabricated ORC JIT stack that can serve as an alternative to MCJIT.
 ///
@@ -35,8 +37,22 @@
 class LLJIT {
   template <typename, typename, typename> friend class LLJITBuilderSetters;
 
+  friend void setUpGenericLLVMIRPlatform(LLJIT &J);
+
 public:
-  static Expected<std::unique_ptr<LLJIT>> Create(LLJITBuilderState &S);
+  /// Initializer support for LLJIT.
+  class PlatformSupport {
+  public:
+    virtual ~PlatformSupport();
+
+    virtual Error initialize(JITDylib &JD) = 0;
+
+    virtual Error deinitialize(JITDylib &JD) = 0;
+
+  protected:
+    static void setInitTransform(LLJIT &J,
+                                 IRTransformLayer::TransformFunction T);
+  };
 
   /// Destruct this instance. If a multi-threaded instance, waits for all
   /// compile threads to complete.
@@ -45,11 +61,14 @@
   /// Returns the ExecutionSession for this instance.
   ExecutionSession &getExecutionSession() { return *ES; }
 
+  /// Returns a reference to the triple for this instance.
+  const Triple &getTargetTriple() const { return TT; }
+
   /// Returns a reference to the DataLayout for this instance.
   const DataLayout &getDataLayout() const { return DL; }
 
   /// Returns a reference to the JITDylib representing the JIT'd main program.
-  JITDylib &getMainJITDylib() { return Main; }
+  JITDylib &getMainJITDylib() { return *Main; }
 
   /// Returns the JITDylib with the given name, or nullptr if no JITDylib with
   /// that name exists.
@@ -63,39 +82,49 @@
   /// input or elsewhere in the environment then the client should check
   /// (e.g. by calling getJITDylibByName) that the given name is not already in
   /// use.
-  JITDylib &createJITDylib(std::string Name) {
+  Expected<JITDylib &> createJITDylib(std::string Name) {
     return ES->createJITDylib(std::move(Name));
   }
 
-  /// Convenience method for defining an absolute symbol.
-  Error defineAbsolute(StringRef Name, JITEvaluatedSymbol Address);
+  /// Adds an IR module with the given ResourceTracker.
+  Error addIRModule(ResourceTrackerSP RT, ThreadSafeModule TSM);
 
   /// Adds an IR module to the given JITDylib.
   Error addIRModule(JITDylib &JD, ThreadSafeModule TSM);
 
   /// Adds an IR module to the Main JITDylib.
   Error addIRModule(ThreadSafeModule TSM) {
-    return addIRModule(Main, std::move(TSM));
+    return addIRModule(*Main, std::move(TSM));
   }
 
   /// Adds an object file to the given JITDylib.
+  Error addObjectFile(ResourceTrackerSP RT, std::unique_ptr<MemoryBuffer> Obj);
+
+  /// Adds an object file to the given JITDylib.
   Error addObjectFile(JITDylib &JD, std::unique_ptr<MemoryBuffer> Obj);
 
   /// Adds an object file to the given JITDylib.
   Error addObjectFile(std::unique_ptr<MemoryBuffer> Obj) {
-    return addObjectFile(Main, std::move(Obj));
+    return addObjectFile(*Main, std::move(Obj));
   }
 
   /// Look up a symbol in JITDylib JD by the symbol's linker-mangled name (to
   /// look up symbols based on their IR name use the lookup function instead).
   Expected<JITEvaluatedSymbol> lookupLinkerMangled(JITDylib &JD,
-                                                   StringRef Name);
+                                                   SymbolStringPtr Name);
+
+  /// Look up a symbol in JITDylib JD by the symbol's linker-mangled name (to
+  /// look up symbols based on their IR name use the lookup function instead).
+  Expected<JITEvaluatedSymbol> lookupLinkerMangled(JITDylib &JD,
+                                                   StringRef Name) {
+    return lookupLinkerMangled(JD, ES->intern(Name));
+  }
 
   /// Look up a symbol in the main JITDylib by the symbol's linker-mangled name
   /// (to look up symbols based on their IR name use the lookup function
   /// instead).
   Expected<JITEvaluatedSymbol> lookupLinkerMangled(StringRef Name) {
-    return lookupLinkerMangled(Main, Name);
+    return lookupLinkerMangled(*Main, Name);
   }
 
   /// Look up a symbol in JITDylib JD based on its IR symbol name.
@@ -105,41 +134,85 @@
 
   /// Look up a symbol in the main JITDylib based on its IR symbol name.
   Expected<JITEvaluatedSymbol> lookup(StringRef UnmangledName) {
-    return lookup(Main, UnmangledName);
+    return lookup(*Main, UnmangledName);
   }
 
-  /// Runs all not-yet-run static constructors.
-  Error runConstructors() { return CtorRunner.run(); }
+  /// Set the PlatformSupport instance.
+  void setPlatformSupport(std::unique_ptr<PlatformSupport> PS) {
+    this->PS = std::move(PS);
+  }
 
-  /// Runs all not-yet-run static destructors.
-  Error runDestructors() { return DtorRunner.run(); }
+  /// Get the PlatformSupport instance.
+  PlatformSupport *getPlatformSupport() { return PS.get(); }
+
+  /// Run the initializers for the given JITDylib.
+  Error initialize(JITDylib &JD) {
+    DEBUG_WITH_TYPE("orc", {
+      dbgs() << "LLJIT running initializers for JITDylib \"" << JD.getName()
+             << "\"\n";
+    });
+    assert(PS && "PlatformSupport must be set to run initializers.");
+    return PS->initialize(JD);
+  }
+
+  /// Run the deinitializers for the given JITDylib.
+  Error deinitialize(JITDylib &JD) {
+    DEBUG_WITH_TYPE("orc", {
+      dbgs() << "LLJIT running deinitializers for JITDylib \"" << JD.getName()
+             << "\"\n";
+    });
+    assert(PS && "PlatformSupport must be set to run initializers.");
+    return PS->deinitialize(JD);
+  }
 
   /// Returns a reference to the ObjLinkingLayer
   ObjectLayer &getObjLinkingLayer() { return *ObjLinkingLayer; }
 
+  /// Returns a reference to the object transform layer.
+  ObjectTransformLayer &getObjTransformLayer() { return *ObjTransformLayer; }
+
+  /// Returns a reference to the IR transform layer.
+  IRTransformLayer &getIRTransformLayer() { return *TransformLayer; }
+
+  /// Returns a reference to the IR compile layer.
+  IRCompileLayer &getIRCompileLayer() { return *CompileLayer; }
+
+  /// Returns a linker-mangled version of UnmangledName.
+  std::string mangle(StringRef UnmangledName) const;
+
+  /// Returns an interned, linker-mangled version of UnmangledName.
+  SymbolStringPtr mangleAndIntern(StringRef UnmangledName) const {
+    return ES->intern(mangle(UnmangledName));
+  }
+
 protected:
-  static std::unique_ptr<ObjectLayer>
+  static Expected<std::unique_ptr<ObjectLayer>>
   createObjectLinkingLayer(LLJITBuilderState &S, ExecutionSession &ES);
 
+  static Expected<std::unique_ptr<IRCompileLayer::IRCompiler>>
+  createCompileFunction(LLJITBuilderState &S, JITTargetMachineBuilder JTMB);
+
   /// Create an LLJIT instance with a single compile thread.
   LLJIT(LLJITBuilderState &S, Error &Err);
 
-  std::string mangle(StringRef UnmangledName);
-
   Error applyDataLayout(Module &M);
 
   void recordCtorDtors(Module &M);
 
   std::unique_ptr<ExecutionSession> ES;
-  JITDylib &Main;
+  std::unique_ptr<PlatformSupport> PS;
+
+  JITDylib *Main = nullptr;
 
   DataLayout DL;
+  Triple TT;
   std::unique_ptr<ThreadPool> CompileThreads;
 
   std::unique_ptr<ObjectLayer> ObjLinkingLayer;
+  std::unique_ptr<ObjectTransformLayer> ObjTransformLayer;
   std::unique_ptr<IRCompileLayer> CompileLayer;
-
-  CtorDtorRunner CtorRunner, DtorRunner;
+  std::unique_ptr<IRTransformLayer> TransformLayer;
+  std::unique_ptr<IRTransformLayer> InitHelperTransformLayer;
 };
 
 /// An extended version of LLJIT that supports lazy function-at-a-time
@@ -149,24 +222,21 @@
 
 public:
 
-  /// Set an IR transform (e.g. pass manager pipeline) to run on each function
-  /// when it is compiled.
-  void setLazyCompileTransform(IRTransformLayer::TransformFunction Transform) {
-    TransformLayer->setTransform(std::move(Transform));
-  }
-
   /// Sets the partition function.
   void
   setPartitionFunction(CompileOnDemandLayer::PartitionFunction Partition) {
     CODLayer->setPartitionFunction(std::move(Partition));
   }
 
+  /// Returns a reference to the on-demand layer.
+  CompileOnDemandLayer &getCompileOnDemandLayer() { return *CODLayer; }
+
   /// Add a module to be lazily compiled to JITDylib JD.
   Error addLazyIRModule(JITDylib &JD, ThreadSafeModule M);
 
   /// Add a module to be lazily compiled to the main JITDylib.
   Error addLazyIRModule(ThreadSafeModule M) {
-    return addLazyIRModule(Main, std::move(M));
+    return addLazyIRModule(*Main, std::move(M));
   }
 
 private:
@@ -175,19 +245,29 @@
   LLLazyJIT(LLLazyJITBuilderState &S, Error &Err);
 
   std::unique_ptr<LazyCallThroughManager> LCTMgr;
-  std::unique_ptr<IRTransformLayer> TransformLayer;
   std::unique_ptr<CompileOnDemandLayer> CODLayer;
 };
 
 class LLJITBuilderState {
 public:
-  using CreateObjectLinkingLayerFunction =
-      std::function<std::unique_ptr<ObjectLayer>(ExecutionSession &)>;
+  using ObjectLinkingLayerCreator =
+      std::function<Expected<std::unique_ptr<ObjectLayer>>(ExecutionSession &,
+                                                           const Triple &)>;
+
+  using CompileFunctionCreator =
+      std::function<Expected<std::unique_ptr<IRCompileLayer::IRCompiler>>(
+          JITTargetMachineBuilder JTMB)>;
+
+  using PlatformSetupFunction = std::function<Error(LLJIT &J)>;
 
   std::unique_ptr<ExecutionSession> ES;
   Optional<JITTargetMachineBuilder> JTMB;
-  CreateObjectLinkingLayerFunction CreateObjectLinkingLayer;
+  Optional<DataLayout> DL;
+  ObjectLinkingLayerCreator CreateObjectLinkingLayer;
+  CompileFunctionCreator CreateCompileFunction;
+  PlatformSetupFunction SetUpPlatform;
   unsigned NumCompileThreads = 0;
+  TargetProcessControl *TPC = nullptr;
 
   /// Called prior to JIT class construcion to fix up defaults.
   Error prepareForConstruction();
@@ -196,6 +276,13 @@
 template <typename JITType, typename SetterImpl, typename State>
 class LLJITBuilderSetters {
 public:
+
+  /// Set an ExecutionSession for this instance.
+  SetterImpl &setExecutionSession(std::unique_ptr<ExecutionSession> ES) {
+    impl().ES = std::move(ES);
+    return impl();
+  }
+
   /// Set the JITTargetMachineBuilder for this instance.
   ///
   /// If this method is not called, JITTargetMachineBuilder::detectHost will be
@@ -211,17 +298,45 @@
     return impl().JTMB;
   }
 
+  /// Set a DataLayout for this instance. If no data layout is specified then
+  /// the target's default data layout will be used.
+  SetterImpl &setDataLayout(Optional<DataLayout> DL) {
+    impl().DL = std::move(DL);
+    return impl();
+  }
+
   /// Set an ObjectLinkingLayer creation function.
   ///
   /// If this method is not called, a default creation function will be used
   /// that will construct an RTDyldObjectLinkingLayer.
-  SetterImpl &setCreateObjectLinkingLayer(
-      LLJITBuilderState::CreateObjectLinkingLayerFunction
-          CreateObjectLinkingLayer) {
+  SetterImpl &setObjectLinkingLayerCreator(
+      LLJITBuilderState::ObjectLinkingLayerCreator CreateObjectLinkingLayer) {
     impl().CreateObjectLinkingLayer = std::move(CreateObjectLinkingLayer);
     return impl();
   }
 
+  /// Set a CompileFunctionCreator.
+  ///
+  /// If this method is not called, a default creation function wil be used
+  /// that will construct a basic IR compile function that is compatible with
+  /// the selected number of threads (SimpleCompiler for '0' compile threads,
+  /// ConcurrentIRCompiler otherwise).
+  SetterImpl &setCompileFunctionCreator(
+      LLJITBuilderState::CompileFunctionCreator CreateCompileFunction) {
+    impl().CreateCompileFunction = std::move(CreateCompileFunction);
+    return impl();
+  }
+
+  /// Set up an PlatformSetupFunction.
+  ///
+  /// If this method is not called then setUpGenericLLVMIRPlatform
+  /// will be used to configure the JIT's platform support.
+  SetterImpl &
+  setPlatformSetUp(LLJITBuilderState::PlatformSetupFunction SetUpPlatform) {
+    impl().SetUpPlatform = std::move(SetUpPlatform);
+    return impl();
+  }
+
   /// Set the number of compile threads to use.
   ///
   /// If set to zero, compilation will be performed on the execution thread when
@@ -235,6 +350,17 @@
     return impl();
   }
 
+  /// Set a TargetProcessControl object.
+  ///
+  /// If the platform uses ObjectLinkingLayer by default and no
+  /// ObjectLinkingLayerCreator has been set then the TargetProcessControl
+  /// object will be used to supply the memory manager for the
+  /// ObjectLinkingLayer.
+  SetterImpl &setTargetProcessControl(TargetProcessControl &TPC) {
+    impl().TPC = &TPC;
+    return impl();
+  }
+
   /// Create an instance of the JIT.
   Expected<std::unique_ptr<JITType>> create() {
     if (auto Err = impl().prepareForConstruction())
@@ -310,6 +436,26 @@
       public LLLazyJITBuilderSetters<LLLazyJIT, LLLazyJITBuilder,
                                      LLLazyJITBuilderState> {};
 
+/// Configure the LLJIT instance to scrape modules for llvm.global_ctors and
+/// llvm.global_dtors variables and (if present) build initialization and
+/// deinitialization functions. Platform specific initialization configurations
+/// should be preferred where available.
+void setUpGenericLLVMIRPlatform(LLJIT &J);
+
+/// Configure the LLJIT instance to use MachOPlatform support.
+///
+/// Warning: MachOPlatform *requires* that LLJIT be configured to use
+/// ObjectLinkingLayer (default on platforms supported by JITLink). If
+/// MachOPlatform is used with RTDyldObjectLinkingLayer it will result in
+/// undefined behavior).
+///
+/// MachOPlatform installs an ObjectLinkingLayer plugin to scrape initializers
+/// from the __mod_inits section. It also provides interposes for the dlfcn
+/// functions (dlopen, dlclose, dlsym, dlerror) that work for JITDylibs as
+/// well as regular libraries (JITDylibs will be preferenced, so make sure
+/// your JITDylib names do not shadow any real library paths).
+Error setUpMachOPlatform(LLJIT &J);
+
 } // End namespace orc
 } // End namespace llvm
 
diff --git a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/LambdaResolver.h b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/LambdaResolver.h
deleted file mode 100644
index 92efded..0000000
--- a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/LambdaResolver.h
+++ /dev/null
@@ -1,58 +0,0 @@
-//===- LambdaResolverMM - Redirect symbol lookup via a functor --*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-//   Defines a RuntimeDyld::SymbolResolver subclass that uses a user-supplied
-// functor for symbol resolution.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_EXECUTIONENGINE_ORC_LAMBDARESOLVER_H
-#define LLVM_EXECUTIONENGINE_ORC_LAMBDARESOLVER_H
-
-#include "llvm/ADT/STLExtras.h"
-#include "llvm/ExecutionEngine/JITSymbol.h"
-#include <memory>
-
-namespace llvm {
-namespace orc {
-
-template <typename DylibLookupFtorT, typename ExternalLookupFtorT>
-class LambdaResolver : public LegacyJITSymbolResolver {
-public:
-  LambdaResolver(DylibLookupFtorT DylibLookupFtor,
-                 ExternalLookupFtorT ExternalLookupFtor)
-      : DylibLookupFtor(DylibLookupFtor),
-        ExternalLookupFtor(ExternalLookupFtor) {}
-
-  JITSymbol findSymbolInLogicalDylib(const std::string &Name) final {
-    return DylibLookupFtor(Name);
-  }
-
-  JITSymbol findSymbol(const std::string &Name) final {
-    return ExternalLookupFtor(Name);
-  }
-
-private:
-  DylibLookupFtorT DylibLookupFtor;
-  ExternalLookupFtorT ExternalLookupFtor;
-};
-
-template <typename DylibLookupFtorT,
-          typename ExternalLookupFtorT>
-std::shared_ptr<LambdaResolver<DylibLookupFtorT, ExternalLookupFtorT>>
-createLambdaResolver(DylibLookupFtorT DylibLookupFtor,
-                     ExternalLookupFtorT ExternalLookupFtor) {
-  using LR = LambdaResolver<DylibLookupFtorT, ExternalLookupFtorT>;
-  return make_unique<LR>(std::move(DylibLookupFtor),
-                         std::move(ExternalLookupFtor));
-}
-
-} // end namespace orc
-} // end namespace llvm
-
-#endif // LLVM_EXECUTIONENGINE_ORC_LAMBDARESOLVER_H
diff --git a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/Layer.h b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/Layer.h
index 8f9bd70..f9cc155 100644
--- a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/Layer.h
+++ b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/Layer.h
@@ -14,6 +14,7 @@
 #define LLVM_EXECUTIONENGINE_ORC_LAYER_H
 
 #include "llvm/ExecutionEngine/Orc/Core.h"
+#include "llvm/ExecutionEngine/Orc/Mangling.h"
 #include "llvm/ExecutionEngine/Orc/ThreadSafeModule.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Support/MemoryBuffer.h"
@@ -21,15 +22,62 @@
 namespace llvm {
 namespace orc {
 
+/// IRMaterializationUnit is a convenient base class for MaterializationUnits
+/// wrapping LLVM IR. Represents materialization responsibility for all symbols
+/// in the given module. If symbols are overridden by other definitions, then
+/// their linkage is changed to available-externally.
+class IRMaterializationUnit : public MaterializationUnit {
+public:
+  using SymbolNameToDefinitionMap = std::map<SymbolStringPtr, GlobalValue *>;
+
+  /// Create an IRMaterializationLayer. Scans the module to build the
+  /// SymbolFlags and SymbolToDefinition maps.
+  IRMaterializationUnit(ExecutionSession &ES,
+                        const IRSymbolMapper::ManglingOptions &MO,
+                        ThreadSafeModule TSM);
+
+  /// Create an IRMaterializationLayer from a module, and pre-existing
+  /// SymbolFlags and SymbolToDefinition maps. The maps must provide
+  /// entries for each definition in M.
+  /// This constructor is useful for delegating work from one
+  /// IRMaterializationUnit to another.
+  IRMaterializationUnit(ThreadSafeModule TSM, SymbolFlagsMap SymbolFlags,
+                        SymbolStringPtr InitSymbol,
+                        SymbolNameToDefinitionMap SymbolToDefinition);
+
+  /// Return the ModuleIdentifier as the name for this MaterializationUnit.
+  StringRef getName() const override;
+
+  /// Return a reference to the contained ThreadSafeModule.
+  const ThreadSafeModule &getModule() const { return TSM; }
+
+protected:
+  ThreadSafeModule TSM;
+  SymbolNameToDefinitionMap SymbolToDefinition;
+
+private:
+  static SymbolStringPtr getInitSymbol(ExecutionSession &ES,
+                                       const ThreadSafeModule &TSM);
+
+  void discard(const JITDylib &JD, const SymbolStringPtr &Name) override;
+};
+
 /// Interface for layers that accept LLVM IR.
 class IRLayer {
 public:
-  IRLayer(ExecutionSession &ES);
+  IRLayer(ExecutionSession &ES, const IRSymbolMapper::ManglingOptions *&MO)
+      : ES(ES), MO(MO) {}
+
   virtual ~IRLayer();
 
   /// Returns the ExecutionSession for this layer.
   ExecutionSession &getExecutionSession() { return ES; }
 
+  /// Get the mangling options for this layer.
+  const IRSymbolMapper::ManglingOptions *&getManglingOptions() const {
+    return MO;
+  }
+
   /// Sets the CloneToNewContextOnEmit flag (false by default).
   ///
   /// When set, IR modules added to this layer will be cloned on to a new
@@ -46,67 +94,38 @@
   /// Returns the current value of the CloneToNewContextOnEmit flag.
   bool getCloneToNewContextOnEmit() const { return CloneToNewContextOnEmit; }
 
+  /// Add a MaterializatinoUnit representing the given IR to the JITDylib
+  /// targeted by the given tracker.
+  virtual Error add(ResourceTrackerSP RT, ThreadSafeModule TSM);
+
   /// Adds a MaterializationUnit representing the given IR to the given
-  /// JITDylib.
-  virtual Error add(JITDylib &JD, ThreadSafeModule TSM,
-                    VModuleKey K = VModuleKey());
+  /// JITDylib. If RT is not specif
+  Error add(JITDylib &JD, ThreadSafeModule TSM) {
+    return add(JD.getDefaultResourceTracker(), std::move(TSM));
+  }
 
   /// Emit should materialize the given IR.
-  virtual void emit(MaterializationResponsibility R, ThreadSafeModule TSM) = 0;
+  virtual void emit(std::unique_ptr<MaterializationResponsibility> R,
+                    ThreadSafeModule TSM) = 0;
 
 private:
   bool CloneToNewContextOnEmit = false;
   ExecutionSession &ES;
-};
-
-/// IRMaterializationUnit is a convenient base class for MaterializationUnits
-/// wrapping LLVM IR. Represents materialization responsibility for all symbols
-/// in the given module. If symbols are overridden by other definitions, then
-/// their linkage is changed to available-externally.
-class IRMaterializationUnit : public MaterializationUnit {
-public:
-  using SymbolNameToDefinitionMap = std::map<SymbolStringPtr, GlobalValue *>;
-
-  /// Create an IRMaterializationLayer. Scans the module to build the
-  /// SymbolFlags and SymbolToDefinition maps.
-  IRMaterializationUnit(ExecutionSession &ES, ThreadSafeModule TSM,
-                        VModuleKey K);
-
-  /// Create an IRMaterializationLayer from a module, and pre-existing
-  /// SymbolFlags and SymbolToDefinition maps. The maps must provide
-  /// entries for each definition in M.
-  /// This constructor is useful for delegating work from one
-  /// IRMaterializationUnit to another.
-  IRMaterializationUnit(ThreadSafeModule TSM, VModuleKey K,
-                        SymbolFlagsMap SymbolFlags,
-                        SymbolNameToDefinitionMap SymbolToDefinition);
-
-  /// Return the ModuleIdentifier as the name for this MaterializationUnit.
-  StringRef getName() const override;
-
-  const ThreadSafeModule &getModule() const { return TSM; }
-
-protected:
-  ThreadSafeModule TSM;
-  SymbolNameToDefinitionMap SymbolToDefinition;
-
-private:
-  void discard(const JITDylib &JD, const SymbolStringPtr &Name) override;
+  const IRSymbolMapper::ManglingOptions *&MO;
 };
 
 /// MaterializationUnit that materializes modules by calling the 'emit' method
 /// on the given IRLayer.
 class BasicIRLayerMaterializationUnit : public IRMaterializationUnit {
 public:
-  BasicIRLayerMaterializationUnit(IRLayer &L, VModuleKey K,
+  BasicIRLayerMaterializationUnit(IRLayer &L,
+                                  const IRSymbolMapper::ManglingOptions &MO,
                                   ThreadSafeModule TSM);
 
 private:
-
-  void materialize(MaterializationResponsibility R) override;
+  void materialize(std::unique_ptr<MaterializationResponsibility> R) override;
 
   IRLayer &L;
-  VModuleKey K;
 };
 
 /// Interface for Layers that accept object files.
@@ -120,11 +139,14 @@
 
   /// Adds a MaterializationUnit representing the given IR to the given
   /// JITDylib.
-  virtual Error add(JITDylib &JD, std::unique_ptr<MemoryBuffer> O,
-                    VModuleKey K = VModuleKey());
+  virtual Error add(ResourceTrackerSP RT, std::unique_ptr<MemoryBuffer> O);
+
+  Error add(JITDylib &JD, std::unique_ptr<MemoryBuffer> O) {
+    return add(JD.getDefaultResourceTracker(), std::move(O));
+  }
 
   /// Emit should materialize the given IR.
-  virtual void emit(MaterializationResponsibility R,
+  virtual void emit(std::unique_ptr<MaterializationResponsibility> R,
                     std::unique_ptr<MemoryBuffer> O) = 0;
 
 private:
@@ -136,30 +158,24 @@
 class BasicObjectLayerMaterializationUnit : public MaterializationUnit {
 public:
   static Expected<std::unique_ptr<BasicObjectLayerMaterializationUnit>>
-  Create(ObjectLayer &L, VModuleKey K, std::unique_ptr<MemoryBuffer> O);
+  Create(ObjectLayer &L, std::unique_ptr<MemoryBuffer> O);
 
-  BasicObjectLayerMaterializationUnit(ObjectLayer &L, VModuleKey K,
+  BasicObjectLayerMaterializationUnit(ObjectLayer &L,
                                       std::unique_ptr<MemoryBuffer> O,
-                                      SymbolFlagsMap SymbolFlags);
+                                      SymbolFlagsMap SymbolFlags,
+                                      SymbolStringPtr InitSymbol);
 
   /// Return the buffer's identifier as the name for this MaterializationUnit.
   StringRef getName() const override;
 
 private:
-
-  void materialize(MaterializationResponsibility R) override;
+  void materialize(std::unique_ptr<MaterializationResponsibility> R) override;
   void discard(const JITDylib &JD, const SymbolStringPtr &Name) override;
 
   ObjectLayer &L;
   std::unique_ptr<MemoryBuffer> O;
 };
 
-/// Returns a SymbolFlagsMap for the object file represented by the given
-/// buffer, or an error if the buffer does not contain a valid object file.
-// FIXME: Maybe move to Core.h?
-Expected<SymbolFlagsMap> getObjectSymbolFlags(ExecutionSession &ES,
-                                              MemoryBufferRef ObjBuffer);
-
 } // End namespace orc
 } // End namespace llvm
 
diff --git a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/LazyEmittingLayer.h b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/LazyEmittingLayer.h
deleted file mode 100644
index e5c5feb..0000000
--- a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/LazyEmittingLayer.h
+++ /dev/null
@@ -1,260 +0,0 @@
-//===- LazyEmittingLayer.h - Lazily emit IR to lower JIT layers -*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// Contains the definition for a lazy-emitting layer for the JIT.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_EXECUTIONENGINE_ORC_LAZYEMITTINGLAYER_H
-#define LLVM_EXECUTIONENGINE_ORC_LAZYEMITTINGLAYER_H
-
-#include "llvm/ADT/STLExtras.h"
-#include "llvm/ADT/StringMap.h"
-#include "llvm/ADT/StringRef.h"
-#include "llvm/ExecutionEngine/JITSymbol.h"
-#include "llvm/ExecutionEngine/Orc/Core.h"
-#include "llvm/IR/GlobalValue.h"
-#include "llvm/IR/Mangler.h"
-#include "llvm/IR/Module.h"
-#include "llvm/Support/ErrorHandling.h"
-#include "llvm/Support/raw_ostream.h"
-#include <algorithm>
-#include <cassert>
-#include <list>
-#include <memory>
-#include <string>
-
-namespace llvm {
-namespace orc {
-
-/// Lazy-emitting IR layer.
-///
-///   This layer accepts LLVM IR Modules (via addModule) but does not
-/// immediately emit them the layer below. Instead, emission to the base layer
-/// is deferred until the first time the client requests the address (via
-/// JITSymbol::getAddress) for a symbol contained in this layer.
-template <typename BaseLayerT> class LazyEmittingLayer {
-private:
-  class EmissionDeferredModule {
-  public:
-    EmissionDeferredModule(VModuleKey K, std::unique_ptr<Module> M)
-        : K(std::move(K)), M(std::move(M)) {}
-
-    JITSymbol find(StringRef Name, bool ExportedSymbolsOnly, BaseLayerT &B) {
-      switch (EmitState) {
-      case NotEmitted:
-        if (auto GV = searchGVs(Name, ExportedSymbolsOnly)) {
-          // Create a std::string version of Name to capture here - the argument
-          // (a StringRef) may go away before the lambda is executed.
-          // FIXME: Use capture-init when we move to C++14.
-          std::string PName = Name;
-          JITSymbolFlags Flags = JITSymbolFlags::fromGlobalValue(*GV);
-          auto GetAddress =
-            [this, ExportedSymbolsOnly, PName, &B]() -> Expected<JITTargetAddress> {
-              if (this->EmitState == Emitting)
-                return 0;
-              else if (this->EmitState == NotEmitted) {
-                this->EmitState = Emitting;
-                if (auto Err = this->emitToBaseLayer(B))
-                  return std::move(Err);
-                this->EmitState = Emitted;
-              }
-              if (auto Sym = B.findSymbolIn(K, PName, ExportedSymbolsOnly))
-                return Sym.getAddress();
-              else if (auto Err = Sym.takeError())
-                return std::move(Err);
-              else
-                llvm_unreachable("Successful symbol lookup should return "
-                                 "definition address here");
-          };
-          return JITSymbol(std::move(GetAddress), Flags);
-        } else
-          return nullptr;
-      case Emitting:
-        // Calling "emit" can trigger a recursive call to 'find' (e.g. to check
-        // for pre-existing definitions of common-symbol), but any symbol in
-        // this module would already have been found internally (in the
-        // RuntimeDyld that did the lookup), so just return a nullptr here.
-        return nullptr;
-      case Emitted:
-        return B.findSymbolIn(K, Name, ExportedSymbolsOnly);
-      }
-      llvm_unreachable("Invalid emit-state.");
-    }
-
-    Error removeModuleFromBaseLayer(BaseLayerT& BaseLayer) {
-      return EmitState != NotEmitted ? BaseLayer.removeModule(K)
-                                     : Error::success();
-    }
-
-    void emitAndFinalize(BaseLayerT &BaseLayer) {
-      assert(EmitState != Emitting &&
-             "Cannot emitAndFinalize while already emitting");
-      if (EmitState == NotEmitted) {
-        EmitState = Emitting;
-        emitToBaseLayer(BaseLayer);
-        EmitState = Emitted;
-      }
-      BaseLayer.emitAndFinalize(K);
-    }
-
-  private:
-
-    const GlobalValue* searchGVs(StringRef Name,
-                                 bool ExportedSymbolsOnly) const {
-      // FIXME: We could clean all this up if we had a way to reliably demangle
-      //        names: We could just demangle name and search, rather than
-      //        mangling everything else.
-
-      // If we have already built the mangled name set then just search it.
-      if (MangledSymbols) {
-        auto VI = MangledSymbols->find(Name);
-        if (VI == MangledSymbols->end())
-          return nullptr;
-        auto GV = VI->second;
-        if (!ExportedSymbolsOnly || GV->hasDefaultVisibility())
-          return GV;
-        return nullptr;
-      }
-
-      // If we haven't built the mangled name set yet, try to build it. As an
-      // optimization this will leave MangledNames set to nullptr if we find
-      // Name in the process of building the set.
-      return buildMangledSymbols(Name, ExportedSymbolsOnly);
-    }
-
-    Error emitToBaseLayer(BaseLayerT &BaseLayer) {
-      // We don't need the mangled names set any more: Once we've emitted this
-      // to the base layer we'll just look for symbols there.
-      MangledSymbols.reset();
-      return BaseLayer.addModule(std::move(K), std::move(M));
-    }
-
-    // If the mangled name of the given GlobalValue matches the given search
-    // name (and its visibility conforms to the ExportedSymbolsOnly flag) then
-    // return the symbol. Otherwise, add the mangled name to the Names map and
-    // return nullptr.
-    const GlobalValue* addGlobalValue(StringMap<const GlobalValue*> &Names,
-                                      const GlobalValue &GV,
-                                      const Mangler &Mang, StringRef SearchName,
-                                      bool ExportedSymbolsOnly) const {
-      // Modules don't "provide" decls or common symbols.
-      if (GV.isDeclaration() || GV.hasCommonLinkage())
-        return nullptr;
-
-      // Mangle the GV name.
-      std::string MangledName;
-      {
-        raw_string_ostream MangledNameStream(MangledName);
-        Mang.getNameWithPrefix(MangledNameStream, &GV, false);
-      }
-
-      // Check whether this is the name we were searching for, and if it is then
-      // bail out early.
-      if (MangledName == SearchName)
-        if (!ExportedSymbolsOnly || GV.hasDefaultVisibility())
-          return &GV;
-
-      // Otherwise add this to the map for later.
-      Names[MangledName] = &GV;
-      return nullptr;
-    }
-
-    // Build the MangledSymbols map. Bails out early (with MangledSymbols left set
-    // to nullptr) if the given SearchName is found while building the map.
-    const GlobalValue* buildMangledSymbols(StringRef SearchName,
-                                           bool ExportedSymbolsOnly) const {
-      assert(!MangledSymbols && "Mangled symbols map already exists?");
-
-      auto Symbols = llvm::make_unique<StringMap<const GlobalValue*>>();
-
-      Mangler Mang;
-
-      for (const auto &GO : M->global_objects())
-          if (auto GV = addGlobalValue(*Symbols, GO, Mang, SearchName,
-                                       ExportedSymbolsOnly))
-            return GV;
-
-      MangledSymbols = std::move(Symbols);
-      return nullptr;
-    }
-
-    enum { NotEmitted, Emitting, Emitted } EmitState = NotEmitted;
-    VModuleKey K;
-    std::unique_ptr<Module> M;
-    mutable std::unique_ptr<StringMap<const GlobalValue*>> MangledSymbols;
-  };
-
-  BaseLayerT &BaseLayer;
-  std::map<VModuleKey, std::unique_ptr<EmissionDeferredModule>> ModuleMap;
-
-public:
-
-  /// Construct a lazy emitting layer.
-  LazyEmittingLayer(BaseLayerT &BaseLayer) : BaseLayer(BaseLayer) {}
-
-  /// Add the given module to the lazy emitting layer.
-  Error addModule(VModuleKey K, std::unique_ptr<Module> M) {
-    assert(!ModuleMap.count(K) && "VModuleKey K already in use");
-    ModuleMap[K] =
-        llvm::make_unique<EmissionDeferredModule>(std::move(K), std::move(M));
-    return Error::success();
-  }
-
-  /// Remove the module represented by the given handle.
-  ///
-  ///   This method will free the memory associated with the given module, both
-  /// in this layer, and the base layer.
-  Error removeModule(VModuleKey K) {
-    auto I = ModuleMap.find(K);
-    assert(I != ModuleMap.end() && "VModuleKey K not valid here");
-    auto EDM = std::move(I.second);
-    ModuleMap.erase(I);
-    return EDM->removeModuleFromBaseLayer(BaseLayer);
-  }
-
-  /// Search for the given named symbol.
-  /// @param Name The name of the symbol to search for.
-  /// @param ExportedSymbolsOnly If true, search only for exported symbols.
-  /// @return A handle for the given named symbol, if it exists.
-  JITSymbol findSymbol(const std::string &Name, bool ExportedSymbolsOnly) {
-    // Look for the symbol among existing definitions.
-    if (auto Symbol = BaseLayer.findSymbol(Name, ExportedSymbolsOnly))
-      return Symbol;
-
-    // If not found then search the deferred modules. If any of these contain a
-    // definition of 'Name' then they will return a JITSymbol that will emit
-    // the corresponding module when the symbol address is requested.
-    for (auto &KV : ModuleMap)
-      if (auto Symbol = KV.second->find(Name, ExportedSymbolsOnly, BaseLayer))
-        return Symbol;
-
-    // If no definition found anywhere return a null symbol.
-    return nullptr;
-  }
-
-  /// Get the address of the given symbol in the context of the of
-  ///        compiled modules represented by the key K.
-  JITSymbol findSymbolIn(VModuleKey K, const std::string &Name,
-                         bool ExportedSymbolsOnly) {
-    assert(ModuleMap.count(K) && "VModuleKey K not valid here");
-    return ModuleMap[K]->find(Name, ExportedSymbolsOnly, BaseLayer);
-  }
-
-  /// Immediately emit and finalize the module represented by the given
-  ///        key.
-  Error emitAndFinalize(VModuleKey K) {
-    assert(ModuleMap.count(K) && "VModuleKey K not valid here");
-    return ModuleMap[K]->emitAndFinalize(BaseLayer);
-  }
-};
-
-} // end namespace orc
-} // end namespace llvm
-
-#endif // LLVM_EXECUTIONENGINE_ORC_LAZYEMITTINGLAYER_H
diff --git a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/LazyReexports.h b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/LazyReexports.h
index 9fdd1d1..e6a9d89 100644
--- a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/LazyReexports.h
+++ b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/LazyReexports.h
@@ -16,8 +16,10 @@
 #ifndef LLVM_EXECUTIONENGINE_ORC_LAZYREEXPORTS_H
 #define LLVM_EXECUTIONENGINE_ORC_LAZYREEXPORTS_H
 
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/ExecutionEngine/Orc/Core.h"
 #include "llvm/ExecutionEngine/Orc/IndirectionUtils.h"
+#include "llvm/ExecutionEngine/Orc/Speculation.h"
 
 namespace llvm {
 
@@ -35,73 +37,48 @@
 /// function.
 class LazyCallThroughManager {
 public:
-  /// Clients will want to take some action on first resolution, e.g. updating
-  /// a stub pointer. Instances of this class can be used to implement this.
-  class NotifyResolvedFunction {
-  public:
-    virtual ~NotifyResolvedFunction() {}
+  using NotifyResolvedFunction =
+      unique_function<Error(JITTargetAddress ResolvedAddr)>;
 
-    /// Called the first time a lazy call through is executed and the target
-    /// symbol resolved.
-    virtual Error operator()(JITDylib &SourceJD,
-                             const SymbolStringPtr &SymbolName,
-                             JITTargetAddress ResolvedAddr) = 0;
-
-  private:
-    virtual void anchor();
-  };
-
-  template <typename NotifyResolvedImpl>
-  class NotifyResolvedFunctionImpl : public NotifyResolvedFunction {
-  public:
-    NotifyResolvedFunctionImpl(NotifyResolvedImpl NotifyResolved)
-        : NotifyResolved(std::move(NotifyResolved)) {}
-    Error operator()(JITDylib &SourceJD, const SymbolStringPtr &SymbolName,
-                     JITTargetAddress ResolvedAddr) {
-      return NotifyResolved(SourceJD, SymbolName, ResolvedAddr);
-    }
-
-  private:
-    NotifyResolvedImpl NotifyResolved;
-  };
-
-  /// Create a shared NotifyResolvedFunction from a given type that is
-  /// callable with the correct signature.
-  template <typename NotifyResolvedImpl>
-  static std::unique_ptr<NotifyResolvedFunction>
-  createNotifyResolvedFunction(NotifyResolvedImpl NotifyResolved) {
-    return llvm::make_unique<NotifyResolvedFunctionImpl<NotifyResolvedImpl>>(
-        std::move(NotifyResolved));
-  }
+  LazyCallThroughManager(ExecutionSession &ES,
+                         JITTargetAddress ErrorHandlerAddr, TrampolinePool *TP);
 
   // Return a free call-through trampoline and bind it to look up and call
   // through to the given symbol.
-  Expected<JITTargetAddress> getCallThroughTrampoline(
-      JITDylib &SourceJD, SymbolStringPtr SymbolName,
-      std::shared_ptr<NotifyResolvedFunction> NotifyResolved);
+  Expected<JITTargetAddress>
+  getCallThroughTrampoline(JITDylib &SourceJD, SymbolStringPtr SymbolName,
+                           NotifyResolvedFunction NotifyResolved);
+
+  void resolveTrampolineLandingAddress(
+      JITTargetAddress TrampolineAddr,
+      TrampolinePool::NotifyLandingResolvedFunction NotifyLandingResolved);
+
+  virtual ~LazyCallThroughManager() = default;
 
 protected:
-  LazyCallThroughManager(ExecutionSession &ES,
-                         JITTargetAddress ErrorHandlerAddr,
-                         std::unique_ptr<TrampolinePool> TP);
+  using NotifyLandingResolvedFunction =
+      TrampolinePool::NotifyLandingResolvedFunction;
 
-  JITTargetAddress callThroughToSymbol(JITTargetAddress TrampolineAddr);
+  struct ReexportsEntry {
+    JITDylib *SourceJD;
+    SymbolStringPtr SymbolName;
+  };
 
-  void setTrampolinePool(std::unique_ptr<TrampolinePool> TP) {
-    this->TP = std::move(TP);
-  }
+  JITTargetAddress reportCallThroughError(Error Err);
+  Expected<ReexportsEntry> findReexport(JITTargetAddress TrampolineAddr);
+  Error notifyResolved(JITTargetAddress TrampolineAddr,
+                       JITTargetAddress ResolvedAddr);
+  void setTrampolinePool(TrampolinePool &TP) { this->TP = &TP; }
 
 private:
-  using ReexportsMap =
-      std::map<JITTargetAddress, std::pair<JITDylib *, SymbolStringPtr>>;
+  using ReexportsMap = std::map<JITTargetAddress, ReexportsEntry>;
 
-  using NotifiersMap =
-      std::map<JITTargetAddress, std::shared_ptr<NotifyResolvedFunction>>;
+  using NotifiersMap = std::map<JITTargetAddress, NotifyResolvedFunction>;
 
   std::mutex LCTMMutex;
   ExecutionSession &ES;
   JITTargetAddress ErrorHandlerAddr;
-  std::unique_ptr<TrampolinePool> TP;
+  TrampolinePool *TP = nullptr;
   ReexportsMap Reexports;
   NotifiersMap Notifiers;
 };
@@ -109,23 +86,31 @@
 /// A lazy call-through manager that builds trampolines in the current process.
 class LocalLazyCallThroughManager : public LazyCallThroughManager {
 private:
+  using NotifyTargetResolved = unique_function<void(JITTargetAddress)>;
+
   LocalLazyCallThroughManager(ExecutionSession &ES,
                               JITTargetAddress ErrorHandlerAddr)
       : LazyCallThroughManager(ES, ErrorHandlerAddr, nullptr) {}
 
   template <typename ORCABI> Error init() {
     auto TP = LocalTrampolinePool<ORCABI>::Create(
-        [this](JITTargetAddress TrampolineAddr) {
-          return callThroughToSymbol(TrampolineAddr);
+        [this](JITTargetAddress TrampolineAddr,
+               TrampolinePool::NotifyLandingResolvedFunction
+                   NotifyLandingResolved) {
+          resolveTrampolineLandingAddress(TrampolineAddr,
+                                          std::move(NotifyLandingResolved));
         });
 
     if (!TP)
       return TP.takeError();
 
-    setTrampolinePool(std::move(*TP));
+    this->TP = std::move(*TP);
+    setTrampolinePool(*this->TP);
     return Error::success();
   }
 
+  std::unique_ptr<TrampolinePool> TP;
+
 public:
   /// Create a LocalLazyCallThroughManager using the given ABI. See
   /// createLocalLazyCallThroughManager.
@@ -159,12 +144,12 @@
                                    IndirectStubsManager &ISManager,
                                    JITDylib &SourceJD,
                                    SymbolAliasMap CallableAliases,
-                                   VModuleKey K);
+                                   ImplSymbolMap *SrcJDLoc);
 
   StringRef getName() const override;
 
 private:
-  void materialize(MaterializationResponsibility R) override;
+  void materialize(std::unique_ptr<MaterializationResponsibility> R) override;
   void discard(const JITDylib &JD, const SymbolStringPtr &Name) override;
   static SymbolFlagsMap extractFlags(const SymbolAliasMap &Aliases);
 
@@ -172,8 +157,7 @@
   IndirectStubsManager &ISManager;
   JITDylib &SourceJD;
   SymbolAliasMap CallableAliases;
-  std::shared_ptr<LazyCallThroughManager::NotifyResolvedFunction>
-      NotifyResolved;
+  ImplSymbolMap *AliaseeTable;
 };
 
 /// Define lazy-reexports based on the given SymbolAliasMap. Each lazy re-export
@@ -182,10 +166,10 @@
 inline std::unique_ptr<LazyReexportsMaterializationUnit>
 lazyReexports(LazyCallThroughManager &LCTManager,
               IndirectStubsManager &ISManager, JITDylib &SourceJD,
-              SymbolAliasMap CallableAliases, VModuleKey K = VModuleKey()) {
-  return llvm::make_unique<LazyReexportsMaterializationUnit>(
-      LCTManager, ISManager, SourceJD, std::move(CallableAliases),
-      std::move(K));
+              SymbolAliasMap CallableAliases,
+              ImplSymbolMap *SrcJDLoc = nullptr) {
+  return std::make_unique<LazyReexportsMaterializationUnit>(
+      LCTManager, ISManager, SourceJD, std::move(CallableAliases), SrcJDLoc);
 }
 
 } // End namespace orc
diff --git a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/Legacy.h b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/Legacy.h
deleted file mode 100644
index f9cbbf6..0000000
--- a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/Legacy.h
+++ /dev/null
@@ -1,215 +0,0 @@
-//===--- Legacy.h -- Adapters for ExecutionEngine API interop ---*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// Contains core ORC APIs.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_EXECUTIONENGINE_ORC_LEGACY_H
-#define LLVM_EXECUTIONENGINE_ORC_LEGACY_H
-
-#include "llvm/ExecutionEngine/JITSymbol.h"
-#include "llvm/ExecutionEngine/Orc/Core.h"
-
-namespace llvm {
-namespace orc {
-
-/// SymbolResolver is a composable interface for looking up symbol flags
-///        and addresses using the AsynchronousSymbolQuery type. It will
-///        eventually replace the LegacyJITSymbolResolver interface as the
-///        stardard ORC symbol resolver type.
-///
-/// FIXME: SymbolResolvers should go away and be replaced with VSOs with
-///        defenition generators.
-class SymbolResolver {
-public:
-  virtual ~SymbolResolver() = default;
-
-  /// Returns the subset of the given symbols that the caller is responsible for
-  /// materializing.
-  virtual SymbolNameSet getResponsibilitySet(const SymbolNameSet &Symbols) = 0;
-
-  /// For each symbol in Symbols that can be found, assigns that symbols
-  /// value in Query. Returns the set of symbols that could not be found.
-  virtual SymbolNameSet lookup(std::shared_ptr<AsynchronousSymbolQuery> Query,
-                               SymbolNameSet Symbols) = 0;
-
-private:
-  virtual void anchor();
-};
-
-/// Implements SymbolResolver with a pair of supplied function objects
-///        for convenience. See createSymbolResolver.
-template <typename GetResponsibilitySetFn, typename LookupFn>
-class LambdaSymbolResolver final : public SymbolResolver {
-public:
-  template <typename GetResponsibilitySetFnRef, typename LookupFnRef>
-  LambdaSymbolResolver(GetResponsibilitySetFnRef &&GetResponsibilitySet,
-                       LookupFnRef &&Lookup)
-      : GetResponsibilitySet(
-            std::forward<GetResponsibilitySetFnRef>(GetResponsibilitySet)),
-        Lookup(std::forward<LookupFnRef>(Lookup)) {}
-
-  SymbolNameSet getResponsibilitySet(const SymbolNameSet &Symbols) final {
-    return GetResponsibilitySet(Symbols);
-  }
-
-  SymbolNameSet lookup(std::shared_ptr<AsynchronousSymbolQuery> Query,
-                       SymbolNameSet Symbols) final {
-    return Lookup(std::move(Query), std::move(Symbols));
-  }
-
-private:
-  GetResponsibilitySetFn GetResponsibilitySet;
-  LookupFn Lookup;
-};
-
-/// Creates a SymbolResolver implementation from the pair of supplied
-///        function objects.
-template <typename GetResponsibilitySetFn, typename LookupFn>
-std::unique_ptr<LambdaSymbolResolver<
-    typename std::remove_cv<
-        typename std::remove_reference<GetResponsibilitySetFn>::type>::type,
-    typename std::remove_cv<
-        typename std::remove_reference<LookupFn>::type>::type>>
-createSymbolResolver(GetResponsibilitySetFn &&GetResponsibilitySet,
-                     LookupFn &&Lookup) {
-  using LambdaSymbolResolverImpl = LambdaSymbolResolver<
-      typename std::remove_cv<
-          typename std::remove_reference<GetResponsibilitySetFn>::type>::type,
-      typename std::remove_cv<
-          typename std::remove_reference<LookupFn>::type>::type>;
-  return llvm::make_unique<LambdaSymbolResolverImpl>(
-      std::forward<GetResponsibilitySetFn>(GetResponsibilitySet),
-      std::forward<LookupFn>(Lookup));
-}
-
-/// Legacy adapter. Remove once we kill off the old ORC layers.
-class JITSymbolResolverAdapter : public JITSymbolResolver {
-public:
-  JITSymbolResolverAdapter(ExecutionSession &ES, SymbolResolver &R,
-                           MaterializationResponsibility *MR);
-  Expected<LookupSet> getResponsibilitySet(const LookupSet &Symbols) override;
-  void lookup(const LookupSet &Symbols, OnResolvedFunction OnResolved) override;
-
-private:
-  ExecutionSession &ES;
-  std::set<SymbolStringPtr> ResolvedStrings;
-  SymbolResolver &R;
-  MaterializationResponsibility *MR;
-};
-
-/// Use the given legacy-style FindSymbol function (i.e. a function that takes
-/// a const std::string& or StringRef and returns a JITSymbol) to get the
-/// subset of symbols that the caller is responsible for materializing. If any
-/// JITSymbol returned by FindSymbol is in an error state the function returns
-/// immediately with that error.
-///
-/// Useful for implementing getResponsibilitySet bodies that query legacy
-/// resolvers.
-template <typename FindSymbolFn>
-Expected<SymbolNameSet>
-getResponsibilitySetWithLegacyFn(const SymbolNameSet &Symbols,
-                                 FindSymbolFn FindSymbol) {
-  SymbolNameSet Result;
-
-  for (auto &S : Symbols) {
-    if (JITSymbol Sym = FindSymbol(*S)) {
-      if (!Sym.getFlags().isStrong())
-        Result.insert(S);
-    } else if (auto Err = Sym.takeError())
-      return std::move(Err);
-  }
-
-  return Result;
-}
-
-/// Use the given legacy-style FindSymbol function (i.e. a function that
-///        takes a const std::string& or StringRef and returns a JITSymbol) to
-///        find the address and flags for each symbol in Symbols and store the
-///        result in Query. If any JITSymbol returned by FindSymbol is in an
-///        error then Query.notifyFailed(...) is called with that error and the
-///        function returns immediately. On success, returns the set of symbols
-///        not found.
-///
-/// Useful for implementing lookup bodies that query legacy resolvers.
-template <typename FindSymbolFn>
-SymbolNameSet
-lookupWithLegacyFn(ExecutionSession &ES, AsynchronousSymbolQuery &Query,
-                   const SymbolNameSet &Symbols, FindSymbolFn FindSymbol) {
-  SymbolNameSet SymbolsNotFound;
-  bool NewSymbolsResolved = false;
-
-  for (auto &S : Symbols) {
-    if (JITSymbol Sym = FindSymbol(*S)) {
-      if (auto Addr = Sym.getAddress()) {
-        Query.notifySymbolMetRequiredState(
-            S, JITEvaluatedSymbol(*Addr, Sym.getFlags()));
-        NewSymbolsResolved = true;
-      } else {
-        ES.legacyFailQuery(Query, Addr.takeError());
-        return SymbolNameSet();
-      }
-    } else if (auto Err = Sym.takeError()) {
-      ES.legacyFailQuery(Query, std::move(Err));
-      return SymbolNameSet();
-    } else
-      SymbolsNotFound.insert(S);
-  }
-
-  if (NewSymbolsResolved && Query.isComplete())
-    Query.handleComplete();
-
-  return SymbolsNotFound;
-}
-
-/// An ORC SymbolResolver implementation that uses a legacy
-///        findSymbol-like function to perform lookup;
-template <typename LegacyLookupFn>
-class LegacyLookupFnResolver final : public SymbolResolver {
-public:
-  using ErrorReporter = std::function<void(Error)>;
-
-  LegacyLookupFnResolver(ExecutionSession &ES, LegacyLookupFn LegacyLookup,
-                         ErrorReporter ReportError)
-      : ES(ES), LegacyLookup(std::move(LegacyLookup)),
-        ReportError(std::move(ReportError)) {}
-
-  SymbolNameSet getResponsibilitySet(const SymbolNameSet &Symbols) final {
-    if (auto ResponsibilitySet =
-            getResponsibilitySetWithLegacyFn(Symbols, LegacyLookup))
-      return std::move(*ResponsibilitySet);
-    else {
-      ReportError(ResponsibilitySet.takeError());
-      return SymbolNameSet();
-    }
-  }
-
-  SymbolNameSet lookup(std::shared_ptr<AsynchronousSymbolQuery> Query,
-                       SymbolNameSet Symbols) final {
-    return lookupWithLegacyFn(ES, *Query, Symbols, LegacyLookup);
-  }
-
-private:
-  ExecutionSession &ES;
-  LegacyLookupFn LegacyLookup;
-  ErrorReporter ReportError;
-};
-
-template <typename LegacyLookupFn>
-std::shared_ptr<LegacyLookupFnResolver<LegacyLookupFn>>
-createLegacyLookupResolver(ExecutionSession &ES, LegacyLookupFn LegacyLookup,
-                           std::function<void(Error)> ErrorReporter) {
-  return std::make_shared<LegacyLookupFnResolver<LegacyLookupFn>>(
-      ES, std::move(LegacyLookup), std::move(ErrorReporter));
-}
-
-} // End namespace orc
-} // End namespace llvm
-
-#endif // LLVM_EXECUTIONENGINE_ORC_LEGACY_H
diff --git a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/MachOPlatform.h b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/MachOPlatform.h
new file mode 100644
index 0000000..90e1d47
--- /dev/null
+++ b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/MachOPlatform.h
@@ -0,0 +1,173 @@
+//===-- MachOPlatform.h - Utilities for executing MachO in Orc --*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Utilities for executing JIT'd MachO in Orc.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_EXECUTIONENGINE_ORC_MACHOPLATFORM_H
+#define LLVM_EXECUTIONENGINE_ORC_MACHOPLATFORM_H
+
+#include "llvm/ADT/StringRef.h"
+#include "llvm/ExecutionEngine/Orc/Core.h"
+#include "llvm/ExecutionEngine/Orc/ExecutionUtils.h"
+#include "llvm/ExecutionEngine/Orc/ObjectLinkingLayer.h"
+
+#include <future>
+#include <thread>
+#include <vector>
+
+namespace llvm {
+namespace orc {
+
+/// Enable registration of JIT'd ObjC classes and selectors.
+Error enableObjCRegistration(const char *PathToLibObjC);
+bool objCRegistrationEnabled();
+
+class MachOJITDylibInitializers {
+public:
+  struct SectionExtent {
+    SectionExtent() = default;
+    SectionExtent(JITTargetAddress Address, uint64_t NumPtrs)
+        : Address(Address), NumPtrs(NumPtrs) {}
+    JITTargetAddress Address = 0;
+    uint64_t NumPtrs = 0;
+  };
+
+  using RawPointerSectionList = std::vector<SectionExtent>;
+
+  void setObjCImageInfoAddr(JITTargetAddress ObjCImageInfoAddr) {
+    this->ObjCImageInfoAddr = ObjCImageInfoAddr;
+  }
+
+  void addModInitsSection(SectionExtent ModInit) {
+    ModInitSections.push_back(std::move(ModInit));
+  }
+
+  const RawPointerSectionList &getModInitsSections() const {
+    return ModInitSections;
+  }
+
+  void addObjCSelRefsSection(SectionExtent ObjCSelRefs) {
+    ObjCSelRefsSections.push_back(std::move(ObjCSelRefs));
+  }
+
+  const RawPointerSectionList &getObjCSelRefsSections() const {
+    return ObjCSelRefsSections;
+  }
+
+  void addObjCClassListSection(SectionExtent ObjCClassList) {
+    ObjCClassListSections.push_back(std::move(ObjCClassList));
+  }
+
+  const RawPointerSectionList &getObjCClassListSections() const {
+    return ObjCClassListSections;
+  }
+
+  void runModInits() const;
+  void registerObjCSelectors() const;
+  Error registerObjCClasses() const;
+
+private:
+
+  JITTargetAddress ObjCImageInfoAddr;
+  RawPointerSectionList ModInitSections;
+  RawPointerSectionList ObjCSelRefsSections;
+  RawPointerSectionList ObjCClassListSections;
+};
+
+class MachOJITDylibDeinitializers {};
+
+/// Mediates between MachO initialization and ExecutionSession state.
+class MachOPlatform : public Platform {
+public:
+  using InitializerSequence =
+      std::vector<std::pair<JITDylib *, MachOJITDylibInitializers>>;
+
+  using DeinitializerSequence =
+      std::vector<std::pair<JITDylib *, MachOJITDylibDeinitializers>>;
+
+  MachOPlatform(ExecutionSession &ES, ObjectLinkingLayer &ObjLinkingLayer,
+                std::unique_ptr<MemoryBuffer> StandardSymbolsObject);
+
+  ExecutionSession &getExecutionSession() const { return ES; }
+
+  Error setupJITDylib(JITDylib &JD) override;
+  Error notifyAdding(ResourceTracker &RT,
+                     const MaterializationUnit &MU) override;
+  Error notifyRemoving(ResourceTracker &RT) override;
+
+  Expected<InitializerSequence> getInitializerSequence(JITDylib &JD);
+
+  Expected<DeinitializerSequence> getDeinitializerSequence(JITDylib &JD);
+
+private:
+  // This ObjectLinkingLayer plugin scans JITLink graphs for __mod_init_func,
+  // __objc_classlist and __sel_ref sections and records their extents so that
+  // they can be run in the target process.
+  class InitScraperPlugin : public ObjectLinkingLayer::Plugin {
+  public:
+    InitScraperPlugin(MachOPlatform &MP) : MP(MP) {}
+
+    void modifyPassConfig(MaterializationResponsibility &MR, const Triple &TT,
+                          jitlink::PassConfiguration &Config) override;
+
+    LocalDependenciesMap getSyntheticSymbolLocalDependencies(
+        MaterializationResponsibility &MR) override;
+
+    // FIXME: We should be tentatively tracking scraped sections and discarding
+    // if the MR fails.
+    Error notifyFailed(MaterializationResponsibility &MR) override {
+      return Error::success();
+    }
+
+    Error notifyRemovingResources(ResourceKey K) override {
+      return Error::success();
+    }
+
+    void notifyTransferringResources(ResourceKey DstKey,
+                                     ResourceKey SrcKey) override {}
+
+  private:
+    using InitSymbolDepMap =
+        DenseMap<MaterializationResponsibility *, JITLinkSymbolVector>;
+
+    void preserveInitSectionIfPresent(JITLinkSymbolVector &Syms,
+                                      jitlink::LinkGraph &G,
+                                      StringRef SectionName);
+
+    Error processObjCImageInfo(jitlink::LinkGraph &G,
+                               MaterializationResponsibility &MR);
+
+    std::mutex InitScraperMutex;
+    MachOPlatform &MP;
+    DenseMap<JITDylib *, std::pair<uint32_t, uint32_t>> ObjCImageInfos;
+    InitSymbolDepMap InitSymbolDeps;
+  };
+
+  void registerInitInfo(JITDylib &JD, JITTargetAddress ObjCImageInfoAddr,
+                        MachOJITDylibInitializers::SectionExtent ModInits,
+                        MachOJITDylibInitializers::SectionExtent ObjCSelRefs,
+                        MachOJITDylibInitializers::SectionExtent ObjCClassList);
+
+  ExecutionSession &ES;
+  ObjectLinkingLayer &ObjLinkingLayer;
+  std::unique_ptr<MemoryBuffer> StandardSymbolsObject;
+
+  DenseMap<JITDylib *, SymbolLookupSet> RegisteredInitSymbols;
+
+  // InitSeqs gets its own mutex to avoid locking the whole session when
+  // aggregating data from the jitlink.
+  std::mutex InitSeqsMutex;
+  DenseMap<JITDylib *, MachOJITDylibInitializers> InitSeqs;
+};
+
+} // end namespace orc
+} // end namespace llvm
+
+#endif // LLVM_EXECUTIONENGINE_ORC_MACHOPLATFORM_H
diff --git a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/Mangling.h b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/Mangling.h
new file mode 100644
index 0000000..e0f770a
--- /dev/null
+++ b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/Mangling.h
@@ -0,0 +1,66 @@
+//===------ Mangling.h -- Name Mangling Utilities for ORC -------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Name mangling utilities for ORC.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_EXECUTIONENGINE_ORC_MANGLING_H
+#define LLVM_EXECUTIONENGINE_ORC_MANGLING_H
+
+#include "llvm/ExecutionEngine/Orc/Core.h"
+#include "llvm/ExecutionEngine/Orc/ThreadSafeModule.h"
+#include "llvm/IR/Module.h"
+#include "llvm/Support/MemoryBuffer.h"
+
+namespace llvm {
+namespace orc {
+
+/// Mangles symbol names then uniques them in the context of an
+/// ExecutionSession.
+class MangleAndInterner {
+public:
+  MangleAndInterner(ExecutionSession &ES, const DataLayout &DL);
+  SymbolStringPtr operator()(StringRef Name);
+
+private:
+  ExecutionSession &ES;
+  const DataLayout &DL;
+};
+
+/// Maps IR global values to their linker symbol names / flags.
+///
+/// This utility can be used when adding new IR globals in the JIT.
+class IRSymbolMapper {
+public:
+  struct ManglingOptions {
+    bool EmulatedTLS = false;
+  };
+
+  using SymbolNameToDefinitionMap = std::map<SymbolStringPtr, GlobalValue *>;
+
+  /// Add mangled symbols for the given GlobalValues to SymbolFlags.
+  /// If a SymbolToDefinitionMap pointer is supplied then it will be populated
+  /// with Name-to-GlobalValue* mappings. Note that this mapping is not
+  /// necessarily one-to-one: thread-local GlobalValues, for example, may
+  /// produce more than one symbol, in which case the map will contain duplicate
+  /// values.
+  static void add(ExecutionSession &ES, const ManglingOptions &MO,
+                  ArrayRef<GlobalValue *> GVs, SymbolFlagsMap &SymbolFlags,
+                  SymbolNameToDefinitionMap *SymbolToDefinition = nullptr);
+};
+
+/// Returns a SymbolFlagsMap for the object file represented by the given
+/// buffer, or an error if the buffer does not contain a valid object file.
+Expected<std::pair<SymbolFlagsMap, SymbolStringPtr>>
+getObjectSymbolInfo(ExecutionSession &ES, MemoryBufferRef ObjBuffer);
+
+} // End namespace orc
+} // End namespace llvm
+
+#endif // LLVM_EXECUTIONENGINE_ORC_MANGLING_H
diff --git a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/NullResolver.h b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/NullResolver.h
deleted file mode 100644
index ffa37a1..0000000
--- a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/NullResolver.h
+++ /dev/null
@@ -1,43 +0,0 @@
-//===------ NullResolver.h - Reject symbol lookup requests ------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-//   Defines a RuntimeDyld::SymbolResolver subclass that rejects all symbol
-// resolution requests, for clients that have no cross-object fixups.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_EXECUTIONENGINE_ORC_NULLRESOLVER_H
-#define LLVM_EXECUTIONENGINE_ORC_NULLRESOLVER_H
-
-#include "llvm/ExecutionEngine/Orc/Legacy.h"
-#include "llvm/ExecutionEngine/RuntimeDyld.h"
-
-namespace llvm {
-namespace orc {
-
-class NullResolver : public SymbolResolver {
-public:
-  SymbolNameSet getResponsibilitySet(const SymbolNameSet &Symbols) final;
-
-  SymbolNameSet lookup(std::shared_ptr<AsynchronousSymbolQuery> Query,
-                       SymbolNameSet Symbols) final;
-};
-
-/// SymbolResolver impliementation that rejects all resolution requests.
-/// Useful for clients that have no cross-object fixups.
-class NullLegacyResolver : public LegacyJITSymbolResolver {
-public:
-  JITSymbol findSymbol(const std::string &Name) final;
-
-  JITSymbol findSymbolInLogicalDylib(const std::string &Name) final;
-};
-
-} // End namespace orc.
-} // End namespace llvm.
-
-#endif // LLVM_EXECUTIONENGINE_ORC_NULLRESOLVER_H
diff --git a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/ObjectLinkingLayer.h b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/ObjectLinkingLayer.h
index c1e7d27..f2975e2 100644
--- a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/ObjectLinkingLayer.h
+++ b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/ObjectLinkingLayer.h
@@ -35,6 +35,8 @@
 
 namespace jitlink {
 class EHFrameRegistrar;
+class LinkGraph;
+class Symbol;
 } // namespace jitlink
 
 namespace object {
@@ -50,7 +52,7 @@
 /// Clients can use this class to add relocatable object files to an
 /// ExecutionSession, and it typically serves as the base layer (underneath
 /// a compiling layer like IRCompileLayer) for the rest of the JIT.
-class ObjectLinkingLayer : public ObjectLayer {
+class ObjectLinkingLayer : public ObjectLayer, private ResourceManager {
   friend class ObjectLinkingLayerJITLinkContext;
 
 public:
@@ -59,28 +61,57 @@
   /// configured.
   class Plugin {
   public:
+    using JITLinkSymbolVector = std::vector<const jitlink::Symbol *>;
+    using LocalDependenciesMap = DenseMap<SymbolStringPtr, JITLinkSymbolVector>;
+
     virtual ~Plugin();
     virtual void modifyPassConfig(MaterializationResponsibility &MR,
                                   const Triple &TT,
                                   jitlink::PassConfiguration &Config) {}
+
     virtual void notifyLoaded(MaterializationResponsibility &MR) {}
     virtual Error notifyEmitted(MaterializationResponsibility &MR) {
       return Error::success();
     }
-    virtual Error notifyRemovingModule(VModuleKey K) {
-      return Error::success();
+    virtual Error notifyFailed(MaterializationResponsibility &MR) = 0;
+    virtual Error notifyRemovingResources(ResourceKey K) = 0;
+    virtual void notifyTransferringResources(ResourceKey DstKey,
+                                             ResourceKey SrcKey) = 0;
+
+    /// Return any dependencies that synthetic symbols (e.g. init symbols)
+    /// have on locally scoped jitlink::Symbols. This is used by the
+    /// ObjectLinkingLayer to update the dependencies for the synthetic
+    /// symbols.
+    virtual LocalDependenciesMap
+    getSyntheticSymbolLocalDependencies(MaterializationResponsibility &MR) {
+      return LocalDependenciesMap();
     }
-    virtual Error notifyRemovingAllModules() { return Error::success(); }
   };
 
-  /// Construct an ObjectLinkingLayer with the given NotifyLoaded,
-  /// and NotifyEmitted functors.
+  using ReturnObjectBufferFunction =
+      std::function<void(std::unique_ptr<MemoryBuffer>)>;
+
+  /// Construct an ObjectLinkingLayer.
   ObjectLinkingLayer(ExecutionSession &ES,
                      jitlink::JITLinkMemoryManager &MemMgr);
 
+  /// Construct an ObjectLinkingLayer. Takes ownership of the given
+  /// JITLinkMemoryManager. This method is a temporary hack to simplify
+  /// co-existence with RTDyldObjectLinkingLayer (which also owns its
+  /// allocators).
+  ObjectLinkingLayer(ExecutionSession &ES,
+                     std::unique_ptr<jitlink::JITLinkMemoryManager> MemMgr);
+
   /// Destruct an ObjectLinkingLayer.
   ~ObjectLinkingLayer();
 
+  /// Set an object buffer return function. By default object buffers are
+  /// deleted once the JIT has linked them. If a return function is set then
+  /// it will be called to transfer ownership of the buffer instead.
+  void setReturnObjectBuffer(ReturnObjectBufferFunction ReturnObjectBuffer) {
+    this->ReturnObjectBuffer = std::move(ReturnObjectBuffer);
+  }
+
   /// Add a pass-config modifier.
   ObjectLinkingLayer &addPlugin(std::unique_ptr<Plugin> P) {
     std::lock_guard<std::mutex> Lock(LayerMutex);
@@ -88,10 +119,14 @@
     return *this;
   }
 
-  /// Emit the object.
-  void emit(MaterializationResponsibility R,
+  /// Emit an object file.
+  void emit(std::unique_ptr<MaterializationResponsibility> R,
             std::unique_ptr<MemoryBuffer> O) override;
 
+  /// Emit a LinkGraph.
+  void emit(std::unique_ptr<MaterializationResponsibility> R,
+            std::unique_ptr<jitlink::LinkGraph> G);
+
   /// Instructs this ObjectLinkingLayer instance to override the symbol flags
   /// found in the AtomGraph with the flags supplied by the
   /// MaterializationResponsibility instance. This is a workaround to support
@@ -131,32 +166,44 @@
   void notifyLoaded(MaterializationResponsibility &MR);
   Error notifyEmitted(MaterializationResponsibility &MR, AllocPtr Alloc);
 
-  Error removeModule(VModuleKey K);
-  Error removeAllModules();
+  Error handleRemoveResources(ResourceKey K) override;
+  void handleTransferResources(ResourceKey DstKey, ResourceKey SrcKey) override;
 
   mutable std::mutex LayerMutex;
   jitlink::JITLinkMemoryManager &MemMgr;
+  std::unique_ptr<jitlink::JITLinkMemoryManager> MemMgrOwnership;
   bool OverrideObjectFlags = false;
   bool AutoClaimObjectSymbols = false;
-  DenseMap<VModuleKey, AllocPtr> TrackedAllocs;
-  std::vector<AllocPtr> UntrackedAllocs;
+  ReturnObjectBufferFunction ReturnObjectBuffer;
+  DenseMap<ResourceKey, std::vector<AllocPtr>> Allocs;
   std::vector<std::unique_ptr<Plugin>> Plugins;
 };
 
 class EHFrameRegistrationPlugin : public ObjectLinkingLayer::Plugin {
 public:
-  EHFrameRegistrationPlugin(jitlink::EHFrameRegistrar &Registrar);
-  Error notifyEmitted(MaterializationResponsibility &MR) override;
+  EHFrameRegistrationPlugin(
+      ExecutionSession &ES,
+      std::unique_ptr<jitlink::EHFrameRegistrar> Registrar);
   void modifyPassConfig(MaterializationResponsibility &MR, const Triple &TT,
                         jitlink::PassConfiguration &PassConfig) override;
-  Error notifyRemovingModule(VModuleKey K) override;
-  Error notifyRemovingAllModules() override;
+  Error notifyEmitted(MaterializationResponsibility &MR) override;
+  Error notifyFailed(MaterializationResponsibility &MR) override;
+  Error notifyRemovingResources(ResourceKey K) override;
+  void notifyTransferringResources(ResourceKey DstKey,
+                                   ResourceKey SrcKey) override;
 
 private:
-  jitlink::EHFrameRegistrar &Registrar;
-  DenseMap<MaterializationResponsibility *, JITTargetAddress> InProcessLinks;
-  DenseMap<VModuleKey, JITTargetAddress> TrackedEHFrameAddrs;
-  std::vector<JITTargetAddress> UntrackedEHFrameAddrs;
+
+  struct EHFrameRange {
+    JITTargetAddress Addr = 0;
+    size_t Size;
+  };
+
+  std::mutex EHFramePluginMutex;
+  ExecutionSession &ES;
+  std::unique_ptr<jitlink::EHFrameRegistrar> Registrar;
+  DenseMap<MaterializationResponsibility *, EHFrameRange> InProcessLinks;
+  DenseMap<ResourceKey, std::vector<EHFrameRange>> EHFrameRanges;
 };
 
 } // end namespace orc
diff --git a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/ObjectTransformLayer.h b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/ObjectTransformLayer.h
index de4603f..d8395ab 100644
--- a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/ObjectTransformLayer.h
+++ b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/ObjectTransformLayer.h
@@ -29,84 +29,20 @@
           std::unique_ptr<MemoryBuffer>)>;
 
   ObjectTransformLayer(ExecutionSession &ES, ObjectLayer &BaseLayer,
-                       TransformFunction Transform);
+                       TransformFunction Transform = TransformFunction());
 
-  void emit(MaterializationResponsibility R,
+  void emit(std::unique_ptr<MaterializationResponsibility> R,
             std::unique_ptr<MemoryBuffer> O) override;
 
+  void setTransform(TransformFunction Transform) {
+    this->Transform = std::move(Transform);
+  }
+
 private:
   ObjectLayer &BaseLayer;
   TransformFunction Transform;
 };
 
-/// Object mutating layer.
-///
-///   This layer accepts sets of ObjectFiles (via addObject). It
-/// immediately applies the user supplied functor to each object, then adds
-/// the set of transformed objects to the layer below.
-template <typename BaseLayerT, typename TransformFtor>
-class LegacyObjectTransformLayer {
-public:
-  /// Construct an ObjectTransformLayer with the given BaseLayer
-  LegacyObjectTransformLayer(BaseLayerT &BaseLayer,
-                             TransformFtor Transform = TransformFtor())
-      : BaseLayer(BaseLayer), Transform(std::move(Transform)) {}
-
-  /// Apply the transform functor to each object in the object set, then
-  ///        add the resulting set of objects to the base layer, along with the
-  ///        memory manager and symbol resolver.
-  ///
-  /// @return A handle for the added objects.
-  template <typename ObjectPtr> Error addObject(VModuleKey K, ObjectPtr Obj) {
-    return BaseLayer.addObject(std::move(K), Transform(std::move(Obj)));
-  }
-
-  /// Remove the object set associated with the VModuleKey K.
-  Error removeObject(VModuleKey K) { return BaseLayer.removeObject(K); }
-
-  /// Search for the given named symbol.
-  /// @param Name The name of the symbol to search for.
-  /// @param ExportedSymbolsOnly If true, search only for exported symbols.
-  /// @return A handle for the given named symbol, if it exists.
-  JITSymbol findSymbol(const std::string &Name, bool ExportedSymbolsOnly) {
-    return BaseLayer.findSymbol(Name, ExportedSymbolsOnly);
-  }
-
-  /// Get the address of the given symbol in the context of the set of
-  ///        objects represented by the VModuleKey K. This call is forwarded to
-  ///        the base layer's implementation.
-  /// @param K The VModuleKey associated with the object set to search in.
-  /// @param Name The name of the symbol to search for.
-  /// @param ExportedSymbolsOnly If true, search only for exported symbols.
-  /// @return A handle for the given named symbol, if it is found in the
-  ///         given object set.
-  JITSymbol findSymbolIn(VModuleKey K, const std::string &Name,
-                         bool ExportedSymbolsOnly) {
-    return BaseLayer.findSymbolIn(K, Name, ExportedSymbolsOnly);
-  }
-
-  /// Immediately emit and finalize the object set represented by the
-  ///        given VModuleKey K.
-  Error emitAndFinalize(VModuleKey K) { return BaseLayer.emitAndFinalize(K); }
-
-  /// Map section addresses for the objects associated with the
-  /// VModuleKey K.
-  void mapSectionAddress(VModuleKey K, const void *LocalAddress,
-                         JITTargetAddress TargetAddr) {
-    BaseLayer.mapSectionAddress(K, LocalAddress, TargetAddr);
-  }
-
-  /// Access the transform functor directly.
-  TransformFtor &getTransform() { return Transform; }
-
-  /// Access the mumate functor directly.
-  const TransformFtor &getTransform() const { return Transform; }
-
-private:
-  BaseLayerT &BaseLayer;
-  TransformFtor Transform;
-};
-
 } // end namespace orc
 } // end namespace llvm
 
diff --git a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/OrcABISupport.h b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/OrcABISupport.h
index 38246bc..5061c15 100644
--- a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/OrcABISupport.h
+++ b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/OrcABISupport.h
@@ -20,128 +20,107 @@
 #include "llvm/ExecutionEngine/JITSymbol.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/ErrorHandling.h"
-#include "llvm/Support/Memory.h"
+#include "llvm/Support/MathExtras.h"
 #include <algorithm>
 #include <cstdint>
 
 namespace llvm {
 namespace orc {
 
+struct IndirectStubsAllocationSizes {
+  uint64_t StubBytes = 0;
+  uint64_t PointerBytes = 0;
+  unsigned NumStubs = 0;
+};
+
+template <typename ORCABI>
+IndirectStubsAllocationSizes
+getIndirectStubsBlockSizes(unsigned MinStubs, unsigned RoundToMultipleOf = 0) {
+  assert(
+      (RoundToMultipleOf == 0 || (RoundToMultipleOf % ORCABI::StubSize == 0)) &&
+      "RoundToMultipleOf is not a multiple of stub size");
+  uint64_t StubBytes = MinStubs * ORCABI::StubSize;
+  if (RoundToMultipleOf)
+    StubBytes = alignTo(StubBytes, RoundToMultipleOf);
+  unsigned NumStubs = StubBytes / ORCABI::StubSize;
+  uint64_t PointerBytes = NumStubs * ORCABI::PointerSize;
+  return {StubBytes, PointerBytes, NumStubs};
+}
+
 /// Generic ORC ABI support.
 ///
-/// This class can be substituted as the target architecure support class for
+/// This class can be substituted as the target architecture support class for
 /// ORC templates that require one (e.g. IndirectStubsManagers). It does not
 /// support lazy JITing however, and any attempt to use that functionality
 /// will result in execution of an llvm_unreachable.
 class OrcGenericABI {
 public:
-  static const unsigned PointerSize = sizeof(uintptr_t);
-  static const unsigned TrampolineSize = 1;
-  static const unsigned ResolverCodeSize = 1;
+  static constexpr unsigned PointerSize = sizeof(uintptr_t);
+  static constexpr unsigned TrampolineSize = 1;
+  static constexpr unsigned StubSize = 1;
+  static constexpr unsigned StubToPointerMaxDisplacement = 1;
+  static constexpr unsigned ResolverCodeSize = 1;
 
-  using JITReentryFn = JITTargetAddress (*)(void *CallbackMgr,
-                                            void *TrampolineId);
-
-  static void writeResolverCode(uint8_t *ResolveMem, JITReentryFn Reentry,
-                                void *CallbackMgr) {
+  static void writeResolverCode(char *ResolveWorkingMem,
+                                JITTargetAddress ResolverTargetAddr,
+                                JITTargetAddress ReentryFnAddr,
+                                JITTargetAddress ReentryCtxAddr) {
     llvm_unreachable("writeResolverCode is not supported by the generic host "
                      "support class");
   }
 
-  static void writeTrampolines(uint8_t *TrampolineMem, void *ResolverAddr,
+  static void writeTrampolines(char *TrampolineBlockWorkingMem,
+                               JITTargetAddress TrampolineBlockTargetAddr,
+                               JITTargetAddress ResolverAddr,
                                unsigned NumTrampolines) {
     llvm_unreachable("writeTrampolines is not supported by the generic host "
                      "support class");
   }
 
-  class IndirectStubsInfo {
-  public:
-    const static unsigned StubSize = 1;
-
-    unsigned getNumStubs() const { llvm_unreachable("Not supported"); }
-    void *getStub(unsigned Idx) const { llvm_unreachable("Not supported"); }
-    void **getPtr(unsigned Idx) const { llvm_unreachable("Not supported"); }
-  };
-
-  static Error emitIndirectStubsBlock(IndirectStubsInfo &StubsInfo,
-                                      unsigned MinStubs, void *InitialPtrVal) {
-    llvm_unreachable("emitIndirectStubsBlock is not supported by the generic "
-                     "host support class");
+  static void writeIndirectStubsBlock(
+      char *StubsBlockWorkingMem, JITTargetAddress StubsBlockTargetAddress,
+      JITTargetAddress PointersBlockTargetAddress, unsigned NumStubs) {
+    llvm_unreachable(
+        "writeIndirectStubsBlock is not supported by the generic host "
+        "support class");
   }
 };
 
-/// Provide information about stub blocks generated by the
-///        makeIndirectStubsBlock function.
-template <unsigned StubSizeVal> class GenericIndirectStubsInfo {
-public:
-  const static unsigned StubSize = StubSizeVal;
-
-  GenericIndirectStubsInfo() = default;
-  GenericIndirectStubsInfo(unsigned NumStubs, sys::OwningMemoryBlock StubsMem)
-      : NumStubs(NumStubs), StubsMem(std::move(StubsMem)) {}
-  GenericIndirectStubsInfo(GenericIndirectStubsInfo &&Other)
-      : NumStubs(Other.NumStubs), StubsMem(std::move(Other.StubsMem)) {
-    Other.NumStubs = 0;
-  }
-
-  GenericIndirectStubsInfo &operator=(GenericIndirectStubsInfo &&Other) {
-    NumStubs = Other.NumStubs;
-    Other.NumStubs = 0;
-    StubsMem = std::move(Other.StubsMem);
-    return *this;
-  }
-
-  /// Number of stubs in this block.
-  unsigned getNumStubs() const { return NumStubs; }
-
-  /// Get a pointer to the stub at the given index, which must be in
-  ///        the range 0 .. getNumStubs() - 1.
-  void *getStub(unsigned Idx) const {
-    return static_cast<char *>(StubsMem.base()) + Idx * StubSize;
-  }
-
-  /// Get a pointer to the implementation-pointer at the given index,
-  ///        which must be in the range 0 .. getNumStubs() - 1.
-  void **getPtr(unsigned Idx) const {
-    char *PtrsBase = static_cast<char *>(StubsMem.base()) + NumStubs * StubSize;
-    return reinterpret_cast<void **>(PtrsBase) + Idx;
-  }
-
-private:
-  unsigned NumStubs = 0;
-  sys::OwningMemoryBlock StubsMem;
-};
-
 class OrcAArch64 {
 public:
-  static const unsigned PointerSize = 8;
-  static const unsigned TrampolineSize = 12;
-  static const unsigned ResolverCodeSize = 0x120;
+  static constexpr unsigned PointerSize = 8;
+  static constexpr unsigned TrampolineSize = 12;
+  static constexpr unsigned StubSize = 8;
+  static constexpr unsigned StubToPointerMaxDisplacement = 1U << 27;
+  static constexpr unsigned ResolverCodeSize = 0x120;
 
-  using IndirectStubsInfo = GenericIndirectStubsInfo<8>;
+  /// Write the resolver code into the given memory. The user is
+  /// responsible for allocating the memory and setting permissions.
+  ///
+  /// ReentryFnAddr should be the address of a function whose signature matches
+  /// void* (*)(void *TrampolineAddr, void *ReentryCtxAddr). The ReentryCtxAddr
+  /// argument of writeResolverCode will be passed as the second argument to
+  /// the function at ReentryFnAddr.
+  static void writeResolverCode(char *ResolverWorkingMem,
+                                JITTargetAddress ResolverTargetAddress,
+                                JITTargetAddress ReentryFnAddr,
+                                JITTargetAddress RentryCtxAddr);
 
-  using JITReentryFn = JITTargetAddress (*)(void *CallbackMgr,
-                                            void *TrampolineId);
-
-  /// Write the resolver code into the given memory. The user is be
-  ///        responsible for allocating the memory and setting permissions.
-  static void writeResolverCode(uint8_t *ResolveMem, JITReentryFn Reentry,
-                                void *CallbackMgr);
-
-  /// Write the requsted number of trampolines into the given memory,
-  ///        which must be big enough to hold 1 pointer, plus NumTrampolines
-  ///        trampolines.
-  static void writeTrampolines(uint8_t *TrampolineMem, void *ResolverAddr,
+  /// Write the requested number of trampolines into the given memory,
+  /// which must be big enough to hold 1 pointer, plus NumTrampolines
+  /// trampolines.
+  static void writeTrampolines(char *TrampolineBlockWorkingMem,
+                               JITTargetAddress TrampolineBlockTargetAddress,
+                               JITTargetAddress ResolverAddr,
                                unsigned NumTrampolines);
 
-  /// Emit at least MinStubs worth of indirect call stubs, rounded out to
-  ///        the nearest page size.
-  ///
-  ///   E.g. Asking for 4 stubs on x86-64, where stubs are 8-bytes, with 4k
-  /// pages will return a block of 512 stubs (4096 / 8 = 512). Asking for 513
-  /// will return a block of 1024 (2-pages worth).
-  static Error emitIndirectStubsBlock(IndirectStubsInfo &StubsInfo,
-                                      unsigned MinStubs, void *InitialPtrVal);
+  /// Write NumStubs indirect stubs to working memory at StubsBlockWorkingMem.
+  /// Stubs will be written as if linked at StubsBlockTargetAddress, with the
+  /// Nth stub using the Nth pointer in memory starting at
+  /// PointersBlockTargetAddress.
+  static void writeIndirectStubsBlock(
+      char *StubsBlockWorkingMem, JITTargetAddress StubsBlockTargetAddress,
+      JITTargetAddress PointersBlockTargetAddress, unsigned MinStubs);
 };
 
 /// X86_64 code that's common to all ABIs.
@@ -149,25 +128,26 @@
 /// X86_64 supports lazy JITing.
 class OrcX86_64_Base {
 public:
-  static const unsigned PointerSize = 8;
-  static const unsigned TrampolineSize = 8;
+  static constexpr unsigned PointerSize = 8;
+  static constexpr unsigned TrampolineSize = 8;
+  static constexpr unsigned StubSize = 8;
+  static constexpr unsigned StubToPointerMaxDisplacement = 1 << 31;
 
-  using IndirectStubsInfo = GenericIndirectStubsInfo<8>;
-
-  /// Write the requsted number of trampolines into the given memory,
-  ///        which must be big enough to hold 1 pointer, plus NumTrampolines
-  ///        trampolines.
-  static void writeTrampolines(uint8_t *TrampolineMem, void *ResolverAddr,
+  /// Write the requested number of trampolines into the given memory,
+  /// which must be big enough to hold 1 pointer, plus NumTrampolines
+  /// trampolines.
+  static void writeTrampolines(char *TrampolineBlockWorkingMem,
+                               JITTargetAddress TrampolineBlockTargetAddress,
+                               JITTargetAddress ResolverAddr,
                                unsigned NumTrampolines);
 
-  /// Emit at least MinStubs worth of indirect call stubs, rounded out to
-  ///        the nearest page size.
-  ///
-  ///   E.g. Asking for 4 stubs on x86-64, where stubs are 8-bytes, with 4k
-  /// pages will return a block of 512 stubs (4096 / 8 = 512). Asking for 513
-  /// will return a block of 1024 (2-pages worth).
-  static Error emitIndirectStubsBlock(IndirectStubsInfo &StubsInfo,
-                                      unsigned MinStubs, void *InitialPtrVal);
+  /// Write NumStubs indirect stubs to working memory at StubsBlockWorkingMem.
+  /// Stubs will be written as if linked at StubsBlockTargetAddress, with the
+  /// Nth stub using the Nth pointer in memory starting at
+  /// PointersBlockTargetAddress.
+  static void writeIndirectStubsBlock(
+      char *StubsBlockWorkingMem, JITTargetAddress StubsBlockTargetAddress,
+      JITTargetAddress PointersBlockTargetAddress, unsigned NumStubs);
 };
 
 /// X86_64 support for SysV ABI (Linux, MacOSX).
@@ -175,15 +155,19 @@
 /// X86_64_SysV supports lazy JITing.
 class OrcX86_64_SysV : public OrcX86_64_Base {
 public:
-  static const unsigned ResolverCodeSize = 0x6C;
+  static constexpr unsigned ResolverCodeSize = 0x6C;
 
-  using JITReentryFn = JITTargetAddress (*)(void *CallbackMgr,
-                                            void *TrampolineId);
-
-  /// Write the resolver code into the given memory. The user is be
-  ///        responsible for allocating the memory and setting permissions.
-  static void writeResolverCode(uint8_t *ResolveMem, JITReentryFn Reentry,
-                                void *CallbackMgr);
+  /// Write the resolver code into the given memory. The user is
+  /// responsible for allocating the memory and setting permissions.
+  ///
+  /// ReentryFnAddr should be the address of a function whose signature matches
+  /// void* (*)(void *TrampolineAddr, void *ReentryCtxAddr). The ReentryCtxAddr
+  /// argument of writeResolverCode will be passed as the second argument to
+  /// the function at ReentryFnAddr.
+  static void writeResolverCode(char *ResolverWorkingMem,
+                                JITTargetAddress ResolverTargetAddress,
+                                JITTargetAddress ReentryFnAddr,
+                                JITTargetAddress ReentryCtxAddr);
 };
 
 /// X86_64 support for Win32.
@@ -191,15 +175,19 @@
 /// X86_64_Win32 supports lazy JITing.
 class OrcX86_64_Win32 : public OrcX86_64_Base {
 public:
-  static const unsigned ResolverCodeSize = 0x74;
+  static constexpr unsigned ResolverCodeSize = 0x74;
 
-  using JITReentryFn = JITTargetAddress (*)(void *CallbackMgr,
-                                            void *TrampolineId);
-
-  /// Write the resolver code into the given memory. The user is be
-  ///        responsible for allocating the memory and setting permissions.
-  static void writeResolverCode(uint8_t *ResolveMem, JITReentryFn Reentry,
-                                void *CallbackMgr);
+  /// Write the resolver code into the given memory. The user is
+  /// responsible for allocating the memory and setting permissions.
+  ///
+  /// ReentryFnAddr should be the address of a function whose signature matches
+  /// void* (*)(void *TrampolineAddr, void *ReentryCtxAddr). The ReentryCtxAddr
+  /// argument of writeResolverCode will be passed as the second argument to
+  /// the function at ReentryFnAddr.
+  static void writeResolverCode(char *ResolverWorkingMem,
+                                JITTargetAddress ResolverTargetAddress,
+                                JITTargetAddress ReentryFnAddr,
+                                JITTargetAddress ReentryCtxAddr);
 };
 
 /// I386 support.
@@ -207,34 +195,39 @@
 /// I386 supports lazy JITing.
 class OrcI386 {
 public:
-  static const unsigned PointerSize = 4;
-  static const unsigned TrampolineSize = 8;
-  static const unsigned ResolverCodeSize = 0x4a;
+  static constexpr unsigned PointerSize = 4;
+  static constexpr unsigned TrampolineSize = 8;
+  static constexpr unsigned StubSize = 8;
+  static constexpr unsigned StubToPointerMaxDisplacement = 1 << 31;
+  static constexpr unsigned ResolverCodeSize = 0x4a;
 
-  using IndirectStubsInfo = GenericIndirectStubsInfo<8>;
+  /// Write the resolver code into the given memory. The user is
+  /// responsible for allocating the memory and setting permissions.
+  ///
+  /// ReentryFnAddr should be the address of a function whose signature matches
+  /// void* (*)(void *TrampolineAddr, void *ReentryCtxAddr). The ReentryCtxAddr
+  /// argument of writeResolverCode will be passed as the second argument to
+  /// the function at ReentryFnAddr.
+  static void writeResolverCode(char *ResolverWorkingMem,
+                                JITTargetAddress ResolverTargetAddress,
+                                JITTargetAddress ReentryFnAddr,
+                                JITTargetAddress ReentryCtxAddr);
 
-  using JITReentryFn = JITTargetAddress (*)(void *CallbackMgr,
-                                            void *TrampolineId);
-
-  /// Write the resolver code into the given memory. The user is be
-  ///        responsible for allocating the memory and setting permissions.
-  static void writeResolverCode(uint8_t *ResolveMem, JITReentryFn Reentry,
-                                void *CallbackMgr);
-
-  /// Write the requsted number of trampolines into the given memory,
-  ///        which must be big enough to hold 1 pointer, plus NumTrampolines
-  ///        trampolines.
-  static void writeTrampolines(uint8_t *TrampolineMem, void *ResolverAddr,
+  /// Write the requested number of trampolines into the given memory,
+  /// which must be big enough to hold 1 pointer, plus NumTrampolines
+  /// trampolines.
+  static void writeTrampolines(char *TrampolineBlockWorkingMem,
+                               JITTargetAddress TrampolineBlockTargetAddress,
+                               JITTargetAddress ResolverAddr,
                                unsigned NumTrampolines);
 
-  /// Emit at least MinStubs worth of indirect call stubs, rounded out to
-  ///        the nearest page size.
-  ///
-  ///   E.g. Asking for 4 stubs on i386, where stubs are 8-bytes, with 4k
-  /// pages will return a block of 512 stubs (4096 / 8 = 512). Asking for 513
-  /// will return a block of 1024 (2-pages worth).
-  static Error emitIndirectStubsBlock(IndirectStubsInfo &StubsInfo,
-                                      unsigned MinStubs, void *InitialPtrVal);
+  /// Write NumStubs indirect stubs to working memory at StubsBlockWorkingMem.
+  /// Stubs will be written as if linked at StubsBlockTargetAddress, with the
+  /// Nth stub using the Nth pointer in memory starting at
+  /// PointersBlockTargetAddress.
+  static void writeIndirectStubsBlock(
+      char *StubsBlockWorkingMem, JITTargetAddress StubsBlockTargetAddress,
+      JITTargetAddress PointersBlockTargetAddress, unsigned NumStubs);
 };
 
 // @brief Mips32 support.
@@ -242,41 +235,61 @@
 // Mips32 supports lazy JITing.
 class OrcMips32_Base {
 public:
-  static const unsigned PointerSize = 4;
-  static const unsigned TrampolineSize = 20;
-  static const unsigned ResolverCodeSize = 0xfc;
-  using IndirectStubsInfo = GenericIndirectStubsInfo<16>;
+  static constexpr unsigned PointerSize = 4;
+  static constexpr unsigned TrampolineSize = 20;
+  static constexpr unsigned StubSize = 8;
+  static constexpr unsigned StubToPointerMaxDisplacement = 1 << 31;
+  static constexpr unsigned ResolverCodeSize = 0xfc;
 
-  using JITReentryFn = JITTargetAddress (*)(void *CallbackMgr,
-                                            void *TrampolineId);
-  /// @brief Write the requsted number of trampolines into the given memory,
-  ///        which must be big enough to hold 1 pointer, plus NumTrampolines
-  ///        trampolines.
-  static void writeTrampolines(uint8_t *TrampolineMem, void *ResolverAddr,unsigned NumTrampolines);
+  /// Write the requested number of trampolines into the given memory,
+  /// which must be big enough to hold 1 pointer, plus NumTrampolines
+  /// trampolines.
+  static void writeTrampolines(char *TrampolineBlockWorkingMem,
+                               JITTargetAddress TrampolineBlockTargetAddress,
+                               JITTargetAddress ResolverAddr,
+                               unsigned NumTrampolines);
 
-  /// @brief Write the resolver code into the given memory. The user is be
-  ///        responsible for allocating the memory and setting permissions.
-  static void writeResolverCode(uint8_t *ResolveMem, JITReentryFn Reentry,void *CallbackMgr, bool isBigEndian);
-  /// @brief Emit at least MinStubs worth of indirect call stubs, rounded out to
-  ///        the nearest page size.
+  /// Write the resolver code into the given memory. The user is
+  /// responsible for allocating the memory and setting permissions.
   ///
-  ///   E.g. Asking for 4 stubs on Mips32, where stubs are 8-bytes, with 4k
-  /// pages will return a block of 512 stubs (4096 / 8 = 512). Asking for 513
-  /// will return a block of 1024 (2-pages worth).
-  static Error emitIndirectStubsBlock(IndirectStubsInfo &StubsInfo,unsigned MinStubs, void *InitialPtrVal);
+  /// ReentryFnAddr should be the address of a function whose signature matches
+  /// void* (*)(void *TrampolineAddr, void *ReentryCtxAddr). The ReentryCtxAddr
+  /// argument of writeResolverCode will be passed as the second argument to
+  /// the function at ReentryFnAddr.
+  static void writeResolverCode(char *ResolverBlockWorkingMem,
+                                JITTargetAddress ResolverBlockTargetAddress,
+                                JITTargetAddress ReentryFnAddr,
+                                JITTargetAddress ReentryCtxAddr,
+                                bool isBigEndian);
+  /// Write NumStubs indirect stubs to working memory at StubsBlockWorkingMem.
+  /// Stubs will be written as if linked at StubsBlockTargetAddress, with the
+  /// Nth stub using the Nth pointer in memory starting at
+  /// PointersBlockTargetAddress.
+  static void writeIndirectStubsBlock(
+      char *StubsBlockWorkingMem, JITTargetAddress StubsBlockTargetAddress,
+      JITTargetAddress PointersBlockTargetAddress, unsigned NumStubs);
 };
 
-
 class OrcMips32Le : public OrcMips32_Base {
 public:
-  static void writeResolverCode(uint8_t *ResolveMem, JITReentryFn Reentry,void *CallbackMgr)
-  { OrcMips32_Base::writeResolverCode(ResolveMem, Reentry, CallbackMgr, false); }
+  static void writeResolverCode(char *ResolverWorkingMem,
+                                JITTargetAddress ResolverTargetAddress,
+                                JITTargetAddress ReentryFnAddr,
+                                JITTargetAddress ReentryCtxAddr) {
+    OrcMips32_Base::writeResolverCode(ResolverWorkingMem, ResolverTargetAddress,
+                                      ReentryFnAddr, ReentryCtxAddr, false);
+  }
 };
 
 class OrcMips32Be : public OrcMips32_Base {
 public:
-  static void writeResolverCode(uint8_t *ResolveMem, JITReentryFn Reentry,void *CallbackMgr)
-  { OrcMips32_Base::writeResolverCode(ResolveMem, Reentry, CallbackMgr, true); }
+  static void writeResolverCode(char *ResolverWorkingMem,
+                                JITTargetAddress ResolverTargetAddress,
+                                JITTargetAddress ReentryFnAddr,
+                                JITTargetAddress ReentryCtxAddr) {
+    OrcMips32_Base::writeResolverCode(ResolverWorkingMem, ResolverTargetAddress,
+                                      ReentryFnAddr, ReentryCtxAddr, true);
+  }
 };
 
 // @brief Mips64 support.
@@ -284,31 +297,41 @@
 // Mips64 supports lazy JITing.
 class OrcMips64 {
 public:
-  static const unsigned PointerSize = 8;
-  static const unsigned TrampolineSize = 40;
-  static const unsigned ResolverCodeSize = 0x120;
+  static constexpr unsigned PointerSize = 8;
+  static constexpr unsigned TrampolineSize = 40;
+  static constexpr unsigned StubSize = 32;
+  static constexpr unsigned StubToPointerMaxDisplacement = 1 << 31;
+  static constexpr unsigned ResolverCodeSize = 0x120;
 
-  using IndirectStubsInfo = GenericIndirectStubsInfo<32>;
-  using JITReentryFn = JITTargetAddress (*)(void *CallbackMgr,
-                                            void *TrampolineId);
-  /// @brief Write the resolver code into the given memory. The user is be
-  ///        responsible for allocating the memory and setting permissions.
-  static void writeResolverCode(uint8_t *ResolveMem, JITReentryFn Reentry,void *CallbackMgr);
-
-  /// @brief Write the requsted number of trampolines into the given memory,
-  ///        which must be big enough to hold 1 pointer, plus NumTrampolines
-  ///        trampolines.
-  static void writeTrampolines(uint8_t *TrampolineMem, void *ResolverAddr,unsigned NumTrampolines);
-
-  /// @brief Emit at least MinStubs worth of indirect call stubs, rounded out to
-  ///        the nearest page size.
+  /// Write the resolver code into the given memory. The user is
+  /// responsible for allocating the memory and setting permissions.
   ///
-  ///   E.g. Asking for 4 stubs on Mips64, where stubs are 8-bytes, with 4k
-  /// pages will return a block of 512 stubs (4096 / 8 = 512). Asking for 513
-  /// will return a block of 1024 (2-pages worth).
-  static Error emitIndirectStubsBlock(IndirectStubsInfo &StubsInfo,unsigned MinStubs, void *InitialPtrVal);
+  /// ReentryFnAddr should be the address of a function whose signature matches
+  /// void* (*)(void *TrampolineAddr, void *ReentryCtxAddr). The ReentryCtxAddr
+  /// argument of writeResolverCode will be passed as the second argument to
+  /// the function at ReentryFnAddr.
+  static void writeResolverCode(char *ResolverWorkingMem,
+                                JITTargetAddress ResolverTargetAddress,
+                                JITTargetAddress ReentryFnAddr,
+                                JITTargetAddress ReentryCtxAddr);
+
+  /// Write the requested number of trampolines into the given memory,
+  /// which must be big enough to hold 1 pointer, plus NumTrampolines
+  /// trampolines.
+  static void writeTrampolines(char *TrampolineBlockWorkingMem,
+                               JITTargetAddress TrampolineBlockTargetAddress,
+                               JITTargetAddress ResolverFnAddr,
+                               unsigned NumTrampolines);
+  /// Write NumStubs indirect stubs to working memory at StubsBlockWorkingMem.
+  /// Stubs will be written as if linked at StubsBlockTargetAddress, with the
+  /// Nth stub using the Nth pointer in memory starting at
+  /// PointersBlockTargetAddress.
+  static void writeIndirectStubsBlock(
+      char *StubsBlockWorkingMem, JITTargetAddress StubsBlockTargetAddress,
+      JITTargetAddress PointersBlockTargetAddress, unsigned NumStubs);
 };
 
- } // end namespace orc
- } // end namespace llvm
+} // end namespace orc
+} // end namespace llvm
+
 #endif // LLVM_EXECUTIONENGINE_ORC_ORCABISUPPORT_H
diff --git a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/OrcError.h b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/OrcError.h
index e5d6a3e..9b0d941 100644
--- a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/OrcError.h
+++ b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/OrcError.h
@@ -14,6 +14,8 @@
 #define LLVM_EXECUTIONENGINE_ORC_ORCERROR_H
 
 #include "llvm/Support/Error.h"
+#include "llvm/Support/raw_ostream.h"
+#include <string>
 #include <system_error>
 
 namespace llvm {
@@ -35,7 +37,9 @@
   UnexpectedRPCCall,
   UnexpectedRPCResponse,
   UnknownErrorCodeFromRemote,
-  UnknownResourceHandle
+  UnknownResourceHandle,
+  MissingSymbolDefinitions,
+  UnexpectedSymbolDefinitions,
 };
 
 std::error_code orcError(OrcErrorCode ErrCode);
diff --git a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/OrcRPCTargetProcessControl.h b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/OrcRPCTargetProcessControl.h
new file mode 100644
index 0000000..1097ae6
--- /dev/null
+++ b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/OrcRPCTargetProcessControl.h
@@ -0,0 +1,415 @@
+//===--- OrcRPCTargetProcessControl.h - Remote target control ---*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Utilities for interacting with target processes.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_EXECUTIONENGINE_ORC_ORCRPCTARGETPROCESSCONTROL_H
+#define LLVM_EXECUTIONENGINE_ORC_ORCRPCTARGETPROCESSCONTROL_H
+
+#include "llvm/ExecutionEngine/Orc/Shared/RPCUtils.h"
+#include "llvm/ExecutionEngine/Orc/Shared/RawByteChannel.h"
+#include "llvm/ExecutionEngine/Orc/TargetProcess/OrcRPCTPCServer.h"
+#include "llvm/ExecutionEngine/Orc/TargetProcessControl.h"
+#include "llvm/Support/MSVCErrorWorkarounds.h"
+
+namespace llvm {
+namespace orc {
+
+/// JITLinkMemoryManager implementation for a process connected via an ORC RPC
+/// endpoint.
+template <typename OrcRPCTPCImplT>
+class OrcRPCTPCJITLinkMemoryManager : public jitlink::JITLinkMemoryManager {
+private:
+  struct HostAlloc {
+    std::unique_ptr<char[]> Mem;
+    uint64_t Size;
+  };
+
+  struct TargetAlloc {
+    JITTargetAddress Address = 0;
+    uint64_t AllocatedSize = 0;
+  };
+
+  using HostAllocMap = DenseMap<int, HostAlloc>;
+  using TargetAllocMap = DenseMap<int, TargetAlloc>;
+
+public:
+  class OrcRPCAllocation : public Allocation {
+  public:
+    OrcRPCAllocation(OrcRPCTPCJITLinkMemoryManager<OrcRPCTPCImplT> &Parent,
+                     HostAllocMap HostAllocs, TargetAllocMap TargetAllocs)
+        : Parent(Parent), HostAllocs(std::move(HostAllocs)),
+          TargetAllocs(std::move(TargetAllocs)) {
+      assert(HostAllocs.size() == TargetAllocs.size() &&
+             "HostAllocs size should match TargetAllocs");
+    }
+
+    ~OrcRPCAllocation() override {
+      assert(TargetAllocs.empty() && "failed to deallocate");
+    }
+
+    MutableArrayRef<char> getWorkingMemory(ProtectionFlags Seg) override {
+      auto I = HostAllocs.find(Seg);
+      assert(I != HostAllocs.end() && "No host allocation for segment");
+      auto &HA = I->second;
+      return {HA.Mem.get(), static_cast<size_t>(HA.Size)};
+    }
+
+    JITTargetAddress getTargetMemory(ProtectionFlags Seg) override {
+      auto I = TargetAllocs.find(Seg);
+      assert(I != TargetAllocs.end() && "No target allocation for segment");
+      return I->second.Address;
+    }
+
+    void finalizeAsync(FinalizeContinuation OnFinalize) override {
+
+      std::vector<tpctypes::BufferWrite> BufferWrites;
+      orcrpctpc::ReleaseOrFinalizeMemRequest FMR;
+
+      for (auto &KV : HostAllocs) {
+        assert(TargetAllocs.count(KV.first) &&
+               "No target allocation for buffer");
+        auto &HA = KV.second;
+        auto &TA = TargetAllocs[KV.first];
+        BufferWrites.push_back({TA.Address, StringRef(HA.Mem.get(), HA.Size)});
+        FMR.push_back({orcrpctpc::toWireProtectionFlags(
+                           static_cast<sys::Memory::ProtectionFlags>(KV.first)),
+                       TA.Address, TA.AllocatedSize});
+      }
+
+      DEBUG_WITH_TYPE("orc", {
+        dbgs() << "finalizeAsync " << (void *)this << ":\n";
+        auto FMRI = FMR.begin();
+        for (auto &B : BufferWrites) {
+          auto Prot = FMRI->Prot;
+          ++FMRI;
+          dbgs() << "  Writing " << formatv("{0:x16}", B.Buffer.size())
+                 << " bytes to " << ((Prot & orcrpctpc::WPF_Read) ? 'R' : '-')
+                 << ((Prot & orcrpctpc::WPF_Write) ? 'W' : '-')
+                 << ((Prot & orcrpctpc::WPF_Exec) ? 'X' : '-')
+                 << " segment: local " << (const void *)B.Buffer.data()
+                 << " -> target " << formatv("{0:x16}", B.Address) << "\n";
+        }
+      });
+      if (auto Err =
+              Parent.Parent.getMemoryAccess().writeBuffers(BufferWrites)) {
+        OnFinalize(std::move(Err));
+        return;
+      }
+
+      DEBUG_WITH_TYPE("orc", dbgs() << " Applying permissions...\n");
+      if (auto Err =
+              Parent.getEndpoint().template callAsync<orcrpctpc::FinalizeMem>(
+                  [OF = std::move(OnFinalize)](Error Err2) {
+                    // FIXME: Dispatch to work queue.
+                    std::thread([OF = std::move(OF),
+                                 Err3 = std::move(Err2)]() mutable {
+                      DEBUG_WITH_TYPE(
+                          "orc", { dbgs() << "  finalizeAsync complete\n"; });
+                      OF(std::move(Err3));
+                    }).detach();
+                    return Error::success();
+                  },
+                  FMR)) {
+        DEBUG_WITH_TYPE("orc", dbgs() << "    failed.\n");
+        Parent.getEndpoint().abandonPendingResponses();
+        Parent.reportError(std::move(Err));
+      }
+      DEBUG_WITH_TYPE("orc", {
+        dbgs() << "Leaving finalizeAsync (finalization may continue in "
+                  "background)\n";
+      });
+    }
+
+    Error deallocate() override {
+      orcrpctpc::ReleaseOrFinalizeMemRequest RMR;
+      for (auto &KV : TargetAllocs)
+        RMR.push_back({orcrpctpc::toWireProtectionFlags(
+                           static_cast<sys::Memory::ProtectionFlags>(KV.first)),
+                       KV.second.Address, KV.second.AllocatedSize});
+      TargetAllocs.clear();
+
+      return Parent.getEndpoint().template callB<orcrpctpc::ReleaseMem>(RMR);
+    }
+
+  private:
+    OrcRPCTPCJITLinkMemoryManager<OrcRPCTPCImplT> &Parent;
+    HostAllocMap HostAllocs;
+    TargetAllocMap TargetAllocs;
+  };
+
+  OrcRPCTPCJITLinkMemoryManager(OrcRPCTPCImplT &Parent) : Parent(Parent) {}
+
+  Expected<std::unique_ptr<Allocation>>
+  allocate(const jitlink::JITLinkDylib *JD,
+           const SegmentsRequestMap &Request) override {
+    orcrpctpc::ReserveMemRequest RMR;
+    HostAllocMap HostAllocs;
+
+    for (auto &KV : Request) {
+      assert(KV.second.getContentSize() <= std::numeric_limits<size_t>::max() &&
+             "Content size is out-of-range for host");
+
+      RMR.push_back({orcrpctpc::toWireProtectionFlags(
+                         static_cast<sys::Memory::ProtectionFlags>(KV.first)),
+                     KV.second.getContentSize() + KV.second.getZeroFillSize(),
+                     KV.second.getAlignment()});
+      HostAllocs[KV.first] = {
+          std::make_unique<char[]>(KV.second.getContentSize()),
+          KV.second.getContentSize()};
+    }
+
+    DEBUG_WITH_TYPE("orc", {
+      dbgs() << "Orc remote memmgr got request:\n";
+      for (auto &KV : Request)
+        dbgs() << "  permissions: "
+               << ((KV.first & sys::Memory::MF_READ) ? 'R' : '-')
+               << ((KV.first & sys::Memory::MF_WRITE) ? 'W' : '-')
+               << ((KV.first & sys::Memory::MF_EXEC) ? 'X' : '-')
+               << ", content size: "
+               << formatv("{0:x16}", KV.second.getContentSize())
+               << " + zero-fill-size: "
+               << formatv("{0:x16}", KV.second.getZeroFillSize())
+               << ", align: " << KV.second.getAlignment() << "\n";
+    });
+
+    // FIXME: LLVM RPC needs to be fixed to support alt
+    // serialization/deserialization on return types. For now just
+    // translate from std::map to DenseMap manually.
+    auto TmpTargetAllocs =
+        Parent.getEndpoint().template callB<orcrpctpc::ReserveMem>(RMR);
+    if (!TmpTargetAllocs)
+      return TmpTargetAllocs.takeError();
+
+    if (TmpTargetAllocs->size() != RMR.size())
+      return make_error<StringError>(
+          "Number of target allocations does not match request",
+          inconvertibleErrorCode());
+
+    TargetAllocMap TargetAllocs;
+    for (auto &E : *TmpTargetAllocs)
+      TargetAllocs[orcrpctpc::fromWireProtectionFlags(E.Prot)] = {
+          E.Address, E.AllocatedSize};
+
+    DEBUG_WITH_TYPE("orc", {
+      auto HAI = HostAllocs.begin();
+      for (auto &KV : TargetAllocs)
+        dbgs() << "  permissions: "
+               << ((KV.first & sys::Memory::MF_READ) ? 'R' : '-')
+               << ((KV.first & sys::Memory::MF_WRITE) ? 'W' : '-')
+               << ((KV.first & sys::Memory::MF_EXEC) ? 'X' : '-')
+               << " assigned local " << (void *)HAI->second.Mem.get()
+               << ", target " << formatv("{0:x16}", KV.second.Address) << "\n";
+    });
+
+    return std::make_unique<OrcRPCAllocation>(*this, std::move(HostAllocs),
+                                              std::move(TargetAllocs));
+  }
+
+private:
+  void reportError(Error Err) { Parent.reportError(std::move(Err)); }
+
+  decltype(std::declval<OrcRPCTPCImplT>().getEndpoint()) getEndpoint() {
+    return Parent.getEndpoint();
+  }
+
+  OrcRPCTPCImplT &Parent;
+};
+
+/// TargetProcessControl::MemoryAccess implementation for a process connected
+/// via an ORC RPC endpoint.
+template <typename OrcRPCTPCImplT>
+class OrcRPCTPCMemoryAccess : public TargetProcessControl::MemoryAccess {
+public:
+  OrcRPCTPCMemoryAccess(OrcRPCTPCImplT &Parent) : Parent(Parent) {}
+
+  void writeUInt8s(ArrayRef<tpctypes::UInt8Write> Ws,
+                   WriteResultFn OnWriteComplete) override {
+    writeViaRPC<orcrpctpc::WriteUInt8s>(Ws, std::move(OnWriteComplete));
+  }
+
+  void writeUInt16s(ArrayRef<tpctypes::UInt16Write> Ws,
+                    WriteResultFn OnWriteComplete) override {
+    writeViaRPC<orcrpctpc::WriteUInt16s>(Ws, std::move(OnWriteComplete));
+  }
+
+  void writeUInt32s(ArrayRef<tpctypes::UInt32Write> Ws,
+                    WriteResultFn OnWriteComplete) override {
+    writeViaRPC<orcrpctpc::WriteUInt32s>(Ws, std::move(OnWriteComplete));
+  }
+
+  void writeUInt64s(ArrayRef<tpctypes::UInt64Write> Ws,
+                    WriteResultFn OnWriteComplete) override {
+    writeViaRPC<orcrpctpc::WriteUInt64s>(Ws, std::move(OnWriteComplete));
+  }
+
+  void writeBuffers(ArrayRef<tpctypes::BufferWrite> Ws,
+                    WriteResultFn OnWriteComplete) override {
+    writeViaRPC<orcrpctpc::WriteBuffers>(Ws, std::move(OnWriteComplete));
+  }
+
+private:
+  template <typename WriteRPCFunction, typename WriteElementT>
+  void writeViaRPC(ArrayRef<WriteElementT> Ws, WriteResultFn OnWriteComplete) {
+    if (auto Err = Parent.getEndpoint().template callAsync<WriteRPCFunction>(
+            [OWC = std::move(OnWriteComplete)](Error Err2) mutable -> Error {
+              OWC(std::move(Err2));
+              return Error::success();
+            },
+            Ws)) {
+      Parent.reportError(std::move(Err));
+      Parent.getEndpoint().abandonPendingResponses();
+    }
+  }
+
+  OrcRPCTPCImplT &Parent;
+};
+
+// TargetProcessControl for a process connected via an ORC RPC Endpoint.
+template <typename RPCEndpointT>
+class OrcRPCTargetProcessControlBase : public TargetProcessControl {
+public:
+  using ErrorReporter = unique_function<void(Error)>;
+
+  using OnCloseConnectionFunction = unique_function<Error(Error)>;
+
+  OrcRPCTargetProcessControlBase(std::shared_ptr<SymbolStringPool> SSP,
+                                 RPCEndpointT &EP, ErrorReporter ReportError)
+      : TargetProcessControl(std::move(SSP)),
+        ReportError(std::move(ReportError)), EP(EP) {}
+
+  void reportError(Error Err) { ReportError(std::move(Err)); }
+
+  RPCEndpointT &getEndpoint() { return EP; }
+
+  Expected<tpctypes::DylibHandle> loadDylib(const char *DylibPath) override {
+    DEBUG_WITH_TYPE("orc", {
+      dbgs() << "Loading dylib \"" << (DylibPath ? DylibPath : "") << "\" ";
+      if (!DylibPath)
+        dbgs() << "(process symbols)";
+      dbgs() << "\n";
+    });
+    if (!DylibPath)
+      DylibPath = "";
+    auto H = EP.template callB<orcrpctpc::LoadDylib>(DylibPath);
+    DEBUG_WITH_TYPE("orc", {
+      if (H)
+        dbgs() << "  got handle " << formatv("{0:x16}", *H) << "\n";
+      else
+        dbgs() << "  error, unable to load\n";
+    });
+    return H;
+  }
+
+  Expected<std::vector<tpctypes::LookupResult>>
+  lookupSymbols(ArrayRef<tpctypes::LookupRequest> Request) override {
+    std::vector<orcrpctpc::RemoteLookupRequest> RR;
+    for (auto &E : Request) {
+      RR.push_back({});
+      RR.back().first = E.Handle;
+      for (auto &KV : E.Symbols)
+        RR.back().second.push_back(
+            {(*KV.first).str(),
+             KV.second == SymbolLookupFlags::WeaklyReferencedSymbol});
+    }
+    DEBUG_WITH_TYPE("orc", {
+      dbgs() << "Compound lookup:\n";
+      for (auto &R : Request) {
+        dbgs() << "  In " << formatv("{0:x16}", R.Handle) << ": {";
+        bool First = true;
+        for (auto &KV : R.Symbols) {
+          dbgs() << (First ? "" : ",") << " " << *KV.first;
+          First = false;
+        }
+        dbgs() << " }\n";
+      }
+    });
+    return EP.template callB<orcrpctpc::LookupSymbols>(RR);
+  }
+
+  Expected<int32_t> runAsMain(JITTargetAddress MainFnAddr,
+                              ArrayRef<std::string> Args) override {
+    DEBUG_WITH_TYPE("orc", {
+      dbgs() << "Running as main: " << formatv("{0:x16}", MainFnAddr)
+             << ", args = [";
+      for (unsigned I = 0; I != Args.size(); ++I)
+        dbgs() << (I ? "," : "") << " \"" << Args[I] << "\"";
+      dbgs() << "]\n";
+    });
+    auto Result = EP.template callB<orcrpctpc::RunMain>(MainFnAddr, Args);
+    DEBUG_WITH_TYPE("orc", {
+      dbgs() << "  call to " << formatv("{0:x16}", MainFnAddr);
+      if (Result)
+        dbgs() << " returned result " << *Result << "\n";
+      else
+        dbgs() << " failed\n";
+    });
+    return Result;
+  }
+
+  Expected<tpctypes::WrapperFunctionResult>
+  runWrapper(JITTargetAddress WrapperFnAddr,
+             ArrayRef<uint8_t> ArgBuffer) override {
+    DEBUG_WITH_TYPE("orc", {
+      dbgs() << "Running as wrapper function "
+             << formatv("{0:x16}", WrapperFnAddr) << " with "
+             << formatv("{0:x16}", ArgBuffer.size()) << " argument buffer\n";
+    });
+    auto Result =
+        EP.template callB<orcrpctpc::RunWrapper>(WrapperFnAddr, ArgBuffer);
+    // dbgs() << "Returned from runWrapper...\n";
+    return Result;
+  }
+
+  Error closeConnection(OnCloseConnectionFunction OnCloseConnection) {
+    DEBUG_WITH_TYPE("orc", dbgs() << "Closing connection to remote\n");
+    return EP.template callAsync<orcrpctpc::CloseConnection>(
+        std::move(OnCloseConnection));
+  }
+
+  Error closeConnectionAndWait() {
+    std::promise<MSVCPError> P;
+    auto F = P.get_future();
+    if (auto Err = closeConnection([&](Error Err2) -> Error {
+          P.set_value(std::move(Err2));
+          return Error::success();
+        })) {
+      EP.abandonAllPendingResponses();
+      return joinErrors(std::move(Err), F.get());
+    }
+    return F.get();
+  }
+
+protected:
+  /// Subclasses must call this during construction to initialize the
+  /// TargetTriple and PageSize members.
+  Error initializeORCRPCTPCBase() {
+    if (auto TripleOrErr = EP.template callB<orcrpctpc::GetTargetTriple>())
+      TargetTriple = Triple(*TripleOrErr);
+    else
+      return TripleOrErr.takeError();
+
+    if (auto PageSizeOrErr = EP.template callB<orcrpctpc::GetPageSize>())
+      PageSize = *PageSizeOrErr;
+    else
+      return PageSizeOrErr.takeError();
+
+    return Error::success();
+  }
+
+private:
+  ErrorReporter ReportError;
+  RPCEndpointT &EP;
+};
+
+} // end namespace orc
+} // end namespace llvm
+
+#endif // LLVM_EXECUTIONENGINE_ORC_ORCRPCTARGETPROCESSCONTROL_H
diff --git a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetClient.h b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetClient.h
index 8b875b7..3d13974 100644
--- a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetClient.h
+++ b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetClient.h
@@ -20,6 +20,7 @@
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ExecutionEngine/JITSymbol.h"
+#include "llvm/ExecutionEngine/JITLink/JITLinkMemoryManager.h"
 #include "llvm/ExecutionEngine/Orc/IndirectionUtils.h"
 #include "llvm/ExecutionEngine/Orc/OrcRemoteTargetRPCAPI.h"
 #include "llvm/ExecutionEngine/RuntimeDyld.h"
@@ -53,7 +54,7 @@
 /// OrcRemoteTargetServer class) via an RPC system (see RPCUtils.h) to carry out
 /// its actions.
 class OrcRemoteTargetClient
-    : public rpc::SingleThreadedRPCEndpoint<rpc::RawByteChannel> {
+    : public shared::SingleThreadedRPCEndpoint<shared::RawByteChannel> {
 public:
   /// Remote-mapped RuntimeDyld-compatible memory manager.
   class RemoteRTDyldMemoryManager : public RuntimeDyld::MemoryManager {
@@ -329,6 +330,221 @@
     std::vector<EHFrame> RegisteredEHFrames;
   };
 
+  class RPCMMAlloc : public jitlink::JITLinkMemoryManager::Allocation {
+    using AllocationMap = DenseMap<unsigned, sys::MemoryBlock>;
+    using FinalizeContinuation =
+        jitlink::JITLinkMemoryManager::Allocation::FinalizeContinuation;
+    using ProtectionFlags = sys::Memory::ProtectionFlags;
+    using SegmentsRequestMap =
+        DenseMap<unsigned, jitlink::JITLinkMemoryManager::SegmentRequest>;
+
+    RPCMMAlloc(OrcRemoteTargetClient &Client, ResourceIdMgr::ResourceId Id)
+        : Client(Client), Id(Id) {}
+
+  public:
+    static Expected<std::unique_ptr<RPCMMAlloc>>
+    Create(OrcRemoteTargetClient &Client, ResourceIdMgr::ResourceId Id,
+           const SegmentsRequestMap &Request) {
+      auto *MM = new RPCMMAlloc(Client, Id);
+
+      if (Error Err = MM->allocateHostBlocks(Request))
+        return std::move(Err);
+
+      if (Error Err = MM->allocateTargetBlocks())
+        return std::move(Err);
+
+      return std::unique_ptr<RPCMMAlloc>(MM);
+    }
+
+    MutableArrayRef<char> getWorkingMemory(ProtectionFlags Seg) override {
+      assert(HostSegBlocks.count(Seg) && "No allocation for segment");
+      return {static_cast<char *>(HostSegBlocks[Seg].base()),
+              HostSegBlocks[Seg].allocatedSize()};
+    }
+
+    JITTargetAddress getTargetMemory(ProtectionFlags Seg) override {
+      assert(TargetSegBlocks.count(Seg) && "No allocation for segment");
+      return pointerToJITTargetAddress(TargetSegBlocks[Seg].base());
+    }
+
+    void finalizeAsync(FinalizeContinuation OnFinalize) override {
+      // Host allocations (working memory) remain ReadWrite.
+      OnFinalize(copyAndProtect());
+    }
+
+    Error deallocate() override {
+      // TODO: Cannot release target allocation. RPCAPI has no function
+      // symmetric to reserveMem(). Add RPC call like freeMem()?
+      return errorCodeToError(sys::Memory::releaseMappedMemory(HostAllocation));
+    }
+
+  private:
+    OrcRemoteTargetClient &Client;
+    ResourceIdMgr::ResourceId Id;
+    AllocationMap HostSegBlocks;
+    AllocationMap TargetSegBlocks;
+    JITTargetAddress TargetSegmentAddr;
+    sys::MemoryBlock HostAllocation;
+
+    Error allocateHostBlocks(const SegmentsRequestMap &Request) {
+      unsigned TargetPageSize = Client.getPageSize();
+
+      if (!isPowerOf2_64(static_cast<uint64_t>(TargetPageSize)))
+        return make_error<StringError>("Host page size is not a power of 2",
+                                       inconvertibleErrorCode());
+
+      auto TotalSize = calcTotalAllocSize(Request, TargetPageSize);
+      if (!TotalSize)
+        return TotalSize.takeError();
+
+      // Allocate one slab to cover all the segments.
+      const sys::Memory::ProtectionFlags ReadWrite =
+          static_cast<sys::Memory::ProtectionFlags>(sys::Memory::MF_READ |
+                                                    sys::Memory::MF_WRITE);
+      std::error_code EC;
+      HostAllocation =
+          sys::Memory::allocateMappedMemory(*TotalSize, nullptr, ReadWrite, EC);
+      if (EC)
+        return errorCodeToError(EC);
+
+      char *SlabAddr = static_cast<char *>(HostAllocation.base());
+#ifndef NDEBUG
+      char *SlabAddrEnd = SlabAddr + HostAllocation.allocatedSize();
+#endif
+
+      // Allocate segment memory from the slab.
+      for (auto &KV : Request) {
+        const auto &Seg = KV.second;
+
+        uint64_t SegmentSize = Seg.getContentSize() + Seg.getZeroFillSize();
+        uint64_t AlignedSegmentSize = alignTo(SegmentSize, TargetPageSize);
+
+        // Zero out zero-fill memory.
+        char *ZeroFillBegin = SlabAddr + Seg.getContentSize();
+        memset(ZeroFillBegin, 0, Seg.getZeroFillSize());
+
+        // Record the block for this segment.
+        HostSegBlocks[KV.first] =
+            sys::MemoryBlock(SlabAddr, AlignedSegmentSize);
+
+        SlabAddr += AlignedSegmentSize;
+        assert(SlabAddr <= SlabAddrEnd && "Out of range");
+      }
+
+      return Error::success();
+    }
+
+    Error allocateTargetBlocks() {
+      // Reserve memory for all blocks on the target. We need as much space on
+      // the target as we allocated on the host.
+      TargetSegmentAddr = Client.reserveMem(Id, HostAllocation.allocatedSize(),
+                                            Client.getPageSize());
+      if (!TargetSegmentAddr)
+        return make_error<StringError>("Failed to reserve memory on the target",
+                                       inconvertibleErrorCode());
+
+      // Map memory blocks into the allocation, that match the host allocation.
+      JITTargetAddress TargetAllocAddr = TargetSegmentAddr;
+      for (const auto &KV : HostSegBlocks) {
+        size_t TargetAllocSize = KV.second.allocatedSize();
+
+        TargetSegBlocks[KV.first] =
+            sys::MemoryBlock(jitTargetAddressToPointer<void *>(TargetAllocAddr),
+                             TargetAllocSize);
+
+        TargetAllocAddr += TargetAllocSize;
+        assert(TargetAllocAddr - TargetSegmentAddr <=
+                   HostAllocation.allocatedSize() &&
+               "Out of range on target");
+      }
+
+      return Error::success();
+    }
+
+    Error copyAndProtect() {
+      unsigned Permissions = 0u;
+
+      // Copy segments one by one.
+      for (auto &KV : TargetSegBlocks) {
+        Permissions |= KV.first;
+
+        const sys::MemoryBlock &TargetBlock = KV.second;
+        const sys::MemoryBlock &HostBlock = HostSegBlocks.lookup(KV.first);
+
+        size_t TargetAllocSize = TargetBlock.allocatedSize();
+        auto TargetAllocAddr = pointerToJITTargetAddress(TargetBlock.base());
+        auto *HostAllocBegin = static_cast<const char *>(HostBlock.base());
+
+        bool CopyErr =
+            Client.writeMem(TargetAllocAddr, HostAllocBegin, TargetAllocSize);
+        if (CopyErr)
+          return createStringError(inconvertibleErrorCode(),
+                                   "Failed to copy %d segment to the target",
+                                   KV.first);
+      }
+
+      // Set permission flags for all segments at once.
+      bool ProtectErr =
+          Client.setProtections(Id, TargetSegmentAddr, Permissions);
+      if (ProtectErr)
+        return createStringError(inconvertibleErrorCode(),
+                                 "Failed to apply permissions for %d segment "
+                                 "on the target",
+                                 Permissions);
+      return Error::success();
+    }
+
+    static Expected<size_t>
+    calcTotalAllocSize(const SegmentsRequestMap &Request,
+                       unsigned TargetPageSize) {
+      size_t TotalSize = 0;
+      for (const auto &KV : Request) {
+        const auto &Seg = KV.second;
+
+        if (Seg.getAlignment() > TargetPageSize)
+          return make_error<StringError>("Cannot request alignment higher than "
+                                         "page alignment on target",
+                                         inconvertibleErrorCode());
+
+        TotalSize = alignTo(TotalSize, TargetPageSize);
+        TotalSize += Seg.getContentSize();
+        TotalSize += Seg.getZeroFillSize();
+      }
+
+      return TotalSize;
+    }
+  };
+
+  class RemoteJITLinkMemoryManager : public jitlink::JITLinkMemoryManager {
+  public:
+    RemoteJITLinkMemoryManager(OrcRemoteTargetClient &Client,
+                               ResourceIdMgr::ResourceId Id)
+        : Client(Client), Id(Id) {}
+
+    RemoteJITLinkMemoryManager(const RemoteJITLinkMemoryManager &) = delete;
+    RemoteJITLinkMemoryManager(RemoteJITLinkMemoryManager &&) = default;
+
+    RemoteJITLinkMemoryManager &
+    operator=(const RemoteJITLinkMemoryManager &) = delete;
+    RemoteJITLinkMemoryManager &
+    operator=(RemoteJITLinkMemoryManager &&) = delete;
+
+    ~RemoteJITLinkMemoryManager() {
+      Client.destroyRemoteAllocator(Id);
+      LLVM_DEBUG(dbgs() << "Destroyed remote allocator " << Id << "\n");
+    }
+
+    Expected<std::unique_ptr<Allocation>>
+    allocate(const jitlink::JITLinkDylib *JD,
+             const SegmentsRequestMap &Request) override {
+      return RPCMMAlloc::Create(Client, Id, Request);
+    }
+
+  private:
+    OrcRemoteTargetClient &Client;
+    ResourceIdMgr::ResourceId Id;
+  };
+
   /// Remote indirect stubs manager.
   class RemoteIndirectStubsManager : public IndirectStubsManager {
   public:
@@ -453,20 +669,8 @@
   public:
     RemoteTrampolinePool(OrcRemoteTargetClient &Client) : Client(Client) {}
 
-    Expected<JITTargetAddress> getTrampoline() override {
-      std::lock_guard<std::mutex> Lock(RTPMutex);
-      if (AvailableTrampolines.empty()) {
-        if (auto Err = grow())
-          return std::move(Err);
-      }
-      assert(!AvailableTrampolines.empty() && "Failed to grow trampoline pool");
-      auto TrampolineAddr = AvailableTrampolines.back();
-      AvailableTrampolines.pop_back();
-      return TrampolineAddr;
-    }
-
   private:
-    Error grow() {
+    Error grow() override {
       JITTargetAddress BlockAddr = 0;
       uint32_t NumTrampolines = 0;
       if (auto TrampolineInfoOrErr = Client.emitTrampolineBlock())
@@ -476,14 +680,12 @@
 
       uint32_t TrampolineSize = Client.getTrampolineSize();
       for (unsigned I = 0; I < NumTrampolines; ++I)
-        this->AvailableTrampolines.push_back(BlockAddr + (I * TrampolineSize));
+        AvailableTrampolines.push_back(BlockAddr + (I * TrampolineSize));
 
       return Error::success();
     }
 
-    std::mutex RTPMutex;
     OrcRemoteTargetClient &Client;
-    std::vector<JITTargetAddress> AvailableTrampolines;
   };
 
   /// Remote compile callback manager.
@@ -493,7 +695,7 @@
                                  ExecutionSession &ES,
                                  JITTargetAddress ErrorHandlerAddress)
         : JITCompileCallbackManager(
-              llvm::make_unique<RemoteTrampolinePool>(Client), ES,
+              std::make_unique<RemoteTrampolinePool>(Client), ES,
               ErrorHandlerAddress) {}
   };
 
@@ -501,7 +703,7 @@
   /// Channel is the ChannelT instance to communicate on. It is assumed that
   /// the channel is ready to be read from and written to.
   static Expected<std::unique_ptr<OrcRemoteTargetClient>>
-  Create(rpc::RawByteChannel &Channel, ExecutionSession &ES) {
+  Create(shared::RawByteChannel &Channel, ExecutionSession &ES) {
     Error Err = Error::success();
     auto Client = std::unique_ptr<OrcRemoteTargetClient>(
         new OrcRemoteTargetClient(Channel, ES, Err));
@@ -518,6 +720,14 @@
     return callB<exec::CallIntVoid>(Addr);
   }
 
+  /// Call the int(int) function at the given address in the target and return
+  /// its result.
+  Expected<int> callIntInt(JITTargetAddress Addr, int Arg) {
+    LLVM_DEBUG(dbgs() << "Calling int(*)(int) " << format("0x%016" PRIx64, Addr)
+                      << "\n");
+    return callB<exec::CallIntInt>(Addr, Arg);
+  }
+
   /// Call the int(int, char*[]) function at the given address in the target and
   /// return its result.
   Expected<int> callMain(JITTargetAddress Addr,
@@ -546,6 +756,18 @@
         new RemoteRTDyldMemoryManager(*this, Id));
   }
 
+  /// Create a JITLink-compatible memory manager which will allocate working
+  /// memory on the host and target memory on the remote target.
+  Expected<std::unique_ptr<RemoteJITLinkMemoryManager>>
+  createRemoteJITLinkMemoryManager() {
+    auto Id = AllocatorIds.getNext();
+    if (auto Err = callB<mem::CreateRemoteAllocator>(Id))
+      return std::move(Err);
+    LLVM_DEBUG(dbgs() << "Created remote allocator " << Id << "\n");
+    return std::unique_ptr<RemoteJITLinkMemoryManager>(
+        new RemoteJITLinkMemoryManager(*this, Id));
+  }
+
   /// Create an RCIndirectStubsManager that will allocate stubs on the remote
   /// target.
   Expected<std::unique_ptr<RemoteIndirectStubsManager>>
@@ -553,7 +775,7 @@
     auto Id = IndirectStubOwnerIds.getNext();
     if (auto Err = callB<stubs::CreateIndirectStubsOwner>(Id))
       return std::move(Err);
-    return llvm::make_unique<RemoteIndirectStubsManager>(*this, Id);
+    return std::make_unique<RemoteIndirectStubsManager>(*this, Id);
   }
 
   Expected<RemoteCompileCallbackManager &>
@@ -583,9 +805,10 @@
   Error terminateSession() { return callB<utils::TerminateSession>(); }
 
 private:
-  OrcRemoteTargetClient(rpc::RawByteChannel &Channel, ExecutionSession &ES,
+  OrcRemoteTargetClient(shared::RawByteChannel &Channel, ExecutionSession &ES,
                         Error &Err)
-      : rpc::SingleThreadedRPCEndpoint<rpc::RawByteChannel>(Channel, true),
+      : shared::SingleThreadedRPCEndpoint<shared::RawByteChannel>(Channel,
+                                                                  true),
         ES(ES) {
     ErrorAsOutParameter EAO(&Err);
 
diff --git a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetRPCAPI.h b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetRPCAPI.h
index e7b598d..367bfb3 100644
--- a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetRPCAPI.h
+++ b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetRPCAPI.h
@@ -16,8 +16,8 @@
 #define LLVM_EXECUTIONENGINE_ORC_ORCREMOTETARGETRPCAPI_H
 
 #include "llvm/ExecutionEngine/JITSymbol.h"
-#include "llvm/ExecutionEngine/Orc/RPCUtils.h"
-#include "llvm/ExecutionEngine/Orc/RawByteChannel.h"
+#include "llvm/ExecutionEngine/Orc/Shared/RPCUtils.h"
+#include "llvm/ExecutionEngine/Orc/Shared/RawByteChannel.h"
 
 namespace llvm {
 namespace orc {
@@ -73,10 +73,9 @@
 
 } // end namespace remote
 
-namespace rpc {
+namespace shared {
 
-template <>
-class RPCTypeName<JITSymbolFlags> {
+template <> class SerializationTypeName<JITSymbolFlags> {
 public:
   static const char *getName() { return "JITSymbolFlags"; }
 };
@@ -100,7 +99,7 @@
   }
 };
 
-template <> class RPCTypeName<remote::DirectBufferWriter> {
+template <> class SerializationTypeName<remote::DirectBufferWriter> {
 public:
   static const char *getName() { return "DirectBufferWriter"; }
 };
@@ -108,8 +107,7 @@
 template <typename ChannelT>
 class SerializationTraits<
     ChannelT, remote::DirectBufferWriter, remote::DirectBufferWriter,
-    typename std::enable_if<
-        std::is_base_of<RawByteChannel, ChannelT>::value>::type> {
+    std::enable_if_t<std::is_base_of<RawByteChannel, ChannelT>::value>> {
 public:
   static Error serialize(ChannelT &C, const remote::DirectBufferWriter &DBW) {
     if (auto EC = serializeSeq(C, DBW.getDst()))
@@ -134,7 +132,7 @@
   }
 };
 
-} // end namespace rpc
+} // end namespace shared
 
 namespace remote {
 
@@ -168,20 +166,20 @@
 namespace eh {
 
   /// Registers EH frames on the remote.
-  class RegisterEHFrames
-      : public rpc::Function<RegisterEHFrames,
-                             void(JITTargetAddress Addr, uint32_t Size)> {
-  public:
-    static const char *getName() { return "RegisterEHFrames"; }
-  };
+class RegisterEHFrames
+    : public shared::RPCFunction<RegisterEHFrames,
+                                 void(JITTargetAddress Addr, uint32_t Size)> {
+public:
+  static const char *getName() { return "RegisterEHFrames"; }
+};
 
   /// Deregisters EH frames on the remote.
-  class DeregisterEHFrames
-      : public rpc::Function<DeregisterEHFrames,
-                             void(JITTargetAddress Addr, uint32_t Size)> {
-  public:
-    static const char *getName() { return "DeregisterEHFrames"; }
-  };
+class DeregisterEHFrames
+    : public shared::RPCFunction<DeregisterEHFrames,
+                                 void(JITTargetAddress Addr, uint32_t Size)> {
+public:
+  static const char *getName() { return "DeregisterEHFrames"; }
+};
 
 } // end namespace eh
 
@@ -190,28 +188,38 @@
 
   /// Call an 'int32_t()'-type function on the remote, returns the called
   /// function's return value.
-  class CallIntVoid
-      : public rpc::Function<CallIntVoid, int32_t(JITTargetAddress Addr)> {
-  public:
-    static const char *getName() { return "CallIntVoid"; }
-  };
+class CallIntVoid
+    : public shared::RPCFunction<CallIntVoid, int32_t(JITTargetAddress Addr)> {
+public:
+  static const char *getName() { return "CallIntVoid"; }
+};
+
+  /// Call an 'int32_t(int32_t)'-type function on the remote, returns the called
+  /// function's return value.
+class CallIntInt
+    : public shared::RPCFunction<CallIntInt,
+                                 int32_t(JITTargetAddress Addr, int)> {
+public:
+  static const char *getName() { return "CallIntInt"; }
+};
 
   /// Call an 'int32_t(int32_t, char**)'-type function on the remote, returns the
   /// called function's return value.
-  class CallMain
-      : public rpc::Function<CallMain, int32_t(JITTargetAddress Addr,
-                                               std::vector<std::string> Args)> {
-  public:
-    static const char *getName() { return "CallMain"; }
-  };
+class CallMain
+    : public shared::RPCFunction<CallMain,
+                                 int32_t(JITTargetAddress Addr,
+                                         std::vector<std::string> Args)> {
+public:
+  static const char *getName() { return "CallMain"; }
+};
 
   /// Calls a 'void()'-type function on the remote, returns when the called
   /// function completes.
-  class CallVoidVoid
-      : public rpc::Function<CallVoidVoid, void(JITTargetAddress FnAddr)> {
-  public:
-    static const char *getName() { return "CallVoidVoid"; }
-  };
+class CallVoidVoid
+    : public shared::RPCFunction<CallVoidVoid, void(JITTargetAddress FnAddr)> {
+public:
+  static const char *getName() { return "CallVoidVoid"; }
+};
 
 } // end namespace exec
 
@@ -219,60 +227,62 @@
 namespace mem {
 
   /// Creates a memory allocator on the remote.
-  class CreateRemoteAllocator
-      : public rpc::Function<CreateRemoteAllocator,
-                             void(ResourceIdMgr::ResourceId AllocatorID)> {
-  public:
-    static const char *getName() { return "CreateRemoteAllocator"; }
-  };
+class CreateRemoteAllocator
+    : public shared::RPCFunction<CreateRemoteAllocator,
+                                 void(ResourceIdMgr::ResourceId AllocatorID)> {
+public:
+  static const char *getName() { return "CreateRemoteAllocator"; }
+};
 
   /// Destroys a remote allocator, freeing any memory allocated by it.
-  class DestroyRemoteAllocator
-      : public rpc::Function<DestroyRemoteAllocator,
-                             void(ResourceIdMgr::ResourceId AllocatorID)> {
-  public:
-    static const char *getName() { return "DestroyRemoteAllocator"; }
-  };
+class DestroyRemoteAllocator
+    : public shared::RPCFunction<DestroyRemoteAllocator,
+                                 void(ResourceIdMgr::ResourceId AllocatorID)> {
+public:
+  static const char *getName() { return "DestroyRemoteAllocator"; }
+};
 
   /// Read a remote memory block.
-  class ReadMem
-      : public rpc::Function<ReadMem, std::vector<uint8_t>(JITTargetAddress Src,
-                                                           uint64_t Size)> {
-  public:
-    static const char *getName() { return "ReadMem"; }
-  };
+class ReadMem
+    : public shared::RPCFunction<
+          ReadMem, std::vector<uint8_t>(JITTargetAddress Src, uint64_t Size)> {
+public:
+  static const char *getName() { return "ReadMem"; }
+};
 
   /// Reserve a block of memory on the remote via the given allocator.
-  class ReserveMem
-      : public rpc::Function<ReserveMem,
-                             JITTargetAddress(ResourceIdMgr::ResourceId AllocID,
-                                              uint64_t Size, uint32_t Align)> {
-  public:
-    static const char *getName() { return "ReserveMem"; }
-  };
+class ReserveMem
+    : public shared::RPCFunction<
+          ReserveMem, JITTargetAddress(ResourceIdMgr::ResourceId AllocID,
+                                       uint64_t Size, uint32_t Align)> {
+public:
+  static const char *getName() { return "ReserveMem"; }
+};
 
   /// Set the memory protection on a memory block.
-  class SetProtections
-      : public rpc::Function<SetProtections,
-                             void(ResourceIdMgr::ResourceId AllocID,
-                                  JITTargetAddress Dst, uint32_t ProtFlags)> {
-  public:
-    static const char *getName() { return "SetProtections"; }
-  };
+class SetProtections
+    : public shared::RPCFunction<
+          SetProtections, void(ResourceIdMgr::ResourceId AllocID,
+                               JITTargetAddress Dst, uint32_t ProtFlags)> {
+public:
+  static const char *getName() { return "SetProtections"; }
+};
 
   /// Write to a remote memory block.
-  class WriteMem
-      : public rpc::Function<WriteMem, void(remote::DirectBufferWriter DB)> {
-  public:
-    static const char *getName() { return "WriteMem"; }
-  };
+class WriteMem
+    : public shared::RPCFunction<WriteMem,
+                                 void(remote::DirectBufferWriter DB)> {
+public:
+  static const char *getName() { return "WriteMem"; }
+};
 
   /// Write to a remote pointer.
-  class WritePtr : public rpc::Function<WritePtr, void(JITTargetAddress Dst,
-                                                       JITTargetAddress Val)> {
-  public:
-    static const char *getName() { return "WritePtr"; }
-  };
+class WritePtr
+    : public shared::RPCFunction<WritePtr, void(JITTargetAddress Dst,
+                                                JITTargetAddress Val)> {
+public:
+  static const char *getName() { return "WritePtr"; }
+};
 
 } // end namespace mem
 
@@ -280,45 +290,46 @@
 namespace stubs {
 
   /// Creates an indirect stub owner on the remote.
-  class CreateIndirectStubsOwner
-      : public rpc::Function<CreateIndirectStubsOwner,
-                             void(ResourceIdMgr::ResourceId StubOwnerID)> {
-  public:
-    static const char *getName() { return "CreateIndirectStubsOwner"; }
-  };
+class CreateIndirectStubsOwner
+    : public shared::RPCFunction<CreateIndirectStubsOwner,
+                                 void(ResourceIdMgr::ResourceId StubOwnerID)> {
+public:
+  static const char *getName() { return "CreateIndirectStubsOwner"; }
+};
 
   /// RPC function for destroying an indirect stubs owner.
-  class DestroyIndirectStubsOwner
-      : public rpc::Function<DestroyIndirectStubsOwner,
-                             void(ResourceIdMgr::ResourceId StubsOwnerID)> {
-  public:
-    static const char *getName() { return "DestroyIndirectStubsOwner"; }
-  };
+class DestroyIndirectStubsOwner
+    : public shared::RPCFunction<DestroyIndirectStubsOwner,
+                                 void(ResourceIdMgr::ResourceId StubsOwnerID)> {
+public:
+  static const char *getName() { return "DestroyIndirectStubsOwner"; }
+};
 
   /// EmitIndirectStubs result is (StubsBase, PtrsBase, NumStubsEmitted).
-  class EmitIndirectStubs
-      : public rpc::Function<
-            EmitIndirectStubs,
-            std::tuple<JITTargetAddress, JITTargetAddress, uint32_t>(
-                ResourceIdMgr::ResourceId StubsOwnerID,
-                uint32_t NumStubsRequired)> {
-  public:
-    static const char *getName() { return "EmitIndirectStubs"; }
-  };
+class EmitIndirectStubs
+    : public shared::RPCFunction<
+          EmitIndirectStubs,
+          std::tuple<JITTargetAddress, JITTargetAddress, uint32_t>(
+              ResourceIdMgr::ResourceId StubsOwnerID,
+              uint32_t NumStubsRequired)> {
+public:
+  static const char *getName() { return "EmitIndirectStubs"; }
+};
 
   /// RPC function to emit the resolver block and return its address.
-  class EmitResolverBlock : public rpc::Function<EmitResolverBlock, void()> {
-  public:
-    static const char *getName() { return "EmitResolverBlock"; }
-  };
+class EmitResolverBlock
+    : public shared::RPCFunction<EmitResolverBlock, void()> {
+public:
+  static const char *getName() { return "EmitResolverBlock"; }
+};
 
   /// EmitTrampolineBlock result is (BlockAddr, NumTrampolines).
-  class EmitTrampolineBlock
-      : public rpc::Function<EmitTrampolineBlock,
-                             std::tuple<JITTargetAddress, uint32_t>()> {
-  public:
-    static const char *getName() { return "EmitTrampolineBlock"; }
-  };
+class EmitTrampolineBlock
+    : public shared::RPCFunction<EmitTrampolineBlock,
+                                 std::tuple<JITTargetAddress, uint32_t>()> {
+public:
+  static const char *getName() { return "EmitTrampolineBlock"; }
+};
 
 } // end namespace stubs
 
@@ -327,44 +338,44 @@
 
   /// GetRemoteInfo result is (Triple, PointerSize, PageSize, TrampolineSize,
   ///                          IndirectStubsSize).
-  class GetRemoteInfo
-      : public rpc::Function<
-            GetRemoteInfo,
-            std::tuple<std::string, uint32_t, uint32_t, uint32_t, uint32_t>()> {
-  public:
-    static const char *getName() { return "GetRemoteInfo"; }
-  };
+class GetRemoteInfo
+    : public shared::RPCFunction<
+          GetRemoteInfo,
+          std::tuple<std::string, uint32_t, uint32_t, uint32_t, uint32_t>()> {
+public:
+  static const char *getName() { return "GetRemoteInfo"; }
+};
 
   /// Get the address of a remote symbol.
-  class GetSymbolAddress
-      : public rpc::Function<GetSymbolAddress,
-                             JITTargetAddress(std::string SymbolName)> {
-  public:
-    static const char *getName() { return "GetSymbolAddress"; }
-  };
+class GetSymbolAddress
+    : public shared::RPCFunction<GetSymbolAddress,
+                                 JITTargetAddress(std::string SymbolName)> {
+public:
+  static const char *getName() { return "GetSymbolAddress"; }
+};
 
   /// Request that the host execute a compile callback.
-  class RequestCompile
-      : public rpc::Function<
-            RequestCompile, JITTargetAddress(JITTargetAddress TrampolineAddr)> {
-  public:
-    static const char *getName() { return "RequestCompile"; }
-  };
+class RequestCompile
+    : public shared::RPCFunction<
+          RequestCompile, JITTargetAddress(JITTargetAddress TrampolineAddr)> {
+public:
+  static const char *getName() { return "RequestCompile"; }
+};
 
   /// Notify the remote and terminate the session.
-  class TerminateSession : public rpc::Function<TerminateSession, void()> {
-  public:
-    static const char *getName() { return "TerminateSession"; }
-  };
+class TerminateSession : public shared::RPCFunction<TerminateSession, void()> {
+public:
+  static const char *getName() { return "TerminateSession"; }
+};
 
 } // namespace utils
 
 class OrcRemoteTargetRPCAPI
-    : public rpc::SingleThreadedRPCEndpoint<rpc::RawByteChannel> {
+    : public shared::SingleThreadedRPCEndpoint<shared::RawByteChannel> {
 public:
   // FIXME: Remove constructors once MSVC supports synthesizing move-ops.
-  OrcRemoteTargetRPCAPI(rpc::RawByteChannel &C)
-      : rpc::SingleThreadedRPCEndpoint<rpc::RawByteChannel>(C, true) {}
+  OrcRemoteTargetRPCAPI(shared::RawByteChannel &C)
+      : shared::SingleThreadedRPCEndpoint<shared::RawByteChannel>(C, true) {}
 };
 
 } // end namespace remote
diff --git a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetServer.h b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetServer.h
index 4c8e2ea..68eccf4 100644
--- a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetServer.h
+++ b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetServer.h
@@ -15,6 +15,7 @@
 #define LLVM_EXECUTIONENGINE_ORC_ORCREMOTETARGETSERVER_H
 
 #include "llvm/ExecutionEngine/JITSymbol.h"
+#include "llvm/ExecutionEngine/Orc/IndirectionUtils.h"
 #include "llvm/ExecutionEngine/Orc/OrcError.h"
 #include "llvm/ExecutionEngine/Orc/OrcRemoteTargetRPCAPI.h"
 #include "llvm/Support/Debug.h"
@@ -45,7 +46,7 @@
 
 template <typename ChannelT, typename TargetT>
 class OrcRemoteTargetServer
-    : public rpc::SingleThreadedRPCEndpoint<rpc::RawByteChannel> {
+    : public shared::SingleThreadedRPCEndpoint<shared::RawByteChannel> {
 public:
   using SymbolLookupFtor =
       std::function<JITTargetAddress(const std::string &Name)>;
@@ -56,12 +57,14 @@
   OrcRemoteTargetServer(ChannelT &Channel, SymbolLookupFtor SymbolLookup,
                         EHFrameRegistrationFtor EHFramesRegister,
                         EHFrameRegistrationFtor EHFramesDeregister)
-      : rpc::SingleThreadedRPCEndpoint<rpc::RawByteChannel>(Channel, true),
+      : shared::SingleThreadedRPCEndpoint<shared::RawByteChannel>(Channel,
+                                                                  true),
         SymbolLookup(std::move(SymbolLookup)),
         EHFramesRegister(std::move(EHFramesRegister)),
         EHFramesDeregister(std::move(EHFramesDeregister)) {
-    using ThisT = typename std::remove_reference<decltype(*this)>::type;
+    using ThisT = std::remove_reference_t<decltype(*this)>;
     addHandler<exec::CallIntVoid>(*this, &ThisT::handleCallIntVoid);
+    addHandler<exec::CallIntInt>(*this, &ThisT::handleCallIntInt);
     addHandler<exec::CallMain>(*this, &ThisT::handleCallMain);
     addHandler<exec::CallVoidVoid>(*this, &ThisT::handleCallVoidVoid);
     addHandler<mem::CreateRemoteAllocator>(*this,
@@ -167,6 +170,19 @@
     return Result;
   }
 
+  Expected<int32_t> handleCallIntInt(JITTargetAddress Addr, int Arg) {
+    using IntIntFnTy = int (*)(int);
+
+    IntIntFnTy Fn = reinterpret_cast<IntIntFnTy>(static_cast<uintptr_t>(Addr));
+
+    LLVM_DEBUG(dbgs() << "  Calling " << format("0x%016x", Addr)
+                      << " with argument " << Arg << "\n");
+    int Result = Fn(Arg);
+    LLVM_DEBUG(dbgs() << "  Result = " << Result << "\n");
+
+    return Result;
+  }
+
   Expected<int32_t> handleCallMain(JITTargetAddress Addr,
                                    std::vector<std::string> Args) {
     using MainFnTy = int (*)(int, const char *[]);
@@ -262,19 +278,17 @@
       return errorCodeToError(
                orcError(OrcErrorCode::RemoteIndirectStubsOwnerDoesNotExist));
 
-    typename TargetT::IndirectStubsInfo IS;
-    if (auto Err =
-            TargetT::emitIndirectStubsBlock(IS, NumStubsRequired, nullptr))
-      return std::move(Err);
+    auto IS = LocalIndirectStubsInfo<TargetT>::create(
+        NumStubsRequired, sys::Process::getPageSizeEstimate());
+    if (!IS)
+      return IS.takeError();
 
-    JITTargetAddress StubsBase = static_cast<JITTargetAddress>(
-        reinterpret_cast<uintptr_t>(IS.getStub(0)));
-    JITTargetAddress PtrsBase = static_cast<JITTargetAddress>(
-        reinterpret_cast<uintptr_t>(IS.getPtr(0)));
-    uint32_t NumStubsEmitted = IS.getNumStubs();
+    JITTargetAddress StubsBase = pointerToJITTargetAddress(IS->getStub(0));
+    JITTargetAddress PtrsBase = pointerToJITTargetAddress(IS->getPtr(0));
+    uint32_t NumStubsEmitted = IS->getNumStubs();
 
     auto &BlockList = StubOwnerItr->second;
-    BlockList.push_back(std::move(IS));
+    BlockList.push_back(std::move(*IS));
 
     return std::make_tuple(StubsBase, PtrsBase, NumStubsEmitted);
   }
@@ -287,8 +301,10 @@
     if (EC)
       return errorCodeToError(EC);
 
-    TargetT::writeResolverCode(static_cast<uint8_t *>(ResolverBlock.base()),
-                               &reenter, this);
+    TargetT::writeResolverCode(static_cast<char *>(ResolverBlock.base()),
+                               pointerToJITTargetAddress(ResolverBlock.base()),
+                               pointerToJITTargetAddress(&reenter),
+                               pointerToJITTargetAddress(this));
 
     return errorCodeToError(sys::Memory::protectMappedMemory(
         ResolverBlock.getMemoryBlock(),
@@ -308,9 +324,10 @@
         (sys::Process::getPageSizeEstimate() - TargetT::PointerSize) /
         TargetT::TrampolineSize;
 
-    uint8_t *TrampolineMem = static_cast<uint8_t *>(TrampolineBlock.base());
-    TargetT::writeTrampolines(TrampolineMem, ResolverBlock.base(),
-                              NumTrampolines);
+    char *TrampolineMem = static_cast<char *>(TrampolineBlock.base());
+    TargetT::writeTrampolines(
+        TrampolineMem, pointerToJITTargetAddress(TrampolineMem),
+        pointerToJITTargetAddress(ResolverBlock.base()), NumTrampolines);
 
     EC = sys::Memory::protectMappedMemory(TrampolineBlock.getMemoryBlock(),
                                           sys::Memory::MF_READ |
@@ -318,10 +335,8 @@
 
     TrampolineBlocks.push_back(std::move(TrampolineBlock));
 
-    auto TrampolineBaseAddr = static_cast<JITTargetAddress>(
-        reinterpret_cast<uintptr_t>(TrampolineMem));
-
-    return std::make_tuple(TrampolineBaseAddr, NumTrampolines);
+    return std::make_tuple(pointerToJITTargetAddress(TrampolineMem),
+                           NumTrampolines);
   }
 
   Expected<JITTargetAddress> handleGetSymbolAddress(const std::string &Name) {
@@ -337,7 +352,7 @@
     uint32_t PointerSize = TargetT::PointerSize;
     uint32_t PageSize = sys::Process::getPageSizeEstimate();
     uint32_t TrampolineSize = TargetT::TrampolineSize;
-    uint32_t IndirectStubSize = TargetT::IndirectStubsInfo::StubSize;
+    uint32_t IndirectStubSize = TargetT::StubSize;
     LLVM_DEBUG(dbgs() << "  Remote info:\n"
                       << "    triple             = '" << ProcessTriple << "'\n"
                       << "    pointer size       = " << PointerSize << "\n"
@@ -433,7 +448,7 @@
   SymbolLookupFtor SymbolLookup;
   EHFrameRegistrationFtor EHFramesRegister, EHFramesDeregister;
   std::map<ResourceIdMgr::ResourceId, Allocator> Allocators;
-  using ISBlockOwnerList = std::vector<typename TargetT::IndirectStubsInfo>;
+  using ISBlockOwnerList = std::vector<LocalIndirectStubsInfo<TargetT>>;
   std::map<ResourceIdMgr::ResourceId, ISBlockOwnerList> IndirectStubsOwners;
   sys::OwningMemoryBlock ResolverBlock;
   std::vector<sys::OwningMemoryBlock> TrampolineBlocks;
diff --git a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h
index 479658b..7dfbf32 100644
--- a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h
+++ b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h
@@ -16,10 +16,10 @@
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/ExecutionEngine/JITEventListener.h"
 #include "llvm/ExecutionEngine/JITSymbol.h"
 #include "llvm/ExecutionEngine/Orc/Core.h"
 #include "llvm/ExecutionEngine/Orc/Layer.h"
-#include "llvm/ExecutionEngine/Orc/Legacy.h"
 #include "llvm/ExecutionEngine/RuntimeDyld.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Support/Error.h"
@@ -35,16 +35,16 @@
 namespace llvm {
 namespace orc {
 
-class RTDyldObjectLinkingLayer : public ObjectLayer {
+class RTDyldObjectLinkingLayer : public ObjectLayer, private ResourceManager {
 public:
   /// Functor for receiving object-loaded notifications.
-  using NotifyLoadedFunction =
-      std::function<void(VModuleKey, const object::ObjectFile &Obj,
-                         const RuntimeDyld::LoadedObjectInfo &)>;
+  using NotifyLoadedFunction = std::function<void(
+      MaterializationResponsibility &R, const object::ObjectFile &Obj,
+      const RuntimeDyld::LoadedObjectInfo &)>;
 
   /// Functor for receiving finalization notifications.
-  using NotifyEmittedFunction =
-      std::function<void(VModuleKey, std::unique_ptr<MemoryBuffer>)>;
+  using NotifyEmittedFunction = std::function<void(
+      MaterializationResponsibility &R, std::unique_ptr<MemoryBuffer>)>;
 
   using GetMemoryManagerFunction =
       std::function<std::unique_ptr<RuntimeDyld::MemoryManager>()>;
@@ -54,8 +54,10 @@
   RTDyldObjectLinkingLayer(ExecutionSession &ES,
                            GetMemoryManagerFunction GetMemoryManager);
 
+  ~RTDyldObjectLinkingLayer();
+
   /// Emit the object.
-  void emit(MaterializationResponsibility R,
+  void emit(std::unique_ptr<MaterializationResponsibility> R,
             std::unique_ptr<MemoryBuffer> O) override;
 
   /// Set the NotifyLoaded callback.
@@ -113,15 +115,30 @@
     return *this;
   }
 
+  /// Register a JITEventListener.
+  void registerJITEventListener(JITEventListener &L);
+
+  /// Unregister a JITEventListener.
+  void unregisterJITEventListener(JITEventListener &L);
+
 private:
-  Error onObjLoad(VModuleKey K, MaterializationResponsibility &R,
-                  object::ObjectFile &Obj,
-                  std::unique_ptr<RuntimeDyld::LoadedObjectInfo> LoadedObjInfo,
+  using MemoryManagerUP = std::unique_ptr<RuntimeDyld::MemoryManager>;
+
+  Error onObjLoad(MaterializationResponsibility &R,
+                  const object::ObjectFile &Obj,
+                  RuntimeDyld::MemoryManager &MemMgr,
+                  RuntimeDyld::LoadedObjectInfo &LoadedObjInfo,
                   std::map<StringRef, JITEvaluatedSymbol> Resolved,
                   std::set<StringRef> &InternalSymbols);
 
-  void onObjEmit(VModuleKey K, std::unique_ptr<MemoryBuffer> ObjBuffer,
-                 MaterializationResponsibility &R, Error Err);
+  void onObjEmit(MaterializationResponsibility &R,
+                 object::OwningBinary<object::ObjectFile> O,
+                 std::unique_ptr<RuntimeDyld::MemoryManager> MemMgr,
+                 std::unique_ptr<RuntimeDyld::LoadedObjectInfo> LoadedObjInfo,
+                 Error Err);
+
+  Error handleRemoveResources(ResourceKey K) override;
+  void handleTransferResources(ResourceKey DstKey, ResourceKey SrcKey) override;
 
   mutable std::mutex RTDyldLayerMutex;
   GetMemoryManagerFunction GetMemoryManager;
@@ -130,340 +147,8 @@
   bool ProcessAllSections = false;
   bool OverrideObjectFlags = false;
   bool AutoClaimObjectSymbols = false;
-  std::vector<std::unique_ptr<RuntimeDyld::MemoryManager>> MemMgrs;
-};
-
-class LegacyRTDyldObjectLinkingLayerBase {
-public:
-  using ObjectPtr = std::unique_ptr<MemoryBuffer>;
-
-protected:
-
-  /// Holds an object to be allocated/linked as a unit in the JIT.
-  ///
-  /// An instance of this class will be created for each object added
-  /// via JITObjectLayer::addObject. Deleting the instance (via
-  /// removeObject) frees its memory, removing all symbol definitions that
-  /// had been provided by this instance. Higher level layers are responsible
-  /// for taking any action required to handle the missing symbols.
-  class LinkedObject {
-  public:
-    LinkedObject() = default;
-    LinkedObject(const LinkedObject&) = delete;
-    void operator=(const LinkedObject&) = delete;
-    virtual ~LinkedObject() = default;
-
-    virtual Error finalize() = 0;
-
-    virtual JITSymbol::GetAddressFtor
-    getSymbolMaterializer(std::string Name) = 0;
-
-    virtual void mapSectionAddress(const void *LocalAddress,
-                                   JITTargetAddress TargetAddr) const = 0;
-
-    JITSymbol getSymbol(StringRef Name, bool ExportedSymbolsOnly) {
-      auto SymEntry = SymbolTable.find(Name);
-      if (SymEntry == SymbolTable.end())
-        return nullptr;
-      if (!SymEntry->second.getFlags().isExported() && ExportedSymbolsOnly)
-        return nullptr;
-      if (!Finalized)
-        return JITSymbol(getSymbolMaterializer(Name),
-                         SymEntry->second.getFlags());
-      return JITSymbol(SymEntry->second);
-    }
-
-  protected:
-    StringMap<JITEvaluatedSymbol> SymbolTable;
-    bool Finalized = false;
-  };
-};
-
-/// Bare bones object linking layer.
-///
-///   This class is intended to be used as the base layer for a JIT. It allows
-/// object files to be loaded into memory, linked, and the addresses of their
-/// symbols queried. All objects added to this layer can see each other's
-/// symbols.
-class LegacyRTDyldObjectLinkingLayer : public LegacyRTDyldObjectLinkingLayerBase {
-public:
-
-  using LegacyRTDyldObjectLinkingLayerBase::ObjectPtr;
-
-  /// Functor for receiving object-loaded notifications.
-  using NotifyLoadedFtor =
-      std::function<void(VModuleKey, const object::ObjectFile &Obj,
-                         const RuntimeDyld::LoadedObjectInfo &)>;
-
-  /// Functor for receiving finalization notifications.
-  using NotifyFinalizedFtor =
-      std::function<void(VModuleKey, const object::ObjectFile &Obj,
-                         const RuntimeDyld::LoadedObjectInfo &)>;
-
-  /// Functor for receiving deallocation notifications.
-  using NotifyFreedFtor = std::function<void(VModuleKey, const object::ObjectFile &Obj)>;
-
-private:
-  using OwnedObject = object::OwningBinary<object::ObjectFile>;
-
-  template <typename MemoryManagerPtrT>
-  class ConcreteLinkedObject : public LinkedObject {
-  public:
-    ConcreteLinkedObject(LegacyRTDyldObjectLinkingLayer &Parent, VModuleKey K,
-                         OwnedObject Obj, MemoryManagerPtrT MemMgr,
-                         std::shared_ptr<SymbolResolver> Resolver,
-                         bool ProcessAllSections)
-        : K(std::move(K)),
-          Parent(Parent),
-          MemMgr(std::move(MemMgr)),
-          PFC(llvm::make_unique<PreFinalizeContents>(
-              std::move(Obj), std::move(Resolver),
-              ProcessAllSections)) {
-      buildInitialSymbolTable(PFC->Obj);
-    }
-
-    ~ConcreteLinkedObject() override {
-      if (this->Parent.NotifyFreed && ObjForNotify.getBinary())
-        this->Parent.NotifyFreed(K, *ObjForNotify.getBinary());
-
-      MemMgr->deregisterEHFrames();
-    }
-
-    Error finalize() override {
-      assert(PFC && "mapSectionAddress called on finalized LinkedObject");
-
-      JITSymbolResolverAdapter ResolverAdapter(Parent.ES, *PFC->Resolver,
-					       nullptr);
-      PFC->RTDyld = llvm::make_unique<RuntimeDyld>(*MemMgr, ResolverAdapter);
-      PFC->RTDyld->setProcessAllSections(PFC->ProcessAllSections);
-
-      Finalized = true;
-
-      std::unique_ptr<RuntimeDyld::LoadedObjectInfo> Info =
-          PFC->RTDyld->loadObject(*PFC->Obj.getBinary());
-
-      // Copy the symbol table out of the RuntimeDyld instance.
-      {
-        auto SymTab = PFC->RTDyld->getSymbolTable();
-        for (auto &KV : SymTab)
-          SymbolTable[KV.first] = KV.second;
-      }
-
-      if (Parent.NotifyLoaded)
-        Parent.NotifyLoaded(K, *PFC->Obj.getBinary(), *Info);
-
-      PFC->RTDyld->finalizeWithMemoryManagerLocking();
-
-      if (PFC->RTDyld->hasError())
-        return make_error<StringError>(PFC->RTDyld->getErrorString(),
-                                       inconvertibleErrorCode());
-
-      if (Parent.NotifyFinalized)
-        Parent.NotifyFinalized(K, *PFC->Obj.getBinary(), *Info);
-
-      // Release resources.
-      if (this->Parent.NotifyFreed)
-        ObjForNotify = std::move(PFC->Obj); // needed for callback
-      PFC = nullptr;
-      return Error::success();
-    }
-
-    JITSymbol::GetAddressFtor getSymbolMaterializer(std::string Name) override {
-      return [this, Name]() -> Expected<JITTargetAddress> {
-        // The symbol may be materialized between the creation of this lambda
-        // and its execution, so we need to double check.
-        if (!this->Finalized)
-          if (auto Err = this->finalize())
-            return std::move(Err);
-        return this->getSymbol(Name, false).getAddress();
-      };
-    }
-
-    void mapSectionAddress(const void *LocalAddress,
-                           JITTargetAddress TargetAddr) const override {
-      assert(PFC && "mapSectionAddress called on finalized LinkedObject");
-      assert(PFC->RTDyld && "mapSectionAddress called on raw LinkedObject");
-      PFC->RTDyld->mapSectionAddress(LocalAddress, TargetAddr);
-    }
-
-  private:
-    void buildInitialSymbolTable(const OwnedObject &Obj) {
-      for (auto &Symbol : Obj.getBinary()->symbols()) {
-        if (Symbol.getFlags() & object::SymbolRef::SF_Undefined)
-          continue;
-        Expected<StringRef> SymbolName = Symbol.getName();
-        // FIXME: Raise an error for bad symbols.
-        if (!SymbolName) {
-          consumeError(SymbolName.takeError());
-          continue;
-        }
-        // FIXME: Raise an error for bad symbols.
-        auto Flags = JITSymbolFlags::fromObjectSymbol(Symbol);
-        if (!Flags) {
-          consumeError(Flags.takeError());
-          continue;
-        }
-        SymbolTable.insert(
-            std::make_pair(*SymbolName, JITEvaluatedSymbol(0, *Flags)));
-      }
-    }
-
-    // Contains the information needed prior to finalization: the object files,
-    // memory manager, resolver, and flags needed for RuntimeDyld.
-    struct PreFinalizeContents {
-      PreFinalizeContents(OwnedObject Obj,
-                          std::shared_ptr<SymbolResolver> Resolver,
-                          bool ProcessAllSections)
-          : Obj(std::move(Obj)),
-            Resolver(std::move(Resolver)),
-            ProcessAllSections(ProcessAllSections) {}
-
-      OwnedObject Obj;
-      std::shared_ptr<SymbolResolver> Resolver;
-      bool ProcessAllSections;
-      std::unique_ptr<RuntimeDyld> RTDyld;
-    };
-
-    VModuleKey K;
-    LegacyRTDyldObjectLinkingLayer &Parent;
-    MemoryManagerPtrT MemMgr;
-    OwnedObject ObjForNotify;
-    std::unique_ptr<PreFinalizeContents> PFC;
-  };
-
-  template <typename MemoryManagerPtrT>
-  std::unique_ptr<ConcreteLinkedObject<MemoryManagerPtrT>>
-  createLinkedObject(LegacyRTDyldObjectLinkingLayer &Parent, VModuleKey K,
-                     OwnedObject Obj, MemoryManagerPtrT MemMgr,
-                     std::shared_ptr<SymbolResolver> Resolver,
-                     bool ProcessAllSections) {
-    using LOS = ConcreteLinkedObject<MemoryManagerPtrT>;
-    return llvm::make_unique<LOS>(Parent, std::move(K), std::move(Obj),
-                                  std::move(MemMgr), std::move(Resolver),
-                                  ProcessAllSections);
-  }
-
-public:
-  struct Resources {
-    std::shared_ptr<RuntimeDyld::MemoryManager> MemMgr;
-    std::shared_ptr<SymbolResolver> Resolver;
-  };
-
-  using ResourcesGetter = std::function<Resources(VModuleKey)>;
-
-  /// Construct an ObjectLinkingLayer with the given NotifyLoaded,
-  ///        and NotifyFinalized functors.
-  LegacyRTDyldObjectLinkingLayer(
-      ExecutionSession &ES, ResourcesGetter GetResources,
-      NotifyLoadedFtor NotifyLoaded = NotifyLoadedFtor(),
-      NotifyFinalizedFtor NotifyFinalized = NotifyFinalizedFtor(),
-      NotifyFreedFtor NotifyFreed = NotifyFreedFtor())
-      : ES(ES), GetResources(std::move(GetResources)),
-        NotifyLoaded(std::move(NotifyLoaded)),
-        NotifyFinalized(std::move(NotifyFinalized)),
-        NotifyFreed(std::move(NotifyFreed)),
-        ProcessAllSections(false) {
-  }
-
-  /// Set the 'ProcessAllSections' flag.
-  ///
-  /// If set to true, all sections in each object file will be allocated using
-  /// the memory manager, rather than just the sections required for execution.
-  ///
-  /// This is kludgy, and may be removed in the future.
-  void setProcessAllSections(bool ProcessAllSections) {
-    this->ProcessAllSections = ProcessAllSections;
-  }
-
-  /// Add an object to the JIT.
-  Error addObject(VModuleKey K, ObjectPtr ObjBuffer) {
-
-    auto Obj =
-        object::ObjectFile::createObjectFile(ObjBuffer->getMemBufferRef());
-    if (!Obj)
-      return Obj.takeError();
-
-    assert(!LinkedObjects.count(K) && "VModuleKey already in use");
-
-    auto R = GetResources(K);
-
-    LinkedObjects[K] = createLinkedObject(
-        *this, K, OwnedObject(std::move(*Obj), std::move(ObjBuffer)),
-        std::move(R.MemMgr), std::move(R.Resolver), ProcessAllSections);
-
-    return Error::success();
-  }
-
-  /// Remove the object associated with VModuleKey K.
-  ///
-  ///   All memory allocated for the object will be freed, and the sections and
-  /// symbols it provided will no longer be available. No attempt is made to
-  /// re-emit the missing symbols, and any use of these symbols (directly or
-  /// indirectly) will result in undefined behavior. If dependence tracking is
-  /// required to detect or resolve such issues it should be added at a higher
-  /// layer.
-  Error removeObject(VModuleKey K) {
-    assert(LinkedObjects.count(K) && "VModuleKey not associated with object");
-    // How do we invalidate the symbols in H?
-    LinkedObjects.erase(K);
-    return Error::success();
-  }
-
-  /// Search for the given named symbol.
-  /// @param Name The name of the symbol to search for.
-  /// @param ExportedSymbolsOnly If true, search only for exported symbols.
-  /// @return A handle for the given named symbol, if it exists.
-  JITSymbol findSymbol(StringRef Name, bool ExportedSymbolsOnly) {
-    for (auto &KV : LinkedObjects)
-      if (auto Sym = KV.second->getSymbol(Name, ExportedSymbolsOnly))
-        return Sym;
-      else if (auto Err = Sym.takeError())
-        return std::move(Err);
-
-    return nullptr;
-  }
-
-  /// Search for the given named symbol in the context of the loaded
-  ///        object represented by the VModuleKey K.
-  /// @param K The VModuleKey for the object to search in.
-  /// @param Name The name of the symbol to search for.
-  /// @param ExportedSymbolsOnly If true, search only for exported symbols.
-  /// @return A handle for the given named symbol, if it is found in the
-  ///         given object.
-  JITSymbol findSymbolIn(VModuleKey K, StringRef Name,
-                         bool ExportedSymbolsOnly) {
-    assert(LinkedObjects.count(K) && "VModuleKey not associated with object");
-    return LinkedObjects[K]->getSymbol(Name, ExportedSymbolsOnly);
-  }
-
-  /// Map section addresses for the object associated with the
-  ///        VModuleKey K.
-  void mapSectionAddress(VModuleKey K, const void *LocalAddress,
-                         JITTargetAddress TargetAddr) {
-    assert(LinkedObjects.count(K) && "VModuleKey not associated with object");
-    LinkedObjects[K]->mapSectionAddress(LocalAddress, TargetAddr);
-  }
-
-  /// Immediately emit and finalize the object represented by the given
-  ///        VModuleKey.
-  /// @param K VModuleKey for object to emit/finalize.
-  Error emitAndFinalize(VModuleKey K) {
-    assert(LinkedObjects.count(K) && "VModuleKey not associated with object");
-    return LinkedObjects[K]->finalize();
-  }
-
-private:
-  ExecutionSession &ES;
-
-  ResourcesGetter GetResources;
-  NotifyLoadedFtor NotifyLoaded;
-  NotifyFinalizedFtor NotifyFinalized;
-  NotifyFreedFtor NotifyFreed;
-
-  // NB!  `LinkedObjects` needs to be destroyed before `NotifyFreed` because
-  // `~ConcreteLinkedObject` calls `NotifyFreed`
-  std::map<VModuleKey, std::unique_ptr<LinkedObject>> LinkedObjects;
-  bool ProcessAllSections = false;
+  DenseMap<ResourceKey, std::vector<MemoryManagerUP>> MemMgrs;
+  std::vector<JITEventListener *> EventListeners;
 };
 
 } // end namespace orc
diff --git a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/RemoteObjectLayer.h b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/RemoteObjectLayer.h
deleted file mode 100644
index 9550edc..0000000
--- a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/RemoteObjectLayer.h
+++ /dev/null
@@ -1,528 +0,0 @@
-//===------ RemoteObjectLayer.h - Forwards objs to a remote -----*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// Forwards objects to a remote object layer via RPC.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_EXECUTIONENGINE_ORC_REMOTEOBJECTLAYER_H
-#define LLVM_EXECUTIONENGINE_ORC_REMOTEOBJECTLAYER_H
-
-#include "llvm/ExecutionEngine/Orc/OrcRemoteTargetRPCAPI.h"
-#include "llvm/Object/ObjectFile.h"
-#include "llvm/ExecutionEngine/Orc/LambdaResolver.h"
-#include <map>
-
-namespace llvm {
-namespace orc {
-
-/// RPC API needed by RemoteObjectClientLayer and RemoteObjectServerLayer.
-class RemoteObjectLayerAPI {
-public:
-
-  using ObjHandleT = remote::ResourceIdMgr::ResourceId;
-
-protected:
-
-  using RemoteSymbolId = remote::ResourceIdMgr::ResourceId;
-  using RemoteSymbol = std::pair<RemoteSymbolId, JITSymbolFlags>;
-
-public:
-
-  using BadSymbolHandleError = remote::ResourceNotFound<RemoteSymbolId>;
-  using BadObjectHandleError = remote::ResourceNotFound<ObjHandleT>;
-
-protected:
-
-  static const ObjHandleT InvalidObjectHandleId = 0;
-  static const RemoteSymbolId NullSymbolId = 0;
-
-  class AddObject
-    : public rpc::Function<AddObject, Expected<ObjHandleT>(std::string)> {
-  public:
-    static const char *getName() { return "AddObject"; }
-  };
-
-  class RemoveObject
-    : public rpc::Function<RemoveObject, Error(ObjHandleT)> {
-  public:
-    static const char *getName() { return "RemoveObject"; }
-  };
-
-  class FindSymbol
-    : public rpc::Function<FindSymbol, Expected<RemoteSymbol>(std::string,
-                                                              bool)> {
-  public:
-    static const char *getName() { return "FindSymbol"; }
-  };
-
-  class FindSymbolIn
-    : public rpc::Function<FindSymbolIn,
-                           Expected<RemoteSymbol>(ObjHandleT, std::string,
-                                                  bool)> {
-  public:
-    static const char *getName() { return "FindSymbolIn"; }
-  };
-
-  class EmitAndFinalize
-    : public rpc::Function<EmitAndFinalize,
-                           Error(ObjHandleT)> {
-  public:
-    static const char *getName() { return "EmitAndFinalize"; }
-  };
-
-  class Lookup
-    : public rpc::Function<Lookup,
-                           Expected<RemoteSymbol>(ObjHandleT, std::string)> {
-  public:
-    static const char *getName() { return "Lookup"; }
-  };
-
-  class LookupInLogicalDylib
-    : public rpc::Function<LookupInLogicalDylib,
-                           Expected<RemoteSymbol>(ObjHandleT, std::string)> {
-  public:
-    static const char *getName() { return "LookupInLogicalDylib"; }
-  };
-
-  class ReleaseRemoteSymbol
-    : public rpc::Function<ReleaseRemoteSymbol, Error(RemoteSymbolId)> {
-  public:
-    static const char *getName() { return "ReleaseRemoteSymbol"; }
-  };
-
-  class MaterializeRemoteSymbol
-    : public rpc::Function<MaterializeRemoteSymbol,
-                           Expected<JITTargetAddress>(RemoteSymbolId)> {
-  public:
-    static const char *getName() { return "MaterializeRemoteSymbol"; }
-  };
-};
-
-/// Base class containing common utilities for RemoteObjectClientLayer and
-/// RemoteObjectServerLayer.
-template <typename RPCEndpoint>
-class RemoteObjectLayer : public RemoteObjectLayerAPI {
-public:
-
-  RemoteObjectLayer(RPCEndpoint &Remote,
-                    std::function<void(Error)> ReportError)
-      : Remote(Remote), ReportError(std::move(ReportError)),
-        SymbolIdMgr(NullSymbolId + 1) {
-    using ThisT = RemoteObjectLayer<RPCEndpoint>;
-    Remote.template addHandler<ReleaseRemoteSymbol>(
-             *this, &ThisT::handleReleaseRemoteSymbol);
-    Remote.template addHandler<MaterializeRemoteSymbol>(
-             *this, &ThisT::handleMaterializeRemoteSymbol);
-  }
-
-protected:
-
-  /// This class is used as the symbol materializer for JITSymbols returned by
-  /// RemoteObjectLayerClient/RemoteObjectLayerServer -- the materializer knows
-  /// how to call back to the other RPC endpoint to get the address when
-  /// requested.
-  class RemoteSymbolMaterializer {
-  public:
-
-    /// Construct a RemoteSymbolMaterializer for the given RemoteObjectLayer
-    /// with the given Id.
-    RemoteSymbolMaterializer(RemoteObjectLayer &C,
-                             RemoteSymbolId Id)
-      : C(C), Id(Id) {}
-
-    RemoteSymbolMaterializer(const RemoteSymbolMaterializer &Other)
-      : C(Other.C), Id(Other.Id) {
-      // FIXME: This is a horrible, auto_ptr-style, copy-as-move operation.
-      //        It should be removed as soon as LLVM has C++14's generalized
-      //        lambda capture (at which point the materializer can be moved
-      //        into the lambda in remoteToJITSymbol below).
-      const_cast<RemoteSymbolMaterializer&>(Other).Id = 0;
-    }
-
-    RemoteSymbolMaterializer&
-    operator=(const RemoteSymbolMaterializer&) = delete;
-
-    /// Release the remote symbol.
-    ~RemoteSymbolMaterializer() {
-      if (Id)
-        C.releaseRemoteSymbol(Id);
-    }
-
-    /// Materialize the symbol on the remote and get its address.
-    Expected<JITTargetAddress> materialize() {
-      auto Addr = C.materializeRemoteSymbol(Id);
-      Id = 0;
-      return Addr;
-    }
-
-  private:
-    RemoteObjectLayer &C;
-    RemoteSymbolId Id;
-  };
-
-  /// Convenience function for getting a null remote symbol value.
-  RemoteSymbol nullRemoteSymbol() {
-    return RemoteSymbol(0, JITSymbolFlags());
-  }
-
-  /// Creates a StringError that contains a copy of Err's log message, then
-  /// sends that StringError to ReportError.
-  ///
-  /// This allows us to locally log error messages for errors that will actually
-  /// be delivered to the remote.
-  Error teeLog(Error Err) {
-    return handleErrors(std::move(Err),
-                        [this](std::unique_ptr<ErrorInfoBase> EIB) {
-                          ReportError(make_error<StringError>(
-                                        EIB->message(),
-                                        EIB->convertToErrorCode()));
-                          return Error(std::move(EIB));
-                        });
-  }
-
-  Error badRemoteSymbolIdError(RemoteSymbolId Id) {
-    return make_error<BadSymbolHandleError>(Id, "Remote JIT Symbol");
-  }
-
-  Error badObjectHandleError(ObjHandleT H) {
-    return make_error<RemoteObjectLayerAPI::BadObjectHandleError>(
-             H, "Bad object handle");
-  }
-
-  /// Create a RemoteSymbol wrapping the given JITSymbol.
-  Expected<RemoteSymbol> jitSymbolToRemote(JITSymbol Sym) {
-    if (Sym) {
-      auto Id = SymbolIdMgr.getNext();
-      auto Flags = Sym.getFlags();
-      assert(!InUseSymbols.count(Id) && "Symbol id already in use");
-      InUseSymbols.insert(std::make_pair(Id, std::move(Sym)));
-      return RemoteSymbol(Id, Flags);
-    } else if (auto Err = Sym.takeError())
-      return teeLog(std::move(Err));
-    // else...
-    return nullRemoteSymbol();
-  }
-
-  /// Convert an Expected<RemoteSymbol> to a JITSymbol.
-  JITSymbol remoteToJITSymbol(Expected<RemoteSymbol> RemoteSymOrErr) {
-    if (RemoteSymOrErr) {
-      auto &RemoteSym = *RemoteSymOrErr;
-      if (RemoteSym == nullRemoteSymbol())
-        return nullptr;
-      // else...
-      RemoteSymbolMaterializer RSM(*this, RemoteSym.first);
-      auto Sym =
-        JITSymbol([RSM]() mutable { return RSM.materialize(); },
-                  RemoteSym.second);
-      return Sym;
-    } else
-      return RemoteSymOrErr.takeError();
-  }
-
-  RPCEndpoint &Remote;
-  std::function<void(Error)> ReportError;
-
-private:
-
-  /// Notify the remote to release the given JITSymbol.
-  void releaseRemoteSymbol(RemoteSymbolId Id) {
-    if (auto Err = Remote.template callB<ReleaseRemoteSymbol>(Id))
-      ReportError(std::move(Err));
-  }
-
-  /// Notify the remote to materialize the JITSymbol with the given Id and
-  /// return its address.
-  Expected<JITTargetAddress> materializeRemoteSymbol(RemoteSymbolId Id) {
-    return Remote.template callB<MaterializeRemoteSymbol>(Id);
-  }
-
-  /// Release the JITSymbol with the given Id.
-  Error handleReleaseRemoteSymbol(RemoteSymbolId Id) {
-    auto SI = InUseSymbols.find(Id);
-    if (SI != InUseSymbols.end()) {
-      InUseSymbols.erase(SI);
-      return Error::success();
-    } else
-      return teeLog(badRemoteSymbolIdError(Id));
-  }
-
-  /// Run the materializer for the JITSymbol with the given Id and return its
-  /// address.
-  Expected<JITTargetAddress> handleMaterializeRemoteSymbol(RemoteSymbolId Id) {
-    auto SI = InUseSymbols.find(Id);
-    if (SI != InUseSymbols.end()) {
-      auto AddrOrErr = SI->second.getAddress();
-      InUseSymbols.erase(SI);
-      SymbolIdMgr.release(Id);
-      if (AddrOrErr)
-        return *AddrOrErr;
-      else
-        return teeLog(AddrOrErr.takeError());
-    } else {
-      return teeLog(badRemoteSymbolIdError(Id));
-    }
-  }
-
-  remote::ResourceIdMgr SymbolIdMgr;
-  std::map<RemoteSymbolId, JITSymbol> InUseSymbols;
-};
-
-/// RemoteObjectClientLayer forwards the ORC Object Layer API over an RPC
-/// connection.
-///
-/// This class can be used as the base layer of a JIT stack on the client and
-/// will forward operations to a corresponding RemoteObjectServerLayer on the
-/// server (which can be composed on top of a "real" object layer like
-/// RTDyldObjectLinkingLayer to actually carry out the operations).
-///
-/// Sending relocatable objects to the server (rather than fully relocated
-/// bits) allows JIT'd code to be cached on the server side and re-used in
-/// subsequent JIT sessions.
-template <typename RPCEndpoint>
-class RemoteObjectClientLayer : public RemoteObjectLayer<RPCEndpoint> {
-private:
-
-  using AddObject = RemoteObjectLayerAPI::AddObject;
-  using RemoveObject = RemoteObjectLayerAPI::RemoveObject;
-  using FindSymbol = RemoteObjectLayerAPI::FindSymbol;
-  using FindSymbolIn = RemoteObjectLayerAPI::FindSymbolIn;
-  using EmitAndFinalize = RemoteObjectLayerAPI::EmitAndFinalize;
-  using Lookup = RemoteObjectLayerAPI::Lookup;
-  using LookupInLogicalDylib = RemoteObjectLayerAPI::LookupInLogicalDylib;
-
-  using RemoteObjectLayer<RPCEndpoint>::teeLog;
-  using RemoteObjectLayer<RPCEndpoint>::badObjectHandleError;
-  using RemoteObjectLayer<RPCEndpoint>::remoteToJITSymbol;
-
-public:
-
-  using ObjHandleT = RemoteObjectLayerAPI::ObjHandleT;
-  using RemoteSymbol = RemoteObjectLayerAPI::RemoteSymbol;
-
-  using ObjectPtr = std::unique_ptr<MemoryBuffer>;
-
-  /// Create a RemoteObjectClientLayer that communicates with a
-  /// RemoteObjectServerLayer instance via the given RPCEndpoint.
-  ///
-  /// The ReportError functor can be used locally log errors that are intended
-  /// to be sent  sent
-  RemoteObjectClientLayer(RPCEndpoint &Remote,
-                          std::function<void(Error)> ReportError)
-      : RemoteObjectLayer<RPCEndpoint>(Remote, std::move(ReportError)) {
-    using ThisT = RemoteObjectClientLayer<RPCEndpoint>;
-    Remote.template addHandler<Lookup>(*this, &ThisT::lookup);
-    Remote.template addHandler<LookupInLogicalDylib>(
-            *this, &ThisT::lookupInLogicalDylib);
-  }
-
-  /// Add an object to the JIT.
-  ///
-  /// @return A handle that can be used to refer to the loaded object (for
-  ///         symbol searching, finalization, freeing memory, etc.).
-  Expected<ObjHandleT>
-  addObject(ObjectPtr ObjBuffer,
-            std::shared_ptr<LegacyJITSymbolResolver> Resolver) {
-    if (auto HandleOrErr =
-            this->Remote.template callB<AddObject>(ObjBuffer->getBuffer())) {
-      auto &Handle = *HandleOrErr;
-      // FIXME: Return an error for this:
-      assert(!Resolvers.count(Handle) && "Handle already in use?");
-      Resolvers[Handle] = std::move(Resolver);
-      return Handle;
-    } else
-      return HandleOrErr.takeError();
-  }
-
-  /// Remove the given object from the JIT.
-  Error removeObject(ObjHandleT H) {
-    return this->Remote.template callB<RemoveObject>(H);
-  }
-
-  /// Search for the given named symbol.
-  JITSymbol findSymbol(StringRef Name, bool ExportedSymbolsOnly) {
-    return remoteToJITSymbol(
-             this->Remote.template callB<FindSymbol>(Name,
-                                                     ExportedSymbolsOnly));
-  }
-
-  /// Search for the given named symbol within the given context.
-  JITSymbol findSymbolIn(ObjHandleT H, StringRef Name, bool ExportedSymbolsOnly) {
-    return remoteToJITSymbol(
-             this->Remote.template callB<FindSymbolIn>(H, Name,
-                                                       ExportedSymbolsOnly));
-  }
-
-  /// Immediately emit and finalize the object with the given handle.
-  Error emitAndFinalize(ObjHandleT H) {
-    return this->Remote.template callB<EmitAndFinalize>(H);
-  }
-
-private:
-
-  Expected<RemoteSymbol> lookup(ObjHandleT H, const std::string &Name) {
-    auto RI = Resolvers.find(H);
-    if (RI != Resolvers.end()) {
-      return this->jitSymbolToRemote(RI->second->findSymbol(Name));
-    } else
-      return teeLog(badObjectHandleError(H));
-  }
-
-  Expected<RemoteSymbol> lookupInLogicalDylib(ObjHandleT H,
-                                              const std::string &Name) {
-    auto RI = Resolvers.find(H);
-    if (RI != Resolvers.end())
-      return this->jitSymbolToRemote(
-               RI->second->findSymbolInLogicalDylib(Name));
-    else
-      return teeLog(badObjectHandleError(H));
-  }
-
-  std::map<remote::ResourceIdMgr::ResourceId,
-           std::shared_ptr<LegacyJITSymbolResolver>>
-      Resolvers;
-};
-
-/// RemoteObjectServerLayer acts as a server and handling RPC calls for the
-/// object layer API from the given RPC connection.
-///
-/// This class can be composed on top of a 'real' object layer (e.g.
-/// RTDyldObjectLinkingLayer) to do the actual work of relocating objects
-/// and making them executable.
-template <typename BaseLayerT, typename RPCEndpoint>
-class RemoteObjectServerLayer : public RemoteObjectLayer<RPCEndpoint> {
-private:
-
-  using ObjHandleT = RemoteObjectLayerAPI::ObjHandleT;
-  using RemoteSymbol = RemoteObjectLayerAPI::RemoteSymbol;
-
-  using AddObject = RemoteObjectLayerAPI::AddObject;
-  using RemoveObject = RemoteObjectLayerAPI::RemoveObject;
-  using FindSymbol = RemoteObjectLayerAPI::FindSymbol;
-  using FindSymbolIn = RemoteObjectLayerAPI::FindSymbolIn;
-  using EmitAndFinalize = RemoteObjectLayerAPI::EmitAndFinalize;
-  using Lookup = RemoteObjectLayerAPI::Lookup;
-  using LookupInLogicalDylib = RemoteObjectLayerAPI::LookupInLogicalDylib;
-
-  using RemoteObjectLayer<RPCEndpoint>::teeLog;
-  using RemoteObjectLayer<RPCEndpoint>::badObjectHandleError;
-  using RemoteObjectLayer<RPCEndpoint>::remoteToJITSymbol;
-
-public:
-
-  /// Create a RemoteObjectServerLayer with the given base layer (which must be
-  /// an object layer), RPC endpoint, and error reporter function.
-  RemoteObjectServerLayer(BaseLayerT &BaseLayer,
-                          RPCEndpoint &Remote,
-                          std::function<void(Error)> ReportError)
-    : RemoteObjectLayer<RPCEndpoint>(Remote, std::move(ReportError)),
-      BaseLayer(BaseLayer), HandleIdMgr(1) {
-    using ThisT = RemoteObjectServerLayer<BaseLayerT, RPCEndpoint>;
-
-    Remote.template addHandler<AddObject>(*this, &ThisT::addObject);
-    Remote.template addHandler<RemoveObject>(*this, &ThisT::removeObject);
-    Remote.template addHandler<FindSymbol>(*this, &ThisT::findSymbol);
-    Remote.template addHandler<FindSymbolIn>(*this, &ThisT::findSymbolIn);
-    Remote.template addHandler<EmitAndFinalize>(*this, &ThisT::emitAndFinalize);
-  }
-
-private:
-
-  class StringMemoryBuffer : public MemoryBuffer {
-  public:
-    StringMemoryBuffer(std::string Buffer)
-      : Buffer(std::move(Buffer)) {
-      init(this->Buffer.data(), this->Buffer.data() + this->Buffer.size(),
-           false);
-    }
-
-    BufferKind getBufferKind() const override { return MemoryBuffer_Malloc; }
-  private:
-    std::string Buffer;
-  };
-
-  JITSymbol lookup(ObjHandleT Id, const std::string &Name) {
-    return remoteToJITSymbol(
-             this->Remote.template callB<Lookup>(Id, Name));
-  }
-
-  JITSymbol lookupInLogicalDylib(ObjHandleT Id, const std::string &Name) {
-    return remoteToJITSymbol(
-             this->Remote.template callB<LookupInLogicalDylib>(Id, Name));
-  }
-
-  Expected<ObjHandleT> addObject(std::string ObjBuffer) {
-    auto Buffer = llvm::make_unique<StringMemoryBuffer>(std::move(ObjBuffer));
-    auto Id = HandleIdMgr.getNext();
-    assert(!BaseLayerHandles.count(Id) && "Id already in use?");
-
-    auto Resolver = createLambdaResolver(
-        [this, Id](const std::string &Name) { return lookup(Id, Name); },
-        [this, Id](const std::string &Name) {
-          return lookupInLogicalDylib(Id, Name);
-        });
-
-    if (auto HandleOrErr =
-            BaseLayer.addObject(std::move(Buffer), std::move(Resolver))) {
-      BaseLayerHandles[Id] = std::move(*HandleOrErr);
-      return Id;
-    } else
-      return teeLog(HandleOrErr.takeError());
-  }
-
-  Error removeObject(ObjHandleT H) {
-    auto HI = BaseLayerHandles.find(H);
-    if (HI != BaseLayerHandles.end()) {
-      if (auto Err = BaseLayer.removeObject(HI->second))
-        return teeLog(std::move(Err));
-      return Error::success();
-    } else
-      return teeLog(badObjectHandleError(H));
-  }
-
-  Expected<RemoteSymbol> findSymbol(const std::string &Name,
-                                    bool ExportedSymbolsOnly) {
-    if (auto Sym = BaseLayer.findSymbol(Name, ExportedSymbolsOnly))
-      return this->jitSymbolToRemote(std::move(Sym));
-    else if (auto Err = Sym.takeError())
-      return teeLog(std::move(Err));
-    return this->nullRemoteSymbol();
-  }
-
-  Expected<RemoteSymbol> findSymbolIn(ObjHandleT H, const std::string &Name,
-                                      bool ExportedSymbolsOnly) {
-    auto HI = BaseLayerHandles.find(H);
-    if (HI != BaseLayerHandles.end()) {
-      if (auto Sym = BaseLayer.findSymbolIn(HI->second, Name, ExportedSymbolsOnly))
-        return this->jitSymbolToRemote(std::move(Sym));
-      else if (auto Err = Sym.takeError())
-        return teeLog(std::move(Err));
-      return this->nullRemoteSymbol();
-    } else
-      return teeLog(badObjectHandleError(H));
-  }
-
-  Error emitAndFinalize(ObjHandleT H) {
-    auto HI = BaseLayerHandles.find(H);
-    if (HI != BaseLayerHandles.end()) {
-      if (auto Err = BaseLayer.emitAndFinalize(HI->second))
-        return teeLog(std::move(Err));
-      return Error::success();
-    } else
-      return teeLog(badObjectHandleError(H));
-  }
-
-  BaseLayerT &BaseLayer;
-  remote::ResourceIdMgr HandleIdMgr;
-  std::map<ObjHandleT, typename BaseLayerT::ObjHandleT> BaseLayerHandles;
-};
-
-} // end namespace orc
-} // end namespace llvm
-
-#endif // LLVM_EXECUTIONENGINE_ORC_REMOTEOBJECTLAYER_H
diff --git a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/Shared/FDRawByteChannel.h b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/Shared/FDRawByteChannel.h
new file mode 100644
index 0000000..3f96fe3
--- /dev/null
+++ b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/Shared/FDRawByteChannel.h
@@ -0,0 +1,79 @@
+//===- FDRawByteChannel.h - File descriptor based byte-channel -*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// File descriptor based RawByteChannel.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_EXECUTIONENGINE_ORC_SHARED_FDRAWBYTECHANNEL_H
+#define LLVM_EXECUTIONENGINE_ORC_SHARED_FDRAWBYTECHANNEL_H
+
+#include "llvm/ExecutionEngine/Orc/Shared/RawByteChannel.h"
+
+#if !defined(_MSC_VER) && !defined(__MINGW32__)
+#include <unistd.h>
+#else
+#include <io.h>
+#endif
+
+namespace llvm {
+namespace orc {
+namespace shared {
+
+/// Serialization channel that reads from and writes from file descriptors.
+class FDRawByteChannel final : public RawByteChannel {
+public:
+  FDRawByteChannel(int InFD, int OutFD) : InFD(InFD), OutFD(OutFD) {}
+
+  llvm::Error readBytes(char *Dst, unsigned Size) override {
+    assert(Dst && "Attempt to read into null.");
+    ssize_t Completed = 0;
+    while (Completed < static_cast<ssize_t>(Size)) {
+      ssize_t Read = ::read(InFD, Dst + Completed, Size - Completed);
+      if (Read <= 0) {
+        auto ErrNo = errno;
+        if (ErrNo == EAGAIN || ErrNo == EINTR)
+          continue;
+        else
+          return llvm::errorCodeToError(
+              std::error_code(errno, std::generic_category()));
+      }
+      Completed += Read;
+    }
+    return llvm::Error::success();
+  }
+
+  llvm::Error appendBytes(const char *Src, unsigned Size) override {
+    assert(Src && "Attempt to append from null.");
+    ssize_t Completed = 0;
+    while (Completed < static_cast<ssize_t>(Size)) {
+      ssize_t Written = ::write(OutFD, Src + Completed, Size - Completed);
+      if (Written < 0) {
+        auto ErrNo = errno;
+        if (ErrNo == EAGAIN || ErrNo == EINTR)
+          continue;
+        else
+          return llvm::errorCodeToError(
+              std::error_code(errno, std::generic_category()));
+      }
+      Completed += Written;
+    }
+    return llvm::Error::success();
+  }
+
+  llvm::Error send() override { return llvm::Error::success(); }
+
+private:
+  int InFD, OutFD;
+};
+
+} // namespace shared
+} // namespace orc
+} // namespace llvm
+
+#endif // LLVM_EXECUTIONENGINE_ORC_SHARED_FDRAWBYTECHANNEL_H
diff --git a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/RPCUtils.h b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/Shared/RPCUtils.h
similarity index 85%
rename from linux-x64/clang/include/llvm/ExecutionEngine/Orc/RPCUtils.h
rename to linux-x64/clang/include/llvm/ExecutionEngine/Orc/Shared/RPCUtils.h
index 3b11e1b..1c8b8e0 100644
--- a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/RPCUtils.h
+++ b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/Shared/RPCUtils.h
@@ -14,8 +14,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_EXECUTIONENGINE_ORC_RPCUTILS_H
-#define LLVM_EXECUTIONENGINE_ORC_RPCUTILS_H
+#ifndef LLVM_EXECUTIONENGINE_ORC_SHARED_RPCUTILS_H
+#define LLVM_EXECUTIONENGINE_ORC_SHARED_RPCUTILS_H
 
 #include <map>
 #include <thread>
@@ -23,14 +23,14 @@
 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ExecutionEngine/Orc/OrcError.h"
-#include "llvm/ExecutionEngine/Orc/RPCSerialization.h"
+#include "llvm/ExecutionEngine/Orc/Shared/Serialization.h"
 #include "llvm/Support/MSVCErrorWorkarounds.h"
 
 #include <future>
 
 namespace llvm {
 namespace orc {
-namespace rpc {
+namespace shared {
 
 /// Base class of all fatal RPC errors (those that necessarily result in the
 /// termination of the RPC session).
@@ -56,7 +56,7 @@
 /// function id it cannot parse the call.
 template <typename FnIdT, typename SeqNoT>
 class BadFunctionCall
-  : public ErrorInfo<BadFunctionCall<FnIdT, SeqNoT>, RPCFatalError> {
+    : public ErrorInfo<BadFunctionCall<FnIdT, SeqNoT>, RPCFatalError> {
 public:
   static char ID;
 
@@ -68,8 +68,10 @@
   }
 
   void log(raw_ostream &OS) const override {
-    OS << "Call to invalid RPC function id '" << FnId << "' with "
-          "sequence number " << SeqNo;
+    OS << "Call to invalid RPC function id '" << FnId
+       << "' with "
+          "sequence number "
+       << SeqNo;
   }
 
 private:
@@ -89,12 +91,12 @@
 /// a result parser for this sequence number it can't do that.
 template <typename SeqNoT>
 class InvalidSequenceNumberForResponse
-    : public ErrorInfo<InvalidSequenceNumberForResponse<SeqNoT>, RPCFatalError> {
+    : public ErrorInfo<InvalidSequenceNumberForResponse<SeqNoT>,
+                       RPCFatalError> {
 public:
   static char ID;
 
-  InvalidSequenceNumberForResponse(SeqNoT SeqNo)
-      : SeqNo(std::move(SeqNo)) {}
+  InvalidSequenceNumberForResponse(SeqNoT SeqNo) : SeqNo(std::move(SeqNo)) {}
 
   std::error_code convertToErrorCode() const override {
     return orcError(OrcErrorCode::UnexpectedRPCCall);
@@ -103,6 +105,7 @@
   void log(raw_ostream &OS) const override {
     OS << "Response has unknown sequence number " << SeqNo;
   }
+
 private:
   SeqNoT SeqNo;
 };
@@ -131,17 +134,18 @@
   std::error_code convertToErrorCode() const override;
   void log(raw_ostream &OS) const override;
   const std::string &getSignature() const { return Signature; }
+
 private:
   std::string Signature;
 };
 
-template <typename DerivedFunc, typename FnT> class Function;
+template <typename DerivedFunc, typename FnT> class RPCFunction;
 
 // RPC Function class.
 // DerivedFunc should be a user defined class with a static 'getName()' method
 // returning a const char* representing the function's name.
 template <typename DerivedFunc, typename RetT, typename... ArgTs>
-class Function<DerivedFunc, RetT(ArgTs...)> {
+class RPCFunction<DerivedFunc, RetT(ArgTs...)> {
 public:
   /// User defined function type.
   using Type = RetT(ArgTs...);
@@ -154,8 +158,9 @@
     static std::string Name = [] {
       std::string Name;
       raw_string_ostream(Name)
-          << RPCTypeName<RetT>::getName() << " " << DerivedFunc::getName()
-          << "(" << llvm::orc::rpc::RPCTypeNameSequence<ArgTs...>() << ")";
+          << SerializationTypeName<RetT>::getName() << " "
+          << DerivedFunc::getName() << "("
+          << SerializationTypeNameSequence<ArgTs...>() << ")";
       return Name;
     }();
     return Name.data();
@@ -184,8 +189,7 @@
 /// This specialization of RPCFunctionIdAllocator provides a default
 /// implementation for integral types.
 template <typename T>
-class RPCFunctionIdAllocator<
-    T, typename std::enable_if<std::is_integral<T>::value>::type> {
+class RPCFunctionIdAllocator<T, std::enable_if_t<std::is_integral<T>::value>> {
 public:
   static T getInvalidId() { return T(0); }
   static T getResponseId() { return T(1); }
@@ -200,13 +204,12 @@
 namespace detail {
 
 /// Provides a typedef for a tuple containing the decayed argument types.
-template <typename T> class FunctionArgsTuple;
+template <typename T> class RPCFunctionArgsTuple;
 
 template <typename RetT, typename... ArgTs>
-class FunctionArgsTuple<RetT(ArgTs...)> {
+class RPCFunctionArgsTuple<RetT(ArgTs...)> {
 public:
-  using Type = std::tuple<typename std::decay<
-      typename std::remove_reference<ArgTs>::type>::type...>;
+  using Type = std::tuple<std::decay_t<std::remove_reference_t<ArgTs>>...>;
 };
 
 // ResultTraits provides typedefs and utilities specific to the return type
@@ -289,34 +292,28 @@
 
 // Determines whether an RPC function's defined error return type supports
 // error return value.
-template <typename T>
-class SupportsErrorReturn {
+template <typename T> class SupportsErrorReturn {
 public:
   static const bool value = false;
 };
 
-template <>
-class SupportsErrorReturn<Error> {
+template <> class SupportsErrorReturn<Error> {
 public:
   static const bool value = true;
 };
 
-template <typename T>
-class SupportsErrorReturn<Expected<T>> {
+template <typename T> class SupportsErrorReturn<Expected<T>> {
 public:
   static const bool value = true;
 };
 
 // RespondHelper packages return values based on whether or not the declared
 // RPC function return type supports error returns.
-template <bool FuncSupportsErrorReturn>
-class RespondHelper;
+template <bool FuncSupportsErrorReturn> class RespondHelper;
 
 // RespondHelper specialization for functions that support error returns.
-template <>
-class RespondHelper<true> {
+template <> class RespondHelper<true> {
 public:
-
   // Send Expected<T>.
   template <typename WireRetT, typename HandlerRetT, typename ChannelT,
             typename FunctionIdT, typename SequenceNumberT>
@@ -332,13 +329,14 @@
 
     // Serialize the result.
     if (auto Err =
-        SerializationTraits<ChannelT, WireRetT,
-                            Expected<HandlerRetT>>::serialize(
-                                                     C, std::move(ResultOrErr)))
+            SerializationTraits<ChannelT, WireRetT, Expected<HandlerRetT>>::
+                serialize(C, std::move(ResultOrErr)))
       return Err;
 
     // Close the response message.
-    return C.endSendMessage();
+    if (auto Err = C.endSendMessage())
+      return Err;
+    return C.send();
   }
 
   template <typename ChannelT, typename FunctionIdT, typename SequenceNumberT>
@@ -350,16 +348,15 @@
       return Err2;
     if (auto Err2 = serializeSeq(C, std::move(Err)))
       return Err2;
-    return C.endSendMessage();
+    if (auto Err2 = C.endSendMessage())
+      return Err2;
+    return C.send();
   }
-
 };
 
 // RespondHelper specialization for functions that do not support error returns.
-template <>
-class RespondHelper<false> {
+template <> class RespondHelper<false> {
 public:
-
   template <typename WireRetT, typename HandlerRetT, typename ChannelT,
             typename FunctionIdT, typename SequenceNumberT>
   static Error sendResult(ChannelT &C, const FunctionIdT &ResponseId,
@@ -374,12 +371,15 @@
 
     // Serialize the result.
     if (auto Err =
-        SerializationTraits<ChannelT, WireRetT, HandlerRetT>::serialize(
-                                                               C, *ResultOrErr))
+            SerializationTraits<ChannelT, WireRetT, HandlerRetT>::serialize(
+                C, *ResultOrErr))
       return Err;
 
-    // Close the response message.
-    return C.endSendMessage();
+    // End the response message.
+    if (auto Err = C.endSendMessage())
+      return Err;
+
+    return C.send();
   }
 
   template <typename ChannelT, typename FunctionIdT, typename SequenceNumberT>
@@ -389,20 +389,21 @@
       return Err;
     if (auto Err2 = C.startSendMessage(ResponseId, SeqNo))
       return Err2;
-    return C.endSendMessage();
+    if (auto Err2 = C.endSendMessage())
+      return Err2;
+    return C.send();
   }
-
 };
 
-
 // Send a response of the given wire return type (WireRetT) over the
 // channel, with the given sequence number.
 template <typename WireRetT, typename HandlerRetT, typename ChannelT,
           typename FunctionIdT, typename SequenceNumberT>
-Error respond(ChannelT &C, const FunctionIdT &ResponseId,
-              SequenceNumberT SeqNo, Expected<HandlerRetT> ResultOrErr) {
+Error respond(ChannelT &C, const FunctionIdT &ResponseId, SequenceNumberT SeqNo,
+              Expected<HandlerRetT> ResultOrErr) {
   return RespondHelper<SupportsErrorReturn<WireRetT>::value>::
-    template sendResult<WireRetT>(C, ResponseId, SeqNo, std::move(ResultOrErr));
+      template sendResult<WireRetT>(C, ResponseId, SeqNo,
+                                    std::move(ResultOrErr));
 }
 
 // Send an empty response message on the given channel to indicate that
@@ -411,8 +412,8 @@
           typename SequenceNumberT>
 Error respond(ChannelT &C, const FunctionIdT &ResponseId, SequenceNumberT SeqNo,
               Error Err) {
-  return RespondHelper<SupportsErrorReturn<WireRetT>::value>::
-    sendResult(C, ResponseId, SeqNo, std::move(Err));
+  return RespondHelper<SupportsErrorReturn<WireRetT>::value>::sendResult(
+      C, ResponseId, SeqNo, std::move(Err));
 }
 
 // Converts a given type to the equivalent error return type.
@@ -446,7 +447,8 @@
 template <typename FnT> class AsyncHandlerTraits;
 
 template <typename ResultT, typename... ArgTs>
-class AsyncHandlerTraits<Error(std::function<Error(Expected<ResultT>)>, ArgTs...)> {
+class AsyncHandlerTraits<Error(std::function<Error(Expected<ResultT>)>,
+                               ArgTs...)> {
 public:
   using Type = Error(ArgTs...);
   using ResultType = Expected<ResultT>;
@@ -474,18 +476,18 @@
 };
 
 template <typename ResponseHandlerT, typename... ArgTs>
-class AsyncHandlerTraits<Error(ResponseHandlerT, ArgTs...)> :
-    public AsyncHandlerTraits<Error(typename std::decay<ResponseHandlerT>::type,
-                                    ArgTs...)> {};
+class AsyncHandlerTraits<Error(ResponseHandlerT, ArgTs...)>
+    : public AsyncHandlerTraits<Error(std::decay_t<ResponseHandlerT>,
+                                      ArgTs...)> {};
 
 // This template class provides utilities related to RPC function handlers.
 // The base case applies to non-function types (the template class is
 // specialized for function types) and inherits from the appropriate
 // speciilization for the given non-function type's call operator.
 template <typename HandlerT>
-class HandlerTraits : public HandlerTraits<decltype(
-                          &std::remove_reference<HandlerT>::type::operator())> {
-};
+class HandlerTraits
+    : public HandlerTraits<
+          decltype(&std::remove_reference<HandlerT>::type::operator())> {};
 
 // Traits for handlers with a given function type.
 template <typename RetT, typename... ArgTs>
@@ -502,7 +504,7 @@
   static typename WrappedHandlerReturn<RetT>::Type
   unpackAndRun(HandlerT &Handler, std::tuple<TArgTs...> &Args) {
     return unpackAndRunHelper(Handler, Args,
-                              llvm::index_sequence_for<TArgTs...>());
+                              std::index_sequence_for<TArgTs...>());
   }
 
   // Call the given handler with the given arguments.
@@ -510,23 +512,22 @@
   static Error unpackAndRunAsync(HandlerT &Handler, ResponderT &Responder,
                                  std::tuple<TArgTs...> &Args) {
     return unpackAndRunAsyncHelper(Handler, Responder, Args,
-                                   llvm::index_sequence_for<TArgTs...>());
+                                   std::index_sequence_for<TArgTs...>());
   }
 
   // Call the given handler with the given arguments.
   template <typename HandlerT>
-  static typename std::enable_if<
-      std::is_void<typename HandlerTraits<HandlerT>::ReturnType>::value,
-      Error>::type
-  run(HandlerT &Handler, ArgTs &&... Args) {
+  static std::enable_if_t<
+      std::is_void<typename HandlerTraits<HandlerT>::ReturnType>::value, Error>
+  run(HandlerT &Handler, ArgTs &&...Args) {
     Handler(std::move(Args)...);
     return Error::success();
   }
 
   template <typename HandlerT, typename... TArgTs>
-  static typename std::enable_if<
+  static std::enable_if_t<
       !std::is_void<typename HandlerTraits<HandlerT>::ReturnType>::value,
-      typename HandlerTraits<HandlerT>::ReturnType>::type
+      typename HandlerTraits<HandlerT>::ReturnType>
   run(HandlerT &Handler, TArgTs... Args) {
     return Handler(std::move(Args)...);
   }
@@ -540,14 +541,13 @@
   // Deserialize arguments from the channel.
   template <typename ChannelT, typename... CArgTs>
   static Error deserializeArgs(ChannelT &C, std::tuple<CArgTs...> &Args) {
-    return deserializeArgsHelper(C, Args,
-                                 llvm::index_sequence_for<CArgTs...>());
+    return deserializeArgsHelper(C, Args, std::index_sequence_for<CArgTs...>());
   }
 
 private:
   template <typename ChannelT, typename... CArgTs, size_t... Indexes>
   static Error deserializeArgsHelper(ChannelT &C, std::tuple<CArgTs...> &Args,
-                                     llvm::index_sequence<Indexes...> _) {
+                                     std::index_sequence<Indexes...> _) {
     return SequenceSerialization<ChannelT, ArgTs...>::deserialize(
         C, std::get<Indexes>(Args)...);
   }
@@ -556,26 +556,24 @@
   static typename WrappedHandlerReturn<
       typename HandlerTraits<HandlerT>::ReturnType>::Type
   unpackAndRunHelper(HandlerT &Handler, ArgTuple &Args,
-                     llvm::index_sequence<Indexes...>) {
+                     std::index_sequence<Indexes...>) {
     return run(Handler, std::move(std::get<Indexes>(Args))...);
   }
 
-
   template <typename HandlerT, typename ResponderT, typename ArgTuple,
             size_t... Indexes>
   static typename WrappedHandlerReturn<
       typename HandlerTraits<HandlerT>::ReturnType>::Type
   unpackAndRunAsyncHelper(HandlerT &Handler, ResponderT &Responder,
-                          ArgTuple &Args,
-                          llvm::index_sequence<Indexes...>) {
+                          ArgTuple &Args, std::index_sequence<Indexes...>) {
     return run(Handler, Responder, std::move(std::get<Indexes>(Args))...);
   }
 };
 
 // Handler traits for free functions.
 template <typename RetT, typename... ArgTs>
-class HandlerTraits<RetT(*)(ArgTs...)>
-  : public HandlerTraits<RetT(ArgTs...)> {};
+class HandlerTraits<RetT (*)(ArgTs...)> : public HandlerTraits<RetT(ArgTs...)> {
+};
 
 // Handler traits for class methods (especially call operators for lambdas).
 template <typename Class, typename RetT, typename... ArgTs>
@@ -711,9 +709,8 @@
         typename HandlerTraits<HandlerT>::Type>::ArgType;
     HandlerArgType Result((typename HandlerArgType::value_type()));
 
-    if (auto Err =
-            SerializationTraits<ChannelT, Expected<FuncRetT>,
-                                HandlerArgType>::deserialize(C, Result))
+    if (auto Err = SerializationTraits<ChannelT, Expected<FuncRetT>,
+                                       HandlerArgType>::deserialize(C, Result))
       return Err;
     if (auto Err = C.endReceiveMessage())
       return Err;
@@ -743,11 +740,15 @@
   // to the user defined handler.
   Error handleResponse(ChannelT &C) override {
     Error Result = Error::success();
-    if (auto Err =
-            SerializationTraits<ChannelT, Error, Error>::deserialize(C, Result))
+    if (auto Err = SerializationTraits<ChannelT, Error, Error>::deserialize(
+            C, Result)) {
+      consumeError(std::move(Result));
       return Err;
-    if (auto Err = C.endReceiveMessage())
+    }
+    if (auto Err = C.endReceiveMessage()) {
+      consumeError(std::move(Result));
       return Err;
+    }
     return Handler(std::move(Result));
   }
 
@@ -767,7 +768,7 @@
 // Create a ResponseHandler from a given user handler.
 template <typename ChannelT, typename FuncRetT, typename HandlerT>
 std::unique_ptr<ResponseHandler<ChannelT>> createResponseHandler(HandlerT H) {
-  return llvm::make_unique<ResponseHandlerImpl<ChannelT, FuncRetT, HandlerT>>(
+  return std::make_unique<ResponseHandlerImpl<ChannelT, FuncRetT, HandlerT>>(
       std::move(H));
 }
 
@@ -779,7 +780,7 @@
   using MethodT = RetT (ClassT::*)(ArgTs...);
   MemberFnWrapper(ClassT &Instance, MethodT Method)
       : Instance(Instance), Method(Method) {}
-  RetT operator()(ArgTs &&... Args) {
+  RetT operator()(ArgTs &&...Args) {
     return (Instance.*Method)(std::move(Args)...);
   }
 
@@ -797,10 +798,9 @@
 template <typename ArgT, typename... ArgTs>
 class ReadArgs<ArgT, ArgTs...> : public ReadArgs<ArgTs...> {
 public:
-  ReadArgs(ArgT &Arg, ArgTs &... Args)
-      : ReadArgs<ArgTs...>(Args...), Arg(Arg) {}
+  ReadArgs(ArgT &Arg, ArgTs &...Args) : ReadArgs<ArgTs...>(Args...), Arg(Arg) {}
 
-  Error operator()(ArgT &ArgVal, ArgTs &... ArgVals) {
+  Error operator()(ArgT &ArgVal, ArgTs &...ArgVals) {
     this->Arg = std::move(ArgVal);
     return ReadArgs<ArgTs...>::operator()(ArgVals...);
   }
@@ -865,8 +865,8 @@
 template <template <class, class> class P, typename T1Sig, typename T2Sig>
 class RPCArgTypeCheck {
 public:
-  using T1Tuple = typename FunctionArgsTuple<T1Sig>::Type;
-  using T2Tuple = typename FunctionArgsTuple<T2Sig>::Type;
+  using T1Tuple = typename RPCFunctionArgsTuple<T1Sig>::Type;
+  using T2Tuple = typename RPCFunctionArgsTuple<T2Sig>::Type;
 
   static_assert(std::tuple_size<T1Tuple>::value >=
                     std::tuple_size<T2Tuple>::value,
@@ -884,12 +884,12 @@
   using S = SerializationTraits<ChannelT, WireT, ConcreteT>;
 
   template <typename T>
-  static std::true_type
-  check(typename std::enable_if<
-        std::is_same<decltype(T::serialize(std::declval<ChannelT &>(),
-                                           std::declval<const ConcreteT &>())),
-                     Error>::value,
-        void *>::type);
+  static std::true_type check(
+      std::enable_if_t<std::is_same<decltype(T::serialize(
+                                        std::declval<ChannelT &>(),
+                                        std::declval<const ConcreteT &>())),
+                                    Error>::value,
+                       void *>);
 
   template <typename> static std::false_type check(...);
 
@@ -904,11 +904,11 @@
 
   template <typename T>
   static std::true_type
-  check(typename std::enable_if<
-        std::is_same<decltype(T::deserialize(std::declval<ChannelT &>(),
-                                             std::declval<ConcreteT &>())),
-                     Error>::value,
-        void *>::type);
+      check(std::enable_if_t<
+            std::is_same<decltype(T::deserialize(std::declval<ChannelT &>(),
+                                                 std::declval<ConcreteT &>())),
+                         Error>::value,
+            void *>);
 
   template <typename> static std::false_type check(...);
 
@@ -930,18 +930,18 @@
           typename SequenceNumberT>
 class RPCEndpointBase {
 protected:
-  class OrcRPCInvalid : public Function<OrcRPCInvalid, void()> {
+  class OrcRPCInvalid : public RPCFunction<OrcRPCInvalid, void()> {
   public:
     static const char *getName() { return "__orc_rpc$invalid"; }
   };
 
-  class OrcRPCResponse : public Function<OrcRPCResponse, void()> {
+  class OrcRPCResponse : public RPCFunction<OrcRPCResponse, void()> {
   public:
     static const char *getName() { return "__orc_rpc$response"; }
   };
 
   class OrcRPCNegotiate
-      : public Function<OrcRPCNegotiate, FunctionIdT(std::string)> {
+      : public RPCFunction<OrcRPCNegotiate, FunctionIdT(std::string)> {
   public:
     static const char *getName() { return "__orc_rpc$negotiate"; }
   };
@@ -987,7 +987,6 @@
         [this](const std::string &Name) { return handleNegotiate(Name); });
   }
 
-
   /// Negotiate a function id for Func with the other end of the channel.
   template <typename Func> Error negotiateFunction(bool Retry = false) {
     return getRemoteFunctionId<Func>(true, Retry).takeError();
@@ -999,7 +998,7 @@
   /// or an Error (if Func::ReturnType is void). The handler will be called
   /// with an error if the return value is abandoned due to a channel error.
   template <typename Func, typename HandlerT, typename... ArgTs>
-  Error appendCallAsync(HandlerT Handler, const ArgTs &... Args) {
+  Error appendCallAsync(HandlerT Handler, const ArgTs &...Args) {
 
     static_assert(
         detail::RPCArgTypeCheck<CanSerializeCheck, typename Func::Type,
@@ -1029,8 +1028,8 @@
 
       // Install the user handler.
       PendingResponses[SeqNo] =
-        detail::createResponseHandler<ChannelT, typename Func::ReturnType>(
-            std::move(Handler));
+          detail::createResponseHandler<ChannelT, typename Func::ReturnType>(
+              std::move(Handler));
     }
 
     // Open the function call message.
@@ -1058,7 +1057,7 @@
   Error sendAppendedCalls() { return C.send(); };
 
   template <typename Func, typename HandlerT, typename... ArgTs>
-  Error callAsync(HandlerT Handler, const ArgTs &... Args) {
+  Error callAsync(HandlerT Handler, const ArgTs &...Args) {
     if (auto Err = appendCallAsync<Func>(std::move(Handler), Args...))
       return Err;
     return C.send();
@@ -1097,7 +1096,7 @@
   ///     /* Handle Args */ ;
   ///
   template <typename... ArgTs>
-  static detail::ReadArgs<ArgTs...> readArgs(ArgTs &... Args) {
+  static detail::ReadArgs<ArgTs...> readArgs(ArgTs &...Args) {
     return detail::ReadArgs<ArgTs...>(Args...);
   }
 
@@ -1121,8 +1120,7 @@
 
   /// Remove the handler for the given function.
   /// A handler must currently be registered for this function.
-  template <typename Func>
-  void removeHandler() {
+  template <typename Func> void removeHandler() {
     auto IdItr = LocalFunctionIds.find(Func::getPrototype());
     assert(IdItr != LocalFunctionIds.end() &&
            "Function does not have a registered handler");
@@ -1133,12 +1131,9 @@
   }
 
   /// Clear all handlers.
-  void clearHandlers() {
-    Handlers.clear();
-  }
+  void clearHandlers() { Handlers.clear(); }
 
 protected:
-
   FunctionIdT getInvalidFunctionId() const {
     return FnIdAllocator.getInvalidId();
   }
@@ -1161,12 +1156,12 @@
   template <typename Func, typename HandlerT>
   void addAsyncHandlerImpl(HandlerT Handler) {
 
-    static_assert(detail::RPCArgTypeCheck<
-                      CanDeserializeCheck, typename Func::Type,
-                      typename detail::AsyncHandlerTraits<
-                        typename detail::HandlerTraits<HandlerT>::Type
-                      >::Type>::value,
-                  "");
+    static_assert(
+        detail::RPCArgTypeCheck<
+            CanDeserializeCheck, typename Func::Type,
+            typename detail::AsyncHandlerTraits<
+                typename detail::HandlerTraits<HandlerT>::Type>::Type>::value,
+        "");
 
     FunctionIdT NewFnId = FnIdAllocator.template allocate<Func>();
     LocalFunctionIds[Func::getPrototype()] = NewFnId;
@@ -1190,8 +1185,8 @@
         // Unlock the pending results map to prevent recursive lock.
         Lock.unlock();
         abandonPendingResponses();
-        return make_error<
-                 InvalidSequenceNumberForResponse<SequenceNumberT>>(SeqNo);
+        return make_error<InvalidSequenceNumberForResponse<SequenceNumberT>>(
+            SeqNo);
       }
     }
 
@@ -1234,7 +1229,7 @@
     if (DoNegotiate) {
       auto &Impl = static_cast<ImplT &>(*this);
       if (auto RemoteIdOrErr =
-          Impl.template callB<OrcRPCNegotiate>(Func::getPrototype())) {
+              Impl.template callB<OrcRPCNegotiate>(Func::getPrototype())) {
         RemoteFunctionIds[Func::getPrototype()] = *RemoteIdOrErr;
         if (*RemoteIdOrErr == getInvalidFunctionId())
           return make_error<CouldNotNegotiate>(Func::getPrototype());
@@ -1257,9 +1252,8 @@
     return [this, Handler](ChannelT &Channel,
                            SequenceNumberT SeqNo) mutable -> Error {
       // Start by deserializing the arguments.
-      using ArgsTuple =
-          typename detail::FunctionArgsTuple<
-            typename detail::HandlerTraits<HandlerT>::Type>::Type;
+      using ArgsTuple = typename detail::RPCFunctionArgsTuple<
+          typename detail::HandlerTraits<HandlerT>::Type>::Type;
       auto Args = std::make_shared<ArgsTuple>();
 
       if (auto Err =
@@ -1291,9 +1285,9 @@
                            SequenceNumberT SeqNo) mutable -> Error {
       // Start by deserializing the arguments.
       using AHTraits = detail::AsyncHandlerTraits<
-                         typename detail::HandlerTraits<HandlerT>::Type>;
+          typename detail::HandlerTraits<HandlerT>::Type>;
       using ArgsTuple =
-          typename detail::FunctionArgsTuple<typename AHTraits::Type>::Type;
+          typename detail::RPCFunctionArgsTuple<typename AHTraits::Type>::Type;
       auto Args = std::make_shared<ArgsTuple>();
 
       if (auto Err =
@@ -1312,11 +1306,11 @@
 
       using HTraits = detail::HandlerTraits<HandlerT>;
       using FuncReturn = typename Func::ReturnType;
-      auto Responder =
-        [this, SeqNo](typename AHTraits::ResultType RetVal) -> Error {
-          return detail::respond<FuncReturn>(C, ResponseId, SeqNo,
-                                             std::move(RetVal));
-        };
+      auto Responder = [this,
+                        SeqNo](typename AHTraits::ResultType RetVal) -> Error {
+        return detail::respond<FuncReturn>(C, ResponseId, SeqNo,
+                                           std::move(RetVal));
+      };
 
       return HTraits::unpackAndRunAsync(Handler, Responder, *Args);
     };
@@ -1349,17 +1343,16 @@
           MultiThreadedRPCEndpoint<ChannelT, FunctionIdT, SequenceNumberT>,
           ChannelT, FunctionIdT, SequenceNumberT> {
 private:
-  using BaseClass =
-      detail::RPCEndpointBase<
-        MultiThreadedRPCEndpoint<ChannelT, FunctionIdT, SequenceNumberT>,
-        ChannelT, FunctionIdT, SequenceNumberT>;
+  using BaseClass = detail::RPCEndpointBase<
+      MultiThreadedRPCEndpoint<ChannelT, FunctionIdT, SequenceNumberT>,
+      ChannelT, FunctionIdT, SequenceNumberT>;
 
 public:
   MultiThreadedRPCEndpoint(ChannelT &C, bool LazyAutoNegotiation)
       : BaseClass(C, LazyAutoNegotiation) {}
 
   /// Add a handler for the given RPC function.
-  /// This installs the given handler functor for the given RPC Function, and
+  /// This installs the given handler functor for the given RPCFunction, and
   /// makes the RPC function available for negotiation/calling from the remote.
   template <typename Func, typename HandlerT>
   void addHandler(HandlerT Handler) {
@@ -1370,7 +1363,7 @@
   template <typename Func, typename ClassT, typename RetT, typename... ArgTs>
   void addHandler(ClassT &Object, RetT (ClassT::*Method)(ArgTs...)) {
     addHandler<Func>(
-      detail::MemberFnWrapper<ClassT, RetT, ArgTs...>(Object, Method));
+        detail::MemberFnWrapper<ClassT, RetT, ArgTs...>(Object, Method));
   }
 
   template <typename Func, typename HandlerT>
@@ -1382,7 +1375,7 @@
   template <typename Func, typename ClassT, typename RetT, typename... ArgTs>
   void addAsyncHandler(ClassT &Object, RetT (ClassT::*Method)(ArgTs...)) {
     addAsyncHandler<Func>(
-      detail::MemberFnWrapper<ClassT, RetT, ArgTs...>(Object, Method));
+        detail::MemberFnWrapper<ClassT, RetT, ArgTs...>(Object, Method));
   }
 
   /// Return type for non-blocking call primitives.
@@ -1398,19 +1391,17 @@
   /// result. In multi-threaded mode the appendCallNB method, which does not
   /// return the sequence numeber, should be preferred.
   template <typename Func, typename... ArgTs>
-  Expected<NonBlockingCallResult<Func>> appendCallNB(const ArgTs &... Args) {
+  Expected<NonBlockingCallResult<Func>> appendCallNB(const ArgTs &...Args) {
     using RTraits = detail::ResultTraits<typename Func::ReturnType>;
     using ErrorReturn = typename RTraits::ErrorReturnType;
     using ErrorReturnPromise = typename RTraits::ReturnPromiseType;
 
-    // FIXME: Stack allocate and move this into the handler once LLVM builds
-    //        with C++14.
-    auto Promise = std::make_shared<ErrorReturnPromise>();
-    auto FutureResult = Promise->get_future();
+    ErrorReturnPromise Promise;
+    auto FutureResult = Promise.get_future();
 
     if (auto Err = this->template appendCallAsync<Func>(
-            [Promise](ErrorReturn RetOrErr) {
-              Promise->set_value(std::move(RetOrErr));
+            [Promise = std::move(Promise)](ErrorReturn RetOrErr) mutable {
+              Promise.set_value(std::move(RetOrErr));
               return Error::success();
             },
             Args...)) {
@@ -1423,7 +1414,7 @@
   /// The same as appendCallNBWithSeq, except that it calls C.send() to
   /// flush the channel after serializing the call.
   template <typename Func, typename... ArgTs>
-  Expected<NonBlockingCallResult<Func>> callNB(const ArgTs &... Args) {
+  Expected<NonBlockingCallResult<Func>> callNB(const ArgTs &...Args) {
     auto Result = appendCallNB<Func>(Args...);
     if (!Result)
       return Result;
@@ -1444,7 +1435,7 @@
   template <typename Func, typename... ArgTs,
             typename AltRetT = typename Func::ReturnType>
   typename detail::ResultTraits<AltRetT>::ErrorReturnType
-  callB(const ArgTs &... Args) {
+  callB(const ArgTs &...Args) {
     if (auto FutureResOrErr = callNB<Func>(Args...))
       return FutureResOrErr->get();
     else
@@ -1467,10 +1458,9 @@
           SingleThreadedRPCEndpoint<ChannelT, FunctionIdT, SequenceNumberT>,
           ChannelT, FunctionIdT, SequenceNumberT> {
 private:
-  using BaseClass =
-      detail::RPCEndpointBase<
-        SingleThreadedRPCEndpoint<ChannelT, FunctionIdT, SequenceNumberT>,
-        ChannelT, FunctionIdT, SequenceNumberT>;
+  using BaseClass = detail::RPCEndpointBase<
+      SingleThreadedRPCEndpoint<ChannelT, FunctionIdT, SequenceNumberT>,
+      ChannelT, FunctionIdT, SequenceNumberT>;
 
 public:
   SingleThreadedRPCEndpoint(ChannelT &C, bool LazyAutoNegotiation)
@@ -1496,13 +1486,13 @@
   template <typename Func, typename ClassT, typename RetT, typename... ArgTs>
   void addAsyncHandler(ClassT &Object, RetT (ClassT::*Method)(ArgTs...)) {
     addAsyncHandler<Func>(
-      detail::MemberFnWrapper<ClassT, RetT, ArgTs...>(Object, Method));
+        detail::MemberFnWrapper<ClassT, RetT, ArgTs...>(Object, Method));
   }
 
   template <typename Func, typename... ArgTs,
             typename AltRetT = typename Func::ReturnType>
   typename detail::ResultTraits<AltRetT>::ErrorReturnType
-  callB(const ArgTs &... Args) {
+  callB(const ArgTs &...Args) {
     bool ReceivedResponse = false;
     using ResultType = typename detail::ResultTraits<AltRetT>::ErrorReturnType;
     auto Result = detail::ResultTraits<AltRetT>::createBlankErrorReturnValue();
@@ -1523,6 +1513,12 @@
       return std::move(Err);
     }
 
+    if (auto Err = this->C.send()) {
+      detail::ResultTraits<typename Func::ReturnType>::consumeAbandoned(
+          std::move(Result));
+      return std::move(Err);
+    }
+
     while (!ReceivedResponse) {
       if (auto Err = this->handleOne()) {
         detail::ResultTraits<typename Func::ReturnType>::consumeAbandoned(
@@ -1536,13 +1532,12 @@
 };
 
 /// Asynchronous dispatch for a function on an RPC endpoint.
-template <typename RPCClass, typename Func>
-class RPCAsyncDispatch {
+template <typename RPCClass, typename Func> class RPCAsyncDispatch {
 public:
   RPCAsyncDispatch(RPCClass &Endpoint) : Endpoint(Endpoint) {}
 
   template <typename HandlerT, typename... ArgTs>
-  Error operator()(HandlerT Handler, const ArgTs &... Args) const {
+  Error operator()(HandlerT Handler, const ArgTs &...Args) const {
     return Endpoint.template appendCallAsync<Func>(std::move(Handler), Args...);
   }
 
@@ -1560,7 +1555,6 @@
 ///        waited on as a group.
 class ParallelCallGroup {
 public:
-
   ParallelCallGroup() = default;
   ParallelCallGroup(const ParallelCallGroup &) = delete;
   ParallelCallGroup &operator=(const ParallelCallGroup &) = delete;
@@ -1568,7 +1562,7 @@
   /// Make as asynchronous call.
   template <typename AsyncDispatcher, typename HandlerT, typename... ArgTs>
   Error call(const AsyncDispatcher &AsyncDispatch, HandlerT Handler,
-             const ArgTs &... Args) {
+             const ArgTs &...Args) {
     // Increment the count of outstanding calls. This has to happen before
     // we invoke the call, as the handler may (depending on scheduling)
     // be run immediately on another thread, and we don't want the decrement
@@ -1582,8 +1576,7 @@
     // outstanding calls count, then poke the condition variable.
     using ArgType = typename detail::ResponseHandlerArg<
         typename detail::HandlerTraits<HandlerT>::Type>::ArgType;
-    // FIXME: Move handler into wrapped handler once we have C++14.
-    auto WrappedHandler = [this, Handler](ArgType Arg) {
+    auto WrappedHandler = [this, Handler = std::move(Handler)](ArgType Arg) {
       auto Err = Handler(std::move(Arg));
       std::unique_lock<std::mutex> Lock(M);
       --NumOutstandingCalls;
@@ -1608,70 +1601,57 @@
   uint32_t NumOutstandingCalls = 0;
 };
 
-/// Convenience class for grouping RPC Functions into APIs that can be
+/// Convenience class for grouping RPCFunctions into APIs that can be
 ///        negotiated as a block.
 ///
-template <typename... Funcs>
-class APICalls {
+template <typename... Funcs> class APICalls {
 public:
-
   /// Test whether this API contains Function F.
-  template <typename F>
-  class Contains {
+  template <typename F> class Contains {
   public:
     static const bool value = false;
   };
 
   /// Negotiate all functions in this API.
-  template <typename RPCEndpoint>
-  static Error negotiate(RPCEndpoint &R) {
+  template <typename RPCEndpoint> static Error negotiate(RPCEndpoint &R) {
     return Error::success();
   }
 };
 
-template <typename Func, typename... Funcs>
-class APICalls<Func, Funcs...> {
+template <typename Func, typename... Funcs> class APICalls<Func, Funcs...> {
 public:
-
-  template <typename F>
-  class Contains {
+  template <typename F> class Contains {
   public:
     static const bool value = std::is_same<F, Func>::value |
                               APICalls<Funcs...>::template Contains<F>::value;
   };
 
-  template <typename RPCEndpoint>
-  static Error negotiate(RPCEndpoint &R) {
+  template <typename RPCEndpoint> static Error negotiate(RPCEndpoint &R) {
     if (auto Err = R.template negotiateFunction<Func>())
       return Err;
     return APICalls<Funcs...>::negotiate(R);
   }
-
 };
 
 template <typename... InnerFuncs, typename... Funcs>
 class APICalls<APICalls<InnerFuncs...>, Funcs...> {
 public:
-
-  template <typename F>
-  class Contains {
+  template <typename F> class Contains {
   public:
     static const bool value =
-      APICalls<InnerFuncs...>::template Contains<F>::value |
-      APICalls<Funcs...>::template Contains<F>::value;
+        APICalls<InnerFuncs...>::template Contains<F>::value |
+        APICalls<Funcs...>::template Contains<F>::value;
   };
 
-  template <typename RPCEndpoint>
-  static Error negotiate(RPCEndpoint &R) {
+  template <typename RPCEndpoint> static Error negotiate(RPCEndpoint &R) {
     if (auto Err = APICalls<InnerFuncs...>::negotiate(R))
       return Err;
     return APICalls<Funcs...>::negotiate(R);
   }
-
 };
 
-} // end namespace rpc
+} // end namespace shared
 } // end namespace orc
 } // end namespace llvm
 
-#endif
+#endif // LLVM_EXECUTIONENGINE_ORC_SHARED_RPCUTILS_H
diff --git a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/RawByteChannel.h b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/Shared/RawByteChannel.h
similarity index 74%
rename from linux-x64/clang/include/llvm/ExecutionEngine/Orc/RawByteChannel.h
rename to linux-x64/clang/include/llvm/ExecutionEngine/Orc/Shared/RawByteChannel.h
index 46b7c59..2ee4719 100644
--- a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/RawByteChannel.h
+++ b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/Shared/RawByteChannel.h
@@ -1,4 +1,4 @@
-//===- llvm/ExecutionEngine/Orc/RawByteChannel.h ----------------*- C++ -*-===//
+//===- RawByteChannel.h -----------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -6,11 +6,11 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_EXECUTIONENGINE_ORC_RAWBYTECHANNEL_H
-#define LLVM_EXECUTIONENGINE_ORC_RAWBYTECHANNEL_H
+#ifndef LLVM_EXECUTIONENGINE_ORC_SHARED_RAWBYTECHANNEL_H
+#define LLVM_EXECUTIONENGINE_ORC_SHARED_RAWBYTECHANNEL_H
 
 #include "llvm/ADT/StringRef.h"
-#include "llvm/ExecutionEngine/Orc/RPCSerialization.h"
+#include "llvm/ExecutionEngine/Orc/Shared/Serialization.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/Error.h"
 #include <cstdint>
@@ -20,9 +20,9 @@
 
 namespace llvm {
 namespace orc {
-namespace rpc {
+namespace shared {
 
-/// Interface for byte-streams to be used with RPC.
+/// Interface for byte-streams to be used with ORC Serialization.
 class RawByteChannel {
 public:
   virtual ~RawByteChannel() = default;
@@ -87,13 +87,13 @@
 template <typename ChannelT, typename T>
 class SerializationTraits<
     ChannelT, T, T,
-    typename std::enable_if<
+    std::enable_if_t<
         std::is_base_of<RawByteChannel, ChannelT>::value &&
         (std::is_same<T, uint8_t>::value || std::is_same<T, int8_t>::value ||
          std::is_same<T, uint16_t>::value || std::is_same<T, int16_t>::value ||
          std::is_same<T, uint32_t>::value || std::is_same<T, int32_t>::value ||
          std::is_same<T, uint64_t>::value || std::is_same<T, int64_t>::value ||
-         std::is_same<T, char>::value)>::type> {
+         std::is_same<T, char>::value)>> {
 public:
   static Error serialize(ChannelT &C, T V) {
     support::endian::byte_swap<T, support::big>(V);
@@ -109,14 +109,13 @@
 };
 
 template <typename ChannelT>
-class SerializationTraits<ChannelT, bool, bool,
-                          typename std::enable_if<std::is_base_of<
-                              RawByteChannel, ChannelT>::value>::type> {
+class SerializationTraits<
+    ChannelT, bool, bool,
+    std::enable_if_t<std::is_base_of<RawByteChannel, ChannelT>::value>> {
 public:
   static Error serialize(ChannelT &C, bool V) {
     uint8_t Tmp = V ? 1 : 0;
-    if (auto Err =
-          C.appendBytes(reinterpret_cast<const char *>(&Tmp), 1))
+    if (auto Err = C.appendBytes(reinterpret_cast<const char *>(&Tmp), 1))
       return Err;
     return Error::success();
   }
@@ -131,11 +130,11 @@
 };
 
 template <typename ChannelT>
-class SerializationTraits<ChannelT, std::string, StringRef,
-                          typename std::enable_if<std::is_base_of<
-                              RawByteChannel, ChannelT>::value>::type> {
+class SerializationTraits<
+    ChannelT, std::string, StringRef,
+    std::enable_if_t<std::is_base_of<RawByteChannel, ChannelT>::value>> {
 public:
-  /// RPC channel serialization for std::strings.
+  /// Serialization channel serialization for std::strings.
   static Error serialize(RawByteChannel &C, StringRef S) {
     if (auto Err = serializeSeq(C, static_cast<uint64_t>(S.size())))
       return Err;
@@ -144,11 +143,11 @@
 };
 
 template <typename ChannelT, typename T>
-class SerializationTraits<ChannelT, std::string, T,
-                          typename std::enable_if<
-                            std::is_base_of<RawByteChannel, ChannelT>::value &&
-                            (std::is_same<T, const char*>::value ||
-                             std::is_same<T, char*>::value)>::type> {
+class SerializationTraits<
+    ChannelT, std::string, T,
+    std::enable_if_t<std::is_base_of<RawByteChannel, ChannelT>::value &&
+                     (std::is_same<T, const char *>::value ||
+                      std::is_same<T, char *>::value)>> {
 public:
   static Error serialize(RawByteChannel &C, const char *S) {
     return SerializationTraits<ChannelT, std::string, StringRef>::serialize(C,
@@ -157,17 +156,17 @@
 };
 
 template <typename ChannelT>
-class SerializationTraits<ChannelT, std::string, std::string,
-                          typename std::enable_if<std::is_base_of<
-                              RawByteChannel, ChannelT>::value>::type> {
+class SerializationTraits<
+    ChannelT, std::string, std::string,
+    std::enable_if_t<std::is_base_of<RawByteChannel, ChannelT>::value>> {
 public:
-  /// RPC channel serialization for std::strings.
+  /// Serialization channel serialization for std::strings.
   static Error serialize(RawByteChannel &C, const std::string &S) {
     return SerializationTraits<ChannelT, std::string, StringRef>::serialize(C,
                                                                             S);
   }
 
-  /// RPC channel deserialization for std::strings.
+  /// Serialization channel deserialization for std::strings.
   static Error deserialize(RawByteChannel &C, std::string &S) {
     uint64_t Count = 0;
     if (auto Err = deserializeSeq(C, Count))
@@ -177,8 +176,8 @@
   }
 };
 
-} // end namespace rpc
+} // end namespace shared
 } // end namespace orc
 } // end namespace llvm
 
-#endif // LLVM_EXECUTIONENGINE_ORC_RAWBYTECHANNEL_H
+#endif // LLVM_EXECUTIONENGINE_ORC_SHARED_RAWBYTECHANNEL_H
diff --git a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/RPCSerialization.h b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/Shared/Serialization.h
similarity index 61%
rename from linux-x64/clang/include/llvm/ExecutionEngine/Orc/RPCSerialization.h
rename to linux-x64/clang/include/llvm/ExecutionEngine/Orc/Shared/Serialization.h
index 07c7471..64a4ab8 100644
--- a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/RPCSerialization.h
+++ b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/Shared/Serialization.h
@@ -1,4 +1,4 @@
-//===- llvm/ExecutionEngine/Orc/RPCSerialization.h --------------*- C++ -*-===//
+//===- Serialization.h ------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -6,10 +6,12 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_EXECUTIONENGINE_ORC_RPCSERIALIZATION_H
-#define LLVM_EXECUTIONENGINE_ORC_RPCSERIALIZATION_H
+#ifndef LLVM_EXECUTIONENGINE_ORC_SHARED_SERIALIZATION_H
+#define LLVM_EXECUTIONENGINE_ORC_SHARED_SERIALIZATION_H
 
-#include "OrcError.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ExecutionEngine/Orc/OrcError.h"
 #include "llvm/Support/thread.h"
 #include <map>
 #include <mutex>
@@ -20,118 +22,104 @@
 
 namespace llvm {
 namespace orc {
-namespace rpc {
+namespace shared {
 
-template <typename T>
-class RPCTypeName;
+template <typename T> class SerializationTypeName;
 
 /// TypeNameSequence is a utility for rendering sequences of types to a string
 /// by rendering each type, separated by ", ".
-template <typename... ArgTs> class RPCTypeNameSequence {};
+template <typename... ArgTs> class SerializationTypeNameSequence {};
 
 /// Render an empty TypeNameSequence to an ostream.
 template <typename OStream>
-OStream &operator<<(OStream &OS, const RPCTypeNameSequence<> &V) {
+OStream &operator<<(OStream &OS, const SerializationTypeNameSequence<> &V) {
   return OS;
 }
 
 /// Render a TypeNameSequence of a single type to an ostream.
 template <typename OStream, typename ArgT>
-OStream &operator<<(OStream &OS, const RPCTypeNameSequence<ArgT> &V) {
-  OS << RPCTypeName<ArgT>::getName();
+OStream &operator<<(OStream &OS, const SerializationTypeNameSequence<ArgT> &V) {
+  OS << SerializationTypeName<ArgT>::getName();
   return OS;
 }
 
 /// Render a TypeNameSequence of more than one type to an ostream.
 template <typename OStream, typename ArgT1, typename ArgT2, typename... ArgTs>
-OStream&
-operator<<(OStream &OS, const RPCTypeNameSequence<ArgT1, ArgT2, ArgTs...> &V) {
-  OS << RPCTypeName<ArgT1>::getName() << ", "
-     << RPCTypeNameSequence<ArgT2, ArgTs...>();
+OStream &
+operator<<(OStream &OS,
+           const SerializationTypeNameSequence<ArgT1, ArgT2, ArgTs...> &V) {
+  OS << SerializationTypeName<ArgT1>::getName() << ", "
+     << SerializationTypeNameSequence<ArgT2, ArgTs...>();
   return OS;
 }
 
-template <>
-class RPCTypeName<void> {
+template <> class SerializationTypeName<void> {
 public:
-  static const char* getName() { return "void"; }
+  static const char *getName() { return "void"; }
 };
 
-template <>
-class RPCTypeName<int8_t> {
+template <> class SerializationTypeName<int8_t> {
 public:
-  static const char* getName() { return "int8_t"; }
+  static const char *getName() { return "int8_t"; }
 };
 
-template <>
-class RPCTypeName<uint8_t> {
+template <> class SerializationTypeName<uint8_t> {
 public:
-  static const char* getName() { return "uint8_t"; }
+  static const char *getName() { return "uint8_t"; }
 };
 
-template <>
-class RPCTypeName<int16_t> {
+template <> class SerializationTypeName<int16_t> {
 public:
-  static const char* getName() { return "int16_t"; }
+  static const char *getName() { return "int16_t"; }
 };
 
-template <>
-class RPCTypeName<uint16_t> {
+template <> class SerializationTypeName<uint16_t> {
 public:
-  static const char* getName() { return "uint16_t"; }
+  static const char *getName() { return "uint16_t"; }
 };
 
-template <>
-class RPCTypeName<int32_t> {
+template <> class SerializationTypeName<int32_t> {
 public:
-  static const char* getName() { return "int32_t"; }
+  static const char *getName() { return "int32_t"; }
 };
 
-template <>
-class RPCTypeName<uint32_t> {
+template <> class SerializationTypeName<uint32_t> {
 public:
-  static const char* getName() { return "uint32_t"; }
+  static const char *getName() { return "uint32_t"; }
 };
 
-template <>
-class RPCTypeName<int64_t> {
+template <> class SerializationTypeName<int64_t> {
 public:
-  static const char* getName() { return "int64_t"; }
+  static const char *getName() { return "int64_t"; }
 };
 
-template <>
-class RPCTypeName<uint64_t> {
+template <> class SerializationTypeName<uint64_t> {
 public:
-  static const char* getName() { return "uint64_t"; }
+  static const char *getName() { return "uint64_t"; }
 };
 
-template <>
-class RPCTypeName<bool> {
+template <> class SerializationTypeName<bool> {
 public:
-  static const char* getName() { return "bool"; }
+  static const char *getName() { return "bool"; }
 };
 
-template <>
-class RPCTypeName<std::string> {
+template <> class SerializationTypeName<std::string> {
 public:
-  static const char* getName() { return "std::string"; }
+  static const char *getName() { return "std::string"; }
 };
 
-template <>
-class RPCTypeName<Error> {
+template <> class SerializationTypeName<Error> {
 public:
-  static const char* getName() { return "Error"; }
+  static const char *getName() { return "Error"; }
 };
 
-template <typename T>
-class RPCTypeName<Expected<T>> {
+template <typename T> class SerializationTypeName<Expected<T>> {
 public:
-  static const char* getName() {
+  static const char *getName() {
     static std::string Name = [] {
       std::string Name;
-      raw_string_ostream(Name) << "Expected<"
-                               << RPCTypeNameSequence<T>()
-                               << ">";
+      raw_string_ostream(Name)
+          << "Expected<" << SerializationTypeNameSequence<T>() << ">";
       return Name;
     }();
     return Name.data();
@@ -139,67 +127,78 @@
 };
 
 template <typename T1, typename T2>
-class RPCTypeName<std::pair<T1, T2>> {
-public:
-  static const char* getName() {
-    static std::string Name = [] {
-      std::string Name;
-      raw_string_ostream(Name) << "std::pair<" << RPCTypeNameSequence<T1, T2>()
-                               << ">";
-      return Name;
-    }();
-    return Name.data();
-  }
-};
-
-template <typename... ArgTs>
-class RPCTypeName<std::tuple<ArgTs...>> {
-public:
-  static const char* getName() {
-    static std::string Name = [] {
-      std::string Name;
-      raw_string_ostream(Name) << "std::tuple<"
-                               << RPCTypeNameSequence<ArgTs...>() << ">";
-      return Name;
-    }();
-    return Name.data();
-  }
-};
-
-template <typename T>
-class RPCTypeName<std::vector<T>> {
-public:
-  static const char*getName() {
-    static std::string Name = [] {
-      std::string Name;
-      raw_string_ostream(Name) << "std::vector<" << RPCTypeName<T>::getName()
-                               << ">";
-      return Name;
-    }();
-    return Name.data();
-  }
-};
-
-template <typename T> class RPCTypeName<std::set<T>> {
+class SerializationTypeName<std::pair<T1, T2>> {
 public:
   static const char *getName() {
     static std::string Name = [] {
       std::string Name;
       raw_string_ostream(Name)
-          << "std::set<" << RPCTypeName<T>::getName() << ">";
+          << "std::pair<" << SerializationTypeNameSequence<T1, T2>() << ">";
       return Name;
     }();
     return Name.data();
   }
 };
 
-template <typename K, typename V> class RPCTypeName<std::map<K, V>> {
+template <typename... ArgTs> class SerializationTypeName<std::tuple<ArgTs...>> {
 public:
   static const char *getName() {
     static std::string Name = [] {
       std::string Name;
       raw_string_ostream(Name)
-          << "std::map<" << RPCTypeNameSequence<K, V>() << ">";
+          << "std::tuple<" << SerializationTypeNameSequence<ArgTs...>() << ">";
+      return Name;
+    }();
+    return Name.data();
+  }
+};
+
+template <typename T> class SerializationTypeName<Optional<T>> {
+public:
+  static const char *getName() {
+    static std::string Name = [] {
+      std::string Name;
+      raw_string_ostream(Name)
+          << "Optional<" << SerializationTypeName<T>::getName() << ">";
+      return Name;
+    }();
+    return Name.data();
+  }
+};
+
+template <typename T> class SerializationTypeName<std::vector<T>> {
+public:
+  static const char *getName() {
+    static std::string Name = [] {
+      std::string Name;
+      raw_string_ostream(Name)
+          << "std::vector<" << SerializationTypeName<T>::getName() << ">";
+      return Name;
+    }();
+    return Name.data();
+  }
+};
+
+template <typename T> class SerializationTypeName<std::set<T>> {
+public:
+  static const char *getName() {
+    static std::string Name = [] {
+      std::string Name;
+      raw_string_ostream(Name)
+          << "std::set<" << SerializationTypeName<T>::getName() << ">";
+      return Name;
+    }();
+    return Name.data();
+  }
+};
+
+template <typename K, typename V> class SerializationTypeName<std::map<K, V>> {
+public:
+  static const char *getName() {
+    static std::string Name = [] {
+      std::string Name;
+      raw_string_ostream(Name)
+          << "std::map<" << SerializationTypeNameSequence<K, V>() << ">";
       return Name;
     }();
     return Name.data();
@@ -230,9 +229,9 @@
 ///
 ///   template <DerivedChannelT>
 ///   class SerializationTraits<DerivedChannelT, bool,
-///         typename std::enable_if<
+///         std::enable_if_t<
 ///           std::is_base_of<VirtChannel, DerivedChannel>::value
-///         >::type> {
+///         >> {
 ///   public:
 ///     static const char* getName() { ... };
 ///   }
@@ -242,8 +241,7 @@
           typename ConcreteType = WireType, typename = void>
 class SerializationTraits;
 
-template <typename ChannelT>
-class SequenceTraits {
+template <typename ChannelT> class SequenceTraits {
 public:
   static Error emitSeparator(ChannelT &C) { return Error::success(); }
   static Error consumeSeparator(ChannelT &C) { return Error::success(); }
@@ -258,11 +256,9 @@
 /// is a SerializationTraits specialization
 /// SerializeTraits<ChannelT, ArgT, CArgT> with methods that can serialize the
 /// caller argument to over-the-wire value.
-template <typename ChannelT, typename... ArgTs>
-class SequenceSerialization;
+template <typename ChannelT, typename... ArgTs> class SequenceSerialization;
 
-template <typename ChannelT>
-class SequenceSerialization<ChannelT> {
+template <typename ChannelT> class SequenceSerialization<ChannelT> {
 public:
   static Error serialize(ChannelT &C) { return Error::success(); }
   static Error deserialize(ChannelT &C) { return Error::success(); }
@@ -271,16 +267,12 @@
 template <typename ChannelT, typename ArgT>
 class SequenceSerialization<ChannelT, ArgT> {
 public:
-
-  template <typename CArgT>
-  static Error serialize(ChannelT &C, CArgT &&CArg) {
-    return SerializationTraits<ChannelT, ArgT,
-                               typename std::decay<CArgT>::type>::
-             serialize(C, std::forward<CArgT>(CArg));
+  template <typename CArgT> static Error serialize(ChannelT &C, CArgT &&CArg) {
+    return SerializationTraits<ChannelT, ArgT, std::decay_t<CArgT>>::serialize(
+        C, std::forward<CArgT>(CArg));
   }
 
-  template <typename CArgT>
-  static Error deserialize(ChannelT &C, CArgT &CArg) {
+  template <typename CArgT> static Error deserialize(ChannelT &C, CArgT &CArg) {
     return SerializationTraits<ChannelT, ArgT, CArgT>::deserialize(C, CArg);
   }
 };
@@ -288,25 +280,22 @@
 template <typename ChannelT, typename ArgT, typename... ArgTs>
 class SequenceSerialization<ChannelT, ArgT, ArgTs...> {
 public:
-
   template <typename CArgT, typename... CArgTs>
-  static Error serialize(ChannelT &C, CArgT &&CArg,
-                         CArgTs &&... CArgs) {
+  static Error serialize(ChannelT &C, CArgT &&CArg, CArgTs &&...CArgs) {
     if (auto Err =
-        SerializationTraits<ChannelT, ArgT, typename std::decay<CArgT>::type>::
-          serialize(C, std::forward<CArgT>(CArg)))
+            SerializationTraits<ChannelT, ArgT, std::decay_t<CArgT>>::serialize(
+                C, std::forward<CArgT>(CArg)))
       return Err;
     if (auto Err = SequenceTraits<ChannelT>::emitSeparator(C))
       return Err;
-    return SequenceSerialization<ChannelT, ArgTs...>::
-             serialize(C, std::forward<CArgTs>(CArgs)...);
+    return SequenceSerialization<ChannelT, ArgTs...>::serialize(
+        C, std::forward<CArgTs>(CArgs)...);
   }
 
   template <typename CArgT, typename... CArgTs>
-  static Error deserialize(ChannelT &C, CArgT &CArg,
-                           CArgTs &... CArgs) {
+  static Error deserialize(ChannelT &C, CArgT &CArg, CArgTs &...CArgs) {
     if (auto Err =
-        SerializationTraits<ChannelT, ArgT, CArgT>::deserialize(C, CArg))
+            SerializationTraits<ChannelT, ArgT, CArgT>::deserialize(C, CArg))
       return Err;
     if (auto Err = SequenceTraits<ChannelT>::consumeSeparator(C))
       return Err;
@@ -315,25 +304,23 @@
 };
 
 template <typename ChannelT, typename... ArgTs>
-Error serializeSeq(ChannelT &C, ArgTs &&... Args) {
-  return SequenceSerialization<ChannelT, typename std::decay<ArgTs>::type...>::
-           serialize(C, std::forward<ArgTs>(Args)...);
+Error serializeSeq(ChannelT &C, ArgTs &&...Args) {
+  return SequenceSerialization<ChannelT, std::decay_t<ArgTs>...>::serialize(
+      C, std::forward<ArgTs>(Args)...);
 }
 
 template <typename ChannelT, typename... ArgTs>
-Error deserializeSeq(ChannelT &C, ArgTs &... Args) {
+Error deserializeSeq(ChannelT &C, ArgTs &...Args) {
   return SequenceSerialization<ChannelT, ArgTs...>::deserialize(C, Args...);
 }
 
-template <typename ChannelT>
-class SerializationTraits<ChannelT, Error> {
+template <typename ChannelT> class SerializationTraits<ChannelT, Error> {
 public:
-
   using WrappedErrorSerializer =
-    std::function<Error(ChannelT &C, const ErrorInfoBase&)>;
+      std::function<Error(ChannelT &C, const ErrorInfoBase &)>;
 
   using WrappedErrorDeserializer =
-    std::function<Error(ChannelT &C, Error &Err)>;
+      std::function<Error(ChannelT &C, Error &Err)>;
 
   template <typename ErrorInfoT, typename SerializeFtor,
             typename DeserializeFtor>
@@ -344,24 +331,23 @@
 
     const std::string *KeyName = nullptr;
     {
-      // We're abusing the stability of std::map here: We take a reference to the
-      // key of the deserializers map to save us from duplicating the string in
-      // the serializer. This should be changed to use a stringpool if we switch
-      // to a map type that may move keys in memory.
+      // We're abusing the stability of std::map here: We take a reference to
+      // the key of the deserializers map to save us from duplicating the string
+      // in the serializer. This should be changed to use a stringpool if we
+      // switch to a map type that may move keys in memory.
       std::lock_guard<std::recursive_mutex> Lock(DeserializersMutex);
-      auto I =
-        Deserializers.insert(Deserializers.begin(),
-                             std::make_pair(std::move(Name),
-                                            std::move(Deserialize)));
+      auto I = Deserializers.insert(
+          Deserializers.begin(),
+          std::make_pair(std::move(Name), std::move(Deserialize)));
       KeyName = &I->first;
     }
 
     {
       assert(KeyName != nullptr && "No keyname pointer");
       std::lock_guard<std::recursive_mutex> Lock(SerializersMutex);
-      // FIXME: Move capture Serialize once we have C++14.
       Serializers[ErrorInfoT::classID()] =
-          [KeyName, Serialize](ChannelT &C, const ErrorInfoBase &EIB) -> Error {
+          [KeyName, Serialize = std::move(Serialize)](
+              ChannelT &C, const ErrorInfoBase &EIB) -> Error {
         assert(EIB.dynamicClassID() == ErrorInfoT::classID() &&
                "Serializer called for wrong error type");
         if (auto Err = serializeSeq(C, *KeyName))
@@ -377,13 +363,12 @@
     if (!Err)
       return serializeSeq(C, std::string());
 
-    return handleErrors(std::move(Err),
-                        [&C](const ErrorInfoBase &EIB) {
-                          auto SI = Serializers.find(EIB.dynamicClassID());
-                          if (SI == Serializers.end())
-                            return serializeAsStringError(C, EIB);
-                          return (SI->second)(C, EIB);
-                        });
+    return handleErrors(std::move(Err), [&C](const ErrorInfoBase &EIB) {
+      auto SI = Serializers.find(EIB.dynamicClassID());
+      if (SI == Serializers.end())
+        return serializeAsStringError(C, EIB);
+      return (SI->second)(C, EIB);
+    });
   }
 
   static Error deserialize(ChannelT &C, Error &Err) {
@@ -405,7 +390,6 @@
   }
 
 private:
-
   static Error serializeAsStringError(ChannelT &C, const ErrorInfoBase &EIB) {
     std::string ErrMsg;
     {
@@ -418,7 +402,7 @@
 
   static std::recursive_mutex SerializersMutex;
   static std::recursive_mutex DeserializersMutex;
-  static std::map<const void*, WrappedErrorSerializer> Serializers;
+  static std::map<const void *, WrappedErrorSerializer> Serializers;
   static std::map<std::string, WrappedErrorDeserializer> Deserializers;
 };
 
@@ -429,14 +413,14 @@
 std::recursive_mutex SerializationTraits<ChannelT, Error>::DeserializersMutex;
 
 template <typename ChannelT>
-std::map<const void*,
+std::map<const void *,
          typename SerializationTraits<ChannelT, Error>::WrappedErrorSerializer>
-SerializationTraits<ChannelT, Error>::Serializers;
+    SerializationTraits<ChannelT, Error>::Serializers;
 
 template <typename ChannelT>
-std::map<std::string,
-         typename SerializationTraits<ChannelT, Error>::WrappedErrorDeserializer>
-SerializationTraits<ChannelT, Error>::Deserializers;
+std::map<std::string, typename SerializationTraits<
+                          ChannelT, Error>::WrappedErrorDeserializer>
+    SerializationTraits<ChannelT, Error>::Deserializers;
 
 /// Registers a serializer and deserializer for the given error type on the
 /// given channel type.
@@ -445,32 +429,29 @@
 void registerErrorSerialization(std::string Name, SerializeFtor &&Serialize,
                                 DeserializeFtor &&Deserialize) {
   SerializationTraits<ChannelT, Error>::template registerErrorType<ErrorInfoT>(
-    std::move(Name),
-    std::forward<SerializeFtor>(Serialize),
-    std::forward<DeserializeFtor>(Deserialize));
+      std::move(Name), std::forward<SerializeFtor>(Serialize),
+      std::forward<DeserializeFtor>(Deserialize));
 }
 
 /// Registers serialization/deserialization for StringError.
-template <typename ChannelT>
-void registerStringError() {
+template <typename ChannelT> void registerStringError() {
   static bool AlreadyRegistered = false;
   if (!AlreadyRegistered) {
     registerErrorSerialization<ChannelT, StringError>(
-      "StringError",
-      [](ChannelT &C, const StringError &SE) {
-        return serializeSeq(C, SE.getMessage());
-      },
-      [](ChannelT &C, Error &Err) -> Error {
-        ErrorAsOutParameter EAO(&Err);
-        std::string Msg;
-        if (auto E2 = deserializeSeq(C, Msg))
-          return E2;
-        Err =
-          make_error<StringError>(std::move(Msg),
-                                  orcError(
-                                    OrcErrorCode::UnknownErrorCodeFromRemote));
-        return Error::success();
-      });
+        "StringError",
+        [](ChannelT &C, const StringError &SE) {
+          return serializeSeq(C, SE.getMessage());
+        },
+        [](ChannelT &C, Error &Err) -> Error {
+          ErrorAsOutParameter EAO(&Err);
+          std::string Msg;
+          if (auto E2 = deserializeSeq(C, Msg))
+            return E2;
+          Err = make_error<StringError>(
+              std::move(Msg),
+              orcError(OrcErrorCode::UnknownErrorCodeFromRemote));
+          return Error::success();
+        });
     AlreadyRegistered = true;
   }
 }
@@ -479,7 +460,6 @@
 template <typename ChannelT, typename T1, typename T2>
 class SerializationTraits<ChannelT, Expected<T1>, Expected<T2>> {
 public:
-
   static Error serialize(ChannelT &C, Expected<T2> &&ValOrErr) {
     if (ValOrErr) {
       if (auto Err = serializeSeq(C, true))
@@ -510,7 +490,6 @@
 template <typename ChannelT, typename T1, typename T2>
 class SerializationTraits<ChannelT, Expected<T1>, T2> {
 public:
-
   static Error serialize(ChannelT &C, T2 &&Val) {
     return serializeSeq(C, Expected<T2>(std::forward<T2>(Val)));
   }
@@ -520,7 +499,6 @@
 template <typename ChannelT, typename T>
 class SerializationTraits<ChannelT, Expected<T>, Error> {
 public:
-
   static Error serialize(ChannelT &C, Error &&Err) {
     return serializeSeq(C, Expected<T>(std::move(Err)));
   }
@@ -548,38 +526,61 @@
 template <typename ChannelT, typename... ArgTs>
 class SerializationTraits<ChannelT, std::tuple<ArgTs...>> {
 public:
-
   /// RPC channel serialization for std::tuple.
   static Error serialize(ChannelT &C, const std::tuple<ArgTs...> &V) {
-    return serializeTupleHelper(C, V, llvm::index_sequence_for<ArgTs...>());
+    return serializeTupleHelper(C, V, std::index_sequence_for<ArgTs...>());
   }
 
   /// RPC channel deserialization for std::tuple.
   static Error deserialize(ChannelT &C, std::tuple<ArgTs...> &V) {
-    return deserializeTupleHelper(C, V, llvm::index_sequence_for<ArgTs...>());
+    return deserializeTupleHelper(C, V, std::index_sequence_for<ArgTs...>());
   }
 
 private:
   // Serialization helper for std::tuple.
   template <size_t... Is>
   static Error serializeTupleHelper(ChannelT &C, const std::tuple<ArgTs...> &V,
-                                    llvm::index_sequence<Is...> _) {
+                                    std::index_sequence<Is...> _) {
     return serializeSeq(C, std::get<Is>(V)...);
   }
 
   // Serialization helper for std::tuple.
   template <size_t... Is>
   static Error deserializeTupleHelper(ChannelT &C, std::tuple<ArgTs...> &V,
-                                      llvm::index_sequence<Is...> _) {
+                                      std::index_sequence<Is...> _) {
     return deserializeSeq(C, std::get<Is>(V)...);
   }
 };
 
+template <typename ChannelT, typename T>
+class SerializationTraits<ChannelT, Optional<T>> {
+public:
+  /// Serialize an Optional<T>.
+  static Error serialize(ChannelT &C, const Optional<T> &O) {
+    if (auto Err = serializeSeq(C, O != None))
+      return Err;
+    if (O)
+      if (auto Err = serializeSeq(C, *O))
+        return Err;
+    return Error::success();
+  }
+
+  /// Deserialize an Optional<T>.
+  static Error deserialize(ChannelT &C, Optional<T> &O) {
+    bool HasValue = false;
+    if (auto Err = deserializeSeq(C, HasValue))
+      return Err;
+    if (HasValue)
+      if (auto Err = deserializeSeq(C, *O))
+        return Err;
+    return Error::success();
+  };
+};
+
 /// SerializationTraits default specialization for std::vector.
 template <typename ChannelT, typename T>
 class SerializationTraits<ChannelT, std::vector<T>> {
 public:
-
   /// Serialize a std::vector<T> from std::vector<T>.
   static Error serialize(ChannelT &C, const std::vector<T> &V) {
     if (auto Err = serializeSeq(C, static_cast<uint64_t>(V.size())))
@@ -610,6 +611,22 @@
   }
 };
 
+/// Enable vector serialization from an ArrayRef.
+template <typename ChannelT, typename T>
+class SerializationTraits<ChannelT, std::vector<T>, ArrayRef<T>> {
+public:
+  static Error serialize(ChannelT &C, ArrayRef<T> V) {
+    if (auto Err = serializeSeq(C, static_cast<uint64_t>(V.size())))
+      return Err;
+
+    for (const auto &E : V)
+      if (auto Err = serializeSeq(C, E))
+        return Err;
+
+    return Error::success();
+  }
+};
+
 template <typename ChannelT, typename T, typename T2>
 class SerializationTraits<ChannelT, std::set<T>, std::set<T2>> {
 public:
@@ -696,8 +713,57 @@
   }
 };
 
-} // end namespace rpc
+template <typename ChannelT, typename K, typename V, typename K2, typename V2>
+class SerializationTraits<ChannelT, std::map<K, V>, DenseMap<K2, V2>> {
+public:
+  /// Serialize a std::map<K, V> from DenseMap<K2, V2>.
+  static Error serialize(ChannelT &C, const DenseMap<K2, V2> &M) {
+    if (auto Err = serializeSeq(C, static_cast<uint64_t>(M.size())))
+      return Err;
+
+    for (auto &E : M) {
+      if (auto Err =
+              SerializationTraits<ChannelT, K, K2>::serialize(C, E.first))
+        return Err;
+
+      if (auto Err =
+              SerializationTraits<ChannelT, V, V2>::serialize(C, E.second))
+        return Err;
+    }
+
+    return Error::success();
+  }
+
+  /// Serialize a std::map<K, V> from DenseMap<K2, V2>.
+  static Error deserialize(ChannelT &C, DenseMap<K2, V2> &M) {
+    assert(M.empty() && "Expected default-constructed map to deserialize into");
+
+    uint64_t Count = 0;
+    if (auto Err = deserializeSeq(C, Count))
+      return Err;
+
+    while (Count-- != 0) {
+      std::pair<K2, V2> Val;
+      if (auto Err =
+              SerializationTraits<ChannelT, K, K2>::deserialize(C, Val.first))
+        return Err;
+
+      if (auto Err =
+              SerializationTraits<ChannelT, V, V2>::deserialize(C, Val.second))
+        return Err;
+
+      auto Added = M.insert(Val).second;
+      if (!Added)
+        return make_error<StringError>("Duplicate element in deserialized map",
+                                       orcError(OrcErrorCode::UnknownORCError));
+    }
+
+    return Error::success();
+  }
+};
+
+} // namespace shared
 } // end namespace orc
 } // end namespace llvm
 
-#endif // LLVM_EXECUTIONENGINE_ORC_RPCSERIALIZATION_H
+#endif // LLVM_EXECUTIONENGINE_ORC_RPC_RPCSERIALIZATION_H
diff --git a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/Shared/TargetProcessControlTypes.h b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/Shared/TargetProcessControlTypes.h
new file mode 100644
index 0000000..f43b929
--- /dev/null
+++ b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/Shared/TargetProcessControlTypes.h
@@ -0,0 +1,174 @@
+//===--- TargetProcessControlTypes.h -- Shared Core/TPC types ---*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// TargetProcessControl types that are used by both the Orc and
+// OrcTargetProcess libraries.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_EXECUTIONENGINE_ORC_SHARED_TARGETPROCESSCONTROLTYPES_H
+#define LLVM_EXECUTIONENGINE_ORC_SHARED_TARGETPROCESSCONTROLTYPES_H
+
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/ExecutionEngine/JITSymbol.h"
+#include "llvm/ExecutionEngine/Orc/Core.h"
+
+#include <vector>
+
+namespace llvm {
+namespace orc {
+namespace tpctypes {
+
+template <typename T> struct UIntWrite {
+  UIntWrite() = default;
+  UIntWrite(JITTargetAddress Address, T Value)
+      : Address(Address), Value(Value) {}
+
+  JITTargetAddress Address = 0;
+  T Value = 0;
+};
+
+/// Describes a write to a uint8_t.
+using UInt8Write = UIntWrite<uint8_t>;
+
+/// Describes a write to a uint16_t.
+using UInt16Write = UIntWrite<uint16_t>;
+
+/// Describes a write to a uint32_t.
+using UInt32Write = UIntWrite<uint32_t>;
+
+/// Describes a write to a uint64_t.
+using UInt64Write = UIntWrite<uint64_t>;
+
+/// Describes a write to a buffer.
+/// For use with TargetProcessControl::MemoryAccess objects.
+struct BufferWrite {
+  BufferWrite() = default;
+  BufferWrite(JITTargetAddress Address, StringRef Buffer)
+      : Address(Address), Buffer(Buffer) {}
+
+  JITTargetAddress Address = 0;
+  StringRef Buffer;
+};
+
+/// A handle used to represent a loaded dylib in the target process.
+using DylibHandle = JITTargetAddress;
+
+/// A pair of a dylib and a set of symbols to be looked up.
+struct LookupRequest {
+  LookupRequest(DylibHandle Handle, const SymbolLookupSet &Symbols)
+      : Handle(Handle), Symbols(Symbols) {}
+  DylibHandle Handle;
+  const SymbolLookupSet &Symbols;
+};
+
+using LookupResult = std::vector<JITTargetAddress>;
+
+/// Either a uint8_t array or a uint8_t*.
+union CWrapperFunctionResultData {
+  uint8_t Value[8];
+  uint8_t *ValuePtr;
+};
+
+/// C ABI compatible wrapper function result.
+///
+/// This can be safely returned from extern "C" functions, but should be used
+/// to construct a WrapperFunctionResult for safety.
+struct CWrapperFunctionResult {
+  uint64_t Size;
+  CWrapperFunctionResultData Data;
+  void (*Destroy)(CWrapperFunctionResultData Data, uint64_t Size);
+};
+
+/// C++ wrapper function result: Same as CWrapperFunctionResult but
+/// auto-releases memory.
+class WrapperFunctionResult {
+public:
+  /// Create a default WrapperFunctionResult.
+  WrapperFunctionResult() { zeroInit(R); }
+
+  /// Create a WrapperFunctionResult from a CWrapperFunctionResult. This
+  /// instance takes ownership of the result object and will automatically
+  /// call the Destroy member upon destruction.
+  WrapperFunctionResult(CWrapperFunctionResult R) : R(R) {}
+
+  WrapperFunctionResult(const WrapperFunctionResult &) = delete;
+  WrapperFunctionResult &operator=(const WrapperFunctionResult &) = delete;
+
+  WrapperFunctionResult(WrapperFunctionResult &&Other) {
+    zeroInit(R);
+    std::swap(R, Other.R);
+  }
+
+  WrapperFunctionResult &operator=(WrapperFunctionResult &&Other) {
+    CWrapperFunctionResult Tmp;
+    zeroInit(Tmp);
+    std::swap(Tmp, Other.R);
+    std::swap(R, Tmp);
+    return *this;
+  }
+
+  ~WrapperFunctionResult() {
+    if (R.Destroy)
+      R.Destroy(R.Data, R.Size);
+  }
+
+  /// Relinquish ownership of and return the CWrapperFunctionResult.
+  CWrapperFunctionResult release() {
+    CWrapperFunctionResult Tmp;
+    zeroInit(Tmp);
+    std::swap(R, Tmp);
+    return Tmp;
+  }
+
+  /// Get an ArrayRef covering the data in the result.
+  ArrayRef<uint8_t> getData() const {
+    if (R.Size <= 8)
+      return ArrayRef<uint8_t>(R.Data.Value, R.Size);
+    return ArrayRef<uint8_t>(R.Data.ValuePtr, R.Size);
+  }
+
+  /// Create a WrapperFunctionResult from the given integer, provided its
+  /// size is no greater than 64 bits.
+  template <typename T,
+            typename _ = std::enable_if_t<std::is_integral<T>::value &&
+                                          sizeof(T) <= sizeof(uint64_t)>>
+  static WrapperFunctionResult from(T Value) {
+    CWrapperFunctionResult R;
+    R.Size = sizeof(T);
+    memcpy(&R.Data.Value, Value, R.Size);
+    R.Destroy = nullptr;
+    return R;
+  }
+
+  /// Create a WrapperFunctionResult from the given string.
+  static WrapperFunctionResult from(StringRef S);
+
+  /// Always free Data.ValuePtr by calling free on it.
+  static void destroyWithFree(CWrapperFunctionResultData Data, uint64_t Size);
+
+  /// Always free Data.ValuePtr by calling delete[] on it.
+  static void destroyWithDeleteArray(CWrapperFunctionResultData Data,
+                                     uint64_t Size);
+
+private:
+  static void zeroInit(CWrapperFunctionResult &R) {
+    R.Size = 0;
+    R.Data.ValuePtr = nullptr;
+    R.Destroy = nullptr;
+  }
+
+  CWrapperFunctionResult R;
+};
+
+} // end namespace tpctypes
+} // end namespace orc
+} // end namespace llvm
+
+#endif // LLVM_EXECUTIONENGINE_ORC_SHARED_TARGETPROCESSCONTROLTYPES_H
diff --git a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/SpeculateAnalyses.h b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/SpeculateAnalyses.h
new file mode 100644
index 0000000..cf57b63
--- /dev/null
+++ b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/SpeculateAnalyses.h
@@ -0,0 +1,84 @@
+//===-- SpeculateAnalyses.h  --*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+// \file
+/// Contains the Analyses and Result Interpretation to select likely functions
+/// to Speculatively compile before they are called. [Purely Experimentation]
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_EXECUTIONENGINE_ORC_SPECULATEANALYSES_H
+#define LLVM_EXECUTIONENGINE_ORC_SPECULATEANALYSES_H
+
+#include "llvm/Analysis/BranchProbabilityInfo.h"
+#include "llvm/ExecutionEngine/Orc/Core.h"
+#include "llvm/ExecutionEngine/Orc/Speculation.h"
+
+#include <vector>
+
+namespace llvm {
+
+namespace orc {
+
+// Provides common code.
+class SpeculateQuery {
+protected:
+  void findCalles(const BasicBlock *, DenseSet<StringRef> &);
+  bool isStraightLine(const Function &F);
+
+public:
+  using ResultTy = Optional<DenseMap<StringRef, DenseSet<StringRef>>>;
+};
+
+// Direct calls in high frequency basic blocks are extracted.
+class BlockFreqQuery : public SpeculateQuery {
+  size_t numBBToGet(size_t);
+
+public:
+  // Find likely next executables based on IR Block Frequency
+  ResultTy operator()(Function &F);
+};
+
+// This Query generates a sequence of basic blocks which follows the order of
+// execution.
+// A handful of BB with higher block frequencies are taken, then path to entry
+// and end BB are discovered by traversing up & down the CFG.
+class SequenceBBQuery : public SpeculateQuery {
+  struct WalkDirection {
+    bool Upward = true, Downward = true;
+    // the block associated contain a call
+    bool CallerBlock = false;
+  };
+
+public:
+  using VisitedBlocksInfoTy = DenseMap<const BasicBlock *, WalkDirection>;
+  using BlockListTy = SmallVector<const BasicBlock *, 8>;
+  using BackEdgesInfoTy =
+      SmallVector<std::pair<const BasicBlock *, const BasicBlock *>, 8>;
+  using BlockFreqInfoTy =
+      SmallVector<std::pair<const BasicBlock *, uint64_t>, 8>;
+
+private:
+  std::size_t getHottestBlocks(std::size_t TotalBlocks);
+  BlockListTy rearrangeBB(const Function &, const BlockListTy &);
+  BlockListTy queryCFG(Function &, const BlockListTy &);
+  void traverseToEntryBlock(const BasicBlock *, const BlockListTy &,
+                            const BackEdgesInfoTy &,
+                            const BranchProbabilityInfo *,
+                            VisitedBlocksInfoTy &);
+  void traverseToExitBlock(const BasicBlock *, const BlockListTy &,
+                           const BackEdgesInfoTy &,
+                           const BranchProbabilityInfo *,
+                           VisitedBlocksInfoTy &);
+
+public:
+  ResultTy operator()(Function &F);
+};
+
+} // namespace orc
+} // namespace llvm
+
+#endif // LLVM_EXECUTIONENGINE_ORC_SPECULATEANALYSES_H
diff --git a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/Speculation.h b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/Speculation.h
new file mode 100644
index 0000000..a138f60
--- /dev/null
+++ b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/Speculation.h
@@ -0,0 +1,210 @@
+//===-- Speculation.h - Speculative Compilation --*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Contains the definition to support speculative compilation when laziness is
+// enabled.
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_EXECUTIONENGINE_ORC_SPECULATION_H
+#define LLVM_EXECUTIONENGINE_ORC_SPECULATION_H
+
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/Optional.h"
+#include "llvm/ExecutionEngine/Orc/Core.h"
+#include "llvm/ExecutionEngine/Orc/DebugUtils.h"
+#include "llvm/ExecutionEngine/Orc/IRCompileLayer.h"
+#include "llvm/Support/Debug.h"
+#include <mutex>
+#include <type_traits>
+#include <utility>
+
+namespace llvm {
+namespace orc {
+
+class Speculator;
+
+// Track the Impls (JITDylib,Symbols) of Symbols while lazy call through
+// trampolines are created. Operations are guarded by locks tp ensure that Imap
+// stays in consistent state after read/write
+
+class ImplSymbolMap {
+  friend class Speculator;
+
+public:
+  using AliaseeDetails = std::pair<SymbolStringPtr, JITDylib *>;
+  using Alias = SymbolStringPtr;
+  using ImapTy = DenseMap<Alias, AliaseeDetails>;
+  void trackImpls(SymbolAliasMap ImplMaps, JITDylib *SrcJD);
+
+private:
+  // FIX ME: find a right way to distinguish the pre-compile Symbols, and update
+  // the callsite
+  Optional<AliaseeDetails> getImplFor(const SymbolStringPtr &StubSymbol) {
+    std::lock_guard<std::mutex> Lockit(ConcurrentAccess);
+    auto Position = Maps.find(StubSymbol);
+    if (Position != Maps.end())
+      return Position->getSecond();
+    else
+      return None;
+  }
+
+  std::mutex ConcurrentAccess;
+  ImapTy Maps;
+};
+
+// Defines Speculator Concept,
+class Speculator {
+public:
+  using TargetFAddr = JITTargetAddress;
+  using FunctionCandidatesMap = DenseMap<SymbolStringPtr, SymbolNameSet>;
+  using StubAddrLikelies = DenseMap<TargetFAddr, SymbolNameSet>;
+
+private:
+  void registerSymbolsWithAddr(TargetFAddr ImplAddr,
+                               SymbolNameSet likelySymbols) {
+    std::lock_guard<std::mutex> Lockit(ConcurrentAccess);
+    GlobalSpecMap.insert({ImplAddr, std::move(likelySymbols)});
+  }
+
+  void launchCompile(JITTargetAddress FAddr) {
+    SymbolNameSet CandidateSet;
+    // Copy CandidateSet is necessary, to avoid unsynchronized access to
+    // the datastructure.
+    {
+      std::lock_guard<std::mutex> Lockit(ConcurrentAccess);
+      auto It = GlobalSpecMap.find(FAddr);
+      if (It == GlobalSpecMap.end())
+        return;
+      CandidateSet = It->getSecond();
+    }
+
+    SymbolDependenceMap SpeculativeLookUpImpls;
+
+    for (auto &Callee : CandidateSet) {
+      auto ImplSymbol = AliaseeImplTable.getImplFor(Callee);
+      // try to distinguish already compiled & library symbols
+      if (!ImplSymbol.hasValue())
+        continue;
+      const auto &ImplSymbolName = ImplSymbol.getPointer()->first;
+      JITDylib *ImplJD = ImplSymbol.getPointer()->second;
+      auto &SymbolsInJD = SpeculativeLookUpImpls[ImplJD];
+      SymbolsInJD.insert(ImplSymbolName);
+    }
+
+    DEBUG_WITH_TYPE("orc", {
+      for (auto &I : SpeculativeLookUpImpls) {
+        llvm::dbgs() << "\n In " << I.first->getName() << " JITDylib ";
+        for (auto &N : I.second)
+          llvm::dbgs() << "\n Likely Symbol : " << N;
+      }
+    });
+
+    // for a given symbol, there may be no symbol qualified for speculatively
+    // compile try to fix this before jumping to this code if possible.
+    for (auto &LookupPair : SpeculativeLookUpImpls)
+      ES.lookup(
+          LookupKind::Static,
+          makeJITDylibSearchOrder(LookupPair.first,
+                                  JITDylibLookupFlags::MatchAllSymbols),
+          SymbolLookupSet(LookupPair.second), SymbolState::Ready,
+          [this](Expected<SymbolMap> Result) {
+            if (auto Err = Result.takeError())
+              ES.reportError(std::move(Err));
+          },
+          NoDependenciesToRegister);
+  }
+
+public:
+  Speculator(ImplSymbolMap &Impl, ExecutionSession &ref)
+      : AliaseeImplTable(Impl), ES(ref), GlobalSpecMap(0) {}
+  Speculator(const Speculator &) = delete;
+  Speculator(Speculator &&) = delete;
+  Speculator &operator=(const Speculator &) = delete;
+  Speculator &operator=(Speculator &&) = delete;
+
+  /// Define symbols for this Speculator object (__orc_speculator) and the
+  /// speculation runtime entry point symbol (__orc_speculate_for) in the
+  /// given JITDylib.
+  Error addSpeculationRuntime(JITDylib &JD, MangleAndInterner &Mangle);
+
+  // Speculatively compile likely functions for the given Stub Address.
+  // destination of __orc_speculate_for jump
+  void speculateFor(TargetFAddr StubAddr) { launchCompile(StubAddr); }
+
+  // FIXME : Register with Stub Address, after JITLink Fix.
+  void registerSymbols(FunctionCandidatesMap Candidates, JITDylib *JD) {
+    for (auto &SymPair : Candidates) {
+      auto Target = SymPair.first;
+      auto Likely = SymPair.second;
+
+      auto OnReadyFixUp = [Likely, Target,
+                           this](Expected<SymbolMap> ReadySymbol) {
+        if (ReadySymbol) {
+          auto RAddr = (*ReadySymbol)[Target].getAddress();
+          registerSymbolsWithAddr(RAddr, std::move(Likely));
+        } else
+          this->getES().reportError(ReadySymbol.takeError());
+      };
+      // Include non-exported symbols also.
+      ES.lookup(
+          LookupKind::Static,
+          makeJITDylibSearchOrder(JD, JITDylibLookupFlags::MatchAllSymbols),
+          SymbolLookupSet(Target, SymbolLookupFlags::WeaklyReferencedSymbol),
+          SymbolState::Ready, OnReadyFixUp, NoDependenciesToRegister);
+    }
+  }
+
+  ExecutionSession &getES() { return ES; }
+
+private:
+  static void speculateForEntryPoint(Speculator *Ptr, uint64_t StubId);
+  std::mutex ConcurrentAccess;
+  ImplSymbolMap &AliaseeImplTable;
+  ExecutionSession &ES;
+  StubAddrLikelies GlobalSpecMap;
+};
+
+class IRSpeculationLayer : public IRLayer {
+public:
+  using IRlikiesStrRef = Optional<DenseMap<StringRef, DenseSet<StringRef>>>;
+  using ResultEval = std::function<IRlikiesStrRef(Function &)>;
+  using TargetAndLikelies = DenseMap<SymbolStringPtr, SymbolNameSet>;
+
+  IRSpeculationLayer(ExecutionSession &ES, IRCompileLayer &BaseLayer,
+                     Speculator &Spec, MangleAndInterner &Mangle,
+                     ResultEval Interpreter)
+      : IRLayer(ES, BaseLayer.getManglingOptions()), NextLayer(BaseLayer),
+        S(Spec), Mangle(Mangle), QueryAnalysis(Interpreter) {}
+
+  void emit(std::unique_ptr<MaterializationResponsibility> R,
+            ThreadSafeModule TSM) override;
+
+private:
+  TargetAndLikelies
+  internToJITSymbols(DenseMap<StringRef, DenseSet<StringRef>> IRNames) {
+    assert(!IRNames.empty() && "No IRNames received to Intern?");
+    TargetAndLikelies InternedNames;
+    for (auto &NamePair : IRNames) {
+      DenseSet<SymbolStringPtr> TargetJITNames;
+      for (auto &TargetNames : NamePair.second)
+        TargetJITNames.insert(Mangle(TargetNames));
+      InternedNames[Mangle(NamePair.first)] = std::move(TargetJITNames);
+    }
+    return InternedNames;
+  }
+
+  IRCompileLayer &NextLayer;
+  Speculator &S;
+  MangleAndInterner &Mangle;
+  ResultEval QueryAnalysis;
+};
+
+} // namespace orc
+} // namespace llvm
+
+#endif // LLVM_EXECUTIONENGINE_ORC_SPECULATION_H
diff --git a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/SymbolStringPool.h b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/SymbolStringPool.h
index c354f6c..c9fadd7 100644
--- a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/SymbolStringPool.h
+++ b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/SymbolStringPool.h
@@ -48,11 +48,13 @@
 
 /// Pointer to a pooled string representing a symbol name.
 class SymbolStringPtr {
+  friend class OrcV2CAPIHelper;
   friend class SymbolStringPool;
   friend struct DenseMapInfo<SymbolStringPtr>;
 
 public:
   SymbolStringPtr() = default;
+  SymbolStringPtr(std::nullptr_t) {}
   SymbolStringPtr(const SymbolStringPtr &Other)
     : S(Other.S) {
     if (isRealPoolEntry(S))
@@ -85,6 +87,8 @@
       --S->getValue();
   }
 
+  explicit operator bool() const { return S; }
+
   StringRef operator*() const { return S->first(); }
 
   friend bool operator==(const SymbolStringPtr &LHS,
@@ -103,7 +107,8 @@
   }
 
 private:
-  using PoolEntryPtr = SymbolStringPool::PoolMapEntry *;
+  using PoolEntry = SymbolStringPool::PoolMapEntry;
+  using PoolEntryPtr = PoolEntry *;
 
   SymbolStringPtr(SymbolStringPool::PoolMapEntry *S)
       : S(S) {
diff --git a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/TPCDynamicLibrarySearchGenerator.h b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/TPCDynamicLibrarySearchGenerator.h
new file mode 100644
index 0000000..ed4f608
--- /dev/null
+++ b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/TPCDynamicLibrarySearchGenerator.h
@@ -0,0 +1,66 @@
+//===------------ TPCDynamicLibrarySearchGenerator.h ------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Support loading and searching of dynamic libraries in a target process via
+// the TargetProcessControl class.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_EXECUTIONENGINE_ORC_TPCDYNAMICLIBRARYSEARCHGENERATOR_H
+#define LLVM_EXECUTIONENGINE_ORC_TPCDYNAMICLIBRARYSEARCHGENERATOR_H
+
+#include "llvm/ADT/FunctionExtras.h"
+#include "llvm/ExecutionEngine/Orc/TargetProcessControl.h"
+
+namespace llvm {
+namespace orc {
+
+class TPCDynamicLibrarySearchGenerator : public DefinitionGenerator {
+public:
+  using SymbolPredicate = unique_function<bool(const SymbolStringPtr &)>;
+
+  /// Create a DynamicLibrarySearchGenerator that searches for symbols in the
+  /// library with the given handle.
+  ///
+  /// If the Allow predicate is given then only symbols matching the predicate
+  /// will be searched for. If the predicate is not given then all symbols will
+  /// be searched for.
+  TPCDynamicLibrarySearchGenerator(TargetProcessControl &TPC,
+                                   tpctypes::DylibHandle H,
+                                   SymbolPredicate Allow = SymbolPredicate())
+      : TPC(TPC), H(H), Allow(std::move(Allow)) {}
+
+  /// Permanently loads the library at the given path and, on success, returns
+  /// a DynamicLibrarySearchGenerator that will search it for symbol definitions
+  /// in the library. On failure returns the reason the library failed to load.
+  static Expected<std::unique_ptr<TPCDynamicLibrarySearchGenerator>>
+  Load(TargetProcessControl &TPC, const char *LibraryPath,
+       SymbolPredicate Allow = SymbolPredicate());
+
+  /// Creates a TPCDynamicLibrarySearchGenerator that searches for symbols in
+  /// the target process.
+  static Expected<std::unique_ptr<TPCDynamicLibrarySearchGenerator>>
+  GetForTargetProcess(TargetProcessControl &TPC,
+                      SymbolPredicate Allow = SymbolPredicate()) {
+    return Load(TPC, nullptr, std::move(Allow));
+  }
+
+  Error tryToGenerate(LookupState &LS, LookupKind K, JITDylib &JD,
+                      JITDylibLookupFlags JDLookupFlags,
+                      const SymbolLookupSet &Symbols) override;
+
+private:
+  TargetProcessControl &TPC;
+  tpctypes::DylibHandle H;
+  SymbolPredicate Allow;
+};
+
+} // end namespace orc
+} // end namespace llvm
+
+#endif // LLVM_EXECUTIONENGINE_ORC_TPCDYNAMICLIBRARYSEARCHGENERATOR_H
diff --git a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/TPCEHFrameRegistrar.h b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/TPCEHFrameRegistrar.h
new file mode 100644
index 0000000..519f818
--- /dev/null
+++ b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/TPCEHFrameRegistrar.h
@@ -0,0 +1,54 @@
+//===-- TPCEHFrameRegistrar.h - TPC based eh-frame registration -*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// TargetProcessControl based eh-frame registration.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_EXECUTIONENGINE_ORC_TPCEHFRAMEREGISTRAR_H
+#define LLVM_EXECUTIONENGINE_ORC_TPCEHFRAMEREGISTRAR_H
+
+#include "llvm/ExecutionEngine/JITLink/EHFrameSupport.h"
+#include "llvm/ExecutionEngine/Orc/TargetProcessControl.h"
+
+namespace llvm {
+namespace orc {
+
+/// Register/Deregisters EH frames in a remote process via a
+/// TargetProcessControl instance.
+class TPCEHFrameRegistrar : public jitlink::EHFrameRegistrar {
+public:
+  /// Create from a TargetProcessControl instance alone. This will use
+  /// the TPC's lookupSymbols method to find the registration/deregistration
+  /// funciton addresses by name.
+  static Expected<std::unique_ptr<TPCEHFrameRegistrar>>
+  Create(TargetProcessControl &TPC);
+
+  /// Create a TPCEHFrameRegistrar with the given TargetProcessControl
+  /// object and registration/deregistration function addresses.
+  TPCEHFrameRegistrar(TargetProcessControl &TPC,
+                      JITTargetAddress RegisterEHFrameWrapperFnAddr,
+                      JITTargetAddress DeregisterEHFRameWrapperFnAddr)
+      : TPC(TPC), RegisterEHFrameWrapperFnAddr(RegisterEHFrameWrapperFnAddr),
+        DeregisterEHFrameWrapperFnAddr(DeregisterEHFRameWrapperFnAddr) {}
+
+  Error registerEHFrames(JITTargetAddress EHFrameSectionAddr,
+                         size_t EHFrameSectionSize) override;
+  Error deregisterEHFrames(JITTargetAddress EHFrameSectionAddr,
+                           size_t EHFrameSectionSize) override;
+
+private:
+  TargetProcessControl &TPC;
+  JITTargetAddress RegisterEHFrameWrapperFnAddr;
+  JITTargetAddress DeregisterEHFrameWrapperFnAddr;
+};
+
+} // end namespace orc
+} // end namespace llvm
+
+#endif // LLVM_EXECUTIONENGINE_ORC_TPCEHFRAMEREGISTRAR_H
diff --git a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/TPCIndirectionUtils.h b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/TPCIndirectionUtils.h
new file mode 100644
index 0000000..e7abd7f
--- /dev/null
+++ b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/TPCIndirectionUtils.h
@@ -0,0 +1,222 @@
+//===--- TPCIndirectionUtils.h - TPC based indirection utils ----*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Indirection utilities (stubs, trampolines, lazy call-throughs) that use the
+// TargetProcessControl API to interact with the target process.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_EXECUTIONENGINE_ORC_TPCINDIRECTIONUTILS_H
+#define LLVM_EXECUTIONENGINE_ORC_TPCINDIRECTIONUTILS_H
+
+#include "llvm/ExecutionEngine/JITLink/JITLinkMemoryManager.h"
+#include "llvm/ExecutionEngine/Orc/IndirectionUtils.h"
+#include "llvm/ExecutionEngine/Orc/LazyReexports.h"
+
+#include <mutex>
+
+namespace llvm {
+namespace orc {
+
+class TargetProcessControl;
+
+/// Provides TargetProcessControl based indirect stubs, trampoline pool and
+/// lazy call through manager.
+class TPCIndirectionUtils {
+  friend class TPCIndirectionUtilsAccess;
+
+public:
+  /// ABI support base class. Used to write resolver, stub, and trampoline
+  /// blocks.
+  class ABISupport {
+  protected:
+    ABISupport(unsigned PointerSize, unsigned TrampolineSize, unsigned StubSize,
+               unsigned StubToPointerMaxDisplacement, unsigned ResolverCodeSize)
+        : PointerSize(PointerSize), TrampolineSize(TrampolineSize),
+          StubSize(StubSize),
+          StubToPointerMaxDisplacement(StubToPointerMaxDisplacement),
+          ResolverCodeSize(ResolverCodeSize) {}
+
+  public:
+    virtual ~ABISupport();
+
+    unsigned getPointerSize() const { return PointerSize; }
+    unsigned getTrampolineSize() const { return TrampolineSize; }
+    unsigned getStubSize() const { return StubSize; }
+    unsigned getStubToPointerMaxDisplacement() const {
+      return StubToPointerMaxDisplacement;
+    }
+    unsigned getResolverCodeSize() const { return ResolverCodeSize; }
+
+    virtual void writeResolverCode(char *ResolverWorkingMem,
+                                   JITTargetAddress ResolverTargetAddr,
+                                   JITTargetAddress ReentryFnAddr,
+                                   JITTargetAddress ReentryCtxAddr) const = 0;
+
+    virtual void writeTrampolines(char *TrampolineBlockWorkingMem,
+                                  JITTargetAddress TrampolineBlockTragetAddr,
+                                  JITTargetAddress ResolverAddr,
+                                  unsigned NumTrampolines) const = 0;
+
+    virtual void
+    writeIndirectStubsBlock(char *StubsBlockWorkingMem,
+                            JITTargetAddress StubsBlockTargetAddress,
+                            JITTargetAddress PointersBlockTargetAddress,
+                            unsigned NumStubs) const = 0;
+
+  private:
+    unsigned PointerSize = 0;
+    unsigned TrampolineSize = 0;
+    unsigned StubSize = 0;
+    unsigned StubToPointerMaxDisplacement = 0;
+    unsigned ResolverCodeSize = 0;
+  };
+
+  /// Create using the given ABI class.
+  template <typename ORCABI>
+  static std::unique_ptr<TPCIndirectionUtils>
+  CreateWithABI(TargetProcessControl &TPC);
+
+  /// Create based on the TargetProcessControl triple.
+  static Expected<std::unique_ptr<TPCIndirectionUtils>>
+  Create(TargetProcessControl &TPC);
+
+  /// Return a reference to the TargetProcessControl object.
+  TargetProcessControl &getTargetProcessControl() const { return TPC; }
+
+  /// Return a reference to the ABISupport object for this instance.
+  ABISupport &getABISupport() const { return *ABI; }
+
+  /// Release memory for resources held by this instance. This *must* be called
+  /// prior to destruction of the class.
+  Error cleanup();
+
+  /// Write resolver code to the target process and return its address.
+  /// This must be called before any call to createTrampolinePool or
+  /// createLazyCallThroughManager.
+  Expected<JITTargetAddress>
+  writeResolverBlock(JITTargetAddress ReentryFnAddr,
+                     JITTargetAddress ReentryCtxAddr);
+
+  /// Returns the address of the Resolver block. Returns zero if the
+  /// writeResolverBlock method has not previously been called.
+  JITTargetAddress getResolverBlockAddress() const { return ResolverBlockAddr; }
+
+  /// Create an IndirectStubsManager for the target process.
+  std::unique_ptr<IndirectStubsManager> createIndirectStubsManager();
+
+  /// Create a TrampolinePool for the target process.
+  TrampolinePool &getTrampolinePool();
+
+  /// Create a LazyCallThroughManager.
+  /// This function should only be called once.
+  LazyCallThroughManager &
+  createLazyCallThroughManager(ExecutionSession &ES,
+                               JITTargetAddress ErrorHandlerAddr);
+
+  /// Create a LazyCallThroughManager for the target process.
+  LazyCallThroughManager &getLazyCallThroughManager() {
+    assert(LCTM && "createLazyCallThroughManager must be called first");
+    return *LCTM;
+  }
+
+private:
+  using Allocation = jitlink::JITLinkMemoryManager::Allocation;
+
+  struct IndirectStubInfo {
+    IndirectStubInfo() = default;
+    IndirectStubInfo(JITTargetAddress StubAddress,
+                     JITTargetAddress PointerAddress)
+        : StubAddress(StubAddress), PointerAddress(PointerAddress) {}
+    JITTargetAddress StubAddress = 0;
+    JITTargetAddress PointerAddress = 0;
+  };
+
+  using IndirectStubInfoVector = std::vector<IndirectStubInfo>;
+
+  /// Create a TPCIndirectionUtils instance.
+  TPCIndirectionUtils(TargetProcessControl &TPC,
+                      std::unique_ptr<ABISupport> ABI);
+
+  Expected<IndirectStubInfoVector> getIndirectStubs(unsigned NumStubs);
+
+  std::mutex TPCUIMutex;
+  TargetProcessControl &TPC;
+  std::unique_ptr<ABISupport> ABI;
+  JITTargetAddress ResolverBlockAddr;
+  std::unique_ptr<jitlink::JITLinkMemoryManager::Allocation> ResolverBlock;
+  std::unique_ptr<TrampolinePool> TP;
+  std::unique_ptr<LazyCallThroughManager> LCTM;
+
+  std::vector<IndirectStubInfo> AvailableIndirectStubs;
+  std::vector<std::unique_ptr<Allocation>> IndirectStubAllocs;
+};
+
+/// This will call writeResolver on the given TPCIndirectionUtils instance
+/// to set up re-entry via a function that will directly return the trampoline
+/// landing address.
+///
+/// The TPCIndirectionUtils' LazyCallThroughManager must have been previously
+/// created via TPCIndirectionUtils::createLazyCallThroughManager.
+///
+/// The TPCIndirectionUtils' writeResolver method must not have been previously
+/// called.
+///
+/// This function is experimental and likely subject to revision.
+Error setUpInProcessLCTMReentryViaTPCIU(TPCIndirectionUtils &TPCIU);
+
+namespace detail {
+
+template <typename ORCABI>
+class ABISupportImpl : public TPCIndirectionUtils::ABISupport {
+public:
+  ABISupportImpl()
+      : ABISupport(ORCABI::PointerSize, ORCABI::TrampolineSize,
+                   ORCABI::StubSize, ORCABI::StubToPointerMaxDisplacement,
+                   ORCABI::ResolverCodeSize) {}
+
+  void writeResolverCode(char *ResolverWorkingMem,
+                         JITTargetAddress ResolverTargetAddr,
+                         JITTargetAddress ReentryFnAddr,
+                         JITTargetAddress ReentryCtxAddr) const override {
+    ORCABI::writeResolverCode(ResolverWorkingMem, ResolverTargetAddr,
+                              ReentryFnAddr, ReentryCtxAddr);
+  }
+
+  void writeTrampolines(char *TrampolineBlockWorkingMem,
+                        JITTargetAddress TrampolineBlockTargetAddr,
+                        JITTargetAddress ResolverAddr,
+                        unsigned NumTrampolines) const override {
+    ORCABI::writeTrampolines(TrampolineBlockWorkingMem,
+                             TrampolineBlockTargetAddr, ResolverAddr,
+                             NumTrampolines);
+  }
+
+  void writeIndirectStubsBlock(char *StubsBlockWorkingMem,
+                               JITTargetAddress StubsBlockTargetAddress,
+                               JITTargetAddress PointersBlockTargetAddress,
+                               unsigned NumStubs) const override {
+    ORCABI::writeIndirectStubsBlock(StubsBlockWorkingMem,
+                                    StubsBlockTargetAddress,
+                                    PointersBlockTargetAddress, NumStubs);
+  }
+};
+
+} // end namespace detail
+
+template <typename ORCABI>
+std::unique_ptr<TPCIndirectionUtils>
+TPCIndirectionUtils::CreateWithABI(TargetProcessControl &TPC) {
+  return std::unique_ptr<TPCIndirectionUtils>(new TPCIndirectionUtils(
+      TPC, std::make_unique<detail::ABISupportImpl<ORCABI>>()));
+}
+
+} // end namespace orc
+} // end namespace llvm
+
+#endif // LLVM_EXECUTIONENGINE_ORC_TPCINDIRECTIONUTILS_H
diff --git a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/TargetProcess/OrcRPCTPCServer.h b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/TargetProcess/OrcRPCTPCServer.h
new file mode 100644
index 0000000..253e06b
--- /dev/null
+++ b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/TargetProcess/OrcRPCTPCServer.h
@@ -0,0 +1,620 @@
+//===-- OrcRPCTPCServer.h -- OrcRPCTargetProcessControl Server --*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// OrcRPCTargetProcessControl server class.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_EXECUTIONENGINE_ORC_TARGETPROCESS_ORCRPCTPCSERVER_H
+#define LLVM_EXECUTIONENGINE_ORC_TARGETPROCESS_ORCRPCTPCSERVER_H
+
+#include "llvm/ADT/BitmaskEnum.h"
+#include "llvm/ExecutionEngine/Orc/Shared/RPCUtils.h"
+#include "llvm/ExecutionEngine/Orc/Shared/RawByteChannel.h"
+#include "llvm/ExecutionEngine/Orc/Shared/TargetProcessControlTypes.h"
+#include "llvm/ExecutionEngine/Orc/TargetProcess/TargetExecutionUtils.h"
+#include "llvm/ExecutionEngine/Orc/TargetProcessControl.h"
+#include "llvm/Support/DynamicLibrary.h"
+#include "llvm/Support/FormatVariadic.h"
+#include "llvm/Support/Host.h"
+#include "llvm/Support/MathExtras.h"
+#include "llvm/Support/Memory.h"
+#include "llvm/Support/Process.h"
+
+#include <atomic>
+
+namespace llvm {
+namespace orc {
+
+namespace orcrpctpc {
+
+enum WireProtectionFlags : uint8_t {
+  WPF_None = 0,
+  WPF_Read = 1U << 0,
+  WPF_Write = 1U << 1,
+  WPF_Exec = 1U << 2,
+  LLVM_MARK_AS_BITMASK_ENUM(WPF_Exec)
+};
+
+/// Convert from sys::Memory::ProtectionFlags
+inline WireProtectionFlags
+toWireProtectionFlags(sys::Memory::ProtectionFlags PF) {
+  WireProtectionFlags WPF = WPF_None;
+  if (PF & sys::Memory::MF_READ)
+    WPF |= WPF_Read;
+  if (PF & sys::Memory::MF_WRITE)
+    WPF |= WPF_Write;
+  if (PF & sys::Memory::MF_EXEC)
+    WPF |= WPF_Exec;
+  return WPF;
+}
+
+inline sys::Memory::ProtectionFlags
+fromWireProtectionFlags(WireProtectionFlags WPF) {
+  int PF = 0;
+  if (WPF & WPF_Read)
+    PF |= sys::Memory::MF_READ;
+  if (WPF & WPF_Write)
+    PF |= sys::Memory::MF_WRITE;
+  if (WPF & WPF_Exec)
+    PF |= sys::Memory::MF_EXEC;
+  return static_cast<sys::Memory::ProtectionFlags>(PF);
+}
+
+struct ReserveMemRequestElement {
+  WireProtectionFlags Prot = WPF_None;
+  uint64_t Size = 0;
+  uint64_t Alignment = 0;
+};
+
+using ReserveMemRequest = std::vector<ReserveMemRequestElement>;
+
+struct ReserveMemResultElement {
+  WireProtectionFlags Prot = WPF_None;
+  JITTargetAddress Address = 0;
+  uint64_t AllocatedSize = 0;
+};
+
+using ReserveMemResult = std::vector<ReserveMemResultElement>;
+
+struct ReleaseOrFinalizeMemRequestElement {
+  WireProtectionFlags Prot = WPF_None;
+  JITTargetAddress Address = 0;
+  uint64_t Size = 0;
+};
+
+using ReleaseOrFinalizeMemRequest =
+    std::vector<ReleaseOrFinalizeMemRequestElement>;
+
+} // end namespace orcrpctpc
+
+namespace shared {
+
+template <> class SerializationTypeName<tpctypes::UInt8Write> {
+public:
+  static const char *getName() { return "UInt8Write"; }
+};
+
+template <> class SerializationTypeName<tpctypes::UInt16Write> {
+public:
+  static const char *getName() { return "UInt16Write"; }
+};
+
+template <> class SerializationTypeName<tpctypes::UInt32Write> {
+public:
+  static const char *getName() { return "UInt32Write"; }
+};
+
+template <> class SerializationTypeName<tpctypes::UInt64Write> {
+public:
+  static const char *getName() { return "UInt64Write"; }
+};
+
+template <> class SerializationTypeName<tpctypes::BufferWrite> {
+public:
+  static const char *getName() { return "BufferWrite"; }
+};
+
+template <> class SerializationTypeName<orcrpctpc::ReserveMemRequestElement> {
+public:
+  static const char *getName() { return "ReserveMemRequestElement"; }
+};
+
+template <> class SerializationTypeName<orcrpctpc::ReserveMemResultElement> {
+public:
+  static const char *getName() { return "ReserveMemResultElement"; }
+};
+
+template <>
+class SerializationTypeName<orcrpctpc::ReleaseOrFinalizeMemRequestElement> {
+public:
+  static const char *getName() { return "ReleaseOrFinalizeMemRequestElement"; }
+};
+
+template <> class SerializationTypeName<tpctypes::WrapperFunctionResult> {
+public:
+  static const char *getName() { return "WrapperFunctionResult"; }
+};
+
+template <typename ChannelT, typename WriteT>
+class SerializationTraits<
+    ChannelT, WriteT, WriteT,
+    std::enable_if_t<std::is_same<WriteT, tpctypes::UInt8Write>::value ||
+                     std::is_same<WriteT, tpctypes::UInt16Write>::value ||
+                     std::is_same<WriteT, tpctypes::UInt32Write>::value ||
+                     std::is_same<WriteT, tpctypes::UInt64Write>::value>> {
+public:
+  static Error serialize(ChannelT &C, const WriteT &W) {
+    return serializeSeq(C, W.Address, W.Value);
+  }
+  static Error deserialize(ChannelT &C, WriteT &W) {
+    return deserializeSeq(C, W.Address, W.Value);
+  }
+};
+
+template <typename ChannelT>
+class SerializationTraits<
+    ChannelT, tpctypes::BufferWrite, tpctypes::BufferWrite,
+    std::enable_if_t<std::is_base_of<RawByteChannel, ChannelT>::value>> {
+public:
+  static Error serialize(ChannelT &C, const tpctypes::BufferWrite &W) {
+    uint64_t Size = W.Buffer.size();
+    if (auto Err = serializeSeq(C, W.Address, Size))
+      return Err;
+
+    return C.appendBytes(W.Buffer.data(), Size);
+  }
+  static Error deserialize(ChannelT &C, tpctypes::BufferWrite &W) {
+    JITTargetAddress Address;
+    uint64_t Size;
+
+    if (auto Err = deserializeSeq(C, Address, Size))
+      return Err;
+
+    char *Buffer = jitTargetAddressToPointer<char *>(Address);
+
+    if (auto Err = C.readBytes(Buffer, Size))
+      return Err;
+
+    W = {Address, StringRef(Buffer, Size)};
+    return Error::success();
+  }
+};
+
+template <typename ChannelT>
+class SerializationTraits<ChannelT, orcrpctpc::ReserveMemRequestElement> {
+public:
+  static Error serialize(ChannelT &C,
+                         const orcrpctpc::ReserveMemRequestElement &E) {
+    return serializeSeq(C, static_cast<uint8_t>(E.Prot), E.Size, E.Alignment);
+  }
+
+  static Error deserialize(ChannelT &C,
+                           orcrpctpc::ReserveMemRequestElement &E) {
+    return deserializeSeq(C, *reinterpret_cast<uint8_t *>(&E.Prot), E.Size,
+                          E.Alignment);
+  }
+};
+
+template <typename ChannelT>
+class SerializationTraits<ChannelT, orcrpctpc::ReserveMemResultElement> {
+public:
+  static Error serialize(ChannelT &C,
+                         const orcrpctpc::ReserveMemResultElement &E) {
+    return serializeSeq(C, static_cast<uint8_t>(E.Prot), E.Address,
+                        E.AllocatedSize);
+  }
+
+  static Error deserialize(ChannelT &C, orcrpctpc::ReserveMemResultElement &E) {
+    return deserializeSeq(C, *reinterpret_cast<uint8_t *>(&E.Prot), E.Address,
+                          E.AllocatedSize);
+  }
+};
+
+template <typename ChannelT>
+class SerializationTraits<ChannelT,
+                          orcrpctpc::ReleaseOrFinalizeMemRequestElement> {
+public:
+  static Error
+  serialize(ChannelT &C,
+            const orcrpctpc::ReleaseOrFinalizeMemRequestElement &E) {
+    return serializeSeq(C, static_cast<uint8_t>(E.Prot), E.Address, E.Size);
+  }
+
+  static Error deserialize(ChannelT &C,
+                           orcrpctpc::ReleaseOrFinalizeMemRequestElement &E) {
+    return deserializeSeq(C, *reinterpret_cast<uint8_t *>(&E.Prot), E.Address,
+                          E.Size);
+  }
+};
+
+template <typename ChannelT>
+class SerializationTraits<
+    ChannelT, tpctypes::WrapperFunctionResult, tpctypes::WrapperFunctionResult,
+    std::enable_if_t<std::is_base_of<RawByteChannel, ChannelT>::value>> {
+public:
+  static Error serialize(ChannelT &C,
+                         const tpctypes::WrapperFunctionResult &E) {
+    auto Data = E.getData();
+    if (auto Err = serializeSeq(C, static_cast<uint64_t>(Data.size())))
+      return Err;
+    if (Data.size() == 0)
+      return Error::success();
+    return C.appendBytes(reinterpret_cast<const char *>(Data.data()),
+                         Data.size());
+  }
+
+  static Error deserialize(ChannelT &C, tpctypes::WrapperFunctionResult &E) {
+    tpctypes::CWrapperFunctionResult R;
+
+    R.Size = 0;
+    R.Data.ValuePtr = nullptr;
+    R.Destroy = nullptr;
+
+    if (auto Err = deserializeSeq(C, R.Size))
+      return Err;
+    if (R.Size == 0)
+      return Error::success();
+    R.Data.ValuePtr = new uint8_t[R.Size];
+    if (auto Err =
+            C.readBytes(reinterpret_cast<char *>(R.Data.ValuePtr), R.Size)) {
+      R.Destroy = tpctypes::WrapperFunctionResult::destroyWithDeleteArray;
+      return Err;
+    }
+
+    E = tpctypes::WrapperFunctionResult(R);
+    return Error::success();
+  }
+};
+
+} // end namespace shared
+
+namespace orcrpctpc {
+
+using RemoteSymbolLookupSet = std::vector<std::pair<std::string, bool>>;
+using RemoteLookupRequest =
+    std::pair<tpctypes::DylibHandle, RemoteSymbolLookupSet>;
+
+class GetTargetTriple
+    : public shared::RPCFunction<GetTargetTriple, std::string()> {
+public:
+  static const char *getName() { return "GetTargetTriple"; }
+};
+
+class GetPageSize : public shared::RPCFunction<GetPageSize, uint64_t()> {
+public:
+  static const char *getName() { return "GetPageSize"; }
+};
+
+class ReserveMem
+    : public shared::RPCFunction<ReserveMem, Expected<ReserveMemResult>(
+                                                 ReserveMemRequest)> {
+public:
+  static const char *getName() { return "ReserveMem"; }
+};
+
+class FinalizeMem
+    : public shared::RPCFunction<FinalizeMem,
+                                 Error(ReleaseOrFinalizeMemRequest)> {
+public:
+  static const char *getName() { return "FinalizeMem"; }
+};
+
+class ReleaseMem
+    : public shared::RPCFunction<ReleaseMem,
+                                 Error(ReleaseOrFinalizeMemRequest)> {
+public:
+  static const char *getName() { return "ReleaseMem"; }
+};
+
+class WriteUInt8s
+    : public shared::RPCFunction<WriteUInt8s,
+                                 Error(std::vector<tpctypes::UInt8Write>)> {
+public:
+  static const char *getName() { return "WriteUInt8s"; }
+};
+
+class WriteUInt16s
+    : public shared::RPCFunction<WriteUInt16s,
+                                 Error(std::vector<tpctypes::UInt16Write>)> {
+public:
+  static const char *getName() { return "WriteUInt16s"; }
+};
+
+class WriteUInt32s
+    : public shared::RPCFunction<WriteUInt32s,
+                                 Error(std::vector<tpctypes::UInt32Write>)> {
+public:
+  static const char *getName() { return "WriteUInt32s"; }
+};
+
+class WriteUInt64s
+    : public shared::RPCFunction<WriteUInt64s,
+                                 Error(std::vector<tpctypes::UInt64Write>)> {
+public:
+  static const char *getName() { return "WriteUInt64s"; }
+};
+
+class WriteBuffers
+    : public shared::RPCFunction<WriteBuffers,
+                                 Error(std::vector<tpctypes::BufferWrite>)> {
+public:
+  static const char *getName() { return "WriteBuffers"; }
+};
+
+class LoadDylib
+    : public shared::RPCFunction<LoadDylib, Expected<tpctypes::DylibHandle>(
+                                                std::string DylibPath)> {
+public:
+  static const char *getName() { return "LoadDylib"; }
+};
+
+class LookupSymbols
+    : public shared::RPCFunction<LookupSymbols,
+                                 Expected<std::vector<tpctypes::LookupResult>>(
+                                     std::vector<RemoteLookupRequest>)> {
+public:
+  static const char *getName() { return "LookupSymbols"; }
+};
+
+class RunMain
+    : public shared::RPCFunction<RunMain,
+                                 int32_t(JITTargetAddress MainAddr,
+                                         std::vector<std::string> Args)> {
+public:
+  static const char *getName() { return "RunMain"; }
+};
+
+class RunWrapper
+    : public shared::RPCFunction<RunWrapper,
+                                 tpctypes::WrapperFunctionResult(
+                                     JITTargetAddress, std::vector<uint8_t>)> {
+public:
+  static const char *getName() { return "RunWrapper"; }
+};
+
+class CloseConnection : public shared::RPCFunction<CloseConnection, void()> {
+public:
+  static const char *getName() { return "CloseConnection"; }
+};
+
+} // end namespace orcrpctpc
+
+/// TargetProcessControl for a process connected via an ORC RPC Endpoint.
+template <typename RPCEndpointT> class OrcRPCTPCServer {
+public:
+  /// Create an OrcRPCTPCServer from the given endpoint.
+  OrcRPCTPCServer(RPCEndpointT &EP) : EP(EP) {
+    using ThisT = OrcRPCTPCServer<RPCEndpointT>;
+
+    TripleStr = sys::getProcessTriple();
+    PageSize = sys::Process::getPageSizeEstimate();
+
+    EP.template addHandler<orcrpctpc::GetTargetTriple>(*this,
+                                                       &ThisT::getTargetTriple);
+    EP.template addHandler<orcrpctpc::GetPageSize>(*this, &ThisT::getPageSize);
+
+    EP.template addHandler<orcrpctpc::ReserveMem>(*this, &ThisT::reserveMemory);
+    EP.template addHandler<orcrpctpc::FinalizeMem>(*this,
+                                                   &ThisT::finalizeMemory);
+    EP.template addHandler<orcrpctpc::ReleaseMem>(*this, &ThisT::releaseMemory);
+
+    EP.template addHandler<orcrpctpc::WriteUInt8s>(
+        handleWriteUInt<tpctypes::UInt8Write>);
+    EP.template addHandler<orcrpctpc::WriteUInt16s>(
+        handleWriteUInt<tpctypes::UInt16Write>);
+    EP.template addHandler<orcrpctpc::WriteUInt32s>(
+        handleWriteUInt<tpctypes::UInt32Write>);
+    EP.template addHandler<orcrpctpc::WriteUInt64s>(
+        handleWriteUInt<tpctypes::UInt64Write>);
+    EP.template addHandler<orcrpctpc::WriteBuffers>(handleWriteBuffer);
+
+    EP.template addHandler<orcrpctpc::LoadDylib>(*this, &ThisT::loadDylib);
+    EP.template addHandler<orcrpctpc::LookupSymbols>(*this,
+                                                     &ThisT::lookupSymbols);
+
+    EP.template addHandler<orcrpctpc::RunMain>(*this, &ThisT::runMain);
+    EP.template addHandler<orcrpctpc::RunWrapper>(*this, &ThisT::runWrapper);
+
+    EP.template addHandler<orcrpctpc::CloseConnection>(*this,
+                                                       &ThisT::closeConnection);
+  }
+
+  /// Set the ProgramName to be used as the first argv element when running
+  /// functions via runAsMain.
+  void setProgramName(Optional<std::string> ProgramName = None) {
+    this->ProgramName = std::move(ProgramName);
+  }
+
+  /// Get the RPC endpoint for this server.
+  RPCEndpointT &getEndpoint() { return EP; }
+
+  /// Run the server loop.
+  Error run() {
+    while (!Finished) {
+      if (auto Err = EP.handleOne())
+        return Err;
+    }
+    return Error::success();
+  }
+
+private:
+  std::string getTargetTriple() { return TripleStr; }
+  uint64_t getPageSize() { return PageSize; }
+
+  template <typename WriteT>
+  static void handleWriteUInt(const std::vector<WriteT> &Ws) {
+    using ValueT = decltype(std::declval<WriteT>().Value);
+    for (auto &W : Ws)
+      *jitTargetAddressToPointer<ValueT *>(W.Address) = W.Value;
+  }
+
+  std::string getProtStr(orcrpctpc::WireProtectionFlags WPF) {
+    std::string Result;
+    Result += (WPF & orcrpctpc::WPF_Read) ? 'R' : '-';
+    Result += (WPF & orcrpctpc::WPF_Write) ? 'W' : '-';
+    Result += (WPF & orcrpctpc::WPF_Exec) ? 'X' : '-';
+    return Result;
+  }
+
+  static void handleWriteBuffer(const std::vector<tpctypes::BufferWrite> &Ws) {
+    for (auto &W : Ws) {
+      memcpy(jitTargetAddressToPointer<char *>(W.Address), W.Buffer.data(),
+             W.Buffer.size());
+    }
+  }
+
+  Expected<orcrpctpc::ReserveMemResult>
+  reserveMemory(const orcrpctpc::ReserveMemRequest &Request) {
+    orcrpctpc::ReserveMemResult Allocs;
+    auto PF = sys::Memory::MF_READ | sys::Memory::MF_WRITE;
+
+    uint64_t TotalSize = 0;
+
+    for (const auto &E : Request) {
+      uint64_t Size = alignTo(E.Size, PageSize);
+      uint16_t Align = E.Alignment;
+
+      if ((Align > PageSize) || (PageSize % Align))
+        return make_error<StringError>(
+            "Page alignmen does not satisfy requested alignment",
+            inconvertibleErrorCode());
+
+      TotalSize += Size;
+    }
+
+    // Allocate memory slab.
+    std::error_code EC;
+    auto MB = sys::Memory::allocateMappedMemory(TotalSize, nullptr, PF, EC);
+    if (EC)
+      return make_error<StringError>("Unable to allocate memory: " +
+                                         EC.message(),
+                                     inconvertibleErrorCode());
+
+    // Zero-fill the whole thing.
+    memset(MB.base(), 0, MB.allocatedSize());
+
+    // Carve up sections to return.
+    uint64_t SectionBase = 0;
+    for (const auto &E : Request) {
+      uint64_t SectionSize = alignTo(E.Size, PageSize);
+      Allocs.push_back({E.Prot,
+                        pointerToJITTargetAddress(MB.base()) + SectionBase,
+                        SectionSize});
+      SectionBase += SectionSize;
+    }
+
+    return Allocs;
+  }
+
+  Error finalizeMemory(const orcrpctpc::ReleaseOrFinalizeMemRequest &FMR) {
+    for (const auto &E : FMR) {
+      sys::MemoryBlock MB(jitTargetAddressToPointer<void *>(E.Address), E.Size);
+
+      auto PF = orcrpctpc::fromWireProtectionFlags(E.Prot);
+      if (auto EC =
+              sys::Memory::protectMappedMemory(MB, static_cast<unsigned>(PF)))
+        return make_error<StringError>("error protecting memory: " +
+                                           EC.message(),
+                                       inconvertibleErrorCode());
+    }
+    return Error::success();
+  }
+
+  Error releaseMemory(const orcrpctpc::ReleaseOrFinalizeMemRequest &RMR) {
+    for (const auto &E : RMR) {
+      sys::MemoryBlock MB(jitTargetAddressToPointer<void *>(E.Address), E.Size);
+
+      if (auto EC = sys::Memory::releaseMappedMemory(MB))
+        return make_error<StringError>("error release memory: " + EC.message(),
+                                       inconvertibleErrorCode());
+    }
+    return Error::success();
+  }
+
+  Expected<tpctypes::DylibHandle> loadDylib(const std::string &Path) {
+    std::string ErrMsg;
+    const char *DLPath = !Path.empty() ? Path.c_str() : nullptr;
+    auto DL = sys::DynamicLibrary::getPermanentLibrary(DLPath, &ErrMsg);
+    if (!DL.isValid())
+      return make_error<StringError>(std::move(ErrMsg),
+                                     inconvertibleErrorCode());
+
+    tpctypes::DylibHandle H = Dylibs.size();
+    Dylibs[H] = std::move(DL);
+    return H;
+  }
+
+  Expected<std::vector<tpctypes::LookupResult>>
+  lookupSymbols(const std::vector<orcrpctpc::RemoteLookupRequest> &Request) {
+    std::vector<tpctypes::LookupResult> Result;
+
+    for (const auto &E : Request) {
+      auto I = Dylibs.find(E.first);
+      if (I == Dylibs.end())
+        return make_error<StringError>("Unrecognized handle",
+                                       inconvertibleErrorCode());
+      auto &DL = I->second;
+      Result.push_back({});
+
+      for (const auto &KV : E.second) {
+        auto &SymString = KV.first;
+        bool WeakReference = KV.second;
+
+        const char *Sym = SymString.c_str();
+#ifdef __APPLE__
+        if (*Sym == '_')
+          ++Sym;
+#endif
+
+        void *Addr = DL.getAddressOfSymbol(Sym);
+        if (!Addr && !WeakReference)
+          return make_error<StringError>(Twine("Missing definition for ") + Sym,
+                                         inconvertibleErrorCode());
+
+        Result.back().push_back(pointerToJITTargetAddress(Addr));
+      }
+    }
+
+    return Result;
+  }
+
+  int32_t runMain(JITTargetAddress MainFnAddr,
+                  const std::vector<std::string> &Args) {
+    Optional<StringRef> ProgramNameOverride;
+    if (ProgramName)
+      ProgramNameOverride = *ProgramName;
+
+    return runAsMain(
+        jitTargetAddressToFunction<int (*)(int, char *[])>(MainFnAddr), Args,
+        ProgramNameOverride);
+  }
+
+  tpctypes::WrapperFunctionResult
+  runWrapper(JITTargetAddress WrapperFnAddr,
+             const std::vector<uint8_t> &ArgBuffer) {
+    using WrapperFnTy = tpctypes::CWrapperFunctionResult (*)(
+        const uint8_t *Data, uint64_t Size);
+    auto *WrapperFn = jitTargetAddressToFunction<WrapperFnTy>(WrapperFnAddr);
+    return WrapperFn(ArgBuffer.data(), ArgBuffer.size());
+  }
+
+  void closeConnection() { Finished = true; }
+
+  std::string TripleStr;
+  uint64_t PageSize = 0;
+  Optional<std::string> ProgramName;
+  RPCEndpointT &EP;
+  std::atomic<bool> Finished{false};
+  DenseMap<tpctypes::DylibHandle, sys::DynamicLibrary> Dylibs;
+};
+
+} // end namespace orc
+} // end namespace llvm
+
+#endif // LLVM_EXECUTIONENGINE_ORC_TARGETPROCESS_ORCRPCTPCSERVER_H
diff --git a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/TargetProcess/RegisterEHFrames.h b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/TargetProcess/RegisterEHFrames.h
new file mode 100644
index 0000000..811c50e
--- /dev/null
+++ b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/TargetProcess/RegisterEHFrames.h
@@ -0,0 +1,41 @@
+//===----- RegisterEHFrames.h -- Register EH frame sections -----*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Support for dynamically registering and deregistering eh-frame sections
+// in-process via libunwind.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_EXECUTIONENGINE_ORC_TARGETPROCESS_REGISTEREHFRAMES_H
+#define LLVM_EXECUTIONENGINE_ORC_TARGETPROCESS_REGISTEREHFRAMES_H
+
+#include "llvm/ExecutionEngine/Orc/Shared/TargetProcessControlTypes.h"
+#include "llvm/Support/Error.h"
+#include <vector>
+
+namespace llvm {
+namespace orc {
+
+/// Register frames in the given eh-frame section with libunwind.
+Error registerEHFrameSection(const void *EHFrameSectionAddr,
+                             size_t EHFrameSectionSize);
+
+/// Unregister frames in the given eh-frame section with libunwind.
+Error deregisterEHFrameSection(const void *EHFrameSectionAddr,
+                               size_t EHFrameSectionSize);
+
+} // end namespace orc
+} // end namespace llvm
+
+extern "C" llvm::orc::tpctypes::CWrapperFunctionResult
+llvm_orc_registerEHFrameSectionWrapper(uint8_t *Data, uint64_t Size);
+
+extern "C" llvm::orc::tpctypes::CWrapperFunctionResult
+llvm_orc_deregisterEHFrameSectionWrapper(uint8_t *Data, uint64_t Size);
+
+#endif // LLVM_EXECUTIONENGINE_ORC_TARGETPROCESS_REGISTEREHFRAMES_H
diff --git a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/TargetProcess/TargetExecutionUtils.h b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/TargetProcess/TargetExecutionUtils.h
new file mode 100644
index 0000000..1d2f6d2
--- /dev/null
+++ b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/TargetProcess/TargetExecutionUtils.h
@@ -0,0 +1,38 @@
+//===-- TargetExecutionUtils.h - Utils for execution in target --*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Utilities for execution in the target process.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_EXECUTIONENGINE_ORC_TARGETPROCESS_TARGETEXECUTIONUTILS_H
+#define LLVM_EXECUTIONENGINE_ORC_TARGETPROCESS_TARGETEXECUTIONUTILS_H
+
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/Optional.h"
+#include "llvm/ADT/StringRef.h"
+#include <string>
+
+namespace llvm {
+namespace orc {
+
+/// Run a main function, returning the result.
+///
+/// If the optional ProgramName argument is given then it will be inserted
+/// before the strings in Args as the first argument to the called function.
+///
+/// It is legal to have an empty argument list and no program name, however
+/// many main functions will expect a name argument at least, and will fail
+/// if none is provided.
+int runAsMain(int (*Main)(int, char *[]), ArrayRef<std::string> Args,
+              Optional<StringRef> ProgramName = None);
+
+} // end namespace orc
+} // end namespace llvm
+
+#endif // LLVM_EXECUTIONENGINE_ORC_TARGETPROCESS_TARGETEXECUTIONUTILS_H
diff --git a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/TargetProcessControl.h b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/TargetProcessControl.h
new file mode 100644
index 0000000..504a5ea
--- /dev/null
+++ b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/TargetProcessControl.h
@@ -0,0 +1,210 @@
+//===--- TargetProcessControl.h - Target process control APIs ---*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Utilities for interacting with target processes.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_EXECUTIONENGINE_ORC_TARGETPROCESSCONTROL_H
+#define LLVM_EXECUTIONENGINE_ORC_TARGETPROCESSCONTROL_H
+
+#include "llvm/ADT/Optional.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/Triple.h"
+#include "llvm/ExecutionEngine/JITLink/JITLinkMemoryManager.h"
+#include "llvm/ExecutionEngine/Orc/Core.h"
+#include "llvm/ExecutionEngine/Orc/Shared/TargetProcessControlTypes.h"
+#include "llvm/Support/DynamicLibrary.h"
+#include "llvm/Support/MSVCErrorWorkarounds.h"
+
+#include <future>
+#include <vector>
+
+namespace llvm {
+namespace orc {
+
+/// TargetProcessControl supports interaction with a JIT target process.
+class TargetProcessControl {
+public:
+  /// APIs for manipulating memory in the target process.
+  class MemoryAccess {
+  public:
+    /// Callback function for asynchronous writes.
+    using WriteResultFn = unique_function<void(Error)>;
+
+    virtual ~MemoryAccess();
+
+    virtual void writeUInt8s(ArrayRef<tpctypes::UInt8Write> Ws,
+                             WriteResultFn OnWriteComplete) = 0;
+
+    virtual void writeUInt16s(ArrayRef<tpctypes::UInt16Write> Ws,
+                              WriteResultFn OnWriteComplete) = 0;
+
+    virtual void writeUInt32s(ArrayRef<tpctypes::UInt32Write> Ws,
+                              WriteResultFn OnWriteComplete) = 0;
+
+    virtual void writeUInt64s(ArrayRef<tpctypes::UInt64Write> Ws,
+                              WriteResultFn OnWriteComplete) = 0;
+
+    virtual void writeBuffers(ArrayRef<tpctypes::BufferWrite> Ws,
+                              WriteResultFn OnWriteComplete) = 0;
+
+    Error writeUInt8s(ArrayRef<tpctypes::UInt8Write> Ws) {
+      std::promise<MSVCPError> ResultP;
+      auto ResultF = ResultP.get_future();
+      writeUInt8s(Ws, [&](Error Err) { ResultP.set_value(std::move(Err)); });
+      return ResultF.get();
+    }
+
+    Error writeUInt16s(ArrayRef<tpctypes::UInt16Write> Ws) {
+      std::promise<MSVCPError> ResultP;
+      auto ResultF = ResultP.get_future();
+      writeUInt16s(Ws, [&](Error Err) { ResultP.set_value(std::move(Err)); });
+      return ResultF.get();
+    }
+
+    Error writeUInt32s(ArrayRef<tpctypes::UInt32Write> Ws) {
+      std::promise<MSVCPError> ResultP;
+      auto ResultF = ResultP.get_future();
+      writeUInt32s(Ws, [&](Error Err) { ResultP.set_value(std::move(Err)); });
+      return ResultF.get();
+    }
+
+    Error writeUInt64s(ArrayRef<tpctypes::UInt64Write> Ws) {
+      std::promise<MSVCPError> ResultP;
+      auto ResultF = ResultP.get_future();
+      writeUInt64s(Ws, [&](Error Err) { ResultP.set_value(std::move(Err)); });
+      return ResultF.get();
+    }
+
+    Error writeBuffers(ArrayRef<tpctypes::BufferWrite> Ws) {
+      std::promise<MSVCPError> ResultP;
+      auto ResultF = ResultP.get_future();
+      writeBuffers(Ws, [&](Error Err) { ResultP.set_value(std::move(Err)); });
+      return ResultF.get();
+    }
+  };
+
+  virtual ~TargetProcessControl();
+
+  /// Intern a symbol name in the SymbolStringPool.
+  SymbolStringPtr intern(StringRef SymName) { return SSP->intern(SymName); }
+
+  /// Return a shared pointer to the SymbolStringPool for this instance.
+  std::shared_ptr<SymbolStringPool> getSymbolStringPool() const { return SSP; }
+
+  /// Return the Triple for the target process.
+  const Triple &getTargetTriple() const { return TargetTriple; }
+
+  /// Get the page size for the target process.
+  unsigned getPageSize() const { return PageSize; }
+
+  /// Return a MemoryAccess object for the target process.
+  MemoryAccess &getMemoryAccess() const { return *MemAccess; }
+
+  /// Return a JITLinkMemoryManager for the target process.
+  jitlink::JITLinkMemoryManager &getMemMgr() const { return *MemMgr; }
+
+  /// Load the dynamic library at the given path and return a handle to it.
+  /// If LibraryPath is null this function will return the global handle for
+  /// the target process.
+  virtual Expected<tpctypes::DylibHandle> loadDylib(const char *DylibPath) = 0;
+
+  /// Search for symbols in the target process.
+  ///
+  /// The result of the lookup is a 2-dimentional array of target addresses
+  /// that correspond to the lookup order. If a required symbol is not
+  /// found then this method will return an error. If a weakly referenced
+  /// symbol is not found then it be assigned a '0' value in the result.
+  /// that correspond to the lookup order.
+  virtual Expected<std::vector<tpctypes::LookupResult>>
+  lookupSymbols(ArrayRef<tpctypes::LookupRequest> Request) = 0;
+
+  /// Run function with a main-like signature.
+  virtual Expected<int32_t> runAsMain(JITTargetAddress MainFnAddr,
+                                      ArrayRef<std::string> Args) = 0;
+
+  /// Run a wrapper function with signature:
+  ///
+  /// \code{.cpp}
+  ///   CWrapperFunctionResult fn(uint8_t *Data, uint64_t Size);
+  /// \endcode{.cpp}
+  ///
+  virtual Expected<tpctypes::WrapperFunctionResult>
+  runWrapper(JITTargetAddress WrapperFnAddr, ArrayRef<uint8_t> ArgBuffer) = 0;
+
+  /// Disconnect from the target process.
+  ///
+  /// This should be called after the JIT session is shut down.
+  virtual Error disconnect() = 0;
+
+protected:
+  TargetProcessControl(std::shared_ptr<SymbolStringPool> SSP)
+      : SSP(std::move(SSP)) {}
+
+  std::shared_ptr<SymbolStringPool> SSP;
+  Triple TargetTriple;
+  unsigned PageSize = 0;
+  MemoryAccess *MemAccess = nullptr;
+  jitlink::JITLinkMemoryManager *MemMgr = nullptr;
+};
+
+/// A TargetProcessControl implementation targeting the current process.
+class SelfTargetProcessControl : public TargetProcessControl,
+                                 private TargetProcessControl::MemoryAccess {
+public:
+  SelfTargetProcessControl(
+      std::shared_ptr<SymbolStringPool> SSP, Triple TargetTriple,
+      unsigned PageSize, std::unique_ptr<jitlink::JITLinkMemoryManager> MemMgr);
+
+  /// Create a SelfTargetProcessControl with the given memory manager.
+  /// If no memory manager is given a jitlink::InProcessMemoryManager will
+  /// be used by default.
+  static Expected<std::unique_ptr<SelfTargetProcessControl>>
+  Create(std::shared_ptr<SymbolStringPool> SSP,
+         std::unique_ptr<jitlink::JITLinkMemoryManager> MemMgr = nullptr);
+
+  Expected<tpctypes::DylibHandle> loadDylib(const char *DylibPath) override;
+
+  Expected<std::vector<tpctypes::LookupResult>>
+  lookupSymbols(ArrayRef<tpctypes::LookupRequest> Request) override;
+
+  Expected<int32_t> runAsMain(JITTargetAddress MainFnAddr,
+                              ArrayRef<std::string> Args) override;
+
+  Expected<tpctypes::WrapperFunctionResult>
+  runWrapper(JITTargetAddress WrapperFnAddr,
+             ArrayRef<uint8_t> ArgBuffer) override;
+
+  Error disconnect() override;
+
+private:
+  void writeUInt8s(ArrayRef<tpctypes::UInt8Write> Ws,
+                   WriteResultFn OnWriteComplete) override;
+
+  void writeUInt16s(ArrayRef<tpctypes::UInt16Write> Ws,
+                    WriteResultFn OnWriteComplete) override;
+
+  void writeUInt32s(ArrayRef<tpctypes::UInt32Write> Ws,
+                    WriteResultFn OnWriteComplete) override;
+
+  void writeUInt64s(ArrayRef<tpctypes::UInt64Write> Ws,
+                    WriteResultFn OnWriteComplete) override;
+
+  void writeBuffers(ArrayRef<tpctypes::BufferWrite> Ws,
+                    WriteResultFn OnWriteComplete) override;
+
+  std::unique_ptr<jitlink::JITLinkMemoryManager> OwnedMemMgr;
+  char GlobalManglingPrefix = 0;
+  std::vector<std::unique_ptr<sys::DynamicLibrary>> DynamicLibraries;
+};
+
+} // end namespace orc
+} // end namespace llvm
+
+#endif // LLVM_EXECUTIONENGINE_ORC_TARGETPROCESSCONTROL_H
diff --git a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/ThreadSafeModule.h b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/ThreadSafeModule.h
index 5787500..82f2b74 100644
--- a/linux-x64/clang/include/llvm/ExecutionEngine/Orc/ThreadSafeModule.h
+++ b/linux-x64/clang/include/llvm/ExecutionEngine/Orc/ThreadSafeModule.h
@@ -38,17 +38,12 @@
 public:
   // RAII based lock for ThreadSafeContext.
   class LLVM_NODISCARD Lock {
-  private:
-    using UnderlyingLock = std::lock_guard<std::recursive_mutex>;
-
   public:
-    Lock(std::shared_ptr<State> S)
-        : S(std::move(S)),
-          L(llvm::make_unique<UnderlyingLock>(this->S->Mutex)) {}
+    Lock(std::shared_ptr<State> S) : S(std::move(S)), L(this->S->Mutex) {}
 
   private:
     std::shared_ptr<State> S;
-    std::unique_ptr<UnderlyingLock> L;
+    std::unique_lock<std::recursive_mutex> L;
   };
 
   /// Construct a null context.
@@ -69,7 +64,7 @@
   /// instance, or null if the instance was default constructed.
   const LLVMContext *getContext() const { return S ? S->Ctx.get() : nullptr; }
 
-  Lock getLock() {
+  Lock getLock() const {
     assert(S && "Can not lock an empty ThreadSafeContext");
     return Lock(S);
   }
@@ -95,7 +90,7 @@
     // We also need to lock the context to make sure the module tear-down
     // does not overlap any other work on the context.
     if (M) {
-      auto L = getContextLock();
+      auto L = TSCtx.getLock();
       M = nullptr;
     }
     M = std::move(Other.M);
@@ -117,23 +112,14 @@
   ~ThreadSafeModule() {
     // We need to lock the context while we destruct the module.
     if (M) {
-      auto L = getContextLock();
+      auto L = TSCtx.getLock();
       M = nullptr;
     }
   }
 
-  /// Get the module wrapped by this ThreadSafeModule.
-  Module *getModule() { return M.get(); }
-
-  /// Get the module wrapped by this ThreadSafeModule.
-  const Module *getModule() const { return M.get(); }
-
-  /// Take out a lock on the ThreadSafeContext for this module.
-  ThreadSafeContext::Lock getContextLock() { return TSCtx.getLock(); }
-
   /// Boolean conversion: This ThreadSafeModule will evaluate to true if it
   /// wraps a non-null module.
-  explicit operator bool() {
+  explicit operator bool() const {
     if (M) {
       assert(TSCtx.getContext() &&
              "Non-null module must have non-null context");
@@ -142,6 +128,30 @@
     return false;
   }
 
+  /// Locks the associated ThreadSafeContext and calls the given function
+  /// on the contained Module.
+  template <typename Func> decltype(auto) withModuleDo(Func &&F) {
+    assert(M && "Can not call on null module");
+    auto Lock = TSCtx.getLock();
+    return F(*M);
+  }
+
+  /// Locks the associated ThreadSafeContext and calls the given function
+  /// on the contained Module.
+  template <typename Func> decltype(auto) withModuleDo(Func &&F) const {
+    auto Lock = TSCtx.getLock();
+    return F(*M);
+  }
+
+  /// Get a raw pointer to the contained module without locking the context.
+  Module *getModuleUnlocked() { return M.get(); }
+
+  /// Get a raw pointer to the contained module without locking the context.
+  const Module *getModuleUnlocked() const { return M.get(); }
+
+  /// Returns the context for this ThreadSafeModule.
+  ThreadSafeContext getContext() const { return TSCtx; }
+
 private:
   std::unique_ptr<Module> M;
   ThreadSafeContext TSCtx;
@@ -152,7 +162,7 @@
 
 /// Clones the given module on to a new context.
 ThreadSafeModule
-cloneToNewContext(ThreadSafeModule &TSMW,
+cloneToNewContext(const ThreadSafeModule &TSMW,
                   GVPredicate ShouldCloneDef = GVPredicate(),
                   GVModifier UpdateClonedDefSource = GVModifier());
 
diff --git a/linux-x64/clang/include/llvm/ExecutionEngine/OrcV1Deprecation.h b/linux-x64/clang/include/llvm/ExecutionEngine/OrcV1Deprecation.h
new file mode 100644
index 0000000..7ed254b
--- /dev/null
+++ b/linux-x64/clang/include/llvm/ExecutionEngine/OrcV1Deprecation.h
@@ -0,0 +1,22 @@
+//===------ OrcV1Deprecation.h - Memory manager for MC-JIT ------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Tag for suppressing ORCv1 deprecation warnings.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_EXECUTIONENGINE_ORCV1DEPRECATION_H
+#define LLVM_EXECUTIONENGINE_ORCV1DEPRECATION_H
+
+namespace llvm {
+
+enum ORCv1DeprecationAcknowledgement { AcknowledgeORCv1Deprecation };
+
+} // namespace llvm
+
+#endif // LLVM_EXECUTIONENGINE_ORCV1DEPRECATION_H
diff --git a/linux-x64/clang/include/llvm/ExecutionEngine/RuntimeDyld.h b/linux-x64/clang/include/llvm/ExecutionEngine/RuntimeDyld.h
index b2b4eba..9b83092 100644
--- a/linux-x64/clang/include/llvm/ExecutionEngine/RuntimeDyld.h
+++ b/linux-x64/clang/include/llvm/ExecutionEngine/RuntimeDyld.h
@@ -13,6 +13,7 @@
 #ifndef LLVM_EXECUTIONENGINE_RUNTIMEDYLD_H
 #define LLVM_EXECUTIONENGINE_RUNTIMEDYLD_H
 
+#include "llvm/ADT/FunctionExtras.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/DebugInfo/DIContext.h"
@@ -266,15 +267,16 @@
   void finalizeWithMemoryManagerLocking();
 
 private:
-  friend void
-  jitLinkForORC(object::ObjectFile &Obj,
-                std::unique_ptr<MemoryBuffer> UnderlyingBuffer,
-                RuntimeDyld::MemoryManager &MemMgr, JITSymbolResolver &Resolver,
-                bool ProcessAllSections,
-                std::function<Error(std::unique_ptr<LoadedObjectInfo>,
-                                    std::map<StringRef, JITEvaluatedSymbol>)>
-                    OnLoaded,
-                std::function<void(Error)> OnEmitted);
+  friend void jitLinkForORC(
+      object::OwningBinary<object::ObjectFile> O,
+      RuntimeDyld::MemoryManager &MemMgr, JITSymbolResolver &Resolver,
+      bool ProcessAllSections,
+      unique_function<Error(const object::ObjectFile &Obj, LoadedObjectInfo &,
+                            std::map<StringRef, JITEvaluatedSymbol>)>
+          OnLoaded,
+      unique_function<void(object::OwningBinary<object::ObjectFile> O,
+                           std::unique_ptr<LoadedObjectInfo>, Error)>
+          OnEmitted);
 
   // RuntimeDyldImpl is the actual class. RuntimeDyld is just the public
   // interface.
@@ -291,14 +293,17 @@
 // but ORC's RTDyldObjectLinkingLayer2. Internally it constructs a RuntimeDyld
 // instance and uses continuation passing to perform the fix-up and finalize
 // steps asynchronously.
-void jitLinkForORC(object::ObjectFile &Obj,
-                   std::unique_ptr<MemoryBuffer> UnderlyingBuffer,
-                   RuntimeDyld::MemoryManager &MemMgr,
-                   JITSymbolResolver &Resolver, bool ProcessAllSections,
-                   std::function<Error(std::unique_ptr<LoadedObjectInfo>,
-                                       std::map<StringRef, JITEvaluatedSymbol>)>
-                       OnLoaded,
-                   std::function<void(Error)> OnEmitted);
+void jitLinkForORC(
+    object::OwningBinary<object::ObjectFile> O,
+    RuntimeDyld::MemoryManager &MemMgr, JITSymbolResolver &Resolver,
+    bool ProcessAllSections,
+    unique_function<Error(const object::ObjectFile &Obj,
+                          RuntimeDyld::LoadedObjectInfo &,
+                          std::map<StringRef, JITEvaluatedSymbol>)>
+        OnLoaded,
+    unique_function<void(object::OwningBinary<object::ObjectFile>,
+                         std::unique_ptr<RuntimeDyld::LoadedObjectInfo>, Error)>
+        OnEmitted);
 
 } // end namespace llvm
 
diff --git a/linux-x64/clang/include/llvm/ExecutionEngine/SectionMemoryManager.h b/linux-x64/clang/include/llvm/ExecutionEngine/SectionMemoryManager.h
index d731642..49956fa 100644
--- a/linux-x64/clang/include/llvm/ExecutionEngine/SectionMemoryManager.h
+++ b/linux-x64/clang/include/llvm/ExecutionEngine/SectionMemoryManager.h
@@ -15,7 +15,6 @@
 #define LLVM_EXECUTIONENGINE_SECTIONMEMORYMANAGER_H
 
 #include "llvm/ADT/SmallVector.h"
-#include "llvm/ADT/StringRef.h"
 #include "llvm/ExecutionEngine/RTDyldMemoryManager.h"
 #include "llvm/Support/Memory.h"
 #include <cstdint>
diff --git a/linux-x64/clang/include/llvm/FileCheck/FileCheck.h b/linux-x64/clang/include/llvm/FileCheck/FileCheck.h
new file mode 100644
index 0000000..b44ab02
--- /dev/null
+++ b/linux-x64/clang/include/llvm/FileCheck/FileCheck.h
@@ -0,0 +1,216 @@
+//==-- llvm/FileCheck/FileCheck.h --------------------------------*- C++ -*-==//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+/// \file This file has some utilities to use FileCheck as an API
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_FILECHECK_FILECHECK_H
+#define LLVM_FILECHECK_FILECHECK_H
+
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/MemoryBuffer.h"
+#include "llvm/Support/Regex.h"
+#include "llvm/Support/SourceMgr.h"
+#include <bitset>
+#include <string>
+#include <vector>
+
+namespace llvm {
+
+/// Contains info about various FileCheck options.
+struct FileCheckRequest {
+  std::vector<StringRef> CheckPrefixes;
+  std::vector<StringRef> CommentPrefixes;
+  bool NoCanonicalizeWhiteSpace = false;
+  std::vector<StringRef> ImplicitCheckNot;
+  std::vector<StringRef> GlobalDefines;
+  bool AllowEmptyInput = false;
+  bool AllowUnusedPrefixes = false;
+  bool MatchFullLines = false;
+  bool IgnoreCase = false;
+  bool IsDefaultCheckPrefix = false;
+  bool EnableVarScope = false;
+  bool AllowDeprecatedDagOverlap = false;
+  bool Verbose = false;
+  bool VerboseVerbose = false;
+};
+
+namespace Check {
+
+enum FileCheckKind {
+  CheckNone = 0,
+  CheckPlain,
+  CheckNext,
+  CheckSame,
+  CheckNot,
+  CheckDAG,
+  CheckLabel,
+  CheckEmpty,
+  CheckComment,
+
+  /// Indicates the pattern only matches the end of file. This is used for
+  /// trailing CHECK-NOTs.
+  CheckEOF,
+
+  /// Marks when parsing found a -NOT check combined with another CHECK suffix.
+  CheckBadNot,
+
+  /// Marks when parsing found a -COUNT directive with invalid count value.
+  CheckBadCount
+};
+
+enum FileCheckKindModifier {
+  /// Modifies directive to perform literal match.
+  ModifierLiteral = 0,
+
+  // The number of modifier.
+  Size
+};
+
+class FileCheckType {
+  FileCheckKind Kind;
+  int Count; ///< optional Count for some checks
+  /// Modifers for the check directive.
+  std::bitset<FileCheckKindModifier::Size> Modifiers;
+
+public:
+  FileCheckType(FileCheckKind Kind = CheckNone)
+      : Kind(Kind), Count(1), Modifiers() {}
+  FileCheckType(const FileCheckType &) = default;
+  FileCheckType &operator=(const FileCheckType &) = default;
+
+  operator FileCheckKind() const { return Kind; }
+
+  int getCount() const { return Count; }
+  FileCheckType &setCount(int C);
+
+  bool isLiteralMatch() const {
+    return Modifiers[FileCheckKindModifier::ModifierLiteral];
+  }
+  FileCheckType &setLiteralMatch(bool Literal = true) {
+    Modifiers.set(FileCheckKindModifier::ModifierLiteral, Literal);
+    return *this;
+  }
+
+  // \returns a description of \p Prefix.
+  std::string getDescription(StringRef Prefix) const;
+
+  // \returns a description of \p Modifiers.
+  std::string getModifiersDescription() const;
+};
+} // namespace Check
+
+/// Summary of a FileCheck diagnostic.
+struct FileCheckDiag {
+  /// What is the FileCheck directive for this diagnostic?
+  Check::FileCheckType CheckTy;
+  /// Where is the FileCheck directive for this diagnostic?
+  SMLoc CheckLoc;
+  /// What type of match result does this diagnostic describe?
+  ///
+  /// A directive's supplied pattern is said to be either expected or excluded
+  /// depending on whether the pattern must have or must not have a match in
+  /// order for the directive to succeed.  For example, a CHECK directive's
+  /// pattern is expected, and a CHECK-NOT directive's pattern is excluded.
+  /// All match result types whose names end with "Excluded" are for excluded
+  /// patterns, and all others are for expected patterns.
+  ///
+  /// There might be more than one match result for a single pattern.  For
+  /// example, there might be several discarded matches
+  /// (MatchFoundButDiscarded) before either a good match
+  /// (MatchFoundAndExpected) or a failure to match (MatchNoneButExpected),
+  /// and there might be a fuzzy match (MatchFuzzy) after the latter.
+  enum MatchType {
+    /// Indicates a good match for an expected pattern.
+    MatchFoundAndExpected,
+    /// Indicates a match for an excluded pattern.
+    MatchFoundButExcluded,
+    /// Indicates a match for an expected pattern, but the match is on the
+    /// wrong line.
+    MatchFoundButWrongLine,
+    /// Indicates a discarded match for an expected pattern.
+    MatchFoundButDiscarded,
+    /// Indicates no match for an excluded pattern.
+    MatchNoneAndExcluded,
+    /// Indicates no match for an expected pattern, but this might follow good
+    /// matches when multiple matches are expected for the pattern, or it might
+    /// follow discarded matches for the pattern.
+    MatchNoneButExpected,
+    /// Indicates a fuzzy match that serves as a suggestion for the next
+    /// intended match for an expected pattern with too few or no good matches.
+    MatchFuzzy,
+  } MatchTy;
+  /// The search range if MatchTy is MatchNoneAndExcluded or
+  /// MatchNoneButExpected, or the match range otherwise.
+  unsigned InputStartLine;
+  unsigned InputStartCol;
+  unsigned InputEndLine;
+  unsigned InputEndCol;
+  /// A note to replace the one normally indicated by MatchTy, or the empty
+  /// string if none.
+  std::string Note;
+  FileCheckDiag(const SourceMgr &SM, const Check::FileCheckType &CheckTy,
+                SMLoc CheckLoc, MatchType MatchTy, SMRange InputRange,
+                StringRef Note = "");
+};
+
+class FileCheckPatternContext;
+struct FileCheckString;
+
+/// FileCheck class takes the request and exposes various methods that
+/// use information from the request.
+class FileCheck {
+  FileCheckRequest Req;
+  std::unique_ptr<FileCheckPatternContext> PatternContext;
+  // C++17 TODO: make this a plain std::vector.
+  std::unique_ptr<std::vector<FileCheckString>> CheckStrings;
+
+public:
+  explicit FileCheck(FileCheckRequest Req);
+  ~FileCheck();
+
+  // Combines the check prefixes into a single regex so that we can efficiently
+  // scan for any of the set.
+  //
+  // The semantics are that the longest-match wins which matches our regex
+  // library.
+  Regex buildCheckPrefixRegex();
+
+  /// Reads the check file from \p Buffer and records the expected strings it
+  /// contains. Errors are reported against \p SM.
+  ///
+  /// Only expected strings whose prefix is one of those listed in \p PrefixRE
+  /// are recorded. \returns true in case of an error, false otherwise.
+  ///
+  /// If \p ImpPatBufferIDRange, then the range (inclusive start, exclusive end)
+  /// of IDs for source buffers added to \p SM for implicit patterns are
+  /// recorded in it.  The range is empty if there are none.
+  bool
+  readCheckFile(SourceMgr &SM, StringRef Buffer, Regex &PrefixRE,
+                std::pair<unsigned, unsigned> *ImpPatBufferIDRange = nullptr);
+
+  bool ValidateCheckPrefixes();
+
+  /// Canonicalizes whitespaces in the file. Line endings are replaced with
+  /// UNIX-style '\n'.
+  StringRef CanonicalizeFile(MemoryBuffer &MB,
+                             SmallVectorImpl<char> &OutputBuffer);
+
+  /// Checks the input to FileCheck provided in the \p Buffer against the
+  /// expected strings read from the check file and record diagnostics emitted
+  /// in \p Diags. Errors are recorded against \p SM.
+  ///
+  /// \returns false if the input fails to satisfy the checks.
+  bool checkInput(SourceMgr &SM, StringRef Buffer,
+                  std::vector<FileCheckDiag> *Diags = nullptr);
+};
+
+} // namespace llvm
+
+#endif
diff --git a/linux-x64/clang/include/llvm/Frontend/Directive/DirectiveBase.td b/linux-x64/clang/include/llvm/Frontend/Directive/DirectiveBase.td
new file mode 100644
index 0000000..164559d
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Frontend/Directive/DirectiveBase.td
@@ -0,0 +1,152 @@
+//===-- DirectiveBase.td - Base directive definition file --*- tablegen -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This is the base definition file directives and clauses.
+//
+//===----------------------------------------------------------------------===//
+
+
+// General information about the directive language.
+class DirectiveLanguage {
+  // Name of the directive language such as omp or acc.
+  string name = ?;
+
+  // The C++ namespace that code of this directive language should be placed
+  // into. This namespace is nested in llvm namespace.
+  //
+  // By default, uses the name of the directive language as the only namespace.
+  // To avoid placing in any namespace, use "". To specify nested namespaces,
+  // use "::" as the delimiter, e.g., given "A::B", ops will be placed in
+  // `namespace A { namespace B { <directives-clauses> } }`.
+  string cppNamespace = name;
+
+  // Optional prefix used for the generation of the enumerator in the Directive
+  // enum.
+  string directivePrefix = "";
+
+  // Optional prefix used for the generation of the enumerator in the Clause
+  // enum.
+  string clausePrefix = "";
+
+  // Make the enum values available in the namespace. This allows us to
+  // write something like Enum_X if we have a `using namespace cppNamespace`.
+  bit makeEnumAvailableInNamespace = false;
+
+  // Generate include and macro to enable LLVM BitmaskEnum.
+  bit enableBitmaskEnumInNamespace = false;
+
+  // Header file included in the implementation code generated. Ususally the
+  // output file of the declaration code generation. Can be left blank.
+  string includeHeader = "";
+
+  // EnumSet class name used for clauses to generated the allowed clauses map.
+  string clauseEnumSetClass = "";
+
+  // Class holding the clauses in the flang parse-tree.
+  string flangClauseBaseClass = "";
+}
+
+// Information about values accepted by enum-like clauses
+class ClauseVal<string n, int v, bit uv> {
+  // Name of the clause value.
+  string name = n;
+
+  // Integer value of the clause.
+  int value = v;
+
+  // Can user specify this value?
+  bit isUserValue = uv;
+
+  // Set clause value used by default when unknown.
+  bit isDefault = false;
+}
+
+// Information about a specific clause.
+class Clause<string c> {
+  // Name of the clause.
+  string name = c;
+
+  // Define an alternative name return in get<LanguageName>ClauseName function.
+  string alternativeName = "";
+
+  // Optional class holding value of the clause in clang AST.
+  string clangClass = "";
+
+  // Optional class holding the clause in flang AST. If left blank, the class
+  // is assumed to be the name of the clause with capitalized word and
+  // underscores removed.
+  // ex: async -> Async
+  //     num_threads -> NumThreads
+  string flangClass = "";
+
+  // Optional class holding value of the clause in flang AST.
+  string flangClassValue = "";
+
+  // If set to true, value is optional. Not optional by default.
+  bit isValueOptional = false;
+
+  // Name of enum when there is a list of allowed clause values.
+  string enumClauseValue = "";
+
+  // List of allowed clause values
+  list<ClauseVal> allowedClauseValues = [];
+  // If set to true, value class is part of a list. Single class by default.
+  bit isValueList = false;
+
+  // Define a default value such as "*".
+  string defaultValue = "";
+
+  // Is clause implicit? If clause is set as implicit, the default kind will
+  // be return in get<LanguageName>ClauseKind instead of their own kind.
+  bit isImplicit = false;
+
+  // Set clause used by default when unknown. Function returning the kind
+  // of enumeration will use this clause as the default.
+  bit isDefault = false;
+}
+
+// Hold information about clause validity by version.
+class VersionedClause<Clause c, int min = 1, int max = 0x7FFFFFFF> {
+  // Actual clause.
+  Clause clause = c;
+
+  // Mininum version number where this clause is valid.
+  int minVersion = min;
+
+  // Maximum version number where this clause is valid.
+  int maxVersion = max;
+}
+
+// Information about a specific directive.
+class Directive<string d> {
+  // Name of the directive. Can be composite directive sepearted by whitespace.
+  string name = d;
+
+  // Define an alternative name return in get<LanguageName>DirectiveName
+  // function.
+  string alternativeName = "";
+
+  // Clauses cannot appear twice in the three allowed lists below. Also, since
+  // required implies allowed, the same clause cannot appear in both the
+  // allowedClauses and requiredClauses lists.
+
+  // List of allowed clauses for the directive.
+  list<VersionedClause> allowedClauses = [];
+
+  // List of clauses that are allowed to appear only once.
+  list<VersionedClause> allowedOnceClauses = [];
+
+  // List of clauses that are allowed but mutually exclusive.
+  list<VersionedClause> allowedExclusiveClauses = [];
+
+  // List of clauses that are required.
+  list<VersionedClause> requiredClauses = [];
+
+  // Set directive used by default when unknown.
+  bit isDefault = false;
+}
diff --git a/linux-x64/clang/include/llvm/Frontend/OpenACC/ACC.h.inc b/linux-x64/clang/include/llvm/Frontend/OpenACC/ACC.h.inc
new file mode 100644
index 0000000..badccfb
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Frontend/OpenACC/ACC.h.inc
@@ -0,0 +1,181 @@
+#ifndef LLVM_OpenACC_INC
+#define LLVM_OpenACC_INC
+
+#include "llvm/ADT/BitmaskEnum.h"
+
+namespace llvm {
+class StringRef;
+namespace acc {
+
+LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE();
+
+enum class Directive {
+  ACCD_atomic,
+  ACCD_cache,
+  ACCD_data,
+  ACCD_declare,
+  ACCD_enter_data,
+  ACCD_exit_data,
+  ACCD_host_data,
+  ACCD_init,
+  ACCD_kernels,
+  ACCD_kernels_loop,
+  ACCD_loop,
+  ACCD_parallel,
+  ACCD_parallel_loop,
+  ACCD_routine,
+  ACCD_serial,
+  ACCD_serial_loop,
+  ACCD_set,
+  ACCD_shutdown,
+  ACCD_unknown,
+  ACCD_update,
+  ACCD_wait,
+};
+
+static constexpr std::size_t Directive_enumSize = 21;
+
+constexpr auto ACCD_atomic = llvm::acc::Directive::ACCD_atomic;
+constexpr auto ACCD_cache = llvm::acc::Directive::ACCD_cache;
+constexpr auto ACCD_data = llvm::acc::Directive::ACCD_data;
+constexpr auto ACCD_declare = llvm::acc::Directive::ACCD_declare;
+constexpr auto ACCD_enter_data = llvm::acc::Directive::ACCD_enter_data;
+constexpr auto ACCD_exit_data = llvm::acc::Directive::ACCD_exit_data;
+constexpr auto ACCD_host_data = llvm::acc::Directive::ACCD_host_data;
+constexpr auto ACCD_init = llvm::acc::Directive::ACCD_init;
+constexpr auto ACCD_kernels = llvm::acc::Directive::ACCD_kernels;
+constexpr auto ACCD_kernels_loop = llvm::acc::Directive::ACCD_kernels_loop;
+constexpr auto ACCD_loop = llvm::acc::Directive::ACCD_loop;
+constexpr auto ACCD_parallel = llvm::acc::Directive::ACCD_parallel;
+constexpr auto ACCD_parallel_loop = llvm::acc::Directive::ACCD_parallel_loop;
+constexpr auto ACCD_routine = llvm::acc::Directive::ACCD_routine;
+constexpr auto ACCD_serial = llvm::acc::Directive::ACCD_serial;
+constexpr auto ACCD_serial_loop = llvm::acc::Directive::ACCD_serial_loop;
+constexpr auto ACCD_set = llvm::acc::Directive::ACCD_set;
+constexpr auto ACCD_shutdown = llvm::acc::Directive::ACCD_shutdown;
+constexpr auto ACCD_unknown = llvm::acc::Directive::ACCD_unknown;
+constexpr auto ACCD_update = llvm::acc::Directive::ACCD_update;
+constexpr auto ACCD_wait = llvm::acc::Directive::ACCD_wait;
+
+enum class Clause {
+  ACCC_async,
+  ACCC_attach,
+  ACCC_auto,
+  ACCC_bind,
+  ACCC_capture,
+  ACCC_collapse,
+  ACCC_copy,
+  ACCC_copyin,
+  ACCC_copyout,
+  ACCC_create,
+  ACCC_default,
+  ACCC_default_async,
+  ACCC_delete,
+  ACCC_detach,
+  ACCC_device,
+  ACCC_device_num,
+  ACCC_deviceptr,
+  ACCC_device_resident,
+  ACCC_device_type,
+  ACCC_finalize,
+  ACCC_firstprivate,
+  ACCC_gang,
+  ACCC_host,
+  ACCC_if,
+  ACCC_if_present,
+  ACCC_independent,
+  ACCC_link,
+  ACCC_no_create,
+  ACCC_nohost,
+  ACCC_num_gangs,
+  ACCC_num_workers,
+  ACCC_present,
+  ACCC_private,
+  ACCC_read,
+  ACCC_reduction,
+  ACCC_self,
+  ACCC_seq,
+  ACCC_tile,
+  ACCC_unknown,
+  ACCC_use_device,
+  ACCC_vector,
+  ACCC_vector_length,
+  ACCC_wait,
+  ACCC_worker,
+  ACCC_write,
+};
+
+static constexpr std::size_t Clause_enumSize = 45;
+
+constexpr auto ACCC_async = llvm::acc::Clause::ACCC_async;
+constexpr auto ACCC_attach = llvm::acc::Clause::ACCC_attach;
+constexpr auto ACCC_auto = llvm::acc::Clause::ACCC_auto;
+constexpr auto ACCC_bind = llvm::acc::Clause::ACCC_bind;
+constexpr auto ACCC_capture = llvm::acc::Clause::ACCC_capture;
+constexpr auto ACCC_collapse = llvm::acc::Clause::ACCC_collapse;
+constexpr auto ACCC_copy = llvm::acc::Clause::ACCC_copy;
+constexpr auto ACCC_copyin = llvm::acc::Clause::ACCC_copyin;
+constexpr auto ACCC_copyout = llvm::acc::Clause::ACCC_copyout;
+constexpr auto ACCC_create = llvm::acc::Clause::ACCC_create;
+constexpr auto ACCC_default = llvm::acc::Clause::ACCC_default;
+constexpr auto ACCC_default_async = llvm::acc::Clause::ACCC_default_async;
+constexpr auto ACCC_delete = llvm::acc::Clause::ACCC_delete;
+constexpr auto ACCC_detach = llvm::acc::Clause::ACCC_detach;
+constexpr auto ACCC_device = llvm::acc::Clause::ACCC_device;
+constexpr auto ACCC_device_num = llvm::acc::Clause::ACCC_device_num;
+constexpr auto ACCC_deviceptr = llvm::acc::Clause::ACCC_deviceptr;
+constexpr auto ACCC_device_resident = llvm::acc::Clause::ACCC_device_resident;
+constexpr auto ACCC_device_type = llvm::acc::Clause::ACCC_device_type;
+constexpr auto ACCC_finalize = llvm::acc::Clause::ACCC_finalize;
+constexpr auto ACCC_firstprivate = llvm::acc::Clause::ACCC_firstprivate;
+constexpr auto ACCC_gang = llvm::acc::Clause::ACCC_gang;
+constexpr auto ACCC_host = llvm::acc::Clause::ACCC_host;
+constexpr auto ACCC_if = llvm::acc::Clause::ACCC_if;
+constexpr auto ACCC_if_present = llvm::acc::Clause::ACCC_if_present;
+constexpr auto ACCC_independent = llvm::acc::Clause::ACCC_independent;
+constexpr auto ACCC_link = llvm::acc::Clause::ACCC_link;
+constexpr auto ACCC_no_create = llvm::acc::Clause::ACCC_no_create;
+constexpr auto ACCC_nohost = llvm::acc::Clause::ACCC_nohost;
+constexpr auto ACCC_num_gangs = llvm::acc::Clause::ACCC_num_gangs;
+constexpr auto ACCC_num_workers = llvm::acc::Clause::ACCC_num_workers;
+constexpr auto ACCC_present = llvm::acc::Clause::ACCC_present;
+constexpr auto ACCC_private = llvm::acc::Clause::ACCC_private;
+constexpr auto ACCC_read = llvm::acc::Clause::ACCC_read;
+constexpr auto ACCC_reduction = llvm::acc::Clause::ACCC_reduction;
+constexpr auto ACCC_self = llvm::acc::Clause::ACCC_self;
+constexpr auto ACCC_seq = llvm::acc::Clause::ACCC_seq;
+constexpr auto ACCC_tile = llvm::acc::Clause::ACCC_tile;
+constexpr auto ACCC_unknown = llvm::acc::Clause::ACCC_unknown;
+constexpr auto ACCC_use_device = llvm::acc::Clause::ACCC_use_device;
+constexpr auto ACCC_vector = llvm::acc::Clause::ACCC_vector;
+constexpr auto ACCC_vector_length = llvm::acc::Clause::ACCC_vector_length;
+constexpr auto ACCC_wait = llvm::acc::Clause::ACCC_wait;
+constexpr auto ACCC_worker = llvm::acc::Clause::ACCC_worker;
+constexpr auto ACCC_write = llvm::acc::Clause::ACCC_write;
+
+enum class DefaultValue {
+  ACC_Default_present=0,
+  ACC_Default_none=1,
+};
+
+constexpr auto ACC_Default_present = llvm::acc::DefaultValue::ACC_Default_present;
+constexpr auto ACC_Default_none = llvm::acc::DefaultValue::ACC_Default_none;
+
+// Enumeration helper functions
+Directive getOpenACCDirectiveKind(llvm::StringRef Str);
+
+llvm::StringRef getOpenACCDirectiveName(Directive D);
+
+Clause getOpenACCClauseKind(llvm::StringRef Str);
+
+llvm::StringRef getOpenACCClauseName(Clause C);
+
+/// Return true if \p C is a valid clause for \p D in version \p Version.
+bool isAllowedClauseForDirective(Directive D, Clause C, unsigned Version);
+
+DefaultValue getDefaultValue(StringRef);
+llvm::StringRef getOpenACCDefaultValueName(DefaultValue);
+
+} // namespace acc
+} // namespace llvm
+#endif // LLVM_OpenACC_INC
diff --git a/linux-x64/clang/include/llvm/Frontend/OpenACC/ACC.inc b/linux-x64/clang/include/llvm/Frontend/OpenACC/ACC.inc
new file mode 100644
index 0000000..e897fa9
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Frontend/OpenACC/ACC.inc
@@ -0,0 +1,1143 @@
+#ifdef GEN_FLANG_DIRECTIVE_CLAUSE_SETS
+#undef GEN_FLANG_DIRECTIVE_CLAUSE_SETS
+
+namespace llvm {
+namespace acc {
+
+  // Sets for atomic
+
+  static AccClauseSet allowedClauses_ACCD_atomic {
+  };
+
+  static AccClauseSet allowedOnceClauses_ACCD_atomic {
+  };
+
+  static AccClauseSet allowedExclusiveClauses_ACCD_atomic {
+  };
+
+  static AccClauseSet requiredClauses_ACCD_atomic {
+  };
+
+  // Sets for cache
+
+  static AccClauseSet allowedClauses_ACCD_cache {
+  };
+
+  static AccClauseSet allowedOnceClauses_ACCD_cache {
+  };
+
+  static AccClauseSet allowedExclusiveClauses_ACCD_cache {
+  };
+
+  static AccClauseSet requiredClauses_ACCD_cache {
+  };
+
+  // Sets for data
+
+  static AccClauseSet allowedClauses_ACCD_data {
+  };
+
+  static AccClauseSet allowedOnceClauses_ACCD_data {
+    llvm::acc::Clause::ACCC_if,
+    llvm::acc::Clause::ACCC_default,
+  };
+
+  static AccClauseSet allowedExclusiveClauses_ACCD_data {
+  };
+
+  static AccClauseSet requiredClauses_ACCD_data {
+    llvm::acc::Clause::ACCC_attach,
+    llvm::acc::Clause::ACCC_copy,
+    llvm::acc::Clause::ACCC_copyin,
+    llvm::acc::Clause::ACCC_copyout,
+    llvm::acc::Clause::ACCC_create,
+    llvm::acc::Clause::ACCC_default,
+    llvm::acc::Clause::ACCC_deviceptr,
+    llvm::acc::Clause::ACCC_no_create,
+    llvm::acc::Clause::ACCC_present,
+  };
+
+  // Sets for declare
+
+  static AccClauseSet allowedClauses_ACCD_declare {
+    llvm::acc::Clause::ACCC_copy,
+    llvm::acc::Clause::ACCC_copyin,
+    llvm::acc::Clause::ACCC_copyout,
+    llvm::acc::Clause::ACCC_create,
+    llvm::acc::Clause::ACCC_present,
+    llvm::acc::Clause::ACCC_deviceptr,
+    llvm::acc::Clause::ACCC_device_resident,
+    llvm::acc::Clause::ACCC_link,
+  };
+
+  static AccClauseSet allowedOnceClauses_ACCD_declare {
+  };
+
+  static AccClauseSet allowedExclusiveClauses_ACCD_declare {
+  };
+
+  static AccClauseSet requiredClauses_ACCD_declare {
+  };
+
+  // Sets for enter data
+
+  static AccClauseSet allowedClauses_ACCD_enter_data {
+  };
+
+  static AccClauseSet allowedOnceClauses_ACCD_enter_data {
+    llvm::acc::Clause::ACCC_async,
+    llvm::acc::Clause::ACCC_if,
+    llvm::acc::Clause::ACCC_wait,
+  };
+
+  static AccClauseSet allowedExclusiveClauses_ACCD_enter_data {
+  };
+
+  static AccClauseSet requiredClauses_ACCD_enter_data {
+    llvm::acc::Clause::ACCC_attach,
+    llvm::acc::Clause::ACCC_create,
+    llvm::acc::Clause::ACCC_copyin,
+  };
+
+  // Sets for exit data
+
+  static AccClauseSet allowedClauses_ACCD_exit_data {
+    llvm::acc::Clause::ACCC_async,
+    llvm::acc::Clause::ACCC_if,
+    llvm::acc::Clause::ACCC_wait,
+    llvm::acc::Clause::ACCC_finalize,
+  };
+
+  static AccClauseSet allowedOnceClauses_ACCD_exit_data {
+  };
+
+  static AccClauseSet allowedExclusiveClauses_ACCD_exit_data {
+  };
+
+  static AccClauseSet requiredClauses_ACCD_exit_data {
+    llvm::acc::Clause::ACCC_copyout,
+    llvm::acc::Clause::ACCC_delete,
+    llvm::acc::Clause::ACCC_detach,
+  };
+
+  // Sets for host_data
+
+  static AccClauseSet allowedClauses_ACCD_host_data {
+    llvm::acc::Clause::ACCC_if,
+    llvm::acc::Clause::ACCC_if_present,
+  };
+
+  static AccClauseSet allowedOnceClauses_ACCD_host_data {
+  };
+
+  static AccClauseSet allowedExclusiveClauses_ACCD_host_data {
+  };
+
+  static AccClauseSet requiredClauses_ACCD_host_data {
+    llvm::acc::Clause::ACCC_use_device,
+  };
+
+  // Sets for init
+
+  static AccClauseSet allowedClauses_ACCD_init {
+  };
+
+  static AccClauseSet allowedOnceClauses_ACCD_init {
+    llvm::acc::Clause::ACCC_device_num,
+    llvm::acc::Clause::ACCC_device_type,
+    llvm::acc::Clause::ACCC_if,
+  };
+
+  static AccClauseSet allowedExclusiveClauses_ACCD_init {
+  };
+
+  static AccClauseSet requiredClauses_ACCD_init {
+  };
+
+  // Sets for kernels
+
+  static AccClauseSet allowedClauses_ACCD_kernels {
+    llvm::acc::Clause::ACCC_attach,
+    llvm::acc::Clause::ACCC_copy,
+    llvm::acc::Clause::ACCC_copyin,
+    llvm::acc::Clause::ACCC_copyout,
+    llvm::acc::Clause::ACCC_create,
+    llvm::acc::Clause::ACCC_device_type,
+    llvm::acc::Clause::ACCC_no_create,
+    llvm::acc::Clause::ACCC_present,
+    llvm::acc::Clause::ACCC_deviceptr,
+    llvm::acc::Clause::ACCC_wait,
+  };
+
+  static AccClauseSet allowedOnceClauses_ACCD_kernels {
+    llvm::acc::Clause::ACCC_async,
+    llvm::acc::Clause::ACCC_default,
+    llvm::acc::Clause::ACCC_if,
+    llvm::acc::Clause::ACCC_num_gangs,
+    llvm::acc::Clause::ACCC_num_workers,
+    llvm::acc::Clause::ACCC_self,
+    llvm::acc::Clause::ACCC_vector_length,
+  };
+
+  static AccClauseSet allowedExclusiveClauses_ACCD_kernels {
+  };
+
+  static AccClauseSet requiredClauses_ACCD_kernels {
+  };
+
+  // Sets for kernels loop
+
+  static AccClauseSet allowedClauses_ACCD_kernels_loop {
+    llvm::acc::Clause::ACCC_copy,
+    llvm::acc::Clause::ACCC_copyin,
+    llvm::acc::Clause::ACCC_copyout,
+    llvm::acc::Clause::ACCC_create,
+    llvm::acc::Clause::ACCC_device_type,
+    llvm::acc::Clause::ACCC_no_create,
+    llvm::acc::Clause::ACCC_present,
+    llvm::acc::Clause::ACCC_private,
+    llvm::acc::Clause::ACCC_deviceptr,
+    llvm::acc::Clause::ACCC_attach,
+  };
+
+  static AccClauseSet allowedOnceClauses_ACCD_kernels_loop {
+    llvm::acc::Clause::ACCC_async,
+    llvm::acc::Clause::ACCC_collapse,
+    llvm::acc::Clause::ACCC_default,
+    llvm::acc::Clause::ACCC_gang,
+    llvm::acc::Clause::ACCC_if,
+    llvm::acc::Clause::ACCC_num_gangs,
+    llvm::acc::Clause::ACCC_num_workers,
+    llvm::acc::Clause::ACCC_reduction,
+    llvm::acc::Clause::ACCC_self,
+    llvm::acc::Clause::ACCC_tile,
+    llvm::acc::Clause::ACCC_vector,
+    llvm::acc::Clause::ACCC_vector_length,
+    llvm::acc::Clause::ACCC_wait,
+    llvm::acc::Clause::ACCC_worker,
+  };
+
+  static AccClauseSet allowedExclusiveClauses_ACCD_kernels_loop {
+    llvm::acc::Clause::ACCC_auto,
+    llvm::acc::Clause::ACCC_independent,
+    llvm::acc::Clause::ACCC_seq,
+  };
+
+  static AccClauseSet requiredClauses_ACCD_kernels_loop {
+  };
+
+  // Sets for loop
+
+  static AccClauseSet allowedClauses_ACCD_loop {
+    llvm::acc::Clause::ACCC_device_type,
+    llvm::acc::Clause::ACCC_private,
+  };
+
+  static AccClauseSet allowedOnceClauses_ACCD_loop {
+    llvm::acc::Clause::ACCC_collapse,
+    llvm::acc::Clause::ACCC_gang,
+    llvm::acc::Clause::ACCC_reduction,
+    llvm::acc::Clause::ACCC_tile,
+    llvm::acc::Clause::ACCC_vector,
+    llvm::acc::Clause::ACCC_worker,
+  };
+
+  static AccClauseSet allowedExclusiveClauses_ACCD_loop {
+    llvm::acc::Clause::ACCC_auto,
+    llvm::acc::Clause::ACCC_independent,
+    llvm::acc::Clause::ACCC_seq,
+  };
+
+  static AccClauseSet requiredClauses_ACCD_loop {
+  };
+
+  // Sets for parallel
+
+  static AccClauseSet allowedClauses_ACCD_parallel {
+    llvm::acc::Clause::ACCC_attach,
+    llvm::acc::Clause::ACCC_copy,
+    llvm::acc::Clause::ACCC_copyin,
+    llvm::acc::Clause::ACCC_copyout,
+    llvm::acc::Clause::ACCC_create,
+    llvm::acc::Clause::ACCC_deviceptr,
+    llvm::acc::Clause::ACCC_device_type,
+    llvm::acc::Clause::ACCC_no_create,
+    llvm::acc::Clause::ACCC_present,
+    llvm::acc::Clause::ACCC_private,
+    llvm::acc::Clause::ACCC_firstprivate,
+    llvm::acc::Clause::ACCC_wait,
+  };
+
+  static AccClauseSet allowedOnceClauses_ACCD_parallel {
+    llvm::acc::Clause::ACCC_async,
+    llvm::acc::Clause::ACCC_default,
+    llvm::acc::Clause::ACCC_if,
+    llvm::acc::Clause::ACCC_num_gangs,
+    llvm::acc::Clause::ACCC_num_workers,
+    llvm::acc::Clause::ACCC_reduction,
+    llvm::acc::Clause::ACCC_self,
+    llvm::acc::Clause::ACCC_vector_length,
+  };
+
+  static AccClauseSet allowedExclusiveClauses_ACCD_parallel {
+  };
+
+  static AccClauseSet requiredClauses_ACCD_parallel {
+  };
+
+  // Sets for parallel loop
+
+  static AccClauseSet allowedClauses_ACCD_parallel_loop {
+    llvm::acc::Clause::ACCC_attach,
+    llvm::acc::Clause::ACCC_copy,
+    llvm::acc::Clause::ACCC_copyin,
+    llvm::acc::Clause::ACCC_copyout,
+    llvm::acc::Clause::ACCC_create,
+    llvm::acc::Clause::ACCC_deviceptr,
+    llvm::acc::Clause::ACCC_device_type,
+    llvm::acc::Clause::ACCC_firstprivate,
+    llvm::acc::Clause::ACCC_no_create,
+    llvm::acc::Clause::ACCC_present,
+    llvm::acc::Clause::ACCC_private,
+    llvm::acc::Clause::ACCC_tile,
+    llvm::acc::Clause::ACCC_wait,
+  };
+
+  static AccClauseSet allowedOnceClauses_ACCD_parallel_loop {
+    llvm::acc::Clause::ACCC_async,
+    llvm::acc::Clause::ACCC_collapse,
+    llvm::acc::Clause::ACCC_default,
+    llvm::acc::Clause::ACCC_gang,
+    llvm::acc::Clause::ACCC_if,
+    llvm::acc::Clause::ACCC_num_gangs,
+    llvm::acc::Clause::ACCC_num_workers,
+    llvm::acc::Clause::ACCC_reduction,
+    llvm::acc::Clause::ACCC_self,
+    llvm::acc::Clause::ACCC_vector,
+    llvm::acc::Clause::ACCC_vector_length,
+    llvm::acc::Clause::ACCC_worker,
+  };
+
+  static AccClauseSet allowedExclusiveClauses_ACCD_parallel_loop {
+    llvm::acc::Clause::ACCC_auto,
+    llvm::acc::Clause::ACCC_independent,
+    llvm::acc::Clause::ACCC_seq,
+  };
+
+  static AccClauseSet requiredClauses_ACCD_parallel_loop {
+  };
+
+  // Sets for routine
+
+  static AccClauseSet allowedClauses_ACCD_routine {
+  };
+
+  static AccClauseSet allowedOnceClauses_ACCD_routine {
+    llvm::acc::Clause::ACCC_bind,
+    llvm::acc::Clause::ACCC_device_type,
+    llvm::acc::Clause::ACCC_nohost,
+  };
+
+  static AccClauseSet allowedExclusiveClauses_ACCD_routine {
+  };
+
+  static AccClauseSet requiredClauses_ACCD_routine {
+    llvm::acc::Clause::ACCC_gang,
+    llvm::acc::Clause::ACCC_seq,
+    llvm::acc::Clause::ACCC_vector,
+    llvm::acc::Clause::ACCC_worker,
+  };
+
+  // Sets for serial
+
+  static AccClauseSet allowedClauses_ACCD_serial {
+    llvm::acc::Clause::ACCC_attach,
+    llvm::acc::Clause::ACCC_copy,
+    llvm::acc::Clause::ACCC_copyin,
+    llvm::acc::Clause::ACCC_copyout,
+    llvm::acc::Clause::ACCC_create,
+    llvm::acc::Clause::ACCC_deviceptr,
+    llvm::acc::Clause::ACCC_device_type,
+    llvm::acc::Clause::ACCC_no_create,
+    llvm::acc::Clause::ACCC_present,
+    llvm::acc::Clause::ACCC_private,
+    llvm::acc::Clause::ACCC_firstprivate,
+    llvm::acc::Clause::ACCC_wait,
+  };
+
+  static AccClauseSet allowedOnceClauses_ACCD_serial {
+    llvm::acc::Clause::ACCC_async,
+    llvm::acc::Clause::ACCC_default,
+    llvm::acc::Clause::ACCC_if,
+    llvm::acc::Clause::ACCC_reduction,
+    llvm::acc::Clause::ACCC_self,
+  };
+
+  static AccClauseSet allowedExclusiveClauses_ACCD_serial {
+  };
+
+  static AccClauseSet requiredClauses_ACCD_serial {
+  };
+
+  // Sets for serial loop
+
+  static AccClauseSet allowedClauses_ACCD_serial_loop {
+    llvm::acc::Clause::ACCC_attach,
+    llvm::acc::Clause::ACCC_copy,
+    llvm::acc::Clause::ACCC_copyin,
+    llvm::acc::Clause::ACCC_copyout,
+    llvm::acc::Clause::ACCC_create,
+    llvm::acc::Clause::ACCC_deviceptr,
+    llvm::acc::Clause::ACCC_device_type,
+    llvm::acc::Clause::ACCC_firstprivate,
+    llvm::acc::Clause::ACCC_no_create,
+    llvm::acc::Clause::ACCC_present,
+    llvm::acc::Clause::ACCC_private,
+    llvm::acc::Clause::ACCC_wait,
+  };
+
+  static AccClauseSet allowedOnceClauses_ACCD_serial_loop {
+    llvm::acc::Clause::ACCC_async,
+    llvm::acc::Clause::ACCC_collapse,
+    llvm::acc::Clause::ACCC_default,
+    llvm::acc::Clause::ACCC_gang,
+    llvm::acc::Clause::ACCC_if,
+    llvm::acc::Clause::ACCC_reduction,
+    llvm::acc::Clause::ACCC_self,
+    llvm::acc::Clause::ACCC_tile,
+    llvm::acc::Clause::ACCC_vector,
+    llvm::acc::Clause::ACCC_worker,
+  };
+
+  static AccClauseSet allowedExclusiveClauses_ACCD_serial_loop {
+    llvm::acc::Clause::ACCC_auto,
+    llvm::acc::Clause::ACCC_independent,
+    llvm::acc::Clause::ACCC_seq,
+  };
+
+  static AccClauseSet requiredClauses_ACCD_serial_loop {
+  };
+
+  // Sets for set
+
+  static AccClauseSet allowedClauses_ACCD_set {
+  };
+
+  static AccClauseSet allowedOnceClauses_ACCD_set {
+    llvm::acc::Clause::ACCC_default_async,
+    llvm::acc::Clause::ACCC_device_num,
+    llvm::acc::Clause::ACCC_device_type,
+    llvm::acc::Clause::ACCC_if,
+  };
+
+  static AccClauseSet allowedExclusiveClauses_ACCD_set {
+  };
+
+  static AccClauseSet requiredClauses_ACCD_set {
+    llvm::acc::Clause::ACCC_default_async,
+    llvm::acc::Clause::ACCC_device_num,
+    llvm::acc::Clause::ACCC_device_type,
+  };
+
+  // Sets for shutdown
+
+  static AccClauseSet allowedClauses_ACCD_shutdown {
+  };
+
+  static AccClauseSet allowedOnceClauses_ACCD_shutdown {
+    llvm::acc::Clause::ACCC_device_num,
+    llvm::acc::Clause::ACCC_device_type,
+    llvm::acc::Clause::ACCC_if,
+  };
+
+  static AccClauseSet allowedExclusiveClauses_ACCD_shutdown {
+  };
+
+  static AccClauseSet requiredClauses_ACCD_shutdown {
+  };
+
+  // Sets for unknown
+
+  static AccClauseSet allowedClauses_ACCD_unknown {
+  };
+
+  static AccClauseSet allowedOnceClauses_ACCD_unknown {
+  };
+
+  static AccClauseSet allowedExclusiveClauses_ACCD_unknown {
+  };
+
+  static AccClauseSet requiredClauses_ACCD_unknown {
+  };
+
+  // Sets for update
+
+  static AccClauseSet allowedClauses_ACCD_update {
+    llvm::acc::Clause::ACCC_device_type,
+    llvm::acc::Clause::ACCC_wait,
+  };
+
+  static AccClauseSet allowedOnceClauses_ACCD_update {
+    llvm::acc::Clause::ACCC_async,
+    llvm::acc::Clause::ACCC_if,
+    llvm::acc::Clause::ACCC_if_present,
+  };
+
+  static AccClauseSet allowedExclusiveClauses_ACCD_update {
+  };
+
+  static AccClauseSet requiredClauses_ACCD_update {
+    llvm::acc::Clause::ACCC_device,
+    llvm::acc::Clause::ACCC_host,
+    llvm::acc::Clause::ACCC_self,
+  };
+
+  // Sets for wait
+
+  static AccClauseSet allowedClauses_ACCD_wait {
+  };
+
+  static AccClauseSet allowedOnceClauses_ACCD_wait {
+    llvm::acc::Clause::ACCC_async,
+    llvm::acc::Clause::ACCC_if,
+  };
+
+  static AccClauseSet allowedExclusiveClauses_ACCD_wait {
+  };
+
+  static AccClauseSet requiredClauses_ACCD_wait {
+  };
+} // namespace acc
+} // namespace llvm
+
+#endif // GEN_FLANG_DIRECTIVE_CLAUSE_SETS
+
+#ifdef GEN_FLANG_DIRECTIVE_CLAUSE_MAP
+#undef GEN_FLANG_DIRECTIVE_CLAUSE_MAP
+
+{
+  {llvm::acc::Directive::ACCD_atomic,
+    {
+      llvm::acc::allowedClauses_ACCD_atomic,
+      llvm::acc::allowedOnceClauses_ACCD_atomic,
+      llvm::acc::allowedExclusiveClauses_ACCD_atomic,
+      llvm::acc::requiredClauses_ACCD_atomic,
+    }
+  },
+  {llvm::acc::Directive::ACCD_cache,
+    {
+      llvm::acc::allowedClauses_ACCD_cache,
+      llvm::acc::allowedOnceClauses_ACCD_cache,
+      llvm::acc::allowedExclusiveClauses_ACCD_cache,
+      llvm::acc::requiredClauses_ACCD_cache,
+    }
+  },
+  {llvm::acc::Directive::ACCD_data,
+    {
+      llvm::acc::allowedClauses_ACCD_data,
+      llvm::acc::allowedOnceClauses_ACCD_data,
+      llvm::acc::allowedExclusiveClauses_ACCD_data,
+      llvm::acc::requiredClauses_ACCD_data,
+    }
+  },
+  {llvm::acc::Directive::ACCD_declare,
+    {
+      llvm::acc::allowedClauses_ACCD_declare,
+      llvm::acc::allowedOnceClauses_ACCD_declare,
+      llvm::acc::allowedExclusiveClauses_ACCD_declare,
+      llvm::acc::requiredClauses_ACCD_declare,
+    }
+  },
+  {llvm::acc::Directive::ACCD_enter_data,
+    {
+      llvm::acc::allowedClauses_ACCD_enter_data,
+      llvm::acc::allowedOnceClauses_ACCD_enter_data,
+      llvm::acc::allowedExclusiveClauses_ACCD_enter_data,
+      llvm::acc::requiredClauses_ACCD_enter_data,
+    }
+  },
+  {llvm::acc::Directive::ACCD_exit_data,
+    {
+      llvm::acc::allowedClauses_ACCD_exit_data,
+      llvm::acc::allowedOnceClauses_ACCD_exit_data,
+      llvm::acc::allowedExclusiveClauses_ACCD_exit_data,
+      llvm::acc::requiredClauses_ACCD_exit_data,
+    }
+  },
+  {llvm::acc::Directive::ACCD_host_data,
+    {
+      llvm::acc::allowedClauses_ACCD_host_data,
+      llvm::acc::allowedOnceClauses_ACCD_host_data,
+      llvm::acc::allowedExclusiveClauses_ACCD_host_data,
+      llvm::acc::requiredClauses_ACCD_host_data,
+    }
+  },
+  {llvm::acc::Directive::ACCD_init,
+    {
+      llvm::acc::allowedClauses_ACCD_init,
+      llvm::acc::allowedOnceClauses_ACCD_init,
+      llvm::acc::allowedExclusiveClauses_ACCD_init,
+      llvm::acc::requiredClauses_ACCD_init,
+    }
+  },
+  {llvm::acc::Directive::ACCD_kernels,
+    {
+      llvm::acc::allowedClauses_ACCD_kernels,
+      llvm::acc::allowedOnceClauses_ACCD_kernels,
+      llvm::acc::allowedExclusiveClauses_ACCD_kernels,
+      llvm::acc::requiredClauses_ACCD_kernels,
+    }
+  },
+  {llvm::acc::Directive::ACCD_kernels_loop,
+    {
+      llvm::acc::allowedClauses_ACCD_kernels_loop,
+      llvm::acc::allowedOnceClauses_ACCD_kernels_loop,
+      llvm::acc::allowedExclusiveClauses_ACCD_kernels_loop,
+      llvm::acc::requiredClauses_ACCD_kernels_loop,
+    }
+  },
+  {llvm::acc::Directive::ACCD_loop,
+    {
+      llvm::acc::allowedClauses_ACCD_loop,
+      llvm::acc::allowedOnceClauses_ACCD_loop,
+      llvm::acc::allowedExclusiveClauses_ACCD_loop,
+      llvm::acc::requiredClauses_ACCD_loop,
+    }
+  },
+  {llvm::acc::Directive::ACCD_parallel,
+    {
+      llvm::acc::allowedClauses_ACCD_parallel,
+      llvm::acc::allowedOnceClauses_ACCD_parallel,
+      llvm::acc::allowedExclusiveClauses_ACCD_parallel,
+      llvm::acc::requiredClauses_ACCD_parallel,
+    }
+  },
+  {llvm::acc::Directive::ACCD_parallel_loop,
+    {
+      llvm::acc::allowedClauses_ACCD_parallel_loop,
+      llvm::acc::allowedOnceClauses_ACCD_parallel_loop,
+      llvm::acc::allowedExclusiveClauses_ACCD_parallel_loop,
+      llvm::acc::requiredClauses_ACCD_parallel_loop,
+    }
+  },
+  {llvm::acc::Directive::ACCD_routine,
+    {
+      llvm::acc::allowedClauses_ACCD_routine,
+      llvm::acc::allowedOnceClauses_ACCD_routine,
+      llvm::acc::allowedExclusiveClauses_ACCD_routine,
+      llvm::acc::requiredClauses_ACCD_routine,
+    }
+  },
+  {llvm::acc::Directive::ACCD_serial,
+    {
+      llvm::acc::allowedClauses_ACCD_serial,
+      llvm::acc::allowedOnceClauses_ACCD_serial,
+      llvm::acc::allowedExclusiveClauses_ACCD_serial,
+      llvm::acc::requiredClauses_ACCD_serial,
+    }
+  },
+  {llvm::acc::Directive::ACCD_serial_loop,
+    {
+      llvm::acc::allowedClauses_ACCD_serial_loop,
+      llvm::acc::allowedOnceClauses_ACCD_serial_loop,
+      llvm::acc::allowedExclusiveClauses_ACCD_serial_loop,
+      llvm::acc::requiredClauses_ACCD_serial_loop,
+    }
+  },
+  {llvm::acc::Directive::ACCD_set,
+    {
+      llvm::acc::allowedClauses_ACCD_set,
+      llvm::acc::allowedOnceClauses_ACCD_set,
+      llvm::acc::allowedExclusiveClauses_ACCD_set,
+      llvm::acc::requiredClauses_ACCD_set,
+    }
+  },
+  {llvm::acc::Directive::ACCD_shutdown,
+    {
+      llvm::acc::allowedClauses_ACCD_shutdown,
+      llvm::acc::allowedOnceClauses_ACCD_shutdown,
+      llvm::acc::allowedExclusiveClauses_ACCD_shutdown,
+      llvm::acc::requiredClauses_ACCD_shutdown,
+    }
+  },
+  {llvm::acc::Directive::ACCD_unknown,
+    {
+      llvm::acc::allowedClauses_ACCD_unknown,
+      llvm::acc::allowedOnceClauses_ACCD_unknown,
+      llvm::acc::allowedExclusiveClauses_ACCD_unknown,
+      llvm::acc::requiredClauses_ACCD_unknown,
+    }
+  },
+  {llvm::acc::Directive::ACCD_update,
+    {
+      llvm::acc::allowedClauses_ACCD_update,
+      llvm::acc::allowedOnceClauses_ACCD_update,
+      llvm::acc::allowedExclusiveClauses_ACCD_update,
+      llvm::acc::requiredClauses_ACCD_update,
+    }
+  },
+  {llvm::acc::Directive::ACCD_wait,
+    {
+      llvm::acc::allowedClauses_ACCD_wait,
+      llvm::acc::allowedOnceClauses_ACCD_wait,
+      llvm::acc::allowedExclusiveClauses_ACCD_wait,
+      llvm::acc::requiredClauses_ACCD_wait,
+    }
+  },
+}
+
+#endif // GEN_FLANG_DIRECTIVE_CLAUSE_MAP
+
+#ifdef GEN_FLANG_CLAUSE_PARSER_CLASSES
+#undef GEN_FLANG_CLAUSE_PARSER_CLASSES
+
+WRAPPER_CLASS(Async, std::optional<ScalarIntExpr>);
+WRAPPER_CLASS(Attach, AccObjectList);
+EMPTY_CLASS(Auto);
+WRAPPER_CLASS(Bind, AccBindClause);
+EMPTY_CLASS(Capture);
+WRAPPER_CLASS(Collapse, ScalarIntConstantExpr);
+WRAPPER_CLASS(Copy, AccObjectList);
+WRAPPER_CLASS(Copyin, AccObjectListWithModifier);
+WRAPPER_CLASS(Copyout, AccObjectListWithModifier);
+WRAPPER_CLASS(Create, AccObjectListWithModifier);
+WRAPPER_CLASS(Default, AccDefaultClause);
+WRAPPER_CLASS(DefaultAsync, ScalarIntExpr);
+WRAPPER_CLASS(Delete, AccObjectList);
+WRAPPER_CLASS(Detach, AccObjectList);
+WRAPPER_CLASS(Device, AccObjectList);
+WRAPPER_CLASS(DeviceNum, ScalarIntExpr);
+WRAPPER_CLASS(Deviceptr, AccObjectList);
+WRAPPER_CLASS(DeviceResident, AccObjectList);
+WRAPPER_CLASS(DeviceType, std::optional<std::list<ScalarIntExpr>>);
+EMPTY_CLASS(Finalize);
+WRAPPER_CLASS(Firstprivate, AccObjectList);
+WRAPPER_CLASS(Gang, std::optional<AccGangArgument>);
+WRAPPER_CLASS(Host, AccObjectList);
+WRAPPER_CLASS(If, ScalarLogicalExpr);
+EMPTY_CLASS(IfPresent);
+EMPTY_CLASS(Independent);
+WRAPPER_CLASS(Link, AccObjectList);
+WRAPPER_CLASS(NoCreate, AccObjectList);
+EMPTY_CLASS(Nohost);
+WRAPPER_CLASS(NumGangs, ScalarIntExpr);
+WRAPPER_CLASS(NumWorkers, ScalarIntExpr);
+WRAPPER_CLASS(Present, AccObjectList);
+WRAPPER_CLASS(Private, AccObjectList);
+EMPTY_CLASS(Read);
+WRAPPER_CLASS(Reduction, AccObjectListWithReduction);
+WRAPPER_CLASS(Self, AccSelfClause);
+EMPTY_CLASS(Seq);
+WRAPPER_CLASS(Tile, AccTileExprList);
+EMPTY_CLASS(Unknown);
+WRAPPER_CLASS(UseDevice, AccObjectList);
+WRAPPER_CLASS(Vector, std::optional<ScalarIntExpr>);
+WRAPPER_CLASS(VectorLength, ScalarIntExpr);
+WRAPPER_CLASS(Wait, std::optional<AccWaitArgument>);
+WRAPPER_CLASS(Worker, std::optional<ScalarIntExpr>);
+EMPTY_CLASS(Write);
+
+#endif // GEN_FLANG_CLAUSE_PARSER_CLASSES
+
+#ifdef GEN_FLANG_CLAUSE_PARSER_CLASSES_LIST
+#undef GEN_FLANG_CLAUSE_PARSER_CLASSES_LIST
+
+Async
+, Attach
+, Auto
+, Bind
+, Capture
+, Collapse
+, Copy
+, Copyin
+, Copyout
+, Create
+, Default
+, DefaultAsync
+, Delete
+, Detach
+, Device
+, DeviceNum
+, Deviceptr
+, DeviceResident
+, DeviceType
+, Finalize
+, Firstprivate
+, Gang
+, Host
+, If
+, IfPresent
+, Independent
+, Link
+, NoCreate
+, Nohost
+, NumGangs
+, NumWorkers
+, Present
+, Private
+, Read
+, Reduction
+, Self
+, Seq
+, Tile
+, Unknown
+, UseDevice
+, Vector
+, VectorLength
+, Wait
+, Worker
+, Write
+
+#endif // GEN_FLANG_CLAUSE_PARSER_CLASSES_LIST
+
+#ifdef GEN_FLANG_DUMP_PARSE_TREE_CLAUSES
+#undef GEN_FLANG_DUMP_PARSE_TREE_CLAUSES
+
+NODE(AccClause, Async)
+NODE(AccClause, Attach)
+NODE(AccClause, Auto)
+NODE(AccClause, Bind)
+NODE(AccClause, Capture)
+NODE(AccClause, Collapse)
+NODE(AccClause, Copy)
+NODE(AccClause, Copyin)
+NODE(AccClause, Copyout)
+NODE(AccClause, Create)
+NODE(AccClause, Default)
+NODE(AccClause, DefaultAsync)
+NODE(AccClause, Delete)
+NODE(AccClause, Detach)
+NODE(AccClause, Device)
+NODE(AccClause, DeviceNum)
+NODE(AccClause, Deviceptr)
+NODE(AccClause, DeviceResident)
+NODE(AccClause, DeviceType)
+NODE(AccClause, Finalize)
+NODE(AccClause, Firstprivate)
+NODE(AccClause, Gang)
+NODE(AccClause, Host)
+NODE(AccClause, If)
+NODE(AccClause, IfPresent)
+NODE(AccClause, Independent)
+NODE(AccClause, Link)
+NODE(AccClause, NoCreate)
+NODE(AccClause, Nohost)
+NODE(AccClause, NumGangs)
+NODE(AccClause, NumWorkers)
+NODE(AccClause, Present)
+NODE(AccClause, Private)
+NODE(AccClause, Read)
+NODE(AccClause, Reduction)
+NODE(AccClause, Self)
+NODE(AccClause, Seq)
+NODE(AccClause, Tile)
+NODE(AccClause, Unknown)
+NODE(AccClause, UseDevice)
+NODE(AccClause, Vector)
+NODE(AccClause, VectorLength)
+NODE(AccClause, Wait)
+NODE(AccClause, Worker)
+NODE(AccClause, Write)
+
+#endif // GEN_FLANG_DUMP_PARSE_TREE_CLAUSES
+
+#ifdef GEN_FLANG_CLAUSE_UNPARSE
+#undef GEN_FLANG_CLAUSE_UNPARSE
+
+void Unparse(const AccClause::Async &x) {
+  Word("ASYNC");
+  Walk("(", x.v, ")");
+}
+void Unparse(const AccClause::Attach &x) {
+  Word("ATTACH");
+  Put("(");
+  Walk(x.v);
+  Put(")");
+}
+void Before(const AccClause::Auto &) { Word("AUTO"); }
+void Unparse(const AccClause::Bind &x) {
+  Word("BIND");
+  Put("(");
+  Walk(x.v);
+  Put(")");
+}
+void Before(const AccClause::Capture &) { Word("CAPTURE"); }
+void Unparse(const AccClause::Collapse &x) {
+  Word("COLLAPSE");
+  Put("(");
+  Walk(x.v);
+  Put(")");
+}
+void Unparse(const AccClause::Copy &x) {
+  Word("COPY");
+  Put("(");
+  Walk(x.v);
+  Put(")");
+}
+void Unparse(const AccClause::Copyin &x) {
+  Word("COPYIN");
+  Put("(");
+  Walk(x.v);
+  Put(")");
+}
+void Unparse(const AccClause::Copyout &x) {
+  Word("COPYOUT");
+  Put("(");
+  Walk(x.v);
+  Put(")");
+}
+void Unparse(const AccClause::Create &x) {
+  Word("CREATE");
+  Put("(");
+  Walk(x.v);
+  Put(")");
+}
+void Unparse(const AccClause::Default &x) {
+  Word("DEFAULT");
+  Put("(");
+  Walk(x.v);
+  Put(")");
+}
+void Unparse(const AccClause::DefaultAsync &x) {
+  Word("DEFAULT_ASYNC");
+  Put("(");
+  Walk(x.v);
+  Put(")");
+}
+void Unparse(const AccClause::Delete &x) {
+  Word("DELETE");
+  Put("(");
+  Walk(x.v);
+  Put(")");
+}
+void Unparse(const AccClause::Detach &x) {
+  Word("DETACH");
+  Put("(");
+  Walk(x.v);
+  Put(")");
+}
+void Unparse(const AccClause::Device &x) {
+  Word("DEVICE");
+  Put("(");
+  Walk(x.v);
+  Put(")");
+}
+void Unparse(const AccClause::DeviceNum &x) {
+  Word("DEVICE_NUM");
+  Put("(");
+  Walk(x.v);
+  Put(")");
+}
+void Unparse(const AccClause::Deviceptr &x) {
+  Word("DEVICEPTR");
+  Put("(");
+  Walk(x.v);
+  Put(")");
+}
+void Unparse(const AccClause::DeviceResident &x) {
+  Word("DEVICE_RESIDENT");
+  Put("(");
+  Walk(x.v);
+  Put(")");
+}
+void Unparse(const AccClause::DeviceType &x) {
+  Word("DEVICE_TYPE");
+  Put("(");
+  if (x.v.has_value())
+    Walk(x.v, ",");
+  else
+    Put("*");
+  Put(")");
+}
+void Before(const AccClause::Finalize &) { Word("FINALIZE"); }
+void Unparse(const AccClause::Firstprivate &x) {
+  Word("FIRSTPRIVATE");
+  Put("(");
+  Walk(x.v);
+  Put(")");
+}
+void Unparse(const AccClause::Gang &x) {
+  Word("GANG");
+  Walk("(", x.v, ")");
+}
+void Unparse(const AccClause::Host &x) {
+  Word("HOST");
+  Put("(");
+  Walk(x.v);
+  Put(")");
+}
+void Unparse(const AccClause::If &x) {
+  Word("IF");
+  Put("(");
+  Walk(x.v);
+  Put(")");
+}
+void Before(const AccClause::IfPresent &) { Word("IF_PRESENT"); }
+void Before(const AccClause::Independent &) { Word("INDEPENDENT"); }
+void Unparse(const AccClause::Link &x) {
+  Word("LINK");
+  Put("(");
+  Walk(x.v);
+  Put(")");
+}
+void Unparse(const AccClause::NoCreate &x) {
+  Word("NO_CREATE");
+  Put("(");
+  Walk(x.v);
+  Put(")");
+}
+void Before(const AccClause::Nohost &) { Word("NOHOST"); }
+void Unparse(const AccClause::NumGangs &x) {
+  Word("NUM_GANGS");
+  Put("(");
+  Walk(x.v);
+  Put(")");
+}
+void Unparse(const AccClause::NumWorkers &x) {
+  Word("NUM_WORKERS");
+  Put("(");
+  Walk(x.v);
+  Put(")");
+}
+void Unparse(const AccClause::Present &x) {
+  Word("PRESENT");
+  Put("(");
+  Walk(x.v);
+  Put(")");
+}
+void Unparse(const AccClause::Private &x) {
+  Word("PRIVATE");
+  Put("(");
+  Walk(x.v);
+  Put(")");
+}
+void Before(const AccClause::Read &) { Word("READ"); }
+void Unparse(const AccClause::Reduction &x) {
+  Word("REDUCTION");
+  Put("(");
+  Walk(x.v);
+  Put(")");
+}
+void Unparse(const AccClause::Self &x) {
+  Word("SELF");
+  Put("(");
+  Walk(x.v);
+  Put(")");
+}
+void Before(const AccClause::Seq &) { Word("SEQ"); }
+void Unparse(const AccClause::Tile &x) {
+  Word("TILE");
+  Put("(");
+  Walk(x.v);
+  Put(")");
+}
+void Before(const AccClause::Unknown &) { Word("UNKNOWN"); }
+void Unparse(const AccClause::UseDevice &x) {
+  Word("USE_DEVICE");
+  Put("(");
+  Walk(x.v);
+  Put(")");
+}
+void Unparse(const AccClause::Vector &x) {
+  Word("VECTOR");
+  Walk("(", x.v, ")");
+}
+void Unparse(const AccClause::VectorLength &x) {
+  Word("VECTOR_LENGTH");
+  Put("(");
+  Walk(x.v);
+  Put(")");
+}
+void Unparse(const AccClause::Wait &x) {
+  Word("WAIT");
+  Walk("(", x.v, ")");
+}
+void Unparse(const AccClause::Worker &x) {
+  Word("WORKER");
+  Walk("(", x.v, ")");
+}
+void Before(const AccClause::Write &) { Word("WRITE"); }
+
+#endif // GEN_FLANG_CLAUSE_UNPARSE
+
+#ifdef GEN_CLANG_CLAUSE_CLASS
+#undef GEN_CLANG_CLAUSE_CLASS
+
+#ifndef CLAUSE
+#define CLAUSE(Enum, Str, Implicit)
+#endif
+#ifndef CLAUSE_CLASS
+#define CLAUSE_CLASS(Enum, Str, Class)
+#endif
+#ifndef CLAUSE_NO_CLASS
+#define CLAUSE_NO_CLASS(Enum, Str)
+#endif
+
+#define __CLAUSE(Name, Class)                      \
+  CLAUSE(ACCC_##Name, #Name, /* Implicit */ false) \
+  CLAUSE_CLASS(ACCC_##Name, #Name, Class)
+#define __CLAUSE_NO_CLASS(Name)                    \
+  CLAUSE(ACCC_##Name, #Name, /* Implicit */ false) \
+  CLAUSE_NO_CLASS(ACCC_##Name, #Name)
+#define __IMPLICIT_CLAUSE_CLASS(Name, Str, Class)  \
+  CLAUSE(ACCC_##Name, Str, /* Implicit */ true)    \
+  CLAUSE_CLASS(ACCC_##Name, Str, Class)
+#define __IMPLICIT_CLAUSE_NO_CLASS(Name, Str)      \
+  CLAUSE(ACCC_##Name, Str, /* Implicit */ true)    \
+  CLAUSE_NO_CLASS(ACCC_##Name, Str)
+
+__CLAUSE_NO_CLASS(async)
+__CLAUSE_NO_CLASS(attach)
+__CLAUSE_NO_CLASS(auto)
+__CLAUSE_NO_CLASS(bind)
+__CLAUSE_NO_CLASS(capture)
+__CLAUSE_NO_CLASS(collapse)
+__CLAUSE_NO_CLASS(copy)
+__CLAUSE_NO_CLASS(copyin)
+__CLAUSE_NO_CLASS(copyout)
+__CLAUSE_NO_CLASS(create)
+__CLAUSE_NO_CLASS(default)
+__CLAUSE_NO_CLASS(default_async)
+__CLAUSE_NO_CLASS(delete)
+__CLAUSE_NO_CLASS(detach)
+__CLAUSE_NO_CLASS(device)
+__CLAUSE_NO_CLASS(device_num)
+__CLAUSE_NO_CLASS(deviceptr)
+__CLAUSE_NO_CLASS(device_resident)
+__CLAUSE_NO_CLASS(device_type)
+__CLAUSE_NO_CLASS(finalize)
+__CLAUSE_NO_CLASS(firstprivate)
+__CLAUSE_NO_CLASS(gang)
+__CLAUSE_NO_CLASS(host)
+__CLAUSE_NO_CLASS(if)
+__CLAUSE_NO_CLASS(if_present)
+__CLAUSE_NO_CLASS(independent)
+__CLAUSE_NO_CLASS(link)
+__CLAUSE_NO_CLASS(no_create)
+__CLAUSE_NO_CLASS(nohost)
+__CLAUSE_NO_CLASS(num_gangs)
+__CLAUSE_NO_CLASS(num_workers)
+__CLAUSE_NO_CLASS(present)
+__CLAUSE_NO_CLASS(private)
+__CLAUSE_NO_CLASS(read)
+__CLAUSE_NO_CLASS(reduction)
+__CLAUSE_NO_CLASS(self)
+__CLAUSE_NO_CLASS(seq)
+__CLAUSE_NO_CLASS(tile)
+__CLAUSE_NO_CLASS(unknown)
+__CLAUSE_NO_CLASS(use_device)
+__CLAUSE_NO_CLASS(vector)
+__CLAUSE_NO_CLASS(vector_length)
+__CLAUSE_NO_CLASS(wait)
+__CLAUSE_NO_CLASS(worker)
+__CLAUSE_NO_CLASS(write)
+
+#undef __IMPLICIT_CLAUSE_NO_CLASS
+#undef __IMPLICIT_CLAUSE_CLASS
+#undef __CLAUSE
+#undef CLAUSE_NO_CLASS
+#undef CLAUSE_CLASS
+#undef CLAUSE
+
+#endif // GEN_CLANG_CLAUSE_CLASS
+
diff --git a/linux-x64/clang/include/llvm/Frontend/OpenACC/ACC.td b/linux-x64/clang/include/llvm/Frontend/OpenACC/ACC.td
new file mode 100644
index 0000000..58bb73f
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Frontend/OpenACC/ACC.td
@@ -0,0 +1,630 @@
+//===-- ACC.td - OpenACC directive definition file ---------*- tablegen -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This is the definition file for OpenACC 3.1 directives and clauses.
+//
+//===----------------------------------------------------------------------===//
+
+include "llvm/Frontend/Directive/DirectiveBase.td"
+
+//===----------------------------------------------------------------------===//
+// Definition of general OpenACC information
+//===----------------------------------------------------------------------===//
+
+def OpenACC : DirectiveLanguage {
+  let name = "OpenACC";
+  let cppNamespace = "acc"; // final namespace will be llvm::acc
+  let directivePrefix = "ACCD_";
+  let clausePrefix = "ACCC_";
+  let makeEnumAvailableInNamespace = true;
+  let enableBitmaskEnumInNamespace = true;
+  let includeHeader = "llvm/Frontend/OpenACC/ACC.h.inc";
+  let clauseEnumSetClass = "AccClauseSet";
+  let flangClauseBaseClass = "AccClause";
+}
+
+//===----------------------------------------------------------------------===//
+// Definition of OpenACC clauses
+//===----------------------------------------------------------------------===//
+
+// 2.16.1
+def ACCC_Async : Clause<"async"> {
+  let flangClassValue = "ScalarIntExpr";
+  let isValueOptional = true;
+}
+
+// 2.9.7
+def ACCC_Auto : Clause<"auto"> {}
+
+// 2.7.12
+def ACCC_Attach : Clause<"attach"> {
+  let flangClassValue = "AccObjectList";
+}
+
+// 2.15.1
+def ACCC_Bind : Clause<"bind"> {
+  let flangClassValue = "AccBindClause";
+}
+
+// 2.12
+def ACCC_Capture : Clause<"capture"> {
+}
+
+// 2.9.1
+def ACCC_Collapse : Clause<"collapse"> {
+  let flangClassValue = "ScalarIntConstantExpr";
+}
+
+// 2.7.6
+def ACCC_Copy : Clause<"copy"> {
+  let flangClassValue = "AccObjectList";
+}
+// 2.7.7
+def ACCC_Copyin : Clause<"copyin"> {
+  let flangClassValue = "AccObjectListWithModifier";
+}
+
+// 2.7.8
+def ACCC_Copyout : Clause<"copyout"> {
+  let flangClassValue = "AccObjectListWithModifier";
+}
+
+// 2.7.9
+def ACCC_Create : Clause<"create"> {
+  let flangClassValue = "AccObjectListWithModifier";
+}
+
+// 2.5.15
+def ACC_Default_none : ClauseVal<"none", 1, 1> { let isDefault = 1; }
+def ACC_Default_present : ClauseVal<"present", 0, 1> {}
+
+def ACCC_Default : Clause<"default"> {
+  let flangClassValue = "AccDefaultClause";
+  let enumClauseValue = "DefaultValue";
+  let allowedClauseValues = [
+    ACC_Default_present,
+    ACC_Default_none
+  ];
+}
+
+// 2.14.3
+def ACCC_DefaultAsync : Clause<"default_async"> {
+  let flangClassValue = "ScalarIntExpr";
+}
+
+// 2.7.11
+def ACCC_Delete : Clause<"delete"> {
+  let flangClassValue = "AccObjectList";
+}
+
+// 2.7.13
+def ACCC_Detach : Clause<"detach"> {
+  let flangClassValue = "AccObjectList";
+}
+
+// 2.14.4
+def ACCC_Device : Clause<"device"> {
+  let flangClassValue = "AccObjectList";
+}
+
+// 2.14.1 - 2.14.2
+def ACCC_DeviceNum : Clause<"device_num">  {
+  let flangClassValue = "ScalarIntExpr";
+}
+
+// 2.7.4
+def ACCC_DevicePtr : Clause<"deviceptr"> {
+  let flangClassValue = "AccObjectList";
+}
+
+// 2.13.1
+def ACCC_DeviceResident : Clause<"device_resident"> {
+  let flangClassValue = "AccObjectList";
+}
+
+// 2.4
+def ACCC_DeviceType : Clause<"device_type"> {
+  let flangClassValue = "ScalarIntExpr";
+  let defaultValue = "*";
+  let isValueOptional = true;
+  let isValueList = true;
+}
+
+// 2.6.6
+def ACCC_Finalize : Clause<"finalize"> {}
+
+// 2.5.13
+def ACCC_FirstPrivate : Clause<"firstprivate"> {
+  let flangClassValue = "AccObjectList";
+}
+
+// 2.9.2
+def ACCC_Gang : Clause<"gang"> {
+  let flangClassValue = "AccGangArgument";
+  let isValueOptional = true;
+}
+
+// 2.14.4
+def ACCC_Host : Clause<"host"> {
+  let flangClassValue = "AccObjectList";
+}
+
+// 2.5.5
+def ACCC_If : Clause <"if"> {
+  let flangClassValue = "ScalarLogicalExpr";
+}
+
+// 2.14.4
+def ACCC_IfPresent : Clause<"if_present"> {}
+
+// 2.9.6
+def ACCC_Independent : Clause<"independent"> {}
+
+// 2.13.3
+def ACCC_Link : Clause<"link"> {
+  let flangClassValue = "AccObjectList";
+}
+
+// 2.7.10
+def ACCC_NoCreate : Clause<"no_create"> {
+  let flangClassValue = "AccObjectList";
+}
+
+// 2.15.1
+def ACCC_NoHost : Clause<"nohost"> {}
+
+// 2.5.9
+def ACCC_NumGangs : Clause<"num_gangs"> {
+  let flangClassValue = "ScalarIntExpr";
+}
+
+// 2.5.10
+def ACCC_NumWorkers : Clause<"num_workers"> {
+  let flangClassValue = "ScalarIntExpr";
+}
+
+// 2.7.5
+def ACCC_Present : Clause<"present"> {
+  let flangClassValue = "AccObjectList";
+}
+
+// 2.5.12
+def ACCC_Private : Clause<"private"> {
+  let flangClassValue = "AccObjectList";
+}
+
+// 2.9.8
+def ACCC_Tile : Clause <"tile"> {
+  let flangClassValue = "AccTileExprList";
+}
+
+// 2.8.1
+def ACCC_UseDevice : Clause <"use_device"> {
+  let flangClassValue = "AccObjectList";
+}
+
+// 2.12
+def ACCC_Read : Clause<"read"> {}
+
+// 2.5.14
+def ACCC_Reduction : Clause<"reduction"> {
+  let flangClassValue = "AccObjectListWithReduction";
+}
+
+// 2.5.6
+def ACCC_Self : Clause<"self"> {
+  let flangClassValue = "AccSelfClause";
+}
+
+// 2.9.5
+def ACCC_Seq : Clause<"seq"> {}
+
+// 2.9.4
+def ACCC_Vector : Clause<"vector"> {
+  let flangClassValue = "ScalarIntExpr";
+  let isValueOptional = true;
+}
+
+// 2.5.11
+def ACCC_VectorLength : Clause<"vector_length"> {
+  let flangClassValue = "ScalarIntExpr";
+}
+
+// 2.16.2
+def ACCC_Wait : Clause<"wait"> {
+  let flangClassValue = "AccWaitArgument";
+  let isValueOptional = true;
+}
+
+// 2.9.3
+def ACCC_Worker: Clause<"worker"> {
+  let flangClassValue = "ScalarIntExpr";
+  let isValueOptional = true;
+}
+
+// 2.12
+def ACCC_Write : Clause<"write"> {}
+
+def ACCC_Unknown : Clause<"unknown"> {
+  let isDefault = true;
+}
+
+//===----------------------------------------------------------------------===//
+// Definition of OpenACC directives
+//===----------------------------------------------------------------------===//
+
+// 2.12
+def ACC_Atomic : Directive<"atomic"> {}
+
+// 2.6.5
+def ACC_Data : Directive<"data"> {
+  let allowedOnceClauses = [
+    VersionedClause<ACCC_If>,
+    VersionedClause<ACCC_Default>
+  ];
+  let requiredClauses = [
+    VersionedClause<ACCC_Attach>,
+    VersionedClause<ACCC_Copy>,
+    VersionedClause<ACCC_Copyin>,
+    VersionedClause<ACCC_Copyout>,
+    VersionedClause<ACCC_Create>,
+    VersionedClause<ACCC_Default>,
+    VersionedClause<ACCC_DevicePtr>,
+    VersionedClause<ACCC_NoCreate>,
+    VersionedClause<ACCC_Present>
+  ];
+}
+
+// 2.13
+def ACC_Declare : Directive<"declare"> {
+  let allowedClauses = [
+    VersionedClause<ACCC_Copy>,
+    VersionedClause<ACCC_Copyin>,
+    VersionedClause<ACCC_Copyout>,
+    VersionedClause<ACCC_Create>,
+    VersionedClause<ACCC_Present>,
+    VersionedClause<ACCC_DevicePtr>,
+    VersionedClause<ACCC_DeviceResident>,
+    VersionedClause<ACCC_Link>
+  ];
+}
+
+// 2.5.3
+def ACC_Kernels : Directive<"kernels"> {
+  let allowedClauses = [
+    VersionedClause<ACCC_Attach>,
+    VersionedClause<ACCC_Copy>,
+    VersionedClause<ACCC_Copyin>,
+    VersionedClause<ACCC_Copyout>,
+    VersionedClause<ACCC_Create>,
+    VersionedClause<ACCC_DeviceType>,
+    VersionedClause<ACCC_NoCreate>,
+    VersionedClause<ACCC_Present>,
+    VersionedClause<ACCC_DevicePtr>,
+    VersionedClause<ACCC_Wait>
+  ];
+  let allowedOnceClauses = [
+    VersionedClause<ACCC_Async>,
+    VersionedClause<ACCC_Default>,
+    VersionedClause<ACCC_If>,
+    VersionedClause<ACCC_NumGangs>,
+    VersionedClause<ACCC_NumWorkers>,
+    VersionedClause<ACCC_Self>,
+    VersionedClause<ACCC_VectorLength>
+  ];
+}
+
+// 2.5.1
+def ACC_Parallel : Directive<"parallel"> {
+  let allowedClauses = [
+    VersionedClause<ACCC_Attach>,
+    VersionedClause<ACCC_Copy>,
+    VersionedClause<ACCC_Copyin>,
+    VersionedClause<ACCC_Copyout>,
+    VersionedClause<ACCC_Create>,
+    VersionedClause<ACCC_DevicePtr>,
+    VersionedClause<ACCC_DeviceType>,
+    VersionedClause<ACCC_NoCreate>,
+    VersionedClause<ACCC_Present>,
+    VersionedClause<ACCC_Private>,
+    VersionedClause<ACCC_FirstPrivate>,
+    VersionedClause<ACCC_Wait>
+  ];
+  let allowedOnceClauses = [
+    VersionedClause<ACCC_Async>,
+    VersionedClause<ACCC_Default>,
+    VersionedClause<ACCC_If>,
+    VersionedClause<ACCC_NumGangs>,
+    VersionedClause<ACCC_NumWorkers>,
+    VersionedClause<ACCC_Reduction>,
+    VersionedClause<ACCC_Self>,
+    VersionedClause<ACCC_VectorLength>
+  ];
+}
+
+// 2.5.2
+def ACC_Serial : Directive<"serial"> {
+  // Spec line 950-951: clause is as for the parallel construct except that the
+  // num_gangs, num_workers, and vector_length clauses are not permitted.
+  let allowedClauses = [
+    VersionedClause<ACCC_Attach>,
+    VersionedClause<ACCC_Copy>,
+    VersionedClause<ACCC_Copyin>,
+    VersionedClause<ACCC_Copyout>,
+    VersionedClause<ACCC_Create>,
+    VersionedClause<ACCC_DevicePtr>,
+    VersionedClause<ACCC_DeviceType>,
+    VersionedClause<ACCC_NoCreate>,
+    VersionedClause<ACCC_Present>,
+    VersionedClause<ACCC_Private>,
+    VersionedClause<ACCC_FirstPrivate>,
+    VersionedClause<ACCC_Wait>
+  ];
+  let allowedOnceClauses = [
+    VersionedClause<ACCC_Async>,
+    VersionedClause<ACCC_Default>,
+    VersionedClause<ACCC_If>,
+    VersionedClause<ACCC_Reduction>,
+    VersionedClause<ACCC_Self>
+  ];
+}
+
+// 2.9
+def ACC_Loop : Directive<"loop"> {
+  let allowedClauses = [
+    VersionedClause<ACCC_DeviceType>,
+    VersionedClause<ACCC_Private>
+  ];
+  let allowedOnceClauses = [
+    VersionedClause<ACCC_Collapse>,
+    VersionedClause<ACCC_Gang>,
+    VersionedClause<ACCC_Reduction>,
+    VersionedClause<ACCC_Tile>,
+    VersionedClause<ACCC_Vector>,
+    VersionedClause<ACCC_Worker>
+  ];
+  let allowedExclusiveClauses = [
+    VersionedClause<ACCC_Auto>,
+    VersionedClause<ACCC_Independent>,
+    VersionedClause<ACCC_Seq>
+  ];
+}
+
+// 2.10
+def ACC_Cache : Directive<"cache"> {}
+
+// 2.14.1
+def ACC_Init : Directive<"init"> {
+  let allowedOnceClauses = [
+    VersionedClause<ACCC_DeviceNum>,
+    VersionedClause<ACCC_DeviceType>,
+    VersionedClause<ACCC_If>
+  ];
+}
+
+// 2.15.1
+def ACC_Routine : Directive<"routine"> {
+  let allowedOnceClauses = [
+    VersionedClause<ACCC_Bind>,
+    VersionedClause<ACCC_DeviceType>,
+    VersionedClause<ACCC_NoHost>
+  ];
+  let requiredClauses = [
+    VersionedClause<ACCC_Gang>,
+    VersionedClause<ACCC_Seq>,
+    VersionedClause<ACCC_Vector>,
+    VersionedClause<ACCC_Worker>
+  ];
+}
+
+// 2.14.3
+def ACC_Set : Directive<"set"> {
+  let allowedOnceClauses = [
+    VersionedClause<ACCC_DefaultAsync>,
+    VersionedClause<ACCC_DeviceNum>,
+    VersionedClause<ACCC_DeviceType>,
+    VersionedClause<ACCC_If>
+  ];
+  let requiredClauses = [
+    // The three following clauses are also in allowedOnceClauses list due to
+    // restriction 2255 - Two instances of the same clause may not appear on the
+    // same directive.
+    VersionedClause<ACCC_DefaultAsync>,
+    VersionedClause<ACCC_DeviceNum>,
+    VersionedClause<ACCC_DeviceType>
+  ];
+}
+
+// 2.14.2
+def ACC_Shutdown : Directive<"shutdown"> {
+  let allowedOnceClauses = [
+    VersionedClause<ACCC_DeviceNum>,
+    VersionedClause<ACCC_DeviceType>,
+    VersionedClause<ACCC_If>
+  ];
+}
+
+// 2.14.4
+def ACC_Update : Directive<"update"> {
+  let allowedClauses = [
+    VersionedClause<ACCC_DeviceType>,
+    VersionedClause<ACCC_Wait>
+  ];
+  let allowedOnceClauses = [
+    VersionedClause<ACCC_Async>,
+    VersionedClause<ACCC_If>,
+    VersionedClause<ACCC_IfPresent>
+  ];
+  let requiredClauses = [
+    VersionedClause<ACCC_Device>,
+    VersionedClause<ACCC_Host>,
+    VersionedClause<ACCC_Self>
+  ];
+}
+
+// 2.16.3
+def ACC_Wait : Directive<"wait"> {
+  let allowedOnceClauses = [
+    VersionedClause<ACCC_Async>,
+    VersionedClause<ACCC_If>
+  ];
+}
+
+// 2.14.6
+def ACC_EnterData : Directive<"enter data"> {
+  let allowedOnceClauses = [
+    VersionedClause<ACCC_Async>,
+    VersionedClause<ACCC_If>,
+    VersionedClause<ACCC_Wait>
+  ];
+  let requiredClauses = [
+    VersionedClause<ACCC_Attach>,
+    VersionedClause<ACCC_Create>,
+    VersionedClause<ACCC_Copyin>
+  ];
+}
+
+// 2.14.7
+def ACC_ExitData : Directive<"exit data"> {
+  let allowedClauses = [
+    VersionedClause<ACCC_Async>,
+    VersionedClause<ACCC_If>,
+    VersionedClause<ACCC_Wait>,
+    VersionedClause<ACCC_Finalize>
+  ];
+  let requiredClauses = [
+    VersionedClause<ACCC_Copyout>,
+    VersionedClause<ACCC_Delete>,
+    VersionedClause<ACCC_Detach>
+  ];
+}
+
+// 2.8
+def ACC_HostData : Directive<"host_data"> {
+  let allowedClauses = [
+    VersionedClause<ACCC_If>,
+    VersionedClause<ACCC_IfPresent>
+  ];
+  let requiredClauses = [
+    VersionedClause<ACCC_UseDevice>
+  ];
+}
+
+// 2.11
+def ACC_KernelsLoop : Directive<"kernels loop"> {
+  let allowedClauses = [
+    VersionedClause<ACCC_Copy>,
+    VersionedClause<ACCC_Copyin>,
+    VersionedClause<ACCC_Copyout>,
+    VersionedClause<ACCC_Create>,
+    VersionedClause<ACCC_DeviceType>,
+    VersionedClause<ACCC_NoCreate>,
+    VersionedClause<ACCC_Present>,
+    VersionedClause<ACCC_Private>,
+    VersionedClause<ACCC_DevicePtr>,
+    VersionedClause<ACCC_Attach>
+  ];
+  let allowedOnceClauses = [
+    VersionedClause<ACCC_Async>,
+    VersionedClause<ACCC_Collapse>,
+    VersionedClause<ACCC_Default>,
+    VersionedClause<ACCC_Gang>,
+    VersionedClause<ACCC_If>,
+    VersionedClause<ACCC_NumGangs>,
+    VersionedClause<ACCC_NumWorkers>,
+    VersionedClause<ACCC_Reduction>,
+    VersionedClause<ACCC_Self>,
+    VersionedClause<ACCC_Tile>,
+    VersionedClause<ACCC_Vector>,
+    VersionedClause<ACCC_VectorLength>,
+    VersionedClause<ACCC_Wait>,
+    VersionedClause<ACCC_Worker>
+  ];
+  let allowedExclusiveClauses = [
+    VersionedClause<ACCC_Auto>,
+    VersionedClause<ACCC_Independent>,
+    VersionedClause<ACCC_Seq>
+  ];
+}
+
+// 2.11
+def ACC_ParallelLoop : Directive<"parallel loop"> {
+  let allowedClauses = [
+    VersionedClause<ACCC_Attach>,
+    VersionedClause<ACCC_Copy>,
+    VersionedClause<ACCC_Copyin>,
+    VersionedClause<ACCC_Copyout>,
+    VersionedClause<ACCC_Create>,
+    VersionedClause<ACCC_DevicePtr>,
+    VersionedClause<ACCC_DeviceType>,
+    VersionedClause<ACCC_FirstPrivate>,
+    VersionedClause<ACCC_NoCreate>,
+    VersionedClause<ACCC_Present>,
+    VersionedClause<ACCC_Private>,
+    VersionedClause<ACCC_Tile>,
+    VersionedClause<ACCC_Wait>
+  ];
+  let allowedOnceClauses = [
+    VersionedClause<ACCC_Async>,
+    VersionedClause<ACCC_Collapse>,
+    VersionedClause<ACCC_Default>,
+    VersionedClause<ACCC_Gang>,
+    VersionedClause<ACCC_If>,
+    VersionedClause<ACCC_NumGangs>,
+    VersionedClause<ACCC_NumWorkers>,
+    VersionedClause<ACCC_Reduction>,
+    VersionedClause<ACCC_Self>,
+    VersionedClause<ACCC_Vector>,
+    VersionedClause<ACCC_VectorLength>,
+    VersionedClause<ACCC_Worker>
+  ];
+  let allowedExclusiveClauses = [
+    VersionedClause<ACCC_Auto>,
+    VersionedClause<ACCC_Independent>,
+    VersionedClause<ACCC_Seq>
+  ];
+}
+
+// 2.11
+def ACC_SerialLoop : Directive<"serial loop"> {
+  let allowedClauses = [
+    VersionedClause<ACCC_Attach>,
+    VersionedClause<ACCC_Copy>,
+    VersionedClause<ACCC_Copyin>,
+    VersionedClause<ACCC_Copyout>,
+    VersionedClause<ACCC_Create>,
+    VersionedClause<ACCC_DevicePtr>,
+    VersionedClause<ACCC_DeviceType>,
+    VersionedClause<ACCC_FirstPrivate>,
+    VersionedClause<ACCC_NoCreate>,
+    VersionedClause<ACCC_Present>,
+    VersionedClause<ACCC_Private>,
+    VersionedClause<ACCC_Wait>
+  ];
+  let allowedOnceClauses = [
+    VersionedClause<ACCC_Async>,
+    VersionedClause<ACCC_Collapse>,
+    VersionedClause<ACCC_Default>,
+    VersionedClause<ACCC_Gang>,
+    VersionedClause<ACCC_If>,
+    VersionedClause<ACCC_Reduction>,
+    VersionedClause<ACCC_Self>,
+    VersionedClause<ACCC_Tile>,
+    VersionedClause<ACCC_Vector>,
+    VersionedClause<ACCC_Worker>
+  ];
+  let allowedExclusiveClauses = [
+    VersionedClause<ACCC_Auto>,
+    VersionedClause<ACCC_Independent>,
+    VersionedClause<ACCC_Seq>
+  ];
+}
+
+def ACC_Unknown : Directive<"unknown"> {
+  let isDefault = true;
+}
diff --git a/linux-x64/clang/include/llvm/Frontend/OpenMP/OMP.h.inc b/linux-x64/clang/include/llvm/Frontend/OpenMP/OMP.h.inc
new file mode 100644
index 0000000..aec25f7
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Frontend/OpenMP/OMP.h.inc
@@ -0,0 +1,411 @@
+#ifndef LLVM_OpenMP_INC
+#define LLVM_OpenMP_INC
+
+#include "llvm/ADT/BitmaskEnum.h"
+
+namespace llvm {
+class StringRef;
+namespace omp {
+
+LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE();
+
+enum class Directive {
+  OMPD_allocate,
+  OMPD_assumes,
+  OMPD_atomic,
+  OMPD_barrier,
+  OMPD_begin_assumes,
+  OMPD_begin_declare_variant,
+  OMPD_cancel,
+  OMPD_cancellation_point,
+  OMPD_critical,
+  OMPD_declare_mapper,
+  OMPD_declare_reduction,
+  OMPD_declare_simd,
+  OMPD_declare_target,
+  OMPD_declare_variant,
+  OMPD_depobj,
+  OMPD_distribute,
+  OMPD_distribute_parallel_do,
+  OMPD_distribute_parallel_do_simd,
+  OMPD_distribute_parallel_for,
+  OMPD_distribute_parallel_for_simd,
+  OMPD_distribute_simd,
+  OMPD_do,
+  OMPD_do_simd,
+  OMPD_end_assumes,
+  OMPD_end_declare_target,
+  OMPD_end_declare_variant,
+  OMPD_end_do,
+  OMPD_end_do_simd,
+  OMPD_end_sections,
+  OMPD_end_single,
+  OMPD_end_workshare,
+  OMPD_flush,
+  OMPD_for,
+  OMPD_for_simd,
+  OMPD_master,
+  OMPD_master_taskloop,
+  OMPD_master_taskloop_simd,
+  OMPD_ordered,
+  OMPD_parallel,
+  OMPD_parallel_do,
+  OMPD_parallel_do_simd,
+  OMPD_parallel_for,
+  OMPD_parallel_for_simd,
+  OMPD_parallel_master,
+  OMPD_parallel_master_taskloop,
+  OMPD_parallel_master_taskloop_simd,
+  OMPD_parallel_sections,
+  OMPD_parallel_workshare,
+  OMPD_requires,
+  OMPD_scan,
+  OMPD_section,
+  OMPD_sections,
+  OMPD_simd,
+  OMPD_single,
+  OMPD_target,
+  OMPD_target_data,
+  OMPD_target_enter_data,
+  OMPD_target_exit_data,
+  OMPD_target_parallel,
+  OMPD_target_parallel_do,
+  OMPD_target_parallel_do_simd,
+  OMPD_target_parallel_for,
+  OMPD_target_parallel_for_simd,
+  OMPD_target_simd,
+  OMPD_target_teams,
+  OMPD_target_teams_distribute,
+  OMPD_target_teams_distribute_parallel_do,
+  OMPD_target_teams_distribute_parallel_do_simd,
+  OMPD_target_teams_distribute_parallel_for,
+  OMPD_target_teams_distribute_parallel_for_simd,
+  OMPD_target_teams_distribute_simd,
+  OMPD_target_update,
+  OMPD_task,
+  OMPD_taskgroup,
+  OMPD_taskloop,
+  OMPD_taskloop_simd,
+  OMPD_taskwait,
+  OMPD_taskyield,
+  OMPD_teams,
+  OMPD_teams_distribute,
+  OMPD_teams_distribute_parallel_do,
+  OMPD_teams_distribute_parallel_do_simd,
+  OMPD_teams_distribute_parallel_for,
+  OMPD_teams_distribute_parallel_for_simd,
+  OMPD_teams_distribute_simd,
+  OMPD_threadprivate,
+  OMPD_unknown,
+  OMPD_workshare,
+};
+
+static constexpr std::size_t Directive_enumSize = 88;
+
+constexpr auto OMPD_allocate = llvm::omp::Directive::OMPD_allocate;
+constexpr auto OMPD_assumes = llvm::omp::Directive::OMPD_assumes;
+constexpr auto OMPD_atomic = llvm::omp::Directive::OMPD_atomic;
+constexpr auto OMPD_barrier = llvm::omp::Directive::OMPD_barrier;
+constexpr auto OMPD_begin_assumes = llvm::omp::Directive::OMPD_begin_assumes;
+constexpr auto OMPD_begin_declare_variant = llvm::omp::Directive::OMPD_begin_declare_variant;
+constexpr auto OMPD_cancel = llvm::omp::Directive::OMPD_cancel;
+constexpr auto OMPD_cancellation_point = llvm::omp::Directive::OMPD_cancellation_point;
+constexpr auto OMPD_critical = llvm::omp::Directive::OMPD_critical;
+constexpr auto OMPD_declare_mapper = llvm::omp::Directive::OMPD_declare_mapper;
+constexpr auto OMPD_declare_reduction = llvm::omp::Directive::OMPD_declare_reduction;
+constexpr auto OMPD_declare_simd = llvm::omp::Directive::OMPD_declare_simd;
+constexpr auto OMPD_declare_target = llvm::omp::Directive::OMPD_declare_target;
+constexpr auto OMPD_declare_variant = llvm::omp::Directive::OMPD_declare_variant;
+constexpr auto OMPD_depobj = llvm::omp::Directive::OMPD_depobj;
+constexpr auto OMPD_distribute = llvm::omp::Directive::OMPD_distribute;
+constexpr auto OMPD_distribute_parallel_do = llvm::omp::Directive::OMPD_distribute_parallel_do;
+constexpr auto OMPD_distribute_parallel_do_simd = llvm::omp::Directive::OMPD_distribute_parallel_do_simd;
+constexpr auto OMPD_distribute_parallel_for = llvm::omp::Directive::OMPD_distribute_parallel_for;
+constexpr auto OMPD_distribute_parallel_for_simd = llvm::omp::Directive::OMPD_distribute_parallel_for_simd;
+constexpr auto OMPD_distribute_simd = llvm::omp::Directive::OMPD_distribute_simd;
+constexpr auto OMPD_do = llvm::omp::Directive::OMPD_do;
+constexpr auto OMPD_do_simd = llvm::omp::Directive::OMPD_do_simd;
+constexpr auto OMPD_end_assumes = llvm::omp::Directive::OMPD_end_assumes;
+constexpr auto OMPD_end_declare_target = llvm::omp::Directive::OMPD_end_declare_target;
+constexpr auto OMPD_end_declare_variant = llvm::omp::Directive::OMPD_end_declare_variant;
+constexpr auto OMPD_end_do = llvm::omp::Directive::OMPD_end_do;
+constexpr auto OMPD_end_do_simd = llvm::omp::Directive::OMPD_end_do_simd;
+constexpr auto OMPD_end_sections = llvm::omp::Directive::OMPD_end_sections;
+constexpr auto OMPD_end_single = llvm::omp::Directive::OMPD_end_single;
+constexpr auto OMPD_end_workshare = llvm::omp::Directive::OMPD_end_workshare;
+constexpr auto OMPD_flush = llvm::omp::Directive::OMPD_flush;
+constexpr auto OMPD_for = llvm::omp::Directive::OMPD_for;
+constexpr auto OMPD_for_simd = llvm::omp::Directive::OMPD_for_simd;
+constexpr auto OMPD_master = llvm::omp::Directive::OMPD_master;
+constexpr auto OMPD_master_taskloop = llvm::omp::Directive::OMPD_master_taskloop;
+constexpr auto OMPD_master_taskloop_simd = llvm::omp::Directive::OMPD_master_taskloop_simd;
+constexpr auto OMPD_ordered = llvm::omp::Directive::OMPD_ordered;
+constexpr auto OMPD_parallel = llvm::omp::Directive::OMPD_parallel;
+constexpr auto OMPD_parallel_do = llvm::omp::Directive::OMPD_parallel_do;
+constexpr auto OMPD_parallel_do_simd = llvm::omp::Directive::OMPD_parallel_do_simd;
+constexpr auto OMPD_parallel_for = llvm::omp::Directive::OMPD_parallel_for;
+constexpr auto OMPD_parallel_for_simd = llvm::omp::Directive::OMPD_parallel_for_simd;
+constexpr auto OMPD_parallel_master = llvm::omp::Directive::OMPD_parallel_master;
+constexpr auto OMPD_parallel_master_taskloop = llvm::omp::Directive::OMPD_parallel_master_taskloop;
+constexpr auto OMPD_parallel_master_taskloop_simd = llvm::omp::Directive::OMPD_parallel_master_taskloop_simd;
+constexpr auto OMPD_parallel_sections = llvm::omp::Directive::OMPD_parallel_sections;
+constexpr auto OMPD_parallel_workshare = llvm::omp::Directive::OMPD_parallel_workshare;
+constexpr auto OMPD_requires = llvm::omp::Directive::OMPD_requires;
+constexpr auto OMPD_scan = llvm::omp::Directive::OMPD_scan;
+constexpr auto OMPD_section = llvm::omp::Directive::OMPD_section;
+constexpr auto OMPD_sections = llvm::omp::Directive::OMPD_sections;
+constexpr auto OMPD_simd = llvm::omp::Directive::OMPD_simd;
+constexpr auto OMPD_single = llvm::omp::Directive::OMPD_single;
+constexpr auto OMPD_target = llvm::omp::Directive::OMPD_target;
+constexpr auto OMPD_target_data = llvm::omp::Directive::OMPD_target_data;
+constexpr auto OMPD_target_enter_data = llvm::omp::Directive::OMPD_target_enter_data;
+constexpr auto OMPD_target_exit_data = llvm::omp::Directive::OMPD_target_exit_data;
+constexpr auto OMPD_target_parallel = llvm::omp::Directive::OMPD_target_parallel;
+constexpr auto OMPD_target_parallel_do = llvm::omp::Directive::OMPD_target_parallel_do;
+constexpr auto OMPD_target_parallel_do_simd = llvm::omp::Directive::OMPD_target_parallel_do_simd;
+constexpr auto OMPD_target_parallel_for = llvm::omp::Directive::OMPD_target_parallel_for;
+constexpr auto OMPD_target_parallel_for_simd = llvm::omp::Directive::OMPD_target_parallel_for_simd;
+constexpr auto OMPD_target_simd = llvm::omp::Directive::OMPD_target_simd;
+constexpr auto OMPD_target_teams = llvm::omp::Directive::OMPD_target_teams;
+constexpr auto OMPD_target_teams_distribute = llvm::omp::Directive::OMPD_target_teams_distribute;
+constexpr auto OMPD_target_teams_distribute_parallel_do = llvm::omp::Directive::OMPD_target_teams_distribute_parallel_do;
+constexpr auto OMPD_target_teams_distribute_parallel_do_simd = llvm::omp::Directive::OMPD_target_teams_distribute_parallel_do_simd;
+constexpr auto OMPD_target_teams_distribute_parallel_for = llvm::omp::Directive::OMPD_target_teams_distribute_parallel_for;
+constexpr auto OMPD_target_teams_distribute_parallel_for_simd = llvm::omp::Directive::OMPD_target_teams_distribute_parallel_for_simd;
+constexpr auto OMPD_target_teams_distribute_simd = llvm::omp::Directive::OMPD_target_teams_distribute_simd;
+constexpr auto OMPD_target_update = llvm::omp::Directive::OMPD_target_update;
+constexpr auto OMPD_task = llvm::omp::Directive::OMPD_task;
+constexpr auto OMPD_taskgroup = llvm::omp::Directive::OMPD_taskgroup;
+constexpr auto OMPD_taskloop = llvm::omp::Directive::OMPD_taskloop;
+constexpr auto OMPD_taskloop_simd = llvm::omp::Directive::OMPD_taskloop_simd;
+constexpr auto OMPD_taskwait = llvm::omp::Directive::OMPD_taskwait;
+constexpr auto OMPD_taskyield = llvm::omp::Directive::OMPD_taskyield;
+constexpr auto OMPD_teams = llvm::omp::Directive::OMPD_teams;
+constexpr auto OMPD_teams_distribute = llvm::omp::Directive::OMPD_teams_distribute;
+constexpr auto OMPD_teams_distribute_parallel_do = llvm::omp::Directive::OMPD_teams_distribute_parallel_do;
+constexpr auto OMPD_teams_distribute_parallel_do_simd = llvm::omp::Directive::OMPD_teams_distribute_parallel_do_simd;
+constexpr auto OMPD_teams_distribute_parallel_for = llvm::omp::Directive::OMPD_teams_distribute_parallel_for;
+constexpr auto OMPD_teams_distribute_parallel_for_simd = llvm::omp::Directive::OMPD_teams_distribute_parallel_for_simd;
+constexpr auto OMPD_teams_distribute_simd = llvm::omp::Directive::OMPD_teams_distribute_simd;
+constexpr auto OMPD_threadprivate = llvm::omp::Directive::OMPD_threadprivate;
+constexpr auto OMPD_unknown = llvm::omp::Directive::OMPD_unknown;
+constexpr auto OMPD_workshare = llvm::omp::Directive::OMPD_workshare;
+
+enum class Clause {
+  OMPC_acq_rel,
+  OMPC_acquire,
+  OMPC_affinity,
+  OMPC_aligned,
+  OMPC_allocate,
+  OMPC_allocator,
+  OMPC_atomic_default_mem_order,
+  OMPC_capture,
+  OMPC_collapse,
+  OMPC_copyprivate,
+  OMPC_copyin,
+  OMPC_default,
+  OMPC_defaultmap,
+  OMPC_depend,
+  OMPC_depobj,
+  OMPC_destroy,
+  OMPC_detach,
+  OMPC_device,
+  OMPC_device_type,
+  OMPC_dist_schedule,
+  OMPC_dynamic_allocators,
+  OMPC_exclusive,
+  OMPC_final,
+  OMPC_firstprivate,
+  OMPC_flush,
+  OMPC_from,
+  OMPC_grainsize,
+  OMPC_hint,
+  OMPC_if,
+  OMPC_in_reduction,
+  OMPC_inbranch,
+  OMPC_inclusive,
+  OMPC_is_device_ptr,
+  OMPC_lastprivate,
+  OMPC_linear,
+  OMPC_link,
+  OMPC_map,
+  OMPC_match,
+  OMPC_mergeable,
+  OMPC_nogroup,
+  OMPC_nowait,
+  OMPC_nontemporal,
+  OMPC_notinbranch,
+  OMPC_num_tasks,
+  OMPC_num_teams,
+  OMPC_num_threads,
+  OMPC_order,
+  OMPC_ordered,
+  OMPC_priority,
+  OMPC_private,
+  OMPC_proc_bind,
+  OMPC_read,
+  OMPC_reduction,
+  OMPC_relaxed,
+  OMPC_release,
+  OMPC_reverse_offload,
+  OMPC_safelen,
+  OMPC_schedule,
+  OMPC_seq_cst,
+  OMPC_shared,
+  OMPC_simd,
+  OMPC_simdlen,
+  OMPC_task_reduction,
+  OMPC_thread_limit,
+  OMPC_threadprivate,
+  OMPC_threads,
+  OMPC_to,
+  OMPC_unified_address,
+  OMPC_unified_shared_memory,
+  OMPC_uniform,
+  OMPC_unknown,
+  OMPC_untied,
+  OMPC_update,
+  OMPC_use_device_addr,
+  OMPC_use_device_ptr,
+  OMPC_uses_allocators,
+  OMPC_write,
+};
+
+static constexpr std::size_t Clause_enumSize = 77;
+
+constexpr auto OMPC_acq_rel = llvm::omp::Clause::OMPC_acq_rel;
+constexpr auto OMPC_acquire = llvm::omp::Clause::OMPC_acquire;
+constexpr auto OMPC_affinity = llvm::omp::Clause::OMPC_affinity;
+constexpr auto OMPC_aligned = llvm::omp::Clause::OMPC_aligned;
+constexpr auto OMPC_allocate = llvm::omp::Clause::OMPC_allocate;
+constexpr auto OMPC_allocator = llvm::omp::Clause::OMPC_allocator;
+constexpr auto OMPC_atomic_default_mem_order = llvm::omp::Clause::OMPC_atomic_default_mem_order;
+constexpr auto OMPC_capture = llvm::omp::Clause::OMPC_capture;
+constexpr auto OMPC_collapse = llvm::omp::Clause::OMPC_collapse;
+constexpr auto OMPC_copyprivate = llvm::omp::Clause::OMPC_copyprivate;
+constexpr auto OMPC_copyin = llvm::omp::Clause::OMPC_copyin;
+constexpr auto OMPC_default = llvm::omp::Clause::OMPC_default;
+constexpr auto OMPC_defaultmap = llvm::omp::Clause::OMPC_defaultmap;
+constexpr auto OMPC_depend = llvm::omp::Clause::OMPC_depend;
+constexpr auto OMPC_depobj = llvm::omp::Clause::OMPC_depobj;
+constexpr auto OMPC_destroy = llvm::omp::Clause::OMPC_destroy;
+constexpr auto OMPC_detach = llvm::omp::Clause::OMPC_detach;
+constexpr auto OMPC_device = llvm::omp::Clause::OMPC_device;
+constexpr auto OMPC_device_type = llvm::omp::Clause::OMPC_device_type;
+constexpr auto OMPC_dist_schedule = llvm::omp::Clause::OMPC_dist_schedule;
+constexpr auto OMPC_dynamic_allocators = llvm::omp::Clause::OMPC_dynamic_allocators;
+constexpr auto OMPC_exclusive = llvm::omp::Clause::OMPC_exclusive;
+constexpr auto OMPC_final = llvm::omp::Clause::OMPC_final;
+constexpr auto OMPC_firstprivate = llvm::omp::Clause::OMPC_firstprivate;
+constexpr auto OMPC_flush = llvm::omp::Clause::OMPC_flush;
+constexpr auto OMPC_from = llvm::omp::Clause::OMPC_from;
+constexpr auto OMPC_grainsize = llvm::omp::Clause::OMPC_grainsize;
+constexpr auto OMPC_hint = llvm::omp::Clause::OMPC_hint;
+constexpr auto OMPC_if = llvm::omp::Clause::OMPC_if;
+constexpr auto OMPC_in_reduction = llvm::omp::Clause::OMPC_in_reduction;
+constexpr auto OMPC_inbranch = llvm::omp::Clause::OMPC_inbranch;
+constexpr auto OMPC_inclusive = llvm::omp::Clause::OMPC_inclusive;
+constexpr auto OMPC_is_device_ptr = llvm::omp::Clause::OMPC_is_device_ptr;
+constexpr auto OMPC_lastprivate = llvm::omp::Clause::OMPC_lastprivate;
+constexpr auto OMPC_linear = llvm::omp::Clause::OMPC_linear;
+constexpr auto OMPC_link = llvm::omp::Clause::OMPC_link;
+constexpr auto OMPC_map = llvm::omp::Clause::OMPC_map;
+constexpr auto OMPC_match = llvm::omp::Clause::OMPC_match;
+constexpr auto OMPC_mergeable = llvm::omp::Clause::OMPC_mergeable;
+constexpr auto OMPC_nogroup = llvm::omp::Clause::OMPC_nogroup;
+constexpr auto OMPC_nowait = llvm::omp::Clause::OMPC_nowait;
+constexpr auto OMPC_nontemporal = llvm::omp::Clause::OMPC_nontemporal;
+constexpr auto OMPC_notinbranch = llvm::omp::Clause::OMPC_notinbranch;
+constexpr auto OMPC_num_tasks = llvm::omp::Clause::OMPC_num_tasks;
+constexpr auto OMPC_num_teams = llvm::omp::Clause::OMPC_num_teams;
+constexpr auto OMPC_num_threads = llvm::omp::Clause::OMPC_num_threads;
+constexpr auto OMPC_order = llvm::omp::Clause::OMPC_order;
+constexpr auto OMPC_ordered = llvm::omp::Clause::OMPC_ordered;
+constexpr auto OMPC_priority = llvm::omp::Clause::OMPC_priority;
+constexpr auto OMPC_private = llvm::omp::Clause::OMPC_private;
+constexpr auto OMPC_proc_bind = llvm::omp::Clause::OMPC_proc_bind;
+constexpr auto OMPC_read = llvm::omp::Clause::OMPC_read;
+constexpr auto OMPC_reduction = llvm::omp::Clause::OMPC_reduction;
+constexpr auto OMPC_relaxed = llvm::omp::Clause::OMPC_relaxed;
+constexpr auto OMPC_release = llvm::omp::Clause::OMPC_release;
+constexpr auto OMPC_reverse_offload = llvm::omp::Clause::OMPC_reverse_offload;
+constexpr auto OMPC_safelen = llvm::omp::Clause::OMPC_safelen;
+constexpr auto OMPC_schedule = llvm::omp::Clause::OMPC_schedule;
+constexpr auto OMPC_seq_cst = llvm::omp::Clause::OMPC_seq_cst;
+constexpr auto OMPC_shared = llvm::omp::Clause::OMPC_shared;
+constexpr auto OMPC_simd = llvm::omp::Clause::OMPC_simd;
+constexpr auto OMPC_simdlen = llvm::omp::Clause::OMPC_simdlen;
+constexpr auto OMPC_task_reduction = llvm::omp::Clause::OMPC_task_reduction;
+constexpr auto OMPC_thread_limit = llvm::omp::Clause::OMPC_thread_limit;
+constexpr auto OMPC_threadprivate = llvm::omp::Clause::OMPC_threadprivate;
+constexpr auto OMPC_threads = llvm::omp::Clause::OMPC_threads;
+constexpr auto OMPC_to = llvm::omp::Clause::OMPC_to;
+constexpr auto OMPC_unified_address = llvm::omp::Clause::OMPC_unified_address;
+constexpr auto OMPC_unified_shared_memory = llvm::omp::Clause::OMPC_unified_shared_memory;
+constexpr auto OMPC_uniform = llvm::omp::Clause::OMPC_uniform;
+constexpr auto OMPC_unknown = llvm::omp::Clause::OMPC_unknown;
+constexpr auto OMPC_untied = llvm::omp::Clause::OMPC_untied;
+constexpr auto OMPC_update = llvm::omp::Clause::OMPC_update;
+constexpr auto OMPC_use_device_addr = llvm::omp::Clause::OMPC_use_device_addr;
+constexpr auto OMPC_use_device_ptr = llvm::omp::Clause::OMPC_use_device_ptr;
+constexpr auto OMPC_uses_allocators = llvm::omp::Clause::OMPC_uses_allocators;
+constexpr auto OMPC_write = llvm::omp::Clause::OMPC_write;
+
+enum class OrderKind {
+  OMP_ORDER_concurrent=2,
+};
+
+constexpr auto OMP_ORDER_concurrent = llvm::omp::OrderKind::OMP_ORDER_concurrent;
+
+enum class ProcBindKind {
+  OMP_PROC_BIND_master=2,
+  OMP_PROC_BIND_close=3,
+  OMP_PROC_BIND_spread=4,
+  OMP_PROC_BIND_default=5,
+  OMP_PROC_BIND_unknown=6,
+};
+
+constexpr auto OMP_PROC_BIND_master = llvm::omp::ProcBindKind::OMP_PROC_BIND_master;
+constexpr auto OMP_PROC_BIND_close = llvm::omp::ProcBindKind::OMP_PROC_BIND_close;
+constexpr auto OMP_PROC_BIND_spread = llvm::omp::ProcBindKind::OMP_PROC_BIND_spread;
+constexpr auto OMP_PROC_BIND_default = llvm::omp::ProcBindKind::OMP_PROC_BIND_default;
+constexpr auto OMP_PROC_BIND_unknown = llvm::omp::ProcBindKind::OMP_PROC_BIND_unknown;
+
+enum class ScheduleKind {
+  OMP_SCHEDULE_Static=2,
+  OMP_SCHEDULE_Dynamic=3,
+  OMP_SCHEDULE_Guided=4,
+  OMP_SCHEDULE_Auto=5,
+  OMP_SCHEDULE_Runtime=6,
+  OMP_SCHEDULE_Default=7,
+};
+
+constexpr auto OMP_SCHEDULE_Static = llvm::omp::ScheduleKind::OMP_SCHEDULE_Static;
+constexpr auto OMP_SCHEDULE_Dynamic = llvm::omp::ScheduleKind::OMP_SCHEDULE_Dynamic;
+constexpr auto OMP_SCHEDULE_Guided = llvm::omp::ScheduleKind::OMP_SCHEDULE_Guided;
+constexpr auto OMP_SCHEDULE_Auto = llvm::omp::ScheduleKind::OMP_SCHEDULE_Auto;
+constexpr auto OMP_SCHEDULE_Runtime = llvm::omp::ScheduleKind::OMP_SCHEDULE_Runtime;
+constexpr auto OMP_SCHEDULE_Default = llvm::omp::ScheduleKind::OMP_SCHEDULE_Default;
+
+// Enumeration helper functions
+Directive getOpenMPDirectiveKind(llvm::StringRef Str);
+
+llvm::StringRef getOpenMPDirectiveName(Directive D);
+
+Clause getOpenMPClauseKind(llvm::StringRef Str);
+
+llvm::StringRef getOpenMPClauseName(Clause C);
+
+/// Return true if \p C is a valid clause for \p D in version \p Version.
+bool isAllowedClauseForDirective(Directive D, Clause C, unsigned Version);
+
+OrderKind getOrderKind(StringRef);
+llvm::StringRef getOpenMPOrderKindName(OrderKind);
+ProcBindKind getProcBindKind(StringRef);
+llvm::StringRef getOpenMPProcBindKindName(ProcBindKind);
+ScheduleKind getScheduleKind(StringRef);
+llvm::StringRef getOpenMPScheduleKindName(ScheduleKind);
+
+} // namespace omp
+} // namespace llvm
+#endif // LLVM_OpenMP_INC
diff --git a/linux-x64/clang/include/llvm/Frontend/OpenMP/OMP.inc b/linux-x64/clang/include/llvm/Frontend/OpenMP/OMP.inc
new file mode 100644
index 0000000..80df71a
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Frontend/OpenMP/OMP.inc
@@ -0,0 +1,3451 @@
+#ifdef GEN_FLANG_DIRECTIVE_CLAUSE_SETS
+#undef GEN_FLANG_DIRECTIVE_CLAUSE_SETS
+
+namespace llvm {
+namespace omp {
+
+  // Sets for allocate
+
+  static OmpClauseSet allowedClauses_OMPD_allocate {
+    llvm::omp::Clause::OMPC_allocator,
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_allocate {
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_allocate {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_allocate {
+  };
+
+  // Sets for assumes
+
+  static OmpClauseSet allowedClauses_OMPD_assumes {
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_assumes {
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_assumes {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_assumes {
+  };
+
+  // Sets for atomic
+
+  static OmpClauseSet allowedClauses_OMPD_atomic {
+    llvm::omp::Clause::OMPC_read,
+    llvm::omp::Clause::OMPC_write,
+    llvm::omp::Clause::OMPC_update,
+    llvm::omp::Clause::OMPC_capture,
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_atomic {
+    llvm::omp::Clause::OMPC_seq_cst,
+    llvm::omp::Clause::OMPC_acq_rel,
+    llvm::omp::Clause::OMPC_acquire,
+    llvm::omp::Clause::OMPC_release,
+    llvm::omp::Clause::OMPC_relaxed,
+    llvm::omp::Clause::OMPC_hint,
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_atomic {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_atomic {
+  };
+
+  // Sets for barrier
+
+  static OmpClauseSet allowedClauses_OMPD_barrier {
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_barrier {
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_barrier {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_barrier {
+  };
+
+  // Sets for begin assumes
+
+  static OmpClauseSet allowedClauses_OMPD_begin_assumes {
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_begin_assumes {
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_begin_assumes {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_begin_assumes {
+  };
+
+  // Sets for begin declare variant
+
+  static OmpClauseSet allowedClauses_OMPD_begin_declare_variant {
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_begin_declare_variant {
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_begin_declare_variant {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_begin_declare_variant {
+  };
+
+  // Sets for cancel
+
+  static OmpClauseSet allowedClauses_OMPD_cancel {
+    llvm::omp::Clause::OMPC_if,
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_cancel {
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_cancel {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_cancel {
+  };
+
+  // Sets for cancellation point
+
+  static OmpClauseSet allowedClauses_OMPD_cancellation_point {
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_cancellation_point {
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_cancellation_point {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_cancellation_point {
+  };
+
+  // Sets for critical
+
+  static OmpClauseSet allowedClauses_OMPD_critical {
+    llvm::omp::Clause::OMPC_hint,
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_critical {
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_critical {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_critical {
+  };
+
+  // Sets for declare mapper
+
+  static OmpClauseSet allowedClauses_OMPD_declare_mapper {
+    llvm::omp::Clause::OMPC_map,
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_declare_mapper {
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_declare_mapper {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_declare_mapper {
+  };
+
+  // Sets for declare reduction
+
+  static OmpClauseSet allowedClauses_OMPD_declare_reduction {
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_declare_reduction {
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_declare_reduction {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_declare_reduction {
+  };
+
+  // Sets for declare simd
+
+  static OmpClauseSet allowedClauses_OMPD_declare_simd {
+    llvm::omp::Clause::OMPC_linear,
+    llvm::omp::Clause::OMPC_aligned,
+    llvm::omp::Clause::OMPC_uniform,
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_declare_simd {
+    llvm::omp::Clause::OMPC_simdlen,
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_declare_simd {
+    llvm::omp::Clause::OMPC_inbranch,
+    llvm::omp::Clause::OMPC_notinbranch,
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_declare_simd {
+  };
+
+  // Sets for declare target
+
+  static OmpClauseSet allowedClauses_OMPD_declare_target {
+    llvm::omp::Clause::OMPC_to,
+    llvm::omp::Clause::OMPC_link,
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_declare_target {
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_declare_target {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_declare_target {
+  };
+
+  // Sets for declare variant
+
+  static OmpClauseSet allowedClauses_OMPD_declare_variant {
+    llvm::omp::Clause::OMPC_match,
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_declare_variant {
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_declare_variant {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_declare_variant {
+  };
+
+  // Sets for depobj
+
+  static OmpClauseSet allowedClauses_OMPD_depobj {
+    llvm::omp::Clause::OMPC_depend,
+    llvm::omp::Clause::OMPC_destroy,
+    llvm::omp::Clause::OMPC_update,
+    llvm::omp::Clause::OMPC_depobj,
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_depobj {
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_depobj {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_depobj {
+  };
+
+  // Sets for distribute
+
+  static OmpClauseSet allowedClauses_OMPD_distribute {
+    llvm::omp::Clause::OMPC_private,
+    llvm::omp::Clause::OMPC_firstprivate,
+    llvm::omp::Clause::OMPC_lastprivate,
+    llvm::omp::Clause::OMPC_allocate,
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_distribute {
+    llvm::omp::Clause::OMPC_collapse,
+    llvm::omp::Clause::OMPC_dist_schedule,
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_distribute {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_distribute {
+  };
+
+  // Sets for distribute parallel do
+
+  static OmpClauseSet allowedClauses_OMPD_distribute_parallel_do {
+    llvm::omp::Clause::OMPC_private,
+    llvm::omp::Clause::OMPC_firstprivate,
+    llvm::omp::Clause::OMPC_lastprivate,
+    llvm::omp::Clause::OMPC_allocate,
+    llvm::omp::Clause::OMPC_order,
+    llvm::omp::Clause::OMPC_default,
+    llvm::omp::Clause::OMPC_shared,
+    llvm::omp::Clause::OMPC_reduction,
+    llvm::omp::Clause::OMPC_copyin,
+    llvm::omp::Clause::OMPC_linear,
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_distribute_parallel_do {
+    llvm::omp::Clause::OMPC_collapse,
+    llvm::omp::Clause::OMPC_dist_schedule,
+    llvm::omp::Clause::OMPC_if,
+    llvm::omp::Clause::OMPC_num_threads,
+    llvm::omp::Clause::OMPC_proc_bind,
+    llvm::omp::Clause::OMPC_schedule,
+    llvm::omp::Clause::OMPC_ordered,
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_distribute_parallel_do {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_distribute_parallel_do {
+  };
+
+  // Sets for distribute parallel do simd
+
+  static OmpClauseSet allowedClauses_OMPD_distribute_parallel_do_simd {
+    llvm::omp::Clause::OMPC_firstprivate,
+    llvm::omp::Clause::OMPC_lastprivate,
+    llvm::omp::Clause::OMPC_collapse,
+    llvm::omp::Clause::OMPC_dist_schedule,
+    llvm::omp::Clause::OMPC_if,
+    llvm::omp::Clause::OMPC_num_threads,
+    llvm::omp::Clause::OMPC_default,
+    llvm::omp::Clause::OMPC_proc_bind,
+    llvm::omp::Clause::OMPC_private,
+    llvm::omp::Clause::OMPC_shared,
+    llvm::omp::Clause::OMPC_reduction,
+    llvm::omp::Clause::OMPC_copyin,
+    llvm::omp::Clause::OMPC_schedule,
+    llvm::omp::Clause::OMPC_linear,
+    llvm::omp::Clause::OMPC_aligned,
+    llvm::omp::Clause::OMPC_safelen,
+    llvm::omp::Clause::OMPC_simdlen,
+    llvm::omp::Clause::OMPC_allocate,
+    llvm::omp::Clause::OMPC_nontemporal,
+    llvm::omp::Clause::OMPC_order,
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_distribute_parallel_do_simd {
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_distribute_parallel_do_simd {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_distribute_parallel_do_simd {
+  };
+
+  // Sets for distribute parallel for
+
+  static OmpClauseSet allowedClauses_OMPD_distribute_parallel_for {
+    llvm::omp::Clause::OMPC_firstprivate,
+    llvm::omp::Clause::OMPC_lastprivate,
+    llvm::omp::Clause::OMPC_collapse,
+    llvm::omp::Clause::OMPC_dist_schedule,
+    llvm::omp::Clause::OMPC_if,
+    llvm::omp::Clause::OMPC_num_threads,
+    llvm::omp::Clause::OMPC_default,
+    llvm::omp::Clause::OMPC_proc_bind,
+    llvm::omp::Clause::OMPC_private,
+    llvm::omp::Clause::OMPC_shared,
+    llvm::omp::Clause::OMPC_reduction,
+    llvm::omp::Clause::OMPC_copyin,
+    llvm::omp::Clause::OMPC_schedule,
+    llvm::omp::Clause::OMPC_allocate,
+    llvm::omp::Clause::OMPC_order,
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_distribute_parallel_for {
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_distribute_parallel_for {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_distribute_parallel_for {
+  };
+
+  // Sets for distribute parallel for simd
+
+  static OmpClauseSet allowedClauses_OMPD_distribute_parallel_for_simd {
+    llvm::omp::Clause::OMPC_firstprivate,
+    llvm::omp::Clause::OMPC_lastprivate,
+    llvm::omp::Clause::OMPC_collapse,
+    llvm::omp::Clause::OMPC_dist_schedule,
+    llvm::omp::Clause::OMPC_if,
+    llvm::omp::Clause::OMPC_num_threads,
+    llvm::omp::Clause::OMPC_default,
+    llvm::omp::Clause::OMPC_proc_bind,
+    llvm::omp::Clause::OMPC_private,
+    llvm::omp::Clause::OMPC_shared,
+    llvm::omp::Clause::OMPC_reduction,
+    llvm::omp::Clause::OMPC_copyin,
+    llvm::omp::Clause::OMPC_schedule,
+    llvm::omp::Clause::OMPC_linear,
+    llvm::omp::Clause::OMPC_aligned,
+    llvm::omp::Clause::OMPC_safelen,
+    llvm::omp::Clause::OMPC_simdlen,
+    llvm::omp::Clause::OMPC_allocate,
+    llvm::omp::Clause::OMPC_nontemporal,
+    llvm::omp::Clause::OMPC_order,
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_distribute_parallel_for_simd {
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_distribute_parallel_for_simd {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_distribute_parallel_for_simd {
+  };
+
+  // Sets for distribute simd
+
+  static OmpClauseSet allowedClauses_OMPD_distribute_simd {
+    llvm::omp::Clause::OMPC_aligned,
+    llvm::omp::Clause::OMPC_allocate,
+    llvm::omp::Clause::OMPC_copyin,
+    llvm::omp::Clause::OMPC_default,
+    llvm::omp::Clause::OMPC_linear,
+    llvm::omp::Clause::OMPC_firstprivate,
+    llvm::omp::Clause::OMPC_lastprivate,
+    llvm::omp::Clause::OMPC_nontemporal,
+    llvm::omp::Clause::OMPC_order,
+    llvm::omp::Clause::OMPC_private,
+    llvm::omp::Clause::OMPC_reduction,
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_distribute_simd {
+    llvm::omp::Clause::OMPC_collapse,
+    llvm::omp::Clause::OMPC_dist_schedule,
+    llvm::omp::Clause::OMPC_if,
+    llvm::omp::Clause::OMPC_num_threads,
+    llvm::omp::Clause::OMPC_ordered,
+    llvm::omp::Clause::OMPC_proc_bind,
+    llvm::omp::Clause::OMPC_schedule,
+    llvm::omp::Clause::OMPC_safelen,
+    llvm::omp::Clause::OMPC_simdlen,
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_distribute_simd {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_distribute_simd {
+  };
+
+  // Sets for do
+
+  static OmpClauseSet allowedClauses_OMPD_do {
+    llvm::omp::Clause::OMPC_private,
+    llvm::omp::Clause::OMPC_firstprivate,
+    llvm::omp::Clause::OMPC_lastprivate,
+    llvm::omp::Clause::OMPC_linear,
+    llvm::omp::Clause::OMPC_reduction,
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_do {
+    llvm::omp::Clause::OMPC_schedule,
+    llvm::omp::Clause::OMPC_collapse,
+    llvm::omp::Clause::OMPC_ordered,
+    llvm::omp::Clause::OMPC_nowait,
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_do {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_do {
+  };
+
+  // Sets for do simd
+
+  static OmpClauseSet allowedClauses_OMPD_do_simd {
+    llvm::omp::Clause::OMPC_aligned,
+    llvm::omp::Clause::OMPC_private,
+    llvm::omp::Clause::OMPC_firstprivate,
+    llvm::omp::Clause::OMPC_lastprivate,
+    llvm::omp::Clause::OMPC_linear,
+    llvm::omp::Clause::OMPC_reduction,
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_do_simd {
+    llvm::omp::Clause::OMPC_schedule,
+    llvm::omp::Clause::OMPC_collapse,
+    llvm::omp::Clause::OMPC_ordered,
+    llvm::omp::Clause::OMPC_safelen,
+    llvm::omp::Clause::OMPC_simdlen,
+    llvm::omp::Clause::OMPC_nowait,
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_do_simd {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_do_simd {
+  };
+
+  // Sets for end assumes
+
+  static OmpClauseSet allowedClauses_OMPD_end_assumes {
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_end_assumes {
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_end_assumes {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_end_assumes {
+  };
+
+  // Sets for end declare target
+
+  static OmpClauseSet allowedClauses_OMPD_end_declare_target {
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_end_declare_target {
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_end_declare_target {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_end_declare_target {
+  };
+
+  // Sets for end declare variant
+
+  static OmpClauseSet allowedClauses_OMPD_end_declare_variant {
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_end_declare_variant {
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_end_declare_variant {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_end_declare_variant {
+  };
+
+  // Sets for end do
+
+  static OmpClauseSet allowedClauses_OMPD_end_do {
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_end_do {
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_end_do {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_end_do {
+  };
+
+  // Sets for end do simd
+
+  static OmpClauseSet allowedClauses_OMPD_end_do_simd {
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_end_do_simd {
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_end_do_simd {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_end_do_simd {
+  };
+
+  // Sets for end sections
+
+  static OmpClauseSet allowedClauses_OMPD_end_sections {
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_end_sections {
+    llvm::omp::Clause::OMPC_nowait,
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_end_sections {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_end_sections {
+  };
+
+  // Sets for end single
+
+  static OmpClauseSet allowedClauses_OMPD_end_single {
+    llvm::omp::Clause::OMPC_copyprivate,
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_end_single {
+    llvm::omp::Clause::OMPC_nowait,
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_end_single {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_end_single {
+  };
+
+  // Sets for end workshare
+
+  static OmpClauseSet allowedClauses_OMPD_end_workshare {
+    llvm::omp::Clause::OMPC_nowait,
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_end_workshare {
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_end_workshare {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_end_workshare {
+  };
+
+  // Sets for flush
+
+  static OmpClauseSet allowedClauses_OMPD_flush {
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_flush {
+    llvm::omp::Clause::OMPC_acq_rel,
+    llvm::omp::Clause::OMPC_acquire,
+    llvm::omp::Clause::OMPC_release,
+    llvm::omp::Clause::OMPC_flush,
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_flush {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_flush {
+  };
+
+  // Sets for for
+
+  static OmpClauseSet allowedClauses_OMPD_for {
+    llvm::omp::Clause::OMPC_private,
+    llvm::omp::Clause::OMPC_lastprivate,
+    llvm::omp::Clause::OMPC_firstprivate,
+    llvm::omp::Clause::OMPC_reduction,
+    llvm::omp::Clause::OMPC_collapse,
+    llvm::omp::Clause::OMPC_schedule,
+    llvm::omp::Clause::OMPC_ordered,
+    llvm::omp::Clause::OMPC_nowait,
+    llvm::omp::Clause::OMPC_linear,
+    llvm::omp::Clause::OMPC_allocate,
+    llvm::omp::Clause::OMPC_order,
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_for {
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_for {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_for {
+  };
+
+  // Sets for for simd
+
+  static OmpClauseSet allowedClauses_OMPD_for_simd {
+    llvm::omp::Clause::OMPC_private,
+    llvm::omp::Clause::OMPC_firstprivate,
+    llvm::omp::Clause::OMPC_lastprivate,
+    llvm::omp::Clause::OMPC_reduction,
+    llvm::omp::Clause::OMPC_schedule,
+    llvm::omp::Clause::OMPC_collapse,
+    llvm::omp::Clause::OMPC_nowait,
+    llvm::omp::Clause::OMPC_safelen,
+    llvm::omp::Clause::OMPC_simdlen,
+    llvm::omp::Clause::OMPC_linear,
+    llvm::omp::Clause::OMPC_aligned,
+    llvm::omp::Clause::OMPC_ordered,
+    llvm::omp::Clause::OMPC_allocate,
+    llvm::omp::Clause::OMPC_if,
+    llvm::omp::Clause::OMPC_nontemporal,
+    llvm::omp::Clause::OMPC_order,
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_for_simd {
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_for_simd {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_for_simd {
+  };
+
+  // Sets for master
+
+  static OmpClauseSet allowedClauses_OMPD_master {
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_master {
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_master {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_master {
+  };
+
+  // Sets for master taskloop
+
+  static OmpClauseSet allowedClauses_OMPD_master_taskloop {
+    llvm::omp::Clause::OMPC_if,
+    llvm::omp::Clause::OMPC_shared,
+    llvm::omp::Clause::OMPC_private,
+    llvm::omp::Clause::OMPC_firstprivate,
+    llvm::omp::Clause::OMPC_lastprivate,
+    llvm::omp::Clause::OMPC_default,
+    llvm::omp::Clause::OMPC_collapse,
+    llvm::omp::Clause::OMPC_final,
+    llvm::omp::Clause::OMPC_untied,
+    llvm::omp::Clause::OMPC_mergeable,
+    llvm::omp::Clause::OMPC_priority,
+    llvm::omp::Clause::OMPC_grainsize,
+    llvm::omp::Clause::OMPC_nogroup,
+    llvm::omp::Clause::OMPC_num_tasks,
+    llvm::omp::Clause::OMPC_reduction,
+    llvm::omp::Clause::OMPC_in_reduction,
+    llvm::omp::Clause::OMPC_allocate,
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_master_taskloop {
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_master_taskloop {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_master_taskloop {
+  };
+
+  // Sets for master taskloop simd
+
+  static OmpClauseSet allowedClauses_OMPD_master_taskloop_simd {
+    llvm::omp::Clause::OMPC_if,
+    llvm::omp::Clause::OMPC_shared,
+    llvm::omp::Clause::OMPC_private,
+    llvm::omp::Clause::OMPC_firstprivate,
+    llvm::omp::Clause::OMPC_lastprivate,
+    llvm::omp::Clause::OMPC_default,
+    llvm::omp::Clause::OMPC_collapse,
+    llvm::omp::Clause::OMPC_final,
+    llvm::omp::Clause::OMPC_untied,
+    llvm::omp::Clause::OMPC_mergeable,
+    llvm::omp::Clause::OMPC_priority,
+    llvm::omp::Clause::OMPC_linear,
+    llvm::omp::Clause::OMPC_aligned,
+    llvm::omp::Clause::OMPC_safelen,
+    llvm::omp::Clause::OMPC_simdlen,
+    llvm::omp::Clause::OMPC_grainsize,
+    llvm::omp::Clause::OMPC_nogroup,
+    llvm::omp::Clause::OMPC_num_tasks,
+    llvm::omp::Clause::OMPC_reduction,
+    llvm::omp::Clause::OMPC_in_reduction,
+    llvm::omp::Clause::OMPC_allocate,
+    llvm::omp::Clause::OMPC_nontemporal,
+    llvm::omp::Clause::OMPC_order,
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_master_taskloop_simd {
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_master_taskloop_simd {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_master_taskloop_simd {
+  };
+
+  // Sets for ordered
+
+  static OmpClauseSet allowedClauses_OMPD_ordered {
+    llvm::omp::Clause::OMPC_threads,
+    llvm::omp::Clause::OMPC_simd,
+    llvm::omp::Clause::OMPC_depend,
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_ordered {
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_ordered {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_ordered {
+  };
+
+  // Sets for parallel
+
+  static OmpClauseSet allowedClauses_OMPD_parallel {
+    llvm::omp::Clause::OMPC_private,
+    llvm::omp::Clause::OMPC_firstprivate,
+    llvm::omp::Clause::OMPC_shared,
+    llvm::omp::Clause::OMPC_reduction,
+    llvm::omp::Clause::OMPC_copyin,
+    llvm::omp::Clause::OMPC_allocate,
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_parallel {
+    llvm::omp::Clause::OMPC_default,
+    llvm::omp::Clause::OMPC_if,
+    llvm::omp::Clause::OMPC_num_threads,
+    llvm::omp::Clause::OMPC_proc_bind,
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_parallel {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_parallel {
+  };
+
+  // Sets for parallel do
+
+  static OmpClauseSet allowedClauses_OMPD_parallel_do {
+    llvm::omp::Clause::OMPC_default,
+    llvm::omp::Clause::OMPC_private,
+    llvm::omp::Clause::OMPC_firstprivate,
+    llvm::omp::Clause::OMPC_shared,
+    llvm::omp::Clause::OMPC_reduction,
+    llvm::omp::Clause::OMPC_copyin,
+    llvm::omp::Clause::OMPC_lastprivate,
+    llvm::omp::Clause::OMPC_linear,
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_parallel_do {
+    llvm::omp::Clause::OMPC_if,
+    llvm::omp::Clause::OMPC_num_threads,
+    llvm::omp::Clause::OMPC_proc_bind,
+    llvm::omp::Clause::OMPC_schedule,
+    llvm::omp::Clause::OMPC_ordered,
+    llvm::omp::Clause::OMPC_collapse,
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_parallel_do {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_parallel_do {
+  };
+
+  // Sets for parallel do simd
+
+  static OmpClauseSet allowedClauses_OMPD_parallel_do_simd {
+    llvm::omp::Clause::OMPC_default,
+    llvm::omp::Clause::OMPC_private,
+    llvm::omp::Clause::OMPC_firstprivate,
+    llvm::omp::Clause::OMPC_shared,
+    llvm::omp::Clause::OMPC_reduction,
+    llvm::omp::Clause::OMPC_copyin,
+    llvm::omp::Clause::OMPC_lastprivate,
+    llvm::omp::Clause::OMPC_linear,
+    llvm::omp::Clause::OMPC_aligned,
+    llvm::omp::Clause::OMPC_allocate,
+    llvm::omp::Clause::OMPC_nontemporal,
+    llvm::omp::Clause::OMPC_order,
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_parallel_do_simd {
+    llvm::omp::Clause::OMPC_if,
+    llvm::omp::Clause::OMPC_num_threads,
+    llvm::omp::Clause::OMPC_proc_bind,
+    llvm::omp::Clause::OMPC_schedule,
+    llvm::omp::Clause::OMPC_ordered,
+    llvm::omp::Clause::OMPC_collapse,
+    llvm::omp::Clause::OMPC_safelen,
+    llvm::omp::Clause::OMPC_simdlen,
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_parallel_do_simd {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_parallel_do_simd {
+  };
+
+  // Sets for parallel for
+
+  static OmpClauseSet allowedClauses_OMPD_parallel_for {
+    llvm::omp::Clause::OMPC_if,
+    llvm::omp::Clause::OMPC_num_threads,
+    llvm::omp::Clause::OMPC_default,
+    llvm::omp::Clause::OMPC_proc_bind,
+    llvm::omp::Clause::OMPC_private,
+    llvm::omp::Clause::OMPC_firstprivate,
+    llvm::omp::Clause::OMPC_shared,
+    llvm::omp::Clause::OMPC_reduction,
+    llvm::omp::Clause::OMPC_copyin,
+    llvm::omp::Clause::OMPC_lastprivate,
+    llvm::omp::Clause::OMPC_collapse,
+    llvm::omp::Clause::OMPC_schedule,
+    llvm::omp::Clause::OMPC_ordered,
+    llvm::omp::Clause::OMPC_linear,
+    llvm::omp::Clause::OMPC_allocate,
+    llvm::omp::Clause::OMPC_order,
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_parallel_for {
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_parallel_for {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_parallel_for {
+  };
+
+  // Sets for parallel for simd
+
+  static OmpClauseSet allowedClauses_OMPD_parallel_for_simd {
+    llvm::omp::Clause::OMPC_if,
+    llvm::omp::Clause::OMPC_num_threads,
+    llvm::omp::Clause::OMPC_default,
+    llvm::omp::Clause::OMPC_proc_bind,
+    llvm::omp::Clause::OMPC_private,
+    llvm::omp::Clause::OMPC_firstprivate,
+    llvm::omp::Clause::OMPC_shared,
+    llvm::omp::Clause::OMPC_reduction,
+    llvm::omp::Clause::OMPC_copyin,
+    llvm::omp::Clause::OMPC_lastprivate,
+    llvm::omp::Clause::OMPC_collapse,
+    llvm::omp::Clause::OMPC_schedule,
+    llvm::omp::Clause::OMPC_safelen,
+    llvm::omp::Clause::OMPC_simdlen,
+    llvm::omp::Clause::OMPC_linear,
+    llvm::omp::Clause::OMPC_aligned,
+    llvm::omp::Clause::OMPC_ordered,
+    llvm::omp::Clause::OMPC_allocate,
+    llvm::omp::Clause::OMPC_nontemporal,
+    llvm::omp::Clause::OMPC_order,
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_parallel_for_simd {
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_parallel_for_simd {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_parallel_for_simd {
+  };
+
+  // Sets for parallel master
+
+  static OmpClauseSet allowedClauses_OMPD_parallel_master {
+    llvm::omp::Clause::OMPC_if,
+    llvm::omp::Clause::OMPC_num_threads,
+    llvm::omp::Clause::OMPC_default,
+    llvm::omp::Clause::OMPC_private,
+    llvm::omp::Clause::OMPC_firstprivate,
+    llvm::omp::Clause::OMPC_shared,
+    llvm::omp::Clause::OMPC_copyin,
+    llvm::omp::Clause::OMPC_reduction,
+    llvm::omp::Clause::OMPC_proc_bind,
+    llvm::omp::Clause::OMPC_allocate,
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_parallel_master {
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_parallel_master {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_parallel_master {
+  };
+
+  // Sets for parallel master taskloop
+
+  static OmpClauseSet allowedClauses_OMPD_parallel_master_taskloop {
+    llvm::omp::Clause::OMPC_if,
+    llvm::omp::Clause::OMPC_shared,
+    llvm::omp::Clause::OMPC_private,
+    llvm::omp::Clause::OMPC_firstprivate,
+    llvm::omp::Clause::OMPC_lastprivate,
+    llvm::omp::Clause::OMPC_default,
+    llvm::omp::Clause::OMPC_collapse,
+    llvm::omp::Clause::OMPC_final,
+    llvm::omp::Clause::OMPC_untied,
+    llvm::omp::Clause::OMPC_mergeable,
+    llvm::omp::Clause::OMPC_priority,
+    llvm::omp::Clause::OMPC_grainsize,
+    llvm::omp::Clause::OMPC_nogroup,
+    llvm::omp::Clause::OMPC_num_tasks,
+    llvm::omp::Clause::OMPC_reduction,
+    llvm::omp::Clause::OMPC_allocate,
+    llvm::omp::Clause::OMPC_num_threads,
+    llvm::omp::Clause::OMPC_proc_bind,
+    llvm::omp::Clause::OMPC_copyin,
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_parallel_master_taskloop {
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_parallel_master_taskloop {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_parallel_master_taskloop {
+  };
+
+  // Sets for parallel master taskloop simd
+
+  static OmpClauseSet allowedClauses_OMPD_parallel_master_taskloop_simd {
+    llvm::omp::Clause::OMPC_if,
+    llvm::omp::Clause::OMPC_shared,
+    llvm::omp::Clause::OMPC_private,
+    llvm::omp::Clause::OMPC_firstprivate,
+    llvm::omp::Clause::OMPC_lastprivate,
+    llvm::omp::Clause::OMPC_default,
+    llvm::omp::Clause::OMPC_collapse,
+    llvm::omp::Clause::OMPC_final,
+    llvm::omp::Clause::OMPC_untied,
+    llvm::omp::Clause::OMPC_mergeable,
+    llvm::omp::Clause::OMPC_priority,
+    llvm::omp::Clause::OMPC_grainsize,
+    llvm::omp::Clause::OMPC_nogroup,
+    llvm::omp::Clause::OMPC_num_tasks,
+    llvm::omp::Clause::OMPC_reduction,
+    llvm::omp::Clause::OMPC_allocate,
+    llvm::omp::Clause::OMPC_num_threads,
+    llvm::omp::Clause::OMPC_proc_bind,
+    llvm::omp::Clause::OMPC_copyin,
+    llvm::omp::Clause::OMPC_linear,
+    llvm::omp::Clause::OMPC_aligned,
+    llvm::omp::Clause::OMPC_safelen,
+    llvm::omp::Clause::OMPC_simdlen,
+    llvm::omp::Clause::OMPC_nontemporal,
+    llvm::omp::Clause::OMPC_order,
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_parallel_master_taskloop_simd {
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_parallel_master_taskloop_simd {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_parallel_master_taskloop_simd {
+  };
+
+  // Sets for parallel sections
+
+  static OmpClauseSet allowedClauses_OMPD_parallel_sections {
+    llvm::omp::Clause::OMPC_if,
+    llvm::omp::Clause::OMPC_default,
+    llvm::omp::Clause::OMPC_proc_bind,
+    llvm::omp::Clause::OMPC_private,
+    llvm::omp::Clause::OMPC_firstprivate,
+    llvm::omp::Clause::OMPC_shared,
+    llvm::omp::Clause::OMPC_reduction,
+    llvm::omp::Clause::OMPC_copyin,
+    llvm::omp::Clause::OMPC_lastprivate,
+    llvm::omp::Clause::OMPC_allocate,
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_parallel_sections {
+    llvm::omp::Clause::OMPC_num_threads,
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_parallel_sections {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_parallel_sections {
+  };
+
+  // Sets for parallel workshare
+
+  static OmpClauseSet allowedClauses_OMPD_parallel_workshare {
+    llvm::omp::Clause::OMPC_allocate,
+    llvm::omp::Clause::OMPC_copyin,
+    llvm::omp::Clause::OMPC_default,
+    llvm::omp::Clause::OMPC_firstprivate,
+    llvm::omp::Clause::OMPC_private,
+    llvm::omp::Clause::OMPC_reduction,
+    llvm::omp::Clause::OMPC_shared,
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_parallel_workshare {
+    llvm::omp::Clause::OMPC_if,
+    llvm::omp::Clause::OMPC_num_threads,
+    llvm::omp::Clause::OMPC_proc_bind,
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_parallel_workshare {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_parallel_workshare {
+  };
+
+  // Sets for requires
+
+  static OmpClauseSet allowedClauses_OMPD_requires {
+    llvm::omp::Clause::OMPC_unified_address,
+    llvm::omp::Clause::OMPC_unified_shared_memory,
+    llvm::omp::Clause::OMPC_reverse_offload,
+    llvm::omp::Clause::OMPC_dynamic_allocators,
+    llvm::omp::Clause::OMPC_atomic_default_mem_order,
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_requires {
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_requires {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_requires {
+  };
+
+  // Sets for scan
+
+  static OmpClauseSet allowedClauses_OMPD_scan {
+    llvm::omp::Clause::OMPC_inclusive,
+    llvm::omp::Clause::OMPC_exclusive,
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_scan {
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_scan {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_scan {
+  };
+
+  // Sets for section
+
+  static OmpClauseSet allowedClauses_OMPD_section {
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_section {
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_section {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_section {
+  };
+
+  // Sets for sections
+
+  static OmpClauseSet allowedClauses_OMPD_sections {
+    llvm::omp::Clause::OMPC_private,
+    llvm::omp::Clause::OMPC_lastprivate,
+    llvm::omp::Clause::OMPC_firstprivate,
+    llvm::omp::Clause::OMPC_reduction,
+    llvm::omp::Clause::OMPC_nowait,
+    llvm::omp::Clause::OMPC_allocate,
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_sections {
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_sections {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_sections {
+  };
+
+  // Sets for simd
+
+  static OmpClauseSet allowedClauses_OMPD_simd {
+    llvm::omp::Clause::OMPC_private,
+    llvm::omp::Clause::OMPC_lastprivate,
+    llvm::omp::Clause::OMPC_linear,
+    llvm::omp::Clause::OMPC_aligned,
+    llvm::omp::Clause::OMPC_reduction,
+    llvm::omp::Clause::OMPC_allocate,
+    llvm::omp::Clause::OMPC_nontemporal,
+    llvm::omp::Clause::OMPC_order,
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_simd {
+    llvm::omp::Clause::OMPC_collapse,
+    llvm::omp::Clause::OMPC_safelen,
+    llvm::omp::Clause::OMPC_simdlen,
+    llvm::omp::Clause::OMPC_if,
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_simd {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_simd {
+  };
+
+  // Sets for single
+
+  static OmpClauseSet allowedClauses_OMPD_single {
+    llvm::omp::Clause::OMPC_private,
+    llvm::omp::Clause::OMPC_firstprivate,
+    llvm::omp::Clause::OMPC_copyprivate,
+    llvm::omp::Clause::OMPC_nowait,
+    llvm::omp::Clause::OMPC_allocate,
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_single {
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_single {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_single {
+  };
+
+  // Sets for target
+
+  static OmpClauseSet allowedClauses_OMPD_target {
+    llvm::omp::Clause::OMPC_if,
+    llvm::omp::Clause::OMPC_map,
+    llvm::omp::Clause::OMPC_private,
+    llvm::omp::Clause::OMPC_depend,
+    llvm::omp::Clause::OMPC_firstprivate,
+    llvm::omp::Clause::OMPC_is_device_ptr,
+    llvm::omp::Clause::OMPC_reduction,
+    llvm::omp::Clause::OMPC_allocate,
+    llvm::omp::Clause::OMPC_uses_allocators,
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_target {
+    llvm::omp::Clause::OMPC_device,
+    llvm::omp::Clause::OMPC_defaultmap,
+    llvm::omp::Clause::OMPC_nowait,
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_target {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_target {
+  };
+
+  // Sets for target data
+
+  static OmpClauseSet allowedClauses_OMPD_target_data {
+    llvm::omp::Clause::OMPC_use_device_ptr,
+    llvm::omp::Clause::OMPC_use_device_addr,
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_target_data {
+    llvm::omp::Clause::OMPC_device,
+    llvm::omp::Clause::OMPC_if,
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_target_data {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_target_data {
+    llvm::omp::Clause::OMPC_map,
+  };
+
+  // Sets for target enter data
+
+  static OmpClauseSet allowedClauses_OMPD_target_enter_data {
+    llvm::omp::Clause::OMPC_depend,
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_target_enter_data {
+    llvm::omp::Clause::OMPC_if,
+    llvm::omp::Clause::OMPC_device,
+    llvm::omp::Clause::OMPC_nowait,
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_target_enter_data {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_target_enter_data {
+    llvm::omp::Clause::OMPC_map,
+  };
+
+  // Sets for target exit data
+
+  static OmpClauseSet allowedClauses_OMPD_target_exit_data {
+    llvm::omp::Clause::OMPC_depend,
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_target_exit_data {
+    llvm::omp::Clause::OMPC_device,
+    llvm::omp::Clause::OMPC_if,
+    llvm::omp::Clause::OMPC_nowait,
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_target_exit_data {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_target_exit_data {
+    llvm::omp::Clause::OMPC_map,
+  };
+
+  // Sets for target parallel
+
+  static OmpClauseSet allowedClauses_OMPD_target_parallel {
+    llvm::omp::Clause::OMPC_map,
+    llvm::omp::Clause::OMPC_nowait,
+    llvm::omp::Clause::OMPC_depend,
+    llvm::omp::Clause::OMPC_private,
+    llvm::omp::Clause::OMPC_firstprivate,
+    llvm::omp::Clause::OMPC_default,
+    llvm::omp::Clause::OMPC_shared,
+    llvm::omp::Clause::OMPC_reduction,
+    llvm::omp::Clause::OMPC_is_device_ptr,
+    llvm::omp::Clause::OMPC_allocate,
+    llvm::omp::Clause::OMPC_uses_allocators,
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_target_parallel {
+    llvm::omp::Clause::OMPC_defaultmap,
+    llvm::omp::Clause::OMPC_device,
+    llvm::omp::Clause::OMPC_if,
+    llvm::omp::Clause::OMPC_num_threads,
+    llvm::omp::Clause::OMPC_proc_bind,
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_target_parallel {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_target_parallel {
+  };
+
+  // Sets for target parallel do
+
+  static OmpClauseSet allowedClauses_OMPD_target_parallel_do {
+    llvm::omp::Clause::OMPC_map,
+    llvm::omp::Clause::OMPC_private,
+    llvm::omp::Clause::OMPC_firstprivate,
+    llvm::omp::Clause::OMPC_lastprivate,
+    llvm::omp::Clause::OMPC_depend,
+    llvm::omp::Clause::OMPC_shared,
+    llvm::omp::Clause::OMPC_reduction,
+    llvm::omp::Clause::OMPC_linear,
+    llvm::omp::Clause::OMPC_is_device_ptr,
+    llvm::omp::Clause::OMPC_allocator,
+    llvm::omp::Clause::OMPC_order,
+    llvm::omp::Clause::OMPC_uses_allocators,
+    llvm::omp::Clause::OMPC_default,
+    llvm::omp::Clause::OMPC_copyin,
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_target_parallel_do {
+    llvm::omp::Clause::OMPC_if,
+    llvm::omp::Clause::OMPC_num_threads,
+    llvm::omp::Clause::OMPC_proc_bind,
+    llvm::omp::Clause::OMPC_device,
+    llvm::omp::Clause::OMPC_defaultmap,
+    llvm::omp::Clause::OMPC_schedule,
+    llvm::omp::Clause::OMPC_collapse,
+    llvm::omp::Clause::OMPC_ordered,
+    llvm::omp::Clause::OMPC_nowait,
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_target_parallel_do {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_target_parallel_do {
+  };
+
+  // Sets for target parallel do simd
+
+  static OmpClauseSet allowedClauses_OMPD_target_parallel_do_simd {
+    llvm::omp::Clause::OMPC_if,
+    llvm::omp::Clause::OMPC_device,
+    llvm::omp::Clause::OMPC_map,
+    llvm::omp::Clause::OMPC_private,
+    llvm::omp::Clause::OMPC_firstprivate,
+    llvm::omp::Clause::OMPC_lastprivate,
+    llvm::omp::Clause::OMPC_nowait,
+    llvm::omp::Clause::OMPC_depend,
+    llvm::omp::Clause::OMPC_defaultmap,
+    llvm::omp::Clause::OMPC_num_threads,
+    llvm::omp::Clause::OMPC_default,
+    llvm::omp::Clause::OMPC_proc_bind,
+    llvm::omp::Clause::OMPC_shared,
+    llvm::omp::Clause::OMPC_reduction,
+    llvm::omp::Clause::OMPC_collapse,
+    llvm::omp::Clause::OMPC_schedule,
+    llvm::omp::Clause::OMPC_ordered,
+    llvm::omp::Clause::OMPC_linear,
+    llvm::omp::Clause::OMPC_safelen,
+    llvm::omp::Clause::OMPC_simdlen,
+    llvm::omp::Clause::OMPC_aligned,
+    llvm::omp::Clause::OMPC_is_device_ptr,
+    llvm::omp::Clause::OMPC_allocate,
+    llvm::omp::Clause::OMPC_nontemporal,
+    llvm::omp::Clause::OMPC_order,
+    llvm::omp::Clause::OMPC_uses_allocators,
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_target_parallel_do_simd {
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_target_parallel_do_simd {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_target_parallel_do_simd {
+  };
+
+  // Sets for target parallel for
+
+  static OmpClauseSet allowedClauses_OMPD_target_parallel_for {
+    llvm::omp::Clause::OMPC_if,
+    llvm::omp::Clause::OMPC_device,
+    llvm::omp::Clause::OMPC_map,
+    llvm::omp::Clause::OMPC_private,
+    llvm::omp::Clause::OMPC_firstprivate,
+    llvm::omp::Clause::OMPC_lastprivate,
+    llvm::omp::Clause::OMPC_nowait,
+    llvm::omp::Clause::OMPC_depend,
+    llvm::omp::Clause::OMPC_defaultmap,
+    llvm::omp::Clause::OMPC_num_threads,
+    llvm::omp::Clause::OMPC_default,
+    llvm::omp::Clause::OMPC_proc_bind,
+    llvm::omp::Clause::OMPC_shared,
+    llvm::omp::Clause::OMPC_reduction,
+    llvm::omp::Clause::OMPC_collapse,
+    llvm::omp::Clause::OMPC_schedule,
+    llvm::omp::Clause::OMPC_ordered,
+    llvm::omp::Clause::OMPC_linear,
+    llvm::omp::Clause::OMPC_is_device_ptr,
+    llvm::omp::Clause::OMPC_allocate,
+    llvm::omp::Clause::OMPC_order,
+    llvm::omp::Clause::OMPC_uses_allocators,
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_target_parallel_for {
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_target_parallel_for {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_target_parallel_for {
+  };
+
+  // Sets for target parallel for simd
+
+  static OmpClauseSet allowedClauses_OMPD_target_parallel_for_simd {
+    llvm::omp::Clause::OMPC_if,
+    llvm::omp::Clause::OMPC_device,
+    llvm::omp::Clause::OMPC_map,
+    llvm::omp::Clause::OMPC_private,
+    llvm::omp::Clause::OMPC_firstprivate,
+    llvm::omp::Clause::OMPC_lastprivate,
+    llvm::omp::Clause::OMPC_nowait,
+    llvm::omp::Clause::OMPC_depend,
+    llvm::omp::Clause::OMPC_defaultmap,
+    llvm::omp::Clause::OMPC_num_threads,
+    llvm::omp::Clause::OMPC_default,
+    llvm::omp::Clause::OMPC_proc_bind,
+    llvm::omp::Clause::OMPC_shared,
+    llvm::omp::Clause::OMPC_reduction,
+    llvm::omp::Clause::OMPC_collapse,
+    llvm::omp::Clause::OMPC_schedule,
+    llvm::omp::Clause::OMPC_ordered,
+    llvm::omp::Clause::OMPC_linear,
+    llvm::omp::Clause::OMPC_safelen,
+    llvm::omp::Clause::OMPC_simdlen,
+    llvm::omp::Clause::OMPC_aligned,
+    llvm::omp::Clause::OMPC_is_device_ptr,
+    llvm::omp::Clause::OMPC_allocate,
+    llvm::omp::Clause::OMPC_nontemporal,
+    llvm::omp::Clause::OMPC_order,
+    llvm::omp::Clause::OMPC_uses_allocators,
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_target_parallel_for_simd {
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_target_parallel_for_simd {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_target_parallel_for_simd {
+  };
+
+  // Sets for target simd
+
+  static OmpClauseSet allowedClauses_OMPD_target_simd {
+    llvm::omp::Clause::OMPC_aligned,
+    llvm::omp::Clause::OMPC_allocate,
+    llvm::omp::Clause::OMPC_depend,
+    llvm::omp::Clause::OMPC_firstprivate,
+    llvm::omp::Clause::OMPC_is_device_ptr,
+    llvm::omp::Clause::OMPC_lastprivate,
+    llvm::omp::Clause::OMPC_linear,
+    llvm::omp::Clause::OMPC_map,
+    llvm::omp::Clause::OMPC_nontemporal,
+    llvm::omp::Clause::OMPC_nowait,
+    llvm::omp::Clause::OMPC_order,
+    llvm::omp::Clause::OMPC_private,
+    llvm::omp::Clause::OMPC_reduction,
+    llvm::omp::Clause::OMPC_shared,
+    llvm::omp::Clause::OMPC_uses_allocators,
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_target_simd {
+    llvm::omp::Clause::OMPC_collapse,
+    llvm::omp::Clause::OMPC_safelen,
+    llvm::omp::Clause::OMPC_simdlen,
+    llvm::omp::Clause::OMPC_if,
+    llvm::omp::Clause::OMPC_num_threads,
+    llvm::omp::Clause::OMPC_proc_bind,
+    llvm::omp::Clause::OMPC_device,
+    llvm::omp::Clause::OMPC_defaultmap,
+    llvm::omp::Clause::OMPC_schedule,
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_target_simd {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_target_simd {
+  };
+
+  // Sets for target teams
+
+  static OmpClauseSet allowedClauses_OMPD_target_teams {
+    llvm::omp::Clause::OMPC_if,
+    llvm::omp::Clause::OMPC_map,
+    llvm::omp::Clause::OMPC_private,
+    llvm::omp::Clause::OMPC_depend,
+    llvm::omp::Clause::OMPC_firstprivate,
+    llvm::omp::Clause::OMPC_is_device_ptr,
+    llvm::omp::Clause::OMPC_reduction,
+    llvm::omp::Clause::OMPC_allocate,
+    llvm::omp::Clause::OMPC_uses_allocators,
+    llvm::omp::Clause::OMPC_shared,
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_target_teams {
+    llvm::omp::Clause::OMPC_device,
+    llvm::omp::Clause::OMPC_nowait,
+    llvm::omp::Clause::OMPC_defaultmap,
+    llvm::omp::Clause::OMPC_default,
+    llvm::omp::Clause::OMPC_num_teams,
+    llvm::omp::Clause::OMPC_thread_limit,
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_target_teams {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_target_teams {
+  };
+
+  // Sets for target teams distribute
+
+  static OmpClauseSet allowedClauses_OMPD_target_teams_distribute {
+    llvm::omp::Clause::OMPC_if,
+    llvm::omp::Clause::OMPC_map,
+    llvm::omp::Clause::OMPC_private,
+    llvm::omp::Clause::OMPC_depend,
+    llvm::omp::Clause::OMPC_firstprivate,
+    llvm::omp::Clause::OMPC_is_device_ptr,
+    llvm::omp::Clause::OMPC_reduction,
+    llvm::omp::Clause::OMPC_allocate,
+    llvm::omp::Clause::OMPC_uses_allocators,
+    llvm::omp::Clause::OMPC_shared,
+    llvm::omp::Clause::OMPC_lastprivate,
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_target_teams_distribute {
+    llvm::omp::Clause::OMPC_device,
+    llvm::omp::Clause::OMPC_nowait,
+    llvm::omp::Clause::OMPC_defaultmap,
+    llvm::omp::Clause::OMPC_default,
+    llvm::omp::Clause::OMPC_num_teams,
+    llvm::omp::Clause::OMPC_thread_limit,
+    llvm::omp::Clause::OMPC_collapse,
+    llvm::omp::Clause::OMPC_dist_schedule,
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_target_teams_distribute {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_target_teams_distribute {
+  };
+
+  // Sets for target teams distribute parallel do
+
+  static OmpClauseSet allowedClauses_OMPD_target_teams_distribute_parallel_do {
+    llvm::omp::Clause::OMPC_if,
+    llvm::omp::Clause::OMPC_map,
+    llvm::omp::Clause::OMPC_private,
+    llvm::omp::Clause::OMPC_depend,
+    llvm::omp::Clause::OMPC_firstprivate,
+    llvm::omp::Clause::OMPC_is_device_ptr,
+    llvm::omp::Clause::OMPC_reduction,
+    llvm::omp::Clause::OMPC_allocate,
+    llvm::omp::Clause::OMPC_uses_allocators,
+    llvm::omp::Clause::OMPC_shared,
+    llvm::omp::Clause::OMPC_lastprivate,
+    llvm::omp::Clause::OMPC_copyin,
+    llvm::omp::Clause::OMPC_linear,
+    llvm::omp::Clause::OMPC_ordered,
+    llvm::omp::Clause::OMPC_order,
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_target_teams_distribute_parallel_do {
+    llvm::omp::Clause::OMPC_device,
+    llvm::omp::Clause::OMPC_defaultmap,
+    llvm::omp::Clause::OMPC_nowait,
+    llvm::omp::Clause::OMPC_default,
+    llvm::omp::Clause::OMPC_num_teams,
+    llvm::omp::Clause::OMPC_thread_limit,
+    llvm::omp::Clause::OMPC_collapse,
+    llvm::omp::Clause::OMPC_dist_schedule,
+    llvm::omp::Clause::OMPC_num_threads,
+    llvm::omp::Clause::OMPC_proc_bind,
+    llvm::omp::Clause::OMPC_schedule,
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_target_teams_distribute_parallel_do {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_target_teams_distribute_parallel_do {
+  };
+
+  // Sets for target teams distribute parallel do simd
+
+  static OmpClauseSet allowedClauses_OMPD_target_teams_distribute_parallel_do_simd {
+    llvm::omp::Clause::OMPC_map,
+    llvm::omp::Clause::OMPC_private,
+    llvm::omp::Clause::OMPC_depend,
+    llvm::omp::Clause::OMPC_firstprivate,
+    llvm::omp::Clause::OMPC_is_device_ptr,
+    llvm::omp::Clause::OMPC_reduction,
+    llvm::omp::Clause::OMPC_allocate,
+    llvm::omp::Clause::OMPC_uses_allocators,
+    llvm::omp::Clause::OMPC_shared,
+    llvm::omp::Clause::OMPC_lastprivate,
+    llvm::omp::Clause::OMPC_copyin,
+    llvm::omp::Clause::OMPC_linear,
+    llvm::omp::Clause::OMPC_ordered,
+    llvm::omp::Clause::OMPC_order,
+    llvm::omp::Clause::OMPC_aligned,
+    llvm::omp::Clause::OMPC_nontemporal,
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_target_teams_distribute_parallel_do_simd {
+    llvm::omp::Clause::OMPC_if,
+    llvm::omp::Clause::OMPC_device,
+    llvm::omp::Clause::OMPC_nowait,
+    llvm::omp::Clause::OMPC_defaultmap,
+    llvm::omp::Clause::OMPC_default,
+    llvm::omp::Clause::OMPC_num_teams,
+    llvm::omp::Clause::OMPC_thread_limit,
+    llvm::omp::Clause::OMPC_collapse,
+    llvm::omp::Clause::OMPC_dist_schedule,
+    llvm::omp::Clause::OMPC_num_threads,
+    llvm::omp::Clause::OMPC_proc_bind,
+    llvm::omp::Clause::OMPC_schedule,
+    llvm::omp::Clause::OMPC_safelen,
+    llvm::omp::Clause::OMPC_simdlen,
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_target_teams_distribute_parallel_do_simd {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_target_teams_distribute_parallel_do_simd {
+  };
+
+  // Sets for target teams distribute parallel for
+
+  static OmpClauseSet allowedClauses_OMPD_target_teams_distribute_parallel_for {
+    llvm::omp::Clause::OMPC_if,
+    llvm::omp::Clause::OMPC_device,
+    llvm::omp::Clause::OMPC_map,
+    llvm::omp::Clause::OMPC_private,
+    llvm::omp::Clause::OMPC_nowait,
+    llvm::omp::Clause::OMPC_depend,
+    llvm::omp::Clause::OMPC_defaultmap,
+    llvm::omp::Clause::OMPC_firstprivate,
+    llvm::omp::Clause::OMPC_is_device_ptr,
+    llvm::omp::Clause::OMPC_default,
+    llvm::omp::Clause::OMPC_shared,
+    llvm::omp::Clause::OMPC_reduction,
+    llvm::omp::Clause::OMPC_num_teams,
+    llvm::omp::Clause::OMPC_thread_limit,
+    llvm::omp::Clause::OMPC_lastprivate,
+    llvm::omp::Clause::OMPC_collapse,
+    llvm::omp::Clause::OMPC_dist_schedule,
+    llvm::omp::Clause::OMPC_num_threads,
+    llvm::omp::Clause::OMPC_proc_bind,
+    llvm::omp::Clause::OMPC_schedule,
+    llvm::omp::Clause::OMPC_allocate,
+    llvm::omp::Clause::OMPC_order,
+    llvm::omp::Clause::OMPC_uses_allocators,
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_target_teams_distribute_parallel_for {
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_target_teams_distribute_parallel_for {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_target_teams_distribute_parallel_for {
+  };
+
+  // Sets for target teams distribute parallel for simd
+
+  static OmpClauseSet allowedClauses_OMPD_target_teams_distribute_parallel_for_simd {
+    llvm::omp::Clause::OMPC_if,
+    llvm::omp::Clause::OMPC_device,
+    llvm::omp::Clause::OMPC_map,
+    llvm::omp::Clause::OMPC_private,
+    llvm::omp::Clause::OMPC_nowait,
+    llvm::omp::Clause::OMPC_depend,
+    llvm::omp::Clause::OMPC_defaultmap,
+    llvm::omp::Clause::OMPC_firstprivate,
+    llvm::omp::Clause::OMPC_is_device_ptr,
+    llvm::omp::Clause::OMPC_default,
+    llvm::omp::Clause::OMPC_shared,
+    llvm::omp::Clause::OMPC_reduction,
+    llvm::omp::Clause::OMPC_num_teams,
+    llvm::omp::Clause::OMPC_thread_limit,
+    llvm::omp::Clause::OMPC_lastprivate,
+    llvm::omp::Clause::OMPC_collapse,
+    llvm::omp::Clause::OMPC_dist_schedule,
+    llvm::omp::Clause::OMPC_num_threads,
+    llvm::omp::Clause::OMPC_proc_bind,
+    llvm::omp::Clause::OMPC_schedule,
+    llvm::omp::Clause::OMPC_linear,
+    llvm::omp::Clause::OMPC_aligned,
+    llvm::omp::Clause::OMPC_safelen,
+    llvm::omp::Clause::OMPC_simdlen,
+    llvm::omp::Clause::OMPC_allocate,
+    llvm::omp::Clause::OMPC_nontemporal,
+    llvm::omp::Clause::OMPC_order,
+    llvm::omp::Clause::OMPC_uses_allocators,
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_target_teams_distribute_parallel_for_simd {
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_target_teams_distribute_parallel_for_simd {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_target_teams_distribute_parallel_for_simd {
+  };
+
+  // Sets for target teams distribute simd
+
+  static OmpClauseSet allowedClauses_OMPD_target_teams_distribute_simd {
+    llvm::omp::Clause::OMPC_aligned,
+    llvm::omp::Clause::OMPC_allocate,
+    llvm::omp::Clause::OMPC_depend,
+    llvm::omp::Clause::OMPC_firstprivate,
+    llvm::omp::Clause::OMPC_if,
+    llvm::omp::Clause::OMPC_is_device_ptr,
+    llvm::omp::Clause::OMPC_lastprivate,
+    llvm::omp::Clause::OMPC_linear,
+    llvm::omp::Clause::OMPC_map,
+    llvm::omp::Clause::OMPC_nontemporal,
+    llvm::omp::Clause::OMPC_order,
+    llvm::omp::Clause::OMPC_private,
+    llvm::omp::Clause::OMPC_reduction,
+    llvm::omp::Clause::OMPC_shared,
+    llvm::omp::Clause::OMPC_uses_allocators,
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_target_teams_distribute_simd {
+    llvm::omp::Clause::OMPC_device,
+    llvm::omp::Clause::OMPC_defaultmap,
+    llvm::omp::Clause::OMPC_nowait,
+    llvm::omp::Clause::OMPC_num_teams,
+    llvm::omp::Clause::OMPC_thread_limit,
+    llvm::omp::Clause::OMPC_collapse,
+    llvm::omp::Clause::OMPC_dist_schedule,
+    llvm::omp::Clause::OMPC_safelen,
+    llvm::omp::Clause::OMPC_simdlen,
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_target_teams_distribute_simd {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_target_teams_distribute_simd {
+  };
+
+  // Sets for target update
+
+  static OmpClauseSet allowedClauses_OMPD_target_update {
+    llvm::omp::Clause::OMPC_if,
+    llvm::omp::Clause::OMPC_device,
+    llvm::omp::Clause::OMPC_to,
+    llvm::omp::Clause::OMPC_from,
+    llvm::omp::Clause::OMPC_nowait,
+    llvm::omp::Clause::OMPC_depend,
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_target_update {
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_target_update {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_target_update {
+  };
+
+  // Sets for task
+
+  static OmpClauseSet allowedClauses_OMPD_task {
+    llvm::omp::Clause::OMPC_private,
+    llvm::omp::Clause::OMPC_firstprivate,
+    llvm::omp::Clause::OMPC_shared,
+    llvm::omp::Clause::OMPC_untied,
+    llvm::omp::Clause::OMPC_mergeable,
+    llvm::omp::Clause::OMPC_depend,
+    llvm::omp::Clause::OMPC_in_reduction,
+    llvm::omp::Clause::OMPC_allocate,
+    llvm::omp::Clause::OMPC_detach,
+    llvm::omp::Clause::OMPC_affinity,
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_task {
+    llvm::omp::Clause::OMPC_default,
+    llvm::omp::Clause::OMPC_if,
+    llvm::omp::Clause::OMPC_final,
+    llvm::omp::Clause::OMPC_priority,
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_task {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_task {
+  };
+
+  // Sets for taskgroup
+
+  static OmpClauseSet allowedClauses_OMPD_taskgroup {
+    llvm::omp::Clause::OMPC_task_reduction,
+    llvm::omp::Clause::OMPC_allocate,
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_taskgroup {
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_taskgroup {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_taskgroup {
+  };
+
+  // Sets for taskloop
+
+  static OmpClauseSet allowedClauses_OMPD_taskloop {
+    llvm::omp::Clause::OMPC_shared,
+    llvm::omp::Clause::OMPC_private,
+    llvm::omp::Clause::OMPC_firstprivate,
+    llvm::omp::Clause::OMPC_lastprivate,
+    llvm::omp::Clause::OMPC_untied,
+    llvm::omp::Clause::OMPC_mergeable,
+    llvm::omp::Clause::OMPC_nogroup,
+    llvm::omp::Clause::OMPC_reduction,
+    llvm::omp::Clause::OMPC_in_reduction,
+    llvm::omp::Clause::OMPC_allocate,
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_taskloop {
+    llvm::omp::Clause::OMPC_default,
+    llvm::omp::Clause::OMPC_if,
+    llvm::omp::Clause::OMPC_collapse,
+    llvm::omp::Clause::OMPC_final,
+    llvm::omp::Clause::OMPC_priority,
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_taskloop {
+    llvm::omp::Clause::OMPC_grainsize,
+    llvm::omp::Clause::OMPC_num_tasks,
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_taskloop {
+  };
+
+  // Sets for taskloop simd
+
+  static OmpClauseSet allowedClauses_OMPD_taskloop_simd {
+    llvm::omp::Clause::OMPC_aligned,
+    llvm::omp::Clause::OMPC_allocate,
+    llvm::omp::Clause::OMPC_default,
+    llvm::omp::Clause::OMPC_firstprivate,
+    llvm::omp::Clause::OMPC_in_reduction,
+    llvm::omp::Clause::OMPC_lastprivate,
+    llvm::omp::Clause::OMPC_linear,
+    llvm::omp::Clause::OMPC_mergeable,
+    llvm::omp::Clause::OMPC_nogroup,
+    llvm::omp::Clause::OMPC_nontemporal,
+    llvm::omp::Clause::OMPC_order,
+    llvm::omp::Clause::OMPC_private,
+    llvm::omp::Clause::OMPC_reduction,
+    llvm::omp::Clause::OMPC_shared,
+    llvm::omp::Clause::OMPC_untied,
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_taskloop_simd {
+    llvm::omp::Clause::OMPC_if,
+    llvm::omp::Clause::OMPC_collapse,
+    llvm::omp::Clause::OMPC_safelen,
+    llvm::omp::Clause::OMPC_simdlen,
+    llvm::omp::Clause::OMPC_final,
+    llvm::omp::Clause::OMPC_priority,
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_taskloop_simd {
+    llvm::omp::Clause::OMPC_grainsize,
+    llvm::omp::Clause::OMPC_num_tasks,
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_taskloop_simd {
+  };
+
+  // Sets for taskwait
+
+  static OmpClauseSet allowedClauses_OMPD_taskwait {
+    llvm::omp::Clause::OMPC_depend,
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_taskwait {
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_taskwait {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_taskwait {
+  };
+
+  // Sets for taskyield
+
+  static OmpClauseSet allowedClauses_OMPD_taskyield {
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_taskyield {
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_taskyield {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_taskyield {
+  };
+
+  // Sets for teams
+
+  static OmpClauseSet allowedClauses_OMPD_teams {
+    llvm::omp::Clause::OMPC_private,
+    llvm::omp::Clause::OMPC_firstprivate,
+    llvm::omp::Clause::OMPC_shared,
+    llvm::omp::Clause::OMPC_reduction,
+    llvm::omp::Clause::OMPC_allocate,
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_teams {
+    llvm::omp::Clause::OMPC_default,
+    llvm::omp::Clause::OMPC_num_teams,
+    llvm::omp::Clause::OMPC_thread_limit,
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_teams {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_teams {
+  };
+
+  // Sets for teams distribute
+
+  static OmpClauseSet allowedClauses_OMPD_teams_distribute {
+    llvm::omp::Clause::OMPC_default,
+    llvm::omp::Clause::OMPC_private,
+    llvm::omp::Clause::OMPC_firstprivate,
+    llvm::omp::Clause::OMPC_shared,
+    llvm::omp::Clause::OMPC_reduction,
+    llvm::omp::Clause::OMPC_num_teams,
+    llvm::omp::Clause::OMPC_thread_limit,
+    llvm::omp::Clause::OMPC_lastprivate,
+    llvm::omp::Clause::OMPC_collapse,
+    llvm::omp::Clause::OMPC_dist_schedule,
+    llvm::omp::Clause::OMPC_allocate,
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_teams_distribute {
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_teams_distribute {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_teams_distribute {
+  };
+
+  // Sets for teams distribute parallel do
+
+  static OmpClauseSet allowedClauses_OMPD_teams_distribute_parallel_do {
+    llvm::omp::Clause::OMPC_private,
+    llvm::omp::Clause::OMPC_firstprivate,
+    llvm::omp::Clause::OMPC_lastprivate,
+    llvm::omp::Clause::OMPC_shared,
+    llvm::omp::Clause::OMPC_reduction,
+    llvm::omp::Clause::OMPC_allocate,
+    llvm::omp::Clause::OMPC_copyin,
+    llvm::omp::Clause::OMPC_linear,
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_teams_distribute_parallel_do {
+    llvm::omp::Clause::OMPC_num_teams,
+    llvm::omp::Clause::OMPC_thread_limit,
+    llvm::omp::Clause::OMPC_default,
+    llvm::omp::Clause::OMPC_collapse,
+    llvm::omp::Clause::OMPC_dist_schedule,
+    llvm::omp::Clause::OMPC_ordered,
+    llvm::omp::Clause::OMPC_order,
+    llvm::omp::Clause::OMPC_if,
+    llvm::omp::Clause::OMPC_num_threads,
+    llvm::omp::Clause::OMPC_proc_bind,
+    llvm::omp::Clause::OMPC_schedule,
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_teams_distribute_parallel_do {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_teams_distribute_parallel_do {
+  };
+
+  // Sets for teams distribute parallel do simd
+
+  static OmpClauseSet allowedClauses_OMPD_teams_distribute_parallel_do_simd {
+    llvm::omp::Clause::OMPC_private,
+    llvm::omp::Clause::OMPC_firstprivate,
+    llvm::omp::Clause::OMPC_lastprivate,
+    llvm::omp::Clause::OMPC_allocate,
+    llvm::omp::Clause::OMPC_shared,
+    llvm::omp::Clause::OMPC_reduction,
+    llvm::omp::Clause::OMPC_linear,
+    llvm::omp::Clause::OMPC_order,
+    llvm::omp::Clause::OMPC_aligned,
+    llvm::omp::Clause::OMPC_nontemporal,
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_teams_distribute_parallel_do_simd {
+    llvm::omp::Clause::OMPC_default,
+    llvm::omp::Clause::OMPC_num_teams,
+    llvm::omp::Clause::OMPC_thread_limit,
+    llvm::omp::Clause::OMPC_collapse,
+    llvm::omp::Clause::OMPC_dist_schedule,
+    llvm::omp::Clause::OMPC_num_threads,
+    llvm::omp::Clause::OMPC_proc_bind,
+    llvm::omp::Clause::OMPC_schedule,
+    llvm::omp::Clause::OMPC_safelen,
+    llvm::omp::Clause::OMPC_simdlen,
+    llvm::omp::Clause::OMPC_if,
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_teams_distribute_parallel_do_simd {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_teams_distribute_parallel_do_simd {
+  };
+
+  // Sets for teams distribute parallel for
+
+  static OmpClauseSet allowedClauses_OMPD_teams_distribute_parallel_for {
+    llvm::omp::Clause::OMPC_firstprivate,
+    llvm::omp::Clause::OMPC_lastprivate,
+    llvm::omp::Clause::OMPC_collapse,
+    llvm::omp::Clause::OMPC_dist_schedule,
+    llvm::omp::Clause::OMPC_if,
+    llvm::omp::Clause::OMPC_num_threads,
+    llvm::omp::Clause::OMPC_default,
+    llvm::omp::Clause::OMPC_proc_bind,
+    llvm::omp::Clause::OMPC_private,
+    llvm::omp::Clause::OMPC_shared,
+    llvm::omp::Clause::OMPC_reduction,
+    llvm::omp::Clause::OMPC_schedule,
+    llvm::omp::Clause::OMPC_num_teams,
+    llvm::omp::Clause::OMPC_thread_limit,
+    llvm::omp::Clause::OMPC_copyin,
+    llvm::omp::Clause::OMPC_allocate,
+    llvm::omp::Clause::OMPC_order,
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_teams_distribute_parallel_for {
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_teams_distribute_parallel_for {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_teams_distribute_parallel_for {
+  };
+
+  // Sets for teams distribute parallel for simd
+
+  static OmpClauseSet allowedClauses_OMPD_teams_distribute_parallel_for_simd {
+    llvm::omp::Clause::OMPC_firstprivate,
+    llvm::omp::Clause::OMPC_lastprivate,
+    llvm::omp::Clause::OMPC_collapse,
+    llvm::omp::Clause::OMPC_dist_schedule,
+    llvm::omp::Clause::OMPC_if,
+    llvm::omp::Clause::OMPC_num_threads,
+    llvm::omp::Clause::OMPC_default,
+    llvm::omp::Clause::OMPC_proc_bind,
+    llvm::omp::Clause::OMPC_private,
+    llvm::omp::Clause::OMPC_shared,
+    llvm::omp::Clause::OMPC_reduction,
+    llvm::omp::Clause::OMPC_schedule,
+    llvm::omp::Clause::OMPC_linear,
+    llvm::omp::Clause::OMPC_aligned,
+    llvm::omp::Clause::OMPC_safelen,
+    llvm::omp::Clause::OMPC_simdlen,
+    llvm::omp::Clause::OMPC_num_teams,
+    llvm::omp::Clause::OMPC_thread_limit,
+    llvm::omp::Clause::OMPC_allocate,
+    llvm::omp::Clause::OMPC_nontemporal,
+    llvm::omp::Clause::OMPC_order,
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_teams_distribute_parallel_for_simd {
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_teams_distribute_parallel_for_simd {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_teams_distribute_parallel_for_simd {
+  };
+
+  // Sets for teams distribute simd
+
+  static OmpClauseSet allowedClauses_OMPD_teams_distribute_simd {
+    llvm::omp::Clause::OMPC_aligned,
+    llvm::omp::Clause::OMPC_allocate,
+    llvm::omp::Clause::OMPC_firstprivate,
+    llvm::omp::Clause::OMPC_lastprivate,
+    llvm::omp::Clause::OMPC_linear,
+    llvm::omp::Clause::OMPC_nontemporal,
+    llvm::omp::Clause::OMPC_order,
+    llvm::omp::Clause::OMPC_private,
+    llvm::omp::Clause::OMPC_reduction,
+    llvm::omp::Clause::OMPC_shared,
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_teams_distribute_simd {
+    llvm::omp::Clause::OMPC_collapse,
+    llvm::omp::Clause::OMPC_default,
+    llvm::omp::Clause::OMPC_dist_schedule,
+    llvm::omp::Clause::OMPC_if,
+    llvm::omp::Clause::OMPC_num_teams,
+    llvm::omp::Clause::OMPC_safelen,
+    llvm::omp::Clause::OMPC_simdlen,
+    llvm::omp::Clause::OMPC_thread_limit,
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_teams_distribute_simd {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_teams_distribute_simd {
+  };
+
+  // Sets for threadprivate
+
+  static OmpClauseSet allowedClauses_OMPD_threadprivate {
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_threadprivate {
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_threadprivate {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_threadprivate {
+  };
+
+  // Sets for unknown
+
+  static OmpClauseSet allowedClauses_OMPD_unknown {
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_unknown {
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_unknown {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_unknown {
+  };
+
+  // Sets for workshare
+
+  static OmpClauseSet allowedClauses_OMPD_workshare {
+  };
+
+  static OmpClauseSet allowedOnceClauses_OMPD_workshare {
+  };
+
+  static OmpClauseSet allowedExclusiveClauses_OMPD_workshare {
+  };
+
+  static OmpClauseSet requiredClauses_OMPD_workshare {
+  };
+} // namespace omp
+} // namespace llvm
+
+#endif // GEN_FLANG_DIRECTIVE_CLAUSE_SETS
+
+#ifdef GEN_FLANG_DIRECTIVE_CLAUSE_MAP
+#undef GEN_FLANG_DIRECTIVE_CLAUSE_MAP
+
+{
+  {llvm::omp::Directive::OMPD_allocate,
+    {
+      llvm::omp::allowedClauses_OMPD_allocate,
+      llvm::omp::allowedOnceClauses_OMPD_allocate,
+      llvm::omp::allowedExclusiveClauses_OMPD_allocate,
+      llvm::omp::requiredClauses_OMPD_allocate,
+    }
+  },
+  {llvm::omp::Directive::OMPD_assumes,
+    {
+      llvm::omp::allowedClauses_OMPD_assumes,
+      llvm::omp::allowedOnceClauses_OMPD_assumes,
+      llvm::omp::allowedExclusiveClauses_OMPD_assumes,
+      llvm::omp::requiredClauses_OMPD_assumes,
+    }
+  },
+  {llvm::omp::Directive::OMPD_atomic,
+    {
+      llvm::omp::allowedClauses_OMPD_atomic,
+      llvm::omp::allowedOnceClauses_OMPD_atomic,
+      llvm::omp::allowedExclusiveClauses_OMPD_atomic,
+      llvm::omp::requiredClauses_OMPD_atomic,
+    }
+  },
+  {llvm::omp::Directive::OMPD_barrier,
+    {
+      llvm::omp::allowedClauses_OMPD_barrier,
+      llvm::omp::allowedOnceClauses_OMPD_barrier,
+      llvm::omp::allowedExclusiveClauses_OMPD_barrier,
+      llvm::omp::requiredClauses_OMPD_barrier,
+    }
+  },
+  {llvm::omp::Directive::OMPD_begin_assumes,
+    {
+      llvm::omp::allowedClauses_OMPD_begin_assumes,
+      llvm::omp::allowedOnceClauses_OMPD_begin_assumes,
+      llvm::omp::allowedExclusiveClauses_OMPD_begin_assumes,
+      llvm::omp::requiredClauses_OMPD_begin_assumes,
+    }
+  },
+  {llvm::omp::Directive::OMPD_begin_declare_variant,
+    {
+      llvm::omp::allowedClauses_OMPD_begin_declare_variant,
+      llvm::omp::allowedOnceClauses_OMPD_begin_declare_variant,
+      llvm::omp::allowedExclusiveClauses_OMPD_begin_declare_variant,
+      llvm::omp::requiredClauses_OMPD_begin_declare_variant,
+    }
+  },
+  {llvm::omp::Directive::OMPD_cancel,
+    {
+      llvm::omp::allowedClauses_OMPD_cancel,
+      llvm::omp::allowedOnceClauses_OMPD_cancel,
+      llvm::omp::allowedExclusiveClauses_OMPD_cancel,
+      llvm::omp::requiredClauses_OMPD_cancel,
+    }
+  },
+  {llvm::omp::Directive::OMPD_cancellation_point,
+    {
+      llvm::omp::allowedClauses_OMPD_cancellation_point,
+      llvm::omp::allowedOnceClauses_OMPD_cancellation_point,
+      llvm::omp::allowedExclusiveClauses_OMPD_cancellation_point,
+      llvm::omp::requiredClauses_OMPD_cancellation_point,
+    }
+  },
+  {llvm::omp::Directive::OMPD_critical,
+    {
+      llvm::omp::allowedClauses_OMPD_critical,
+      llvm::omp::allowedOnceClauses_OMPD_critical,
+      llvm::omp::allowedExclusiveClauses_OMPD_critical,
+      llvm::omp::requiredClauses_OMPD_critical,
+    }
+  },
+  {llvm::omp::Directive::OMPD_declare_mapper,
+    {
+      llvm::omp::allowedClauses_OMPD_declare_mapper,
+      llvm::omp::allowedOnceClauses_OMPD_declare_mapper,
+      llvm::omp::allowedExclusiveClauses_OMPD_declare_mapper,
+      llvm::omp::requiredClauses_OMPD_declare_mapper,
+    }
+  },
+  {llvm::omp::Directive::OMPD_declare_reduction,
+    {
+      llvm::omp::allowedClauses_OMPD_declare_reduction,
+      llvm::omp::allowedOnceClauses_OMPD_declare_reduction,
+      llvm::omp::allowedExclusiveClauses_OMPD_declare_reduction,
+      llvm::omp::requiredClauses_OMPD_declare_reduction,
+    }
+  },
+  {llvm::omp::Directive::OMPD_declare_simd,
+    {
+      llvm::omp::allowedClauses_OMPD_declare_simd,
+      llvm::omp::allowedOnceClauses_OMPD_declare_simd,
+      llvm::omp::allowedExclusiveClauses_OMPD_declare_simd,
+      llvm::omp::requiredClauses_OMPD_declare_simd,
+    }
+  },
+  {llvm::omp::Directive::OMPD_declare_target,
+    {
+      llvm::omp::allowedClauses_OMPD_declare_target,
+      llvm::omp::allowedOnceClauses_OMPD_declare_target,
+      llvm::omp::allowedExclusiveClauses_OMPD_declare_target,
+      llvm::omp::requiredClauses_OMPD_declare_target,
+    }
+  },
+  {llvm::omp::Directive::OMPD_declare_variant,
+    {
+      llvm::omp::allowedClauses_OMPD_declare_variant,
+      llvm::omp::allowedOnceClauses_OMPD_declare_variant,
+      llvm::omp::allowedExclusiveClauses_OMPD_declare_variant,
+      llvm::omp::requiredClauses_OMPD_declare_variant,
+    }
+  },
+  {llvm::omp::Directive::OMPD_depobj,
+    {
+      llvm::omp::allowedClauses_OMPD_depobj,
+      llvm::omp::allowedOnceClauses_OMPD_depobj,
+      llvm::omp::allowedExclusiveClauses_OMPD_depobj,
+      llvm::omp::requiredClauses_OMPD_depobj,
+    }
+  },
+  {llvm::omp::Directive::OMPD_distribute,
+    {
+      llvm::omp::allowedClauses_OMPD_distribute,
+      llvm::omp::allowedOnceClauses_OMPD_distribute,
+      llvm::omp::allowedExclusiveClauses_OMPD_distribute,
+      llvm::omp::requiredClauses_OMPD_distribute,
+    }
+  },
+  {llvm::omp::Directive::OMPD_distribute_parallel_do,
+    {
+      llvm::omp::allowedClauses_OMPD_distribute_parallel_do,
+      llvm::omp::allowedOnceClauses_OMPD_distribute_parallel_do,
+      llvm::omp::allowedExclusiveClauses_OMPD_distribute_parallel_do,
+      llvm::omp::requiredClauses_OMPD_distribute_parallel_do,
+    }
+  },
+  {llvm::omp::Directive::OMPD_distribute_parallel_do_simd,
+    {
+      llvm::omp::allowedClauses_OMPD_distribute_parallel_do_simd,
+      llvm::omp::allowedOnceClauses_OMPD_distribute_parallel_do_simd,
+      llvm::omp::allowedExclusiveClauses_OMPD_distribute_parallel_do_simd,
+      llvm::omp::requiredClauses_OMPD_distribute_parallel_do_simd,
+    }
+  },
+  {llvm::omp::Directive::OMPD_distribute_parallel_for,
+    {
+      llvm::omp::allowedClauses_OMPD_distribute_parallel_for,
+      llvm::omp::allowedOnceClauses_OMPD_distribute_parallel_for,
+      llvm::omp::allowedExclusiveClauses_OMPD_distribute_parallel_for,
+      llvm::omp::requiredClauses_OMPD_distribute_parallel_for,
+    }
+  },
+  {llvm::omp::Directive::OMPD_distribute_parallel_for_simd,
+    {
+      llvm::omp::allowedClauses_OMPD_distribute_parallel_for_simd,
+      llvm::omp::allowedOnceClauses_OMPD_distribute_parallel_for_simd,
+      llvm::omp::allowedExclusiveClauses_OMPD_distribute_parallel_for_simd,
+      llvm::omp::requiredClauses_OMPD_distribute_parallel_for_simd,
+    }
+  },
+  {llvm::omp::Directive::OMPD_distribute_simd,
+    {
+      llvm::omp::allowedClauses_OMPD_distribute_simd,
+      llvm::omp::allowedOnceClauses_OMPD_distribute_simd,
+      llvm::omp::allowedExclusiveClauses_OMPD_distribute_simd,
+      llvm::omp::requiredClauses_OMPD_distribute_simd,
+    }
+  },
+  {llvm::omp::Directive::OMPD_do,
+    {
+      llvm::omp::allowedClauses_OMPD_do,
+      llvm::omp::allowedOnceClauses_OMPD_do,
+      llvm::omp::allowedExclusiveClauses_OMPD_do,
+      llvm::omp::requiredClauses_OMPD_do,
+    }
+  },
+  {llvm::omp::Directive::OMPD_do_simd,
+    {
+      llvm::omp::allowedClauses_OMPD_do_simd,
+      llvm::omp::allowedOnceClauses_OMPD_do_simd,
+      llvm::omp::allowedExclusiveClauses_OMPD_do_simd,
+      llvm::omp::requiredClauses_OMPD_do_simd,
+    }
+  },
+  {llvm::omp::Directive::OMPD_end_assumes,
+    {
+      llvm::omp::allowedClauses_OMPD_end_assumes,
+      llvm::omp::allowedOnceClauses_OMPD_end_assumes,
+      llvm::omp::allowedExclusiveClauses_OMPD_end_assumes,
+      llvm::omp::requiredClauses_OMPD_end_assumes,
+    }
+  },
+  {llvm::omp::Directive::OMPD_end_declare_target,
+    {
+      llvm::omp::allowedClauses_OMPD_end_declare_target,
+      llvm::omp::allowedOnceClauses_OMPD_end_declare_target,
+      llvm::omp::allowedExclusiveClauses_OMPD_end_declare_target,
+      llvm::omp::requiredClauses_OMPD_end_declare_target,
+    }
+  },
+  {llvm::omp::Directive::OMPD_end_declare_variant,
+    {
+      llvm::omp::allowedClauses_OMPD_end_declare_variant,
+      llvm::omp::allowedOnceClauses_OMPD_end_declare_variant,
+      llvm::omp::allowedExclusiveClauses_OMPD_end_declare_variant,
+      llvm::omp::requiredClauses_OMPD_end_declare_variant,
+    }
+  },
+  {llvm::omp::Directive::OMPD_end_do,
+    {
+      llvm::omp::allowedClauses_OMPD_end_do,
+      llvm::omp::allowedOnceClauses_OMPD_end_do,
+      llvm::omp::allowedExclusiveClauses_OMPD_end_do,
+      llvm::omp::requiredClauses_OMPD_end_do,
+    }
+  },
+  {llvm::omp::Directive::OMPD_end_do_simd,
+    {
+      llvm::omp::allowedClauses_OMPD_end_do_simd,
+      llvm::omp::allowedOnceClauses_OMPD_end_do_simd,
+      llvm::omp::allowedExclusiveClauses_OMPD_end_do_simd,
+      llvm::omp::requiredClauses_OMPD_end_do_simd,
+    }
+  },
+  {llvm::omp::Directive::OMPD_end_sections,
+    {
+      llvm::omp::allowedClauses_OMPD_end_sections,
+      llvm::omp::allowedOnceClauses_OMPD_end_sections,
+      llvm::omp::allowedExclusiveClauses_OMPD_end_sections,
+      llvm::omp::requiredClauses_OMPD_end_sections,
+    }
+  },
+  {llvm::omp::Directive::OMPD_end_single,
+    {
+      llvm::omp::allowedClauses_OMPD_end_single,
+      llvm::omp::allowedOnceClauses_OMPD_end_single,
+      llvm::omp::allowedExclusiveClauses_OMPD_end_single,
+      llvm::omp::requiredClauses_OMPD_end_single,
+    }
+  },
+  {llvm::omp::Directive::OMPD_end_workshare,
+    {
+      llvm::omp::allowedClauses_OMPD_end_workshare,
+      llvm::omp::allowedOnceClauses_OMPD_end_workshare,
+      llvm::omp::allowedExclusiveClauses_OMPD_end_workshare,
+      llvm::omp::requiredClauses_OMPD_end_workshare,
+    }
+  },
+  {llvm::omp::Directive::OMPD_flush,
+    {
+      llvm::omp::allowedClauses_OMPD_flush,
+      llvm::omp::allowedOnceClauses_OMPD_flush,
+      llvm::omp::allowedExclusiveClauses_OMPD_flush,
+      llvm::omp::requiredClauses_OMPD_flush,
+    }
+  },
+  {llvm::omp::Directive::OMPD_for,
+    {
+      llvm::omp::allowedClauses_OMPD_for,
+      llvm::omp::allowedOnceClauses_OMPD_for,
+      llvm::omp::allowedExclusiveClauses_OMPD_for,
+      llvm::omp::requiredClauses_OMPD_for,
+    }
+  },
+  {llvm::omp::Directive::OMPD_for_simd,
+    {
+      llvm::omp::allowedClauses_OMPD_for_simd,
+      llvm::omp::allowedOnceClauses_OMPD_for_simd,
+      llvm::omp::allowedExclusiveClauses_OMPD_for_simd,
+      llvm::omp::requiredClauses_OMPD_for_simd,
+    }
+  },
+  {llvm::omp::Directive::OMPD_master,
+    {
+      llvm::omp::allowedClauses_OMPD_master,
+      llvm::omp::allowedOnceClauses_OMPD_master,
+      llvm::omp::allowedExclusiveClauses_OMPD_master,
+      llvm::omp::requiredClauses_OMPD_master,
+    }
+  },
+  {llvm::omp::Directive::OMPD_master_taskloop,
+    {
+      llvm::omp::allowedClauses_OMPD_master_taskloop,
+      llvm::omp::allowedOnceClauses_OMPD_master_taskloop,
+      llvm::omp::allowedExclusiveClauses_OMPD_master_taskloop,
+      llvm::omp::requiredClauses_OMPD_master_taskloop,
+    }
+  },
+  {llvm::omp::Directive::OMPD_master_taskloop_simd,
+    {
+      llvm::omp::allowedClauses_OMPD_master_taskloop_simd,
+      llvm::omp::allowedOnceClauses_OMPD_master_taskloop_simd,
+      llvm::omp::allowedExclusiveClauses_OMPD_master_taskloop_simd,
+      llvm::omp::requiredClauses_OMPD_master_taskloop_simd,
+    }
+  },
+  {llvm::omp::Directive::OMPD_ordered,
+    {
+      llvm::omp::allowedClauses_OMPD_ordered,
+      llvm::omp::allowedOnceClauses_OMPD_ordered,
+      llvm::omp::allowedExclusiveClauses_OMPD_ordered,
+      llvm::omp::requiredClauses_OMPD_ordered,
+    }
+  },
+  {llvm::omp::Directive::OMPD_parallel,
+    {
+      llvm::omp::allowedClauses_OMPD_parallel,
+      llvm::omp::allowedOnceClauses_OMPD_parallel,
+      llvm::omp::allowedExclusiveClauses_OMPD_parallel,
+      llvm::omp::requiredClauses_OMPD_parallel,
+    }
+  },
+  {llvm::omp::Directive::OMPD_parallel_do,
+    {
+      llvm::omp::allowedClauses_OMPD_parallel_do,
+      llvm::omp::allowedOnceClauses_OMPD_parallel_do,
+      llvm::omp::allowedExclusiveClauses_OMPD_parallel_do,
+      llvm::omp::requiredClauses_OMPD_parallel_do,
+    }
+  },
+  {llvm::omp::Directive::OMPD_parallel_do_simd,
+    {
+      llvm::omp::allowedClauses_OMPD_parallel_do_simd,
+      llvm::omp::allowedOnceClauses_OMPD_parallel_do_simd,
+      llvm::omp::allowedExclusiveClauses_OMPD_parallel_do_simd,
+      llvm::omp::requiredClauses_OMPD_parallel_do_simd,
+    }
+  },
+  {llvm::omp::Directive::OMPD_parallel_for,
+    {
+      llvm::omp::allowedClauses_OMPD_parallel_for,
+      llvm::omp::allowedOnceClauses_OMPD_parallel_for,
+      llvm::omp::allowedExclusiveClauses_OMPD_parallel_for,
+      llvm::omp::requiredClauses_OMPD_parallel_for,
+    }
+  },
+  {llvm::omp::Directive::OMPD_parallel_for_simd,
+    {
+      llvm::omp::allowedClauses_OMPD_parallel_for_simd,
+      llvm::omp::allowedOnceClauses_OMPD_parallel_for_simd,
+      llvm::omp::allowedExclusiveClauses_OMPD_parallel_for_simd,
+      llvm::omp::requiredClauses_OMPD_parallel_for_simd,
+    }
+  },
+  {llvm::omp::Directive::OMPD_parallel_master,
+    {
+      llvm::omp::allowedClauses_OMPD_parallel_master,
+      llvm::omp::allowedOnceClauses_OMPD_parallel_master,
+      llvm::omp::allowedExclusiveClauses_OMPD_parallel_master,
+      llvm::omp::requiredClauses_OMPD_parallel_master,
+    }
+  },
+  {llvm::omp::Directive::OMPD_parallel_master_taskloop,
+    {
+      llvm::omp::allowedClauses_OMPD_parallel_master_taskloop,
+      llvm::omp::allowedOnceClauses_OMPD_parallel_master_taskloop,
+      llvm::omp::allowedExclusiveClauses_OMPD_parallel_master_taskloop,
+      llvm::omp::requiredClauses_OMPD_parallel_master_taskloop,
+    }
+  },
+  {llvm::omp::Directive::OMPD_parallel_master_taskloop_simd,
+    {
+      llvm::omp::allowedClauses_OMPD_parallel_master_taskloop_simd,
+      llvm::omp::allowedOnceClauses_OMPD_parallel_master_taskloop_simd,
+      llvm::omp::allowedExclusiveClauses_OMPD_parallel_master_taskloop_simd,
+      llvm::omp::requiredClauses_OMPD_parallel_master_taskloop_simd,
+    }
+  },
+  {llvm::omp::Directive::OMPD_parallel_sections,
+    {
+      llvm::omp::allowedClauses_OMPD_parallel_sections,
+      llvm::omp::allowedOnceClauses_OMPD_parallel_sections,
+      llvm::omp::allowedExclusiveClauses_OMPD_parallel_sections,
+      llvm::omp::requiredClauses_OMPD_parallel_sections,
+    }
+  },
+  {llvm::omp::Directive::OMPD_parallel_workshare,
+    {
+      llvm::omp::allowedClauses_OMPD_parallel_workshare,
+      llvm::omp::allowedOnceClauses_OMPD_parallel_workshare,
+      llvm::omp::allowedExclusiveClauses_OMPD_parallel_workshare,
+      llvm::omp::requiredClauses_OMPD_parallel_workshare,
+    }
+  },
+  {llvm::omp::Directive::OMPD_requires,
+    {
+      llvm::omp::allowedClauses_OMPD_requires,
+      llvm::omp::allowedOnceClauses_OMPD_requires,
+      llvm::omp::allowedExclusiveClauses_OMPD_requires,
+      llvm::omp::requiredClauses_OMPD_requires,
+    }
+  },
+  {llvm::omp::Directive::OMPD_scan,
+    {
+      llvm::omp::allowedClauses_OMPD_scan,
+      llvm::omp::allowedOnceClauses_OMPD_scan,
+      llvm::omp::allowedExclusiveClauses_OMPD_scan,
+      llvm::omp::requiredClauses_OMPD_scan,
+    }
+  },
+  {llvm::omp::Directive::OMPD_section,
+    {
+      llvm::omp::allowedClauses_OMPD_section,
+      llvm::omp::allowedOnceClauses_OMPD_section,
+      llvm::omp::allowedExclusiveClauses_OMPD_section,
+      llvm::omp::requiredClauses_OMPD_section,
+    }
+  },
+  {llvm::omp::Directive::OMPD_sections,
+    {
+      llvm::omp::allowedClauses_OMPD_sections,
+      llvm::omp::allowedOnceClauses_OMPD_sections,
+      llvm::omp::allowedExclusiveClauses_OMPD_sections,
+      llvm::omp::requiredClauses_OMPD_sections,
+    }
+  },
+  {llvm::omp::Directive::OMPD_simd,
+    {
+      llvm::omp::allowedClauses_OMPD_simd,
+      llvm::omp::allowedOnceClauses_OMPD_simd,
+      llvm::omp::allowedExclusiveClauses_OMPD_simd,
+      llvm::omp::requiredClauses_OMPD_simd,
+    }
+  },
+  {llvm::omp::Directive::OMPD_single,
+    {
+      llvm::omp::allowedClauses_OMPD_single,
+      llvm::omp::allowedOnceClauses_OMPD_single,
+      llvm::omp::allowedExclusiveClauses_OMPD_single,
+      llvm::omp::requiredClauses_OMPD_single,
+    }
+  },
+  {llvm::omp::Directive::OMPD_target,
+    {
+      llvm::omp::allowedClauses_OMPD_target,
+      llvm::omp::allowedOnceClauses_OMPD_target,
+      llvm::omp::allowedExclusiveClauses_OMPD_target,
+      llvm::omp::requiredClauses_OMPD_target,
+    }
+  },
+  {llvm::omp::Directive::OMPD_target_data,
+    {
+      llvm::omp::allowedClauses_OMPD_target_data,
+      llvm::omp::allowedOnceClauses_OMPD_target_data,
+      llvm::omp::allowedExclusiveClauses_OMPD_target_data,
+      llvm::omp::requiredClauses_OMPD_target_data,
+    }
+  },
+  {llvm::omp::Directive::OMPD_target_enter_data,
+    {
+      llvm::omp::allowedClauses_OMPD_target_enter_data,
+      llvm::omp::allowedOnceClauses_OMPD_target_enter_data,
+      llvm::omp::allowedExclusiveClauses_OMPD_target_enter_data,
+      llvm::omp::requiredClauses_OMPD_target_enter_data,
+    }
+  },
+  {llvm::omp::Directive::OMPD_target_exit_data,
+    {
+      llvm::omp::allowedClauses_OMPD_target_exit_data,
+      llvm::omp::allowedOnceClauses_OMPD_target_exit_data,
+      llvm::omp::allowedExclusiveClauses_OMPD_target_exit_data,
+      llvm::omp::requiredClauses_OMPD_target_exit_data,
+    }
+  },
+  {llvm::omp::Directive::OMPD_target_parallel,
+    {
+      llvm::omp::allowedClauses_OMPD_target_parallel,
+      llvm::omp::allowedOnceClauses_OMPD_target_parallel,
+      llvm::omp::allowedExclusiveClauses_OMPD_target_parallel,
+      llvm::omp::requiredClauses_OMPD_target_parallel,
+    }
+  },
+  {llvm::omp::Directive::OMPD_target_parallel_do,
+    {
+      llvm::omp::allowedClauses_OMPD_target_parallel_do,
+      llvm::omp::allowedOnceClauses_OMPD_target_parallel_do,
+      llvm::omp::allowedExclusiveClauses_OMPD_target_parallel_do,
+      llvm::omp::requiredClauses_OMPD_target_parallel_do,
+    }
+  },
+  {llvm::omp::Directive::OMPD_target_parallel_do_simd,
+    {
+      llvm::omp::allowedClauses_OMPD_target_parallel_do_simd,
+      llvm::omp::allowedOnceClauses_OMPD_target_parallel_do_simd,
+      llvm::omp::allowedExclusiveClauses_OMPD_target_parallel_do_simd,
+      llvm::omp::requiredClauses_OMPD_target_parallel_do_simd,
+    }
+  },
+  {llvm::omp::Directive::OMPD_target_parallel_for,
+    {
+      llvm::omp::allowedClauses_OMPD_target_parallel_for,
+      llvm::omp::allowedOnceClauses_OMPD_target_parallel_for,
+      llvm::omp::allowedExclusiveClauses_OMPD_target_parallel_for,
+      llvm::omp::requiredClauses_OMPD_target_parallel_for,
+    }
+  },
+  {llvm::omp::Directive::OMPD_target_parallel_for_simd,
+    {
+      llvm::omp::allowedClauses_OMPD_target_parallel_for_simd,
+      llvm::omp::allowedOnceClauses_OMPD_target_parallel_for_simd,
+      llvm::omp::allowedExclusiveClauses_OMPD_target_parallel_for_simd,
+      llvm::omp::requiredClauses_OMPD_target_parallel_for_simd,
+    }
+  },
+  {llvm::omp::Directive::OMPD_target_simd,
+    {
+      llvm::omp::allowedClauses_OMPD_target_simd,
+      llvm::omp::allowedOnceClauses_OMPD_target_simd,
+      llvm::omp::allowedExclusiveClauses_OMPD_target_simd,
+      llvm::omp::requiredClauses_OMPD_target_simd,
+    }
+  },
+  {llvm::omp::Directive::OMPD_target_teams,
+    {
+      llvm::omp::allowedClauses_OMPD_target_teams,
+      llvm::omp::allowedOnceClauses_OMPD_target_teams,
+      llvm::omp::allowedExclusiveClauses_OMPD_target_teams,
+      llvm::omp::requiredClauses_OMPD_target_teams,
+    }
+  },
+  {llvm::omp::Directive::OMPD_target_teams_distribute,
+    {
+      llvm::omp::allowedClauses_OMPD_target_teams_distribute,
+      llvm::omp::allowedOnceClauses_OMPD_target_teams_distribute,
+      llvm::omp::allowedExclusiveClauses_OMPD_target_teams_distribute,
+      llvm::omp::requiredClauses_OMPD_target_teams_distribute,
+    }
+  },
+  {llvm::omp::Directive::OMPD_target_teams_distribute_parallel_do,
+    {
+      llvm::omp::allowedClauses_OMPD_target_teams_distribute_parallel_do,
+      llvm::omp::allowedOnceClauses_OMPD_target_teams_distribute_parallel_do,
+      llvm::omp::allowedExclusiveClauses_OMPD_target_teams_distribute_parallel_do,
+      llvm::omp::requiredClauses_OMPD_target_teams_distribute_parallel_do,
+    }
+  },
+  {llvm::omp::Directive::OMPD_target_teams_distribute_parallel_do_simd,
+    {
+      llvm::omp::allowedClauses_OMPD_target_teams_distribute_parallel_do_simd,
+      llvm::omp::allowedOnceClauses_OMPD_target_teams_distribute_parallel_do_simd,
+      llvm::omp::allowedExclusiveClauses_OMPD_target_teams_distribute_parallel_do_simd,
+      llvm::omp::requiredClauses_OMPD_target_teams_distribute_parallel_do_simd,
+    }
+  },
+  {llvm::omp::Directive::OMPD_target_teams_distribute_parallel_for,
+    {
+      llvm::omp::allowedClauses_OMPD_target_teams_distribute_parallel_for,
+      llvm::omp::allowedOnceClauses_OMPD_target_teams_distribute_parallel_for,
+      llvm::omp::allowedExclusiveClauses_OMPD_target_teams_distribute_parallel_for,
+      llvm::omp::requiredClauses_OMPD_target_teams_distribute_parallel_for,
+    }
+  },
+  {llvm::omp::Directive::OMPD_target_teams_distribute_parallel_for_simd,
+    {
+      llvm::omp::allowedClauses_OMPD_target_teams_distribute_parallel_for_simd,
+      llvm::omp::allowedOnceClauses_OMPD_target_teams_distribute_parallel_for_simd,
+      llvm::omp::allowedExclusiveClauses_OMPD_target_teams_distribute_parallel_for_simd,
+      llvm::omp::requiredClauses_OMPD_target_teams_distribute_parallel_for_simd,
+    }
+  },
+  {llvm::omp::Directive::OMPD_target_teams_distribute_simd,
+    {
+      llvm::omp::allowedClauses_OMPD_target_teams_distribute_simd,
+      llvm::omp::allowedOnceClauses_OMPD_target_teams_distribute_simd,
+      llvm::omp::allowedExclusiveClauses_OMPD_target_teams_distribute_simd,
+      llvm::omp::requiredClauses_OMPD_target_teams_distribute_simd,
+    }
+  },
+  {llvm::omp::Directive::OMPD_target_update,
+    {
+      llvm::omp::allowedClauses_OMPD_target_update,
+      llvm::omp::allowedOnceClauses_OMPD_target_update,
+      llvm::omp::allowedExclusiveClauses_OMPD_target_update,
+      llvm::omp::requiredClauses_OMPD_target_update,
+    }
+  },
+  {llvm::omp::Directive::OMPD_task,
+    {
+      llvm::omp::allowedClauses_OMPD_task,
+      llvm::omp::allowedOnceClauses_OMPD_task,
+      llvm::omp::allowedExclusiveClauses_OMPD_task,
+      llvm::omp::requiredClauses_OMPD_task,
+    }
+  },
+  {llvm::omp::Directive::OMPD_taskgroup,
+    {
+      llvm::omp::allowedClauses_OMPD_taskgroup,
+      llvm::omp::allowedOnceClauses_OMPD_taskgroup,
+      llvm::omp::allowedExclusiveClauses_OMPD_taskgroup,
+      llvm::omp::requiredClauses_OMPD_taskgroup,
+    }
+  },
+  {llvm::omp::Directive::OMPD_taskloop,
+    {
+      llvm::omp::allowedClauses_OMPD_taskloop,
+      llvm::omp::allowedOnceClauses_OMPD_taskloop,
+      llvm::omp::allowedExclusiveClauses_OMPD_taskloop,
+      llvm::omp::requiredClauses_OMPD_taskloop,
+    }
+  },
+  {llvm::omp::Directive::OMPD_taskloop_simd,
+    {
+      llvm::omp::allowedClauses_OMPD_taskloop_simd,
+      llvm::omp::allowedOnceClauses_OMPD_taskloop_simd,
+      llvm::omp::allowedExclusiveClauses_OMPD_taskloop_simd,
+      llvm::omp::requiredClauses_OMPD_taskloop_simd,
+    }
+  },
+  {llvm::omp::Directive::OMPD_taskwait,
+    {
+      llvm::omp::allowedClauses_OMPD_taskwait,
+      llvm::omp::allowedOnceClauses_OMPD_taskwait,
+      llvm::omp::allowedExclusiveClauses_OMPD_taskwait,
+      llvm::omp::requiredClauses_OMPD_taskwait,
+    }
+  },
+  {llvm::omp::Directive::OMPD_taskyield,
+    {
+      llvm::omp::allowedClauses_OMPD_taskyield,
+      llvm::omp::allowedOnceClauses_OMPD_taskyield,
+      llvm::omp::allowedExclusiveClauses_OMPD_taskyield,
+      llvm::omp::requiredClauses_OMPD_taskyield,
+    }
+  },
+  {llvm::omp::Directive::OMPD_teams,
+    {
+      llvm::omp::allowedClauses_OMPD_teams,
+      llvm::omp::allowedOnceClauses_OMPD_teams,
+      llvm::omp::allowedExclusiveClauses_OMPD_teams,
+      llvm::omp::requiredClauses_OMPD_teams,
+    }
+  },
+  {llvm::omp::Directive::OMPD_teams_distribute,
+    {
+      llvm::omp::allowedClauses_OMPD_teams_distribute,
+      llvm::omp::allowedOnceClauses_OMPD_teams_distribute,
+      llvm::omp::allowedExclusiveClauses_OMPD_teams_distribute,
+      llvm::omp::requiredClauses_OMPD_teams_distribute,
+    }
+  },
+  {llvm::omp::Directive::OMPD_teams_distribute_parallel_do,
+    {
+      llvm::omp::allowedClauses_OMPD_teams_distribute_parallel_do,
+      llvm::omp::allowedOnceClauses_OMPD_teams_distribute_parallel_do,
+      llvm::omp::allowedExclusiveClauses_OMPD_teams_distribute_parallel_do,
+      llvm::omp::requiredClauses_OMPD_teams_distribute_parallel_do,
+    }
+  },
+  {llvm::omp::Directive::OMPD_teams_distribute_parallel_do_simd,
+    {
+      llvm::omp::allowedClauses_OMPD_teams_distribute_parallel_do_simd,
+      llvm::omp::allowedOnceClauses_OMPD_teams_distribute_parallel_do_simd,
+      llvm::omp::allowedExclusiveClauses_OMPD_teams_distribute_parallel_do_simd,
+      llvm::omp::requiredClauses_OMPD_teams_distribute_parallel_do_simd,
+    }
+  },
+  {llvm::omp::Directive::OMPD_teams_distribute_parallel_for,
+    {
+      llvm::omp::allowedClauses_OMPD_teams_distribute_parallel_for,
+      llvm::omp::allowedOnceClauses_OMPD_teams_distribute_parallel_for,
+      llvm::omp::allowedExclusiveClauses_OMPD_teams_distribute_parallel_for,
+      llvm::omp::requiredClauses_OMPD_teams_distribute_parallel_for,
+    }
+  },
+  {llvm::omp::Directive::OMPD_teams_distribute_parallel_for_simd,
+    {
+      llvm::omp::allowedClauses_OMPD_teams_distribute_parallel_for_simd,
+      llvm::omp::allowedOnceClauses_OMPD_teams_distribute_parallel_for_simd,
+      llvm::omp::allowedExclusiveClauses_OMPD_teams_distribute_parallel_for_simd,
+      llvm::omp::requiredClauses_OMPD_teams_distribute_parallel_for_simd,
+    }
+  },
+  {llvm::omp::Directive::OMPD_teams_distribute_simd,
+    {
+      llvm::omp::allowedClauses_OMPD_teams_distribute_simd,
+      llvm::omp::allowedOnceClauses_OMPD_teams_distribute_simd,
+      llvm::omp::allowedExclusiveClauses_OMPD_teams_distribute_simd,
+      llvm::omp::requiredClauses_OMPD_teams_distribute_simd,
+    }
+  },
+  {llvm::omp::Directive::OMPD_threadprivate,
+    {
+      llvm::omp::allowedClauses_OMPD_threadprivate,
+      llvm::omp::allowedOnceClauses_OMPD_threadprivate,
+      llvm::omp::allowedExclusiveClauses_OMPD_threadprivate,
+      llvm::omp::requiredClauses_OMPD_threadprivate,
+    }
+  },
+  {llvm::omp::Directive::OMPD_unknown,
+    {
+      llvm::omp::allowedClauses_OMPD_unknown,
+      llvm::omp::allowedOnceClauses_OMPD_unknown,
+      llvm::omp::allowedExclusiveClauses_OMPD_unknown,
+      llvm::omp::requiredClauses_OMPD_unknown,
+    }
+  },
+  {llvm::omp::Directive::OMPD_workshare,
+    {
+      llvm::omp::allowedClauses_OMPD_workshare,
+      llvm::omp::allowedOnceClauses_OMPD_workshare,
+      llvm::omp::allowedExclusiveClauses_OMPD_workshare,
+      llvm::omp::requiredClauses_OMPD_workshare,
+    }
+  },
+}
+
+#endif // GEN_FLANG_DIRECTIVE_CLAUSE_MAP
+
+#ifdef GEN_FLANG_CLAUSE_PARSER_CLASSES
+#undef GEN_FLANG_CLAUSE_PARSER_CLASSES
+
+EMPTY_CLASS(AcqRel);
+EMPTY_CLASS(Acquire);
+EMPTY_CLASS(Affinity);
+WRAPPER_CLASS(Allocate, OmpAllocateClause);
+WRAPPER_CLASS(Allocator, ScalarIntExpr);
+EMPTY_CLASS(AtomicDefaultMemOrder);
+EMPTY_CLASS(Capture);
+WRAPPER_CLASS(Collapse, ScalarIntConstantExpr);
+WRAPPER_CLASS(Copyprivate, OmpObjectList);
+WRAPPER_CLASS(Copyin, OmpObjectList);
+WRAPPER_CLASS(Default, OmpDefaultClause);
+EMPTY_CLASS(Depobj);
+EMPTY_CLASS(Destroy);
+EMPTY_CLASS(Detach);
+WRAPPER_CLASS(Device, ScalarIntExpr);
+EMPTY_CLASS(DeviceType);
+WRAPPER_CLASS(DistSchedule, std::optional<ScalarIntExpr>);
+EMPTY_CLASS(DynamicAllocators);
+EMPTY_CLASS(Exclusive);
+WRAPPER_CLASS(Final, ScalarLogicalExpr);
+WRAPPER_CLASS(Firstprivate, OmpObjectList);
+EMPTY_CLASS(Flush);
+WRAPPER_CLASS(From, OmpObjectList);
+WRAPPER_CLASS(Grainsize, ScalarIntExpr);
+WRAPPER_CLASS(Hint, ConstantExpr);
+EMPTY_CLASS(InReduction);
+EMPTY_CLASS(Inbranch);
+EMPTY_CLASS(Inclusive);
+WRAPPER_CLASS(IsDevicePtr, std::list<Name>);
+WRAPPER_CLASS(Lastprivate, OmpObjectList);
+WRAPPER_CLASS(Link, OmpObjectList);
+EMPTY_CLASS(Match);
+EMPTY_CLASS(Mergeable);
+EMPTY_CLASS(Nogroup);
+EMPTY_CLASS(Nowait);
+EMPTY_CLASS(Nontemporal);
+EMPTY_CLASS(Notinbranch);
+WRAPPER_CLASS(NumTasks, ScalarIntExpr);
+WRAPPER_CLASS(NumTeams, ScalarIntExpr);
+WRAPPER_CLASS(NumThreads, ScalarIntExpr);
+EMPTY_CLASS(Order);
+WRAPPER_CLASS(Ordered, std::optional<ScalarIntConstantExpr>);
+WRAPPER_CLASS(Priority, ScalarIntExpr);
+WRAPPER_CLASS(Private, OmpObjectList);
+WRAPPER_CLASS(ProcBind, OmpProcBindClause);
+EMPTY_CLASS(Read);
+WRAPPER_CLASS(Reduction, OmpReductionClause);
+EMPTY_CLASS(Relaxed);
+EMPTY_CLASS(Release);
+EMPTY_CLASS(ReverseOffload);
+WRAPPER_CLASS(Safelen, ScalarIntConstantExpr);
+EMPTY_CLASS(SeqCst);
+WRAPPER_CLASS(Shared, OmpObjectList);
+EMPTY_CLASS(Simd);
+WRAPPER_CLASS(Simdlen, ScalarIntConstantExpr);
+WRAPPER_CLASS(TaskReduction, OmpReductionClause);
+WRAPPER_CLASS(ThreadLimit, ScalarIntExpr);
+EMPTY_CLASS(Threadprivate);
+EMPTY_CLASS(Threads);
+WRAPPER_CLASS(To, OmpObjectList);
+EMPTY_CLASS(UnifiedAddress);
+EMPTY_CLASS(UnifiedSharedMemory);
+WRAPPER_CLASS(Uniform, std::list<Name>);
+EMPTY_CLASS(Unknown);
+EMPTY_CLASS(Untied);
+EMPTY_CLASS(Update);
+EMPTY_CLASS(UseDeviceAddr);
+WRAPPER_CLASS(UseDevicePtr, std::list<Name>);
+EMPTY_CLASS(UsesAllocators);
+EMPTY_CLASS(Write);
+
+#endif // GEN_FLANG_CLAUSE_PARSER_CLASSES
+
+#ifdef GEN_FLANG_CLAUSE_PARSER_CLASSES_LIST
+#undef GEN_FLANG_CLAUSE_PARSER_CLASSES_LIST
+
+AcqRel
+, Acquire
+, Affinity
+, OmpAlignedClause
+, Allocate
+, Allocator
+, AtomicDefaultMemOrder
+, Capture
+, Collapse
+, Copyprivate
+, Copyin
+, Default
+, OmpDefaultmapClause
+, OmpDependClause
+, Depobj
+, Destroy
+, Detach
+, Device
+, DeviceType
+, DistSchedule
+, DynamicAllocators
+, Exclusive
+, Final
+, Firstprivate
+, Flush
+, From
+, Grainsize
+, Hint
+, OmpIfClause
+, InReduction
+, Inbranch
+, Inclusive
+, IsDevicePtr
+, Lastprivate
+, OmpLinearClause
+, Link
+, OmpMapClause
+, Match
+, Mergeable
+, Nogroup
+, Nowait
+, Nontemporal
+, Notinbranch
+, NumTasks
+, NumTeams
+, NumThreads
+, Order
+, Ordered
+, Priority
+, Private
+, ProcBind
+, Read
+, Reduction
+, Relaxed
+, Release
+, ReverseOffload
+, Safelen
+, OmpScheduleClause
+, SeqCst
+, Shared
+, Simd
+, Simdlen
+, TaskReduction
+, ThreadLimit
+, Threadprivate
+, Threads
+, To
+, UnifiedAddress
+, UnifiedSharedMemory
+, Uniform
+, Unknown
+, Untied
+, Update
+, UseDeviceAddr
+, UseDevicePtr
+, UsesAllocators
+, Write
+
+#endif // GEN_FLANG_CLAUSE_PARSER_CLASSES_LIST
+
+#ifdef GEN_FLANG_DUMP_PARSE_TREE_CLAUSES
+#undef GEN_FLANG_DUMP_PARSE_TREE_CLAUSES
+
+NODE(OmpClause, AcqRel)
+NODE(OmpClause, Acquire)
+NODE(OmpClause, Affinity)
+NODE(OmpClause, Allocate)
+NODE(OmpClause, Allocator)
+NODE(OmpClause, AtomicDefaultMemOrder)
+NODE(OmpClause, Capture)
+NODE(OmpClause, Collapse)
+NODE(OmpClause, Copyprivate)
+NODE(OmpClause, Copyin)
+NODE(OmpClause, Default)
+NODE(OmpClause, Depobj)
+NODE(OmpClause, Destroy)
+NODE(OmpClause, Detach)
+NODE(OmpClause, Device)
+NODE(OmpClause, DeviceType)
+NODE(OmpClause, DistSchedule)
+NODE(OmpClause, DynamicAllocators)
+NODE(OmpClause, Exclusive)
+NODE(OmpClause, Final)
+NODE(OmpClause, Firstprivate)
+NODE(OmpClause, Flush)
+NODE(OmpClause, From)
+NODE(OmpClause, Grainsize)
+NODE(OmpClause, Hint)
+NODE(OmpClause, InReduction)
+NODE(OmpClause, Inbranch)
+NODE(OmpClause, Inclusive)
+NODE(OmpClause, IsDevicePtr)
+NODE(OmpClause, Lastprivate)
+NODE(OmpClause, Link)
+NODE(OmpClause, Match)
+NODE(OmpClause, Mergeable)
+NODE(OmpClause, Nogroup)
+NODE(OmpClause, Nowait)
+NODE(OmpClause, Nontemporal)
+NODE(OmpClause, Notinbranch)
+NODE(OmpClause, NumTasks)
+NODE(OmpClause, NumTeams)
+NODE(OmpClause, NumThreads)
+NODE(OmpClause, Order)
+NODE(OmpClause, Ordered)
+NODE(OmpClause, Priority)
+NODE(OmpClause, Private)
+NODE(OmpClause, ProcBind)
+NODE(OmpClause, Read)
+NODE(OmpClause, Reduction)
+NODE(OmpClause, Relaxed)
+NODE(OmpClause, Release)
+NODE(OmpClause, ReverseOffload)
+NODE(OmpClause, Safelen)
+NODE(OmpClause, SeqCst)
+NODE(OmpClause, Shared)
+NODE(OmpClause, Simd)
+NODE(OmpClause, Simdlen)
+NODE(OmpClause, TaskReduction)
+NODE(OmpClause, ThreadLimit)
+NODE(OmpClause, Threadprivate)
+NODE(OmpClause, Threads)
+NODE(OmpClause, To)
+NODE(OmpClause, UnifiedAddress)
+NODE(OmpClause, UnifiedSharedMemory)
+NODE(OmpClause, Uniform)
+NODE(OmpClause, Unknown)
+NODE(OmpClause, Untied)
+NODE(OmpClause, Update)
+NODE(OmpClause, UseDeviceAddr)
+NODE(OmpClause, UseDevicePtr)
+NODE(OmpClause, UsesAllocators)
+NODE(OmpClause, Write)
+
+#endif // GEN_FLANG_DUMP_PARSE_TREE_CLAUSES
+
+#ifdef GEN_FLANG_CLAUSE_UNPARSE
+#undef GEN_FLANG_CLAUSE_UNPARSE
+
+void Before(const OmpClause::AcqRel &) { Word("ACQ_REL"); }
+void Before(const OmpClause::Acquire &) { Word("ACQUIRE"); }
+void Before(const OmpClause::Affinity &) { Word("AFFINITY"); }
+void Unparse(const OmpClause::Allocate &x) {
+  Word("ALLOCATE");
+  Put("(");
+  Walk(x.v);
+  Put(")");
+}
+void Unparse(const OmpClause::Allocator &x) {
+  Word("ALLOCATOR");
+  Put("(");
+  Walk(x.v);
+  Put(")");
+}
+void Before(const OmpClause::AtomicDefaultMemOrder &) { Word("ATOMIC_DEFAULT_MEM_ORDER"); }
+void Before(const OmpClause::Capture &) { Word("CAPTURE"); }
+void Unparse(const OmpClause::Collapse &x) {
+  Word("COLLAPSE");
+  Put("(");
+  Walk(x.v);
+  Put(")");
+}
+void Unparse(const OmpClause::Copyprivate &x) {
+  Word("COPYPRIVATE");
+  Put("(");
+  Walk(x.v);
+  Put(")");
+}
+void Unparse(const OmpClause::Copyin &x) {
+  Word("COPYIN");
+  Put("(");
+  Walk(x.v);
+  Put(")");
+}
+void Unparse(const OmpClause::Default &x) {
+  Word("DEFAULT");
+  Put("(");
+  Walk(x.v);
+  Put(")");
+}
+void Before(const OmpClause::Depobj &) { Word("DEPOBJ"); }
+void Before(const OmpClause::Destroy &) { Word("DESTROY"); }
+void Before(const OmpClause::Detach &) { Word("DETACH"); }
+void Unparse(const OmpClause::Device &x) {
+  Word("DEVICE");
+  Put("(");
+  Walk(x.v);
+  Put(")");
+}
+void Before(const OmpClause::DeviceType &) { Word("DEVICE_TYPE"); }
+void Unparse(const OmpClause::DistSchedule &x) {
+  Word("DIST_SCHEDULE");
+  Walk("(", x.v, ")");
+}
+void Before(const OmpClause::DynamicAllocators &) { Word("DYNAMIC_ALLOCATORS"); }
+void Before(const OmpClause::Exclusive &) { Word("EXCLUSIVE"); }
+void Unparse(const OmpClause::Final &x) {
+  Word("FINAL");
+  Put("(");
+  Walk(x.v);
+  Put(")");
+}
+void Unparse(const OmpClause::Firstprivate &x) {
+  Word("FIRSTPRIVATE");
+  Put("(");
+  Walk(x.v);
+  Put(")");
+}
+void Before(const OmpClause::Flush &) { Word("FLUSH"); }
+void Unparse(const OmpClause::From &x) {
+  Word("FROM");
+  Put("(");
+  Walk(x.v);
+  Put(")");
+}
+void Unparse(const OmpClause::Grainsize &x) {
+  Word("GRAINSIZE");
+  Put("(");
+  Walk(x.v);
+  Put(")");
+}
+void Unparse(const OmpClause::Hint &x) {
+  Word("HINT");
+  Put("(");
+  Walk(x.v);
+  Put(")");
+}
+void Before(const OmpClause::InReduction &) { Word("IN_REDUCTION"); }
+void Before(const OmpClause::Inbranch &) { Word("INBRANCH"); }
+void Before(const OmpClause::Inclusive &) { Word("INCLUSIVE"); }
+void Unparse(const OmpClause::IsDevicePtr &x) {
+  Word("IS_DEVICE_PTR");
+  Put("(");
+  Walk(x.v, ",");
+  Put(")");
+}
+void Unparse(const OmpClause::Lastprivate &x) {
+  Word("LASTPRIVATE");
+  Put("(");
+  Walk(x.v);
+  Put(")");
+}
+void Unparse(const OmpClause::Link &x) {
+  Word("LINK");
+  Put("(");
+  Walk(x.v);
+  Put(")");
+}
+void Before(const OmpClause::Match &) { Word("MATCH"); }
+void Before(const OmpClause::Mergeable &) { Word("MERGEABLE"); }
+void Before(const OmpClause::Nogroup &) { Word("NOGROUP"); }
+void Before(const OmpClause::Nowait &) { Word("NOWAIT"); }
+void Before(const OmpClause::Nontemporal &) { Word("NONTEMPORAL"); }
+void Before(const OmpClause::Notinbranch &) { Word("NOTINBRANCH"); }
+void Unparse(const OmpClause::NumTasks &x) {
+  Word("NUM_TASKS");
+  Put("(");
+  Walk(x.v);
+  Put(")");
+}
+void Unparse(const OmpClause::NumTeams &x) {
+  Word("NUM_TEAMS");
+  Put("(");
+  Walk(x.v);
+  Put(")");
+}
+void Unparse(const OmpClause::NumThreads &x) {
+  Word("NUM_THREADS");
+  Put("(");
+  Walk(x.v);
+  Put(")");
+}
+void Before(const OmpClause::Order &) { Word("ORDER"); }
+void Unparse(const OmpClause::Ordered &x) {
+  Word("ORDERED");
+  Walk("(", x.v, ")");
+}
+void Unparse(const OmpClause::Priority &x) {
+  Word("PRIORITY");
+  Put("(");
+  Walk(x.v);
+  Put(")");
+}
+void Unparse(const OmpClause::Private &x) {
+  Word("PRIVATE");
+  Put("(");
+  Walk(x.v);
+  Put(")");
+}
+void Unparse(const OmpClause::ProcBind &x) {
+  Word("PROC_BIND");
+  Put("(");
+  Walk(x.v);
+  Put(")");
+}
+void Before(const OmpClause::Read &) { Word("READ"); }
+void Unparse(const OmpClause::Reduction &x) {
+  Word("REDUCTION");
+  Put("(");
+  Walk(x.v);
+  Put(")");
+}
+void Before(const OmpClause::Relaxed &) { Word("RELAXED"); }
+void Before(const OmpClause::Release &) { Word("RELEASE"); }
+void Before(const OmpClause::ReverseOffload &) { Word("REVERSE_OFFLOAD"); }
+void Unparse(const OmpClause::Safelen &x) {
+  Word("SAFELEN");
+  Put("(");
+  Walk(x.v);
+  Put(")");
+}
+void Before(const OmpClause::SeqCst &) { Word("SEQ_CST"); }
+void Unparse(const OmpClause::Shared &x) {
+  Word("SHARED");
+  Put("(");
+  Walk(x.v);
+  Put(")");
+}
+void Before(const OmpClause::Simd &) { Word("SIMD"); }
+void Unparse(const OmpClause::Simdlen &x) {
+  Word("SIMDLEN");
+  Put("(");
+  Walk(x.v);
+  Put(")");
+}
+void Unparse(const OmpClause::TaskReduction &x) {
+  Word("TASK_REDUCTION");
+  Put("(");
+  Walk(x.v);
+  Put(")");
+}
+void Unparse(const OmpClause::ThreadLimit &x) {
+  Word("THREAD_LIMIT");
+  Put("(");
+  Walk(x.v);
+  Put(")");
+}
+void Before(const OmpClause::Threadprivate &) { Word("THREADPRIVATE"); }
+void Before(const OmpClause::Threads &) { Word("THREADS"); }
+void Unparse(const OmpClause::To &x) {
+  Word("TO");
+  Put("(");
+  Walk(x.v);
+  Put(")");
+}
+void Before(const OmpClause::UnifiedAddress &) { Word("UNIFIED_ADDRESS"); }
+void Before(const OmpClause::UnifiedSharedMemory &) { Word("UNIFIED_SHARED_MEMORY"); }
+void Unparse(const OmpClause::Uniform &x) {
+  Word("UNIFORM");
+  Put("(");
+  Walk(x.v, ",");
+  Put(")");
+}
+void Before(const OmpClause::Unknown &) { Word("UNKNOWN"); }
+void Before(const OmpClause::Untied &) { Word("UNTIED"); }
+void Before(const OmpClause::Update &) { Word("UPDATE"); }
+void Before(const OmpClause::UseDeviceAddr &) { Word("USE_DEVICE_ADDR"); }
+void Unparse(const OmpClause::UseDevicePtr &x) {
+  Word("USE_DEVICE_PTR");
+  Put("(");
+  Walk(x.v, ",");
+  Put(")");
+}
+void Before(const OmpClause::UsesAllocators &) { Word("USES_ALLOCATORS"); }
+void Before(const OmpClause::Write &) { Word("WRITE"); }
+
+#endif // GEN_FLANG_CLAUSE_UNPARSE
+
+#ifdef GEN_CLANG_CLAUSE_CLASS
+#undef GEN_CLANG_CLAUSE_CLASS
+
+#ifndef CLAUSE
+#define CLAUSE(Enum, Str, Implicit)
+#endif
+#ifndef CLAUSE_CLASS
+#define CLAUSE_CLASS(Enum, Str, Class)
+#endif
+#ifndef CLAUSE_NO_CLASS
+#define CLAUSE_NO_CLASS(Enum, Str)
+#endif
+
+#define __CLAUSE(Name, Class)                      \
+  CLAUSE(OMPC_##Name, #Name, /* Implicit */ false) \
+  CLAUSE_CLASS(OMPC_##Name, #Name, Class)
+#define __CLAUSE_NO_CLASS(Name)                    \
+  CLAUSE(OMPC_##Name, #Name, /* Implicit */ false) \
+  CLAUSE_NO_CLASS(OMPC_##Name, #Name)
+#define __IMPLICIT_CLAUSE_CLASS(Name, Str, Class)  \
+  CLAUSE(OMPC_##Name, Str, /* Implicit */ true)    \
+  CLAUSE_CLASS(OMPC_##Name, Str, Class)
+#define __IMPLICIT_CLAUSE_NO_CLASS(Name, Str)      \
+  CLAUSE(OMPC_##Name, Str, /* Implicit */ true)    \
+  CLAUSE_NO_CLASS(OMPC_##Name, Str)
+
+__CLAUSE(acq_rel, OMPAcqRelClause)
+__CLAUSE(acquire, OMPAcquireClause)
+__CLAUSE(affinity, OMPAffinityClause)
+__CLAUSE(aligned, OMPAlignedClause)
+__CLAUSE(allocate, OMPAllocateClause)
+__CLAUSE(allocator, OMPAllocatorClause)
+__CLAUSE(atomic_default_mem_order, OMPAtomicDefaultMemOrderClause)
+__CLAUSE(capture, OMPCaptureClause)
+__CLAUSE(collapse, OMPCollapseClause)
+__CLAUSE(copyprivate, OMPCopyprivateClause)
+__CLAUSE(copyin, OMPCopyinClause)
+__CLAUSE(default, OMPDefaultClause)
+__CLAUSE(defaultmap, OMPDefaultmapClause)
+__CLAUSE(depend, OMPDependClause)
+__IMPLICIT_CLAUSE_CLASS(depobj, "depobj", OMPDepobjClause)
+__CLAUSE(destroy, OMPDestroyClause)
+__CLAUSE(detach, OMPDetachClause)
+__CLAUSE(device, OMPDeviceClause)
+__CLAUSE_NO_CLASS(device_type)
+__CLAUSE(dist_schedule, OMPDistScheduleClause)
+__CLAUSE(dynamic_allocators, OMPDynamicAllocatorsClause)
+__CLAUSE(exclusive, OMPExclusiveClause)
+__CLAUSE(final, OMPFinalClause)
+__CLAUSE(firstprivate, OMPFirstprivateClause)
+__IMPLICIT_CLAUSE_CLASS(flush, "flush", OMPFlushClause)
+__CLAUSE(from, OMPFromClause)
+__CLAUSE(grainsize, OMPGrainsizeClause)
+__CLAUSE(hint, OMPHintClause)
+__CLAUSE(if, OMPIfClause)
+__CLAUSE(in_reduction, OMPInReductionClause)
+__CLAUSE_NO_CLASS(inbranch)
+__CLAUSE(inclusive, OMPInclusiveClause)
+__CLAUSE(is_device_ptr, OMPIsDevicePtrClause)
+__CLAUSE(lastprivate, OMPLastprivateClause)
+__CLAUSE(linear, OMPLinearClause)
+__CLAUSE_NO_CLASS(link)
+__CLAUSE(map, OMPMapClause)
+__CLAUSE_NO_CLASS(match)
+__CLAUSE(mergeable, OMPMergeableClause)
+__CLAUSE(nogroup, OMPNogroupClause)
+__CLAUSE(nowait, OMPNowaitClause)
+__CLAUSE(nontemporal, OMPNontemporalClause)
+__CLAUSE_NO_CLASS(notinbranch)
+__CLAUSE(num_tasks, OMPNumTasksClause)
+__CLAUSE(num_teams, OMPNumTeamsClause)
+__CLAUSE(num_threads, OMPNumThreadsClause)
+__CLAUSE(order, OMPOrderClause)
+__CLAUSE(ordered, OMPOrderedClause)
+__CLAUSE(priority, OMPPriorityClause)
+__CLAUSE(private, OMPPrivateClause)
+__CLAUSE(proc_bind, OMPProcBindClause)
+__CLAUSE(read, OMPReadClause)
+__CLAUSE(reduction, OMPReductionClause)
+__CLAUSE(relaxed, OMPRelaxedClause)
+__CLAUSE(release, OMPReleaseClause)
+__CLAUSE(reverse_offload, OMPReverseOffloadClause)
+__CLAUSE(safelen, OMPSafelenClause)
+__CLAUSE(schedule, OMPScheduleClause)
+__CLAUSE(seq_cst, OMPSeqCstClause)
+__CLAUSE(shared, OMPSharedClause)
+__CLAUSE(simd, OMPSIMDClause)
+__CLAUSE(simdlen, OMPSimdlenClause)
+__CLAUSE(task_reduction, OMPTaskReductionClause)
+__CLAUSE(thread_limit, OMPThreadLimitClause)
+__IMPLICIT_CLAUSE_NO_CLASS(threadprivate, "threadprivate")
+__CLAUSE(threads, OMPThreadsClause)
+__CLAUSE(to, OMPToClause)
+__CLAUSE(unified_address, OMPUnifiedAddressClause)
+__CLAUSE(unified_shared_memory, OMPUnifiedSharedMemoryClause)
+__CLAUSE_NO_CLASS(uniform)
+__IMPLICIT_CLAUSE_NO_CLASS(unknown, "unknown")
+__CLAUSE(untied, OMPUntiedClause)
+__CLAUSE(update, OMPUpdateClause)
+__CLAUSE(use_device_addr, OMPUseDeviceAddrClause)
+__CLAUSE(use_device_ptr, OMPUseDevicePtrClause)
+__CLAUSE(uses_allocators, OMPUsesAllocatorsClause)
+__CLAUSE(write, OMPWriteClause)
+
+#undef __IMPLICIT_CLAUSE_NO_CLASS
+#undef __IMPLICIT_CLAUSE_CLASS
+#undef __CLAUSE
+#undef CLAUSE_NO_CLASS
+#undef CLAUSE_CLASS
+#undef CLAUSE
+
+#endif // GEN_CLANG_CLAUSE_CLASS
+
diff --git a/linux-x64/clang/include/llvm/Frontend/OpenMP/OMP.td b/linux-x64/clang/include/llvm/Frontend/OpenMP/OMP.td
new file mode 100644
index 0000000..b5b5bb2
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Frontend/OpenMP/OMP.td
@@ -0,0 +1,1639 @@
+//===-- OMP.td - OpenMP directive definition file ----------*- tablegen -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This is the definition file for OpenMP directives and clauses.
+//
+//===----------------------------------------------------------------------===//
+
+include "llvm/Frontend/Directive/DirectiveBase.td"
+
+//===----------------------------------------------------------------------===//
+// Definition of general OpenMP information
+//===----------------------------------------------------------------------===//
+
+def OpenMP : DirectiveLanguage {
+  let name = "OpenMP";
+  let cppNamespace = "omp"; // final namespace will be llvm::omp
+  let directivePrefix = "OMPD_";
+  let clausePrefix = "OMPC_";
+  let makeEnumAvailableInNamespace = true;
+  let enableBitmaskEnumInNamespace = true;
+  let includeHeader = "llvm/Frontend/OpenMP/OMP.h.inc";
+  let clauseEnumSetClass = "OmpClauseSet";
+  let flangClauseBaseClass = "OmpClause";
+}
+
+//===----------------------------------------------------------------------===//
+// Definition of OpenMP clauses
+//===----------------------------------------------------------------------===//
+
+def OMPC_Allocator : Clause<"allocator"> {
+  let clangClass = "OMPAllocatorClause";
+  let flangClassValue = "ScalarIntExpr";
+}
+def OMPC_If : Clause<"if"> {
+  let clangClass = "OMPIfClause";
+  let flangClass = "OmpIfClause";
+}
+def OMPC_Final : Clause<"final"> {
+  let clangClass = "OMPFinalClause";
+  let flangClassValue = "ScalarLogicalExpr";
+}
+def OMPC_NumThreads : Clause<"num_threads"> {
+  let clangClass = "OMPNumThreadsClause";
+  let flangClassValue = "ScalarIntExpr";
+}
+def OMPC_SafeLen : Clause<"safelen"> {
+  let clangClass = "OMPSafelenClause";
+  let flangClassValue = "ScalarIntConstantExpr";
+}
+def OMPC_SimdLen : Clause<"simdlen"> {
+  let clangClass = "OMPSimdlenClause";
+  let flangClassValue = "ScalarIntConstantExpr";
+}
+def OMPC_Collapse : Clause<"collapse"> {
+  let clangClass = "OMPCollapseClause";
+  let flangClassValue = "ScalarIntConstantExpr";
+}
+def OMPC_Default : Clause<"default"> {
+  let clangClass = "OMPDefaultClause";
+  let flangClassValue = "OmpDefaultClause";
+}
+def OMPC_Private : Clause<"private"> {
+  let clangClass = "OMPPrivateClause";
+  let flangClassValue = "OmpObjectList";
+}
+def OMPC_FirstPrivate : Clause<"firstprivate"> {
+  let clangClass = "OMPFirstprivateClause";
+  let flangClassValue = "OmpObjectList";
+}
+def OMPC_LastPrivate : Clause<"lastprivate"> {
+  let clangClass = "OMPLastprivateClause";
+  let flangClassValue = "OmpObjectList";
+}
+def OMPC_Shared : Clause<"shared"> {
+  let clangClass = "OMPSharedClause";
+  let flangClassValue = "OmpObjectList";
+}
+def OMPC_Reduction : Clause<"reduction"> {
+  let clangClass = "OMPReductionClause";
+  let flangClassValue = "OmpReductionClause";
+}
+def OMPC_Linear : Clause<"linear"> {
+  let clangClass = "OMPLinearClause";
+  let flangClass = "OmpLinearClause";
+}
+def OMPC_Aligned : Clause<"aligned"> {
+  let clangClass = "OMPAlignedClause";
+  let flangClass = "OmpAlignedClause";
+}
+def OMPC_Copyin : Clause<"copyin"> {
+  let clangClass = "OMPCopyinClause";
+  let flangClassValue = "OmpObjectList";
+}
+def OMPC_CopyPrivate : Clause<"copyprivate"> {
+  let clangClass = "OMPCopyprivateClause";
+  let flangClassValue = "OmpObjectList";
+}
+def OMP_PROC_BIND_master : ClauseVal<"master",2,1> {}
+def OMP_PROC_BIND_close : ClauseVal<"close",3,1> {}
+def OMP_PROC_BIND_spread : ClauseVal<"spread",4,1> {}
+def OMP_PROC_BIND_default : ClauseVal<"default",5,0> {}
+def OMP_PROC_BIND_unknown : ClauseVal<"unknown",6,0> { let isDefault = true; }
+def OMPC_ProcBind : Clause<"proc_bind"> {
+  let clangClass = "OMPProcBindClause";
+  let flangClassValue = "OmpProcBindClause";
+  let enumClauseValue = "ProcBindKind";
+  let allowedClauseValues = [
+    OMP_PROC_BIND_master,
+    OMP_PROC_BIND_close,
+    OMP_PROC_BIND_spread,
+    OMP_PROC_BIND_default,
+    OMP_PROC_BIND_unknown
+  ];
+}
+
+// static and auto are C++ keywords so need a capital to disambiguate.
+def OMP_SCHEDULE_Static : ClauseVal<"Static", 2, 1> {}
+def OMP_SCHEDULE_Dynamic : ClauseVal<"Dynamic", 3, 1> {}
+def OMP_SCHEDULE_Guided : ClauseVal<"Guided", 4, 1> {}
+def OMP_SCHEDULE_Auto : ClauseVal<"Auto", 5, 1> {}
+def OMP_SCHEDULE_Runtime : ClauseVal<"Runtime", 6, 1> {}
+def OMP_SCHEDULE_Default : ClauseVal<"Default", 7, 0> { let isDefault = 1; }
+
+def OMPC_Schedule : Clause<"schedule"> {
+  let clangClass = "OMPScheduleClause";
+  let flangClass = "OmpScheduleClause";
+  let enumClauseValue = "ScheduleKind";
+  let allowedClauseValues = [
+    OMP_SCHEDULE_Static,
+    OMP_SCHEDULE_Dynamic,
+    OMP_SCHEDULE_Guided,
+    OMP_SCHEDULE_Auto,
+    OMP_SCHEDULE_Runtime,
+    OMP_SCHEDULE_Default
+  ];
+}
+
+def OMPC_Ordered : Clause<"ordered"> {
+  let clangClass = "OMPOrderedClause";
+  let flangClassValue = "ScalarIntConstantExpr";
+  let isValueOptional = true;
+}
+def OMPC_NoWait : Clause<"nowait"> {
+  let clangClass = "OMPNowaitClause";
+}
+def OMPC_Untied : Clause<"untied"> { let clangClass = "OMPUntiedClause"; }
+def OMPC_Mergeable : Clause<"mergeable"> {
+  let clangClass = "OMPMergeableClause";
+}
+def OMPC_Read : Clause<"read"> { let clangClass = "OMPReadClause"; }
+def OMPC_Write : Clause<"write"> { let clangClass = "OMPWriteClause"; }
+def OMPC_Update : Clause<"update"> { let clangClass = "OMPUpdateClause"; }
+def OMPC_Capture : Clause<"capture"> { let clangClass = "OMPCaptureClause"; }
+def OMPC_SeqCst : Clause<"seq_cst"> { let clangClass = "OMPSeqCstClause"; }
+def OMPC_AcqRel : Clause<"acq_rel"> { let clangClass = "OMPAcqRelClause"; }
+def OMPC_Acquire : Clause<"acquire"> { let clangClass = "OMPAcquireClause"; }
+def OMPC_Release : Clause<"release"> { let clangClass = "OMPReleaseClause"; }
+def OMPC_Relaxed : Clause<"relaxed"> { let clangClass = "OMPRelaxedClause"; }
+def OMPC_Depend : Clause<"depend"> {
+  let clangClass = "OMPDependClause";
+  let flangClass = "OmpDependClause";
+}
+def OMPC_Device : Clause<"device"> {
+  let clangClass = "OMPDeviceClause";
+  let flangClassValue = "ScalarIntExpr";
+}
+def OMPC_Threads : Clause<"threads"> { let clangClass = "OMPThreadsClause"; }
+def OMPC_Simd : Clause<"simd"> { let clangClass = "OMPSIMDClause"; }
+def OMPC_Map : Clause<"map"> {
+  let clangClass = "OMPMapClause";
+  let flangClass = "OmpMapClause";
+}
+def OMPC_NumTeams : Clause<"num_teams"> {
+  let clangClass = "OMPNumTeamsClause";
+  let flangClassValue = "ScalarIntExpr";
+}
+def OMPC_ThreadLimit : Clause<"thread_limit"> {
+  let clangClass = "OMPThreadLimitClause";
+  let flangClassValue = "ScalarIntExpr";
+}
+def OMPC_Priority : Clause<"priority"> {
+  let clangClass = "OMPPriorityClause";
+  let flangClassValue = "ScalarIntExpr";
+}
+def OMPC_GrainSize : Clause<"grainsize"> {
+  let clangClass = "OMPGrainsizeClause";
+  let flangClassValue = "ScalarIntExpr";
+}
+def OMPC_NoGroup : Clause<"nogroup"> {
+  let clangClass = "OMPNogroupClause";
+}
+def OMPC_NumTasks : Clause<"num_tasks"> {
+  let clangClass = "OMPNumTasksClause";
+  let flangClassValue = "ScalarIntExpr";
+}
+def OMPC_Hint : Clause<"hint"> {
+  let clangClass = "OMPHintClause";
+  let flangClassValue = "ConstantExpr";
+}
+def OMPC_DistSchedule : Clause<"dist_schedule"> {
+  let clangClass = "OMPDistScheduleClause";
+  let flangClassValue = "ScalarIntExpr";
+  let isValueOptional = true;
+}
+def OMPC_DefaultMap : Clause<"defaultmap"> {
+  let clangClass = "OMPDefaultmapClause";
+  let flangClass = "OmpDefaultmapClause";
+}
+def OMPC_To : Clause<"to"> {
+  let clangClass = "OMPToClause";
+  let flangClassValue = "OmpObjectList";
+}
+def OMPC_From : Clause<"from"> {
+  let clangClass = "OMPFromClause";
+  let flangClassValue = "OmpObjectList";
+}
+def OMPC_UseDevicePtr : Clause<"use_device_ptr"> {
+  let clangClass = "OMPUseDevicePtrClause";
+  let flangClassValue = "Name";
+  let isValueList = true;
+}
+def OMPC_IsDevicePtr : Clause<"is_device_ptr"> {
+  let clangClass = "OMPIsDevicePtrClause";
+  let flangClassValue = "Name";
+  let isValueList = true;
+}
+def OMPC_TaskReduction : Clause<"task_reduction"> {
+  let clangClass = "OMPTaskReductionClause";
+  let flangClassValue = "OmpReductionClause";
+}
+def OMPC_InReduction : Clause<"in_reduction"> {
+  let clangClass = "OMPInReductionClause";
+}
+def OMPC_UnifiedAddress : Clause<"unified_address"> {
+  let clangClass = "OMPUnifiedAddressClause";
+}
+def OMPC_UnifiedSharedMemory : Clause<"unified_shared_memory"> {
+  let clangClass = "OMPUnifiedSharedMemoryClause";
+}
+def OMPC_ReverseOffload : Clause<"reverse_offload"> {
+  let clangClass = "OMPReverseOffloadClause";
+}
+def OMPC_DynamicAllocators : Clause<"dynamic_allocators"> {
+  let clangClass = "OMPDynamicAllocatorsClause";
+}
+def OMPC_AtomicDefaultMemOrder : Clause<"atomic_default_mem_order"> {
+  let clangClass = "OMPAtomicDefaultMemOrderClause";
+}
+def OMPC_Allocate : Clause<"allocate"> {
+  let clangClass = "OMPAllocateClause";
+  let flangClassValue = "OmpAllocateClause";
+}
+def OMPC_NonTemporal : Clause<"nontemporal"> {
+  let clangClass = "OMPNontemporalClause";
+}
+
+def OMP_ORDER_concurrent : ClauseVal<"default",2,0> { let isDefault = 1; }
+def OMPC_Order : Clause<"order"> {
+  let clangClass = "OMPOrderClause";
+  let enumClauseValue = "OrderKind";
+  let allowedClauseValues = [
+    OMP_ORDER_concurrent
+  ];
+}
+def OMPC_Destroy : Clause<"destroy"> {
+  let clangClass = "OMPDestroyClause";
+}
+def OMPC_Detach : Clause<"detach"> {
+  let clangClass = "OMPDetachClause";
+}
+def OMPC_Inclusive : Clause<"inclusive"> {
+  let clangClass = "OMPInclusiveClause";
+}
+def OMPC_Exclusive : Clause<"exclusive"> {
+  let clangClass = "OMPExclusiveClause";
+}
+def OMPC_UsesAllocators : Clause<"uses_allocators"> {
+  let clangClass = "OMPUsesAllocatorsClause";
+}
+def OMPC_Affinity : Clause<"affinity"> {
+  let clangClass = "OMPAffinityClause";
+}
+def OMPC_UseDeviceAddr : Clause<"use_device_addr"> {
+  let clangClass = "OMPUseDeviceAddrClause";
+}
+def OMPC_Uniform : Clause<"uniform"> {
+  let flangClassValue = "Name";
+  let isValueList = true;
+}
+def OMPC_DeviceType : Clause<"device_type"> {}
+def OMPC_Match : Clause<"match"> {}
+def OMPC_Depobj : Clause<"depobj"> {
+  let clangClass = "OMPDepobjClause";
+  let isImplicit = true;
+}
+def OMPC_Flush : Clause<"flush"> {
+  let clangClass = "OMPFlushClause";
+  let isImplicit = true;
+}
+def OMPC_ThreadPrivate : Clause<"threadprivate"> {
+  let alternativeName = "threadprivate or thread local";
+  let isImplicit = true;
+}
+def OMPC_Unknown : Clause<"unknown"> {
+  let isImplicit = true;
+  let isDefault = true;
+}
+def OMPC_Link : Clause<"link"> {
+  let flangClassValue = "OmpObjectList";
+}
+def OMPC_Inbranch : Clause<"inbranch"> {}
+def OMPC_Notinbranch : Clause<"notinbranch"> {}
+
+//===----------------------------------------------------------------------===//
+// Definition of OpenMP directives
+//===----------------------------------------------------------------------===//
+
+def OMP_ThreadPrivate : Directive<"threadprivate"> {}
+def OMP_Parallel : Directive<"parallel"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_Private>,
+    VersionedClause<OMPC_FirstPrivate>,
+    VersionedClause<OMPC_Shared>,
+    VersionedClause<OMPC_Reduction>,
+    VersionedClause<OMPC_Copyin>,
+    VersionedClause<OMPC_Allocate>
+  ];
+  let allowedOnceClauses = [
+    VersionedClause<OMPC_Default>,
+    VersionedClause<OMPC_If>,
+    VersionedClause<OMPC_NumThreads>,
+    VersionedClause<OMPC_ProcBind>,
+  ];
+}
+def OMP_Task : Directive<"task"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_Private>,
+    VersionedClause<OMPC_FirstPrivate>,
+    VersionedClause<OMPC_Shared>,
+    VersionedClause<OMPC_Untied>,
+    VersionedClause<OMPC_Mergeable>,
+    VersionedClause<OMPC_Depend>,
+    VersionedClause<OMPC_InReduction>,
+    VersionedClause<OMPC_Allocate>,
+    VersionedClause<OMPC_Detach, 50>,
+    VersionedClause<OMPC_Affinity, 50>
+  ];
+  let allowedOnceClauses = [
+    VersionedClause<OMPC_Default>,
+    VersionedClause<OMPC_If>,
+    VersionedClause<OMPC_Final>,
+    VersionedClause<OMPC_Priority>
+  ];
+}
+def OMP_Simd : Directive<"simd"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_Private>,
+    VersionedClause<OMPC_LastPrivate>,
+    VersionedClause<OMPC_Linear>,
+    VersionedClause<OMPC_Aligned>,
+    VersionedClause<OMPC_Reduction>,
+    VersionedClause<OMPC_Allocate>,
+    VersionedClause<OMPC_NonTemporal, 50>,
+    VersionedClause<OMPC_Order, 50>
+  ];
+  let allowedOnceClauses = [
+    VersionedClause<OMPC_Collapse>,
+    VersionedClause<OMPC_SafeLen>,
+    VersionedClause<OMPC_SimdLen>,
+    VersionedClause<OMPC_If, 50>,
+  ];
+}
+def OMP_For : Directive<"for"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_Private>,
+    VersionedClause<OMPC_LastPrivate>,
+    VersionedClause<OMPC_FirstPrivate>,
+    VersionedClause<OMPC_Reduction>,
+    VersionedClause<OMPC_Collapse>,
+    VersionedClause<OMPC_Schedule>,
+    VersionedClause<OMPC_Ordered>,
+    VersionedClause<OMPC_NoWait>,
+    VersionedClause<OMPC_Linear>,
+    VersionedClause<OMPC_Allocate>,
+    VersionedClause<OMPC_Order, 50>
+  ];
+}
+def OMP_Do : Directive<"do"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_Private>,
+    VersionedClause<OMPC_FirstPrivate>,
+    VersionedClause<OMPC_LastPrivate>,
+    VersionedClause<OMPC_Linear>,
+    VersionedClause<OMPC_Reduction>
+  ];
+  let allowedOnceClauses = [
+    VersionedClause<OMPC_Schedule>,
+    VersionedClause<OMPC_Collapse>,
+    VersionedClause<OMPC_Ordered>,
+    VersionedClause<OMPC_NoWait>
+  ];
+}
+def OMP_Sections : Directive<"sections"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_Private>,
+    VersionedClause<OMPC_LastPrivate>,
+    VersionedClause<OMPC_FirstPrivate>,
+    VersionedClause<OMPC_Reduction>,
+    VersionedClause<OMPC_NoWait>,
+    VersionedClause<OMPC_Allocate>
+  ];
+}
+def OMP_Section : Directive<"section"> {}
+def OMP_Single : Directive<"single"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_Private>,
+    VersionedClause<OMPC_FirstPrivate>,
+    VersionedClause<OMPC_CopyPrivate>,
+    VersionedClause<OMPC_NoWait>,
+    VersionedClause<OMPC_Allocate>
+  ];
+}
+def OMP_Master : Directive<"master"> {}
+def OMP_Critical : Directive<"critical"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_Hint>
+  ];
+}
+def OMP_TaskYield : Directive<"taskyield"> {}
+def OMP_Barrier : Directive<"barrier"> {}
+def OMP_TaskWait : Directive<"taskwait"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_Depend, 50>
+  ];
+}
+def OMP_TaskGroup : Directive<"taskgroup"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_TaskReduction>,
+    VersionedClause<OMPC_Allocate>
+  ];
+}
+def OMP_Flush : Directive<"flush"> {
+  let allowedOnceClauses = [
+    VersionedClause<OMPC_AcqRel, 50>,
+    VersionedClause<OMPC_Acquire, 50>,
+    VersionedClause<OMPC_Release, 50>,
+    // TODO This should ne `none` instead. Comment carried over from
+    // OMPKinds.def.
+    VersionedClause<OMPC_Flush>
+  ];
+}
+def OMP_Ordered : Directive<"ordered"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_Threads>,
+    VersionedClause<OMPC_Simd>,
+    VersionedClause<OMPC_Depend>
+  ];
+}
+def OMP_Atomic : Directive<"atomic"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_Read>,
+    VersionedClause<OMPC_Write>,
+    VersionedClause<OMPC_Update>,
+    VersionedClause<OMPC_Capture>,
+  ];
+  let allowedOnceClauses = [
+    VersionedClause<OMPC_SeqCst>,
+    VersionedClause<OMPC_AcqRel, 50>,
+    VersionedClause<OMPC_Acquire, 50>,
+    VersionedClause<OMPC_Release, 50>,
+    VersionedClause<OMPC_Relaxed, 50>,
+    VersionedClause<OMPC_Hint, 50>
+  ];
+}
+def OMP_Target : Directive<"target"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_If>,
+    VersionedClause<OMPC_Map>,
+    VersionedClause<OMPC_Private>,
+    VersionedClause<OMPC_Depend>,
+    VersionedClause<OMPC_FirstPrivate>,
+    VersionedClause<OMPC_IsDevicePtr>,
+    VersionedClause<OMPC_Reduction>,
+    VersionedClause<OMPC_Allocate>,
+    VersionedClause<OMPC_UsesAllocators, 50>
+  ];
+  let allowedOnceClauses = [
+    VersionedClause<OMPC_Device>,
+    VersionedClause<OMPC_DefaultMap>,
+    VersionedClause<OMPC_NoWait>
+  ];
+}
+def OMP_Teams : Directive<"teams"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_Private>,
+    VersionedClause<OMPC_FirstPrivate>,
+    VersionedClause<OMPC_Shared>,
+    VersionedClause<OMPC_Reduction>,
+    VersionedClause<OMPC_Allocate>
+  ];
+  let allowedOnceClauses = [
+    VersionedClause<OMPC_Default>,
+    VersionedClause<OMPC_NumTeams>,
+    VersionedClause<OMPC_ThreadLimit>
+  ];
+}
+def OMP_Cancel : Directive<"cancel"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_If>
+  ];
+}
+def OMP_Requires : Directive<"requires"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_UnifiedAddress>,
+    VersionedClause<OMPC_UnifiedSharedMemory>,
+    VersionedClause<OMPC_ReverseOffload>,
+    VersionedClause<OMPC_DynamicAllocators>,
+    VersionedClause<OMPC_AtomicDefaultMemOrder>
+  ];
+}
+def OMP_TargetData : Directive<"target data"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_UseDevicePtr>,
+    VersionedClause<OMPC_UseDeviceAddr, 50>
+  ];
+  let allowedOnceClauses = [
+    VersionedClause<OMPC_Device>,
+    VersionedClause<OMPC_If>
+  ];
+  let requiredClauses = [
+    VersionedClause<OMPC_Map>
+  ];
+}
+def OMP_TargetEnterData : Directive<"target enter data"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_Depend>
+  ];
+  let allowedOnceClauses = [
+    VersionedClause<OMPC_If>,
+    VersionedClause<OMPC_Device>,
+    VersionedClause<OMPC_NoWait>
+  ];
+  let requiredClauses = [
+    VersionedClause<OMPC_Map>
+  ];
+}
+def OMP_TargetExitData : Directive<"target exit data"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_Depend>
+  ];
+  let allowedOnceClauses = [
+    VersionedClause<OMPC_Device>,
+    VersionedClause<OMPC_If>,
+    VersionedClause<OMPC_NoWait>
+  ];
+  let requiredClauses = [
+    VersionedClause<OMPC_Map>
+  ];
+}
+def OMP_TargetParallel : Directive<"target parallel"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_Map>,
+    VersionedClause<OMPC_NoWait>,
+    VersionedClause<OMPC_Depend>,
+    VersionedClause<OMPC_Private>,
+    VersionedClause<OMPC_FirstPrivate>,
+    VersionedClause<OMPC_Default>,
+    VersionedClause<OMPC_Shared>,
+    VersionedClause<OMPC_Reduction>,
+    VersionedClause<OMPC_IsDevicePtr>,
+    VersionedClause<OMPC_Allocate>,
+    VersionedClause<OMPC_UsesAllocators, 50>
+  ];
+  let allowedOnceClauses = [
+    VersionedClause<OMPC_DefaultMap>,
+    VersionedClause<OMPC_Device>,
+    VersionedClause<OMPC_If>,
+    VersionedClause<OMPC_NumThreads>,
+    VersionedClause<OMPC_ProcBind>
+  ];
+}
+def OMP_TargetParallelFor : Directive<"target parallel for"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_If>,
+    VersionedClause<OMPC_Device>,
+    VersionedClause<OMPC_Map>,
+    VersionedClause<OMPC_Private>,
+    VersionedClause<OMPC_FirstPrivate>,
+    VersionedClause<OMPC_LastPrivate>,
+    VersionedClause<OMPC_NoWait>,
+    VersionedClause<OMPC_Depend>,
+    VersionedClause<OMPC_DefaultMap>,
+    VersionedClause<OMPC_NumThreads>,
+    VersionedClause<OMPC_Default>,
+    VersionedClause<OMPC_ProcBind>,
+    VersionedClause<OMPC_Shared>,
+    VersionedClause<OMPC_Reduction>,
+    VersionedClause<OMPC_Collapse>,
+    VersionedClause<OMPC_Schedule>,
+    VersionedClause<OMPC_Ordered>,
+    VersionedClause<OMPC_Linear>,
+    VersionedClause<OMPC_IsDevicePtr>,
+    VersionedClause<OMPC_Allocate>,
+    VersionedClause<OMPC_Order, 50>,
+    VersionedClause<OMPC_UsesAllocators, 50>
+  ];
+}
+def OMP_TargetParallelDo : Directive<"target parallel do"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_Map>,
+    VersionedClause<OMPC_Private>,
+    VersionedClause<OMPC_FirstPrivate>,
+    VersionedClause<OMPC_LastPrivate>,
+    VersionedClause<OMPC_Depend>,
+    VersionedClause<OMPC_Shared>,
+    VersionedClause<OMPC_Reduction>,
+    VersionedClause<OMPC_Linear>,
+    VersionedClause<OMPC_IsDevicePtr>,
+    VersionedClause<OMPC_Allocator>,
+    VersionedClause<OMPC_Order>,
+    VersionedClause<OMPC_UsesAllocators>,
+    VersionedClause<OMPC_Default>,
+    VersionedClause<OMPC_Copyin>
+  ];
+  let allowedOnceClauses = [
+    VersionedClause<OMPC_If>,
+    VersionedClause<OMPC_NumThreads>,
+    VersionedClause<OMPC_ProcBind>,
+    VersionedClause<OMPC_Device>,
+    VersionedClause<OMPC_DefaultMap>,
+    VersionedClause<OMPC_Schedule>,
+    VersionedClause<OMPC_Collapse>,
+    VersionedClause<OMPC_Ordered>,
+    VersionedClause<OMPC_NoWait>
+  ];
+}
+def OMP_TargetUpdate : Directive<"target update"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_If>,
+    VersionedClause<OMPC_Device>,
+    VersionedClause<OMPC_To>,
+    VersionedClause<OMPC_From>,
+    VersionedClause<OMPC_NoWait>,
+    VersionedClause<OMPC_Depend>
+  ];
+}
+def OMP_ParallelFor : Directive<"parallel for"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_If>,
+    VersionedClause<OMPC_NumThreads>,
+    VersionedClause<OMPC_Default>,
+    VersionedClause<OMPC_ProcBind>,
+    VersionedClause<OMPC_Private>,
+    VersionedClause<OMPC_FirstPrivate>,
+    VersionedClause<OMPC_Shared>,
+    VersionedClause<OMPC_Reduction>,
+    VersionedClause<OMPC_Copyin>,
+    VersionedClause<OMPC_LastPrivate>,
+    VersionedClause<OMPC_Collapse>,
+    VersionedClause<OMPC_Schedule>,
+    VersionedClause<OMPC_Ordered>,
+    VersionedClause<OMPC_Linear>,
+    VersionedClause<OMPC_Allocate>,
+    VersionedClause<OMPC_Order, 50>
+  ];
+}
+def OMP_ParallelDo : Directive<"parallel do"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_Default>,
+    VersionedClause<OMPC_Private>,
+    VersionedClause<OMPC_FirstPrivate>,
+    VersionedClause<OMPC_Shared>,
+    VersionedClause<OMPC_Reduction>,
+    VersionedClause<OMPC_Copyin>,
+    VersionedClause<OMPC_LastPrivate>,
+    VersionedClause<OMPC_Linear>
+  ];
+  let allowedOnceClauses = [
+    VersionedClause<OMPC_If>,
+    VersionedClause<OMPC_NumThreads>,
+    VersionedClause<OMPC_ProcBind>,
+    VersionedClause<OMPC_Schedule>,
+    VersionedClause<OMPC_Ordered>,
+    VersionedClause<OMPC_Collapse>
+  ];
+}
+def OMP_ParallelForSimd : Directive<"parallel for simd"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_If>,
+    VersionedClause<OMPC_NumThreads>,
+    VersionedClause<OMPC_Default>,
+    VersionedClause<OMPC_ProcBind>,
+    VersionedClause<OMPC_Private>,
+    VersionedClause<OMPC_FirstPrivate>,
+    VersionedClause<OMPC_Shared>,
+    VersionedClause<OMPC_Reduction>,
+    VersionedClause<OMPC_Copyin>,
+    VersionedClause<OMPC_LastPrivate>,
+    VersionedClause<OMPC_Collapse>,
+    VersionedClause<OMPC_Schedule>,
+    VersionedClause<OMPC_SafeLen>,
+    VersionedClause<OMPC_SimdLen>,
+    VersionedClause<OMPC_Linear>,
+    VersionedClause<OMPC_Aligned>,
+    VersionedClause<OMPC_Ordered>,
+    VersionedClause<OMPC_Allocate>,
+    VersionedClause<OMPC_NonTemporal, 50>,
+    VersionedClause<OMPC_Order, 50>
+  ];
+}
+def OMP_ParallelDoSimd : Directive<"parallel do simd"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_Default>,
+    VersionedClause<OMPC_Private>,
+    VersionedClause<OMPC_FirstPrivate>,
+    VersionedClause<OMPC_Shared>,
+    VersionedClause<OMPC_Reduction>,
+    VersionedClause<OMPC_Copyin>,
+    VersionedClause<OMPC_LastPrivate>,
+    VersionedClause<OMPC_Linear>,
+    VersionedClause<OMPC_Aligned>,
+    VersionedClause<OMPC_Allocate>,
+    VersionedClause<OMPC_NonTemporal>,
+    VersionedClause<OMPC_Order>
+  ];
+  let allowedOnceClauses = [
+    VersionedClause<OMPC_If>,
+    VersionedClause<OMPC_NumThreads>,
+    VersionedClause<OMPC_ProcBind>,
+    VersionedClause<OMPC_Schedule>,
+    VersionedClause<OMPC_Ordered>,
+    VersionedClause<OMPC_Collapse>,
+    VersionedClause<OMPC_SafeLen>,
+    VersionedClause<OMPC_SimdLen>
+  ];
+}
+def OMP_ParallelMaster : Directive<"parallel master"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_If>,
+    VersionedClause<OMPC_NumThreads>,
+    VersionedClause<OMPC_Default>,
+    VersionedClause<OMPC_Private>,
+    VersionedClause<OMPC_FirstPrivate>,
+    VersionedClause<OMPC_Shared>,
+    VersionedClause<OMPC_Copyin>,
+    VersionedClause<OMPC_Reduction>,
+    VersionedClause<OMPC_ProcBind>,
+    VersionedClause<OMPC_Allocate>
+  ];
+}
+def OMP_ParallelSections : Directive<"parallel sections"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_If>,
+    VersionedClause<OMPC_Default>,
+    VersionedClause<OMPC_ProcBind>,
+    VersionedClause<OMPC_Private>,
+    VersionedClause<OMPC_FirstPrivate>,
+    VersionedClause<OMPC_Shared>,
+    VersionedClause<OMPC_Reduction>,
+    VersionedClause<OMPC_Copyin>,
+    VersionedClause<OMPC_LastPrivate>,
+    VersionedClause<OMPC_Allocate>
+  ];
+  let allowedOnceClauses = [
+    VersionedClause<OMPC_NumThreads>
+  ];
+}
+def OMP_ForSimd : Directive<"for simd"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_Private>,
+    VersionedClause<OMPC_FirstPrivate>,
+    VersionedClause<OMPC_LastPrivate>,
+    VersionedClause<OMPC_Reduction>,
+    VersionedClause<OMPC_Schedule>,
+    VersionedClause<OMPC_Collapse>,
+    VersionedClause<OMPC_NoWait>,
+    VersionedClause<OMPC_SafeLen>,
+    VersionedClause<OMPC_SimdLen>,
+    VersionedClause<OMPC_Linear>,
+    VersionedClause<OMPC_Aligned>,
+    VersionedClause<OMPC_Ordered>,
+    VersionedClause<OMPC_Allocate>,
+    VersionedClause<OMPC_If, 50>,
+    VersionedClause<OMPC_NonTemporal, 50>,
+    VersionedClause<OMPC_Order, 50>,
+  ];
+}
+def OMP_DoSimd : Directive<"do simd"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_Aligned>,
+    VersionedClause<OMPC_Private>,
+    VersionedClause<OMPC_FirstPrivate>,
+    VersionedClause<OMPC_LastPrivate>,
+    VersionedClause<OMPC_Linear>,
+    VersionedClause<OMPC_Reduction>
+  ];
+  let allowedOnceClauses = [
+    VersionedClause<OMPC_Schedule>,
+    VersionedClause<OMPC_Collapse>,
+    VersionedClause<OMPC_Ordered>,
+    VersionedClause<OMPC_SafeLen>,
+    VersionedClause<OMPC_SimdLen>,
+    VersionedClause<OMPC_NoWait>
+  ];
+}
+def OMP_CancellationPoint : Directive<"cancellation point"> {}
+def OMP_DeclareReduction : Directive<"declare reduction"> {}
+def OMP_DeclareMapper : Directive<"declare mapper"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_Map>
+  ];
+}
+def OMP_DeclareSimd : Directive<"declare simd"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_Linear>,
+    VersionedClause<OMPC_Aligned>,
+    VersionedClause<OMPC_Uniform>
+  ];
+  let allowedOnceClauses = [
+    VersionedClause<OMPC_SimdLen>
+  ];
+  let allowedExclusiveClauses = [
+    VersionedClause<OMPC_Inbranch>,
+    VersionedClause<OMPC_Notinbranch>
+  ];
+}
+def OMP_TaskLoop : Directive<"taskloop"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_Shared>,
+    VersionedClause<OMPC_Private>,
+    VersionedClause<OMPC_FirstPrivate>,
+    VersionedClause<OMPC_LastPrivate>,
+    VersionedClause<OMPC_Untied>,
+    VersionedClause<OMPC_Mergeable>,
+    VersionedClause<OMPC_NoGroup>,
+    VersionedClause<OMPC_Reduction>,
+    VersionedClause<OMPC_InReduction>,
+    VersionedClause<OMPC_Allocate>
+  ];
+  let allowedOnceClauses = [
+    VersionedClause<OMPC_Default>,
+    VersionedClause<OMPC_If>,
+    VersionedClause<OMPC_Collapse>,
+    VersionedClause<OMPC_Final>,
+    VersionedClause<OMPC_Priority>,
+  ];
+  let allowedExclusiveClauses = [
+    VersionedClause<OMPC_GrainSize>,
+    VersionedClause<OMPC_NumTasks>
+  ];
+}
+def OMP_TaskLoopSimd : Directive<"taskloop simd"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_Aligned>,
+    VersionedClause<OMPC_Allocate>,
+    VersionedClause<OMPC_Default>,
+    VersionedClause<OMPC_FirstPrivate>,
+    VersionedClause<OMPC_InReduction>,
+    VersionedClause<OMPC_LastPrivate>,
+    VersionedClause<OMPC_Linear>,
+    VersionedClause<OMPC_Mergeable>,
+    VersionedClause<OMPC_NoGroup>,
+    VersionedClause<OMPC_NonTemporal, 50>,
+    VersionedClause<OMPC_Order, 50>,
+    VersionedClause<OMPC_Private>,
+    VersionedClause<OMPC_Reduction>,
+    VersionedClause<OMPC_Shared>,
+    VersionedClause<OMPC_Untied>
+  ];
+  let allowedOnceClauses = [
+    VersionedClause<OMPC_If>,
+    VersionedClause<OMPC_Collapse>,
+    VersionedClause<OMPC_SafeLen>,
+    VersionedClause<OMPC_SimdLen>,
+    VersionedClause<OMPC_Final>,
+    VersionedClause<OMPC_Priority>
+  ];
+  let allowedExclusiveClauses = [
+    VersionedClause<OMPC_GrainSize>,
+    VersionedClause<OMPC_NumTasks>
+  ];
+}
+def OMP_Distribute : Directive<"distribute"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_Private>,
+    VersionedClause<OMPC_FirstPrivate>,
+    VersionedClause<OMPC_LastPrivate>,
+    VersionedClause<OMPC_Allocate>
+  ];
+  let allowedOnceClauses = [
+    VersionedClause<OMPC_Collapse>,
+    VersionedClause<OMPC_DistSchedule>
+  ];
+}
+def OMP_DeclareTarget : Directive<"declare target"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_To>,
+    VersionedClause<OMPC_Link>
+  ];
+}
+def OMP_EndDeclareTarget : Directive<"end declare target"> {}
+def OMP_DistributeParallelFor : Directive<"distribute parallel for"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_FirstPrivate>,
+    VersionedClause<OMPC_LastPrivate>,
+    VersionedClause<OMPC_Collapse>,
+    VersionedClause<OMPC_DistSchedule>,
+    VersionedClause<OMPC_If>,
+    VersionedClause<OMPC_NumThreads>,
+    VersionedClause<OMPC_Default>,
+    VersionedClause<OMPC_ProcBind>,
+    VersionedClause<OMPC_Private>,
+    VersionedClause<OMPC_Shared>,
+    VersionedClause<OMPC_Reduction>,
+    VersionedClause<OMPC_Copyin>,
+    VersionedClause<OMPC_Schedule>,
+    VersionedClause<OMPC_Allocate>,
+    VersionedClause<OMPC_Order, 50>
+  ];
+}
+def OMP_DistributeParallelDo : Directive<"distribute parallel do"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_Private>,
+    VersionedClause<OMPC_FirstPrivate>,
+    VersionedClause<OMPC_LastPrivate>,
+    VersionedClause<OMPC_Allocate>,
+    VersionedClause<OMPC_Order>,
+    VersionedClause<OMPC_Default>,
+    VersionedClause<OMPC_Shared>,
+    VersionedClause<OMPC_Reduction>,
+    VersionedClause<OMPC_Copyin>,
+    VersionedClause<OMPC_Linear>
+  ];
+  let allowedOnceClauses = [
+    VersionedClause<OMPC_Collapse>,
+    VersionedClause<OMPC_DistSchedule>,
+    VersionedClause<OMPC_If>,
+    VersionedClause<OMPC_NumThreads>,
+    VersionedClause<OMPC_ProcBind>,
+    VersionedClause<OMPC_Schedule>,
+    VersionedClause<OMPC_Ordered>
+  ];
+}
+def OMP_DistributeParallelForSimd : Directive<"distribute parallel for simd"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_FirstPrivate>,
+    VersionedClause<OMPC_LastPrivate>,
+    VersionedClause<OMPC_Collapse>,
+    VersionedClause<OMPC_DistSchedule>,
+    VersionedClause<OMPC_If>,
+    VersionedClause<OMPC_NumThreads>,
+    VersionedClause<OMPC_Default>,
+    VersionedClause<OMPC_ProcBind>,
+    VersionedClause<OMPC_Private>,
+    VersionedClause<OMPC_Shared>,
+    VersionedClause<OMPC_Reduction>,
+    VersionedClause<OMPC_Copyin>,
+    VersionedClause<OMPC_Schedule>,
+    VersionedClause<OMPC_Linear>,
+    VersionedClause<OMPC_Aligned>,
+    VersionedClause<OMPC_SafeLen>,
+    VersionedClause<OMPC_SimdLen>,
+    VersionedClause<OMPC_Allocate>,
+    VersionedClause<OMPC_NonTemporal, 50>,
+    VersionedClause<OMPC_Order, 50>
+  ];
+}
+def OMP_DistributeParallelDoSimd : Directive<"distribute parallel do simd"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_FirstPrivate>,
+    VersionedClause<OMPC_LastPrivate>,
+    VersionedClause<OMPC_Collapse>,
+    VersionedClause<OMPC_DistSchedule>,
+    VersionedClause<OMPC_If>,
+    VersionedClause<OMPC_NumThreads>,
+    VersionedClause<OMPC_Default>,
+    VersionedClause<OMPC_ProcBind>,
+    VersionedClause<OMPC_Private>,
+    VersionedClause<OMPC_Shared>,
+    VersionedClause<OMPC_Reduction>,
+    VersionedClause<OMPC_Copyin>,
+    VersionedClause<OMPC_Schedule>,
+    VersionedClause<OMPC_Linear>,
+    VersionedClause<OMPC_Aligned>,
+    VersionedClause<OMPC_SafeLen>,
+    VersionedClause<OMPC_SimdLen>,
+    VersionedClause<OMPC_Allocate>,
+    VersionedClause<OMPC_NonTemporal>,
+    VersionedClause<OMPC_Order>
+  ];
+}
+def OMP_DistributeSimd : Directive<"distribute simd"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_Aligned>,
+    VersionedClause<OMPC_Allocate>,
+    VersionedClause<OMPC_Copyin>,
+    VersionedClause<OMPC_Default>,
+    VersionedClause<OMPC_Linear>,
+    VersionedClause<OMPC_FirstPrivate>,
+    VersionedClause<OMPC_LastPrivate>,
+    VersionedClause<OMPC_NonTemporal, 50>,
+    VersionedClause<OMPC_Order, 50>,
+    VersionedClause<OMPC_Private>,
+    VersionedClause<OMPC_Reduction>
+  ];
+  let allowedOnceClauses = [
+    VersionedClause<OMPC_Collapse>,
+    VersionedClause<OMPC_DistSchedule>,
+    VersionedClause<OMPC_If, 50>,
+    VersionedClause<OMPC_NumThreads>,
+    VersionedClause<OMPC_Ordered>,
+    VersionedClause<OMPC_ProcBind>,
+    VersionedClause<OMPC_Schedule>,
+    VersionedClause<OMPC_SafeLen>,
+    VersionedClause<OMPC_SimdLen>
+  ];
+}
+
+def OMP_TargetParallelForSimd : Directive<"target parallel for simd"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_If>,
+    VersionedClause<OMPC_Device>,
+    VersionedClause<OMPC_Map>,
+    VersionedClause<OMPC_Private>,
+    VersionedClause<OMPC_FirstPrivate>,
+    VersionedClause<OMPC_LastPrivate>,
+    VersionedClause<OMPC_NoWait>,
+    VersionedClause<OMPC_Depend>,
+    VersionedClause<OMPC_DefaultMap>,
+    VersionedClause<OMPC_NumThreads>,
+    VersionedClause<OMPC_Default>,
+    VersionedClause<OMPC_ProcBind>,
+    VersionedClause<OMPC_Shared>,
+    VersionedClause<OMPC_Reduction>,
+    VersionedClause<OMPC_Collapse>,
+    VersionedClause<OMPC_Schedule>,
+    VersionedClause<OMPC_Ordered>,
+    VersionedClause<OMPC_Linear>,
+    VersionedClause<OMPC_SafeLen>,
+    VersionedClause<OMPC_SimdLen>,
+    VersionedClause<OMPC_Aligned>,
+    VersionedClause<OMPC_IsDevicePtr>,
+    VersionedClause<OMPC_Allocate>,
+    VersionedClause<OMPC_NonTemporal, 50>,
+    VersionedClause<OMPC_Order, 50>,
+    VersionedClause<OMPC_UsesAllocators, 50>
+  ];
+}
+def OMP_TargetParallelDoSimd : Directive<"target parallel do simd"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_If>,
+    VersionedClause<OMPC_Device>,
+    VersionedClause<OMPC_Map>,
+    VersionedClause<OMPC_Private>,
+    VersionedClause<OMPC_FirstPrivate>,
+    VersionedClause<OMPC_LastPrivate>,
+    VersionedClause<OMPC_NoWait>,
+    VersionedClause<OMPC_Depend>,
+    VersionedClause<OMPC_DefaultMap>,
+    VersionedClause<OMPC_NumThreads>,
+    VersionedClause<OMPC_Default>,
+    VersionedClause<OMPC_ProcBind>,
+    VersionedClause<OMPC_Shared>,
+    VersionedClause<OMPC_Reduction>,
+    VersionedClause<OMPC_Collapse>,
+    VersionedClause<OMPC_Schedule>,
+    VersionedClause<OMPC_Ordered>,
+    VersionedClause<OMPC_Linear>,
+    VersionedClause<OMPC_SafeLen>,
+    VersionedClause<OMPC_SimdLen>,
+    VersionedClause<OMPC_Aligned>,
+    VersionedClause<OMPC_IsDevicePtr>,
+    VersionedClause<OMPC_Allocate>,
+    VersionedClause<OMPC_NonTemporal>,
+    VersionedClause<OMPC_Order>,
+    VersionedClause<OMPC_UsesAllocators>
+  ];
+}
+def OMP_TargetSimd : Directive<"target simd"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_Aligned>,
+    VersionedClause<OMPC_Allocate>,
+    VersionedClause<OMPC_Depend>,
+    VersionedClause<OMPC_FirstPrivate>,
+    VersionedClause<OMPC_IsDevicePtr>,
+    VersionedClause<OMPC_LastPrivate>,
+    VersionedClause<OMPC_Linear>,
+    VersionedClause<OMPC_Map>,
+    VersionedClause<OMPC_NonTemporal, 50>,
+    VersionedClause<OMPC_NoWait>,
+    VersionedClause<OMPC_Order, 50>,
+    VersionedClause<OMPC_Private>,
+    VersionedClause<OMPC_Reduction>,
+    VersionedClause<OMPC_Shared>,
+    VersionedClause<OMPC_UsesAllocators, 50>
+  ];
+  let allowedOnceClauses = [
+    VersionedClause<OMPC_Collapse>,
+    VersionedClause<OMPC_SafeLen>,
+    VersionedClause<OMPC_SimdLen>,
+    VersionedClause<OMPC_If>,
+    VersionedClause<OMPC_NumThreads>,
+    VersionedClause<OMPC_ProcBind>,
+    VersionedClause<OMPC_Device>,
+    VersionedClause<OMPC_DefaultMap>,
+    VersionedClause<OMPC_Schedule>
+  ];
+}
+def OMP_TeamsDistribute : Directive<"teams distribute"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_Default>,
+    VersionedClause<OMPC_Private>,
+    VersionedClause<OMPC_FirstPrivate>,
+    VersionedClause<OMPC_Shared>,
+    VersionedClause<OMPC_Reduction>,
+    VersionedClause<OMPC_NumTeams>,
+    VersionedClause<OMPC_ThreadLimit>,
+    VersionedClause<OMPC_LastPrivate>,
+    VersionedClause<OMPC_Collapse>,
+    VersionedClause<OMPC_DistSchedule>,
+    VersionedClause<OMPC_Allocate>
+  ];
+}
+def OMP_TeamsDistributeSimd : Directive<"teams distribute simd"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_Aligned>,
+    VersionedClause<OMPC_Allocate>,
+    VersionedClause<OMPC_FirstPrivate>,
+    VersionedClause<OMPC_LastPrivate>,
+    VersionedClause<OMPC_Linear>,
+    VersionedClause<OMPC_NonTemporal, 50>,
+    VersionedClause<OMPC_Order, 50>,
+    VersionedClause<OMPC_Private>,
+    VersionedClause<OMPC_Reduction>,
+    VersionedClause<OMPC_Shared>
+  ];
+  let allowedOnceClauses = [
+    VersionedClause<OMPC_Collapse>,
+    VersionedClause<OMPC_Default>,
+    VersionedClause<OMPC_DistSchedule>,
+    VersionedClause<OMPC_If, 50>,
+    VersionedClause<OMPC_NumTeams>,
+    VersionedClause<OMPC_SafeLen>,
+    VersionedClause<OMPC_SimdLen>,
+    VersionedClause<OMPC_ThreadLimit>
+  ];
+}
+
+def OMP_TeamsDistributeParallelForSimd :
+    Directive<"teams distribute parallel for simd"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_FirstPrivate>,
+    VersionedClause<OMPC_LastPrivate>,
+    VersionedClause<OMPC_Collapse>,
+    VersionedClause<OMPC_DistSchedule>,
+    VersionedClause<OMPC_If>,
+    VersionedClause<OMPC_NumThreads>,
+    VersionedClause<OMPC_Default>,
+    VersionedClause<OMPC_ProcBind>,
+    VersionedClause<OMPC_Private>,
+    VersionedClause<OMPC_Shared>,
+    VersionedClause<OMPC_Reduction>,
+    VersionedClause<OMPC_Schedule>,
+    VersionedClause<OMPC_Linear>,
+    VersionedClause<OMPC_Aligned>,
+    VersionedClause<OMPC_SafeLen>,
+    VersionedClause<OMPC_SimdLen>,
+    VersionedClause<OMPC_NumTeams>,
+    VersionedClause<OMPC_ThreadLimit>,
+    VersionedClause<OMPC_Allocate>,
+    VersionedClause<OMPC_NonTemporal, 50>,
+    VersionedClause<OMPC_Order, 50>
+  ];
+}
+def OMP_TeamsDistributeParallelDoSimd :
+    Directive<"teams distribute parallel do simd"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_Private>,
+    VersionedClause<OMPC_FirstPrivate>,
+    VersionedClause<OMPC_LastPrivate>,
+    VersionedClause<OMPC_Allocate>,
+    VersionedClause<OMPC_Shared>,
+    VersionedClause<OMPC_Reduction>,
+    VersionedClause<OMPC_Linear>,
+    VersionedClause<OMPC_Order>,
+    VersionedClause<OMPC_Aligned>,
+    VersionedClause<OMPC_NonTemporal>
+  ];
+  let allowedOnceClauses = [
+    VersionedClause<OMPC_Default>,
+    VersionedClause<OMPC_NumTeams>,
+    VersionedClause<OMPC_ThreadLimit>,
+    VersionedClause<OMPC_Collapse>,
+    VersionedClause<OMPC_DistSchedule>,
+    VersionedClause<OMPC_NumThreads>,
+    VersionedClause<OMPC_ProcBind>,
+    VersionedClause<OMPC_Schedule>,
+    VersionedClause<OMPC_SafeLen>,
+    VersionedClause<OMPC_SimdLen>,
+    VersionedClause<OMPC_If>,
+  ];
+}
+def OMP_TeamsDistributeParallelFor :
+    Directive<"teams distribute parallel for"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_FirstPrivate>,
+    VersionedClause<OMPC_LastPrivate>,
+    VersionedClause<OMPC_Collapse>,
+    VersionedClause<OMPC_DistSchedule>,
+    VersionedClause<OMPC_If>,
+    VersionedClause<OMPC_NumThreads>,
+    VersionedClause<OMPC_Default>,
+    VersionedClause<OMPC_ProcBind>,
+    VersionedClause<OMPC_Private>,
+    VersionedClause<OMPC_Shared>,
+    VersionedClause<OMPC_Reduction>,
+    VersionedClause<OMPC_Schedule>,
+    VersionedClause<OMPC_NumTeams>,
+    VersionedClause<OMPC_ThreadLimit>,
+    VersionedClause<OMPC_Copyin>,
+    VersionedClause<OMPC_Allocate>,
+    VersionedClause<OMPC_Order, 50>
+  ];
+}
+def OMP_TeamsDistributeParallelDo :
+    Directive<"teams distribute parallel do"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_Private>,
+    VersionedClause<OMPC_FirstPrivate>,
+    VersionedClause<OMPC_LastPrivate>,
+    VersionedClause<OMPC_Shared>,
+    VersionedClause<OMPC_Reduction>,
+    VersionedClause<OMPC_Allocate>,
+    VersionedClause<OMPC_Copyin>,
+    VersionedClause<OMPC_Linear>
+  ];
+let allowedOnceClauses = [
+    VersionedClause<OMPC_NumTeams>,
+    VersionedClause<OMPC_ThreadLimit>,
+    VersionedClause<OMPC_Default>,
+    VersionedClause<OMPC_Collapse>,
+    VersionedClause<OMPC_DistSchedule>,
+    VersionedClause<OMPC_Ordered>,
+    VersionedClause<OMPC_Order>,
+    VersionedClause<OMPC_If>,
+    VersionedClause<OMPC_NumThreads>,
+    VersionedClause<OMPC_ProcBind>,
+    VersionedClause<OMPC_Schedule>
+  ];
+}
+def OMP_TargetTeams : Directive<"target teams"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_If>,
+    VersionedClause<OMPC_Map>,
+    VersionedClause<OMPC_Private>,
+    VersionedClause<OMPC_Depend>,
+    VersionedClause<OMPC_FirstPrivate>,
+    VersionedClause<OMPC_IsDevicePtr>,
+    VersionedClause<OMPC_Reduction>,
+    VersionedClause<OMPC_Allocate>,
+    VersionedClause<OMPC_UsesAllocators, 50>,
+    VersionedClause<OMPC_Shared>
+  ];
+
+  let allowedOnceClauses = [
+    VersionedClause<OMPC_Device>,
+    VersionedClause<OMPC_NoWait>,
+    VersionedClause<OMPC_DefaultMap>,
+    VersionedClause<OMPC_Default>,
+    VersionedClause<OMPC_NumTeams>,
+    VersionedClause<OMPC_ThreadLimit>
+  ];
+}
+def OMP_TargetTeamsDistribute : Directive<"target teams distribute"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_If>,
+    VersionedClause<OMPC_Map>,
+    VersionedClause<OMPC_Private>,
+    VersionedClause<OMPC_Depend>,
+    VersionedClause<OMPC_FirstPrivate>,
+    VersionedClause<OMPC_IsDevicePtr>,
+    VersionedClause<OMPC_Reduction>,
+    VersionedClause<OMPC_Allocate>,
+    VersionedClause<OMPC_UsesAllocators, 50>,
+    VersionedClause<OMPC_Shared>,
+    VersionedClause<OMPC_LastPrivate>
+  ];
+  let allowedOnceClauses = [
+    VersionedClause<OMPC_Device>,
+    VersionedClause<OMPC_NoWait>,
+    VersionedClause<OMPC_DefaultMap>,
+    VersionedClause<OMPC_Default>,
+    VersionedClause<OMPC_NumTeams>,
+    VersionedClause<OMPC_ThreadLimit>,
+    VersionedClause<OMPC_Collapse>,
+    VersionedClause<OMPC_DistSchedule>
+  ];
+}
+
+def OMP_TargetTeamsDistributeParallelFor :
+    Directive<"target teams distribute parallel for"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_If>,
+    VersionedClause<OMPC_Device>,
+    VersionedClause<OMPC_Map>,
+    VersionedClause<OMPC_Private>,
+    VersionedClause<OMPC_NoWait>,
+    VersionedClause<OMPC_Depend>,
+    VersionedClause<OMPC_DefaultMap>,
+    VersionedClause<OMPC_FirstPrivate>,
+    VersionedClause<OMPC_IsDevicePtr>,
+    VersionedClause<OMPC_Default>,
+    VersionedClause<OMPC_Shared>,
+    VersionedClause<OMPC_Reduction>,
+    VersionedClause<OMPC_NumTeams>,
+    VersionedClause<OMPC_ThreadLimit>,
+    VersionedClause<OMPC_LastPrivate>,
+    VersionedClause<OMPC_Collapse>,
+    VersionedClause<OMPC_DistSchedule>,
+    VersionedClause<OMPC_NumThreads>,
+    VersionedClause<OMPC_ProcBind>,
+    VersionedClause<OMPC_Schedule>,
+    VersionedClause<OMPC_Allocate>,
+    VersionedClause<OMPC_Order, 50>,
+    VersionedClause<OMPC_UsesAllocators, 50>
+  ];
+}
+def OMP_TargetTeamsDistributeParallelDo :
+    Directive<"target teams distribute parallel do"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_If>,
+    VersionedClause<OMPC_Map>,
+    VersionedClause<OMPC_Private>,
+    VersionedClause<OMPC_Depend>,
+    VersionedClause<OMPC_FirstPrivate>,
+    VersionedClause<OMPC_IsDevicePtr>,
+    VersionedClause<OMPC_Reduction>,
+    VersionedClause<OMPC_Allocate>,
+    VersionedClause<OMPC_UsesAllocators>,
+    VersionedClause<OMPC_Shared>,
+    VersionedClause<OMPC_LastPrivate>,
+    VersionedClause<OMPC_Copyin>,
+    VersionedClause<OMPC_Linear>,
+    VersionedClause<OMPC_Ordered>,
+    VersionedClause<OMPC_Order>
+  ];
+  let allowedOnceClauses = [
+    VersionedClause<OMPC_Device>,
+    VersionedClause<OMPC_DefaultMap>,
+    VersionedClause<OMPC_NoWait>,
+    VersionedClause<OMPC_Default>,
+    VersionedClause<OMPC_NumTeams>,
+    VersionedClause<OMPC_ThreadLimit>,
+    VersionedClause<OMPC_Collapse>,
+    VersionedClause<OMPC_DistSchedule>,
+    VersionedClause<OMPC_NumThreads>,
+    VersionedClause<OMPC_ProcBind>,
+    VersionedClause<OMPC_Schedule>,
+  ];
+}
+def OMP_TargetTeamsDistributeParallelForSimd :
+    Directive<"target teams distribute parallel for simd"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_If>,
+    VersionedClause<OMPC_Device>,
+    VersionedClause<OMPC_Map>,
+    VersionedClause<OMPC_Private>,
+    VersionedClause<OMPC_NoWait>,
+    VersionedClause<OMPC_Depend>,
+    VersionedClause<OMPC_DefaultMap>,
+    VersionedClause<OMPC_FirstPrivate>,
+    VersionedClause<OMPC_IsDevicePtr>,
+    VersionedClause<OMPC_Default>,
+    VersionedClause<OMPC_Shared>,
+    VersionedClause<OMPC_Reduction>,
+    VersionedClause<OMPC_NumTeams>,
+    VersionedClause<OMPC_ThreadLimit>,
+    VersionedClause<OMPC_LastPrivate>,
+    VersionedClause<OMPC_Collapse>,
+    VersionedClause<OMPC_DistSchedule>,
+    VersionedClause<OMPC_NumThreads>,
+    VersionedClause<OMPC_ProcBind>,
+    VersionedClause<OMPC_Schedule>,
+    VersionedClause<OMPC_Linear>,
+    VersionedClause<OMPC_Aligned>,
+    VersionedClause<OMPC_SafeLen>,
+    VersionedClause<OMPC_SimdLen>,
+    VersionedClause<OMPC_Allocate>,
+    VersionedClause<OMPC_NonTemporal, 50>,
+    VersionedClause<OMPC_Order, 50>,
+    VersionedClause<OMPC_UsesAllocators, 50>
+  ];
+}
+def OMP_TargetTeamsDistributeParallelDoSimd :
+    Directive<"target teams distribute parallel do simd"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_Map>,
+    VersionedClause<OMPC_Private>,
+    VersionedClause<OMPC_Depend>,
+    VersionedClause<OMPC_FirstPrivate>,
+    VersionedClause<OMPC_IsDevicePtr>,
+    VersionedClause<OMPC_Reduction>,
+    VersionedClause<OMPC_Allocate>,
+    VersionedClause<OMPC_UsesAllocators>,
+    VersionedClause<OMPC_Shared>,
+    VersionedClause<OMPC_LastPrivate>,
+    VersionedClause<OMPC_Copyin>,
+    VersionedClause<OMPC_Linear>,
+    VersionedClause<OMPC_Ordered>,
+    VersionedClause<OMPC_Order>,
+    VersionedClause<OMPC_Aligned>,
+    VersionedClause<OMPC_NonTemporal>
+  ];
+  let allowedOnceClauses = [
+    VersionedClause<OMPC_If>,
+    VersionedClause<OMPC_Device>,
+    VersionedClause<OMPC_NoWait>,
+    VersionedClause<OMPC_DefaultMap>,
+    VersionedClause<OMPC_Default>,
+    VersionedClause<OMPC_NumTeams>,
+    VersionedClause<OMPC_ThreadLimit>,
+    VersionedClause<OMPC_Collapse>,
+    VersionedClause<OMPC_DistSchedule>,
+    VersionedClause<OMPC_NumThreads>,
+    VersionedClause<OMPC_ProcBind>,
+    VersionedClause<OMPC_Schedule>,
+    VersionedClause<OMPC_SafeLen>,
+    VersionedClause<OMPC_SimdLen>
+  ];
+}
+def OMP_TargetTeamsDistributeSimd :
+    Directive<"target teams distribute simd"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_Aligned>,
+    VersionedClause<OMPC_Allocate>,
+    VersionedClause<OMPC_Depend>,
+    VersionedClause<OMPC_FirstPrivate>,
+    VersionedClause<OMPC_If>,
+    VersionedClause<OMPC_IsDevicePtr>,
+    VersionedClause<OMPC_LastPrivate>,
+    VersionedClause<OMPC_Linear>,
+    VersionedClause<OMPC_Map>,
+    VersionedClause<OMPC_NonTemporal, 50>,
+    VersionedClause<OMPC_Order, 50>,
+    VersionedClause<OMPC_Private>,
+    VersionedClause<OMPC_Reduction>,
+    VersionedClause<OMPC_Shared>,
+    VersionedClause<OMPC_UsesAllocators, 50>
+  ];
+  let allowedOnceClauses = [
+    VersionedClause<OMPC_Device>,
+    VersionedClause<OMPC_DefaultMap>,
+    VersionedClause<OMPC_NoWait>,
+    VersionedClause<OMPC_NumTeams>,
+    VersionedClause<OMPC_ThreadLimit>,
+    VersionedClause<OMPC_Collapse>,
+    VersionedClause<OMPC_DistSchedule>,
+    VersionedClause<OMPC_SafeLen>,
+    VersionedClause<OMPC_SimdLen>,
+  ];
+}
+def OMP_Allocate : Directive<"allocate"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_Allocator>
+  ];
+}
+def OMP_DeclareVariant : Directive<"declare variant"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_Match>
+  ];
+}
+def OMP_MasterTaskloop : Directive<"master taskloop"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_If>,
+    VersionedClause<OMPC_Shared>,
+    VersionedClause<OMPC_Private>,
+    VersionedClause<OMPC_FirstPrivate>,
+    VersionedClause<OMPC_LastPrivate>,
+    VersionedClause<OMPC_Default>,
+    VersionedClause<OMPC_Collapse>,
+    VersionedClause<OMPC_Final>,
+    VersionedClause<OMPC_Untied>,
+    VersionedClause<OMPC_Mergeable>,
+    VersionedClause<OMPC_Priority>,
+    VersionedClause<OMPC_GrainSize>,
+    VersionedClause<OMPC_NoGroup>,
+    VersionedClause<OMPC_NumTasks>,
+    VersionedClause<OMPC_Reduction>,
+    VersionedClause<OMPC_InReduction>,
+    VersionedClause<OMPC_Allocate>
+  ];
+}
+def OMP_ParallelMasterTaskloop :
+    Directive<"parallel master taskloop"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_If>,
+    VersionedClause<OMPC_Shared>,
+    VersionedClause<OMPC_Private>,
+    VersionedClause<OMPC_FirstPrivate>,
+    VersionedClause<OMPC_LastPrivate>,
+    VersionedClause<OMPC_Default>,
+    VersionedClause<OMPC_Collapse>,
+    VersionedClause<OMPC_Final>,
+    VersionedClause<OMPC_Untied>,
+    VersionedClause<OMPC_Mergeable>,
+    VersionedClause<OMPC_Priority>,
+    VersionedClause<OMPC_GrainSize>,
+    VersionedClause<OMPC_NoGroup>,
+    VersionedClause<OMPC_NumTasks>,
+    VersionedClause<OMPC_Reduction>,
+    VersionedClause<OMPC_Allocate>,
+    VersionedClause<OMPC_NumThreads>,
+    VersionedClause<OMPC_ProcBind>,
+    VersionedClause<OMPC_Copyin>
+  ];
+}
+def OMP_MasterTaskloopSimd : Directive<"master taskloop simd"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_If>,
+    VersionedClause<OMPC_Shared>,
+    VersionedClause<OMPC_Private>,
+    VersionedClause<OMPC_FirstPrivate>,
+    VersionedClause<OMPC_LastPrivate>,
+    VersionedClause<OMPC_Default>,
+    VersionedClause<OMPC_Collapse>,
+    VersionedClause<OMPC_Final>,
+    VersionedClause<OMPC_Untied>,
+    VersionedClause<OMPC_Mergeable>,
+    VersionedClause<OMPC_Priority>,
+    VersionedClause<OMPC_Linear>,
+    VersionedClause<OMPC_Aligned>,
+    VersionedClause<OMPC_SafeLen>,
+    VersionedClause<OMPC_SimdLen>,
+    VersionedClause<OMPC_GrainSize>,
+    VersionedClause<OMPC_NoGroup>,
+    VersionedClause<OMPC_NumTasks>,
+    VersionedClause<OMPC_Reduction>,
+    VersionedClause<OMPC_InReduction>,
+    VersionedClause<OMPC_Allocate>,
+    VersionedClause<OMPC_NonTemporal, 50>,
+    VersionedClause<OMPC_Order, 50>
+  ];
+}
+def OMP_ParallelMasterTaskloopSimd :
+    Directive<"parallel master taskloop simd"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_If>,
+    VersionedClause<OMPC_Shared>,
+    VersionedClause<OMPC_Private>,
+    VersionedClause<OMPC_FirstPrivate>,
+    VersionedClause<OMPC_LastPrivate>,
+    VersionedClause<OMPC_Default>,
+    VersionedClause<OMPC_Collapse>,
+    VersionedClause<OMPC_Final>,
+    VersionedClause<OMPC_Untied>,
+    VersionedClause<OMPC_Mergeable>,
+    VersionedClause<OMPC_Priority>,
+    VersionedClause<OMPC_GrainSize>,
+    VersionedClause<OMPC_NoGroup>,
+    VersionedClause<OMPC_NumTasks>,
+    VersionedClause<OMPC_Reduction>,
+    VersionedClause<OMPC_Allocate>,
+    VersionedClause<OMPC_NumThreads>,
+    VersionedClause<OMPC_ProcBind>,
+    VersionedClause<OMPC_Copyin>,
+    VersionedClause<OMPC_Linear>,
+    VersionedClause<OMPC_Aligned>,
+    VersionedClause<OMPC_SafeLen>,
+    VersionedClause<OMPC_SimdLen>,
+    VersionedClause<OMPC_NonTemporal, 50>,
+    VersionedClause<OMPC_Order, 50>
+  ];
+}
+def OMP_Depobj : Directive<"depobj"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_Depend, 50>,
+    VersionedClause<OMPC_Destroy, 50>,
+    VersionedClause<OMPC_Update, 50>,
+    // TODO This should ne `none` instead. Comment carried over from
+    // OMPKinds.def.
+    VersionedClause<OMPC_Depobj, 50>
+  ];
+}
+def OMP_Scan : Directive<"scan"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_Inclusive, 50>,
+    VersionedClause<OMPC_Exclusive, 50>
+  ];
+}
+def OMP_Assumes : Directive<"assumes"> {}
+def OMP_BeginAssumes : Directive<"begin assumes"> {}
+def OMP_EndAssumes : Directive<"end assumes"> {}
+def OMP_BeginDeclareVariant : Directive<"begin declare variant"> {}
+def OMP_EndDeclareVariant : Directive<"end declare variant"> {}
+def OMP_ParallelWorkshare : Directive<"parallel workshare"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_Allocate>,
+    VersionedClause<OMPC_Copyin>,
+    VersionedClause<OMPC_Default>,
+    VersionedClause<OMPC_FirstPrivate>,
+    VersionedClause<OMPC_Private>,
+    VersionedClause<OMPC_Reduction>,
+    VersionedClause<OMPC_Shared>
+  ];
+  let allowedOnceClauses = [
+    VersionedClause<OMPC_If>,
+    VersionedClause<OMPC_NumThreads>,
+    VersionedClause<OMPC_ProcBind>
+  ];
+}
+def OMP_Workshare : Directive<"workshare"> {}
+def OMP_EndDo : Directive<"end do"> {}
+def OMP_EndDoSimd : Directive<"end do simd"> {}
+def OMP_EndSections : Directive<"end sections"> {
+  let allowedOnceClauses = [
+    VersionedClause<OMPC_NoWait>
+  ];
+}
+def OMP_EndSingle : Directive<"end single"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_CopyPrivate>
+  ];
+  let allowedOnceClauses = [
+    VersionedClause<OMPC_NoWait>
+  ];
+}
+def OMP_EndWorkshare : Directive<"end workshare"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_NoWait>
+  ];
+}
+def OMP_Unknown : Directive<"unknown"> {
+  let isDefault = true;
+}
diff --git a/linux-x64/clang/include/llvm/Frontend/OpenMP/OMPConstants.h b/linux-x64/clang/include/llvm/Frontend/OpenMP/OMPConstants.h
new file mode 100644
index 0000000..36ce3fc
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Frontend/OpenMP/OMPConstants.h
@@ -0,0 +1,114 @@
+//===- OMPConstants.h - OpenMP related constants and helpers ------ C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+/// \file
+///
+/// This file defines constans and helpers used when dealing with OpenMP.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_OPENMP_CONSTANTS_H
+#define LLVM_OPENMP_CONSTANTS_H
+
+#include "llvm/ADT/BitmaskEnum.h"
+
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Frontend/OpenMP/OMP.h.inc"
+
+namespace llvm {
+class Type;
+class Module;
+class ArrayType;
+class StructType;
+class PointerType;
+class StringRef;
+class FunctionType;
+
+namespace omp {
+LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE();
+
+/// IDs for all Internal Control Variables (ICVs).
+enum class InternalControlVar {
+#define ICV_DATA_ENV(Enum, ...) Enum,
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
+};
+
+#define ICV_DATA_ENV(Enum, ...)                                                \
+  constexpr auto Enum = omp::InternalControlVar::Enum;
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
+
+enum class ICVInitValue {
+#define ICV_INIT_VALUE(Enum, Name) Enum,
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
+};
+
+#define ICV_INIT_VALUE(Enum, Name)                                             \
+  constexpr auto Enum = omp::ICVInitValue::Enum;
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
+
+/// IDs for all omp runtime library (RTL) functions.
+enum class RuntimeFunction {
+#define OMP_RTL(Enum, ...) Enum,
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
+};
+
+#define OMP_RTL(Enum, ...) constexpr auto Enum = omp::RuntimeFunction::Enum;
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
+
+/// IDs for the different default kinds.
+enum class DefaultKind {
+#define OMP_DEFAULT_KIND(Enum, Str) Enum,
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
+};
+
+#define OMP_DEFAULT_KIND(Enum, ...)                                            \
+  constexpr auto Enum = omp::DefaultKind::Enum;
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
+
+/// IDs for all omp runtime library ident_t flag encodings (see
+/// their defintion in openmp/runtime/src/kmp.h).
+enum class IdentFlag {
+#define OMP_IDENT_FLAG(Enum, Str, Value) Enum = Value,
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
+  LLVM_MARK_AS_BITMASK_ENUM(0x7FFFFFFF)
+};
+
+#define OMP_IDENT_FLAG(Enum, ...) constexpr auto Enum = omp::IdentFlag::Enum;
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
+
+/// Helper to describe assume clauses.
+struct AssumptionClauseMappingInfo {
+  /// The identifier describing the (beginning of the) clause.
+  llvm::StringLiteral Identifier;
+  /// Flag to determine if the identifier is a full name or the start of a name.
+  bool StartsWith;
+  /// Flag to determine if a directive lists follows.
+  bool HasDirectiveList;
+  /// Flag to determine if an expression follows.
+  bool HasExpression;
+};
+
+/// All known assume clauses.
+static constexpr AssumptionClauseMappingInfo AssumptionClauseMappings[] = {
+#define OMP_ASSUME_CLAUSE(Identifier, StartsWith, HasDirectiveList,            \
+                          HasExpression)                                       \
+  {Identifier, StartsWith, HasDirectiveList, HasExpression},
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
+};
+
+inline std::string getAllAssumeClauseOptions() {
+  std::string S;
+  for (const AssumptionClauseMappingInfo &ACMI : AssumptionClauseMappings)
+    S += (S.empty() ? "'" : "', '") + ACMI.Identifier.str();
+  return S + "'";
+}
+
+} // end namespace omp
+
+} // end namespace llvm
+
+#endif // LLVM_OPENMP_CONSTANTS_H
diff --git a/linux-x64/clang/include/llvm/Frontend/OpenMP/OMPContext.h b/linux-x64/clang/include/llvm/Frontend/OpenMP/OMPContext.h
new file mode 100644
index 0000000..8a41791
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Frontend/OpenMP/OMPContext.h
@@ -0,0 +1,210 @@
+//===- OpenMP/OMPContext.h ----- OpenMP context helper functions  - C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+/// \file
+///
+/// This file provides helper functions and classes to deal with OpenMP
+/// contexts as used by `[begin/end] declare variant` and `metadirective`.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_OPENMP_CONTEXT_H
+#define LLVM_OPENMP_CONTEXT_H
+
+#include "llvm/ADT/APSInt.h"
+#include "llvm/ADT/BitVector.h"
+#include "llvm/ADT/SetVector.h"
+#include "llvm/ADT/SmallSet.h"
+#include "llvm/ADT/Triple.h"
+#include "llvm/Frontend/OpenMP/OMPConstants.h"
+
+namespace llvm {
+namespace omp {
+
+/// OpenMP Context related IDs and helpers
+///
+///{
+
+/// IDs for all OpenMP context selector trait sets (construct/device/...).
+enum class TraitSet {
+#define OMP_TRAIT_SET(Enum, ...) Enum,
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
+};
+
+/// IDs for all OpenMP context selector trait (device={kind/isa...}/...).
+enum class TraitSelector {
+#define OMP_TRAIT_SELECTOR(Enum, ...) Enum,
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
+};
+
+/// IDs for all OpenMP context trait properties (host/gpu/bsc/llvm/...)
+enum class TraitProperty {
+#define OMP_TRAIT_PROPERTY(Enum, ...) Enum,
+#define OMP_LAST_TRAIT_PROPERTY(Enum) Last = Enum
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
+};
+
+/// Parse \p Str and return the trait set it matches or TraitSet::invalid.
+TraitSet getOpenMPContextTraitSetKind(StringRef Str);
+
+/// Return the trait set for which \p Selector is a selector.
+TraitSet getOpenMPContextTraitSetForSelector(TraitSelector Selector);
+
+/// Return the trait set for which \p Property is a property.
+TraitSet getOpenMPContextTraitSetForProperty(TraitProperty Property);
+
+/// Return a textual representation of the trait set \p Kind.
+StringRef getOpenMPContextTraitSetName(TraitSet Kind);
+
+/// Parse \p Str and return the trait set it matches or
+/// TraitSelector::invalid.
+TraitSelector getOpenMPContextTraitSelectorKind(StringRef Str);
+
+/// Return the trait selector for which \p Property is a property.
+TraitSelector getOpenMPContextTraitSelectorForProperty(TraitProperty Property);
+
+/// Return a textual representation of the trait selector \p Kind.
+StringRef getOpenMPContextTraitSelectorName(TraitSelector Kind);
+
+/// Parse \p Str and return the trait property it matches in the set \p Set and
+/// selector \p Selector or TraitProperty::invalid.
+TraitProperty getOpenMPContextTraitPropertyKind(TraitSet Set,
+                                                TraitSelector Selector,
+                                                StringRef Str);
+
+/// Return the trait property for a singleton selector \p Selector.
+TraitProperty getOpenMPContextTraitPropertyForSelector(TraitSelector Selector);
+
+/// Return a textual representation of the trait property \p Kind, which might
+/// be the raw string we parsed (\p RawString) if we do not translate the
+/// property into a (distinct) enum.
+StringRef getOpenMPContextTraitPropertyName(TraitProperty Kind,
+                                            StringRef RawString);
+
+/// Return a textual representation of the trait property \p Kind with selector
+/// and set name included.
+StringRef getOpenMPContextTraitPropertyFullName(TraitProperty Kind);
+
+/// Return a string listing all trait sets.
+std::string listOpenMPContextTraitSets();
+
+/// Return a string listing all trait selectors for \p Set.
+std::string listOpenMPContextTraitSelectors(TraitSet Set);
+
+/// Return a string listing all trait properties for \p Set and \p Selector.
+std::string listOpenMPContextTraitProperties(TraitSet Set,
+                                             TraitSelector Selector);
+///}
+
+/// Return true if \p Selector can be nested in \p Set. Also sets
+/// \p AllowsTraitScore and \p RequiresProperty to true/false if the user can
+/// specify a score for properties in \p Selector and if the \p Selector
+/// requires at least one property.
+bool isValidTraitSelectorForTraitSet(TraitSelector Selector, TraitSet Set,
+                                     bool &AllowsTraitScore,
+                                     bool &RequiresProperty);
+
+/// Return true if \p Property can be nested in \p Selector and \p Set.
+bool isValidTraitPropertyForTraitSetAndSelector(TraitProperty Property,
+                                                TraitSelector Selector,
+                                                TraitSet Set);
+
+/// Variant match information describes the required traits and how they are
+/// scored (via the ScoresMap). In addition, the required consturct nesting is
+/// decribed as well.
+struct VariantMatchInfo {
+  /// Add the trait \p Property to the required trait set. \p RawString is the
+  /// string we parsed and derived \p Property from. If \p Score is not null, it
+  /// recorded as well. If \p Property is in the `construct` set it is recorded
+  /// in-order in the ConstructTraits as well.
+  void addTrait(TraitProperty Property, StringRef RawString,
+                APInt *Score = nullptr) {
+    addTrait(getOpenMPContextTraitSetForProperty(Property), Property, RawString,
+             Score);
+  }
+  /// Add the trait \p Property which is in set \p Set to the required trait
+  /// set. \p RawString is the string we parsed and derived \p Property from. If
+  /// \p Score is not null, it recorded as well. If \p Set is the `construct`
+  /// set it is recorded in-order in the ConstructTraits as well.
+  void addTrait(TraitSet Set, TraitProperty Property, StringRef RawString,
+                APInt *Score = nullptr) {
+    if (Score)
+      ScoreMap[Property] = *Score;
+
+    // Special handling for `device={isa(...)}` as we do not match the enum but
+    // the raw string.
+    if (Property == TraitProperty::device_isa___ANY)
+      ISATraits.push_back(RawString);
+
+    RequiredTraits.set(unsigned(Property));
+    if (Set == TraitSet::construct)
+      ConstructTraits.push_back(Property);
+  }
+
+  BitVector RequiredTraits = BitVector(unsigned(TraitProperty::Last) + 1);
+  SmallVector<StringRef, 8> ISATraits;
+  SmallVector<TraitProperty, 8> ConstructTraits;
+  SmallDenseMap<TraitProperty, APInt> ScoreMap;
+};
+
+/// The context for a source location is made up of active property traits,
+/// e.g., device={kind(host)}, and constructs traits which describe the nesting
+/// in OpenMP constructs at the location.
+struct OMPContext {
+  OMPContext(bool IsDeviceCompilation, Triple TargetTriple);
+  virtual ~OMPContext() = default;
+
+  void addTrait(TraitProperty Property) {
+    addTrait(getOpenMPContextTraitSetForProperty(Property), Property);
+  }
+  void addTrait(TraitSet Set, TraitProperty Property) {
+    ActiveTraits.set(unsigned(Property));
+    if (Set == TraitSet::construct)
+      ConstructTraits.push_back(Property);
+  }
+
+  /// Hook for users to check if an ISA trait matches. The trait is described as
+  /// the string that got parsed and it depends on the target and context if
+  /// this matches or not.
+  virtual bool matchesISATrait(StringRef) const { return false; }
+
+  BitVector ActiveTraits = BitVector(unsigned(TraitProperty::Last) + 1);
+  SmallVector<TraitProperty, 8> ConstructTraits;
+};
+
+/// Return true if \p VMI is applicable in \p Ctx, that is, all traits required
+/// by \p VMI are available in the OpenMP context \p Ctx. If \p DeviceSetOnly is
+/// true, only the device selector set, if present, are checked. Note that we
+/// still honor extension traits provided by the user.
+bool isVariantApplicableInContext(const VariantMatchInfo &VMI,
+                                  const OMPContext &Ctx,
+                                  bool DeviceSetOnly = false);
+
+/// Return the index (into \p VMIs) of the variant with the highest score
+/// from the ones applicble in \p Ctx. See llvm::isVariantApplicableInContext.
+int getBestVariantMatchForContext(const SmallVectorImpl<VariantMatchInfo> &VMIs,
+                                  const OMPContext &Ctx);
+
+} // namespace omp
+
+template <> struct DenseMapInfo<omp::TraitProperty> {
+  static inline omp::TraitProperty getEmptyKey() {
+    return omp::TraitProperty(-1);
+  }
+  static inline omp::TraitProperty getTombstoneKey() {
+    return omp::TraitProperty(-2);
+  }
+  static unsigned getHashValue(omp::TraitProperty val) {
+    return std::hash<unsigned>{}(unsigned(val));
+  }
+  static bool isEqual(omp::TraitProperty LHS, omp::TraitProperty RHS) {
+    return LHS == RHS;
+  }
+};
+
+} // end namespace llvm
+#endif // LLVM_OPENMP_CONTEXT_H
diff --git a/linux-x64/clang/include/llvm/Frontend/OpenMP/OMPGridValues.h b/linux-x64/clang/include/llvm/Frontend/OpenMP/OMPGridValues.h
new file mode 100644
index 0000000..6b48cc4
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Frontend/OpenMP/OMPGridValues.h
@@ -0,0 +1,131 @@
+//====--- OMPGridValues.h - Language-specific address spaces --*- C++ -*-====//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// \brief Provides definitions for Target specific Grid Values
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_OPENMP_GRIDVALUES_H
+#define LLVM_OPENMP_GRIDVALUES_H
+
+namespace llvm {
+
+namespace omp {
+
+/// \brief Defines various target-specific GPU grid values that must be
+///        consistent between host RTL (plugin), device RTL, and clang.
+///        We can change grid values for a "fat" binary so that different
+///        passes get the correct values when generating code for a
+///        multi-target binary. Both amdgcn and nvptx values are stored in
+///        this file. In the future, should there be differences between GPUs
+///        of the same architecture, then simply make a different array and
+///        use the new array name.
+///
+/// Example usage in clang:
+///   const unsigned slot_size =
+///   ctx.GetTargetInfo().getGridValue(llvm::omp::GVIDX::GV_Warp_Size);
+///
+/// Example usage in libomptarget/deviceRTLs:
+///   #include "llvm/Frontend/OpenMP/OMPGridValues.h"
+///   #ifdef __AMDGPU__
+///     #define GRIDVAL AMDGPUGpuGridValues
+///   #else
+///     #define GRIDVAL NVPTXGpuGridValues
+///   #endif
+///   ... Then use this reference for GV_Warp_Size in the deviceRTL source.
+///   llvm::omp::GRIDVAL[llvm::omp::GVIDX::GV_Warp_Size]
+///
+/// Example usage in libomptarget hsa plugin:
+///   #include "llvm/Frontend/OpenMP/OMPGridValues.h"
+///   #define GRIDVAL AMDGPUGpuGridValues
+///   ... Then use this reference to access GV_Warp_Size in the hsa plugin.
+///   llvm::omp::GRIDVAL[llvm::omp::GVIDX::GV_Warp_Size]
+///
+/// Example usage in libomptarget cuda plugin:
+///    #include "llvm/Frontend/OpenMP/OMPGridValues.h"
+///    #define GRIDVAL NVPTXGpuGridValues
+///   ... Then use this reference to access GV_Warp_Size in the cuda plugin.
+///    llvm::omp::GRIDVAL[llvm::omp::GVIDX::GV_Warp_Size]
+///
+enum GVIDX {
+  /// The maximum number of workers in a kernel.
+  /// (THREAD_ABSOLUTE_LIMIT) - (GV_Warp_Size), might be issue for blockDim.z
+  GV_Threads,
+  /// The size reserved for data in a shared memory slot.
+  GV_Slot_Size,
+  /// The default value of maximum number of threads in a worker warp.
+  GV_Warp_Size,
+  /// Alternate warp size for some AMDGCN architectures. Same as GV_Warp_Size
+  /// for NVPTX.
+  GV_Warp_Size_32,
+  /// The number of bits required to represent the max number of threads in warp
+  GV_Warp_Size_Log2,
+  /// GV_Warp_Size * GV_Slot_Size,
+  GV_Warp_Slot_Size,
+  /// the maximum number of teams.
+  GV_Max_Teams,
+  /// Global Memory Alignment
+  GV_Mem_Align,
+  /// (~0u >> (GV_Warp_Size - GV_Warp_Size_Log2))
+  GV_Warp_Size_Log2_Mask,
+  // An alternative to the heavy data sharing infrastructure that uses global
+  // memory is one that uses device __shared__ memory.  The amount of such space
+  // (in bytes) reserved by the OpenMP runtime is noted here.
+  GV_SimpleBufferSize,
+  // The absolute maximum team size for a working group
+  GV_Max_WG_Size,
+  // The default maximum team size for a working group
+  GV_Default_WG_Size,
+  // This is GV_Max_WG_Size / GV_WarpSize. 32 for NVPTX and 16 for AMDGCN.
+  GV_Max_Warp_Number,
+  /// The slot size that should be reserved for a working warp.
+  /// (~0u >> (GV_Warp_Size - GV_Warp_Size_Log2))
+  GV_Warp_Size_Log2_MaskL
+};
+
+/// For AMDGPU GPUs
+static constexpr unsigned AMDGPUGpuGridValues[] = {
+    448,       // GV_Threads
+    256,       // GV_Slot_Size
+    64,        // GV_Warp_Size
+    32,        // GV_Warp_Size_32
+    6,         // GV_Warp_Size_Log2
+    64 * 256,  // GV_Warp_Slot_Size
+    128,       // GV_Max_Teams
+    256,       // GV_Mem_Align
+    63,        // GV_Warp_Size_Log2_Mask
+    896,       // GV_SimpleBufferSize
+    1024,      // GV_Max_WG_Size,
+    256,       // GV_Defaut_WG_Size
+    1024 / 64, // GV_Max_WG_Size / GV_WarpSize
+    63         // GV_Warp_Size_Log2_MaskL
+};
+
+/// For Nvidia GPUs
+static constexpr unsigned NVPTXGpuGridValues[] = {
+    992,               // GV_Threads
+    256,               // GV_Slot_Size
+    32,                // GV_Warp_Size
+    32,                // GV_Warp_Size_32
+    5,                 // GV_Warp_Size_Log2
+    32 * 256,          // GV_Warp_Slot_Size
+    1024,              // GV_Max_Teams
+    256,               // GV_Mem_Align
+    (~0u >> (32 - 5)), // GV_Warp_Size_Log2_Mask
+    896,               // GV_SimpleBufferSize
+    1024,              // GV_Max_WG_Size
+    128,               // GV_Defaut_WG_Size
+    1024 / 32,         // GV_Max_WG_Size / GV_WarpSize
+    31                 // GV_Warp_Size_Log2_MaskL
+};
+
+} // namespace omp
+} // namespace llvm
+
+#endif // LLVM_OPENMP_GRIDVALUES_H
diff --git a/linux-x64/clang/include/llvm/Frontend/OpenMP/OMPIRBuilder.h b/linux-x64/clang/include/llvm/Frontend/OpenMP/OMPIRBuilder.h
new file mode 100644
index 0000000..8e95226
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Frontend/OpenMP/OMPIRBuilder.h
@@ -0,0 +1,800 @@
+//===- IR/OpenMPIRBuilder.h - OpenMP encoding builder for LLVM IR - C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the OpenMPIRBuilder class and helpers used as a convenient
+// way to create LLVM instructions for OpenMP directives.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_OPENMP_IR_IRBUILDER_H
+#define LLVM_OPENMP_IR_IRBUILDER_H
+
+#include "llvm/Frontend/OpenMP/OMPConstants.h"
+#include "llvm/IR/DebugLoc.h"
+#include "llvm/IR/IRBuilder.h"
+#include "llvm/Support/Allocator.h"
+#include <forward_list>
+
+namespace llvm {
+class CanonicalLoopInfo;
+
+/// An interface to create LLVM-IR for OpenMP directives.
+///
+/// Each OpenMP directive has a corresponding public generator method.
+class OpenMPIRBuilder {
+public:
+  /// Create a new OpenMPIRBuilder operating on the given module \p M. This will
+  /// not have an effect on \p M (see initialize).
+  OpenMPIRBuilder(Module &M) : M(M), Builder(M.getContext()) {}
+
+  /// Initialize the internal state, this will put structures types and
+  /// potentially other helpers into the underlying module. Must be called
+  /// before any other method and only once!
+  void initialize();
+
+  /// Finalize the underlying module, e.g., by outlining regions.
+  /// \param AllowExtractorSinking Flag to include sinking instructions,
+  ///                              emitted by CodeExtractor, in the
+  ///                              outlined region. Default is false.
+  void finalize(bool AllowExtractorSinking = false);
+
+  /// Add attributes known for \p FnID to \p Fn.
+  void addAttributes(omp::RuntimeFunction FnID, Function &Fn);
+
+  /// Type used throughout for insertion points.
+  using InsertPointTy = IRBuilder<>::InsertPoint;
+
+  /// Callback type for variable finalization (think destructors).
+  ///
+  /// \param CodeGenIP is the insertion point at which the finalization code
+  ///                  should be placed.
+  ///
+  /// A finalize callback knows about all objects that need finalization, e.g.
+  /// destruction, when the scope of the currently generated construct is left
+  /// at the time, and location, the callback is invoked.
+  using FinalizeCallbackTy = std::function<void(InsertPointTy CodeGenIP)>;
+
+  struct FinalizationInfo {
+    /// The finalization callback provided by the last in-flight invocation of
+    /// createXXXX for the directive of kind DK.
+    FinalizeCallbackTy FiniCB;
+
+    /// The directive kind of the innermost directive that has an associated
+    /// region which might require finalization when it is left.
+    omp::Directive DK;
+
+    /// Flag to indicate if the directive is cancellable.
+    bool IsCancellable;
+  };
+
+  /// Push a finalization callback on the finalization stack.
+  ///
+  /// NOTE: Temporary solution until Clang CG is gone.
+  void pushFinalizationCB(const FinalizationInfo &FI) {
+    FinalizationStack.push_back(FI);
+  }
+
+  /// Pop the last finalization callback from the finalization stack.
+  ///
+  /// NOTE: Temporary solution until Clang CG is gone.
+  void popFinalizationCB() { FinalizationStack.pop_back(); }
+
+  /// Callback type for body (=inner region) code generation
+  ///
+  /// The callback takes code locations as arguments, each describing a
+  /// location at which code might need to be generated or a location that is
+  /// the target of control transfer.
+  ///
+  /// \param AllocaIP is the insertion point at which new alloca instructions
+  ///                 should be placed.
+  /// \param CodeGenIP is the insertion point at which the body code should be
+  ///                  placed.
+  /// \param ContinuationBB is the basic block target to leave the body.
+  ///
+  /// Note that all blocks pointed to by the arguments have terminators.
+  using BodyGenCallbackTy =
+      function_ref<void(InsertPointTy AllocaIP, InsertPointTy CodeGenIP,
+                        BasicBlock &ContinuationBB)>;
+
+  /// Callback type for loop body code generation.
+  ///
+  /// \param CodeGenIP is the insertion point where the loop's body code must be
+  ///                  placed. This will be a dedicated BasicBlock with a
+  ///                  conditional branch from the loop condition check and
+  ///                  terminated with an unconditional branch to the loop
+  ///                  latch.
+  /// \param IndVar    is the induction variable usable at the insertion point.
+  using LoopBodyGenCallbackTy =
+      function_ref<void(InsertPointTy CodeGenIP, Value *IndVar)>;
+
+  /// Callback type for variable privatization (think copy & default
+  /// constructor).
+  ///
+  /// \param AllocaIP is the insertion point at which new alloca instructions
+  ///                 should be placed.
+  /// \param CodeGenIP is the insertion point at which the privatization code
+  ///                  should be placed.
+  /// \param Original The value being copied/created, should not be used in the
+  ///                 generated IR.
+  /// \param Inner The equivalent of \p Original that should be used in the
+  ///              generated IR; this is equal to \p Original if the value is
+  ///              a pointer and can thus be passed directly, otherwise it is
+  ///              an equivalent but different value.
+  /// \param ReplVal The replacement value, thus a copy or new created version
+  ///                of \p Inner.
+  ///
+  /// \returns The new insertion point where code generation continues and
+  ///          \p ReplVal the replacement value.
+  using PrivatizeCallbackTy = function_ref<InsertPointTy(
+      InsertPointTy AllocaIP, InsertPointTy CodeGenIP, Value &Original,
+      Value &Inner, Value *&ReplVal)>;
+
+  /// Description of a LLVM-IR insertion point (IP) and a debug/source location
+  /// (filename, line, column, ...).
+  struct LocationDescription {
+    template <typename T, typename U>
+    LocationDescription(const IRBuilder<T, U> &IRB)
+        : IP(IRB.saveIP()), DL(IRB.getCurrentDebugLocation()) {}
+    LocationDescription(const InsertPointTy &IP) : IP(IP) {}
+    LocationDescription(const InsertPointTy &IP, const DebugLoc &DL)
+        : IP(IP), DL(DL) {}
+    InsertPointTy IP;
+    DebugLoc DL;
+  };
+
+  /// Emitter methods for OpenMP directives.
+  ///
+  ///{
+
+  /// Generator for '#omp barrier'
+  ///
+  /// \param Loc The location where the barrier directive was encountered.
+  /// \param DK The kind of directive that caused the barrier.
+  /// \param ForceSimpleCall Flag to force a simple (=non-cancellation) barrier.
+  /// \param CheckCancelFlag Flag to indicate a cancel barrier return value
+  ///                        should be checked and acted upon.
+  ///
+  /// \returns The insertion point after the barrier.
+  InsertPointTy createBarrier(const LocationDescription &Loc, omp::Directive DK,
+                              bool ForceSimpleCall = false,
+                              bool CheckCancelFlag = true);
+
+  /// Generator for '#omp cancel'
+  ///
+  /// \param Loc The location where the directive was encountered.
+  /// \param IfCondition The evaluated 'if' clause expression, if any.
+  /// \param CanceledDirective The kind of directive that is cancled.
+  ///
+  /// \returns The insertion point after the barrier.
+  InsertPointTy createCancel(const LocationDescription &Loc, Value *IfCondition,
+                             omp::Directive CanceledDirective);
+
+  /// Generator for '#omp parallel'
+  ///
+  /// \param Loc The insert and source location description.
+  /// \param AllocaIP The insertion points to be used for alloca instructions.
+  /// \param BodyGenCB Callback that will generate the region code.
+  /// \param PrivCB Callback to copy a given variable (think copy constructor).
+  /// \param FiniCB Callback to finalize variable copies.
+  /// \param IfCondition The evaluated 'if' clause expression, if any.
+  /// \param NumThreads The evaluated 'num_threads' clause expression, if any.
+  /// \param ProcBind The value of the 'proc_bind' clause (see ProcBindKind).
+  /// \param IsCancellable Flag to indicate a cancellable parallel region.
+  ///
+  /// \returns The insertion position *after* the parallel.
+  IRBuilder<>::InsertPoint
+  createParallel(const LocationDescription &Loc, InsertPointTy AllocaIP,
+                 BodyGenCallbackTy BodyGenCB, PrivatizeCallbackTy PrivCB,
+                 FinalizeCallbackTy FiniCB, Value *IfCondition,
+                 Value *NumThreads, omp::ProcBindKind ProcBind,
+                 bool IsCancellable);
+
+  /// Generator for the control flow structure of an OpenMP canonical loop.
+  ///
+  /// This generator operates on the logical iteration space of the loop, i.e.
+  /// the caller only has to provide a loop trip count of the loop as defined by
+  /// base language semantics. The trip count is interpreted as an unsigned
+  /// integer. The induction variable passed to \p BodyGenCB will be of the same
+  /// type and run from 0 to \p TripCount - 1. It is up to the callback to
+  /// convert the logical iteration variable to the loop counter variable in the
+  /// loop body.
+  ///
+  /// \param Loc       The insert and source location description. The insert
+  ///                  location can be between two instructions or the end of a
+  ///                  degenerate block (e.g. a BB under construction).
+  /// \param BodyGenCB Callback that will generate the loop body code.
+  /// \param TripCount Number of iterations the loop body is executed.
+  /// \param Name      Base name used to derive BB and instruction names.
+  ///
+  /// \returns An object representing the created control flow structure which
+  ///          can be used for loop-associated directives.
+  CanonicalLoopInfo *createCanonicalLoop(const LocationDescription &Loc,
+                                         LoopBodyGenCallbackTy BodyGenCB,
+                                         Value *TripCount,
+                                         const Twine &Name = "loop");
+
+  /// Generator for the control flow structure of an OpenMP canonical loop.
+  ///
+  /// Instead of a logical iteration space, this allows specifying user-defined
+  /// loop counter values using increment, upper- and lower bounds. To
+  /// disambiguate the terminology when counting downwards, instead of lower
+  /// bounds we use \p Start for the loop counter value in the first body
+  /// iteration.
+  ///
+  /// Consider the following limitations:
+  ///
+  ///  * A loop counter space over all integer values of its bit-width cannot be
+  ///    represented. E.g using uint8_t, its loop trip count of 256 cannot be
+  ///    stored into an 8 bit integer):
+  ///
+  ///      DO I = 0, 255, 1
+  ///
+  ///  * Unsigned wrapping is only supported when wrapping only "once"; E.g.
+  ///    effectively counting downwards:
+  ///
+  ///      for (uint8_t i = 100u; i > 0; i += 127u)
+  ///
+  ///
+  /// TODO: May need to add additional parameters to represent:
+  ///
+  ///  * Allow representing downcounting with unsigned integers.
+  ///
+  ///  * Sign of the step and the comparison operator might disagree:
+  ///
+  ///      for (int i = 0; i < 42; --i)
+  ///
+  //
+  /// \param Loc       The insert and source location description.
+  /// \param BodyGenCB Callback that will generate the loop body code.
+  /// \param Start     Value of the loop counter for the first iterations.
+  /// \param Stop      Loop counter values past this will stop the the
+  ///                  iterations.
+  /// \param Step      Loop counter increment after each iteration; negative
+  ///                  means counting down. \param IsSigned  Whether Start, Stop
+  ///                  and Stop are signed integers.
+  /// \param InclusiveStop Whether  \p Stop itself is a valid value for the loop
+  ///                      counter.
+  /// \param ComputeIP Insertion point for instructions computing the trip
+  ///                  count. Can be used to ensure the trip count is available
+  ///                  at the outermost loop of a loop nest. If not set,
+  ///                  defaults to the preheader of the generated loop.
+  /// \param Name      Base name used to derive BB and instruction names.
+  ///
+  /// \returns An object representing the created control flow structure which
+  ///          can be used for loop-associated directives.
+  CanonicalLoopInfo *createCanonicalLoop(const LocationDescription &Loc,
+                                         LoopBodyGenCallbackTy BodyGenCB,
+                                         Value *Start, Value *Stop, Value *Step,
+                                         bool IsSigned, bool InclusiveStop,
+                                         InsertPointTy ComputeIP = {},
+                                         const Twine &Name = "loop");
+
+  /// Modifies the canonical loop to be a statically-scheduled workshare loop.
+  ///
+  /// This takes a \p LoopInfo representing a canonical loop, such as the one
+  /// created by \p createCanonicalLoop and emits additional instructions to
+  /// turn it into a workshare loop. In particular, it calls to an OpenMP
+  /// runtime function in the preheader to obtain the loop bounds to be used in
+  /// the current thread, updates the relevant instructions in the canonical
+  /// loop and calls to an OpenMP runtime finalization function after the loop.
+  ///
+  /// \param Loc      The source location description, the insertion location
+  ///                 is not used.
+  /// \param CLI      A descriptor of the canonical loop to workshare.
+  /// \param AllocaIP An insertion point for Alloca instructions usable in the
+  ///                 preheader of the loop.
+  /// \param NeedsBarrier Indicates whether a barrier must be insterted after
+  ///                     the loop.
+  /// \param Chunk    The size of loop chunk considered as a unit when
+  ///                 scheduling. If \p nullptr, defaults to 1.
+  ///
+  /// \returns Updated CanonicalLoopInfo.
+  CanonicalLoopInfo *createStaticWorkshareLoop(const LocationDescription &Loc,
+                                               CanonicalLoopInfo *CLI,
+                                               InsertPointTy AllocaIP,
+                                               bool NeedsBarrier,
+                                               Value *Chunk = nullptr);
+
+  /// Generator for '#omp flush'
+  ///
+  /// \param Loc The location where the flush directive was encountered
+  void createFlush(const LocationDescription &Loc);
+
+  /// Generator for '#omp taskwait'
+  ///
+  /// \param Loc The location where the taskwait directive was encountered.
+  void createTaskwait(const LocationDescription &Loc);
+
+  /// Generator for '#omp taskyield'
+  ///
+  /// \param Loc The location where the taskyield directive was encountered.
+  void createTaskyield(const LocationDescription &Loc);
+
+  ///}
+
+  /// Return the insertion point used by the underlying IRBuilder.
+  InsertPointTy getInsertionPoint() { return Builder.saveIP(); }
+
+  /// Update the internal location to \p Loc.
+  bool updateToLocation(const LocationDescription &Loc) {
+    Builder.restoreIP(Loc.IP);
+    Builder.SetCurrentDebugLocation(Loc.DL);
+    return Loc.IP.getBlock() != nullptr;
+  }
+
+  /// Return the function declaration for the runtime function with \p FnID.
+  FunctionCallee getOrCreateRuntimeFunction(Module &M,
+                                            omp::RuntimeFunction FnID);
+
+  Function *getOrCreateRuntimeFunctionPtr(omp::RuntimeFunction FnID);
+
+  /// Return the (LLVM-IR) string describing the source location \p LocStr.
+  Constant *getOrCreateSrcLocStr(StringRef LocStr);
+
+  /// Return the (LLVM-IR) string describing the default source location.
+  Constant *getOrCreateDefaultSrcLocStr();
+
+  /// Return the (LLVM-IR) string describing the source location identified by
+  /// the arguments.
+  Constant *getOrCreateSrcLocStr(StringRef FunctionName, StringRef FileName,
+                                 unsigned Line, unsigned Column);
+
+  /// Return the (LLVM-IR) string describing the source location \p Loc.
+  Constant *getOrCreateSrcLocStr(const LocationDescription &Loc);
+
+  /// Return an ident_t* encoding the source location \p SrcLocStr and \p Flags.
+  /// TODO: Create a enum class for the Reserve2Flags
+  Value *getOrCreateIdent(Constant *SrcLocStr,
+                          omp::IdentFlag Flags = omp::IdentFlag(0),
+                          unsigned Reserve2Flags = 0);
+
+  // Get the type corresponding to __kmpc_impl_lanemask_t from the deviceRTL
+  Type *getLanemaskType();
+
+  /// Generate control flow and cleanup for cancellation.
+  ///
+  /// \param CancelFlag Flag indicating if the cancellation is performed.
+  /// \param CanceledDirective The kind of directive that is cancled.
+  void emitCancelationCheckImpl(Value *CancelFlag,
+                                omp::Directive CanceledDirective);
+
+  /// Generate a barrier runtime call.
+  ///
+  /// \param Loc The location at which the request originated and is fulfilled.
+  /// \param DK The directive which caused the barrier
+  /// \param ForceSimpleCall Flag to force a simple (=non-cancellation) barrier.
+  /// \param CheckCancelFlag Flag to indicate a cancel barrier return value
+  ///                        should be checked and acted upon.
+  ///
+  /// \returns The insertion point after the barrier.
+  InsertPointTy emitBarrierImpl(const LocationDescription &Loc,
+                                omp::Directive DK, bool ForceSimpleCall,
+                                bool CheckCancelFlag);
+
+  /// Generate a flush runtime call.
+  ///
+  /// \param Loc The location at which the request originated and is fulfilled.
+  void emitFlush(const LocationDescription &Loc);
+
+  /// The finalization stack made up of finalize callbacks currently in-flight,
+  /// wrapped into FinalizationInfo objects that reference also the finalization
+  /// target block and the kind of cancellable directive.
+  SmallVector<FinalizationInfo, 8> FinalizationStack;
+
+  /// Return true if the last entry in the finalization stack is of kind \p DK
+  /// and cancellable.
+  bool isLastFinalizationInfoCancellable(omp::Directive DK) {
+    return !FinalizationStack.empty() &&
+           FinalizationStack.back().IsCancellable &&
+           FinalizationStack.back().DK == DK;
+  }
+
+  /// Generate a taskwait runtime call.
+  ///
+  /// \param Loc The location at which the request originated and is fulfilled.
+  void emitTaskwaitImpl(const LocationDescription &Loc);
+
+  /// Generate a taskyield runtime call.
+  ///
+  /// \param Loc The location at which the request originated and is fulfilled.
+  void emitTaskyieldImpl(const LocationDescription &Loc);
+
+  /// Return the current thread ID.
+  ///
+  /// \param Ident The ident (ident_t*) describing the query origin.
+  Value *getOrCreateThreadID(Value *Ident);
+
+  /// The underlying LLVM-IR module
+  Module &M;
+
+  /// The LLVM-IR Builder used to create IR.
+  IRBuilder<> Builder;
+
+  /// Map to remember source location strings
+  StringMap<Constant *> SrcLocStrMap;
+
+  /// Map to remember existing ident_t*.
+  DenseMap<std::pair<Constant *, uint64_t>, Value *> IdentMap;
+
+  /// Helper that contains information about regions we need to outline
+  /// during finalization.
+  struct OutlineInfo {
+    using PostOutlineCBTy = std::function<void(Function &)>;
+    PostOutlineCBTy PostOutlineCB;
+    BasicBlock *EntryBB, *ExitBB;
+
+    /// Collect all blocks in between EntryBB and ExitBB in both the given
+    /// vector and set.
+    void collectBlocks(SmallPtrSetImpl<BasicBlock *> &BlockSet,
+                       SmallVectorImpl<BasicBlock *> &BlockVector);
+  };
+
+  /// Collection of regions that need to be outlined during finalization.
+  SmallVector<OutlineInfo, 16> OutlineInfos;
+
+  /// Collection of owned canonical loop objects that eventually need to be
+  /// free'd.
+  std::forward_list<CanonicalLoopInfo> LoopInfos;
+
+  /// Add a new region that will be outlined later.
+  void addOutlineInfo(OutlineInfo &&OI) { OutlineInfos.emplace_back(OI); }
+
+  /// An ordered map of auto-generated variables to their unique names.
+  /// It stores variables with the following names: 1) ".gomp_critical_user_" +
+  /// <critical_section_name> + ".var" for "omp critical" directives; 2)
+  /// <mangled_name_for_global_var> + ".cache." for cache for threadprivate
+  /// variables.
+  StringMap<AssertingVH<Constant>, BumpPtrAllocator> InternalVars;
+
+public:
+  /// Generator for __kmpc_copyprivate
+  ///
+  /// \param Loc The source location description.
+  /// \param BufSize Number of elements in the buffer.
+  /// \param CpyBuf List of pointers to data to be copied.
+  /// \param CpyFn function to call for copying data.
+  /// \param DidIt flag variable; 1 for 'single' thread, 0 otherwise.
+  ///
+  /// \return The insertion position *after* the CopyPrivate call.
+
+  InsertPointTy createCopyPrivate(const LocationDescription &Loc,
+                                  llvm::Value *BufSize, llvm::Value *CpyBuf,
+                                  llvm::Value *CpyFn, llvm::Value *DidIt);
+
+  /// Generator for '#omp single'
+  ///
+  /// \param Loc The source location description.
+  /// \param BodyGenCB Callback that will generate the region code.
+  /// \param FiniCB Callback to finalize variable copies.
+  /// \param DidIt Local variable used as a flag to indicate 'single' thread
+  ///
+  /// \returns The insertion position *after* the single call.
+  InsertPointTy createSingle(const LocationDescription &Loc,
+                             BodyGenCallbackTy BodyGenCB,
+                             FinalizeCallbackTy FiniCB, llvm::Value *DidIt);
+
+  /// Generator for '#omp master'
+  ///
+  /// \param Loc The insert and source location description.
+  /// \param BodyGenCB Callback that will generate the region code.
+  /// \param FiniCB Callback to finalize variable copies.
+  ///
+  /// \returns The insertion position *after* the master.
+  InsertPointTy createMaster(const LocationDescription &Loc,
+                             BodyGenCallbackTy BodyGenCB,
+                             FinalizeCallbackTy FiniCB);
+
+  /// Generator for '#omp critical'
+  ///
+  /// \param Loc The insert and source location description.
+  /// \param BodyGenCB Callback that will generate the region body code.
+  /// \param FiniCB Callback to finalize variable copies.
+  /// \param CriticalName name of the lock used by the critical directive
+  /// \param HintInst Hint Instruction for hint clause associated with critical
+  ///
+  /// \returns The insertion position *after* the master.
+  InsertPointTy createCritical(const LocationDescription &Loc,
+                               BodyGenCallbackTy BodyGenCB,
+                               FinalizeCallbackTy FiniCB,
+                               StringRef CriticalName, Value *HintInst);
+
+  /// Generate conditional branch and relevant BasicBlocks through which private
+  /// threads copy the 'copyin' variables from Master copy to threadprivate
+  /// copies.
+  ///
+  /// \param IP insertion block for copyin conditional
+  /// \param MasterVarPtr a pointer to the master variable
+  /// \param PrivateVarPtr a pointer to the threadprivate variable
+  /// \param IntPtrTy Pointer size type
+  /// \param BranchtoEnd Create a branch between the copyin.not.master blocks
+  //				 and copy.in.end block
+  ///
+  /// \returns The insertion point where copying operation to be emitted.
+  InsertPointTy createCopyinClauseBlocks(InsertPointTy IP, Value *MasterAddr,
+                                         Value *PrivateAddr,
+                                         llvm::IntegerType *IntPtrTy,
+                                         bool BranchtoEnd = true);
+
+  /// Create a runtime call for kmpc_Alloc
+  ///
+  /// \param Loc The insert and source location description.
+  /// \param Size Size of allocated memory space
+  /// \param Allocator Allocator information instruction
+  /// \param Name Name of call Instruction for OMP_alloc
+  ///
+  /// \returns CallInst to the OMP_Alloc call
+  CallInst *createOMPAlloc(const LocationDescription &Loc, Value *Size,
+                           Value *Allocator, std::string Name = "");
+
+  /// Create a runtime call for kmpc_free
+  ///
+  /// \param Loc The insert and source location description.
+  /// \param Addr Address of memory space to be freed
+  /// \param Allocator Allocator information instruction
+  /// \param Name Name of call Instruction for OMP_Free
+  ///
+  /// \returns CallInst to the OMP_Free call
+  CallInst *createOMPFree(const LocationDescription &Loc, Value *Addr,
+                          Value *Allocator, std::string Name = "");
+
+  /// Create a runtime call for kmpc_threadprivate_cached
+  ///
+  /// \param Loc The insert and source location description.
+  /// \param Pointer pointer to data to be cached
+  /// \param Size size of data to be cached
+  /// \param Name Name of call Instruction for callinst
+  ///
+  /// \returns CallInst to the thread private cache call.
+  CallInst *createCachedThreadPrivate(const LocationDescription &Loc,
+                                      llvm::Value *Pointer,
+                                      llvm::ConstantInt *Size,
+                                      const llvm::Twine &Name = Twine(""));
+
+  /// Declarations for LLVM-IR types (simple, array, function and structure) are
+  /// generated below. Their names are defined and used in OpenMPKinds.def. Here
+  /// we provide the declarations, the initializeTypes function will provide the
+  /// values.
+  ///
+  ///{
+#define OMP_TYPE(VarName, InitValue) Type *VarName = nullptr;
+#define OMP_ARRAY_TYPE(VarName, ElemTy, ArraySize)                             \
+  ArrayType *VarName##Ty = nullptr;                                            \
+  PointerType *VarName##PtrTy = nullptr;
+#define OMP_FUNCTION_TYPE(VarName, IsVarArg, ReturnType, ...)                  \
+  FunctionType *VarName = nullptr;                                             \
+  PointerType *VarName##Ptr = nullptr;
+#define OMP_STRUCT_TYPE(VarName, StrName, ...)                                 \
+  StructType *VarName = nullptr;                                               \
+  PointerType *VarName##Ptr = nullptr;
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
+
+  ///}
+
+private:
+  /// Create all simple and struct types exposed by the runtime and remember
+  /// the llvm::PointerTypes of them for easy access later.
+  void initializeTypes(Module &M);
+
+  /// Common interface for generating entry calls for OMP Directives.
+  /// if the directive has a region/body, It will set the insertion
+  /// point to the body
+  ///
+  /// \param OMPD Directive to generate entry blocks for
+  /// \param EntryCall Call to the entry OMP Runtime Function
+  /// \param ExitBB block where the region ends.
+  /// \param Conditional indicate if the entry call result will be used
+  ///        to evaluate a conditional of whether a thread will execute
+  ///        body code or not.
+  ///
+  /// \return The insertion position in exit block
+  InsertPointTy emitCommonDirectiveEntry(omp::Directive OMPD, Value *EntryCall,
+                                         BasicBlock *ExitBB,
+                                         bool Conditional = false);
+
+  /// Common interface to finalize the region
+  ///
+  /// \param OMPD Directive to generate exiting code for
+  /// \param FinIP Insertion point for emitting Finalization code and exit call
+  /// \param ExitCall Call to the ending OMP Runtime Function
+  /// \param HasFinalize indicate if the directive will require finalization
+  ///         and has a finalization callback in the stack that
+  ///        should be called.
+  ///
+  /// \return The insertion position in exit block
+  InsertPointTy emitCommonDirectiveExit(omp::Directive OMPD,
+                                        InsertPointTy FinIP,
+                                        Instruction *ExitCall,
+                                        bool HasFinalize = true);
+
+  /// Common Interface to generate OMP inlined regions
+  ///
+  /// \param OMPD Directive to generate inlined region for
+  /// \param EntryCall Call to the entry OMP Runtime Function
+  /// \param ExitCall Call to the ending OMP Runtime Function
+  /// \param BodyGenCB Body code generation callback.
+  /// \param FiniCB Finalization Callback. Will be called when finalizing region
+  /// \param Conditional indicate if the entry call result will be used
+  ///        to evaluate a conditional of whether a thread will execute
+  ///        body code or not.
+  /// \param HasFinalize indicate if the directive will require finalization
+  ///         and has a finalization callback in the stack that
+  /// should        be called.
+  ///
+  /// \return The insertion point after the region
+
+  InsertPointTy
+  EmitOMPInlinedRegion(omp::Directive OMPD, Instruction *EntryCall,
+                       Instruction *ExitCall, BodyGenCallbackTy BodyGenCB,
+                       FinalizeCallbackTy FiniCB, bool Conditional = false,
+                       bool HasFinalize = true);
+
+  /// Get the platform-specific name separator.
+  /// \param Parts different parts of the final name that needs separation
+  /// \param FirstSeparator First separator used between the initial two
+  ///        parts of the name.
+  /// \param Separator separator used between all of the rest consecutive
+  ///        parts of the name
+  static std::string getNameWithSeparators(ArrayRef<StringRef> Parts,
+                                           StringRef FirstSeparator,
+                                           StringRef Separator);
+
+  /// Gets (if variable with the given name already exist) or creates
+  /// internal global variable with the specified Name. The created variable has
+  /// linkage CommonLinkage by default and is initialized by null value.
+  /// \param Ty Type of the global variable. If it is exist already the type
+  /// must be the same.
+  /// \param Name Name of the variable.
+  Constant *getOrCreateOMPInternalVariable(Type *Ty, const Twine &Name,
+                                           unsigned AddressSpace = 0);
+
+  /// Returns corresponding lock object for the specified critical region
+  /// name. If the lock object does not exist it is created, otherwise the
+  /// reference to the existing copy is returned.
+  /// \param CriticalName Name of the critical region.
+  ///
+  Value *getOMPCriticalRegionLock(StringRef CriticalName);
+
+  /// Create the control flow structure of a canonical OpenMP loop.
+  ///
+  /// The emitted loop will be disconnected, i.e. no edge to the loop's
+  /// preheader and no terminator in the AfterBB. The OpenMPIRBuilder's
+  /// IRBuilder location is not preserved.
+  ///
+  /// \param DL        DebugLoc used for the instructions in the skeleton.
+  /// \param TripCount Value to be used for the trip count.
+  /// \param F         Function in which to insert the BasicBlocks.
+  /// \param PreInsertBefore  Where to insert BBs that execute before the body,
+  ///                         typically the body itself.
+  /// \param PostInsertBefore Where to insert BBs that execute after the body.
+  /// \param Name      Base name used to derive BB
+  ///                  and instruction names.
+  ///
+  /// \returns The CanonicalLoopInfo that represents the emitted loop.
+  CanonicalLoopInfo *createLoopSkeleton(DebugLoc DL, Value *TripCount,
+                                        Function *F,
+                                        BasicBlock *PreInsertBefore,
+                                        BasicBlock *PostInsertBefore,
+                                        const Twine &Name = {});
+};
+
+/// Class to represented the control flow structure of an OpenMP canonical loop.
+///
+/// The control-flow structure is standardized for easy consumption by
+/// directives associated with loops. For instance, the worksharing-loop
+/// construct may change this control flow such that each loop iteration is
+/// executed on only one thread.
+///
+/// The control flow can be described as follows:
+///
+///     Preheader
+///        |
+///  /-> Header
+///  |     |
+///  |    Cond---\
+///  |     |     |
+///  |    Body   |
+///  |    | |    |
+///  |   <...>   |
+///  |    | |    |
+///   \--Latch   |
+///              |
+///             Exit
+///              |
+///            After
+///
+/// Code in the header, condition block, latch and exit block must not have any
+/// side-effect. The body block is the single entry point into the loop body,
+/// which may contain arbitrary control flow as long as all control paths
+/// eventually branch to the latch block.
+///
+/// Defined outside OpenMPIRBuilder because one cannot forward-declare nested
+/// classes.
+class CanonicalLoopInfo {
+  friend class OpenMPIRBuilder;
+
+private:
+  /// Whether this object currently represents a loop.
+  bool IsValid = false;
+
+  BasicBlock *Preheader;
+  BasicBlock *Header;
+  BasicBlock *Cond;
+  BasicBlock *Body;
+  BasicBlock *Latch;
+  BasicBlock *Exit;
+  BasicBlock *After;
+
+public:
+  /// The preheader ensures that there is only a single edge entering the loop.
+  /// Code that must be execute before any loop iteration can be emitted here,
+  /// such as computing the loop trip count and begin lifetime markers. Code in
+  /// the preheader is not considered part of the canonical loop.
+  BasicBlock *getPreheader() const { return Preheader; }
+
+  /// The header is the entry for each iteration. In the canonical control flow,
+  /// it only contains the PHINode for the induction variable.
+  BasicBlock *getHeader() const { return Header; }
+
+  /// The condition block computes whether there is another loop iteration. If
+  /// yes, branches to the body; otherwise to the exit block.
+  BasicBlock *getCond() const { return Cond; }
+
+  /// The body block is the single entry for a loop iteration and not controlled
+  /// by CanonicalLoopInfo. It can contain arbitrary control flow but must
+  /// eventually branch to the \p Latch block.
+  BasicBlock *getBody() const { return Body; }
+
+  /// Reaching the latch indicates the end of the loop body code. In the
+  /// canonical control flow, it only contains the increment of the induction
+  /// variable.
+  BasicBlock *getLatch() const { return Latch; }
+
+  /// Reaching the exit indicates no more iterations are being executed.
+  BasicBlock *getExit() const { return Exit; }
+
+  /// The after block is intended for clean-up code such as lifetime end
+  /// markers. It is separate from the exit block to ensure, analogous to the
+  /// preheader, it having just a single entry edge and being free from PHI
+  /// nodes should there be multiple loop exits (such as from break
+  /// statements/cancellations).
+  BasicBlock *getAfter() const { return After; }
+
+  /// Returns the llvm::Value containing the number of loop iterations. It must
+  /// be valid in the preheader and always interpreted as an unsigned integer of
+  /// any bit-width.
+  Value *getTripCount() const {
+    Instruction *CmpI = &Cond->front();
+    assert(isa<CmpInst>(CmpI) && "First inst must compare IV with TripCount");
+    return CmpI->getOperand(1);
+  }
+
+  /// Returns the instruction representing the current logical induction
+  /// variable. Always unsigned, always starting at 0 with an increment of one.
+  Instruction *getIndVar() const {
+    Instruction *IndVarPHI = &Header->front();
+    assert(isa<PHINode>(IndVarPHI) && "First inst must be the IV PHI");
+    return IndVarPHI;
+  }
+
+  /// Return the insertion point for user code in the body.
+  OpenMPIRBuilder::InsertPointTy getBodyIP() const {
+    return {Body, Body->begin()};
+  };
+
+  /// Return the insertion point for user code after the loop.
+  OpenMPIRBuilder::InsertPointTy getAfterIP() const {
+    return {After, After->begin()};
+  };
+
+  /// Consistency self-check.
+  void assertOK() const;
+};
+
+} // end namespace llvm
+
+#endif // LLVM_IR_IRBUILDER_H
diff --git a/linux-x64/clang/include/llvm/Frontend/OpenMP/OMPKinds.def b/linux-x64/clang/include/llvm/Frontend/OpenMP/OMPKinds.def
new file mode 100644
index 0000000..38496d3
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Frontend/OpenMP/OMPKinds.def
@@ -0,0 +1,1141 @@
+//===--- OMPKinds.def - OpenMP directives, clauses, rt-calls -*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+/// \file
+///
+/// This file defines the list of supported OpenMP runtime
+/// calls, and other things that need to be listed in enums.
+///
+/// This file is under transition to OMP.td with TableGen code generation.
+///
+//===----------------------------------------------------------------------===//
+
+/// OpenMP Directives, combined directives and Clauses
+/// - Moved to OMP.td
+
+/// Types used in runtime structs or runtime functions
+///
+///{
+
+#ifndef OMP_TYPE
+#define OMP_TYPE(VarName, InitValue)
+#endif
+
+#define __OMP_TYPE(VarName) OMP_TYPE(VarName, Type::get##VarName##Ty(Ctx))
+
+__OMP_TYPE(Void)
+__OMP_TYPE(Int1)
+__OMP_TYPE(Int8)
+__OMP_TYPE(Int16)
+__OMP_TYPE(Int32)
+__OMP_TYPE(Int64)
+__OMP_TYPE(Int8Ptr)
+__OMP_TYPE(Int16Ptr)
+__OMP_TYPE(Int32Ptr)
+__OMP_TYPE(Int64Ptr)
+
+OMP_TYPE(SizeTy, M.getDataLayout().getIntPtrType(Ctx))
+OMP_TYPE(LanemaskTy, getLanemaskType())
+
+#define __OMP_PTR_TYPE(NAME, BASE) OMP_TYPE(NAME, BASE->getPointerTo())
+
+__OMP_PTR_TYPE(VoidPtr, Int8)
+__OMP_PTR_TYPE(VoidPtrPtr, VoidPtr)
+__OMP_PTR_TYPE(VoidPtrPtrPtr, VoidPtrPtr)
+
+__OMP_PTR_TYPE(Int8PtrPtr, Int8Ptr)
+__OMP_PTR_TYPE(Int8PtrPtrPtr, Int8PtrPtr)
+
+#undef __OMP_PTR_TYPE
+
+#undef __OMP_TYPE
+#undef OMP_TYPE
+
+///}
+
+/// array types
+///
+///{
+
+#ifndef OMP_ARRAY_TYPE
+#define OMP_ARRAY_TYPE(VarName, ElemTy, ArraySize)
+#endif
+
+#define __OMP_ARRAY_TYPE(VarName, ElemTy, ArraySize)                           \
+  OMP_ARRAY_TYPE(VarName, ElemTy, ArraySize)
+
+__OMP_ARRAY_TYPE(KmpCriticalName, Int32, 8)
+
+#undef __OMP_ARRAY_TYPE
+#undef OMP_ARRAY_TYPE
+
+///}
+
+/// Struct and function types
+///
+///{
+
+#ifndef OMP_STRUCT_TYPE
+#define OMP_STRUCT_TYPE(VarName, StructName, ...)
+#endif
+
+#define __OMP_STRUCT_TYPE(VarName, Name, ...)                                  \
+  OMP_STRUCT_TYPE(VarName, "struct." #Name, __VA_ARGS__)
+
+__OMP_STRUCT_TYPE(Ident, ident_t, Int32, Int32, Int32, Int32, Int8Ptr)
+__OMP_STRUCT_TYPE(AsyncInfo, __tgt_async_info, Int8Ptr)
+
+#undef __OMP_STRUCT_TYPE
+#undef OMP_STRUCT_TYPE
+
+#ifndef OMP_FUNCTION_TYPE
+#define OMP_FUNCTION_TYPE(VarName, IsVarArg, ReturnType, ...)
+#endif
+
+#define __OMP_FUNCTION_TYPE(VarName, IsVarArg, ReturnType, ...)                \
+  OMP_FUNCTION_TYPE(VarName, IsVarArg, ReturnType, __VA_ARGS__)
+
+__OMP_FUNCTION_TYPE(ParallelTask, true, Void, Int32Ptr, Int32Ptr)
+__OMP_FUNCTION_TYPE(ReduceFunction, false, Void, VoidPtr, VoidPtr)
+__OMP_FUNCTION_TYPE(CopyFunction, false, Void, VoidPtr, VoidPtr)
+__OMP_FUNCTION_TYPE(KmpcCtor, false, VoidPtr, VoidPtr)
+__OMP_FUNCTION_TYPE(KmpcDtor, false, Void, VoidPtr)
+__OMP_FUNCTION_TYPE(KmpcCopyCtor, false, VoidPtr, VoidPtr, VoidPtr)
+__OMP_FUNCTION_TYPE(TaskRoutineEntry, false, Int32, Int32,
+                    /* kmp_task_t */ VoidPtr)
+__OMP_FUNCTION_TYPE(ShuffleReduce, false, Void, VoidPtr, Int16, Int16, Int16)
+__OMP_FUNCTION_TYPE(InterWarpCopy, false, Void, VoidPtr, Int32)
+__OMP_FUNCTION_TYPE(GlobalList, false, Void, VoidPtr, Int32, VoidPtr)
+
+#undef __OMP_FUNCTION_TYPE
+#undef OMP_FUNCTION_TYPE
+
+///}
+
+/// Internal Control Variables information
+///
+///{
+
+#ifndef ICV_INIT_VALUE
+#define ICV_INIT_VALUE(Enum, Name)
+#endif
+
+#define __ICV_INIT_VALUE(Name) ICV_INIT_VALUE(ICV_##Name, #Name)
+
+__ICV_INIT_VALUE(ZERO)
+__ICV_INIT_VALUE(FALSE)
+__ICV_INIT_VALUE(IMPLEMENTATION_DEFINED)
+__ICV_INIT_VALUE(LAST)
+
+#undef __ICV_INIT_VALUE
+#undef ICV_INIT_VALUE
+
+#ifndef ICV_DATA_ENV
+#define ICV_DATA_ENV(Enum, Name, EnvVarName, Init)
+#endif
+
+#define __ICV_DATA_ENV(Name, EnvVarName, Init)                                 \
+  ICV_DATA_ENV(ICV_##Name, #Name, #EnvVarName, Init)
+
+__ICV_DATA_ENV(nthreads, OMP_NUM_THREADS, ICV_IMPLEMENTATION_DEFINED)
+__ICV_DATA_ENV(active_levels, NONE, ICV_ZERO)
+__ICV_DATA_ENV(cancel, OMP_CANCELLATION, ICV_FALSE)
+__ICV_DATA_ENV(proc_bind, OMP_PROC_BIND, ICV_IMPLEMENTATION_DEFINED)
+__ICV_DATA_ENV(__last, last, ICV_LAST)
+
+#undef __ICV_DATA_ENV
+#undef ICV_DATA_ENV
+
+#ifndef ICV_RT_SET
+#define ICV_RT_SET(Name, RTL)
+#endif
+
+#define __ICV_RT_SET(Name, RTL) ICV_RT_SET(ICV_##Name, OMPRTL_##RTL)
+
+__ICV_RT_SET(nthreads, omp_set_num_threads)
+
+#undef __ICV_RT_SET
+#undef ICV_RT_SET
+
+#ifndef ICV_RT_GET
+#define ICV_RT_GET(Name, RTL)
+#endif
+
+#define __ICV_RT_GET(Name, RTL) ICV_RT_GET(ICV_##Name, OMPRTL_##RTL)
+
+__ICV_RT_GET(nthreads, omp_get_max_threads)
+__ICV_RT_GET(active_levels, omp_get_active_level)
+__ICV_RT_GET(cancel, omp_get_cancellation)
+__ICV_RT_GET(proc_bind, omp_get_proc_bind)
+
+#undef __ICV_RT_GET
+#undef ICV_RT_GET
+
+///}
+
+/// Runtime library function (and their attributes)
+///
+///{
+
+#ifndef OMP_RTL
+#define OMP_RTL(Enum, Str, IsVarArg, ReturnType, ...)
+#endif
+
+#define __OMP_RTL(Name, IsVarArg, ReturnType, ...)                             \
+  OMP_RTL(OMPRTL_##Name, #Name, IsVarArg, ReturnType, __VA_ARGS__)
+
+
+
+__OMP_RTL(__kmpc_barrier, false, Void, IdentPtr, Int32)
+__OMP_RTL(__kmpc_cancel, false, Int32, IdentPtr, Int32, Int32)
+__OMP_RTL(__kmpc_cancel_barrier, false, Int32, IdentPtr, Int32)
+__OMP_RTL(__kmpc_flush, false, Void, IdentPtr)
+__OMP_RTL(__kmpc_global_thread_num, false, Int32, IdentPtr)
+__OMP_RTL(__kmpc_fork_call, true, Void, IdentPtr, Int32, ParallelTaskPtr)
+__OMP_RTL(__kmpc_omp_taskwait, false, Int32, IdentPtr, Int32)
+__OMP_RTL(__kmpc_omp_taskyield, false, Int32, IdentPtr, Int32, /* Int */ Int32)
+__OMP_RTL(__kmpc_push_num_threads, false, Void, IdentPtr, Int32,
+          /* Int */ Int32)
+__OMP_RTL(__kmpc_push_proc_bind, false, Void, IdentPtr, Int32, /* Int */ Int32)
+__OMP_RTL(__kmpc_omp_reg_task_with_affinity, false, Int32, IdentPtr, Int32,
+          /* kmp_task_t */ VoidPtr, Int32,
+          /* kmp_task_affinity_info_t */ VoidPtr)
+
+__OMP_RTL(omp_get_thread_num, false, Int32, )
+__OMP_RTL(omp_get_num_threads, false, Int32, )
+__OMP_RTL(omp_get_max_threads, false, Int32, )
+__OMP_RTL(omp_in_parallel, false, Int32, )
+__OMP_RTL(omp_get_dynamic, false, Int32, )
+__OMP_RTL(omp_get_cancellation, false, Int32, )
+__OMP_RTL(omp_get_nested, false, Int32, )
+__OMP_RTL(omp_get_schedule, false, Void, Int32Ptr, Int32Ptr)
+__OMP_RTL(omp_get_thread_limit, false, Int32, )
+__OMP_RTL(omp_get_supported_active_levels, false, Int32, )
+__OMP_RTL(omp_get_max_active_levels, false, Int32, )
+__OMP_RTL(omp_get_level, false, Int32, )
+__OMP_RTL(omp_get_ancestor_thread_num, false, Int32, Int32)
+__OMP_RTL(omp_get_team_size, false, Int32, Int32)
+__OMP_RTL(omp_get_active_level, false, Int32, )
+__OMP_RTL(omp_in_final, false, Int32, )
+__OMP_RTL(omp_get_proc_bind, false, Int32, )
+__OMP_RTL(omp_get_num_places, false, Int32, )
+__OMP_RTL(omp_get_num_procs, false, Int32, )
+__OMP_RTL(omp_get_place_proc_ids, false, Void, Int32, Int32Ptr)
+__OMP_RTL(omp_get_place_num, false, Int32, )
+__OMP_RTL(omp_get_partition_num_places, false, Int32, )
+__OMP_RTL(omp_get_partition_place_nums, false, Void, Int32Ptr)
+
+__OMP_RTL(omp_set_num_threads, false, Void, Int32)
+__OMP_RTL(omp_set_dynamic, false, Void, Int32)
+__OMP_RTL(omp_set_nested, false, Void, Int32)
+__OMP_RTL(omp_set_schedule, false, Void, Int32, Int32)
+__OMP_RTL(omp_set_max_active_levels, false, Void, Int32)
+
+__OMP_RTL(__kmpc_master, false, Int32, IdentPtr, Int32)
+__OMP_RTL(__kmpc_end_master, false, Void, IdentPtr, Int32)
+__OMP_RTL(__kmpc_critical, false, Void, IdentPtr, Int32, KmpCriticalNamePtrTy)
+__OMP_RTL(__kmpc_critical_with_hint, false, Void, IdentPtr, Int32,
+          KmpCriticalNamePtrTy, Int32)
+__OMP_RTL(__kmpc_end_critical, false, Void, IdentPtr, Int32,
+          KmpCriticalNamePtrTy)
+
+__OMP_RTL(__kmpc_begin, false, Void, IdentPtr, Int32)
+__OMP_RTL(__kmpc_end, false, Void, IdentPtr)
+
+__OMP_RTL(__kmpc_reduce, false, Int32, IdentPtr, Int32, Int32, SizeTy, VoidPtr,
+          ReduceFunctionPtr, KmpCriticalNamePtrTy)
+__OMP_RTL(__kmpc_reduce_nowait, false, Int32, IdentPtr, Int32, Int32, SizeTy,
+          VoidPtr, ReduceFunctionPtr, KmpCriticalNamePtrTy)
+__OMP_RTL(__kmpc_end_reduce, false, Void, IdentPtr, Int32, KmpCriticalNamePtrTy)
+__OMP_RTL(__kmpc_end_reduce_nowait, false, Void, IdentPtr, Int32,
+          KmpCriticalNamePtrTy)
+
+__OMP_RTL(__kmpc_ordered, false, Void, IdentPtr, Int32)
+__OMP_RTL(__kmpc_end_ordered, false, Void, IdentPtr, Int32)
+
+__OMP_RTL(__kmpc_for_static_init_4, false, Void, IdentPtr, Int32, Int32,
+          Int32Ptr, Int32Ptr, Int32Ptr, Int32Ptr, Int32, Int32)
+__OMP_RTL(__kmpc_for_static_init_4u, false, Void, IdentPtr, Int32, Int32,
+          Int32Ptr, Int32Ptr, Int32Ptr, Int32Ptr, Int32, Int32)
+__OMP_RTL(__kmpc_for_static_init_8, false, Void, IdentPtr, Int32, Int32,
+          Int32Ptr, Int64Ptr, Int64Ptr, Int64Ptr, Int64, Int64)
+__OMP_RTL(__kmpc_for_static_init_8u, false, Void, IdentPtr, Int32, Int32,
+          Int32Ptr, Int64Ptr, Int64Ptr, Int64Ptr, Int64, Int64)
+__OMP_RTL(__kmpc_for_static_fini, false, Void, IdentPtr, Int32)
+__OMP_RTL(__kmpc_dist_dispatch_init_4, false, Void, IdentPtr, Int32, Int32,
+          Int32Ptr, Int32, Int32, Int32, Int32)
+__OMP_RTL(__kmpc_dist_dispatch_init_4u, false, Void, IdentPtr, Int32, Int32,
+          Int32Ptr, Int32, Int32, Int32, Int32)
+__OMP_RTL(__kmpc_dist_dispatch_init_8, false, Void, IdentPtr, Int32, Int32,
+          Int32Ptr, Int64, Int64, Int64, Int64)
+__OMP_RTL(__kmpc_dist_dispatch_init_8u, false, Void, IdentPtr, Int32, Int32,
+          Int32Ptr, Int64, Int64, Int64, Int64)
+__OMP_RTL(__kmpc_dispatch_init_4, false, Void, IdentPtr, Int32, Int32, Int32,
+          Int32, Int32, Int32)
+__OMP_RTL(__kmpc_dispatch_init_4u, false, Void, IdentPtr, Int32, Int32, Int32,
+          Int32, Int32, Int32)
+__OMP_RTL(__kmpc_dispatch_init_8, false, Void, IdentPtr, Int32, Int32, Int64,
+          Int64, Int64, Int64)
+__OMP_RTL(__kmpc_dispatch_init_8u, false, Void, IdentPtr, Int32, Int32, Int64,
+          Int64, Int64, Int64)
+__OMP_RTL(__kmpc_dispatch_next_4, false, Int32, IdentPtr, Int32, Int32Ptr,
+          Int32Ptr, Int32Ptr, Int32Ptr)
+__OMP_RTL(__kmpc_dispatch_next_4u, false, Int32, IdentPtr, Int32, Int32Ptr,
+          Int32Ptr, Int32Ptr, Int32Ptr)
+__OMP_RTL(__kmpc_dispatch_next_8, false, Int32, IdentPtr, Int32, Int32Ptr,
+          Int64Ptr, Int64Ptr, Int64Ptr)
+__OMP_RTL(__kmpc_dispatch_next_8u, false, Int32, IdentPtr, Int32, Int32Ptr,
+          Int64Ptr, Int64Ptr, Int64Ptr)
+__OMP_RTL(__kmpc_dispatch_fini_4, false, Void, IdentPtr, Int32)
+__OMP_RTL(__kmpc_dispatch_fini_4u, false, Void, IdentPtr, Int32)
+__OMP_RTL(__kmpc_dispatch_fini_8, false, Void, IdentPtr, Int32)
+__OMP_RTL(__kmpc_dispatch_fini_8u, false, Void, IdentPtr, Int32)
+__OMP_RTL(__kmpc_team_static_init_4, false, Void, IdentPtr, Int32, Int32Ptr,
+          Int32Ptr, Int32Ptr, Int32Ptr, Int32, Int32)
+__OMP_RTL(__kmpc_team_static_init_4u, false, Void, IdentPtr, Int32, Int32Ptr,
+          Int32Ptr, Int32Ptr, Int32Ptr, Int32, Int32)
+__OMP_RTL(__kmpc_team_static_init_8, false, Void, IdentPtr, Int32, Int32Ptr,
+          Int64Ptr, Int64Ptr, Int64Ptr, Int64, Int64)
+__OMP_RTL(__kmpc_team_static_init_8u, false, Void, IdentPtr, Int32, Int32Ptr,
+          Int64Ptr, Int64Ptr, Int64Ptr, Int64, Int64)
+__OMP_RTL(__kmpc_dist_for_static_init_4, false, Void, IdentPtr, Int32, Int32,
+          Int32Ptr, Int32Ptr, Int32Ptr, Int32Ptr, Int32Ptr, Int32, Int32)
+__OMP_RTL(__kmpc_dist_for_static_init_4u, false, Void, IdentPtr, Int32, Int32,
+          Int32Ptr, Int32Ptr, Int32Ptr, Int32Ptr, Int32Ptr, Int32, Int32)
+__OMP_RTL(__kmpc_dist_for_static_init_8, false, Void, IdentPtr, Int32, Int32,
+          Int32Ptr, Int64Ptr, Int64Ptr, Int64Ptr, Int64Ptr, Int64, Int64)
+__OMP_RTL(__kmpc_dist_for_static_init_8u, false, Void, IdentPtr, Int32, Int32,
+          Int32Ptr, Int64Ptr, Int64Ptr, Int64Ptr, Int64Ptr, Int64, Int64)
+
+__OMP_RTL(__kmpc_single, false, Int32, IdentPtr, Int32)
+__OMP_RTL(__kmpc_end_single, false, Void, IdentPtr, Int32)
+
+__OMP_RTL(__kmpc_omp_task_alloc, false, /* kmp_task_t */ VoidPtr, IdentPtr,
+          Int32, Int32, SizeTy, SizeTy, TaskRoutineEntryPtr)
+__OMP_RTL(__kmpc_omp_task, false, Int32, IdentPtr, Int32,
+          /* kmp_task_t */ VoidPtr)
+__OMP_RTL(__kmpc_end_taskgroup, false, Void, IdentPtr, Int32)
+__OMP_RTL(__kmpc_taskgroup, false, Void, IdentPtr, Int32)
+__OMP_RTL(__kmpc_omp_task_begin_if0, false, Void, IdentPtr, Int32,
+          /* kmp_task_t */ VoidPtr)
+__OMP_RTL(__kmpc_omp_task_complete_if0, false, Void, IdentPtr, Int32,
+          /* kmp_tasK_t */ VoidPtr)
+__OMP_RTL(__kmpc_omp_task_with_deps, false, Int32, IdentPtr, Int32,
+          /* kmp_task_t */ VoidPtr, Int32,
+          /* kmp_depend_info_t */ VoidPtr, Int32,
+          /* kmp_depend_info_t */ VoidPtr)
+__OMP_RTL(__kmpc_taskloop, false, Void, IdentPtr, /* Int */ Int32, VoidPtr,
+          /* Int */ Int32, Int64Ptr, Int64Ptr, Int64, /* Int */ Int32,
+          /* Int */ Int32, Int64, VoidPtr)
+__OMP_RTL(__kmpc_omp_target_task_alloc, false, /* kmp_task_t */ VoidPtr,
+          IdentPtr, Int32, Int32, SizeTy, SizeTy, TaskRoutineEntryPtr, Int64)
+__OMP_RTL(__kmpc_taskred_modifier_init, false, /* kmp_taskgroup */ VoidPtr,
+          IdentPtr, /* Int */ Int32, /* Int */ Int32, /* Int */ Int32, VoidPtr)
+__OMP_RTL(__kmpc_taskred_init, false, /* kmp_taskgroup */ VoidPtr,
+          /* Int */ Int32, /* Int */ Int32, VoidPtr)
+__OMP_RTL(__kmpc_task_reduction_modifier_fini, false, Void, IdentPtr,
+          /* Int */ Int32, /* Int */ Int32)
+__OMP_RTL(__kmpc_task_reduction_get_th_data, false, VoidPtr, Int32, VoidPtr,
+          VoidPtr)
+__OMP_RTL(__kmpc_task_reduction_init, false, VoidPtr, Int32, Int32, VoidPtr)
+__OMP_RTL(__kmpc_task_reduction_modifier_init, false, VoidPtr, VoidPtr, Int32,
+          Int32, Int32, VoidPtr)
+__OMP_RTL(__kmpc_proxy_task_completed_ooo, false, Void, VoidPtr)
+
+__OMP_RTL(__kmpc_omp_wait_deps, false, Void, IdentPtr, Int32, Int32,
+          /* kmp_depend_info_t */ VoidPtr, Int32, VoidPtr)
+__OMP_RTL(__kmpc_cancellationpoint, false, Int32, IdentPtr, Int32, Int32)
+
+__OMP_RTL(__kmpc_fork_teams, true, Void, IdentPtr, Int32, ParallelTaskPtr)
+__OMP_RTL(__kmpc_push_num_teams, false, Void, IdentPtr, Int32, Int32, Int32)
+
+__OMP_RTL(__kmpc_copyprivate, false, Void, IdentPtr, Int32, SizeTy, VoidPtr,
+          CopyFunctionPtr, Int32)
+__OMP_RTL(__kmpc_threadprivate_cached, false, VoidPtr, IdentPtr, Int32, VoidPtr,
+          SizeTy, VoidPtrPtrPtr)
+__OMP_RTL(__kmpc_threadprivate_register, false, Void, IdentPtr, VoidPtr,
+          KmpcCtorPtr, KmpcCopyCtorPtr, KmpcDtorPtr)
+
+__OMP_RTL(__kmpc_doacross_init, false, Void, IdentPtr, Int32, Int32,
+          /* kmp_dim */ VoidPtr)
+__OMP_RTL(__kmpc_doacross_post, false, Void, IdentPtr, Int32, Int64Ptr)
+__OMP_RTL(__kmpc_doacross_wait, false, Void, IdentPtr, Int32, Int64Ptr)
+__OMP_RTL(__kmpc_doacross_fini, false, Void, IdentPtr, Int32)
+
+__OMP_RTL(__kmpc_alloc, false, VoidPtr, /* Int */ Int32, SizeTy, VoidPtr)
+__OMP_RTL(__kmpc_free, false, Void, /* Int */ Int32, VoidPtr, VoidPtr)
+
+__OMP_RTL(__kmpc_init_allocator, false, /* omp_allocator_handle_t */ VoidPtr,
+          /* Int */ Int32, /* omp_memespace_handle_t */ VoidPtr,
+          /* Int */ Int32, /* omp_alloctrait_t */ VoidPtr)
+__OMP_RTL(__kmpc_destroy_allocator, false, Void, /* Int */ Int32,
+          /* omp_allocator_handle_t */ VoidPtr)
+
+__OMP_RTL(__kmpc_push_target_tripcount, false, Void, IdentPtr, Int64, Int64)
+__OMP_RTL(__tgt_target_mapper, false, Int32, IdentPtr, Int64, VoidPtr, Int32, VoidPtrPtr,
+          VoidPtrPtr, Int64Ptr, Int64Ptr, VoidPtrPtr, VoidPtrPtr)
+__OMP_RTL(__tgt_target_nowait_mapper, false, Int32, IdentPtr, Int64, VoidPtr, Int32,
+          VoidPtrPtr, VoidPtrPtr, Int64Ptr, Int64Ptr, VoidPtrPtr, VoidPtrPtr)
+__OMP_RTL(__tgt_target_teams_mapper, false, Int32, IdentPtr, Int64, VoidPtr, Int32,
+          VoidPtrPtr, VoidPtrPtr, Int64Ptr, Int64Ptr, VoidPtrPtr, VoidPtrPtr, Int32, Int32)
+__OMP_RTL(__tgt_target_teams_nowait_mapper, false, Int32, IdentPtr, Int64, VoidPtr, Int32,
+          VoidPtrPtr, VoidPtrPtr, Int64Ptr, Int64Ptr, VoidPtrPtr, VoidPtrPtr, Int32, Int32)
+__OMP_RTL(__tgt_register_requires, false, Void, Int64)
+__OMP_RTL(__tgt_target_data_begin_mapper, false, Void, IdentPtr, Int64, Int32, VoidPtrPtr,
+          VoidPtrPtr, Int64Ptr, Int64Ptr, VoidPtrPtr, VoidPtrPtr)
+__OMP_RTL(__tgt_target_data_begin_nowait_mapper, false, Void, IdentPtr, Int64, Int32,
+          VoidPtrPtr, VoidPtrPtr, Int64Ptr, Int64Ptr, VoidPtrPtr, VoidPtrPtr)
+__OMP_RTL(__tgt_target_data_begin_mapper_issue, false, Void, IdentPtr, Int64, Int32,
+          VoidPtrPtr, VoidPtrPtr, Int64Ptr, Int64Ptr, VoidPtrPtr, VoidPtrPtr, AsyncInfoPtr)
+__OMP_RTL(__tgt_target_data_begin_mapper_wait, false, Void, Int64, AsyncInfoPtr)
+__OMP_RTL(__tgt_target_data_end_mapper, false, Void, IdentPtr, Int64, Int32, VoidPtrPtr,
+          VoidPtrPtr, Int64Ptr, Int64Ptr, VoidPtrPtr, VoidPtrPtr)
+__OMP_RTL(__tgt_target_data_end_nowait_mapper, false, Void, IdentPtr, Int64, Int32,
+          VoidPtrPtr, VoidPtrPtr, Int64Ptr, Int64Ptr, VoidPtrPtr, VoidPtrPtr)
+__OMP_RTL(__tgt_target_data_update_mapper, false, Void, IdentPtr, Int64, Int32,
+          VoidPtrPtr, VoidPtrPtr, Int64Ptr, Int64Ptr, VoidPtrPtr, VoidPtrPtr)
+__OMP_RTL(__tgt_target_data_update_nowait_mapper, false, Void, IdentPtr, Int64, Int32,
+          VoidPtrPtr, VoidPtrPtr, Int64Ptr, Int64Ptr, VoidPtrPtr, VoidPtrPtr)
+__OMP_RTL(__tgt_mapper_num_components, false, Int64, VoidPtr)
+__OMP_RTL(__tgt_push_mapper_component, false, Void, VoidPtr, VoidPtr, VoidPtr,
+          Int64, Int64)
+__OMP_RTL(__kmpc_task_allow_completion_event, false, VoidPtr, IdentPtr,
+          /* Int */ Int32, /* kmp_task_t */ VoidPtr)
+
+/// OpenMP Device runtime functions
+__OMP_RTL(__kmpc_kernel_init, false, Void, Int32, Int16)
+__OMP_RTL(__kmpc_kernel_deinit, false, Void, Int16)
+__OMP_RTL(__kmpc_spmd_kernel_init, false, Void, Int32, Int16)
+__OMP_RTL(__kmpc_spmd_kernel_deinit_v2, false, Void, Int16)
+__OMP_RTL(__kmpc_kernel_prepare_parallel, false, Void, VoidPtr)
+__OMP_RTL(__kmpc_kernel_parallel, false, Int1, VoidPtrPtr)
+__OMP_RTL(__kmpc_kernel_end_parallel, false, Void, )
+__OMP_RTL(__kmpc_serialized_parallel, false, Void, IdentPtr, Int32)
+__OMP_RTL(__kmpc_end_serialized_parallel, false, Void, IdentPtr, Int32)
+__OMP_RTL(__kmpc_shuffle_int32, false, Int32, Int32, Int16, Int16)
+__OMP_RTL(__kmpc_nvptx_parallel_reduce_nowait_v2, false, Int32, IdentPtr, Int32,
+          Int32, SizeTy, VoidPtr, ShuffleReducePtr, InterWarpCopyPtr)
+__OMP_RTL(__kmpc_nvptx_end_reduce_nowait, false, Void, Int32)
+__OMP_RTL(__kmpc_nvptx_teams_reduce_nowait_v2, false, Int32, IdentPtr, Int32,
+          VoidPtr, Int32, VoidPtr, ShuffleReducePtr, InterWarpCopyPtr,
+          GlobalListPtr, GlobalListPtr, GlobalListPtr, GlobalListPtr)
+
+__OMP_RTL(__kmpc_shuffle_int64, false, Int64, Int64, Int16, Int16)
+__OMP_RTL(__kmpc_data_sharing_init_stack, false, Void, )
+__OMP_RTL(__kmpc_data_sharing_init_stack_spmd, false, Void, )
+
+__OMP_RTL(__kmpc_data_sharing_coalesced_push_stack, false, VoidPtr, SizeTy, Int16)
+__OMP_RTL(__kmpc_data_sharing_push_stack, false, VoidPtr, SizeTy, Int16)
+__OMP_RTL(__kmpc_data_sharing_pop_stack, false, Void, VoidPtr)
+__OMP_RTL(__kmpc_begin_sharing_variables, false, Void, VoidPtrPtrPtr, SizeTy)
+__OMP_RTL(__kmpc_end_sharing_variables, false, Void, )
+__OMP_RTL(__kmpc_get_shared_variables, false, Void, VoidPtrPtrPtr)
+__OMP_RTL(__kmpc_parallel_level, false, Int16, IdentPtr, Int32)
+__OMP_RTL(__kmpc_is_spmd_exec_mode, false, Int8, )
+__OMP_RTL(__kmpc_get_team_static_memory, false, Void, Int16, VoidPtr, SizeTy,
+          Int16, VoidPtrPtr)
+__OMP_RTL(__kmpc_restore_team_static_memory, false, Void, Int16, Int16)
+__OMP_RTL(__kmpc_barrier_simple_spmd, false, Void, IdentPtr, Int32)
+
+__OMP_RTL(__kmpc_warp_active_thread_mask, false, LanemaskTy,)
+__OMP_RTL(__kmpc_syncwarp, false, Void, LanemaskTy)
+
+__OMP_RTL(__last, false, Void, )
+
+#undef __OMP_RTL
+#undef OMP_RTL
+
+#define ParamAttrs(...) ArrayRef<AttributeSet>({__VA_ARGS__})
+#define EnumAttr(Kind) Attribute::get(Ctx, Attribute::AttrKind::Kind)
+#define EnumAttrInt(Kind, N) Attribute::get(Ctx, Attribute::AttrKind::Kind, N)
+#define AttributeSet(...)                                                      \
+  AttributeSet::get(Ctx, ArrayRef<Attribute>({__VA_ARGS__}))
+
+#ifndef OMP_ATTRS_SET
+#define OMP_ATTRS_SET(VarName, AttrSet)
+#endif
+
+#define __OMP_ATTRS_SET(VarName, AttrSet) OMP_ATTRS_SET(VarName, AttrSet)
+
+__OMP_ATTRS_SET(GetterAttrs,
+                OptimisticAttributes
+                    ? AttributeSet(EnumAttr(NoUnwind), EnumAttr(ReadOnly),
+                                   EnumAttr(NoSync), EnumAttr(NoFree),
+                                   EnumAttr(InaccessibleMemOnly),
+                                   EnumAttr(WillReturn))
+                    : AttributeSet(EnumAttr(NoUnwind)))
+__OMP_ATTRS_SET(GetterArgWriteAttrs,
+                OptimisticAttributes
+                    ? AttributeSet(EnumAttr(NoUnwind), EnumAttr(NoSync),
+                                   EnumAttr(NoFree),
+                                   EnumAttr(InaccessibleMemOrArgMemOnly),
+                                   EnumAttr(WillReturn))
+                    : AttributeSet(EnumAttr(NoUnwind)))
+__OMP_ATTRS_SET(SetterAttrs,
+                OptimisticAttributes
+                    ? AttributeSet(EnumAttr(NoUnwind), EnumAttr(WriteOnly),
+                                   EnumAttr(NoSync), EnumAttr(NoFree),
+                                   EnumAttr(InaccessibleMemOnly),
+                                   EnumAttr(WillReturn))
+                    : AttributeSet(EnumAttr(NoUnwind)))
+
+__OMP_ATTRS_SET(DefaultAttrs,
+                OptimisticAttributes
+                    ? AttributeSet(EnumAttr(NoUnwind), EnumAttr(NoSync),
+                                   EnumAttr(WillReturn), EnumAttr(NoFree))
+                    : AttributeSet(EnumAttr(NoUnwind)))
+
+__OMP_ATTRS_SET(BarrierAttrs,
+                OptimisticAttributes
+                    ? AttributeSet(EnumAttr(NoUnwind), EnumAttr(Convergent))
+                    : AttributeSet(EnumAttr(NoUnwind), EnumAttr(Convergent)))
+
+__OMP_ATTRS_SET(InaccessibleArgOnlyAttrs,
+                OptimisticAttributes
+                    ? AttributeSet(EnumAttr(NoUnwind), EnumAttr(NoSync),
+                                   EnumAttr(InaccessibleMemOrArgMemOnly),
+                                   EnumAttr(WillReturn), EnumAttr(NoFree))
+                    : AttributeSet(EnumAttr(NoUnwind)))
+
+#if 0
+__OMP_ATTRS_SET(InaccessibleOnlyAttrs,
+                OptimisticAttributes
+                    ? AttributeSet(EnumAttr(NoUnwind), EnumAttr(NoSync),
+                                   EnumAttr(InaccessibleMemOnly),
+                                   EnumAttr(WillReturn), EnumAttr(NoFree))
+                    : AttributeSet(EnumAttr(NoUnwind)))
+#endif
+
+__OMP_ATTRS_SET(AllocAttrs,
+                OptimisticAttributes
+                    ? AttributeSet(EnumAttr(NoUnwind), EnumAttr(NoSync),
+                                   EnumAttr(WillReturn))
+                    : AttributeSet(EnumAttr(NoUnwind)))
+
+__OMP_ATTRS_SET(ForkAttrs, OptimisticAttributes
+                               ? AttributeSet(EnumAttr(NoUnwind))
+                               : AttributeSet(EnumAttr(NoUnwind)))
+
+__OMP_ATTRS_SET(ReadOnlyPtrAttrs,
+                OptimisticAttributes
+                    ? AttributeSet(EnumAttr(ReadOnly), EnumAttr(NoFree),
+                                   EnumAttr(NoCapture))
+                    : AttributeSet())
+
+#if 0
+__OMP_ATTRS_SET(WriteOnlyPtrAttrs,
+                OptimisticAttributes
+                    ? AttributeSet(EnumAttr(WriteOnly), EnumAttr(NoFree),
+                                   EnumAttr(NoCapture))
+                    : AttributeSet())
+#endif
+
+__OMP_ATTRS_SET(ArgPtrAttrs,
+                OptimisticAttributes
+                    ? AttributeSet(EnumAttr(NoCapture), EnumAttr(NoFree))
+                    : AttributeSet())
+
+__OMP_ATTRS_SET(ReturnPtrAttrs,
+                OptimisticAttributes
+                    ? AttributeSet(EnumAttr(NoAlias))
+                    : AttributeSet())
+
+#if 0
+__OMP_ATTRS_SET(ReturnAlignedPtrAttrs,
+                OptimisticAttributes
+                    ? AttributeSet(EnumAttr(NoAlias), EnumAttrInt(Alignment, 8),
+                                   EnumAttrInt(DereferenceableOrNull, 8))
+                    : AttributeSet())
+#endif
+
+#undef __OMP_ATTRS_SET
+#undef OMP_ATTRS_SET
+
+#ifndef OMP_RTL_ATTRS
+#define OMP_RTL_ATTRS(Enum, FnAttrSet, RetAttrSet, ArgAttrSets)
+#endif
+
+#define __OMP_RTL_ATTRS(Name, FnAttrSet, RetAttrSet, ArgAttrSets)              \
+  OMP_RTL_ATTRS(OMPRTL_##Name, FnAttrSet, RetAttrSet, ArgAttrSets)
+
+__OMP_RTL_ATTRS(__kmpc_barrier, BarrierAttrs, AttributeSet(),
+                ParamAttrs(ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_barrier_simple_spmd, BarrierAttrs, AttributeSet(),
+                ParamAttrs(ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_warp_active_thread_mask, BarrierAttrs, AttributeSet(),
+                ParamAttrs())
+__OMP_RTL_ATTRS(__kmpc_syncwarp, BarrierAttrs, AttributeSet(), ParamAttrs())
+__OMP_RTL_ATTRS(__kmpc_cancel, InaccessibleArgOnlyAttrs, AttributeSet(),
+                ParamAttrs(ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_cancel_barrier, BarrierAttrs, AttributeSet(),
+                ParamAttrs(ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_flush, BarrierAttrs, AttributeSet(),
+                ParamAttrs(ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_global_thread_num, GetterAttrs, AttributeSet(),
+                ParamAttrs(ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_fork_call, ForkAttrs, AttributeSet(),
+                ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_omp_taskwait, BarrierAttrs, AttributeSet(),
+                ParamAttrs(ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_omp_taskyield, InaccessibleArgOnlyAttrs, AttributeSet(),
+                ParamAttrs(ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_push_num_threads, InaccessibleArgOnlyAttrs,
+                AttributeSet(), ParamAttrs(ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_push_proc_bind, InaccessibleArgOnlyAttrs, AttributeSet(),
+                ParamAttrs(ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_serialized_parallel, InaccessibleArgOnlyAttrs,
+                AttributeSet(), ParamAttrs(ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_end_serialized_parallel, InaccessibleArgOnlyAttrs,
+                AttributeSet(), ParamAttrs(ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_omp_reg_task_with_affinity, DefaultAttrs, AttributeSet(),
+                ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), ReadOnlyPtrAttrs,
+                           AttributeSet(), ReadOnlyPtrAttrs))
+
+__OMP_RTL_ATTRS(omp_get_thread_num, GetterAttrs, AttributeSet(), ParamAttrs())
+__OMP_RTL_ATTRS(omp_get_num_threads, GetterAttrs, AttributeSet(), ParamAttrs())
+__OMP_RTL_ATTRS(omp_get_max_threads, GetterAttrs, AttributeSet(), ParamAttrs())
+__OMP_RTL_ATTRS(omp_in_parallel, GetterAttrs, AttributeSet(), ParamAttrs())
+__OMP_RTL_ATTRS(omp_get_dynamic, GetterAttrs, AttributeSet(), ParamAttrs())
+__OMP_RTL_ATTRS(omp_get_cancellation, GetterAttrs, AttributeSet(), ParamAttrs())
+__OMP_RTL_ATTRS(omp_get_nested, GetterAttrs, AttributeSet(), ParamAttrs())
+__OMP_RTL_ATTRS(
+    omp_get_schedule, GetterArgWriteAttrs, AttributeSet(),
+    ParamAttrs(AttributeSet(EnumAttr(NoCapture), EnumAttr(WriteOnly)),
+               AttributeSet(EnumAttr(NoCapture), EnumAttr(WriteOnly))))
+__OMP_RTL_ATTRS(omp_get_thread_limit, GetterAttrs, AttributeSet(), ParamAttrs())
+__OMP_RTL_ATTRS(omp_get_supported_active_levels, GetterAttrs, AttributeSet(),
+                ParamAttrs())
+__OMP_RTL_ATTRS(omp_get_max_active_levels, GetterAttrs, AttributeSet(),
+                ParamAttrs())
+__OMP_RTL_ATTRS(omp_get_level, GetterAttrs, AttributeSet(), ParamAttrs())
+__OMP_RTL_ATTRS(omp_get_ancestor_thread_num, GetterAttrs, AttributeSet(),
+                ParamAttrs())
+__OMP_RTL_ATTRS(omp_get_team_size, GetterAttrs, AttributeSet(), ParamAttrs())
+__OMP_RTL_ATTRS(omp_get_active_level, GetterAttrs, AttributeSet(), ParamAttrs())
+__OMP_RTL_ATTRS(omp_in_final, GetterAttrs, AttributeSet(), ParamAttrs())
+__OMP_RTL_ATTRS(omp_get_proc_bind, GetterAttrs, AttributeSet(), ParamAttrs())
+__OMP_RTL_ATTRS(omp_get_num_places, GetterAttrs, AttributeSet(), ParamAttrs())
+__OMP_RTL_ATTRS(omp_get_num_procs, GetterAttrs, AttributeSet(), ParamAttrs())
+__OMP_RTL_ATTRS(omp_get_place_proc_ids, GetterArgWriteAttrs, AttributeSet(),
+                ParamAttrs(AttributeSet(), AttributeSet(EnumAttr(NoCapture),
+                                                        EnumAttr(WriteOnly))))
+__OMP_RTL_ATTRS(omp_get_place_num, GetterAttrs, AttributeSet(), ParamAttrs())
+__OMP_RTL_ATTRS(omp_get_partition_num_places, GetterAttrs, AttributeSet(),
+                ParamAttrs())
+__OMP_RTL_ATTRS(omp_get_partition_place_nums, GetterAttrs, AttributeSet(),
+                ParamAttrs())
+
+__OMP_RTL_ATTRS(omp_set_num_threads, SetterAttrs, AttributeSet(), ParamAttrs())
+__OMP_RTL_ATTRS(omp_set_dynamic, SetterAttrs, AttributeSet(), ParamAttrs())
+__OMP_RTL_ATTRS(omp_set_nested, SetterAttrs, AttributeSet(), ParamAttrs())
+__OMP_RTL_ATTRS(omp_set_schedule, SetterAttrs, AttributeSet(), ParamAttrs())
+__OMP_RTL_ATTRS(omp_set_max_active_levels, SetterAttrs, AttributeSet(),
+                ParamAttrs())
+
+__OMP_RTL_ATTRS(__kmpc_master, InaccessibleArgOnlyAttrs, AttributeSet(),
+                ParamAttrs(ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_end_master, InaccessibleArgOnlyAttrs, AttributeSet(),
+                ParamAttrs(ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_critical, BarrierAttrs, AttributeSet(),
+                ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet()))
+__OMP_RTL_ATTRS(__kmpc_critical_with_hint, BarrierAttrs, AttributeSet(),
+                ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet(),
+                           AttributeSet()))
+__OMP_RTL_ATTRS(__kmpc_end_critical, BarrierAttrs, AttributeSet(),
+                ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet()))
+
+__OMP_RTL_ATTRS(__kmpc_begin, DefaultAttrs, AttributeSet(),
+                ParamAttrs(ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_end, DefaultAttrs, AttributeSet(),
+                ParamAttrs(ReadOnlyPtrAttrs))
+
+__OMP_RTL_ATTRS(__kmpc_reduce, BarrierAttrs, AttributeSet(),
+                ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet(),
+                           AttributeSet(), ReadOnlyPtrAttrs, AttributeSet()))
+__OMP_RTL_ATTRS(__kmpc_reduce_nowait, BarrierAttrs, AttributeSet(),
+                ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet(),
+                           AttributeSet(), ReadOnlyPtrAttrs, AttributeSet()))
+__OMP_RTL_ATTRS(__kmpc_end_reduce, BarrierAttrs, AttributeSet(),
+                ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet()))
+__OMP_RTL_ATTRS(__kmpc_end_reduce_nowait, BarrierAttrs, AttributeSet(),
+                ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet()))
+
+__OMP_RTL_ATTRS(__kmpc_ordered, BarrierAttrs, AttributeSet(),
+                ParamAttrs(ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_end_ordered, BarrierAttrs, AttributeSet(),
+                ParamAttrs(ReadOnlyPtrAttrs))
+
+__OMP_RTL_ATTRS(__kmpc_for_static_init_4, GetterArgWriteAttrs, AttributeSet(),
+                ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet(),
+                           ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs,
+                           AttributeSet(), AttributeSet()))
+__OMP_RTL_ATTRS(__kmpc_for_static_init_4u, GetterArgWriteAttrs, AttributeSet(),
+                ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet(),
+                           ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs,
+                           AttributeSet(), AttributeSet()))
+__OMP_RTL_ATTRS(__kmpc_for_static_init_8, GetterArgWriteAttrs, AttributeSet(),
+                ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet(),
+                           ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs,
+                           AttributeSet(), AttributeSet()))
+__OMP_RTL_ATTRS(__kmpc_for_static_init_8u, GetterArgWriteAttrs, AttributeSet(),
+                ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet(),
+                           ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs,
+                           AttributeSet(), AttributeSet()))
+__OMP_RTL_ATTRS(__kmpc_for_static_fini, InaccessibleArgOnlyAttrs,
+                AttributeSet(), ParamAttrs(ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_dist_dispatch_init_4, GetterArgWriteAttrs,
+                AttributeSet(),
+                ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet(),
+                           ArgPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_dist_dispatch_init_4u, GetterArgWriteAttrs,
+                AttributeSet(),
+                ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet(),
+                           ArgPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_dist_dispatch_init_8, GetterArgWriteAttrs,
+                AttributeSet(),
+                ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet(),
+                           ArgPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_dist_dispatch_init_8u, GetterArgWriteAttrs,
+                AttributeSet(),
+                ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet(),
+                           ArgPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_dispatch_init_4, GetterArgWriteAttrs, AttributeSet(),
+                ParamAttrs(ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_dispatch_init_4u, GetterArgWriteAttrs, AttributeSet(),
+                ParamAttrs(ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_dispatch_init_8, GetterArgWriteAttrs, AttributeSet(),
+                ParamAttrs(ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_dispatch_init_8u, GetterArgWriteAttrs, AttributeSet(),
+                ParamAttrs(ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_dispatch_next_4, GetterArgWriteAttrs, AttributeSet(),
+                ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), ArgPtrAttrs,
+                           ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_dispatch_next_4u, GetterArgWriteAttrs, AttributeSet(),
+                ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), ArgPtrAttrs,
+                           ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_dispatch_next_8, GetterArgWriteAttrs, AttributeSet(),
+                ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), ArgPtrAttrs,
+                           ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_dispatch_next_8u, GetterArgWriteAttrs, AttributeSet(),
+                ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), ArgPtrAttrs,
+                           ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_dispatch_fini_4, InaccessibleArgOnlyAttrs,
+                AttributeSet(), ParamAttrs(ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_dispatch_fini_4u, InaccessibleArgOnlyAttrs,
+                AttributeSet(), ParamAttrs(ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_dispatch_fini_8, InaccessibleArgOnlyAttrs,
+                AttributeSet(), ParamAttrs(ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_dispatch_fini_8u, InaccessibleArgOnlyAttrs,
+                AttributeSet(), ParamAttrs(ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_team_static_init_4, GetterArgWriteAttrs, AttributeSet(),
+                ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), ArgPtrAttrs,
+                           ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_team_static_init_4u, GetterArgWriteAttrs, AttributeSet(),
+                ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), ArgPtrAttrs,
+                           ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_team_static_init_8, GetterArgWriteAttrs, AttributeSet(),
+                ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), ArgPtrAttrs,
+                           ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_team_static_init_8u, GetterArgWriteAttrs, AttributeSet(),
+                ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), ArgPtrAttrs,
+                           ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_dist_for_static_init_4, GetterArgWriteAttrs,
+                AttributeSet(),
+                ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet(),
+                           ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs,
+                           ArgPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_dist_for_static_init_4u, GetterArgWriteAttrs,
+                AttributeSet(),
+                ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet(),
+                           ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs,
+                           ArgPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_dist_for_static_init_8, GetterArgWriteAttrs,
+                AttributeSet(),
+                ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet(),
+                           ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs,
+                           ArgPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_dist_for_static_init_8u, GetterArgWriteAttrs,
+                AttributeSet(),
+                ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet(),
+                           ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs,
+                           ArgPtrAttrs))
+
+__OMP_RTL_ATTRS(__kmpc_single, BarrierAttrs, AttributeSet(),
+                ParamAttrs(ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_end_single, BarrierAttrs, AttributeSet(),
+                ParamAttrs(ReadOnlyPtrAttrs))
+
+__OMP_RTL_ATTRS(__kmpc_omp_task_alloc, DefaultAttrs, ReturnPtrAttrs,
+                ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet(),
+                           AttributeSet(), AttributeSet(), ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_omp_task, DefaultAttrs, AttributeSet(),
+                ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet()))
+__OMP_RTL_ATTRS(__kmpc_end_taskgroup, BarrierAttrs, AttributeSet(),
+                ParamAttrs(ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_taskgroup, BarrierAttrs, AttributeSet(),
+                ParamAttrs(ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_omp_task_begin_if0, DefaultAttrs, AttributeSet(),
+                ParamAttrs(ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_omp_task_complete_if0, DefaultAttrs, AttributeSet(),
+                ParamAttrs(ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_omp_task_with_deps, DefaultAttrs, AttributeSet(),
+                ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet(),
+                           AttributeSet(), ReadOnlyPtrAttrs, AttributeSet(),
+                           ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_taskloop, DefaultAttrs, AttributeSet(),
+                ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet(),
+                           AttributeSet(), ArgPtrAttrs, ArgPtrAttrs,
+                           AttributeSet(), AttributeSet(), AttributeSet(),
+                           AttributeSet(), AttributeSet()))
+__OMP_RTL_ATTRS(__kmpc_omp_target_task_alloc, DefaultAttrs, ReturnPtrAttrs,
+                ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet(),
+                           AttributeSet(), AttributeSet(), ReadOnlyPtrAttrs,
+                           AttributeSet()))
+__OMP_RTL_ATTRS(__kmpc_taskred_modifier_init, DefaultAttrs, ReturnPtrAttrs,
+                ParamAttrs(ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_taskred_init, DefaultAttrs, AttributeSet(), ParamAttrs())
+__OMP_RTL_ATTRS(__kmpc_task_reduction_modifier_fini, BarrierAttrs,
+                AttributeSet(), ParamAttrs(ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_task_reduction_get_th_data, DefaultAttrs, ReturnPtrAttrs,
+                ParamAttrs())
+__OMP_RTL_ATTRS(__kmpc_task_reduction_init, DefaultAttrs, ReturnPtrAttrs,
+                ParamAttrs())
+__OMP_RTL_ATTRS(__kmpc_task_reduction_modifier_init, DefaultAttrs,
+                ReturnPtrAttrs, ParamAttrs())
+__OMP_RTL_ATTRS(__kmpc_proxy_task_completed_ooo, DefaultAttrs, AttributeSet(),
+                ParamAttrs())
+
+__OMP_RTL_ATTRS(__kmpc_omp_wait_deps, BarrierAttrs, AttributeSet(),
+                ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet(),
+                           ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_cancellationpoint, DefaultAttrs, AttributeSet(),
+                ParamAttrs(ReadOnlyPtrAttrs))
+
+__OMP_RTL_ATTRS(__kmpc_fork_teams, ForkAttrs, AttributeSet(),
+                ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_push_num_teams, InaccessibleArgOnlyAttrs, AttributeSet(),
+                ParamAttrs(ReadOnlyPtrAttrs))
+
+__OMP_RTL_ATTRS(__kmpc_copyprivate, DefaultAttrs, AttributeSet(),
+                ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet(),
+                           ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_threadprivate_cached, DefaultAttrs, ReturnPtrAttrs,
+                ParamAttrs(ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_threadprivate_register, DefaultAttrs, AttributeSet(),
+                ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), ReadOnlyPtrAttrs,
+                           ReadOnlyPtrAttrs, ReadOnlyPtrAttrs))
+
+__OMP_RTL_ATTRS(__kmpc_doacross_init, BarrierAttrs, AttributeSet(),
+                ParamAttrs(ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_doacross_post, BarrierAttrs, AttributeSet(),
+                ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_doacross_wait, BarrierAttrs, AttributeSet(),
+                ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_doacross_fini, BarrierAttrs, AttributeSet(),
+                ParamAttrs(ReadOnlyPtrAttrs))
+
+__OMP_RTL_ATTRS(__kmpc_alloc, DefaultAttrs, ReturnPtrAttrs, {})
+__OMP_RTL_ATTRS(__kmpc_free, AllocAttrs, AttributeSet(), {})
+
+__OMP_RTL_ATTRS(__kmpc_init_allocator, DefaultAttrs, ReturnPtrAttrs, {})
+__OMP_RTL_ATTRS(__kmpc_destroy_allocator, AllocAttrs, AttributeSet(), {})
+
+__OMP_RTL_ATTRS(__kmpc_push_target_tripcount, SetterAttrs, AttributeSet(), {})
+__OMP_RTL_ATTRS(__tgt_target_mapper, ForkAttrs, AttributeSet(), {})
+__OMP_RTL_ATTRS(__tgt_target_nowait_mapper, ForkAttrs, AttributeSet(), {})
+__OMP_RTL_ATTRS(__tgt_target_teams_mapper, ForkAttrs, AttributeSet(), {})
+__OMP_RTL_ATTRS(__tgt_target_teams_nowait_mapper, ForkAttrs, AttributeSet(), {})
+__OMP_RTL_ATTRS(__tgt_register_requires, ForkAttrs, AttributeSet(), {})
+__OMP_RTL_ATTRS(__tgt_target_data_begin_mapper, ForkAttrs, AttributeSet(), {})
+__OMP_RTL_ATTRS(__tgt_target_data_begin_nowait_mapper, ForkAttrs,
+        AttributeSet(), {})
+__OMP_RTL_ATTRS(__tgt_target_data_end_mapper, ForkAttrs, AttributeSet(), {})
+__OMP_RTL_ATTRS(__tgt_target_data_end_nowait_mapper, ForkAttrs,
+        AttributeSet(), {})
+__OMP_RTL_ATTRS(__tgt_target_data_update_mapper, ForkAttrs, AttributeSet(), {})
+__OMP_RTL_ATTRS(__tgt_target_data_update_nowait_mapper, ForkAttrs,
+        AttributeSet(), {})
+__OMP_RTL_ATTRS(__tgt_mapper_num_components, ForkAttrs, AttributeSet(), {})
+__OMP_RTL_ATTRS(__tgt_push_mapper_component, ForkAttrs, AttributeSet(), {})
+__OMP_RTL_ATTRS(__kmpc_task_allow_completion_event, DefaultAttrs,
+                ReturnPtrAttrs, ParamAttrs(ReadOnlyPtrAttrs))
+
+#undef __OMP_RTL_ATTRS
+#undef OMP_RTL_ATTRS
+#undef AttributeSet
+#undef EnumAttr
+#undef EnumAttrInt
+#undef ParamAttrs
+
+///}
+
+/// KMP ident_t bit flags
+///
+/// In accordance with the values in `openmp/runtime/src/kmp.h`.
+///
+///{
+
+#ifndef OMP_IDENT_FLAG
+#define OMP_IDENT_FLAG(Enum, Str, Value)
+#endif
+
+#define __OMP_IDENT_FLAG(Name, Value)                                          \
+  OMP_IDENT_FLAG(OMP_IDENT_FLAG_##Name, #Name, Value)
+
+__OMP_IDENT_FLAG(KMPC, 0x02)
+__OMP_IDENT_FLAG(BARRIER_EXPL, 0x20)
+__OMP_IDENT_FLAG(BARRIER_IMPL, 0x0040)
+__OMP_IDENT_FLAG(BARRIER_IMPL_MASK, 0x01C0)
+__OMP_IDENT_FLAG(BARRIER_IMPL_FOR, 0x0040)
+__OMP_IDENT_FLAG(BARRIER_IMPL_SECTIONS, 0x00C0)
+__OMP_IDENT_FLAG(BARRIER_IMPL_SINGLE, 0x0140)
+__OMP_IDENT_FLAG(BARRIER_IMPL_WORKSHARE, 0x01C0)
+
+#undef __OMP_IDENT_FLAG
+#undef OMP_IDENT_FLAG
+
+///}
+
+/// KMP cancel kind
+///
+///{
+
+#ifndef OMP_CANCEL_KIND
+#define OMP_CANCEL_KIND(Enum, Str, DirectiveEnum, Value)
+#endif
+
+#define __OMP_CANCEL_KIND(Name, Value)                                         \
+  OMP_CANCEL_KIND(OMP_CANCEL_KIND_##Name, #Name, OMPD_##Name, Value)
+
+__OMP_CANCEL_KIND(parallel, 1)
+__OMP_CANCEL_KIND(for, 2)
+__OMP_CANCEL_KIND(sections, 3)
+__OMP_CANCEL_KIND(taskgroup, 4)
+
+#undef __OMP_CANCEL_KIND
+#undef OMP_CANCEL_KIND
+
+///}
+
+/// Default kinds
+///
+///{
+
+#ifndef OMP_DEFAULT_KIND
+#define OMP_DEFAULT_KIND(Enum, Str)
+#endif
+
+#define __OMP_DEFAULT_KIND(Name) OMP_DEFAULT_KIND(OMP_DEFAULT_##Name, #Name)
+
+__OMP_DEFAULT_KIND(none)
+__OMP_DEFAULT_KIND(shared)
+__OMP_DEFAULT_KIND(firstprivate)
+__OMP_DEFAULT_KIND(unknown)
+
+#undef __OMP_DEFAULT_KIND
+#undef OMP_DEFAULT_KIND
+
+///}
+
+/// Proc bind kinds
+///
+///{
+
+#ifndef OMP_PROC_BIND_KIND
+#define OMP_PROC_BIND_KIND(Enum, Str, Value)
+#endif
+
+#define __OMP_PROC_BIND_KIND(Name, Value)                                      \
+  OMP_PROC_BIND_KIND(OMP_PROC_BIND_##Name, #Name, Value)
+
+__OMP_PROC_BIND_KIND(master, 2)
+__OMP_PROC_BIND_KIND(close, 3)
+__OMP_PROC_BIND_KIND(spread, 4)
+__OMP_PROC_BIND_KIND(default, 6)
+__OMP_PROC_BIND_KIND(unknown, 7)
+
+#undef __OMP_PROC_BIND_KIND
+#undef OMP_PROC_BIND_KIND
+
+///}
+
+/// OpenMP context related definitions:
+///  - trait set selector
+///  - trait selector
+///  - trait property
+///
+///{
+
+#ifndef OMP_TRAIT_SET
+#define OMP_TRAIT_SET(Enum, Str)
+#endif
+#ifndef OMP_TRAIT_SELECTOR
+#define OMP_TRAIT_SELECTOR(Enum, TraitSetEnum, Str, RequiresProperty)
+#endif
+#ifndef OMP_TRAIT_PROPERTY
+#define OMP_TRAIT_PROPERTY(Enum, TraitSetEnum, TraitSelectorEnum, Str)
+#endif
+#ifndef OMP_LAST_TRAIT_PROPERTY
+#define OMP_LAST_TRAIT_PROPERTY(Enum)
+#endif
+
+#define __OMP_TRAIT_SET(Name) OMP_TRAIT_SET(Name, #Name)
+#define __OMP_TRAIT_SELECTOR(TraitSet, Name, RequiresProperty)                 \
+  OMP_TRAIT_SELECTOR(TraitSet##_##Name, TraitSet, #Name, RequiresProperty)
+#define __OMP_TRAIT_SELECTOR_AND_PROPERTY(TraitSet, Name)                      \
+  OMP_TRAIT_SELECTOR(TraitSet##_##Name, TraitSet, #Name, false)                \
+  OMP_TRAIT_PROPERTY(TraitSet##_##Name##_##Name, TraitSet, TraitSet##_##Name,  \
+                     #Name)
+#define __OMP_TRAIT_PROPERTY(TraitSet, TraitSelector, Name)                    \
+  OMP_TRAIT_PROPERTY(TraitSet##_##TraitSelector##_##Name, TraitSet,            \
+                     TraitSet##_##TraitSelector, #Name)
+
+// "invalid" must go first.
+OMP_TRAIT_SET(invalid, "invalid")
+OMP_TRAIT_SELECTOR(invalid, invalid, "invalid", false)
+OMP_TRAIT_PROPERTY(invalid, invalid, invalid, "invalid")
+
+__OMP_TRAIT_SET(construct)
+__OMP_TRAIT_SELECTOR_AND_PROPERTY(construct, target)
+__OMP_TRAIT_SELECTOR_AND_PROPERTY(construct, teams)
+__OMP_TRAIT_SELECTOR_AND_PROPERTY(construct, parallel)
+__OMP_TRAIT_SELECTOR_AND_PROPERTY(construct, for)
+__OMP_TRAIT_SELECTOR_AND_PROPERTY(construct, simd)
+
+__OMP_TRAIT_SET(device)
+
+__OMP_TRAIT_SELECTOR(device, kind, true)
+
+__OMP_TRAIT_PROPERTY(device, kind, host)
+__OMP_TRAIT_PROPERTY(device, kind, nohost)
+__OMP_TRAIT_PROPERTY(device, kind, cpu)
+__OMP_TRAIT_PROPERTY(device, kind, gpu)
+__OMP_TRAIT_PROPERTY(device, kind, fpga)
+__OMP_TRAIT_PROPERTY(device, kind, any)
+
+__OMP_TRAIT_SELECTOR(device, arch, true)
+
+__OMP_TRAIT_PROPERTY(device, arch, arm)
+__OMP_TRAIT_PROPERTY(device, arch, armeb)
+__OMP_TRAIT_PROPERTY(device, arch, aarch64)
+__OMP_TRAIT_PROPERTY(device, arch, aarch64_be)
+__OMP_TRAIT_PROPERTY(device, arch, aarch64_32)
+__OMP_TRAIT_PROPERTY(device, arch, ppc)
+__OMP_TRAIT_PROPERTY(device, arch, ppcle)
+__OMP_TRAIT_PROPERTY(device, arch, ppc64)
+__OMP_TRAIT_PROPERTY(device, arch, ppc64le)
+__OMP_TRAIT_PROPERTY(device, arch, x86)
+__OMP_TRAIT_PROPERTY(device, arch, x86_64)
+__OMP_TRAIT_PROPERTY(device, arch, amdgcn)
+__OMP_TRAIT_PROPERTY(device, arch, nvptx)
+__OMP_TRAIT_PROPERTY(device, arch, nvptx64)
+
+__OMP_TRAIT_SET(implementation)
+
+__OMP_TRAIT_SELECTOR(implementation, vendor, true)
+
+__OMP_TRAIT_PROPERTY(implementation, vendor, amd)
+__OMP_TRAIT_PROPERTY(implementation, vendor, arm)
+__OMP_TRAIT_PROPERTY(implementation, vendor, bsc)
+__OMP_TRAIT_PROPERTY(implementation, vendor, cray)
+__OMP_TRAIT_PROPERTY(implementation, vendor, fujitsu)
+__OMP_TRAIT_PROPERTY(implementation, vendor, gnu)
+__OMP_TRAIT_PROPERTY(implementation, vendor, ibm)
+__OMP_TRAIT_PROPERTY(implementation, vendor, intel)
+__OMP_TRAIT_PROPERTY(implementation, vendor, llvm)
+__OMP_TRAIT_PROPERTY(implementation, vendor, pgi)
+__OMP_TRAIT_PROPERTY(implementation, vendor, ti)
+__OMP_TRAIT_PROPERTY(implementation, vendor, unknown)
+
+__OMP_TRAIT_SELECTOR(implementation, extension, true)
+__OMP_TRAIT_PROPERTY(implementation, extension, match_all)
+__OMP_TRAIT_PROPERTY(implementation, extension, match_any)
+__OMP_TRAIT_PROPERTY(implementation, extension, match_none)
+__OMP_TRAIT_PROPERTY(implementation, extension, disable_implicit_base)
+__OMP_TRAIT_PROPERTY(implementation, extension, allow_templates)
+
+__OMP_TRAIT_SET(user)
+
+__OMP_TRAIT_SELECTOR(user, condition, true)
+
+__OMP_TRAIT_PROPERTY(user, condition, true)
+__OMP_TRAIT_PROPERTY(user, condition, false)
+__OMP_TRAIT_PROPERTY(user, condition, unknown)
+
+
+// Note that we put isa last so that the other conditions are checked first.
+// This allows us to issue warnings wrt. isa only if we match otherwise.
+__OMP_TRAIT_SELECTOR(device, isa, true)
+
+// We use "__ANY" as a placeholder in the isa property to denote the
+// conceptual "any", not the literal `any` used in kind. The string we
+// we use is not important except that it will show up in diagnostics.
+OMP_TRAIT_PROPERTY(device_isa___ANY, device, device_isa,
+                   "<any, entirely target dependent>")
+
+
+#undef OMP_TRAIT_SET
+#undef __OMP_TRAIT_SET
+///}
+
+/// Traits for the requires directive
+///
+/// These will (potentially) become trait selectors for the OpenMP context if
+/// the OMP_REQUIRES_TRAIT macro is not defined.
+///
+///{
+
+#ifdef OMP_REQUIRES_TRAIT
+#define __OMP_REQUIRES_TRAIT(Name)                                             \
+  OMP_REQUIRES_TRAIT(OMP_REQUIRES_TRAIT_##Name, #Name)
+#else
+#define __OMP_REQUIRES_TRAIT(Name)                                             \
+  __OMP_TRAIT_SELECTOR_AND_PROPERTY(implementation, Name)
+#endif
+
+__OMP_REQUIRES_TRAIT(unified_address)
+__OMP_REQUIRES_TRAIT(unified_shared_memory)
+__OMP_REQUIRES_TRAIT(reverse_offload)
+__OMP_REQUIRES_TRAIT(dynamic_allocators)
+__OMP_REQUIRES_TRAIT(atomic_default_mem_order)
+
+OMP_LAST_TRAIT_PROPERTY(
+    implementation_atomic_default_mem_order_atomic_default_mem_order)
+
+#undef __OMP_TRAIT_SELECTOR_AND_PROPERTY
+#undef OMP_TRAIT_SELECTOR
+#undef __OMP_TRAIT_SELECTOR
+#undef OMP_TRAIT_PROPERTY
+#undef OMP_LAST_TRAIT_PROPERTY
+#undef __OMP_TRAIT_PROPERTY
+#undef __OMP_REQUIRES_TRAIT
+#undef OMP_REQUIRES_TRAIT
+///}
+
+
+/// Assumption clauses
+///
+///{
+
+#ifdef OMP_ASSUME_CLAUSE
+#define __OMP_ASSUME_CLAUSE(Identifier, StartsWith, HasDirectiveList, HasExpression) \
+OMP_ASSUME_CLAUSE(Identifier, StartsWith, HasDirectiveList, HasExpression)
+#else
+#define __OMP_ASSUME_CLAUSE(...)
+#endif
+
+__OMP_ASSUME_CLAUSE(llvm::StringLiteral("ext_"), true, false, false)
+__OMP_ASSUME_CLAUSE(llvm::StringLiteral("absent"), false, true, false)
+__OMP_ASSUME_CLAUSE(llvm::StringLiteral("contains"), false, true, false)
+__OMP_ASSUME_CLAUSE(llvm::StringLiteral("holds"), false, false, true)
+__OMP_ASSUME_CLAUSE(llvm::StringLiteral("no_openmp"), false, false, false)
+__OMP_ASSUME_CLAUSE(llvm::StringLiteral("no_openmp_routines"), false, false, false)
+__OMP_ASSUME_CLAUSE(llvm::StringLiteral("no_parallelism"), false, false, false)
+
+#undef __OMP_ASSUME_CLAUSE
+#undef OMP_ASSUME_CLAUSE
+///}
diff --git a/linux-x64/clang/include/llvm/FuzzMutate/FuzzerCLI.h b/linux-x64/clang/include/llvm/FuzzMutate/FuzzerCLI.h
index 2a16e43..27eec05 100644
--- a/linux-x64/clang/include/llvm/FuzzMutate/FuzzerCLI.h
+++ b/linux-x64/clang/include/llvm/FuzzMutate/FuzzerCLI.h
@@ -14,12 +14,13 @@
 #ifndef LLVM_FUZZMUTATE_FUZZER_CLI_H
 #define LLVM_FUZZMUTATE_FUZZER_CLI_H
 
-#include "llvm/ADT/StringRef.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/Support/DataTypes.h"
 
 namespace llvm {
 
+class StringRef;
+
 /// Parse cl::opts from a fuzz target commandline.
 ///
 /// This handles all arguments after -ignore_remaining_args=1 as cl::opts.
diff --git a/linux-x64/clang/include/llvm/FuzzMutate/Random.h b/linux-x64/clang/include/llvm/FuzzMutate/Random.h
index 615b15f..9d3af3a 100644
--- a/linux-x64/clang/include/llvm/FuzzMutate/Random.h
+++ b/linux-x64/clang/include/llvm/FuzzMutate/Random.h
@@ -32,7 +32,7 @@
 /// elements, which may each be weighted to be more likely choices.
 template <typename T, typename GenT> class ReservoirSampler {
   GenT &RandGen;
-  typename std::remove_const<T>::type Selection = {};
+  std::remove_const_t<T> Selection = {};
   uint64_t TotalWeight = 0;
 
 public:
@@ -70,8 +70,8 @@
 };
 
 template <typename GenT, typename RangeT,
-          typename ElT = typename std::remove_reference<
-              decltype(*std::begin(std::declval<RangeT>()))>::type>
+          typename ElT = std::remove_reference_t<
+              decltype(*std::begin(std::declval<RangeT>()))>>
 ReservoirSampler<ElT, GenT> makeSampler(GenT &RandGen, RangeT &&Items) {
   ReservoirSampler<ElT, GenT> RS(RandGen);
   RS.sample(Items);
diff --git a/linux-x64/clang/include/llvm/IR/AbstractCallSite.h b/linux-x64/clang/include/llvm/IR/AbstractCallSite.h
new file mode 100644
index 0000000..e8cf050
--- /dev/null
+++ b/linux-x64/clang/include/llvm/IR/AbstractCallSite.h
@@ -0,0 +1,247 @@
+//===- AbstractCallSite.h - Abstract call sites -----------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the AbstractCallSite class, which is a is a wrapper that
+// allows treating direct, indirect, and callback calls the same.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_IR_ABSTRACTCALLSITE_H
+#define LLVM_IR_ABSTRACTCALLSITE_H
+
+#include "llvm/IR/Function.h"
+#include "llvm/IR/InstrTypes.h"
+#include "llvm/IR/Instruction.h"
+#include "llvm/IR/Use.h"
+#include "llvm/IR/User.h"
+#include "llvm/IR/Value.h"
+#include "llvm/Support/Casting.h"
+#include <cassert>
+
+namespace llvm {
+
+/// AbstractCallSite
+///
+/// An abstract call site is a wrapper that allows to treat direct,
+/// indirect, and callback calls the same. If an abstract call site
+/// represents a direct or indirect call site it behaves like a stripped
+/// down version of a normal call site object. The abstract call site can
+/// also represent a callback call, thus the fact that the initially
+/// called function (=broker) may invoke a third one (=callback callee).
+/// In this case, the abstract call site hides the middle man, hence the
+/// broker function. The result is a representation of the callback call,
+/// inside the broker, but in the context of the original call to the broker.
+///
+/// There are up to three functions involved when we talk about callback call
+/// sites. The caller (1), which invokes the broker function. The broker
+/// function (2), that will invoke the callee zero or more times. And finally
+/// the callee (3), which is the target of the callback call.
+///
+/// The abstract call site will handle the mapping from parameters to arguments
+/// depending on the semantic of the broker function. However, it is important
+/// to note that the mapping is often partial. Thus, some arguments of the
+/// call/invoke instruction are mapped to parameters of the callee while others
+/// are not.
+class AbstractCallSite {
+public:
+
+  /// The encoding of a callback with regards to the underlying instruction.
+  struct CallbackInfo {
+
+    /// For direct/indirect calls the parameter encoding is empty. If it is not,
+    /// the abstract call site represents a callback. In that case, the first
+    /// element of the encoding vector represents which argument of the call
+    /// site CB is the callback callee. The remaining elements map parameters
+    /// (identified by their position) to the arguments that will be passed
+    /// through (also identified by position but in the call site instruction).
+    ///
+    /// NOTE that we use LLVM argument numbers (starting at 0) and not
+    /// clang/source argument numbers (starting at 1). The -1 entries represent
+    /// unknown values that are passed to the callee.
+    using ParameterEncodingTy = SmallVector<int, 0>;
+    ParameterEncodingTy ParameterEncoding;
+
+  };
+
+private:
+
+  /// The underlying call site:
+  ///   caller -> callee,             if this is a direct or indirect call site
+  ///   caller -> broker function,    if this is a callback call site
+  CallBase *CB;
+
+  /// The encoding of a callback with regards to the underlying instruction.
+  CallbackInfo CI;
+
+public:
+  /// Sole constructor for abstract call sites (ACS).
+  ///
+  /// An abstract call site can only be constructed through a llvm::Use because
+  /// each operand (=use) of an instruction could potentially be a different
+  /// abstract call site. Furthermore, even if the value of the llvm::Use is the
+  /// same, and the user is as well, the abstract call sites might not be.
+  ///
+  /// If a use is not associated with an abstract call site the constructed ACS
+  /// will evaluate to false if converted to a boolean.
+  ///
+  /// If the use is the callee use of a call or invoke instruction, the
+  /// constructed abstract call site will behave as a llvm::CallSite would.
+  ///
+  /// If the use is not a callee use of a call or invoke instruction, the
+  /// callback metadata is used to determine the argument <-> parameter mapping
+  /// as well as the callee of the abstract call site.
+  AbstractCallSite(const Use *U);
+
+  /// Add operand uses of \p CB that represent callback uses into
+  /// \p CallbackUses.
+  ///
+  /// All uses added to \p CallbackUses can be used to create abstract call
+  /// sites for which AbstractCallSite::isCallbackCall() will return true.
+  static void getCallbackUses(const CallBase &CB,
+                              SmallVectorImpl<const Use *> &CallbackUses);
+
+  /// Conversion operator to conveniently check for a valid/initialized ACS.
+  explicit operator bool() const { return CB != nullptr; }
+
+  /// Return the underlying instruction.
+  CallBase *getInstruction() const { return CB; }
+
+  /// Return true if this ACS represents a direct call.
+  bool isDirectCall() const {
+    return !isCallbackCall() && !CB->isIndirectCall();
+  }
+
+  /// Return true if this ACS represents an indirect call.
+  bool isIndirectCall() const {
+    return !isCallbackCall() && CB->isIndirectCall();
+  }
+
+  /// Return true if this ACS represents a callback call.
+  bool isCallbackCall() const {
+    // For a callback call site the callee is ALWAYS stored first in the
+    // transitive values vector. Thus, a non-empty vector indicates a callback.
+    return !CI.ParameterEncoding.empty();
+  }
+
+  /// Return true if @p UI is the use that defines the callee of this ACS.
+  bool isCallee(Value::const_user_iterator UI) const {
+    return isCallee(&UI.getUse());
+  }
+
+  /// Return true if @p U is the use that defines the callee of this ACS.
+  bool isCallee(const Use *U) const {
+    if (isDirectCall())
+      return CB->isCallee(U);
+
+    assert(!CI.ParameterEncoding.empty() &&
+           "Callback without parameter encoding!");
+
+    // If the use is actually in a constant cast expression which itself
+    // has only one use, we look through the constant cast expression.
+    if (auto *CE = dyn_cast<ConstantExpr>(U->getUser()))
+      if (CE->hasOneUse() && CE->isCast())
+        U = &*CE->use_begin();
+
+    return (int)CB->getArgOperandNo(U) == CI.ParameterEncoding[0];
+  }
+
+  /// Return the number of parameters of the callee.
+  unsigned getNumArgOperands() const {
+    if (isDirectCall())
+      return CB->getNumArgOperands();
+    // Subtract 1 for the callee encoding.
+    return CI.ParameterEncoding.size() - 1;
+  }
+
+  /// Return the operand index of the underlying instruction associated with @p
+  /// Arg.
+  int getCallArgOperandNo(Argument &Arg) const {
+    return getCallArgOperandNo(Arg.getArgNo());
+  }
+
+  /// Return the operand index of the underlying instruction associated with
+  /// the function parameter number @p ArgNo or -1 if there is none.
+  int getCallArgOperandNo(unsigned ArgNo) const {
+    if (isDirectCall())
+      return ArgNo;
+    // Add 1 for the callee encoding.
+    return CI.ParameterEncoding[ArgNo + 1];
+  }
+
+  /// Return the operand of the underlying instruction associated with @p Arg.
+  Value *getCallArgOperand(Argument &Arg) const {
+    return getCallArgOperand(Arg.getArgNo());
+  }
+
+  /// Return the operand of the underlying instruction associated with the
+  /// function parameter number @p ArgNo or nullptr if there is none.
+  Value *getCallArgOperand(unsigned ArgNo) const {
+    if (isDirectCall())
+      return CB->getArgOperand(ArgNo);
+    // Add 1 for the callee encoding.
+    return CI.ParameterEncoding[ArgNo + 1] >= 0
+               ? CB->getArgOperand(CI.ParameterEncoding[ArgNo + 1])
+               : nullptr;
+  }
+
+  /// Return the operand index of the underlying instruction associated with the
+  /// callee of this ACS. Only valid for callback calls!
+  int getCallArgOperandNoForCallee() const {
+    assert(isCallbackCall());
+    assert(CI.ParameterEncoding.size() && CI.ParameterEncoding[0] >= 0);
+    return CI.ParameterEncoding[0];
+  }
+
+  /// Return the use of the callee value in the underlying instruction. Only
+  /// valid for callback calls!
+  const Use &getCalleeUseForCallback() const {
+    int CalleeArgIdx = getCallArgOperandNoForCallee();
+    assert(CalleeArgIdx >= 0 &&
+           unsigned(CalleeArgIdx) < getInstruction()->getNumOperands());
+    return getInstruction()->getOperandUse(CalleeArgIdx);
+  }
+
+  /// Return the pointer to function that is being called.
+  Value *getCalledOperand() const {
+    if (isDirectCall())
+      return CB->getCalledOperand();
+    return CB->getArgOperand(getCallArgOperandNoForCallee());
+  }
+
+  /// Return the function being called if this is a direct call, otherwise
+  /// return null (if it's an indirect call).
+  Function *getCalledFunction() const {
+    Value *V = getCalledOperand();
+    return V ? dyn_cast<Function>(V->stripPointerCasts()) : nullptr;
+  }
+};
+
+/// Apply function Func to each CB's callback call site.
+template <typename UnaryFunction>
+void forEachCallbackCallSite(const CallBase &CB, UnaryFunction Func) {
+  SmallVector<const Use *, 4u> CallbackUses;
+  AbstractCallSite::getCallbackUses(CB, CallbackUses);
+  for (const Use *U : CallbackUses) {
+    AbstractCallSite ACS(U);
+    assert(ACS && ACS.isCallbackCall() && "must be a callback call");
+    Func(ACS);
+  }
+}
+
+/// Apply function Func to each CB's callback function.
+template <typename UnaryFunction>
+void forEachCallbackFunction(const CallBase &CB, UnaryFunction Func) {
+  forEachCallbackCallSite(CB, [&Func](AbstractCallSite &ACS) {
+    if (Function *Callback = ACS.getCalledFunction())
+      Func(Callback);
+  });
+}
+
+} // end namespace llvm
+
+#endif // LLVM_IR_ABSTRACTCALLSITE_H
diff --git a/linux-x64/clang/include/llvm/IR/Argument.h b/linux-x64/clang/include/llvm/IR/Argument.h
index 5f514b9..f59a498 100644
--- a/linux-x64/clang/include/llvm/IR/Argument.h
+++ b/linux-x64/clang/include/llvm/IR/Argument.h
@@ -65,22 +65,50 @@
   /// Return true if this argument has the byval attribute.
   bool hasByValAttr() const;
 
+  /// Return true if this argument has the byref attribute.
+  bool hasByRefAttr() const;
+
   /// Return true if this argument has the swiftself attribute.
   bool hasSwiftSelfAttr() const;
 
   /// Return true if this argument has the swifterror attribute.
   bool hasSwiftErrorAttr() const;
 
-  /// Return true if this argument has the byval attribute or inalloca
-  /// attribute. These attributes represent arguments being passed by value.
-  bool hasByValOrInAllocaAttr() const;
+  /// Return true if this argument has the byval, inalloca, or preallocated
+  /// attribute. These attributes represent arguments being passed by value,
+  /// with an associated copy between the caller and callee
+  bool hasPassPointeeByValueCopyAttr() const;
+
+  /// If this argument satisfies has hasPassPointeeByValueAttr, return the
+  /// in-memory ABI size copied to the stack for the call. Otherwise, return 0.
+  uint64_t getPassPointeeByValueCopySize(const DataLayout &DL) const;
+
+  /// Return true if this argument has the byval, sret, inalloca, preallocated,
+  /// or byref attribute. These attributes represent arguments being passed by
+  /// value (which may or may not involve a stack copy)
+  bool hasPointeeInMemoryValueAttr() const;
+
+  /// If hasPointeeInMemoryValueAttr returns true, the in-memory ABI type is
+  /// returned. Otherwise, nullptr.
+  Type *getPointeeInMemoryValueType() const;
 
   /// If this is a byval or inalloca argument, return its alignment.
+  /// FIXME: Remove this function once transition to Align is over.
+  /// Use getParamAlign() instead.
   unsigned getParamAlignment() const;
 
+  /// If this is a byval or inalloca argument, return its alignment.
+  MaybeAlign getParamAlign() const;
+
   /// If this is a byval argument, return its type.
   Type *getParamByValType() const;
 
+  /// If this is an sret argument, return its type.
+  Type *getParamStructRetType() const;
+
+  /// If this is a byref argument, return its type.
+  Type *getParamByRefType() const;
+
   /// Return true if this argument has the nest attribute.
   bool hasNestAttr() const;
 
@@ -105,6 +133,9 @@
   /// Return true if this argument has the inalloca attribute.
   bool hasInAllocaAttr() const;
 
+  /// Return true if this argument has the preallocated attribute.
+  bool hasPreallocatedAttr() const;
+
   /// Return true if this argument has the zext attribute.
   bool hasZExtAttr() const;
 
diff --git a/linux-x64/clang/include/llvm/IR/Assumptions.h b/linux-x64/clang/include/llvm/IR/Assumptions.h
new file mode 100644
index 0000000..f64616c
--- /dev/null
+++ b/linux-x64/clang/include/llvm/IR/Assumptions.h
@@ -0,0 +1,50 @@
+//===--- Assumptions.h - Assumption handling and organization ---*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// String assumptions that are known to optimization passes should be placed in
+// the KnownAssumptionStrings set. This can be done in various ways, i.a.,
+// via a static KnownAssumptionString object.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_IR_ASSUMPTIONS_H
+#define LLVM_IR_ASSUMPTIONS_H
+
+#include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/StringSet.h"
+
+namespace llvm {
+
+class Function;
+
+/// The key we use for assumption attributes.
+constexpr StringRef AssumptionAttrKey = "llvm.assume";
+
+/// A set of known assumption strings that are accepted without warning and
+/// which can be recommended as typo correction.
+extern StringSet<> KnownAssumptionStrings;
+
+/// Helper that allows to insert a new assumption string in the known assumption
+/// set by creating a (static) object.
+struct KnownAssumptionString {
+  KnownAssumptionString(StringRef AssumptionStr)
+      : AssumptionStr(AssumptionStr) {
+    KnownAssumptionStrings.insert(AssumptionStr);
+  }
+  operator StringRef() const { return AssumptionStr; }
+
+private:
+  StringRef AssumptionStr;
+};
+
+/// Return true if \p F has the assumption \p AssumptionStr attached.
+bool hasAssumption(Function &F, const KnownAssumptionString &AssumptionStr);
+
+} // namespace llvm
+
+#endif
diff --git a/linux-x64/clang/include/llvm/IR/Attributes.h b/linux-x64/clang/include/llvm/IR/Attributes.h
index 06cc09e..fbfe585 100644
--- a/linux-x64/clang/include/llvm/IR/Attributes.h
+++ b/linux-x64/clang/include/llvm/IR/Attributes.h
@@ -17,11 +17,11 @@
 
 #include "llvm-c/Types.h"
 #include "llvm/ADT/ArrayRef.h"
-#include "llvm/ADT/FoldingSet.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/Config/llvm-config.h"
+#include "llvm/Support/Alignment.h"
 #include "llvm/Support/PointerLikeTypeTraits.h"
 #include <bitset>
 #include <cassert>
@@ -37,6 +37,7 @@
 class AttributeListImpl;
 class AttributeSetNode;
 template<typename T> struct DenseMapInfo;
+class FoldingSetNodeID;
 class Function;
 class LLVMContext;
 class Type;
@@ -69,9 +70,12 @@
   enum AttrKind {
     // IR-Level Attributes
     None,                  ///< No attributes have been set
-    #define GET_ATTR_ENUM
+    #define GET_ATTR_NAMES
+    #define ATTRIBUTE_ENUM(ENUM_NAME, OTHER) ENUM_NAME,
     #include "llvm/IR/Attributes.inc"
-    EndAttrKinds           ///< Sentinal value useful for loops
+    EndAttrKinds,          ///< Sentinal value useful for loops
+    EmptyKey,              ///< Use as Empty key for DenseMap of AttrKind
+    TombstoneKey,          ///< Use as Tombstone key for DenseMap of AttrKind
   };
 
 private:
@@ -94,8 +98,8 @@
 
   /// Return a uniquified Attribute object that has the specific
   /// alignment set.
-  static Attribute getWithAlignment(LLVMContext &Context, uint64_t Align);
-  static Attribute getWithStackAlignment(LLVMContext &Context, uint64_t Align);
+  static Attribute getWithAlignment(LLVMContext &Context, Align Alignment);
+  static Attribute getWithStackAlignment(LLVMContext &Context, Align Alignment);
   static Attribute getWithDereferenceableBytes(LLVMContext &Context,
                                               uint64_t Bytes);
   static Attribute getWithDereferenceableOrNullBytes(LLVMContext &Context,
@@ -104,6 +108,27 @@
                                         unsigned ElemSizeArg,
                                         const Optional<unsigned> &NumElemsArg);
   static Attribute getWithByValType(LLVMContext &Context, Type *Ty);
+  static Attribute getWithStructRetType(LLVMContext &Context, Type *Ty);
+  static Attribute getWithByRefType(LLVMContext &Context, Type *Ty);
+  static Attribute getWithPreallocatedType(LLVMContext &Context, Type *Ty);
+
+  /// For a typed attribute, return the equivalent attribute with the type
+  /// changed to \p ReplacementTy.
+  Attribute getWithNewType(LLVMContext &Context, Type *ReplacementTy) {
+    assert(isTypeAttribute() && "this requires a typed attribute");
+    return get(Context, getKindAsEnum(), ReplacementTy);
+  }
+
+  static Attribute::AttrKind getAttrKindFromName(StringRef AttrName);
+
+  static StringRef getNameFromAttrKind(Attribute::AttrKind AttrKind);
+
+  /// Return true if and only if the attribute has an Argument.
+  static bool doesAttrKindHaveArgument(Attribute::AttrKind AttrKind);
+
+  /// Return true if the provided string matches the IR name of an attribute.
+  /// example: "noalias" return true but not "NoAlias"
+  static bool isExistingAttribute(StringRef Name);
 
   //===--------------------------------------------------------------------===//
   // Attribute Accessors
@@ -122,6 +147,9 @@
   /// Return true if the attribute is a type attribute.
   bool isTypeAttribute() const;
 
+  /// Return true if the attribute is any kind of attribute.
+  bool isValid() const { return pImpl; }
+
   /// Return true if the attribute is present.
   bool hasAttribute(AttrKind Val) const;
 
@@ -150,11 +178,11 @@
 
   /// Returns the alignment field of an attribute as a byte alignment
   /// value.
-  unsigned getAlignment() const;
+  MaybeAlign getAlignment() const;
 
   /// Returns the stack alignment field of an attribute as a byte
   /// alignment value.
-  unsigned getStackAlignment() const;
+  MaybeAlign getStackAlignment() const;
 
   /// Returns the number of dereferenceable bytes from the
   /// dereferenceable attribute.
@@ -179,9 +207,7 @@
   /// Less-than operator. Useful for sorting the attributes list.
   bool operator<(Attribute A) const;
 
-  void Profile(FoldingSetNodeID &ID) const {
-    ID.AddPointer(pImpl);
-  }
+  void Profile(FoldingSetNodeID &ID) const;
 
   /// Return a raw pointer that uniquely identifies this attribute.
   void *getRawPointer() const {
@@ -284,11 +310,14 @@
   /// Return the target-dependent attribute object.
   Attribute getAttribute(StringRef Kind) const;
 
-  unsigned getAlignment() const;
-  unsigned getStackAlignment() const;
+  MaybeAlign getAlignment() const;
+  MaybeAlign getStackAlignment() const;
   uint64_t getDereferenceableBytes() const;
   uint64_t getDereferenceableOrNullBytes() const;
   Type *getByValType() const;
+  Type *getStructRetType() const;
+  Type *getByRefType() const;
+  Type *getPreallocatedType() const;
   std::pair<unsigned, Optional<unsigned>> getAllocSizeArgs() const;
   std::string getAsString(bool InAttrGrp = false) const;
 
@@ -382,6 +411,9 @@
   static AttributeList get(LLVMContext &C, unsigned Index,
                            ArrayRef<Attribute::AttrKind> Kinds);
   static AttributeList get(LLVMContext &C, unsigned Index,
+                           ArrayRef<Attribute::AttrKind> Kinds,
+                           ArrayRef<uint64_t> Values);
+  static AttributeList get(LLVMContext &C, unsigned Index,
                            ArrayRef<StringRef> Kind);
   static AttributeList get(LLVMContext &C, unsigned Index,
                            const AttrBuilder &B);
@@ -485,6 +517,17 @@
     return removeAttributes(C, ArgNo + FirstArgIndex);
   }
 
+  /// Replace the type contained by attribute \p AttrKind at index \p ArgNo wih
+  /// \p ReplacementTy, preserving all other attributes.
+  LLVM_NODISCARD AttributeList replaceAttributeType(LLVMContext &C,
+                                                    unsigned ArgNo,
+                                                    Attribute::AttrKind Kind,
+                                                    Type *ReplacementTy) const {
+    Attribute Attr = getAttribute(ArgNo, Kind);
+    auto Attrs = removeAttribute(C, ArgNo, Kind);
+    return Attrs.addAttribute(C, ArgNo, Attr.getWithNewType(C, ReplacementTy));
+  }
+
   /// \brief Add the dereferenceable attribute to the attribute set at the given
   /// index. Returns a new list because attribute lists are immutable.
   LLVM_NODISCARD AttributeList addDereferenceableAttr(LLVMContext &C,
@@ -529,9 +572,6 @@
   // AttributeList Accessors
   //===--------------------------------------------------------------------===//
 
-  /// Retrieve the LLVM context.
-  LLVMContext &getContext() const;
-
   /// The attributes for the specified index are returned.
   AttributeSet getAttributes(unsigned Index) const;
 
@@ -603,16 +643,25 @@
   }
 
   /// Return the alignment of the return value.
-  unsigned getRetAlignment() const;
+  MaybeAlign getRetAlignment() const;
 
   /// Return the alignment for the specified function parameter.
-  unsigned getParamAlignment(unsigned ArgNo) const;
+  MaybeAlign getParamAlignment(unsigned ArgNo) const;
 
   /// Return the byval type for the specified function parameter.
   Type *getParamByValType(unsigned ArgNo) const;
 
+  /// Return the sret type for the specified function parameter.
+  Type *getParamStructRetType(unsigned ArgNo) const;
+
+  /// Return the byref type for the specified function parameter.
+  Type *getParamByRefType(unsigned ArgNo) const;
+
+  /// Return the preallocated type for the specified function parameter.
+  Type *getParamPreallocatedType(unsigned ArgNo) const;
+
   /// Get the stack alignment.
-  unsigned getStackAlignment(unsigned Index) const;
+  MaybeAlign getStackAlignment(unsigned Index) const;
 
   /// Get the number of dereferenceable bytes (or zero if unknown).
   uint64_t getDereferenceableBytes(unsigned Index) const;
@@ -704,13 +753,16 @@
 /// equality, presence of attributes, etc.
 class AttrBuilder {
   std::bitset<Attribute::EndAttrKinds> Attrs;
-  std::map<std::string, std::string> TargetDepAttrs;
-  uint64_t Alignment = 0;
-  uint64_t StackAlignment = 0;
+  std::map<std::string, std::string, std::less<>> TargetDepAttrs;
+  MaybeAlign Alignment;
+  MaybeAlign StackAlignment;
   uint64_t DerefBytes = 0;
   uint64_t DerefOrNullBytes = 0;
   uint64_t AllocSizeArgs = 0;
   Type *ByValType = nullptr;
+  Type *StructRetType = nullptr;
+  Type *ByRefType = nullptr;
+  Type *PreallocatedType = nullptr;
 
 public:
   AttrBuilder() = default;
@@ -725,7 +777,14 @@
   void clear();
 
   /// Add an attribute to the builder.
-  AttrBuilder &addAttribute(Attribute::AttrKind Val);
+  AttrBuilder &addAttribute(Attribute::AttrKind Val) {
+    assert((unsigned)Val < Attribute::EndAttrKinds &&
+           "Attribute out of range!");
+    assert(!Attribute::doesAttrKindHaveArgument(Val) &&
+           "Adding integer attribute without adding a value!");
+    Attrs[Val] = true;
+    return *this;
+  }
 
   /// Add the Attribute object to the builder.
   AttrBuilder &addAttribute(Attribute A);
@@ -773,10 +832,10 @@
   bool hasAlignmentAttr() const;
 
   /// Retrieve the alignment attribute, if it exists.
-  uint64_t getAlignment() const { return Alignment; }
+  MaybeAlign getAlignment() const { return Alignment; }
 
   /// Retrieve the stack alignment attribute, if it exists.
-  uint64_t getStackAlignment() const { return StackAlignment; }
+  MaybeAlign getStackAlignment() const { return StackAlignment; }
 
   /// Retrieve the number of dereferenceable bytes, if the
   /// dereferenceable attribute exists (zero is returned otherwise).
@@ -789,17 +848,42 @@
   /// Retrieve the byval type.
   Type *getByValType() const { return ByValType; }
 
+  /// Retrieve the sret type.
+  Type *getStructRetType() const { return StructRetType; }
+
+  /// Retrieve the byref type.
+  Type *getByRefType() const { return ByRefType; }
+
+  /// Retrieve the preallocated type.
+  Type *getPreallocatedType() const { return PreallocatedType; }
+
   /// Retrieve the allocsize args, if the allocsize attribute exists.  If it
   /// doesn't exist, pair(0, 0) is returned.
   std::pair<unsigned, Optional<unsigned>> getAllocSizeArgs() const;
 
+  /// This turns an alignment into the form used internally in Attribute.
+  /// This call has no effect if Align is not set.
+  AttrBuilder &addAlignmentAttr(MaybeAlign Align);
+
   /// This turns an int alignment (which must be a power of 2) into the
   /// form used internally in Attribute.
-  AttrBuilder &addAlignmentAttr(unsigned Align);
+  /// This call has no effect if Align is 0.
+  /// Deprecated, use the version using a MaybeAlign.
+  inline AttrBuilder &addAlignmentAttr(unsigned Align) {
+    return addAlignmentAttr(MaybeAlign(Align));
+  }
+
+  /// This turns a stack alignment into the form used internally in Attribute.
+  /// This call has no effect if Align is not set.
+  AttrBuilder &addStackAlignmentAttr(MaybeAlign Align);
 
   /// This turns an int stack alignment (which must be a power of 2) into
   /// the form used internally in Attribute.
-  AttrBuilder &addStackAlignmentAttr(unsigned Align);
+  /// This call has no effect if Align is 0.
+  /// Deprecated, use the version using a MaybeAlign.
+  inline AttrBuilder &addStackAlignmentAttr(unsigned Align) {
+    return addStackAlignmentAttr(MaybeAlign(Align));
+  }
 
   /// This turns the number of dereferenceable bytes into the form used
   /// internally in Attribute.
@@ -816,6 +900,15 @@
   /// This turns a byval type into the form used internally in Attribute.
   AttrBuilder &addByValAttr(Type *Ty);
 
+  /// This turns a sret type into the form used internally in Attribute.
+  AttrBuilder &addStructRetAttr(Type *Ty);
+
+  /// This turns a byref type into the form used internally in Attribute.
+  AttrBuilder &addByRefAttr(Type *Ty);
+
+  /// This turns a preallocated type into the form used internally in Attribute.
+  AttrBuilder &addPreallocatedAttr(Type *Ty);
+
   /// Add an allocsize attribute, using the representation returned by
   /// Attribute.getIntValue().
   AttrBuilder &addAllocSizeAttrFromRawRepr(uint64_t RawAllocSizeRepr);
@@ -826,8 +919,8 @@
 
   // Iterators for target-dependent attributes.
   using td_type = std::pair<std::string, std::string>;
-  using td_iterator = std::map<std::string, std::string>::iterator;
-  using td_const_iterator = std::map<std::string, std::string>::const_iterator;
+  using td_iterator = decltype(TargetDepAttrs)::iterator;
+  using td_const_iterator = decltype(TargetDepAttrs)::const_iterator;
   using td_range = iterator_range<td_iterator>;
   using td_const_range = iterator_range<td_const_iterator>;
 
@@ -845,10 +938,8 @@
 
   bool td_empty() const { return TargetDepAttrs.empty(); }
 
-  bool operator==(const AttrBuilder &B);
-  bool operator!=(const AttrBuilder &B) {
-    return !(*this == B);
-  }
+  bool operator==(const AttrBuilder &B) const;
+  bool operator!=(const AttrBuilder &B) const { return !(*this == B); }
 };
 
 namespace AttributeFuncs {
@@ -860,9 +951,24 @@
 /// attributes for inlining purposes.
 bool areInlineCompatible(const Function &Caller, const Function &Callee);
 
+
+/// Checks  if there are any incompatible function attributes between
+/// \p A and \p B.
+///
+/// \param [in] A - The first function to be compared with.
+/// \param [in] B - The second function to be compared with.
+/// \returns true if the functions have compatible attributes.
+bool areOutlineCompatible(const Function &A, const Function &B);
+
 /// Merge caller's and callee's attributes.
 void mergeAttributesForInlining(Function &Caller, const Function &Callee);
 
+/// Merges the functions attributes from \p ToMerge into function \p Base.
+///
+/// \param [in,out] Base - The function being merged into.
+/// \param [in] ToMerge - The function to merge attributes from.
+void mergeAttributesForOutlining(Function &Base, const Function &ToMerge);
+
 } // end namespace AttributeFuncs
 
 } // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/IR/Attributes.inc b/linux-x64/clang/include/llvm/IR/Attributes.inc
index c99cba1..550d818 100644
--- a/linux-x64/clang/include/llvm/IR/Attributes.inc
+++ b/linux-x64/clang/include/llvm/IR/Attributes.inc
@@ -1,512 +1,106 @@
-#ifdef GET_ATTR_ENUM
-#undef GET_ATTR_ENUM
-Alignment,
-AllocSize,
-AlwaysInline,
-ArgMemOnly,
-Builtin,
-ByVal,
-Cold,
-Convergent,
-Dereferenceable,
-DereferenceableOrNull,
-ImmArg,
-InAlloca,
-InReg,
-InaccessibleMemOnly,
-InaccessibleMemOrArgMemOnly,
-InlineHint,
-JumpTable,
-MinSize,
-Naked,
-Nest,
-NoAlias,
-NoBuiltin,
-NoCapture,
-NoCfCheck,
-NoDuplicate,
-NoFree,
-NoImplicitFloat,
-NoInline,
-NoRecurse,
-NoRedZone,
-NoReturn,
-NoUnwind,
-NonLazyBind,
-NonNull,
-OptForFuzzing,
-OptimizeForSize,
-OptimizeNone,
-ReadNone,
-ReadOnly,
-Returned,
-ReturnsTwice,
-SExt,
-SafeStack,
-SanitizeAddress,
-SanitizeHWAddress,
-SanitizeMemory,
-SanitizeThread,
-ShadowCallStack,
-Speculatable,
-SpeculativeLoadHardening,
-StackAlignment,
-StackProtect,
-StackProtectReq,
-StackProtectStrong,
-StrictFP,
-StructRet,
-SwiftError,
-SwiftSelf,
-UWTable,
-WillReturn,
-WriteOnly,
-ZExt,
+#ifdef GET_ATTR_NAMES
+#undef GET_ATTR_NAMES
+#ifndef ATTRIBUTE_ALL
+#define ATTRIBUTE_ALL(FIRST, SECOND)
 #endif
-#ifdef GET_ATTR_KIND_FROM_NAME
-#undef GET_ATTR_KIND_FROM_NAME
-static Attribute::AttrKind getAttrKindFromName(StringRef AttrName) {
-  return StringSwitch<Attribute::AttrKind>(AttrName)
-    .Case("align", Attribute::Alignment)
-    .Case("allocsize", Attribute::AllocSize)
-    .Case("alwaysinline", Attribute::AlwaysInline)
-    .Case("argmemonly", Attribute::ArgMemOnly)
-    .Case("builtin", Attribute::Builtin)
-    .Case("byval", Attribute::ByVal)
-    .Case("cold", Attribute::Cold)
-    .Case("convergent", Attribute::Convergent)
-    .Case("dereferenceable", Attribute::Dereferenceable)
-    .Case("dereferenceable_or_null", Attribute::DereferenceableOrNull)
-    .Case("immarg", Attribute::ImmArg)
-    .Case("inalloca", Attribute::InAlloca)
-    .Case("inreg", Attribute::InReg)
-    .Case("inaccessiblememonly", Attribute::InaccessibleMemOnly)
-    .Case("inaccessiblemem_or_argmemonly", Attribute::InaccessibleMemOrArgMemOnly)
-    .Case("inlinehint", Attribute::InlineHint)
-    .Case("jumptable", Attribute::JumpTable)
-    .Case("minsize", Attribute::MinSize)
-    .Case("naked", Attribute::Naked)
-    .Case("nest", Attribute::Nest)
-    .Case("noalias", Attribute::NoAlias)
-    .Case("nobuiltin", Attribute::NoBuiltin)
-    .Case("nocapture", Attribute::NoCapture)
-    .Case("nocf_check", Attribute::NoCfCheck)
-    .Case("noduplicate", Attribute::NoDuplicate)
-    .Case("nofree", Attribute::NoFree)
-    .Case("noimplicitfloat", Attribute::NoImplicitFloat)
-    .Case("noinline", Attribute::NoInline)
-    .Case("norecurse", Attribute::NoRecurse)
-    .Case("noredzone", Attribute::NoRedZone)
-    .Case("noreturn", Attribute::NoReturn)
-    .Case("nounwind", Attribute::NoUnwind)
-    .Case("nonlazybind", Attribute::NonLazyBind)
-    .Case("nonnull", Attribute::NonNull)
-    .Case("optforfuzzing", Attribute::OptForFuzzing)
-    .Case("optsize", Attribute::OptimizeForSize)
-    .Case("optnone", Attribute::OptimizeNone)
-    .Case("readnone", Attribute::ReadNone)
-    .Case("readonly", Attribute::ReadOnly)
-    .Case("returned", Attribute::Returned)
-    .Case("returns_twice", Attribute::ReturnsTwice)
-    .Case("signext", Attribute::SExt)
-    .Case("safestack", Attribute::SafeStack)
-    .Case("sanitize_address", Attribute::SanitizeAddress)
-    .Case("sanitize_hwaddress", Attribute::SanitizeHWAddress)
-    .Case("sanitize_memory", Attribute::SanitizeMemory)
-    .Case("sanitize_thread", Attribute::SanitizeThread)
-    .Case("shadowcallstack", Attribute::ShadowCallStack)
-    .Case("speculatable", Attribute::Speculatable)
-    .Case("speculative_load_hardening", Attribute::SpeculativeLoadHardening)
-    .Case("alignstack", Attribute::StackAlignment)
-    .Case("ssp", Attribute::StackProtect)
-    .Case("sspreq", Attribute::StackProtectReq)
-    .Case("sspstrong", Attribute::StackProtectStrong)
-    .Case("strictfp", Attribute::StrictFP)
-    .Case("sret", Attribute::StructRet)
-    .Case("swifterror", Attribute::SwiftError)
-    .Case("swiftself", Attribute::SwiftSelf)
-    .Case("uwtable", Attribute::UWTable)
-    .Case("willreturn", Attribute::WillReturn)
-    .Case("writeonly", Attribute::WriteOnly)
-    .Case("zeroext", Attribute::ZExt)
-    .Default(Attribute::None);
-}
 
+#ifndef ATTRIBUTE_ENUM
+#define ATTRIBUTE_ENUM(FIRST, SECOND) ATTRIBUTE_ALL(FIRST, SECOND)
+#endif
+
+ATTRIBUTE_ENUM(AlwaysInline,alwaysinline)
+ATTRIBUTE_ENUM(ArgMemOnly,argmemonly)
+ATTRIBUTE_ENUM(Builtin,builtin)
+ATTRIBUTE_ENUM(Cold,cold)
+ATTRIBUTE_ENUM(Convergent,convergent)
+ATTRIBUTE_ENUM(Hot,hot)
+ATTRIBUTE_ENUM(ImmArg,immarg)
+ATTRIBUTE_ENUM(InAlloca,inalloca)
+ATTRIBUTE_ENUM(InReg,inreg)
+ATTRIBUTE_ENUM(InaccessibleMemOnly,inaccessiblememonly)
+ATTRIBUTE_ENUM(InaccessibleMemOrArgMemOnly,inaccessiblemem_or_argmemonly)
+ATTRIBUTE_ENUM(InlineHint,inlinehint)
+ATTRIBUTE_ENUM(JumpTable,jumptable)
+ATTRIBUTE_ENUM(MinSize,minsize)
+ATTRIBUTE_ENUM(Naked,naked)
+ATTRIBUTE_ENUM(Nest,nest)
+ATTRIBUTE_ENUM(NoAlias,noalias)
+ATTRIBUTE_ENUM(NoBuiltin,nobuiltin)
+ATTRIBUTE_ENUM(NoCallback,nocallback)
+ATTRIBUTE_ENUM(NoCapture,nocapture)
+ATTRIBUTE_ENUM(NoCfCheck,nocf_check)
+ATTRIBUTE_ENUM(NoDuplicate,noduplicate)
+ATTRIBUTE_ENUM(NoFree,nofree)
+ATTRIBUTE_ENUM(NoImplicitFloat,noimplicitfloat)
+ATTRIBUTE_ENUM(NoInline,noinline)
+ATTRIBUTE_ENUM(NoMerge,nomerge)
+ATTRIBUTE_ENUM(NoRecurse,norecurse)
+ATTRIBUTE_ENUM(NoRedZone,noredzone)
+ATTRIBUTE_ENUM(NoReturn,noreturn)
+ATTRIBUTE_ENUM(NoSync,nosync)
+ATTRIBUTE_ENUM(NoUndef,noundef)
+ATTRIBUTE_ENUM(NoUnwind,nounwind)
+ATTRIBUTE_ENUM(NonLazyBind,nonlazybind)
+ATTRIBUTE_ENUM(NonNull,nonnull)
+ATTRIBUTE_ENUM(NullPointerIsValid,null_pointer_is_valid)
+ATTRIBUTE_ENUM(OptForFuzzing,optforfuzzing)
+ATTRIBUTE_ENUM(OptimizeForSize,optsize)
+ATTRIBUTE_ENUM(OptimizeNone,optnone)
+ATTRIBUTE_ENUM(ReadNone,readnone)
+ATTRIBUTE_ENUM(ReadOnly,readonly)
+ATTRIBUTE_ENUM(Returned,returned)
+ATTRIBUTE_ENUM(ReturnsTwice,returns_twice)
+ATTRIBUTE_ENUM(SExt,signext)
+ATTRIBUTE_ENUM(SafeStack,safestack)
+ATTRIBUTE_ENUM(SanitizeAddress,sanitize_address)
+ATTRIBUTE_ENUM(SanitizeHWAddress,sanitize_hwaddress)
+ATTRIBUTE_ENUM(SanitizeMemTag,sanitize_memtag)
+ATTRIBUTE_ENUM(SanitizeMemory,sanitize_memory)
+ATTRIBUTE_ENUM(SanitizeThread,sanitize_thread)
+ATTRIBUTE_ENUM(ShadowCallStack,shadowcallstack)
+ATTRIBUTE_ENUM(Speculatable,speculatable)
+ATTRIBUTE_ENUM(SpeculativeLoadHardening,speculative_load_hardening)
+ATTRIBUTE_ENUM(StackProtect,ssp)
+ATTRIBUTE_ENUM(StackProtectReq,sspreq)
+ATTRIBUTE_ENUM(StackProtectStrong,sspstrong)
+ATTRIBUTE_ENUM(StrictFP,strictfp)
+ATTRIBUTE_ENUM(SwiftError,swifterror)
+ATTRIBUTE_ENUM(SwiftSelf,swiftself)
+ATTRIBUTE_ENUM(UWTable,uwtable)
+ATTRIBUTE_ENUM(WillReturn,willreturn)
+ATTRIBUTE_ENUM(WriteOnly,writeonly)
+ATTRIBUTE_ENUM(ZExt,zeroext)
+ATTRIBUTE_ENUM(ByRef,byref)
+ATTRIBUTE_ENUM(ByVal,byval)
+ATTRIBUTE_ENUM(MustProgress,mustprogress)
+ATTRIBUTE_ENUM(Preallocated,preallocated)
+ATTRIBUTE_ENUM(StructRet,sret)
+ATTRIBUTE_ENUM(Alignment,align)
+ATTRIBUTE_ENUM(AllocSize,allocsize)
+ATTRIBUTE_ENUM(Dereferenceable,dereferenceable)
+ATTRIBUTE_ENUM(DereferenceableOrNull,dereferenceable_or_null)
+ATTRIBUTE_ENUM(StackAlignment,alignstack)
+#undef ATTRIBUTE_ENUM
+
+#ifndef ATTRIBUTE_STRBOOL
+#define ATTRIBUTE_STRBOOL(FIRST, SECOND) ATTRIBUTE_ALL(FIRST, SECOND)
+#endif
+
+ATTRIBUTE_STRBOOL(LessPreciseFPMAD,less-precise-fpmad)
+ATTRIBUTE_STRBOOL(NoInfsFPMath,no-infs-fp-math)
+ATTRIBUTE_STRBOOL(NoInlineLineTables,no-inline-line-tables)
+ATTRIBUTE_STRBOOL(NoJumpTables,no-jump-tables)
+ATTRIBUTE_STRBOOL(NoNansFPMath,no-nans-fp-math)
+ATTRIBUTE_STRBOOL(NoSignedZerosFPMath,no-signed-zeros-fp-math)
+ATTRIBUTE_STRBOOL(ProfileSampleAccurate,profile-sample-accurate)
+ATTRIBUTE_STRBOOL(UnsafeFPMath,unsafe-fp-math)
+ATTRIBUTE_STRBOOL(UseSampleProfile,use-sample-profile)
+#undef ATTRIBUTE_STRBOOL
+
+#undef ATTRIBUTE_ALL
 #endif
 #ifdef GET_ATTR_COMPAT_FUNC
 #undef GET_ATTR_COMPAT_FUNC
-struct EnumAttr {
-  static bool isSet(const Function &Fn,
-                    Attribute::AttrKind Kind) {
-    return Fn.hasFnAttribute(Kind);
-  }
-
-  static void set(Function &Fn,
-                  Attribute::AttrKind Kind, bool Val) {
-    if (Val)
-      Fn.addFnAttr(Kind);
-    else
-      Fn.removeFnAttr(Kind);
-  }
-};
-
-struct StrBoolAttr {
-  static bool isSet(const Function &Fn,
-                    StringRef Kind) {
-    auto A = Fn.getFnAttribute(Kind);
-    return A.getValueAsString().equals("true");
-  }
-
-  static void set(Function &Fn,
-                  StringRef Kind, bool Val) {
-    Fn.addFnAttr(Kind, Val ? "true" : "false");
-  }
-};
-
-// EnumAttr classes
-struct AlignmentAttr : EnumAttr {
-  static enum Attribute::AttrKind getKind() {
-    return llvm::Attribute::Alignment;
-  }
-};
-struct AllocSizeAttr : EnumAttr {
-  static enum Attribute::AttrKind getKind() {
-    return llvm::Attribute::AllocSize;
-  }
-};
-struct AlwaysInlineAttr : EnumAttr {
-  static enum Attribute::AttrKind getKind() {
-    return llvm::Attribute::AlwaysInline;
-  }
-};
-struct ArgMemOnlyAttr : EnumAttr {
-  static enum Attribute::AttrKind getKind() {
-    return llvm::Attribute::ArgMemOnly;
-  }
-};
-struct BuiltinAttr : EnumAttr {
-  static enum Attribute::AttrKind getKind() {
-    return llvm::Attribute::Builtin;
-  }
-};
-struct ByValAttr : EnumAttr {
-  static enum Attribute::AttrKind getKind() {
-    return llvm::Attribute::ByVal;
-  }
-};
-struct ColdAttr : EnumAttr {
-  static enum Attribute::AttrKind getKind() {
-    return llvm::Attribute::Cold;
-  }
-};
-struct ConvergentAttr : EnumAttr {
-  static enum Attribute::AttrKind getKind() {
-    return llvm::Attribute::Convergent;
-  }
-};
-struct DereferenceableAttr : EnumAttr {
-  static enum Attribute::AttrKind getKind() {
-    return llvm::Attribute::Dereferenceable;
-  }
-};
-struct DereferenceableOrNullAttr : EnumAttr {
-  static enum Attribute::AttrKind getKind() {
-    return llvm::Attribute::DereferenceableOrNull;
-  }
-};
-struct ImmArgAttr : EnumAttr {
-  static enum Attribute::AttrKind getKind() {
-    return llvm::Attribute::ImmArg;
-  }
-};
-struct InAllocaAttr : EnumAttr {
-  static enum Attribute::AttrKind getKind() {
-    return llvm::Attribute::InAlloca;
-  }
-};
-struct InRegAttr : EnumAttr {
-  static enum Attribute::AttrKind getKind() {
-    return llvm::Attribute::InReg;
-  }
-};
-struct InaccessibleMemOnlyAttr : EnumAttr {
-  static enum Attribute::AttrKind getKind() {
-    return llvm::Attribute::InaccessibleMemOnly;
-  }
-};
-struct InaccessibleMemOrArgMemOnlyAttr : EnumAttr {
-  static enum Attribute::AttrKind getKind() {
-    return llvm::Attribute::InaccessibleMemOrArgMemOnly;
-  }
-};
-struct InlineHintAttr : EnumAttr {
-  static enum Attribute::AttrKind getKind() {
-    return llvm::Attribute::InlineHint;
-  }
-};
-struct JumpTableAttr : EnumAttr {
-  static enum Attribute::AttrKind getKind() {
-    return llvm::Attribute::JumpTable;
-  }
-};
-struct MinSizeAttr : EnumAttr {
-  static enum Attribute::AttrKind getKind() {
-    return llvm::Attribute::MinSize;
-  }
-};
-struct NakedAttr : EnumAttr {
-  static enum Attribute::AttrKind getKind() {
-    return llvm::Attribute::Naked;
-  }
-};
-struct NestAttr : EnumAttr {
-  static enum Attribute::AttrKind getKind() {
-    return llvm::Attribute::Nest;
-  }
-};
-struct NoAliasAttr : EnumAttr {
-  static enum Attribute::AttrKind getKind() {
-    return llvm::Attribute::NoAlias;
-  }
-};
-struct NoBuiltinAttr : EnumAttr {
-  static enum Attribute::AttrKind getKind() {
-    return llvm::Attribute::NoBuiltin;
-  }
-};
-struct NoCaptureAttr : EnumAttr {
-  static enum Attribute::AttrKind getKind() {
-    return llvm::Attribute::NoCapture;
-  }
-};
-struct NoCfCheckAttr : EnumAttr {
-  static enum Attribute::AttrKind getKind() {
-    return llvm::Attribute::NoCfCheck;
-  }
-};
-struct NoDuplicateAttr : EnumAttr {
-  static enum Attribute::AttrKind getKind() {
-    return llvm::Attribute::NoDuplicate;
-  }
-};
-struct NoFreeAttr : EnumAttr {
-  static enum Attribute::AttrKind getKind() {
-    return llvm::Attribute::NoFree;
-  }
-};
-struct NoImplicitFloatAttr : EnumAttr {
-  static enum Attribute::AttrKind getKind() {
-    return llvm::Attribute::NoImplicitFloat;
-  }
-};
-struct NoInlineAttr : EnumAttr {
-  static enum Attribute::AttrKind getKind() {
-    return llvm::Attribute::NoInline;
-  }
-};
-struct NoRecurseAttr : EnumAttr {
-  static enum Attribute::AttrKind getKind() {
-    return llvm::Attribute::NoRecurse;
-  }
-};
-struct NoRedZoneAttr : EnumAttr {
-  static enum Attribute::AttrKind getKind() {
-    return llvm::Attribute::NoRedZone;
-  }
-};
-struct NoReturnAttr : EnumAttr {
-  static enum Attribute::AttrKind getKind() {
-    return llvm::Attribute::NoReturn;
-  }
-};
-struct NoUnwindAttr : EnumAttr {
-  static enum Attribute::AttrKind getKind() {
-    return llvm::Attribute::NoUnwind;
-  }
-};
-struct NonLazyBindAttr : EnumAttr {
-  static enum Attribute::AttrKind getKind() {
-    return llvm::Attribute::NonLazyBind;
-  }
-};
-struct NonNullAttr : EnumAttr {
-  static enum Attribute::AttrKind getKind() {
-    return llvm::Attribute::NonNull;
-  }
-};
-struct OptForFuzzingAttr : EnumAttr {
-  static enum Attribute::AttrKind getKind() {
-    return llvm::Attribute::OptForFuzzing;
-  }
-};
-struct OptimizeForSizeAttr : EnumAttr {
-  static enum Attribute::AttrKind getKind() {
-    return llvm::Attribute::OptimizeForSize;
-  }
-};
-struct OptimizeNoneAttr : EnumAttr {
-  static enum Attribute::AttrKind getKind() {
-    return llvm::Attribute::OptimizeNone;
-  }
-};
-struct ReadNoneAttr : EnumAttr {
-  static enum Attribute::AttrKind getKind() {
-    return llvm::Attribute::ReadNone;
-  }
-};
-struct ReadOnlyAttr : EnumAttr {
-  static enum Attribute::AttrKind getKind() {
-    return llvm::Attribute::ReadOnly;
-  }
-};
-struct ReturnedAttr : EnumAttr {
-  static enum Attribute::AttrKind getKind() {
-    return llvm::Attribute::Returned;
-  }
-};
-struct ReturnsTwiceAttr : EnumAttr {
-  static enum Attribute::AttrKind getKind() {
-    return llvm::Attribute::ReturnsTwice;
-  }
-};
-struct SExtAttr : EnumAttr {
-  static enum Attribute::AttrKind getKind() {
-    return llvm::Attribute::SExt;
-  }
-};
-struct SafeStackAttr : EnumAttr {
-  static enum Attribute::AttrKind getKind() {
-    return llvm::Attribute::SafeStack;
-  }
-};
-struct SanitizeAddressAttr : EnumAttr {
-  static enum Attribute::AttrKind getKind() {
-    return llvm::Attribute::SanitizeAddress;
-  }
-};
-struct SanitizeHWAddressAttr : EnumAttr {
-  static enum Attribute::AttrKind getKind() {
-    return llvm::Attribute::SanitizeHWAddress;
-  }
-};
-struct SanitizeMemoryAttr : EnumAttr {
-  static enum Attribute::AttrKind getKind() {
-    return llvm::Attribute::SanitizeMemory;
-  }
-};
-struct SanitizeThreadAttr : EnumAttr {
-  static enum Attribute::AttrKind getKind() {
-    return llvm::Attribute::SanitizeThread;
-  }
-};
-struct ShadowCallStackAttr : EnumAttr {
-  static enum Attribute::AttrKind getKind() {
-    return llvm::Attribute::ShadowCallStack;
-  }
-};
-struct SpeculatableAttr : EnumAttr {
-  static enum Attribute::AttrKind getKind() {
-    return llvm::Attribute::Speculatable;
-  }
-};
-struct SpeculativeLoadHardeningAttr : EnumAttr {
-  static enum Attribute::AttrKind getKind() {
-    return llvm::Attribute::SpeculativeLoadHardening;
-  }
-};
-struct StackAlignmentAttr : EnumAttr {
-  static enum Attribute::AttrKind getKind() {
-    return llvm::Attribute::StackAlignment;
-  }
-};
-struct StackProtectAttr : EnumAttr {
-  static enum Attribute::AttrKind getKind() {
-    return llvm::Attribute::StackProtect;
-  }
-};
-struct StackProtectReqAttr : EnumAttr {
-  static enum Attribute::AttrKind getKind() {
-    return llvm::Attribute::StackProtectReq;
-  }
-};
-struct StackProtectStrongAttr : EnumAttr {
-  static enum Attribute::AttrKind getKind() {
-    return llvm::Attribute::StackProtectStrong;
-  }
-};
-struct StrictFPAttr : EnumAttr {
-  static enum Attribute::AttrKind getKind() {
-    return llvm::Attribute::StrictFP;
-  }
-};
-struct StructRetAttr : EnumAttr {
-  static enum Attribute::AttrKind getKind() {
-    return llvm::Attribute::StructRet;
-  }
-};
-struct SwiftErrorAttr : EnumAttr {
-  static enum Attribute::AttrKind getKind() {
-    return llvm::Attribute::SwiftError;
-  }
-};
-struct SwiftSelfAttr : EnumAttr {
-  static enum Attribute::AttrKind getKind() {
-    return llvm::Attribute::SwiftSelf;
-  }
-};
-struct UWTableAttr : EnumAttr {
-  static enum Attribute::AttrKind getKind() {
-    return llvm::Attribute::UWTable;
-  }
-};
-struct WillReturnAttr : EnumAttr {
-  static enum Attribute::AttrKind getKind() {
-    return llvm::Attribute::WillReturn;
-  }
-};
-struct WriteOnlyAttr : EnumAttr {
-  static enum Attribute::AttrKind getKind() {
-    return llvm::Attribute::WriteOnly;
-  }
-};
-struct ZExtAttr : EnumAttr {
-  static enum Attribute::AttrKind getKind() {
-    return llvm::Attribute::ZExt;
-  }
-};
-
-// StrBoolAttr classes
-struct LessPreciseFPMADAttr : StrBoolAttr {
-  static StringRef getKind() {
-    return "less-precise-fpmad";
-  }
-};
-struct NoInfsFPMathAttr : StrBoolAttr {
-  static StringRef getKind() {
-    return "no-infs-fp-math";
-  }
-};
-struct NoJumpTablesAttr : StrBoolAttr {
-  static StringRef getKind() {
-    return "no-jump-tables";
-  }
-};
-struct NoNansFPMathAttr : StrBoolAttr {
-  static StringRef getKind() {
-    return "no-nans-fp-math";
-  }
-};
-struct ProfileSampleAccurateAttr : StrBoolAttr {
-  static StringRef getKind() {
-    return "profile-sample-accurate";
-  }
-};
-struct UnsafeFPMathAttr : StrBoolAttr {
-  static StringRef getKind() {
-    return "unsafe-fp-math";
-  }
-};
-
 static inline bool hasCompatibleFnAttrs(const Function &Caller,
                                         const Function &Callee) {
   bool Ret = true;
@@ -515,14 +109,19 @@
   Ret &= isEqual<SanitizeThreadAttr>(Caller, Callee);
   Ret &= isEqual<SanitizeMemoryAttr>(Caller, Callee);
   Ret &= isEqual<SanitizeHWAddressAttr>(Caller, Callee);
+  Ret &= isEqual<SanitizeMemTagAttr>(Caller, Callee);
   Ret &= isEqual<SafeStackAttr>(Caller, Callee);
   Ret &= isEqual<ShadowCallStackAttr>(Caller, Callee);
+  Ret &= isEqual<UseSampleProfileAttr>(Caller, Callee);
 
   return Ret;
 }
 
 static inline void mergeFnAttrs(Function &Caller,
                                 const Function &Callee) {
+  setAND<NoNansFPMathAttr>(Caller, Callee);
+  setAND<NoSignedZerosFPMathAttr>(Caller, Callee);
+  setAND<UnsafeFPMathAttr>(Caller, Callee);
   setOR<NoImplicitFloatAttr>(Caller, Callee);
   setOR<NoJumpTablesAttr>(Caller, Callee);
   setOR<ProfileSampleAccurateAttr>(Caller, Callee);
@@ -532,10 +131,9 @@
   adjustCallerStackProbeSize(Caller, Callee);
   adjustMinLegalVectorWidth(Caller, Callee);
   adjustNullPointerValidAttr(Caller, Callee);
+  setAND<MustProgressAttr>(Caller, Callee);
   setAND<LessPreciseFPMADAttr>(Caller, Callee);
   setAND<NoInfsFPMathAttr>(Caller, Callee);
-  setAND<NoNansFPMathAttr>(Caller, Callee);
-  setAND<UnsafeFPMathAttr>(Caller, Callee);
 }
 
 #endif
diff --git a/linux-x64/clang/include/llvm/IR/Attributes.td b/linux-x64/clang/include/llvm/IR/Attributes.td
index 694a23a..4546074 100644
--- a/linux-x64/clang/include/llvm/IR/Attributes.td
+++ b/linux-x64/clang/include/llvm/IR/Attributes.td
@@ -1,3 +1,15 @@
+//===- Attributes.td - Defines all LLVM attributes ---------*- tablegen -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines all the LLVM attributes.
+//
+//===----------------------------------------------------------------------===//
+
 /// Attribute base class.
 class Attr<string S> {
   // String representation of this attribute in the IR.
@@ -7,18 +19,24 @@
 /// Enum attribute.
 class EnumAttr<string S> : Attr<S>;
 
+/// Int attribute.
+class IntAttr<string S> : Attr<S>;
+
 /// StringBool attribute.
 class StrBoolAttr<string S> : Attr<S>;
 
+/// Type attribute.
+class TypeAttr<string S> : Attr<S>;
+
 /// Target-independent enum attributes.
 
 /// Alignment of parameter (5 bits) stored as log2 of alignment with +1 bias.
 /// 0 means unaligned (different from align(1)).
-def Alignment : EnumAttr<"align">;
+def Alignment : IntAttr<"align">;
 
 /// The result of the function is guaranteed to point to a number of bytes that
 /// we can determine if we know the value of the function's arguments.
-def AllocSize : EnumAttr<"allocsize">;
+def AllocSize : IntAttr<"allocsize">;
 
 /// inline=always.
 def AlwaysInline : EnumAttr<"alwaysinline">;
@@ -31,7 +49,13 @@
 def Builtin : EnumAttr<"builtin">;
 
 /// Pass structure by value.
-def ByVal : EnumAttr<"byval">;
+def ByVal : TypeAttr<"byval">;
+
+/// Mark in-memory ABI type.
+def ByRef : TypeAttr<"byref">;
+
+/// Parameter or return value may not contain uninitialized or poison bits.
+def NoUndef : EnumAttr<"noundef">;
 
 /// Marks function as being in a cold path.
 def Cold : EnumAttr<"cold">;
@@ -39,11 +63,14 @@
 /// Can only be moved to control-equivalent blocks.
 def Convergent : EnumAttr<"convergent">;
 
+/// Marks function as being in a hot path and frequently called.
+def Hot: EnumAttr<"hot">;
+
 /// Pointer is known to be dereferenceable.
-def Dereferenceable : EnumAttr<"dereferenceable">;
+def Dereferenceable : IntAttr<"dereferenceable">;
 
 /// Pointer is either null or dereferenceable.
-def DereferenceableOrNull : EnumAttr<"dereferenceable_or_null">;
+def DereferenceableOrNull : IntAttr<"dereferenceable_or_null">;
 
 /// Function may only access memory that is inaccessible from IR.
 def InaccessibleMemOnly : EnumAttr<"inaccessiblememonly">;
@@ -79,6 +106,9 @@
 /// Callee isn't recognized as a builtin.
 def NoBuiltin : EnumAttr<"nobuiltin">;
 
+/// Function cannot enter into caller's translation unit.
+def NoCallback : EnumAttr<"nocallback">;
+
 /// Function creates no aliases of pointer.
 def NoCapture : EnumAttr<"nocapture">;
 
@@ -97,6 +127,9 @@
 /// Function is called early and/or often, so lazy binding isn't worthwhile.
 def NonLazyBind : EnumAttr<"nonlazybind">;
 
+/// Disable merging for specified functions or call sites.
+def NoMerge : EnumAttr<"nomerge">;
+
 /// Pointer is known to be not null.
 def NonNull : EnumAttr<"nonnull">;
 
@@ -109,12 +142,18 @@
 /// Mark the function as not returning.
 def NoReturn : EnumAttr<"noreturn">;
 
+/// Function does not synchronize.
+def NoSync : EnumAttr<"nosync">;
+
 /// Disable Indirect Branch Tracking.
 def NoCfCheck : EnumAttr<"nocf_check">;
 
 /// Function doesn't unwind stack.
 def NoUnwind : EnumAttr<"nounwind">;
 
+/// Null pointer in address space zero is valid.
+def NullPointerIsValid : EnumAttr<"null_pointer_is_valid">;
+
 /// Select optimizations for best fuzzing signal.
 def OptForFuzzing : EnumAttr<"optforfuzzing">;
 
@@ -124,6 +163,9 @@
 /// Function must not be optimized.
 def OptimizeNone : EnumAttr<"optnone">;
 
+/// Similar to byval but without a copy.
+def Preallocated : TypeAttr<"preallocated">;
+
 /// Function does not access memory.
 def ReadNone : EnumAttr<"readnone">;
 
@@ -150,7 +192,7 @@
 
 /// Alignment of stack for function (3 bits)  stored as log2 of alignment with
 /// +1 bias 0 means unaligned (different from alignstack=(1)).
-def StackAlignment : EnumAttr<"alignstack">;
+def StackAlignment : IntAttr<"alignstack">;
 
 /// Function can be speculated.
 def Speculatable : EnumAttr<"speculatable">;
@@ -168,7 +210,7 @@
 def StrictFP : EnumAttr<"strictfp">;
 
 /// Hidden pointer to structure to return.
-def StructRet : EnumAttr<"sret">;
+def StructRet : TypeAttr<"sret">;
 
 /// AddressSanitizer is on.
 def SanitizeAddress : EnumAttr<"sanitize_address">;
@@ -182,6 +224,9 @@
 /// HWAddressSanitizer is on.
 def SanitizeHWAddress : EnumAttr<"sanitize_hwaddress">;
 
+/// MemTagSanitizer is on.
+def SanitizeMemTag : EnumAttr<"sanitize_memtag">;
+
 /// Speculative Load Hardening is enabled.
 ///
 /// Note that this uses the default compatibility (always compatible during
@@ -208,13 +253,19 @@
 /// Zero extended before/after call.
 def ZExt : EnumAttr<"zeroext">;
 
+/// Function is required to make Forward Progress.
+def MustProgress : TypeAttr<"mustprogress">;
+
 /// Target-independent string attributes.
 def LessPreciseFPMAD : StrBoolAttr<"less-precise-fpmad">;
 def NoInfsFPMath : StrBoolAttr<"no-infs-fp-math">;
 def NoNansFPMath : StrBoolAttr<"no-nans-fp-math">;
+def NoSignedZerosFPMath : StrBoolAttr<"no-signed-zeros-fp-math">;
 def UnsafeFPMath : StrBoolAttr<"unsafe-fp-math">;
 def NoJumpTables : StrBoolAttr<"no-jump-tables">;
+def NoInlineLineTables : StrBoolAttr<"no-inline-line-tables">;
 def ProfileSampleAccurate : StrBoolAttr<"profile-sample-accurate">;
+def UseSampleProfile : StrBoolAttr<"use-sample-profile">;
 
 class CompatRule<string F> {
   // The name of the function called to check the attribute of the caller and
@@ -230,8 +281,10 @@
 def : CompatRule<"isEqual<SanitizeThreadAttr>">;
 def : CompatRule<"isEqual<SanitizeMemoryAttr>">;
 def : CompatRule<"isEqual<SanitizeHWAddressAttr>">;
+def : CompatRule<"isEqual<SanitizeMemTagAttr>">;
 def : CompatRule<"isEqual<SafeStackAttr>">;
 def : CompatRule<"isEqual<ShadowCallStackAttr>">;
+def : CompatRule<"isEqual<UseSampleProfileAttr>">;
 
 class MergeRule<string F> {
   // The name of the function called to merge the attributes of the caller and
@@ -245,6 +298,7 @@
 def : MergeRule<"setAND<LessPreciseFPMADAttr>">;
 def : MergeRule<"setAND<NoInfsFPMathAttr>">;
 def : MergeRule<"setAND<NoNansFPMathAttr>">;
+def : MergeRule<"setAND<NoSignedZerosFPMathAttr>">;
 def : MergeRule<"setAND<UnsafeFPMathAttr>">;
 def : MergeRule<"setOR<NoImplicitFloatAttr>">;
 def : MergeRule<"setOR<NoJumpTablesAttr>">;
@@ -255,3 +309,4 @@
 def : MergeRule<"adjustCallerStackProbeSize">;
 def : MergeRule<"adjustMinLegalVectorWidth">;
 def : MergeRule<"adjustNullPointerValidAttr">;
+def : MergeRule<"setAND<MustProgressAttr>">;
diff --git a/linux-x64/clang/include/llvm/IR/AutoUpgrade.h b/linux-x64/clang/include/llvm/IR/AutoUpgrade.h
index 017ad93..f331fc3 100644
--- a/linux-x64/clang/include/llvm/IR/AutoUpgrade.h
+++ b/linux-x64/clang/include/llvm/IR/AutoUpgrade.h
@@ -16,6 +16,7 @@
 #include "llvm/ADT/StringRef.h"
 
 namespace llvm {
+  class AttrBuilder;
   class CallInst;
   class Constant;
   class Function;
@@ -54,12 +55,15 @@
   /// module is modified.
   bool UpgradeModuleFlags(Module &M);
 
-  /// This checks for objc retain release marker which should be upgraded. It
-  /// returns true if module is modified.
-  bool UpgradeRetainReleaseMarker(Module &M);
+  /// Convert calls to ARC runtime functions to intrinsic calls and upgrade the
+  /// old retain release marker to new module flag format.
+  void UpgradeARCRuntime(Module &M);
 
   void UpgradeSectionAttributes(Module &M);
 
+  /// Correct any IR that is relying on old function attribute behavior.
+  void UpgradeFunctionAttributes(Function &F);
+
   /// If the given TBAA tag uses the scalar TBAA format, create a new node
   /// corresponding to the upgrade to the struct-path aware TBAA format.
   /// Otherwise return the \p TBAANode itself.
@@ -87,6 +91,13 @@
   /// Upgrade the loop attachment metadata node.
   MDNode *upgradeInstructionLoopAttachment(MDNode &N);
 
+  /// Upgrade the datalayout string by adding a section for address space
+  /// pointers.
+  std::string UpgradeDataLayoutString(StringRef DL, StringRef Triple);
+
+  /// Upgrade attributes that changed format or kind.
+  void UpgradeAttributes(AttrBuilder &B);
+
 } // End llvm namespace
 
 #endif
diff --git a/linux-x64/clang/include/llvm/IR/BasicBlock.h b/linux-x64/clang/include/llvm/IR/BasicBlock.h
index 69555af..b86bb16 100644
--- a/linux-x64/clang/include/llvm/IR/BasicBlock.h
+++ b/linux-x64/clang/include/llvm/IR/BasicBlock.h
@@ -31,6 +31,7 @@
 
 namespace llvm {
 
+class AssemblyAnnotationWriter;
 class CallInst;
 class Function;
 class LandingPadInst;
@@ -133,6 +134,15 @@
          static_cast<const BasicBlock *>(this)->getTerminatingDeoptimizeCall());
   }
 
+  /// Returns the call instruction calling \@llvm.experimental.deoptimize
+  /// that is present either in current basic block or in block that is a unique
+  /// successor to current block, if such call is present. Otherwise, returns null.
+  const CallInst *getPostdominatingDeoptimizeCall() const;
+  CallInst *getPostdominatingDeoptimizeCall() {
+    return const_cast<CallInst *>(
+         static_cast<const BasicBlock *>(this)->getPostdominatingDeoptimizeCall());
+  }
+
   /// Returns the call instruction marked 'musttail' prior to the terminating
   /// return instruction of this basic block, if such a call is present.
   /// Otherwise, returns null.
@@ -155,19 +165,24 @@
   }
 
   /// Returns a pointer to the first instruction in this block that is not a
-  /// PHINode or a debug intrinsic.
-  const Instruction* getFirstNonPHIOrDbg() const;
-  Instruction* getFirstNonPHIOrDbg() {
+  /// PHINode or a debug intrinsic, or any pseudo operation if \c SkipPseudoOp
+  /// is true.
+  const Instruction *getFirstNonPHIOrDbg(bool SkipPseudoOp = false) const;
+  Instruction *getFirstNonPHIOrDbg(bool SkipPseudoOp = false) {
     return const_cast<Instruction *>(
-                  static_cast<const BasicBlock *>(this)->getFirstNonPHIOrDbg());
+        static_cast<const BasicBlock *>(this)->getFirstNonPHIOrDbg(
+            SkipPseudoOp));
   }
 
   /// Returns a pointer to the first instruction in this block that is not a
-  /// PHINode, a debug intrinsic, or a lifetime intrinsic.
-  const Instruction* getFirstNonPHIOrDbgOrLifetime() const;
-  Instruction* getFirstNonPHIOrDbgOrLifetime() {
+  /// PHINode, a debug intrinsic, or a lifetime intrinsic, or any pseudo
+  /// operation if \c SkipPseudoOp is true.
+  const Instruction *
+  getFirstNonPHIOrDbgOrLifetime(bool SkipPseudoOp = false) const;
+  Instruction *getFirstNonPHIOrDbgOrLifetime(bool SkipPseudoOp = false) {
     return const_cast<Instruction *>(
-        static_cast<const BasicBlock *>(this)->getFirstNonPHIOrDbgOrLifetime());
+        static_cast<const BasicBlock *>(this)->getFirstNonPHIOrDbgOrLifetime(
+            SkipPseudoOp));
   }
 
   /// Returns an iterator to the first instruction in this block that is
@@ -181,16 +196,23 @@
   }
 
   /// Return a const iterator range over the instructions in the block, skipping
-  /// any debug instructions.
+  /// any debug instructions. Skip any pseudo operations as well if \c
+  /// SkipPseudoOp is true.
   iterator_range<filter_iterator<BasicBlock::const_iterator,
                                  std::function<bool(const Instruction &)>>>
-  instructionsWithoutDebug() const;
+  instructionsWithoutDebug(bool SkipPseudoOp = false) const;
 
   /// Return an iterator range over the instructions in the block, skipping any
-  /// debug instructions.
-  iterator_range<filter_iterator<BasicBlock::iterator,
-                                 std::function<bool(Instruction &)>>>
-  instructionsWithoutDebug();
+  /// debug instructions. Skip and any pseudo operations as well if \c
+  /// SkipPseudoOp is true.
+  iterator_range<
+      filter_iterator<BasicBlock::iterator, std::function<bool(Instruction &)>>>
+  instructionsWithoutDebug(bool SkipPseudoOp = false);
+
+  /// Return the size of the basic block ignoring debug instructions
+  filter_iterator<BasicBlock::const_iterator,
+                  std::function<bool(const Instruction &)>>::difference_type
+  sizeWithoutDebug() const;
 
   /// Unlink 'this' from the containing function, but do not delete it.
   void removeFromParent();
@@ -262,6 +284,12 @@
                    static_cast<const BasicBlock *>(this)->getUniqueSuccessor());
   }
 
+  /// Print the basic block to an output stream with an optional
+  /// AssemblyAnnotationWriter.
+  void print(raw_ostream &OS, AssemblyAnnotationWriter *AAW = nullptr,
+             bool ShouldPreserveUseListOrder = false,
+             bool IsForDebug = false) const;
+
   //===--------------------------------------------------------------------===//
   /// Instruction iterator methods
   ///
@@ -299,7 +327,9 @@
     phi_iterator_impl() = default;
 
     // Allow conversion between instantiations where valid.
-    template <typename PHINodeU, typename BBIteratorU>
+    template <typename PHINodeU, typename BBIteratorU,
+              typename = std::enable_if_t<
+                  std::is_convertible<PHINodeU *, PHINodeT *>::value>>
     phi_iterator_impl(const phi_iterator_impl<PHINodeU, BBIteratorU> &Arg)
         : PN(Arg.PN) {}
 
@@ -356,39 +386,68 @@
   /// except operator delete.
   void dropAllReferences();
 
-  /// Notify the BasicBlock that the predecessor \p Pred is no longer able to
-  /// reach it.
+  /// Update PHI nodes in this BasicBlock before removal of predecessor \p Pred.
+  /// Note that this function does not actually remove the predecessor.
   ///
-  /// This is actually not used to update the Predecessor list, but is actually
-  /// used to update the PHI nodes that reside in the block.  Note that this
-  /// should be called while the predecessor still refers to this block.
+  /// If \p KeepOneInputPHIs is true then don't remove PHIs that are left with
+  /// zero or one incoming values, and don't simplify PHIs with all incoming
+  /// values the same.
   void removePredecessor(BasicBlock *Pred, bool KeepOneInputPHIs = false);
 
   bool canSplitPredecessors() const;
 
   /// Split the basic block into two basic blocks at the specified instruction.
   ///
-  /// Note that all instructions BEFORE the specified iterator stay as part of
-  /// the original basic block, an unconditional branch is added to the original
-  /// BB, and the rest of the instructions in the BB are moved to the new BB,
-  /// including the old terminator.  The newly formed BasicBlock is returned.
-  /// This function invalidates the specified iterator.
+  /// If \p Before is true, splitBasicBlockBefore handles the
+  /// block splitting. Otherwise, execution proceeds as described below.
+  ///
+  /// Note that all instructions BEFORE the specified iterator
+  /// stay as part of the original basic block, an unconditional branch is added
+  /// to the original BB, and the rest of the instructions in the BB are moved
+  /// to the new BB, including the old terminator.  The newly formed basic block
+  /// is returned. This function invalidates the specified iterator.
   ///
   /// Note that this only works on well formed basic blocks (must have a
-  /// terminator), and 'I' must not be the end of instruction list (which would
-  /// cause a degenerate basic block to be formed, having a terminator inside of
-  /// the basic block).
+  /// terminator), and \p 'I' must not be the end of instruction list (which
+  /// would cause a degenerate basic block to be formed, having a terminator
+  /// inside of the basic block).
   ///
   /// Also note that this doesn't preserve any passes. To split blocks while
   /// keeping loop information consistent, use the SplitBlock utility function.
-  BasicBlock *splitBasicBlock(iterator I, const Twine &BBName = "");
-  BasicBlock *splitBasicBlock(Instruction *I, const Twine &BBName = "") {
-    return splitBasicBlock(I->getIterator(), BBName);
+  BasicBlock *splitBasicBlock(iterator I, const Twine &BBName = "",
+                              bool Before = false);
+  BasicBlock *splitBasicBlock(Instruction *I, const Twine &BBName = "",
+                              bool Before = false) {
+    return splitBasicBlock(I->getIterator(), BBName, Before);
+  }
+
+  /// Split the basic block into two basic blocks at the specified instruction
+  /// and insert the new basic blocks as the predecessor of the current block.
+  ///
+  /// This function ensures all instructions AFTER and including the specified
+  /// iterator \p I are part of the original basic block. All Instructions
+  /// BEFORE the iterator \p I are moved to the new BB and an unconditional
+  /// branch is added to the new BB. The new basic block is returned.
+  ///
+  /// Note that this only works on well formed basic blocks (must have a
+  /// terminator), and \p 'I' must not be the end of instruction list (which
+  /// would cause a degenerate basic block to be formed, having a terminator
+  /// inside of the basic block).  \p 'I' cannot be a iterator for a PHINode
+  /// with multiple incoming blocks.
+  ///
+  /// Also note that this doesn't preserve any passes. To split blocks while
+  /// keeping loop information consistent, use the SplitBlockBefore utility
+  /// function.
+  BasicBlock *splitBasicBlockBefore(iterator I, const Twine &BBName = "");
+  BasicBlock *splitBasicBlockBefore(Instruction *I, const Twine &BBName = "") {
+    return splitBasicBlockBefore(I->getIterator(), BBName);
   }
 
   /// Returns true if there are any uses of this basic block other than
   /// direct branches, switches, etc. to it.
-  bool hasAddressTaken() const { return getSubclassDataFromValue() != 0; }
+  bool hasAddressTaken() const {
+    return getBasicBlockBits().BlockAddressRefCount != 0;
+  }
 
   /// Update all phi nodes in this basic block to refer to basic block \p New
   /// instead of basic block \p Old.
@@ -423,16 +482,81 @@
 
   Optional<uint64_t> getIrrLoopHeaderWeight() const;
 
+  /// Returns true if the Order field of child Instructions is valid.
+  bool isInstrOrderValid() const {
+    return getBasicBlockBits().InstrOrderValid;
+  }
+
+  /// Mark instruction ordering invalid. Done on every instruction insert.
+  void invalidateOrders() {
+    validateInstrOrdering();
+    BasicBlockBits Bits = getBasicBlockBits();
+    Bits.InstrOrderValid = false;
+    setBasicBlockBits(Bits);
+  }
+
+  /// Renumber instructions and mark the ordering as valid.
+  void renumberInstructions();
+
+  /// Asserts that instruction order numbers are marked invalid, or that they
+  /// are in ascending order. This is constant time if the ordering is invalid,
+  /// and linear in the number of instructions if the ordering is valid. Callers
+  /// should be careful not to call this in ways that make common operations
+  /// O(n^2). For example, it takes O(n) time to assign order numbers to
+  /// instructions, so the order should be validated no more than once after
+  /// each ordering to ensure that transforms have the same algorithmic
+  /// complexity when asserts are enabled as when they are disabled.
+  void validateInstrOrdering() const;
+
 private:
+#if defined(_AIX) && (!defined(__GNUC__) || defined(__ibmxl__))
+// Except for GCC; by default, AIX compilers store bit-fields in 4-byte words
+// and give the `pack` pragma push semantics.
+#define BEGIN_TWO_BYTE_PACK() _Pragma("pack(2)")
+#define END_TWO_BYTE_PACK() _Pragma("pack(pop)")
+#else
+#define BEGIN_TWO_BYTE_PACK()
+#define END_TWO_BYTE_PACK()
+#endif
+
+  BEGIN_TWO_BYTE_PACK()
+  /// Bitfield to help interpret the bits in Value::SubclassData.
+  struct BasicBlockBits {
+    unsigned short BlockAddressRefCount : 15;
+    unsigned short InstrOrderValid : 1;
+  };
+  END_TWO_BYTE_PACK()
+
+#undef BEGIN_TWO_BYTE_PACK
+#undef END_TWO_BYTE_PACK
+
+  /// Safely reinterpret the subclass data bits to a more useful form.
+  BasicBlockBits getBasicBlockBits() const {
+    static_assert(sizeof(BasicBlockBits) == sizeof(unsigned short),
+                  "too many bits for Value::SubclassData");
+    unsigned short ValueData = getSubclassDataFromValue();
+    BasicBlockBits AsBits;
+    memcpy(&AsBits, &ValueData, sizeof(AsBits));
+    return AsBits;
+  }
+
+  /// Reinterpret our subclass bits and store them back into Value.
+  void setBasicBlockBits(BasicBlockBits AsBits) {
+    unsigned short D;
+    memcpy(&D, &AsBits, sizeof(D));
+    Value::setValueSubclassData(D);
+  }
+
   /// Increment the internal refcount of the number of BlockAddresses
   /// referencing this BasicBlock by \p Amt.
   ///
   /// This is almost always 0, sometimes one possibly, but almost never 2, and
   /// inconceivably 3 or more.
   void AdjustBlockAddressRefCount(int Amt) {
-    setValueSubclassData(getSubclassDataFromValue()+Amt);
-    assert((int)(signed char)getSubclassDataFromValue() >= 0 &&
-           "Refcount wrap-around");
+    BasicBlockBits Bits = getBasicBlockBits();
+    Bits.BlockAddressRefCount += Amt;
+    setBasicBlockBits(Bits);
+    assert(Bits.BlockAddressRefCount < 255 && "Refcount wrap-around");
   }
 
   /// Shadow Value::setValueSubclassData with a private forwarding method so
@@ -449,6 +573,12 @@
 /// This assumes that \p It is not at the end of a block.
 BasicBlock::iterator skipDebugIntrinsics(BasicBlock::iterator It);
 
+#ifdef NDEBUG
+/// In release builds, this is a no-op. For !NDEBUG builds, the checks are
+/// implemented in the .cpp file to avoid circular header deps.
+inline void BasicBlock::validateInstrOrdering() const {}
+#endif
+
 } // end namespace llvm
 
 #endif // LLVM_IR_BASICBLOCK_H
diff --git a/linux-x64/clang/include/llvm/IR/CFG.h b/linux-x64/clang/include/llvm/IR/CFG.h
index 55aff71..f798b1a 100644
--- a/linux-x64/clang/include/llvm/IR/CFG.h
+++ b/linux-x64/clang/include/llvm/IR/CFG.h
@@ -22,18 +22,19 @@
 #include "llvm/ADT/GraphTraits.h"
 #include "llvm/ADT/iterator.h"
 #include "llvm/ADT/iterator_range.h"
-#include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/Function.h"
-#include "llvm/IR/InstrTypes.h"
 #include "llvm/IR/Value.h"
 #include "llvm/Support/Casting.h"
-#include "llvm/Support/type_traits.h"
 #include <cassert>
 #include <cstddef>
 #include <iterator>
 
 namespace llvm {
 
+class BasicBlock;
+class Instruction;
+class Use;
+
 //===----------------------------------------------------------------------===//
 // BasicBlock pred_iterator definition
 //===----------------------------------------------------------------------===//
@@ -103,7 +104,7 @@
 using const_pred_iterator =
     PredIterator<const BasicBlock, Value::const_user_iterator>;
 using pred_range = iterator_range<pred_iterator>;
-using pred_const_range = iterator_range<const_pred_iterator>;
+using const_pred_range = iterator_range<const_pred_iterator>;
 
 inline pred_iterator pred_begin(BasicBlock *BB) { return pred_iterator(BB); }
 inline const_pred_iterator pred_begin(const BasicBlock *BB) {
@@ -124,8 +125,8 @@
 inline pred_range predecessors(BasicBlock *BB) {
   return pred_range(pred_begin(BB), pred_end(BB));
 }
-inline pred_const_range predecessors(const BasicBlock *BB) {
-  return pred_const_range(pred_begin(BB), pred_end(BB));
+inline const_pred_range predecessors(const BasicBlock *BB) {
+  return const_pred_range(pred_begin(BB), pred_end(BB));
 }
 
 //===----------------------------------------------------------------------===//
@@ -238,17 +239,17 @@
 };
 
 using succ_iterator = SuccIterator<Instruction, BasicBlock>;
-using succ_const_iterator = SuccIterator<const Instruction, const BasicBlock>;
+using const_succ_iterator = SuccIterator<const Instruction, const BasicBlock>;
 using succ_range = iterator_range<succ_iterator>;
-using succ_const_range = iterator_range<succ_const_iterator>;
+using const_succ_range = iterator_range<const_succ_iterator>;
 
 inline succ_iterator succ_begin(Instruction *I) { return succ_iterator(I); }
-inline succ_const_iterator succ_begin(const Instruction *I) {
-  return succ_const_iterator(I);
+inline const_succ_iterator succ_begin(const Instruction *I) {
+  return const_succ_iterator(I);
 }
 inline succ_iterator succ_end(Instruction *I) { return succ_iterator(I, true); }
-inline succ_const_iterator succ_end(const Instruction *I) {
-  return succ_const_iterator(I, true);
+inline const_succ_iterator succ_end(const Instruction *I) {
+  return const_succ_iterator(I, true);
 }
 inline bool succ_empty(const Instruction *I) {
   return succ_begin(I) == succ_end(I);
@@ -259,21 +260,21 @@
 inline succ_range successors(Instruction *I) {
   return succ_range(succ_begin(I), succ_end(I));
 }
-inline succ_const_range successors(const Instruction *I) {
-  return succ_const_range(succ_begin(I), succ_end(I));
+inline const_succ_range successors(const Instruction *I) {
+  return const_succ_range(succ_begin(I), succ_end(I));
 }
 
 inline succ_iterator succ_begin(BasicBlock *BB) {
   return succ_iterator(BB->getTerminator());
 }
-inline succ_const_iterator succ_begin(const BasicBlock *BB) {
-  return succ_const_iterator(BB->getTerminator());
+inline const_succ_iterator succ_begin(const BasicBlock *BB) {
+  return const_succ_iterator(BB->getTerminator());
 }
 inline succ_iterator succ_end(BasicBlock *BB) {
   return succ_iterator(BB->getTerminator(), true);
 }
-inline succ_const_iterator succ_end(const BasicBlock *BB) {
-  return succ_const_iterator(BB->getTerminator(), true);
+inline const_succ_iterator succ_end(const BasicBlock *BB) {
+  return const_succ_iterator(BB->getTerminator(), true);
 }
 inline bool succ_empty(const BasicBlock *BB) {
   return succ_begin(BB) == succ_end(BB);
@@ -284,8 +285,8 @@
 inline succ_range successors(BasicBlock *BB) {
   return succ_range(succ_begin(BB), succ_end(BB));
 }
-inline succ_const_range successors(const BasicBlock *BB) {
-  return succ_const_range(succ_begin(BB), succ_end(BB));
+inline const_succ_range successors(const BasicBlock *BB) {
+  return const_succ_range(succ_begin(BB), succ_end(BB));
 }
 
 //===--------------------------------------------------------------------===//
@@ -306,7 +307,7 @@
 
 template <> struct GraphTraits<const BasicBlock*> {
   using NodeRef = const BasicBlock *;
-  using ChildIteratorType = succ_const_iterator;
+  using ChildIteratorType = const_succ_iterator;
 
   static NodeRef getEntryNode(const BasicBlock *BB) { return BB; }
 
diff --git a/linux-x64/clang/include/llvm/IR/CFGDiff.h b/linux-x64/clang/include/llvm/IR/CFGDiff.h
deleted file mode 100644
index 57b62dd..0000000
--- a/linux-x64/clang/include/llvm/IR/CFGDiff.h
+++ /dev/null
@@ -1,284 +0,0 @@
-//===- CFGDiff.h - Define a CFG snapshot. -----------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// This file defines specializations of GraphTraits that allows generic
-// algorithms to see a different snapshot of a CFG.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_IR_CFGDIFF_H
-#define LLVM_IR_CFGDIFF_H
-
-#include "llvm/ADT/GraphTraits.h"
-#include "llvm/ADT/iterator.h"
-#include "llvm/ADT/iterator_range.h"
-#include "llvm/IR/BasicBlock.h"
-#include "llvm/IR/CFG.h"
-#include "llvm/Support/CFGUpdate.h"
-#include "llvm/Support/type_traits.h"
-#include <cassert>
-#include <cstddef>
-#include <iterator>
-
-// Two booleans are used to define orders in graphs:
-// InverseGraph defines when we need to reverse the whole graph and is as such
-// also equivalent to applying updates in reverse.
-// InverseEdge defines whether we want to change the edges direction. E.g., for
-// a non-inversed graph, the children are naturally the successors when
-// InverseEdge is false and the predecessors when InverseEdge is true.
-
-// We define two base clases that call into GraphDiff, one for successors
-// (CFGSuccessors), where InverseEdge is false, and one for predecessors
-// (CFGPredecessors), where InverseEdge is true.
-// FIXME: Further refactoring may merge the two base classes into a single one
-// templated / parametrized on using succ_iterator/pred_iterator and false/true
-// for the InverseEdge.
-
-// CFGViewSuccessors and CFGViewPredecessors, both can be parametrized to
-// consider the graph inverted or not (i.e. InverseGraph). Successors
-// implicitly has InverseEdge = false and Predecessors implicitly has
-// InverseEdge = true (see calls to GraphDiff methods in there). The GraphTraits
-// instantiations that follow define the value of InverseGraph.
-
-// GraphTraits instantiations:
-// - GraphDiff<BasicBlock *> is equivalent to InverseGraph = false
-// - GraphDiff<Inverse<BasicBlock *>> is equivalent to InverseGraph = true
-// - second pair item is BasicBlock *, then InverseEdge = false (so it inherits
-// from CFGViewSuccessors).
-// - second pair item is Inverse<BasicBlock *>, then InverseEdge = true (so it
-// inherits from CFGViewPredecessors).
-
-// The 4 GraphTraits are as follows:
-// 1. std::pair<const GraphDiff<BasicBlock *> *, BasicBlock *>> :
-//        CFGViewSuccessors<false>
-// Regular CFG, children means successors, InverseGraph = false,
-// InverseEdge = false.
-// 2. std::pair<const GraphDiff<Inverse<BasicBlock *>> *, BasicBlock *>> :
-//        CFGViewSuccessors<true>
-// Reverse the graph, get successors but reverse-apply updates,
-// InverseGraph = true, InverseEdge = false.
-// 3. std::pair<const GraphDiff<BasicBlock *> *, Inverse<BasicBlock *>>> :
-//        CFGViewPredecessors<false>
-// Regular CFG, reverse edges, so children mean predecessors,
-// InverseGraph = false, InverseEdge = true.
-// 4. std::pair<const GraphDiff<Inverse<BasicBlock *>> *, Inverse<BasicBlock *>>
-//        : CFGViewPredecessors<true>
-// Reverse the graph and the edges, InverseGraph = true, InverseEdge = true.
-
-namespace llvm {
-
-// GraphDiff defines a CFG snapshot: given a set of Update<NodePtr>, provide
-// utilities to skip edges marked as deleted and return a set of edges marked as
-// newly inserted. The current diff treats the CFG as a graph rather than a
-// multigraph. Added edges are pruned to be unique, and deleted edges will
-// remove all existing edges between two blocks.
-template <typename NodePtr, bool InverseGraph = false> class GraphDiff {
-  using UpdateMapType = SmallDenseMap<NodePtr, SmallVector<NodePtr, 2>>;
-  UpdateMapType SuccInsert;
-  UpdateMapType SuccDelete;
-  UpdateMapType PredInsert;
-  UpdateMapType PredDelete;
-  // Using a singleton empty vector for all BasicBlock requests with no
-  // children.
-  SmallVector<NodePtr, 1> Empty;
-
-  void printMap(raw_ostream &OS, const UpdateMapType &M) const {
-    for (auto Pair : M)
-      for (auto Child : Pair.second) {
-        OS << "(";
-        Pair.first->printAsOperand(OS, false);
-        OS << ", ";
-        Child->printAsOperand(OS, false);
-        OS << ") ";
-      }
-    OS << "\n";
-  }
-
-public:
-  GraphDiff() {}
-  GraphDiff(ArrayRef<cfg::Update<NodePtr>> Updates) {
-    SmallVector<cfg::Update<NodePtr>, 4> LegalizedUpdates;
-    cfg::LegalizeUpdates<NodePtr>(Updates, LegalizedUpdates, InverseGraph);
-    for (auto U : LegalizedUpdates) {
-      if (U.getKind() == cfg::UpdateKind::Insert) {
-        SuccInsert[U.getFrom()].push_back(U.getTo());
-        PredInsert[U.getTo()].push_back(U.getFrom());
-      } else {
-        SuccDelete[U.getFrom()].push_back(U.getTo());
-        PredDelete[U.getTo()].push_back(U.getFrom());
-      }
-    }
-  }
-
-  bool ignoreChild(const NodePtr BB, NodePtr EdgeEnd, bool InverseEdge) const {
-    auto &DeleteChildren =
-        (InverseEdge != InverseGraph) ? PredDelete : SuccDelete;
-    auto It = DeleteChildren.find(BB);
-    if (It == DeleteChildren.end())
-      return false;
-    auto &EdgesForBB = It->second;
-    return llvm::find(EdgesForBB, EdgeEnd) != EdgesForBB.end();
-  }
-
-  iterator_range<typename SmallVectorImpl<NodePtr>::const_iterator>
-  getAddedChildren(const NodePtr BB, bool InverseEdge) const {
-    auto &InsertChildren =
-        (InverseEdge != InverseGraph) ? PredInsert : SuccInsert;
-    auto It = InsertChildren.find(BB);
-    if (It == InsertChildren.end())
-      return make_range(Empty.begin(), Empty.end());
-    return make_range(It->second.begin(), It->second.end());
-  }
-
-  void print(raw_ostream &OS) const {
-    OS << "===== GraphDiff: CFG edge changes to create a CFG snapshot. \n"
-          "===== (Note: notion of children/inverse_children depends on "
-          "the direction of edges and the graph.)\n";
-    OS << "Children to insert:\n\t";
-    printMap(OS, SuccInsert);
-    OS << "Children to delete:\n\t";
-    printMap(OS, SuccDelete);
-    OS << "Inverse_children to insert:\n\t";
-    printMap(OS, PredInsert);
-    OS << "Inverse_children to delete:\n\t";
-    printMap(OS, PredDelete);
-    OS << "\n";
-  }
-
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-  LLVM_DUMP_METHOD void dump() const { print(dbgs()); }
-#endif
-};
-
-template <bool InverseGraph = false> struct CFGViewSuccessors {
-  using DataRef = const GraphDiff<BasicBlock *, InverseGraph> *;
-  using NodeRef = std::pair<DataRef, BasicBlock *>;
-
-  using ExistingChildIterator =
-      WrappedPairNodeDataIterator<succ_iterator, NodeRef, DataRef>;
-  struct DeletedEdgesFilter {
-    BasicBlock *BB;
-    DeletedEdgesFilter(BasicBlock *BB) : BB(BB){};
-    bool operator()(NodeRef N) const {
-      return !N.first->ignoreChild(BB, N.second, false);
-    }
-  };
-  using FilterExistingChildrenIterator =
-      filter_iterator<ExistingChildIterator, DeletedEdgesFilter>;
-
-  using vec_iterator = SmallVectorImpl<BasicBlock *>::const_iterator;
-  using AddNewChildrenIterator =
-      WrappedPairNodeDataIterator<vec_iterator, NodeRef, DataRef>;
-  using ChildIteratorType =
-      concat_iterator<NodeRef, FilterExistingChildrenIterator,
-                      AddNewChildrenIterator>;
-
-  static ChildIteratorType child_begin(NodeRef N) {
-    auto InsertVec = N.first->getAddedChildren(N.second, false);
-    // filter iterator init:
-    auto firstit = make_filter_range(
-        make_range<ExistingChildIterator>({succ_begin(N.second), N.first},
-                                          {succ_end(N.second), N.first}),
-        DeletedEdgesFilter(N.second));
-    // new inserts iterator init:
-    auto secondit = make_range<AddNewChildrenIterator>(
-        {InsertVec.begin(), N.first}, {InsertVec.end(), N.first});
-
-    return concat_iterator<NodeRef, FilterExistingChildrenIterator,
-                           AddNewChildrenIterator>(firstit, secondit);
-  }
-
-  static ChildIteratorType child_end(NodeRef N) {
-    auto InsertVec = N.first->getAddedChildren(N.second, false);
-    // filter iterator init:
-    auto firstit = make_filter_range(
-        make_range<ExistingChildIterator>({succ_end(N.second), N.first},
-                                          {succ_end(N.second), N.first}),
-        DeletedEdgesFilter(N.second));
-    // new inserts iterator init:
-    auto secondit = make_range<AddNewChildrenIterator>(
-        {InsertVec.end(), N.first}, {InsertVec.end(), N.first});
-
-    return concat_iterator<NodeRef, FilterExistingChildrenIterator,
-                           AddNewChildrenIterator>(firstit, secondit);
-  }
-};
-
-template <bool InverseGraph = false> struct CFGViewPredecessors {
-  using DataRef = const GraphDiff<BasicBlock *, InverseGraph> *;
-  using NodeRef = std::pair<DataRef, BasicBlock *>;
-
-  using ExistingChildIterator =
-      WrappedPairNodeDataIterator<pred_iterator, NodeRef, DataRef>;
-  struct DeletedEdgesFilter {
-    BasicBlock *BB;
-    DeletedEdgesFilter(BasicBlock *BB) : BB(BB){};
-    bool operator()(NodeRef N) const {
-      return !N.first->ignoreChild(BB, N.second, true);
-    }
-  };
-  using FilterExistingChildrenIterator =
-      filter_iterator<ExistingChildIterator, DeletedEdgesFilter>;
-
-  using vec_iterator = SmallVectorImpl<BasicBlock *>::const_iterator;
-  using AddNewChildrenIterator =
-      WrappedPairNodeDataIterator<vec_iterator, NodeRef, DataRef>;
-  using ChildIteratorType =
-      concat_iterator<NodeRef, FilterExistingChildrenIterator,
-                      AddNewChildrenIterator>;
-
-  static ChildIteratorType child_begin(NodeRef N) {
-    auto InsertVec = N.first->getAddedChildren(N.second, true);
-    // filter iterator init:
-    auto firstit = make_filter_range(
-        make_range<ExistingChildIterator>({pred_begin(N.second), N.first},
-                                          {pred_end(N.second), N.first}),
-        DeletedEdgesFilter(N.second));
-    // new inserts iterator init:
-    auto secondit = make_range<AddNewChildrenIterator>(
-        {InsertVec.begin(), N.first}, {InsertVec.end(), N.first});
-
-    return concat_iterator<NodeRef, FilterExistingChildrenIterator,
-                           AddNewChildrenIterator>(firstit, secondit);
-  }
-
-  static ChildIteratorType child_end(NodeRef N) {
-    auto InsertVec = N.first->getAddedChildren(N.second, true);
-    // filter iterator init:
-    auto firstit = make_filter_range(
-        make_range<ExistingChildIterator>({pred_end(N.second), N.first},
-                                          {pred_end(N.second), N.first}),
-        DeletedEdgesFilter(N.second));
-    // new inserts iterator init:
-    auto secondit = make_range<AddNewChildrenIterator>(
-        {InsertVec.end(), N.first}, {InsertVec.end(), N.first});
-
-    return concat_iterator<NodeRef, FilterExistingChildrenIterator,
-                           AddNewChildrenIterator>(firstit, secondit);
-  }
-};
-
-template <>
-struct GraphTraits<
-    std::pair<const GraphDiff<BasicBlock *, false> *, BasicBlock *>>
-    : CFGViewSuccessors<false> {};
-template <>
-struct GraphTraits<
-    std::pair<const GraphDiff<BasicBlock *, true> *, BasicBlock *>>
-    : CFGViewSuccessors<true> {};
-template <>
-struct GraphTraits<
-    std::pair<const GraphDiff<BasicBlock *, false> *, Inverse<BasicBlock *>>>
-    : CFGViewPredecessors<false> {};
-template <>
-struct GraphTraits<
-    std::pair<const GraphDiff<BasicBlock *, true> *, Inverse<BasicBlock *>>>
-    : CFGViewPredecessors<true> {};
-} // end namespace llvm
-
-#endif // LLVM_IR_CFGDIFF_H
diff --git a/linux-x64/clang/include/llvm/IR/CallSite.h b/linux-x64/clang/include/llvm/IR/CallSite.h
deleted file mode 100644
index b47a96c..0000000
--- a/linux-x64/clang/include/llvm/IR/CallSite.h
+++ /dev/null
@@ -1,910 +0,0 @@
-//===- CallSite.h - Abstract Call & Invoke instrs ---------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// This file defines the CallSite class, which is a handy wrapper for code that
-// wants to treat Call, Invoke and CallBr instructions in a generic way. When
-// in non-mutation context (e.g. an analysis) ImmutableCallSite should be used.
-// Finally, when some degree of customization is necessary between these two
-// extremes, CallSiteBase<> can be supplied with fine-tuned parameters.
-//
-// NOTE: These classes are supposed to have "value semantics". So they should be
-// passed by value, not by reference; they should not be "new"ed or "delete"d.
-// They are efficiently copyable, assignable and constructable, with cost
-// equivalent to copying a pointer (notice that they have only a single data
-// member). The internal representation carries a flag which indicates which of
-// the three variants is enclosed. This allows for cheaper checks when various
-// accessors of CallSite are employed.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_IR_CALLSITE_H
-#define LLVM_IR_CALLSITE_H
-
-#include "llvm/ADT/Optional.h"
-#include "llvm/ADT/PointerIntPair.h"
-#include "llvm/ADT/iterator_range.h"
-#include "llvm/IR/Attributes.h"
-#include "llvm/IR/CallingConv.h"
-#include "llvm/IR/Function.h"
-#include "llvm/IR/InstrTypes.h"
-#include "llvm/IR/Instruction.h"
-#include "llvm/IR/Instructions.h"
-#include "llvm/IR/Use.h"
-#include "llvm/IR/User.h"
-#include "llvm/IR/Value.h"
-#include "llvm/Support/Casting.h"
-#include <cassert>
-#include <cstdint>
-#include <iterator>
-
-namespace llvm {
-
-namespace Intrinsic {
-enum ID : unsigned;
-}
-
-template <typename FunTy = const Function, typename BBTy = const BasicBlock,
-          typename ValTy = const Value, typename UserTy = const User,
-          typename UseTy = const Use, typename InstrTy = const Instruction,
-          typename CallTy = const CallInst,
-          typename InvokeTy = const InvokeInst,
-          typename CallBrTy = const CallBrInst,
-          typename IterTy = User::const_op_iterator>
-class CallSiteBase {
-protected:
-  PointerIntPair<InstrTy *, 2, int> I;
-
-  CallSiteBase() = default;
-  CallSiteBase(CallTy *CI) : I(CI, 1) { assert(CI); }
-  CallSiteBase(InvokeTy *II) : I(II, 0) { assert(II); }
-  CallSiteBase(CallBrTy *CBI) : I(CBI, 2) { assert(CBI); }
-  explicit CallSiteBase(ValTy *II) { *this = get(II); }
-
-private:
-  /// This static method is like a constructor. It will create an appropriate
-  /// call site for a Call, Invoke or CallBr instruction, but it can also create
-  /// a null initialized CallSiteBase object for something which is NOT a call
-  /// site.
-  static CallSiteBase get(ValTy *V) {
-    if (InstrTy *II = dyn_cast<InstrTy>(V)) {
-      if (II->getOpcode() == Instruction::Call)
-        return CallSiteBase(static_cast<CallTy*>(II));
-      if (II->getOpcode() == Instruction::Invoke)
-        return CallSiteBase(static_cast<InvokeTy*>(II));
-      if (II->getOpcode() == Instruction::CallBr)
-        return CallSiteBase(static_cast<CallBrTy *>(II));
-    }
-    return CallSiteBase();
-  }
-
-public:
-  /// Return true if a CallInst is enclosed.
-  bool isCall() const { return I.getInt() == 1; }
-
-  /// Return true if a InvokeInst is enclosed. !I.getInt() may also signify a
-  /// NULL instruction pointer, so check that.
-  bool isInvoke() const { return getInstruction() && I.getInt() == 0; }
-
-  /// Return true if a CallBrInst is enclosed.
-  bool isCallBr() const { return I.getInt() == 2; }
-
-  InstrTy *getInstruction() const { return I.getPointer(); }
-  InstrTy *operator->() const { return I.getPointer(); }
-  explicit operator bool() const { return I.getPointer(); }
-
-  /// Get the basic block containing the call site.
-  BBTy* getParent() const { return getInstruction()->getParent(); }
-
-  /// Return the pointer to function that is being called.
-  ValTy *getCalledValue() const {
-    assert(getInstruction() && "Not a call, invoke or callbr instruction!");
-    return *getCallee();
-  }
-
-  /// Return the function being called if this is a direct call, otherwise
-  /// return null (if it's an indirect call).
-  FunTy *getCalledFunction() const {
-    return dyn_cast<FunTy>(getCalledValue());
-  }
-
-  /// Return true if the callsite is an indirect call.
-  bool isIndirectCall() const {
-    const Value *V = getCalledValue();
-    if (!V)
-      return false;
-    if (isa<FunTy>(V) || isa<Constant>(V))
-      return false;
-    if (const CallBase *CB = dyn_cast<CallBase>(getInstruction()))
-      if (CB->isInlineAsm())
-        return false;
-    return true;
-  }
-
-  /// Set the callee to the specified value.  Unlike the function of the same
-  /// name on CallBase, does not modify the type!
-  void setCalledFunction(Value *V) {
-    assert(getInstruction() && "Not a call, callbr, or invoke instruction!");
-    assert(cast<PointerType>(V->getType())->getElementType() ==
-               cast<CallBase>(getInstruction())->getFunctionType() &&
-           "New callee type does not match FunctionType on call");
-    *getCallee() = V;
-  }
-
-  /// Return the intrinsic ID of the intrinsic called by this CallSite,
-  /// or Intrinsic::not_intrinsic if the called function is not an
-  /// intrinsic, or if this CallSite is an indirect call.
-  Intrinsic::ID getIntrinsicID() const {
-    if (auto *F = getCalledFunction())
-      return F->getIntrinsicID();
-    // Don't use Intrinsic::not_intrinsic, as it will require pulling
-    // Intrinsics.h into every header that uses CallSite.
-    return static_cast<Intrinsic::ID>(0);
-  }
-
-  /// Determine whether the passed iterator points to the callee operand's Use.
-  bool isCallee(Value::const_user_iterator UI) const {
-    return isCallee(&UI.getUse());
-  }
-
-  /// Determine whether this Use is the callee operand's Use.
-  bool isCallee(const Use *U) const { return getCallee() == U; }
-
-  /// Determine whether the passed iterator points to an argument operand.
-  bool isArgOperand(Value::const_user_iterator UI) const {
-    return isArgOperand(&UI.getUse());
-  }
-
-  /// Determine whether the passed use points to an argument operand.
-  bool isArgOperand(const Use *U) const {
-    assert(getInstruction() == U->getUser());
-    return arg_begin() <= U && U < arg_end();
-  }
-
-  /// Determine whether the passed iterator points to a bundle operand.
-  bool isBundleOperand(Value::const_user_iterator UI) const {
-    return isBundleOperand(&UI.getUse());
-  }
-
-  /// Determine whether the passed use points to a bundle operand.
-  bool isBundleOperand(const Use *U) const {
-    assert(getInstruction() == U->getUser());
-    if (!hasOperandBundles())
-      return false;
-    unsigned OperandNo = U - (*this)->op_begin();
-    return getBundleOperandsStartIndex() <= OperandNo &&
-           OperandNo < getBundleOperandsEndIndex();
-  }
-
-  /// Determine whether the passed iterator points to a data operand.
-  bool isDataOperand(Value::const_user_iterator UI) const {
-    return isDataOperand(&UI.getUse());
-  }
-
-  /// Determine whether the passed use points to a data operand.
-  bool isDataOperand(const Use *U) const {
-    return data_operands_begin() <= U && U < data_operands_end();
-  }
-
-  ValTy *getArgument(unsigned ArgNo) const {
-    assert(arg_begin() + ArgNo < arg_end() && "Argument # out of range!");
-    return *(arg_begin() + ArgNo);
-  }
-
-  void setArgument(unsigned ArgNo, Value* newVal) {
-    assert(getInstruction() && "Not a call, invoke or callbr instruction!");
-    assert(arg_begin() + ArgNo < arg_end() && "Argument # out of range!");
-    getInstruction()->setOperand(ArgNo, newVal);
-  }
-
-  /// Given a value use iterator, returns the argument that corresponds to it.
-  /// Iterator must actually correspond to an argument.
-  unsigned getArgumentNo(Value::const_user_iterator I) const {
-    return getArgumentNo(&I.getUse());
-  }
-
-  /// Given a use for an argument, get the argument number that corresponds to
-  /// it.
-  unsigned getArgumentNo(const Use *U) const {
-    assert(getInstruction() && "Not a call, invoke or callbr instruction!");
-    assert(isArgOperand(U) && "Argument # out of range!");
-    return U - arg_begin();
-  }
-
-  /// The type of iterator to use when looping over actual arguments at this
-  /// call site.
-  using arg_iterator = IterTy;
-
-  iterator_range<IterTy> args() const {
-    return make_range(arg_begin(), arg_end());
-  }
-  bool arg_empty() const { return arg_end() == arg_begin(); }
-  unsigned arg_size() const { return unsigned(arg_end() - arg_begin()); }
-
-  /// Given a value use iterator, return the data operand corresponding to it.
-  /// Iterator must actually correspond to a data operand.
-  unsigned getDataOperandNo(Value::const_user_iterator UI) const {
-    return getDataOperandNo(&UI.getUse());
-  }
-
-  /// Given a use for a data operand, get the data operand number that
-  /// corresponds to it.
-  unsigned getDataOperandNo(const Use *U) const {
-    assert(getInstruction() && "Not a call, invoke or callbr instruction!");
-    assert(isDataOperand(U) && "Data operand # out of range!");
-    return U - data_operands_begin();
-  }
-
-  /// Type of iterator to use when looping over data operands at this call site
-  /// (see below).
-  using data_operand_iterator = IterTy;
-
-  /// data_operands_begin/data_operands_end - Return iterators iterating over
-  /// the call / invoke / callbr argument list and bundle operands. For invokes,
-  /// this is the set of instruction operands except the invoke target and the
-  /// two successor blocks; for calls this is the set of instruction operands
-  /// except the call target; for callbrs the number of labels to skip must be
-  /// determined first.
-
-  IterTy data_operands_begin() const {
-    assert(getInstruction() && "Not a call or invoke instruction!");
-    return cast<CallBase>(getInstruction())->data_operands_begin();
-  }
-  IterTy data_operands_end() const {
-    assert(getInstruction() && "Not a call or invoke instruction!");
-    return cast<CallBase>(getInstruction())->data_operands_end();
-  }
-  iterator_range<IterTy> data_ops() const {
-    return make_range(data_operands_begin(), data_operands_end());
-  }
-  bool data_operands_empty() const {
-    return data_operands_end() == data_operands_begin();
-  }
-  unsigned data_operands_size() const {
-    return std::distance(data_operands_begin(), data_operands_end());
-  }
-
-  /// Return the type of the instruction that generated this call site.
-  Type *getType() const { return (*this)->getType(); }
-
-  /// Return the caller function for this call site.
-  FunTy *getCaller() const { return (*this)->getParent()->getParent(); }
-
-  /// Tests if this call site must be tail call optimized. Only a CallInst can
-  /// be tail call optimized.
-  bool isMustTailCall() const {
-    return isCall() && cast<CallInst>(getInstruction())->isMustTailCall();
-  }
-
-  /// Tests if this call site is marked as a tail call.
-  bool isTailCall() const {
-    return isCall() && cast<CallInst>(getInstruction())->isTailCall();
-  }
-
-#define CALLSITE_DELEGATE_GETTER(METHOD)                                       \
-  InstrTy *II = getInstruction();                                              \
-  return isCall() ? cast<CallInst>(II)->METHOD                                 \
-                  : isCallBr() ? cast<CallBrInst>(II)->METHOD                  \
-                                : cast<InvokeInst>(II)->METHOD
-
-#define CALLSITE_DELEGATE_SETTER(METHOD)                                       \
-  InstrTy *II = getInstruction();                                              \
-  if (isCall())                                                                \
-    cast<CallInst>(II)->METHOD;                                                \
-  else if (isCallBr())                                                         \
-    cast<CallBrInst>(II)->METHOD;                                              \
-  else                                                                         \
-    cast<InvokeInst>(II)->METHOD
-
-  unsigned getNumArgOperands() const {
-    CALLSITE_DELEGATE_GETTER(getNumArgOperands());
-  }
-
-  ValTy *getArgOperand(unsigned i) const {
-    CALLSITE_DELEGATE_GETTER(getArgOperand(i));
-  }
-
-  ValTy *getReturnedArgOperand() const {
-    CALLSITE_DELEGATE_GETTER(getReturnedArgOperand());
-  }
-
-  bool isInlineAsm() const {
-    return cast<CallBase>(getInstruction())->isInlineAsm();
-  }
-
-  /// Get the calling convention of the call.
-  CallingConv::ID getCallingConv() const {
-    CALLSITE_DELEGATE_GETTER(getCallingConv());
-  }
-  /// Set the calling convention of the call.
-  void setCallingConv(CallingConv::ID CC) {
-    CALLSITE_DELEGATE_SETTER(setCallingConv(CC));
-  }
-
-  FunctionType *getFunctionType() const {
-    CALLSITE_DELEGATE_GETTER(getFunctionType());
-  }
-
-  void mutateFunctionType(FunctionType *Ty) const {
-    CALLSITE_DELEGATE_SETTER(mutateFunctionType(Ty));
-  }
-
-  /// Get the parameter attributes of the call.
-  AttributeList getAttributes() const {
-    CALLSITE_DELEGATE_GETTER(getAttributes());
-  }
-  /// Set the parameter attributes of the call.
-  void setAttributes(AttributeList PAL) {
-    CALLSITE_DELEGATE_SETTER(setAttributes(PAL));
-  }
-
-  void addAttribute(unsigned i, Attribute::AttrKind Kind) {
-    CALLSITE_DELEGATE_SETTER(addAttribute(i, Kind));
-  }
-
-  void addAttribute(unsigned i, Attribute Attr) {
-    CALLSITE_DELEGATE_SETTER(addAttribute(i, Attr));
-  }
-
-  void addParamAttr(unsigned ArgNo, Attribute::AttrKind Kind) {
-    CALLSITE_DELEGATE_SETTER(addParamAttr(ArgNo, Kind));
-  }
-
-  void removeAttribute(unsigned i, Attribute::AttrKind Kind) {
-    CALLSITE_DELEGATE_SETTER(removeAttribute(i, Kind));
-  }
-
-  void removeAttribute(unsigned i, StringRef Kind) {
-    CALLSITE_DELEGATE_SETTER(removeAttribute(i, Kind));
-  }
-
-  void removeParamAttr(unsigned ArgNo, Attribute::AttrKind Kind) {
-    CALLSITE_DELEGATE_SETTER(removeParamAttr(ArgNo, Kind));
-  }
-
-  /// Return true if this function has the given attribute.
-  bool hasFnAttr(Attribute::AttrKind Kind) const {
-    CALLSITE_DELEGATE_GETTER(hasFnAttr(Kind));
-  }
-
-  /// Return true if this function has the given attribute.
-  bool hasFnAttr(StringRef Kind) const {
-    CALLSITE_DELEGATE_GETTER(hasFnAttr(Kind));
-  }
-
-  /// Return true if this return value has the given attribute.
-  bool hasRetAttr(Attribute::AttrKind Kind) const {
-    CALLSITE_DELEGATE_GETTER(hasRetAttr(Kind));
-  }
-
-  /// Return true if the call or the callee has the given attribute.
-  bool paramHasAttr(unsigned ArgNo, Attribute::AttrKind Kind) const {
-    CALLSITE_DELEGATE_GETTER(paramHasAttr(ArgNo, Kind));
-  }
-
-  Attribute getAttribute(unsigned i, Attribute::AttrKind Kind) const {
-    CALLSITE_DELEGATE_GETTER(getAttribute(i, Kind));
-  }
-
-  Attribute getAttribute(unsigned i, StringRef Kind) const {
-    CALLSITE_DELEGATE_GETTER(getAttribute(i, Kind));
-  }
-
-  /// Return true if the data operand at index \p i directly or indirectly has
-  /// the attribute \p A.
-  ///
-  /// Normal call, invoke or callbr arguments have per operand attributes, as
-  /// specified in the attribute set attached to this instruction, while operand
-  /// bundle operands may have some attributes implied by the type of its
-  /// containing operand bundle.
-  bool dataOperandHasImpliedAttr(unsigned i, Attribute::AttrKind Kind) const {
-    CALLSITE_DELEGATE_GETTER(dataOperandHasImpliedAttr(i, Kind));
-  }
-
-  /// Extract the alignment of the return value.
-  unsigned getRetAlignment() const {
-    CALLSITE_DELEGATE_GETTER(getRetAlignment());
-  }
-
-  /// Extract the alignment for a call or parameter (0=unknown).
-  unsigned getParamAlignment(unsigned ArgNo) const {
-    CALLSITE_DELEGATE_GETTER(getParamAlignment(ArgNo));
-  }
-
-  /// Extract the byval type for a call or parameter (nullptr=unknown).
-  Type *getParamByValType(unsigned ArgNo) const {
-    CALLSITE_DELEGATE_GETTER(getParamByValType(ArgNo));
-  }
-
-  /// Extract the number of dereferenceable bytes for a call or parameter
-  /// (0=unknown).
-  uint64_t getDereferenceableBytes(unsigned i) const {
-    CALLSITE_DELEGATE_GETTER(getDereferenceableBytes(i));
-  }
-
-  /// Extract the number of dereferenceable_or_null bytes for a call or
-  /// parameter (0=unknown).
-  uint64_t getDereferenceableOrNullBytes(unsigned i) const {
-    CALLSITE_DELEGATE_GETTER(getDereferenceableOrNullBytes(i));
-  }
-
-  /// Determine if the return value is marked with NoAlias attribute.
-  bool returnDoesNotAlias() const {
-    CALLSITE_DELEGATE_GETTER(returnDoesNotAlias());
-  }
-
-  /// Return true if the call should not be treated as a call to a builtin.
-  bool isNoBuiltin() const {
-    CALLSITE_DELEGATE_GETTER(isNoBuiltin());
-  }
-
-  /// Return true if the call requires strict floating point semantics.
-  bool isStrictFP() const {
-    CALLSITE_DELEGATE_GETTER(isStrictFP());
-  }
-
-  /// Return true if the call should not be inlined.
-  bool isNoInline() const {
-    CALLSITE_DELEGATE_GETTER(isNoInline());
-  }
-  void setIsNoInline(bool Value = true) {
-    CALLSITE_DELEGATE_SETTER(setIsNoInline(Value));
-  }
-
-  /// Determine if the call does not access memory.
-  bool doesNotAccessMemory() const {
-    CALLSITE_DELEGATE_GETTER(doesNotAccessMemory());
-  }
-  void setDoesNotAccessMemory() {
-    CALLSITE_DELEGATE_SETTER(setDoesNotAccessMemory());
-  }
-
-  /// Determine if the call does not access or only reads memory.
-  bool onlyReadsMemory() const {
-    CALLSITE_DELEGATE_GETTER(onlyReadsMemory());
-  }
-  void setOnlyReadsMemory() {
-    CALLSITE_DELEGATE_SETTER(setOnlyReadsMemory());
-  }
-
-  /// Determine if the call does not access or only writes memory.
-  bool doesNotReadMemory() const {
-    CALLSITE_DELEGATE_GETTER(doesNotReadMemory());
-  }
-  void setDoesNotReadMemory() {
-    CALLSITE_DELEGATE_SETTER(setDoesNotReadMemory());
-  }
-
-  /// Determine if the call can access memmory only using pointers based
-  /// on its arguments.
-  bool onlyAccessesArgMemory() const {
-    CALLSITE_DELEGATE_GETTER(onlyAccessesArgMemory());
-  }
-  void setOnlyAccessesArgMemory() {
-    CALLSITE_DELEGATE_SETTER(setOnlyAccessesArgMemory());
-  }
-
-  /// Determine if the function may only access memory that is
-  /// inaccessible from the IR.
-  bool onlyAccessesInaccessibleMemory() const {
-    CALLSITE_DELEGATE_GETTER(onlyAccessesInaccessibleMemory());
-  }
-  void setOnlyAccessesInaccessibleMemory() {
-    CALLSITE_DELEGATE_SETTER(setOnlyAccessesInaccessibleMemory());
-  }
-
-  /// Determine if the function may only access memory that is
-  /// either inaccessible from the IR or pointed to by its arguments.
-  bool onlyAccessesInaccessibleMemOrArgMem() const {
-    CALLSITE_DELEGATE_GETTER(onlyAccessesInaccessibleMemOrArgMem());
-  }
-  void setOnlyAccessesInaccessibleMemOrArgMem() {
-    CALLSITE_DELEGATE_SETTER(setOnlyAccessesInaccessibleMemOrArgMem());
-  }
-
-  /// Determine if the call cannot return.
-  bool doesNotReturn() const {
-    CALLSITE_DELEGATE_GETTER(doesNotReturn());
-  }
-  void setDoesNotReturn() {
-    CALLSITE_DELEGATE_SETTER(setDoesNotReturn());
-  }
-
-  /// Determine if the call cannot unwind.
-  bool doesNotThrow() const {
-    CALLSITE_DELEGATE_GETTER(doesNotThrow());
-  }
-  void setDoesNotThrow() {
-    CALLSITE_DELEGATE_SETTER(setDoesNotThrow());
-  }
-
-  /// Determine if the call can be duplicated.
-  bool cannotDuplicate() const {
-    CALLSITE_DELEGATE_GETTER(cannotDuplicate());
-  }
-  void setCannotDuplicate() {
-    CALLSITE_DELEGATE_SETTER(setCannotDuplicate());
-  }
-
-  /// Determine if the call is convergent.
-  bool isConvergent() const {
-    CALLSITE_DELEGATE_GETTER(isConvergent());
-  }
-  void setConvergent() {
-    CALLSITE_DELEGATE_SETTER(setConvergent());
-  }
-  void setNotConvergent() {
-    CALLSITE_DELEGATE_SETTER(setNotConvergent());
-  }
-
-  unsigned getNumOperandBundles() const {
-    CALLSITE_DELEGATE_GETTER(getNumOperandBundles());
-  }
-
-  bool hasOperandBundles() const {
-    CALLSITE_DELEGATE_GETTER(hasOperandBundles());
-  }
-
-  unsigned getBundleOperandsStartIndex() const {
-    CALLSITE_DELEGATE_GETTER(getBundleOperandsStartIndex());
-  }
-
-  unsigned getBundleOperandsEndIndex() const {
-    CALLSITE_DELEGATE_GETTER(getBundleOperandsEndIndex());
-  }
-
-  unsigned getNumTotalBundleOperands() const {
-    CALLSITE_DELEGATE_GETTER(getNumTotalBundleOperands());
-  }
-
-  OperandBundleUse getOperandBundleAt(unsigned Index) const {
-    CALLSITE_DELEGATE_GETTER(getOperandBundleAt(Index));
-  }
-
-  Optional<OperandBundleUse> getOperandBundle(StringRef Name) const {
-    CALLSITE_DELEGATE_GETTER(getOperandBundle(Name));
-  }
-
-  Optional<OperandBundleUse> getOperandBundle(uint32_t ID) const {
-    CALLSITE_DELEGATE_GETTER(getOperandBundle(ID));
-  }
-
-  unsigned countOperandBundlesOfType(uint32_t ID) const {
-    CALLSITE_DELEGATE_GETTER(countOperandBundlesOfType(ID));
-  }
-
-  bool isBundleOperand(unsigned Idx) const {
-    CALLSITE_DELEGATE_GETTER(isBundleOperand(Idx));
-  }
-
-  IterTy arg_begin() const {
-    CALLSITE_DELEGATE_GETTER(arg_begin());
-  }
-
-  IterTy arg_end() const {
-    CALLSITE_DELEGATE_GETTER(arg_end());
-  }
-
-#undef CALLSITE_DELEGATE_GETTER
-#undef CALLSITE_DELEGATE_SETTER
-
-  void getOperandBundlesAsDefs(SmallVectorImpl<OperandBundleDef> &Defs) const {
-    // Since this is actually a getter that "looks like" a setter, don't use the
-    // above macros to avoid confusion.
-    cast<CallBase>(getInstruction())->getOperandBundlesAsDefs(Defs);
-  }
-
-  /// Determine whether this data operand is not captured.
-  bool doesNotCapture(unsigned OpNo) const {
-    return dataOperandHasImpliedAttr(OpNo + 1, Attribute::NoCapture);
-  }
-
-  /// Determine whether this argument is passed by value.
-  bool isByValArgument(unsigned ArgNo) const {
-    return paramHasAttr(ArgNo, Attribute::ByVal);
-  }
-
-  /// Determine whether this argument is passed in an alloca.
-  bool isInAllocaArgument(unsigned ArgNo) const {
-    return paramHasAttr(ArgNo, Attribute::InAlloca);
-  }
-
-  /// Determine whether this argument is passed by value or in an alloca.
-  bool isByValOrInAllocaArgument(unsigned ArgNo) const {
-    return paramHasAttr(ArgNo, Attribute::ByVal) ||
-           paramHasAttr(ArgNo, Attribute::InAlloca);
-  }
-
-  /// Determine if there are is an inalloca argument. Only the last argument can
-  /// have the inalloca attribute.
-  bool hasInAllocaArgument() const {
-    return !arg_empty() && paramHasAttr(arg_size() - 1, Attribute::InAlloca);
-  }
-
-  bool doesNotAccessMemory(unsigned OpNo) const {
-    return dataOperandHasImpliedAttr(OpNo + 1, Attribute::ReadNone);
-  }
-
-  bool onlyReadsMemory(unsigned OpNo) const {
-    return dataOperandHasImpliedAttr(OpNo + 1, Attribute::ReadOnly) ||
-           dataOperandHasImpliedAttr(OpNo + 1, Attribute::ReadNone);
-  }
-
-  bool doesNotReadMemory(unsigned OpNo) const {
-    return dataOperandHasImpliedAttr(OpNo + 1, Attribute::WriteOnly) ||
-           dataOperandHasImpliedAttr(OpNo + 1, Attribute::ReadNone);
-  }
-
-  /// Return true if the return value is known to be not null.
-  /// This may be because it has the nonnull attribute, or because at least
-  /// one byte is dereferenceable and the pointer is in addrspace(0).
-  bool isReturnNonNull() const {
-    if (hasRetAttr(Attribute::NonNull))
-      return true;
-    else if (getDereferenceableBytes(AttributeList::ReturnIndex) > 0 &&
-             !NullPointerIsDefined(getCaller(),
-                                   getType()->getPointerAddressSpace()))
-      return true;
-
-    return false;
-  }
-
-  /// Returns true if this CallSite passes the given Value* as an argument to
-  /// the called function.
-  bool hasArgument(const Value *Arg) const {
-    for (arg_iterator AI = this->arg_begin(), E = this->arg_end(); AI != E;
-         ++AI)
-      if (AI->get() == Arg)
-        return true;
-    return false;
-  }
-
-private:
-  IterTy getCallee() const {
-    return cast<CallBase>(getInstruction())->op_end() - 1;
-  }
-};
-
-class CallSite : public CallSiteBase<Function, BasicBlock, Value, User, Use,
-                                     Instruction, CallInst, InvokeInst,
-                                     CallBrInst, User::op_iterator> {
-public:
-  CallSite() = default;
-  CallSite(CallSiteBase B) : CallSiteBase(B) {}
-  CallSite(CallInst *CI) : CallSiteBase(CI) {}
-  CallSite(InvokeInst *II) : CallSiteBase(II) {}
-  CallSite(CallBrInst *CBI) : CallSiteBase(CBI) {}
-  explicit CallSite(Instruction *II) : CallSiteBase(II) {}
-  explicit CallSite(Value *V) : CallSiteBase(V) {}
-
-  bool operator==(const CallSite &CS) const { return I == CS.I; }
-  bool operator!=(const CallSite &CS) const { return I != CS.I; }
-  bool operator<(const CallSite &CS) const {
-    return getInstruction() < CS.getInstruction();
-  }
-
-private:
-  friend struct DenseMapInfo<CallSite>;
-
-  User::op_iterator getCallee() const;
-};
-
-/// AbstractCallSite
-///
-/// An abstract call site is a wrapper that allows to treat direct,
-/// indirect, and callback calls the same. If an abstract call site
-/// represents a direct or indirect call site it behaves like a stripped
-/// down version of a normal call site object. The abstract call site can
-/// also represent a callback call, thus the fact that the initially
-/// called function (=broker) may invoke a third one (=callback callee).
-/// In this case, the abstract call site hides the middle man, hence the
-/// broker function. The result is a representation of the callback call,
-/// inside the broker, but in the context of the original call to the broker.
-///
-/// There are up to three functions involved when we talk about callback call
-/// sites. The caller (1), which invokes the broker function. The broker
-/// function (2), that will invoke the callee zero or more times. And finally
-/// the callee (3), which is the target of the callback call.
-///
-/// The abstract call site will handle the mapping from parameters to arguments
-/// depending on the semantic of the broker function. However, it is important
-/// to note that the mapping is often partial. Thus, some arguments of the
-/// call/invoke instruction are mapped to parameters of the callee while others
-/// are not.
-class AbstractCallSite {
-public:
-
-  /// The encoding of a callback with regards to the underlying instruction.
-  struct CallbackInfo {
-
-    /// For direct/indirect calls the parameter encoding is empty. If it is not,
-    /// the abstract call site represents a callback. In that case, the first
-    /// element of the encoding vector represents which argument of the call
-    /// site CS is the callback callee. The remaining elements map parameters
-    /// (identified by their position) to the arguments that will be passed
-    /// through (also identified by position but in the call site instruction).
-    ///
-    /// NOTE that we use LLVM argument numbers (starting at 0) and not
-    /// clang/source argument numbers (starting at 1). The -1 entries represent
-    /// unknown values that are passed to the callee.
-    using ParameterEncodingTy = SmallVector<int, 0>;
-    ParameterEncodingTy ParameterEncoding;
-
-  };
-
-private:
-
-  /// The underlying call site:
-  ///   caller -> callee,             if this is a direct or indirect call site
-  ///   caller -> broker function,    if this is a callback call site
-  CallSite CS;
-
-  /// The encoding of a callback with regards to the underlying instruction.
-  CallbackInfo CI;
-
-public:
-  /// Sole constructor for abstract call sites (ACS).
-  ///
-  /// An abstract call site can only be constructed through a llvm::Use because
-  /// each operand (=use) of an instruction could potentially be a different
-  /// abstract call site. Furthermore, even if the value of the llvm::Use is the
-  /// same, and the user is as well, the abstract call sites might not be.
-  ///
-  /// If a use is not associated with an abstract call site the constructed ACS
-  /// will evaluate to false if converted to a boolean.
-  ///
-  /// If the use is the callee use of a call or invoke instruction, the
-  /// constructed abstract call site will behave as a llvm::CallSite would.
-  ///
-  /// If the use is not a callee use of a call or invoke instruction, the
-  /// callback metadata is used to determine the argument <-> parameter mapping
-  /// as well as the callee of the abstract call site.
-  AbstractCallSite(const Use *U);
-
-  /// Conversion operator to conveniently check for a valid/initialized ACS.
-  explicit operator bool() const { return (bool)CS; }
-
-  /// Return the underlying instruction.
-  Instruction *getInstruction() const { return CS.getInstruction(); }
-
-  /// Return the call site abstraction for the underlying instruction.
-  CallSite getCallSite() const { return CS; }
-
-  /// Return true if this ACS represents a direct call.
-  bool isDirectCall() const {
-    return !isCallbackCall() && !CS.isIndirectCall();
-  }
-
-  /// Return true if this ACS represents an indirect call.
-  bool isIndirectCall() const {
-    return !isCallbackCall() && CS.isIndirectCall();
-  }
-
-  /// Return true if this ACS represents a callback call.
-  bool isCallbackCall() const {
-    // For a callback call site the callee is ALWAYS stored first in the
-    // transitive values vector. Thus, a non-empty vector indicates a callback.
-    return !CI.ParameterEncoding.empty();
-  }
-
-  /// Return true if @p UI is the use that defines the callee of this ACS.
-  bool isCallee(Value::const_user_iterator UI) const {
-    return isCallee(&UI.getUse());
-  }
-
-  /// Return true if @p U is the use that defines the callee of this ACS.
-  bool isCallee(const Use *U) const {
-    if (isDirectCall())
-      return CS.isCallee(U);
-
-    assert(!CI.ParameterEncoding.empty() &&
-           "Callback without parameter encoding!");
-
-    return (int)CS.getArgumentNo(U) == CI.ParameterEncoding[0];
-  }
-
-  /// Return the number of parameters of the callee.
-  unsigned getNumArgOperands() const {
-    if (isDirectCall())
-      return CS.getNumArgOperands();
-    // Subtract 1 for the callee encoding.
-    return CI.ParameterEncoding.size() - 1;
-  }
-
-  /// Return the operand index of the underlying instruction associated with @p
-  /// Arg.
-  int getCallArgOperandNo(Argument &Arg) const {
-    return getCallArgOperandNo(Arg.getArgNo());
-  }
-
-  /// Return the operand index of the underlying instruction associated with
-  /// the function parameter number @p ArgNo or -1 if there is none.
-  int getCallArgOperandNo(unsigned ArgNo) const {
-    if (isDirectCall())
-      return ArgNo;
-    // Add 1 for the callee encoding.
-    return CI.ParameterEncoding[ArgNo + 1];
-  }
-
-  /// Return the operand of the underlying instruction associated with @p Arg.
-  Value *getCallArgOperand(Argument &Arg) const {
-    return getCallArgOperand(Arg.getArgNo());
-  }
-
-  /// Return the operand of the underlying instruction associated with the
-  /// function parameter number @p ArgNo or nullptr if there is none.
-  Value *getCallArgOperand(unsigned ArgNo) const {
-    if (isDirectCall())
-      return CS.getArgOperand(ArgNo);
-    // Add 1 for the callee encoding.
-    return CI.ParameterEncoding[ArgNo + 1] >= 0
-               ? CS.getArgOperand(CI.ParameterEncoding[ArgNo + 1])
-               : nullptr;
-  }
-
-  /// Return the operand index of the underlying instruction associated with the
-  /// callee of this ACS. Only valid for callback calls!
-  int getCallArgOperandNoForCallee() const {
-    assert(isCallbackCall());
-    assert(CI.ParameterEncoding.size() && CI.ParameterEncoding[0] > 0);
-    return CI.ParameterEncoding[0];
-  }
-
-  /// Return the pointer to function that is being called.
-  Value *getCalledValue() const {
-    if (isDirectCall())
-      return CS.getCalledValue();
-    return CS.getArgOperand(getCallArgOperandNoForCallee());
-  }
-
-  /// Return the function being called if this is a direct call, otherwise
-  /// return null (if it's an indirect call).
-  Function *getCalledFunction() const {
-    Value *V = getCalledValue();
-    return V ? dyn_cast<Function>(V->stripPointerCasts()) : nullptr;
-  }
-};
-
-template <> struct DenseMapInfo<CallSite> {
-  using BaseInfo = DenseMapInfo<decltype(CallSite::I)>;
-
-  static CallSite getEmptyKey() {
-    CallSite CS;
-    CS.I = BaseInfo::getEmptyKey();
-    return CS;
-  }
-
-  static CallSite getTombstoneKey() {
-    CallSite CS;
-    CS.I = BaseInfo::getTombstoneKey();
-    return CS;
-  }
-
-  static unsigned getHashValue(const CallSite &CS) {
-    return BaseInfo::getHashValue(CS.I);
-  }
-
-  static bool isEqual(const CallSite &LHS, const CallSite &RHS) {
-    return LHS == RHS;
-  }
-};
-
-/// Establish a view to a call site for examination.
-class ImmutableCallSite : public CallSiteBase<> {
-public:
-  ImmutableCallSite() = default;
-  ImmutableCallSite(const CallInst *CI) : CallSiteBase(CI) {}
-  ImmutableCallSite(const InvokeInst *II) : CallSiteBase(II) {}
-  ImmutableCallSite(const CallBrInst *CBI) : CallSiteBase(CBI) {}
-  explicit ImmutableCallSite(const Instruction *II) : CallSiteBase(II) {}
-  explicit ImmutableCallSite(const Value *V) : CallSiteBase(V) {}
-  ImmutableCallSite(CallSite CS) : CallSiteBase(CS.getInstruction()) {}
-};
-
-} // end namespace llvm
-
-#endif // LLVM_IR_CALLSITE_H
diff --git a/linux-x64/clang/include/llvm/IR/CallingConv.h b/linux-x64/clang/include/llvm/IR/CallingConv.h
index 399c6ad..6a4e368 100644
--- a/linux-x64/clang/include/llvm/IR/CallingConv.h
+++ b/linux-x64/clang/include/llvm/IR/CallingConv.h
@@ -75,6 +75,17 @@
     // CXX_FAST_TLS - Calling convention for access functions.
     CXX_FAST_TLS = 17,
 
+    /// Tail - This calling convention attemps to make calls as fast as
+    /// possible while guaranteeing that tail call optimization can always
+    /// be performed.
+    Tail = 18,
+
+    /// Special calling convention on Windows for calling the Control
+    /// Guard Check ICall funtion. The function takes exactly one argument
+    /// (address of the target function) passed in the first argument register,
+    /// and has no return value. All register values are preserved.
+    CFGuard_Check = 19,
+
     // Target - This is the start of the target-specific calling conventions,
     // e.g. fastcall and thiscall on X86.
     FirstTargetCC = 64,
@@ -222,6 +233,17 @@
     // Calling convention between AArch64 Advanced SIMD functions
     AArch64_VectorCall = 97,
 
+    /// Calling convention between AArch64 SVE functions
+    AArch64_SVE_VectorCall = 98,
+
+    /// Calling convention for emscripten __invoke_* functions. The first
+    /// argument is required to be the function ptr being indirectly called.
+    /// The remainder matches the regular calling convention.
+    WASM_EmscriptenInvoke = 99,
+
+    /// Calling convention used for AMD graphics targets.
+    AMDGPU_Gfx = 100,
+
     /// The highest possible calling convention ID. Must be some 2^k - 1.
     MaxID = 1023
   };
diff --git a/linux-x64/clang/include/llvm/IR/Constant.h b/linux-x64/clang/include/llvm/IR/Constant.h
index 9315766..0190aca 100644
--- a/linux-x64/clang/include/llvm/IR/Constant.h
+++ b/linux-x64/clang/include/llvm/IR/Constant.h
@@ -43,6 +43,8 @@
   Constant(Type *ty, ValueTy vty, Use *Ops, unsigned NumOps)
     : User(ty, vty, Ops, NumOps) {}
 
+  ~Constant() = default;
+
 public:
   void operator=(const Constant &) = delete;
   Constant(const Constant &) = delete;
@@ -53,6 +55,10 @@
   /// Returns true if the value is one.
   bool isOneValue() const;
 
+  /// Return true if the value is not the one value, or,
+  /// for vectors, does not contain one value elements.
+  bool isNotOneValue() const;
+
   /// Return true if this is the value that would be returned by
   /// getAllOnesValue.
   bool isAllOnesValue() const;
@@ -64,18 +70,21 @@
   /// Return true if the value is negative zero or null value.
   bool isZeroValue() const;
 
-  /// Return true if the value is not the smallest signed value.
+  /// Return true if the value is not the smallest signed value, or,
+  /// for vectors, does not contain smallest signed value elements.
   bool isNotMinSignedValue() const;
 
   /// Return true if the value is the smallest signed value.
   bool isMinSignedValue() const;
 
   /// Return true if this is a finite and non-zero floating-point scalar
-  /// constant or a vector constant with all finite and non-zero elements.
+  /// constant or a fixed width vector constant with all finite and non-zero
+  /// elements.
   bool isFiniteNonZeroFP() const;
 
-  /// Return true if this is a normal (as opposed to denormal) floating-point
-  /// scalar constant or a vector constant with all normal elements.
+  /// Return true if this is a normal (as opposed to denormal, infinity, nan,
+  /// or zero) floating-point scalar constant or a vector constant with all
+  /// normal elements. See APFloat::isNormal.
   bool isNormalFP() const;
 
   /// Return true if this scalar has an exact multiplicative inverse or this
@@ -86,12 +95,24 @@
   /// floating-point constant with all NaN elements.
   bool isNaN() const;
 
-  /// Return true if this is a vector constant that includes any undefined
-  /// elements.
-  bool containsUndefElement() const;
+  /// Return true if this constant and a constant 'Y' are element-wise equal.
+  /// This is identical to just comparing the pointers, with the exception that
+  /// for vectors, if only one of the constants has an `undef` element in some
+  /// lane, the constants still match.
+  bool isElementWiseEqual(Value *Y) const;
 
-  /// Return true if this is a vector constant that includes any constant
-  /// expressions.
+  /// Return true if this is a vector constant that includes any undef or
+  /// poison elements. Since it is impossible to inspect a scalable vector
+  /// element- wise at compile time, this function returns true only if the
+  /// entire vector is undef or poison.
+  bool containsUndefOrPoisonElement() const;
+
+  /// Return true if this is a vector constant that includes any poison
+  /// elements.
+  bool containsPoisonElement() const;
+
+  /// Return true if this is a fixed width vector constant that includes
+  /// any constant expressions.
   bool containsConstantExpression() const;
 
   /// Return true if evaluation of this constant could trap. This is true for
@@ -122,9 +143,10 @@
   Constant *getAggregateElement(unsigned Elt) const;
   Constant *getAggregateElement(Constant *Elt) const;
 
-  /// If this is a splat vector constant, meaning that all of the elements have
-  /// the same value, return that value. Otherwise return 0.
-  Constant *getSplatValue() const;
+  /// If all elements of the vector constant have the same value, return that
+  /// value. Otherwise, return nullptr. Ignore undefined elements by setting
+  /// AllowUndefs to true.
+  Constant *getSplatValue(bool AllowUndefs = false) const;
 
   /// If C is a constant integer then return its value, otherwise C must be a
   /// vector of constant integers, all equal, and the common value is returned.
@@ -182,6 +204,16 @@
     return const_cast<Constant*>(
                       static_cast<const Constant *>(this)->stripPointerCasts());
   }
+
+  /// Try to replace undefined constant C or undefined elements in C with
+  /// Replacement. If no changes are made, the constant C is returned.
+  static Constant *replaceUndefsWith(Constant *C, Constant *Replacement);
+
+  /// Merges undefs of a Constant with another Constant, along with the
+  /// undefs already present. Other doesn't have to be the same type as C, but
+  /// both must either be scalars or vectors with the same element count. If no
+  /// changes are made, the constant C is returned.
+  static Constant *mergeUndefsWith(Constant *C, Constant *Other);
 };
 
 } // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/IR/ConstantFolder.h b/linux-x64/clang/include/llvm/IR/ConstantFolder.h
index 5a5cabf..da4a18e 100644
--- a/linux-x64/clang/include/llvm/IR/ConstantFolder.h
+++ b/linux-x64/clang/include/llvm/IR/ConstantFolder.h
@@ -20,11 +20,14 @@
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/InstrTypes.h"
 #include "llvm/IR/Instruction.h"
+#include "llvm/IR/IRBuilderFolder.h"
 
 namespace llvm {
 
 /// ConstantFolder - Create constants with minimum, target independent, folding.
-class ConstantFolder {
+class ConstantFolder final : public IRBuilderFolder {
+  virtual void anchor();
+
 public:
   explicit ConstantFolder() = default;
 
@@ -33,87 +36,87 @@
   //===--------------------------------------------------------------------===//
 
   Constant *CreateAdd(Constant *LHS, Constant *RHS,
-                      bool HasNUW = false, bool HasNSW = false) const {
+                      bool HasNUW = false, bool HasNSW = false) const override {
     return ConstantExpr::getAdd(LHS, RHS, HasNUW, HasNSW);
   }
 
-  Constant *CreateFAdd(Constant *LHS, Constant *RHS) const {
+  Constant *CreateFAdd(Constant *LHS, Constant *RHS) const override {
     return ConstantExpr::getFAdd(LHS, RHS);
   }
 
   Constant *CreateSub(Constant *LHS, Constant *RHS,
-                      bool HasNUW = false, bool HasNSW = false) const {
+                      bool HasNUW = false, bool HasNSW = false) const override {
     return ConstantExpr::getSub(LHS, RHS, HasNUW, HasNSW);
   }
 
-  Constant *CreateFSub(Constant *LHS, Constant *RHS) const {
+  Constant *CreateFSub(Constant *LHS, Constant *RHS) const override {
     return ConstantExpr::getFSub(LHS, RHS);
   }
 
   Constant *CreateMul(Constant *LHS, Constant *RHS,
-                      bool HasNUW = false, bool HasNSW = false) const {
+                      bool HasNUW = false, bool HasNSW = false) const override {
     return ConstantExpr::getMul(LHS, RHS, HasNUW, HasNSW);
   }
 
-  Constant *CreateFMul(Constant *LHS, Constant *RHS) const {
+  Constant *CreateFMul(Constant *LHS, Constant *RHS) const override {
     return ConstantExpr::getFMul(LHS, RHS);
   }
 
   Constant *CreateUDiv(Constant *LHS, Constant *RHS,
-                       bool isExact = false) const {
+                               bool isExact = false) const override {
     return ConstantExpr::getUDiv(LHS, RHS, isExact);
   }
 
   Constant *CreateSDiv(Constant *LHS, Constant *RHS,
-                       bool isExact = false) const {
+                               bool isExact = false) const override {
     return ConstantExpr::getSDiv(LHS, RHS, isExact);
   }
 
-  Constant *CreateFDiv(Constant *LHS, Constant *RHS) const {
+  Constant *CreateFDiv(Constant *LHS, Constant *RHS) const override {
     return ConstantExpr::getFDiv(LHS, RHS);
   }
 
-  Constant *CreateURem(Constant *LHS, Constant *RHS) const {
+  Constant *CreateURem(Constant *LHS, Constant *RHS) const override {
     return ConstantExpr::getURem(LHS, RHS);
   }
 
-  Constant *CreateSRem(Constant *LHS, Constant *RHS) const {
+  Constant *CreateSRem(Constant *LHS, Constant *RHS) const override {
     return ConstantExpr::getSRem(LHS, RHS);
   }
 
-  Constant *CreateFRem(Constant *LHS, Constant *RHS) const {
+  Constant *CreateFRem(Constant *LHS, Constant *RHS) const override {
     return ConstantExpr::getFRem(LHS, RHS);
   }
 
   Constant *CreateShl(Constant *LHS, Constant *RHS,
-                      bool HasNUW = false, bool HasNSW = false) const {
+                      bool HasNUW = false, bool HasNSW = false) const override {
     return ConstantExpr::getShl(LHS, RHS, HasNUW, HasNSW);
   }
 
   Constant *CreateLShr(Constant *LHS, Constant *RHS,
-                       bool isExact = false) const {
+                       bool isExact = false) const override {
     return ConstantExpr::getLShr(LHS, RHS, isExact);
   }
 
   Constant *CreateAShr(Constant *LHS, Constant *RHS,
-                       bool isExact = false) const {
+                       bool isExact = false) const override {
     return ConstantExpr::getAShr(LHS, RHS, isExact);
   }
 
-  Constant *CreateAnd(Constant *LHS, Constant *RHS) const {
+  Constant *CreateAnd(Constant *LHS, Constant *RHS) const override {
     return ConstantExpr::getAnd(LHS, RHS);
   }
 
-  Constant *CreateOr(Constant *LHS, Constant *RHS) const {
+  Constant *CreateOr(Constant *LHS, Constant *RHS) const override {
     return ConstantExpr::getOr(LHS, RHS);
   }
 
-  Constant *CreateXor(Constant *LHS, Constant *RHS) const {
+  Constant *CreateXor(Constant *LHS, Constant *RHS) const override {
     return ConstantExpr::getXor(LHS, RHS);
   }
 
   Constant *CreateBinOp(Instruction::BinaryOps Opc,
-                        Constant *LHS, Constant *RHS) const {
+                        Constant *LHS, Constant *RHS) const override {
     return ConstantExpr::get(Opc, LHS, RHS);
   }
 
@@ -122,19 +125,19 @@
   //===--------------------------------------------------------------------===//
 
   Constant *CreateNeg(Constant *C,
-                      bool HasNUW = false, bool HasNSW = false) const {
+                      bool HasNUW = false, bool HasNSW = false) const override {
     return ConstantExpr::getNeg(C, HasNUW, HasNSW);
   }
 
-  Constant *CreateFNeg(Constant *C) const {
+  Constant *CreateFNeg(Constant *C) const override {
     return ConstantExpr::getFNeg(C);
   }
 
-  Constant *CreateNot(Constant *C) const {
+  Constant *CreateNot(Constant *C) const override {
     return ConstantExpr::getNot(C);
   }
 
-  Constant *CreateUnOp(Instruction::UnaryOps Opc, Constant *C) const {
+  Constant *CreateUnOp(Instruction::UnaryOps Opc, Constant *C) const override {
     return ConstantExpr::get(Opc, C);
   }
 
@@ -143,11 +146,12 @@
   //===--------------------------------------------------------------------===//
 
   Constant *CreateGetElementPtr(Type *Ty, Constant *C,
-                                ArrayRef<Constant *> IdxList) const {
+                                ArrayRef<Constant *> IdxList) const override {
     return ConstantExpr::getGetElementPtr(Ty, C, IdxList);
   }
 
-  Constant *CreateGetElementPtr(Type *Ty, Constant *C, Constant *Idx) const {
+  Constant *CreateGetElementPtr(Type *Ty, Constant *C,
+                                Constant *Idx) const override {
     // This form of the function only exists to avoid ambiguous overload
     // warnings about whether to convert Idx to ArrayRef<Constant *> or
     // ArrayRef<Value *>.
@@ -155,25 +159,25 @@
   }
 
   Constant *CreateGetElementPtr(Type *Ty, Constant *C,
-                                ArrayRef<Value *> IdxList) const {
+                                ArrayRef<Value *> IdxList) const override {
     return ConstantExpr::getGetElementPtr(Ty, C, IdxList);
   }
 
-  Constant *CreateInBoundsGetElementPtr(Type *Ty, Constant *C,
-                                        ArrayRef<Constant *> IdxList) const {
+  Constant *CreateInBoundsGetElementPtr(
+      Type *Ty, Constant *C, ArrayRef<Constant *> IdxList) const override {
     return ConstantExpr::getInBoundsGetElementPtr(Ty, C, IdxList);
   }
 
   Constant *CreateInBoundsGetElementPtr(Type *Ty, Constant *C,
-                                        Constant *Idx) const {
+                                        Constant *Idx) const override {
     // This form of the function only exists to avoid ambiguous overload
     // warnings about whether to convert Idx to ArrayRef<Constant *> or
     // ArrayRef<Value *>.
     return ConstantExpr::getInBoundsGetElementPtr(Ty, C, Idx);
   }
 
-  Constant *CreateInBoundsGetElementPtr(Type *Ty, Constant *C,
-                                        ArrayRef<Value *> IdxList) const {
+  Constant *CreateInBoundsGetElementPtr(
+      Type *Ty, Constant *C, ArrayRef<Value *> IdxList) const override {
     return ConstantExpr::getInBoundsGetElementPtr(Ty, C, IdxList);
   }
 
@@ -182,49 +186,49 @@
   //===--------------------------------------------------------------------===//
 
   Constant *CreateCast(Instruction::CastOps Op, Constant *C,
-                       Type *DestTy) const {
+                       Type *DestTy) const override {
     return ConstantExpr::getCast(Op, C, DestTy);
   }
 
-  Constant *CreatePointerCast(Constant *C, Type *DestTy) const {
+  Constant *CreatePointerCast(Constant *C, Type *DestTy) const override {
     return ConstantExpr::getPointerCast(C, DestTy);
   }
 
   Constant *CreatePointerBitCastOrAddrSpaceCast(Constant *C,
-                                                Type *DestTy) const {
+                                                Type *DestTy) const override {
     return ConstantExpr::getPointerBitCastOrAddrSpaceCast(C, DestTy);
   }
 
   Constant *CreateIntCast(Constant *C, Type *DestTy,
-                          bool isSigned) const {
+                          bool isSigned) const override {
     return ConstantExpr::getIntegerCast(C, DestTy, isSigned);
   }
 
-  Constant *CreateFPCast(Constant *C, Type *DestTy) const {
+  Constant *CreateFPCast(Constant *C, Type *DestTy) const override {
     return ConstantExpr::getFPCast(C, DestTy);
   }
 
-  Constant *CreateBitCast(Constant *C, Type *DestTy) const {
+  Constant *CreateBitCast(Constant *C, Type *DestTy) const override {
     return CreateCast(Instruction::BitCast, C, DestTy);
   }
 
-  Constant *CreateIntToPtr(Constant *C, Type *DestTy) const {
+  Constant *CreateIntToPtr(Constant *C, Type *DestTy) const override {
     return CreateCast(Instruction::IntToPtr, C, DestTy);
   }
 
-  Constant *CreatePtrToInt(Constant *C, Type *DestTy) const {
+  Constant *CreatePtrToInt(Constant *C, Type *DestTy) const override {
     return CreateCast(Instruction::PtrToInt, C, DestTy);
   }
 
-  Constant *CreateZExtOrBitCast(Constant *C, Type *DestTy) const {
+  Constant *CreateZExtOrBitCast(Constant *C, Type *DestTy) const override {
     return ConstantExpr::getZExtOrBitCast(C, DestTy);
   }
 
-  Constant *CreateSExtOrBitCast(Constant *C, Type *DestTy) const {
+  Constant *CreateSExtOrBitCast(Constant *C, Type *DestTy) const override {
     return ConstantExpr::getSExtOrBitCast(C, DestTy);
   }
 
-  Constant *CreateTruncOrBitCast(Constant *C, Type *DestTy) const {
+  Constant *CreateTruncOrBitCast(Constant *C, Type *DestTy) const override {
     return ConstantExpr::getTruncOrBitCast(C, DestTy);
   }
 
@@ -233,12 +237,12 @@
   //===--------------------------------------------------------------------===//
 
   Constant *CreateICmp(CmpInst::Predicate P, Constant *LHS,
-                       Constant *RHS) const {
+                       Constant *RHS) const override {
     return ConstantExpr::getCompare(P, LHS, RHS);
   }
 
   Constant *CreateFCmp(CmpInst::Predicate P, Constant *LHS,
-                       Constant *RHS) const {
+                       Constant *RHS) const override {
     return ConstantExpr::getCompare(P, LHS, RHS);
   }
 
@@ -246,31 +250,32 @@
   // Other Instructions
   //===--------------------------------------------------------------------===//
 
-  Constant *CreateSelect(Constant *C, Constant *True, Constant *False) const {
+  Constant *CreateSelect(Constant *C, Constant *True,
+                         Constant *False) const override {
     return ConstantExpr::getSelect(C, True, False);
   }
 
-  Constant *CreateExtractElement(Constant *Vec, Constant *Idx) const {
+  Constant *CreateExtractElement(Constant *Vec, Constant *Idx) const override {
     return ConstantExpr::getExtractElement(Vec, Idx);
   }
 
   Constant *CreateInsertElement(Constant *Vec, Constant *NewElt,
-                                Constant *Idx) const {
+                                Constant *Idx) const override {
     return ConstantExpr::getInsertElement(Vec, NewElt, Idx);
   }
 
   Constant *CreateShuffleVector(Constant *V1, Constant *V2,
-                                Constant *Mask) const {
+                                ArrayRef<int> Mask) const override {
     return ConstantExpr::getShuffleVector(V1, V2, Mask);
   }
 
   Constant *CreateExtractValue(Constant *Agg,
-                               ArrayRef<unsigned> IdxList) const {
+                               ArrayRef<unsigned> IdxList) const override {
     return ConstantExpr::getExtractValue(Agg, IdxList);
   }
 
   Constant *CreateInsertValue(Constant *Agg, Constant *Val,
-                              ArrayRef<unsigned> IdxList) const {
+                              ArrayRef<unsigned> IdxList) const override {
     return ConstantExpr::getInsertValue(Agg, Val, IdxList);
   }
 };
diff --git a/linux-x64/clang/include/llvm/IR/ConstantRange.h b/linux-x64/clang/include/llvm/IR/ConstantRange.h
index 91f3f31..20e8e67 100644
--- a/linux-x64/clang/include/llvm/IR/ConstantRange.h
+++ b/linux-x64/clang/include/llvm/IR/ConstantRange.h
@@ -150,6 +150,14 @@
                                              const APInt &Other,
                                              unsigned NoWrapKind);
 
+  /// Returns true if ConstantRange calculations are supported for intrinsic
+  /// with \p IntrinsicID.
+  static bool isIntrinsicSupported(Intrinsic::ID IntrinsicID);
+
+  /// Compute range of intrinsic result for the given operand ranges.
+  static ConstantRange intrinsic(Intrinsic::ID IntrinsicID,
+                                 ArrayRef<ConstantRange> Ops);
+
   /// Set up \p Pred and \p RHS such that
   /// ConstantRange::makeExactICmpRegion(Pred, RHS) == *this.  Return true if
   /// successful.
@@ -253,6 +261,14 @@
     return !operator==(CR);
   }
 
+  /// Compute the maximal number of active bits needed to represent every value
+  /// in this range.
+  unsigned getActiveBits() const;
+
+  /// Compute the maximal number of bits needed to represent every value
+  /// in this signed range.
+  unsigned getMinSignedBits() const;
+
   /// Subtract the specified constant from the endpoints of this constant range.
   ConstantRange subtract(const APInt &CI) const;
 
@@ -327,18 +343,38 @@
                          const ConstantRange &Other) const;
 
   /// Return a new range representing the possible values resulting
+  /// from an application of the specified overflowing binary operator to a
+  /// left hand side of this range and a right hand side of \p Other given
+  /// the provided knowledge about lack of wrapping \p NoWrapKind.
+  ConstantRange overflowingBinaryOp(Instruction::BinaryOps BinOp,
+                                    const ConstantRange &Other,
+                                    unsigned NoWrapKind) const;
+
+  /// Return a new range representing the possible values resulting
   /// from an addition of a value in this range and a value in \p Other.
   ConstantRange add(const ConstantRange &Other) const;
 
-  /// Return a new range representing the possible values resulting from a
-  /// known NSW addition of a value in this range and \p Other constant.
-  ConstantRange addWithNoSignedWrap(const APInt &Other) const;
+  /// Return a new range representing the possible values resulting
+  /// from an addition with wrap type \p NoWrapKind of a value in this
+  /// range and a value in \p Other.
+  /// If the result range is disjoint, the preferred range is determined by the
+  /// \p PreferredRangeType.
+  ConstantRange addWithNoWrap(const ConstantRange &Other, unsigned NoWrapKind,
+                              PreferredRangeType RangeType = Smallest) const;
 
   /// Return a new range representing the possible values resulting
   /// from a subtraction of a value in this range and a value in \p Other.
   ConstantRange sub(const ConstantRange &Other) const;
 
   /// Return a new range representing the possible values resulting
+  /// from an subtraction with wrap type \p NoWrapKind of a value in this
+  /// range and a value in \p Other.
+  /// If the result range is disjoint, the preferred range is determined by the
+  /// \p PreferredRangeType.
+  ConstantRange subWithNoWrap(const ConstantRange &Other, unsigned NoWrapKind,
+                              PreferredRangeType RangeType = Smallest) const;
+
+  /// Return a new range representing the possible values resulting
   /// from a multiplication of a value in this range and a value in \p Other,
   /// treating both this and \p Other as unsigned ranges.
   ConstantRange multiply(const ConstantRange &Other) const;
@@ -381,6 +417,11 @@
   /// value in \p Other.
   ConstantRange srem(const ConstantRange &Other) const;
 
+  /// Return a new range representing the possible values resulting from
+  /// a binary-xor of a value in this range by an all-one value,
+  /// aka bitwise complement operation.
+  ConstantRange binaryNot() const;
+
   /// Return a new range representing the possible values resulting
   /// from a binary-and of a value in this range by a value in \p Other.
   ConstantRange binaryAnd(const ConstantRange &Other) const;
@@ -390,6 +431,10 @@
   ConstantRange binaryOr(const ConstantRange &Other) const;
 
   /// Return a new range representing the possible values resulting
+  /// from a binary-xor of a value in this range by a value in \p Other.
+  ConstantRange binaryXor(const ConstantRange &Other) const;
+
+  /// Return a new range representing the possible values resulting
   /// from a left shift of a value in this range by a value in \p Other.
   /// TODO: This isn't fully implemented yet.
   ConstantRange shl(const ConstantRange &Other) const;
@@ -414,12 +459,27 @@
   /// Perform a signed saturating subtraction of two constant ranges.
   ConstantRange ssub_sat(const ConstantRange &Other) const;
 
+  /// Perform an unsigned saturating multiplication of two constant ranges.
+  ConstantRange umul_sat(const ConstantRange &Other) const;
+
+  /// Perform a signed saturating multiplication of two constant ranges.
+  ConstantRange smul_sat(const ConstantRange &Other) const;
+
+  /// Perform an unsigned saturating left shift of this constant range by a
+  /// value in \p Other.
+  ConstantRange ushl_sat(const ConstantRange &Other) const;
+
+  /// Perform a signed saturating left shift of this constant range by a
+  /// value in \p Other.
+  ConstantRange sshl_sat(const ConstantRange &Other) const;
+
   /// Return a new range that is the logical not of the current set.
   ConstantRange inverse() const;
 
   /// Calculate absolute value range. If the original range contains signed
-  /// min, then the resulting range will also contain signed min.
-  ConstantRange abs() const;
+  /// min, then the resulting range will contain signed min if and only if
+  /// \p IntMinIsPoison is false.
+  ConstantRange abs(bool IntMinIsPoison = false) const;
 
   /// Represents whether an operation on the given constant range is known to
   /// always or never overflow.
diff --git a/linux-x64/clang/include/llvm/IR/Constants.h b/linux-x64/clang/include/llvm/IR/Constants.h
index ca56e8b..ac80223 100644
--- a/linux-x64/clang/include/llvm/IR/Constants.h
+++ b/linux-x64/clang/include/llvm/IR/Constants.h
@@ -41,12 +41,6 @@
 
 namespace llvm {
 
-class ArrayType;
-class IntegerType;
-class PointerType;
-class SequentialType;
-class StructType;
-class VectorType;
 template <class ConstantClass> struct ConstantAggrKeyType;
 
 /// Base class for constants with no operands.
@@ -94,8 +88,10 @@
 
   static ConstantInt *getTrue(LLVMContext &Context);
   static ConstantInt *getFalse(LLVMContext &Context);
+  static ConstantInt *getBool(LLVMContext &Context, bool V);
   static Constant *getTrue(Type *Ty);
   static Constant *getFalse(Type *Ty);
+  static Constant *getBool(Type *Ty, bool V);
 
   /// If Ty is a vector type, return a Constant with a splat of the given
   /// value. Otherwise return a ConstantInt for the given value.
@@ -157,6 +153,20 @@
     return Val.getSExtValue();
   }
 
+  /// Return the constant as an llvm::MaybeAlign.
+  /// Note that this method can assert if the value does not fit in 64 bits or
+  /// is not a power of two.
+  inline MaybeAlign getMaybeAlignValue() const {
+    return MaybeAlign(getZExtValue());
+  }
+
+  /// Return the constant as an llvm::Align, interpreting `0` as `Align(1)`.
+  /// Note that this method can assert if the value does not fit in 64 bits or
+  /// is not a power of two.
+  inline Align getAlignValue() const {
+    return getMaybeAlignValue().valueOrOne();
+  }
+
   /// A helper method that can be used to determine if the constant contained
   /// within is equal to a constant.  This only works for very small values,
   /// because this is all that can be represented with all types.
@@ -300,6 +310,7 @@
   /// Return true if Ty is big enough to represent V.
   static bool isValueValidForType(Type *Ty, const APFloat &V);
   inline const APFloat &getValueAPF() const { return Val; }
+  inline const APFloat &getValue() const { return Val; }
 
   /// Return true if the value is positive or negative zero.
   bool isZero() const { return Val.isZero(); }
@@ -388,7 +399,7 @@
 /// use operands.
 class ConstantAggregate : public Constant {
 protected:
-  ConstantAggregate(CompositeType *T, ValueTy VT, ArrayRef<Constant *> V);
+  ConstantAggregate(Type *T, ValueTy VT, ArrayRef<Constant *> V);
 
 public:
   /// Transparently provide more efficient getOperand methods.
@@ -456,8 +467,7 @@
   static Constant *get(StructType *T, ArrayRef<Constant*> V);
 
   template <typename... Csts>
-  static typename std::enable_if<are_base_of<Constant, Csts...>::value,
-                                 Constant *>::type
+  static std::enable_if_t<are_base_of<Constant, Csts...>::value, Constant *>
   get(StructType *T, Csts *... Vs) {
     SmallVector<Constant *, 8> Values({Vs...});
     return get(T, Values);
@@ -514,17 +524,19 @@
 
 public:
   /// Return a ConstantVector with the specified constant in each element.
-  static Constant *getSplat(unsigned NumElts, Constant *Elt);
+  /// Note that this might not return an instance of ConstantVector
+  static Constant *getSplat(ElementCount EC, Constant *Elt);
 
-  /// Specialize the getType() method to always return a VectorType,
+  /// Specialize the getType() method to always return a FixedVectorType,
   /// which reduces the amount of casting needed in parts of the compiler.
-  inline VectorType *getType() const {
-    return cast<VectorType>(Value::getType());
+  inline FixedVectorType *getType() const {
+    return cast<FixedVectorType>(Value::getType());
   }
 
-  /// If this is a splat constant, meaning that all of the elements have the
-  /// same value, return that value. Otherwise return NULL.
-  Constant *getSplatValue() const;
+  /// If all elements of the vector constant have the same value, return that
+  /// value. Otherwise, return nullptr. Ignore undefined elements by setting
+  /// AllowUndefs to true.
+  Constant *getSplatValue(bool AllowUndefs = false) const;
 
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Value *V) {
@@ -582,14 +594,13 @@
   /// the same value but different type.  For example, 0,0,0,1 could be a 4
   /// element array of i8, or a 1-element array of i32.  They'll both end up in
   /// the same StringMap bucket, linked up.
-  ConstantDataSequential *Next;
+  std::unique_ptr<ConstantDataSequential> Next;
 
   void destroyConstantImpl();
 
 protected:
   explicit ConstantDataSequential(Type *ty, ValueTy VT, const char *Data)
-      : ConstantData(ty, VT), DataElements(Data), Next(nullptr) {}
-  ~ConstantDataSequential() { delete Next; }
+      : ConstantData(ty, VT), DataElements(Data) {}
 
   static Constant *getImpl(StringRef Bytes, Type *Ty);
 
@@ -627,12 +638,6 @@
   /// efficient as getElementAsInteger/Float/Double.
   Constant *getElementAsConstant(unsigned i) const;
 
-  /// Specialize the getType() method to always return a SequentialType, which
-  /// reduces the amount of casting needed in parts of the compiler.
-  inline SequentialType *getType() const {
-    return cast<SequentialType>(Value::getType());
-  }
-
   /// Return the element type of the array/vector.
   Type *getElementType() const;
 
@@ -723,14 +728,15 @@
     return getImpl(Data, Ty);
   }
 
-  /// getFP() constructors - Return a constant with array type with an element
-  /// count and element type of float with precision matching the number of
-  /// bits in the ArrayRef passed in. (i.e. half for 16bits, float for 32bits,
-  /// double for 64bits) Note that this can return a ConstantAggregateZero
-  /// object.
-  static Constant *getFP(LLVMContext &Context, ArrayRef<uint16_t> Elts);
-  static Constant *getFP(LLVMContext &Context, ArrayRef<uint32_t> Elts);
-  static Constant *getFP(LLVMContext &Context, ArrayRef<uint64_t> Elts);
+  /// getFP() constructors - Return a constant of array type with a float
+  /// element type taken from argument `ElementType', and count taken from
+  /// argument `Elts'.  The amount of bits of the contained type must match the
+  /// number of bits of the type contained in the passed in ArrayRef.
+  /// (i.e. half or bfloat for 16bits, float for 32bits, double for 64bits) Note
+  /// that this can return a ConstantAggregateZero object.
+  static Constant *getFP(Type *ElementType, ArrayRef<uint16_t> Elts);
+  static Constant *getFP(Type *ElementType, ArrayRef<uint32_t> Elts);
+  static Constant *getFP(Type *ElementType, ArrayRef<uint64_t> Elts);
 
   /// This method constructs a CDS and initializes it with a text string.
   /// The default behavior (AddNull==true) causes a null terminator to
@@ -762,7 +768,12 @@
   friend class ConstantDataSequential;
 
   explicit ConstantDataVector(Type *ty, const char *Data)
-      : ConstantDataSequential(ty, ConstantDataVectorVal, Data) {}
+      : ConstantDataSequential(ty, ConstantDataVectorVal, Data),
+        IsSplatSet(false) {}
+  // Cache whether or not the constant is a splat.
+  mutable bool IsSplatSet : 1;
+  mutable bool IsSplat : 1;
+  bool isSplatData() const;
 
 public:
   ConstantDataVector(const ConstantDataVector &) = delete;
@@ -777,14 +788,15 @@
   static Constant *get(LLVMContext &Context, ArrayRef<float> Elts);
   static Constant *get(LLVMContext &Context, ArrayRef<double> Elts);
 
-  /// getFP() constructors - Return a constant with vector type with an element
-  /// count and element type of float with the precision matching the number of
-  /// bits in the ArrayRef passed in.  (i.e. half for 16bits, float for 32bits,
-  /// double for 64bits) Note that this can return a ConstantAggregateZero
-  /// object.
-  static Constant *getFP(LLVMContext &Context, ArrayRef<uint16_t> Elts);
-  static Constant *getFP(LLVMContext &Context, ArrayRef<uint32_t> Elts);
-  static Constant *getFP(LLVMContext &Context, ArrayRef<uint64_t> Elts);
+  /// getFP() constructors - Return a constant of vector type with a float
+  /// element type taken from argument `ElementType', and count taken from
+  /// argument `Elts'.  The amount of bits of the contained type must match the
+  /// number of bits of the type contained in the passed in ArrayRef.
+  /// (i.e. half or bfloat for 16bits, float for 32bits, double for 64bits) Note
+  /// that this can return a ConstantAggregateZero object.
+  static Constant *getFP(Type *ElementType, ArrayRef<uint16_t> Elts);
+  static Constant *getFP(Type *ElementType, ArrayRef<uint32_t> Elts);
+  static Constant *getFP(Type *ElementType, ArrayRef<uint64_t> Elts);
 
   /// Return a ConstantVector with the specified constant in each element.
   /// The specified constant has to be a of a compatible type (i8/i16/
@@ -799,10 +811,10 @@
   /// same value, return that value. Otherwise return NULL.
   Constant *getSplatValue() const;
 
-  /// Specialize the getType() method to always return a VectorType,
+  /// Specialize the getType() method to always return a FixedVectorType,
   /// which reduces the amount of casting needed in parts of the compiler.
-  inline VectorType *getType() const {
-    return cast<VectorType>(Value::getType());
+  inline FixedVectorType *getType() const {
+    return cast<FixedVectorType>(Value::getType());
   }
 
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
@@ -878,6 +890,42 @@
 
 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(BlockAddress, Value)
 
+/// Wrapper for a function that represents a value that
+/// functionally represents the original function. This can be a function,
+/// global alias to a function, or an ifunc.
+class DSOLocalEquivalent final : public Constant {
+  friend class Constant;
+
+  DSOLocalEquivalent(GlobalValue *GV);
+
+  void *operator new(size_t s) { return User::operator new(s, 1); }
+
+  void destroyConstantImpl();
+  Value *handleOperandChangeImpl(Value *From, Value *To);
+
+public:
+  /// Return a DSOLocalEquivalent for the specified global value.
+  static DSOLocalEquivalent *get(GlobalValue *GV);
+
+  /// Transparently provide more efficient getOperand methods.
+  DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
+
+  GlobalValue *getGlobalValue() const {
+    return cast<GlobalValue>(Op<0>().get());
+  }
+
+  /// Methods for support type inquiry through isa, cast, and dyn_cast:
+  static bool classof(const Value *V) {
+    return V->getValueID() == DSOLocalEquivalentVal;
+  }
+};
+
+template <>
+struct OperandTraits<DSOLocalEquivalent>
+    : public FixedNumOperandTraits<DSOLocalEquivalent, 1> {};
+
+DEFINE_TRANSPARENT_OPERAND_ACCESSORS(DSOLocalEquivalent, Value)
+
 //===----------------------------------------------------------------------===//
 /// A constant value that is initialized with an expression using
 /// other constant values.
@@ -899,6 +947,8 @@
     setValueSubclassData(Opcode);
   }
 
+  ~ConstantExpr() = default;
+
 public:
   // Static methods to construct a ConstantExpr of different kinds.  Note that
   // these methods may return a object that is not an instance of the
@@ -946,6 +996,7 @@
   static Constant *getAnd(Constant *C1, Constant *C2);
   static Constant *getOr(Constant *C1, Constant *C2);
   static Constant *getXor(Constant *C1, Constant *C2);
+  static Constant *getUMin(Constant *C1, Constant *C2);
   static Constant *getShl(Constant *C1, Constant *C2,
                           bool HasNUW = false, bool HasNSW = false);
   static Constant *getLShr(Constant *C1, Constant *C2, bool isExact = false);
@@ -1021,6 +1072,12 @@
     return getLShr(C1, C2, true);
   }
 
+  /// If C is a scalar/fixed width vector of known powers of 2, then this
+  /// function returns a new scalar/fixed width vector obtained from logBase2
+  /// of C. Undef vector elements are set to zero.
+  /// Return a null pointer otherwise.
+  static Constant *getExactLogBase2(Constant *C);
+
   /// Return the identity constant for a binary opcode.
   /// The identity constant C is defined as X op C = X and C op X = X for every
   /// X when the binary operation is commutative. If the binop is not
@@ -1197,7 +1254,8 @@
                                      Type *OnlyIfReducedTy = nullptr);
   static Constant *getInsertElement(Constant *Vec, Constant *Elt, Constant *Idx,
                                     Type *OnlyIfReducedTy = nullptr);
-  static Constant *getShuffleVector(Constant *V1, Constant *V2, Constant *Mask,
+  static Constant *getShuffleVector(Constant *V1, Constant *V2,
+                                    ArrayRef<int> Mask,
                                     Type *OnlyIfReducedTy = nullptr);
   static Constant *getExtractValue(Constant *Agg, ArrayRef<unsigned> Idxs,
                                    Type *OnlyIfReducedTy = nullptr);
@@ -1216,6 +1274,16 @@
   /// expression and return the list of indices.
   ArrayRef<unsigned> getIndices() const;
 
+  /// Assert that this is a shufflevector and return the mask. See class
+  /// ShuffleVectorInst for a description of the mask representation.
+  ArrayRef<int> getShuffleMask() const;
+
+  /// Assert that this is a shufflevector and return the mask.
+  ///
+  /// TODO: This is a temporary hack until we update the bitcode format for
+  /// shufflevector.
+  Constant *getShuffleMaskForBitcode() const;
+
   /// Return a string representation for an opcode.
   const char *getOpcodeName() const;
 
@@ -1250,7 +1318,7 @@
   /// which would take a ConstantExpr parameter, but that would have spread
   /// implementation details of ConstantExpr outside of Constants.cpp, which
   /// would make it harder to remove ConstantExprs altogether.
-  Instruction *getAsInstruction();
+  Instruction *getAsInstruction() const;
 
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Value *V) {
@@ -1282,13 +1350,16 @@
 /// can appear to have different bit patterns at each use. See
 /// LangRef.html#undefvalues for details.
 ///
-class UndefValue final : public ConstantData {
+class UndefValue : public ConstantData {
   friend class Constant;
 
   explicit UndefValue(Type *T) : ConstantData(T, UndefValueVal) {}
 
   void destroyConstantImpl();
 
+protected:
+  explicit UndefValue(Type *T, ValueTy vty) : ConstantData(T, vty) {}
+
 public:
   UndefValue(const UndefValue &) = delete;
 
@@ -1315,7 +1386,49 @@
 
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Value *V) {
-    return V->getValueID() == UndefValueVal;
+    return V->getValueID() == UndefValueVal ||
+           V->getValueID() == PoisonValueVal;
+  }
+};
+
+//===----------------------------------------------------------------------===//
+/// In order to facilitate speculative execution, many instructions do not
+/// invoke immediate undefined behavior when provided with illegal operands,
+/// and return a poison value instead.
+///
+/// see LangRef.html#poisonvalues for details.
+///
+class PoisonValue final : public UndefValue {
+  friend class Constant;
+
+  explicit PoisonValue(Type *T) : UndefValue(T, PoisonValueVal) {}
+
+  void destroyConstantImpl();
+
+public:
+  PoisonValue(const PoisonValue &) = delete;
+
+  /// Static factory methods - Return an 'poison' object of the specified type.
+  static PoisonValue *get(Type *T);
+
+  /// If this poison has array or vector type, return a poison with the right
+  /// element type.
+  PoisonValue *getSequentialElement() const;
+
+  /// If this poison has struct type, return a poison with the right element
+  /// type for the specified element.
+  PoisonValue *getStructElement(unsigned Elt) const;
+
+  /// Return an poison of the right value for the specified GEP index if we can,
+  /// otherwise return null (e.g. if C is a ConstantExpr).
+  PoisonValue *getElementValue(Constant *C) const;
+
+  /// Return an poison of the right value for the specified GEP index.
+  PoisonValue *getElementValue(unsigned Idx) const;
+
+  /// Methods for support type inquiry through isa, cast, and dyn_cast:
+  static bool classof(const Value *V) {
+    return V->getValueID() == PoisonValueVal;
   }
 };
 
diff --git a/linux-x64/clang/include/llvm/IR/ConstrainedOps.def b/linux-x64/clang/include/llvm/IR/ConstrainedOps.def
new file mode 100644
index 0000000..ecba68f
--- /dev/null
+++ b/linux-x64/clang/include/llvm/IR/ConstrainedOps.def
@@ -0,0 +1,107 @@
+//===- llvm/IR/ConstrainedOps.def - Constrained intrinsics ------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Defines properties of constrained intrinsics, in particular corresponding
+// floating point operations and DAG nodes.
+//
+//===----------------------------------------------------------------------===//
+
+// DAG_FUNCTION defers to DAG_INSTRUCTION if its defined, otherwise FUNCTION.
+#ifndef DAG_FUNCTION
+#ifdef DAG_INSTRUCTION
+#define DAG_FUNCTION(N,A,R,I,D) DAG_INSTRUCTION(N,A,R,I,D)
+#else
+#define DAG_FUNCTION(N,A,R,I,D) FUNCTION(N,A,R,I)
+#endif
+#endif
+
+#ifndef INSTRUCTION
+#define INSTRUCTION(N,A,R,I)
+#endif
+
+// DAG_INSTRUCTION is treated like an INSTRUCTION if the DAG node isn't used.
+#ifndef DAG_INSTRUCTION
+#define DAG_INSTRUCTION(N,A,R,I,D) INSTRUCTION(N,A,R,I)
+#endif
+
+// In most cases intrinsic function is handled similar to instruction.
+#ifndef FUNCTION
+#define FUNCTION(N,A,R,I) INSTRUCTION(N,A,R,I)
+#endif
+
+// Compare instruction have a DAG node so they are treated like DAG_INSTRUCTION.
+#ifndef CMP_INSTRUCTION
+#define CMP_INSTRUCTION(N,A,R,I,D) DAG_INSTRUCTION(N,A,R,I,D)
+#endif
+
+// Arguments of the entries are:
+// - instruction or intrinsic function name.
+// - Number of original instruction/intrinsic arguments.
+// - 1 if the corresponding constrained intrinsic has rounding mode argument.
+// - name of the constrained intrinsic to represent this instruction/function.
+// - DAG node corresponding to the constrained intrinsic without prefix STRICT_.
+
+// These are definitions for instructions, that are converted into constrained
+// intrinsics.
+//
+DAG_INSTRUCTION(FAdd,         2, 1, experimental_constrained_fadd,       FADD)
+DAG_INSTRUCTION(FSub,         2, 1, experimental_constrained_fsub,       FSUB)
+DAG_INSTRUCTION(FMul,         2, 1, experimental_constrained_fmul,       FMUL)
+DAG_INSTRUCTION(FDiv,         2, 1, experimental_constrained_fdiv,       FDIV)
+DAG_INSTRUCTION(FRem,         2, 1, experimental_constrained_frem,       FREM)
+DAG_INSTRUCTION(FPExt,        1, 0, experimental_constrained_fpext,      FP_EXTEND)
+DAG_INSTRUCTION(SIToFP,       1, 1, experimental_constrained_sitofp,     SINT_TO_FP)
+DAG_INSTRUCTION(UIToFP,       1, 1, experimental_constrained_uitofp,     UINT_TO_FP)
+DAG_INSTRUCTION(FPToSI,       1, 0, experimental_constrained_fptosi,     FP_TO_SINT)
+DAG_INSTRUCTION(FPToUI,       1, 0, experimental_constrained_fptoui,     FP_TO_UINT)
+DAG_INSTRUCTION(FPTrunc,      1, 1, experimental_constrained_fptrunc,    FP_ROUND)
+
+// These are definitions for compare instructions (signaling and quiet version).
+// Both of these match to FCmp / SETCC.
+CMP_INSTRUCTION(FCmp,         2, 0, experimental_constrained_fcmp,       FSETCC)
+CMP_INSTRUCTION(FCmp,         2, 0, experimental_constrained_fcmps,      FSETCCS)
+
+// Theses are definitions for intrinsic functions, that are converted into
+// constrained intrinsics.
+//
+DAG_FUNCTION(ceil,            1, 0, experimental_constrained_ceil,       FCEIL)
+DAG_FUNCTION(cos,             1, 1, experimental_constrained_cos,        FCOS)
+DAG_FUNCTION(exp,             1, 1, experimental_constrained_exp,        FEXP)
+DAG_FUNCTION(exp2,            1, 1, experimental_constrained_exp2,       FEXP2)
+DAG_FUNCTION(floor,           1, 0, experimental_constrained_floor,      FFLOOR)
+DAG_FUNCTION(fma,             3, 1, experimental_constrained_fma,        FMA)
+DAG_FUNCTION(log,             1, 1, experimental_constrained_log,        FLOG)
+DAG_FUNCTION(log10,           1, 1, experimental_constrained_log10,      FLOG10)
+DAG_FUNCTION(log2,            1, 1, experimental_constrained_log2,       FLOG2)
+DAG_FUNCTION(lrint,           1, 1, experimental_constrained_lrint,      LRINT)
+DAG_FUNCTION(llrint,          1, 1, experimental_constrained_llrint,     LLRINT)
+DAG_FUNCTION(lround,          1, 0, experimental_constrained_lround,     LROUND)
+DAG_FUNCTION(llround,         1, 0, experimental_constrained_llround,    LLROUND)
+DAG_FUNCTION(maxnum,          2, 0, experimental_constrained_maxnum,     FMAXNUM)
+DAG_FUNCTION(minnum,          2, 0, experimental_constrained_minnum,     FMINNUM)
+DAG_FUNCTION(maximum,         2, 0, experimental_constrained_maximum,    FMAXIMUM)
+DAG_FUNCTION(minimum,         2, 0, experimental_constrained_minimum,    FMINIMUM)
+DAG_FUNCTION(nearbyint,       1, 1, experimental_constrained_nearbyint,  FNEARBYINT)
+DAG_FUNCTION(pow,             2, 1, experimental_constrained_pow,        FPOW)
+DAG_FUNCTION(powi,            2, 1, experimental_constrained_powi,       FPOWI)
+DAG_FUNCTION(rint,            1, 1, experimental_constrained_rint,       FRINT)
+DAG_FUNCTION(round,           1, 0, experimental_constrained_round,      FROUND)
+DAG_FUNCTION(roundeven,       1, 0, experimental_constrained_roundeven,  FROUNDEVEN)
+DAG_FUNCTION(sin,             1, 1, experimental_constrained_sin,        FSIN)
+DAG_FUNCTION(sqrt,            1, 1, experimental_constrained_sqrt,       FSQRT)
+DAG_FUNCTION(trunc,           1, 0, experimental_constrained_trunc,      FTRUNC)
+
+// This is definition for fmuladd intrinsic function, that is converted into
+// constrained FMA or FMUL + FADD intrinsics.
+FUNCTION(fmuladd,         3, 1, experimental_constrained_fmuladd)
+
+#undef INSTRUCTION
+#undef FUNCTION
+#undef CMP_INSTRUCTION
+#undef DAG_INSTRUCTION
+#undef DAG_FUNCTION
diff --git a/linux-x64/clang/include/llvm/IR/DIBuilder.h b/linux-x64/clang/include/llvm/IR/DIBuilder.h
index ad9a35b..e023856 100644
--- a/linux-x64/clang/include/llvm/IR/DIBuilder.h
+++ b/linux-x64/clang/include/llvm/IR/DIBuilder.h
@@ -135,6 +135,9 @@
     ///                              profile collection.
     /// \param NameTableKind  Whether to emit .debug_gnu_pubnames,
     ///                      .debug_pubnames, or no pubnames at all.
+    /// \param SysRoot       The clang system root (value of -isysroot).
+    /// \param SDK           The SDK name. On Darwin, this is the last component
+    ///                      of the sysroot.
     DICompileUnit *
     createCompileUnit(unsigned Lang, DIFile *File, StringRef Producer,
                       bool isOptimized, StringRef Flags, unsigned RV,
@@ -145,7 +148,8 @@
                       bool DebugInfoForProfiling = false,
                       DICompileUnit::DebugNameTableKind NameTableKind =
                           DICompileUnit::DebugNameTableKind::Default,
-                      bool RangesBaseAddress = false);
+                      bool RangesBaseAddress = false, StringRef SysRoot = {},
+                      StringRef SDK = {});
 
     /// Create a file descriptor to hold debugging information for a file.
     /// \param Filename  File name.
@@ -195,6 +199,12 @@
                                  unsigned Encoding,
                                  DINode::DIFlags Flags = DINode::FlagZero);
 
+    /// Create debugging information entry for a string
+    /// type.
+    /// \param Name        Type name.
+    /// \param SizeInBits  Size of the type.
+    DIStringType *createStringType(StringRef Name, uint64_t SizeInBits);
+
     /// Create debugging information entry for a qualified
     /// type, e.g. 'const int'.
     /// \param Tag         Tag identifing type, e.g. dwarf::TAG_volatile_type
@@ -237,8 +247,10 @@
     /// \param File        File where this type is defined.
     /// \param LineNo      Line number.
     /// \param Context     The surrounding context for the typedef.
+    /// \param AlignInBits Alignment. (optional)
     DIDerivedType *createTypedef(DIType *Ty, StringRef Name, DIFile *File,
-                                 unsigned LineNo, DIScope *Context);
+                                 unsigned LineNo, DIScope *Context,
+                                 uint32_t AlignInBits = 0);
 
     /// Create debugging information entry for a 'friend'.
     DIDerivedType *createFriend(DIType *Ty, DIType *FriendTy);
@@ -440,19 +452,22 @@
     /// \param Scope        Scope in which this type is defined.
     /// \param Name         Type parameter name.
     /// \param Ty           Parameter type.
-    DITemplateTypeParameter *
-    createTemplateTypeParameter(DIScope *Scope, StringRef Name, DIType *Ty);
+    /// \param IsDefault    Parameter is default or not
+    DITemplateTypeParameter *createTemplateTypeParameter(DIScope *Scope,
+                                                         StringRef Name,
+                                                         DIType *Ty,
+                                                         bool IsDefault);
 
     /// Create debugging information for template
     /// value parameter.
     /// \param Scope        Scope in which this type is defined.
     /// \param Name         Value parameter name.
     /// \param Ty           Parameter type.
+    /// \param IsDefault    Parameter is default or not
     /// \param Val          Constant parameter value.
-    DITemplateValueParameter *createTemplateValueParameter(DIScope *Scope,
-                                                           StringRef Name,
-                                                           DIType *Ty,
-                                                           Constant *Val);
+    DITemplateValueParameter *
+    createTemplateValueParameter(DIScope *Scope, StringRef Name, DIType *Ty,
+                                 bool IsDefault, Constant *Val);
 
     /// Create debugging information for a template template parameter.
     /// \param Scope        Scope in which this type is defined.
@@ -479,8 +494,24 @@
     /// \param AlignInBits  Alignment.
     /// \param Ty           Element type.
     /// \param Subscripts   Subscripts.
-    DICompositeType *createArrayType(uint64_t Size, uint32_t AlignInBits,
-                                     DIType *Ty, DINodeArray Subscripts);
+    /// \param DataLocation The location of the raw data of a descriptor-based
+    ///                     Fortran array, either a DIExpression* or
+    ///                     a DIVariable*.
+    /// \param Associated   The associated attribute of a descriptor-based
+    ///                     Fortran array, either a DIExpression* or
+    ///                     a DIVariable*.
+    /// \param Allocated    The allocated attribute of a descriptor-based
+    ///                     Fortran array, either a DIExpression* or
+    ///                     a DIVariable*.
+    /// \param Rank         The rank attribute of a descriptor-based
+    ///                     Fortran array, either a DIExpression* or
+    ///                     a DIVariable*.
+    DICompositeType *createArrayType(
+        uint64_t Size, uint32_t AlignInBits, DIType *Ty, DINodeArray Subscripts,
+        PointerUnion<DIExpression *, DIVariable *> DataLocation = nullptr,
+        PointerUnion<DIExpression *, DIVariable *> Associated = nullptr,
+        PointerUnion<DIExpression *, DIVariable *> Allocated = nullptr,
+        PointerUnion<DIExpression *, DIVariable *> Rank = nullptr);
 
     /// Create debugging information entry for a vector type.
     /// \param Size         Array size.
@@ -564,6 +595,14 @@
     /// implicitly uniques the values returned.
     DISubrange *getOrCreateSubrange(int64_t Lo, int64_t Count);
     DISubrange *getOrCreateSubrange(int64_t Lo, Metadata *CountNode);
+    DISubrange *getOrCreateSubrange(Metadata *Count, Metadata *LowerBound,
+                                    Metadata *UpperBound, Metadata *Stride);
+
+    DIGenericSubrange *
+    getOrCreateGenericSubrange(DIGenericSubrange::BoundType Count,
+                               DIGenericSubrange::BoundType LowerBound,
+                               DIGenericSubrange::BoundType UpperBound,
+                               DIGenericSubrange::BoundType Stride);
 
     /// Create a new descriptor for the specified variable.
     /// \param Context     Variable scope.
@@ -572,7 +611,7 @@
     /// \param File        File where this variable is defined.
     /// \param LineNo      Line number.
     /// \param Ty          Variable Type.
-    /// \param isLocalToUnit Boolean flag indicate whether this variable is
+    /// \param IsLocalToUnit Boolean flag indicate whether this variable is
     ///                      externally visible or not.
     /// \param Expr        The location of the global relative to the attached
     ///                    GlobalVariable.
@@ -581,16 +620,16 @@
     ///                    specified)
     DIGlobalVariableExpression *createGlobalVariableExpression(
         DIScope *Context, StringRef Name, StringRef LinkageName, DIFile *File,
-        unsigned LineNo, DIType *Ty, bool isLocalToUnit,
+        unsigned LineNo, DIType *Ty, bool IsLocalToUnit, bool isDefined = true,
         DIExpression *Expr = nullptr, MDNode *Decl = nullptr,
-        MDTuple *templateParams = nullptr, uint32_t AlignInBits = 0);
+        MDTuple *TemplateParams = nullptr, uint32_t AlignInBits = 0);
 
     /// Identical to createGlobalVariable
     /// except that the resulting DbgNode is temporary and meant to be RAUWed.
     DIGlobalVariable *createTempGlobalVariableFwdDecl(
         DIScope *Context, StringRef Name, StringRef LinkageName, DIFile *File,
-        unsigned LineNo, DIType *Ty, bool isLocalToUnit, MDNode *Decl = nullptr,
-        MDTuple *templateParams = nullptr, uint32_t AlignInBits = 0);
+        unsigned LineNo, DIType *Ty, bool IsLocalToUnit, MDNode *Decl = nullptr,
+        MDTuple *TemplateParams= nullptr, uint32_t AlignInBits = 0);
 
     /// Create a new descriptor for an auto variable.  This is a local variable
     /// that is not a subprogram parameter.
@@ -732,11 +771,19 @@
     ///                    A space-separated shell-quoted list of -D macro
     ///                    definitions as they would appear on a command line.
     /// \param IncludePath The path to the module map file.
-    /// \param ISysRoot    The clang system root (value of -isysroot).
+    /// \param APINotesFile The path to an API notes file for this module.
+    /// \param File        Source file of the module.
+    ///                    Used for Fortran modules.
+    /// \param LineNo      Source line number of the module.
+    ///                    Used for Fortran modules.
+    /// \param IsDecl      This is a module declaration; default to false;
+    ///                    when set to true, only Scope and Name are required
+    ///                    as this entry is just a hint for the debugger to find
+    ///                    the corresponding definition in the global scope.
     DIModule *createModule(DIScope *Scope, StringRef Name,
-                           StringRef ConfigurationMacros,
-                           StringRef IncludePath,
-                           StringRef ISysRoot);
+                           StringRef ConfigurationMacros, StringRef IncludePath,
+                           StringRef APINotesFile = {}, DIFile *File = nullptr,
+                           unsigned LineNo = 0, bool IsDecl = false);
 
     /// This creates a descriptor for a lexical block with a new file
     /// attached. This merely extends the existing
diff --git a/linux-x64/clang/include/llvm/IR/DataLayout.h b/linux-x64/clang/include/llvm/IR/DataLayout.h
index ac9770a..eb03161 100644
--- a/linux-x64/clang/include/llvm/IR/DataLayout.h
+++ b/linux-x64/clang/include/llvm/IR/DataLayout.h
@@ -25,10 +25,11 @@
 #include "llvm/ADT/StringRef.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Type.h"
-#include "llvm/Pass.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MathExtras.h"
+#include "llvm/Support/Alignment.h"
+#include "llvm/Support/TypeSize.h"
 #include <cassert>
 #include <cstdint>
 #include <string>
@@ -71,11 +72,11 @@
   /// Alignment type from \c AlignTypeEnum
   unsigned AlignType : 8;
   unsigned TypeBitWidth : 24;
-  unsigned ABIAlign : 16;
-  unsigned PrefAlign : 16;
+  Align ABIAlign;
+  Align PrefAlign;
 
-  static LayoutAlignElem get(AlignTypeEnum align_type, unsigned abi_align,
-                             unsigned pref_align, uint32_t bit_width);
+  static LayoutAlignElem get(AlignTypeEnum align_type, Align abi_align,
+                             Align pref_align, uint32_t bit_width);
 
   bool operator==(const LayoutAlignElem &rhs) const;
 };
@@ -87,15 +88,15 @@
 /// \note The unusual order of elements in the structure attempts to reduce
 /// padding and make the structure slightly more cache friendly.
 struct PointerAlignElem {
-  unsigned ABIAlign;
-  unsigned PrefAlign;
+  Align ABIAlign;
+  Align PrefAlign;
   uint32_t TypeByteWidth;
   uint32_t AddressSpace;
   uint32_t IndexWidth;
 
   /// Initializer
-  static PointerAlignElem get(uint32_t AddressSpace, unsigned ABIAlign,
-                              unsigned PrefAlign, uint32_t TypeByteWidth,
+  static PointerAlignElem get(uint32_t AddressSpace, Align ABIAlign,
+                              Align PrefAlign, uint32_t TypeByteWidth,
                               uint32_t IndexWidth);
 
   bool operator==(const PointerAlignElem &rhs) const;
@@ -120,10 +121,11 @@
   bool BigEndian;
 
   unsigned AllocaAddrSpace;
-  unsigned StackNaturalAlign;
+  MaybeAlign StackNaturalAlign;
   unsigned ProgramAddrSpace;
+  unsigned DefaultGlobalsAddrSpace;
 
-  unsigned FunctionPtrAlign;
+  MaybeAlign FunctionPtrAlign;
   FunctionPtrAlignType TheFunctionPtrAlignType;
 
   enum ManglingModeT {
@@ -132,7 +134,8 @@
     MM_MachO,
     MM_WinCOFF,
     MM_WinCOFFX86,
-    MM_Mips
+    MM_Mips,
+    MM_XCOFF
   };
   ManglingModeT ManglingMode;
 
@@ -158,12 +161,7 @@
   using PointersTy = SmallVector<PointerAlignElem, 8>;
   PointersTy Pointers;
 
-  PointersTy::const_iterator
-  findPointerLowerBound(uint32_t AddressSpace) const {
-    return const_cast<DataLayout *>(this)->findPointerLowerBound(AddressSpace);
-  }
-
-  PointersTy::iterator findPointerLowerBound(uint32_t AddressSpace);
+  const PointerAlignElem &getPointerAlignElem(uint32_t AddressSpace) const;
 
   // The StructType -> StructLayout map.
   mutable void *LayoutMap = nullptr;
@@ -172,20 +170,25 @@
   /// well-defined bitwise representation.
   SmallVector<unsigned, 8> NonIntegralAddressSpaces;
 
-  void setAlignment(AlignTypeEnum align_type, unsigned abi_align,
-                    unsigned pref_align, uint32_t bit_width);
-  unsigned getAlignmentInfo(AlignTypeEnum align_type, uint32_t bit_width,
-                            bool ABIAlign, Type *Ty) const;
-  void setPointerAlignment(uint32_t AddrSpace, unsigned ABIAlign,
-                           unsigned PrefAlign, uint32_t TypeByteWidth,
-                           uint32_t IndexWidth);
+  /// Attempts to set the alignment of the given type. Returns an error
+  /// description on failure.
+  Error setAlignment(AlignTypeEnum align_type, Align abi_align,
+                     Align pref_align, uint32_t bit_width);
+
+  /// Attempts to set the alignment of a pointer in the given address space.
+  /// Returns an error description on failure.
+  Error setPointerAlignment(uint32_t AddrSpace, Align ABIAlign, Align PrefAlign,
+                            uint32_t TypeByteWidth, uint32_t IndexWidth);
+
+  /// Internal helper to get alignment for integer of given bitwidth.
+  Align getIntegerAlignment(uint32_t BitWidth, bool abi_or_pref) const;
 
   /// Internal helper method that returns requested alignment for type.
-  unsigned getAlignment(Type *Ty, bool abi_or_pref) const;
+  Align getAlignment(Type *Ty, bool abi_or_pref) const;
 
-  /// Parses a target data specification string. Assert if the string is
-  /// malformed.
-  void parseSpecifier(StringRef LayoutDescription);
+  /// Attempts to parse a target data specification string and reports an error
+  /// if the string is malformed.
+  Error parseSpecifier(StringRef Desc);
 
   // Free all internal data structures.
   void clear();
@@ -212,6 +215,7 @@
     FunctionPtrAlign = DL.FunctionPtrAlign;
     TheFunctionPtrAlignType = DL.TheFunctionPtrAlignType;
     ProgramAddrSpace = DL.ProgramAddrSpace;
+    DefaultGlobalsAddrSpace = DL.DefaultGlobalsAddrSpace;
     ManglingMode = DL.ManglingMode;
     LegalIntWidths = DL.LegalIntWidths;
     Alignments = DL.Alignments;
@@ -228,6 +232,10 @@
   /// Parse a data layout string (with fallback to default values).
   void reset(StringRef LayoutDescription);
 
+  /// Parse a data layout string and return the layout. Return an error
+  /// description on failure.
+  static Expected<DataLayout> parse(StringRef LayoutDescription);
+
   /// Layout endianness...
   bool isLittleEndian() const { return !BigEndian; }
   bool isBigEndian() const { return BigEndian; }
@@ -261,17 +269,21 @@
   bool isIllegalInteger(uint64_t Width) const { return !isLegalInteger(Width); }
 
   /// Returns true if the given alignment exceeds the natural stack alignment.
-  bool exceedsNaturalStackAlignment(unsigned Align) const {
-    return (StackNaturalAlign != 0) && (Align > StackNaturalAlign);
+  bool exceedsNaturalStackAlignment(Align Alignment) const {
+    return StackNaturalAlign && (Alignment > *StackNaturalAlign);
   }
 
-  unsigned getStackAlignment() const { return StackNaturalAlign; }
+  Align getStackAlignment() const {
+    assert(StackNaturalAlign && "StackNaturalAlign must be defined");
+    return *StackNaturalAlign;
+  }
+
   unsigned getAllocaAddrSpace() const { return AllocaAddrSpace; }
 
   /// Returns the alignment of function pointers, which may or may not be
   /// related to the alignment of functions.
   /// \see getFunctionPtrAlignType
-  unsigned getFunctionPtrAlign() const { return FunctionPtrAlign; }
+  MaybeAlign getFunctionPtrAlign() const { return FunctionPtrAlign; }
 
   /// Return the type of function pointer alignment.
   /// \see getFunctionPtrAlign
@@ -280,6 +292,9 @@
   }
 
   unsigned getProgramAddressSpace() const { return ProgramAddrSpace; }
+  unsigned getDefaultGlobalsAddressSpace() const {
+    return DefaultGlobalsAddrSpace;
+  }
 
   bool hasMicrosoftFastStdCallMangling() const {
     return ManglingMode == MM_WinCOFFX86;
@@ -305,6 +320,7 @@
     case MM_ELF:
     case MM_Mips:
     case MM_WinCOFF:
+    case MM_XCOFF:
       return '\0';
     case MM_MachO:
     case MM_WinCOFFX86:
@@ -325,6 +341,8 @@
     case MM_MachO:
     case MM_WinCOFFX86:
       return "L";
+    case MM_XCOFF:
+      return "L..";
     }
     llvm_unreachable("invalid mangling mode");
   }
@@ -344,12 +362,12 @@
   }
 
   /// Layout pointer alignment
-  unsigned getPointerABIAlignment(unsigned AS) const;
+  Align getPointerABIAlignment(unsigned AS) const;
 
   /// Return target's alignment for stack-based pointers
   /// FIXME: The defaults need to be removed once all of
   /// the backends/clients are updated.
-  unsigned getPointerPrefAlignment(unsigned AS = 0) const;
+  Align getPointerPrefAlignment(unsigned AS = 0) const;
 
   /// Layout pointer size
   /// FIXME: The defaults need to be removed once all of
@@ -370,7 +388,7 @@
 
   bool isNonIntegralAddressSpace(unsigned AddrSpace) const {
     ArrayRef<unsigned> NonIntegralSpaces = getNonIntegralAddressSpaces();
-    return find(NonIntegralSpaces, AddrSpace) != NonIntegralSpaces.end();
+    return is_contained(NonIntegralSpaces, AddrSpace);
   }
 
   bool isNonIntegralPointerType(PointerType *PT) const {
@@ -433,23 +451,33 @@
 
   /// Returns the number of bits necessary to hold the specified type.
   ///
+  /// If Ty is a scalable vector type, the scalable property will be set and
+  /// the runtime size will be a positive integer multiple of the base size.
+  ///
   /// For example, returns 36 for i36 and 80 for x86_fp80. The type passed must
   /// have a size (Type::isSized() must return true).
-  uint64_t getTypeSizeInBits(Type *Ty) const;
+  TypeSize getTypeSizeInBits(Type *Ty) const;
 
   /// Returns the maximum number of bytes that may be overwritten by
   /// storing the specified type.
   ///
+  /// If Ty is a scalable vector type, the scalable property will be set and
+  /// the runtime size will be a positive integer multiple of the base size.
+  ///
   /// For example, returns 5 for i36 and 10 for x86_fp80.
-  uint64_t getTypeStoreSize(Type *Ty) const {
-    return (getTypeSizeInBits(Ty) + 7) / 8;
+  TypeSize getTypeStoreSize(Type *Ty) const {
+    TypeSize BaseSize = getTypeSizeInBits(Ty);
+    return { (BaseSize.getKnownMinSize() + 7) / 8, BaseSize.isScalable() };
   }
 
   /// Returns the maximum number of bits that may be overwritten by
   /// storing the specified type; always a multiple of 8.
   ///
+  /// If Ty is a scalable vector type, the scalable property will be set and
+  /// the runtime size will be a positive integer multiple of the base size.
+  ///
   /// For example, returns 40 for i36 and 80 for x86_fp80.
-  uint64_t getTypeStoreSizeInBits(Type *Ty) const {
+  TypeSize getTypeStoreSizeInBits(Type *Ty) const {
     return 8 * getTypeStoreSize(Ty);
   }
 
@@ -464,9 +492,12 @@
   /// Returns the offset in bytes between successive objects of the
   /// specified type, including alignment padding.
   ///
+  /// If Ty is a scalable vector type, the scalable property will be set and
+  /// the runtime size will be a positive integer multiple of the base size.
+  ///
   /// This is the amount that alloca reserves for this type. For example,
   /// returns 12 or 16 for x86_fp80, depending on alignment.
-  uint64_t getTypeAllocSize(Type *Ty) const {
+  TypeSize getTypeAllocSize(Type *Ty) const {
     // Round up to the next alignment boundary.
     return alignTo(getTypeStoreSize(Ty), getABITypeAlignment(Ty));
   }
@@ -474,28 +505,47 @@
   /// Returns the offset in bits between successive objects of the
   /// specified type, including alignment padding; always a multiple of 8.
   ///
+  /// If Ty is a scalable vector type, the scalable property will be set and
+  /// the runtime size will be a positive integer multiple of the base size.
+  ///
   /// This is the amount that alloca reserves for this type. For example,
   /// returns 96 or 128 for x86_fp80, depending on alignment.
-  uint64_t getTypeAllocSizeInBits(Type *Ty) const {
+  TypeSize getTypeAllocSizeInBits(Type *Ty) const {
     return 8 * getTypeAllocSize(Ty);
   }
 
   /// Returns the minimum ABI-required alignment for the specified type.
+  /// FIXME: Deprecate this function once migration to Align is over.
   unsigned getABITypeAlignment(Type *Ty) const;
 
+  /// Returns the minimum ABI-required alignment for the specified type.
+  Align getABITypeAlign(Type *Ty) const;
+
+  /// Helper function to return `Alignment` if it's set or the result of
+  /// `getABITypeAlignment(Ty)`, in any case the result is a valid alignment.
+  inline Align getValueOrABITypeAlignment(MaybeAlign Alignment,
+                                          Type *Ty) const {
+    return Alignment ? *Alignment : getABITypeAlign(Ty);
+  }
+
   /// Returns the minimum ABI-required alignment for an integer type of
   /// the specified bitwidth.
-  unsigned getABIIntegerTypeAlignment(unsigned BitWidth) const;
+  Align getABIIntegerTypeAlignment(unsigned BitWidth) const {
+    return getIntegerAlignment(BitWidth, /* abi_or_pref */ true);
+  }
 
   /// Returns the preferred stack/global alignment for the specified
   /// type.
   ///
   /// This is always at least as good as the ABI alignment.
+  /// FIXME: Deprecate this function once migration to Align is over.
   unsigned getPrefTypeAlignment(Type *Ty) const;
 
-  /// Returns the preferred alignment for the specified type, returned as
-  /// log2 of the value (a shift amount).
-  unsigned getPreferredTypeAlignmentShift(Type *Ty) const;
+  /// Returns the preferred stack/global alignment for the specified
+  /// type.
+  ///
+  /// This is always at least as good as the ABI alignment.
+  Align getPrefTypeAlign(Type *Ty) const;
 
   /// Returns an integer type with size at least as big as that of a
   /// pointer in the given address space.
@@ -540,13 +590,26 @@
   /// Returns the preferred alignment of the specified global.
   ///
   /// This includes an explicitly requested alignment (if the global has one).
-  unsigned getPreferredAlignment(const GlobalVariable *GV) const;
+  Align getPreferredAlign(const GlobalVariable *GV) const;
+
+  /// Returns the preferred alignment of the specified global.
+  ///
+  /// This includes an explicitly requested alignment (if the global has one).
+  LLVM_ATTRIBUTE_DEPRECATED(
+      inline unsigned getPreferredAlignment(const GlobalVariable *GV) const,
+      "Use getPreferredAlign instead") {
+    return getPreferredAlign(GV).value();
+  }
 
   /// Returns the preferred alignment of the specified global, returned
   /// in log form.
   ///
   /// This includes an explicitly requested alignment (if the global has one).
-  unsigned getPreferredAlignmentLog(const GlobalVariable *GV) const;
+  LLVM_ATTRIBUTE_DEPRECATED(
+      inline unsigned getPreferredAlignmentLog(const GlobalVariable *GV) const,
+      "Inline where needed") {
+    return Log2(getPreferredAlign(GV));
+  }
 };
 
 inline DataLayout *unwrap(LLVMTargetDataRef P) {
@@ -561,7 +624,7 @@
 /// based on the DataLayout structure.
 class StructLayout {
   uint64_t StructSize;
-  unsigned StructAlignment;
+  Align StructAlignment;
   unsigned IsPadded : 1;
   unsigned NumElements : 31;
   uint64_t MemberOffsets[1]; // variable sized array!
@@ -571,7 +634,7 @@
 
   uint64_t getSizeInBits() const { return 8 * StructSize; }
 
-  unsigned getAlignment() const { return StructAlignment; }
+  Align getAlignment() const { return StructAlignment; }
 
   /// Returns whether the struct has padding or not between its fields.
   /// NB: Padding in nested element is not taken into account.
@@ -598,13 +661,13 @@
 
 // The implementation of this method is provided inline as it is particularly
 // well suited to constant folding when called on a specific Type subclass.
-inline uint64_t DataLayout::getTypeSizeInBits(Type *Ty) const {
+inline TypeSize DataLayout::getTypeSizeInBits(Type *Ty) const {
   assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!");
   switch (Ty->getTypeID()) {
   case Type::LabelTyID:
-    return getPointerSizeInBits(0);
+    return TypeSize::Fixed(getPointerSizeInBits(0));
   case Type::PointerTyID:
-    return getPointerSizeInBits(Ty->getPointerAddressSpace());
+    return TypeSize::Fixed(getPointerSizeInBits(Ty->getPointerAddressSpace()));
   case Type::ArrayTyID: {
     ArrayType *ATy = cast<ArrayType>(Ty);
     return ATy->getNumElements() *
@@ -612,26 +675,34 @@
   }
   case Type::StructTyID:
     // Get the layout annotation... which is lazily created on demand.
-    return getStructLayout(cast<StructType>(Ty))->getSizeInBits();
+    return TypeSize::Fixed(
+                        getStructLayout(cast<StructType>(Ty))->getSizeInBits());
   case Type::IntegerTyID:
-    return Ty->getIntegerBitWidth();
+    return TypeSize::Fixed(Ty->getIntegerBitWidth());
   case Type::HalfTyID:
-    return 16;
+  case Type::BFloatTyID:
+    return TypeSize::Fixed(16);
   case Type::FloatTyID:
-    return 32;
+    return TypeSize::Fixed(32);
   case Type::DoubleTyID:
   case Type::X86_MMXTyID:
-    return 64;
+    return TypeSize::Fixed(64);
   case Type::PPC_FP128TyID:
   case Type::FP128TyID:
-    return 128;
+    return TypeSize::Fixed(128);
+  case Type::X86_AMXTyID:
+    return TypeSize::Fixed(8192);
   // In memory objects this is always aligned to a higher boundary, but
   // only 80 bits contain information.
   case Type::X86_FP80TyID:
-    return 80;
-  case Type::VectorTyID: {
+    return TypeSize::Fixed(80);
+  case Type::FixedVectorTyID:
+  case Type::ScalableVectorTyID: {
     VectorType *VTy = cast<VectorType>(Ty);
-    return VTy->getNumElements() * getTypeSizeInBits(VTy->getElementType());
+    auto EltCnt = VTy->getElementCount();
+    uint64_t MinBits = EltCnt.getKnownMinValue() *
+                       getTypeSizeInBits(VTy->getElementType()).getFixedSize();
+    return TypeSize(MinBits, EltCnt.isScalable());
   }
   default:
     llvm_unreachable("DataLayout::getTypeSizeInBits(): Unsupported type");
diff --git a/linux-x64/clang/include/llvm/IR/DebugInfo.h b/linux-x64/clang/include/llvm/IR/DebugInfo.h
index 171e162..e7c1d9a 100644
--- a/linux-x64/clang/include/llvm/IR/DebugInfo.h
+++ b/linux-x64/clang/include/llvm/IR/DebugInfo.h
@@ -16,6 +16,7 @@
 #ifndef LLVM_IR_DEBUGINFO_H
 #define LLVM_IR_DEBUGINFO_H
 
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/iterator_range.h"
@@ -23,8 +24,8 @@
 
 namespace llvm {
 
-class DbgDeclareInst;
-class DbgValueInst;
+class DbgVariableIntrinsic;
+class Instruction;
 class Module;
 
 /// Find subprogram that is enclosing this scope.
@@ -50,6 +51,13 @@
 ///   All debug type metadata nodes are unreachable and garbage collected.
 bool stripNonLineTableDebugInfo(Module &M);
 
+/// Update the debug locations contained within the MD_loop metadata attached
+/// to the instruction \p I, if one exists. \p Updater is applied to each debug
+/// location in the MD_loop metadata: the returned value is included in the
+/// updated loop metadata node if it is non-null.
+void updateLoopMetadataDebugLocations(
+    Instruction &I, function_ref<DILocation *(const DILocation &)> Updater);
+
 /// Return Debug Info Metadata Version by checking module flags.
 unsigned getDebugMetadataVersionFromModule(const Module &M);
 
@@ -68,10 +76,8 @@
   /// Process a single instruction and collect debug info anchors.
   void processInstruction(const Module &M, const Instruction &I);
 
-  /// Process DbgDeclareInst.
-  void processDeclare(const Module &M, const DbgDeclareInst *DDI);
-  /// Process DbgValueInst.
-  void processValue(const Module &M, const DbgValueInst *DVI);
+  /// Process DbgVariableIntrinsic.
+  void processVariable(const Module &M, const DbgVariableIntrinsic &DVI);
   /// Process debug info location.
   void processLocation(const Module &M, const DILocation *Loc);
 
diff --git a/linux-x64/clang/include/llvm/IR/DebugInfoFlags.def b/linux-x64/clang/include/llvm/IR/DebugInfoFlags.def
index 07e3d6b..df375b6 100644
--- a/linux-x64/clang/include/llvm/IR/DebugInfoFlags.def
+++ b/linux-x64/clang/include/llvm/IR/DebugInfoFlags.def
@@ -31,7 +31,8 @@
 HANDLE_DI_FLAG(3, Public)
 HANDLE_DI_FLAG((1 << 2), FwdDecl)
 HANDLE_DI_FLAG((1 << 3), AppleBlock)
-HANDLE_DI_FLAG((1 << 4), BlockByrefStruct)
+// Used to be BlockByRef, can be reused for anything except DICompositeType.
+HANDLE_DI_FLAG((1 << 4), ReservedBit4)
 HANDLE_DI_FLAG((1 << 5), Virtual)
 HANDLE_DI_FLAG((1 << 6), Artificial)
 HANDLE_DI_FLAG((1 << 7), Explicit)
@@ -42,15 +43,13 @@
 HANDLE_DI_FLAG((1 << 12), StaticMember)
 HANDLE_DI_FLAG((1 << 13), LValueReference)
 HANDLE_DI_FLAG((1 << 14), RValueReference)
-// 15 was formerly ExternalTypeRef, but this was never used.
-HANDLE_DI_FLAG((1 << 15), Reserved)
+HANDLE_DI_FLAG((1 << 15), ExportSymbols)
 HANDLE_DI_FLAG((1 << 16), SingleInheritance)
 HANDLE_DI_FLAG((2 << 16), MultipleInheritance)
 HANDLE_DI_FLAG((3 << 16), VirtualInheritance)
 HANDLE_DI_FLAG((1 << 18), IntroducedVirtual)
 HANDLE_DI_FLAG((1 << 19), BitField)
 HANDLE_DI_FLAG((1 << 20), NoReturn)
-HANDLE_DI_FLAG((1 << 21), ArgumentNotModified)
 HANDLE_DI_FLAG((1 << 22), TypePassByValue)
 HANDLE_DI_FLAG((1 << 23), TypePassByReference)
 HANDLE_DI_FLAG((1 << 24), EnumClass)
@@ -88,11 +87,15 @@
 HANDLE_DISP_FLAG((1u << 6), Elemental)
 HANDLE_DISP_FLAG((1u << 7), Recursive)
 HANDLE_DISP_FLAG((1u << 8), MainSubprogram)
+// May also utilize this Flag in future, when adding support
+// for defaulted functions
+HANDLE_DISP_FLAG((1u << 9), Deleted)
+HANDLE_DISP_FLAG((1u << 11), ObjCDirect)
 
 #ifdef DISP_FLAG_LARGEST_NEEDED
 // Intended to be used with ADT/BitmaskEnum.h.
 // NOTE: Always must be equal to largest flag, check this when adding new flags.
-HANDLE_DISP_FLAG((1 << 8), Largest)
+HANDLE_DISP_FLAG((1 << 11), Largest)
 #undef DISP_FLAG_LARGEST_NEEDED
 #endif
 
diff --git a/linux-x64/clang/include/llvm/IR/DebugInfoMetadata.h b/linux-x64/clang/include/llvm/IR/DebugInfoMetadata.h
index 9dc6dfb..22dd5ee 100644
--- a/linux-x64/clang/include/llvm/IR/DebugInfoMetadata.h
+++ b/linux-x64/clang/include/llvm/IR/DebugInfoMetadata.h
@@ -182,6 +182,7 @@
     case DISubrangeKind:
     case DIEnumeratorKind:
     case DIBasicTypeKind:
+    case DIStringTypeKind:
     case DIDerivedTypeKind:
     case DICompositeTypeKind:
     case DISubroutineTypeKind:
@@ -200,6 +201,7 @@
     case DIObjCPropertyKind:
     case DIImportedEntityKind:
     case DIModuleKind:
+    case DIGenericSubrangeKind:
       return true;
     }
   }
@@ -238,9 +240,8 @@
                                 StorageType Storage, bool ShouldCreate = true);
 
   TempGenericDINode cloneImpl() const {
-    return getTemporary(
-        getContext(), getTag(), getHeader(),
-        SmallVector<Metadata *, 4>(dwarf_op_begin(), dwarf_op_end()));
+    return getTemporary(getContext(), getTag(), getHeader(),
+                        SmallVector<Metadata *, 4>(dwarf_operands()));
   }
 
 public:
@@ -287,12 +288,8 @@
   friend class LLVMContextImpl;
   friend class MDNode;
 
-  int64_t LowerBound;
-
-  DISubrange(LLVMContext &C, StorageType Storage, Metadata *Node,
-             int64_t LowerBound, ArrayRef<Metadata *> Ops)
-      : DINode(C, DISubrangeKind, Storage, dwarf::DW_TAG_subrange_type, Ops),
-        LowerBound(LowerBound) {}
+  DISubrange(LLVMContext &C, StorageType Storage, ArrayRef<Metadata *> Ops)
+      : DINode(C, DISubrangeKind, Storage, dwarf::DW_TAG_subrange_type, Ops) {}
 
   ~DISubrange() = default;
 
@@ -304,8 +301,14 @@
                              int64_t LowerBound, StorageType Storage,
                              bool ShouldCreate = true);
 
+  static DISubrange *getImpl(LLVMContext &Context, Metadata *CountNode,
+                             Metadata *LowerBound, Metadata *UpperBound,
+                             Metadata *Stride, StorageType Storage,
+                             bool ShouldCreate = true);
+
   TempDISubrange cloneImpl() const {
-    return getTemporary(getContext(), getRawCountNode(), getLowerBound());
+    return getTemporary(getContext(), getRawCountNode(), getRawLowerBound(),
+                        getRawUpperBound(), getRawStride());
   }
 
 public:
@@ -315,31 +318,85 @@
   DEFINE_MDNODE_GET(DISubrange, (Metadata *CountNode, int64_t LowerBound = 0),
                     (CountNode, LowerBound))
 
-  TempDISubrange clone() const { return cloneImpl(); }
+  DEFINE_MDNODE_GET(DISubrange,
+                    (Metadata * CountNode, Metadata *LowerBound,
+                     Metadata *UpperBound, Metadata *Stride),
+                    (CountNode, LowerBound, UpperBound, Stride))
 
-  int64_t getLowerBound() const { return LowerBound; }
+  TempDISubrange clone() const { return cloneImpl(); }
 
   Metadata *getRawCountNode() const {
     return getOperand(0).get();
   }
 
+  Metadata *getRawLowerBound() const { return getOperand(1).get(); }
+
+  Metadata *getRawUpperBound() const { return getOperand(2).get(); }
+
+  Metadata *getRawStride() const { return getOperand(3).get(); }
+
   typedef PointerUnion<ConstantInt*, DIVariable*> CountType;
+  typedef PointerUnion<ConstantInt *, DIVariable *, DIExpression *> BoundType;
 
-  CountType getCount() const {
-    if (auto *MD = dyn_cast<ConstantAsMetadata>(getRawCountNode()))
-      return CountType(cast<ConstantInt>(MD->getValue()));
+  CountType getCount() const;
 
-    if (auto *DV = dyn_cast<DIVariable>(getRawCountNode()))
-      return CountType(DV);
+  BoundType getLowerBound() const;
 
-    return CountType();
-  }
+  BoundType getUpperBound() const;
+
+  BoundType getStride() const;
 
   static bool classof(const Metadata *MD) {
     return MD->getMetadataID() == DISubrangeKind;
   }
 };
 
+class DIGenericSubrange : public DINode {
+  friend class LLVMContextImpl;
+  friend class MDNode;
+
+  DIGenericSubrange(LLVMContext &C, StorageType Storage,
+                    ArrayRef<Metadata *> Ops)
+      : DINode(C, DIGenericSubrangeKind, Storage,
+               dwarf::DW_TAG_generic_subrange, Ops) {}
+
+  ~DIGenericSubrange() = default;
+
+  static DIGenericSubrange *getImpl(LLVMContext &Context, Metadata *CountNode,
+                                    Metadata *LowerBound, Metadata *UpperBound,
+                                    Metadata *Stride, StorageType Storage,
+                                    bool ShouldCreate = true);
+
+  TempDIGenericSubrange cloneImpl() const {
+    return getTemporary(getContext(), getRawCountNode(), getRawLowerBound(),
+                        getRawUpperBound(), getRawStride());
+  }
+
+public:
+  DEFINE_MDNODE_GET(DIGenericSubrange,
+                    (Metadata * CountNode, Metadata *LowerBound,
+                     Metadata *UpperBound, Metadata *Stride),
+                    (CountNode, LowerBound, UpperBound, Stride))
+
+  TempDIGenericSubrange clone() const { return cloneImpl(); }
+
+  Metadata *getRawCountNode() const { return getOperand(0).get(); }
+  Metadata *getRawLowerBound() const { return getOperand(1).get(); }
+  Metadata *getRawUpperBound() const { return getOperand(2).get(); }
+  Metadata *getRawStride() const { return getOperand(3).get(); }
+
+  using BoundType = PointerUnion<DIVariable *, DIExpression *>;
+
+  BoundType getCount() const;
+  BoundType getLowerBound() const;
+  BoundType getUpperBound() const;
+  BoundType getStride() const;
+
+  static bool classof(const Metadata *MD) {
+    return MD->getMetadataID() == DIGenericSubrangeKind;
+  }
+};
+
 /// Enumeration value.
 ///
 /// TODO: Add a pointer to the context (DW_TAG_enumeration_type) once that no
@@ -348,22 +405,26 @@
   friend class LLVMContextImpl;
   friend class MDNode;
 
-  int64_t Value;
-  DIEnumerator(LLVMContext &C, StorageType Storage, int64_t Value,
+  APInt Value;
+  DIEnumerator(LLVMContext &C, StorageType Storage, const APInt &Value,
                bool IsUnsigned, ArrayRef<Metadata *> Ops)
       : DINode(C, DIEnumeratorKind, Storage, dwarf::DW_TAG_enumerator, Ops),
         Value(Value) {
     SubclassData32 = IsUnsigned;
   }
+  DIEnumerator(LLVMContext &C, StorageType Storage, int64_t Value,
+               bool IsUnsigned, ArrayRef<Metadata *> Ops)
+      : DIEnumerator(C, Storage, APInt(64, Value, !IsUnsigned), IsUnsigned,
+                     Ops) {}
   ~DIEnumerator() = default;
 
-  static DIEnumerator *getImpl(LLVMContext &Context, int64_t Value,
+  static DIEnumerator *getImpl(LLVMContext &Context, const APInt &Value,
                                bool IsUnsigned, StringRef Name,
                                StorageType Storage, bool ShouldCreate = true) {
     return getImpl(Context, Value, IsUnsigned,
                    getCanonicalMDString(Context, Name), Storage, ShouldCreate);
   }
-  static DIEnumerator *getImpl(LLVMContext &Context, int64_t Value,
+  static DIEnumerator *getImpl(LLVMContext &Context, const APInt &Value,
                                bool IsUnsigned, MDString *Name,
                                StorageType Storage, bool ShouldCreate = true);
 
@@ -372,14 +433,22 @@
   }
 
 public:
-  DEFINE_MDNODE_GET(DIEnumerator, (int64_t Value, bool IsUnsigned, StringRef Name),
+  DEFINE_MDNODE_GET(DIEnumerator,
+                    (int64_t Value, bool IsUnsigned, StringRef Name),
+                    (APInt(64, Value, !IsUnsigned), IsUnsigned, Name))
+  DEFINE_MDNODE_GET(DIEnumerator,
+                    (int64_t Value, bool IsUnsigned, MDString *Name),
+                    (APInt(64, Value, !IsUnsigned), IsUnsigned, Name))
+  DEFINE_MDNODE_GET(DIEnumerator,
+                    (APInt Value, bool IsUnsigned, StringRef Name),
                     (Value, IsUnsigned, Name))
-  DEFINE_MDNODE_GET(DIEnumerator, (int64_t Value, bool IsUnsigned, MDString *Name),
+  DEFINE_MDNODE_GET(DIEnumerator,
+                    (APInt Value, bool IsUnsigned, MDString *Name),
                     (Value, IsUnsigned, Name))
 
   TempDIEnumerator clone() const { return cloneImpl(); }
 
-  int64_t getValue() const { return Value; }
+  const APInt &getValue() const { return Value; }
   bool isUnsigned() const { return SubclassData32; }
   StringRef getName() const { return getStringOperand(0); }
 
@@ -429,6 +498,7 @@
     default:
       return false;
     case DIBasicTypeKind:
+    case DIStringTypeKind:
     case DIDerivedTypeKind:
     case DICompositeTypeKind:
     case DISubroutineTypeKind:
@@ -465,7 +535,8 @@
     // encoding is reserved.
     CSK_MD5 = 1,
     CSK_SHA1 = 2,
-    CSK_Last = CSK_SHA1 // Should be last enumeration.
+    CSK_SHA256 = 3,
+    CSK_Last = CSK_SHA256 // Should be last enumeration.
   };
 
   /// A single checksum, represented by a \a Kind and a \a Value (a string).
@@ -650,7 +721,6 @@
   }
   bool isForwardDecl() const { return getFlags() & FlagFwdDecl; }
   bool isAppleBlockExtension() const { return getFlags() & FlagAppleBlock; }
-  bool isBlockByrefStruct() const { return getFlags() & FlagBlockByrefStruct; }
   bool isVirtual() const { return getFlags() & FlagVirtual; }
   bool isArtificial() const { return getFlags() & FlagArtificial; }
   bool isObjectPointer() const { return getFlags() & FlagObjectPointer; }
@@ -668,12 +738,14 @@
   }
   bool isBigEndian() const { return getFlags() & FlagBigEndian; }
   bool isLittleEndian() const { return getFlags() & FlagLittleEndian; }
+  bool getExportSymbols() const { return getFlags() & FlagExportSymbols; }
 
   static bool classof(const Metadata *MD) {
     switch (MD->getMetadataID()) {
     default:
       return false;
     case DIBasicTypeKind:
+    case DIStringTypeKind:
     case DIDerivedTypeKind:
     case DICompositeTypeKind:
     case DISubroutineTypeKind:
@@ -724,6 +796,12 @@
   DEFINE_MDNODE_GET(DIBasicType, (unsigned Tag, StringRef Name),
                     (Tag, Name, 0, 0, 0, FlagZero))
   DEFINE_MDNODE_GET(DIBasicType,
+                    (unsigned Tag, StringRef Name, uint64_t SizeInBits),
+                    (Tag, Name, SizeInBits, 0, 0, FlagZero))
+  DEFINE_MDNODE_GET(DIBasicType,
+                    (unsigned Tag, MDString *Name, uint64_t SizeInBits),
+                    (Tag, Name, SizeInBits, 0, 0, FlagZero))
+  DEFINE_MDNODE_GET(DIBasicType,
                     (unsigned Tag, StringRef Name, uint64_t SizeInBits,
                      uint32_t AlignInBits, unsigned Encoding, DIFlags Flags),
                     (Tag, Name, SizeInBits, AlignInBits, Encoding, Flags))
@@ -747,6 +825,81 @@
   }
 };
 
+/// String type, Fortran CHARACTER(n)
+class DIStringType : public DIType {
+  friend class LLVMContextImpl;
+  friend class MDNode;
+
+  unsigned Encoding;
+
+  DIStringType(LLVMContext &C, StorageType Storage, unsigned Tag,
+               uint64_t SizeInBits, uint32_t AlignInBits, unsigned Encoding,
+               ArrayRef<Metadata *> Ops)
+      : DIType(C, DIStringTypeKind, Storage, Tag, 0, SizeInBits, AlignInBits, 0,
+               FlagZero, Ops),
+        Encoding(Encoding) {}
+  ~DIStringType() = default;
+
+  static DIStringType *getImpl(LLVMContext &Context, unsigned Tag,
+                               StringRef Name, Metadata *StringLength,
+                               Metadata *StrLenExp, uint64_t SizeInBits,
+                               uint32_t AlignInBits, unsigned Encoding,
+                               StorageType Storage, bool ShouldCreate = true) {
+    return getImpl(Context, Tag, getCanonicalMDString(Context, Name),
+                   StringLength, StrLenExp, SizeInBits, AlignInBits, Encoding,
+                   Storage, ShouldCreate);
+  }
+  static DIStringType *getImpl(LLVMContext &Context, unsigned Tag,
+                               MDString *Name, Metadata *StringLength,
+                               Metadata *StrLenExp, uint64_t SizeInBits,
+                               uint32_t AlignInBits, unsigned Encoding,
+                               StorageType Storage, bool ShouldCreate = true);
+
+  TempDIStringType cloneImpl() const {
+    return getTemporary(getContext(), getTag(), getRawName(),
+                        getRawStringLength(), getRawStringLengthExp(),
+                        getSizeInBits(), getAlignInBits(), getEncoding());
+  }
+
+public:
+  DEFINE_MDNODE_GET(DIStringType,
+                    (unsigned Tag, StringRef Name, uint64_t SizeInBits,
+                     uint32_t AlignInBits),
+                    (Tag, Name, nullptr, nullptr, SizeInBits, AlignInBits, 0))
+  DEFINE_MDNODE_GET(DIStringType,
+                    (unsigned Tag, MDString *Name, Metadata *StringLength,
+                     Metadata *StringLengthExp, uint64_t SizeInBits,
+                     uint32_t AlignInBits, unsigned Encoding),
+                    (Tag, Name, StringLength, StringLengthExp, SizeInBits,
+                     AlignInBits, Encoding))
+  DEFINE_MDNODE_GET(DIStringType,
+                    (unsigned Tag, StringRef Name, Metadata *StringLength,
+                     Metadata *StringLengthExp, uint64_t SizeInBits,
+                     uint32_t AlignInBits, unsigned Encoding),
+                    (Tag, Name, StringLength, StringLengthExp, SizeInBits,
+                     AlignInBits, Encoding))
+
+  TempDIStringType clone() const { return cloneImpl(); }
+
+  static bool classof(const Metadata *MD) {
+    return MD->getMetadataID() == DIStringTypeKind;
+  }
+
+  DIVariable *getStringLength() const {
+    return cast_or_null<DIVariable>(getRawStringLength());
+  }
+
+  DIExpression *getStringLengthExp() const {
+    return cast_or_null<DIExpression>(getRawStringLengthExp());
+  }
+
+  unsigned getEncoding() const { return Encoding; }
+
+  Metadata *getRawStringLength() const { return getOperand(3); }
+
+  Metadata *getRawStringLengthExp() const { return getOperand(4); }
+};
+
 /// Derived types.
 ///
 /// This includes qualified types, pointers, references, friends, typedefs, and
@@ -918,13 +1071,15 @@
           uint32_t AlignInBits, uint64_t OffsetInBits, DIFlags Flags,
           DINodeArray Elements, unsigned RuntimeLang, DIType *VTableHolder,
           DITemplateParameterArray TemplateParams, StringRef Identifier,
-          DIDerivedType *Discriminator, StorageType Storage,
-          bool ShouldCreate = true) {
+          DIDerivedType *Discriminator, Metadata *DataLocation,
+          Metadata *Associated, Metadata *Allocated, Metadata *Rank,
+          StorageType Storage, bool ShouldCreate = true) {
     return getImpl(
         Context, Tag, getCanonicalMDString(Context, Name), File, Line, Scope,
         BaseType, SizeInBits, AlignInBits, OffsetInBits, Flags, Elements.get(),
         RuntimeLang, VTableHolder, TemplateParams.get(),
-        getCanonicalMDString(Context, Identifier), Discriminator, Storage, ShouldCreate);
+        getCanonicalMDString(Context, Identifier), Discriminator, DataLocation,
+        Associated, Allocated, Rank, Storage, ShouldCreate);
   }
   static DICompositeType *
   getImpl(LLVMContext &Context, unsigned Tag, MDString *Name, Metadata *File,
@@ -932,7 +1087,8 @@
           uint64_t SizeInBits, uint32_t AlignInBits, uint64_t OffsetInBits,
           DIFlags Flags, Metadata *Elements, unsigned RuntimeLang,
           Metadata *VTableHolder, Metadata *TemplateParams,
-          MDString *Identifier, Metadata *Discriminator,
+          MDString *Identifier, Metadata *Discriminator, Metadata *DataLocation,
+          Metadata *Associated, Metadata *Allocated, Metadata *Rank,
           StorageType Storage, bool ShouldCreate = true);
 
   TempDICompositeType cloneImpl() const {
@@ -940,34 +1096,38 @@
                         getScope(), getBaseType(), getSizeInBits(),
                         getAlignInBits(), getOffsetInBits(), getFlags(),
                         getElements(), getRuntimeLang(), getVTableHolder(),
-                        getTemplateParams(), getIdentifier(), getDiscriminator());
+                        getTemplateParams(), getIdentifier(),
+                        getDiscriminator(), getRawDataLocation(),
+                        getRawAssociated(), getRawAllocated(), getRawRank());
   }
 
 public:
-  DEFINE_MDNODE_GET(DICompositeType,
-                    (unsigned Tag, StringRef Name, DIFile *File, unsigned Line,
-                     DIScope *Scope, DIType *BaseType, uint64_t SizeInBits,
-                     uint32_t AlignInBits, uint64_t OffsetInBits, DIFlags Flags,
-                     DINodeArray Elements, unsigned RuntimeLang,
-                     DIType *VTableHolder,
-                     DITemplateParameterArray TemplateParams = nullptr,
-                     StringRef Identifier = "",
-                     DIDerivedType *Discriminator = nullptr),
-                    (Tag, Name, File, Line, Scope, BaseType, SizeInBits,
-                     AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang,
-                     VTableHolder, TemplateParams, Identifier, Discriminator))
-  DEFINE_MDNODE_GET(DICompositeType,
-                    (unsigned Tag, MDString *Name, Metadata *File,
-                     unsigned Line, Metadata *Scope, Metadata *BaseType,
-                     uint64_t SizeInBits, uint32_t AlignInBits,
-                     uint64_t OffsetInBits, DIFlags Flags, Metadata *Elements,
-                     unsigned RuntimeLang, Metadata *VTableHolder,
-                     Metadata *TemplateParams = nullptr,
-                     MDString *Identifier = nullptr,
-                     Metadata *Discriminator = nullptr),
-                    (Tag, Name, File, Line, Scope, BaseType, SizeInBits,
-                     AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang,
-                     VTableHolder, TemplateParams, Identifier, Discriminator))
+  DEFINE_MDNODE_GET(
+      DICompositeType,
+      (unsigned Tag, StringRef Name, DIFile *File, unsigned Line,
+       DIScope *Scope, DIType *BaseType, uint64_t SizeInBits,
+       uint32_t AlignInBits, uint64_t OffsetInBits, DIFlags Flags,
+       DINodeArray Elements, unsigned RuntimeLang, DIType *VTableHolder,
+       DITemplateParameterArray TemplateParams = nullptr,
+       StringRef Identifier = "", DIDerivedType *Discriminator = nullptr,
+       Metadata *DataLocation = nullptr, Metadata *Associated = nullptr,
+       Metadata *Allocated = nullptr, Metadata *Rank = nullptr),
+      (Tag, Name, File, Line, Scope, BaseType, SizeInBits, AlignInBits,
+       OffsetInBits, Flags, Elements, RuntimeLang, VTableHolder, TemplateParams,
+       Identifier, Discriminator, DataLocation, Associated, Allocated, Rank))
+  DEFINE_MDNODE_GET(
+      DICompositeType,
+      (unsigned Tag, MDString *Name, Metadata *File, unsigned Line,
+       Metadata *Scope, Metadata *BaseType, uint64_t SizeInBits,
+       uint32_t AlignInBits, uint64_t OffsetInBits, DIFlags Flags,
+       Metadata *Elements, unsigned RuntimeLang, Metadata *VTableHolder,
+       Metadata *TemplateParams = nullptr, MDString *Identifier = nullptr,
+       Metadata *Discriminator = nullptr, Metadata *DataLocation = nullptr,
+       Metadata *Associated = nullptr, Metadata *Allocated = nullptr,
+       Metadata *Rank = nullptr),
+      (Tag, Name, File, Line, Scope, BaseType, SizeInBits, AlignInBits,
+       OffsetInBits, Flags, Elements, RuntimeLang, VTableHolder, TemplateParams,
+       Identifier, Discriminator, DataLocation, Associated, Allocated, Rank))
 
   TempDICompositeType clone() const { return cloneImpl(); }
 
@@ -984,7 +1144,9 @@
              Metadata *BaseType, uint64_t SizeInBits, uint32_t AlignInBits,
              uint64_t OffsetInBits, DIFlags Flags, Metadata *Elements,
              unsigned RuntimeLang, Metadata *VTableHolder,
-             Metadata *TemplateParams, Metadata *Discriminator);
+             Metadata *TemplateParams, Metadata *Discriminator,
+             Metadata *DataLocation, Metadata *Associated, Metadata *Allocated,
+             Metadata *Rank);
   static DICompositeType *getODRTypeIfExists(LLVMContext &Context,
                                              MDString &Identifier);
 
@@ -1003,7 +1165,9 @@
                Metadata *BaseType, uint64_t SizeInBits, uint32_t AlignInBits,
                uint64_t OffsetInBits, DIFlags Flags, Metadata *Elements,
                unsigned RuntimeLang, Metadata *VTableHolder,
-               Metadata *TemplateParams, Metadata *Discriminator);
+               Metadata *TemplateParams, Metadata *Discriminator,
+               Metadata *DataLocation, Metadata *Associated,
+               Metadata *Allocated, Metadata *Rank);
 
   DIType *getBaseType() const { return cast_or_null<DIType>(getRawBaseType()); }
   DINodeArray getElements() const {
@@ -1025,6 +1189,36 @@
   MDString *getRawIdentifier() const { return getOperandAs<MDString>(7); }
   Metadata *getRawDiscriminator() const { return getOperand(8); }
   DIDerivedType *getDiscriminator() const { return getOperandAs<DIDerivedType>(8); }
+  Metadata *getRawDataLocation() const { return getOperand(9); }
+  DIVariable *getDataLocation() const {
+    return dyn_cast_or_null<DIVariable>(getRawDataLocation());
+  }
+  DIExpression *getDataLocationExp() const {
+    return dyn_cast_or_null<DIExpression>(getRawDataLocation());
+  }
+  Metadata *getRawAssociated() const { return getOperand(10); }
+  DIVariable *getAssociated() const {
+    return dyn_cast_or_null<DIVariable>(getRawAssociated());
+  }
+  DIExpression *getAssociatedExp() const {
+    return dyn_cast_or_null<DIExpression>(getRawAssociated());
+  }
+  Metadata *getRawAllocated() const { return getOperand(11); }
+  DIVariable *getAllocated() const {
+    return dyn_cast_or_null<DIVariable>(getRawAllocated());
+  }
+  DIExpression *getAllocatedExp() const {
+    return dyn_cast_or_null<DIExpression>(getRawAllocated());
+  }
+  Metadata *getRawRank() const { return getOperand(12); }
+  ConstantInt *getRankConst() const {
+    if (auto *MD = dyn_cast_or_null<ConstantAsMetadata>(getRawRank()))
+      return dyn_cast_or_null<ConstantInt>(MD->getValue());
+    return nullptr;
+  }
+  DIExpression *getRankExp() const {
+    return dyn_cast_or_null<DIExpression>(getRawRank());
+  }
 
   /// Replace operands.
   ///
@@ -1172,16 +1366,17 @@
           DIGlobalVariableExpressionArray GlobalVariables,
           DIImportedEntityArray ImportedEntities, DIMacroNodeArray Macros,
           uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling,
-          unsigned NameTableKind, bool RangesBaseAddress, StorageType Storage,
-          bool ShouldCreate = true) {
-    return getImpl(Context, SourceLanguage, File,
-                   getCanonicalMDString(Context, Producer), IsOptimized,
-                   getCanonicalMDString(Context, Flags), RuntimeVersion,
-                   getCanonicalMDString(Context, SplitDebugFilename),
-                   EmissionKind, EnumTypes.get(), RetainedTypes.get(),
-                   GlobalVariables.get(), ImportedEntities.get(), Macros.get(),
-                   DWOId, SplitDebugInlining, DebugInfoForProfiling,
-                   NameTableKind, RangesBaseAddress, Storage, ShouldCreate);
+          unsigned NameTableKind, bool RangesBaseAddress, StringRef SysRoot,
+          StringRef SDK, StorageType Storage, bool ShouldCreate = true) {
+    return getImpl(
+        Context, SourceLanguage, File, getCanonicalMDString(Context, Producer),
+        IsOptimized, getCanonicalMDString(Context, Flags), RuntimeVersion,
+        getCanonicalMDString(Context, SplitDebugFilename), EmissionKind,
+        EnumTypes.get(), RetainedTypes.get(), GlobalVariables.get(),
+        ImportedEntities.get(), Macros.get(), DWOId, SplitDebugInlining,
+        DebugInfoForProfiling, NameTableKind, RangesBaseAddress,
+        getCanonicalMDString(Context, SysRoot),
+        getCanonicalMDString(Context, SDK), Storage, ShouldCreate);
   }
   static DICompileUnit *
   getImpl(LLVMContext &Context, unsigned SourceLanguage, Metadata *File,
@@ -1191,7 +1386,8 @@
           Metadata *GlobalVariables, Metadata *ImportedEntities,
           Metadata *Macros, uint64_t DWOId, bool SplitDebugInlining,
           bool DebugInfoForProfiling, unsigned NameTableKind,
-          bool RangesBaseAddress, StorageType Storage, bool ShouldCreate = true);
+          bool RangesBaseAddress, MDString *SysRoot, MDString *SDK,
+          StorageType Storage, bool ShouldCreate = true);
 
   TempDICompileUnit cloneImpl() const {
     return getTemporary(
@@ -1200,7 +1396,7 @@
         getEmissionKind(), getEnumTypes(), getRetainedTypes(),
         getGlobalVariables(), getImportedEntities(), getMacros(), DWOId,
         getSplitDebugInlining(), getDebugInfoForProfiling(), getNameTableKind(),
-        getRangesBaseAddress());
+        getRangesBaseAddress(), getSysRoot(), getSDK());
   }
 
 public:
@@ -1216,11 +1412,13 @@
        DIGlobalVariableExpressionArray GlobalVariables,
        DIImportedEntityArray ImportedEntities, DIMacroNodeArray Macros,
        uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling,
-       DebugNameTableKind NameTableKind, bool RangesBaseAddress),
+       DebugNameTableKind NameTableKind, bool RangesBaseAddress,
+       StringRef SysRoot, StringRef SDK),
       (SourceLanguage, File, Producer, IsOptimized, Flags, RuntimeVersion,
        SplitDebugFilename, EmissionKind, EnumTypes, RetainedTypes,
        GlobalVariables, ImportedEntities, Macros, DWOId, SplitDebugInlining,
-       DebugInfoForProfiling, (unsigned)NameTableKind, RangesBaseAddress))
+       DebugInfoForProfiling, (unsigned)NameTableKind, RangesBaseAddress,
+       SysRoot, SDK))
   DEFINE_MDNODE_GET_DISTINCT_TEMPORARY(
       DICompileUnit,
       (unsigned SourceLanguage, Metadata *File, MDString *Producer,
@@ -1229,11 +1427,12 @@
        Metadata *RetainedTypes, Metadata *GlobalVariables,
        Metadata *ImportedEntities, Metadata *Macros, uint64_t DWOId,
        bool SplitDebugInlining, bool DebugInfoForProfiling,
-       unsigned NameTableKind, bool RangesBaseAddress),
+       unsigned NameTableKind, bool RangesBaseAddress, MDString *SysRoot,
+       MDString *SDK),
       (SourceLanguage, File, Producer, IsOptimized, Flags, RuntimeVersion,
        SplitDebugFilename, EmissionKind, EnumTypes, RetainedTypes,
        GlobalVariables, ImportedEntities, Macros, DWOId, SplitDebugInlining,
-       DebugInfoForProfiling, NameTableKind, RangesBaseAddress))
+       DebugInfoForProfiling, NameTableKind, RangesBaseAddress, SysRoot, SDK))
 
   TempDICompileUnit clone() const { return cloneImpl(); }
 
@@ -1250,14 +1449,10 @@
   DebugNameTableKind getNameTableKind() const {
     return (DebugNameTableKind)NameTableKind;
   }
-  bool getRangesBaseAddress() const {
-    return RangesBaseAddress; }
-  StringRef getProducer() const {
-    return getStringOperand(1); }
-  StringRef getFlags() const {
-    return getStringOperand(2); }
-  StringRef getSplitDebugFilename() const {
-    return getStringOperand(3); }
+  bool getRangesBaseAddress() const { return RangesBaseAddress; }
+  StringRef getProducer() const { return getStringOperand(1); }
+  StringRef getFlags() const { return getStringOperand(2); }
+  StringRef getSplitDebugFilename() const { return getStringOperand(3); }
   DICompositeTypeArray getEnumTypes() const {
     return cast_or_null<MDTuple>(getRawEnumTypes());
   }
@@ -1279,6 +1474,8 @@
   void setSplitDebugInlining(bool SplitDebugInlining) {
     this->SplitDebugInlining = SplitDebugInlining;
   }
+  StringRef getSysRoot() const { return getStringOperand(9); }
+  StringRef getSDK() const { return getStringOperand(10); }
 
   MDString *getRawProducer() const { return getOperandAs<MDString>(1); }
   MDString *getRawFlags() const { return getOperandAs<MDString>(2); }
@@ -1290,6 +1487,8 @@
   Metadata *getRawGlobalVariables() const { return getOperand(6); }
   Metadata *getRawImportedEntities() const { return getOperand(7); }
   Metadata *getRawMacros() const { return getOperand(8); }
+  MDString *getRawSysRoot() const { return getOperandAs<MDString>(9); }
+  MDString *getRawSDK() const { return getOperandAs<MDString>(10); }
 
   /// Replace arrays.
   ///
@@ -1498,6 +1697,18 @@
 
   inline unsigned getDiscriminator() const;
 
+  // For the regular discriminator, it stands for all empty components if all
+  // the lowest 3 bits are non-zero and all higher 29 bits are unused(zero by
+  // default). Here we fully leverage the higher 29 bits for pseudo probe use.
+  // This is the format:
+  // [2:0] - 0x7
+  // [31:3] - pseudo probe fields guaranteed to be non-zero as a whole
+  // So if the lower 3 bits is non-zero and the others has at least one
+  // non-zero bit, it guarantees to be a pseudo probe discriminator
+  inline static bool isPseudoProbeDiscriminator(unsigned Discriminator) {
+    return ((Discriminator & 0x7) == 0x7) && (Discriminator & 0xFFFFFFF8);
+  }
+
   /// Returns a new DILocation with updated \p Discriminator.
   inline const DILocation *cloneWithDiscriminator(unsigned Discriminator) const;
 
@@ -1540,6 +1751,13 @@
   static const DILocation *getMergedLocation(const DILocation *LocA,
                                              const DILocation *LocB);
 
+  /// Try to combine the vector of locations passed as input in a single one.
+  /// This function applies getMergedLocation() repeatedly left-to-right.
+  ///
+  /// \p Locs: The locations to be merged.
+  static
+  const DILocation *getMergedLocations(ArrayRef<const DILocation *> Locs);
+
   /// Returns the base discriminator for a given encoded discriminator \p D.
   static unsigned getBaseDiscriminatorFromDiscriminator(unsigned D) {
     return getUnsignedFromPrefixEncoding(D);
@@ -1758,6 +1976,13 @@
   bool isPure() const { return getSPFlags() & SPFlagPure; }
   bool isElemental() const { return getSPFlags() & SPFlagElemental; }
   bool isRecursive() const { return getSPFlags() & SPFlagRecursive; }
+  bool isObjCDirect() const { return getSPFlags() & SPFlagObjCDirect; }
+
+  /// Check if this is deleted member function.
+  ///
+  /// Return true if this subprogram is a C++11 special
+  /// member function declared deleted.
+  bool isDeleted() const { return getSPFlags() & SPFlagDeleted; }
 
   /// Check if this is reference-qualified.
   ///
@@ -1827,6 +2052,10 @@
     return getNumOperands() > 10 ? getOperandAs<Metadata>(10) : nullptr;
   }
 
+  void replaceRawLinkageName(MDString *LinkageName) {
+    replaceOperandWith(3, LinkageName);
+  }
+
   /// Check if this subprogram describes the given function.
   ///
   /// FIXME: Should this be looking through bitcasts?
@@ -2065,60 +2294,76 @@
   }
 };
 
-/// A (clang) module that has been imported by the compile unit.
-///
+/// Represents a module in the programming language, for example, a Clang
+/// module, or a Fortran module.
 class DIModule : public DIScope {
   friend class LLVMContextImpl;
   friend class MDNode;
+  unsigned LineNo;
+  bool IsDecl;
 
-  DIModule(LLVMContext &Context, StorageType Storage, ArrayRef<Metadata *> Ops)
-      : DIScope(Context, DIModuleKind, Storage, dwarf::DW_TAG_module, Ops) {}
+  DIModule(LLVMContext &Context, StorageType Storage, unsigned LineNo,
+           bool IsDecl, ArrayRef<Metadata *> Ops)
+      : DIScope(Context, DIModuleKind, Storage, dwarf::DW_TAG_module, Ops),
+        LineNo(LineNo), IsDecl(IsDecl) {}
   ~DIModule() = default;
 
-  static DIModule *getImpl(LLVMContext &Context, DIScope *Scope,
+  static DIModule *getImpl(LLVMContext &Context, DIFile *File, DIScope *Scope,
                            StringRef Name, StringRef ConfigurationMacros,
-                           StringRef IncludePath, StringRef ISysRoot,
-                           StorageType Storage, bool ShouldCreate = true) {
-    return getImpl(Context, Scope, getCanonicalMDString(Context, Name),
+                           StringRef IncludePath, StringRef APINotesFile,
+                           unsigned LineNo, bool IsDecl, StorageType Storage,
+                           bool ShouldCreate = true) {
+    return getImpl(Context, File, Scope, getCanonicalMDString(Context, Name),
                    getCanonicalMDString(Context, ConfigurationMacros),
                    getCanonicalMDString(Context, IncludePath),
-                   getCanonicalMDString(Context, ISysRoot),
+                   getCanonicalMDString(Context, APINotesFile), LineNo, IsDecl,
                    Storage, ShouldCreate);
   }
-  static DIModule *getImpl(LLVMContext &Context, Metadata *Scope,
-                           MDString *Name, MDString *ConfigurationMacros,
-                           MDString *IncludePath, MDString *ISysRoot,
+  static DIModule *getImpl(LLVMContext &Context, Metadata *File,
+                           Metadata *Scope, MDString *Name,
+                           MDString *ConfigurationMacros, MDString *IncludePath,
+                           MDString *APINotesFile, unsigned LineNo, bool IsDecl,
                            StorageType Storage, bool ShouldCreate = true);
 
   TempDIModule cloneImpl() const {
-    return getTemporary(getContext(), getScope(), getName(),
+    return getTemporary(getContext(), getFile(), getScope(), getName(),
                         getConfigurationMacros(), getIncludePath(),
-                        getISysRoot());
+                        getAPINotesFile(), getLineNo(), getIsDecl());
   }
 
 public:
-  DEFINE_MDNODE_GET(DIModule, (DIScope *Scope, StringRef Name,
-                               StringRef ConfigurationMacros, StringRef IncludePath,
-                               StringRef ISysRoot),
-                    (Scope, Name, ConfigurationMacros, IncludePath, ISysRoot))
   DEFINE_MDNODE_GET(DIModule,
-                    (Metadata *Scope, MDString *Name, MDString *ConfigurationMacros,
-                     MDString *IncludePath, MDString *ISysRoot),
-                    (Scope, Name, ConfigurationMacros, IncludePath, ISysRoot))
+                    (DIFile * File, DIScope *Scope, StringRef Name,
+                     StringRef ConfigurationMacros, StringRef IncludePath,
+                     StringRef APINotesFile, unsigned LineNo,
+                     bool IsDecl = false),
+                    (File, Scope, Name, ConfigurationMacros, IncludePath,
+                     APINotesFile, LineNo, IsDecl))
+  DEFINE_MDNODE_GET(DIModule,
+                    (Metadata * File, Metadata *Scope, MDString *Name,
+                     MDString *ConfigurationMacros, MDString *IncludePath,
+                     MDString *APINotesFile, unsigned LineNo,
+                     bool IsDecl = false),
+                    (File, Scope, Name, ConfigurationMacros, IncludePath,
+                     APINotesFile, LineNo, IsDecl))
 
   TempDIModule clone() const { return cloneImpl(); }
 
   DIScope *getScope() const { return cast_or_null<DIScope>(getRawScope()); }
-  StringRef getName() const { return getStringOperand(1); }
-  StringRef getConfigurationMacros() const { return getStringOperand(2); }
-  StringRef getIncludePath() const { return getStringOperand(3); }
-  StringRef getISysRoot() const { return getStringOperand(4); }
+  StringRef getName() const { return getStringOperand(2); }
+  StringRef getConfigurationMacros() const { return getStringOperand(3); }
+  StringRef getIncludePath() const { return getStringOperand(4); }
+  StringRef getAPINotesFile() const { return getStringOperand(5); }
+  unsigned getLineNo() const { return LineNo; }
+  bool getIsDecl() const { return IsDecl; }
 
-  Metadata *getRawScope() const { return getOperand(0); }
-  MDString *getRawName() const { return getOperandAs<MDString>(1); }
-  MDString *getRawConfigurationMacros() const { return getOperandAs<MDString>(2); }
-  MDString *getRawIncludePath() const { return getOperandAs<MDString>(3); }
-  MDString *getRawISysRoot() const { return getOperandAs<MDString>(4); }
+  Metadata *getRawScope() const { return getOperand(1); }
+  MDString *getRawName() const { return getOperandAs<MDString>(2); }
+  MDString *getRawConfigurationMacros() const {
+    return getOperandAs<MDString>(3);
+  }
+  MDString *getRawIncludePath() const { return getOperandAs<MDString>(4); }
+  MDString *getRawAPINotesFile() const { return getOperandAs<MDString>(5); }
 
   static bool classof(const Metadata *MD) {
     return MD->getMetadataID() == DIModuleKind;
@@ -2128,9 +2373,11 @@
 /// Base class for template parameters.
 class DITemplateParameter : public DINode {
 protected:
+  bool IsDefault;
+
   DITemplateParameter(LLVMContext &Context, unsigned ID, StorageType Storage,
-                      unsigned Tag, ArrayRef<Metadata *> Ops)
-      : DINode(Context, ID, Storage, Tag, Ops) {}
+                      unsigned Tag, bool IsDefault, ArrayRef<Metadata *> Ops)
+      : DINode(Context, ID, Storage, Tag, Ops), IsDefault(IsDefault) {}
   ~DITemplateParameter() = default;
 
 public:
@@ -2139,6 +2386,7 @@
 
   MDString *getRawName() const { return getOperandAs<MDString>(0); }
   Metadata *getRawType() const { return getOperand(1); }
+  bool isDefault() const { return IsDefault; }
 
   static bool classof(const Metadata *MD) {
     return MD->getMetadataID() == DITemplateTypeParameterKind ||
@@ -2151,30 +2399,35 @@
   friend class MDNode;
 
   DITemplateTypeParameter(LLVMContext &Context, StorageType Storage,
-                          ArrayRef<Metadata *> Ops)
+                          bool IsDefault, ArrayRef<Metadata *> Ops)
       : DITemplateParameter(Context, DITemplateTypeParameterKind, Storage,
-                            dwarf::DW_TAG_template_type_parameter, Ops) {}
+                            dwarf::DW_TAG_template_type_parameter, IsDefault,
+                            Ops) {}
   ~DITemplateTypeParameter() = default;
 
   static DITemplateTypeParameter *getImpl(LLVMContext &Context, StringRef Name,
-                                          DIType *Type, StorageType Storage,
+                                          DIType *Type, bool IsDefault,
+                                          StorageType Storage,
                                           bool ShouldCreate = true) {
-    return getImpl(Context, getCanonicalMDString(Context, Name), Type, Storage,
-                   ShouldCreate);
+    return getImpl(Context, getCanonicalMDString(Context, Name), Type,
+                   IsDefault, Storage, ShouldCreate);
   }
   static DITemplateTypeParameter *getImpl(LLVMContext &Context, MDString *Name,
-                                          Metadata *Type, StorageType Storage,
+                                          Metadata *Type, bool IsDefault,
+                                          StorageType Storage,
                                           bool ShouldCreate = true);
 
   TempDITemplateTypeParameter cloneImpl() const {
-    return getTemporary(getContext(), getName(), getType());
+    return getTemporary(getContext(), getName(), getType(), isDefault());
   }
 
 public:
-  DEFINE_MDNODE_GET(DITemplateTypeParameter, (StringRef Name, DIType *Type),
-                    (Name, Type))
-  DEFINE_MDNODE_GET(DITemplateTypeParameter, (MDString * Name, Metadata *Type),
-                    (Name, Type))
+  DEFINE_MDNODE_GET(DITemplateTypeParameter,
+                    (StringRef Name, DIType *Type, bool IsDefault),
+                    (Name, Type, IsDefault))
+  DEFINE_MDNODE_GET(DITemplateTypeParameter,
+                    (MDString *Name, Metadata *Type, bool IsDefault),
+                    (Name, Type, IsDefault))
 
   TempDITemplateTypeParameter clone() const { return cloneImpl(); }
 
@@ -2188,36 +2441,40 @@
   friend class MDNode;
 
   DITemplateValueParameter(LLVMContext &Context, StorageType Storage,
-                           unsigned Tag, ArrayRef<Metadata *> Ops)
+                           unsigned Tag, bool IsDefault,
+                           ArrayRef<Metadata *> Ops)
       : DITemplateParameter(Context, DITemplateValueParameterKind, Storage, Tag,
-                            Ops) {}
+                            IsDefault, Ops) {}
   ~DITemplateValueParameter() = default;
 
   static DITemplateValueParameter *getImpl(LLVMContext &Context, unsigned Tag,
                                            StringRef Name, DIType *Type,
-                                           Metadata *Value, StorageType Storage,
+                                           bool IsDefault, Metadata *Value,
+                                           StorageType Storage,
                                            bool ShouldCreate = true) {
     return getImpl(Context, Tag, getCanonicalMDString(Context, Name), Type,
-                   Value, Storage, ShouldCreate);
+                   IsDefault, Value, Storage, ShouldCreate);
   }
   static DITemplateValueParameter *getImpl(LLVMContext &Context, unsigned Tag,
                                            MDString *Name, Metadata *Type,
-                                           Metadata *Value, StorageType Storage,
+                                           bool IsDefault, Metadata *Value,
+                                           StorageType Storage,
                                            bool ShouldCreate = true);
 
   TempDITemplateValueParameter cloneImpl() const {
     return getTemporary(getContext(), getTag(), getName(), getType(),
-                        getValue());
+                        isDefault(), getValue());
   }
 
 public:
   DEFINE_MDNODE_GET(DITemplateValueParameter,
-                    (unsigned Tag, StringRef Name, DIType *Type,
+                    (unsigned Tag, StringRef Name, DIType *Type, bool IsDefault,
                      Metadata *Value),
-                    (Tag, Name, Type, Value))
-  DEFINE_MDNODE_GET(DITemplateValueParameter, (unsigned Tag, MDString *Name,
-                                               Metadata *Type, Metadata *Value),
-                    (Tag, Name, Type, Value))
+                    (Tag, Name, Type, IsDefault, Value))
+  DEFINE_MDNODE_GET(DITemplateValueParameter,
+                    (unsigned Tag, MDString *Name, Metadata *Type,
+                     bool IsDefault, Metadata *Value),
+                    (Tag, Name, Type, IsDefault, Value))
 
   TempDITemplateValueParameter clone() const { return cloneImpl(); }
 
@@ -2333,6 +2590,9 @@
   /// Determine whether this represents a standalone constant value.
   bool isConstant() const;
 
+  /// Determine whether this represents a standalone signed constant value.
+  bool isSignedConstant() const;
+
   using element_iterator = ArrayRef<uint64_t>::iterator;
 
   element_iterator elements_begin() const { return getElements().begin(); }
@@ -2545,6 +2805,16 @@
       return 0;
   }
 
+  using ExtOps = std::array<uint64_t, 6>;
+
+  /// Returns the ops for a zero- or sign-extension in a DIExpression.
+  static ExtOps getExtOps(unsigned FromSize, unsigned ToSize, bool Signed);
+
+  /// Append a zero- or sign-extension to \p Expr. Converts the expression to a
+  /// stack value if it isn't one already.
+  static DIExpression *appendExt(const DIExpression *Expr, unsigned FromSize,
+                                 unsigned ToSize, bool Signed);
+
   /// Check if fragments overlap between a pair of FragmentInfos.
   static bool fragmentsOverlap(const FragmentInfo &A, const FragmentInfo &B) {
     return fragmentCmp(A, B) == 0;
@@ -2569,7 +2839,7 @@
   /// (This is the only configuration of entry values that is supported.)
   bool isEntryValue() const {
     return getNumElements() > 0 &&
-           getElement(0) == dwarf::DW_OP_entry_value;
+           getElement(0) == dwarf::DW_OP_LLVM_entry_value;
   }
 };
 
@@ -2809,11 +3079,6 @@
   bool isArtificial() const { return getFlags() & FlagArtificial; }
   bool isObjectPointer() const { return getFlags() & FlagObjectPointer; }
 
-  /// Check that an argument is unmodified.
-  bool isNotModified() const { return getFlags() & FlagArgumentNotModified; }
-  /// Set the flag if an argument is unmodified.
-  void setIsNotModified() { Flags |= FlagArgumentNotModified; }
-
   /// Check that a location is valid for this variable.
   ///
   /// Check that \c DL exists, is in the same subprogram, and has the same
@@ -3247,6 +3512,89 @@
   }
 };
 
+/// Identifies a unique instance of a variable.
+///
+/// Storage for identifying a potentially inlined instance of a variable,
+/// or a fragment thereof. This guarantees that exactly one variable instance
+/// may be identified by this class, even when that variable is a fragment of
+/// an aggregate variable and/or there is another inlined instance of the same
+/// source code variable nearby.
+/// This class does not necessarily uniquely identify that variable: it is
+/// possible that a DebugVariable with different parameters may point to the
+/// same variable instance, but not that one DebugVariable points to multiple
+/// variable instances.
+class DebugVariable {
+  using FragmentInfo = DIExpression::FragmentInfo;
+
+  const DILocalVariable *Variable;
+  Optional<FragmentInfo> Fragment;
+  const DILocation *InlinedAt;
+
+  /// Fragment that will overlap all other fragments. Used as default when
+  /// caller demands a fragment.
+  static const FragmentInfo DefaultFragment;
+
+public:
+  DebugVariable(const DILocalVariable *Var, Optional<FragmentInfo> FragmentInfo,
+                const DILocation *InlinedAt)
+      : Variable(Var), Fragment(FragmentInfo), InlinedAt(InlinedAt) {}
+
+  DebugVariable(const DILocalVariable *Var, const DIExpression *DIExpr,
+                const DILocation *InlinedAt)
+      : Variable(Var),
+        Fragment(DIExpr ? DIExpr->getFragmentInfo() : NoneType()),
+        InlinedAt(InlinedAt) {}
+
+  const DILocalVariable *getVariable() const { return Variable; }
+  const Optional<FragmentInfo> getFragment() const { return Fragment; }
+  const DILocation *getInlinedAt() const { return InlinedAt; }
+
+  const FragmentInfo getFragmentOrDefault() const {
+    return Fragment.getValueOr(DefaultFragment);
+  }
+
+  static bool isDefaultFragment(const FragmentInfo F) {
+    return F == DefaultFragment;
+  }
+
+  bool operator==(const DebugVariable &Other) const {
+    return std::tie(Variable, Fragment, InlinedAt) ==
+           std::tie(Other.Variable, Other.Fragment, Other.InlinedAt);
+  }
+
+  bool operator<(const DebugVariable &Other) const {
+    return std::tie(Variable, Fragment, InlinedAt) <
+           std::tie(Other.Variable, Other.Fragment, Other.InlinedAt);
+  }
+};
+
+template <> struct DenseMapInfo<DebugVariable> {
+  using FragmentInfo = DIExpression::FragmentInfo;
+
+  /// Empty key: no key should be generated that has no DILocalVariable.
+  static inline DebugVariable getEmptyKey() {
+    return DebugVariable(nullptr, NoneType(), nullptr);
+  }
+
+  /// Difference in tombstone is that the Optional is meaningful.
+  static inline DebugVariable getTombstoneKey() {
+    return DebugVariable(nullptr, {{0, 0}}, nullptr);
+  }
+
+  static unsigned getHashValue(const DebugVariable &D) {
+    unsigned HV = 0;
+    const Optional<FragmentInfo> Fragment = D.getFragment();
+    if (Fragment)
+      HV = DenseMapInfo<FragmentInfo>::getHashValue(*Fragment);
+
+    return hash_combine(D.getVariable(), HV, D.getInlinedAt());
+  }
+
+  static bool isEqual(const DebugVariable &A, const DebugVariable &B) {
+    return A == B;
+  }
+};
+
 } // end namespace llvm
 
 #undef DEFINE_MDNODE_GET_UNPACK_IMPL
diff --git a/linux-x64/clang/include/llvm/IR/DebugLoc.h b/linux-x64/clang/include/llvm/IR/DebugLoc.h
index 780d17a..4824f2e 100644
--- a/linux-x64/clang/include/llvm/IR/DebugLoc.h
+++ b/linux-x64/clang/include/llvm/IR/DebugLoc.h
@@ -68,27 +68,13 @@
     /// Check whether this has a trivial destructor.
     bool hasTrivialDestructor() const { return Loc.hasTrivialDestructor(); }
 
-    /// Create a new DebugLoc.
-    ///
-    /// Create a new DebugLoc at the specified line/col and scope/inline.  This
-    /// forwards to \a DILocation::get().
-    ///
-    /// If \c !Scope, returns a default-constructed \a DebugLoc.
-    ///
-    /// FIXME: Remove this.  Users should use DILocation::get().
-    static DebugLoc get(unsigned Line, unsigned Col, const MDNode *Scope,
-                        const MDNode *InlinedAt = nullptr,
-                        bool ImplicitCode = false);
-
     enum { ReplaceLastInlinedAt = true };
     /// Rebuild the entire inlined-at chain for this instruction so that the top of
     /// the chain now is inlined-at the new call site.
     /// \param   InlinedAt    The new outermost inlined-at in the chain.
-    /// \param   ReplaceLast  Replace the last location in the inlined-at chain.
-    static DebugLoc appendInlinedAt(DebugLoc DL, DILocation *InlinedAt,
+    static DebugLoc appendInlinedAt(const DebugLoc &DL, DILocation *InlinedAt,
                                     LLVMContext &Ctx,
-                                    DenseMap<const MDNode *, MDNode *> &Cache,
-                                    bool ReplaceLast = false);
+                                    DenseMap<const MDNode *, MDNode *> &Cache);
 
     unsigned getLine() const;
     unsigned getCol() const;
diff --git a/linux-x64/clang/include/llvm/IR/DerivedTypes.h b/linux-x64/clang/include/llvm/IR/DerivedTypes.h
index 3c1d427..51c5dd2 100644
--- a/linux-x64/clang/include/llvm/IR/DerivedTypes.h
+++ b/linux-x64/clang/include/llvm/IR/DerivedTypes.h
@@ -23,7 +23,7 @@
 #include "llvm/IR/Type.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Compiler.h"
-#include "llvm/Support/ScalableSize.h"
+#include "llvm/Support/TypeSize.h"
 #include <cassert>
 #include <cstdint>
 
@@ -62,6 +62,11 @@
   /// Get or create an IntegerType instance.
   static IntegerType *get(LLVMContext &C, unsigned NumBits);
 
+  /// Returns type twice as wide the input type.
+  IntegerType *getExtendedType() const {
+    return Type::getIntNTy(getContext(), 2 * getScalarSizeInBits());
+  }
+
   /// Get the number of bits in this IntegerType
   unsigned getBitWidth() const { return getSubclassData(); }
 
@@ -82,12 +87,6 @@
   /// Get a bit mask for this type.
   APInt getMask() const;
 
-  /// This method determines if the width of this IntegerType is a power-of-2
-  /// in terms of 8 bit bytes.
-  /// @returns true if this is a power-of-2 byte width.
-  /// Is this a power-of-2 byte-width IntegerType ?
-  bool isPowerOf2ByteWidth() const;
-
   /// Methods for support type inquiry through isa, cast, and dyn_cast.
   static bool classof(const Type *T) {
     return T->getTypeID() == IntegerTyID;
@@ -190,26 +189,6 @@
   Value *Callee = nullptr;
 };
 
-/// Common super class of ArrayType, StructType and VectorType.
-class CompositeType : public Type {
-protected:
-  explicit CompositeType(LLVMContext &C, TypeID tid) : Type(C, tid) {}
-
-public:
-  /// Given an index value into the type, return the type of the element.
-  Type *getTypeAtIndex(const Value *V) const;
-  Type *getTypeAtIndex(unsigned Idx) const;
-  bool indexValid(const Value *V) const;
-  bool indexValid(unsigned Idx) const;
-
-  /// Methods for support type inquiry through isa, cast, and dyn_cast.
-  static bool classof(const Type *T) {
-    return T->getTypeID() == ArrayTyID ||
-           T->getTypeID() == StructTyID ||
-           T->getTypeID() == VectorTyID;
-  }
-};
-
 /// Class to represent struct types. There are two different kinds of struct
 /// types: Literal structs and Identified structs.
 ///
@@ -230,8 +209,8 @@
 /// elements as defined by DataLayout (which is required to match what the code
 /// generator for a target expects).
 ///
-class StructType : public CompositeType {
-  StructType(LLVMContext &C) : CompositeType(C, StructTyID) {}
+class StructType : public Type {
+  StructType(LLVMContext &C) : Type(C, StructTyID) {}
 
   enum {
     /// This is the contents of the SubClassData field.
@@ -262,8 +241,7 @@
                             StringRef Name, bool isPacked = false);
   static StructType *create(LLVMContext &Context, ArrayRef<Type *> Elements);
   template <class... Tys>
-  static typename std::enable_if<are_base_of<Type, Tys...>::value,
-                                 StructType *>::type
+  static std::enable_if_t<are_base_of<Type, Tys...>::value, StructType *>
   create(StringRef Name, Type *elt1, Tys *... elts) {
     assert(elt1 && "Cannot create a struct type with no elements with this");
     SmallVector<llvm::Type *, 8> StructFields({elt1, elts...});
@@ -281,8 +259,7 @@
   /// specifying the elements as arguments. Note that this method always returns
   /// a non-packed struct, and requires at least one element type.
   template <class... Tys>
-  static typename std::enable_if<are_base_of<Type, Tys...>::value,
-                                 StructType *>::type
+  static std::enable_if_t<are_base_of<Type, Tys...>::value, StructType *>
   get(Type *elt1, Tys *... elts) {
     assert(elt1 && "Cannot create a struct type with no elements with this");
     LLVMContext &Ctx = elt1->getContext();
@@ -290,6 +267,10 @@
     return llvm::StructType::get(Ctx, StructFields);
   }
 
+  /// Return the type with the specified name, or null if there is none by that
+  /// name.
+  static StructType *getTypeByName(LLVMContext &C, StringRef Name);
+
   bool isPacked() const { return (getSubclassData() & SCDB_Packed) != 0; }
 
   /// Return true if this type is uniqued by structural equivalence, false if it
@@ -319,7 +300,7 @@
   void setBody(ArrayRef<Type*> Elements, bool isPacked = false);
 
   template <typename... Tys>
-  typename std::enable_if<are_base_of<Type, Tys...>::value, void>::type
+  std::enable_if_t<are_base_of<Type, Tys...>::value, void>
   setBody(Type *elt1, Tys *... elts) {
     assert(elt1 && "Cannot create a struct type with no elements with this");
     SmallVector<llvm::Type *, 8> StructFields({elt1, elts...});
@@ -347,6 +328,11 @@
     assert(N < NumContainedTys && "Element number out of range!");
     return ContainedTys[N];
   }
+  /// Given an index value into the type, return the type of the element.
+  Type *getTypeAtIndex(const Value *V) const;
+  Type *getTypeAtIndex(unsigned N) const { return getElementType(N); }
+  bool indexValid(const Value *V) const;
+  bool indexValid(unsigned Idx) const { return Idx < getNumElements(); }
 
   /// Methods for support type inquiry through isa, cast, and dyn_cast.
   static bool classof(const Type *T) {
@@ -366,47 +352,22 @@
   return cast<StructType>(this)->getElementType(N);
 }
 
-/// This is the superclass of the array and vector type classes. Both of these
-/// represent "arrays" in memory. The array type represents a specifically sized
-/// array, and the vector type represents a specifically sized array that allows
-/// for use of SIMD instructions. SequentialType holds the common features of
-/// both, which stem from the fact that both lay their components out in memory
-/// identically.
-class SequentialType : public CompositeType {
-  Type *ContainedType;               ///< Storage for the single contained type.
+/// Class to represent array types.
+class ArrayType : public Type {
+  /// The element type of the array.
+  Type *ContainedType;
+  /// Number of elements in the array.
   uint64_t NumElements;
 
-protected:
-  SequentialType(TypeID TID, Type *ElType, uint64_t NumElements)
-    : CompositeType(ElType->getContext(), TID), ContainedType(ElType),
-      NumElements(NumElements) {
-    ContainedTys = &ContainedType;
-    NumContainedTys = 1;
-  }
-
-public:
-  SequentialType(const SequentialType &) = delete;
-  SequentialType &operator=(const SequentialType &) = delete;
-
-  /// For scalable vectors, this will return the minimum number of elements
-  /// in the vector.
-  uint64_t getNumElements() const { return NumElements; }
-  Type *getElementType() const { return ContainedType; }
-
-  /// Methods for support type inquiry through isa, cast, and dyn_cast.
-  static bool classof(const Type *T) {
-    return T->getTypeID() == ArrayTyID || T->getTypeID() == VectorTyID;
-  }
-};
-
-/// Class to represent array types.
-class ArrayType : public SequentialType {
   ArrayType(Type *ElType, uint64_t NumEl);
 
 public:
   ArrayType(const ArrayType &) = delete;
   ArrayType &operator=(const ArrayType &) = delete;
 
+  uint64_t getNumElements() const { return NumElements; }
+  Type *getElementType() const { return ContainedType; }
+
   /// This static method is the primary way to construct an ArrayType
   static ArrayType *get(Type *ElementType, uint64_t NumElements);
 
@@ -423,8 +384,8 @@
   return cast<ArrayType>(this)->getNumElements();
 }
 
-/// Class to represent vector types.
-class VectorType : public SequentialType {
+/// Base class of all SIMD vector types
+class VectorType : public Type {
   /// A fully specified VectorType is of the form <vscale x n x Ty>. 'n' is the
   /// minimum number of elements of type Ty contained within the vector, and
   /// 'vscale x' indicates that the total element count is an integer multiple
@@ -438,23 +399,47 @@
   /// <vscale x 4 x i32> - a vector containing an unknown integer multiple
   ///                      of 4 i32s
 
-  VectorType(Type *ElType, unsigned NumEl, bool Scalable = false);
-  VectorType(Type *ElType, ElementCount EC);
+  /// The element type of the vector.
+  Type *ContainedType;
 
-  // If true, the total number of elements is an unknown multiple of the
-  // minimum 'NumElements' from SequentialType. Otherwise the total number
-  // of elements is exactly equal to 'NumElements'.
-  bool Scalable;
+protected:
+  /// The element quantity of this vector. The meaning of this value depends
+  /// on the type of vector:
+  /// - For FixedVectorType = <ElementQuantity x ty>, there are
+  ///   exactly ElementQuantity elements in this vector.
+  /// - For ScalableVectorType = <vscale x ElementQuantity x ty>,
+  ///   there are vscale * ElementQuantity elements in this vector, where
+  ///   vscale is a runtime-constant integer greater than 0.
+  const unsigned ElementQuantity;
+
+  VectorType(Type *ElType, unsigned EQ, Type::TypeID TID);
 
 public:
   VectorType(const VectorType &) = delete;
   VectorType &operator=(const VectorType &) = delete;
 
+  /// Get the number of elements in this vector. It does not make sense to call
+  /// this function on a scalable vector, and this will be moved into
+  /// FixedVectorType in a future commit
+  LLVM_ATTRIBUTE_DEPRECATED(
+      inline unsigned getNumElements() const,
+      "Calling this function via a base VectorType is deprecated. Either call "
+      "getElementCount() and handle the case where Scalable is true or cast to "
+      "FixedVectorType.");
+
+  Type *getElementType() const { return ContainedType; }
+
   /// This static method is the primary way to construct an VectorType.
   static VectorType *get(Type *ElementType, ElementCount EC);
+
   static VectorType *get(Type *ElementType, unsigned NumElements,
-                         bool Scalable = false) {
-    return VectorType::get(ElementType, {NumElements, Scalable});
+                         bool Scalable) {
+    return VectorType::get(ElementType,
+                           ElementCount::get(NumElements, Scalable));
+  }
+
+  static VectorType *get(Type *ElementType, const VectorType *Other) {
+    return VectorType::get(ElementType, Other->getElementCount());
   }
 
   /// This static method gets a VectorType with the same number of elements as
@@ -470,37 +455,64 @@
   /// This static method is like getInteger except that the element types are
   /// twice as wide as the elements in the input type.
   static VectorType *getExtendedElementVectorType(VectorType *VTy) {
-    unsigned EltBits = VTy->getElementType()->getPrimitiveSizeInBits();
-    Type *EltTy = IntegerType::get(VTy->getContext(), EltBits * 2);
+    assert(VTy->isIntOrIntVectorTy() && "VTy expected to be a vector of ints.");
+    auto *EltTy = cast<IntegerType>(VTy->getElementType());
+    return VectorType::get(EltTy->getExtendedType(), VTy->getElementCount());
+  }
+
+  // This static method gets a VectorType with the same number of elements as
+  // the input type, and the element type is an integer or float type which
+  // is half as wide as the elements in the input type.
+  static VectorType *getTruncatedElementVectorType(VectorType *VTy) {
+    Type *EltTy;
+    if (VTy->getElementType()->isFloatingPointTy()) {
+      switch(VTy->getElementType()->getTypeID()) {
+      case DoubleTyID:
+        EltTy = Type::getFloatTy(VTy->getContext());
+        break;
+      case FloatTyID:
+        EltTy = Type::getHalfTy(VTy->getContext());
+        break;
+      default:
+        llvm_unreachable("Cannot create narrower fp vector element type");
+      }
+    } else {
+      unsigned EltBits = VTy->getElementType()->getPrimitiveSizeInBits();
+      assert((EltBits & 1) == 0 &&
+             "Cannot truncate vector element with odd bit-width");
+      EltTy = IntegerType::get(VTy->getContext(), EltBits / 2);
+    }
     return VectorType::get(EltTy, VTy->getElementCount());
   }
 
-  /// This static method is like getInteger except that the element types are
-  /// half as wide as the elements in the input type.
-  static VectorType *getTruncatedElementVectorType(VectorType *VTy) {
-    unsigned EltBits = VTy->getElementType()->getPrimitiveSizeInBits();
-    assert((EltBits & 1) == 0 &&
-           "Cannot truncate vector element with odd bit-width");
-    Type *EltTy = IntegerType::get(VTy->getContext(), EltBits / 2);
-    return VectorType::get(EltTy, VTy->getElementCount());
+  // This static method returns a VectorType with a smaller number of elements
+  // of a larger type than the input element type. For example, a <16 x i8>
+  // subdivided twice would return <4 x i32>
+  static VectorType *getSubdividedVectorType(VectorType *VTy, int NumSubdivs) {
+    for (int i = 0; i < NumSubdivs; ++i) {
+      VTy = VectorType::getDoubleElementsVectorType(VTy);
+      VTy = VectorType::getTruncatedElementVectorType(VTy);
+    }
+    return VTy;
   }
 
   /// This static method returns a VectorType with half as many elements as the
   /// input type and the same element type.
   static VectorType *getHalfElementsVectorType(VectorType *VTy) {
     auto EltCnt = VTy->getElementCount();
-    assert ((EltCnt.Min & 1) == 0 &&
-            "Cannot halve vector with odd number of elements.");
-    return VectorType::get(VTy->getElementType(), EltCnt/2);
+    assert(EltCnt.isKnownEven() &&
+           "Cannot halve vector with odd number of elements.");
+    return VectorType::get(VTy->getElementType(),
+                           EltCnt.divideCoefficientBy(2));
   }
 
   /// This static method returns a VectorType with twice as many elements as the
   /// input type and the same element type.
   static VectorType *getDoubleElementsVectorType(VectorType *VTy) {
     auto EltCnt = VTy->getElementCount();
-    assert((VTy->getNumElements() * 2ull) <= UINT_MAX &&
+    assert((EltCnt.getKnownMinValue() * 2ull) <= UINT_MAX &&
            "Too many elements in vector");
-    return VectorType::get(VTy->getElementType(), EltCnt*2);
+    return VectorType::get(VTy->getElementType(), EltCnt * 2);
   }
 
   /// Return true if the specified type is valid as a element type.
@@ -508,36 +520,135 @@
 
   /// Return an ElementCount instance to represent the (possibly scalable)
   /// number of elements in the vector.
-  ElementCount getElementCount() const {
-    uint64_t MinimumEltCnt = getNumElements();
-    assert(MinimumEltCnt <= UINT_MAX && "Too many elements in vector");
-    return { (unsigned)MinimumEltCnt, Scalable };
-  }
-
-  /// Returns whether or not this is a scalable vector (meaning the total
-  /// element count is a multiple of the minimum).
-  bool isScalable() const {
-    return Scalable;
-  }
-
-  /// Return the minimum number of bits in the Vector type.
-  /// Returns zero when the vector is a vector of pointers.
-  unsigned getBitWidth() const {
-    return getNumElements() * getElementType()->getPrimitiveSizeInBits();
-  }
+  inline ElementCount getElementCount() const;
 
   /// Methods for support type inquiry through isa, cast, and dyn_cast.
   static bool classof(const Type *T) {
-    return T->getTypeID() == VectorTyID;
+    return T->getTypeID() == FixedVectorTyID ||
+           T->getTypeID() == ScalableVectorTyID;
   }
 };
 
-unsigned Type::getVectorNumElements() const {
-  return cast<VectorType>(this)->getNumElements();
+unsigned VectorType::getNumElements() const {
+  ElementCount EC = getElementCount();
+#ifdef STRICT_FIXED_SIZE_VECTORS
+  assert(!EC.isScalable() &&
+         "Request for fixed number of elements from scalable vector");
+#else
+  if (EC.isScalable())
+    WithColor::warning()
+        << "The code that requested the fixed number of elements has made the "
+           "assumption that this vector is not scalable. This assumption was "
+           "not correct, and this may lead to broken code\n";
+#endif
+  return EC.getKnownMinValue();
 }
 
-bool Type::getVectorIsScalable() const {
-  return cast<VectorType>(this)->isScalable();
+/// Class to represent fixed width SIMD vectors
+class FixedVectorType : public VectorType {
+protected:
+  FixedVectorType(Type *ElTy, unsigned NumElts)
+      : VectorType(ElTy, NumElts, FixedVectorTyID) {}
+
+public:
+  static FixedVectorType *get(Type *ElementType, unsigned NumElts);
+
+  static FixedVectorType *get(Type *ElementType, const FixedVectorType *FVTy) {
+    return get(ElementType, FVTy->getNumElements());
+  }
+
+  static FixedVectorType *getInteger(FixedVectorType *VTy) {
+    return cast<FixedVectorType>(VectorType::getInteger(VTy));
+  }
+
+  static FixedVectorType *getExtendedElementVectorType(FixedVectorType *VTy) {
+    return cast<FixedVectorType>(VectorType::getExtendedElementVectorType(VTy));
+  }
+
+  static FixedVectorType *getTruncatedElementVectorType(FixedVectorType *VTy) {
+    return cast<FixedVectorType>(
+        VectorType::getTruncatedElementVectorType(VTy));
+  }
+
+  static FixedVectorType *getSubdividedVectorType(FixedVectorType *VTy,
+                                                  int NumSubdivs) {
+    return cast<FixedVectorType>(
+        VectorType::getSubdividedVectorType(VTy, NumSubdivs));
+  }
+
+  static FixedVectorType *getHalfElementsVectorType(FixedVectorType *VTy) {
+    return cast<FixedVectorType>(VectorType::getHalfElementsVectorType(VTy));
+  }
+
+  static FixedVectorType *getDoubleElementsVectorType(FixedVectorType *VTy) {
+    return cast<FixedVectorType>(VectorType::getDoubleElementsVectorType(VTy));
+  }
+
+  static bool classof(const Type *T) {
+    return T->getTypeID() == FixedVectorTyID;
+  }
+
+  unsigned getNumElements() const { return ElementQuantity; }
+};
+
+/// Class to represent scalable SIMD vectors
+class ScalableVectorType : public VectorType {
+protected:
+  ScalableVectorType(Type *ElTy, unsigned MinNumElts)
+      : VectorType(ElTy, MinNumElts, ScalableVectorTyID) {}
+
+public:
+  static ScalableVectorType *get(Type *ElementType, unsigned MinNumElts);
+
+  static ScalableVectorType *get(Type *ElementType,
+                                 const ScalableVectorType *SVTy) {
+    return get(ElementType, SVTy->getMinNumElements());
+  }
+
+  static ScalableVectorType *getInteger(ScalableVectorType *VTy) {
+    return cast<ScalableVectorType>(VectorType::getInteger(VTy));
+  }
+
+  static ScalableVectorType *
+  getExtendedElementVectorType(ScalableVectorType *VTy) {
+    return cast<ScalableVectorType>(
+        VectorType::getExtendedElementVectorType(VTy));
+  }
+
+  static ScalableVectorType *
+  getTruncatedElementVectorType(ScalableVectorType *VTy) {
+    return cast<ScalableVectorType>(
+        VectorType::getTruncatedElementVectorType(VTy));
+  }
+
+  static ScalableVectorType *getSubdividedVectorType(ScalableVectorType *VTy,
+                                                     int NumSubdivs) {
+    return cast<ScalableVectorType>(
+        VectorType::getSubdividedVectorType(VTy, NumSubdivs));
+  }
+
+  static ScalableVectorType *
+  getHalfElementsVectorType(ScalableVectorType *VTy) {
+    return cast<ScalableVectorType>(VectorType::getHalfElementsVectorType(VTy));
+  }
+
+  static ScalableVectorType *
+  getDoubleElementsVectorType(ScalableVectorType *VTy) {
+    return cast<ScalableVectorType>(
+        VectorType::getDoubleElementsVectorType(VTy));
+  }
+
+  /// Get the minimum number of elements in this vector. The actual number of
+  /// elements in the vector is an integer multiple of this value.
+  uint64_t getMinNumElements() const { return ElementQuantity; }
+
+  static bool classof(const Type *T) {
+    return T->getTypeID() == ScalableVectorTyID;
+  }
+};
+
+inline ElementCount VectorType::getElementCount() const {
+  return ElementCount::get(ElementQuantity, isa<ScalableVectorType>(this));
 }
 
 /// Class to represent pointers.
@@ -577,6 +688,26 @@
   }
 };
 
+Type *Type::getExtendedType() const {
+  assert(
+      isIntOrIntVectorTy() &&
+      "Original type expected to be a vector of integers or a scalar integer.");
+  if (auto *VTy = dyn_cast<VectorType>(this))
+    return VectorType::getExtendedElementVectorType(
+        const_cast<VectorType *>(VTy));
+  return cast<IntegerType>(this)->getExtendedType();
+}
+
+Type *Type::getWithNewBitWidth(unsigned NewBitWidth) const {
+  assert(
+      isIntOrIntVectorTy() &&
+      "Original type expected to be a vector of integers or a scalar integer.");
+  Type *NewType = getIntNTy(getContext(), NewBitWidth);
+  if (auto *VTy = dyn_cast<VectorType>(this))
+    NewType = VectorType::get(NewType, VTy->getElementCount());
+  return NewType;
+}
+
 unsigned Type::getPointerAddressSpace() const {
   return cast<PointerType>(getScalarType())->getAddressSpace();
 }
diff --git a/linux-x64/clang/include/llvm/IR/DiagnosticInfo.h b/linux-x64/clang/include/llvm/IR/DiagnosticInfo.h
index 3736632..c457072 100644
--- a/linux-x64/clang/include/llvm/IR/DiagnosticInfo.h
+++ b/linux-x64/clang/include/llvm/IR/DiagnosticInfo.h
@@ -21,6 +21,7 @@
 #include "llvm/ADT/Twine.h"
 #include "llvm/IR/DebugLoc.h"
 #include "llvm/Support/CBindingWrapping.h"
+#include "llvm/Support/TypeSize.h"
 #include "llvm/Support/YAMLTraits.h"
 #include <algorithm>
 #include <cstdint>
@@ -34,6 +35,7 @@
 class DiagnosticPrinter;
 class Function;
 class Instruction;
+class InstructionCost;
 class LLVMContext;
 class Module;
 class SMDiagnostic;
@@ -55,6 +57,7 @@
   DK_ResourceLimit,
   DK_StackSize,
   DK_Linker,
+  DK_Lowering,
   DK_DebugMetadataVersion,
   DK_DebugMetadataInvalid,
   DK_ISelFallback,
@@ -75,7 +78,8 @@
   DK_MIRParser,
   DK_PGOProfile,
   DK_Unsupported,
-  DK_FirstPluginKind
+  DK_FirstPluginKind // Must be last value to work with
+                     // getNextAvailablePluginDiagnosticKind
 };
 
 /// Get the next available kind ID for a plugin diagnostic.
@@ -210,7 +214,7 @@
 };
 
 class DiagnosticInfoStackSize : public DiagnosticInfoResourceLimit {
-  virtual void anchor() override;
+  void anchor() override;
 public:
   DiagnosticInfoStackSize(const Function &Fn, uint64_t StackSize,
                           DiagnosticSeverity Severity = DS_Warning,
@@ -361,7 +365,7 @@
 
 /// Common features for diagnostics with an associated location.
 class DiagnosticInfoWithLocationBase : public DiagnosticInfo {
-  virtual void anchor() override;
+  void anchor() override;
 public:
   /// \p Fn is the function where the diagnostic is being emitted. \p Loc is
   /// the location information to use in the diagnostic.
@@ -431,8 +435,10 @@
     Argument(StringRef Key, unsigned N);
     Argument(StringRef Key, unsigned long N);
     Argument(StringRef Key, unsigned long long N);
+    Argument(StringRef Key, ElementCount EC);
     Argument(StringRef Key, bool B) : Key(Key), Val(B ? "true" : "false") {}
     Argument(StringRef Key, DebugLoc dl);
+    Argument(StringRef Key, InstructionCost C);
   };
 
   /// \p PassName is the name of the pass emitting this diagnostic. \p
@@ -529,9 +535,10 @@
 template <class RemarkT>
 RemarkT &
 operator<<(RemarkT &R,
-           typename std::enable_if<
+           std::enable_if_t<
                std::is_base_of<DiagnosticInfoOptimizationBase, RemarkT>::value,
-               StringRef>::type S) {
+               StringRef>
+               S) {
   R.insert(S);
   return R;
 }
@@ -541,9 +548,10 @@
 template <class RemarkT>
 RemarkT &
 operator<<(RemarkT &&R,
-           typename std::enable_if<
+           std::enable_if_t<
                std::is_base_of<DiagnosticInfoOptimizationBase, RemarkT>::value,
-               StringRef>::type S) {
+               StringRef>
+               S) {
   R.insert(S);
   return R;
 }
@@ -551,9 +559,10 @@
 template <class RemarkT>
 RemarkT &
 operator<<(RemarkT &R,
-           typename std::enable_if<
+           std::enable_if_t<
                std::is_base_of<DiagnosticInfoOptimizationBase, RemarkT>::value,
-               DiagnosticInfoOptimizationBase::Argument>::type A) {
+               DiagnosticInfoOptimizationBase::Argument>
+               A) {
   R.insert(A);
   return R;
 }
@@ -561,9 +570,10 @@
 template <class RemarkT>
 RemarkT &
 operator<<(RemarkT &&R,
-           typename std::enable_if<
+           std::enable_if_t<
                std::is_base_of<DiagnosticInfoOptimizationBase, RemarkT>::value,
-               DiagnosticInfoOptimizationBase::Argument>::type A) {
+               DiagnosticInfoOptimizationBase::Argument>
+               A) {
   R.insert(A);
   return R;
 }
@@ -571,9 +581,10 @@
 template <class RemarkT>
 RemarkT &
 operator<<(RemarkT &R,
-           typename std::enable_if<
+           std::enable_if_t<
                std::is_base_of<DiagnosticInfoOptimizationBase, RemarkT>::value,
-               DiagnosticInfoOptimizationBase::setIsVerbose>::type V) {
+               DiagnosticInfoOptimizationBase::setIsVerbose>
+               V) {
   R.insert(V);
   return R;
 }
@@ -581,9 +592,10 @@
 template <class RemarkT>
 RemarkT &
 operator<<(RemarkT &&R,
-           typename std::enable_if<
+           std::enable_if_t<
                std::is_base_of<DiagnosticInfoOptimizationBase, RemarkT>::value,
-               DiagnosticInfoOptimizationBase::setIsVerbose>::type V) {
+               DiagnosticInfoOptimizationBase::setIsVerbose>
+               V) {
   R.insert(V);
   return R;
 }
@@ -591,9 +603,10 @@
 template <class RemarkT>
 RemarkT &
 operator<<(RemarkT &R,
-           typename std::enable_if<
+           std::enable_if_t<
                std::is_base_of<DiagnosticInfoOptimizationBase, RemarkT>::value,
-               DiagnosticInfoOptimizationBase::setExtraArgs>::type EA) {
+               DiagnosticInfoOptimizationBase::setExtraArgs>
+               EA) {
   R.insert(EA);
   return R;
 }
@@ -601,7 +614,7 @@
 /// Common features for diagnostics dealing with optimization remarks
 /// that are used by IR passes.
 class DiagnosticInfoIROptimization : public DiagnosticInfoOptimizationBase {
-  virtual void anchor() override;
+  void anchor() override;
 public:
   /// \p PassName is the name of the pass emitting this diagnostic. \p
   /// RemarkName is a textual identifier for the remark (single-word,
@@ -663,7 +676,7 @@
 private:
   /// The IR value (currently basic block) that the optimization operates on.
   /// This is currently used to provide run-time hotness information with PGO.
-  const Value *CodeRegion;
+  const Value *CodeRegion = nullptr;
 };
 
 /// Diagnostic information for applied optimization remarks.
@@ -822,7 +835,7 @@
 /// Diagnostic information for optimization analysis remarks related to
 /// floating-point non-commutativity.
 class OptimizationRemarkAnalysisFPCommute : public OptimizationRemarkAnalysis {
-  virtual void anchor();
+  void anchor() override;
 public:
   /// \p PassName is the name of the pass emitting this diagnostic. If this name
   /// matches the regular expression given in -Rpass-analysis=, then the
@@ -864,7 +877,7 @@
 /// Diagnostic information for optimization analysis remarks related to
 /// pointer aliasing.
 class OptimizationRemarkAnalysisAliasing : public OptimizationRemarkAnalysis {
-  virtual void anchor();
+  void anchor() override;
 public:
   /// \p PassName is the name of the pass emitting this diagnostic. If this name
   /// matches the regular expression given in -Rpass-analysis=, then the
diff --git a/linux-x64/clang/include/llvm/IR/Dominators.h b/linux-x64/clang/include/llvm/IR/Dominators.h
index fef1c6a..08dbcca 100644
--- a/linux-x64/clang/include/llvm/IR/Dominators.h
+++ b/linux-x64/clang/include/llvm/IR/Dominators.h
@@ -44,6 +44,9 @@
 
 using BBUpdates = ArrayRef<llvm::cfg::Update<BasicBlock *>>;
 
+using BBDomTreeGraphDiff = GraphDiff<BasicBlock *, false>;
+using BBPostDomTreeGraphDiff = GraphDiff<BasicBlock *, true>;
+
 extern template void Calculate<BBDomTree>(BBDomTree &DT);
 extern template void CalculateWithUpdates<BBDomTree>(BBDomTree &DT,
                                                      BBUpdates U);
@@ -62,8 +65,12 @@
                                                BasicBlock *From,
                                                BasicBlock *To);
 
-extern template void ApplyUpdates<BBDomTree>(BBDomTree &DT, BBUpdates);
-extern template void ApplyUpdates<BBPostDomTree>(BBPostDomTree &DT, BBUpdates);
+extern template void ApplyUpdates<BBDomTree>(BBDomTree &DT,
+                                             BBDomTreeGraphDiff &,
+                                             BBDomTreeGraphDiff *);
+extern template void ApplyUpdates<BBPostDomTree>(BBPostDomTree &DT,
+                                                 BBPostDomTreeGraphDiff &,
+                                                 BBPostDomTreeGraphDiff *);
 
 extern template bool Verify<BBDomTree>(const BBDomTree &DT,
                                        BBDomTree::VerificationLevel VL);
@@ -158,12 +165,21 @@
   // Ensure base-class overloads are visible.
   using Base::dominates;
 
-  /// Return true if Def dominates a use in User.
+  /// Return true if value Def dominates use U, in the sense that Def is
+  /// available at U, and could be substituted as the used value without
+  /// violating the SSA dominance requirement.
   ///
-  /// This performs the special checks necessary if Def and User are in the same
-  /// basic block. Note that Def doesn't dominate a use in Def itself!
-  bool dominates(const Instruction *Def, const Use &U) const;
-  bool dominates(const Instruction *Def, const Instruction *User) const;
+  /// In particular, it is worth noting that:
+  ///  * Non-instruction Defs dominate everything.
+  ///  * Def does not dominate a use in Def itself (outside of degenerate cases
+  ///    like unreachable code or trivial phi cycles).
+  ///  * Invoke/callbr Defs only dominate uses in their default destination.
+  bool dominates(const Value *Def, const Use &U) const;
+  /// Return true if value Def dominates all possible uses inside instruction
+  /// User. Same comments as for the Use-based API apply.
+  bool dominates(const Value *Def, const Instruction *User) const;
+  // Does not accept Value to avoid ambiguity with dominance checks between
+  // two basic blocks.
   bool dominates(const Instruction *Def, const BasicBlock *BB) const;
 
   /// Return true if an edge dominates a use.
@@ -172,6 +188,8 @@
   /// never dominate the use.
   bool dominates(const BasicBlockEdge &BBE, const Use &U) const;
   bool dominates(const BasicBlockEdge &BBE, const BasicBlock *BB) const;
+  /// Returns true if edge \p BBE1 dominates edge \p BBE2.
+  bool dominates(const BasicBlockEdge &BBE1, const BasicBlockEdge &BBE2) const;
 
   // Ensure base class overloads are visible.
   using Base::isReachableFromEntry;
@@ -206,7 +224,8 @@
 
 template <>
 struct GraphTraits<DomTreeNode *>
-    : public DomTreeGraphTraitsBase<DomTreeNode, DomTreeNode::iterator> {};
+    : public DomTreeGraphTraitsBase<DomTreeNode, DomTreeNode::const_iterator> {
+};
 
 template <>
 struct GraphTraits<const DomTreeNode *>
@@ -262,9 +281,7 @@
 public:
   static char ID;
 
-  DominatorTreeWrapperPass() : FunctionPass(ID) {
-    initializeDominatorTreeWrapperPassPass(*PassRegistry::getPassRegistry());
-  }
+  DominatorTreeWrapperPass();
 
   DominatorTree &getDomTree() { return DT; }
   const DominatorTree &getDomTree() const { return DT; }
@@ -277,7 +294,7 @@
     AU.setPreservesAll();
   }
 
-  void releaseMemory() override { DT.releaseMemory(); }
+  void releaseMemory() override { DT.reset(); }
 
   void print(raw_ostream &OS, const Module *M = nullptr) const override;
 };
diff --git a/linux-x64/clang/include/llvm/IR/FPEnv.h b/linux-x64/clang/include/llvm/IR/FPEnv.h
new file mode 100644
index 0000000..f00cb73
--- /dev/null
+++ b/linux-x64/clang/include/llvm/IR/FPEnv.h
@@ -0,0 +1,56 @@
+//===- FPEnv.h ---- FP Environment ------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+/// @file
+/// This file contains the declarations of entities that describe floating
+/// point environment and related functions.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_IR_FLOATINGPOINT_H
+#define LLVM_IR_FLOATINGPOINT_H
+
+#include "llvm/ADT/FloatingPointMode.h"
+#include "llvm/ADT/Optional.h"
+
+namespace llvm {
+class StringRef;
+
+namespace fp {
+
+/// Exception behavior used for floating point operations.
+///
+/// Each of these values correspond to some metadata argument value of a
+/// constrained floating point intrinsic. See the LLVM Language Reference Manual
+/// for details.
+enum ExceptionBehavior : uint8_t {
+  ebIgnore,  ///< This corresponds to "fpexcept.ignore".
+  ebMayTrap, ///< This corresponds to "fpexcept.maytrap".
+  ebStrict   ///< This corresponds to "fpexcept.strict".
+};
+
+}
+
+/// Returns a valid RoundingMode enumerator when given a string
+/// that is valid as input in constrained intrinsic rounding mode
+/// metadata.
+Optional<RoundingMode> StrToRoundingMode(StringRef);
+
+/// For any RoundingMode enumerator, returns a string valid as input in
+/// constrained intrinsic rounding mode metadata.
+Optional<StringRef> RoundingModeToStr(RoundingMode);
+
+/// Returns a valid ExceptionBehavior enumerator when given a string
+/// valid as input in constrained intrinsic exception behavior metadata.
+Optional<fp::ExceptionBehavior> StrToExceptionBehavior(StringRef);
+
+/// For any ExceptionBehavior enumerator, returns a string valid as
+/// input in constrained intrinsic exception behavior metadata.
+Optional<StringRef> ExceptionBehaviorToStr(fp::ExceptionBehavior);
+}
+#endif
diff --git a/linux-x64/clang/include/llvm/IR/FixedMetadataKinds.def b/linux-x64/clang/include/llvm/IR/FixedMetadataKinds.def
new file mode 100644
index 0000000..31979cd
--- /dev/null
+++ b/linux-x64/clang/include/llvm/IR/FixedMetadataKinds.def
@@ -0,0 +1,44 @@
+/*===-- FixedMetadataKinds.def - Fixed metadata kind IDs -------*- C++ -*-=== *\
+|*
+|* Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+|* See https://llvm.org/LICENSE.txt for license information.
+|* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+|*
+\*===----------------------------------------------------------------------===*/
+
+#ifndef LLVM_FIXED_MD_KIND
+#error "LLVM_FIXED_MD_KIND(EnumID, Name, Value) is not defined."
+#endif
+
+LLVM_FIXED_MD_KIND(MD_dbg, "dbg", 0)
+LLVM_FIXED_MD_KIND(MD_tbaa, "tbaa", 1)
+LLVM_FIXED_MD_KIND(MD_prof, "prof", 2)
+LLVM_FIXED_MD_KIND(MD_fpmath, "fpmath", 3)
+LLVM_FIXED_MD_KIND(MD_range, "range", 4)
+LLVM_FIXED_MD_KIND(MD_tbaa_struct, "tbaa.struct", 5)
+LLVM_FIXED_MD_KIND(MD_invariant_load, "invariant.load", 6)
+LLVM_FIXED_MD_KIND(MD_alias_scope, "alias.scope", 7)
+LLVM_FIXED_MD_KIND(MD_noalias, "noalias", 8)
+LLVM_FIXED_MD_KIND(MD_nontemporal, "nontemporal", 9)
+LLVM_FIXED_MD_KIND(MD_mem_parallel_loop_access,
+                    "llvm.mem.parallel_loop_access", 10)
+LLVM_FIXED_MD_KIND(MD_nonnull, "nonnull", 11)
+LLVM_FIXED_MD_KIND(MD_dereferenceable, "dereferenceable", 12)
+LLVM_FIXED_MD_KIND(MD_dereferenceable_or_null, "dereferenceable_or_null", 13)
+LLVM_FIXED_MD_KIND(MD_make_implicit, "make.implicit", 14)
+LLVM_FIXED_MD_KIND(MD_unpredictable, "unpredictable", 15)
+LLVM_FIXED_MD_KIND(MD_invariant_group, "invariant.group", 16)
+LLVM_FIXED_MD_KIND(MD_align, "align", 17)
+LLVM_FIXED_MD_KIND(MD_loop, "llvm.loop", 18)
+LLVM_FIXED_MD_KIND(MD_type, "type", 19)
+LLVM_FIXED_MD_KIND(MD_section_prefix, "section_prefix", 20)
+LLVM_FIXED_MD_KIND(MD_absolute_symbol, "absolute_symbol", 21)
+LLVM_FIXED_MD_KIND(MD_associated, "associated", 22)
+LLVM_FIXED_MD_KIND(MD_callees, "callees", 23)
+LLVM_FIXED_MD_KIND(MD_irr_loop, "irr_loop", 24)
+LLVM_FIXED_MD_KIND(MD_access_group, "llvm.access.group", 25)
+LLVM_FIXED_MD_KIND(MD_callback, "callback", 26)
+LLVM_FIXED_MD_KIND(MD_preserve_access_index, "llvm.preserve.access.index", 27)
+LLVM_FIXED_MD_KIND(MD_vcall_visibility, "vcall_visibility", 28)
+LLVM_FIXED_MD_KIND(MD_noundef, "noundef", 29)
+LLVM_FIXED_MD_KIND(MD_annotation, "annotation", 30)
diff --git a/linux-x64/clang/include/llvm/IR/FixedPointBuilder.h b/linux-x64/clang/include/llvm/IR/FixedPointBuilder.h
new file mode 100644
index 0000000..a99c761
--- /dev/null
+++ b/linux-x64/clang/include/llvm/IR/FixedPointBuilder.h
@@ -0,0 +1,465 @@
+//===- llvm/FixedPointBuilder.h - Builder for fixed-point ops ---*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the FixedPointBuilder class, which is used as a convenient
+// way to lower fixed-point arithmetic operations to LLVM IR.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_IR_FIXEDPOINTBUILDER_H
+#define LLVM_IR_FIXEDPOINTBUILDER_H
+
+#include "llvm/ADT/APFixedPoint.h"
+#include "llvm/IR/Constant.h"
+#include "llvm/IR/Constants.h"
+#include "llvm/IR/IRBuilder.h"
+#include "llvm/IR/InstrTypes.h"
+#include "llvm/IR/Instruction.h"
+#include "llvm/IR/IntrinsicInst.h"
+#include "llvm/IR/Intrinsics.h"
+#include "llvm/IR/Type.h"
+#include "llvm/IR/Value.h"
+
+namespace llvm {
+
+template <class IRBuilderTy> class FixedPointBuilder {
+  IRBuilderTy &B;
+
+  Value *Convert(Value *Src, const FixedPointSemantics &SrcSema,
+                 const FixedPointSemantics &DstSema, bool DstIsInteger) {
+    unsigned SrcWidth = SrcSema.getWidth();
+    unsigned DstWidth = DstSema.getWidth();
+    unsigned SrcScale = SrcSema.getScale();
+    unsigned DstScale = DstSema.getScale();
+    bool SrcIsSigned = SrcSema.isSigned();
+    bool DstIsSigned = DstSema.isSigned();
+
+    Type *DstIntTy = B.getIntNTy(DstWidth);
+
+    Value *Result = Src;
+    unsigned ResultWidth = SrcWidth;
+
+    // Downscale.
+    if (DstScale < SrcScale) {
+      // When converting to integers, we round towards zero. For negative
+      // numbers, right shifting rounds towards negative infinity. In this case,
+      // we can just round up before shifting.
+      if (DstIsInteger && SrcIsSigned) {
+        Value *Zero = Constant::getNullValue(Result->getType());
+        Value *IsNegative = B.CreateICmpSLT(Result, Zero);
+        Value *LowBits = ConstantInt::get(
+            B.getContext(), APInt::getLowBitsSet(ResultWidth, SrcScale));
+        Value *Rounded = B.CreateAdd(Result, LowBits);
+        Result = B.CreateSelect(IsNegative, Rounded, Result);
+      }
+
+      Result = SrcIsSigned
+                   ? B.CreateAShr(Result, SrcScale - DstScale, "downscale")
+                   : B.CreateLShr(Result, SrcScale - DstScale, "downscale");
+    }
+
+    if (!DstSema.isSaturated()) {
+      // Resize.
+      Result = B.CreateIntCast(Result, DstIntTy, SrcIsSigned, "resize");
+
+      // Upscale.
+      if (DstScale > SrcScale)
+        Result = B.CreateShl(Result, DstScale - SrcScale, "upscale");
+    } else {
+      // Adjust the number of fractional bits.
+      if (DstScale > SrcScale) {
+        // Compare to DstWidth to prevent resizing twice.
+        ResultWidth = std::max(SrcWidth + DstScale - SrcScale, DstWidth);
+        Type *UpscaledTy = B.getIntNTy(ResultWidth);
+        Result = B.CreateIntCast(Result, UpscaledTy, SrcIsSigned, "resize");
+        Result = B.CreateShl(Result, DstScale - SrcScale, "upscale");
+      }
+
+      // Handle saturation.
+      bool LessIntBits = DstSema.getIntegralBits() < SrcSema.getIntegralBits();
+      if (LessIntBits) {
+        Value *Max = ConstantInt::get(
+            B.getContext(),
+            APFixedPoint::getMax(DstSema).getValue().extOrTrunc(ResultWidth));
+        Value *TooHigh = SrcIsSigned ? B.CreateICmpSGT(Result, Max)
+                                     : B.CreateICmpUGT(Result, Max);
+        Result = B.CreateSelect(TooHigh, Max, Result, "satmax");
+      }
+      // Cannot overflow min to dest type if src is unsigned since all fixed
+      // point types can cover the unsigned min of 0.
+      if (SrcIsSigned && (LessIntBits || !DstIsSigned)) {
+        Value *Min = ConstantInt::get(
+            B.getContext(),
+            APFixedPoint::getMin(DstSema).getValue().extOrTrunc(ResultWidth));
+        Value *TooLow = B.CreateICmpSLT(Result, Min);
+        Result = B.CreateSelect(TooLow, Min, Result, "satmin");
+      }
+
+      // Resize the integer part to get the final destination size.
+      if (ResultWidth != DstWidth)
+        Result = B.CreateIntCast(Result, DstIntTy, SrcIsSigned, "resize");
+    }
+    return Result;
+  }
+
+  /// Get the common semantic for two semantics, with the added imposition that
+  /// saturated padded types retain the padding bit.
+  FixedPointSemantics
+  getCommonBinopSemantic(const FixedPointSemantics &LHSSema,
+                         const FixedPointSemantics &RHSSema) {
+    auto C = LHSSema.getCommonSemantics(RHSSema);
+    bool BothPadded =
+        LHSSema.hasUnsignedPadding() && RHSSema.hasUnsignedPadding();
+    return FixedPointSemantics(
+        C.getWidth() + (unsigned)(BothPadded && C.isSaturated()), C.getScale(),
+        C.isSigned(), C.isSaturated(), BothPadded);
+  }
+
+  /// Given a floating point type and a fixed-point semantic, return a floating
+  /// point type which can accommodate the fixed-point semantic. This is either
+  /// \p Ty, or a floating point type with a larger exponent than Ty.
+  Type *getAccommodatingFloatType(Type *Ty, const FixedPointSemantics &Sema) {
+    const fltSemantics *FloatSema = &Ty->getFltSemantics();
+    while (!Sema.fitsInFloatSemantics(*FloatSema))
+      FloatSema = APFixedPoint::promoteFloatSemantics(FloatSema);
+    return Type::getFloatingPointTy(Ty->getContext(), *FloatSema);
+  }
+
+public:
+  FixedPointBuilder(IRBuilderTy &Builder) : B(Builder) {}
+
+  /// Convert an integer value representing a fixed-point number from one
+  /// fixed-point semantic to another fixed-point semantic.
+  /// \p Src     - The source value
+  /// \p SrcSema - The fixed-point semantic of the source value
+  /// \p DstSema - The resulting fixed-point semantic
+  Value *CreateFixedToFixed(Value *Src, const FixedPointSemantics &SrcSema,
+                            const FixedPointSemantics &DstSema) {
+    return Convert(Src, SrcSema, DstSema, false);
+  }
+
+  /// Convert an integer value representing a fixed-point number to an integer
+  /// with the given bit width and signedness.
+  /// \p Src         - The source value
+  /// \p SrcSema     - The fixed-point semantic of the source value
+  /// \p DstWidth    - The bit width of the result value
+  /// \p DstIsSigned - The signedness of the result value
+  Value *CreateFixedToInteger(Value *Src, const FixedPointSemantics &SrcSema,
+                              unsigned DstWidth, bool DstIsSigned) {
+    return Convert(
+        Src, SrcSema,
+        FixedPointSemantics::GetIntegerSemantics(DstWidth, DstIsSigned), true);
+  }
+
+  /// Convert an integer value with the given signedness to an integer value
+  /// representing the given fixed-point semantic.
+  /// \p Src         - The source value
+  /// \p SrcIsSigned - The signedness of the source value
+  /// \p DstSema     - The resulting fixed-point semantic
+  Value *CreateIntegerToFixed(Value *Src, unsigned SrcIsSigned,
+                              const FixedPointSemantics &DstSema) {
+    return Convert(Src,
+                   FixedPointSemantics::GetIntegerSemantics(
+                       Src->getType()->getScalarSizeInBits(), SrcIsSigned),
+                   DstSema, false);
+  }
+
+  Value *CreateFixedToFloating(Value *Src, const FixedPointSemantics &SrcSema,
+                               Type *DstTy) {
+    Value *Result;
+    Type *OpTy = getAccommodatingFloatType(DstTy, SrcSema);
+    // Convert the raw fixed-point value directly to floating point. If the
+    // value is too large to fit, it will be rounded, not truncated.
+    Result = SrcSema.isSigned() ? B.CreateSIToFP(Src, OpTy)
+                                : B.CreateUIToFP(Src, OpTy);
+    // Rescale the integral-in-floating point by the scaling factor. This is
+    // lossless, except for overflow to infinity which is unlikely.
+    Result = B.CreateFMul(Result,
+        ConstantFP::get(OpTy, std::pow(2, -(int)SrcSema.getScale())));
+    if (OpTy != DstTy)
+      Result = B.CreateFPTrunc(Result, DstTy);
+    return Result;
+  }
+
+  Value *CreateFloatingToFixed(Value *Src, const FixedPointSemantics &DstSema) {
+    bool UseSigned = DstSema.isSigned() || DstSema.hasUnsignedPadding();
+    Value *Result = Src;
+    Type *OpTy = getAccommodatingFloatType(Src->getType(), DstSema);
+    if (OpTy != Src->getType())
+      Result = B.CreateFPExt(Result, OpTy);
+    // Rescale the floating point value so that its significant bits (for the
+    // purposes of the conversion) are in the integral range.
+    Result = B.CreateFMul(Result,
+        ConstantFP::get(OpTy, std::pow(2, DstSema.getScale())));
+
+    Type *ResultTy = B.getIntNTy(DstSema.getWidth());
+    if (DstSema.isSaturated()) {
+      Intrinsic::ID IID =
+          UseSigned ? Intrinsic::fptosi_sat : Intrinsic::fptoui_sat;
+      Result = B.CreateIntrinsic(IID, {ResultTy, OpTy}, {Result});
+    } else {
+      Result = UseSigned ? B.CreateFPToSI(Result, ResultTy)
+                         : B.CreateFPToUI(Result, ResultTy);
+    }
+
+    // When saturating unsigned-with-padding using signed operations, we may
+    // get negative values. Emit an extra clamp to zero.
+    if (DstSema.isSaturated() && DstSema.hasUnsignedPadding()) {
+      Constant *Zero = Constant::getNullValue(Result->getType());
+      Result =
+          B.CreateSelect(B.CreateICmpSLT(Result, Zero), Zero, Result, "satmin");
+    }
+
+    return Result;
+  }
+
+  /// Add two fixed-point values and return the result in their common semantic.
+  /// \p LHS     - The left hand side
+  /// \p LHSSema - The semantic of the left hand side
+  /// \p RHS     - The right hand side
+  /// \p RHSSema - The semantic of the right hand side
+  Value *CreateAdd(Value *LHS, const FixedPointSemantics &LHSSema,
+                   Value *RHS, const FixedPointSemantics &RHSSema) {
+    auto CommonSema = getCommonBinopSemantic(LHSSema, RHSSema);
+    bool UseSigned = CommonSema.isSigned() || CommonSema.hasUnsignedPadding();
+
+    Value *WideLHS = CreateFixedToFixed(LHS, LHSSema, CommonSema);
+    Value *WideRHS = CreateFixedToFixed(RHS, RHSSema, CommonSema);
+
+    Value *Result;
+    if (CommonSema.isSaturated()) {
+      Intrinsic::ID IID = UseSigned ? Intrinsic::sadd_sat : Intrinsic::uadd_sat;
+      Result = B.CreateBinaryIntrinsic(IID, WideLHS, WideRHS);
+    } else {
+      Result = B.CreateAdd(WideLHS, WideRHS);
+    }
+
+    return CreateFixedToFixed(Result, CommonSema,
+                              LHSSema.getCommonSemantics(RHSSema));
+  }
+
+  /// Subtract two fixed-point values and return the result in their common
+  /// semantic.
+  /// \p LHS     - The left hand side
+  /// \p LHSSema - The semantic of the left hand side
+  /// \p RHS     - The right hand side
+  /// \p RHSSema - The semantic of the right hand side
+  Value *CreateSub(Value *LHS, const FixedPointSemantics &LHSSema,
+                   Value *RHS, const FixedPointSemantics &RHSSema) {
+    auto CommonSema = getCommonBinopSemantic(LHSSema, RHSSema);
+    bool UseSigned = CommonSema.isSigned() || CommonSema.hasUnsignedPadding();
+
+    Value *WideLHS = CreateFixedToFixed(LHS, LHSSema, CommonSema);
+    Value *WideRHS = CreateFixedToFixed(RHS, RHSSema, CommonSema);
+
+    Value *Result;
+    if (CommonSema.isSaturated()) {
+      Intrinsic::ID IID = UseSigned ? Intrinsic::ssub_sat : Intrinsic::usub_sat;
+      Result = B.CreateBinaryIntrinsic(IID, WideLHS, WideRHS);
+    } else {
+      Result = B.CreateSub(WideLHS, WideRHS);
+    }
+
+    // Subtraction can end up below 0 for padded unsigned operations, so emit
+    // an extra clamp in that case.
+    if (CommonSema.isSaturated() && CommonSema.hasUnsignedPadding()) {
+      Constant *Zero = Constant::getNullValue(Result->getType());
+      Result =
+          B.CreateSelect(B.CreateICmpSLT(Result, Zero), Zero, Result, "satmin");
+    }
+
+    return CreateFixedToFixed(Result, CommonSema,
+                              LHSSema.getCommonSemantics(RHSSema));
+  }
+
+  /// Multiply two fixed-point values and return the result in their common
+  /// semantic.
+  /// \p LHS     - The left hand side
+  /// \p LHSSema - The semantic of the left hand side
+  /// \p RHS     - The right hand side
+  /// \p RHSSema - The semantic of the right hand side
+  Value *CreateMul(Value *LHS, const FixedPointSemantics &LHSSema,
+                   Value *RHS, const FixedPointSemantics &RHSSema) {
+    auto CommonSema = getCommonBinopSemantic(LHSSema, RHSSema);
+    bool UseSigned = CommonSema.isSigned() || CommonSema.hasUnsignedPadding();
+
+    Value *WideLHS = CreateFixedToFixed(LHS, LHSSema, CommonSema);
+    Value *WideRHS = CreateFixedToFixed(RHS, RHSSema, CommonSema);
+
+    Intrinsic::ID IID;
+    if (CommonSema.isSaturated()) {
+      IID = UseSigned ? Intrinsic::smul_fix_sat : Intrinsic::umul_fix_sat;
+    } else {
+      IID = UseSigned ? Intrinsic::smul_fix : Intrinsic::umul_fix;
+    }
+    Value *Result = B.CreateIntrinsic(
+        IID, {WideLHS->getType()},
+        {WideLHS, WideRHS, B.getInt32(CommonSema.getScale())});
+
+    return CreateFixedToFixed(Result, CommonSema,
+                              LHSSema.getCommonSemantics(RHSSema));
+  }
+
+  /// Divide two fixed-point values and return the result in their common
+  /// semantic.
+  /// \p LHS     - The left hand side
+  /// \p LHSSema - The semantic of the left hand side
+  /// \p RHS     - The right hand side
+  /// \p RHSSema - The semantic of the right hand side
+  Value *CreateDiv(Value *LHS, const FixedPointSemantics &LHSSema,
+                   Value *RHS, const FixedPointSemantics &RHSSema) {
+    auto CommonSema = getCommonBinopSemantic(LHSSema, RHSSema);
+    bool UseSigned = CommonSema.isSigned() || CommonSema.hasUnsignedPadding();
+
+    Value *WideLHS = CreateFixedToFixed(LHS, LHSSema, CommonSema);
+    Value *WideRHS = CreateFixedToFixed(RHS, RHSSema, CommonSema);
+
+    Intrinsic::ID IID;
+    if (CommonSema.isSaturated()) {
+      IID = UseSigned ? Intrinsic::sdiv_fix_sat : Intrinsic::udiv_fix_sat;
+    } else {
+      IID = UseSigned ? Intrinsic::sdiv_fix : Intrinsic::udiv_fix;
+    }
+    Value *Result = B.CreateIntrinsic(
+        IID, {WideLHS->getType()},
+        {WideLHS, WideRHS, B.getInt32(CommonSema.getScale())});
+
+    return CreateFixedToFixed(Result, CommonSema,
+                              LHSSema.getCommonSemantics(RHSSema));
+  }
+
+  /// Left shift a fixed-point value by an unsigned integer value. The integer
+  /// value can be any bit width.
+  /// \p LHS     - The left hand side
+  /// \p LHSSema - The semantic of the left hand side
+  /// \p RHS     - The right hand side
+  Value *CreateShl(Value *LHS, const FixedPointSemantics &LHSSema, Value *RHS) {
+    bool UseSigned = LHSSema.isSigned() || LHSSema.hasUnsignedPadding();
+
+    RHS = B.CreateIntCast(RHS, LHS->getType(), /*IsSigned=*/false);
+
+    Value *Result;
+    if (LHSSema.isSaturated()) {
+      Intrinsic::ID IID = UseSigned ? Intrinsic::sshl_sat : Intrinsic::ushl_sat;
+      Result = B.CreateBinaryIntrinsic(IID, LHS, RHS);
+    } else {
+      Result = B.CreateShl(LHS, RHS);
+    }
+
+    return Result;
+  }
+
+  /// Right shift a fixed-point value by an unsigned integer value. The integer
+  /// value can be any bit width.
+  /// \p LHS     - The left hand side
+  /// \p LHSSema - The semantic of the left hand side
+  /// \p RHS     - The right hand side
+  Value *CreateShr(Value *LHS, const FixedPointSemantics &LHSSema, Value *RHS) {
+    RHS = B.CreateIntCast(RHS, LHS->getType(), false);
+
+    return LHSSema.isSigned() ? B.CreateAShr(LHS, RHS) : B.CreateLShr(LHS, RHS);
+  }
+
+  /// Compare two fixed-point values for equality.
+  /// \p LHS     - The left hand side
+  /// \p LHSSema - The semantic of the left hand side
+  /// \p RHS     - The right hand side
+  /// \p RHSSema - The semantic of the right hand side
+  Value *CreateEQ(Value *LHS, const FixedPointSemantics &LHSSema,
+                  Value *RHS, const FixedPointSemantics &RHSSema) {
+    auto CommonSema = getCommonBinopSemantic(LHSSema, RHSSema);
+
+    Value *WideLHS = CreateFixedToFixed(LHS, LHSSema, CommonSema);
+    Value *WideRHS = CreateFixedToFixed(RHS, RHSSema, CommonSema);
+
+    return B.CreateICmpEQ(WideLHS, WideRHS);
+  }
+
+  /// Compare two fixed-point values for inequality.
+  /// \p LHS     - The left hand side
+  /// \p LHSSema - The semantic of the left hand side
+  /// \p RHS     - The right hand side
+  /// \p RHSSema - The semantic of the right hand side
+  Value *CreateNE(Value *LHS, const FixedPointSemantics &LHSSema,
+                  Value *RHS, const FixedPointSemantics &RHSSema) {
+    auto CommonSema = getCommonBinopSemantic(LHSSema, RHSSema);
+
+    Value *WideLHS = CreateFixedToFixed(LHS, LHSSema, CommonSema);
+    Value *WideRHS = CreateFixedToFixed(RHS, RHSSema, CommonSema);
+
+    return B.CreateICmpNE(WideLHS, WideRHS);
+  }
+
+  /// Compare two fixed-point values as LHS < RHS.
+  /// \p LHS     - The left hand side
+  /// \p LHSSema - The semantic of the left hand side
+  /// \p RHS     - The right hand side
+  /// \p RHSSema - The semantic of the right hand side
+  Value *CreateLT(Value *LHS, const FixedPointSemantics &LHSSema,
+                  Value *RHS, const FixedPointSemantics &RHSSema) {
+    auto CommonSema = getCommonBinopSemantic(LHSSema, RHSSema);
+
+    Value *WideLHS = CreateFixedToFixed(LHS, LHSSema, CommonSema);
+    Value *WideRHS = CreateFixedToFixed(RHS, RHSSema, CommonSema);
+
+    return CommonSema.isSigned() ? B.CreateICmpSLT(WideLHS, WideRHS)
+                                 : B.CreateICmpULT(WideLHS, WideRHS);
+  }
+
+  /// Compare two fixed-point values as LHS <= RHS.
+  /// \p LHS     - The left hand side
+  /// \p LHSSema - The semantic of the left hand side
+  /// \p RHS     - The right hand side
+  /// \p RHSSema - The semantic of the right hand side
+  Value *CreateLE(Value *LHS, const FixedPointSemantics &LHSSema,
+                  Value *RHS, const FixedPointSemantics &RHSSema) {
+    auto CommonSema = getCommonBinopSemantic(LHSSema, RHSSema);
+
+    Value *WideLHS = CreateFixedToFixed(LHS, LHSSema, CommonSema);
+    Value *WideRHS = CreateFixedToFixed(RHS, RHSSema, CommonSema);
+
+    return CommonSema.isSigned() ? B.CreateICmpSLE(WideLHS, WideRHS)
+                                 : B.CreateICmpULE(WideLHS, WideRHS);
+  }
+
+  /// Compare two fixed-point values as LHS > RHS.
+  /// \p LHS     - The left hand side
+  /// \p LHSSema - The semantic of the left hand side
+  /// \p RHS     - The right hand side
+  /// \p RHSSema - The semantic of the right hand side
+  Value *CreateGT(Value *LHS, const FixedPointSemantics &LHSSema,
+                  Value *RHS, const FixedPointSemantics &RHSSema) {
+    auto CommonSema = getCommonBinopSemantic(LHSSema, RHSSema);
+
+    Value *WideLHS = CreateFixedToFixed(LHS, LHSSema, CommonSema);
+    Value *WideRHS = CreateFixedToFixed(RHS, RHSSema, CommonSema);
+
+    return CommonSema.isSigned() ? B.CreateICmpSGT(WideLHS, WideRHS)
+                                 : B.CreateICmpUGT(WideLHS, WideRHS);
+  }
+
+  /// Compare two fixed-point values as LHS >= RHS.
+  /// \p LHS     - The left hand side
+  /// \p LHSSema - The semantic of the left hand side
+  /// \p RHS     - The right hand side
+  /// \p RHSSema - The semantic of the right hand side
+  Value *CreateGE(Value *LHS, const FixedPointSemantics &LHSSema,
+                  Value *RHS, const FixedPointSemantics &RHSSema) {
+    auto CommonSema = getCommonBinopSemantic(LHSSema, RHSSema);
+
+    Value *WideLHS = CreateFixedToFixed(LHS, LHSSema, CommonSema);
+    Value *WideRHS = CreateFixedToFixed(RHS, RHSSema, CommonSema);
+
+    return CommonSema.isSigned() ? B.CreateICmpSGE(WideLHS, WideRHS)
+                                 : B.CreateICmpUGE(WideLHS, WideRHS);
+  }
+};
+
+} // end namespace llvm
+
+#endif // LLVM_IR_FIXEDPOINTBUILDER_H
diff --git a/linux-x64/clang/include/llvm/IR/Function.h b/linux-x64/clang/include/llvm/IR/Function.h
index 7fa61e1..7e209bb 100644
--- a/linux-x64/clang/include/llvm/IR/Function.h
+++ b/linux-x64/clang/include/llvm/IR/Function.h
@@ -43,7 +43,7 @@
 namespace llvm {
 
 namespace Intrinsic {
-enum ID : unsigned;
+typedef unsigned ID;
 }
 
 class AssemblyAnnotationWriter;
@@ -55,6 +55,8 @@
 class raw_ostream;
 class Type;
 class User;
+class BranchProbabilityInfo;
+class BlockFrequencyInfo;
 
 class Function : public GlobalObject, public ilist_node<Function> {
 public:
@@ -197,6 +199,20 @@
   /// returns Intrinsic::not_intrinsic!
   bool isIntrinsic() const { return HasLLVMReservedName; }
 
+  /// isTargetIntrinsic - Returns true if IID is an intrinsic specific to a
+  /// certain target. If it is a generic intrinsic false is returned.
+  static bool isTargetIntrinsic(Intrinsic::ID IID);
+
+  /// isTargetIntrinsic - Returns true if this function is an intrinsic and the
+  /// intrinsic is specific to a certain target. If this is not an intrinsic
+  /// or a generic intrinsic, false is returned.
+  bool isTargetIntrinsic() const;
+
+  /// Returns true if the function is one of the "Constrained Floating-Point
+  /// Intrinsics". Returns false if not, and returns false when
+  /// getIntrinsicID() returns Intrinsic::not_intrinsic.
+  bool isConstrainedFPIntrinsic() const;
+
   static Intrinsic::ID lookupIntrinsicID(StringRef Name);
 
   /// Recalculate the ID for this function if it is an Intrinsic defined
@@ -252,6 +268,12 @@
         getContext(), AttributeList::FunctionIndex, Kind));
   }
 
+  /// A function will have the "coroutine.presplit" attribute if it's
+  /// a coroutine and has not gone through full CoroSplit pass.
+  bool isPresplitCoroutine() const {
+    return hasFnAttribute("coroutine.presplit");
+  }
+
   enum ProfileCountType { PCT_Invalid, PCT_Real, PCT_Synthetic };
 
   /// Class to represent profile counts.
@@ -343,6 +365,16 @@
   unsigned getFnStackAlignment() const {
     if (!hasFnAttribute(Attribute::StackAlignment))
       return 0;
+    if (const auto MA =
+            AttributeSets.getStackAlignment(AttributeList::FunctionIndex))
+      return MA->value();
+    return 0;
+  }
+
+  /// Return the stack alignment for the function.
+  MaybeAlign getFnStackAlign() const {
+    if (!hasFnAttribute(Attribute::StackAlignment))
+      return None;
     return AttributeSets.getStackAlignment(AttributeList::FunctionIndex);
   }
 
@@ -355,6 +387,9 @@
   void setGC(std::string Str);
   void clearGC();
 
+  /// Returns true if the function has ssp, sspstrong, or sspreq fn attrs.
+  bool hasStackProtectorFnAttr() const;
+
   /// adds the attribute to the list of attributes.
   void addAttribute(unsigned i, Attribute::AttrKind Kind);
 
@@ -432,14 +467,31 @@
   void addDereferenceableOrNullParamAttr(unsigned ArgNo, uint64_t Bytes);
 
   /// Extract the alignment for a call or parameter (0=unknown).
+  /// FIXME: Remove this function once transition to Align is over.
+  /// Use getParamAlign() instead.
   unsigned getParamAlignment(unsigned ArgNo) const {
+    if (const auto MA = getParamAlign(ArgNo))
+      return MA->value();
+    return 0;
+  }
+
+  MaybeAlign getParamAlign(unsigned ArgNo) const {
     return AttributeSets.getParamAlignment(ArgNo);
   }
 
   /// Extract the byval type for a parameter.
   Type *getParamByValType(unsigned ArgNo) const {
-    Type *Ty = AttributeSets.getParamByValType(ArgNo);
-    return Ty ? Ty : (arg_begin() + ArgNo)->getType()->getPointerElementType();
+    return AttributeSets.getParamByValType(ArgNo);
+  }
+
+  /// Extract the sret type for a parameter.
+  Type *getParamStructRetType(unsigned ArgNo) const {
+    return AttributeSets.getParamStructRetType(ArgNo);
+  }
+
+  /// Extract the byref type for a parameter.
+  Type *getParamByRefType(unsigned ArgNo) const {
+    return AttributeSets.getParamByRefType(ArgNo);
   }
 
   /// Extract the number of dereferenceable bytes for a call or
@@ -581,6 +633,17 @@
     addFnAttr(Attribute::NoRecurse);
   }
 
+  /// Determine if the function is required to make forward progress.
+  bool mustProgress() const {
+    return hasFnAttribute(Attribute::MustProgress) ||
+           hasFnAttribute(Attribute::WillReturn);
+  }
+  void setMustProgress() { addFnAttr(Attribute::MustProgress); }
+
+  /// Determine if the function will return.
+  bool willReturn() const { return hasFnAttribute(Attribute::WillReturn); }
+  void setWillReturn() { addFnAttr(Attribute::WillReturn); }
+
   /// True if the ABI mandates (or the user requested) that this
   /// function be in a unwind table.
   bool hasUWTable() const {
@@ -623,6 +686,10 @@
     return hasFnAttribute(Attribute::OptimizeForSize) || hasMinSize();
   }
 
+  /// Returns the denormal handling type for the default rounding mode of the
+  /// function.
+  DenormalMode getDenormalMode(const fltSemantics &FPType) const;
+
   /// copyAttributesFrom - copy all additional attributes (those not needed to
   /// create a Function) from the Function Src to this one.
   void copyAttributesFrom(const Function *Src);
@@ -710,6 +777,12 @@
     return Arguments + NumArgs;
   }
 
+  Argument* getArg(unsigned i) const {
+    assert (i < NumArgs && "getArg() out of range!");
+    CheckLazyArguments();
+    return Arguments + i;
+  }
+
   iterator_range<arg_iterator> args() {
     return make_range(arg_begin(), arg_end());
   }
@@ -763,6 +836,10 @@
   ///
   void viewCFG() const;
 
+  /// Extended form to print edge weights.
+  void viewCFG(bool ViewCFGOnly, const BlockFrequencyInfo *BFI,
+               const BranchProbabilityInfo *BPI) const;
+
   /// viewCFGOnly - This function is meant for use from the debugger.  It works
   /// just like viewCFG, but it does not include the contents of basic blocks
   /// into the nodes, just the label.  If you are only interested in the CFG
@@ -770,6 +847,10 @@
   ///
   void viewCFGOnly() const;
 
+  /// Extended form to print edge weights.
+  void viewCFGOnly(const BlockFrequencyInfo *BFI,
+                   const BranchProbabilityInfo *BPI) const;
+
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Value *V) {
     return V->getValueID() == Value::FunctionVal;
@@ -791,9 +872,11 @@
 
   /// hasAddressTaken - returns true if there are any uses of this function
   /// other than direct calls or invokes to it, or blockaddress expressions.
-  /// Optionally passes back an offending user for diagnostic purposes.
+  /// Optionally passes back an offending user for diagnostic purposes and
+  /// ignores callback uses.
   ///
-  bool hasAddressTaken(const User** = nullptr) const;
+  bool hasAddressTaken(const User ** = nullptr,
+                       bool IgnoreCallbackUses = false) const;
 
   /// isDefTriviallyDead - Return true if it is trivially safe to remove
   /// this function definition from the module (because it isn't externally
diff --git a/linux-x64/clang/include/llvm/IR/GetElementPtrTypeIterator.h b/linux-x64/clang/include/llvm/IR/GetElementPtrTypeIterator.h
index 9b257ab..6293305 100644
--- a/linux-x64/clang/include/llvm/IR/GetElementPtrTypeIterator.h
+++ b/linux-x64/clang/include/llvm/IR/GetElementPtrTypeIterator.h
@@ -75,9 +75,15 @@
 
     generic_gep_type_iterator& operator++() {   // Preincrement
       Type *Ty = getIndexedType();
-      if (auto *STy = dyn_cast<SequentialType>(Ty)) {
-        CurTy = STy->getElementType();
-        NumElements = STy->getNumElements();
+      if (auto *ATy = dyn_cast<ArrayType>(Ty)) {
+        CurTy = ATy->getElementType();
+        NumElements = ATy->getNumElements();
+      } else if (auto *VTy = dyn_cast<VectorType>(Ty)) {
+        CurTy = VTy->getElementType();
+        if (isa<ScalableVectorType>(VTy))
+          NumElements = Unbounded;
+        else
+          NumElements = cast<FixedVectorType>(VTy)->getNumElements();
       } else
         CurTy = dyn_cast<StructType>(Ty);
       ++OpIt;
diff --git a/linux-x64/clang/include/llvm/IR/GlobalAlias.h b/linux-x64/clang/include/llvm/IR/GlobalAlias.h
index 3cd4057..f2d9b96 100644
--- a/linux-x64/clang/include/llvm/IR/GlobalAlias.h
+++ b/linux-x64/clang/include/llvm/IR/GlobalAlias.h
@@ -58,10 +58,6 @@
   // Linkage, Type, Parent and AddressSpace taken from the Aliasee.
   static GlobalAlias *create(const Twine &Name, GlobalValue *Aliasee);
 
-  void copyAttributesFrom(const GlobalValue *Src) {
-    GlobalValue::copyAttributesFrom(Src);
-  }
-
   /// removeFromParent - This method unlinks 'this' from the containing module,
   /// but does not delete it.
   ///
diff --git a/linux-x64/clang/include/llvm/IR/GlobalIFunc.h b/linux-x64/clang/include/llvm/IR/GlobalIFunc.h
index bc0d3c0..0fdae91 100644
--- a/linux-x64/clang/include/llvm/IR/GlobalIFunc.h
+++ b/linux-x64/clang/include/llvm/IR/GlobalIFunc.h
@@ -46,10 +46,6 @@
                              LinkageTypes Linkage, const Twine &Name,
                              Constant *Resolver, Module *Parent);
 
-  void copyAttributesFrom(const GlobalIFunc *Src) {
-    GlobalValue::copyAttributesFrom(Src);
-  }
-
   /// This method unlinks 'this' from the containing module, but does not
   /// delete it.
   void removeFromParent();
diff --git a/linux-x64/clang/include/llvm/IR/GlobalIndirectSymbol.h b/linux-x64/clang/include/llvm/IR/GlobalIndirectSymbol.h
index 8bc3f90..d996237 100644
--- a/linux-x64/clang/include/llvm/IR/GlobalIndirectSymbol.h
+++ b/linux-x64/clang/include/llvm/IR/GlobalIndirectSymbol.h
@@ -42,6 +42,10 @@
   /// Provide fast operand accessors
   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Constant);
 
+  void copyAttributesFrom(const GlobalValue *Src) {
+    GlobalValue::copyAttributesFrom(Src);
+  }
+
   /// These methods set and retrieve indirect symbol.
   void setIndirectSymbol(Constant *Symbol) {
     setOperand(0, Symbol);
@@ -54,9 +58,7 @@
           static_cast<const GlobalIndirectSymbol *>(this)->getIndirectSymbol());
   }
 
-  const GlobalObject *getBaseObject() const {
-    return dyn_cast<GlobalObject>(getIndirectSymbol()->stripInBoundsOffsets());
-  }
+  const GlobalObject *getBaseObject() const;
   GlobalObject *getBaseObject() {
     return const_cast<GlobalObject *>(
               static_cast<const GlobalIndirectSymbol *>(this)->getBaseObject());
diff --git a/linux-x64/clang/include/llvm/IR/GlobalObject.h b/linux-x64/clang/include/llvm/IR/GlobalObject.h
index b8ab614..d01abdc 100644
--- a/linux-x64/clang/include/llvm/IR/GlobalObject.h
+++ b/linux-x64/clang/include/llvm/IR/GlobalObject.h
@@ -17,6 +17,7 @@
 #include "llvm/ADT/StringRef.h"
 #include "llvm/IR/GlobalValue.h"
 #include "llvm/IR/Value.h"
+#include "llvm/Support/Alignment.h"
 #include <string>
 #include <utility>
 
@@ -27,6 +28,20 @@
 class Metadata;
 
 class GlobalObject : public GlobalValue {
+public:
+  // VCallVisibility - values for visibility metadata attached to vtables. This
+  // describes the scope in which a virtual call could end up being dispatched
+  // through this vtable.
+  enum VCallVisibility {
+    // Type is potentially visible to external code.
+    VCallVisibilityPublic = 0,
+    // Type is only visible to code which will be in the current Module after
+    // LTO internalization.
+    VCallVisibilityLinkageUnit = 1,
+    // Type is only visible to code in the current Module.
+    VCallVisibilityTranslationUnit = 2,
+  };
+
 protected:
   GlobalObject(Type *Ty, ValueTy VTy, Use *Ops, unsigned NumOps,
                LinkageTypes Linkage, const Twine &Name,
@@ -39,7 +54,6 @@
   Comdat *ObjComdat;
   enum {
     LastAlignmentBit = 4,
-    HasMetadataHashEntryBit,
     HasSectionHashEntryBit,
 
     GlobalObjectBits,
@@ -55,12 +69,23 @@
 public:
   GlobalObject(const GlobalObject &) = delete;
 
+  /// FIXME: Remove this function once transition to Align is over.
   unsigned getAlignment() const {
+    MaybeAlign Align = getAlign();
+    return Align ? Align->value() : 0;
+  }
+
+  /// Returns the alignment of the given variable or function.
+  ///
+  /// Note that for functions this is the alignment of the code, not the
+  /// alignment of a function pointer.
+  MaybeAlign getAlign() const {
     unsigned Data = getGlobalValueSubClassData();
     unsigned AlignmentData = Data & AlignmentMask;
-    return (1u << AlignmentData) >> 1;
+    return decodeMaybeAlign(AlignmentData);
   }
-  void setAlignment(unsigned Align);
+
+  void setAlignment(MaybeAlign Align);
 
   unsigned getGlobalObjectSubClassData() const {
     unsigned ValueData = getGlobalValueSubClassData();
@@ -101,63 +126,27 @@
   Comdat *getComdat() { return ObjComdat; }
   void setComdat(Comdat *C) { ObjComdat = C; }
 
-  /// Check if this has any metadata.
-  bool hasMetadata() const { return hasMetadataHashEntry(); }
-
-  /// Check if this has any metadata of the given kind.
-  bool hasMetadata(unsigned KindID) const {
-    return getMetadata(KindID) != nullptr;
-  }
-  bool hasMetadata(StringRef Kind) const {
-    return getMetadata(Kind) != nullptr;
-  }
-
-  /// Get the current metadata attachments for the given kind, if any.
-  ///
-  /// These functions require that the function have at most a single attachment
-  /// of the given kind, and return \c nullptr if such an attachment is missing.
-  /// @{
-  MDNode *getMetadata(unsigned KindID) const;
-  MDNode *getMetadata(StringRef Kind) const;
-  /// @}
-
-  /// Appends all attachments with the given ID to \c MDs in insertion order.
-  /// If the global has no attachments with the given ID, or if ID is invalid,
-  /// leaves MDs unchanged.
-  /// @{
-  void getMetadata(unsigned KindID, SmallVectorImpl<MDNode *> &MDs) const;
-  void getMetadata(StringRef Kind, SmallVectorImpl<MDNode *> &MDs) const;
-  /// @}
-
-  /// Set a particular kind of metadata attachment.
-  ///
-  /// Sets the given attachment to \c MD, erasing it if \c MD is \c nullptr or
-  /// replacing it if it already exists.
-  /// @{
-  void setMetadata(unsigned KindID, MDNode *MD);
-  void setMetadata(StringRef Kind, MDNode *MD);
-  /// @}
-
-  /// Add a metadata attachment.
-  /// @{
-  void addMetadata(unsigned KindID, MDNode &MD);
-  void addMetadata(StringRef Kind, MDNode &MD);
-  /// @}
-
-  /// Appends all attachments for the global to \c MDs, sorting by attachment
-  /// ID. Attachments with the same ID appear in insertion order.
-  void
-  getAllMetadata(SmallVectorImpl<std::pair<unsigned, MDNode *>> &MDs) const;
-
-  /// Erase all metadata attachments with the given kind.
-  ///
-  /// \returns true if any metadata was removed.
-  bool eraseMetadata(unsigned KindID);
+  using Value::addMetadata;
+  using Value::clearMetadata;
+  using Value::eraseMetadata;
+  using Value::getAllMetadata;
+  using Value::getMetadata;
+  using Value::hasMetadata;
+  using Value::setMetadata;
 
   /// Copy metadata from Src, adjusting offsets by Offset.
   void copyMetadata(const GlobalObject *Src, unsigned Offset);
 
   void addTypeMetadata(unsigned Offset, Metadata *TypeID);
+  void setVCallVisibilityMetadata(VCallVisibility Visibility);
+  VCallVisibility getVCallVisibility() const;
+
+  /// Returns true if the alignment of the value can be unilaterally
+  /// increased.
+  ///
+  /// Note that for functions this is the alignment of the code, not the
+  /// alignment of a function pointer.
+  bool canIncreaseAlignment() const;
 
 protected:
   void copyAttributesFrom(const GlobalObject *Src);
@@ -169,8 +158,6 @@
            V->getValueID() == Value::GlobalVariableVal;
   }
 
-  void clearMetadata();
-
 private:
   void setGlobalObjectFlag(unsigned Bit, bool Val) {
     unsigned Mask = 1 << Bit;
@@ -178,13 +165,6 @@
                                (Val ? Mask : 0u));
   }
 
-  bool hasMetadataHashEntry() const {
-    return getGlobalValueSubClassData() & (1 << HasMetadataHashEntryBit);
-  }
-  void setHasMetadataHashEntry(bool HasEntry) {
-    setGlobalObjectFlag(HasMetadataHashEntryBit, HasEntry);
-  }
-
   StringRef getSectionImpl() const;
 };
 
diff --git a/linux-x64/clang/include/llvm/IR/GlobalValue.h b/linux-x64/clang/include/llvm/IR/GlobalValue.h
index 2209881..cf704d1 100644
--- a/linux-x64/clang/include/llvm/IR/GlobalValue.h
+++ b/linux-x64/clang/include/llvm/IR/GlobalValue.h
@@ -38,7 +38,7 @@
 class Module;
 
 namespace Intrinsic {
-  enum ID : unsigned;
+typedef unsigned ID;
 } // end namespace Intrinsic
 
 class GlobalValue : public Constant {
@@ -146,12 +146,6 @@
     llvm_unreachable("Fully covered switch above!");
   }
 
-  void maybeSetDsoLocal() {
-    if (hasLocalLinkage() ||
-        (!hasDefaultVisibility() && !hasExternalWeakLinkage()))
-      setDSOLocal(true);
-  }
-
 protected:
   /// The intrinsic ID for this subclass (which must be a Function).
   ///
@@ -191,7 +185,6 @@
 
   GlobalValue(const GlobalValue &) = delete;
 
-  unsigned getAlignment() const;
   unsigned getAddressSpace() const;
 
   enum class UnnamedAddr {
@@ -243,7 +236,8 @@
     assert((!hasLocalLinkage() || V == DefaultVisibility) &&
            "local linkage requires default visibility");
     Visibility = V;
-    maybeSetDsoLocal();
+    if (isImplicitDSOLocal())
+      setDSOLocal(true);
   }
 
   /// If the value is "Thread Local", its value isn't shared by the threads.
@@ -278,6 +272,11 @@
 
   Type *getValueType() const { return ValueType; }
 
+  bool isImplicitDSOLocal() const {
+    return hasLocalLinkage() ||
+           (!hasDefaultVisibility() && !hasExternalWeakLinkage());
+  }
+
   void setDSOLocal(bool Local) { IsDSOLocal = Local; }
 
   bool isDSOLocal() const {
@@ -423,10 +422,11 @@
   }
 
   /// Return true if this global's definition can be substituted with an
-  /// *arbitrary* definition at link time.  We cannot do any IPO or inlinining
-  /// across interposable call edges, since the callee can be replaced with
-  /// something arbitrary at link time.
-  bool isInterposable() const { return isInterposableLinkage(getLinkage()); }
+  /// *arbitrary* definition at link time or load time. We cannot do any IPO or
+  /// inlining across interposable call edges, since the callee can be
+  /// replaced with something arbitrary.
+  bool isInterposable() const;
+  bool canBenefitFromLocalAlias() const;
 
   bool hasExternalLinkage() const { return isExternalLinkage(getLinkage()); }
   bool hasAvailableExternallyLinkage() const {
@@ -455,7 +455,8 @@
     if (isLocalLinkage(LT))
       Visibility = DefaultVisibility;
     Linkage = LT;
-    maybeSetDsoLocal();
+    if (isImplicitDSOLocal())
+      setDSOLocal(true);
   }
   LinkageTypes getLinkage() const { return LinkageTypes(Linkage); }
 
@@ -547,10 +548,6 @@
     return !(isDeclarationForLinker() || isWeakForLinker());
   }
 
-  // Returns true if the alignment of the value can be unilaterally
-  // increased.
-  bool canIncreaseAlignment() const;
-
   const GlobalObject *getBaseObject() const;
   GlobalObject *getBaseObject() {
     return const_cast<GlobalObject *>(
diff --git a/linux-x64/clang/include/llvm/IR/GlobalVariable.h b/linux-x64/clang/include/llvm/IR/GlobalVariable.h
index 2e2c8c4..674d49e 100644
--- a/linux-x64/clang/include/llvm/IR/GlobalVariable.h
+++ b/linux-x64/clang/include/llvm/IR/GlobalVariable.h
@@ -19,7 +19,6 @@
 #ifndef LLVM_IR_GLOBALVARIABLE_H
 #define LLVM_IR_GLOBALVARIABLE_H
 
-#include "llvm/ADT/PointerUnion.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/ADT/ilist_node.h"
 #include "llvm/IR/Attributes.h"
@@ -57,10 +56,11 @@
                  bool isExternallyInitialized = false);
   /// GlobalVariable ctor - This creates a global and inserts it before the
   /// specified other global.
-  GlobalVariable(Module &M, Type *Ty, bool isConstant,
-                 LinkageTypes Linkage, Constant *Initializer,
-                 const Twine &Name = "", GlobalVariable *InsertBefore = nullptr,
-                 ThreadLocalMode = NotThreadLocal, unsigned AddressSpace = 0,
+  GlobalVariable(Module &M, Type *Ty, bool isConstant, LinkageTypes Linkage,
+                 Constant *Initializer, const Twine &Name = "",
+                 GlobalVariable *InsertBefore = nullptr,
+                 ThreadLocalMode = NotThreadLocal,
+                 Optional<unsigned> AddressSpace = None,
                  bool isExternallyInitialized = false);
   GlobalVariable(const GlobalVariable &) = delete;
   GlobalVariable &operator=(const GlobalVariable &) = delete;
@@ -243,6 +243,7 @@
   bool hasImplicitSection() const {
     return getAttributes().hasAttribute("bss-section") ||
            getAttributes().hasAttribute("data-section") ||
+           getAttributes().hasAttribute("relro-section") ||
            getAttributes().hasAttribute("rodata-section");
   }
 
diff --git a/linux-x64/clang/include/llvm/IR/IRBuilder.h b/linux-x64/clang/include/llvm/IR/IRBuilder.h
index a74364d..c9074ab 100644
--- a/linux-x64/clang/include/llvm/IR/IRBuilder.h
+++ b/linux-x64/clang/include/llvm/IR/IRBuilder.h
@@ -17,6 +17,7 @@
 #include "llvm-c/Types.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/None.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/IR/BasicBlock.h"
@@ -24,6 +25,7 @@
 #include "llvm/IR/ConstantFolder.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DataLayout.h"
+#include "llvm/IR/DebugInfoMetadata.h"
 #include "llvm/IR/DebugLoc.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Function.h"
@@ -59,9 +61,12 @@
 ///
 /// By default, this inserts the instruction at the insertion point.
 class IRBuilderDefaultInserter {
-protected:
-  void InsertHelper(Instruction *I, const Twine &Name,
-                    BasicBlock *BB, BasicBlock::iterator InsertPt) const {
+public:
+  virtual ~IRBuilderDefaultInserter();
+
+  virtual void InsertHelper(Instruction *I, const Twine &Name,
+                            BasicBlock *BB,
+                            BasicBlock::iterator InsertPt) const {
     if (BB) BB->getInstList().insert(InsertPt, I);
     I->setName(Name);
   }
@@ -69,16 +74,18 @@
 
 /// Provides an 'InsertHelper' that calls a user-provided callback after
 /// performing the default insertion.
-class IRBuilderCallbackInserter : IRBuilderDefaultInserter {
+class IRBuilderCallbackInserter : public IRBuilderDefaultInserter {
   std::function<void(Instruction *)> Callback;
 
 public:
+  virtual ~IRBuilderCallbackInserter();
+
   IRBuilderCallbackInserter(std::function<void(Instruction *)> Callback)
       : Callback(std::move(Callback)) {}
 
-protected:
   void InsertHelper(Instruction *I, const Twine &Name,
-                    BasicBlock *BB, BasicBlock::iterator InsertPt) const {
+                    BasicBlock *BB,
+                    BasicBlock::iterator InsertPt) const override {
     IRBuilderDefaultInserter::InsertHelper(I, Name, BB, InsertPt);
     Callback(I);
   }
@@ -86,32 +93,77 @@
 
 /// Common base class shared among various IRBuilders.
 class IRBuilderBase {
-  DebugLoc CurDbgLocation;
+  /// Pairs of (metadata kind, MDNode *) that should be added to all newly
+  /// created instructions, like !dbg metadata.
+  SmallVector<std::pair<unsigned, MDNode *>, 2> MetadataToCopy;
+
+  /// Add or update the an entry (Kind, MD) to MetadataToCopy, if \p MD is not
+  /// null. If \p MD is null, remove the entry with \p Kind.
+  void AddOrRemoveMetadataToCopy(unsigned Kind, MDNode *MD) {
+    if (!MD) {
+      erase_if(MetadataToCopy, [Kind](const std::pair<unsigned, MDNode *> &KV) {
+        return KV.first == Kind;
+      });
+      return;
+    }
+
+    for (auto &KV : MetadataToCopy)
+      if (KV.first == Kind) {
+        KV.second = MD;
+        return;
+      }
+
+    MetadataToCopy.emplace_back(Kind, MD);
+  }
 
 protected:
   BasicBlock *BB;
   BasicBlock::iterator InsertPt;
   LLVMContext &Context;
+  const IRBuilderFolder &Folder;
+  const IRBuilderDefaultInserter &Inserter;
 
   MDNode *DefaultFPMathTag;
   FastMathFlags FMF;
 
   bool IsFPConstrained;
-  ConstrainedFPIntrinsic::ExceptionBehavior DefaultConstrainedExcept;
-  ConstrainedFPIntrinsic::RoundingMode DefaultConstrainedRounding;
+  fp::ExceptionBehavior DefaultConstrainedExcept;
+  RoundingMode DefaultConstrainedRounding;
 
   ArrayRef<OperandBundleDef> DefaultOperandBundles;
 
 public:
-  IRBuilderBase(LLVMContext &context, MDNode *FPMathTag = nullptr,
-                ArrayRef<OperandBundleDef> OpBundles = None)
-      : Context(context), DefaultFPMathTag(FPMathTag), IsFPConstrained(false),
-        DefaultConstrainedExcept(ConstrainedFPIntrinsic::ebStrict),
-        DefaultConstrainedRounding(ConstrainedFPIntrinsic::rmDynamic),
+  IRBuilderBase(LLVMContext &context, const IRBuilderFolder &Folder,
+                const IRBuilderDefaultInserter &Inserter,
+                MDNode *FPMathTag, ArrayRef<OperandBundleDef> OpBundles)
+      : Context(context), Folder(Folder), Inserter(Inserter),
+        DefaultFPMathTag(FPMathTag), IsFPConstrained(false),
+        DefaultConstrainedExcept(fp::ebStrict),
+        DefaultConstrainedRounding(RoundingMode::Dynamic),
         DefaultOperandBundles(OpBundles) {
     ClearInsertionPoint();
   }
 
+  /// Insert and return the specified instruction.
+  template<typename InstTy>
+  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
+    Inserter.InsertHelper(I, Name, BB, InsertPt);
+    AddMetadataToInst(I);
+    return I;
+  }
+
+  /// No-op overload to handle constants.
+  Constant *Insert(Constant *C, const Twine& = "") const {
+    return C;
+  }
+
+  Value *Insert(Value *V, const Twine &Name = "") const {
+    if (Instruction *I = dyn_cast<Instruction>(V))
+      return Insert(I, Name);
+    assert(isa<Constant>(V));
+    return V;
+  }
+
   //===--------------------------------------------------------------------===//
   // Builder configuration methods
   //===--------------------------------------------------------------------===//
@@ -153,16 +205,42 @@
   }
 
   /// Set location information used by debugging information.
-  void SetCurrentDebugLocation(DebugLoc L) { CurDbgLocation = std::move(L); }
+  void SetCurrentDebugLocation(DebugLoc L) {
+    AddOrRemoveMetadataToCopy(LLVMContext::MD_dbg, L.getAsMDNode());
+  }
+
+  /// Collect metadata with IDs \p MetadataKinds from \p Src which should be
+  /// added to all created instructions. Entries present in MedataDataToCopy but
+  /// not on \p Src will be dropped from MetadataToCopy.
+  void CollectMetadataToCopy(Instruction *Src,
+                             ArrayRef<unsigned> MetadataKinds) {
+    for (unsigned K : MetadataKinds)
+      AddOrRemoveMetadataToCopy(K, Src->getMetadata(K));
+  }
 
   /// Get location information used by debugging information.
-  const DebugLoc &getCurrentDebugLocation() const { return CurDbgLocation; }
+  DebugLoc getCurrentDebugLocation() const {
+    for (auto &KV : MetadataToCopy)
+      if (KV.first == LLVMContext::MD_dbg)
+        return {cast<DILocation>(KV.second)};
+
+    return {};
+  }
 
   /// If this builder has a current debug location, set it on the
   /// specified instruction.
   void SetInstDebugLocation(Instruction *I) const {
-    if (CurDbgLocation)
-      I->setDebugLoc(CurDbgLocation);
+    for (const auto &KV : MetadataToCopy)
+      if (KV.first == LLVMContext::MD_dbg) {
+        I->setDebugLoc(DebugLoc(KV.second));
+        return;
+      }
+  }
+
+  /// Add all entries in MetadataToCopy to \p I.
+  void AddMetadataToInst(Instruction *I) const {
+    for (auto &KV : MetadataToCopy)
+      I->setMetadata(KV.first, KV.second);
   }
 
   /// Get the return type of the current function that we're emitting
@@ -215,6 +293,8 @@
   /// Get the flags to be applied to created floating point ops
   FastMathFlags getFastMathFlags() const { return FMF; }
 
+  FastMathFlags &getFastMathFlags() { return FMF; }
+
   /// Clear the fast-math flags.
   void clearFastMathFlags() { FMF.clear(); }
 
@@ -234,27 +314,50 @@
   bool getIsFPConstrained() { return IsFPConstrained; }
 
   /// Set the exception handling to be used with constrained floating point
-  void setDefaultConstrainedExcept(
-      ConstrainedFPIntrinsic::ExceptionBehavior NewExcept) {
+  void setDefaultConstrainedExcept(fp::ExceptionBehavior NewExcept) {
+#ifndef NDEBUG
+    Optional<StringRef> ExceptStr = ExceptionBehaviorToStr(NewExcept);
+    assert(ExceptStr.hasValue() && "Garbage strict exception behavior!");
+#endif
     DefaultConstrainedExcept = NewExcept;
   }
 
   /// Set the rounding mode handling to be used with constrained floating point
-  void setDefaultConstrainedRounding(
-      ConstrainedFPIntrinsic::RoundingMode NewRounding) {
+  void setDefaultConstrainedRounding(RoundingMode NewRounding) {
+#ifndef NDEBUG
+    Optional<StringRef> RoundingStr = RoundingModeToStr(NewRounding);
+    assert(RoundingStr.hasValue() && "Garbage strict rounding mode!");
+#endif
     DefaultConstrainedRounding = NewRounding;
   }
 
   /// Get the exception handling used with constrained floating point
-  ConstrainedFPIntrinsic::ExceptionBehavior getDefaultConstrainedExcept() {
+  fp::ExceptionBehavior getDefaultConstrainedExcept() {
     return DefaultConstrainedExcept;
   }
 
   /// Get the rounding mode handling used with constrained floating point
-  ConstrainedFPIntrinsic::RoundingMode getDefaultConstrainedRounding() {
+  RoundingMode getDefaultConstrainedRounding() {
     return DefaultConstrainedRounding;
   }
 
+  void setConstrainedFPFunctionAttr() {
+    assert(BB && "Must have a basic block to set any function attributes!");
+
+    Function *F = BB->getParent();
+    if (!F->hasFnAttribute(Attribute::StrictFP)) {
+      F->addFnAttr(Attribute::StrictFP);
+    }
+  }
+
+  void setConstrainedFPCallAttr(CallBase *I) {
+    I->addAttribute(AttributeList::FunctionIndex, Attribute::StrictFP);
+  }
+
+  void setDefaultOperandBundles(ArrayRef<OperandBundleDef> OpBundles) {
+    DefaultOperandBundles = OpBundles;
+  }
+
   //===--------------------------------------------------------------------===//
   // RAII helpers.
   //===--------------------------------------------------------------------===//
@@ -287,10 +390,16 @@
     IRBuilderBase &Builder;
     FastMathFlags FMF;
     MDNode *FPMathTag;
+    bool IsFPConstrained;
+    fp::ExceptionBehavior DefaultConstrainedExcept;
+    RoundingMode DefaultConstrainedRounding;
 
   public:
     FastMathFlagGuard(IRBuilderBase &B)
-        : Builder(B), FMF(B.FMF), FPMathTag(B.DefaultFPMathTag) {}
+        : Builder(B), FMF(B.FMF), FPMathTag(B.DefaultFPMathTag),
+          IsFPConstrained(B.IsFPConstrained),
+          DefaultConstrainedExcept(B.DefaultConstrainedExcept),
+          DefaultConstrainedRounding(B.DefaultConstrainedRounding) {}
 
     FastMathFlagGuard(const FastMathFlagGuard &) = delete;
     FastMathFlagGuard &operator=(const FastMathFlagGuard &) = delete;
@@ -298,9 +407,31 @@
     ~FastMathFlagGuard() {
       Builder.FMF = FMF;
       Builder.DefaultFPMathTag = FPMathTag;
+      Builder.IsFPConstrained = IsFPConstrained;
+      Builder.DefaultConstrainedExcept = DefaultConstrainedExcept;
+      Builder.DefaultConstrainedRounding = DefaultConstrainedRounding;
     }
   };
 
+  // RAII object that stores the current default operand bundles and restores
+  // them when the object is destroyed.
+  class OperandBundlesGuard {
+    IRBuilderBase &Builder;
+    ArrayRef<OperandBundleDef> DefaultOperandBundles;
+
+  public:
+    OperandBundlesGuard(IRBuilderBase &B)
+        : Builder(B), DefaultOperandBundles(B.DefaultOperandBundles) {}
+
+    OperandBundlesGuard(const OperandBundlesGuard &) = delete;
+    OperandBundlesGuard &operator=(const OperandBundlesGuard &) = delete;
+
+    ~OperandBundlesGuard() {
+      Builder.DefaultOperandBundles = DefaultOperandBundles;
+    }
+  };
+
+
   //===--------------------------------------------------------------------===//
   // Miscellaneous creation methods.
   //===--------------------------------------------------------------------===//
@@ -311,8 +442,12 @@
   /// filled in with the null terminated string value specified.  The new global
   /// variable will be marked mergable with any others of the same contents.  If
   /// Name is specified, it is the name of the global variable created.
+  ///
+  /// If no module is given via \p M, it is take from the insertion point basic
+  /// block.
   GlobalVariable *CreateGlobalString(StringRef Str, const Twine &Name = "",
-                                     unsigned AddressSpace = 0);
+                                     unsigned AddressSpace = 0,
+                                     Module *M = nullptr);
 
   /// Get a constant value representing either true or false.
   ConstantInt *getInt1(bool V) {
@@ -402,6 +537,11 @@
     return Type::getHalfTy(Context);
   }
 
+  /// Fetch the type representing a 16-bit brain floating point value.
+  Type *getBFloatTy() {
+    return Type::getBFloatTy(Context);
+  }
+
   /// Fetch the type representing a 32-bit floating point value.
   Type *getFloatTy() {
     return Type::getFloatTy(Context);
@@ -437,15 +577,15 @@
   /// If the pointer isn't an i8*, it will be converted. If a TBAA tag is
   /// specified, it will be added to the instruction. Likewise with alias.scope
   /// and noalias tags.
-  CallInst *CreateMemSet(Value *Ptr, Value *Val, uint64_t Size, unsigned Align,
-                         bool isVolatile = false, MDNode *TBAATag = nullptr,
-                         MDNode *ScopeTag = nullptr,
+  CallInst *CreateMemSet(Value *Ptr, Value *Val, uint64_t Size,
+                         MaybeAlign Align, bool isVolatile = false,
+                         MDNode *TBAATag = nullptr, MDNode *ScopeTag = nullptr,
                          MDNode *NoAliasTag = nullptr) {
     return CreateMemSet(Ptr, Val, getInt64(Size), Align, isVolatile,
                         TBAATag, ScopeTag, NoAliasTag);
   }
 
-  CallInst *CreateMemSet(Value *Ptr, Value *Val, Value *Size, unsigned Align,
+  CallInst *CreateMemSet(Value *Ptr, Value *Val, Value *Size, MaybeAlign Align,
                          bool isVolatile = false, MDNode *TBAATag = nullptr,
                          MDNode *ScopeTag = nullptr,
                          MDNode *NoAliasTag = nullptr);
@@ -457,18 +597,18 @@
   /// specified, it will be added to the instruction. Likewise with alias.scope
   /// and noalias tags.
   CallInst *CreateElementUnorderedAtomicMemSet(Value *Ptr, Value *Val,
-                                               uint64_t Size, unsigned Align,
+                                               uint64_t Size, Align Alignment,
                                                uint32_t ElementSize,
                                                MDNode *TBAATag = nullptr,
                                                MDNode *ScopeTag = nullptr,
                                                MDNode *NoAliasTag = nullptr) {
-    return CreateElementUnorderedAtomicMemSet(Ptr, Val, getInt64(Size), Align,
-                                              ElementSize, TBAATag, ScopeTag,
-                                              NoAliasTag);
+    return CreateElementUnorderedAtomicMemSet(Ptr, Val, getInt64(Size),
+                                              Align(Alignment), ElementSize,
+                                              TBAATag, ScopeTag, NoAliasTag);
   }
 
   CallInst *CreateElementUnorderedAtomicMemSet(Value *Ptr, Value *Val,
-                                               Value *Size, unsigned Align,
+                                               Value *Size, Align Alignment,
                                                uint32_t ElementSize,
                                                MDNode *TBAATag = nullptr,
                                                MDNode *ScopeTag = nullptr,
@@ -479,8 +619,8 @@
   /// If the pointers aren't i8*, they will be converted.  If a TBAA tag is
   /// specified, it will be added to the instruction. Likewise with alias.scope
   /// and noalias tags.
-  CallInst *CreateMemCpy(Value *Dst, unsigned DstAlign, Value *Src,
-                         unsigned SrcAlign, uint64_t Size,
+  CallInst *CreateMemCpy(Value *Dst, MaybeAlign DstAlign, Value *Src,
+                         MaybeAlign SrcAlign, uint64_t Size,
                          bool isVolatile = false, MDNode *TBAATag = nullptr,
                          MDNode *TBAAStructTag = nullptr,
                          MDNode *ScopeTag = nullptr,
@@ -490,12 +630,25 @@
                         NoAliasTag);
   }
 
-  CallInst *CreateMemCpy(Value *Dst, unsigned DstAlign, Value *Src,
-                         unsigned SrcAlign, Value *Size,
+  CallInst *CreateMemTransferInst(
+      Intrinsic::ID IntrID, Value *Dst, MaybeAlign DstAlign, Value *Src,
+      MaybeAlign SrcAlign, Value *Size, bool isVolatile = false,
+      MDNode *TBAATag = nullptr, MDNode *TBAAStructTag = nullptr,
+      MDNode *ScopeTag = nullptr, MDNode *NoAliasTag = nullptr);
+
+  CallInst *CreateMemCpy(Value *Dst, MaybeAlign DstAlign, Value *Src,
+                         MaybeAlign SrcAlign, Value *Size,
                          bool isVolatile = false, MDNode *TBAATag = nullptr,
                          MDNode *TBAAStructTag = nullptr,
                          MDNode *ScopeTag = nullptr,
-                         MDNode *NoAliasTag = nullptr);
+                         MDNode *NoAliasTag = nullptr) {
+    return CreateMemTransferInst(Intrinsic::memcpy, Dst, DstAlign, Src,
+                                 SrcAlign, Size, isVolatile, TBAATag,
+                                 TBAAStructTag, ScopeTag, NoAliasTag);
+  }
+
+  CallInst *CreateMemCpyInline(Value *Dst, MaybeAlign DstAlign, Value *Src,
+                               MaybeAlign SrcAlign, Value *Size);
 
   /// Create and insert an element unordered-atomic memcpy between the
   /// specified pointers.
@@ -506,37 +659,49 @@
   /// specified, it will be added to the instruction. Likewise with alias.scope
   /// and noalias tags.
   CallInst *CreateElementUnorderedAtomicMemCpy(
-      Value *Dst, unsigned DstAlign, Value *Src, unsigned SrcAlign,
-      uint64_t Size, uint32_t ElementSize, MDNode *TBAATag = nullptr,
-      MDNode *TBAAStructTag = nullptr, MDNode *ScopeTag = nullptr,
-      MDNode *NoAliasTag = nullptr) {
-    return CreateElementUnorderedAtomicMemCpy(
-        Dst, DstAlign, Src, SrcAlign, getInt64(Size), ElementSize, TBAATag,
-        TBAAStructTag, ScopeTag, NoAliasTag);
-  }
-
-  CallInst *CreateElementUnorderedAtomicMemCpy(
-      Value *Dst, unsigned DstAlign, Value *Src, unsigned SrcAlign, Value *Size,
+      Value *Dst, Align DstAlign, Value *Src, Align SrcAlign, Value *Size,
       uint32_t ElementSize, MDNode *TBAATag = nullptr,
       MDNode *TBAAStructTag = nullptr, MDNode *ScopeTag = nullptr,
       MDNode *NoAliasTag = nullptr);
 
-  /// Create and insert a memmove between the specified
-  /// pointers.
-  ///
-  /// If the pointers aren't i8*, they will be converted.  If a TBAA tag is
-  /// specified, it will be added to the instruction. Likewise with alias.scope
-  /// and noalias tags.
-  CallInst *CreateMemMove(Value *Dst, unsigned DstAlign, Value *Src, unsigned SrcAlign,
-                          uint64_t Size, bool isVolatile = false,
-                          MDNode *TBAATag = nullptr, MDNode *ScopeTag = nullptr,
-                          MDNode *NoAliasTag = nullptr) {
-    return CreateMemMove(Dst, DstAlign, Src, SrcAlign, getInt64(Size), isVolatile,
-                         TBAATag, ScopeTag, NoAliasTag);
+  LLVM_ATTRIBUTE_DEPRECATED(CallInst *CreateElementUnorderedAtomicMemCpy(
+                                Value *Dst, unsigned DstAlign, Value *Src,
+                                unsigned SrcAlign, uint64_t Size,
+                                uint32_t ElementSize, MDNode *TBAATag = nullptr,
+                                MDNode *TBAAStructTag = nullptr,
+                                MDNode *ScopeTag = nullptr,
+                                MDNode *NoAliasTag = nullptr),
+                            "Use the version that takes Align instead") {
+    return CreateElementUnorderedAtomicMemCpy(
+        Dst, Align(DstAlign), Src, Align(SrcAlign), getInt64(Size), ElementSize,
+        TBAATag, TBAAStructTag, ScopeTag, NoAliasTag);
   }
 
-  CallInst *CreateMemMove(Value *Dst, unsigned DstAlign, Value *Src, unsigned SrcAlign,
-                          Value *Size, bool isVolatile = false, MDNode *TBAATag = nullptr,
+  LLVM_ATTRIBUTE_DEPRECATED(CallInst *CreateElementUnorderedAtomicMemCpy(
+                                Value *Dst, unsigned DstAlign, Value *Src,
+                                unsigned SrcAlign, Value *Size,
+                                uint32_t ElementSize, MDNode *TBAATag = nullptr,
+                                MDNode *TBAAStructTag = nullptr,
+                                MDNode *ScopeTag = nullptr,
+                                MDNode *NoAliasTag = nullptr),
+                            "Use the version that takes Align instead") {
+    return CreateElementUnorderedAtomicMemCpy(
+        Dst, Align(DstAlign), Src, Align(SrcAlign), Size, ElementSize, TBAATag,
+        TBAAStructTag, ScopeTag, NoAliasTag);
+  }
+
+  CallInst *CreateMemMove(Value *Dst, MaybeAlign DstAlign, Value *Src,
+                          MaybeAlign SrcAlign, uint64_t Size,
+                          bool isVolatile = false, MDNode *TBAATag = nullptr,
+                          MDNode *ScopeTag = nullptr,
+                          MDNode *NoAliasTag = nullptr) {
+    return CreateMemMove(Dst, DstAlign, Src, SrcAlign, getInt64(Size),
+                         isVolatile, TBAATag, ScopeTag, NoAliasTag);
+  }
+
+  CallInst *CreateMemMove(Value *Dst, MaybeAlign DstAlign, Value *Src,
+                          MaybeAlign SrcAlign, Value *Size,
+                          bool isVolatile = false, MDNode *TBAATag = nullptr,
                           MDNode *ScopeTag = nullptr,
                           MDNode *NoAliasTag = nullptr);
 
@@ -550,21 +715,37 @@
   /// specified, it will be added to the instruction. Likewise with alias.scope
   /// and noalias tags.
   CallInst *CreateElementUnorderedAtomicMemMove(
-      Value *Dst, unsigned DstAlign, Value *Src, unsigned SrcAlign,
-      uint64_t Size, uint32_t ElementSize, MDNode *TBAATag = nullptr,
-      MDNode *TBAAStructTag = nullptr, MDNode *ScopeTag = nullptr,
-      MDNode *NoAliasTag = nullptr) {
-    return CreateElementUnorderedAtomicMemMove(
-        Dst, DstAlign, Src, SrcAlign, getInt64(Size), ElementSize, TBAATag,
-        TBAAStructTag, ScopeTag, NoAliasTag);
-  }
-
-  CallInst *CreateElementUnorderedAtomicMemMove(
-      Value *Dst, unsigned DstAlign, Value *Src, unsigned SrcAlign, Value *Size,
+      Value *Dst, Align DstAlign, Value *Src, Align SrcAlign, Value *Size,
       uint32_t ElementSize, MDNode *TBAATag = nullptr,
       MDNode *TBAAStructTag = nullptr, MDNode *ScopeTag = nullptr,
       MDNode *NoAliasTag = nullptr);
 
+  LLVM_ATTRIBUTE_DEPRECATED(CallInst *CreateElementUnorderedAtomicMemMove(
+                                Value *Dst, unsigned DstAlign, Value *Src,
+                                unsigned SrcAlign, uint64_t Size,
+                                uint32_t ElementSize, MDNode *TBAATag = nullptr,
+                                MDNode *TBAAStructTag = nullptr,
+                                MDNode *ScopeTag = nullptr,
+                                MDNode *NoAliasTag = nullptr),
+                            "Use the version that takes Align instead") {
+    return CreateElementUnorderedAtomicMemMove(
+        Dst, Align(DstAlign), Src, Align(SrcAlign), getInt64(Size), ElementSize,
+        TBAATag, TBAAStructTag, ScopeTag, NoAliasTag);
+  }
+
+  LLVM_ATTRIBUTE_DEPRECATED(CallInst *CreateElementUnorderedAtomicMemMove(
+                                Value *Dst, unsigned DstAlign, Value *Src,
+                                unsigned SrcAlign, Value *Size,
+                                uint32_t ElementSize, MDNode *TBAATag = nullptr,
+                                MDNode *TBAAStructTag = nullptr,
+                                MDNode *ScopeTag = nullptr,
+                                MDNode *NoAliasTag = nullptr),
+                            "Use the version that takes Align instead") {
+    return CreateElementUnorderedAtomicMemMove(
+        Dst, Align(DstAlign), Src, Align(SrcAlign), Size, ElementSize, TBAATag,
+        TBAAStructTag, ScopeTag, NoAliasTag);
+  }
+
   /// Create a vector fadd reduction intrinsic of the source vector.
   /// The first parameter is a scalar accumulator value for ordered reductions.
   CallInst *CreateFAddReduce(Value *Acc, Value *Src);
@@ -598,11 +779,11 @@
 
   /// Create a vector float max reduction intrinsic of the source
   /// vector.
-  CallInst *CreateFPMaxReduce(Value *Src, bool NoNaN = false);
+  CallInst *CreateFPMaxReduce(Value *Src);
 
   /// Create a vector float min reduction intrinsic of the source
   /// vector.
-  CallInst *CreateFPMinReduce(Value *Src, bool NoNaN = false);
+  CallInst *CreateFPMinReduce(Value *Src);
 
   /// Create a lifetime.start intrinsic.
   ///
@@ -620,33 +801,69 @@
   CallInst *CreateInvariantStart(Value *Ptr, ConstantInt *Size = nullptr);
 
   /// Create a call to Masked Load intrinsic
-  CallInst *CreateMaskedLoad(Value *Ptr, unsigned Align, Value *Mask,
+  LLVM_ATTRIBUTE_DEPRECATED(
+      CallInst *CreateMaskedLoad(Value *Ptr, unsigned Alignment, Value *Mask,
+                                 Value *PassThru = nullptr,
+                                 const Twine &Name = ""),
+      "Use the version that takes Align instead") {
+    return CreateMaskedLoad(Ptr, assumeAligned(Alignment), Mask, PassThru,
+                            Name);
+  }
+  CallInst *CreateMaskedLoad(Value *Ptr, Align Alignment, Value *Mask,
                              Value *PassThru = nullptr, const Twine &Name = "");
 
   /// Create a call to Masked Store intrinsic
-  CallInst *CreateMaskedStore(Value *Val, Value *Ptr, unsigned Align,
+  LLVM_ATTRIBUTE_DEPRECATED(CallInst *CreateMaskedStore(Value *Val, Value *Ptr,
+                                                        unsigned Alignment,
+                                                        Value *Mask),
+                            "Use the version that takes Align instead") {
+    return CreateMaskedStore(Val, Ptr, assumeAligned(Alignment), Mask);
+  }
+
+  CallInst *CreateMaskedStore(Value *Val, Value *Ptr, Align Alignment,
                               Value *Mask);
 
   /// Create a call to Masked Gather intrinsic
-  CallInst *CreateMaskedGather(Value *Ptrs, unsigned Align,
-                               Value *Mask = nullptr,
-                               Value *PassThru = nullptr,
-                               const Twine& Name = "");
+  LLVM_ATTRIBUTE_DEPRECATED(
+      CallInst *CreateMaskedGather(Value *Ptrs, unsigned Alignment,
+                                   Value *Mask = nullptr,
+                                   Value *PassThru = nullptr,
+                                   const Twine &Name = ""),
+      "Use the version that takes Align instead") {
+    return CreateMaskedGather(Ptrs, Align(Alignment), Mask, PassThru, Name);
+  }
+
+  /// Create a call to Masked Gather intrinsic
+  CallInst *CreateMaskedGather(Value *Ptrs, Align Alignment,
+                               Value *Mask = nullptr, Value *PassThru = nullptr,
+                               const Twine &Name = "");
 
   /// Create a call to Masked Scatter intrinsic
-  CallInst *CreateMaskedScatter(Value *Val, Value *Ptrs, unsigned Align,
+  LLVM_ATTRIBUTE_DEPRECATED(
+      CallInst *CreateMaskedScatter(Value *Val, Value *Ptrs, unsigned Alignment,
+                                    Value *Mask = nullptr),
+      "Use the version that takes Align instead") {
+    return CreateMaskedScatter(Val, Ptrs, Align(Alignment), Mask);
+  }
+
+  /// Create a call to Masked Scatter intrinsic
+  CallInst *CreateMaskedScatter(Value *Val, Value *Ptrs, Align Alignment,
                                 Value *Mask = nullptr);
 
   /// Create an assume intrinsic call that allows the optimizer to
   /// assume that the provided condition will be true.
-  CallInst *CreateAssumption(Value *Cond);
+  ///
+  /// The optional argument \p OpBundles specifies operand bundles that are
+  /// added to the call instruction.
+  CallInst *CreateAssumption(Value *Cond,
+                             ArrayRef<OperandBundleDef> OpBundles = llvm::None);
 
   /// Create a call to the experimental.gc.statepoint intrinsic to
   /// start a new statepoint sequence.
   CallInst *CreateGCStatepointCall(uint64_t ID, uint32_t NumPatchBytes,
                                    Value *ActualCallee,
                                    ArrayRef<Value *> CallArgs,
-                                   ArrayRef<Value *> DeoptArgs,
+                                   Optional<ArrayRef<Value *>> DeoptArgs,
                                    ArrayRef<Value *> GCArgs,
                                    const Twine &Name = "");
 
@@ -654,9 +871,9 @@
   /// start a new statepoint sequence.
   CallInst *CreateGCStatepointCall(uint64_t ID, uint32_t NumPatchBytes,
                                    Value *ActualCallee, uint32_t Flags,
-                                   ArrayRef<Use> CallArgs,
-                                   ArrayRef<Use> TransitionArgs,
-                                   ArrayRef<Use> DeoptArgs,
+                                   ArrayRef<Value *> CallArgs,
+                                   Optional<ArrayRef<Use>> TransitionArgs,
+                                   Optional<ArrayRef<Use>> DeoptArgs,
                                    ArrayRef<Value *> GCArgs,
                                    const Twine &Name = "");
 
@@ -665,7 +882,7 @@
   /// .get()'ed to get the Value pointer.
   CallInst *CreateGCStatepointCall(uint64_t ID, uint32_t NumPatchBytes,
                                    Value *ActualCallee, ArrayRef<Use> CallArgs,
-                                   ArrayRef<Value *> DeoptArgs,
+                                   Optional<ArrayRef<Value *>> DeoptArgs,
                                    ArrayRef<Value *> GCArgs,
                                    const Twine &Name = "");
 
@@ -675,7 +892,7 @@
   CreateGCStatepointInvoke(uint64_t ID, uint32_t NumPatchBytes,
                            Value *ActualInvokee, BasicBlock *NormalDest,
                            BasicBlock *UnwindDest, ArrayRef<Value *> InvokeArgs,
-                           ArrayRef<Value *> DeoptArgs,
+                           Optional<ArrayRef<Value *>> DeoptArgs,
                            ArrayRef<Value *> GCArgs, const Twine &Name = "");
 
   /// Create an invoke to the experimental.gc.statepoint intrinsic to
@@ -683,8 +900,8 @@
   InvokeInst *CreateGCStatepointInvoke(
       uint64_t ID, uint32_t NumPatchBytes, Value *ActualInvokee,
       BasicBlock *NormalDest, BasicBlock *UnwindDest, uint32_t Flags,
-      ArrayRef<Use> InvokeArgs, ArrayRef<Use> TransitionArgs,
-      ArrayRef<Use> DeoptArgs, ArrayRef<Value *> GCArgs,
+      ArrayRef<Value *> InvokeArgs, Optional<ArrayRef<Use>> TransitionArgs,
+      Optional<ArrayRef<Use>> DeoptArgs, ArrayRef<Value *> GCArgs,
       const Twine &Name = "");
 
   // Convenience function for the common case when CallArgs are filled in using
@@ -694,7 +911,7 @@
   CreateGCStatepointInvoke(uint64_t ID, uint32_t NumPatchBytes,
                            Value *ActualInvokee, BasicBlock *NormalDest,
                            BasicBlock *UnwindDest, ArrayRef<Use> InvokeArgs,
-                           ArrayRef<Value *> DeoptArgs,
+                           Optional<ArrayRef<Value *>> DeoptArgs,
                            ArrayRef<Value *> GCArgs, const Twine &Name = "");
 
   /// Create a call to the experimental.gc.result intrinsic to extract
@@ -711,6 +928,10 @@
                              Type *ResultType,
                              const Twine &Name = "");
 
+  /// Create a call to llvm.vscale, multiplied by \p Scaling. The type of VScale
+  /// will be the same type as that of \p Scaling.
+  Value *CreateVScale(Constant *Scaling, const Twine &Name = "");
+
   /// Create a call to intrinsic \p ID with 1 operand which is mangled on its
   /// type.
   CallInst *CreateUnaryIntrinsic(Intrinsic::ID ID, Value *V,
@@ -751,6 +972,22 @@
     return CreateBinaryIntrinsic(Intrinsic::maximum, LHS, RHS, nullptr, Name);
   }
 
+  /// Create a call to the experimental.vector.extract intrinsic.
+  CallInst *CreateExtractVector(Type *DstType, Value *SrcVec, Value *Idx,
+                                const Twine &Name = "") {
+    return CreateIntrinsic(Intrinsic::experimental_vector_extract,
+                           {DstType, SrcVec->getType()}, {SrcVec, Idx}, nullptr,
+                           Name);
+  }
+
+  /// Create a call to the experimental.vector.insert intrinsic.
+  CallInst *CreateInsertVector(Type *DstType, Value *SrcVec, Value *SubVec,
+                               Value *Idx, const Twine &Name = "") {
+    return CreateIntrinsic(Intrinsic::experimental_vector_insert,
+                           {DstType, SubVec->getType()}, {SrcVec, SubVec, Idx},
+                           nullptr, Name);
+  }
+
 private:
   /// Create a call to a masked intrinsic with given Id.
   CallInst *CreateMaskedIntrinsic(Intrinsic::ID Id, ArrayRef<Value *> Ops,
@@ -758,85 +995,6 @@
                                   const Twine &Name = "");
 
   Value *getCastedInt8PtrValue(Value *Ptr);
-};
-
-/// This provides a uniform API for creating instructions and inserting
-/// them into a basic block: either at the end of a BasicBlock, or at a specific
-/// iterator location in a block.
-///
-/// Note that the builder does not expose the full generality of LLVM
-/// instructions.  For access to extra instruction properties, use the mutators
-/// (e.g. setVolatile) on the instructions after they have been
-/// created. Convenience state exists to specify fast-math flags and fp-math
-/// tags.
-///
-/// The first template argument specifies a class to use for creating constants.
-/// This defaults to creating minimally folded constants.  The second template
-/// argument allows clients to specify custom insertion hooks that are called on
-/// every newly created insertion.
-template <typename T = ConstantFolder,
-          typename Inserter = IRBuilderDefaultInserter>
-class IRBuilder : public IRBuilderBase, public Inserter {
-  T Folder;
-
-public:
-  IRBuilder(LLVMContext &C, const T &F, Inserter I = Inserter(),
-            MDNode *FPMathTag = nullptr,
-            ArrayRef<OperandBundleDef> OpBundles = None)
-      : IRBuilderBase(C, FPMathTag, OpBundles), Inserter(std::move(I)),
-        Folder(F) {}
-
-  explicit IRBuilder(LLVMContext &C, MDNode *FPMathTag = nullptr,
-                     ArrayRef<OperandBundleDef> OpBundles = None)
-      : IRBuilderBase(C, FPMathTag, OpBundles) {}
-
-  explicit IRBuilder(BasicBlock *TheBB, const T &F, MDNode *FPMathTag = nullptr,
-                     ArrayRef<OperandBundleDef> OpBundles = None)
-      : IRBuilderBase(TheBB->getContext(), FPMathTag, OpBundles), Folder(F) {
-    SetInsertPoint(TheBB);
-  }
-
-  explicit IRBuilder(BasicBlock *TheBB, MDNode *FPMathTag = nullptr,
-                     ArrayRef<OperandBundleDef> OpBundles = None)
-      : IRBuilderBase(TheBB->getContext(), FPMathTag, OpBundles) {
-    SetInsertPoint(TheBB);
-  }
-
-  explicit IRBuilder(Instruction *IP, MDNode *FPMathTag = nullptr,
-                     ArrayRef<OperandBundleDef> OpBundles = None)
-      : IRBuilderBase(IP->getContext(), FPMathTag, OpBundles) {
-    SetInsertPoint(IP);
-  }
-
-  IRBuilder(BasicBlock *TheBB, BasicBlock::iterator IP, const T &F,
-            MDNode *FPMathTag = nullptr,
-            ArrayRef<OperandBundleDef> OpBundles = None)
-      : IRBuilderBase(TheBB->getContext(), FPMathTag, OpBundles), Folder(F) {
-    SetInsertPoint(TheBB, IP);
-  }
-
-  IRBuilder(BasicBlock *TheBB, BasicBlock::iterator IP,
-            MDNode *FPMathTag = nullptr,
-            ArrayRef<OperandBundleDef> OpBundles = None)
-      : IRBuilderBase(TheBB->getContext(), FPMathTag, OpBundles) {
-    SetInsertPoint(TheBB, IP);
-  }
-
-  /// Get the constant folder being used.
-  const T &getFolder() { return Folder; }
-
-  /// Insert and return the specified instruction.
-  template<typename InstTy>
-  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
-    this->InsertHelper(I, Name, BB, InsertPt);
-    this->SetInstDebugLocation(I);
-    return I;
-  }
-
-  /// No-op overload to handle constants.
-  Constant *Insert(Constant *C, const Twine& = "") const {
-    return C;
-  }
 
   //===--------------------------------------------------------------------===//
   // Instruction creation methods: Terminators
@@ -930,16 +1088,21 @@
                            ArrayRef<Value *> Args,
                            ArrayRef<OperandBundleDef> OpBundles,
                            const Twine &Name = "") {
-    return Insert(
-        InvokeInst::Create(Ty, Callee, NormalDest, UnwindDest, Args, OpBundles),
-        Name);
+    InvokeInst *II =
+        InvokeInst::Create(Ty, Callee, NormalDest, UnwindDest, Args, OpBundles);
+    if (IsFPConstrained)
+      setConstrainedFPCallAttr(II);
+    return Insert(II, Name);
   }
   InvokeInst *CreateInvoke(FunctionType *Ty, Value *Callee,
                            BasicBlock *NormalDest, BasicBlock *UnwindDest,
                            ArrayRef<Value *> Args = None,
                            const Twine &Name = "") {
-    return Insert(InvokeInst::Create(Ty, Callee, NormalDest, UnwindDest, Args),
-                  Name);
+    InvokeInst *II =
+        InvokeInst::Create(Ty, Callee, NormalDest, UnwindDest, Args);
+    if (IsFPConstrained)
+      setConstrainedFPCallAttr(II);
+    return Insert(II, Name);
   }
 
   InvokeInst *CreateInvoke(FunctionCallee Callee, BasicBlock *NormalDest,
@@ -958,28 +1121,6 @@
                         NormalDest, UnwindDest, Args, Name);
   }
 
-  // Deprecated [opaque pointer types]
-  InvokeInst *CreateInvoke(Value *Callee, BasicBlock *NormalDest,
-                           BasicBlock *UnwindDest, ArrayRef<Value *> Args,
-                           ArrayRef<OperandBundleDef> OpBundles,
-                           const Twine &Name = "") {
-    return CreateInvoke(
-        cast<FunctionType>(
-            cast<PointerType>(Callee->getType())->getElementType()),
-        Callee, NormalDest, UnwindDest, Args, OpBundles, Name);
-  }
-
-  // Deprecated [opaque pointer types]
-  InvokeInst *CreateInvoke(Value *Callee, BasicBlock *NormalDest,
-                           BasicBlock *UnwindDest,
-                           ArrayRef<Value *> Args = None,
-                           const Twine &Name = "") {
-    return CreateInvoke(
-        cast<FunctionType>(
-            cast<PointerType>(Callee->getType())->getElementType()),
-        Callee, NormalDest, UnwindDest, Args, Name);
-  }
-
   /// \brief Create a callbr instruction.
   CallBrInst *CreateCallBr(FunctionType *Ty, Value *Callee,
                            BasicBlock *DefaultDest,
@@ -1082,38 +1223,44 @@
     return (LC && RC) ? Insert(Folder.CreateBinOp(Opc, LC, RC), Name) : nullptr;
   }
 
-  Value *getConstrainedFPRounding(
-      Optional<ConstrainedFPIntrinsic::RoundingMode> Rounding) {
-    ConstrainedFPIntrinsic::RoundingMode UseRounding =
-        DefaultConstrainedRounding;
+  Value *getConstrainedFPRounding(Optional<RoundingMode> Rounding) {
+    RoundingMode UseRounding = DefaultConstrainedRounding;
 
     if (Rounding.hasValue())
       UseRounding = Rounding.getValue();
 
-    Optional<StringRef> RoundingStr =
-        ConstrainedFPIntrinsic::RoundingModeToStr(UseRounding);
+    Optional<StringRef> RoundingStr = RoundingModeToStr(UseRounding);
     assert(RoundingStr.hasValue() && "Garbage strict rounding mode!");
     auto *RoundingMDS = MDString::get(Context, RoundingStr.getValue());
 
     return MetadataAsValue::get(Context, RoundingMDS);
   }
 
-  Value *getConstrainedFPExcept(
-      Optional<ConstrainedFPIntrinsic::ExceptionBehavior> Except) {
-    ConstrainedFPIntrinsic::ExceptionBehavior UseExcept =
-        DefaultConstrainedExcept;
+  Value *getConstrainedFPExcept(Optional<fp::ExceptionBehavior> Except) {
+    fp::ExceptionBehavior UseExcept = DefaultConstrainedExcept;
 
     if (Except.hasValue())
       UseExcept = Except.getValue();
 
-    Optional<StringRef> ExceptStr =
-        ConstrainedFPIntrinsic::ExceptionBehaviorToStr(UseExcept);
+    Optional<StringRef> ExceptStr = ExceptionBehaviorToStr(UseExcept);
     assert(ExceptStr.hasValue() && "Garbage strict exception behavior!");
     auto *ExceptMDS = MDString::get(Context, ExceptStr.getValue());
 
     return MetadataAsValue::get(Context, ExceptMDS);
   }
 
+  Value *getConstrainedFPPredicate(CmpInst::Predicate Predicate) {
+    assert(CmpInst::isFPPredicate(Predicate) &&
+           Predicate != CmpInst::FCMP_FALSE &&
+           Predicate != CmpInst::FCMP_TRUE &&
+           "Invalid constrained FP comparison predicate!");
+
+    StringRef PredicateStr = CmpInst::getPredicateName(Predicate);
+    auto *PredicateMDS = MDString::get(Context, PredicateStr);
+
+    return MetadataAsValue::get(Context, PredicateMDS);
+  }
+
 public:
   Value *CreateAdd(Value *LHS, Value *RHS, const Twine &Name = "",
                    bool HasNUW = false, bool HasNSW = false) {
@@ -1461,26 +1608,15 @@
     if (Value *V = foldConstant(Opc, LHS, RHS, Name)) return V;
     Instruction *BinOp = BinaryOperator::Create(Opc, LHS, RHS);
     if (isa<FPMathOperator>(BinOp))
-      BinOp = setFPAttrs(BinOp, FPMathTag, FMF);
+      setFPAttrs(BinOp, FPMathTag, FMF);
     return Insert(BinOp, Name);
   }
 
   CallInst *CreateConstrainedFPBinOp(
       Intrinsic::ID ID, Value *L, Value *R, Instruction *FMFSource = nullptr,
       const Twine &Name = "", MDNode *FPMathTag = nullptr,
-      Optional<ConstrainedFPIntrinsic::RoundingMode> Rounding = None,
-      Optional<ConstrainedFPIntrinsic::ExceptionBehavior> Except = None) {
-    Value *RoundingV = getConstrainedFPRounding(Rounding);
-    Value *ExceptV = getConstrainedFPExcept(Except);
-
-    FastMathFlags UseFMF = FMF;
-    if (FMFSource)
-      UseFMF = FMFSource->getFastMathFlags();
-
-    CallInst *C = CreateIntrinsic(ID, {L->getType()},
-                                  {L, R, RoundingV, ExceptV}, nullptr, Name);
-    return cast<CallInst>(setFPAttrs(C, FPMathTag, UseFMF));
-  }
+      Optional<RoundingMode> Rounding = None,
+      Optional<fp::ExceptionBehavior> Except = None);
 
   Value *CreateNeg(Value *V, const Twine &Name = "",
                    bool HasNUW = false, bool HasNSW = false) {
@@ -1504,7 +1640,7 @@
                     MDNode *FPMathTag = nullptr) {
     if (auto *VC = dyn_cast<Constant>(V))
       return Insert(Folder.CreateFNeg(VC), Name);
-    return Insert(setFPAttrs(BinaryOperator::CreateFNeg(V), FPMathTag, FMF),
+    return Insert(setFPAttrs(UnaryOperator::CreateFNeg(V), FPMathTag, FMF),
                   Name);
   }
 
@@ -1514,9 +1650,7 @@
                        const Twine &Name = "") {
    if (auto *VC = dyn_cast<Constant>(V))
      return Insert(Folder.CreateFNeg(VC), Name);
-   // TODO: This should return UnaryOperator::CreateFNeg(...) once we are
-   // confident that they are optimized sufficiently.
-   return Insert(setFPAttrs(BinaryOperator::CreateFNeg(V), nullptr,
+   return Insert(setFPAttrs(UnaryOperator::CreateFNeg(V), nullptr,
                             FMFSource->getFastMathFlags()),
                  Name);
   }
@@ -1534,27 +1668,14 @@
       return Insert(Folder.CreateUnOp(Opc, VC), Name);
     Instruction *UnOp = UnaryOperator::Create(Opc, V);
     if (isa<FPMathOperator>(UnOp))
-      UnOp = setFPAttrs(UnOp, FPMathTag, FMF);
+      setFPAttrs(UnOp, FPMathTag, FMF);
     return Insert(UnOp, Name);
   }
 
   /// Create either a UnaryOperator or BinaryOperator depending on \p Opc.
   /// Correct number of operands must be passed accordingly.
   Value *CreateNAryOp(unsigned Opc, ArrayRef<Value *> Ops,
-                      const Twine &Name = "",
-                      MDNode *FPMathTag = nullptr) {
-    if (Instruction::isBinaryOp(Opc)) {
-      assert(Ops.size() == 2 && "Invalid number of operands!");
-      return CreateBinOp(static_cast<Instruction::BinaryOps>(Opc),
-                         Ops[0], Ops[1], Name, FPMathTag);
-    }
-    if (Instruction::isUnaryOp(Opc)) {
-      assert(Ops.size() == 1 && "Invalid number of operands!");
-      return CreateUnOp(static_cast<Instruction::UnaryOps>(Opc),
-                        Ops[0], Name, FPMathTag);
-    }
-    llvm_unreachable("Unexpected opcode!");
-  }
+                      const Twine &Name = "", MDNode *FPMathTag = nullptr);
 
   //===--------------------------------------------------------------------===//
   // Instruction creation methods: Memory Instructions
@@ -1562,28 +1683,32 @@
 
   AllocaInst *CreateAlloca(Type *Ty, unsigned AddrSpace,
                            Value *ArraySize = nullptr, const Twine &Name = "") {
-    return Insert(new AllocaInst(Ty, AddrSpace, ArraySize), Name);
+    const DataLayout &DL = BB->getModule()->getDataLayout();
+    Align AllocaAlign = DL.getPrefTypeAlign(Ty);
+    return Insert(new AllocaInst(Ty, AddrSpace, ArraySize, AllocaAlign), Name);
   }
 
   AllocaInst *CreateAlloca(Type *Ty, Value *ArraySize = nullptr,
                            const Twine &Name = "") {
-    const DataLayout &DL = BB->getParent()->getParent()->getDataLayout();
-    return Insert(new AllocaInst(Ty, DL.getAllocaAddrSpace(), ArraySize), Name);
+    const DataLayout &DL = BB->getModule()->getDataLayout();
+    Align AllocaAlign = DL.getPrefTypeAlign(Ty);
+    unsigned AddrSpace = DL.getAllocaAddrSpace();
+    return Insert(new AllocaInst(Ty, AddrSpace, ArraySize, AllocaAlign), Name);
   }
 
   /// Provided to resolve 'CreateLoad(Ty, Ptr, "...")' correctly, instead of
   /// converting the string to 'bool' for the isVolatile parameter.
   LoadInst *CreateLoad(Type *Ty, Value *Ptr, const char *Name) {
-    return Insert(new LoadInst(Ty, Ptr), Name);
+    return CreateAlignedLoad(Ty, Ptr, MaybeAlign(), Name);
   }
 
   LoadInst *CreateLoad(Type *Ty, Value *Ptr, const Twine &Name = "") {
-    return Insert(new LoadInst(Ty, Ptr), Name);
+    return CreateAlignedLoad(Ty, Ptr, MaybeAlign(), Name);
   }
 
   LoadInst *CreateLoad(Type *Ty, Value *Ptr, bool isVolatile,
                        const Twine &Name = "") {
-    return Insert(new LoadInst(Ty, Ptr, Twine(), isVolatile), Name);
+    return CreateAlignedLoad(Ty, Ptr, MaybeAlign(), isVolatile, Name);
   }
 
   // Deprecated [opaque pointer types]
@@ -1603,75 +1728,125 @@
   }
 
   StoreInst *CreateStore(Value *Val, Value *Ptr, bool isVolatile = false) {
-    return Insert(new StoreInst(Val, Ptr, isVolatile));
+    return CreateAlignedStore(Val, Ptr, MaybeAlign(), isVolatile);
   }
 
-  /// Provided to resolve 'CreateAlignedLoad(Ptr, Align, "...")'
-  /// correctly, instead of converting the string to 'bool' for the isVolatile
-  /// parameter.
-  LoadInst *CreateAlignedLoad(Type *Ty, Value *Ptr, unsigned Align,
+  LLVM_ATTRIBUTE_DEPRECATED(LoadInst *CreateAlignedLoad(Type *Ty, Value *Ptr,
+                                                        unsigned Align,
+                                                        const char *Name),
+                            "Use the version that takes NaybeAlign instead") {
+    return CreateAlignedLoad(Ty, Ptr, MaybeAlign(Align), Name);
+  }
+  LoadInst *CreateAlignedLoad(Type *Ty, Value *Ptr, MaybeAlign Align,
                               const char *Name) {
-    LoadInst *LI = CreateLoad(Ty, Ptr, Name);
-    LI->setAlignment(Align);
-    return LI;
+    return CreateAlignedLoad(Ty, Ptr, Align, /*isVolatile*/false, Name);
   }
-  LoadInst *CreateAlignedLoad(Type *Ty, Value *Ptr, unsigned Align,
+
+  LLVM_ATTRIBUTE_DEPRECATED(LoadInst *CreateAlignedLoad(Type *Ty, Value *Ptr,
+                                                        unsigned Align,
+                                                        const Twine &Name = ""),
+                            "Use the version that takes MaybeAlign instead") {
+    return CreateAlignedLoad(Ty, Ptr, MaybeAlign(Align), Name);
+  }
+  LoadInst *CreateAlignedLoad(Type *Ty, Value *Ptr, MaybeAlign Align,
                               const Twine &Name = "") {
-    LoadInst *LI = CreateLoad(Ty, Ptr, Name);
-    LI->setAlignment(Align);
-    return LI;
+    return CreateAlignedLoad(Ty, Ptr, Align, /*isVolatile*/false, Name);
   }
-  LoadInst *CreateAlignedLoad(Type *Ty, Value *Ptr, unsigned Align,
+
+  LLVM_ATTRIBUTE_DEPRECATED(LoadInst *CreateAlignedLoad(Type *Ty, Value *Ptr,
+                                                        unsigned Align,
+                                                        bool isVolatile,
+                                                        const Twine &Name = ""),
+                            "Use the version that takes MaybeAlign instead") {
+    return CreateAlignedLoad(Ty, Ptr, MaybeAlign(Align), isVolatile, Name);
+  }
+  LoadInst *CreateAlignedLoad(Type *Ty, Value *Ptr, MaybeAlign Align,
                               bool isVolatile, const Twine &Name = "") {
-    LoadInst *LI = CreateLoad(Ty, Ptr, isVolatile, Name);
-    LI->setAlignment(Align);
-    return LI;
+    if (!Align) {
+      const DataLayout &DL = BB->getModule()->getDataLayout();
+      Align = DL.getABITypeAlign(Ty);
+    }
+    return Insert(new LoadInst(Ty, Ptr, Twine(), isVolatile, *Align), Name);
   }
 
   // Deprecated [opaque pointer types]
-  LoadInst *CreateAlignedLoad(Value *Ptr, unsigned Align, const char *Name) {
+  LLVM_ATTRIBUTE_DEPRECATED(LoadInst *CreateAlignedLoad(Value *Ptr,
+                                                        unsigned Align,
+                                                        const char *Name),
+                            "Use the version that takes MaybeAlign instead") {
+    return CreateAlignedLoad(Ptr->getType()->getPointerElementType(), Ptr,
+                             MaybeAlign(Align), Name);
+  }
+  // Deprecated [opaque pointer types]
+  LLVM_ATTRIBUTE_DEPRECATED(LoadInst *CreateAlignedLoad(Value *Ptr,
+                                                        unsigned Align,
+                                                        const Twine &Name = ""),
+                            "Use the version that takes MaybeAlign instead") {
+    return CreateAlignedLoad(Ptr->getType()->getPointerElementType(), Ptr,
+                             MaybeAlign(Align), Name);
+  }
+  // Deprecated [opaque pointer types]
+  LLVM_ATTRIBUTE_DEPRECATED(LoadInst *CreateAlignedLoad(Value *Ptr,
+                                                        unsigned Align,
+                                                        bool isVolatile,
+                                                        const Twine &Name = ""),
+                            "Use the version that takes MaybeAlign instead") {
+    return CreateAlignedLoad(Ptr->getType()->getPointerElementType(), Ptr,
+                             MaybeAlign(Align), isVolatile, Name);
+  }
+  // Deprecated [opaque pointer types]
+  LoadInst *CreateAlignedLoad(Value *Ptr, MaybeAlign Align, const char *Name) {
     return CreateAlignedLoad(Ptr->getType()->getPointerElementType(), Ptr,
                              Align, Name);
   }
   // Deprecated [opaque pointer types]
-  LoadInst *CreateAlignedLoad(Value *Ptr, unsigned Align,
+  LoadInst *CreateAlignedLoad(Value *Ptr, MaybeAlign Align,
                               const Twine &Name = "") {
     return CreateAlignedLoad(Ptr->getType()->getPointerElementType(), Ptr,
                              Align, Name);
   }
   // Deprecated [opaque pointer types]
-  LoadInst *CreateAlignedLoad(Value *Ptr, unsigned Align, bool isVolatile,
+  LoadInst *CreateAlignedLoad(Value *Ptr, MaybeAlign Align, bool isVolatile,
                               const Twine &Name = "") {
     return CreateAlignedLoad(Ptr->getType()->getPointerElementType(), Ptr,
                              Align, isVolatile, Name);
   }
 
-  StoreInst *CreateAlignedStore(Value *Val, Value *Ptr, unsigned Align,
-                                bool isVolatile = false) {
-    StoreInst *SI = CreateStore(Val, Ptr, isVolatile);
-    SI->setAlignment(Align);
-    return SI;
+  LLVM_ATTRIBUTE_DEPRECATED(
+      StoreInst *CreateAlignedStore(Value *Val, Value *Ptr, unsigned Align,
+                                    bool isVolatile = false),
+      "Use the version that takes MaybeAlign instead") {
+    return CreateAlignedStore(Val, Ptr, MaybeAlign(Align), isVolatile);
   }
-
+  StoreInst *CreateAlignedStore(Value *Val, Value *Ptr, MaybeAlign Align,
+                                bool isVolatile = false) {
+    if (!Align) {
+      const DataLayout &DL = BB->getModule()->getDataLayout();
+      Align = DL.getABITypeAlign(Val->getType());
+    }
+    return Insert(new StoreInst(Val, Ptr, isVolatile, *Align));
+  }
   FenceInst *CreateFence(AtomicOrdering Ordering,
                          SyncScope::ID SSID = SyncScope::System,
                          const Twine &Name = "") {
     return Insert(new FenceInst(Context, Ordering, SSID), Name);
   }
 
-  AtomicCmpXchgInst *
-  CreateAtomicCmpXchg(Value *Ptr, Value *Cmp, Value *New,
-                      AtomicOrdering SuccessOrdering,
-                      AtomicOrdering FailureOrdering,
-                      SyncScope::ID SSID = SyncScope::System) {
-    return Insert(new AtomicCmpXchgInst(Ptr, Cmp, New, SuccessOrdering,
-                                        FailureOrdering, SSID));
+  AtomicCmpXchgInst *CreateAtomicCmpXchg(
+      Value *Ptr, Value *Cmp, Value *New, AtomicOrdering SuccessOrdering,
+      AtomicOrdering FailureOrdering, SyncScope::ID SSID = SyncScope::System) {
+    const DataLayout &DL = BB->getModule()->getDataLayout();
+    Align Alignment(DL.getTypeStoreSize(New->getType()));
+    return Insert(new AtomicCmpXchgInst(
+        Ptr, Cmp, New, Alignment, SuccessOrdering, FailureOrdering, SSID));
   }
 
   AtomicRMWInst *CreateAtomicRMW(AtomicRMWInst::BinOp Op, Value *Ptr, Value *Val,
                                  AtomicOrdering Ordering,
                                  SyncScope::ID SSID = SyncScope::System) {
-    return Insert(new AtomicRMWInst(Op, Ptr, Val, Ordering, SSID));
+    const DataLayout &DL = BB->getModule()->getDataLayout();
+    Align Alignment(DL.getTypeStoreSize(Val->getType()));
+    return Insert(new AtomicRMWInst(Op, Ptr, Val, Alignment, Ordering, SSID));
   }
 
   Value *CreateGEP(Value *Ptr, ArrayRef<Value *> IdxList,
@@ -1858,9 +2033,13 @@
 
   /// Same as CreateGlobalString, but return a pointer with "i8*" type
   /// instead of a pointer to array of i8.
+  ///
+  /// If no module is given via \p M, it is take from the insertion point basic
+  /// block.
   Constant *CreateGlobalStringPtr(StringRef Str, const Twine &Name = "",
-                                  unsigned AddressSpace = 0) {
-    GlobalVariable *GV = CreateGlobalString(Str, Name, AddressSpace);
+                                  unsigned AddressSpace = 0,
+                                  Module *M = nullptr) {
+    GlobalVariable *GV = CreateGlobalString(Str, Name, AddressSpace, M);
     Constant *Zero = ConstantInt::get(Type::getInt32Ty(Context), 0);
     Constant *Indices[] = {Zero, Zero};
     return ConstantExpr::getInBoundsGetElementPtr(GV->getValueType(), GV,
@@ -1913,28 +2092,47 @@
     return V;
   }
 
-  Value *CreateFPToUI(Value *V, Type *DestTy, const Twine &Name = ""){
+  Value *CreateFPToUI(Value *V, Type *DestTy, const Twine &Name = "") {
+    if (IsFPConstrained)
+      return CreateConstrainedFPCast(Intrinsic::experimental_constrained_fptoui,
+                                     V, DestTy, nullptr, Name);
     return CreateCast(Instruction::FPToUI, V, DestTy, Name);
   }
 
-  Value *CreateFPToSI(Value *V, Type *DestTy, const Twine &Name = ""){
+  Value *CreateFPToSI(Value *V, Type *DestTy, const Twine &Name = "") {
+    if (IsFPConstrained)
+      return CreateConstrainedFPCast(Intrinsic::experimental_constrained_fptosi,
+                                     V, DestTy, nullptr, Name);
     return CreateCast(Instruction::FPToSI, V, DestTy, Name);
   }
 
   Value *CreateUIToFP(Value *V, Type *DestTy, const Twine &Name = ""){
+    if (IsFPConstrained)
+      return CreateConstrainedFPCast(Intrinsic::experimental_constrained_uitofp,
+                                     V, DestTy, nullptr, Name);
     return CreateCast(Instruction::UIToFP, V, DestTy, Name);
   }
 
   Value *CreateSIToFP(Value *V, Type *DestTy, const Twine &Name = ""){
+    if (IsFPConstrained)
+      return CreateConstrainedFPCast(Intrinsic::experimental_constrained_sitofp,
+                                     V, DestTy, nullptr, Name);
     return CreateCast(Instruction::SIToFP, V, DestTy, Name);
   }
 
   Value *CreateFPTrunc(Value *V, Type *DestTy,
                        const Twine &Name = "") {
+    if (IsFPConstrained)
+      return CreateConstrainedFPCast(
+          Intrinsic::experimental_constrained_fptrunc, V, DestTy, nullptr,
+          Name);
     return CreateCast(Instruction::FPTrunc, V, DestTy, Name);
   }
 
   Value *CreateFPExt(Value *V, Type *DestTy, const Twine &Name = "") {
+    if (IsFPConstrained)
+      return CreateConstrainedFPCast(Intrinsic::experimental_constrained_fpext,
+                                     V, DestTy, nullptr, Name);
     return CreateCast(Instruction::FPExt, V, DestTy, Name);
   }
 
@@ -2046,6 +2244,13 @@
     return Insert(CastInst::CreateFPCast(V, DestTy), Name);
   }
 
+  CallInst *CreateConstrainedFPCast(
+      Intrinsic::ID ID, Value *V, Type *DestTy,
+      Instruction *FMFSource = nullptr, const Twine &Name = "",
+      MDNode *FPMathTag = nullptr,
+      Optional<RoundingMode> Rounding = None,
+      Optional<fp::ExceptionBehavior> Except = None);
+
   // Provided to resolve 'CreateIntCast(Ptr, Ptr, "...")', giving a
   // compile time error, instead of converting the string to bool for the
   // isSigned parameter.
@@ -2173,29 +2378,60 @@
     return Insert(new ICmpInst(P, LHS, RHS), Name);
   }
 
+  // Create a quiet floating-point comparison (i.e. one that raises an FP
+  // exception only in the case where an input is a signaling NaN).
+  // Note that this differs from CreateFCmpS only if IsFPConstrained is true.
   Value *CreateFCmp(CmpInst::Predicate P, Value *LHS, Value *RHS,
                     const Twine &Name = "", MDNode *FPMathTag = nullptr) {
-    if (auto *LC = dyn_cast<Constant>(LHS))
-      if (auto *RC = dyn_cast<Constant>(RHS))
-        return Insert(Folder.CreateFCmp(P, LC, RC), Name);
-    return Insert(setFPAttrs(new FCmpInst(P, LHS, RHS), FPMathTag, FMF), Name);
+    return CreateFCmpHelper(P, LHS, RHS, Name, FPMathTag, false);
   }
 
+  Value *CreateCmp(CmpInst::Predicate Pred, Value *LHS, Value *RHS,
+                   const Twine &Name = "", MDNode *FPMathTag = nullptr) {
+    return CmpInst::isFPPredicate(Pred)
+               ? CreateFCmp(Pred, LHS, RHS, Name, FPMathTag)
+               : CreateICmp(Pred, LHS, RHS, Name);
+  }
+
+  // Create a signaling floating-point comparison (i.e. one that raises an FP
+  // exception whenever an input is any NaN, signaling or quiet).
+  // Note that this differs from CreateFCmp only if IsFPConstrained is true.
+  Value *CreateFCmpS(CmpInst::Predicate P, Value *LHS, Value *RHS,
+                     const Twine &Name = "", MDNode *FPMathTag = nullptr) {
+    return CreateFCmpHelper(P, LHS, RHS, Name, FPMathTag, true);
+  }
+
+private:
+  // Helper routine to create either a signaling or a quiet FP comparison.
+  Value *CreateFCmpHelper(CmpInst::Predicate P, Value *LHS, Value *RHS,
+                          const Twine &Name, MDNode *FPMathTag,
+                          bool IsSignaling);
+
+public:
+  CallInst *CreateConstrainedFPCmp(
+      Intrinsic::ID ID, CmpInst::Predicate P, Value *L, Value *R,
+      const Twine &Name = "", Optional<fp::ExceptionBehavior> Except = None);
+
   //===--------------------------------------------------------------------===//
   // Instruction creation methods: Other Instructions
   //===--------------------------------------------------------------------===//
 
   PHINode *CreatePHI(Type *Ty, unsigned NumReservedValues,
                      const Twine &Name = "") {
-    return Insert(PHINode::Create(Ty, NumReservedValues), Name);
+    PHINode *Phi = PHINode::Create(Ty, NumReservedValues);
+    if (isa<FPMathOperator>(Phi))
+      setFPAttrs(Phi, nullptr /* MDNode* */, FMF);
+    return Insert(Phi, Name);
   }
 
   CallInst *CreateCall(FunctionType *FTy, Value *Callee,
                        ArrayRef<Value *> Args = None, const Twine &Name = "",
                        MDNode *FPMathTag = nullptr) {
     CallInst *CI = CallInst::Create(FTy, Callee, Args, DefaultOperandBundles);
+    if (IsFPConstrained)
+      setConstrainedFPCallAttr(CI);
     if (isa<FPMathOperator>(CI))
-      CI = cast<CallInst>(setFPAttrs(CI, FPMathTag, FMF));
+      setFPAttrs(CI, FPMathTag, FMF);
     return Insert(CI, Name);
   }
 
@@ -2203,8 +2439,10 @@
                        ArrayRef<OperandBundleDef> OpBundles,
                        const Twine &Name = "", MDNode *FPMathTag = nullptr) {
     CallInst *CI = CallInst::Create(FTy, Callee, Args, OpBundles);
+    if (IsFPConstrained)
+      setConstrainedFPCallAttr(CI);
     if (isa<FPMathOperator>(CI))
-      CI = cast<CallInst>(setFPAttrs(CI, FPMathTag, FMF));
+      setFPAttrs(CI, FPMathTag, FMF);
     return Insert(CI, Name);
   }
 
@@ -2221,40 +2459,13 @@
                       OpBundles, Name, FPMathTag);
   }
 
-  // Deprecated [opaque pointer types]
-  CallInst *CreateCall(Value *Callee, ArrayRef<Value *> Args = None,
-                       const Twine &Name = "", MDNode *FPMathTag = nullptr) {
-    return CreateCall(
-        cast<FunctionType>(Callee->getType()->getPointerElementType()), Callee,
-        Args, Name, FPMathTag);
-  }
-
-  // Deprecated [opaque pointer types]
-  CallInst *CreateCall(Value *Callee, ArrayRef<Value *> Args,
-                       ArrayRef<OperandBundleDef> OpBundles,
-                       const Twine &Name = "", MDNode *FPMathTag = nullptr) {
-    return CreateCall(
-        cast<FunctionType>(Callee->getType()->getPointerElementType()), Callee,
-        Args, OpBundles, Name, FPMathTag);
-  }
+  CallInst *CreateConstrainedFPCall(
+      Function *Callee, ArrayRef<Value *> Args, const Twine &Name = "",
+      Optional<RoundingMode> Rounding = None,
+      Optional<fp::ExceptionBehavior> Except = None);
 
   Value *CreateSelect(Value *C, Value *True, Value *False,
-                      const Twine &Name = "", Instruction *MDFrom = nullptr) {
-    if (auto *CC = dyn_cast<Constant>(C))
-      if (auto *TC = dyn_cast<Constant>(True))
-        if (auto *FC = dyn_cast<Constant>(False))
-          return Insert(Folder.CreateSelect(CC, TC, FC), Name);
-
-    SelectInst *Sel = SelectInst::Create(C, True, False);
-    if (MDFrom) {
-      MDNode *Prof = MDFrom->getMetadata(LLVMContext::MD_prof);
-      MDNode *Unpred = MDFrom->getMetadata(LLVMContext::MD_unpredictable);
-      Sel = addBranchMetadata(Sel, Prof, Unpred);
-    }
-    if (isa<FPMathOperator>(Sel))
-      Sel = cast<SelectInst>(setFPAttrs(Sel, nullptr /* MDNode* */, FMF));
-    return Insert(Sel, Name);
-  }
+                      const Twine &Name = "", Instruction *MDFrom = nullptr);
 
   VAArgInst *CreateVAArg(Value *List, Type *Ty, const Twine &Name = "") {
     return Insert(new VAArgInst(List, Ty), Name);
@@ -2289,17 +2500,34 @@
 
   Value *CreateShuffleVector(Value *V1, Value *V2, Value *Mask,
                              const Twine &Name = "") {
+    SmallVector<int, 16> IntMask;
+    ShuffleVectorInst::getShuffleMask(cast<Constant>(Mask), IntMask);
+    return CreateShuffleVector(V1, V2, IntMask, Name);
+  }
+
+  LLVM_ATTRIBUTE_DEPRECATED(Value *CreateShuffleVector(Value *V1, Value *V2,
+                                                       ArrayRef<uint32_t> Mask,
+                                                       const Twine &Name = ""),
+                            "Pass indices as 'int' instead") {
+    SmallVector<int, 16> IntMask;
+    IntMask.assign(Mask.begin(), Mask.end());
+    return CreateShuffleVector(V1, V2, IntMask, Name);
+  }
+
+  /// See class ShuffleVectorInst for a description of the mask representation.
+  Value *CreateShuffleVector(Value *V1, Value *V2, ArrayRef<int> Mask,
+                             const Twine &Name = "") {
     if (auto *V1C = dyn_cast<Constant>(V1))
       if (auto *V2C = dyn_cast<Constant>(V2))
-        if (auto *MC = dyn_cast<Constant>(Mask))
-          return Insert(Folder.CreateShuffleVector(V1C, V2C, MC), Name);
+        return Insert(Folder.CreateShuffleVector(V1C, V2C, Mask), Name);
     return Insert(new ShuffleVectorInst(V1, V2, Mask), Name);
   }
 
-  Value *CreateShuffleVector(Value *V1, Value *V2, ArrayRef<uint32_t> IntMask,
+  /// Create a unary shuffle. The second vector operand of the IR instruction
+  /// is poison.
+  Value *CreateShuffleVector(Value *V, ArrayRef<int> Mask,
                              const Twine &Name = "") {
-    Value *Mask = ConstantDataVector::get(Context, IntMask);
-    return CreateShuffleVector(V1, V2, Mask, Name);
+    return CreateShuffleVector(V, PoisonValue::get(V->getType()), Mask, Name);
   }
 
   Value *CreateExtractValue(Value *Agg,
@@ -2324,6 +2552,10 @@
     return Insert(LandingPadInst::Create(Ty, NumClauses), Name);
   }
 
+  Value *CreateFreeze(Value *V, const Twine &Name = "") {
+    return Insert(new FreezeInst(V), Name);
+  }
+
   //===--------------------------------------------------------------------===//
   // Utility creation methods
   //===--------------------------------------------------------------------===//
@@ -2346,213 +2578,49 @@
   /// This is intended to implement C-style pointer subtraction. As such, the
   /// pointers must be appropriately aligned for their element types and
   /// pointing into the same object.
-  Value *CreatePtrDiff(Value *LHS, Value *RHS, const Twine &Name = "") {
-    assert(LHS->getType() == RHS->getType() &&
-           "Pointer subtraction operand types must match!");
-    auto *ArgType = cast<PointerType>(LHS->getType());
-    Value *LHS_int = CreatePtrToInt(LHS, Type::getInt64Ty(Context));
-    Value *RHS_int = CreatePtrToInt(RHS, Type::getInt64Ty(Context));
-    Value *Difference = CreateSub(LHS_int, RHS_int);
-    return CreateExactSDiv(Difference,
-                           ConstantExpr::getSizeOf(ArgType->getElementType()),
-                           Name);
-  }
+  Value *CreatePtrDiff(Value *LHS, Value *RHS, const Twine &Name = "");
 
   /// Create a launder.invariant.group intrinsic call. If Ptr type is
   /// different from pointer to i8, it's casted to pointer to i8 in the same
   /// address space before call and casted back to Ptr type after call.
-  Value *CreateLaunderInvariantGroup(Value *Ptr) {
-    assert(isa<PointerType>(Ptr->getType()) &&
-           "launder.invariant.group only applies to pointers.");
-    // FIXME: we could potentially avoid casts to/from i8*.
-    auto *PtrType = Ptr->getType();
-    auto *Int8PtrTy = getInt8PtrTy(PtrType->getPointerAddressSpace());
-    if (PtrType != Int8PtrTy)
-      Ptr = CreateBitCast(Ptr, Int8PtrTy);
-    Module *M = BB->getParent()->getParent();
-    Function *FnLaunderInvariantGroup = Intrinsic::getDeclaration(
-        M, Intrinsic::launder_invariant_group, {Int8PtrTy});
-
-    assert(FnLaunderInvariantGroup->getReturnType() == Int8PtrTy &&
-           FnLaunderInvariantGroup->getFunctionType()->getParamType(0) ==
-               Int8PtrTy &&
-           "LaunderInvariantGroup should take and return the same type");
-
-    CallInst *Fn = CreateCall(FnLaunderInvariantGroup, {Ptr});
-
-    if (PtrType != Int8PtrTy)
-      return CreateBitCast(Fn, PtrType);
-    return Fn;
-  }
+  Value *CreateLaunderInvariantGroup(Value *Ptr);
 
   /// \brief Create a strip.invariant.group intrinsic call. If Ptr type is
   /// different from pointer to i8, it's casted to pointer to i8 in the same
   /// address space before call and casted back to Ptr type after call.
-  Value *CreateStripInvariantGroup(Value *Ptr) {
-    assert(isa<PointerType>(Ptr->getType()) &&
-           "strip.invariant.group only applies to pointers.");
-
-    // FIXME: we could potentially avoid casts to/from i8*.
-    auto *PtrType = Ptr->getType();
-    auto *Int8PtrTy = getInt8PtrTy(PtrType->getPointerAddressSpace());
-    if (PtrType != Int8PtrTy)
-      Ptr = CreateBitCast(Ptr, Int8PtrTy);
-    Module *M = BB->getParent()->getParent();
-    Function *FnStripInvariantGroup = Intrinsic::getDeclaration(
-        M, Intrinsic::strip_invariant_group, {Int8PtrTy});
-
-    assert(FnStripInvariantGroup->getReturnType() == Int8PtrTy &&
-           FnStripInvariantGroup->getFunctionType()->getParamType(0) ==
-               Int8PtrTy &&
-           "StripInvariantGroup should take and return the same type");
-
-    CallInst *Fn = CreateCall(FnStripInvariantGroup, {Ptr});
-
-    if (PtrType != Int8PtrTy)
-      return CreateBitCast(Fn, PtrType);
-    return Fn;
-  }
+  Value *CreateStripInvariantGroup(Value *Ptr);
 
   /// Return a vector value that contains \arg V broadcasted to \p
   /// NumElts elements.
-  Value *CreateVectorSplat(unsigned NumElts, Value *V, const Twine &Name = "") {
-    assert(NumElts > 0 && "Cannot splat to an empty vector!");
+  Value *CreateVectorSplat(unsigned NumElts, Value *V, const Twine &Name = "");
 
-    // First insert it into an undef vector so we can shuffle it.
-    Type *I32Ty = getInt32Ty();
-    Value *Undef = UndefValue::get(VectorType::get(V->getType(), NumElts));
-    V = CreateInsertElement(Undef, V, ConstantInt::get(I32Ty, 0),
-                            Name + ".splatinsert");
-
-    // Shuffle the value across the desired number of elements.
-    Value *Zeros = ConstantAggregateZero::get(VectorType::get(I32Ty, NumElts));
-    return CreateShuffleVector(V, Undef, Zeros, Name + ".splat");
-  }
+  /// Return a vector value that contains \arg V broadcasted to \p
+  /// EC elements.
+  Value *CreateVectorSplat(ElementCount EC, Value *V, const Twine &Name = "");
 
   /// Return a value that has been extracted from a larger integer type.
   Value *CreateExtractInteger(const DataLayout &DL, Value *From,
                               IntegerType *ExtractedTy, uint64_t Offset,
-                              const Twine &Name) {
-    auto *IntTy = cast<IntegerType>(From->getType());
-    assert(DL.getTypeStoreSize(ExtractedTy) + Offset <=
-               DL.getTypeStoreSize(IntTy) &&
-           "Element extends past full value");
-    uint64_t ShAmt = 8 * Offset;
-    Value *V = From;
-    if (DL.isBigEndian())
-      ShAmt = 8 * (DL.getTypeStoreSize(IntTy) -
-                   DL.getTypeStoreSize(ExtractedTy) - Offset);
-    if (ShAmt) {
-      V = CreateLShr(V, ShAmt, Name + ".shift");
-    }
-    assert(ExtractedTy->getBitWidth() <= IntTy->getBitWidth() &&
-           "Cannot extract to a larger integer!");
-    if (ExtractedTy != IntTy) {
-      V = CreateTrunc(V, ExtractedTy, Name + ".trunc");
-    }
-    return V;
-  }
+                              const Twine &Name);
 
-  Value *CreatePreserveArrayAccessIndex(Value *Base, unsigned Dimension,
-                                        unsigned LastIndex) {
-    assert(isa<PointerType>(Base->getType()) &&
-           "Invalid Base ptr type for preserve.array.access.index.");
-    auto *BaseType = Base->getType();
-
-    Value *LastIndexV = getInt32(LastIndex);
-    Constant *Zero = ConstantInt::get(Type::getInt32Ty(Context), 0);
-    SmallVector<Value *, 4> IdxList;
-    for (unsigned I = 0; I < Dimension; ++I)
-      IdxList.push_back(Zero);
-    IdxList.push_back(LastIndexV);
-
-    Type *ResultType =
-        GetElementPtrInst::getGEPReturnType(Base, IdxList);
-
-    Module *M = BB->getParent()->getParent();
-    Function *FnPreserveArrayAccessIndex = Intrinsic::getDeclaration(
-        M, Intrinsic::preserve_array_access_index, {ResultType, BaseType});
-
-    Value *DimV = getInt32(Dimension);
-    CallInst *Fn =
-        CreateCall(FnPreserveArrayAccessIndex, {Base, DimV, LastIndexV});
-
-    return Fn;
-  }
+  Value *CreatePreserveArrayAccessIndex(Type *ElTy, Value *Base,
+                                        unsigned Dimension, unsigned LastIndex,
+                                        MDNode *DbgInfo);
 
   Value *CreatePreserveUnionAccessIndex(Value *Base, unsigned FieldIndex,
-                                        MDNode *DbgInfo) {
-    assert(isa<PointerType>(Base->getType()) &&
-           "Invalid Base ptr type for preserve.union.access.index.");
-    auto *BaseType = Base->getType();
+                                        MDNode *DbgInfo);
 
-    Module *M = BB->getParent()->getParent();
-    Function *FnPreserveUnionAccessIndex = Intrinsic::getDeclaration(
-        M, Intrinsic::preserve_union_access_index, {BaseType, BaseType});
-
-    Value *DIIndex = getInt32(FieldIndex);
-    CallInst *Fn =
-        CreateCall(FnPreserveUnionAccessIndex, {Base, DIIndex});
-    Fn->setMetadata(LLVMContext::MD_preserve_access_index, DbgInfo);
-
-    return Fn;
-  }
-
-  Value *CreatePreserveStructAccessIndex(Value *Base, unsigned Index,
-                                         unsigned FieldIndex, MDNode *DbgInfo) {
-    assert(isa<PointerType>(Base->getType()) &&
-           "Invalid Base ptr type for preserve.struct.access.index.");
-    auto *BaseType = Base->getType();
-
-    Value *GEPIndex = getInt32(Index);
-    Constant *Zero = ConstantInt::get(Type::getInt32Ty(Context), 0);
-    Type *ResultType =
-        GetElementPtrInst::getGEPReturnType(Base, {Zero, GEPIndex});
-
-    Module *M = BB->getParent()->getParent();
-    Function *FnPreserveStructAccessIndex = Intrinsic::getDeclaration(
-        M, Intrinsic::preserve_struct_access_index, {ResultType, BaseType});
-
-    Value *DIIndex = getInt32(FieldIndex);
-    CallInst *Fn = CreateCall(FnPreserveStructAccessIndex,
-                              {Base, GEPIndex, DIIndex});
-    Fn->setMetadata(LLVMContext::MD_preserve_access_index, DbgInfo);
-
-    return Fn;
-  }
+  Value *CreatePreserveStructAccessIndex(Type *ElTy, Value *Base,
+                                         unsigned Index, unsigned FieldIndex,
+                                         MDNode *DbgInfo);
 
 private:
   /// Helper function that creates an assume intrinsic call that
-  /// represents an alignment assumption on the provided Ptr, Mask, Type
-  /// and Offset. It may be sometimes useful to do some other logic
-  /// based on this alignment check, thus it can be stored into 'TheCheck'.
+  /// represents an alignment assumption on the provided pointer \p PtrValue
+  /// with offset \p OffsetValue and alignment value \p AlignValue.
   CallInst *CreateAlignmentAssumptionHelper(const DataLayout &DL,
-                                            Value *PtrValue, Value *Mask,
-                                            Type *IntPtrTy, Value *OffsetValue,
-                                            Value **TheCheck) {
-    Value *PtrIntValue = CreatePtrToInt(PtrValue, IntPtrTy, "ptrint");
-
-    if (OffsetValue) {
-      bool IsOffsetZero = false;
-      if (const auto *CI = dyn_cast<ConstantInt>(OffsetValue))
-        IsOffsetZero = CI->isZero();
-
-      if (!IsOffsetZero) {
-        if (OffsetValue->getType() != IntPtrTy)
-          OffsetValue = CreateIntCast(OffsetValue, IntPtrTy, /*isSigned*/ true,
-                                      "offsetcast");
-        PtrIntValue = CreateSub(PtrIntValue, OffsetValue, "offsetptr");
-      }
-    }
-
-    Value *Zero = ConstantInt::get(IntPtrTy, 0);
-    Value *MaskedPtr = CreateAnd(PtrIntValue, Mask, "maskedptr");
-    Value *InvCond = CreateICmpEQ(MaskedPtr, Zero, "maskcond");
-    if (TheCheck)
-      *TheCheck = InvCond;
-
-    return CreateAssumption(InvCond);
-  }
+                                            Value *PtrValue, Value *AlignValue,
+                                            Value *OffsetValue);
 
 public:
   /// Create an assume intrinsic call that represents an alignment
@@ -2561,23 +2629,9 @@
   /// An optional offset can be provided, and if it is provided, the offset
   /// must be subtracted from the provided pointer to get the pointer with the
   /// specified alignment.
-  ///
-  /// It may be sometimes useful to do some other logic
-  /// based on this alignment check, thus it can be stored into 'TheCheck'.
   CallInst *CreateAlignmentAssumption(const DataLayout &DL, Value *PtrValue,
                                       unsigned Alignment,
-                                      Value *OffsetValue = nullptr,
-                                      Value **TheCheck = nullptr) {
-    assert(isa<PointerType>(PtrValue->getType()) &&
-           "trying to create an alignment assumption on a non-pointer?");
-    assert(Alignment != 0 && "Invalid Alignment");
-    auto *PtrTy = cast<PointerType>(PtrValue->getType());
-    Type *IntPtrTy = getIntPtrTy(DL, PtrTy->getAddressSpace());
-
-    Value *Mask = ConstantInt::get(IntPtrTy, Alignment - 1);
-    return CreateAlignmentAssumptionHelper(DL, PtrValue, Mask, IntPtrTy,
-                                           OffsetValue, TheCheck);
-  }
+                                      Value *OffsetValue = nullptr);
 
   /// Create an assume intrinsic call that represents an alignment
   /// assumption on the provided pointer.
@@ -2586,29 +2640,88 @@
   /// must be subtracted from the provided pointer to get the pointer with the
   /// specified alignment.
   ///
-  /// It may be sometimes useful to do some other logic
-  /// based on this alignment check, thus it can be stored into 'TheCheck'.
-  ///
   /// This overload handles the condition where the Alignment is dependent
   /// on an existing value rather than a static value.
   CallInst *CreateAlignmentAssumption(const DataLayout &DL, Value *PtrValue,
                                       Value *Alignment,
-                                      Value *OffsetValue = nullptr,
-                                      Value **TheCheck = nullptr) {
-    assert(isa<PointerType>(PtrValue->getType()) &&
-           "trying to create an alignment assumption on a non-pointer?");
-    auto *PtrTy = cast<PointerType>(PtrValue->getType());
-    Type *IntPtrTy = getIntPtrTy(DL, PtrTy->getAddressSpace());
+                                      Value *OffsetValue = nullptr);
+};
 
-    if (Alignment->getType() != IntPtrTy)
-      Alignment = CreateIntCast(Alignment, IntPtrTy, /*isSigned*/ false,
-                                "alignmentcast");
+/// This provides a uniform API for creating instructions and inserting
+/// them into a basic block: either at the end of a BasicBlock, or at a specific
+/// iterator location in a block.
+///
+/// Note that the builder does not expose the full generality of LLVM
+/// instructions.  For access to extra instruction properties, use the mutators
+/// (e.g. setVolatile) on the instructions after they have been
+/// created. Convenience state exists to specify fast-math flags and fp-math
+/// tags.
+///
+/// The first template argument specifies a class to use for creating constants.
+/// This defaults to creating minimally folded constants.  The second template
+/// argument allows clients to specify custom insertion hooks that are called on
+/// every newly created insertion.
+template <typename FolderTy = ConstantFolder,
+          typename InserterTy = IRBuilderDefaultInserter>
+class IRBuilder : public IRBuilderBase {
+private:
+  FolderTy Folder;
+  InserterTy Inserter;
 
-    Value *Mask = CreateSub(Alignment, ConstantInt::get(IntPtrTy, 1), "mask");
+public:
+  IRBuilder(LLVMContext &C, FolderTy Folder, InserterTy Inserter = InserterTy(),
+            MDNode *FPMathTag = nullptr,
+            ArrayRef<OperandBundleDef> OpBundles = None)
+      : IRBuilderBase(C, this->Folder, this->Inserter, FPMathTag, OpBundles),
+        Folder(Folder), Inserter(Inserter) {}
 
-    return CreateAlignmentAssumptionHelper(DL, PtrValue, Mask, IntPtrTy,
-                                           OffsetValue, TheCheck);
+  explicit IRBuilder(LLVMContext &C, MDNode *FPMathTag = nullptr,
+                     ArrayRef<OperandBundleDef> OpBundles = None)
+      : IRBuilderBase(C, this->Folder, this->Inserter, FPMathTag, OpBundles) {}
+
+  explicit IRBuilder(BasicBlock *TheBB, FolderTy Folder,
+                     MDNode *FPMathTag = nullptr,
+                     ArrayRef<OperandBundleDef> OpBundles = None)
+      : IRBuilderBase(TheBB->getContext(), this->Folder, this->Inserter,
+                      FPMathTag, OpBundles), Folder(Folder) {
+    SetInsertPoint(TheBB);
   }
+
+  explicit IRBuilder(BasicBlock *TheBB, MDNode *FPMathTag = nullptr,
+                     ArrayRef<OperandBundleDef> OpBundles = None)
+      : IRBuilderBase(TheBB->getContext(), this->Folder, this->Inserter,
+                      FPMathTag, OpBundles) {
+    SetInsertPoint(TheBB);
+  }
+
+  explicit IRBuilder(Instruction *IP, MDNode *FPMathTag = nullptr,
+                     ArrayRef<OperandBundleDef> OpBundles = None)
+      : IRBuilderBase(IP->getContext(), this->Folder, this->Inserter,
+                      FPMathTag, OpBundles) {
+    SetInsertPoint(IP);
+  }
+
+  IRBuilder(BasicBlock *TheBB, BasicBlock::iterator IP, FolderTy Folder,
+            MDNode *FPMathTag = nullptr,
+            ArrayRef<OperandBundleDef> OpBundles = None)
+      : IRBuilderBase(TheBB->getContext(), this->Folder, this->Inserter,
+                      FPMathTag, OpBundles), Folder(Folder) {
+    SetInsertPoint(TheBB, IP);
+  }
+
+  IRBuilder(BasicBlock *TheBB, BasicBlock::iterator IP,
+            MDNode *FPMathTag = nullptr,
+            ArrayRef<OperandBundleDef> OpBundles = None)
+      : IRBuilderBase(TheBB->getContext(), this->Folder, this->Inserter,
+                      FPMathTag, OpBundles) {
+    SetInsertPoint(TheBB, IP);
+  }
+
+  /// Avoid copying the full IRBuilder. Prefer using InsertPointGuard
+  /// or FastMathFlagGuard instead.
+  IRBuilder(const IRBuilder &) = delete;
+
+  InserterTy &getInserter() { return Inserter; }
 };
 
 // Create wrappers for C Binding types (see CBindingWrapping.h).
diff --git a/linux-x64/clang/include/llvm/IR/IRBuilderFolder.h b/linux-x64/clang/include/llvm/IR/IRBuilderFolder.h
new file mode 100644
index 0000000..e781e8e
--- /dev/null
+++ b/linux-x64/clang/include/llvm/IR/IRBuilderFolder.h
@@ -0,0 +1,141 @@
+//===- IRBuilderFolder.h - Const folder interface for IRBuilder -*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines for constant folding interface used by IRBuilder.
+// It is implemented by ConstantFolder (default), TargetFolder and NoFoler.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_IR_IRBUILDERFOLDER_H
+#define LLVM_IR_IRBUILDERFOLDER_H
+
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/IR/InstrTypes.h"
+#include "llvm/IR/Instruction.h"
+
+namespace llvm {
+
+/// IRBuilderFolder - Interface for constant folding in IRBuilder.
+class IRBuilderFolder {
+public:
+  virtual ~IRBuilderFolder();
+
+  //===--------------------------------------------------------------------===//
+  // Binary Operators
+  //===--------------------------------------------------------------------===//
+
+  virtual Value *CreateAdd(Constant *LHS, Constant *RHS,
+                           bool HasNUW = false, bool HasNSW = false) const = 0;
+  virtual Value *CreateFAdd(Constant *LHS, Constant *RHS) const = 0;
+  virtual Value *CreateSub(Constant *LHS, Constant *RHS,
+                           bool HasNUW = false, bool HasNSW = false) const = 0;
+  virtual Value *CreateFSub(Constant *LHS, Constant *RHS) const = 0;
+  virtual Value *CreateMul(Constant *LHS, Constant *RHS,
+                           bool HasNUW = false, bool HasNSW = false) const = 0;
+  virtual Value *CreateFMul(Constant *LHS, Constant *RHS) const = 0;
+  virtual Value *CreateUDiv(Constant *LHS, Constant *RHS,
+                            bool isExact = false) const = 0;
+  virtual Value *CreateSDiv(Constant *LHS, Constant *RHS,
+                            bool isExact = false) const = 0;
+  virtual Value *CreateFDiv(Constant *LHS, Constant *RHS) const = 0;
+  virtual Value *CreateURem(Constant *LHS, Constant *RHS) const = 0;
+  virtual Value *CreateSRem(Constant *LHS, Constant *RHS) const = 0;
+  virtual Value *CreateFRem(Constant *LHS, Constant *RHS) const = 0;
+  virtual Value *CreateShl(Constant *LHS, Constant *RHS,
+                           bool HasNUW = false, bool HasNSW = false) const = 0;
+  virtual Value *CreateLShr(Constant *LHS, Constant *RHS,
+                            bool isExact = false) const = 0;
+  virtual Value *CreateAShr(Constant *LHS, Constant *RHS,
+                            bool isExact = false) const = 0;
+  virtual Value *CreateAnd(Constant *LHS, Constant *RHS) const = 0;
+  virtual Value *CreateOr(Constant *LHS, Constant *RHS) const = 0;
+  virtual Value *CreateXor(Constant *LHS, Constant *RHS) const = 0;
+  virtual Value *CreateBinOp(Instruction::BinaryOps Opc,
+                             Constant *LHS, Constant *RHS) const = 0;
+
+  //===--------------------------------------------------------------------===//
+  // Unary Operators
+  //===--------------------------------------------------------------------===//
+
+  virtual Value *CreateNeg(Constant *C,
+                           bool HasNUW = false, bool HasNSW = false) const = 0;
+  virtual Value *CreateFNeg(Constant *C) const = 0;
+  virtual Value *CreateNot(Constant *C) const = 0;
+  virtual Value *CreateUnOp(Instruction::UnaryOps Opc, Constant *C) const = 0;
+
+  //===--------------------------------------------------------------------===//
+  // Memory Instructions
+  //===--------------------------------------------------------------------===//
+
+  virtual Value *CreateGetElementPtr(Type *Ty, Constant *C,
+                                     ArrayRef<Constant *> IdxList) const = 0;
+  // This form of the function only exists to avoid ambiguous overload
+  // warnings about whether to convert Idx to ArrayRef<Constant *> or
+  // ArrayRef<Value *>.
+  virtual Value *CreateGetElementPtr(Type *Ty, Constant *C,
+                                     Constant *Idx) const = 0;
+  virtual Value *CreateGetElementPtr(Type *Ty, Constant *C,
+                                     ArrayRef<Value *> IdxList) const = 0;
+  virtual Value *CreateInBoundsGetElementPtr(
+      Type *Ty, Constant *C, ArrayRef<Constant *> IdxList) const = 0;
+  // This form of the function only exists to avoid ambiguous overload
+  // warnings about whether to convert Idx to ArrayRef<Constant *> or
+  // ArrayRef<Value *>.
+  virtual Value *CreateInBoundsGetElementPtr(Type *Ty, Constant *C,
+                                             Constant *Idx) const = 0;
+  virtual Value *CreateInBoundsGetElementPtr(
+      Type *Ty, Constant *C, ArrayRef<Value *> IdxList) const = 0;
+
+  //===--------------------------------------------------------------------===//
+  // Cast/Conversion Operators
+  //===--------------------------------------------------------------------===//
+
+  virtual Value *CreateCast(Instruction::CastOps Op, Constant *C,
+                            Type *DestTy) const = 0;
+  virtual Value *CreatePointerCast(Constant *C, Type *DestTy) const = 0;
+  virtual Value *CreatePointerBitCastOrAddrSpaceCast(Constant *C,
+                                                     Type *DestTy) const = 0;
+  virtual Value *CreateIntCast(Constant *C, Type *DestTy,
+                               bool isSigned) const = 0;
+  virtual Value *CreateFPCast(Constant *C, Type *DestTy) const = 0;
+  virtual Value *CreateBitCast(Constant *C, Type *DestTy) const = 0;
+  virtual Value *CreateIntToPtr(Constant *C, Type *DestTy) const = 0;
+  virtual Value *CreatePtrToInt(Constant *C, Type *DestTy) const = 0;
+  virtual Value *CreateZExtOrBitCast(Constant *C, Type *DestTy) const = 0;
+  virtual Value *CreateSExtOrBitCast(Constant *C, Type *DestTy) const = 0;
+  virtual Value *CreateTruncOrBitCast(Constant *C, Type *DestTy) const = 0;
+
+  //===--------------------------------------------------------------------===//
+  // Compare Instructions
+  //===--------------------------------------------------------------------===//
+
+  virtual Value *CreateICmp(CmpInst::Predicate P, Constant *LHS,
+                            Constant *RHS) const = 0;
+  virtual Value *CreateFCmp(CmpInst::Predicate P, Constant *LHS,
+                            Constant *RHS) const = 0;
+
+  //===--------------------------------------------------------------------===//
+  // Other Instructions
+  //===--------------------------------------------------------------------===//
+
+  virtual Value *CreateSelect(Constant *C, Constant *True,
+                              Constant *False) const = 0;
+  virtual Value *CreateExtractElement(Constant *Vec, Constant *Idx) const = 0;
+  virtual Value *CreateInsertElement(Constant *Vec, Constant *NewElt,
+                                     Constant *Idx) const = 0;
+  virtual Value *CreateShuffleVector(Constant *V1, Constant *V2,
+                                     ArrayRef<int> Mask) const = 0;
+  virtual Value *CreateExtractValue(Constant *Agg,
+                                    ArrayRef<unsigned> IdxList) const = 0;
+  virtual Value *CreateInsertValue(Constant *Agg, Constant *Val,
+                                   ArrayRef<unsigned> IdxList) const = 0;
+};
+
+} // end namespace llvm
+
+#endif // LLVM_IR_IRBUILDERFOLDER_H
diff --git a/linux-x64/clang/include/llvm/IR/IRPrintingPasses.h b/linux-x64/clang/include/llvm/IR/IRPrintingPasses.h
index 3be9449..2e62be7 100644
--- a/linux-x64/clang/include/llvm/IR/IRPrintingPasses.h
+++ b/linux-x64/clang/include/llvm/IR/IRPrintingPasses.h
@@ -18,19 +18,12 @@
 #ifndef LLVM_IR_IRPRINTINGPASSES_H
 #define LLVM_IR_IRPRINTINGPASSES_H
 
-#include "llvm/ADT/StringRef.h"
+#include "llvm/IR/PassManager.h"
 #include <string>
 
 namespace llvm {
-class Pass;
-class BasicBlockPass;
-class Function;
-class FunctionPass;
-class Module;
-class ModulePass;
-class PreservedAnalyses;
 class raw_ostream;
-template <typename IRUnitT, typename... ExtraArgTs> class AnalysisManager;
+class StringRef;
 
 /// Create and return a pass that writes the module to the specified
 /// \c raw_ostream.
@@ -43,11 +36,6 @@
 FunctionPass *createPrintFunctionPass(raw_ostream &OS,
                                       const std::string &Banner = "");
 
-/// Create and return a pass that writes the BB to the specified
-/// \c raw_ostream.
-BasicBlockPass *createPrintBasicBlockPass(raw_ostream &OS,
-                                          const std::string &Banner = "");
-
 /// Print out a name of an LLVM value without any prefixes.
 ///
 /// The name is surrounded with ""'s and escaped if it has any special or
@@ -57,27 +45,11 @@
 /// Return true if a pass is for IR printing.
 bool isIRPrintingPass(Pass *P);
 
-/// isFunctionInPrintList - returns true if a function should be printed via
-//  debugging options like -print-after-all/-print-before-all.
-//  Tells if the function IR should be printed by PrinterPass.
-extern bool isFunctionInPrintList(StringRef FunctionName);
-
-/// forcePrintModuleIR - returns true if IR printing passes should
-//  be printing module IR (even for local-pass printers e.g. function-pass)
-//  to provide more context, as enabled by debugging option -print-module-scope
-//  Tells if IR printer should be printing module IR
-extern bool forcePrintModuleIR();
-
-extern bool shouldPrintBeforePass();
-extern bool shouldPrintBeforePass(StringRef);
-extern bool shouldPrintAfterPass();
-extern bool shouldPrintAfterPass(StringRef);
-
 /// Pass for printing a Module as LLVM's text IR assembly.
 ///
 /// Note: This pass is for use with the new pass manager. Use the create...Pass
 /// functions above to create passes for use with the legacy pass manager.
-class PrintModulePass {
+class PrintModulePass : public PassInfoMixin<PrintModulePass> {
   raw_ostream &OS;
   std::string Banner;
   bool ShouldPreserveUseListOrder;
@@ -88,15 +60,14 @@
                   bool ShouldPreserveUseListOrder = false);
 
   PreservedAnalyses run(Module &M, AnalysisManager<Module> &);
-
-  static StringRef name() { return "PrintModulePass"; }
+  static bool isRequired() { return true; }
 };
 
 /// Pass for printing a Function as LLVM's text IR assembly.
 ///
 /// Note: This pass is for use with the new pass manager. Use the create...Pass
 /// functions above to create passes for use with the legacy pass manager.
-class PrintFunctionPass {
+class PrintFunctionPass : public PassInfoMixin<PrintFunctionPass> {
   raw_ostream &OS;
   std::string Banner;
 
@@ -105,10 +76,9 @@
   PrintFunctionPass(raw_ostream &OS, const std::string &Banner = "");
 
   PreservedAnalyses run(Function &F, AnalysisManager<Function> &);
-
-  static StringRef name() { return "PrintFunctionPass"; }
+  static bool isRequired() { return true; }
 };
 
-} // End llvm namespace
+} // namespace llvm
 
 #endif
diff --git a/linux-x64/clang/include/llvm/IR/InlineAsm.h b/linux-x64/clang/include/llvm/IR/InlineAsm.h
index 2aac807..b6f3770 100644
--- a/linux-x64/clang/include/llvm/IR/InlineAsm.h
+++ b/linux-x64/clang/include/llvm/IR/InlineAsm.h
@@ -17,6 +17,7 @@
 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/IR/Value.h"
+#include "llvm/Support/ErrorHandling.h"
 #include <cassert>
 #include <string>
 #include <vector>
@@ -244,6 +245,7 @@
     Constraint_m,
     Constraint_o,
     Constraint_v,
+    Constraint_A,
     Constraint_Q,
     Constraint_R,
     Constraint_S,
@@ -358,6 +360,96 @@
     RC = High - 1;
     return true;
   }
+
+  static std::vector<StringRef> getExtraInfoNames(unsigned ExtraInfo) {
+    std::vector<StringRef> Result;
+    if (ExtraInfo & InlineAsm::Extra_HasSideEffects)
+      Result.push_back("sideeffect");
+    if (ExtraInfo & InlineAsm::Extra_MayLoad)
+      Result.push_back("mayload");
+    if (ExtraInfo & InlineAsm::Extra_MayStore)
+      Result.push_back("maystore");
+    if (ExtraInfo & InlineAsm::Extra_IsConvergent)
+      Result.push_back("isconvergent");
+    if (ExtraInfo & InlineAsm::Extra_IsAlignStack)
+      Result.push_back("alignstack");
+
+    AsmDialect Dialect =
+        InlineAsm::AsmDialect((ExtraInfo & InlineAsm::Extra_AsmDialect));
+
+    if (Dialect == InlineAsm::AD_ATT)
+      Result.push_back("attdialect");
+    if (Dialect == InlineAsm::AD_Intel)
+      Result.push_back("inteldialect");
+
+    return Result;
+  }
+
+  static StringRef getKindName(unsigned Kind) {
+    switch (Kind) {
+    case InlineAsm::Kind_RegUse:
+      return "reguse";
+    case InlineAsm::Kind_RegDef:
+      return "regdef";
+    case InlineAsm::Kind_RegDefEarlyClobber:
+      return "regdef-ec";
+    case InlineAsm::Kind_Clobber:
+      return "clobber";
+    case InlineAsm::Kind_Imm:
+      return "imm";
+    case InlineAsm::Kind_Mem:
+      return "mem";
+    default:
+      llvm_unreachable("Unknown operand kind");
+    }
+  }
+
+  static StringRef getMemConstraintName(unsigned Constraint) {
+    switch (Constraint) {
+    case InlineAsm::Constraint_es:
+      return "es";
+    case InlineAsm::Constraint_i:
+      return "i";
+    case InlineAsm::Constraint_m:
+      return "m";
+    case InlineAsm::Constraint_o:
+      return "o";
+    case InlineAsm::Constraint_v:
+      return "v";
+    case InlineAsm::Constraint_Q:
+      return "Q";
+    case InlineAsm::Constraint_R:
+      return "R";
+    case InlineAsm::Constraint_S:
+      return "S";
+    case InlineAsm::Constraint_T:
+      return "T";
+    case InlineAsm::Constraint_Um:
+      return "Um";
+    case InlineAsm::Constraint_Un:
+      return "Un";
+    case InlineAsm::Constraint_Uq:
+      return "Uq";
+    case InlineAsm::Constraint_Us:
+      return "Us";
+    case InlineAsm::Constraint_Ut:
+      return "Ut";
+    case InlineAsm::Constraint_Uv:
+      return "Uv";
+    case InlineAsm::Constraint_Uy:
+      return "Uy";
+    case InlineAsm::Constraint_X:
+      return "X";
+    case InlineAsm::Constraint_Z:
+      return "Z";
+    case InlineAsm::Constraint_ZC:
+      return "ZC";
+    case InlineAsm::Constraint_Zy:
+      return "Zy";
+    default:
+      llvm_unreachable("Unknown memory constraint");
+    }
+  }
 };
 
 } // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/IR/InstVisitor.h b/linux-x64/clang/include/llvm/IR/InstVisitor.h
index fbeb2ca..4dbdc66 100644
--- a/linux-x64/clang/include/llvm/IR/InstVisitor.h
+++ b/linux-x64/clang/include/llvm/IR/InstVisitor.h
@@ -10,7 +10,6 @@
 #ifndef LLVM_IR_INSTVISITOR_H
 #define LLVM_IR_INSTVISITOR_H
 
-#include "llvm/IR/CallSite.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/IntrinsicInst.h"
@@ -199,6 +198,7 @@
   RetTy visitFuncletPadInst(FuncletPadInst &I) { DELEGATE(Instruction); }
   RetTy visitCleanupPadInst(CleanupPadInst &I) { DELEGATE(FuncletPadInst); }
   RetTy visitCatchPadInst(CatchPadInst &I)     { DELEGATE(FuncletPadInst); }
+  RetTy visitFreezeInst(FreezeInst &I)         { DELEGATE(Instruction); }
 
   // Handle the special instrinsic instruction classes.
   RetTy visitDbgDeclareInst(DbgDeclareInst &I)    { DELEGATE(DbgVariableIntrinsic);}
@@ -216,18 +216,9 @@
   RetTy visitVAEndInst(VAEndInst &I)              { DELEGATE(IntrinsicInst); }
   RetTy visitVACopyInst(VACopyInst &I)            { DELEGATE(IntrinsicInst); }
   RetTy visitIntrinsicInst(IntrinsicInst &I)      { DELEGATE(CallInst); }
-
-  // Call, Invoke and CallBr are slightly different as they delegate first
-  // through a generic CallSite visitor.
-  RetTy visitCallInst(CallInst &I) {
-    return static_cast<SubClass*>(this)->visitCallSite(&I);
-  }
-  RetTy visitInvokeInst(InvokeInst &I) {
-    return static_cast<SubClass*>(this)->visitCallSite(&I);
-  }
-  RetTy visitCallBrInst(CallBrInst &I) {
-    return static_cast<SubClass *>(this)->visitCallSite(&I);
-  }
+  RetTy visitCallInst(CallInst &I)                { DELEGATE(CallBase); }
+  RetTy visitInvokeInst(InvokeInst &I)            { DELEGATE(CallBase); }
+  RetTy visitCallBrInst(CallBrInst &I)            { DELEGATE(CallBase); }
 
   // While terminators don't have a distinct type modeling them, we support
   // intercepting them with dedicated a visitor callback.
@@ -279,16 +270,6 @@
     DELEGATE(Instruction);
   }
 
-  // Provide a legacy visitor for a 'callsite' that visits calls, invokes,
-  // and calbrs.
-  //
-  // Prefer overriding the type system based `CallBase` instead.
-  RetTy visitCallSite(CallSite CS) {
-    assert(CS);
-    Instruction &I = *CS.getInstruction();
-    DELEGATE(CallBase);
-  }
-
   // If the user wants a 'default' case, they can choose to override this
   // function.  If this function is not overloaded in the user's subclass, then
   // this instruction just gets ignored.
diff --git a/linux-x64/clang/include/llvm/IR/InstrTypes.h b/linux-x64/clang/include/llvm/IR/InstrTypes.h
index ca419b5..631665e 100644
--- a/linux-x64/clang/include/llvm/IR/InstrTypes.h
+++ b/linux-x64/clang/include/llvm/IR/InstrTypes.h
@@ -47,7 +47,7 @@
 namespace llvm {
 
 namespace Intrinsic {
-enum ID : unsigned;
+typedef unsigned ID;
 }
 
 //===----------------------------------------------------------------------===//
@@ -154,18 +154,20 @@
   }
 #include "llvm/IR/Instruction.def"
 
-  static UnaryOperator *CreateWithCopiedFlags(UnaryOps Opc,
-                                              Value *V,
-                                              Instruction *CopyO,
-                                              const Twine &Name = "") {
-    UnaryOperator *UO = Create(Opc, V, Name);
+  static UnaryOperator *
+  CreateWithCopiedFlags(UnaryOps Opc, Value *V, Instruction *CopyO,
+                        const Twine &Name = "",
+                        Instruction *InsertBefore = nullptr) {
+    UnaryOperator *UO = Create(Opc, V, Name, InsertBefore);
     UO->copyIRFlags(CopyO);
     return UO;
   }
 
   static UnaryOperator *CreateFNegFMF(Value *Op, Instruction *FMFSource,
-                                      const Twine &Name = "") {
-    return CreateWithCopiedFlags(Instruction::FNeg, Op, FMFSource, Name);
+                                      const Twine &Name = "",
+                                      Instruction *InsertBefore = nullptr) {
+    return CreateWithCopiedFlags(Instruction::FNeg, Op, FMFSource, Name,
+                                 InsertBefore);
   }
 
   UnaryOps getOpcode() const {
@@ -280,11 +282,6 @@
                                        const Twine &Name = "") {
     return CreateWithCopiedFlags(Instruction::FRem, V1, V2, FMFSource, Name);
   }
-  static BinaryOperator *CreateFNegFMF(Value *Op, Instruction *FMFSource,
-                                       const Twine &Name = "") {
-    Value *Zero = ConstantFP::getNegativeZero(Op->getType());
-    return CreateWithCopiedFlags(Instruction::FSub, Zero, Op, FMFSource, Name);
-  }
 
   static BinaryOperator *CreateNSW(BinaryOps Opc, Value *V1, Value *V2,
                                    const Twine &Name = "") {
@@ -390,10 +387,6 @@
                                       Instruction *InsertBefore = nullptr);
   static BinaryOperator *CreateNUWNeg(Value *Op, const Twine &Name,
                                       BasicBlock *InsertAtEnd);
-  static BinaryOperator *CreateFNeg(Value *Op, const Twine &Name = "",
-                                    Instruction *InsertBefore = nullptr);
-  static BinaryOperator *CreateFNeg(Value *Op, const Twine &Name,
-                                    BasicBlock *InsertAtEnd);
   static BinaryOperator *CreateNot(Value *Op, const Twine &Name = "",
                                    Instruction *InsertBefore = nullptr);
   static BinaryOperator *CreateNot(Value *Op, const Twine &Name,
@@ -606,12 +599,6 @@
     BasicBlock *InsertAtEnd  ///< The block to insert the instruction into
   );
 
-  /// Check whether it is valid to call getCastOpcode for these types.
-  static bool isCastable(
-    Type *SrcTy, ///< The Type from which the value should be cast.
-    Type *DestTy ///< The Type to which the value should be cast.
-  );
-
   /// Check whether a bitcast between these types is valid
   static bool isBitCastable(
     Type *SrcTy, ///< The Type from which the value should be cast.
@@ -657,8 +644,8 @@
   /// DataLayout argument is to determine the pointer size when examining casts
   /// involving Integer and Pointer types. They are no-op casts if the integer
   /// is the same size as the pointer. However, pointer size varies with
-  /// platform.
-  /// Determine if the described cast is a no-op cast.
+  /// platform.  Note that a precondition of this method is that the cast is
+  /// legal - i.e. the instruction formed with these operands would verify.
   static bool isNoopCast(
     Instruction::CastOps Opcode, ///< Opcode of cast
     Type *SrcTy,         ///< SrcTy of cast
@@ -698,11 +685,14 @@
   /// Return the destination type, as a convenience
   Type* getDestTy() const { return getType(); }
 
-  /// This method can be used to determine if a cast from S to DstTy using
+  /// This method can be used to determine if a cast from SrcTy to DstTy using
   /// Opcode op is valid or not.
   /// @returns true iff the proposed cast is valid.
   /// Determine if a cast is valid without creating one.
-  static bool castIsValid(Instruction::CastOps op, Value *S, Type *DstTy);
+  static bool castIsValid(Instruction::CastOps op, Type *SrcTy, Type *DstTy);
+  static bool castIsValid(Instruction::CastOps op, Value *S, Type *DstTy) {
+    return castIsValid(op, S->getType(), DstTy);
+  }
 
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Instruction *I) {
@@ -729,41 +719,43 @@
   /// Some passes (e.g. InstCombine) depend on the bit-wise characteristics of
   /// FCMP_* values. Changing the bit patterns requires a potential change to
   /// those passes.
-  enum Predicate {
-    // Opcode              U L G E    Intuitive operation
-    FCMP_FALSE =  0,  ///< 0 0 0 0    Always false (always folded)
-    FCMP_OEQ   =  1,  ///< 0 0 0 1    True if ordered and equal
-    FCMP_OGT   =  2,  ///< 0 0 1 0    True if ordered and greater than
-    FCMP_OGE   =  3,  ///< 0 0 1 1    True if ordered and greater than or equal
-    FCMP_OLT   =  4,  ///< 0 1 0 0    True if ordered and less than
-    FCMP_OLE   =  5,  ///< 0 1 0 1    True if ordered and less than or equal
-    FCMP_ONE   =  6,  ///< 0 1 1 0    True if ordered and operands are unequal
-    FCMP_ORD   =  7,  ///< 0 1 1 1    True if ordered (no nans)
-    FCMP_UNO   =  8,  ///< 1 0 0 0    True if unordered: isnan(X) | isnan(Y)
-    FCMP_UEQ   =  9,  ///< 1 0 0 1    True if unordered or equal
-    FCMP_UGT   = 10,  ///< 1 0 1 0    True if unordered or greater than
-    FCMP_UGE   = 11,  ///< 1 0 1 1    True if unordered, greater than, or equal
-    FCMP_ULT   = 12,  ///< 1 1 0 0    True if unordered or less than
-    FCMP_ULE   = 13,  ///< 1 1 0 1    True if unordered, less than, or equal
-    FCMP_UNE   = 14,  ///< 1 1 1 0    True if unordered or not equal
-    FCMP_TRUE  = 15,  ///< 1 1 1 1    Always true (always folded)
+  enum Predicate : unsigned {
+    // Opcode            U L G E    Intuitive operation
+    FCMP_FALSE = 0, ///< 0 0 0 0    Always false (always folded)
+    FCMP_OEQ = 1,   ///< 0 0 0 1    True if ordered and equal
+    FCMP_OGT = 2,   ///< 0 0 1 0    True if ordered and greater than
+    FCMP_OGE = 3,   ///< 0 0 1 1    True if ordered and greater than or equal
+    FCMP_OLT = 4,   ///< 0 1 0 0    True if ordered and less than
+    FCMP_OLE = 5,   ///< 0 1 0 1    True if ordered and less than or equal
+    FCMP_ONE = 6,   ///< 0 1 1 0    True if ordered and operands are unequal
+    FCMP_ORD = 7,   ///< 0 1 1 1    True if ordered (no nans)
+    FCMP_UNO = 8,   ///< 1 0 0 0    True if unordered: isnan(X) | isnan(Y)
+    FCMP_UEQ = 9,   ///< 1 0 0 1    True if unordered or equal
+    FCMP_UGT = 10,  ///< 1 0 1 0    True if unordered or greater than
+    FCMP_UGE = 11,  ///< 1 0 1 1    True if unordered, greater than, or equal
+    FCMP_ULT = 12,  ///< 1 1 0 0    True if unordered or less than
+    FCMP_ULE = 13,  ///< 1 1 0 1    True if unordered, less than, or equal
+    FCMP_UNE = 14,  ///< 1 1 1 0    True if unordered or not equal
+    FCMP_TRUE = 15, ///< 1 1 1 1    Always true (always folded)
     FIRST_FCMP_PREDICATE = FCMP_FALSE,
     LAST_FCMP_PREDICATE = FCMP_TRUE,
     BAD_FCMP_PREDICATE = FCMP_TRUE + 1,
-    ICMP_EQ    = 32,  ///< equal
-    ICMP_NE    = 33,  ///< not equal
-    ICMP_UGT   = 34,  ///< unsigned greater than
-    ICMP_UGE   = 35,  ///< unsigned greater or equal
-    ICMP_ULT   = 36,  ///< unsigned less than
-    ICMP_ULE   = 37,  ///< unsigned less or equal
-    ICMP_SGT   = 38,  ///< signed greater than
-    ICMP_SGE   = 39,  ///< signed greater or equal
-    ICMP_SLT   = 40,  ///< signed less than
-    ICMP_SLE   = 41,  ///< signed less or equal
+    ICMP_EQ = 32,  ///< equal
+    ICMP_NE = 33,  ///< not equal
+    ICMP_UGT = 34, ///< unsigned greater than
+    ICMP_UGE = 35, ///< unsigned greater or equal
+    ICMP_ULT = 36, ///< unsigned less than
+    ICMP_ULE = 37, ///< unsigned less or equal
+    ICMP_SGT = 38, ///< signed greater than
+    ICMP_SGE = 39, ///< signed greater or equal
+    ICMP_SLT = 40, ///< signed less than
+    ICMP_SLE = 41, ///< signed less or equal
     FIRST_ICMP_PREDICATE = ICMP_EQ,
     LAST_ICMP_PREDICATE = ICMP_SLE,
     BAD_ICMP_PREDICATE = ICMP_SLE + 1
   };
+  using PredicateField =
+      Bitfield::Element<Predicate, 0, 6, LAST_ICMP_PREDICATE>;
 
 protected:
   CmpInst(Type *ty, Instruction::OtherOps op, Predicate pred,
@@ -804,15 +796,15 @@
   }
 
   /// Return the predicate for this instruction.
-  Predicate getPredicate() const {
-    return Predicate(getSubclassDataFromInstruction());
-  }
+  Predicate getPredicate() const { return getSubclassData<PredicateField>(); }
 
   /// Set the predicate for this instruction to the specified value.
-  void setPredicate(Predicate P) { setInstructionSubclassData(P); }
+  void setPredicate(Predicate P) { setSubclassData<PredicateField>(P); }
 
   static bool isFPPredicate(Predicate P) {
-    return P >= FIRST_FCMP_PREDICATE && P <= LAST_FCMP_PREDICATE;
+    assert(FIRST_FCMP_PREDICATE == 0 &&
+           "FIRST_FCMP_PREDICATE is required to be 0");
+    return P <= LAST_FCMP_PREDICATE;
   }
 
   static bool isIntPredicate(Predicate P) {
@@ -853,20 +845,38 @@
   /// Return the predicate as if the operands were swapped.
   static Predicate getSwappedPredicate(Predicate pred);
 
-  /// For predicate of kind "is X or equal to 0" returns the predicate "is X".
-  /// For predicate of kind "is X" returns the predicate "is X or equal to 0".
-  /// does not support other kind of predicates.
-  /// @returns the predicate that does not contains is equal to zero if
-  /// it had and vice versa.
-  /// Return the flipped strictness of predicate
-  Predicate getFlippedStrictnessPredicate() const {
-    return getFlippedStrictnessPredicate(getPredicate());
+  /// This is a static version that you can use without an instruction
+  /// available.
+  /// @returns true if the comparison predicate is strict, false otherwise.
+  static bool isStrictPredicate(Predicate predicate);
+
+  /// @returns true if the comparison predicate is strict, false otherwise.
+  /// Determine if this instruction is using an strict comparison predicate.
+  bool isStrictPredicate() const { return isStrictPredicate(getPredicate()); }
+
+  /// This is a static version that you can use without an instruction
+  /// available.
+  /// @returns true if the comparison predicate is non-strict, false otherwise.
+  static bool isNonStrictPredicate(Predicate predicate);
+
+  /// @returns true if the comparison predicate is non-strict, false otherwise.
+  /// Determine if this instruction is using an non-strict comparison predicate.
+  bool isNonStrictPredicate() const {
+    return isNonStrictPredicate(getPredicate());
+  }
+
+  /// For example, SGE -> SGT, SLE -> SLT, ULE -> ULT, UGE -> UGT.
+  /// Returns the strict version of non-strict comparisons.
+  Predicate getStrictPredicate() const {
+    return getStrictPredicate(getPredicate());
   }
 
   /// This is a static version that you can use without an instruction
   /// available.
-  /// Return the flipped strictness of predicate
-  static Predicate getFlippedStrictnessPredicate(Predicate pred);
+  /// @returns the strict version of comparison provided in \p pred.
+  /// If \p pred is not a strict comparison predicate, returns \p pred.
+  /// Returns the strict version of non-strict comparisons.
+  static Predicate getStrictPredicate(Predicate pred);
 
   /// For example, SGT -> SGE, SLT -> SLE, ULT -> ULE, UGT -> UGE.
   /// Returns the non-strict version of strict comparisons.
@@ -881,6 +891,21 @@
   /// Returns the non-strict version of strict comparisons.
   static Predicate getNonStrictPredicate(Predicate pred);
 
+  /// This is a static version that you can use without an instruction
+  /// available.
+  /// Return the flipped strictness of predicate
+  static Predicate getFlippedStrictnessPredicate(Predicate pred);
+
+  /// For predicate of kind "is X or equal to 0" returns the predicate "is X".
+  /// For predicate of kind "is X" returns the predicate "is X or equal to 0".
+  /// does not support other kind of predicates.
+  /// @returns the predicate that does not contains is equal to zero if
+  /// it had and vice versa.
+  /// Return the flipped strictness of predicate
+  Predicate getFlippedStrictnessPredicate() const {
+    return getFlippedStrictnessPredicate(getPredicate());
+  }
+
   /// Provide more efficient getOperand methods.
   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
 
@@ -893,9 +918,19 @@
   /// Determine if this CmpInst is commutative.
   bool isCommutative() const;
 
-  /// This is just a convenience that dispatches to the subclasses.
   /// Determine if this is an equals/not equals predicate.
-  bool isEquality() const;
+  /// This is a static version that you can use without an instruction
+  /// available.
+  static bool isEquality(Predicate pred);
+
+  /// Determine if this is an equals/not equals predicate.
+  bool isEquality() const { return isEquality(getPredicate()); }
+
+  /// Return true if the predicate is relational (not EQ or NE).
+  static bool isRelational(Predicate P) { return !isEquality(P); }
+
+  /// Return true if the predicate is relational (not EQ or NE).
+  bool isRelational() const { return !isEquality(); }
 
   /// @returns true if the comparison is signed, false otherwise.
   /// Determine if this instruction is using a signed comparison.
@@ -922,6 +957,30 @@
     return getSignedPredicate(getPredicate());
   }
 
+  /// For example, SLT->ULT, SLE->ULE, SGT->UGT, SGE->UGE, ULT->Failed assert
+  /// @returns the unsigned version of the signed predicate pred.
+  static Predicate getUnsignedPredicate(Predicate pred);
+
+  /// For example, SLT->ULT, SLE->ULE, SGT->UGT, SGE->UGE, ULT->Failed assert
+  /// @returns the unsigned version of the predicate for this instruction (which
+  /// has to be an signed predicate).
+  /// return the unsigned version of a predicate
+  Predicate getUnsignedPredicate() {
+    return getUnsignedPredicate(getPredicate());
+  }
+
+  /// For example, SLT->ULT, ULT->SLT, SLE->ULE, ULE->SLE, EQ->Failed assert
+  /// @returns the unsigned version of the signed predicate pred or
+  ///          the signed version of the signed predicate pred.
+  static Predicate getFlippedSignednessPredicate(Predicate pred);
+
+  /// For example, SLT->ULT, ULT->SLT, SLE->ULE, ULE->SLE, EQ->Failed assert
+  /// @returns the unsigned version of the signed predicate pred or
+  ///          the signed version of the signed predicate pred.
+  Predicate getFlippedSignednessPredicate() {
+    return getFlippedSignednessPredicate(getPredicate());
+  }
+
   /// This is just a convenience.
   /// Determine if this is true when both operands are the same.
   bool isTrueWhenEqual() const {
@@ -975,7 +1034,7 @@
   static Type* makeCmpResultType(Type* opnd_type) {
     if (VectorType* vt = dyn_cast<VectorType>(opnd_type)) {
       return VectorType::get(Type::getInt1Ty(opnd_type->getContext()),
-                             vt->getNumElements());
+                             vt->getElementCount());
     }
     return Type::getInt1Ty(opnd_type->getContext());
   }
@@ -1039,6 +1098,11 @@
     return getTagID() == LLVMContext::OB_funclet;
   }
 
+  /// Return true if this is a "cfguardtarget" operand bundle.
+  bool isCFGuardTargetOperandBundle() const {
+    return getTagID() == LLVMContext::OB_cfguardtarget;
+  }
+
 private:
   /// Pointer to an entry in LLVMContextImpl::getOrInsertBundleTag.
   StringMapEntry<uint32_t> *Tag;
@@ -1061,8 +1125,8 @@
       : Tag(std::move(Tag)), Inputs(Inputs) {}
 
   explicit OperandBundleDefT(const OperandBundleUse &OBU) {
-    Tag = OBU.getTagName();
-    Inputs.insert(Inputs.end(), OBU.Inputs.begin(), OBU.Inputs.end());
+    Tag = std::string(OBU.getTagName());
+    llvm::append_range(Inputs, OBU.Inputs);
   }
 
   ArrayRef<InputTy> inputs() const { return Inputs; }
@@ -1099,6 +1163,15 @@
 /// as cheap as most other operations on the base class.
 class CallBase : public Instruction {
 protected:
+  // The first two bits are reserved by CallInst for fast retrieval,
+  using CallInstReservedField = Bitfield::Element<unsigned, 0, 2>;
+  using CallingConvField =
+      Bitfield::Element<CallingConv::ID, CallInstReservedField::NextBit, 10,
+                        CallingConv::MaxID>;
+  static_assert(
+      Bitfield::areContiguous<CallInstReservedField, CallingConvField>(),
+      "Bitfields must be contiguous");
+
   /// The last operand is the called operand.
   static constexpr int CalledOperandOpEndIdx = -1;
 
@@ -1132,6 +1205,15 @@
 public:
   using Instruction::getContext;
 
+  /// Create a clone of \p CB with a different set of operand bundles and
+  /// insert it before \p InsertPt.
+  ///
+  /// The returned call instruction is identical \p CB in every way except that
+  /// the operand bundles for the new instruction are set to the operand bundles
+  /// in \p Bundles.
+  static CallBase *Create(CallBase *CB, ArrayRef<OperandBundleDef> Bundles,
+                          Instruction *InsertPt = nullptr);
+
   static bool classof(const Instruction *I) {
     return I->getOpcode() == Instruction::Call ||
            I->getOpcode() == Instruction::Invoke ||
@@ -1267,18 +1349,27 @@
     return isArgOperand(&UI.getUse());
   }
 
+  /// Given a use for a arg operand, get the arg operand number that
+  /// corresponds to it.
+  unsigned getArgOperandNo(const Use *U) const {
+    assert(isArgOperand(U) && "Arg operand # out of range!");
+    return U - arg_begin();
+  }
+
+  /// Given a value use iterator, return the arg operand number corresponding to
+  /// it. Iterator must actually correspond to a data operand.
+  unsigned getArgOperandNo(Value::const_user_iterator UI) const {
+    return getArgOperandNo(&UI.getUse());
+  }
+
   /// Returns true if this CallSite passes the given Value* as an argument to
   /// the called function.
   bool hasArgument(const Value *V) const {
-    return llvm::any_of(args(), [V](const Value *Arg) { return Arg == V; });
+    return llvm::is_contained(args(), V);
   }
 
   Value *getCalledOperand() const { return Op<CalledOperandOpEndIdx>(); }
 
-  // DEPRECATED: This routine will be removed in favor of `getCalledOperand` in
-  // the near future.
-  Value *getCalledValue() const { return getCalledOperand(); }
-
   const Use &getCalledOperandUse() const { return Op<CalledOperandOpEndIdx>(); }
   Use &getCalledOperandUse() { return Op<CalledOperandOpEndIdx>(); }
 
@@ -1342,14 +1433,11 @@
   }
 
   CallingConv::ID getCallingConv() const {
-    return static_cast<CallingConv::ID>(getSubclassDataFromInstruction() >> 2);
+    return getSubclassData<CallingConvField>();
   }
 
   void setCallingConv(CallingConv::ID CC) {
-    auto ID = static_cast<unsigned>(CC);
-    assert(!(ID & ~CallingConv::MaxID) && "Unsupported calling convention");
-    setInstructionSubclassData((getSubclassDataFromInstruction() & 3) |
-                               (ID << 2));
+    setSubclassData<CallingConvField>(CC);
   }
 
   /// Check if this call is an inline asm statement.
@@ -1369,14 +1457,18 @@
   ///
   void setAttributes(AttributeList A) { Attrs = A; }
 
-  /// Determine whether this call has the given attribute.
+  /// Determine whether this call has the given attribute. If it does not
+  /// then determine if the called function has the attribute, but only if
+  /// the attribute is allowed for the call.
   bool hasFnAttr(Attribute::AttrKind Kind) const {
     assert(Kind != Attribute::NoBuiltin &&
            "Use CallBase::isNoBuiltin() to check for Attribute::NoBuiltin");
     return hasFnAttrImpl(Kind);
   }
 
-  /// Determine whether this call has the given attribute.
+  /// Determine whether this call has the given attribute. If it does not
+  /// then determine if the called function has the attribute, but only if
+  /// the attribute is allowed for the call.
   bool hasFnAttr(StringRef Kind) const { return hasFnAttrImpl(Kind); }
 
   /// adds the attribute to the list of attributes.
@@ -1423,6 +1515,12 @@
     setAttributes(PAL);
   }
 
+  void removeAttributes(unsigned i, const AttrBuilder &Attrs) {
+    AttributeList PAL = getAttributes();
+    PAL = PAL.removeAttributes(getContext(), i, Attrs);
+    setAttributes(PAL);
+  }
+
   /// Removes the attribute from the given argument
   void removeParamAttr(unsigned ArgNo, Attribute::AttrKind Kind) {
     assert(ArgNo < getNumArgOperands() && "Out of bounds");
@@ -1455,7 +1553,11 @@
   }
 
   /// Determine whether the return value has the given attribute.
-  bool hasRetAttr(Attribute::AttrKind Kind) const;
+  bool hasRetAttr(Attribute::AttrKind Kind) const {
+    return hasRetAttrImpl(Kind);
+  }
+  /// Determine whether the return value has the given attribute.
+  bool hasRetAttr(StringRef Kind) const { return hasRetAttrImpl(Kind); }
 
   /// Determine whether the argument or parameter has the given attribute.
   bool paramHasAttr(unsigned ArgNo, Attribute::AttrKind Kind) const;
@@ -1534,10 +1636,12 @@
     return paramHasAttr(ArgNo, Attribute::InAlloca);
   }
 
-  /// Determine whether this argument is passed by value or in an alloca.
-  bool isByValOrInAllocaArgument(unsigned ArgNo) const {
+  /// Determine whether this argument is passed by value, in an alloca, or is
+  /// preallocated.
+  bool isPassPointeeByValueArgument(unsigned ArgNo) const {
     return paramHasAttr(ArgNo, Attribute::ByVal) ||
-           paramHasAttr(ArgNo, Attribute::InAlloca);
+           paramHasAttr(ArgNo, Attribute::InAlloca) ||
+           paramHasAttr(ArgNo, Attribute::Preallocated);
   }
 
   /// Determine if there are is an inalloca argument. Only the last argument can
@@ -1566,11 +1670,26 @@
            dataOperandHasImpliedAttr(OpNo + 1, Attribute::ReadNone);
   }
 
+  LLVM_ATTRIBUTE_DEPRECATED(unsigned getRetAlignment() const,
+                            "Use getRetAlign() instead") {
+    if (const auto MA = Attrs.getRetAlignment())
+      return MA->value();
+    return 0;
+  }
+
   /// Extract the alignment of the return value.
-  unsigned getRetAlignment() const { return Attrs.getRetAlignment(); }
+  MaybeAlign getRetAlign() const { return Attrs.getRetAlignment(); }
 
   /// Extract the alignment for a call or parameter (0=unknown).
-  unsigned getParamAlignment(unsigned ArgNo) const {
+  LLVM_ATTRIBUTE_DEPRECATED(unsigned getParamAlignment(unsigned ArgNo) const,
+                            "Use getParamAlign() instead") {
+    if (const auto MA = Attrs.getParamAlignment(ArgNo))
+      return MA->value();
+    return 0;
+  }
+
+  /// Extract the alignment for a call or parameter (0=unknown).
+  MaybeAlign getParamAlign(unsigned ArgNo) const {
     return Attrs.getParamAlignment(ArgNo);
   }
 
@@ -1580,6 +1699,12 @@
     return Ty ? Ty : getArgOperand(ArgNo)->getType()->getPointerElementType();
   }
 
+  /// Extract the preallocated type for a call or parameter.
+  Type *getParamPreallocatedType(unsigned ArgNo) const {
+    Type *Ty = Attrs.getParamPreallocatedType(ArgNo);
+    return Ty ? Ty : getArgOperand(ArgNo)->getType()->getPointerElementType();
+  }
+
   /// Extract the number of dereferenceable bytes for a call or
   /// parameter (0=unknown).
   uint64_t getDereferenceableBytes(unsigned i) const {
@@ -1691,6 +1816,12 @@
     addAttribute(AttributeList::FunctionIndex, Attribute::NoDuplicate);
   }
 
+  /// Determine if the call cannot be tail merged.
+  bool cannotMerge() const { return hasFnAttr(Attribute::NoMerge); }
+  void setCannotMerge() {
+    addAttribute(AttributeList::FunctionIndex, Attribute::NoMerge);
+  }
+
   /// Determine if the invoke is convergent
   bool isConvergent() const { return hasFnAttr(Attribute::Convergent); }
   void setConvergent() {
@@ -1840,10 +1971,7 @@
   /// OperandBundleUser to a vector of OperandBundleDefs.  Note:
   /// OperandBundeUses and OperandBundleDefs are non-trivially *different*
   /// representations of operand bundles (see documentation above).
-  void getOperandBundlesAsDefs(SmallVectorImpl<OperandBundleDef> &Defs) const {
-    for (unsigned i = 0, e = getNumOperandBundles(); i != e; ++i)
-      Defs.emplace_back(getOperandBundleAt(i));
-  }
+  void getOperandBundlesAsDefs(SmallVectorImpl<OperandBundleDef> &Defs) const;
 
   /// Return the operand bundle for the operand at index OpIdx.
   ///
@@ -1911,7 +2039,7 @@
   /// Is the function attribute S disallowed by some operand bundle on
   /// this operand bundle user?
   bool isFnAttrDisallowedByOpBundle(StringRef S) const {
-    // Operand bundles only possibly disallow readnone, readonly and argmenonly
+    // Operand bundles only possibly disallow readnone, readonly and argmemonly
     // attributes.  All String attributes are fine.
     return false;
   }
@@ -2071,16 +2199,14 @@
   op_iterator populateBundleOperandInfos(ArrayRef<OperandBundleDef> Bundles,
                                          const unsigned BeginIndex);
 
+public:
   /// Return the BundleOpInfo for the operand at index OpIdx.
   ///
   /// It is an error to call this with an OpIdx that does not correspond to an
   /// bundle operand.
+  BundleOpInfo &getBundleOpInfoForOperand(unsigned OpIdx);
   const BundleOpInfo &getBundleOpInfoForOperand(unsigned OpIdx) const {
-    for (auto &BOI : bundle_op_infos())
-      if (BOI.Begin <= OpIdx && OpIdx < BOI.End)
-        return BOI;
-
-    llvm_unreachable("Did not find operand bundle for operand!");
+    return const_cast<CallBase *>(this)->getBundleOpInfoForOperand(OpIdx);
   }
 
 protected:
@@ -2100,7 +2226,7 @@
   bool hasFnAttrOnCalledFunction(StringRef Kind) const;
 
   template <typename AttrKind> bool hasFnAttrImpl(AttrKind Kind) const {
-    if (Attrs.hasAttribute(AttributeList::FunctionIndex, Kind))
+    if (Attrs.hasFnAttribute(Kind))
       return true;
 
     // Operand bundles override attributes on the called function, but don't
@@ -2110,6 +2236,18 @@
 
     return hasFnAttrOnCalledFunction(Kind);
   }
+
+  /// Determine whether the return value has the given attribute. Supports
+  /// Attribute::AttrKind and StringRef as \p AttrKind types.
+  template <typename AttrKind> bool hasRetAttrImpl(AttrKind Kind) const {
+    if (Attrs.hasAttribute(AttributeList::ReturnIndex, Kind))
+      return true;
+
+    // Look at the callee, if available.
+    if (const Function *F = getCalledFunction())
+      return F->getAttributes().hasAttribute(AttributeList::ReturnIndex, Kind);
+    return false;
+  }
 };
 
 template <>
diff --git a/linux-x64/clang/include/llvm/IR/Instruction.def b/linux-x64/clang/include/llvm/IR/Instruction.def
index 41cdf61..a5ad92f 100644
--- a/linux-x64/clang/include/llvm/IR/Instruction.def
+++ b/linux-x64/clang/include/llvm/IR/Instruction.def
@@ -217,7 +217,8 @@
 HANDLE_OTHER_INST(64, ExtractValue, ExtractValueInst)// extract from aggregate
 HANDLE_OTHER_INST(65, InsertValue, InsertValueInst)  // insert into aggregate
 HANDLE_OTHER_INST(66, LandingPad, LandingPadInst)  // Landing pad instruction.
-  LAST_OTHER_INST(66)
+HANDLE_OTHER_INST(67, Freeze, FreezeInst) // Freeze instruction.
+  LAST_OTHER_INST(67)
 
 #undef  FIRST_TERM_INST
 #undef HANDLE_TERM_INST
diff --git a/linux-x64/clang/include/llvm/IR/Instruction.h b/linux-x64/clang/include/llvm/IR/Instruction.h
index 6a9a74b..d2a55f8 100644
--- a/linux-x64/clang/include/llvm/IR/Instruction.h
+++ b/linux-x64/clang/include/llvm/IR/Instruction.h
@@ -15,6 +15,7 @@
 #define LLVM_IR_INSTRUCTION_H
 
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/Bitfields.h"
 #include "llvm/ADT/None.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/ilist_node.h"
@@ -22,6 +23,7 @@
 #include "llvm/IR/SymbolTableListTraits.h"
 #include "llvm/IR/User.h"
 #include "llvm/IR/Value.h"
+#include "llvm/Support/AtomicOrdering.h"
 #include "llvm/Support/Casting.h"
 #include <algorithm>
 #include <cassert>
@@ -45,11 +47,37 @@
   BasicBlock *Parent;
   DebugLoc DbgLoc;                         // 'dbg' Metadata cache.
 
-  enum {
-    /// This is a bit stored in the SubClassData field which indicates whether
-    /// this instruction has metadata attached to it or not.
-    HasMetadataBit = 1 << 15
-  };
+  /// Relative order of this instruction in its parent basic block. Used for
+  /// O(1) local dominance checks between instructions.
+  mutable unsigned Order = 0;
+
+protected:
+  // The 15 first bits of `Value::SubclassData` are available for subclasses of
+  // `Instruction` to use.
+  using OpaqueField = Bitfield::Element<uint16_t, 0, 15>;
+
+  // Template alias so that all Instruction storing alignment use the same
+  // definiton.
+  // Valid alignments are powers of two from 2^0 to 2^MaxAlignmentExponent =
+  // 2^29. We store them as Log2(Alignment), so we need 5 bits to encode the 30
+  // possible values.
+  template <unsigned Offset>
+  using AlignmentBitfieldElementT =
+      typename Bitfield::Element<unsigned, Offset, 5,
+                                 Value::MaxAlignmentExponent>;
+
+  template <unsigned Offset>
+  using BoolBitfieldElementT = typename Bitfield::Element<bool, Offset, 1>;
+
+  template <unsigned Offset>
+  using AtomicOrderingBitfieldElementT =
+      typename Bitfield::Element<AtomicOrdering, Offset, 3,
+                                 AtomicOrdering::LAST>;
+
+private:
+  // The last bit is used to store whether the instruction has metadata attached
+  // or not.
+  using HasMetadataField = Bitfield::Element<bool, 15, 1>;
 
 protected:
   ~Instruction(); // Use deleteValue() to delete a generic Instruction.
@@ -117,6 +145,13 @@
   /// the basic block that MovePos lives in, right after MovePos.
   void moveAfter(Instruction *MovePos);
 
+  /// Given an instruction Other in the same basic block as this instruction,
+  /// return true if this instruction comes before Other. In this worst case,
+  /// this takes linear time in the number of instructions in the block. The
+  /// results are cached, so in common cases when the block remains unmodified,
+  /// it takes constant time.
+  bool comesBefore(const Instruction *Other) const;
+
   //===--------------------------------------------------------------------===//
   // Subclass classification.
   //===--------------------------------------------------------------------===//
@@ -129,7 +164,7 @@
   bool isUnaryOp() const { return isUnaryOp(getOpcode()); }
   bool isBinaryOp() const { return isBinaryOp(getOpcode()); }
   bool isIntDivRem() const { return isIntDivRem(getOpcode()); }
-  bool isShift() { return isShift(getOpcode()); }
+  bool isShift() const { return isShift(getOpcode()); }
   bool isCast() const { return isCast(getOpcode()); }
   bool isFuncletPad() const { return isFuncletPad(getOpcode()); }
   bool isExceptionalTerminator() const {
@@ -221,12 +256,20 @@
   //===--------------------------------------------------------------------===//
 
   /// Return true if this instruction has any metadata attached to it.
-  bool hasMetadata() const { return DbgLoc || hasMetadataHashEntry(); }
+  bool hasMetadata() const { return DbgLoc || Value::hasMetadata(); }
 
   /// Return true if this instruction has metadata attached to it other than a
   /// debug location.
-  bool hasMetadataOtherThanDebugLoc() const {
-    return hasMetadataHashEntry();
+  bool hasMetadataOtherThanDebugLoc() const { return Value::hasMetadata(); }
+
+  /// Return true if this instruction has the given type of metadata attached.
+  bool hasMetadata(unsigned KindID) const {
+    return getMetadata(KindID) != nullptr;
+  }
+
+  /// Return true if this instruction has the given type of metadata attached.
+  bool hasMetadata(StringRef Kind) const {
+    return getMetadata(Kind) != nullptr;
   }
 
   /// Get the metadata of given kind attached to this Instruction.
@@ -256,8 +299,7 @@
   /// debug location.
   void getAllMetadataOtherThanDebugLoc(
       SmallVectorImpl<std::pair<unsigned, MDNode *>> &MDs) const {
-    if (hasMetadataOtherThanDebugLoc())
-      getAllMetadataOtherThanDebugLocImpl(MDs);
+    Value::getAllMetadata(MDs);
   }
 
   /// Fills the AAMDNodes structure with AA metadata from this instruction.
@@ -298,6 +340,11 @@
   }
   /// @}
 
+  /// Adds an !annotation metadata node with \p Annotation to this instruction.
+  /// If this instruction already has !annotation metadata, append \p Annotation
+  /// to the existing node.
+  void addAnnotationMetadata(StringRef Annotation);
+
   /// Sets the metadata on this instruction from the AAMDNodes structure.
   void setAAMetadata(const AAMDNodes &N);
 
@@ -311,9 +358,6 @@
   /// Returns false if no metadata was found.
   bool extractProfTotalWeight(uint64_t &TotalVal) const;
 
-  /// Sets the branch_weights metadata to \p W for CallInst.
-  void setProfWeight(uint64_t W);
-
   /// Set the debug location information for this instruction.
   void setDebugLoc(DebugLoc Loc) { DbgLoc = std::move(Loc); }
 
@@ -375,6 +419,11 @@
   /// this flag.
   void setHasAllowReciprocal(bool B);
 
+  /// Set or clear the allow-contract flag on this instruction, which must be
+  /// an operator which supports this flag. See LangRef.html for the meaning of
+  /// this flag.
+  void setHasAllowContract(bool B);
+
   /// Set or clear the approximate-math-functions flag on this instruction,
   /// which must be an operator which supports this flag. See LangRef.html for
   /// the meaning of this flag.
@@ -445,21 +494,26 @@
   /// merged DebugLoc.
   void applyMergedLocation(const DILocation *LocA, const DILocation *LocB);
 
-private:
-  /// Return true if we have an entry in the on-the-side metadata hash.
-  bool hasMetadataHashEntry() const {
-    return (getSubclassDataFromValue() & HasMetadataBit) != 0;
-  }
+  /// Updates the debug location given that the instruction has been hoisted
+  /// from a block to a predecessor of that block.
+  /// Note: it is undefined behavior to call this on an instruction not
+  /// currently inserted into a function.
+  void updateLocationAfterHoist();
 
+  /// Drop the instruction's debug location. This does not guarantee removal
+  /// of the !dbg source location attachment, as it must set a line 0 location
+  /// with scope information attached on call instructions. To guarantee
+  /// removal of the !dbg attachment, use the \ref setDebugLoc() API.
+  /// Note: it is undefined behavior to call this on an instruction not
+  /// currently inserted into a function.
+  void dropLocation();
+
+private:
   // These are all implemented in Metadata.cpp.
   MDNode *getMetadataImpl(unsigned KindID) const;
   MDNode *getMetadataImpl(StringRef Kind) const;
   void
   getAllMetadataImpl(SmallVectorImpl<std::pair<unsigned, MDNode *>> &) const;
-  void getAllMetadataOtherThanDebugLocImpl(
-      SmallVectorImpl<std::pair<unsigned, MDNode *>> &) const;
-  /// Clear all hashtable-based metadata from this instruction.
-  void clearMetadataHashEntries();
 
 public:
   //===--------------------------------------------------------------------===//
@@ -485,7 +539,7 @@
   /// In LLVM, these are the commutative operators, plus SetEQ and SetNE, when
   /// applied to any type.
   ///
-  bool isCommutative() const { return isCommutative(getOpcode()); }
+  bool isCommutative() const LLVM_READONLY;
   static bool isCommutative(unsigned Opcode) {
     switch (Opcode) {
     case Add: case FAdd:
@@ -597,19 +651,25 @@
   bool isLifetimeStartOrEnd() const;
 
   /// Return a pointer to the next non-debug instruction in the same basic
-  /// block as 'this', or nullptr if no such instruction exists.
-  const Instruction *getNextNonDebugInstruction() const;
-  Instruction *getNextNonDebugInstruction() {
+  /// block as 'this', or nullptr if no such instruction exists. Skip any pseudo
+  /// operations if \c SkipPseudoOp is true.
+  const Instruction *
+  getNextNonDebugInstruction(bool SkipPseudoOp = false) const;
+  Instruction *getNextNonDebugInstruction(bool SkipPseudoOp = false) {
     return const_cast<Instruction *>(
-        static_cast<const Instruction *>(this)->getNextNonDebugInstruction());
+        static_cast<const Instruction *>(this)->getNextNonDebugInstruction(
+            SkipPseudoOp));
   }
 
   /// Return a pointer to the previous non-debug instruction in the same basic
-  /// block as 'this', or nullptr if no such instruction exists.
-  const Instruction *getPrevNonDebugInstruction() const;
-  Instruction *getPrevNonDebugInstruction() {
+  /// block as 'this', or nullptr if no such instruction exists. Skip any pseudo
+  /// operations if \c SkipPseudoOp is true.
+  const Instruction *
+  getPrevNonDebugInstruction(bool SkipPseudoOp = false) const;
+  Instruction *getPrevNonDebugInstruction(bool SkipPseudoOp = false) {
     return const_cast<Instruction *>(
-        static_cast<const Instruction *>(this)->getPrevNonDebugInstruction());
+        static_cast<const Instruction *>(this)->getPrevNonDebugInstruction(
+            SkipPseudoOp));
   }
 
   /// Create a copy of 'this' instruction that is identical in all ways except
@@ -728,6 +788,7 @@
 
 private:
   friend class SymbolTableListTraits<Instruction>;
+  friend class BasicBlock; // For renumbering.
 
   // Shadow Value::setValueSubclassData with a private forwarding method so that
   // subclasses cannot accidentally use it.
@@ -739,25 +800,30 @@
     return Value::getSubclassDataFromValue();
   }
 
-  void setHasMetadataHashEntry(bool V) {
-    setValueSubclassData((getSubclassDataFromValue() & ~HasMetadataBit) |
-                         (V ? HasMetadataBit : 0));
-  }
-
   void setParent(BasicBlock *P);
 
 protected:
   // Instruction subclasses can stick up to 15 bits of stuff into the
   // SubclassData field of instruction with these members.
 
-  // Verify that only the low 15 bits are used.
-  void setInstructionSubclassData(unsigned short D) {
-    assert((D & HasMetadataBit) == 0 && "Out of range value put into field");
-    setValueSubclassData((getSubclassDataFromValue() & HasMetadataBit) | D);
+  template <typename BitfieldElement>
+  typename BitfieldElement::Type getSubclassData() const {
+    static_assert(
+        std::is_same<BitfieldElement, HasMetadataField>::value ||
+            !Bitfield::isOverlapping<BitfieldElement, HasMetadataField>(),
+        "Must not overlap with the metadata bit");
+    return Bitfield::get<BitfieldElement>(getSubclassDataFromValue());
   }
 
-  unsigned getSubclassDataFromInstruction() const {
-    return getSubclassDataFromValue() & ~HasMetadataBit;
+  template <typename BitfieldElement>
+  void setSubclassData(typename BitfieldElement::Type Value) {
+    static_assert(
+        std::is_same<BitfieldElement, HasMetadataField>::value ||
+            !Bitfield::isOverlapping<BitfieldElement, HasMetadataField>(),
+        "Must not overlap with the metadata bit");
+    auto Storage = getSubclassDataFromValue();
+    Bitfield::set<BitfieldElement>(Storage, Value);
+    setValueSubclassData(Storage);
   }
 
   Instruction(Type *Ty, unsigned iType, Use *Ops, unsigned NumOps,
diff --git a/linux-x64/clang/include/llvm/IR/Instructions.h b/linux-x64/clang/include/llvm/IR/Instructions.h
index 6773664..00ecc2a 100644
--- a/linux-x64/clang/include/llvm/IR/Instructions.h
+++ b/linux-x64/clang/include/llvm/IR/Instructions.h
@@ -16,6 +16,7 @@
 #define LLVM_IR_INSTRUCTIONS_H
 
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/Bitfields.h"
 #include "llvm/ADT/None.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallVector.h"
@@ -26,6 +27,7 @@
 #include "llvm/IR/Attributes.h"
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/CallingConv.h"
+#include "llvm/IR/CFG.h"
 #include "llvm/IR/Constant.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Function.h"
@@ -59,6 +61,13 @@
 class AllocaInst : public UnaryInstruction {
   Type *AllocatedType;
 
+  using AlignmentField = AlignmentBitfieldElementT<0>;
+  using UsedWithInAllocaField = BoolBitfieldElementT<AlignmentField::NextBit>;
+  using SwiftErrorField = BoolBitfieldElementT<UsedWithInAllocaField::NextBit>;
+  static_assert(Bitfield::areContiguous<AlignmentField, UsedWithInAllocaField,
+                                        SwiftErrorField>(),
+                "Bitfields must be contiguous");
+
 protected:
   // Note: Instruction needs to be a friend here to call cloneImpl.
   friend class Instruction;
@@ -66,21 +75,19 @@
   AllocaInst *cloneImpl() const;
 
 public:
-  explicit AllocaInst(Type *Ty, unsigned AddrSpace,
-                      Value *ArraySize = nullptr,
-                      const Twine &Name = "",
-                      Instruction *InsertBefore = nullptr);
+  explicit AllocaInst(Type *Ty, unsigned AddrSpace, Value *ArraySize,
+                      const Twine &Name, Instruction *InsertBefore);
   AllocaInst(Type *Ty, unsigned AddrSpace, Value *ArraySize,
              const Twine &Name, BasicBlock *InsertAtEnd);
 
-  AllocaInst(Type *Ty, unsigned AddrSpace,
-             const Twine &Name, Instruction *InsertBefore = nullptr);
+  AllocaInst(Type *Ty, unsigned AddrSpace, const Twine &Name,
+             Instruction *InsertBefore);
   AllocaInst(Type *Ty, unsigned AddrSpace,
              const Twine &Name, BasicBlock *InsertAtEnd);
 
-  AllocaInst(Type *Ty, unsigned AddrSpace, Value *ArraySize, unsigned Align,
+  AllocaInst(Type *Ty, unsigned AddrSpace, Value *ArraySize, Align Align,
              const Twine &Name = "", Instruction *InsertBefore = nullptr);
-  AllocaInst(Type *Ty, unsigned AddrSpace, Value *ArraySize, unsigned Align,
+  AllocaInst(Type *Ty, unsigned AddrSpace, Value *ArraySize, Align Align,
              const Twine &Name, BasicBlock *InsertAtEnd);
 
   /// Return true if there is an allocation size parameter to the allocation
@@ -99,7 +106,7 @@
 
   /// Get allocation size in bits. Returns None if size can't be determined,
   /// e.g. in case of a VLA.
-  Optional<uint64_t> getAllocationSizeInBits(const DataLayout &DL) const;
+  Optional<TypeSize> getAllocationSizeInBits(const DataLayout &DL) const;
 
   /// Return the type that is being allocated by the instruction.
   Type *getAllocatedType() const { return AllocatedType; }
@@ -109,10 +116,16 @@
 
   /// Return the alignment of the memory that is being allocated by the
   /// instruction.
-  unsigned getAlignment() const {
-    return (1u << (getSubclassDataFromInstruction() & 31)) >> 1;
+  Align getAlign() const {
+    return Align(1ULL << getSubclassData<AlignmentField>());
   }
-  void setAlignment(unsigned Align);
+
+  void setAlignment(Align Align) {
+    setSubclassData<AlignmentField>(Log2(Align));
+  }
+
+  // FIXME: Remove this one transition to Align is over.
+  unsigned getAlignment() const { return getAlign().value(); }
 
   /// Return true if this alloca is in the entry block of the function and is a
   /// constant size. If so, the code generator will fold it into the
@@ -122,25 +135,18 @@
   /// Return true if this alloca is used as an inalloca argument to a call. Such
   /// allocas are never considered static even if they are in the entry block.
   bool isUsedWithInAlloca() const {
-    return getSubclassDataFromInstruction() & 32;
+    return getSubclassData<UsedWithInAllocaField>();
   }
 
   /// Specify whether this alloca is used to represent the arguments to a call.
   void setUsedWithInAlloca(bool V) {
-    setInstructionSubclassData((getSubclassDataFromInstruction() & ~32) |
-                               (V ? 32 : 0));
+    setSubclassData<UsedWithInAllocaField>(V);
   }
 
   /// Return true if this alloca is used as a swifterror argument to a call.
-  bool isSwiftError() const {
-    return getSubclassDataFromInstruction() & 64;
-  }
-
+  bool isSwiftError() const { return getSubclassData<SwiftErrorField>(); }
   /// Specify whether this alloca is used to represent a swifterror.
-  void setSwiftError(bool V) {
-    setInstructionSubclassData((getSubclassDataFromInstruction() & ~64) |
-                               (V ? 64 : 0));
-  }
+  void setSwiftError(bool V) { setSubclassData<SwiftErrorField>(V); }
 
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Instruction *I) {
@@ -153,8 +159,9 @@
 private:
   // Shadow Instruction::setInstructionSubclassData with a private forwarding
   // method so that subclasses cannot accidentally use it.
-  void setInstructionSubclassData(unsigned short D) {
-    Instruction::setInstructionSubclassData(D);
+  template <typename Bitfield>
+  void setSubclassData(typename Bitfield::Type Value) {
+    Instruction::setSubclassData<Bitfield>(Value);
   }
 };
 
@@ -165,6 +172,13 @@
 /// An instruction for reading from memory. This uses the SubclassData field in
 /// Value to store whether or not the load is volatile.
 class LoadInst : public UnaryInstruction {
+  using VolatileField = BoolBitfieldElementT<0>;
+  using AlignmentField = AlignmentBitfieldElementT<VolatileField::NextBit>;
+  using OrderingField = AtomicOrderingBitfieldElementT<AlignmentField::NextBit>;
+  static_assert(
+      Bitfield::areContiguous<VolatileField, AlignmentField, OrderingField>(),
+      "Bitfields must be contiguous");
+
   void AssertOK();
 
 protected:
@@ -174,85 +188,53 @@
   LoadInst *cloneImpl() const;
 
 public:
-  LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr = "",
-           Instruction *InsertBefore = nullptr);
+  LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr,
+           Instruction *InsertBefore);
   LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, BasicBlock *InsertAtEnd);
   LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile,
-           Instruction *InsertBefore = nullptr);
+           Instruction *InsertBefore);
   LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile,
            BasicBlock *InsertAtEnd);
   LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile,
-           unsigned Align, Instruction *InsertBefore = nullptr);
+           Align Align, Instruction *InsertBefore = nullptr);
   LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile,
-           unsigned Align, BasicBlock *InsertAtEnd);
+           Align Align, BasicBlock *InsertAtEnd);
   LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile,
-           unsigned Align, AtomicOrdering Order,
+           Align Align, AtomicOrdering Order,
            SyncScope::ID SSID = SyncScope::System,
            Instruction *InsertBefore = nullptr);
   LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile,
-           unsigned Align, AtomicOrdering Order, SyncScope::ID SSID,
+           Align Align, AtomicOrdering Order, SyncScope::ID SSID,
            BasicBlock *InsertAtEnd);
 
-  // Deprecated [opaque pointer types]
-  explicit LoadInst(Value *Ptr, const Twine &NameStr = "",
-                    Instruction *InsertBefore = nullptr)
-      : LoadInst(Ptr->getType()->getPointerElementType(), Ptr, NameStr,
-                 InsertBefore) {}
-  LoadInst(Value *Ptr, const Twine &NameStr, BasicBlock *InsertAtEnd)
-      : LoadInst(Ptr->getType()->getPointerElementType(), Ptr, NameStr,
-                 InsertAtEnd) {}
-  LoadInst(Value *Ptr, const Twine &NameStr, bool isVolatile,
-           Instruction *InsertBefore = nullptr)
-      : LoadInst(Ptr->getType()->getPointerElementType(), Ptr, NameStr,
-                 isVolatile, InsertBefore) {}
-  LoadInst(Value *Ptr, const Twine &NameStr, bool isVolatile,
-           BasicBlock *InsertAtEnd)
-      : LoadInst(Ptr->getType()->getPointerElementType(), Ptr, NameStr,
-                 isVolatile, InsertAtEnd) {}
-  LoadInst(Value *Ptr, const Twine &NameStr, bool isVolatile, unsigned Align,
-           Instruction *InsertBefore = nullptr)
-      : LoadInst(Ptr->getType()->getPointerElementType(), Ptr, NameStr,
-                 isVolatile, Align, InsertBefore) {}
-  LoadInst(Value *Ptr, const Twine &NameStr, bool isVolatile, unsigned Align,
-           BasicBlock *InsertAtEnd)
-      : LoadInst(Ptr->getType()->getPointerElementType(), Ptr, NameStr,
-                 isVolatile, Align, InsertAtEnd) {}
-  LoadInst(Value *Ptr, const Twine &NameStr, bool isVolatile, unsigned Align,
-           AtomicOrdering Order, SyncScope::ID SSID = SyncScope::System,
-           Instruction *InsertBefore = nullptr)
-      : LoadInst(Ptr->getType()->getPointerElementType(), Ptr, NameStr,
-                 isVolatile, Align, Order, SSID, InsertBefore) {}
-  LoadInst(Value *Ptr, const Twine &NameStr, bool isVolatile, unsigned Align,
-           AtomicOrdering Order, SyncScope::ID SSID, BasicBlock *InsertAtEnd)
-      : LoadInst(Ptr->getType()->getPointerElementType(), Ptr, NameStr,
-                 isVolatile, Align, Order, SSID, InsertAtEnd) {}
-
   /// Return true if this is a load from a volatile memory location.
-  bool isVolatile() const { return getSubclassDataFromInstruction() & 1; }
+  bool isVolatile() const { return getSubclassData<VolatileField>(); }
 
   /// Specify whether this is a volatile load or not.
-  void setVolatile(bool V) {
-    setInstructionSubclassData((getSubclassDataFromInstruction() & ~1) |
-                               (V ? 1 : 0));
-  }
+  void setVolatile(bool V) { setSubclassData<VolatileField>(V); }
 
   /// Return the alignment of the access that is being performed.
-  unsigned getAlignment() const {
-    return (1 << ((getSubclassDataFromInstruction() >> 1) & 31)) >> 1;
+  /// FIXME: Remove this function once transition to Align is over.
+  /// Use getAlign() instead.
+  unsigned getAlignment() const { return getAlign().value(); }
+
+  /// Return the alignment of the access that is being performed.
+  Align getAlign() const {
+    return Align(1ULL << (getSubclassData<AlignmentField>()));
   }
 
-  void setAlignment(unsigned Align);
+  void setAlignment(Align Align) {
+    setSubclassData<AlignmentField>(Log2(Align));
+  }
 
   /// Returns the ordering constraint of this load instruction.
   AtomicOrdering getOrdering() const {
-    return AtomicOrdering((getSubclassDataFromInstruction() >> 7) & 7);
+    return getSubclassData<OrderingField>();
   }
-
   /// Sets the ordering constraint of this load instruction.  May not be Release
   /// or AcquireRelease.
   void setOrdering(AtomicOrdering Ordering) {
-    setInstructionSubclassData((getSubclassDataFromInstruction() & ~(7 << 7)) |
-                               ((unsigned)Ordering << 7));
+    setSubclassData<OrderingField>(Ordering);
   }
 
   /// Returns the synchronization scope ID of this load instruction.
@@ -302,8 +284,9 @@
 private:
   // Shadow Instruction::setInstructionSubclassData with a private forwarding
   // method so that subclasses cannot accidentally use it.
-  void setInstructionSubclassData(unsigned short D) {
-    Instruction::setInstructionSubclassData(D);
+  template <typename Bitfield>
+  void setSubclassData(typename Bitfield::Type Value) {
+    Instruction::setSubclassData<Bitfield>(Value);
   }
 
   /// The synchronization scope ID of this load instruction.  Not quite enough
@@ -318,6 +301,13 @@
 
 /// An instruction for storing to memory.
 class StoreInst : public Instruction {
+  using VolatileField = BoolBitfieldElementT<0>;
+  using AlignmentField = AlignmentBitfieldElementT<VolatileField::NextBit>;
+  using OrderingField = AtomicOrderingBitfieldElementT<AlignmentField::NextBit>;
+  static_assert(
+      Bitfield::areContiguous<VolatileField, AlignmentField, OrderingField>(),
+      "Bitfields must be contiguous");
+
   void AssertOK();
 
 protected:
@@ -329,20 +319,17 @@
 public:
   StoreInst(Value *Val, Value *Ptr, Instruction *InsertBefore);
   StoreInst(Value *Val, Value *Ptr, BasicBlock *InsertAtEnd);
-  StoreInst(Value *Val, Value *Ptr, bool isVolatile = false,
-            Instruction *InsertBefore = nullptr);
+  StoreInst(Value *Val, Value *Ptr, bool isVolatile, Instruction *InsertBefore);
   StoreInst(Value *Val, Value *Ptr, bool isVolatile, BasicBlock *InsertAtEnd);
-  StoreInst(Value *Val, Value *Ptr, bool isVolatile,
-            unsigned Align, Instruction *InsertBefore = nullptr);
-  StoreInst(Value *Val, Value *Ptr, bool isVolatile,
-            unsigned Align, BasicBlock *InsertAtEnd);
-  StoreInst(Value *Val, Value *Ptr, bool isVolatile,
-            unsigned Align, AtomicOrdering Order,
-            SyncScope::ID SSID = SyncScope::System,
+  StoreInst(Value *Val, Value *Ptr, bool isVolatile, Align Align,
             Instruction *InsertBefore = nullptr);
-  StoreInst(Value *Val, Value *Ptr, bool isVolatile,
-            unsigned Align, AtomicOrdering Order, SyncScope::ID SSID,
+  StoreInst(Value *Val, Value *Ptr, bool isVolatile, Align Align,
             BasicBlock *InsertAtEnd);
+  StoreInst(Value *Val, Value *Ptr, bool isVolatile, Align Align,
+            AtomicOrdering Order, SyncScope::ID SSID = SyncScope::System,
+            Instruction *InsertBefore = nullptr);
+  StoreInst(Value *Val, Value *Ptr, bool isVolatile, Align Align,
+            AtomicOrdering Order, SyncScope::ID SSID, BasicBlock *InsertAtEnd);
 
   // allocate space for exactly two operands
   void *operator new(size_t s) {
@@ -350,34 +337,36 @@
   }
 
   /// Return true if this is a store to a volatile memory location.
-  bool isVolatile() const { return getSubclassDataFromInstruction() & 1; }
+  bool isVolatile() const { return getSubclassData<VolatileField>(); }
 
   /// Specify whether this is a volatile store or not.
-  void setVolatile(bool V) {
-    setInstructionSubclassData((getSubclassDataFromInstruction() & ~1) |
-                               (V ? 1 : 0));
-  }
+  void setVolatile(bool V) { setSubclassData<VolatileField>(V); }
 
   /// Transparently provide more efficient getOperand methods.
   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
 
   /// Return the alignment of the access that is being performed
-  unsigned getAlignment() const {
-    return (1 << ((getSubclassDataFromInstruction() >> 1) & 31)) >> 1;
+  /// FIXME: Remove this function once transition to Align is over.
+  /// Use getAlign() instead.
+  unsigned getAlignment() const { return getAlign().value(); }
+
+  Align getAlign() const {
+    return Align(1ULL << (getSubclassData<AlignmentField>()));
   }
 
-  void setAlignment(unsigned Align);
+  void setAlignment(Align Align) {
+    setSubclassData<AlignmentField>(Log2(Align));
+  }
 
   /// Returns the ordering constraint of this store instruction.
   AtomicOrdering getOrdering() const {
-    return AtomicOrdering((getSubclassDataFromInstruction() >> 7) & 7);
+    return getSubclassData<OrderingField>();
   }
 
   /// Sets the ordering constraint of this store instruction.  May not be
   /// Acquire or AcquireRelease.
   void setOrdering(AtomicOrdering Ordering) {
-    setInstructionSubclassData((getSubclassDataFromInstruction() & ~(7 << 7)) |
-                               ((unsigned)Ordering << 7));
+    setSubclassData<OrderingField>(Ordering);
   }
 
   /// Returns the synchronization scope ID of this store instruction.
@@ -430,8 +419,9 @@
 private:
   // Shadow Instruction::setInstructionSubclassData with a private forwarding
   // method so that subclasses cannot accidentally use it.
-  void setInstructionSubclassData(unsigned short D) {
-    Instruction::setInstructionSubclassData(D);
+  template <typename Bitfield>
+  void setSubclassData(typename Bitfield::Type Value) {
+    Instruction::setSubclassData<Bitfield>(Value);
   }
 
   /// The synchronization scope ID of this store instruction.  Not quite enough
@@ -452,6 +442,8 @@
 
 /// An instruction for ordering other memory operations.
 class FenceInst : public Instruction {
+  using OrderingField = AtomicOrderingBitfieldElementT<0>;
+
   void Init(AtomicOrdering Ordering, SyncScope::ID SSID);
 
 protected:
@@ -476,14 +468,13 @@
 
   /// Returns the ordering constraint of this fence instruction.
   AtomicOrdering getOrdering() const {
-    return AtomicOrdering(getSubclassDataFromInstruction() >> 1);
+    return getSubclassData<OrderingField>();
   }
 
   /// Sets the ordering constraint of this fence instruction.  May only be
   /// Acquire, Release, AcquireRelease, or SequentiallyConsistent.
   void setOrdering(AtomicOrdering Ordering) {
-    setInstructionSubclassData((getSubclassDataFromInstruction() & 1) |
-                               ((unsigned)Ordering << 1));
+    setSubclassData<OrderingField>(Ordering);
   }
 
   /// Returns the synchronization scope ID of this fence instruction.
@@ -507,8 +498,9 @@
 private:
   // Shadow Instruction::setInstructionSubclassData with a private forwarding
   // method so that subclasses cannot accidentally use it.
-  void setInstructionSubclassData(unsigned short D) {
-    Instruction::setInstructionSubclassData(D);
+  template <typename Bitfield>
+  void setSubclassData(typename Bitfield::Type Value) {
+    Instruction::setSubclassData<Bitfield>(Value);
   }
 
   /// The synchronization scope ID of this fence instruction.  Not quite enough
@@ -528,10 +520,15 @@
 /// failure (false) as second element.
 ///
 class AtomicCmpXchgInst : public Instruction {
-  void Init(Value *Ptr, Value *Cmp, Value *NewVal,
+  void Init(Value *Ptr, Value *Cmp, Value *NewVal, Align Align,
             AtomicOrdering SuccessOrdering, AtomicOrdering FailureOrdering,
             SyncScope::ID SSID);
 
+  template <unsigned Offset>
+  using AtomicOrderingBitfieldElement =
+      typename Bitfield::Element<AtomicOrdering, Offset, 3,
+                                 AtomicOrdering::LAST>;
+
 protected:
   // Note: Instruction needs to be a friend here to call cloneImpl.
   friend class Instruction;
@@ -539,71 +536,82 @@
   AtomicCmpXchgInst *cloneImpl() const;
 
 public:
-  AtomicCmpXchgInst(Value *Ptr, Value *Cmp, Value *NewVal,
+  AtomicCmpXchgInst(Value *Ptr, Value *Cmp, Value *NewVal, Align Alignment,
                     AtomicOrdering SuccessOrdering,
-                    AtomicOrdering FailureOrdering,
-                    SyncScope::ID SSID, Instruction *InsertBefore = nullptr);
-  AtomicCmpXchgInst(Value *Ptr, Value *Cmp, Value *NewVal,
+                    AtomicOrdering FailureOrdering, SyncScope::ID SSID,
+                    Instruction *InsertBefore = nullptr);
+  AtomicCmpXchgInst(Value *Ptr, Value *Cmp, Value *NewVal, Align Alignment,
                     AtomicOrdering SuccessOrdering,
-                    AtomicOrdering FailureOrdering,
-                    SyncScope::ID SSID, BasicBlock *InsertAtEnd);
+                    AtomicOrdering FailureOrdering, SyncScope::ID SSID,
+                    BasicBlock *InsertAtEnd);
 
   // allocate space for exactly three operands
   void *operator new(size_t s) {
     return User::operator new(s, 3);
   }
 
+  using VolatileField = BoolBitfieldElementT<0>;
+  using WeakField = BoolBitfieldElementT<VolatileField::NextBit>;
+  using SuccessOrderingField =
+      AtomicOrderingBitfieldElementT<WeakField::NextBit>;
+  using FailureOrderingField =
+      AtomicOrderingBitfieldElementT<SuccessOrderingField::NextBit>;
+  using AlignmentField =
+      AlignmentBitfieldElementT<FailureOrderingField::NextBit>;
+  static_assert(
+      Bitfield::areContiguous<VolatileField, WeakField, SuccessOrderingField,
+                              FailureOrderingField, AlignmentField>(),
+      "Bitfields must be contiguous");
+
+  /// Return the alignment of the memory that is being allocated by the
+  /// instruction.
+  Align getAlign() const {
+    return Align(1ULL << getSubclassData<AlignmentField>());
+  }
+
+  void setAlignment(Align Align) {
+    setSubclassData<AlignmentField>(Log2(Align));
+  }
+
   /// Return true if this is a cmpxchg from a volatile memory
   /// location.
   ///
-  bool isVolatile() const {
-    return getSubclassDataFromInstruction() & 1;
-  }
+  bool isVolatile() const { return getSubclassData<VolatileField>(); }
 
   /// Specify whether this is a volatile cmpxchg.
   ///
-  void setVolatile(bool V) {
-     setInstructionSubclassData((getSubclassDataFromInstruction() & ~1) |
-                                (unsigned)V);
-  }
+  void setVolatile(bool V) { setSubclassData<VolatileField>(V); }
 
   /// Return true if this cmpxchg may spuriously fail.
-  bool isWeak() const {
-    return getSubclassDataFromInstruction() & 0x100;
-  }
+  bool isWeak() const { return getSubclassData<WeakField>(); }
 
-  void setWeak(bool IsWeak) {
-    setInstructionSubclassData((getSubclassDataFromInstruction() & ~0x100) |
-                               (IsWeak << 8));
-  }
+  void setWeak(bool IsWeak) { setSubclassData<WeakField>(IsWeak); }
 
   /// Transparently provide more efficient getOperand methods.
   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
 
   /// Returns the success ordering constraint of this cmpxchg instruction.
   AtomicOrdering getSuccessOrdering() const {
-    return AtomicOrdering((getSubclassDataFromInstruction() >> 2) & 7);
+    return getSubclassData<SuccessOrderingField>();
   }
 
   /// Sets the success ordering constraint of this cmpxchg instruction.
   void setSuccessOrdering(AtomicOrdering Ordering) {
     assert(Ordering != AtomicOrdering::NotAtomic &&
            "CmpXchg instructions can only be atomic.");
-    setInstructionSubclassData((getSubclassDataFromInstruction() & ~0x1c) |
-                               ((unsigned)Ordering << 2));
+    setSubclassData<SuccessOrderingField>(Ordering);
   }
 
   /// Returns the failure ordering constraint of this cmpxchg instruction.
   AtomicOrdering getFailureOrdering() const {
-    return AtomicOrdering((getSubclassDataFromInstruction() >> 5) & 7);
+    return getSubclassData<FailureOrderingField>();
   }
 
   /// Sets the failure ordering constraint of this cmpxchg instruction.
   void setFailureOrdering(AtomicOrdering Ordering) {
     assert(Ordering != AtomicOrdering::NotAtomic &&
            "CmpXchg instructions can only be atomic.");
-    setInstructionSubclassData((getSubclassDataFromInstruction() & ~0xe0) |
-                               ((unsigned)Ordering << 5));
+    setSubclassData<FailureOrderingField>(Ordering);
   }
 
   /// Returns the synchronization scope ID of this cmpxchg instruction.
@@ -665,8 +673,9 @@
 private:
   // Shadow Instruction::setInstructionSubclassData with a private forwarding
   // method so that subclasses cannot accidentally use it.
-  void setInstructionSubclassData(unsigned short D) {
-    Instruction::setInstructionSubclassData(D);
+  template <typename Bitfield>
+  void setSubclassData(typename Bitfield::Type Value) {
+    Instruction::setSubclassData<Bitfield>(Value);
   }
 
   /// The synchronization scope ID of this cmpxchg instruction.  Not quite
@@ -702,7 +711,7 @@
   /// the descriptions, 'p' is the pointer to the instruction's memory location,
   /// 'old' is the initial value of *p, and 'v' is the other value passed to the
   /// instruction.  These instructions always return 'old'.
-  enum BinOp {
+  enum BinOp : unsigned {
     /// *p = v
     Xchg,
     /// *p = old + v
@@ -737,10 +746,21 @@
     BAD_BINOP
   };
 
-  AtomicRMWInst(BinOp Operation, Value *Ptr, Value *Val,
+private:
+  template <unsigned Offset>
+  using AtomicOrderingBitfieldElement =
+      typename Bitfield::Element<AtomicOrdering, Offset, 3,
+                                 AtomicOrdering::LAST>;
+
+  template <unsigned Offset>
+  using BinOpBitfieldElement =
+      typename Bitfield::Element<BinOp, Offset, 4, BinOp::LAST_BINOP>;
+
+public:
+  AtomicRMWInst(BinOp Operation, Value *Ptr, Value *Val, Align Alignment,
                 AtomicOrdering Ordering, SyncScope::ID SSID,
                 Instruction *InsertBefore = nullptr);
-  AtomicRMWInst(BinOp Operation, Value *Ptr, Value *Val,
+  AtomicRMWInst(BinOp Operation, Value *Ptr, Value *Val, Align Alignment,
                 AtomicOrdering Ordering, SyncScope::ID SSID,
                 BasicBlock *InsertAtEnd);
 
@@ -749,9 +769,16 @@
     return User::operator new(s, 2);
   }
 
-  BinOp getOperation() const {
-    return static_cast<BinOp>(getSubclassDataFromInstruction() >> 5);
-  }
+  using VolatileField = BoolBitfieldElementT<0>;
+  using AtomicOrderingField =
+      AtomicOrderingBitfieldElementT<VolatileField::NextBit>;
+  using OperationField = BinOpBitfieldElement<AtomicOrderingField::NextBit>;
+  using AlignmentField = AlignmentBitfieldElementT<OperationField::NextBit>;
+  static_assert(Bitfield::areContiguous<VolatileField, AtomicOrderingField,
+                                        OperationField, AlignmentField>(),
+                "Bitfields must be contiguous");
+
+  BinOp getOperation() const { return getSubclassData<OperationField>(); }
 
   static StringRef getOperationName(BinOp Op);
 
@@ -766,38 +793,40 @@
   }
 
   void setOperation(BinOp Operation) {
-    unsigned short SubclassData = getSubclassDataFromInstruction();
-    setInstructionSubclassData((SubclassData & 31) |
-                               (Operation << 5));
+    setSubclassData<OperationField>(Operation);
+  }
+
+  /// Return the alignment of the memory that is being allocated by the
+  /// instruction.
+  Align getAlign() const {
+    return Align(1ULL << getSubclassData<AlignmentField>());
+  }
+
+  void setAlignment(Align Align) {
+    setSubclassData<AlignmentField>(Log2(Align));
   }
 
   /// Return true if this is a RMW on a volatile memory location.
   ///
-  bool isVolatile() const {
-    return getSubclassDataFromInstruction() & 1;
-  }
+  bool isVolatile() const { return getSubclassData<VolatileField>(); }
 
   /// Specify whether this is a volatile RMW or not.
   ///
-  void setVolatile(bool V) {
-     setInstructionSubclassData((getSubclassDataFromInstruction() & ~1) |
-                                (unsigned)V);
-  }
+  void setVolatile(bool V) { setSubclassData<VolatileField>(V); }
 
   /// Transparently provide more efficient getOperand methods.
   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
 
   /// Returns the ordering constraint of this rmw instruction.
   AtomicOrdering getOrdering() const {
-    return AtomicOrdering((getSubclassDataFromInstruction() >> 2) & 7);
+    return getSubclassData<AtomicOrderingField>();
   }
 
   /// Sets the ordering constraint of this rmw instruction.
   void setOrdering(AtomicOrdering Ordering) {
     assert(Ordering != AtomicOrdering::NotAtomic &&
            "atomicrmw instructions can only be atomic.");
-    setInstructionSubclassData((getSubclassDataFromInstruction() & ~(7 << 2)) |
-                               ((unsigned)Ordering << 2));
+    setSubclassData<AtomicOrderingField>(Ordering);
   }
 
   /// Returns the synchronization scope ID of this rmw instruction.
@@ -835,13 +864,14 @@
   }
 
 private:
-  void Init(BinOp Operation, Value *Ptr, Value *Val,
+  void Init(BinOp Operation, Value *Ptr, Value *Val, Align Align,
             AtomicOrdering Ordering, SyncScope::ID SSID);
 
   // Shadow Instruction::setInstructionSubclassData with a private forwarding
   // method so that subclasses cannot accidentally use it.
-  void setInstructionSubclassData(unsigned short D) {
-    Instruction::setInstructionSubclassData(D);
+  template <typename Bitfield>
+  void setSubclassData(typename Bitfield::Type Value) {
+    Instruction::setSubclassData<Bitfield>(Value);
   }
 
   /// The synchronization scope ID of this rmw instruction.  Not quite enough
@@ -987,16 +1017,23 @@
     return getPointerAddressSpace();
   }
 
-  /// Returns the type of the element that would be loaded with
-  /// a load instruction with the specified parameters.
+  /// Returns the result type of a getelementptr with the given source
+  /// element type and indexes.
   ///
   /// Null is returned if the indices are invalid for the specified
-  /// pointer type.
-  ///
+  /// source element type.
   static Type *getIndexedType(Type *Ty, ArrayRef<Value *> IdxList);
   static Type *getIndexedType(Type *Ty, ArrayRef<Constant *> IdxList);
   static Type *getIndexedType(Type *Ty, ArrayRef<uint64_t> IdxList);
 
+  /// Return the type of the element at the given index of an indexable
+  /// type.  This is equivalent to "getIndexedType(Agg, {Zero, Idx})".
+  ///
+  /// Returns null if the type can't be indexed, or the given index is not
+  /// legal for the given type.
+  static Type *getTypeAtIndex(Type *Ty, Value *Idx);
+  static Type *getTypeAtIndex(Type *Ty, uint64_t Idx);
+
   inline op_iterator       idx_begin()       { return op_begin()+1; }
   inline const_op_iterator idx_begin() const { return op_begin()+1; }
   inline op_iterator       idx_end()         { return op_end(); }
@@ -1033,24 +1070,19 @@
 
   /// Returns the pointer type returned by the GEP
   /// instruction, which may be a vector of pointers.
-  static Type *getGEPReturnType(Value *Ptr, ArrayRef<Value *> IdxList) {
-    return getGEPReturnType(
-      cast<PointerType>(Ptr->getType()->getScalarType())->getElementType(),
-      Ptr, IdxList);
-  }
   static Type *getGEPReturnType(Type *ElTy, Value *Ptr,
                                 ArrayRef<Value *> IdxList) {
     Type *PtrTy = PointerType::get(checkGEPType(getIndexedType(ElTy, IdxList)),
                                    Ptr->getType()->getPointerAddressSpace());
     // Vector GEP
-    if (Ptr->getType()->isVectorTy()) {
-      unsigned NumElem = Ptr->getType()->getVectorNumElements();
-      return VectorType::get(PtrTy, NumElem);
+    if (auto *PtrVTy = dyn_cast<VectorType>(Ptr->getType())) {
+      ElementCount EltCount = PtrVTy->getElementCount();
+      return VectorType::get(PtrTy, EltCount);
     }
     for (Value *Index : IdxList)
-      if (Index->getType()->isVectorTy()) {
-        unsigned NumElem = Index->getType()->getVectorNumElements();
-        return VectorType::get(PtrTy, NumElem);
+      if (auto *IndexVTy = dyn_cast<VectorType>(Index->getType())) {
+        ElementCount EltCount = IndexVTy->getElementCount();
+        return VectorType::get(PtrTy, EltCount);
       }
     // Scalar GEP
     return PtrTy;
@@ -1258,6 +1290,30 @@
     return !isEquality(P);
   }
 
+  /// Return true if the predicate is SGT or UGT.
+  ///
+  static bool isGT(Predicate P) {
+    return P == ICMP_SGT || P == ICMP_UGT;
+  }
+
+  /// Return true if the predicate is SLT or ULT.
+  ///
+  static bool isLT(Predicate P) {
+    return P == ICMP_SLT || P == ICMP_ULT;
+  }
+
+  /// Return true if the predicate is SGE or UGE.
+  ///
+  static bool isGE(Predicate P) {
+    return P == ICMP_SGE || P == ICMP_UGE;
+  }
+
+  /// Return true if the predicate is SLE or ULE.
+  ///
+  static bool isLE(Predicate P) {
+    return P == ICMP_SLE || P == ICMP_ULE;
+  }
+
   /// Exchange the two operands to this instruction in such a way that it does
   /// not modify the semantics of the instruction. The predicate value may be
   /// changed to retain the same result if the predicate is order dependent
@@ -1520,58 +1576,6 @@
                   NameStr, InsertAtEnd);
   }
 
-  // Deprecated [opaque pointer types]
-  static CallInst *Create(Value *Func, const Twine &NameStr = "",
-                          Instruction *InsertBefore = nullptr) {
-    return Create(cast<FunctionType>(
-                      cast<PointerType>(Func->getType())->getElementType()),
-                  Func, NameStr, InsertBefore);
-  }
-
-  // Deprecated [opaque pointer types]
-  static CallInst *Create(Value *Func, ArrayRef<Value *> Args,
-                          const Twine &NameStr,
-                          Instruction *InsertBefore = nullptr) {
-    return Create(cast<FunctionType>(
-                      cast<PointerType>(Func->getType())->getElementType()),
-                  Func, Args, NameStr, InsertBefore);
-  }
-
-  // Deprecated [opaque pointer types]
-  static CallInst *Create(Value *Func, ArrayRef<Value *> Args,
-                          ArrayRef<OperandBundleDef> Bundles = None,
-                          const Twine &NameStr = "",
-                          Instruction *InsertBefore = nullptr) {
-    return Create(cast<FunctionType>(
-                      cast<PointerType>(Func->getType())->getElementType()),
-                  Func, Args, Bundles, NameStr, InsertBefore);
-  }
-
-  // Deprecated [opaque pointer types]
-  static CallInst *Create(Value *Func, const Twine &NameStr,
-                          BasicBlock *InsertAtEnd) {
-    return Create(cast<FunctionType>(
-                      cast<PointerType>(Func->getType())->getElementType()),
-                  Func, NameStr, InsertAtEnd);
-  }
-
-  // Deprecated [opaque pointer types]
-  static CallInst *Create(Value *Func, ArrayRef<Value *> Args,
-                          const Twine &NameStr, BasicBlock *InsertAtEnd) {
-    return Create(cast<FunctionType>(
-                      cast<PointerType>(Func->getType())->getElementType()),
-                  Func, Args, NameStr, InsertAtEnd);
-  }
-
-  // Deprecated [opaque pointer types]
-  static CallInst *Create(Value *Func, ArrayRef<Value *> Args,
-                          ArrayRef<OperandBundleDef> Bundles,
-                          const Twine &NameStr, BasicBlock *InsertAtEnd) {
-    return Create(cast<FunctionType>(
-                      cast<PointerType>(Func->getType())->getElementType()),
-                  Func, Args, Bundles, NameStr, InsertAtEnd);
-  }
-
   /// Create a clone of \p CI with a different set of operand bundles and
   /// insert it before \p InsertPt.
   ///
@@ -1581,6 +1585,16 @@
   static CallInst *Create(CallInst *CI, ArrayRef<OperandBundleDef> Bundles,
                           Instruction *InsertPt = nullptr);
 
+  /// Create a clone of \p CI with a different set of operand bundles and
+  /// insert it before \p InsertPt.
+  ///
+  /// The returned call instruction is identical \p CI in every way except that
+  /// the operand bundle for the new instruction is set to the operand bundle
+  /// in \p Bundle.
+  static CallInst *CreateWithReplacedBundle(CallInst *CI,
+                                            OperandBundleDef Bundle,
+                                            Instruction *InsertPt = nullptr);
+
   /// Generate the IR for a call to malloc:
   /// 1. Compute the malloc call's argument as the specified type's size,
   ///    possibly multiplied by the array size if the array size is not
@@ -1620,37 +1634,38 @@
                                  BasicBlock *InsertAtEnd);
 
   // Note that 'musttail' implies 'tail'.
-  enum TailCallKind {
+  enum TailCallKind : unsigned {
     TCK_None = 0,
     TCK_Tail = 1,
     TCK_MustTail = 2,
-    TCK_NoTail = 3
+    TCK_NoTail = 3,
+    TCK_LAST = TCK_NoTail
   };
+
+  using TailCallKindField = Bitfield::Element<TailCallKind, 0, 2, TCK_LAST>;
+  static_assert(
+      Bitfield::areContiguous<TailCallKindField, CallBase::CallingConvField>(),
+      "Bitfields must be contiguous");
+
   TailCallKind getTailCallKind() const {
-    return TailCallKind(getSubclassDataFromInstruction() & 3);
+    return getSubclassData<TailCallKindField>();
   }
 
   bool isTailCall() const {
-    unsigned Kind = getSubclassDataFromInstruction() & 3;
+    TailCallKind Kind = getTailCallKind();
     return Kind == TCK_Tail || Kind == TCK_MustTail;
   }
 
-  bool isMustTailCall() const {
-    return (getSubclassDataFromInstruction() & 3) == TCK_MustTail;
-  }
+  bool isMustTailCall() const { return getTailCallKind() == TCK_MustTail; }
 
-  bool isNoTailCall() const {
-    return (getSubclassDataFromInstruction() & 3) == TCK_NoTail;
-  }
-
-  void setTailCall(bool isTC = true) {
-    setInstructionSubclassData((getSubclassDataFromInstruction() & ~3) |
-                               unsigned(isTC ? TCK_Tail : TCK_None));
-  }
+  bool isNoTailCall() const { return getTailCallKind() == TCK_NoTail; }
 
   void setTailCallKind(TailCallKind TCK) {
-    setInstructionSubclassData((getSubclassDataFromInstruction() & ~3) |
-                               unsigned(TCK));
+    setSubclassData<TailCallKindField>(TCK);
+  }
+
+  void setTailCall(bool IsTc = true) {
+    setTailCallKind(IsTc ? TCK_Tail : TCK_None);
   }
 
   /// Return true if the call can return twice
@@ -1673,8 +1688,9 @@
 private:
   // Shadow Instruction::setInstructionSubclassData with a private forwarding
   // method so that subclasses cannot accidentally use it.
-  void setInstructionSubclassData(unsigned short D) {
-    Instruction::setInstructionSubclassData(D);
+  template <typename Bitfield>
+  void setSubclassData(typename Bitfield::Type Value) {
+    Instruction::setSubclassData<Bitfield>(Value);
   }
 };
 
@@ -1764,6 +1780,10 @@
   void setTrueValue(Value *V) { Op<1>() = V; }
   void setFalseValue(Value *V) { Op<2>() = V; }
 
+  /// Swap the true and false values of the select instruction.
+  /// This doesn't swap prof metadata.
+  void swapValues() { Op<1>().swap(Op<2>()); }
+
   /// Return a string if the specified operands are invalid
   /// for a select operation, otherwise return null.
   static const char *areInvalidOperands(Value *Cond, Value *True, Value *False);
@@ -1961,10 +1981,22 @@
 //                           ShuffleVectorInst Class
 //===----------------------------------------------------------------------===//
 
+constexpr int UndefMaskElem = -1;
+
 /// This instruction constructs a fixed permutation of two
 /// input vectors.
 ///
+/// For each element of the result vector, the shuffle mask selects an element
+/// from one of the input vectors to copy to the result. Non-negative elements
+/// in the mask represent an index into the concatenated pair of input vectors.
+/// UndefMaskElem (-1) specifies that the result element is undefined.
+///
+/// For scalable vectors, all the elements of the mask must be 0 or -1. This
+/// requirement may be relaxed in the future.
 class ShuffleVectorInst : public Instruction {
+  SmallVector<int, 4> ShuffleMask;
+  Constant *ShuffleMaskForBitcode;
+
 protected:
   // Note: Instruction needs to be a friend here to call cloneImpl.
   friend class Instruction;
@@ -1977,13 +2009,15 @@
                     Instruction *InsertBefor = nullptr);
   ShuffleVectorInst(Value *V1, Value *V2, Value *Mask,
                     const Twine &NameStr, BasicBlock *InsertAtEnd);
+  ShuffleVectorInst(Value *V1, Value *V2, ArrayRef<int> Mask,
+                    const Twine &NameStr = "",
+                    Instruction *InsertBefor = nullptr);
+  ShuffleVectorInst(Value *V1, Value *V2, ArrayRef<int> Mask,
+                    const Twine &NameStr, BasicBlock *InsertAtEnd);
 
-  // allocate space for exactly three operands
-  void *operator new(size_t s) {
-    return User::operator new(s, 3);
-  }
+  void *operator new(size_t s) { return User::operator new(s, 2); }
 
-  /// Swap the first 2 operands and adjust the mask to preserve the semantics
+  /// Swap the operands and adjust the mask to preserve the semantics
   /// of the instruction.
   void commute();
 
@@ -1991,6 +2025,8 @@
   /// formed with the specified operands.
   static bool isValidOperands(const Value *V1, const Value *V2,
                               const Value *Mask);
+  static bool isValidOperands(const Value *V1, const Value *V2,
+                              ArrayRef<int> Mask);
 
   /// Overload to return most specific vector type.
   ///
@@ -2001,44 +2037,43 @@
   /// Transparently provide more efficient getOperand methods.
   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
 
-  Constant *getMask() const {
-    return cast<Constant>(getOperand(2));
-  }
-
-  /// Return the shuffle mask value for the specified element of the mask.
-  /// Return -1 if the element is undef.
-  static int getMaskValue(const Constant *Mask, unsigned Elt);
-
   /// Return the shuffle mask value of this instruction for the given element
-  /// index. Return -1 if the element is undef.
-  int getMaskValue(unsigned Elt) const {
-    return getMaskValue(getMask(), Elt);
-  }
+  /// index. Return UndefMaskElem if the element is undef.
+  int getMaskValue(unsigned Elt) const { return ShuffleMask[Elt]; }
 
   /// Convert the input shuffle mask operand to a vector of integers. Undefined
-  /// elements of the mask are returned as -1.
+  /// elements of the mask are returned as UndefMaskElem.
   static void getShuffleMask(const Constant *Mask,
                              SmallVectorImpl<int> &Result);
 
   /// Return the mask for this instruction as a vector of integers. Undefined
-  /// elements of the mask are returned as -1.
+  /// elements of the mask are returned as UndefMaskElem.
   void getShuffleMask(SmallVectorImpl<int> &Result) const {
-    return getShuffleMask(getMask(), Result);
+    Result.assign(ShuffleMask.begin(), ShuffleMask.end());
   }
 
-  SmallVector<int, 16> getShuffleMask() const {
-    SmallVector<int, 16> Mask;
-    getShuffleMask(Mask);
-    return Mask;
-  }
+  /// Return the mask for this instruction, for use in bitcode.
+  ///
+  /// TODO: This is temporary until we decide a new bitcode encoding for
+  /// shufflevector.
+  Constant *getShuffleMaskForBitcode() const { return ShuffleMaskForBitcode; }
+
+  static Constant *convertShuffleMaskForBitcode(ArrayRef<int> Mask,
+                                                Type *ResultTy);
+
+  void setShuffleMask(ArrayRef<int> Mask);
+
+  ArrayRef<int> getShuffleMask() const { return ShuffleMask; }
 
   /// Return true if this shuffle returns a vector with a different number of
   /// elements than its source vectors.
   /// Examples: shufflevector <4 x n> A, <4 x n> B, <1,2,3>
   ///           shufflevector <4 x n> A, <4 x n> B, <1,2,3,4,5>
   bool changesLength() const {
-    unsigned NumSourceElts = Op<0>()->getType()->getVectorNumElements();
-    unsigned NumMaskElts = getMask()->getType()->getVectorNumElements();
+    unsigned NumSourceElts = cast<VectorType>(Op<0>()->getType())
+                                 ->getElementCount()
+                                 .getKnownMinValue();
+    unsigned NumMaskElts = ShuffleMask.size();
     return NumSourceElts != NumMaskElts;
   }
 
@@ -2046,8 +2081,10 @@
   /// elements than its source vectors.
   /// Example: shufflevector <2 x n> A, <2 x n> B, <1,2,3>
   bool increasesLength() const {
-    unsigned NumSourceElts = Op<0>()->getType()->getVectorNumElements();
-    unsigned NumMaskElts = getMask()->getType()->getVectorNumElements();
+    unsigned NumSourceElts = cast<VectorType>(Op<0>()->getType())
+                                 ->getElementCount()
+                                 .getKnownMinValue();
+    unsigned NumMaskElts = ShuffleMask.size();
     return NumSourceElts < NumMaskElts;
   }
 
@@ -2068,7 +2105,7 @@
   /// Example: shufflevector <4 x n> A, <4 x n> B, <3,0,undef,3>
   /// TODO: Optionally allow length-changing shuffles.
   bool isSingleSource() const {
-    return !changesLength() && isSingleSourceMask(getMask());
+    return !changesLength() && isSingleSourceMask(ShuffleMask);
   }
 
   /// Return true if this shuffle mask chooses elements from exactly one source
@@ -2089,7 +2126,7 @@
   /// from its input vectors.
   /// Example: shufflevector <4 x n> A, <4 x n> B, <4,undef,6,undef>
   bool isIdentity() const {
-    return !changesLength() && isIdentityMask(getShuffleMask());
+    return !changesLength() && isIdentityMask(ShuffleMask);
   }
 
   /// Return true if this shuffle lengthens exactly one source vector with
@@ -2130,7 +2167,7 @@
   /// In that case, the shuffle is better classified as an identity shuffle.
   /// TODO: Optionally allow length-changing shuffles.
   bool isSelect() const {
-    return !changesLength() && isSelectMask(getMask());
+    return !changesLength() && isSelectMask(ShuffleMask);
   }
 
   /// Return true if this shuffle mask swaps the order of elements from exactly
@@ -2150,7 +2187,7 @@
   /// Example: shufflevector <4 x n> A, <4 x n> B, <3,undef,1,undef>
   /// TODO: Optionally allow length-changing shuffles.
   bool isReverse() const {
-    return !changesLength() && isReverseMask(getMask());
+    return !changesLength() && isReverseMask(ShuffleMask);
   }
 
   /// Return true if this shuffle mask chooses all elements with the same value
@@ -2172,7 +2209,7 @@
   /// TODO: Optionally allow length-changing shuffles.
   /// TODO: Optionally allow splats from other elements.
   bool isZeroEltSplat() const {
-    return !changesLength() && isZeroEltSplatMask(getMask());
+    return !changesLength() && isZeroEltSplatMask(ShuffleMask);
   }
 
   /// Return true if this shuffle mask is a transpose mask.
@@ -2221,7 +2258,7 @@
   /// exact specification.
   /// Example: shufflevector <4 x n> A, <4 x n> B, <0,4,2,6>
   bool isTranspose() const {
-    return !changesLength() && isTransposeMask(getMask());
+    return !changesLength() && isTransposeMask(ShuffleMask);
   }
 
   /// Return true if this shuffle mask is an extract subvector mask.
@@ -2232,6 +2269,10 @@
   static bool isExtractSubvectorMask(const Constant *Mask, int NumSrcElts,
                                      int &Index) {
     assert(Mask->getType()->isVectorTy() && "Shuffle needs vector constant.");
+    // Not possible to express a shuffle mask for a scalable vector for this
+    // case.
+    if (isa<ScalableVectorType>(Mask->getType()))
+      return false;
     SmallVector<int, 16> MaskAsInts;
     getShuffleMask(Mask, MaskAsInts);
     return isExtractSubvectorMask(MaskAsInts, NumSrcElts, Index);
@@ -2239,8 +2280,14 @@
 
   /// Return true if this shuffle mask is an extract subvector mask.
   bool isExtractSubvectorMask(int &Index) const {
-    int NumSrcElts = Op<0>()->getType()->getVectorNumElements();
-    return isExtractSubvectorMask(getMask(), NumSrcElts, Index);
+    // Not possible to express a shuffle mask for a scalable vector for this
+    // case.
+    if (isa<ScalableVectorType>(getType()))
+      return false;
+
+    int NumSrcElts =
+        cast<FixedVectorType>(Op<0>()->getType())->getNumElements();
+    return isExtractSubvectorMask(ShuffleMask, NumSrcElts, Index);
   }
 
   /// Change values in a shuffle permute mask assuming the two vector operands
@@ -2266,9 +2313,8 @@
 };
 
 template <>
-struct OperandTraits<ShuffleVectorInst> :
-  public FixedNumOperandTraits<ShuffleVectorInst, 3> {
-};
+struct OperandTraits<ShuffleVectorInst>
+    : public FixedNumOperandTraits<ShuffleVectorInst, 2> {};
 
 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ShuffleVectorInst, Value)
 
@@ -2594,15 +2640,11 @@
   using const_block_iterator = BasicBlock * const *;
 
   block_iterator block_begin() {
-    Use::UserRef *ref =
-      reinterpret_cast<Use::UserRef*>(op_begin() + ReservedSpace);
-    return reinterpret_cast<block_iterator>(ref + 1);
+    return reinterpret_cast<block_iterator>(op_begin() + ReservedSpace);
   }
 
   const_block_iterator block_begin() const {
-    const Use::UserRef *ref =
-      reinterpret_cast<const Use::UserRef*>(op_begin() + ReservedSpace);
-    return reinterpret_cast<const_block_iterator>(ref + 1);
+    return reinterpret_cast<const_block_iterator>(op_begin() + ReservedSpace);
   }
 
   block_iterator block_end() {
@@ -2748,6 +2790,15 @@
   /// non-undef value.
   bool hasConstantOrUndefValue() const;
 
+  /// If the PHI node is complete which means all of its parent's predecessors
+  /// have incoming value in this PHI, return true, otherwise return false.
+  bool isComplete() const {
+    return llvm::all_of(predecessors(getParent()),
+                        [this](const BasicBlock *Pred) {
+                          return getBasicBlockIndex(Pred) >= 0;
+                        });
+  }
+
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Instruction *I) {
     return I->getOpcode() == Instruction::PHI;
@@ -2779,6 +2830,8 @@
 /// cleanup.
 ///
 class LandingPadInst : public Instruction {
+  using CleanupField = BoolBitfieldElementT<0>;
+
   /// The number of operands actually allocated.  NumOperands is
   /// the number actually in use.
   unsigned ReservedSpace;
@@ -2823,13 +2876,10 @@
   /// Return 'true' if this landingpad instruction is a
   /// cleanup. I.e., it should be run when unwinding even if its landing pad
   /// doesn't catch the exception.
-  bool isCleanup() const { return getSubclassDataFromInstruction() & 1; }
+  bool isCleanup() const { return getSubclassData<CleanupField>(); }
 
   /// Indicate that this landingpad instruction is a cleanup.
-  void setCleanup(bool V) {
-    setInstructionSubclassData((getSubclassDataFromInstruction() & ~1) |
-                               (V ? 1 : 0));
-  }
+  void setCleanup(bool V) { setSubclassData<CleanupField>(V); }
 
   /// Add a catch or filter clause to the landing pad.
   void addClause(Constant *ClauseVal);
@@ -3455,16 +3505,7 @@
 class SwitchInstProfUpdateWrapper {
   SwitchInst &SI;
   Optional<SmallVector<uint32_t, 8> > Weights = None;
-
-  // Sticky invalid state is needed to safely ignore operations with prof data
-  // in cases where SwitchInstProfUpdateWrapper is created from SwitchInst
-  // with inconsistent prof data. TODO: once we fix all prof data
-  // inconsistencies we can turn invalid state to assertions.
-  enum {
-    Invalid,
-    Initialized,
-    Changed
-  } State = Invalid;
+  bool Changed = false;
 
 protected:
   static MDNode *getProfBranchWeightsMD(const SwitchInst &SI);
@@ -3482,7 +3523,7 @@
   SwitchInstProfUpdateWrapper(SwitchInst &SI) : SI(SI) { init(); }
 
   ~SwitchInstProfUpdateWrapper() {
-    if (State == Changed)
+    if (Changed)
       SI.setMetadata(LLVMContext::MD_prof, buildProfBranchWeightsMD());
   }
 
@@ -3774,49 +3815,6 @@
                   IfException, Args, Bundles, NameStr, InsertAtEnd);
   }
 
-  // Deprecated [opaque pointer types]
-  static InvokeInst *Create(Value *Func, BasicBlock *IfNormal,
-                            BasicBlock *IfException, ArrayRef<Value *> Args,
-                            const Twine &NameStr,
-                            Instruction *InsertBefore = nullptr) {
-    return Create(cast<FunctionType>(
-                      cast<PointerType>(Func->getType())->getElementType()),
-                  Func, IfNormal, IfException, Args, None, NameStr,
-                  InsertBefore);
-  }
-
-  // Deprecated [opaque pointer types]
-  static InvokeInst *Create(Value *Func, BasicBlock *IfNormal,
-                            BasicBlock *IfException, ArrayRef<Value *> Args,
-                            ArrayRef<OperandBundleDef> Bundles = None,
-                            const Twine &NameStr = "",
-                            Instruction *InsertBefore = nullptr) {
-    return Create(cast<FunctionType>(
-                      cast<PointerType>(Func->getType())->getElementType()),
-                  Func, IfNormal, IfException, Args, Bundles, NameStr,
-                  InsertBefore);
-  }
-
-  // Deprecated [opaque pointer types]
-  static InvokeInst *Create(Value *Func, BasicBlock *IfNormal,
-                            BasicBlock *IfException, ArrayRef<Value *> Args,
-                            const Twine &NameStr, BasicBlock *InsertAtEnd) {
-    return Create(cast<FunctionType>(
-                      cast<PointerType>(Func->getType())->getElementType()),
-                  Func, IfNormal, IfException, Args, NameStr, InsertAtEnd);
-  }
-
-  // Deprecated [opaque pointer types]
-  static InvokeInst *Create(Value *Func, BasicBlock *IfNormal,
-                            BasicBlock *IfException, ArrayRef<Value *> Args,
-                            ArrayRef<OperandBundleDef> Bundles,
-                            const Twine &NameStr, BasicBlock *InsertAtEnd) {
-    return Create(cast<FunctionType>(
-                      cast<PointerType>(Func->getType())->getElementType()),
-                  Func, IfNormal, IfException, Args, Bundles, NameStr,
-                  InsertAtEnd);
-  }
-
   /// Create a clone of \p II with a different set of operand bundles and
   /// insert it before \p InsertPt.
   ///
@@ -3826,14 +3824,15 @@
   static InvokeInst *Create(InvokeInst *II, ArrayRef<OperandBundleDef> Bundles,
                             Instruction *InsertPt = nullptr);
 
-  /// Determine if the call should not perform indirect branch tracking.
-  bool doesNoCfCheck() const { return hasFnAttr(Attribute::NoCfCheck); }
-
-  /// Determine if the call cannot unwind.
-  bool doesNotThrow() const { return hasFnAttr(Attribute::NoUnwind); }
-  void setDoesNotThrow() {
-    addAttribute(AttributeList::FunctionIndex, Attribute::NoUnwind);
-  }
+  /// Create a clone of \p II with a different set of operand bundles and
+  /// insert it before \p InsertPt.
+  ///
+  /// The returned invoke instruction is identical to \p II in every way except
+  /// that the operand bundle for the new instruction is set to the operand
+  /// bundle in \p Bundle.
+  static InvokeInst *CreateWithReplacedBundle(InvokeInst *II,
+                                              OperandBundleDef Bundles,
+                                              Instruction *InsertPt = nullptr);
 
   // get*Dest - Return the destination basic blocks...
   BasicBlock *getNormalDest() const {
@@ -3877,11 +3876,11 @@
   }
 
 private:
-
   // Shadow Instruction::setInstructionSubclassData with a private forwarding
   // method so that subclasses cannot accidentally use it.
-  void setInstructionSubclassData(unsigned short D) {
-    Instruction::setInstructionSubclassData(D);
+  template <typename Bitfield>
+  void setSubclassData(typename Bitfield::Type Value) {
+    Instruction::setSubclassData<Bitfield>(Value);
   }
 };
 
@@ -4117,11 +4116,11 @@
   }
 
 private:
-
   // Shadow Instruction::setInstructionSubclassData with a private forwarding
   // method so that subclasses cannot accidentally use it.
-  void setInstructionSubclassData(unsigned short D) {
-    Instruction::setInstructionSubclassData(D);
+  template <typename Bitfield>
+  void setSubclassData(typename Bitfield::Type Value) {
+    Instruction::setSubclassData<Bitfield>(Value);
   }
 };
 
@@ -4141,13 +4140,9 @@
                        ArrayRef<Value *> Args,
                        ArrayRef<OperandBundleDef> Bundles, int NumOperands,
                        const Twine &NameStr, BasicBlock *InsertAtEnd)
-    : CallBase(
-          cast<FunctionType>(
-              cast<PointerType>(Func->getType())->getElementType())
-              ->getReturnType(),
-          Instruction::CallBr,
-          OperandTraits<CallBase>::op_end(this) - NumOperands, NumOperands,
-          InsertAtEnd) {
+    : CallBase(Ty->getReturnType(), Instruction::CallBr,
+               OperandTraits<CallBase>::op_end(this) - NumOperands, NumOperands,
+               InsertAtEnd) {
   init(Ty, Func, DefaultDest, IndirectDests, Args, Bundles, NameStr);
 }
 
@@ -4216,6 +4211,8 @@
 //                         CatchSwitchInst Class
 //===----------------------------------------------------------------------===//
 class CatchSwitchInst : public Instruction {
+  using UnwindDestField = BoolBitfieldElementT<0>;
+
   /// The number of operands actually allocated.  NumOperands is
   /// the number actually in use.
   unsigned ReservedSpace;
@@ -4277,7 +4274,7 @@
   void setParentPad(Value *ParentPad) { setOperand(0, ParentPad); }
 
   // Accessor Methods for CatchSwitch stmt
-  bool hasUnwindDest() const { return getSubclassDataFromInstruction() & 1; }
+  bool hasUnwindDest() const { return getSubclassData<UnwindDestField>(); }
   bool unwindsToCaller() const { return !hasUnwindDest(); }
   BasicBlock *getUnwindDest() const {
     if (hasUnwindDest())
@@ -4563,6 +4560,8 @@
 //===----------------------------------------------------------------------===//
 
 class CleanupReturnInst : public Instruction {
+  using UnwindDestField = BoolBitfieldElementT<0>;
+
 private:
   CleanupReturnInst(const CleanupReturnInst &RI);
   CleanupReturnInst(Value *CleanupPad, BasicBlock *UnwindBB, unsigned Values,
@@ -4603,7 +4602,7 @@
   /// Provide fast operand accessors
   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
 
-  bool hasUnwindDest() const { return getSubclassDataFromInstruction() & 1; }
+  bool hasUnwindDest() const { return getSubclassData<UnwindDestField>(); }
   bool unwindsToCaller() const { return !hasUnwindDest(); }
 
   /// Convenience accessor.
@@ -4647,8 +4646,9 @@
 
   // Shadow Instruction::setInstructionSubclassData with a private forwarding
   // method so that subclasses cannot accidentally use it.
-  void setInstructionSubclassData(unsigned short D) {
-    Instruction::setInstructionSubclassData(D);
+  template <typename Bitfield>
+  void setSubclassData(typename Bitfield::Type Value) {
+    Instruction::setSubclassData<Bitfield>(Value);
   }
 };
 
@@ -5254,31 +5254,38 @@
 
 /// A helper function that returns the pointer operand of a load or store
 /// instruction. Returns nullptr if not load or store.
-inline Value *getLoadStorePointerOperand(Value *V) {
+inline const Value *getLoadStorePointerOperand(const Value *V) {
   if (auto *Load = dyn_cast<LoadInst>(V))
     return Load->getPointerOperand();
   if (auto *Store = dyn_cast<StoreInst>(V))
     return Store->getPointerOperand();
   return nullptr;
 }
+inline Value *getLoadStorePointerOperand(Value *V) {
+  return const_cast<Value *>(
+      getLoadStorePointerOperand(static_cast<const Value *>(V)));
+}
 
 /// A helper function that returns the pointer operand of a load, store
 /// or GEP instruction. Returns nullptr if not load, store, or GEP.
-inline Value *getPointerOperand(Value *V) {
+inline const Value *getPointerOperand(const Value *V) {
   if (auto *Ptr = getLoadStorePointerOperand(V))
     return Ptr;
   if (auto *Gep = dyn_cast<GetElementPtrInst>(V))
     return Gep->getPointerOperand();
   return nullptr;
 }
+inline Value *getPointerOperand(Value *V) {
+  return const_cast<Value *>(getPointerOperand(static_cast<const Value *>(V)));
+}
 
 /// A helper function that returns the alignment of load or store instruction.
-inline unsigned getLoadStoreAlignment(Value *I) {
+inline Align getLoadStoreAlignment(Value *I) {
   assert((isa<LoadInst>(I) || isa<StoreInst>(I)) &&
          "Expected Load or Store instruction");
   if (auto *LI = dyn_cast<LoadInst>(I))
-    return LI->getAlignment();
-  return cast<StoreInst>(I)->getAlignment();
+    return LI->getAlign();
+  return cast<StoreInst>(I)->getAlign();
 }
 
 /// A helper function that returns the address space of the pointer operand of
@@ -5291,6 +5298,35 @@
   return cast<StoreInst>(I)->getPointerAddressSpace();
 }
 
+//===----------------------------------------------------------------------===//
+//                              FreezeInst Class
+//===----------------------------------------------------------------------===//
+
+/// This class represents a freeze function that returns random concrete
+/// value if an operand is either a poison value or an undef value
+class FreezeInst : public UnaryInstruction {
+protected:
+  // Note: Instruction needs to be a friend here to call cloneImpl.
+  friend class Instruction;
+
+  /// Clone an identical FreezeInst
+  FreezeInst *cloneImpl() const;
+
+public:
+  explicit FreezeInst(Value *S,
+                      const Twine &NameStr = "",
+                      Instruction *InsertBefore = nullptr);
+  FreezeInst(Value *S, const Twine &NameStr, BasicBlock *InsertAtEnd);
+
+  // Methods for support type inquiry through isa, cast, and dyn_cast:
+  static inline bool classof(const Instruction *I) {
+    return I->getOpcode() == Freeze;
+  }
+  static inline bool classof(const Value *V) {
+    return isa<Instruction>(V) && classof(cast<Instruction>(V));
+  }
+};
+
 } // end namespace llvm
 
 #endif // LLVM_IR_INSTRUCTIONS_H
diff --git a/linux-x64/clang/include/llvm/IR/IntrinsicEnums.inc b/linux-x64/clang/include/llvm/IR/IntrinsicEnums.inc
index 6123806..c89a520 100644
--- a/linux-x64/clang/include/llvm/IR/IntrinsicEnums.inc
+++ b/linux-x64/clang/include/llvm/IR/IntrinsicEnums.inc
@@ -6,22 +6,17 @@
 |*                                                                            *|
 \*===----------------------------------------------------------------------===*/
 
-// VisualStudio defines setjmp as _setjmp
-#if defined(_MSC_VER) && defined(setjmp) && \
-                         !defined(setjmp_undefined_for_msvc)
-#  pragma push_macro("setjmp")
-#  undef setjmp
-#  define setjmp_undefined_for_msvc
-#endif
-
-// Enum values for Intrinsics.h
-#ifdef GET_INTRINSIC_ENUM_VALUES
+// Enum values for intrinsics
+    abs = 1,                                       // llvm.abs
     addressofreturnaddress,                    // llvm.addressofreturnaddress
     adjust_trampoline,                         // llvm.adjust.trampoline
     annotation,                                // llvm.annotation
     assume,                                    // llvm.assume
     bitreverse,                                // llvm.bitreverse
     bswap,                                     // llvm.bswap
+    call_preallocated_arg,                     // llvm.call.preallocated.arg
+    call_preallocated_setup,                   // llvm.call.preallocated.setup
+    call_preallocated_teardown,                // llvm.call.preallocated.teardown
     canonicalize,                              // llvm.canonicalize
     ceil,                                      // llvm.ceil
     clear_cache,                               // llvm.clear_cache
@@ -30,21 +25,35 @@
     convert_to_fp16,                           // llvm.convert.to.fp16
     copysign,                                  // llvm.copysign
     coro_alloc,                                // llvm.coro.alloc
+    coro_alloca_alloc,                         // llvm.coro.alloca.alloc
+    coro_alloca_free,                          // llvm.coro.alloca.free
+    coro_alloca_get,                           // llvm.coro.alloca.get
+    coro_async_context_alloc,                  // llvm.coro.async.context.alloc
+    coro_async_context_dealloc,                // llvm.coro.async.context.dealloc
+    coro_async_resume,                         // llvm.coro.async.resume
     coro_begin,                                // llvm.coro.begin
     coro_destroy,                              // llvm.coro.destroy
     coro_done,                                 // llvm.coro.done
     coro_end,                                  // llvm.coro.end
+    coro_end_async,                            // llvm.coro.end.async
     coro_frame,                                // llvm.coro.frame
     coro_free,                                 // llvm.coro.free
     coro_id,                                   // llvm.coro.id
+    coro_id_async,                             // llvm.coro.id.async
+    coro_id_retcon,                            // llvm.coro.id.retcon
+    coro_id_retcon_once,                       // llvm.coro.id.retcon.once
     coro_noop,                                 // llvm.coro.noop
     coro_param,                                // llvm.coro.param
+    coro_prepare_async,                        // llvm.coro.prepare.async
+    coro_prepare_retcon,                       // llvm.coro.prepare.retcon
     coro_promise,                              // llvm.coro.promise
     coro_resume,                               // llvm.coro.resume
     coro_save,                                 // llvm.coro.save
     coro_size,                                 // llvm.coro.size
     coro_subfn_addr,                           // llvm.coro.subfn.addr
     coro_suspend,                              // llvm.coro.suspend
+    coro_suspend_async,                        // llvm.coro.suspend.async
+    coro_suspend_retcon,                       // llvm.coro.suspend.retcon
     cos,                                       // llvm.cos
     ctlz,                                      // llvm.ctlz
     ctpop,                                     // llvm.ctpop
@@ -72,32 +81,47 @@
     exp,                                       // llvm.exp
     exp2,                                      // llvm.exp2
     expect,                                    // llvm.expect
+    expect_with_probability,                   // llvm.expect.with.probability
     experimental_constrained_ceil,             // llvm.experimental.constrained.ceil
     experimental_constrained_cos,              // llvm.experimental.constrained.cos
     experimental_constrained_exp,              // llvm.experimental.constrained.exp
     experimental_constrained_exp2,             // llvm.experimental.constrained.exp2
     experimental_constrained_fadd,             // llvm.experimental.constrained.fadd
+    experimental_constrained_fcmp,             // llvm.experimental.constrained.fcmp
+    experimental_constrained_fcmps,            // llvm.experimental.constrained.fcmps
     experimental_constrained_fdiv,             // llvm.experimental.constrained.fdiv
     experimental_constrained_floor,            // llvm.experimental.constrained.floor
     experimental_constrained_fma,              // llvm.experimental.constrained.fma
     experimental_constrained_fmul,             // llvm.experimental.constrained.fmul
+    experimental_constrained_fmuladd,          // llvm.experimental.constrained.fmuladd
     experimental_constrained_fpext,            // llvm.experimental.constrained.fpext
+    experimental_constrained_fptosi,           // llvm.experimental.constrained.fptosi
+    experimental_constrained_fptoui,           // llvm.experimental.constrained.fptoui
     experimental_constrained_fptrunc,          // llvm.experimental.constrained.fptrunc
     experimental_constrained_frem,             // llvm.experimental.constrained.frem
     experimental_constrained_fsub,             // llvm.experimental.constrained.fsub
+    experimental_constrained_llrint,           // llvm.experimental.constrained.llrint
+    experimental_constrained_llround,          // llvm.experimental.constrained.llround
     experimental_constrained_log,              // llvm.experimental.constrained.log
     experimental_constrained_log10,            // llvm.experimental.constrained.log10
     experimental_constrained_log2,             // llvm.experimental.constrained.log2
+    experimental_constrained_lrint,            // llvm.experimental.constrained.lrint
+    experimental_constrained_lround,           // llvm.experimental.constrained.lround
+    experimental_constrained_maximum,          // llvm.experimental.constrained.maximum
     experimental_constrained_maxnum,           // llvm.experimental.constrained.maxnum
+    experimental_constrained_minimum,          // llvm.experimental.constrained.minimum
     experimental_constrained_minnum,           // llvm.experimental.constrained.minnum
     experimental_constrained_nearbyint,        // llvm.experimental.constrained.nearbyint
     experimental_constrained_pow,              // llvm.experimental.constrained.pow
     experimental_constrained_powi,             // llvm.experimental.constrained.powi
     experimental_constrained_rint,             // llvm.experimental.constrained.rint
     experimental_constrained_round,            // llvm.experimental.constrained.round
+    experimental_constrained_roundeven,        // llvm.experimental.constrained.roundeven
     experimental_constrained_sin,              // llvm.experimental.constrained.sin
+    experimental_constrained_sitofp,           // llvm.experimental.constrained.sitofp
     experimental_constrained_sqrt,             // llvm.experimental.constrained.sqrt
     experimental_constrained_trunc,            // llvm.experimental.constrained.trunc
+    experimental_constrained_uitofp,           // llvm.experimental.constrained.uitofp
     experimental_deoptimize,                   // llvm.experimental.deoptimize
     experimental_gc_relocate,                  // llvm.experimental.gc.relocate
     experimental_gc_result,                    // llvm.experimental.gc.result
@@ -106,33 +130,26 @@
     experimental_patchpoint_i64,               // llvm.experimental.patchpoint.i64
     experimental_patchpoint_void,              // llvm.experimental.patchpoint.void
     experimental_stackmap,                     // llvm.experimental.stackmap
-    experimental_vector_reduce_add,            // llvm.experimental.vector.reduce.add
-    experimental_vector_reduce_and,            // llvm.experimental.vector.reduce.and
-    experimental_vector_reduce_fmax,           // llvm.experimental.vector.reduce.fmax
-    experimental_vector_reduce_fmin,           // llvm.experimental.vector.reduce.fmin
-    experimental_vector_reduce_mul,            // llvm.experimental.vector.reduce.mul
-    experimental_vector_reduce_or,             // llvm.experimental.vector.reduce.or
-    experimental_vector_reduce_smax,           // llvm.experimental.vector.reduce.smax
-    experimental_vector_reduce_smin,           // llvm.experimental.vector.reduce.smin
-    experimental_vector_reduce_umax,           // llvm.experimental.vector.reduce.umax
-    experimental_vector_reduce_umin,           // llvm.experimental.vector.reduce.umin
-    experimental_vector_reduce_v2_fadd,        // llvm.experimental.vector.reduce.v2.fadd
-    experimental_vector_reduce_v2_fmul,        // llvm.experimental.vector.reduce.v2.fmul
-    experimental_vector_reduce_xor,            // llvm.experimental.vector.reduce.xor
+    experimental_vector_extract,               // llvm.experimental.vector.extract
+    experimental_vector_insert,                // llvm.experimental.vector.insert
     experimental_widenable_condition,          // llvm.experimental.widenable.condition
     fabs,                                      // llvm.fabs
     floor,                                     // llvm.floor
     flt_rounds,                                // llvm.flt.rounds
     fma,                                       // llvm.fma
     fmuladd,                                   // llvm.fmuladd
+    fptosi_sat,                                // llvm.fptosi.sat
+    fptoui_sat,                                // llvm.fptoui.sat
     frameaddress,                              // llvm.frameaddress
     fshl,                                      // llvm.fshl
     fshr,                                      // llvm.fshr
     gcread,                                    // llvm.gcread
     gcroot,                                    // llvm.gcroot
     gcwrite,                                   // llvm.gcwrite
+    get_active_lane_mask,                      // llvm.get.active.lane.mask
     get_dynamic_area_offset,                   // llvm.get.dynamic.area.offset
     hwasan_check_memaccess,                    // llvm.hwasan.check.memaccess
+    hwasan_check_memaccess_shortgranules,      // llvm.hwasan.check.memaccess.shortgranules
     icall_branch_funnel,                       // llvm.icall.branch.funnel
     init_trampoline,                           // llvm.init.trampoline
     instrprof_increment,                       // llvm.instrprof.increment
@@ -153,7 +170,6 @@
     log,                                       // llvm.log
     log10,                                     // llvm.log10
     log2,                                      // llvm.log2
-    longjmp,                                   // llvm.longjmp
     loop_decrement,                            // llvm.loop.decrement
     loop_decrement_reg,                        // llvm.loop.decrement.reg
     lrint,                                     // llvm.lrint
@@ -164,10 +180,15 @@
     masked_load,                               // llvm.masked.load
     masked_scatter,                            // llvm.masked.scatter
     masked_store,                              // llvm.masked.store
+    matrix_column_major_load,                  // llvm.matrix.column.major.load
+    matrix_column_major_store,                 // llvm.matrix.column.major.store
+    matrix_multiply,                           // llvm.matrix.multiply
+    matrix_transpose,                          // llvm.matrix.transpose
     maximum,                                   // llvm.maximum
     maxnum,                                    // llvm.maxnum
     memcpy,                                    // llvm.memcpy
     memcpy_element_unordered_atomic,           // llvm.memcpy.element.unordered.atomic
+    memcpy_inline,                             // llvm.memcpy.inline
     memmove,                                   // llvm.memmove
     memmove_element_unordered_atomic,          // llvm.memmove.element.unordered.atomic
     memset,                                    // llvm.memset
@@ -213,32 +234,39 @@
     preserve_array_access_index,               // llvm.preserve.array.access.index
     preserve_struct_access_index,              // llvm.preserve.struct.access.index
     preserve_union_access_index,               // llvm.preserve.union.access.index
+    pseudoprobe,                               // llvm.pseudoprobe
     ptr_annotation,                            // llvm.ptr.annotation
+    ptrmask,                                   // llvm.ptrmask
     read_register,                             // llvm.read_register
+    read_volatile_register,                    // llvm.read_volatile_register
     readcyclecounter,                          // llvm.readcyclecounter
     returnaddress,                             // llvm.returnaddress
     rint,                                      // llvm.rint
     round,                                     // llvm.round
+    roundeven,                                 // llvm.roundeven
     sadd_sat,                                  // llvm.sadd.sat
     sadd_with_overflow,                        // llvm.sadd.with.overflow
+    sdiv_fix,                                  // llvm.sdiv.fix
+    sdiv_fix_sat,                              // llvm.sdiv.fix.sat
     set_loop_iterations,                       // llvm.set.loop.iterations
-    setjmp,                                    // llvm.setjmp
     sideeffect,                                // llvm.sideeffect
-    siglongjmp,                                // llvm.siglongjmp
-    sigsetjmp,                                 // llvm.sigsetjmp
     sin,                                       // llvm.sin
+    smax,                                      // llvm.smax
+    smin,                                      // llvm.smin
     smul_fix,                                  // llvm.smul.fix
     smul_fix_sat,                              // llvm.smul.fix.sat
     smul_with_overflow,                        // llvm.smul.with.overflow
     sponentry,                                 // llvm.sponentry
     sqrt,                                      // llvm.sqrt
     ssa_copy,                                  // llvm.ssa.copy
+    sshl_sat,                                  // llvm.sshl.sat
     ssub_sat,                                  // llvm.ssub.sat
     ssub_with_overflow,                        // llvm.ssub.with.overflow
     stackguard,                                // llvm.stackguard
     stackprotector,                            // llvm.stackprotector
     stackrestore,                              // llvm.stackrestore
     stacksave,                                 // llvm.stacksave
+    start_loop_iterations,                     // llvm.start.loop.iterations
     strip_invariant_group,                     // llvm.strip.invariant.group
     test_set_loop_iterations,                  // llvm.test.set.loop.iterations
     thread_pointer,                            // llvm.thread.pointer
@@ -248,6780 +276,49 @@
     type_test,                                 // llvm.type.test
     uadd_sat,                                  // llvm.uadd.sat
     uadd_with_overflow,                        // llvm.uadd.with.overflow
+    ubsantrap,                                 // llvm.ubsantrap
+    udiv_fix,                                  // llvm.udiv.fix
+    udiv_fix_sat,                              // llvm.udiv.fix.sat
+    umax,                                      // llvm.umax
+    umin,                                      // llvm.umin
     umul_fix,                                  // llvm.umul.fix
+    umul_fix_sat,                              // llvm.umul.fix.sat
     umul_with_overflow,                        // llvm.umul.with.overflow
+    ushl_sat,                                  // llvm.ushl.sat
     usub_sat,                                  // llvm.usub.sat
     usub_with_overflow,                        // llvm.usub.with.overflow
     vacopy,                                    // llvm.va_copy
     vaend,                                     // llvm.va_end
     vastart,                                   // llvm.va_start
     var_annotation,                            // llvm.var.annotation
+    vector_reduce_add,                         // llvm.vector.reduce.add
+    vector_reduce_and,                         // llvm.vector.reduce.and
+    vector_reduce_fadd,                        // llvm.vector.reduce.fadd
+    vector_reduce_fmax,                        // llvm.vector.reduce.fmax
+    vector_reduce_fmin,                        // llvm.vector.reduce.fmin
+    vector_reduce_fmul,                        // llvm.vector.reduce.fmul
+    vector_reduce_mul,                         // llvm.vector.reduce.mul
+    vector_reduce_or,                          // llvm.vector.reduce.or
+    vector_reduce_smax,                        // llvm.vector.reduce.smax
+    vector_reduce_smin,                        // llvm.vector.reduce.smin
+    vector_reduce_umax,                        // llvm.vector.reduce.umax
+    vector_reduce_umin,                        // llvm.vector.reduce.umin
+    vector_reduce_xor,                         // llvm.vector.reduce.xor
+    vp_add,                                    // llvm.vp.add
+    vp_and,                                    // llvm.vp.and
+    vp_ashr,                                   // llvm.vp.ashr
+    vp_lshr,                                   // llvm.vp.lshr
+    vp_mul,                                    // llvm.vp.mul
+    vp_or,                                     // llvm.vp.or
+    vp_sdiv,                                   // llvm.vp.sdiv
+    vp_shl,                                    // llvm.vp.shl
+    vp_srem,                                   // llvm.vp.srem
+    vp_sub,                                    // llvm.vp.sub
+    vp_udiv,                                   // llvm.vp.udiv
+    vp_urem,                                   // llvm.vp.urem
+    vp_xor,                                    // llvm.vp.xor
+    vscale,                                    // llvm.vscale
     write_register,                            // llvm.write_register
     xray_customevent,                          // llvm.xray.customevent
     xray_typedevent,                           // llvm.xray.typedevent
-    aarch64_addg,                              // llvm.aarch64.addg
-    aarch64_clrex,                             // llvm.aarch64.clrex
-    aarch64_crc32b,                            // llvm.aarch64.crc32b
-    aarch64_crc32cb,                           // llvm.aarch64.crc32cb
-    aarch64_crc32ch,                           // llvm.aarch64.crc32ch
-    aarch64_crc32cw,                           // llvm.aarch64.crc32cw
-    aarch64_crc32cx,                           // llvm.aarch64.crc32cx
-    aarch64_crc32h,                            // llvm.aarch64.crc32h
-    aarch64_crc32w,                            // llvm.aarch64.crc32w
-    aarch64_crc32x,                            // llvm.aarch64.crc32x
-    aarch64_crypto_aesd,                       // llvm.aarch64.crypto.aesd
-    aarch64_crypto_aese,                       // llvm.aarch64.crypto.aese
-    aarch64_crypto_aesimc,                     // llvm.aarch64.crypto.aesimc
-    aarch64_crypto_aesmc,                      // llvm.aarch64.crypto.aesmc
-    aarch64_crypto_sha1c,                      // llvm.aarch64.crypto.sha1c
-    aarch64_crypto_sha1h,                      // llvm.aarch64.crypto.sha1h
-    aarch64_crypto_sha1m,                      // llvm.aarch64.crypto.sha1m
-    aarch64_crypto_sha1p,                      // llvm.aarch64.crypto.sha1p
-    aarch64_crypto_sha1su0,                    // llvm.aarch64.crypto.sha1su0
-    aarch64_crypto_sha1su1,                    // llvm.aarch64.crypto.sha1su1
-    aarch64_crypto_sha256h,                    // llvm.aarch64.crypto.sha256h
-    aarch64_crypto_sha256h2,                   // llvm.aarch64.crypto.sha256h2
-    aarch64_crypto_sha256su0,                  // llvm.aarch64.crypto.sha256su0
-    aarch64_crypto_sha256su1,                  // llvm.aarch64.crypto.sha256su1
-    aarch64_dmb,                               // llvm.aarch64.dmb
-    aarch64_dsb,                               // llvm.aarch64.dsb
-    aarch64_get_fpcr,                          // llvm.aarch64.get.fpcr
-    aarch64_gmi,                               // llvm.aarch64.gmi
-    aarch64_hint,                              // llvm.aarch64.hint
-    aarch64_irg,                               // llvm.aarch64.irg
-    aarch64_isb,                               // llvm.aarch64.isb
-    aarch64_ldaxp,                             // llvm.aarch64.ldaxp
-    aarch64_ldaxr,                             // llvm.aarch64.ldaxr
-    aarch64_ldg,                               // llvm.aarch64.ldg
-    aarch64_ldxp,                              // llvm.aarch64.ldxp
-    aarch64_ldxr,                              // llvm.aarch64.ldxr
-    aarch64_neon_abs,                          // llvm.aarch64.neon.abs
-    aarch64_neon_addhn,                        // llvm.aarch64.neon.addhn
-    aarch64_neon_addp,                         // llvm.aarch64.neon.addp
-    aarch64_neon_cls,                          // llvm.aarch64.neon.cls
-    aarch64_neon_fabd,                         // llvm.aarch64.neon.fabd
-    aarch64_neon_facge,                        // llvm.aarch64.neon.facge
-    aarch64_neon_facgt,                        // llvm.aarch64.neon.facgt
-    aarch64_neon_faddp,                        // llvm.aarch64.neon.faddp
-    aarch64_neon_faddv,                        // llvm.aarch64.neon.faddv
-    aarch64_neon_fcvtas,                       // llvm.aarch64.neon.fcvtas
-    aarch64_neon_fcvtau,                       // llvm.aarch64.neon.fcvtau
-    aarch64_neon_fcvtms,                       // llvm.aarch64.neon.fcvtms
-    aarch64_neon_fcvtmu,                       // llvm.aarch64.neon.fcvtmu
-    aarch64_neon_fcvtns,                       // llvm.aarch64.neon.fcvtns
-    aarch64_neon_fcvtnu,                       // llvm.aarch64.neon.fcvtnu
-    aarch64_neon_fcvtps,                       // llvm.aarch64.neon.fcvtps
-    aarch64_neon_fcvtpu,                       // llvm.aarch64.neon.fcvtpu
-    aarch64_neon_fcvtxn,                       // llvm.aarch64.neon.fcvtxn
-    aarch64_neon_fcvtzs,                       // llvm.aarch64.neon.fcvtzs
-    aarch64_neon_fcvtzu,                       // llvm.aarch64.neon.fcvtzu
-    aarch64_neon_fmax,                         // llvm.aarch64.neon.fmax
-    aarch64_neon_fmaxnm,                       // llvm.aarch64.neon.fmaxnm
-    aarch64_neon_fmaxnmp,                      // llvm.aarch64.neon.fmaxnmp
-    aarch64_neon_fmaxnmv,                      // llvm.aarch64.neon.fmaxnmv
-    aarch64_neon_fmaxp,                        // llvm.aarch64.neon.fmaxp
-    aarch64_neon_fmaxv,                        // llvm.aarch64.neon.fmaxv
-    aarch64_neon_fmin,                         // llvm.aarch64.neon.fmin
-    aarch64_neon_fminnm,                       // llvm.aarch64.neon.fminnm
-    aarch64_neon_fminnmp,                      // llvm.aarch64.neon.fminnmp
-    aarch64_neon_fminnmv,                      // llvm.aarch64.neon.fminnmv
-    aarch64_neon_fminp,                        // llvm.aarch64.neon.fminp
-    aarch64_neon_fminv,                        // llvm.aarch64.neon.fminv
-    aarch64_neon_fmlal,                        // llvm.aarch64.neon.fmlal
-    aarch64_neon_fmlal2,                       // llvm.aarch64.neon.fmlal2
-    aarch64_neon_fmlsl,                        // llvm.aarch64.neon.fmlsl
-    aarch64_neon_fmlsl2,                       // llvm.aarch64.neon.fmlsl2
-    aarch64_neon_fmulx,                        // llvm.aarch64.neon.fmulx
-    aarch64_neon_frecpe,                       // llvm.aarch64.neon.frecpe
-    aarch64_neon_frecps,                       // llvm.aarch64.neon.frecps
-    aarch64_neon_frecpx,                       // llvm.aarch64.neon.frecpx
-    aarch64_neon_frintn,                       // llvm.aarch64.neon.frintn
-    aarch64_neon_frsqrte,                      // llvm.aarch64.neon.frsqrte
-    aarch64_neon_frsqrts,                      // llvm.aarch64.neon.frsqrts
-    aarch64_neon_ld1x2,                        // llvm.aarch64.neon.ld1x2
-    aarch64_neon_ld1x3,                        // llvm.aarch64.neon.ld1x3
-    aarch64_neon_ld1x4,                        // llvm.aarch64.neon.ld1x4
-    aarch64_neon_ld2,                          // llvm.aarch64.neon.ld2
-    aarch64_neon_ld2lane,                      // llvm.aarch64.neon.ld2lane
-    aarch64_neon_ld2r,                         // llvm.aarch64.neon.ld2r
-    aarch64_neon_ld3,                          // llvm.aarch64.neon.ld3
-    aarch64_neon_ld3lane,                      // llvm.aarch64.neon.ld3lane
-    aarch64_neon_ld3r,                         // llvm.aarch64.neon.ld3r
-    aarch64_neon_ld4,                          // llvm.aarch64.neon.ld4
-    aarch64_neon_ld4lane,                      // llvm.aarch64.neon.ld4lane
-    aarch64_neon_ld4r,                         // llvm.aarch64.neon.ld4r
-    aarch64_neon_pmul,                         // llvm.aarch64.neon.pmul
-    aarch64_neon_pmull,                        // llvm.aarch64.neon.pmull
-    aarch64_neon_pmull64,                      // llvm.aarch64.neon.pmull64
-    aarch64_neon_raddhn,                       // llvm.aarch64.neon.raddhn
-    aarch64_neon_rbit,                         // llvm.aarch64.neon.rbit
-    aarch64_neon_rshrn,                        // llvm.aarch64.neon.rshrn
-    aarch64_neon_rsubhn,                       // llvm.aarch64.neon.rsubhn
-    aarch64_neon_sabd,                         // llvm.aarch64.neon.sabd
-    aarch64_neon_saddlp,                       // llvm.aarch64.neon.saddlp
-    aarch64_neon_saddlv,                       // llvm.aarch64.neon.saddlv
-    aarch64_neon_saddv,                        // llvm.aarch64.neon.saddv
-    aarch64_neon_scalar_sqxtn,                 // llvm.aarch64.neon.scalar.sqxtn
-    aarch64_neon_scalar_sqxtun,                // llvm.aarch64.neon.scalar.sqxtun
-    aarch64_neon_scalar_uqxtn,                 // llvm.aarch64.neon.scalar.uqxtn
-    aarch64_neon_sdot,                         // llvm.aarch64.neon.sdot
-    aarch64_neon_shadd,                        // llvm.aarch64.neon.shadd
-    aarch64_neon_shll,                         // llvm.aarch64.neon.shll
-    aarch64_neon_shsub,                        // llvm.aarch64.neon.shsub
-    aarch64_neon_smax,                         // llvm.aarch64.neon.smax
-    aarch64_neon_smaxp,                        // llvm.aarch64.neon.smaxp
-    aarch64_neon_smaxv,                        // llvm.aarch64.neon.smaxv
-    aarch64_neon_smin,                         // llvm.aarch64.neon.smin
-    aarch64_neon_sminp,                        // llvm.aarch64.neon.sminp
-    aarch64_neon_sminv,                        // llvm.aarch64.neon.sminv
-    aarch64_neon_smull,                        // llvm.aarch64.neon.smull
-    aarch64_neon_sqabs,                        // llvm.aarch64.neon.sqabs
-    aarch64_neon_sqadd,                        // llvm.aarch64.neon.sqadd
-    aarch64_neon_sqdmulh,                      // llvm.aarch64.neon.sqdmulh
-    aarch64_neon_sqdmull,                      // llvm.aarch64.neon.sqdmull
-    aarch64_neon_sqdmulls_scalar,              // llvm.aarch64.neon.sqdmulls.scalar
-    aarch64_neon_sqneg,                        // llvm.aarch64.neon.sqneg
-    aarch64_neon_sqrdmulh,                     // llvm.aarch64.neon.sqrdmulh
-    aarch64_neon_sqrshl,                       // llvm.aarch64.neon.sqrshl
-    aarch64_neon_sqrshrn,                      // llvm.aarch64.neon.sqrshrn
-    aarch64_neon_sqrshrun,                     // llvm.aarch64.neon.sqrshrun
-    aarch64_neon_sqshl,                        // llvm.aarch64.neon.sqshl
-    aarch64_neon_sqshlu,                       // llvm.aarch64.neon.sqshlu
-    aarch64_neon_sqshrn,                       // llvm.aarch64.neon.sqshrn
-    aarch64_neon_sqshrun,                      // llvm.aarch64.neon.sqshrun
-    aarch64_neon_sqsub,                        // llvm.aarch64.neon.sqsub
-    aarch64_neon_sqxtn,                        // llvm.aarch64.neon.sqxtn
-    aarch64_neon_sqxtun,                       // llvm.aarch64.neon.sqxtun
-    aarch64_neon_srhadd,                       // llvm.aarch64.neon.srhadd
-    aarch64_neon_srshl,                        // llvm.aarch64.neon.srshl
-    aarch64_neon_sshl,                         // llvm.aarch64.neon.sshl
-    aarch64_neon_sshll,                        // llvm.aarch64.neon.sshll
-    aarch64_neon_st1x2,                        // llvm.aarch64.neon.st1x2
-    aarch64_neon_st1x3,                        // llvm.aarch64.neon.st1x3
-    aarch64_neon_st1x4,                        // llvm.aarch64.neon.st1x4
-    aarch64_neon_st2,                          // llvm.aarch64.neon.st2
-    aarch64_neon_st2lane,                      // llvm.aarch64.neon.st2lane
-    aarch64_neon_st3,                          // llvm.aarch64.neon.st3
-    aarch64_neon_st3lane,                      // llvm.aarch64.neon.st3lane
-    aarch64_neon_st4,                          // llvm.aarch64.neon.st4
-    aarch64_neon_st4lane,                      // llvm.aarch64.neon.st4lane
-    aarch64_neon_subhn,                        // llvm.aarch64.neon.subhn
-    aarch64_neon_suqadd,                       // llvm.aarch64.neon.suqadd
-    aarch64_neon_tbl1,                         // llvm.aarch64.neon.tbl1
-    aarch64_neon_tbl2,                         // llvm.aarch64.neon.tbl2
-    aarch64_neon_tbl3,                         // llvm.aarch64.neon.tbl3
-    aarch64_neon_tbl4,                         // llvm.aarch64.neon.tbl4
-    aarch64_neon_tbx1,                         // llvm.aarch64.neon.tbx1
-    aarch64_neon_tbx2,                         // llvm.aarch64.neon.tbx2
-    aarch64_neon_tbx3,                         // llvm.aarch64.neon.tbx3
-    aarch64_neon_tbx4,                         // llvm.aarch64.neon.tbx4
-    aarch64_neon_uabd,                         // llvm.aarch64.neon.uabd
-    aarch64_neon_uaddlp,                       // llvm.aarch64.neon.uaddlp
-    aarch64_neon_uaddlv,                       // llvm.aarch64.neon.uaddlv
-    aarch64_neon_uaddv,                        // llvm.aarch64.neon.uaddv
-    aarch64_neon_udot,                         // llvm.aarch64.neon.udot
-    aarch64_neon_uhadd,                        // llvm.aarch64.neon.uhadd
-    aarch64_neon_uhsub,                        // llvm.aarch64.neon.uhsub
-    aarch64_neon_umax,                         // llvm.aarch64.neon.umax
-    aarch64_neon_umaxp,                        // llvm.aarch64.neon.umaxp
-    aarch64_neon_umaxv,                        // llvm.aarch64.neon.umaxv
-    aarch64_neon_umin,                         // llvm.aarch64.neon.umin
-    aarch64_neon_uminp,                        // llvm.aarch64.neon.uminp
-    aarch64_neon_uminv,                        // llvm.aarch64.neon.uminv
-    aarch64_neon_umull,                        // llvm.aarch64.neon.umull
-    aarch64_neon_uqadd,                        // llvm.aarch64.neon.uqadd
-    aarch64_neon_uqrshl,                       // llvm.aarch64.neon.uqrshl
-    aarch64_neon_uqrshrn,                      // llvm.aarch64.neon.uqrshrn
-    aarch64_neon_uqshl,                        // llvm.aarch64.neon.uqshl
-    aarch64_neon_uqshrn,                       // llvm.aarch64.neon.uqshrn
-    aarch64_neon_uqsub,                        // llvm.aarch64.neon.uqsub
-    aarch64_neon_uqxtn,                        // llvm.aarch64.neon.uqxtn
-    aarch64_neon_urecpe,                       // llvm.aarch64.neon.urecpe
-    aarch64_neon_urhadd,                       // llvm.aarch64.neon.urhadd
-    aarch64_neon_urshl,                        // llvm.aarch64.neon.urshl
-    aarch64_neon_ursqrte,                      // llvm.aarch64.neon.ursqrte
-    aarch64_neon_ushl,                         // llvm.aarch64.neon.ushl
-    aarch64_neon_ushll,                        // llvm.aarch64.neon.ushll
-    aarch64_neon_usqadd,                       // llvm.aarch64.neon.usqadd
-    aarch64_neon_vcopy_lane,                   // llvm.aarch64.neon.vcopy.lane
-    aarch64_neon_vcvtfp2fxs,                   // llvm.aarch64.neon.vcvtfp2fxs
-    aarch64_neon_vcvtfp2fxu,                   // llvm.aarch64.neon.vcvtfp2fxu
-    aarch64_neon_vcvtfp2hf,                    // llvm.aarch64.neon.vcvtfp2hf
-    aarch64_neon_vcvtfxs2fp,                   // llvm.aarch64.neon.vcvtfxs2fp
-    aarch64_neon_vcvtfxu2fp,                   // llvm.aarch64.neon.vcvtfxu2fp
-    aarch64_neon_vcvthf2fp,                    // llvm.aarch64.neon.vcvthf2fp
-    aarch64_neon_vsli,                         // llvm.aarch64.neon.vsli
-    aarch64_neon_vsri,                         // llvm.aarch64.neon.vsri
-    aarch64_sdiv,                              // llvm.aarch64.sdiv
-    aarch64_sisd_fabd,                         // llvm.aarch64.sisd.fabd
-    aarch64_sisd_fcvtxn,                       // llvm.aarch64.sisd.fcvtxn
-    aarch64_space,                             // llvm.aarch64.space
-    aarch64_stg,                               // llvm.aarch64.stg
-    aarch64_stlxp,                             // llvm.aarch64.stlxp
-    aarch64_stlxr,                             // llvm.aarch64.stlxr
-    aarch64_stxp,                              // llvm.aarch64.stxp
-    aarch64_stxr,                              // llvm.aarch64.stxr
-    aarch64_subp,                              // llvm.aarch64.subp
-    aarch64_udiv,                              // llvm.aarch64.udiv
-    amdgcn_alignbit,                           // llvm.amdgcn.alignbit
-    amdgcn_alignbyte,                          // llvm.amdgcn.alignbyte
-    amdgcn_atomic_dec,                         // llvm.amdgcn.atomic.dec
-    amdgcn_atomic_inc,                         // llvm.amdgcn.atomic.inc
-    amdgcn_buffer_atomic_add,                  // llvm.amdgcn.buffer.atomic.add
-    amdgcn_buffer_atomic_and,                  // llvm.amdgcn.buffer.atomic.and
-    amdgcn_buffer_atomic_cmpswap,              // llvm.amdgcn.buffer.atomic.cmpswap
-    amdgcn_buffer_atomic_or,                   // llvm.amdgcn.buffer.atomic.or
-    amdgcn_buffer_atomic_smax,                 // llvm.amdgcn.buffer.atomic.smax
-    amdgcn_buffer_atomic_smin,                 // llvm.amdgcn.buffer.atomic.smin
-    amdgcn_buffer_atomic_sub,                  // llvm.amdgcn.buffer.atomic.sub
-    amdgcn_buffer_atomic_swap,                 // llvm.amdgcn.buffer.atomic.swap
-    amdgcn_buffer_atomic_umax,                 // llvm.amdgcn.buffer.atomic.umax
-    amdgcn_buffer_atomic_umin,                 // llvm.amdgcn.buffer.atomic.umin
-    amdgcn_buffer_atomic_xor,                  // llvm.amdgcn.buffer.atomic.xor
-    amdgcn_buffer_load,                        // llvm.amdgcn.buffer.load
-    amdgcn_buffer_load_format,                 // llvm.amdgcn.buffer.load.format
-    amdgcn_buffer_store,                       // llvm.amdgcn.buffer.store
-    amdgcn_buffer_store_format,                // llvm.amdgcn.buffer.store.format
-    amdgcn_buffer_wbinvl1,                     // llvm.amdgcn.buffer.wbinvl1
-    amdgcn_buffer_wbinvl1_sc,                  // llvm.amdgcn.buffer.wbinvl1.sc
-    amdgcn_buffer_wbinvl1_vol,                 // llvm.amdgcn.buffer.wbinvl1.vol
-    amdgcn_class,                              // llvm.amdgcn.class
-    amdgcn_cos,                                // llvm.amdgcn.cos
-    amdgcn_cubeid,                             // llvm.amdgcn.cubeid
-    amdgcn_cubema,                             // llvm.amdgcn.cubema
-    amdgcn_cubesc,                             // llvm.amdgcn.cubesc
-    amdgcn_cubetc,                             // llvm.amdgcn.cubetc
-    amdgcn_cvt_pk_i16,                         // llvm.amdgcn.cvt.pk.i16
-    amdgcn_cvt_pk_u16,                         // llvm.amdgcn.cvt.pk.u16
-    amdgcn_cvt_pk_u8_f32,                      // llvm.amdgcn.cvt.pk.u8.f32
-    amdgcn_cvt_pknorm_i16,                     // llvm.amdgcn.cvt.pknorm.i16
-    amdgcn_cvt_pknorm_u16,                     // llvm.amdgcn.cvt.pknorm.u16
-    amdgcn_cvt_pkrtz,                          // llvm.amdgcn.cvt.pkrtz
-    amdgcn_dispatch_id,                        // llvm.amdgcn.dispatch.id
-    amdgcn_dispatch_ptr,                       // llvm.amdgcn.dispatch.ptr
-    amdgcn_div_fixup,                          // llvm.amdgcn.div.fixup
-    amdgcn_div_fmas,                           // llvm.amdgcn.div.fmas
-    amdgcn_div_scale,                          // llvm.amdgcn.div.scale
-    amdgcn_ds_append,                          // llvm.amdgcn.ds.append
-    amdgcn_ds_bpermute,                        // llvm.amdgcn.ds.bpermute
-    amdgcn_ds_consume,                         // llvm.amdgcn.ds.consume
-    amdgcn_ds_fadd,                            // llvm.amdgcn.ds.fadd
-    amdgcn_ds_fmax,                            // llvm.amdgcn.ds.fmax
-    amdgcn_ds_fmin,                            // llvm.amdgcn.ds.fmin
-    amdgcn_ds_gws_barrier,                     // llvm.amdgcn.ds.gws.barrier
-    amdgcn_ds_gws_init,                        // llvm.amdgcn.ds.gws.init
-    amdgcn_ds_gws_sema_br,                     // llvm.amdgcn.ds.gws.sema.br
-    amdgcn_ds_gws_sema_p,                      // llvm.amdgcn.ds.gws.sema.p
-    amdgcn_ds_gws_sema_release_all,            // llvm.amdgcn.ds.gws.sema.release.all
-    amdgcn_ds_gws_sema_v,                      // llvm.amdgcn.ds.gws.sema.v
-    amdgcn_ds_ordered_add,                     // llvm.amdgcn.ds.ordered.add
-    amdgcn_ds_ordered_swap,                    // llvm.amdgcn.ds.ordered.swap
-    amdgcn_ds_permute,                         // llvm.amdgcn.ds.permute
-    amdgcn_ds_swizzle,                         // llvm.amdgcn.ds.swizzle
-    amdgcn_else,                               // llvm.amdgcn.else
-    amdgcn_end_cf,                             // llvm.amdgcn.end.cf
-    amdgcn_exp,                                // llvm.amdgcn.exp
-    amdgcn_exp_compr,                          // llvm.amdgcn.exp.compr
-    amdgcn_fcmp,                               // llvm.amdgcn.fcmp
-    amdgcn_fdiv_fast,                          // llvm.amdgcn.fdiv.fast
-    amdgcn_fdot2,                              // llvm.amdgcn.fdot2
-    amdgcn_fmad_ftz,                           // llvm.amdgcn.fmad.ftz
-    amdgcn_fmed3,                              // llvm.amdgcn.fmed3
-    amdgcn_fmul_legacy,                        // llvm.amdgcn.fmul.legacy
-    amdgcn_fract,                              // llvm.amdgcn.fract
-    amdgcn_frexp_exp,                          // llvm.amdgcn.frexp.exp
-    amdgcn_frexp_mant,                         // llvm.amdgcn.frexp.mant
-    amdgcn_groupstaticsize,                    // llvm.amdgcn.groupstaticsize
-    amdgcn_icmp,                               // llvm.amdgcn.icmp
-    amdgcn_if,                                 // llvm.amdgcn.if
-    amdgcn_if_break,                           // llvm.amdgcn.if.break
-    amdgcn_image_atomic_add_1d,                // llvm.amdgcn.image.atomic.add.1d
-    amdgcn_image_atomic_add_1darray,           // llvm.amdgcn.image.atomic.add.1darray
-    amdgcn_image_atomic_add_2d,                // llvm.amdgcn.image.atomic.add.2d
-    amdgcn_image_atomic_add_2darray,           // llvm.amdgcn.image.atomic.add.2darray
-    amdgcn_image_atomic_add_2darraymsaa,       // llvm.amdgcn.image.atomic.add.2darraymsaa
-    amdgcn_image_atomic_add_2dmsaa,            // llvm.amdgcn.image.atomic.add.2dmsaa
-    amdgcn_image_atomic_add_3d,                // llvm.amdgcn.image.atomic.add.3d
-    amdgcn_image_atomic_add_cube,              // llvm.amdgcn.image.atomic.add.cube
-    amdgcn_image_atomic_and_1d,                // llvm.amdgcn.image.atomic.and.1d
-    amdgcn_image_atomic_and_1darray,           // llvm.amdgcn.image.atomic.and.1darray
-    amdgcn_image_atomic_and_2d,                // llvm.amdgcn.image.atomic.and.2d
-    amdgcn_image_atomic_and_2darray,           // llvm.amdgcn.image.atomic.and.2darray
-    amdgcn_image_atomic_and_2darraymsaa,       // llvm.amdgcn.image.atomic.and.2darraymsaa
-    amdgcn_image_atomic_and_2dmsaa,            // llvm.amdgcn.image.atomic.and.2dmsaa
-    amdgcn_image_atomic_and_3d,                // llvm.amdgcn.image.atomic.and.3d
-    amdgcn_image_atomic_and_cube,              // llvm.amdgcn.image.atomic.and.cube
-    amdgcn_image_atomic_cmpswap_1d,            // llvm.amdgcn.image.atomic.cmpswap.1d
-    amdgcn_image_atomic_cmpswap_1darray,       // llvm.amdgcn.image.atomic.cmpswap.1darray
-    amdgcn_image_atomic_cmpswap_2d,            // llvm.amdgcn.image.atomic.cmpswap.2d
-    amdgcn_image_atomic_cmpswap_2darray,       // llvm.amdgcn.image.atomic.cmpswap.2darray
-    amdgcn_image_atomic_cmpswap_2darraymsaa,   // llvm.amdgcn.image.atomic.cmpswap.2darraymsaa
-    amdgcn_image_atomic_cmpswap_2dmsaa,        // llvm.amdgcn.image.atomic.cmpswap.2dmsaa
-    amdgcn_image_atomic_cmpswap_3d,            // llvm.amdgcn.image.atomic.cmpswap.3d
-    amdgcn_image_atomic_cmpswap_cube,          // llvm.amdgcn.image.atomic.cmpswap.cube
-    amdgcn_image_atomic_dec_1d,                // llvm.amdgcn.image.atomic.dec.1d
-    amdgcn_image_atomic_dec_1darray,           // llvm.amdgcn.image.atomic.dec.1darray
-    amdgcn_image_atomic_dec_2d,                // llvm.amdgcn.image.atomic.dec.2d
-    amdgcn_image_atomic_dec_2darray,           // llvm.amdgcn.image.atomic.dec.2darray
-    amdgcn_image_atomic_dec_2darraymsaa,       // llvm.amdgcn.image.atomic.dec.2darraymsaa
-    amdgcn_image_atomic_dec_2dmsaa,            // llvm.amdgcn.image.atomic.dec.2dmsaa
-    amdgcn_image_atomic_dec_3d,                // llvm.amdgcn.image.atomic.dec.3d
-    amdgcn_image_atomic_dec_cube,              // llvm.amdgcn.image.atomic.dec.cube
-    amdgcn_image_atomic_inc_1d,                // llvm.amdgcn.image.atomic.inc.1d
-    amdgcn_image_atomic_inc_1darray,           // llvm.amdgcn.image.atomic.inc.1darray
-    amdgcn_image_atomic_inc_2d,                // llvm.amdgcn.image.atomic.inc.2d
-    amdgcn_image_atomic_inc_2darray,           // llvm.amdgcn.image.atomic.inc.2darray
-    amdgcn_image_atomic_inc_2darraymsaa,       // llvm.amdgcn.image.atomic.inc.2darraymsaa
-    amdgcn_image_atomic_inc_2dmsaa,            // llvm.amdgcn.image.atomic.inc.2dmsaa
-    amdgcn_image_atomic_inc_3d,                // llvm.amdgcn.image.atomic.inc.3d
-    amdgcn_image_atomic_inc_cube,              // llvm.amdgcn.image.atomic.inc.cube
-    amdgcn_image_atomic_or_1d,                 // llvm.amdgcn.image.atomic.or.1d
-    amdgcn_image_atomic_or_1darray,            // llvm.amdgcn.image.atomic.or.1darray
-    amdgcn_image_atomic_or_2d,                 // llvm.amdgcn.image.atomic.or.2d
-    amdgcn_image_atomic_or_2darray,            // llvm.amdgcn.image.atomic.or.2darray
-    amdgcn_image_atomic_or_2darraymsaa,        // llvm.amdgcn.image.atomic.or.2darraymsaa
-    amdgcn_image_atomic_or_2dmsaa,             // llvm.amdgcn.image.atomic.or.2dmsaa
-    amdgcn_image_atomic_or_3d,                 // llvm.amdgcn.image.atomic.or.3d
-    amdgcn_image_atomic_or_cube,               // llvm.amdgcn.image.atomic.or.cube
-    amdgcn_image_atomic_smax_1d,               // llvm.amdgcn.image.atomic.smax.1d
-    amdgcn_image_atomic_smax_1darray,          // llvm.amdgcn.image.atomic.smax.1darray
-    amdgcn_image_atomic_smax_2d,               // llvm.amdgcn.image.atomic.smax.2d
-    amdgcn_image_atomic_smax_2darray,          // llvm.amdgcn.image.atomic.smax.2darray
-    amdgcn_image_atomic_smax_2darraymsaa,      // llvm.amdgcn.image.atomic.smax.2darraymsaa
-    amdgcn_image_atomic_smax_2dmsaa,           // llvm.amdgcn.image.atomic.smax.2dmsaa
-    amdgcn_image_atomic_smax_3d,               // llvm.amdgcn.image.atomic.smax.3d
-    amdgcn_image_atomic_smax_cube,             // llvm.amdgcn.image.atomic.smax.cube
-    amdgcn_image_atomic_smin_1d,               // llvm.amdgcn.image.atomic.smin.1d
-    amdgcn_image_atomic_smin_1darray,          // llvm.amdgcn.image.atomic.smin.1darray
-    amdgcn_image_atomic_smin_2d,               // llvm.amdgcn.image.atomic.smin.2d
-    amdgcn_image_atomic_smin_2darray,          // llvm.amdgcn.image.atomic.smin.2darray
-    amdgcn_image_atomic_smin_2darraymsaa,      // llvm.amdgcn.image.atomic.smin.2darraymsaa
-    amdgcn_image_atomic_smin_2dmsaa,           // llvm.amdgcn.image.atomic.smin.2dmsaa
-    amdgcn_image_atomic_smin_3d,               // llvm.amdgcn.image.atomic.smin.3d
-    amdgcn_image_atomic_smin_cube,             // llvm.amdgcn.image.atomic.smin.cube
-    amdgcn_image_atomic_sub_1d,                // llvm.amdgcn.image.atomic.sub.1d
-    amdgcn_image_atomic_sub_1darray,           // llvm.amdgcn.image.atomic.sub.1darray
-    amdgcn_image_atomic_sub_2d,                // llvm.amdgcn.image.atomic.sub.2d
-    amdgcn_image_atomic_sub_2darray,           // llvm.amdgcn.image.atomic.sub.2darray
-    amdgcn_image_atomic_sub_2darraymsaa,       // llvm.amdgcn.image.atomic.sub.2darraymsaa
-    amdgcn_image_atomic_sub_2dmsaa,            // llvm.amdgcn.image.atomic.sub.2dmsaa
-    amdgcn_image_atomic_sub_3d,                // llvm.amdgcn.image.atomic.sub.3d
-    amdgcn_image_atomic_sub_cube,              // llvm.amdgcn.image.atomic.sub.cube
-    amdgcn_image_atomic_swap_1d,               // llvm.amdgcn.image.atomic.swap.1d
-    amdgcn_image_atomic_swap_1darray,          // llvm.amdgcn.image.atomic.swap.1darray
-    amdgcn_image_atomic_swap_2d,               // llvm.amdgcn.image.atomic.swap.2d
-    amdgcn_image_atomic_swap_2darray,          // llvm.amdgcn.image.atomic.swap.2darray
-    amdgcn_image_atomic_swap_2darraymsaa,      // llvm.amdgcn.image.atomic.swap.2darraymsaa
-    amdgcn_image_atomic_swap_2dmsaa,           // llvm.amdgcn.image.atomic.swap.2dmsaa
-    amdgcn_image_atomic_swap_3d,               // llvm.amdgcn.image.atomic.swap.3d
-    amdgcn_image_atomic_swap_cube,             // llvm.amdgcn.image.atomic.swap.cube
-    amdgcn_image_atomic_umax_1d,               // llvm.amdgcn.image.atomic.umax.1d
-    amdgcn_image_atomic_umax_1darray,          // llvm.amdgcn.image.atomic.umax.1darray
-    amdgcn_image_atomic_umax_2d,               // llvm.amdgcn.image.atomic.umax.2d
-    amdgcn_image_atomic_umax_2darray,          // llvm.amdgcn.image.atomic.umax.2darray
-    amdgcn_image_atomic_umax_2darraymsaa,      // llvm.amdgcn.image.atomic.umax.2darraymsaa
-    amdgcn_image_atomic_umax_2dmsaa,           // llvm.amdgcn.image.atomic.umax.2dmsaa
-    amdgcn_image_atomic_umax_3d,               // llvm.amdgcn.image.atomic.umax.3d
-    amdgcn_image_atomic_umax_cube,             // llvm.amdgcn.image.atomic.umax.cube
-    amdgcn_image_atomic_umin_1d,               // llvm.amdgcn.image.atomic.umin.1d
-    amdgcn_image_atomic_umin_1darray,          // llvm.amdgcn.image.atomic.umin.1darray
-    amdgcn_image_atomic_umin_2d,               // llvm.amdgcn.image.atomic.umin.2d
-    amdgcn_image_atomic_umin_2darray,          // llvm.amdgcn.image.atomic.umin.2darray
-    amdgcn_image_atomic_umin_2darraymsaa,      // llvm.amdgcn.image.atomic.umin.2darraymsaa
-    amdgcn_image_atomic_umin_2dmsaa,           // llvm.amdgcn.image.atomic.umin.2dmsaa
-    amdgcn_image_atomic_umin_3d,               // llvm.amdgcn.image.atomic.umin.3d
-    amdgcn_image_atomic_umin_cube,             // llvm.amdgcn.image.atomic.umin.cube
-    amdgcn_image_atomic_xor_1d,                // llvm.amdgcn.image.atomic.xor.1d
-    amdgcn_image_atomic_xor_1darray,           // llvm.amdgcn.image.atomic.xor.1darray
-    amdgcn_image_atomic_xor_2d,                // llvm.amdgcn.image.atomic.xor.2d
-    amdgcn_image_atomic_xor_2darray,           // llvm.amdgcn.image.atomic.xor.2darray
-    amdgcn_image_atomic_xor_2darraymsaa,       // llvm.amdgcn.image.atomic.xor.2darraymsaa
-    amdgcn_image_atomic_xor_2dmsaa,            // llvm.amdgcn.image.atomic.xor.2dmsaa
-    amdgcn_image_atomic_xor_3d,                // llvm.amdgcn.image.atomic.xor.3d
-    amdgcn_image_atomic_xor_cube,              // llvm.amdgcn.image.atomic.xor.cube
-    amdgcn_image_gather4_2d,                   // llvm.amdgcn.image.gather4.2d
-    amdgcn_image_gather4_2darray,              // llvm.amdgcn.image.gather4.2darray
-    amdgcn_image_gather4_b_2d,                 // llvm.amdgcn.image.gather4.b.2d
-    amdgcn_image_gather4_b_2darray,            // llvm.amdgcn.image.gather4.b.2darray
-    amdgcn_image_gather4_b_cl_2d,              // llvm.amdgcn.image.gather4.b.cl.2d
-    amdgcn_image_gather4_b_cl_2darray,         // llvm.amdgcn.image.gather4.b.cl.2darray
-    amdgcn_image_gather4_b_cl_cube,            // llvm.amdgcn.image.gather4.b.cl.cube
-    amdgcn_image_gather4_b_cl_o_2d,            // llvm.amdgcn.image.gather4.b.cl.o.2d
-    amdgcn_image_gather4_b_cl_o_2darray,       // llvm.amdgcn.image.gather4.b.cl.o.2darray
-    amdgcn_image_gather4_b_cl_o_cube,          // llvm.amdgcn.image.gather4.b.cl.o.cube
-    amdgcn_image_gather4_b_cube,               // llvm.amdgcn.image.gather4.b.cube
-    amdgcn_image_gather4_b_o_2d,               // llvm.amdgcn.image.gather4.b.o.2d
-    amdgcn_image_gather4_b_o_2darray,          // llvm.amdgcn.image.gather4.b.o.2darray
-    amdgcn_image_gather4_b_o_cube,             // llvm.amdgcn.image.gather4.b.o.cube
-    amdgcn_image_gather4_c_2d,                 // llvm.amdgcn.image.gather4.c.2d
-    amdgcn_image_gather4_c_2darray,            // llvm.amdgcn.image.gather4.c.2darray
-    amdgcn_image_gather4_c_b_2d,               // llvm.amdgcn.image.gather4.c.b.2d
-    amdgcn_image_gather4_c_b_2darray,          // llvm.amdgcn.image.gather4.c.b.2darray
-    amdgcn_image_gather4_c_b_cl_2d,            // llvm.amdgcn.image.gather4.c.b.cl.2d
-    amdgcn_image_gather4_c_b_cl_2darray,       // llvm.amdgcn.image.gather4.c.b.cl.2darray
-    amdgcn_image_gather4_c_b_cl_cube,          // llvm.amdgcn.image.gather4.c.b.cl.cube
-    amdgcn_image_gather4_c_b_cl_o_2d,          // llvm.amdgcn.image.gather4.c.b.cl.o.2d
-    amdgcn_image_gather4_c_b_cl_o_2darray,     // llvm.amdgcn.image.gather4.c.b.cl.o.2darray
-    amdgcn_image_gather4_c_b_cl_o_cube,        // llvm.amdgcn.image.gather4.c.b.cl.o.cube
-    amdgcn_image_gather4_c_b_cube,             // llvm.amdgcn.image.gather4.c.b.cube
-    amdgcn_image_gather4_c_b_o_2d,             // llvm.amdgcn.image.gather4.c.b.o.2d
-    amdgcn_image_gather4_c_b_o_2darray,        // llvm.amdgcn.image.gather4.c.b.o.2darray
-    amdgcn_image_gather4_c_b_o_cube,           // llvm.amdgcn.image.gather4.c.b.o.cube
-    amdgcn_image_gather4_c_cl_2d,              // llvm.amdgcn.image.gather4.c.cl.2d
-    amdgcn_image_gather4_c_cl_2darray,         // llvm.amdgcn.image.gather4.c.cl.2darray
-    amdgcn_image_gather4_c_cl_cube,            // llvm.amdgcn.image.gather4.c.cl.cube
-    amdgcn_image_gather4_c_cl_o_2d,            // llvm.amdgcn.image.gather4.c.cl.o.2d
-    amdgcn_image_gather4_c_cl_o_2darray,       // llvm.amdgcn.image.gather4.c.cl.o.2darray
-    amdgcn_image_gather4_c_cl_o_cube,          // llvm.amdgcn.image.gather4.c.cl.o.cube
-    amdgcn_image_gather4_c_cube,               // llvm.amdgcn.image.gather4.c.cube
-    amdgcn_image_gather4_c_l_2d,               // llvm.amdgcn.image.gather4.c.l.2d
-    amdgcn_image_gather4_c_l_2darray,          // llvm.amdgcn.image.gather4.c.l.2darray
-    amdgcn_image_gather4_c_l_cube,             // llvm.amdgcn.image.gather4.c.l.cube
-    amdgcn_image_gather4_c_l_o_2d,             // llvm.amdgcn.image.gather4.c.l.o.2d
-    amdgcn_image_gather4_c_l_o_2darray,        // llvm.amdgcn.image.gather4.c.l.o.2darray
-    amdgcn_image_gather4_c_l_o_cube,           // llvm.amdgcn.image.gather4.c.l.o.cube
-    amdgcn_image_gather4_c_lz_2d,              // llvm.amdgcn.image.gather4.c.lz.2d
-    amdgcn_image_gather4_c_lz_2darray,         // llvm.amdgcn.image.gather4.c.lz.2darray
-    amdgcn_image_gather4_c_lz_cube,            // llvm.amdgcn.image.gather4.c.lz.cube
-    amdgcn_image_gather4_c_lz_o_2d,            // llvm.amdgcn.image.gather4.c.lz.o.2d
-    amdgcn_image_gather4_c_lz_o_2darray,       // llvm.amdgcn.image.gather4.c.lz.o.2darray
-    amdgcn_image_gather4_c_lz_o_cube,          // llvm.amdgcn.image.gather4.c.lz.o.cube
-    amdgcn_image_gather4_c_o_2d,               // llvm.amdgcn.image.gather4.c.o.2d
-    amdgcn_image_gather4_c_o_2darray,          // llvm.amdgcn.image.gather4.c.o.2darray
-    amdgcn_image_gather4_c_o_cube,             // llvm.amdgcn.image.gather4.c.o.cube
-    amdgcn_image_gather4_cl_2d,                // llvm.amdgcn.image.gather4.cl.2d
-    amdgcn_image_gather4_cl_2darray,           // llvm.amdgcn.image.gather4.cl.2darray
-    amdgcn_image_gather4_cl_cube,              // llvm.amdgcn.image.gather4.cl.cube
-    amdgcn_image_gather4_cl_o_2d,              // llvm.amdgcn.image.gather4.cl.o.2d
-    amdgcn_image_gather4_cl_o_2darray,         // llvm.amdgcn.image.gather4.cl.o.2darray
-    amdgcn_image_gather4_cl_o_cube,            // llvm.amdgcn.image.gather4.cl.o.cube
-    amdgcn_image_gather4_cube,                 // llvm.amdgcn.image.gather4.cube
-    amdgcn_image_gather4_l_2d,                 // llvm.amdgcn.image.gather4.l.2d
-    amdgcn_image_gather4_l_2darray,            // llvm.amdgcn.image.gather4.l.2darray
-    amdgcn_image_gather4_l_cube,               // llvm.amdgcn.image.gather4.l.cube
-    amdgcn_image_gather4_l_o_2d,               // llvm.amdgcn.image.gather4.l.o.2d
-    amdgcn_image_gather4_l_o_2darray,          // llvm.amdgcn.image.gather4.l.o.2darray
-    amdgcn_image_gather4_l_o_cube,             // llvm.amdgcn.image.gather4.l.o.cube
-    amdgcn_image_gather4_lz_2d,                // llvm.amdgcn.image.gather4.lz.2d
-    amdgcn_image_gather4_lz_2darray,           // llvm.amdgcn.image.gather4.lz.2darray
-    amdgcn_image_gather4_lz_cube,              // llvm.amdgcn.image.gather4.lz.cube
-    amdgcn_image_gather4_lz_o_2d,              // llvm.amdgcn.image.gather4.lz.o.2d
-    amdgcn_image_gather4_lz_o_2darray,         // llvm.amdgcn.image.gather4.lz.o.2darray
-    amdgcn_image_gather4_lz_o_cube,            // llvm.amdgcn.image.gather4.lz.o.cube
-    amdgcn_image_gather4_o_2d,                 // llvm.amdgcn.image.gather4.o.2d
-    amdgcn_image_gather4_o_2darray,            // llvm.amdgcn.image.gather4.o.2darray
-    amdgcn_image_gather4_o_cube,               // llvm.amdgcn.image.gather4.o.cube
-    amdgcn_image_getlod_1d,                    // llvm.amdgcn.image.getlod.1d
-    amdgcn_image_getlod_1darray,               // llvm.amdgcn.image.getlod.1darray
-    amdgcn_image_getlod_2d,                    // llvm.amdgcn.image.getlod.2d
-    amdgcn_image_getlod_2darray,               // llvm.amdgcn.image.getlod.2darray
-    amdgcn_image_getlod_3d,                    // llvm.amdgcn.image.getlod.3d
-    amdgcn_image_getlod_cube,                  // llvm.amdgcn.image.getlod.cube
-    amdgcn_image_getresinfo_1d,                // llvm.amdgcn.image.getresinfo.1d
-    amdgcn_image_getresinfo_1darray,           // llvm.amdgcn.image.getresinfo.1darray
-    amdgcn_image_getresinfo_2d,                // llvm.amdgcn.image.getresinfo.2d
-    amdgcn_image_getresinfo_2darray,           // llvm.amdgcn.image.getresinfo.2darray
-    amdgcn_image_getresinfo_2darraymsaa,       // llvm.amdgcn.image.getresinfo.2darraymsaa
-    amdgcn_image_getresinfo_2dmsaa,            // llvm.amdgcn.image.getresinfo.2dmsaa
-    amdgcn_image_getresinfo_3d,                // llvm.amdgcn.image.getresinfo.3d
-    amdgcn_image_getresinfo_cube,              // llvm.amdgcn.image.getresinfo.cube
-    amdgcn_image_load_1d,                      // llvm.amdgcn.image.load.1d
-    amdgcn_image_load_1darray,                 // llvm.amdgcn.image.load.1darray
-    amdgcn_image_load_2d,                      // llvm.amdgcn.image.load.2d
-    amdgcn_image_load_2darray,                 // llvm.amdgcn.image.load.2darray
-    amdgcn_image_load_2darraymsaa,             // llvm.amdgcn.image.load.2darraymsaa
-    amdgcn_image_load_2dmsaa,                  // llvm.amdgcn.image.load.2dmsaa
-    amdgcn_image_load_3d,                      // llvm.amdgcn.image.load.3d
-    amdgcn_image_load_cube,                    // llvm.amdgcn.image.load.cube
-    amdgcn_image_load_mip_1d,                  // llvm.amdgcn.image.load.mip.1d
-    amdgcn_image_load_mip_1darray,             // llvm.amdgcn.image.load.mip.1darray
-    amdgcn_image_load_mip_2d,                  // llvm.amdgcn.image.load.mip.2d
-    amdgcn_image_load_mip_2darray,             // llvm.amdgcn.image.load.mip.2darray
-    amdgcn_image_load_mip_3d,                  // llvm.amdgcn.image.load.mip.3d
-    amdgcn_image_load_mip_cube,                // llvm.amdgcn.image.load.mip.cube
-    amdgcn_image_sample_1d,                    // llvm.amdgcn.image.sample.1d
-    amdgcn_image_sample_1darray,               // llvm.amdgcn.image.sample.1darray
-    amdgcn_image_sample_2d,                    // llvm.amdgcn.image.sample.2d
-    amdgcn_image_sample_2darray,               // llvm.amdgcn.image.sample.2darray
-    amdgcn_image_sample_3d,                    // llvm.amdgcn.image.sample.3d
-    amdgcn_image_sample_b_1d,                  // llvm.amdgcn.image.sample.b.1d
-    amdgcn_image_sample_b_1darray,             // llvm.amdgcn.image.sample.b.1darray
-    amdgcn_image_sample_b_2d,                  // llvm.amdgcn.image.sample.b.2d
-    amdgcn_image_sample_b_2darray,             // llvm.amdgcn.image.sample.b.2darray
-    amdgcn_image_sample_b_3d,                  // llvm.amdgcn.image.sample.b.3d
-    amdgcn_image_sample_b_cl_1d,               // llvm.amdgcn.image.sample.b.cl.1d
-    amdgcn_image_sample_b_cl_1darray,          // llvm.amdgcn.image.sample.b.cl.1darray
-    amdgcn_image_sample_b_cl_2d,               // llvm.amdgcn.image.sample.b.cl.2d
-    amdgcn_image_sample_b_cl_2darray,          // llvm.amdgcn.image.sample.b.cl.2darray
-    amdgcn_image_sample_b_cl_3d,               // llvm.amdgcn.image.sample.b.cl.3d
-    amdgcn_image_sample_b_cl_cube,             // llvm.amdgcn.image.sample.b.cl.cube
-    amdgcn_image_sample_b_cl_o_1d,             // llvm.amdgcn.image.sample.b.cl.o.1d
-    amdgcn_image_sample_b_cl_o_1darray,        // llvm.amdgcn.image.sample.b.cl.o.1darray
-    amdgcn_image_sample_b_cl_o_2d,             // llvm.amdgcn.image.sample.b.cl.o.2d
-    amdgcn_image_sample_b_cl_o_2darray,        // llvm.amdgcn.image.sample.b.cl.o.2darray
-    amdgcn_image_sample_b_cl_o_3d,             // llvm.amdgcn.image.sample.b.cl.o.3d
-    amdgcn_image_sample_b_cl_o_cube,           // llvm.amdgcn.image.sample.b.cl.o.cube
-    amdgcn_image_sample_b_cube,                // llvm.amdgcn.image.sample.b.cube
-    amdgcn_image_sample_b_o_1d,                // llvm.amdgcn.image.sample.b.o.1d
-    amdgcn_image_sample_b_o_1darray,           // llvm.amdgcn.image.sample.b.o.1darray
-    amdgcn_image_sample_b_o_2d,                // llvm.amdgcn.image.sample.b.o.2d
-    amdgcn_image_sample_b_o_2darray,           // llvm.amdgcn.image.sample.b.o.2darray
-    amdgcn_image_sample_b_o_3d,                // llvm.amdgcn.image.sample.b.o.3d
-    amdgcn_image_sample_b_o_cube,              // llvm.amdgcn.image.sample.b.o.cube
-    amdgcn_image_sample_c_1d,                  // llvm.amdgcn.image.sample.c.1d
-    amdgcn_image_sample_c_1darray,             // llvm.amdgcn.image.sample.c.1darray
-    amdgcn_image_sample_c_2d,                  // llvm.amdgcn.image.sample.c.2d
-    amdgcn_image_sample_c_2darray,             // llvm.amdgcn.image.sample.c.2darray
-    amdgcn_image_sample_c_3d,                  // llvm.amdgcn.image.sample.c.3d
-    amdgcn_image_sample_c_b_1d,                // llvm.amdgcn.image.sample.c.b.1d
-    amdgcn_image_sample_c_b_1darray,           // llvm.amdgcn.image.sample.c.b.1darray
-    amdgcn_image_sample_c_b_2d,                // llvm.amdgcn.image.sample.c.b.2d
-    amdgcn_image_sample_c_b_2darray,           // llvm.amdgcn.image.sample.c.b.2darray
-    amdgcn_image_sample_c_b_3d,                // llvm.amdgcn.image.sample.c.b.3d
-    amdgcn_image_sample_c_b_cl_1d,             // llvm.amdgcn.image.sample.c.b.cl.1d
-    amdgcn_image_sample_c_b_cl_1darray,        // llvm.amdgcn.image.sample.c.b.cl.1darray
-    amdgcn_image_sample_c_b_cl_2d,             // llvm.amdgcn.image.sample.c.b.cl.2d
-    amdgcn_image_sample_c_b_cl_2darray,        // llvm.amdgcn.image.sample.c.b.cl.2darray
-    amdgcn_image_sample_c_b_cl_3d,             // llvm.amdgcn.image.sample.c.b.cl.3d
-    amdgcn_image_sample_c_b_cl_cube,           // llvm.amdgcn.image.sample.c.b.cl.cube
-    amdgcn_image_sample_c_b_cl_o_1d,           // llvm.amdgcn.image.sample.c.b.cl.o.1d
-    amdgcn_image_sample_c_b_cl_o_1darray,      // llvm.amdgcn.image.sample.c.b.cl.o.1darray
-    amdgcn_image_sample_c_b_cl_o_2d,           // llvm.amdgcn.image.sample.c.b.cl.o.2d
-    amdgcn_image_sample_c_b_cl_o_2darray,      // llvm.amdgcn.image.sample.c.b.cl.o.2darray
-    amdgcn_image_sample_c_b_cl_o_3d,           // llvm.amdgcn.image.sample.c.b.cl.o.3d
-    amdgcn_image_sample_c_b_cl_o_cube,         // llvm.amdgcn.image.sample.c.b.cl.o.cube
-    amdgcn_image_sample_c_b_cube,              // llvm.amdgcn.image.sample.c.b.cube
-    amdgcn_image_sample_c_b_o_1d,              // llvm.amdgcn.image.sample.c.b.o.1d
-    amdgcn_image_sample_c_b_o_1darray,         // llvm.amdgcn.image.sample.c.b.o.1darray
-    amdgcn_image_sample_c_b_o_2d,              // llvm.amdgcn.image.sample.c.b.o.2d
-    amdgcn_image_sample_c_b_o_2darray,         // llvm.amdgcn.image.sample.c.b.o.2darray
-    amdgcn_image_sample_c_b_o_3d,              // llvm.amdgcn.image.sample.c.b.o.3d
-    amdgcn_image_sample_c_b_o_cube,            // llvm.amdgcn.image.sample.c.b.o.cube
-    amdgcn_image_sample_c_cd_1d,               // llvm.amdgcn.image.sample.c.cd.1d
-    amdgcn_image_sample_c_cd_1darray,          // llvm.amdgcn.image.sample.c.cd.1darray
-    amdgcn_image_sample_c_cd_2d,               // llvm.amdgcn.image.sample.c.cd.2d
-    amdgcn_image_sample_c_cd_2darray,          // llvm.amdgcn.image.sample.c.cd.2darray
-    amdgcn_image_sample_c_cd_3d,               // llvm.amdgcn.image.sample.c.cd.3d
-    amdgcn_image_sample_c_cd_cl_1d,            // llvm.amdgcn.image.sample.c.cd.cl.1d
-    amdgcn_image_sample_c_cd_cl_1darray,       // llvm.amdgcn.image.sample.c.cd.cl.1darray
-    amdgcn_image_sample_c_cd_cl_2d,            // llvm.amdgcn.image.sample.c.cd.cl.2d
-    amdgcn_image_sample_c_cd_cl_2darray,       // llvm.amdgcn.image.sample.c.cd.cl.2darray
-    amdgcn_image_sample_c_cd_cl_3d,            // llvm.amdgcn.image.sample.c.cd.cl.3d
-    amdgcn_image_sample_c_cd_cl_cube,          // llvm.amdgcn.image.sample.c.cd.cl.cube
-    amdgcn_image_sample_c_cd_cl_o_1d,          // llvm.amdgcn.image.sample.c.cd.cl.o.1d
-    amdgcn_image_sample_c_cd_cl_o_1darray,     // llvm.amdgcn.image.sample.c.cd.cl.o.1darray
-    amdgcn_image_sample_c_cd_cl_o_2d,          // llvm.amdgcn.image.sample.c.cd.cl.o.2d
-    amdgcn_image_sample_c_cd_cl_o_2darray,     // llvm.amdgcn.image.sample.c.cd.cl.o.2darray
-    amdgcn_image_sample_c_cd_cl_o_3d,          // llvm.amdgcn.image.sample.c.cd.cl.o.3d
-    amdgcn_image_sample_c_cd_cl_o_cube,        // llvm.amdgcn.image.sample.c.cd.cl.o.cube
-    amdgcn_image_sample_c_cd_cube,             // llvm.amdgcn.image.sample.c.cd.cube
-    amdgcn_image_sample_c_cd_o_1d,             // llvm.amdgcn.image.sample.c.cd.o.1d
-    amdgcn_image_sample_c_cd_o_1darray,        // llvm.amdgcn.image.sample.c.cd.o.1darray
-    amdgcn_image_sample_c_cd_o_2d,             // llvm.amdgcn.image.sample.c.cd.o.2d
-    amdgcn_image_sample_c_cd_o_2darray,        // llvm.amdgcn.image.sample.c.cd.o.2darray
-    amdgcn_image_sample_c_cd_o_3d,             // llvm.amdgcn.image.sample.c.cd.o.3d
-    amdgcn_image_sample_c_cd_o_cube,           // llvm.amdgcn.image.sample.c.cd.o.cube
-    amdgcn_image_sample_c_cl_1d,               // llvm.amdgcn.image.sample.c.cl.1d
-    amdgcn_image_sample_c_cl_1darray,          // llvm.amdgcn.image.sample.c.cl.1darray
-    amdgcn_image_sample_c_cl_2d,               // llvm.amdgcn.image.sample.c.cl.2d
-    amdgcn_image_sample_c_cl_2darray,          // llvm.amdgcn.image.sample.c.cl.2darray
-    amdgcn_image_sample_c_cl_3d,               // llvm.amdgcn.image.sample.c.cl.3d
-    amdgcn_image_sample_c_cl_cube,             // llvm.amdgcn.image.sample.c.cl.cube
-    amdgcn_image_sample_c_cl_o_1d,             // llvm.amdgcn.image.sample.c.cl.o.1d
-    amdgcn_image_sample_c_cl_o_1darray,        // llvm.amdgcn.image.sample.c.cl.o.1darray
-    amdgcn_image_sample_c_cl_o_2d,             // llvm.amdgcn.image.sample.c.cl.o.2d
-    amdgcn_image_sample_c_cl_o_2darray,        // llvm.amdgcn.image.sample.c.cl.o.2darray
-    amdgcn_image_sample_c_cl_o_3d,             // llvm.amdgcn.image.sample.c.cl.o.3d
-    amdgcn_image_sample_c_cl_o_cube,           // llvm.amdgcn.image.sample.c.cl.o.cube
-    amdgcn_image_sample_c_cube,                // llvm.amdgcn.image.sample.c.cube
-    amdgcn_image_sample_c_d_1d,                // llvm.amdgcn.image.sample.c.d.1d
-    amdgcn_image_sample_c_d_1darray,           // llvm.amdgcn.image.sample.c.d.1darray
-    amdgcn_image_sample_c_d_2d,                // llvm.amdgcn.image.sample.c.d.2d
-    amdgcn_image_sample_c_d_2darray,           // llvm.amdgcn.image.sample.c.d.2darray
-    amdgcn_image_sample_c_d_3d,                // llvm.amdgcn.image.sample.c.d.3d
-    amdgcn_image_sample_c_d_cl_1d,             // llvm.amdgcn.image.sample.c.d.cl.1d
-    amdgcn_image_sample_c_d_cl_1darray,        // llvm.amdgcn.image.sample.c.d.cl.1darray
-    amdgcn_image_sample_c_d_cl_2d,             // llvm.amdgcn.image.sample.c.d.cl.2d
-    amdgcn_image_sample_c_d_cl_2darray,        // llvm.amdgcn.image.sample.c.d.cl.2darray
-    amdgcn_image_sample_c_d_cl_3d,             // llvm.amdgcn.image.sample.c.d.cl.3d
-    amdgcn_image_sample_c_d_cl_cube,           // llvm.amdgcn.image.sample.c.d.cl.cube
-    amdgcn_image_sample_c_d_cl_o_1d,           // llvm.amdgcn.image.sample.c.d.cl.o.1d
-    amdgcn_image_sample_c_d_cl_o_1darray,      // llvm.amdgcn.image.sample.c.d.cl.o.1darray
-    amdgcn_image_sample_c_d_cl_o_2d,           // llvm.amdgcn.image.sample.c.d.cl.o.2d
-    amdgcn_image_sample_c_d_cl_o_2darray,      // llvm.amdgcn.image.sample.c.d.cl.o.2darray
-    amdgcn_image_sample_c_d_cl_o_3d,           // llvm.amdgcn.image.sample.c.d.cl.o.3d
-    amdgcn_image_sample_c_d_cl_o_cube,         // llvm.amdgcn.image.sample.c.d.cl.o.cube
-    amdgcn_image_sample_c_d_cube,              // llvm.amdgcn.image.sample.c.d.cube
-    amdgcn_image_sample_c_d_o_1d,              // llvm.amdgcn.image.sample.c.d.o.1d
-    amdgcn_image_sample_c_d_o_1darray,         // llvm.amdgcn.image.sample.c.d.o.1darray
-    amdgcn_image_sample_c_d_o_2d,              // llvm.amdgcn.image.sample.c.d.o.2d
-    amdgcn_image_sample_c_d_o_2darray,         // llvm.amdgcn.image.sample.c.d.o.2darray
-    amdgcn_image_sample_c_d_o_3d,              // llvm.amdgcn.image.sample.c.d.o.3d
-    amdgcn_image_sample_c_d_o_cube,            // llvm.amdgcn.image.sample.c.d.o.cube
-    amdgcn_image_sample_c_l_1d,                // llvm.amdgcn.image.sample.c.l.1d
-    amdgcn_image_sample_c_l_1darray,           // llvm.amdgcn.image.sample.c.l.1darray
-    amdgcn_image_sample_c_l_2d,                // llvm.amdgcn.image.sample.c.l.2d
-    amdgcn_image_sample_c_l_2darray,           // llvm.amdgcn.image.sample.c.l.2darray
-    amdgcn_image_sample_c_l_3d,                // llvm.amdgcn.image.sample.c.l.3d
-    amdgcn_image_sample_c_l_cube,              // llvm.amdgcn.image.sample.c.l.cube
-    amdgcn_image_sample_c_l_o_1d,              // llvm.amdgcn.image.sample.c.l.o.1d
-    amdgcn_image_sample_c_l_o_1darray,         // llvm.amdgcn.image.sample.c.l.o.1darray
-    amdgcn_image_sample_c_l_o_2d,              // llvm.amdgcn.image.sample.c.l.o.2d
-    amdgcn_image_sample_c_l_o_2darray,         // llvm.amdgcn.image.sample.c.l.o.2darray
-    amdgcn_image_sample_c_l_o_3d,              // llvm.amdgcn.image.sample.c.l.o.3d
-    amdgcn_image_sample_c_l_o_cube,            // llvm.amdgcn.image.sample.c.l.o.cube
-    amdgcn_image_sample_c_lz_1d,               // llvm.amdgcn.image.sample.c.lz.1d
-    amdgcn_image_sample_c_lz_1darray,          // llvm.amdgcn.image.sample.c.lz.1darray
-    amdgcn_image_sample_c_lz_2d,               // llvm.amdgcn.image.sample.c.lz.2d
-    amdgcn_image_sample_c_lz_2darray,          // llvm.amdgcn.image.sample.c.lz.2darray
-    amdgcn_image_sample_c_lz_3d,               // llvm.amdgcn.image.sample.c.lz.3d
-    amdgcn_image_sample_c_lz_cube,             // llvm.amdgcn.image.sample.c.lz.cube
-    amdgcn_image_sample_c_lz_o_1d,             // llvm.amdgcn.image.sample.c.lz.o.1d
-    amdgcn_image_sample_c_lz_o_1darray,        // llvm.amdgcn.image.sample.c.lz.o.1darray
-    amdgcn_image_sample_c_lz_o_2d,             // llvm.amdgcn.image.sample.c.lz.o.2d
-    amdgcn_image_sample_c_lz_o_2darray,        // llvm.amdgcn.image.sample.c.lz.o.2darray
-    amdgcn_image_sample_c_lz_o_3d,             // llvm.amdgcn.image.sample.c.lz.o.3d
-    amdgcn_image_sample_c_lz_o_cube,           // llvm.amdgcn.image.sample.c.lz.o.cube
-    amdgcn_image_sample_c_o_1d,                // llvm.amdgcn.image.sample.c.o.1d
-    amdgcn_image_sample_c_o_1darray,           // llvm.amdgcn.image.sample.c.o.1darray
-    amdgcn_image_sample_c_o_2d,                // llvm.amdgcn.image.sample.c.o.2d
-    amdgcn_image_sample_c_o_2darray,           // llvm.amdgcn.image.sample.c.o.2darray
-    amdgcn_image_sample_c_o_3d,                // llvm.amdgcn.image.sample.c.o.3d
-    amdgcn_image_sample_c_o_cube,              // llvm.amdgcn.image.sample.c.o.cube
-    amdgcn_image_sample_cd_1d,                 // llvm.amdgcn.image.sample.cd.1d
-    amdgcn_image_sample_cd_1darray,            // llvm.amdgcn.image.sample.cd.1darray
-    amdgcn_image_sample_cd_2d,                 // llvm.amdgcn.image.sample.cd.2d
-    amdgcn_image_sample_cd_2darray,            // llvm.amdgcn.image.sample.cd.2darray
-    amdgcn_image_sample_cd_3d,                 // llvm.amdgcn.image.sample.cd.3d
-    amdgcn_image_sample_cd_cl_1d,              // llvm.amdgcn.image.sample.cd.cl.1d
-    amdgcn_image_sample_cd_cl_1darray,         // llvm.amdgcn.image.sample.cd.cl.1darray
-    amdgcn_image_sample_cd_cl_2d,              // llvm.amdgcn.image.sample.cd.cl.2d
-    amdgcn_image_sample_cd_cl_2darray,         // llvm.amdgcn.image.sample.cd.cl.2darray
-    amdgcn_image_sample_cd_cl_3d,              // llvm.amdgcn.image.sample.cd.cl.3d
-    amdgcn_image_sample_cd_cl_cube,            // llvm.amdgcn.image.sample.cd.cl.cube
-    amdgcn_image_sample_cd_cl_o_1d,            // llvm.amdgcn.image.sample.cd.cl.o.1d
-    amdgcn_image_sample_cd_cl_o_1darray,       // llvm.amdgcn.image.sample.cd.cl.o.1darray
-    amdgcn_image_sample_cd_cl_o_2d,            // llvm.amdgcn.image.sample.cd.cl.o.2d
-    amdgcn_image_sample_cd_cl_o_2darray,       // llvm.amdgcn.image.sample.cd.cl.o.2darray
-    amdgcn_image_sample_cd_cl_o_3d,            // llvm.amdgcn.image.sample.cd.cl.o.3d
-    amdgcn_image_sample_cd_cl_o_cube,          // llvm.amdgcn.image.sample.cd.cl.o.cube
-    amdgcn_image_sample_cd_cube,               // llvm.amdgcn.image.sample.cd.cube
-    amdgcn_image_sample_cd_o_1d,               // llvm.amdgcn.image.sample.cd.o.1d
-    amdgcn_image_sample_cd_o_1darray,          // llvm.amdgcn.image.sample.cd.o.1darray
-    amdgcn_image_sample_cd_o_2d,               // llvm.amdgcn.image.sample.cd.o.2d
-    amdgcn_image_sample_cd_o_2darray,          // llvm.amdgcn.image.sample.cd.o.2darray
-    amdgcn_image_sample_cd_o_3d,               // llvm.amdgcn.image.sample.cd.o.3d
-    amdgcn_image_sample_cd_o_cube,             // llvm.amdgcn.image.sample.cd.o.cube
-    amdgcn_image_sample_cl_1d,                 // llvm.amdgcn.image.sample.cl.1d
-    amdgcn_image_sample_cl_1darray,            // llvm.amdgcn.image.sample.cl.1darray
-    amdgcn_image_sample_cl_2d,                 // llvm.amdgcn.image.sample.cl.2d
-    amdgcn_image_sample_cl_2darray,            // llvm.amdgcn.image.sample.cl.2darray
-    amdgcn_image_sample_cl_3d,                 // llvm.amdgcn.image.sample.cl.3d
-    amdgcn_image_sample_cl_cube,               // llvm.amdgcn.image.sample.cl.cube
-    amdgcn_image_sample_cl_o_1d,               // llvm.amdgcn.image.sample.cl.o.1d
-    amdgcn_image_sample_cl_o_1darray,          // llvm.amdgcn.image.sample.cl.o.1darray
-    amdgcn_image_sample_cl_o_2d,               // llvm.amdgcn.image.sample.cl.o.2d
-    amdgcn_image_sample_cl_o_2darray,          // llvm.amdgcn.image.sample.cl.o.2darray
-    amdgcn_image_sample_cl_o_3d,               // llvm.amdgcn.image.sample.cl.o.3d
-    amdgcn_image_sample_cl_o_cube,             // llvm.amdgcn.image.sample.cl.o.cube
-    amdgcn_image_sample_cube,                  // llvm.amdgcn.image.sample.cube
-    amdgcn_image_sample_d_1d,                  // llvm.amdgcn.image.sample.d.1d
-    amdgcn_image_sample_d_1darray,             // llvm.amdgcn.image.sample.d.1darray
-    amdgcn_image_sample_d_2d,                  // llvm.amdgcn.image.sample.d.2d
-    amdgcn_image_sample_d_2darray,             // llvm.amdgcn.image.sample.d.2darray
-    amdgcn_image_sample_d_3d,                  // llvm.amdgcn.image.sample.d.3d
-    amdgcn_image_sample_d_cl_1d,               // llvm.amdgcn.image.sample.d.cl.1d
-    amdgcn_image_sample_d_cl_1darray,          // llvm.amdgcn.image.sample.d.cl.1darray
-    amdgcn_image_sample_d_cl_2d,               // llvm.amdgcn.image.sample.d.cl.2d
-    amdgcn_image_sample_d_cl_2darray,          // llvm.amdgcn.image.sample.d.cl.2darray
-    amdgcn_image_sample_d_cl_3d,               // llvm.amdgcn.image.sample.d.cl.3d
-    amdgcn_image_sample_d_cl_cube,             // llvm.amdgcn.image.sample.d.cl.cube
-    amdgcn_image_sample_d_cl_o_1d,             // llvm.amdgcn.image.sample.d.cl.o.1d
-    amdgcn_image_sample_d_cl_o_1darray,        // llvm.amdgcn.image.sample.d.cl.o.1darray
-    amdgcn_image_sample_d_cl_o_2d,             // llvm.amdgcn.image.sample.d.cl.o.2d
-    amdgcn_image_sample_d_cl_o_2darray,        // llvm.amdgcn.image.sample.d.cl.o.2darray
-    amdgcn_image_sample_d_cl_o_3d,             // llvm.amdgcn.image.sample.d.cl.o.3d
-    amdgcn_image_sample_d_cl_o_cube,           // llvm.amdgcn.image.sample.d.cl.o.cube
-    amdgcn_image_sample_d_cube,                // llvm.amdgcn.image.sample.d.cube
-    amdgcn_image_sample_d_o_1d,                // llvm.amdgcn.image.sample.d.o.1d
-    amdgcn_image_sample_d_o_1darray,           // llvm.amdgcn.image.sample.d.o.1darray
-    amdgcn_image_sample_d_o_2d,                // llvm.amdgcn.image.sample.d.o.2d
-    amdgcn_image_sample_d_o_2darray,           // llvm.amdgcn.image.sample.d.o.2darray
-    amdgcn_image_sample_d_o_3d,                // llvm.amdgcn.image.sample.d.o.3d
-    amdgcn_image_sample_d_o_cube,              // llvm.amdgcn.image.sample.d.o.cube
-    amdgcn_image_sample_l_1d,                  // llvm.amdgcn.image.sample.l.1d
-    amdgcn_image_sample_l_1darray,             // llvm.amdgcn.image.sample.l.1darray
-    amdgcn_image_sample_l_2d,                  // llvm.amdgcn.image.sample.l.2d
-    amdgcn_image_sample_l_2darray,             // llvm.amdgcn.image.sample.l.2darray
-    amdgcn_image_sample_l_3d,                  // llvm.amdgcn.image.sample.l.3d
-    amdgcn_image_sample_l_cube,                // llvm.amdgcn.image.sample.l.cube
-    amdgcn_image_sample_l_o_1d,                // llvm.amdgcn.image.sample.l.o.1d
-    amdgcn_image_sample_l_o_1darray,           // llvm.amdgcn.image.sample.l.o.1darray
-    amdgcn_image_sample_l_o_2d,                // llvm.amdgcn.image.sample.l.o.2d
-    amdgcn_image_sample_l_o_2darray,           // llvm.amdgcn.image.sample.l.o.2darray
-    amdgcn_image_sample_l_o_3d,                // llvm.amdgcn.image.sample.l.o.3d
-    amdgcn_image_sample_l_o_cube,              // llvm.amdgcn.image.sample.l.o.cube
-    amdgcn_image_sample_lz_1d,                 // llvm.amdgcn.image.sample.lz.1d
-    amdgcn_image_sample_lz_1darray,            // llvm.amdgcn.image.sample.lz.1darray
-    amdgcn_image_sample_lz_2d,                 // llvm.amdgcn.image.sample.lz.2d
-    amdgcn_image_sample_lz_2darray,            // llvm.amdgcn.image.sample.lz.2darray
-    amdgcn_image_sample_lz_3d,                 // llvm.amdgcn.image.sample.lz.3d
-    amdgcn_image_sample_lz_cube,               // llvm.amdgcn.image.sample.lz.cube
-    amdgcn_image_sample_lz_o_1d,               // llvm.amdgcn.image.sample.lz.o.1d
-    amdgcn_image_sample_lz_o_1darray,          // llvm.amdgcn.image.sample.lz.o.1darray
-    amdgcn_image_sample_lz_o_2d,               // llvm.amdgcn.image.sample.lz.o.2d
-    amdgcn_image_sample_lz_o_2darray,          // llvm.amdgcn.image.sample.lz.o.2darray
-    amdgcn_image_sample_lz_o_3d,               // llvm.amdgcn.image.sample.lz.o.3d
-    amdgcn_image_sample_lz_o_cube,             // llvm.amdgcn.image.sample.lz.o.cube
-    amdgcn_image_sample_o_1d,                  // llvm.amdgcn.image.sample.o.1d
-    amdgcn_image_sample_o_1darray,             // llvm.amdgcn.image.sample.o.1darray
-    amdgcn_image_sample_o_2d,                  // llvm.amdgcn.image.sample.o.2d
-    amdgcn_image_sample_o_2darray,             // llvm.amdgcn.image.sample.o.2darray
-    amdgcn_image_sample_o_3d,                  // llvm.amdgcn.image.sample.o.3d
-    amdgcn_image_sample_o_cube,                // llvm.amdgcn.image.sample.o.cube
-    amdgcn_image_store_1d,                     // llvm.amdgcn.image.store.1d
-    amdgcn_image_store_1darray,                // llvm.amdgcn.image.store.1darray
-    amdgcn_image_store_2d,                     // llvm.amdgcn.image.store.2d
-    amdgcn_image_store_2darray,                // llvm.amdgcn.image.store.2darray
-    amdgcn_image_store_2darraymsaa,            // llvm.amdgcn.image.store.2darraymsaa
-    amdgcn_image_store_2dmsaa,                 // llvm.amdgcn.image.store.2dmsaa
-    amdgcn_image_store_3d,                     // llvm.amdgcn.image.store.3d
-    amdgcn_image_store_cube,                   // llvm.amdgcn.image.store.cube
-    amdgcn_image_store_mip_1d,                 // llvm.amdgcn.image.store.mip.1d
-    amdgcn_image_store_mip_1darray,            // llvm.amdgcn.image.store.mip.1darray
-    amdgcn_image_store_mip_2d,                 // llvm.amdgcn.image.store.mip.2d
-    amdgcn_image_store_mip_2darray,            // llvm.amdgcn.image.store.mip.2darray
-    amdgcn_image_store_mip_3d,                 // llvm.amdgcn.image.store.mip.3d
-    amdgcn_image_store_mip_cube,               // llvm.amdgcn.image.store.mip.cube
-    amdgcn_implicit_buffer_ptr,                // llvm.amdgcn.implicit.buffer.ptr
-    amdgcn_implicitarg_ptr,                    // llvm.amdgcn.implicitarg.ptr
-    amdgcn_init_exec,                          // llvm.amdgcn.init.exec
-    amdgcn_init_exec_from_input,               // llvm.amdgcn.init.exec.from.input
-    amdgcn_interp_mov,                         // llvm.amdgcn.interp.mov
-    amdgcn_interp_p1,                          // llvm.amdgcn.interp.p1
-    amdgcn_interp_p1_f16,                      // llvm.amdgcn.interp.p1.f16
-    amdgcn_interp_p2,                          // llvm.amdgcn.interp.p2
-    amdgcn_interp_p2_f16,                      // llvm.amdgcn.interp.p2.f16
-    amdgcn_kernarg_segment_ptr,                // llvm.amdgcn.kernarg.segment.ptr
-    amdgcn_kill,                               // llvm.amdgcn.kill
-    amdgcn_ldexp,                              // llvm.amdgcn.ldexp
-    amdgcn_lerp,                               // llvm.amdgcn.lerp
-    amdgcn_log_clamp,                          // llvm.amdgcn.log.clamp
-    amdgcn_loop,                               // llvm.amdgcn.loop
-    amdgcn_mbcnt_hi,                           // llvm.amdgcn.mbcnt.hi
-    amdgcn_mbcnt_lo,                           // llvm.amdgcn.mbcnt.lo
-    amdgcn_mfma_f32_16x16x16f16,               // llvm.amdgcn.mfma.f32.16x16x16f16
-    amdgcn_mfma_f32_16x16x1f32,                // llvm.amdgcn.mfma.f32.16x16x1f32
-    amdgcn_mfma_f32_16x16x2bf16,               // llvm.amdgcn.mfma.f32.16x16x2bf16
-    amdgcn_mfma_f32_16x16x4f16,                // llvm.amdgcn.mfma.f32.16x16x4f16
-    amdgcn_mfma_f32_16x16x4f32,                // llvm.amdgcn.mfma.f32.16x16x4f32
-    amdgcn_mfma_f32_16x16x8bf16,               // llvm.amdgcn.mfma.f32.16x16x8bf16
-    amdgcn_mfma_f32_32x32x1f32,                // llvm.amdgcn.mfma.f32.32x32x1f32
-    amdgcn_mfma_f32_32x32x2bf16,               // llvm.amdgcn.mfma.f32.32x32x2bf16
-    amdgcn_mfma_f32_32x32x2f32,                // llvm.amdgcn.mfma.f32.32x32x2f32
-    amdgcn_mfma_f32_32x32x4bf16,               // llvm.amdgcn.mfma.f32.32x32x4bf16
-    amdgcn_mfma_f32_32x32x4f16,                // llvm.amdgcn.mfma.f32.32x32x4f16
-    amdgcn_mfma_f32_32x32x8f16,                // llvm.amdgcn.mfma.f32.32x32x8f16
-    amdgcn_mfma_f32_4x4x1f32,                  // llvm.amdgcn.mfma.f32.4x4x1f32
-    amdgcn_mfma_f32_4x4x2bf16,                 // llvm.amdgcn.mfma.f32.4x4x2bf16
-    amdgcn_mfma_f32_4x4x4f16,                  // llvm.amdgcn.mfma.f32.4x4x4f16
-    amdgcn_mfma_i32_16x16x16i8,                // llvm.amdgcn.mfma.i32.16x16x16i8
-    amdgcn_mfma_i32_16x16x4i8,                 // llvm.amdgcn.mfma.i32.16x16x4i8
-    amdgcn_mfma_i32_32x32x4i8,                 // llvm.amdgcn.mfma.i32.32x32x4i8
-    amdgcn_mfma_i32_32x32x8i8,                 // llvm.amdgcn.mfma.i32.32x32x8i8
-    amdgcn_mfma_i32_4x4x4i8,                   // llvm.amdgcn.mfma.i32.4x4x4i8
-    amdgcn_mov_dpp,                            // llvm.amdgcn.mov.dpp
-    amdgcn_mov_dpp8,                           // llvm.amdgcn.mov.dpp8
-    amdgcn_mqsad_pk_u16_u8,                    // llvm.amdgcn.mqsad.pk.u16.u8
-    amdgcn_mqsad_u32_u8,                       // llvm.amdgcn.mqsad.u32.u8
-    amdgcn_msad_u8,                            // llvm.amdgcn.msad.u8
-    amdgcn_permlane16,                         // llvm.amdgcn.permlane16
-    amdgcn_permlanex16,                        // llvm.amdgcn.permlanex16
-    amdgcn_ps_live,                            // llvm.amdgcn.ps.live
-    amdgcn_qsad_pk_u16_u8,                     // llvm.amdgcn.qsad.pk.u16.u8
-    amdgcn_queue_ptr,                          // llvm.amdgcn.queue.ptr
-    amdgcn_raw_buffer_atomic_add,              // llvm.amdgcn.raw.buffer.atomic.add
-    amdgcn_raw_buffer_atomic_and,              // llvm.amdgcn.raw.buffer.atomic.and
-    amdgcn_raw_buffer_atomic_cmpswap,          // llvm.amdgcn.raw.buffer.atomic.cmpswap
-    amdgcn_raw_buffer_atomic_or,               // llvm.amdgcn.raw.buffer.atomic.or
-    amdgcn_raw_buffer_atomic_smax,             // llvm.amdgcn.raw.buffer.atomic.smax
-    amdgcn_raw_buffer_atomic_smin,             // llvm.amdgcn.raw.buffer.atomic.smin
-    amdgcn_raw_buffer_atomic_sub,              // llvm.amdgcn.raw.buffer.atomic.sub
-    amdgcn_raw_buffer_atomic_swap,             // llvm.amdgcn.raw.buffer.atomic.swap
-    amdgcn_raw_buffer_atomic_umax,             // llvm.amdgcn.raw.buffer.atomic.umax
-    amdgcn_raw_buffer_atomic_umin,             // llvm.amdgcn.raw.buffer.atomic.umin
-    amdgcn_raw_buffer_atomic_xor,              // llvm.amdgcn.raw.buffer.atomic.xor
-    amdgcn_raw_buffer_load,                    // llvm.amdgcn.raw.buffer.load
-    amdgcn_raw_buffer_load_format,             // llvm.amdgcn.raw.buffer.load.format
-    amdgcn_raw_buffer_store,                   // llvm.amdgcn.raw.buffer.store
-    amdgcn_raw_buffer_store_format,            // llvm.amdgcn.raw.buffer.store.format
-    amdgcn_raw_tbuffer_load,                   // llvm.amdgcn.raw.tbuffer.load
-    amdgcn_raw_tbuffer_store,                  // llvm.amdgcn.raw.tbuffer.store
-    amdgcn_rcp,                                // llvm.amdgcn.rcp
-    amdgcn_rcp_legacy,                         // llvm.amdgcn.rcp.legacy
-    amdgcn_readfirstlane,                      // llvm.amdgcn.readfirstlane
-    amdgcn_readlane,                           // llvm.amdgcn.readlane
-    amdgcn_rsq,                                // llvm.amdgcn.rsq
-    amdgcn_rsq_clamp,                          // llvm.amdgcn.rsq.clamp
-    amdgcn_rsq_legacy,                         // llvm.amdgcn.rsq.legacy
-    amdgcn_s_barrier,                          // llvm.amdgcn.s.barrier
-    amdgcn_s_buffer_load,                      // llvm.amdgcn.s.buffer.load
-    amdgcn_s_dcache_inv,                       // llvm.amdgcn.s.dcache.inv
-    amdgcn_s_dcache_inv_vol,                   // llvm.amdgcn.s.dcache.inv.vol
-    amdgcn_s_dcache_wb,                        // llvm.amdgcn.s.dcache.wb
-    amdgcn_s_dcache_wb_vol,                    // llvm.amdgcn.s.dcache.wb.vol
-    amdgcn_s_decperflevel,                     // llvm.amdgcn.s.decperflevel
-    amdgcn_s_get_waveid_in_workgroup,          // llvm.amdgcn.s.get.waveid.in.workgroup
-    amdgcn_s_getpc,                            // llvm.amdgcn.s.getpc
-    amdgcn_s_getreg,                           // llvm.amdgcn.s.getreg
-    amdgcn_s_incperflevel,                     // llvm.amdgcn.s.incperflevel
-    amdgcn_s_memrealtime,                      // llvm.amdgcn.s.memrealtime
-    amdgcn_s_memtime,                          // llvm.amdgcn.s.memtime
-    amdgcn_s_sendmsg,                          // llvm.amdgcn.s.sendmsg
-    amdgcn_s_sendmsghalt,                      // llvm.amdgcn.s.sendmsghalt
-    amdgcn_s_sleep,                            // llvm.amdgcn.s.sleep
-    amdgcn_s_waitcnt,                          // llvm.amdgcn.s.waitcnt
-    amdgcn_sad_hi_u8,                          // llvm.amdgcn.sad.hi.u8
-    amdgcn_sad_u16,                            // llvm.amdgcn.sad.u16
-    amdgcn_sad_u8,                             // llvm.amdgcn.sad.u8
-    amdgcn_sbfe,                               // llvm.amdgcn.sbfe
-    amdgcn_sdot2,                              // llvm.amdgcn.sdot2
-    amdgcn_sdot4,                              // llvm.amdgcn.sdot4
-    amdgcn_sdot8,                              // llvm.amdgcn.sdot8
-    amdgcn_set_inactive,                       // llvm.amdgcn.set.inactive
-    amdgcn_sffbh,                              // llvm.amdgcn.sffbh
-    amdgcn_sin,                                // llvm.amdgcn.sin
-    amdgcn_struct_buffer_atomic_add,           // llvm.amdgcn.struct.buffer.atomic.add
-    amdgcn_struct_buffer_atomic_and,           // llvm.amdgcn.struct.buffer.atomic.and
-    amdgcn_struct_buffer_atomic_cmpswap,       // llvm.amdgcn.struct.buffer.atomic.cmpswap
-    amdgcn_struct_buffer_atomic_or,            // llvm.amdgcn.struct.buffer.atomic.or
-    amdgcn_struct_buffer_atomic_smax,          // llvm.amdgcn.struct.buffer.atomic.smax
-    amdgcn_struct_buffer_atomic_smin,          // llvm.amdgcn.struct.buffer.atomic.smin
-    amdgcn_struct_buffer_atomic_sub,           // llvm.amdgcn.struct.buffer.atomic.sub
-    amdgcn_struct_buffer_atomic_swap,          // llvm.amdgcn.struct.buffer.atomic.swap
-    amdgcn_struct_buffer_atomic_umax,          // llvm.amdgcn.struct.buffer.atomic.umax
-    amdgcn_struct_buffer_atomic_umin,          // llvm.amdgcn.struct.buffer.atomic.umin
-    amdgcn_struct_buffer_atomic_xor,           // llvm.amdgcn.struct.buffer.atomic.xor
-    amdgcn_struct_buffer_load,                 // llvm.amdgcn.struct.buffer.load
-    amdgcn_struct_buffer_load_format,          // llvm.amdgcn.struct.buffer.load.format
-    amdgcn_struct_buffer_store,                // llvm.amdgcn.struct.buffer.store
-    amdgcn_struct_buffer_store_format,         // llvm.amdgcn.struct.buffer.store.format
-    amdgcn_struct_tbuffer_load,                // llvm.amdgcn.struct.tbuffer.load
-    amdgcn_struct_tbuffer_store,               // llvm.amdgcn.struct.tbuffer.store
-    amdgcn_tbuffer_load,                       // llvm.amdgcn.tbuffer.load
-    amdgcn_tbuffer_store,                      // llvm.amdgcn.tbuffer.store
-    amdgcn_trig_preop,                         // llvm.amdgcn.trig.preop
-    amdgcn_ubfe,                               // llvm.amdgcn.ubfe
-    amdgcn_udot2,                              // llvm.amdgcn.udot2
-    amdgcn_udot4,                              // llvm.amdgcn.udot4
-    amdgcn_udot8,                              // llvm.amdgcn.udot8
-    amdgcn_unreachable,                        // llvm.amdgcn.unreachable
-    amdgcn_update_dpp,                         // llvm.amdgcn.update.dpp
-    amdgcn_wave_barrier,                       // llvm.amdgcn.wave.barrier
-    amdgcn_wavefrontsize,                      // llvm.amdgcn.wavefrontsize
-    amdgcn_workgroup_id_x,                     // llvm.amdgcn.workgroup.id.x
-    amdgcn_workgroup_id_y,                     // llvm.amdgcn.workgroup.id.y
-    amdgcn_workgroup_id_z,                     // llvm.amdgcn.workgroup.id.z
-    amdgcn_workitem_id_x,                      // llvm.amdgcn.workitem.id.x
-    amdgcn_workitem_id_y,                      // llvm.amdgcn.workitem.id.y
-    amdgcn_workitem_id_z,                      // llvm.amdgcn.workitem.id.z
-    amdgcn_wqm,                                // llvm.amdgcn.wqm
-    amdgcn_wqm_vote,                           // llvm.amdgcn.wqm.vote
-    amdgcn_writelane,                          // llvm.amdgcn.writelane
-    amdgcn_wwm,                                // llvm.amdgcn.wwm
-    arm_cdp,                                   // llvm.arm.cdp
-    arm_cdp2,                                  // llvm.arm.cdp2
-    arm_clrex,                                 // llvm.arm.clrex
-    arm_cmse_tt,                               // llvm.arm.cmse.tt
-    arm_cmse_tta,                              // llvm.arm.cmse.tta
-    arm_cmse_ttat,                             // llvm.arm.cmse.ttat
-    arm_cmse_ttt,                              // llvm.arm.cmse.ttt
-    arm_crc32b,                                // llvm.arm.crc32b
-    arm_crc32cb,                               // llvm.arm.crc32cb
-    arm_crc32ch,                               // llvm.arm.crc32ch
-    arm_crc32cw,                               // llvm.arm.crc32cw
-    arm_crc32h,                                // llvm.arm.crc32h
-    arm_crc32w,                                // llvm.arm.crc32w
-    arm_dbg,                                   // llvm.arm.dbg
-    arm_dmb,                                   // llvm.arm.dmb
-    arm_dsb,                                   // llvm.arm.dsb
-    arm_get_fpscr,                             // llvm.arm.get.fpscr
-    arm_gnu_eabi_mcount,                       // llvm.arm.gnu.eabi.mcount
-    arm_hint,                                  // llvm.arm.hint
-    arm_isb,                                   // llvm.arm.isb
-    arm_ldaex,                                 // llvm.arm.ldaex
-    arm_ldaexd,                                // llvm.arm.ldaexd
-    arm_ldc,                                   // llvm.arm.ldc
-    arm_ldc2,                                  // llvm.arm.ldc2
-    arm_ldc2l,                                 // llvm.arm.ldc2l
-    arm_ldcl,                                  // llvm.arm.ldcl
-    arm_ldrex,                                 // llvm.arm.ldrex
-    arm_ldrexd,                                // llvm.arm.ldrexd
-    arm_mcr,                                   // llvm.arm.mcr
-    arm_mcr2,                                  // llvm.arm.mcr2
-    arm_mcrr,                                  // llvm.arm.mcrr
-    arm_mcrr2,                                 // llvm.arm.mcrr2
-    arm_mrc,                                   // llvm.arm.mrc
-    arm_mrc2,                                  // llvm.arm.mrc2
-    arm_mrrc,                                  // llvm.arm.mrrc
-    arm_mrrc2,                                 // llvm.arm.mrrc2
-    arm_neon_aesd,                             // llvm.arm.neon.aesd
-    arm_neon_aese,                             // llvm.arm.neon.aese
-    arm_neon_aesimc,                           // llvm.arm.neon.aesimc
-    arm_neon_aesmc,                            // llvm.arm.neon.aesmc
-    arm_neon_sdot,                             // llvm.arm.neon.sdot
-    arm_neon_sha1c,                            // llvm.arm.neon.sha1c
-    arm_neon_sha1h,                            // llvm.arm.neon.sha1h
-    arm_neon_sha1m,                            // llvm.arm.neon.sha1m
-    arm_neon_sha1p,                            // llvm.arm.neon.sha1p
-    arm_neon_sha1su0,                          // llvm.arm.neon.sha1su0
-    arm_neon_sha1su1,                          // llvm.arm.neon.sha1su1
-    arm_neon_sha256h,                          // llvm.arm.neon.sha256h
-    arm_neon_sha256h2,                         // llvm.arm.neon.sha256h2
-    arm_neon_sha256su0,                        // llvm.arm.neon.sha256su0
-    arm_neon_sha256su1,                        // llvm.arm.neon.sha256su1
-    arm_neon_udot,                             // llvm.arm.neon.udot
-    arm_neon_vabds,                            // llvm.arm.neon.vabds
-    arm_neon_vabdu,                            // llvm.arm.neon.vabdu
-    arm_neon_vabs,                             // llvm.arm.neon.vabs
-    arm_neon_vacge,                            // llvm.arm.neon.vacge
-    arm_neon_vacgt,                            // llvm.arm.neon.vacgt
-    arm_neon_vbsl,                             // llvm.arm.neon.vbsl
-    arm_neon_vcls,                             // llvm.arm.neon.vcls
-    arm_neon_vcvtas,                           // llvm.arm.neon.vcvtas
-    arm_neon_vcvtau,                           // llvm.arm.neon.vcvtau
-    arm_neon_vcvtfp2fxs,                       // llvm.arm.neon.vcvtfp2fxs
-    arm_neon_vcvtfp2fxu,                       // llvm.arm.neon.vcvtfp2fxu
-    arm_neon_vcvtfp2hf,                        // llvm.arm.neon.vcvtfp2hf
-    arm_neon_vcvtfxs2fp,                       // llvm.arm.neon.vcvtfxs2fp
-    arm_neon_vcvtfxu2fp,                       // llvm.arm.neon.vcvtfxu2fp
-    arm_neon_vcvthf2fp,                        // llvm.arm.neon.vcvthf2fp
-    arm_neon_vcvtms,                           // llvm.arm.neon.vcvtms
-    arm_neon_vcvtmu,                           // llvm.arm.neon.vcvtmu
-    arm_neon_vcvtns,                           // llvm.arm.neon.vcvtns
-    arm_neon_vcvtnu,                           // llvm.arm.neon.vcvtnu
-    arm_neon_vcvtps,                           // llvm.arm.neon.vcvtps
-    arm_neon_vcvtpu,                           // llvm.arm.neon.vcvtpu
-    arm_neon_vhadds,                           // llvm.arm.neon.vhadds
-    arm_neon_vhaddu,                           // llvm.arm.neon.vhaddu
-    arm_neon_vhsubs,                           // llvm.arm.neon.vhsubs
-    arm_neon_vhsubu,                           // llvm.arm.neon.vhsubu
-    arm_neon_vld1,                             // llvm.arm.neon.vld1
-    arm_neon_vld1x2,                           // llvm.arm.neon.vld1x2
-    arm_neon_vld1x3,                           // llvm.arm.neon.vld1x3
-    arm_neon_vld1x4,                           // llvm.arm.neon.vld1x4
-    arm_neon_vld2,                             // llvm.arm.neon.vld2
-    arm_neon_vld2dup,                          // llvm.arm.neon.vld2dup
-    arm_neon_vld2lane,                         // llvm.arm.neon.vld2lane
-    arm_neon_vld3,                             // llvm.arm.neon.vld3
-    arm_neon_vld3dup,                          // llvm.arm.neon.vld3dup
-    arm_neon_vld3lane,                         // llvm.arm.neon.vld3lane
-    arm_neon_vld4,                             // llvm.arm.neon.vld4
-    arm_neon_vld4dup,                          // llvm.arm.neon.vld4dup
-    arm_neon_vld4lane,                         // llvm.arm.neon.vld4lane
-    arm_neon_vmaxnm,                           // llvm.arm.neon.vmaxnm
-    arm_neon_vmaxs,                            // llvm.arm.neon.vmaxs
-    arm_neon_vmaxu,                            // llvm.arm.neon.vmaxu
-    arm_neon_vminnm,                           // llvm.arm.neon.vminnm
-    arm_neon_vmins,                            // llvm.arm.neon.vmins
-    arm_neon_vminu,                            // llvm.arm.neon.vminu
-    arm_neon_vmullp,                           // llvm.arm.neon.vmullp
-    arm_neon_vmulls,                           // llvm.arm.neon.vmulls
-    arm_neon_vmullu,                           // llvm.arm.neon.vmullu
-    arm_neon_vmulp,                            // llvm.arm.neon.vmulp
-    arm_neon_vpadals,                          // llvm.arm.neon.vpadals
-    arm_neon_vpadalu,                          // llvm.arm.neon.vpadalu
-    arm_neon_vpadd,                            // llvm.arm.neon.vpadd
-    arm_neon_vpaddls,                          // llvm.arm.neon.vpaddls
-    arm_neon_vpaddlu,                          // llvm.arm.neon.vpaddlu
-    arm_neon_vpmaxs,                           // llvm.arm.neon.vpmaxs
-    arm_neon_vpmaxu,                           // llvm.arm.neon.vpmaxu
-    arm_neon_vpmins,                           // llvm.arm.neon.vpmins
-    arm_neon_vpminu,                           // llvm.arm.neon.vpminu
-    arm_neon_vqabs,                            // llvm.arm.neon.vqabs
-    arm_neon_vqadds,                           // llvm.arm.neon.vqadds
-    arm_neon_vqaddu,                           // llvm.arm.neon.vqaddu
-    arm_neon_vqdmulh,                          // llvm.arm.neon.vqdmulh
-    arm_neon_vqdmull,                          // llvm.arm.neon.vqdmull
-    arm_neon_vqmovns,                          // llvm.arm.neon.vqmovns
-    arm_neon_vqmovnsu,                         // llvm.arm.neon.vqmovnsu
-    arm_neon_vqmovnu,                          // llvm.arm.neon.vqmovnu
-    arm_neon_vqneg,                            // llvm.arm.neon.vqneg
-    arm_neon_vqrdmulh,                         // llvm.arm.neon.vqrdmulh
-    arm_neon_vqrshiftns,                       // llvm.arm.neon.vqrshiftns
-    arm_neon_vqrshiftnsu,                      // llvm.arm.neon.vqrshiftnsu
-    arm_neon_vqrshiftnu,                       // llvm.arm.neon.vqrshiftnu
-    arm_neon_vqrshifts,                        // llvm.arm.neon.vqrshifts
-    arm_neon_vqrshiftu,                        // llvm.arm.neon.vqrshiftu
-    arm_neon_vqshiftns,                        // llvm.arm.neon.vqshiftns
-    arm_neon_vqshiftnsu,                       // llvm.arm.neon.vqshiftnsu
-    arm_neon_vqshiftnu,                        // llvm.arm.neon.vqshiftnu
-    arm_neon_vqshifts,                         // llvm.arm.neon.vqshifts
-    arm_neon_vqshiftsu,                        // llvm.arm.neon.vqshiftsu
-    arm_neon_vqshiftu,                         // llvm.arm.neon.vqshiftu
-    arm_neon_vqsubs,                           // llvm.arm.neon.vqsubs
-    arm_neon_vqsubu,                           // llvm.arm.neon.vqsubu
-    arm_neon_vraddhn,                          // llvm.arm.neon.vraddhn
-    arm_neon_vrecpe,                           // llvm.arm.neon.vrecpe
-    arm_neon_vrecps,                           // llvm.arm.neon.vrecps
-    arm_neon_vrhadds,                          // llvm.arm.neon.vrhadds
-    arm_neon_vrhaddu,                          // llvm.arm.neon.vrhaddu
-    arm_neon_vrinta,                           // llvm.arm.neon.vrinta
-    arm_neon_vrintm,                           // llvm.arm.neon.vrintm
-    arm_neon_vrintn,                           // llvm.arm.neon.vrintn
-    arm_neon_vrintp,                           // llvm.arm.neon.vrintp
-    arm_neon_vrintx,                           // llvm.arm.neon.vrintx
-    arm_neon_vrintz,                           // llvm.arm.neon.vrintz
-    arm_neon_vrshiftn,                         // llvm.arm.neon.vrshiftn
-    arm_neon_vrshifts,                         // llvm.arm.neon.vrshifts
-    arm_neon_vrshiftu,                         // llvm.arm.neon.vrshiftu
-    arm_neon_vrsqrte,                          // llvm.arm.neon.vrsqrte
-    arm_neon_vrsqrts,                          // llvm.arm.neon.vrsqrts
-    arm_neon_vrsubhn,                          // llvm.arm.neon.vrsubhn
-    arm_neon_vshiftins,                        // llvm.arm.neon.vshiftins
-    arm_neon_vshifts,                          // llvm.arm.neon.vshifts
-    arm_neon_vshiftu,                          // llvm.arm.neon.vshiftu
-    arm_neon_vst1,                             // llvm.arm.neon.vst1
-    arm_neon_vst1x2,                           // llvm.arm.neon.vst1x2
-    arm_neon_vst1x3,                           // llvm.arm.neon.vst1x3
-    arm_neon_vst1x4,                           // llvm.arm.neon.vst1x4
-    arm_neon_vst2,                             // llvm.arm.neon.vst2
-    arm_neon_vst2lane,                         // llvm.arm.neon.vst2lane
-    arm_neon_vst3,                             // llvm.arm.neon.vst3
-    arm_neon_vst3lane,                         // llvm.arm.neon.vst3lane
-    arm_neon_vst4,                             // llvm.arm.neon.vst4
-    arm_neon_vst4lane,                         // llvm.arm.neon.vst4lane
-    arm_neon_vtbl1,                            // llvm.arm.neon.vtbl1
-    arm_neon_vtbl2,                            // llvm.arm.neon.vtbl2
-    arm_neon_vtbl3,                            // llvm.arm.neon.vtbl3
-    arm_neon_vtbl4,                            // llvm.arm.neon.vtbl4
-    arm_neon_vtbx1,                            // llvm.arm.neon.vtbx1
-    arm_neon_vtbx2,                            // llvm.arm.neon.vtbx2
-    arm_neon_vtbx3,                            // llvm.arm.neon.vtbx3
-    arm_neon_vtbx4,                            // llvm.arm.neon.vtbx4
-    arm_qadd,                                  // llvm.arm.qadd
-    arm_qadd16,                                // llvm.arm.qadd16
-    arm_qadd8,                                 // llvm.arm.qadd8
-    arm_qasx,                                  // llvm.arm.qasx
-    arm_qsax,                                  // llvm.arm.qsax
-    arm_qsub,                                  // llvm.arm.qsub
-    arm_qsub16,                                // llvm.arm.qsub16
-    arm_qsub8,                                 // llvm.arm.qsub8
-    arm_sadd16,                                // llvm.arm.sadd16
-    arm_sadd8,                                 // llvm.arm.sadd8
-    arm_sasx,                                  // llvm.arm.sasx
-    arm_sel,                                   // llvm.arm.sel
-    arm_set_fpscr,                             // llvm.arm.set.fpscr
-    arm_shadd16,                               // llvm.arm.shadd16
-    arm_shadd8,                                // llvm.arm.shadd8
-    arm_shasx,                                 // llvm.arm.shasx
-    arm_shsax,                                 // llvm.arm.shsax
-    arm_shsub16,                               // llvm.arm.shsub16
-    arm_shsub8,                                // llvm.arm.shsub8
-    arm_smlabb,                                // llvm.arm.smlabb
-    arm_smlabt,                                // llvm.arm.smlabt
-    arm_smlad,                                 // llvm.arm.smlad
-    arm_smladx,                                // llvm.arm.smladx
-    arm_smlald,                                // llvm.arm.smlald
-    arm_smlaldx,                               // llvm.arm.smlaldx
-    arm_smlatb,                                // llvm.arm.smlatb
-    arm_smlatt,                                // llvm.arm.smlatt
-    arm_smlawb,                                // llvm.arm.smlawb
-    arm_smlawt,                                // llvm.arm.smlawt
-    arm_smlsd,                                 // llvm.arm.smlsd
-    arm_smlsdx,                                // llvm.arm.smlsdx
-    arm_smlsld,                                // llvm.arm.smlsld
-    arm_smlsldx,                               // llvm.arm.smlsldx
-    arm_smuad,                                 // llvm.arm.smuad
-    arm_smuadx,                                // llvm.arm.smuadx
-    arm_smulbb,                                // llvm.arm.smulbb
-    arm_smulbt,                                // llvm.arm.smulbt
-    arm_smultb,                                // llvm.arm.smultb
-    arm_smultt,                                // llvm.arm.smultt
-    arm_smulwb,                                // llvm.arm.smulwb
-    arm_smulwt,                                // llvm.arm.smulwt
-    arm_smusd,                                 // llvm.arm.smusd
-    arm_smusdx,                                // llvm.arm.smusdx
-    arm_space,                                 // llvm.arm.space
-    arm_ssat,                                  // llvm.arm.ssat
-    arm_ssat16,                                // llvm.arm.ssat16
-    arm_ssax,                                  // llvm.arm.ssax
-    arm_ssub16,                                // llvm.arm.ssub16
-    arm_ssub8,                                 // llvm.arm.ssub8
-    arm_stc,                                   // llvm.arm.stc
-    arm_stc2,                                  // llvm.arm.stc2
-    arm_stc2l,                                 // llvm.arm.stc2l
-    arm_stcl,                                  // llvm.arm.stcl
-    arm_stlex,                                 // llvm.arm.stlex
-    arm_stlexd,                                // llvm.arm.stlexd
-    arm_strex,                                 // llvm.arm.strex
-    arm_strexd,                                // llvm.arm.strexd
-    arm_sxtab16,                               // llvm.arm.sxtab16
-    arm_sxtb16,                                // llvm.arm.sxtb16
-    arm_uadd16,                                // llvm.arm.uadd16
-    arm_uadd8,                                 // llvm.arm.uadd8
-    arm_uasx,                                  // llvm.arm.uasx
-    arm_uhadd16,                               // llvm.arm.uhadd16
-    arm_uhadd8,                                // llvm.arm.uhadd8
-    arm_uhasx,                                 // llvm.arm.uhasx
-    arm_uhsax,                                 // llvm.arm.uhsax
-    arm_uhsub16,                               // llvm.arm.uhsub16
-    arm_uhsub8,                                // llvm.arm.uhsub8
-    arm_undefined,                             // llvm.arm.undefined
-    arm_uqadd16,                               // llvm.arm.uqadd16
-    arm_uqadd8,                                // llvm.arm.uqadd8
-    arm_uqasx,                                 // llvm.arm.uqasx
-    arm_uqsax,                                 // llvm.arm.uqsax
-    arm_uqsub16,                               // llvm.arm.uqsub16
-    arm_uqsub8,                                // llvm.arm.uqsub8
-    arm_usad8,                                 // llvm.arm.usad8
-    arm_usada8,                                // llvm.arm.usada8
-    arm_usat,                                  // llvm.arm.usat
-    arm_usat16,                                // llvm.arm.usat16
-    arm_usax,                                  // llvm.arm.usax
-    arm_usub16,                                // llvm.arm.usub16
-    arm_usub8,                                 // llvm.arm.usub8
-    arm_uxtab16,                               // llvm.arm.uxtab16
-    arm_uxtb16,                                // llvm.arm.uxtb16
-    arm_vcvtr,                                 // llvm.arm.vcvtr
-    arm_vcvtru,                                // llvm.arm.vcvtru
-    bpf_load_byte,                             // llvm.bpf.load.byte
-    bpf_load_half,                             // llvm.bpf.load.half
-    bpf_load_word,                             // llvm.bpf.load.word
-    bpf_pseudo,                                // llvm.bpf.pseudo
-    hexagon_A2_abs,                            // llvm.hexagon.A2.abs
-    hexagon_A2_absp,                           // llvm.hexagon.A2.absp
-    hexagon_A2_abssat,                         // llvm.hexagon.A2.abssat
-    hexagon_A2_add,                            // llvm.hexagon.A2.add
-    hexagon_A2_addh_h16_hh,                    // llvm.hexagon.A2.addh.h16.hh
-    hexagon_A2_addh_h16_hl,                    // llvm.hexagon.A2.addh.h16.hl
-    hexagon_A2_addh_h16_lh,                    // llvm.hexagon.A2.addh.h16.lh
-    hexagon_A2_addh_h16_ll,                    // llvm.hexagon.A2.addh.h16.ll
-    hexagon_A2_addh_h16_sat_hh,                // llvm.hexagon.A2.addh.h16.sat.hh
-    hexagon_A2_addh_h16_sat_hl,                // llvm.hexagon.A2.addh.h16.sat.hl
-    hexagon_A2_addh_h16_sat_lh,                // llvm.hexagon.A2.addh.h16.sat.lh
-    hexagon_A2_addh_h16_sat_ll,                // llvm.hexagon.A2.addh.h16.sat.ll
-    hexagon_A2_addh_l16_hl,                    // llvm.hexagon.A2.addh.l16.hl
-    hexagon_A2_addh_l16_ll,                    // llvm.hexagon.A2.addh.l16.ll
-    hexagon_A2_addh_l16_sat_hl,                // llvm.hexagon.A2.addh.l16.sat.hl
-    hexagon_A2_addh_l16_sat_ll,                // llvm.hexagon.A2.addh.l16.sat.ll
-    hexagon_A2_addi,                           // llvm.hexagon.A2.addi
-    hexagon_A2_addp,                           // llvm.hexagon.A2.addp
-    hexagon_A2_addpsat,                        // llvm.hexagon.A2.addpsat
-    hexagon_A2_addsat,                         // llvm.hexagon.A2.addsat
-    hexagon_A2_addsp,                          // llvm.hexagon.A2.addsp
-    hexagon_A2_and,                            // llvm.hexagon.A2.and
-    hexagon_A2_andir,                          // llvm.hexagon.A2.andir
-    hexagon_A2_andp,                           // llvm.hexagon.A2.andp
-    hexagon_A2_aslh,                           // llvm.hexagon.A2.aslh
-    hexagon_A2_asrh,                           // llvm.hexagon.A2.asrh
-    hexagon_A2_combine_hh,                     // llvm.hexagon.A2.combine.hh
-    hexagon_A2_combine_hl,                     // llvm.hexagon.A2.combine.hl
-    hexagon_A2_combine_lh,                     // llvm.hexagon.A2.combine.lh
-    hexagon_A2_combine_ll,                     // llvm.hexagon.A2.combine.ll
-    hexagon_A2_combineii,                      // llvm.hexagon.A2.combineii
-    hexagon_A2_combinew,                       // llvm.hexagon.A2.combinew
-    hexagon_A2_max,                            // llvm.hexagon.A2.max
-    hexagon_A2_maxp,                           // llvm.hexagon.A2.maxp
-    hexagon_A2_maxu,                           // llvm.hexagon.A2.maxu
-    hexagon_A2_maxup,                          // llvm.hexagon.A2.maxup
-    hexagon_A2_min,                            // llvm.hexagon.A2.min
-    hexagon_A2_minp,                           // llvm.hexagon.A2.minp
-    hexagon_A2_minu,                           // llvm.hexagon.A2.minu
-    hexagon_A2_minup,                          // llvm.hexagon.A2.minup
-    hexagon_A2_neg,                            // llvm.hexagon.A2.neg
-    hexagon_A2_negp,                           // llvm.hexagon.A2.negp
-    hexagon_A2_negsat,                         // llvm.hexagon.A2.negsat
-    hexagon_A2_not,                            // llvm.hexagon.A2.not
-    hexagon_A2_notp,                           // llvm.hexagon.A2.notp
-    hexagon_A2_or,                             // llvm.hexagon.A2.or
-    hexagon_A2_orir,                           // llvm.hexagon.A2.orir
-    hexagon_A2_orp,                            // llvm.hexagon.A2.orp
-    hexagon_A2_pxorf,                          // llvm.hexagon.A2.pxorf
-    hexagon_A2_roundsat,                       // llvm.hexagon.A2.roundsat
-    hexagon_A2_sat,                            // llvm.hexagon.A2.sat
-    hexagon_A2_satb,                           // llvm.hexagon.A2.satb
-    hexagon_A2_sath,                           // llvm.hexagon.A2.sath
-    hexagon_A2_satub,                          // llvm.hexagon.A2.satub
-    hexagon_A2_satuh,                          // llvm.hexagon.A2.satuh
-    hexagon_A2_sub,                            // llvm.hexagon.A2.sub
-    hexagon_A2_subh_h16_hh,                    // llvm.hexagon.A2.subh.h16.hh
-    hexagon_A2_subh_h16_hl,                    // llvm.hexagon.A2.subh.h16.hl
-    hexagon_A2_subh_h16_lh,                    // llvm.hexagon.A2.subh.h16.lh
-    hexagon_A2_subh_h16_ll,                    // llvm.hexagon.A2.subh.h16.ll
-    hexagon_A2_subh_h16_sat_hh,                // llvm.hexagon.A2.subh.h16.sat.hh
-    hexagon_A2_subh_h16_sat_hl,                // llvm.hexagon.A2.subh.h16.sat.hl
-    hexagon_A2_subh_h16_sat_lh,                // llvm.hexagon.A2.subh.h16.sat.lh
-    hexagon_A2_subh_h16_sat_ll,                // llvm.hexagon.A2.subh.h16.sat.ll
-    hexagon_A2_subh_l16_hl,                    // llvm.hexagon.A2.subh.l16.hl
-    hexagon_A2_subh_l16_ll,                    // llvm.hexagon.A2.subh.l16.ll
-    hexagon_A2_subh_l16_sat_hl,                // llvm.hexagon.A2.subh.l16.sat.hl
-    hexagon_A2_subh_l16_sat_ll,                // llvm.hexagon.A2.subh.l16.sat.ll
-    hexagon_A2_subp,                           // llvm.hexagon.A2.subp
-    hexagon_A2_subri,                          // llvm.hexagon.A2.subri
-    hexagon_A2_subsat,                         // llvm.hexagon.A2.subsat
-    hexagon_A2_svaddh,                         // llvm.hexagon.A2.svaddh
-    hexagon_A2_svaddhs,                        // llvm.hexagon.A2.svaddhs
-    hexagon_A2_svadduhs,                       // llvm.hexagon.A2.svadduhs
-    hexagon_A2_svavgh,                         // llvm.hexagon.A2.svavgh
-    hexagon_A2_svavghs,                        // llvm.hexagon.A2.svavghs
-    hexagon_A2_svnavgh,                        // llvm.hexagon.A2.svnavgh
-    hexagon_A2_svsubh,                         // llvm.hexagon.A2.svsubh
-    hexagon_A2_svsubhs,                        // llvm.hexagon.A2.svsubhs
-    hexagon_A2_svsubuhs,                       // llvm.hexagon.A2.svsubuhs
-    hexagon_A2_swiz,                           // llvm.hexagon.A2.swiz
-    hexagon_A2_sxtb,                           // llvm.hexagon.A2.sxtb
-    hexagon_A2_sxth,                           // llvm.hexagon.A2.sxth
-    hexagon_A2_sxtw,                           // llvm.hexagon.A2.sxtw
-    hexagon_A2_tfr,                            // llvm.hexagon.A2.tfr
-    hexagon_A2_tfrcrr,                         // llvm.hexagon.A2.tfrcrr
-    hexagon_A2_tfrih,                          // llvm.hexagon.A2.tfrih
-    hexagon_A2_tfril,                          // llvm.hexagon.A2.tfril
-    hexagon_A2_tfrp,                           // llvm.hexagon.A2.tfrp
-    hexagon_A2_tfrpi,                          // llvm.hexagon.A2.tfrpi
-    hexagon_A2_tfrrcr,                         // llvm.hexagon.A2.tfrrcr
-    hexagon_A2_tfrsi,                          // llvm.hexagon.A2.tfrsi
-    hexagon_A2_vabsh,                          // llvm.hexagon.A2.vabsh
-    hexagon_A2_vabshsat,                       // llvm.hexagon.A2.vabshsat
-    hexagon_A2_vabsw,                          // llvm.hexagon.A2.vabsw
-    hexagon_A2_vabswsat,                       // llvm.hexagon.A2.vabswsat
-    hexagon_A2_vaddb_map,                      // llvm.hexagon.A2.vaddb.map
-    hexagon_A2_vaddh,                          // llvm.hexagon.A2.vaddh
-    hexagon_A2_vaddhs,                         // llvm.hexagon.A2.vaddhs
-    hexagon_A2_vaddub,                         // llvm.hexagon.A2.vaddub
-    hexagon_A2_vaddubs,                        // llvm.hexagon.A2.vaddubs
-    hexagon_A2_vadduhs,                        // llvm.hexagon.A2.vadduhs
-    hexagon_A2_vaddw,                          // llvm.hexagon.A2.vaddw
-    hexagon_A2_vaddws,                         // llvm.hexagon.A2.vaddws
-    hexagon_A2_vavgh,                          // llvm.hexagon.A2.vavgh
-    hexagon_A2_vavghcr,                        // llvm.hexagon.A2.vavghcr
-    hexagon_A2_vavghr,                         // llvm.hexagon.A2.vavghr
-    hexagon_A2_vavgub,                         // llvm.hexagon.A2.vavgub
-    hexagon_A2_vavgubr,                        // llvm.hexagon.A2.vavgubr
-    hexagon_A2_vavguh,                         // llvm.hexagon.A2.vavguh
-    hexagon_A2_vavguhr,                        // llvm.hexagon.A2.vavguhr
-    hexagon_A2_vavguw,                         // llvm.hexagon.A2.vavguw
-    hexagon_A2_vavguwr,                        // llvm.hexagon.A2.vavguwr
-    hexagon_A2_vavgw,                          // llvm.hexagon.A2.vavgw
-    hexagon_A2_vavgwcr,                        // llvm.hexagon.A2.vavgwcr
-    hexagon_A2_vavgwr,                         // llvm.hexagon.A2.vavgwr
-    hexagon_A2_vcmpbeq,                        // llvm.hexagon.A2.vcmpbeq
-    hexagon_A2_vcmpbgtu,                       // llvm.hexagon.A2.vcmpbgtu
-    hexagon_A2_vcmpheq,                        // llvm.hexagon.A2.vcmpheq
-    hexagon_A2_vcmphgt,                        // llvm.hexagon.A2.vcmphgt
-    hexagon_A2_vcmphgtu,                       // llvm.hexagon.A2.vcmphgtu
-    hexagon_A2_vcmpweq,                        // llvm.hexagon.A2.vcmpweq
-    hexagon_A2_vcmpwgt,                        // llvm.hexagon.A2.vcmpwgt
-    hexagon_A2_vcmpwgtu,                       // llvm.hexagon.A2.vcmpwgtu
-    hexagon_A2_vconj,                          // llvm.hexagon.A2.vconj
-    hexagon_A2_vmaxb,                          // llvm.hexagon.A2.vmaxb
-    hexagon_A2_vmaxh,                          // llvm.hexagon.A2.vmaxh
-    hexagon_A2_vmaxub,                         // llvm.hexagon.A2.vmaxub
-    hexagon_A2_vmaxuh,                         // llvm.hexagon.A2.vmaxuh
-    hexagon_A2_vmaxuw,                         // llvm.hexagon.A2.vmaxuw
-    hexagon_A2_vmaxw,                          // llvm.hexagon.A2.vmaxw
-    hexagon_A2_vminb,                          // llvm.hexagon.A2.vminb
-    hexagon_A2_vminh,                          // llvm.hexagon.A2.vminh
-    hexagon_A2_vminub,                         // llvm.hexagon.A2.vminub
-    hexagon_A2_vminuh,                         // llvm.hexagon.A2.vminuh
-    hexagon_A2_vminuw,                         // llvm.hexagon.A2.vminuw
-    hexagon_A2_vminw,                          // llvm.hexagon.A2.vminw
-    hexagon_A2_vnavgh,                         // llvm.hexagon.A2.vnavgh
-    hexagon_A2_vnavghcr,                       // llvm.hexagon.A2.vnavghcr
-    hexagon_A2_vnavghr,                        // llvm.hexagon.A2.vnavghr
-    hexagon_A2_vnavgw,                         // llvm.hexagon.A2.vnavgw
-    hexagon_A2_vnavgwcr,                       // llvm.hexagon.A2.vnavgwcr
-    hexagon_A2_vnavgwr,                        // llvm.hexagon.A2.vnavgwr
-    hexagon_A2_vraddub,                        // llvm.hexagon.A2.vraddub
-    hexagon_A2_vraddub_acc,                    // llvm.hexagon.A2.vraddub.acc
-    hexagon_A2_vrsadub,                        // llvm.hexagon.A2.vrsadub
-    hexagon_A2_vrsadub_acc,                    // llvm.hexagon.A2.vrsadub.acc
-    hexagon_A2_vsubb_map,                      // llvm.hexagon.A2.vsubb.map
-    hexagon_A2_vsubh,                          // llvm.hexagon.A2.vsubh
-    hexagon_A2_vsubhs,                         // llvm.hexagon.A2.vsubhs
-    hexagon_A2_vsubub,                         // llvm.hexagon.A2.vsubub
-    hexagon_A2_vsububs,                        // llvm.hexagon.A2.vsububs
-    hexagon_A2_vsubuhs,                        // llvm.hexagon.A2.vsubuhs
-    hexagon_A2_vsubw,                          // llvm.hexagon.A2.vsubw
-    hexagon_A2_vsubws,                         // llvm.hexagon.A2.vsubws
-    hexagon_A2_xor,                            // llvm.hexagon.A2.xor
-    hexagon_A2_xorp,                           // llvm.hexagon.A2.xorp
-    hexagon_A2_zxtb,                           // llvm.hexagon.A2.zxtb
-    hexagon_A2_zxth,                           // llvm.hexagon.A2.zxth
-    hexagon_A4_addp_c,                         // llvm.hexagon.A4.addp.c
-    hexagon_A4_andn,                           // llvm.hexagon.A4.andn
-    hexagon_A4_andnp,                          // llvm.hexagon.A4.andnp
-    hexagon_A4_bitsplit,                       // llvm.hexagon.A4.bitsplit
-    hexagon_A4_bitspliti,                      // llvm.hexagon.A4.bitspliti
-    hexagon_A4_boundscheck,                    // llvm.hexagon.A4.boundscheck
-    hexagon_A4_cmpbeq,                         // llvm.hexagon.A4.cmpbeq
-    hexagon_A4_cmpbeqi,                        // llvm.hexagon.A4.cmpbeqi
-    hexagon_A4_cmpbgt,                         // llvm.hexagon.A4.cmpbgt
-    hexagon_A4_cmpbgti,                        // llvm.hexagon.A4.cmpbgti
-    hexagon_A4_cmpbgtu,                        // llvm.hexagon.A4.cmpbgtu
-    hexagon_A4_cmpbgtui,                       // llvm.hexagon.A4.cmpbgtui
-    hexagon_A4_cmpheq,                         // llvm.hexagon.A4.cmpheq
-    hexagon_A4_cmpheqi,                        // llvm.hexagon.A4.cmpheqi
-    hexagon_A4_cmphgt,                         // llvm.hexagon.A4.cmphgt
-    hexagon_A4_cmphgti,                        // llvm.hexagon.A4.cmphgti
-    hexagon_A4_cmphgtu,                        // llvm.hexagon.A4.cmphgtu
-    hexagon_A4_cmphgtui,                       // llvm.hexagon.A4.cmphgtui
-    hexagon_A4_combineii,                      // llvm.hexagon.A4.combineii
-    hexagon_A4_combineir,                      // llvm.hexagon.A4.combineir
-    hexagon_A4_combineri,                      // llvm.hexagon.A4.combineri
-    hexagon_A4_cround_ri,                      // llvm.hexagon.A4.cround.ri
-    hexagon_A4_cround_rr,                      // llvm.hexagon.A4.cround.rr
-    hexagon_A4_modwrapu,                       // llvm.hexagon.A4.modwrapu
-    hexagon_A4_orn,                            // llvm.hexagon.A4.orn
-    hexagon_A4_ornp,                           // llvm.hexagon.A4.ornp
-    hexagon_A4_rcmpeq,                         // llvm.hexagon.A4.rcmpeq
-    hexagon_A4_rcmpeqi,                        // llvm.hexagon.A4.rcmpeqi
-    hexagon_A4_rcmpneq,                        // llvm.hexagon.A4.rcmpneq
-    hexagon_A4_rcmpneqi,                       // llvm.hexagon.A4.rcmpneqi
-    hexagon_A4_round_ri,                       // llvm.hexagon.A4.round.ri
-    hexagon_A4_round_ri_sat,                   // llvm.hexagon.A4.round.ri.sat
-    hexagon_A4_round_rr,                       // llvm.hexagon.A4.round.rr
-    hexagon_A4_round_rr_sat,                   // llvm.hexagon.A4.round.rr.sat
-    hexagon_A4_subp_c,                         // llvm.hexagon.A4.subp.c
-    hexagon_A4_tfrcpp,                         // llvm.hexagon.A4.tfrcpp
-    hexagon_A4_tfrpcp,                         // llvm.hexagon.A4.tfrpcp
-    hexagon_A4_tlbmatch,                       // llvm.hexagon.A4.tlbmatch
-    hexagon_A4_vcmpbeq_any,                    // llvm.hexagon.A4.vcmpbeq.any
-    hexagon_A4_vcmpbeqi,                       // llvm.hexagon.A4.vcmpbeqi
-    hexagon_A4_vcmpbgt,                        // llvm.hexagon.A4.vcmpbgt
-    hexagon_A4_vcmpbgti,                       // llvm.hexagon.A4.vcmpbgti
-    hexagon_A4_vcmpbgtui,                      // llvm.hexagon.A4.vcmpbgtui
-    hexagon_A4_vcmpheqi,                       // llvm.hexagon.A4.vcmpheqi
-    hexagon_A4_vcmphgti,                       // llvm.hexagon.A4.vcmphgti
-    hexagon_A4_vcmphgtui,                      // llvm.hexagon.A4.vcmphgtui
-    hexagon_A4_vcmpweqi,                       // llvm.hexagon.A4.vcmpweqi
-    hexagon_A4_vcmpwgti,                       // llvm.hexagon.A4.vcmpwgti
-    hexagon_A4_vcmpwgtui,                      // llvm.hexagon.A4.vcmpwgtui
-    hexagon_A4_vrmaxh,                         // llvm.hexagon.A4.vrmaxh
-    hexagon_A4_vrmaxuh,                        // llvm.hexagon.A4.vrmaxuh
-    hexagon_A4_vrmaxuw,                        // llvm.hexagon.A4.vrmaxuw
-    hexagon_A4_vrmaxw,                         // llvm.hexagon.A4.vrmaxw
-    hexagon_A4_vrminh,                         // llvm.hexagon.A4.vrminh
-    hexagon_A4_vrminuh,                        // llvm.hexagon.A4.vrminuh
-    hexagon_A4_vrminuw,                        // llvm.hexagon.A4.vrminuw
-    hexagon_A4_vrminw,                         // llvm.hexagon.A4.vrminw
-    hexagon_A5_ACS,                            // llvm.hexagon.A5.ACS
-    hexagon_A5_vaddhubs,                       // llvm.hexagon.A5.vaddhubs
-    hexagon_A6_vcmpbeq_notany,                 // llvm.hexagon.A6.vcmpbeq.notany
-    hexagon_A6_vminub_RdP,                     // llvm.hexagon.A6.vminub.RdP
-    hexagon_C2_all8,                           // llvm.hexagon.C2.all8
-    hexagon_C2_and,                            // llvm.hexagon.C2.and
-    hexagon_C2_andn,                           // llvm.hexagon.C2.andn
-    hexagon_C2_any8,                           // llvm.hexagon.C2.any8
-    hexagon_C2_bitsclr,                        // llvm.hexagon.C2.bitsclr
-    hexagon_C2_bitsclri,                       // llvm.hexagon.C2.bitsclri
-    hexagon_C2_bitsset,                        // llvm.hexagon.C2.bitsset
-    hexagon_C2_cmpeq,                          // llvm.hexagon.C2.cmpeq
-    hexagon_C2_cmpeqi,                         // llvm.hexagon.C2.cmpeqi
-    hexagon_C2_cmpeqp,                         // llvm.hexagon.C2.cmpeqp
-    hexagon_C2_cmpgei,                         // llvm.hexagon.C2.cmpgei
-    hexagon_C2_cmpgeui,                        // llvm.hexagon.C2.cmpgeui
-    hexagon_C2_cmpgt,                          // llvm.hexagon.C2.cmpgt
-    hexagon_C2_cmpgti,                         // llvm.hexagon.C2.cmpgti
-    hexagon_C2_cmpgtp,                         // llvm.hexagon.C2.cmpgtp
-    hexagon_C2_cmpgtu,                         // llvm.hexagon.C2.cmpgtu
-    hexagon_C2_cmpgtui,                        // llvm.hexagon.C2.cmpgtui
-    hexagon_C2_cmpgtup,                        // llvm.hexagon.C2.cmpgtup
-    hexagon_C2_cmplt,                          // llvm.hexagon.C2.cmplt
-    hexagon_C2_cmpltu,                         // llvm.hexagon.C2.cmpltu
-    hexagon_C2_mask,                           // llvm.hexagon.C2.mask
-    hexagon_C2_mux,                            // llvm.hexagon.C2.mux
-    hexagon_C2_muxii,                          // llvm.hexagon.C2.muxii
-    hexagon_C2_muxir,                          // llvm.hexagon.C2.muxir
-    hexagon_C2_muxri,                          // llvm.hexagon.C2.muxri
-    hexagon_C2_not,                            // llvm.hexagon.C2.not
-    hexagon_C2_or,                             // llvm.hexagon.C2.or
-    hexagon_C2_orn,                            // llvm.hexagon.C2.orn
-    hexagon_C2_pxfer_map,                      // llvm.hexagon.C2.pxfer.map
-    hexagon_C2_tfrpr,                          // llvm.hexagon.C2.tfrpr
-    hexagon_C2_tfrrp,                          // llvm.hexagon.C2.tfrrp
-    hexagon_C2_vitpack,                        // llvm.hexagon.C2.vitpack
-    hexagon_C2_vmux,                           // llvm.hexagon.C2.vmux
-    hexagon_C2_xor,                            // llvm.hexagon.C2.xor
-    hexagon_C4_and_and,                        // llvm.hexagon.C4.and.and
-    hexagon_C4_and_andn,                       // llvm.hexagon.C4.and.andn
-    hexagon_C4_and_or,                         // llvm.hexagon.C4.and.or
-    hexagon_C4_and_orn,                        // llvm.hexagon.C4.and.orn
-    hexagon_C4_cmplte,                         // llvm.hexagon.C4.cmplte
-    hexagon_C4_cmpltei,                        // llvm.hexagon.C4.cmpltei
-    hexagon_C4_cmplteu,                        // llvm.hexagon.C4.cmplteu
-    hexagon_C4_cmplteui,                       // llvm.hexagon.C4.cmplteui
-    hexagon_C4_cmpneq,                         // llvm.hexagon.C4.cmpneq
-    hexagon_C4_cmpneqi,                        // llvm.hexagon.C4.cmpneqi
-    hexagon_C4_fastcorner9,                    // llvm.hexagon.C4.fastcorner9
-    hexagon_C4_fastcorner9_not,                // llvm.hexagon.C4.fastcorner9.not
-    hexagon_C4_nbitsclr,                       // llvm.hexagon.C4.nbitsclr
-    hexagon_C4_nbitsclri,                      // llvm.hexagon.C4.nbitsclri
-    hexagon_C4_nbitsset,                       // llvm.hexagon.C4.nbitsset
-    hexagon_C4_or_and,                         // llvm.hexagon.C4.or.and
-    hexagon_C4_or_andn,                        // llvm.hexagon.C4.or.andn
-    hexagon_C4_or_or,                          // llvm.hexagon.C4.or.or
-    hexagon_C4_or_orn,                         // llvm.hexagon.C4.or.orn
-    hexagon_F2_conv_d2df,                      // llvm.hexagon.F2.conv.d2df
-    hexagon_F2_conv_d2sf,                      // llvm.hexagon.F2.conv.d2sf
-    hexagon_F2_conv_df2d,                      // llvm.hexagon.F2.conv.df2d
-    hexagon_F2_conv_df2d_chop,                 // llvm.hexagon.F2.conv.df2d.chop
-    hexagon_F2_conv_df2sf,                     // llvm.hexagon.F2.conv.df2sf
-    hexagon_F2_conv_df2ud,                     // llvm.hexagon.F2.conv.df2ud
-    hexagon_F2_conv_df2ud_chop,                // llvm.hexagon.F2.conv.df2ud.chop
-    hexagon_F2_conv_df2uw,                     // llvm.hexagon.F2.conv.df2uw
-    hexagon_F2_conv_df2uw_chop,                // llvm.hexagon.F2.conv.df2uw.chop
-    hexagon_F2_conv_df2w,                      // llvm.hexagon.F2.conv.df2w
-    hexagon_F2_conv_df2w_chop,                 // llvm.hexagon.F2.conv.df2w.chop
-    hexagon_F2_conv_sf2d,                      // llvm.hexagon.F2.conv.sf2d
-    hexagon_F2_conv_sf2d_chop,                 // llvm.hexagon.F2.conv.sf2d.chop
-    hexagon_F2_conv_sf2df,                     // llvm.hexagon.F2.conv.sf2df
-    hexagon_F2_conv_sf2ud,                     // llvm.hexagon.F2.conv.sf2ud
-    hexagon_F2_conv_sf2ud_chop,                // llvm.hexagon.F2.conv.sf2ud.chop
-    hexagon_F2_conv_sf2uw,                     // llvm.hexagon.F2.conv.sf2uw
-    hexagon_F2_conv_sf2uw_chop,                // llvm.hexagon.F2.conv.sf2uw.chop
-    hexagon_F2_conv_sf2w,                      // llvm.hexagon.F2.conv.sf2w
-    hexagon_F2_conv_sf2w_chop,                 // llvm.hexagon.F2.conv.sf2w.chop
-    hexagon_F2_conv_ud2df,                     // llvm.hexagon.F2.conv.ud2df
-    hexagon_F2_conv_ud2sf,                     // llvm.hexagon.F2.conv.ud2sf
-    hexagon_F2_conv_uw2df,                     // llvm.hexagon.F2.conv.uw2df
-    hexagon_F2_conv_uw2sf,                     // llvm.hexagon.F2.conv.uw2sf
-    hexagon_F2_conv_w2df,                      // llvm.hexagon.F2.conv.w2df
-    hexagon_F2_conv_w2sf,                      // llvm.hexagon.F2.conv.w2sf
-    hexagon_F2_dfadd,                          // llvm.hexagon.F2.dfadd
-    hexagon_F2_dfclass,                        // llvm.hexagon.F2.dfclass
-    hexagon_F2_dfcmpeq,                        // llvm.hexagon.F2.dfcmpeq
-    hexagon_F2_dfcmpge,                        // llvm.hexagon.F2.dfcmpge
-    hexagon_F2_dfcmpgt,                        // llvm.hexagon.F2.dfcmpgt
-    hexagon_F2_dfcmpuo,                        // llvm.hexagon.F2.dfcmpuo
-    hexagon_F2_dfimm_n,                        // llvm.hexagon.F2.dfimm.n
-    hexagon_F2_dfimm_p,                        // llvm.hexagon.F2.dfimm.p
-    hexagon_F2_dfsub,                          // llvm.hexagon.F2.dfsub
-    hexagon_F2_sfadd,                          // llvm.hexagon.F2.sfadd
-    hexagon_F2_sfclass,                        // llvm.hexagon.F2.sfclass
-    hexagon_F2_sfcmpeq,                        // llvm.hexagon.F2.sfcmpeq
-    hexagon_F2_sfcmpge,                        // llvm.hexagon.F2.sfcmpge
-    hexagon_F2_sfcmpgt,                        // llvm.hexagon.F2.sfcmpgt
-    hexagon_F2_sfcmpuo,                        // llvm.hexagon.F2.sfcmpuo
-    hexagon_F2_sffixupd,                       // llvm.hexagon.F2.sffixupd
-    hexagon_F2_sffixupn,                       // llvm.hexagon.F2.sffixupn
-    hexagon_F2_sffixupr,                       // llvm.hexagon.F2.sffixupr
-    hexagon_F2_sffma,                          // llvm.hexagon.F2.sffma
-    hexagon_F2_sffma_lib,                      // llvm.hexagon.F2.sffma.lib
-    hexagon_F2_sffma_sc,                       // llvm.hexagon.F2.sffma.sc
-    hexagon_F2_sffms,                          // llvm.hexagon.F2.sffms
-    hexagon_F2_sffms_lib,                      // llvm.hexagon.F2.sffms.lib
-    hexagon_F2_sfimm_n,                        // llvm.hexagon.F2.sfimm.n
-    hexagon_F2_sfimm_p,                        // llvm.hexagon.F2.sfimm.p
-    hexagon_F2_sfinvsqrta,                     // llvm.hexagon.F2.sfinvsqrta
-    hexagon_F2_sfmax,                          // llvm.hexagon.F2.sfmax
-    hexagon_F2_sfmin,                          // llvm.hexagon.F2.sfmin
-    hexagon_F2_sfmpy,                          // llvm.hexagon.F2.sfmpy
-    hexagon_F2_sfrecipa,                       // llvm.hexagon.F2.sfrecipa
-    hexagon_F2_sfsub,                          // llvm.hexagon.F2.sfsub
-    hexagon_L2_loadrb_pbr,                     // llvm.hexagon.L2.loadrb.pbr
-    hexagon_L2_loadrb_pci,                     // llvm.hexagon.L2.loadrb.pci
-    hexagon_L2_loadrb_pcr,                     // llvm.hexagon.L2.loadrb.pcr
-    hexagon_L2_loadrd_pbr,                     // llvm.hexagon.L2.loadrd.pbr
-    hexagon_L2_loadrd_pci,                     // llvm.hexagon.L2.loadrd.pci
-    hexagon_L2_loadrd_pcr,                     // llvm.hexagon.L2.loadrd.pcr
-    hexagon_L2_loadrh_pbr,                     // llvm.hexagon.L2.loadrh.pbr
-    hexagon_L2_loadrh_pci,                     // llvm.hexagon.L2.loadrh.pci
-    hexagon_L2_loadrh_pcr,                     // llvm.hexagon.L2.loadrh.pcr
-    hexagon_L2_loadri_pbr,                     // llvm.hexagon.L2.loadri.pbr
-    hexagon_L2_loadri_pci,                     // llvm.hexagon.L2.loadri.pci
-    hexagon_L2_loadri_pcr,                     // llvm.hexagon.L2.loadri.pcr
-    hexagon_L2_loadrub_pbr,                    // llvm.hexagon.L2.loadrub.pbr
-    hexagon_L2_loadrub_pci,                    // llvm.hexagon.L2.loadrub.pci
-    hexagon_L2_loadrub_pcr,                    // llvm.hexagon.L2.loadrub.pcr
-    hexagon_L2_loadruh_pbr,                    // llvm.hexagon.L2.loadruh.pbr
-    hexagon_L2_loadruh_pci,                    // llvm.hexagon.L2.loadruh.pci
-    hexagon_L2_loadruh_pcr,                    // llvm.hexagon.L2.loadruh.pcr
-    hexagon_L2_loadw_locked,                   // llvm.hexagon.L2.loadw.locked
-    hexagon_L4_loadd_locked,                   // llvm.hexagon.L4.loadd.locked
-    hexagon_M2_acci,                           // llvm.hexagon.M2.acci
-    hexagon_M2_accii,                          // llvm.hexagon.M2.accii
-    hexagon_M2_cmaci_s0,                       // llvm.hexagon.M2.cmaci.s0
-    hexagon_M2_cmacr_s0,                       // llvm.hexagon.M2.cmacr.s0
-    hexagon_M2_cmacs_s0,                       // llvm.hexagon.M2.cmacs.s0
-    hexagon_M2_cmacs_s1,                       // llvm.hexagon.M2.cmacs.s1
-    hexagon_M2_cmacsc_s0,                      // llvm.hexagon.M2.cmacsc.s0
-    hexagon_M2_cmacsc_s1,                      // llvm.hexagon.M2.cmacsc.s1
-    hexagon_M2_cmpyi_s0,                       // llvm.hexagon.M2.cmpyi.s0
-    hexagon_M2_cmpyr_s0,                       // llvm.hexagon.M2.cmpyr.s0
-    hexagon_M2_cmpyrs_s0,                      // llvm.hexagon.M2.cmpyrs.s0
-    hexagon_M2_cmpyrs_s1,                      // llvm.hexagon.M2.cmpyrs.s1
-    hexagon_M2_cmpyrsc_s0,                     // llvm.hexagon.M2.cmpyrsc.s0
-    hexagon_M2_cmpyrsc_s1,                     // llvm.hexagon.M2.cmpyrsc.s1
-    hexagon_M2_cmpys_s0,                       // llvm.hexagon.M2.cmpys.s0
-    hexagon_M2_cmpys_s1,                       // llvm.hexagon.M2.cmpys.s1
-    hexagon_M2_cmpysc_s0,                      // llvm.hexagon.M2.cmpysc.s0
-    hexagon_M2_cmpysc_s1,                      // llvm.hexagon.M2.cmpysc.s1
-    hexagon_M2_cnacs_s0,                       // llvm.hexagon.M2.cnacs.s0
-    hexagon_M2_cnacs_s1,                       // llvm.hexagon.M2.cnacs.s1
-    hexagon_M2_cnacsc_s0,                      // llvm.hexagon.M2.cnacsc.s0
-    hexagon_M2_cnacsc_s1,                      // llvm.hexagon.M2.cnacsc.s1
-    hexagon_M2_dpmpyss_acc_s0,                 // llvm.hexagon.M2.dpmpyss.acc.s0
-    hexagon_M2_dpmpyss_nac_s0,                 // llvm.hexagon.M2.dpmpyss.nac.s0
-    hexagon_M2_dpmpyss_rnd_s0,                 // llvm.hexagon.M2.dpmpyss.rnd.s0
-    hexagon_M2_dpmpyss_s0,                     // llvm.hexagon.M2.dpmpyss.s0
-    hexagon_M2_dpmpyuu_acc_s0,                 // llvm.hexagon.M2.dpmpyuu.acc.s0
-    hexagon_M2_dpmpyuu_nac_s0,                 // llvm.hexagon.M2.dpmpyuu.nac.s0
-    hexagon_M2_dpmpyuu_s0,                     // llvm.hexagon.M2.dpmpyuu.s0
-    hexagon_M2_hmmpyh_rs1,                     // llvm.hexagon.M2.hmmpyh.rs1
-    hexagon_M2_hmmpyh_s1,                      // llvm.hexagon.M2.hmmpyh.s1
-    hexagon_M2_hmmpyl_rs1,                     // llvm.hexagon.M2.hmmpyl.rs1
-    hexagon_M2_hmmpyl_s1,                      // llvm.hexagon.M2.hmmpyl.s1
-    hexagon_M2_maci,                           // llvm.hexagon.M2.maci
-    hexagon_M2_macsin,                         // llvm.hexagon.M2.macsin
-    hexagon_M2_macsip,                         // llvm.hexagon.M2.macsip
-    hexagon_M2_mmachs_rs0,                     // llvm.hexagon.M2.mmachs.rs0
-    hexagon_M2_mmachs_rs1,                     // llvm.hexagon.M2.mmachs.rs1
-    hexagon_M2_mmachs_s0,                      // llvm.hexagon.M2.mmachs.s0
-    hexagon_M2_mmachs_s1,                      // llvm.hexagon.M2.mmachs.s1
-    hexagon_M2_mmacls_rs0,                     // llvm.hexagon.M2.mmacls.rs0
-    hexagon_M2_mmacls_rs1,                     // llvm.hexagon.M2.mmacls.rs1
-    hexagon_M2_mmacls_s0,                      // llvm.hexagon.M2.mmacls.s0
-    hexagon_M2_mmacls_s1,                      // llvm.hexagon.M2.mmacls.s1
-    hexagon_M2_mmacuhs_rs0,                    // llvm.hexagon.M2.mmacuhs.rs0
-    hexagon_M2_mmacuhs_rs1,                    // llvm.hexagon.M2.mmacuhs.rs1
-    hexagon_M2_mmacuhs_s0,                     // llvm.hexagon.M2.mmacuhs.s0
-    hexagon_M2_mmacuhs_s1,                     // llvm.hexagon.M2.mmacuhs.s1
-    hexagon_M2_mmaculs_rs0,                    // llvm.hexagon.M2.mmaculs.rs0
-    hexagon_M2_mmaculs_rs1,                    // llvm.hexagon.M2.mmaculs.rs1
-    hexagon_M2_mmaculs_s0,                     // llvm.hexagon.M2.mmaculs.s0
-    hexagon_M2_mmaculs_s1,                     // llvm.hexagon.M2.mmaculs.s1
-    hexagon_M2_mmpyh_rs0,                      // llvm.hexagon.M2.mmpyh.rs0
-    hexagon_M2_mmpyh_rs1,                      // llvm.hexagon.M2.mmpyh.rs1
-    hexagon_M2_mmpyh_s0,                       // llvm.hexagon.M2.mmpyh.s0
-    hexagon_M2_mmpyh_s1,                       // llvm.hexagon.M2.mmpyh.s1
-    hexagon_M2_mmpyl_rs0,                      // llvm.hexagon.M2.mmpyl.rs0
-    hexagon_M2_mmpyl_rs1,                      // llvm.hexagon.M2.mmpyl.rs1
-    hexagon_M2_mmpyl_s0,                       // llvm.hexagon.M2.mmpyl.s0
-    hexagon_M2_mmpyl_s1,                       // llvm.hexagon.M2.mmpyl.s1
-    hexagon_M2_mmpyuh_rs0,                     // llvm.hexagon.M2.mmpyuh.rs0
-    hexagon_M2_mmpyuh_rs1,                     // llvm.hexagon.M2.mmpyuh.rs1
-    hexagon_M2_mmpyuh_s0,                      // llvm.hexagon.M2.mmpyuh.s0
-    hexagon_M2_mmpyuh_s1,                      // llvm.hexagon.M2.mmpyuh.s1
-    hexagon_M2_mmpyul_rs0,                     // llvm.hexagon.M2.mmpyul.rs0
-    hexagon_M2_mmpyul_rs1,                     // llvm.hexagon.M2.mmpyul.rs1
-    hexagon_M2_mmpyul_s0,                      // llvm.hexagon.M2.mmpyul.s0
-    hexagon_M2_mmpyul_s1,                      // llvm.hexagon.M2.mmpyul.s1
-    hexagon_M2_mnaci,                          // llvm.hexagon.M2.mnaci
-    hexagon_M2_mpy_acc_hh_s0,                  // llvm.hexagon.M2.mpy.acc.hh.s0
-    hexagon_M2_mpy_acc_hh_s1,                  // llvm.hexagon.M2.mpy.acc.hh.s1
-    hexagon_M2_mpy_acc_hl_s0,                  // llvm.hexagon.M2.mpy.acc.hl.s0
-    hexagon_M2_mpy_acc_hl_s1,                  // llvm.hexagon.M2.mpy.acc.hl.s1
-    hexagon_M2_mpy_acc_lh_s0,                  // llvm.hexagon.M2.mpy.acc.lh.s0
-    hexagon_M2_mpy_acc_lh_s1,                  // llvm.hexagon.M2.mpy.acc.lh.s1
-    hexagon_M2_mpy_acc_ll_s0,                  // llvm.hexagon.M2.mpy.acc.ll.s0
-    hexagon_M2_mpy_acc_ll_s1,                  // llvm.hexagon.M2.mpy.acc.ll.s1
-    hexagon_M2_mpy_acc_sat_hh_s0,              // llvm.hexagon.M2.mpy.acc.sat.hh.s0
-    hexagon_M2_mpy_acc_sat_hh_s1,              // llvm.hexagon.M2.mpy.acc.sat.hh.s1
-    hexagon_M2_mpy_acc_sat_hl_s0,              // llvm.hexagon.M2.mpy.acc.sat.hl.s0
-    hexagon_M2_mpy_acc_sat_hl_s1,              // llvm.hexagon.M2.mpy.acc.sat.hl.s1
-    hexagon_M2_mpy_acc_sat_lh_s0,              // llvm.hexagon.M2.mpy.acc.sat.lh.s0
-    hexagon_M2_mpy_acc_sat_lh_s1,              // llvm.hexagon.M2.mpy.acc.sat.lh.s1
-    hexagon_M2_mpy_acc_sat_ll_s0,              // llvm.hexagon.M2.mpy.acc.sat.ll.s0
-    hexagon_M2_mpy_acc_sat_ll_s1,              // llvm.hexagon.M2.mpy.acc.sat.ll.s1
-    hexagon_M2_mpy_hh_s0,                      // llvm.hexagon.M2.mpy.hh.s0
-    hexagon_M2_mpy_hh_s1,                      // llvm.hexagon.M2.mpy.hh.s1
-    hexagon_M2_mpy_hl_s0,                      // llvm.hexagon.M2.mpy.hl.s0
-    hexagon_M2_mpy_hl_s1,                      // llvm.hexagon.M2.mpy.hl.s1
-    hexagon_M2_mpy_lh_s0,                      // llvm.hexagon.M2.mpy.lh.s0
-    hexagon_M2_mpy_lh_s1,                      // llvm.hexagon.M2.mpy.lh.s1
-    hexagon_M2_mpy_ll_s0,                      // llvm.hexagon.M2.mpy.ll.s0
-    hexagon_M2_mpy_ll_s1,                      // llvm.hexagon.M2.mpy.ll.s1
-    hexagon_M2_mpy_nac_hh_s0,                  // llvm.hexagon.M2.mpy.nac.hh.s0
-    hexagon_M2_mpy_nac_hh_s1,                  // llvm.hexagon.M2.mpy.nac.hh.s1
-    hexagon_M2_mpy_nac_hl_s0,                  // llvm.hexagon.M2.mpy.nac.hl.s0
-    hexagon_M2_mpy_nac_hl_s1,                  // llvm.hexagon.M2.mpy.nac.hl.s1
-    hexagon_M2_mpy_nac_lh_s0,                  // llvm.hexagon.M2.mpy.nac.lh.s0
-    hexagon_M2_mpy_nac_lh_s1,                  // llvm.hexagon.M2.mpy.nac.lh.s1
-    hexagon_M2_mpy_nac_ll_s0,                  // llvm.hexagon.M2.mpy.nac.ll.s0
-    hexagon_M2_mpy_nac_ll_s1,                  // llvm.hexagon.M2.mpy.nac.ll.s1
-    hexagon_M2_mpy_nac_sat_hh_s0,              // llvm.hexagon.M2.mpy.nac.sat.hh.s0
-    hexagon_M2_mpy_nac_sat_hh_s1,              // llvm.hexagon.M2.mpy.nac.sat.hh.s1
-    hexagon_M2_mpy_nac_sat_hl_s0,              // llvm.hexagon.M2.mpy.nac.sat.hl.s0
-    hexagon_M2_mpy_nac_sat_hl_s1,              // llvm.hexagon.M2.mpy.nac.sat.hl.s1
-    hexagon_M2_mpy_nac_sat_lh_s0,              // llvm.hexagon.M2.mpy.nac.sat.lh.s0
-    hexagon_M2_mpy_nac_sat_lh_s1,              // llvm.hexagon.M2.mpy.nac.sat.lh.s1
-    hexagon_M2_mpy_nac_sat_ll_s0,              // llvm.hexagon.M2.mpy.nac.sat.ll.s0
-    hexagon_M2_mpy_nac_sat_ll_s1,              // llvm.hexagon.M2.mpy.nac.sat.ll.s1
-    hexagon_M2_mpy_rnd_hh_s0,                  // llvm.hexagon.M2.mpy.rnd.hh.s0
-    hexagon_M2_mpy_rnd_hh_s1,                  // llvm.hexagon.M2.mpy.rnd.hh.s1
-    hexagon_M2_mpy_rnd_hl_s0,                  // llvm.hexagon.M2.mpy.rnd.hl.s0
-    hexagon_M2_mpy_rnd_hl_s1,                  // llvm.hexagon.M2.mpy.rnd.hl.s1
-    hexagon_M2_mpy_rnd_lh_s0,                  // llvm.hexagon.M2.mpy.rnd.lh.s0
-    hexagon_M2_mpy_rnd_lh_s1,                  // llvm.hexagon.M2.mpy.rnd.lh.s1
-    hexagon_M2_mpy_rnd_ll_s0,                  // llvm.hexagon.M2.mpy.rnd.ll.s0
-    hexagon_M2_mpy_rnd_ll_s1,                  // llvm.hexagon.M2.mpy.rnd.ll.s1
-    hexagon_M2_mpy_sat_hh_s0,                  // llvm.hexagon.M2.mpy.sat.hh.s0
-    hexagon_M2_mpy_sat_hh_s1,                  // llvm.hexagon.M2.mpy.sat.hh.s1
-    hexagon_M2_mpy_sat_hl_s0,                  // llvm.hexagon.M2.mpy.sat.hl.s0
-    hexagon_M2_mpy_sat_hl_s1,                  // llvm.hexagon.M2.mpy.sat.hl.s1
-    hexagon_M2_mpy_sat_lh_s0,                  // llvm.hexagon.M2.mpy.sat.lh.s0
-    hexagon_M2_mpy_sat_lh_s1,                  // llvm.hexagon.M2.mpy.sat.lh.s1
-    hexagon_M2_mpy_sat_ll_s0,                  // llvm.hexagon.M2.mpy.sat.ll.s0
-    hexagon_M2_mpy_sat_ll_s1,                  // llvm.hexagon.M2.mpy.sat.ll.s1
-    hexagon_M2_mpy_sat_rnd_hh_s0,              // llvm.hexagon.M2.mpy.sat.rnd.hh.s0
-    hexagon_M2_mpy_sat_rnd_hh_s1,              // llvm.hexagon.M2.mpy.sat.rnd.hh.s1
-    hexagon_M2_mpy_sat_rnd_hl_s0,              // llvm.hexagon.M2.mpy.sat.rnd.hl.s0
-    hexagon_M2_mpy_sat_rnd_hl_s1,              // llvm.hexagon.M2.mpy.sat.rnd.hl.s1
-    hexagon_M2_mpy_sat_rnd_lh_s0,              // llvm.hexagon.M2.mpy.sat.rnd.lh.s0
-    hexagon_M2_mpy_sat_rnd_lh_s1,              // llvm.hexagon.M2.mpy.sat.rnd.lh.s1
-    hexagon_M2_mpy_sat_rnd_ll_s0,              // llvm.hexagon.M2.mpy.sat.rnd.ll.s0
-    hexagon_M2_mpy_sat_rnd_ll_s1,              // llvm.hexagon.M2.mpy.sat.rnd.ll.s1
-    hexagon_M2_mpy_up,                         // llvm.hexagon.M2.mpy.up
-    hexagon_M2_mpy_up_s1,                      // llvm.hexagon.M2.mpy.up.s1
-    hexagon_M2_mpy_up_s1_sat,                  // llvm.hexagon.M2.mpy.up.s1.sat
-    hexagon_M2_mpyd_acc_hh_s0,                 // llvm.hexagon.M2.mpyd.acc.hh.s0
-    hexagon_M2_mpyd_acc_hh_s1,                 // llvm.hexagon.M2.mpyd.acc.hh.s1
-    hexagon_M2_mpyd_acc_hl_s0,                 // llvm.hexagon.M2.mpyd.acc.hl.s0
-    hexagon_M2_mpyd_acc_hl_s1,                 // llvm.hexagon.M2.mpyd.acc.hl.s1
-    hexagon_M2_mpyd_acc_lh_s0,                 // llvm.hexagon.M2.mpyd.acc.lh.s0
-    hexagon_M2_mpyd_acc_lh_s1,                 // llvm.hexagon.M2.mpyd.acc.lh.s1
-    hexagon_M2_mpyd_acc_ll_s0,                 // llvm.hexagon.M2.mpyd.acc.ll.s0
-    hexagon_M2_mpyd_acc_ll_s1,                 // llvm.hexagon.M2.mpyd.acc.ll.s1
-    hexagon_M2_mpyd_hh_s0,                     // llvm.hexagon.M2.mpyd.hh.s0
-    hexagon_M2_mpyd_hh_s1,                     // llvm.hexagon.M2.mpyd.hh.s1
-    hexagon_M2_mpyd_hl_s0,                     // llvm.hexagon.M2.mpyd.hl.s0
-    hexagon_M2_mpyd_hl_s1,                     // llvm.hexagon.M2.mpyd.hl.s1
-    hexagon_M2_mpyd_lh_s0,                     // llvm.hexagon.M2.mpyd.lh.s0
-    hexagon_M2_mpyd_lh_s1,                     // llvm.hexagon.M2.mpyd.lh.s1
-    hexagon_M2_mpyd_ll_s0,                     // llvm.hexagon.M2.mpyd.ll.s0
-    hexagon_M2_mpyd_ll_s1,                     // llvm.hexagon.M2.mpyd.ll.s1
-    hexagon_M2_mpyd_nac_hh_s0,                 // llvm.hexagon.M2.mpyd.nac.hh.s0
-    hexagon_M2_mpyd_nac_hh_s1,                 // llvm.hexagon.M2.mpyd.nac.hh.s1
-    hexagon_M2_mpyd_nac_hl_s0,                 // llvm.hexagon.M2.mpyd.nac.hl.s0
-    hexagon_M2_mpyd_nac_hl_s1,                 // llvm.hexagon.M2.mpyd.nac.hl.s1
-    hexagon_M2_mpyd_nac_lh_s0,                 // llvm.hexagon.M2.mpyd.nac.lh.s0
-    hexagon_M2_mpyd_nac_lh_s1,                 // llvm.hexagon.M2.mpyd.nac.lh.s1
-    hexagon_M2_mpyd_nac_ll_s0,                 // llvm.hexagon.M2.mpyd.nac.ll.s0
-    hexagon_M2_mpyd_nac_ll_s1,                 // llvm.hexagon.M2.mpyd.nac.ll.s1
-    hexagon_M2_mpyd_rnd_hh_s0,                 // llvm.hexagon.M2.mpyd.rnd.hh.s0
-    hexagon_M2_mpyd_rnd_hh_s1,                 // llvm.hexagon.M2.mpyd.rnd.hh.s1
-    hexagon_M2_mpyd_rnd_hl_s0,                 // llvm.hexagon.M2.mpyd.rnd.hl.s0
-    hexagon_M2_mpyd_rnd_hl_s1,                 // llvm.hexagon.M2.mpyd.rnd.hl.s1
-    hexagon_M2_mpyd_rnd_lh_s0,                 // llvm.hexagon.M2.mpyd.rnd.lh.s0
-    hexagon_M2_mpyd_rnd_lh_s1,                 // llvm.hexagon.M2.mpyd.rnd.lh.s1
-    hexagon_M2_mpyd_rnd_ll_s0,                 // llvm.hexagon.M2.mpyd.rnd.ll.s0
-    hexagon_M2_mpyd_rnd_ll_s1,                 // llvm.hexagon.M2.mpyd.rnd.ll.s1
-    hexagon_M2_mpyi,                           // llvm.hexagon.M2.mpyi
-    hexagon_M2_mpysin,                         // llvm.hexagon.M2.mpysin
-    hexagon_M2_mpysip,                         // llvm.hexagon.M2.mpysip
-    hexagon_M2_mpysmi,                         // llvm.hexagon.M2.mpysmi
-    hexagon_M2_mpysu_up,                       // llvm.hexagon.M2.mpysu.up
-    hexagon_M2_mpyu_acc_hh_s0,                 // llvm.hexagon.M2.mpyu.acc.hh.s0
-    hexagon_M2_mpyu_acc_hh_s1,                 // llvm.hexagon.M2.mpyu.acc.hh.s1
-    hexagon_M2_mpyu_acc_hl_s0,                 // llvm.hexagon.M2.mpyu.acc.hl.s0
-    hexagon_M2_mpyu_acc_hl_s1,                 // llvm.hexagon.M2.mpyu.acc.hl.s1
-    hexagon_M2_mpyu_acc_lh_s0,                 // llvm.hexagon.M2.mpyu.acc.lh.s0
-    hexagon_M2_mpyu_acc_lh_s1,                 // llvm.hexagon.M2.mpyu.acc.lh.s1
-    hexagon_M2_mpyu_acc_ll_s0,                 // llvm.hexagon.M2.mpyu.acc.ll.s0
-    hexagon_M2_mpyu_acc_ll_s1,                 // llvm.hexagon.M2.mpyu.acc.ll.s1
-    hexagon_M2_mpyu_hh_s0,                     // llvm.hexagon.M2.mpyu.hh.s0
-    hexagon_M2_mpyu_hh_s1,                     // llvm.hexagon.M2.mpyu.hh.s1
-    hexagon_M2_mpyu_hl_s0,                     // llvm.hexagon.M2.mpyu.hl.s0
-    hexagon_M2_mpyu_hl_s1,                     // llvm.hexagon.M2.mpyu.hl.s1
-    hexagon_M2_mpyu_lh_s0,                     // llvm.hexagon.M2.mpyu.lh.s0
-    hexagon_M2_mpyu_lh_s1,                     // llvm.hexagon.M2.mpyu.lh.s1
-    hexagon_M2_mpyu_ll_s0,                     // llvm.hexagon.M2.mpyu.ll.s0
-    hexagon_M2_mpyu_ll_s1,                     // llvm.hexagon.M2.mpyu.ll.s1
-    hexagon_M2_mpyu_nac_hh_s0,                 // llvm.hexagon.M2.mpyu.nac.hh.s0
-    hexagon_M2_mpyu_nac_hh_s1,                 // llvm.hexagon.M2.mpyu.nac.hh.s1
-    hexagon_M2_mpyu_nac_hl_s0,                 // llvm.hexagon.M2.mpyu.nac.hl.s0
-    hexagon_M2_mpyu_nac_hl_s1,                 // llvm.hexagon.M2.mpyu.nac.hl.s1
-    hexagon_M2_mpyu_nac_lh_s0,                 // llvm.hexagon.M2.mpyu.nac.lh.s0
-    hexagon_M2_mpyu_nac_lh_s1,                 // llvm.hexagon.M2.mpyu.nac.lh.s1
-    hexagon_M2_mpyu_nac_ll_s0,                 // llvm.hexagon.M2.mpyu.nac.ll.s0
-    hexagon_M2_mpyu_nac_ll_s1,                 // llvm.hexagon.M2.mpyu.nac.ll.s1
-    hexagon_M2_mpyu_up,                        // llvm.hexagon.M2.mpyu.up
-    hexagon_M2_mpyud_acc_hh_s0,                // llvm.hexagon.M2.mpyud.acc.hh.s0
-    hexagon_M2_mpyud_acc_hh_s1,                // llvm.hexagon.M2.mpyud.acc.hh.s1
-    hexagon_M2_mpyud_acc_hl_s0,                // llvm.hexagon.M2.mpyud.acc.hl.s0
-    hexagon_M2_mpyud_acc_hl_s1,                // llvm.hexagon.M2.mpyud.acc.hl.s1
-    hexagon_M2_mpyud_acc_lh_s0,                // llvm.hexagon.M2.mpyud.acc.lh.s0
-    hexagon_M2_mpyud_acc_lh_s1,                // llvm.hexagon.M2.mpyud.acc.lh.s1
-    hexagon_M2_mpyud_acc_ll_s0,                // llvm.hexagon.M2.mpyud.acc.ll.s0
-    hexagon_M2_mpyud_acc_ll_s1,                // llvm.hexagon.M2.mpyud.acc.ll.s1
-    hexagon_M2_mpyud_hh_s0,                    // llvm.hexagon.M2.mpyud.hh.s0
-    hexagon_M2_mpyud_hh_s1,                    // llvm.hexagon.M2.mpyud.hh.s1
-    hexagon_M2_mpyud_hl_s0,                    // llvm.hexagon.M2.mpyud.hl.s0
-    hexagon_M2_mpyud_hl_s1,                    // llvm.hexagon.M2.mpyud.hl.s1
-    hexagon_M2_mpyud_lh_s0,                    // llvm.hexagon.M2.mpyud.lh.s0
-    hexagon_M2_mpyud_lh_s1,                    // llvm.hexagon.M2.mpyud.lh.s1
-    hexagon_M2_mpyud_ll_s0,                    // llvm.hexagon.M2.mpyud.ll.s0
-    hexagon_M2_mpyud_ll_s1,                    // llvm.hexagon.M2.mpyud.ll.s1
-    hexagon_M2_mpyud_nac_hh_s0,                // llvm.hexagon.M2.mpyud.nac.hh.s0
-    hexagon_M2_mpyud_nac_hh_s1,                // llvm.hexagon.M2.mpyud.nac.hh.s1
-    hexagon_M2_mpyud_nac_hl_s0,                // llvm.hexagon.M2.mpyud.nac.hl.s0
-    hexagon_M2_mpyud_nac_hl_s1,                // llvm.hexagon.M2.mpyud.nac.hl.s1
-    hexagon_M2_mpyud_nac_lh_s0,                // llvm.hexagon.M2.mpyud.nac.lh.s0
-    hexagon_M2_mpyud_nac_lh_s1,                // llvm.hexagon.M2.mpyud.nac.lh.s1
-    hexagon_M2_mpyud_nac_ll_s0,                // llvm.hexagon.M2.mpyud.nac.ll.s0
-    hexagon_M2_mpyud_nac_ll_s1,                // llvm.hexagon.M2.mpyud.nac.ll.s1
-    hexagon_M2_mpyui,                          // llvm.hexagon.M2.mpyui
-    hexagon_M2_nacci,                          // llvm.hexagon.M2.nacci
-    hexagon_M2_naccii,                         // llvm.hexagon.M2.naccii
-    hexagon_M2_subacc,                         // llvm.hexagon.M2.subacc
-    hexagon_M2_vabsdiffh,                      // llvm.hexagon.M2.vabsdiffh
-    hexagon_M2_vabsdiffw,                      // llvm.hexagon.M2.vabsdiffw
-    hexagon_M2_vcmac_s0_sat_i,                 // llvm.hexagon.M2.vcmac.s0.sat.i
-    hexagon_M2_vcmac_s0_sat_r,                 // llvm.hexagon.M2.vcmac.s0.sat.r
-    hexagon_M2_vcmpy_s0_sat_i,                 // llvm.hexagon.M2.vcmpy.s0.sat.i
-    hexagon_M2_vcmpy_s0_sat_r,                 // llvm.hexagon.M2.vcmpy.s0.sat.r
-    hexagon_M2_vcmpy_s1_sat_i,                 // llvm.hexagon.M2.vcmpy.s1.sat.i
-    hexagon_M2_vcmpy_s1_sat_r,                 // llvm.hexagon.M2.vcmpy.s1.sat.r
-    hexagon_M2_vdmacs_s0,                      // llvm.hexagon.M2.vdmacs.s0
-    hexagon_M2_vdmacs_s1,                      // llvm.hexagon.M2.vdmacs.s1
-    hexagon_M2_vdmpyrs_s0,                     // llvm.hexagon.M2.vdmpyrs.s0
-    hexagon_M2_vdmpyrs_s1,                     // llvm.hexagon.M2.vdmpyrs.s1
-    hexagon_M2_vdmpys_s0,                      // llvm.hexagon.M2.vdmpys.s0
-    hexagon_M2_vdmpys_s1,                      // llvm.hexagon.M2.vdmpys.s1
-    hexagon_M2_vmac2,                          // llvm.hexagon.M2.vmac2
-    hexagon_M2_vmac2es,                        // llvm.hexagon.M2.vmac2es
-    hexagon_M2_vmac2es_s0,                     // llvm.hexagon.M2.vmac2es.s0
-    hexagon_M2_vmac2es_s1,                     // llvm.hexagon.M2.vmac2es.s1
-    hexagon_M2_vmac2s_s0,                      // llvm.hexagon.M2.vmac2s.s0
-    hexagon_M2_vmac2s_s1,                      // llvm.hexagon.M2.vmac2s.s1
-    hexagon_M2_vmac2su_s0,                     // llvm.hexagon.M2.vmac2su.s0
-    hexagon_M2_vmac2su_s1,                     // llvm.hexagon.M2.vmac2su.s1
-    hexagon_M2_vmpy2es_s0,                     // llvm.hexagon.M2.vmpy2es.s0
-    hexagon_M2_vmpy2es_s1,                     // llvm.hexagon.M2.vmpy2es.s1
-    hexagon_M2_vmpy2s_s0,                      // llvm.hexagon.M2.vmpy2s.s0
-    hexagon_M2_vmpy2s_s0pack,                  // llvm.hexagon.M2.vmpy2s.s0pack
-    hexagon_M2_vmpy2s_s1,                      // llvm.hexagon.M2.vmpy2s.s1
-    hexagon_M2_vmpy2s_s1pack,                  // llvm.hexagon.M2.vmpy2s.s1pack
-    hexagon_M2_vmpy2su_s0,                     // llvm.hexagon.M2.vmpy2su.s0
-    hexagon_M2_vmpy2su_s1,                     // llvm.hexagon.M2.vmpy2su.s1
-    hexagon_M2_vraddh,                         // llvm.hexagon.M2.vraddh
-    hexagon_M2_vradduh,                        // llvm.hexagon.M2.vradduh
-    hexagon_M2_vrcmaci_s0,                     // llvm.hexagon.M2.vrcmaci.s0
-    hexagon_M2_vrcmaci_s0c,                    // llvm.hexagon.M2.vrcmaci.s0c
-    hexagon_M2_vrcmacr_s0,                     // llvm.hexagon.M2.vrcmacr.s0
-    hexagon_M2_vrcmacr_s0c,                    // llvm.hexagon.M2.vrcmacr.s0c
-    hexagon_M2_vrcmpyi_s0,                     // llvm.hexagon.M2.vrcmpyi.s0
-    hexagon_M2_vrcmpyi_s0c,                    // llvm.hexagon.M2.vrcmpyi.s0c
-    hexagon_M2_vrcmpyr_s0,                     // llvm.hexagon.M2.vrcmpyr.s0
-    hexagon_M2_vrcmpyr_s0c,                    // llvm.hexagon.M2.vrcmpyr.s0c
-    hexagon_M2_vrcmpys_acc_s1,                 // llvm.hexagon.M2.vrcmpys.acc.s1
-    hexagon_M2_vrcmpys_s1,                     // llvm.hexagon.M2.vrcmpys.s1
-    hexagon_M2_vrcmpys_s1rp,                   // llvm.hexagon.M2.vrcmpys.s1rp
-    hexagon_M2_vrmac_s0,                       // llvm.hexagon.M2.vrmac.s0
-    hexagon_M2_vrmpy_s0,                       // llvm.hexagon.M2.vrmpy.s0
-    hexagon_M2_xor_xacc,                       // llvm.hexagon.M2.xor.xacc
-    hexagon_M4_and_and,                        // llvm.hexagon.M4.and.and
-    hexagon_M4_and_andn,                       // llvm.hexagon.M4.and.andn
-    hexagon_M4_and_or,                         // llvm.hexagon.M4.and.or
-    hexagon_M4_and_xor,                        // llvm.hexagon.M4.and.xor
-    hexagon_M4_cmpyi_wh,                       // llvm.hexagon.M4.cmpyi.wh
-    hexagon_M4_cmpyi_whc,                      // llvm.hexagon.M4.cmpyi.whc
-    hexagon_M4_cmpyr_wh,                       // llvm.hexagon.M4.cmpyr.wh
-    hexagon_M4_cmpyr_whc,                      // llvm.hexagon.M4.cmpyr.whc
-    hexagon_M4_mac_up_s1_sat,                  // llvm.hexagon.M4.mac.up.s1.sat
-    hexagon_M4_mpyri_addi,                     // llvm.hexagon.M4.mpyri.addi
-    hexagon_M4_mpyri_addr,                     // llvm.hexagon.M4.mpyri.addr
-    hexagon_M4_mpyri_addr_u2,                  // llvm.hexagon.M4.mpyri.addr.u2
-    hexagon_M4_mpyrr_addi,                     // llvm.hexagon.M4.mpyrr.addi
-    hexagon_M4_mpyrr_addr,                     // llvm.hexagon.M4.mpyrr.addr
-    hexagon_M4_nac_up_s1_sat,                  // llvm.hexagon.M4.nac.up.s1.sat
-    hexagon_M4_or_and,                         // llvm.hexagon.M4.or.and
-    hexagon_M4_or_andn,                        // llvm.hexagon.M4.or.andn
-    hexagon_M4_or_or,                          // llvm.hexagon.M4.or.or
-    hexagon_M4_or_xor,                         // llvm.hexagon.M4.or.xor
-    hexagon_M4_pmpyw,                          // llvm.hexagon.M4.pmpyw
-    hexagon_M4_pmpyw_acc,                      // llvm.hexagon.M4.pmpyw.acc
-    hexagon_M4_vpmpyh,                         // llvm.hexagon.M4.vpmpyh
-    hexagon_M4_vpmpyh_acc,                     // llvm.hexagon.M4.vpmpyh.acc
-    hexagon_M4_vrmpyeh_acc_s0,                 // llvm.hexagon.M4.vrmpyeh.acc.s0
-    hexagon_M4_vrmpyeh_acc_s1,                 // llvm.hexagon.M4.vrmpyeh.acc.s1
-    hexagon_M4_vrmpyeh_s0,                     // llvm.hexagon.M4.vrmpyeh.s0
-    hexagon_M4_vrmpyeh_s1,                     // llvm.hexagon.M4.vrmpyeh.s1
-    hexagon_M4_vrmpyoh_acc_s0,                 // llvm.hexagon.M4.vrmpyoh.acc.s0
-    hexagon_M4_vrmpyoh_acc_s1,                 // llvm.hexagon.M4.vrmpyoh.acc.s1
-    hexagon_M4_vrmpyoh_s0,                     // llvm.hexagon.M4.vrmpyoh.s0
-    hexagon_M4_vrmpyoh_s1,                     // llvm.hexagon.M4.vrmpyoh.s1
-    hexagon_M4_xor_and,                        // llvm.hexagon.M4.xor.and
-    hexagon_M4_xor_andn,                       // llvm.hexagon.M4.xor.andn
-    hexagon_M4_xor_or,                         // llvm.hexagon.M4.xor.or
-    hexagon_M4_xor_xacc,                       // llvm.hexagon.M4.xor.xacc
-    hexagon_M5_vdmacbsu,                       // llvm.hexagon.M5.vdmacbsu
-    hexagon_M5_vdmpybsu,                       // llvm.hexagon.M5.vdmpybsu
-    hexagon_M5_vmacbsu,                        // llvm.hexagon.M5.vmacbsu
-    hexagon_M5_vmacbuu,                        // llvm.hexagon.M5.vmacbuu
-    hexagon_M5_vmpybsu,                        // llvm.hexagon.M5.vmpybsu
-    hexagon_M5_vmpybuu,                        // llvm.hexagon.M5.vmpybuu
-    hexagon_M5_vrmacbsu,                       // llvm.hexagon.M5.vrmacbsu
-    hexagon_M5_vrmacbuu,                       // llvm.hexagon.M5.vrmacbuu
-    hexagon_M5_vrmpybsu,                       // llvm.hexagon.M5.vrmpybsu
-    hexagon_M5_vrmpybuu,                       // llvm.hexagon.M5.vrmpybuu
-    hexagon_M6_vabsdiffb,                      // llvm.hexagon.M6.vabsdiffb
-    hexagon_M6_vabsdiffub,                     // llvm.hexagon.M6.vabsdiffub
-    hexagon_S2_addasl_rrri,                    // llvm.hexagon.S2.addasl.rrri
-    hexagon_S2_asl_i_p,                        // llvm.hexagon.S2.asl.i.p
-    hexagon_S2_asl_i_p_acc,                    // llvm.hexagon.S2.asl.i.p.acc
-    hexagon_S2_asl_i_p_and,                    // llvm.hexagon.S2.asl.i.p.and
-    hexagon_S2_asl_i_p_nac,                    // llvm.hexagon.S2.asl.i.p.nac
-    hexagon_S2_asl_i_p_or,                     // llvm.hexagon.S2.asl.i.p.or
-    hexagon_S2_asl_i_p_xacc,                   // llvm.hexagon.S2.asl.i.p.xacc
-    hexagon_S2_asl_i_r,                        // llvm.hexagon.S2.asl.i.r
-    hexagon_S2_asl_i_r_acc,                    // llvm.hexagon.S2.asl.i.r.acc
-    hexagon_S2_asl_i_r_and,                    // llvm.hexagon.S2.asl.i.r.and
-    hexagon_S2_asl_i_r_nac,                    // llvm.hexagon.S2.asl.i.r.nac
-    hexagon_S2_asl_i_r_or,                     // llvm.hexagon.S2.asl.i.r.or
-    hexagon_S2_asl_i_r_sat,                    // llvm.hexagon.S2.asl.i.r.sat
-    hexagon_S2_asl_i_r_xacc,                   // llvm.hexagon.S2.asl.i.r.xacc
-    hexagon_S2_asl_i_vh,                       // llvm.hexagon.S2.asl.i.vh
-    hexagon_S2_asl_i_vw,                       // llvm.hexagon.S2.asl.i.vw
-    hexagon_S2_asl_r_p,                        // llvm.hexagon.S2.asl.r.p
-    hexagon_S2_asl_r_p_acc,                    // llvm.hexagon.S2.asl.r.p.acc
-    hexagon_S2_asl_r_p_and,                    // llvm.hexagon.S2.asl.r.p.and
-    hexagon_S2_asl_r_p_nac,                    // llvm.hexagon.S2.asl.r.p.nac
-    hexagon_S2_asl_r_p_or,                     // llvm.hexagon.S2.asl.r.p.or
-    hexagon_S2_asl_r_p_xor,                    // llvm.hexagon.S2.asl.r.p.xor
-    hexagon_S2_asl_r_r,                        // llvm.hexagon.S2.asl.r.r
-    hexagon_S2_asl_r_r_acc,                    // llvm.hexagon.S2.asl.r.r.acc
-    hexagon_S2_asl_r_r_and,                    // llvm.hexagon.S2.asl.r.r.and
-    hexagon_S2_asl_r_r_nac,                    // llvm.hexagon.S2.asl.r.r.nac
-    hexagon_S2_asl_r_r_or,                     // llvm.hexagon.S2.asl.r.r.or
-    hexagon_S2_asl_r_r_sat,                    // llvm.hexagon.S2.asl.r.r.sat
-    hexagon_S2_asl_r_vh,                       // llvm.hexagon.S2.asl.r.vh
-    hexagon_S2_asl_r_vw,                       // llvm.hexagon.S2.asl.r.vw
-    hexagon_S2_asr_i_p,                        // llvm.hexagon.S2.asr.i.p
-    hexagon_S2_asr_i_p_acc,                    // llvm.hexagon.S2.asr.i.p.acc
-    hexagon_S2_asr_i_p_and,                    // llvm.hexagon.S2.asr.i.p.and
-    hexagon_S2_asr_i_p_nac,                    // llvm.hexagon.S2.asr.i.p.nac
-    hexagon_S2_asr_i_p_or,                     // llvm.hexagon.S2.asr.i.p.or
-    hexagon_S2_asr_i_p_rnd,                    // llvm.hexagon.S2.asr.i.p.rnd
-    hexagon_S2_asr_i_p_rnd_goodsyntax,         // llvm.hexagon.S2.asr.i.p.rnd.goodsyntax
-    hexagon_S2_asr_i_r,                        // llvm.hexagon.S2.asr.i.r
-    hexagon_S2_asr_i_r_acc,                    // llvm.hexagon.S2.asr.i.r.acc
-    hexagon_S2_asr_i_r_and,                    // llvm.hexagon.S2.asr.i.r.and
-    hexagon_S2_asr_i_r_nac,                    // llvm.hexagon.S2.asr.i.r.nac
-    hexagon_S2_asr_i_r_or,                     // llvm.hexagon.S2.asr.i.r.or
-    hexagon_S2_asr_i_r_rnd,                    // llvm.hexagon.S2.asr.i.r.rnd
-    hexagon_S2_asr_i_r_rnd_goodsyntax,         // llvm.hexagon.S2.asr.i.r.rnd.goodsyntax
-    hexagon_S2_asr_i_svw_trun,                 // llvm.hexagon.S2.asr.i.svw.trun
-    hexagon_S2_asr_i_vh,                       // llvm.hexagon.S2.asr.i.vh
-    hexagon_S2_asr_i_vw,                       // llvm.hexagon.S2.asr.i.vw
-    hexagon_S2_asr_r_p,                        // llvm.hexagon.S2.asr.r.p
-    hexagon_S2_asr_r_p_acc,                    // llvm.hexagon.S2.asr.r.p.acc
-    hexagon_S2_asr_r_p_and,                    // llvm.hexagon.S2.asr.r.p.and
-    hexagon_S2_asr_r_p_nac,                    // llvm.hexagon.S2.asr.r.p.nac
-    hexagon_S2_asr_r_p_or,                     // llvm.hexagon.S2.asr.r.p.or
-    hexagon_S2_asr_r_p_xor,                    // llvm.hexagon.S2.asr.r.p.xor
-    hexagon_S2_asr_r_r,                        // llvm.hexagon.S2.asr.r.r
-    hexagon_S2_asr_r_r_acc,                    // llvm.hexagon.S2.asr.r.r.acc
-    hexagon_S2_asr_r_r_and,                    // llvm.hexagon.S2.asr.r.r.and
-    hexagon_S2_asr_r_r_nac,                    // llvm.hexagon.S2.asr.r.r.nac
-    hexagon_S2_asr_r_r_or,                     // llvm.hexagon.S2.asr.r.r.or
-    hexagon_S2_asr_r_r_sat,                    // llvm.hexagon.S2.asr.r.r.sat
-    hexagon_S2_asr_r_svw_trun,                 // llvm.hexagon.S2.asr.r.svw.trun
-    hexagon_S2_asr_r_vh,                       // llvm.hexagon.S2.asr.r.vh
-    hexagon_S2_asr_r_vw,                       // llvm.hexagon.S2.asr.r.vw
-    hexagon_S2_brev,                           // llvm.hexagon.S2.brev
-    hexagon_S2_brevp,                          // llvm.hexagon.S2.brevp
-    hexagon_S2_cl0,                            // llvm.hexagon.S2.cl0
-    hexagon_S2_cl0p,                           // llvm.hexagon.S2.cl0p
-    hexagon_S2_cl1,                            // llvm.hexagon.S2.cl1
-    hexagon_S2_cl1p,                           // llvm.hexagon.S2.cl1p
-    hexagon_S2_clb,                            // llvm.hexagon.S2.clb
-    hexagon_S2_clbnorm,                        // llvm.hexagon.S2.clbnorm
-    hexagon_S2_clbp,                           // llvm.hexagon.S2.clbp
-    hexagon_S2_clrbit_i,                       // llvm.hexagon.S2.clrbit.i
-    hexagon_S2_clrbit_r,                       // llvm.hexagon.S2.clrbit.r
-    hexagon_S2_ct0,                            // llvm.hexagon.S2.ct0
-    hexagon_S2_ct0p,                           // llvm.hexagon.S2.ct0p
-    hexagon_S2_ct1,                            // llvm.hexagon.S2.ct1
-    hexagon_S2_ct1p,                           // llvm.hexagon.S2.ct1p
-    hexagon_S2_deinterleave,                   // llvm.hexagon.S2.deinterleave
-    hexagon_S2_extractu,                       // llvm.hexagon.S2.extractu
-    hexagon_S2_extractu_rp,                    // llvm.hexagon.S2.extractu.rp
-    hexagon_S2_extractup,                      // llvm.hexagon.S2.extractup
-    hexagon_S2_extractup_rp,                   // llvm.hexagon.S2.extractup.rp
-    hexagon_S2_insert,                         // llvm.hexagon.S2.insert
-    hexagon_S2_insert_rp,                      // llvm.hexagon.S2.insert.rp
-    hexagon_S2_insertp,                        // llvm.hexagon.S2.insertp
-    hexagon_S2_insertp_rp,                     // llvm.hexagon.S2.insertp.rp
-    hexagon_S2_interleave,                     // llvm.hexagon.S2.interleave
-    hexagon_S2_lfsp,                           // llvm.hexagon.S2.lfsp
-    hexagon_S2_lsl_r_p,                        // llvm.hexagon.S2.lsl.r.p
-    hexagon_S2_lsl_r_p_acc,                    // llvm.hexagon.S2.lsl.r.p.acc
-    hexagon_S2_lsl_r_p_and,                    // llvm.hexagon.S2.lsl.r.p.and
-    hexagon_S2_lsl_r_p_nac,                    // llvm.hexagon.S2.lsl.r.p.nac
-    hexagon_S2_lsl_r_p_or,                     // llvm.hexagon.S2.lsl.r.p.or
-    hexagon_S2_lsl_r_p_xor,                    // llvm.hexagon.S2.lsl.r.p.xor
-    hexagon_S2_lsl_r_r,                        // llvm.hexagon.S2.lsl.r.r
-    hexagon_S2_lsl_r_r_acc,                    // llvm.hexagon.S2.lsl.r.r.acc
-    hexagon_S2_lsl_r_r_and,                    // llvm.hexagon.S2.lsl.r.r.and
-    hexagon_S2_lsl_r_r_nac,                    // llvm.hexagon.S2.lsl.r.r.nac
-    hexagon_S2_lsl_r_r_or,                     // llvm.hexagon.S2.lsl.r.r.or
-    hexagon_S2_lsl_r_vh,                       // llvm.hexagon.S2.lsl.r.vh
-    hexagon_S2_lsl_r_vw,                       // llvm.hexagon.S2.lsl.r.vw
-    hexagon_S2_lsr_i_p,                        // llvm.hexagon.S2.lsr.i.p
-    hexagon_S2_lsr_i_p_acc,                    // llvm.hexagon.S2.lsr.i.p.acc
-    hexagon_S2_lsr_i_p_and,                    // llvm.hexagon.S2.lsr.i.p.and
-    hexagon_S2_lsr_i_p_nac,                    // llvm.hexagon.S2.lsr.i.p.nac
-    hexagon_S2_lsr_i_p_or,                     // llvm.hexagon.S2.lsr.i.p.or
-    hexagon_S2_lsr_i_p_xacc,                   // llvm.hexagon.S2.lsr.i.p.xacc
-    hexagon_S2_lsr_i_r,                        // llvm.hexagon.S2.lsr.i.r
-    hexagon_S2_lsr_i_r_acc,                    // llvm.hexagon.S2.lsr.i.r.acc
-    hexagon_S2_lsr_i_r_and,                    // llvm.hexagon.S2.lsr.i.r.and
-    hexagon_S2_lsr_i_r_nac,                    // llvm.hexagon.S2.lsr.i.r.nac
-    hexagon_S2_lsr_i_r_or,                     // llvm.hexagon.S2.lsr.i.r.or
-    hexagon_S2_lsr_i_r_xacc,                   // llvm.hexagon.S2.lsr.i.r.xacc
-    hexagon_S2_lsr_i_vh,                       // llvm.hexagon.S2.lsr.i.vh
-    hexagon_S2_lsr_i_vw,                       // llvm.hexagon.S2.lsr.i.vw
-    hexagon_S2_lsr_r_p,                        // llvm.hexagon.S2.lsr.r.p
-    hexagon_S2_lsr_r_p_acc,                    // llvm.hexagon.S2.lsr.r.p.acc
-    hexagon_S2_lsr_r_p_and,                    // llvm.hexagon.S2.lsr.r.p.and
-    hexagon_S2_lsr_r_p_nac,                    // llvm.hexagon.S2.lsr.r.p.nac
-    hexagon_S2_lsr_r_p_or,                     // llvm.hexagon.S2.lsr.r.p.or
-    hexagon_S2_lsr_r_p_xor,                    // llvm.hexagon.S2.lsr.r.p.xor
-    hexagon_S2_lsr_r_r,                        // llvm.hexagon.S2.lsr.r.r
-    hexagon_S2_lsr_r_r_acc,                    // llvm.hexagon.S2.lsr.r.r.acc
-    hexagon_S2_lsr_r_r_and,                    // llvm.hexagon.S2.lsr.r.r.and
-    hexagon_S2_lsr_r_r_nac,                    // llvm.hexagon.S2.lsr.r.r.nac
-    hexagon_S2_lsr_r_r_or,                     // llvm.hexagon.S2.lsr.r.r.or
-    hexagon_S2_lsr_r_vh,                       // llvm.hexagon.S2.lsr.r.vh
-    hexagon_S2_lsr_r_vw,                       // llvm.hexagon.S2.lsr.r.vw
-    hexagon_S2_mask,                           // llvm.hexagon.S2.mask
-    hexagon_S2_packhl,                         // llvm.hexagon.S2.packhl
-    hexagon_S2_parityp,                        // llvm.hexagon.S2.parityp
-    hexagon_S2_setbit_i,                       // llvm.hexagon.S2.setbit.i
-    hexagon_S2_setbit_r,                       // llvm.hexagon.S2.setbit.r
-    hexagon_S2_shuffeb,                        // llvm.hexagon.S2.shuffeb
-    hexagon_S2_shuffeh,                        // llvm.hexagon.S2.shuffeh
-    hexagon_S2_shuffob,                        // llvm.hexagon.S2.shuffob
-    hexagon_S2_shuffoh,                        // llvm.hexagon.S2.shuffoh
-    hexagon_S2_storerb_pbr,                    // llvm.hexagon.S2.storerb.pbr
-    hexagon_S2_storerb_pci,                    // llvm.hexagon.S2.storerb.pci
-    hexagon_S2_storerb_pcr,                    // llvm.hexagon.S2.storerb.pcr
-    hexagon_S2_storerd_pbr,                    // llvm.hexagon.S2.storerd.pbr
-    hexagon_S2_storerd_pci,                    // llvm.hexagon.S2.storerd.pci
-    hexagon_S2_storerd_pcr,                    // llvm.hexagon.S2.storerd.pcr
-    hexagon_S2_storerf_pbr,                    // llvm.hexagon.S2.storerf.pbr
-    hexagon_S2_storerf_pci,                    // llvm.hexagon.S2.storerf.pci
-    hexagon_S2_storerf_pcr,                    // llvm.hexagon.S2.storerf.pcr
-    hexagon_S2_storerh_pbr,                    // llvm.hexagon.S2.storerh.pbr
-    hexagon_S2_storerh_pci,                    // llvm.hexagon.S2.storerh.pci
-    hexagon_S2_storerh_pcr,                    // llvm.hexagon.S2.storerh.pcr
-    hexagon_S2_storeri_pbr,                    // llvm.hexagon.S2.storeri.pbr
-    hexagon_S2_storeri_pci,                    // llvm.hexagon.S2.storeri.pci
-    hexagon_S2_storeri_pcr,                    // llvm.hexagon.S2.storeri.pcr
-    hexagon_S2_storew_locked,                  // llvm.hexagon.S2.storew.locked
-    hexagon_S2_svsathb,                        // llvm.hexagon.S2.svsathb
-    hexagon_S2_svsathub,                       // llvm.hexagon.S2.svsathub
-    hexagon_S2_tableidxb_goodsyntax,           // llvm.hexagon.S2.tableidxb.goodsyntax
-    hexagon_S2_tableidxd_goodsyntax,           // llvm.hexagon.S2.tableidxd.goodsyntax
-    hexagon_S2_tableidxh_goodsyntax,           // llvm.hexagon.S2.tableidxh.goodsyntax
-    hexagon_S2_tableidxw_goodsyntax,           // llvm.hexagon.S2.tableidxw.goodsyntax
-    hexagon_S2_togglebit_i,                    // llvm.hexagon.S2.togglebit.i
-    hexagon_S2_togglebit_r,                    // llvm.hexagon.S2.togglebit.r
-    hexagon_S2_tstbit_i,                       // llvm.hexagon.S2.tstbit.i
-    hexagon_S2_tstbit_r,                       // llvm.hexagon.S2.tstbit.r
-    hexagon_S2_valignib,                       // llvm.hexagon.S2.valignib
-    hexagon_S2_valignrb,                       // llvm.hexagon.S2.valignrb
-    hexagon_S2_vcnegh,                         // llvm.hexagon.S2.vcnegh
-    hexagon_S2_vcrotate,                       // llvm.hexagon.S2.vcrotate
-    hexagon_S2_vrcnegh,                        // llvm.hexagon.S2.vrcnegh
-    hexagon_S2_vrndpackwh,                     // llvm.hexagon.S2.vrndpackwh
-    hexagon_S2_vrndpackwhs,                    // llvm.hexagon.S2.vrndpackwhs
-    hexagon_S2_vsathb,                         // llvm.hexagon.S2.vsathb
-    hexagon_S2_vsathb_nopack,                  // llvm.hexagon.S2.vsathb.nopack
-    hexagon_S2_vsathub,                        // llvm.hexagon.S2.vsathub
-    hexagon_S2_vsathub_nopack,                 // llvm.hexagon.S2.vsathub.nopack
-    hexagon_S2_vsatwh,                         // llvm.hexagon.S2.vsatwh
-    hexagon_S2_vsatwh_nopack,                  // llvm.hexagon.S2.vsatwh.nopack
-    hexagon_S2_vsatwuh,                        // llvm.hexagon.S2.vsatwuh
-    hexagon_S2_vsatwuh_nopack,                 // llvm.hexagon.S2.vsatwuh.nopack
-    hexagon_S2_vsplatrb,                       // llvm.hexagon.S2.vsplatrb
-    hexagon_S2_vsplatrh,                       // llvm.hexagon.S2.vsplatrh
-    hexagon_S2_vspliceib,                      // llvm.hexagon.S2.vspliceib
-    hexagon_S2_vsplicerb,                      // llvm.hexagon.S2.vsplicerb
-    hexagon_S2_vsxtbh,                         // llvm.hexagon.S2.vsxtbh
-    hexagon_S2_vsxthw,                         // llvm.hexagon.S2.vsxthw
-    hexagon_S2_vtrunehb,                       // llvm.hexagon.S2.vtrunehb
-    hexagon_S2_vtrunewh,                       // llvm.hexagon.S2.vtrunewh
-    hexagon_S2_vtrunohb,                       // llvm.hexagon.S2.vtrunohb
-    hexagon_S2_vtrunowh,                       // llvm.hexagon.S2.vtrunowh
-    hexagon_S2_vzxtbh,                         // llvm.hexagon.S2.vzxtbh
-    hexagon_S2_vzxthw,                         // llvm.hexagon.S2.vzxthw
-    hexagon_S4_addaddi,                        // llvm.hexagon.S4.addaddi
-    hexagon_S4_addi_asl_ri,                    // llvm.hexagon.S4.addi.asl.ri
-    hexagon_S4_addi_lsr_ri,                    // llvm.hexagon.S4.addi.lsr.ri
-    hexagon_S4_andi_asl_ri,                    // llvm.hexagon.S4.andi.asl.ri
-    hexagon_S4_andi_lsr_ri,                    // llvm.hexagon.S4.andi.lsr.ri
-    hexagon_S4_clbaddi,                        // llvm.hexagon.S4.clbaddi
-    hexagon_S4_clbpaddi,                       // llvm.hexagon.S4.clbpaddi
-    hexagon_S4_clbpnorm,                       // llvm.hexagon.S4.clbpnorm
-    hexagon_S4_extract,                        // llvm.hexagon.S4.extract
-    hexagon_S4_extract_rp,                     // llvm.hexagon.S4.extract.rp
-    hexagon_S4_extractp,                       // llvm.hexagon.S4.extractp
-    hexagon_S4_extractp_rp,                    // llvm.hexagon.S4.extractp.rp
-    hexagon_S4_lsli,                           // llvm.hexagon.S4.lsli
-    hexagon_S4_ntstbit_i,                      // llvm.hexagon.S4.ntstbit.i
-    hexagon_S4_ntstbit_r,                      // llvm.hexagon.S4.ntstbit.r
-    hexagon_S4_or_andi,                        // llvm.hexagon.S4.or.andi
-    hexagon_S4_or_andix,                       // llvm.hexagon.S4.or.andix
-    hexagon_S4_or_ori,                         // llvm.hexagon.S4.or.ori
-    hexagon_S4_ori_asl_ri,                     // llvm.hexagon.S4.ori.asl.ri
-    hexagon_S4_ori_lsr_ri,                     // llvm.hexagon.S4.ori.lsr.ri
-    hexagon_S4_parity,                         // llvm.hexagon.S4.parity
-    hexagon_S4_stored_locked,                  // llvm.hexagon.S4.stored.locked
-    hexagon_S4_subaddi,                        // llvm.hexagon.S4.subaddi
-    hexagon_S4_subi_asl_ri,                    // llvm.hexagon.S4.subi.asl.ri
-    hexagon_S4_subi_lsr_ri,                    // llvm.hexagon.S4.subi.lsr.ri
-    hexagon_S4_vrcrotate,                      // llvm.hexagon.S4.vrcrotate
-    hexagon_S4_vrcrotate_acc,                  // llvm.hexagon.S4.vrcrotate.acc
-    hexagon_S4_vxaddsubh,                      // llvm.hexagon.S4.vxaddsubh
-    hexagon_S4_vxaddsubhr,                     // llvm.hexagon.S4.vxaddsubhr
-    hexagon_S4_vxaddsubw,                      // llvm.hexagon.S4.vxaddsubw
-    hexagon_S4_vxsubaddh,                      // llvm.hexagon.S4.vxsubaddh
-    hexagon_S4_vxsubaddhr,                     // llvm.hexagon.S4.vxsubaddhr
-    hexagon_S4_vxsubaddw,                      // llvm.hexagon.S4.vxsubaddw
-    hexagon_S5_asrhub_rnd_sat_goodsyntax,      // llvm.hexagon.S5.asrhub.rnd.sat.goodsyntax
-    hexagon_S5_asrhub_sat,                     // llvm.hexagon.S5.asrhub.sat
-    hexagon_S5_popcountp,                      // llvm.hexagon.S5.popcountp
-    hexagon_S5_vasrhrnd_goodsyntax,            // llvm.hexagon.S5.vasrhrnd.goodsyntax
-    hexagon_S6_rol_i_p,                        // llvm.hexagon.S6.rol.i.p
-    hexagon_S6_rol_i_p_acc,                    // llvm.hexagon.S6.rol.i.p.acc
-    hexagon_S6_rol_i_p_and,                    // llvm.hexagon.S6.rol.i.p.and
-    hexagon_S6_rol_i_p_nac,                    // llvm.hexagon.S6.rol.i.p.nac
-    hexagon_S6_rol_i_p_or,                     // llvm.hexagon.S6.rol.i.p.or
-    hexagon_S6_rol_i_p_xacc,                   // llvm.hexagon.S6.rol.i.p.xacc
-    hexagon_S6_rol_i_r,                        // llvm.hexagon.S6.rol.i.r
-    hexagon_S6_rol_i_r_acc,                    // llvm.hexagon.S6.rol.i.r.acc
-    hexagon_S6_rol_i_r_and,                    // llvm.hexagon.S6.rol.i.r.and
-    hexagon_S6_rol_i_r_nac,                    // llvm.hexagon.S6.rol.i.r.nac
-    hexagon_S6_rol_i_r_or,                     // llvm.hexagon.S6.rol.i.r.or
-    hexagon_S6_rol_i_r_xacc,                   // llvm.hexagon.S6.rol.i.r.xacc
-    hexagon_S6_vsplatrbp,                      // llvm.hexagon.S6.vsplatrbp
-    hexagon_S6_vtrunehb_ppp,                   // llvm.hexagon.S6.vtrunehb.ppp
-    hexagon_S6_vtrunohb_ppp,                   // llvm.hexagon.S6.vtrunohb.ppp
-    hexagon_V6_extractw,                       // llvm.hexagon.V6.extractw
-    hexagon_V6_extractw_128B,                  // llvm.hexagon.V6.extractw.128B
-    hexagon_V6_hi,                             // llvm.hexagon.V6.hi
-    hexagon_V6_hi_128B,                        // llvm.hexagon.V6.hi.128B
-    hexagon_V6_ld0,                            // llvm.hexagon.V6.ld0
-    hexagon_V6_ld0_128B,                       // llvm.hexagon.V6.ld0.128B
-    hexagon_V6_ldcnp0,                         // llvm.hexagon.V6.ldcnp0
-    hexagon_V6_ldcnp0_128B,                    // llvm.hexagon.V6.ldcnp0.128B
-    hexagon_V6_ldcnpnt0,                       // llvm.hexagon.V6.ldcnpnt0
-    hexagon_V6_ldcnpnt0_128B,                  // llvm.hexagon.V6.ldcnpnt0.128B
-    hexagon_V6_ldcp0,                          // llvm.hexagon.V6.ldcp0
-    hexagon_V6_ldcp0_128B,                     // llvm.hexagon.V6.ldcp0.128B
-    hexagon_V6_ldcpnt0,                        // llvm.hexagon.V6.ldcpnt0
-    hexagon_V6_ldcpnt0_128B,                   // llvm.hexagon.V6.ldcpnt0.128B
-    hexagon_V6_ldnp0,                          // llvm.hexagon.V6.ldnp0
-    hexagon_V6_ldnp0_128B,                     // llvm.hexagon.V6.ldnp0.128B
-    hexagon_V6_ldnpnt0,                        // llvm.hexagon.V6.ldnpnt0
-    hexagon_V6_ldnpnt0_128B,                   // llvm.hexagon.V6.ldnpnt0.128B
-    hexagon_V6_ldnt0,                          // llvm.hexagon.V6.ldnt0
-    hexagon_V6_ldnt0_128B,                     // llvm.hexagon.V6.ldnt0.128B
-    hexagon_V6_ldntnt0,                        // llvm.hexagon.V6.ldntnt0
-    hexagon_V6_ldp0,                           // llvm.hexagon.V6.ldp0
-    hexagon_V6_ldp0_128B,                      // llvm.hexagon.V6.ldp0.128B
-    hexagon_V6_ldpnt0,                         // llvm.hexagon.V6.ldpnt0
-    hexagon_V6_ldpnt0_128B,                    // llvm.hexagon.V6.ldpnt0.128B
-    hexagon_V6_ldtnp0,                         // llvm.hexagon.V6.ldtnp0
-    hexagon_V6_ldtnp0_128B,                    // llvm.hexagon.V6.ldtnp0.128B
-    hexagon_V6_ldtnpnt0,                       // llvm.hexagon.V6.ldtnpnt0
-    hexagon_V6_ldtnpnt0_128B,                  // llvm.hexagon.V6.ldtnpnt0.128B
-    hexagon_V6_ldtp0,                          // llvm.hexagon.V6.ldtp0
-    hexagon_V6_ldtp0_128B,                     // llvm.hexagon.V6.ldtp0.128B
-    hexagon_V6_ldtpnt0,                        // llvm.hexagon.V6.ldtpnt0
-    hexagon_V6_ldtpnt0_128B,                   // llvm.hexagon.V6.ldtpnt0.128B
-    hexagon_V6_ldu0,                           // llvm.hexagon.V6.ldu0
-    hexagon_V6_ldu0_128B,                      // llvm.hexagon.V6.ldu0.128B
-    hexagon_V6_lo,                             // llvm.hexagon.V6.lo
-    hexagon_V6_lo_128B,                        // llvm.hexagon.V6.lo.128B
-    hexagon_V6_lvsplatb,                       // llvm.hexagon.V6.lvsplatb
-    hexagon_V6_lvsplatb_128B,                  // llvm.hexagon.V6.lvsplatb.128B
-    hexagon_V6_lvsplath,                       // llvm.hexagon.V6.lvsplath
-    hexagon_V6_lvsplath_128B,                  // llvm.hexagon.V6.lvsplath.128B
-    hexagon_V6_lvsplatw,                       // llvm.hexagon.V6.lvsplatw
-    hexagon_V6_lvsplatw_128B,                  // llvm.hexagon.V6.lvsplatw.128B
-    hexagon_V6_pred_and,                       // llvm.hexagon.V6.pred.and
-    hexagon_V6_pred_and_128B,                  // llvm.hexagon.V6.pred.and.128B
-    hexagon_V6_pred_and_n,                     // llvm.hexagon.V6.pred.and.n
-    hexagon_V6_pred_and_n_128B,                // llvm.hexagon.V6.pred.and.n.128B
-    hexagon_V6_pred_not,                       // llvm.hexagon.V6.pred.not
-    hexagon_V6_pred_not_128B,                  // llvm.hexagon.V6.pred.not.128B
-    hexagon_V6_pred_or,                        // llvm.hexagon.V6.pred.or
-    hexagon_V6_pred_or_128B,                   // llvm.hexagon.V6.pred.or.128B
-    hexagon_V6_pred_or_n,                      // llvm.hexagon.V6.pred.or.n
-    hexagon_V6_pred_or_n_128B,                 // llvm.hexagon.V6.pred.or.n.128B
-    hexagon_V6_pred_scalar2,                   // llvm.hexagon.V6.pred.scalar2
-    hexagon_V6_pred_scalar2_128B,              // llvm.hexagon.V6.pred.scalar2.128B
-    hexagon_V6_pred_scalar2v2,                 // llvm.hexagon.V6.pred.scalar2v2
-    hexagon_V6_pred_scalar2v2_128B,            // llvm.hexagon.V6.pred.scalar2v2.128B
-    hexagon_V6_pred_xor,                       // llvm.hexagon.V6.pred.xor
-    hexagon_V6_pred_xor_128B,                  // llvm.hexagon.V6.pred.xor.128B
-    hexagon_V6_shuffeqh,                       // llvm.hexagon.V6.shuffeqh
-    hexagon_V6_shuffeqh_128B,                  // llvm.hexagon.V6.shuffeqh.128B
-    hexagon_V6_shuffeqw,                       // llvm.hexagon.V6.shuffeqw
-    hexagon_V6_shuffeqw_128B,                  // llvm.hexagon.V6.shuffeqw.128B
-    hexagon_V6_vS32b_nqpred_ai,                // llvm.hexagon.V6.vS32b.nqpred.ai
-    hexagon_V6_vS32b_nqpred_ai_128B,           // llvm.hexagon.V6.vS32b.nqpred.ai.128B
-    hexagon_V6_vS32b_nt_nqpred_ai,             // llvm.hexagon.V6.vS32b.nt.nqpred.ai
-    hexagon_V6_vS32b_nt_nqpred_ai_128B,        // llvm.hexagon.V6.vS32b.nt.nqpred.ai.128B
-    hexagon_V6_vS32b_nt_qpred_ai,              // llvm.hexagon.V6.vS32b.nt.qpred.ai
-    hexagon_V6_vS32b_nt_qpred_ai_128B,         // llvm.hexagon.V6.vS32b.nt.qpred.ai.128B
-    hexagon_V6_vS32b_qpred_ai,                 // llvm.hexagon.V6.vS32b.qpred.ai
-    hexagon_V6_vS32b_qpred_ai_128B,            // llvm.hexagon.V6.vS32b.qpred.ai.128B
-    hexagon_V6_vabsb,                          // llvm.hexagon.V6.vabsb
-    hexagon_V6_vabsb_128B,                     // llvm.hexagon.V6.vabsb.128B
-    hexagon_V6_vabsb_sat,                      // llvm.hexagon.V6.vabsb.sat
-    hexagon_V6_vabsb_sat_128B,                 // llvm.hexagon.V6.vabsb.sat.128B
-    hexagon_V6_vabsdiffh,                      // llvm.hexagon.V6.vabsdiffh
-    hexagon_V6_vabsdiffh_128B,                 // llvm.hexagon.V6.vabsdiffh.128B
-    hexagon_V6_vabsdiffub,                     // llvm.hexagon.V6.vabsdiffub
-    hexagon_V6_vabsdiffub_128B,                // llvm.hexagon.V6.vabsdiffub.128B
-    hexagon_V6_vabsdiffuh,                     // llvm.hexagon.V6.vabsdiffuh
-    hexagon_V6_vabsdiffuh_128B,                // llvm.hexagon.V6.vabsdiffuh.128B
-    hexagon_V6_vabsdiffw,                      // llvm.hexagon.V6.vabsdiffw
-    hexagon_V6_vabsdiffw_128B,                 // llvm.hexagon.V6.vabsdiffw.128B
-    hexagon_V6_vabsh,                          // llvm.hexagon.V6.vabsh
-    hexagon_V6_vabsh_128B,                     // llvm.hexagon.V6.vabsh.128B
-    hexagon_V6_vabsh_sat,                      // llvm.hexagon.V6.vabsh.sat
-    hexagon_V6_vabsh_sat_128B,                 // llvm.hexagon.V6.vabsh.sat.128B
-    hexagon_V6_vabsw,                          // llvm.hexagon.V6.vabsw
-    hexagon_V6_vabsw_128B,                     // llvm.hexagon.V6.vabsw.128B
-    hexagon_V6_vabsw_sat,                      // llvm.hexagon.V6.vabsw.sat
-    hexagon_V6_vabsw_sat_128B,                 // llvm.hexagon.V6.vabsw.sat.128B
-    hexagon_V6_vaddb,                          // llvm.hexagon.V6.vaddb
-    hexagon_V6_vaddb_128B,                     // llvm.hexagon.V6.vaddb.128B
-    hexagon_V6_vaddb_dv,                       // llvm.hexagon.V6.vaddb.dv
-    hexagon_V6_vaddb_dv_128B,                  // llvm.hexagon.V6.vaddb.dv.128B
-    hexagon_V6_vaddbnq,                        // llvm.hexagon.V6.vaddbnq
-    hexagon_V6_vaddbnq_128B,                   // llvm.hexagon.V6.vaddbnq.128B
-    hexagon_V6_vaddbq,                         // llvm.hexagon.V6.vaddbq
-    hexagon_V6_vaddbq_128B,                    // llvm.hexagon.V6.vaddbq.128B
-    hexagon_V6_vaddbsat,                       // llvm.hexagon.V6.vaddbsat
-    hexagon_V6_vaddbsat_128B,                  // llvm.hexagon.V6.vaddbsat.128B
-    hexagon_V6_vaddbsat_dv,                    // llvm.hexagon.V6.vaddbsat.dv
-    hexagon_V6_vaddbsat_dv_128B,               // llvm.hexagon.V6.vaddbsat.dv.128B
-    hexagon_V6_vaddcarry,                      // llvm.hexagon.V6.vaddcarry
-    hexagon_V6_vaddcarry_128B,                 // llvm.hexagon.V6.vaddcarry.128B
-    hexagon_V6_vaddcarrysat,                   // llvm.hexagon.V6.vaddcarrysat
-    hexagon_V6_vaddcarrysat_128B,              // llvm.hexagon.V6.vaddcarrysat.128B
-    hexagon_V6_vaddclbh,                       // llvm.hexagon.V6.vaddclbh
-    hexagon_V6_vaddclbh_128B,                  // llvm.hexagon.V6.vaddclbh.128B
-    hexagon_V6_vaddclbw,                       // llvm.hexagon.V6.vaddclbw
-    hexagon_V6_vaddclbw_128B,                  // llvm.hexagon.V6.vaddclbw.128B
-    hexagon_V6_vaddh,                          // llvm.hexagon.V6.vaddh
-    hexagon_V6_vaddh_128B,                     // llvm.hexagon.V6.vaddh.128B
-    hexagon_V6_vaddh_dv,                       // llvm.hexagon.V6.vaddh.dv
-    hexagon_V6_vaddh_dv_128B,                  // llvm.hexagon.V6.vaddh.dv.128B
-    hexagon_V6_vaddhnq,                        // llvm.hexagon.V6.vaddhnq
-    hexagon_V6_vaddhnq_128B,                   // llvm.hexagon.V6.vaddhnq.128B
-    hexagon_V6_vaddhq,                         // llvm.hexagon.V6.vaddhq
-    hexagon_V6_vaddhq_128B,                    // llvm.hexagon.V6.vaddhq.128B
-    hexagon_V6_vaddhsat,                       // llvm.hexagon.V6.vaddhsat
-    hexagon_V6_vaddhsat_128B,                  // llvm.hexagon.V6.vaddhsat.128B
-    hexagon_V6_vaddhsat_dv,                    // llvm.hexagon.V6.vaddhsat.dv
-    hexagon_V6_vaddhsat_dv_128B,               // llvm.hexagon.V6.vaddhsat.dv.128B
-    hexagon_V6_vaddhw,                         // llvm.hexagon.V6.vaddhw
-    hexagon_V6_vaddhw_128B,                    // llvm.hexagon.V6.vaddhw.128B
-    hexagon_V6_vaddhw_acc,                     // llvm.hexagon.V6.vaddhw.acc
-    hexagon_V6_vaddhw_acc_128B,                // llvm.hexagon.V6.vaddhw.acc.128B
-    hexagon_V6_vaddubh,                        // llvm.hexagon.V6.vaddubh
-    hexagon_V6_vaddubh_128B,                   // llvm.hexagon.V6.vaddubh.128B
-    hexagon_V6_vaddubh_acc,                    // llvm.hexagon.V6.vaddubh.acc
-    hexagon_V6_vaddubh_acc_128B,               // llvm.hexagon.V6.vaddubh.acc.128B
-    hexagon_V6_vaddubsat,                      // llvm.hexagon.V6.vaddubsat
-    hexagon_V6_vaddubsat_128B,                 // llvm.hexagon.V6.vaddubsat.128B
-    hexagon_V6_vaddubsat_dv,                   // llvm.hexagon.V6.vaddubsat.dv
-    hexagon_V6_vaddubsat_dv_128B,              // llvm.hexagon.V6.vaddubsat.dv.128B
-    hexagon_V6_vaddububb_sat,                  // llvm.hexagon.V6.vaddububb.sat
-    hexagon_V6_vaddububb_sat_128B,             // llvm.hexagon.V6.vaddububb.sat.128B
-    hexagon_V6_vadduhsat,                      // llvm.hexagon.V6.vadduhsat
-    hexagon_V6_vadduhsat_128B,                 // llvm.hexagon.V6.vadduhsat.128B
-    hexagon_V6_vadduhsat_dv,                   // llvm.hexagon.V6.vadduhsat.dv
-    hexagon_V6_vadduhsat_dv_128B,              // llvm.hexagon.V6.vadduhsat.dv.128B
-    hexagon_V6_vadduhw,                        // llvm.hexagon.V6.vadduhw
-    hexagon_V6_vadduhw_128B,                   // llvm.hexagon.V6.vadduhw.128B
-    hexagon_V6_vadduhw_acc,                    // llvm.hexagon.V6.vadduhw.acc
-    hexagon_V6_vadduhw_acc_128B,               // llvm.hexagon.V6.vadduhw.acc.128B
-    hexagon_V6_vadduwsat,                      // llvm.hexagon.V6.vadduwsat
-    hexagon_V6_vadduwsat_128B,                 // llvm.hexagon.V6.vadduwsat.128B
-    hexagon_V6_vadduwsat_dv,                   // llvm.hexagon.V6.vadduwsat.dv
-    hexagon_V6_vadduwsat_dv_128B,              // llvm.hexagon.V6.vadduwsat.dv.128B
-    hexagon_V6_vaddw,                          // llvm.hexagon.V6.vaddw
-    hexagon_V6_vaddw_128B,                     // llvm.hexagon.V6.vaddw.128B
-    hexagon_V6_vaddw_dv,                       // llvm.hexagon.V6.vaddw.dv
-    hexagon_V6_vaddw_dv_128B,                  // llvm.hexagon.V6.vaddw.dv.128B
-    hexagon_V6_vaddwnq,                        // llvm.hexagon.V6.vaddwnq
-    hexagon_V6_vaddwnq_128B,                   // llvm.hexagon.V6.vaddwnq.128B
-    hexagon_V6_vaddwq,                         // llvm.hexagon.V6.vaddwq
-    hexagon_V6_vaddwq_128B,                    // llvm.hexagon.V6.vaddwq.128B
-    hexagon_V6_vaddwsat,                       // llvm.hexagon.V6.vaddwsat
-    hexagon_V6_vaddwsat_128B,                  // llvm.hexagon.V6.vaddwsat.128B
-    hexagon_V6_vaddwsat_dv,                    // llvm.hexagon.V6.vaddwsat.dv
-    hexagon_V6_vaddwsat_dv_128B,               // llvm.hexagon.V6.vaddwsat.dv.128B
-    hexagon_V6_valignb,                        // llvm.hexagon.V6.valignb
-    hexagon_V6_valignb_128B,                   // llvm.hexagon.V6.valignb.128B
-    hexagon_V6_valignbi,                       // llvm.hexagon.V6.valignbi
-    hexagon_V6_valignbi_128B,                  // llvm.hexagon.V6.valignbi.128B
-    hexagon_V6_vand,                           // llvm.hexagon.V6.vand
-    hexagon_V6_vand_128B,                      // llvm.hexagon.V6.vand.128B
-    hexagon_V6_vandnqrt,                       // llvm.hexagon.V6.vandnqrt
-    hexagon_V6_vandnqrt_128B,                  // llvm.hexagon.V6.vandnqrt.128B
-    hexagon_V6_vandnqrt_acc,                   // llvm.hexagon.V6.vandnqrt.acc
-    hexagon_V6_vandnqrt_acc_128B,              // llvm.hexagon.V6.vandnqrt.acc.128B
-    hexagon_V6_vandqrt,                        // llvm.hexagon.V6.vandqrt
-    hexagon_V6_vandqrt_128B,                   // llvm.hexagon.V6.vandqrt.128B
-    hexagon_V6_vandqrt_acc,                    // llvm.hexagon.V6.vandqrt.acc
-    hexagon_V6_vandqrt_acc_128B,               // llvm.hexagon.V6.vandqrt.acc.128B
-    hexagon_V6_vandvnqv,                       // llvm.hexagon.V6.vandvnqv
-    hexagon_V6_vandvnqv_128B,                  // llvm.hexagon.V6.vandvnqv.128B
-    hexagon_V6_vandvqv,                        // llvm.hexagon.V6.vandvqv
-    hexagon_V6_vandvqv_128B,                   // llvm.hexagon.V6.vandvqv.128B
-    hexagon_V6_vandvrt,                        // llvm.hexagon.V6.vandvrt
-    hexagon_V6_vandvrt_128B,                   // llvm.hexagon.V6.vandvrt.128B
-    hexagon_V6_vandvrt_acc,                    // llvm.hexagon.V6.vandvrt.acc
-    hexagon_V6_vandvrt_acc_128B,               // llvm.hexagon.V6.vandvrt.acc.128B
-    hexagon_V6_vaslh,                          // llvm.hexagon.V6.vaslh
-    hexagon_V6_vaslh_128B,                     // llvm.hexagon.V6.vaslh.128B
-    hexagon_V6_vaslh_acc,                      // llvm.hexagon.V6.vaslh.acc
-    hexagon_V6_vaslh_acc_128B,                 // llvm.hexagon.V6.vaslh.acc.128B
-    hexagon_V6_vaslhv,                         // llvm.hexagon.V6.vaslhv
-    hexagon_V6_vaslhv_128B,                    // llvm.hexagon.V6.vaslhv.128B
-    hexagon_V6_vaslw,                          // llvm.hexagon.V6.vaslw
-    hexagon_V6_vaslw_128B,                     // llvm.hexagon.V6.vaslw.128B
-    hexagon_V6_vaslw_acc,                      // llvm.hexagon.V6.vaslw.acc
-    hexagon_V6_vaslw_acc_128B,                 // llvm.hexagon.V6.vaslw.acc.128B
-    hexagon_V6_vaslwv,                         // llvm.hexagon.V6.vaslwv
-    hexagon_V6_vaslwv_128B,                    // llvm.hexagon.V6.vaslwv.128B
-    hexagon_V6_vasr_into,                      // llvm.hexagon.V6.vasr.into
-    hexagon_V6_vasr_into_128B,                 // llvm.hexagon.V6.vasr.into.128B
-    hexagon_V6_vasrh,                          // llvm.hexagon.V6.vasrh
-    hexagon_V6_vasrh_128B,                     // llvm.hexagon.V6.vasrh.128B
-    hexagon_V6_vasrh_acc,                      // llvm.hexagon.V6.vasrh.acc
-    hexagon_V6_vasrh_acc_128B,                 // llvm.hexagon.V6.vasrh.acc.128B
-    hexagon_V6_vasrhbrndsat,                   // llvm.hexagon.V6.vasrhbrndsat
-    hexagon_V6_vasrhbrndsat_128B,              // llvm.hexagon.V6.vasrhbrndsat.128B
-    hexagon_V6_vasrhbsat,                      // llvm.hexagon.V6.vasrhbsat
-    hexagon_V6_vasrhbsat_128B,                 // llvm.hexagon.V6.vasrhbsat.128B
-    hexagon_V6_vasrhubrndsat,                  // llvm.hexagon.V6.vasrhubrndsat
-    hexagon_V6_vasrhubrndsat_128B,             // llvm.hexagon.V6.vasrhubrndsat.128B
-    hexagon_V6_vasrhubsat,                     // llvm.hexagon.V6.vasrhubsat
-    hexagon_V6_vasrhubsat_128B,                // llvm.hexagon.V6.vasrhubsat.128B
-    hexagon_V6_vasrhv,                         // llvm.hexagon.V6.vasrhv
-    hexagon_V6_vasrhv_128B,                    // llvm.hexagon.V6.vasrhv.128B
-    hexagon_V6_vasruhubrndsat,                 // llvm.hexagon.V6.vasruhubrndsat
-    hexagon_V6_vasruhubrndsat_128B,            // llvm.hexagon.V6.vasruhubrndsat.128B
-    hexagon_V6_vasruhubsat,                    // llvm.hexagon.V6.vasruhubsat
-    hexagon_V6_vasruhubsat_128B,               // llvm.hexagon.V6.vasruhubsat.128B
-    hexagon_V6_vasruwuhrndsat,                 // llvm.hexagon.V6.vasruwuhrndsat
-    hexagon_V6_vasruwuhrndsat_128B,            // llvm.hexagon.V6.vasruwuhrndsat.128B
-    hexagon_V6_vasruwuhsat,                    // llvm.hexagon.V6.vasruwuhsat
-    hexagon_V6_vasruwuhsat_128B,               // llvm.hexagon.V6.vasruwuhsat.128B
-    hexagon_V6_vasrw,                          // llvm.hexagon.V6.vasrw
-    hexagon_V6_vasrw_128B,                     // llvm.hexagon.V6.vasrw.128B
-    hexagon_V6_vasrw_acc,                      // llvm.hexagon.V6.vasrw.acc
-    hexagon_V6_vasrw_acc_128B,                 // llvm.hexagon.V6.vasrw.acc.128B
-    hexagon_V6_vasrwh,                         // llvm.hexagon.V6.vasrwh
-    hexagon_V6_vasrwh_128B,                    // llvm.hexagon.V6.vasrwh.128B
-    hexagon_V6_vasrwhrndsat,                   // llvm.hexagon.V6.vasrwhrndsat
-    hexagon_V6_vasrwhrndsat_128B,              // llvm.hexagon.V6.vasrwhrndsat.128B
-    hexagon_V6_vasrwhsat,                      // llvm.hexagon.V6.vasrwhsat
-    hexagon_V6_vasrwhsat_128B,                 // llvm.hexagon.V6.vasrwhsat.128B
-    hexagon_V6_vasrwuhrndsat,                  // llvm.hexagon.V6.vasrwuhrndsat
-    hexagon_V6_vasrwuhrndsat_128B,             // llvm.hexagon.V6.vasrwuhrndsat.128B
-    hexagon_V6_vasrwuhsat,                     // llvm.hexagon.V6.vasrwuhsat
-    hexagon_V6_vasrwuhsat_128B,                // llvm.hexagon.V6.vasrwuhsat.128B
-    hexagon_V6_vasrwv,                         // llvm.hexagon.V6.vasrwv
-    hexagon_V6_vasrwv_128B,                    // llvm.hexagon.V6.vasrwv.128B
-    hexagon_V6_vassign,                        // llvm.hexagon.V6.vassign
-    hexagon_V6_vassign_128B,                   // llvm.hexagon.V6.vassign.128B
-    hexagon_V6_vassignp,                       // llvm.hexagon.V6.vassignp
-    hexagon_V6_vassignp_128B,                  // llvm.hexagon.V6.vassignp.128B
-    hexagon_V6_vavgb,                          // llvm.hexagon.V6.vavgb
-    hexagon_V6_vavgb_128B,                     // llvm.hexagon.V6.vavgb.128B
-    hexagon_V6_vavgbrnd,                       // llvm.hexagon.V6.vavgbrnd
-    hexagon_V6_vavgbrnd_128B,                  // llvm.hexagon.V6.vavgbrnd.128B
-    hexagon_V6_vavgh,                          // llvm.hexagon.V6.vavgh
-    hexagon_V6_vavgh_128B,                     // llvm.hexagon.V6.vavgh.128B
-    hexagon_V6_vavghrnd,                       // llvm.hexagon.V6.vavghrnd
-    hexagon_V6_vavghrnd_128B,                  // llvm.hexagon.V6.vavghrnd.128B
-    hexagon_V6_vavgub,                         // llvm.hexagon.V6.vavgub
-    hexagon_V6_vavgub_128B,                    // llvm.hexagon.V6.vavgub.128B
-    hexagon_V6_vavgubrnd,                      // llvm.hexagon.V6.vavgubrnd
-    hexagon_V6_vavgubrnd_128B,                 // llvm.hexagon.V6.vavgubrnd.128B
-    hexagon_V6_vavguh,                         // llvm.hexagon.V6.vavguh
-    hexagon_V6_vavguh_128B,                    // llvm.hexagon.V6.vavguh.128B
-    hexagon_V6_vavguhrnd,                      // llvm.hexagon.V6.vavguhrnd
-    hexagon_V6_vavguhrnd_128B,                 // llvm.hexagon.V6.vavguhrnd.128B
-    hexagon_V6_vavguw,                         // llvm.hexagon.V6.vavguw
-    hexagon_V6_vavguw_128B,                    // llvm.hexagon.V6.vavguw.128B
-    hexagon_V6_vavguwrnd,                      // llvm.hexagon.V6.vavguwrnd
-    hexagon_V6_vavguwrnd_128B,                 // llvm.hexagon.V6.vavguwrnd.128B
-    hexagon_V6_vavgw,                          // llvm.hexagon.V6.vavgw
-    hexagon_V6_vavgw_128B,                     // llvm.hexagon.V6.vavgw.128B
-    hexagon_V6_vavgwrnd,                       // llvm.hexagon.V6.vavgwrnd
-    hexagon_V6_vavgwrnd_128B,                  // llvm.hexagon.V6.vavgwrnd.128B
-    hexagon_V6_vcl0h,                          // llvm.hexagon.V6.vcl0h
-    hexagon_V6_vcl0h_128B,                     // llvm.hexagon.V6.vcl0h.128B
-    hexagon_V6_vcl0w,                          // llvm.hexagon.V6.vcl0w
-    hexagon_V6_vcl0w_128B,                     // llvm.hexagon.V6.vcl0w.128B
-    hexagon_V6_vcombine,                       // llvm.hexagon.V6.vcombine
-    hexagon_V6_vcombine_128B,                  // llvm.hexagon.V6.vcombine.128B
-    hexagon_V6_vd0,                            // llvm.hexagon.V6.vd0
-    hexagon_V6_vd0_128B,                       // llvm.hexagon.V6.vd0.128B
-    hexagon_V6_vdd0,                           // llvm.hexagon.V6.vdd0
-    hexagon_V6_vdd0_128B,                      // llvm.hexagon.V6.vdd0.128B
-    hexagon_V6_vdealb,                         // llvm.hexagon.V6.vdealb
-    hexagon_V6_vdealb_128B,                    // llvm.hexagon.V6.vdealb.128B
-    hexagon_V6_vdealb4w,                       // llvm.hexagon.V6.vdealb4w
-    hexagon_V6_vdealb4w_128B,                  // llvm.hexagon.V6.vdealb4w.128B
-    hexagon_V6_vdealh,                         // llvm.hexagon.V6.vdealh
-    hexagon_V6_vdealh_128B,                    // llvm.hexagon.V6.vdealh.128B
-    hexagon_V6_vdealvdd,                       // llvm.hexagon.V6.vdealvdd
-    hexagon_V6_vdealvdd_128B,                  // llvm.hexagon.V6.vdealvdd.128B
-    hexagon_V6_vdelta,                         // llvm.hexagon.V6.vdelta
-    hexagon_V6_vdelta_128B,                    // llvm.hexagon.V6.vdelta.128B
-    hexagon_V6_vdmpybus,                       // llvm.hexagon.V6.vdmpybus
-    hexagon_V6_vdmpybus_128B,                  // llvm.hexagon.V6.vdmpybus.128B
-    hexagon_V6_vdmpybus_acc,                   // llvm.hexagon.V6.vdmpybus.acc
-    hexagon_V6_vdmpybus_acc_128B,              // llvm.hexagon.V6.vdmpybus.acc.128B
-    hexagon_V6_vdmpybus_dv,                    // llvm.hexagon.V6.vdmpybus.dv
-    hexagon_V6_vdmpybus_dv_128B,               // llvm.hexagon.V6.vdmpybus.dv.128B
-    hexagon_V6_vdmpybus_dv_acc,                // llvm.hexagon.V6.vdmpybus.dv.acc
-    hexagon_V6_vdmpybus_dv_acc_128B,           // llvm.hexagon.V6.vdmpybus.dv.acc.128B
-    hexagon_V6_vdmpyhb,                        // llvm.hexagon.V6.vdmpyhb
-    hexagon_V6_vdmpyhb_128B,                   // llvm.hexagon.V6.vdmpyhb.128B
-    hexagon_V6_vdmpyhb_acc,                    // llvm.hexagon.V6.vdmpyhb.acc
-    hexagon_V6_vdmpyhb_acc_128B,               // llvm.hexagon.V6.vdmpyhb.acc.128B
-    hexagon_V6_vdmpyhb_dv,                     // llvm.hexagon.V6.vdmpyhb.dv
-    hexagon_V6_vdmpyhb_dv_128B,                // llvm.hexagon.V6.vdmpyhb.dv.128B
-    hexagon_V6_vdmpyhb_dv_acc,                 // llvm.hexagon.V6.vdmpyhb.dv.acc
-    hexagon_V6_vdmpyhb_dv_acc_128B,            // llvm.hexagon.V6.vdmpyhb.dv.acc.128B
-    hexagon_V6_vdmpyhisat,                     // llvm.hexagon.V6.vdmpyhisat
-    hexagon_V6_vdmpyhisat_128B,                // llvm.hexagon.V6.vdmpyhisat.128B
-    hexagon_V6_vdmpyhisat_acc,                 // llvm.hexagon.V6.vdmpyhisat.acc
-    hexagon_V6_vdmpyhisat_acc_128B,            // llvm.hexagon.V6.vdmpyhisat.acc.128B
-    hexagon_V6_vdmpyhsat,                      // llvm.hexagon.V6.vdmpyhsat
-    hexagon_V6_vdmpyhsat_128B,                 // llvm.hexagon.V6.vdmpyhsat.128B
-    hexagon_V6_vdmpyhsat_acc,                  // llvm.hexagon.V6.vdmpyhsat.acc
-    hexagon_V6_vdmpyhsat_acc_128B,             // llvm.hexagon.V6.vdmpyhsat.acc.128B
-    hexagon_V6_vdmpyhsuisat,                   // llvm.hexagon.V6.vdmpyhsuisat
-    hexagon_V6_vdmpyhsuisat_128B,              // llvm.hexagon.V6.vdmpyhsuisat.128B
-    hexagon_V6_vdmpyhsuisat_acc,               // llvm.hexagon.V6.vdmpyhsuisat.acc
-    hexagon_V6_vdmpyhsuisat_acc_128B,          // llvm.hexagon.V6.vdmpyhsuisat.acc.128B
-    hexagon_V6_vdmpyhsusat,                    // llvm.hexagon.V6.vdmpyhsusat
-    hexagon_V6_vdmpyhsusat_128B,               // llvm.hexagon.V6.vdmpyhsusat.128B
-    hexagon_V6_vdmpyhsusat_acc,                // llvm.hexagon.V6.vdmpyhsusat.acc
-    hexagon_V6_vdmpyhsusat_acc_128B,           // llvm.hexagon.V6.vdmpyhsusat.acc.128B
-    hexagon_V6_vdmpyhvsat,                     // llvm.hexagon.V6.vdmpyhvsat
-    hexagon_V6_vdmpyhvsat_128B,                // llvm.hexagon.V6.vdmpyhvsat.128B
-    hexagon_V6_vdmpyhvsat_acc,                 // llvm.hexagon.V6.vdmpyhvsat.acc
-    hexagon_V6_vdmpyhvsat_acc_128B,            // llvm.hexagon.V6.vdmpyhvsat.acc.128B
-    hexagon_V6_vdsaduh,                        // llvm.hexagon.V6.vdsaduh
-    hexagon_V6_vdsaduh_128B,                   // llvm.hexagon.V6.vdsaduh.128B
-    hexagon_V6_vdsaduh_acc,                    // llvm.hexagon.V6.vdsaduh.acc
-    hexagon_V6_vdsaduh_acc_128B,               // llvm.hexagon.V6.vdsaduh.acc.128B
-    hexagon_V6_veqb,                           // llvm.hexagon.V6.veqb
-    hexagon_V6_veqb_128B,                      // llvm.hexagon.V6.veqb.128B
-    hexagon_V6_veqb_and,                       // llvm.hexagon.V6.veqb.and
-    hexagon_V6_veqb_and_128B,                  // llvm.hexagon.V6.veqb.and.128B
-    hexagon_V6_veqb_or,                        // llvm.hexagon.V6.veqb.or
-    hexagon_V6_veqb_or_128B,                   // llvm.hexagon.V6.veqb.or.128B
-    hexagon_V6_veqb_xor,                       // llvm.hexagon.V6.veqb.xor
-    hexagon_V6_veqb_xor_128B,                  // llvm.hexagon.V6.veqb.xor.128B
-    hexagon_V6_veqh,                           // llvm.hexagon.V6.veqh
-    hexagon_V6_veqh_128B,                      // llvm.hexagon.V6.veqh.128B
-    hexagon_V6_veqh_and,                       // llvm.hexagon.V6.veqh.and
-    hexagon_V6_veqh_and_128B,                  // llvm.hexagon.V6.veqh.and.128B
-    hexagon_V6_veqh_or,                        // llvm.hexagon.V6.veqh.or
-    hexagon_V6_veqh_or_128B,                   // llvm.hexagon.V6.veqh.or.128B
-    hexagon_V6_veqh_xor,                       // llvm.hexagon.V6.veqh.xor
-    hexagon_V6_veqh_xor_128B,                  // llvm.hexagon.V6.veqh.xor.128B
-    hexagon_V6_veqw,                           // llvm.hexagon.V6.veqw
-    hexagon_V6_veqw_128B,                      // llvm.hexagon.V6.veqw.128B
-    hexagon_V6_veqw_and,                       // llvm.hexagon.V6.veqw.and
-    hexagon_V6_veqw_and_128B,                  // llvm.hexagon.V6.veqw.and.128B
-    hexagon_V6_veqw_or,                        // llvm.hexagon.V6.veqw.or
-    hexagon_V6_veqw_or_128B,                   // llvm.hexagon.V6.veqw.or.128B
-    hexagon_V6_veqw_xor,                       // llvm.hexagon.V6.veqw.xor
-    hexagon_V6_veqw_xor_128B,                  // llvm.hexagon.V6.veqw.xor.128B
-    hexagon_V6_vgathermh,                      // llvm.hexagon.V6.vgathermh
-    hexagon_V6_vgathermh_128B,                 // llvm.hexagon.V6.vgathermh.128B
-    hexagon_V6_vgathermhq,                     // llvm.hexagon.V6.vgathermhq
-    hexagon_V6_vgathermhq_128B,                // llvm.hexagon.V6.vgathermhq.128B
-    hexagon_V6_vgathermhw,                     // llvm.hexagon.V6.vgathermhw
-    hexagon_V6_vgathermhw_128B,                // llvm.hexagon.V6.vgathermhw.128B
-    hexagon_V6_vgathermhwq,                    // llvm.hexagon.V6.vgathermhwq
-    hexagon_V6_vgathermhwq_128B,               // llvm.hexagon.V6.vgathermhwq.128B
-    hexagon_V6_vgathermw,                      // llvm.hexagon.V6.vgathermw
-    hexagon_V6_vgathermw_128B,                 // llvm.hexagon.V6.vgathermw.128B
-    hexagon_V6_vgathermwq,                     // llvm.hexagon.V6.vgathermwq
-    hexagon_V6_vgathermwq_128B,                // llvm.hexagon.V6.vgathermwq.128B
-    hexagon_V6_vgtb,                           // llvm.hexagon.V6.vgtb
-    hexagon_V6_vgtb_128B,                      // llvm.hexagon.V6.vgtb.128B
-    hexagon_V6_vgtb_and,                       // llvm.hexagon.V6.vgtb.and
-    hexagon_V6_vgtb_and_128B,                  // llvm.hexagon.V6.vgtb.and.128B
-    hexagon_V6_vgtb_or,                        // llvm.hexagon.V6.vgtb.or
-    hexagon_V6_vgtb_or_128B,                   // llvm.hexagon.V6.vgtb.or.128B
-    hexagon_V6_vgtb_xor,                       // llvm.hexagon.V6.vgtb.xor
-    hexagon_V6_vgtb_xor_128B,                  // llvm.hexagon.V6.vgtb.xor.128B
-    hexagon_V6_vgth,                           // llvm.hexagon.V6.vgth
-    hexagon_V6_vgth_128B,                      // llvm.hexagon.V6.vgth.128B
-    hexagon_V6_vgth_and,                       // llvm.hexagon.V6.vgth.and
-    hexagon_V6_vgth_and_128B,                  // llvm.hexagon.V6.vgth.and.128B
-    hexagon_V6_vgth_or,                        // llvm.hexagon.V6.vgth.or
-    hexagon_V6_vgth_or_128B,                   // llvm.hexagon.V6.vgth.or.128B
-    hexagon_V6_vgth_xor,                       // llvm.hexagon.V6.vgth.xor
-    hexagon_V6_vgth_xor_128B,                  // llvm.hexagon.V6.vgth.xor.128B
-    hexagon_V6_vgtub,                          // llvm.hexagon.V6.vgtub
-    hexagon_V6_vgtub_128B,                     // llvm.hexagon.V6.vgtub.128B
-    hexagon_V6_vgtub_and,                      // llvm.hexagon.V6.vgtub.and
-    hexagon_V6_vgtub_and_128B,                 // llvm.hexagon.V6.vgtub.and.128B
-    hexagon_V6_vgtub_or,                       // llvm.hexagon.V6.vgtub.or
-    hexagon_V6_vgtub_or_128B,                  // llvm.hexagon.V6.vgtub.or.128B
-    hexagon_V6_vgtub_xor,                      // llvm.hexagon.V6.vgtub.xor
-    hexagon_V6_vgtub_xor_128B,                 // llvm.hexagon.V6.vgtub.xor.128B
-    hexagon_V6_vgtuh,                          // llvm.hexagon.V6.vgtuh
-    hexagon_V6_vgtuh_128B,                     // llvm.hexagon.V6.vgtuh.128B
-    hexagon_V6_vgtuh_and,                      // llvm.hexagon.V6.vgtuh.and
-    hexagon_V6_vgtuh_and_128B,                 // llvm.hexagon.V6.vgtuh.and.128B
-    hexagon_V6_vgtuh_or,                       // llvm.hexagon.V6.vgtuh.or
-    hexagon_V6_vgtuh_or_128B,                  // llvm.hexagon.V6.vgtuh.or.128B
-    hexagon_V6_vgtuh_xor,                      // llvm.hexagon.V6.vgtuh.xor
-    hexagon_V6_vgtuh_xor_128B,                 // llvm.hexagon.V6.vgtuh.xor.128B
-    hexagon_V6_vgtuw,                          // llvm.hexagon.V6.vgtuw
-    hexagon_V6_vgtuw_128B,                     // llvm.hexagon.V6.vgtuw.128B
-    hexagon_V6_vgtuw_and,                      // llvm.hexagon.V6.vgtuw.and
-    hexagon_V6_vgtuw_and_128B,                 // llvm.hexagon.V6.vgtuw.and.128B
-    hexagon_V6_vgtuw_or,                       // llvm.hexagon.V6.vgtuw.or
-    hexagon_V6_vgtuw_or_128B,                  // llvm.hexagon.V6.vgtuw.or.128B
-    hexagon_V6_vgtuw_xor,                      // llvm.hexagon.V6.vgtuw.xor
-    hexagon_V6_vgtuw_xor_128B,                 // llvm.hexagon.V6.vgtuw.xor.128B
-    hexagon_V6_vgtw,                           // llvm.hexagon.V6.vgtw
-    hexagon_V6_vgtw_128B,                      // llvm.hexagon.V6.vgtw.128B
-    hexagon_V6_vgtw_and,                       // llvm.hexagon.V6.vgtw.and
-    hexagon_V6_vgtw_and_128B,                  // llvm.hexagon.V6.vgtw.and.128B
-    hexagon_V6_vgtw_or,                        // llvm.hexagon.V6.vgtw.or
-    hexagon_V6_vgtw_or_128B,                   // llvm.hexagon.V6.vgtw.or.128B
-    hexagon_V6_vgtw_xor,                       // llvm.hexagon.V6.vgtw.xor
-    hexagon_V6_vgtw_xor_128B,                  // llvm.hexagon.V6.vgtw.xor.128B
-    hexagon_V6_vinsertwr,                      // llvm.hexagon.V6.vinsertwr
-    hexagon_V6_vinsertwr_128B,                 // llvm.hexagon.V6.vinsertwr.128B
-    hexagon_V6_vlalignb,                       // llvm.hexagon.V6.vlalignb
-    hexagon_V6_vlalignb_128B,                  // llvm.hexagon.V6.vlalignb.128B
-    hexagon_V6_vlalignbi,                      // llvm.hexagon.V6.vlalignbi
-    hexagon_V6_vlalignbi_128B,                 // llvm.hexagon.V6.vlalignbi.128B
-    hexagon_V6_vlsrb,                          // llvm.hexagon.V6.vlsrb
-    hexagon_V6_vlsrb_128B,                     // llvm.hexagon.V6.vlsrb.128B
-    hexagon_V6_vlsrh,                          // llvm.hexagon.V6.vlsrh
-    hexagon_V6_vlsrh_128B,                     // llvm.hexagon.V6.vlsrh.128B
-    hexagon_V6_vlsrhv,                         // llvm.hexagon.V6.vlsrhv
-    hexagon_V6_vlsrhv_128B,                    // llvm.hexagon.V6.vlsrhv.128B
-    hexagon_V6_vlsrw,                          // llvm.hexagon.V6.vlsrw
-    hexagon_V6_vlsrw_128B,                     // llvm.hexagon.V6.vlsrw.128B
-    hexagon_V6_vlsrwv,                         // llvm.hexagon.V6.vlsrwv
-    hexagon_V6_vlsrwv_128B,                    // llvm.hexagon.V6.vlsrwv.128B
-    hexagon_V6_vlut4,                          // llvm.hexagon.V6.vlut4
-    hexagon_V6_vlut4_128B,                     // llvm.hexagon.V6.vlut4.128B
-    hexagon_V6_vlutvvb,                        // llvm.hexagon.V6.vlutvvb
-    hexagon_V6_vlutvvb_128B,                   // llvm.hexagon.V6.vlutvvb.128B
-    hexagon_V6_vlutvvb_nm,                     // llvm.hexagon.V6.vlutvvb.nm
-    hexagon_V6_vlutvvb_nm_128B,                // llvm.hexagon.V6.vlutvvb.nm.128B
-    hexagon_V6_vlutvvb_oracc,                  // llvm.hexagon.V6.vlutvvb.oracc
-    hexagon_V6_vlutvvb_oracc_128B,             // llvm.hexagon.V6.vlutvvb.oracc.128B
-    hexagon_V6_vlutvvb_oracci,                 // llvm.hexagon.V6.vlutvvb.oracci
-    hexagon_V6_vlutvvb_oracci_128B,            // llvm.hexagon.V6.vlutvvb.oracci.128B
-    hexagon_V6_vlutvvbi,                       // llvm.hexagon.V6.vlutvvbi
-    hexagon_V6_vlutvvbi_128B,                  // llvm.hexagon.V6.vlutvvbi.128B
-    hexagon_V6_vlutvwh,                        // llvm.hexagon.V6.vlutvwh
-    hexagon_V6_vlutvwh_128B,                   // llvm.hexagon.V6.vlutvwh.128B
-    hexagon_V6_vlutvwh_nm,                     // llvm.hexagon.V6.vlutvwh.nm
-    hexagon_V6_vlutvwh_nm_128B,                // llvm.hexagon.V6.vlutvwh.nm.128B
-    hexagon_V6_vlutvwh_oracc,                  // llvm.hexagon.V6.vlutvwh.oracc
-    hexagon_V6_vlutvwh_oracc_128B,             // llvm.hexagon.V6.vlutvwh.oracc.128B
-    hexagon_V6_vlutvwh_oracci,                 // llvm.hexagon.V6.vlutvwh.oracci
-    hexagon_V6_vlutvwh_oracci_128B,            // llvm.hexagon.V6.vlutvwh.oracci.128B
-    hexagon_V6_vlutvwhi,                       // llvm.hexagon.V6.vlutvwhi
-    hexagon_V6_vlutvwhi_128B,                  // llvm.hexagon.V6.vlutvwhi.128B
-    hexagon_V6_vmaskedstorenq,                 // llvm.hexagon.V6.vmaskedstorenq
-    hexagon_V6_vmaskedstorenq_128B,            // llvm.hexagon.V6.vmaskedstorenq.128B
-    hexagon_V6_vmaskedstorentnq,               // llvm.hexagon.V6.vmaskedstorentnq
-    hexagon_V6_vmaskedstorentnq_128B,          // llvm.hexagon.V6.vmaskedstorentnq.128B
-    hexagon_V6_vmaskedstorentq,                // llvm.hexagon.V6.vmaskedstorentq
-    hexagon_V6_vmaskedstorentq_128B,           // llvm.hexagon.V6.vmaskedstorentq.128B
-    hexagon_V6_vmaskedstoreq,                  // llvm.hexagon.V6.vmaskedstoreq
-    hexagon_V6_vmaskedstoreq_128B,             // llvm.hexagon.V6.vmaskedstoreq.128B
-    hexagon_V6_vmaxb,                          // llvm.hexagon.V6.vmaxb
-    hexagon_V6_vmaxb_128B,                     // llvm.hexagon.V6.vmaxb.128B
-    hexagon_V6_vmaxh,                          // llvm.hexagon.V6.vmaxh
-    hexagon_V6_vmaxh_128B,                     // llvm.hexagon.V6.vmaxh.128B
-    hexagon_V6_vmaxub,                         // llvm.hexagon.V6.vmaxub
-    hexagon_V6_vmaxub_128B,                    // llvm.hexagon.V6.vmaxub.128B
-    hexagon_V6_vmaxuh,                         // llvm.hexagon.V6.vmaxuh
-    hexagon_V6_vmaxuh_128B,                    // llvm.hexagon.V6.vmaxuh.128B
-    hexagon_V6_vmaxw,                          // llvm.hexagon.V6.vmaxw
-    hexagon_V6_vmaxw_128B,                     // llvm.hexagon.V6.vmaxw.128B
-    hexagon_V6_vminb,                          // llvm.hexagon.V6.vminb
-    hexagon_V6_vminb_128B,                     // llvm.hexagon.V6.vminb.128B
-    hexagon_V6_vminh,                          // llvm.hexagon.V6.vminh
-    hexagon_V6_vminh_128B,                     // llvm.hexagon.V6.vminh.128B
-    hexagon_V6_vminub,                         // llvm.hexagon.V6.vminub
-    hexagon_V6_vminub_128B,                    // llvm.hexagon.V6.vminub.128B
-    hexagon_V6_vminuh,                         // llvm.hexagon.V6.vminuh
-    hexagon_V6_vminuh_128B,                    // llvm.hexagon.V6.vminuh.128B
-    hexagon_V6_vminw,                          // llvm.hexagon.V6.vminw
-    hexagon_V6_vminw_128B,                     // llvm.hexagon.V6.vminw.128B
-    hexagon_V6_vmpabus,                        // llvm.hexagon.V6.vmpabus
-    hexagon_V6_vmpabus_128B,                   // llvm.hexagon.V6.vmpabus.128B
-    hexagon_V6_vmpabus_acc,                    // llvm.hexagon.V6.vmpabus.acc
-    hexagon_V6_vmpabus_acc_128B,               // llvm.hexagon.V6.vmpabus.acc.128B
-    hexagon_V6_vmpabusv,                       // llvm.hexagon.V6.vmpabusv
-    hexagon_V6_vmpabusv_128B,                  // llvm.hexagon.V6.vmpabusv.128B
-    hexagon_V6_vmpabuu,                        // llvm.hexagon.V6.vmpabuu
-    hexagon_V6_vmpabuu_128B,                   // llvm.hexagon.V6.vmpabuu.128B
-    hexagon_V6_vmpabuu_acc,                    // llvm.hexagon.V6.vmpabuu.acc
-    hexagon_V6_vmpabuu_acc_128B,               // llvm.hexagon.V6.vmpabuu.acc.128B
-    hexagon_V6_vmpabuuv,                       // llvm.hexagon.V6.vmpabuuv
-    hexagon_V6_vmpabuuv_128B,                  // llvm.hexagon.V6.vmpabuuv.128B
-    hexagon_V6_vmpahb,                         // llvm.hexagon.V6.vmpahb
-    hexagon_V6_vmpahb_128B,                    // llvm.hexagon.V6.vmpahb.128B
-    hexagon_V6_vmpahb_acc,                     // llvm.hexagon.V6.vmpahb.acc
-    hexagon_V6_vmpahb_acc_128B,                // llvm.hexagon.V6.vmpahb.acc.128B
-    hexagon_V6_vmpahhsat,                      // llvm.hexagon.V6.vmpahhsat
-    hexagon_V6_vmpahhsat_128B,                 // llvm.hexagon.V6.vmpahhsat.128B
-    hexagon_V6_vmpauhb,                        // llvm.hexagon.V6.vmpauhb
-    hexagon_V6_vmpauhb_128B,                   // llvm.hexagon.V6.vmpauhb.128B
-    hexagon_V6_vmpauhb_acc,                    // llvm.hexagon.V6.vmpauhb.acc
-    hexagon_V6_vmpauhb_acc_128B,               // llvm.hexagon.V6.vmpauhb.acc.128B
-    hexagon_V6_vmpauhuhsat,                    // llvm.hexagon.V6.vmpauhuhsat
-    hexagon_V6_vmpauhuhsat_128B,               // llvm.hexagon.V6.vmpauhuhsat.128B
-    hexagon_V6_vmpsuhuhsat,                    // llvm.hexagon.V6.vmpsuhuhsat
-    hexagon_V6_vmpsuhuhsat_128B,               // llvm.hexagon.V6.vmpsuhuhsat.128B
-    hexagon_V6_vmpybus,                        // llvm.hexagon.V6.vmpybus
-    hexagon_V6_vmpybus_128B,                   // llvm.hexagon.V6.vmpybus.128B
-    hexagon_V6_vmpybus_acc,                    // llvm.hexagon.V6.vmpybus.acc
-    hexagon_V6_vmpybus_acc_128B,               // llvm.hexagon.V6.vmpybus.acc.128B
-    hexagon_V6_vmpybusv,                       // llvm.hexagon.V6.vmpybusv
-    hexagon_V6_vmpybusv_128B,                  // llvm.hexagon.V6.vmpybusv.128B
-    hexagon_V6_vmpybusv_acc,                   // llvm.hexagon.V6.vmpybusv.acc
-    hexagon_V6_vmpybusv_acc_128B,              // llvm.hexagon.V6.vmpybusv.acc.128B
-    hexagon_V6_vmpybv,                         // llvm.hexagon.V6.vmpybv
-    hexagon_V6_vmpybv_128B,                    // llvm.hexagon.V6.vmpybv.128B
-    hexagon_V6_vmpybv_acc,                     // llvm.hexagon.V6.vmpybv.acc
-    hexagon_V6_vmpybv_acc_128B,                // llvm.hexagon.V6.vmpybv.acc.128B
-    hexagon_V6_vmpyewuh,                       // llvm.hexagon.V6.vmpyewuh
-    hexagon_V6_vmpyewuh_128B,                  // llvm.hexagon.V6.vmpyewuh.128B
-    hexagon_V6_vmpyewuh_64,                    // llvm.hexagon.V6.vmpyewuh.64
-    hexagon_V6_vmpyewuh_64_128B,               // llvm.hexagon.V6.vmpyewuh.64.128B
-    hexagon_V6_vmpyh,                          // llvm.hexagon.V6.vmpyh
-    hexagon_V6_vmpyh_128B,                     // llvm.hexagon.V6.vmpyh.128B
-    hexagon_V6_vmpyh_acc,                      // llvm.hexagon.V6.vmpyh.acc
-    hexagon_V6_vmpyh_acc_128B,                 // llvm.hexagon.V6.vmpyh.acc.128B
-    hexagon_V6_vmpyhsat_acc,                   // llvm.hexagon.V6.vmpyhsat.acc
-    hexagon_V6_vmpyhsat_acc_128B,              // llvm.hexagon.V6.vmpyhsat.acc.128B
-    hexagon_V6_vmpyhsrs,                       // llvm.hexagon.V6.vmpyhsrs
-    hexagon_V6_vmpyhsrs_128B,                  // llvm.hexagon.V6.vmpyhsrs.128B
-    hexagon_V6_vmpyhss,                        // llvm.hexagon.V6.vmpyhss
-    hexagon_V6_vmpyhss_128B,                   // llvm.hexagon.V6.vmpyhss.128B
-    hexagon_V6_vmpyhus,                        // llvm.hexagon.V6.vmpyhus
-    hexagon_V6_vmpyhus_128B,                   // llvm.hexagon.V6.vmpyhus.128B
-    hexagon_V6_vmpyhus_acc,                    // llvm.hexagon.V6.vmpyhus.acc
-    hexagon_V6_vmpyhus_acc_128B,               // llvm.hexagon.V6.vmpyhus.acc.128B
-    hexagon_V6_vmpyhv,                         // llvm.hexagon.V6.vmpyhv
-    hexagon_V6_vmpyhv_128B,                    // llvm.hexagon.V6.vmpyhv.128B
-    hexagon_V6_vmpyhv_acc,                     // llvm.hexagon.V6.vmpyhv.acc
-    hexagon_V6_vmpyhv_acc_128B,                // llvm.hexagon.V6.vmpyhv.acc.128B
-    hexagon_V6_vmpyhvsrs,                      // llvm.hexagon.V6.vmpyhvsrs
-    hexagon_V6_vmpyhvsrs_128B,                 // llvm.hexagon.V6.vmpyhvsrs.128B
-    hexagon_V6_vmpyieoh,                       // llvm.hexagon.V6.vmpyieoh
-    hexagon_V6_vmpyieoh_128B,                  // llvm.hexagon.V6.vmpyieoh.128B
-    hexagon_V6_vmpyiewh_acc,                   // llvm.hexagon.V6.vmpyiewh.acc
-    hexagon_V6_vmpyiewh_acc_128B,              // llvm.hexagon.V6.vmpyiewh.acc.128B
-    hexagon_V6_vmpyiewuh,                      // llvm.hexagon.V6.vmpyiewuh
-    hexagon_V6_vmpyiewuh_128B,                 // llvm.hexagon.V6.vmpyiewuh.128B
-    hexagon_V6_vmpyiewuh_acc,                  // llvm.hexagon.V6.vmpyiewuh.acc
-    hexagon_V6_vmpyiewuh_acc_128B,             // llvm.hexagon.V6.vmpyiewuh.acc.128B
-    hexagon_V6_vmpyih,                         // llvm.hexagon.V6.vmpyih
-    hexagon_V6_vmpyih_128B,                    // llvm.hexagon.V6.vmpyih.128B
-    hexagon_V6_vmpyih_acc,                     // llvm.hexagon.V6.vmpyih.acc
-    hexagon_V6_vmpyih_acc_128B,                // llvm.hexagon.V6.vmpyih.acc.128B
-    hexagon_V6_vmpyihb,                        // llvm.hexagon.V6.vmpyihb
-    hexagon_V6_vmpyihb_128B,                   // llvm.hexagon.V6.vmpyihb.128B
-    hexagon_V6_vmpyihb_acc,                    // llvm.hexagon.V6.vmpyihb.acc
-    hexagon_V6_vmpyihb_acc_128B,               // llvm.hexagon.V6.vmpyihb.acc.128B
-    hexagon_V6_vmpyiowh,                       // llvm.hexagon.V6.vmpyiowh
-    hexagon_V6_vmpyiowh_128B,                  // llvm.hexagon.V6.vmpyiowh.128B
-    hexagon_V6_vmpyiwb,                        // llvm.hexagon.V6.vmpyiwb
-    hexagon_V6_vmpyiwb_128B,                   // llvm.hexagon.V6.vmpyiwb.128B
-    hexagon_V6_vmpyiwb_acc,                    // llvm.hexagon.V6.vmpyiwb.acc
-    hexagon_V6_vmpyiwb_acc_128B,               // llvm.hexagon.V6.vmpyiwb.acc.128B
-    hexagon_V6_vmpyiwh,                        // llvm.hexagon.V6.vmpyiwh
-    hexagon_V6_vmpyiwh_128B,                   // llvm.hexagon.V6.vmpyiwh.128B
-    hexagon_V6_vmpyiwh_acc,                    // llvm.hexagon.V6.vmpyiwh.acc
-    hexagon_V6_vmpyiwh_acc_128B,               // llvm.hexagon.V6.vmpyiwh.acc.128B
-    hexagon_V6_vmpyiwub,                       // llvm.hexagon.V6.vmpyiwub
-    hexagon_V6_vmpyiwub_128B,                  // llvm.hexagon.V6.vmpyiwub.128B
-    hexagon_V6_vmpyiwub_acc,                   // llvm.hexagon.V6.vmpyiwub.acc
-    hexagon_V6_vmpyiwub_acc_128B,              // llvm.hexagon.V6.vmpyiwub.acc.128B
-    hexagon_V6_vmpyowh,                        // llvm.hexagon.V6.vmpyowh
-    hexagon_V6_vmpyowh_128B,                   // llvm.hexagon.V6.vmpyowh.128B
-    hexagon_V6_vmpyowh_64_acc,                 // llvm.hexagon.V6.vmpyowh.64.acc
-    hexagon_V6_vmpyowh_64_acc_128B,            // llvm.hexagon.V6.vmpyowh.64.acc.128B
-    hexagon_V6_vmpyowh_rnd,                    // llvm.hexagon.V6.vmpyowh.rnd
-    hexagon_V6_vmpyowh_rnd_128B,               // llvm.hexagon.V6.vmpyowh.rnd.128B
-    hexagon_V6_vmpyowh_rnd_sacc,               // llvm.hexagon.V6.vmpyowh.rnd.sacc
-    hexagon_V6_vmpyowh_rnd_sacc_128B,          // llvm.hexagon.V6.vmpyowh.rnd.sacc.128B
-    hexagon_V6_vmpyowh_sacc,                   // llvm.hexagon.V6.vmpyowh.sacc
-    hexagon_V6_vmpyowh_sacc_128B,              // llvm.hexagon.V6.vmpyowh.sacc.128B
-    hexagon_V6_vmpyub,                         // llvm.hexagon.V6.vmpyub
-    hexagon_V6_vmpyub_128B,                    // llvm.hexagon.V6.vmpyub.128B
-    hexagon_V6_vmpyub_acc,                     // llvm.hexagon.V6.vmpyub.acc
-    hexagon_V6_vmpyub_acc_128B,                // llvm.hexagon.V6.vmpyub.acc.128B
-    hexagon_V6_vmpyubv,                        // llvm.hexagon.V6.vmpyubv
-    hexagon_V6_vmpyubv_128B,                   // llvm.hexagon.V6.vmpyubv.128B
-    hexagon_V6_vmpyubv_acc,                    // llvm.hexagon.V6.vmpyubv.acc
-    hexagon_V6_vmpyubv_acc_128B,               // llvm.hexagon.V6.vmpyubv.acc.128B
-    hexagon_V6_vmpyuh,                         // llvm.hexagon.V6.vmpyuh
-    hexagon_V6_vmpyuh_128B,                    // llvm.hexagon.V6.vmpyuh.128B
-    hexagon_V6_vmpyuh_acc,                     // llvm.hexagon.V6.vmpyuh.acc
-    hexagon_V6_vmpyuh_acc_128B,                // llvm.hexagon.V6.vmpyuh.acc.128B
-    hexagon_V6_vmpyuhe,                        // llvm.hexagon.V6.vmpyuhe
-    hexagon_V6_vmpyuhe_128B,                   // llvm.hexagon.V6.vmpyuhe.128B
-    hexagon_V6_vmpyuhe_acc,                    // llvm.hexagon.V6.vmpyuhe.acc
-    hexagon_V6_vmpyuhe_acc_128B,               // llvm.hexagon.V6.vmpyuhe.acc.128B
-    hexagon_V6_vmpyuhv,                        // llvm.hexagon.V6.vmpyuhv
-    hexagon_V6_vmpyuhv_128B,                   // llvm.hexagon.V6.vmpyuhv.128B
-    hexagon_V6_vmpyuhv_acc,                    // llvm.hexagon.V6.vmpyuhv.acc
-    hexagon_V6_vmpyuhv_acc_128B,               // llvm.hexagon.V6.vmpyuhv.acc.128B
-    hexagon_V6_vmux,                           // llvm.hexagon.V6.vmux
-    hexagon_V6_vmux_128B,                      // llvm.hexagon.V6.vmux.128B
-    hexagon_V6_vnavgb,                         // llvm.hexagon.V6.vnavgb
-    hexagon_V6_vnavgb_128B,                    // llvm.hexagon.V6.vnavgb.128B
-    hexagon_V6_vnavgh,                         // llvm.hexagon.V6.vnavgh
-    hexagon_V6_vnavgh_128B,                    // llvm.hexagon.V6.vnavgh.128B
-    hexagon_V6_vnavgub,                        // llvm.hexagon.V6.vnavgub
-    hexagon_V6_vnavgub_128B,                   // llvm.hexagon.V6.vnavgub.128B
-    hexagon_V6_vnavgw,                         // llvm.hexagon.V6.vnavgw
-    hexagon_V6_vnavgw_128B,                    // llvm.hexagon.V6.vnavgw.128B
-    hexagon_V6_vnormamth,                      // llvm.hexagon.V6.vnormamth
-    hexagon_V6_vnormamth_128B,                 // llvm.hexagon.V6.vnormamth.128B
-    hexagon_V6_vnormamtw,                      // llvm.hexagon.V6.vnormamtw
-    hexagon_V6_vnormamtw_128B,                 // llvm.hexagon.V6.vnormamtw.128B
-    hexagon_V6_vnot,                           // llvm.hexagon.V6.vnot
-    hexagon_V6_vnot_128B,                      // llvm.hexagon.V6.vnot.128B
-    hexagon_V6_vor,                            // llvm.hexagon.V6.vor
-    hexagon_V6_vor_128B,                       // llvm.hexagon.V6.vor.128B
-    hexagon_V6_vpackeb,                        // llvm.hexagon.V6.vpackeb
-    hexagon_V6_vpackeb_128B,                   // llvm.hexagon.V6.vpackeb.128B
-    hexagon_V6_vpackeh,                        // llvm.hexagon.V6.vpackeh
-    hexagon_V6_vpackeh_128B,                   // llvm.hexagon.V6.vpackeh.128B
-    hexagon_V6_vpackhb_sat,                    // llvm.hexagon.V6.vpackhb.sat
-    hexagon_V6_vpackhb_sat_128B,               // llvm.hexagon.V6.vpackhb.sat.128B
-    hexagon_V6_vpackhub_sat,                   // llvm.hexagon.V6.vpackhub.sat
-    hexagon_V6_vpackhub_sat_128B,              // llvm.hexagon.V6.vpackhub.sat.128B
-    hexagon_V6_vpackob,                        // llvm.hexagon.V6.vpackob
-    hexagon_V6_vpackob_128B,                   // llvm.hexagon.V6.vpackob.128B
-    hexagon_V6_vpackoh,                        // llvm.hexagon.V6.vpackoh
-    hexagon_V6_vpackoh_128B,                   // llvm.hexagon.V6.vpackoh.128B
-    hexagon_V6_vpackwh_sat,                    // llvm.hexagon.V6.vpackwh.sat
-    hexagon_V6_vpackwh_sat_128B,               // llvm.hexagon.V6.vpackwh.sat.128B
-    hexagon_V6_vpackwuh_sat,                   // llvm.hexagon.V6.vpackwuh.sat
-    hexagon_V6_vpackwuh_sat_128B,              // llvm.hexagon.V6.vpackwuh.sat.128B
-    hexagon_V6_vpopcounth,                     // llvm.hexagon.V6.vpopcounth
-    hexagon_V6_vpopcounth_128B,                // llvm.hexagon.V6.vpopcounth.128B
-    hexagon_V6_vprefixqb,                      // llvm.hexagon.V6.vprefixqb
-    hexagon_V6_vprefixqb_128B,                 // llvm.hexagon.V6.vprefixqb.128B
-    hexagon_V6_vprefixqh,                      // llvm.hexagon.V6.vprefixqh
-    hexagon_V6_vprefixqh_128B,                 // llvm.hexagon.V6.vprefixqh.128B
-    hexagon_V6_vprefixqw,                      // llvm.hexagon.V6.vprefixqw
-    hexagon_V6_vprefixqw_128B,                 // llvm.hexagon.V6.vprefixqw.128B
-    hexagon_V6_vrdelta,                        // llvm.hexagon.V6.vrdelta
-    hexagon_V6_vrdelta_128B,                   // llvm.hexagon.V6.vrdelta.128B
-    hexagon_V6_vrmpybub_rtt,                   // llvm.hexagon.V6.vrmpybub.rtt
-    hexagon_V6_vrmpybub_rtt_128B,              // llvm.hexagon.V6.vrmpybub.rtt.128B
-    hexagon_V6_vrmpybub_rtt_acc,               // llvm.hexagon.V6.vrmpybub.rtt.acc
-    hexagon_V6_vrmpybub_rtt_acc_128B,          // llvm.hexagon.V6.vrmpybub.rtt.acc.128B
-    hexagon_V6_vrmpybus,                       // llvm.hexagon.V6.vrmpybus
-    hexagon_V6_vrmpybus_128B,                  // llvm.hexagon.V6.vrmpybus.128B
-    hexagon_V6_vrmpybus_acc,                   // llvm.hexagon.V6.vrmpybus.acc
-    hexagon_V6_vrmpybus_acc_128B,              // llvm.hexagon.V6.vrmpybus.acc.128B
-    hexagon_V6_vrmpybusi,                      // llvm.hexagon.V6.vrmpybusi
-    hexagon_V6_vrmpybusi_128B,                 // llvm.hexagon.V6.vrmpybusi.128B
-    hexagon_V6_vrmpybusi_acc,                  // llvm.hexagon.V6.vrmpybusi.acc
-    hexagon_V6_vrmpybusi_acc_128B,             // llvm.hexagon.V6.vrmpybusi.acc.128B
-    hexagon_V6_vrmpybusv,                      // llvm.hexagon.V6.vrmpybusv
-    hexagon_V6_vrmpybusv_128B,                 // llvm.hexagon.V6.vrmpybusv.128B
-    hexagon_V6_vrmpybusv_acc,                  // llvm.hexagon.V6.vrmpybusv.acc
-    hexagon_V6_vrmpybusv_acc_128B,             // llvm.hexagon.V6.vrmpybusv.acc.128B
-    hexagon_V6_vrmpybv,                        // llvm.hexagon.V6.vrmpybv
-    hexagon_V6_vrmpybv_128B,                   // llvm.hexagon.V6.vrmpybv.128B
-    hexagon_V6_vrmpybv_acc,                    // llvm.hexagon.V6.vrmpybv.acc
-    hexagon_V6_vrmpybv_acc_128B,               // llvm.hexagon.V6.vrmpybv.acc.128B
-    hexagon_V6_vrmpyub,                        // llvm.hexagon.V6.vrmpyub
-    hexagon_V6_vrmpyub_128B,                   // llvm.hexagon.V6.vrmpyub.128B
-    hexagon_V6_vrmpyub_acc,                    // llvm.hexagon.V6.vrmpyub.acc
-    hexagon_V6_vrmpyub_acc_128B,               // llvm.hexagon.V6.vrmpyub.acc.128B
-    hexagon_V6_vrmpyub_rtt,                    // llvm.hexagon.V6.vrmpyub.rtt
-    hexagon_V6_vrmpyub_rtt_128B,               // llvm.hexagon.V6.vrmpyub.rtt.128B
-    hexagon_V6_vrmpyub_rtt_acc,                // llvm.hexagon.V6.vrmpyub.rtt.acc
-    hexagon_V6_vrmpyub_rtt_acc_128B,           // llvm.hexagon.V6.vrmpyub.rtt.acc.128B
-    hexagon_V6_vrmpyubi,                       // llvm.hexagon.V6.vrmpyubi
-    hexagon_V6_vrmpyubi_128B,                  // llvm.hexagon.V6.vrmpyubi.128B
-    hexagon_V6_vrmpyubi_acc,                   // llvm.hexagon.V6.vrmpyubi.acc
-    hexagon_V6_vrmpyubi_acc_128B,              // llvm.hexagon.V6.vrmpyubi.acc.128B
-    hexagon_V6_vrmpyubv,                       // llvm.hexagon.V6.vrmpyubv
-    hexagon_V6_vrmpyubv_128B,                  // llvm.hexagon.V6.vrmpyubv.128B
-    hexagon_V6_vrmpyubv_acc,                   // llvm.hexagon.V6.vrmpyubv.acc
-    hexagon_V6_vrmpyubv_acc_128B,              // llvm.hexagon.V6.vrmpyubv.acc.128B
-    hexagon_V6_vror,                           // llvm.hexagon.V6.vror
-    hexagon_V6_vror_128B,                      // llvm.hexagon.V6.vror.128B
-    hexagon_V6_vrotr,                          // llvm.hexagon.V6.vrotr
-    hexagon_V6_vrotr_128B,                     // llvm.hexagon.V6.vrotr.128B
-    hexagon_V6_vroundhb,                       // llvm.hexagon.V6.vroundhb
-    hexagon_V6_vroundhb_128B,                  // llvm.hexagon.V6.vroundhb.128B
-    hexagon_V6_vroundhub,                      // llvm.hexagon.V6.vroundhub
-    hexagon_V6_vroundhub_128B,                 // llvm.hexagon.V6.vroundhub.128B
-    hexagon_V6_vrounduhub,                     // llvm.hexagon.V6.vrounduhub
-    hexagon_V6_vrounduhub_128B,                // llvm.hexagon.V6.vrounduhub.128B
-    hexagon_V6_vrounduwuh,                     // llvm.hexagon.V6.vrounduwuh
-    hexagon_V6_vrounduwuh_128B,                // llvm.hexagon.V6.vrounduwuh.128B
-    hexagon_V6_vroundwh,                       // llvm.hexagon.V6.vroundwh
-    hexagon_V6_vroundwh_128B,                  // llvm.hexagon.V6.vroundwh.128B
-    hexagon_V6_vroundwuh,                      // llvm.hexagon.V6.vroundwuh
-    hexagon_V6_vroundwuh_128B,                 // llvm.hexagon.V6.vroundwuh.128B
-    hexagon_V6_vrsadubi,                       // llvm.hexagon.V6.vrsadubi
-    hexagon_V6_vrsadubi_128B,                  // llvm.hexagon.V6.vrsadubi.128B
-    hexagon_V6_vrsadubi_acc,                   // llvm.hexagon.V6.vrsadubi.acc
-    hexagon_V6_vrsadubi_acc_128B,              // llvm.hexagon.V6.vrsadubi.acc.128B
-    hexagon_V6_vsatdw,                         // llvm.hexagon.V6.vsatdw
-    hexagon_V6_vsatdw_128B,                    // llvm.hexagon.V6.vsatdw.128B
-    hexagon_V6_vsathub,                        // llvm.hexagon.V6.vsathub
-    hexagon_V6_vsathub_128B,                   // llvm.hexagon.V6.vsathub.128B
-    hexagon_V6_vsatuwuh,                       // llvm.hexagon.V6.vsatuwuh
-    hexagon_V6_vsatuwuh_128B,                  // llvm.hexagon.V6.vsatuwuh.128B
-    hexagon_V6_vsatwh,                         // llvm.hexagon.V6.vsatwh
-    hexagon_V6_vsatwh_128B,                    // llvm.hexagon.V6.vsatwh.128B
-    hexagon_V6_vsb,                            // llvm.hexagon.V6.vsb
-    hexagon_V6_vsb_128B,                       // llvm.hexagon.V6.vsb.128B
-    hexagon_V6_vscattermh,                     // llvm.hexagon.V6.vscattermh
-    hexagon_V6_vscattermh_128B,                // llvm.hexagon.V6.vscattermh.128B
-    hexagon_V6_vscattermh_add,                 // llvm.hexagon.V6.vscattermh.add
-    hexagon_V6_vscattermh_add_128B,            // llvm.hexagon.V6.vscattermh.add.128B
-    hexagon_V6_vscattermhq,                    // llvm.hexagon.V6.vscattermhq
-    hexagon_V6_vscattermhq_128B,               // llvm.hexagon.V6.vscattermhq.128B
-    hexagon_V6_vscattermhw,                    // llvm.hexagon.V6.vscattermhw
-    hexagon_V6_vscattermhw_128B,               // llvm.hexagon.V6.vscattermhw.128B
-    hexagon_V6_vscattermhw_add,                // llvm.hexagon.V6.vscattermhw.add
-    hexagon_V6_vscattermhw_add_128B,           // llvm.hexagon.V6.vscattermhw.add.128B
-    hexagon_V6_vscattermhwq,                   // llvm.hexagon.V6.vscattermhwq
-    hexagon_V6_vscattermhwq_128B,              // llvm.hexagon.V6.vscattermhwq.128B
-    hexagon_V6_vscattermw,                     // llvm.hexagon.V6.vscattermw
-    hexagon_V6_vscattermw_128B,                // llvm.hexagon.V6.vscattermw.128B
-    hexagon_V6_vscattermw_add,                 // llvm.hexagon.V6.vscattermw.add
-    hexagon_V6_vscattermw_add_128B,            // llvm.hexagon.V6.vscattermw.add.128B
-    hexagon_V6_vscattermwq,                    // llvm.hexagon.V6.vscattermwq
-    hexagon_V6_vscattermwq_128B,               // llvm.hexagon.V6.vscattermwq.128B
-    hexagon_V6_vsh,                            // llvm.hexagon.V6.vsh
-    hexagon_V6_vsh_128B,                       // llvm.hexagon.V6.vsh.128B
-    hexagon_V6_vshufeh,                        // llvm.hexagon.V6.vshufeh
-    hexagon_V6_vshufeh_128B,                   // llvm.hexagon.V6.vshufeh.128B
-    hexagon_V6_vshuffb,                        // llvm.hexagon.V6.vshuffb
-    hexagon_V6_vshuffb_128B,                   // llvm.hexagon.V6.vshuffb.128B
-    hexagon_V6_vshuffeb,                       // llvm.hexagon.V6.vshuffeb
-    hexagon_V6_vshuffeb_128B,                  // llvm.hexagon.V6.vshuffeb.128B
-    hexagon_V6_vshuffh,                        // llvm.hexagon.V6.vshuffh
-    hexagon_V6_vshuffh_128B,                   // llvm.hexagon.V6.vshuffh.128B
-    hexagon_V6_vshuffob,                       // llvm.hexagon.V6.vshuffob
-    hexagon_V6_vshuffob_128B,                  // llvm.hexagon.V6.vshuffob.128B
-    hexagon_V6_vshuffvdd,                      // llvm.hexagon.V6.vshuffvdd
-    hexagon_V6_vshuffvdd_128B,                 // llvm.hexagon.V6.vshuffvdd.128B
-    hexagon_V6_vshufoeb,                       // llvm.hexagon.V6.vshufoeb
-    hexagon_V6_vshufoeb_128B,                  // llvm.hexagon.V6.vshufoeb.128B
-    hexagon_V6_vshufoeh,                       // llvm.hexagon.V6.vshufoeh
-    hexagon_V6_vshufoeh_128B,                  // llvm.hexagon.V6.vshufoeh.128B
-    hexagon_V6_vshufoh,                        // llvm.hexagon.V6.vshufoh
-    hexagon_V6_vshufoh_128B,                   // llvm.hexagon.V6.vshufoh.128B
-    hexagon_V6_vsubb,                          // llvm.hexagon.V6.vsubb
-    hexagon_V6_vsubb_128B,                     // llvm.hexagon.V6.vsubb.128B
-    hexagon_V6_vsubb_dv,                       // llvm.hexagon.V6.vsubb.dv
-    hexagon_V6_vsubb_dv_128B,                  // llvm.hexagon.V6.vsubb.dv.128B
-    hexagon_V6_vsubbnq,                        // llvm.hexagon.V6.vsubbnq
-    hexagon_V6_vsubbnq_128B,                   // llvm.hexagon.V6.vsubbnq.128B
-    hexagon_V6_vsubbq,                         // llvm.hexagon.V6.vsubbq
-    hexagon_V6_vsubbq_128B,                    // llvm.hexagon.V6.vsubbq.128B
-    hexagon_V6_vsubbsat,                       // llvm.hexagon.V6.vsubbsat
-    hexagon_V6_vsubbsat_128B,                  // llvm.hexagon.V6.vsubbsat.128B
-    hexagon_V6_vsubbsat_dv,                    // llvm.hexagon.V6.vsubbsat.dv
-    hexagon_V6_vsubbsat_dv_128B,               // llvm.hexagon.V6.vsubbsat.dv.128B
-    hexagon_V6_vsubcarry,                      // llvm.hexagon.V6.vsubcarry
-    hexagon_V6_vsubcarry_128B,                 // llvm.hexagon.V6.vsubcarry.128B
-    hexagon_V6_vsubh,                          // llvm.hexagon.V6.vsubh
-    hexagon_V6_vsubh_128B,                     // llvm.hexagon.V6.vsubh.128B
-    hexagon_V6_vsubh_dv,                       // llvm.hexagon.V6.vsubh.dv
-    hexagon_V6_vsubh_dv_128B,                  // llvm.hexagon.V6.vsubh.dv.128B
-    hexagon_V6_vsubhnq,                        // llvm.hexagon.V6.vsubhnq
-    hexagon_V6_vsubhnq_128B,                   // llvm.hexagon.V6.vsubhnq.128B
-    hexagon_V6_vsubhq,                         // llvm.hexagon.V6.vsubhq
-    hexagon_V6_vsubhq_128B,                    // llvm.hexagon.V6.vsubhq.128B
-    hexagon_V6_vsubhsat,                       // llvm.hexagon.V6.vsubhsat
-    hexagon_V6_vsubhsat_128B,                  // llvm.hexagon.V6.vsubhsat.128B
-    hexagon_V6_vsubhsat_dv,                    // llvm.hexagon.V6.vsubhsat.dv
-    hexagon_V6_vsubhsat_dv_128B,               // llvm.hexagon.V6.vsubhsat.dv.128B
-    hexagon_V6_vsubhw,                         // llvm.hexagon.V6.vsubhw
-    hexagon_V6_vsubhw_128B,                    // llvm.hexagon.V6.vsubhw.128B
-    hexagon_V6_vsububh,                        // llvm.hexagon.V6.vsububh
-    hexagon_V6_vsububh_128B,                   // llvm.hexagon.V6.vsububh.128B
-    hexagon_V6_vsububsat,                      // llvm.hexagon.V6.vsububsat
-    hexagon_V6_vsububsat_128B,                 // llvm.hexagon.V6.vsububsat.128B
-    hexagon_V6_vsububsat_dv,                   // llvm.hexagon.V6.vsububsat.dv
-    hexagon_V6_vsububsat_dv_128B,              // llvm.hexagon.V6.vsububsat.dv.128B
-    hexagon_V6_vsubububb_sat,                  // llvm.hexagon.V6.vsubububb.sat
-    hexagon_V6_vsubububb_sat_128B,             // llvm.hexagon.V6.vsubububb.sat.128B
-    hexagon_V6_vsubuhsat,                      // llvm.hexagon.V6.vsubuhsat
-    hexagon_V6_vsubuhsat_128B,                 // llvm.hexagon.V6.vsubuhsat.128B
-    hexagon_V6_vsubuhsat_dv,                   // llvm.hexagon.V6.vsubuhsat.dv
-    hexagon_V6_vsubuhsat_dv_128B,              // llvm.hexagon.V6.vsubuhsat.dv.128B
-    hexagon_V6_vsubuhw,                        // llvm.hexagon.V6.vsubuhw
-    hexagon_V6_vsubuhw_128B,                   // llvm.hexagon.V6.vsubuhw.128B
-    hexagon_V6_vsubuwsat,                      // llvm.hexagon.V6.vsubuwsat
-    hexagon_V6_vsubuwsat_128B,                 // llvm.hexagon.V6.vsubuwsat.128B
-    hexagon_V6_vsubuwsat_dv,                   // llvm.hexagon.V6.vsubuwsat.dv
-    hexagon_V6_vsubuwsat_dv_128B,              // llvm.hexagon.V6.vsubuwsat.dv.128B
-    hexagon_V6_vsubw,                          // llvm.hexagon.V6.vsubw
-    hexagon_V6_vsubw_128B,                     // llvm.hexagon.V6.vsubw.128B
-    hexagon_V6_vsubw_dv,                       // llvm.hexagon.V6.vsubw.dv
-    hexagon_V6_vsubw_dv_128B,                  // llvm.hexagon.V6.vsubw.dv.128B
-    hexagon_V6_vsubwnq,                        // llvm.hexagon.V6.vsubwnq
-    hexagon_V6_vsubwnq_128B,                   // llvm.hexagon.V6.vsubwnq.128B
-    hexagon_V6_vsubwq,                         // llvm.hexagon.V6.vsubwq
-    hexagon_V6_vsubwq_128B,                    // llvm.hexagon.V6.vsubwq.128B
-    hexagon_V6_vsubwsat,                       // llvm.hexagon.V6.vsubwsat
-    hexagon_V6_vsubwsat_128B,                  // llvm.hexagon.V6.vsubwsat.128B
-    hexagon_V6_vsubwsat_dv,                    // llvm.hexagon.V6.vsubwsat.dv
-    hexagon_V6_vsubwsat_dv_128B,               // llvm.hexagon.V6.vsubwsat.dv.128B
-    hexagon_V6_vswap,                          // llvm.hexagon.V6.vswap
-    hexagon_V6_vswap_128B,                     // llvm.hexagon.V6.vswap.128B
-    hexagon_V6_vtmpyb,                         // llvm.hexagon.V6.vtmpyb
-    hexagon_V6_vtmpyb_128B,                    // llvm.hexagon.V6.vtmpyb.128B
-    hexagon_V6_vtmpyb_acc,                     // llvm.hexagon.V6.vtmpyb.acc
-    hexagon_V6_vtmpyb_acc_128B,                // llvm.hexagon.V6.vtmpyb.acc.128B
-    hexagon_V6_vtmpybus,                       // llvm.hexagon.V6.vtmpybus
-    hexagon_V6_vtmpybus_128B,                  // llvm.hexagon.V6.vtmpybus.128B
-    hexagon_V6_vtmpybus_acc,                   // llvm.hexagon.V6.vtmpybus.acc
-    hexagon_V6_vtmpybus_acc_128B,              // llvm.hexagon.V6.vtmpybus.acc.128B
-    hexagon_V6_vtmpyhb,                        // llvm.hexagon.V6.vtmpyhb
-    hexagon_V6_vtmpyhb_128B,                   // llvm.hexagon.V6.vtmpyhb.128B
-    hexagon_V6_vtmpyhb_acc,                    // llvm.hexagon.V6.vtmpyhb.acc
-    hexagon_V6_vtmpyhb_acc_128B,               // llvm.hexagon.V6.vtmpyhb.acc.128B
-    hexagon_V6_vtran2x2_map,                   // llvm.hexagon.V6.vtran2x2.map
-    hexagon_V6_vtran2x2_map_128B,              // llvm.hexagon.V6.vtran2x2.map.128B
-    hexagon_V6_vunpackb,                       // llvm.hexagon.V6.vunpackb
-    hexagon_V6_vunpackb_128B,                  // llvm.hexagon.V6.vunpackb.128B
-    hexagon_V6_vunpackh,                       // llvm.hexagon.V6.vunpackh
-    hexagon_V6_vunpackh_128B,                  // llvm.hexagon.V6.vunpackh.128B
-    hexagon_V6_vunpackob,                      // llvm.hexagon.V6.vunpackob
-    hexagon_V6_vunpackob_128B,                 // llvm.hexagon.V6.vunpackob.128B
-    hexagon_V6_vunpackoh,                      // llvm.hexagon.V6.vunpackoh
-    hexagon_V6_vunpackoh_128B,                 // llvm.hexagon.V6.vunpackoh.128B
-    hexagon_V6_vunpackub,                      // llvm.hexagon.V6.vunpackub
-    hexagon_V6_vunpackub_128B,                 // llvm.hexagon.V6.vunpackub.128B
-    hexagon_V6_vunpackuh,                      // llvm.hexagon.V6.vunpackuh
-    hexagon_V6_vunpackuh_128B,                 // llvm.hexagon.V6.vunpackuh.128B
-    hexagon_V6_vxor,                           // llvm.hexagon.V6.vxor
-    hexagon_V6_vxor_128B,                      // llvm.hexagon.V6.vxor.128B
-    hexagon_V6_vzb,                            // llvm.hexagon.V6.vzb
-    hexagon_V6_vzb_128B,                       // llvm.hexagon.V6.vzb.128B
-    hexagon_V6_vzh,                            // llvm.hexagon.V6.vzh
-    hexagon_V6_vzh_128B,                       // llvm.hexagon.V6.vzh.128B
-    hexagon_Y2_dccleana,                       // llvm.hexagon.Y2.dccleana
-    hexagon_Y2_dccleaninva,                    // llvm.hexagon.Y2.dccleaninva
-    hexagon_Y2_dcinva,                         // llvm.hexagon.Y2.dcinva
-    hexagon_Y2_dczeroa,                        // llvm.hexagon.Y2.dczeroa
-    hexagon_Y4_l2fetch,                        // llvm.hexagon.Y4.l2fetch
-    hexagon_Y5_l2fetch,                        // llvm.hexagon.Y5.l2fetch
-    hexagon_circ_ldb,                          // llvm.hexagon.circ.ldb
-    hexagon_circ_ldd,                          // llvm.hexagon.circ.ldd
-    hexagon_circ_ldh,                          // llvm.hexagon.circ.ldh
-    hexagon_circ_ldub,                         // llvm.hexagon.circ.ldub
-    hexagon_circ_lduh,                         // llvm.hexagon.circ.lduh
-    hexagon_circ_ldw,                          // llvm.hexagon.circ.ldw
-    hexagon_circ_stb,                          // llvm.hexagon.circ.stb
-    hexagon_circ_std,                          // llvm.hexagon.circ.std
-    hexagon_circ_sth,                          // llvm.hexagon.circ.sth
-    hexagon_circ_sthhi,                        // llvm.hexagon.circ.sthhi
-    hexagon_circ_stw,                          // llvm.hexagon.circ.stw
-    hexagon_prefetch,                          // llvm.hexagon.prefetch
-    hexagon_vmemcpy,                           // llvm.hexagon.vmemcpy
-    hexagon_vmemset,                           // llvm.hexagon.vmemset
-    mips_absq_s_ph,                            // llvm.mips.absq.s.ph
-    mips_absq_s_qb,                            // llvm.mips.absq.s.qb
-    mips_absq_s_w,                             // llvm.mips.absq.s.w
-    mips_add_a_b,                              // llvm.mips.add.a.b
-    mips_add_a_d,                              // llvm.mips.add.a.d
-    mips_add_a_h,                              // llvm.mips.add.a.h
-    mips_add_a_w,                              // llvm.mips.add.a.w
-    mips_addq_ph,                              // llvm.mips.addq.ph
-    mips_addq_s_ph,                            // llvm.mips.addq.s.ph
-    mips_addq_s_w,                             // llvm.mips.addq.s.w
-    mips_addqh_ph,                             // llvm.mips.addqh.ph
-    mips_addqh_r_ph,                           // llvm.mips.addqh.r.ph
-    mips_addqh_r_w,                            // llvm.mips.addqh.r.w
-    mips_addqh_w,                              // llvm.mips.addqh.w
-    mips_adds_a_b,                             // llvm.mips.adds.a.b
-    mips_adds_a_d,                             // llvm.mips.adds.a.d
-    mips_adds_a_h,                             // llvm.mips.adds.a.h
-    mips_adds_a_w,                             // llvm.mips.adds.a.w
-    mips_adds_s_b,                             // llvm.mips.adds.s.b
-    mips_adds_s_d,                             // llvm.mips.adds.s.d
-    mips_adds_s_h,                             // llvm.mips.adds.s.h
-    mips_adds_s_w,                             // llvm.mips.adds.s.w
-    mips_adds_u_b,                             // llvm.mips.adds.u.b
-    mips_adds_u_d,                             // llvm.mips.adds.u.d
-    mips_adds_u_h,                             // llvm.mips.adds.u.h
-    mips_adds_u_w,                             // llvm.mips.adds.u.w
-    mips_addsc,                                // llvm.mips.addsc
-    mips_addu_ph,                              // llvm.mips.addu.ph
-    mips_addu_qb,                              // llvm.mips.addu.qb
-    mips_addu_s_ph,                            // llvm.mips.addu.s.ph
-    mips_addu_s_qb,                            // llvm.mips.addu.s.qb
-    mips_adduh_qb,                             // llvm.mips.adduh.qb
-    mips_adduh_r_qb,                           // llvm.mips.adduh.r.qb
-    mips_addv_b,                               // llvm.mips.addv.b
-    mips_addv_d,                               // llvm.mips.addv.d
-    mips_addv_h,                               // llvm.mips.addv.h
-    mips_addv_w,                               // llvm.mips.addv.w
-    mips_addvi_b,                              // llvm.mips.addvi.b
-    mips_addvi_d,                              // llvm.mips.addvi.d
-    mips_addvi_h,                              // llvm.mips.addvi.h
-    mips_addvi_w,                              // llvm.mips.addvi.w
-    mips_addwc,                                // llvm.mips.addwc
-    mips_and_v,                                // llvm.mips.and.v
-    mips_andi_b,                               // llvm.mips.andi.b
-    mips_append,                               // llvm.mips.append
-    mips_asub_s_b,                             // llvm.mips.asub.s.b
-    mips_asub_s_d,                             // llvm.mips.asub.s.d
-    mips_asub_s_h,                             // llvm.mips.asub.s.h
-    mips_asub_s_w,                             // llvm.mips.asub.s.w
-    mips_asub_u_b,                             // llvm.mips.asub.u.b
-    mips_asub_u_d,                             // llvm.mips.asub.u.d
-    mips_asub_u_h,                             // llvm.mips.asub.u.h
-    mips_asub_u_w,                             // llvm.mips.asub.u.w
-    mips_ave_s_b,                              // llvm.mips.ave.s.b
-    mips_ave_s_d,                              // llvm.mips.ave.s.d
-    mips_ave_s_h,                              // llvm.mips.ave.s.h
-    mips_ave_s_w,                              // llvm.mips.ave.s.w
-    mips_ave_u_b,                              // llvm.mips.ave.u.b
-    mips_ave_u_d,                              // llvm.mips.ave.u.d
-    mips_ave_u_h,                              // llvm.mips.ave.u.h
-    mips_ave_u_w,                              // llvm.mips.ave.u.w
-    mips_aver_s_b,                             // llvm.mips.aver.s.b
-    mips_aver_s_d,                             // llvm.mips.aver.s.d
-    mips_aver_s_h,                             // llvm.mips.aver.s.h
-    mips_aver_s_w,                             // llvm.mips.aver.s.w
-    mips_aver_u_b,                             // llvm.mips.aver.u.b
-    mips_aver_u_d,                             // llvm.mips.aver.u.d
-    mips_aver_u_h,                             // llvm.mips.aver.u.h
-    mips_aver_u_w,                             // llvm.mips.aver.u.w
-    mips_balign,                               // llvm.mips.balign
-    mips_bclr_b,                               // llvm.mips.bclr.b
-    mips_bclr_d,                               // llvm.mips.bclr.d
-    mips_bclr_h,                               // llvm.mips.bclr.h
-    mips_bclr_w,                               // llvm.mips.bclr.w
-    mips_bclri_b,                              // llvm.mips.bclri.b
-    mips_bclri_d,                              // llvm.mips.bclri.d
-    mips_bclri_h,                              // llvm.mips.bclri.h
-    mips_bclri_w,                              // llvm.mips.bclri.w
-    mips_binsl_b,                              // llvm.mips.binsl.b
-    mips_binsl_d,                              // llvm.mips.binsl.d
-    mips_binsl_h,                              // llvm.mips.binsl.h
-    mips_binsl_w,                              // llvm.mips.binsl.w
-    mips_binsli_b,                             // llvm.mips.binsli.b
-    mips_binsli_d,                             // llvm.mips.binsli.d
-    mips_binsli_h,                             // llvm.mips.binsli.h
-    mips_binsli_w,                             // llvm.mips.binsli.w
-    mips_binsr_b,                              // llvm.mips.binsr.b
-    mips_binsr_d,                              // llvm.mips.binsr.d
-    mips_binsr_h,                              // llvm.mips.binsr.h
-    mips_binsr_w,                              // llvm.mips.binsr.w
-    mips_binsri_b,                             // llvm.mips.binsri.b
-    mips_binsri_d,                             // llvm.mips.binsri.d
-    mips_binsri_h,                             // llvm.mips.binsri.h
-    mips_binsri_w,                             // llvm.mips.binsri.w
-    mips_bitrev,                               // llvm.mips.bitrev
-    mips_bmnz_v,                               // llvm.mips.bmnz.v
-    mips_bmnzi_b,                              // llvm.mips.bmnzi.b
-    mips_bmz_v,                                // llvm.mips.bmz.v
-    mips_bmzi_b,                               // llvm.mips.bmzi.b
-    mips_bneg_b,                               // llvm.mips.bneg.b
-    mips_bneg_d,                               // llvm.mips.bneg.d
-    mips_bneg_h,                               // llvm.mips.bneg.h
-    mips_bneg_w,                               // llvm.mips.bneg.w
-    mips_bnegi_b,                              // llvm.mips.bnegi.b
-    mips_bnegi_d,                              // llvm.mips.bnegi.d
-    mips_bnegi_h,                              // llvm.mips.bnegi.h
-    mips_bnegi_w,                              // llvm.mips.bnegi.w
-    mips_bnz_b,                                // llvm.mips.bnz.b
-    mips_bnz_d,                                // llvm.mips.bnz.d
-    mips_bnz_h,                                // llvm.mips.bnz.h
-    mips_bnz_v,                                // llvm.mips.bnz.v
-    mips_bnz_w,                                // llvm.mips.bnz.w
-    mips_bposge32,                             // llvm.mips.bposge32
-    mips_bsel_v,                               // llvm.mips.bsel.v
-    mips_bseli_b,                              // llvm.mips.bseli.b
-    mips_bset_b,                               // llvm.mips.bset.b
-    mips_bset_d,                               // llvm.mips.bset.d
-    mips_bset_h,                               // llvm.mips.bset.h
-    mips_bset_w,                               // llvm.mips.bset.w
-    mips_bseti_b,                              // llvm.mips.bseti.b
-    mips_bseti_d,                              // llvm.mips.bseti.d
-    mips_bseti_h,                              // llvm.mips.bseti.h
-    mips_bseti_w,                              // llvm.mips.bseti.w
-    mips_bz_b,                                 // llvm.mips.bz.b
-    mips_bz_d,                                 // llvm.mips.bz.d
-    mips_bz_h,                                 // llvm.mips.bz.h
-    mips_bz_v,                                 // llvm.mips.bz.v
-    mips_bz_w,                                 // llvm.mips.bz.w
-    mips_ceq_b,                                // llvm.mips.ceq.b
-    mips_ceq_d,                                // llvm.mips.ceq.d
-    mips_ceq_h,                                // llvm.mips.ceq.h
-    mips_ceq_w,                                // llvm.mips.ceq.w
-    mips_ceqi_b,                               // llvm.mips.ceqi.b
-    mips_ceqi_d,                               // llvm.mips.ceqi.d
-    mips_ceqi_h,                               // llvm.mips.ceqi.h
-    mips_ceqi_w,                               // llvm.mips.ceqi.w
-    mips_cfcmsa,                               // llvm.mips.cfcmsa
-    mips_cle_s_b,                              // llvm.mips.cle.s.b
-    mips_cle_s_d,                              // llvm.mips.cle.s.d
-    mips_cle_s_h,                              // llvm.mips.cle.s.h
-    mips_cle_s_w,                              // llvm.mips.cle.s.w
-    mips_cle_u_b,                              // llvm.mips.cle.u.b
-    mips_cle_u_d,                              // llvm.mips.cle.u.d
-    mips_cle_u_h,                              // llvm.mips.cle.u.h
-    mips_cle_u_w,                              // llvm.mips.cle.u.w
-    mips_clei_s_b,                             // llvm.mips.clei.s.b
-    mips_clei_s_d,                             // llvm.mips.clei.s.d
-    mips_clei_s_h,                             // llvm.mips.clei.s.h
-    mips_clei_s_w,                             // llvm.mips.clei.s.w
-    mips_clei_u_b,                             // llvm.mips.clei.u.b
-    mips_clei_u_d,                             // llvm.mips.clei.u.d
-    mips_clei_u_h,                             // llvm.mips.clei.u.h
-    mips_clei_u_w,                             // llvm.mips.clei.u.w
-    mips_clt_s_b,                              // llvm.mips.clt.s.b
-    mips_clt_s_d,                              // llvm.mips.clt.s.d
-    mips_clt_s_h,                              // llvm.mips.clt.s.h
-    mips_clt_s_w,                              // llvm.mips.clt.s.w
-    mips_clt_u_b,                              // llvm.mips.clt.u.b
-    mips_clt_u_d,                              // llvm.mips.clt.u.d
-    mips_clt_u_h,                              // llvm.mips.clt.u.h
-    mips_clt_u_w,                              // llvm.mips.clt.u.w
-    mips_clti_s_b,                             // llvm.mips.clti.s.b
-    mips_clti_s_d,                             // llvm.mips.clti.s.d
-    mips_clti_s_h,                             // llvm.mips.clti.s.h
-    mips_clti_s_w,                             // llvm.mips.clti.s.w
-    mips_clti_u_b,                             // llvm.mips.clti.u.b
-    mips_clti_u_d,                             // llvm.mips.clti.u.d
-    mips_clti_u_h,                             // llvm.mips.clti.u.h
-    mips_clti_u_w,                             // llvm.mips.clti.u.w
-    mips_cmp_eq_ph,                            // llvm.mips.cmp.eq.ph
-    mips_cmp_le_ph,                            // llvm.mips.cmp.le.ph
-    mips_cmp_lt_ph,                            // llvm.mips.cmp.lt.ph
-    mips_cmpgdu_eq_qb,                         // llvm.mips.cmpgdu.eq.qb
-    mips_cmpgdu_le_qb,                         // llvm.mips.cmpgdu.le.qb
-    mips_cmpgdu_lt_qb,                         // llvm.mips.cmpgdu.lt.qb
-    mips_cmpgu_eq_qb,                          // llvm.mips.cmpgu.eq.qb
-    mips_cmpgu_le_qb,                          // llvm.mips.cmpgu.le.qb
-    mips_cmpgu_lt_qb,                          // llvm.mips.cmpgu.lt.qb
-    mips_cmpu_eq_qb,                           // llvm.mips.cmpu.eq.qb
-    mips_cmpu_le_qb,                           // llvm.mips.cmpu.le.qb
-    mips_cmpu_lt_qb,                           // llvm.mips.cmpu.lt.qb
-    mips_copy_s_b,                             // llvm.mips.copy.s.b
-    mips_copy_s_d,                             // llvm.mips.copy.s.d
-    mips_copy_s_h,                             // llvm.mips.copy.s.h
-    mips_copy_s_w,                             // llvm.mips.copy.s.w
-    mips_copy_u_b,                             // llvm.mips.copy.u.b
-    mips_copy_u_d,                             // llvm.mips.copy.u.d
-    mips_copy_u_h,                             // llvm.mips.copy.u.h
-    mips_copy_u_w,                             // llvm.mips.copy.u.w
-    mips_ctcmsa,                               // llvm.mips.ctcmsa
-    mips_div_s_b,                              // llvm.mips.div.s.b
-    mips_div_s_d,                              // llvm.mips.div.s.d
-    mips_div_s_h,                              // llvm.mips.div.s.h
-    mips_div_s_w,                              // llvm.mips.div.s.w
-    mips_div_u_b,                              // llvm.mips.div.u.b
-    mips_div_u_d,                              // llvm.mips.div.u.d
-    mips_div_u_h,                              // llvm.mips.div.u.h
-    mips_div_u_w,                              // llvm.mips.div.u.w
-    mips_dlsa,                                 // llvm.mips.dlsa
-    mips_dotp_s_d,                             // llvm.mips.dotp.s.d
-    mips_dotp_s_h,                             // llvm.mips.dotp.s.h
-    mips_dotp_s_w,                             // llvm.mips.dotp.s.w
-    mips_dotp_u_d,                             // llvm.mips.dotp.u.d
-    mips_dotp_u_h,                             // llvm.mips.dotp.u.h
-    mips_dotp_u_w,                             // llvm.mips.dotp.u.w
-    mips_dpa_w_ph,                             // llvm.mips.dpa.w.ph
-    mips_dpadd_s_d,                            // llvm.mips.dpadd.s.d
-    mips_dpadd_s_h,                            // llvm.mips.dpadd.s.h
-    mips_dpadd_s_w,                            // llvm.mips.dpadd.s.w
-    mips_dpadd_u_d,                            // llvm.mips.dpadd.u.d
-    mips_dpadd_u_h,                            // llvm.mips.dpadd.u.h
-    mips_dpadd_u_w,                            // llvm.mips.dpadd.u.w
-    mips_dpaq_s_w_ph,                          // llvm.mips.dpaq.s.w.ph
-    mips_dpaq_sa_l_w,                          // llvm.mips.dpaq.sa.l.w
-    mips_dpaqx_s_w_ph,                         // llvm.mips.dpaqx.s.w.ph
-    mips_dpaqx_sa_w_ph,                        // llvm.mips.dpaqx.sa.w.ph
-    mips_dpau_h_qbl,                           // llvm.mips.dpau.h.qbl
-    mips_dpau_h_qbr,                           // llvm.mips.dpau.h.qbr
-    mips_dpax_w_ph,                            // llvm.mips.dpax.w.ph
-    mips_dps_w_ph,                             // llvm.mips.dps.w.ph
-    mips_dpsq_s_w_ph,                          // llvm.mips.dpsq.s.w.ph
-    mips_dpsq_sa_l_w,                          // llvm.mips.dpsq.sa.l.w
-    mips_dpsqx_s_w_ph,                         // llvm.mips.dpsqx.s.w.ph
-    mips_dpsqx_sa_w_ph,                        // llvm.mips.dpsqx.sa.w.ph
-    mips_dpsu_h_qbl,                           // llvm.mips.dpsu.h.qbl
-    mips_dpsu_h_qbr,                           // llvm.mips.dpsu.h.qbr
-    mips_dpsub_s_d,                            // llvm.mips.dpsub.s.d
-    mips_dpsub_s_h,                            // llvm.mips.dpsub.s.h
-    mips_dpsub_s_w,                            // llvm.mips.dpsub.s.w
-    mips_dpsub_u_d,                            // llvm.mips.dpsub.u.d
-    mips_dpsub_u_h,                            // llvm.mips.dpsub.u.h
-    mips_dpsub_u_w,                            // llvm.mips.dpsub.u.w
-    mips_dpsx_w_ph,                            // llvm.mips.dpsx.w.ph
-    mips_extp,                                 // llvm.mips.extp
-    mips_extpdp,                               // llvm.mips.extpdp
-    mips_extr_r_w,                             // llvm.mips.extr.r.w
-    mips_extr_rs_w,                            // llvm.mips.extr.rs.w
-    mips_extr_s_h,                             // llvm.mips.extr.s.h
-    mips_extr_w,                               // llvm.mips.extr.w
-    mips_fadd_d,                               // llvm.mips.fadd.d
-    mips_fadd_w,                               // llvm.mips.fadd.w
-    mips_fcaf_d,                               // llvm.mips.fcaf.d
-    mips_fcaf_w,                               // llvm.mips.fcaf.w
-    mips_fceq_d,                               // llvm.mips.fceq.d
-    mips_fceq_w,                               // llvm.mips.fceq.w
-    mips_fclass_d,                             // llvm.mips.fclass.d
-    mips_fclass_w,                             // llvm.mips.fclass.w
-    mips_fcle_d,                               // llvm.mips.fcle.d
-    mips_fcle_w,                               // llvm.mips.fcle.w
-    mips_fclt_d,                               // llvm.mips.fclt.d
-    mips_fclt_w,                               // llvm.mips.fclt.w
-    mips_fcne_d,                               // llvm.mips.fcne.d
-    mips_fcne_w,                               // llvm.mips.fcne.w
-    mips_fcor_d,                               // llvm.mips.fcor.d
-    mips_fcor_w,                               // llvm.mips.fcor.w
-    mips_fcueq_d,                              // llvm.mips.fcueq.d
-    mips_fcueq_w,                              // llvm.mips.fcueq.w
-    mips_fcule_d,                              // llvm.mips.fcule.d
-    mips_fcule_w,                              // llvm.mips.fcule.w
-    mips_fcult_d,                              // llvm.mips.fcult.d
-    mips_fcult_w,                              // llvm.mips.fcult.w
-    mips_fcun_d,                               // llvm.mips.fcun.d
-    mips_fcun_w,                               // llvm.mips.fcun.w
-    mips_fcune_d,                              // llvm.mips.fcune.d
-    mips_fcune_w,                              // llvm.mips.fcune.w
-    mips_fdiv_d,                               // llvm.mips.fdiv.d
-    mips_fdiv_w,                               // llvm.mips.fdiv.w
-    mips_fexdo_h,                              // llvm.mips.fexdo.h
-    mips_fexdo_w,                              // llvm.mips.fexdo.w
-    mips_fexp2_d,                              // llvm.mips.fexp2.d
-    mips_fexp2_w,                              // llvm.mips.fexp2.w
-    mips_fexupl_d,                             // llvm.mips.fexupl.d
-    mips_fexupl_w,                             // llvm.mips.fexupl.w
-    mips_fexupr_d,                             // llvm.mips.fexupr.d
-    mips_fexupr_w,                             // llvm.mips.fexupr.w
-    mips_ffint_s_d,                            // llvm.mips.ffint.s.d
-    mips_ffint_s_w,                            // llvm.mips.ffint.s.w
-    mips_ffint_u_d,                            // llvm.mips.ffint.u.d
-    mips_ffint_u_w,                            // llvm.mips.ffint.u.w
-    mips_ffql_d,                               // llvm.mips.ffql.d
-    mips_ffql_w,                               // llvm.mips.ffql.w
-    mips_ffqr_d,                               // llvm.mips.ffqr.d
-    mips_ffqr_w,                               // llvm.mips.ffqr.w
-    mips_fill_b,                               // llvm.mips.fill.b
-    mips_fill_d,                               // llvm.mips.fill.d
-    mips_fill_h,                               // llvm.mips.fill.h
-    mips_fill_w,                               // llvm.mips.fill.w
-    mips_flog2_d,                              // llvm.mips.flog2.d
-    mips_flog2_w,                              // llvm.mips.flog2.w
-    mips_fmadd_d,                              // llvm.mips.fmadd.d
-    mips_fmadd_w,                              // llvm.mips.fmadd.w
-    mips_fmax_a_d,                             // llvm.mips.fmax.a.d
-    mips_fmax_a_w,                             // llvm.mips.fmax.a.w
-    mips_fmax_d,                               // llvm.mips.fmax.d
-    mips_fmax_w,                               // llvm.mips.fmax.w
-    mips_fmin_a_d,                             // llvm.mips.fmin.a.d
-    mips_fmin_a_w,                             // llvm.mips.fmin.a.w
-    mips_fmin_d,                               // llvm.mips.fmin.d
-    mips_fmin_w,                               // llvm.mips.fmin.w
-    mips_fmsub_d,                              // llvm.mips.fmsub.d
-    mips_fmsub_w,                              // llvm.mips.fmsub.w
-    mips_fmul_d,                               // llvm.mips.fmul.d
-    mips_fmul_w,                               // llvm.mips.fmul.w
-    mips_frcp_d,                               // llvm.mips.frcp.d
-    mips_frcp_w,                               // llvm.mips.frcp.w
-    mips_frint_d,                              // llvm.mips.frint.d
-    mips_frint_w,                              // llvm.mips.frint.w
-    mips_frsqrt_d,                             // llvm.mips.frsqrt.d
-    mips_frsqrt_w,                             // llvm.mips.frsqrt.w
-    mips_fsaf_d,                               // llvm.mips.fsaf.d
-    mips_fsaf_w,                               // llvm.mips.fsaf.w
-    mips_fseq_d,                               // llvm.mips.fseq.d
-    mips_fseq_w,                               // llvm.mips.fseq.w
-    mips_fsle_d,                               // llvm.mips.fsle.d
-    mips_fsle_w,                               // llvm.mips.fsle.w
-    mips_fslt_d,                               // llvm.mips.fslt.d
-    mips_fslt_w,                               // llvm.mips.fslt.w
-    mips_fsne_d,                               // llvm.mips.fsne.d
-    mips_fsne_w,                               // llvm.mips.fsne.w
-    mips_fsor_d,                               // llvm.mips.fsor.d
-    mips_fsor_w,                               // llvm.mips.fsor.w
-    mips_fsqrt_d,                              // llvm.mips.fsqrt.d
-    mips_fsqrt_w,                              // llvm.mips.fsqrt.w
-    mips_fsub_d,                               // llvm.mips.fsub.d
-    mips_fsub_w,                               // llvm.mips.fsub.w
-    mips_fsueq_d,                              // llvm.mips.fsueq.d
-    mips_fsueq_w,                              // llvm.mips.fsueq.w
-    mips_fsule_d,                              // llvm.mips.fsule.d
-    mips_fsule_w,                              // llvm.mips.fsule.w
-    mips_fsult_d,                              // llvm.mips.fsult.d
-    mips_fsult_w,                              // llvm.mips.fsult.w
-    mips_fsun_d,                               // llvm.mips.fsun.d
-    mips_fsun_w,                               // llvm.mips.fsun.w
-    mips_fsune_d,                              // llvm.mips.fsune.d
-    mips_fsune_w,                              // llvm.mips.fsune.w
-    mips_ftint_s_d,                            // llvm.mips.ftint.s.d
-    mips_ftint_s_w,                            // llvm.mips.ftint.s.w
-    mips_ftint_u_d,                            // llvm.mips.ftint.u.d
-    mips_ftint_u_w,                            // llvm.mips.ftint.u.w
-    mips_ftq_h,                                // llvm.mips.ftq.h
-    mips_ftq_w,                                // llvm.mips.ftq.w
-    mips_ftrunc_s_d,                           // llvm.mips.ftrunc.s.d
-    mips_ftrunc_s_w,                           // llvm.mips.ftrunc.s.w
-    mips_ftrunc_u_d,                           // llvm.mips.ftrunc.u.d
-    mips_ftrunc_u_w,                           // llvm.mips.ftrunc.u.w
-    mips_hadd_s_d,                             // llvm.mips.hadd.s.d
-    mips_hadd_s_h,                             // llvm.mips.hadd.s.h
-    mips_hadd_s_w,                             // llvm.mips.hadd.s.w
-    mips_hadd_u_d,                             // llvm.mips.hadd.u.d
-    mips_hadd_u_h,                             // llvm.mips.hadd.u.h
-    mips_hadd_u_w,                             // llvm.mips.hadd.u.w
-    mips_hsub_s_d,                             // llvm.mips.hsub.s.d
-    mips_hsub_s_h,                             // llvm.mips.hsub.s.h
-    mips_hsub_s_w,                             // llvm.mips.hsub.s.w
-    mips_hsub_u_d,                             // llvm.mips.hsub.u.d
-    mips_hsub_u_h,                             // llvm.mips.hsub.u.h
-    mips_hsub_u_w,                             // llvm.mips.hsub.u.w
-    mips_ilvev_b,                              // llvm.mips.ilvev.b
-    mips_ilvev_d,                              // llvm.mips.ilvev.d
-    mips_ilvev_h,                              // llvm.mips.ilvev.h
-    mips_ilvev_w,                              // llvm.mips.ilvev.w
-    mips_ilvl_b,                               // llvm.mips.ilvl.b
-    mips_ilvl_d,                               // llvm.mips.ilvl.d
-    mips_ilvl_h,                               // llvm.mips.ilvl.h
-    mips_ilvl_w,                               // llvm.mips.ilvl.w
-    mips_ilvod_b,                              // llvm.mips.ilvod.b
-    mips_ilvod_d,                              // llvm.mips.ilvod.d
-    mips_ilvod_h,                              // llvm.mips.ilvod.h
-    mips_ilvod_w,                              // llvm.mips.ilvod.w
-    mips_ilvr_b,                               // llvm.mips.ilvr.b
-    mips_ilvr_d,                               // llvm.mips.ilvr.d
-    mips_ilvr_h,                               // llvm.mips.ilvr.h
-    mips_ilvr_w,                               // llvm.mips.ilvr.w
-    mips_insert_b,                             // llvm.mips.insert.b
-    mips_insert_d,                             // llvm.mips.insert.d
-    mips_insert_h,                             // llvm.mips.insert.h
-    mips_insert_w,                             // llvm.mips.insert.w
-    mips_insv,                                 // llvm.mips.insv
-    mips_insve_b,                              // llvm.mips.insve.b
-    mips_insve_d,                              // llvm.mips.insve.d
-    mips_insve_h,                              // llvm.mips.insve.h
-    mips_insve_w,                              // llvm.mips.insve.w
-    mips_lbux,                                 // llvm.mips.lbux
-    mips_ld_b,                                 // llvm.mips.ld.b
-    mips_ld_d,                                 // llvm.mips.ld.d
-    mips_ld_h,                                 // llvm.mips.ld.h
-    mips_ld_w,                                 // llvm.mips.ld.w
-    mips_ldi_b,                                // llvm.mips.ldi.b
-    mips_ldi_d,                                // llvm.mips.ldi.d
-    mips_ldi_h,                                // llvm.mips.ldi.h
-    mips_ldi_w,                                // llvm.mips.ldi.w
-    mips_lhx,                                  // llvm.mips.lhx
-    mips_lsa,                                  // llvm.mips.lsa
-    mips_lwx,                                  // llvm.mips.lwx
-    mips_madd,                                 // llvm.mips.madd
-    mips_madd_q_h,                             // llvm.mips.madd.q.h
-    mips_madd_q_w,                             // llvm.mips.madd.q.w
-    mips_maddr_q_h,                            // llvm.mips.maddr.q.h
-    mips_maddr_q_w,                            // llvm.mips.maddr.q.w
-    mips_maddu,                                // llvm.mips.maddu
-    mips_maddv_b,                              // llvm.mips.maddv.b
-    mips_maddv_d,                              // llvm.mips.maddv.d
-    mips_maddv_h,                              // llvm.mips.maddv.h
-    mips_maddv_w,                              // llvm.mips.maddv.w
-    mips_maq_s_w_phl,                          // llvm.mips.maq.s.w.phl
-    mips_maq_s_w_phr,                          // llvm.mips.maq.s.w.phr
-    mips_maq_sa_w_phl,                         // llvm.mips.maq.sa.w.phl
-    mips_maq_sa_w_phr,                         // llvm.mips.maq.sa.w.phr
-    mips_max_a_b,                              // llvm.mips.max.a.b
-    mips_max_a_d,                              // llvm.mips.max.a.d
-    mips_max_a_h,                              // llvm.mips.max.a.h
-    mips_max_a_w,                              // llvm.mips.max.a.w
-    mips_max_s_b,                              // llvm.mips.max.s.b
-    mips_max_s_d,                              // llvm.mips.max.s.d
-    mips_max_s_h,                              // llvm.mips.max.s.h
-    mips_max_s_w,                              // llvm.mips.max.s.w
-    mips_max_u_b,                              // llvm.mips.max.u.b
-    mips_max_u_d,                              // llvm.mips.max.u.d
-    mips_max_u_h,                              // llvm.mips.max.u.h
-    mips_max_u_w,                              // llvm.mips.max.u.w
-    mips_maxi_s_b,                             // llvm.mips.maxi.s.b
-    mips_maxi_s_d,                             // llvm.mips.maxi.s.d
-    mips_maxi_s_h,                             // llvm.mips.maxi.s.h
-    mips_maxi_s_w,                             // llvm.mips.maxi.s.w
-    mips_maxi_u_b,                             // llvm.mips.maxi.u.b
-    mips_maxi_u_d,                             // llvm.mips.maxi.u.d
-    mips_maxi_u_h,                             // llvm.mips.maxi.u.h
-    mips_maxi_u_w,                             // llvm.mips.maxi.u.w
-    mips_min_a_b,                              // llvm.mips.min.a.b
-    mips_min_a_d,                              // llvm.mips.min.a.d
-    mips_min_a_h,                              // llvm.mips.min.a.h
-    mips_min_a_w,                              // llvm.mips.min.a.w
-    mips_min_s_b,                              // llvm.mips.min.s.b
-    mips_min_s_d,                              // llvm.mips.min.s.d
-    mips_min_s_h,                              // llvm.mips.min.s.h
-    mips_min_s_w,                              // llvm.mips.min.s.w
-    mips_min_u_b,                              // llvm.mips.min.u.b
-    mips_min_u_d,                              // llvm.mips.min.u.d
-    mips_min_u_h,                              // llvm.mips.min.u.h
-    mips_min_u_w,                              // llvm.mips.min.u.w
-    mips_mini_s_b,                             // llvm.mips.mini.s.b
-    mips_mini_s_d,                             // llvm.mips.mini.s.d
-    mips_mini_s_h,                             // llvm.mips.mini.s.h
-    mips_mini_s_w,                             // llvm.mips.mini.s.w
-    mips_mini_u_b,                             // llvm.mips.mini.u.b
-    mips_mini_u_d,                             // llvm.mips.mini.u.d
-    mips_mini_u_h,                             // llvm.mips.mini.u.h
-    mips_mini_u_w,                             // llvm.mips.mini.u.w
-    mips_mod_s_b,                              // llvm.mips.mod.s.b
-    mips_mod_s_d,                              // llvm.mips.mod.s.d
-    mips_mod_s_h,                              // llvm.mips.mod.s.h
-    mips_mod_s_w,                              // llvm.mips.mod.s.w
-    mips_mod_u_b,                              // llvm.mips.mod.u.b
-    mips_mod_u_d,                              // llvm.mips.mod.u.d
-    mips_mod_u_h,                              // llvm.mips.mod.u.h
-    mips_mod_u_w,                              // llvm.mips.mod.u.w
-    mips_modsub,                               // llvm.mips.modsub
-    mips_move_v,                               // llvm.mips.move.v
-    mips_msub,                                 // llvm.mips.msub
-    mips_msub_q_h,                             // llvm.mips.msub.q.h
-    mips_msub_q_w,                             // llvm.mips.msub.q.w
-    mips_msubr_q_h,                            // llvm.mips.msubr.q.h
-    mips_msubr_q_w,                            // llvm.mips.msubr.q.w
-    mips_msubu,                                // llvm.mips.msubu
-    mips_msubv_b,                              // llvm.mips.msubv.b
-    mips_msubv_d,                              // llvm.mips.msubv.d
-    mips_msubv_h,                              // llvm.mips.msubv.h
-    mips_msubv_w,                              // llvm.mips.msubv.w
-    mips_mthlip,                               // llvm.mips.mthlip
-    mips_mul_ph,                               // llvm.mips.mul.ph
-    mips_mul_q_h,                              // llvm.mips.mul.q.h
-    mips_mul_q_w,                              // llvm.mips.mul.q.w
-    mips_mul_s_ph,                             // llvm.mips.mul.s.ph
-    mips_muleq_s_w_phl,                        // llvm.mips.muleq.s.w.phl
-    mips_muleq_s_w_phr,                        // llvm.mips.muleq.s.w.phr
-    mips_muleu_s_ph_qbl,                       // llvm.mips.muleu.s.ph.qbl
-    mips_muleu_s_ph_qbr,                       // llvm.mips.muleu.s.ph.qbr
-    mips_mulq_rs_ph,                           // llvm.mips.mulq.rs.ph
-    mips_mulq_rs_w,                            // llvm.mips.mulq.rs.w
-    mips_mulq_s_ph,                            // llvm.mips.mulq.s.ph
-    mips_mulq_s_w,                             // llvm.mips.mulq.s.w
-    mips_mulr_q_h,                             // llvm.mips.mulr.q.h
-    mips_mulr_q_w,                             // llvm.mips.mulr.q.w
-    mips_mulsa_w_ph,                           // llvm.mips.mulsa.w.ph
-    mips_mulsaq_s_w_ph,                        // llvm.mips.mulsaq.s.w.ph
-    mips_mult,                                 // llvm.mips.mult
-    mips_multu,                                // llvm.mips.multu
-    mips_mulv_b,                               // llvm.mips.mulv.b
-    mips_mulv_d,                               // llvm.mips.mulv.d
-    mips_mulv_h,                               // llvm.mips.mulv.h
-    mips_mulv_w,                               // llvm.mips.mulv.w
-    mips_nloc_b,                               // llvm.mips.nloc.b
-    mips_nloc_d,                               // llvm.mips.nloc.d
-    mips_nloc_h,                               // llvm.mips.nloc.h
-    mips_nloc_w,                               // llvm.mips.nloc.w
-    mips_nlzc_b,                               // llvm.mips.nlzc.b
-    mips_nlzc_d,                               // llvm.mips.nlzc.d
-    mips_nlzc_h,                               // llvm.mips.nlzc.h
-    mips_nlzc_w,                               // llvm.mips.nlzc.w
-    mips_nor_v,                                // llvm.mips.nor.v
-    mips_nori_b,                               // llvm.mips.nori.b
-    mips_or_v,                                 // llvm.mips.or.v
-    mips_ori_b,                                // llvm.mips.ori.b
-    mips_packrl_ph,                            // llvm.mips.packrl.ph
-    mips_pckev_b,                              // llvm.mips.pckev.b
-    mips_pckev_d,                              // llvm.mips.pckev.d
-    mips_pckev_h,                              // llvm.mips.pckev.h
-    mips_pckev_w,                              // llvm.mips.pckev.w
-    mips_pckod_b,                              // llvm.mips.pckod.b
-    mips_pckod_d,                              // llvm.mips.pckod.d
-    mips_pckod_h,                              // llvm.mips.pckod.h
-    mips_pckod_w,                              // llvm.mips.pckod.w
-    mips_pcnt_b,                               // llvm.mips.pcnt.b
-    mips_pcnt_d,                               // llvm.mips.pcnt.d
-    mips_pcnt_h,                               // llvm.mips.pcnt.h
-    mips_pcnt_w,                               // llvm.mips.pcnt.w
-    mips_pick_ph,                              // llvm.mips.pick.ph
-    mips_pick_qb,                              // llvm.mips.pick.qb
-    mips_preceq_w_phl,                         // llvm.mips.preceq.w.phl
-    mips_preceq_w_phr,                         // llvm.mips.preceq.w.phr
-    mips_precequ_ph_qbl,                       // llvm.mips.precequ.ph.qbl
-    mips_precequ_ph_qbla,                      // llvm.mips.precequ.ph.qbla
-    mips_precequ_ph_qbr,                       // llvm.mips.precequ.ph.qbr
-    mips_precequ_ph_qbra,                      // llvm.mips.precequ.ph.qbra
-    mips_preceu_ph_qbl,                        // llvm.mips.preceu.ph.qbl
-    mips_preceu_ph_qbla,                       // llvm.mips.preceu.ph.qbla
-    mips_preceu_ph_qbr,                        // llvm.mips.preceu.ph.qbr
-    mips_preceu_ph_qbra,                       // llvm.mips.preceu.ph.qbra
-    mips_precr_qb_ph,                          // llvm.mips.precr.qb.ph
-    mips_precr_sra_ph_w,                       // llvm.mips.precr.sra.ph.w
-    mips_precr_sra_r_ph_w,                     // llvm.mips.precr.sra.r.ph.w
-    mips_precrq_ph_w,                          // llvm.mips.precrq.ph.w
-    mips_precrq_qb_ph,                         // llvm.mips.precrq.qb.ph
-    mips_precrq_rs_ph_w,                       // llvm.mips.precrq.rs.ph.w
-    mips_precrqu_s_qb_ph,                      // llvm.mips.precrqu.s.qb.ph
-    mips_prepend,                              // llvm.mips.prepend
-    mips_raddu_w_qb,                           // llvm.mips.raddu.w.qb
-    mips_rddsp,                                // llvm.mips.rddsp
-    mips_repl_ph,                              // llvm.mips.repl.ph
-    mips_repl_qb,                              // llvm.mips.repl.qb
-    mips_sat_s_b,                              // llvm.mips.sat.s.b
-    mips_sat_s_d,                              // llvm.mips.sat.s.d
-    mips_sat_s_h,                              // llvm.mips.sat.s.h
-    mips_sat_s_w,                              // llvm.mips.sat.s.w
-    mips_sat_u_b,                              // llvm.mips.sat.u.b
-    mips_sat_u_d,                              // llvm.mips.sat.u.d
-    mips_sat_u_h,                              // llvm.mips.sat.u.h
-    mips_sat_u_w,                              // llvm.mips.sat.u.w
-    mips_shf_b,                                // llvm.mips.shf.b
-    mips_shf_h,                                // llvm.mips.shf.h
-    mips_shf_w,                                // llvm.mips.shf.w
-    mips_shilo,                                // llvm.mips.shilo
-    mips_shll_ph,                              // llvm.mips.shll.ph
-    mips_shll_qb,                              // llvm.mips.shll.qb
-    mips_shll_s_ph,                            // llvm.mips.shll.s.ph
-    mips_shll_s_w,                             // llvm.mips.shll.s.w
-    mips_shra_ph,                              // llvm.mips.shra.ph
-    mips_shra_qb,                              // llvm.mips.shra.qb
-    mips_shra_r_ph,                            // llvm.mips.shra.r.ph
-    mips_shra_r_qb,                            // llvm.mips.shra.r.qb
-    mips_shra_r_w,                             // llvm.mips.shra.r.w
-    mips_shrl_ph,                              // llvm.mips.shrl.ph
-    mips_shrl_qb,                              // llvm.mips.shrl.qb
-    mips_sld_b,                                // llvm.mips.sld.b
-    mips_sld_d,                                // llvm.mips.sld.d
-    mips_sld_h,                                // llvm.mips.sld.h
-    mips_sld_w,                                // llvm.mips.sld.w
-    mips_sldi_b,                               // llvm.mips.sldi.b
-    mips_sldi_d,                               // llvm.mips.sldi.d
-    mips_sldi_h,                               // llvm.mips.sldi.h
-    mips_sldi_w,                               // llvm.mips.sldi.w
-    mips_sll_b,                                // llvm.mips.sll.b
-    mips_sll_d,                                // llvm.mips.sll.d
-    mips_sll_h,                                // llvm.mips.sll.h
-    mips_sll_w,                                // llvm.mips.sll.w
-    mips_slli_b,                               // llvm.mips.slli.b
-    mips_slli_d,                               // llvm.mips.slli.d
-    mips_slli_h,                               // llvm.mips.slli.h
-    mips_slli_w,                               // llvm.mips.slli.w
-    mips_splat_b,                              // llvm.mips.splat.b
-    mips_splat_d,                              // llvm.mips.splat.d
-    mips_splat_h,                              // llvm.mips.splat.h
-    mips_splat_w,                              // llvm.mips.splat.w
-    mips_splati_b,                             // llvm.mips.splati.b
-    mips_splati_d,                             // llvm.mips.splati.d
-    mips_splati_h,                             // llvm.mips.splati.h
-    mips_splati_w,                             // llvm.mips.splati.w
-    mips_sra_b,                                // llvm.mips.sra.b
-    mips_sra_d,                                // llvm.mips.sra.d
-    mips_sra_h,                                // llvm.mips.sra.h
-    mips_sra_w,                                // llvm.mips.sra.w
-    mips_srai_b,                               // llvm.mips.srai.b
-    mips_srai_d,                               // llvm.mips.srai.d
-    mips_srai_h,                               // llvm.mips.srai.h
-    mips_srai_w,                               // llvm.mips.srai.w
-    mips_srar_b,                               // llvm.mips.srar.b
-    mips_srar_d,                               // llvm.mips.srar.d
-    mips_srar_h,                               // llvm.mips.srar.h
-    mips_srar_w,                               // llvm.mips.srar.w
-    mips_srari_b,                              // llvm.mips.srari.b
-    mips_srari_d,                              // llvm.mips.srari.d
-    mips_srari_h,                              // llvm.mips.srari.h
-    mips_srari_w,                              // llvm.mips.srari.w
-    mips_srl_b,                                // llvm.mips.srl.b
-    mips_srl_d,                                // llvm.mips.srl.d
-    mips_srl_h,                                // llvm.mips.srl.h
-    mips_srl_w,                                // llvm.mips.srl.w
-    mips_srli_b,                               // llvm.mips.srli.b
-    mips_srli_d,                               // llvm.mips.srli.d
-    mips_srli_h,                               // llvm.mips.srli.h
-    mips_srli_w,                               // llvm.mips.srli.w
-    mips_srlr_b,                               // llvm.mips.srlr.b
-    mips_srlr_d,                               // llvm.mips.srlr.d
-    mips_srlr_h,                               // llvm.mips.srlr.h
-    mips_srlr_w,                               // llvm.mips.srlr.w
-    mips_srlri_b,                              // llvm.mips.srlri.b
-    mips_srlri_d,                              // llvm.mips.srlri.d
-    mips_srlri_h,                              // llvm.mips.srlri.h
-    mips_srlri_w,                              // llvm.mips.srlri.w
-    mips_st_b,                                 // llvm.mips.st.b
-    mips_st_d,                                 // llvm.mips.st.d
-    mips_st_h,                                 // llvm.mips.st.h
-    mips_st_w,                                 // llvm.mips.st.w
-    mips_subq_ph,                              // llvm.mips.subq.ph
-    mips_subq_s_ph,                            // llvm.mips.subq.s.ph
-    mips_subq_s_w,                             // llvm.mips.subq.s.w
-    mips_subqh_ph,                             // llvm.mips.subqh.ph
-    mips_subqh_r_ph,                           // llvm.mips.subqh.r.ph
-    mips_subqh_r_w,                            // llvm.mips.subqh.r.w
-    mips_subqh_w,                              // llvm.mips.subqh.w
-    mips_subs_s_b,                             // llvm.mips.subs.s.b
-    mips_subs_s_d,                             // llvm.mips.subs.s.d
-    mips_subs_s_h,                             // llvm.mips.subs.s.h
-    mips_subs_s_w,                             // llvm.mips.subs.s.w
-    mips_subs_u_b,                             // llvm.mips.subs.u.b
-    mips_subs_u_d,                             // llvm.mips.subs.u.d
-    mips_subs_u_h,                             // llvm.mips.subs.u.h
-    mips_subs_u_w,                             // llvm.mips.subs.u.w
-    mips_subsus_u_b,                           // llvm.mips.subsus.u.b
-    mips_subsus_u_d,                           // llvm.mips.subsus.u.d
-    mips_subsus_u_h,                           // llvm.mips.subsus.u.h
-    mips_subsus_u_w,                           // llvm.mips.subsus.u.w
-    mips_subsuu_s_b,                           // llvm.mips.subsuu.s.b
-    mips_subsuu_s_d,                           // llvm.mips.subsuu.s.d
-    mips_subsuu_s_h,                           // llvm.mips.subsuu.s.h
-    mips_subsuu_s_w,                           // llvm.mips.subsuu.s.w
-    mips_subu_ph,                              // llvm.mips.subu.ph
-    mips_subu_qb,                              // llvm.mips.subu.qb
-    mips_subu_s_ph,                            // llvm.mips.subu.s.ph
-    mips_subu_s_qb,                            // llvm.mips.subu.s.qb
-    mips_subuh_qb,                             // llvm.mips.subuh.qb
-    mips_subuh_r_qb,                           // llvm.mips.subuh.r.qb
-    mips_subv_b,                               // llvm.mips.subv.b
-    mips_subv_d,                               // llvm.mips.subv.d
-    mips_subv_h,                               // llvm.mips.subv.h
-    mips_subv_w,                               // llvm.mips.subv.w
-    mips_subvi_b,                              // llvm.mips.subvi.b
-    mips_subvi_d,                              // llvm.mips.subvi.d
-    mips_subvi_h,                              // llvm.mips.subvi.h
-    mips_subvi_w,                              // llvm.mips.subvi.w
-    mips_vshf_b,                               // llvm.mips.vshf.b
-    mips_vshf_d,                               // llvm.mips.vshf.d
-    mips_vshf_h,                               // llvm.mips.vshf.h
-    mips_vshf_w,                               // llvm.mips.vshf.w
-    mips_wrdsp,                                // llvm.mips.wrdsp
-    mips_xor_v,                                // llvm.mips.xor.v
-    mips_xori_b,                               // llvm.mips.xori.b
-    nvvm_add_rm_d,                             // llvm.nvvm.add.rm.d
-    nvvm_add_rm_f,                             // llvm.nvvm.add.rm.f
-    nvvm_add_rm_ftz_f,                         // llvm.nvvm.add.rm.ftz.f
-    nvvm_add_rn_d,                             // llvm.nvvm.add.rn.d
-    nvvm_add_rn_f,                             // llvm.nvvm.add.rn.f
-    nvvm_add_rn_ftz_f,                         // llvm.nvvm.add.rn.ftz.f
-    nvvm_add_rp_d,                             // llvm.nvvm.add.rp.d
-    nvvm_add_rp_f,                             // llvm.nvvm.add.rp.f
-    nvvm_add_rp_ftz_f,                         // llvm.nvvm.add.rp.ftz.f
-    nvvm_add_rz_d,                             // llvm.nvvm.add.rz.d
-    nvvm_add_rz_f,                             // llvm.nvvm.add.rz.f
-    nvvm_add_rz_ftz_f,                         // llvm.nvvm.add.rz.ftz.f
-    nvvm_atomic_add_gen_f_cta,                 // llvm.nvvm.atomic.add.gen.f.cta
-    nvvm_atomic_add_gen_f_sys,                 // llvm.nvvm.atomic.add.gen.f.sys
-    nvvm_atomic_add_gen_i_cta,                 // llvm.nvvm.atomic.add.gen.i.cta
-    nvvm_atomic_add_gen_i_sys,                 // llvm.nvvm.atomic.add.gen.i.sys
-    nvvm_atomic_and_gen_i_cta,                 // llvm.nvvm.atomic.and.gen.i.cta
-    nvvm_atomic_and_gen_i_sys,                 // llvm.nvvm.atomic.and.gen.i.sys
-    nvvm_atomic_cas_gen_i_cta,                 // llvm.nvvm.atomic.cas.gen.i.cta
-    nvvm_atomic_cas_gen_i_sys,                 // llvm.nvvm.atomic.cas.gen.i.sys
-    nvvm_atomic_dec_gen_i_cta,                 // llvm.nvvm.atomic.dec.gen.i.cta
-    nvvm_atomic_dec_gen_i_sys,                 // llvm.nvvm.atomic.dec.gen.i.sys
-    nvvm_atomic_exch_gen_i_cta,                // llvm.nvvm.atomic.exch.gen.i.cta
-    nvvm_atomic_exch_gen_i_sys,                // llvm.nvvm.atomic.exch.gen.i.sys
-    nvvm_atomic_inc_gen_i_cta,                 // llvm.nvvm.atomic.inc.gen.i.cta
-    nvvm_atomic_inc_gen_i_sys,                 // llvm.nvvm.atomic.inc.gen.i.sys
-    nvvm_atomic_load_add_f32,                  // llvm.nvvm.atomic.load.add.f32
-    nvvm_atomic_load_add_f64,                  // llvm.nvvm.atomic.load.add.f64
-    nvvm_atomic_load_dec_32,                   // llvm.nvvm.atomic.load.dec.32
-    nvvm_atomic_load_inc_32,                   // llvm.nvvm.atomic.load.inc.32
-    nvvm_atomic_max_gen_i_cta,                 // llvm.nvvm.atomic.max.gen.i.cta
-    nvvm_atomic_max_gen_i_sys,                 // llvm.nvvm.atomic.max.gen.i.sys
-    nvvm_atomic_min_gen_i_cta,                 // llvm.nvvm.atomic.min.gen.i.cta
-    nvvm_atomic_min_gen_i_sys,                 // llvm.nvvm.atomic.min.gen.i.sys
-    nvvm_atomic_or_gen_i_cta,                  // llvm.nvvm.atomic.or.gen.i.cta
-    nvvm_atomic_or_gen_i_sys,                  // llvm.nvvm.atomic.or.gen.i.sys
-    nvvm_atomic_xor_gen_i_cta,                 // llvm.nvvm.atomic.xor.gen.i.cta
-    nvvm_atomic_xor_gen_i_sys,                 // llvm.nvvm.atomic.xor.gen.i.sys
-    nvvm_bar_sync,                             // llvm.nvvm.bar.sync
-    nvvm_bar_warp_sync,                        // llvm.nvvm.bar.warp.sync
-    nvvm_barrier,                              // llvm.nvvm.barrier
-    nvvm_barrier_n,                            // llvm.nvvm.barrier.n
-    nvvm_barrier_sync,                         // llvm.nvvm.barrier.sync
-    nvvm_barrier_sync_cnt,                     // llvm.nvvm.barrier.sync.cnt
-    nvvm_barrier0,                             // llvm.nvvm.barrier0
-    nvvm_barrier0_and,                         // llvm.nvvm.barrier0.and
-    nvvm_barrier0_or,                          // llvm.nvvm.barrier0.or
-    nvvm_barrier0_popc,                        // llvm.nvvm.barrier0.popc
-    nvvm_bitcast_d2ll,                         // llvm.nvvm.bitcast.d2ll
-    nvvm_bitcast_f2i,                          // llvm.nvvm.bitcast.f2i
-    nvvm_bitcast_i2f,                          // llvm.nvvm.bitcast.i2f
-    nvvm_bitcast_ll2d,                         // llvm.nvvm.bitcast.ll2d
-    nvvm_ceil_d,                               // llvm.nvvm.ceil.d
-    nvvm_ceil_f,                               // llvm.nvvm.ceil.f
-    nvvm_ceil_ftz_f,                           // llvm.nvvm.ceil.ftz.f
-    nvvm_compiler_error,                       // llvm.nvvm.compiler.error
-    nvvm_compiler_warn,                        // llvm.nvvm.compiler.warn
-    nvvm_cos_approx_f,                         // llvm.nvvm.cos.approx.f
-    nvvm_cos_approx_ftz_f,                     // llvm.nvvm.cos.approx.ftz.f
-    nvvm_d2f_rm,                               // llvm.nvvm.d2f.rm
-    nvvm_d2f_rm_ftz,                           // llvm.nvvm.d2f.rm.ftz
-    nvvm_d2f_rn,                               // llvm.nvvm.d2f.rn
-    nvvm_d2f_rn_ftz,                           // llvm.nvvm.d2f.rn.ftz
-    nvvm_d2f_rp,                               // llvm.nvvm.d2f.rp
-    nvvm_d2f_rp_ftz,                           // llvm.nvvm.d2f.rp.ftz
-    nvvm_d2f_rz,                               // llvm.nvvm.d2f.rz
-    nvvm_d2f_rz_ftz,                           // llvm.nvvm.d2f.rz.ftz
-    nvvm_d2i_hi,                               // llvm.nvvm.d2i.hi
-    nvvm_d2i_lo,                               // llvm.nvvm.d2i.lo
-    nvvm_d2i_rm,                               // llvm.nvvm.d2i.rm
-    nvvm_d2i_rn,                               // llvm.nvvm.d2i.rn
-    nvvm_d2i_rp,                               // llvm.nvvm.d2i.rp
-    nvvm_d2i_rz,                               // llvm.nvvm.d2i.rz
-    nvvm_d2ll_rm,                              // llvm.nvvm.d2ll.rm
-    nvvm_d2ll_rn,                              // llvm.nvvm.d2ll.rn
-    nvvm_d2ll_rp,                              // llvm.nvvm.d2ll.rp
-    nvvm_d2ll_rz,                              // llvm.nvvm.d2ll.rz
-    nvvm_d2ui_rm,                              // llvm.nvvm.d2ui.rm
-    nvvm_d2ui_rn,                              // llvm.nvvm.d2ui.rn
-    nvvm_d2ui_rp,                              // llvm.nvvm.d2ui.rp
-    nvvm_d2ui_rz,                              // llvm.nvvm.d2ui.rz
-    nvvm_d2ull_rm,                             // llvm.nvvm.d2ull.rm
-    nvvm_d2ull_rn,                             // llvm.nvvm.d2ull.rn
-    nvvm_d2ull_rp,                             // llvm.nvvm.d2ull.rp
-    nvvm_d2ull_rz,                             // llvm.nvvm.d2ull.rz
-    nvvm_div_approx_f,                         // llvm.nvvm.div.approx.f
-    nvvm_div_approx_ftz_f,                     // llvm.nvvm.div.approx.ftz.f
-    nvvm_div_rm_d,                             // llvm.nvvm.div.rm.d
-    nvvm_div_rm_f,                             // llvm.nvvm.div.rm.f
-    nvvm_div_rm_ftz_f,                         // llvm.nvvm.div.rm.ftz.f
-    nvvm_div_rn_d,                             // llvm.nvvm.div.rn.d
-    nvvm_div_rn_f,                             // llvm.nvvm.div.rn.f
-    nvvm_div_rn_ftz_f,                         // llvm.nvvm.div.rn.ftz.f
-    nvvm_div_rp_d,                             // llvm.nvvm.div.rp.d
-    nvvm_div_rp_f,                             // llvm.nvvm.div.rp.f
-    nvvm_div_rp_ftz_f,                         // llvm.nvvm.div.rp.ftz.f
-    nvvm_div_rz_d,                             // llvm.nvvm.div.rz.d
-    nvvm_div_rz_f,                             // llvm.nvvm.div.rz.f
-    nvvm_div_rz_ftz_f,                         // llvm.nvvm.div.rz.ftz.f
-    nvvm_ex2_approx_d,                         // llvm.nvvm.ex2.approx.d
-    nvvm_ex2_approx_f,                         // llvm.nvvm.ex2.approx.f
-    nvvm_ex2_approx_ftz_f,                     // llvm.nvvm.ex2.approx.ftz.f
-    nvvm_f2h_rn,                               // llvm.nvvm.f2h.rn
-    nvvm_f2h_rn_ftz,                           // llvm.nvvm.f2h.rn.ftz
-    nvvm_f2i_rm,                               // llvm.nvvm.f2i.rm
-    nvvm_f2i_rm_ftz,                           // llvm.nvvm.f2i.rm.ftz
-    nvvm_f2i_rn,                               // llvm.nvvm.f2i.rn
-    nvvm_f2i_rn_ftz,                           // llvm.nvvm.f2i.rn.ftz
-    nvvm_f2i_rp,                               // llvm.nvvm.f2i.rp
-    nvvm_f2i_rp_ftz,                           // llvm.nvvm.f2i.rp.ftz
-    nvvm_f2i_rz,                               // llvm.nvvm.f2i.rz
-    nvvm_f2i_rz_ftz,                           // llvm.nvvm.f2i.rz.ftz
-    nvvm_f2ll_rm,                              // llvm.nvvm.f2ll.rm
-    nvvm_f2ll_rm_ftz,                          // llvm.nvvm.f2ll.rm.ftz
-    nvvm_f2ll_rn,                              // llvm.nvvm.f2ll.rn
-    nvvm_f2ll_rn_ftz,                          // llvm.nvvm.f2ll.rn.ftz
-    nvvm_f2ll_rp,                              // llvm.nvvm.f2ll.rp
-    nvvm_f2ll_rp_ftz,                          // llvm.nvvm.f2ll.rp.ftz
-    nvvm_f2ll_rz,                              // llvm.nvvm.f2ll.rz
-    nvvm_f2ll_rz_ftz,                          // llvm.nvvm.f2ll.rz.ftz
-    nvvm_f2ui_rm,                              // llvm.nvvm.f2ui.rm
-    nvvm_f2ui_rm_ftz,                          // llvm.nvvm.f2ui.rm.ftz
-    nvvm_f2ui_rn,                              // llvm.nvvm.f2ui.rn
-    nvvm_f2ui_rn_ftz,                          // llvm.nvvm.f2ui.rn.ftz
-    nvvm_f2ui_rp,                              // llvm.nvvm.f2ui.rp
-    nvvm_f2ui_rp_ftz,                          // llvm.nvvm.f2ui.rp.ftz
-    nvvm_f2ui_rz,                              // llvm.nvvm.f2ui.rz
-    nvvm_f2ui_rz_ftz,                          // llvm.nvvm.f2ui.rz.ftz
-    nvvm_f2ull_rm,                             // llvm.nvvm.f2ull.rm
-    nvvm_f2ull_rm_ftz,                         // llvm.nvvm.f2ull.rm.ftz
-    nvvm_f2ull_rn,                             // llvm.nvvm.f2ull.rn
-    nvvm_f2ull_rn_ftz,                         // llvm.nvvm.f2ull.rn.ftz
-    nvvm_f2ull_rp,                             // llvm.nvvm.f2ull.rp
-    nvvm_f2ull_rp_ftz,                         // llvm.nvvm.f2ull.rp.ftz
-    nvvm_f2ull_rz,                             // llvm.nvvm.f2ull.rz
-    nvvm_f2ull_rz_ftz,                         // llvm.nvvm.f2ull.rz.ftz
-    nvvm_fabs_d,                               // llvm.nvvm.fabs.d
-    nvvm_fabs_f,                               // llvm.nvvm.fabs.f
-    nvvm_fabs_ftz_f,                           // llvm.nvvm.fabs.ftz.f
-    nvvm_floor_d,                              // llvm.nvvm.floor.d
-    nvvm_floor_f,                              // llvm.nvvm.floor.f
-    nvvm_floor_ftz_f,                          // llvm.nvvm.floor.ftz.f
-    nvvm_fma_rm_d,                             // llvm.nvvm.fma.rm.d
-    nvvm_fma_rm_f,                             // llvm.nvvm.fma.rm.f
-    nvvm_fma_rm_ftz_f,                         // llvm.nvvm.fma.rm.ftz.f
-    nvvm_fma_rn_d,                             // llvm.nvvm.fma.rn.d
-    nvvm_fma_rn_f,                             // llvm.nvvm.fma.rn.f
-    nvvm_fma_rn_ftz_f,                         // llvm.nvvm.fma.rn.ftz.f
-    nvvm_fma_rp_d,                             // llvm.nvvm.fma.rp.d
-    nvvm_fma_rp_f,                             // llvm.nvvm.fma.rp.f
-    nvvm_fma_rp_ftz_f,                         // llvm.nvvm.fma.rp.ftz.f
-    nvvm_fma_rz_d,                             // llvm.nvvm.fma.rz.d
-    nvvm_fma_rz_f,                             // llvm.nvvm.fma.rz.f
-    nvvm_fma_rz_ftz_f,                         // llvm.nvvm.fma.rz.ftz.f
-    nvvm_fmax_d,                               // llvm.nvvm.fmax.d
-    nvvm_fmax_f,                               // llvm.nvvm.fmax.f
-    nvvm_fmax_ftz_f,                           // llvm.nvvm.fmax.ftz.f
-    nvvm_fmin_d,                               // llvm.nvvm.fmin.d
-    nvvm_fmin_f,                               // llvm.nvvm.fmin.f
-    nvvm_fmin_ftz_f,                           // llvm.nvvm.fmin.ftz.f
-    nvvm_fns,                                  // llvm.nvvm.fns
-    nvvm_i2d_rm,                               // llvm.nvvm.i2d.rm
-    nvvm_i2d_rn,                               // llvm.nvvm.i2d.rn
-    nvvm_i2d_rp,                               // llvm.nvvm.i2d.rp
-    nvvm_i2d_rz,                               // llvm.nvvm.i2d.rz
-    nvvm_i2f_rm,                               // llvm.nvvm.i2f.rm
-    nvvm_i2f_rn,                               // llvm.nvvm.i2f.rn
-    nvvm_i2f_rp,                               // llvm.nvvm.i2f.rp
-    nvvm_i2f_rz,                               // llvm.nvvm.i2f.rz
-    nvvm_isspacep_const,                       // llvm.nvvm.isspacep.const
-    nvvm_isspacep_global,                      // llvm.nvvm.isspacep.global
-    nvvm_isspacep_local,                       // llvm.nvvm.isspacep.local
-    nvvm_isspacep_shared,                      // llvm.nvvm.isspacep.shared
-    nvvm_istypep_sampler,                      // llvm.nvvm.istypep.sampler
-    nvvm_istypep_surface,                      // llvm.nvvm.istypep.surface
-    nvvm_istypep_texture,                      // llvm.nvvm.istypep.texture
-    nvvm_ldg_global_f,                         // llvm.nvvm.ldg.global.f
-    nvvm_ldg_global_i,                         // llvm.nvvm.ldg.global.i
-    nvvm_ldg_global_p,                         // llvm.nvvm.ldg.global.p
-    nvvm_ldu_global_f,                         // llvm.nvvm.ldu.global.f
-    nvvm_ldu_global_i,                         // llvm.nvvm.ldu.global.i
-    nvvm_ldu_global_p,                         // llvm.nvvm.ldu.global.p
-    nvvm_lg2_approx_d,                         // llvm.nvvm.lg2.approx.d
-    nvvm_lg2_approx_f,                         // llvm.nvvm.lg2.approx.f
-    nvvm_lg2_approx_ftz_f,                     // llvm.nvvm.lg2.approx.ftz.f
-    nvvm_ll2d_rm,                              // llvm.nvvm.ll2d.rm
-    nvvm_ll2d_rn,                              // llvm.nvvm.ll2d.rn
-    nvvm_ll2d_rp,                              // llvm.nvvm.ll2d.rp
-    nvvm_ll2d_rz,                              // llvm.nvvm.ll2d.rz
-    nvvm_ll2f_rm,                              // llvm.nvvm.ll2f.rm
-    nvvm_ll2f_rn,                              // llvm.nvvm.ll2f.rn
-    nvvm_ll2f_rp,                              // llvm.nvvm.ll2f.rp
-    nvvm_ll2f_rz,                              // llvm.nvvm.ll2f.rz
-    nvvm_lohi_i2d,                             // llvm.nvvm.lohi.i2d
-    nvvm_match_all_sync_i32p,                  // llvm.nvvm.match.all.sync.i32p
-    nvvm_match_all_sync_i64p,                  // llvm.nvvm.match.all.sync.i64p
-    nvvm_match_any_sync_i32,                   // llvm.nvvm.match.any.sync.i32
-    nvvm_match_any_sync_i64,                   // llvm.nvvm.match.any.sync.i64
-    nvvm_membar_cta,                           // llvm.nvvm.membar.cta
-    nvvm_membar_gl,                            // llvm.nvvm.membar.gl
-    nvvm_membar_sys,                           // llvm.nvvm.membar.sys
-    nvvm_move_double,                          // llvm.nvvm.move.double
-    nvvm_move_float,                           // llvm.nvvm.move.float
-    nvvm_move_i16,                             // llvm.nvvm.move.i16
-    nvvm_move_i32,                             // llvm.nvvm.move.i32
-    nvvm_move_i64,                             // llvm.nvvm.move.i64
-    nvvm_move_ptr,                             // llvm.nvvm.move.ptr
-    nvvm_mul_rm_d,                             // llvm.nvvm.mul.rm.d
-    nvvm_mul_rm_f,                             // llvm.nvvm.mul.rm.f
-    nvvm_mul_rm_ftz_f,                         // llvm.nvvm.mul.rm.ftz.f
-    nvvm_mul_rn_d,                             // llvm.nvvm.mul.rn.d
-    nvvm_mul_rn_f,                             // llvm.nvvm.mul.rn.f
-    nvvm_mul_rn_ftz_f,                         // llvm.nvvm.mul.rn.ftz.f
-    nvvm_mul_rp_d,                             // llvm.nvvm.mul.rp.d
-    nvvm_mul_rp_f,                             // llvm.nvvm.mul.rp.f
-    nvvm_mul_rp_ftz_f,                         // llvm.nvvm.mul.rp.ftz.f
-    nvvm_mul_rz_d,                             // llvm.nvvm.mul.rz.d
-    nvvm_mul_rz_f,                             // llvm.nvvm.mul.rz.f
-    nvvm_mul_rz_ftz_f,                         // llvm.nvvm.mul.rz.ftz.f
-    nvvm_mul24_i,                              // llvm.nvvm.mul24.i
-    nvvm_mul24_ui,                             // llvm.nvvm.mul24.ui
-    nvvm_mulhi_i,                              // llvm.nvvm.mulhi.i
-    nvvm_mulhi_ll,                             // llvm.nvvm.mulhi.ll
-    nvvm_mulhi_ui,                             // llvm.nvvm.mulhi.ui
-    nvvm_mulhi_ull,                            // llvm.nvvm.mulhi.ull
-    nvvm_prmt,                                 // llvm.nvvm.prmt
-    nvvm_ptr_constant_to_gen,                  // llvm.nvvm.ptr.constant.to.gen
-    nvvm_ptr_gen_to_constant,                  // llvm.nvvm.ptr.gen.to.constant
-    nvvm_ptr_gen_to_global,                    // llvm.nvvm.ptr.gen.to.global
-    nvvm_ptr_gen_to_local,                     // llvm.nvvm.ptr.gen.to.local
-    nvvm_ptr_gen_to_param,                     // llvm.nvvm.ptr.gen.to.param
-    nvvm_ptr_gen_to_shared,                    // llvm.nvvm.ptr.gen.to.shared
-    nvvm_ptr_global_to_gen,                    // llvm.nvvm.ptr.global.to.gen
-    nvvm_ptr_local_to_gen,                     // llvm.nvvm.ptr.local.to.gen
-    nvvm_ptr_shared_to_gen,                    // llvm.nvvm.ptr.shared.to.gen
-    nvvm_rcp_approx_ftz_d,                     // llvm.nvvm.rcp.approx.ftz.d
-    nvvm_rcp_rm_d,                             // llvm.nvvm.rcp.rm.d
-    nvvm_rcp_rm_f,                             // llvm.nvvm.rcp.rm.f
-    nvvm_rcp_rm_ftz_f,                         // llvm.nvvm.rcp.rm.ftz.f
-    nvvm_rcp_rn_d,                             // llvm.nvvm.rcp.rn.d
-    nvvm_rcp_rn_f,                             // llvm.nvvm.rcp.rn.f
-    nvvm_rcp_rn_ftz_f,                         // llvm.nvvm.rcp.rn.ftz.f
-    nvvm_rcp_rp_d,                             // llvm.nvvm.rcp.rp.d
-    nvvm_rcp_rp_f,                             // llvm.nvvm.rcp.rp.f
-    nvvm_rcp_rp_ftz_f,                         // llvm.nvvm.rcp.rp.ftz.f
-    nvvm_rcp_rz_d,                             // llvm.nvvm.rcp.rz.d
-    nvvm_rcp_rz_f,                             // llvm.nvvm.rcp.rz.f
-    nvvm_rcp_rz_ftz_f,                         // llvm.nvvm.rcp.rz.ftz.f
-    nvvm_read_ptx_sreg_clock,                  // llvm.nvvm.read.ptx.sreg.clock
-    nvvm_read_ptx_sreg_clock64,                // llvm.nvvm.read.ptx.sreg.clock64
-    nvvm_read_ptx_sreg_ctaid_w,                // llvm.nvvm.read.ptx.sreg.ctaid.w
-    nvvm_read_ptx_sreg_ctaid_x,                // llvm.nvvm.read.ptx.sreg.ctaid.x
-    nvvm_read_ptx_sreg_ctaid_y,                // llvm.nvvm.read.ptx.sreg.ctaid.y
-    nvvm_read_ptx_sreg_ctaid_z,                // llvm.nvvm.read.ptx.sreg.ctaid.z
-    nvvm_read_ptx_sreg_envreg0,                // llvm.nvvm.read.ptx.sreg.envreg0
-    nvvm_read_ptx_sreg_envreg1,                // llvm.nvvm.read.ptx.sreg.envreg1
-    nvvm_read_ptx_sreg_envreg10,               // llvm.nvvm.read.ptx.sreg.envreg10
-    nvvm_read_ptx_sreg_envreg11,               // llvm.nvvm.read.ptx.sreg.envreg11
-    nvvm_read_ptx_sreg_envreg12,               // llvm.nvvm.read.ptx.sreg.envreg12
-    nvvm_read_ptx_sreg_envreg13,               // llvm.nvvm.read.ptx.sreg.envreg13
-    nvvm_read_ptx_sreg_envreg14,               // llvm.nvvm.read.ptx.sreg.envreg14
-    nvvm_read_ptx_sreg_envreg15,               // llvm.nvvm.read.ptx.sreg.envreg15
-    nvvm_read_ptx_sreg_envreg16,               // llvm.nvvm.read.ptx.sreg.envreg16
-    nvvm_read_ptx_sreg_envreg17,               // llvm.nvvm.read.ptx.sreg.envreg17
-    nvvm_read_ptx_sreg_envreg18,               // llvm.nvvm.read.ptx.sreg.envreg18
-    nvvm_read_ptx_sreg_envreg19,               // llvm.nvvm.read.ptx.sreg.envreg19
-    nvvm_read_ptx_sreg_envreg2,                // llvm.nvvm.read.ptx.sreg.envreg2
-    nvvm_read_ptx_sreg_envreg20,               // llvm.nvvm.read.ptx.sreg.envreg20
-    nvvm_read_ptx_sreg_envreg21,               // llvm.nvvm.read.ptx.sreg.envreg21
-    nvvm_read_ptx_sreg_envreg22,               // llvm.nvvm.read.ptx.sreg.envreg22
-    nvvm_read_ptx_sreg_envreg23,               // llvm.nvvm.read.ptx.sreg.envreg23
-    nvvm_read_ptx_sreg_envreg24,               // llvm.nvvm.read.ptx.sreg.envreg24
-    nvvm_read_ptx_sreg_envreg25,               // llvm.nvvm.read.ptx.sreg.envreg25
-    nvvm_read_ptx_sreg_envreg26,               // llvm.nvvm.read.ptx.sreg.envreg26
-    nvvm_read_ptx_sreg_envreg27,               // llvm.nvvm.read.ptx.sreg.envreg27
-    nvvm_read_ptx_sreg_envreg28,               // llvm.nvvm.read.ptx.sreg.envreg28
-    nvvm_read_ptx_sreg_envreg29,               // llvm.nvvm.read.ptx.sreg.envreg29
-    nvvm_read_ptx_sreg_envreg3,                // llvm.nvvm.read.ptx.sreg.envreg3
-    nvvm_read_ptx_sreg_envreg30,               // llvm.nvvm.read.ptx.sreg.envreg30
-    nvvm_read_ptx_sreg_envreg31,               // llvm.nvvm.read.ptx.sreg.envreg31
-    nvvm_read_ptx_sreg_envreg4,                // llvm.nvvm.read.ptx.sreg.envreg4
-    nvvm_read_ptx_sreg_envreg5,                // llvm.nvvm.read.ptx.sreg.envreg5
-    nvvm_read_ptx_sreg_envreg6,                // llvm.nvvm.read.ptx.sreg.envreg6
-    nvvm_read_ptx_sreg_envreg7,                // llvm.nvvm.read.ptx.sreg.envreg7
-    nvvm_read_ptx_sreg_envreg8,                // llvm.nvvm.read.ptx.sreg.envreg8
-    nvvm_read_ptx_sreg_envreg9,                // llvm.nvvm.read.ptx.sreg.envreg9
-    nvvm_read_ptx_sreg_gridid,                 // llvm.nvvm.read.ptx.sreg.gridid
-    nvvm_read_ptx_sreg_laneid,                 // llvm.nvvm.read.ptx.sreg.laneid
-    nvvm_read_ptx_sreg_lanemask_eq,            // llvm.nvvm.read.ptx.sreg.lanemask.eq
-    nvvm_read_ptx_sreg_lanemask_ge,            // llvm.nvvm.read.ptx.sreg.lanemask.ge
-    nvvm_read_ptx_sreg_lanemask_gt,            // llvm.nvvm.read.ptx.sreg.lanemask.gt
-    nvvm_read_ptx_sreg_lanemask_le,            // llvm.nvvm.read.ptx.sreg.lanemask.le
-    nvvm_read_ptx_sreg_lanemask_lt,            // llvm.nvvm.read.ptx.sreg.lanemask.lt
-    nvvm_read_ptx_sreg_nctaid_w,               // llvm.nvvm.read.ptx.sreg.nctaid.w
-    nvvm_read_ptx_sreg_nctaid_x,               // llvm.nvvm.read.ptx.sreg.nctaid.x
-    nvvm_read_ptx_sreg_nctaid_y,               // llvm.nvvm.read.ptx.sreg.nctaid.y
-    nvvm_read_ptx_sreg_nctaid_z,               // llvm.nvvm.read.ptx.sreg.nctaid.z
-    nvvm_read_ptx_sreg_nsmid,                  // llvm.nvvm.read.ptx.sreg.nsmid
-    nvvm_read_ptx_sreg_ntid_w,                 // llvm.nvvm.read.ptx.sreg.ntid.w
-    nvvm_read_ptx_sreg_ntid_x,                 // llvm.nvvm.read.ptx.sreg.ntid.x
-    nvvm_read_ptx_sreg_ntid_y,                 // llvm.nvvm.read.ptx.sreg.ntid.y
-    nvvm_read_ptx_sreg_ntid_z,                 // llvm.nvvm.read.ptx.sreg.ntid.z
-    nvvm_read_ptx_sreg_nwarpid,                // llvm.nvvm.read.ptx.sreg.nwarpid
-    nvvm_read_ptx_sreg_pm0,                    // llvm.nvvm.read.ptx.sreg.pm0
-    nvvm_read_ptx_sreg_pm1,                    // llvm.nvvm.read.ptx.sreg.pm1
-    nvvm_read_ptx_sreg_pm2,                    // llvm.nvvm.read.ptx.sreg.pm2
-    nvvm_read_ptx_sreg_pm3,                    // llvm.nvvm.read.ptx.sreg.pm3
-    nvvm_read_ptx_sreg_smid,                   // llvm.nvvm.read.ptx.sreg.smid
-    nvvm_read_ptx_sreg_tid_w,                  // llvm.nvvm.read.ptx.sreg.tid.w
-    nvvm_read_ptx_sreg_tid_x,                  // llvm.nvvm.read.ptx.sreg.tid.x
-    nvvm_read_ptx_sreg_tid_y,                  // llvm.nvvm.read.ptx.sreg.tid.y
-    nvvm_read_ptx_sreg_tid_z,                  // llvm.nvvm.read.ptx.sreg.tid.z
-    nvvm_read_ptx_sreg_warpid,                 // llvm.nvvm.read.ptx.sreg.warpid
-    nvvm_read_ptx_sreg_warpsize,               // llvm.nvvm.read.ptx.sreg.warpsize
-    nvvm_reflect,                              // llvm.nvvm.reflect
-    nvvm_rotate_b32,                           // llvm.nvvm.rotate.b32
-    nvvm_rotate_b64,                           // llvm.nvvm.rotate.b64
-    nvvm_rotate_right_b64,                     // llvm.nvvm.rotate.right.b64
-    nvvm_round_d,                              // llvm.nvvm.round.d
-    nvvm_round_f,                              // llvm.nvvm.round.f
-    nvvm_round_ftz_f,                          // llvm.nvvm.round.ftz.f
-    nvvm_rsqrt_approx_d,                       // llvm.nvvm.rsqrt.approx.d
-    nvvm_rsqrt_approx_f,                       // llvm.nvvm.rsqrt.approx.f
-    nvvm_rsqrt_approx_ftz_f,                   // llvm.nvvm.rsqrt.approx.ftz.f
-    nvvm_sad_i,                                // llvm.nvvm.sad.i
-    nvvm_sad_ui,                               // llvm.nvvm.sad.ui
-    nvvm_saturate_d,                           // llvm.nvvm.saturate.d
-    nvvm_saturate_f,                           // llvm.nvvm.saturate.f
-    nvvm_saturate_ftz_f,                       // llvm.nvvm.saturate.ftz.f
-    nvvm_shfl_bfly_f32,                        // llvm.nvvm.shfl.bfly.f32
-    nvvm_shfl_bfly_i32,                        // llvm.nvvm.shfl.bfly.i32
-    nvvm_shfl_down_f32,                        // llvm.nvvm.shfl.down.f32
-    nvvm_shfl_down_i32,                        // llvm.nvvm.shfl.down.i32
-    nvvm_shfl_idx_f32,                         // llvm.nvvm.shfl.idx.f32
-    nvvm_shfl_idx_i32,                         // llvm.nvvm.shfl.idx.i32
-    nvvm_shfl_sync_bfly_f32,                   // llvm.nvvm.shfl.sync.bfly.f32
-    nvvm_shfl_sync_bfly_i32,                   // llvm.nvvm.shfl.sync.bfly.i32
-    nvvm_shfl_sync_down_f32,                   // llvm.nvvm.shfl.sync.down.f32
-    nvvm_shfl_sync_down_i32,                   // llvm.nvvm.shfl.sync.down.i32
-    nvvm_shfl_sync_idx_f32,                    // llvm.nvvm.shfl.sync.idx.f32
-    nvvm_shfl_sync_idx_i32,                    // llvm.nvvm.shfl.sync.idx.i32
-    nvvm_shfl_sync_up_f32,                     // llvm.nvvm.shfl.sync.up.f32
-    nvvm_shfl_sync_up_i32,                     // llvm.nvvm.shfl.sync.up.i32
-    nvvm_shfl_up_f32,                          // llvm.nvvm.shfl.up.f32
-    nvvm_shfl_up_i32,                          // llvm.nvvm.shfl.up.i32
-    nvvm_sin_approx_f,                         // llvm.nvvm.sin.approx.f
-    nvvm_sin_approx_ftz_f,                     // llvm.nvvm.sin.approx.ftz.f
-    nvvm_sqrt_approx_f,                        // llvm.nvvm.sqrt.approx.f
-    nvvm_sqrt_approx_ftz_f,                    // llvm.nvvm.sqrt.approx.ftz.f
-    nvvm_sqrt_f,                               // llvm.nvvm.sqrt.f
-    nvvm_sqrt_rm_d,                            // llvm.nvvm.sqrt.rm.d
-    nvvm_sqrt_rm_f,                            // llvm.nvvm.sqrt.rm.f
-    nvvm_sqrt_rm_ftz_f,                        // llvm.nvvm.sqrt.rm.ftz.f
-    nvvm_sqrt_rn_d,                            // llvm.nvvm.sqrt.rn.d
-    nvvm_sqrt_rn_f,                            // llvm.nvvm.sqrt.rn.f
-    nvvm_sqrt_rn_ftz_f,                        // llvm.nvvm.sqrt.rn.ftz.f
-    nvvm_sqrt_rp_d,                            // llvm.nvvm.sqrt.rp.d
-    nvvm_sqrt_rp_f,                            // llvm.nvvm.sqrt.rp.f
-    nvvm_sqrt_rp_ftz_f,                        // llvm.nvvm.sqrt.rp.ftz.f
-    nvvm_sqrt_rz_d,                            // llvm.nvvm.sqrt.rz.d
-    nvvm_sqrt_rz_f,                            // llvm.nvvm.sqrt.rz.f
-    nvvm_sqrt_rz_ftz_f,                        // llvm.nvvm.sqrt.rz.ftz.f
-    nvvm_suld_1d_array_i16_clamp,              // llvm.nvvm.suld.1d.array.i16.clamp
-    nvvm_suld_1d_array_i16_trap,               // llvm.nvvm.suld.1d.array.i16.trap
-    nvvm_suld_1d_array_i16_zero,               // llvm.nvvm.suld.1d.array.i16.zero
-    nvvm_suld_1d_array_i32_clamp,              // llvm.nvvm.suld.1d.array.i32.clamp
-    nvvm_suld_1d_array_i32_trap,               // llvm.nvvm.suld.1d.array.i32.trap
-    nvvm_suld_1d_array_i32_zero,               // llvm.nvvm.suld.1d.array.i32.zero
-    nvvm_suld_1d_array_i64_clamp,              // llvm.nvvm.suld.1d.array.i64.clamp
-    nvvm_suld_1d_array_i64_trap,               // llvm.nvvm.suld.1d.array.i64.trap
-    nvvm_suld_1d_array_i64_zero,               // llvm.nvvm.suld.1d.array.i64.zero
-    nvvm_suld_1d_array_i8_clamp,               // llvm.nvvm.suld.1d.array.i8.clamp
-    nvvm_suld_1d_array_i8_trap,                // llvm.nvvm.suld.1d.array.i8.trap
-    nvvm_suld_1d_array_i8_zero,                // llvm.nvvm.suld.1d.array.i8.zero
-    nvvm_suld_1d_array_v2i16_clamp,            // llvm.nvvm.suld.1d.array.v2i16.clamp
-    nvvm_suld_1d_array_v2i16_trap,             // llvm.nvvm.suld.1d.array.v2i16.trap
-    nvvm_suld_1d_array_v2i16_zero,             // llvm.nvvm.suld.1d.array.v2i16.zero
-    nvvm_suld_1d_array_v2i32_clamp,            // llvm.nvvm.suld.1d.array.v2i32.clamp
-    nvvm_suld_1d_array_v2i32_trap,             // llvm.nvvm.suld.1d.array.v2i32.trap
-    nvvm_suld_1d_array_v2i32_zero,             // llvm.nvvm.suld.1d.array.v2i32.zero
-    nvvm_suld_1d_array_v2i64_clamp,            // llvm.nvvm.suld.1d.array.v2i64.clamp
-    nvvm_suld_1d_array_v2i64_trap,             // llvm.nvvm.suld.1d.array.v2i64.trap
-    nvvm_suld_1d_array_v2i64_zero,             // llvm.nvvm.suld.1d.array.v2i64.zero
-    nvvm_suld_1d_array_v2i8_clamp,             // llvm.nvvm.suld.1d.array.v2i8.clamp
-    nvvm_suld_1d_array_v2i8_trap,              // llvm.nvvm.suld.1d.array.v2i8.trap
-    nvvm_suld_1d_array_v2i8_zero,              // llvm.nvvm.suld.1d.array.v2i8.zero
-    nvvm_suld_1d_array_v4i16_clamp,            // llvm.nvvm.suld.1d.array.v4i16.clamp
-    nvvm_suld_1d_array_v4i16_trap,             // llvm.nvvm.suld.1d.array.v4i16.trap
-    nvvm_suld_1d_array_v4i16_zero,             // llvm.nvvm.suld.1d.array.v4i16.zero
-    nvvm_suld_1d_array_v4i32_clamp,            // llvm.nvvm.suld.1d.array.v4i32.clamp
-    nvvm_suld_1d_array_v4i32_trap,             // llvm.nvvm.suld.1d.array.v4i32.trap
-    nvvm_suld_1d_array_v4i32_zero,             // llvm.nvvm.suld.1d.array.v4i32.zero
-    nvvm_suld_1d_array_v4i8_clamp,             // llvm.nvvm.suld.1d.array.v4i8.clamp
-    nvvm_suld_1d_array_v4i8_trap,              // llvm.nvvm.suld.1d.array.v4i8.trap
-    nvvm_suld_1d_array_v4i8_zero,              // llvm.nvvm.suld.1d.array.v4i8.zero
-    nvvm_suld_1d_i16_clamp,                    // llvm.nvvm.suld.1d.i16.clamp
-    nvvm_suld_1d_i16_trap,                     // llvm.nvvm.suld.1d.i16.trap
-    nvvm_suld_1d_i16_zero,                     // llvm.nvvm.suld.1d.i16.zero
-    nvvm_suld_1d_i32_clamp,                    // llvm.nvvm.suld.1d.i32.clamp
-    nvvm_suld_1d_i32_trap,                     // llvm.nvvm.suld.1d.i32.trap
-    nvvm_suld_1d_i32_zero,                     // llvm.nvvm.suld.1d.i32.zero
-    nvvm_suld_1d_i64_clamp,                    // llvm.nvvm.suld.1d.i64.clamp
-    nvvm_suld_1d_i64_trap,                     // llvm.nvvm.suld.1d.i64.trap
-    nvvm_suld_1d_i64_zero,                     // llvm.nvvm.suld.1d.i64.zero
-    nvvm_suld_1d_i8_clamp,                     // llvm.nvvm.suld.1d.i8.clamp
-    nvvm_suld_1d_i8_trap,                      // llvm.nvvm.suld.1d.i8.trap
-    nvvm_suld_1d_i8_zero,                      // llvm.nvvm.suld.1d.i8.zero
-    nvvm_suld_1d_v2i16_clamp,                  // llvm.nvvm.suld.1d.v2i16.clamp
-    nvvm_suld_1d_v2i16_trap,                   // llvm.nvvm.suld.1d.v2i16.trap
-    nvvm_suld_1d_v2i16_zero,                   // llvm.nvvm.suld.1d.v2i16.zero
-    nvvm_suld_1d_v2i32_clamp,                  // llvm.nvvm.suld.1d.v2i32.clamp
-    nvvm_suld_1d_v2i32_trap,                   // llvm.nvvm.suld.1d.v2i32.trap
-    nvvm_suld_1d_v2i32_zero,                   // llvm.nvvm.suld.1d.v2i32.zero
-    nvvm_suld_1d_v2i64_clamp,                  // llvm.nvvm.suld.1d.v2i64.clamp
-    nvvm_suld_1d_v2i64_trap,                   // llvm.nvvm.suld.1d.v2i64.trap
-    nvvm_suld_1d_v2i64_zero,                   // llvm.nvvm.suld.1d.v2i64.zero
-    nvvm_suld_1d_v2i8_clamp,                   // llvm.nvvm.suld.1d.v2i8.clamp
-    nvvm_suld_1d_v2i8_trap,                    // llvm.nvvm.suld.1d.v2i8.trap
-    nvvm_suld_1d_v2i8_zero,                    // llvm.nvvm.suld.1d.v2i8.zero
-    nvvm_suld_1d_v4i16_clamp,                  // llvm.nvvm.suld.1d.v4i16.clamp
-    nvvm_suld_1d_v4i16_trap,                   // llvm.nvvm.suld.1d.v4i16.trap
-    nvvm_suld_1d_v4i16_zero,                   // llvm.nvvm.suld.1d.v4i16.zero
-    nvvm_suld_1d_v4i32_clamp,                  // llvm.nvvm.suld.1d.v4i32.clamp
-    nvvm_suld_1d_v4i32_trap,                   // llvm.nvvm.suld.1d.v4i32.trap
-    nvvm_suld_1d_v4i32_zero,                   // llvm.nvvm.suld.1d.v4i32.zero
-    nvvm_suld_1d_v4i8_clamp,                   // llvm.nvvm.suld.1d.v4i8.clamp
-    nvvm_suld_1d_v4i8_trap,                    // llvm.nvvm.suld.1d.v4i8.trap
-    nvvm_suld_1d_v4i8_zero,                    // llvm.nvvm.suld.1d.v4i8.zero
-    nvvm_suld_2d_array_i16_clamp,              // llvm.nvvm.suld.2d.array.i16.clamp
-    nvvm_suld_2d_array_i16_trap,               // llvm.nvvm.suld.2d.array.i16.trap
-    nvvm_suld_2d_array_i16_zero,               // llvm.nvvm.suld.2d.array.i16.zero
-    nvvm_suld_2d_array_i32_clamp,              // llvm.nvvm.suld.2d.array.i32.clamp
-    nvvm_suld_2d_array_i32_trap,               // llvm.nvvm.suld.2d.array.i32.trap
-    nvvm_suld_2d_array_i32_zero,               // llvm.nvvm.suld.2d.array.i32.zero
-    nvvm_suld_2d_array_i64_clamp,              // llvm.nvvm.suld.2d.array.i64.clamp
-    nvvm_suld_2d_array_i64_trap,               // llvm.nvvm.suld.2d.array.i64.trap
-    nvvm_suld_2d_array_i64_zero,               // llvm.nvvm.suld.2d.array.i64.zero
-    nvvm_suld_2d_array_i8_clamp,               // llvm.nvvm.suld.2d.array.i8.clamp
-    nvvm_suld_2d_array_i8_trap,                // llvm.nvvm.suld.2d.array.i8.trap
-    nvvm_suld_2d_array_i8_zero,                // llvm.nvvm.suld.2d.array.i8.zero
-    nvvm_suld_2d_array_v2i16_clamp,            // llvm.nvvm.suld.2d.array.v2i16.clamp
-    nvvm_suld_2d_array_v2i16_trap,             // llvm.nvvm.suld.2d.array.v2i16.trap
-    nvvm_suld_2d_array_v2i16_zero,             // llvm.nvvm.suld.2d.array.v2i16.zero
-    nvvm_suld_2d_array_v2i32_clamp,            // llvm.nvvm.suld.2d.array.v2i32.clamp
-    nvvm_suld_2d_array_v2i32_trap,             // llvm.nvvm.suld.2d.array.v2i32.trap
-    nvvm_suld_2d_array_v2i32_zero,             // llvm.nvvm.suld.2d.array.v2i32.zero
-    nvvm_suld_2d_array_v2i64_clamp,            // llvm.nvvm.suld.2d.array.v2i64.clamp
-    nvvm_suld_2d_array_v2i64_trap,             // llvm.nvvm.suld.2d.array.v2i64.trap
-    nvvm_suld_2d_array_v2i64_zero,             // llvm.nvvm.suld.2d.array.v2i64.zero
-    nvvm_suld_2d_array_v2i8_clamp,             // llvm.nvvm.suld.2d.array.v2i8.clamp
-    nvvm_suld_2d_array_v2i8_trap,              // llvm.nvvm.suld.2d.array.v2i8.trap
-    nvvm_suld_2d_array_v2i8_zero,              // llvm.nvvm.suld.2d.array.v2i8.zero
-    nvvm_suld_2d_array_v4i16_clamp,            // llvm.nvvm.suld.2d.array.v4i16.clamp
-    nvvm_suld_2d_array_v4i16_trap,             // llvm.nvvm.suld.2d.array.v4i16.trap
-    nvvm_suld_2d_array_v4i16_zero,             // llvm.nvvm.suld.2d.array.v4i16.zero
-    nvvm_suld_2d_array_v4i32_clamp,            // llvm.nvvm.suld.2d.array.v4i32.clamp
-    nvvm_suld_2d_array_v4i32_trap,             // llvm.nvvm.suld.2d.array.v4i32.trap
-    nvvm_suld_2d_array_v4i32_zero,             // llvm.nvvm.suld.2d.array.v4i32.zero
-    nvvm_suld_2d_array_v4i8_clamp,             // llvm.nvvm.suld.2d.array.v4i8.clamp
-    nvvm_suld_2d_array_v4i8_trap,              // llvm.nvvm.suld.2d.array.v4i8.trap
-    nvvm_suld_2d_array_v4i8_zero,              // llvm.nvvm.suld.2d.array.v4i8.zero
-    nvvm_suld_2d_i16_clamp,                    // llvm.nvvm.suld.2d.i16.clamp
-    nvvm_suld_2d_i16_trap,                     // llvm.nvvm.suld.2d.i16.trap
-    nvvm_suld_2d_i16_zero,                     // llvm.nvvm.suld.2d.i16.zero
-    nvvm_suld_2d_i32_clamp,                    // llvm.nvvm.suld.2d.i32.clamp
-    nvvm_suld_2d_i32_trap,                     // llvm.nvvm.suld.2d.i32.trap
-    nvvm_suld_2d_i32_zero,                     // llvm.nvvm.suld.2d.i32.zero
-    nvvm_suld_2d_i64_clamp,                    // llvm.nvvm.suld.2d.i64.clamp
-    nvvm_suld_2d_i64_trap,                     // llvm.nvvm.suld.2d.i64.trap
-    nvvm_suld_2d_i64_zero,                     // llvm.nvvm.suld.2d.i64.zero
-    nvvm_suld_2d_i8_clamp,                     // llvm.nvvm.suld.2d.i8.clamp
-    nvvm_suld_2d_i8_trap,                      // llvm.nvvm.suld.2d.i8.trap
-    nvvm_suld_2d_i8_zero,                      // llvm.nvvm.suld.2d.i8.zero
-    nvvm_suld_2d_v2i16_clamp,                  // llvm.nvvm.suld.2d.v2i16.clamp
-    nvvm_suld_2d_v2i16_trap,                   // llvm.nvvm.suld.2d.v2i16.trap
-    nvvm_suld_2d_v2i16_zero,                   // llvm.nvvm.suld.2d.v2i16.zero
-    nvvm_suld_2d_v2i32_clamp,                  // llvm.nvvm.suld.2d.v2i32.clamp
-    nvvm_suld_2d_v2i32_trap,                   // llvm.nvvm.suld.2d.v2i32.trap
-    nvvm_suld_2d_v2i32_zero,                   // llvm.nvvm.suld.2d.v2i32.zero
-    nvvm_suld_2d_v2i64_clamp,                  // llvm.nvvm.suld.2d.v2i64.clamp
-    nvvm_suld_2d_v2i64_trap,                   // llvm.nvvm.suld.2d.v2i64.trap
-    nvvm_suld_2d_v2i64_zero,                   // llvm.nvvm.suld.2d.v2i64.zero
-    nvvm_suld_2d_v2i8_clamp,                   // llvm.nvvm.suld.2d.v2i8.clamp
-    nvvm_suld_2d_v2i8_trap,                    // llvm.nvvm.suld.2d.v2i8.trap
-    nvvm_suld_2d_v2i8_zero,                    // llvm.nvvm.suld.2d.v2i8.zero
-    nvvm_suld_2d_v4i16_clamp,                  // llvm.nvvm.suld.2d.v4i16.clamp
-    nvvm_suld_2d_v4i16_trap,                   // llvm.nvvm.suld.2d.v4i16.trap
-    nvvm_suld_2d_v4i16_zero,                   // llvm.nvvm.suld.2d.v4i16.zero
-    nvvm_suld_2d_v4i32_clamp,                  // llvm.nvvm.suld.2d.v4i32.clamp
-    nvvm_suld_2d_v4i32_trap,                   // llvm.nvvm.suld.2d.v4i32.trap
-    nvvm_suld_2d_v4i32_zero,                   // llvm.nvvm.suld.2d.v4i32.zero
-    nvvm_suld_2d_v4i8_clamp,                   // llvm.nvvm.suld.2d.v4i8.clamp
-    nvvm_suld_2d_v4i8_trap,                    // llvm.nvvm.suld.2d.v4i8.trap
-    nvvm_suld_2d_v4i8_zero,                    // llvm.nvvm.suld.2d.v4i8.zero
-    nvvm_suld_3d_i16_clamp,                    // llvm.nvvm.suld.3d.i16.clamp
-    nvvm_suld_3d_i16_trap,                     // llvm.nvvm.suld.3d.i16.trap
-    nvvm_suld_3d_i16_zero,                     // llvm.nvvm.suld.3d.i16.zero
-    nvvm_suld_3d_i32_clamp,                    // llvm.nvvm.suld.3d.i32.clamp
-    nvvm_suld_3d_i32_trap,                     // llvm.nvvm.suld.3d.i32.trap
-    nvvm_suld_3d_i32_zero,                     // llvm.nvvm.suld.3d.i32.zero
-    nvvm_suld_3d_i64_clamp,                    // llvm.nvvm.suld.3d.i64.clamp
-    nvvm_suld_3d_i64_trap,                     // llvm.nvvm.suld.3d.i64.trap
-    nvvm_suld_3d_i64_zero,                     // llvm.nvvm.suld.3d.i64.zero
-    nvvm_suld_3d_i8_clamp,                     // llvm.nvvm.suld.3d.i8.clamp
-    nvvm_suld_3d_i8_trap,                      // llvm.nvvm.suld.3d.i8.trap
-    nvvm_suld_3d_i8_zero,                      // llvm.nvvm.suld.3d.i8.zero
-    nvvm_suld_3d_v2i16_clamp,                  // llvm.nvvm.suld.3d.v2i16.clamp
-    nvvm_suld_3d_v2i16_trap,                   // llvm.nvvm.suld.3d.v2i16.trap
-    nvvm_suld_3d_v2i16_zero,                   // llvm.nvvm.suld.3d.v2i16.zero
-    nvvm_suld_3d_v2i32_clamp,                  // llvm.nvvm.suld.3d.v2i32.clamp
-    nvvm_suld_3d_v2i32_trap,                   // llvm.nvvm.suld.3d.v2i32.trap
-    nvvm_suld_3d_v2i32_zero,                   // llvm.nvvm.suld.3d.v2i32.zero
-    nvvm_suld_3d_v2i64_clamp,                  // llvm.nvvm.suld.3d.v2i64.clamp
-    nvvm_suld_3d_v2i64_trap,                   // llvm.nvvm.suld.3d.v2i64.trap
-    nvvm_suld_3d_v2i64_zero,                   // llvm.nvvm.suld.3d.v2i64.zero
-    nvvm_suld_3d_v2i8_clamp,                   // llvm.nvvm.suld.3d.v2i8.clamp
-    nvvm_suld_3d_v2i8_trap,                    // llvm.nvvm.suld.3d.v2i8.trap
-    nvvm_suld_3d_v2i8_zero,                    // llvm.nvvm.suld.3d.v2i8.zero
-    nvvm_suld_3d_v4i16_clamp,                  // llvm.nvvm.suld.3d.v4i16.clamp
-    nvvm_suld_3d_v4i16_trap,                   // llvm.nvvm.suld.3d.v4i16.trap
-    nvvm_suld_3d_v4i16_zero,                   // llvm.nvvm.suld.3d.v4i16.zero
-    nvvm_suld_3d_v4i32_clamp,                  // llvm.nvvm.suld.3d.v4i32.clamp
-    nvvm_suld_3d_v4i32_trap,                   // llvm.nvvm.suld.3d.v4i32.trap
-    nvvm_suld_3d_v4i32_zero,                   // llvm.nvvm.suld.3d.v4i32.zero
-    nvvm_suld_3d_v4i8_clamp,                   // llvm.nvvm.suld.3d.v4i8.clamp
-    nvvm_suld_3d_v4i8_trap,                    // llvm.nvvm.suld.3d.v4i8.trap
-    nvvm_suld_3d_v4i8_zero,                    // llvm.nvvm.suld.3d.v4i8.zero
-    nvvm_suq_array_size,                       // llvm.nvvm.suq.array.size
-    nvvm_suq_channel_data_type,                // llvm.nvvm.suq.channel.data.type
-    nvvm_suq_channel_order,                    // llvm.nvvm.suq.channel.order
-    nvvm_suq_depth,                            // llvm.nvvm.suq.depth
-    nvvm_suq_height,                           // llvm.nvvm.suq.height
-    nvvm_suq_width,                            // llvm.nvvm.suq.width
-    nvvm_sust_b_1d_array_i16_clamp,            // llvm.nvvm.sust.b.1d.array.i16.clamp
-    nvvm_sust_b_1d_array_i16_trap,             // llvm.nvvm.sust.b.1d.array.i16.trap
-    nvvm_sust_b_1d_array_i16_zero,             // llvm.nvvm.sust.b.1d.array.i16.zero
-    nvvm_sust_b_1d_array_i32_clamp,            // llvm.nvvm.sust.b.1d.array.i32.clamp
-    nvvm_sust_b_1d_array_i32_trap,             // llvm.nvvm.sust.b.1d.array.i32.trap
-    nvvm_sust_b_1d_array_i32_zero,             // llvm.nvvm.sust.b.1d.array.i32.zero
-    nvvm_sust_b_1d_array_i64_clamp,            // llvm.nvvm.sust.b.1d.array.i64.clamp
-    nvvm_sust_b_1d_array_i64_trap,             // llvm.nvvm.sust.b.1d.array.i64.trap
-    nvvm_sust_b_1d_array_i64_zero,             // llvm.nvvm.sust.b.1d.array.i64.zero
-    nvvm_sust_b_1d_array_i8_clamp,             // llvm.nvvm.sust.b.1d.array.i8.clamp
-    nvvm_sust_b_1d_array_i8_trap,              // llvm.nvvm.sust.b.1d.array.i8.trap
-    nvvm_sust_b_1d_array_i8_zero,              // llvm.nvvm.sust.b.1d.array.i8.zero
-    nvvm_sust_b_1d_array_v2i16_clamp,          // llvm.nvvm.sust.b.1d.array.v2i16.clamp
-    nvvm_sust_b_1d_array_v2i16_trap,           // llvm.nvvm.sust.b.1d.array.v2i16.trap
-    nvvm_sust_b_1d_array_v2i16_zero,           // llvm.nvvm.sust.b.1d.array.v2i16.zero
-    nvvm_sust_b_1d_array_v2i32_clamp,          // llvm.nvvm.sust.b.1d.array.v2i32.clamp
-    nvvm_sust_b_1d_array_v2i32_trap,           // llvm.nvvm.sust.b.1d.array.v2i32.trap
-    nvvm_sust_b_1d_array_v2i32_zero,           // llvm.nvvm.sust.b.1d.array.v2i32.zero
-    nvvm_sust_b_1d_array_v2i64_clamp,          // llvm.nvvm.sust.b.1d.array.v2i64.clamp
-    nvvm_sust_b_1d_array_v2i64_trap,           // llvm.nvvm.sust.b.1d.array.v2i64.trap
-    nvvm_sust_b_1d_array_v2i64_zero,           // llvm.nvvm.sust.b.1d.array.v2i64.zero
-    nvvm_sust_b_1d_array_v2i8_clamp,           // llvm.nvvm.sust.b.1d.array.v2i8.clamp
-    nvvm_sust_b_1d_array_v2i8_trap,            // llvm.nvvm.sust.b.1d.array.v2i8.trap
-    nvvm_sust_b_1d_array_v2i8_zero,            // llvm.nvvm.sust.b.1d.array.v2i8.zero
-    nvvm_sust_b_1d_array_v4i16_clamp,          // llvm.nvvm.sust.b.1d.array.v4i16.clamp
-    nvvm_sust_b_1d_array_v4i16_trap,           // llvm.nvvm.sust.b.1d.array.v4i16.trap
-    nvvm_sust_b_1d_array_v4i16_zero,           // llvm.nvvm.sust.b.1d.array.v4i16.zero
-    nvvm_sust_b_1d_array_v4i32_clamp,          // llvm.nvvm.sust.b.1d.array.v4i32.clamp
-    nvvm_sust_b_1d_array_v4i32_trap,           // llvm.nvvm.sust.b.1d.array.v4i32.trap
-    nvvm_sust_b_1d_array_v4i32_zero,           // llvm.nvvm.sust.b.1d.array.v4i32.zero
-    nvvm_sust_b_1d_array_v4i8_clamp,           // llvm.nvvm.sust.b.1d.array.v4i8.clamp
-    nvvm_sust_b_1d_array_v4i8_trap,            // llvm.nvvm.sust.b.1d.array.v4i8.trap
-    nvvm_sust_b_1d_array_v4i8_zero,            // llvm.nvvm.sust.b.1d.array.v4i8.zero
-    nvvm_sust_b_1d_i16_clamp,                  // llvm.nvvm.sust.b.1d.i16.clamp
-    nvvm_sust_b_1d_i16_trap,                   // llvm.nvvm.sust.b.1d.i16.trap
-    nvvm_sust_b_1d_i16_zero,                   // llvm.nvvm.sust.b.1d.i16.zero
-    nvvm_sust_b_1d_i32_clamp,                  // llvm.nvvm.sust.b.1d.i32.clamp
-    nvvm_sust_b_1d_i32_trap,                   // llvm.nvvm.sust.b.1d.i32.trap
-    nvvm_sust_b_1d_i32_zero,                   // llvm.nvvm.sust.b.1d.i32.zero
-    nvvm_sust_b_1d_i64_clamp,                  // llvm.nvvm.sust.b.1d.i64.clamp
-    nvvm_sust_b_1d_i64_trap,                   // llvm.nvvm.sust.b.1d.i64.trap
-    nvvm_sust_b_1d_i64_zero,                   // llvm.nvvm.sust.b.1d.i64.zero
-    nvvm_sust_b_1d_i8_clamp,                   // llvm.nvvm.sust.b.1d.i8.clamp
-    nvvm_sust_b_1d_i8_trap,                    // llvm.nvvm.sust.b.1d.i8.trap
-    nvvm_sust_b_1d_i8_zero,                    // llvm.nvvm.sust.b.1d.i8.zero
-    nvvm_sust_b_1d_v2i16_clamp,                // llvm.nvvm.sust.b.1d.v2i16.clamp
-    nvvm_sust_b_1d_v2i16_trap,                 // llvm.nvvm.sust.b.1d.v2i16.trap
-    nvvm_sust_b_1d_v2i16_zero,                 // llvm.nvvm.sust.b.1d.v2i16.zero
-    nvvm_sust_b_1d_v2i32_clamp,                // llvm.nvvm.sust.b.1d.v2i32.clamp
-    nvvm_sust_b_1d_v2i32_trap,                 // llvm.nvvm.sust.b.1d.v2i32.trap
-    nvvm_sust_b_1d_v2i32_zero,                 // llvm.nvvm.sust.b.1d.v2i32.zero
-    nvvm_sust_b_1d_v2i64_clamp,                // llvm.nvvm.sust.b.1d.v2i64.clamp
-    nvvm_sust_b_1d_v2i64_trap,                 // llvm.nvvm.sust.b.1d.v2i64.trap
-    nvvm_sust_b_1d_v2i64_zero,                 // llvm.nvvm.sust.b.1d.v2i64.zero
-    nvvm_sust_b_1d_v2i8_clamp,                 // llvm.nvvm.sust.b.1d.v2i8.clamp
-    nvvm_sust_b_1d_v2i8_trap,                  // llvm.nvvm.sust.b.1d.v2i8.trap
-    nvvm_sust_b_1d_v2i8_zero,                  // llvm.nvvm.sust.b.1d.v2i8.zero
-    nvvm_sust_b_1d_v4i16_clamp,                // llvm.nvvm.sust.b.1d.v4i16.clamp
-    nvvm_sust_b_1d_v4i16_trap,                 // llvm.nvvm.sust.b.1d.v4i16.trap
-    nvvm_sust_b_1d_v4i16_zero,                 // llvm.nvvm.sust.b.1d.v4i16.zero
-    nvvm_sust_b_1d_v4i32_clamp,                // llvm.nvvm.sust.b.1d.v4i32.clamp
-    nvvm_sust_b_1d_v4i32_trap,                 // llvm.nvvm.sust.b.1d.v4i32.trap
-    nvvm_sust_b_1d_v4i32_zero,                 // llvm.nvvm.sust.b.1d.v4i32.zero
-    nvvm_sust_b_1d_v4i8_clamp,                 // llvm.nvvm.sust.b.1d.v4i8.clamp
-    nvvm_sust_b_1d_v4i8_trap,                  // llvm.nvvm.sust.b.1d.v4i8.trap
-    nvvm_sust_b_1d_v4i8_zero,                  // llvm.nvvm.sust.b.1d.v4i8.zero
-    nvvm_sust_b_2d_array_i16_clamp,            // llvm.nvvm.sust.b.2d.array.i16.clamp
-    nvvm_sust_b_2d_array_i16_trap,             // llvm.nvvm.sust.b.2d.array.i16.trap
-    nvvm_sust_b_2d_array_i16_zero,             // llvm.nvvm.sust.b.2d.array.i16.zero
-    nvvm_sust_b_2d_array_i32_clamp,            // llvm.nvvm.sust.b.2d.array.i32.clamp
-    nvvm_sust_b_2d_array_i32_trap,             // llvm.nvvm.sust.b.2d.array.i32.trap
-    nvvm_sust_b_2d_array_i32_zero,             // llvm.nvvm.sust.b.2d.array.i32.zero
-    nvvm_sust_b_2d_array_i64_clamp,            // llvm.nvvm.sust.b.2d.array.i64.clamp
-    nvvm_sust_b_2d_array_i64_trap,             // llvm.nvvm.sust.b.2d.array.i64.trap
-    nvvm_sust_b_2d_array_i64_zero,             // llvm.nvvm.sust.b.2d.array.i64.zero
-    nvvm_sust_b_2d_array_i8_clamp,             // llvm.nvvm.sust.b.2d.array.i8.clamp
-    nvvm_sust_b_2d_array_i8_trap,              // llvm.nvvm.sust.b.2d.array.i8.trap
-    nvvm_sust_b_2d_array_i8_zero,              // llvm.nvvm.sust.b.2d.array.i8.zero
-    nvvm_sust_b_2d_array_v2i16_clamp,          // llvm.nvvm.sust.b.2d.array.v2i16.clamp
-    nvvm_sust_b_2d_array_v2i16_trap,           // llvm.nvvm.sust.b.2d.array.v2i16.trap
-    nvvm_sust_b_2d_array_v2i16_zero,           // llvm.nvvm.sust.b.2d.array.v2i16.zero
-    nvvm_sust_b_2d_array_v2i32_clamp,          // llvm.nvvm.sust.b.2d.array.v2i32.clamp
-    nvvm_sust_b_2d_array_v2i32_trap,           // llvm.nvvm.sust.b.2d.array.v2i32.trap
-    nvvm_sust_b_2d_array_v2i32_zero,           // llvm.nvvm.sust.b.2d.array.v2i32.zero
-    nvvm_sust_b_2d_array_v2i64_clamp,          // llvm.nvvm.sust.b.2d.array.v2i64.clamp
-    nvvm_sust_b_2d_array_v2i64_trap,           // llvm.nvvm.sust.b.2d.array.v2i64.trap
-    nvvm_sust_b_2d_array_v2i64_zero,           // llvm.nvvm.sust.b.2d.array.v2i64.zero
-    nvvm_sust_b_2d_array_v2i8_clamp,           // llvm.nvvm.sust.b.2d.array.v2i8.clamp
-    nvvm_sust_b_2d_array_v2i8_trap,            // llvm.nvvm.sust.b.2d.array.v2i8.trap
-    nvvm_sust_b_2d_array_v2i8_zero,            // llvm.nvvm.sust.b.2d.array.v2i8.zero
-    nvvm_sust_b_2d_array_v4i16_clamp,          // llvm.nvvm.sust.b.2d.array.v4i16.clamp
-    nvvm_sust_b_2d_array_v4i16_trap,           // llvm.nvvm.sust.b.2d.array.v4i16.trap
-    nvvm_sust_b_2d_array_v4i16_zero,           // llvm.nvvm.sust.b.2d.array.v4i16.zero
-    nvvm_sust_b_2d_array_v4i32_clamp,          // llvm.nvvm.sust.b.2d.array.v4i32.clamp
-    nvvm_sust_b_2d_array_v4i32_trap,           // llvm.nvvm.sust.b.2d.array.v4i32.trap
-    nvvm_sust_b_2d_array_v4i32_zero,           // llvm.nvvm.sust.b.2d.array.v4i32.zero
-    nvvm_sust_b_2d_array_v4i8_clamp,           // llvm.nvvm.sust.b.2d.array.v4i8.clamp
-    nvvm_sust_b_2d_array_v4i8_trap,            // llvm.nvvm.sust.b.2d.array.v4i8.trap
-    nvvm_sust_b_2d_array_v4i8_zero,            // llvm.nvvm.sust.b.2d.array.v4i8.zero
-    nvvm_sust_b_2d_i16_clamp,                  // llvm.nvvm.sust.b.2d.i16.clamp
-    nvvm_sust_b_2d_i16_trap,                   // llvm.nvvm.sust.b.2d.i16.trap
-    nvvm_sust_b_2d_i16_zero,                   // llvm.nvvm.sust.b.2d.i16.zero
-    nvvm_sust_b_2d_i32_clamp,                  // llvm.nvvm.sust.b.2d.i32.clamp
-    nvvm_sust_b_2d_i32_trap,                   // llvm.nvvm.sust.b.2d.i32.trap
-    nvvm_sust_b_2d_i32_zero,                   // llvm.nvvm.sust.b.2d.i32.zero
-    nvvm_sust_b_2d_i64_clamp,                  // llvm.nvvm.sust.b.2d.i64.clamp
-    nvvm_sust_b_2d_i64_trap,                   // llvm.nvvm.sust.b.2d.i64.trap
-    nvvm_sust_b_2d_i64_zero,                   // llvm.nvvm.sust.b.2d.i64.zero
-    nvvm_sust_b_2d_i8_clamp,                   // llvm.nvvm.sust.b.2d.i8.clamp
-    nvvm_sust_b_2d_i8_trap,                    // llvm.nvvm.sust.b.2d.i8.trap
-    nvvm_sust_b_2d_i8_zero,                    // llvm.nvvm.sust.b.2d.i8.zero
-    nvvm_sust_b_2d_v2i16_clamp,                // llvm.nvvm.sust.b.2d.v2i16.clamp
-    nvvm_sust_b_2d_v2i16_trap,                 // llvm.nvvm.sust.b.2d.v2i16.trap
-    nvvm_sust_b_2d_v2i16_zero,                 // llvm.nvvm.sust.b.2d.v2i16.zero
-    nvvm_sust_b_2d_v2i32_clamp,                // llvm.nvvm.sust.b.2d.v2i32.clamp
-    nvvm_sust_b_2d_v2i32_trap,                 // llvm.nvvm.sust.b.2d.v2i32.trap
-    nvvm_sust_b_2d_v2i32_zero,                 // llvm.nvvm.sust.b.2d.v2i32.zero
-    nvvm_sust_b_2d_v2i64_clamp,                // llvm.nvvm.sust.b.2d.v2i64.clamp
-    nvvm_sust_b_2d_v2i64_trap,                 // llvm.nvvm.sust.b.2d.v2i64.trap
-    nvvm_sust_b_2d_v2i64_zero,                 // llvm.nvvm.sust.b.2d.v2i64.zero
-    nvvm_sust_b_2d_v2i8_clamp,                 // llvm.nvvm.sust.b.2d.v2i8.clamp
-    nvvm_sust_b_2d_v2i8_trap,                  // llvm.nvvm.sust.b.2d.v2i8.trap
-    nvvm_sust_b_2d_v2i8_zero,                  // llvm.nvvm.sust.b.2d.v2i8.zero
-    nvvm_sust_b_2d_v4i16_clamp,                // llvm.nvvm.sust.b.2d.v4i16.clamp
-    nvvm_sust_b_2d_v4i16_trap,                 // llvm.nvvm.sust.b.2d.v4i16.trap
-    nvvm_sust_b_2d_v4i16_zero,                 // llvm.nvvm.sust.b.2d.v4i16.zero
-    nvvm_sust_b_2d_v4i32_clamp,                // llvm.nvvm.sust.b.2d.v4i32.clamp
-    nvvm_sust_b_2d_v4i32_trap,                 // llvm.nvvm.sust.b.2d.v4i32.trap
-    nvvm_sust_b_2d_v4i32_zero,                 // llvm.nvvm.sust.b.2d.v4i32.zero
-    nvvm_sust_b_2d_v4i8_clamp,                 // llvm.nvvm.sust.b.2d.v4i8.clamp
-    nvvm_sust_b_2d_v4i8_trap,                  // llvm.nvvm.sust.b.2d.v4i8.trap
-    nvvm_sust_b_2d_v4i8_zero,                  // llvm.nvvm.sust.b.2d.v4i8.zero
-    nvvm_sust_b_3d_i16_clamp,                  // llvm.nvvm.sust.b.3d.i16.clamp
-    nvvm_sust_b_3d_i16_trap,                   // llvm.nvvm.sust.b.3d.i16.trap
-    nvvm_sust_b_3d_i16_zero,                   // llvm.nvvm.sust.b.3d.i16.zero
-    nvvm_sust_b_3d_i32_clamp,                  // llvm.nvvm.sust.b.3d.i32.clamp
-    nvvm_sust_b_3d_i32_trap,                   // llvm.nvvm.sust.b.3d.i32.trap
-    nvvm_sust_b_3d_i32_zero,                   // llvm.nvvm.sust.b.3d.i32.zero
-    nvvm_sust_b_3d_i64_clamp,                  // llvm.nvvm.sust.b.3d.i64.clamp
-    nvvm_sust_b_3d_i64_trap,                   // llvm.nvvm.sust.b.3d.i64.trap
-    nvvm_sust_b_3d_i64_zero,                   // llvm.nvvm.sust.b.3d.i64.zero
-    nvvm_sust_b_3d_i8_clamp,                   // llvm.nvvm.sust.b.3d.i8.clamp
-    nvvm_sust_b_3d_i8_trap,                    // llvm.nvvm.sust.b.3d.i8.trap
-    nvvm_sust_b_3d_i8_zero,                    // llvm.nvvm.sust.b.3d.i8.zero
-    nvvm_sust_b_3d_v2i16_clamp,                // llvm.nvvm.sust.b.3d.v2i16.clamp
-    nvvm_sust_b_3d_v2i16_trap,                 // llvm.nvvm.sust.b.3d.v2i16.trap
-    nvvm_sust_b_3d_v2i16_zero,                 // llvm.nvvm.sust.b.3d.v2i16.zero
-    nvvm_sust_b_3d_v2i32_clamp,                // llvm.nvvm.sust.b.3d.v2i32.clamp
-    nvvm_sust_b_3d_v2i32_trap,                 // llvm.nvvm.sust.b.3d.v2i32.trap
-    nvvm_sust_b_3d_v2i32_zero,                 // llvm.nvvm.sust.b.3d.v2i32.zero
-    nvvm_sust_b_3d_v2i64_clamp,                // llvm.nvvm.sust.b.3d.v2i64.clamp
-    nvvm_sust_b_3d_v2i64_trap,                 // llvm.nvvm.sust.b.3d.v2i64.trap
-    nvvm_sust_b_3d_v2i64_zero,                 // llvm.nvvm.sust.b.3d.v2i64.zero
-    nvvm_sust_b_3d_v2i8_clamp,                 // llvm.nvvm.sust.b.3d.v2i8.clamp
-    nvvm_sust_b_3d_v2i8_trap,                  // llvm.nvvm.sust.b.3d.v2i8.trap
-    nvvm_sust_b_3d_v2i8_zero,                  // llvm.nvvm.sust.b.3d.v2i8.zero
-    nvvm_sust_b_3d_v4i16_clamp,                // llvm.nvvm.sust.b.3d.v4i16.clamp
-    nvvm_sust_b_3d_v4i16_trap,                 // llvm.nvvm.sust.b.3d.v4i16.trap
-    nvvm_sust_b_3d_v4i16_zero,                 // llvm.nvvm.sust.b.3d.v4i16.zero
-    nvvm_sust_b_3d_v4i32_clamp,                // llvm.nvvm.sust.b.3d.v4i32.clamp
-    nvvm_sust_b_3d_v4i32_trap,                 // llvm.nvvm.sust.b.3d.v4i32.trap
-    nvvm_sust_b_3d_v4i32_zero,                 // llvm.nvvm.sust.b.3d.v4i32.zero
-    nvvm_sust_b_3d_v4i8_clamp,                 // llvm.nvvm.sust.b.3d.v4i8.clamp
-    nvvm_sust_b_3d_v4i8_trap,                  // llvm.nvvm.sust.b.3d.v4i8.trap
-    nvvm_sust_b_3d_v4i8_zero,                  // llvm.nvvm.sust.b.3d.v4i8.zero
-    nvvm_sust_p_1d_array_i16_trap,             // llvm.nvvm.sust.p.1d.array.i16.trap
-    nvvm_sust_p_1d_array_i32_trap,             // llvm.nvvm.sust.p.1d.array.i32.trap
-    nvvm_sust_p_1d_array_i8_trap,              // llvm.nvvm.sust.p.1d.array.i8.trap
-    nvvm_sust_p_1d_array_v2i16_trap,           // llvm.nvvm.sust.p.1d.array.v2i16.trap
-    nvvm_sust_p_1d_array_v2i32_trap,           // llvm.nvvm.sust.p.1d.array.v2i32.trap
-    nvvm_sust_p_1d_array_v2i8_trap,            // llvm.nvvm.sust.p.1d.array.v2i8.trap
-    nvvm_sust_p_1d_array_v4i16_trap,           // llvm.nvvm.sust.p.1d.array.v4i16.trap
-    nvvm_sust_p_1d_array_v4i32_trap,           // llvm.nvvm.sust.p.1d.array.v4i32.trap
-    nvvm_sust_p_1d_array_v4i8_trap,            // llvm.nvvm.sust.p.1d.array.v4i8.trap
-    nvvm_sust_p_1d_i16_trap,                   // llvm.nvvm.sust.p.1d.i16.trap
-    nvvm_sust_p_1d_i32_trap,                   // llvm.nvvm.sust.p.1d.i32.trap
-    nvvm_sust_p_1d_i8_trap,                    // llvm.nvvm.sust.p.1d.i8.trap
-    nvvm_sust_p_1d_v2i16_trap,                 // llvm.nvvm.sust.p.1d.v2i16.trap
-    nvvm_sust_p_1d_v2i32_trap,                 // llvm.nvvm.sust.p.1d.v2i32.trap
-    nvvm_sust_p_1d_v2i8_trap,                  // llvm.nvvm.sust.p.1d.v2i8.trap
-    nvvm_sust_p_1d_v4i16_trap,                 // llvm.nvvm.sust.p.1d.v4i16.trap
-    nvvm_sust_p_1d_v4i32_trap,                 // llvm.nvvm.sust.p.1d.v4i32.trap
-    nvvm_sust_p_1d_v4i8_trap,                  // llvm.nvvm.sust.p.1d.v4i8.trap
-    nvvm_sust_p_2d_array_i16_trap,             // llvm.nvvm.sust.p.2d.array.i16.trap
-    nvvm_sust_p_2d_array_i32_trap,             // llvm.nvvm.sust.p.2d.array.i32.trap
-    nvvm_sust_p_2d_array_i8_trap,              // llvm.nvvm.sust.p.2d.array.i8.trap
-    nvvm_sust_p_2d_array_v2i16_trap,           // llvm.nvvm.sust.p.2d.array.v2i16.trap
-    nvvm_sust_p_2d_array_v2i32_trap,           // llvm.nvvm.sust.p.2d.array.v2i32.trap
-    nvvm_sust_p_2d_array_v2i8_trap,            // llvm.nvvm.sust.p.2d.array.v2i8.trap
-    nvvm_sust_p_2d_array_v4i16_trap,           // llvm.nvvm.sust.p.2d.array.v4i16.trap
-    nvvm_sust_p_2d_array_v4i32_trap,           // llvm.nvvm.sust.p.2d.array.v4i32.trap
-    nvvm_sust_p_2d_array_v4i8_trap,            // llvm.nvvm.sust.p.2d.array.v4i8.trap
-    nvvm_sust_p_2d_i16_trap,                   // llvm.nvvm.sust.p.2d.i16.trap
-    nvvm_sust_p_2d_i32_trap,                   // llvm.nvvm.sust.p.2d.i32.trap
-    nvvm_sust_p_2d_i8_trap,                    // llvm.nvvm.sust.p.2d.i8.trap
-    nvvm_sust_p_2d_v2i16_trap,                 // llvm.nvvm.sust.p.2d.v2i16.trap
-    nvvm_sust_p_2d_v2i32_trap,                 // llvm.nvvm.sust.p.2d.v2i32.trap
-    nvvm_sust_p_2d_v2i8_trap,                  // llvm.nvvm.sust.p.2d.v2i8.trap
-    nvvm_sust_p_2d_v4i16_trap,                 // llvm.nvvm.sust.p.2d.v4i16.trap
-    nvvm_sust_p_2d_v4i32_trap,                 // llvm.nvvm.sust.p.2d.v4i32.trap
-    nvvm_sust_p_2d_v4i8_trap,                  // llvm.nvvm.sust.p.2d.v4i8.trap
-    nvvm_sust_p_3d_i16_trap,                   // llvm.nvvm.sust.p.3d.i16.trap
-    nvvm_sust_p_3d_i32_trap,                   // llvm.nvvm.sust.p.3d.i32.trap
-    nvvm_sust_p_3d_i8_trap,                    // llvm.nvvm.sust.p.3d.i8.trap
-    nvvm_sust_p_3d_v2i16_trap,                 // llvm.nvvm.sust.p.3d.v2i16.trap
-    nvvm_sust_p_3d_v2i32_trap,                 // llvm.nvvm.sust.p.3d.v2i32.trap
-    nvvm_sust_p_3d_v2i8_trap,                  // llvm.nvvm.sust.p.3d.v2i8.trap
-    nvvm_sust_p_3d_v4i16_trap,                 // llvm.nvvm.sust.p.3d.v4i16.trap
-    nvvm_sust_p_3d_v4i32_trap,                 // llvm.nvvm.sust.p.3d.v4i32.trap
-    nvvm_sust_p_3d_v4i8_trap,                  // llvm.nvvm.sust.p.3d.v4i8.trap
-    nvvm_swap_lo_hi_b64,                       // llvm.nvvm.swap.lo.hi.b64
-    nvvm_tex_1d_array_grad_v4f32_f32,          // llvm.nvvm.tex.1d.array.grad.v4f32.f32
-    nvvm_tex_1d_array_grad_v4s32_f32,          // llvm.nvvm.tex.1d.array.grad.v4s32.f32
-    nvvm_tex_1d_array_grad_v4u32_f32,          // llvm.nvvm.tex.1d.array.grad.v4u32.f32
-    nvvm_tex_1d_array_level_v4f32_f32,         // llvm.nvvm.tex.1d.array.level.v4f32.f32
-    nvvm_tex_1d_array_level_v4s32_f32,         // llvm.nvvm.tex.1d.array.level.v4s32.f32
-    nvvm_tex_1d_array_level_v4u32_f32,         // llvm.nvvm.tex.1d.array.level.v4u32.f32
-    nvvm_tex_1d_array_v4f32_f32,               // llvm.nvvm.tex.1d.array.v4f32.f32
-    nvvm_tex_1d_array_v4f32_s32,               // llvm.nvvm.tex.1d.array.v4f32.s32
-    nvvm_tex_1d_array_v4s32_f32,               // llvm.nvvm.tex.1d.array.v4s32.f32
-    nvvm_tex_1d_array_v4s32_s32,               // llvm.nvvm.tex.1d.array.v4s32.s32
-    nvvm_tex_1d_array_v4u32_f32,               // llvm.nvvm.tex.1d.array.v4u32.f32
-    nvvm_tex_1d_array_v4u32_s32,               // llvm.nvvm.tex.1d.array.v4u32.s32
-    nvvm_tex_1d_grad_v4f32_f32,                // llvm.nvvm.tex.1d.grad.v4f32.f32
-    nvvm_tex_1d_grad_v4s32_f32,                // llvm.nvvm.tex.1d.grad.v4s32.f32
-    nvvm_tex_1d_grad_v4u32_f32,                // llvm.nvvm.tex.1d.grad.v4u32.f32
-    nvvm_tex_1d_level_v4f32_f32,               // llvm.nvvm.tex.1d.level.v4f32.f32
-    nvvm_tex_1d_level_v4s32_f32,               // llvm.nvvm.tex.1d.level.v4s32.f32
-    nvvm_tex_1d_level_v4u32_f32,               // llvm.nvvm.tex.1d.level.v4u32.f32
-    nvvm_tex_1d_v4f32_f32,                     // llvm.nvvm.tex.1d.v4f32.f32
-    nvvm_tex_1d_v4f32_s32,                     // llvm.nvvm.tex.1d.v4f32.s32
-    nvvm_tex_1d_v4s32_f32,                     // llvm.nvvm.tex.1d.v4s32.f32
-    nvvm_tex_1d_v4s32_s32,                     // llvm.nvvm.tex.1d.v4s32.s32
-    nvvm_tex_1d_v4u32_f32,                     // llvm.nvvm.tex.1d.v4u32.f32
-    nvvm_tex_1d_v4u32_s32,                     // llvm.nvvm.tex.1d.v4u32.s32
-    nvvm_tex_2d_array_grad_v4f32_f32,          // llvm.nvvm.tex.2d.array.grad.v4f32.f32
-    nvvm_tex_2d_array_grad_v4s32_f32,          // llvm.nvvm.tex.2d.array.grad.v4s32.f32
-    nvvm_tex_2d_array_grad_v4u32_f32,          // llvm.nvvm.tex.2d.array.grad.v4u32.f32
-    nvvm_tex_2d_array_level_v4f32_f32,         // llvm.nvvm.tex.2d.array.level.v4f32.f32
-    nvvm_tex_2d_array_level_v4s32_f32,         // llvm.nvvm.tex.2d.array.level.v4s32.f32
-    nvvm_tex_2d_array_level_v4u32_f32,         // llvm.nvvm.tex.2d.array.level.v4u32.f32
-    nvvm_tex_2d_array_v4f32_f32,               // llvm.nvvm.tex.2d.array.v4f32.f32
-    nvvm_tex_2d_array_v4f32_s32,               // llvm.nvvm.tex.2d.array.v4f32.s32
-    nvvm_tex_2d_array_v4s32_f32,               // llvm.nvvm.tex.2d.array.v4s32.f32
-    nvvm_tex_2d_array_v4s32_s32,               // llvm.nvvm.tex.2d.array.v4s32.s32
-    nvvm_tex_2d_array_v4u32_f32,               // llvm.nvvm.tex.2d.array.v4u32.f32
-    nvvm_tex_2d_array_v4u32_s32,               // llvm.nvvm.tex.2d.array.v4u32.s32
-    nvvm_tex_2d_grad_v4f32_f32,                // llvm.nvvm.tex.2d.grad.v4f32.f32
-    nvvm_tex_2d_grad_v4s32_f32,                // llvm.nvvm.tex.2d.grad.v4s32.f32
-    nvvm_tex_2d_grad_v4u32_f32,                // llvm.nvvm.tex.2d.grad.v4u32.f32
-    nvvm_tex_2d_level_v4f32_f32,               // llvm.nvvm.tex.2d.level.v4f32.f32
-    nvvm_tex_2d_level_v4s32_f32,               // llvm.nvvm.tex.2d.level.v4s32.f32
-    nvvm_tex_2d_level_v4u32_f32,               // llvm.nvvm.tex.2d.level.v4u32.f32
-    nvvm_tex_2d_v4f32_f32,                     // llvm.nvvm.tex.2d.v4f32.f32
-    nvvm_tex_2d_v4f32_s32,                     // llvm.nvvm.tex.2d.v4f32.s32
-    nvvm_tex_2d_v4s32_f32,                     // llvm.nvvm.tex.2d.v4s32.f32
-    nvvm_tex_2d_v4s32_s32,                     // llvm.nvvm.tex.2d.v4s32.s32
-    nvvm_tex_2d_v4u32_f32,                     // llvm.nvvm.tex.2d.v4u32.f32
-    nvvm_tex_2d_v4u32_s32,                     // llvm.nvvm.tex.2d.v4u32.s32
-    nvvm_tex_3d_grad_v4f32_f32,                // llvm.nvvm.tex.3d.grad.v4f32.f32
-    nvvm_tex_3d_grad_v4s32_f32,                // llvm.nvvm.tex.3d.grad.v4s32.f32
-    nvvm_tex_3d_grad_v4u32_f32,                // llvm.nvvm.tex.3d.grad.v4u32.f32
-    nvvm_tex_3d_level_v4f32_f32,               // llvm.nvvm.tex.3d.level.v4f32.f32
-    nvvm_tex_3d_level_v4s32_f32,               // llvm.nvvm.tex.3d.level.v4s32.f32
-    nvvm_tex_3d_level_v4u32_f32,               // llvm.nvvm.tex.3d.level.v4u32.f32
-    nvvm_tex_3d_v4f32_f32,                     // llvm.nvvm.tex.3d.v4f32.f32
-    nvvm_tex_3d_v4f32_s32,                     // llvm.nvvm.tex.3d.v4f32.s32
-    nvvm_tex_3d_v4s32_f32,                     // llvm.nvvm.tex.3d.v4s32.f32
-    nvvm_tex_3d_v4s32_s32,                     // llvm.nvvm.tex.3d.v4s32.s32
-    nvvm_tex_3d_v4u32_f32,                     // llvm.nvvm.tex.3d.v4u32.f32
-    nvvm_tex_3d_v4u32_s32,                     // llvm.nvvm.tex.3d.v4u32.s32
-    nvvm_tex_cube_array_level_v4f32_f32,       // llvm.nvvm.tex.cube.array.level.v4f32.f32
-    nvvm_tex_cube_array_level_v4s32_f32,       // llvm.nvvm.tex.cube.array.level.v4s32.f32
-    nvvm_tex_cube_array_level_v4u32_f32,       // llvm.nvvm.tex.cube.array.level.v4u32.f32
-    nvvm_tex_cube_array_v4f32_f32,             // llvm.nvvm.tex.cube.array.v4f32.f32
-    nvvm_tex_cube_array_v4s32_f32,             // llvm.nvvm.tex.cube.array.v4s32.f32
-    nvvm_tex_cube_array_v4u32_f32,             // llvm.nvvm.tex.cube.array.v4u32.f32
-    nvvm_tex_cube_level_v4f32_f32,             // llvm.nvvm.tex.cube.level.v4f32.f32
-    nvvm_tex_cube_level_v4s32_f32,             // llvm.nvvm.tex.cube.level.v4s32.f32
-    nvvm_tex_cube_level_v4u32_f32,             // llvm.nvvm.tex.cube.level.v4u32.f32
-    nvvm_tex_cube_v4f32_f32,                   // llvm.nvvm.tex.cube.v4f32.f32
-    nvvm_tex_cube_v4s32_f32,                   // llvm.nvvm.tex.cube.v4s32.f32
-    nvvm_tex_cube_v4u32_f32,                   // llvm.nvvm.tex.cube.v4u32.f32
-    nvvm_tex_unified_1d_array_grad_v4f32_f32,  // llvm.nvvm.tex.unified.1d.array.grad.v4f32.f32
-    nvvm_tex_unified_1d_array_grad_v4s32_f32,  // llvm.nvvm.tex.unified.1d.array.grad.v4s32.f32
-    nvvm_tex_unified_1d_array_grad_v4u32_f32,  // llvm.nvvm.tex.unified.1d.array.grad.v4u32.f32
-    nvvm_tex_unified_1d_array_level_v4f32_f32,  // llvm.nvvm.tex.unified.1d.array.level.v4f32.f32
-    nvvm_tex_unified_1d_array_level_v4s32_f32,  // llvm.nvvm.tex.unified.1d.array.level.v4s32.f32
-    nvvm_tex_unified_1d_array_level_v4u32_f32,  // llvm.nvvm.tex.unified.1d.array.level.v4u32.f32
-    nvvm_tex_unified_1d_array_v4f32_f32,       // llvm.nvvm.tex.unified.1d.array.v4f32.f32
-    nvvm_tex_unified_1d_array_v4f32_s32,       // llvm.nvvm.tex.unified.1d.array.v4f32.s32
-    nvvm_tex_unified_1d_array_v4s32_f32,       // llvm.nvvm.tex.unified.1d.array.v4s32.f32
-    nvvm_tex_unified_1d_array_v4s32_s32,       // llvm.nvvm.tex.unified.1d.array.v4s32.s32
-    nvvm_tex_unified_1d_array_v4u32_f32,       // llvm.nvvm.tex.unified.1d.array.v4u32.f32
-    nvvm_tex_unified_1d_array_v4u32_s32,       // llvm.nvvm.tex.unified.1d.array.v4u32.s32
-    nvvm_tex_unified_1d_grad_v4f32_f32,        // llvm.nvvm.tex.unified.1d.grad.v4f32.f32
-    nvvm_tex_unified_1d_grad_v4s32_f32,        // llvm.nvvm.tex.unified.1d.grad.v4s32.f32
-    nvvm_tex_unified_1d_grad_v4u32_f32,        // llvm.nvvm.tex.unified.1d.grad.v4u32.f32
-    nvvm_tex_unified_1d_level_v4f32_f32,       // llvm.nvvm.tex.unified.1d.level.v4f32.f32
-    nvvm_tex_unified_1d_level_v4s32_f32,       // llvm.nvvm.tex.unified.1d.level.v4s32.f32
-    nvvm_tex_unified_1d_level_v4u32_f32,       // llvm.nvvm.tex.unified.1d.level.v4u32.f32
-    nvvm_tex_unified_1d_v4f32_f32,             // llvm.nvvm.tex.unified.1d.v4f32.f32
-    nvvm_tex_unified_1d_v4f32_s32,             // llvm.nvvm.tex.unified.1d.v4f32.s32
-    nvvm_tex_unified_1d_v4s32_f32,             // llvm.nvvm.tex.unified.1d.v4s32.f32
-    nvvm_tex_unified_1d_v4s32_s32,             // llvm.nvvm.tex.unified.1d.v4s32.s32
-    nvvm_tex_unified_1d_v4u32_f32,             // llvm.nvvm.tex.unified.1d.v4u32.f32
-    nvvm_tex_unified_1d_v4u32_s32,             // llvm.nvvm.tex.unified.1d.v4u32.s32
-    nvvm_tex_unified_2d_array_grad_v4f32_f32,  // llvm.nvvm.tex.unified.2d.array.grad.v4f32.f32
-    nvvm_tex_unified_2d_array_grad_v4s32_f32,  // llvm.nvvm.tex.unified.2d.array.grad.v4s32.f32
-    nvvm_tex_unified_2d_array_grad_v4u32_f32,  // llvm.nvvm.tex.unified.2d.array.grad.v4u32.f32
-    nvvm_tex_unified_2d_array_level_v4f32_f32,  // llvm.nvvm.tex.unified.2d.array.level.v4f32.f32
-    nvvm_tex_unified_2d_array_level_v4s32_f32,  // llvm.nvvm.tex.unified.2d.array.level.v4s32.f32
-    nvvm_tex_unified_2d_array_level_v4u32_f32,  // llvm.nvvm.tex.unified.2d.array.level.v4u32.f32
-    nvvm_tex_unified_2d_array_v4f32_f32,       // llvm.nvvm.tex.unified.2d.array.v4f32.f32
-    nvvm_tex_unified_2d_array_v4f32_s32,       // llvm.nvvm.tex.unified.2d.array.v4f32.s32
-    nvvm_tex_unified_2d_array_v4s32_f32,       // llvm.nvvm.tex.unified.2d.array.v4s32.f32
-    nvvm_tex_unified_2d_array_v4s32_s32,       // llvm.nvvm.tex.unified.2d.array.v4s32.s32
-    nvvm_tex_unified_2d_array_v4u32_f32,       // llvm.nvvm.tex.unified.2d.array.v4u32.f32
-    nvvm_tex_unified_2d_array_v4u32_s32,       // llvm.nvvm.tex.unified.2d.array.v4u32.s32
-    nvvm_tex_unified_2d_grad_v4f32_f32,        // llvm.nvvm.tex.unified.2d.grad.v4f32.f32
-    nvvm_tex_unified_2d_grad_v4s32_f32,        // llvm.nvvm.tex.unified.2d.grad.v4s32.f32
-    nvvm_tex_unified_2d_grad_v4u32_f32,        // llvm.nvvm.tex.unified.2d.grad.v4u32.f32
-    nvvm_tex_unified_2d_level_v4f32_f32,       // llvm.nvvm.tex.unified.2d.level.v4f32.f32
-    nvvm_tex_unified_2d_level_v4s32_f32,       // llvm.nvvm.tex.unified.2d.level.v4s32.f32
-    nvvm_tex_unified_2d_level_v4u32_f32,       // llvm.nvvm.tex.unified.2d.level.v4u32.f32
-    nvvm_tex_unified_2d_v4f32_f32,             // llvm.nvvm.tex.unified.2d.v4f32.f32
-    nvvm_tex_unified_2d_v4f32_s32,             // llvm.nvvm.tex.unified.2d.v4f32.s32
-    nvvm_tex_unified_2d_v4s32_f32,             // llvm.nvvm.tex.unified.2d.v4s32.f32
-    nvvm_tex_unified_2d_v4s32_s32,             // llvm.nvvm.tex.unified.2d.v4s32.s32
-    nvvm_tex_unified_2d_v4u32_f32,             // llvm.nvvm.tex.unified.2d.v4u32.f32
-    nvvm_tex_unified_2d_v4u32_s32,             // llvm.nvvm.tex.unified.2d.v4u32.s32
-    nvvm_tex_unified_3d_grad_v4f32_f32,        // llvm.nvvm.tex.unified.3d.grad.v4f32.f32
-    nvvm_tex_unified_3d_grad_v4s32_f32,        // llvm.nvvm.tex.unified.3d.grad.v4s32.f32
-    nvvm_tex_unified_3d_grad_v4u32_f32,        // llvm.nvvm.tex.unified.3d.grad.v4u32.f32
-    nvvm_tex_unified_3d_level_v4f32_f32,       // llvm.nvvm.tex.unified.3d.level.v4f32.f32
-    nvvm_tex_unified_3d_level_v4s32_f32,       // llvm.nvvm.tex.unified.3d.level.v4s32.f32
-    nvvm_tex_unified_3d_level_v4u32_f32,       // llvm.nvvm.tex.unified.3d.level.v4u32.f32
-    nvvm_tex_unified_3d_v4f32_f32,             // llvm.nvvm.tex.unified.3d.v4f32.f32
-    nvvm_tex_unified_3d_v4f32_s32,             // llvm.nvvm.tex.unified.3d.v4f32.s32
-    nvvm_tex_unified_3d_v4s32_f32,             // llvm.nvvm.tex.unified.3d.v4s32.f32
-    nvvm_tex_unified_3d_v4s32_s32,             // llvm.nvvm.tex.unified.3d.v4s32.s32
-    nvvm_tex_unified_3d_v4u32_f32,             // llvm.nvvm.tex.unified.3d.v4u32.f32
-    nvvm_tex_unified_3d_v4u32_s32,             // llvm.nvvm.tex.unified.3d.v4u32.s32
-    nvvm_tex_unified_cube_array_level_v4f32_f32,  // llvm.nvvm.tex.unified.cube.array.level.v4f32.f32
-    nvvm_tex_unified_cube_array_level_v4s32_f32,  // llvm.nvvm.tex.unified.cube.array.level.v4s32.f32
-    nvvm_tex_unified_cube_array_level_v4u32_f32,  // llvm.nvvm.tex.unified.cube.array.level.v4u32.f32
-    nvvm_tex_unified_cube_array_v4f32_f32,     // llvm.nvvm.tex.unified.cube.array.v4f32.f32
-    nvvm_tex_unified_cube_array_v4s32_f32,     // llvm.nvvm.tex.unified.cube.array.v4s32.f32
-    nvvm_tex_unified_cube_array_v4u32_f32,     // llvm.nvvm.tex.unified.cube.array.v4u32.f32
-    nvvm_tex_unified_cube_level_v4f32_f32,     // llvm.nvvm.tex.unified.cube.level.v4f32.f32
-    nvvm_tex_unified_cube_level_v4s32_f32,     // llvm.nvvm.tex.unified.cube.level.v4s32.f32
-    nvvm_tex_unified_cube_level_v4u32_f32,     // llvm.nvvm.tex.unified.cube.level.v4u32.f32
-    nvvm_tex_unified_cube_v4f32_f32,           // llvm.nvvm.tex.unified.cube.v4f32.f32
-    nvvm_tex_unified_cube_v4s32_f32,           // llvm.nvvm.tex.unified.cube.v4s32.f32
-    nvvm_tex_unified_cube_v4u32_f32,           // llvm.nvvm.tex.unified.cube.v4u32.f32
-    nvvm_texsurf_handle,                       // llvm.nvvm.texsurf.handle
-    nvvm_texsurf_handle_internal,              // llvm.nvvm.texsurf.handle.internal
-    nvvm_tld4_a_2d_v4f32_f32,                  // llvm.nvvm.tld4.a.2d.v4f32.f32
-    nvvm_tld4_a_2d_v4s32_f32,                  // llvm.nvvm.tld4.a.2d.v4s32.f32
-    nvvm_tld4_a_2d_v4u32_f32,                  // llvm.nvvm.tld4.a.2d.v4u32.f32
-    nvvm_tld4_b_2d_v4f32_f32,                  // llvm.nvvm.tld4.b.2d.v4f32.f32
-    nvvm_tld4_b_2d_v4s32_f32,                  // llvm.nvvm.tld4.b.2d.v4s32.f32
-    nvvm_tld4_b_2d_v4u32_f32,                  // llvm.nvvm.tld4.b.2d.v4u32.f32
-    nvvm_tld4_g_2d_v4f32_f32,                  // llvm.nvvm.tld4.g.2d.v4f32.f32
-    nvvm_tld4_g_2d_v4s32_f32,                  // llvm.nvvm.tld4.g.2d.v4s32.f32
-    nvvm_tld4_g_2d_v4u32_f32,                  // llvm.nvvm.tld4.g.2d.v4u32.f32
-    nvvm_tld4_r_2d_v4f32_f32,                  // llvm.nvvm.tld4.r.2d.v4f32.f32
-    nvvm_tld4_r_2d_v4s32_f32,                  // llvm.nvvm.tld4.r.2d.v4s32.f32
-    nvvm_tld4_r_2d_v4u32_f32,                  // llvm.nvvm.tld4.r.2d.v4u32.f32
-    nvvm_tld4_unified_a_2d_v4f32_f32,          // llvm.nvvm.tld4.unified.a.2d.v4f32.f32
-    nvvm_tld4_unified_a_2d_v4s32_f32,          // llvm.nvvm.tld4.unified.a.2d.v4s32.f32
-    nvvm_tld4_unified_a_2d_v4u32_f32,          // llvm.nvvm.tld4.unified.a.2d.v4u32.f32
-    nvvm_tld4_unified_b_2d_v4f32_f32,          // llvm.nvvm.tld4.unified.b.2d.v4f32.f32
-    nvvm_tld4_unified_b_2d_v4s32_f32,          // llvm.nvvm.tld4.unified.b.2d.v4s32.f32
-    nvvm_tld4_unified_b_2d_v4u32_f32,          // llvm.nvvm.tld4.unified.b.2d.v4u32.f32
-    nvvm_tld4_unified_g_2d_v4f32_f32,          // llvm.nvvm.tld4.unified.g.2d.v4f32.f32
-    nvvm_tld4_unified_g_2d_v4s32_f32,          // llvm.nvvm.tld4.unified.g.2d.v4s32.f32
-    nvvm_tld4_unified_g_2d_v4u32_f32,          // llvm.nvvm.tld4.unified.g.2d.v4u32.f32
-    nvvm_tld4_unified_r_2d_v4f32_f32,          // llvm.nvvm.tld4.unified.r.2d.v4f32.f32
-    nvvm_tld4_unified_r_2d_v4s32_f32,          // llvm.nvvm.tld4.unified.r.2d.v4s32.f32
-    nvvm_tld4_unified_r_2d_v4u32_f32,          // llvm.nvvm.tld4.unified.r.2d.v4u32.f32
-    nvvm_trunc_d,                              // llvm.nvvm.trunc.d
-    nvvm_trunc_f,                              // llvm.nvvm.trunc.f
-    nvvm_trunc_ftz_f,                          // llvm.nvvm.trunc.ftz.f
-    nvvm_txq_array_size,                       // llvm.nvvm.txq.array.size
-    nvvm_txq_channel_data_type,                // llvm.nvvm.txq.channel.data.type
-    nvvm_txq_channel_order,                    // llvm.nvvm.txq.channel.order
-    nvvm_txq_depth,                            // llvm.nvvm.txq.depth
-    nvvm_txq_height,                           // llvm.nvvm.txq.height
-    nvvm_txq_num_mipmap_levels,                // llvm.nvvm.txq.num.mipmap.levels
-    nvvm_txq_num_samples,                      // llvm.nvvm.txq.num.samples
-    nvvm_txq_width,                            // llvm.nvvm.txq.width
-    nvvm_ui2d_rm,                              // llvm.nvvm.ui2d.rm
-    nvvm_ui2d_rn,                              // llvm.nvvm.ui2d.rn
-    nvvm_ui2d_rp,                              // llvm.nvvm.ui2d.rp
-    nvvm_ui2d_rz,                              // llvm.nvvm.ui2d.rz
-    nvvm_ui2f_rm,                              // llvm.nvvm.ui2f.rm
-    nvvm_ui2f_rn,                              // llvm.nvvm.ui2f.rn
-    nvvm_ui2f_rp,                              // llvm.nvvm.ui2f.rp
-    nvvm_ui2f_rz,                              // llvm.nvvm.ui2f.rz
-    nvvm_ull2d_rm,                             // llvm.nvvm.ull2d.rm
-    nvvm_ull2d_rn,                             // llvm.nvvm.ull2d.rn
-    nvvm_ull2d_rp,                             // llvm.nvvm.ull2d.rp
-    nvvm_ull2d_rz,                             // llvm.nvvm.ull2d.rz
-    nvvm_ull2f_rm,                             // llvm.nvvm.ull2f.rm
-    nvvm_ull2f_rn,                             // llvm.nvvm.ull2f.rn
-    nvvm_ull2f_rp,                             // llvm.nvvm.ull2f.rp
-    nvvm_ull2f_rz,                             // llvm.nvvm.ull2f.rz
-    nvvm_vote_all,                             // llvm.nvvm.vote.all
-    nvvm_vote_all_sync,                        // llvm.nvvm.vote.all.sync
-    nvvm_vote_any,                             // llvm.nvvm.vote.any
-    nvvm_vote_any_sync,                        // llvm.nvvm.vote.any.sync
-    nvvm_vote_ballot,                          // llvm.nvvm.vote.ballot
-    nvvm_vote_ballot_sync,                     // llvm.nvvm.vote.ballot.sync
-    nvvm_vote_uni,                             // llvm.nvvm.vote.uni
-    nvvm_vote_uni_sync,                        // llvm.nvvm.vote.uni.sync
-    nvvm_wmma_m16n16k16_load_a_f16_col,        // llvm.nvvm.wmma.m16n16k16.load.a.col.f16
-    nvvm_wmma_m16n16k16_load_a_s8_col,         // llvm.nvvm.wmma.m16n16k16.load.a.col.s8
-    nvvm_wmma_m16n16k16_load_a_f16_col_stride,  // llvm.nvvm.wmma.m16n16k16.load.a.col.stride.f16
-    nvvm_wmma_m16n16k16_load_a_s8_col_stride,  // llvm.nvvm.wmma.m16n16k16.load.a.col.stride.s8
-    nvvm_wmma_m16n16k16_load_a_u8_col_stride,  // llvm.nvvm.wmma.m16n16k16.load.a.col.stride.u8
-    nvvm_wmma_m16n16k16_load_a_u8_col,         // llvm.nvvm.wmma.m16n16k16.load.a.col.u8
-    nvvm_wmma_m16n16k16_load_a_f16_row,        // llvm.nvvm.wmma.m16n16k16.load.a.row.f16
-    nvvm_wmma_m16n16k16_load_a_s8_row,         // llvm.nvvm.wmma.m16n16k16.load.a.row.s8
-    nvvm_wmma_m16n16k16_load_a_f16_row_stride,  // llvm.nvvm.wmma.m16n16k16.load.a.row.stride.f16
-    nvvm_wmma_m16n16k16_load_a_s8_row_stride,  // llvm.nvvm.wmma.m16n16k16.load.a.row.stride.s8
-    nvvm_wmma_m16n16k16_load_a_u8_row_stride,  // llvm.nvvm.wmma.m16n16k16.load.a.row.stride.u8
-    nvvm_wmma_m16n16k16_load_a_u8_row,         // llvm.nvvm.wmma.m16n16k16.load.a.row.u8
-    nvvm_wmma_m16n16k16_load_b_f16_col,        // llvm.nvvm.wmma.m16n16k16.load.b.col.f16
-    nvvm_wmma_m16n16k16_load_b_s8_col,         // llvm.nvvm.wmma.m16n16k16.load.b.col.s8
-    nvvm_wmma_m16n16k16_load_b_f16_col_stride,  // llvm.nvvm.wmma.m16n16k16.load.b.col.stride.f16
-    nvvm_wmma_m16n16k16_load_b_s8_col_stride,  // llvm.nvvm.wmma.m16n16k16.load.b.col.stride.s8
-    nvvm_wmma_m16n16k16_load_b_u8_col_stride,  // llvm.nvvm.wmma.m16n16k16.load.b.col.stride.u8
-    nvvm_wmma_m16n16k16_load_b_u8_col,         // llvm.nvvm.wmma.m16n16k16.load.b.col.u8
-    nvvm_wmma_m16n16k16_load_b_f16_row,        // llvm.nvvm.wmma.m16n16k16.load.b.row.f16
-    nvvm_wmma_m16n16k16_load_b_s8_row,         // llvm.nvvm.wmma.m16n16k16.load.b.row.s8
-    nvvm_wmma_m16n16k16_load_b_f16_row_stride,  // llvm.nvvm.wmma.m16n16k16.load.b.row.stride.f16
-    nvvm_wmma_m16n16k16_load_b_s8_row_stride,  // llvm.nvvm.wmma.m16n16k16.load.b.row.stride.s8
-    nvvm_wmma_m16n16k16_load_b_u8_row_stride,  // llvm.nvvm.wmma.m16n16k16.load.b.row.stride.u8
-    nvvm_wmma_m16n16k16_load_b_u8_row,         // llvm.nvvm.wmma.m16n16k16.load.b.row.u8
-    nvvm_wmma_m16n16k16_load_c_f16_col,        // llvm.nvvm.wmma.m16n16k16.load.c.col.f16
-    nvvm_wmma_m16n16k16_load_c_f32_col,        // llvm.nvvm.wmma.m16n16k16.load.c.col.f32
-    nvvm_wmma_m16n16k16_load_c_s32_col,        // llvm.nvvm.wmma.m16n16k16.load.c.col.s32
-    nvvm_wmma_m16n16k16_load_c_f16_col_stride,  // llvm.nvvm.wmma.m16n16k16.load.c.col.stride.f16
-    nvvm_wmma_m16n16k16_load_c_f32_col_stride,  // llvm.nvvm.wmma.m16n16k16.load.c.col.stride.f32
-    nvvm_wmma_m16n16k16_load_c_s32_col_stride,  // llvm.nvvm.wmma.m16n16k16.load.c.col.stride.s32
-    nvvm_wmma_m16n16k16_load_c_f16_row,        // llvm.nvvm.wmma.m16n16k16.load.c.row.f16
-    nvvm_wmma_m16n16k16_load_c_f32_row,        // llvm.nvvm.wmma.m16n16k16.load.c.row.f32
-    nvvm_wmma_m16n16k16_load_c_s32_row,        // llvm.nvvm.wmma.m16n16k16.load.c.row.s32
-    nvvm_wmma_m16n16k16_load_c_f16_row_stride,  // llvm.nvvm.wmma.m16n16k16.load.c.row.stride.f16
-    nvvm_wmma_m16n16k16_load_c_f32_row_stride,  // llvm.nvvm.wmma.m16n16k16.load.c.row.stride.f32
-    nvvm_wmma_m16n16k16_load_c_s32_row_stride,  // llvm.nvvm.wmma.m16n16k16.load.c.row.stride.s32
-    nvvm_wmma_m16n16k16_mma_col_col_f16_f16,   // llvm.nvvm.wmma.m16n16k16.mma.col.col.f16.f16
-    nvvm_wmma_m16n16k16_mma_col_col_f16_f16_satfinite,  // llvm.nvvm.wmma.m16n16k16.mma.col.col.f16.f16.satfinite
-    nvvm_wmma_m16n16k16_mma_col_col_f16_f32,   // llvm.nvvm.wmma.m16n16k16.mma.col.col.f16.f32
-    nvvm_wmma_m16n16k16_mma_col_col_f16_f32_satfinite,  // llvm.nvvm.wmma.m16n16k16.mma.col.col.f16.f32.satfinite
-    nvvm_wmma_m16n16k16_mma_col_col_f32_f16,   // llvm.nvvm.wmma.m16n16k16.mma.col.col.f32.f16
-    nvvm_wmma_m16n16k16_mma_col_col_f32_f16_satfinite,  // llvm.nvvm.wmma.m16n16k16.mma.col.col.f32.f16.satfinite
-    nvvm_wmma_m16n16k16_mma_col_col_f32_f32,   // llvm.nvvm.wmma.m16n16k16.mma.col.col.f32.f32
-    nvvm_wmma_m16n16k16_mma_col_col_f32_f32_satfinite,  // llvm.nvvm.wmma.m16n16k16.mma.col.col.f32.f32.satfinite
-    nvvm_wmma_m16n16k16_mma_col_col_s8,        // llvm.nvvm.wmma.m16n16k16.mma.col.col.s8
-    nvvm_wmma_m16n16k16_mma_col_col_s8_satfinite,  // llvm.nvvm.wmma.m16n16k16.mma.col.col.s8.satfinite
-    nvvm_wmma_m16n16k16_mma_col_col_u8,        // llvm.nvvm.wmma.m16n16k16.mma.col.col.u8
-    nvvm_wmma_m16n16k16_mma_col_col_u8_satfinite,  // llvm.nvvm.wmma.m16n16k16.mma.col.col.u8.satfinite
-    nvvm_wmma_m16n16k16_mma_col_row_f16_f16,   // llvm.nvvm.wmma.m16n16k16.mma.col.row.f16.f16
-    nvvm_wmma_m16n16k16_mma_col_row_f16_f16_satfinite,  // llvm.nvvm.wmma.m16n16k16.mma.col.row.f16.f16.satfinite
-    nvvm_wmma_m16n16k16_mma_col_row_f16_f32,   // llvm.nvvm.wmma.m16n16k16.mma.col.row.f16.f32
-    nvvm_wmma_m16n16k16_mma_col_row_f16_f32_satfinite,  // llvm.nvvm.wmma.m16n16k16.mma.col.row.f16.f32.satfinite
-    nvvm_wmma_m16n16k16_mma_col_row_f32_f16,   // llvm.nvvm.wmma.m16n16k16.mma.col.row.f32.f16
-    nvvm_wmma_m16n16k16_mma_col_row_f32_f16_satfinite,  // llvm.nvvm.wmma.m16n16k16.mma.col.row.f32.f16.satfinite
-    nvvm_wmma_m16n16k16_mma_col_row_f32_f32,   // llvm.nvvm.wmma.m16n16k16.mma.col.row.f32.f32
-    nvvm_wmma_m16n16k16_mma_col_row_f32_f32_satfinite,  // llvm.nvvm.wmma.m16n16k16.mma.col.row.f32.f32.satfinite
-    nvvm_wmma_m16n16k16_mma_col_row_s8,        // llvm.nvvm.wmma.m16n16k16.mma.col.row.s8
-    nvvm_wmma_m16n16k16_mma_col_row_s8_satfinite,  // llvm.nvvm.wmma.m16n16k16.mma.col.row.s8.satfinite
-    nvvm_wmma_m16n16k16_mma_col_row_u8,        // llvm.nvvm.wmma.m16n16k16.mma.col.row.u8
-    nvvm_wmma_m16n16k16_mma_col_row_u8_satfinite,  // llvm.nvvm.wmma.m16n16k16.mma.col.row.u8.satfinite
-    nvvm_wmma_m16n16k16_mma_row_col_f16_f16,   // llvm.nvvm.wmma.m16n16k16.mma.row.col.f16.f16
-    nvvm_wmma_m16n16k16_mma_row_col_f16_f16_satfinite,  // llvm.nvvm.wmma.m16n16k16.mma.row.col.f16.f16.satfinite
-    nvvm_wmma_m16n16k16_mma_row_col_f16_f32,   // llvm.nvvm.wmma.m16n16k16.mma.row.col.f16.f32
-    nvvm_wmma_m16n16k16_mma_row_col_f16_f32_satfinite,  // llvm.nvvm.wmma.m16n16k16.mma.row.col.f16.f32.satfinite
-    nvvm_wmma_m16n16k16_mma_row_col_f32_f16,   // llvm.nvvm.wmma.m16n16k16.mma.row.col.f32.f16
-    nvvm_wmma_m16n16k16_mma_row_col_f32_f16_satfinite,  // llvm.nvvm.wmma.m16n16k16.mma.row.col.f32.f16.satfinite
-    nvvm_wmma_m16n16k16_mma_row_col_f32_f32,   // llvm.nvvm.wmma.m16n16k16.mma.row.col.f32.f32
-    nvvm_wmma_m16n16k16_mma_row_col_f32_f32_satfinite,  // llvm.nvvm.wmma.m16n16k16.mma.row.col.f32.f32.satfinite
-    nvvm_wmma_m16n16k16_mma_row_col_s8,        // llvm.nvvm.wmma.m16n16k16.mma.row.col.s8
-    nvvm_wmma_m16n16k16_mma_row_col_s8_satfinite,  // llvm.nvvm.wmma.m16n16k16.mma.row.col.s8.satfinite
-    nvvm_wmma_m16n16k16_mma_row_col_u8,        // llvm.nvvm.wmma.m16n16k16.mma.row.col.u8
-    nvvm_wmma_m16n16k16_mma_row_col_u8_satfinite,  // llvm.nvvm.wmma.m16n16k16.mma.row.col.u8.satfinite
-    nvvm_wmma_m16n16k16_mma_row_row_f16_f16,   // llvm.nvvm.wmma.m16n16k16.mma.row.row.f16.f16
-    nvvm_wmma_m16n16k16_mma_row_row_f16_f16_satfinite,  // llvm.nvvm.wmma.m16n16k16.mma.row.row.f16.f16.satfinite
-    nvvm_wmma_m16n16k16_mma_row_row_f16_f32,   // llvm.nvvm.wmma.m16n16k16.mma.row.row.f16.f32
-    nvvm_wmma_m16n16k16_mma_row_row_f16_f32_satfinite,  // llvm.nvvm.wmma.m16n16k16.mma.row.row.f16.f32.satfinite
-    nvvm_wmma_m16n16k16_mma_row_row_f32_f16,   // llvm.nvvm.wmma.m16n16k16.mma.row.row.f32.f16
-    nvvm_wmma_m16n16k16_mma_row_row_f32_f16_satfinite,  // llvm.nvvm.wmma.m16n16k16.mma.row.row.f32.f16.satfinite
-    nvvm_wmma_m16n16k16_mma_row_row_f32_f32,   // llvm.nvvm.wmma.m16n16k16.mma.row.row.f32.f32
-    nvvm_wmma_m16n16k16_mma_row_row_f32_f32_satfinite,  // llvm.nvvm.wmma.m16n16k16.mma.row.row.f32.f32.satfinite
-    nvvm_wmma_m16n16k16_mma_row_row_s8,        // llvm.nvvm.wmma.m16n16k16.mma.row.row.s8
-    nvvm_wmma_m16n16k16_mma_row_row_s8_satfinite,  // llvm.nvvm.wmma.m16n16k16.mma.row.row.s8.satfinite
-    nvvm_wmma_m16n16k16_mma_row_row_u8,        // llvm.nvvm.wmma.m16n16k16.mma.row.row.u8
-    nvvm_wmma_m16n16k16_mma_row_row_u8_satfinite,  // llvm.nvvm.wmma.m16n16k16.mma.row.row.u8.satfinite
-    nvvm_wmma_m16n16k16_store_d_f16_col,       // llvm.nvvm.wmma.m16n16k16.store.d.col.f16
-    nvvm_wmma_m16n16k16_store_d_f32_col,       // llvm.nvvm.wmma.m16n16k16.store.d.col.f32
-    nvvm_wmma_m16n16k16_store_d_s32_col,       // llvm.nvvm.wmma.m16n16k16.store.d.col.s32
-    nvvm_wmma_m16n16k16_store_d_f16_col_stride,  // llvm.nvvm.wmma.m16n16k16.store.d.col.stride.f16
-    nvvm_wmma_m16n16k16_store_d_f32_col_stride,  // llvm.nvvm.wmma.m16n16k16.store.d.col.stride.f32
-    nvvm_wmma_m16n16k16_store_d_s32_col_stride,  // llvm.nvvm.wmma.m16n16k16.store.d.col.stride.s32
-    nvvm_wmma_m16n16k16_store_d_f16_row,       // llvm.nvvm.wmma.m16n16k16.store.d.row.f16
-    nvvm_wmma_m16n16k16_store_d_f32_row,       // llvm.nvvm.wmma.m16n16k16.store.d.row.f32
-    nvvm_wmma_m16n16k16_store_d_s32_row,       // llvm.nvvm.wmma.m16n16k16.store.d.row.s32
-    nvvm_wmma_m16n16k16_store_d_f16_row_stride,  // llvm.nvvm.wmma.m16n16k16.store.d.row.stride.f16
-    nvvm_wmma_m16n16k16_store_d_f32_row_stride,  // llvm.nvvm.wmma.m16n16k16.store.d.row.stride.f32
-    nvvm_wmma_m16n16k16_store_d_s32_row_stride,  // llvm.nvvm.wmma.m16n16k16.store.d.row.stride.s32
-    nvvm_wmma_m32n8k16_load_a_f16_col,         // llvm.nvvm.wmma.m32n8k16.load.a.col.f16
-    nvvm_wmma_m32n8k16_load_a_s8_col,          // llvm.nvvm.wmma.m32n8k16.load.a.col.s8
-    nvvm_wmma_m32n8k16_load_a_f16_col_stride,  // llvm.nvvm.wmma.m32n8k16.load.a.col.stride.f16
-    nvvm_wmma_m32n8k16_load_a_s8_col_stride,   // llvm.nvvm.wmma.m32n8k16.load.a.col.stride.s8
-    nvvm_wmma_m32n8k16_load_a_u8_col_stride,   // llvm.nvvm.wmma.m32n8k16.load.a.col.stride.u8
-    nvvm_wmma_m32n8k16_load_a_u8_col,          // llvm.nvvm.wmma.m32n8k16.load.a.col.u8
-    nvvm_wmma_m32n8k16_load_a_f16_row,         // llvm.nvvm.wmma.m32n8k16.load.a.row.f16
-    nvvm_wmma_m32n8k16_load_a_s8_row,          // llvm.nvvm.wmma.m32n8k16.load.a.row.s8
-    nvvm_wmma_m32n8k16_load_a_f16_row_stride,  // llvm.nvvm.wmma.m32n8k16.load.a.row.stride.f16
-    nvvm_wmma_m32n8k16_load_a_s8_row_stride,   // llvm.nvvm.wmma.m32n8k16.load.a.row.stride.s8
-    nvvm_wmma_m32n8k16_load_a_u8_row_stride,   // llvm.nvvm.wmma.m32n8k16.load.a.row.stride.u8
-    nvvm_wmma_m32n8k16_load_a_u8_row,          // llvm.nvvm.wmma.m32n8k16.load.a.row.u8
-    nvvm_wmma_m32n8k16_load_b_f16_col,         // llvm.nvvm.wmma.m32n8k16.load.b.col.f16
-    nvvm_wmma_m32n8k16_load_b_s8_col,          // llvm.nvvm.wmma.m32n8k16.load.b.col.s8
-    nvvm_wmma_m32n8k16_load_b_f16_col_stride,  // llvm.nvvm.wmma.m32n8k16.load.b.col.stride.f16
-    nvvm_wmma_m32n8k16_load_b_s8_col_stride,   // llvm.nvvm.wmma.m32n8k16.load.b.col.stride.s8
-    nvvm_wmma_m32n8k16_load_b_u8_col_stride,   // llvm.nvvm.wmma.m32n8k16.load.b.col.stride.u8
-    nvvm_wmma_m32n8k16_load_b_u8_col,          // llvm.nvvm.wmma.m32n8k16.load.b.col.u8
-    nvvm_wmma_m32n8k16_load_b_f16_row,         // llvm.nvvm.wmma.m32n8k16.load.b.row.f16
-    nvvm_wmma_m32n8k16_load_b_s8_row,          // llvm.nvvm.wmma.m32n8k16.load.b.row.s8
-    nvvm_wmma_m32n8k16_load_b_f16_row_stride,  // llvm.nvvm.wmma.m32n8k16.load.b.row.stride.f16
-    nvvm_wmma_m32n8k16_load_b_s8_row_stride,   // llvm.nvvm.wmma.m32n8k16.load.b.row.stride.s8
-    nvvm_wmma_m32n8k16_load_b_u8_row_stride,   // llvm.nvvm.wmma.m32n8k16.load.b.row.stride.u8
-    nvvm_wmma_m32n8k16_load_b_u8_row,          // llvm.nvvm.wmma.m32n8k16.load.b.row.u8
-    nvvm_wmma_m32n8k16_load_c_f16_col,         // llvm.nvvm.wmma.m32n8k16.load.c.col.f16
-    nvvm_wmma_m32n8k16_load_c_f32_col,         // llvm.nvvm.wmma.m32n8k16.load.c.col.f32
-    nvvm_wmma_m32n8k16_load_c_s32_col,         // llvm.nvvm.wmma.m32n8k16.load.c.col.s32
-    nvvm_wmma_m32n8k16_load_c_f16_col_stride,  // llvm.nvvm.wmma.m32n8k16.load.c.col.stride.f16
-    nvvm_wmma_m32n8k16_load_c_f32_col_stride,  // llvm.nvvm.wmma.m32n8k16.load.c.col.stride.f32
-    nvvm_wmma_m32n8k16_load_c_s32_col_stride,  // llvm.nvvm.wmma.m32n8k16.load.c.col.stride.s32
-    nvvm_wmma_m32n8k16_load_c_f16_row,         // llvm.nvvm.wmma.m32n8k16.load.c.row.f16
-    nvvm_wmma_m32n8k16_load_c_f32_row,         // llvm.nvvm.wmma.m32n8k16.load.c.row.f32
-    nvvm_wmma_m32n8k16_load_c_s32_row,         // llvm.nvvm.wmma.m32n8k16.load.c.row.s32
-    nvvm_wmma_m32n8k16_load_c_f16_row_stride,  // llvm.nvvm.wmma.m32n8k16.load.c.row.stride.f16
-    nvvm_wmma_m32n8k16_load_c_f32_row_stride,  // llvm.nvvm.wmma.m32n8k16.load.c.row.stride.f32
-    nvvm_wmma_m32n8k16_load_c_s32_row_stride,  // llvm.nvvm.wmma.m32n8k16.load.c.row.stride.s32
-    nvvm_wmma_m32n8k16_mma_col_col_f16_f16,    // llvm.nvvm.wmma.m32n8k16.mma.col.col.f16.f16
-    nvvm_wmma_m32n8k16_mma_col_col_f16_f16_satfinite,  // llvm.nvvm.wmma.m32n8k16.mma.col.col.f16.f16.satfinite
-    nvvm_wmma_m32n8k16_mma_col_col_f16_f32,    // llvm.nvvm.wmma.m32n8k16.mma.col.col.f16.f32
-    nvvm_wmma_m32n8k16_mma_col_col_f16_f32_satfinite,  // llvm.nvvm.wmma.m32n8k16.mma.col.col.f16.f32.satfinite
-    nvvm_wmma_m32n8k16_mma_col_col_f32_f16,    // llvm.nvvm.wmma.m32n8k16.mma.col.col.f32.f16
-    nvvm_wmma_m32n8k16_mma_col_col_f32_f16_satfinite,  // llvm.nvvm.wmma.m32n8k16.mma.col.col.f32.f16.satfinite
-    nvvm_wmma_m32n8k16_mma_col_col_f32_f32,    // llvm.nvvm.wmma.m32n8k16.mma.col.col.f32.f32
-    nvvm_wmma_m32n8k16_mma_col_col_f32_f32_satfinite,  // llvm.nvvm.wmma.m32n8k16.mma.col.col.f32.f32.satfinite
-    nvvm_wmma_m32n8k16_mma_col_col_s8,         // llvm.nvvm.wmma.m32n8k16.mma.col.col.s8
-    nvvm_wmma_m32n8k16_mma_col_col_s8_satfinite,  // llvm.nvvm.wmma.m32n8k16.mma.col.col.s8.satfinite
-    nvvm_wmma_m32n8k16_mma_col_col_u8,         // llvm.nvvm.wmma.m32n8k16.mma.col.col.u8
-    nvvm_wmma_m32n8k16_mma_col_col_u8_satfinite,  // llvm.nvvm.wmma.m32n8k16.mma.col.col.u8.satfinite
-    nvvm_wmma_m32n8k16_mma_col_row_f16_f16,    // llvm.nvvm.wmma.m32n8k16.mma.col.row.f16.f16
-    nvvm_wmma_m32n8k16_mma_col_row_f16_f16_satfinite,  // llvm.nvvm.wmma.m32n8k16.mma.col.row.f16.f16.satfinite
-    nvvm_wmma_m32n8k16_mma_col_row_f16_f32,    // llvm.nvvm.wmma.m32n8k16.mma.col.row.f16.f32
-    nvvm_wmma_m32n8k16_mma_col_row_f16_f32_satfinite,  // llvm.nvvm.wmma.m32n8k16.mma.col.row.f16.f32.satfinite
-    nvvm_wmma_m32n8k16_mma_col_row_f32_f16,    // llvm.nvvm.wmma.m32n8k16.mma.col.row.f32.f16
-    nvvm_wmma_m32n8k16_mma_col_row_f32_f16_satfinite,  // llvm.nvvm.wmma.m32n8k16.mma.col.row.f32.f16.satfinite
-    nvvm_wmma_m32n8k16_mma_col_row_f32_f32,    // llvm.nvvm.wmma.m32n8k16.mma.col.row.f32.f32
-    nvvm_wmma_m32n8k16_mma_col_row_f32_f32_satfinite,  // llvm.nvvm.wmma.m32n8k16.mma.col.row.f32.f32.satfinite
-    nvvm_wmma_m32n8k16_mma_col_row_s8,         // llvm.nvvm.wmma.m32n8k16.mma.col.row.s8
-    nvvm_wmma_m32n8k16_mma_col_row_s8_satfinite,  // llvm.nvvm.wmma.m32n8k16.mma.col.row.s8.satfinite
-    nvvm_wmma_m32n8k16_mma_col_row_u8,         // llvm.nvvm.wmma.m32n8k16.mma.col.row.u8
-    nvvm_wmma_m32n8k16_mma_col_row_u8_satfinite,  // llvm.nvvm.wmma.m32n8k16.mma.col.row.u8.satfinite
-    nvvm_wmma_m32n8k16_mma_row_col_f16_f16,    // llvm.nvvm.wmma.m32n8k16.mma.row.col.f16.f16
-    nvvm_wmma_m32n8k16_mma_row_col_f16_f16_satfinite,  // llvm.nvvm.wmma.m32n8k16.mma.row.col.f16.f16.satfinite
-    nvvm_wmma_m32n8k16_mma_row_col_f16_f32,    // llvm.nvvm.wmma.m32n8k16.mma.row.col.f16.f32
-    nvvm_wmma_m32n8k16_mma_row_col_f16_f32_satfinite,  // llvm.nvvm.wmma.m32n8k16.mma.row.col.f16.f32.satfinite
-    nvvm_wmma_m32n8k16_mma_row_col_f32_f16,    // llvm.nvvm.wmma.m32n8k16.mma.row.col.f32.f16
-    nvvm_wmma_m32n8k16_mma_row_col_f32_f16_satfinite,  // llvm.nvvm.wmma.m32n8k16.mma.row.col.f32.f16.satfinite
-    nvvm_wmma_m32n8k16_mma_row_col_f32_f32,    // llvm.nvvm.wmma.m32n8k16.mma.row.col.f32.f32
-    nvvm_wmma_m32n8k16_mma_row_col_f32_f32_satfinite,  // llvm.nvvm.wmma.m32n8k16.mma.row.col.f32.f32.satfinite
-    nvvm_wmma_m32n8k16_mma_row_col_s8,         // llvm.nvvm.wmma.m32n8k16.mma.row.col.s8
-    nvvm_wmma_m32n8k16_mma_row_col_s8_satfinite,  // llvm.nvvm.wmma.m32n8k16.mma.row.col.s8.satfinite
-    nvvm_wmma_m32n8k16_mma_row_col_u8,         // llvm.nvvm.wmma.m32n8k16.mma.row.col.u8
-    nvvm_wmma_m32n8k16_mma_row_col_u8_satfinite,  // llvm.nvvm.wmma.m32n8k16.mma.row.col.u8.satfinite
-    nvvm_wmma_m32n8k16_mma_row_row_f16_f16,    // llvm.nvvm.wmma.m32n8k16.mma.row.row.f16.f16
-    nvvm_wmma_m32n8k16_mma_row_row_f16_f16_satfinite,  // llvm.nvvm.wmma.m32n8k16.mma.row.row.f16.f16.satfinite
-    nvvm_wmma_m32n8k16_mma_row_row_f16_f32,    // llvm.nvvm.wmma.m32n8k16.mma.row.row.f16.f32
-    nvvm_wmma_m32n8k16_mma_row_row_f16_f32_satfinite,  // llvm.nvvm.wmma.m32n8k16.mma.row.row.f16.f32.satfinite
-    nvvm_wmma_m32n8k16_mma_row_row_f32_f16,    // llvm.nvvm.wmma.m32n8k16.mma.row.row.f32.f16
-    nvvm_wmma_m32n8k16_mma_row_row_f32_f16_satfinite,  // llvm.nvvm.wmma.m32n8k16.mma.row.row.f32.f16.satfinite
-    nvvm_wmma_m32n8k16_mma_row_row_f32_f32,    // llvm.nvvm.wmma.m32n8k16.mma.row.row.f32.f32
-    nvvm_wmma_m32n8k16_mma_row_row_f32_f32_satfinite,  // llvm.nvvm.wmma.m32n8k16.mma.row.row.f32.f32.satfinite
-    nvvm_wmma_m32n8k16_mma_row_row_s8,         // llvm.nvvm.wmma.m32n8k16.mma.row.row.s8
-    nvvm_wmma_m32n8k16_mma_row_row_s8_satfinite,  // llvm.nvvm.wmma.m32n8k16.mma.row.row.s8.satfinite
-    nvvm_wmma_m32n8k16_mma_row_row_u8,         // llvm.nvvm.wmma.m32n8k16.mma.row.row.u8
-    nvvm_wmma_m32n8k16_mma_row_row_u8_satfinite,  // llvm.nvvm.wmma.m32n8k16.mma.row.row.u8.satfinite
-    nvvm_wmma_m32n8k16_store_d_f16_col,        // llvm.nvvm.wmma.m32n8k16.store.d.col.f16
-    nvvm_wmma_m32n8k16_store_d_f32_col,        // llvm.nvvm.wmma.m32n8k16.store.d.col.f32
-    nvvm_wmma_m32n8k16_store_d_s32_col,        // llvm.nvvm.wmma.m32n8k16.store.d.col.s32
-    nvvm_wmma_m32n8k16_store_d_f16_col_stride,  // llvm.nvvm.wmma.m32n8k16.store.d.col.stride.f16
-    nvvm_wmma_m32n8k16_store_d_f32_col_stride,  // llvm.nvvm.wmma.m32n8k16.store.d.col.stride.f32
-    nvvm_wmma_m32n8k16_store_d_s32_col_stride,  // llvm.nvvm.wmma.m32n8k16.store.d.col.stride.s32
-    nvvm_wmma_m32n8k16_store_d_f16_row,        // llvm.nvvm.wmma.m32n8k16.store.d.row.f16
-    nvvm_wmma_m32n8k16_store_d_f32_row,        // llvm.nvvm.wmma.m32n8k16.store.d.row.f32
-    nvvm_wmma_m32n8k16_store_d_s32_row,        // llvm.nvvm.wmma.m32n8k16.store.d.row.s32
-    nvvm_wmma_m32n8k16_store_d_f16_row_stride,  // llvm.nvvm.wmma.m32n8k16.store.d.row.stride.f16
-    nvvm_wmma_m32n8k16_store_d_f32_row_stride,  // llvm.nvvm.wmma.m32n8k16.store.d.row.stride.f32
-    nvvm_wmma_m32n8k16_store_d_s32_row_stride,  // llvm.nvvm.wmma.m32n8k16.store.d.row.stride.s32
-    nvvm_wmma_m8n32k16_load_a_f16_col,         // llvm.nvvm.wmma.m8n32k16.load.a.col.f16
-    nvvm_wmma_m8n32k16_load_a_s8_col,          // llvm.nvvm.wmma.m8n32k16.load.a.col.s8
-    nvvm_wmma_m8n32k16_load_a_f16_col_stride,  // llvm.nvvm.wmma.m8n32k16.load.a.col.stride.f16
-    nvvm_wmma_m8n32k16_load_a_s8_col_stride,   // llvm.nvvm.wmma.m8n32k16.load.a.col.stride.s8
-    nvvm_wmma_m8n32k16_load_a_u8_col_stride,   // llvm.nvvm.wmma.m8n32k16.load.a.col.stride.u8
-    nvvm_wmma_m8n32k16_load_a_u8_col,          // llvm.nvvm.wmma.m8n32k16.load.a.col.u8
-    nvvm_wmma_m8n32k16_load_a_f16_row,         // llvm.nvvm.wmma.m8n32k16.load.a.row.f16
-    nvvm_wmma_m8n32k16_load_a_s8_row,          // llvm.nvvm.wmma.m8n32k16.load.a.row.s8
-    nvvm_wmma_m8n32k16_load_a_f16_row_stride,  // llvm.nvvm.wmma.m8n32k16.load.a.row.stride.f16
-    nvvm_wmma_m8n32k16_load_a_s8_row_stride,   // llvm.nvvm.wmma.m8n32k16.load.a.row.stride.s8
-    nvvm_wmma_m8n32k16_load_a_u8_row_stride,   // llvm.nvvm.wmma.m8n32k16.load.a.row.stride.u8
-    nvvm_wmma_m8n32k16_load_a_u8_row,          // llvm.nvvm.wmma.m8n32k16.load.a.row.u8
-    nvvm_wmma_m8n32k16_load_b_f16_col,         // llvm.nvvm.wmma.m8n32k16.load.b.col.f16
-    nvvm_wmma_m8n32k16_load_b_s8_col,          // llvm.nvvm.wmma.m8n32k16.load.b.col.s8
-    nvvm_wmma_m8n32k16_load_b_f16_col_stride,  // llvm.nvvm.wmma.m8n32k16.load.b.col.stride.f16
-    nvvm_wmma_m8n32k16_load_b_s8_col_stride,   // llvm.nvvm.wmma.m8n32k16.load.b.col.stride.s8
-    nvvm_wmma_m8n32k16_load_b_u8_col_stride,   // llvm.nvvm.wmma.m8n32k16.load.b.col.stride.u8
-    nvvm_wmma_m8n32k16_load_b_u8_col,          // llvm.nvvm.wmma.m8n32k16.load.b.col.u8
-    nvvm_wmma_m8n32k16_load_b_f16_row,         // llvm.nvvm.wmma.m8n32k16.load.b.row.f16
-    nvvm_wmma_m8n32k16_load_b_s8_row,          // llvm.nvvm.wmma.m8n32k16.load.b.row.s8
-    nvvm_wmma_m8n32k16_load_b_f16_row_stride,  // llvm.nvvm.wmma.m8n32k16.load.b.row.stride.f16
-    nvvm_wmma_m8n32k16_load_b_s8_row_stride,   // llvm.nvvm.wmma.m8n32k16.load.b.row.stride.s8
-    nvvm_wmma_m8n32k16_load_b_u8_row_stride,   // llvm.nvvm.wmma.m8n32k16.load.b.row.stride.u8
-    nvvm_wmma_m8n32k16_load_b_u8_row,          // llvm.nvvm.wmma.m8n32k16.load.b.row.u8
-    nvvm_wmma_m8n32k16_load_c_f16_col,         // llvm.nvvm.wmma.m8n32k16.load.c.col.f16
-    nvvm_wmma_m8n32k16_load_c_f32_col,         // llvm.nvvm.wmma.m8n32k16.load.c.col.f32
-    nvvm_wmma_m8n32k16_load_c_s32_col,         // llvm.nvvm.wmma.m8n32k16.load.c.col.s32
-    nvvm_wmma_m8n32k16_load_c_f16_col_stride,  // llvm.nvvm.wmma.m8n32k16.load.c.col.stride.f16
-    nvvm_wmma_m8n32k16_load_c_f32_col_stride,  // llvm.nvvm.wmma.m8n32k16.load.c.col.stride.f32
-    nvvm_wmma_m8n32k16_load_c_s32_col_stride,  // llvm.nvvm.wmma.m8n32k16.load.c.col.stride.s32
-    nvvm_wmma_m8n32k16_load_c_f16_row,         // llvm.nvvm.wmma.m8n32k16.load.c.row.f16
-    nvvm_wmma_m8n32k16_load_c_f32_row,         // llvm.nvvm.wmma.m8n32k16.load.c.row.f32
-    nvvm_wmma_m8n32k16_load_c_s32_row,         // llvm.nvvm.wmma.m8n32k16.load.c.row.s32
-    nvvm_wmma_m8n32k16_load_c_f16_row_stride,  // llvm.nvvm.wmma.m8n32k16.load.c.row.stride.f16
-    nvvm_wmma_m8n32k16_load_c_f32_row_stride,  // llvm.nvvm.wmma.m8n32k16.load.c.row.stride.f32
-    nvvm_wmma_m8n32k16_load_c_s32_row_stride,  // llvm.nvvm.wmma.m8n32k16.load.c.row.stride.s32
-    nvvm_wmma_m8n32k16_mma_col_col_f16_f16,    // llvm.nvvm.wmma.m8n32k16.mma.col.col.f16.f16
-    nvvm_wmma_m8n32k16_mma_col_col_f16_f16_satfinite,  // llvm.nvvm.wmma.m8n32k16.mma.col.col.f16.f16.satfinite
-    nvvm_wmma_m8n32k16_mma_col_col_f16_f32,    // llvm.nvvm.wmma.m8n32k16.mma.col.col.f16.f32
-    nvvm_wmma_m8n32k16_mma_col_col_f16_f32_satfinite,  // llvm.nvvm.wmma.m8n32k16.mma.col.col.f16.f32.satfinite
-    nvvm_wmma_m8n32k16_mma_col_col_f32_f16,    // llvm.nvvm.wmma.m8n32k16.mma.col.col.f32.f16
-    nvvm_wmma_m8n32k16_mma_col_col_f32_f16_satfinite,  // llvm.nvvm.wmma.m8n32k16.mma.col.col.f32.f16.satfinite
-    nvvm_wmma_m8n32k16_mma_col_col_f32_f32,    // llvm.nvvm.wmma.m8n32k16.mma.col.col.f32.f32
-    nvvm_wmma_m8n32k16_mma_col_col_f32_f32_satfinite,  // llvm.nvvm.wmma.m8n32k16.mma.col.col.f32.f32.satfinite
-    nvvm_wmma_m8n32k16_mma_col_col_s8,         // llvm.nvvm.wmma.m8n32k16.mma.col.col.s8
-    nvvm_wmma_m8n32k16_mma_col_col_s8_satfinite,  // llvm.nvvm.wmma.m8n32k16.mma.col.col.s8.satfinite
-    nvvm_wmma_m8n32k16_mma_col_col_u8,         // llvm.nvvm.wmma.m8n32k16.mma.col.col.u8
-    nvvm_wmma_m8n32k16_mma_col_col_u8_satfinite,  // llvm.nvvm.wmma.m8n32k16.mma.col.col.u8.satfinite
-    nvvm_wmma_m8n32k16_mma_col_row_f16_f16,    // llvm.nvvm.wmma.m8n32k16.mma.col.row.f16.f16
-    nvvm_wmma_m8n32k16_mma_col_row_f16_f16_satfinite,  // llvm.nvvm.wmma.m8n32k16.mma.col.row.f16.f16.satfinite
-    nvvm_wmma_m8n32k16_mma_col_row_f16_f32,    // llvm.nvvm.wmma.m8n32k16.mma.col.row.f16.f32
-    nvvm_wmma_m8n32k16_mma_col_row_f16_f32_satfinite,  // llvm.nvvm.wmma.m8n32k16.mma.col.row.f16.f32.satfinite
-    nvvm_wmma_m8n32k16_mma_col_row_f32_f16,    // llvm.nvvm.wmma.m8n32k16.mma.col.row.f32.f16
-    nvvm_wmma_m8n32k16_mma_col_row_f32_f16_satfinite,  // llvm.nvvm.wmma.m8n32k16.mma.col.row.f32.f16.satfinite
-    nvvm_wmma_m8n32k16_mma_col_row_f32_f32,    // llvm.nvvm.wmma.m8n32k16.mma.col.row.f32.f32
-    nvvm_wmma_m8n32k16_mma_col_row_f32_f32_satfinite,  // llvm.nvvm.wmma.m8n32k16.mma.col.row.f32.f32.satfinite
-    nvvm_wmma_m8n32k16_mma_col_row_s8,         // llvm.nvvm.wmma.m8n32k16.mma.col.row.s8
-    nvvm_wmma_m8n32k16_mma_col_row_s8_satfinite,  // llvm.nvvm.wmma.m8n32k16.mma.col.row.s8.satfinite
-    nvvm_wmma_m8n32k16_mma_col_row_u8,         // llvm.nvvm.wmma.m8n32k16.mma.col.row.u8
-    nvvm_wmma_m8n32k16_mma_col_row_u8_satfinite,  // llvm.nvvm.wmma.m8n32k16.mma.col.row.u8.satfinite
-    nvvm_wmma_m8n32k16_mma_row_col_f16_f16,    // llvm.nvvm.wmma.m8n32k16.mma.row.col.f16.f16
-    nvvm_wmma_m8n32k16_mma_row_col_f16_f16_satfinite,  // llvm.nvvm.wmma.m8n32k16.mma.row.col.f16.f16.satfinite
-    nvvm_wmma_m8n32k16_mma_row_col_f16_f32,    // llvm.nvvm.wmma.m8n32k16.mma.row.col.f16.f32
-    nvvm_wmma_m8n32k16_mma_row_col_f16_f32_satfinite,  // llvm.nvvm.wmma.m8n32k16.mma.row.col.f16.f32.satfinite
-    nvvm_wmma_m8n32k16_mma_row_col_f32_f16,    // llvm.nvvm.wmma.m8n32k16.mma.row.col.f32.f16
-    nvvm_wmma_m8n32k16_mma_row_col_f32_f16_satfinite,  // llvm.nvvm.wmma.m8n32k16.mma.row.col.f32.f16.satfinite
-    nvvm_wmma_m8n32k16_mma_row_col_f32_f32,    // llvm.nvvm.wmma.m8n32k16.mma.row.col.f32.f32
-    nvvm_wmma_m8n32k16_mma_row_col_f32_f32_satfinite,  // llvm.nvvm.wmma.m8n32k16.mma.row.col.f32.f32.satfinite
-    nvvm_wmma_m8n32k16_mma_row_col_s8,         // llvm.nvvm.wmma.m8n32k16.mma.row.col.s8
-    nvvm_wmma_m8n32k16_mma_row_col_s8_satfinite,  // llvm.nvvm.wmma.m8n32k16.mma.row.col.s8.satfinite
-    nvvm_wmma_m8n32k16_mma_row_col_u8,         // llvm.nvvm.wmma.m8n32k16.mma.row.col.u8
-    nvvm_wmma_m8n32k16_mma_row_col_u8_satfinite,  // llvm.nvvm.wmma.m8n32k16.mma.row.col.u8.satfinite
-    nvvm_wmma_m8n32k16_mma_row_row_f16_f16,    // llvm.nvvm.wmma.m8n32k16.mma.row.row.f16.f16
-    nvvm_wmma_m8n32k16_mma_row_row_f16_f16_satfinite,  // llvm.nvvm.wmma.m8n32k16.mma.row.row.f16.f16.satfinite
-    nvvm_wmma_m8n32k16_mma_row_row_f16_f32,    // llvm.nvvm.wmma.m8n32k16.mma.row.row.f16.f32
-    nvvm_wmma_m8n32k16_mma_row_row_f16_f32_satfinite,  // llvm.nvvm.wmma.m8n32k16.mma.row.row.f16.f32.satfinite
-    nvvm_wmma_m8n32k16_mma_row_row_f32_f16,    // llvm.nvvm.wmma.m8n32k16.mma.row.row.f32.f16
-    nvvm_wmma_m8n32k16_mma_row_row_f32_f16_satfinite,  // llvm.nvvm.wmma.m8n32k16.mma.row.row.f32.f16.satfinite
-    nvvm_wmma_m8n32k16_mma_row_row_f32_f32,    // llvm.nvvm.wmma.m8n32k16.mma.row.row.f32.f32
-    nvvm_wmma_m8n32k16_mma_row_row_f32_f32_satfinite,  // llvm.nvvm.wmma.m8n32k16.mma.row.row.f32.f32.satfinite
-    nvvm_wmma_m8n32k16_mma_row_row_s8,         // llvm.nvvm.wmma.m8n32k16.mma.row.row.s8
-    nvvm_wmma_m8n32k16_mma_row_row_s8_satfinite,  // llvm.nvvm.wmma.m8n32k16.mma.row.row.s8.satfinite
-    nvvm_wmma_m8n32k16_mma_row_row_u8,         // llvm.nvvm.wmma.m8n32k16.mma.row.row.u8
-    nvvm_wmma_m8n32k16_mma_row_row_u8_satfinite,  // llvm.nvvm.wmma.m8n32k16.mma.row.row.u8.satfinite
-    nvvm_wmma_m8n32k16_store_d_f16_col,        // llvm.nvvm.wmma.m8n32k16.store.d.col.f16
-    nvvm_wmma_m8n32k16_store_d_f32_col,        // llvm.nvvm.wmma.m8n32k16.store.d.col.f32
-    nvvm_wmma_m8n32k16_store_d_s32_col,        // llvm.nvvm.wmma.m8n32k16.store.d.col.s32
-    nvvm_wmma_m8n32k16_store_d_f16_col_stride,  // llvm.nvvm.wmma.m8n32k16.store.d.col.stride.f16
-    nvvm_wmma_m8n32k16_store_d_f32_col_stride,  // llvm.nvvm.wmma.m8n32k16.store.d.col.stride.f32
-    nvvm_wmma_m8n32k16_store_d_s32_col_stride,  // llvm.nvvm.wmma.m8n32k16.store.d.col.stride.s32
-    nvvm_wmma_m8n32k16_store_d_f16_row,        // llvm.nvvm.wmma.m8n32k16.store.d.row.f16
-    nvvm_wmma_m8n32k16_store_d_f32_row,        // llvm.nvvm.wmma.m8n32k16.store.d.row.f32
-    nvvm_wmma_m8n32k16_store_d_s32_row,        // llvm.nvvm.wmma.m8n32k16.store.d.row.s32
-    nvvm_wmma_m8n32k16_store_d_f16_row_stride,  // llvm.nvvm.wmma.m8n32k16.store.d.row.stride.f16
-    nvvm_wmma_m8n32k16_store_d_f32_row_stride,  // llvm.nvvm.wmma.m8n32k16.store.d.row.stride.f32
-    nvvm_wmma_m8n32k16_store_d_s32_row_stride,  // llvm.nvvm.wmma.m8n32k16.store.d.row.stride.s32
-    nvvm_wmma_m8n8k128_load_a_b1_row,          // llvm.nvvm.wmma.m8n8k128.load.a.row.b1
-    nvvm_wmma_m8n8k128_load_a_b1_row_stride,   // llvm.nvvm.wmma.m8n8k128.load.a.row.stride.b1
-    nvvm_wmma_m8n8k128_load_b_b1_col,          // llvm.nvvm.wmma.m8n8k128.load.b.col.b1
-    nvvm_wmma_m8n8k128_load_b_b1_col_stride,   // llvm.nvvm.wmma.m8n8k128.load.b.col.stride.b1
-    nvvm_wmma_m8n8k128_load_c_s32_col,         // llvm.nvvm.wmma.m8n8k128.load.c.col.s32
-    nvvm_wmma_m8n8k128_load_c_s32_col_stride,  // llvm.nvvm.wmma.m8n8k128.load.c.col.stride.s32
-    nvvm_wmma_m8n8k128_load_c_s32_row,         // llvm.nvvm.wmma.m8n8k128.load.c.row.s32
-    nvvm_wmma_m8n8k128_load_c_s32_row_stride,  // llvm.nvvm.wmma.m8n8k128.load.c.row.stride.s32
-    nvvm_wmma_m8n8k128_mma_row_col_b1,         // llvm.nvvm.wmma.m8n8k128.mma.row.col.b1
-    nvvm_wmma_m8n8k128_store_d_s32_col,        // llvm.nvvm.wmma.m8n8k128.store.d.col.s32
-    nvvm_wmma_m8n8k128_store_d_s32_col_stride,  // llvm.nvvm.wmma.m8n8k128.store.d.col.stride.s32
-    nvvm_wmma_m8n8k128_store_d_s32_row,        // llvm.nvvm.wmma.m8n8k128.store.d.row.s32
-    nvvm_wmma_m8n8k128_store_d_s32_row_stride,  // llvm.nvvm.wmma.m8n8k128.store.d.row.stride.s32
-    nvvm_wmma_m8n8k32_load_a_s4_row,           // llvm.nvvm.wmma.m8n8k32.load.a.row.s4
-    nvvm_wmma_m8n8k32_load_a_s4_row_stride,    // llvm.nvvm.wmma.m8n8k32.load.a.row.stride.s4
-    nvvm_wmma_m8n8k32_load_a_u4_row_stride,    // llvm.nvvm.wmma.m8n8k32.load.a.row.stride.u4
-    nvvm_wmma_m8n8k32_load_a_u4_row,           // llvm.nvvm.wmma.m8n8k32.load.a.row.u4
-    nvvm_wmma_m8n8k32_load_b_s4_col,           // llvm.nvvm.wmma.m8n8k32.load.b.col.s4
-    nvvm_wmma_m8n8k32_load_b_s4_col_stride,    // llvm.nvvm.wmma.m8n8k32.load.b.col.stride.s4
-    nvvm_wmma_m8n8k32_load_b_u4_col_stride,    // llvm.nvvm.wmma.m8n8k32.load.b.col.stride.u4
-    nvvm_wmma_m8n8k32_load_b_u4_col,           // llvm.nvvm.wmma.m8n8k32.load.b.col.u4
-    nvvm_wmma_m8n8k32_load_c_s32_col,          // llvm.nvvm.wmma.m8n8k32.load.c.col.s32
-    nvvm_wmma_m8n8k32_load_c_s32_col_stride,   // llvm.nvvm.wmma.m8n8k32.load.c.col.stride.s32
-    nvvm_wmma_m8n8k32_load_c_s32_row,          // llvm.nvvm.wmma.m8n8k32.load.c.row.s32
-    nvvm_wmma_m8n8k32_load_c_s32_row_stride,   // llvm.nvvm.wmma.m8n8k32.load.c.row.stride.s32
-    nvvm_wmma_m8n8k32_mma_row_col_s4,          // llvm.nvvm.wmma.m8n8k32.mma.row.col.s4
-    nvvm_wmma_m8n8k32_mma_row_col_s4_satfinite,  // llvm.nvvm.wmma.m8n8k32.mma.row.col.s4.satfinite
-    nvvm_wmma_m8n8k32_mma_row_col_u4,          // llvm.nvvm.wmma.m8n8k32.mma.row.col.u4
-    nvvm_wmma_m8n8k32_mma_row_col_u4_satfinite,  // llvm.nvvm.wmma.m8n8k32.mma.row.col.u4.satfinite
-    nvvm_wmma_m8n8k32_store_d_s32_col,         // llvm.nvvm.wmma.m8n8k32.store.d.col.s32
-    nvvm_wmma_m8n8k32_store_d_s32_col_stride,  // llvm.nvvm.wmma.m8n8k32.store.d.col.stride.s32
-    nvvm_wmma_m8n8k32_store_d_s32_row,         // llvm.nvvm.wmma.m8n8k32.store.d.row.s32
-    nvvm_wmma_m8n8k32_store_d_s32_row_stride,  // llvm.nvvm.wmma.m8n8k32.store.d.row.stride.s32
-    ppc_addf128_round_to_odd,                  // llvm.ppc.addf128.round.to.odd
-    ppc_altivec_crypto_vcipher,                // llvm.ppc.altivec.crypto.vcipher
-    ppc_altivec_crypto_vcipherlast,            // llvm.ppc.altivec.crypto.vcipherlast
-    ppc_altivec_crypto_vncipher,               // llvm.ppc.altivec.crypto.vncipher
-    ppc_altivec_crypto_vncipherlast,           // llvm.ppc.altivec.crypto.vncipherlast
-    ppc_altivec_crypto_vpermxor,               // llvm.ppc.altivec.crypto.vpermxor
-    ppc_altivec_crypto_vpmsumb,                // llvm.ppc.altivec.crypto.vpmsumb
-    ppc_altivec_crypto_vpmsumd,                // llvm.ppc.altivec.crypto.vpmsumd
-    ppc_altivec_crypto_vpmsumh,                // llvm.ppc.altivec.crypto.vpmsumh
-    ppc_altivec_crypto_vpmsumw,                // llvm.ppc.altivec.crypto.vpmsumw
-    ppc_altivec_crypto_vsbox,                  // llvm.ppc.altivec.crypto.vsbox
-    ppc_altivec_crypto_vshasigmad,             // llvm.ppc.altivec.crypto.vshasigmad
-    ppc_altivec_crypto_vshasigmaw,             // llvm.ppc.altivec.crypto.vshasigmaw
-    ppc_altivec_dss,                           // llvm.ppc.altivec.dss
-    ppc_altivec_dssall,                        // llvm.ppc.altivec.dssall
-    ppc_altivec_dst,                           // llvm.ppc.altivec.dst
-    ppc_altivec_dstst,                         // llvm.ppc.altivec.dstst
-    ppc_altivec_dststt,                        // llvm.ppc.altivec.dststt
-    ppc_altivec_dstt,                          // llvm.ppc.altivec.dstt
-    ppc_altivec_lvebx,                         // llvm.ppc.altivec.lvebx
-    ppc_altivec_lvehx,                         // llvm.ppc.altivec.lvehx
-    ppc_altivec_lvewx,                         // llvm.ppc.altivec.lvewx
-    ppc_altivec_lvsl,                          // llvm.ppc.altivec.lvsl
-    ppc_altivec_lvsr,                          // llvm.ppc.altivec.lvsr
-    ppc_altivec_lvx,                           // llvm.ppc.altivec.lvx
-    ppc_altivec_lvxl,                          // llvm.ppc.altivec.lvxl
-    ppc_altivec_mfvscr,                        // llvm.ppc.altivec.mfvscr
-    ppc_altivec_mtvscr,                        // llvm.ppc.altivec.mtvscr
-    ppc_altivec_stvebx,                        // llvm.ppc.altivec.stvebx
-    ppc_altivec_stvehx,                        // llvm.ppc.altivec.stvehx
-    ppc_altivec_stvewx,                        // llvm.ppc.altivec.stvewx
-    ppc_altivec_stvx,                          // llvm.ppc.altivec.stvx
-    ppc_altivec_stvxl,                         // llvm.ppc.altivec.stvxl
-    ppc_altivec_vabsdub,                       // llvm.ppc.altivec.vabsdub
-    ppc_altivec_vabsduh,                       // llvm.ppc.altivec.vabsduh
-    ppc_altivec_vabsduw,                       // llvm.ppc.altivec.vabsduw
-    ppc_altivec_vaddcuq,                       // llvm.ppc.altivec.vaddcuq
-    ppc_altivec_vaddcuw,                       // llvm.ppc.altivec.vaddcuw
-    ppc_altivec_vaddecuq,                      // llvm.ppc.altivec.vaddecuq
-    ppc_altivec_vaddeuqm,                      // llvm.ppc.altivec.vaddeuqm
-    ppc_altivec_vaddsbs,                       // llvm.ppc.altivec.vaddsbs
-    ppc_altivec_vaddshs,                       // llvm.ppc.altivec.vaddshs
-    ppc_altivec_vaddsws,                       // llvm.ppc.altivec.vaddsws
-    ppc_altivec_vaddubs,                       // llvm.ppc.altivec.vaddubs
-    ppc_altivec_vadduhs,                       // llvm.ppc.altivec.vadduhs
-    ppc_altivec_vadduws,                       // llvm.ppc.altivec.vadduws
-    ppc_altivec_vavgsb,                        // llvm.ppc.altivec.vavgsb
-    ppc_altivec_vavgsh,                        // llvm.ppc.altivec.vavgsh
-    ppc_altivec_vavgsw,                        // llvm.ppc.altivec.vavgsw
-    ppc_altivec_vavgub,                        // llvm.ppc.altivec.vavgub
-    ppc_altivec_vavguh,                        // llvm.ppc.altivec.vavguh
-    ppc_altivec_vavguw,                        // llvm.ppc.altivec.vavguw
-    ppc_altivec_vbpermq,                       // llvm.ppc.altivec.vbpermq
-    ppc_altivec_vcfsx,                         // llvm.ppc.altivec.vcfsx
-    ppc_altivec_vcfux,                         // llvm.ppc.altivec.vcfux
-    ppc_altivec_vclzlsbb,                      // llvm.ppc.altivec.vclzlsbb
-    ppc_altivec_vcmpbfp,                       // llvm.ppc.altivec.vcmpbfp
-    ppc_altivec_vcmpbfp_p,                     // llvm.ppc.altivec.vcmpbfp.p
-    ppc_altivec_vcmpeqfp,                      // llvm.ppc.altivec.vcmpeqfp
-    ppc_altivec_vcmpeqfp_p,                    // llvm.ppc.altivec.vcmpeqfp.p
-    ppc_altivec_vcmpequb,                      // llvm.ppc.altivec.vcmpequb
-    ppc_altivec_vcmpequb_p,                    // llvm.ppc.altivec.vcmpequb.p
-    ppc_altivec_vcmpequd,                      // llvm.ppc.altivec.vcmpequd
-    ppc_altivec_vcmpequd_p,                    // llvm.ppc.altivec.vcmpequd.p
-    ppc_altivec_vcmpequh,                      // llvm.ppc.altivec.vcmpequh
-    ppc_altivec_vcmpequh_p,                    // llvm.ppc.altivec.vcmpequh.p
-    ppc_altivec_vcmpequw,                      // llvm.ppc.altivec.vcmpequw
-    ppc_altivec_vcmpequw_p,                    // llvm.ppc.altivec.vcmpequw.p
-    ppc_altivec_vcmpgefp,                      // llvm.ppc.altivec.vcmpgefp
-    ppc_altivec_vcmpgefp_p,                    // llvm.ppc.altivec.vcmpgefp.p
-    ppc_altivec_vcmpgtfp,                      // llvm.ppc.altivec.vcmpgtfp
-    ppc_altivec_vcmpgtfp_p,                    // llvm.ppc.altivec.vcmpgtfp.p
-    ppc_altivec_vcmpgtsb,                      // llvm.ppc.altivec.vcmpgtsb
-    ppc_altivec_vcmpgtsb_p,                    // llvm.ppc.altivec.vcmpgtsb.p
-    ppc_altivec_vcmpgtsd,                      // llvm.ppc.altivec.vcmpgtsd
-    ppc_altivec_vcmpgtsd_p,                    // llvm.ppc.altivec.vcmpgtsd.p
-    ppc_altivec_vcmpgtsh,                      // llvm.ppc.altivec.vcmpgtsh
-    ppc_altivec_vcmpgtsh_p,                    // llvm.ppc.altivec.vcmpgtsh.p
-    ppc_altivec_vcmpgtsw,                      // llvm.ppc.altivec.vcmpgtsw
-    ppc_altivec_vcmpgtsw_p,                    // llvm.ppc.altivec.vcmpgtsw.p
-    ppc_altivec_vcmpgtub,                      // llvm.ppc.altivec.vcmpgtub
-    ppc_altivec_vcmpgtub_p,                    // llvm.ppc.altivec.vcmpgtub.p
-    ppc_altivec_vcmpgtud,                      // llvm.ppc.altivec.vcmpgtud
-    ppc_altivec_vcmpgtud_p,                    // llvm.ppc.altivec.vcmpgtud.p
-    ppc_altivec_vcmpgtuh,                      // llvm.ppc.altivec.vcmpgtuh
-    ppc_altivec_vcmpgtuh_p,                    // llvm.ppc.altivec.vcmpgtuh.p
-    ppc_altivec_vcmpgtuw,                      // llvm.ppc.altivec.vcmpgtuw
-    ppc_altivec_vcmpgtuw_p,                    // llvm.ppc.altivec.vcmpgtuw.p
-    ppc_altivec_vcmpneb,                       // llvm.ppc.altivec.vcmpneb
-    ppc_altivec_vcmpneb_p,                     // llvm.ppc.altivec.vcmpneb.p
-    ppc_altivec_vcmpneh,                       // llvm.ppc.altivec.vcmpneh
-    ppc_altivec_vcmpneh_p,                     // llvm.ppc.altivec.vcmpneh.p
-    ppc_altivec_vcmpnew,                       // llvm.ppc.altivec.vcmpnew
-    ppc_altivec_vcmpnew_p,                     // llvm.ppc.altivec.vcmpnew.p
-    ppc_altivec_vcmpnezb,                      // llvm.ppc.altivec.vcmpnezb
-    ppc_altivec_vcmpnezb_p,                    // llvm.ppc.altivec.vcmpnezb.p
-    ppc_altivec_vcmpnezh,                      // llvm.ppc.altivec.vcmpnezh
-    ppc_altivec_vcmpnezh_p,                    // llvm.ppc.altivec.vcmpnezh.p
-    ppc_altivec_vcmpnezw,                      // llvm.ppc.altivec.vcmpnezw
-    ppc_altivec_vcmpnezw_p,                    // llvm.ppc.altivec.vcmpnezw.p
-    ppc_altivec_vctsxs,                        // llvm.ppc.altivec.vctsxs
-    ppc_altivec_vctuxs,                        // llvm.ppc.altivec.vctuxs
-    ppc_altivec_vctzlsbb,                      // llvm.ppc.altivec.vctzlsbb
-    ppc_altivec_vexptefp,                      // llvm.ppc.altivec.vexptefp
-    ppc_altivec_vgbbd,                         // llvm.ppc.altivec.vgbbd
-    ppc_altivec_vlogefp,                       // llvm.ppc.altivec.vlogefp
-    ppc_altivec_vmaddfp,                       // llvm.ppc.altivec.vmaddfp
-    ppc_altivec_vmaxfp,                        // llvm.ppc.altivec.vmaxfp
-    ppc_altivec_vmaxsb,                        // llvm.ppc.altivec.vmaxsb
-    ppc_altivec_vmaxsd,                        // llvm.ppc.altivec.vmaxsd
-    ppc_altivec_vmaxsh,                        // llvm.ppc.altivec.vmaxsh
-    ppc_altivec_vmaxsw,                        // llvm.ppc.altivec.vmaxsw
-    ppc_altivec_vmaxub,                        // llvm.ppc.altivec.vmaxub
-    ppc_altivec_vmaxud,                        // llvm.ppc.altivec.vmaxud
-    ppc_altivec_vmaxuh,                        // llvm.ppc.altivec.vmaxuh
-    ppc_altivec_vmaxuw,                        // llvm.ppc.altivec.vmaxuw
-    ppc_altivec_vmhaddshs,                     // llvm.ppc.altivec.vmhaddshs
-    ppc_altivec_vmhraddshs,                    // llvm.ppc.altivec.vmhraddshs
-    ppc_altivec_vminfp,                        // llvm.ppc.altivec.vminfp
-    ppc_altivec_vminsb,                        // llvm.ppc.altivec.vminsb
-    ppc_altivec_vminsd,                        // llvm.ppc.altivec.vminsd
-    ppc_altivec_vminsh,                        // llvm.ppc.altivec.vminsh
-    ppc_altivec_vminsw,                        // llvm.ppc.altivec.vminsw
-    ppc_altivec_vminub,                        // llvm.ppc.altivec.vminub
-    ppc_altivec_vminud,                        // llvm.ppc.altivec.vminud
-    ppc_altivec_vminuh,                        // llvm.ppc.altivec.vminuh
-    ppc_altivec_vminuw,                        // llvm.ppc.altivec.vminuw
-    ppc_altivec_vmladduhm,                     // llvm.ppc.altivec.vmladduhm
-    ppc_altivec_vmsummbm,                      // llvm.ppc.altivec.vmsummbm
-    ppc_altivec_vmsumshm,                      // llvm.ppc.altivec.vmsumshm
-    ppc_altivec_vmsumshs,                      // llvm.ppc.altivec.vmsumshs
-    ppc_altivec_vmsumubm,                      // llvm.ppc.altivec.vmsumubm
-    ppc_altivec_vmsumuhm,                      // llvm.ppc.altivec.vmsumuhm
-    ppc_altivec_vmsumuhs,                      // llvm.ppc.altivec.vmsumuhs
-    ppc_altivec_vmulesb,                       // llvm.ppc.altivec.vmulesb
-    ppc_altivec_vmulesh,                       // llvm.ppc.altivec.vmulesh
-    ppc_altivec_vmulesw,                       // llvm.ppc.altivec.vmulesw
-    ppc_altivec_vmuleub,                       // llvm.ppc.altivec.vmuleub
-    ppc_altivec_vmuleuh,                       // llvm.ppc.altivec.vmuleuh
-    ppc_altivec_vmuleuw,                       // llvm.ppc.altivec.vmuleuw
-    ppc_altivec_vmulosb,                       // llvm.ppc.altivec.vmulosb
-    ppc_altivec_vmulosh,                       // llvm.ppc.altivec.vmulosh
-    ppc_altivec_vmulosw,                       // llvm.ppc.altivec.vmulosw
-    ppc_altivec_vmuloub,                       // llvm.ppc.altivec.vmuloub
-    ppc_altivec_vmulouh,                       // llvm.ppc.altivec.vmulouh
-    ppc_altivec_vmulouw,                       // llvm.ppc.altivec.vmulouw
-    ppc_altivec_vnmsubfp,                      // llvm.ppc.altivec.vnmsubfp
-    ppc_altivec_vperm,                         // llvm.ppc.altivec.vperm
-    ppc_altivec_vpkpx,                         // llvm.ppc.altivec.vpkpx
-    ppc_altivec_vpksdss,                       // llvm.ppc.altivec.vpksdss
-    ppc_altivec_vpksdus,                       // llvm.ppc.altivec.vpksdus
-    ppc_altivec_vpkshss,                       // llvm.ppc.altivec.vpkshss
-    ppc_altivec_vpkshus,                       // llvm.ppc.altivec.vpkshus
-    ppc_altivec_vpkswss,                       // llvm.ppc.altivec.vpkswss
-    ppc_altivec_vpkswus,                       // llvm.ppc.altivec.vpkswus
-    ppc_altivec_vpkudus,                       // llvm.ppc.altivec.vpkudus
-    ppc_altivec_vpkuhus,                       // llvm.ppc.altivec.vpkuhus
-    ppc_altivec_vpkuwus,                       // llvm.ppc.altivec.vpkuwus
-    ppc_altivec_vprtybd,                       // llvm.ppc.altivec.vprtybd
-    ppc_altivec_vprtybq,                       // llvm.ppc.altivec.vprtybq
-    ppc_altivec_vprtybw,                       // llvm.ppc.altivec.vprtybw
-    ppc_altivec_vrefp,                         // llvm.ppc.altivec.vrefp
-    ppc_altivec_vrfim,                         // llvm.ppc.altivec.vrfim
-    ppc_altivec_vrfin,                         // llvm.ppc.altivec.vrfin
-    ppc_altivec_vrfip,                         // llvm.ppc.altivec.vrfip
-    ppc_altivec_vrfiz,                         // llvm.ppc.altivec.vrfiz
-    ppc_altivec_vrlb,                          // llvm.ppc.altivec.vrlb
-    ppc_altivec_vrld,                          // llvm.ppc.altivec.vrld
-    ppc_altivec_vrldmi,                        // llvm.ppc.altivec.vrldmi
-    ppc_altivec_vrldnm,                        // llvm.ppc.altivec.vrldnm
-    ppc_altivec_vrlh,                          // llvm.ppc.altivec.vrlh
-    ppc_altivec_vrlw,                          // llvm.ppc.altivec.vrlw
-    ppc_altivec_vrlwmi,                        // llvm.ppc.altivec.vrlwmi
-    ppc_altivec_vrlwnm,                        // llvm.ppc.altivec.vrlwnm
-    ppc_altivec_vrsqrtefp,                     // llvm.ppc.altivec.vrsqrtefp
-    ppc_altivec_vsel,                          // llvm.ppc.altivec.vsel
-    ppc_altivec_vsl,                           // llvm.ppc.altivec.vsl
-    ppc_altivec_vslb,                          // llvm.ppc.altivec.vslb
-    ppc_altivec_vslh,                          // llvm.ppc.altivec.vslh
-    ppc_altivec_vslo,                          // llvm.ppc.altivec.vslo
-    ppc_altivec_vslv,                          // llvm.ppc.altivec.vslv
-    ppc_altivec_vslw,                          // llvm.ppc.altivec.vslw
-    ppc_altivec_vsr,                           // llvm.ppc.altivec.vsr
-    ppc_altivec_vsrab,                         // llvm.ppc.altivec.vsrab
-    ppc_altivec_vsrah,                         // llvm.ppc.altivec.vsrah
-    ppc_altivec_vsraw,                         // llvm.ppc.altivec.vsraw
-    ppc_altivec_vsrb,                          // llvm.ppc.altivec.vsrb
-    ppc_altivec_vsrh,                          // llvm.ppc.altivec.vsrh
-    ppc_altivec_vsro,                          // llvm.ppc.altivec.vsro
-    ppc_altivec_vsrv,                          // llvm.ppc.altivec.vsrv
-    ppc_altivec_vsrw,                          // llvm.ppc.altivec.vsrw
-    ppc_altivec_vsubcuq,                       // llvm.ppc.altivec.vsubcuq
-    ppc_altivec_vsubcuw,                       // llvm.ppc.altivec.vsubcuw
-    ppc_altivec_vsubecuq,                      // llvm.ppc.altivec.vsubecuq
-    ppc_altivec_vsubeuqm,                      // llvm.ppc.altivec.vsubeuqm
-    ppc_altivec_vsubsbs,                       // llvm.ppc.altivec.vsubsbs
-    ppc_altivec_vsubshs,                       // llvm.ppc.altivec.vsubshs
-    ppc_altivec_vsubsws,                       // llvm.ppc.altivec.vsubsws
-    ppc_altivec_vsububs,                       // llvm.ppc.altivec.vsububs
-    ppc_altivec_vsubuhs,                       // llvm.ppc.altivec.vsubuhs
-    ppc_altivec_vsubuws,                       // llvm.ppc.altivec.vsubuws
-    ppc_altivec_vsum2sws,                      // llvm.ppc.altivec.vsum2sws
-    ppc_altivec_vsum4sbs,                      // llvm.ppc.altivec.vsum4sbs
-    ppc_altivec_vsum4shs,                      // llvm.ppc.altivec.vsum4shs
-    ppc_altivec_vsum4ubs,                      // llvm.ppc.altivec.vsum4ubs
-    ppc_altivec_vsumsws,                       // llvm.ppc.altivec.vsumsws
-    ppc_altivec_vupkhpx,                       // llvm.ppc.altivec.vupkhpx
-    ppc_altivec_vupkhsb,                       // llvm.ppc.altivec.vupkhsb
-    ppc_altivec_vupkhsh,                       // llvm.ppc.altivec.vupkhsh
-    ppc_altivec_vupkhsw,                       // llvm.ppc.altivec.vupkhsw
-    ppc_altivec_vupklpx,                       // llvm.ppc.altivec.vupklpx
-    ppc_altivec_vupklsb,                       // llvm.ppc.altivec.vupklsb
-    ppc_altivec_vupklsh,                       // llvm.ppc.altivec.vupklsh
-    ppc_altivec_vupklsw,                       // llvm.ppc.altivec.vupklsw
-    ppc_bpermd,                                // llvm.ppc.bpermd
-    ppc_cfence,                                // llvm.ppc.cfence
-    ppc_dcba,                                  // llvm.ppc.dcba
-    ppc_dcbf,                                  // llvm.ppc.dcbf
-    ppc_dcbi,                                  // llvm.ppc.dcbi
-    ppc_dcbst,                                 // llvm.ppc.dcbst
-    ppc_dcbt,                                  // llvm.ppc.dcbt
-    ppc_dcbtst,                                // llvm.ppc.dcbtst
-    ppc_dcbz,                                  // llvm.ppc.dcbz
-    ppc_dcbzl,                                 // llvm.ppc.dcbzl
-    ppc_divde,                                 // llvm.ppc.divde
-    ppc_divdeu,                                // llvm.ppc.divdeu
-    ppc_divf128_round_to_odd,                  // llvm.ppc.divf128.round.to.odd
-    ppc_divwe,                                 // llvm.ppc.divwe
-    ppc_divweu,                                // llvm.ppc.divweu
-    ppc_fmaf128_round_to_odd,                  // llvm.ppc.fmaf128.round.to.odd
-    ppc_get_texasr,                            // llvm.ppc.get.texasr
-    ppc_get_texasru,                           // llvm.ppc.get.texasru
-    ppc_get_tfhar,                             // llvm.ppc.get.tfhar
-    ppc_get_tfiar,                             // llvm.ppc.get.tfiar
-    ppc_is_decremented_ctr_nonzero,            // llvm.ppc.is.decremented.ctr.nonzero
-    ppc_lwsync,                                // llvm.ppc.lwsync
-    ppc_mtctr,                                 // llvm.ppc.mtctr
-    ppc_mulf128_round_to_odd,                  // llvm.ppc.mulf128.round.to.odd
-    ppc_qpx_qvfabs,                            // llvm.ppc.qpx.qvfabs
-    ppc_qpx_qvfadd,                            // llvm.ppc.qpx.qvfadd
-    ppc_qpx_qvfadds,                           // llvm.ppc.qpx.qvfadds
-    ppc_qpx_qvfcfid,                           // llvm.ppc.qpx.qvfcfid
-    ppc_qpx_qvfcfids,                          // llvm.ppc.qpx.qvfcfids
-    ppc_qpx_qvfcfidu,                          // llvm.ppc.qpx.qvfcfidu
-    ppc_qpx_qvfcfidus,                         // llvm.ppc.qpx.qvfcfidus
-    ppc_qpx_qvfcmpeq,                          // llvm.ppc.qpx.qvfcmpeq
-    ppc_qpx_qvfcmpgt,                          // llvm.ppc.qpx.qvfcmpgt
-    ppc_qpx_qvfcmplt,                          // llvm.ppc.qpx.qvfcmplt
-    ppc_qpx_qvfcpsgn,                          // llvm.ppc.qpx.qvfcpsgn
-    ppc_qpx_qvfctid,                           // llvm.ppc.qpx.qvfctid
-    ppc_qpx_qvfctidu,                          // llvm.ppc.qpx.qvfctidu
-    ppc_qpx_qvfctiduz,                         // llvm.ppc.qpx.qvfctiduz
-    ppc_qpx_qvfctidz,                          // llvm.ppc.qpx.qvfctidz
-    ppc_qpx_qvfctiw,                           // llvm.ppc.qpx.qvfctiw
-    ppc_qpx_qvfctiwu,                          // llvm.ppc.qpx.qvfctiwu
-    ppc_qpx_qvfctiwuz,                         // llvm.ppc.qpx.qvfctiwuz
-    ppc_qpx_qvfctiwz,                          // llvm.ppc.qpx.qvfctiwz
-    ppc_qpx_qvflogical,                        // llvm.ppc.qpx.qvflogical
-    ppc_qpx_qvfmadd,                           // llvm.ppc.qpx.qvfmadd
-    ppc_qpx_qvfmadds,                          // llvm.ppc.qpx.qvfmadds
-    ppc_qpx_qvfmsub,                           // llvm.ppc.qpx.qvfmsub
-    ppc_qpx_qvfmsubs,                          // llvm.ppc.qpx.qvfmsubs
-    ppc_qpx_qvfmul,                            // llvm.ppc.qpx.qvfmul
-    ppc_qpx_qvfmuls,                           // llvm.ppc.qpx.qvfmuls
-    ppc_qpx_qvfnabs,                           // llvm.ppc.qpx.qvfnabs
-    ppc_qpx_qvfneg,                            // llvm.ppc.qpx.qvfneg
-    ppc_qpx_qvfnmadd,                          // llvm.ppc.qpx.qvfnmadd
-    ppc_qpx_qvfnmadds,                         // llvm.ppc.qpx.qvfnmadds
-    ppc_qpx_qvfnmsub,                          // llvm.ppc.qpx.qvfnmsub
-    ppc_qpx_qvfnmsubs,                         // llvm.ppc.qpx.qvfnmsubs
-    ppc_qpx_qvfperm,                           // llvm.ppc.qpx.qvfperm
-    ppc_qpx_qvfre,                             // llvm.ppc.qpx.qvfre
-    ppc_qpx_qvfres,                            // llvm.ppc.qpx.qvfres
-    ppc_qpx_qvfrim,                            // llvm.ppc.qpx.qvfrim
-    ppc_qpx_qvfrin,                            // llvm.ppc.qpx.qvfrin
-    ppc_qpx_qvfrip,                            // llvm.ppc.qpx.qvfrip
-    ppc_qpx_qvfriz,                            // llvm.ppc.qpx.qvfriz
-    ppc_qpx_qvfrsp,                            // llvm.ppc.qpx.qvfrsp
-    ppc_qpx_qvfrsqrte,                         // llvm.ppc.qpx.qvfrsqrte
-    ppc_qpx_qvfrsqrtes,                        // llvm.ppc.qpx.qvfrsqrtes
-    ppc_qpx_qvfsel,                            // llvm.ppc.qpx.qvfsel
-    ppc_qpx_qvfsub,                            // llvm.ppc.qpx.qvfsub
-    ppc_qpx_qvfsubs,                           // llvm.ppc.qpx.qvfsubs
-    ppc_qpx_qvftstnan,                         // llvm.ppc.qpx.qvftstnan
-    ppc_qpx_qvfxmadd,                          // llvm.ppc.qpx.qvfxmadd
-    ppc_qpx_qvfxmadds,                         // llvm.ppc.qpx.qvfxmadds
-    ppc_qpx_qvfxmul,                           // llvm.ppc.qpx.qvfxmul
-    ppc_qpx_qvfxmuls,                          // llvm.ppc.qpx.qvfxmuls
-    ppc_qpx_qvfxxcpnmadd,                      // llvm.ppc.qpx.qvfxxcpnmadd
-    ppc_qpx_qvfxxcpnmadds,                     // llvm.ppc.qpx.qvfxxcpnmadds
-    ppc_qpx_qvfxxmadd,                         // llvm.ppc.qpx.qvfxxmadd
-    ppc_qpx_qvfxxmadds,                        // llvm.ppc.qpx.qvfxxmadds
-    ppc_qpx_qvfxxnpmadd,                       // llvm.ppc.qpx.qvfxxnpmadd
-    ppc_qpx_qvfxxnpmadds,                      // llvm.ppc.qpx.qvfxxnpmadds
-    ppc_qpx_qvgpci,                            // llvm.ppc.qpx.qvgpci
-    ppc_qpx_qvlfcd,                            // llvm.ppc.qpx.qvlfcd
-    ppc_qpx_qvlfcda,                           // llvm.ppc.qpx.qvlfcda
-    ppc_qpx_qvlfcs,                            // llvm.ppc.qpx.qvlfcs
-    ppc_qpx_qvlfcsa,                           // llvm.ppc.qpx.qvlfcsa
-    ppc_qpx_qvlfd,                             // llvm.ppc.qpx.qvlfd
-    ppc_qpx_qvlfda,                            // llvm.ppc.qpx.qvlfda
-    ppc_qpx_qvlfiwa,                           // llvm.ppc.qpx.qvlfiwa
-    ppc_qpx_qvlfiwaa,                          // llvm.ppc.qpx.qvlfiwaa
-    ppc_qpx_qvlfiwz,                           // llvm.ppc.qpx.qvlfiwz
-    ppc_qpx_qvlfiwza,                          // llvm.ppc.qpx.qvlfiwza
-    ppc_qpx_qvlfs,                             // llvm.ppc.qpx.qvlfs
-    ppc_qpx_qvlfsa,                            // llvm.ppc.qpx.qvlfsa
-    ppc_qpx_qvlpcld,                           // llvm.ppc.qpx.qvlpcld
-    ppc_qpx_qvlpcls,                           // llvm.ppc.qpx.qvlpcls
-    ppc_qpx_qvlpcrd,                           // llvm.ppc.qpx.qvlpcrd
-    ppc_qpx_qvlpcrs,                           // llvm.ppc.qpx.qvlpcrs
-    ppc_qpx_qvstfcd,                           // llvm.ppc.qpx.qvstfcd
-    ppc_qpx_qvstfcda,                          // llvm.ppc.qpx.qvstfcda
-    ppc_qpx_qvstfcs,                           // llvm.ppc.qpx.qvstfcs
-    ppc_qpx_qvstfcsa,                          // llvm.ppc.qpx.qvstfcsa
-    ppc_qpx_qvstfd,                            // llvm.ppc.qpx.qvstfd
-    ppc_qpx_qvstfda,                           // llvm.ppc.qpx.qvstfda
-    ppc_qpx_qvstfiw,                           // llvm.ppc.qpx.qvstfiw
-    ppc_qpx_qvstfiwa,                          // llvm.ppc.qpx.qvstfiwa
-    ppc_qpx_qvstfs,                            // llvm.ppc.qpx.qvstfs
-    ppc_qpx_qvstfsa,                           // llvm.ppc.qpx.qvstfsa
-    ppc_scalar_extract_expq,                   // llvm.ppc.scalar.extract.expq
-    ppc_scalar_insert_exp_qp,                  // llvm.ppc.scalar.insert.exp.qp
-    ppc_set_texasr,                            // llvm.ppc.set.texasr
-    ppc_set_texasru,                           // llvm.ppc.set.texasru
-    ppc_set_tfhar,                             // llvm.ppc.set.tfhar
-    ppc_set_tfiar,                             // llvm.ppc.set.tfiar
-    ppc_setrnd,                                // llvm.ppc.setrnd
-    ppc_sqrtf128_round_to_odd,                 // llvm.ppc.sqrtf128.round.to.odd
-    ppc_subf128_round_to_odd,                  // llvm.ppc.subf128.round.to.odd
-    ppc_sync,                                  // llvm.ppc.sync
-    ppc_tabort,                                // llvm.ppc.tabort
-    ppc_tabortdc,                              // llvm.ppc.tabortdc
-    ppc_tabortdci,                             // llvm.ppc.tabortdci
-    ppc_tabortwc,                              // llvm.ppc.tabortwc
-    ppc_tabortwci,                             // llvm.ppc.tabortwci
-    ppc_tbegin,                                // llvm.ppc.tbegin
-    ppc_tcheck,                                // llvm.ppc.tcheck
-    ppc_tend,                                  // llvm.ppc.tend
-    ppc_tendall,                               // llvm.ppc.tendall
-    ppc_trechkpt,                              // llvm.ppc.trechkpt
-    ppc_treclaim,                              // llvm.ppc.treclaim
-    ppc_tresume,                               // llvm.ppc.tresume
-    ppc_truncf128_round_to_odd,                // llvm.ppc.truncf128.round.to.odd
-    ppc_tsr,                                   // llvm.ppc.tsr
-    ppc_tsuspend,                              // llvm.ppc.tsuspend
-    ppc_ttest,                                 // llvm.ppc.ttest
-    ppc_vsx_lxvd2x,                            // llvm.ppc.vsx.lxvd2x
-    ppc_vsx_lxvd2x_be,                         // llvm.ppc.vsx.lxvd2x.be
-    ppc_vsx_lxvl,                              // llvm.ppc.vsx.lxvl
-    ppc_vsx_lxvll,                             // llvm.ppc.vsx.lxvll
-    ppc_vsx_lxvw4x,                            // llvm.ppc.vsx.lxvw4x
-    ppc_vsx_lxvw4x_be,                         // llvm.ppc.vsx.lxvw4x.be
-    ppc_vsx_stxvd2x,                           // llvm.ppc.vsx.stxvd2x
-    ppc_vsx_stxvd2x_be,                        // llvm.ppc.vsx.stxvd2x.be
-    ppc_vsx_stxvl,                             // llvm.ppc.vsx.stxvl
-    ppc_vsx_stxvll,                            // llvm.ppc.vsx.stxvll
-    ppc_vsx_stxvw4x,                           // llvm.ppc.vsx.stxvw4x
-    ppc_vsx_stxvw4x_be,                        // llvm.ppc.vsx.stxvw4x.be
-    ppc_vsx_xsmaxdp,                           // llvm.ppc.vsx.xsmaxdp
-    ppc_vsx_xsmindp,                           // llvm.ppc.vsx.xsmindp
-    ppc_vsx_xvcmpeqdp,                         // llvm.ppc.vsx.xvcmpeqdp
-    ppc_vsx_xvcmpeqdp_p,                       // llvm.ppc.vsx.xvcmpeqdp.p
-    ppc_vsx_xvcmpeqsp,                         // llvm.ppc.vsx.xvcmpeqsp
-    ppc_vsx_xvcmpeqsp_p,                       // llvm.ppc.vsx.xvcmpeqsp.p
-    ppc_vsx_xvcmpgedp,                         // llvm.ppc.vsx.xvcmpgedp
-    ppc_vsx_xvcmpgedp_p,                       // llvm.ppc.vsx.xvcmpgedp.p
-    ppc_vsx_xvcmpgesp,                         // llvm.ppc.vsx.xvcmpgesp
-    ppc_vsx_xvcmpgesp_p,                       // llvm.ppc.vsx.xvcmpgesp.p
-    ppc_vsx_xvcmpgtdp,                         // llvm.ppc.vsx.xvcmpgtdp
-    ppc_vsx_xvcmpgtdp_p,                       // llvm.ppc.vsx.xvcmpgtdp.p
-    ppc_vsx_xvcmpgtsp,                         // llvm.ppc.vsx.xvcmpgtsp
-    ppc_vsx_xvcmpgtsp_p,                       // llvm.ppc.vsx.xvcmpgtsp.p
-    ppc_vsx_xvcvdpsp,                          // llvm.ppc.vsx.xvcvdpsp
-    ppc_vsx_xvcvdpsxws,                        // llvm.ppc.vsx.xvcvdpsxws
-    ppc_vsx_xvcvdpuxws,                        // llvm.ppc.vsx.xvcvdpuxws
-    ppc_vsx_xvcvhpsp,                          // llvm.ppc.vsx.xvcvhpsp
-    ppc_vsx_xvcvspdp,                          // llvm.ppc.vsx.xvcvspdp
-    ppc_vsx_xvcvsphp,                          // llvm.ppc.vsx.xvcvsphp
-    ppc_vsx_xvcvsxdsp,                         // llvm.ppc.vsx.xvcvsxdsp
-    ppc_vsx_xvcvsxwdp,                         // llvm.ppc.vsx.xvcvsxwdp
-    ppc_vsx_xvcvuxdsp,                         // llvm.ppc.vsx.xvcvuxdsp
-    ppc_vsx_xvcvuxwdp,                         // llvm.ppc.vsx.xvcvuxwdp
-    ppc_vsx_xvdivdp,                           // llvm.ppc.vsx.xvdivdp
-    ppc_vsx_xvdivsp,                           // llvm.ppc.vsx.xvdivsp
-    ppc_vsx_xviexpdp,                          // llvm.ppc.vsx.xviexpdp
-    ppc_vsx_xviexpsp,                          // llvm.ppc.vsx.xviexpsp
-    ppc_vsx_xvmaxdp,                           // llvm.ppc.vsx.xvmaxdp
-    ppc_vsx_xvmaxsp,                           // llvm.ppc.vsx.xvmaxsp
-    ppc_vsx_xvmindp,                           // llvm.ppc.vsx.xvmindp
-    ppc_vsx_xvminsp,                           // llvm.ppc.vsx.xvminsp
-    ppc_vsx_xvrdpip,                           // llvm.ppc.vsx.xvrdpip
-    ppc_vsx_xvredp,                            // llvm.ppc.vsx.xvredp
-    ppc_vsx_xvresp,                            // llvm.ppc.vsx.xvresp
-    ppc_vsx_xvrspip,                           // llvm.ppc.vsx.xvrspip
-    ppc_vsx_xvrsqrtedp,                        // llvm.ppc.vsx.xvrsqrtedp
-    ppc_vsx_xvrsqrtesp,                        // llvm.ppc.vsx.xvrsqrtesp
-    ppc_vsx_xvtstdcdp,                         // llvm.ppc.vsx.xvtstdcdp
-    ppc_vsx_xvtstdcsp,                         // llvm.ppc.vsx.xvtstdcsp
-    ppc_vsx_xvxexpdp,                          // llvm.ppc.vsx.xvxexpdp
-    ppc_vsx_xvxexpsp,                          // llvm.ppc.vsx.xvxexpsp
-    ppc_vsx_xvxsigdp,                          // llvm.ppc.vsx.xvxsigdp
-    ppc_vsx_xvxsigsp,                          // llvm.ppc.vsx.xvxsigsp
-    ppc_vsx_xxextractuw,                       // llvm.ppc.vsx.xxextractuw
-    ppc_vsx_xxinsertw,                         // llvm.ppc.vsx.xxinsertw
-    ppc_vsx_xxleqv,                            // llvm.ppc.vsx.xxleqv
-    r600_cube,                                 // llvm.r600.cube
-    r600_ddx,                                  // llvm.r600.ddx
-    r600_ddy,                                  // llvm.r600.ddy
-    r600_dot4,                                 // llvm.r600.dot4
-    r600_group_barrier,                        // llvm.r600.group.barrier
-    r600_implicitarg_ptr,                      // llvm.r600.implicitarg.ptr
-    r600_kill,                                 // llvm.r600.kill
-    r600_rat_store_typed,                      // llvm.r600.rat.store.typed
-    r600_read_global_size_x,                   // llvm.r600.read.global.size.x
-    r600_read_global_size_y,                   // llvm.r600.read.global.size.y
-    r600_read_global_size_z,                   // llvm.r600.read.global.size.z
-    r600_read_local_size_x,                    // llvm.r600.read.local.size.x
-    r600_read_local_size_y,                    // llvm.r600.read.local.size.y
-    r600_read_local_size_z,                    // llvm.r600.read.local.size.z
-    r600_read_ngroups_x,                       // llvm.r600.read.ngroups.x
-    r600_read_ngroups_y,                       // llvm.r600.read.ngroups.y
-    r600_read_ngroups_z,                       // llvm.r600.read.ngroups.z
-    r600_read_tgid_x,                          // llvm.r600.read.tgid.x
-    r600_read_tgid_y,                          // llvm.r600.read.tgid.y
-    r600_read_tgid_z,                          // llvm.r600.read.tgid.z
-    r600_read_tidig_x,                         // llvm.r600.read.tidig.x
-    r600_read_tidig_y,                         // llvm.r600.read.tidig.y
-    r600_read_tidig_z,                         // llvm.r600.read.tidig.z
-    r600_recipsqrt_clamped,                    // llvm.r600.recipsqrt.clamped
-    r600_recipsqrt_ieee,                       // llvm.r600.recipsqrt.ieee
-    r600_store_stream_output,                  // llvm.r600.store.stream.output
-    r600_store_swizzle,                        // llvm.r600.store.swizzle
-    r600_tex,                                  // llvm.r600.tex
-    r600_texc,                                 // llvm.r600.texc
-    r600_txb,                                  // llvm.r600.txb
-    r600_txbc,                                 // llvm.r600.txbc
-    r600_txf,                                  // llvm.r600.txf
-    r600_txl,                                  // llvm.r600.txl
-    r600_txlc,                                 // llvm.r600.txlc
-    r600_txq,                                  // llvm.r600.txq
-    riscv_masked_atomicrmw_add_i32,            // llvm.riscv.masked.atomicrmw.add.i32
-    riscv_masked_atomicrmw_add_i64,            // llvm.riscv.masked.atomicrmw.add.i64
-    riscv_masked_atomicrmw_max_i32,            // llvm.riscv.masked.atomicrmw.max.i32
-    riscv_masked_atomicrmw_max_i64,            // llvm.riscv.masked.atomicrmw.max.i64
-    riscv_masked_atomicrmw_min_i32,            // llvm.riscv.masked.atomicrmw.min.i32
-    riscv_masked_atomicrmw_min_i64,            // llvm.riscv.masked.atomicrmw.min.i64
-    riscv_masked_atomicrmw_nand_i32,           // llvm.riscv.masked.atomicrmw.nand.i32
-    riscv_masked_atomicrmw_nand_i64,           // llvm.riscv.masked.atomicrmw.nand.i64
-    riscv_masked_atomicrmw_sub_i32,            // llvm.riscv.masked.atomicrmw.sub.i32
-    riscv_masked_atomicrmw_sub_i64,            // llvm.riscv.masked.atomicrmw.sub.i64
-    riscv_masked_atomicrmw_umax_i32,           // llvm.riscv.masked.atomicrmw.umax.i32
-    riscv_masked_atomicrmw_umax_i64,           // llvm.riscv.masked.atomicrmw.umax.i64
-    riscv_masked_atomicrmw_umin_i32,           // llvm.riscv.masked.atomicrmw.umin.i32
-    riscv_masked_atomicrmw_umin_i64,           // llvm.riscv.masked.atomicrmw.umin.i64
-    riscv_masked_atomicrmw_xchg_i32,           // llvm.riscv.masked.atomicrmw.xchg.i32
-    riscv_masked_atomicrmw_xchg_i64,           // llvm.riscv.masked.atomicrmw.xchg.i64
-    riscv_masked_cmpxchg_i32,                  // llvm.riscv.masked.cmpxchg.i32
-    riscv_masked_cmpxchg_i64,                  // llvm.riscv.masked.cmpxchg.i64
-    s390_efpc,                                 // llvm.s390.efpc
-    s390_etnd,                                 // llvm.s390.etnd
-    s390_lcbb,                                 // llvm.s390.lcbb
-    s390_ntstg,                                // llvm.s390.ntstg
-    s390_ppa_txassist,                         // llvm.s390.ppa.txassist
-    s390_sfpc,                                 // llvm.s390.sfpc
-    s390_tabort,                               // llvm.s390.tabort
-    s390_tbegin,                               // llvm.s390.tbegin
-    s390_tbegin_nofloat,                       // llvm.s390.tbegin.nofloat
-    s390_tbeginc,                              // llvm.s390.tbeginc
-    s390_tdc,                                  // llvm.s390.tdc
-    s390_tend,                                 // llvm.s390.tend
-    s390_vaccb,                                // llvm.s390.vaccb
-    s390_vacccq,                               // llvm.s390.vacccq
-    s390_vaccf,                                // llvm.s390.vaccf
-    s390_vaccg,                                // llvm.s390.vaccg
-    s390_vacch,                                // llvm.s390.vacch
-    s390_vaccq,                                // llvm.s390.vaccq
-    s390_vacq,                                 // llvm.s390.vacq
-    s390_vaq,                                  // llvm.s390.vaq
-    s390_vavgb,                                // llvm.s390.vavgb
-    s390_vavgf,                                // llvm.s390.vavgf
-    s390_vavgg,                                // llvm.s390.vavgg
-    s390_vavgh,                                // llvm.s390.vavgh
-    s390_vavglb,                               // llvm.s390.vavglb
-    s390_vavglf,                               // llvm.s390.vavglf
-    s390_vavglg,                               // llvm.s390.vavglg
-    s390_vavglh,                               // llvm.s390.vavglh
-    s390_vbperm,                               // llvm.s390.vbperm
-    s390_vceqbs,                               // llvm.s390.vceqbs
-    s390_vceqfs,                               // llvm.s390.vceqfs
-    s390_vceqgs,                               // llvm.s390.vceqgs
-    s390_vceqhs,                               // llvm.s390.vceqhs
-    s390_vchbs,                                // llvm.s390.vchbs
-    s390_vchfs,                                // llvm.s390.vchfs
-    s390_vchgs,                                // llvm.s390.vchgs
-    s390_vchhs,                                // llvm.s390.vchhs
-    s390_vchlbs,                               // llvm.s390.vchlbs
-    s390_vchlfs,                               // llvm.s390.vchlfs
-    s390_vchlgs,                               // llvm.s390.vchlgs
-    s390_vchlhs,                               // llvm.s390.vchlhs
-    s390_vcksm,                                // llvm.s390.vcksm
-    s390_verimb,                               // llvm.s390.verimb
-    s390_verimf,                               // llvm.s390.verimf
-    s390_verimg,                               // llvm.s390.verimg
-    s390_verimh,                               // llvm.s390.verimh
-    s390_verllb,                               // llvm.s390.verllb
-    s390_verllf,                               // llvm.s390.verllf
-    s390_verllg,                               // llvm.s390.verllg
-    s390_verllh,                               // llvm.s390.verllh
-    s390_verllvb,                              // llvm.s390.verllvb
-    s390_verllvf,                              // llvm.s390.verllvf
-    s390_verllvg,                              // llvm.s390.verllvg
-    s390_verllvh,                              // llvm.s390.verllvh
-    s390_vfaeb,                                // llvm.s390.vfaeb
-    s390_vfaebs,                               // llvm.s390.vfaebs
-    s390_vfaef,                                // llvm.s390.vfaef
-    s390_vfaefs,                               // llvm.s390.vfaefs
-    s390_vfaeh,                                // llvm.s390.vfaeh
-    s390_vfaehs,                               // llvm.s390.vfaehs
-    s390_vfaezb,                               // llvm.s390.vfaezb
-    s390_vfaezbs,                              // llvm.s390.vfaezbs
-    s390_vfaezf,                               // llvm.s390.vfaezf
-    s390_vfaezfs,                              // llvm.s390.vfaezfs
-    s390_vfaezh,                               // llvm.s390.vfaezh
-    s390_vfaezhs,                              // llvm.s390.vfaezhs
-    s390_vfcedbs,                              // llvm.s390.vfcedbs
-    s390_vfcesbs,                              // llvm.s390.vfcesbs
-    s390_vfchdbs,                              // llvm.s390.vfchdbs
-    s390_vfchedbs,                             // llvm.s390.vfchedbs
-    s390_vfchesbs,                             // llvm.s390.vfchesbs
-    s390_vfchsbs,                              // llvm.s390.vfchsbs
-    s390_vfeeb,                                // llvm.s390.vfeeb
-    s390_vfeebs,                               // llvm.s390.vfeebs
-    s390_vfeef,                                // llvm.s390.vfeef
-    s390_vfeefs,                               // llvm.s390.vfeefs
-    s390_vfeeh,                                // llvm.s390.vfeeh
-    s390_vfeehs,                               // llvm.s390.vfeehs
-    s390_vfeezb,                               // llvm.s390.vfeezb
-    s390_vfeezbs,                              // llvm.s390.vfeezbs
-    s390_vfeezf,                               // llvm.s390.vfeezf
-    s390_vfeezfs,                              // llvm.s390.vfeezfs
-    s390_vfeezh,                               // llvm.s390.vfeezh
-    s390_vfeezhs,                              // llvm.s390.vfeezhs
-    s390_vfeneb,                               // llvm.s390.vfeneb
-    s390_vfenebs,                              // llvm.s390.vfenebs
-    s390_vfenef,                               // llvm.s390.vfenef
-    s390_vfenefs,                              // llvm.s390.vfenefs
-    s390_vfeneh,                               // llvm.s390.vfeneh
-    s390_vfenehs,                              // llvm.s390.vfenehs
-    s390_vfenezb,                              // llvm.s390.vfenezb
-    s390_vfenezbs,                             // llvm.s390.vfenezbs
-    s390_vfenezf,                              // llvm.s390.vfenezf
-    s390_vfenezfs,                             // llvm.s390.vfenezfs
-    s390_vfenezh,                              // llvm.s390.vfenezh
-    s390_vfenezhs,                             // llvm.s390.vfenezhs
-    s390_vfidb,                                // llvm.s390.vfidb
-    s390_vfisb,                                // llvm.s390.vfisb
-    s390_vfmaxdb,                              // llvm.s390.vfmaxdb
-    s390_vfmaxsb,                              // llvm.s390.vfmaxsb
-    s390_vfmindb,                              // llvm.s390.vfmindb
-    s390_vfminsb,                              // llvm.s390.vfminsb
-    s390_vftcidb,                              // llvm.s390.vftcidb
-    s390_vftcisb,                              // llvm.s390.vftcisb
-    s390_vgfmab,                               // llvm.s390.vgfmab
-    s390_vgfmaf,                               // llvm.s390.vgfmaf
-    s390_vgfmag,                               // llvm.s390.vgfmag
-    s390_vgfmah,                               // llvm.s390.vgfmah
-    s390_vgfmb,                                // llvm.s390.vgfmb
-    s390_vgfmf,                                // llvm.s390.vgfmf
-    s390_vgfmg,                                // llvm.s390.vgfmg
-    s390_vgfmh,                                // llvm.s390.vgfmh
-    s390_vistrb,                               // llvm.s390.vistrb
-    s390_vistrbs,                              // llvm.s390.vistrbs
-    s390_vistrf,                               // llvm.s390.vistrf
-    s390_vistrfs,                              // llvm.s390.vistrfs
-    s390_vistrh,                               // llvm.s390.vistrh
-    s390_vistrhs,                              // llvm.s390.vistrhs
-    s390_vlbb,                                 // llvm.s390.vlbb
-    s390_vll,                                  // llvm.s390.vll
-    s390_vlrl,                                 // llvm.s390.vlrl
-    s390_vmaeb,                                // llvm.s390.vmaeb
-    s390_vmaef,                                // llvm.s390.vmaef
-    s390_vmaeh,                                // llvm.s390.vmaeh
-    s390_vmahb,                                // llvm.s390.vmahb
-    s390_vmahf,                                // llvm.s390.vmahf
-    s390_vmahh,                                // llvm.s390.vmahh
-    s390_vmaleb,                               // llvm.s390.vmaleb
-    s390_vmalef,                               // llvm.s390.vmalef
-    s390_vmaleh,                               // llvm.s390.vmaleh
-    s390_vmalhb,                               // llvm.s390.vmalhb
-    s390_vmalhf,                               // llvm.s390.vmalhf
-    s390_vmalhh,                               // llvm.s390.vmalhh
-    s390_vmalob,                               // llvm.s390.vmalob
-    s390_vmalof,                               // llvm.s390.vmalof
-    s390_vmaloh,                               // llvm.s390.vmaloh
-    s390_vmaob,                                // llvm.s390.vmaob
-    s390_vmaof,                                // llvm.s390.vmaof
-    s390_vmaoh,                                // llvm.s390.vmaoh
-    s390_vmeb,                                 // llvm.s390.vmeb
-    s390_vmef,                                 // llvm.s390.vmef
-    s390_vmeh,                                 // llvm.s390.vmeh
-    s390_vmhb,                                 // llvm.s390.vmhb
-    s390_vmhf,                                 // llvm.s390.vmhf
-    s390_vmhh,                                 // llvm.s390.vmhh
-    s390_vmleb,                                // llvm.s390.vmleb
-    s390_vmlef,                                // llvm.s390.vmlef
-    s390_vmleh,                                // llvm.s390.vmleh
-    s390_vmlhb,                                // llvm.s390.vmlhb
-    s390_vmlhf,                                // llvm.s390.vmlhf
-    s390_vmlhh,                                // llvm.s390.vmlhh
-    s390_vmlob,                                // llvm.s390.vmlob
-    s390_vmlof,                                // llvm.s390.vmlof
-    s390_vmloh,                                // llvm.s390.vmloh
-    s390_vmob,                                 // llvm.s390.vmob
-    s390_vmof,                                 // llvm.s390.vmof
-    s390_vmoh,                                 // llvm.s390.vmoh
-    s390_vmslg,                                // llvm.s390.vmslg
-    s390_vpdi,                                 // llvm.s390.vpdi
-    s390_vperm,                                // llvm.s390.vperm
-    s390_vpklsf,                               // llvm.s390.vpklsf
-    s390_vpklsfs,                              // llvm.s390.vpklsfs
-    s390_vpklsg,                               // llvm.s390.vpklsg
-    s390_vpklsgs,                              // llvm.s390.vpklsgs
-    s390_vpklsh,                               // llvm.s390.vpklsh
-    s390_vpklshs,                              // llvm.s390.vpklshs
-    s390_vpksf,                                // llvm.s390.vpksf
-    s390_vpksfs,                               // llvm.s390.vpksfs
-    s390_vpksg,                                // llvm.s390.vpksg
-    s390_vpksgs,                               // llvm.s390.vpksgs
-    s390_vpksh,                                // llvm.s390.vpksh
-    s390_vpkshs,                               // llvm.s390.vpkshs
-    s390_vsbcbiq,                              // llvm.s390.vsbcbiq
-    s390_vsbiq,                                // llvm.s390.vsbiq
-    s390_vscbib,                               // llvm.s390.vscbib
-    s390_vscbif,                               // llvm.s390.vscbif
-    s390_vscbig,                               // llvm.s390.vscbig
-    s390_vscbih,                               // llvm.s390.vscbih
-    s390_vscbiq,                               // llvm.s390.vscbiq
-    s390_vsl,                                  // llvm.s390.vsl
-    s390_vslb,                                 // llvm.s390.vslb
-    s390_vsldb,                                // llvm.s390.vsldb
-    s390_vsq,                                  // llvm.s390.vsq
-    s390_vsra,                                 // llvm.s390.vsra
-    s390_vsrab,                                // llvm.s390.vsrab
-    s390_vsrl,                                 // llvm.s390.vsrl
-    s390_vsrlb,                                // llvm.s390.vsrlb
-    s390_vstl,                                 // llvm.s390.vstl
-    s390_vstrcb,                               // llvm.s390.vstrcb
-    s390_vstrcbs,                              // llvm.s390.vstrcbs
-    s390_vstrcf,                               // llvm.s390.vstrcf
-    s390_vstrcfs,                              // llvm.s390.vstrcfs
-    s390_vstrch,                               // llvm.s390.vstrch
-    s390_vstrchs,                              // llvm.s390.vstrchs
-    s390_vstrczb,                              // llvm.s390.vstrczb
-    s390_vstrczbs,                             // llvm.s390.vstrczbs
-    s390_vstrczf,                              // llvm.s390.vstrczf
-    s390_vstrczfs,                             // llvm.s390.vstrczfs
-    s390_vstrczh,                              // llvm.s390.vstrczh
-    s390_vstrczhs,                             // llvm.s390.vstrczhs
-    s390_vstrl,                                // llvm.s390.vstrl
-    s390_vsumb,                                // llvm.s390.vsumb
-    s390_vsumgf,                               // llvm.s390.vsumgf
-    s390_vsumgh,                               // llvm.s390.vsumgh
-    s390_vsumh,                                // llvm.s390.vsumh
-    s390_vsumqf,                               // llvm.s390.vsumqf
-    s390_vsumqg,                               // llvm.s390.vsumqg
-    s390_vtm,                                  // llvm.s390.vtm
-    s390_vuphb,                                // llvm.s390.vuphb
-    s390_vuphf,                                // llvm.s390.vuphf
-    s390_vuphh,                                // llvm.s390.vuphh
-    s390_vuplb,                                // llvm.s390.vuplb
-    s390_vuplf,                                // llvm.s390.vuplf
-    s390_vuplhb,                               // llvm.s390.vuplhb
-    s390_vuplhf,                               // llvm.s390.vuplhf
-    s390_vuplhh,                               // llvm.s390.vuplhh
-    s390_vuplhw,                               // llvm.s390.vuplhw
-    s390_vupllb,                               // llvm.s390.vupllb
-    s390_vupllf,                               // llvm.s390.vupllf
-    s390_vupllh,                               // llvm.s390.vupllh
-    wasm_alltrue,                              // llvm.wasm.alltrue
-    wasm_anytrue,                              // llvm.wasm.anytrue
-    wasm_atomic_notify,                        // llvm.wasm.atomic.notify
-    wasm_atomic_wait_i32,                      // llvm.wasm.atomic.wait.i32
-    wasm_atomic_wait_i64,                      // llvm.wasm.atomic.wait.i64
-    wasm_bitselect,                            // llvm.wasm.bitselect
-    wasm_data_drop,                            // llvm.wasm.data.drop
-    wasm_extract_exception,                    // llvm.wasm.extract.exception
-    wasm_get_ehselector,                       // llvm.wasm.get.ehselector
-    wasm_get_exception,                        // llvm.wasm.get.exception
-    wasm_landingpad_index,                     // llvm.wasm.landingpad.index
-    wasm_lsda,                                 // llvm.wasm.lsda
-    wasm_memory_grow,                          // llvm.wasm.memory.grow
-    wasm_memory_init,                          // llvm.wasm.memory.init
-    wasm_memory_size,                          // llvm.wasm.memory.size
-    wasm_rethrow_in_catch,                     // llvm.wasm.rethrow.in.catch
-    wasm_sub_saturate_signed,                  // llvm.wasm.sub.saturate.signed
-    wasm_sub_saturate_unsigned,                // llvm.wasm.sub.saturate.unsigned
-    wasm_throw,                                // llvm.wasm.throw
-    wasm_trunc_saturate_signed,                // llvm.wasm.trunc.saturate.signed
-    wasm_trunc_saturate_unsigned,              // llvm.wasm.trunc.saturate.unsigned
-    x86_3dnow_pavgusb,                         // llvm.x86.3dnow.pavgusb
-    x86_3dnow_pf2id,                           // llvm.x86.3dnow.pf2id
-    x86_3dnow_pfacc,                           // llvm.x86.3dnow.pfacc
-    x86_3dnow_pfadd,                           // llvm.x86.3dnow.pfadd
-    x86_3dnow_pfcmpeq,                         // llvm.x86.3dnow.pfcmpeq
-    x86_3dnow_pfcmpge,                         // llvm.x86.3dnow.pfcmpge
-    x86_3dnow_pfcmpgt,                         // llvm.x86.3dnow.pfcmpgt
-    x86_3dnow_pfmax,                           // llvm.x86.3dnow.pfmax
-    x86_3dnow_pfmin,                           // llvm.x86.3dnow.pfmin
-    x86_3dnow_pfmul,                           // llvm.x86.3dnow.pfmul
-    x86_3dnow_pfrcp,                           // llvm.x86.3dnow.pfrcp
-    x86_3dnow_pfrcpit1,                        // llvm.x86.3dnow.pfrcpit1
-    x86_3dnow_pfrcpit2,                        // llvm.x86.3dnow.pfrcpit2
-    x86_3dnow_pfrsqit1,                        // llvm.x86.3dnow.pfrsqit1
-    x86_3dnow_pfrsqrt,                         // llvm.x86.3dnow.pfrsqrt
-    x86_3dnow_pfsub,                           // llvm.x86.3dnow.pfsub
-    x86_3dnow_pfsubr,                          // llvm.x86.3dnow.pfsubr
-    x86_3dnow_pi2fd,                           // llvm.x86.3dnow.pi2fd
-    x86_3dnow_pmulhrw,                         // llvm.x86.3dnow.pmulhrw
-    x86_3dnowa_pf2iw,                          // llvm.x86.3dnowa.pf2iw
-    x86_3dnowa_pfnacc,                         // llvm.x86.3dnowa.pfnacc
-    x86_3dnowa_pfpnacc,                        // llvm.x86.3dnowa.pfpnacc
-    x86_3dnowa_pi2fw,                          // llvm.x86.3dnowa.pi2fw
-    x86_3dnowa_pswapd,                         // llvm.x86.3dnowa.pswapd
-    x86_addcarry_32,                           // llvm.x86.addcarry.32
-    x86_addcarry_64,                           // llvm.x86.addcarry.64
-    x86_aesni_aesdec,                          // llvm.x86.aesni.aesdec
-    x86_aesni_aesdec_256,                      // llvm.x86.aesni.aesdec.256
-    x86_aesni_aesdec_512,                      // llvm.x86.aesni.aesdec.512
-    x86_aesni_aesdeclast,                      // llvm.x86.aesni.aesdeclast
-    x86_aesni_aesdeclast_256,                  // llvm.x86.aesni.aesdeclast.256
-    x86_aesni_aesdeclast_512,                  // llvm.x86.aesni.aesdeclast.512
-    x86_aesni_aesenc,                          // llvm.x86.aesni.aesenc
-    x86_aesni_aesenc_256,                      // llvm.x86.aesni.aesenc.256
-    x86_aesni_aesenc_512,                      // llvm.x86.aesni.aesenc.512
-    x86_aesni_aesenclast,                      // llvm.x86.aesni.aesenclast
-    x86_aesni_aesenclast_256,                  // llvm.x86.aesni.aesenclast.256
-    x86_aesni_aesenclast_512,                  // llvm.x86.aesni.aesenclast.512
-    x86_aesni_aesimc,                          // llvm.x86.aesni.aesimc
-    x86_aesni_aeskeygenassist,                 // llvm.x86.aesni.aeskeygenassist
-    x86_avx_addsub_pd_256,                     // llvm.x86.avx.addsub.pd.256
-    x86_avx_addsub_ps_256,                     // llvm.x86.avx.addsub.ps.256
-    x86_avx_blendv_pd_256,                     // llvm.x86.avx.blendv.pd.256
-    x86_avx_blendv_ps_256,                     // llvm.x86.avx.blendv.ps.256
-    x86_avx_cmp_pd_256,                        // llvm.x86.avx.cmp.pd.256
-    x86_avx_cmp_ps_256,                        // llvm.x86.avx.cmp.ps.256
-    x86_avx_cvt_pd2_ps_256,                    // llvm.x86.avx.cvt.pd2.ps.256
-    x86_avx_cvt_pd2dq_256,                     // llvm.x86.avx.cvt.pd2dq.256
-    x86_avx_cvt_ps2dq_256,                     // llvm.x86.avx.cvt.ps2dq.256
-    x86_avx_cvtt_pd2dq_256,                    // llvm.x86.avx.cvtt.pd2dq.256
-    x86_avx_cvtt_ps2dq_256,                    // llvm.x86.avx.cvtt.ps2dq.256
-    x86_avx_dp_ps_256,                         // llvm.x86.avx.dp.ps.256
-    x86_avx_hadd_pd_256,                       // llvm.x86.avx.hadd.pd.256
-    x86_avx_hadd_ps_256,                       // llvm.x86.avx.hadd.ps.256
-    x86_avx_hsub_pd_256,                       // llvm.x86.avx.hsub.pd.256
-    x86_avx_hsub_ps_256,                       // llvm.x86.avx.hsub.ps.256
-    x86_avx_ldu_dq_256,                        // llvm.x86.avx.ldu.dq.256
-    x86_avx_maskload_pd,                       // llvm.x86.avx.maskload.pd
-    x86_avx_maskload_pd_256,                   // llvm.x86.avx.maskload.pd.256
-    x86_avx_maskload_ps,                       // llvm.x86.avx.maskload.ps
-    x86_avx_maskload_ps_256,                   // llvm.x86.avx.maskload.ps.256
-    x86_avx_maskstore_pd,                      // llvm.x86.avx.maskstore.pd
-    x86_avx_maskstore_pd_256,                  // llvm.x86.avx.maskstore.pd.256
-    x86_avx_maskstore_ps,                      // llvm.x86.avx.maskstore.ps
-    x86_avx_maskstore_ps_256,                  // llvm.x86.avx.maskstore.ps.256
-    x86_avx_max_pd_256,                        // llvm.x86.avx.max.pd.256
-    x86_avx_max_ps_256,                        // llvm.x86.avx.max.ps.256
-    x86_avx_min_pd_256,                        // llvm.x86.avx.min.pd.256
-    x86_avx_min_ps_256,                        // llvm.x86.avx.min.ps.256
-    x86_avx_movmsk_pd_256,                     // llvm.x86.avx.movmsk.pd.256
-    x86_avx_movmsk_ps_256,                     // llvm.x86.avx.movmsk.ps.256
-    x86_avx_ptestc_256,                        // llvm.x86.avx.ptestc.256
-    x86_avx_ptestnzc_256,                      // llvm.x86.avx.ptestnzc.256
-    x86_avx_ptestz_256,                        // llvm.x86.avx.ptestz.256
-    x86_avx_rcp_ps_256,                        // llvm.x86.avx.rcp.ps.256
-    x86_avx_round_pd_256,                      // llvm.x86.avx.round.pd.256
-    x86_avx_round_ps_256,                      // llvm.x86.avx.round.ps.256
-    x86_avx_rsqrt_ps_256,                      // llvm.x86.avx.rsqrt.ps.256
-    x86_avx_vpermilvar_pd,                     // llvm.x86.avx.vpermilvar.pd
-    x86_avx_vpermilvar_pd_256,                 // llvm.x86.avx.vpermilvar.pd.256
-    x86_avx_vpermilvar_ps,                     // llvm.x86.avx.vpermilvar.ps
-    x86_avx_vpermilvar_ps_256,                 // llvm.x86.avx.vpermilvar.ps.256
-    x86_avx_vtestc_pd,                         // llvm.x86.avx.vtestc.pd
-    x86_avx_vtestc_pd_256,                     // llvm.x86.avx.vtestc.pd.256
-    x86_avx_vtestc_ps,                         // llvm.x86.avx.vtestc.ps
-    x86_avx_vtestc_ps_256,                     // llvm.x86.avx.vtestc.ps.256
-    x86_avx_vtestnzc_pd,                       // llvm.x86.avx.vtestnzc.pd
-    x86_avx_vtestnzc_pd_256,                   // llvm.x86.avx.vtestnzc.pd.256
-    x86_avx_vtestnzc_ps,                       // llvm.x86.avx.vtestnzc.ps
-    x86_avx_vtestnzc_ps_256,                   // llvm.x86.avx.vtestnzc.ps.256
-    x86_avx_vtestz_pd,                         // llvm.x86.avx.vtestz.pd
-    x86_avx_vtestz_pd_256,                     // llvm.x86.avx.vtestz.pd.256
-    x86_avx_vtestz_ps,                         // llvm.x86.avx.vtestz.ps
-    x86_avx_vtestz_ps_256,                     // llvm.x86.avx.vtestz.ps.256
-    x86_avx_vzeroall,                          // llvm.x86.avx.vzeroall
-    x86_avx_vzeroupper,                        // llvm.x86.avx.vzeroupper
-    x86_avx2_gather_d_d,                       // llvm.x86.avx2.gather.d.d
-    x86_avx2_gather_d_d_256,                   // llvm.x86.avx2.gather.d.d.256
-    x86_avx2_gather_d_pd,                      // llvm.x86.avx2.gather.d.pd
-    x86_avx2_gather_d_pd_256,                  // llvm.x86.avx2.gather.d.pd.256
-    x86_avx2_gather_d_ps,                      // llvm.x86.avx2.gather.d.ps
-    x86_avx2_gather_d_ps_256,                  // llvm.x86.avx2.gather.d.ps.256
-    x86_avx2_gather_d_q,                       // llvm.x86.avx2.gather.d.q
-    x86_avx2_gather_d_q_256,                   // llvm.x86.avx2.gather.d.q.256
-    x86_avx2_gather_q_d,                       // llvm.x86.avx2.gather.q.d
-    x86_avx2_gather_q_d_256,                   // llvm.x86.avx2.gather.q.d.256
-    x86_avx2_gather_q_pd,                      // llvm.x86.avx2.gather.q.pd
-    x86_avx2_gather_q_pd_256,                  // llvm.x86.avx2.gather.q.pd.256
-    x86_avx2_gather_q_ps,                      // llvm.x86.avx2.gather.q.ps
-    x86_avx2_gather_q_ps_256,                  // llvm.x86.avx2.gather.q.ps.256
-    x86_avx2_gather_q_q,                       // llvm.x86.avx2.gather.q.q
-    x86_avx2_gather_q_q_256,                   // llvm.x86.avx2.gather.q.q.256
-    x86_avx2_maskload_d,                       // llvm.x86.avx2.maskload.d
-    x86_avx2_maskload_d_256,                   // llvm.x86.avx2.maskload.d.256
-    x86_avx2_maskload_q,                       // llvm.x86.avx2.maskload.q
-    x86_avx2_maskload_q_256,                   // llvm.x86.avx2.maskload.q.256
-    x86_avx2_maskstore_d,                      // llvm.x86.avx2.maskstore.d
-    x86_avx2_maskstore_d_256,                  // llvm.x86.avx2.maskstore.d.256
-    x86_avx2_maskstore_q,                      // llvm.x86.avx2.maskstore.q
-    x86_avx2_maskstore_q_256,                  // llvm.x86.avx2.maskstore.q.256
-    x86_avx2_mpsadbw,                          // llvm.x86.avx2.mpsadbw
-    x86_avx2_packssdw,                         // llvm.x86.avx2.packssdw
-    x86_avx2_packsswb,                         // llvm.x86.avx2.packsswb
-    x86_avx2_packusdw,                         // llvm.x86.avx2.packusdw
-    x86_avx2_packuswb,                         // llvm.x86.avx2.packuswb
-    x86_avx2_pavg_b,                           // llvm.x86.avx2.pavg.b
-    x86_avx2_pavg_w,                           // llvm.x86.avx2.pavg.w
-    x86_avx2_pblendvb,                         // llvm.x86.avx2.pblendvb
-    x86_avx2_permd,                            // llvm.x86.avx2.permd
-    x86_avx2_permps,                           // llvm.x86.avx2.permps
-    x86_avx2_phadd_d,                          // llvm.x86.avx2.phadd.d
-    x86_avx2_phadd_sw,                         // llvm.x86.avx2.phadd.sw
-    x86_avx2_phadd_w,                          // llvm.x86.avx2.phadd.w
-    x86_avx2_phsub_d,                          // llvm.x86.avx2.phsub.d
-    x86_avx2_phsub_sw,                         // llvm.x86.avx2.phsub.sw
-    x86_avx2_phsub_w,                          // llvm.x86.avx2.phsub.w
-    x86_avx2_pmadd_ub_sw,                      // llvm.x86.avx2.pmadd.ub.sw
-    x86_avx2_pmadd_wd,                         // llvm.x86.avx2.pmadd.wd
-    x86_avx2_pmovmskb,                         // llvm.x86.avx2.pmovmskb
-    x86_avx2_pmul_hr_sw,                       // llvm.x86.avx2.pmul.hr.sw
-    x86_avx2_pmulh_w,                          // llvm.x86.avx2.pmulh.w
-    x86_avx2_pmulhu_w,                         // llvm.x86.avx2.pmulhu.w
-    x86_avx2_psad_bw,                          // llvm.x86.avx2.psad.bw
-    x86_avx2_pshuf_b,                          // llvm.x86.avx2.pshuf.b
-    x86_avx2_psign_b,                          // llvm.x86.avx2.psign.b
-    x86_avx2_psign_d,                          // llvm.x86.avx2.psign.d
-    x86_avx2_psign_w,                          // llvm.x86.avx2.psign.w
-    x86_avx2_psll_d,                           // llvm.x86.avx2.psll.d
-    x86_avx2_psll_q,                           // llvm.x86.avx2.psll.q
-    x86_avx2_psll_w,                           // llvm.x86.avx2.psll.w
-    x86_avx2_pslli_d,                          // llvm.x86.avx2.pslli.d
-    x86_avx2_pslli_q,                          // llvm.x86.avx2.pslli.q
-    x86_avx2_pslli_w,                          // llvm.x86.avx2.pslli.w
-    x86_avx2_psllv_d,                          // llvm.x86.avx2.psllv.d
-    x86_avx2_psllv_d_256,                      // llvm.x86.avx2.psllv.d.256
-    x86_avx2_psllv_q,                          // llvm.x86.avx2.psllv.q
-    x86_avx2_psllv_q_256,                      // llvm.x86.avx2.psllv.q.256
-    x86_avx2_psra_d,                           // llvm.x86.avx2.psra.d
-    x86_avx2_psra_w,                           // llvm.x86.avx2.psra.w
-    x86_avx2_psrai_d,                          // llvm.x86.avx2.psrai.d
-    x86_avx2_psrai_w,                          // llvm.x86.avx2.psrai.w
-    x86_avx2_psrav_d,                          // llvm.x86.avx2.psrav.d
-    x86_avx2_psrav_d_256,                      // llvm.x86.avx2.psrav.d.256
-    x86_avx2_psrl_d,                           // llvm.x86.avx2.psrl.d
-    x86_avx2_psrl_q,                           // llvm.x86.avx2.psrl.q
-    x86_avx2_psrl_w,                           // llvm.x86.avx2.psrl.w
-    x86_avx2_psrli_d,                          // llvm.x86.avx2.psrli.d
-    x86_avx2_psrli_q,                          // llvm.x86.avx2.psrli.q
-    x86_avx2_psrli_w,                          // llvm.x86.avx2.psrli.w
-    x86_avx2_psrlv_d,                          // llvm.x86.avx2.psrlv.d
-    x86_avx2_psrlv_d_256,                      // llvm.x86.avx2.psrlv.d.256
-    x86_avx2_psrlv_q,                          // llvm.x86.avx2.psrlv.q
-    x86_avx2_psrlv_q_256,                      // llvm.x86.avx2.psrlv.q.256
-    x86_avx512_add_pd_512,                     // llvm.x86.avx512.add.pd.512
-    x86_avx512_add_ps_512,                     // llvm.x86.avx512.add.ps.512
-    x86_avx512_broadcastmb_128,                // llvm.x86.avx512.broadcastmb.128
-    x86_avx512_broadcastmb_256,                // llvm.x86.avx512.broadcastmb.256
-    x86_avx512_broadcastmb_512,                // llvm.x86.avx512.broadcastmb.512
-    x86_avx512_broadcastmw_128,                // llvm.x86.avx512.broadcastmw.128
-    x86_avx512_broadcastmw_256,                // llvm.x86.avx512.broadcastmw.256
-    x86_avx512_broadcastmw_512,                // llvm.x86.avx512.broadcastmw.512
-    x86_avx512_cmp_pd_128,                     // llvm.x86.avx512.cmp.pd.128
-    x86_avx512_cmp_pd_256,                     // llvm.x86.avx512.cmp.pd.256
-    x86_avx512_cmp_pd_512,                     // llvm.x86.avx512.cmp.pd.512
-    x86_avx512_cmp_ps_128,                     // llvm.x86.avx512.cmp.ps.128
-    x86_avx512_cmp_ps_256,                     // llvm.x86.avx512.cmp.ps.256
-    x86_avx512_cmp_ps_512,                     // llvm.x86.avx512.cmp.ps.512
-    x86_avx512_conflict_d_128,                 // llvm.x86.avx512.conflict.d.128
-    x86_avx512_conflict_d_256,                 // llvm.x86.avx512.conflict.d.256
-    x86_avx512_conflict_d_512,                 // llvm.x86.avx512.conflict.d.512
-    x86_avx512_conflict_q_128,                 // llvm.x86.avx512.conflict.q.128
-    x86_avx512_conflict_q_256,                 // llvm.x86.avx512.conflict.q.256
-    x86_avx512_conflict_q_512,                 // llvm.x86.avx512.conflict.q.512
-    x86_avx512_cvtsi2sd64,                     // llvm.x86.avx512.cvtsi2sd64
-    x86_avx512_cvtsi2ss32,                     // llvm.x86.avx512.cvtsi2ss32
-    x86_avx512_cvtsi2ss64,                     // llvm.x86.avx512.cvtsi2ss64
-    x86_avx512_cvttsd2si,                      // llvm.x86.avx512.cvttsd2si
-    x86_avx512_cvttsd2si64,                    // llvm.x86.avx512.cvttsd2si64
-    x86_avx512_cvttsd2usi,                     // llvm.x86.avx512.cvttsd2usi
-    x86_avx512_cvttsd2usi64,                   // llvm.x86.avx512.cvttsd2usi64
-    x86_avx512_cvttss2si,                      // llvm.x86.avx512.cvttss2si
-    x86_avx512_cvttss2si64,                    // llvm.x86.avx512.cvttss2si64
-    x86_avx512_cvttss2usi,                     // llvm.x86.avx512.cvttss2usi
-    x86_avx512_cvttss2usi64,                   // llvm.x86.avx512.cvttss2usi64
-    x86_avx512_cvtusi2ss,                      // llvm.x86.avx512.cvtusi2ss
-    x86_avx512_cvtusi642sd,                    // llvm.x86.avx512.cvtusi642sd
-    x86_avx512_cvtusi642ss,                    // llvm.x86.avx512.cvtusi642ss
-    x86_avx512_dbpsadbw_128,                   // llvm.x86.avx512.dbpsadbw.128
-    x86_avx512_dbpsadbw_256,                   // llvm.x86.avx512.dbpsadbw.256
-    x86_avx512_dbpsadbw_512,                   // llvm.x86.avx512.dbpsadbw.512
-    x86_avx512_div_pd_512,                     // llvm.x86.avx512.div.pd.512
-    x86_avx512_div_ps_512,                     // llvm.x86.avx512.div.ps.512
-    x86_avx512_exp2_pd,                        // llvm.x86.avx512.exp2.pd
-    x86_avx512_exp2_ps,                        // llvm.x86.avx512.exp2.ps
-    x86_avx512_fpclass_pd_128,                 // llvm.x86.avx512.fpclass.pd.128
-    x86_avx512_fpclass_pd_256,                 // llvm.x86.avx512.fpclass.pd.256
-    x86_avx512_fpclass_pd_512,                 // llvm.x86.avx512.fpclass.pd.512
-    x86_avx512_fpclass_ps_128,                 // llvm.x86.avx512.fpclass.ps.128
-    x86_avx512_fpclass_ps_256,                 // llvm.x86.avx512.fpclass.ps.256
-    x86_avx512_fpclass_ps_512,                 // llvm.x86.avx512.fpclass.ps.512
-    x86_avx512_gather_dpd_512,                 // llvm.x86.avx512.gather.dpd.512
-    x86_avx512_gather_dpi_512,                 // llvm.x86.avx512.gather.dpi.512
-    x86_avx512_gather_dpq_512,                 // llvm.x86.avx512.gather.dpq.512
-    x86_avx512_gather_dps_512,                 // llvm.x86.avx512.gather.dps.512
-    x86_avx512_gather_qpd_512,                 // llvm.x86.avx512.gather.qpd.512
-    x86_avx512_gather_qpi_512,                 // llvm.x86.avx512.gather.qpi.512
-    x86_avx512_gather_qpq_512,                 // llvm.x86.avx512.gather.qpq.512
-    x86_avx512_gather_qps_512,                 // llvm.x86.avx512.gather.qps.512
-    x86_avx512_gather3div2_df,                 // llvm.x86.avx512.gather3div2.df
-    x86_avx512_gather3div2_di,                 // llvm.x86.avx512.gather3div2.di
-    x86_avx512_gather3div4_df,                 // llvm.x86.avx512.gather3div4.df
-    x86_avx512_gather3div4_di,                 // llvm.x86.avx512.gather3div4.di
-    x86_avx512_gather3div4_sf,                 // llvm.x86.avx512.gather3div4.sf
-    x86_avx512_gather3div4_si,                 // llvm.x86.avx512.gather3div4.si
-    x86_avx512_gather3div8_sf,                 // llvm.x86.avx512.gather3div8.sf
-    x86_avx512_gather3div8_si,                 // llvm.x86.avx512.gather3div8.si
-    x86_avx512_gather3siv2_df,                 // llvm.x86.avx512.gather3siv2.df
-    x86_avx512_gather3siv2_di,                 // llvm.x86.avx512.gather3siv2.di
-    x86_avx512_gather3siv4_df,                 // llvm.x86.avx512.gather3siv4.df
-    x86_avx512_gather3siv4_di,                 // llvm.x86.avx512.gather3siv4.di
-    x86_avx512_gather3siv4_sf,                 // llvm.x86.avx512.gather3siv4.sf
-    x86_avx512_gather3siv4_si,                 // llvm.x86.avx512.gather3siv4.si
-    x86_avx512_gather3siv8_sf,                 // llvm.x86.avx512.gather3siv8.sf
-    x86_avx512_gather3siv8_si,                 // llvm.x86.avx512.gather3siv8.si
-    x86_avx512_gatherpf_dpd_512,               // llvm.x86.avx512.gatherpf.dpd.512
-    x86_avx512_gatherpf_dps_512,               // llvm.x86.avx512.gatherpf.dps.512
-    x86_avx512_gatherpf_qpd_512,               // llvm.x86.avx512.gatherpf.qpd.512
-    x86_avx512_gatherpf_qps_512,               // llvm.x86.avx512.gatherpf.qps.512
-    x86_avx512_kadd_b,                         // llvm.x86.avx512.kadd.b
-    x86_avx512_kadd_d,                         // llvm.x86.avx512.kadd.d
-    x86_avx512_kadd_q,                         // llvm.x86.avx512.kadd.q
-    x86_avx512_kadd_w,                         // llvm.x86.avx512.kadd.w
-    x86_avx512_ktestc_b,                       // llvm.x86.avx512.ktestc.b
-    x86_avx512_ktestc_d,                       // llvm.x86.avx512.ktestc.d
-    x86_avx512_ktestc_q,                       // llvm.x86.avx512.ktestc.q
-    x86_avx512_ktestc_w,                       // llvm.x86.avx512.ktestc.w
-    x86_avx512_ktestz_b,                       // llvm.x86.avx512.ktestz.b
-    x86_avx512_ktestz_d,                       // llvm.x86.avx512.ktestz.d
-    x86_avx512_ktestz_q,                       // llvm.x86.avx512.ktestz.q
-    x86_avx512_ktestz_w,                       // llvm.x86.avx512.ktestz.w
-    x86_avx512_mask_add_sd_round,              // llvm.x86.avx512.mask.add.sd.round
-    x86_avx512_mask_add_ss_round,              // llvm.x86.avx512.mask.add.ss.round
-    x86_avx512_mask_cmp_sd,                    // llvm.x86.avx512.mask.cmp.sd
-    x86_avx512_mask_cmp_ss,                    // llvm.x86.avx512.mask.cmp.ss
-    x86_avx512_mask_compress,                  // llvm.x86.avx512.mask.compress
-    x86_avx512_mask_cvtpd2dq_128,              // llvm.x86.avx512.mask.cvtpd2dq.128
-    x86_avx512_mask_cvtpd2dq_512,              // llvm.x86.avx512.mask.cvtpd2dq.512
-    x86_avx512_mask_cvtpd2ps,                  // llvm.x86.avx512.mask.cvtpd2ps
-    x86_avx512_mask_cvtpd2ps_512,              // llvm.x86.avx512.mask.cvtpd2ps.512
-    x86_avx512_mask_cvtpd2qq_128,              // llvm.x86.avx512.mask.cvtpd2qq.128
-    x86_avx512_mask_cvtpd2qq_256,              // llvm.x86.avx512.mask.cvtpd2qq.256
-    x86_avx512_mask_cvtpd2qq_512,              // llvm.x86.avx512.mask.cvtpd2qq.512
-    x86_avx512_mask_cvtpd2udq_128,             // llvm.x86.avx512.mask.cvtpd2udq.128
-    x86_avx512_mask_cvtpd2udq_256,             // llvm.x86.avx512.mask.cvtpd2udq.256
-    x86_avx512_mask_cvtpd2udq_512,             // llvm.x86.avx512.mask.cvtpd2udq.512
-    x86_avx512_mask_cvtpd2uqq_128,             // llvm.x86.avx512.mask.cvtpd2uqq.128
-    x86_avx512_mask_cvtpd2uqq_256,             // llvm.x86.avx512.mask.cvtpd2uqq.256
-    x86_avx512_mask_cvtpd2uqq_512,             // llvm.x86.avx512.mask.cvtpd2uqq.512
-    x86_avx512_mask_cvtps2dq_128,              // llvm.x86.avx512.mask.cvtps2dq.128
-    x86_avx512_mask_cvtps2dq_256,              // llvm.x86.avx512.mask.cvtps2dq.256
-    x86_avx512_mask_cvtps2dq_512,              // llvm.x86.avx512.mask.cvtps2dq.512
-    x86_avx512_mask_cvtps2pd_512,              // llvm.x86.avx512.mask.cvtps2pd.512
-    x86_avx512_mask_cvtps2qq_128,              // llvm.x86.avx512.mask.cvtps2qq.128
-    x86_avx512_mask_cvtps2qq_256,              // llvm.x86.avx512.mask.cvtps2qq.256
-    x86_avx512_mask_cvtps2qq_512,              // llvm.x86.avx512.mask.cvtps2qq.512
-    x86_avx512_mask_cvtps2udq_128,             // llvm.x86.avx512.mask.cvtps2udq.128
-    x86_avx512_mask_cvtps2udq_256,             // llvm.x86.avx512.mask.cvtps2udq.256
-    x86_avx512_mask_cvtps2udq_512,             // llvm.x86.avx512.mask.cvtps2udq.512
-    x86_avx512_mask_cvtps2uqq_128,             // llvm.x86.avx512.mask.cvtps2uqq.128
-    x86_avx512_mask_cvtps2uqq_256,             // llvm.x86.avx512.mask.cvtps2uqq.256
-    x86_avx512_mask_cvtps2uqq_512,             // llvm.x86.avx512.mask.cvtps2uqq.512
-    x86_avx512_mask_cvtqq2ps_128,              // llvm.x86.avx512.mask.cvtqq2ps.128
-    x86_avx512_mask_cvtsd2ss_round,            // llvm.x86.avx512.mask.cvtsd2ss.round
-    x86_avx512_mask_cvtss2sd_round,            // llvm.x86.avx512.mask.cvtss2sd.round
-    x86_avx512_mask_cvttpd2dq_128,             // llvm.x86.avx512.mask.cvttpd2dq.128
-    x86_avx512_mask_cvttpd2dq_512,             // llvm.x86.avx512.mask.cvttpd2dq.512
-    x86_avx512_mask_cvttpd2qq_128,             // llvm.x86.avx512.mask.cvttpd2qq.128
-    x86_avx512_mask_cvttpd2qq_256,             // llvm.x86.avx512.mask.cvttpd2qq.256
-    x86_avx512_mask_cvttpd2qq_512,             // llvm.x86.avx512.mask.cvttpd2qq.512
-    x86_avx512_mask_cvttpd2udq_128,            // llvm.x86.avx512.mask.cvttpd2udq.128
-    x86_avx512_mask_cvttpd2udq_256,            // llvm.x86.avx512.mask.cvttpd2udq.256
-    x86_avx512_mask_cvttpd2udq_512,            // llvm.x86.avx512.mask.cvttpd2udq.512
-    x86_avx512_mask_cvttpd2uqq_128,            // llvm.x86.avx512.mask.cvttpd2uqq.128
-    x86_avx512_mask_cvttpd2uqq_256,            // llvm.x86.avx512.mask.cvttpd2uqq.256
-    x86_avx512_mask_cvttpd2uqq_512,            // llvm.x86.avx512.mask.cvttpd2uqq.512
-    x86_avx512_mask_cvttps2dq_512,             // llvm.x86.avx512.mask.cvttps2dq.512
-    x86_avx512_mask_cvttps2qq_128,             // llvm.x86.avx512.mask.cvttps2qq.128
-    x86_avx512_mask_cvttps2qq_256,             // llvm.x86.avx512.mask.cvttps2qq.256
-    x86_avx512_mask_cvttps2qq_512,             // llvm.x86.avx512.mask.cvttps2qq.512
-    x86_avx512_mask_cvttps2udq_128,            // llvm.x86.avx512.mask.cvttps2udq.128
-    x86_avx512_mask_cvttps2udq_256,            // llvm.x86.avx512.mask.cvttps2udq.256
-    x86_avx512_mask_cvttps2udq_512,            // llvm.x86.avx512.mask.cvttps2udq.512
-    x86_avx512_mask_cvttps2uqq_128,            // llvm.x86.avx512.mask.cvttps2uqq.128
-    x86_avx512_mask_cvttps2uqq_256,            // llvm.x86.avx512.mask.cvttps2uqq.256
-    x86_avx512_mask_cvttps2uqq_512,            // llvm.x86.avx512.mask.cvttps2uqq.512
-    x86_avx512_mask_cvtuqq2ps_128,             // llvm.x86.avx512.mask.cvtuqq2ps.128
-    x86_avx512_mask_div_sd_round,              // llvm.x86.avx512.mask.div.sd.round
-    x86_avx512_mask_div_ss_round,              // llvm.x86.avx512.mask.div.ss.round
-    x86_avx512_mask_expand,                    // llvm.x86.avx512.mask.expand
-    x86_avx512_mask_fixupimm_pd_128,           // llvm.x86.avx512.mask.fixupimm.pd.128
-    x86_avx512_mask_fixupimm_pd_256,           // llvm.x86.avx512.mask.fixupimm.pd.256
-    x86_avx512_mask_fixupimm_pd_512,           // llvm.x86.avx512.mask.fixupimm.pd.512
-    x86_avx512_mask_fixupimm_ps_128,           // llvm.x86.avx512.mask.fixupimm.ps.128
-    x86_avx512_mask_fixupimm_ps_256,           // llvm.x86.avx512.mask.fixupimm.ps.256
-    x86_avx512_mask_fixupimm_ps_512,           // llvm.x86.avx512.mask.fixupimm.ps.512
-    x86_avx512_mask_fixupimm_sd,               // llvm.x86.avx512.mask.fixupimm.sd
-    x86_avx512_mask_fixupimm_ss,               // llvm.x86.avx512.mask.fixupimm.ss
-    x86_avx512_mask_fpclass_sd,                // llvm.x86.avx512.mask.fpclass.sd
-    x86_avx512_mask_fpclass_ss,                // llvm.x86.avx512.mask.fpclass.ss
-    x86_avx512_mask_gather_dpd_512,            // llvm.x86.avx512.mask.gather.dpd.512
-    x86_avx512_mask_gather_dpi_512,            // llvm.x86.avx512.mask.gather.dpi.512
-    x86_avx512_mask_gather_dpq_512,            // llvm.x86.avx512.mask.gather.dpq.512
-    x86_avx512_mask_gather_dps_512,            // llvm.x86.avx512.mask.gather.dps.512
-    x86_avx512_mask_gather_qpd_512,            // llvm.x86.avx512.mask.gather.qpd.512
-    x86_avx512_mask_gather_qpi_512,            // llvm.x86.avx512.mask.gather.qpi.512
-    x86_avx512_mask_gather_qpq_512,            // llvm.x86.avx512.mask.gather.qpq.512
-    x86_avx512_mask_gather_qps_512,            // llvm.x86.avx512.mask.gather.qps.512
-    x86_avx512_mask_gather3div2_df,            // llvm.x86.avx512.mask.gather3div2.df
-    x86_avx512_mask_gather3div2_di,            // llvm.x86.avx512.mask.gather3div2.di
-    x86_avx512_mask_gather3div4_df,            // llvm.x86.avx512.mask.gather3div4.df
-    x86_avx512_mask_gather3div4_di,            // llvm.x86.avx512.mask.gather3div4.di
-    x86_avx512_mask_gather3div4_sf,            // llvm.x86.avx512.mask.gather3div4.sf
-    x86_avx512_mask_gather3div4_si,            // llvm.x86.avx512.mask.gather3div4.si
-    x86_avx512_mask_gather3div8_sf,            // llvm.x86.avx512.mask.gather3div8.sf
-    x86_avx512_mask_gather3div8_si,            // llvm.x86.avx512.mask.gather3div8.si
-    x86_avx512_mask_gather3siv2_df,            // llvm.x86.avx512.mask.gather3siv2.df
-    x86_avx512_mask_gather3siv2_di,            // llvm.x86.avx512.mask.gather3siv2.di
-    x86_avx512_mask_gather3siv4_df,            // llvm.x86.avx512.mask.gather3siv4.df
-    x86_avx512_mask_gather3siv4_di,            // llvm.x86.avx512.mask.gather3siv4.di
-    x86_avx512_mask_gather3siv4_sf,            // llvm.x86.avx512.mask.gather3siv4.sf
-    x86_avx512_mask_gather3siv4_si,            // llvm.x86.avx512.mask.gather3siv4.si
-    x86_avx512_mask_gather3siv8_sf,            // llvm.x86.avx512.mask.gather3siv8.sf
-    x86_avx512_mask_gather3siv8_si,            // llvm.x86.avx512.mask.gather3siv8.si
-    x86_avx512_mask_getexp_pd_128,             // llvm.x86.avx512.mask.getexp.pd.128
-    x86_avx512_mask_getexp_pd_256,             // llvm.x86.avx512.mask.getexp.pd.256
-    x86_avx512_mask_getexp_pd_512,             // llvm.x86.avx512.mask.getexp.pd.512
-    x86_avx512_mask_getexp_ps_128,             // llvm.x86.avx512.mask.getexp.ps.128
-    x86_avx512_mask_getexp_ps_256,             // llvm.x86.avx512.mask.getexp.ps.256
-    x86_avx512_mask_getexp_ps_512,             // llvm.x86.avx512.mask.getexp.ps.512
-    x86_avx512_mask_getexp_sd,                 // llvm.x86.avx512.mask.getexp.sd
-    x86_avx512_mask_getexp_ss,                 // llvm.x86.avx512.mask.getexp.ss
-    x86_avx512_mask_getmant_pd_128,            // llvm.x86.avx512.mask.getmant.pd.128
-    x86_avx512_mask_getmant_pd_256,            // llvm.x86.avx512.mask.getmant.pd.256
-    x86_avx512_mask_getmant_pd_512,            // llvm.x86.avx512.mask.getmant.pd.512
-    x86_avx512_mask_getmant_ps_128,            // llvm.x86.avx512.mask.getmant.ps.128
-    x86_avx512_mask_getmant_ps_256,            // llvm.x86.avx512.mask.getmant.ps.256
-    x86_avx512_mask_getmant_ps_512,            // llvm.x86.avx512.mask.getmant.ps.512
-    x86_avx512_mask_getmant_sd,                // llvm.x86.avx512.mask.getmant.sd
-    x86_avx512_mask_getmant_ss,                // llvm.x86.avx512.mask.getmant.ss
-    x86_avx512_mask_max_sd_round,              // llvm.x86.avx512.mask.max.sd.round
-    x86_avx512_mask_max_ss_round,              // llvm.x86.avx512.mask.max.ss.round
-    x86_avx512_mask_min_sd_round,              // llvm.x86.avx512.mask.min.sd.round
-    x86_avx512_mask_min_ss_round,              // llvm.x86.avx512.mask.min.ss.round
-    x86_avx512_mask_mul_sd_round,              // llvm.x86.avx512.mask.mul.sd.round
-    x86_avx512_mask_mul_ss_round,              // llvm.x86.avx512.mask.mul.ss.round
-    x86_avx512_mask_pmov_db_128,               // llvm.x86.avx512.mask.pmov.db.128
-    x86_avx512_mask_pmov_db_256,               // llvm.x86.avx512.mask.pmov.db.256
-    x86_avx512_mask_pmov_db_512,               // llvm.x86.avx512.mask.pmov.db.512
-    x86_avx512_mask_pmov_db_mem_128,           // llvm.x86.avx512.mask.pmov.db.mem.128
-    x86_avx512_mask_pmov_db_mem_256,           // llvm.x86.avx512.mask.pmov.db.mem.256
-    x86_avx512_mask_pmov_db_mem_512,           // llvm.x86.avx512.mask.pmov.db.mem.512
-    x86_avx512_mask_pmov_dw_128,               // llvm.x86.avx512.mask.pmov.dw.128
-    x86_avx512_mask_pmov_dw_256,               // llvm.x86.avx512.mask.pmov.dw.256
-    x86_avx512_mask_pmov_dw_512,               // llvm.x86.avx512.mask.pmov.dw.512
-    x86_avx512_mask_pmov_dw_mem_128,           // llvm.x86.avx512.mask.pmov.dw.mem.128
-    x86_avx512_mask_pmov_dw_mem_256,           // llvm.x86.avx512.mask.pmov.dw.mem.256
-    x86_avx512_mask_pmov_dw_mem_512,           // llvm.x86.avx512.mask.pmov.dw.mem.512
-    x86_avx512_mask_pmov_qb_128,               // llvm.x86.avx512.mask.pmov.qb.128
-    x86_avx512_mask_pmov_qb_256,               // llvm.x86.avx512.mask.pmov.qb.256
-    x86_avx512_mask_pmov_qb_512,               // llvm.x86.avx512.mask.pmov.qb.512
-    x86_avx512_mask_pmov_qb_mem_128,           // llvm.x86.avx512.mask.pmov.qb.mem.128
-    x86_avx512_mask_pmov_qb_mem_256,           // llvm.x86.avx512.mask.pmov.qb.mem.256
-    x86_avx512_mask_pmov_qb_mem_512,           // llvm.x86.avx512.mask.pmov.qb.mem.512
-    x86_avx512_mask_pmov_qd_128,               // llvm.x86.avx512.mask.pmov.qd.128
-    x86_avx512_mask_pmov_qd_mem_128,           // llvm.x86.avx512.mask.pmov.qd.mem.128
-    x86_avx512_mask_pmov_qd_mem_256,           // llvm.x86.avx512.mask.pmov.qd.mem.256
-    x86_avx512_mask_pmov_qd_mem_512,           // llvm.x86.avx512.mask.pmov.qd.mem.512
-    x86_avx512_mask_pmov_qw_128,               // llvm.x86.avx512.mask.pmov.qw.128
-    x86_avx512_mask_pmov_qw_256,               // llvm.x86.avx512.mask.pmov.qw.256
-    x86_avx512_mask_pmov_qw_512,               // llvm.x86.avx512.mask.pmov.qw.512
-    x86_avx512_mask_pmov_qw_mem_128,           // llvm.x86.avx512.mask.pmov.qw.mem.128
-    x86_avx512_mask_pmov_qw_mem_256,           // llvm.x86.avx512.mask.pmov.qw.mem.256
-    x86_avx512_mask_pmov_qw_mem_512,           // llvm.x86.avx512.mask.pmov.qw.mem.512
-    x86_avx512_mask_pmov_wb_128,               // llvm.x86.avx512.mask.pmov.wb.128
-    x86_avx512_mask_pmov_wb_mem_128,           // llvm.x86.avx512.mask.pmov.wb.mem.128
-    x86_avx512_mask_pmov_wb_mem_256,           // llvm.x86.avx512.mask.pmov.wb.mem.256
-    x86_avx512_mask_pmov_wb_mem_512,           // llvm.x86.avx512.mask.pmov.wb.mem.512
-    x86_avx512_mask_pmovs_db_128,              // llvm.x86.avx512.mask.pmovs.db.128
-    x86_avx512_mask_pmovs_db_256,              // llvm.x86.avx512.mask.pmovs.db.256
-    x86_avx512_mask_pmovs_db_512,              // llvm.x86.avx512.mask.pmovs.db.512
-    x86_avx512_mask_pmovs_db_mem_128,          // llvm.x86.avx512.mask.pmovs.db.mem.128
-    x86_avx512_mask_pmovs_db_mem_256,          // llvm.x86.avx512.mask.pmovs.db.mem.256
-    x86_avx512_mask_pmovs_db_mem_512,          // llvm.x86.avx512.mask.pmovs.db.mem.512
-    x86_avx512_mask_pmovs_dw_128,              // llvm.x86.avx512.mask.pmovs.dw.128
-    x86_avx512_mask_pmovs_dw_256,              // llvm.x86.avx512.mask.pmovs.dw.256
-    x86_avx512_mask_pmovs_dw_512,              // llvm.x86.avx512.mask.pmovs.dw.512
-    x86_avx512_mask_pmovs_dw_mem_128,          // llvm.x86.avx512.mask.pmovs.dw.mem.128
-    x86_avx512_mask_pmovs_dw_mem_256,          // llvm.x86.avx512.mask.pmovs.dw.mem.256
-    x86_avx512_mask_pmovs_dw_mem_512,          // llvm.x86.avx512.mask.pmovs.dw.mem.512
-    x86_avx512_mask_pmovs_qb_128,              // llvm.x86.avx512.mask.pmovs.qb.128
-    x86_avx512_mask_pmovs_qb_256,              // llvm.x86.avx512.mask.pmovs.qb.256
-    x86_avx512_mask_pmovs_qb_512,              // llvm.x86.avx512.mask.pmovs.qb.512
-    x86_avx512_mask_pmovs_qb_mem_128,          // llvm.x86.avx512.mask.pmovs.qb.mem.128
-    x86_avx512_mask_pmovs_qb_mem_256,          // llvm.x86.avx512.mask.pmovs.qb.mem.256
-    x86_avx512_mask_pmovs_qb_mem_512,          // llvm.x86.avx512.mask.pmovs.qb.mem.512
-    x86_avx512_mask_pmovs_qd_128,              // llvm.x86.avx512.mask.pmovs.qd.128
-    x86_avx512_mask_pmovs_qd_256,              // llvm.x86.avx512.mask.pmovs.qd.256
-    x86_avx512_mask_pmovs_qd_512,              // llvm.x86.avx512.mask.pmovs.qd.512
-    x86_avx512_mask_pmovs_qd_mem_128,          // llvm.x86.avx512.mask.pmovs.qd.mem.128
-    x86_avx512_mask_pmovs_qd_mem_256,          // llvm.x86.avx512.mask.pmovs.qd.mem.256
-    x86_avx512_mask_pmovs_qd_mem_512,          // llvm.x86.avx512.mask.pmovs.qd.mem.512
-    x86_avx512_mask_pmovs_qw_128,              // llvm.x86.avx512.mask.pmovs.qw.128
-    x86_avx512_mask_pmovs_qw_256,              // llvm.x86.avx512.mask.pmovs.qw.256
-    x86_avx512_mask_pmovs_qw_512,              // llvm.x86.avx512.mask.pmovs.qw.512
-    x86_avx512_mask_pmovs_qw_mem_128,          // llvm.x86.avx512.mask.pmovs.qw.mem.128
-    x86_avx512_mask_pmovs_qw_mem_256,          // llvm.x86.avx512.mask.pmovs.qw.mem.256
-    x86_avx512_mask_pmovs_qw_mem_512,          // llvm.x86.avx512.mask.pmovs.qw.mem.512
-    x86_avx512_mask_pmovs_wb_128,              // llvm.x86.avx512.mask.pmovs.wb.128
-    x86_avx512_mask_pmovs_wb_256,              // llvm.x86.avx512.mask.pmovs.wb.256
-    x86_avx512_mask_pmovs_wb_512,              // llvm.x86.avx512.mask.pmovs.wb.512
-    x86_avx512_mask_pmovs_wb_mem_128,          // llvm.x86.avx512.mask.pmovs.wb.mem.128
-    x86_avx512_mask_pmovs_wb_mem_256,          // llvm.x86.avx512.mask.pmovs.wb.mem.256
-    x86_avx512_mask_pmovs_wb_mem_512,          // llvm.x86.avx512.mask.pmovs.wb.mem.512
-    x86_avx512_mask_pmovus_db_128,             // llvm.x86.avx512.mask.pmovus.db.128
-    x86_avx512_mask_pmovus_db_256,             // llvm.x86.avx512.mask.pmovus.db.256
-    x86_avx512_mask_pmovus_db_512,             // llvm.x86.avx512.mask.pmovus.db.512
-    x86_avx512_mask_pmovus_db_mem_128,         // llvm.x86.avx512.mask.pmovus.db.mem.128
-    x86_avx512_mask_pmovus_db_mem_256,         // llvm.x86.avx512.mask.pmovus.db.mem.256
-    x86_avx512_mask_pmovus_db_mem_512,         // llvm.x86.avx512.mask.pmovus.db.mem.512
-    x86_avx512_mask_pmovus_dw_128,             // llvm.x86.avx512.mask.pmovus.dw.128
-    x86_avx512_mask_pmovus_dw_256,             // llvm.x86.avx512.mask.pmovus.dw.256
-    x86_avx512_mask_pmovus_dw_512,             // llvm.x86.avx512.mask.pmovus.dw.512
-    x86_avx512_mask_pmovus_dw_mem_128,         // llvm.x86.avx512.mask.pmovus.dw.mem.128
-    x86_avx512_mask_pmovus_dw_mem_256,         // llvm.x86.avx512.mask.pmovus.dw.mem.256
-    x86_avx512_mask_pmovus_dw_mem_512,         // llvm.x86.avx512.mask.pmovus.dw.mem.512
-    x86_avx512_mask_pmovus_qb_128,             // llvm.x86.avx512.mask.pmovus.qb.128
-    x86_avx512_mask_pmovus_qb_256,             // llvm.x86.avx512.mask.pmovus.qb.256
-    x86_avx512_mask_pmovus_qb_512,             // llvm.x86.avx512.mask.pmovus.qb.512
-    x86_avx512_mask_pmovus_qb_mem_128,         // llvm.x86.avx512.mask.pmovus.qb.mem.128
-    x86_avx512_mask_pmovus_qb_mem_256,         // llvm.x86.avx512.mask.pmovus.qb.mem.256
-    x86_avx512_mask_pmovus_qb_mem_512,         // llvm.x86.avx512.mask.pmovus.qb.mem.512
-    x86_avx512_mask_pmovus_qd_128,             // llvm.x86.avx512.mask.pmovus.qd.128
-    x86_avx512_mask_pmovus_qd_256,             // llvm.x86.avx512.mask.pmovus.qd.256
-    x86_avx512_mask_pmovus_qd_512,             // llvm.x86.avx512.mask.pmovus.qd.512
-    x86_avx512_mask_pmovus_qd_mem_128,         // llvm.x86.avx512.mask.pmovus.qd.mem.128
-    x86_avx512_mask_pmovus_qd_mem_256,         // llvm.x86.avx512.mask.pmovus.qd.mem.256
-    x86_avx512_mask_pmovus_qd_mem_512,         // llvm.x86.avx512.mask.pmovus.qd.mem.512
-    x86_avx512_mask_pmovus_qw_128,             // llvm.x86.avx512.mask.pmovus.qw.128
-    x86_avx512_mask_pmovus_qw_256,             // llvm.x86.avx512.mask.pmovus.qw.256
-    x86_avx512_mask_pmovus_qw_512,             // llvm.x86.avx512.mask.pmovus.qw.512
-    x86_avx512_mask_pmovus_qw_mem_128,         // llvm.x86.avx512.mask.pmovus.qw.mem.128
-    x86_avx512_mask_pmovus_qw_mem_256,         // llvm.x86.avx512.mask.pmovus.qw.mem.256
-    x86_avx512_mask_pmovus_qw_mem_512,         // llvm.x86.avx512.mask.pmovus.qw.mem.512
-    x86_avx512_mask_pmovus_wb_128,             // llvm.x86.avx512.mask.pmovus.wb.128
-    x86_avx512_mask_pmovus_wb_256,             // llvm.x86.avx512.mask.pmovus.wb.256
-    x86_avx512_mask_pmovus_wb_512,             // llvm.x86.avx512.mask.pmovus.wb.512
-    x86_avx512_mask_pmovus_wb_mem_128,         // llvm.x86.avx512.mask.pmovus.wb.mem.128
-    x86_avx512_mask_pmovus_wb_mem_256,         // llvm.x86.avx512.mask.pmovus.wb.mem.256
-    x86_avx512_mask_pmovus_wb_mem_512,         // llvm.x86.avx512.mask.pmovus.wb.mem.512
-    x86_avx512_mask_range_pd_128,              // llvm.x86.avx512.mask.range.pd.128
-    x86_avx512_mask_range_pd_256,              // llvm.x86.avx512.mask.range.pd.256
-    x86_avx512_mask_range_pd_512,              // llvm.x86.avx512.mask.range.pd.512
-    x86_avx512_mask_range_ps_128,              // llvm.x86.avx512.mask.range.ps.128
-    x86_avx512_mask_range_ps_256,              // llvm.x86.avx512.mask.range.ps.256
-    x86_avx512_mask_range_ps_512,              // llvm.x86.avx512.mask.range.ps.512
-    x86_avx512_mask_range_sd,                  // llvm.x86.avx512.mask.range.sd
-    x86_avx512_mask_range_ss,                  // llvm.x86.avx512.mask.range.ss
-    x86_avx512_mask_reduce_pd_128,             // llvm.x86.avx512.mask.reduce.pd.128
-    x86_avx512_mask_reduce_pd_256,             // llvm.x86.avx512.mask.reduce.pd.256
-    x86_avx512_mask_reduce_pd_512,             // llvm.x86.avx512.mask.reduce.pd.512
-    x86_avx512_mask_reduce_ps_128,             // llvm.x86.avx512.mask.reduce.ps.128
-    x86_avx512_mask_reduce_ps_256,             // llvm.x86.avx512.mask.reduce.ps.256
-    x86_avx512_mask_reduce_ps_512,             // llvm.x86.avx512.mask.reduce.ps.512
-    x86_avx512_mask_reduce_sd,                 // llvm.x86.avx512.mask.reduce.sd
-    x86_avx512_mask_reduce_ss,                 // llvm.x86.avx512.mask.reduce.ss
-    x86_avx512_mask_rndscale_pd_128,           // llvm.x86.avx512.mask.rndscale.pd.128
-    x86_avx512_mask_rndscale_pd_256,           // llvm.x86.avx512.mask.rndscale.pd.256
-    x86_avx512_mask_rndscale_pd_512,           // llvm.x86.avx512.mask.rndscale.pd.512
-    x86_avx512_mask_rndscale_ps_128,           // llvm.x86.avx512.mask.rndscale.ps.128
-    x86_avx512_mask_rndscale_ps_256,           // llvm.x86.avx512.mask.rndscale.ps.256
-    x86_avx512_mask_rndscale_ps_512,           // llvm.x86.avx512.mask.rndscale.ps.512
-    x86_avx512_mask_rndscale_sd,               // llvm.x86.avx512.mask.rndscale.sd
-    x86_avx512_mask_rndscale_ss,               // llvm.x86.avx512.mask.rndscale.ss
-    x86_avx512_mask_scalef_pd_128,             // llvm.x86.avx512.mask.scalef.pd.128
-    x86_avx512_mask_scalef_pd_256,             // llvm.x86.avx512.mask.scalef.pd.256
-    x86_avx512_mask_scalef_pd_512,             // llvm.x86.avx512.mask.scalef.pd.512
-    x86_avx512_mask_scalef_ps_128,             // llvm.x86.avx512.mask.scalef.ps.128
-    x86_avx512_mask_scalef_ps_256,             // llvm.x86.avx512.mask.scalef.ps.256
-    x86_avx512_mask_scalef_ps_512,             // llvm.x86.avx512.mask.scalef.ps.512
-    x86_avx512_mask_scalef_sd,                 // llvm.x86.avx512.mask.scalef.sd
-    x86_avx512_mask_scalef_ss,                 // llvm.x86.avx512.mask.scalef.ss
-    x86_avx512_mask_scatter_dpd_512,           // llvm.x86.avx512.mask.scatter.dpd.512
-    x86_avx512_mask_scatter_dpi_512,           // llvm.x86.avx512.mask.scatter.dpi.512
-    x86_avx512_mask_scatter_dpq_512,           // llvm.x86.avx512.mask.scatter.dpq.512
-    x86_avx512_mask_scatter_dps_512,           // llvm.x86.avx512.mask.scatter.dps.512
-    x86_avx512_mask_scatter_qpd_512,           // llvm.x86.avx512.mask.scatter.qpd.512
-    x86_avx512_mask_scatter_qpi_512,           // llvm.x86.avx512.mask.scatter.qpi.512
-    x86_avx512_mask_scatter_qpq_512,           // llvm.x86.avx512.mask.scatter.qpq.512
-    x86_avx512_mask_scatter_qps_512,           // llvm.x86.avx512.mask.scatter.qps.512
-    x86_avx512_mask_scatterdiv2_df,            // llvm.x86.avx512.mask.scatterdiv2.df
-    x86_avx512_mask_scatterdiv2_di,            // llvm.x86.avx512.mask.scatterdiv2.di
-    x86_avx512_mask_scatterdiv4_df,            // llvm.x86.avx512.mask.scatterdiv4.df
-    x86_avx512_mask_scatterdiv4_di,            // llvm.x86.avx512.mask.scatterdiv4.di
-    x86_avx512_mask_scatterdiv4_sf,            // llvm.x86.avx512.mask.scatterdiv4.sf
-    x86_avx512_mask_scatterdiv4_si,            // llvm.x86.avx512.mask.scatterdiv4.si
-    x86_avx512_mask_scatterdiv8_sf,            // llvm.x86.avx512.mask.scatterdiv8.sf
-    x86_avx512_mask_scatterdiv8_si,            // llvm.x86.avx512.mask.scatterdiv8.si
-    x86_avx512_mask_scattersiv2_df,            // llvm.x86.avx512.mask.scattersiv2.df
-    x86_avx512_mask_scattersiv2_di,            // llvm.x86.avx512.mask.scattersiv2.di
-    x86_avx512_mask_scattersiv4_df,            // llvm.x86.avx512.mask.scattersiv4.df
-    x86_avx512_mask_scattersiv4_di,            // llvm.x86.avx512.mask.scattersiv4.di
-    x86_avx512_mask_scattersiv4_sf,            // llvm.x86.avx512.mask.scattersiv4.sf
-    x86_avx512_mask_scattersiv4_si,            // llvm.x86.avx512.mask.scattersiv4.si
-    x86_avx512_mask_scattersiv8_sf,            // llvm.x86.avx512.mask.scattersiv8.sf
-    x86_avx512_mask_scattersiv8_si,            // llvm.x86.avx512.mask.scattersiv8.si
-    x86_avx512_mask_sqrt_sd,                   // llvm.x86.avx512.mask.sqrt.sd
-    x86_avx512_mask_sqrt_ss,                   // llvm.x86.avx512.mask.sqrt.ss
-    x86_avx512_mask_sub_sd_round,              // llvm.x86.avx512.mask.sub.sd.round
-    x86_avx512_mask_sub_ss_round,              // llvm.x86.avx512.mask.sub.ss.round
-    x86_avx512_mask_vcvtph2ps_128,             // llvm.x86.avx512.mask.vcvtph2ps.128
-    x86_avx512_mask_vcvtph2ps_256,             // llvm.x86.avx512.mask.vcvtph2ps.256
-    x86_avx512_mask_vcvtph2ps_512,             // llvm.x86.avx512.mask.vcvtph2ps.512
-    x86_avx512_mask_vcvtps2ph_128,             // llvm.x86.avx512.mask.vcvtps2ph.128
-    x86_avx512_mask_vcvtps2ph_256,             // llvm.x86.avx512.mask.vcvtps2ph.256
-    x86_avx512_mask_vcvtps2ph_512,             // llvm.x86.avx512.mask.vcvtps2ph.512
-    x86_avx512_maskz_fixupimm_pd_128,          // llvm.x86.avx512.maskz.fixupimm.pd.128
-    x86_avx512_maskz_fixupimm_pd_256,          // llvm.x86.avx512.maskz.fixupimm.pd.256
-    x86_avx512_maskz_fixupimm_pd_512,          // llvm.x86.avx512.maskz.fixupimm.pd.512
-    x86_avx512_maskz_fixupimm_ps_128,          // llvm.x86.avx512.maskz.fixupimm.ps.128
-    x86_avx512_maskz_fixupimm_ps_256,          // llvm.x86.avx512.maskz.fixupimm.ps.256
-    x86_avx512_maskz_fixupimm_ps_512,          // llvm.x86.avx512.maskz.fixupimm.ps.512
-    x86_avx512_maskz_fixupimm_sd,              // llvm.x86.avx512.maskz.fixupimm.sd
-    x86_avx512_maskz_fixupimm_ss,              // llvm.x86.avx512.maskz.fixupimm.ss
-    x86_avx512_max_pd_512,                     // llvm.x86.avx512.max.pd.512
-    x86_avx512_max_ps_512,                     // llvm.x86.avx512.max.ps.512
-    x86_avx512_min_pd_512,                     // llvm.x86.avx512.min.pd.512
-    x86_avx512_min_ps_512,                     // llvm.x86.avx512.min.ps.512
-    x86_avx512_mul_pd_512,                     // llvm.x86.avx512.mul.pd.512
-    x86_avx512_mul_ps_512,                     // llvm.x86.avx512.mul.ps.512
-    x86_avx512_packssdw_512,                   // llvm.x86.avx512.packssdw.512
-    x86_avx512_packsswb_512,                   // llvm.x86.avx512.packsswb.512
-    x86_avx512_packusdw_512,                   // llvm.x86.avx512.packusdw.512
-    x86_avx512_packuswb_512,                   // llvm.x86.avx512.packuswb.512
-    x86_avx512_pavg_b_512,                     // llvm.x86.avx512.pavg.b.512
-    x86_avx512_pavg_w_512,                     // llvm.x86.avx512.pavg.w.512
-    x86_avx512_permvar_df_256,                 // llvm.x86.avx512.permvar.df.256
-    x86_avx512_permvar_df_512,                 // llvm.x86.avx512.permvar.df.512
-    x86_avx512_permvar_di_256,                 // llvm.x86.avx512.permvar.di.256
-    x86_avx512_permvar_di_512,                 // llvm.x86.avx512.permvar.di.512
-    x86_avx512_permvar_hi_128,                 // llvm.x86.avx512.permvar.hi.128
-    x86_avx512_permvar_hi_256,                 // llvm.x86.avx512.permvar.hi.256
-    x86_avx512_permvar_hi_512,                 // llvm.x86.avx512.permvar.hi.512
-    x86_avx512_permvar_qi_128,                 // llvm.x86.avx512.permvar.qi.128
-    x86_avx512_permvar_qi_256,                 // llvm.x86.avx512.permvar.qi.256
-    x86_avx512_permvar_qi_512,                 // llvm.x86.avx512.permvar.qi.512
-    x86_avx512_permvar_sf_512,                 // llvm.x86.avx512.permvar.sf.512
-    x86_avx512_permvar_si_512,                 // llvm.x86.avx512.permvar.si.512
-    x86_avx512_pmaddubs_w_512,                 // llvm.x86.avx512.pmaddubs.w.512
-    x86_avx512_pmaddw_d_512,                   // llvm.x86.avx512.pmaddw.d.512
-    x86_avx512_pmul_hr_sw_512,                 // llvm.x86.avx512.pmul.hr.sw.512
-    x86_avx512_pmulh_w_512,                    // llvm.x86.avx512.pmulh.w.512
-    x86_avx512_pmulhu_w_512,                   // llvm.x86.avx512.pmulhu.w.512
-    x86_avx512_pmultishift_qb_128,             // llvm.x86.avx512.pmultishift.qb.128
-    x86_avx512_pmultishift_qb_256,             // llvm.x86.avx512.pmultishift.qb.256
-    x86_avx512_pmultishift_qb_512,             // llvm.x86.avx512.pmultishift.qb.512
-    x86_avx512_psad_bw_512,                    // llvm.x86.avx512.psad.bw.512
-    x86_avx512_pshuf_b_512,                    // llvm.x86.avx512.pshuf.b.512
-    x86_avx512_psll_d_512,                     // llvm.x86.avx512.psll.d.512
-    x86_avx512_psll_q_512,                     // llvm.x86.avx512.psll.q.512
-    x86_avx512_psll_w_512,                     // llvm.x86.avx512.psll.w.512
-    x86_avx512_pslli_d_512,                    // llvm.x86.avx512.pslli.d.512
-    x86_avx512_pslli_q_512,                    // llvm.x86.avx512.pslli.q.512
-    x86_avx512_pslli_w_512,                    // llvm.x86.avx512.pslli.w.512
-    x86_avx512_psllv_d_512,                    // llvm.x86.avx512.psllv.d.512
-    x86_avx512_psllv_q_512,                    // llvm.x86.avx512.psllv.q.512
-    x86_avx512_psllv_w_128,                    // llvm.x86.avx512.psllv.w.128
-    x86_avx512_psllv_w_256,                    // llvm.x86.avx512.psllv.w.256
-    x86_avx512_psllv_w_512,                    // llvm.x86.avx512.psllv.w.512
-    x86_avx512_psra_d_512,                     // llvm.x86.avx512.psra.d.512
-    x86_avx512_psra_q_128,                     // llvm.x86.avx512.psra.q.128
-    x86_avx512_psra_q_256,                     // llvm.x86.avx512.psra.q.256
-    x86_avx512_psra_q_512,                     // llvm.x86.avx512.psra.q.512
-    x86_avx512_psra_w_512,                     // llvm.x86.avx512.psra.w.512
-    x86_avx512_psrai_d_512,                    // llvm.x86.avx512.psrai.d.512
-    x86_avx512_psrai_q_128,                    // llvm.x86.avx512.psrai.q.128
-    x86_avx512_psrai_q_256,                    // llvm.x86.avx512.psrai.q.256
-    x86_avx512_psrai_q_512,                    // llvm.x86.avx512.psrai.q.512
-    x86_avx512_psrai_w_512,                    // llvm.x86.avx512.psrai.w.512
-    x86_avx512_psrav_d_512,                    // llvm.x86.avx512.psrav.d.512
-    x86_avx512_psrav_q_128,                    // llvm.x86.avx512.psrav.q.128
-    x86_avx512_psrav_q_256,                    // llvm.x86.avx512.psrav.q.256
-    x86_avx512_psrav_q_512,                    // llvm.x86.avx512.psrav.q.512
-    x86_avx512_psrav_w_128,                    // llvm.x86.avx512.psrav.w.128
-    x86_avx512_psrav_w_256,                    // llvm.x86.avx512.psrav.w.256
-    x86_avx512_psrav_w_512,                    // llvm.x86.avx512.psrav.w.512
-    x86_avx512_psrl_d_512,                     // llvm.x86.avx512.psrl.d.512
-    x86_avx512_psrl_q_512,                     // llvm.x86.avx512.psrl.q.512
-    x86_avx512_psrl_w_512,                     // llvm.x86.avx512.psrl.w.512
-    x86_avx512_psrli_d_512,                    // llvm.x86.avx512.psrli.d.512
-    x86_avx512_psrli_q_512,                    // llvm.x86.avx512.psrli.q.512
-    x86_avx512_psrli_w_512,                    // llvm.x86.avx512.psrli.w.512
-    x86_avx512_psrlv_d_512,                    // llvm.x86.avx512.psrlv.d.512
-    x86_avx512_psrlv_q_512,                    // llvm.x86.avx512.psrlv.q.512
-    x86_avx512_psrlv_w_128,                    // llvm.x86.avx512.psrlv.w.128
-    x86_avx512_psrlv_w_256,                    // llvm.x86.avx512.psrlv.w.256
-    x86_avx512_psrlv_w_512,                    // llvm.x86.avx512.psrlv.w.512
-    x86_avx512_pternlog_d_128,                 // llvm.x86.avx512.pternlog.d.128
-    x86_avx512_pternlog_d_256,                 // llvm.x86.avx512.pternlog.d.256
-    x86_avx512_pternlog_d_512,                 // llvm.x86.avx512.pternlog.d.512
-    x86_avx512_pternlog_q_128,                 // llvm.x86.avx512.pternlog.q.128
-    x86_avx512_pternlog_q_256,                 // llvm.x86.avx512.pternlog.q.256
-    x86_avx512_pternlog_q_512,                 // llvm.x86.avx512.pternlog.q.512
-    x86_avx512_rcp14_pd_128,                   // llvm.x86.avx512.rcp14.pd.128
-    x86_avx512_rcp14_pd_256,                   // llvm.x86.avx512.rcp14.pd.256
-    x86_avx512_rcp14_pd_512,                   // llvm.x86.avx512.rcp14.pd.512
-    x86_avx512_rcp14_ps_128,                   // llvm.x86.avx512.rcp14.ps.128
-    x86_avx512_rcp14_ps_256,                   // llvm.x86.avx512.rcp14.ps.256
-    x86_avx512_rcp14_ps_512,                   // llvm.x86.avx512.rcp14.ps.512
-    x86_avx512_rcp14_sd,                       // llvm.x86.avx512.rcp14.sd
-    x86_avx512_rcp14_ss,                       // llvm.x86.avx512.rcp14.ss
-    x86_avx512_rcp28_pd,                       // llvm.x86.avx512.rcp28.pd
-    x86_avx512_rcp28_ps,                       // llvm.x86.avx512.rcp28.ps
-    x86_avx512_rcp28_sd,                       // llvm.x86.avx512.rcp28.sd
-    x86_avx512_rcp28_ss,                       // llvm.x86.avx512.rcp28.ss
-    x86_avx512_rsqrt14_pd_128,                 // llvm.x86.avx512.rsqrt14.pd.128
-    x86_avx512_rsqrt14_pd_256,                 // llvm.x86.avx512.rsqrt14.pd.256
-    x86_avx512_rsqrt14_pd_512,                 // llvm.x86.avx512.rsqrt14.pd.512
-    x86_avx512_rsqrt14_ps_128,                 // llvm.x86.avx512.rsqrt14.ps.128
-    x86_avx512_rsqrt14_ps_256,                 // llvm.x86.avx512.rsqrt14.ps.256
-    x86_avx512_rsqrt14_ps_512,                 // llvm.x86.avx512.rsqrt14.ps.512
-    x86_avx512_rsqrt14_sd,                     // llvm.x86.avx512.rsqrt14.sd
-    x86_avx512_rsqrt14_ss,                     // llvm.x86.avx512.rsqrt14.ss
-    x86_avx512_rsqrt28_pd,                     // llvm.x86.avx512.rsqrt28.pd
-    x86_avx512_rsqrt28_ps,                     // llvm.x86.avx512.rsqrt28.ps
-    x86_avx512_rsqrt28_sd,                     // llvm.x86.avx512.rsqrt28.sd
-    x86_avx512_rsqrt28_ss,                     // llvm.x86.avx512.rsqrt28.ss
-    x86_avx512_scatter_dpd_512,                // llvm.x86.avx512.scatter.dpd.512
-    x86_avx512_scatter_dpi_512,                // llvm.x86.avx512.scatter.dpi.512
-    x86_avx512_scatter_dpq_512,                // llvm.x86.avx512.scatter.dpq.512
-    x86_avx512_scatter_dps_512,                // llvm.x86.avx512.scatter.dps.512
-    x86_avx512_scatter_qpd_512,                // llvm.x86.avx512.scatter.qpd.512
-    x86_avx512_scatter_qpi_512,                // llvm.x86.avx512.scatter.qpi.512
-    x86_avx512_scatter_qpq_512,                // llvm.x86.avx512.scatter.qpq.512
-    x86_avx512_scatter_qps_512,                // llvm.x86.avx512.scatter.qps.512
-    x86_avx512_scatterdiv2_df,                 // llvm.x86.avx512.scatterdiv2.df
-    x86_avx512_scatterdiv2_di,                 // llvm.x86.avx512.scatterdiv2.di
-    x86_avx512_scatterdiv4_df,                 // llvm.x86.avx512.scatterdiv4.df
-    x86_avx512_scatterdiv4_di,                 // llvm.x86.avx512.scatterdiv4.di
-    x86_avx512_scatterdiv4_sf,                 // llvm.x86.avx512.scatterdiv4.sf
-    x86_avx512_scatterdiv4_si,                 // llvm.x86.avx512.scatterdiv4.si
-    x86_avx512_scatterdiv8_sf,                 // llvm.x86.avx512.scatterdiv8.sf
-    x86_avx512_scatterdiv8_si,                 // llvm.x86.avx512.scatterdiv8.si
-    x86_avx512_scatterpf_dpd_512,              // llvm.x86.avx512.scatterpf.dpd.512
-    x86_avx512_scatterpf_dps_512,              // llvm.x86.avx512.scatterpf.dps.512
-    x86_avx512_scatterpf_qpd_512,              // llvm.x86.avx512.scatterpf.qpd.512
-    x86_avx512_scatterpf_qps_512,              // llvm.x86.avx512.scatterpf.qps.512
-    x86_avx512_scattersiv2_df,                 // llvm.x86.avx512.scattersiv2.df
-    x86_avx512_scattersiv2_di,                 // llvm.x86.avx512.scattersiv2.di
-    x86_avx512_scattersiv4_df,                 // llvm.x86.avx512.scattersiv4.df
-    x86_avx512_scattersiv4_di,                 // llvm.x86.avx512.scattersiv4.di
-    x86_avx512_scattersiv4_sf,                 // llvm.x86.avx512.scattersiv4.sf
-    x86_avx512_scattersiv4_si,                 // llvm.x86.avx512.scattersiv4.si
-    x86_avx512_scattersiv8_sf,                 // llvm.x86.avx512.scattersiv8.sf
-    x86_avx512_scattersiv8_si,                 // llvm.x86.avx512.scattersiv8.si
-    x86_avx512_sitofp_round,                   // llvm.x86.avx512.sitofp.round
-    x86_avx512_sqrt_pd_512,                    // llvm.x86.avx512.sqrt.pd.512
-    x86_avx512_sqrt_ps_512,                    // llvm.x86.avx512.sqrt.ps.512
-    x86_avx512_sub_pd_512,                     // llvm.x86.avx512.sub.pd.512
-    x86_avx512_sub_ps_512,                     // llvm.x86.avx512.sub.ps.512
-    x86_avx512_uitofp_round,                   // llvm.x86.avx512.uitofp.round
-    x86_avx512_vcomi_sd,                       // llvm.x86.avx512.vcomi.sd
-    x86_avx512_vcomi_ss,                       // llvm.x86.avx512.vcomi.ss
-    x86_avx512_vcvtsd2si32,                    // llvm.x86.avx512.vcvtsd2si32
-    x86_avx512_vcvtsd2si64,                    // llvm.x86.avx512.vcvtsd2si64
-    x86_avx512_vcvtsd2usi32,                   // llvm.x86.avx512.vcvtsd2usi32
-    x86_avx512_vcvtsd2usi64,                   // llvm.x86.avx512.vcvtsd2usi64
-    x86_avx512_vcvtss2si32,                    // llvm.x86.avx512.vcvtss2si32
-    x86_avx512_vcvtss2si64,                    // llvm.x86.avx512.vcvtss2si64
-    x86_avx512_vcvtss2usi32,                   // llvm.x86.avx512.vcvtss2usi32
-    x86_avx512_vcvtss2usi64,                   // llvm.x86.avx512.vcvtss2usi64
-    x86_avx512_vfmadd_f32,                     // llvm.x86.avx512.vfmadd.f32
-    x86_avx512_vfmadd_f64,                     // llvm.x86.avx512.vfmadd.f64
-    x86_avx512_vfmadd_pd_512,                  // llvm.x86.avx512.vfmadd.pd.512
-    x86_avx512_vfmadd_ps_512,                  // llvm.x86.avx512.vfmadd.ps.512
-    x86_avx512_vfmaddsub_pd_512,               // llvm.x86.avx512.vfmaddsub.pd.512
-    x86_avx512_vfmaddsub_ps_512,               // llvm.x86.avx512.vfmaddsub.ps.512
-    x86_avx512_vp2intersect_d_128,             // llvm.x86.avx512.vp2intersect.d.128
-    x86_avx512_vp2intersect_d_256,             // llvm.x86.avx512.vp2intersect.d.256
-    x86_avx512_vp2intersect_d_512,             // llvm.x86.avx512.vp2intersect.d.512
-    x86_avx512_vp2intersect_q_128,             // llvm.x86.avx512.vp2intersect.q.128
-    x86_avx512_vp2intersect_q_256,             // llvm.x86.avx512.vp2intersect.q.256
-    x86_avx512_vp2intersect_q_512,             // llvm.x86.avx512.vp2intersect.q.512
-    x86_avx512_vpdpbusd_128,                   // llvm.x86.avx512.vpdpbusd.128
-    x86_avx512_vpdpbusd_256,                   // llvm.x86.avx512.vpdpbusd.256
-    x86_avx512_vpdpbusd_512,                   // llvm.x86.avx512.vpdpbusd.512
-    x86_avx512_vpdpbusds_128,                  // llvm.x86.avx512.vpdpbusds.128
-    x86_avx512_vpdpbusds_256,                  // llvm.x86.avx512.vpdpbusds.256
-    x86_avx512_vpdpbusds_512,                  // llvm.x86.avx512.vpdpbusds.512
-    x86_avx512_vpdpwssd_128,                   // llvm.x86.avx512.vpdpwssd.128
-    x86_avx512_vpdpwssd_256,                   // llvm.x86.avx512.vpdpwssd.256
-    x86_avx512_vpdpwssd_512,                   // llvm.x86.avx512.vpdpwssd.512
-    x86_avx512_vpdpwssds_128,                  // llvm.x86.avx512.vpdpwssds.128
-    x86_avx512_vpdpwssds_256,                  // llvm.x86.avx512.vpdpwssds.256
-    x86_avx512_vpdpwssds_512,                  // llvm.x86.avx512.vpdpwssds.512
-    x86_avx512_vpermi2var_d_128,               // llvm.x86.avx512.vpermi2var.d.128
-    x86_avx512_vpermi2var_d_256,               // llvm.x86.avx512.vpermi2var.d.256
-    x86_avx512_vpermi2var_d_512,               // llvm.x86.avx512.vpermi2var.d.512
-    x86_avx512_vpermi2var_hi_128,              // llvm.x86.avx512.vpermi2var.hi.128
-    x86_avx512_vpermi2var_hi_256,              // llvm.x86.avx512.vpermi2var.hi.256
-    x86_avx512_vpermi2var_hi_512,              // llvm.x86.avx512.vpermi2var.hi.512
-    x86_avx512_vpermi2var_pd_128,              // llvm.x86.avx512.vpermi2var.pd.128
-    x86_avx512_vpermi2var_pd_256,              // llvm.x86.avx512.vpermi2var.pd.256
-    x86_avx512_vpermi2var_pd_512,              // llvm.x86.avx512.vpermi2var.pd.512
-    x86_avx512_vpermi2var_ps_128,              // llvm.x86.avx512.vpermi2var.ps.128
-    x86_avx512_vpermi2var_ps_256,              // llvm.x86.avx512.vpermi2var.ps.256
-    x86_avx512_vpermi2var_ps_512,              // llvm.x86.avx512.vpermi2var.ps.512
-    x86_avx512_vpermi2var_q_128,               // llvm.x86.avx512.vpermi2var.q.128
-    x86_avx512_vpermi2var_q_256,               // llvm.x86.avx512.vpermi2var.q.256
-    x86_avx512_vpermi2var_q_512,               // llvm.x86.avx512.vpermi2var.q.512
-    x86_avx512_vpermi2var_qi_128,              // llvm.x86.avx512.vpermi2var.qi.128
-    x86_avx512_vpermi2var_qi_256,              // llvm.x86.avx512.vpermi2var.qi.256
-    x86_avx512_vpermi2var_qi_512,              // llvm.x86.avx512.vpermi2var.qi.512
-    x86_avx512_vpermilvar_pd_512,              // llvm.x86.avx512.vpermilvar.pd.512
-    x86_avx512_vpermilvar_ps_512,              // llvm.x86.avx512.vpermilvar.ps.512
-    x86_avx512_vpmadd52h_uq_128,               // llvm.x86.avx512.vpmadd52h.uq.128
-    x86_avx512_vpmadd52h_uq_256,               // llvm.x86.avx512.vpmadd52h.uq.256
-    x86_avx512_vpmadd52h_uq_512,               // llvm.x86.avx512.vpmadd52h.uq.512
-    x86_avx512_vpmadd52l_uq_128,               // llvm.x86.avx512.vpmadd52l.uq.128
-    x86_avx512_vpmadd52l_uq_256,               // llvm.x86.avx512.vpmadd52l.uq.256
-    x86_avx512_vpmadd52l_uq_512,               // llvm.x86.avx512.vpmadd52l.uq.512
-    x86_avx512_vpshufbitqmb_128,               // llvm.x86.avx512.vpshufbitqmb.128
-    x86_avx512_vpshufbitqmb_256,               // llvm.x86.avx512.vpshufbitqmb.256
-    x86_avx512_vpshufbitqmb_512,               // llvm.x86.avx512.vpshufbitqmb.512
-    x86_avx512bf16_cvtne2ps2bf16_128,          // llvm.x86.avx512bf16.cvtne2ps2bf16.128
-    x86_avx512bf16_cvtne2ps2bf16_256,          // llvm.x86.avx512bf16.cvtne2ps2bf16.256
-    x86_avx512bf16_cvtne2ps2bf16_512,          // llvm.x86.avx512bf16.cvtne2ps2bf16.512
-    x86_avx512bf16_cvtneps2bf16_256,           // llvm.x86.avx512bf16.cvtneps2bf16.256
-    x86_avx512bf16_cvtneps2bf16_512,           // llvm.x86.avx512bf16.cvtneps2bf16.512
-    x86_avx512bf16_dpbf16ps_128,               // llvm.x86.avx512bf16.dpbf16ps.128
-    x86_avx512bf16_dpbf16ps_256,               // llvm.x86.avx512bf16.dpbf16ps.256
-    x86_avx512bf16_dpbf16ps_512,               // llvm.x86.avx512bf16.dpbf16ps.512
-    x86_avx512bf16_mask_cvtneps2bf16_128,      // llvm.x86.avx512bf16.mask.cvtneps2bf16.128
-    x86_bmi_bextr_32,                          // llvm.x86.bmi.bextr.32
-    x86_bmi_bextr_64,                          // llvm.x86.bmi.bextr.64
-    x86_bmi_bzhi_32,                           // llvm.x86.bmi.bzhi.32
-    x86_bmi_bzhi_64,                           // llvm.x86.bmi.bzhi.64
-    x86_bmi_pdep_32,                           // llvm.x86.bmi.pdep.32
-    x86_bmi_pdep_64,                           // llvm.x86.bmi.pdep.64
-    x86_bmi_pext_32,                           // llvm.x86.bmi.pext.32
-    x86_bmi_pext_64,                           // llvm.x86.bmi.pext.64
-    x86_cldemote,                              // llvm.x86.cldemote
-    x86_clflushopt,                            // llvm.x86.clflushopt
-    x86_clrssbsy,                              // llvm.x86.clrssbsy
-    x86_clwb,                                  // llvm.x86.clwb
-    x86_clzero,                                // llvm.x86.clzero
-    x86_directstore32,                         // llvm.x86.directstore32
-    x86_directstore64,                         // llvm.x86.directstore64
-    x86_enqcmd,                                // llvm.x86.enqcmd
-    x86_enqcmds,                               // llvm.x86.enqcmds
-    x86_flags_read_u32,                        // llvm.x86.flags.read.u32
-    x86_flags_read_u64,                        // llvm.x86.flags.read.u64
-    x86_flags_write_u32,                       // llvm.x86.flags.write.u32
-    x86_flags_write_u64,                       // llvm.x86.flags.write.u64
-    x86_fxrstor,                               // llvm.x86.fxrstor
-    x86_fxrstor64,                             // llvm.x86.fxrstor64
-    x86_fxsave,                                // llvm.x86.fxsave
-    x86_fxsave64,                              // llvm.x86.fxsave64
-    x86_incsspd,                               // llvm.x86.incsspd
-    x86_incsspq,                               // llvm.x86.incsspq
-    x86_int,                                   // llvm.x86.int
-    x86_invpcid,                               // llvm.x86.invpcid
-    x86_llwpcb,                                // llvm.x86.llwpcb
-    x86_lwpins32,                              // llvm.x86.lwpins32
-    x86_lwpins64,                              // llvm.x86.lwpins64
-    x86_lwpval32,                              // llvm.x86.lwpval32
-    x86_lwpval64,                              // llvm.x86.lwpval64
-    x86_mmx_emms,                              // llvm.x86.mmx.emms
-    x86_mmx_femms,                             // llvm.x86.mmx.femms
-    x86_mmx_maskmovq,                          // llvm.x86.mmx.maskmovq
-    x86_mmx_movnt_dq,                          // llvm.x86.mmx.movnt.dq
-    x86_mmx_packssdw,                          // llvm.x86.mmx.packssdw
-    x86_mmx_packsswb,                          // llvm.x86.mmx.packsswb
-    x86_mmx_packuswb,                          // llvm.x86.mmx.packuswb
-    x86_mmx_padd_b,                            // llvm.x86.mmx.padd.b
-    x86_mmx_padd_d,                            // llvm.x86.mmx.padd.d
-    x86_mmx_padd_q,                            // llvm.x86.mmx.padd.q
-    x86_mmx_padd_w,                            // llvm.x86.mmx.padd.w
-    x86_mmx_padds_b,                           // llvm.x86.mmx.padds.b
-    x86_mmx_padds_w,                           // llvm.x86.mmx.padds.w
-    x86_mmx_paddus_b,                          // llvm.x86.mmx.paddus.b
-    x86_mmx_paddus_w,                          // llvm.x86.mmx.paddus.w
-    x86_mmx_palignr_b,                         // llvm.x86.mmx.palignr.b
-    x86_mmx_pand,                              // llvm.x86.mmx.pand
-    x86_mmx_pandn,                             // llvm.x86.mmx.pandn
-    x86_mmx_pavg_b,                            // llvm.x86.mmx.pavg.b
-    x86_mmx_pavg_w,                            // llvm.x86.mmx.pavg.w
-    x86_mmx_pcmpeq_b,                          // llvm.x86.mmx.pcmpeq.b
-    x86_mmx_pcmpeq_d,                          // llvm.x86.mmx.pcmpeq.d
-    x86_mmx_pcmpeq_w,                          // llvm.x86.mmx.pcmpeq.w
-    x86_mmx_pcmpgt_b,                          // llvm.x86.mmx.pcmpgt.b
-    x86_mmx_pcmpgt_d,                          // llvm.x86.mmx.pcmpgt.d
-    x86_mmx_pcmpgt_w,                          // llvm.x86.mmx.pcmpgt.w
-    x86_mmx_pextr_w,                           // llvm.x86.mmx.pextr.w
-    x86_mmx_pinsr_w,                           // llvm.x86.mmx.pinsr.w
-    x86_mmx_pmadd_wd,                          // llvm.x86.mmx.pmadd.wd
-    x86_mmx_pmaxs_w,                           // llvm.x86.mmx.pmaxs.w
-    x86_mmx_pmaxu_b,                           // llvm.x86.mmx.pmaxu.b
-    x86_mmx_pmins_w,                           // llvm.x86.mmx.pmins.w
-    x86_mmx_pminu_b,                           // llvm.x86.mmx.pminu.b
-    x86_mmx_pmovmskb,                          // llvm.x86.mmx.pmovmskb
-    x86_mmx_pmulh_w,                           // llvm.x86.mmx.pmulh.w
-    x86_mmx_pmulhu_w,                          // llvm.x86.mmx.pmulhu.w
-    x86_mmx_pmull_w,                           // llvm.x86.mmx.pmull.w
-    x86_mmx_pmulu_dq,                          // llvm.x86.mmx.pmulu.dq
-    x86_mmx_por,                               // llvm.x86.mmx.por
-    x86_mmx_psad_bw,                           // llvm.x86.mmx.psad.bw
-    x86_mmx_psll_d,                            // llvm.x86.mmx.psll.d
-    x86_mmx_psll_q,                            // llvm.x86.mmx.psll.q
-    x86_mmx_psll_w,                            // llvm.x86.mmx.psll.w
-    x86_mmx_pslli_d,                           // llvm.x86.mmx.pslli.d
-    x86_mmx_pslli_q,                           // llvm.x86.mmx.pslli.q
-    x86_mmx_pslli_w,                           // llvm.x86.mmx.pslli.w
-    x86_mmx_psra_d,                            // llvm.x86.mmx.psra.d
-    x86_mmx_psra_w,                            // llvm.x86.mmx.psra.w
-    x86_mmx_psrai_d,                           // llvm.x86.mmx.psrai.d
-    x86_mmx_psrai_w,                           // llvm.x86.mmx.psrai.w
-    x86_mmx_psrl_d,                            // llvm.x86.mmx.psrl.d
-    x86_mmx_psrl_q,                            // llvm.x86.mmx.psrl.q
-    x86_mmx_psrl_w,                            // llvm.x86.mmx.psrl.w
-    x86_mmx_psrli_d,                           // llvm.x86.mmx.psrli.d
-    x86_mmx_psrli_q,                           // llvm.x86.mmx.psrli.q
-    x86_mmx_psrli_w,                           // llvm.x86.mmx.psrli.w
-    x86_mmx_psub_b,                            // llvm.x86.mmx.psub.b
-    x86_mmx_psub_d,                            // llvm.x86.mmx.psub.d
-    x86_mmx_psub_q,                            // llvm.x86.mmx.psub.q
-    x86_mmx_psub_w,                            // llvm.x86.mmx.psub.w
-    x86_mmx_psubs_b,                           // llvm.x86.mmx.psubs.b
-    x86_mmx_psubs_w,                           // llvm.x86.mmx.psubs.w
-    x86_mmx_psubus_b,                          // llvm.x86.mmx.psubus.b
-    x86_mmx_psubus_w,                          // llvm.x86.mmx.psubus.w
-    x86_mmx_punpckhbw,                         // llvm.x86.mmx.punpckhbw
-    x86_mmx_punpckhdq,                         // llvm.x86.mmx.punpckhdq
-    x86_mmx_punpckhwd,                         // llvm.x86.mmx.punpckhwd
-    x86_mmx_punpcklbw,                         // llvm.x86.mmx.punpcklbw
-    x86_mmx_punpckldq,                         // llvm.x86.mmx.punpckldq
-    x86_mmx_punpcklwd,                         // llvm.x86.mmx.punpcklwd
-    x86_mmx_pxor,                              // llvm.x86.mmx.pxor
-    x86_monitorx,                              // llvm.x86.monitorx
-    x86_movdir64b,                             // llvm.x86.movdir64b
-    x86_mwaitx,                                // llvm.x86.mwaitx
-    x86_pclmulqdq,                             // llvm.x86.pclmulqdq
-    x86_pclmulqdq_256,                         // llvm.x86.pclmulqdq.256
-    x86_pclmulqdq_512,                         // llvm.x86.pclmulqdq.512
-    x86_ptwrite32,                             // llvm.x86.ptwrite32
-    x86_ptwrite64,                             // llvm.x86.ptwrite64
-    x86_rdfsbase_32,                           // llvm.x86.rdfsbase.32
-    x86_rdfsbase_64,                           // llvm.x86.rdfsbase.64
-    x86_rdgsbase_32,                           // llvm.x86.rdgsbase.32
-    x86_rdgsbase_64,                           // llvm.x86.rdgsbase.64
-    x86_rdpid,                                 // llvm.x86.rdpid
-    x86_rdpkru,                                // llvm.x86.rdpkru
-    x86_rdpmc,                                 // llvm.x86.rdpmc
-    x86_rdrand_16,                             // llvm.x86.rdrand.16
-    x86_rdrand_32,                             // llvm.x86.rdrand.32
-    x86_rdrand_64,                             // llvm.x86.rdrand.64
-    x86_rdseed_16,                             // llvm.x86.rdseed.16
-    x86_rdseed_32,                             // llvm.x86.rdseed.32
-    x86_rdseed_64,                             // llvm.x86.rdseed.64
-    x86_rdsspd,                                // llvm.x86.rdsspd
-    x86_rdsspq,                                // llvm.x86.rdsspq
-    x86_rdtsc,                                 // llvm.x86.rdtsc
-    x86_rdtscp,                                // llvm.x86.rdtscp
-    x86_rstorssp,                              // llvm.x86.rstorssp
-    x86_saveprevssp,                           // llvm.x86.saveprevssp
-    x86_seh_ehguard,                           // llvm.x86.seh.ehguard
-    x86_seh_ehregnode,                         // llvm.x86.seh.ehregnode
-    x86_seh_lsda,                              // llvm.x86.seh.lsda
-    x86_setssbsy,                              // llvm.x86.setssbsy
-    x86_sha1msg1,                              // llvm.x86.sha1msg1
-    x86_sha1msg2,                              // llvm.x86.sha1msg2
-    x86_sha1nexte,                             // llvm.x86.sha1nexte
-    x86_sha1rnds4,                             // llvm.x86.sha1rnds4
-    x86_sha256msg1,                            // llvm.x86.sha256msg1
-    x86_sha256msg2,                            // llvm.x86.sha256msg2
-    x86_sha256rnds2,                           // llvm.x86.sha256rnds2
-    x86_slwpcb,                                // llvm.x86.slwpcb
-    x86_sse_cmp_ps,                            // llvm.x86.sse.cmp.ps
-    x86_sse_cmp_ss,                            // llvm.x86.sse.cmp.ss
-    x86_sse_comieq_ss,                         // llvm.x86.sse.comieq.ss
-    x86_sse_comige_ss,                         // llvm.x86.sse.comige.ss
-    x86_sse_comigt_ss,                         // llvm.x86.sse.comigt.ss
-    x86_sse_comile_ss,                         // llvm.x86.sse.comile.ss
-    x86_sse_comilt_ss,                         // llvm.x86.sse.comilt.ss
-    x86_sse_comineq_ss,                        // llvm.x86.sse.comineq.ss
-    x86_sse_cvtpd2pi,                          // llvm.x86.sse.cvtpd2pi
-    x86_sse_cvtpi2pd,                          // llvm.x86.sse.cvtpi2pd
-    x86_sse_cvtpi2ps,                          // llvm.x86.sse.cvtpi2ps
-    x86_sse_cvtps2pi,                          // llvm.x86.sse.cvtps2pi
-    x86_sse_cvtss2si,                          // llvm.x86.sse.cvtss2si
-    x86_sse_cvtss2si64,                        // llvm.x86.sse.cvtss2si64
-    x86_sse_cvttpd2pi,                         // llvm.x86.sse.cvttpd2pi
-    x86_sse_cvttps2pi,                         // llvm.x86.sse.cvttps2pi
-    x86_sse_cvttss2si,                         // llvm.x86.sse.cvttss2si
-    x86_sse_cvttss2si64,                       // llvm.x86.sse.cvttss2si64
-    x86_sse_ldmxcsr,                           // llvm.x86.sse.ldmxcsr
-    x86_sse_max_ps,                            // llvm.x86.sse.max.ps
-    x86_sse_max_ss,                            // llvm.x86.sse.max.ss
-    x86_sse_min_ps,                            // llvm.x86.sse.min.ps
-    x86_sse_min_ss,                            // llvm.x86.sse.min.ss
-    x86_sse_movmsk_ps,                         // llvm.x86.sse.movmsk.ps
-    x86_sse_pshuf_w,                           // llvm.x86.sse.pshuf.w
-    x86_sse_rcp_ps,                            // llvm.x86.sse.rcp.ps
-    x86_sse_rcp_ss,                            // llvm.x86.sse.rcp.ss
-    x86_sse_rsqrt_ps,                          // llvm.x86.sse.rsqrt.ps
-    x86_sse_rsqrt_ss,                          // llvm.x86.sse.rsqrt.ss
-    x86_sse_sfence,                            // llvm.x86.sse.sfence
-    x86_sse_stmxcsr,                           // llvm.x86.sse.stmxcsr
-    x86_sse_ucomieq_ss,                        // llvm.x86.sse.ucomieq.ss
-    x86_sse_ucomige_ss,                        // llvm.x86.sse.ucomige.ss
-    x86_sse_ucomigt_ss,                        // llvm.x86.sse.ucomigt.ss
-    x86_sse_ucomile_ss,                        // llvm.x86.sse.ucomile.ss
-    x86_sse_ucomilt_ss,                        // llvm.x86.sse.ucomilt.ss
-    x86_sse_ucomineq_ss,                       // llvm.x86.sse.ucomineq.ss
-    x86_sse2_clflush,                          // llvm.x86.sse2.clflush
-    x86_sse2_cmp_pd,                           // llvm.x86.sse2.cmp.pd
-    x86_sse2_cmp_sd,                           // llvm.x86.sse2.cmp.sd
-    x86_sse2_comieq_sd,                        // llvm.x86.sse2.comieq.sd
-    x86_sse2_comige_sd,                        // llvm.x86.sse2.comige.sd
-    x86_sse2_comigt_sd,                        // llvm.x86.sse2.comigt.sd
-    x86_sse2_comile_sd,                        // llvm.x86.sse2.comile.sd
-    x86_sse2_comilt_sd,                        // llvm.x86.sse2.comilt.sd
-    x86_sse2_comineq_sd,                       // llvm.x86.sse2.comineq.sd
-    x86_sse2_cvtpd2dq,                         // llvm.x86.sse2.cvtpd2dq
-    x86_sse2_cvtpd2ps,                         // llvm.x86.sse2.cvtpd2ps
-    x86_sse2_cvtps2dq,                         // llvm.x86.sse2.cvtps2dq
-    x86_sse2_cvtsd2si,                         // llvm.x86.sse2.cvtsd2si
-    x86_sse2_cvtsd2si64,                       // llvm.x86.sse2.cvtsd2si64
-    x86_sse2_cvtsd2ss,                         // llvm.x86.sse2.cvtsd2ss
-    x86_sse2_cvttpd2dq,                        // llvm.x86.sse2.cvttpd2dq
-    x86_sse2_cvttps2dq,                        // llvm.x86.sse2.cvttps2dq
-    x86_sse2_cvttsd2si,                        // llvm.x86.sse2.cvttsd2si
-    x86_sse2_cvttsd2si64,                      // llvm.x86.sse2.cvttsd2si64
-    x86_sse2_lfence,                           // llvm.x86.sse2.lfence
-    x86_sse2_maskmov_dqu,                      // llvm.x86.sse2.maskmov.dqu
-    x86_sse2_max_pd,                           // llvm.x86.sse2.max.pd
-    x86_sse2_max_sd,                           // llvm.x86.sse2.max.sd
-    x86_sse2_mfence,                           // llvm.x86.sse2.mfence
-    x86_sse2_min_pd,                           // llvm.x86.sse2.min.pd
-    x86_sse2_min_sd,                           // llvm.x86.sse2.min.sd
-    x86_sse2_movmsk_pd,                        // llvm.x86.sse2.movmsk.pd
-    x86_sse2_packssdw_128,                     // llvm.x86.sse2.packssdw.128
-    x86_sse2_packsswb_128,                     // llvm.x86.sse2.packsswb.128
-    x86_sse2_packuswb_128,                     // llvm.x86.sse2.packuswb.128
-    x86_sse2_pause,                            // llvm.x86.sse2.pause
-    x86_sse2_pavg_b,                           // llvm.x86.sse2.pavg.b
-    x86_sse2_pavg_w,                           // llvm.x86.sse2.pavg.w
-    x86_sse2_pmadd_wd,                         // llvm.x86.sse2.pmadd.wd
-    x86_sse2_pmovmskb_128,                     // llvm.x86.sse2.pmovmskb.128
-    x86_sse2_pmulh_w,                          // llvm.x86.sse2.pmulh.w
-    x86_sse2_pmulhu_w,                         // llvm.x86.sse2.pmulhu.w
-    x86_sse2_psad_bw,                          // llvm.x86.sse2.psad.bw
-    x86_sse2_psll_d,                           // llvm.x86.sse2.psll.d
-    x86_sse2_psll_q,                           // llvm.x86.sse2.psll.q
-    x86_sse2_psll_w,                           // llvm.x86.sse2.psll.w
-    x86_sse2_pslli_d,                          // llvm.x86.sse2.pslli.d
-    x86_sse2_pslli_q,                          // llvm.x86.sse2.pslli.q
-    x86_sse2_pslli_w,                          // llvm.x86.sse2.pslli.w
-    x86_sse2_psra_d,                           // llvm.x86.sse2.psra.d
-    x86_sse2_psra_w,                           // llvm.x86.sse2.psra.w
-    x86_sse2_psrai_d,                          // llvm.x86.sse2.psrai.d
-    x86_sse2_psrai_w,                          // llvm.x86.sse2.psrai.w
-    x86_sse2_psrl_d,                           // llvm.x86.sse2.psrl.d
-    x86_sse2_psrl_q,                           // llvm.x86.sse2.psrl.q
-    x86_sse2_psrl_w,                           // llvm.x86.sse2.psrl.w
-    x86_sse2_psrli_d,                          // llvm.x86.sse2.psrli.d
-    x86_sse2_psrli_q,                          // llvm.x86.sse2.psrli.q
-    x86_sse2_psrli_w,                          // llvm.x86.sse2.psrli.w
-    x86_sse2_ucomieq_sd,                       // llvm.x86.sse2.ucomieq.sd
-    x86_sse2_ucomige_sd,                       // llvm.x86.sse2.ucomige.sd
-    x86_sse2_ucomigt_sd,                       // llvm.x86.sse2.ucomigt.sd
-    x86_sse2_ucomile_sd,                       // llvm.x86.sse2.ucomile.sd
-    x86_sse2_ucomilt_sd,                       // llvm.x86.sse2.ucomilt.sd
-    x86_sse2_ucomineq_sd,                      // llvm.x86.sse2.ucomineq.sd
-    x86_sse3_addsub_pd,                        // llvm.x86.sse3.addsub.pd
-    x86_sse3_addsub_ps,                        // llvm.x86.sse3.addsub.ps
-    x86_sse3_hadd_pd,                          // llvm.x86.sse3.hadd.pd
-    x86_sse3_hadd_ps,                          // llvm.x86.sse3.hadd.ps
-    x86_sse3_hsub_pd,                          // llvm.x86.sse3.hsub.pd
-    x86_sse3_hsub_ps,                          // llvm.x86.sse3.hsub.ps
-    x86_sse3_ldu_dq,                           // llvm.x86.sse3.ldu.dq
-    x86_sse3_monitor,                          // llvm.x86.sse3.monitor
-    x86_sse3_mwait,                            // llvm.x86.sse3.mwait
-    x86_sse41_blendvpd,                        // llvm.x86.sse41.blendvpd
-    x86_sse41_blendvps,                        // llvm.x86.sse41.blendvps
-    x86_sse41_dppd,                            // llvm.x86.sse41.dppd
-    x86_sse41_dpps,                            // llvm.x86.sse41.dpps
-    x86_sse41_insertps,                        // llvm.x86.sse41.insertps
-    x86_sse41_mpsadbw,                         // llvm.x86.sse41.mpsadbw
-    x86_sse41_packusdw,                        // llvm.x86.sse41.packusdw
-    x86_sse41_pblendvb,                        // llvm.x86.sse41.pblendvb
-    x86_sse41_phminposuw,                      // llvm.x86.sse41.phminposuw
-    x86_sse41_ptestc,                          // llvm.x86.sse41.ptestc
-    x86_sse41_ptestnzc,                        // llvm.x86.sse41.ptestnzc
-    x86_sse41_ptestz,                          // llvm.x86.sse41.ptestz
-    x86_sse41_round_pd,                        // llvm.x86.sse41.round.pd
-    x86_sse41_round_ps,                        // llvm.x86.sse41.round.ps
-    x86_sse41_round_sd,                        // llvm.x86.sse41.round.sd
-    x86_sse41_round_ss,                        // llvm.x86.sse41.round.ss
-    x86_sse42_crc32_32_16,                     // llvm.x86.sse42.crc32.32.16
-    x86_sse42_crc32_32_32,                     // llvm.x86.sse42.crc32.32.32
-    x86_sse42_crc32_32_8,                      // llvm.x86.sse42.crc32.32.8
-    x86_sse42_crc32_64_64,                     // llvm.x86.sse42.crc32.64.64
-    x86_sse42_pcmpestri128,                    // llvm.x86.sse42.pcmpestri128
-    x86_sse42_pcmpestria128,                   // llvm.x86.sse42.pcmpestria128
-    x86_sse42_pcmpestric128,                   // llvm.x86.sse42.pcmpestric128
-    x86_sse42_pcmpestrio128,                   // llvm.x86.sse42.pcmpestrio128
-    x86_sse42_pcmpestris128,                   // llvm.x86.sse42.pcmpestris128
-    x86_sse42_pcmpestriz128,                   // llvm.x86.sse42.pcmpestriz128
-    x86_sse42_pcmpestrm128,                    // llvm.x86.sse42.pcmpestrm128
-    x86_sse42_pcmpistri128,                    // llvm.x86.sse42.pcmpistri128
-    x86_sse42_pcmpistria128,                   // llvm.x86.sse42.pcmpistria128
-    x86_sse42_pcmpistric128,                   // llvm.x86.sse42.pcmpistric128
-    x86_sse42_pcmpistrio128,                   // llvm.x86.sse42.pcmpistrio128
-    x86_sse42_pcmpistris128,                   // llvm.x86.sse42.pcmpistris128
-    x86_sse42_pcmpistriz128,                   // llvm.x86.sse42.pcmpistriz128
-    x86_sse42_pcmpistrm128,                    // llvm.x86.sse42.pcmpistrm128
-    x86_sse4a_extrq,                           // llvm.x86.sse4a.extrq
-    x86_sse4a_extrqi,                          // llvm.x86.sse4a.extrqi
-    x86_sse4a_insertq,                         // llvm.x86.sse4a.insertq
-    x86_sse4a_insertqi,                        // llvm.x86.sse4a.insertqi
-    x86_ssse3_pabs_b,                          // llvm.x86.ssse3.pabs.b
-    x86_ssse3_pabs_d,                          // llvm.x86.ssse3.pabs.d
-    x86_ssse3_pabs_w,                          // llvm.x86.ssse3.pabs.w
-    x86_ssse3_phadd_d,                         // llvm.x86.ssse3.phadd.d
-    x86_ssse3_phadd_d_128,                     // llvm.x86.ssse3.phadd.d.128
-    x86_ssse3_phadd_sw,                        // llvm.x86.ssse3.phadd.sw
-    x86_ssse3_phadd_sw_128,                    // llvm.x86.ssse3.phadd.sw.128
-    x86_ssse3_phadd_w,                         // llvm.x86.ssse3.phadd.w
-    x86_ssse3_phadd_w_128,                     // llvm.x86.ssse3.phadd.w.128
-    x86_ssse3_phsub_d,                         // llvm.x86.ssse3.phsub.d
-    x86_ssse3_phsub_d_128,                     // llvm.x86.ssse3.phsub.d.128
-    x86_ssse3_phsub_sw,                        // llvm.x86.ssse3.phsub.sw
-    x86_ssse3_phsub_sw_128,                    // llvm.x86.ssse3.phsub.sw.128
-    x86_ssse3_phsub_w,                         // llvm.x86.ssse3.phsub.w
-    x86_ssse3_phsub_w_128,                     // llvm.x86.ssse3.phsub.w.128
-    x86_ssse3_pmadd_ub_sw,                     // llvm.x86.ssse3.pmadd.ub.sw
-    x86_ssse3_pmadd_ub_sw_128,                 // llvm.x86.ssse3.pmadd.ub.sw.128
-    x86_ssse3_pmul_hr_sw,                      // llvm.x86.ssse3.pmul.hr.sw
-    x86_ssse3_pmul_hr_sw_128,                  // llvm.x86.ssse3.pmul.hr.sw.128
-    x86_ssse3_pshuf_b,                         // llvm.x86.ssse3.pshuf.b
-    x86_ssse3_pshuf_b_128,                     // llvm.x86.ssse3.pshuf.b.128
-    x86_ssse3_psign_b,                         // llvm.x86.ssse3.psign.b
-    x86_ssse3_psign_b_128,                     // llvm.x86.ssse3.psign.b.128
-    x86_ssse3_psign_d,                         // llvm.x86.ssse3.psign.d
-    x86_ssse3_psign_d_128,                     // llvm.x86.ssse3.psign.d.128
-    x86_ssse3_psign_w,                         // llvm.x86.ssse3.psign.w
-    x86_ssse3_psign_w_128,                     // llvm.x86.ssse3.psign.w.128
-    x86_subborrow_32,                          // llvm.x86.subborrow.32
-    x86_subborrow_64,                          // llvm.x86.subborrow.64
-    x86_tbm_bextri_u32,                        // llvm.x86.tbm.bextri.u32
-    x86_tbm_bextri_u64,                        // llvm.x86.tbm.bextri.u64
-    x86_tpause,                                // llvm.x86.tpause
-    x86_umonitor,                              // llvm.x86.umonitor
-    x86_umwait,                                // llvm.x86.umwait
-    x86_vcvtph2ps_128,                         // llvm.x86.vcvtph2ps.128
-    x86_vcvtph2ps_256,                         // llvm.x86.vcvtph2ps.256
-    x86_vcvtps2ph_128,                         // llvm.x86.vcvtps2ph.128
-    x86_vcvtps2ph_256,                         // llvm.x86.vcvtps2ph.256
-    x86_vgf2p8affineinvqb_128,                 // llvm.x86.vgf2p8affineinvqb.128
-    x86_vgf2p8affineinvqb_256,                 // llvm.x86.vgf2p8affineinvqb.256
-    x86_vgf2p8affineinvqb_512,                 // llvm.x86.vgf2p8affineinvqb.512
-    x86_vgf2p8affineqb_128,                    // llvm.x86.vgf2p8affineqb.128
-    x86_vgf2p8affineqb_256,                    // llvm.x86.vgf2p8affineqb.256
-    x86_vgf2p8affineqb_512,                    // llvm.x86.vgf2p8affineqb.512
-    x86_vgf2p8mulb_128,                        // llvm.x86.vgf2p8mulb.128
-    x86_vgf2p8mulb_256,                        // llvm.x86.vgf2p8mulb.256
-    x86_vgf2p8mulb_512,                        // llvm.x86.vgf2p8mulb.512
-    x86_wbinvd,                                // llvm.x86.wbinvd
-    x86_wbnoinvd,                              // llvm.x86.wbnoinvd
-    x86_wrfsbase_32,                           // llvm.x86.wrfsbase.32
-    x86_wrfsbase_64,                           // llvm.x86.wrfsbase.64
-    x86_wrgsbase_32,                           // llvm.x86.wrgsbase.32
-    x86_wrgsbase_64,                           // llvm.x86.wrgsbase.64
-    x86_wrpkru,                                // llvm.x86.wrpkru
-    x86_wrssd,                                 // llvm.x86.wrssd
-    x86_wrssq,                                 // llvm.x86.wrssq
-    x86_wrussd,                                // llvm.x86.wrussd
-    x86_wrussq,                                // llvm.x86.wrussq
-    x86_xabort,                                // llvm.x86.xabort
-    x86_xbegin,                                // llvm.x86.xbegin
-    x86_xend,                                  // llvm.x86.xend
-    x86_xgetbv,                                // llvm.x86.xgetbv
-    x86_xop_vfrcz_pd,                          // llvm.x86.xop.vfrcz.pd
-    x86_xop_vfrcz_pd_256,                      // llvm.x86.xop.vfrcz.pd.256
-    x86_xop_vfrcz_ps,                          // llvm.x86.xop.vfrcz.ps
-    x86_xop_vfrcz_ps_256,                      // llvm.x86.xop.vfrcz.ps.256
-    x86_xop_vfrcz_sd,                          // llvm.x86.xop.vfrcz.sd
-    x86_xop_vfrcz_ss,                          // llvm.x86.xop.vfrcz.ss
-    x86_xop_vpermil2pd,                        // llvm.x86.xop.vpermil2pd
-    x86_xop_vpermil2pd_256,                    // llvm.x86.xop.vpermil2pd.256
-    x86_xop_vpermil2ps,                        // llvm.x86.xop.vpermil2ps
-    x86_xop_vpermil2ps_256,                    // llvm.x86.xop.vpermil2ps.256
-    x86_xop_vphaddbd,                          // llvm.x86.xop.vphaddbd
-    x86_xop_vphaddbq,                          // llvm.x86.xop.vphaddbq
-    x86_xop_vphaddbw,                          // llvm.x86.xop.vphaddbw
-    x86_xop_vphadddq,                          // llvm.x86.xop.vphadddq
-    x86_xop_vphaddubd,                         // llvm.x86.xop.vphaddubd
-    x86_xop_vphaddubq,                         // llvm.x86.xop.vphaddubq
-    x86_xop_vphaddubw,                         // llvm.x86.xop.vphaddubw
-    x86_xop_vphaddudq,                         // llvm.x86.xop.vphaddudq
-    x86_xop_vphadduwd,                         // llvm.x86.xop.vphadduwd
-    x86_xop_vphadduwq,                         // llvm.x86.xop.vphadduwq
-    x86_xop_vphaddwd,                          // llvm.x86.xop.vphaddwd
-    x86_xop_vphaddwq,                          // llvm.x86.xop.vphaddwq
-    x86_xop_vphsubbw,                          // llvm.x86.xop.vphsubbw
-    x86_xop_vphsubdq,                          // llvm.x86.xop.vphsubdq
-    x86_xop_vphsubwd,                          // llvm.x86.xop.vphsubwd
-    x86_xop_vpmacsdd,                          // llvm.x86.xop.vpmacsdd
-    x86_xop_vpmacsdqh,                         // llvm.x86.xop.vpmacsdqh
-    x86_xop_vpmacsdql,                         // llvm.x86.xop.vpmacsdql
-    x86_xop_vpmacssdd,                         // llvm.x86.xop.vpmacssdd
-    x86_xop_vpmacssdqh,                        // llvm.x86.xop.vpmacssdqh
-    x86_xop_vpmacssdql,                        // llvm.x86.xop.vpmacssdql
-    x86_xop_vpmacsswd,                         // llvm.x86.xop.vpmacsswd
-    x86_xop_vpmacssww,                         // llvm.x86.xop.vpmacssww
-    x86_xop_vpmacswd,                          // llvm.x86.xop.vpmacswd
-    x86_xop_vpmacsww,                          // llvm.x86.xop.vpmacsww
-    x86_xop_vpmadcsswd,                        // llvm.x86.xop.vpmadcsswd
-    x86_xop_vpmadcswd,                         // llvm.x86.xop.vpmadcswd
-    x86_xop_vpperm,                            // llvm.x86.xop.vpperm
-    x86_xop_vpshab,                            // llvm.x86.xop.vpshab
-    x86_xop_vpshad,                            // llvm.x86.xop.vpshad
-    x86_xop_vpshaq,                            // llvm.x86.xop.vpshaq
-    x86_xop_vpshaw,                            // llvm.x86.xop.vpshaw
-    x86_xop_vpshlb,                            // llvm.x86.xop.vpshlb
-    x86_xop_vpshld,                            // llvm.x86.xop.vpshld
-    x86_xop_vpshlq,                            // llvm.x86.xop.vpshlq
-    x86_xop_vpshlw,                            // llvm.x86.xop.vpshlw
-    x86_xrstor,                                // llvm.x86.xrstor
-    x86_xrstor64,                              // llvm.x86.xrstor64
-    x86_xrstors,                               // llvm.x86.xrstors
-    x86_xrstors64,                             // llvm.x86.xrstors64
-    x86_xsave,                                 // llvm.x86.xsave
-    x86_xsave64,                               // llvm.x86.xsave64
-    x86_xsavec,                                // llvm.x86.xsavec
-    x86_xsavec64,                              // llvm.x86.xsavec64
-    x86_xsaveopt,                              // llvm.x86.xsaveopt
-    x86_xsaveopt64,                            // llvm.x86.xsaveopt64
-    x86_xsaves,                                // llvm.x86.xsaves
-    x86_xsaves64,                              // llvm.x86.xsaves64
-    x86_xsetbv,                                // llvm.x86.xsetbv
-    x86_xtest,                                 // llvm.x86.xtest
-    xcore_bitrev,                              // llvm.xcore.bitrev
-    xcore_checkevent,                          // llvm.xcore.checkevent
-    xcore_chkct,                               // llvm.xcore.chkct
-    xcore_clre,                                // llvm.xcore.clre
-    xcore_clrpt,                               // llvm.xcore.clrpt
-    xcore_clrsr,                               // llvm.xcore.clrsr
-    xcore_crc32,                               // llvm.xcore.crc32
-    xcore_crc8,                                // llvm.xcore.crc8
-    xcore_edu,                                 // llvm.xcore.edu
-    xcore_eeu,                                 // llvm.xcore.eeu
-    xcore_endin,                               // llvm.xcore.endin
-    xcore_freer,                               // llvm.xcore.freer
-    xcore_geted,                               // llvm.xcore.geted
-    xcore_getet,                               // llvm.xcore.getet
-    xcore_getid,                               // llvm.xcore.getid
-    xcore_getps,                               // llvm.xcore.getps
-    xcore_getr,                                // llvm.xcore.getr
-    xcore_getst,                               // llvm.xcore.getst
-    xcore_getts,                               // llvm.xcore.getts
-    xcore_in,                                  // llvm.xcore.in
-    xcore_inct,                                // llvm.xcore.inct
-    xcore_initcp,                              // llvm.xcore.initcp
-    xcore_initdp,                              // llvm.xcore.initdp
-    xcore_initlr,                              // llvm.xcore.initlr
-    xcore_initpc,                              // llvm.xcore.initpc
-    xcore_initsp,                              // llvm.xcore.initsp
-    xcore_inshr,                               // llvm.xcore.inshr
-    xcore_int,                                 // llvm.xcore.int
-    xcore_mjoin,                               // llvm.xcore.mjoin
-    xcore_msync,                               // llvm.xcore.msync
-    xcore_out,                                 // llvm.xcore.out
-    xcore_outct,                               // llvm.xcore.outct
-    xcore_outshr,                              // llvm.xcore.outshr
-    xcore_outt,                                // llvm.xcore.outt
-    xcore_peek,                                // llvm.xcore.peek
-    xcore_setc,                                // llvm.xcore.setc
-    xcore_setclk,                              // llvm.xcore.setclk
-    xcore_setd,                                // llvm.xcore.setd
-    xcore_setev,                               // llvm.xcore.setev
-    xcore_setps,                               // llvm.xcore.setps
-    xcore_setpsc,                              // llvm.xcore.setpsc
-    xcore_setpt,                               // llvm.xcore.setpt
-    xcore_setrdy,                              // llvm.xcore.setrdy
-    xcore_setsr,                               // llvm.xcore.setsr
-    xcore_settw,                               // llvm.xcore.settw
-    xcore_setv,                                // llvm.xcore.setv
-    xcore_sext,                                // llvm.xcore.sext
-    xcore_ssync,                               // llvm.xcore.ssync
-    xcore_syncr,                               // llvm.xcore.syncr
-    xcore_testct,                              // llvm.xcore.testct
-    xcore_testwct,                             // llvm.xcore.testwct
-    xcore_waitevent,                           // llvm.xcore.waitevent
-    xcore_zext                                 // llvm.xcore.zext
-#endif
-
-#if defined(_MSC_VER) && defined(setjmp_undefined_for_msvc)
-// let's return it to _setjmp state
-#  pragma pop_macro("setjmp")
-#  undef setjmp_undefined_for_msvc
-#endif
-
+    num_intrinsics = 9759
diff --git a/linux-x64/clang/include/llvm/IR/IntrinsicImpl.inc b/linux-x64/clang/include/llvm/IR/IntrinsicImpl.inc
index c6ff35c..b0c562d 100644
--- a/linux-x64/clang/include/llvm/IR/IntrinsicImpl.inc
+++ b/linux-x64/clang/include/llvm/IR/IntrinsicImpl.inc
@@ -6,14 +6,6 @@
 |*                                                                            *|
 \*===----------------------------------------------------------------------===*/
 
-// VisualStudio defines setjmp as _setjmp
-#if defined(_MSC_VER) && defined(setjmp) && \
-                         !defined(setjmp_undefined_for_msvc)
-#  pragma push_macro("setjmp")
-#  undef setjmp
-#  define setjmp_undefined_for_msvc
-#endif
-
 // Target mapping
 #ifdef GET_INTRINSIC_TARGET_DATA
 struct IntrinsicTargetInfo {
@@ -22,33 +14,38 @@
   size_t Count;
 };
 static constexpr IntrinsicTargetInfo TargetInfos[] = {
-  {llvm::StringLiteral(""), 0, 243},
-  {llvm::StringLiteral("aarch64"), 243, 204},
-  {llvm::StringLiteral("amdgcn"), 447, 666},
-  {llvm::StringLiteral("arm"), 1113, 256},
-  {llvm::StringLiteral("bpf"), 1369, 4},
-  {llvm::StringLiteral("hexagon"), 1373, 1766},
-  {llvm::StringLiteral("mips"), 3139, 667},
-  {llvm::StringLiteral("nvvm"), 3806, 1270},
-  {llvm::StringLiteral("ppc"), 5076, 406},
-  {llvm::StringLiteral("r600"), 5482, 35},
-  {llvm::StringLiteral("riscv"), 5517, 18},
-  {llvm::StringLiteral("s390"), 5535, 220},
-  {llvm::StringLiteral("wasm"), 5755, 21},
-  {llvm::StringLiteral("x86"), 5776, 1172},
-  {llvm::StringLiteral("xcore"), 6948, 53},
+  {llvm::StringLiteral(""), 0, 314},
+  {llvm::StringLiteral("aarch64"), 314, 845},
+  {llvm::StringLiteral("amdgcn"), 1159, 696},
+  {llvm::StringLiteral("arm"), 1855, 489},
+  {llvm::StringLiteral("bpf"), 2344, 9},
+  {llvm::StringLiteral("hexagon"), 2353, 1750},
+  {llvm::StringLiteral("mips"), 4103, 671},
+  {llvm::StringLiteral("nvvm"), 4774, 1296},
+  {llvm::StringLiteral("ppc"), 6070, 515},
+  {llvm::StringLiteral("r600"), 6585, 35},
+  {llvm::StringLiteral("riscv"), 6620, 366},
+  {llvm::StringLiteral("s390"), 6986, 228},
+  {llvm::StringLiteral("ve"), 7214, 1220},
+  {llvm::StringLiteral("wasm"), 8434, 65},
+  {llvm::StringLiteral("x86"), 8499, 1206},
+  {llvm::StringLiteral("xcore"), 9705, 53},
 };
 #endif
 
 // Intrinsic ID to name table
 #ifdef GET_INTRINSIC_NAME_TABLE
   // Note that entry #0 is the invalid intrinsic!
+  "llvm.abs",
   "llvm.addressofreturnaddress",
   "llvm.adjust.trampoline",
   "llvm.annotation",
   "llvm.assume",
   "llvm.bitreverse",
   "llvm.bswap",
+  "llvm.call.preallocated.arg",
+  "llvm.call.preallocated.setup",
+  "llvm.call.preallocated.teardown",
   "llvm.canonicalize",
   "llvm.ceil",
   "llvm.clear_cache",
@@ -57,21 +54,35 @@
   "llvm.convert.to.fp16",
   "llvm.copysign",
   "llvm.coro.alloc",
+  "llvm.coro.alloca.alloc",
+  "llvm.coro.alloca.free",
+  "llvm.coro.alloca.get",
+  "llvm.coro.async.context.alloc",
+  "llvm.coro.async.context.dealloc",
+  "llvm.coro.async.resume",
   "llvm.coro.begin",
   "llvm.coro.destroy",
   "llvm.coro.done",
   "llvm.coro.end",
+  "llvm.coro.end.async",
   "llvm.coro.frame",
   "llvm.coro.free",
   "llvm.coro.id",
+  "llvm.coro.id.async",
+  "llvm.coro.id.retcon",
+  "llvm.coro.id.retcon.once",
   "llvm.coro.noop",
   "llvm.coro.param",
+  "llvm.coro.prepare.async",
+  "llvm.coro.prepare.retcon",
   "llvm.coro.promise",
   "llvm.coro.resume",
   "llvm.coro.save",
   "llvm.coro.size",
   "llvm.coro.subfn.addr",
   "llvm.coro.suspend",
+  "llvm.coro.suspend.async",
+  "llvm.coro.suspend.retcon",
   "llvm.cos",
   "llvm.ctlz",
   "llvm.ctpop",
@@ -99,32 +110,47 @@
   "llvm.exp",
   "llvm.exp2",
   "llvm.expect",
+  "llvm.expect.with.probability",
   "llvm.experimental.constrained.ceil",
   "llvm.experimental.constrained.cos",
   "llvm.experimental.constrained.exp",
   "llvm.experimental.constrained.exp2",
   "llvm.experimental.constrained.fadd",
+  "llvm.experimental.constrained.fcmp",
+  "llvm.experimental.constrained.fcmps",
   "llvm.experimental.constrained.fdiv",
   "llvm.experimental.constrained.floor",
   "llvm.experimental.constrained.fma",
   "llvm.experimental.constrained.fmul",
+  "llvm.experimental.constrained.fmuladd",
   "llvm.experimental.constrained.fpext",
+  "llvm.experimental.constrained.fptosi",
+  "llvm.experimental.constrained.fptoui",
   "llvm.experimental.constrained.fptrunc",
   "llvm.experimental.constrained.frem",
   "llvm.experimental.constrained.fsub",
+  "llvm.experimental.constrained.llrint",
+  "llvm.experimental.constrained.llround",
   "llvm.experimental.constrained.log",
   "llvm.experimental.constrained.log10",
   "llvm.experimental.constrained.log2",
+  "llvm.experimental.constrained.lrint",
+  "llvm.experimental.constrained.lround",
+  "llvm.experimental.constrained.maximum",
   "llvm.experimental.constrained.maxnum",
+  "llvm.experimental.constrained.minimum",
   "llvm.experimental.constrained.minnum",
   "llvm.experimental.constrained.nearbyint",
   "llvm.experimental.constrained.pow",
   "llvm.experimental.constrained.powi",
   "llvm.experimental.constrained.rint",
   "llvm.experimental.constrained.round",
+  "llvm.experimental.constrained.roundeven",
   "llvm.experimental.constrained.sin",
+  "llvm.experimental.constrained.sitofp",
   "llvm.experimental.constrained.sqrt",
   "llvm.experimental.constrained.trunc",
+  "llvm.experimental.constrained.uitofp",
   "llvm.experimental.deoptimize",
   "llvm.experimental.gc.relocate",
   "llvm.experimental.gc.result",
@@ -133,33 +159,26 @@
   "llvm.experimental.patchpoint.i64",
   "llvm.experimental.patchpoint.void",
   "llvm.experimental.stackmap",
-  "llvm.experimental.vector.reduce.add",
-  "llvm.experimental.vector.reduce.and",
-  "llvm.experimental.vector.reduce.fmax",
-  "llvm.experimental.vector.reduce.fmin",
-  "llvm.experimental.vector.reduce.mul",
-  "llvm.experimental.vector.reduce.or",
-  "llvm.experimental.vector.reduce.smax",
-  "llvm.experimental.vector.reduce.smin",
-  "llvm.experimental.vector.reduce.umax",
-  "llvm.experimental.vector.reduce.umin",
-  "llvm.experimental.vector.reduce.v2.fadd",
-  "llvm.experimental.vector.reduce.v2.fmul",
-  "llvm.experimental.vector.reduce.xor",
+  "llvm.experimental.vector.extract",
+  "llvm.experimental.vector.insert",
   "llvm.experimental.widenable.condition",
   "llvm.fabs",
   "llvm.floor",
   "llvm.flt.rounds",
   "llvm.fma",
   "llvm.fmuladd",
+  "llvm.fptosi.sat",
+  "llvm.fptoui.sat",
   "llvm.frameaddress",
   "llvm.fshl",
   "llvm.fshr",
   "llvm.gcread",
   "llvm.gcroot",
   "llvm.gcwrite",
+  "llvm.get.active.lane.mask",
   "llvm.get.dynamic.area.offset",
   "llvm.hwasan.check.memaccess",
+  "llvm.hwasan.check.memaccess.shortgranules",
   "llvm.icall.branch.funnel",
   "llvm.init.trampoline",
   "llvm.instrprof.increment",
@@ -180,7 +199,6 @@
   "llvm.log",
   "llvm.log10",
   "llvm.log2",
-  "llvm.longjmp",
   "llvm.loop.decrement",
   "llvm.loop.decrement.reg",
   "llvm.lrint",
@@ -191,10 +209,15 @@
   "llvm.masked.load",
   "llvm.masked.scatter",
   "llvm.masked.store",
+  "llvm.matrix.column.major.load",
+  "llvm.matrix.column.major.store",
+  "llvm.matrix.multiply",
+  "llvm.matrix.transpose",
   "llvm.maximum",
   "llvm.maxnum",
   "llvm.memcpy",
   "llvm.memcpy.element.unordered.atomic",
+  "llvm.memcpy.inline",
   "llvm.memmove",
   "llvm.memmove.element.unordered.atomic",
   "llvm.memset",
@@ -240,32 +263,39 @@
   "llvm.preserve.array.access.index",
   "llvm.preserve.struct.access.index",
   "llvm.preserve.union.access.index",
+  "llvm.pseudoprobe",
   "llvm.ptr.annotation",
+  "llvm.ptrmask",
   "llvm.read_register",
+  "llvm.read_volatile_register",
   "llvm.readcyclecounter",
   "llvm.returnaddress",
   "llvm.rint",
   "llvm.round",
+  "llvm.roundeven",
   "llvm.sadd.sat",
   "llvm.sadd.with.overflow",
+  "llvm.sdiv.fix",
+  "llvm.sdiv.fix.sat",
   "llvm.set.loop.iterations",
-  "llvm.setjmp",
   "llvm.sideeffect",
-  "llvm.siglongjmp",
-  "llvm.sigsetjmp",
   "llvm.sin",
+  "llvm.smax",
+  "llvm.smin",
   "llvm.smul.fix",
   "llvm.smul.fix.sat",
   "llvm.smul.with.overflow",
   "llvm.sponentry",
   "llvm.sqrt",
   "llvm.ssa.copy",
+  "llvm.sshl.sat",
   "llvm.ssub.sat",
   "llvm.ssub.with.overflow",
   "llvm.stackguard",
   "llvm.stackprotector",
   "llvm.stackrestore",
   "llvm.stacksave",
+  "llvm.start.loop.iterations",
   "llvm.strip.invariant.group",
   "llvm.test.set.loop.iterations",
   "llvm.thread.pointer",
@@ -275,19 +305,55 @@
   "llvm.type.test",
   "llvm.uadd.sat",
   "llvm.uadd.with.overflow",
+  "llvm.ubsantrap",
+  "llvm.udiv.fix",
+  "llvm.udiv.fix.sat",
+  "llvm.umax",
+  "llvm.umin",
   "llvm.umul.fix",
+  "llvm.umul.fix.sat",
   "llvm.umul.with.overflow",
+  "llvm.ushl.sat",
   "llvm.usub.sat",
   "llvm.usub.with.overflow",
   "llvm.va_copy",
   "llvm.va_end",
   "llvm.va_start",
   "llvm.var.annotation",
+  "llvm.vector.reduce.add",
+  "llvm.vector.reduce.and",
+  "llvm.vector.reduce.fadd",
+  "llvm.vector.reduce.fmax",
+  "llvm.vector.reduce.fmin",
+  "llvm.vector.reduce.fmul",
+  "llvm.vector.reduce.mul",
+  "llvm.vector.reduce.or",
+  "llvm.vector.reduce.smax",
+  "llvm.vector.reduce.smin",
+  "llvm.vector.reduce.umax",
+  "llvm.vector.reduce.umin",
+  "llvm.vector.reduce.xor",
+  "llvm.vp.add",
+  "llvm.vp.and",
+  "llvm.vp.ashr",
+  "llvm.vp.lshr",
+  "llvm.vp.mul",
+  "llvm.vp.or",
+  "llvm.vp.sdiv",
+  "llvm.vp.shl",
+  "llvm.vp.srem",
+  "llvm.vp.sub",
+  "llvm.vp.udiv",
+  "llvm.vp.urem",
+  "llvm.vp.xor",
+  "llvm.vscale",
   "llvm.write_register",
   "llvm.xray.customevent",
   "llvm.xray.typedevent",
   "llvm.aarch64.addg",
   "llvm.aarch64.clrex",
+  "llvm.aarch64.cls",
+  "llvm.aarch64.cls64",
   "llvm.aarch64.crc32b",
   "llvm.aarch64.crc32cb",
   "llvm.aarch64.crc32ch",
@@ -312,11 +378,14 @@
   "llvm.aarch64.crypto.sha256su1",
   "llvm.aarch64.dmb",
   "llvm.aarch64.dsb",
+  "llvm.aarch64.fjcvtzs",
   "llvm.aarch64.get.fpcr",
   "llvm.aarch64.gmi",
   "llvm.aarch64.hint",
   "llvm.aarch64.irg",
+  "llvm.aarch64.irg.sp",
   "llvm.aarch64.isb",
+  "llvm.aarch64.ld64b",
   "llvm.aarch64.ldaxp",
   "llvm.aarch64.ldaxr",
   "llvm.aarch64.ldg",
@@ -325,6 +394,13 @@
   "llvm.aarch64.neon.abs",
   "llvm.aarch64.neon.addhn",
   "llvm.aarch64.neon.addp",
+  "llvm.aarch64.neon.bfcvt",
+  "llvm.aarch64.neon.bfcvtn",
+  "llvm.aarch64.neon.bfcvtn2",
+  "llvm.aarch64.neon.bfdot",
+  "llvm.aarch64.neon.bfmlalb",
+  "llvm.aarch64.neon.bfmlalt",
+  "llvm.aarch64.neon.bfmmla",
   "llvm.aarch64.neon.cls",
   "llvm.aarch64.neon.fabd",
   "llvm.aarch64.neon.facge",
@@ -401,14 +477,19 @@
   "llvm.aarch64.neon.smin",
   "llvm.aarch64.neon.sminp",
   "llvm.aarch64.neon.sminv",
+  "llvm.aarch64.neon.smmla",
   "llvm.aarch64.neon.smull",
   "llvm.aarch64.neon.sqabs",
   "llvm.aarch64.neon.sqadd",
   "llvm.aarch64.neon.sqdmulh",
+  "llvm.aarch64.neon.sqdmulh.lane",
+  "llvm.aarch64.neon.sqdmulh.laneq",
   "llvm.aarch64.neon.sqdmull",
   "llvm.aarch64.neon.sqdmulls.scalar",
   "llvm.aarch64.neon.sqneg",
   "llvm.aarch64.neon.sqrdmulh",
+  "llvm.aarch64.neon.sqrdmulh.lane",
+  "llvm.aarch64.neon.sqrdmulh.laneq",
   "llvm.aarch64.neon.sqrshl",
   "llvm.aarch64.neon.sqrshrn",
   "llvm.aarch64.neon.sqrshrun",
@@ -455,6 +536,7 @@
   "llvm.aarch64.neon.umin",
   "llvm.aarch64.neon.uminp",
   "llvm.aarch64.neon.uminv",
+  "llvm.aarch64.neon.ummla",
   "llvm.aarch64.neon.umull",
   "llvm.aarch64.neon.uqadd",
   "llvm.aarch64.neon.uqrshl",
@@ -467,9 +549,17 @@
   "llvm.aarch64.neon.urhadd",
   "llvm.aarch64.neon.urshl",
   "llvm.aarch64.neon.ursqrte",
+  "llvm.aarch64.neon.usdot",
   "llvm.aarch64.neon.ushl",
   "llvm.aarch64.neon.ushll",
+  "llvm.aarch64.neon.usmmla",
   "llvm.aarch64.neon.usqadd",
+  "llvm.aarch64.neon.vcadd.rot270",
+  "llvm.aarch64.neon.vcadd.rot90",
+  "llvm.aarch64.neon.vcmla.rot0",
+  "llvm.aarch64.neon.vcmla.rot180",
+  "llvm.aarch64.neon.vcmla.rot270",
+  "llvm.aarch64.neon.vcmla.rot90",
   "llvm.aarch64.neon.vcopy.lane",
   "llvm.aarch64.neon.vcvtfp2fxs",
   "llvm.aarch64.neon.vcvtfp2fxu",
@@ -480,23 +570,641 @@
   "llvm.aarch64.neon.vsli",
   "llvm.aarch64.neon.vsri",
   "llvm.aarch64.sdiv",
+  "llvm.aarch64.settag",
+  "llvm.aarch64.settag.zero",
   "llvm.aarch64.sisd.fabd",
   "llvm.aarch64.sisd.fcvtxn",
   "llvm.aarch64.space",
+  "llvm.aarch64.st64b",
+  "llvm.aarch64.st64bv",
+  "llvm.aarch64.st64bv0",
   "llvm.aarch64.stg",
+  "llvm.aarch64.stgp",
   "llvm.aarch64.stlxp",
   "llvm.aarch64.stlxr",
   "llvm.aarch64.stxp",
   "llvm.aarch64.stxr",
   "llvm.aarch64.subp",
+  "llvm.aarch64.sve.abs",
+  "llvm.aarch64.sve.adclb",
+  "llvm.aarch64.sve.adclt",
+  "llvm.aarch64.sve.add",
+  "llvm.aarch64.sve.addhnb",
+  "llvm.aarch64.sve.addhnt",
+  "llvm.aarch64.sve.addp",
+  "llvm.aarch64.sve.adrb",
+  "llvm.aarch64.sve.adrd",
+  "llvm.aarch64.sve.adrh",
+  "llvm.aarch64.sve.adrw",
+  "llvm.aarch64.sve.aesd",
+  "llvm.aarch64.sve.aese",
+  "llvm.aarch64.sve.aesimc",
+  "llvm.aarch64.sve.aesmc",
+  "llvm.aarch64.sve.and",
+  "llvm.aarch64.sve.and.z",
+  "llvm.aarch64.sve.andv",
+  "llvm.aarch64.sve.asr",
+  "llvm.aarch64.sve.asr.wide",
+  "llvm.aarch64.sve.asrd",
+  "llvm.aarch64.sve.bcax",
+  "llvm.aarch64.sve.bdep.x",
+  "llvm.aarch64.sve.bext.x",
+  "llvm.aarch64.sve.bfdot",
+  "llvm.aarch64.sve.bfdot.lane",
+  "llvm.aarch64.sve.bfmlalb",
+  "llvm.aarch64.sve.bfmlalb.lane",
+  "llvm.aarch64.sve.bfmlalt",
+  "llvm.aarch64.sve.bfmlalt.lane",
+  "llvm.aarch64.sve.bfmmla",
+  "llvm.aarch64.sve.bgrp.x",
+  "llvm.aarch64.sve.bic",
+  "llvm.aarch64.sve.bic.z",
+  "llvm.aarch64.sve.brka",
+  "llvm.aarch64.sve.brka.z",
+  "llvm.aarch64.sve.brkb",
+  "llvm.aarch64.sve.brkb.z",
+  "llvm.aarch64.sve.brkn.z",
+  "llvm.aarch64.sve.brkpa.z",
+  "llvm.aarch64.sve.brkpb.z",
+  "llvm.aarch64.sve.bsl",
+  "llvm.aarch64.sve.bsl1n",
+  "llvm.aarch64.sve.bsl2n",
+  "llvm.aarch64.sve.cadd.x",
+  "llvm.aarch64.sve.cdot",
+  "llvm.aarch64.sve.cdot.lane",
+  "llvm.aarch64.sve.clasta",
+  "llvm.aarch64.sve.clasta.n",
+  "llvm.aarch64.sve.clastb",
+  "llvm.aarch64.sve.clastb.n",
+  "llvm.aarch64.sve.cls",
+  "llvm.aarch64.sve.clz",
+  "llvm.aarch64.sve.cmla.lane.x",
+  "llvm.aarch64.sve.cmla.x",
+  "llvm.aarch64.sve.cmpeq",
+  "llvm.aarch64.sve.cmpeq.wide",
+  "llvm.aarch64.sve.cmpge",
+  "llvm.aarch64.sve.cmpge.wide",
+  "llvm.aarch64.sve.cmpgt",
+  "llvm.aarch64.sve.cmpgt.wide",
+  "llvm.aarch64.sve.cmphi",
+  "llvm.aarch64.sve.cmphi.wide",
+  "llvm.aarch64.sve.cmphs",
+  "llvm.aarch64.sve.cmphs.wide",
+  "llvm.aarch64.sve.cmple.wide",
+  "llvm.aarch64.sve.cmplo.wide",
+  "llvm.aarch64.sve.cmpls.wide",
+  "llvm.aarch64.sve.cmplt.wide",
+  "llvm.aarch64.sve.cmpne",
+  "llvm.aarch64.sve.cmpne.wide",
+  "llvm.aarch64.sve.cnot",
+  "llvm.aarch64.sve.cnt",
+  "llvm.aarch64.sve.cntb",
+  "llvm.aarch64.sve.cntd",
+  "llvm.aarch64.sve.cnth",
+  "llvm.aarch64.sve.cntp",
+  "llvm.aarch64.sve.cntw",
+  "llvm.aarch64.sve.compact",
+  "llvm.aarch64.sve.convert.from.svbool",
+  "llvm.aarch64.sve.convert.to.svbool",
+  "llvm.aarch64.sve.dup",
+  "llvm.aarch64.sve.dup.x",
+  "llvm.aarch64.sve.dupq.lane",
+  "llvm.aarch64.sve.eor",
+  "llvm.aarch64.sve.eor.z",
+  "llvm.aarch64.sve.eor3",
+  "llvm.aarch64.sve.eorbt",
+  "llvm.aarch64.sve.eortb",
+  "llvm.aarch64.sve.eorv",
+  "llvm.aarch64.sve.ext",
+  "llvm.aarch64.sve.fabd",
+  "llvm.aarch64.sve.fabs",
+  "llvm.aarch64.sve.facge",
+  "llvm.aarch64.sve.facgt",
+  "llvm.aarch64.sve.fadd",
+  "llvm.aarch64.sve.fadda",
+  "llvm.aarch64.sve.faddp",
+  "llvm.aarch64.sve.faddv",
+  "llvm.aarch64.sve.fcadd",
+  "llvm.aarch64.sve.fcmla",
+  "llvm.aarch64.sve.fcmla.lane",
+  "llvm.aarch64.sve.fcmpeq",
+  "llvm.aarch64.sve.fcmpge",
+  "llvm.aarch64.sve.fcmpgt",
+  "llvm.aarch64.sve.fcmpne",
+  "llvm.aarch64.sve.fcmpuo",
+  "llvm.aarch64.sve.fcvt",
+  "llvm.aarch64.sve.fcvt.bf16f32",
+  "llvm.aarch64.sve.fcvt.f16f32",
+  "llvm.aarch64.sve.fcvt.f16f64",
+  "llvm.aarch64.sve.fcvt.f32f16",
+  "llvm.aarch64.sve.fcvt.f32f64",
+  "llvm.aarch64.sve.fcvt.f64f16",
+  "llvm.aarch64.sve.fcvt.f64f32",
+  "llvm.aarch64.sve.fcvtlt.f32f16",
+  "llvm.aarch64.sve.fcvtlt.f64f32",
+  "llvm.aarch64.sve.fcvtnt.bf16f32",
+  "llvm.aarch64.sve.fcvtnt.f16f32",
+  "llvm.aarch64.sve.fcvtnt.f32f64",
+  "llvm.aarch64.sve.fcvtx.f32f64",
+  "llvm.aarch64.sve.fcvtxnt.f32f64",
+  "llvm.aarch64.sve.fcvtzs",
+  "llvm.aarch64.sve.fcvtzs.i32f16",
+  "llvm.aarch64.sve.fcvtzs.i32f64",
+  "llvm.aarch64.sve.fcvtzs.i64f16",
+  "llvm.aarch64.sve.fcvtzs.i64f32",
+  "llvm.aarch64.sve.fcvtzu",
+  "llvm.aarch64.sve.fcvtzu.i32f16",
+  "llvm.aarch64.sve.fcvtzu.i32f64",
+  "llvm.aarch64.sve.fcvtzu.i64f16",
+  "llvm.aarch64.sve.fcvtzu.i64f32",
+  "llvm.aarch64.sve.fdiv",
+  "llvm.aarch64.sve.fdivr",
+  "llvm.aarch64.sve.fexpa.x",
+  "llvm.aarch64.sve.flogb",
+  "llvm.aarch64.sve.fmad",
+  "llvm.aarch64.sve.fmax",
+  "llvm.aarch64.sve.fmaxnm",
+  "llvm.aarch64.sve.fmaxnmp",
+  "llvm.aarch64.sve.fmaxnmv",
+  "llvm.aarch64.sve.fmaxp",
+  "llvm.aarch64.sve.fmaxv",
+  "llvm.aarch64.sve.fmin",
+  "llvm.aarch64.sve.fminnm",
+  "llvm.aarch64.sve.fminnmp",
+  "llvm.aarch64.sve.fminnmv",
+  "llvm.aarch64.sve.fminp",
+  "llvm.aarch64.sve.fminv",
+  "llvm.aarch64.sve.fmla",
+  "llvm.aarch64.sve.fmla.lane",
+  "llvm.aarch64.sve.fmlalb",
+  "llvm.aarch64.sve.fmlalb.lane",
+  "llvm.aarch64.sve.fmlalt",
+  "llvm.aarch64.sve.fmlalt.lane",
+  "llvm.aarch64.sve.fmls",
+  "llvm.aarch64.sve.fmls.lane",
+  "llvm.aarch64.sve.fmlslb",
+  "llvm.aarch64.sve.fmlslb.lane",
+  "llvm.aarch64.sve.fmlslt",
+  "llvm.aarch64.sve.fmlslt.lane",
+  "llvm.aarch64.sve.fmmla",
+  "llvm.aarch64.sve.fmsb",
+  "llvm.aarch64.sve.fmul",
+  "llvm.aarch64.sve.fmul.lane",
+  "llvm.aarch64.sve.fmulx",
+  "llvm.aarch64.sve.fneg",
+  "llvm.aarch64.sve.fnmad",
+  "llvm.aarch64.sve.fnmla",
+  "llvm.aarch64.sve.fnmls",
+  "llvm.aarch64.sve.fnmsb",
+  "llvm.aarch64.sve.frecpe.x",
+  "llvm.aarch64.sve.frecps.x",
+  "llvm.aarch64.sve.frecpx",
+  "llvm.aarch64.sve.frinta",
+  "llvm.aarch64.sve.frinti",
+  "llvm.aarch64.sve.frintm",
+  "llvm.aarch64.sve.frintn",
+  "llvm.aarch64.sve.frintp",
+  "llvm.aarch64.sve.frintx",
+  "llvm.aarch64.sve.frintz",
+  "llvm.aarch64.sve.frsqrte.x",
+  "llvm.aarch64.sve.frsqrts.x",
+  "llvm.aarch64.sve.fscale",
+  "llvm.aarch64.sve.fsqrt",
+  "llvm.aarch64.sve.fsub",
+  "llvm.aarch64.sve.fsubr",
+  "llvm.aarch64.sve.ftmad.x",
+  "llvm.aarch64.sve.ftsmul.x",
+  "llvm.aarch64.sve.ftssel.x",
+  "llvm.aarch64.sve.histcnt",
+  "llvm.aarch64.sve.histseg",
+  "llvm.aarch64.sve.index",
+  "llvm.aarch64.sve.insr",
+  "llvm.aarch64.sve.lasta",
+  "llvm.aarch64.sve.lastb",
+  "llvm.aarch64.sve.ld1",
+  "llvm.aarch64.sve.ld1.gather",
+  "llvm.aarch64.sve.ld1.gather.index",
+  "llvm.aarch64.sve.ld1.gather.scalar.offset",
+  "llvm.aarch64.sve.ld1.gather.sxtw",
+  "llvm.aarch64.sve.ld1.gather.sxtw.index",
+  "llvm.aarch64.sve.ld1.gather.uxtw",
+  "llvm.aarch64.sve.ld1.gather.uxtw.index",
+  "llvm.aarch64.sve.ld1ro",
+  "llvm.aarch64.sve.ld1rq",
+  "llvm.aarch64.sve.ld2",
+  "llvm.aarch64.sve.ld3",
+  "llvm.aarch64.sve.ld4",
+  "llvm.aarch64.sve.ldff1",
+  "llvm.aarch64.sve.ldff1.gather",
+  "llvm.aarch64.sve.ldff1.gather.index",
+  "llvm.aarch64.sve.ldff1.gather.scalar.offset",
+  "llvm.aarch64.sve.ldff1.gather.sxtw",
+  "llvm.aarch64.sve.ldff1.gather.sxtw.index",
+  "llvm.aarch64.sve.ldff1.gather.uxtw",
+  "llvm.aarch64.sve.ldff1.gather.uxtw.index",
+  "llvm.aarch64.sve.ldnf1",
+  "llvm.aarch64.sve.ldnt1",
+  "llvm.aarch64.sve.ldnt1.gather",
+  "llvm.aarch64.sve.ldnt1.gather.index",
+  "llvm.aarch64.sve.ldnt1.gather.scalar.offset",
+  "llvm.aarch64.sve.ldnt1.gather.uxtw",
+  "llvm.aarch64.sve.lsl",
+  "llvm.aarch64.sve.lsl.wide",
+  "llvm.aarch64.sve.lsr",
+  "llvm.aarch64.sve.lsr.wide",
+  "llvm.aarch64.sve.mad",
+  "llvm.aarch64.sve.match",
+  "llvm.aarch64.sve.mla",
+  "llvm.aarch64.sve.mla.lane",
+  "llvm.aarch64.sve.mls",
+  "llvm.aarch64.sve.mls.lane",
+  "llvm.aarch64.sve.msb",
+  "llvm.aarch64.sve.mul",
+  "llvm.aarch64.sve.mul.lane",
+  "llvm.aarch64.sve.nand.z",
+  "llvm.aarch64.sve.nbsl",
+  "llvm.aarch64.sve.neg",
+  "llvm.aarch64.sve.nmatch",
+  "llvm.aarch64.sve.nor.z",
+  "llvm.aarch64.sve.not",
+  "llvm.aarch64.sve.orn.z",
+  "llvm.aarch64.sve.orr",
+  "llvm.aarch64.sve.orr.z",
+  "llvm.aarch64.sve.orv",
+  "llvm.aarch64.sve.pfirst",
+  "llvm.aarch64.sve.pmul",
+  "llvm.aarch64.sve.pmullb.pair",
+  "llvm.aarch64.sve.pmullt.pair",
+  "llvm.aarch64.sve.pnext",
+  "llvm.aarch64.sve.prf",
+  "llvm.aarch64.sve.prfb.gather.index",
+  "llvm.aarch64.sve.prfb.gather.scalar.offset",
+  "llvm.aarch64.sve.prfb.gather.sxtw.index",
+  "llvm.aarch64.sve.prfb.gather.uxtw.index",
+  "llvm.aarch64.sve.prfd.gather.index",
+  "llvm.aarch64.sve.prfd.gather.scalar.offset",
+  "llvm.aarch64.sve.prfd.gather.sxtw.index",
+  "llvm.aarch64.sve.prfd.gather.uxtw.index",
+  "llvm.aarch64.sve.prfh.gather.index",
+  "llvm.aarch64.sve.prfh.gather.scalar.offset",
+  "llvm.aarch64.sve.prfh.gather.sxtw.index",
+  "llvm.aarch64.sve.prfh.gather.uxtw.index",
+  "llvm.aarch64.sve.prfw.gather.index",
+  "llvm.aarch64.sve.prfw.gather.scalar.offset",
+  "llvm.aarch64.sve.prfw.gather.sxtw.index",
+  "llvm.aarch64.sve.prfw.gather.uxtw.index",
+  "llvm.aarch64.sve.ptest.any",
+  "llvm.aarch64.sve.ptest.first",
+  "llvm.aarch64.sve.ptest.last",
+  "llvm.aarch64.sve.ptrue",
+  "llvm.aarch64.sve.punpkhi",
+  "llvm.aarch64.sve.punpklo",
+  "llvm.aarch64.sve.raddhnb",
+  "llvm.aarch64.sve.raddhnt",
+  "llvm.aarch64.sve.rax1",
+  "llvm.aarch64.sve.rbit",
+  "llvm.aarch64.sve.rdffr",
+  "llvm.aarch64.sve.rdffr.z",
+  "llvm.aarch64.sve.rev",
+  "llvm.aarch64.sve.revb",
+  "llvm.aarch64.sve.revh",
+  "llvm.aarch64.sve.revw",
+  "llvm.aarch64.sve.rshrnb",
+  "llvm.aarch64.sve.rshrnt",
+  "llvm.aarch64.sve.rsubhnb",
+  "llvm.aarch64.sve.rsubhnt",
+  "llvm.aarch64.sve.saba",
+  "llvm.aarch64.sve.sabalb",
+  "llvm.aarch64.sve.sabalt",
+  "llvm.aarch64.sve.sabd",
+  "llvm.aarch64.sve.sabdlb",
+  "llvm.aarch64.sve.sabdlt",
+  "llvm.aarch64.sve.sadalp",
+  "llvm.aarch64.sve.saddlb",
+  "llvm.aarch64.sve.saddlbt",
+  "llvm.aarch64.sve.saddlt",
+  "llvm.aarch64.sve.saddv",
+  "llvm.aarch64.sve.saddwb",
+  "llvm.aarch64.sve.saddwt",
+  "llvm.aarch64.sve.sbclb",
+  "llvm.aarch64.sve.sbclt",
+  "llvm.aarch64.sve.scvtf",
+  "llvm.aarch64.sve.scvtf.f16i32",
+  "llvm.aarch64.sve.scvtf.f16i64",
+  "llvm.aarch64.sve.scvtf.f32i64",
+  "llvm.aarch64.sve.scvtf.f64i32",
+  "llvm.aarch64.sve.sdiv",
+  "llvm.aarch64.sve.sdivr",
+  "llvm.aarch64.sve.sdot",
+  "llvm.aarch64.sve.sdot.lane",
+  "llvm.aarch64.sve.sel",
+  "llvm.aarch64.sve.setffr",
+  "llvm.aarch64.sve.shadd",
+  "llvm.aarch64.sve.shrnb",
+  "llvm.aarch64.sve.shrnt",
+  "llvm.aarch64.sve.shsub",
+  "llvm.aarch64.sve.shsubr",
+  "llvm.aarch64.sve.sli",
+  "llvm.aarch64.sve.sm4e",
+  "llvm.aarch64.sve.sm4ekey",
+  "llvm.aarch64.sve.smax",
+  "llvm.aarch64.sve.smaxp",
+  "llvm.aarch64.sve.smaxv",
+  "llvm.aarch64.sve.smin",
+  "llvm.aarch64.sve.sminp",
+  "llvm.aarch64.sve.sminv",
+  "llvm.aarch64.sve.smlalb",
+  "llvm.aarch64.sve.smlalb.lane",
+  "llvm.aarch64.sve.smlalt",
+  "llvm.aarch64.sve.smlalt.lane",
+  "llvm.aarch64.sve.smlslb",
+  "llvm.aarch64.sve.smlslb.lane",
+  "llvm.aarch64.sve.smlslt",
+  "llvm.aarch64.sve.smlslt.lane",
+  "llvm.aarch64.sve.smmla",
+  "llvm.aarch64.sve.smulh",
+  "llvm.aarch64.sve.smullb",
+  "llvm.aarch64.sve.smullb.lane",
+  "llvm.aarch64.sve.smullt",
+  "llvm.aarch64.sve.smullt.lane",
+  "llvm.aarch64.sve.splice",
+  "llvm.aarch64.sve.sqabs",
+  "llvm.aarch64.sve.sqadd",
+  "llvm.aarch64.sve.sqadd.x",
+  "llvm.aarch64.sve.sqcadd.x",
+  "llvm.aarch64.sve.sqdecb.n32",
+  "llvm.aarch64.sve.sqdecb.n64",
+  "llvm.aarch64.sve.sqdecd",
+  "llvm.aarch64.sve.sqdecd.n32",
+  "llvm.aarch64.sve.sqdecd.n64",
+  "llvm.aarch64.sve.sqdech",
+  "llvm.aarch64.sve.sqdech.n32",
+  "llvm.aarch64.sve.sqdech.n64",
+  "llvm.aarch64.sve.sqdecp",
+  "llvm.aarch64.sve.sqdecp.n32",
+  "llvm.aarch64.sve.sqdecp.n64",
+  "llvm.aarch64.sve.sqdecw",
+  "llvm.aarch64.sve.sqdecw.n32",
+  "llvm.aarch64.sve.sqdecw.n64",
+  "llvm.aarch64.sve.sqdmlalb",
+  "llvm.aarch64.sve.sqdmlalb.lane",
+  "llvm.aarch64.sve.sqdmlalbt",
+  "llvm.aarch64.sve.sqdmlalt",
+  "llvm.aarch64.sve.sqdmlalt.lane",
+  "llvm.aarch64.sve.sqdmlslb",
+  "llvm.aarch64.sve.sqdmlslb.lane",
+  "llvm.aarch64.sve.sqdmlslbt",
+  "llvm.aarch64.sve.sqdmlslt",
+  "llvm.aarch64.sve.sqdmlslt.lane",
+  "llvm.aarch64.sve.sqdmulh",
+  "llvm.aarch64.sve.sqdmulh.lane",
+  "llvm.aarch64.sve.sqdmullb",
+  "llvm.aarch64.sve.sqdmullb.lane",
+  "llvm.aarch64.sve.sqdmullt",
+  "llvm.aarch64.sve.sqdmullt.lane",
+  "llvm.aarch64.sve.sqincb.n32",
+  "llvm.aarch64.sve.sqincb.n64",
+  "llvm.aarch64.sve.sqincd",
+  "llvm.aarch64.sve.sqincd.n32",
+  "llvm.aarch64.sve.sqincd.n64",
+  "llvm.aarch64.sve.sqinch",
+  "llvm.aarch64.sve.sqinch.n32",
+  "llvm.aarch64.sve.sqinch.n64",
+  "llvm.aarch64.sve.sqincp",
+  "llvm.aarch64.sve.sqincp.n32",
+  "llvm.aarch64.sve.sqincp.n64",
+  "llvm.aarch64.sve.sqincw",
+  "llvm.aarch64.sve.sqincw.n32",
+  "llvm.aarch64.sve.sqincw.n64",
+  "llvm.aarch64.sve.sqneg",
+  "llvm.aarch64.sve.sqrdcmlah.lane.x",
+  "llvm.aarch64.sve.sqrdcmlah.x",
+  "llvm.aarch64.sve.sqrdmlah",
+  "llvm.aarch64.sve.sqrdmlah.lane",
+  "llvm.aarch64.sve.sqrdmlsh",
+  "llvm.aarch64.sve.sqrdmlsh.lane",
+  "llvm.aarch64.sve.sqrdmulh",
+  "llvm.aarch64.sve.sqrdmulh.lane",
+  "llvm.aarch64.sve.sqrshl",
+  "llvm.aarch64.sve.sqrshrnb",
+  "llvm.aarch64.sve.sqrshrnt",
+  "llvm.aarch64.sve.sqrshrunb",
+  "llvm.aarch64.sve.sqrshrunt",
+  "llvm.aarch64.sve.sqshl",
+  "llvm.aarch64.sve.sqshlu",
+  "llvm.aarch64.sve.sqshrnb",
+  "llvm.aarch64.sve.sqshrnt",
+  "llvm.aarch64.sve.sqshrunb",
+  "llvm.aarch64.sve.sqshrunt",
+  "llvm.aarch64.sve.sqsub",
+  "llvm.aarch64.sve.sqsub.x",
+  "llvm.aarch64.sve.sqsubr",
+  "llvm.aarch64.sve.sqxtnb",
+  "llvm.aarch64.sve.sqxtnt",
+  "llvm.aarch64.sve.sqxtunb",
+  "llvm.aarch64.sve.sqxtunt",
+  "llvm.aarch64.sve.srhadd",
+  "llvm.aarch64.sve.sri",
+  "llvm.aarch64.sve.srshl",
+  "llvm.aarch64.sve.srshr",
+  "llvm.aarch64.sve.srsra",
+  "llvm.aarch64.sve.sshllb",
+  "llvm.aarch64.sve.sshllt",
+  "llvm.aarch64.sve.ssra",
+  "llvm.aarch64.sve.ssublb",
+  "llvm.aarch64.sve.ssublbt",
+  "llvm.aarch64.sve.ssublt",
+  "llvm.aarch64.sve.ssubltb",
+  "llvm.aarch64.sve.ssubwb",
+  "llvm.aarch64.sve.ssubwt",
+  "llvm.aarch64.sve.st1",
+  "llvm.aarch64.sve.st1.scatter",
+  "llvm.aarch64.sve.st1.scatter.index",
+  "llvm.aarch64.sve.st1.scatter.scalar.offset",
+  "llvm.aarch64.sve.st1.scatter.sxtw",
+  "llvm.aarch64.sve.st1.scatter.sxtw.index",
+  "llvm.aarch64.sve.st1.scatter.uxtw",
+  "llvm.aarch64.sve.st1.scatter.uxtw.index",
+  "llvm.aarch64.sve.st2",
+  "llvm.aarch64.sve.st3",
+  "llvm.aarch64.sve.st4",
+  "llvm.aarch64.sve.stnt1",
+  "llvm.aarch64.sve.stnt1.scatter",
+  "llvm.aarch64.sve.stnt1.scatter.index",
+  "llvm.aarch64.sve.stnt1.scatter.scalar.offset",
+  "llvm.aarch64.sve.stnt1.scatter.uxtw",
+  "llvm.aarch64.sve.sub",
+  "llvm.aarch64.sve.subhnb",
+  "llvm.aarch64.sve.subhnt",
+  "llvm.aarch64.sve.subr",
+  "llvm.aarch64.sve.sudot.lane",
+  "llvm.aarch64.sve.sunpkhi",
+  "llvm.aarch64.sve.sunpklo",
+  "llvm.aarch64.sve.suqadd",
+  "llvm.aarch64.sve.sxtb",
+  "llvm.aarch64.sve.sxth",
+  "llvm.aarch64.sve.sxtw",
+  "llvm.aarch64.sve.tbl",
+  "llvm.aarch64.sve.tbl2",
+  "llvm.aarch64.sve.tbx",
+  "llvm.aarch64.sve.trn1",
+  "llvm.aarch64.sve.trn1q",
+  "llvm.aarch64.sve.trn2",
+  "llvm.aarch64.sve.trn2q",
+  "llvm.aarch64.sve.tuple.create2",
+  "llvm.aarch64.sve.tuple.create3",
+  "llvm.aarch64.sve.tuple.create4",
+  "llvm.aarch64.sve.tuple.get",
+  "llvm.aarch64.sve.tuple.set",
+  "llvm.aarch64.sve.uaba",
+  "llvm.aarch64.sve.uabalb",
+  "llvm.aarch64.sve.uabalt",
+  "llvm.aarch64.sve.uabd",
+  "llvm.aarch64.sve.uabdlb",
+  "llvm.aarch64.sve.uabdlt",
+  "llvm.aarch64.sve.uadalp",
+  "llvm.aarch64.sve.uaddlb",
+  "llvm.aarch64.sve.uaddlt",
+  "llvm.aarch64.sve.uaddv",
+  "llvm.aarch64.sve.uaddwb",
+  "llvm.aarch64.sve.uaddwt",
+  "llvm.aarch64.sve.ucvtf",
+  "llvm.aarch64.sve.ucvtf.f16i32",
+  "llvm.aarch64.sve.ucvtf.f16i64",
+  "llvm.aarch64.sve.ucvtf.f32i64",
+  "llvm.aarch64.sve.ucvtf.f64i32",
+  "llvm.aarch64.sve.udiv",
+  "llvm.aarch64.sve.udivr",
+  "llvm.aarch64.sve.udot",
+  "llvm.aarch64.sve.udot.lane",
+  "llvm.aarch64.sve.uhadd",
+  "llvm.aarch64.sve.uhsub",
+  "llvm.aarch64.sve.uhsubr",
+  "llvm.aarch64.sve.umax",
+  "llvm.aarch64.sve.umaxp",
+  "llvm.aarch64.sve.umaxv",
+  "llvm.aarch64.sve.umin",
+  "llvm.aarch64.sve.uminp",
+  "llvm.aarch64.sve.uminv",
+  "llvm.aarch64.sve.umlalb",
+  "llvm.aarch64.sve.umlalb.lane",
+  "llvm.aarch64.sve.umlalt",
+  "llvm.aarch64.sve.umlalt.lane",
+  "llvm.aarch64.sve.umlslb",
+  "llvm.aarch64.sve.umlslb.lane",
+  "llvm.aarch64.sve.umlslt",
+  "llvm.aarch64.sve.umlslt.lane",
+  "llvm.aarch64.sve.ummla",
+  "llvm.aarch64.sve.umulh",
+  "llvm.aarch64.sve.umullb",
+  "llvm.aarch64.sve.umullb.lane",
+  "llvm.aarch64.sve.umullt",
+  "llvm.aarch64.sve.umullt.lane",
+  "llvm.aarch64.sve.uqadd",
+  "llvm.aarch64.sve.uqadd.x",
+  "llvm.aarch64.sve.uqdecb.n32",
+  "llvm.aarch64.sve.uqdecb.n64",
+  "llvm.aarch64.sve.uqdecd",
+  "llvm.aarch64.sve.uqdecd.n32",
+  "llvm.aarch64.sve.uqdecd.n64",
+  "llvm.aarch64.sve.uqdech",
+  "llvm.aarch64.sve.uqdech.n32",
+  "llvm.aarch64.sve.uqdech.n64",
+  "llvm.aarch64.sve.uqdecp",
+  "llvm.aarch64.sve.uqdecp.n32",
+  "llvm.aarch64.sve.uqdecp.n64",
+  "llvm.aarch64.sve.uqdecw",
+  "llvm.aarch64.sve.uqdecw.n32",
+  "llvm.aarch64.sve.uqdecw.n64",
+  "llvm.aarch64.sve.uqincb.n32",
+  "llvm.aarch64.sve.uqincb.n64",
+  "llvm.aarch64.sve.uqincd",
+  "llvm.aarch64.sve.uqincd.n32",
+  "llvm.aarch64.sve.uqincd.n64",
+  "llvm.aarch64.sve.uqinch",
+  "llvm.aarch64.sve.uqinch.n32",
+  "llvm.aarch64.sve.uqinch.n64",
+  "llvm.aarch64.sve.uqincp",
+  "llvm.aarch64.sve.uqincp.n32",
+  "llvm.aarch64.sve.uqincp.n64",
+  "llvm.aarch64.sve.uqincw",
+  "llvm.aarch64.sve.uqincw.n32",
+  "llvm.aarch64.sve.uqincw.n64",
+  "llvm.aarch64.sve.uqrshl",
+  "llvm.aarch64.sve.uqrshrnb",
+  "llvm.aarch64.sve.uqrshrnt",
+  "llvm.aarch64.sve.uqshl",
+  "llvm.aarch64.sve.uqshrnb",
+  "llvm.aarch64.sve.uqshrnt",
+  "llvm.aarch64.sve.uqsub",
+  "llvm.aarch64.sve.uqsub.x",
+  "llvm.aarch64.sve.uqsubr",
+  "llvm.aarch64.sve.uqxtnb",
+  "llvm.aarch64.sve.uqxtnt",
+  "llvm.aarch64.sve.urecpe",
+  "llvm.aarch64.sve.urhadd",
+  "llvm.aarch64.sve.urshl",
+  "llvm.aarch64.sve.urshr",
+  "llvm.aarch64.sve.ursqrte",
+  "llvm.aarch64.sve.ursra",
+  "llvm.aarch64.sve.usdot",
+  "llvm.aarch64.sve.usdot.lane",
+  "llvm.aarch64.sve.ushllb",
+  "llvm.aarch64.sve.ushllt",
+  "llvm.aarch64.sve.usmmla",
+  "llvm.aarch64.sve.usqadd",
+  "llvm.aarch64.sve.usra",
+  "llvm.aarch64.sve.usublb",
+  "llvm.aarch64.sve.usublt",
+  "llvm.aarch64.sve.usubwb",
+  "llvm.aarch64.sve.usubwt",
+  "llvm.aarch64.sve.uunpkhi",
+  "llvm.aarch64.sve.uunpklo",
+  "llvm.aarch64.sve.uxtb",
+  "llvm.aarch64.sve.uxth",
+  "llvm.aarch64.sve.uxtw",
+  "llvm.aarch64.sve.uzp1",
+  "llvm.aarch64.sve.uzp1q",
+  "llvm.aarch64.sve.uzp2",
+  "llvm.aarch64.sve.uzp2q",
+  "llvm.aarch64.sve.whilege",
+  "llvm.aarch64.sve.whilegt",
+  "llvm.aarch64.sve.whilehi",
+  "llvm.aarch64.sve.whilehs",
+  "llvm.aarch64.sve.whilele",
+  "llvm.aarch64.sve.whilelo",
+  "llvm.aarch64.sve.whilels",
+  "llvm.aarch64.sve.whilelt",
+  "llvm.aarch64.sve.whilerw.b",
+  "llvm.aarch64.sve.whilerw.d",
+  "llvm.aarch64.sve.whilerw.h",
+  "llvm.aarch64.sve.whilerw.s",
+  "llvm.aarch64.sve.whilewr.b",
+  "llvm.aarch64.sve.whilewr.d",
+  "llvm.aarch64.sve.whilewr.h",
+  "llvm.aarch64.sve.whilewr.s",
+  "llvm.aarch64.sve.wrffr",
+  "llvm.aarch64.sve.xar",
+  "llvm.aarch64.sve.zip1",
+  "llvm.aarch64.sve.zip1q",
+  "llvm.aarch64.sve.zip2",
+  "llvm.aarch64.sve.zip2q",
+  "llvm.aarch64.tagp",
+  "llvm.aarch64.tcancel",
+  "llvm.aarch64.tcommit",
+  "llvm.aarch64.tstart",
+  "llvm.aarch64.ttest",
   "llvm.aarch64.udiv",
   "llvm.amdgcn.alignbit",
   "llvm.amdgcn.alignbyte",
   "llvm.amdgcn.atomic.dec",
   "llvm.amdgcn.atomic.inc",
+  "llvm.amdgcn.ballot",
   "llvm.amdgcn.buffer.atomic.add",
   "llvm.amdgcn.buffer.atomic.and",
   "llvm.amdgcn.buffer.atomic.cmpswap",
+  "llvm.amdgcn.buffer.atomic.csub",
+  "llvm.amdgcn.buffer.atomic.fadd",
   "llvm.amdgcn.buffer.atomic.or",
   "llvm.amdgcn.buffer.atomic.smax",
   "llvm.amdgcn.buffer.atomic.smin",
@@ -547,17 +1255,21 @@
   "llvm.amdgcn.ds.swizzle",
   "llvm.amdgcn.else",
   "llvm.amdgcn.end.cf",
+  "llvm.amdgcn.endpgm",
   "llvm.amdgcn.exp",
   "llvm.amdgcn.exp.compr",
   "llvm.amdgcn.fcmp",
   "llvm.amdgcn.fdiv.fast",
   "llvm.amdgcn.fdot2",
+  "llvm.amdgcn.fma.legacy",
   "llvm.amdgcn.fmad.ftz",
   "llvm.amdgcn.fmed3",
   "llvm.amdgcn.fmul.legacy",
   "llvm.amdgcn.fract",
   "llvm.amdgcn.frexp.exp",
   "llvm.amdgcn.frexp.mant",
+  "llvm.amdgcn.global.atomic.csub",
+  "llvm.amdgcn.global.atomic.fadd",
   "llvm.amdgcn.groupstaticsize",
   "llvm.amdgcn.icmp",
   "llvm.amdgcn.if",
@@ -666,6 +1378,7 @@
   "llvm.amdgcn.image.atomic.xor.2dmsaa",
   "llvm.amdgcn.image.atomic.xor.3d",
   "llvm.amdgcn.image.atomic.xor.cube",
+  "llvm.amdgcn.image.bvh.intersect.ray",
   "llvm.amdgcn.image.gather4.2d",
   "llvm.amdgcn.image.gather4.2darray",
   "llvm.amdgcn.image.gather4.b.2d",
@@ -766,6 +1479,14 @@
   "llvm.amdgcn.image.load.mip.2darray",
   "llvm.amdgcn.image.load.mip.3d",
   "llvm.amdgcn.image.load.mip.cube",
+  "llvm.amdgcn.image.msaa.load.1d",
+  "llvm.amdgcn.image.msaa.load.1darray",
+  "llvm.amdgcn.image.msaa.load.2d",
+  "llvm.amdgcn.image.msaa.load.2darray",
+  "llvm.amdgcn.image.msaa.load.2darraymsaa",
+  "llvm.amdgcn.image.msaa.load.2dmsaa",
+  "llvm.amdgcn.image.msaa.load.3d",
+  "llvm.amdgcn.image.msaa.load.cube",
   "llvm.amdgcn.image.sample.1d",
   "llvm.amdgcn.image.sample.1darray",
   "llvm.amdgcn.image.sample.2d",
@@ -1029,6 +1750,8 @@
   "llvm.amdgcn.interp.p1.f16",
   "llvm.amdgcn.interp.p2",
   "llvm.amdgcn.interp.p2.f16",
+  "llvm.amdgcn.is.private",
+  "llvm.amdgcn.is.shared",
   "llvm.amdgcn.kernarg.segment.ptr",
   "llvm.amdgcn.kill",
   "llvm.amdgcn.ldexp",
@@ -1062,6 +1785,8 @@
   "llvm.amdgcn.mqsad.pk.u16.u8",
   "llvm.amdgcn.mqsad.u32.u8",
   "llvm.amdgcn.msad.u8",
+  "llvm.amdgcn.mul.i24",
+  "llvm.amdgcn.mul.u24",
   "llvm.amdgcn.permlane16",
   "llvm.amdgcn.permlanex16",
   "llvm.amdgcn.ps.live",
@@ -1070,6 +1795,9 @@
   "llvm.amdgcn.raw.buffer.atomic.add",
   "llvm.amdgcn.raw.buffer.atomic.and",
   "llvm.amdgcn.raw.buffer.atomic.cmpswap",
+  "llvm.amdgcn.raw.buffer.atomic.dec",
+  "llvm.amdgcn.raw.buffer.atomic.fadd",
+  "llvm.amdgcn.raw.buffer.atomic.inc",
   "llvm.amdgcn.raw.buffer.atomic.or",
   "llvm.amdgcn.raw.buffer.atomic.smax",
   "llvm.amdgcn.raw.buffer.atomic.smin",
@@ -1088,6 +1816,7 @@
   "llvm.amdgcn.rcp.legacy",
   "llvm.amdgcn.readfirstlane",
   "llvm.amdgcn.readlane",
+  "llvm.amdgcn.reloc.constant",
   "llvm.amdgcn.rsq",
   "llvm.amdgcn.rsq.clamp",
   "llvm.amdgcn.rsq.legacy",
@@ -1106,6 +1835,7 @@
   "llvm.amdgcn.s.memtime",
   "llvm.amdgcn.s.sendmsg",
   "llvm.amdgcn.s.sendmsghalt",
+  "llvm.amdgcn.s.setreg",
   "llvm.amdgcn.s.sleep",
   "llvm.amdgcn.s.waitcnt",
   "llvm.amdgcn.sad.hi.u8",
@@ -1118,9 +1848,14 @@
   "llvm.amdgcn.set.inactive",
   "llvm.amdgcn.sffbh",
   "llvm.amdgcn.sin",
+  "llvm.amdgcn.softwqm",
+  "llvm.amdgcn.sqrt",
   "llvm.amdgcn.struct.buffer.atomic.add",
   "llvm.amdgcn.struct.buffer.atomic.and",
   "llvm.amdgcn.struct.buffer.atomic.cmpswap",
+  "llvm.amdgcn.struct.buffer.atomic.dec",
+  "llvm.amdgcn.struct.buffer.atomic.fadd",
+  "llvm.amdgcn.struct.buffer.atomic.inc",
   "llvm.amdgcn.struct.buffer.atomic.or",
   "llvm.amdgcn.struct.buffer.atomic.smax",
   "llvm.amdgcn.struct.buffer.atomic.smin",
@@ -1156,9 +1891,41 @@
   "llvm.amdgcn.wqm.vote",
   "llvm.amdgcn.writelane",
   "llvm.amdgcn.wwm",
+  "llvm.arm.cde.cx1",
+  "llvm.arm.cde.cx1a",
+  "llvm.arm.cde.cx1d",
+  "llvm.arm.cde.cx1da",
+  "llvm.arm.cde.cx2",
+  "llvm.arm.cde.cx2a",
+  "llvm.arm.cde.cx2d",
+  "llvm.arm.cde.cx2da",
+  "llvm.arm.cde.cx3",
+  "llvm.arm.cde.cx3a",
+  "llvm.arm.cde.cx3d",
+  "llvm.arm.cde.cx3da",
+  "llvm.arm.cde.vcx1",
+  "llvm.arm.cde.vcx1a",
+  "llvm.arm.cde.vcx1q",
+  "llvm.arm.cde.vcx1q.predicated",
+  "llvm.arm.cde.vcx1qa",
+  "llvm.arm.cde.vcx1qa.predicated",
+  "llvm.arm.cde.vcx2",
+  "llvm.arm.cde.vcx2a",
+  "llvm.arm.cde.vcx2q",
+  "llvm.arm.cde.vcx2q.predicated",
+  "llvm.arm.cde.vcx2qa",
+  "llvm.arm.cde.vcx2qa.predicated",
+  "llvm.arm.cde.vcx3",
+  "llvm.arm.cde.vcx3a",
+  "llvm.arm.cde.vcx3q",
+  "llvm.arm.cde.vcx3q.predicated",
+  "llvm.arm.cde.vcx3qa",
+  "llvm.arm.cde.vcx3qa.predicated",
   "llvm.arm.cdp",
   "llvm.arm.cdp2",
   "llvm.arm.clrex",
+  "llvm.arm.cls",
+  "llvm.arm.cls64",
   "llvm.arm.cmse.tt",
   "llvm.arm.cmse.tta",
   "llvm.arm.cmse.ttat",
@@ -1192,10 +1959,207 @@
   "llvm.arm.mrc2",
   "llvm.arm.mrrc",
   "llvm.arm.mrrc2",
+  "llvm.arm.mve.abd.predicated",
+  "llvm.arm.mve.abs.predicated",
+  "llvm.arm.mve.add.predicated",
+  "llvm.arm.mve.addlv",
+  "llvm.arm.mve.addlv.predicated",
+  "llvm.arm.mve.addv",
+  "llvm.arm.mve.addv.predicated",
+  "llvm.arm.mve.and.predicated",
+  "llvm.arm.mve.asrl",
+  "llvm.arm.mve.bic.predicated",
+  "llvm.arm.mve.cls.predicated",
+  "llvm.arm.mve.clz.predicated",
+  "llvm.arm.mve.eor.predicated",
+  "llvm.arm.mve.fma.predicated",
+  "llvm.arm.mve.hadd.predicated",
+  "llvm.arm.mve.hsub.predicated",
+  "llvm.arm.mve.lsll",
+  "llvm.arm.mve.max.predicated",
+  "llvm.arm.mve.maxav",
+  "llvm.arm.mve.maxav.predicated",
+  "llvm.arm.mve.maxnmav",
+  "llvm.arm.mve.maxnmav.predicated",
+  "llvm.arm.mve.maxnmv",
+  "llvm.arm.mve.maxnmv.predicated",
+  "llvm.arm.mve.maxv",
+  "llvm.arm.mve.maxv.predicated",
+  "llvm.arm.mve.min.predicated",
+  "llvm.arm.mve.minav",
+  "llvm.arm.mve.minav.predicated",
+  "llvm.arm.mve.minnmav",
+  "llvm.arm.mve.minnmav.predicated",
+  "llvm.arm.mve.minnmv",
+  "llvm.arm.mve.minnmv.predicated",
+  "llvm.arm.mve.minv",
+  "llvm.arm.mve.minv.predicated",
+  "llvm.arm.mve.mul.predicated",
+  "llvm.arm.mve.mulh.predicated",
+  "llvm.arm.mve.mull.int.predicated",
+  "llvm.arm.mve.mull.poly.predicated",
+  "llvm.arm.mve.mvn.predicated",
+  "llvm.arm.mve.neg.predicated",
+  "llvm.arm.mve.orn.predicated",
+  "llvm.arm.mve.orr.predicated",
+  "llvm.arm.mve.pred.i2v",
+  "llvm.arm.mve.pred.v2i",
+  "llvm.arm.mve.qabs.predicated",
+  "llvm.arm.mve.qadd.predicated",
+  "llvm.arm.mve.qdmulh.predicated",
+  "llvm.arm.mve.qneg.predicated",
+  "llvm.arm.mve.qrdmulh.predicated",
+  "llvm.arm.mve.qsub.predicated",
+  "llvm.arm.mve.rhadd.predicated",
+  "llvm.arm.mve.rmulh.predicated",
+  "llvm.arm.mve.shl.imm.predicated",
+  "llvm.arm.mve.shr.imm.predicated",
+  "llvm.arm.mve.sqrshr",
+  "llvm.arm.mve.sqrshrl",
+  "llvm.arm.mve.sqshl",
+  "llvm.arm.mve.sqshll",
+  "llvm.arm.mve.srshr",
+  "llvm.arm.mve.srshrl",
+  "llvm.arm.mve.sub.predicated",
+  "llvm.arm.mve.uqrshl",
+  "llvm.arm.mve.uqrshll",
+  "llvm.arm.mve.uqshl",
+  "llvm.arm.mve.uqshll",
+  "llvm.arm.mve.urshr",
+  "llvm.arm.mve.urshrl",
+  "llvm.arm.mve.vabav",
+  "llvm.arm.mve.vabav.predicated",
+  "llvm.arm.mve.vabd",
+  "llvm.arm.mve.vadc",
+  "llvm.arm.mve.vadc.predicated",
+  "llvm.arm.mve.vbrsr",
+  "llvm.arm.mve.vbrsr.predicated",
+  "llvm.arm.mve.vcaddq",
+  "llvm.arm.mve.vcaddq.predicated",
+  "llvm.arm.mve.vcls",
+  "llvm.arm.mve.vcmlaq",
+  "llvm.arm.mve.vcmlaq.predicated",
+  "llvm.arm.mve.vcmulq",
+  "llvm.arm.mve.vcmulq.predicated",
+  "llvm.arm.mve.vctp16",
+  "llvm.arm.mve.vctp32",
+  "llvm.arm.mve.vctp64",
+  "llvm.arm.mve.vctp8",
+  "llvm.arm.mve.vcvt.fix",
+  "llvm.arm.mve.vcvt.fix.predicated",
+  "llvm.arm.mve.vcvt.fp.int.predicated",
+  "llvm.arm.mve.vcvt.narrow",
+  "llvm.arm.mve.vcvt.narrow.predicated",
+  "llvm.arm.mve.vcvt.widen",
+  "llvm.arm.mve.vcvt.widen.predicated",
+  "llvm.arm.mve.vcvta",
+  "llvm.arm.mve.vcvta.predicated",
+  "llvm.arm.mve.vcvtm",
+  "llvm.arm.mve.vcvtm.predicated",
+  "llvm.arm.mve.vcvtn",
+  "llvm.arm.mve.vcvtn.predicated",
+  "llvm.arm.mve.vcvtp",
+  "llvm.arm.mve.vcvtp.predicated",
+  "llvm.arm.mve.vddup",
+  "llvm.arm.mve.vddup.predicated",
+  "llvm.arm.mve.vdwdup",
+  "llvm.arm.mve.vdwdup.predicated",
+  "llvm.arm.mve.vhadd",
+  "llvm.arm.mve.vhsub",
+  "llvm.arm.mve.vidup",
+  "llvm.arm.mve.vidup.predicated",
+  "llvm.arm.mve.viwdup",
+  "llvm.arm.mve.viwdup.predicated",
+  "llvm.arm.mve.vld2q",
+  "llvm.arm.mve.vld4q",
+  "llvm.arm.mve.vldr.gather.base",
+  "llvm.arm.mve.vldr.gather.base.predicated",
+  "llvm.arm.mve.vldr.gather.base.wb",
+  "llvm.arm.mve.vldr.gather.base.wb.predicated",
+  "llvm.arm.mve.vldr.gather.offset",
+  "llvm.arm.mve.vldr.gather.offset.predicated",
+  "llvm.arm.mve.vmaxa.predicated",
+  "llvm.arm.mve.vmaxnma.predicated",
+  "llvm.arm.mve.vmina.predicated",
+  "llvm.arm.mve.vminnma.predicated",
+  "llvm.arm.mve.vmla.n.predicated",
+  "llvm.arm.mve.vmlas.n.predicated",
+  "llvm.arm.mve.vmldava",
+  "llvm.arm.mve.vmldava.predicated",
+  "llvm.arm.mve.vmlldava",
+  "llvm.arm.mve.vmlldava.predicated",
+  "llvm.arm.mve.vmovl.predicated",
+  "llvm.arm.mve.vmovn.predicated",
+  "llvm.arm.mve.vmulh",
+  "llvm.arm.mve.vmull",
+  "llvm.arm.mve.vmull.poly",
+  "llvm.arm.mve.vqdmlad",
+  "llvm.arm.mve.vqdmlad.predicated",
+  "llvm.arm.mve.vqdmlah",
+  "llvm.arm.mve.vqdmlah.predicated",
+  "llvm.arm.mve.vqdmlash",
+  "llvm.arm.mve.vqdmlash.predicated",
+  "llvm.arm.mve.vqdmulh",
+  "llvm.arm.mve.vqdmull",
+  "llvm.arm.mve.vqdmull.predicated",
+  "llvm.arm.mve.vqmovn",
+  "llvm.arm.mve.vqmovn.predicated",
+  "llvm.arm.mve.vqrdmlah",
+  "llvm.arm.mve.vqrdmlah.predicated",
+  "llvm.arm.mve.vqrdmlash",
+  "llvm.arm.mve.vqrdmlash.predicated",
+  "llvm.arm.mve.vqrdmulh",
+  "llvm.arm.mve.vqshl.imm",
+  "llvm.arm.mve.vqshl.imm.predicated",
+  "llvm.arm.mve.vqshlu.imm",
+  "llvm.arm.mve.vqshlu.imm.predicated",
+  "llvm.arm.mve.vreinterpretq",
+  "llvm.arm.mve.vrev.predicated",
+  "llvm.arm.mve.vrhadd",
+  "llvm.arm.mve.vrinta.predicated",
+  "llvm.arm.mve.vrintm.predicated",
+  "llvm.arm.mve.vrintn",
+  "llvm.arm.mve.vrintn.predicated",
+  "llvm.arm.mve.vrintp.predicated",
+  "llvm.arm.mve.vrintx.predicated",
+  "llvm.arm.mve.vrintz.predicated",
+  "llvm.arm.mve.vrmlldavha",
+  "llvm.arm.mve.vrmlldavha.predicated",
+  "llvm.arm.mve.vrmulh",
+  "llvm.arm.mve.vrshr.imm",
+  "llvm.arm.mve.vrshr.imm.predicated",
+  "llvm.arm.mve.vsbc",
+  "llvm.arm.mve.vsbc.predicated",
+  "llvm.arm.mve.vshl.scalar",
+  "llvm.arm.mve.vshl.scalar.predicated",
+  "llvm.arm.mve.vshl.vector",
+  "llvm.arm.mve.vshl.vector.predicated",
+  "llvm.arm.mve.vshlc",
+  "llvm.arm.mve.vshlc.predicated",
+  "llvm.arm.mve.vshll.imm",
+  "llvm.arm.mve.vshll.imm.predicated",
+  "llvm.arm.mve.vshrn",
+  "llvm.arm.mve.vshrn.predicated",
+  "llvm.arm.mve.vsli",
+  "llvm.arm.mve.vsli.predicated",
+  "llvm.arm.mve.vsri",
+  "llvm.arm.mve.vsri.predicated",
+  "llvm.arm.mve.vst2q",
+  "llvm.arm.mve.vst4q",
+  "llvm.arm.mve.vstr.scatter.base",
+  "llvm.arm.mve.vstr.scatter.base.predicated",
+  "llvm.arm.mve.vstr.scatter.base.wb",
+  "llvm.arm.mve.vstr.scatter.base.wb.predicated",
+  "llvm.arm.mve.vstr.scatter.offset",
+  "llvm.arm.mve.vstr.scatter.offset.predicated",
   "llvm.arm.neon.aesd",
   "llvm.arm.neon.aese",
   "llvm.arm.neon.aesimc",
   "llvm.arm.neon.aesmc",
+  "llvm.arm.neon.bfdot",
+  "llvm.arm.neon.bfmlalb",
+  "llvm.arm.neon.bfmlalt",
+  "llvm.arm.neon.bfmmla",
   "llvm.arm.neon.sdot",
   "llvm.arm.neon.sha1c",
   "llvm.arm.neon.sha1h",
@@ -1207,16 +2171,24 @@
   "llvm.arm.neon.sha256h2",
   "llvm.arm.neon.sha256su0",
   "llvm.arm.neon.sha256su1",
+  "llvm.arm.neon.smmla",
   "llvm.arm.neon.udot",
+  "llvm.arm.neon.ummla",
+  "llvm.arm.neon.usdot",
+  "llvm.arm.neon.usmmla",
   "llvm.arm.neon.vabds",
   "llvm.arm.neon.vabdu",
   "llvm.arm.neon.vabs",
   "llvm.arm.neon.vacge",
   "llvm.arm.neon.vacgt",
   "llvm.arm.neon.vbsl",
+  "llvm.arm.neon.vcadd.rot270",
+  "llvm.arm.neon.vcadd.rot90",
   "llvm.arm.neon.vcls",
   "llvm.arm.neon.vcvtas",
   "llvm.arm.neon.vcvtau",
+  "llvm.arm.neon.vcvtbfp2bf",
+  "llvm.arm.neon.vcvtfp2bf",
   "llvm.arm.neon.vcvtfp2fxs",
   "llvm.arm.neon.vcvtfp2fxu",
   "llvm.arm.neon.vcvtfp2hf",
@@ -1266,8 +2238,6 @@
   "llvm.arm.neon.vpmins",
   "llvm.arm.neon.vpminu",
   "llvm.arm.neon.vqabs",
-  "llvm.arm.neon.vqadds",
-  "llvm.arm.neon.vqaddu",
   "llvm.arm.neon.vqdmulh",
   "llvm.arm.neon.vqdmull",
   "llvm.arm.neon.vqmovns",
@@ -1286,8 +2256,6 @@
   "llvm.arm.neon.vqshifts",
   "llvm.arm.neon.vqshiftsu",
   "llvm.arm.neon.vqshiftu",
-  "llvm.arm.neon.vqsubs",
-  "llvm.arm.neon.vqsubu",
   "llvm.arm.neon.vraddhn",
   "llvm.arm.neon.vrecpe",
   "llvm.arm.neon.vrecps",
@@ -1412,9 +2380,14 @@
   "llvm.arm.uxtb16",
   "llvm.arm.vcvtr",
   "llvm.arm.vcvtru",
+  "llvm.bpf.btf.type.id",
   "llvm.bpf.load.byte",
   "llvm.bpf.load.half",
   "llvm.bpf.load.word",
+  "llvm.bpf.passthrough",
+  "llvm.bpf.preserve.enum.value",
+  "llvm.bpf.preserve.field.info",
+  "llvm.bpf.preserve.type.info",
   "llvm.bpf.pseudo",
   "llvm.hexagon.A2.abs",
   "llvm.hexagon.A2.absp",
@@ -1464,7 +2437,6 @@
   "llvm.hexagon.A2.or",
   "llvm.hexagon.A2.orir",
   "llvm.hexagon.A2.orp",
-  "llvm.hexagon.A2.pxorf",
   "llvm.hexagon.A2.roundsat",
   "llvm.hexagon.A2.sat",
   "llvm.hexagon.A2.satb",
@@ -1501,12 +2473,10 @@
   "llvm.hexagon.A2.sxth",
   "llvm.hexagon.A2.sxtw",
   "llvm.hexagon.A2.tfr",
-  "llvm.hexagon.A2.tfrcrr",
   "llvm.hexagon.A2.tfrih",
   "llvm.hexagon.A2.tfril",
   "llvm.hexagon.A2.tfrp",
   "llvm.hexagon.A2.tfrpi",
-  "llvm.hexagon.A2.tfrrcr",
   "llvm.hexagon.A2.tfrsi",
   "llvm.hexagon.A2.vabsh",
   "llvm.hexagon.A2.vabshsat",
@@ -1575,7 +2545,6 @@
   "llvm.hexagon.A2.xorp",
   "llvm.hexagon.A2.zxtb",
   "llvm.hexagon.A2.zxth",
-  "llvm.hexagon.A4.addp.c",
   "llvm.hexagon.A4.andn",
   "llvm.hexagon.A4.andnp",
   "llvm.hexagon.A4.bitsplit",
@@ -1593,7 +2562,6 @@
   "llvm.hexagon.A4.cmphgti",
   "llvm.hexagon.A4.cmphgtu",
   "llvm.hexagon.A4.cmphgtui",
-  "llvm.hexagon.A4.combineii",
   "llvm.hexagon.A4.combineir",
   "llvm.hexagon.A4.combineri",
   "llvm.hexagon.A4.cround.ri",
@@ -1609,9 +2577,6 @@
   "llvm.hexagon.A4.round.ri.sat",
   "llvm.hexagon.A4.round.rr",
   "llvm.hexagon.A4.round.rr.sat",
-  "llvm.hexagon.A4.subp.c",
-  "llvm.hexagon.A4.tfrcpp",
-  "llvm.hexagon.A4.tfrpcp",
   "llvm.hexagon.A4.tlbmatch",
   "llvm.hexagon.A4.vcmpbeq.any",
   "llvm.hexagon.A4.vcmpbeqi",
@@ -1632,10 +2597,12 @@
   "llvm.hexagon.A4.vrminuh",
   "llvm.hexagon.A4.vrminuw",
   "llvm.hexagon.A4.vrminw",
-  "llvm.hexagon.A5.ACS",
   "llvm.hexagon.A5.vaddhubs",
   "llvm.hexagon.A6.vcmpbeq.notany",
-  "llvm.hexagon.A6.vminub.RdP",
+  "llvm.hexagon.A7.clip",
+  "llvm.hexagon.A7.croundd.ri",
+  "llvm.hexagon.A7.croundd.rr",
+  "llvm.hexagon.A7.vclip",
   "llvm.hexagon.C2.all8",
   "llvm.hexagon.C2.and",
   "llvm.hexagon.C2.andn",
@@ -1723,6 +2690,12 @@
   "llvm.hexagon.F2.dfcmpuo",
   "llvm.hexagon.F2.dfimm.n",
   "llvm.hexagon.F2.dfimm.p",
+  "llvm.hexagon.F2.dfmax",
+  "llvm.hexagon.F2.dfmin",
+  "llvm.hexagon.F2.dfmpyfix",
+  "llvm.hexagon.F2.dfmpyhh",
+  "llvm.hexagon.F2.dfmpylh",
+  "llvm.hexagon.F2.dfmpyll",
   "llvm.hexagon.F2.dfsub",
   "llvm.hexagon.F2.sfadd",
   "llvm.hexagon.F2.sfclass",
@@ -1740,11 +2713,9 @@
   "llvm.hexagon.F2.sffms.lib",
   "llvm.hexagon.F2.sfimm.n",
   "llvm.hexagon.F2.sfimm.p",
-  "llvm.hexagon.F2.sfinvsqrta",
   "llvm.hexagon.F2.sfmax",
   "llvm.hexagon.F2.sfmin",
   "llvm.hexagon.F2.sfmpy",
-  "llvm.hexagon.F2.sfrecipa",
   "llvm.hexagon.F2.sfsub",
   "llvm.hexagon.L2.loadrb.pbr",
   "llvm.hexagon.L2.loadrb.pci",
@@ -1935,8 +2906,6 @@
   "llvm.hexagon.M2.mpyd.rnd.ll.s0",
   "llvm.hexagon.M2.mpyd.rnd.ll.s1",
   "llvm.hexagon.M2.mpyi",
-  "llvm.hexagon.M2.mpysin",
-  "llvm.hexagon.M2.mpysip",
   "llvm.hexagon.M2.mpysmi",
   "llvm.hexagon.M2.mpysu.up",
   "llvm.hexagon.M2.mpyu.acc.hh.s0",
@@ -2085,6 +3054,24 @@
   "llvm.hexagon.M5.vrmpybuu",
   "llvm.hexagon.M6.vabsdiffb",
   "llvm.hexagon.M6.vabsdiffub",
+  "llvm.hexagon.M7.dcmpyiw",
+  "llvm.hexagon.M7.dcmpyiw.acc",
+  "llvm.hexagon.M7.dcmpyiwc",
+  "llvm.hexagon.M7.dcmpyiwc.acc",
+  "llvm.hexagon.M7.dcmpyrw",
+  "llvm.hexagon.M7.dcmpyrw.acc",
+  "llvm.hexagon.M7.dcmpyrwc",
+  "llvm.hexagon.M7.dcmpyrwc.acc",
+  "llvm.hexagon.M7.vdmpy",
+  "llvm.hexagon.M7.vdmpy.acc",
+  "llvm.hexagon.M7.wcmpyiw",
+  "llvm.hexagon.M7.wcmpyiw.rnd",
+  "llvm.hexagon.M7.wcmpyiwc",
+  "llvm.hexagon.M7.wcmpyiwc.rnd",
+  "llvm.hexagon.M7.wcmpyrw",
+  "llvm.hexagon.M7.wcmpyrw.rnd",
+  "llvm.hexagon.M7.wcmpyrwc",
+  "llvm.hexagon.M7.wcmpyrwc.rnd",
   "llvm.hexagon.S2.addasl.rrri",
   "llvm.hexagon.S2.asl.i.p",
   "llvm.hexagon.S2.asl.i.p.acc",
@@ -2331,37 +3318,6 @@
   "llvm.hexagon.V6.extractw.128B",
   "llvm.hexagon.V6.hi",
   "llvm.hexagon.V6.hi.128B",
-  "llvm.hexagon.V6.ld0",
-  "llvm.hexagon.V6.ld0.128B",
-  "llvm.hexagon.V6.ldcnp0",
-  "llvm.hexagon.V6.ldcnp0.128B",
-  "llvm.hexagon.V6.ldcnpnt0",
-  "llvm.hexagon.V6.ldcnpnt0.128B",
-  "llvm.hexagon.V6.ldcp0",
-  "llvm.hexagon.V6.ldcp0.128B",
-  "llvm.hexagon.V6.ldcpnt0",
-  "llvm.hexagon.V6.ldcpnt0.128B",
-  "llvm.hexagon.V6.ldnp0",
-  "llvm.hexagon.V6.ldnp0.128B",
-  "llvm.hexagon.V6.ldnpnt0",
-  "llvm.hexagon.V6.ldnpnt0.128B",
-  "llvm.hexagon.V6.ldnt0",
-  "llvm.hexagon.V6.ldnt0.128B",
-  "llvm.hexagon.V6.ldntnt0",
-  "llvm.hexagon.V6.ldp0",
-  "llvm.hexagon.V6.ldp0.128B",
-  "llvm.hexagon.V6.ldpnt0",
-  "llvm.hexagon.V6.ldpnt0.128B",
-  "llvm.hexagon.V6.ldtnp0",
-  "llvm.hexagon.V6.ldtnp0.128B",
-  "llvm.hexagon.V6.ldtnpnt0",
-  "llvm.hexagon.V6.ldtnpnt0.128B",
-  "llvm.hexagon.V6.ldtp0",
-  "llvm.hexagon.V6.ldtp0.128B",
-  "llvm.hexagon.V6.ldtpnt0",
-  "llvm.hexagon.V6.ldtpnt0.128B",
-  "llvm.hexagon.V6.ldu0",
-  "llvm.hexagon.V6.ldu0.128B",
   "llvm.hexagon.V6.lo",
   "llvm.hexagon.V6.lo.128B",
   "llvm.hexagon.V6.lvsplatb",
@@ -2384,6 +3340,8 @@
   "llvm.hexagon.V6.pred.scalar2.128B",
   "llvm.hexagon.V6.pred.scalar2v2",
   "llvm.hexagon.V6.pred.scalar2v2.128B",
+  "llvm.hexagon.V6.pred.typecast",
+  "llvm.hexagon.V6.pred.typecast.128B",
   "llvm.hexagon.V6.pred.xor",
   "llvm.hexagon.V6.pred.xor.128B",
   "llvm.hexagon.V6.shuffeqh",
@@ -3142,8 +4100,6 @@
   "llvm.hexagon.V6.vtmpyhb.128B",
   "llvm.hexagon.V6.vtmpyhb.acc",
   "llvm.hexagon.V6.vtmpyhb.acc.128B",
-  "llvm.hexagon.V6.vtran2x2.map",
-  "llvm.hexagon.V6.vtran2x2.map.128B",
   "llvm.hexagon.V6.vunpackb",
   "llvm.hexagon.V6.vunpackb.128B",
   "llvm.hexagon.V6.vunpackh",
@@ -3164,6 +4120,7 @@
   "llvm.hexagon.V6.vzh.128B",
   "llvm.hexagon.Y2.dccleana",
   "llvm.hexagon.Y2.dccleaninva",
+  "llvm.hexagon.Y2.dcfetch",
   "llvm.hexagon.Y2.dcinva",
   "llvm.hexagon.Y2.dczeroa",
   "llvm.hexagon.Y4.l2fetch",
@@ -3573,6 +4530,8 @@
   "llvm.mips.ldi.d",
   "llvm.mips.ldi.h",
   "llvm.mips.ldi.w",
+  "llvm.mips.ldr.d",
+  "llvm.mips.ldr.w",
   "llvm.mips.lhx",
   "llvm.mips.lsa",
   "llvm.mips.lwx",
@@ -3805,6 +4764,8 @@
   "llvm.mips.st.d",
   "llvm.mips.st.h",
   "llvm.mips.st.w",
+  "llvm.mips.str.d",
+  "llvm.mips.str.w",
   "llvm.mips.subq.ph",
   "llvm.mips.subq.s.ph",
   "llvm.mips.subq.s.w",
@@ -3875,8 +4836,6 @@
   "llvm.nvvm.atomic.exch.gen.i.sys",
   "llvm.nvvm.atomic.inc.gen.i.cta",
   "llvm.nvvm.atomic.inc.gen.i.sys",
-  "llvm.nvvm.atomic.load.add.f32",
-  "llvm.nvvm.atomic.load.add.f64",
   "llvm.nvvm.atomic.load.dec.32",
   "llvm.nvvm.atomic.load.inc.32",
   "llvm.nvvm.atomic.max.gen.i.cta",
@@ -4050,6 +5009,18 @@
   "llvm.nvvm.membar.cta",
   "llvm.nvvm.membar.gl",
   "llvm.nvvm.membar.sys",
+  "llvm.nvvm.mma.m8n8k4.col.col.f16.f16",
+  "llvm.nvvm.mma.m8n8k4.col.col.f32.f16",
+  "llvm.nvvm.mma.m8n8k4.col.col.f32.f32",
+  "llvm.nvvm.mma.m8n8k4.col.row.f16.f16",
+  "llvm.nvvm.mma.m8n8k4.col.row.f32.f16",
+  "llvm.nvvm.mma.m8n8k4.col.row.f32.f32",
+  "llvm.nvvm.mma.m8n8k4.row.col.f16.f16",
+  "llvm.nvvm.mma.m8n8k4.row.col.f32.f16",
+  "llvm.nvvm.mma.m8n8k4.row.col.f32.f32",
+  "llvm.nvvm.mma.m8n8k4.row.row.f16.f16",
+  "llvm.nvvm.mma.m8n8k4.row.row.f32.f16",
+  "llvm.nvvm.mma.m8n8k4.row.row.f32.f32",
   "llvm.nvvm.move.double",
   "llvm.nvvm.move.float",
   "llvm.nvvm.move.i16",
@@ -4179,21 +5150,37 @@
   "llvm.nvvm.saturate.f",
   "llvm.nvvm.saturate.ftz.f",
   "llvm.nvvm.shfl.bfly.f32",
+  "llvm.nvvm.shfl.bfly.f32p",
   "llvm.nvvm.shfl.bfly.i32",
+  "llvm.nvvm.shfl.bfly.i32p",
   "llvm.nvvm.shfl.down.f32",
+  "llvm.nvvm.shfl.down.f32p",
   "llvm.nvvm.shfl.down.i32",
+  "llvm.nvvm.shfl.down.i32p",
   "llvm.nvvm.shfl.idx.f32",
+  "llvm.nvvm.shfl.idx.f32p",
   "llvm.nvvm.shfl.idx.i32",
+  "llvm.nvvm.shfl.idx.i32p",
   "llvm.nvvm.shfl.sync.bfly.f32",
+  "llvm.nvvm.shfl.sync.bfly.f32p",
   "llvm.nvvm.shfl.sync.bfly.i32",
+  "llvm.nvvm.shfl.sync.bfly.i32p",
   "llvm.nvvm.shfl.sync.down.f32",
+  "llvm.nvvm.shfl.sync.down.f32p",
   "llvm.nvvm.shfl.sync.down.i32",
+  "llvm.nvvm.shfl.sync.down.i32p",
   "llvm.nvvm.shfl.sync.idx.f32",
+  "llvm.nvvm.shfl.sync.idx.f32p",
   "llvm.nvvm.shfl.sync.idx.i32",
+  "llvm.nvvm.shfl.sync.idx.i32p",
   "llvm.nvvm.shfl.sync.up.f32",
+  "llvm.nvvm.shfl.sync.up.f32p",
   "llvm.nvvm.shfl.sync.up.i32",
+  "llvm.nvvm.shfl.sync.up.i32p",
   "llvm.nvvm.shfl.up.f32",
+  "llvm.nvvm.shfl.up.f32p",
   "llvm.nvvm.shfl.up.i32",
+  "llvm.nvvm.shfl.up.i32p",
   "llvm.nvvm.sin.approx.f",
   "llvm.nvvm.sin.approx.ftz.f",
   "llvm.nvvm.sqrt.approx.f",
@@ -5147,6 +6134,11 @@
   "llvm.ppc.altivec.lvxl",
   "llvm.ppc.altivec.mfvscr",
   "llvm.ppc.altivec.mtvscr",
+  "llvm.ppc.altivec.mtvsrbm",
+  "llvm.ppc.altivec.mtvsrdm",
+  "llvm.ppc.altivec.mtvsrhm",
+  "llvm.ppc.altivec.mtvsrqm",
+  "llvm.ppc.altivec.mtvsrwm",
   "llvm.ppc.altivec.stvebx",
   "llvm.ppc.altivec.stvehx",
   "llvm.ppc.altivec.stvewx",
@@ -5173,7 +6165,11 @@
   "llvm.ppc.altivec.vavguw",
   "llvm.ppc.altivec.vbpermq",
   "llvm.ppc.altivec.vcfsx",
+  "llvm.ppc.altivec.vcfuged",
   "llvm.ppc.altivec.vcfux",
+  "llvm.ppc.altivec.vclrlb",
+  "llvm.ppc.altivec.vclrrb",
+  "llvm.ppc.altivec.vclzdm",
   "llvm.ppc.altivec.vclzlsbb",
   "llvm.ppc.altivec.vcmpbfp",
   "llvm.ppc.altivec.vcmpbfp.p",
@@ -5185,6 +6181,8 @@
   "llvm.ppc.altivec.vcmpequd.p",
   "llvm.ppc.altivec.vcmpequh",
   "llvm.ppc.altivec.vcmpequh.p",
+  "llvm.ppc.altivec.vcmpequq",
+  "llvm.ppc.altivec.vcmpequq.p",
   "llvm.ppc.altivec.vcmpequw",
   "llvm.ppc.altivec.vcmpequw.p",
   "llvm.ppc.altivec.vcmpgefp",
@@ -5197,6 +6195,8 @@
   "llvm.ppc.altivec.vcmpgtsd.p",
   "llvm.ppc.altivec.vcmpgtsh",
   "llvm.ppc.altivec.vcmpgtsh.p",
+  "llvm.ppc.altivec.vcmpgtsq",
+  "llvm.ppc.altivec.vcmpgtsq.p",
   "llvm.ppc.altivec.vcmpgtsw",
   "llvm.ppc.altivec.vcmpgtsw.p",
   "llvm.ppc.altivec.vcmpgtub",
@@ -5205,6 +6205,8 @@
   "llvm.ppc.altivec.vcmpgtud.p",
   "llvm.ppc.altivec.vcmpgtuh",
   "llvm.ppc.altivec.vcmpgtuh.p",
+  "llvm.ppc.altivec.vcmpgtuq",
+  "llvm.ppc.altivec.vcmpgtuq.p",
   "llvm.ppc.altivec.vcmpgtuw",
   "llvm.ppc.altivec.vcmpgtuw.p",
   "llvm.ppc.altivec.vcmpneb",
@@ -5219,11 +6221,63 @@
   "llvm.ppc.altivec.vcmpnezh.p",
   "llvm.ppc.altivec.vcmpnezw",
   "llvm.ppc.altivec.vcmpnezw.p",
+  "llvm.ppc.altivec.vcntmbb",
+  "llvm.ppc.altivec.vcntmbd",
+  "llvm.ppc.altivec.vcntmbh",
+  "llvm.ppc.altivec.vcntmbw",
   "llvm.ppc.altivec.vctsxs",
   "llvm.ppc.altivec.vctuxs",
+  "llvm.ppc.altivec.vctzdm",
   "llvm.ppc.altivec.vctzlsbb",
+  "llvm.ppc.altivec.vdivesd",
+  "llvm.ppc.altivec.vdivesq",
+  "llvm.ppc.altivec.vdivesw",
+  "llvm.ppc.altivec.vdiveud",
+  "llvm.ppc.altivec.vdiveuq",
+  "llvm.ppc.altivec.vdiveuw",
+  "llvm.ppc.altivec.vexpandbm",
+  "llvm.ppc.altivec.vexpanddm",
+  "llvm.ppc.altivec.vexpandhm",
+  "llvm.ppc.altivec.vexpandqm",
+  "llvm.ppc.altivec.vexpandwm",
   "llvm.ppc.altivec.vexptefp",
+  "llvm.ppc.altivec.vextddvlx",
+  "llvm.ppc.altivec.vextddvrx",
+  "llvm.ppc.altivec.vextdubvlx",
+  "llvm.ppc.altivec.vextdubvrx",
+  "llvm.ppc.altivec.vextduhvlx",
+  "llvm.ppc.altivec.vextduhvrx",
+  "llvm.ppc.altivec.vextduwvlx",
+  "llvm.ppc.altivec.vextduwvrx",
+  "llvm.ppc.altivec.vextractbm",
+  "llvm.ppc.altivec.vextractdm",
+  "llvm.ppc.altivec.vextracthm",
+  "llvm.ppc.altivec.vextractqm",
+  "llvm.ppc.altivec.vextractwm",
+  "llvm.ppc.altivec.vextsb2d",
+  "llvm.ppc.altivec.vextsb2w",
+  "llvm.ppc.altivec.vextsd2q",
+  "llvm.ppc.altivec.vextsh2d",
+  "llvm.ppc.altivec.vextsh2w",
+  "llvm.ppc.altivec.vextsw2d",
   "llvm.ppc.altivec.vgbbd",
+  "llvm.ppc.altivec.vgnb",
+  "llvm.ppc.altivec.vinsblx",
+  "llvm.ppc.altivec.vinsbrx",
+  "llvm.ppc.altivec.vinsbvlx",
+  "llvm.ppc.altivec.vinsbvrx",
+  "llvm.ppc.altivec.vinsd",
+  "llvm.ppc.altivec.vinsdlx",
+  "llvm.ppc.altivec.vinsdrx",
+  "llvm.ppc.altivec.vinshlx",
+  "llvm.ppc.altivec.vinshrx",
+  "llvm.ppc.altivec.vinshvlx",
+  "llvm.ppc.altivec.vinshvrx",
+  "llvm.ppc.altivec.vinsw",
+  "llvm.ppc.altivec.vinswlx",
+  "llvm.ppc.altivec.vinswrx",
+  "llvm.ppc.altivec.vinswvlx",
+  "llvm.ppc.altivec.vinswvrx",
   "llvm.ppc.altivec.vlogefp",
   "llvm.ppc.altivec.vmaddfp",
   "llvm.ppc.altivec.vmaxfp",
@@ -5247,26 +6301,38 @@
   "llvm.ppc.altivec.vminuh",
   "llvm.ppc.altivec.vminuw",
   "llvm.ppc.altivec.vmladduhm",
+  "llvm.ppc.altivec.vmsumcud",
   "llvm.ppc.altivec.vmsummbm",
   "llvm.ppc.altivec.vmsumshm",
   "llvm.ppc.altivec.vmsumshs",
   "llvm.ppc.altivec.vmsumubm",
+  "llvm.ppc.altivec.vmsumudm",
   "llvm.ppc.altivec.vmsumuhm",
   "llvm.ppc.altivec.vmsumuhs",
   "llvm.ppc.altivec.vmulesb",
+  "llvm.ppc.altivec.vmulesd",
   "llvm.ppc.altivec.vmulesh",
   "llvm.ppc.altivec.vmulesw",
   "llvm.ppc.altivec.vmuleub",
+  "llvm.ppc.altivec.vmuleud",
   "llvm.ppc.altivec.vmuleuh",
   "llvm.ppc.altivec.vmuleuw",
+  "llvm.ppc.altivec.vmulhsd",
+  "llvm.ppc.altivec.vmulhsw",
+  "llvm.ppc.altivec.vmulhud",
+  "llvm.ppc.altivec.vmulhuw",
   "llvm.ppc.altivec.vmulosb",
+  "llvm.ppc.altivec.vmulosd",
   "llvm.ppc.altivec.vmulosh",
   "llvm.ppc.altivec.vmulosw",
   "llvm.ppc.altivec.vmuloub",
+  "llvm.ppc.altivec.vmuloud",
   "llvm.ppc.altivec.vmulouh",
   "llvm.ppc.altivec.vmulouw",
   "llvm.ppc.altivec.vnmsubfp",
+  "llvm.ppc.altivec.vpdepd",
   "llvm.ppc.altivec.vperm",
+  "llvm.ppc.altivec.vpextd",
   "llvm.ppc.altivec.vpkpx",
   "llvm.ppc.altivec.vpksdss",
   "llvm.ppc.altivec.vpksdus",
@@ -5290,6 +6356,8 @@
   "llvm.ppc.altivec.vrldmi",
   "llvm.ppc.altivec.vrldnm",
   "llvm.ppc.altivec.vrlh",
+  "llvm.ppc.altivec.vrlqmi",
+  "llvm.ppc.altivec.vrlqnm",
   "llvm.ppc.altivec.vrlw",
   "llvm.ppc.altivec.vrlwmi",
   "llvm.ppc.altivec.vrlwnm",
@@ -5297,6 +6365,7 @@
   "llvm.ppc.altivec.vsel",
   "llvm.ppc.altivec.vsl",
   "llvm.ppc.altivec.vslb",
+  "llvm.ppc.altivec.vsldbi",
   "llvm.ppc.altivec.vslh",
   "llvm.ppc.altivec.vslo",
   "llvm.ppc.altivec.vslv",
@@ -5306,10 +6375,19 @@
   "llvm.ppc.altivec.vsrah",
   "llvm.ppc.altivec.vsraw",
   "llvm.ppc.altivec.vsrb",
+  "llvm.ppc.altivec.vsrdbi",
   "llvm.ppc.altivec.vsrh",
   "llvm.ppc.altivec.vsro",
   "llvm.ppc.altivec.vsrv",
   "llvm.ppc.altivec.vsrw",
+  "llvm.ppc.altivec.vstribl",
+  "llvm.ppc.altivec.vstribl.p",
+  "llvm.ppc.altivec.vstribr",
+  "llvm.ppc.altivec.vstribr.p",
+  "llvm.ppc.altivec.vstrihl",
+  "llvm.ppc.altivec.vstrihl.p",
+  "llvm.ppc.altivec.vstrihr",
+  "llvm.ppc.altivec.vstrihr.p",
   "llvm.ppc.altivec.vsubcuq",
   "llvm.ppc.altivec.vsubcuw",
   "llvm.ppc.altivec.vsubecuq",
@@ -5335,12 +6413,24 @@
   "llvm.ppc.altivec.vupklsw",
   "llvm.ppc.bpermd",
   "llvm.ppc.cfence",
+  "llvm.ppc.cfuged",
+  "llvm.ppc.cntlzdm",
+  "llvm.ppc.cnttzdm",
+  "llvm.ppc.darn",
+  "llvm.ppc.darn32",
+  "llvm.ppc.darnraw",
   "llvm.ppc.dcba",
   "llvm.ppc.dcbf",
+  "llvm.ppc.dcbfl",
+  "llvm.ppc.dcbflp",
+  "llvm.ppc.dcbfps",
   "llvm.ppc.dcbi",
   "llvm.ppc.dcbst",
+  "llvm.ppc.dcbstps",
   "llvm.ppc.dcbt",
+  "llvm.ppc.dcbt.with.hint",
   "llvm.ppc.dcbtst",
+  "llvm.ppc.dcbtst.with.hint",
   "llvm.ppc.dcbz",
   "llvm.ppc.dcbzl",
   "llvm.ppc.divde",
@@ -5348,104 +6438,89 @@
   "llvm.ppc.divf128.round.to.odd",
   "llvm.ppc.divwe",
   "llvm.ppc.divweu",
+  "llvm.ppc.eieio",
   "llvm.ppc.fmaf128.round.to.odd",
   "llvm.ppc.get.texasr",
   "llvm.ppc.get.texasru",
   "llvm.ppc.get.tfhar",
   "llvm.ppc.get.tfiar",
-  "llvm.ppc.is.decremented.ctr.nonzero",
+  "llvm.ppc.isync",
   "llvm.ppc.lwsync",
-  "llvm.ppc.mtctr",
+  "llvm.ppc.mma.assemble.acc",
+  "llvm.ppc.mma.disassemble.acc",
+  "llvm.ppc.mma.pmxvbf16ger2",
+  "llvm.ppc.mma.pmxvbf16ger2nn",
+  "llvm.ppc.mma.pmxvbf16ger2np",
+  "llvm.ppc.mma.pmxvbf16ger2pn",
+  "llvm.ppc.mma.pmxvbf16ger2pp",
+  "llvm.ppc.mma.pmxvf16ger2",
+  "llvm.ppc.mma.pmxvf16ger2nn",
+  "llvm.ppc.mma.pmxvf16ger2np",
+  "llvm.ppc.mma.pmxvf16ger2pn",
+  "llvm.ppc.mma.pmxvf16ger2pp",
+  "llvm.ppc.mma.pmxvf32ger",
+  "llvm.ppc.mma.pmxvf32gernn",
+  "llvm.ppc.mma.pmxvf32gernp",
+  "llvm.ppc.mma.pmxvf32gerpn",
+  "llvm.ppc.mma.pmxvf32gerpp",
+  "llvm.ppc.mma.pmxvf64ger",
+  "llvm.ppc.mma.pmxvf64gernn",
+  "llvm.ppc.mma.pmxvf64gernp",
+  "llvm.ppc.mma.pmxvf64gerpn",
+  "llvm.ppc.mma.pmxvf64gerpp",
+  "llvm.ppc.mma.pmxvi16ger2",
+  "llvm.ppc.mma.pmxvi16ger2pp",
+  "llvm.ppc.mma.pmxvi16ger2s",
+  "llvm.ppc.mma.pmxvi16ger2spp",
+  "llvm.ppc.mma.pmxvi4ger8",
+  "llvm.ppc.mma.pmxvi4ger8pp",
+  "llvm.ppc.mma.pmxvi8ger4",
+  "llvm.ppc.mma.pmxvi8ger4pp",
+  "llvm.ppc.mma.pmxvi8ger4spp",
+  "llvm.ppc.mma.xvbf16ger2",
+  "llvm.ppc.mma.xvbf16ger2nn",
+  "llvm.ppc.mma.xvbf16ger2np",
+  "llvm.ppc.mma.xvbf16ger2pn",
+  "llvm.ppc.mma.xvbf16ger2pp",
+  "llvm.ppc.mma.xvf16ger2",
+  "llvm.ppc.mma.xvf16ger2nn",
+  "llvm.ppc.mma.xvf16ger2np",
+  "llvm.ppc.mma.xvf16ger2pn",
+  "llvm.ppc.mma.xvf16ger2pp",
+  "llvm.ppc.mma.xvf32ger",
+  "llvm.ppc.mma.xvf32gernn",
+  "llvm.ppc.mma.xvf32gernp",
+  "llvm.ppc.mma.xvf32gerpn",
+  "llvm.ppc.mma.xvf32gerpp",
+  "llvm.ppc.mma.xvf64ger",
+  "llvm.ppc.mma.xvf64gernn",
+  "llvm.ppc.mma.xvf64gernp",
+  "llvm.ppc.mma.xvf64gerpn",
+  "llvm.ppc.mma.xvf64gerpp",
+  "llvm.ppc.mma.xvi16ger2",
+  "llvm.ppc.mma.xvi16ger2pp",
+  "llvm.ppc.mma.xvi16ger2s",
+  "llvm.ppc.mma.xvi16ger2spp",
+  "llvm.ppc.mma.xvi4ger8",
+  "llvm.ppc.mma.xvi4ger8pp",
+  "llvm.ppc.mma.xvi8ger4",
+  "llvm.ppc.mma.xvi8ger4pp",
+  "llvm.ppc.mma.xvi8ger4spp",
+  "llvm.ppc.mma.xxmfacc",
+  "llvm.ppc.mma.xxmtacc",
+  "llvm.ppc.mma.xxsetaccz",
   "llvm.ppc.mulf128.round.to.odd",
-  "llvm.ppc.qpx.qvfabs",
-  "llvm.ppc.qpx.qvfadd",
-  "llvm.ppc.qpx.qvfadds",
-  "llvm.ppc.qpx.qvfcfid",
-  "llvm.ppc.qpx.qvfcfids",
-  "llvm.ppc.qpx.qvfcfidu",
-  "llvm.ppc.qpx.qvfcfidus",
-  "llvm.ppc.qpx.qvfcmpeq",
-  "llvm.ppc.qpx.qvfcmpgt",
-  "llvm.ppc.qpx.qvfcmplt",
-  "llvm.ppc.qpx.qvfcpsgn",
-  "llvm.ppc.qpx.qvfctid",
-  "llvm.ppc.qpx.qvfctidu",
-  "llvm.ppc.qpx.qvfctiduz",
-  "llvm.ppc.qpx.qvfctidz",
-  "llvm.ppc.qpx.qvfctiw",
-  "llvm.ppc.qpx.qvfctiwu",
-  "llvm.ppc.qpx.qvfctiwuz",
-  "llvm.ppc.qpx.qvfctiwz",
-  "llvm.ppc.qpx.qvflogical",
-  "llvm.ppc.qpx.qvfmadd",
-  "llvm.ppc.qpx.qvfmadds",
-  "llvm.ppc.qpx.qvfmsub",
-  "llvm.ppc.qpx.qvfmsubs",
-  "llvm.ppc.qpx.qvfmul",
-  "llvm.ppc.qpx.qvfmuls",
-  "llvm.ppc.qpx.qvfnabs",
-  "llvm.ppc.qpx.qvfneg",
-  "llvm.ppc.qpx.qvfnmadd",
-  "llvm.ppc.qpx.qvfnmadds",
-  "llvm.ppc.qpx.qvfnmsub",
-  "llvm.ppc.qpx.qvfnmsubs",
-  "llvm.ppc.qpx.qvfperm",
-  "llvm.ppc.qpx.qvfre",
-  "llvm.ppc.qpx.qvfres",
-  "llvm.ppc.qpx.qvfrim",
-  "llvm.ppc.qpx.qvfrin",
-  "llvm.ppc.qpx.qvfrip",
-  "llvm.ppc.qpx.qvfriz",
-  "llvm.ppc.qpx.qvfrsp",
-  "llvm.ppc.qpx.qvfrsqrte",
-  "llvm.ppc.qpx.qvfrsqrtes",
-  "llvm.ppc.qpx.qvfsel",
-  "llvm.ppc.qpx.qvfsub",
-  "llvm.ppc.qpx.qvfsubs",
-  "llvm.ppc.qpx.qvftstnan",
-  "llvm.ppc.qpx.qvfxmadd",
-  "llvm.ppc.qpx.qvfxmadds",
-  "llvm.ppc.qpx.qvfxmul",
-  "llvm.ppc.qpx.qvfxmuls",
-  "llvm.ppc.qpx.qvfxxcpnmadd",
-  "llvm.ppc.qpx.qvfxxcpnmadds",
-  "llvm.ppc.qpx.qvfxxmadd",
-  "llvm.ppc.qpx.qvfxxmadds",
-  "llvm.ppc.qpx.qvfxxnpmadd",
-  "llvm.ppc.qpx.qvfxxnpmadds",
-  "llvm.ppc.qpx.qvgpci",
-  "llvm.ppc.qpx.qvlfcd",
-  "llvm.ppc.qpx.qvlfcda",
-  "llvm.ppc.qpx.qvlfcs",
-  "llvm.ppc.qpx.qvlfcsa",
-  "llvm.ppc.qpx.qvlfd",
-  "llvm.ppc.qpx.qvlfda",
-  "llvm.ppc.qpx.qvlfiwa",
-  "llvm.ppc.qpx.qvlfiwaa",
-  "llvm.ppc.qpx.qvlfiwz",
-  "llvm.ppc.qpx.qvlfiwza",
-  "llvm.ppc.qpx.qvlfs",
-  "llvm.ppc.qpx.qvlfsa",
-  "llvm.ppc.qpx.qvlpcld",
-  "llvm.ppc.qpx.qvlpcls",
-  "llvm.ppc.qpx.qvlpcrd",
-  "llvm.ppc.qpx.qvlpcrs",
-  "llvm.ppc.qpx.qvstfcd",
-  "llvm.ppc.qpx.qvstfcda",
-  "llvm.ppc.qpx.qvstfcs",
-  "llvm.ppc.qpx.qvstfcsa",
-  "llvm.ppc.qpx.qvstfd",
-  "llvm.ppc.qpx.qvstfda",
-  "llvm.ppc.qpx.qvstfiw",
-  "llvm.ppc.qpx.qvstfiwa",
-  "llvm.ppc.qpx.qvstfs",
-  "llvm.ppc.qpx.qvstfsa",
+  "llvm.ppc.pdepd",
+  "llvm.ppc.pextd",
+  "llvm.ppc.popcntb",
+  "llvm.ppc.readflm",
   "llvm.ppc.scalar.extract.expq",
   "llvm.ppc.scalar.insert.exp.qp",
   "llvm.ppc.set.texasr",
   "llvm.ppc.set.texasru",
   "llvm.ppc.set.tfhar",
   "llvm.ppc.set.tfiar",
+  "llvm.ppc.setflm",
   "llvm.ppc.setrnd",
   "llvm.ppc.sqrtf128.round.to.odd",
   "llvm.ppc.subf128.round.to.odd",
@@ -5466,16 +6541,20 @@
   "llvm.ppc.tsr",
   "llvm.ppc.tsuspend",
   "llvm.ppc.ttest",
+  "llvm.ppc.vsx.assemble.pair",
+  "llvm.ppc.vsx.disassemble.pair",
   "llvm.ppc.vsx.lxvd2x",
   "llvm.ppc.vsx.lxvd2x.be",
   "llvm.ppc.vsx.lxvl",
   "llvm.ppc.vsx.lxvll",
+  "llvm.ppc.vsx.lxvp",
   "llvm.ppc.vsx.lxvw4x",
   "llvm.ppc.vsx.lxvw4x.be",
   "llvm.ppc.vsx.stxvd2x",
   "llvm.ppc.vsx.stxvd2x.be",
   "llvm.ppc.vsx.stxvl",
   "llvm.ppc.vsx.stxvll",
+  "llvm.ppc.vsx.stxvp",
   "llvm.ppc.vsx.stxvw4x",
   "llvm.ppc.vsx.stxvw4x.be",
   "llvm.ppc.vsx.xsmaxdp",
@@ -5492,10 +6571,12 @@
   "llvm.ppc.vsx.xvcmpgtdp.p",
   "llvm.ppc.vsx.xvcmpgtsp",
   "llvm.ppc.vsx.xvcmpgtsp.p",
+  "llvm.ppc.vsx.xvcvbf16spn",
   "llvm.ppc.vsx.xvcvdpsp",
   "llvm.ppc.vsx.xvcvdpsxws",
   "llvm.ppc.vsx.xvcvdpuxws",
   "llvm.ppc.vsx.xvcvhpsp",
+  "llvm.ppc.vsx.xvcvspbf16",
   "llvm.ppc.vsx.xvcvspdp",
   "llvm.ppc.vsx.xvcvsphp",
   "llvm.ppc.vsx.xvcvsxdsp",
@@ -5516,15 +6597,30 @@
   "llvm.ppc.vsx.xvrspip",
   "llvm.ppc.vsx.xvrsqrtedp",
   "llvm.ppc.vsx.xvrsqrtesp",
+  "llvm.ppc.vsx.xvtdivdp",
+  "llvm.ppc.vsx.xvtdivsp",
+  "llvm.ppc.vsx.xvtlsbb",
+  "llvm.ppc.vsx.xvtsqrtdp",
+  "llvm.ppc.vsx.xvtsqrtsp",
   "llvm.ppc.vsx.xvtstdcdp",
   "llvm.ppc.vsx.xvtstdcsp",
   "llvm.ppc.vsx.xvxexpdp",
   "llvm.ppc.vsx.xvxexpsp",
   "llvm.ppc.vsx.xvxsigdp",
   "llvm.ppc.vsx.xvxsigsp",
+  "llvm.ppc.vsx.xxblendvb",
+  "llvm.ppc.vsx.xxblendvd",
+  "llvm.ppc.vsx.xxblendvh",
+  "llvm.ppc.vsx.xxblendvw",
+  "llvm.ppc.vsx.xxeval",
   "llvm.ppc.vsx.xxextractuw",
+  "llvm.ppc.vsx.xxgenpcvbm",
+  "llvm.ppc.vsx.xxgenpcvdm",
+  "llvm.ppc.vsx.xxgenpcvhm",
+  "llvm.ppc.vsx.xxgenpcvwm",
   "llvm.ppc.vsx.xxinsertw",
   "llvm.ppc.vsx.xxleqv",
+  "llvm.ppc.vsx.xxpermx",
   "llvm.r600.cube",
   "llvm.r600.ddx",
   "llvm.r600.ddy",
@@ -5578,6 +6674,354 @@
   "llvm.riscv.masked.atomicrmw.xchg.i64",
   "llvm.riscv.masked.cmpxchg.i32",
   "llvm.riscv.masked.cmpxchg.i64",
+  "llvm.riscv.vaadd",
+  "llvm.riscv.vaadd.mask",
+  "llvm.riscv.vaaddu",
+  "llvm.riscv.vaaddu.mask",
+  "llvm.riscv.vadc",
+  "llvm.riscv.vadd",
+  "llvm.riscv.vadd.mask",
+  "llvm.riscv.vand",
+  "llvm.riscv.vand.mask",
+  "llvm.riscv.vasub",
+  "llvm.riscv.vasub.mask",
+  "llvm.riscv.vasubu",
+  "llvm.riscv.vasubu.mask",
+  "llvm.riscv.vcompress",
+  "llvm.riscv.vdiv",
+  "llvm.riscv.vdiv.mask",
+  "llvm.riscv.vdivu",
+  "llvm.riscv.vdivu.mask",
+  "llvm.riscv.vfadd",
+  "llvm.riscv.vfadd.mask",
+  "llvm.riscv.vfclass",
+  "llvm.riscv.vfclass.mask",
+  "llvm.riscv.vfcvt.f.x.v",
+  "llvm.riscv.vfcvt.f.x.v.mask",
+  "llvm.riscv.vfcvt.f.xu.v",
+  "llvm.riscv.vfcvt.f.xu.v.mask",
+  "llvm.riscv.vfcvt.rtz.x.f.v",
+  "llvm.riscv.vfcvt.rtz.x.f.v.mask",
+  "llvm.riscv.vfcvt.rtz.xu.f.v",
+  "llvm.riscv.vfcvt.rtz.xu.f.v.mask",
+  "llvm.riscv.vfcvt.x.f.v",
+  "llvm.riscv.vfcvt.x.f.v.mask",
+  "llvm.riscv.vfcvt.xu.f.v",
+  "llvm.riscv.vfcvt.xu.f.v.mask",
+  "llvm.riscv.vfdiv",
+  "llvm.riscv.vfdiv.mask",
+  "llvm.riscv.vfirst",
+  "llvm.riscv.vfirst.mask",
+  "llvm.riscv.vfmacc",
+  "llvm.riscv.vfmacc.mask",
+  "llvm.riscv.vfmadd",
+  "llvm.riscv.vfmadd.mask",
+  "llvm.riscv.vfmax",
+  "llvm.riscv.vfmax.mask",
+  "llvm.riscv.vfmerge",
+  "llvm.riscv.vfmin",
+  "llvm.riscv.vfmin.mask",
+  "llvm.riscv.vfmsac",
+  "llvm.riscv.vfmsac.mask",
+  "llvm.riscv.vfmsub",
+  "llvm.riscv.vfmsub.mask",
+  "llvm.riscv.vfmul",
+  "llvm.riscv.vfmul.mask",
+  "llvm.riscv.vfmv.f.s",
+  "llvm.riscv.vfmv.s.f",
+  "llvm.riscv.vfmv.v.f",
+  "llvm.riscv.vfncvt.f.f.w",
+  "llvm.riscv.vfncvt.f.f.w.mask",
+  "llvm.riscv.vfncvt.f.x.w",
+  "llvm.riscv.vfncvt.f.x.w.mask",
+  "llvm.riscv.vfncvt.f.xu.w",
+  "llvm.riscv.vfncvt.f.xu.w.mask",
+  "llvm.riscv.vfncvt.rod.f.f.w",
+  "llvm.riscv.vfncvt.rod.f.f.w.mask",
+  "llvm.riscv.vfncvt.rtz.x.f.w",
+  "llvm.riscv.vfncvt.rtz.x.f.w.mask",
+  "llvm.riscv.vfncvt.rtz.xu.f.w",
+  "llvm.riscv.vfncvt.rtz.xu.f.w.mask",
+  "llvm.riscv.vfncvt.x.f.w",
+  "llvm.riscv.vfncvt.x.f.w.mask",
+  "llvm.riscv.vfncvt.xu.f.w",
+  "llvm.riscv.vfncvt.xu.f.w.mask",
+  "llvm.riscv.vfnmacc",
+  "llvm.riscv.vfnmacc.mask",
+  "llvm.riscv.vfnmadd",
+  "llvm.riscv.vfnmadd.mask",
+  "llvm.riscv.vfnmsac",
+  "llvm.riscv.vfnmsac.mask",
+  "llvm.riscv.vfnmsub",
+  "llvm.riscv.vfnmsub.mask",
+  "llvm.riscv.vfrdiv",
+  "llvm.riscv.vfrdiv.mask",
+  "llvm.riscv.vfredmax",
+  "llvm.riscv.vfredmax.mask",
+  "llvm.riscv.vfredmin",
+  "llvm.riscv.vfredmin.mask",
+  "llvm.riscv.vfredosum",
+  "llvm.riscv.vfredosum.mask",
+  "llvm.riscv.vfredsum",
+  "llvm.riscv.vfredsum.mask",
+  "llvm.riscv.vfrsub",
+  "llvm.riscv.vfrsub.mask",
+  "llvm.riscv.vfsgnj",
+  "llvm.riscv.vfsgnj.mask",
+  "llvm.riscv.vfsgnjn",
+  "llvm.riscv.vfsgnjn.mask",
+  "llvm.riscv.vfsgnjx",
+  "llvm.riscv.vfsgnjx.mask",
+  "llvm.riscv.vfslide1down",
+  "llvm.riscv.vfslide1down.mask",
+  "llvm.riscv.vfslide1up",
+  "llvm.riscv.vfslide1up.mask",
+  "llvm.riscv.vfsqrt",
+  "llvm.riscv.vfsqrt.mask",
+  "llvm.riscv.vfsub",
+  "llvm.riscv.vfsub.mask",
+  "llvm.riscv.vfwadd",
+  "llvm.riscv.vfwadd.mask",
+  "llvm.riscv.vfwadd.w",
+  "llvm.riscv.vfwadd.w.mask",
+  "llvm.riscv.vfwcvt.f.f.v",
+  "llvm.riscv.vfwcvt.f.f.v.mask",
+  "llvm.riscv.vfwcvt.f.x.v",
+  "llvm.riscv.vfwcvt.f.x.v.mask",
+  "llvm.riscv.vfwcvt.f.xu.v",
+  "llvm.riscv.vfwcvt.f.xu.v.mask",
+  "llvm.riscv.vfwcvt.rtz.x.f.v",
+  "llvm.riscv.vfwcvt.rtz.x.f.v.mask",
+  "llvm.riscv.vfwcvt.rtz.xu.f.v",
+  "llvm.riscv.vfwcvt.rtz.xu.f.v.mask",
+  "llvm.riscv.vfwcvt.x.f.v",
+  "llvm.riscv.vfwcvt.x.f.v.mask",
+  "llvm.riscv.vfwcvt.xu.f.v",
+  "llvm.riscv.vfwcvt.xu.f.v.mask",
+  "llvm.riscv.vfwmacc",
+  "llvm.riscv.vfwmacc.mask",
+  "llvm.riscv.vfwmsac",
+  "llvm.riscv.vfwmsac.mask",
+  "llvm.riscv.vfwmul",
+  "llvm.riscv.vfwmul.mask",
+  "llvm.riscv.vfwnmacc",
+  "llvm.riscv.vfwnmacc.mask",
+  "llvm.riscv.vfwnmsac",
+  "llvm.riscv.vfwnmsac.mask",
+  "llvm.riscv.vfwredosum",
+  "llvm.riscv.vfwredosum.mask",
+  "llvm.riscv.vfwredsum",
+  "llvm.riscv.vfwredsum.mask",
+  "llvm.riscv.vfwsub",
+  "llvm.riscv.vfwsub.mask",
+  "llvm.riscv.vfwsub.w",
+  "llvm.riscv.vfwsub.w.mask",
+  "llvm.riscv.vid",
+  "llvm.riscv.vid.mask",
+  "llvm.riscv.viota",
+  "llvm.riscv.viota.mask",
+  "llvm.riscv.vle",
+  "llvm.riscv.vle.mask",
+  "llvm.riscv.vleff",
+  "llvm.riscv.vleff.mask",
+  "llvm.riscv.vlse",
+  "llvm.riscv.vlse.mask",
+  "llvm.riscv.vlxe",
+  "llvm.riscv.vlxe.mask",
+  "llvm.riscv.vmacc",
+  "llvm.riscv.vmacc.mask",
+  "llvm.riscv.vmadc",
+  "llvm.riscv.vmadc.carry.in",
+  "llvm.riscv.vmadd",
+  "llvm.riscv.vmadd.mask",
+  "llvm.riscv.vmand",
+  "llvm.riscv.vmandnot",
+  "llvm.riscv.vmax",
+  "llvm.riscv.vmax.mask",
+  "llvm.riscv.vmaxu",
+  "llvm.riscv.vmaxu.mask",
+  "llvm.riscv.vmclr",
+  "llvm.riscv.vmerge",
+  "llvm.riscv.vmfeq",
+  "llvm.riscv.vmfeq.mask",
+  "llvm.riscv.vmfge",
+  "llvm.riscv.vmfge.mask",
+  "llvm.riscv.vmfgt",
+  "llvm.riscv.vmfgt.mask",
+  "llvm.riscv.vmfle",
+  "llvm.riscv.vmfle.mask",
+  "llvm.riscv.vmflt",
+  "llvm.riscv.vmflt.mask",
+  "llvm.riscv.vmfne",
+  "llvm.riscv.vmfne.mask",
+  "llvm.riscv.vmin",
+  "llvm.riscv.vmin.mask",
+  "llvm.riscv.vminu",
+  "llvm.riscv.vminu.mask",
+  "llvm.riscv.vmnand",
+  "llvm.riscv.vmnor",
+  "llvm.riscv.vmor",
+  "llvm.riscv.vmornot",
+  "llvm.riscv.vmsbc",
+  "llvm.riscv.vmsbc.borrow.in",
+  "llvm.riscv.vmsbf",
+  "llvm.riscv.vmsbf.mask",
+  "llvm.riscv.vmseq",
+  "llvm.riscv.vmseq.mask",
+  "llvm.riscv.vmset",
+  "llvm.riscv.vmsgt",
+  "llvm.riscv.vmsgt.mask",
+  "llvm.riscv.vmsgtu",
+  "llvm.riscv.vmsgtu.mask",
+  "llvm.riscv.vmsif",
+  "llvm.riscv.vmsif.mask",
+  "llvm.riscv.vmsle",
+  "llvm.riscv.vmsle.mask",
+  "llvm.riscv.vmsleu",
+  "llvm.riscv.vmsleu.mask",
+  "llvm.riscv.vmslt",
+  "llvm.riscv.vmslt.mask",
+  "llvm.riscv.vmsltu",
+  "llvm.riscv.vmsltu.mask",
+  "llvm.riscv.vmsne",
+  "llvm.riscv.vmsne.mask",
+  "llvm.riscv.vmsof",
+  "llvm.riscv.vmsof.mask",
+  "llvm.riscv.vmul",
+  "llvm.riscv.vmul.mask",
+  "llvm.riscv.vmulh",
+  "llvm.riscv.vmulh.mask",
+  "llvm.riscv.vmulhsu",
+  "llvm.riscv.vmulhsu.mask",
+  "llvm.riscv.vmulhu",
+  "llvm.riscv.vmulhu.mask",
+  "llvm.riscv.vmv.s.x",
+  "llvm.riscv.vmv.v.v",
+  "llvm.riscv.vmv.v.x",
+  "llvm.riscv.vmv.x.s",
+  "llvm.riscv.vmxnor",
+  "llvm.riscv.vmxor",
+  "llvm.riscv.vnclip",
+  "llvm.riscv.vnclip.mask",
+  "llvm.riscv.vnclipu",
+  "llvm.riscv.vnclipu.mask",
+  "llvm.riscv.vnmsac",
+  "llvm.riscv.vnmsac.mask",
+  "llvm.riscv.vnmsub",
+  "llvm.riscv.vnmsub.mask",
+  "llvm.riscv.vnsra",
+  "llvm.riscv.vnsra.mask",
+  "llvm.riscv.vnsrl",
+  "llvm.riscv.vnsrl.mask",
+  "llvm.riscv.vor",
+  "llvm.riscv.vor.mask",
+  "llvm.riscv.vpopc",
+  "llvm.riscv.vpopc.mask",
+  "llvm.riscv.vredand",
+  "llvm.riscv.vredand.mask",
+  "llvm.riscv.vredmax",
+  "llvm.riscv.vredmax.mask",
+  "llvm.riscv.vredmaxu",
+  "llvm.riscv.vredmaxu.mask",
+  "llvm.riscv.vredmin",
+  "llvm.riscv.vredmin.mask",
+  "llvm.riscv.vredminu",
+  "llvm.riscv.vredminu.mask",
+  "llvm.riscv.vredor",
+  "llvm.riscv.vredor.mask",
+  "llvm.riscv.vredsum",
+  "llvm.riscv.vredsum.mask",
+  "llvm.riscv.vredxor",
+  "llvm.riscv.vredxor.mask",
+  "llvm.riscv.vrem",
+  "llvm.riscv.vrem.mask",
+  "llvm.riscv.vremu",
+  "llvm.riscv.vremu.mask",
+  "llvm.riscv.vrgather",
+  "llvm.riscv.vrgather.mask",
+  "llvm.riscv.vrsub",
+  "llvm.riscv.vrsub.mask",
+  "llvm.riscv.vsadd",
+  "llvm.riscv.vsadd.mask",
+  "llvm.riscv.vsaddu",
+  "llvm.riscv.vsaddu.mask",
+  "llvm.riscv.vsbc",
+  "llvm.riscv.vse",
+  "llvm.riscv.vse.mask",
+  "llvm.riscv.vsetvli",
+  "llvm.riscv.vsetvlimax",
+  "llvm.riscv.vsext",
+  "llvm.riscv.vsext.mask",
+  "llvm.riscv.vslide1down",
+  "llvm.riscv.vslide1down.mask",
+  "llvm.riscv.vslide1up",
+  "llvm.riscv.vslide1up.mask",
+  "llvm.riscv.vslidedown",
+  "llvm.riscv.vslidedown.mask",
+  "llvm.riscv.vslideup",
+  "llvm.riscv.vslideup.mask",
+  "llvm.riscv.vsll",
+  "llvm.riscv.vsll.mask",
+  "llvm.riscv.vsmul",
+  "llvm.riscv.vsmul.mask",
+  "llvm.riscv.vsra",
+  "llvm.riscv.vsra.mask",
+  "llvm.riscv.vsrl",
+  "llvm.riscv.vsrl.mask",
+  "llvm.riscv.vsse",
+  "llvm.riscv.vsse.mask",
+  "llvm.riscv.vssra",
+  "llvm.riscv.vssra.mask",
+  "llvm.riscv.vssrl",
+  "llvm.riscv.vssrl.mask",
+  "llvm.riscv.vssub",
+  "llvm.riscv.vssub.mask",
+  "llvm.riscv.vssubu",
+  "llvm.riscv.vssubu.mask",
+  "llvm.riscv.vsub",
+  "llvm.riscv.vsub.mask",
+  "llvm.riscv.vsuxe",
+  "llvm.riscv.vsuxe.mask",
+  "llvm.riscv.vsxe",
+  "llvm.riscv.vsxe.mask",
+  "llvm.riscv.vwadd",
+  "llvm.riscv.vwadd.mask",
+  "llvm.riscv.vwadd.w",
+  "llvm.riscv.vwadd.w.mask",
+  "llvm.riscv.vwaddu",
+  "llvm.riscv.vwaddu.mask",
+  "llvm.riscv.vwaddu.w",
+  "llvm.riscv.vwaddu.w.mask",
+  "llvm.riscv.vwmacc",
+  "llvm.riscv.vwmacc.mask",
+  "llvm.riscv.vwmaccsu",
+  "llvm.riscv.vwmaccsu.mask",
+  "llvm.riscv.vwmaccu",
+  "llvm.riscv.vwmaccu.mask",
+  "llvm.riscv.vwmaccus",
+  "llvm.riscv.vwmaccus.mask",
+  "llvm.riscv.vwmul",
+  "llvm.riscv.vwmul.mask",
+  "llvm.riscv.vwmulsu",
+  "llvm.riscv.vwmulsu.mask",
+  "llvm.riscv.vwmulu",
+  "llvm.riscv.vwmulu.mask",
+  "llvm.riscv.vwredsum",
+  "llvm.riscv.vwredsum.mask",
+  "llvm.riscv.vwredsumu",
+  "llvm.riscv.vwredsumu.mask",
+  "llvm.riscv.vwsub",
+  "llvm.riscv.vwsub.mask",
+  "llvm.riscv.vwsub.w",
+  "llvm.riscv.vwsub.w.mask",
+  "llvm.riscv.vwsubu",
+  "llvm.riscv.vwsubu.mask",
+  "llvm.riscv.vwsubu.w",
+  "llvm.riscv.vwsubu.w.mask",
+  "llvm.riscv.vxor",
+  "llvm.riscv.vxor.mask",
+  "llvm.riscv.vzext",
+  "llvm.riscv.vzext.mask",
   "llvm.s390.efpc",
   "llvm.s390.etnd",
   "llvm.s390.lcbb",
@@ -5759,10 +7203,12 @@
   "llvm.s390.vscbiq",
   "llvm.s390.vsl",
   "llvm.s390.vslb",
+  "llvm.s390.vsld",
   "llvm.s390.vsldb",
   "llvm.s390.vsq",
   "llvm.s390.vsra",
   "llvm.s390.vsrab",
+  "llvm.s390.vsrd",
   "llvm.s390.vsrl",
   "llvm.s390.vsrlb",
   "llvm.s390.vstl",
@@ -5779,6 +7225,12 @@
   "llvm.s390.vstrczh",
   "llvm.s390.vstrczhs",
   "llvm.s390.vstrl",
+  "llvm.s390.vstrsb",
+  "llvm.s390.vstrsf",
+  "llvm.s390.vstrsh",
+  "llvm.s390.vstrszb",
+  "llvm.s390.vstrszf",
+  "llvm.s390.vstrszh",
   "llvm.s390.vsumb",
   "llvm.s390.vsumgf",
   "llvm.s390.vsumgh",
@@ -5798,27 +7250,1291 @@
   "llvm.s390.vupllb",
   "llvm.s390.vupllf",
   "llvm.s390.vupllh",
+  "llvm.ve.vl.andm.MMM",
+  "llvm.ve.vl.andm.mmm",
+  "llvm.ve.vl.eqvm.MMM",
+  "llvm.ve.vl.eqvm.mmm",
+  "llvm.ve.vl.extract.vm512l",
+  "llvm.ve.vl.extract.vm512u",
+  "llvm.ve.vl.insert.vm512l",
+  "llvm.ve.vl.insert.vm512u",
+  "llvm.ve.vl.lsv.vvss",
+  "llvm.ve.vl.lvm.MMss",
+  "llvm.ve.vl.lvm.mmss",
+  "llvm.ve.vl.lvsd.svs",
+  "llvm.ve.vl.lvsl.svs",
+  "llvm.ve.vl.lvss.svs",
+  "llvm.ve.vl.lzvm.sml",
+  "llvm.ve.vl.negm.MM",
+  "llvm.ve.vl.negm.mm",
+  "llvm.ve.vl.nndm.MMM",
+  "llvm.ve.vl.nndm.mmm",
+  "llvm.ve.vl.orm.MMM",
+  "llvm.ve.vl.orm.mmm",
+  "llvm.ve.vl.pack.f32a",
+  "llvm.ve.vl.pack.f32p",
+  "llvm.ve.vl.pcvm.sml",
+  "llvm.ve.vl.pfchv.ssl",
+  "llvm.ve.vl.pfchvnc.ssl",
+  "llvm.ve.vl.pvadds.vsvMvl",
+  "llvm.ve.vl.pvadds.vsvl",
+  "llvm.ve.vl.pvadds.vsvvl",
+  "llvm.ve.vl.pvadds.vvvMvl",
+  "llvm.ve.vl.pvadds.vvvl",
+  "llvm.ve.vl.pvadds.vvvvl",
+  "llvm.ve.vl.pvaddu.vsvMvl",
+  "llvm.ve.vl.pvaddu.vsvl",
+  "llvm.ve.vl.pvaddu.vsvvl",
+  "llvm.ve.vl.pvaddu.vvvMvl",
+  "llvm.ve.vl.pvaddu.vvvl",
+  "llvm.ve.vl.pvaddu.vvvvl",
+  "llvm.ve.vl.pvand.vsvMvl",
+  "llvm.ve.vl.pvand.vsvl",
+  "llvm.ve.vl.pvand.vsvvl",
+  "llvm.ve.vl.pvand.vvvMvl",
+  "llvm.ve.vl.pvand.vvvl",
+  "llvm.ve.vl.pvand.vvvvl",
+  "llvm.ve.vl.pvbrd.vsMvl",
+  "llvm.ve.vl.pvbrd.vsl",
+  "llvm.ve.vl.pvbrd.vsvl",
+  "llvm.ve.vl.pvcmps.vsvMvl",
+  "llvm.ve.vl.pvcmps.vsvl",
+  "llvm.ve.vl.pvcmps.vsvvl",
+  "llvm.ve.vl.pvcmps.vvvMvl",
+  "llvm.ve.vl.pvcmps.vvvl",
+  "llvm.ve.vl.pvcmps.vvvvl",
+  "llvm.ve.vl.pvcmpu.vsvMvl",
+  "llvm.ve.vl.pvcmpu.vsvl",
+  "llvm.ve.vl.pvcmpu.vsvvl",
+  "llvm.ve.vl.pvcmpu.vvvMvl",
+  "llvm.ve.vl.pvcmpu.vvvl",
+  "llvm.ve.vl.pvcmpu.vvvvl",
+  "llvm.ve.vl.pvcvtsw.vvl",
+  "llvm.ve.vl.pvcvtsw.vvvl",
+  "llvm.ve.vl.pvcvtws.vvMvl",
+  "llvm.ve.vl.pvcvtws.vvl",
+  "llvm.ve.vl.pvcvtws.vvvl",
+  "llvm.ve.vl.pvcvtwsrz.vvMvl",
+  "llvm.ve.vl.pvcvtwsrz.vvl",
+  "llvm.ve.vl.pvcvtwsrz.vvvl",
+  "llvm.ve.vl.pveqv.vsvMvl",
+  "llvm.ve.vl.pveqv.vsvl",
+  "llvm.ve.vl.pveqv.vsvvl",
+  "llvm.ve.vl.pveqv.vvvMvl",
+  "llvm.ve.vl.pveqv.vvvl",
+  "llvm.ve.vl.pveqv.vvvvl",
+  "llvm.ve.vl.pvfadd.vsvMvl",
+  "llvm.ve.vl.pvfadd.vsvl",
+  "llvm.ve.vl.pvfadd.vsvvl",
+  "llvm.ve.vl.pvfadd.vvvMvl",
+  "llvm.ve.vl.pvfadd.vvvl",
+  "llvm.ve.vl.pvfadd.vvvvl",
+  "llvm.ve.vl.pvfcmp.vsvMvl",
+  "llvm.ve.vl.pvfcmp.vsvl",
+  "llvm.ve.vl.pvfcmp.vsvvl",
+  "llvm.ve.vl.pvfcmp.vvvMvl",
+  "llvm.ve.vl.pvfcmp.vvvl",
+  "llvm.ve.vl.pvfcmp.vvvvl",
+  "llvm.ve.vl.pvfmad.vsvvMvl",
+  "llvm.ve.vl.pvfmad.vsvvl",
+  "llvm.ve.vl.pvfmad.vsvvvl",
+  "llvm.ve.vl.pvfmad.vvsvMvl",
+  "llvm.ve.vl.pvfmad.vvsvl",
+  "llvm.ve.vl.pvfmad.vvsvvl",
+  "llvm.ve.vl.pvfmad.vvvvMvl",
+  "llvm.ve.vl.pvfmad.vvvvl",
+  "llvm.ve.vl.pvfmad.vvvvvl",
+  "llvm.ve.vl.pvfmax.vsvMvl",
+  "llvm.ve.vl.pvfmax.vsvl",
+  "llvm.ve.vl.pvfmax.vsvvl",
+  "llvm.ve.vl.pvfmax.vvvMvl",
+  "llvm.ve.vl.pvfmax.vvvl",
+  "llvm.ve.vl.pvfmax.vvvvl",
+  "llvm.ve.vl.pvfmin.vsvMvl",
+  "llvm.ve.vl.pvfmin.vsvl",
+  "llvm.ve.vl.pvfmin.vsvvl",
+  "llvm.ve.vl.pvfmin.vvvMvl",
+  "llvm.ve.vl.pvfmin.vvvl",
+  "llvm.ve.vl.pvfmin.vvvvl",
+  "llvm.ve.vl.pvfmkaf.Ml",
+  "llvm.ve.vl.pvfmkat.Ml",
+  "llvm.ve.vl.pvfmkseq.MvMl",
+  "llvm.ve.vl.pvfmkseq.Mvl",
+  "llvm.ve.vl.pvfmkseqnan.MvMl",
+  "llvm.ve.vl.pvfmkseqnan.Mvl",
+  "llvm.ve.vl.pvfmksge.MvMl",
+  "llvm.ve.vl.pvfmksge.Mvl",
+  "llvm.ve.vl.pvfmksgenan.MvMl",
+  "llvm.ve.vl.pvfmksgenan.Mvl",
+  "llvm.ve.vl.pvfmksgt.MvMl",
+  "llvm.ve.vl.pvfmksgt.Mvl",
+  "llvm.ve.vl.pvfmksgtnan.MvMl",
+  "llvm.ve.vl.pvfmksgtnan.Mvl",
+  "llvm.ve.vl.pvfmksle.MvMl",
+  "llvm.ve.vl.pvfmksle.Mvl",
+  "llvm.ve.vl.pvfmkslenan.MvMl",
+  "llvm.ve.vl.pvfmkslenan.Mvl",
+  "llvm.ve.vl.pvfmksloeq.mvl",
+  "llvm.ve.vl.pvfmksloeq.mvml",
+  "llvm.ve.vl.pvfmksloeqnan.mvl",
+  "llvm.ve.vl.pvfmksloeqnan.mvml",
+  "llvm.ve.vl.pvfmksloge.mvl",
+  "llvm.ve.vl.pvfmksloge.mvml",
+  "llvm.ve.vl.pvfmkslogenan.mvl",
+  "llvm.ve.vl.pvfmkslogenan.mvml",
+  "llvm.ve.vl.pvfmkslogt.mvl",
+  "llvm.ve.vl.pvfmkslogt.mvml",
+  "llvm.ve.vl.pvfmkslogtnan.mvl",
+  "llvm.ve.vl.pvfmkslogtnan.mvml",
+  "llvm.ve.vl.pvfmkslole.mvl",
+  "llvm.ve.vl.pvfmkslole.mvml",
+  "llvm.ve.vl.pvfmkslolenan.mvl",
+  "llvm.ve.vl.pvfmkslolenan.mvml",
+  "llvm.ve.vl.pvfmkslolt.mvl",
+  "llvm.ve.vl.pvfmkslolt.mvml",
+  "llvm.ve.vl.pvfmksloltnan.mvl",
+  "llvm.ve.vl.pvfmksloltnan.mvml",
+  "llvm.ve.vl.pvfmkslonan.mvl",
+  "llvm.ve.vl.pvfmkslonan.mvml",
+  "llvm.ve.vl.pvfmkslone.mvl",
+  "llvm.ve.vl.pvfmkslone.mvml",
+  "llvm.ve.vl.pvfmkslonenan.mvl",
+  "llvm.ve.vl.pvfmkslonenan.mvml",
+  "llvm.ve.vl.pvfmkslonum.mvl",
+  "llvm.ve.vl.pvfmkslonum.mvml",
+  "llvm.ve.vl.pvfmkslt.MvMl",
+  "llvm.ve.vl.pvfmkslt.Mvl",
+  "llvm.ve.vl.pvfmksltnan.MvMl",
+  "llvm.ve.vl.pvfmksltnan.Mvl",
+  "llvm.ve.vl.pvfmksnan.MvMl",
+  "llvm.ve.vl.pvfmksnan.Mvl",
+  "llvm.ve.vl.pvfmksne.MvMl",
+  "llvm.ve.vl.pvfmksne.Mvl",
+  "llvm.ve.vl.pvfmksnenan.MvMl",
+  "llvm.ve.vl.pvfmksnenan.Mvl",
+  "llvm.ve.vl.pvfmksnum.MvMl",
+  "llvm.ve.vl.pvfmksnum.Mvl",
+  "llvm.ve.vl.pvfmksupeq.mvl",
+  "llvm.ve.vl.pvfmksupeq.mvml",
+  "llvm.ve.vl.pvfmksupeqnan.mvl",
+  "llvm.ve.vl.pvfmksupeqnan.mvml",
+  "llvm.ve.vl.pvfmksupge.mvl",
+  "llvm.ve.vl.pvfmksupge.mvml",
+  "llvm.ve.vl.pvfmksupgenan.mvl",
+  "llvm.ve.vl.pvfmksupgenan.mvml",
+  "llvm.ve.vl.pvfmksupgt.mvl",
+  "llvm.ve.vl.pvfmksupgt.mvml",
+  "llvm.ve.vl.pvfmksupgtnan.mvl",
+  "llvm.ve.vl.pvfmksupgtnan.mvml",
+  "llvm.ve.vl.pvfmksuple.mvl",
+  "llvm.ve.vl.pvfmksuple.mvml",
+  "llvm.ve.vl.pvfmksuplenan.mvl",
+  "llvm.ve.vl.pvfmksuplenan.mvml",
+  "llvm.ve.vl.pvfmksuplt.mvl",
+  "llvm.ve.vl.pvfmksuplt.mvml",
+  "llvm.ve.vl.pvfmksupltnan.mvl",
+  "llvm.ve.vl.pvfmksupltnan.mvml",
+  "llvm.ve.vl.pvfmksupnan.mvl",
+  "llvm.ve.vl.pvfmksupnan.mvml",
+  "llvm.ve.vl.pvfmksupne.mvl",
+  "llvm.ve.vl.pvfmksupne.mvml",
+  "llvm.ve.vl.pvfmksupnenan.mvl",
+  "llvm.ve.vl.pvfmksupnenan.mvml",
+  "llvm.ve.vl.pvfmksupnum.mvl",
+  "llvm.ve.vl.pvfmksupnum.mvml",
+  "llvm.ve.vl.pvfmkweq.MvMl",
+  "llvm.ve.vl.pvfmkweq.Mvl",
+  "llvm.ve.vl.pvfmkweqnan.MvMl",
+  "llvm.ve.vl.pvfmkweqnan.Mvl",
+  "llvm.ve.vl.pvfmkwge.MvMl",
+  "llvm.ve.vl.pvfmkwge.Mvl",
+  "llvm.ve.vl.pvfmkwgenan.MvMl",
+  "llvm.ve.vl.pvfmkwgenan.Mvl",
+  "llvm.ve.vl.pvfmkwgt.MvMl",
+  "llvm.ve.vl.pvfmkwgt.Mvl",
+  "llvm.ve.vl.pvfmkwgtnan.MvMl",
+  "llvm.ve.vl.pvfmkwgtnan.Mvl",
+  "llvm.ve.vl.pvfmkwle.MvMl",
+  "llvm.ve.vl.pvfmkwle.Mvl",
+  "llvm.ve.vl.pvfmkwlenan.MvMl",
+  "llvm.ve.vl.pvfmkwlenan.Mvl",
+  "llvm.ve.vl.pvfmkwloeq.mvl",
+  "llvm.ve.vl.pvfmkwloeq.mvml",
+  "llvm.ve.vl.pvfmkwloeqnan.mvl",
+  "llvm.ve.vl.pvfmkwloeqnan.mvml",
+  "llvm.ve.vl.pvfmkwloge.mvl",
+  "llvm.ve.vl.pvfmkwloge.mvml",
+  "llvm.ve.vl.pvfmkwlogenan.mvl",
+  "llvm.ve.vl.pvfmkwlogenan.mvml",
+  "llvm.ve.vl.pvfmkwlogt.mvl",
+  "llvm.ve.vl.pvfmkwlogt.mvml",
+  "llvm.ve.vl.pvfmkwlogtnan.mvl",
+  "llvm.ve.vl.pvfmkwlogtnan.mvml",
+  "llvm.ve.vl.pvfmkwlole.mvl",
+  "llvm.ve.vl.pvfmkwlole.mvml",
+  "llvm.ve.vl.pvfmkwlolenan.mvl",
+  "llvm.ve.vl.pvfmkwlolenan.mvml",
+  "llvm.ve.vl.pvfmkwlolt.mvl",
+  "llvm.ve.vl.pvfmkwlolt.mvml",
+  "llvm.ve.vl.pvfmkwloltnan.mvl",
+  "llvm.ve.vl.pvfmkwloltnan.mvml",
+  "llvm.ve.vl.pvfmkwlonan.mvl",
+  "llvm.ve.vl.pvfmkwlonan.mvml",
+  "llvm.ve.vl.pvfmkwlone.mvl",
+  "llvm.ve.vl.pvfmkwlone.mvml",
+  "llvm.ve.vl.pvfmkwlonenan.mvl",
+  "llvm.ve.vl.pvfmkwlonenan.mvml",
+  "llvm.ve.vl.pvfmkwlonum.mvl",
+  "llvm.ve.vl.pvfmkwlonum.mvml",
+  "llvm.ve.vl.pvfmkwlt.MvMl",
+  "llvm.ve.vl.pvfmkwlt.Mvl",
+  "llvm.ve.vl.pvfmkwltnan.MvMl",
+  "llvm.ve.vl.pvfmkwltnan.Mvl",
+  "llvm.ve.vl.pvfmkwnan.MvMl",
+  "llvm.ve.vl.pvfmkwnan.Mvl",
+  "llvm.ve.vl.pvfmkwne.MvMl",
+  "llvm.ve.vl.pvfmkwne.Mvl",
+  "llvm.ve.vl.pvfmkwnenan.MvMl",
+  "llvm.ve.vl.pvfmkwnenan.Mvl",
+  "llvm.ve.vl.pvfmkwnum.MvMl",
+  "llvm.ve.vl.pvfmkwnum.Mvl",
+  "llvm.ve.vl.pvfmkwupeq.mvl",
+  "llvm.ve.vl.pvfmkwupeq.mvml",
+  "llvm.ve.vl.pvfmkwupeqnan.mvl",
+  "llvm.ve.vl.pvfmkwupeqnan.mvml",
+  "llvm.ve.vl.pvfmkwupge.mvl",
+  "llvm.ve.vl.pvfmkwupge.mvml",
+  "llvm.ve.vl.pvfmkwupgenan.mvl",
+  "llvm.ve.vl.pvfmkwupgenan.mvml",
+  "llvm.ve.vl.pvfmkwupgt.mvl",
+  "llvm.ve.vl.pvfmkwupgt.mvml",
+  "llvm.ve.vl.pvfmkwupgtnan.mvl",
+  "llvm.ve.vl.pvfmkwupgtnan.mvml",
+  "llvm.ve.vl.pvfmkwuple.mvl",
+  "llvm.ve.vl.pvfmkwuple.mvml",
+  "llvm.ve.vl.pvfmkwuplenan.mvl",
+  "llvm.ve.vl.pvfmkwuplenan.mvml",
+  "llvm.ve.vl.pvfmkwuplt.mvl",
+  "llvm.ve.vl.pvfmkwuplt.mvml",
+  "llvm.ve.vl.pvfmkwupltnan.mvl",
+  "llvm.ve.vl.pvfmkwupltnan.mvml",
+  "llvm.ve.vl.pvfmkwupnan.mvl",
+  "llvm.ve.vl.pvfmkwupnan.mvml",
+  "llvm.ve.vl.pvfmkwupne.mvl",
+  "llvm.ve.vl.pvfmkwupne.mvml",
+  "llvm.ve.vl.pvfmkwupnenan.mvl",
+  "llvm.ve.vl.pvfmkwupnenan.mvml",
+  "llvm.ve.vl.pvfmkwupnum.mvl",
+  "llvm.ve.vl.pvfmkwupnum.mvml",
+  "llvm.ve.vl.pvfmsb.vsvvMvl",
+  "llvm.ve.vl.pvfmsb.vsvvl",
+  "llvm.ve.vl.pvfmsb.vsvvvl",
+  "llvm.ve.vl.pvfmsb.vvsvMvl",
+  "llvm.ve.vl.pvfmsb.vvsvl",
+  "llvm.ve.vl.pvfmsb.vvsvvl",
+  "llvm.ve.vl.pvfmsb.vvvvMvl",
+  "llvm.ve.vl.pvfmsb.vvvvl",
+  "llvm.ve.vl.pvfmsb.vvvvvl",
+  "llvm.ve.vl.pvfmul.vsvMvl",
+  "llvm.ve.vl.pvfmul.vsvl",
+  "llvm.ve.vl.pvfmul.vsvvl",
+  "llvm.ve.vl.pvfmul.vvvMvl",
+  "llvm.ve.vl.pvfmul.vvvl",
+  "llvm.ve.vl.pvfmul.vvvvl",
+  "llvm.ve.vl.pvfnmad.vsvvMvl",
+  "llvm.ve.vl.pvfnmad.vsvvl",
+  "llvm.ve.vl.pvfnmad.vsvvvl",
+  "llvm.ve.vl.pvfnmad.vvsvMvl",
+  "llvm.ve.vl.pvfnmad.vvsvl",
+  "llvm.ve.vl.pvfnmad.vvsvvl",
+  "llvm.ve.vl.pvfnmad.vvvvMvl",
+  "llvm.ve.vl.pvfnmad.vvvvl",
+  "llvm.ve.vl.pvfnmad.vvvvvl",
+  "llvm.ve.vl.pvfnmsb.vsvvMvl",
+  "llvm.ve.vl.pvfnmsb.vsvvl",
+  "llvm.ve.vl.pvfnmsb.vsvvvl",
+  "llvm.ve.vl.pvfnmsb.vvsvMvl",
+  "llvm.ve.vl.pvfnmsb.vvsvl",
+  "llvm.ve.vl.pvfnmsb.vvsvvl",
+  "llvm.ve.vl.pvfnmsb.vvvvMvl",
+  "llvm.ve.vl.pvfnmsb.vvvvl",
+  "llvm.ve.vl.pvfnmsb.vvvvvl",
+  "llvm.ve.vl.pvfsub.vsvMvl",
+  "llvm.ve.vl.pvfsub.vsvl",
+  "llvm.ve.vl.pvfsub.vsvvl",
+  "llvm.ve.vl.pvfsub.vvvMvl",
+  "llvm.ve.vl.pvfsub.vvvl",
+  "llvm.ve.vl.pvfsub.vvvvl",
+  "llvm.ve.vl.pvmaxs.vsvMvl",
+  "llvm.ve.vl.pvmaxs.vsvl",
+  "llvm.ve.vl.pvmaxs.vsvvl",
+  "llvm.ve.vl.pvmaxs.vvvMvl",
+  "llvm.ve.vl.pvmaxs.vvvl",
+  "llvm.ve.vl.pvmaxs.vvvvl",
+  "llvm.ve.vl.pvmins.vsvMvl",
+  "llvm.ve.vl.pvmins.vsvl",
+  "llvm.ve.vl.pvmins.vsvvl",
+  "llvm.ve.vl.pvmins.vvvMvl",
+  "llvm.ve.vl.pvmins.vvvl",
+  "llvm.ve.vl.pvmins.vvvvl",
+  "llvm.ve.vl.pvor.vsvMvl",
+  "llvm.ve.vl.pvor.vsvl",
+  "llvm.ve.vl.pvor.vsvvl",
+  "llvm.ve.vl.pvor.vvvMvl",
+  "llvm.ve.vl.pvor.vvvl",
+  "llvm.ve.vl.pvor.vvvvl",
+  "llvm.ve.vl.pvrcp.vvl",
+  "llvm.ve.vl.pvrcp.vvvl",
+  "llvm.ve.vl.pvrsqrt.vvl",
+  "llvm.ve.vl.pvrsqrt.vvvl",
+  "llvm.ve.vl.pvrsqrtnex.vvl",
+  "llvm.ve.vl.pvrsqrtnex.vvvl",
+  "llvm.ve.vl.pvseq.vl",
+  "llvm.ve.vl.pvseq.vvl",
+  "llvm.ve.vl.pvseqlo.vl",
+  "llvm.ve.vl.pvseqlo.vvl",
+  "llvm.ve.vl.pvsequp.vl",
+  "llvm.ve.vl.pvsequp.vvl",
+  "llvm.ve.vl.pvsla.vvsMvl",
+  "llvm.ve.vl.pvsla.vvsl",
+  "llvm.ve.vl.pvsla.vvsvl",
+  "llvm.ve.vl.pvsla.vvvMvl",
+  "llvm.ve.vl.pvsla.vvvl",
+  "llvm.ve.vl.pvsla.vvvvl",
+  "llvm.ve.vl.pvsll.vvsMvl",
+  "llvm.ve.vl.pvsll.vvsl",
+  "llvm.ve.vl.pvsll.vvsvl",
+  "llvm.ve.vl.pvsll.vvvMvl",
+  "llvm.ve.vl.pvsll.vvvl",
+  "llvm.ve.vl.pvsll.vvvvl",
+  "llvm.ve.vl.pvsra.vvsMvl",
+  "llvm.ve.vl.pvsra.vvsl",
+  "llvm.ve.vl.pvsra.vvsvl",
+  "llvm.ve.vl.pvsra.vvvMvl",
+  "llvm.ve.vl.pvsra.vvvl",
+  "llvm.ve.vl.pvsra.vvvvl",
+  "llvm.ve.vl.pvsrl.vvsMvl",
+  "llvm.ve.vl.pvsrl.vvsl",
+  "llvm.ve.vl.pvsrl.vvsvl",
+  "llvm.ve.vl.pvsrl.vvvMvl",
+  "llvm.ve.vl.pvsrl.vvvl",
+  "llvm.ve.vl.pvsrl.vvvvl",
+  "llvm.ve.vl.pvsubs.vsvMvl",
+  "llvm.ve.vl.pvsubs.vsvl",
+  "llvm.ve.vl.pvsubs.vsvvl",
+  "llvm.ve.vl.pvsubs.vvvMvl",
+  "llvm.ve.vl.pvsubs.vvvl",
+  "llvm.ve.vl.pvsubs.vvvvl",
+  "llvm.ve.vl.pvsubu.vsvMvl",
+  "llvm.ve.vl.pvsubu.vsvl",
+  "llvm.ve.vl.pvsubu.vsvvl",
+  "llvm.ve.vl.pvsubu.vvvMvl",
+  "llvm.ve.vl.pvsubu.vvvl",
+  "llvm.ve.vl.pvsubu.vvvvl",
+  "llvm.ve.vl.pvxor.vsvMvl",
+  "llvm.ve.vl.pvxor.vsvl",
+  "llvm.ve.vl.pvxor.vsvvl",
+  "llvm.ve.vl.pvxor.vvvMvl",
+  "llvm.ve.vl.pvxor.vvvl",
+  "llvm.ve.vl.pvxor.vvvvl",
+  "llvm.ve.vl.svm.sMs",
+  "llvm.ve.vl.svm.sms",
+  "llvm.ve.vl.svob",
+  "llvm.ve.vl.tovm.sml",
+  "llvm.ve.vl.vaddsl.vsvl",
+  "llvm.ve.vl.vaddsl.vsvmvl",
+  "llvm.ve.vl.vaddsl.vsvvl",
+  "llvm.ve.vl.vaddsl.vvvl",
+  "llvm.ve.vl.vaddsl.vvvmvl",
+  "llvm.ve.vl.vaddsl.vvvvl",
+  "llvm.ve.vl.vaddswsx.vsvl",
+  "llvm.ve.vl.vaddswsx.vsvmvl",
+  "llvm.ve.vl.vaddswsx.vsvvl",
+  "llvm.ve.vl.vaddswsx.vvvl",
+  "llvm.ve.vl.vaddswsx.vvvmvl",
+  "llvm.ve.vl.vaddswsx.vvvvl",
+  "llvm.ve.vl.vaddswzx.vsvl",
+  "llvm.ve.vl.vaddswzx.vsvmvl",
+  "llvm.ve.vl.vaddswzx.vsvvl",
+  "llvm.ve.vl.vaddswzx.vvvl",
+  "llvm.ve.vl.vaddswzx.vvvmvl",
+  "llvm.ve.vl.vaddswzx.vvvvl",
+  "llvm.ve.vl.vaddul.vsvl",
+  "llvm.ve.vl.vaddul.vsvmvl",
+  "llvm.ve.vl.vaddul.vsvvl",
+  "llvm.ve.vl.vaddul.vvvl",
+  "llvm.ve.vl.vaddul.vvvmvl",
+  "llvm.ve.vl.vaddul.vvvvl",
+  "llvm.ve.vl.vadduw.vsvl",
+  "llvm.ve.vl.vadduw.vsvmvl",
+  "llvm.ve.vl.vadduw.vsvvl",
+  "llvm.ve.vl.vadduw.vvvl",
+  "llvm.ve.vl.vadduw.vvvmvl",
+  "llvm.ve.vl.vadduw.vvvvl",
+  "llvm.ve.vl.vand.vsvl",
+  "llvm.ve.vl.vand.vsvmvl",
+  "llvm.ve.vl.vand.vsvvl",
+  "llvm.ve.vl.vand.vvvl",
+  "llvm.ve.vl.vand.vvvmvl",
+  "llvm.ve.vl.vand.vvvvl",
+  "llvm.ve.vl.vbrdd.vsl",
+  "llvm.ve.vl.vbrdd.vsmvl",
+  "llvm.ve.vl.vbrdd.vsvl",
+  "llvm.ve.vl.vbrdl.vsl",
+  "llvm.ve.vl.vbrdl.vsmvl",
+  "llvm.ve.vl.vbrdl.vsvl",
+  "llvm.ve.vl.vbrds.vsl",
+  "llvm.ve.vl.vbrds.vsmvl",
+  "llvm.ve.vl.vbrds.vsvl",
+  "llvm.ve.vl.vbrdw.vsl",
+  "llvm.ve.vl.vbrdw.vsmvl",
+  "llvm.ve.vl.vbrdw.vsvl",
+  "llvm.ve.vl.vcmpsl.vsvl",
+  "llvm.ve.vl.vcmpsl.vsvmvl",
+  "llvm.ve.vl.vcmpsl.vsvvl",
+  "llvm.ve.vl.vcmpsl.vvvl",
+  "llvm.ve.vl.vcmpsl.vvvmvl",
+  "llvm.ve.vl.vcmpsl.vvvvl",
+  "llvm.ve.vl.vcmpswsx.vsvl",
+  "llvm.ve.vl.vcmpswsx.vsvmvl",
+  "llvm.ve.vl.vcmpswsx.vsvvl",
+  "llvm.ve.vl.vcmpswsx.vvvl",
+  "llvm.ve.vl.vcmpswsx.vvvmvl",
+  "llvm.ve.vl.vcmpswsx.vvvvl",
+  "llvm.ve.vl.vcmpswzx.vsvl",
+  "llvm.ve.vl.vcmpswzx.vsvmvl",
+  "llvm.ve.vl.vcmpswzx.vsvvl",
+  "llvm.ve.vl.vcmpswzx.vvvl",
+  "llvm.ve.vl.vcmpswzx.vvvmvl",
+  "llvm.ve.vl.vcmpswzx.vvvvl",
+  "llvm.ve.vl.vcmpul.vsvl",
+  "llvm.ve.vl.vcmpul.vsvmvl",
+  "llvm.ve.vl.vcmpul.vsvvl",
+  "llvm.ve.vl.vcmpul.vvvl",
+  "llvm.ve.vl.vcmpul.vvvmvl",
+  "llvm.ve.vl.vcmpul.vvvvl",
+  "llvm.ve.vl.vcmpuw.vsvl",
+  "llvm.ve.vl.vcmpuw.vsvmvl",
+  "llvm.ve.vl.vcmpuw.vsvvl",
+  "llvm.ve.vl.vcmpuw.vvvl",
+  "llvm.ve.vl.vcmpuw.vvvmvl",
+  "llvm.ve.vl.vcmpuw.vvvvl",
+  "llvm.ve.vl.vcp.vvmvl",
+  "llvm.ve.vl.vcvtdl.vvl",
+  "llvm.ve.vl.vcvtdl.vvvl",
+  "llvm.ve.vl.vcvtds.vvl",
+  "llvm.ve.vl.vcvtds.vvvl",
+  "llvm.ve.vl.vcvtdw.vvl",
+  "llvm.ve.vl.vcvtdw.vvvl",
+  "llvm.ve.vl.vcvtld.vvl",
+  "llvm.ve.vl.vcvtld.vvmvl",
+  "llvm.ve.vl.vcvtld.vvvl",
+  "llvm.ve.vl.vcvtldrz.vvl",
+  "llvm.ve.vl.vcvtldrz.vvmvl",
+  "llvm.ve.vl.vcvtldrz.vvvl",
+  "llvm.ve.vl.vcvtsd.vvl",
+  "llvm.ve.vl.vcvtsd.vvvl",
+  "llvm.ve.vl.vcvtsw.vvl",
+  "llvm.ve.vl.vcvtsw.vvvl",
+  "llvm.ve.vl.vcvtwdsx.vvl",
+  "llvm.ve.vl.vcvtwdsx.vvmvl",
+  "llvm.ve.vl.vcvtwdsx.vvvl",
+  "llvm.ve.vl.vcvtwdsxrz.vvl",
+  "llvm.ve.vl.vcvtwdsxrz.vvmvl",
+  "llvm.ve.vl.vcvtwdsxrz.vvvl",
+  "llvm.ve.vl.vcvtwdzx.vvl",
+  "llvm.ve.vl.vcvtwdzx.vvmvl",
+  "llvm.ve.vl.vcvtwdzx.vvvl",
+  "llvm.ve.vl.vcvtwdzxrz.vvl",
+  "llvm.ve.vl.vcvtwdzxrz.vvmvl",
+  "llvm.ve.vl.vcvtwdzxrz.vvvl",
+  "llvm.ve.vl.vcvtwssx.vvl",
+  "llvm.ve.vl.vcvtwssx.vvmvl",
+  "llvm.ve.vl.vcvtwssx.vvvl",
+  "llvm.ve.vl.vcvtwssxrz.vvl",
+  "llvm.ve.vl.vcvtwssxrz.vvmvl",
+  "llvm.ve.vl.vcvtwssxrz.vvvl",
+  "llvm.ve.vl.vcvtwszx.vvl",
+  "llvm.ve.vl.vcvtwszx.vvmvl",
+  "llvm.ve.vl.vcvtwszx.vvvl",
+  "llvm.ve.vl.vcvtwszxrz.vvl",
+  "llvm.ve.vl.vcvtwszxrz.vvmvl",
+  "llvm.ve.vl.vcvtwszxrz.vvvl",
+  "llvm.ve.vl.vdivsl.vsvl",
+  "llvm.ve.vl.vdivsl.vsvmvl",
+  "llvm.ve.vl.vdivsl.vsvvl",
+  "llvm.ve.vl.vdivsl.vvsl",
+  "llvm.ve.vl.vdivsl.vvsmvl",
+  "llvm.ve.vl.vdivsl.vvsvl",
+  "llvm.ve.vl.vdivsl.vvvl",
+  "llvm.ve.vl.vdivsl.vvvmvl",
+  "llvm.ve.vl.vdivsl.vvvvl",
+  "llvm.ve.vl.vdivswsx.vsvl",
+  "llvm.ve.vl.vdivswsx.vsvmvl",
+  "llvm.ve.vl.vdivswsx.vsvvl",
+  "llvm.ve.vl.vdivswsx.vvsl",
+  "llvm.ve.vl.vdivswsx.vvsmvl",
+  "llvm.ve.vl.vdivswsx.vvsvl",
+  "llvm.ve.vl.vdivswsx.vvvl",
+  "llvm.ve.vl.vdivswsx.vvvmvl",
+  "llvm.ve.vl.vdivswsx.vvvvl",
+  "llvm.ve.vl.vdivswzx.vsvl",
+  "llvm.ve.vl.vdivswzx.vsvmvl",
+  "llvm.ve.vl.vdivswzx.vsvvl",
+  "llvm.ve.vl.vdivswzx.vvsl",
+  "llvm.ve.vl.vdivswzx.vvsmvl",
+  "llvm.ve.vl.vdivswzx.vvsvl",
+  "llvm.ve.vl.vdivswzx.vvvl",
+  "llvm.ve.vl.vdivswzx.vvvmvl",
+  "llvm.ve.vl.vdivswzx.vvvvl",
+  "llvm.ve.vl.vdivul.vsvl",
+  "llvm.ve.vl.vdivul.vsvmvl",
+  "llvm.ve.vl.vdivul.vsvvl",
+  "llvm.ve.vl.vdivul.vvsl",
+  "llvm.ve.vl.vdivul.vvsmvl",
+  "llvm.ve.vl.vdivul.vvsvl",
+  "llvm.ve.vl.vdivul.vvvl",
+  "llvm.ve.vl.vdivul.vvvmvl",
+  "llvm.ve.vl.vdivul.vvvvl",
+  "llvm.ve.vl.vdivuw.vsvl",
+  "llvm.ve.vl.vdivuw.vsvmvl",
+  "llvm.ve.vl.vdivuw.vsvvl",
+  "llvm.ve.vl.vdivuw.vvsl",
+  "llvm.ve.vl.vdivuw.vvsmvl",
+  "llvm.ve.vl.vdivuw.vvsvl",
+  "llvm.ve.vl.vdivuw.vvvl",
+  "llvm.ve.vl.vdivuw.vvvmvl",
+  "llvm.ve.vl.vdivuw.vvvvl",
+  "llvm.ve.vl.veqv.vsvl",
+  "llvm.ve.vl.veqv.vsvmvl",
+  "llvm.ve.vl.veqv.vsvvl",
+  "llvm.ve.vl.veqv.vvvl",
+  "llvm.ve.vl.veqv.vvvmvl",
+  "llvm.ve.vl.veqv.vvvvl",
+  "llvm.ve.vl.vex.vvmvl",
+  "llvm.ve.vl.vfaddd.vsvl",
+  "llvm.ve.vl.vfaddd.vsvmvl",
+  "llvm.ve.vl.vfaddd.vsvvl",
+  "llvm.ve.vl.vfaddd.vvvl",
+  "llvm.ve.vl.vfaddd.vvvmvl",
+  "llvm.ve.vl.vfaddd.vvvvl",
+  "llvm.ve.vl.vfadds.vsvl",
+  "llvm.ve.vl.vfadds.vsvmvl",
+  "llvm.ve.vl.vfadds.vsvvl",
+  "llvm.ve.vl.vfadds.vvvl",
+  "llvm.ve.vl.vfadds.vvvmvl",
+  "llvm.ve.vl.vfadds.vvvvl",
+  "llvm.ve.vl.vfcmpd.vsvl",
+  "llvm.ve.vl.vfcmpd.vsvmvl",
+  "llvm.ve.vl.vfcmpd.vsvvl",
+  "llvm.ve.vl.vfcmpd.vvvl",
+  "llvm.ve.vl.vfcmpd.vvvmvl",
+  "llvm.ve.vl.vfcmpd.vvvvl",
+  "llvm.ve.vl.vfcmps.vsvl",
+  "llvm.ve.vl.vfcmps.vsvmvl",
+  "llvm.ve.vl.vfcmps.vsvvl",
+  "llvm.ve.vl.vfcmps.vvvl",
+  "llvm.ve.vl.vfcmps.vvvmvl",
+  "llvm.ve.vl.vfcmps.vvvvl",
+  "llvm.ve.vl.vfdivd.vsvl",
+  "llvm.ve.vl.vfdivd.vsvmvl",
+  "llvm.ve.vl.vfdivd.vsvvl",
+  "llvm.ve.vl.vfdivd.vvvl",
+  "llvm.ve.vl.vfdivd.vvvmvl",
+  "llvm.ve.vl.vfdivd.vvvvl",
+  "llvm.ve.vl.vfdivs.vsvl",
+  "llvm.ve.vl.vfdivs.vsvmvl",
+  "llvm.ve.vl.vfdivs.vsvvl",
+  "llvm.ve.vl.vfdivs.vvvl",
+  "llvm.ve.vl.vfdivs.vvvmvl",
+  "llvm.ve.vl.vfdivs.vvvvl",
+  "llvm.ve.vl.vfmadd.vsvvl",
+  "llvm.ve.vl.vfmadd.vsvvmvl",
+  "llvm.ve.vl.vfmadd.vsvvvl",
+  "llvm.ve.vl.vfmadd.vvsvl",
+  "llvm.ve.vl.vfmadd.vvsvmvl",
+  "llvm.ve.vl.vfmadd.vvsvvl",
+  "llvm.ve.vl.vfmadd.vvvvl",
+  "llvm.ve.vl.vfmadd.vvvvmvl",
+  "llvm.ve.vl.vfmadd.vvvvvl",
+  "llvm.ve.vl.vfmads.vsvvl",
+  "llvm.ve.vl.vfmads.vsvvmvl",
+  "llvm.ve.vl.vfmads.vsvvvl",
+  "llvm.ve.vl.vfmads.vvsvl",
+  "llvm.ve.vl.vfmads.vvsvmvl",
+  "llvm.ve.vl.vfmads.vvsvvl",
+  "llvm.ve.vl.vfmads.vvvvl",
+  "llvm.ve.vl.vfmads.vvvvmvl",
+  "llvm.ve.vl.vfmads.vvvvvl",
+  "llvm.ve.vl.vfmaxd.vsvl",
+  "llvm.ve.vl.vfmaxd.vsvmvl",
+  "llvm.ve.vl.vfmaxd.vsvvl",
+  "llvm.ve.vl.vfmaxd.vvvl",
+  "llvm.ve.vl.vfmaxd.vvvmvl",
+  "llvm.ve.vl.vfmaxd.vvvvl",
+  "llvm.ve.vl.vfmaxs.vsvl",
+  "llvm.ve.vl.vfmaxs.vsvmvl",
+  "llvm.ve.vl.vfmaxs.vsvvl",
+  "llvm.ve.vl.vfmaxs.vvvl",
+  "llvm.ve.vl.vfmaxs.vvvmvl",
+  "llvm.ve.vl.vfmaxs.vvvvl",
+  "llvm.ve.vl.vfmind.vsvl",
+  "llvm.ve.vl.vfmind.vsvmvl",
+  "llvm.ve.vl.vfmind.vsvvl",
+  "llvm.ve.vl.vfmind.vvvl",
+  "llvm.ve.vl.vfmind.vvvmvl",
+  "llvm.ve.vl.vfmind.vvvvl",
+  "llvm.ve.vl.vfmins.vsvl",
+  "llvm.ve.vl.vfmins.vsvmvl",
+  "llvm.ve.vl.vfmins.vsvvl",
+  "llvm.ve.vl.vfmins.vvvl",
+  "llvm.ve.vl.vfmins.vvvmvl",
+  "llvm.ve.vl.vfmins.vvvvl",
+  "llvm.ve.vl.vfmkdeq.mvl",
+  "llvm.ve.vl.vfmkdeq.mvml",
+  "llvm.ve.vl.vfmkdeqnan.mvl",
+  "llvm.ve.vl.vfmkdeqnan.mvml",
+  "llvm.ve.vl.vfmkdge.mvl",
+  "llvm.ve.vl.vfmkdge.mvml",
+  "llvm.ve.vl.vfmkdgenan.mvl",
+  "llvm.ve.vl.vfmkdgenan.mvml",
+  "llvm.ve.vl.vfmkdgt.mvl",
+  "llvm.ve.vl.vfmkdgt.mvml",
+  "llvm.ve.vl.vfmkdgtnan.mvl",
+  "llvm.ve.vl.vfmkdgtnan.mvml",
+  "llvm.ve.vl.vfmkdle.mvl",
+  "llvm.ve.vl.vfmkdle.mvml",
+  "llvm.ve.vl.vfmkdlenan.mvl",
+  "llvm.ve.vl.vfmkdlenan.mvml",
+  "llvm.ve.vl.vfmkdlt.mvl",
+  "llvm.ve.vl.vfmkdlt.mvml",
+  "llvm.ve.vl.vfmkdltnan.mvl",
+  "llvm.ve.vl.vfmkdltnan.mvml",
+  "llvm.ve.vl.vfmkdnan.mvl",
+  "llvm.ve.vl.vfmkdnan.mvml",
+  "llvm.ve.vl.vfmkdne.mvl",
+  "llvm.ve.vl.vfmkdne.mvml",
+  "llvm.ve.vl.vfmkdnenan.mvl",
+  "llvm.ve.vl.vfmkdnenan.mvml",
+  "llvm.ve.vl.vfmkdnum.mvl",
+  "llvm.ve.vl.vfmkdnum.mvml",
+  "llvm.ve.vl.vfmklaf.ml",
+  "llvm.ve.vl.vfmklat.ml",
+  "llvm.ve.vl.vfmkleq.mvl",
+  "llvm.ve.vl.vfmkleq.mvml",
+  "llvm.ve.vl.vfmkleqnan.mvl",
+  "llvm.ve.vl.vfmkleqnan.mvml",
+  "llvm.ve.vl.vfmklge.mvl",
+  "llvm.ve.vl.vfmklge.mvml",
+  "llvm.ve.vl.vfmklgenan.mvl",
+  "llvm.ve.vl.vfmklgenan.mvml",
+  "llvm.ve.vl.vfmklgt.mvl",
+  "llvm.ve.vl.vfmklgt.mvml",
+  "llvm.ve.vl.vfmklgtnan.mvl",
+  "llvm.ve.vl.vfmklgtnan.mvml",
+  "llvm.ve.vl.vfmklle.mvl",
+  "llvm.ve.vl.vfmklle.mvml",
+  "llvm.ve.vl.vfmkllenan.mvl",
+  "llvm.ve.vl.vfmkllenan.mvml",
+  "llvm.ve.vl.vfmkllt.mvl",
+  "llvm.ve.vl.vfmkllt.mvml",
+  "llvm.ve.vl.vfmklltnan.mvl",
+  "llvm.ve.vl.vfmklltnan.mvml",
+  "llvm.ve.vl.vfmklnan.mvl",
+  "llvm.ve.vl.vfmklnan.mvml",
+  "llvm.ve.vl.vfmklne.mvl",
+  "llvm.ve.vl.vfmklne.mvml",
+  "llvm.ve.vl.vfmklnenan.mvl",
+  "llvm.ve.vl.vfmklnenan.mvml",
+  "llvm.ve.vl.vfmklnum.mvl",
+  "llvm.ve.vl.vfmklnum.mvml",
+  "llvm.ve.vl.vfmkseq.mvl",
+  "llvm.ve.vl.vfmkseq.mvml",
+  "llvm.ve.vl.vfmkseqnan.mvl",
+  "llvm.ve.vl.vfmkseqnan.mvml",
+  "llvm.ve.vl.vfmksge.mvl",
+  "llvm.ve.vl.vfmksge.mvml",
+  "llvm.ve.vl.vfmksgenan.mvl",
+  "llvm.ve.vl.vfmksgenan.mvml",
+  "llvm.ve.vl.vfmksgt.mvl",
+  "llvm.ve.vl.vfmksgt.mvml",
+  "llvm.ve.vl.vfmksgtnan.mvl",
+  "llvm.ve.vl.vfmksgtnan.mvml",
+  "llvm.ve.vl.vfmksle.mvl",
+  "llvm.ve.vl.vfmksle.mvml",
+  "llvm.ve.vl.vfmkslenan.mvl",
+  "llvm.ve.vl.vfmkslenan.mvml",
+  "llvm.ve.vl.vfmkslt.mvl",
+  "llvm.ve.vl.vfmkslt.mvml",
+  "llvm.ve.vl.vfmksltnan.mvl",
+  "llvm.ve.vl.vfmksltnan.mvml",
+  "llvm.ve.vl.vfmksnan.mvl",
+  "llvm.ve.vl.vfmksnan.mvml",
+  "llvm.ve.vl.vfmksne.mvl",
+  "llvm.ve.vl.vfmksne.mvml",
+  "llvm.ve.vl.vfmksnenan.mvl",
+  "llvm.ve.vl.vfmksnenan.mvml",
+  "llvm.ve.vl.vfmksnum.mvl",
+  "llvm.ve.vl.vfmksnum.mvml",
+  "llvm.ve.vl.vfmkweq.mvl",
+  "llvm.ve.vl.vfmkweq.mvml",
+  "llvm.ve.vl.vfmkweqnan.mvl",
+  "llvm.ve.vl.vfmkweqnan.mvml",
+  "llvm.ve.vl.vfmkwge.mvl",
+  "llvm.ve.vl.vfmkwge.mvml",
+  "llvm.ve.vl.vfmkwgenan.mvl",
+  "llvm.ve.vl.vfmkwgenan.mvml",
+  "llvm.ve.vl.vfmkwgt.mvl",
+  "llvm.ve.vl.vfmkwgt.mvml",
+  "llvm.ve.vl.vfmkwgtnan.mvl",
+  "llvm.ve.vl.vfmkwgtnan.mvml",
+  "llvm.ve.vl.vfmkwle.mvl",
+  "llvm.ve.vl.vfmkwle.mvml",
+  "llvm.ve.vl.vfmkwlenan.mvl",
+  "llvm.ve.vl.vfmkwlenan.mvml",
+  "llvm.ve.vl.vfmkwlt.mvl",
+  "llvm.ve.vl.vfmkwlt.mvml",
+  "llvm.ve.vl.vfmkwltnan.mvl",
+  "llvm.ve.vl.vfmkwltnan.mvml",
+  "llvm.ve.vl.vfmkwnan.mvl",
+  "llvm.ve.vl.vfmkwnan.mvml",
+  "llvm.ve.vl.vfmkwne.mvl",
+  "llvm.ve.vl.vfmkwne.mvml",
+  "llvm.ve.vl.vfmkwnenan.mvl",
+  "llvm.ve.vl.vfmkwnenan.mvml",
+  "llvm.ve.vl.vfmkwnum.mvl",
+  "llvm.ve.vl.vfmkwnum.mvml",
+  "llvm.ve.vl.vfmsbd.vsvvl",
+  "llvm.ve.vl.vfmsbd.vsvvmvl",
+  "llvm.ve.vl.vfmsbd.vsvvvl",
+  "llvm.ve.vl.vfmsbd.vvsvl",
+  "llvm.ve.vl.vfmsbd.vvsvmvl",
+  "llvm.ve.vl.vfmsbd.vvsvvl",
+  "llvm.ve.vl.vfmsbd.vvvvl",
+  "llvm.ve.vl.vfmsbd.vvvvmvl",
+  "llvm.ve.vl.vfmsbd.vvvvvl",
+  "llvm.ve.vl.vfmsbs.vsvvl",
+  "llvm.ve.vl.vfmsbs.vsvvmvl",
+  "llvm.ve.vl.vfmsbs.vsvvvl",
+  "llvm.ve.vl.vfmsbs.vvsvl",
+  "llvm.ve.vl.vfmsbs.vvsvmvl",
+  "llvm.ve.vl.vfmsbs.vvsvvl",
+  "llvm.ve.vl.vfmsbs.vvvvl",
+  "llvm.ve.vl.vfmsbs.vvvvmvl",
+  "llvm.ve.vl.vfmsbs.vvvvvl",
+  "llvm.ve.vl.vfmuld.vsvl",
+  "llvm.ve.vl.vfmuld.vsvmvl",
+  "llvm.ve.vl.vfmuld.vsvvl",
+  "llvm.ve.vl.vfmuld.vvvl",
+  "llvm.ve.vl.vfmuld.vvvmvl",
+  "llvm.ve.vl.vfmuld.vvvvl",
+  "llvm.ve.vl.vfmuls.vsvl",
+  "llvm.ve.vl.vfmuls.vsvmvl",
+  "llvm.ve.vl.vfmuls.vsvvl",
+  "llvm.ve.vl.vfmuls.vvvl",
+  "llvm.ve.vl.vfmuls.vvvmvl",
+  "llvm.ve.vl.vfmuls.vvvvl",
+  "llvm.ve.vl.vfnmadd.vsvvl",
+  "llvm.ve.vl.vfnmadd.vsvvmvl",
+  "llvm.ve.vl.vfnmadd.vsvvvl",
+  "llvm.ve.vl.vfnmadd.vvsvl",
+  "llvm.ve.vl.vfnmadd.vvsvmvl",
+  "llvm.ve.vl.vfnmadd.vvsvvl",
+  "llvm.ve.vl.vfnmadd.vvvvl",
+  "llvm.ve.vl.vfnmadd.vvvvmvl",
+  "llvm.ve.vl.vfnmadd.vvvvvl",
+  "llvm.ve.vl.vfnmads.vsvvl",
+  "llvm.ve.vl.vfnmads.vsvvmvl",
+  "llvm.ve.vl.vfnmads.vsvvvl",
+  "llvm.ve.vl.vfnmads.vvsvl",
+  "llvm.ve.vl.vfnmads.vvsvmvl",
+  "llvm.ve.vl.vfnmads.vvsvvl",
+  "llvm.ve.vl.vfnmads.vvvvl",
+  "llvm.ve.vl.vfnmads.vvvvmvl",
+  "llvm.ve.vl.vfnmads.vvvvvl",
+  "llvm.ve.vl.vfnmsbd.vsvvl",
+  "llvm.ve.vl.vfnmsbd.vsvvmvl",
+  "llvm.ve.vl.vfnmsbd.vsvvvl",
+  "llvm.ve.vl.vfnmsbd.vvsvl",
+  "llvm.ve.vl.vfnmsbd.vvsvmvl",
+  "llvm.ve.vl.vfnmsbd.vvsvvl",
+  "llvm.ve.vl.vfnmsbd.vvvvl",
+  "llvm.ve.vl.vfnmsbd.vvvvmvl",
+  "llvm.ve.vl.vfnmsbd.vvvvvl",
+  "llvm.ve.vl.vfnmsbs.vsvvl",
+  "llvm.ve.vl.vfnmsbs.vsvvmvl",
+  "llvm.ve.vl.vfnmsbs.vsvvvl",
+  "llvm.ve.vl.vfnmsbs.vvsvl",
+  "llvm.ve.vl.vfnmsbs.vvsvmvl",
+  "llvm.ve.vl.vfnmsbs.vvsvvl",
+  "llvm.ve.vl.vfnmsbs.vvvvl",
+  "llvm.ve.vl.vfnmsbs.vvvvmvl",
+  "llvm.ve.vl.vfnmsbs.vvvvvl",
+  "llvm.ve.vl.vfrmaxdfst.vvl",
+  "llvm.ve.vl.vfrmaxdfst.vvvl",
+  "llvm.ve.vl.vfrmaxdlst.vvl",
+  "llvm.ve.vl.vfrmaxdlst.vvvl",
+  "llvm.ve.vl.vfrmaxsfst.vvl",
+  "llvm.ve.vl.vfrmaxsfst.vvvl",
+  "llvm.ve.vl.vfrmaxslst.vvl",
+  "llvm.ve.vl.vfrmaxslst.vvvl",
+  "llvm.ve.vl.vfrmindfst.vvl",
+  "llvm.ve.vl.vfrmindfst.vvvl",
+  "llvm.ve.vl.vfrmindlst.vvl",
+  "llvm.ve.vl.vfrmindlst.vvvl",
+  "llvm.ve.vl.vfrminsfst.vvl",
+  "llvm.ve.vl.vfrminsfst.vvvl",
+  "llvm.ve.vl.vfrminslst.vvl",
+  "llvm.ve.vl.vfrminslst.vvvl",
+  "llvm.ve.vl.vfsqrtd.vvl",
+  "llvm.ve.vl.vfsqrtd.vvvl",
+  "llvm.ve.vl.vfsqrts.vvl",
+  "llvm.ve.vl.vfsqrts.vvvl",
+  "llvm.ve.vl.vfsubd.vsvl",
+  "llvm.ve.vl.vfsubd.vsvmvl",
+  "llvm.ve.vl.vfsubd.vsvvl",
+  "llvm.ve.vl.vfsubd.vvvl",
+  "llvm.ve.vl.vfsubd.vvvmvl",
+  "llvm.ve.vl.vfsubd.vvvvl",
+  "llvm.ve.vl.vfsubs.vsvl",
+  "llvm.ve.vl.vfsubs.vsvmvl",
+  "llvm.ve.vl.vfsubs.vsvvl",
+  "llvm.ve.vl.vfsubs.vvvl",
+  "llvm.ve.vl.vfsubs.vvvmvl",
+  "llvm.ve.vl.vfsubs.vvvvl",
+  "llvm.ve.vl.vfsumd.vvl",
+  "llvm.ve.vl.vfsumd.vvml",
+  "llvm.ve.vl.vfsums.vvl",
+  "llvm.ve.vl.vfsums.vvml",
+  "llvm.ve.vl.vgt.vvssl",
+  "llvm.ve.vl.vgt.vvssml",
+  "llvm.ve.vl.vgt.vvssmvl",
+  "llvm.ve.vl.vgt.vvssvl",
+  "llvm.ve.vl.vgtlsx.vvssl",
+  "llvm.ve.vl.vgtlsx.vvssml",
+  "llvm.ve.vl.vgtlsx.vvssmvl",
+  "llvm.ve.vl.vgtlsx.vvssvl",
+  "llvm.ve.vl.vgtlsxnc.vvssl",
+  "llvm.ve.vl.vgtlsxnc.vvssml",
+  "llvm.ve.vl.vgtlsxnc.vvssmvl",
+  "llvm.ve.vl.vgtlsxnc.vvssvl",
+  "llvm.ve.vl.vgtlzx.vvssl",
+  "llvm.ve.vl.vgtlzx.vvssml",
+  "llvm.ve.vl.vgtlzx.vvssmvl",
+  "llvm.ve.vl.vgtlzx.vvssvl",
+  "llvm.ve.vl.vgtlzxnc.vvssl",
+  "llvm.ve.vl.vgtlzxnc.vvssml",
+  "llvm.ve.vl.vgtlzxnc.vvssmvl",
+  "llvm.ve.vl.vgtlzxnc.vvssvl",
+  "llvm.ve.vl.vgtnc.vvssl",
+  "llvm.ve.vl.vgtnc.vvssml",
+  "llvm.ve.vl.vgtnc.vvssmvl",
+  "llvm.ve.vl.vgtnc.vvssvl",
+  "llvm.ve.vl.vgtu.vvssl",
+  "llvm.ve.vl.vgtu.vvssml",
+  "llvm.ve.vl.vgtu.vvssmvl",
+  "llvm.ve.vl.vgtu.vvssvl",
+  "llvm.ve.vl.vgtunc.vvssl",
+  "llvm.ve.vl.vgtunc.vvssml",
+  "llvm.ve.vl.vgtunc.vvssmvl",
+  "llvm.ve.vl.vgtunc.vvssvl",
+  "llvm.ve.vl.vld.vssl",
+  "llvm.ve.vl.vld.vssvl",
+  "llvm.ve.vl.vld2d.vssl",
+  "llvm.ve.vl.vld2d.vssvl",
+  "llvm.ve.vl.vld2dnc.vssl",
+  "llvm.ve.vl.vld2dnc.vssvl",
+  "llvm.ve.vl.vldl2dsx.vssl",
+  "llvm.ve.vl.vldl2dsx.vssvl",
+  "llvm.ve.vl.vldl2dsxnc.vssl",
+  "llvm.ve.vl.vldl2dsxnc.vssvl",
+  "llvm.ve.vl.vldl2dzx.vssl",
+  "llvm.ve.vl.vldl2dzx.vssvl",
+  "llvm.ve.vl.vldl2dzxnc.vssl",
+  "llvm.ve.vl.vldl2dzxnc.vssvl",
+  "llvm.ve.vl.vldlsx.vssl",
+  "llvm.ve.vl.vldlsx.vssvl",
+  "llvm.ve.vl.vldlsxnc.vssl",
+  "llvm.ve.vl.vldlsxnc.vssvl",
+  "llvm.ve.vl.vldlzx.vssl",
+  "llvm.ve.vl.vldlzx.vssvl",
+  "llvm.ve.vl.vldlzxnc.vssl",
+  "llvm.ve.vl.vldlzxnc.vssvl",
+  "llvm.ve.vl.vldnc.vssl",
+  "llvm.ve.vl.vldnc.vssvl",
+  "llvm.ve.vl.vldu.vssl",
+  "llvm.ve.vl.vldu.vssvl",
+  "llvm.ve.vl.vldu2d.vssl",
+  "llvm.ve.vl.vldu2d.vssvl",
+  "llvm.ve.vl.vldu2dnc.vssl",
+  "llvm.ve.vl.vldu2dnc.vssvl",
+  "llvm.ve.vl.vldunc.vssl",
+  "llvm.ve.vl.vldunc.vssvl",
+  "llvm.ve.vl.vmaxsl.vsvl",
+  "llvm.ve.vl.vmaxsl.vsvmvl",
+  "llvm.ve.vl.vmaxsl.vsvvl",
+  "llvm.ve.vl.vmaxsl.vvvl",
+  "llvm.ve.vl.vmaxsl.vvvmvl",
+  "llvm.ve.vl.vmaxsl.vvvvl",
+  "llvm.ve.vl.vmaxswsx.vsvl",
+  "llvm.ve.vl.vmaxswsx.vsvmvl",
+  "llvm.ve.vl.vmaxswsx.vsvvl",
+  "llvm.ve.vl.vmaxswsx.vvvl",
+  "llvm.ve.vl.vmaxswsx.vvvmvl",
+  "llvm.ve.vl.vmaxswsx.vvvvl",
+  "llvm.ve.vl.vmaxswzx.vsvl",
+  "llvm.ve.vl.vmaxswzx.vsvmvl",
+  "llvm.ve.vl.vmaxswzx.vsvvl",
+  "llvm.ve.vl.vmaxswzx.vvvl",
+  "llvm.ve.vl.vmaxswzx.vvvmvl",
+  "llvm.ve.vl.vmaxswzx.vvvvl",
+  "llvm.ve.vl.vminsl.vsvl",
+  "llvm.ve.vl.vminsl.vsvmvl",
+  "llvm.ve.vl.vminsl.vsvvl",
+  "llvm.ve.vl.vminsl.vvvl",
+  "llvm.ve.vl.vminsl.vvvmvl",
+  "llvm.ve.vl.vminsl.vvvvl",
+  "llvm.ve.vl.vminswsx.vsvl",
+  "llvm.ve.vl.vminswsx.vsvmvl",
+  "llvm.ve.vl.vminswsx.vsvvl",
+  "llvm.ve.vl.vminswsx.vvvl",
+  "llvm.ve.vl.vminswsx.vvvmvl",
+  "llvm.ve.vl.vminswsx.vvvvl",
+  "llvm.ve.vl.vminswzx.vsvl",
+  "llvm.ve.vl.vminswzx.vsvmvl",
+  "llvm.ve.vl.vminswzx.vsvvl",
+  "llvm.ve.vl.vminswzx.vvvl",
+  "llvm.ve.vl.vminswzx.vvvmvl",
+  "llvm.ve.vl.vminswzx.vvvvl",
+  "llvm.ve.vl.vmrg.vsvml",
+  "llvm.ve.vl.vmrg.vsvmvl",
+  "llvm.ve.vl.vmrg.vvvml",
+  "llvm.ve.vl.vmrg.vvvmvl",
+  "llvm.ve.vl.vmrgw.vsvMl",
+  "llvm.ve.vl.vmrgw.vsvMvl",
+  "llvm.ve.vl.vmrgw.vvvMl",
+  "llvm.ve.vl.vmrgw.vvvMvl",
+  "llvm.ve.vl.vmulsl.vsvl",
+  "llvm.ve.vl.vmulsl.vsvmvl",
+  "llvm.ve.vl.vmulsl.vsvvl",
+  "llvm.ve.vl.vmulsl.vvvl",
+  "llvm.ve.vl.vmulsl.vvvmvl",
+  "llvm.ve.vl.vmulsl.vvvvl",
+  "llvm.ve.vl.vmulslw.vsvl",
+  "llvm.ve.vl.vmulslw.vsvvl",
+  "llvm.ve.vl.vmulslw.vvvl",
+  "llvm.ve.vl.vmulslw.vvvvl",
+  "llvm.ve.vl.vmulswsx.vsvl",
+  "llvm.ve.vl.vmulswsx.vsvmvl",
+  "llvm.ve.vl.vmulswsx.vsvvl",
+  "llvm.ve.vl.vmulswsx.vvvl",
+  "llvm.ve.vl.vmulswsx.vvvmvl",
+  "llvm.ve.vl.vmulswsx.vvvvl",
+  "llvm.ve.vl.vmulswzx.vsvl",
+  "llvm.ve.vl.vmulswzx.vsvmvl",
+  "llvm.ve.vl.vmulswzx.vsvvl",
+  "llvm.ve.vl.vmulswzx.vvvl",
+  "llvm.ve.vl.vmulswzx.vvvmvl",
+  "llvm.ve.vl.vmulswzx.vvvvl",
+  "llvm.ve.vl.vmulul.vsvl",
+  "llvm.ve.vl.vmulul.vsvmvl",
+  "llvm.ve.vl.vmulul.vsvvl",
+  "llvm.ve.vl.vmulul.vvvl",
+  "llvm.ve.vl.vmulul.vvvmvl",
+  "llvm.ve.vl.vmulul.vvvvl",
+  "llvm.ve.vl.vmuluw.vsvl",
+  "llvm.ve.vl.vmuluw.vsvmvl",
+  "llvm.ve.vl.vmuluw.vsvvl",
+  "llvm.ve.vl.vmuluw.vvvl",
+  "llvm.ve.vl.vmuluw.vvvmvl",
+  "llvm.ve.vl.vmuluw.vvvvl",
+  "llvm.ve.vl.vmv.vsvl",
+  "llvm.ve.vl.vmv.vsvmvl",
+  "llvm.ve.vl.vmv.vsvvl",
+  "llvm.ve.vl.vor.vsvl",
+  "llvm.ve.vl.vor.vsvmvl",
+  "llvm.ve.vl.vor.vsvvl",
+  "llvm.ve.vl.vor.vvvl",
+  "llvm.ve.vl.vor.vvvmvl",
+  "llvm.ve.vl.vor.vvvvl",
+  "llvm.ve.vl.vrand.vvl",
+  "llvm.ve.vl.vrand.vvml",
+  "llvm.ve.vl.vrcpd.vvl",
+  "llvm.ve.vl.vrcpd.vvvl",
+  "llvm.ve.vl.vrcps.vvl",
+  "llvm.ve.vl.vrcps.vvvl",
+  "llvm.ve.vl.vrmaxslfst.vvl",
+  "llvm.ve.vl.vrmaxslfst.vvvl",
+  "llvm.ve.vl.vrmaxsllst.vvl",
+  "llvm.ve.vl.vrmaxsllst.vvvl",
+  "llvm.ve.vl.vrmaxswfstsx.vvl",
+  "llvm.ve.vl.vrmaxswfstsx.vvvl",
+  "llvm.ve.vl.vrmaxswfstzx.vvl",
+  "llvm.ve.vl.vrmaxswfstzx.vvvl",
+  "llvm.ve.vl.vrmaxswlstsx.vvl",
+  "llvm.ve.vl.vrmaxswlstsx.vvvl",
+  "llvm.ve.vl.vrmaxswlstzx.vvl",
+  "llvm.ve.vl.vrmaxswlstzx.vvvl",
+  "llvm.ve.vl.vrminslfst.vvl",
+  "llvm.ve.vl.vrminslfst.vvvl",
+  "llvm.ve.vl.vrminsllst.vvl",
+  "llvm.ve.vl.vrminsllst.vvvl",
+  "llvm.ve.vl.vrminswfstsx.vvl",
+  "llvm.ve.vl.vrminswfstsx.vvvl",
+  "llvm.ve.vl.vrminswfstzx.vvl",
+  "llvm.ve.vl.vrminswfstzx.vvvl",
+  "llvm.ve.vl.vrminswlstsx.vvl",
+  "llvm.ve.vl.vrminswlstsx.vvvl",
+  "llvm.ve.vl.vrminswlstzx.vvl",
+  "llvm.ve.vl.vrminswlstzx.vvvl",
+  "llvm.ve.vl.vror.vvl",
+  "llvm.ve.vl.vror.vvml",
+  "llvm.ve.vl.vrsqrtd.vvl",
+  "llvm.ve.vl.vrsqrtd.vvvl",
+  "llvm.ve.vl.vrsqrtdnex.vvl",
+  "llvm.ve.vl.vrsqrtdnex.vvvl",
+  "llvm.ve.vl.vrsqrts.vvl",
+  "llvm.ve.vl.vrsqrts.vvvl",
+  "llvm.ve.vl.vrsqrtsnex.vvl",
+  "llvm.ve.vl.vrsqrtsnex.vvvl",
+  "llvm.ve.vl.vrxor.vvl",
+  "llvm.ve.vl.vrxor.vvml",
+  "llvm.ve.vl.vsc.vvssl",
+  "llvm.ve.vl.vsc.vvssml",
+  "llvm.ve.vl.vscl.vvssl",
+  "llvm.ve.vl.vscl.vvssml",
+  "llvm.ve.vl.vsclnc.vvssl",
+  "llvm.ve.vl.vsclnc.vvssml",
+  "llvm.ve.vl.vsclncot.vvssl",
+  "llvm.ve.vl.vsclncot.vvssml",
+  "llvm.ve.vl.vsclot.vvssl",
+  "llvm.ve.vl.vsclot.vvssml",
+  "llvm.ve.vl.vscnc.vvssl",
+  "llvm.ve.vl.vscnc.vvssml",
+  "llvm.ve.vl.vscncot.vvssl",
+  "llvm.ve.vl.vscncot.vvssml",
+  "llvm.ve.vl.vscot.vvssl",
+  "llvm.ve.vl.vscot.vvssml",
+  "llvm.ve.vl.vscu.vvssl",
+  "llvm.ve.vl.vscu.vvssml",
+  "llvm.ve.vl.vscunc.vvssl",
+  "llvm.ve.vl.vscunc.vvssml",
+  "llvm.ve.vl.vscuncot.vvssl",
+  "llvm.ve.vl.vscuncot.vvssml",
+  "llvm.ve.vl.vscuot.vvssl",
+  "llvm.ve.vl.vscuot.vvssml",
+  "llvm.ve.vl.vseq.vl",
+  "llvm.ve.vl.vseq.vvl",
+  "llvm.ve.vl.vsfa.vvssl",
+  "llvm.ve.vl.vsfa.vvssmvl",
+  "llvm.ve.vl.vsfa.vvssvl",
+  "llvm.ve.vl.vshf.vvvsl",
+  "llvm.ve.vl.vshf.vvvsvl",
+  "llvm.ve.vl.vslal.vvsl",
+  "llvm.ve.vl.vslal.vvsmvl",
+  "llvm.ve.vl.vslal.vvsvl",
+  "llvm.ve.vl.vslal.vvvl",
+  "llvm.ve.vl.vslal.vvvmvl",
+  "llvm.ve.vl.vslal.vvvvl",
+  "llvm.ve.vl.vslawsx.vvsl",
+  "llvm.ve.vl.vslawsx.vvsmvl",
+  "llvm.ve.vl.vslawsx.vvsvl",
+  "llvm.ve.vl.vslawsx.vvvl",
+  "llvm.ve.vl.vslawsx.vvvmvl",
+  "llvm.ve.vl.vslawsx.vvvvl",
+  "llvm.ve.vl.vslawzx.vvsl",
+  "llvm.ve.vl.vslawzx.vvsmvl",
+  "llvm.ve.vl.vslawzx.vvsvl",
+  "llvm.ve.vl.vslawzx.vvvl",
+  "llvm.ve.vl.vslawzx.vvvmvl",
+  "llvm.ve.vl.vslawzx.vvvvl",
+  "llvm.ve.vl.vsll.vvsl",
+  "llvm.ve.vl.vsll.vvsmvl",
+  "llvm.ve.vl.vsll.vvsvl",
+  "llvm.ve.vl.vsll.vvvl",
+  "llvm.ve.vl.vsll.vvvmvl",
+  "llvm.ve.vl.vsll.vvvvl",
+  "llvm.ve.vl.vsral.vvsl",
+  "llvm.ve.vl.vsral.vvsmvl",
+  "llvm.ve.vl.vsral.vvsvl",
+  "llvm.ve.vl.vsral.vvvl",
+  "llvm.ve.vl.vsral.vvvmvl",
+  "llvm.ve.vl.vsral.vvvvl",
+  "llvm.ve.vl.vsrawsx.vvsl",
+  "llvm.ve.vl.vsrawsx.vvsmvl",
+  "llvm.ve.vl.vsrawsx.vvsvl",
+  "llvm.ve.vl.vsrawsx.vvvl",
+  "llvm.ve.vl.vsrawsx.vvvmvl",
+  "llvm.ve.vl.vsrawsx.vvvvl",
+  "llvm.ve.vl.vsrawzx.vvsl",
+  "llvm.ve.vl.vsrawzx.vvsmvl",
+  "llvm.ve.vl.vsrawzx.vvsvl",
+  "llvm.ve.vl.vsrawzx.vvvl",
+  "llvm.ve.vl.vsrawzx.vvvmvl",
+  "llvm.ve.vl.vsrawzx.vvvvl",
+  "llvm.ve.vl.vsrl.vvsl",
+  "llvm.ve.vl.vsrl.vvsmvl",
+  "llvm.ve.vl.vsrl.vvsvl",
+  "llvm.ve.vl.vsrl.vvvl",
+  "llvm.ve.vl.vsrl.vvvmvl",
+  "llvm.ve.vl.vsrl.vvvvl",
+  "llvm.ve.vl.vst.vssl",
+  "llvm.ve.vl.vst.vssml",
+  "llvm.ve.vl.vst2d.vssl",
+  "llvm.ve.vl.vst2d.vssml",
+  "llvm.ve.vl.vst2dnc.vssl",
+  "llvm.ve.vl.vst2dnc.vssml",
+  "llvm.ve.vl.vst2dncot.vssl",
+  "llvm.ve.vl.vst2dncot.vssml",
+  "llvm.ve.vl.vst2dot.vssl",
+  "llvm.ve.vl.vst2dot.vssml",
+  "llvm.ve.vl.vstl.vssl",
+  "llvm.ve.vl.vstl.vssml",
+  "llvm.ve.vl.vstl2d.vssl",
+  "llvm.ve.vl.vstl2d.vssml",
+  "llvm.ve.vl.vstl2dnc.vssl",
+  "llvm.ve.vl.vstl2dnc.vssml",
+  "llvm.ve.vl.vstl2dncot.vssl",
+  "llvm.ve.vl.vstl2dncot.vssml",
+  "llvm.ve.vl.vstl2dot.vssl",
+  "llvm.ve.vl.vstl2dot.vssml",
+  "llvm.ve.vl.vstlnc.vssl",
+  "llvm.ve.vl.vstlnc.vssml",
+  "llvm.ve.vl.vstlncot.vssl",
+  "llvm.ve.vl.vstlncot.vssml",
+  "llvm.ve.vl.vstlot.vssl",
+  "llvm.ve.vl.vstlot.vssml",
+  "llvm.ve.vl.vstnc.vssl",
+  "llvm.ve.vl.vstnc.vssml",
+  "llvm.ve.vl.vstncot.vssl",
+  "llvm.ve.vl.vstncot.vssml",
+  "llvm.ve.vl.vstot.vssl",
+  "llvm.ve.vl.vstot.vssml",
+  "llvm.ve.vl.vstu.vssl",
+  "llvm.ve.vl.vstu.vssml",
+  "llvm.ve.vl.vstu2d.vssl",
+  "llvm.ve.vl.vstu2d.vssml",
+  "llvm.ve.vl.vstu2dnc.vssl",
+  "llvm.ve.vl.vstu2dnc.vssml",
+  "llvm.ve.vl.vstu2dncot.vssl",
+  "llvm.ve.vl.vstu2dncot.vssml",
+  "llvm.ve.vl.vstu2dot.vssl",
+  "llvm.ve.vl.vstu2dot.vssml",
+  "llvm.ve.vl.vstunc.vssl",
+  "llvm.ve.vl.vstunc.vssml",
+  "llvm.ve.vl.vstuncot.vssl",
+  "llvm.ve.vl.vstuncot.vssml",
+  "llvm.ve.vl.vstuot.vssl",
+  "llvm.ve.vl.vstuot.vssml",
+  "llvm.ve.vl.vsubsl.vsvl",
+  "llvm.ve.vl.vsubsl.vsvmvl",
+  "llvm.ve.vl.vsubsl.vsvvl",
+  "llvm.ve.vl.vsubsl.vvvl",
+  "llvm.ve.vl.vsubsl.vvvmvl",
+  "llvm.ve.vl.vsubsl.vvvvl",
+  "llvm.ve.vl.vsubswsx.vsvl",
+  "llvm.ve.vl.vsubswsx.vsvmvl",
+  "llvm.ve.vl.vsubswsx.vsvvl",
+  "llvm.ve.vl.vsubswsx.vvvl",
+  "llvm.ve.vl.vsubswsx.vvvmvl",
+  "llvm.ve.vl.vsubswsx.vvvvl",
+  "llvm.ve.vl.vsubswzx.vsvl",
+  "llvm.ve.vl.vsubswzx.vsvmvl",
+  "llvm.ve.vl.vsubswzx.vsvvl",
+  "llvm.ve.vl.vsubswzx.vvvl",
+  "llvm.ve.vl.vsubswzx.vvvmvl",
+  "llvm.ve.vl.vsubswzx.vvvvl",
+  "llvm.ve.vl.vsubul.vsvl",
+  "llvm.ve.vl.vsubul.vsvmvl",
+  "llvm.ve.vl.vsubul.vsvvl",
+  "llvm.ve.vl.vsubul.vvvl",
+  "llvm.ve.vl.vsubul.vvvmvl",
+  "llvm.ve.vl.vsubul.vvvvl",
+  "llvm.ve.vl.vsubuw.vsvl",
+  "llvm.ve.vl.vsubuw.vsvmvl",
+  "llvm.ve.vl.vsubuw.vsvvl",
+  "llvm.ve.vl.vsubuw.vvvl",
+  "llvm.ve.vl.vsubuw.vvvmvl",
+  "llvm.ve.vl.vsubuw.vvvvl",
+  "llvm.ve.vl.vsuml.vvl",
+  "llvm.ve.vl.vsuml.vvml",
+  "llvm.ve.vl.vsumwsx.vvl",
+  "llvm.ve.vl.vsumwsx.vvml",
+  "llvm.ve.vl.vsumwzx.vvl",
+  "llvm.ve.vl.vsumwzx.vvml",
+  "llvm.ve.vl.vxor.vsvl",
+  "llvm.ve.vl.vxor.vsvmvl",
+  "llvm.ve.vl.vxor.vsvvl",
+  "llvm.ve.vl.vxor.vvvl",
+  "llvm.ve.vl.vxor.vvvmvl",
+  "llvm.ve.vl.vxor.vvvvl",
+  "llvm.ve.vl.xorm.MMM",
+  "llvm.ve.vl.xorm.mmm",
   "llvm.wasm.alltrue",
   "llvm.wasm.anytrue",
-  "llvm.wasm.atomic.notify",
-  "llvm.wasm.atomic.wait.i32",
-  "llvm.wasm.atomic.wait.i64",
+  "llvm.wasm.avgr.unsigned",
+  "llvm.wasm.bitmask",
   "llvm.wasm.bitselect",
-  "llvm.wasm.data.drop",
-  "llvm.wasm.extract.exception",
+  "llvm.wasm.catch",
+  "llvm.wasm.ceil",
+  "llvm.wasm.dot",
+  "llvm.wasm.eq",
+  "llvm.wasm.extadd.pairwise.signed",
+  "llvm.wasm.extadd.pairwise.unsigned",
+  "llvm.wasm.extmul.high.signed",
+  "llvm.wasm.extmul.high.unsigned",
+  "llvm.wasm.extmul.low.signed",
+  "llvm.wasm.extmul.low.unsigned",
+  "llvm.wasm.floor",
   "llvm.wasm.get.ehselector",
   "llvm.wasm.get.exception",
   "llvm.wasm.landingpad.index",
+  "llvm.wasm.load16.lane",
+  "llvm.wasm.load32.lane",
+  "llvm.wasm.load32.zero",
+  "llvm.wasm.load64.lane",
+  "llvm.wasm.load64.zero",
+  "llvm.wasm.load8.lane",
   "llvm.wasm.lsda",
+  "llvm.wasm.memory.atomic.notify",
+  "llvm.wasm.memory.atomic.wait32",
+  "llvm.wasm.memory.atomic.wait64",
   "llvm.wasm.memory.grow",
-  "llvm.wasm.memory.init",
   "llvm.wasm.memory.size",
-  "llvm.wasm.rethrow.in.catch",
+  "llvm.wasm.narrow.signed",
+  "llvm.wasm.narrow.unsigned",
+  "llvm.wasm.nearest",
+  "llvm.wasm.pmax",
+  "llvm.wasm.pmin",
+  "llvm.wasm.popcnt",
+  "llvm.wasm.prefetch.nt",
+  "llvm.wasm.prefetch.t",
+  "llvm.wasm.q15mulr.saturate.signed",
+  "llvm.wasm.qfma",
+  "llvm.wasm.qfms",
+  "llvm.wasm.rethrow",
+  "llvm.wasm.shuffle",
+  "llvm.wasm.signselect",
+  "llvm.wasm.store16.lane",
+  "llvm.wasm.store32.lane",
+  "llvm.wasm.store64.lane",
+  "llvm.wasm.store8.lane",
   "llvm.wasm.sub.saturate.signed",
   "llvm.wasm.sub.saturate.unsigned",
+  "llvm.wasm.swizzle",
   "llvm.wasm.throw",
+  "llvm.wasm.tls.align",
+  "llvm.wasm.tls.base",
+  "llvm.wasm.tls.size",
+  "llvm.wasm.trunc",
   "llvm.wasm.trunc.saturate.signed",
   "llvm.wasm.trunc.saturate.unsigned",
+  "llvm.wasm.trunc.signed",
+  "llvm.wasm.trunc.unsigned",
+  "llvm.wasm.widen.high.signed",
+  "llvm.wasm.widen.high.unsigned",
+  "llvm.wasm.widen.low.signed",
+  "llvm.wasm.widen.low.unsigned",
   "llvm.x86.3dnow.pavgusb",
   "llvm.x86.3dnow.pf2id",
   "llvm.x86.3dnow.pfacc",
@@ -5845,6 +8561,14 @@
   "llvm.x86.3dnowa.pswapd",
   "llvm.x86.addcarry.32",
   "llvm.x86.addcarry.64",
+  "llvm.x86.aesdec128kl",
+  "llvm.x86.aesdec256kl",
+  "llvm.x86.aesdecwide128kl",
+  "llvm.x86.aesdecwide256kl",
+  "llvm.x86.aesenc128kl",
+  "llvm.x86.aesenc256kl",
+  "llvm.x86.aesencwide128kl",
+  "llvm.x86.aesencwide256kl",
   "llvm.x86.aesni.aesdec",
   "llvm.x86.aesni.aesdec.256",
   "llvm.x86.aesni.aesdec.512",
@@ -6000,12 +8724,6 @@
   "llvm.x86.avx512.broadcastmw.128",
   "llvm.x86.avx512.broadcastmw.256",
   "llvm.x86.avx512.broadcastmw.512",
-  "llvm.x86.avx512.cmp.pd.128",
-  "llvm.x86.avx512.cmp.pd.256",
-  "llvm.x86.avx512.cmp.pd.512",
-  "llvm.x86.avx512.cmp.ps.128",
-  "llvm.x86.avx512.cmp.ps.256",
-  "llvm.x86.avx512.cmp.ps.512",
   "llvm.x86.avx512.conflict.d.128",
   "llvm.x86.avx512.conflict.d.256",
   "llvm.x86.avx512.conflict.d.512",
@@ -6081,6 +8799,12 @@
   "llvm.x86.avx512.ktestz.w",
   "llvm.x86.avx512.mask.add.sd.round",
   "llvm.x86.avx512.mask.add.ss.round",
+  "llvm.x86.avx512.mask.cmp.pd.128",
+  "llvm.x86.avx512.mask.cmp.pd.256",
+  "llvm.x86.avx512.mask.cmp.pd.512",
+  "llvm.x86.avx512.mask.cmp.ps.128",
+  "llvm.x86.avx512.mask.cmp.ps.256",
+  "llvm.x86.avx512.mask.cmp.ps.512",
   "llvm.x86.avx512.mask.cmp.sd",
   "llvm.x86.avx512.mask.cmp.ss",
   "llvm.x86.avx512.mask.compress",
@@ -6358,8 +9082,6 @@
   "llvm.x86.avx512.mask.sqrt.ss",
   "llvm.x86.avx512.mask.sub.sd.round",
   "llvm.x86.avx512.mask.sub.ss.round",
-  "llvm.x86.avx512.mask.vcvtph2ps.128",
-  "llvm.x86.avx512.mask.vcvtph2ps.256",
   "llvm.x86.avx512.mask.vcvtph2ps.512",
   "llvm.x86.avx512.mask.vcvtps2ph.128",
   "llvm.x86.avx512.mask.vcvtps2ph.256",
@@ -6592,16 +9314,23 @@
   "llvm.x86.cldemote",
   "llvm.x86.clflushopt",
   "llvm.x86.clrssbsy",
+  "llvm.x86.clui",
   "llvm.x86.clwb",
   "llvm.x86.clzero",
   "llvm.x86.directstore32",
   "llvm.x86.directstore64",
+  "llvm.x86.encodekey128",
+  "llvm.x86.encodekey256",
   "llvm.x86.enqcmd",
   "llvm.x86.enqcmds",
   "llvm.x86.flags.read.u32",
   "llvm.x86.flags.read.u64",
   "llvm.x86.flags.write.u32",
   "llvm.x86.flags.write.u64",
+  "llvm.x86.fma.vfmaddsub.pd",
+  "llvm.x86.fma.vfmaddsub.pd.256",
+  "llvm.x86.fma.vfmaddsub.ps",
+  "llvm.x86.fma.vfmaddsub.ps.256",
   "llvm.x86.fxrstor",
   "llvm.x86.fxrstor64",
   "llvm.x86.fxsave",
@@ -6610,7 +9339,9 @@
   "llvm.x86.incsspq",
   "llvm.x86.int",
   "llvm.x86.invpcid",
+  "llvm.x86.ldtilecfg",
   "llvm.x86.llwpcb",
+  "llvm.x86.loadiwkey",
   "llvm.x86.lwpins32",
   "llvm.x86.lwpins64",
   "llvm.x86.lwpval32",
@@ -6716,6 +9447,8 @@
   "llvm.x86.seh.ehguard",
   "llvm.x86.seh.ehregnode",
   "llvm.x86.seh.lsda",
+  "llvm.x86.senduipi",
+  "llvm.x86.serialize",
   "llvm.x86.setssbsy",
   "llvm.x86.sha1msg1",
   "llvm.x86.sha1msg2",
@@ -6896,15 +9629,30 @@
   "llvm.x86.ssse3.psign.d.128",
   "llvm.x86.ssse3.psign.w",
   "llvm.x86.ssse3.psign.w.128",
+  "llvm.x86.sttilecfg",
+  "llvm.x86.stui",
   "llvm.x86.subborrow.32",
   "llvm.x86.subborrow.64",
   "llvm.x86.tbm.bextri.u32",
   "llvm.x86.tbm.bextri.u64",
+  "llvm.x86.tdpbf16ps",
+  "llvm.x86.tdpbssd",
+  "llvm.x86.tdpbssd.internal",
+  "llvm.x86.tdpbsud",
+  "llvm.x86.tdpbusd",
+  "llvm.x86.tdpbuud",
+  "llvm.x86.testui",
+  "llvm.x86.tileloadd64",
+  "llvm.x86.tileloadd64.internal",
+  "llvm.x86.tileloaddt164",
+  "llvm.x86.tilerelease",
+  "llvm.x86.tilestored64",
+  "llvm.x86.tilestored64.internal",
+  "llvm.x86.tilezero",
+  "llvm.x86.tilezero.internal",
   "llvm.x86.tpause",
   "llvm.x86.umonitor",
   "llvm.x86.umwait",
-  "llvm.x86.vcvtph2ps.128",
-  "llvm.x86.vcvtph2ps.256",
   "llvm.x86.vcvtps2ph.128",
   "llvm.x86.vcvtps2ph.256",
   "llvm.x86.vgf2p8affineinvqb.128",
@@ -6977,6 +9725,7 @@
   "llvm.x86.xop.vpshld",
   "llvm.x86.xop.vpshlq",
   "llvm.x86.xop.vpshlw",
+  "llvm.x86.xresldtrk",
   "llvm.x86.xrstor",
   "llvm.x86.xrstor64",
   "llvm.x86.xrstors",
@@ -6990,6 +9739,7 @@
   "llvm.x86.xsaves",
   "llvm.x86.xsaves64",
   "llvm.x86.xsetbv",
+  "llvm.x86.xsusldtrk",
   "llvm.x86.xtest",
   "llvm.xcore.bitrev",
   "llvm.xcore.checkevent",
@@ -7049,882 +9799,1226 @@
 // Intrinsic ID to overload bitset
 #ifdef GET_INTRINSIC_OVERLOAD_TABLE
 static const uint8_t OTable[] = {
-  0 | (1<<3) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<3) | (1<<4) | (1<<5),
-  0,
-  0 | (1<<3) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1),
-  0 | (1<<2),
-  0 | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6),
-  0 | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<1) | (1<<2) | (1<<4) | (1<<5) | (1<<7),
-  0 | (1<<0) | (1<<4),
-  0 | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<1) | (1<<2) | (1<<4) | (1<<6) | (1<<7),
+  0 | (1<<3) | (1<<4) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<3),
   0,
   0,
-  0,
-  0 | (1<<6),
-  0 | (1<<0) | (1<<1) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6),
-  0 | (1<<3) | (1<<4) | (1<<5) | (1<<6),
+  0 | (1<<3) | (1<<7),
   0 | (1<<0) | (1<<1) | (1<<2) | (1<<3),
-  0 | (1<<0) | (1<<1) | (1<<4) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4),
-  0 | (1<<1),
+  0 | (1<<4),
   0,
-  0,
-  0,
-  0 | (1<<4) | (1<<7),
   0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
   0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
   0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
   0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
   0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
   0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<4) | (1<<5) | (1<<7),
   0 | (1<<0) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6),
-  0 | (1<<0) | (1<<1) | (1<<3) | (1<<4) | (1<<5) | (1<<6),
-  0 | (1<<3) | (1<<5) | (1<<7),
-  0 | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<6) | (1<<7),
-  0,
-  0 | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<1),
-  0 | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<6) | (1<<7),
-  0 | (1<<1) | (1<<2) | (1<<3) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1),
-  0 | (1<<5) | (1<<7),
-  0 | (1<<0),
-  0,
-  0 | (1<<7),
-  0 | (1<<0),
-  0 | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<6) | (1<<7),
-  0 | (1<<2),
-  0,
-  0 | (1<<5),
-  0 | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<5),
-  0 | (1<<6),
-  0 | (1<<1),
-  0,
-  0 | (1<<6),
-  0 | (1<<4),
-  0,
-  0 | (1<<2),
+  0 | (1<<0) | (1<<4) | (1<<5),
   0 | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<2) | (1<<3) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3),
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0 | (1<<1) | (1<<3),
-  0,
-  0,
-  0,
-  0 | (1<<0) | (1<<1),
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0 | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4),
-  0,
-  0 | (1<<6) | (1<<7),
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0 | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4),
-  0,
-  0,
-  0 | (1<<5),
-  0,
-  0,
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5),
   0 | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1),
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0 | (1<<1),
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0 | (1<<7),
-  0 | (1<<0),
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0 | (1<<4) | (1<<5) | (1<<6) | (1<<7),
   0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
   0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5),
   0,
   0,
   0,
-  0,
-  0,
-  0,
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<4) | (1<<6) | (1<<7),
   0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
   0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4),
-  0 | (1<<1) | (1<<2) | (1<<3) | (1<<4),
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0 | (1<<4),
-  0,
-  0,
-  0 | (1<<1),
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0 | (1<<2) | (1<<3),
-  0 | (1<<6) | (1<<7),
+  0 | (1<<4) | (1<<5) | (1<<6),
+  0 | (1<<1) | (1<<4) | (1<<5) | (1<<7),
   0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
-  0,
-  0 | (1<<2),
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0 | (1<<4) | (1<<5),
-  0 | (1<<1),
-  0 | (1<<0) | (1<<2) | (1<<4) | (1<<5) | (1<<7),
-  0 | (1<<0),
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0 | (1<<1),
-  0,
-  0,
-  0,
-  0,
-  0,
-  0 | (1<<7),
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0 | (1<<5),
-  0 | (1<<2),
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0 | (1<<7),
-  0 | (1<<1) | (1<<5) | (1<<6) | (1<<7),
   0 | (1<<0) | (1<<5) | (1<<6) | (1<<7),
   0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
   0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0),
+  0,
+  0,
+  0,
+  0,
+  0 | (1<<0) | (1<<3) | (1<<4) | (1<<5) | (1<<6),
+  0 | (1<<2) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
   0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<5) | (1<<6) | (1<<7),
-  0 | (1<<1) | (1<<2) | (1<<5) | (1<<6) | (1<<7),
-  0
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<1) | (1<<2) | (1<<4) | (1<<5) | (1<<6),
+  0 | (1<<1),
+  0 | (1<<2) | (1<<4) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5),
+  0 | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6),
+  0 | (1<<2) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1),
+  0,
+  0 | (1<<0) | (1<<5),
+  0 | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<3) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5),
+  0 | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<3) | (1<<6),
+  0 | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6),
+  0 | (1<<1) | (1<<4) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<5),
+  0 | (1<<0) | (1<<3) | (1<<4) | (1<<5) | (1<<6),
+  0 | (1<<3) | (1<<6),
+  0 | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<7),
+  0 | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5),
+  0 | (1<<1) | (1<<2),
+  0 | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0,
+  0 | (1<<2) | (1<<3) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<3) | (1<<4) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1),
+  0 | (1<<7),
+  0 | (1<<1) | (1<<2),
+  0,
+  0,
+  0 | (1<<1) | (1<<2),
+  0 | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<6) | (1<<7),
+  0 | (1<<2),
+  0,
+  0 | (1<<6),
+  0 | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6),
+  0 | (1<<3),
+  0 | (1<<4) | (1<<7),
+  0,
+  0 | (1<<4) | (1<<5) | (1<<7),
+  0 | (1<<1) | (1<<2) | (1<<3) | (1<<5) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<3) | (1<<5),
+  0,
+  0,
+  0 | (1<<4),
+  0 | (1<<2),
+  0 | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2),
+  0 | (1<<1),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5),
+  0 | (1<<2) | (1<<3) | (1<<4),
+  0 | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4),
+  0 | (1<<1) | (1<<5),
+  0,
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<1) | (1<<2) | (1<<3) | (1<<5) | (1<<6),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2),
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0 | (1<<0) | (1<<2),
+  0,
+  0,
+  0 | (1<<7),
+  0 | (1<<0) | (1<<5) | (1<<7),
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0 | (1<<1) | (1<<2),
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0 | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2),
+  0,
+  0 | (1<<4) | (1<<5),
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0 | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2),
+  0,
+  0,
+  0,
+  0 | (1<<7),
+  0,
+  0,
+  0 | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3),
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0 | (1<<3),
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0 | (1<<1) | (1<<2),
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0 | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1),
+  0,
+  0,
+  0,
+  0,
+  0,
+  0 | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1),
+  0,
+  0,
+  0,
+  0,
+  0,
+  0 | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1),
+  0,
+  0,
+  0,
+  0,
+  0,
+  0 | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6),
+  0 | (1<<3) | (1<<4) | (1<<5) | (1<<6),
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0 | (1<<1),
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0 | (1<<1) | (1<<2),
+  0 | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2),
+  0 | (1<<5),
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0 | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<1) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2),
+  0,
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6),
+  0 | (1<<3) | (1<<4) | (1<<7),
+  0 | (1<<4) | (1<<5),
+  0 | (1<<0) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0 | (1<<4),
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0 | (1<<2),
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0 | (1<<6),
+  0 | (1<<3),
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0 | (1<<4) | (1<<6),
+  0 | (1<<2) | (1<<3) | (1<<4) | (1<<5),
+  0 | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7),
+  0 | (1<<0) | (1<<2) | (1<<3) | (1<<4) | (1<<6) | (1<<7),
+  0 | (1<<2) | (1<<3) | (1<<4)
 };
 
 return (OTable[id/8] & (1 << (id%8))) != 0;
@@ -7933,243 +11027,365 @@
 // Global intrinsic function declaration type table.
 #ifdef GET_INTRINSIC_GENERATOR_GLOBAL
 static const unsigned IIT_Table[] = {
-  0x2e, 0x2e2e, (1U<<31) | 1578, 0x10, 0x7f1f, 0x7f1f, 0x7f2f, 
-  0x7f2f, 0x2e2e0, (1U<<31) | 6512, 0x32f, 0x2f3, 0x7f7f2f, (1U<<31) | 6501, (1U<<31) | 759, 
-  0x2e0, 0x2e1, 0x12e1, 0x2e, (1U<<31) | 759, (1U<<31) | 670, 0x2e, 0x2e2e1, 
-  0x142e2e, 0x2e0, (1U<<31) | 761, 0x1f, 0x22e2e, (1U<<31) | 193, 0x7f2f, 0x17f1f, 
-  0x7f1f, 0x17f1f, (1U<<31) | 6581, (1U<<31) | 6581, (1U<<31) | 6512, (1U<<31) | 6581, 0x0, 0x0, 
-  0x42e, (1U<<31) | 6509, (1U<<31) | 6508, 0x2e2e2e, 0x2e40, 0x2e50, 0x40, 0x2e0, 
-  0x2e0, 0x2e, 0x2e4, 0x0, 0x2e4, 0x0, 0x7f2f, 0x7f2f, 
-  0x7f7f1f, (1U<<31) | 6547, (1U<<31) | 6547, (1U<<31) | 6547, (1U<<31) | 6547, (1U<<31) | 6554, (1U<<31) | 6554, (1U<<31) | 6547, 
-  (1U<<31) | 6563, (1U<<31) | 6554, (1U<<31) | 6533, (1U<<31) | 6574, (1U<<31) | 6554, (1U<<31) | 6554, (1U<<31) | 6547, (1U<<31) | 6547, 
-  (1U<<31) | 6547, (1U<<31) | 6554, (1U<<31) | 6554, (1U<<31) | 6547, (1U<<31) | 6554, (1U<<31) | 6539, (1U<<31) | 6547, (1U<<31) | 6547, 
-  (1U<<31) | 6547, (1U<<31) | 6547, (1U<<31) | 6547, (1U<<31) | 6586, (1U<<31) | 4236, (1U<<31) | 6497, (1U<<31) | 6610, (1U<<31) | 6590, 
-  (1U<<31) | 6602, (1U<<31) | 6594, (1U<<31) | 6619, (1U<<31) | 842, (1U<<31) | 842, (1U<<31) | 842, (1U<<31) | 842, (1U<<31) | 842, 
-  (1U<<31) | 842, (1U<<31) | 842, (1U<<31) | 842, (1U<<31) | 842, (1U<<31) | 842, 0xbf7f2f, 0xbf7f2f, (1U<<31) | 842, 
-  0x1, 0x7f2f, 0x7f2f, 0x4, 0x7f7f7f2f, 0x7f7f7f2f, 0x42e, 0x7f7f7f1f, 
-  0x7f7f7f1f, 0x2ee2e2e, 0x2e2ee0, 0x2ee2e2e0, 0x1f, 0x42e2e0, (1U<<31) | 6587, 0x2e2e2e0, 
-  0x4452e0, 0x54452e0, 0x44552e0, (1U<<31) | 5091, (1U<<31) | 5092, 0xf1, 0x7f4f, 0x4f50, 
-  0x4f50, 0xaf1f, 0xaf1f, 0x1f2e2e, 0x2e, (1U<<31) | 6587, 0x42e2e2e, 0x7f2f, 
-  0x7f2f, 0x7f2f, 0x42e0, 0x1f1, (1U<<31) | 6481, 0xaf1f, 0xaf1f, (1U<<31) | 97, 
-  (1U<<31) | 6093, (1U<<31) | 6070, (1U<<31) | 6082, (1U<<31) | 66, (1U<<31) | 77, 0x7f7f2f, 0x7f7f2f, (1U<<31) | 184, 
-  (1U<<31) | 5205, (1U<<31) | 184, (1U<<31) | 5205, 0x19f24f0, 0x49f24f0, 0x7f7f2f, 0x7f7f2f, 0x7f2f, 
-  0x2ee2ee0, 0x2ee2ee0, 0x2ee2ee0, 0x2ee2ee0, 0x2e2e, 0x2e0, 0x2e, 0x2e2e, 
-  (1U<<31) | 6587, 0x2ee2ee0, 0x2ee0, 0x2e2ee2e, 0x2ee2e, 0x2ee2e, 0x2ee2ee0, 0x2e0, 
-  0x2e2e, 0x2e2e, 0x2e2e, 0x2e2e, 0x2e2e, 0x2e2e, 0x2e2e, 0x2e2ee0, 
-  0x2e2ee2e, 0x2e4, 0x2e4, 0x2e2e, 0x2e2e, 0x2e2e, 0x111cf1f, 0x40, 
-  0x7f7f2f, 0x47f2f, 0x4442e0, 0x44cf4f, 0x44cf4f, 0x4cf4f, (1U<<31) | 1588, (1U<<31) | 6515, 
-  0x5, 0x42e, 0x7f2f, 0x7f2f, 0x7f7f1f, (1U<<31) | 6166, 0x1f0, 0x2e4, 
-  0x0, 0x42e0, 0x42e4, 0x7f2f, 0x47f7f1f, 0x47f7f1f, (1U<<31) | 6166, 0x2e, 
-  0x7f2f, 0x7f0f, 0x7f7f1f, (1U<<31) | 6166, 0x2e, 0x2ee2e0, 0x2e0, 0x2e, 
-  0x7f4f, 0x1f1, 0x2e, 0x0, 0x7f2f, (1U<<31) | 6524, (1U<<31) | 6519, 0x7f7f1f, 
-  (1U<<31) | 6166, 0x47f7f1f, (1U<<31) | 6166, 0x7f7f1f, (1U<<31) | 6166, 0x2e2e0, 0x2e0, 0x2e0, 
-  0x42e2e2e0, (1U<<31) | 166, 0x42e0, 0x42e30, 0x52e2e, 0x0, 0x444, 0x444, 
-  0x444, 0x444, 0x544, 0x444, 0x444, 0x544, 0x2c2c2c, 0x2c2c2c, 
-  0x2c2c, 0x2c2c, 0x4a44a4a, 0x44, 0x4a44a4a, 0x4a44a4a, 0x4a4a4a4a, 0x4a4a4a, 
-  0x4a4a4a4a, 0x4a4a4a4a, 0x4a4a4a, 0x4a4a4a4a, 0x40, 0x40, 0x5, 0x52e5, 
-  0x40, 0x52e2e, 0x40, (1U<<31) | 747, 0x4f5, 0x2e2e2e, (1U<<31) | 747, 0x4f5, 
-  0x7f0f, (1U<<31) | 6187, 0x7f7f3f, 0x7f3f, 0x7f7f3f, 0xffaf1f, 0xffaf1f, 0x7f7f3f, 
-  0xbf2f, 0xaf1f, 0xaf1f, 0xaf1f, 0xaf1f, 0xaf1f, 0xaf1f, 0xaf1f, 
-  0xaf1f, 0xbf3f, 0xaf1f, 0xaf1f, 0x7f7f2f, 0x7f7f2f, 0x7f7f3f, 0xbf2f, 
-  0x7f7f3f, 0xbf2f, 0x7f7f2f, 0x7f7f2f, 0x7f7f3f, 0xbf2f, 0x7f7f3f, 0xbf2f, 
-  (1U<<31) | 6437, (1U<<31) | 6437, (1U<<31) | 6437, (1U<<31) | 6437, 0x7f7f2f, 0x7f2f, 0x7f7f2f, 0x7f2f, 
-  0x7f2f, 0x7f2f, 0x7f7f2f, (1U<<31) | 6293, (1U<<31) | 6283, (1U<<31) | 6271, (1U<<31) | 6293, (1U<<31) | 6339, 
-  (1U<<31) | 6293, (1U<<31) | 6283, (1U<<31) | 6322, (1U<<31) | 6283, (1U<<31) | 6271, (1U<<31) | 6301, (1U<<31) | 6271, 0x7f7f3f, 
-  (1U<<31) | 6199, 0x552c, (1U<<31) | 6187, 0x7f3f, (1U<<31) | 4643, (1U<<31) | 6187, 0x7f7f3f, 0xbf3f, 
-  0xbf1f, 0xbf1f, 0x9f1f, 0x9f1f, 0x9f1f, (1U<<31) | 6437, 0x7f7f3f, (1U<<31) | 6194, 
-  0x7f7f3f, 0x7f7f3f, 0x7f7f3f, 0xbf1f, 0x7f7f3f, 0x7f7f3f, 0xbf1f, (1U<<31) | 6199, 
-  0x7f1f, 0x7f7f1f, 0x7f7f1f, (1U<<31) | 6199, 0x445, 0x7f1f, 0x7f7f1f, 0x7f7f1f, 
-  (1U<<31) | 4643, (1U<<31) | 4643, 0x7f7f1f, 0x7f7f1f, (1U<<31) | 4643, (1U<<31) | 4643, 0x7f7f1f, (1U<<31) | 6177, 
-  (1U<<31) | 6177, 0x7f7f3f, 0x7f7f1f, 0x7f7f1f, (1U<<31) | 4649, 0xcf7f3f0, (1U<<31) | 6393, (1U<<31) | 6413, 
-  0xcf7f3f0, (1U<<31) | 6352, (1U<<31) | 6393, (1U<<31) | 6361, (1U<<31) | 6413, (1U<<31) | 6372, (1U<<31) | 6187, 0x7f7f1f, 
-  0x7f2c3f, 0x7f2c2c3f, (1U<<31) | 6131, (1U<<31) | 6103, 0x7f2c7f3f, (1U<<31) | 6155, (1U<<31) | 6142, (1U<<31) | 6116, 
-  0x7f7f3f, 0xbf3f, 0xbf1f, 0xbf1f, (1U<<31) | 6437, 0x7f7f3f, 0x7f7f3f, 0x7f7f3f, 
-  0x7f7f3f, 0xbf1f, 0x7f7f3f, 0x7f7f3f, 0xbf1f, (1U<<31) | 6199, 0x7f7f1f, 0x7f7f1f, 
-  (1U<<31) | 4643, 0x7f7f1f, (1U<<31) | 4643, 0x7f7f1f, (1U<<31) | 6177, 0x7f3f, 0x7f7f3f, 0x7f7f1f, 
-  0x7f3f, 0x7f7f1f, (1U<<31) | 4649, 0x7f7f1f, 0x57f5bf3f, 0x4af1f, 0x4af1f, 0x7a3a, 
-  0x49f2f, 0x49f2f, 0x3a7a, 0x47f7f3f, 0x47f7f3f, 0x7f7f1f, 0x7f7f2f, 0x87, 
-  0x545, 0x2e2e0, 0x2e554, 0x4f54, 0x2e554, 0x4f54, 0x2e2e5, 0x7f7f1f, 
-  0x4444, 0x4444, (1U<<31) | 136, (1U<<31) | 136, (1U<<31) | 117, (1U<<31) | 117, 0x1444a444, (1U<<31) | 117, 
-  (1U<<31) | 117, (1U<<31) | 117, (1U<<31) | 117, (1U<<31) | 117, (1U<<31) | 117, (1U<<31) | 117, (1U<<31) | 117, 0x11444a0f, 
-  0x11444a0f, (1U<<31) | 26, (1U<<31) | 26, 0x0, 0x0, 0x0, 0x42f1, 0x7f2f, 
-  0x7777, 0x7777, 0x7777, 0x7777, 0x4439, 0x4439, 0x4474, 0x7739, 
-  0x7739, 0x7769, 0x5, (1U<<31) | 383, 0x7f7f7f2f, (1U<<31) | 156, (1U<<31) | 146, 0x14f4, 
-  0x444, 0x14f4, (1U<<31) | 127, (1U<<31) | 127, (1U<<31) | 127, 0x440, 0x440, 0x440, 
-  0x40, 0x40, 0x40, (1U<<31) | 0, (1U<<31) | 0, 0x444, 0x444, (1U<<31) | 6264, 
-  0x1f0, (1U<<31) | 46, (1U<<31) | 36, 0x4ffaf1f, 0x777, 0x1769697, 0x7f7f7f2f, 0x7f7f7f2f, 
-  0x777, 0x7f2f, 0xaf1f, 0x7f2f, 0x4, 0x4ff9f1f, (1U<<31) | 60, 0x9f11f, 
-  (1U<<31) | 3531, (1U<<31) | 3580, (1U<<31) | 3580, (1U<<31) | 3637, (1U<<31) | 3702, (1U<<31) | 3637, (1U<<31) | 3637, (1U<<31) | 3637, 
-  (1U<<31) | 3531, (1U<<31) | 3580, (1U<<31) | 3580, (1U<<31) | 3637, (1U<<31) | 3702, (1U<<31) | 3637, (1U<<31) | 3637, (1U<<31) | 3637, 
-  (1U<<31) | 3542, (1U<<31) | 3593, (1U<<31) | 3593, (1U<<31) | 3652, (1U<<31) | 3719, (1U<<31) | 3652, (1U<<31) | 3652, (1U<<31) | 3652, 
-  (1U<<31) | 3531, (1U<<31) | 3580, (1U<<31) | 3580, (1U<<31) | 3637, (1U<<31) | 3702, (1U<<31) | 3637, (1U<<31) | 3637, (1U<<31) | 3637, 
-  (1U<<31) | 3531, (1U<<31) | 3580, (1U<<31) | 3580, (1U<<31) | 3637, (1U<<31) | 3702, (1U<<31) | 3637, (1U<<31) | 3637, (1U<<31) | 3637, 
-  (1U<<31) | 3531, (1U<<31) | 3580, (1U<<31) | 3580, (1U<<31) | 3637, (1U<<31) | 3702, (1U<<31) | 3637, (1U<<31) | 3637, (1U<<31) | 3637, 
-  (1U<<31) | 3531, (1U<<31) | 3580, (1U<<31) | 3580, (1U<<31) | 3637, (1U<<31) | 3702, (1U<<31) | 3637, (1U<<31) | 3637, (1U<<31) | 3637, 
-  (1U<<31) | 3531, (1U<<31) | 3580, (1U<<31) | 3580, (1U<<31) | 3637, (1U<<31) | 3702, (1U<<31) | 3637, (1U<<31) | 3637, (1U<<31) | 3637, 
-  (1U<<31) | 3531, (1U<<31) | 3580, (1U<<31) | 3580, (1U<<31) | 3637, (1U<<31) | 3702, (1U<<31) | 3637, (1U<<31) | 3637, (1U<<31) | 3637, 
-  (1U<<31) | 3531, (1U<<31) | 3580, (1U<<31) | 3580, (1U<<31) | 3637, (1U<<31) | 3702, (1U<<31) | 3637, (1U<<31) | 3637, (1U<<31) | 3637, 
-  (1U<<31) | 3531, (1U<<31) | 3580, (1U<<31) | 3580, (1U<<31) | 3637, (1U<<31) | 3702, (1U<<31) | 3637, (1U<<31) | 3637, (1U<<31) | 3637, 
-  (1U<<31) | 3531, (1U<<31) | 3580, (1U<<31) | 3580, (1U<<31) | 3637, (1U<<31) | 3702, (1U<<31) | 3637, (1U<<31) | 3637, (1U<<31) | 3637, 
-  (1U<<31) | 3531, (1U<<31) | 3580, (1U<<31) | 3580, (1U<<31) | 3637, (1U<<31) | 3702, (1U<<31) | 3637, (1U<<31) | 3637, (1U<<31) | 3637, 
-  (1U<<31) | 1755, (1U<<31) | 1819, (1U<<31) | 2144, (1U<<31) | 2396, (1U<<31) | 2396, (1U<<31) | 2792, (1U<<31) | 2792, (1U<<31) | 2415, 
-  (1U<<31) | 2813, (1U<<31) | 2813, (1U<<31) | 2396, (1U<<31) | 2161, (1U<<31) | 2415, (1U<<31) | 2415, (1U<<31) | 1786, (1U<<31) | 1854, 
-  (1U<<31) | 2107, (1U<<31) | 2355, (1U<<31) | 2355, (1U<<31) | 2747, (1U<<31) | 2747, (1U<<31) | 2375, (1U<<31) | 2769, (1U<<31) | 2769, 
-  (1U<<31) | 2355, (1U<<31) | 2125, (1U<<31) | 2375, (1U<<31) | 2375, (1U<<31) | 1854, (1U<<31) | 1930, (1U<<31) | 1930, (1U<<31) | 1872, 
-  (1U<<31) | 1950, (1U<<31) | 1950, (1U<<31) | 1854, (1U<<31) | 1854, (1U<<31) | 1930, (1U<<31) | 1930, (1U<<31) | 1872, (1U<<31) | 1950, 
-  (1U<<31) | 1950, (1U<<31) | 1786, (1U<<31) | 1854, (1U<<31) | 1854, (1U<<31) | 1802, (1U<<31) | 1872, (1U<<31) | 1872, (1U<<31) | 1802, 
-  (1U<<31) | 1872, (1U<<31) | 1872, (1U<<31) | 1819, (1U<<31) | 1891, (1U<<31) | 1891, (1U<<31) | 1836, (1U<<31) | 1910, (1U<<31) | 1910, 
-  (1U<<31) | 1819, (1U<<31) | 1819, (1U<<31) | 1891, (1U<<31) | 1891, (1U<<31) | 1836, (1U<<31) | 1910, (1U<<31) | 1910, (1U<<31) | 1755, 
-  (1U<<31) | 1819, (1U<<31) | 1819, (1U<<31) | 1770, (1U<<31) | 1836, (1U<<31) | 1836, (1U<<31) | 1770, (1U<<31) | 1836, (1U<<31) | 1836, 
-  (1U<<31) | 1699, (1U<<31) | 1755, (1U<<31) | 1755, (1U<<31) | 1819, (1U<<31) | 1819, (1U<<31) | 1819, (1U<<31) | 3521, (1U<<31) | 3521, 
-  (1U<<31) | 3521, (1U<<31) | 3521, (1U<<31) | 3521, (1U<<31) | 3521, (1U<<31) | 3521, (1U<<31) | 3521, (1U<<31) | 3510, (1U<<31) | 3555, 
-  (1U<<31) | 3555, (1U<<31) | 3608, (1U<<31) | 3669, (1U<<31) | 3608, (1U<<31) | 3608, (1U<<31) | 3608, (1U<<31) | 3555, (1U<<31) | 3608, 
-  (1U<<31) | 3608, (1U<<31) | 3669, (1U<<31) | 3669, (1U<<31) | 3669, (1U<<31) | 1699, (1U<<31) | 1755, (1U<<31) | 1755, (1U<<31) | 1819, 
-  (1U<<31) | 1819, (1U<<31) | 2004, (1U<<31) | 2144, (1U<<31) | 2144, (1U<<31) | 2396, (1U<<31) | 2396, (1U<<31) | 2144, (1U<<31) | 2396, 
-  (1U<<31) | 2396, (1U<<31) | 2792, (1U<<31) | 2792, (1U<<31) | 2792, (1U<<31) | 2161, (1U<<31) | 2415, (1U<<31) | 2415, (1U<<31) | 2813, 
-  (1U<<31) | 2813, (1U<<31) | 2813, (1U<<31) | 2396, (1U<<31) | 2019, (1U<<31) | 2161, (1U<<31) | 2161, (1U<<31) | 2415, (1U<<31) | 2415, 
-  (1U<<31) | 2415, (1U<<31) | 1726, (1U<<31) | 1786, (1U<<31) | 1786, (1U<<31) | 1854, (1U<<31) | 1854, (1U<<31) | 1971, (1U<<31) | 2107, 
-  (1U<<31) | 2107, (1U<<31) | 2355, (1U<<31) | 2355, (1U<<31) | 2107, (1U<<31) | 2355, (1U<<31) | 2355, (1U<<31) | 2747, (1U<<31) | 2747, 
-  (1U<<31) | 2747, (1U<<31) | 2125, (1U<<31) | 2375, (1U<<31) | 2375, (1U<<31) | 2769, (1U<<31) | 2769, (1U<<31) | 2769, (1U<<31) | 2355, 
-  (1U<<31) | 1987, (1U<<31) | 2125, (1U<<31) | 2125, (1U<<31) | 2375, (1U<<31) | 2375, (1U<<31) | 2375, (1U<<31) | 2070, (1U<<31) | 2218, 
-  (1U<<31) | 2306, (1U<<31) | 2574, (1U<<31) | 2686, (1U<<31) | 2218, (1U<<31) | 2478, (1U<<31) | 2574, (1U<<31) | 2890, (1U<<31) | 3010, 
-  (1U<<31) | 2890, (1U<<31) | 2238, (1U<<31) | 2500, (1U<<31) | 2600, (1U<<31) | 2918, (1U<<31) | 3042, (1U<<31) | 2918, (1U<<31) | 2574, 
-  (1U<<31) | 2088, (1U<<31) | 2238, (1U<<31) | 2330, (1U<<31) | 2600, (1U<<31) | 2716, (1U<<31) | 2600, (1U<<31) | 1786, (1U<<31) | 1854, 
-  (1U<<31) | 1854, (1U<<31) | 1930, (1U<<31) | 1930, (1U<<31) | 1930, (1U<<31) | 1802, (1U<<31) | 1872, (1U<<31) | 1872, (1U<<31) | 1950, 
-  (1U<<31) | 1950, (1U<<31) | 1950, (1U<<31) | 1854, (1U<<31) | 2070, (1U<<31) | 2218, (1U<<31) | 2306, (1U<<31) | 2574, (1U<<31) | 2686, 
-  (1U<<31) | 2218, (1U<<31) | 2478, (1U<<31) | 2574, (1U<<31) | 2890, (1U<<31) | 3010, (1U<<31) | 2890, (1U<<31) | 2238, (1U<<31) | 2500, 
-  (1U<<31) | 2600, (1U<<31) | 2918, (1U<<31) | 3042, (1U<<31) | 2918, (1U<<31) | 2574, (1U<<31) | 2088, (1U<<31) | 2238, (1U<<31) | 2330, 
-  (1U<<31) | 2600, (1U<<31) | 2716, (1U<<31) | 2600, (1U<<31) | 1786, (1U<<31) | 1854, (1U<<31) | 1854, (1U<<31) | 1930, (1U<<31) | 1930, 
-  (1U<<31) | 1930, (1U<<31) | 1802, (1U<<31) | 1872, (1U<<31) | 1872, (1U<<31) | 1950, (1U<<31) | 1950, (1U<<31) | 1950, (1U<<31) | 1726, 
-  (1U<<31) | 1786, (1U<<31) | 1786, (1U<<31) | 1854, (1U<<31) | 1854, (1U<<31) | 1854, (1U<<31) | 1740, (1U<<31) | 1802, (1U<<31) | 1802, 
-  (1U<<31) | 1872, (1U<<31) | 1872, (1U<<31) | 1872, (1U<<31) | 1740, (1U<<31) | 1802, (1U<<31) | 1802, (1U<<31) | 1872, (1U<<31) | 1872, 
-  (1U<<31) | 1872, (1U<<31) | 2035, (1U<<31) | 2179, (1U<<31) | 2259, (1U<<31) | 2523, (1U<<31) | 2627, (1U<<31) | 2179, (1U<<31) | 2435, 
-  (1U<<31) | 2523, (1U<<31) | 2835, (1U<<31) | 2947, (1U<<31) | 2835, (1U<<31) | 2198, (1U<<31) | 2456, (1U<<31) | 2548, (1U<<31) | 2862, 
-  (1U<<31) | 2978, (1U<<31) | 2862, (1U<<31) | 2523, (1U<<31) | 2052, (1U<<31) | 2198, (1U<<31) | 2282, (1U<<31) | 2548, (1U<<31) | 2656, 
-  (1U<<31) | 2548, (1U<<31) | 1755, (1U<<31) | 1819, (1U<<31) | 1819, (1U<<31) | 1891, (1U<<31) | 1891, (1U<<31) | 1891, (1U<<31) | 1770, 
-  (1U<<31) | 1836, (1U<<31) | 1836, (1U<<31) | 1910, (1U<<31) | 1910, (1U<<31) | 1910, (1U<<31) | 1819, (1U<<31) | 2035, (1U<<31) | 2179, 
-  (1U<<31) | 2259, (1U<<31) | 2523, (1U<<31) | 2627, (1U<<31) | 2179, (1U<<31) | 2435, (1U<<31) | 2523, (1U<<31) | 2835, (1U<<31) | 2947, 
-  (1U<<31) | 2835, (1U<<31) | 2198, (1U<<31) | 2456, (1U<<31) | 2548, (1U<<31) | 2862, (1U<<31) | 2978, (1U<<31) | 2862, (1U<<31) | 2523, 
-  (1U<<31) | 2052, (1U<<31) | 2198, (1U<<31) | 2282, (1U<<31) | 2548, (1U<<31) | 2656, (1U<<31) | 2548, (1U<<31) | 1755, (1U<<31) | 1819, 
-  (1U<<31) | 1819, (1U<<31) | 1891, (1U<<31) | 1891, (1U<<31) | 1891, (1U<<31) | 1770, (1U<<31) | 1836, (1U<<31) | 1836, (1U<<31) | 1910, 
-  (1U<<31) | 1910, (1U<<31) | 1910, (1U<<31) | 1699, (1U<<31) | 1755, (1U<<31) | 1755, (1U<<31) | 1819, (1U<<31) | 1819, (1U<<31) | 1819, 
-  (1U<<31) | 1712, (1U<<31) | 1770, (1U<<31) | 1770, (1U<<31) | 1836, (1U<<31) | 1836, (1U<<31) | 1836, (1U<<31) | 1712, (1U<<31) | 1770, 
-  (1U<<31) | 1770, (1U<<31) | 1836, (1U<<31) | 1836, (1U<<31) | 1836, (1U<<31) | 3520, (1U<<31) | 3567, (1U<<31) | 3567, (1U<<31) | 3622, 
-  (1U<<31) | 3685, (1U<<31) | 3622, (1U<<31) | 3622, (1U<<31) | 3622, (1U<<31) | 3567, (1U<<31) | 3622, (1U<<31) | 3622, (1U<<31) | 3685, 
-  (1U<<31) | 3685, (1U<<31) | 3685, (1U<<31) | 383, (1U<<31) | 383, 0x50, 0x440, 0x44447, 0x44477, 
-  0x414477, 0x444777, 0x4144776, (1U<<31) | 383, 0x10, 0x47f2f, 0x4444, 0x7f2f, 
-  0x1f1, 0x444, 0x444, (1U<<31) | 3454, (1U<<31) | 3500, (1U<<31) | 3476, (1U<<31) | 3488, (1U<<31) | 3466, 
-  (1U<<31) | 3442, (1U<<31) | 3356, (1U<<31) | 3322, (1U<<31) | 3500, (1U<<31) | 3476, (1U<<31) | 3344, (1U<<31) | 3488, (1U<<31) | 3466, 
-  (1U<<31) | 3442, (1U<<31) | 3454, (1U<<31) | 3280, (1U<<31) | 3312, (1U<<31) | 3334, (1U<<31) | 3312, (1U<<31) | 3280, 0x14447f1f, 
-  0x47f1f, 0x5455, 0x4a454a, 0x4444, 0x1144444, 0x1144444, 0x1, 0x5455, 
-  (1U<<31) | 383, (1U<<31) | 3290, (1U<<31) | 3290, (1U<<31) | 3300, (1U<<31) | 3290, (1U<<31) | 3290, (1U<<31) | 3290, (1U<<31) | 3290, 
-  (1U<<31) | 3290, (1U<<31) | 3290, (1U<<31) | 3290, (1U<<31) | 3290, 0x4444a0f, 0x4444a0f, 0x4444a0f0, 0x4444a0f0, 
-  0x44444a0f, (1U<<31) | 3239, 0x7f2f, 0x77, 0x44, 0x444, 0x7f2f, 0x7f2f, 
+  0x17f1f, 0x4f, 0x2e2e, (1U<<31) | 2056, 0x10, 0x7f1f, 0x7f1f, 
+  (1U<<31) | 6520, (1U<<31) | 6517, (1U<<31) | 9230, 0x7f2f, 0x7f2f, 0x2e2e0, (1U<<31) | 9251, 0x32f, 
+  0x2f3, 0x7f7f2f, (1U<<31) | 9233, (1U<<31) | 1533, (1U<<31) | 9230, (1U<<31) | 9236, 0x2e2e2e, 0x2e0, 
+  0x2e, (1U<<31) | 1060, 0x2e0, 0x2e1, 0x12e1, (1U<<31) | 9547, 0x2e, (1U<<31) | 1060, 
+  (1U<<31) | 920, (1U<<31) | 1004, (1U<<31) | 908, (1U<<31) | 908, 0x2e, 0x2e2e1, 0x2e2e, 0x2e2e, 
+  0x142e2e, 0x2e0, (1U<<31) | 1062, 0x1f, 0x22e2e, (1U<<31) | 328, (1U<<31) | 9553, (1U<<31) | 9539, 
+  0x7f2f, 0x17f1f, 0x7f1f, 0x17f1f, (1U<<31) | 9462, (1U<<31) | 9462, (1U<<31) | 9251, (1U<<31) | 9462, 
+  0x0, 0x0, 0x42e, (1U<<31) | 9241, (1U<<31) | 9240, 0x2e2e2e, 0x2e40, 0x2e50, 
+  0x40, 0x2e0, 0x2e0, 0x2e, 0x2e4, 0x0, 0x2e4, 0x0, 
+  0x7f2f, 0x7f2f, 0x7f7f1f, 0x87f7f1f, (1U<<31) | 9272, (1U<<31) | 9414, (1U<<31) | 9414, (1U<<31) | 9414, 
+  (1U<<31) | 9421, (1U<<31) | 9411, (1U<<31) | 9411, (1U<<31) | 9421, (1U<<31) | 9272, (1U<<31) | 9430, (1U<<31) | 9421, (1U<<31) | 9430, 
+  (1U<<31) | 9292, (1U<<31) | 9286, (1U<<31) | 9286, (1U<<31) | 9455, (1U<<31) | 9421, (1U<<31) | 9421, (1U<<31) | 9448, (1U<<31) | 9286, 
+  (1U<<31) | 9414, (1U<<31) | 9414, (1U<<31) | 9414, (1U<<31) | 9448, (1U<<31) | 9286, (1U<<31) | 9278, (1U<<31) | 9278, (1U<<31) | 9278, 
+  (1U<<31) | 9278, (1U<<31) | 9414, (1U<<31) | 9421, (1U<<31) | 9403, (1U<<31) | 9414, (1U<<31) | 9272, (1U<<31) | 9272, (1U<<31) | 9414, 
+  (1U<<31) | 9441, (1U<<31) | 9414, (1U<<31) | 9272, (1U<<31) | 9441, (1U<<31) | 9539, (1U<<31) | 4991, (1U<<31) | 9229, (1U<<31) | 9582, 
+  (1U<<31) | 9543, (1U<<31) | 9574, (1U<<31) | 9566, (1U<<31) | 9591, 0x5bf3f, 0x5bf7f3f, 0x1, 0x7f2f, 
+  0x7f2f, 0x4, 0x7f7f7f2f, 0x7f7f7f2f, 0xaf1f, 0xaf1f, 0x44f, 0x7f7f7f1f, 
+  0x7f7f7f1f, 0x2ee2e2e, 0x2e2ee0, 0x2ee2e2e0, 0xff9f3f, 0x1f, 0x42e2e0, 0x42e2e0, 
+  (1U<<31) | 9540, 0x2e2e2e0, 0x4452e0, 0x54452e0, 0x44552e0, (1U<<31) | 6380, (1U<<31) | 6381, 0xf1, 
+  0x7f4f, 0x4f50, 0x4f50, 0xaf1f, 0xaf1f, 0x1f2e2e, 0x2e, (1U<<31) | 9540, 
+  0x42e2e2e, 0x7f2f, 0x7f2f, 0x7f2f, 0x1f1, 0x7f7f1f, 0xaf1f, 0xaf1f, 
+  (1U<<31) | 115, (1U<<31) | 7834, (1U<<31) | 7801, (1U<<31) | 7813, (1U<<31) | 76, (1U<<31) | 87, (1U<<31) | 3588, (1U<<31) | 3587, 
+  (1U<<31) | 4431, 0x447f3f, 0x7f7f2f, 0x7f7f2f, (1U<<31) | 319, (1U<<31) | 6503, (1U<<31) | 319, (1U<<31) | 319, 
+  (1U<<31) | 6503, 0x19f24f0, 0x49f24f0, 0x7f7f2f, 0x7f7f2f, 0x7f2f, 0x2ee2ee0, 0x2ee2ee0, 
+  0x2ee2ee0, 0x2ee2ee0, 0x2e2e, 0x2e0, 0x2e, 0x2e2e, (1U<<31) | 9540, 0x2ee2ee0, 
+  0x2ee0, 0x2e2ee2e, 0x2ee2e, 0x2ee2e, 0x2ee2ee0, 0x2e0, 0x2e2e, 0x2e2e, 
+  0x2e2e, 0x2e2e, 0x2e2e, 0x2e2e, 0x2e2e, 0x2e2ee0, 0x2e2ee2e, 0x2e4, 
+  0x2e4, 0x2e2e, 0x2e2e, 0x2e2e, 0x111cf1f, 0x40, 0x7f7f2f, 0x47f2f, 
+  0x4444f0, 0x44cf4f, 0x44cf4f, 0x4cf4f, 0x4550, (1U<<31) | 960, 0x9f7f4f, (1U<<31) | 9254, 
+  (1U<<31) | 9254, 0x5, 0x42e, 0x7f2f, 0x7f2f, 0x7f2f, 0x7f7f1f, (1U<<31) | 7940, 
+  0x47f7f1f, 0x47f7f1f, 0x1f0, 0x0, 0x7f2f, 0x7f7f1f, 0x7f7f1f, 0x47f7f1f, 
+  0x47f7f1f, (1U<<31) | 7940, 0x4f, 0x7f2f, 0x7f0f, 0x7f7f1f, 0x7f7f1f, (1U<<31) | 7940, 
+  0x2e, 0x2ee2e0, 0x2e0, 0x2e, 0x7f1f, 0x7f4f, 0x1f1, 0x2e, 
+  0x0, 0x7f2f, (1U<<31) | 9263, (1U<<31) | 9258, 0x7f7f1f, (1U<<31) | 7940, 0x20, 0x47f7f1f, 
+  0x47f7f1f, 0x7f7f1f, 0x7f7f1f, 0x47f7f1f, 0x47f7f1f, (1U<<31) | 7940, 0x7f7f1f, 0x7f7f1f, 
+  (1U<<31) | 7940, 0x2e2e0, 0x2e0, 0x2e0, (1U<<31) | 929, (1U<<31) | 1193, (1U<<31) | 1193, (1U<<31) | 1198, 
+  (1U<<31) | 1193, (1U<<31) | 1193, (1U<<31) | 1198, (1U<<31) | 1193, (1U<<31) | 1193, (1U<<31) | 1193, (1U<<31) | 1193, (1U<<31) | 1193, 
+  (1U<<31) | 1193, (1U<<31) | 1193, (1U<<31) | 1212, (1U<<31) | 1212, (1U<<31) | 1212, (1U<<31) | 1212, (1U<<31) | 1212, (1U<<31) | 1212, 
+  (1U<<31) | 1212, (1U<<31) | 1212, (1U<<31) | 1212, (1U<<31) | 1212, (1U<<31) | 1212, (1U<<31) | 1212, (1U<<31) | 1212, 0x1f, 
+  (1U<<31) | 280, 0x42e0, 0x42e30, 0x52e2e, 0x0, 0x44, 0x54, 0x444, 
+  0x444, 0x444, 0x444, 0x544, 0x444, 0x444, 0x544, 0x2c2c2c, 
+  0x2c2c2c, 0x2c2c, 0x2c2c, 0x4a44a4a, 0x44, 0x4a44a4a, 0x4a44a4a, 0x4a4a4a4a, 
+  0x4a4a4a, 0x4a4a4a4a, 0x4a4a4a4a, 0x4a4a4a, 0x4a4a4a4a, 0x40, 0x40, 0x84, 
+  0x5, 0x52e5, 0x40, 0x52e2e, 0x52e, 0x40, (1U<<31) | 1027, (1U<<31) | 1039, 
+  0x4f5, 0x2e2e2e, (1U<<31) | 1039, 0x4f5, 0x7f0f, (1U<<31) | 8109, 0x7f7f3f, (1U<<31) | 8290, 
+  (1U<<31) | 7788, (1U<<31) | 7786, (1U<<31) | 8964, (1U<<31) | 9649, (1U<<31) | 9649, (1U<<31) | 9649, 0x7f3f, 0x7f7f3f, 
+  0xffaf1f, 0xffaf1f, 0x7f7f3f, 0xbf2f, 0xaf1f, 0xaf1f, 0xaf1f, 0xaf1f, 
+  0xaf1f, 0xaf1f, 0xaf1f, 0xaf1f, 0xbf3f, 0xaf1f, 0xaf1f, 0x7f7f2f, 
+  0x7f7f2f, 0x7f7f3f, 0xbf2f, 0x7f7f3f, 0xbf2f, 0x7f7f2f, 0x7f7f2f, 0x7f7f3f, 
+  0xbf2f, 0x7f7f3f, 0xbf2f, (1U<<31) | 8964, (1U<<31) | 8964, (1U<<31) | 8964, (1U<<31) | 8964, 0x7f7f2f, 
+  0x7f2f, 0x7f7f2f, 0x7f2f, 0x7f2f, 0x7f2f, 0x7f7f2f, (1U<<31) | 8755, (1U<<31) | 8745, 
+  (1U<<31) | 8733, (1U<<31) | 8755, (1U<<31) | 8801, (1U<<31) | 8755, (1U<<31) | 8745, (1U<<31) | 8784, (1U<<31) | 8745, (1U<<31) | 8733, 
+  (1U<<31) | 8763, (1U<<31) | 8733, 0x7f7f3f, (1U<<31) | 8121, 0x552c, (1U<<31) | 8109, 0x7f3f, (1U<<31) | 5497, 
+  (1U<<31) | 8109, 0x7f7f3f, 0xbf3f, 0xbf1f, 0xbf1f, 0x9f1f, 0x9f1f, 0x9f1f, 
+  (1U<<31) | 8964, 0x7f7f3f, (1U<<31) | 8116, 0x7f7f3f, 0x7f7f3f, 0x7f7f3f, 0xbf1f, 0x7f7f3f, 
+  0x7f7f3f, 0xbf1f, (1U<<31) | 8964, (1U<<31) | 8121, 0x7f1f, 0x7f7f1f, 0x7f7f1f, 0x49f7f1f, 
+  0x49f7f1f, (1U<<31) | 8121, 0x445, 0x7f1f, 0x7f7f1f, 0x49f7f1f, 0x49f7f1f, 0x7f7f1f, 
+  (1U<<31) | 5497, (1U<<31) | 5497, 0x7f7f1f, 0x7f7f1f, (1U<<31) | 5497, (1U<<31) | 5497, 0x7f7f1f, (1U<<31) | 8099, 
+  (1U<<31) | 8099, 0x7f7f3f, 0x7f7f1f, 0x7f7f1f, (1U<<31) | 5503, 0xcf7f3f0, (1U<<31) | 8855, (1U<<31) | 8875, 
+  0xcf7f3f0, (1U<<31) | 8814, (1U<<31) | 8855, (1U<<31) | 8823, (1U<<31) | 8875, (1U<<31) | 8834, (1U<<31) | 8109, 0x7f7f1f, 
+  0x7f2c3f, 0x7f2c2c3f, (1U<<31) | 7872, (1U<<31) | 7844, 0x7f2c7f3f, (1U<<31) | 7896, (1U<<31) | 7883, (1U<<31) | 7857, 
+  0x7f7f3f, 0xbf3f, 0xbf1f, 0xbf1f, (1U<<31) | 8964, 0x7f7f3f, 0x7f7f3f, 0x7f7f3f, 
+  0x7f7f3f, 0xbf1f, 0x7f7f3f, 0x7f7f3f, 0xbf1f, (1U<<31) | 8964, (1U<<31) | 8121, 0x7f7f1f, 
+  0x7f7f1f, (1U<<31) | 5497, 0x7f7f1f, (1U<<31) | 5497, 0x7f7f1f, (1U<<31) | 8099, 0x7f3f, 0x7f7f3f, 
+  0x7f7f1f, 0x7f3f, (1U<<31) | 8964, 0x7f7f1f, (1U<<31) | 5503, (1U<<31) | 8964, 0x7f7f1f, 0x7f7f3f, 
+  0x7f7f3f, 0x7f7f7f3f, 0x7f7f7f3f, 0x7f7f7f3f, 0x7f7f7f3f, 0x57f5bf3f, 0x4af1f, 0x4af1f, 
+  0x7a3a, 0x49f2f, 0x49f2f, 0x3a7a, 0x47f7f3f, 0x47f7f3f, 0x7f7f1f, 0x52e0, 
+  0x52e0, 0x7f7f2f, 0x87, 0x545, (1U<<31) | 6601, (1U<<31) | 6613, (1U<<31) | 6613, 0x2e2e0, 
+  0x552e0, 0x2e554, 0x4f54, 0x2e554, 0x4f54, 0x2e2e5, (1U<<31) | 7824, 0x7f7f7f3f, 
+  0x7f7f7f3f, (1U<<31) | 7951, (1U<<31) | 7933, (1U<<31) | 7931, (1U<<31) | 7951, 0x7f7f3f, 0x7f7f3f, 0x7f7f3f, 
+  0x7f7f3f, (1U<<31) | 892, (1U<<31) | 892, (1U<<31) | 895, (1U<<31) | 895, (1U<<31) | 7951, (1U<<31) | 7951, (1U<<31) | 1159, 
+  (1U<<31) | 7951, (1U<<31) | 6790, (1U<<31) | 5433, 0x7f7f7f3f, 0x7f7f3f, 0x7f7f3f, (1U<<31) | 9636, (1U<<31) | 6839, 
+  (1U<<31) | 9636, (1U<<31) | 6839, (1U<<31) | 9636, (1U<<31) | 6839, (1U<<31) | 9636, 0x7f7f3f, (1U<<31) | 7951, (1U<<31) | 7951, 
+  (1U<<31) | 7824, (1U<<31) | 7793, (1U<<31) | 7824, (1U<<31) | 7793, (1U<<31) | 7951, (1U<<31) | 7951, (1U<<31) | 7951, 0x7f7f7f3f, 
+  0x7f7f7f3f, 0x7f7f7f3f, 0x47f7f3f, (1U<<31) | 5533, (1U<<31) | 4608, (1U<<31) | 7951, (1U<<31) | 1188, (1U<<31) | 7951, 
+  (1U<<31) | 1188, (1U<<31) | 7824, (1U<<31) | 7824, (1U<<31) | 4543, (1U<<31) | 5476, (1U<<31) | 7907, (1U<<31) | 6768, (1U<<31) | 7907, 
+  (1U<<31) | 6768, (1U<<31) | 7907, (1U<<31) | 6768, (1U<<31) | 7907, (1U<<31) | 6768, (1U<<31) | 7907, (1U<<31) | 6768, (1U<<31) | 6768, 
+  (1U<<31) | 6768, (1U<<31) | 6768, (1U<<31) | 6768, (1U<<31) | 7907, (1U<<31) | 6768, (1U<<31) | 7824, (1U<<31) | 1167, 0x45, 
+  0x45, 0x45, 0x7f3f5, 0x45, (1U<<31) | 7793, (1U<<31) | 269, (1U<<31) | 1177, (1U<<31) | 8183, 
+  (1U<<31) | 8193, 0x57f3f, (1U<<31) | 7951, (1U<<31) | 7951, 0x7f7f7f3f, 0x7f7f7f3f, 0x7f7f7f3f, (1U<<31) | 1159, 
+  0x47f7f3f, (1U<<31) | 7951, (1U<<31) | 7824, (1U<<31) | 7907, (1U<<31) | 7907, (1U<<31) | 7951, (1U<<31) | 1188, (1U<<31) | 7951, 
+  (1U<<31) | 1159, (1U<<31) | 5442, (1U<<31) | 5463, (1U<<31) | 4543, (1U<<31) | 7907, (1U<<31) | 7907, (1U<<31) | 7907, (1U<<31) | 7907, 
+  (1U<<31) | 7907, (1U<<31) | 8537, (1U<<31) | 7773, (1U<<31) | 7760, (1U<<31) | 8337, (1U<<31) | 7056, (1U<<31) | 8350, (1U<<31) | 7030, 
+  (1U<<31) | 7747, (1U<<31) | 7056, (1U<<31) | 7747, (1U<<31) | 7773, (1U<<31) | 7760, (1U<<31) | 8350, (1U<<31) | 8350, (1U<<31) | 8350, 
+  (1U<<31) | 8547, (1U<<31) | 7043, (1U<<31) | 8324, (1U<<31) | 7017, (1U<<31) | 7734, (1U<<31) | 8547, (1U<<31) | 7043, (1U<<31) | 8324, 
+  (1U<<31) | 7017, (1U<<31) | 7734, (1U<<31) | 7951, (1U<<31) | 7951, (1U<<31) | 8259, (1U<<31) | 1167, (1U<<31) | 7961, (1U<<31) | 7951, 
+  (1U<<31) | 7951, (1U<<31) | 7951, (1U<<31) | 1159, (1U<<31) | 7951, (1U<<31) | 1159, (1U<<31) | 7951, (1U<<31) | 7951, (1U<<31) | 7951, 
+  (1U<<31) | 1159, (1U<<31) | 7951, (1U<<31) | 1159, (1U<<31) | 7961, (1U<<31) | 5476, (1U<<31) | 8241, (1U<<31) | 5523, (1U<<31) | 8241, 
+  (1U<<31) | 5523, (1U<<31) | 7961, (1U<<31) | 5476, (1U<<31) | 8241, (1U<<31) | 5523, (1U<<31) | 8241, (1U<<31) | 5523, 0x7f7f7f3f, 
+  (1U<<31) | 7961, (1U<<31) | 7951, 0x47f7f3f, (1U<<31) | 7951, (1U<<31) | 7824, (1U<<31) | 7961, (1U<<31) | 7961, (1U<<31) | 7961, 
+  (1U<<31) | 7961, 0x7f3f, 0x7f7f3f, (1U<<31) | 7824, (1U<<31) | 7824, (1U<<31) | 7824, (1U<<31) | 7824, (1U<<31) | 7824, 
+  (1U<<31) | 7824, (1U<<31) | 7824, (1U<<31) | 7824, 0x7f3f, 0x7f7f3f, (1U<<31) | 8264, (1U<<31) | 7824, (1U<<31) | 7951, 
+  (1U<<31) | 7951, 0x47f7f3f, (1U<<31) | 8274, (1U<<31) | 8274, (1U<<31) | 7951, 0x7f7f3f, (1U<<31) | 8205, (1U<<31) | 8198, 
+  (1U<<31) | 1159, (1U<<31) | 1159, (1U<<31) | 8129, (1U<<31) | 6548, (1U<<31) | 6548, (1U<<31) | 6822, (1U<<31) | 2194, (1U<<31) | 2194, 
+  (1U<<31) | 2194, (1U<<31) | 2194, (1U<<31) | 8129, (1U<<31) | 8129, (1U<<31) | 8176, (1U<<31) | 8176, (1U<<31) | 8176, (1U<<31) | 8129, 
+  (1U<<31) | 6548, (1U<<31) | 6548, (1U<<31) | 6822, (1U<<31) | 2194, (1U<<31) | 2194, (1U<<31) | 2194, (1U<<31) | 2194, (1U<<31) | 8129, 
+  (1U<<31) | 8129, (1U<<31) | 6548, (1U<<31) | 6548, (1U<<31) | 6822, (1U<<31) | 2194, (1U<<31) | 7951, (1U<<31) | 6790, (1U<<31) | 7951, 
+  (1U<<31) | 6790, (1U<<31) | 7961, (1U<<31) | 7907, (1U<<31) | 7961, (1U<<31) | 5476, (1U<<31) | 7961, (1U<<31) | 5476, (1U<<31) | 7961, 
+  (1U<<31) | 7951, 0x47f7f3f, (1U<<31) | 7951, 0x7f7f7f3f, (1U<<31) | 7824, (1U<<31) | 7907, (1U<<31) | 7951, (1U<<31) | 7824, 
+  (1U<<31) | 7951, (1U<<31) | 7951, (1U<<31) | 7951, (1U<<31) | 1159, (1U<<31) | 7793, 0x7f7f3f, 0x7f7f3f, 0x7f7f3f, 
+  (1U<<31) | 7793, 0x42e3f0, (1U<<31) | 2171, (1U<<31) | 5025, (1U<<31) | 2171, (1U<<31) | 2171, (1U<<31) | 2171, (1U<<31) | 5025, 
+  (1U<<31) | 2171, (1U<<31) | 2171, (1U<<31) | 2171, (1U<<31) | 5025, (1U<<31) | 2171, (1U<<31) | 2171, (1U<<31) | 2171, (1U<<31) | 5025, 
+  (1U<<31) | 2171, (1U<<31) | 2171, 0x7f3f1, 0x7f3f1, 0x7f3f1, 0x43f, (1U<<31) | 1183, (1U<<31) | 1183, 
+  (1U<<31) | 7933, (1U<<31) | 7931, (1U<<31) | 6780, (1U<<31) | 7824, (1U<<31) | 258, (1U<<31) | 262, 0x7f3f, (1U<<31) | 7824, 
+  (1U<<31) | 7824, (1U<<31) | 7824, (1U<<31) | 2183, (1U<<31) | 2181, (1U<<31) | 7933, (1U<<31) | 7931, 0x7f7f7f3f, (1U<<31) | 8241, 
+  (1U<<31) | 8241, (1U<<31) | 7951, (1U<<31) | 8234, (1U<<31) | 8234, (1U<<31) | 8217, (1U<<31) | 8234, (1U<<31) | 8234, (1U<<31) | 8234, 
+  (1U<<31) | 1152, (1U<<31) | 8227, (1U<<31) | 8227, 0x7f7f7f3f, 0x7f7f7f3f, (1U<<31) | 8537, (1U<<31) | 6100, (1U<<31) | 6742, 
+  (1U<<31) | 6755, (1U<<31) | 6087, (1U<<31) | 7951, (1U<<31) | 7951, (1U<<31) | 8250, (1U<<31) | 5533, (1U<<31) | 7951, 0x0, 
+  (1U<<31) | 7951, (1U<<31) | 2183, (1U<<31) | 2181, (1U<<31) | 7951, (1U<<31) | 7951, 0x47f7f3f, (1U<<31) | 6113, (1U<<31) | 6113, 
+  (1U<<31) | 7951, (1U<<31) | 7951, (1U<<31) | 1159, (1U<<31) | 7951, (1U<<31) | 7951, (1U<<31) | 1159, (1U<<31) | 8241, (1U<<31) | 5523, 
+  (1U<<31) | 8241, (1U<<31) | 5523, (1U<<31) | 8241, (1U<<31) | 5523, (1U<<31) | 8241, (1U<<31) | 5523, (1U<<31) | 8250, (1U<<31) | 7951, 
+  (1U<<31) | 8234, (1U<<31) | 5515, (1U<<31) | 8234, (1U<<31) | 5515, (1U<<31) | 7951, (1U<<31) | 7824, (1U<<31) | 7951, 0x7f7f3f, 
+  0x47f7f3f, 0x4444, 0x4455, 0x447f3f, 0x4444, 0x4455, 0x447f3f, 0x4444, 
+  0x4455, (1U<<31) | 97, 0x3f44, 0x3f55, 0x447f3f, 0x4444, 0x4455, (1U<<31) | 8241, 
+  (1U<<31) | 5523, (1U<<31) | 8241, (1U<<31) | 8241, (1U<<31) | 5523, (1U<<31) | 8241, (1U<<31) | 5523, (1U<<31) | 8241, (1U<<31) | 8241, 
+  (1U<<31) | 5523, 0x7f7f3f, 0x47f7f3f, (1U<<31) | 8234, (1U<<31) | 5515, (1U<<31) | 8234, (1U<<31) | 5515, 0x4444, 
+  0x4455, 0x447f3f, 0x4444, 0x4455, 0x447f3f, 0x4444, 0x4455, (1U<<31) | 97, 
+  0x3f44, 0x3f55, 0x447f3f, 0x4444, 0x4455, (1U<<31) | 7824, (1U<<31) | 4543, (1U<<31) | 5476, 
+  0x7f7f7f3f, (1U<<31) | 5476, 0x7f7f7f3f, (1U<<31) | 5476, 0x7f7f3f, 0x47f7f3f, (1U<<31) | 7951, (1U<<31) | 2183, 
+  (1U<<31) | 2181, (1U<<31) | 2183, (1U<<31) | 2181, (1U<<31) | 7951, (1U<<31) | 5433, (1U<<31) | 2183, (1U<<31) | 2181, (1U<<31) | 2183, 
+  (1U<<31) | 2181, (1U<<31) | 7951, 0x7f7f3f, (1U<<31) | 7951, (1U<<31) | 1207, (1U<<31) | 1205, (1U<<31) | 1207, (1U<<31) | 1205, 
+  (1U<<31) | 7951, 0x47f7f3f, (1U<<31) | 7951, (1U<<31) | 5433, 0x47f7f3f, (1U<<31) | 5509, (1U<<31) | 5509, 0x47f7f3f, 
+  (1U<<31) | 8234, (1U<<31) | 8234, (1U<<31) | 8234, (1U<<31) | 8234, (1U<<31) | 8227, (1U<<31) | 8227, (1U<<31) | 8128, (1U<<31) | 6547, 
+  (1U<<31) | 6547, (1U<<31) | 6821, (1U<<31) | 2193, (1U<<31) | 2193, (1U<<31) | 2193, (1U<<31) | 2193, (1U<<31) | 8137, (1U<<31) | 8148, 
+  (1U<<31) | 8161, (1U<<31) | 8128, (1U<<31) | 6547, (1U<<31) | 6547, (1U<<31) | 6821, (1U<<31) | 2193, (1U<<31) | 7951, (1U<<31) | 7933, 
+  (1U<<31) | 7931, (1U<<31) | 7951, (1U<<31) | 5533, (1U<<31) | 8212, (1U<<31) | 8212, (1U<<31) | 7951, (1U<<31) | 7824, (1U<<31) | 7824, 
+  (1U<<31) | 7824, (1U<<31) | 8274, (1U<<31) | 8281, (1U<<31) | 8281, 0x7f7f3f, 0x7f7f3f, 0x7f7f3f, 0x7f7f3f, 
+  0xffbf3f, (1U<<31) | 8973, (1U<<31) | 8992, 0x4bf3f, 0xbf47f3f, 0x7f7f7f3f, (1U<<31) | 8241, (1U<<31) | 8241, 
+  (1U<<31) | 7951, (1U<<31) | 8234, (1U<<31) | 8234, (1U<<31) | 8217, (1U<<31) | 8234, (1U<<31) | 8234, (1U<<31) | 1152, (1U<<31) | 8227, 
+  (1U<<31) | 8227, (1U<<31) | 8537, (1U<<31) | 6100, (1U<<31) | 6742, (1U<<31) | 6755, (1U<<31) | 6087, (1U<<31) | 7951, (1U<<31) | 7951, 
+  (1U<<31) | 8250, (1U<<31) | 5533, (1U<<31) | 7951, (1U<<31) | 7951, (1U<<31) | 7951, (1U<<31) | 7951, (1U<<31) | 7951, (1U<<31) | 1159, 
+  (1U<<31) | 7951, (1U<<31) | 7951, (1U<<31) | 1159, (1U<<31) | 8241, (1U<<31) | 5523, (1U<<31) | 8241, (1U<<31) | 5523, (1U<<31) | 8241, 
+  (1U<<31) | 5523, (1U<<31) | 8241, (1U<<31) | 5523, (1U<<31) | 8250, (1U<<31) | 7951, (1U<<31) | 8234, (1U<<31) | 5515, (1U<<31) | 8234, 
+  (1U<<31) | 5515, (1U<<31) | 7951, 0x7f7f3f, 0x4444, 0x4455, 0x447f3f, 0x4444, 0x4455, 
+  0x447f3f, 0x4444, 0x4455, (1U<<31) | 97, 0x3f44, 0x3f55, 0x447f3f, 0x4444, 
+  0x4455, 0x4444, 0x4455, 0x447f3f, 0x4444, 0x4455, 0x447f3f, 0x4444, 
+  0x4455, (1U<<31) | 97, 0x3f44, 0x3f55, 0x447f3f, 0x4444, 0x4455, (1U<<31) | 7951, 
+  (1U<<31) | 2183, (1U<<31) | 2181, (1U<<31) | 7951, (1U<<31) | 2183, (1U<<31) | 2181, (1U<<31) | 7951, 0x7f7f3f, (1U<<31) | 7951, 
+  (1U<<31) | 1207, (1U<<31) | 1205, (1U<<31) | 7824, (1U<<31) | 7951, (1U<<31) | 7951, (1U<<31) | 5433, (1U<<31) | 7824, 0x47f7f3f, 
+  (1U<<31) | 8250, (1U<<31) | 5533, (1U<<31) | 5509, (1U<<31) | 5509, (1U<<31) | 8250, (1U<<31) | 7951, 0x47f7f3f, (1U<<31) | 8234, 
+  (1U<<31) | 8234, (1U<<31) | 8227, (1U<<31) | 8227, (1U<<31) | 8212, (1U<<31) | 8212, (1U<<31) | 7824, (1U<<31) | 7824, (1U<<31) | 7824, 
+  0x7f7f3f, 0x7f7f3f, 0x7f7f3f, 0x7f7f3f, 0xff9f3f, 0xff9f3f, 0xff9f3f, 0xff9f3f, 
+  0xff9f3f, 0xff9f3f, 0xff9f3f, 0xff9f3f, 0xffcf3f, 0xffcf3f, 0xffcf3f, 0xffcf3f, 
+  0xffcf3f, 0xffcf3f, 0xffcf3f, 0xffcf3f, (1U<<31) | 257, 0x47f7f3f, 0x7f7f3f, 0x7f7f3f, 
+  0x7f7f3f, 0x7f7f3f, 0x52e7f4f, 0x50, 0x0, 0x5, 0x5, 0x7f7f1f, 
+  0x4444, 0x4444, (1U<<31) | 167, (1U<<31) | 167, 0x11f, (1U<<31) | 135, (1U<<31) | 135, 0x1444a444, 
+  (1U<<31) | 135, (1U<<31) | 145, (1U<<31) | 135, (1U<<31) | 135, (1U<<31) | 135, (1U<<31) | 135, (1U<<31) | 135, (1U<<31) | 135, 
+  (1U<<31) | 135, (1U<<31) | 135, 0x11444a0f, 0x11444a2f, (1U<<31) | 26, (1U<<31) | 36, 0x0, 0x0, 
+  0x0, 0x42f1, 0x7f2f, 0x7777, 0x7777, 0x7777, 0x7777, 0x4439, 
+  0x4439, 0x4474, 0x7739, 0x7739, 0x7769, 0x5, (1U<<31) | 536, 0x7f7f7f2f, 
+  (1U<<31) | 187, (1U<<31) | 177, 0x14f4, 0x444, 0x14f4, (1U<<31) | 155, (1U<<31) | 155, (1U<<31) | 155, 
+  0x440, 0x440, 0x440, 0x40, 0x40, 0x40, (1U<<31) | 0, (1U<<31) | 0, 
+  0x444, 0x444, (1U<<31) | 8462, 0x1f0, 0x0, (1U<<31) | 56, (1U<<31) | 46, 0x4ffaf1f, 
+  0x777, 0x1769697, 0x7777, 0x7f7f7f2f, 0x7f7f7f2f, 0x777, 0x7f2f, 0xaf1f, 
+  0x7f2f, 0x44f4, (1U<<31) | 9244, 0x4, 0x4ff9f1f, (1U<<31) | 70, 0x7f11f, (1U<<31) | 4205, 
+  (1U<<31) | 4264, (1U<<31) | 4264, (1U<<31) | 4321, (1U<<31) | 4386, (1U<<31) | 4321, (1U<<31) | 4321, (1U<<31) | 4321, (1U<<31) | 4205, 
+  (1U<<31) | 4264, (1U<<31) | 4264, (1U<<31) | 4321, (1U<<31) | 4386, (1U<<31) | 4321, (1U<<31) | 4321, (1U<<31) | 4321, (1U<<31) | 4216, 
+  (1U<<31) | 4277, (1U<<31) | 4277, (1U<<31) | 4336, (1U<<31) | 4403, (1U<<31) | 4336, (1U<<31) | 4336, (1U<<31) | 4336, (1U<<31) | 4205, 
+  (1U<<31) | 4264, (1U<<31) | 4264, (1U<<31) | 4321, (1U<<31) | 4386, (1U<<31) | 4321, (1U<<31) | 4321, (1U<<31) | 4321, (1U<<31) | 4205, 
+  (1U<<31) | 4264, (1U<<31) | 4264, (1U<<31) | 4321, (1U<<31) | 4386, (1U<<31) | 4321, (1U<<31) | 4321, (1U<<31) | 4321, (1U<<31) | 4205, 
+  (1U<<31) | 4264, (1U<<31) | 4264, (1U<<31) | 4321, (1U<<31) | 4386, (1U<<31) | 4321, (1U<<31) | 4321, (1U<<31) | 4321, (1U<<31) | 4205, 
+  (1U<<31) | 4264, (1U<<31) | 4264, (1U<<31) | 4321, (1U<<31) | 4386, (1U<<31) | 4321, (1U<<31) | 4321, (1U<<31) | 4321, (1U<<31) | 4205, 
+  (1U<<31) | 4264, (1U<<31) | 4264, (1U<<31) | 4321, (1U<<31) | 4386, (1U<<31) | 4321, (1U<<31) | 4321, (1U<<31) | 4321, (1U<<31) | 4205, 
+  (1U<<31) | 4264, (1U<<31) | 4264, (1U<<31) | 4321, (1U<<31) | 4386, (1U<<31) | 4321, (1U<<31) | 4321, (1U<<31) | 4321, (1U<<31) | 4205, 
+  (1U<<31) | 4264, (1U<<31) | 4264, (1U<<31) | 4321, (1U<<31) | 4386, (1U<<31) | 4321, (1U<<31) | 4321, (1U<<31) | 4321, (1U<<31) | 4205, 
+  (1U<<31) | 4264, (1U<<31) | 4264, (1U<<31) | 4321, (1U<<31) | 4386, (1U<<31) | 4321, (1U<<31) | 4321, (1U<<31) | 4321, (1U<<31) | 4205, 
+  (1U<<31) | 4264, (1U<<31) | 4264, (1U<<31) | 4321, (1U<<31) | 4386, (1U<<31) | 4321, (1U<<31) | 4321, (1U<<31) | 4321, (1U<<31) | 4205, 
+  (1U<<31) | 4264, (1U<<31) | 4264, (1U<<31) | 4321, (1U<<31) | 4386, (1U<<31) | 4321, (1U<<31) | 4321, (1U<<31) | 4321, (1U<<31) | 6073, 
+  (1U<<31) | 2261, (1U<<31) | 2325, (1U<<31) | 2650, (1U<<31) | 2902, (1U<<31) | 2902, (1U<<31) | 3298, (1U<<31) | 3298, (1U<<31) | 2921, 
+  (1U<<31) | 3319, (1U<<31) | 3319, (1U<<31) | 2902, (1U<<31) | 2667, (1U<<31) | 2921, (1U<<31) | 2921, (1U<<31) | 2292, (1U<<31) | 2360, 
+  (1U<<31) | 2613, (1U<<31) | 2861, (1U<<31) | 2861, (1U<<31) | 3253, (1U<<31) | 3253, (1U<<31) | 2881, (1U<<31) | 3275, (1U<<31) | 3275, 
+  (1U<<31) | 2861, (1U<<31) | 2631, (1U<<31) | 2881, (1U<<31) | 2881, (1U<<31) | 2360, (1U<<31) | 2436, (1U<<31) | 2436, (1U<<31) | 2378, 
+  (1U<<31) | 2456, (1U<<31) | 2456, (1U<<31) | 2360, (1U<<31) | 2360, (1U<<31) | 2436, (1U<<31) | 2436, (1U<<31) | 2378, (1U<<31) | 2456, 
+  (1U<<31) | 2456, (1U<<31) | 2292, (1U<<31) | 2360, (1U<<31) | 2360, (1U<<31) | 2308, (1U<<31) | 2378, (1U<<31) | 2378, (1U<<31) | 2308, 
+  (1U<<31) | 2378, (1U<<31) | 2378, (1U<<31) | 2325, (1U<<31) | 2397, (1U<<31) | 2397, (1U<<31) | 2342, (1U<<31) | 2416, (1U<<31) | 2416, 
+  (1U<<31) | 2325, (1U<<31) | 2325, (1U<<31) | 2397, (1U<<31) | 2397, (1U<<31) | 2342, (1U<<31) | 2416, (1U<<31) | 2416, (1U<<31) | 2261, 
+  (1U<<31) | 2325, (1U<<31) | 2325, (1U<<31) | 2276, (1U<<31) | 2342, (1U<<31) | 2342, (1U<<31) | 2276, (1U<<31) | 2342, (1U<<31) | 2342, 
+  (1U<<31) | 2205, (1U<<31) | 2261, (1U<<31) | 2261, (1U<<31) | 2325, (1U<<31) | 2325, (1U<<31) | 2325, (1U<<31) | 4195, (1U<<31) | 4195, 
+  (1U<<31) | 4195, (1U<<31) | 4195, (1U<<31) | 4195, (1U<<31) | 4195, (1U<<31) | 4195, (1U<<31) | 4195, (1U<<31) | 4184, (1U<<31) | 4239, 
+  (1U<<31) | 4239, (1U<<31) | 4292, (1U<<31) | 4353, (1U<<31) | 4292, (1U<<31) | 4292, (1U<<31) | 4292, (1U<<31) | 4239, (1U<<31) | 4292, 
+  (1U<<31) | 4292, (1U<<31) | 4353, (1U<<31) | 4353, (1U<<31) | 4353, (1U<<31) | 4184, (1U<<31) | 4239, (1U<<31) | 4239, (1U<<31) | 4292, 
+  (1U<<31) | 4353, (1U<<31) | 4292, (1U<<31) | 4292, (1U<<31) | 4292, (1U<<31) | 2205, (1U<<31) | 2261, (1U<<31) | 2261, (1U<<31) | 2325, 
+  (1U<<31) | 2325, (1U<<31) | 2510, (1U<<31) | 2650, (1U<<31) | 2650, (1U<<31) | 2902, (1U<<31) | 2902, (1U<<31) | 2650, (1U<<31) | 2902, 
+  (1U<<31) | 2902, (1U<<31) | 3298, (1U<<31) | 3298, (1U<<31) | 3298, (1U<<31) | 2667, (1U<<31) | 2921, (1U<<31) | 2921, (1U<<31) | 3319, 
+  (1U<<31) | 3319, (1U<<31) | 3319, (1U<<31) | 2902, (1U<<31) | 2525, (1U<<31) | 2667, (1U<<31) | 2667, (1U<<31) | 2921, (1U<<31) | 2921, 
+  (1U<<31) | 2921, (1U<<31) | 2232, (1U<<31) | 2292, (1U<<31) | 2292, (1U<<31) | 2360, (1U<<31) | 2360, (1U<<31) | 2477, (1U<<31) | 2613, 
+  (1U<<31) | 2613, (1U<<31) | 2861, (1U<<31) | 2861, (1U<<31) | 2613, (1U<<31) | 2861, (1U<<31) | 2861, (1U<<31) | 3253, (1U<<31) | 3253, 
+  (1U<<31) | 3253, (1U<<31) | 2631, (1U<<31) | 2881, (1U<<31) | 2881, (1U<<31) | 3275, (1U<<31) | 3275, (1U<<31) | 3275, (1U<<31) | 2861, 
+  (1U<<31) | 2493, (1U<<31) | 2631, (1U<<31) | 2631, (1U<<31) | 2881, (1U<<31) | 2881, (1U<<31) | 2881, (1U<<31) | 2576, (1U<<31) | 2724, 
+  (1U<<31) | 2812, (1U<<31) | 3080, (1U<<31) | 3192, (1U<<31) | 2724, (1U<<31) | 2984, (1U<<31) | 3080, (1U<<31) | 3396, (1U<<31) | 3516, 
+  (1U<<31) | 3396, (1U<<31) | 2744, (1U<<31) | 3006, (1U<<31) | 3106, (1U<<31) | 3424, (1U<<31) | 3548, (1U<<31) | 3424, (1U<<31) | 3080, 
+  (1U<<31) | 2594, (1U<<31) | 2744, (1U<<31) | 2836, (1U<<31) | 3106, (1U<<31) | 3222, (1U<<31) | 3106, (1U<<31) | 2292, (1U<<31) | 2360, 
+  (1U<<31) | 2360, (1U<<31) | 2436, (1U<<31) | 2436, (1U<<31) | 2436, (1U<<31) | 2308, (1U<<31) | 2378, (1U<<31) | 2378, (1U<<31) | 2456, 
+  (1U<<31) | 2456, (1U<<31) | 2456, (1U<<31) | 2360, (1U<<31) | 2576, (1U<<31) | 2724, (1U<<31) | 2812, (1U<<31) | 3080, (1U<<31) | 3192, 
+  (1U<<31) | 2724, (1U<<31) | 2984, (1U<<31) | 3080, (1U<<31) | 3396, (1U<<31) | 3516, (1U<<31) | 3396, (1U<<31) | 2744, (1U<<31) | 3006, 
+  (1U<<31) | 3106, (1U<<31) | 3424, (1U<<31) | 3548, (1U<<31) | 3424, (1U<<31) | 3080, (1U<<31) | 2594, (1U<<31) | 2744, (1U<<31) | 2836, 
+  (1U<<31) | 3106, (1U<<31) | 3222, (1U<<31) | 3106, (1U<<31) | 2292, (1U<<31) | 2360, (1U<<31) | 2360, (1U<<31) | 2436, (1U<<31) | 2436, 
+  (1U<<31) | 2436, (1U<<31) | 2308, (1U<<31) | 2378, (1U<<31) | 2378, (1U<<31) | 2456, (1U<<31) | 2456, (1U<<31) | 2456, (1U<<31) | 2232, 
+  (1U<<31) | 2292, (1U<<31) | 2292, (1U<<31) | 2360, (1U<<31) | 2360, (1U<<31) | 2360, (1U<<31) | 2246, (1U<<31) | 2308, (1U<<31) | 2308, 
+  (1U<<31) | 2378, (1U<<31) | 2378, (1U<<31) | 2378, (1U<<31) | 2246, (1U<<31) | 2308, (1U<<31) | 2308, (1U<<31) | 2378, (1U<<31) | 2378, 
+  (1U<<31) | 2378, (1U<<31) | 2541, (1U<<31) | 2685, (1U<<31) | 2765, (1U<<31) | 3029, (1U<<31) | 3133, (1U<<31) | 2685, (1U<<31) | 2941, 
+  (1U<<31) | 3029, (1U<<31) | 3341, (1U<<31) | 3453, (1U<<31) | 3341, (1U<<31) | 2704, (1U<<31) | 2962, (1U<<31) | 3054, (1U<<31) | 3368, 
+  (1U<<31) | 3484, (1U<<31) | 3368, (1U<<31) | 3029, (1U<<31) | 2558, (1U<<31) | 2704, (1U<<31) | 2788, (1U<<31) | 3054, (1U<<31) | 3162, 
+  (1U<<31) | 3054, (1U<<31) | 2261, (1U<<31) | 2325, (1U<<31) | 2325, (1U<<31) | 2397, (1U<<31) | 2397, (1U<<31) | 2397, (1U<<31) | 2276, 
+  (1U<<31) | 2342, (1U<<31) | 2342, (1U<<31) | 2416, (1U<<31) | 2416, (1U<<31) | 2416, (1U<<31) | 2325, (1U<<31) | 2541, (1U<<31) | 2685, 
+  (1U<<31) | 2765, (1U<<31) | 3029, (1U<<31) | 3133, (1U<<31) | 2685, (1U<<31) | 2941, (1U<<31) | 3029, (1U<<31) | 3341, (1U<<31) | 3453, 
+  (1U<<31) | 3341, (1U<<31) | 2704, (1U<<31) | 2962, (1U<<31) | 3054, (1U<<31) | 3368, (1U<<31) | 3484, (1U<<31) | 3368, (1U<<31) | 3029, 
+  (1U<<31) | 2558, (1U<<31) | 2704, (1U<<31) | 2788, (1U<<31) | 3054, (1U<<31) | 3162, (1U<<31) | 3054, (1U<<31) | 2261, (1U<<31) | 2325, 
+  (1U<<31) | 2325, (1U<<31) | 2397, (1U<<31) | 2397, (1U<<31) | 2397, (1U<<31) | 2276, (1U<<31) | 2342, (1U<<31) | 2342, (1U<<31) | 2416, 
+  (1U<<31) | 2416, (1U<<31) | 2416, (1U<<31) | 2205, (1U<<31) | 2261, (1U<<31) | 2261, (1U<<31) | 2325, (1U<<31) | 2325, (1U<<31) | 2325, 
+  (1U<<31) | 2218, (1U<<31) | 2276, (1U<<31) | 2276, (1U<<31) | 2342, (1U<<31) | 2342, (1U<<31) | 2342, (1U<<31) | 2218, (1U<<31) | 2276, 
+  (1U<<31) | 2276, (1U<<31) | 2342, (1U<<31) | 2342, (1U<<31) | 2342, (1U<<31) | 4194, (1U<<31) | 4251, (1U<<31) | 4251, (1U<<31) | 4306, 
+  (1U<<31) | 4369, (1U<<31) | 4306, (1U<<31) | 4306, (1U<<31) | 4306, (1U<<31) | 4251, (1U<<31) | 4306, (1U<<31) | 4306, (1U<<31) | 4369, 
+  (1U<<31) | 4369, (1U<<31) | 4369, (1U<<31) | 536, (1U<<31) | 536, 0x50, 0x440, 0x44447, 0x44477, 
+  0x414477, 0x444777, 0x4144776, 0x2e1, 0x2e1, (1U<<31) | 536, 0x10, 0x47f2f, 
+  0x4444, 0x7f2f, 0x1f1, 0x444, 0x444, (1U<<31) | 4082, (1U<<31) | 4128, (1U<<31) | 4104, 
+  (1U<<31) | 4116, (1U<<31) | 4094, (1U<<31) | 4070, (1U<<31) | 4162, (1U<<31) | 4138, (1U<<31) | 4128, (1U<<31) | 4104, (1U<<31) | 4150, 
+  (1U<<31) | 4116, (1U<<31) | 4094, (1U<<31) | 4070, (1U<<31) | 4082, (1U<<31) | 3926, (1U<<31) | 3968, (1U<<31) | 3978, (1U<<31) | 3968, 
+  (1U<<31) | 3926, 0x14447f1f, 0x47f1f, 0x5455, 0x4a454a, 0x4444, 0x444, 0x444, 
+  0x1144444, 0x1144444, 0x1, 0x5455, (1U<<31) | 536, (1U<<31) | 3936, (1U<<31) | 3936, (1U<<31) | 3956, 
+  (1U<<31) | 3936, (1U<<31) | 3946, (1U<<31) | 3936, (1U<<31) | 3936, (1U<<31) | 3936, (1U<<31) | 3936, (1U<<31) | 3936, (1U<<31) | 3936, 
+  (1U<<31) | 3936, (1U<<31) | 3936, (1U<<31) | 3936, 0x4444a0f, 0x4444a2f, 0x4444a0f0, 0x4444a2f0, 0x44444a0f, 
+  (1U<<31) | 3874, 0x7f2f, 0x77, 0x44, 0x444, (1U<<31) | 9269, 0x7f2f, 0x7f2f, 
   0x77, 0x0, 0x444a0f, 0x0, 0x0, 0x0, 0x0, 0x40, 
   0x4, 0x5, 0x44, 0x40, 0x5, 0x5, 0x440, 0x440, 
-  0x40, 0x40, 0x4444, 0x4444, 0x4444, 0x447f1f, 0x1439394, 0x14444, 
-  0x14444, 0x7f7f1f, 0x7f1f, 0x7f2f, (1U<<31) | 3249, (1U<<31) | 3249, (1U<<31) | 3260, (1U<<31) | 3249, 
-  (1U<<31) | 3249, (1U<<31) | 3249, (1U<<31) | 3249, (1U<<31) | 3249, (1U<<31) | 3249, (1U<<31) | 3249, (1U<<31) | 3249, 0x44444a0f, 
-  0x44444a0f, (1U<<31) | 3239, (1U<<31) | 3239, (1U<<31) | 3221, (1U<<31) | 3220, (1U<<31) | 13, (1U<<31) | 12, 0x47f2f, 
-  0x447f1f, 0x1439394, 0x14444, 0x14444, 0x0, (1U<<31) | 106, 0x0, 0x4, 
-  0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x7f0f, 0x11, 
-  0x4444, 0x7f0f, 0x4444440, 0x4444440, 0x0, 0x2e4, 0x2e4, 0x2e4, 
-  0x2e4, 0x444, 0x444, 0x444, 0x444, 0x444, 0x444, 0x40, 
-  0x40, 0x40, 0x4, 0x0, 0x40, 0x40, 0x4f4, (1U<<31) | 731, 
-  0x2e440, 0x2e440, 0x2e440, 0x2e440, 0x4f4, (1U<<31) | 731, 0x4444440, 0x4444440, 
-  0x444440, 0x444440, 0x444444, 0x444444, (1U<<31) | 3273, (1U<<31) | 3273, 0x2c2c2c, 0x2c2c2c, 
-  0x2c2c, 0x2c2c, (1U<<31) | 6437, 0x4a44a4a, 0x44, 0x4a44a4a, 0x4a44a4a, 0x4a4a4a4a, 
-  0x4a4a4a, 0x4a4a4a4a, 0x4a4a4a4a, 0x4a4a4a, 0x4a4a4a4a, (1U<<31) | 6437, 0x7f7f3f, 0x7f7f3f, 
-  0x7f3f, 0xffbf3f, 0xffbf3f, 0x7f7f7f3f, 0x7f3f, 0xbf3f, 0xbf3f, 0x4af1f, 
-  0x4af1f, 0x7a3a, 0x49f2f, 0x49f2f, 0x3a7a, 0xbf3f, 0xbf3f, 0xbf3f, 
-  0xbf3f, 0xbf3f, 0xbf3f, 0x7f7f3f, 0x7f7f3f, 0x7f7f3f, 0x7f7f3f, 0x4cf3f, 
-  (1U<<31) | 6385, (1U<<31) | 6403, (1U<<31) | 6425, (1U<<31) | 4926, (1U<<31) | 4926, (1U<<31) | 3855, (1U<<31) | 4935, (1U<<31) | 4935, 
-  (1U<<31) | 3837, (1U<<31) | 4946, (1U<<31) | 4946, (1U<<31) | 3815, 0x7f7f3f, 0x7f7f3f, 0x7f7f3f, 0x7f7f3f, 
-  0x7f7f3f, 0x7f7f3f, (1U<<31) | 6199, (1U<<31) | 6199, (1U<<31) | 6199, 0x7f7f3f, 0xbf7f3f, 0xbf7f3f, 
-  0x7f7f3f, 0xbf3f, 0xbf3f, 0x7f7f3f, 0x7f7f3f, 0x7f7f3f, 0x7f7f3f, 0x7f3f, 
-  0x7f7f3f, 0x7f7f3f, 0x7f7f3f, (1U<<31) | 6199, (1U<<31) | 6182, (1U<<31) | 6182, (1U<<31) | 6182, 0x7f3f, 
-  0x7f7f3f, (1U<<31) | 6187, (1U<<31) | 6187, (1U<<31) | 6187, 0x7f7f3f, 0x7f7f3f, (1U<<31) | 6187, (1U<<31) | 6187, 
-  (1U<<31) | 6187, 0x7f7f3f, 0x7f7f3f, 0x7f7f3f, 0x7f7f3f, 0x7f7f3f, (1U<<31) | 6187, 0x7f3f, 
-  0x7f7f3f, 0x7f7f3f, 0x7f7f3f, 0x7f3f, 0x7f3f, 0x7f2f, 0x7f3f, 0x7f3f, 
-  0x7f3f, (1U<<31) | 6187, 0x7f7f3f, 0x7f7f3f, 0x7f3f, 0x7f7f3f, (1U<<31) | 6187, 0x7f7f7f3f, 
-  0x7f7f3f, 0x7f7f3f, 0x4bf4f0, 0xffbf4f0, (1U<<31) | 6446, (1U<<31) | 6456, 0x4ffbf4f0, (1U<<31) | 4179, 
-  (1U<<31) | 5142, (1U<<31) | 4189, (1U<<31) | 5153, (1U<<31) | 4201, 0x2b2b2b, 0x2b2b2b2b, (1U<<31) | 643, (1U<<31) | 641, 
-  0x2b2b2b2b, (1U<<31) | 643, (1U<<31) | 641, (1U<<31) | 639, 0x444, 0x444, 0x444, 0x444, 
+  0x440, 0x40, 0x40, 0x4444, 0x4444, 0x4444, 0x447f1f, 0x1439394, 
+  0x14444, 0x14444, 0x7f7f1f, 0x7f1f, 0x7f2f, 0x7f0f, 0x7f2f, (1U<<31) | 3884, 
+  (1U<<31) | 3884, (1U<<31) | 3906, (1U<<31) | 3884, (1U<<31) | 3895, (1U<<31) | 3884, (1U<<31) | 3884, (1U<<31) | 3884, (1U<<31) | 3884, 
+  (1U<<31) | 3884, (1U<<31) | 3884, (1U<<31) | 3884, (1U<<31) | 3884, (1U<<31) | 3884, 0x44444a0f, 0x44444a0f, (1U<<31) | 3874, 
+  (1U<<31) | 3874, (1U<<31) | 3843, (1U<<31) | 3842, (1U<<31) | 13, (1U<<31) | 12, 0x47f2f, 0x447f1f, 0x1439394, 
+  0x14444, 0x14444, 0x0, (1U<<31) | 124, 0x0, 0x4, 0x4, 0x4, 
+  0x4, 0x4, 0x4, 0x4, 0x7f0f, 0x11, 0x4444, 0x7f0f, 
+  0x444, 0x4444, (1U<<31) | 3988, (1U<<31) | 3866, 0x4444, 0x44444, (1U<<31) | 3919, (1U<<31) | 3833, 
+  0x44444, 0x444444, (1U<<31) | 3866, (1U<<31) | 3813, 0x442f, 0x47f42f, 0x442c, (1U<<31) | 8640, 
+  0x42c42c, (1U<<31) | 8640, 0x47f42f, 0x47f7f42f, 0x42c42c, (1U<<31) | 8570, 0x42c2c42c, (1U<<31) | 8570, 
+  0x47f7f42f, (1U<<31) | 5486, 0x42c2c42c, (1U<<31) | 8557, (1U<<31) | 2009, (1U<<31) | 8557, 0x4444440, 0x4444440, 
+  0x0, 0x44, 0x54, 0x2e4, 0x2e4, 0x2e4, 0x2e4, 0x444, 
+  0x444, 0x444, 0x444, 0x444, 0x444, 0x40, 0x40, 0x40, 
+  0x4, 0x0, 0x40, 0x40, 0x4f4, (1U<<31) | 1011, 0x2e440, 0x2e440, 
+  0x2e440, 0x2e440, 0x4f4, (1U<<31) | 1011, 0x4444440, 0x4444440, 0x444440, 0x444440, 
+  0x444444, 0x444444, (1U<<31) | 3919, (1U<<31) | 3919, (1U<<31) | 8004, 0x7fbf7f3f, (1U<<31) | 8016, 0x43f5, 
+  0xbf43f5, 0x43f4, 0xbf43f4, (1U<<31) | 8016, (1U<<31) | 3919, (1U<<31) | 8016, 0x7fbf7f3f, 0x7fbf7f3f, 
+  (1U<<31) | 8016, (1U<<31) | 8697, (1U<<31) | 8004, (1U<<31) | 8004, (1U<<31) | 3919, (1U<<31) | 8004, 0x3f44, 0xbf3f44, 
+  0xbf7f2f, (1U<<31) | 9384, 0xbf7f2f, (1U<<31) | 9384, 0x43f44, 0xbf43f44, (1U<<31) | 8004, 0x3f44, 
+  0xbf3f44, 0xbf7f2f, (1U<<31) | 9384, 0xbf7f2f, (1U<<31) | 9384, 0x43f44, 0xbf43f44, (1U<<31) | 8016, 
+  (1U<<31) | 8004, (1U<<31) | 8064, (1U<<31) | 8087, 0x7fbf7f3f, 0x7fbf7f3f, (1U<<31) | 8016, (1U<<31) | 8016, 0x43f, 
+  0x3f4, 0x7fbf7f3f, (1U<<31) | 8004, (1U<<31) | 8016, 0x7fbf7f3f, (1U<<31) | 8016, (1U<<31) | 8004, (1U<<31) | 8004, 
+  (1U<<31) | 8004, (1U<<31) | 7994, (1U<<31) | 7983, 0x444, (1U<<31) | 3866, 0x444, (1U<<31) | 3919, 0x444, 
+  (1U<<31) | 3919, (1U<<31) | 8016, 0x444, (1U<<31) | 3866, 0x444, (1U<<31) | 3919, 0x444, (1U<<31) | 3919, 
+  0x7f3f444, (1U<<31) | 8678, 0x47f7f3f, (1U<<31) | 5453, (1U<<31) | 8659, 0x47f3f, (1U<<31) | 8649, 0x7f7f443f, 
+  (1U<<31) | 8720, 0x7f3f, (1U<<31) | 7973, (1U<<31) | 8708, 0x7f7f43f, (1U<<31) | 8708, 0x41b, 0x41a, 
+  0x41a, 0x41c, 0x4bf43f, (1U<<31) | 9343, (1U<<31) | 8077, 0x47a6b6b, (1U<<31) | 217, 0x46b7a, 
+  (1U<<31) | 207, 0xbf43f, (1U<<31) | 9393, 0xbf43f, (1U<<31) | 9393, 0xbf43f, (1U<<31) | 9393, 0xbf43f, 
+  (1U<<31) | 9393, (1U<<31) | 3669, (1U<<31) | 8629, (1U<<31) | 3684, (1U<<31) | 8592, 0x47f7f3f, 0x47f7f3f, (1U<<31) | 3669, 
+  (1U<<31) | 8629, (1U<<31) | 3684, (1U<<31) | 8592, (1U<<31) | 8847, (1U<<31) | 8887, 0x4bf3f, (1U<<31) | 9325, (1U<<31) | 6431, 
+  (1U<<31) | 9354, (1U<<31) | 4441, (1U<<31) | 9515, (1U<<31) | 8688, (1U<<31) | 8688, (1U<<31) | 8688, (1U<<31) | 8688, (1U<<31) | 8649, 
+  (1U<<31) | 8649, (1U<<31) | 7921, (1U<<31) | 8676, (1U<<31) | 7918, (1U<<31) | 8673, (1U<<31) | 8053, (1U<<31) | 9333, 0x47f7f3f, 
+  0x44ffbf3f, 0x4ffbf3f, (1U<<31) | 4172, (1U<<31) | 8604, 0x47f7f3f, (1U<<31) | 8649, 0x47f7f3f, (1U<<31) | 8649, 
+  0x7f7f3f, 0x4ffbf3f, (1U<<31) | 8087, (1U<<31) | 4229, (1U<<31) | 9313, 0x47f7f3f, (1U<<31) | 8649, 0x47f7f3f, 
+  (1U<<31) | 8649, 0x7f7f3f, 0x447f3f, (1U<<31) | 7983, 0x47f3f, (1U<<31) | 7994, 0xbf3f, (1U<<31) | 7994, 
+  0x47f7f3f, 0x7fbf7f3f, 0x7fbf7f3f, 0x7f3f, 0x7fbf7f3f, 0x7fbf7f3f, 0x7fbf7f3f, 0x7fbf7f3f, 
+  (1U<<31) | 7918, (1U<<31) | 8673, 0x47f7f3f, 0x447f3f, (1U<<31) | 7983, (1U<<31) | 5453, (1U<<31) | 8659, 0x44447f3f, 
+  (1U<<31) | 8581, (1U<<31) | 4229, (1U<<31) | 8039, (1U<<31) | 4534, (1U<<31) | 8618, 0x444bf3f, (1U<<31) | 8027, (1U<<31) | 3853, 
+  (1U<<31) | 9298, 0x47f7f3f, (1U<<31) | 8649, 0x47f7f3f, (1U<<31) | 8649, 0x4ffbf4f0, (1U<<31) | 6451, 0xbf43f0, 
+  (1U<<31) | 9365, 0xbf47f3f, (1U<<31) | 9374, (1U<<31) | 4997, (1U<<31) | 9527, 0x2c2c2c, 0x2c2c2c, 0x2c2c, 
+  0x2c2c, (1U<<31) | 8964, (1U<<31) | 9649, (1U<<31) | 9649, (1U<<31) | 9649, (1U<<31) | 8964, 0x4a44a4a, 0x44, 
+  0x4a44a4a, 0x4a44a4a, 0x4a4a4a4a, 0x4a4a4a, 0x4a4a4a4a, 0x4a4a4a4a, 0x4a4a4a, 0x4a4a4a4a, 
+  (1U<<31) | 8964, (1U<<31) | 8964, (1U<<31) | 8964, (1U<<31) | 8964, (1U<<31) | 8964, 0x7f7f3f, 0x7f7f3f, 0x7f3f, 
+  0xffbf3f, 0xffbf3f, 0x7f7f7f3f, 0x7f7f3f, 0x7f7f3f, 0x7f3f, 0xbf3f, 0xbf3f, 
+  (1U<<31) | 8290, 0x7a3f, 0x4af1f, 0x4af1f, 0x7a3a, 0x49f2f, 0x49f2f, 0x3a7a, 
+  0xbf3f, 0xbf3f, 0xbf3f, 0xbf3f, 0xbf3f, 0xbf3f, 0x7f7f3f, 0x7f7f3f, 
+  0x7f7f3f, 0x7f7f3f, 0x4cf3f, (1U<<31) | 8847, (1U<<31) | 8865, (1U<<31) | 8887, (1U<<31) | 6215, (1U<<31) | 6215, 
+  (1U<<31) | 4594, (1U<<31) | 6224, (1U<<31) | 6224, (1U<<31) | 4576, (1U<<31) | 6235, (1U<<31) | 6235, (1U<<31) | 4554, 0x7f7f3f, 
+  0x7f7f3f, 0x7f7f3f, 0x7f7f3f, 0x7f7f3f, 0x7f7f3f, (1U<<31) | 8121, (1U<<31) | 8121, (1U<<31) | 8121, 
+  0x7f7f3f, 0xbf7f3f, 0xbf7f3f, 0x7f7f3f, 0xbf3f, 0xbf3f, 0x7f7f3f, 0x7f7f3f, 
+  0x7f7f3f, 0x7f7f3f, 0x7f3f, 0x7f7f3f, (1U<<31) | 8121, (1U<<31) | 8104, (1U<<31) | 8104, (1U<<31) | 8104, 
+  0x7f3f, 0x7f7f3f, (1U<<31) | 8109, (1U<<31) | 8109, (1U<<31) | 8109, 0x7f7f3f, 0x7f7f3f, (1U<<31) | 8109, 
+  (1U<<31) | 8109, (1U<<31) | 8109, 0x7f7f3f, 0x7f7f3f, 0x7f7f3f, (1U<<31) | 8109, 0x7f3f, 0x7f7f3f, 
+  0x7f7f3f, 0x7f7f3f, 0x7f3f, 0x7f3f, 0x7f2f, 0x7f3f, 0x7f3f, 0x7f3f, 
+  (1U<<31) | 8109, 0x7f7f3f, 0x7f7f3f, 0x7f3f, 0x7f7f3f, (1U<<31) | 8109, 0x7f7f7f3f, 0x7f7f3f, 
+  0x7f7f3f, 0x4bf4f0, 0xffbf4f0, (1U<<31) | 8982, (1U<<31) | 9003, 0x4ffbf4f0, (1U<<31) | 4934, (1U<<31) | 6440, 
+  (1U<<31) | 4944, (1U<<31) | 6451, (1U<<31) | 4956, 0x2b2b2b, 0x2b2b2b2b, (1U<<31) | 796, (1U<<31) | 794, 0x2b2b2b2b, 
+  (1U<<31) | 796, (1U<<31) | 794, (1U<<31) | 792, 0x444, 0x444, 0x444, 0x444, 0x444, 
+  0x444, 0x444, 0x444, 0x444, 0x444, 0x444, 0x444, 0x40, 
+  0x444, 0x444, 0x444, 0x444, 0x444, 0x444, 0x4444, 0x4444, 
+  0x4444, 0x4444, 0x5445, 0x5445, 0x4444, 0x4444, 0x4444, 0x4444, 
+  0x4444, 0x4444, 0x5445, 0x5445, 0x444, 0x444, 0x444, 0x444, 
   0x444, 0x444, 0x444, 0x444, 0x444, 0x444, 0x444, 0x444, 
-  0x40, 0x444, 0x444, 0x444, 0x444, 0x444, 0x444, 0x4444, 
-  0x4444, 0x4444, 0x4444, 0x5445, 0x5445, 0x4444, 0x4444, 0x4444, 
-  0x4444, 0x4444, 0x4444, 0x5445, 0x5445, 0x444, 0x444, 0x444, 
+  0x444, 0x444, 0x444, 0x444, 0x2e440, 0x2e440, 0x2e440, 0x2e440, 
+  0x4f44, 0x2e444, 0x4f44, 0x2e444, 0x444, 0x44, 0x444, 0x444, 
+  0x444, 0x444, 0x444, 0x444, 0x444, 0x444, 0x444, 0x40, 
+  0x444, 0x444, 0x444, 0x444, 0x444, 0x444, 0x444, 0x4444, 
+  0x444, 0x444, 0x444, 0x444, 0x444, 0x444, 0x44, 0x2f7, 
+  0x2f7, 0x545, 0x52e5, 0x52e5, 0x52e5, 0x8f40f, 0x52e45, 0x54f4, 
+  0x544, 0x555, 0x44, 0x55, 0x44, 0x444, 0x444, 0x444, 
   0x444, 0x444, 0x444, 0x444, 0x444, 0x444, 0x444, 0x444, 
-  0x444, 0x444, 0x444, 0x444, 0x444, 0x2e440, 0x2e440, 0x2e440, 
-  0x2e440, 0x4f44, 0x2e444, 0x4f44, 0x2e444, 0x444, 0x44, 0x444, 
+  0x444, 0x444, 0x444, 0x555, 0x555, 0x444, 0x545, 0x444, 
+  0x444, 0x555, 0x44, 0x44, 0x444, 0x444, 0x444, 0x444, 
+  0x445, 0x445, 0x444, 0x555, 0x444, 0x555, 0x444, 0x555, 
+  0x444, 0x555, 0x44, 0x55, 0x44, 0x44, 0x55, 0x444, 
+  0x444, 0x555, 0x54, 0x54, 0x44, 0x44, 0x44, 0x44, 
   0x444, 0x444, 0x444, 0x444, 0x444, 0x444, 0x444, 0x444, 
-  0x40, 0x444, 0x444, 0x444, 0x444, 0x444, 0x444, 0x444, 
-  0x4444, 0x444, 0x444, 0x444, 0x444, 0x444, 0x444, 0x44, 
-  0x2f7, 0x2f7, 0x52e5, 0x52e5, 0x52e5, 0x555, 0x44, 0x55, 
-  0x44, 0x444, 0x444, 0x444, 0x444, 0x444, 0x444, 0x444, 
-  0x444, 0x444, 0x444, 0x444, 0x444, 0x444, 0x444, 0x555, 
-  0x555, 0x444, 0x545, 0x444, 0x444, 0x555, 0x44, 0x44, 
-  0x444, 0x444, 0x444, 0x444, 0x445, 0x445, 0x444, 0x555, 
-  0x444, 0x555, 0x444, 0x555, 0x444, 0x555, 0x44, 0x55, 
-  0x44, 0x44, 0x55, 0x444, 0x444, 0x555, 0x4444, 0x54, 
-  0x54, 0x44, 0x44, 0x44, 0x44, 0x444, 0x444, 0x444, 
+  0x444, 0x444, 0x444, 0x444, 0x444, 0x555, 0x444, 0x444, 
   0x444, 0x444, 0x444, 0x444, 0x444, 0x444, 0x444, 0x444, 
-  0x444, 0x444, 0x555, 0x444, 0x444, 0x444, 0x444, 0x444, 
-  0x444, 0x444, 0x444, 0x444, 0x444, 0x444, 0x44, 0x44, 
-  0x44, 0x45, 0x44, 0x44, 0x444, 0x444, 0x55, 0x45, 
-  0x44, 0x44, 0x55, 0x55, 0x55, 0x55, 0x555, 0x555, 
+  0x444, 0x44, 0x44, 0x44, 0x45, 0x44, 0x444, 0x444, 
+  0x55, 0x45, 0x44, 0x55, 0x55, 0x55, 0x55, 0x555, 
   0x555, 0x555, 0x555, 0x555, 0x555, 0x555, 0x555, 0x555, 
   0x555, 0x555, 0x555, 0x555, 0x555, 0x555, 0x555, 0x555, 
-  0x555, 0x555, 0x554, 0x554, 0x554, 0x554, 0x554, 0x554, 
-  0x554, 0x554, 0x55, 0x555, 0x555, 0x555, 0x555, 0x555, 
+  0x555, 0x555, 0x555, 0x554, 0x554, 0x554, 0x554, 0x554, 
+  0x554, 0x554, 0x554, 0x55, 0x555, 0x555, 0x555, 0x555, 
   0x555, 0x555, 0x555, 0x555, 0x555, 0x555, 0x555, 0x555, 
-  0x555, 0x555, 0x555, 0x555, 0x555, 0x555, 0x5555, 0x555, 
-  0x5555, 0x555, 0x555, 0x555, 0x555, 0x555, 0x555, 0x555, 
-  0x555, 0x444, 0x555, 0x44, 0x44, (1U<<31) | 4283, 0x444, 0x555, 
+  0x555, 0x555, 0x555, 0x555, 0x555, 0x555, 0x555, 0x5555, 
+  0x555, 0x5555, 0x555, 0x555, 0x555, 0x555, 0x555, 0x555, 
+  0x555, 0x555, 0x444, 0x555, 0x44, 0x44, 0x444, 0x555, 
   0x445, 0x445, 0x544, 0x444, 0x444, 0x444, 0x444, 0x444, 
   0x444, 0x444, 0x444, 0x444, 0x444, 0x444, 0x444, 0x445, 
-  0x445, 0x445, 0x444, 0x444, 0x444, 0x444, 0x555, 0x444, 
-  0x444, 0x444, 0x444, 0x444, 0x444, 0x444, 0x444, (1U<<31) | 4283, 
-  0x55, 0x55, 0x454, 0x554, 0x454, 0x554, 0x454, 0x454, 
-  0x454, 0x454, 0x454, 0x454, 0x454, 0x454, 0x4555, 0x4555, 
-  0x4555, 0x4555, 0x4555, 0x4555, 0x4555, 0x4555, (1U<<31) | 5249, 0x554, 
-  0x554, (1U<<31) | 5243, 0x44, 0x444, 0x444, 0x44, 0x444, 0x444, 
-  0x444, 0x444, 0x444, 0x554, 0x444, 0x444, 0x444, 0x444, 
-  0x554, 0x444, 0x444, 0x554, 0x444, 0x444, 0x45, 0x4444, 
-  0x4444, 0x4444, 0x4444, 0x44, 0x444, 0x444, 0x44, 0x44, 
-  0x44, 0x444, 0x5545, 0x444, 0x4444, 0x4444, 0x4444, 0x4444, 
+  0x445, 0x444, 0x444, 0x444, 0x444, 0x555, 0x444, 0x444, 
+  0x444, 0x444, 0x444, 0x444, 0x444, 0x444, 0x454, 0x554, 
+  0x454, 0x554, 0x454, 0x454, 0x454, 0x454, 0x454, 0x454, 
+  0x454, 0x454, 0x4555, 0x4555, 0x4555, 0x4555, 0x4555, 0x4555, 
+  0x4555, 0x4555, 0x554, 0x554, 0x444, 0x455, 0x455, 0x455, 
+  0x44, 0x444, 0x444, 0x44, 0x444, 0x444, 0x444, 0x444, 
+  0x444, 0x554, 0x444, 0x444, 0x444, 0x444, 0x554, 0x444, 
+  0x444, 0x554, 0x444, 0x444, 0x45, 0x4444, 0x4444, 0x4444, 
+  0x4444, 0x44, 0x444, 0x444, 0x44, 0x44, 0x44, 0x444, 
+  0x5545, 0x444, 0x4444, 0x4444, 0x4444, 0x4444, 0x444, 0x444, 
   0x444, 0x444, 0x444, 0x444, 0x444, 0x444, 0x444, 0x444, 
-  0x444, 0x444, 0x444, 0x4444, 0x4444, 0x4444, 0x4444, 0x58, 
-  0x57, 0x85, 0x85, 0x87, 0x85, 0x85, 0x84, 0x84, 
-  0x84, 0x84, 0x75, 0x75, 0x78, 0x75, 0x75, 0x74, 
-  0x74, 0x74, 0x74, 0x58, 0x57, 0x48, 0x47, 0x48, 
-  0x47, 0x888, 0x484, 0x884, 0x884, 0x884, 0x884, 0x48, 
-  0x48, 0x888, 0x777, 0x474, 0x774, 0x774, 0x774, 0x774, 
-  0x777, 0x777, 0x77, 0x7777, 0x7777, 0x47777, 0x7777, 0x7777, 
-  0x47, 0x47, (1U<<31) | 5458, 0x777, 0x777, 0x777, (1U<<31) | 5539, 0x777, 
-  (1U<<31) | 1562, (1U<<31) | 699, (1U<<31) | 679, (1U<<31) | 1570, (1U<<31) | 710, (1U<<31) | 689, (1U<<31) | 1562, (1U<<31) | 699, 
-  (1U<<31) | 679, (1U<<31) | 1562, (1U<<31) | 699, (1U<<31) | 679, (1U<<31) | 1562, (1U<<31) | 699, (1U<<31) | 679, (1U<<31) | 1562, 
-  (1U<<31) | 699, (1U<<31) | 679, 0x4e4, 0x5e5, 0x4444, 0x4444, 0x4455, 0x4455, 
-  0x4455, 0x4455, 0x4455, 0x4455, 0x445, 0x445, 0x444, 0x444, 
-  0x444, 0x444, 0x445, 0x445, 0x445, 0x445, 0x4455, 0x4455, 
-  0x4455, 0x4455, 0x4455, 0x4455, 0x444, 0x445, 0x4455, 0x4455, 
-  0x445, 0x444, 0x444, 0x444, 0x444, 0x4444, 0x4444, 0x4444, 
+  0x444, 0x4444, 0x4444, 0x4444, 0x4444, 0x58, 0x57, 0x85, 
+  0x85, 0x87, 0x85, 0x85, 0x84, 0x84, 0x84, 0x84, 
+  0x75, 0x75, 0x78, 0x75, 0x75, 0x74, 0x74, 0x74, 
+  0x74, 0x58, 0x57, 0x48, 0x47, 0x48, 0x47, 0x888, 
+  0x484, 0x884, 0x884, 0x884, 0x884, 0x48, 0x48, 0x888, 
+  0x888, 0x888, 0x8888, 0x8888, 0x888, 0x888, 0x777, 0x474, 
+  0x774, 0x774, 0x774, 0x774, 0x777, 0x777, 0x77, 0x7777, 
+  0x7777, 0x47777, 0x7777, 0x7777, 0x47, 0x47, 0x777, 0x777, 
+  0x777, 0x777, (1U<<31) | 2040, (1U<<31) | 972, (1U<<31) | 940, (1U<<31) | 2048, (1U<<31) | 983, (1U<<31) | 950, 
+  (1U<<31) | 2040, (1U<<31) | 972, (1U<<31) | 940, (1U<<31) | 2040, (1U<<31) | 972, (1U<<31) | 940, (1U<<31) | 2040, (1U<<31) | 972, 
+  (1U<<31) | 940, (1U<<31) | 2040, (1U<<31) | 972, (1U<<31) | 940, 0x4e4, 0x5e5, 0x4444, 0x4444, 
+  0x4455, 0x4455, 0x4455, 0x4455, 0x4455, 0x4455, 0x445, 0x445, 
+  0x444, 0x444, 0x444, 0x444, 0x445, 0x445, 0x445, 0x445, 
+  0x4455, 0x4455, 0x4455, 0x4455, 0x4455, 0x4455, 0x444, 0x445, 
+  0x4455, 0x4455, 0x445, 0x444, 0x444, 0x444, 0x444, 0x4444, 
+  0x4444, 0x4444, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 
   0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 
-  0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 
+  0x5555, 0x5555, 0x555, 0x555, 0x555, 0x555, 0x555, 0x555, 
   0x555, 0x555, 0x555, 0x555, 0x555, 0x555, 0x555, 0x555, 
-  0x555, 0x555, 0x555, 0x555, 0x555, 0x555, 0x555, 0x555, 
+  0x555, 0x555, 0x4444, 0x4444, 0x4444, 0x4444, 0x4444, 0x4444, 
   0x4444, 0x4444, 0x4444, 0x4444, 0x4444, 0x4444, 0x4444, 0x4444, 
+  0x4444, 0x4444, 0x4444, 0x444, 0x444, 0x444, 0x444, 0x444, 
+  0x444, 0x444, 0x444, 0x4444, 0x4444, 0x4444, 0x4444, 0x4444, 
   0x4444, 0x4444, 0x4444, 0x4444, 0x4444, 0x4444, 0x4444, 0x4444, 
-  0x4444, 0x444, 0x444, 0x444, 0x444, 0x444, 0x444, 0x444, 
-  0x444, 0x4444, 0x4444, 0x4444, 0x4444, 0x4444, 0x4444, 0x4444, 
-  0x4444, 0x4444, 0x4444, 0x4444, 0x4444, 0x4444, 0x4444, 0x4444, 
-  0x4444, 0x444, 0x444, 0x444, 0x444, 0x444, 0x444, 0x444, 
+  0x4444, 0x4444, 0x4444, 0x444, 0x444, 0x444, 0x444, 0x444, 
   0x444, 0x444, 0x444, 0x444, 0x444, 0x444, 0x444, 0x444, 
   0x444, 0x444, 0x444, 0x444, 0x444, 0x444, 0x444, 0x444, 
-  0x444, 0x444, 0x444, 0x444, 0x4455, 0x4455, 0x4455, 0x4455, 
-  0x4455, 0x4455, 0x4455, 0x4455, 0x445, 0x445, 0x445, 0x445, 
-  0x445, 0x445, 0x445, 0x445, 0x4455, 0x4455, 0x4455, 0x4455, 
-  0x4455, 0x4455, 0x4455, 0x4455, 0x445, 0x445, 0x445, 0x445, 
-  0x445, 0x445, 0x445, 0x445, 0x444, 0x444, 0x444, 0x444, 
+  0x444, 0x444, 0x444, 0x444, 0x444, 0x444, 0x4455, 0x4455, 
+  0x4455, 0x4455, 0x4455, 0x4455, 0x4455, 0x4455, 0x445, 0x445, 
+  0x445, 0x445, 0x445, 0x445, 0x445, 0x445, 0x4455, 0x4455, 
+  0x4455, 0x4455, 0x4455, 0x4455, 0x4455, 0x4455, 0x445, 0x445, 
+  0x445, 0x445, 0x445, 0x445, 0x445, 0x445, 0x444, 0x444, 
   0x444, 0x4444, 0x4444, 0x4444, 0x4444, 0x4444, 0x4444, 0x4444, 
   0x4444, 0x444, 0x444, 0x444, 0x444, 0x444, 0x444, 0x444, 
   0x444, 0x4444, 0x4444, 0x4444, 0x4444, 0x4444, 0x4444, 0x4444, 
@@ -8188,222 +11404,221 @@
   0x4455, 0x445, 0x4455, 0x5555, 0x5555, 0x555, 0x555, 0x5555, 
   0x5555, 0x555, 0x555, 0x4444, 0x4444, 0x4444, 0x5555, 0x5555, 
   0x555, 0x4455, 0x4455, 0x445, 0x445, 0x5555, 0x5555, 0x555, 
-  0x555, 0x555, 0x555, 0x4444, 0x455, 0x4555, 0x4555, 0x4555, 
+  0x555, 0x555, 0x555, 0x555, 0x5555, 0x555, 0x5555, 0x555, 
+  0x5555, 0x555, 0x5555, 0x555, 0x5555, 0x554, 0x554, 0x554, 
+  0x554, 0x554, 0x554, 0x554, 0x554, 0x4444, 0x455, 0x4555, 
+  0x4555, 0x4555, 0x4555, 0x4555, 0x444, 0x4444, 0x4444, 0x4444, 
+  0x4444, 0x444, 0x4444, 0x455, 0x455, 0x455, 0x4555, 0x4555, 
+  0x4555, 0x4555, 0x4555, 0x444, 0x4444, 0x4444, 0x4444, 0x4444, 
+  0x444, 0x455, 0x455, 0x455, 0x4555, 0x4555, 0x4555, 0x4555, 
+  0x455, 0x455, 0x444, 0x4444, 0x4444, 0x4444, 0x4444, 0x444, 
+  0x444, 0x454, 0x455, 0x455, 0x455, 0x4555, 0x4555, 0x4555, 
   0x4555, 0x4555, 0x444, 0x4444, 0x4444, 0x4444, 0x4444, 0x444, 
-  0x4444, 0x455, 0x455, 0x455, 0x4555, 0x4555, 0x4555, 0x4555, 
-  0x4555, 0x444, 0x4444, 0x4444, 0x4444, 0x4444, 0x444, 0x455, 
-  0x455, 0x455, 0x4555, 0x4555, 0x4555, 0x4555, 0x455, 0x455, 
-  0x444, 0x4444, 0x4444, 0x4444, 0x4444, 0x444, 0x444, 0x454, 
+  0x454, 0x455, 0x455, 0x44, 0x55, 0x44, 0x54, 0x44, 
+  0x54, 0x44, 0x44, 0x54, 0x444, 0x444, 0x44, 0x54, 
+  0x44, 0x54, 0x55, 0x4444, 0x544, 0x4455, 0x555, 0x44444, 
+  0x5444, 0x44555, 0x5555, 0x55, 0x555, 0x455, 0x4555, 0x4555, 
+  0x4555, 0x4555, 0x4555, 0x444, 0x4444, 0x4444, 0x4444, 0x4444, 
   0x455, 0x455, 0x455, 0x4555, 0x4555, 0x4555, 0x4555, 0x4555, 
-  0x444, 0x4444, 0x4444, 0x4444, 0x4444, 0x444, 0x454, 0x455, 
-  0x455, 0x44, 0x55, 0x44, 0x54, 0x44, 0x54, 0x44, 
-  0x44, 0x54, 0x444, 0x444, 0x44, 0x54, 0x44, 0x54, 
-  0x55, 0x4444, 0x544, 0x4455, 0x555, 0x44444, 0x5444, 0x44555, 
-  0x5555, 0x55, 0x555, 0x455, 0x4555, 0x4555, 0x4555, 0x4555, 
-  0x4555, 0x444, 0x4444, 0x4444, 0x4444, 0x4444, 0x455, 0x455, 
+  0x444, 0x4444, 0x4444, 0x4444, 0x4444, 0x4444, 0x455, 0x455, 
   0x455, 0x4555, 0x4555, 0x4555, 0x4555, 0x4555, 0x444, 0x4444, 
-  0x4444, 0x4444, 0x4444, 0x4444, 0x455, 0x455, 0x455, 0x4555, 
-  0x4555, 0x4555, 0x4555, 0x4555, 0x444, 0x4444, 0x4444, 0x4444, 
-  0x4444, 0x455, 0x455, 0x444, 0x445, 0x554, 0x444, 0x444, 
-  0x555, 0x555, 0x555, 0x555, 0x442e2e, (1U<<31) | 721, 0x2e442e2e, 0x452e2e, 
-  (1U<<31) | 737, 0x2e542e2e, 0x442e2e, (1U<<31) | 721, 0x2e442e2e, 0x442e2e, (1U<<31) | 721, 0x2e442e2e, 
-  0x442e2e, (1U<<31) | 721, 0x2e442e2e, 0x44e4, 0x44, 0x44, 0x44444, 0x44444, 
-  0x44444, 0x44444, 0x444, 0x444, 0x444, 0x444, 0x4555, 0x4555, 
-  0x455, 0x455, 0x4555, 0x54, 0x54, 0x54, 0x55, 0x54, 
-  0x55, 0x54, 0x55, 0x54, 0x55, 0x44, 0x45, 0x4555, 
-  0x4555, 0x45, 0x45, 0x54, 0x555, 0x54, 0x555, 0x45, 
-  0x45, 0x4444, 0x4444, 0x4444, 0x4444, 0x4444, 0x444, 0x454, 
-  0x54, 0x4444, 0x544, 0x4455, 0x555, 0x444, 0x444, 0x444, 
-  0x4444, 0x4444, 0x4444, 0x4444, 0x4444, 0x444, 0x55e4, 0x4444, 
-  0x4444, 0x4444, 0x4455, 0x44555, 0x555, 0x555, 0x555, 0x555, 
-  0x555, 0x555, 0x454, 0x454, 0x54, 0x455, 0x455, 0x4555, 
-  0x4555, 0x4555, 0x4555, 0x4555, 0x444, 0x4444, 0x4444, 0x4444, 
-  0x4444, 0x4444, 0x45, 0x555, 0x555, 0x44c4, 0x44d4, 0x4d4c, 
-  (1U<<31) | 5189, 0x44c, 0x44d, 0x444c, 0x444d, 0x444c, 0x444d, 0x444c, 
-  0x444d, 0x444c, 0x444d, 0x444c, 0x444d, 0x444c, 0x444d, 0x44c, 
-  0x44d, 0x44c, 0x444c, 0x444d, 0x444c, 0x444d, 0x444c, 0x444d, 
-  0x444c, 0x444d, 0x444c, 0x444d, 0x444c, 0x444d, 0x44c, 0x44d, 
-  0x4d4c, (1U<<31) | 5189, 0x44c, 0x44d, 0x44c, 0x44d, 0x44c, 0x44d, 
-  (1U<<31) | 197, (1U<<31) | 225, (1U<<31) | 197, (1U<<31) | 225, (1U<<31) | 199, (1U<<31) | 227, (1U<<31) | 197, (1U<<31) | 225, 
-  (1U<<31) | 197, (1U<<31) | 225, (1U<<31) | 1139, (1U<<31) | 1147, (1U<<31) | 1139, (1U<<31) | 1147, (1U<<31) | 197, (1U<<31) | 225, 
-  (1U<<31) | 197, (1U<<31) | 225, (1U<<31) | 197, (1U<<31) | 225, (1U<<31) | 4851, (1U<<31) | 4966, (1U<<31) | 4851, (1U<<31) | 4966, 
-  (1U<<31) | 4851, (1U<<31) | 4966, (1U<<31) | 4851, (1U<<31) | 4966, 0x4c4c, 0x4d4d, 0x4c4c, 0x4d4d, 
-  0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 
-  0x4c4c, 0x4d4d, 0x4c4c, 0x4d4d, 0x4c4c, 0x4d4d, 0x4c4c, 0x4d4d, 
-  0x4c4c4c, 0x4d4d4d, 0x4d4d4d, (1U<<31) | 5194, (1U<<31) | 4888, (1U<<31) | 5003, (1U<<31) | 4888, (1U<<31) | 5003, 
-  0x4c4c4c, 0x4d4d4d, 0x4d4d4d, (1U<<31) | 5194, (1U<<31) | 204, (1U<<31) | 232, (1U<<31) | 216, (1U<<31) | 244, 
-  0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 0x4d4d4d, (1U<<31) | 5194, 
-  (1U<<31) | 4888, (1U<<31) | 5003, (1U<<31) | 4888, (1U<<31) | 5003, 0x4c4c4c, 0x4d4d4d, 0x4d4d4d, (1U<<31) | 5194, 
-  0x4c4c4d, (1U<<31) | 5033, 0x4c4c4d4d, (1U<<31) | 5031, 0x4c4c4d, (1U<<31) | 5033, 0x4c4c4d4d, (1U<<31) | 5031, 
-  0x4c4c4c, 0x4d4d4d, 0x4d4d4d, (1U<<31) | 5194, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 
-  0x4d4d4d, (1U<<31) | 5194, 0x4c4c4d, (1U<<31) | 5033, 0x4c4c4d4d, (1U<<31) | 5031, 0x4c4c4c, 0x4d4d4d, 
-  0x4d4d4d, (1U<<31) | 5194, 0x4c4c4c, 0x4d4d4d, 0x4d4d4d, (1U<<31) | 5194, (1U<<31) | 4888, (1U<<31) | 5003, 
-  (1U<<31) | 4888, (1U<<31) | 5003, 0x4c4c4c, 0x4d4d4d, 0x4d4d4d, (1U<<31) | 5194, 0x44c4c4c, 0x44d4d4d, 
-  0x44c4c4c, 0x44d4d4d, 0x4c4c4c, 0x4d4d4d, (1U<<31) | 1137, (1U<<31) | 1145, (1U<<31) | 1135, (1U<<31) | 1143, 
-  (1U<<31) | 1137, (1U<<31) | 1145, (1U<<31) | 1135, (1U<<31) | 1143, (1U<<31) | 4844, (1U<<31) | 4959, (1U<<31) | 4844, (1U<<31) | 4959, 
-  (1U<<31) | 4018, (1U<<31) | 4068, (1U<<31) | 4016, (1U<<31) | 4066, 0x44c4c, 0x44d4d, 0x44c4c4c, 0x44d4d4d, 
-  0x4c4c4c, 0x4d4d4d, 0x44c4c, 0x44d4d, 0x44c4c4c, 0x44d4d4d, 0x4c4c4c, 0x4d4d4d, 
-  0x4c4c4d4d, (1U<<31) | 5031, 0x44c4c, 0x44d4d, 0x44c4c4c, 0x44d4d4d, 0x44c4c4c, 0x44d4d4d, 
-  0x44c4c4c, 0x44d4d4d, 0x44c4c4c, 0x44d4d4d, 0x44c4c4c, 0x44d4d4d, 0x4c4c4c, 0x4d4d4d, 
-  0x44c4c4c, 0x44d4d4d, 0x44c4c4c, 0x44d4d4d, 0x44c4c4c, 0x44d4d4d, 0x44c4c4c, 0x44d4d4d, 
-  0x44c4c, 0x44d4d, 0x44c4c4c, 0x44d4d4d, 0x44c4c4c, 0x44d4d4d, 0x44c4c4c, 0x44d4d4d, 
-  0x44c4c4c, 0x44d4d4d, 0x44c4c4c, 0x44d4d4d, 0x44c4c4c, 0x44d4d4d, 0x4c4c4c, 0x4d4d4d, 
-  0x4c4c, 0x4d4d, 0x4d4d, (1U<<31) | 5196, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 
-  0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 
-  0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 
-  0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 0x4c4c, 0x4d4d, 0x4c4c, 0x4d4d, 
-  0x4c4c4d, (1U<<31) | 5033, 0x4c, 0x4d, 0x4d, (1U<<31) | 5178, 0x4c4c, 0x4d4d, 
-  0x4c4c4c, 0x4d4d4d, 0x4c4c, 0x4d4d, 0x44c4c4d, (1U<<31) | 4087, 0x4c4c4c, 0x4d4d4d, 
-  0x44c4c, 0x44d4d, 0x44c4c4c, 0x44d4d4d, 0x44d4d, (1U<<31) | 4225, 0x44d4d4d, (1U<<31) | 4223, 
-  0x44c4c, 0x44d4d, 0x44c4c4c, 0x44d4d4d, 0x44d4d, (1U<<31) | 4225, 0x44d4d4d, (1U<<31) | 4223, 
-  0x44d4c, (1U<<31) | 4217, 0x44d4c4c, (1U<<31) | 4215, 0x44c4c, 0x44d4d, 0x44c4c4c, 0x44d4d4d, 
-  0x44d4c, (1U<<31) | 4217, 0x44d4c4c, (1U<<31) | 4215, 0x44c4c, 0x44d4d, 0x44c4c4c, 0x44d4d4d, 
-  0x4c4c4c, 0x4d4d4d, 0x4c4c4c4c, 0x4d4d4d4d, 0x44d4d, (1U<<31) | 4225, 0x44d4d4d, (1U<<31) | 4223, 
-  (1U<<31) | 4881, (1U<<31) | 4996, (1U<<31) | 4879, (1U<<31) | 4994, (1U<<31) | 4879, (1U<<31) | 4994, (1U<<31) | 4879, (1U<<31) | 4994, 
-  (1U<<31) | 4881, (1U<<31) | 4996, (1U<<31) | 4879, (1U<<31) | 4994, (1U<<31) | 4879, (1U<<31) | 4994, (1U<<31) | 4879, (1U<<31) | 4994, 
-  (1U<<31) | 4881, (1U<<31) | 4996, (1U<<31) | 4879, (1U<<31) | 4994, (1U<<31) | 4879, (1U<<31) | 4994, (1U<<31) | 4879, (1U<<31) | 4994, 
-  0x4c442e0, 0x4d442e0, (1U<<31) | 4859, (1U<<31) | 4984, 0x4d442e0, (1U<<31) | 5181, (1U<<31) | 4974, (1U<<31) | 5171, 
-  0x4c442e0, 0x4d442e0, (1U<<31) | 4859, (1U<<31) | 4984, (1U<<31) | 4881, (1U<<31) | 4996, (1U<<31) | 4879, (1U<<31) | 4994, 
-  (1U<<31) | 4879, (1U<<31) | 4994, (1U<<31) | 4879, (1U<<31) | 4994, (1U<<31) | 4881, (1U<<31) | 4996, (1U<<31) | 4879, (1U<<31) | 4994, 
-  (1U<<31) | 4879, (1U<<31) | 4994, (1U<<31) | 4879, (1U<<31) | 4994, (1U<<31) | 4881, (1U<<31) | 4996, (1U<<31) | 4879, (1U<<31) | 4994, 
-  (1U<<31) | 4879, (1U<<31) | 4994, (1U<<31) | 4879, (1U<<31) | 4994, (1U<<31) | 4881, (1U<<31) | 4996, (1U<<31) | 4879, (1U<<31) | 4994, 
-  (1U<<31) | 4879, (1U<<31) | 4994, (1U<<31) | 4879, (1U<<31) | 4994, (1U<<31) | 4881, (1U<<31) | 4996, (1U<<31) | 4879, (1U<<31) | 4994, 
-  (1U<<31) | 4879, (1U<<31) | 4994, (1U<<31) | 4879, (1U<<31) | 4994, (1U<<31) | 4881, (1U<<31) | 4996, (1U<<31) | 4879, (1U<<31) | 4994, 
-  (1U<<31) | 4879, (1U<<31) | 4994, (1U<<31) | 4879, (1U<<31) | 4994, 0x44c4c, 0x44d4d, 0x44c4c4c, 0x44d4d4d, 
-  0x44c4c4c, 0x44d4d4d, 0x44c4c, 0x44d4d, 0x44c4c, 0x44d4d, 0x4c4c4c, 0x4d4d4d, 
-  0x44c4c, 0x44d4d, 0x4c4c4c, 0x4d4d4d, 0x54c4c, 0x54d4d, 0x44c4c4c, 0x44d4d4d, 
-  0x44c4c4c, 0x44d4d4d, (1U<<31) | 4046, (1U<<31) | 4075, (1U<<31) | 4046, (1U<<31) | 4075, 0x44c4c4c, 0x44d4d4d, 
-  0x44c4c4d, (1U<<31) | 4087, 0x44c4c4d, (1U<<31) | 4087, (1U<<31) | 4056, (1U<<31) | 4085, (1U<<31) | 4056, (1U<<31) | 4085, 
-  0x44c4c4d, (1U<<31) | 4087, (1U<<31) | 4851, (1U<<31) | 4966, (1U<<31) | 4851, (1U<<31) | 4966, (1U<<31) | 4851, (1U<<31) | 4966, 
-  (1U<<31) | 4851, (1U<<31) | 4966, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 
-  0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 
-  0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 0x44d4d, (1U<<31) | 4225, 
-  0x44d4d4d, (1U<<31) | 4223, 0x4d4d4d, (1U<<31) | 5194, 0x44d4d, (1U<<31) | 4225, 0x44d4d4d, (1U<<31) | 4223, 
-  0x4d4d4d, (1U<<31) | 5194, 0x44d4d, (1U<<31) | 4225, 0x44d4d4d, (1U<<31) | 4223, 0x54c4c4c, 0x54d4d4d, 
-  0x44d4d, (1U<<31) | 4225, 0x44d4d4d, (1U<<31) | 4223, 0x54c4c4c, 0x54d4d4d, 0x54c4c4c, 0x54d4d4d, 
-  0x44c4d, (1U<<31) | 4097, 0x44c4d4d, (1U<<31) | 4095, 0x4c4c4d, (1U<<31) | 5033, 0x4c4c4d4d, (1U<<31) | 5031, 
-  0x4c4c4d, (1U<<31) | 5033, 0x4c4c4d4d, (1U<<31) | 5031, 0x4c4c4c, 0x4d4d4d, 0x4c4c4d, (1U<<31) | 5033, 
-  0x44c4d, (1U<<31) | 4097, 0x44c4d4d, (1U<<31) | 4095, 0x44c4d4d, (1U<<31) | 4095, 0x44c4c, 0x44d4d, 
-  0x44c4c, 0x44d4d, 0x4c4c4d, (1U<<31) | 5033, 0x4c4c4d4d, (1U<<31) | 5031, 0x4c4c4d, (1U<<31) | 5033, 
-  0x4c4c4d4d, (1U<<31) | 5031, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c4c, 0x4d4d4d4d, 
-  0x4c4c4c, 0x4d4d4d, 0x4c4c4c4c, 0x4d4d4d4d, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c4c, 0x4d4d4d4d, 
-  0x44c4c, 0x44d4d, 0x44c4c4c, 0x44d4d4d, 0x4c4c4c, 0x4d4d4d, 0x44c4c, 0x44d4d, 
-  0x44c4c4c, 0x44d4d4d, 0x44c4c, 0x44d4d, 0x44c4c4c, 0x44d4d4d, 0x44c4c, 0x44d4d, 
-  0x44c4c4c, 0x44d4d4d, 0x4c4c4c, 0x4d4d4d, 0x4c4c4d4d, (1U<<31) | 5031, 0x4c4c4c, 0x4d4d4d, 
-  0x4c4c4c4c, 0x4d4d4d4d, 0x4c4c4c4c, 0x4d4d4d4d, 0x44c4d, (1U<<31) | 4097, 0x44c4d4d, (1U<<31) | 4095, 
-  0x4c4c4d, (1U<<31) | 5033, 0x4c4c4d4d, (1U<<31) | 5031, 0x44c4d, (1U<<31) | 4097, 0x44c4d4d, (1U<<31) | 4095, 
-  0x44c4c, 0x44d4d, 0x44c4c4c, 0x44d4d4d, 0x4c4c4d, (1U<<31) | 5033, 0x4c4c4d4d, (1U<<31) | 5031, 
-  (1U<<31) | 4888, (1U<<31) | 5003, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 
-  0x4c4c4c, 0x4d4d4d, 0x4c4c, 0x4d4d, 0x4c4c, 0x4d4d, 0x4c4c, 0x4d4d, 
-  0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 
-  0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 
-  0x4c4c4c, 0x4d4d4d, 0x4c4c, 0x4d4d, (1U<<31) | 211, (1U<<31) | 239, (1U<<31) | 211, (1U<<31) | 239, 
-  (1U<<31) | 211, (1U<<31) | 239, 0x4c4c4c, 0x4d4d4d, 0x54c4d, (1U<<31) | 5230, 0x54c4d4d, (1U<<31) | 5228, 
-  0x44c4c, 0x44d4d, 0x44c4c4c, 0x44d4d4d, 0x444d4d, (1U<<31) | 3740, 0x444d4d4d, (1U<<31) | 3738, 
-  0x4c4c4c, 0x4d4d4d, 0x4c4c4c4c, 0x4d4d4d4d, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c4c, 0x4d4d4d4d, 
-  0x44c4c, 0x44d4d, 0x44c4c4c, 0x44d4d4d, 0x54c4d, (1U<<31) | 5230, 0x54c4d4d, (1U<<31) | 5228, 
-  0x444d4d, (1U<<31) | 3740, 0x444d4d4d, (1U<<31) | 3738, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c4c, 0x4d4d4d4d, 
-  0x44c4c, 0x44d4d, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 
-  0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 
-  0x444d4d, (1U<<31) | 3740, 0x444d4d4d, (1U<<31) | 3738, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 
-  0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 0x4c4d, (1U<<31) | 5043, 0x4c4c440, 0x4d4d440, 
-  0x4c4c440, 0x4d4d440, (1U<<31) | 4906, (1U<<31) | 5021, 0x4c4d440, (1U<<31) | 5040, 0x4c4d440, (1U<<31) | 5040, 
-  (1U<<31) | 4916, (1U<<31) | 5048, 0x4c4c440, 0x4d4d440, 0x4c4c440, 0x4d4d440, (1U<<31) | 4906, (1U<<31) | 5021, 
-  0x4c4d, (1U<<31) | 5043, 0x4c4c4c, 0x4d4d4d, 0x4c4c, 0x4d4d, 0x4c4c4c, 0x4d4d4d, 
-  0x4c4c, 0x4d4d, 0x4c4c4c, 0x4d4d4d, 0x44c4c4d, (1U<<31) | 4087, 0x4c4c4d, (1U<<31) | 5033, 
-  0x4c4c4d, (1U<<31) | 5033, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 0x4d4d4d, (1U<<31) | 5194, 
-  (1U<<31) | 4888, (1U<<31) | 5003, (1U<<31) | 4888, (1U<<31) | 5003, 0x4c4c4c, 0x4d4d4d, 0x4d4d4d, (1U<<31) | 5194, 
-  (1U<<31) | 204, (1U<<31) | 232, 0x4c4c4c, 0x4d4d4d, 0x4d4d4d, (1U<<31) | 5194, (1U<<31) | 4888, (1U<<31) | 5003, 
-  (1U<<31) | 4888, (1U<<31) | 5003, 0x4c4c4c, 0x4d4d4d, 0x4d4d4d, (1U<<31) | 5194, 0x4c4c4d, (1U<<31) | 5033, 
-  0x4c4c4d, (1U<<31) | 5033, 0x4c4c4c, 0x4d4d4d, 0x4d4d4d, (1U<<31) | 5194, 0x4c4c4c, 0x4d4d4d, 
-  0x4c4c4c, 0x4d4d4d, 0x4d4d4d, (1U<<31) | 5194, 0x4c4c4d, (1U<<31) | 5033, 0x4c4c4c, 0x4d4d4d, 
-  0x4d4d4d, (1U<<31) | 5194, 0x4c4c4c, 0x4d4d4d, 0x4d4d4d, (1U<<31) | 5194, (1U<<31) | 4888, (1U<<31) | 5003, 
-  (1U<<31) | 4888, (1U<<31) | 5003, 0x4c4c4c, 0x4d4d4d, 0x4d4d4d, (1U<<31) | 5194, (1U<<31) | 4897, (1U<<31) | 5012, 
-  0x44d4d, (1U<<31) | 4225, 0x44d4d4d, (1U<<31) | 4223, 0x44d4d, (1U<<31) | 4225, 0x44d4d4d, (1U<<31) | 4223, 
-  0x44d4d, (1U<<31) | 4225, 0x44d4d4d, (1U<<31) | 4223, (1U<<31) | 4045, (1U<<31) | 4074, 0x4c4d, (1U<<31) | 5043, 
-  0x4c4d, (1U<<31) | 5043, 0x4c4d4d, (1U<<31) | 5058, 0x4c4d4d, (1U<<31) | 5058, 0x4c4d, (1U<<31) | 5043, 
-  0x4c4d, (1U<<31) | 5043, 0x4c4c4c, 0x4d4d4d, 0x4c4d, (1U<<31) | 5043, 0x4c4d, (1U<<31) | 5043, 
-  0x2e0, 0x2e0, 0x2e0, 0x2e0, 0x42e0, 0x52e0, 0x442e2e2e, 0x442e2e2e, 
-  0x442e2e2e, 0x442e2e2e, 0x442e2e2e, 0x442e2e2e, 0x4442e2e, 0x4452e2e, 0x4442e2e, 0x4442e2e, 
-  0x4442e2e, 0x2e0, 0x42e2e0, 0x442e0, 0x3939, 0x2a2a, 0x44, 0x2c2c2c, 
-  0x595959, 0x3b3b3b, 0x4a4a4a, 0x393939, 0x393939, 0x444, 0x393939, 0x393939, 
-  0x444, 0x444, 0x2c2c2c, 0x595959, 0x3b3b3b, 0x4a4a4a, 0x2c2c2c, 0x595959, 
-  0x3b3b3b, 0x4a4a4a, 0x2c2c2c, 0x595959, 0x3b3b3b, 0x4a4a4a, 0x444, 0x393939, 
-  0x2a2a2a, 0x393939, 0x2a2a2a, 0x2a2a2a, 0x2a2a2a, 0x2c2c2c, 0x595959, 0x3b3b3b, 
-  0x4a4a4a, 0x42c2c, 0x45959, 0x43b3b, 0x44a4a, 0x444, 0x2c2c2c, 0x42c2c, 
-  0x4444, 0x2c2c2c, 0x595959, 0x3b3b3b, 0x4a4a4a, 0x2c2c2c, 0x595959, 0x3b3b3b, 
+  0x4444, 0x4444, 0x4444, 0x455, 0x455, 0x444, 0x445, 0x554, 
+  0x444, 0x444, 0x555, 0x555, 0x555, 0x555, 0x442e2e, (1U<<31) | 994, 
+  0x2e442e2e, 0x452e2e, (1U<<31) | 1017, 0x2e542e2e, 0x442e2e, (1U<<31) | 994, 0x2e442e2e, 0x442e2e, 
+  (1U<<31) | 994, 0x2e442e2e, 0x442e2e, (1U<<31) | 994, 0x2e442e2e, 0x44e4, 0x44, 0x44, 
+  0x44444, 0x44444, 0x44444, 0x44444, 0x444, 0x444, 0x444, 0x444, 
+  0x4555, 0x4555, 0x455, 0x455, 0x4555, 0x54, 0x54, 0x54, 
+  0x55, 0x54, 0x55, 0x54, 0x55, 0x54, 0x55, 0x44, 
+  0x45, 0x4555, 0x4555, 0x45, 0x45, 0x54, 0x555, 0x54, 
+  0x555, 0x45, 0x45, 0x4444, 0x4444, 0x4444, 0x4444, 0x4444, 
+  0x444, 0x454, 0x54, 0x4444, 0x544, 0x4455, 0x555, 0x444, 
+  0x444, 0x444, 0x4444, 0x4444, 0x4444, 0x4444, 0x4444, 0x444, 
+  0x55e4, 0x4444, 0x4444, 0x4444, 0x4455, 0x44555, 0x555, 0x555, 
+  0x555, 0x555, 0x555, 0x555, 0x454, 0x454, 0x54, 0x455, 
+  0x455, 0x4555, 0x4555, 0x4555, 0x4555, 0x4555, 0x444, 0x4444, 
+  0x4444, 0x4444, 0x4444, 0x4444, 0x45, 0x555, 0x555, 0x44c4, 
+  0x44d4, 0x4d4c, (1U<<31) | 6487, 0x4d4c, (1U<<31) | 6487, 0x44c, 0x44d, 0x44c, 
+  0x44d, 0x44c, 0x44d, (1U<<31) | 285, (1U<<31) | 356, (1U<<31) | 285, (1U<<31) | 356, (1U<<31) | 287, 
+  (1U<<31) | 358, (1U<<31) | 285, (1U<<31) | 356, (1U<<31) | 285, (1U<<31) | 356, (1U<<31) | 1542, (1U<<31) | 1577, (1U<<31) | 1542, 
+  (1U<<31) | 1577, 0xbf3f, 0xbf3f, (1U<<31) | 285, (1U<<31) | 356, (1U<<31) | 285, (1U<<31) | 356, (1U<<31) | 285, 
+  (1U<<31) | 356, (1U<<31) | 6140, (1U<<31) | 6255, (1U<<31) | 6140, (1U<<31) | 6255, (1U<<31) | 6140, (1U<<31) | 6255, (1U<<31) | 6140, 
+  (1U<<31) | 6255, 0x4c4c, 0x4d4d, 0x4c4c, 0x4d4d, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 
+  0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 0x4c4c, 0x4d4d, 0x4c4c, 
+  0x4d4d, 0x4c4c, 0x4d4d, 0x4c4c, 0x4d4d, 0x4c4c4c, 0x4d4d4d, 0x4d4d4d, 
+  (1U<<31) | 6492, (1U<<31) | 6177, (1U<<31) | 6292, (1U<<31) | 6177, (1U<<31) | 6292, 0x4c4c4c, 0x4d4d4d, 0x4d4d4d, 
+  (1U<<31) | 6492, (1U<<31) | 298, (1U<<31) | 363, (1U<<31) | 310, (1U<<31) | 375, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 
+  0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 0x4d4d4d, (1U<<31) | 6492, (1U<<31) | 6177, (1U<<31) | 6292, (1U<<31) | 6177, 
+  (1U<<31) | 6292, 0x4c4c4c, 0x4d4d4d, 0x4d4d4d, (1U<<31) | 6492, 0x4c4c4d, (1U<<31) | 6322, 0x4c4c4d4d, 
+  (1U<<31) | 6320, 0x4c4c4d, (1U<<31) | 6322, 0x4c4c4d4d, (1U<<31) | 6320, 0x4c4c4c, 0x4d4d4d, 0x4d4d4d, 
+  (1U<<31) | 6492, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 0x4d4d4d, (1U<<31) | 6492, 0x4c4c4d, 
+  (1U<<31) | 6322, 0x4c4c4d4d, (1U<<31) | 6320, 0x4c4c4c, 0x4d4d4d, 0x4d4d4d, (1U<<31) | 6492, 0x4c4c4c, 
+  0x4d4d4d, 0x4d4d4d, (1U<<31) | 6492, (1U<<31) | 6177, (1U<<31) | 6292, (1U<<31) | 6177, (1U<<31) | 6292, 0x4c4c4c, 
+  0x4d4d4d, 0x4d4d4d, (1U<<31) | 6492, 0x44c4c4c, 0x44d4d4d, 0x44c4c4c, 0x44d4d4d, 0x4c4c4c, 
+  0x4d4d4d, (1U<<31) | 1540, (1U<<31) | 1575, (1U<<31) | 1538, (1U<<31) | 1573, (1U<<31) | 1540, (1U<<31) | 1575, (1U<<31) | 1538, 
+  (1U<<31) | 1573, (1U<<31) | 6133, (1U<<31) | 6248, (1U<<31) | 6133, (1U<<31) | 6248, (1U<<31) | 4775, (1U<<31) | 4824, (1U<<31) | 4773, 
+  (1U<<31) | 4822, 0x44c4c, 0x44d4d, 0x44c4c4c, 0x44d4d4d, 0x4c4c4c, 0x4d4d4d, 0x44c4c, 
+  0x44d4d, 0x44c4c4c, 0x44d4d4d, 0x4c4c4c, 0x4d4d4d, 0x4c4c4d4d, (1U<<31) | 6320, 0x44c4c, 
+  0x44d4d, 0x44c4c4c, 0x44d4d4d, 0x44c4c4c, 0x44d4d4d, 0x44c4c4c, 0x44d4d4d, 0x44c4c4c, 
+  0x44d4d4d, 0x44c4c4c, 0x44d4d4d, 0x4c4c4c, 0x4d4d4d, 0x44c4c4c, 0x44d4d4d, 0x44c4c4c, 
+  0x44d4d4d, 0x44c4c4c, 0x44d4d4d, 0x44c4c4c, 0x44d4d4d, 0x44c4c, 0x44d4d, 0x44c4c4c, 
+  0x44d4d4d, 0x44c4c4c, 0x44d4d4d, 0x44c4c4c, 0x44d4d4d, 0x44c4c4c, 0x44d4d4d, 0x44c4c4c, 
+  0x44d4d4d, 0x44c4c4c, 0x44d4d4d, 0x4c4c4c, 0x4d4d4d, 0x4c4c, 0x4d4d, 0x4d4d, 
+  (1U<<31) | 6494, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 
+  0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 
+  0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 
+  0x4d4d4d, 0x4c4c, 0x4d4d, 0x4c4c, 0x4d4d, 0x4c4c4d, (1U<<31) | 6322, 0x4c, 
+  0x4d, 0x4d, (1U<<31) | 6476, 0x4c4c, 0x4d4d, 0x4c4c4c, 0x4d4d4d, 0x4c4c, 
+  0x4d4d, 0x44c4c4d, (1U<<31) | 4842, 0x4c4c4c, 0x4d4d4d, 0x44c4c, 0x44d4d, 0x44c4c4c, 
+  0x44d4d4d, 0x44d4d, (1U<<31) | 4980, 0x44d4d4d, (1U<<31) | 4978, 0x44c4c, 0x44d4d, 0x44c4c4c, 
+  0x44d4d4d, 0x44d4d, (1U<<31) | 4980, 0x44d4d4d, (1U<<31) | 4978, 0x44d4c, (1U<<31) | 4972, 0x44d4c4c, 
+  (1U<<31) | 4970, 0x44c4c, 0x44d4d, 0x44c4c4c, 0x44d4d4d, 0x44d4c, (1U<<31) | 4972, 0x44d4c4c, 
+  (1U<<31) | 4970, 0x44c4c, 0x44d4d, 0x44c4c4c, 0x44d4d4d, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c4c, 
+  0x4d4d4d4d, 0x44d4d, (1U<<31) | 4980, 0x44d4d4d, (1U<<31) | 4978, (1U<<31) | 6170, (1U<<31) | 6285, (1U<<31) | 6168, 
+  (1U<<31) | 6283, (1U<<31) | 6168, (1U<<31) | 6283, (1U<<31) | 6168, (1U<<31) | 6283, (1U<<31) | 6170, (1U<<31) | 6285, (1U<<31) | 6168, 
+  (1U<<31) | 6283, (1U<<31) | 6168, (1U<<31) | 6283, (1U<<31) | 6168, (1U<<31) | 6283, (1U<<31) | 6170, (1U<<31) | 6285, (1U<<31) | 6168, 
+  (1U<<31) | 6283, (1U<<31) | 6168, (1U<<31) | 6283, (1U<<31) | 6168, (1U<<31) | 6283, 0x4c442e0, 0x4d442e0, (1U<<31) | 6148, 
+  (1U<<31) | 6273, 0x4d442e0, (1U<<31) | 6479, (1U<<31) | 6263, (1U<<31) | 6469, 0x4c442e0, 0x4d442e0, (1U<<31) | 6148, 
+  (1U<<31) | 6273, (1U<<31) | 6170, (1U<<31) | 6285, (1U<<31) | 6168, (1U<<31) | 6283, (1U<<31) | 6168, (1U<<31) | 6283, (1U<<31) | 6168, 
+  (1U<<31) | 6283, (1U<<31) | 6170, (1U<<31) | 6285, (1U<<31) | 6168, (1U<<31) | 6283, (1U<<31) | 6168, (1U<<31) | 6283, (1U<<31) | 6168, 
+  (1U<<31) | 6283, (1U<<31) | 6170, (1U<<31) | 6285, (1U<<31) | 6168, (1U<<31) | 6283, (1U<<31) | 6168, (1U<<31) | 6283, (1U<<31) | 6168, 
+  (1U<<31) | 6283, (1U<<31) | 6170, (1U<<31) | 6285, (1U<<31) | 6168, (1U<<31) | 6283, (1U<<31) | 6168, (1U<<31) | 6283, (1U<<31) | 6168, 
+  (1U<<31) | 6283, (1U<<31) | 6170, (1U<<31) | 6285, (1U<<31) | 6168, (1U<<31) | 6283, (1U<<31) | 6168, (1U<<31) | 6283, (1U<<31) | 6168, 
+  (1U<<31) | 6283, (1U<<31) | 6170, (1U<<31) | 6285, (1U<<31) | 6168, (1U<<31) | 6283, (1U<<31) | 6168, (1U<<31) | 6283, (1U<<31) | 6168, 
+  (1U<<31) | 6283, 0x44c4c, 0x44d4d, 0x44c4c4c, 0x44d4d4d, 0x44c4c4c, 0x44d4d4d, 0x44c4c, 
+  0x44d4d, 0x44c4c, 0x44d4d, 0x4c4c4c, 0x4d4d4d, 0x44c4c, 0x44d4d, 0x4c4c4c, 
+  0x4d4d4d, 0x54c4c, 0x54d4d, 0x44c4c4c, 0x44d4d4d, 0x44c4c4c, 0x44d4d4d, (1U<<31) | 4802, 
+  (1U<<31) | 4830, (1U<<31) | 4802, (1U<<31) | 4830, 0x44c4c4c, 0x44d4d4d, 0x44c4c4d, (1U<<31) | 4842, 0x44c4c4d, 
+  (1U<<31) | 4842, (1U<<31) | 4812, (1U<<31) | 4840, (1U<<31) | 4812, (1U<<31) | 4840, 0x44c4c4d, (1U<<31) | 4842, (1U<<31) | 6140, 
+  (1U<<31) | 6255, (1U<<31) | 6140, (1U<<31) | 6255, (1U<<31) | 6140, (1U<<31) | 6255, (1U<<31) | 6140, (1U<<31) | 6255, 0x4c4c4c, 
+  0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 
+  0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 
+  0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 0x44d4d, (1U<<31) | 4980, 0x44d4d4d, (1U<<31) | 4978, 0x4d4d4d, 
+  (1U<<31) | 6492, 0x44d4d, (1U<<31) | 4980, 0x44d4d4d, (1U<<31) | 4978, 0x4d4d4d, (1U<<31) | 6492, 0x44d4d, 
+  (1U<<31) | 4980, 0x44d4d4d, (1U<<31) | 4978, 0x54c4c4c, 0x54d4d4d, 0x44d4d, (1U<<31) | 4980, 0x44d4d4d, 
+  (1U<<31) | 4978, 0x54c4c4c, 0x54d4d4d, 0x54c4c4c, 0x54d4d4d, 0x44c4d, (1U<<31) | 4852, 0x44c4d4d, 
+  (1U<<31) | 4850, 0x4c4c4d, (1U<<31) | 6322, 0x4c4c4d4d, (1U<<31) | 6320, 0x4c4c4d, (1U<<31) | 6322, 0x4c4c4d4d, 
+  (1U<<31) | 6320, 0x4c4c4c, 0x4d4d4d, 0x4c4c4d, (1U<<31) | 6322, 0x44c4d, (1U<<31) | 4852, 0x44c4d4d, 
+  (1U<<31) | 4850, 0x44c4d4d, (1U<<31) | 4850, 0x44c4c, 0x44d4d, 0x44c4c, 0x44d4d, 0x4c4c4d, 
+  (1U<<31) | 6322, 0x4c4c4d4d, (1U<<31) | 6320, 0x4c4c4d, (1U<<31) | 6322, 0x4c4c4d4d, (1U<<31) | 6320, 0x4c4c4c, 
+  0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c4c, 0x4d4d4d4d, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c4c, 
+  0x4d4d4d4d, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c4c, 0x4d4d4d4d, 0x44c4c, 0x44d4d, 0x44c4c4c, 
+  0x44d4d4d, 0x4c4c4c, 0x4d4d4d, 0x44c4c, 0x44d4d, 0x44c4c4c, 0x44d4d4d, 0x44c4c, 
+  0x44d4d, 0x44c4c4c, 0x44d4d4d, 0x44c4c, 0x44d4d, 0x44c4c4c, 0x44d4d4d, 0x4c4c4c, 
+  0x4d4d4d, 0x4c4c4d4d, (1U<<31) | 6320, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c4c, 0x4d4d4d4d, 0x4c4c4c4c, 
+  0x4d4d4d4d, 0x44c4d, (1U<<31) | 4852, 0x44c4d4d, (1U<<31) | 4850, 0x4c4c4d, (1U<<31) | 6322, 0x4c4c4d4d, 
+  (1U<<31) | 6320, 0x44c4d, (1U<<31) | 4852, 0x44c4d4d, (1U<<31) | 4850, 0x44c4c, 0x44d4d, 0x44c4c4c, 
+  0x44d4d4d, 0x4c4c4d, (1U<<31) | 6322, 0x4c4c4d4d, (1U<<31) | 6320, (1U<<31) | 6177, (1U<<31) | 6292, 0x4c4c4c, 
+  0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 0x4c4c, 
+  0x4d4d, 0x4c4c, 0x4d4d, 0x4c4c, 0x4d4d, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 
+  0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 
+  0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 0x4c4c, 
+  0x4d4d, (1U<<31) | 305, (1U<<31) | 370, (1U<<31) | 305, (1U<<31) | 370, (1U<<31) | 305, (1U<<31) | 370, 0x4c4c4c, 
+  0x4d4d4d, 0x54c4d, (1U<<31) | 6574, 0x54c4d4d, (1U<<31) | 6572, 0x44c4c, 0x44d4d, 0x44c4c4c, 
+  0x44d4d4d, 0x444d4d, (1U<<31) | 4424, 0x444d4d4d, (1U<<31) | 4422, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c4c, 
+  0x4d4d4d4d, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c4c, 0x4d4d4d4d, 0x44c4c, 0x44d4d, 0x44c4c4c, 
+  0x44d4d4d, 0x54c4d, (1U<<31) | 6574, 0x54c4d4d, (1U<<31) | 6572, 0x444d4d, (1U<<31) | 4424, 0x444d4d4d, 
+  (1U<<31) | 4422, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c4c, 0x4d4d4d4d, 0x44c4c, 0x44d4d, 0x4c4c4c, 
+  0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 
+  0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 0x444d4d, (1U<<31) | 4424, 0x444d4d4d, 
+  (1U<<31) | 4422, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 
+  0x4d4d4d, 0x4c4d, (1U<<31) | 6332, 0x4c4c440, 0x4d4d440, 0x4c4c440, 0x4d4d440, (1U<<31) | 6195, 
+  (1U<<31) | 6310, 0x4c4d440, (1U<<31) | 6329, 0x4c4d440, (1U<<31) | 6329, (1U<<31) | 6205, (1U<<31) | 6337, 0x4c4c440, 
+  0x4d4d440, 0x4c4c440, 0x4d4d440, (1U<<31) | 6195, (1U<<31) | 6310, 0x4c4d, (1U<<31) | 6332, 0x4c4c4c, 
+  0x4d4d4d, 0x4c4c, 0x4d4d, 0x4c4c4c, 0x4d4d4d, 0x4c4c, 0x4d4d, 0x4c4c4c, 
+  0x4d4d4d, 0x44c4c4d, (1U<<31) | 4842, 0x4c4c4d, (1U<<31) | 6322, 0x4c4c4d, (1U<<31) | 6322, 0x4c4c4c, 
+  0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 0x4d4d4d, (1U<<31) | 6492, (1U<<31) | 6177, (1U<<31) | 6292, (1U<<31) | 6177, 
+  (1U<<31) | 6292, 0x4c4c4c, 0x4d4d4d, 0x4d4d4d, (1U<<31) | 6492, (1U<<31) | 298, (1U<<31) | 363, 0x4c4c4c, 
+  0x4d4d4d, 0x4d4d4d, (1U<<31) | 6492, (1U<<31) | 6177, (1U<<31) | 6292, (1U<<31) | 6177, (1U<<31) | 6292, 0x4c4c4c, 
+  0x4d4d4d, 0x4d4d4d, (1U<<31) | 6492, 0x4c4c4d, (1U<<31) | 6322, 0x4c4c4d, (1U<<31) | 6322, 0x4c4c4c, 
+  0x4d4d4d, 0x4d4d4d, (1U<<31) | 6492, 0x4c4c4c, 0x4d4d4d, 0x4c4c4c, 0x4d4d4d, 0x4d4d4d, 
+  (1U<<31) | 6492, 0x4c4c4d, (1U<<31) | 6322, 0x4c4c4c, 0x4d4d4d, 0x4d4d4d, (1U<<31) | 6492, 0x4c4c4c, 
+  0x4d4d4d, 0x4d4d4d, (1U<<31) | 6492, (1U<<31) | 6177, (1U<<31) | 6292, (1U<<31) | 6177, (1U<<31) | 6292, 0x4c4c4c, 
+  0x4d4d4d, 0x4d4d4d, (1U<<31) | 6492, (1U<<31) | 6186, (1U<<31) | 6301, 0x44d4d, (1U<<31) | 4980, 0x44d4d4d, 
+  (1U<<31) | 4978, 0x44d4d, (1U<<31) | 4980, 0x44d4d4d, (1U<<31) | 4978, 0x44d4d, (1U<<31) | 4980, 0x44d4d4d, 
+  (1U<<31) | 4978, 0x4c4d, (1U<<31) | 6332, 0x4c4d, (1U<<31) | 6332, 0x4c4d4d, (1U<<31) | 6347, 0x4c4d4d, 
+  (1U<<31) | 6347, 0x4c4d, (1U<<31) | 6332, 0x4c4d, (1U<<31) | 6332, 0x4c4c4c, 0x4d4d4d, 0x4c4d, 
+  (1U<<31) | 6332, 0x4c4d, (1U<<31) | 6332, 0x2e0, 0x2e0, 0x2e0, 0x2e0, 0x2e0, 
+  0x42e0, 0x52e0, 0x442e2e2e, 0x442e2e2e, 0x442e2e2e, 0x442e2e2e, 0x442e2e2e, 0x442e2e2e, 
+  0x4442e2e, 0x4452e2e, 0x4442e2e, 0x4442e2e, 0x4442e2e, 0x2e0, 0x42e2e0, 0x442e0, 
+  0x3939, 0x2a2a, 0x44, 0x2c2c2c, 0x595959, 0x3b3b3b, 0x4a4a4a, 0x393939, 
+  0x393939, 0x444, 0x393939, 0x393939, 0x444, 0x444, 0x2c2c2c, 0x595959, 
+  0x3b3b3b, 0x4a4a4a, 0x2c2c2c, 0x595959, 0x3b3b3b, 0x4a4a4a, 0x2c2c2c, 0x595959, 
+  0x3b3b3b, 0x4a4a4a, 0x444, 0x393939, 0x2a2a2a, 0x393939, 0x2a2a2a, 0x2a2a2a, 
+  0x2a2a2a, 0x2c2c2c, 0x595959, 0x3b3b3b, 0x4a4a4a, 0x42c2c, 0x45959, 0x43b3b, 
+  0x44a4a, 0x444, 0x2c2c2c, 0x42c2c, 0x4444, 0x2c2c2c, 0x595959, 0x3b3b3b, 
   0x4a4a4a, 0x2c2c2c, 0x595959, 0x3b3b3b, 0x4a4a4a, 0x2c2c2c, 0x595959, 0x3b3b3b, 
   0x4a4a4a, 0x2c2c2c, 0x595959, 0x3b3b3b, 0x4a4a4a, 0x2c2c2c, 0x595959, 0x3b3b3b, 
-  0x4a4a4a, 0x4444, 0x2c2c2c, 0x595959, 0x3b3b3b, 0x4a4a4a, 0x42c2c, 0x45959, 
-  0x43b3b, 0x44a4a, 0x2c2c2c2c, 0x59595959, 0x3b3b3b3b, 0x4a4a4a4a, 0x42c2c2c, 0x4595959, 
-  0x43b3b3b, 0x44a4a4a, 0x2c2c2c2c, 0x59595959, 0x3b3b3b3b, 0x4a4a4a4a, 0x42c2c2c, 0x4595959, 
-  0x43b3b3b, 0x44a4a4a, 0x44, 0x2c2c2c2c, 0x42c2c2c, 0x2c2c2c2c, 0x42c2c2c, 0x2c2c2c, 
-  0x595959, 0x3b3b3b, 0x4a4a4a, 0x42c2c, 0x45959, 0x43b3b, 0x44a4a, 0x2c4, 
-  0x594, 0x3b4, 0x2c4, 0x4a4, 0x4, 0x2c2c2c2c, 0x42c2c2c, 0x2c2c2c, 
-  0x595959, 0x3b3b3b, 0x4a4a4a, 0x42c2c, 0x45959, 0x43b3b, 0x44a4a, 0x2c4, 
-  0x594, 0x3b4, 0x2c4, 0x4a4, 0x2c2c2c, 0x595959, 0x3b3b3b, 0x4a4a4a, 
-  0x42c2c, 0x45959, 0x43b3b, 0x44a4a, 0x44, 0x2c2c2c, 0x595959, 0x3b3b3b, 
-  0x4a4a4a, 0x2c2c2c, 0x595959, 0x3b3b3b, 0x4a4a4a, 0x42c2c, 0x45959, 0x43b3b, 
-  0x44a4a, 0x42c2c, 0x45959, 0x43b3b, 0x44a4a, 0x2c2c2c, 0x595959, 0x3b3b3b, 
-  0x4a4a4a, 0x2c2c2c, 0x595959, 0x3b3b3b, 0x4a4a4a, 0x42c2c, 0x45959, 0x43b3b, 
-  0x44a4a, 0x42c2c, 0x45959, 0x43b3b, 0x44a4a, 0x39390, 0x39390, 0x39390, 
-  0x2a2a4, 0x2a2a4, 0x2a2a4, 0x2a2a4, 0x2a2a4, 0x2a2a4, 0x2a2a0, 0x2a2a0, 
-  0x2a2a0, 0x42c4, 0x4595, 0x43b4, 0x44a4, 0x42c4, 0x4595, 0x43b4, 
-  0x44a4, 0x440, 0x2c2c2c, 0x595959, 0x3b3b3b, 0x4a4a4a, 0x2c2c2c, 0x595959, 
-  0x3b3b3b, 0x4a4a4a, 0x4555, 0x4a4a59, 0x2c2c3b, 0x3b3b4a, 0x4a4a59, 0x2c2c3b, 
-  0x3b3b4a, 0x393955, 0x4a4a5959, 0x2c2c3b3b, 0x3b3b4a4a, 0x4a4a5959, 0x2c2c3b3b, 0x3b3b4a4a, 
-  0x393955, 0x4455, 0x393955, 0x393955, 0x2a2a55, 0x2a2a55, 0x393955, 0x393955, 
-  0x393955, 0x4455, 0x393955, 0x393955, 0x2a2a55, 0x2a2a55, 0x4a4a5959, 0x2c2c3b3b, 
-  0x3b3b4a4a, 0x4a4a5959, 0x2c2c3b3b, 0x3b3b4a4a, 0x393955, 0x454, 0x454, 0x454, 
-  0x454, 0x454, 0x454, 0x898989, 0x7a7a7a, 0x898959, 0x7a7a4a, 0x898959, 
-  0x7a7a4a, 0x8959, 0x7a4a, 0x898959, 0x7a7a4a, 0x898959, 0x7a7a4a, 0x898959, 
-  0x7a7a4a, 0x898959, 0x7a7a4a, 0x898959, 0x7a7a4a, 0x898959, 0x7a7a4a, 0x898959, 
-  0x7a7a4a, 0x898959, 0x7a7a4a, 0x898959, 0x7a7a4a, 0x898989, 0x7a7a7a, 0x7a7a6b, 
-  0x89897a, 0x598989, 0x4a7a7a, 0x7a89, 0x6b7a, 0x7a89, 0x6b7a, 0x5989, 
-  0x4a7a, 0x5989, 0x4a7a, 0x4a89, 0x3b7a, 0x4a89, 0x3b7a, 0x42c, 
-  0x559, 0x43b, 0x44a, 0x8989, 0x7a7a, (1U<<31) | 6224, 0x7a7a7a7a, 0x898989, 
-  0x7a7a7a, 0x898989, 0x7a7a7a, 0x898989, 0x7a7a7a, 0x898989, 0x7a7a7a, (1U<<31) | 6224, 
-  0x7a7a7a7a, 0x898989, 0x7a7a7a, 0x8989, 0x7a7a, 0x8989, 0x7a7a, 0x8989, 
-  0x7a7a, 0x898959, 0x7a7a4a, 0x898959, 0x7a7a4a, 0x898959, 0x7a7a4a, 0x898959, 
-  0x7a7a4a, 0x898959, 0x7a7a4a, 0x898959, 0x7a7a4a, 0x8989, 0x7a7a, 0x898989, 
-  0x7a7a7a, 0x898959, 0x7a7a4a, 0x898959, 0x7a7a4a, 0x898959, 0x7a7a4a, 0x898959, 
-  0x7a7a4a, 0x898959, 0x7a7a4a, 0x8959, 0x7a4a, 0x8959, 0x7a4a, 0x7a7a3b, 
-  0x89894a, 0x8959, 0x7a4a, 0x8959, 0x7a4a, 0x4a4a59, 0x2c2c3b, 0x3b3b4a, 
-  0x4a4a59, 0x2c2c3b, 0x3b3b4a, 0x4a4a59, 0x2c2c3b, 0x3b3b4a, 0x4a4a59, 0x2c2c3b, 
-  0x3b3b4a, 0x2c2c2c, 0x595959, 0x3b3b3b, 0x4a4a4a, 0x2c2c2c, 0x595959, 0x3b3b3b, 
-  0x4a4a4a, 0x2c2c2c, 0x595959, 0x3b3b3b, 0x4a4a4a, 0x2c2c2c, 0x595959, 0x3b3b3b, 
-  0x4a4a4a, 0x442c2c, 0x545959, 0x443b3b, 0x444a4a, 0x444, 0x2c42c2c, 0x5945959, 
-  0x3b43b3b, 0x4a44a4a, 0x42e4, 0x42e2c, 0x42e59, 0x42e3b, 0x42e4a, 0x42c, 
-  0x459, 0x43b, 0x44a, 0x42e4, 0x4444, 0x42e4, 0x4455, 0x3b3b3b3b, 
-  0x4a4a4a4a, 0x3b3b3b3b, 0x4a4a4a4a, 0x4455, 0x2c2c2c2c, 0x59595959, 0x3b3b3b3b, 0x4a4a4a4a, 
-  0x393955, 0x393955, 0x393955, 0x393955, 0x2c2c2c, 0x595959, 0x3b3b3b, 0x4a4a4a, 
-  0x2c2c2c, 0x595959, 0x3b3b3b, 0x4a4a4a, 0x2c2c2c, 0x595959, 0x3b3b3b, 0x4a4a4a, 
-  0x42c2c, 0x45959, 0x43b3b, 0x44a4a, 0x42c2c, 0x45959, 0x43b3b, 0x44a4a, 
-  0x2c2c2c, 0x595959, 0x3b3b3b, 0x4a4a4a, 0x2c2c2c, 0x595959, 0x3b3b3b, 0x4a4a4a, 
+  0x4a4a4a, 0x2c2c2c, 0x595959, 0x3b3b3b, 0x4a4a4a, 0x4444, 0x2c2c2c, 0x595959, 
+  0x3b3b3b, 0x4a4a4a, 0x42c2c, 0x45959, 0x43b3b, 0x44a4a, 0x2c2c2c2c, 0x59595959, 
+  0x3b3b3b3b, 0x4a4a4a4a, 0x42c2c2c, 0x4595959, 0x43b3b3b, 0x44a4a4a, 0x2c2c2c2c, 0x59595959, 
+  0x3b3b3b3b, 0x4a4a4a4a, 0x42c2c2c, 0x4595959, 0x43b3b3b, 0x44a4a4a, 0x44, 0x2c2c2c2c, 
+  0x42c2c2c, 0x2c2c2c2c, 0x42c2c2c, 0x2c2c2c, 0x595959, 0x3b3b3b, 0x4a4a4a, 0x42c2c, 
+  0x45959, 0x43b3b, 0x44a4a, 0x2c4, 0x594, 0x3b4, 0x2c4, 0x4a4, 
+  0x4, 0x2c2c2c2c, 0x42c2c2c, 0x2c2c2c, 0x595959, 0x3b3b3b, 0x4a4a4a, 0x42c2c, 
+  0x45959, 0x43b3b, 0x44a4a, 0x2c4, 0x594, 0x3b4, 0x2c4, 0x4a4, 
   0x2c2c2c, 0x595959, 0x3b3b3b, 0x4a4a4a, 0x42c2c, 0x45959, 0x43b3b, 0x44a4a, 
-  0x42c2c, 0x45959, 0x43b3b, 0x44a4a, 0x2c2c2c, 0x595959, 0x3b3b3b, 0x4a4a4a, 
-  0x2c2c2c, 0x595959, 0x3b3b3b, 0x4a4a4a, 0x444, 0x2c2c, 0x4455, 0x3b3b3b3b, 
-  0x4a4a4a4a, 0x3b3b3b3b, 0x4a4a4a4a, 0x4455, 0x2c2c2c2c, 0x59595959, 0x3b3b3b3b, 0x4a4a4a4a, 
-  0x455, 0x393939, 0x3b3b3b, 0x4a4a4a, 0x393939, 0x39394, 0x39394, 0x392a39, 
-  0x392a39, 0x393939, 0x444, 0x393939, 0x444, 0x3b3b3b, 0x4a4a4a, 0x393955, 
-  0x393955, 0x445, 0x445, 0x2c2c2c, 0x595959, 0x3b3b3b, 0x4a4a4a, 0x2c2c, 
-  0x5959, 0x3b3b, 0x4a4a, 0x2c2c, 0x5959, 0x3b3b, 0x4a4a, 0x2c2c2c, 
-  0x42c2c, 0x2c2c2c, 0x42c2c, 0x393939, 0x2c2c2c, 0x595959, 0x3b3b3b, 0x4a4a4a, 
-  0x2c2c2c, 0x595959, 0x3b3b3b, 0x4a4a4a, 0x2c2c, 0x5959, 0x3b3b, 0x4a4a, 
-  0x393939, 0x2a2a2a, 0x394, 0x394, 0x2a39, 0x2a39, 0x2a39, 0x2a39, 
-  0x2a39, 0x2a39, 0x2a39, 0x2a39, 0x39392a, 0x44439, 0x44439, 0x4439, 
-  0x39392a, 0x4439, 0x39392a, 0x4444, 0x2a4, 0x44, 0x439, 0x42a, 
-  0x42c2c, 0x45959, 0x43b3b, 0x44a4a, 0x42c2c, 0x45959, 0x43b3b, 0x44a4a, 
-  0x42c2c, 0x43b3b, 0x44a4a, 0x455, 0x43939, 0x42a2a, 0x43939, 0x444, 
-  0x43939, 0x42a2a, 0x43939, 0x42a2a, 0x444, 0x43939, 0x42a2a, 0x42c2c2c, 
-  0x4595959, 0x43b3b3b, 0x44a4a4a, 0x42c2c2c, 0x4595959, 0x43b3b3b, 0x44a4a4a, 0x2c2c2c, 
-  0x595959, 0x3b3b3b, 0x4a4a4a, 0x42c2c, 0x45959, 0x43b3b, 0x44a4a, 0x42c2c, 
-  0x45959, 0x43b3b, 0x44a4a, 0x42c2c, 0x45959, 0x43b3b, 0x44a4a, 0x2c2c2c, 
-  0x595959, 0x3b3b3b, 0x4a4a4a, 0x42c2c, 0x45959, 0x43b3b, 0x44a4a, 0x2c2c2c, 
-  0x595959, 0x3b3b3b, 0x4a4a4a, 0x42c2c, 0x45959, 0x43b3b, 0x44a4a, 0x2c2c2c, 
-  0x595959, 0x3b3b3b, 0x4a4a4a, 0x42c2c, 0x45959, 0x43b3b, 0x44a4a, 0x2c2c2c, 
-  0x595959, 0x3b3b3b, 0x4a4a4a, 0x42c2c, 0x45959, 0x43b3b, 0x44a4a, 0x42e2c0, 
-  0x42e590, 0x42e3b0, 0x42e4a0, 0x393939, 0x393939, 0x444, 0x393939, 0x393939, 
+  0x44, 0x2c2c2c, 0x595959, 0x3b3b3b, 0x4a4a4a, 0x2c2c2c, 0x595959, 0x3b3b3b, 
+  0x4a4a4a, 0x42c2c, 0x45959, 0x43b3b, 0x44a4a, 0x42c2c, 0x45959, 0x43b3b, 
+  0x44a4a, 0x2c2c2c, 0x595959, 0x3b3b3b, 0x4a4a4a, 0x2c2c2c, 0x595959, 0x3b3b3b, 
+  0x4a4a4a, 0x42c2c, 0x45959, 0x43b3b, 0x44a4a, 0x42c2c, 0x45959, 0x43b3b, 
+  0x44a4a, 0x39390, 0x39390, 0x39390, 0x2a2a4, 0x2a2a4, 0x2a2a4, 0x2a2a4, 
+  0x2a2a4, 0x2a2a4, 0x2a2a0, 0x2a2a0, 0x2a2a0, 0x42c4, 0x4595, 0x43b4, 
+  0x44a4, 0x42c4, 0x4595, 0x43b4, 0x44a4, 0x440, 0x2c2c2c, 0x595959, 
+  0x3b3b3b, 0x4a4a4a, 0x2c2c2c, 0x595959, 0x3b3b3b, 0x4a4a4a, 0x4555, 0x4a4a59, 
+  0x2c2c3b, 0x3b3b4a, 0x4a4a59, 0x2c2c3b, 0x3b3b4a, 0x393955, 0x4a4a5959, 0x2c2c3b3b, 
+  0x3b3b4a4a, 0x4a4a5959, 0x2c2c3b3b, 0x3b3b4a4a, 0x393955, 0x4455, 0x393955, 0x393955, 
+  0x2a2a55, 0x2a2a55, 0x393955, 0x393955, 0x393955, 0x4455, 0x393955, 0x393955, 
+  0x2a2a55, 0x2a2a55, 0x4a4a5959, 0x2c2c3b3b, 0x3b3b4a4a, 0x4a4a5959, 0x2c2c3b3b, 0x3b3b4a4a, 
+  0x393955, 0x454, 0x454, 0x454, 0x454, 0x454, 0x454, 0x898989, 
+  0x7a7a7a, 0x898959, 0x7a7a4a, 0x898959, 0x7a7a4a, 0x8959, 0x7a4a, 0x898959, 
+  0x7a7a4a, 0x898959, 0x7a7a4a, 0x898959, 0x7a7a4a, 0x898959, 0x7a7a4a, 0x898959, 
+  0x7a7a4a, 0x898959, 0x7a7a4a, 0x898959, 0x7a7a4a, 0x898959, 0x7a7a4a, 0x898959, 
+  0x7a7a4a, 0x898989, 0x7a7a7a, 0x7a7a6b, 0x89897a, 0x598989, 0x4a7a7a, 0x7a89, 
+  0x6b7a, 0x7a89, 0x6b7a, 0x5989, 0x4a7a, 0x5989, 0x4a7a, 0x4a89, 
+  0x3b7a, 0x4a89, 0x3b7a, 0x42c, 0x559, 0x43b, 0x44a, 0x8989, 
+  0x7a7a, (1U<<31) | 8311, 0x7a7a7a7a, 0x898989, 0x7a7a7a, 0x898989, 0x7a7a7a, 0x898989, 
+  0x7a7a7a, 0x898989, 0x7a7a7a, (1U<<31) | 8311, 0x7a7a7a7a, 0x898989, 0x7a7a7a, 0x8989, 
+  0x7a7a, 0x8989, 0x7a7a, 0x8989, 0x7a7a, 0x898959, 0x7a7a4a, 0x898959, 
+  0x7a7a4a, 0x898959, 0x7a7a4a, 0x898959, 0x7a7a4a, 0x898959, 0x7a7a4a, 0x898959, 
+  0x7a7a4a, 0x8989, 0x7a7a, 0x898989, 0x7a7a7a, 0x898959, 0x7a7a4a, 0x898959, 
+  0x7a7a4a, 0x898959, 0x7a7a4a, 0x898959, 0x7a7a4a, 0x898959, 0x7a7a4a, 0x8959, 
+  0x7a4a, 0x8959, 0x7a4a, 0x7a7a3b, 0x89894a, 0x8959, 0x7a4a, 0x8959, 
+  0x7a4a, 0x4a4a59, 0x2c2c3b, 0x3b3b4a, 0x4a4a59, 0x2c2c3b, 0x3b3b4a, 0x4a4a59, 
+  0x2c2c3b, 0x3b3b4a, 0x4a4a59, 0x2c2c3b, 0x3b3b4a, 0x2c2c2c, 0x595959, 0x3b3b3b, 
+  0x4a4a4a, 0x2c2c2c, 0x595959, 0x3b3b3b, 0x4a4a4a, 0x2c2c2c, 0x595959, 0x3b3b3b, 
+  0x4a4a4a, 0x2c2c2c, 0x595959, 0x3b3b3b, 0x4a4a4a, 0x442c2c, 0x545959, 0x443b3b, 
+  0x444a4a, 0x444, 0x2c42c2c, 0x5945959, 0x3b43b3b, 0x4a44a4a, 0x42e4, 0x42e2c, 
+  0x42e59, 0x42e3b, 0x42e4a, 0x42c, 0x459, 0x43b, 0x44a, 0x42e59, 
+  0x42e4a, 0x42e4, 0x4444, 0x42e4, 0x4455, 0x3b3b3b3b, 0x4a4a4a4a, 0x3b3b3b3b, 
+  0x4a4a4a4a, 0x4455, 0x2c2c2c2c, 0x59595959, 0x3b3b3b3b, 0x4a4a4a4a, 0x393955, 0x393955, 
+  0x393955, 0x393955, 0x2c2c2c, 0x595959, 0x3b3b3b, 0x4a4a4a, 0x2c2c2c, 0x595959, 
+  0x3b3b3b, 0x4a4a4a, 0x2c2c2c, 0x595959, 0x3b3b3b, 0x4a4a4a, 0x42c2c, 0x45959, 
+  0x43b3b, 0x44a4a, 0x42c2c, 0x45959, 0x43b3b, 0x44a4a, 0x2c2c2c, 0x595959, 
+  0x3b3b3b, 0x4a4a4a, 0x2c2c2c, 0x595959, 0x3b3b3b, 0x4a4a4a, 0x2c2c2c, 0x595959, 
+  0x3b3b3b, 0x4a4a4a, 0x42c2c, 0x45959, 0x43b3b, 0x44a4a, 0x42c2c, 0x45959, 
+  0x43b3b, 0x44a4a, 0x2c2c2c, 0x595959, 0x3b3b3b, 0x4a4a4a, 0x2c2c2c, 0x595959, 
+  0x3b3b3b, 0x4a4a4a, 0x444, 0x2c2c, 0x4455, 0x3b3b3b3b, 0x4a4a4a4a, 0x3b3b3b3b, 
+  0x4a4a4a4a, 0x4455, 0x2c2c2c2c, 0x59595959, 0x3b3b3b3b, 0x4a4a4a4a, 0x455, 0x393939, 
+  0x3b3b3b, 0x4a4a4a, 0x393939, 0x39394, 0x39394, 0x392a39, 0x392a39, 0x393939, 
+  0x444, 0x393939, 0x444, 0x3b3b3b, 0x4a4a4a, 0x393955, 0x393955, 0x445, 
+  0x445, 0x2c2c2c, 0x595959, 0x3b3b3b, 0x4a4a4a, 0x2c2c, 0x5959, 0x3b3b, 
+  0x4a4a, 0x2c2c, 0x5959, 0x3b3b, 0x4a4a, 0x2c2c2c, 0x42c2c, 0x2c2c2c, 
+  0x42c2c, 0x393939, 0x2c2c2c, 0x595959, 0x3b3b3b, 0x4a4a4a, 0x2c2c2c, 0x595959, 
+  0x3b3b3b, 0x4a4a4a, 0x2c2c, 0x5959, 0x3b3b, 0x4a4a, 0x393939, 0x2a2a2a, 
+  0x394, 0x394, 0x2a39, 0x2a39, 0x2a39, 0x2a39, 0x2a39, 0x2a39, 
+  0x2a39, 0x2a39, 0x39392a, 0x44439, 0x44439, 0x4439, 0x39392a, 0x4439, 
+  0x39392a, 0x4444, 0x2a4, 0x44, 0x439, 0x42a, 0x42c2c, 0x45959, 
+  0x43b3b, 0x44a4a, 0x42c2c, 0x45959, 0x43b3b, 0x44a4a, 0x42c2c, 0x43b3b, 
+  0x44a4a, 0x455, 0x43939, 0x42a2a, 0x43939, 0x444, 0x43939, 0x42a2a, 
+  0x43939, 0x42a2a, 0x444, 0x43939, 0x42a2a, 0x42c2c2c, 0x4595959, 0x43b3b3b, 
+  0x44a4a4a, 0x42c2c2c, 0x4595959, 0x43b3b3b, 0x44a4a4a, 0x2c2c2c, 0x595959, 0x3b3b3b, 
+  0x4a4a4a, 0x42c2c, 0x45959, 0x43b3b, 0x44a4a, 0x42c2c, 0x45959, 0x43b3b, 
+  0x44a4a, 0x42c2c, 0x45959, 0x43b3b, 0x44a4a, 0x2c2c2c, 0x595959, 0x3b3b3b, 
+  0x4a4a4a, 0x42c2c, 0x45959, 0x43b3b, 0x44a4a, 0x2c2c2c, 0x595959, 0x3b3b3b, 
+  0x4a4a4a, 0x42c2c, 0x45959, 0x43b3b, 0x44a4a, 0x2c2c2c, 0x595959, 0x3b3b3b, 
+  0x4a4a4a, 0x42c2c, 0x45959, 0x43b3b, 0x44a4a, 0x2c2c2c, 0x595959, 0x3b3b3b, 
+  0x4a4a4a, 0x42c2c, 0x45959, 0x43b3b, 0x44a4a, 0x42e2c0, 0x42e590, 0x42e3b0, 
+  0x42e4a0, 0x42e590, 0x42e4a0, 0x393939, 0x393939, 0x444, 0x393939, 0x393939, 
   0x444, 0x444, 0x2c2c2c, 0x595959, 0x3b3b3b, 0x4a4a4a, 0x2c2c2c, 0x595959, 
   0x3b3b3b, 0x4a4a4a, 0x2c2c2c, 0x595959, 0x3b3b3b, 0x4a4a4a, 0x2c2c2c, 0x595959, 
   0x3b3b3b, 0x4a4a4a, 0x393939, 0x2a2a2a, 0x393939, 0x2a2a2a, 0x2a2a2a, 0x2a2a2a, 
@@ -8412,978 +11627,1491 @@
   0x777, 0x777, 0x888, 0x777, 0x777, 0x888, 0x777, 0x777, 
   0x888, 0x777, 0x777, 0x7fcf2f, 0x7fcf2f, 0x7fcf1f, 0x7fcf1f, 0x7fcf1f, 
   0x7fcf1f, 0x7f7fcf1f, 0x7f7fcf1f, 0x7fcf1f, 0x7fcf1f, 0x7fcf1f, 0x7fcf1f, 0x7fcf1f, 
-  0x7fcf1f, 0x74f7, 0x84f8, 0x44f4, 0x44f4, 0x7fcf1f, 0x7fcf1f, 0x7fcf1f, 
-  0x7fcf1f, 0x7fcf1f, 0x7fcf1f, 0x7fcf1f, 0x7fcf1f, 0x40, 0x40, 0x440, 
-  0x40, 0x40, 0x440, 0x0, 0x44, 0x44, 0x44, 0x85, 
-  0x74, 0x47, 0x58, 0x88, 0x77, 0x77, 0x4f0, 0x4f0, 
-  0x77, 0x77, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 
-  0x87, 0x87, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 
-  0x85, 0x85, 0x85, 0x85, 0x84, 0x84, 0x84, 0x84, 
-  0x85, 0x85, 0x85, 0x85, 0x777, 0x777, 0x888, 0x777, 
-  0x777, 0x888, 0x777, 0x777, 0x888, 0x777, 0x777, 0x888, 
-  0x777, 0x777, 0x88, 0x77, 0x77, 0x73, 0x73, 0x74, 
-  0x74, 0x74, 0x74, 0x74, 0x74, 0x74, 0x74, 0x75, 
-  0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x74, 
-  0x74, 0x74, 0x74, 0x74, 0x74, 0x74, 0x74, 0x75, 
-  0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x88, 
-  0x77, 0x77, 0x88, 0x77, 0x77, 0x8888, 0x7777, 0x7777, 
-  0x8888, 0x7777, 0x7777, 0x8888, 0x7777, 0x7777, 0x8888, 0x7777, 
-  0x7777, 0x888, 0x777, 0x777, 0x888, 0x777, 0x777, 0x4444, 
-  0x48, 0x48, 0x48, 0x48, 0x47, 0x47, 0x47, 0x47, 
-  0x2e1, 0x2e1, 0x2e1, 0x2e1, 0x51, 0x51, 0x51, 0x4cf2f, 
-  0x4cf1f, 0x4cf4f, 0x4cf2f, 0x4cf1f, 0x4cf4f, 0x88, 0x77, 0x77, 
-  0x58, 0x58, 0x58, 0x58, 0x57, 0x57, 0x57, 0x57, 
-  0x448, (1U<<31) | 3075, (1U<<31) | 5222, 0x444, 0x545, 0x0, 0x0, 0x0, 
-  0x88, 0x77, 0x33, 0x44, 0x55, 0xcf4f, 0x888, 0x777, 
-  0x777, 0x888, 0x777, 0x777, 0x888, 0x777, 0x777, 0x888, 
-  0x777, 0x777, 0x444, 0x444, 0x444, 0x555, 0x444, 0x555, 
-  0x4444, 0xcf4f, 0xcf4f, 0xcf4f, 0xcf4f, 0xcf4f, 0xcf4f, 0xcf4f, 
-  0xcf4f, 0xcf4f, 0x88, 0x88, 0x77, 0x77, 0x88, 0x77, 
-  0x77, 0x88, 0x77, 0x77, 0x88, 0x77, 0x77, 0x4, 
-  0x5, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 
-  0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 
-  0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 
-  0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 
-  0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 
-  0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 
-  0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 
-  0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 
-  0x4, 0x4f4, 0x444, 0x455, 0x455, 0x88, 0x77, 0x77, 
-  0x88, 0x77, 0x77, 0x4444, 0x4444, 0x88, 0x77, 0x77, 
-  0x4477, 0x4444, 0x4477, 0x4444, 0x4477, 0x4444, 0x44747, 0x44444, 
-  0x44747, 0x44444, 0x44747, 0x44444, 0x44747, 0x44444, 0x4477, 0x4444, 
-  0x77, 0x77, 0x77, 0x77, 0x77, 0x88, 0x77, 0x77, 
+  0x7fcf1f, 0x44f4, 0x44f4, 0x7fcf1f, 0x7fcf1f, 0x7fcf1f, 0x7fcf1f, 0x7fcf1f, 
+  0x7fcf1f, 0x7fcf1f, 0x7fcf1f, 0x40, 0x40, 0x440, 0x40, 0x40, 
+  0x440, 0x0, 0x44, 0x44, 0x44, 0x85, 0x74, 0x47, 
+  0x58, 0x88, 0x77, 0x77, 0x4f0, 0x4f0, 0x77, 0x77, 
+  0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 
+  0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x85, 0x85, 
+  0x85, 0x85, 0x84, 0x84, 0x84, 0x84, 0x85, 0x85, 
+  0x85, 0x85, 0x777, 0x777, 0x888, 0x777, 0x777, 0x888, 
+  0x777, 0x777, 0x888, 0x777, 0x777, 0x888, 0x777, 0x777, 
+  0x88, 0x77, 0x77, 0x73, 0x73, 0x74, 0x74, 0x74, 
+  0x74, 0x74, 0x74, 0x74, 0x74, 0x75, 0x75, 0x75, 
+  0x75, 0x75, 0x75, 0x75, 0x75, 0x74, 0x74, 0x74, 
+  0x74, 0x74, 0x74, 0x74, 0x74, 0x75, 0x75, 0x75, 
+  0x75, 0x75, 0x75, 0x75, 0x75, 0x88, 0x77, 0x77, 
+  0x88, 0x77, 0x77, 0x8888, 0x7777, 0x7777, 0x8888, 0x7777, 
+  0x7777, 0x8888, 0x7777, 0x7777, 0x8888, 0x7777, 0x7777, 0x888, 
+  0x777, 0x777, 0x888, 0x777, 0x777, 0x4444, 0x48, 0x48, 
+  0x48, 0x48, 0x47, 0x47, 0x47, 0x47, 0x2e1, 0x2e1, 
+  0x2e1, 0x2e1, 0x51, 0x51, 0x51, 0x4cf2f, 0x4cf1f, 0x4cf4f, 
+  0x4cf2f, 0x4cf1f, 0x4cf4f, 0x88, 0x77, 0x77, 0x58, 0x58, 
+  0x58, 0x58, 0x57, 0x57, 0x57, 0x57, 0x448, (1U<<31) | 3581, 
+  (1U<<31) | 6559, 0x444, 0x545, 0x0, 0x0, 0x0, (1U<<31) | 6965, (1U<<31) | 6991, 
+  (1U<<31) | 7629, (1U<<31) | 6965, (1U<<31) | 6991, (1U<<31) | 7629, (1U<<31) | 6965, (1U<<31) | 6991, (1U<<31) | 7629, (1U<<31) | 6965, 
+  (1U<<31) | 6991, (1U<<31) | 7629, 0x88, 0x77, 0x33, 0x44, 0x55, 0xcf4f, 
+  0x888, 0x777, 0x777, 0x888, 0x777, 0x777, 0x888, 0x777, 
+  0x777, 0x888, 0x777, 0x777, 0x444, 0x444, 0x444, 0x555, 
+  0x444, 0x555, 0x4444, 0xcf4f, 0xcf4f, 0xcf4f, 0xcf4f, 0xcf4f, 
+  0xcf4f, 0xcf4f, 0xcf4f, 0xcf4f, 0x88, 0x88, 0x77, 0x77, 
   0x88, 0x77, 0x77, 0x88, 0x77, 0x77, 0x88, 0x77, 
-  0x77, 0x4453, 0x4453, 0x4453, 0x4454, 0x4454, 0x4454, 0x4455, 
-  0x4455, 0x4455, 0x4453, 0x4453, 0x4453, (1U<<31) | 3756, (1U<<31) | 3756, (1U<<31) | 3756, 
-  (1U<<31) | 3772, (1U<<31) | 3772, (1U<<31) | 3772, (1U<<31) | 3789, (1U<<31) | 3789, (1U<<31) | 3789, (1U<<31) | 3756, (1U<<31) | 3756, 
-  (1U<<31) | 3756, (1U<<31) | 3747, (1U<<31) | 3747, (1U<<31) | 3747, (1U<<31) | 3763, (1U<<31) | 3763, (1U<<31) | 3763, (1U<<31) | 3747, 
-  (1U<<31) | 3747, (1U<<31) | 3747, 0x453, 0x453, 0x453, 0x454, 0x454, 0x454, 
-  0x455, 0x455, 0x455, 0x453, 0x453, 0x453, (1U<<31) | 4254, (1U<<31) | 4254, 
-  (1U<<31) | 4254, (1U<<31) | 4268, (1U<<31) | 4268, (1U<<31) | 4268, (1U<<31) | 4290, (1U<<31) | 4290, (1U<<31) | 4290, (1U<<31) | 4254, 
-  (1U<<31) | 4254, (1U<<31) | 4254, (1U<<31) | 4246, (1U<<31) | 4246, (1U<<31) | 4246, (1U<<31) | 4260, (1U<<31) | 4260, (1U<<31) | 4260, 
-  (1U<<31) | 4246, (1U<<31) | 4246, (1U<<31) | 4246, 0x44453, 0x44453, 0x44453, 0x44454, 0x44454, 
-  0x44454, 0x44455, 0x44455, 0x44455, 0x44453, 0x44453, 0x44453, (1U<<31) | 3376, 
-  (1U<<31) | 3376, (1U<<31) | 3376, (1U<<31) | 3394, (1U<<31) | 3394, (1U<<31) | 3394, (1U<<31) | 3413, (1U<<31) | 3413, (1U<<31) | 3413, 
-  (1U<<31) | 3376, (1U<<31) | 3376, (1U<<31) | 3376, (1U<<31) | 3366, (1U<<31) | 3366, (1U<<31) | 3366, (1U<<31) | 3384, (1U<<31) | 3384, 
-  (1U<<31) | 3384, (1U<<31) | 3366, (1U<<31) | 3366, (1U<<31) | 3366, 0x4453, 0x4453, 0x4453, 0x4454, 
-  0x4454, 0x4454, 0x4455, 0x4455, 0x4455, 0x4453, 0x4453, 0x4453, 
-  (1U<<31) | 3756, (1U<<31) | 3756, (1U<<31) | 3756, (1U<<31) | 3772, (1U<<31) | 3772, (1U<<31) | 3772, (1U<<31) | 3789, (1U<<31) | 3789, 
-  (1U<<31) | 3789, (1U<<31) | 3756, (1U<<31) | 3756, (1U<<31) | 3756, (1U<<31) | 3747, (1U<<31) | 3747, (1U<<31) | 3747, (1U<<31) | 3763, 
-  (1U<<31) | 3763, (1U<<31) | 3763, (1U<<31) | 3747, (1U<<31) | 3747, (1U<<31) | 3747, 0x44453, 0x44453, 0x44453, 
+  0x77, 0x4, 0x5, 0x4, 0x4, 0x4, 0x4, 0x4, 
+  0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 
+  0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 
+  0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 
+  0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 
+  0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 
+  0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 
+  0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 
+  0x4, 0x4, 0x4, 0x4f4, 0x444, 0x455, 0x455, 0x88, 
+  0x77, 0x77, 0x88, 0x77, 0x77, 0x4444, 0x4444, 0x88, 
+  0x77, 0x77, 0x4477, (1U<<31) | 4519, 0x4444, (1U<<31) | 3650, 0x4477, (1U<<31) | 4519, 
+  0x4444, (1U<<31) | 3650, 0x4477, (1U<<31) | 4519, 0x4444, (1U<<31) | 3650, 0x44747, (1U<<31) | 4526, 
+  0x44444, (1U<<31) | 3676, 0x44747, (1U<<31) | 4526, 0x44444, (1U<<31) | 3676, 0x44747, (1U<<31) | 4526, 
+  0x44444, (1U<<31) | 3676, 0x44747, (1U<<31) | 4526, 0x44444, (1U<<31) | 3676, 0x4477, (1U<<31) | 4519, 
+  0x4444, (1U<<31) | 3650, 0x77, 0x77, 0x77, 0x77, 0x77, 0x88, 
+  0x77, 0x77, 0x88, 0x77, 0x77, 0x88, 0x77, 0x77, 
+  0x88, 0x77, 0x77, 0x4453, 0x4453, 0x4453, 0x4454, 0x4454, 
+  0x4454, 0x4455, 0x4455, 0x4455, 0x4453, 0x4453, 0x4453, (1U<<31) | 4460, 
+  (1U<<31) | 4460, (1U<<31) | 4460, (1U<<31) | 4476, (1U<<31) | 4476, (1U<<31) | 4476, (1U<<31) | 4493, (1U<<31) | 4493, (1U<<31) | 4493, 
+  (1U<<31) | 4460, (1U<<31) | 4460, (1U<<31) | 4460, (1U<<31) | 4451, (1U<<31) | 4451, (1U<<31) | 4451, (1U<<31) | 4467, (1U<<31) | 4467, 
+  (1U<<31) | 4467, (1U<<31) | 4451, (1U<<31) | 4451, (1U<<31) | 4451, 0x453, 0x453, 0x453, 0x454, 
+  0x454, 0x454, 0x455, 0x455, 0x455, 0x453, 0x453, 0x453, 
+  (1U<<31) | 5019, (1U<<31) | 5019, (1U<<31) | 5019, (1U<<31) | 5042, (1U<<31) | 5042, (1U<<31) | 5042, (1U<<31) | 5057, (1U<<31) | 5057, 
+  (1U<<31) | 5057, (1U<<31) | 5019, (1U<<31) | 5019, (1U<<31) | 5019, (1U<<31) | 5011, (1U<<31) | 5011, (1U<<31) | 5011, (1U<<31) | 5034, 
+  (1U<<31) | 5034, (1U<<31) | 5034, (1U<<31) | 5011, (1U<<31) | 5011, (1U<<31) | 5011, 0x44453, 0x44453, 0x44453, 
   0x44454, 0x44454, 0x44454, 0x44455, 0x44455, 0x44455, 0x44453, 0x44453, 
-  0x44453, (1U<<31) | 3376, (1U<<31) | 3376, (1U<<31) | 3376, (1U<<31) | 3394, (1U<<31) | 3394, (1U<<31) | 3394, (1U<<31) | 3413, 
-  (1U<<31) | 3413, (1U<<31) | 3413, (1U<<31) | 3376, (1U<<31) | 3376, (1U<<31) | 3376, (1U<<31) | 3366, (1U<<31) | 3366, (1U<<31) | 3366, 
-  (1U<<31) | 3384, (1U<<31) | 3384, (1U<<31) | 3384, (1U<<31) | 3366, (1U<<31) | 3366, (1U<<31) | 3366, 0x54, 0x54, 
-  0x54, 0x54, 0x54, 0x54, 0x34450, 0x34450, 0x34450, 0x44450, 
-  0x44450, 0x44450, 0x54450, 0x54450, 0x54450, 0x34450, 0x34450, 0x34450, 
-  0x334450, 0x334450, 0x334450, 0x444450, 0x444450, 0x444450, 0x554450, 0x554450, 
-  0x554450, 0x334450, 0x334450, 0x334450, 0x33334450, 0x33334450, 0x33334450, 0x44444450, 
-  0x44444450, 0x44444450, 0x33334450, 0x33334450, 0x33334450, 0x3450, 0x3450, 0x3450, 
-  0x4450, 0x4450, 0x4450, 0x5450, 0x5450, 0x5450, 0x3450, 0x3450, 
-  0x3450, 0x33450, 0x33450, 0x33450, 0x44450, 0x44450, 0x44450, 0x55450, 
-  0x55450, 0x55450, 0x33450, 0x33450, 0x33450, 0x3333450, 0x3333450, 0x3333450, 
-  0x4444450, 0x4444450, 0x4444450, 0x3333450, 0x3333450, 0x3333450, 0x344450, 0x344450, 
-  0x344450, 0x444450, 0x444450, 0x444450, 0x544450, 0x544450, 0x544450, 0x344450, 
-  0x344450, 0x344450, 0x3344450, 0x3344450, 0x3344450, 0x4444450, 0x4444450, 0x4444450, 
-  0x5544450, 0x5544450, 0x5544450, 0x3344450, 0x3344450, 0x3344450, (1U<<31) | 800, (1U<<31) | 800, 
-  (1U<<31) | 800, (1U<<31) | 3210, (1U<<31) | 3210, (1U<<31) | 3210, (1U<<31) | 800, (1U<<31) | 800, (1U<<31) | 800, 0x34450, 
-  0x34450, 0x34450, 0x44450, 0x44450, 0x44450, 0x54450, 0x54450, 0x54450, 
-  0x34450, 0x34450, 0x34450, 0x334450, 0x334450, 0x334450, 0x444450, 0x444450, 
-  0x444450, 0x554450, 0x554450, 0x554450, 0x334450, 0x334450, 0x334450, 0x33334450, 
-  0x33334450, 0x33334450, 0x44444450, 0x44444450, 0x44444450, 0x33334450, 0x33334450, 0x33334450, 
+  0x44453, (1U<<31) | 4004, (1U<<31) | 4004, (1U<<31) | 4004, (1U<<31) | 4022, (1U<<31) | 4022, (1U<<31) | 4022, (1U<<31) | 4041, 
+  (1U<<31) | 4041, (1U<<31) | 4041, (1U<<31) | 4004, (1U<<31) | 4004, (1U<<31) | 4004, (1U<<31) | 3994, (1U<<31) | 3994, (1U<<31) | 3994, 
+  (1U<<31) | 4012, (1U<<31) | 4012, (1U<<31) | 4012, (1U<<31) | 3994, (1U<<31) | 3994, (1U<<31) | 3994, 0x4453, 0x4453, 
+  0x4453, 0x4454, 0x4454, 0x4454, 0x4455, 0x4455, 0x4455, 0x4453, 
+  0x4453, 0x4453, (1U<<31) | 4460, (1U<<31) | 4460, (1U<<31) | 4460, (1U<<31) | 4476, (1U<<31) | 4476, (1U<<31) | 4476, 
+  (1U<<31) | 4493, (1U<<31) | 4493, (1U<<31) | 4493, (1U<<31) | 4460, (1U<<31) | 4460, (1U<<31) | 4460, (1U<<31) | 4451, (1U<<31) | 4451, 
+  (1U<<31) | 4451, (1U<<31) | 4467, (1U<<31) | 4467, (1U<<31) | 4467, (1U<<31) | 4451, (1U<<31) | 4451, (1U<<31) | 4451, 0x44453, 
+  0x44453, 0x44453, 0x44454, 0x44454, 0x44454, 0x44455, 0x44455, 0x44455, 
+  0x44453, 0x44453, 0x44453, (1U<<31) | 4004, (1U<<31) | 4004, (1U<<31) | 4004, (1U<<31) | 4022, (1U<<31) | 4022, 
+  (1U<<31) | 4022, (1U<<31) | 4041, (1U<<31) | 4041, (1U<<31) | 4041, (1U<<31) | 4004, (1U<<31) | 4004, (1U<<31) | 4004, (1U<<31) | 3994, 
+  (1U<<31) | 3994, (1U<<31) | 3994, (1U<<31) | 4012, (1U<<31) | 4012, (1U<<31) | 4012, (1U<<31) | 3994, (1U<<31) | 3994, (1U<<31) | 3994, 
+  0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x34450, 0x34450, 
+  0x34450, 0x44450, 0x44450, 0x44450, 0x54450, 0x54450, 0x54450, 0x34450, 
+  0x34450, 0x34450, 0x334450, 0x334450, 0x334450, 0x444450, 0x444450, 0x444450, 
+  0x554450, 0x554450, 0x554450, 0x334450, 0x334450, 0x334450, 0x33334450, 0x33334450, 
+  0x33334450, 0x44444450, 0x44444450, 0x44444450, 0x33334450, 0x33334450, 0x33334450, 0x3450, 
+  0x3450, 0x3450, 0x4450, 0x4450, 0x4450, 0x5450, 0x5450, 0x5450, 
+  0x3450, 0x3450, 0x3450, 0x33450, 0x33450, 0x33450, 0x44450, 0x44450, 
+  0x44450, 0x55450, 0x55450, 0x55450, 0x33450, 0x33450, 0x33450, 0x3333450, 
+  0x3333450, 0x3333450, 0x4444450, 0x4444450, 0x4444450, 0x3333450, 0x3333450, 0x3333450, 
   0x344450, 0x344450, 0x344450, 0x444450, 0x444450, 0x444450, 0x544450, 0x544450, 
   0x544450, 0x344450, 0x344450, 0x344450, 0x3344450, 0x3344450, 0x3344450, 0x4444450, 
   0x4444450, 0x4444450, 0x5544450, 0x5544450, 0x5544450, 0x3344450, 0x3344450, 0x3344450, 
-  (1U<<31) | 800, (1U<<31) | 800, (1U<<31) | 800, (1U<<31) | 3210, (1U<<31) | 3210, (1U<<31) | 3210, (1U<<31) | 800, (1U<<31) | 800, 
-  (1U<<31) | 800, 0x34450, 0x44450, 0x34450, 0x334450, 0x444450, 0x334450, 0x33334450, 
-  0x44444450, 0x33334450, 0x3450, 0x4450, 0x3450, 0x33450, 0x44450, 0x33450, 
-  0x3333450, 0x4444450, 0x3333450, 0x344450, 0x444450, 0x344450, 0x3344450, 0x4444450, 
-  0x3344450, (1U<<31) | 800, (1U<<31) | 3210, (1U<<31) | 800, 0x34450, 0x44450, 0x34450, 0x334450, 
-  0x444450, 0x334450, 0x33334450, 0x44444450, 0x33334450, 0x344450, 0x444450, 0x344450, 
-  0x3344450, 0x4444450, 0x3344450, (1U<<31) | 800, (1U<<31) | 3210, (1U<<31) | 800, 0x55, (1U<<31) | 5606, 
-  (1U<<31) | 5594, (1U<<31) | 5594, (1U<<31) | 5518, (1U<<31) | 5507, (1U<<31) | 5507, (1U<<31) | 5439, (1U<<31) | 3796, (1U<<31) | 5429, 
-  (1U<<31) | 3779, (1U<<31) | 5429, (1U<<31) | 3779, (1U<<31) | 5650, (1U<<31) | 5639, (1U<<31) | 5639, (1U<<31) | 5564, (1U<<31) | 5554, 
-  (1U<<31) | 5554, (1U<<31) | 5480, (1U<<31) | 4296, (1U<<31) | 5471, (1U<<31) | 4274, (1U<<31) | 5471, (1U<<31) | 4274, (1U<<31) | 5796, 
-  (1U<<31) | 5781, (1U<<31) | 5781, (1U<<31) | 5606, (1U<<31) | 5594, (1U<<31) | 5594, (1U<<31) | 5518, (1U<<31) | 3421, (1U<<31) | 5507, 
-  (1U<<31) | 3402, (1U<<31) | 5507, (1U<<31) | 3402, (1U<<31) | 5852, (1U<<31) | 5838, (1U<<31) | 5838, (1U<<31) | 5650, (1U<<31) | 5639, 
-  (1U<<31) | 5639, (1U<<31) | 5564, (1U<<31) | 3796, (1U<<31) | 5554, (1U<<31) | 3779, (1U<<31) | 5554, (1U<<31) | 3779, (1U<<31) | 6024, 
-  (1U<<31) | 6007, (1U<<31) | 6007, (1U<<31) | 5744, (1U<<31) | 5732, (1U<<31) | 5732, (1U<<31) | 5650, (1U<<31) | 3421, (1U<<31) | 5639, 
-  (1U<<31) | 3402, (1U<<31) | 5639, (1U<<31) | 3402, (1U<<31) | 5696, (1U<<31) | 5683, (1U<<31) | 5683, (1U<<31) | 5606, (1U<<31) | 5594, 
-  (1U<<31) | 5594, (1U<<31) | 5744, (1U<<31) | 5732, (1U<<31) | 5732, (1U<<31) | 5650, (1U<<31) | 5639, (1U<<31) | 5639, (1U<<31) | 5618, 
-  (1U<<31) | 5583, (1U<<31) | 5583, (1U<<31) | 5529, (1U<<31) | 5497, (1U<<31) | 5497, (1U<<31) | 5449, (1U<<31) | 3806, (1U<<31) | 5420, 
-  (1U<<31) | 3763, (1U<<31) | 5420, (1U<<31) | 3763, (1U<<31) | 5661, (1U<<31) | 5629, (1U<<31) | 5629, (1U<<31) | 5574, (1U<<31) | 5545, 
-  (1U<<31) | 5545, (1U<<31) | 5489, (1U<<31) | 4305, (1U<<31) | 5463, (1U<<31) | 4260, (1U<<31) | 5463, (1U<<31) | 4260, (1U<<31) | 5811, 
-  (1U<<31) | 5767, (1U<<31) | 5767, (1U<<31) | 5618, (1U<<31) | 5583, (1U<<31) | 5583, (1U<<31) | 5529, (1U<<31) | 3432, (1U<<31) | 5497, 
-  (1U<<31) | 3384, (1U<<31) | 5497, (1U<<31) | 3384, (1U<<31) | 5866, (1U<<31) | 5825, (1U<<31) | 5825, (1U<<31) | 5661, (1U<<31) | 5629, 
-  (1U<<31) | 5629, (1U<<31) | 5574, (1U<<31) | 3806, (1U<<31) | 5545, (1U<<31) | 3763, (1U<<31) | 5545, (1U<<31) | 3763, (1U<<31) | 6041, 
-  (1U<<31) | 5991, (1U<<31) | 5991, (1U<<31) | 5756, (1U<<31) | 5721, (1U<<31) | 5721, (1U<<31) | 5661, (1U<<31) | 3432, (1U<<31) | 5629, 
-  (1U<<31) | 3384, (1U<<31) | 5629, (1U<<31) | 3384, (1U<<31) | 5709, (1U<<31) | 5671, (1U<<31) | 5671, (1U<<31) | 5618, (1U<<31) | 5583, 
-  (1U<<31) | 5583, (1U<<31) | 5756, (1U<<31) | 5721, (1U<<31) | 5721, (1U<<31) | 5661, (1U<<31) | 5629, (1U<<31) | 5629, (1U<<31) | 5166, 
-  0x4f5, (1U<<31) | 5564, (1U<<31) | 5554, (1U<<31) | 5554, (1U<<31) | 5564, (1U<<31) | 5554, (1U<<31) | 5554, (1U<<31) | 5564, 
-  (1U<<31) | 5554, (1U<<31) | 5554, (1U<<31) | 5564, (1U<<31) | 5554, (1U<<31) | 5554, (1U<<31) | 5574, (1U<<31) | 5545, (1U<<31) | 5545, 
-  (1U<<31) | 5574, (1U<<31) | 5545, (1U<<31) | 5545, (1U<<31) | 5574, (1U<<31) | 5545, (1U<<31) | 5545, (1U<<31) | 5574, (1U<<31) | 5545, 
-  (1U<<31) | 5545, 0x88, 0x77, 0x77, 0x54, 0x54, 0x54, 0x54, 
-  0x54, 0x54, 0x54, 0x54, 0x48, 0x48, 0x48, 0x48, 
-  0x47, 0x47, 0x47, 0x47, 0x58, 0x58, 0x58, 0x58, 
-  0x57, 0x57, 0x57, 0x57, 0x11, 0x141, 0x11, 0x141, 
-  0x14, 0x144, 0x11, 0x141, (1U<<31) | 5098, (1U<<31) | 5085, (1U<<31) | 4132, (1U<<31) | 4125, 
-  (1U<<31) | 4125, (1U<<31) | 5085, (1U<<31) | 5098, (1U<<31) | 5085, (1U<<31) | 4132, (1U<<31) | 4125, (1U<<31) | 4125, (1U<<31) | 5085, 
-  (1U<<31) | 5098, (1U<<31) | 5085, (1U<<31) | 4132, (1U<<31) | 4125, (1U<<31) | 4125, (1U<<31) | 5085, (1U<<31) | 5098, (1U<<31) | 5085, 
-  (1U<<31) | 4132, (1U<<31) | 4125, (1U<<31) | 4125, (1U<<31) | 5085, (1U<<31) | 5118, (1U<<31) | 5130, (1U<<31) | 5065, (1U<<31) | 4153, 
-  (1U<<31) | 4166, (1U<<31) | 4103, (1U<<31) | 5118, (1U<<31) | 5130, (1U<<31) | 5065, (1U<<31) | 4153, (1U<<31) | 4166, (1U<<31) | 4103, 
-  (1U<<31) | 5320, (1U<<31) | 5320, (1U<<31) | 5891, (1U<<31) | 5891, (1U<<31) | 5370, (1U<<31) | 5370, (1U<<31) | 5941, (1U<<31) | 5941, 
-  (1U<<31) | 3135, (1U<<31) | 3135, (1U<<31) | 3135, (1U<<31) | 3135, (1U<<31) | 5320, (1U<<31) | 5320, (1U<<31) | 5891, (1U<<31) | 5891, 
-  (1U<<31) | 5370, (1U<<31) | 5370, (1U<<31) | 5941, (1U<<31) | 5941, (1U<<31) | 3135, (1U<<31) | 3135, (1U<<31) | 3135, (1U<<31) | 3135, 
-  (1U<<31) | 5320, (1U<<31) | 5320, (1U<<31) | 5891, (1U<<31) | 5891, (1U<<31) | 5370, (1U<<31) | 5370, (1U<<31) | 5941, (1U<<31) | 5941, 
-  (1U<<31) | 3135, (1U<<31) | 3135, (1U<<31) | 3135, (1U<<31) | 3135, (1U<<31) | 5320, (1U<<31) | 5320, (1U<<31) | 5891, (1U<<31) | 5891, 
-  (1U<<31) | 5370, (1U<<31) | 5370, (1U<<31) | 5941, (1U<<31) | 5941, (1U<<31) | 3135, (1U<<31) | 3135, (1U<<31) | 3135, (1U<<31) | 3135, 
-  (1U<<31) | 5308, (1U<<31) | 5879, (1U<<31) | 3198, (1U<<31) | 4473, (1U<<31) | 4486, (1U<<31) | 3171, (1U<<31) | 5308, (1U<<31) | 5879, 
-  (1U<<31) | 3198, (1U<<31) | 4473, (1U<<31) | 4486, (1U<<31) | 3171, (1U<<31) | 5098, (1U<<31) | 5077, (1U<<31) | 4132, (1U<<31) | 4116, 
-  (1U<<31) | 4116, (1U<<31) | 5077, (1U<<31) | 5098, (1U<<31) | 5077, (1U<<31) | 4132, (1U<<31) | 4116, (1U<<31) | 4116, (1U<<31) | 5077, 
-  (1U<<31) | 5098, 0x4f4, (1U<<31) | 4132, 0x44f4, 0x44f4, 0x4f4, (1U<<31) | 5098, 0x4f4, 
-  (1U<<31) | 4132, 0x44f4, 0x44f4, 0x4f4, (1U<<31) | 5118, (1U<<31) | 5130, (1U<<31) | 5065, (1U<<31) | 4153, 
-  (1U<<31) | 4166, (1U<<31) | 4103, (1U<<31) | 5118, (1U<<31) | 5130, (1U<<31) | 5065, (1U<<31) | 4153, (1U<<31) | 4166, (1U<<31) | 4103, 
-  (1U<<31) | 5320, (1U<<31) | 5320, (1U<<31) | 5891, (1U<<31) | 5891, (1U<<31) | 5370, (1U<<31) | 5370, (1U<<31) | 5941, (1U<<31) | 5941, 
-  (1U<<31) | 3112, (1U<<31) | 3112, (1U<<31) | 3112, (1U<<31) | 3112, (1U<<31) | 5320, (1U<<31) | 5320, (1U<<31) | 5891, (1U<<31) | 5891, 
-  (1U<<31) | 5370, (1U<<31) | 5370, (1U<<31) | 5941, (1U<<31) | 5941, (1U<<31) | 3112, (1U<<31) | 3112, (1U<<31) | 3112, (1U<<31) | 3112, 
-  (1U<<31) | 5320, (1U<<31) | 5320, (1U<<31) | 5891, (1U<<31) | 5891, (1U<<31) | 5370, (1U<<31) | 5370, (1U<<31) | 5941, (1U<<31) | 5941, 
-  (1U<<31) | 3112, (1U<<31) | 3112, (1U<<31) | 3112, (1U<<31) | 3112, (1U<<31) | 5320, (1U<<31) | 5320, (1U<<31) | 5891, (1U<<31) | 5891, 
-  (1U<<31) | 5370, (1U<<31) | 5370, (1U<<31) | 5941, (1U<<31) | 5941, (1U<<31) | 3112, (1U<<31) | 3112, (1U<<31) | 3112, (1U<<31) | 3112, 
-  (1U<<31) | 5308, (1U<<31) | 5879, (1U<<31) | 3198, (1U<<31) | 4473, (1U<<31) | 4486, (1U<<31) | 3171, (1U<<31) | 5308, (1U<<31) | 5879, 
-  (1U<<31) | 3198, (1U<<31) | 4473, (1U<<31) | 4486, (1U<<31) | 3171, (1U<<31) | 5098, 0x4f4, (1U<<31) | 4132, 0x44f4, 
-  0x44f4, 0x4f4, (1U<<31) | 5098, 0x4f4, (1U<<31) | 4132, 0x44f4, 0x44f4, 0x4f4, 
-  (1U<<31) | 5098, (1U<<31) | 5077, (1U<<31) | 4132, (1U<<31) | 4116, (1U<<31) | 4116, (1U<<31) | 5077, (1U<<31) | 5098, (1U<<31) | 5077, 
-  (1U<<31) | 4132, (1U<<31) | 4116, (1U<<31) | 4116, (1U<<31) | 5077, (1U<<31) | 5118, (1U<<31) | 5130, (1U<<31) | 5065, (1U<<31) | 4153, 
-  (1U<<31) | 4166, (1U<<31) | 4103, (1U<<31) | 5118, (1U<<31) | 5130, (1U<<31) | 5065, (1U<<31) | 4153, (1U<<31) | 4166, (1U<<31) | 4103, 
-  (1U<<31) | 5320, (1U<<31) | 5320, (1U<<31) | 5891, (1U<<31) | 5891, (1U<<31) | 5370, (1U<<31) | 5370, (1U<<31) | 5941, (1U<<31) | 5941, 
-  (1U<<31) | 3112, (1U<<31) | 3112, (1U<<31) | 3112, (1U<<31) | 3112, (1U<<31) | 5320, (1U<<31) | 5320, (1U<<31) | 5891, (1U<<31) | 5891, 
-  (1U<<31) | 5370, (1U<<31) | 5370, (1U<<31) | 5941, (1U<<31) | 5941, (1U<<31) | 3112, (1U<<31) | 3112, (1U<<31) | 3112, (1U<<31) | 3112, 
-  (1U<<31) | 5320, (1U<<31) | 5320, (1U<<31) | 5891, (1U<<31) | 5891, (1U<<31) | 5370, (1U<<31) | 5370, (1U<<31) | 5941, (1U<<31) | 5941, 
-  (1U<<31) | 3112, (1U<<31) | 3112, (1U<<31) | 3112, (1U<<31) | 3112, (1U<<31) | 5320, (1U<<31) | 5320, (1U<<31) | 5891, (1U<<31) | 5891, 
-  (1U<<31) | 5370, (1U<<31) | 5370, (1U<<31) | 5941, (1U<<31) | 5941, (1U<<31) | 3112, (1U<<31) | 3112, (1U<<31) | 3112, (1U<<31) | 3112, 
-  (1U<<31) | 5308, (1U<<31) | 5879, (1U<<31) | 3198, (1U<<31) | 4473, (1U<<31) | 4486, (1U<<31) | 3171, (1U<<31) | 5308, (1U<<31) | 5879, 
-  (1U<<31) | 3198, (1U<<31) | 4473, (1U<<31) | 4486, (1U<<31) | 3171, 0x4f4, 0x44f4, 0x4f4, 0x44f4, 
-  (1U<<31) | 5085, (1U<<31) | 4125, (1U<<31) | 5085, (1U<<31) | 4125, (1U<<31) | 3231, 0x444f0, 0x4444f0, 0x444f0, 
-  0x4444f0, 0x4f4, 0x44f4, 0x44f4, 0x4f4, 0x4f4, 0x44f4, 0x44f4, 
-  0x4f4, (1U<<31) | 5085, (1U<<31) | 4125, (1U<<31) | 5085, (1U<<31) | 4125, (1U<<31) | 3231, (1U<<31) | 3231, (1U<<31) | 3231, 
-  (1U<<31) | 3231, 0x444f0, 0x4444f0, 0x444f0, 0x4444f0, (1U<<31) | 6640, 0x595959, 0x595959, 
-  0x595959, 0x595959, 0x2c2c2c2c, 0x2c2c2c, 0x595959, 0x3b3b3b, 0x4a4a4a, 0x5959, 
-  0x445959, 0x444a4a, 0x40, 0x0, 0x442e0, 0x442e0, 0x442e0, 0x442e0, 
-  0x2e2c, 0x2e3b, 0x2e4a, 0x2e2c, 0x2e2c, 0x2e4a, 0x2e4a, 0x3b, 
-  0x4a0, 0x2e2c0, 0x2e3b0, 0x2e4a0, 0x2e4a0, 0x2e4a0, 0x2c2c2c, 0x3b3b3b, 
-  0x4a4a4a, (1U<<31) | 6626, 0x4a4a4a, (1U<<31) | 6624, (1U<<31) | 6624, 0x2c2c2c, 0x3b3b3b, 0x4a4a4a, 
-  0x2c2c2c, 0x3b3b3b, 0x4a4a4a, 0x2c2c2c, 0x3b3b3b, 0x4a4a4a, 0x2c2c2c, 0x3b3b3b, 
-  0x4a4a4a, 0x2c2c59, 0x44a7a, 0x44a7a, 0x2c4, 0x7a7a4a, 0x7a7a44, 0x7a7a4a, 
-  0x7a7a44, 0x2c2c2c, 0x2c2c44, 0x595959, 0x595944, 0x3b3b3b, 0x3b3b44, 0x4a4a4a, 
-  0x4a4a44, 0x7a7a4a, 0x7a7a44, 0x7a7a4a, 0x7a7a44, 0x2c2c2c, 0x2c2c44, 0x595959, 
-  0x595944, 0x3b3b3b, 0x3b3b44, 0x4a4a4a, 0x4a4a44, 0x2c2c2c, 0x2c2c44, 0x595959, 
-  0x595944, 0x3b3b3b, 0x3b3b44, 0x4a4a4a, 0x4a4a44, 0x2c2c2c, 0x2c2c44, 0x3b3b3b, 
-  0x3b3b44, 0x4a4a4a, 0x4a4a44, 0x2c2c2c, 0x2c2c44, 0x3b3b3b, 0x3b3b44, 0x4a4a4a, 
-  0x4a4a44, 0x47a4a, 0x47a4a, 0x2c4, 0x7a7a, 0x2c2c, 0x7a7a, 0x7a7a7a7a, 
+  (1U<<31) | 1106, (1U<<31) | 1106, (1U<<31) | 1106, (1U<<31) | 3823, (1U<<31) | 3823, (1U<<31) | 3823, (1U<<31) | 1106, (1U<<31) | 1106, 
+  (1U<<31) | 1106, 0x34450, 0x34450, 0x34450, 0x44450, 0x44450, 0x44450, 0x54450, 
+  0x54450, 0x54450, 0x34450, 0x34450, 0x34450, 0x334450, 0x334450, 0x334450, 
+  0x444450, 0x444450, 0x444450, 0x554450, 0x554450, 0x554450, 0x334450, 0x334450, 
+  0x334450, 0x33334450, 0x33334450, 0x33334450, 0x44444450, 0x44444450, 0x44444450, 0x33334450, 
+  0x33334450, 0x33334450, 0x344450, 0x344450, 0x344450, 0x444450, 0x444450, 0x444450, 
+  0x544450, 0x544450, 0x544450, 0x344450, 0x344450, 0x344450, 0x3344450, 0x3344450, 
+  0x3344450, 0x4444450, 0x4444450, 0x4444450, 0x5544450, 0x5544450, 0x5544450, 0x3344450, 
+  0x3344450, 0x3344450, (1U<<31) | 1106, (1U<<31) | 1106, (1U<<31) | 1106, (1U<<31) | 3823, (1U<<31) | 3823, (1U<<31) | 3823, 
+  (1U<<31) | 1106, (1U<<31) | 1106, (1U<<31) | 1106, 0x34450, 0x44450, 0x34450, 0x334450, 0x444450, 
+  0x334450, 0x33334450, 0x44444450, 0x33334450, 0x3450, 0x4450, 0x3450, 0x33450, 
+  0x44450, 0x33450, 0x3333450, 0x4444450, 0x3333450, 0x344450, 0x444450, 0x344450, 
+  0x3344450, 0x4444450, 0x3344450, (1U<<31) | 1106, (1U<<31) | 3823, (1U<<31) | 1106, 0x34450, 0x44450, 
+  0x34450, 0x334450, 0x444450, 0x334450, 0x33334450, 0x44444450, 0x33334450, 0x344450, 
+  0x444450, 0x344450, 0x3344450, 0x4444450, 0x3344450, (1U<<31) | 1106, (1U<<31) | 3823, (1U<<31) | 1106, 
+  0x55, (1U<<31) | 7244, (1U<<31) | 7232, (1U<<31) | 7232, (1U<<31) | 7162, (1U<<31) | 7151, (1U<<31) | 7151, (1U<<31) | 7088, 
+  (1U<<31) | 4500, (1U<<31) | 7078, (1U<<31) | 4483, (1U<<31) | 7078, (1U<<31) | 4483, (1U<<31) | 7288, (1U<<31) | 7277, (1U<<31) | 7277, 
+  (1U<<31) | 7202, (1U<<31) | 7192, (1U<<31) | 7192, (1U<<31) | 7124, (1U<<31) | 5063, (1U<<31) | 7115, (1U<<31) | 5048, (1U<<31) | 7115, 
+  (1U<<31) | 5048, (1U<<31) | 7434, (1U<<31) | 7419, (1U<<31) | 7419, (1U<<31) | 7244, (1U<<31) | 7232, (1U<<31) | 7232, (1U<<31) | 7162, 
+  (1U<<31) | 4049, (1U<<31) | 7151, (1U<<31) | 4030, (1U<<31) | 7151, (1U<<31) | 4030, (1U<<31) | 7490, (1U<<31) | 7476, (1U<<31) | 7476, 
+  (1U<<31) | 7288, (1U<<31) | 7277, (1U<<31) | 7277, (1U<<31) | 7202, (1U<<31) | 4500, (1U<<31) | 7192, (1U<<31) | 4483, (1U<<31) | 7192, 
+  (1U<<31) | 4483, (1U<<31) | 7688, (1U<<31) | 7671, (1U<<31) | 7671, (1U<<31) | 7382, (1U<<31) | 7370, (1U<<31) | 7370, (1U<<31) | 7288, 
+  (1U<<31) | 4049, (1U<<31) | 7277, (1U<<31) | 4030, (1U<<31) | 7277, (1U<<31) | 4030, (1U<<31) | 7334, (1U<<31) | 7321, (1U<<31) | 7321, 
+  (1U<<31) | 7244, (1U<<31) | 7232, (1U<<31) | 7232, (1U<<31) | 7382, (1U<<31) | 7370, (1U<<31) | 7370, (1U<<31) | 7288, (1U<<31) | 7277, 
+  (1U<<31) | 7277, (1U<<31) | 7256, (1U<<31) | 7221, (1U<<31) | 7221, (1U<<31) | 7173, (1U<<31) | 7141, (1U<<31) | 7141, (1U<<31) | 7098, 
+  (1U<<31) | 4510, (1U<<31) | 7069, (1U<<31) | 4467, (1U<<31) | 7069, (1U<<31) | 4467, (1U<<31) | 7299, (1U<<31) | 7267, (1U<<31) | 7267, 
+  (1U<<31) | 7212, (1U<<31) | 7183, (1U<<31) | 7183, (1U<<31) | 7133, (1U<<31) | 5081, (1U<<31) | 7107, (1U<<31) | 5034, (1U<<31) | 7107, 
+  (1U<<31) | 5034, (1U<<31) | 7449, (1U<<31) | 7405, (1U<<31) | 7405, (1U<<31) | 7256, (1U<<31) | 7221, (1U<<31) | 7221, (1U<<31) | 7173, 
+  (1U<<31) | 4060, (1U<<31) | 7141, (1U<<31) | 4012, (1U<<31) | 7141, (1U<<31) | 4012, (1U<<31) | 7504, (1U<<31) | 7463, (1U<<31) | 7463, 
+  (1U<<31) | 7299, (1U<<31) | 7267, (1U<<31) | 7267, (1U<<31) | 7212, (1U<<31) | 4510, (1U<<31) | 7183, (1U<<31) | 4467, (1U<<31) | 7183, 
+  (1U<<31) | 4467, (1U<<31) | 7705, (1U<<31) | 7655, (1U<<31) | 7655, (1U<<31) | 7394, (1U<<31) | 7359, (1U<<31) | 7359, (1U<<31) | 7299, 
+  (1U<<31) | 4060, (1U<<31) | 7267, (1U<<31) | 4012, (1U<<31) | 7267, (1U<<31) | 4012, (1U<<31) | 7347, (1U<<31) | 7309, (1U<<31) | 7309, 
+  (1U<<31) | 7256, (1U<<31) | 7221, (1U<<31) | 7221, (1U<<31) | 7394, (1U<<31) | 7359, (1U<<31) | 7359, (1U<<31) | 7299, (1U<<31) | 7267, 
+  (1U<<31) | 7267, (1U<<31) | 6464, 0x4f5, (1U<<31) | 7202, (1U<<31) | 7192, (1U<<31) | 7192, (1U<<31) | 7202, (1U<<31) | 7192, 
+  (1U<<31) | 7192, (1U<<31) | 7202, (1U<<31) | 7192, (1U<<31) | 7192, (1U<<31) | 7202, (1U<<31) | 7192, (1U<<31) | 7192, (1U<<31) | 7212, 
+  (1U<<31) | 7183, (1U<<31) | 7183, (1U<<31) | 7212, (1U<<31) | 7183, (1U<<31) | 7183, (1U<<31) | 7212, (1U<<31) | 7183, (1U<<31) | 7183, 
+  (1U<<31) | 7212, (1U<<31) | 7183, (1U<<31) | 7183, 0x88, 0x77, 0x77, 0x54, 0x54, 
+  0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x48, 0x48, 
+  0x48, 0x48, 0x47, 0x47, 0x47, 0x47, 0x58, 0x58, 
+  0x58, 0x58, 0x57, 0x57, 0x57, 0x57, 0x11, 0x141, 
+  0x11, 0x141, 0x14, 0x144, 0x11, 0x141, (1U<<31) | 6387, (1U<<31) | 6374, 
+  (1U<<31) | 4887, (1U<<31) | 4880, (1U<<31) | 4880, (1U<<31) | 6374, (1U<<31) | 6387, (1U<<31) | 6374, (1U<<31) | 4887, (1U<<31) | 4880, 
+  (1U<<31) | 4880, (1U<<31) | 6374, (1U<<31) | 6387, (1U<<31) | 6374, (1U<<31) | 4887, (1U<<31) | 4880, (1U<<31) | 4880, (1U<<31) | 6374, 
+  (1U<<31) | 6387, (1U<<31) | 6374, (1U<<31) | 4887, (1U<<31) | 4880, (1U<<31) | 4880, (1U<<31) | 6374, (1U<<31) | 6407, (1U<<31) | 6419, 
+  (1U<<31) | 6354, (1U<<31) | 4908, (1U<<31) | 4921, (1U<<31) | 4858, (1U<<31) | 6407, (1U<<31) | 6419, (1U<<31) | 6354, (1U<<31) | 4908, 
+  (1U<<31) | 4921, (1U<<31) | 4858, (1U<<31) | 6865, (1U<<31) | 6865, (1U<<31) | 7529, (1U<<31) | 7529, (1U<<31) | 6915, (1U<<31) | 6915, 
+  (1U<<31) | 7579, (1U<<31) | 7579, (1U<<31) | 3738, (1U<<31) | 3738, (1U<<31) | 3738, (1U<<31) | 3738, (1U<<31) | 6865, (1U<<31) | 6865, 
+  (1U<<31) | 7529, (1U<<31) | 7529, (1U<<31) | 6915, (1U<<31) | 6915, (1U<<31) | 7579, (1U<<31) | 7579, (1U<<31) | 3738, (1U<<31) | 3738, 
+  (1U<<31) | 3738, (1U<<31) | 3738, (1U<<31) | 6865, (1U<<31) | 6865, (1U<<31) | 7529, (1U<<31) | 7529, (1U<<31) | 6915, (1U<<31) | 6915, 
+  (1U<<31) | 7579, (1U<<31) | 7579, (1U<<31) | 3738, (1U<<31) | 3738, (1U<<31) | 3738, (1U<<31) | 3738, (1U<<31) | 6865, (1U<<31) | 6865, 
+  (1U<<31) | 7529, (1U<<31) | 7529, (1U<<31) | 6915, (1U<<31) | 6915, (1U<<31) | 7579, (1U<<31) | 7579, (1U<<31) | 3738, (1U<<31) | 3738, 
+  (1U<<31) | 3738, (1U<<31) | 3738, (1U<<31) | 6853, (1U<<31) | 7517, (1U<<31) | 3801, (1U<<31) | 5258, (1U<<31) | 5271, (1U<<31) | 3774, 
+  (1U<<31) | 6853, (1U<<31) | 7517, (1U<<31) | 3801, (1U<<31) | 5258, (1U<<31) | 5271, (1U<<31) | 3774, (1U<<31) | 6387, (1U<<31) | 6366, 
+  (1U<<31) | 4887, (1U<<31) | 4871, (1U<<31) | 4871, (1U<<31) | 6366, (1U<<31) | 6387, (1U<<31) | 6366, (1U<<31) | 4887, (1U<<31) | 4871, 
+  (1U<<31) | 4871, (1U<<31) | 6366, (1U<<31) | 6387, 0x4f4, (1U<<31) | 4887, 0x44f4, 0x44f4, 0x4f4, 
+  (1U<<31) | 6387, 0x4f4, (1U<<31) | 4887, 0x44f4, 0x44f4, 0x4f4, (1U<<31) | 6407, (1U<<31) | 6419, 
+  (1U<<31) | 6354, (1U<<31) | 4908, (1U<<31) | 4921, (1U<<31) | 4858, (1U<<31) | 6407, (1U<<31) | 6419, (1U<<31) | 6354, (1U<<31) | 4908, 
+  (1U<<31) | 4921, (1U<<31) | 4858, (1U<<31) | 6865, (1U<<31) | 6865, (1U<<31) | 7529, (1U<<31) | 7529, (1U<<31) | 6915, (1U<<31) | 6915, 
+  (1U<<31) | 7579, (1U<<31) | 7579, (1U<<31) | 3715, (1U<<31) | 3715, (1U<<31) | 3715, (1U<<31) | 3715, (1U<<31) | 6865, (1U<<31) | 6865, 
+  (1U<<31) | 7529, (1U<<31) | 7529, (1U<<31) | 6915, (1U<<31) | 6915, (1U<<31) | 7579, (1U<<31) | 7579, (1U<<31) | 3715, (1U<<31) | 3715, 
+  (1U<<31) | 3715, (1U<<31) | 3715, (1U<<31) | 6865, (1U<<31) | 6865, (1U<<31) | 7529, (1U<<31) | 7529, (1U<<31) | 6915, (1U<<31) | 6915, 
+  (1U<<31) | 7579, (1U<<31) | 7579, (1U<<31) | 3715, (1U<<31) | 3715, (1U<<31) | 3715, (1U<<31) | 3715, (1U<<31) | 6865, (1U<<31) | 6865, 
+  (1U<<31) | 7529, (1U<<31) | 7529, (1U<<31) | 6915, (1U<<31) | 6915, (1U<<31) | 7579, (1U<<31) | 7579, (1U<<31) | 3715, (1U<<31) | 3715, 
+  (1U<<31) | 3715, (1U<<31) | 3715, (1U<<31) | 6853, (1U<<31) | 7517, (1U<<31) | 3801, (1U<<31) | 5258, (1U<<31) | 5271, (1U<<31) | 3774, 
+  (1U<<31) | 6853, (1U<<31) | 7517, (1U<<31) | 3801, (1U<<31) | 5258, (1U<<31) | 5271, (1U<<31) | 3774, (1U<<31) | 6387, 0x4f4, 
+  (1U<<31) | 4887, 0x44f4, 0x44f4, 0x4f4, (1U<<31) | 6387, 0x4f4, (1U<<31) | 4887, 0x44f4, 
+  0x44f4, 0x4f4, (1U<<31) | 6387, (1U<<31) | 6366, (1U<<31) | 4887, (1U<<31) | 4871, (1U<<31) | 4871, (1U<<31) | 6366, 
+  (1U<<31) | 6387, (1U<<31) | 6366, (1U<<31) | 4887, (1U<<31) | 4871, (1U<<31) | 4871, (1U<<31) | 6366, (1U<<31) | 6407, (1U<<31) | 6419, 
+  (1U<<31) | 6354, (1U<<31) | 4908, (1U<<31) | 4921, (1U<<31) | 4858, (1U<<31) | 6407, (1U<<31) | 6419, (1U<<31) | 6354, (1U<<31) | 4908, 
+  (1U<<31) | 4921, (1U<<31) | 4858, (1U<<31) | 6865, (1U<<31) | 6865, (1U<<31) | 7529, (1U<<31) | 7529, (1U<<31) | 6915, (1U<<31) | 6915, 
+  (1U<<31) | 7579, (1U<<31) | 7579, (1U<<31) | 3715, (1U<<31) | 3715, (1U<<31) | 3715, (1U<<31) | 3715, (1U<<31) | 6865, (1U<<31) | 6865, 
+  (1U<<31) | 7529, (1U<<31) | 7529, (1U<<31) | 6915, (1U<<31) | 6915, (1U<<31) | 7579, (1U<<31) | 7579, (1U<<31) | 3715, (1U<<31) | 3715, 
+  (1U<<31) | 3715, (1U<<31) | 3715, (1U<<31) | 6865, (1U<<31) | 6865, (1U<<31) | 7529, (1U<<31) | 7529, (1U<<31) | 6915, (1U<<31) | 6915, 
+  (1U<<31) | 7579, (1U<<31) | 7579, (1U<<31) | 3715, (1U<<31) | 3715, (1U<<31) | 3715, (1U<<31) | 3715, (1U<<31) | 6865, (1U<<31) | 6865, 
+  (1U<<31) | 7529, (1U<<31) | 7529, (1U<<31) | 6915, (1U<<31) | 6915, (1U<<31) | 7579, (1U<<31) | 7579, (1U<<31) | 3715, (1U<<31) | 3715, 
+  (1U<<31) | 3715, (1U<<31) | 3715, (1U<<31) | 6853, (1U<<31) | 7517, (1U<<31) | 3801, (1U<<31) | 5258, (1U<<31) | 5271, (1U<<31) | 3774, 
+  (1U<<31) | 6853, (1U<<31) | 7517, (1U<<31) | 3801, (1U<<31) | 5258, (1U<<31) | 5271, (1U<<31) | 3774, 0x4f4, 0x44f4, 
+  0x4f4, 0x44f4, (1U<<31) | 6374, (1U<<31) | 4880, (1U<<31) | 6374, (1U<<31) | 4880, (1U<<31) | 3866, 0x444f0, 
+  0x4444f0, 0x444f0, 0x4444f0, 0x4f4, 0x44f4, 0x44f4, 0x4f4, 0x4f4, 
+  0x44f4, 0x44f4, 0x4f4, (1U<<31) | 6374, (1U<<31) | 4880, (1U<<31) | 6374, (1U<<31) | 4880, (1U<<31) | 3866, 
+  (1U<<31) | 3866, (1U<<31) | 3866, (1U<<31) | 3866, 0x444f0, 0x4444f0, 0x444f0, 0x4444f0, (1U<<31) | 9632, 
+  0x595959, 0x595959, 0x595959, 0x595959, 0x2c2c2c2c, 0x2c2c2c, 0x595959, 0x3b3b3b, 
+  0x4a4a4a, 0x5959, 0x445959, 0x444a4a, 0x40, 0x0, 0x442e0, 0x442e0, 
+  0x442e0, 0x442e0, 0x2e2c, 0x2e3b, 0x2e4a, 0x2e2c, 0x2e2c, 0x2e4a, 
+  0x2e4a, 0x3b, 0x4a0, 0x52c, 0x559, 0x53b, (1U<<31) | 6831, 0x54a, 
+  0x2e2c0, 0x2e3b0, 0x2e4a0, 0x2e4a0, 0x2e4a0, 0x2c2c2c, 0x3b3b3b, 0x4a4a4a, 
+  (1U<<31) | 9618, 0x4a4a4a, (1U<<31) | 9616, (1U<<31) | 9616, 0x2c2c2c, 0x3b3b3b, 0x4a4a4a, 0x2c2c2c, 
+  0x3b3b3b, 0x4a4a4a, 0x2c2c2c, 0x3b3b3b, 0x4a4a4a, 0x2c2c2c, 0x3b3b3b, 0x4a4a4a, 
+  0x2c2c59, 0x44a7a, 0x595959, 0x44a7a, 0x42c2c, 0x42c2c, 0x595959, 0x2c4, 
+  0x7a7a4a, 0x7a7a44, 0x7a7a4a, 0x7a7a44, 0x2c2c2c, 0x2c2c44, 0x595959, 0x595944, 
+  0x3b3b3b, 0x3b3b44, (1U<<31) | 9618, (1U<<31) | 9609, 0x4a4a4a, 0x4a4a44, 0x7a7a4a, 0x7a7a44, 
+  0x7a7a4a, 0x7a7a44, 0x2c2c2c, 0x2c2c44, 0x595959, 0x595944, 0x3b3b3b, 0x3b3b44, 
+  (1U<<31) | 9618, (1U<<31) | 9609, 0x4a4a4a, 0x4a4a44, 0x2c2c2c, 0x2c2c44, 0x595959, 0x595944, 
+  0x3b3b3b, 0x3b3b44, (1U<<31) | 9618, (1U<<31) | 9609, 0x4a4a4a, 0x4a4a44, 0x2c2c2c, 0x2c2c44, 
+  0x3b3b3b, 0x3b3b44, 0x4a4a4a, 0x4a4a44, 0x2c2c2c, 0x2c2c44, 0x3b3b3b, 0x3b3b44, 
+  0x4a4a4a, 0x4a4a44, 0x42c5, 0x4595, 0x43b5, 0x44a5, 0x47a4a, 0x47a4a, 
+  0x595959, 0x2c4, 0x595959, (1U<<31) | 9618, 0x4a4a4a, 0x595959, (1U<<31) | 9618, 0x4a4a4a, 
+  0x2c2c, 0x5959, 0x3b3b, (1U<<31) | 9611, 0x4a4a, 0x7a7a, 0x4595959, 0x4595959, 
+  0x42c2c59, 0x42c2c59, 0x43b3b59, 0x43b3b59, 0x44a4a59, 0x44a4a59, 0x2c4, 0x594, 
+  0x3b4, (1U<<31) | 9596, 0x4a4, 0x2c59, 0x2c4a, (1U<<31) | 6737, 0x3b59, 0x3b4a, 
+  0x4a59, 0x2c2c, (1U<<31) | 6525, 0x442c2c, 0x442c2c, 0x2c42c2c, 0x2c42c2c, 0x455959, 
+  0x555959, 0x555959, 0x443b3b, 0x443b3b, 0x3b43b3b, 0x3b43b3b, 0x444a4a, 0x444a4a, 
+  0x444a4a, 0x4a44a4a, 0x4a44a4a, 0x7a7a, 0x7a7a7a7a, 0x7a7a7a, 0x2c2c2c, 0x595959, 
+  0x3b3b3b, 0x4a4a4a, 0x2c2c2c, 0x595959, 0x3b3b3b, 0x4a4a4a, 0x3b3b3b3b, 0x3b3b3b3b, 
   0x7a7a7a, 0x2c2c2c, 0x595959, 0x3b3b3b, 0x4a4a4a, 0x2c2c2c, 0x595959, 0x3b3b3b, 
-  0x4a4a4a, 0x3b3b3b3b, 0x3b3b3b3b, 0x7a7a7a, 0x2c2c2c, 0x595959, 0x3b3b3b, 0x4a4a4a, 
-  0x2c2c2c, 0x595959, 0x3b3b3b, 0x4a4a4a, 0x3b3b3b3b, 0x4a2c2c4a, 0x4a3b3b4a, 0x4a3b3b4a, 
-  0x4a2c2c4a, 0x4a3b3b4a, 0x4a3b3b4a, 0x2c2c3b, 0x3b3b4a, 0x4a4a59, 0x2c2c3b, 0x3b3b4a, 
-  0x4a4a59, 0x2c2c3b, 0x3b3b4a, 0x4a4a59, 0x2c2c3b, 0x3b3b4a, 0x4a4a59, 0x7a7a7a7a, 
-  0x2c4a4a4a, 0x4a4a3b, 0x59594a, 0x59594a, 0x3b3b2c, 0x3b3b2c, 0x4a4a3b, 0x4a4a3b, 
-  0x59594a, 0x3b3b2c, 0x4a4a3b, 0x5959, (1U<<31) | 6628, 0x4a4a, 0x7a7a, 0x7a7a, 
-  0x7a7a, 0x7a7a, 0x7a7a, 0x2c2c2c, 0x595959, 0x59595959, 0x595959, 0x3b3b3b, 
-  0x4a4a4a, 0x4a4a4a4a, 0x4a4a4a, 0x7a7a, 0x4a4a4a4a, 0x4a4a4a, 0x2c2c2c, 0x3b3b3b, 
-  0x4a4a4a, 0x2c2c2c, 0x4a4a4a, 0x4a4a4a, 0x2c2c2c, 0x3b3b3b, 0x4a4a4a, 0x2c2c2c, 
-  0x3b3b3b, 0x4a4a4a, 0x2c2c2c, 0x4a4a4a, (1U<<31) | 6626, 0x4a4a4a, (1U<<31) | 6624, (1U<<31) | 6624, 
-  0x2c2c2c, 0x3b3b3b, 0x4a4a4a, 0x2c2c2c, 0x3b3b3b, 0x4a4a4a, 0x4a4a4a, 0x4a2c4a, 
-  0x4a3b4a, 0x4a2c4a, 0x4a4a4a, 0x3b4a, 0x2c3b, 0x3b4a, 0x4a59, 0x3b4a, 
-  0x2c3b, 0x3b4a, 0x4a59, 0x555, 0x1f0, 0x2e0, 0x2e0, 0x2e0, 
-  0x2e0, 0x2e0, 0x2e0, 0x2e0, 0x2e0, 0x555, 0x555, (1U<<31) | 6640, 
-  0x444, 0x444, (1U<<31) | 6639, 0x5, 0x5, 0x5, 0x5, 0x1, 
-  0x0, 0x1f0, (1U<<31) | 6640, 0x8a8a, 0x8a8a8a, 0x8a8a8a, 0x8a8a, 0x8a8a, 
-  0x8a8a, 0x8a8a, 0x8a8a8a, 0x8a8a8a, 0x8a8a8a, 0x8a8a8a, 0x8a8a, 0x8a8a, 
-  0x8a8a, 0x8a8a, 0x8a8a, 0x8a8a, 0x8a8a, 0x8a8a, 0x48a8a8a, (1U<<31) | 6246, 
-  (1U<<31) | 6246, (1U<<31) | 6246, (1U<<31) | 6246, 0x8a8a8a, 0x8a8a8a, 0x8a8a, 0x8a8a, (1U<<31) | 6246, 
-  (1U<<31) | 6246, (1U<<31) | 6246, (1U<<31) | 6246, (1U<<31) | 6246, 0x8a8a, 0x8a8a, 0x8a8a, 0x8a8a, 
-  0x8a8a, 0x8a8a, 0x8a8a, 0x8a8a, 0x8a8a, (1U<<31) | 6246, 0x8a8a8a, 0x8a8a8a, 
-  0x8a8a8a, (1U<<31) | 6246, (1U<<31) | 6246, 0x8a8a8a, 0x8a8a8a, (1U<<31) | 6246, (1U<<31) | 6246, (1U<<31) | 6246, 
-  (1U<<31) | 6246, (1U<<31) | 6246, (1U<<31) | 6246, 0x48a, 0x2e8a, 0x2e8a, 0x2e8a, 0x2e8a, 
-  0x2e8a, 0x2e8a, 0x2e8a, 0x2e8a, 0x2e8a, 0x2e8a, 0x2e8a, 0x2e8a, 
-  0x2e8a, 0x2e8a, 0x2e8a, 0x2e8a, 0x2e8a0, 0x2e8a0, 0x2e8a0, 0x2e8a0, 
-  0x2e8a0, 0x2e8a0, 0x2e8a0, 0x2e8a0, 0x2e8a0, 0x2e8a0, (1U<<31) | 6633, (1U<<31) | 5304, 
-  0x50, 0x50, 0x50, 0x50, 0x48, (1U<<31) | 6641, (1U<<31) | 6640, 0x0, 
-  0x44, 0x4444, 0x4444, 0x4444, 0x4444, 0x44, 0x4, 0x44, 
-  0x4, 0x4, 0x44, 0x4, (1U<<31) | 6636, 0x44, 0x4, 0x5, 
-  0x2e89, 0x2e89, 0x52e4a, 0x52e4a, 0x2e4a, 0x2e4a, 0x2e890, 0x2e890, 
-  0x52e4a0, 0x52e4a0, 0x2e4a0, 0x2e4a0, 0x888, 0x888, 0x898959, 0x898944, 
-  0x7a7a4a, 0x7a7a44, 0x898959, 0x898944, 0x7a7a4a, 0x7a7a44, 0x898959, 0x898944, 
-  0x7a7a4a, 0x7a7a44, 0x897a, 0x894a, 0x894a, 0x3b7a, 0x7a89, 0x7a7a, 
+  0x4a4a4a, 0x3b3b3b3b, (1U<<31) | 9600, 0x4a2c2c4a, 0x4a3b3b4a, 0x4a3b3b4a, 0x4a2c2c4a, (1U<<31) | 9600, 
+  0x4a3b3b4a, 0x4a3b3b4a, 0x2c2c3b, (1U<<31) | 6730, 0x3b3b4a, 0x4a4a59, 0x2c2c3b, (1U<<31) | 6730, 
+  0x3b3b4a, 0x4a4a59, 0x595959, 0x4a4a4a, 0x595959, 0x4a4a4a, 0x2c2c3b, (1U<<31) | 6730, 
+  0x3b3b4a, 0x4a4a59, 0x2c2c3b, (1U<<31) | 6730, 0x3b3b4a, 0x4a4a59, 0x7a7a7a7a, 0x595959, 
+  0x2c4a4a4a, 0x595959, 0x4a4a3b, 0x59594a, 0x59594a, 0x3b3b2c, 0x3b3b2c, 0x4a4a3b, 
+  0x4a4a3b, 0x59594a, 0x3b3b2c, 0x4a4a3b, 0x5959, (1U<<31) | 9611, 0x4a4a, 0x7a7a, 
+  0x7a7a, 0x7a7a, 0x7a7a, 0x7a7a, 0x2c2c2c, 0x595959, 0x59595959, 0x595959, 
+  0x3b3b3b, (1U<<31) | 9616, (1U<<31) | 9618, 0x4a4a4a, 0x4a4a4a4a, 0x4a4a4a, 0x7a7a, 0x4a4a4a4a, 
+  0x4a4a4a, 0x2c2c2c, 0x42c2c2c, 0x3b3b3b, 0x4a4a4a, 0x2c2c2c, 0x4a4a4a, 0x4a4a4a, 
+  0x2c2c2c, 0x3b3b3b, 0x4a4a4a, 0x2c2c2c, 0x42c2c2c, 0x3b3b3b, 0x4a4a4a, 0x2c2c2c, 
+  0x4a4a4a, 0x2c2c, 0x2c44, 0x2c2c, 0x2c44, 0x3b3b, 0x3b44, 0x3b3b, 
+  0x3b44, (1U<<31) | 9618, 0x4a4a4a, (1U<<31) | 9616, (1U<<31) | 9616, 0x2c2c2c, 0x3b3b3b, 0x4a4a4a, 
+  0x2c2c2c, 0x3b3b3b, 0x4a4a4a, 0x4a4a4a, 0x4a2c4a, 0x4a3b4a, 0x4a2c4a, 0x4a4a4a, 
+  0x3b4a, 0x2c3b, 0x3b4a, 0x4a59, 0x3b4a, 0x2c3b, 0x3b4a, 0x4a59, 
+  0x555, 0x1f0, 0x555, 0x555, 0x555, 0x5, 0x4, 0x5, 
+  0x2e0, 0x2e0, 0x2e0, 0x2e0, 0x2e0, 0x2e0, 0x2e0, 0x2e0, 
+  0x2e0, 0x42e0, 0x2e0, 0x42e0, 0x2e0, 0x2e0, 0x555, 0x555, 
+  (1U<<31) | 9632, 0x444, 0x444, 0x0, (1U<<31) | 9631, 0x5, 0x5, 0x5, 
+  0x5, 0x0, 0x0, (1U<<31) | 832, (1U<<31) | 344, (1U<<31) | 3659, (1U<<31) | 3657, (1U<<31) | 3657, 
+  (1U<<31) | 3657, (1U<<31) | 3657, (1U<<31) | 3659, (1U<<31) | 3657, (1U<<31) | 3657, (1U<<31) | 3657, (1U<<31) | 3657, (1U<<31) | 3641, 
+  (1U<<31) | 3639, (1U<<31) | 3639, (1U<<31) | 3639, (1U<<31) | 3639, (1U<<31) | 3630, (1U<<31) | 3628, (1U<<31) | 3628, (1U<<31) | 3628, 
+  (1U<<31) | 3628, (1U<<31) | 3659, (1U<<31) | 3657, (1U<<31) | 3659, (1U<<31) | 3657, (1U<<31) | 3659, (1U<<31) | 3657, (1U<<31) | 3659, 
+  (1U<<31) | 3657, (1U<<31) | 3657, (1U<<31) | 818, (1U<<31) | 816, (1U<<31) | 816, (1U<<31) | 816, (1U<<31) | 816, (1U<<31) | 818, 
+  (1U<<31) | 816, (1U<<31) | 816, (1U<<31) | 816, (1U<<31) | 816, (1U<<31) | 818, (1U<<31) | 816, (1U<<31) | 816, (1U<<31) | 816, 
+  (1U<<31) | 816, (1U<<31) | 809, (1U<<31) | 807, (1U<<31) | 807, (1U<<31) | 807, (1U<<31) | 807, (1U<<31) | 818, (1U<<31) | 816, 
+  (1U<<31) | 818, (1U<<31) | 816, (1U<<31) | 818, (1U<<31) | 816, (1U<<31) | 818, (1U<<31) | 816, (1U<<31) | 816, (1U<<31) | 334, 
+  (1U<<31) | 334, (1U<<31) | 336, (1U<<31) | 9632, 0x555, 0x555, 0x55, 0x8, (1U<<31) | 9625, 
+  (1U<<31) | 6835, 0x50, 0x50, 0x50, 0x50, 0x88, 0x48, (1U<<31) | 9633, 
+  (1U<<31) | 9632, 0x0, 0x44, 0x4444, 0x4444, 0x4444, 0x4444, 0x44, 
+  0x4, 0x44, 0x4, 0x4, 0x44, 0x4, (1U<<31) | 9628, 0x44, 
+  0x4, 0x5, (1U<<31) | 825, (1U<<31) | 398, 0x2e89, 0x2e89, 0x52e4a, 0x52e4a, 
+  (1U<<31) | 903, 0x2e4a, 0x2e4a, 0x2e890, 0x2e890, 0x52e4a0, 0x52e4a0, (1U<<31) | 902, 
+  0x2e4a0, 0x2e4a0, 0x888, 0x888, 0x898959, 0x898944, 0x7a7a4a, 0x7a7a44, 
+  0x898959, 0x898944, 0x7a7a4a, 0x7a7a44, 0x898959, 0x898944, 0x7a7a4a, 0x7a7a44, 
+  0x2c2c, 0x897a, 0x894a, 0x894a, 0x3b7a, 0x2c2c, 0x7a89, 0x7a7a, 
   0x597a, 0x4a89, 0x597a, 0x4a89, 0x898989, 0x7a7a7a, 0x595989, 0x4a4a7a, 
   0x898989, 0x7a7a7a, 0x898989, 0x7a7a7a, 0x8989, 0x8989, 0x7a7a, 0x7a7a, 
-  0x8989, 0x7a7a, 0x48959, 0x47a4a, 0x8959, 0x7a4a, 0x8959, 0x7a4a, 
-  0x45959, 0x4594a4a, 0x4a4a4a, 0x7a7a, (1U<<31) | 3184, (1U<<31) | 3184, 0x7a7a7, 0x0, 
-  (1U<<31) | 545, 0x70, 0x44a4a0, 0x4, 0x4, 0x4, 0x4, 0x4, 
+  0x8989, 0x7a7a, 0x89894, 0x7a7a4, 0x42c4, 0x894, 0x7a4, 0x48959, 
+  0x47a4a, 0x8959, 0x7a4a, 0x8959, 0x7a4a, 0x2c2c2c2c, 0x59595959, 0x3b3b3b3b, 
+  0x4a4a4a4a, (1U<<31) | 5140, 0x45959, 0x42c2c, 0x45959, 0x43b3b, 0x44a4a, 0x4594a4a, 
+  0x4a4a4a, (1U<<31) | 1998, 0x7a7a, (1U<<31) | 3787, (1U<<31) | 3787, 0x7a7a7, 0x0, (1U<<31) | 698, 
+  0x70, 0x44a4a0, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 
   0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 
-  0x4, 0x4, 0x7f2f, 0x7f2f, 0x4447a0, 0x447a0, (1U<<31) | 3184, (1U<<31) | 3184, 
-  (1U<<31) | 3184, (1U<<31) | 3184, (1U<<31) | 3157, (1U<<31) | 3184, (1U<<31) | 3184, (1U<<31) | 3157, 0x4444f4, 0x5554f5, 
-  0x44444f4, 0x55554f5, 0x44444f4, 0x55554f5, 0x4444f4, 0x5554f5, 0x4444f4, 0x5554f5, 
-  0x4444f4, 0x5554f5, 0x4444f4, 0x5554f5, 0x4444f4, 0x5554f5, 0x44444f4, 0x55554f5, 
-  0x4, 0x4, 0x42e4, 0x5e50, 0x40, 0x40, 0x50, 0x42e4, 
-  0x42e4, 0x42e0, 0x52f4, 0x4, 0x2c2c2c, 0x2c2c2c2c, 0x4a4a4a, 0x595959, 
-  0x3b3b3b, 0x2c2c2c, 0x2c2c2c2c, 0x2c2c2c, 0x2c2c2c, 0x4a4a4a, 0x595959, 0x3b3b3b, 
-  0x2c2c2c, 0x4a4a4a, 0x595959, 0x3b3b3b, 0x2c2c59, (1U<<31) | 654, (1U<<31) | 4825, (1U<<31) | 5275, 
-  (1U<<31) | 819, (1U<<31) | 654, (1U<<31) | 4825, (1U<<31) | 5275, (1U<<31) | 819, (1U<<31) | 654, (1U<<31) | 4825, (1U<<31) | 5275, 
-  (1U<<31) | 819, 0x4a4a4a, (1U<<31) | 1520, (1U<<31) | 3912, (1U<<31) | 4355, (1U<<31) | 1663, 0x42c2c, 0x44a4a, 
-  0x45959, 0x43b3b, 0x2c2c2c, 0x4a4a4a, 0x595959, 0x3b3b3b, 0x42c2c2c, (1U<<31) | 1542, 
-  0x44a4a4a, (1U<<31) | 3890, 0x43b3b3b, (1U<<31) | 1685, 0x42c2c2c, (1U<<31) | 1542, 0x44a4a4a, (1U<<31) | 3890, 
-  0x43b3b3b, (1U<<31) | 1685, (1U<<31) | 6215, (1U<<31) | 6057, (1U<<31) | 6215, (1U<<31) | 6215, (1U<<31) | 6057, (1U<<31) | 6057, 
-  0x2c2c2c, (1U<<31) | 654, 0x4a4a4a, (1U<<31) | 4825, 0x3b3b3b, (1U<<31) | 819, 0x2c2c2c, (1U<<31) | 654, 
-  0x4a4a4a, (1U<<31) | 4825, 0x3b3b3b, (1U<<31) | 819, 0x2c2c2c, (1U<<31) | 654, 0x4a4a4a, (1U<<31) | 4825, 
-  0x3b3b3b, (1U<<31) | 819, 0x2c2c2c, (1U<<31) | 654, 0x4a4a4a, (1U<<31) | 4825, 0x3b3b3b, (1U<<31) | 819, 
-  0x448989, 0x447a7a, 0x4898989, 0x47a7a7a, 0x4898989, 0x47a7a7a, (1U<<31) | 4655, (1U<<31) | 4499, 
-  0x3b2c2c3b, 0x594a4a59, 0x2c59592c, 0x4a3b3b4a, 0x2c2c3b, 0x4a4a59, 0x59592c, 0x3b3b4a, 
-  0x2c2c, (1U<<31) | 663, 0x4a4a, (1U<<31) | 4799, 0x3b3b, (1U<<31) | 828, 0x42e2c, 0x2e42c, 
-  0x2e42c, 0x3b2c2c3b, 0x594a4a59, 0x4a3b3b4a, 0x2c2c2c2c, 0x4a4a4a4a, 0x3b3b3b3b, 0x3b2c2c3b, 
-  0x594a4a59, 0x4a3b3b4a, 0x2c2c2c2c, 0x4a4a4a4a, 0x3b3b3b3b, 0x3b2c2c3b, 0x594a4a59, 0x4a3b3b4a, 
-  0x3b2c2c3b, 0x594a4a59, 0x4a3b3b4a, 0x2c2c3b, 0x4a4a59, 0x3b3b4a, 0x2c2c2c, 0x4a4a4a, 
-  0x3b3b3b, 0x2c2c3b, 0x4a4a59, 0x3b3b4a, 0x2c2c2c, 0x4a4a4a, 0x3b3b3b, 0x2c2c3b, 
-  0x4a4a59, 0x3b3b4a, 0x2c2c3b, 0x4a4a59, 0x3b3b4a, (1U<<31) | 1552, 0x4595959, 0x2c2c2c2c, 
-  0x4a4a3b, (1U<<31) | 4816, 0x59594a, (1U<<31) | 5266, 0x3b3b2c, (1U<<31) | 810, 0x4a4a3b, (1U<<31) | 4816, 
-  0x59594a, (1U<<31) | 5266, 0x3b3b2c, (1U<<31) | 810, 0x2c2c2c2c, 0x2c2c2c2c, 0x2c2c2c, 0x4a4a4a, 
-  0x595959, 0x3b3b3b, 0x2c2c2c, 0x2c2c2c, 0x2c2c2c, 0x42c2c2c, 0x2c2c2c, 0x2c2c2c, 
-  0x2c2c2c, 0x2c2c2c, 0x2c2c2c, 0x2e42c0, (1U<<31) | 1520, (1U<<31) | 1530, (1U<<31) | 3912, (1U<<31) | 3900, 
-  (1U<<31) | 1663, (1U<<31) | 1673, (1U<<31) | 1520, (1U<<31) | 1530, (1U<<31) | 3912, (1U<<31) | 3900, (1U<<31) | 1663, (1U<<31) | 1673, 
-  0x2e42c0, 0x2c2c4a, 0x4a4a59, 0x3b3b59, 0x3b3b4a, 0x4a4a2c, 0x59592c, 0x2c2c4, 
-  0x2c3b, 0x4a59, 0x3b4a, 0x2c3b, 0x4a59, 0x2c3b, 0x4a59, 0x3b4a, 
-  0x3b4a, 0x2c3b, 0x4a59, 0x3b4a, 0x3f4, 0x3f4, 0x44e4, 0x544e4, 
-  0x555e4, 0x7f7f7f3f, 0x40, 0x2e, (1U<<31) | 6509, (1U<<31) | 6504, (1U<<31) | 5218, 0x2e, 
-  0x7f41f, 0x442e440, 0x41f, 0x0, 0x7f7f3f, 0x7f7f3f, 0x2e40, 0xaf1f, 
-  0xaf1f, (1U<<31) | 6493, (1U<<31) | 6490, (1U<<31) | 6493, (1U<<31) | 6493, (1U<<31) | 6493, (1U<<31) | 6493, (1U<<31) | 6493, 
-  (1U<<31) | 6493, (1U<<31) | 6493, (1U<<31) | 6493, (1U<<31) | 6490, (1U<<31) | 6493, (1U<<31) | 6493, (1U<<31) | 6493, (1U<<31) | 6490, 
-  (1U<<31) | 6493, (1U<<31) | 6493, (1U<<31) | 6490, (1U<<31) | 6493, (1U<<31) | 6490, (1U<<31) | 6493, (1U<<31) | 6493, (1U<<31) | 6490, 
-  (1U<<31) | 6490, (1U<<31) | 3081, (1U<<31) | 5236, 0x595959, 0x5a5a5a, 0x5b5b5b, 0x595959, 0x5a5a5a, 
-  0x5b5b5b, 0x595959, 0x5a5a5a, 0x5b5b5b, 0x595959, 0x5a5a5a, 0x5b5b5b, 0x5959, 
-  0x25959, 0x8a8a8a, 0x7b7b7b, (1U<<31) | 6246, 0x7b7b7b7b, 0x28a8a8a, 0x27b7b7b, 0x8a7a, 
-  0x8a4a, 0x7b4b, 0x8a4a, 0x7b4b, 0x27b7b7b, 0x8a8a8a, 0x7b7b7b, 0x8a8a8a, 
-  0x7b7b7b, 0x2e2d, 0x592e89, 0x5a2e8a, 0x4a2e7a, 0x4b2e7b, 0x89592e0, 0x8a5a2e0, 
-  0x7a4a2e0, 0x7b4b2e0, 0x8a8a8a, 0x7b7b7b, 0x8a8a8a, 0x7b7b7b, 0x8a4, 0x7b4, 
-  0x5a5a4, 0x5a5a4, 0x5a5a4, 0x7b7b, 0x48a8a, 0x47b7b, 0x7b7b, 0x598989, 
-  0x5a8a8a, 0x4a7a7a, 0x4b7b7b, 0x89894, 0x8a8a4, 0x7a7a4, 0x7b7b4, 0x89894, 
-  0x8a8a4, 0x7a7a4, 0x7b7b4, 0x89894, 0x8a8a4, 0x7a7a4, 0x7b7b4, 0x0, 
-  0x0, (1U<<31) | 315, (1U<<31) | 361, (1U<<31) | 560, (1U<<31) | 605, (1U<<31) | 466, (1U<<31) | 523, (1U<<31) | 387, 
-  (1U<<31) | 421, (1U<<31) | 327, (1U<<31) | 339, (1U<<31) | 572, (1U<<31) | 617, (1U<<31) | 478, (1U<<31) | 490, (1U<<31) | 399, 
-  (1U<<31) | 433, 0x4a2e4a, 0x4b2e4b, 0x592e59, 0x5a2e5a, 0x4a4a2e0, 0x4b4b2e0, 0x59592e0, 
-  0x5a5a2e0, 0x22d2d3c, 0x4b4b3c, 0x3c3c2d, 0x4b4b3c, 0x3c3c2d, 0x2d2d2d, 0x3c3c3c, 
-  0x2d2d2d2d, 0x4b4b4b, 0x4b7b7b, 0x4b4b4b, 0x3c3c3c, 0x3c3c3c, 0x4b4b4b, 0x3c3c3c, 
-  0x3c3c3c, 0x2d2d3c, 0x3c3c4b, 0x2d4, 0x3c3c3c, 0x3c3c3c, 0x3c3c3c, 0x2d2d5a, 
-  0x2d2d2d, 0x2d2d2d, 0x4b4b4b, 0x3c3c3c, 0x4a4b4b, 0x595a5a, 0x3b3c3c, 0x44b4b, 
-  0x45a5a, 0x43c3c, 0x4a4a4a, 0x4b4b4b, 0x595959, 0x5a5a5a, 0x4a4b4b, 0x3b3c3c, 
-  0x44b4b, 0x43c3c, 0x4a4a4a, 0x4b4b4b, 0x4a4b4b, 0x595a5a, 0x3b3c3c, 0x44b4b, 
-  0x45a5a, 0x43c3c, 0x4a4a4a, 0x4b4b4b, 0x595959, 0x5a5a5a, 0x48b8b8b, 0x47c7c7c, 
-  0x259, 0x25a, 0x25b, 0x34a, 0x34b, 0x34c, 0x4898919, 0x48a8a1a, 
-  0x448b8b1b, 0x47a7a1a, 0x47b7b1b, 0x447c7c1c, 0x4a4a, 0x4b4b, 0x4c4c, 0x5959, 
-  0x5a5a, 0x5b5b, 0x458989, 0x447a7a, 0x457a7a, 0x4894, 0x4895, 0x4894, 
-  0x4895, 0x47a4, 0x47a5, 0x47a4, 0x47a5, 0x447a7a, 0x458989, 0x457a7a, 
-  0x42c2c3b, 0x42d2d3c, (1U<<31) | 1598, 0x48b8b8b, 0x47c7c7c, 0x428b8b8b, 0x437c7c7c, 0x48919, 
-  0x48a1a, 0x48b1b, 0x47a1a, 0x47b1b, 0x47c1c, (1U<<31) | 1286, (1U<<31) | 1618, (1U<<31) | 1264, 
-  (1U<<31) | 1629, (1U<<31) | 1418, (1U<<31) | 1385, (1U<<31) | 1396, (1U<<31) | 1407, (1U<<31) | 1330, (1U<<31) | 1308, (1U<<31) | 1374, 
-  (1U<<31) | 1352, (1U<<31) | 1319, (1U<<31) | 1297, (1U<<31) | 1363, (1U<<31) | 1341, (1U<<31) | 1231, (1U<<31) | 1198, (1U<<31) | 1242, 
-  (1U<<31) | 1209, (1U<<31) | 1220, (1U<<31) | 1187, (1U<<31) | 1275, (1U<<31) | 1253, 0x442e4b20, 0x442e4c30, 0x442e5b20, 
-  0x442e5b20, 0x1b1b1b, 0x1d1d1d, (1U<<31) | 171, 0x1c1c1c, 0x1b1b4, 0x1d1d4, (1U<<31) | 178, 
-  0x1c1c4, 0x1b1b4, 0x1d1d4, (1U<<31) | 178, 0x1c1c4, (1U<<31) | 1486, (1U<<31) | 1441, 0x42489892, 
-  0x4247a7a2, (1U<<31) | 87, 0x24a894a, 0x424b8b4b, 0x27a897a, 0x427b8b7b, 0x2598959, 0x25a8a5a, 
-  0x425b8b5b, 0x24a894a, 0x24a8a4a, 0x424b8b4b, 0x2598959, 0x25a8a5a, 0x425b8b5b, 0x24a7a4a, 
-  0x24b7b4b, 0x434c7c4c, 0x428b7b8b, 0x2597a59, 0x25a7a5a, 0x425b7b5b, 0x24a7a4a, 0x24b7b4b, 
-  0x434c7c4c, 0x2597a59, 0x25a7a5a, 0x425b7b5b, 0x27a597a, (1U<<31) | 1452, (1U<<31) | 1475, 0x24a894a, 
-  0x424b8b4b, 0x2598959, 0x25a8a5a, 0x425b8b5b, 0x24a894a, 0x24a8a4a, 0x424b8b4b, 0x2598959, 
-  0x25a8a5a, 0x425b8b5b, 0x434c7c4c, 0x2597a59, 0x25a7a5a, 0x425b7b5b, 0x24a7a4a, 0x24b7b4b, 
-  0x434c7c4c, 0x2597a59, 0x25a7a5a, 0x425b7b5b, 0x27a597a, (1U<<31) | 1486, (1U<<31) | 1441, (1U<<31) | 87, 
-  (1U<<31) | 293, (1U<<31) | 304, (1U<<31) | 1175, (1U<<31) | 271, (1U<<31) | 282, (1U<<31) | 1606, (1U<<31) | 1163, (1U<<31) | 1151, 
-  0x24892, 0x247a2, (1U<<31) | 1051, (1U<<31) | 1111, (1U<<31) | 1027, (1U<<31) | 1123, (1U<<31) | 1099, (1U<<31) | 1063, 
-  (1U<<31) | 1075, (1U<<31) | 1087, (1U<<31) | 907, (1U<<31) | 883, (1U<<31) | 1003, (1U<<31) | 979, (1U<<31) | 895, (1U<<31) | 871, 
-  (1U<<31) | 991, (1U<<31) | 967, (1U<<31) | 859, (1U<<31) | 847, (1U<<31) | 955, (1U<<31) | 931, (1U<<31) | 943, (1U<<31) | 919, 
-  (1U<<31) | 1039, (1U<<31) | 1015, 0x2898989, 0x28a8a8a, 0x428b8b8b, 0x27a7a7a, 0x27b7b7b, 0x437c7c7c, 
-  (1U<<31) | 1486, (1U<<31) | 1441, 0x28948989, 0x28a48a8a, (1U<<31) | 1499, 0x27a47a7a, 0x27b47b7b, (1U<<31) | 1642, 
-  (1U<<31) | 1463, (1U<<31) | 1429, (1U<<31) | 1486, (1U<<31) | 1441, (1U<<31) | 1486, (1U<<31) | 1441, (1U<<31) | 1486, (1U<<31) | 1441, 
-  0x22c4a2c, 0x22c4b2c, 0x32c4c2c, 0x24a2e0, 0x24b2e0, 0x34c2e0, 0x23b4a3b, 0x23b4b3b, 
-  0x33c4c3c, 0x24a2e0, 0x24b2e0, 0x34c2e0, 0x22c592c, 0x22c5a2c, 0x22c5b2c, 0x2592e0, 
-  0x25a2e0, 0x25b2e0, 0x24a594a, 0x2592e0, 0x25a2e0, 0x25b2e0, 0x23b593b, 0x23b5a3b, 
-  0x23b5b3b, 0x2592e0, 0x25a2e0, 0x25b2e0, 0x22c3b2c, 0x23b2e0, 0x33c2e0, 0x43d2e0, 
-  0x22c4a2c, 0x22c4b2c, 0x32c4c2c, 0x24a2e0, 0x24b2e0, 0x34c2e0, 0x23b4a3b, 0x23b4b3b, 
-  0x33c4c3c, 0x24a2e0, 0x24b2e0, 0x34c2e0, 0x22c592c, 0x22c5a2c, 0x22c5b2c, 0x2592e0, 
-  0x25a2e0, 0x25b2e0, 0x24a594a, 0x24a5a4a, 0x24b5b4b, 0x2592e0, 0x25a2e0, 0x25b2e0, 
-  0x23b593b, 0x23b5a3b, 0x23b5b3b, 0x2592e0, 0x25a2e0, 0x25b2e0, 0x22c3b2c, 0x32c3c2c, 
-  0x42d3d2d, 0x23b2e0, 0x33c2e0, 0x43d2e0, 0x22c4a2c, 0x22c4b2c, 0x32c4c2c, 0x24a2e0, 
-  0x24b2e0, 0x34c2e0, 0x23b4a3b, 0x23b4b3b, 0x33c4c3c, 0x24a2e0, 0x24b2e0, 0x34c2e0, 
-  0x22c592c, 0x22c5a2c, 0x22c5b2c, 0x2592e0, 0x25a2e0, 0x25b2e0, 0x24a594a, 0x24a5a4a, 
-  0x24b5b4b, 0x2592e0, 0x25a2e0, 0x25b2e0, 0x23b593b, 0x23b5a3b, 0x23b5b3b, 0x2592e0, 
-  0x25a2e0, 0x25b2e0, 0x22c3b2c, 0x32c3c2c, 0x42d3d2d, 0x23b2e0, 0x33c2e0, 0x43d2e0, 
-  (1U<<31) | 549, (1U<<31) | 594, (1U<<31) | 1497, (1U<<31) | 455, (1U<<31) | 512, (1U<<31) | 1640, (1U<<31) | 3100, (1U<<31) | 3088, 
-  0x28948989, 0x28a48a8a, (1U<<31) | 1499, 0x27a47a7a, 0x27b47b7b, (1U<<31) | 1642, (1U<<31) | 3100, (1U<<31) | 3088, 
-  0x28948989, 0x28a48a8a, (1U<<31) | 1499, 0x27a47a7a, 0x27b47b7b, (1U<<31) | 1642, (1U<<31) | 3100, (1U<<31) | 3088, 
-  (1U<<31) | 584, (1U<<31) | 629, (1U<<31) | 1509, (1U<<31) | 502, (1U<<31) | 535, (1U<<31) | 1652, (1U<<31) | 1486, (1U<<31) | 1441, 
-  (1U<<31) | 4747, (1U<<31) | 4024, (1U<<31) | 4417, (1U<<31) | 4612, (1U<<31) | 4768, (1U<<31) | 3995, (1U<<31) | 4438, (1U<<31) | 4591, 
-  (1U<<31) | 4684, (1U<<31) | 4334, (1U<<31) | 4726, (1U<<31) | 4386, (1U<<31) | 4528, (1U<<31) | 3922, (1U<<31) | 4549, (1U<<31) | 3943, 
-  (1U<<31) | 4663, (1U<<31) | 4313, (1U<<31) | 4705, (1U<<31) | 4365, (1U<<31) | 4507, (1U<<31) | 3869, (1U<<31) | 4570, (1U<<31) | 3964, 
-  (1U<<31) | 1486, (1U<<31) | 1441, (1U<<31) | 1486, (1U<<31) | 1441, 0x27a3b7a, 0x27b3b7b, 0x437c3c7c, 0x23b47a3b, 
-  0x23b47b3b, 0x33c47c3c, (1U<<31) | 293, (1U<<31) | 304, (1U<<31) | 1175, (1U<<31) | 271, (1U<<31) | 282, (1U<<31) | 1606, 
-  (1U<<31) | 1163, (1U<<31) | 1151, 0x48b8b8b, 0x47c7c7c, 0x48b8b8b, 0x47c7c7c, 0x48b8b8b, 0x47c7c7c, 
-  0x4c4c3d, (1U<<31) | 835, 0x4c4c3d, (1U<<31) | 835, (1U<<31) | 774, 0x3d3d3d, 0x5a8a8a, 0x5b8b8b, 
-  0x5a5a5a, 0x5b5b5b, 0x3b3b3b, 0x3c3c3c, 0x3d3d3d, 0x2c2c2c, 0x2d2d2d, (1U<<31) | 774, 
-  0x4c7c7c, 0x4c4c4c, (1U<<31) | 781, 0x3d3d4c, 0x3d3d3d, 0x3d3d3d, 0x3d3d3d, 0x2c2c2c, 
-  0x2d2d2d, (1U<<31) | 774, (1U<<31) | 788, (1U<<31) | 774, 0x4a4c4c, 0x595b5b, 0x3b3d3d, 0x44c4c, 
-  0x45b5b, 0x43d3d, 0x4c4c4c, 0x5b5b5b, 0x3b3b3b, 0x3c3c3c, 0x3d3d3d, 0x4a4c4c, 
-  0x595959, 0x595a5a, 0x595b5b, 0x3b3d3d, 0x44c4c, 0x45959, 0x45a5a, 0x45b5b, 
-  0x43d3d, 0x4c4c4c, 0x595959, 0x5a5a5a, 0x5b5b5b, 0x3b3b3b, 0x3c3c3c, 0x3d3d3d, 
-  0x4a4c4c, 0x595b5b, 0x3b3d3d, 0x44c4c, 0x45b5b, 0x43d3d, 0x4c4c4c, 0x5b5b5b, 
-  0x3b3b3b, 0x3c3c3c, 0x3d3d3d, (1U<<31) | 3912, (1U<<31) | 3985, (1U<<31) | 4046, (1U<<31) | 4355, (1U<<31) | 4407, 
-  (1U<<31) | 4459, 0x2898989, 0x28a8a8a, 0x28b8b8b, 0x27a7a7a, 0x27b7b7b, 0x37c7c7c, (1U<<31) | 584, 
-  (1U<<31) | 502, 0x428b8b8b, 0x437c7c7c, (1U<<31) | 1486, (1U<<31) | 1441, 0x2898989, 0x28a8a8a, 0x28b8b8b, 
-  0x27a7a7a, 0x27b7b7b, 0x37c7c7c, (1U<<31) | 584, (1U<<31) | 502, 0x428b8b8b, 0x437c7c7c, (1U<<31) | 1486, 
-  (1U<<31) | 1441, (1U<<31) | 4758, (1U<<31) | 4035, (1U<<31) | 4428, (1U<<31) | 4623, (1U<<31) | 4779, (1U<<31) | 4006, (1U<<31) | 4449, 
-  (1U<<31) | 4602, (1U<<31) | 4695, (1U<<31) | 4345, (1U<<31) | 4737, (1U<<31) | 4397, (1U<<31) | 4539, (1U<<31) | 3933, (1U<<31) | 4560, 
-  (1U<<31) | 3954, 0x442e4b20, 0x442e4c30, 0x442e5b20, 0x442e5b20, (1U<<31) | 4674, (1U<<31) | 4324, (1U<<31) | 4716, 
-  (1U<<31) | 4376, (1U<<31) | 4518, (1U<<31) | 3880, (1U<<31) | 4581, (1U<<31) | 3975, 0x49f2f, 0x48b8b, 0x47c7c, 
-  0x48b8b8b, 0x47c7c7c, 0x49f2f, 0x4489894, 0x447a7a4, 0x4894, 0x4895, 0x4894, 
-  0x4895, 0x47a4, 0x47a5, 0x47a4, 0x47a5, 0x47777, 0x48888, (1U<<31) | 4789, 
-  (1U<<31) | 4633, (1U<<31) | 4789, (1U<<31) | 4633, (1U<<31) | 4806, (1U<<31) | 4834, (1U<<31) | 4869, (1U<<31) | 5256, (1U<<31) | 5284, 
-  (1U<<31) | 5294, 0x4a4a4a4a, 0x4b4b4b4b, 0x4c4c4c4c, 0x4a4a4a4a, 0x4b4b4b4b, 0x4c4c4c4c, 0x4a4a4a4a, 
-  0x4b4b4b4b, 0x4c4c4c4c, 0x4a4a4a4a, 0x4b4b4b4b, 0x4c4c4c4c, 0x4a4a4a4a, 0x4b4b4b4b, 0x4c4c4c4c, 
-  0x3b3b3b3b, 0x3c3c3c3c, 0x3d3d3d3d, (1U<<31) | 6206, (1U<<31) | 6237, (1U<<31) | 6255, 0x7a4a7a7a, 0x7b4b7b7b, 
-  0x7c4c7c7c, 0x59595959, 0x5a5a5a5a, 0x5b5b5b5b, 0x2c2c2c2c, 0x2d2d2d2d, (1U<<31) | 772, 0x5b8b8b, 
-  0x4c7c7c, 0x59595959, 0x5a5a5a5a, 0x5b5b5b5b, 0x59595959, 0x5a5a5a5a, 0x5b5b5b5b, 0x2c2c1c, 
-  0x2d2d1d, (1U<<31) | 765, 0x7a7a3b, 0x7b7b3c, 0x7c7c3d, 0x7b3b, 0x7c3c, 0x4a4a7a7a, 
-  0x4b4b7b7b, 0x4c4c7c7c, 0x1a3b7a3b, 0x444, 0x555, 0x444, 0x555, 0x444, 
-  0x555, 0x444, 0x555, 0x2e0, 0x2e0, 0x2e0, 0x2e0, 0x2e0, 
-  0x42e0, 0x52e0, 0x2e2e2, 0x2e2e2, 0x4, 0x5, 0x40, 0x50, 
+  0x4, 0x7f2f, 0x7f2f, 0x4447a0, 0x447a0, (1U<<31) | 3787, (1U<<31) | 3787, (1U<<31) | 3787, 
+  (1U<<31) | 3787, (1U<<31) | 3760, (1U<<31) | 3787, (1U<<31) | 3787, (1U<<31) | 3760, 0x4444f4, 0x5554f5, 0x44444f4, 
+  0x55554f5, 0x44444f4, 0x55554f5, 0x4444f4, 0x5554f5, 0x4444f4, 0x5554f5, 0x4444f4, 
+  0x5554f5, 0x4444f4, 0x5554f5, 0x4444f4, 0x5554f5, 0x44444f4, 0x55554f5, (1U<<31) | 9183, 
+  (1U<<31) | 9070, (1U<<31) | 9183, (1U<<31) | 9070, (1U<<31) | 9058, (1U<<31) | 9183, (1U<<31) | 9070, (1U<<31) | 9183, (1U<<31) | 9070, 
+  (1U<<31) | 9183, (1U<<31) | 9070, (1U<<31) | 9183, (1U<<31) | 9070, (1U<<31) | 8425, (1U<<31) | 9183, (1U<<31) | 9070, (1U<<31) | 9183, 
+  (1U<<31) | 9070, (1U<<31) | 9183, (1U<<31) | 9070, (1U<<31) | 8469, (1U<<31) | 8403, (1U<<31) | 9203, (1U<<31) | 9084, (1U<<31) | 9203, 
+  (1U<<31) | 9084, (1U<<31) | 9203, (1U<<31) | 9084, (1U<<31) | 9203, (1U<<31) | 9084, (1U<<31) | 9203, (1U<<31) | 9084, (1U<<31) | 9203, 
+  (1U<<31) | 9084, (1U<<31) | 9183, (1U<<31) | 9070, 0x7fbf1f, 0x7fffbf1f, (1U<<31) | 9151, (1U<<31) | 9028, (1U<<31) | 9151, 
+  (1U<<31) | 9028, (1U<<31) | 9183, (1U<<31) | 9070, (1U<<31) | 9058, (1U<<31) | 9183, (1U<<31) | 9070, (1U<<31) | 9151, (1U<<31) | 9028, 
+  (1U<<31) | 9151, (1U<<31) | 9028, (1U<<31) | 9183, (1U<<31) | 9070, (1U<<31) | 1066, (1U<<31) | 8528, (1U<<31) | 8512, (1U<<31) | 9203, 
+  (1U<<31) | 9084, (1U<<31) | 9203, (1U<<31) | 9084, (1U<<31) | 9203, (1U<<31) | 9084, (1U<<31) | 9203, (1U<<31) | 9084, (1U<<31) | 9203, 
+  (1U<<31) | 9084, (1U<<31) | 9203, (1U<<31) | 9084, (1U<<31) | 9203, (1U<<31) | 9084, (1U<<31) | 9203, (1U<<31) | 9084, (1U<<31) | 9151, 
+  (1U<<31) | 9028, (1U<<31) | 9151, (1U<<31) | 9028, (1U<<31) | 9151, (1U<<31) | 9028, (1U<<31) | 9151, (1U<<31) | 9028, (1U<<31) | 9183, 
+  (1U<<31) | 9070, (1U<<31) | 9162, (1U<<31) | 9125, (1U<<31) | 9162, (1U<<31) | 9125, (1U<<31) | 9162, (1U<<31) | 9125, (1U<<31) | 9162, 
+  (1U<<31) | 9125, (1U<<31) | 9183, (1U<<31) | 9070, (1U<<31) | 9183, (1U<<31) | 9070, (1U<<31) | 9183, (1U<<31) | 9070, (1U<<31) | 9183, 
+  (1U<<31) | 9070, (1U<<31) | 9183, (1U<<31) | 9070, (1U<<31) | 9183, (1U<<31) | 9070, 0x9f7f3f, (1U<<31) | 8425, (1U<<31) | 9183, 
+  (1U<<31) | 9070, (1U<<31) | 9495, (1U<<31) | 9467, (1U<<31) | 9183, (1U<<31) | 9070, (1U<<31) | 9203, (1U<<31) | 9084, (1U<<31) | 9203, 
+  (1U<<31) | 9084, (1U<<31) | 9203, (1U<<31) | 9084, (1U<<31) | 9203, (1U<<31) | 9084, (1U<<31) | 9203, (1U<<31) | 9084, (1U<<31) | 9203, 
+  (1U<<31) | 9084, (1U<<31) | 9203, (1U<<31) | 9084, (1U<<31) | 9504, (1U<<31) | 9481, (1U<<31) | 9504, (1U<<31) | 9481, (1U<<31) | 9495, 
+  (1U<<31) | 9467, (1U<<31) | 9504, (1U<<31) | 9481, (1U<<31) | 9504, (1U<<31) | 9481, (1U<<31) | 9162, (1U<<31) | 9125, (1U<<31) | 9162, 
+  (1U<<31) | 9125, (1U<<31) | 9495, (1U<<31) | 9467, (1U<<31) | 9183, (1U<<31) | 9070, 0x9f3f, (1U<<31) | 8415, (1U<<31) | 8407, 
+  (1U<<31) | 8390, 0x9f7fe3f, (1U<<31) | 8449, 0x9f7fe3f, (1U<<31) | 8449, (1U<<31) | 8954, (1U<<31) | 8927, (1U<<31) | 9210, 
+  (1U<<31) | 9110, (1U<<31) | 9151, (1U<<31) | 9028, (1U<<31) | 9173, (1U<<31) | 9045, (1U<<31) | 9151, (1U<<31) | 9028, (1U<<31) | 8476, 
+  (1U<<31) | 8476, (1U<<31) | 9183, (1U<<31) | 9070, (1U<<31) | 9183, (1U<<31) | 9070, 0x9f3f, (1U<<31) | 9058, (1U<<31) | 9173, 
+  (1U<<31) | 9042, (1U<<31) | 9173, (1U<<31) | 9042, (1U<<31) | 9173, (1U<<31) | 9042, (1U<<31) | 9173, (1U<<31) | 9042, (1U<<31) | 9173, 
+  (1U<<31) | 9042, (1U<<31) | 9173, (1U<<31) | 9042, (1U<<31) | 9183, (1U<<31) | 9070, (1U<<31) | 9183, (1U<<31) | 9070, (1U<<31) | 8476, 
+  (1U<<31) | 8476, (1U<<31) | 8476, (1U<<31) | 8476, (1U<<31) | 9173, (1U<<31) | 9045, 0x9f7f3f, (1U<<31) | 8485, (1U<<31) | 9173, 
+  (1U<<31) | 9042, 0x9f3f, (1U<<31) | 9173, (1U<<31) | 9042, (1U<<31) | 9173, (1U<<31) | 9042, 0x9f7f3f, (1U<<31) | 8485, 
+  (1U<<31) | 9173, (1U<<31) | 9042, (1U<<31) | 9173, (1U<<31) | 9042, (1U<<31) | 9173, (1U<<31) | 9042, (1U<<31) | 9173, (1U<<31) | 9042, 
+  (1U<<31) | 9173, (1U<<31) | 9042, 0x9f7f3f, (1U<<31) | 8485, (1U<<31) | 9183, (1U<<31) | 9070, (1U<<31) | 9183, (1U<<31) | 9070, 
+  (1U<<31) | 9183, (1U<<31) | 9070, (1U<<31) | 9183, (1U<<31) | 9070, (1U<<31) | 8519, 0x9f7f3f, (1U<<31) | 8505, (1U<<31) | 275, 
+  (1U<<31) | 8476, (1U<<31) | 8476, (1U<<31) | 9495, (1U<<31) | 9467, (1U<<31) | 9495, (1U<<31) | 9467, (1U<<31) | 9151, (1U<<31) | 9028, 
+  (1U<<31) | 9151, (1U<<31) | 9028, (1U<<31) | 9495, (1U<<31) | 9467, (1U<<31) | 9495, (1U<<31) | 9467, (1U<<31) | 9183, (1U<<31) | 9070, 
+  0x7fbf1f, 0x7fffbf1f, (1U<<31) | 9162, (1U<<31) | 9125, (1U<<31) | 9162, (1U<<31) | 9125, (1U<<31) | 9162, (1U<<31) | 9125, 
+  (1U<<31) | 9162, (1U<<31) | 9125, (1U<<31) | 9162, (1U<<31) | 9125, (1U<<31) | 9162, (1U<<31) | 9125, (1U<<31) | 9162, (1U<<31) | 9125, 
+  (1U<<31) | 9162, (1U<<31) | 9125, (1U<<31) | 9183, (1U<<31) | 9070, (1U<<31) | 9183, (1U<<31) | 9070, (1U<<31) | 9183, (1U<<31) | 9070, 
+  (1U<<31) | 9183, (1U<<31) | 9070, (1U<<31) | 9183, (1U<<31) | 9070, (1U<<31) | 9183, (1U<<31) | 9070, (1U<<31) | 9058, (1U<<31) | 8496, 
+  (1U<<31) | 8437, 0x7f7f7f1f, 0x7f7f1f, (1U<<31) | 9203, (1U<<31) | 9139, (1U<<31) | 9183, (1U<<31) | 9070, (1U<<31) | 9183, 
+  (1U<<31) | 9070, (1U<<31) | 8942, (1U<<31) | 8899, (1U<<31) | 8942, (1U<<31) | 8899, (1U<<31) | 9183, (1U<<31) | 9070, (1U<<31) | 9183, 
+  (1U<<31) | 9070, (1U<<31) | 9183, (1U<<31) | 9070, (1U<<31) | 9183, (1U<<31) | 9070, (1U<<31) | 8953, (1U<<31) | 8913, (1U<<31) | 9183, 
+  (1U<<31) | 9070, (1U<<31) | 9183, (1U<<31) | 9070, (1U<<31) | 9183, (1U<<31) | 9070, (1U<<31) | 9183, (1U<<31) | 9070, (1U<<31) | 9183, 
+  (1U<<31) | 9070, (1U<<31) | 9192, (1U<<31) | 9096, (1U<<31) | 9192, (1U<<31) | 9096, (1U<<31) | 9495, (1U<<31) | 9467, (1U<<31) | 9183, 
+  (1U<<31) | 9070, (1U<<31) | 9495, (1U<<31) | 9467, (1U<<31) | 9183, (1U<<31) | 9070, (1U<<31) | 9504, (1U<<31) | 9481, (1U<<31) | 9504, 
+  (1U<<31) | 9481, (1U<<31) | 9504, (1U<<31) | 9481, (1U<<31) | 9504, (1U<<31) | 9481, (1U<<31) | 9495, (1U<<31) | 9467, (1U<<31) | 9495, 
+  (1U<<31) | 9467, (1U<<31) | 9495, (1U<<31) | 9467, (1U<<31) | 9162, (1U<<31) | 9125, (1U<<31) | 9162, (1U<<31) | 9125, (1U<<31) | 9495, 
+  (1U<<31) | 9467, (1U<<31) | 9183, (1U<<31) | 9070, (1U<<31) | 9495, (1U<<31) | 9467, (1U<<31) | 9183, (1U<<31) | 9070, (1U<<31) | 9183, 
+  (1U<<31) | 9070, (1U<<31) | 9203, (1U<<31) | 9139, 0x4, 0x4, 0x42e4, 0x5e50, 0x40, 
+  0x40, 0x50, 0x42e4, 0x42e4, 0x42e0, 0x52f4, 0x4, 0x2c2c2c, 
+  0x2c2c2c2c, 0x4a4a4a, 0x595959, 0x3b3b3b, 0x2c2c2c, 0x2c2c2c2c, 0x2c2c2c, 0x2c2c2c, 
+  0x4a4a4a, 0x595959, 0x3b3b3b, 0x2c2c2c, 0x4a4a4a, 0x595959, 0x3b3b3b, 0x2c2c59, 
+  (1U<<31) | 854, (1U<<31) | 6064, (1U<<31) | 6684, (1U<<31) | 1129, (1U<<31) | 854, (1U<<31) | 6064, (1U<<31) | 6684, (1U<<31) | 1129, 
+  (1U<<31) | 854, (1U<<31) | 6064, (1U<<31) | 6684, (1U<<31) | 1129, 0x4a4a4a, (1U<<31) | 1998, (1U<<31) | 4669, (1U<<31) | 5140, 
+  (1U<<31) | 2139, 0x42c2c, 0x44a4a, 0x45959, 0x43b3b, 0x2c2c2c, 0x4a4a4a, 0x595959, 
+  0x3b3b3b, 0x42c2c2c, (1U<<31) | 2020, 0x44a4a4a, (1U<<31) | 4647, 0x43b3b3b, (1U<<31) | 2161, 0x42c2c2c, 
+  (1U<<31) | 2020, 0x44a4a4a, (1U<<31) | 4647, 0x43b3b3b, (1U<<31) | 2161, (1U<<31) | 8302, (1U<<31) | 7721, (1U<<31) | 8302, 
+  (1U<<31) | 8302, (1U<<31) | 7721, (1U<<31) | 7721, 0x2c2c2c, (1U<<31) | 854, 0x4a4a4a, (1U<<31) | 6064, 0x3b3b3b, 
+  (1U<<31) | 1129, 0x2c2c2c, (1U<<31) | 854, 0x4a4a4a, (1U<<31) | 6064, 0x3b3b3b, (1U<<31) | 1129, 0x2c2c2c, 
+  (1U<<31) | 854, 0x4a4a4a, (1U<<31) | 6064, 0x3b3b3b, (1U<<31) | 1129, 0x2c2c2c, (1U<<31) | 854, 0x4a4a4a, 
+  (1U<<31) | 6064, 0x3b3b3b, (1U<<31) | 1129, 0x448989, 0x447a7a, 0x4898989, 0x47a7a7a, 0x4898989, 
+  0x47a7a7a, (1U<<31) | 5548, (1U<<31) | 5289, 0x3b2c2c3b, 0x594a4a59, 0x2c59592c, 0x4a3b3b4a, 0x2c2c3b, 
+  0x4a4a59, 0x59592c, 0x3b3b4a, 0x2c2c, (1U<<31) | 874, 0x4a4a, (1U<<31) | 6038, 0x3b3b, 
+  (1U<<31) | 1138, 0x42e2c, 0x2e42c, 0x2e42c, 0x3b2c2c3b, 0x594a4a59, 0x4a3b3b4a, 0x2c2c2c2c, 
+  0x4a4a4a4a, 0x3b3b3b3b, 0x3b2c2c3b, 0x594a4a59, 0x4a3b3b4a, 0x2c2c2c2c, 0x4a4a4a4a, 0x3b3b3b3b, 
+  0x3b2c2c3b, 0x594a4a59, 0x4a3b3b4a, 0x3b2c2c3b, 0x594a4a59, 0x4a3b3b4a, 0x2c2c3b, 0x4a4a59, 
+  0x3b3b4a, 0x2c2c2c, 0x4a4a4a, 0x3b3b3b, 0x2c2c3b, 0x4a4a59, 0x3b3b4a, 0x2c2c2c, 
+  0x4a4a4a, 0x3b3b3b, 0x2c2c3b, 0x4a4a59, 0x3b3b4a, 0x2c2c3b, 0x4a4a59, 0x3b3b4a, 
+  (1U<<31) | 2030, 0x4595959, 0x2c2c2c2c, 0x4a4a3b, (1U<<31) | 6055, 0x59594a, (1U<<31) | 6653, 0x3b3b2c, 
+  (1U<<31) | 1120, 0x4a4a3b, (1U<<31) | 6055, 0x59594a, (1U<<31) | 6653, 0x3b3b2c, (1U<<31) | 1120, 0x2c2c2c2c, 
+  0x2c2c2c2c, 0x2c2c2c, 0x4a4a4a, 0x595959, 0x3b3b3b, 0x2c2c2c, 0x2c2c2c, 0x2c2c2c, 
+  0x42c2c2c, 0x42c2c2c, 0x2c2c2c, 0x2c2c2c, 0x2c2c2c, 0x42c2c2c, 0x2c2c2c, 0x2c2c2c, 
+  0x2e42c0, (1U<<31) | 1998, (1U<<31) | 2008, (1U<<31) | 4669, (1U<<31) | 4657, (1U<<31) | 2139, (1U<<31) | 2149, (1U<<31) | 1998, 
+  (1U<<31) | 2008, (1U<<31) | 4669, (1U<<31) | 4657, (1U<<31) | 2139, (1U<<31) | 2149, 0x2e42c0, (1U<<31) | 843, (1U<<31) | 881, 
+  (1U<<31) | 863, (1U<<31) | 843, (1U<<31) | 881, (1U<<31) | 863, 0x2c2c4a, 0x4a4a59, 0x3b3b59, 0x3b3b4a, 
+  0x4a4a2c, 0x59592c, 0x2c2c4, 0x2c3b, 0x4a59, 0x3b4a, 0x2c3b, 0x4a59, 
+  0x2c3b, 0x4a59, 0x3b4a, 0x3b4a, 0x2c3b, 0x4a59, 0x3b4a, (1U<<31) | 332, 
+  (1U<<31) | 391, (1U<<31) | 332, (1U<<31) | 391, (1U<<31) | 339, (1U<<31) | 339, (1U<<31) | 384, (1U<<31) | 384, (1U<<31) | 6565, 
+  (1U<<31) | 6580, (1U<<31) | 6587, (1U<<31) | 5946, (1U<<31) | 5917, (1U<<31) | 5937, (1U<<31) | 1597, (1U<<31) | 334, (1U<<31) | 393, 
+  (1U<<31) | 332, (1U<<31) | 391, (1U<<31) | 332, (1U<<31) | 391, 0x2e5, 0x2e2e5, (1U<<31) | 1597, 0x42e50, 
+  0x42e50, (1U<<31) | 5716, (1U<<31) | 5926, (1U<<31) | 5962, (1U<<31) | 5742, (1U<<31) | 5996, (1U<<31) | 6028, (1U<<31) | 5716, 
+  (1U<<31) | 5926, (1U<<31) | 5962, (1U<<31) | 5742, (1U<<31) | 5996, (1U<<31) | 6028, (1U<<31) | 5716, (1U<<31) | 5926, (1U<<31) | 5962, 
+  (1U<<31) | 5742, (1U<<31) | 5996, (1U<<31) | 6028, (1U<<31) | 5694, (1U<<31) | 5093, (1U<<31) | 5926, (1U<<31) | 5716, (1U<<31) | 5926, 
+  (1U<<31) | 5962, (1U<<31) | 5742, (1U<<31) | 5996, (1U<<31) | 6028, (1U<<31) | 5716, (1U<<31) | 5926, (1U<<31) | 5962, (1U<<31) | 5742, 
+  (1U<<31) | 5996, (1U<<31) | 6028, (1U<<31) | 5954, (1U<<31) | 5996, (1U<<31) | 5730, (1U<<31) | 5954, (1U<<31) | 5996, (1U<<31) | 5730, 
+  (1U<<31) | 5954, (1U<<31) | 5996, (1U<<31) | 5716, (1U<<31) | 5926, (1U<<31) | 5962, (1U<<31) | 5742, (1U<<31) | 5996, (1U<<31) | 6028, 
+  (1U<<31) | 5716, (1U<<31) | 5926, (1U<<31) | 5962, (1U<<31) | 5742, (1U<<31) | 5996, (1U<<31) | 6028, (1U<<31) | 5716, (1U<<31) | 5926, 
+  (1U<<31) | 5962, (1U<<31) | 5742, (1U<<31) | 5996, (1U<<31) | 6028, (1U<<31) | 5727, (1U<<31) | 5962, (1U<<31) | 5993, (1U<<31) | 5714, 
+  (1U<<31) | 5924, (1U<<31) | 5960, (1U<<31) | 5740, (1U<<31) | 6028, (1U<<31) | 6026, (1U<<31) | 5716, (1U<<31) | 5926, (1U<<31) | 5962, 
+  (1U<<31) | 5742, (1U<<31) | 5996, (1U<<31) | 6028, (1U<<31) | 5716, (1U<<31) | 5926, (1U<<31) | 5962, (1U<<31) | 5742, (1U<<31) | 5996, 
+  (1U<<31) | 6028, (1U<<31) | 1550, (1U<<31) | 1550, (1U<<31) | 1546, (1U<<31) | 5697, (1U<<31) | 1546, (1U<<31) | 5697, (1U<<31) | 1546, 
+  (1U<<31) | 5697, (1U<<31) | 1546, (1U<<31) | 5697, (1U<<31) | 1546, (1U<<31) | 5697, (1U<<31) | 1546, (1U<<31) | 5697, (1U<<31) | 1546, 
+  (1U<<31) | 5697, (1U<<31) | 1546, (1U<<31) | 5697, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, 
+  (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, 
+  (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, 
+  (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 1546, 
+  (1U<<31) | 5697, (1U<<31) | 1546, (1U<<31) | 5697, (1U<<31) | 1546, (1U<<31) | 5697, (1U<<31) | 1546, (1U<<31) | 5697, (1U<<31) | 1546, 
+  (1U<<31) | 5697, (1U<<31) | 1546, (1U<<31) | 5697, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, 
+  (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, 
+  (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, 
+  (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 1546, 
+  (1U<<31) | 5697, (1U<<31) | 1546, (1U<<31) | 5697, (1U<<31) | 1546, (1U<<31) | 5697, (1U<<31) | 1546, (1U<<31) | 5697, (1U<<31) | 1546, 
+  (1U<<31) | 5697, (1U<<31) | 1546, (1U<<31) | 5697, (1U<<31) | 1546, (1U<<31) | 5697, (1U<<31) | 1546, (1U<<31) | 5697, (1U<<31) | 5759, 
+  (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, 
+  (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, 
+  (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, 
+  (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 1546, (1U<<31) | 5697, (1U<<31) | 1546, (1U<<31) | 5697, (1U<<31) | 1546, 
+  (1U<<31) | 5697, (1U<<31) | 1546, (1U<<31) | 5697, (1U<<31) | 1546, (1U<<31) | 5697, (1U<<31) | 1546, (1U<<31) | 5697, (1U<<31) | 5759, 
+  (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, 
+  (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, 
+  (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, 
+  (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5727, (1U<<31) | 5962, (1U<<31) | 5993, (1U<<31) | 5714, (1U<<31) | 5924, 
+  (1U<<31) | 5960, (1U<<31) | 5740, (1U<<31) | 6028, (1U<<31) | 6026, (1U<<31) | 5716, (1U<<31) | 5926, (1U<<31) | 5962, (1U<<31) | 5742, 
+  (1U<<31) | 5996, (1U<<31) | 6028, (1U<<31) | 5727, (1U<<31) | 5962, (1U<<31) | 5993, (1U<<31) | 5714, (1U<<31) | 5924, (1U<<31) | 5960, 
+  (1U<<31) | 5740, (1U<<31) | 6028, (1U<<31) | 6026, (1U<<31) | 5727, (1U<<31) | 5962, (1U<<31) | 5993, (1U<<31) | 5714, (1U<<31) | 5924, 
+  (1U<<31) | 5960, (1U<<31) | 5740, (1U<<31) | 6028, (1U<<31) | 6026, (1U<<31) | 5716, (1U<<31) | 5926, (1U<<31) | 5962, (1U<<31) | 5742, 
+  (1U<<31) | 5996, (1U<<31) | 6028, (1U<<31) | 5716, (1U<<31) | 5926, (1U<<31) | 5962, (1U<<31) | 5742, (1U<<31) | 5996, (1U<<31) | 6028, 
+  (1U<<31) | 5716, (1U<<31) | 5926, (1U<<31) | 5962, (1U<<31) | 5742, (1U<<31) | 5996, (1U<<31) | 6028, (1U<<31) | 5716, (1U<<31) | 5926, 
+  (1U<<31) | 5962, (1U<<31) | 5742, (1U<<31) | 5996, (1U<<31) | 6028, (1U<<31) | 5954, (1U<<31) | 5996, (1U<<31) | 5954, (1U<<31) | 5996, 
+  (1U<<31) | 5954, (1U<<31) | 5996, (1U<<31) | 5699, (1U<<31) | 5954, (1U<<31) | 5699, (1U<<31) | 5954, (1U<<31) | 5699, (1U<<31) | 5954, 
+  (1U<<31) | 5692, (1U<<31) | 5091, (1U<<31) | 5924, (1U<<31) | 5742, (1U<<31) | 5996, (1U<<31) | 6028, (1U<<31) | 5692, (1U<<31) | 5091, 
+  (1U<<31) | 5924, (1U<<31) | 5742, (1U<<31) | 5996, (1U<<31) | 6028, (1U<<31) | 5692, (1U<<31) | 5091, (1U<<31) | 5924, (1U<<31) | 5742, 
+  (1U<<31) | 5996, (1U<<31) | 6028, (1U<<31) | 5692, (1U<<31) | 5091, (1U<<31) | 5924, (1U<<31) | 5742, (1U<<31) | 5996, (1U<<31) | 6028, 
+  (1U<<31) | 5716, (1U<<31) | 5926, (1U<<31) | 5962, (1U<<31) | 5742, (1U<<31) | 5996, (1U<<31) | 6028, (1U<<31) | 5716, (1U<<31) | 5926, 
+  (1U<<31) | 5962, (1U<<31) | 5742, (1U<<31) | 5996, (1U<<31) | 6028, (1U<<31) | 5716, (1U<<31) | 5926, (1U<<31) | 5962, (1U<<31) | 5742, 
+  (1U<<31) | 5996, (1U<<31) | 6028, (1U<<31) | 6530, (1U<<31) | 6535, 0x0, (1U<<31) | 1597, (1U<<31) | 5926, (1U<<31) | 5817, 
+  (1U<<31) | 5962, (1U<<31) | 5996, (1U<<31) | 5882, (1U<<31) | 6028, (1U<<31) | 5905, (1U<<31) | 5806, (1U<<31) | 5951, (1U<<31) | 5996, 
+  (1U<<31) | 5882, (1U<<31) | 6028, (1U<<31) | 5905, (1U<<31) | 5806, (1U<<31) | 5951, (1U<<31) | 5996, (1U<<31) | 5882, (1U<<31) | 6028, 
+  (1U<<31) | 5926, (1U<<31) | 5817, (1U<<31) | 5962, (1U<<31) | 5996, (1U<<31) | 5882, (1U<<31) | 6028, (1U<<31) | 5905, (1U<<31) | 5806, 
+  (1U<<31) | 5951, (1U<<31) | 5996, (1U<<31) | 5882, (1U<<31) | 6028, (1U<<31) | 5926, (1U<<31) | 5817, (1U<<31) | 5962, (1U<<31) | 5996, 
+  (1U<<31) | 5882, (1U<<31) | 6028, (1U<<31) | 5543, (1U<<31) | 5797, (1U<<31) | 5944, (1U<<31) | 5093, (1U<<31) | 5779, (1U<<31) | 5926, 
+  (1U<<31) | 5284, (1U<<31) | 5788, (1U<<31) | 5935, (1U<<31) | 4621, (1U<<31) | 5756, (1U<<31) | 5905, (1U<<31) | 5926, (1U<<31) | 5817, 
+  (1U<<31) | 5962, (1U<<31) | 5996, (1U<<31) | 5882, (1U<<31) | 6028, (1U<<31) | 5905, (1U<<31) | 5806, (1U<<31) | 5951, (1U<<31) | 5996, 
+  (1U<<31) | 5882, (1U<<31) | 6028, (1U<<31) | 5905, (1U<<31) | 5806, (1U<<31) | 5951, (1U<<31) | 5996, (1U<<31) | 5882, (1U<<31) | 6028, 
+  (1U<<31) | 5926, (1U<<31) | 5817, (1U<<31) | 5962, (1U<<31) | 5996, (1U<<31) | 5882, (1U<<31) | 6028, (1U<<31) | 5905, (1U<<31) | 5806, 
+  (1U<<31) | 5951, (1U<<31) | 5996, (1U<<31) | 5882, (1U<<31) | 6028, (1U<<31) | 5857, (1U<<31) | 5954, (1U<<31) | 5996, (1U<<31) | 5954, 
+  (1U<<31) | 5996, (1U<<31) | 5954, (1U<<31) | 5996, (1U<<31) | 5954, (1U<<31) | 5857, (1U<<31) | 5996, (1U<<31) | 5954, (1U<<31) | 5857, 
+  (1U<<31) | 5996, (1U<<31) | 5954, (1U<<31) | 5996, (1U<<31) | 5954, (1U<<31) | 5996, (1U<<31) | 5954, (1U<<31) | 5857, (1U<<31) | 5996, 
+  (1U<<31) | 5954, (1U<<31) | 5857, (1U<<31) | 5996, (1U<<31) | 5954, (1U<<31) | 5857, (1U<<31) | 5996, (1U<<31) | 5954, (1U<<31) | 5857, 
+  (1U<<31) | 5996, (1U<<31) | 5954, (1U<<31) | 5857, (1U<<31) | 5996, (1U<<31) | 5954, (1U<<31) | 5857, (1U<<31) | 5996, (1U<<31) | 5954, 
+  (1U<<31) | 5857, (1U<<31) | 5996, (1U<<31) | 5954, (1U<<31) | 5857, (1U<<31) | 5996, (1U<<31) | 5926, (1U<<31) | 5817, (1U<<31) | 5962, 
+  (1U<<31) | 5091, (1U<<31) | 5777, (1U<<31) | 5924, (1U<<31) | 5996, (1U<<31) | 5882, (1U<<31) | 6028, (1U<<31) | 5905, (1U<<31) | 5806, 
+  (1U<<31) | 5951, (1U<<31) | 4619, (1U<<31) | 5754, (1U<<31) | 5903, (1U<<31) | 5996, (1U<<31) | 5882, (1U<<31) | 6028, (1U<<31) | 5905, 
+  (1U<<31) | 5806, (1U<<31) | 5951, (1U<<31) | 4619, (1U<<31) | 5754, (1U<<31) | 5903, (1U<<31) | 5996, (1U<<31) | 5882, (1U<<31) | 6028, 
+  (1U<<31) | 5926, (1U<<31) | 5817, (1U<<31) | 5962, (1U<<31) | 5091, (1U<<31) | 5777, (1U<<31) | 5924, (1U<<31) | 5996, (1U<<31) | 5882, 
+  (1U<<31) | 6028, (1U<<31) | 5905, (1U<<31) | 5806, (1U<<31) | 5951, (1U<<31) | 4619, (1U<<31) | 5754, (1U<<31) | 5903, (1U<<31) | 5996, 
+  (1U<<31) | 5882, (1U<<31) | 6028, (1U<<31) | 5926, (1U<<31) | 5817, (1U<<31) | 5962, (1U<<31) | 5996, (1U<<31) | 5882, (1U<<31) | 6028, 
+  (1U<<31) | 5857, (1U<<31) | 5944, (1U<<31) | 5843, (1U<<31) | 5984, (1U<<31) | 5996, (1U<<31) | 5882, (1U<<31) | 6028, (1U<<31) | 5935, 
+  (1U<<31) | 5830, (1U<<31) | 5973, (1U<<31) | 5996, (1U<<31) | 5882, (1U<<31) | 6028, (1U<<31) | 5944, (1U<<31) | 5843, (1U<<31) | 5984, 
+  (1U<<31) | 5996, (1U<<31) | 5882, (1U<<31) | 6028, (1U<<31) | 5935, (1U<<31) | 5830, (1U<<31) | 5973, (1U<<31) | 5996, (1U<<31) | 5882, 
+  (1U<<31) | 6028, (1U<<31) | 5944, (1U<<31) | 5843, (1U<<31) | 5984, (1U<<31) | 5996, (1U<<31) | 5882, (1U<<31) | 6028, (1U<<31) | 5935, 
+  (1U<<31) | 5830, (1U<<31) | 5973, (1U<<31) | 5996, (1U<<31) | 5882, (1U<<31) | 6028, (1U<<31) | 5984, (1U<<31) | 5867, (1U<<31) | 6015, 
+  (1U<<31) | 5942, (1U<<31) | 5841, (1U<<31) | 5982, (1U<<31) | 6028, (1U<<31) | 5880, (1U<<31) | 6026, (1U<<31) | 5973, (1U<<31) | 5854, 
+  (1U<<31) | 6004, (1U<<31) | 5933, (1U<<31) | 5828, (1U<<31) | 5971, (1U<<31) | 6028, (1U<<31) | 5880, (1U<<31) | 6026, (1U<<31) | 5944, 
+  (1U<<31) | 5843, (1U<<31) | 5984, (1U<<31) | 5996, (1U<<31) | 5882, (1U<<31) | 6028, (1U<<31) | 5935, (1U<<31) | 5830, (1U<<31) | 5973, 
+  (1U<<31) | 5996, (1U<<31) | 5882, (1U<<31) | 6028, (1U<<31) | 5944, (1U<<31) | 5843, (1U<<31) | 5984, (1U<<31) | 5996, (1U<<31) | 5882, 
+  (1U<<31) | 6028, (1U<<31) | 5935, (1U<<31) | 5830, (1U<<31) | 5973, (1U<<31) | 5996, (1U<<31) | 5882, (1U<<31) | 6028, (1U<<31) | 5759, 
+  (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, 
+  (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, 
+  (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, 
+  (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 1587, (1U<<31) | 1587, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, 
+  (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, 
+  (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, 
+  (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, 
+  (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, 
+  (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, 
+  (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, 
+  (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, 
+  (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, 
+  (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, 
+  (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, (1U<<31) | 1602, (1U<<31) | 5759, 
+  (1U<<31) | 1602, (1U<<31) | 5984, (1U<<31) | 5867, (1U<<31) | 6015, (1U<<31) | 5942, (1U<<31) | 5841, (1U<<31) | 5982, (1U<<31) | 6028, 
+  (1U<<31) | 5880, (1U<<31) | 6026, (1U<<31) | 5973, (1U<<31) | 5854, (1U<<31) | 6004, (1U<<31) | 5933, (1U<<31) | 5828, (1U<<31) | 5971, 
+  (1U<<31) | 6028, (1U<<31) | 5880, (1U<<31) | 6026, (1U<<31) | 5944, (1U<<31) | 5843, (1U<<31) | 5984, (1U<<31) | 5996, (1U<<31) | 5882, 
+  (1U<<31) | 6028, (1U<<31) | 5935, (1U<<31) | 5830, (1U<<31) | 5973, (1U<<31) | 5996, (1U<<31) | 5882, (1U<<31) | 6028, (1U<<31) | 5984, 
+  (1U<<31) | 5867, (1U<<31) | 6015, (1U<<31) | 5942, (1U<<31) | 5841, (1U<<31) | 5982, (1U<<31) | 6028, (1U<<31) | 5880, (1U<<31) | 6026, 
+  (1U<<31) | 5973, (1U<<31) | 5854, (1U<<31) | 6004, (1U<<31) | 5933, (1U<<31) | 5828, (1U<<31) | 5971, (1U<<31) | 6028, (1U<<31) | 5880, 
+  (1U<<31) | 6026, (1U<<31) | 5984, (1U<<31) | 5867, (1U<<31) | 6015, (1U<<31) | 5942, (1U<<31) | 5841, (1U<<31) | 5982, (1U<<31) | 6028, 
+  (1U<<31) | 5880, (1U<<31) | 6026, (1U<<31) | 5973, (1U<<31) | 5854, (1U<<31) | 6004, (1U<<31) | 5933, (1U<<31) | 5828, (1U<<31) | 5971, 
+  (1U<<31) | 6028, (1U<<31) | 5880, (1U<<31) | 6026, (1U<<31) | 5954, (1U<<31) | 5996, (1U<<31) | 5954, (1U<<31) | 5996, (1U<<31) | 5954, 
+  (1U<<31) | 5996, (1U<<31) | 5954, (1U<<31) | 5996, (1U<<31) | 5954, (1U<<31) | 5996, (1U<<31) | 5954, (1U<<31) | 5996, (1U<<31) | 5954, 
+  (1U<<31) | 5996, (1U<<31) | 5954, (1U<<31) | 5996, (1U<<31) | 5954, (1U<<31) | 5996, (1U<<31) | 5954, (1U<<31) | 5996, (1U<<31) | 5944, 
+  (1U<<31) | 5843, (1U<<31) | 5984, (1U<<31) | 5996, (1U<<31) | 5882, (1U<<31) | 6028, (1U<<31) | 5935, (1U<<31) | 5830, (1U<<31) | 5973, 
+  (1U<<31) | 5996, (1U<<31) | 5882, (1U<<31) | 6028, (1U<<31) | 5954, (1U<<31) | 1621, (1U<<31) | 5954, (1U<<31) | 1621, (1U<<31) | 5073, 
+  (1U<<31) | 1592, (1U<<31) | 5765, (1U<<31) | 5912, (1U<<31) | 5073, (1U<<31) | 1592, (1U<<31) | 5765, (1U<<31) | 5912, (1U<<31) | 5073, 
+  (1U<<31) | 1592, (1U<<31) | 5765, (1U<<31) | 5912, (1U<<31) | 5073, (1U<<31) | 1592, (1U<<31) | 5765, (1U<<31) | 5912, (1U<<31) | 5073, 
+  (1U<<31) | 1592, (1U<<31) | 5765, (1U<<31) | 5912, (1U<<31) | 5073, (1U<<31) | 1592, (1U<<31) | 5765, (1U<<31) | 5912, (1U<<31) | 5073, 
+  (1U<<31) | 1592, (1U<<31) | 5765, (1U<<31) | 5912, (1U<<31) | 5073, (1U<<31) | 1592, (1U<<31) | 5765, (1U<<31) | 5912, (1U<<31) | 2067, 
+  (1U<<31) | 5894, (1U<<31) | 2067, (1U<<31) | 5894, (1U<<31) | 2067, (1U<<31) | 5894, (1U<<31) | 2067, (1U<<31) | 5894, (1U<<31) | 2067, 
+  (1U<<31) | 5894, (1U<<31) | 2067, (1U<<31) | 5894, (1U<<31) | 2067, (1U<<31) | 5894, (1U<<31) | 2067, (1U<<31) | 5894, (1U<<31) | 2067, 
+  (1U<<31) | 5894, (1U<<31) | 2067, (1U<<31) | 5894, (1U<<31) | 2067, (1U<<31) | 5894, (1U<<31) | 2067, (1U<<31) | 5894, (1U<<31) | 2067, 
+  (1U<<31) | 5894, (1U<<31) | 2067, (1U<<31) | 5894, (1U<<31) | 2067, (1U<<31) | 5894, (1U<<31) | 2067, (1U<<31) | 5894, (1U<<31) | 5926, 
+  (1U<<31) | 5817, (1U<<31) | 5962, (1U<<31) | 5996, (1U<<31) | 5882, (1U<<31) | 6028, (1U<<31) | 5905, (1U<<31) | 5806, (1U<<31) | 5951, 
+  (1U<<31) | 5996, (1U<<31) | 5882, (1U<<31) | 6028, (1U<<31) | 5905, (1U<<31) | 5806, (1U<<31) | 5951, (1U<<31) | 5996, (1U<<31) | 5882, 
+  (1U<<31) | 6028, (1U<<31) | 5926, (1U<<31) | 5817, (1U<<31) | 5962, (1U<<31) | 5996, (1U<<31) | 5882, (1U<<31) | 6028, (1U<<31) | 5905, 
+  (1U<<31) | 5806, (1U<<31) | 5951, (1U<<31) | 5996, (1U<<31) | 5882, (1U<<31) | 6028, (1U<<31) | 5905, (1U<<31) | 5806, (1U<<31) | 5951, 
+  (1U<<31) | 5996, (1U<<31) | 5882, (1U<<31) | 6028, (1U<<31) | 1610, (1U<<31) | 5817, (1U<<31) | 1619, (1U<<31) | 5882, (1U<<31) | 1554, 
+  (1U<<31) | 5703, (1U<<31) | 1563, (1U<<31) | 5742, (1U<<31) | 5926, (1U<<31) | 5817, (1U<<31) | 5962, (1U<<31) | 5996, (1U<<31) | 5882, 
+  (1U<<31) | 6028, (1U<<31) | 5905, (1U<<31) | 5951, (1U<<31) | 5996, (1U<<31) | 6028, (1U<<31) | 5905, (1U<<31) | 5806, (1U<<31) | 5951, 
+  (1U<<31) | 5996, (1U<<31) | 5882, (1U<<31) | 6028, (1U<<31) | 5905, (1U<<31) | 5806, (1U<<31) | 5951, (1U<<31) | 5996, (1U<<31) | 5882, 
+  (1U<<31) | 6028, (1U<<31) | 5926, (1U<<31) | 5817, (1U<<31) | 5962, (1U<<31) | 5996, (1U<<31) | 5882, (1U<<31) | 6028, (1U<<31) | 5905, 
+  (1U<<31) | 5806, (1U<<31) | 5951, (1U<<31) | 5996, (1U<<31) | 5882, (1U<<31) | 6028, (1U<<31) | 5905, (1U<<31) | 5806, (1U<<31) | 5951, 
+  (1U<<31) | 5926, (1U<<31) | 5817, (1U<<31) | 5962, (1U<<31) | 5996, (1U<<31) | 5882, (1U<<31) | 6028, (1U<<31) | 5954, (1U<<31) | 1621, 
+  (1U<<31) | 5954, (1U<<31) | 5996, (1U<<31) | 5954, (1U<<31) | 5996, (1U<<31) | 5954, (1U<<31) | 5996, (1U<<31) | 5954, (1U<<31) | 5996, 
+  (1U<<31) | 5954, (1U<<31) | 5996, (1U<<31) | 5954, (1U<<31) | 5996, (1U<<31) | 5954, (1U<<31) | 5996, (1U<<31) | 5954, (1U<<31) | 5996, 
+  (1U<<31) | 5954, (1U<<31) | 5996, (1U<<31) | 5954, (1U<<31) | 5996, (1U<<31) | 5954, (1U<<31) | 5996, (1U<<31) | 5954, (1U<<31) | 5996, 
+  (1U<<31) | 5954, (1U<<31) | 5996, (1U<<31) | 5954, (1U<<31) | 5996, (1U<<31) | 5954, (1U<<31) | 1621, (1U<<31) | 5954, (1U<<31) | 5996, 
+  (1U<<31) | 5954, (1U<<31) | 5996, (1U<<31) | 5954, (1U<<31) | 5996, (1U<<31) | 5954, (1U<<31) | 5996, (1U<<31) | 5954, (1U<<31) | 1621, 
+  (1U<<31) | 5072, (1U<<31) | 1591, (1U<<31) | 5072, (1U<<31) | 1591, (1U<<31) | 5072, (1U<<31) | 1591, (1U<<31) | 5072, (1U<<31) | 1591, 
+  (1U<<31) | 5072, (1U<<31) | 1591, (1U<<31) | 5072, (1U<<31) | 1591, (1U<<31) | 5072, (1U<<31) | 1591, (1U<<31) | 5072, (1U<<31) | 1591, 
+  (1U<<31) | 5072, (1U<<31) | 1591, (1U<<31) | 5072, (1U<<31) | 1591, (1U<<31) | 5072, (1U<<31) | 1591, (1U<<31) | 5072, (1U<<31) | 1591, 
+  (1U<<31) | 5699, (1U<<31) | 5954, (1U<<31) | 5073, (1U<<31) | 5765, (1U<<31) | 5912, (1U<<31) | 5089, (1U<<31) | 5922, (1U<<31) | 5091, 
+  (1U<<31) | 5777, (1U<<31) | 5924, (1U<<31) | 5996, (1U<<31) | 5882, (1U<<31) | 6028, (1U<<31) | 4619, (1U<<31) | 5754, (1U<<31) | 5903, 
+  (1U<<31) | 5996, (1U<<31) | 5882, (1U<<31) | 6028, (1U<<31) | 4619, (1U<<31) | 5754, (1U<<31) | 5903, (1U<<31) | 5996, (1U<<31) | 5882, 
+  (1U<<31) | 6028, (1U<<31) | 5091, (1U<<31) | 5777, (1U<<31) | 5924, (1U<<31) | 5996, (1U<<31) | 5882, (1U<<31) | 6028, (1U<<31) | 5091, 
+  (1U<<31) | 5777, (1U<<31) | 5924, (1U<<31) | 5996, (1U<<31) | 5882, (1U<<31) | 6028, (1U<<31) | 4619, (1U<<31) | 5754, (1U<<31) | 5903, 
+  (1U<<31) | 5996, (1U<<31) | 5882, (1U<<31) | 6028, (1U<<31) | 4619, (1U<<31) | 5754, (1U<<31) | 5903, (1U<<31) | 5996, (1U<<31) | 5882, 
+  (1U<<31) | 6028, (1U<<31) | 5091, (1U<<31) | 5777, (1U<<31) | 5924, (1U<<31) | 5996, (1U<<31) | 5882, (1U<<31) | 6028, (1U<<31) | 2066, 
+  (1U<<31) | 1581, (1U<<31) | 2066, (1U<<31) | 1581, (1U<<31) | 2066, (1U<<31) | 1581, (1U<<31) | 2066, (1U<<31) | 1581, (1U<<31) | 2066, 
+  (1U<<31) | 1581, (1U<<31) | 2066, (1U<<31) | 1581, (1U<<31) | 2066, (1U<<31) | 1581, (1U<<31) | 2066, (1U<<31) | 1581, (1U<<31) | 2066, 
+  (1U<<31) | 1581, (1U<<31) | 2066, (1U<<31) | 1581, (1U<<31) | 2066, (1U<<31) | 1581, (1U<<31) | 2066, (1U<<31) | 1581, (1U<<31) | 2066, 
+  (1U<<31) | 1581, (1U<<31) | 2066, (1U<<31) | 1581, (1U<<31) | 2066, (1U<<31) | 1581, (1U<<31) | 2066, (1U<<31) | 1581, (1U<<31) | 2066, 
+  (1U<<31) | 1581, (1U<<31) | 2066, (1U<<31) | 1581, (1U<<31) | 2066, (1U<<31) | 1581, (1U<<31) | 2066, (1U<<31) | 1581, (1U<<31) | 2066, 
+  (1U<<31) | 1581, (1U<<31) | 2066, (1U<<31) | 1581, (1U<<31) | 2066, (1U<<31) | 1581, (1U<<31) | 2066, (1U<<31) | 1581, (1U<<31) | 5926, 
+  (1U<<31) | 5817, (1U<<31) | 5962, (1U<<31) | 5996, (1U<<31) | 5882, (1U<<31) | 6028, (1U<<31) | 5905, (1U<<31) | 5806, (1U<<31) | 5951, 
+  (1U<<31) | 5996, (1U<<31) | 5882, (1U<<31) | 6028, (1U<<31) | 5905, (1U<<31) | 5806, (1U<<31) | 5951, (1U<<31) | 5996, (1U<<31) | 5882, 
+  (1U<<31) | 6028, (1U<<31) | 5926, (1U<<31) | 5817, (1U<<31) | 5962, (1U<<31) | 5996, (1U<<31) | 5882, (1U<<31) | 6028, (1U<<31) | 5905, 
+  (1U<<31) | 5806, (1U<<31) | 5951, (1U<<31) | 5996, (1U<<31) | 5882, (1U<<31) | 6028, (1U<<31) | 5954, (1U<<31) | 1621, (1U<<31) | 5954, 
+  (1U<<31) | 1621, (1U<<31) | 5954, (1U<<31) | 1621, (1U<<31) | 5926, (1U<<31) | 5817, (1U<<31) | 5962, (1U<<31) | 5996, (1U<<31) | 5882, 
+  (1U<<31) | 6028, (1U<<31) | 332, (1U<<31) | 391, 0x3f4, 0x3f4, 0x7f7f3f, 0x3f4, 0x7f7f7f3f, 
+  0x42e, 0x7f3f, 0x3b3b4a, 0x595959, (1U<<31) | 8212, (1U<<31) | 8212, (1U<<31) | 8234, (1U<<31) | 8234, 
+  (1U<<31) | 8234, (1U<<31) | 8234, 0x7f3f, (1U<<31) | 9241, (1U<<31) | 9236, (1U<<31) | 6516, 0x43b3e3b, 0x44a4e4a, 
+  0x4e4a, 0x4595e59, 0x5e59, 0x42c2e2c, 0x2e, 0x44e4, 0x544e4, 0x555e4, 
+  0x7f41f, 0x41f, 0xffbf3f, 0xffbf3f, 0x7f3f, 0x7f7f3f, 0x7f7f3f, 0x2c2c, 
+  0x2e0, 0x2e0, 0x3b3b3b, 0x7f7f7f3f, 0x7f7f7f3f, 0x0, (1U<<31) | 3692, 0x7f7f7f3f, 
+  0x43b3e0, 0x44a4e0, 0x4595e0, 0x42c2e0, 0x7f7f3f, 0x7f7f3f, 0x2c2c2c, 0x2e40, 
+  0x1f, 0x2e, 0x1f, 0x7f3f, 0xaf1f, 0xaf1f, 0xaf1f, 0xaf1f, 
+  0x4a59, 0x4a59, 0x4a59, 0x4a59, (1U<<31) | 9225, (1U<<31) | 9222, (1U<<31) | 9225, (1U<<31) | 9225, 
+  (1U<<31) | 9225, (1U<<31) | 9225, (1U<<31) | 9225, (1U<<31) | 9225, (1U<<31) | 9225, (1U<<31) | 9225, (1U<<31) | 9222, (1U<<31) | 9225, 
+  (1U<<31) | 9225, (1U<<31) | 9225, (1U<<31) | 9222, (1U<<31) | 9225, (1U<<31) | 9225, (1U<<31) | 9222, (1U<<31) | 9225, (1U<<31) | 9222, 
+  (1U<<31) | 9225, (1U<<31) | 9225, (1U<<31) | 9222, (1U<<31) | 9222, (1U<<31) | 3597, (1U<<31) | 6594, (1U<<31) | 1045, (1U<<31) | 1045, 
+  (1U<<31) | 6693, (1U<<31) | 6693, (1U<<31) | 1045, (1U<<31) | 1045, (1U<<31) | 6693, (1U<<31) | 6693, 0x595959, 0x5a5a5a, 
+  0x5b5b5b, 0x595959, 0x5a5a5a, 0x5b5b5b, 0x595959, 0x5a5a5a, 0x5b5b5b, 0x595959, 
+  0x5a5a5a, 0x5b5b5b, 0x5959, 0x25959, 0x8a8a8a, 0x7b7b7b, (1U<<31) | 8372, 0x7b7b7b7b, 
+  0x28a8a8a, 0x27b7b7b, 0x8a7a, 0x8a4a, 0x7b4b, 0x8a4a, 0x7b4b, 0x27b7b7b, 
+  0x8a8a8a, 0x7b7b7b, 0x8a8a8a, 0x7b7b7b, 0x2e2d, 0x592e89, 0x5a2e8a, 0x4a2e7a, 
+  0x4b2e7b, 0x89592e0, 0x8a5a2e0, 0x7a4a2e0, 0x7b4b2e0, 0x8a8a8a, 0x7b7b7b, 0x8a8a8a, 
+  0x7b7b7b, 0x8a4, 0x7b4, 0x5a5a4, 0x5a5a4, 0x5a5a4, 0x7b7b, 0x48a8a, 
+  0x47b7b, 0x7b7b, 0x598989, 0x5a8a8a, 0x4a7a7a, 0x4b7b7b, 0x89894, 0x8a8a4, 
+  0x7a7a4, 0x7b7b4, 0x89894, 0x8a8a4, 0x7a7a4, 0x7b7b4, 0x89894, 0x8a8a4, 
+  0x7a7a4, 0x7b7b4, 0x0, 0x0, (1U<<31) | 468, (1U<<31) | 514, (1U<<31) | 713, (1U<<31) | 758, 
+  (1U<<31) | 619, (1U<<31) | 676, (1U<<31) | 540, (1U<<31) | 574, (1U<<31) | 480, (1U<<31) | 492, (1U<<31) | 725, (1U<<31) | 770, 
+  (1U<<31) | 631, (1U<<31) | 643, (1U<<31) | 552, (1U<<31) | 586, 0x4a2e4a, 0x4b2e4b, 0x592e59, 0x5a2e5a, 
+  0x4a4a2e0, 0x4b4b2e0, 0x59592e0, 0x5a5a2e0, 0x22d2d3c, 0x4b4b3c, 0x3c3c2d, 0x4b4b3c, 
+  0x3c3c2d, 0x2d2d2d, 0x3c3c3c, 0x2d2d2d2d, 0x4b4b4b, 0x4b7b7b, 0x4b4b4b, 0x3c3c3c, 
+  0x3c3c3c, 0x4b4b4b, 0x3c3c3c, 0x3c3c3c, 0x2d2d3c, 0x3c3c4b, 0x2d4, 0x3c3c3c, 
+  0x3c3c3c, 0x3c3c3c, 0x2d2d5a, 0x2d2d2d, 0x2d2d2d, 0x4b4b4b, 0x3c3c3c, 0x4a4b4b, 
+  0x595a5a, 0x3b3c3c, 0x44b4b, 0x45a5a, 0x43c3c, 0x4a4a4a, 0x4b4b4b, 0x595959, 
+  0x5a5a5a, 0x4a4b4b, 0x3b3c3c, 0x44b4b, 0x43c3c, 0x4a4a4a, 0x4b4b4b, 0x4a4b4b, 
+  0x595a5a, 0x3b3c3c, 0x44b4b, 0x45a5a, 0x43c3c, 0x4a4a4a, 0x4b4b4b, 0x595959, 
+  0x5a5a5a, 0x48b8b8b, 0x47c7c7c, 0x259, 0x25a, 0x25b, 0x34a, 0x34b, 
+  0x34c, 0x4a4a, 0x4b4b, 0x4c4c, 0x5959, 0x5a5a, 0x5b5b, 0x458989, 
+  0x447a7a, 0x457a7a, 0x4894, 0x4895, 0x4894, 0x4895, 0x47a4, 0x47a5, 
+  0x47a4, 0x47a5, 0x447a7a, 0x458989, 0x457a7a, 0x42c2c3b, 0x42d2d3c, (1U<<31) | 2074, 
+  0x48b8b8b, 0x47c7c7c, 0x428b8b8b, 0x437c7c7c, 0x48919, 0x48a1a, 0x48b1b, 0x47a1a, 
+  0x47b1b, 0x47c1c, (1U<<31) | 1764, (1U<<31) | 2094, (1U<<31) | 1742, (1U<<31) | 2105, (1U<<31) | 1896, (1U<<31) | 1863, 
+  (1U<<31) | 1874, (1U<<31) | 1885, (1U<<31) | 1808, (1U<<31) | 1786, (1U<<31) | 1852, (1U<<31) | 1830, (1U<<31) | 1797, (1U<<31) | 1775, 
+  (1U<<31) | 1841, (1U<<31) | 1819, (1U<<31) | 1709, (1U<<31) | 1676, (1U<<31) | 1720, (1U<<31) | 1687, (1U<<31) | 1698, (1U<<31) | 1665, 
+  (1U<<31) | 1753, (1U<<31) | 1731, 0x442e4b20, 0x442e4c30, 0x442e5b20, 0x442e5b20, 0x1b1b1b, 0x1d1d1d, 
+  (1U<<31) | 285, 0x1c1c1c, 0x1b1b4, 0x1d1d4, (1U<<31) | 292, 0x1c1c4, 0x1b1b4, 0x1d1d4, 
+  (1U<<31) | 292, 0x1c1c4, (1U<<31) | 1964, (1U<<31) | 1919, (1U<<31) | 197, (1U<<31) | 237, (1U<<31) | 1391, (1U<<31) | 227, 
+  (1U<<31) | 247, (1U<<31) | 1498, 0x42489892, 0x4247a7a2, (1U<<31) | 105, 0x24a894a, 0x424b8b4b, 0x27a897a, 
+  0x427b8b7b, 0x2598959, 0x25a8a5a, 0x425b8b5b, 0x24a894a, 0x24a8a4a, 0x424b8b4b, 0x2598959, 
+  0x25a8a5a, 0x425b8b5b, 0x24a7a4a, 0x24b7b4b, 0x434c7c4c, 0x428b7b8b, 0x2597a59, 0x25a7a5a, 
+  0x425b7b5b, 0x24a7a4a, 0x24b7b4b, 0x434c7c4c, 0x2597a59, 0x25a7a5a, 0x425b7b5b, 0x27a597a, 
+  (1U<<31) | 1930, (1U<<31) | 1953, 0x24a894a, 0x424b8b4b, 0x2598959, 0x25a8a5a, 0x425b8b5b, 0x24a894a, 
+  0x24a8a4a, 0x424b8b4b, 0x2598959, 0x25a8a5a, 0x425b8b5b, 0x434c7c4c, 0x2597a59, 0x25a7a5a, 
+  0x425b7b5b, 0x24a7a4a, 0x24b7b4b, 0x434c7c4c, 0x2597a59, 0x25a7a5a, 0x425b7b5b, 0x27a597a, 
+  (1U<<31) | 1964, (1U<<31) | 1919, (1U<<31) | 105, (1U<<31) | 446, (1U<<31) | 457, (1U<<31) | 1653, (1U<<31) | 424, (1U<<31) | 435, 
+  (1U<<31) | 2082, (1U<<31) | 1641, (1U<<31) | 1629, 0x24892, 0x247a2, (1U<<31) | 1438, (1U<<31) | 1509, (1U<<31) | 1414, 
+  (1U<<31) | 1521, (1U<<31) | 1486, (1U<<31) | 1450, (1U<<31) | 1462, (1U<<31) | 1474, (1U<<31) | 1283, (1U<<31) | 1259, (1U<<31) | 1379, 
+  (1U<<31) | 1355, (1U<<31) | 1271, (1U<<31) | 1247, (1U<<31) | 1367, (1U<<31) | 1343, (1U<<31) | 1235, (1U<<31) | 1223, (1U<<31) | 1331, 
+  (1U<<31) | 1307, (1U<<31) | 1319, (1U<<31) | 1295, (1U<<31) | 1426, (1U<<31) | 1402, 0x2898989, 0x28a8a8a, 0x428b8b8b, 
+  0x27a7a7a, 0x27b7b7b, 0x437c7c7c, (1U<<31) | 1964, (1U<<31) | 1919, 0x28948989, 0x28a48a8a, (1U<<31) | 1977, 
+  0x27a47a7a, 0x27b47b7b, (1U<<31) | 2118, (1U<<31) | 1941, (1U<<31) | 1907, (1U<<31) | 1964, (1U<<31) | 1919, (1U<<31) | 1964, 
+  (1U<<31) | 1919, (1U<<31) | 1964, (1U<<31) | 1919, 0x22c4a2c, 0x22c4b2c, 0x32c4c2c, 0x24a2e0, 0x24b2e0, 
+  0x34c2e0, 0x23b4a3b, 0x23b4b3b, 0x33c4c3c, 0x24a2e0, 0x24b2e0, 0x34c2e0, 0x22c592c, 
+  0x22c5a2c, 0x22c5b2c, 0x2592e0, 0x25a2e0, 0x25b2e0, 0x24a594a, 0x2592e0, 0x25a2e0, 
+  0x25b2e0, 0x23b593b, 0x23b5a3b, 0x23b5b3b, 0x2592e0, 0x25a2e0, 0x25b2e0, 0x22c3b2c, 
+  0x23b2e0, 0x33c2e0, 0x43d2e0, 0x22c4a2c, 0x22c4b2c, 0x32c4c2c, 0x24a2e0, 0x24b2e0, 
+  0x34c2e0, 0x23b4a3b, 0x23b4b3b, 0x33c4c3c, 0x24a2e0, 0x24b2e0, 0x34c2e0, 0x22c592c, 
+  0x22c5a2c, 0x22c5b2c, 0x2592e0, 0x25a2e0, 0x25b2e0, 0x24a594a, 0x24a5a4a, 0x24b5b4b, 
+  0x2592e0, 0x25a2e0, 0x25b2e0, 0x23b593b, 0x23b5a3b, 0x23b5b3b, 0x2592e0, 0x25a2e0, 
+  0x25b2e0, 0x22c3b2c, 0x32c3c2c, 0x42d3d2d, 0x23b2e0, 0x33c2e0, 0x43d2e0, 0x22c4a2c, 
+  0x22c4b2c, 0x32c4c2c, 0x24a2e0, 0x24b2e0, 0x34c2e0, 0x23b4a3b, 0x23b4b3b, 0x33c4c3c, 
+  0x24a2e0, 0x24b2e0, 0x34c2e0, 0x22c592c, 0x22c5a2c, 0x22c5b2c, 0x2592e0, 0x25a2e0, 
+  0x25b2e0, 0x24a594a, 0x24a5a4a, 0x24b5b4b, 0x2592e0, 0x25a2e0, 0x25b2e0, 0x23b593b, 
+  0x23b5a3b, 0x23b5b3b, 0x2592e0, 0x25a2e0, 0x25b2e0, 0x22c3b2c, 0x32c3c2c, 0x42d3d2d, 
+  0x23b2e0, 0x33c2e0, 0x43d2e0, (1U<<31) | 702, (1U<<31) | 747, (1U<<31) | 1975, (1U<<31) | 608, (1U<<31) | 665, 
+  (1U<<31) | 2116, (1U<<31) | 3616, (1U<<31) | 3604, 0x28948989, 0x28a48a8a, (1U<<31) | 1977, 0x27a47a7a, 0x27b47b7b, 
+  (1U<<31) | 2118, (1U<<31) | 3616, (1U<<31) | 3604, 0x28948989, 0x28a48a8a, (1U<<31) | 1977, 0x27a47a7a, 0x27b47b7b, 
+  (1U<<31) | 2118, (1U<<31) | 3616, (1U<<31) | 3604, (1U<<31) | 737, (1U<<31) | 782, (1U<<31) | 1987, (1U<<31) | 655, (1U<<31) | 688, 
+  (1U<<31) | 2128, (1U<<31) | 1964, (1U<<31) | 1919, (1U<<31) | 5640, (1U<<31) | 4781, (1U<<31) | 5202, (1U<<31) | 5402, (1U<<31) | 5661, 
+  (1U<<31) | 4752, (1U<<31) | 5223, (1U<<31) | 5381, (1U<<31) | 5577, (1U<<31) | 5119, (1U<<31) | 5619, (1U<<31) | 5171, (1U<<31) | 5318, 
+  (1U<<31) | 4679, (1U<<31) | 5339, (1U<<31) | 4700, (1U<<31) | 5556, (1U<<31) | 5098, (1U<<31) | 5598, (1U<<31) | 5150, (1U<<31) | 5297, 
+  (1U<<31) | 4626, (1U<<31) | 5360, (1U<<31) | 4721, (1U<<31) | 1964, (1U<<31) | 1919, (1U<<31) | 1964, (1U<<31) | 1919, 0x437c3c7c, 
+  0x23b47a3b, 0x23b47b3b, 0x33c47c3c, (1U<<31) | 446, (1U<<31) | 457, (1U<<31) | 1653, (1U<<31) | 424, (1U<<31) | 435, 
+  (1U<<31) | 2082, (1U<<31) | 1641, (1U<<31) | 1629, 0x48b8b8b, 0x47c7c7c, 0x48b8b8b, 0x47c7c7c, 0x48b8b8b, 
+  0x47c7c7c, 0x4c4c3d, (1U<<31) | 1145, 0x4c4c3d, (1U<<31) | 1145, (1U<<31) | 1080, 0x3d3d3d, 0x5a8a8a, 
+  0x5b8b8b, 0x5a5a5a, 0x5b5b5b, 0x3b3b3b, 0x3c3c3c, 0x3d3d3d, 0x2c2c2c, 0x2d2d2d, 
+  (1U<<31) | 1080, 0x4c7c7c, 0x4c4c4c, (1U<<31) | 1087, 0x3d3d4c, 0x3d3d3d, 0x3d3d3d, 0x3d3d3d, 
+  0x2c2c2c, 0x2d2d2d, (1U<<31) | 1080, (1U<<31) | 1094, (1U<<31) | 1080, 0x4a4c4c, 0x595b5b, 0x3b3d3d, 
+  0x44c4c, 0x45b5b, 0x43d3d, 0x4c4c4c, 0x5b5b5b, 0x3b3b3b, 0x3c3c3c, 0x3d3d3d, 
+  0x4a4c4c, 0x595959, 0x595a5a, 0x595b5b, 0x3b3d3d, 0x44c4c, 0x45959, 0x45a5a, 
+  0x45b5b, 0x43d3d, 0x4c4c4c, 0x595959, 0x5a5a5a, 0x5b5b5b, 0x3b3b3b, 0x3c3c3c, 
+  0x3d3d3d, 0x4a4c4c, 0x595b5b, 0x3b3d3d, 0x44c4c, 0x45b5b, 0x43d3d, 0x4c4c4c, 
+  0x5b5b5b, 0x3b3b3b, 0x3c3c3c, 0x3d3d3d, (1U<<31) | 4669, (1U<<31) | 4742, (1U<<31) | 4802, (1U<<31) | 5140, 
+  (1U<<31) | 5192, (1U<<31) | 5244, 0x2898989, 0x28a8a8a, 0x28b8b8b, 0x27a7a7a, 0x27b7b7b, 0x37c7c7c, 
+  (1U<<31) | 737, (1U<<31) | 655, 0x428b8b8b, 0x437c7c7c, (1U<<31) | 1964, (1U<<31) | 1919, 0x2898989, 0x28a8a8a, 
+  0x28b8b8b, 0x27a7a7a, 0x27b7b7b, 0x37c7c7c, (1U<<31) | 737, (1U<<31) | 655, 0x428b8b8b, 0x437c7c7c, 
+  (1U<<31) | 1964, (1U<<31) | 1919, (1U<<31) | 5651, (1U<<31) | 4792, (1U<<31) | 5213, (1U<<31) | 5413, (1U<<31) | 5672, (1U<<31) | 4763, 
+  (1U<<31) | 5234, (1U<<31) | 5392, (1U<<31) | 5588, (1U<<31) | 5130, (1U<<31) | 5630, (1U<<31) | 5182, (1U<<31) | 5329, (1U<<31) | 4690, 
+  (1U<<31) | 5350, (1U<<31) | 4711, 0x442e4b20, 0x442e4c30, 0x442e5b20, 0x442e5b20, (1U<<31) | 5567, (1U<<31) | 5109, 
+  (1U<<31) | 5609, (1U<<31) | 5161, (1U<<31) | 5308, (1U<<31) | 4637, (1U<<31) | 5371, (1U<<31) | 4732, 0x49f2f, 0x48b8b, 
+  0x47c7c, 0x48b8b8b, 0x47c7c7c, 0x49f2f, 0x4489894, 0x447a7a4, 0x4894, 0x4895, 
+  0x4894, 0x4895, 0x47a4, 0x47a5, 0x47a4, 0x47a5, 0x47777, 0x48888, 
+  (1U<<31) | 5682, (1U<<31) | 5423, (1U<<31) | 5682, (1U<<31) | 5423, (1U<<31) | 6045, (1U<<31) | 6123, (1U<<31) | 6158, (1U<<31) | 6643, 
+  (1U<<31) | 6801, (1U<<31) | 6811, 0x4a4a4a4a, 0x4b4b4b4b, 0x4c4c4c4c, 0x4a4a4a4a, 0x4b4b4b4b, 0x4c4c4c4c, 
+  0x4a4a4a4a, 0x4b4b4b4b, 0x4c4c4c4c, 0x4a4a4a4a, 0x4b4b4b4b, 0x4c4c4c4c, 0x4a4a4a4a, 0x4b4b4b4b, 
+  0x4c4c4c4c, 0x3b3b3b3b, 0x3c3c3c3c, 0x3d3d3d3d, (1U<<31) | 8293, (1U<<31) | 8363, (1U<<31) | 8381, 0x7a4a7a7a, 
+  0x7b4b7b7b, 0x7c4c7c7c, 0x59595959, 0x5a5a5a5a, 0x5b5b5b5b, 0x2c2c2c2c, 0x2d2d2d2d, (1U<<31) | 1078, 
+  0x5b8b8b, 0x4c7c7c, 0x59595959, 0x5a5a5a5a, 0x5b5b5b5b, 0x59595959, 0x5a5a5a5a, 0x5b5b5b5b, 
+  0x2c2c1c, 0x2d2d1d, (1U<<31) | 1071, 0x7a7a3b, 0x7b7b3c, 0x7c7c3d, 0x7b3b, 0x7c3c, 
+  0x4a4a7a7a, 0x4b4b7b7b, 0x4c4c7c7c, 0x1a3b7a3b, 0x444, 0x555, 0x444, 0x555, 
+  0x444, 0x555, 0x444, 0x555, 0x2e0, 0x2e0, 0x2e0, 0x0, 
+  0x2e0, 0x2e0, 0x42e0, 0x52e0, (1U<<31) | 6625, (1U<<31) | 6662, 0x2e2e2, 0x2e2e2, 
+  0x4, 0x5, 0x40, 0x50, (1U<<31) | 8311, (1U<<31) | 8372, 0x7a7a7a7a, 0x7b7b7b7b, 
   0x2e0, 0x2e0, 0x2e0, 0x2e0, 0x40, 0x50, 0x20, 0x2e40, 
-  0x2e0, 0x4442, 0x4452, 0x4440, 0x4450, 0x0, 0x0, (1U<<31) | 753, 
-  (1U<<31) | 6488, (1U<<31) | 6493, (1U<<31) | 6493, (1U<<31) | 6493, (1U<<31) | 6493, (1U<<31) | 6493, (1U<<31) | 6493, (1U<<31) | 6493, 
-  (1U<<31) | 6493, (1U<<31) | 6493, (1U<<31) | 6493, (1U<<31) | 6493, (1U<<31) | 795, (1U<<31) | 6493, (1U<<31) | 6493, (1U<<31) | 6493, 
-  (1U<<31) | 6493, (1U<<31) | 6493, (1U<<31) | 6493, (1U<<31) | 6493, (1U<<31) | 6493, (1U<<31) | 6493, (1U<<31) | 6493, (1U<<31) | 5201, 
-  (1U<<31) | 4231, (1U<<31) | 6493, (1U<<31) | 6493, (1U<<31) | 6493, (1U<<31) | 6493, (1U<<31) | 6493, (1U<<31) | 6468, (1U<<31) | 6493, 
-  (1U<<31) | 6493, (1U<<31) | 6493, (1U<<31) | 6493, (1U<<31) | 6493, (1U<<31) | 6493, (1U<<31) | 6493, (1U<<31) | 6493, (1U<<31) | 6493, 
-  (1U<<31) | 5214, (1U<<31) | 5214, (1U<<31) | 5214, (1U<<31) | 6493, (1U<<31) | 6493, (1U<<31) | 5214, (1U<<31) | 5214, (1U<<31) | 6493, 
-  (1U<<31) | 6493, (1U<<31) | 6493, (1U<<31) | 5214, (1U<<31) | 5214, (1U<<31) | 5214, (1U<<31) | 6493, (1U<<31) | 6493, (1U<<31) | 6493, 
-  (1U<<31) | 6493, (1U<<31) | 6493, (1U<<31) | 6493, (1U<<31) | 6493, (1U<<31) | 6493, (1U<<31) | 6493, (1U<<31) | 6493, (1U<<31) | 6493, 
-  (1U<<31) | 6493, (1U<<31) | 6493, (1U<<31) | 6493, (1U<<31) | 6493, 0x442e0, 0x2e2e0, 0x4440, 0x2595959, 
-  0x25a5a5a, 0x25b5b5b, 0x40, 0x50, 0x4, 0x5, 0x4, 0x5, 
-  0x4, 0x4, 0x45, (1U<<31) | 1695, (1U<<31) | 4242, (1U<<31) | 4469, (1U<<31) | 1695, (1U<<31) | 4242, 
-  (1U<<31) | 4469, 0x44, 0x55, 0x5, (1U<<31) | 4469, 0x2e0, 0x0, 0x2e0, 
-  0x2e0, 0x2e2e, 0x0, 0x4a4a4a, 0x4a4a4a, 0x4a4a4a, 0x24a4a4a, 0x4a4a4a, 
-  0x4a4a4a, 0x4a4a4a4a, 0x2e, 0x27a7a7a, 0x27a7a7a, 0x7a7a4, 0x7a7a4, 0x7a7a4, 
-  0x7a7a4, 0x7a7a4, 0x7a7a4, (1U<<31) | 6233, (1U<<31) | 6477, (1U<<31) | 6471, (1U<<31) | 6066, 0x7a4, 
-  0x7a5, (1U<<31) | 6233, (1U<<31) | 6066, 0x7a4, 0x7a5, 0x2e0, 0x7a7a7a, 0x7a7a7a, 
-  0x7a7a7a, 0x7a7a7a, 0x7a4, (1U<<31) | 796, 0x7a7a, 0x7a7a, 0x7a7a, 0x7a7a, 
-  0x0, 0x2e0, 0x7a7a4, 0x7a7a4, 0x7a7a4, 0x7a7a4, 0x7a7a4, 0x7a7a4, 
-  0x2e0, 0x2898989, 0x2898989, 0x89894, 0x89894, 0x89894, 0x89894, 0x89894, 
-  0x89894, 0x894a, 0x897a, 0x7a4a, 0x894, 0x895, 0x897a7a, 0x894a, 
-  0x7a4a, 0x894, 0x895, 0x0, 0x2e2c2c0, 0x898989, 0x898989, 0x0, 
-  0x898989, 0x898989, 0x894, 0x4a4a3b, 0x3b3b2c, 0x3b3b2c, 0x0, 0x2c2c2c, 
-  0x3b3b3b, 0x3b3b4a, 0x2c4, 0x3b3b3b, 0x3b3b3b, 0x2c2c59, 0x4a4a4a, 0x595959, 
-  0x3b3b3b, 0x44a4a, 0x45959, 0x43b3b, 0x4a4a4a, 0x3b3b3b, 0x44a4a, 0x43b3b, 
-  0x4a4a4a, 0x595959, 0x3b3b3b, 0x44a4a, 0x45959, 0x43b3b, 0x89894, 0x89894, 
-  0x89894, 0x89894, 0x89894, 0x89894, 0x898989, 0x7a7a7a, 0x898989, 0x7a7a7a, 
-  0x898989, 0x7a7a7a, 0x2e2c, 0x442e0, 0x440, (1U<<31) | 6224, 0x7a7a7a7a, 0x2898989, 
-  0x27a7a7a, 0x27a7a7a, 0x22c2c3b, 0x4a4a3b, 0x2c2c2c2c, 0x3b3b, 0x59594, 0x59594, 
-  0x59594, 0x48989, 0x47a7a, 0x4898989, 0x47a7a7a, 0x344, 0x444, 0x244, 
-  0x555, 0x242c42c4, 0x242c42c4, 0x242c42c4, 0x242c42c4, 0x242c42c4, 0x242c42c4, (1U<<31) | 261, 
-  0x22c2c4, 0x22c2c4, 0x22c2c4, 0x22c2c4, 0x22c2c4, 0x22c2c4, 0x22c2c2c, 0x2c5959, 
-  0x225959, 0x595959, 0x22595959, (1U<<31) | 6490, (1U<<31) | 6490, (1U<<31) | 6490, (1U<<31) | 6493, 0x4a4a4a, 
-  (1U<<31) | 6493, 0x3b3b3b, (1U<<31) | 6493, 0x3b3b3b, (1U<<31) | 6493, 0x4a4a4a, (1U<<31) | 6493, 0x3b3b3b, 
-  (1U<<31) | 6493, 0x3b3b3b, (1U<<31) | 6493, 0x2c2c3b, (1U<<31) | 6493, 0x3b3b3b, (1U<<31) | 6493, 0x2c2c2c, 
-  (1U<<31) | 6493, 0x2c2c2c, (1U<<31) | 6493, 0x4a4a4a, (1U<<31) | 6493, 0x3b3b3b, (1U<<31) | 3081, (1U<<31) | 5236, 
-  0x444, 0x555, 0x4442, 0x2e0, 0x4442, 0x3b7a, 0x3b7b, 0x47a3b, 
-  0x47b3b, 0x22c2c2c, 0x22d2d2d, (1U<<31) | 253, 0x22c2c2c, 0x22d2d2d, (1U<<31) | 253, 0x2c2c2c, 
-  0x2d2d2d, (1U<<31) | 774, 0x0, 0x0, 0x40, 0x50, 0x40, 0x50, 
-  0x40, 0x2e40, 0x2e50, 0x2e40, 0x2e50, 0x20, 0x4, 0x0, 
-  0x45, 0x8989, 0x8a8a, 0x7a7a, 0x7b7b, 0x8989, 0x7a7a, (1U<<31) | 411, 
-  (1U<<31) | 445, (1U<<31) | 351, (1U<<31) | 373, 0x2c4a, 0x2c59, 0x2c3b, 0x4a59, 0x2c4a, 
-  0x2c59, 0x2c3b, 0x4a59, 0x3b4a, 0x3b59, 0x3b4a, 0x3b59, 0x2c3b, 
-  0x4a59, 0x3b4a, 0x4a4a4a4a, 0x594a4a59, 0x594a4a59, 0x4a4a4a4a, 0x594a4a59, 0x594a4a59, 
-  0x4a3b3b4a, 0x3b3b3b3b, 0x4a3b3b4a, 0x3b3b3b3b, 0x4a3b3b4a, 0x4a3b3b4a, 0x2c2c2c2c, 0x2c2c2c, 
-  0x4a4a4a, 0x595959, 0x3b3b3b, 0x2c2c2c, 0x4a4a4a, 0x595959, 0x3b3b3b, 0x442e0, 
-  0x442e0, 0x442e0, 0x442e0, 0x442e0, 0x442e0, 0x442e0, 0x442e0, 0x442e0, 
-  0x442e0, 0x442e0, 0x442e0, 0x4440, 0x4, 0x44, 0x2e2e, 0x44f0, 
-  0x0, 0x4f0, 0x40, 0x4444, (1U<<31) | 3273, 0x4f0, 0x4f0, 0x4f4, 
-  0x4f0, 0x4, 0x4, 0x4, 0x44, 0x44f, 0xcf4f, 0x4f4, 
-  0x4f4, 0x4f4, 0x2e4f0, 0x2e4f0, 0x2e4f0, 0x2e4f0, 0x2e4f0, 0x44f4, 
-  0x4f4, 0x4f0, 0x4f0, 0x44f0, 0x44f0, 0x44f4, 0x44f0, 0x4f4, 
-  0x44f0, 0xcf4f0, 0x44f0, 0x2e4f0, 0x440, 0x44f0, 0x44f0, 0xcf4f0, 
-  0x40, 0x44f0, 0x2e4f0, 0x444, 0x0, 0x4f0, 0x4f4, 0x4f4, 
-  0x2e, 0x444, 0
+  0x2e0, 0x2e0, 0x45959590, 0x4442, 0x4452, 0x4440, 0x4450, 0x0, 
+  0x0, (1U<<31) | 1054, (1U<<31) | 9220, (1U<<31) | 9225, (1U<<31) | 9225, (1U<<31) | 9225, (1U<<31) | 9225, (1U<<31) | 9225, 
+  (1U<<31) | 9225, (1U<<31) | 9225, (1U<<31) | 9225, (1U<<31) | 9225, (1U<<31) | 9225, (1U<<31) | 9225, (1U<<31) | 1101, (1U<<31) | 9225, 
+  (1U<<31) | 9225, (1U<<31) | 9225, (1U<<31) | 9225, (1U<<31) | 9225, (1U<<31) | 9225, (1U<<31) | 9225, (1U<<31) | 9225, (1U<<31) | 9225, 
+  (1U<<31) | 9225, (1U<<31) | 6499, (1U<<31) | 4986, (1U<<31) | 9225, (1U<<31) | 9225, (1U<<31) | 9225, (1U<<31) | 9225, (1U<<31) | 9225, 
+  (1U<<31) | 9015, (1U<<31) | 9225, (1U<<31) | 9225, (1U<<31) | 9225, (1U<<31) | 9225, (1U<<31) | 9225, (1U<<31) | 9225, (1U<<31) | 9225, 
+  (1U<<31) | 9225, (1U<<31) | 9225, (1U<<31) | 6512, (1U<<31) | 6512, (1U<<31) | 6512, (1U<<31) | 9225, (1U<<31) | 9225, (1U<<31) | 6512, 
+  (1U<<31) | 6512, (1U<<31) | 9225, (1U<<31) | 9225, (1U<<31) | 9225, (1U<<31) | 6512, (1U<<31) | 6512, (1U<<31) | 6512, (1U<<31) | 9225, 
+  (1U<<31) | 9225, (1U<<31) | 9225, (1U<<31) | 9225, (1U<<31) | 9225, (1U<<31) | 9225, (1U<<31) | 9225, (1U<<31) | 9225, (1U<<31) | 9225, 
+  (1U<<31) | 9225, (1U<<31) | 9225, (1U<<31) | 9225, (1U<<31) | 9225, (1U<<31) | 9225, (1U<<31) | 9225, 0x442e0, 0x2e2e0, 
+  0x4440, 0x2595959, 0x25a5a5a, 0x25b5b5b, 0x40, 0x50, 0x4, 0x5, 
+  0x4, 0x5, 0x4, 0x4, 0x45, (1U<<31) | 2189, (1U<<31) | 5007, (1U<<31) | 5254, 
+  (1U<<31) | 2189, (1U<<31) | 5007, (1U<<31) | 5254, 0x44, 0x55, 0x5, (1U<<31) | 5254, 0x2e0, 
+  0x0, 0x2e0, 0x2e0, 0x2e2e, 0x50, 0x0, 0x0, 0x4a4a4a, 
+  0x4a4a4a, 0x4a4a4a, 0x24a4a4a, 0x4a4a4a, 0x4a4a4a, 0x4a4a4a4a, 0x2e, 0x27a7a7a, 
+  0x27a7a7a, 0x7a7a4, 0x7a7a4, 0x7a7a4, 0x7a7a4, 0x7a7a4, 0x7a7a4, (1U<<31) | 8320, 
+  (1U<<31) | 9024, (1U<<31) | 9018, (1U<<31) | 7730, 0x7a4, 0x7a5, (1U<<31) | 8320, (1U<<31) | 7730, 0x7a4, 
+  0x7a5, 0x2e0, 0x7a7a7a, 0x7a7a7a, 0x7a7a7a, 0x7a7a7a, 0x7a4, (1U<<31) | 1102, 
+  0x7a7a, 0x7a7a, 0x7a7a, 0x7a7a, 0x0, 0x2e0, 0x7a7a4, 0x7a7a4, 
+  0x7a7a4, 0x7a7a4, 0x7a7a4, 0x7a7a4, 0x2e0, 0x2898989, 0x2898989, 0x89894, 
+  0x89894, 0x89894, 0x89894, 0x89894, 0x89894, 0x894a, 0x897a, 0x7a4a, 
+  0x894, 0x895, 0x897a7a, 0x894a, 0x7a4a, 0x894, 0x895, 0x0, 
+  0x2e2c2c0, 0x898989, 0x898989, 0x0, 0x898989, 0x898989, 0x894, 0x4a4a3b, 
+  0x3b3b2c, 0x3b3b2c, 0x0, 0x2c2c2c, 0x3b3b3b, 0x3b3b4a, 0x2c4, 0x3b3b3b, 
+  0x3b3b3b, 0x2c2c59, 0x4a4a4a, 0x595959, 0x3b3b3b, 0x44a4a, 0x45959, 0x43b3b, 
+  0x4a4a4a, 0x3b3b3b, 0x44a4a, 0x43b3b, 0x4a4a4a, 0x595959, 0x3b3b3b, 0x44a4a, 
+  0x45959, 0x43b3b, 0x89894, 0x89894, 0x89894, 0x89894, 0x89894, 0x89894, 
+  0x898989, 0x7a7a7a, 0x898989, 0x7a7a7a, 0x898989, 0x7a7a7a, 0x2e2c, 0x442e0, 
+  0x440, (1U<<31) | 8311, 0x7a7a7a7a, 0x2898989, 0x27a7a7a, 0x27a7a7a, 0x22c2c3b, 0x4a4a3b, 
+  0x2c2c2c2c, 0x3b3b, 0x59594, 0x59594, 0x59594, 0x48989, 0x47a7a, 0x4898989, 
+  0x47a7a7a, 0x344, 0x444, 0x244, 0x555, 0x242c42c4, 0x242c42c4, 0x242c42c4, 
+  0x242c42c4, 0x242c42c4, 0x242c42c4, (1U<<31) | 414, 0x22c2c4, 0x22c2c4, 0x22c2c4, 0x22c2c4, 
+  0x22c2c4, 0x22c2c4, 0x22c2c2c, 0x2c5959, 0x225959, 0x595959, 0x22595959, (1U<<31) | 9222, 
+  (1U<<31) | 9222, (1U<<31) | 9222, (1U<<31) | 9225, 0x4a4a4a, (1U<<31) | 9225, 0x3b3b3b, (1U<<31) | 9225, 0x3b3b3b, 
+  (1U<<31) | 9225, 0x4a4a4a, (1U<<31) | 9225, 0x3b3b3b, (1U<<31) | 9225, 0x3b3b3b, (1U<<31) | 9225, 0x2c2c3b, 
+  (1U<<31) | 9225, 0x3b3b3b, (1U<<31) | 9225, 0x2c2c2c, (1U<<31) | 9225, 0x2c2c2c, (1U<<31) | 9225, 0x4a4a4a, 
+  (1U<<31) | 9225, 0x3b3b3b, 0x2e0, 0x0, (1U<<31) | 3597, (1U<<31) | 6594, 0x444, 0x555, 
+  0x2220, 0x2220, (1U<<31) | 9666, 0x2220, 0x2220, 0x2220, 0x2, 0x52e20, 
+  (1U<<31) | 6540, 0x52e20, 0x0, 0x52e20, (1U<<31) | 9658, 0x20, (1U<<31) | 1116, 0x4442, 
+  0x2e0, 0x4442, 0x47a3b, 0x47b3b, 0x22c2c2c, 0x22d2d2d, (1U<<31) | 406, 0x22c2c2c, 
+  0x22d2d2d, (1U<<31) | 406, 0x2c2c2c, 0x2d2d2d, (1U<<31) | 1080, 0x0, 0x0, 0x40, 
+  0x50, 0x40, 0x50, 0x40, 0x2e40, 0x2e50, 0x2e40, 0x2e50, 
+  0x20, 0x4, 0x0, 0x45, 0x8989, 0x8a8a, 0x7a7a, 0x7b7b, 
+  0x8989, 0x7a7a, (1U<<31) | 564, (1U<<31) | 598, (1U<<31) | 504, (1U<<31) | 526, 0x2c4a, 0x2c59, 
+  0x2c3b, 0x4a59, 0x2c4a, 0x2c59, 0x2c3b, 0x4a59, 0x3b4a, 0x3b59, 
+  0x3b4a, 0x3b59, 0x2c3b, 0x4a59, 0x3b4a, 0x4a4a4a4a, 0x594a4a59, 0x594a4a59, 
+  0x4a4a4a4a, 0x594a4a59, 0x594a4a59, 0x4a3b3b4a, 0x3b3b3b3b, 0x4a3b3b4a, 0x3b3b3b3b, 0x4a3b3b4a, 
+  0x4a3b3b4a, 0x2c2c2c2c, 0x2c2c2c, 0x4a4a4a, 0x595959, 0x3b3b3b, 0x2c2c2c, 0x4a4a4a, 
+  0x595959, 0x3b3b3b, 0x0, 0x442e0, 0x442e0, 0x442e0, 0x442e0, 0x442e0, 
+  0x442e0, 0x442e0, 0x442e0, 0x442e0, 0x442e0, 0x442e0, 0x442e0, 0x4440, 
+  0x0, 0x4, 0x44, 0x2e2e, 0x44f0, 0x0, 0x4f0, 0x40, 
+  0x4444, (1U<<31) | 3919, 0x4f0, 0x4f0, 0x4f4, 0x4f0, 0x4, 0x4, 
+  0x4, 0x44, 0x44f, 0xcf4f, 0x4f4, 0x4f4, 0x4f4, 0x2e4f0, 
+  0x2e4f0, 0x2e4f0, 0x2e4f0, 0x2e4f0, 0x44f4, 0x4f4, 0x4f0, 0x4f0, 
+  0x44f0, 0x44f0, 0x44f4, 0x44f0, 0x4f4, 0x44f0, 0xcf4f0, 0x44f0, 
+  0x2e4f0, 0x440, 0x44f0, 0x44f0, 0xcf4f0, 0x40, 0x44f0, 0x2e4f0, 
+  0x444, 0x0, 0x4f0, 0x4f4, 0x4f4, 0x2e, 0x444, 0
 };
 
 static const unsigned char IIT_LongEncodingTable[] = {
   /* 0 */ 4, 27, 2, 4, 4, 4, 4, 1, 4, 1, 1, 0,
   /* 12 */ 0, 15, 0, 10, 4, 4, 4, 4, 4, 4, 4, 1, 1, 0,
   /* 26 */ 0, 15, 0, 10, 4, 4, 4, 1, 1, 0,
-  /* 36 */ 0, 4, 4, 15, 3, 15, 7, 1, 1, 0,
-  /* 46 */ 0, 4, 4, 15, 0, 15, 7, 15, 7, 15, 7, 1, 1, 0,
-  /* 60 */ 21, 1, 15, 1, 1, 0,
-  /* 66 */ 0, 15, 3, 34, 1, 0, 4, 31, 3, 1, 0,
-  /* 77 */ 0, 15, 3, 15, 12, 4, 31, 3, 1, 0,
-  /* 87 */ 15, 3, 15, 7, 15, 7, 31, 3, 1, 0,
-  /* 97 */ 0, 15, 3, 33, 7, 31, 3, 1, 0,
-  /* 106 */ 15, 1, 15, 7, 15, 7, 4, 4, 4, 1, 0,
-  /* 117 */ 15, 1, 15, 7, 10, 4, 4, 4, 1, 0,
-  /* 127 */ 7, 27, 3, 7, 7, 4, 4, 1, 0,
-  /* 136 */ 15, 1, 15, 12, 15, 7, 4, 4, 1, 0,
-  /* 146 */ 21, 15, 2, 1, 15, 7, 15, 7, 1, 0,
-  /* 156 */ 15, 2, 15, 7, 15, 7, 15, 7, 1, 0,
-  /* 166 */ 0, 19, 15, 1, 0,
-  /* 171 */ 16, 1, 16, 1, 16, 1, 0,
-  /* 178 */ 4, 16, 1, 16, 1, 0,
-  /* 184 */ 0, 15, 4, 15, 12, 15, 17, 1, 0,
-  /* 193 */ 2, 18, 1, 0,
-  /* 197 */ 36, 1, 36, 1, 36, 1, 0,
-  /* 204 */ 21, 12, 4, 36, 1, 12, 4, 12, 4, 36, 1, 0,
-  /* 216 */ 12, 4, 12, 4, 12, 4, 36, 1, 0,
-  /* 225 */ 37, 1, 37, 1, 37, 1, 0,
-  /* 232 */ 21, 13, 4, 37, 1, 13, 4, 13, 4, 37, 1, 0,
-  /* 244 */ 13, 4, 13, 4, 13, 4, 37, 1, 0,
-  /* 253 */ 16, 2, 16, 2, 16, 2, 2, 0,
-  /* 261 */ 12, 2, 12, 2, 4, 12, 2, 4, 2, 0,
-  /* 271 */ 10, 7, 10, 7, 10, 7, 10, 4, 4, 2, 0,
-  /* 282 */ 11, 7, 11, 7, 11, 7, 11, 4, 4, 2, 0,
-  /* 293 */ 9, 8, 9, 8, 9, 8, 9, 5, 4, 2, 0,
-  /* 304 */ 10, 8, 10, 8, 10, 8, 10, 5, 4, 2, 0,
-  /* 315 */ 10, 4, 10, 4, 14, 2, 10, 4, 10, 4, 2, 0,
-  /* 327 */ 10, 4, 10, 4, 14, 2, 9, 5, 10, 4, 2, 0,
-  /* 339 */ 10, 4, 10, 4, 14, 2, 10, 5, 10, 4, 2, 0,
-  /* 351 */ 10, 7, 10, 7, 10, 7, 10, 4, 2, 0,
-  /* 361 */ 11, 4, 11, 4, 14, 2, 11, 4, 11, 4, 2, 0,
-  /* 373 */ 11, 7, 11, 7, 11, 7, 11, 4, 2, 0,
-  /* 383 */ 27, 4, 2, 0,
-  /* 387 */ 9, 5, 9, 5, 14, 2, 10, 4, 9, 5, 2, 0,
-  /* 399 */ 9, 5, 9, 5, 14, 2, 9, 5, 9, 5, 2, 0,
-  /* 411 */ 9, 8, 9, 8, 9, 8, 9, 5, 2, 0,
-  /* 421 */ 10, 5, 10, 5, 14, 2, 10, 4, 10, 5, 2, 0,
-  /* 433 */ 10, 5, 10, 5, 14, 2, 10, 5, 10, 5, 2, 0,
-  /* 445 */ 10, 8, 10, 8, 10, 8, 10, 5, 2, 0,
-  /* 455 */ 10, 7, 10, 7, 10, 7, 4, 10, 7, 2, 0,
-  /* 466 */ 10, 7, 10, 7, 14, 2, 10, 4, 10, 7, 2, 0,
-  /* 478 */ 10, 7, 10, 7, 14, 2, 9, 5, 10, 7, 2, 0,
-  /* 490 */ 10, 7, 10, 7, 14, 2, 10, 5, 10, 7, 2, 0,
-  /* 502 */ 10, 7, 10, 7, 10, 7, 10, 7, 2, 0,
-  /* 512 */ 11, 7, 11, 7, 11, 7, 4, 11, 7, 2, 0,
-  /* 523 */ 11, 7, 11, 7, 14, 2, 11, 4, 11, 7, 2, 0,
-  /* 535 */ 11, 7, 11, 7, 11, 7, 11, 7, 2, 0,
-  /* 545 */ 27, 7, 2, 0,
-  /* 549 */ 9, 8, 9, 8, 9, 8, 4, 9, 8, 2, 0,
-  /* 560 */ 9, 8, 9, 8, 14, 2, 10, 4, 9, 8, 2, 0,
-  /* 572 */ 9, 8, 9, 8, 14, 2, 9, 5, 9, 8, 2, 0,
-  /* 584 */ 9, 8, 9, 8, 9, 8, 9, 8, 2, 0,
-  /* 594 */ 10, 8, 10, 8, 10, 8, 4, 10, 8, 2, 0,
-  /* 605 */ 10, 8, 10, 8, 14, 2, 10, 4, 10, 8, 2, 0,
-  /* 617 */ 10, 8, 10, 8, 14, 2, 10, 5, 10, 8, 2, 0,
-  /* 629 */ 10, 8, 10, 8, 10, 8, 10, 8, 2, 0,
-  /* 639 */ 11, 2, 11, 2, 11, 2, 11, 2, 11, 2, 11, 2, 11, 2, 0,
-  /* 654 */ 21, 12, 2, 4, 12, 2, 12, 2, 0,
-  /* 663 */ 21, 12, 2, 4, 12, 2, 0,
-  /* 670 */ 18, 4, 14, 2, 14, 2, 14, 2, 0,
-  /* 679 */ 21, 4, 14, 2, 14, 2, 4, 14, 2, 0,
-  /* 689 */ 21, 5, 14, 2, 14, 2, 4, 14, 2, 0,
-  /* 699 */ 21, 4, 14, 2, 14, 2, 4, 4, 14, 2, 0,
-  /* 710 */ 21, 5, 14, 2, 14, 2, 4, 4, 14, 2, 0,
-  /* 721 */ 14, 2, 14, 2, 4, 4, 4, 14, 2, 0,
-  /* 731 */ 21, 4, 4, 14, 2, 0,
-  /* 737 */ 14, 2, 14, 2, 4, 4, 5, 14, 2, 0,
-  /* 747 */ 21, 5, 5, 14, 2, 0,
-  /* 753 */ 0, 17, 17, 14, 2, 0,
-  /* 759 */ 14, 2, 18, 14, 2, 0,
-  /* 765 */ 16, 1, 16, 2, 16, 2, 0,
-  /* 772 */ 16, 2, 16, 2, 16, 2, 16, 2, 0,
-  /* 781 */ 13, 3, 16, 2, 16, 2, 0,
-  /* 788 */ 11, 5, 16, 2, 16, 2, 0,
-  /* 795 */ 17, 17, 17, 2, 0,
-  /* 800 */ 0, 5, 4, 4, 4, 3, 3, 3, 3, 0,
-  /* 810 */ 21, 12, 2, 4, 11, 3, 11, 3, 0,
-  /* 819 */ 21, 11, 3, 4, 11, 3, 11, 3, 0,
-  /* 828 */ 21, 11, 3, 4, 11, 3, 0,
-  /* 835 */ 16, 2, 13, 3, 13, 3, 0,
-  /* 842 */ 42, 7, 15, 3, 0,
-  /* 847 */ 9, 5, 9, 5, 14, 2, 10, 4, 9, 1, 4, 0,
-  /* 859 */ 9, 8, 9, 8, 14, 2, 10, 4, 9, 1, 4, 0,
-  /* 871 */ 10, 4, 10, 4, 14, 2, 9, 5, 9, 1, 4, 0,
-  /* 883 */ 9, 5, 9, 5, 14, 2, 9, 5, 9, 1, 4, 0,
-  /* 895 */ 10, 7, 10, 7, 14, 2, 9, 5, 9, 1, 4, 0,
-  /* 907 */ 9, 8, 9, 8, 14, 2, 9, 5, 9, 1, 4, 0,
-  /* 919 */ 10, 4, 10, 4, 14, 2, 10, 4, 10, 1, 4, 0,
-  /* 931 */ 10, 5, 10, 5, 14, 2, 10, 4, 10, 1, 4, 0,
-  /* 943 */ 10, 7, 10, 7, 14, 2, 10, 4, 10, 1, 4, 0,
-  /* 955 */ 10, 8, 10, 8, 14, 2, 10, 4, 10, 1, 4, 0,
-  /* 967 */ 10, 4, 10, 4, 14, 2, 10, 5, 10, 1, 4, 0,
-  /* 979 */ 10, 5, 10, 5, 14, 2, 10, 5, 10, 1, 4, 0,
-  /* 991 */ 10, 7, 10, 7, 14, 2, 10, 5, 10, 1, 4, 0,
-  /* 1003 */ 10, 8, 10, 8, 14, 2, 10, 5, 10, 1, 4, 0,
-  /* 1015 */ 11, 4, 11, 4, 14, 2, 11, 4, 11, 1, 4, 0,
-  /* 1027 */ 11, 5, 11, 5, 14, 2, 11, 4, 11, 1, 4, 0,
-  /* 1039 */ 11, 7, 11, 7, 14, 2, 11, 4, 11, 1, 4, 0,
-  /* 1051 */ 11, 8, 11, 8, 14, 2, 11, 4, 11, 1, 4, 0,
-  /* 1063 */ 11, 4, 11, 4, 14, 2, 11, 5, 11, 1, 4, 0,
-  /* 1075 */ 11, 5, 11, 5, 14, 2, 11, 5, 11, 1, 4, 0,
-  /* 1087 */ 11, 7, 11, 7, 14, 2, 11, 5, 11, 1, 4, 0,
-  /* 1099 */ 11, 8, 11, 8, 14, 2, 11, 5, 11, 1, 4, 0,
-  /* 1111 */ 12, 4, 12, 4, 14, 2, 12, 4, 12, 1, 4, 0,
-  /* 1123 */ 12, 7, 12, 7, 14, 2, 12, 4, 12, 1, 4, 0,
-  /* 1135 */ 12, 4, 12, 4, 36, 1, 4, 0,
-  /* 1143 */ 13, 4, 13, 4, 37, 1, 4, 0,
-  /* 1151 */ 10, 7, 10, 7, 10, 7, 10, 4, 4, 2, 4, 0,
-  /* 1163 */ 9, 8, 9, 8, 9, 8, 9, 5, 4, 2, 4, 0,
-  /* 1175 */ 11, 8, 11, 8, 11, 8, 11, 5, 4, 2, 4, 0,
-  /* 1187 */ 10, 4, 10, 4, 14, 2, 10, 4, 2, 4, 0,
-  /* 1198 */ 9, 5, 9, 5, 14, 2, 10, 4, 2, 4, 0,
-  /* 1209 */ 10, 5, 10, 5, 14, 2, 10, 4, 2, 4, 0,
-  /* 1220 */ 10, 7, 10, 7, 14, 2, 10, 4, 2, 4, 0,
-  /* 1231 */ 9, 8, 9, 8, 14, 2, 10, 4, 2, 4, 0,
-  /* 1242 */ 10, 8, 10, 8, 14, 2, 10, 4, 2, 4, 0,
-  /* 1253 */ 11, 4, 11, 4, 14, 2, 11, 4, 2, 4, 0,
-  /* 1264 */ 11, 5, 11, 5, 14, 2, 11, 4, 2, 4, 0,
-  /* 1275 */ 11, 7, 11, 7, 14, 2, 11, 4, 2, 4, 0,
-  /* 1286 */ 11, 8, 11, 8, 14, 2, 11, 4, 2, 4, 0,
-  /* 1297 */ 10, 4, 10, 4, 14, 2, 9, 5, 2, 4, 0,
-  /* 1308 */ 9, 5, 9, 5, 14, 2, 9, 5, 2, 4, 0,
-  /* 1319 */ 10, 7, 10, 7, 14, 2, 9, 5, 2, 4, 0,
-  /* 1330 */ 9, 8, 9, 8, 14, 2, 9, 5, 2, 4, 0,
-  /* 1341 */ 10, 4, 10, 4, 14, 2, 10, 5, 2, 4, 0,
-  /* 1352 */ 10, 5, 10, 5, 14, 2, 10, 5, 2, 4, 0,
-  /* 1363 */ 10, 7, 10, 7, 14, 2, 10, 5, 2, 4, 0,
-  /* 1374 */ 10, 8, 10, 8, 14, 2, 10, 5, 2, 4, 0,
-  /* 1385 */ 11, 4, 11, 4, 14, 2, 11, 5, 2, 4, 0,
-  /* 1396 */ 11, 5, 11, 5, 14, 2, 11, 5, 2, 4, 0,
-  /* 1407 */ 11, 7, 11, 7, 14, 2, 11, 5, 2, 4, 0,
-  /* 1418 */ 11, 8, 11, 8, 14, 2, 11, 5, 2, 4, 0,
-  /* 1429 */ 10, 7, 10, 7, 10, 7, 4, 10, 7, 2, 4, 0,
-  /* 1441 */ 10, 7, 10, 7, 10, 7, 10, 7, 2, 4, 0,
-  /* 1452 */ 10, 7, 10, 7, 9, 8, 10, 7, 2, 4, 0,
-  /* 1463 */ 9, 8, 9, 8, 9, 8, 4, 9, 8, 2, 4, 0,
-  /* 1475 */ 9, 8, 9, 8, 10, 7, 9, 8, 2, 4, 0,
-  /* 1486 */ 9, 8, 9, 8, 9, 8, 9, 8, 2, 4, 0,
-  /* 1497 */ 11, 8, 11, 8, 11, 8, 4, 11, 8, 2, 4, 0,
-  /* 1509 */ 11, 8, 11, 8, 11, 8, 11, 8, 2, 4, 0,
-  /* 1520 */ 12, 2, 12, 2, 12, 2, 12, 2, 4, 0,
-  /* 1530 */ 21, 12, 2, 4, 12, 2, 12, 2, 12, 2, 4, 0,
-  /* 1542 */ 21, 12, 2, 4, 12, 2, 12, 2, 4, 0,
-  /* 1552 */ 12, 2, 9, 5, 9, 5, 12, 2, 4, 0,
-  /* 1562 */ 21, 4, 14, 2, 14, 2, 4, 0,
-  /* 1570 */ 21, 5, 14, 2, 14, 2, 4, 0,
-  /* 1578 */ 15, 1, 15, 7, 14, 2, 14, 2, 4, 0,
-  /* 1588 */ 15, 4, 15, 7, 14, 2, 14, 2, 4, 0,
-  /* 1598 */ 13, 3, 16, 2, 16, 2, 4, 0,
-  /* 1606 */ 12, 7, 12, 7, 12, 7, 12, 4, 4, 3, 4, 0,
-  /* 1618 */ 12, 4, 12, 4, 14, 2, 12, 4, 3, 4, 0,
-  /* 1629 */ 12, 7, 12, 7, 14, 2, 12, 4, 3, 4, 0,
-  /* 1640 */ 12, 7, 12, 7, 12, 7, 4, 12, 7, 3, 4, 0,
-  /* 1652 */ 12, 7, 12, 7, 12, 7, 12, 7, 3, 4, 0,
-  /* 1663 */ 11, 3, 11, 3, 11, 3, 11, 3, 4, 0,
-  /* 1673 */ 21, 11, 3, 4, 11, 3, 11, 3, 11, 3, 4, 0,
-  /* 1685 */ 21, 11, 3, 4, 11, 3, 11, 3, 4, 0,
-  /* 1695 */ 21, 3, 4, 0,
-  /* 1699 */ 15, 0, 4, 15, 10, 11, 4, 10, 4, 1, 4, 4, 0,
-  /* 1712 */ 15, 0, 4, 4, 15, 10, 11, 4, 10, 4, 1, 4, 4, 0,
-  /* 1726 */ 15, 0, 4, 7, 15, 10, 11, 4, 10, 4, 1, 4, 4, 0,
-  /* 1740 */ 15, 0, 4, 4, 7, 15, 10, 11, 4, 10, 4, 1, 4, 4, 0,
-  /* 1755 */ 15, 0, 4, 15, 10, 15, 15, 11, 4, 10, 4, 1, 4, 4, 0,
-  /* 1770 */ 15, 0, 4, 4, 15, 10, 15, 15, 11, 4, 10, 4, 1, 4, 4, 0,
-  /* 1786 */ 15, 0, 4, 7, 15, 10, 15, 15, 11, 4, 10, 4, 1, 4, 4, 0,
-  /* 1802 */ 15, 0, 4, 4, 7, 15, 10, 15, 15, 11, 4, 10, 4, 1, 4, 4, 0,
-  /* 1819 */ 15, 0, 4, 15, 10, 15, 15, 15, 15, 11, 4, 10, 4, 1, 4, 4, 0,
-  /* 1836 */ 15, 0, 4, 4, 15, 10, 15, 15, 15, 15, 11, 4, 10, 4, 1, 4, 4, 0,
-  /* 1854 */ 15, 0, 4, 7, 15, 10, 15, 15, 15, 15, 11, 4, 10, 4, 1, 4, 4, 0,
-  /* 1872 */ 15, 0, 4, 4, 7, 15, 10, 15, 15, 15, 15, 11, 4, 10, 4, 1, 4, 4, 0,
-  /* 1891 */ 15, 0, 4, 15, 10, 15, 15, 15, 15, 15, 15, 11, 4, 10, 4, 1, 4, 4, 0,
-  /* 1910 */ 15, 0, 4, 4, 15, 10, 15, 15, 15, 15, 15, 15, 11, 4, 10, 4, 1, 4, 4, 0,
-  /* 1930 */ 15, 0, 4, 7, 15, 10, 15, 15, 15, 15, 15, 15, 11, 4, 10, 4, 1, 4, 4, 0,
-  /* 1950 */ 15, 0, 4, 4, 7, 15, 10, 15, 15, 15, 15, 15, 15, 11, 4, 10, 4, 1, 4, 4, 0,
-  /* 1971 */ 15, 0, 4, 15, 10, 7, 15, 18, 11, 4, 10, 4, 1, 4, 4, 0,
-  /* 1987 */ 15, 0, 4, 4, 15, 10, 7, 15, 18, 11, 4, 10, 4, 1, 4, 4, 0,
-  /* 2004 */ 15, 0, 4, 15, 10, 15, 18, 11, 4, 10, 4, 1, 4, 4, 0,
-  /* 2019 */ 15, 0, 4, 4, 15, 10, 15, 18, 11, 4, 10, 4, 1, 4, 4, 0,
-  /* 2035 */ 15, 0, 4, 15, 10, 15, 15, 15, 18, 11, 4, 10, 4, 1, 4, 4, 0,
-  /* 2052 */ 15, 0, 4, 4, 15, 10, 15, 15, 15, 18, 11, 4, 10, 4, 1, 4, 4, 0,
-  /* 2070 */ 15, 0, 4, 7, 15, 10, 15, 15, 15, 18, 11, 4, 10, 4, 1, 4, 4, 0,
-  /* 2088 */ 15, 0, 4, 4, 7, 15, 10, 15, 15, 15, 18, 11, 4, 10, 4, 1, 4, 4, 0,
-  /* 2107 */ 15, 0, 4, 15, 10, 7, 15, 18, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
-  /* 2125 */ 15, 0, 4, 4, 15, 10, 7, 15, 18, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
-  /* 2144 */ 15, 0, 4, 15, 10, 15, 18, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
-  /* 2161 */ 15, 0, 4, 4, 15, 10, 15, 18, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
-  /* 2179 */ 15, 0, 4, 15, 10, 15, 15, 15, 18, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
-  /* 2198 */ 15, 0, 4, 4, 15, 10, 15, 15, 15, 18, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
-  /* 2218 */ 15, 0, 4, 7, 15, 10, 15, 15, 15, 18, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
-  /* 2238 */ 15, 0, 4, 4, 7, 15, 10, 15, 15, 15, 18, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
-  /* 2259 */ 15, 0, 4, 15, 10, 15, 15, 15, 15, 15, 15, 15, 18, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
-  /* 2282 */ 15, 0, 4, 4, 15, 10, 15, 15, 15, 15, 15, 15, 15, 18, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
-  /* 2306 */ 15, 0, 4, 7, 15, 10, 15, 15, 15, 15, 15, 15, 15, 18, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
-  /* 2330 */ 15, 0, 4, 4, 7, 15, 10, 15, 15, 15, 15, 15, 15, 15, 18, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
-  /* 2355 */ 15, 0, 4, 15, 10, 7, 15, 18, 15, 23, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
-  /* 2375 */ 15, 0, 4, 4, 15, 10, 7, 15, 18, 15, 23, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
-  /* 2396 */ 15, 0, 4, 15, 10, 15, 18, 15, 23, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
-  /* 2415 */ 15, 0, 4, 4, 15, 10, 15, 18, 15, 23, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
-  /* 2435 */ 15, 0, 4, 15, 10, 15, 15, 15, 18, 15, 23, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
-  /* 2456 */ 15, 0, 4, 4, 15, 10, 15, 15, 15, 18, 15, 23, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
-  /* 2478 */ 15, 0, 4, 7, 15, 10, 15, 15, 15, 18, 15, 23, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
-  /* 2500 */ 15, 0, 4, 4, 7, 15, 10, 15, 15, 15, 18, 15, 23, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
-  /* 2523 */ 15, 0, 4, 15, 10, 15, 15, 15, 15, 15, 15, 15, 18, 15, 23, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
-  /* 2548 */ 15, 0, 4, 4, 15, 10, 15, 15, 15, 15, 15, 15, 15, 18, 15, 23, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
-  /* 2574 */ 15, 0, 4, 7, 15, 10, 15, 15, 15, 15, 15, 15, 15, 18, 15, 23, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
-  /* 2600 */ 15, 0, 4, 4, 7, 15, 10, 15, 15, 15, 15, 15, 15, 15, 18, 15, 23, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
-  /* 2627 */ 15, 0, 4, 15, 10, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 18, 15, 23, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
-  /* 2656 */ 15, 0, 4, 4, 15, 10, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 18, 15, 23, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
-  /* 2686 */ 15, 0, 4, 7, 15, 10, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 18, 15, 23, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
-  /* 2716 */ 15, 0, 4, 4, 7, 15, 10, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 18, 15, 23, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
-  /* 2747 */ 15, 0, 4, 15, 10, 7, 15, 18, 15, 23, 15, 23, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
-  /* 2769 */ 15, 0, 4, 4, 15, 10, 7, 15, 18, 15, 23, 15, 23, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
-  /* 2792 */ 15, 0, 4, 15, 10, 15, 18, 15, 23, 15, 23, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
-  /* 2813 */ 15, 0, 4, 4, 15, 10, 15, 18, 15, 23, 15, 23, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
-  /* 2835 */ 15, 0, 4, 15, 10, 15, 15, 15, 15, 15, 15, 15, 18, 15, 23, 15, 23, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
-  /* 2862 */ 15, 0, 4, 4, 15, 10, 15, 15, 15, 15, 15, 15, 15, 18, 15, 23, 15, 23, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
-  /* 2890 */ 15, 0, 4, 7, 15, 10, 15, 15, 15, 15, 15, 15, 15, 18, 15, 23, 15, 23, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
-  /* 2918 */ 15, 0, 4, 4, 7, 15, 10, 15, 15, 15, 15, 15, 15, 15, 18, 15, 23, 15, 23, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
-  /* 2947 */ 15, 0, 4, 15, 10, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 18, 15, 23, 15, 23, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
-  /* 2978 */ 15, 0, 4, 4, 15, 10, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 18, 15, 23, 15, 23, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
-  /* 3010 */ 15, 0, 4, 7, 15, 10, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 18, 15, 23, 15, 23, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
-  /* 3042 */ 15, 0, 4, 4, 7, 15, 10, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 18, 15, 23, 15, 23, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
-  /* 3075 */ 21, 4, 1, 4, 4, 0,
-  /* 3081 */ 21, 2, 4, 2, 4, 4, 0,
-  /* 3088 */ 10, 7, 10, 7, 10, 7, 10, 7, 2, 4, 4, 0,
-  /* 3100 */ 9, 8, 9, 8, 9, 8, 9, 8, 2, 4, 4, 0,
-  /* 3112 */ 40, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0,
-  /* 3135 */ 40, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0,
-  /* 3157 */ 10, 4, 10, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0,
-  /* 3171 */ 0, 15, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0,
-  /* 3184 */ 10, 7, 10, 7, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0,
-  /* 3198 */ 0, 15, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0,
-  /* 3210 */ 0, 5, 4, 4, 4, 4, 4, 4, 4, 0,
-  /* 3220 */ 0, 15, 0, 10, 4, 4, 4, 4, 4, 4, 0,
-  /* 3231 */ 21, 4, 4, 4, 4, 4, 4, 0,
-  /* 3239 */ 0, 15, 0, 10, 4, 4, 4, 4, 4, 0,
-  /* 3249 */ 15, 1, 15, 7, 10, 4, 4, 4, 4, 4, 0,
-  /* 3260 */ 15, 1, 15, 7, 15, 7, 10, 4, 4, 4, 4, 4, 0,
-  /* 3273 */ 21, 4, 4, 4, 4, 4, 0,
-  /* 3280 */ 10, 4, 4, 4, 10, 4, 4, 4, 4, 0,
-  /* 3290 */ 15, 1, 15, 7, 10, 4, 4, 4, 4, 0,
-  /* 3300 */ 15, 1, 15, 7, 15, 7, 10, 4, 4, 4, 4, 0,
-  /* 3312 */ 12, 4, 4, 4, 12, 4, 4, 4, 4, 0,
-  /* 3322 */ 13, 4, 9, 3, 9, 3, 13, 4, 4, 4, 4, 0,
-  /* 3334 */ 13, 4, 4, 4, 13, 4, 4, 4, 4, 0,
-  /* 3344 */ 13, 4, 10, 6, 10, 6, 13, 4, 4, 4, 4, 0,
-  /* 3356 */ 13, 4, 7, 7, 13, 4, 4, 4, 4, 0,
-  /* 3366 */ 23, 3, 3, 3, 3, 5, 4, 4, 4, 0,
-  /* 3376 */ 21, 3, 3, 5, 4, 4, 4, 0,
-  /* 3384 */ 23, 4, 4, 4, 4, 5, 4, 4, 4, 0,
-  /* 3394 */ 21, 4, 4, 5, 4, 4, 4, 0,
-  /* 3402 */ 23, 4, 4, 4, 4, 5, 5, 4, 4, 4, 0,
-  /* 3413 */ 21, 5, 5, 5, 4, 4, 4, 0,
-  /* 3421 */ 23, 7, 7, 7, 7, 5, 5, 4, 4, 4, 0,
-  /* 3432 */ 23, 7, 7, 7, 7, 5, 4, 4, 4, 0,
-  /* 3442 */ 10, 7, 9, 3, 9, 3, 10, 7, 4, 4, 4, 0,
-  /* 3454 */ 10, 7, 10, 6, 10, 6, 10, 7, 4, 4, 4, 0,
-  /* 3466 */ 10, 7, 7, 7, 10, 7, 4, 4, 4, 0,
-  /* 3476 */ 12, 7, 9, 3, 9, 3, 12, 7, 4, 4, 4, 0,
-  /* 3488 */ 12, 7, 10, 6, 10, 6, 12, 7, 4, 4, 4, 0,
-  /* 3500 */ 12, 7, 7, 7, 12, 7, 4, 4, 4, 0,
-  /* 3510 */ 15, 0, 4, 15, 9, 11, 4, 4, 4, 0,
-  /* 3520 */ 0, 15, 2, 4, 15, 9, 11, 4, 4, 4, 0,
-  /* 3531 */ 15, 1, 15, 7, 15, 9, 11, 4, 4, 4, 0,
-  /* 3542 */ 15, 1, 15, 7, 15, 7, 15, 9, 11, 4, 4, 4, 0,
-  /* 3555 */ 15, 0, 4, 15, 9, 15, 15, 11, 4, 4, 4, 0,
-  /* 3567 */ 0, 15, 2, 4, 15, 9, 15, 15, 11, 4, 4, 4, 0,
-  /* 3580 */ 15, 1, 15, 7, 15, 9, 15, 15, 11, 4, 4, 4, 0,
-  /* 3593 */ 15, 1, 15, 7, 15, 7, 15, 9, 15, 15, 11, 4, 4, 4, 0,
-  /* 3608 */ 15, 0, 4, 15, 9, 15, 15, 15, 15, 11, 4, 4, 4, 0,
-  /* 3622 */ 0, 15, 2, 4, 15, 9, 15, 15, 15, 15, 11, 4, 4, 4, 0,
-  /* 3637 */ 15, 1, 15, 7, 15, 9, 15, 15, 15, 15, 11, 4, 4, 4, 0,
-  /* 3652 */ 15, 1, 15, 7, 15, 7, 15, 9, 15, 15, 15, 15, 11, 4, 4, 4, 0,
-  /* 3669 */ 15, 0, 4, 15, 9, 15, 15, 15, 15, 15, 15, 11, 4, 4, 4, 0,
-  /* 3685 */ 0, 15, 2, 4, 15, 9, 15, 15, 15, 15, 15, 15, 11, 4, 4, 4, 0,
-  /* 3702 */ 15, 1, 15, 7, 15, 9, 15, 15, 15, 15, 15, 15, 11, 4, 4, 4, 0,
-  /* 3719 */ 15, 1, 15, 7, 15, 7, 15, 9, 15, 15, 15, 15, 15, 15, 11, 4, 4, 4, 0,
-  /* 3738 */ 16, 4, 16, 4, 16, 4, 4, 4, 0,
-  /* 3747 */ 23, 3, 3, 3, 3, 5, 4, 4, 0,
-  /* 3756 */ 21, 3, 3, 5, 4, 4, 0,
-  /* 3763 */ 23, 4, 4, 4, 4, 5, 4, 4, 0,
-  /* 3772 */ 21, 4, 4, 5, 4, 4, 0,
-  /* 3779 */ 23, 4, 4, 4, 4, 5, 5, 4, 4, 0,
-  /* 3789 */ 21, 5, 5, 5, 4, 4, 0,
-  /* 3796 */ 23, 7, 7, 7, 7, 5, 5, 4, 4, 0,
-  /* 3806 */ 23, 7, 7, 7, 7, 5, 4, 4, 0,
-  /* 3815 */ 23, 15, 3, 15, 7, 15, 7, 15, 7, 15, 12, 15, 7, 15, 7, 15, 7, 15, 7, 4, 4, 0,
-  /* 3837 */ 22, 15, 3, 15, 7, 15, 7, 15, 12, 15, 7, 15, 7, 15, 7, 4, 4, 0,
-  /* 3855 */ 21, 15, 3, 15, 7, 15, 12, 15, 7, 15, 7, 4, 4, 0,
-  /* 3869 */ 0, 14, 2, 10, 1, 10, 4, 10, 4, 4, 0,
-  /* 3880 */ 0, 14, 2, 2, 10, 4, 10, 4, 4, 0,
-  /* 3890 */ 21, 10, 4, 4, 10, 4, 10, 4, 4, 0,
-  /* 3900 */ 21, 10, 4, 4, 10, 4, 10, 4, 10, 4, 4, 0,
-  /* 3912 */ 10, 4, 10, 4, 10, 4, 10, 4, 4, 0,
-  /* 3922 */ 0, 14, 2, 9, 1, 9, 5, 10, 4, 4, 0,
-  /* 3933 */ 0, 14, 2, 2, 9, 5, 10, 4, 4, 0,
-  /* 3943 */ 0, 14, 2, 10, 1, 10, 5, 10, 4, 4, 0,
-  /* 3954 */ 0, 14, 2, 2, 10, 5, 10, 4, 4, 0,
-  /* 3964 */ 0, 14, 2, 11, 1, 11, 4, 11, 4, 4, 0,
-  /* 3975 */ 0, 14, 2, 2, 11, 4, 11, 4, 4, 0,
-  /* 3985 */ 11, 4, 11, 4, 11, 4, 11, 4, 4, 0,
-  /* 3995 */ 0, 14, 2, 11, 1, 11, 5, 11, 4, 4, 0,
-  /* 4006 */ 0, 14, 2, 2, 11, 5, 11, 4, 4, 0,
-  /* 4016 */ 36, 1, 36, 1, 12, 4, 4, 0,
-  /* 4024 */ 0, 14, 2, 12, 1, 12, 4, 12, 4, 4, 0,
-  /* 4035 */ 0, 14, 2, 3, 12, 4, 12, 4, 4, 0,
-  /* 4045 */ 21, 12, 4, 12, 4, 12, 4, 12, 4, 4, 0,
-  /* 4056 */ 13, 4, 13, 4, 12, 4, 12, 4, 4, 0,
-  /* 4066 */ 37, 1, 37, 1, 13, 4, 4, 0,
-  /* 4074 */ 21, 13, 4, 13, 4, 13, 4, 13, 4, 4, 0,
-  /* 4085 */ 16, 4, 16, 4, 13, 4, 13, 4, 4, 0,
-  /* 4095 */ 16, 4, 16, 4, 13, 4, 4, 0,
-  /* 4103 */ 40, 4, 4, 4, 4, 4, 4, 4, 4, 15, 4, 4, 0,
-  /* 4116 */ 23, 4, 4, 4, 4, 15, 4, 4, 0,
-  /* 4125 */ 21, 4, 4, 15, 4, 4, 0,
-  /* 4132 */ 40, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 15, 4, 4, 0,
-  /* 4153 */ 23, 9, 6, 9, 6, 9, 6, 9, 6, 15, 4, 4, 0,
-  /* 4166 */ 40, 7, 7, 7, 7, 7, 7, 7, 7, 15, 4, 4, 0,
-  /* 4179 */ 0, 15, 4, 15, 11, 15, 15, 4, 4, 0,
-  /* 4189 */ 0, 15, 4, 15, 11, 15, 15, 15, 15, 4, 4, 0,
-  /* 4201 */ 0, 15, 4, 15, 11, 15, 15, 15, 15, 15, 15, 4, 4, 0,
-  /* 4215 */ 13, 4, 13, 4, 16, 4, 4, 0,
-  /* 4223 */ 16, 4, 16, 4, 16, 4, 4, 0,
-  /* 4231 */ 17, 17, 4, 4, 0,
-  /* 4236 */ 15, 0, 18, 4, 4, 0,
-  /* 4242 */ 21, 4, 4, 0,
-  /* 4246 */ 23, 3, 3, 3, 3, 5, 4, 0,
-  /* 4254 */ 21, 3, 3, 5, 4, 0,
-  /* 4260 */ 23, 4, 4, 4, 4, 5, 4, 0,
-  /* 4268 */ 21, 4, 4, 5, 4, 0,
-  /* 4274 */ 23, 4, 4, 4, 4, 5, 5, 4, 0,
-  /* 4283 */ 21, 5, 4, 5, 5, 4, 0,
-  /* 4290 */ 21, 5, 5, 5, 4, 0,
-  /* 4296 */ 23, 7, 7, 7, 7, 5, 5, 4, 0,
-  /* 4305 */ 23, 7, 7, 7, 7, 5, 4, 0,
-  /* 4313 */ 0, 14, 2, 9, 1, 10, 4, 9, 5, 4, 0,
-  /* 4324 */ 0, 14, 2, 2, 10, 4, 9, 5, 4, 0,
-  /* 4334 */ 0, 14, 2, 9, 1, 9, 5, 9, 5, 4, 0,
-  /* 4345 */ 0, 14, 2, 2, 9, 5, 9, 5, 4, 0,
-  /* 4355 */ 9, 5, 9, 5, 9, 5, 9, 5, 4, 0,
-  /* 4365 */ 0, 14, 2, 10, 1, 10, 4, 10, 5, 4, 0,
-  /* 4376 */ 0, 14, 2, 2, 10, 4, 10, 5, 4, 0,
-  /* 4386 */ 0, 14, 2, 10, 1, 10, 5, 10, 5, 4, 0,
-  /* 4397 */ 0, 14, 2, 2, 10, 5, 10, 5, 4, 0,
-  /* 4407 */ 10, 5, 10, 5, 10, 5, 10, 5, 4, 0,
-  /* 4417 */ 0, 14, 2, 11, 1, 11, 4, 11, 5, 4, 0,
-  /* 4428 */ 0, 14, 2, 2, 11, 4, 11, 5, 4, 0,
-  /* 4438 */ 0, 14, 2, 11, 1, 11, 5, 11, 5, 4, 0,
-  /* 4449 */ 0, 14, 2, 2, 11, 5, 11, 5, 4, 0,
-  /* 4459 */ 11, 5, 11, 5, 11, 5, 11, 5, 4, 0,
-  /* 4469 */ 21, 5, 4, 0,
-  /* 4473 */ 0, 15, 4, 9, 6, 9, 6, 9, 6, 9, 6, 4, 0,
-  /* 4486 */ 0, 15, 4, 7, 7, 7, 7, 7, 7, 7, 7, 4, 0,
-  /* 4499 */ 21, 10, 4, 4, 10, 7, 4, 0,
-  /* 4507 */ 0, 14, 2, 10, 1, 10, 4, 10, 7, 4, 0,
-  /* 4518 */ 0, 14, 2, 2, 10, 4, 10, 7, 4, 0,
-  /* 4528 */ 0, 14, 2, 9, 1, 9, 5, 10, 7, 4, 0,
-  /* 4539 */ 0, 14, 2, 2, 9, 5, 10, 7, 4, 0,
-  /* 4549 */ 0, 14, 2, 10, 1, 10, 5, 10, 7, 4, 0,
-  /* 4560 */ 0, 14, 2, 2, 10, 5, 10, 7, 4, 0,
-  /* 4570 */ 0, 14, 2, 11, 1, 11, 4, 11, 7, 4, 0,
-  /* 4581 */ 0, 14, 2, 2, 11, 4, 11, 7, 4, 0,
-  /* 4591 */ 0, 14, 2, 11, 1, 11, 5, 11, 7, 4, 0,
-  /* 4602 */ 0, 14, 2, 2, 11, 5, 11, 7, 4, 0,
-  /* 4612 */ 0, 14, 2, 12, 1, 12, 4, 12, 7, 4, 0,
-  /* 4623 */ 0, 14, 2, 3, 12, 4, 12, 7, 4, 0,
-  /* 4633 */ 12, 7, 12, 7, 12, 7, 12, 7, 4, 0,
-  /* 4643 */ 15, 1, 25, 7, 4, 0,
-  /* 4649 */ 15, 3, 26, 7, 4, 0,
-  /* 4655 */ 21, 9, 5, 4, 9, 8, 4, 0,
-  /* 4663 */ 0, 14, 2, 9, 1, 10, 4, 9, 8, 4, 0,
-  /* 4674 */ 0, 14, 2, 2, 10, 4, 9, 8, 4, 0,
-  /* 4684 */ 0, 14, 2, 9, 1, 9, 5, 9, 8, 4, 0,
-  /* 4695 */ 0, 14, 2, 2, 9, 5, 9, 8, 4, 0,
-  /* 4705 */ 0, 14, 2, 10, 1, 10, 4, 10, 8, 4, 0,
-  /* 4716 */ 0, 14, 2, 2, 10, 4, 10, 8, 4, 0,
-  /* 4726 */ 0, 14, 2, 10, 1, 10, 5, 10, 8, 4, 0,
-  /* 4737 */ 0, 14, 2, 2, 10, 5, 10, 8, 4, 0,
-  /* 4747 */ 0, 14, 2, 11, 1, 11, 4, 11, 8, 4, 0,
-  /* 4758 */ 0, 14, 2, 2, 11, 4, 11, 8, 4, 0,
-  /* 4768 */ 0, 14, 2, 11, 1, 11, 5, 11, 8, 4, 0,
-  /* 4779 */ 0, 14, 2, 2, 11, 5, 11, 8, 4, 0,
-  /* 4789 */ 11, 8, 11, 8, 11, 8, 11, 8, 4, 0,
-  /* 4799 */ 21, 10, 4, 4, 10, 4, 0,
-  /* 4806 */ 21, 10, 1, 10, 1, 10, 4, 10, 4, 0,
-  /* 4816 */ 21, 11, 3, 4, 10, 4, 10, 4, 0,
-  /* 4825 */ 21, 10, 4, 4, 10, 4, 10, 4, 0,
-  /* 4834 */ 21, 11, 1, 11, 1, 11, 4, 11, 4, 0,
-  /* 4844 */ 12, 4, 36, 1, 12, 4, 0,
-  /* 4851 */ 0, 36, 1, 14, 2, 12, 4, 0,
-  /* 4859 */ 0, 14, 2, 36, 1, 4, 4, 12, 4, 0,
-  /* 4869 */ 21, 12, 1, 12, 1, 12, 4, 12, 4, 0,
-  /* 4879 */ 36, 1, 36, 1, 12, 4, 12, 4, 0,
-  /* 4888 */ 12, 4, 36, 1, 12, 4, 12, 4, 0,
-  /* 4897 */ 13, 4, 36, 1, 12, 4, 12, 4, 0,
-  /* 4906 */ 0, 36, 1, 4, 4, 12, 4, 12, 4, 0,
-  /* 4916 */ 0, 36, 1, 4, 4, 13, 4, 12, 4, 0,
-  /* 4926 */ 21, 15, 3, 15, 7, 15, 12, 4, 0,
-  /* 4935 */ 22, 15, 3, 15, 7, 15, 7, 15, 12, 4, 0,
-  /* 4946 */ 23, 15, 3, 15, 7, 15, 7, 15, 7, 15, 12, 4, 0,
-  /* 4959 */ 13, 4, 37, 1, 13, 4, 0,
-  /* 4966 */ 0, 37, 1, 14, 2, 13, 4, 0,
-  /* 4974 */ 0, 14, 2, 36, 1, 4, 4, 13, 4, 0,
-  /* 4984 */ 0, 14, 2, 37, 1, 4, 4, 13, 4, 0,
-  /* 4994 */ 37, 1, 37, 1, 13, 4, 13, 4, 0,
-  /* 5003 */ 13, 4, 37, 1, 13, 4, 13, 4, 0,
-  /* 5012 */ 16, 4, 37, 1, 13, 4, 13, 4, 0,
-  /* 5021 */ 0, 37, 1, 4, 4, 13, 4, 13, 4, 0,
-  /* 5031 */ 16, 4, 16, 4, 13, 4, 13, 4, 0,
-  /* 5040 */ 0, 4, 4, 16, 4, 13, 4, 0,
-  /* 5048 */ 0, 37, 1, 4, 4, 16, 4, 13, 4, 0,
-  /* 5058 */ 16, 4, 16, 4, 13, 4, 0,
-  /* 5065 */ 40, 4, 4, 4, 4, 4, 4, 4, 4, 15, 4, 0,
-  /* 5077 */ 23, 4, 4, 4, 4, 15, 4, 0,
-  /* 5085 */ 21, 4, 4, 15, 4, 0,
-  /* 5091 */ 0, 14, 20, 5, 15, 4, 0,
-  /* 5098 */ 40, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 15, 4, 0,
-  /* 5118 */ 23, 9, 6, 9, 6, 9, 6, 9, 6, 15, 4, 0,
-  /* 5130 */ 40, 7, 7, 7, 7, 7, 7, 7, 7, 15, 4, 0,
-  /* 5142 */ 0, 15, 4, 15, 11, 15, 15, 15, 15, 4, 0,
-  /* 5153 */ 0, 15, 4, 15, 11, 15, 15, 15, 15, 15, 15, 4, 0,
-  /* 5166 */ 5, 19, 15, 4, 0,
-  /* 5171 */ 0, 14, 2, 37, 1, 4, 4, 16, 4, 0,
-  /* 5181 */ 0, 14, 2, 4, 4, 16, 4, 0,
-  /* 5189 */ 13, 4, 16, 4, 0,
-  /* 5194 */ 16, 4, 16, 4, 16, 4, 0,
-  /* 5201 */ 4, 17, 4, 0,
-  /* 5205 */ 0, 15, 4, 15, 12, 15, 17, 4, 0,
-  /* 5214 */ 17, 17, 4, 0,
-  /* 5218 */ 0, 18, 4, 0,
-  /* 5222 */ 21, 5, 1, 4, 5, 0,
-  /* 5228 */ 16, 4, 16, 4, 13, 4, 5, 0,
-  /* 5236 */ 21, 2, 5, 2, 5, 5, 0,
-  /* 5243 */ 21, 5, 4, 5, 5, 0,
-  /* 5249 */ 21, 5, 4, 5, 5, 5, 0,
-  /* 5256 */ 21, 9, 1, 9, 1, 9, 5, 9, 5, 0,
-  /* 5266 */ 21, 10, 4, 4, 9, 5, 9, 5, 0,
-  /* 5275 */ 21, 9, 5, 4, 9, 5, 9, 5, 0,
-  /* 5284 */ 21, 10, 1, 10, 1, 10, 5, 10, 5, 0,
-  /* 5294 */ 21, 11, 1, 11, 1, 11, 5, 11, 5, 0,
-  /* 5304 */ 41, 41, 5, 0,
-  /* 5308 */ 0, 15, 4, 9, 6, 9, 6, 9, 6, 9, 6, 0,
-  /* 5320 */ 23, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 0,
-  /* 5370 */ 40, 7, 7, 7, 7, 7, 7, 7, 7, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 0,
-  /* 5420 */ 23, 4, 4, 4, 4, 5, 4, 7, 0,
-  /* 5429 */ 23, 4, 4, 4, 4, 5, 5, 4, 7, 0,
-  /* 5439 */ 23, 7, 7, 7, 7, 5, 5, 4, 7, 0,
-  /* 5449 */ 23, 7, 7, 7, 7, 5, 4, 7, 0,
-  /* 5458 */ 21, 7, 4, 7, 0,
-  /* 5463 */ 23, 4, 4, 4, 4, 5, 7, 0,
-  /* 5471 */ 23, 4, 4, 4, 4, 5, 5, 7, 0,
-  /* 5480 */ 23, 7, 7, 7, 7, 5, 5, 7, 0,
-  /* 5489 */ 23, 7, 7, 7, 7, 5, 7, 0,
-  /* 5497 */ 23, 4, 4, 4, 4, 5, 4, 7, 7, 0,
-  /* 5507 */ 23, 4, 4, 4, 4, 5, 5, 4, 7, 7, 0,
-  /* 5518 */ 23, 7, 7, 7, 7, 5, 5, 4, 7, 7, 0,
-  /* 5529 */ 23, 7, 7, 7, 7, 5, 4, 7, 7, 0,
-  /* 5539 */ 21, 7, 4, 7, 7, 0,
-  /* 5545 */ 23, 4, 4, 4, 4, 5, 7, 7, 0,
-  /* 5554 */ 23, 4, 4, 4, 4, 5, 5, 7, 7, 0,
-  /* 5564 */ 23, 7, 7, 7, 7, 5, 5, 7, 7, 0,
-  /* 5574 */ 23, 7, 7, 7, 7, 5, 7, 7, 0,
-  /* 5583 */ 23, 4, 4, 4, 4, 5, 4, 7, 7, 7, 0,
-  /* 5594 */ 23, 4, 4, 4, 4, 5, 5, 4, 7, 7, 7, 0,
-  /* 5606 */ 23, 7, 7, 7, 7, 5, 5, 4, 7, 7, 7, 0,
-  /* 5618 */ 23, 7, 7, 7, 7, 5, 4, 7, 7, 7, 0,
-  /* 5629 */ 23, 4, 4, 4, 4, 5, 7, 7, 7, 0,
-  /* 5639 */ 23, 4, 4, 4, 4, 5, 5, 7, 7, 7, 0,
-  /* 5650 */ 23, 7, 7, 7, 7, 5, 5, 7, 7, 7, 0,
-  /* 5661 */ 23, 7, 7, 7, 7, 5, 7, 7, 7, 0,
-  /* 5671 */ 23, 4, 4, 4, 4, 5, 4, 7, 7, 7, 7, 0,
-  /* 5683 */ 23, 4, 4, 4, 4, 5, 5, 4, 7, 7, 7, 7, 0,
-  /* 5696 */ 23, 7, 7, 7, 7, 5, 5, 4, 7, 7, 7, 7, 0,
-  /* 5709 */ 23, 7, 7, 7, 7, 5, 4, 7, 7, 7, 7, 0,
-  /* 5721 */ 23, 4, 4, 4, 4, 5, 7, 7, 7, 7, 0,
-  /* 5732 */ 23, 4, 4, 4, 4, 5, 5, 7, 7, 7, 7, 0,
-  /* 5744 */ 23, 7, 7, 7, 7, 5, 5, 7, 7, 7, 7, 0,
-  /* 5756 */ 23, 7, 7, 7, 7, 5, 7, 7, 7, 7, 0,
-  /* 5767 */ 23, 4, 4, 4, 4, 5, 4, 7, 7, 7, 7, 7, 7, 0,
-  /* 5781 */ 23, 4, 4, 4, 4, 5, 5, 4, 7, 7, 7, 7, 7, 7, 0,
-  /* 5796 */ 23, 7, 7, 7, 7, 5, 5, 4, 7, 7, 7, 7, 7, 7, 0,
-  /* 5811 */ 23, 7, 7, 7, 7, 5, 4, 7, 7, 7, 7, 7, 7, 0,
-  /* 5825 */ 23, 4, 4, 4, 4, 5, 7, 7, 7, 7, 7, 7, 0,
-  /* 5838 */ 23, 4, 4, 4, 4, 5, 5, 7, 7, 7, 7, 7, 7, 0,
-  /* 5852 */ 23, 7, 7, 7, 7, 5, 5, 7, 7, 7, 7, 7, 7, 0,
-  /* 5866 */ 23, 7, 7, 7, 7, 5, 7, 7, 7, 7, 7, 7, 0,
-  /* 5879 */ 0, 15, 4, 7, 7, 7, 7, 7, 7, 7, 7, 0,
-  /* 5891 */ 23, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 7, 7, 7, 7, 7, 7, 7, 7, 0,
-  /* 5941 */ 40, 7, 7, 7, 7, 7, 7, 7, 7, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 7, 7, 7, 7, 7, 7, 7, 7, 0,
-  /* 5991 */ 23, 4, 4, 4, 4, 5, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0,
-  /* 6007 */ 23, 4, 4, 4, 4, 5, 5, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0,
-  /* 6024 */ 23, 7, 7, 7, 7, 5, 5, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0,
-  /* 6041 */ 23, 7, 7, 7, 7, 5, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0,
-  /* 6057 */ 21, 10, 4, 4, 10, 7, 10, 7, 0,
-  /* 6066 */ 17, 10, 7, 0,
-  /* 6070 */ 15, 3, 34, 1, 0, 4, 31, 3, 1, 15, 7, 0,
-  /* 6082 */ 15, 3, 15, 12, 4, 31, 3, 1, 15, 7, 0,
-  /* 6093 */ 15, 3, 33, 7, 31, 3, 1, 15, 7, 0,
-  /* 6103 */ 15, 3, 12, 2, 12, 2, 12, 2, 12, 2, 15, 7, 0,
-  /* 6116 */ 15, 3, 15, 7, 12, 2, 12, 2, 12, 2, 12, 2, 15, 7, 0,
-  /* 6131 */ 15, 3, 12, 2, 12, 2, 12, 2, 15, 7, 0,
-  /* 6142 */ 15, 3, 15, 7, 12, 2, 12, 2, 12, 2, 15, 7, 0,
-  /* 6155 */ 15, 3, 15, 7, 12, 2, 12, 2, 15, 7, 0,
-  /* 6166 */ 21, 15, 1, 31, 1, 1, 15, 7, 15, 7, 0,
-  /* 6177 */ 15, 1, 25, 7, 0,
-  /* 6182 */ 15, 3, 25, 7, 0,
-  /* 6187 */ 15, 3, 25, 7, 25, 7, 0,
-  /* 6194 */ 15, 3, 26, 7, 0,
-  /* 6199 */ 15, 3, 26, 7, 26, 7, 0,
-  /* 6206 */ 9, 8, 9, 8, 9, 5, 9, 8, 0,
-  /* 6215 */ 21, 9, 5, 4, 9, 8, 9, 8, 0,
-  /* 6224 */ 9, 8, 9, 8, 9, 8, 9, 8, 0,
-  /* 6233 */ 17, 9, 8, 0,
-  /* 6237 */ 10, 8, 10, 8, 10, 5, 10, 8, 0,
-  /* 6246 */ 10, 8, 10, 8, 10, 8, 10, 8, 0,
-  /* 6255 */ 11, 8, 11, 8, 11, 5, 11, 8, 0,
-  /* 6264 */ 21, 1, 15, 1, 15, 9, 0,
-  /* 6271 */ 23, 15, 7, 15, 7, 15, 7, 15, 3, 15, 12, 0,
-  /* 6283 */ 22, 15, 7, 15, 7, 15, 3, 15, 12, 0,
-  /* 6293 */ 21, 15, 7, 15, 3, 15, 12, 0,
-  /* 6301 */ 23, 15, 7, 15, 7, 15, 7, 15, 7, 15, 7, 15, 7, 15, 7, 15, 3, 5, 15, 12, 0,
-  /* 6322 */ 22, 15, 7, 15, 7, 15, 7, 15, 7, 15, 7, 15, 3, 5, 15, 12, 0,
-  /* 6339 */ 21, 15, 7, 15, 7, 15, 7, 15, 3, 5, 15, 12, 0,
-  /* 6352 */ 0, 15, 3, 15, 7, 5, 15, 12, 0,
-  /* 6361 */ 0, 15, 3, 15, 7, 15, 7, 5, 15, 12, 0,
-  /* 6372 */ 0, 15, 3, 15, 7, 15, 7, 15, 7, 5, 15, 12, 0,
-  /* 6385 */ 21, 15, 3, 15, 7, 15, 12, 0,
-  /* 6393 */ 0, 15, 3, 15, 7, 15, 7, 15, 12, 0,
-  /* 6403 */ 22, 15, 3, 15, 7, 15, 7, 15, 12, 0,
-  /* 6413 */ 0, 15, 3, 15, 7, 15, 7, 15, 7, 15, 12, 0,
-  /* 6425 */ 23, 15, 3, 15, 7, 15, 7, 15, 7, 15, 12, 0,
-  /* 6437 */ 15, 3, 15, 7, 15, 11, 15, 15, 0,
-  /* 6446 */ 0, 15, 4, 15, 11, 15, 15, 15, 15, 0,
-  /* 6456 */ 0, 15, 4, 15, 11, 15, 15, 15, 15, 15, 15, 0,
-  /* 6468 */ 4, 17, 0,
-  /* 6471 */ 10, 7, 10, 7, 17, 0,
-  /* 6477 */ 9, 8, 17, 0,
-  /* 6481 */ 15, 1, 15, 9, 15, 17, 0,
-  /* 6488 */ 0, 14, 17, 17, 0,
-  /* 6493 */ 17, 17, 17, 0,
-  /* 6497 */ 15, 0, 18, 0,
-  /* 6501 */ 1, 18, 0,
-  /* 6504 */ 14, 2, 18, 0,
-  /* 6508 */ 15, 4, 18, 0,
-  /* 6512 */ 0, 19, 0,
-  /* 6515 */ 15, 1, 19, 0,
-  /* 6519 */ 1, 14, 2, 19, 0,
-  /* 6524 */ 21, 14, 2, 1, 14, 2, 4, 19, 0,
-  /* 6533 */ 15, 2, 15, 10, 19, 0,
-  /* 6539 */ 15, 2, 15, 7, 4, 19, 19, 0,
-  /* 6547 */ 15, 2, 15, 7, 19, 19, 0,
-  /* 6554 */ 15, 2, 15, 7, 15, 7, 19, 19, 0,
-  /* 6563 */ 15, 2, 15, 7, 15, 7, 15, 7, 19, 19, 0,
-  /* 6574 */ 15, 2, 15, 10, 19, 19, 0,
-  /* 6581 */ 0, 19, 19, 19, 0,
-  /* 6586 */ 15, 0, 29, 0,
-  /* 6590 */ 0, 1, 29, 0,
-  /* 6594 */ 0, 5, 4, 14, 2, 4, 29, 0,
-  /* 6602 */ 5, 5, 4, 14, 2, 4, 29, 0,
-  /* 6610 */ 18, 5, 4, 15, 4, 4, 4, 29, 0,
-  /* 6619 */ 0, 5, 4, 29, 0,
-  /* 6624 */ 28, 35, 28, 35, 28, 35, 28, 35, 0,
-  /* 6633 */ 5, 41, 0,
-  /* 6636 */ 8, 41, 0,
-  /* 6639 */ 41, 41, 41, 41, 0,
+  /* 36 */ 0, 15, 2, 10, 4, 4, 4, 1, 1, 0,
+  /* 46 */ 0, 4, 4, 15, 3, 15, 7, 1, 1, 0,
+  /* 56 */ 0, 4, 4, 15, 0, 15, 7, 15, 7, 15, 7, 1, 1, 0,
+  /* 70 */ 21, 1, 15, 1, 1, 0,
+  /* 76 */ 0, 15, 3, 34, 1, 0, 4, 31, 3, 1, 0,
+  /* 87 */ 0, 15, 3, 15, 12, 4, 31, 3, 1, 0,
+  /* 97 */ 15, 3, 15, 7, 31, 3, 1, 0,
+  /* 105 */ 15, 3, 15, 7, 15, 7, 31, 3, 1, 0,
+  /* 115 */ 0, 15, 3, 33, 7, 31, 3, 1, 0,
+  /* 124 */ 15, 1, 15, 7, 15, 7, 4, 4, 4, 1, 0,
+  /* 135 */ 15, 1, 15, 7, 10, 4, 4, 4, 1, 0,
+  /* 145 */ 15, 2, 15, 7, 10, 4, 4, 4, 1, 0,
+  /* 155 */ 15, 0, 27, 3, 15, 7, 15, 7, 4, 4, 1, 0,
+  /* 167 */ 15, 1, 15, 12, 15, 7, 4, 4, 1, 0,
+  /* 177 */ 21, 15, 2, 1, 15, 7, 15, 7, 1, 0,
+  /* 187 */ 15, 2, 15, 7, 15, 7, 15, 7, 1, 0,
+  /* 197 */ 9, 1, 9, 8, 9, 8, 4, 9, 1, 0,
+  /* 207 */ 10, 7, 10, 7, 11, 6, 4, 10, 1, 0,
+  /* 217 */ 11, 6, 11, 6, 10, 7, 4, 10, 1, 0,
+  /* 227 */ 10, 1, 10, 7, 10, 7, 4, 10, 1, 0,
+  /* 237 */ 10, 1, 10, 8, 10, 8, 4, 10, 1, 0,
+  /* 247 */ 11, 1, 11, 7, 11, 7, 4, 11, 1, 0,
+  /* 257 */ 0, 43, 12, 1, 0,
+  /* 262 */ 43, 12, 1, 43, 12, 1, 0,
+  /* 269 */ 15, 3, 43, 12, 1, 0,
+  /* 275 */ 42, 7, 15, 1, 0,
+  /* 280 */ 0, 19, 15, 1, 0,
+  /* 285 */ 16, 1, 16, 1, 16, 1, 0,
+  /* 292 */ 4, 16, 1, 16, 1, 0,
+  /* 298 */ 21, 12, 4, 16, 1, 12, 4, 12, 4, 16, 1, 0,
+  /* 310 */ 12, 4, 12, 4, 12, 4, 16, 1, 0,
+  /* 319 */ 0, 15, 4, 15, 12, 15, 17, 1, 0,
+  /* 328 */ 2, 18, 1, 0,
+  /* 332 */ 36, 1, 36, 1, 36, 1, 0,
+  /* 339 */ 50, 1, 36, 1, 0,
+  /* 344 */ 23, 12, 2, 12, 2, 12, 2, 12, 2, 36, 1, 0,
+  /* 356 */ 47, 1, 47, 1, 47, 1, 0,
+  /* 363 */ 21, 13, 4, 47, 1, 13, 4, 13, 4, 47, 1, 0,
+  /* 375 */ 13, 4, 13, 4, 13, 4, 47, 1, 0,
+  /* 384 */ 36, 1, 36, 1, 50, 1, 0,
+  /* 391 */ 50, 1, 50, 1, 50, 1, 0,
+  /* 398 */ 21, 12, 2, 12, 2, 50, 1, 0,
+  /* 406 */ 16, 2, 16, 2, 16, 2, 2, 0,
+  /* 414 */ 12, 2, 12, 2, 4, 12, 2, 4, 2, 0,
+  /* 424 */ 10, 7, 10, 7, 10, 7, 10, 4, 4, 2, 0,
+  /* 435 */ 11, 7, 11, 7, 11, 7, 11, 4, 4, 2, 0,
+  /* 446 */ 9, 8, 9, 8, 9, 8, 9, 5, 4, 2, 0,
+  /* 457 */ 10, 8, 10, 8, 10, 8, 10, 5, 4, 2, 0,
+  /* 468 */ 10, 4, 10, 4, 14, 2, 10, 4, 10, 4, 2, 0,
+  /* 480 */ 10, 4, 10, 4, 14, 2, 9, 5, 10, 4, 2, 0,
+  /* 492 */ 10, 4, 10, 4, 14, 2, 10, 5, 10, 4, 2, 0,
+  /* 504 */ 10, 7, 10, 7, 10, 7, 10, 4, 2, 0,
+  /* 514 */ 11, 4, 11, 4, 14, 2, 11, 4, 11, 4, 2, 0,
+  /* 526 */ 11, 7, 11, 7, 11, 7, 11, 4, 2, 0,
+  /* 536 */ 27, 4, 2, 0,
+  /* 540 */ 9, 5, 9, 5, 14, 2, 10, 4, 9, 5, 2, 0,
+  /* 552 */ 9, 5, 9, 5, 14, 2, 9, 5, 9, 5, 2, 0,
+  /* 564 */ 9, 8, 9, 8, 9, 8, 9, 5, 2, 0,
+  /* 574 */ 10, 5, 10, 5, 14, 2, 10, 4, 10, 5, 2, 0,
+  /* 586 */ 10, 5, 10, 5, 14, 2, 10, 5, 10, 5, 2, 0,
+  /* 598 */ 10, 8, 10, 8, 10, 8, 10, 5, 2, 0,
+  /* 608 */ 10, 7, 10, 7, 10, 7, 4, 10, 7, 2, 0,
+  /* 619 */ 10, 7, 10, 7, 14, 2, 10, 4, 10, 7, 2, 0,
+  /* 631 */ 10, 7, 10, 7, 14, 2, 9, 5, 10, 7, 2, 0,
+  /* 643 */ 10, 7, 10, 7, 14, 2, 10, 5, 10, 7, 2, 0,
+  /* 655 */ 10, 7, 10, 7, 10, 7, 10, 7, 2, 0,
+  /* 665 */ 11, 7, 11, 7, 11, 7, 4, 11, 7, 2, 0,
+  /* 676 */ 11, 7, 11, 7, 14, 2, 11, 4, 11, 7, 2, 0,
+  /* 688 */ 11, 7, 11, 7, 11, 7, 11, 7, 2, 0,
+  /* 698 */ 27, 7, 2, 0,
+  /* 702 */ 9, 8, 9, 8, 9, 8, 4, 9, 8, 2, 0,
+  /* 713 */ 9, 8, 9, 8, 14, 2, 10, 4, 9, 8, 2, 0,
+  /* 725 */ 9, 8, 9, 8, 14, 2, 9, 5, 9, 8, 2, 0,
+  /* 737 */ 9, 8, 9, 8, 9, 8, 9, 8, 2, 0,
+  /* 747 */ 10, 8, 10, 8, 10, 8, 4, 10, 8, 2, 0,
+  /* 758 */ 10, 8, 10, 8, 14, 2, 10, 4, 10, 8, 2, 0,
+  /* 770 */ 10, 8, 10, 8, 14, 2, 10, 5, 10, 8, 2, 0,
+  /* 782 */ 10, 8, 10, 8, 10, 8, 10, 8, 2, 0,
+  /* 792 */ 11, 2, 11, 2, 11, 2, 11, 2, 11, 2, 11, 2, 11, 2, 0,
+  /* 807 */ 36, 1, 36, 1, 50, 1, 12, 2, 0,
+  /* 816 */ 36, 1, 36, 1, 12, 2, 12, 2, 0,
+  /* 825 */ 50, 1, 12, 2, 12, 2, 0,
+  /* 832 */ 36, 1, 12, 2, 12, 2, 12, 2, 12, 2, 0,
+  /* 843 */ 21, 12, 2, 4, 12, 2, 12, 2, 12, 2, 0,
+  /* 854 */ 21, 12, 2, 4, 12, 2, 12, 2, 0,
+  /* 863 */ 21, 12, 2, 4, 11, 3, 11, 3, 12, 2, 0,
+  /* 874 */ 21, 12, 2, 4, 12, 2, 0,
+  /* 881 */ 21, 12, 2, 4, 10, 4, 10, 4, 12, 2, 0,
+  /* 892 */ 43, 12, 2, 43, 12, 2, 43, 12, 2, 0,
+  /* 902 */ 0, 50, 1, 14, 2, 0,
+  /* 908 */ 18, 4, 4, 14, 2, 14, 2, 14, 2, 14, 2, 0,
+  /* 920 */ 18, 4, 14, 2, 14, 2, 14, 2, 0,
+  /* 929 */ 0, 14, 2, 14, 2, 14, 2, 4, 14, 2, 0,
+  /* 940 */ 21, 4, 14, 2, 14, 2, 4, 14, 2, 0,
+  /* 950 */ 21, 5, 14, 2, 14, 2, 4, 14, 2, 0,
+  /* 960 */ 15, 4, 15, 7, 14, 2, 14, 2, 4, 14, 2, 0,
+  /* 972 */ 21, 4, 14, 2, 14, 2, 4, 4, 14, 2, 0,
+  /* 983 */ 21, 5, 14, 2, 14, 2, 4, 4, 14, 2, 0,
+  /* 994 */ 14, 2, 14, 2, 4, 4, 4, 14, 2, 0,
+  /* 1004 */ 18, 4, 4, 4, 14, 2, 0,
+  /* 1011 */ 21, 4, 4, 14, 2, 0,
+  /* 1017 */ 14, 2, 14, 2, 4, 4, 5, 14, 2, 0,
+  /* 1027 */ 40, 5, 5, 5, 5, 5, 5, 5, 5, 14, 2, 0,
+  /* 1039 */ 21, 5, 5, 14, 2, 0,
+  /* 1045 */ 21, 2, 9, 5, 9, 5, 14, 2, 0,
+  /* 1054 */ 0, 17, 17, 14, 2, 0,
+  /* 1060 */ 14, 2, 18, 14, 2, 0,
+  /* 1066 */ 42, 7, 15, 2, 0,
+  /* 1071 */ 16, 1, 16, 2, 16, 2, 0,
+  /* 1078 */ 16, 2, 16, 2, 16, 2, 16, 2, 0,
+  /* 1087 */ 13, 3, 16, 2, 16, 2, 0,
+  /* 1094 */ 11, 5, 16, 2, 16, 2, 0,
+  /* 1101 */ 17, 17, 17, 2, 0,
+  /* 1106 */ 0, 5, 4, 4, 4, 3, 3, 3, 3, 0,
+  /* 1116 */ 51, 3, 3, 0,
+  /* 1120 */ 21, 12, 2, 4, 11, 3, 11, 3, 0,
+  /* 1129 */ 21, 11, 3, 4, 11, 3, 11, 3, 0,
+  /* 1138 */ 21, 11, 3, 4, 11, 3, 0,
+  /* 1145 */ 16, 2, 13, 3, 13, 3, 0,
+  /* 1152 */ 5, 31, 3, 1, 15, 3, 0,
+  /* 1159 */ 42, 7, 31, 3, 1, 15, 3, 0,
+  /* 1167 */ 46, 7, 46, 7, 31, 3, 1, 15, 3, 0,
+  /* 1177 */ 43, 12, 1, 15, 3, 0,
+  /* 1183 */ 30, 7, 15, 3, 0,
+  /* 1188 */ 42, 7, 31, 3, 1, 42, 7, 15, 3, 0,
+  /* 1198 */ 42, 7, 42, 7, 15, 3, 0,
+  /* 1205 */ 44, 7, 44, 7, 15, 3, 0,
+  /* 1212 */ 15, 3, 15, 7, 15, 7, 31, 3, 1, 4, 0,
+  /* 1223 */ 9, 5, 9, 5, 14, 2, 10, 4, 9, 1, 4, 0,
+  /* 1235 */ 9, 8, 9, 8, 14, 2, 10, 4, 9, 1, 4, 0,
+  /* 1247 */ 10, 4, 10, 4, 14, 2, 9, 5, 9, 1, 4, 0,
+  /* 1259 */ 9, 5, 9, 5, 14, 2, 9, 5, 9, 1, 4, 0,
+  /* 1271 */ 10, 7, 10, 7, 14, 2, 9, 5, 9, 1, 4, 0,
+  /* 1283 */ 9, 8, 9, 8, 14, 2, 9, 5, 9, 1, 4, 0,
+  /* 1295 */ 10, 4, 10, 4, 14, 2, 10, 4, 10, 1, 4, 0,
+  /* 1307 */ 10, 5, 10, 5, 14, 2, 10, 4, 10, 1, 4, 0,
+  /* 1319 */ 10, 7, 10, 7, 14, 2, 10, 4, 10, 1, 4, 0,
+  /* 1331 */ 10, 8, 10, 8, 14, 2, 10, 4, 10, 1, 4, 0,
+  /* 1343 */ 10, 4, 10, 4, 14, 2, 10, 5, 10, 1, 4, 0,
+  /* 1355 */ 10, 5, 10, 5, 14, 2, 10, 5, 10, 1, 4, 0,
+  /* 1367 */ 10, 7, 10, 7, 14, 2, 10, 5, 10, 1, 4, 0,
+  /* 1379 */ 10, 8, 10, 8, 14, 2, 10, 5, 10, 1, 4, 0,
+  /* 1391 */ 11, 1, 11, 8, 11, 8, 4, 11, 1, 4, 0,
+  /* 1402 */ 11, 4, 11, 4, 14, 2, 11, 4, 11, 1, 4, 0,
+  /* 1414 */ 11, 5, 11, 5, 14, 2, 11, 4, 11, 1, 4, 0,
+  /* 1426 */ 11, 7, 11, 7, 14, 2, 11, 4, 11, 1, 4, 0,
+  /* 1438 */ 11, 8, 11, 8, 14, 2, 11, 4, 11, 1, 4, 0,
+  /* 1450 */ 11, 4, 11, 4, 14, 2, 11, 5, 11, 1, 4, 0,
+  /* 1462 */ 11, 5, 11, 5, 14, 2, 11, 5, 11, 1, 4, 0,
+  /* 1474 */ 11, 7, 11, 7, 14, 2, 11, 5, 11, 1, 4, 0,
+  /* 1486 */ 11, 8, 11, 8, 14, 2, 11, 5, 11, 1, 4, 0,
+  /* 1498 */ 12, 1, 12, 7, 12, 7, 4, 12, 1, 4, 0,
+  /* 1509 */ 12, 4, 12, 4, 14, 2, 12, 4, 12, 1, 4, 0,
+  /* 1521 */ 12, 7, 12, 7, 14, 2, 12, 4, 12, 1, 4, 0,
+  /* 1533 */ 18, 15, 1, 4, 0,
+  /* 1538 */ 12, 4, 12, 4, 16, 1, 4, 0,
+  /* 1546 */ 36, 1, 50, 8, 36, 1, 4, 0,
+  /* 1554 */ 50, 8, 4, 50, 8, 36, 1, 4, 0,
+  /* 1563 */ 50, 8, 50, 8, 50, 8, 36, 1, 4, 0,
+  /* 1573 */ 13, 4, 13, 4, 47, 1, 4, 0,
+  /* 1581 */ 0, 50, 8, 5, 14, 2, 50, 1, 4, 0,
+  /* 1591 */ 0, 50, 8, 50, 8, 5, 5, 50, 1, 4, 0,
+  /* 1602 */ 50, 1, 50, 8, 50, 1, 4, 0,
+  /* 1610 */ 50, 8, 5, 50, 8, 50, 1, 4, 0,
+  /* 1619 */ 50, 8, 50, 8, 50, 8, 50, 1, 4, 0,
+  /* 1629 */ 10, 7, 10, 7, 10, 7, 10, 4, 4, 2, 4, 0,
+  /* 1641 */ 9, 8, 9, 8, 9, 8, 9, 5, 4, 2, 4, 0,
+  /* 1653 */ 11, 8, 11, 8, 11, 8, 11, 5, 4, 2, 4, 0,
+  /* 1665 */ 10, 4, 10, 4, 14, 2, 10, 4, 2, 4, 0,
+  /* 1676 */ 9, 5, 9, 5, 14, 2, 10, 4, 2, 4, 0,
+  /* 1687 */ 10, 5, 10, 5, 14, 2, 10, 4, 2, 4, 0,
+  /* 1698 */ 10, 7, 10, 7, 14, 2, 10, 4, 2, 4, 0,
+  /* 1709 */ 9, 8, 9, 8, 14, 2, 10, 4, 2, 4, 0,
+  /* 1720 */ 10, 8, 10, 8, 14, 2, 10, 4, 2, 4, 0,
+  /* 1731 */ 11, 4, 11, 4, 14, 2, 11, 4, 2, 4, 0,
+  /* 1742 */ 11, 5, 11, 5, 14, 2, 11, 4, 2, 4, 0,
+  /* 1753 */ 11, 7, 11, 7, 14, 2, 11, 4, 2, 4, 0,
+  /* 1764 */ 11, 8, 11, 8, 14, 2, 11, 4, 2, 4, 0,
+  /* 1775 */ 10, 4, 10, 4, 14, 2, 9, 5, 2, 4, 0,
+  /* 1786 */ 9, 5, 9, 5, 14, 2, 9, 5, 2, 4, 0,
+  /* 1797 */ 10, 7, 10, 7, 14, 2, 9, 5, 2, 4, 0,
+  /* 1808 */ 9, 8, 9, 8, 14, 2, 9, 5, 2, 4, 0,
+  /* 1819 */ 10, 4, 10, 4, 14, 2, 10, 5, 2, 4, 0,
+  /* 1830 */ 10, 5, 10, 5, 14, 2, 10, 5, 2, 4, 0,
+  /* 1841 */ 10, 7, 10, 7, 14, 2, 10, 5, 2, 4, 0,
+  /* 1852 */ 10, 8, 10, 8, 14, 2, 10, 5, 2, 4, 0,
+  /* 1863 */ 11, 4, 11, 4, 14, 2, 11, 5, 2, 4, 0,
+  /* 1874 */ 11, 5, 11, 5, 14, 2, 11, 5, 2, 4, 0,
+  /* 1885 */ 11, 7, 11, 7, 14, 2, 11, 5, 2, 4, 0,
+  /* 1896 */ 11, 8, 11, 8, 14, 2, 11, 5, 2, 4, 0,
+  /* 1907 */ 10, 7, 10, 7, 10, 7, 4, 10, 7, 2, 4, 0,
+  /* 1919 */ 10, 7, 10, 7, 10, 7, 10, 7, 2, 4, 0,
+  /* 1930 */ 10, 7, 10, 7, 9, 8, 10, 7, 2, 4, 0,
+  /* 1941 */ 9, 8, 9, 8, 9, 8, 4, 9, 8, 2, 4, 0,
+  /* 1953 */ 9, 8, 9, 8, 10, 7, 9, 8, 2, 4, 0,
+  /* 1964 */ 9, 8, 9, 8, 9, 8, 9, 8, 2, 4, 0,
+  /* 1975 */ 11, 8, 11, 8, 11, 8, 4, 11, 8, 2, 4, 0,
+  /* 1987 */ 11, 8, 11, 8, 11, 8, 11, 8, 2, 4, 0,
+  /* 1998 */ 12, 2, 12, 2, 12, 2, 12, 2, 4, 0,
+  /* 2008 */ 21, 12, 2, 4, 12, 2, 12, 2, 12, 2, 4, 0,
+  /* 2020 */ 21, 12, 2, 4, 12, 2, 12, 2, 4, 0,
+  /* 2030 */ 12, 2, 9, 5, 9, 5, 12, 2, 4, 0,
+  /* 2040 */ 21, 4, 14, 2, 14, 2, 4, 0,
+  /* 2048 */ 21, 5, 14, 2, 14, 2, 4, 0,
+  /* 2056 */ 15, 1, 15, 7, 14, 2, 14, 2, 4, 0,
+  /* 2066 */ 0, 50, 8, 5, 14, 2, 4, 0,
+  /* 2074 */ 13, 3, 16, 2, 16, 2, 4, 0,
+  /* 2082 */ 12, 7, 12, 7, 12, 7, 12, 4, 4, 3, 4, 0,
+  /* 2094 */ 12, 4, 12, 4, 14, 2, 12, 4, 3, 4, 0,
+  /* 2105 */ 12, 7, 12, 7, 14, 2, 12, 4, 3, 4, 0,
+  /* 2116 */ 12, 7, 12, 7, 12, 7, 4, 12, 7, 3, 4, 0,
+  /* 2128 */ 12, 7, 12, 7, 12, 7, 12, 7, 3, 4, 0,
+  /* 2139 */ 11, 3, 11, 3, 11, 3, 11, 3, 4, 0,
+  /* 2149 */ 21, 11, 3, 4, 11, 3, 11, 3, 11, 3, 4, 0,
+  /* 2161 */ 21, 11, 3, 4, 11, 3, 11, 3, 4, 0,
+  /* 2171 */ 0, 31, 3, 1, 14, 2, 15, 3, 4, 0,
+  /* 2181 */ 44, 7, 44, 7, 15, 3, 4, 0,
+  /* 2189 */ 21, 3, 4, 0,
+  /* 2193 */ 0, 15, 3, 31, 3, 1, 33, 7, 31, 3, 4, 0,
+  /* 2205 */ 15, 0, 4, 15, 10, 11, 4, 10, 4, 1, 4, 4, 0,
+  /* 2218 */ 15, 0, 4, 4, 15, 10, 11, 4, 10, 4, 1, 4, 4, 0,
+  /* 2232 */ 15, 0, 4, 7, 15, 10, 11, 4, 10, 4, 1, 4, 4, 0,
+  /* 2246 */ 15, 0, 4, 4, 7, 15, 10, 11, 4, 10, 4, 1, 4, 4, 0,
+  /* 2261 */ 15, 0, 4, 15, 10, 15, 15, 11, 4, 10, 4, 1, 4, 4, 0,
+  /* 2276 */ 15, 0, 4, 4, 15, 10, 15, 15, 11, 4, 10, 4, 1, 4, 4, 0,
+  /* 2292 */ 15, 0, 4, 7, 15, 10, 15, 15, 11, 4, 10, 4, 1, 4, 4, 0,
+  /* 2308 */ 15, 0, 4, 4, 7, 15, 10, 15, 15, 11, 4, 10, 4, 1, 4, 4, 0,
+  /* 2325 */ 15, 0, 4, 15, 10, 15, 15, 15, 15, 11, 4, 10, 4, 1, 4, 4, 0,
+  /* 2342 */ 15, 0, 4, 4, 15, 10, 15, 15, 15, 15, 11, 4, 10, 4, 1, 4, 4, 0,
+  /* 2360 */ 15, 0, 4, 7, 15, 10, 15, 15, 15, 15, 11, 4, 10, 4, 1, 4, 4, 0,
+  /* 2378 */ 15, 0, 4, 4, 7, 15, 10, 15, 15, 15, 15, 11, 4, 10, 4, 1, 4, 4, 0,
+  /* 2397 */ 15, 0, 4, 15, 10, 15, 15, 15, 15, 15, 15, 11, 4, 10, 4, 1, 4, 4, 0,
+  /* 2416 */ 15, 0, 4, 4, 15, 10, 15, 15, 15, 15, 15, 15, 11, 4, 10, 4, 1, 4, 4, 0,
+  /* 2436 */ 15, 0, 4, 7, 15, 10, 15, 15, 15, 15, 15, 15, 11, 4, 10, 4, 1, 4, 4, 0,
+  /* 2456 */ 15, 0, 4, 4, 7, 15, 10, 15, 15, 15, 15, 15, 15, 11, 4, 10, 4, 1, 4, 4, 0,
+  /* 2477 */ 15, 0, 4, 15, 10, 7, 15, 18, 11, 4, 10, 4, 1, 4, 4, 0,
+  /* 2493 */ 15, 0, 4, 4, 15, 10, 7, 15, 18, 11, 4, 10, 4, 1, 4, 4, 0,
+  /* 2510 */ 15, 0, 4, 15, 10, 15, 18, 11, 4, 10, 4, 1, 4, 4, 0,
+  /* 2525 */ 15, 0, 4, 4, 15, 10, 15, 18, 11, 4, 10, 4, 1, 4, 4, 0,
+  /* 2541 */ 15, 0, 4, 15, 10, 15, 15, 15, 18, 11, 4, 10, 4, 1, 4, 4, 0,
+  /* 2558 */ 15, 0, 4, 4, 15, 10, 15, 15, 15, 18, 11, 4, 10, 4, 1, 4, 4, 0,
+  /* 2576 */ 15, 0, 4, 7, 15, 10, 15, 15, 15, 18, 11, 4, 10, 4, 1, 4, 4, 0,
+  /* 2594 */ 15, 0, 4, 4, 7, 15, 10, 15, 15, 15, 18, 11, 4, 10, 4, 1, 4, 4, 0,
+  /* 2613 */ 15, 0, 4, 15, 10, 7, 15, 18, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
+  /* 2631 */ 15, 0, 4, 4, 15, 10, 7, 15, 18, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
+  /* 2650 */ 15, 0, 4, 15, 10, 15, 18, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
+  /* 2667 */ 15, 0, 4, 4, 15, 10, 15, 18, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
+  /* 2685 */ 15, 0, 4, 15, 10, 15, 15, 15, 18, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
+  /* 2704 */ 15, 0, 4, 4, 15, 10, 15, 15, 15, 18, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
+  /* 2724 */ 15, 0, 4, 7, 15, 10, 15, 15, 15, 18, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
+  /* 2744 */ 15, 0, 4, 4, 7, 15, 10, 15, 15, 15, 18, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
+  /* 2765 */ 15, 0, 4, 15, 10, 15, 15, 15, 15, 15, 15, 15, 18, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
+  /* 2788 */ 15, 0, 4, 4, 15, 10, 15, 15, 15, 15, 15, 15, 15, 18, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
+  /* 2812 */ 15, 0, 4, 7, 15, 10, 15, 15, 15, 15, 15, 15, 15, 18, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
+  /* 2836 */ 15, 0, 4, 4, 7, 15, 10, 15, 15, 15, 15, 15, 15, 15, 18, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
+  /* 2861 */ 15, 0, 4, 15, 10, 7, 15, 18, 15, 23, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
+  /* 2881 */ 15, 0, 4, 4, 15, 10, 7, 15, 18, 15, 23, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
+  /* 2902 */ 15, 0, 4, 15, 10, 15, 18, 15, 23, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
+  /* 2921 */ 15, 0, 4, 4, 15, 10, 15, 18, 15, 23, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
+  /* 2941 */ 15, 0, 4, 15, 10, 15, 15, 15, 18, 15, 23, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
+  /* 2962 */ 15, 0, 4, 4, 15, 10, 15, 15, 15, 18, 15, 23, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
+  /* 2984 */ 15, 0, 4, 7, 15, 10, 15, 15, 15, 18, 15, 23, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
+  /* 3006 */ 15, 0, 4, 4, 7, 15, 10, 15, 15, 15, 18, 15, 23, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
+  /* 3029 */ 15, 0, 4, 15, 10, 15, 15, 15, 15, 15, 15, 15, 18, 15, 23, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
+  /* 3054 */ 15, 0, 4, 4, 15, 10, 15, 15, 15, 15, 15, 15, 15, 18, 15, 23, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
+  /* 3080 */ 15, 0, 4, 7, 15, 10, 15, 15, 15, 15, 15, 15, 15, 18, 15, 23, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
+  /* 3106 */ 15, 0, 4, 4, 7, 15, 10, 15, 15, 15, 15, 15, 15, 15, 18, 15, 23, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
+  /* 3133 */ 15, 0, 4, 15, 10, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 18, 15, 23, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
+  /* 3162 */ 15, 0, 4, 4, 15, 10, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 18, 15, 23, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
+  /* 3192 */ 15, 0, 4, 7, 15, 10, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 18, 15, 23, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
+  /* 3222 */ 15, 0, 4, 4, 7, 15, 10, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 18, 15, 23, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
+  /* 3253 */ 15, 0, 4, 15, 10, 7, 15, 18, 15, 23, 15, 23, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
+  /* 3275 */ 15, 0, 4, 4, 15, 10, 7, 15, 18, 15, 23, 15, 23, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
+  /* 3298 */ 15, 0, 4, 15, 10, 15, 18, 15, 23, 15, 23, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
+  /* 3319 */ 15, 0, 4, 4, 15, 10, 15, 18, 15, 23, 15, 23, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
+  /* 3341 */ 15, 0, 4, 15, 10, 15, 15, 15, 15, 15, 15, 15, 18, 15, 23, 15, 23, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
+  /* 3368 */ 15, 0, 4, 4, 15, 10, 15, 15, 15, 15, 15, 15, 15, 18, 15, 23, 15, 23, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
+  /* 3396 */ 15, 0, 4, 7, 15, 10, 15, 15, 15, 15, 15, 15, 15, 18, 15, 23, 15, 23, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
+  /* 3424 */ 15, 0, 4, 4, 7, 15, 10, 15, 15, 15, 15, 15, 15, 15, 18, 15, 23, 15, 23, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
+  /* 3453 */ 15, 0, 4, 15, 10, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 18, 15, 23, 15, 23, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
+  /* 3484 */ 15, 0, 4, 4, 15, 10, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 18, 15, 23, 15, 23, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
+  /* 3516 */ 15, 0, 4, 7, 15, 10, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 18, 15, 23, 15, 23, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
+  /* 3548 */ 15, 0, 4, 4, 7, 15, 10, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 18, 15, 23, 15, 23, 15, 23, 11, 4, 10, 4, 1, 4, 4, 0,
+  /* 3581 */ 21, 4, 1, 4, 4, 0,
+  /* 3587 */ 0, 15, 3, 33, 7, 5, 1, 4, 4, 0,
+  /* 3597 */ 21, 2, 4, 2, 4, 4, 0,
+  /* 3604 */ 10, 7, 10, 7, 10, 7, 10, 7, 2, 4, 4, 0,
+  /* 3616 */ 9, 8, 9, 8, 9, 8, 9, 8, 2, 4, 4, 0,
+  /* 3628 */ 36, 1, 36, 1, 50, 1, 12, 2, 4, 4, 0,
+  /* 3639 */ 36, 1, 36, 1, 12, 2, 12, 2, 4, 4, 0,
+  /* 3650 */ 21, 4, 1, 4, 4, 4, 0,
+  /* 3657 */ 36, 1, 36, 1, 12, 2, 12, 2, 4, 4, 4, 0,
+  /* 3669 */ 21, 15, 3, 4, 4, 4, 0,
+  /* 3676 */ 21, 4, 1, 4, 4, 4, 4, 0,
+  /* 3684 */ 21, 15, 3, 4, 4, 4, 4, 0,
+  /* 3692 */ 12, 2, 12, 2, 12, 2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0,
+  /* 3715 */ 40, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0,
+  /* 3738 */ 40, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0,
+  /* 3760 */ 10, 4, 10, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0,
+  /* 3774 */ 0, 15, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0,
+  /* 3787 */ 10, 7, 10, 7, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0,
+  /* 3801 */ 0, 15, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0,
+  /* 3813 */ 21, 4, 4, 4, 4, 4, 4, 4, 4, 0,
+  /* 3823 */ 0, 5, 4, 4, 4, 4, 4, 4, 4, 0,
+  /* 3833 */ 21, 4, 4, 4, 4, 4, 4, 4, 0,
+  /* 3842 */ 0, 15, 0, 10, 4, 4, 4, 4, 4, 4, 0,
+  /* 3853 */ 15, 3, 15, 7, 15, 11, 4, 4, 4, 4, 4, 4, 0,
+  /* 3866 */ 21, 4, 4, 4, 4, 4, 4, 0,
+  /* 3874 */ 0, 15, 0, 10, 4, 4, 4, 4, 4, 0,
+  /* 3884 */ 15, 0, 15, 7, 10, 4, 4, 4, 4, 4, 0,
+  /* 3895 */ 15, 2, 15, 7, 10, 4, 4, 4, 4, 4, 0,
+  /* 3906 */ 15, 1, 15, 7, 15, 7, 10, 4, 4, 4, 4, 4, 0,
+  /* 3919 */ 21, 4, 4, 4, 4, 4, 0,
+  /* 3926 */ 10, 4, 4, 4, 10, 4, 4, 4, 4, 0,
+  /* 3936 */ 15, 0, 15, 7, 10, 4, 4, 4, 4, 0,
+  /* 3946 */ 15, 2, 15, 7, 10, 4, 4, 4, 4, 0,
+  /* 3956 */ 15, 1, 15, 7, 15, 7, 10, 4, 4, 4, 4, 0,
+  /* 3968 */ 12, 4, 4, 4, 12, 4, 4, 4, 4, 0,
+  /* 3978 */ 13, 4, 4, 4, 13, 4, 4, 4, 4, 0,
+  /* 3988 */ 21, 4, 4, 4, 4, 0,
+  /* 3994 */ 23, 3, 3, 3, 3, 5, 4, 4, 4, 0,
+  /* 4004 */ 21, 3, 3, 5, 4, 4, 4, 0,
+  /* 4012 */ 23, 4, 4, 4, 4, 5, 4, 4, 4, 0,
+  /* 4022 */ 21, 4, 4, 5, 4, 4, 4, 0,
+  /* 4030 */ 23, 4, 4, 4, 4, 5, 5, 4, 4, 4, 0,
+  /* 4041 */ 21, 5, 5, 5, 4, 4, 4, 0,
+  /* 4049 */ 23, 7, 7, 7, 7, 5, 5, 4, 4, 4, 0,
+  /* 4060 */ 23, 7, 7, 7, 7, 5, 4, 4, 4, 0,
+  /* 4070 */ 10, 7, 9, 3, 9, 3, 10, 7, 4, 4, 4, 0,
+  /* 4082 */ 10, 7, 10, 6, 10, 6, 10, 7, 4, 4, 4, 0,
+  /* 4094 */ 10, 7, 7, 7, 10, 7, 4, 4, 4, 0,
+  /* 4104 */ 12, 7, 9, 3, 9, 3, 12, 7, 4, 4, 4, 0,
+  /* 4116 */ 12, 7, 10, 6, 10, 6, 12, 7, 4, 4, 4, 0,
+  /* 4128 */ 12, 7, 7, 7, 12, 7, 4, 4, 4, 0,
+  /* 4138 */ 13, 7, 9, 3, 9, 3, 13, 7, 4, 4, 4, 0,
+  /* 4150 */ 13, 7, 10, 6, 10, 6, 13, 7, 4, 4, 4, 0,
+  /* 4162 */ 13, 7, 7, 7, 13, 7, 4, 4, 4, 0,
+  /* 4172 */ 15, 3, 15, 7, 15, 7, 15, 7, 4, 4, 4, 0,
+  /* 4184 */ 15, 0, 4, 15, 9, 11, 4, 4, 4, 0,
+  /* 4194 */ 0, 15, 2, 4, 15, 9, 11, 4, 4, 4, 0,
+  /* 4205 */ 15, 1, 15, 7, 15, 9, 11, 4, 4, 4, 0,
+  /* 4216 */ 15, 1, 15, 7, 15, 7, 15, 9, 11, 4, 4, 4, 0,
+  /* 4229 */ 15, 3, 15, 7, 15, 11, 4, 4, 4, 0,
+  /* 4239 */ 15, 0, 4, 15, 9, 15, 15, 11, 4, 4, 4, 0,
+  /* 4251 */ 0, 15, 2, 4, 15, 9, 15, 15, 11, 4, 4, 4, 0,
+  /* 4264 */ 15, 1, 15, 7, 15, 9, 15, 15, 11, 4, 4, 4, 0,
+  /* 4277 */ 15, 1, 15, 7, 15, 7, 15, 9, 15, 15, 11, 4, 4, 4, 0,
+  /* 4292 */ 15, 0, 4, 15, 9, 15, 15, 15, 15, 11, 4, 4, 4, 0,
+  /* 4306 */ 0, 15, 2, 4, 15, 9, 15, 15, 15, 15, 11, 4, 4, 4, 0,
+  /* 4321 */ 15, 1, 15, 7, 15, 9, 15, 15, 15, 15, 11, 4, 4, 4, 0,
+  /* 4336 */ 15, 1, 15, 7, 15, 7, 15, 9, 15, 15, 15, 15, 11, 4, 4, 4, 0,
+  /* 4353 */ 15, 0, 4, 15, 9, 15, 15, 15, 15, 15, 15, 11, 4, 4, 4, 0,
+  /* 4369 */ 0, 15, 2, 4, 15, 9, 15, 15, 15, 15, 15, 15, 11, 4, 4, 4, 0,
+  /* 4386 */ 15, 1, 15, 7, 15, 9, 15, 15, 15, 15, 15, 15, 11, 4, 4, 4, 0,
+  /* 4403 */ 15, 1, 15, 7, 15, 7, 15, 9, 15, 15, 15, 15, 15, 15, 11, 4, 4, 4, 0,
+  /* 4422 */ 16, 4, 16, 4, 16, 4, 4, 4, 0,
+  /* 4431 */ 15, 3, 15, 11, 15, 19, 4, 4, 4, 0,
+  /* 4441 */ 15, 3, 15, 12, 15, 19, 4, 4, 4, 0,
+  /* 4451 */ 23, 3, 3, 3, 3, 5, 4, 4, 0,
+  /* 4460 */ 21, 3, 3, 5, 4, 4, 0,
+  /* 4467 */ 23, 4, 4, 4, 4, 5, 4, 4, 0,
+  /* 4476 */ 21, 4, 4, 5, 4, 4, 0,
+  /* 4483 */ 23, 4, 4, 4, 4, 5, 5, 4, 4, 0,
+  /* 4493 */ 21, 5, 5, 5, 4, 4, 0,
+  /* 4500 */ 23, 7, 7, 7, 7, 5, 5, 4, 4, 0,
+  /* 4510 */ 23, 7, 7, 7, 7, 5, 4, 4, 0,
+  /* 4519 */ 21, 7, 1, 7, 4, 4, 0,
+  /* 4526 */ 21, 7, 1, 4, 7, 4, 4, 0,
+  /* 4534 */ 21, 4, 15, 3, 15, 7, 4, 4, 0,
+  /* 4543 */ 15, 3, 15, 7, 15, 7, 15, 7, 4, 4, 0,
+  /* 4554 */ 23, 15, 3, 15, 7, 15, 7, 15, 7, 15, 12, 15, 7, 15, 7, 15, 7, 15, 7, 4, 4, 0,
+  /* 4576 */ 22, 15, 3, 15, 7, 15, 7, 15, 12, 15, 7, 15, 7, 15, 7, 4, 4, 0,
+  /* 4594 */ 21, 15, 3, 15, 7, 15, 12, 15, 7, 15, 7, 4, 4, 0,
+  /* 4608 */ 15, 3, 15, 7, 45, 7, 45, 7, 4, 4, 0,
+  /* 4619 */ 50, 8, 50, 8, 4, 4, 0,
+  /* 4626 */ 0, 14, 2, 10, 1, 10, 4, 10, 4, 4, 0,
+  /* 4637 */ 0, 14, 2, 2, 10, 4, 10, 4, 4, 0,
+  /* 4647 */ 21, 10, 4, 4, 10, 4, 10, 4, 4, 0,
+  /* 4657 */ 21, 10, 4, 4, 10, 4, 10, 4, 10, 4, 4, 0,
+  /* 4669 */ 10, 4, 10, 4, 10, 4, 10, 4, 4, 0,
+  /* 4679 */ 0, 14, 2, 9, 1, 9, 5, 10, 4, 4, 0,
+  /* 4690 */ 0, 14, 2, 2, 9, 5, 10, 4, 4, 0,
+  /* 4700 */ 0, 14, 2, 10, 1, 10, 5, 10, 4, 4, 0,
+  /* 4711 */ 0, 14, 2, 2, 10, 5, 10, 4, 4, 0,
+  /* 4721 */ 0, 14, 2, 11, 1, 11, 4, 11, 4, 4, 0,
+  /* 4732 */ 0, 14, 2, 2, 11, 4, 11, 4, 4, 0,
+  /* 4742 */ 11, 4, 11, 4, 11, 4, 11, 4, 4, 0,
+  /* 4752 */ 0, 14, 2, 11, 1, 11, 5, 11, 4, 4, 0,
+  /* 4763 */ 0, 14, 2, 2, 11, 5, 11, 4, 4, 0,
+  /* 4773 */ 16, 1, 16, 1, 12, 4, 4, 0,
+  /* 4781 */ 0, 14, 2, 12, 1, 12, 4, 12, 4, 4, 0,
+  /* 4792 */ 0, 14, 2, 3, 12, 4, 12, 4, 4, 0,
+  /* 4802 */ 12, 4, 12, 4, 12, 4, 12, 4, 4, 0,
+  /* 4812 */ 13, 4, 13, 4, 12, 4, 12, 4, 4, 0,
+  /* 4822 */ 47, 1, 47, 1, 13, 4, 4, 0,
+  /* 4830 */ 13, 4, 13, 4, 13, 4, 13, 4, 4, 0,
+  /* 4840 */ 16, 4, 16, 4, 13, 4, 13, 4, 4, 0,
+  /* 4850 */ 16, 4, 16, 4, 13, 4, 4, 0,
+  /* 4858 */ 40, 4, 4, 4, 4, 4, 4, 4, 4, 15, 4, 4, 0,
+  /* 4871 */ 23, 4, 4, 4, 4, 15, 4, 4, 0,
+  /* 4880 */ 21, 4, 4, 15, 4, 4, 0,
+  /* 4887 */ 40, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 15, 4, 4, 0,
+  /* 4908 */ 23, 9, 6, 9, 6, 9, 6, 9, 6, 15, 4, 4, 0,
+  /* 4921 */ 40, 7, 7, 7, 7, 7, 7, 7, 7, 15, 4, 4, 0,
+  /* 4934 */ 0, 15, 4, 15, 11, 15, 15, 4, 4, 0,
+  /* 4944 */ 0, 15, 4, 15, 11, 15, 15, 15, 15, 4, 4, 0,
+  /* 4956 */ 0, 15, 4, 15, 11, 15, 15, 15, 15, 15, 15, 4, 4, 0,
+  /* 4970 */ 13, 4, 13, 4, 16, 4, 4, 0,
+  /* 4978 */ 16, 4, 16, 4, 16, 4, 4, 0,
+  /* 4986 */ 17, 17, 4, 4, 0,
+  /* 4991 */ 15, 0, 18, 4, 4, 0,
+  /* 4997 */ 0, 15, 4, 15, 11, 15, 19, 4, 4, 0,
+  /* 5007 */ 21, 4, 4, 0,
+  /* 5011 */ 23, 3, 3, 3, 3, 5, 4, 0,
+  /* 5019 */ 21, 3, 3, 5, 4, 0,
+  /* 5025 */ 0, 31, 3, 1, 15, 3, 5, 4, 0,
+  /* 5034 */ 23, 4, 4, 4, 4, 5, 4, 0,
+  /* 5042 */ 21, 4, 4, 5, 4, 0,
+  /* 5048 */ 23, 4, 4, 4, 4, 5, 5, 4, 0,
+  /* 5057 */ 21, 5, 5, 5, 4, 0,
+  /* 5063 */ 23, 7, 7, 7, 7, 5, 5, 4, 0,
+  /* 5072 */ 0, 50, 8, 50, 8, 5, 5, 4, 0,
+  /* 5081 */ 23, 7, 7, 7, 7, 5, 4, 0,
+  /* 5089 */ 50, 8, 50, 8, 50, 8, 5, 4, 0,
+  /* 5098 */ 0, 14, 2, 9, 1, 10, 4, 9, 5, 4, 0,
+  /* 5109 */ 0, 14, 2, 2, 10, 4, 9, 5, 4, 0,
+  /* 5119 */ 0, 14, 2, 9, 1, 9, 5, 9, 5, 4, 0,
+  /* 5130 */ 0, 14, 2, 2, 9, 5, 9, 5, 4, 0,
+  /* 5140 */ 9, 5, 9, 5, 9, 5, 9, 5, 4, 0,
+  /* 5150 */ 0, 14, 2, 10, 1, 10, 4, 10, 5, 4, 0,
+  /* 5161 */ 0, 14, 2, 2, 10, 4, 10, 5, 4, 0,
+  /* 5171 */ 0, 14, 2, 10, 1, 10, 5, 10, 5, 4, 0,
+  /* 5182 */ 0, 14, 2, 2, 10, 5, 10, 5, 4, 0,
+  /* 5192 */ 10, 5, 10, 5, 10, 5, 10, 5, 4, 0,
+  /* 5202 */ 0, 14, 2, 11, 1, 11, 4, 11, 5, 4, 0,
+  /* 5213 */ 0, 14, 2, 2, 11, 4, 11, 5, 4, 0,
+  /* 5223 */ 0, 14, 2, 11, 1, 11, 5, 11, 5, 4, 0,
+  /* 5234 */ 0, 14, 2, 2, 11, 5, 11, 5, 4, 0,
+  /* 5244 */ 11, 5, 11, 5, 11, 5, 11, 5, 4, 0,
+  /* 5254 */ 21, 5, 4, 0,
+  /* 5258 */ 0, 15, 4, 9, 6, 9, 6, 9, 6, 9, 6, 4, 0,
+  /* 5271 */ 0, 15, 4, 7, 7, 7, 7, 7, 7, 7, 7, 4, 0,
+  /* 5284 */ 50, 8, 7, 4, 0,
+  /* 5289 */ 21, 10, 4, 4, 10, 7, 4, 0,
+  /* 5297 */ 0, 14, 2, 10, 1, 10, 4, 10, 7, 4, 0,
+  /* 5308 */ 0, 14, 2, 2, 10, 4, 10, 7, 4, 0,
+  /* 5318 */ 0, 14, 2, 9, 1, 9, 5, 10, 7, 4, 0,
+  /* 5329 */ 0, 14, 2, 2, 9, 5, 10, 7, 4, 0,
+  /* 5339 */ 0, 14, 2, 10, 1, 10, 5, 10, 7, 4, 0,
+  /* 5350 */ 0, 14, 2, 2, 10, 5, 10, 7, 4, 0,
+  /* 5360 */ 0, 14, 2, 11, 1, 11, 4, 11, 7, 4, 0,
+  /* 5371 */ 0, 14, 2, 2, 11, 4, 11, 7, 4, 0,
+  /* 5381 */ 0, 14, 2, 11, 1, 11, 5, 11, 7, 4, 0,
+  /* 5392 */ 0, 14, 2, 2, 11, 5, 11, 7, 4, 0,
+  /* 5402 */ 0, 14, 2, 12, 1, 12, 4, 12, 7, 4, 0,
+  /* 5413 */ 0, 14, 2, 3, 12, 4, 12, 7, 4, 0,
+  /* 5423 */ 12, 7, 12, 7, 12, 7, 12, 7, 4, 0,
+  /* 5433 */ 15, 3, 31, 3, 1, 15, 7, 4, 0,
+  /* 5442 */ 15, 3, 31, 3, 1, 15, 7, 15, 7, 4, 0,
+  /* 5453 */ 21, 15, 3, 4, 15, 7, 15, 7, 4, 0,
+  /* 5463 */ 15, 3, 31, 3, 1, 15, 7, 15, 7, 15, 7, 4, 0,
+  /* 5476 */ 15, 3, 15, 7, 15, 7, 15, 7, 4, 0,
+  /* 5486 */ 15, 2, 4, 15, 7, 15, 7, 15, 7, 4, 0,
+  /* 5497 */ 15, 1, 25, 7, 4, 0,
+  /* 5503 */ 15, 3, 26, 7, 4, 0,
+  /* 5509 */ 15, 3, 44, 7, 4, 0,
+  /* 5515 */ 15, 3, 44, 7, 44, 7, 4, 0,
+  /* 5523 */ 15, 3, 15, 7, 44, 7, 44, 7, 4, 0,
+  /* 5533 */ 15, 3, 15, 7, 45, 7, 45, 7, 4, 0,
+  /* 5543 */ 50, 8, 8, 4, 0,
+  /* 5548 */ 21, 9, 5, 4, 9, 8, 4, 0,
+  /* 5556 */ 0, 14, 2, 9, 1, 10, 4, 9, 8, 4, 0,
+  /* 5567 */ 0, 14, 2, 2, 10, 4, 9, 8, 4, 0,
+  /* 5577 */ 0, 14, 2, 9, 1, 9, 5, 9, 8, 4, 0,
+  /* 5588 */ 0, 14, 2, 2, 9, 5, 9, 8, 4, 0,
+  /* 5598 */ 0, 14, 2, 10, 1, 10, 4, 10, 8, 4, 0,
+  /* 5609 */ 0, 14, 2, 2, 10, 4, 10, 8, 4, 0,
+  /* 5619 */ 0, 14, 2, 10, 1, 10, 5, 10, 8, 4, 0,
+  /* 5630 */ 0, 14, 2, 2, 10, 5, 10, 8, 4, 0,
+  /* 5640 */ 0, 14, 2, 11, 1, 11, 4, 11, 8, 4, 0,
+  /* 5651 */ 0, 14, 2, 2, 11, 4, 11, 8, 4, 0,
+  /* 5661 */ 0, 14, 2, 11, 1, 11, 5, 11, 8, 4, 0,
+  /* 5672 */ 0, 14, 2, 2, 11, 5, 11, 8, 4, 0,
+  /* 5682 */ 11, 8, 11, 8, 11, 8, 11, 8, 4, 0,
+  /* 5692 */ 50, 8, 50, 8, 5, 36, 1, 50, 8, 4, 0,
+  /* 5703 */ 50, 8, 4, 50, 8, 36, 1, 50, 8, 4, 0,
+  /* 5714 */ 50, 8, 50, 8, 5, 50, 8, 36, 1, 50, 8, 4, 0,
+  /* 5727 */ 50, 8, 5, 50, 8, 50, 8, 36, 1, 50, 8, 4, 0,
+  /* 5740 */ 50, 8, 50, 8, 50, 8, 50, 8, 36, 1, 50, 8, 4, 0,
+  /* 5754 */ 50, 8, 50, 8, 4, 50, 1, 50, 8, 4, 0,
+  /* 5765 */ 50, 8, 50, 8, 5, 5, 50, 1, 50, 8, 4, 0,
+  /* 5777 */ 50, 8, 50, 8, 5, 50, 1, 50, 8, 4, 0,
+  /* 5788 */ 50, 8, 7, 50, 1, 50, 8, 4, 0,
+  /* 5797 */ 50, 8, 8, 50, 1, 50, 8, 4, 0,
+  /* 5806 */ 50, 8, 4, 50, 8, 50, 1, 50, 8, 4, 0,
+  /* 5817 */ 50, 8, 5, 50, 8, 50, 1, 50, 8, 4, 0,
+  /* 5828 */ 50, 8, 50, 8, 7, 50, 8, 50, 1, 50, 8, 4, 0,
+  /* 5841 */ 50, 8, 50, 8, 8, 50, 8, 50, 1, 50, 8, 4, 0,
+  /* 5854 */ 50, 8, 7, 50, 8, 50, 8, 50, 1, 50, 8, 4, 0,
+  /* 5867 */ 50, 8, 8, 50, 8, 50, 8, 50, 1, 50, 8, 4, 0,
+  /* 5880 */ 50, 8, 50, 8, 50, 8, 50, 8, 50, 1, 50, 8, 4, 0,
+  /* 5894 */ 50, 8, 5, 14, 2, 50, 8, 4, 0,
+  /* 5903 */ 50, 8, 50, 8, 4, 50, 8, 4, 0,
+  /* 5912 */ 50, 8, 50, 8, 5, 5, 50, 8, 4, 0,
+  /* 5922 */ 50, 8, 50, 8, 50, 8, 5, 50, 8, 4, 0,
+  /* 5933 */ 50, 8, 50, 8, 7, 50, 8, 4, 0,
+  /* 5942 */ 50, 8, 50, 8, 8, 50, 8, 4, 0,
+  /* 5951 */ 50, 8, 4, 50, 8, 50, 8, 4, 0,
+  /* 5960 */ 50, 8, 50, 8, 5, 50, 8, 50, 8, 4, 0,
+  /* 5971 */ 50, 8, 50, 8, 7, 50, 8, 50, 8, 4, 0,
+  /* 5982 */ 50, 8, 50, 8, 8, 50, 8, 50, 8, 4, 0,
+  /* 5993 */ 50, 8, 5, 50, 8, 50, 8, 50, 8, 4, 0,
+  /* 6004 */ 50, 8, 7, 50, 8, 50, 8, 50, 8, 4, 0,
+  /* 6015 */ 50, 8, 8, 50, 8, 50, 8, 50, 8, 4, 0,
+  /* 6026 */ 50, 8, 50, 8, 50, 8, 50, 8, 50, 8, 4, 0,
+  /* 6038 */ 21, 10, 4, 4, 10, 4, 0,
+  /* 6045 */ 21, 10, 1, 10, 1, 10, 4, 10, 4, 0,
+  /* 6055 */ 21, 11, 3, 4, 10, 4, 10, 4, 0,
+  /* 6064 */ 21, 10, 4, 4, 10, 4, 10, 4, 0,
+  /* 6073 */ 10, 4, 15, 1, 7, 10, 7, 15, 11, 15, 15, 10, 4, 0,
+  /* 6087 */ 43, 9, 8, 43, 9, 8, 43, 9, 1, 43, 10, 4, 0,
+  /* 6100 */ 43, 11, 6, 43, 11, 6, 43, 10, 1, 43, 10, 4, 0,
+  /* 6113 */ 43, 10, 4, 43, 10, 4, 43, 10, 4, 0,
+  /* 6123 */ 21, 11, 1, 11, 1, 11, 4, 11, 4, 0,
+  /* 6133 */ 12, 4, 16, 1, 12, 4, 0,
+  /* 6140 */ 0, 16, 1, 14, 2, 12, 4, 0,
+  /* 6148 */ 0, 14, 2, 16, 1, 4, 4, 12, 4, 0,
+  /* 6158 */ 21, 12, 1, 12, 1, 12, 4, 12, 4, 0,
+  /* 6168 */ 16, 1, 16, 1, 12, 4, 12, 4, 0,
+  /* 6177 */ 12, 4, 16, 1, 12, 4, 12, 4, 0,
+  /* 6186 */ 13, 4, 16, 1, 12, 4, 12, 4, 0,
+  /* 6195 */ 0, 16, 1, 4, 4, 12, 4, 12, 4, 0,
+  /* 6205 */ 0, 16, 1, 4, 4, 13, 4, 12, 4, 0,
+  /* 6215 */ 21, 15, 3, 15, 7, 15, 12, 4, 0,
+  /* 6224 */ 22, 15, 3, 15, 7, 15, 7, 15, 12, 4, 0,
+  /* 6235 */ 23, 15, 3, 15, 7, 15, 7, 15, 7, 15, 12, 4, 0,
+  /* 6248 */ 13, 4, 47, 1, 13, 4, 0,
+  /* 6255 */ 0, 47, 1, 14, 2, 13, 4, 0,
+  /* 6263 */ 0, 14, 2, 16, 1, 4, 4, 13, 4, 0,
+  /* 6273 */ 0, 14, 2, 47, 1, 4, 4, 13, 4, 0,
+  /* 6283 */ 47, 1, 47, 1, 13, 4, 13, 4, 0,
+  /* 6292 */ 13, 4, 47, 1, 13, 4, 13, 4, 0,
+  /* 6301 */ 16, 4, 47, 1, 13, 4, 13, 4, 0,
+  /* 6310 */ 0, 47, 1, 4, 4, 13, 4, 13, 4, 0,
+  /* 6320 */ 16, 4, 16, 4, 13, 4, 13, 4, 0,
+  /* 6329 */ 0, 4, 4, 16, 4, 13, 4, 0,
+  /* 6337 */ 0, 47, 1, 4, 4, 16, 4, 13, 4, 0,
+  /* 6347 */ 16, 4, 16, 4, 13, 4, 0,
+  /* 6354 */ 40, 4, 4, 4, 4, 4, 4, 4, 4, 15, 4, 0,
+  /* 6366 */ 23, 4, 4, 4, 4, 15, 4, 0,
+  /* 6374 */ 21, 4, 4, 15, 4, 0,
+  /* 6380 */ 0, 14, 20, 5, 15, 4, 0,
+  /* 6387 */ 40, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 15, 4, 0,
+  /* 6407 */ 23, 9, 6, 9, 6, 9, 6, 9, 6, 15, 4, 0,
+  /* 6419 */ 40, 7, 7, 7, 7, 7, 7, 7, 7, 15, 4, 0,
+  /* 6431 */ 21, 15, 3, 15, 11, 15, 15, 4, 0,
+  /* 6440 */ 0, 15, 4, 15, 11, 15, 15, 15, 15, 4, 0,
+  /* 6451 */ 0, 15, 4, 15, 11, 15, 15, 15, 15, 15, 15, 4, 0,
+  /* 6464 */ 5, 19, 15, 4, 0,
+  /* 6469 */ 0, 14, 2, 47, 1, 4, 4, 16, 4, 0,
+  /* 6479 */ 0, 14, 2, 4, 4, 16, 4, 0,
+  /* 6487 */ 13, 4, 16, 4, 0,
+  /* 6492 */ 16, 4, 16, 4, 16, 4, 0,
+  /* 6499 */ 4, 17, 4, 0,
+  /* 6503 */ 0, 15, 4, 15, 12, 15, 17, 4, 0,
+  /* 6512 */ 17, 17, 4, 0,
+  /* 6516 */ 0, 18, 4, 0,
+  /* 6520 */ 14, 2, 18, 4, 0,
+  /* 6525 */ 5, 28, 35, 4, 0,
+  /* 6530 */ 5, 36, 1, 5, 0,
+  /* 6535 */ 5, 50, 1, 5, 0,
+  /* 6540 */ 51, 3, 3, 14, 2, 5, 0,
+  /* 6547 */ 0, 15, 3, 31, 3, 1, 33, 7, 31, 3, 5, 0,
+  /* 6559 */ 21, 5, 1, 4, 5, 0,
+  /* 6565 */ 50, 8, 50, 8, 4, 5, 0,
+  /* 6572 */ 16, 4, 16, 4, 13, 4, 5, 0,
+  /* 6580 */ 36, 1, 36, 1, 5, 5, 0,
+  /* 6587 */ 50, 1, 50, 1, 5, 5, 0,
+  /* 6594 */ 21, 2, 5, 2, 5, 5, 0,
+  /* 6601 */ 0, 14, 2, 5, 5, 5, 5, 5, 5, 5, 5, 0,
+  /* 6613 */ 5, 14, 2, 5, 5, 5, 5, 5, 5, 5, 5, 0,
+  /* 6625 */ 39, 4, 9, 5, 9, 5, 9, 5, 9, 5, 9, 5, 9, 5, 4, 9, 5, 0,
+  /* 6643 */ 21, 9, 1, 9, 1, 9, 5, 9, 5, 0,
+  /* 6653 */ 21, 10, 4, 4, 9, 5, 9, 5, 0,
+  /* 6662 */ 40, 4, 9, 5, 9, 5, 9, 5, 9, 5, 9, 5, 9, 5, 9, 5, 4, 9, 5, 9, 5, 0,
+  /* 6684 */ 21, 9, 5, 4, 9, 5, 9, 5, 0,
+  /* 6693 */ 49, 2, 9, 5, 9, 5, 9, 5, 9, 5, 9, 5, 9, 5, 9, 5, 9, 5, 14, 2, 9, 5, 9, 5, 9, 5, 9, 5, 9, 5, 9, 5, 9, 5, 9, 5, 0,
+  /* 6730 */ 28, 35, 9, 5, 9, 5, 0,
+  /* 6737 */ 28, 35, 9, 5, 0,
+  /* 6742 */ 43, 11, 6, 43, 11, 6, 43, 9, 1, 43, 9, 5, 0,
+  /* 6755 */ 43, 10, 7, 43, 10, 7, 43, 9, 1, 43, 9, 5, 0,
+  /* 6768 */ 31, 3, 1, 31, 3, 1, 15, 3, 43, 9, 5, 0,
+  /* 6780 */ 43, 9, 5, 43, 9, 5, 43, 9, 5, 0,
+  /* 6790 */ 15, 3, 31, 3, 1, 15, 7, 43, 9, 5, 0,
+  /* 6801 */ 21, 10, 1, 10, 1, 10, 5, 10, 5, 0,
+  /* 6811 */ 21, 11, 1, 11, 1, 11, 5, 11, 5, 0,
+  /* 6821 */ 0, 15, 3, 31, 3, 1, 15, 11, 5, 0,
+  /* 6831 */ 28, 35, 5, 0,
+  /* 6835 */ 41, 41, 5, 0,
+  /* 6839 */ 43, 10, 7, 43, 10, 7, 43, 11, 48, 43, 11, 48, 5, 0,
+  /* 6853 */ 0, 15, 4, 9, 6, 9, 6, 9, 6, 9, 6, 0,
+  /* 6865 */ 23, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 0,
+  /* 6915 */ 40, 7, 7, 7, 7, 7, 7, 7, 7, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 0,
+  /* 6965 */ 23, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 0,
+  /* 6991 */ 40, 7, 7, 7, 7, 7, 7, 7, 7, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 0,
+  /* 7017 */ 43, 9, 5, 43, 9, 5, 43, 9, 1, 43, 11, 6, 0,
+  /* 7030 */ 43, 9, 8, 43, 9, 8, 43, 9, 1, 43, 11, 6, 0,
+  /* 7043 */ 43, 10, 4, 43, 10, 4, 43, 10, 1, 43, 11, 6, 0,
+  /* 7056 */ 43, 10, 7, 43, 10, 7, 43, 10, 1, 43, 11, 6, 0,
+  /* 7069 */ 23, 4, 4, 4, 4, 5, 4, 7, 0,
+  /* 7078 */ 23, 4, 4, 4, 4, 5, 5, 4, 7, 0,
+  /* 7088 */ 23, 7, 7, 7, 7, 5, 5, 4, 7, 0,
+  /* 7098 */ 23, 7, 7, 7, 7, 5, 4, 7, 0,
+  /* 7107 */ 23, 4, 4, 4, 4, 5, 7, 0,
+  /* 7115 */ 23, 4, 4, 4, 4, 5, 5, 7, 0,
+  /* 7124 */ 23, 7, 7, 7, 7, 5, 5, 7, 0,
+  /* 7133 */ 23, 7, 7, 7, 7, 5, 7, 0,
+  /* 7141 */ 23, 4, 4, 4, 4, 5, 4, 7, 7, 0,
+  /* 7151 */ 23, 4, 4, 4, 4, 5, 5, 4, 7, 7, 0,
+  /* 7162 */ 23, 7, 7, 7, 7, 5, 5, 4, 7, 7, 0,
+  /* 7173 */ 23, 7, 7, 7, 7, 5, 4, 7, 7, 0,
+  /* 7183 */ 23, 4, 4, 4, 4, 5, 7, 7, 0,
+  /* 7192 */ 23, 4, 4, 4, 4, 5, 5, 7, 7, 0,
+  /* 7202 */ 23, 7, 7, 7, 7, 5, 5, 7, 7, 0,
+  /* 7212 */ 23, 7, 7, 7, 7, 5, 7, 7, 0,
+  /* 7221 */ 23, 4, 4, 4, 4, 5, 4, 7, 7, 7, 0,
+  /* 7232 */ 23, 4, 4, 4, 4, 5, 5, 4, 7, 7, 7, 0,
+  /* 7244 */ 23, 7, 7, 7, 7, 5, 5, 4, 7, 7, 7, 0,
+  /* 7256 */ 23, 7, 7, 7, 7, 5, 4, 7, 7, 7, 0,
+  /* 7267 */ 23, 4, 4, 4, 4, 5, 7, 7, 7, 0,
+  /* 7277 */ 23, 4, 4, 4, 4, 5, 5, 7, 7, 7, 0,
+  /* 7288 */ 23, 7, 7, 7, 7, 5, 5, 7, 7, 7, 0,
+  /* 7299 */ 23, 7, 7, 7, 7, 5, 7, 7, 7, 0,
+  /* 7309 */ 23, 4, 4, 4, 4, 5, 4, 7, 7, 7, 7, 0,
+  /* 7321 */ 23, 4, 4, 4, 4, 5, 5, 4, 7, 7, 7, 7, 0,
+  /* 7334 */ 23, 7, 7, 7, 7, 5, 5, 4, 7, 7, 7, 7, 0,
+  /* 7347 */ 23, 7, 7, 7, 7, 5, 4, 7, 7, 7, 7, 0,
+  /* 7359 */ 23, 4, 4, 4, 4, 5, 7, 7, 7, 7, 0,
+  /* 7370 */ 23, 4, 4, 4, 4, 5, 5, 7, 7, 7, 7, 0,
+  /* 7382 */ 23, 7, 7, 7, 7, 5, 5, 7, 7, 7, 7, 0,
+  /* 7394 */ 23, 7, 7, 7, 7, 5, 7, 7, 7, 7, 0,
+  /* 7405 */ 23, 4, 4, 4, 4, 5, 4, 7, 7, 7, 7, 7, 7, 0,
+  /* 7419 */ 23, 4, 4, 4, 4, 5, 5, 4, 7, 7, 7, 7, 7, 7, 0,
+  /* 7434 */ 23, 7, 7, 7, 7, 5, 5, 4, 7, 7, 7, 7, 7, 7, 0,
+  /* 7449 */ 23, 7, 7, 7, 7, 5, 4, 7, 7, 7, 7, 7, 7, 0,
+  /* 7463 */ 23, 4, 4, 4, 4, 5, 7, 7, 7, 7, 7, 7, 0,
+  /* 7476 */ 23, 4, 4, 4, 4, 5, 5, 7, 7, 7, 7, 7, 7, 0,
+  /* 7490 */ 23, 7, 7, 7, 7, 5, 5, 7, 7, 7, 7, 7, 7, 0,
+  /* 7504 */ 23, 7, 7, 7, 7, 5, 7, 7, 7, 7, 7, 7, 0,
+  /* 7517 */ 0, 15, 4, 7, 7, 7, 7, 7, 7, 7, 7, 0,
+  /* 7529 */ 23, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 7, 7, 7, 7, 7, 7, 7, 7, 0,
+  /* 7579 */ 40, 7, 7, 7, 7, 7, 7, 7, 7, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 7, 7, 7, 7, 7, 7, 7, 7, 0,
+  /* 7629 */ 40, 7, 7, 7, 7, 7, 7, 7, 7, 9, 6, 9, 6, 9, 6, 9, 6, 7, 7, 7, 7, 7, 7, 7, 7, 0,
+  /* 7655 */ 23, 4, 4, 4, 4, 5, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0,
+  /* 7671 */ 23, 4, 4, 4, 4, 5, 5, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0,
+  /* 7688 */ 23, 7, 7, 7, 7, 5, 5, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0,
+  /* 7705 */ 23, 7, 7, 7, 7, 5, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0,
+  /* 7721 */ 21, 10, 4, 4, 10, 7, 10, 7, 0,
+  /* 7730 */ 17, 10, 7, 0,
+  /* 7734 */ 43, 9, 5, 43, 9, 5, 43, 9, 1, 43, 10, 7, 0,
+  /* 7747 */ 43, 9, 8, 43, 9, 8, 43, 9, 1, 43, 10, 7, 0,
+  /* 7760 */ 43, 11, 6, 43, 11, 6, 43, 10, 1, 43, 10, 7, 0,
+  /* 7773 */ 43, 11, 48, 43, 11, 48, 43, 11, 1, 43, 10, 7, 0,
+  /* 7786 */ 11, 48, 11, 48, 10, 7, 0,
+  /* 7793 */ 15, 3, 31, 3, 1, 15, 7, 0,
+  /* 7801 */ 15, 3, 34, 1, 0, 4, 31, 3, 1, 15, 7, 0,
+  /* 7813 */ 15, 3, 15, 12, 4, 31, 3, 1, 15, 7, 0,
+  /* 7824 */ 15, 3, 15, 7, 31, 3, 1, 15, 7, 0,
+  /* 7834 */ 15, 3, 33, 7, 31, 3, 1, 15, 7, 0,
+  /* 7844 */ 15, 3, 12, 2, 12, 2, 12, 2, 12, 2, 15, 7, 0,
+  /* 7857 */ 15, 3, 15, 7, 12, 2, 12, 2, 12, 2, 12, 2, 15, 7, 0,
+  /* 7872 */ 15, 3, 12, 2, 12, 2, 12, 2, 15, 7, 0,
+  /* 7883 */ 15, 3, 15, 7, 12, 2, 12, 2, 12, 2, 15, 7, 0,
+  /* 7896 */ 15, 3, 15, 7, 12, 2, 12, 2, 15, 7, 0,
+  /* 7907 */ 31, 3, 1, 31, 3, 1, 15, 3, 15, 7, 0,
+  /* 7918 */ 21, 4, 4, 4, 4, 4, 4, 4, 15, 3, 15, 7, 0,
+  /* 7931 */ 44, 7, 44, 7, 15, 3, 15, 7, 0,
+  /* 7940 */ 21, 15, 1, 31, 1, 1, 15, 7, 15, 7, 0,
+  /* 7951 */ 15, 3, 31, 3, 1, 15, 7, 15, 7, 0,
+  /* 7961 */ 15, 3, 31, 3, 1, 15, 7, 15, 7, 15, 7, 0,
+  /* 7973 */ 15, 3, 4, 15, 7, 15, 7, 15, 7, 0,
+  /* 7983 */ 15, 3, 15, 7, 4, 4, 15, 11, 15, 7, 0,
+  /* 7994 */ 15, 3, 15, 7, 4, 15, 11, 15, 7, 0,
+  /* 8004 */ 15, 3, 15, 7, 15, 7, 4, 15, 11, 15, 7, 0,
+  /* 8016 */ 15, 3, 15, 7, 15, 7, 15, 11, 15, 7, 0,
+  /* 8027 */ 15, 3, 15, 11, 4, 4, 4, 15, 19, 15, 7, 0,
+  /* 8039 */ 15, 3, 15, 7, 15, 11, 4, 4, 4, 15, 19, 15, 7, 0,
+  /* 8053 */ 15, 3, 15, 11, 4, 4, 15, 19, 15, 7, 0,
+  /* 8064 */ 15, 3, 15, 11, 15, 15, 4, 4, 15, 19, 15, 7, 0,
+  /* 8077 */ 15, 3, 15, 11, 4, 15, 19, 15, 7, 0,
+  /* 8087 */ 15, 3, 15, 11, 15, 15, 4, 15, 19, 15, 7, 0,
+  /* 8099 */ 15, 1, 25, 7, 0,
+  /* 8104 */ 15, 3, 25, 7, 0,
+  /* 8109 */ 15, 3, 25, 7, 25, 7, 0,
+  /* 8116 */ 15, 3, 26, 7, 0,
+  /* 8121 */ 15, 3, 26, 7, 26, 7, 0,
+  /* 8128 */ 0, 15, 3, 31, 3, 1, 33, 7, 0,
+  /* 8137 */ 0, 15, 3, 15, 7, 31, 3, 1, 33, 7, 0,
+  /* 8148 */ 0, 15, 3, 15, 7, 15, 7, 31, 3, 1, 33, 7, 0,
+  /* 8161 */ 0, 15, 3, 15, 7, 15, 7, 15, 7, 31, 3, 1, 33, 7, 0,
+  /* 8176 */ 15, 3, 15, 11, 33, 7, 0,
+  /* 8183 */ 15, 3, 15, 7, 31, 3, 1, 42, 7, 0,
+  /* 8193 */ 15, 3, 42, 7, 0,
+  /* 8198 */ 15, 3, 15, 7, 42, 7, 0,
+  /* 8205 */ 15, 3, 42, 7, 42, 7, 0,
+  /* 8212 */ 15, 3, 44, 7, 0,
+  /* 8217 */ 15, 3, 31, 3, 1, 15, 7, 44, 7, 0,
+  /* 8227 */ 15, 3, 15, 7, 44, 7, 0,
+  /* 8234 */ 15, 3, 44, 7, 44, 7, 0,
+  /* 8241 */ 15, 3, 15, 7, 44, 7, 44, 7, 0,
+  /* 8250 */ 15, 3, 15, 7, 45, 7, 45, 7, 0,
+  /* 8259 */ 15, 3, 46, 7, 0,
+  /* 8264 */ 15, 3, 31, 3, 1, 15, 7, 46, 7, 0,
+  /* 8274 */ 15, 3, 15, 7, 46, 7, 0,
+  /* 8281 */ 15, 3, 15, 7, 15, 7, 46, 7, 0,
+  /* 8290 */ 48, 7, 0,
+  /* 8293 */ 9, 8, 9, 8, 9, 5, 9, 8, 0,
+  /* 8302 */ 21, 9, 5, 4, 9, 8, 9, 8, 0,
+  /* 8311 */ 9, 8, 9, 8, 9, 8, 9, 8, 0,
+  /* 8320 */ 17, 9, 8, 0,
+  /* 8324 */ 43, 10, 4, 43, 10, 4, 43, 9, 1, 43, 9, 8, 0,
+  /* 8337 */ 43, 11, 6, 43, 11, 6, 43, 9, 1, 43, 9, 8, 0,
+  /* 8350 */ 43, 10, 7, 43, 10, 7, 43, 9, 1, 43, 9, 8, 0,
+  /* 8363 */ 10, 8, 10, 8, 10, 5, 10, 8, 0,
+  /* 8372 */ 10, 8, 10, 8, 10, 8, 10, 8, 0,
+  /* 8381 */ 11, 8, 11, 8, 11, 5, 11, 8, 0,
+  /* 8390 */ 15, 3, 15, 7, 31, 3, 1, 31, 3, 1, 15, 9, 0,
+  /* 8403 */ 46, 7, 46, 7, 15, 3, 31, 3, 1, 15, 9, 0,
+  /* 8415 */ 15, 3, 15, 7, 31, 3, 1, 15, 9, 0,
+  /* 8425 */ 15, 3, 15, 7, 15, 7, 31, 3, 1, 15, 9, 0,
+  /* 8437 */ 0, 15, 3, 14, 15, 7, 31, 3, 1, 15, 9, 0,
+  /* 8449 */ 15, 3, 15, 7, 14, 15, 7, 31, 3, 1, 15, 9, 0,
+  /* 8462 */ 21, 1, 15, 1, 15, 9, 0,
+  /* 8469 */ 46, 7, 15, 3, 15, 9, 0,
+  /* 8476 */ 15, 3, 15, 7, 15, 7, 15, 9, 0,
+  /* 8485 */ 15, 1, 15, 7, 15, 7, 15, 7, 15, 9, 0,
+  /* 8496 */ 0, 15, 3, 14, 15, 7, 15, 9, 0,
+  /* 8505 */ 15, 1, 42, 7, 15, 9, 0,
+  /* 8512 */ 15, 2, 42, 7, 15, 9, 0,
+  /* 8519 */ 15, 1, 15, 7, 42, 7, 15, 9, 0,
+  /* 8528 */ 15, 2, 15, 7, 42, 7, 15, 9, 0,
+  /* 8537 */ 15, 3, 15, 7, 31, 3, 1, 15, 11, 0,
+  /* 8547 */ 15, 3, 46, 7, 31, 3, 1, 15, 11, 0,
+  /* 8557 */ 15, 3, 4, 15, 7, 12, 2, 12, 2, 4, 15, 11, 0,
+  /* 8570 */ 15, 3, 4, 15, 7, 12, 2, 4, 15, 11, 0,
+  /* 8581 */ 15, 3, 15, 7, 4, 4, 4, 4, 15, 11, 0,
+  /* 8592 */ 21, 15, 3, 4, 15, 7, 4, 4, 4, 15, 11, 0,
+  /* 8604 */ 15, 3, 15, 7, 15, 7, 15, 7, 4, 4, 4, 15, 11, 0,
+  /* 8618 */ 21, 4, 15, 3, 15, 7, 4, 4, 15, 11, 0,
+  /* 8629 */ 21, 15, 3, 4, 15, 7, 4, 4, 15, 11, 0,
+  /* 8640 */ 15, 3, 4, 15, 7, 4, 15, 11, 0,
+  /* 8649 */ 15, 3, 15, 7, 15, 7, 4, 15, 11, 0,
+  /* 8659 */ 21, 15, 3, 4, 15, 7, 15, 7, 15, 7, 4, 15, 11, 0,
+  /* 8673 */ 21, 4, 4, 4, 4, 4, 4, 4, 15, 3, 15, 7, 15, 11, 0,
+  /* 8688 */ 15, 3, 15, 7, 15, 7, 15, 11, 0,
+  /* 8697 */ 15, 3, 15, 7, 15, 7, 15, 7, 15, 11, 0,
+  /* 8708 */ 15, 3, 4, 15, 7, 15, 7, 15, 7, 15, 11, 0,
+  /* 8720 */ 15, 3, 4, 4, 15, 7, 15, 7, 15, 7, 15, 11, 0,
+  /* 8733 */ 23, 15, 7, 15, 7, 15, 7, 15, 3, 15, 12, 0,
+  /* 8745 */ 22, 15, 7, 15, 7, 15, 3, 15, 12, 0,
+  /* 8755 */ 21, 15, 7, 15, 3, 15, 12, 0,
+  /* 8763 */ 23, 15, 7, 15, 7, 15, 7, 15, 7, 15, 7, 15, 7, 15, 7, 15, 3, 5, 15, 12, 0,
+  /* 8784 */ 22, 15, 7, 15, 7, 15, 7, 15, 7, 15, 7, 15, 3, 5, 15, 12, 0,
+  /* 8801 */ 21, 15, 7, 15, 7, 15, 7, 15, 3, 5, 15, 12, 0,
+  /* 8814 */ 0, 15, 3, 15, 7, 5, 15, 12, 0,
+  /* 8823 */ 0, 15, 3, 15, 7, 15, 7, 5, 15, 12, 0,
+  /* 8834 */ 0, 15, 3, 15, 7, 15, 7, 15, 7, 5, 15, 12, 0,
+  /* 8847 */ 21, 15, 3, 15, 7, 15, 12, 0,
+  /* 8855 */ 0, 15, 3, 15, 7, 15, 7, 15, 12, 0,
+  /* 8865 */ 22, 15, 3, 15, 7, 15, 7, 15, 12, 0,
+  /* 8875 */ 0, 15, 3, 15, 7, 15, 7, 15, 7, 15, 12, 0,
+  /* 8887 */ 23, 15, 3, 15, 7, 15, 7, 15, 7, 15, 12, 0,
+  /* 8899 */ 15, 3, 15, 7, 15, 7, 15, 9, 31, 3, 1, 15, 15, 0,
+  /* 8913 */ 0, 15, 3, 14, 15, 7, 15, 9, 31, 3, 1, 15, 15, 0,
+  /* 8927 */ 15, 3, 15, 7, 14, 15, 7, 15, 9, 31, 3, 1, 15, 15, 0,
+  /* 8942 */ 15, 3, 15, 7, 15, 7, 15, 9, 15, 15, 0,
+  /* 8953 */ 0, 15, 3, 14, 15, 7, 15, 9, 15, 15, 0,
+  /* 8964 */ 15, 3, 15, 7, 15, 11, 15, 15, 0,
+  /* 8973 */ 15, 3, 15, 11, 15, 15, 15, 15, 0,
+  /* 8982 */ 0, 15, 4, 15, 11, 15, 15, 15, 15, 0,
+  /* 8992 */ 15, 3, 15, 11, 15, 15, 15, 15, 15, 15, 0,
+  /* 9003 */ 0, 15, 4, 15, 11, 15, 15, 15, 15, 15, 15, 0,
+  /* 9015 */ 4, 17, 0,
+  /* 9018 */ 10, 7, 10, 7, 17, 0,
+  /* 9024 */ 9, 8, 17, 0,
+  /* 9028 */ 15, 3, 15, 7, 15, 8, 15, 7, 31, 3, 1, 15, 17, 0,
+  /* 9042 */ 31, 3, 1, 31, 3, 1, 15, 3, 15, 8, 31, 3, 1, 15, 17, 0,
+  /* 9058 */ 15, 3, 15, 7, 15, 8, 31, 3, 1, 15, 17, 0,
+  /* 9070 */ 15, 3, 15, 7, 15, 7, 15, 8, 31, 3, 1, 15, 17, 0,
+  /* 9084 */ 15, 3, 15, 7, 15, 11, 31, 3, 1, 15, 17, 0,
+  /* 9096 */ 0, 15, 3, 14, 15, 7, 15, 11, 31, 3, 1, 15, 17, 0,
+  /* 9110 */ 15, 3, 15, 7, 14, 15, 7, 15, 11, 31, 3, 1, 15, 17, 0,
+  /* 9125 */ 15, 3, 15, 7, 15, 11, 15, 7, 31, 11, 1, 15, 17, 0,
+  /* 9139 */ 15, 3, 15, 7, 15, 11, 31, 11, 1, 15, 17, 0,
+  /* 9151 */ 15, 3, 15, 7, 15, 8, 15, 7, 15, 17, 0,
+  /* 9162 */ 15, 3, 15, 7, 15, 11, 15, 7, 15, 17, 0,
+  /* 9173 */ 31, 3, 1, 15, 3, 15, 8, 15, 17, 0,
+  /* 9183 */ 15, 3, 15, 7, 15, 8, 15, 17, 0,
+  /* 9192 */ 0, 15, 3, 14, 15, 7, 15, 9, 15, 17, 0,
+  /* 9203 */ 15, 3, 15, 11, 15, 17, 0,
+  /* 9210 */ 15, 3, 14, 15, 7, 15, 11, 15, 17, 0,
+  /* 9220 */ 0, 14, 17, 17, 0,
+  /* 9225 */ 17, 17, 17, 0,
+  /* 9229 */ 15, 0, 18, 0,
+  /* 9233 */ 1, 18, 0,
+  /* 9236 */ 14, 2, 18, 0,
+  /* 9240 */ 15, 4, 18, 0,
+  /* 9244 */ 15, 2, 15, 12, 15, 18, 0,
+  /* 9251 */ 0, 19, 0,
+  /* 9254 */ 15, 1, 19, 0,
+  /* 9258 */ 1, 14, 2, 19, 0,
+  /* 9263 */ 21, 14, 2, 1, 14, 2, 4, 19, 0,
+  /* 9272 */ 15, 2, 15, 7, 19, 0,
+  /* 9278 */ 15, 2, 15, 7, 15, 7, 19, 0,
+  /* 9286 */ 15, 1, 15, 10, 19, 0,
+  /* 9292 */ 15, 2, 15, 10, 19, 0,
+  /* 9298 */ 15, 3, 15, 7, 15, 11, 4, 4, 4, 4, 4, 4, 15, 19, 0,
+  /* 9313 */ 15, 3, 15, 7, 15, 11, 4, 4, 4, 15, 19, 0,
+  /* 9325 */ 15, 3, 15, 11, 4, 15, 19, 0,
+  /* 9333 */ 15, 3, 15, 7, 15, 11, 4, 15, 19, 0,
+  /* 9343 */ 15, 3, 4, 15, 7, 15, 11, 4, 15, 19, 0,
+  /* 9354 */ 21, 15, 3, 15, 11, 15, 15, 4, 15, 19, 0,
+  /* 9365 */ 0, 15, 3, 4, 15, 11, 15, 19, 0,
+  /* 9374 */ 15, 3, 15, 7, 4, 15, 11, 15, 19, 0,
+  /* 9384 */ 15, 2, 15, 7, 15, 11, 15, 19, 0,
+  /* 9393 */ 15, 3, 4, 15, 7, 15, 11, 15, 19, 0,
+  /* 9403 */ 15, 2, 15, 7, 4, 19, 19, 0,
+  /* 9411 */ 31, 2, 1, 15, 2, 15, 7, 19, 19, 0,
+  /* 9421 */ 15, 2, 15, 7, 15, 7, 19, 19, 0,
+  /* 9430 */ 15, 2, 15, 7, 15, 7, 15, 7, 19, 19, 0,
+  /* 9441 */ 15, 2, 15, 9, 19, 19, 0,
+  /* 9448 */ 15, 1, 15, 10, 19, 19, 0,
+  /* 9455 */ 15, 2, 15, 10, 19, 19, 0,
+  /* 9462 */ 0, 19, 19, 19, 0,
+  /* 9467 */ 15, 3, 15, 7, 15, 11, 15, 16, 31, 3, 1, 15, 25, 0,
+  /* 9481 */ 15, 3, 15, 7, 15, 8, 15, 19, 31, 3, 1, 15, 25, 0,
+  /* 9495 */ 15, 3, 15, 11, 15, 16, 15, 25, 0,
+  /* 9504 */ 15, 3, 15, 7, 15, 8, 15, 19, 15, 25, 0,
+  /* 9515 */ 15, 3, 15, 12, 15, 19, 4, 4, 4, 15, 27, 0,
+  /* 9527 */ 0, 15, 4, 15, 11, 15, 19, 4, 4, 15, 27, 0,
+  /* 9539 */ 15, 0, 29, 0,
+  /* 9543 */ 0, 1, 29, 0,
+  /* 9547 */ 1, 14, 2, 1, 29, 0,
+  /* 9553 */ 22, 14, 2, 14, 2, 14, 2, 14, 2, 14, 2, 29, 0,
+  /* 9566 */ 0, 5, 4, 14, 2, 4, 29, 0,
+  /* 9574 */ 5, 5, 4, 14, 2, 4, 29, 0,
+  /* 9582 */ 18, 5, 4, 15, 4, 4, 4, 29, 0,
+  /* 9591 */ 0, 5, 4, 29, 0,
+  /* 9596 */ 4, 28, 35, 0,
+  /* 9600 */ 28, 35, 9, 5, 9, 5, 28, 35, 0,
+  /* 9609 */ 4, 4, 28, 35, 28, 35, 0,
+  /* 9616 */ 28, 35, 28, 35, 28, 35, 28, 35, 0,
+  /* 9625 */ 5, 41, 0,
+  /* 9628 */ 8, 41, 0,
+  /* 9631 */ 41, 41, 41, 41, 0,
+  /* 9636 */ 43, 10, 7, 43, 10, 7, 43, 11, 48, 43, 11, 48, 0,
+  /* 9649 */ 10, 7, 10, 7, 11, 48, 11, 48, 0,
+  /* 9658 */ 0, 3, 3, 14, 2, 5, 51, 0,
+  /* 9666 */ 51, 3, 3, 3, 51, 51, 51, 0,
   255
 };
 
@@ -9393,7021 +13121,9778 @@
 #ifdef GET_INTRINSIC_ATTRIBUTES
 AttributeList Intrinsic::getAttributes(LLVMContext &C, ID id) {
   static const uint8_t IntrinsicsToAttributesMap[] = {
-    1, // llvm.addressofreturnaddress
-    2, // llvm.adjust.trampoline
-    3, // llvm.annotation
-    3, // llvm.assume
-    4, // llvm.bitreverse
-    4, // llvm.bswap
-    4, // llvm.canonicalize
-    4, // llvm.ceil
-    3, // llvm.clear_cache
-    5, // llvm.codeview.annotation
-    1, // llvm.convert.from.fp16
-    1, // llvm.convert.to.fp16
-    4, // llvm.copysign
-    3, // llvm.coro.alloc
-    6, // llvm.coro.begin
-    7, // llvm.coro.destroy
-    8, // llvm.coro.done
-    3, // llvm.coro.end
-    1, // llvm.coro.frame
-    9, // llvm.coro.free
-    10, // llvm.coro.id
-    1, // llvm.coro.noop
-    11, // llvm.coro.param
-    12, // llvm.coro.promise
-    7, // llvm.coro.resume
-    3, // llvm.coro.save
-    1, // llvm.coro.size
-    13, // llvm.coro.subfn.addr
-    3, // llvm.coro.suspend
-    4, // llvm.cos
-    14, // llvm.ctlz
-    4, // llvm.ctpop
-    14, // llvm.cttz
-    4, // llvm.dbg.addr
-    4, // llvm.dbg.declare
-    4, // llvm.dbg.label
-    4, // llvm.dbg.value
-    3, // llvm.debugtrap
-    1, // llvm.donothing
-    3, // llvm.eh.dwarf.cfa
-    1, // llvm.eh.exceptioncode
-    1, // llvm.eh.exceptionpointer
-    1, // llvm.eh.recoverfp
-    3, // llvm.eh.return.i32
-    3, // llvm.eh.return.i64
-    1, // llvm.eh.sjlj.callsite
-    3, // llvm.eh.sjlj.functioncontext
-    15, // llvm.eh.sjlj.longjmp
-    1, // llvm.eh.sjlj.lsda
-    3, // llvm.eh.sjlj.setjmp
-    3, // llvm.eh.sjlj.setup.dispatch
-    1, // llvm.eh.typeid.for
-    3, // llvm.eh.unwind.init
-    4, // llvm.exp
-    4, // llvm.exp2
-    1, // llvm.expect
-    16, // llvm.experimental.constrained.ceil
-    16, // llvm.experimental.constrained.cos
-    16, // llvm.experimental.constrained.exp
-    16, // llvm.experimental.constrained.exp2
-    16, // llvm.experimental.constrained.fadd
-    16, // llvm.experimental.constrained.fdiv
-    16, // llvm.experimental.constrained.floor
-    16, // llvm.experimental.constrained.fma
-    16, // llvm.experimental.constrained.fmul
-    16, // llvm.experimental.constrained.fpext
-    16, // llvm.experimental.constrained.fptrunc
-    16, // llvm.experimental.constrained.frem
-    16, // llvm.experimental.constrained.fsub
-    16, // llvm.experimental.constrained.log
-    16, // llvm.experimental.constrained.log10
-    16, // llvm.experimental.constrained.log2
-    16, // llvm.experimental.constrained.maxnum
-    16, // llvm.experimental.constrained.minnum
-    16, // llvm.experimental.constrained.nearbyint
-    16, // llvm.experimental.constrained.pow
-    16, // llvm.experimental.constrained.powi
-    16, // llvm.experimental.constrained.rint
-    16, // llvm.experimental.constrained.round
-    16, // llvm.experimental.constrained.sin
-    16, // llvm.experimental.constrained.sqrt
-    16, // llvm.experimental.constrained.trunc
-    7, // llvm.experimental.deoptimize
-    17, // llvm.experimental.gc.relocate
-    18, // llvm.experimental.gc.result
-    19, // llvm.experimental.gc.statepoint
-    7, // llvm.experimental.guard
-    7, // llvm.experimental.patchpoint.i64
-    7, // llvm.experimental.patchpoint.void
-    7, // llvm.experimental.stackmap
-    1, // llvm.experimental.vector.reduce.add
-    1, // llvm.experimental.vector.reduce.and
-    1, // llvm.experimental.vector.reduce.fmax
-    1, // llvm.experimental.vector.reduce.fmin
-    1, // llvm.experimental.vector.reduce.mul
-    1, // llvm.experimental.vector.reduce.or
-    1, // llvm.experimental.vector.reduce.smax
-    1, // llvm.experimental.vector.reduce.smin
-    1, // llvm.experimental.vector.reduce.umax
-    1, // llvm.experimental.vector.reduce.umin
-    1, // llvm.experimental.vector.reduce.v2.fadd
-    1, // llvm.experimental.vector.reduce.v2.fmul
-    1, // llvm.experimental.vector.reduce.xor
-    16, // llvm.experimental.widenable.condition
-    4, // llvm.fabs
-    4, // llvm.floor
-    3, // llvm.flt.rounds
-    4, // llvm.fma
-    4, // llvm.fmuladd
-    20, // llvm.frameaddress
-    4, // llvm.fshl
-    4, // llvm.fshr
-    2, // llvm.gcread
-    3, // llvm.gcroot
-    21, // llvm.gcwrite
-    3, // llvm.get.dynamic.area.offset
-    22, // llvm.hwasan.check.memaccess
-    3, // llvm.icall.branch.funnel
-    23, // llvm.init.trampoline
-    3, // llvm.instrprof.increment
-    3, // llvm.instrprof.increment.step
-    3, // llvm.instrprof.value.profile
-    24, // llvm.invariant.end
-    25, // llvm.invariant.start
-    1, // llvm.is.constant
+    1, // llvm.abs
+    2, // llvm.addressofreturnaddress
+    3, // llvm.adjust.trampoline
+    4, // llvm.annotation
+    5, // llvm.assume
+    6, // llvm.bitreverse
+    6, // llvm.bswap
+    4, // llvm.call.preallocated.arg
+    4, // llvm.call.preallocated.setup
+    4, // llvm.call.preallocated.teardown
+    6, // llvm.canonicalize
+    6, // llvm.ceil
+    7, // llvm.clear_cache
+    8, // llvm.codeview.annotation
+    2, // llvm.convert.from.fp16
+    2, // llvm.convert.to.fp16
+    6, // llvm.copysign
+    7, // llvm.coro.alloc
+    7, // llvm.coro.alloca.alloc
+    7, // llvm.coro.alloca.free
+    7, // llvm.coro.alloca.get
+    7, // llvm.coro.async.context.alloc
+    7, // llvm.coro.async.context.dealloc
+    7, // llvm.coro.async.resume
+    9, // llvm.coro.begin
+    10, // llvm.coro.destroy
+    11, // llvm.coro.done
+    7, // llvm.coro.end
+    7, // llvm.coro.end.async
+    12, // llvm.coro.frame
+    13, // llvm.coro.free
+    14, // llvm.coro.id
+    7, // llvm.coro.id.async
+    7, // llvm.coro.id.retcon
+    7, // llvm.coro.id.retcon.once
+    12, // llvm.coro.noop
+    15, // llvm.coro.param
+    12, // llvm.coro.prepare.async
+    12, // llvm.coro.prepare.retcon
+    16, // llvm.coro.promise
+    10, // llvm.coro.resume
+    7, // llvm.coro.save
+    12, // llvm.coro.size
+    17, // llvm.coro.subfn.addr
+    7, // llvm.coro.suspend
+    7, // llvm.coro.suspend.async
+    7, // llvm.coro.suspend.retcon
+    6, // llvm.cos
+    1, // llvm.ctlz
+    6, // llvm.ctpop
+    1, // llvm.cttz
+    6, // llvm.dbg.addr
+    6, // llvm.dbg.declare
+    6, // llvm.dbg.label
+    6, // llvm.dbg.value
+    7, // llvm.debugtrap
+    2, // llvm.donothing
+    7, // llvm.eh.dwarf.cfa
+    12, // llvm.eh.exceptioncode
+    12, // llvm.eh.exceptionpointer
+    2, // llvm.eh.recoverfp
+    7, // llvm.eh.return.i32
+    7, // llvm.eh.return.i64
+    12, // llvm.eh.sjlj.callsite
+    7, // llvm.eh.sjlj.functioncontext
+    18, // llvm.eh.sjlj.longjmp
+    12, // llvm.eh.sjlj.lsda
+    7, // llvm.eh.sjlj.setjmp
+    7, // llvm.eh.sjlj.setup.dispatch
+    12, // llvm.eh.typeid.for
+    7, // llvm.eh.unwind.init
+    6, // llvm.exp
+    6, // llvm.exp2
+    2, // llvm.expect
+    2, // llvm.expect.with.probability
+    19, // llvm.experimental.constrained.ceil
+    19, // llvm.experimental.constrained.cos
+    19, // llvm.experimental.constrained.exp
+    19, // llvm.experimental.constrained.exp2
+    19, // llvm.experimental.constrained.fadd
+    19, // llvm.experimental.constrained.fcmp
+    19, // llvm.experimental.constrained.fcmps
+    19, // llvm.experimental.constrained.fdiv
+    19, // llvm.experimental.constrained.floor
+    19, // llvm.experimental.constrained.fma
+    19, // llvm.experimental.constrained.fmul
+    19, // llvm.experimental.constrained.fmuladd
+    19, // llvm.experimental.constrained.fpext
+    19, // llvm.experimental.constrained.fptosi
+    19, // llvm.experimental.constrained.fptoui
+    19, // llvm.experimental.constrained.fptrunc
+    19, // llvm.experimental.constrained.frem
+    19, // llvm.experimental.constrained.fsub
+    19, // llvm.experimental.constrained.llrint
+    19, // llvm.experimental.constrained.llround
+    19, // llvm.experimental.constrained.log
+    19, // llvm.experimental.constrained.log10
+    19, // llvm.experimental.constrained.log2
+    19, // llvm.experimental.constrained.lrint
+    19, // llvm.experimental.constrained.lround
+    19, // llvm.experimental.constrained.maximum
+    19, // llvm.experimental.constrained.maxnum
+    19, // llvm.experimental.constrained.minimum
+    19, // llvm.experimental.constrained.minnum
+    19, // llvm.experimental.constrained.nearbyint
+    19, // llvm.experimental.constrained.pow
+    19, // llvm.experimental.constrained.powi
+    19, // llvm.experimental.constrained.rint
+    19, // llvm.experimental.constrained.round
+    19, // llvm.experimental.constrained.roundeven
+    19, // llvm.experimental.constrained.sin
+    19, // llvm.experimental.constrained.sitofp
+    19, // llvm.experimental.constrained.sqrt
+    19, // llvm.experimental.constrained.trunc
+    19, // llvm.experimental.constrained.uitofp
+    10, // llvm.experimental.deoptimize
+    20, // llvm.experimental.gc.relocate
+    21, // llvm.experimental.gc.result
+    22, // llvm.experimental.gc.statepoint
+    23, // llvm.experimental.guard
+    23, // llvm.experimental.patchpoint.i64
+    23, // llvm.experimental.patchpoint.void
+    23, // llvm.experimental.stackmap
+    24, // llvm.experimental.vector.extract
+    25, // llvm.experimental.vector.insert
+    26, // llvm.experimental.widenable.condition
+    6, // llvm.fabs
+    6, // llvm.floor
+    19, // llvm.flt.rounds
+    6, // llvm.fma
+    6, // llvm.fmuladd
+    6, // llvm.fptosi.sat
+    6, // llvm.fptoui.sat
+    27, // llvm.frameaddress
+    6, // llvm.fshl
+    6, // llvm.fshr
+    3, // llvm.gcread
+    7, // llvm.gcroot
+    28, // llvm.gcwrite
+    2, // llvm.get.active.lane.mask
+    4, // llvm.get.dynamic.area.offset
+    29, // llvm.hwasan.check.memaccess
+    29, // llvm.hwasan.check.memaccess.shortgranules
+    4, // llvm.icall.branch.funnel
+    30, // llvm.init.trampoline
+    7, // llvm.instrprof.increment
+    7, // llvm.instrprof.increment.step
+    7, // llvm.instrprof.value.profile
+    31, // llvm.invariant.end
+    32, // llvm.invariant.start
+    33, // llvm.is.constant
     26, // llvm.launder.invariant.group
-    25, // llvm.lifetime.end
-    25, // llvm.lifetime.start
-    4, // llvm.llrint
-    4, // llvm.llround
-    2, // llvm.load.relative
-    1, // llvm.localaddress
-    3, // llvm.localescape
-    27, // llvm.localrecover
-    4, // llvm.log
-    4, // llvm.log10
-    4, // llvm.log2
-    15, // llvm.longjmp
-    28, // llvm.loop.decrement
-    28, // llvm.loop.decrement.reg
-    4, // llvm.lrint
-    4, // llvm.lround
-    29, // llvm.masked.compressstore
-    18, // llvm.masked.expandload
-    30, // llvm.masked.gather
-    31, // llvm.masked.load
-    32, // llvm.masked.scatter
-    33, // llvm.masked.store
-    4, // llvm.maximum
-    4, // llvm.maxnum
-    34, // llvm.memcpy
-    34, // llvm.memcpy.element.unordered.atomic
-    35, // llvm.memmove
-    34, // llvm.memmove.element.unordered.atomic
-    36, // llvm.memset
-    36, // llvm.memset.element.unordered.atomic
-    4, // llvm.minimum
-    4, // llvm.minnum
-    4, // llvm.nearbyint
-    3, // llvm.objc.arc.annotation.bottomup.bbend
-    3, // llvm.objc.arc.annotation.bottomup.bbstart
-    3, // llvm.objc.arc.annotation.topdown.bbend
-    3, // llvm.objc.arc.annotation.topdown.bbstart
-    3, // llvm.objc.autorelease
-    3, // llvm.objc.autoreleasePoolPop
-    3, // llvm.objc.autoreleasePoolPush
-    3, // llvm.objc.autoreleaseReturnValue
-    3, // llvm.objc.clang.arc.use
-    3, // llvm.objc.copyWeak
-    3, // llvm.objc.destroyWeak
-    3, // llvm.objc.initWeak
-    3, // llvm.objc.loadWeak
-    3, // llvm.objc.loadWeakRetained
-    3, // llvm.objc.moveWeak
-    3, // llvm.objc.release
-    3, // llvm.objc.retain
-    3, // llvm.objc.retain.autorelease
-    3, // llvm.objc.retainAutorelease
-    3, // llvm.objc.retainAutoreleaseReturnValue
-    3, // llvm.objc.retainAutoreleasedReturnValue
-    3, // llvm.objc.retainBlock
-    3, // llvm.objc.retainedObject
-    3, // llvm.objc.storeStrong
-    3, // llvm.objc.storeWeak
-    3, // llvm.objc.sync.enter
-    3, // llvm.objc.sync.exit
-    3, // llvm.objc.unretainedObject
-    3, // llvm.objc.unretainedPointer
-    3, // llvm.objc.unsafeClaimAutoreleasedReturnValue
-    37, // llvm.objectsize
-    3, // llvm.pcmarker
-    4, // llvm.pow
-    4, // llvm.powi
-    38, // llvm.prefetch
-    39, // llvm.preserve.array.access.index
-    39, // llvm.preserve.struct.access.index
-    40, // llvm.preserve.union.access.index
-    3, // llvm.ptr.annotation
-    18, // llvm.read_register
-    3, // llvm.readcyclecounter
-    20, // llvm.returnaddress
-    4, // llvm.rint
-    4, // llvm.round
-    4, // llvm.sadd.sat
-    4, // llvm.sadd.with.overflow
-    28, // llvm.set.loop.iterations
-    3, // llvm.setjmp
-    16, // llvm.sideeffect
-    15, // llvm.siglongjmp
-    3, // llvm.sigsetjmp
-    4, // llvm.sin
-    41, // llvm.smul.fix
-    41, // llvm.smul.fix.sat
-    4, // llvm.smul.with.overflow
-    1, // llvm.sponentry
-    4, // llvm.sqrt
-    42, // llvm.ssa.copy
-    4, // llvm.ssub.sat
-    4, // llvm.ssub.with.overflow
-    3, // llvm.stackguard
-    3, // llvm.stackprotector
-    3, // llvm.stackrestore
-    3, // llvm.stacksave
-    4, // llvm.strip.invariant.group
-    28, // llvm.test.set.loop.iterations
-    1, // llvm.thread.pointer
-    43, // llvm.trap
-    4, // llvm.trunc
-    1, // llvm.type.checked.load
-    1, // llvm.type.test
-    4, // llvm.uadd.sat
-    4, // llvm.uadd.with.overflow
-    41, // llvm.umul.fix
-    4, // llvm.umul.with.overflow
-    4, // llvm.usub.sat
-    4, // llvm.usub.with.overflow
-    3, // llvm.va_copy
-    3, // llvm.va_end
-    3, // llvm.va_start
-    3, // llvm.var.annotation
-    3, // llvm.write_register
-    44, // llvm.xray.customevent
-    45, // llvm.xray.typedevent
-    1, // llvm.aarch64.addg
-    3, // llvm.aarch64.clrex
-    1, // llvm.aarch64.crc32b
-    1, // llvm.aarch64.crc32cb
-    1, // llvm.aarch64.crc32ch
-    1, // llvm.aarch64.crc32cw
-    1, // llvm.aarch64.crc32cx
-    1, // llvm.aarch64.crc32h
-    1, // llvm.aarch64.crc32w
-    1, // llvm.aarch64.crc32x
-    1, // llvm.aarch64.crypto.aesd
-    1, // llvm.aarch64.crypto.aese
-    1, // llvm.aarch64.crypto.aesimc
-    1, // llvm.aarch64.crypto.aesmc
-    1, // llvm.aarch64.crypto.sha1c
-    1, // llvm.aarch64.crypto.sha1h
-    1, // llvm.aarch64.crypto.sha1m
-    1, // llvm.aarch64.crypto.sha1p
-    1, // llvm.aarch64.crypto.sha1su0
-    1, // llvm.aarch64.crypto.sha1su1
-    1, // llvm.aarch64.crypto.sha256h
-    1, // llvm.aarch64.crypto.sha256h2
-    1, // llvm.aarch64.crypto.sha256su0
-    1, // llvm.aarch64.crypto.sha256su1
-    3, // llvm.aarch64.dmb
-    3, // llvm.aarch64.dsb
-    1, // llvm.aarch64.get.fpcr
-    1, // llvm.aarch64.gmi
-    3, // llvm.aarch64.hint
-    16, // llvm.aarch64.irg
-    3, // llvm.aarch64.isb
-    3, // llvm.aarch64.ldaxp
-    3, // llvm.aarch64.ldaxr
-    18, // llvm.aarch64.ldg
-    3, // llvm.aarch64.ldxp
-    3, // llvm.aarch64.ldxr
-    1, // llvm.aarch64.neon.abs
-    1, // llvm.aarch64.neon.addhn
-    1, // llvm.aarch64.neon.addp
-    1, // llvm.aarch64.neon.cls
-    1, // llvm.aarch64.neon.fabd
-    1, // llvm.aarch64.neon.facge
-    1, // llvm.aarch64.neon.facgt
-    1, // llvm.aarch64.neon.faddp
-    1, // llvm.aarch64.neon.faddv
-    1, // llvm.aarch64.neon.fcvtas
-    1, // llvm.aarch64.neon.fcvtau
-    1, // llvm.aarch64.neon.fcvtms
-    1, // llvm.aarch64.neon.fcvtmu
-    1, // llvm.aarch64.neon.fcvtns
-    1, // llvm.aarch64.neon.fcvtnu
-    1, // llvm.aarch64.neon.fcvtps
-    1, // llvm.aarch64.neon.fcvtpu
-    1, // llvm.aarch64.neon.fcvtxn
-    1, // llvm.aarch64.neon.fcvtzs
-    1, // llvm.aarch64.neon.fcvtzu
-    1, // llvm.aarch64.neon.fmax
-    1, // llvm.aarch64.neon.fmaxnm
-    1, // llvm.aarch64.neon.fmaxnmp
-    1, // llvm.aarch64.neon.fmaxnmv
-    1, // llvm.aarch64.neon.fmaxp
-    1, // llvm.aarch64.neon.fmaxv
-    1, // llvm.aarch64.neon.fmin
-    1, // llvm.aarch64.neon.fminnm
-    1, // llvm.aarch64.neon.fminnmp
-    1, // llvm.aarch64.neon.fminnmv
-    1, // llvm.aarch64.neon.fminp
-    1, // llvm.aarch64.neon.fminv
-    1, // llvm.aarch64.neon.fmlal
-    1, // llvm.aarch64.neon.fmlal2
-    1, // llvm.aarch64.neon.fmlsl
-    1, // llvm.aarch64.neon.fmlsl2
-    1, // llvm.aarch64.neon.fmulx
-    1, // llvm.aarch64.neon.frecpe
-    1, // llvm.aarch64.neon.frecps
-    1, // llvm.aarch64.neon.frecpx
-    1, // llvm.aarch64.neon.frintn
-    1, // llvm.aarch64.neon.frsqrte
-    1, // llvm.aarch64.neon.frsqrts
-    2, // llvm.aarch64.neon.ld1x2
-    2, // llvm.aarch64.neon.ld1x3
-    2, // llvm.aarch64.neon.ld1x4
-    2, // llvm.aarch64.neon.ld2
-    2, // llvm.aarch64.neon.ld2lane
-    2, // llvm.aarch64.neon.ld2r
-    2, // llvm.aarch64.neon.ld3
-    2, // llvm.aarch64.neon.ld3lane
-    2, // llvm.aarch64.neon.ld3r
-    2, // llvm.aarch64.neon.ld4
-    2, // llvm.aarch64.neon.ld4lane
-    2, // llvm.aarch64.neon.ld4r
-    1, // llvm.aarch64.neon.pmul
-    1, // llvm.aarch64.neon.pmull
-    1, // llvm.aarch64.neon.pmull64
-    1, // llvm.aarch64.neon.raddhn
-    1, // llvm.aarch64.neon.rbit
-    1, // llvm.aarch64.neon.rshrn
-    1, // llvm.aarch64.neon.rsubhn
-    1, // llvm.aarch64.neon.sabd
-    1, // llvm.aarch64.neon.saddlp
-    1, // llvm.aarch64.neon.saddlv
-    1, // llvm.aarch64.neon.saddv
-    1, // llvm.aarch64.neon.scalar.sqxtn
-    1, // llvm.aarch64.neon.scalar.sqxtun
-    1, // llvm.aarch64.neon.scalar.uqxtn
-    1, // llvm.aarch64.neon.sdot
-    1, // llvm.aarch64.neon.shadd
-    1, // llvm.aarch64.neon.shll
-    1, // llvm.aarch64.neon.shsub
-    1, // llvm.aarch64.neon.smax
-    1, // llvm.aarch64.neon.smaxp
-    1, // llvm.aarch64.neon.smaxv
-    1, // llvm.aarch64.neon.smin
-    1, // llvm.aarch64.neon.sminp
-    1, // llvm.aarch64.neon.sminv
-    1, // llvm.aarch64.neon.smull
-    1, // llvm.aarch64.neon.sqabs
-    1, // llvm.aarch64.neon.sqadd
-    1, // llvm.aarch64.neon.sqdmulh
-    1, // llvm.aarch64.neon.sqdmull
-    1, // llvm.aarch64.neon.sqdmulls.scalar
-    1, // llvm.aarch64.neon.sqneg
-    1, // llvm.aarch64.neon.sqrdmulh
-    1, // llvm.aarch64.neon.sqrshl
-    1, // llvm.aarch64.neon.sqrshrn
-    1, // llvm.aarch64.neon.sqrshrun
-    1, // llvm.aarch64.neon.sqshl
-    1, // llvm.aarch64.neon.sqshlu
-    1, // llvm.aarch64.neon.sqshrn
-    1, // llvm.aarch64.neon.sqshrun
-    1, // llvm.aarch64.neon.sqsub
-    1, // llvm.aarch64.neon.sqxtn
-    1, // llvm.aarch64.neon.sqxtun
-    1, // llvm.aarch64.neon.srhadd
-    1, // llvm.aarch64.neon.srshl
-    1, // llvm.aarch64.neon.sshl
-    1, // llvm.aarch64.neon.sshll
-    46, // llvm.aarch64.neon.st1x2
-    47, // llvm.aarch64.neon.st1x3
-    48, // llvm.aarch64.neon.st1x4
-    46, // llvm.aarch64.neon.st2
-    47, // llvm.aarch64.neon.st2lane
-    47, // llvm.aarch64.neon.st3
-    48, // llvm.aarch64.neon.st3lane
-    48, // llvm.aarch64.neon.st4
-    49, // llvm.aarch64.neon.st4lane
-    1, // llvm.aarch64.neon.subhn
-    1, // llvm.aarch64.neon.suqadd
-    1, // llvm.aarch64.neon.tbl1
-    1, // llvm.aarch64.neon.tbl2
-    1, // llvm.aarch64.neon.tbl3
-    1, // llvm.aarch64.neon.tbl4
-    1, // llvm.aarch64.neon.tbx1
-    1, // llvm.aarch64.neon.tbx2
-    1, // llvm.aarch64.neon.tbx3
-    1, // llvm.aarch64.neon.tbx4
-    1, // llvm.aarch64.neon.uabd
-    1, // llvm.aarch64.neon.uaddlp
-    1, // llvm.aarch64.neon.uaddlv
-    1, // llvm.aarch64.neon.uaddv
-    1, // llvm.aarch64.neon.udot
-    1, // llvm.aarch64.neon.uhadd
-    1, // llvm.aarch64.neon.uhsub
-    1, // llvm.aarch64.neon.umax
-    1, // llvm.aarch64.neon.umaxp
-    1, // llvm.aarch64.neon.umaxv
-    1, // llvm.aarch64.neon.umin
-    1, // llvm.aarch64.neon.uminp
-    1, // llvm.aarch64.neon.uminv
-    1, // llvm.aarch64.neon.umull
-    1, // llvm.aarch64.neon.uqadd
-    1, // llvm.aarch64.neon.uqrshl
-    1, // llvm.aarch64.neon.uqrshrn
-    1, // llvm.aarch64.neon.uqshl
-    1, // llvm.aarch64.neon.uqshrn
-    1, // llvm.aarch64.neon.uqsub
-    1, // llvm.aarch64.neon.uqxtn
-    1, // llvm.aarch64.neon.urecpe
-    1, // llvm.aarch64.neon.urhadd
-    1, // llvm.aarch64.neon.urshl
-    1, // llvm.aarch64.neon.ursqrte
-    1, // llvm.aarch64.neon.ushl
-    1, // llvm.aarch64.neon.ushll
-    1, // llvm.aarch64.neon.usqadd
-    1, // llvm.aarch64.neon.vcopy.lane
-    1, // llvm.aarch64.neon.vcvtfp2fxs
-    1, // llvm.aarch64.neon.vcvtfp2fxu
-    1, // llvm.aarch64.neon.vcvtfp2hf
-    1, // llvm.aarch64.neon.vcvtfxs2fp
-    1, // llvm.aarch64.neon.vcvtfxu2fp
-    1, // llvm.aarch64.neon.vcvthf2fp
-    1, // llvm.aarch64.neon.vsli
-    1, // llvm.aarch64.neon.vsri
-    1, // llvm.aarch64.sdiv
-    1, // llvm.aarch64.sisd.fabd
-    1, // llvm.aarch64.sisd.fcvtxn
-    3, // llvm.aarch64.space
-    50, // llvm.aarch64.stg
-    3, // llvm.aarch64.stlxp
-    3, // llvm.aarch64.stlxr
-    3, // llvm.aarch64.stxp
-    3, // llvm.aarch64.stxr
-    1, // llvm.aarch64.subp
-    1, // llvm.aarch64.udiv
-    4, // llvm.amdgcn.alignbit
-    4, // llvm.amdgcn.alignbyte
-    51, // llvm.amdgcn.atomic.dec
-    51, // llvm.amdgcn.atomic.inc
-    52, // llvm.amdgcn.buffer.atomic.add
-    52, // llvm.amdgcn.buffer.atomic.and
-    53, // llvm.amdgcn.buffer.atomic.cmpswap
-    52, // llvm.amdgcn.buffer.atomic.or
-    52, // llvm.amdgcn.buffer.atomic.smax
-    52, // llvm.amdgcn.buffer.atomic.smin
-    52, // llvm.amdgcn.buffer.atomic.sub
-    52, // llvm.amdgcn.buffer.atomic.swap
-    52, // llvm.amdgcn.buffer.atomic.umax
-    52, // llvm.amdgcn.buffer.atomic.umin
-    52, // llvm.amdgcn.buffer.atomic.xor
-    54, // llvm.amdgcn.buffer.load
-    54, // llvm.amdgcn.buffer.load.format
-    55, // llvm.amdgcn.buffer.store
-    55, // llvm.amdgcn.buffer.store.format
-    3, // llvm.amdgcn.buffer.wbinvl1
-    3, // llvm.amdgcn.buffer.wbinvl1.sc
-    3, // llvm.amdgcn.buffer.wbinvl1.vol
-    4, // llvm.amdgcn.class
-    4, // llvm.amdgcn.cos
-    4, // llvm.amdgcn.cubeid
-    4, // llvm.amdgcn.cubema
-    4, // llvm.amdgcn.cubesc
-    4, // llvm.amdgcn.cubetc
-    4, // llvm.amdgcn.cvt.pk.i16
-    4, // llvm.amdgcn.cvt.pk.u16
-    4, // llvm.amdgcn.cvt.pk.u8.f32
-    4, // llvm.amdgcn.cvt.pknorm.i16
-    4, // llvm.amdgcn.cvt.pknorm.u16
-    4, // llvm.amdgcn.cvt.pkrtz
-    4, // llvm.amdgcn.dispatch.id
-    4, // llvm.amdgcn.dispatch.ptr
-    4, // llvm.amdgcn.div.fixup
-    4, // llvm.amdgcn.div.fmas
-    41, // llvm.amdgcn.div.scale
-    56, // llvm.amdgcn.ds.append
-    57, // llvm.amdgcn.ds.bpermute
-    56, // llvm.amdgcn.ds.consume
-    51, // llvm.amdgcn.ds.fadd
-    51, // llvm.amdgcn.ds.fmax
-    51, // llvm.amdgcn.ds.fmin
-    58, // llvm.amdgcn.ds.gws.barrier
-    59, // llvm.amdgcn.ds.gws.init
-    58, // llvm.amdgcn.ds.gws.sema.br
-    58, // llvm.amdgcn.ds.gws.sema.p
-    58, // llvm.amdgcn.ds.gws.sema.release.all
-    58, // llvm.amdgcn.ds.gws.sema.v
-    60, // llvm.amdgcn.ds.ordered.add
-    60, // llvm.amdgcn.ds.ordered.swap
-    57, // llvm.amdgcn.ds.permute
-    61, // llvm.amdgcn.ds.swizzle
-    62, // llvm.amdgcn.else
-    62, // llvm.amdgcn.end.cf
-    63, // llvm.amdgcn.exp
-    64, // llvm.amdgcn.exp.compr
-    65, // llvm.amdgcn.fcmp
-    4, // llvm.amdgcn.fdiv.fast
-    66, // llvm.amdgcn.fdot2
-    4, // llvm.amdgcn.fmad.ftz
-    4, // llvm.amdgcn.fmed3
-    4, // llvm.amdgcn.fmul.legacy
-    4, // llvm.amdgcn.fract
-    4, // llvm.amdgcn.frexp.exp
-    4, // llvm.amdgcn.frexp.mant
-    4, // llvm.amdgcn.groupstaticsize
-    65, // llvm.amdgcn.icmp
-    62, // llvm.amdgcn.if
-    57, // llvm.amdgcn.if.break
-    67, // llvm.amdgcn.image.atomic.add.1d
-    68, // llvm.amdgcn.image.atomic.add.1darray
-    68, // llvm.amdgcn.image.atomic.add.2d
-    69, // llvm.amdgcn.image.atomic.add.2darray
-    70, // llvm.amdgcn.image.atomic.add.2darraymsaa
-    69, // llvm.amdgcn.image.atomic.add.2dmsaa
-    69, // llvm.amdgcn.image.atomic.add.3d
-    69, // llvm.amdgcn.image.atomic.add.cube
-    67, // llvm.amdgcn.image.atomic.and.1d
-    68, // llvm.amdgcn.image.atomic.and.1darray
-    68, // llvm.amdgcn.image.atomic.and.2d
-    69, // llvm.amdgcn.image.atomic.and.2darray
-    70, // llvm.amdgcn.image.atomic.and.2darraymsaa
-    69, // llvm.amdgcn.image.atomic.and.2dmsaa
-    69, // llvm.amdgcn.image.atomic.and.3d
-    69, // llvm.amdgcn.image.atomic.and.cube
-    68, // llvm.amdgcn.image.atomic.cmpswap.1d
-    69, // llvm.amdgcn.image.atomic.cmpswap.1darray
-    69, // llvm.amdgcn.image.atomic.cmpswap.2d
-    70, // llvm.amdgcn.image.atomic.cmpswap.2darray
-    71, // llvm.amdgcn.image.atomic.cmpswap.2darraymsaa
-    70, // llvm.amdgcn.image.atomic.cmpswap.2dmsaa
-    70, // llvm.amdgcn.image.atomic.cmpswap.3d
-    70, // llvm.amdgcn.image.atomic.cmpswap.cube
-    67, // llvm.amdgcn.image.atomic.dec.1d
-    68, // llvm.amdgcn.image.atomic.dec.1darray
-    68, // llvm.amdgcn.image.atomic.dec.2d
-    69, // llvm.amdgcn.image.atomic.dec.2darray
-    70, // llvm.amdgcn.image.atomic.dec.2darraymsaa
-    69, // llvm.amdgcn.image.atomic.dec.2dmsaa
-    69, // llvm.amdgcn.image.atomic.dec.3d
-    69, // llvm.amdgcn.image.atomic.dec.cube
-    67, // llvm.amdgcn.image.atomic.inc.1d
-    68, // llvm.amdgcn.image.atomic.inc.1darray
-    68, // llvm.amdgcn.image.atomic.inc.2d
-    69, // llvm.amdgcn.image.atomic.inc.2darray
-    70, // llvm.amdgcn.image.atomic.inc.2darraymsaa
-    69, // llvm.amdgcn.image.atomic.inc.2dmsaa
-    69, // llvm.amdgcn.image.atomic.inc.3d
-    69, // llvm.amdgcn.image.atomic.inc.cube
-    67, // llvm.amdgcn.image.atomic.or.1d
-    68, // llvm.amdgcn.image.atomic.or.1darray
-    68, // llvm.amdgcn.image.atomic.or.2d
-    69, // llvm.amdgcn.image.atomic.or.2darray
-    70, // llvm.amdgcn.image.atomic.or.2darraymsaa
-    69, // llvm.amdgcn.image.atomic.or.2dmsaa
-    69, // llvm.amdgcn.image.atomic.or.3d
-    69, // llvm.amdgcn.image.atomic.or.cube
-    67, // llvm.amdgcn.image.atomic.smax.1d
-    68, // llvm.amdgcn.image.atomic.smax.1darray
-    68, // llvm.amdgcn.image.atomic.smax.2d
-    69, // llvm.amdgcn.image.atomic.smax.2darray
-    70, // llvm.amdgcn.image.atomic.smax.2darraymsaa
-    69, // llvm.amdgcn.image.atomic.smax.2dmsaa
-    69, // llvm.amdgcn.image.atomic.smax.3d
-    69, // llvm.amdgcn.image.atomic.smax.cube
-    67, // llvm.amdgcn.image.atomic.smin.1d
-    68, // llvm.amdgcn.image.atomic.smin.1darray
-    68, // llvm.amdgcn.image.atomic.smin.2d
-    69, // llvm.amdgcn.image.atomic.smin.2darray
-    70, // llvm.amdgcn.image.atomic.smin.2darraymsaa
-    69, // llvm.amdgcn.image.atomic.smin.2dmsaa
-    69, // llvm.amdgcn.image.atomic.smin.3d
-    69, // llvm.amdgcn.image.atomic.smin.cube
-    67, // llvm.amdgcn.image.atomic.sub.1d
-    68, // llvm.amdgcn.image.atomic.sub.1darray
-    68, // llvm.amdgcn.image.atomic.sub.2d
-    69, // llvm.amdgcn.image.atomic.sub.2darray
-    70, // llvm.amdgcn.image.atomic.sub.2darraymsaa
-    69, // llvm.amdgcn.image.atomic.sub.2dmsaa
-    69, // llvm.amdgcn.image.atomic.sub.3d
-    69, // llvm.amdgcn.image.atomic.sub.cube
-    67, // llvm.amdgcn.image.atomic.swap.1d
-    68, // llvm.amdgcn.image.atomic.swap.1darray
-    68, // llvm.amdgcn.image.atomic.swap.2d
-    69, // llvm.amdgcn.image.atomic.swap.2darray
-    70, // llvm.amdgcn.image.atomic.swap.2darraymsaa
-    69, // llvm.amdgcn.image.atomic.swap.2dmsaa
-    69, // llvm.amdgcn.image.atomic.swap.3d
-    69, // llvm.amdgcn.image.atomic.swap.cube
-    67, // llvm.amdgcn.image.atomic.umax.1d
-    68, // llvm.amdgcn.image.atomic.umax.1darray
-    68, // llvm.amdgcn.image.atomic.umax.2d
-    69, // llvm.amdgcn.image.atomic.umax.2darray
-    70, // llvm.amdgcn.image.atomic.umax.2darraymsaa
-    69, // llvm.amdgcn.image.atomic.umax.2dmsaa
-    69, // llvm.amdgcn.image.atomic.umax.3d
-    69, // llvm.amdgcn.image.atomic.umax.cube
-    67, // llvm.amdgcn.image.atomic.umin.1d
-    68, // llvm.amdgcn.image.atomic.umin.1darray
-    68, // llvm.amdgcn.image.atomic.umin.2d
-    69, // llvm.amdgcn.image.atomic.umin.2darray
-    70, // llvm.amdgcn.image.atomic.umin.2darraymsaa
-    69, // llvm.amdgcn.image.atomic.umin.2dmsaa
-    69, // llvm.amdgcn.image.atomic.umin.3d
-    69, // llvm.amdgcn.image.atomic.umin.cube
-    67, // llvm.amdgcn.image.atomic.xor.1d
-    68, // llvm.amdgcn.image.atomic.xor.1darray
-    68, // llvm.amdgcn.image.atomic.xor.2d
-    69, // llvm.amdgcn.image.atomic.xor.2darray
-    70, // llvm.amdgcn.image.atomic.xor.2darraymsaa
-    69, // llvm.amdgcn.image.atomic.xor.2dmsaa
-    69, // llvm.amdgcn.image.atomic.xor.3d
-    69, // llvm.amdgcn.image.atomic.xor.cube
-    72, // llvm.amdgcn.image.gather4.2d
-    73, // llvm.amdgcn.image.gather4.2darray
-    73, // llvm.amdgcn.image.gather4.b.2d
-    74, // llvm.amdgcn.image.gather4.b.2darray
-    74, // llvm.amdgcn.image.gather4.b.cl.2d
-    75, // llvm.amdgcn.image.gather4.b.cl.2darray
-    75, // llvm.amdgcn.image.gather4.b.cl.cube
-    75, // llvm.amdgcn.image.gather4.b.cl.o.2d
-    76, // llvm.amdgcn.image.gather4.b.cl.o.2darray
-    76, // llvm.amdgcn.image.gather4.b.cl.o.cube
-    74, // llvm.amdgcn.image.gather4.b.cube
-    74, // llvm.amdgcn.image.gather4.b.o.2d
-    75, // llvm.amdgcn.image.gather4.b.o.2darray
-    75, // llvm.amdgcn.image.gather4.b.o.cube
-    73, // llvm.amdgcn.image.gather4.c.2d
-    74, // llvm.amdgcn.image.gather4.c.2darray
-    74, // llvm.amdgcn.image.gather4.c.b.2d
-    75, // llvm.amdgcn.image.gather4.c.b.2darray
-    75, // llvm.amdgcn.image.gather4.c.b.cl.2d
-    76, // llvm.amdgcn.image.gather4.c.b.cl.2darray
-    76, // llvm.amdgcn.image.gather4.c.b.cl.cube
-    76, // llvm.amdgcn.image.gather4.c.b.cl.o.2d
-    77, // llvm.amdgcn.image.gather4.c.b.cl.o.2darray
-    77, // llvm.amdgcn.image.gather4.c.b.cl.o.cube
-    75, // llvm.amdgcn.image.gather4.c.b.cube
-    75, // llvm.amdgcn.image.gather4.c.b.o.2d
-    76, // llvm.amdgcn.image.gather4.c.b.o.2darray
-    76, // llvm.amdgcn.image.gather4.c.b.o.cube
-    74, // llvm.amdgcn.image.gather4.c.cl.2d
-    75, // llvm.amdgcn.image.gather4.c.cl.2darray
-    75, // llvm.amdgcn.image.gather4.c.cl.cube
-    75, // llvm.amdgcn.image.gather4.c.cl.o.2d
-    76, // llvm.amdgcn.image.gather4.c.cl.o.2darray
-    76, // llvm.amdgcn.image.gather4.c.cl.o.cube
-    74, // llvm.amdgcn.image.gather4.c.cube
-    74, // llvm.amdgcn.image.gather4.c.l.2d
-    75, // llvm.amdgcn.image.gather4.c.l.2darray
-    75, // llvm.amdgcn.image.gather4.c.l.cube
-    75, // llvm.amdgcn.image.gather4.c.l.o.2d
-    76, // llvm.amdgcn.image.gather4.c.l.o.2darray
-    76, // llvm.amdgcn.image.gather4.c.l.o.cube
-    73, // llvm.amdgcn.image.gather4.c.lz.2d
-    74, // llvm.amdgcn.image.gather4.c.lz.2darray
-    74, // llvm.amdgcn.image.gather4.c.lz.cube
-    74, // llvm.amdgcn.image.gather4.c.lz.o.2d
-    75, // llvm.amdgcn.image.gather4.c.lz.o.2darray
-    75, // llvm.amdgcn.image.gather4.c.lz.o.cube
-    74, // llvm.amdgcn.image.gather4.c.o.2d
-    75, // llvm.amdgcn.image.gather4.c.o.2darray
-    75, // llvm.amdgcn.image.gather4.c.o.cube
-    73, // llvm.amdgcn.image.gather4.cl.2d
-    74, // llvm.amdgcn.image.gather4.cl.2darray
-    74, // llvm.amdgcn.image.gather4.cl.cube
-    74, // llvm.amdgcn.image.gather4.cl.o.2d
-    75, // llvm.amdgcn.image.gather4.cl.o.2darray
-    75, // llvm.amdgcn.image.gather4.cl.o.cube
-    73, // llvm.amdgcn.image.gather4.cube
-    73, // llvm.amdgcn.image.gather4.l.2d
-    74, // llvm.amdgcn.image.gather4.l.2darray
-    74, // llvm.amdgcn.image.gather4.l.cube
-    74, // llvm.amdgcn.image.gather4.l.o.2d
-    75, // llvm.amdgcn.image.gather4.l.o.2darray
-    75, // llvm.amdgcn.image.gather4.l.o.cube
-    72, // llvm.amdgcn.image.gather4.lz.2d
-    73, // llvm.amdgcn.image.gather4.lz.2darray
-    73, // llvm.amdgcn.image.gather4.lz.cube
-    73, // llvm.amdgcn.image.gather4.lz.o.2d
-    74, // llvm.amdgcn.image.gather4.lz.o.2darray
-    74, // llvm.amdgcn.image.gather4.lz.o.cube
-    73, // llvm.amdgcn.image.gather4.o.2d
-    74, // llvm.amdgcn.image.gather4.o.2darray
-    74, // llvm.amdgcn.image.gather4.o.cube
-    78, // llvm.amdgcn.image.getlod.1d
-    79, // llvm.amdgcn.image.getlod.1darray
-    79, // llvm.amdgcn.image.getlod.2d
-    80, // llvm.amdgcn.image.getlod.2darray
-    80, // llvm.amdgcn.image.getlod.3d
-    80, // llvm.amdgcn.image.getlod.cube
-    81, // llvm.amdgcn.image.getresinfo.1d
-    81, // llvm.amdgcn.image.getresinfo.1darray
-    81, // llvm.amdgcn.image.getresinfo.2d
-    81, // llvm.amdgcn.image.getresinfo.2darray
-    81, // llvm.amdgcn.image.getresinfo.2darraymsaa
-    81, // llvm.amdgcn.image.getresinfo.2dmsaa
-    81, // llvm.amdgcn.image.getresinfo.3d
-    81, // llvm.amdgcn.image.getresinfo.cube
-    82, // llvm.amdgcn.image.load.1d
-    83, // llvm.amdgcn.image.load.1darray
-    83, // llvm.amdgcn.image.load.2d
-    84, // llvm.amdgcn.image.load.2darray
-    85, // llvm.amdgcn.image.load.2darraymsaa
-    84, // llvm.amdgcn.image.load.2dmsaa
-    84, // llvm.amdgcn.image.load.3d
-    84, // llvm.amdgcn.image.load.cube
-    83, // llvm.amdgcn.image.load.mip.1d
-    84, // llvm.amdgcn.image.load.mip.1darray
-    84, // llvm.amdgcn.image.load.mip.2d
-    85, // llvm.amdgcn.image.load.mip.2darray
-    85, // llvm.amdgcn.image.load.mip.3d
-    85, // llvm.amdgcn.image.load.mip.cube
-    86, // llvm.amdgcn.image.sample.1d
-    72, // llvm.amdgcn.image.sample.1darray
-    72, // llvm.amdgcn.image.sample.2d
-    73, // llvm.amdgcn.image.sample.2darray
-    73, // llvm.amdgcn.image.sample.3d
-    72, // llvm.amdgcn.image.sample.b.1d
-    73, // llvm.amdgcn.image.sample.b.1darray
-    73, // llvm.amdgcn.image.sample.b.2d
-    74, // llvm.amdgcn.image.sample.b.2darray
-    74, // llvm.amdgcn.image.sample.b.3d
-    73, // llvm.amdgcn.image.sample.b.cl.1d
-    74, // llvm.amdgcn.image.sample.b.cl.1darray
-    74, // llvm.amdgcn.image.sample.b.cl.2d
-    75, // llvm.amdgcn.image.sample.b.cl.2darray
-    75, // llvm.amdgcn.image.sample.b.cl.3d
-    75, // llvm.amdgcn.image.sample.b.cl.cube
-    74, // llvm.amdgcn.image.sample.b.cl.o.1d
-    75, // llvm.amdgcn.image.sample.b.cl.o.1darray
-    75, // llvm.amdgcn.image.sample.b.cl.o.2d
-    76, // llvm.amdgcn.image.sample.b.cl.o.2darray
-    76, // llvm.amdgcn.image.sample.b.cl.o.3d
-    76, // llvm.amdgcn.image.sample.b.cl.o.cube
-    74, // llvm.amdgcn.image.sample.b.cube
-    73, // llvm.amdgcn.image.sample.b.o.1d
-    74, // llvm.amdgcn.image.sample.b.o.1darray
-    74, // llvm.amdgcn.image.sample.b.o.2d
-    75, // llvm.amdgcn.image.sample.b.o.2darray
-    75, // llvm.amdgcn.image.sample.b.o.3d
-    75, // llvm.amdgcn.image.sample.b.o.cube
-    72, // llvm.amdgcn.image.sample.c.1d
-    73, // llvm.amdgcn.image.sample.c.1darray
-    73, // llvm.amdgcn.image.sample.c.2d
-    74, // llvm.amdgcn.image.sample.c.2darray
-    74, // llvm.amdgcn.image.sample.c.3d
-    73, // llvm.amdgcn.image.sample.c.b.1d
-    74, // llvm.amdgcn.image.sample.c.b.1darray
-    74, // llvm.amdgcn.image.sample.c.b.2d
-    75, // llvm.amdgcn.image.sample.c.b.2darray
-    75, // llvm.amdgcn.image.sample.c.b.3d
-    74, // llvm.amdgcn.image.sample.c.b.cl.1d
-    75, // llvm.amdgcn.image.sample.c.b.cl.1darray
-    75, // llvm.amdgcn.image.sample.c.b.cl.2d
-    76, // llvm.amdgcn.image.sample.c.b.cl.2darray
-    76, // llvm.amdgcn.image.sample.c.b.cl.3d
-    76, // llvm.amdgcn.image.sample.c.b.cl.cube
-    75, // llvm.amdgcn.image.sample.c.b.cl.o.1d
-    76, // llvm.amdgcn.image.sample.c.b.cl.o.1darray
-    76, // llvm.amdgcn.image.sample.c.b.cl.o.2d
-    77, // llvm.amdgcn.image.sample.c.b.cl.o.2darray
-    77, // llvm.amdgcn.image.sample.c.b.cl.o.3d
-    77, // llvm.amdgcn.image.sample.c.b.cl.o.cube
-    75, // llvm.amdgcn.image.sample.c.b.cube
-    74, // llvm.amdgcn.image.sample.c.b.o.1d
-    75, // llvm.amdgcn.image.sample.c.b.o.1darray
-    75, // llvm.amdgcn.image.sample.c.b.o.2d
-    76, // llvm.amdgcn.image.sample.c.b.o.2darray
-    76, // llvm.amdgcn.image.sample.c.b.o.3d
-    76, // llvm.amdgcn.image.sample.c.b.o.cube
-    74, // llvm.amdgcn.image.sample.c.cd.1d
-    75, // llvm.amdgcn.image.sample.c.cd.1darray
-    77, // llvm.amdgcn.image.sample.c.cd.2d
-    87, // llvm.amdgcn.image.sample.c.cd.2darray
-    88, // llvm.amdgcn.image.sample.c.cd.3d
-    75, // llvm.amdgcn.image.sample.c.cd.cl.1d
-    76, // llvm.amdgcn.image.sample.c.cd.cl.1darray
-    87, // llvm.amdgcn.image.sample.c.cd.cl.2d
-    89, // llvm.amdgcn.image.sample.c.cd.cl.2darray
-    90, // llvm.amdgcn.image.sample.c.cd.cl.3d
-    89, // llvm.amdgcn.image.sample.c.cd.cl.cube
-    76, // llvm.amdgcn.image.sample.c.cd.cl.o.1d
-    77, // llvm.amdgcn.image.sample.c.cd.cl.o.1darray
-    89, // llvm.amdgcn.image.sample.c.cd.cl.o.2d
-    88, // llvm.amdgcn.image.sample.c.cd.cl.o.2darray
-    91, // llvm.amdgcn.image.sample.c.cd.cl.o.3d
-    88, // llvm.amdgcn.image.sample.c.cd.cl.o.cube
-    87, // llvm.amdgcn.image.sample.c.cd.cube
-    75, // llvm.amdgcn.image.sample.c.cd.o.1d
-    76, // llvm.amdgcn.image.sample.c.cd.o.1darray
-    87, // llvm.amdgcn.image.sample.c.cd.o.2d
-    89, // llvm.amdgcn.image.sample.c.cd.o.2darray
-    90, // llvm.amdgcn.image.sample.c.cd.o.3d
-    89, // llvm.amdgcn.image.sample.c.cd.o.cube
-    73, // llvm.amdgcn.image.sample.c.cl.1d
-    74, // llvm.amdgcn.image.sample.c.cl.1darray
-    74, // llvm.amdgcn.image.sample.c.cl.2d
-    75, // llvm.amdgcn.image.sample.c.cl.2darray
-    75, // llvm.amdgcn.image.sample.c.cl.3d
-    75, // llvm.amdgcn.image.sample.c.cl.cube
-    74, // llvm.amdgcn.image.sample.c.cl.o.1d
-    75, // llvm.amdgcn.image.sample.c.cl.o.1darray
-    75, // llvm.amdgcn.image.sample.c.cl.o.2d
-    76, // llvm.amdgcn.image.sample.c.cl.o.2darray
-    76, // llvm.amdgcn.image.sample.c.cl.o.3d
-    76, // llvm.amdgcn.image.sample.c.cl.o.cube
-    74, // llvm.amdgcn.image.sample.c.cube
-    74, // llvm.amdgcn.image.sample.c.d.1d
-    75, // llvm.amdgcn.image.sample.c.d.1darray
-    77, // llvm.amdgcn.image.sample.c.d.2d
-    87, // llvm.amdgcn.image.sample.c.d.2darray
-    88, // llvm.amdgcn.image.sample.c.d.3d
-    75, // llvm.amdgcn.image.sample.c.d.cl.1d
-    76, // llvm.amdgcn.image.sample.c.d.cl.1darray
-    87, // llvm.amdgcn.image.sample.c.d.cl.2d
-    89, // llvm.amdgcn.image.sample.c.d.cl.2darray
-    90, // llvm.amdgcn.image.sample.c.d.cl.3d
-    89, // llvm.amdgcn.image.sample.c.d.cl.cube
-    76, // llvm.amdgcn.image.sample.c.d.cl.o.1d
-    77, // llvm.amdgcn.image.sample.c.d.cl.o.1darray
-    89, // llvm.amdgcn.image.sample.c.d.cl.o.2d
-    88, // llvm.amdgcn.image.sample.c.d.cl.o.2darray
-    91, // llvm.amdgcn.image.sample.c.d.cl.o.3d
-    88, // llvm.amdgcn.image.sample.c.d.cl.o.cube
-    87, // llvm.amdgcn.image.sample.c.d.cube
-    75, // llvm.amdgcn.image.sample.c.d.o.1d
-    76, // llvm.amdgcn.image.sample.c.d.o.1darray
-    87, // llvm.amdgcn.image.sample.c.d.o.2d
-    89, // llvm.amdgcn.image.sample.c.d.o.2darray
-    90, // llvm.amdgcn.image.sample.c.d.o.3d
-    89, // llvm.amdgcn.image.sample.c.d.o.cube
-    73, // llvm.amdgcn.image.sample.c.l.1d
-    74, // llvm.amdgcn.image.sample.c.l.1darray
-    74, // llvm.amdgcn.image.sample.c.l.2d
-    75, // llvm.amdgcn.image.sample.c.l.2darray
-    75, // llvm.amdgcn.image.sample.c.l.3d
-    75, // llvm.amdgcn.image.sample.c.l.cube
-    74, // llvm.amdgcn.image.sample.c.l.o.1d
-    75, // llvm.amdgcn.image.sample.c.l.o.1darray
-    75, // llvm.amdgcn.image.sample.c.l.o.2d
-    76, // llvm.amdgcn.image.sample.c.l.o.2darray
-    76, // llvm.amdgcn.image.sample.c.l.o.3d
-    76, // llvm.amdgcn.image.sample.c.l.o.cube
-    72, // llvm.amdgcn.image.sample.c.lz.1d
-    73, // llvm.amdgcn.image.sample.c.lz.1darray
-    73, // llvm.amdgcn.image.sample.c.lz.2d
-    74, // llvm.amdgcn.image.sample.c.lz.2darray
-    74, // llvm.amdgcn.image.sample.c.lz.3d
-    74, // llvm.amdgcn.image.sample.c.lz.cube
-    73, // llvm.amdgcn.image.sample.c.lz.o.1d
-    74, // llvm.amdgcn.image.sample.c.lz.o.1darray
-    74, // llvm.amdgcn.image.sample.c.lz.o.2d
-    75, // llvm.amdgcn.image.sample.c.lz.o.2darray
-    75, // llvm.amdgcn.image.sample.c.lz.o.3d
-    75, // llvm.amdgcn.image.sample.c.lz.o.cube
-    73, // llvm.amdgcn.image.sample.c.o.1d
-    74, // llvm.amdgcn.image.sample.c.o.1darray
-    74, // llvm.amdgcn.image.sample.c.o.2d
-    75, // llvm.amdgcn.image.sample.c.o.2darray
-    75, // llvm.amdgcn.image.sample.c.o.3d
-    75, // llvm.amdgcn.image.sample.c.o.cube
-    73, // llvm.amdgcn.image.sample.cd.1d
-    74, // llvm.amdgcn.image.sample.cd.1darray
-    76, // llvm.amdgcn.image.sample.cd.2d
-    77, // llvm.amdgcn.image.sample.cd.2darray
-    89, // llvm.amdgcn.image.sample.cd.3d
-    74, // llvm.amdgcn.image.sample.cd.cl.1d
-    75, // llvm.amdgcn.image.sample.cd.cl.1darray
-    77, // llvm.amdgcn.image.sample.cd.cl.2d
-    87, // llvm.amdgcn.image.sample.cd.cl.2darray
-    88, // llvm.amdgcn.image.sample.cd.cl.3d
-    87, // llvm.amdgcn.image.sample.cd.cl.cube
-    75, // llvm.amdgcn.image.sample.cd.cl.o.1d
-    76, // llvm.amdgcn.image.sample.cd.cl.o.1darray
-    87, // llvm.amdgcn.image.sample.cd.cl.o.2d
-    89, // llvm.amdgcn.image.sample.cd.cl.o.2darray
-    90, // llvm.amdgcn.image.sample.cd.cl.o.3d
-    89, // llvm.amdgcn.image.sample.cd.cl.o.cube
-    77, // llvm.amdgcn.image.sample.cd.cube
-    74, // llvm.amdgcn.image.sample.cd.o.1d
-    75, // llvm.amdgcn.image.sample.cd.o.1darray
-    77, // llvm.amdgcn.image.sample.cd.o.2d
-    87, // llvm.amdgcn.image.sample.cd.o.2darray
-    88, // llvm.amdgcn.image.sample.cd.o.3d
-    87, // llvm.amdgcn.image.sample.cd.o.cube
-    72, // llvm.amdgcn.image.sample.cl.1d
-    73, // llvm.amdgcn.image.sample.cl.1darray
-    73, // llvm.amdgcn.image.sample.cl.2d
-    74, // llvm.amdgcn.image.sample.cl.2darray
-    74, // llvm.amdgcn.image.sample.cl.3d
-    74, // llvm.amdgcn.image.sample.cl.cube
-    73, // llvm.amdgcn.image.sample.cl.o.1d
-    74, // llvm.amdgcn.image.sample.cl.o.1darray
-    74, // llvm.amdgcn.image.sample.cl.o.2d
-    75, // llvm.amdgcn.image.sample.cl.o.2darray
-    75, // llvm.amdgcn.image.sample.cl.o.3d
-    75, // llvm.amdgcn.image.sample.cl.o.cube
-    73, // llvm.amdgcn.image.sample.cube
-    73, // llvm.amdgcn.image.sample.d.1d
-    74, // llvm.amdgcn.image.sample.d.1darray
-    76, // llvm.amdgcn.image.sample.d.2d
-    77, // llvm.amdgcn.image.sample.d.2darray
-    89, // llvm.amdgcn.image.sample.d.3d
-    74, // llvm.amdgcn.image.sample.d.cl.1d
-    75, // llvm.amdgcn.image.sample.d.cl.1darray
-    77, // llvm.amdgcn.image.sample.d.cl.2d
-    87, // llvm.amdgcn.image.sample.d.cl.2darray
-    88, // llvm.amdgcn.image.sample.d.cl.3d
-    87, // llvm.amdgcn.image.sample.d.cl.cube
-    75, // llvm.amdgcn.image.sample.d.cl.o.1d
-    76, // llvm.amdgcn.image.sample.d.cl.o.1darray
-    87, // llvm.amdgcn.image.sample.d.cl.o.2d
-    89, // llvm.amdgcn.image.sample.d.cl.o.2darray
-    90, // llvm.amdgcn.image.sample.d.cl.o.3d
-    89, // llvm.amdgcn.image.sample.d.cl.o.cube
-    77, // llvm.amdgcn.image.sample.d.cube
-    74, // llvm.amdgcn.image.sample.d.o.1d
-    75, // llvm.amdgcn.image.sample.d.o.1darray
-    77, // llvm.amdgcn.image.sample.d.o.2d
-    87, // llvm.amdgcn.image.sample.d.o.2darray
-    88, // llvm.amdgcn.image.sample.d.o.3d
-    87, // llvm.amdgcn.image.sample.d.o.cube
-    72, // llvm.amdgcn.image.sample.l.1d
-    73, // llvm.amdgcn.image.sample.l.1darray
-    73, // llvm.amdgcn.image.sample.l.2d
-    74, // llvm.amdgcn.image.sample.l.2darray
-    74, // llvm.amdgcn.image.sample.l.3d
-    74, // llvm.amdgcn.image.sample.l.cube
-    73, // llvm.amdgcn.image.sample.l.o.1d
-    74, // llvm.amdgcn.image.sample.l.o.1darray
-    74, // llvm.amdgcn.image.sample.l.o.2d
-    75, // llvm.amdgcn.image.sample.l.o.2darray
-    75, // llvm.amdgcn.image.sample.l.o.3d
-    75, // llvm.amdgcn.image.sample.l.o.cube
-    86, // llvm.amdgcn.image.sample.lz.1d
-    72, // llvm.amdgcn.image.sample.lz.1darray
-    72, // llvm.amdgcn.image.sample.lz.2d
-    73, // llvm.amdgcn.image.sample.lz.2darray
-    73, // llvm.amdgcn.image.sample.lz.3d
-    73, // llvm.amdgcn.image.sample.lz.cube
-    72, // llvm.amdgcn.image.sample.lz.o.1d
-    73, // llvm.amdgcn.image.sample.lz.o.1darray
-    73, // llvm.amdgcn.image.sample.lz.o.2d
-    74, // llvm.amdgcn.image.sample.lz.o.2darray
-    74, // llvm.amdgcn.image.sample.lz.o.3d
-    74, // llvm.amdgcn.image.sample.lz.o.cube
-    72, // llvm.amdgcn.image.sample.o.1d
-    73, // llvm.amdgcn.image.sample.o.1darray
-    73, // llvm.amdgcn.image.sample.o.2d
-    74, // llvm.amdgcn.image.sample.o.2darray
-    74, // llvm.amdgcn.image.sample.o.3d
-    74, // llvm.amdgcn.image.sample.o.cube
-    92, // llvm.amdgcn.image.store.1d
-    93, // llvm.amdgcn.image.store.1darray
-    93, // llvm.amdgcn.image.store.2d
-    94, // llvm.amdgcn.image.store.2darray
-    95, // llvm.amdgcn.image.store.2darraymsaa
-    94, // llvm.amdgcn.image.store.2dmsaa
-    94, // llvm.amdgcn.image.store.3d
-    94, // llvm.amdgcn.image.store.cube
-    93, // llvm.amdgcn.image.store.mip.1d
-    94, // llvm.amdgcn.image.store.mip.1darray
-    94, // llvm.amdgcn.image.store.mip.2d
-    95, // llvm.amdgcn.image.store.mip.2darray
-    95, // llvm.amdgcn.image.store.mip.3d
-    95, // llvm.amdgcn.image.store.mip.cube
-    4, // llvm.amdgcn.implicit.buffer.ptr
-    4, // llvm.amdgcn.implicitarg.ptr
-    96, // llvm.amdgcn.init.exec
-    62, // llvm.amdgcn.init.exec.from.input
-    4, // llvm.amdgcn.interp.mov
-    4, // llvm.amdgcn.interp.p1
-    4, // llvm.amdgcn.interp.p1.f16
-    4, // llvm.amdgcn.interp.p2
-    4, // llvm.amdgcn.interp.p2.f16
-    4, // llvm.amdgcn.kernarg.segment.ptr
-    3, // llvm.amdgcn.kill
-    4, // llvm.amdgcn.ldexp
-    4, // llvm.amdgcn.lerp
-    4, // llvm.amdgcn.log.clamp
-    62, // llvm.amdgcn.loop
-    1, // llvm.amdgcn.mbcnt.hi
-    1, // llvm.amdgcn.mbcnt.lo
-    57, // llvm.amdgcn.mfma.f32.16x16x16f16
-    57, // llvm.amdgcn.mfma.f32.16x16x1f32
-    57, // llvm.amdgcn.mfma.f32.16x16x2bf16
-    57, // llvm.amdgcn.mfma.f32.16x16x4f16
-    57, // llvm.amdgcn.mfma.f32.16x16x4f32
-    57, // llvm.amdgcn.mfma.f32.16x16x8bf16
-    57, // llvm.amdgcn.mfma.f32.32x32x1f32
-    57, // llvm.amdgcn.mfma.f32.32x32x2bf16
-    57, // llvm.amdgcn.mfma.f32.32x32x2f32
-    57, // llvm.amdgcn.mfma.f32.32x32x4bf16
-    57, // llvm.amdgcn.mfma.f32.32x32x4f16
-    57, // llvm.amdgcn.mfma.f32.32x32x8f16
-    57, // llvm.amdgcn.mfma.f32.4x4x1f32
-    57, // llvm.amdgcn.mfma.f32.4x4x2bf16
-    57, // llvm.amdgcn.mfma.f32.4x4x4f16
-    57, // llvm.amdgcn.mfma.i32.16x16x16i8
-    57, // llvm.amdgcn.mfma.i32.16x16x4i8
-    57, // llvm.amdgcn.mfma.i32.32x32x4i8
-    57, // llvm.amdgcn.mfma.i32.32x32x8i8
-    57, // llvm.amdgcn.mfma.i32.4x4x4i8
-    97, // llvm.amdgcn.mov.dpp
-    61, // llvm.amdgcn.mov.dpp8
-    4, // llvm.amdgcn.mqsad.pk.u16.u8
-    4, // llvm.amdgcn.mqsad.u32.u8
-    4, // llvm.amdgcn.msad.u8
-    98, // llvm.amdgcn.permlane16
-    98, // llvm.amdgcn.permlanex16
-    1, // llvm.amdgcn.ps.live
-    4, // llvm.amdgcn.qsad.pk.u16.u8
-    4, // llvm.amdgcn.queue.ptr
-    52, // llvm.amdgcn.raw.buffer.atomic.add
-    52, // llvm.amdgcn.raw.buffer.atomic.and
-    53, // llvm.amdgcn.raw.buffer.atomic.cmpswap
-    52, // llvm.amdgcn.raw.buffer.atomic.or
-    52, // llvm.amdgcn.raw.buffer.atomic.smax
-    52, // llvm.amdgcn.raw.buffer.atomic.smin
-    52, // llvm.amdgcn.raw.buffer.atomic.sub
-    52, // llvm.amdgcn.raw.buffer.atomic.swap
-    52, // llvm.amdgcn.raw.buffer.atomic.umax
-    52, // llvm.amdgcn.raw.buffer.atomic.umin
-    52, // llvm.amdgcn.raw.buffer.atomic.xor
-    99, // llvm.amdgcn.raw.buffer.load
-    99, // llvm.amdgcn.raw.buffer.load.format
-    100, // llvm.amdgcn.raw.buffer.store
-    100, // llvm.amdgcn.raw.buffer.store.format
-    54, // llvm.amdgcn.raw.tbuffer.load
-    55, // llvm.amdgcn.raw.tbuffer.store
-    4, // llvm.amdgcn.rcp
-    4, // llvm.amdgcn.rcp.legacy
-    57, // llvm.amdgcn.readfirstlane
-    57, // llvm.amdgcn.readlane
-    4, // llvm.amdgcn.rsq
-    4, // llvm.amdgcn.rsq.clamp
-    4, // llvm.amdgcn.rsq.legacy
-    62, // llvm.amdgcn.s.barrier
-    27, // llvm.amdgcn.s.buffer.load
-    3, // llvm.amdgcn.s.dcache.inv
-    3, // llvm.amdgcn.s.dcache.inv.vol
-    3, // llvm.amdgcn.s.dcache.wb
-    3, // llvm.amdgcn.s.dcache.wb.vol
-    101, // llvm.amdgcn.s.decperflevel
-    102, // llvm.amdgcn.s.get.waveid.in.workgroup
-    4, // llvm.amdgcn.s.getpc
-    103, // llvm.amdgcn.s.getreg
-    101, // llvm.amdgcn.s.incperflevel
-    3, // llvm.amdgcn.s.memrealtime
-    3, // llvm.amdgcn.s.memtime
-    101, // llvm.amdgcn.s.sendmsg
-    101, // llvm.amdgcn.s.sendmsghalt
-    101, // llvm.amdgcn.s.sleep
-    101, // llvm.amdgcn.s.waitcnt
-    4, // llvm.amdgcn.sad.hi.u8
-    4, // llvm.amdgcn.sad.u16
-    4, // llvm.amdgcn.sad.u8
-    4, // llvm.amdgcn.sbfe
-    66, // llvm.amdgcn.sdot2
-    66, // llvm.amdgcn.sdot4
-    66, // llvm.amdgcn.sdot8
-    57, // llvm.amdgcn.set.inactive
-    4, // llvm.amdgcn.sffbh
-    4, // llvm.amdgcn.sin
-    53, // llvm.amdgcn.struct.buffer.atomic.add
-    53, // llvm.amdgcn.struct.buffer.atomic.and
-    104, // llvm.amdgcn.struct.buffer.atomic.cmpswap
-    53, // llvm.amdgcn.struct.buffer.atomic.or
-    53, // llvm.amdgcn.struct.buffer.atomic.smax
-    53, // llvm.amdgcn.struct.buffer.atomic.smin
-    53, // llvm.amdgcn.struct.buffer.atomic.sub
-    53, // llvm.amdgcn.struct.buffer.atomic.swap
-    53, // llvm.amdgcn.struct.buffer.atomic.umax
-    53, // llvm.amdgcn.struct.buffer.atomic.umin
-    53, // llvm.amdgcn.struct.buffer.atomic.xor
-    105, // llvm.amdgcn.struct.buffer.load
-    105, // llvm.amdgcn.struct.buffer.load.format
-    106, // llvm.amdgcn.struct.buffer.store
-    106, // llvm.amdgcn.struct.buffer.store.format
-    107, // llvm.amdgcn.struct.tbuffer.load
-    108, // llvm.amdgcn.struct.tbuffer.store
-    109, // llvm.amdgcn.tbuffer.load
-    110, // llvm.amdgcn.tbuffer.store
-    4, // llvm.amdgcn.trig.preop
-    4, // llvm.amdgcn.ubfe
-    66, // llvm.amdgcn.udot2
-    66, // llvm.amdgcn.udot4
-    66, // llvm.amdgcn.udot8
-    62, // llvm.amdgcn.unreachable
-    111, // llvm.amdgcn.update.dpp
-    62, // llvm.amdgcn.wave.barrier
-    4, // llvm.amdgcn.wavefrontsize
-    4, // llvm.amdgcn.workgroup.id.x
-    4, // llvm.amdgcn.workgroup.id.y
-    4, // llvm.amdgcn.workgroup.id.z
-    4, // llvm.amdgcn.workitem.id.x
-    4, // llvm.amdgcn.workitem.id.y
-    4, // llvm.amdgcn.workitem.id.z
-    4, // llvm.amdgcn.wqm
-    57, // llvm.amdgcn.wqm.vote
-    57, // llvm.amdgcn.writelane
-    112, // llvm.amdgcn.wwm
-    113, // llvm.arm.cdp
-    113, // llvm.arm.cdp2
-    3, // llvm.arm.clrex
-    1, // llvm.arm.cmse.tt
-    1, // llvm.arm.cmse.tta
-    1, // llvm.arm.cmse.ttat
-    1, // llvm.arm.cmse.ttt
-    1, // llvm.arm.crc32b
-    1, // llvm.arm.crc32cb
-    1, // llvm.arm.crc32ch
-    1, // llvm.arm.crc32cw
-    1, // llvm.arm.crc32h
-    1, // llvm.arm.crc32w
-    3, // llvm.arm.dbg
-    3, // llvm.arm.dmb
-    3, // llvm.arm.dsb
-    3, // llvm.arm.get.fpscr
-    114, // llvm.arm.gnu.eabi.mcount
-    3, // llvm.arm.hint
-    3, // llvm.arm.isb
-    3, // llvm.arm.ldaex
-    3, // llvm.arm.ldaexd
-    115, // llvm.arm.ldc
-    115, // llvm.arm.ldc2
-    115, // llvm.arm.ldc2l
-    115, // llvm.arm.ldcl
-    3, // llvm.arm.ldrex
-    3, // llvm.arm.ldrexd
-    116, // llvm.arm.mcr
-    116, // llvm.arm.mcr2
-    117, // llvm.arm.mcrr
-    117, // llvm.arm.mcrr2
-    118, // llvm.arm.mrc
-    118, // llvm.arm.mrc2
-    119, // llvm.arm.mrrc
-    119, // llvm.arm.mrrc2
-    1, // llvm.arm.neon.aesd
-    1, // llvm.arm.neon.aese
-    1, // llvm.arm.neon.aesimc
-    1, // llvm.arm.neon.aesmc
-    1, // llvm.arm.neon.sdot
-    1, // llvm.arm.neon.sha1c
-    1, // llvm.arm.neon.sha1h
-    1, // llvm.arm.neon.sha1m
-    1, // llvm.arm.neon.sha1p
-    1, // llvm.arm.neon.sha1su0
-    1, // llvm.arm.neon.sha1su1
-    1, // llvm.arm.neon.sha256h
-    1, // llvm.arm.neon.sha256h2
-    1, // llvm.arm.neon.sha256su0
-    1, // llvm.arm.neon.sha256su1
-    1, // llvm.arm.neon.udot
-    1, // llvm.arm.neon.vabds
-    1, // llvm.arm.neon.vabdu
-    1, // llvm.arm.neon.vabs
-    1, // llvm.arm.neon.vacge
-    1, // llvm.arm.neon.vacgt
-    1, // llvm.arm.neon.vbsl
-    1, // llvm.arm.neon.vcls
-    1, // llvm.arm.neon.vcvtas
-    1, // llvm.arm.neon.vcvtau
-    1, // llvm.arm.neon.vcvtfp2fxs
-    1, // llvm.arm.neon.vcvtfp2fxu
-    1, // llvm.arm.neon.vcvtfp2hf
-    1, // llvm.arm.neon.vcvtfxs2fp
-    1, // llvm.arm.neon.vcvtfxu2fp
-    1, // llvm.arm.neon.vcvthf2fp
-    1, // llvm.arm.neon.vcvtms
-    1, // llvm.arm.neon.vcvtmu
-    1, // llvm.arm.neon.vcvtns
-    1, // llvm.arm.neon.vcvtnu
-    1, // llvm.arm.neon.vcvtps
-    1, // llvm.arm.neon.vcvtpu
-    1, // llvm.arm.neon.vhadds
-    1, // llvm.arm.neon.vhaddu
-    1, // llvm.arm.neon.vhsubs
-    1, // llvm.arm.neon.vhsubu
-    2, // llvm.arm.neon.vld1
-    2, // llvm.arm.neon.vld1x2
-    2, // llvm.arm.neon.vld1x3
-    2, // llvm.arm.neon.vld1x4
-    2, // llvm.arm.neon.vld2
-    2, // llvm.arm.neon.vld2dup
-    2, // llvm.arm.neon.vld2lane
-    2, // llvm.arm.neon.vld3
-    2, // llvm.arm.neon.vld3dup
-    2, // llvm.arm.neon.vld3lane
-    2, // llvm.arm.neon.vld4
-    2, // llvm.arm.neon.vld4dup
-    2, // llvm.arm.neon.vld4lane
-    1, // llvm.arm.neon.vmaxnm
-    1, // llvm.arm.neon.vmaxs
-    1, // llvm.arm.neon.vmaxu
-    1, // llvm.arm.neon.vminnm
-    1, // llvm.arm.neon.vmins
-    1, // llvm.arm.neon.vminu
-    1, // llvm.arm.neon.vmullp
-    1, // llvm.arm.neon.vmulls
-    1, // llvm.arm.neon.vmullu
-    1, // llvm.arm.neon.vmulp
-    1, // llvm.arm.neon.vpadals
-    1, // llvm.arm.neon.vpadalu
-    1, // llvm.arm.neon.vpadd
-    1, // llvm.arm.neon.vpaddls
-    1, // llvm.arm.neon.vpaddlu
-    1, // llvm.arm.neon.vpmaxs
-    1, // llvm.arm.neon.vpmaxu
-    1, // llvm.arm.neon.vpmins
-    1, // llvm.arm.neon.vpminu
-    1, // llvm.arm.neon.vqabs
-    1, // llvm.arm.neon.vqadds
-    1, // llvm.arm.neon.vqaddu
-    1, // llvm.arm.neon.vqdmulh
-    1, // llvm.arm.neon.vqdmull
-    1, // llvm.arm.neon.vqmovns
-    1, // llvm.arm.neon.vqmovnsu
-    1, // llvm.arm.neon.vqmovnu
-    1, // llvm.arm.neon.vqneg
-    1, // llvm.arm.neon.vqrdmulh
-    1, // llvm.arm.neon.vqrshiftns
-    1, // llvm.arm.neon.vqrshiftnsu
-    1, // llvm.arm.neon.vqrshiftnu
-    1, // llvm.arm.neon.vqrshifts
-    1, // llvm.arm.neon.vqrshiftu
-    1, // llvm.arm.neon.vqshiftns
-    1, // llvm.arm.neon.vqshiftnsu
-    1, // llvm.arm.neon.vqshiftnu
-    1, // llvm.arm.neon.vqshifts
-    1, // llvm.arm.neon.vqshiftsu
-    1, // llvm.arm.neon.vqshiftu
-    1, // llvm.arm.neon.vqsubs
-    1, // llvm.arm.neon.vqsubu
-    1, // llvm.arm.neon.vraddhn
-    1, // llvm.arm.neon.vrecpe
-    1, // llvm.arm.neon.vrecps
-    1, // llvm.arm.neon.vrhadds
-    1, // llvm.arm.neon.vrhaddu
-    1, // llvm.arm.neon.vrinta
-    1, // llvm.arm.neon.vrintm
-    1, // llvm.arm.neon.vrintn
-    1, // llvm.arm.neon.vrintp
-    1, // llvm.arm.neon.vrintx
-    1, // llvm.arm.neon.vrintz
-    1, // llvm.arm.neon.vrshiftn
-    1, // llvm.arm.neon.vrshifts
-    1, // llvm.arm.neon.vrshiftu
-    1, // llvm.arm.neon.vrsqrte
-    1, // llvm.arm.neon.vrsqrts
-    1, // llvm.arm.neon.vrsubhn
-    1, // llvm.arm.neon.vshiftins
-    1, // llvm.arm.neon.vshifts
-    1, // llvm.arm.neon.vshiftu
-    29, // llvm.arm.neon.vst1
-    23, // llvm.arm.neon.vst1x2
-    23, // llvm.arm.neon.vst1x3
-    23, // llvm.arm.neon.vst1x4
-    29, // llvm.arm.neon.vst2
-    29, // llvm.arm.neon.vst2lane
-    29, // llvm.arm.neon.vst3
-    29, // llvm.arm.neon.vst3lane
-    29, // llvm.arm.neon.vst4
-    29, // llvm.arm.neon.vst4lane
-    1, // llvm.arm.neon.vtbl1
-    1, // llvm.arm.neon.vtbl2
-    1, // llvm.arm.neon.vtbl3
-    1, // llvm.arm.neon.vtbl4
-    1, // llvm.arm.neon.vtbx1
-    1, // llvm.arm.neon.vtbx2
-    1, // llvm.arm.neon.vtbx3
-    1, // llvm.arm.neon.vtbx4
-    1, // llvm.arm.qadd
-    1, // llvm.arm.qadd16
-    1, // llvm.arm.qadd8
-    1, // llvm.arm.qasx
-    1, // llvm.arm.qsax
-    1, // llvm.arm.qsub
-    1, // llvm.arm.qsub16
-    1, // llvm.arm.qsub8
-    3, // llvm.arm.sadd16
-    3, // llvm.arm.sadd8
-    3, // llvm.arm.sasx
-    18, // llvm.arm.sel
-    3, // llvm.arm.set.fpscr
-    1, // llvm.arm.shadd16
-    1, // llvm.arm.shadd8
-    1, // llvm.arm.shasx
-    1, // llvm.arm.shsax
-    1, // llvm.arm.shsub16
-    1, // llvm.arm.shsub8
-    1, // llvm.arm.smlabb
-    1, // llvm.arm.smlabt
-    1, // llvm.arm.smlad
-    1, // llvm.arm.smladx
-    1, // llvm.arm.smlald
-    1, // llvm.arm.smlaldx
-    1, // llvm.arm.smlatb
-    1, // llvm.arm.smlatt
-    1, // llvm.arm.smlawb
-    1, // llvm.arm.smlawt
-    1, // llvm.arm.smlsd
-    1, // llvm.arm.smlsdx
-    1, // llvm.arm.smlsld
-    1, // llvm.arm.smlsldx
-    1, // llvm.arm.smuad
-    1, // llvm.arm.smuadx
-    1, // llvm.arm.smulbb
-    1, // llvm.arm.smulbt
-    1, // llvm.arm.smultb
-    1, // llvm.arm.smultt
-    1, // llvm.arm.smulwb
-    1, // llvm.arm.smulwt
-    1, // llvm.arm.smusd
-    1, // llvm.arm.smusdx
-    3, // llvm.arm.space
-    1, // llvm.arm.ssat
-    1, // llvm.arm.ssat16
-    3, // llvm.arm.ssax
-    3, // llvm.arm.ssub16
-    3, // llvm.arm.ssub8
-    115, // llvm.arm.stc
-    115, // llvm.arm.stc2
-    115, // llvm.arm.stc2l
-    115, // llvm.arm.stcl
-    3, // llvm.arm.stlex
-    3, // llvm.arm.stlexd
-    3, // llvm.arm.strex
-    3, // llvm.arm.strexd
-    1, // llvm.arm.sxtab16
-    1, // llvm.arm.sxtb16
-    3, // llvm.arm.uadd16
-    3, // llvm.arm.uadd8
-    3, // llvm.arm.uasx
-    1, // llvm.arm.uhadd16
-    1, // llvm.arm.uhadd8
-    1, // llvm.arm.uhasx
-    1, // llvm.arm.uhsax
-    1, // llvm.arm.uhsub16
-    1, // llvm.arm.uhsub8
-    3, // llvm.arm.undefined
-    1, // llvm.arm.uqadd16
-    1, // llvm.arm.uqadd8
-    1, // llvm.arm.uqasx
-    1, // llvm.arm.uqsax
-    1, // llvm.arm.uqsub16
-    1, // llvm.arm.uqsub8
-    1, // llvm.arm.usad8
-    1, // llvm.arm.usada8
-    1, // llvm.arm.usat
-    1, // llvm.arm.usat16
-    3, // llvm.arm.usax
-    3, // llvm.arm.usub16
-    3, // llvm.arm.usub8
-    1, // llvm.arm.uxtab16
-    1, // llvm.arm.uxtb16
-    1, // llvm.arm.vcvtr
-    1, // llvm.arm.vcvtru
-    18, // llvm.bpf.load.byte
-    18, // llvm.bpf.load.half
-    18, // llvm.bpf.load.word
-    3, // llvm.bpf.pseudo
-    1, // llvm.hexagon.A2.abs
-    1, // llvm.hexagon.A2.absp
-    1, // llvm.hexagon.A2.abssat
-    1, // llvm.hexagon.A2.add
-    1, // llvm.hexagon.A2.addh.h16.hh
-    1, // llvm.hexagon.A2.addh.h16.hl
-    1, // llvm.hexagon.A2.addh.h16.lh
-    1, // llvm.hexagon.A2.addh.h16.ll
-    1, // llvm.hexagon.A2.addh.h16.sat.hh
-    1, // llvm.hexagon.A2.addh.h16.sat.hl
-    1, // llvm.hexagon.A2.addh.h16.sat.lh
-    1, // llvm.hexagon.A2.addh.h16.sat.ll
-    1, // llvm.hexagon.A2.addh.l16.hl
-    1, // llvm.hexagon.A2.addh.l16.ll
-    1, // llvm.hexagon.A2.addh.l16.sat.hl
-    1, // llvm.hexagon.A2.addh.l16.sat.ll
-    40, // llvm.hexagon.A2.addi
-    1, // llvm.hexagon.A2.addp
-    1, // llvm.hexagon.A2.addpsat
-    1, // llvm.hexagon.A2.addsat
-    1, // llvm.hexagon.A2.addsp
-    1, // llvm.hexagon.A2.and
-    40, // llvm.hexagon.A2.andir
-    1, // llvm.hexagon.A2.andp
-    1, // llvm.hexagon.A2.aslh
-    1, // llvm.hexagon.A2.asrh
-    1, // llvm.hexagon.A2.combine.hh
-    1, // llvm.hexagon.A2.combine.hl
-    1, // llvm.hexagon.A2.combine.lh
-    1, // llvm.hexagon.A2.combine.ll
-    120, // llvm.hexagon.A2.combineii
-    1, // llvm.hexagon.A2.combinew
-    1, // llvm.hexagon.A2.max
-    1, // llvm.hexagon.A2.maxp
-    1, // llvm.hexagon.A2.maxu
-    1, // llvm.hexagon.A2.maxup
-    1, // llvm.hexagon.A2.min
-    1, // llvm.hexagon.A2.minp
-    1, // llvm.hexagon.A2.minu
-    1, // llvm.hexagon.A2.minup
-    1, // llvm.hexagon.A2.neg
-    1, // llvm.hexagon.A2.negp
-    1, // llvm.hexagon.A2.negsat
-    1, // llvm.hexagon.A2.not
-    1, // llvm.hexagon.A2.notp
-    1, // llvm.hexagon.A2.or
-    40, // llvm.hexagon.A2.orir
-    1, // llvm.hexagon.A2.orp
-    1, // llvm.hexagon.A2.pxorf
-    1, // llvm.hexagon.A2.roundsat
-    1, // llvm.hexagon.A2.sat
-    1, // llvm.hexagon.A2.satb
-    1, // llvm.hexagon.A2.sath
-    1, // llvm.hexagon.A2.satub
-    1, // llvm.hexagon.A2.satuh
-    1, // llvm.hexagon.A2.sub
-    1, // llvm.hexagon.A2.subh.h16.hh
-    1, // llvm.hexagon.A2.subh.h16.hl
-    1, // llvm.hexagon.A2.subh.h16.lh
-    1, // llvm.hexagon.A2.subh.h16.ll
-    1, // llvm.hexagon.A2.subh.h16.sat.hh
-    1, // llvm.hexagon.A2.subh.h16.sat.hl
-    1, // llvm.hexagon.A2.subh.h16.sat.lh
-    1, // llvm.hexagon.A2.subh.h16.sat.ll
-    1, // llvm.hexagon.A2.subh.l16.hl
-    1, // llvm.hexagon.A2.subh.l16.ll
-    1, // llvm.hexagon.A2.subh.l16.sat.hl
-    1, // llvm.hexagon.A2.subh.l16.sat.ll
-    1, // llvm.hexagon.A2.subp
-    20, // llvm.hexagon.A2.subri
-    1, // llvm.hexagon.A2.subsat
-    1, // llvm.hexagon.A2.svaddh
-    1, // llvm.hexagon.A2.svaddhs
-    1, // llvm.hexagon.A2.svadduhs
-    1, // llvm.hexagon.A2.svavgh
-    1, // llvm.hexagon.A2.svavghs
-    1, // llvm.hexagon.A2.svnavgh
-    1, // llvm.hexagon.A2.svsubh
-    1, // llvm.hexagon.A2.svsubhs
-    1, // llvm.hexagon.A2.svsubuhs
-    1, // llvm.hexagon.A2.swiz
-    1, // llvm.hexagon.A2.sxtb
-    1, // llvm.hexagon.A2.sxth
-    1, // llvm.hexagon.A2.sxtw
-    1, // llvm.hexagon.A2.tfr
-    1, // llvm.hexagon.A2.tfrcrr
-    40, // llvm.hexagon.A2.tfrih
-    40, // llvm.hexagon.A2.tfril
-    1, // llvm.hexagon.A2.tfrp
-    20, // llvm.hexagon.A2.tfrpi
-    1, // llvm.hexagon.A2.tfrrcr
-    20, // llvm.hexagon.A2.tfrsi
-    1, // llvm.hexagon.A2.vabsh
-    1, // llvm.hexagon.A2.vabshsat
-    1, // llvm.hexagon.A2.vabsw
-    1, // llvm.hexagon.A2.vabswsat
-    1, // llvm.hexagon.A2.vaddb.map
-    1, // llvm.hexagon.A2.vaddh
-    1, // llvm.hexagon.A2.vaddhs
-    1, // llvm.hexagon.A2.vaddub
-    1, // llvm.hexagon.A2.vaddubs
-    1, // llvm.hexagon.A2.vadduhs
-    1, // llvm.hexagon.A2.vaddw
-    1, // llvm.hexagon.A2.vaddws
-    1, // llvm.hexagon.A2.vavgh
-    1, // llvm.hexagon.A2.vavghcr
-    1, // llvm.hexagon.A2.vavghr
-    1, // llvm.hexagon.A2.vavgub
-    1, // llvm.hexagon.A2.vavgubr
-    1, // llvm.hexagon.A2.vavguh
-    1, // llvm.hexagon.A2.vavguhr
-    1, // llvm.hexagon.A2.vavguw
-    1, // llvm.hexagon.A2.vavguwr
-    1, // llvm.hexagon.A2.vavgw
-    1, // llvm.hexagon.A2.vavgwcr
-    1, // llvm.hexagon.A2.vavgwr
-    1, // llvm.hexagon.A2.vcmpbeq
-    1, // llvm.hexagon.A2.vcmpbgtu
-    1, // llvm.hexagon.A2.vcmpheq
-    1, // llvm.hexagon.A2.vcmphgt
-    1, // llvm.hexagon.A2.vcmphgtu
-    1, // llvm.hexagon.A2.vcmpweq
-    1, // llvm.hexagon.A2.vcmpwgt
-    1, // llvm.hexagon.A2.vcmpwgtu
-    1, // llvm.hexagon.A2.vconj
-    1, // llvm.hexagon.A2.vmaxb
-    1, // llvm.hexagon.A2.vmaxh
-    1, // llvm.hexagon.A2.vmaxub
-    1, // llvm.hexagon.A2.vmaxuh
-    1, // llvm.hexagon.A2.vmaxuw
-    1, // llvm.hexagon.A2.vmaxw
-    1, // llvm.hexagon.A2.vminb
-    1, // llvm.hexagon.A2.vminh
-    1, // llvm.hexagon.A2.vminub
-    1, // llvm.hexagon.A2.vminuh
-    1, // llvm.hexagon.A2.vminuw
-    1, // llvm.hexagon.A2.vminw
-    1, // llvm.hexagon.A2.vnavgh
-    1, // llvm.hexagon.A2.vnavghcr
-    1, // llvm.hexagon.A2.vnavghr
-    1, // llvm.hexagon.A2.vnavgw
-    1, // llvm.hexagon.A2.vnavgwcr
-    1, // llvm.hexagon.A2.vnavgwr
-    1, // llvm.hexagon.A2.vraddub
-    1, // llvm.hexagon.A2.vraddub.acc
-    1, // llvm.hexagon.A2.vrsadub
-    1, // llvm.hexagon.A2.vrsadub.acc
-    1, // llvm.hexagon.A2.vsubb.map
-    1, // llvm.hexagon.A2.vsubh
-    1, // llvm.hexagon.A2.vsubhs
-    1, // llvm.hexagon.A2.vsubub
-    1, // llvm.hexagon.A2.vsububs
-    1, // llvm.hexagon.A2.vsubuhs
-    1, // llvm.hexagon.A2.vsubw
-    1, // llvm.hexagon.A2.vsubws
-    1, // llvm.hexagon.A2.xor
-    1, // llvm.hexagon.A2.xorp
-    1, // llvm.hexagon.A2.zxtb
-    1, // llvm.hexagon.A2.zxth
-    1, // llvm.hexagon.A4.addp.c
-    1, // llvm.hexagon.A4.andn
-    1, // llvm.hexagon.A4.andnp
-    1, // llvm.hexagon.A4.bitsplit
-    40, // llvm.hexagon.A4.bitspliti
-    1, // llvm.hexagon.A4.boundscheck
-    1, // llvm.hexagon.A4.cmpbeq
-    40, // llvm.hexagon.A4.cmpbeqi
-    1, // llvm.hexagon.A4.cmpbgt
-    40, // llvm.hexagon.A4.cmpbgti
-    1, // llvm.hexagon.A4.cmpbgtu
-    40, // llvm.hexagon.A4.cmpbgtui
-    1, // llvm.hexagon.A4.cmpheq
-    40, // llvm.hexagon.A4.cmpheqi
-    1, // llvm.hexagon.A4.cmphgt
-    40, // llvm.hexagon.A4.cmphgti
-    1, // llvm.hexagon.A4.cmphgtu
-    40, // llvm.hexagon.A4.cmphgtui
-    120, // llvm.hexagon.A4.combineii
-    20, // llvm.hexagon.A4.combineir
-    40, // llvm.hexagon.A4.combineri
-    40, // llvm.hexagon.A4.cround.ri
-    1, // llvm.hexagon.A4.cround.rr
-    1, // llvm.hexagon.A4.modwrapu
-    1, // llvm.hexagon.A4.orn
-    1, // llvm.hexagon.A4.ornp
-    1, // llvm.hexagon.A4.rcmpeq
-    40, // llvm.hexagon.A4.rcmpeqi
-    1, // llvm.hexagon.A4.rcmpneq
-    40, // llvm.hexagon.A4.rcmpneqi
-    40, // llvm.hexagon.A4.round.ri
-    40, // llvm.hexagon.A4.round.ri.sat
-    1, // llvm.hexagon.A4.round.rr
-    1, // llvm.hexagon.A4.round.rr.sat
-    1, // llvm.hexagon.A4.subp.c
-    1, // llvm.hexagon.A4.tfrcpp
-    1, // llvm.hexagon.A4.tfrpcp
-    1, // llvm.hexagon.A4.tlbmatch
-    1, // llvm.hexagon.A4.vcmpbeq.any
-    40, // llvm.hexagon.A4.vcmpbeqi
-    1, // llvm.hexagon.A4.vcmpbgt
-    40, // llvm.hexagon.A4.vcmpbgti
-    40, // llvm.hexagon.A4.vcmpbgtui
-    40, // llvm.hexagon.A4.vcmpheqi
-    40, // llvm.hexagon.A4.vcmphgti
-    40, // llvm.hexagon.A4.vcmphgtui
-    40, // llvm.hexagon.A4.vcmpweqi
-    40, // llvm.hexagon.A4.vcmpwgti
-    40, // llvm.hexagon.A4.vcmpwgtui
-    1, // llvm.hexagon.A4.vrmaxh
-    1, // llvm.hexagon.A4.vrmaxuh
-    1, // llvm.hexagon.A4.vrmaxuw
-    1, // llvm.hexagon.A4.vrmaxw
-    1, // llvm.hexagon.A4.vrminh
-    1, // llvm.hexagon.A4.vrminuh
-    1, // llvm.hexagon.A4.vrminuw
-    1, // llvm.hexagon.A4.vrminw
-    1, // llvm.hexagon.A5.ACS
-    1, // llvm.hexagon.A5.vaddhubs
-    1, // llvm.hexagon.A6.vcmpbeq.notany
-    1, // llvm.hexagon.A6.vminub.RdP
-    1, // llvm.hexagon.C2.all8
-    1, // llvm.hexagon.C2.and
-    1, // llvm.hexagon.C2.andn
-    1, // llvm.hexagon.C2.any8
-    1, // llvm.hexagon.C2.bitsclr
-    40, // llvm.hexagon.C2.bitsclri
-    1, // llvm.hexagon.C2.bitsset
-    1, // llvm.hexagon.C2.cmpeq
-    40, // llvm.hexagon.C2.cmpeqi
-    1, // llvm.hexagon.C2.cmpeqp
-    40, // llvm.hexagon.C2.cmpgei
-    40, // llvm.hexagon.C2.cmpgeui
-    1, // llvm.hexagon.C2.cmpgt
-    40, // llvm.hexagon.C2.cmpgti
-    1, // llvm.hexagon.C2.cmpgtp
-    1, // llvm.hexagon.C2.cmpgtu
-    40, // llvm.hexagon.C2.cmpgtui
-    1, // llvm.hexagon.C2.cmpgtup
-    1, // llvm.hexagon.C2.cmplt
-    1, // llvm.hexagon.C2.cmpltu
-    1, // llvm.hexagon.C2.mask
-    1, // llvm.hexagon.C2.mux
-    39, // llvm.hexagon.C2.muxii
-    27, // llvm.hexagon.C2.muxir
-    40, // llvm.hexagon.C2.muxri
-    1, // llvm.hexagon.C2.not
-    1, // llvm.hexagon.C2.or
-    1, // llvm.hexagon.C2.orn
-    1, // llvm.hexagon.C2.pxfer.map
-    1, // llvm.hexagon.C2.tfrpr
-    1, // llvm.hexagon.C2.tfrrp
-    1, // llvm.hexagon.C2.vitpack
-    1, // llvm.hexagon.C2.vmux
-    1, // llvm.hexagon.C2.xor
-    1, // llvm.hexagon.C4.and.and
-    1, // llvm.hexagon.C4.and.andn
-    1, // llvm.hexagon.C4.and.or
-    1, // llvm.hexagon.C4.and.orn
-    1, // llvm.hexagon.C4.cmplte
-    40, // llvm.hexagon.C4.cmpltei
-    1, // llvm.hexagon.C4.cmplteu
-    40, // llvm.hexagon.C4.cmplteui
-    1, // llvm.hexagon.C4.cmpneq
-    40, // llvm.hexagon.C4.cmpneqi
-    1, // llvm.hexagon.C4.fastcorner9
-    1, // llvm.hexagon.C4.fastcorner9.not
-    1, // llvm.hexagon.C4.nbitsclr
-    40, // llvm.hexagon.C4.nbitsclri
-    1, // llvm.hexagon.C4.nbitsset
-    1, // llvm.hexagon.C4.or.and
-    1, // llvm.hexagon.C4.or.andn
-    1, // llvm.hexagon.C4.or.or
-    1, // llvm.hexagon.C4.or.orn
-    1, // llvm.hexagon.F2.conv.d2df
-    1, // llvm.hexagon.F2.conv.d2sf
-    1, // llvm.hexagon.F2.conv.df2d
-    1, // llvm.hexagon.F2.conv.df2d.chop
-    1, // llvm.hexagon.F2.conv.df2sf
-    1, // llvm.hexagon.F2.conv.df2ud
-    1, // llvm.hexagon.F2.conv.df2ud.chop
-    1, // llvm.hexagon.F2.conv.df2uw
-    1, // llvm.hexagon.F2.conv.df2uw.chop
-    1, // llvm.hexagon.F2.conv.df2w
-    1, // llvm.hexagon.F2.conv.df2w.chop
-    1, // llvm.hexagon.F2.conv.sf2d
-    1, // llvm.hexagon.F2.conv.sf2d.chop
-    1, // llvm.hexagon.F2.conv.sf2df
-    1, // llvm.hexagon.F2.conv.sf2ud
-    1, // llvm.hexagon.F2.conv.sf2ud.chop
-    1, // llvm.hexagon.F2.conv.sf2uw
-    1, // llvm.hexagon.F2.conv.sf2uw.chop
-    1, // llvm.hexagon.F2.conv.sf2w
-    1, // llvm.hexagon.F2.conv.sf2w.chop
-    1, // llvm.hexagon.F2.conv.ud2df
-    1, // llvm.hexagon.F2.conv.ud2sf
-    1, // llvm.hexagon.F2.conv.uw2df
-    1, // llvm.hexagon.F2.conv.uw2sf
-    1, // llvm.hexagon.F2.conv.w2df
-    1, // llvm.hexagon.F2.conv.w2sf
-    121, // llvm.hexagon.F2.dfadd
-    122, // llvm.hexagon.F2.dfclass
-    121, // llvm.hexagon.F2.dfcmpeq
-    121, // llvm.hexagon.F2.dfcmpge
-    121, // llvm.hexagon.F2.dfcmpgt
-    121, // llvm.hexagon.F2.dfcmpuo
-    20, // llvm.hexagon.F2.dfimm.n
-    20, // llvm.hexagon.F2.dfimm.p
-    121, // llvm.hexagon.F2.dfsub
-    121, // llvm.hexagon.F2.sfadd
-    122, // llvm.hexagon.F2.sfclass
-    121, // llvm.hexagon.F2.sfcmpeq
-    121, // llvm.hexagon.F2.sfcmpge
-    121, // llvm.hexagon.F2.sfcmpgt
-    121, // llvm.hexagon.F2.sfcmpuo
-    121, // llvm.hexagon.F2.sffixupd
-    121, // llvm.hexagon.F2.sffixupn
-    121, // llvm.hexagon.F2.sffixupr
-    121, // llvm.hexagon.F2.sffma
-    121, // llvm.hexagon.F2.sffma.lib
-    121, // llvm.hexagon.F2.sffma.sc
-    121, // llvm.hexagon.F2.sffms
-    121, // llvm.hexagon.F2.sffms.lib
-    20, // llvm.hexagon.F2.sfimm.n
-    20, // llvm.hexagon.F2.sfimm.p
-    121, // llvm.hexagon.F2.sfinvsqrta
-    121, // llvm.hexagon.F2.sfmax
-    121, // llvm.hexagon.F2.sfmin
-    121, // llvm.hexagon.F2.sfmpy
-    121, // llvm.hexagon.F2.sfrecipa
-    121, // llvm.hexagon.F2.sfsub
-    18, // llvm.hexagon.L2.loadrb.pbr
-    47, // llvm.hexagon.L2.loadrb.pci
-    46, // llvm.hexagon.L2.loadrb.pcr
-    18, // llvm.hexagon.L2.loadrd.pbr
-    47, // llvm.hexagon.L2.loadrd.pci
-    46, // llvm.hexagon.L2.loadrd.pcr
-    18, // llvm.hexagon.L2.loadrh.pbr
-    47, // llvm.hexagon.L2.loadrh.pci
-    46, // llvm.hexagon.L2.loadrh.pcr
-    18, // llvm.hexagon.L2.loadri.pbr
-    47, // llvm.hexagon.L2.loadri.pci
-    46, // llvm.hexagon.L2.loadri.pcr
-    18, // llvm.hexagon.L2.loadrub.pbr
-    47, // llvm.hexagon.L2.loadrub.pci
-    46, // llvm.hexagon.L2.loadrub.pcr
-    18, // llvm.hexagon.L2.loadruh.pbr
-    47, // llvm.hexagon.L2.loadruh.pci
-    46, // llvm.hexagon.L2.loadruh.pcr
-    23, // llvm.hexagon.L2.loadw.locked
-    23, // llvm.hexagon.L4.loadd.locked
-    1, // llvm.hexagon.M2.acci
-    27, // llvm.hexagon.M2.accii
-    1, // llvm.hexagon.M2.cmaci.s0
-    1, // llvm.hexagon.M2.cmacr.s0
-    1, // llvm.hexagon.M2.cmacs.s0
-    1, // llvm.hexagon.M2.cmacs.s1
-    1, // llvm.hexagon.M2.cmacsc.s0
-    1, // llvm.hexagon.M2.cmacsc.s1
-    1, // llvm.hexagon.M2.cmpyi.s0
-    1, // llvm.hexagon.M2.cmpyr.s0
-    1, // llvm.hexagon.M2.cmpyrs.s0
-    1, // llvm.hexagon.M2.cmpyrs.s1
-    1, // llvm.hexagon.M2.cmpyrsc.s0
-    1, // llvm.hexagon.M2.cmpyrsc.s1
-    1, // llvm.hexagon.M2.cmpys.s0
-    1, // llvm.hexagon.M2.cmpys.s1
-    1, // llvm.hexagon.M2.cmpysc.s0
-    1, // llvm.hexagon.M2.cmpysc.s1
-    1, // llvm.hexagon.M2.cnacs.s0
-    1, // llvm.hexagon.M2.cnacs.s1
-    1, // llvm.hexagon.M2.cnacsc.s0
-    1, // llvm.hexagon.M2.cnacsc.s1
-    1, // llvm.hexagon.M2.dpmpyss.acc.s0
-    1, // llvm.hexagon.M2.dpmpyss.nac.s0
-    1, // llvm.hexagon.M2.dpmpyss.rnd.s0
-    1, // llvm.hexagon.M2.dpmpyss.s0
-    1, // llvm.hexagon.M2.dpmpyuu.acc.s0
-    1, // llvm.hexagon.M2.dpmpyuu.nac.s0
-    1, // llvm.hexagon.M2.dpmpyuu.s0
-    1, // llvm.hexagon.M2.hmmpyh.rs1
-    1, // llvm.hexagon.M2.hmmpyh.s1
-    1, // llvm.hexagon.M2.hmmpyl.rs1
-    1, // llvm.hexagon.M2.hmmpyl.s1
-    1, // llvm.hexagon.M2.maci
-    27, // llvm.hexagon.M2.macsin
-    27, // llvm.hexagon.M2.macsip
-    1, // llvm.hexagon.M2.mmachs.rs0
-    1, // llvm.hexagon.M2.mmachs.rs1
-    1, // llvm.hexagon.M2.mmachs.s0
-    1, // llvm.hexagon.M2.mmachs.s1
-    1, // llvm.hexagon.M2.mmacls.rs0
-    1, // llvm.hexagon.M2.mmacls.rs1
-    1, // llvm.hexagon.M2.mmacls.s0
-    1, // llvm.hexagon.M2.mmacls.s1
-    1, // llvm.hexagon.M2.mmacuhs.rs0
-    1, // llvm.hexagon.M2.mmacuhs.rs1
-    1, // llvm.hexagon.M2.mmacuhs.s0
-    1, // llvm.hexagon.M2.mmacuhs.s1
-    1, // llvm.hexagon.M2.mmaculs.rs0
-    1, // llvm.hexagon.M2.mmaculs.rs1
-    1, // llvm.hexagon.M2.mmaculs.s0
-    1, // llvm.hexagon.M2.mmaculs.s1
-    1, // llvm.hexagon.M2.mmpyh.rs0
-    1, // llvm.hexagon.M2.mmpyh.rs1
-    1, // llvm.hexagon.M2.mmpyh.s0
-    1, // llvm.hexagon.M2.mmpyh.s1
-    1, // llvm.hexagon.M2.mmpyl.rs0
-    1, // llvm.hexagon.M2.mmpyl.rs1
-    1, // llvm.hexagon.M2.mmpyl.s0
-    1, // llvm.hexagon.M2.mmpyl.s1
-    1, // llvm.hexagon.M2.mmpyuh.rs0
-    1, // llvm.hexagon.M2.mmpyuh.rs1
-    1, // llvm.hexagon.M2.mmpyuh.s0
-    1, // llvm.hexagon.M2.mmpyuh.s1
-    1, // llvm.hexagon.M2.mmpyul.rs0
-    1, // llvm.hexagon.M2.mmpyul.rs1
-    1, // llvm.hexagon.M2.mmpyul.s0
-    1, // llvm.hexagon.M2.mmpyul.s1
-    1, // llvm.hexagon.M2.mnaci
-    1, // llvm.hexagon.M2.mpy.acc.hh.s0
-    1, // llvm.hexagon.M2.mpy.acc.hh.s1
-    1, // llvm.hexagon.M2.mpy.acc.hl.s0
-    1, // llvm.hexagon.M2.mpy.acc.hl.s1
-    1, // llvm.hexagon.M2.mpy.acc.lh.s0
-    1, // llvm.hexagon.M2.mpy.acc.lh.s1
-    1, // llvm.hexagon.M2.mpy.acc.ll.s0
-    1, // llvm.hexagon.M2.mpy.acc.ll.s1
-    1, // llvm.hexagon.M2.mpy.acc.sat.hh.s0
-    1, // llvm.hexagon.M2.mpy.acc.sat.hh.s1
-    1, // llvm.hexagon.M2.mpy.acc.sat.hl.s0
-    1, // llvm.hexagon.M2.mpy.acc.sat.hl.s1
-    1, // llvm.hexagon.M2.mpy.acc.sat.lh.s0
-    1, // llvm.hexagon.M2.mpy.acc.sat.lh.s1
-    1, // llvm.hexagon.M2.mpy.acc.sat.ll.s0
-    1, // llvm.hexagon.M2.mpy.acc.sat.ll.s1
-    1, // llvm.hexagon.M2.mpy.hh.s0
-    1, // llvm.hexagon.M2.mpy.hh.s1
-    1, // llvm.hexagon.M2.mpy.hl.s0
-    1, // llvm.hexagon.M2.mpy.hl.s1
-    1, // llvm.hexagon.M2.mpy.lh.s0
-    1, // llvm.hexagon.M2.mpy.lh.s1
-    1, // llvm.hexagon.M2.mpy.ll.s0
-    1, // llvm.hexagon.M2.mpy.ll.s1
-    1, // llvm.hexagon.M2.mpy.nac.hh.s0
-    1, // llvm.hexagon.M2.mpy.nac.hh.s1
-    1, // llvm.hexagon.M2.mpy.nac.hl.s0
-    1, // llvm.hexagon.M2.mpy.nac.hl.s1
-    1, // llvm.hexagon.M2.mpy.nac.lh.s0
-    1, // llvm.hexagon.M2.mpy.nac.lh.s1
-    1, // llvm.hexagon.M2.mpy.nac.ll.s0
-    1, // llvm.hexagon.M2.mpy.nac.ll.s1
-    1, // llvm.hexagon.M2.mpy.nac.sat.hh.s0
-    1, // llvm.hexagon.M2.mpy.nac.sat.hh.s1
-    1, // llvm.hexagon.M2.mpy.nac.sat.hl.s0
-    1, // llvm.hexagon.M2.mpy.nac.sat.hl.s1
-    1, // llvm.hexagon.M2.mpy.nac.sat.lh.s0
-    1, // llvm.hexagon.M2.mpy.nac.sat.lh.s1
-    1, // llvm.hexagon.M2.mpy.nac.sat.ll.s0
-    1, // llvm.hexagon.M2.mpy.nac.sat.ll.s1
-    1, // llvm.hexagon.M2.mpy.rnd.hh.s0
-    1, // llvm.hexagon.M2.mpy.rnd.hh.s1
-    1, // llvm.hexagon.M2.mpy.rnd.hl.s0
-    1, // llvm.hexagon.M2.mpy.rnd.hl.s1
-    1, // llvm.hexagon.M2.mpy.rnd.lh.s0
-    1, // llvm.hexagon.M2.mpy.rnd.lh.s1
-    1, // llvm.hexagon.M2.mpy.rnd.ll.s0
-    1, // llvm.hexagon.M2.mpy.rnd.ll.s1
-    1, // llvm.hexagon.M2.mpy.sat.hh.s0
-    1, // llvm.hexagon.M2.mpy.sat.hh.s1
-    1, // llvm.hexagon.M2.mpy.sat.hl.s0
-    1, // llvm.hexagon.M2.mpy.sat.hl.s1
-    1, // llvm.hexagon.M2.mpy.sat.lh.s0
-    1, // llvm.hexagon.M2.mpy.sat.lh.s1
-    1, // llvm.hexagon.M2.mpy.sat.ll.s0
-    1, // llvm.hexagon.M2.mpy.sat.ll.s1
-    1, // llvm.hexagon.M2.mpy.sat.rnd.hh.s0
-    1, // llvm.hexagon.M2.mpy.sat.rnd.hh.s1
-    1, // llvm.hexagon.M2.mpy.sat.rnd.hl.s0
-    1, // llvm.hexagon.M2.mpy.sat.rnd.hl.s1
-    1, // llvm.hexagon.M2.mpy.sat.rnd.lh.s0
-    1, // llvm.hexagon.M2.mpy.sat.rnd.lh.s1
-    1, // llvm.hexagon.M2.mpy.sat.rnd.ll.s0
-    1, // llvm.hexagon.M2.mpy.sat.rnd.ll.s1
-    1, // llvm.hexagon.M2.mpy.up
-    1, // llvm.hexagon.M2.mpy.up.s1
-    1, // llvm.hexagon.M2.mpy.up.s1.sat
-    1, // llvm.hexagon.M2.mpyd.acc.hh.s0
-    1, // llvm.hexagon.M2.mpyd.acc.hh.s1
-    1, // llvm.hexagon.M2.mpyd.acc.hl.s0
-    1, // llvm.hexagon.M2.mpyd.acc.hl.s1
-    1, // llvm.hexagon.M2.mpyd.acc.lh.s0
-    1, // llvm.hexagon.M2.mpyd.acc.lh.s1
-    1, // llvm.hexagon.M2.mpyd.acc.ll.s0
-    1, // llvm.hexagon.M2.mpyd.acc.ll.s1
-    1, // llvm.hexagon.M2.mpyd.hh.s0
-    1, // llvm.hexagon.M2.mpyd.hh.s1
-    1, // llvm.hexagon.M2.mpyd.hl.s0
-    1, // llvm.hexagon.M2.mpyd.hl.s1
-    1, // llvm.hexagon.M2.mpyd.lh.s0
-    1, // llvm.hexagon.M2.mpyd.lh.s1
-    1, // llvm.hexagon.M2.mpyd.ll.s0
-    1, // llvm.hexagon.M2.mpyd.ll.s1
-    1, // llvm.hexagon.M2.mpyd.nac.hh.s0
-    1, // llvm.hexagon.M2.mpyd.nac.hh.s1
-    1, // llvm.hexagon.M2.mpyd.nac.hl.s0
-    1, // llvm.hexagon.M2.mpyd.nac.hl.s1
-    1, // llvm.hexagon.M2.mpyd.nac.lh.s0
-    1, // llvm.hexagon.M2.mpyd.nac.lh.s1
-    1, // llvm.hexagon.M2.mpyd.nac.ll.s0
-    1, // llvm.hexagon.M2.mpyd.nac.ll.s1
-    1, // llvm.hexagon.M2.mpyd.rnd.hh.s0
-    1, // llvm.hexagon.M2.mpyd.rnd.hh.s1
-    1, // llvm.hexagon.M2.mpyd.rnd.hl.s0
-    1, // llvm.hexagon.M2.mpyd.rnd.hl.s1
-    1, // llvm.hexagon.M2.mpyd.rnd.lh.s0
-    1, // llvm.hexagon.M2.mpyd.rnd.lh.s1
-    1, // llvm.hexagon.M2.mpyd.rnd.ll.s0
-    1, // llvm.hexagon.M2.mpyd.rnd.ll.s1
-    1, // llvm.hexagon.M2.mpyi
-    40, // llvm.hexagon.M2.mpysin
-    40, // llvm.hexagon.M2.mpysip
-    40, // llvm.hexagon.M2.mpysmi
-    1, // llvm.hexagon.M2.mpysu.up
-    1, // llvm.hexagon.M2.mpyu.acc.hh.s0
-    1, // llvm.hexagon.M2.mpyu.acc.hh.s1
-    1, // llvm.hexagon.M2.mpyu.acc.hl.s0
-    1, // llvm.hexagon.M2.mpyu.acc.hl.s1
-    1, // llvm.hexagon.M2.mpyu.acc.lh.s0
-    1, // llvm.hexagon.M2.mpyu.acc.lh.s1
-    1, // llvm.hexagon.M2.mpyu.acc.ll.s0
-    1, // llvm.hexagon.M2.mpyu.acc.ll.s1
-    1, // llvm.hexagon.M2.mpyu.hh.s0
-    1, // llvm.hexagon.M2.mpyu.hh.s1
-    1, // llvm.hexagon.M2.mpyu.hl.s0
-    1, // llvm.hexagon.M2.mpyu.hl.s1
-    1, // llvm.hexagon.M2.mpyu.lh.s0
-    1, // llvm.hexagon.M2.mpyu.lh.s1
-    1, // llvm.hexagon.M2.mpyu.ll.s0
-    1, // llvm.hexagon.M2.mpyu.ll.s1
-    1, // llvm.hexagon.M2.mpyu.nac.hh.s0
-    1, // llvm.hexagon.M2.mpyu.nac.hh.s1
-    1, // llvm.hexagon.M2.mpyu.nac.hl.s0
-    1, // llvm.hexagon.M2.mpyu.nac.hl.s1
-    1, // llvm.hexagon.M2.mpyu.nac.lh.s0
-    1, // llvm.hexagon.M2.mpyu.nac.lh.s1
-    1, // llvm.hexagon.M2.mpyu.nac.ll.s0
-    1, // llvm.hexagon.M2.mpyu.nac.ll.s1
-    1, // llvm.hexagon.M2.mpyu.up
-    1, // llvm.hexagon.M2.mpyud.acc.hh.s0
-    1, // llvm.hexagon.M2.mpyud.acc.hh.s1
-    1, // llvm.hexagon.M2.mpyud.acc.hl.s0
-    1, // llvm.hexagon.M2.mpyud.acc.hl.s1
-    1, // llvm.hexagon.M2.mpyud.acc.lh.s0
-    1, // llvm.hexagon.M2.mpyud.acc.lh.s1
-    1, // llvm.hexagon.M2.mpyud.acc.ll.s0
-    1, // llvm.hexagon.M2.mpyud.acc.ll.s1
-    1, // llvm.hexagon.M2.mpyud.hh.s0
-    1, // llvm.hexagon.M2.mpyud.hh.s1
-    1, // llvm.hexagon.M2.mpyud.hl.s0
-    1, // llvm.hexagon.M2.mpyud.hl.s1
-    1, // llvm.hexagon.M2.mpyud.lh.s0
-    1, // llvm.hexagon.M2.mpyud.lh.s1
-    1, // llvm.hexagon.M2.mpyud.ll.s0
-    1, // llvm.hexagon.M2.mpyud.ll.s1
-    1, // llvm.hexagon.M2.mpyud.nac.hh.s0
-    1, // llvm.hexagon.M2.mpyud.nac.hh.s1
-    1, // llvm.hexagon.M2.mpyud.nac.hl.s0
-    1, // llvm.hexagon.M2.mpyud.nac.hl.s1
-    1, // llvm.hexagon.M2.mpyud.nac.lh.s0
-    1, // llvm.hexagon.M2.mpyud.nac.lh.s1
-    1, // llvm.hexagon.M2.mpyud.nac.ll.s0
-    1, // llvm.hexagon.M2.mpyud.nac.ll.s1
-    1, // llvm.hexagon.M2.mpyui
-    1, // llvm.hexagon.M2.nacci
-    27, // llvm.hexagon.M2.naccii
-    1, // llvm.hexagon.M2.subacc
-    1, // llvm.hexagon.M2.vabsdiffh
-    1, // llvm.hexagon.M2.vabsdiffw
-    1, // llvm.hexagon.M2.vcmac.s0.sat.i
-    1, // llvm.hexagon.M2.vcmac.s0.sat.r
-    1, // llvm.hexagon.M2.vcmpy.s0.sat.i
-    1, // llvm.hexagon.M2.vcmpy.s0.sat.r
-    1, // llvm.hexagon.M2.vcmpy.s1.sat.i
-    1, // llvm.hexagon.M2.vcmpy.s1.sat.r
-    1, // llvm.hexagon.M2.vdmacs.s0
-    1, // llvm.hexagon.M2.vdmacs.s1
-    1, // llvm.hexagon.M2.vdmpyrs.s0
-    1, // llvm.hexagon.M2.vdmpyrs.s1
-    1, // llvm.hexagon.M2.vdmpys.s0
-    1, // llvm.hexagon.M2.vdmpys.s1
-    1, // llvm.hexagon.M2.vmac2
-    1, // llvm.hexagon.M2.vmac2es
-    1, // llvm.hexagon.M2.vmac2es.s0
-    1, // llvm.hexagon.M2.vmac2es.s1
-    1, // llvm.hexagon.M2.vmac2s.s0
-    1, // llvm.hexagon.M2.vmac2s.s1
-    1, // llvm.hexagon.M2.vmac2su.s0
-    1, // llvm.hexagon.M2.vmac2su.s1
-    1, // llvm.hexagon.M2.vmpy2es.s0
-    1, // llvm.hexagon.M2.vmpy2es.s1
-    1, // llvm.hexagon.M2.vmpy2s.s0
-    1, // llvm.hexagon.M2.vmpy2s.s0pack
-    1, // llvm.hexagon.M2.vmpy2s.s1
-    1, // llvm.hexagon.M2.vmpy2s.s1pack
-    1, // llvm.hexagon.M2.vmpy2su.s0
-    1, // llvm.hexagon.M2.vmpy2su.s1
-    1, // llvm.hexagon.M2.vraddh
-    1, // llvm.hexagon.M2.vradduh
-    1, // llvm.hexagon.M2.vrcmaci.s0
-    1, // llvm.hexagon.M2.vrcmaci.s0c
-    1, // llvm.hexagon.M2.vrcmacr.s0
-    1, // llvm.hexagon.M2.vrcmacr.s0c
-    1, // llvm.hexagon.M2.vrcmpyi.s0
-    1, // llvm.hexagon.M2.vrcmpyi.s0c
-    1, // llvm.hexagon.M2.vrcmpyr.s0
-    1, // llvm.hexagon.M2.vrcmpyr.s0c
-    1, // llvm.hexagon.M2.vrcmpys.acc.s1
-    1, // llvm.hexagon.M2.vrcmpys.s1
-    1, // llvm.hexagon.M2.vrcmpys.s1rp
-    1, // llvm.hexagon.M2.vrmac.s0
-    1, // llvm.hexagon.M2.vrmpy.s0
-    1, // llvm.hexagon.M2.xor.xacc
-    1, // llvm.hexagon.M4.and.and
-    1, // llvm.hexagon.M4.and.andn
-    1, // llvm.hexagon.M4.and.or
-    1, // llvm.hexagon.M4.and.xor
-    1, // llvm.hexagon.M4.cmpyi.wh
-    1, // llvm.hexagon.M4.cmpyi.whc
-    1, // llvm.hexagon.M4.cmpyr.wh
-    1, // llvm.hexagon.M4.cmpyr.whc
-    1, // llvm.hexagon.M4.mac.up.s1.sat
-    123, // llvm.hexagon.M4.mpyri.addi
-    27, // llvm.hexagon.M4.mpyri.addr
-    40, // llvm.hexagon.M4.mpyri.addr.u2
-    20, // llvm.hexagon.M4.mpyrr.addi
-    1, // llvm.hexagon.M4.mpyrr.addr
-    1, // llvm.hexagon.M4.nac.up.s1.sat
-    1, // llvm.hexagon.M4.or.and
-    1, // llvm.hexagon.M4.or.andn
-    1, // llvm.hexagon.M4.or.or
-    1, // llvm.hexagon.M4.or.xor
-    1, // llvm.hexagon.M4.pmpyw
-    1, // llvm.hexagon.M4.pmpyw.acc
-    1, // llvm.hexagon.M4.vpmpyh
-    1, // llvm.hexagon.M4.vpmpyh.acc
-    1, // llvm.hexagon.M4.vrmpyeh.acc.s0
-    1, // llvm.hexagon.M4.vrmpyeh.acc.s1
-    1, // llvm.hexagon.M4.vrmpyeh.s0
-    1, // llvm.hexagon.M4.vrmpyeh.s1
-    1, // llvm.hexagon.M4.vrmpyoh.acc.s0
-    1, // llvm.hexagon.M4.vrmpyoh.acc.s1
-    1, // llvm.hexagon.M4.vrmpyoh.s0
-    1, // llvm.hexagon.M4.vrmpyoh.s1
-    1, // llvm.hexagon.M4.xor.and
-    1, // llvm.hexagon.M4.xor.andn
-    1, // llvm.hexagon.M4.xor.or
-    1, // llvm.hexagon.M4.xor.xacc
-    1, // llvm.hexagon.M5.vdmacbsu
-    1, // llvm.hexagon.M5.vdmpybsu
-    1, // llvm.hexagon.M5.vmacbsu
-    1, // llvm.hexagon.M5.vmacbuu
-    1, // llvm.hexagon.M5.vmpybsu
-    1, // llvm.hexagon.M5.vmpybuu
-    1, // llvm.hexagon.M5.vrmacbsu
-    1, // llvm.hexagon.M5.vrmacbuu
-    1, // llvm.hexagon.M5.vrmpybsu
-    1, // llvm.hexagon.M5.vrmpybuu
-    1, // llvm.hexagon.M6.vabsdiffb
-    1, // llvm.hexagon.M6.vabsdiffub
-    27, // llvm.hexagon.S2.addasl.rrri
-    40, // llvm.hexagon.S2.asl.i.p
-    27, // llvm.hexagon.S2.asl.i.p.acc
-    27, // llvm.hexagon.S2.asl.i.p.and
-    27, // llvm.hexagon.S2.asl.i.p.nac
-    27, // llvm.hexagon.S2.asl.i.p.or
-    27, // llvm.hexagon.S2.asl.i.p.xacc
-    40, // llvm.hexagon.S2.asl.i.r
-    27, // llvm.hexagon.S2.asl.i.r.acc
-    27, // llvm.hexagon.S2.asl.i.r.and
-    27, // llvm.hexagon.S2.asl.i.r.nac
-    27, // llvm.hexagon.S2.asl.i.r.or
-    40, // llvm.hexagon.S2.asl.i.r.sat
-    27, // llvm.hexagon.S2.asl.i.r.xacc
-    40, // llvm.hexagon.S2.asl.i.vh
-    40, // llvm.hexagon.S2.asl.i.vw
-    1, // llvm.hexagon.S2.asl.r.p
-    1, // llvm.hexagon.S2.asl.r.p.acc
-    1, // llvm.hexagon.S2.asl.r.p.and
-    1, // llvm.hexagon.S2.asl.r.p.nac
-    1, // llvm.hexagon.S2.asl.r.p.or
-    1, // llvm.hexagon.S2.asl.r.p.xor
-    1, // llvm.hexagon.S2.asl.r.r
-    1, // llvm.hexagon.S2.asl.r.r.acc
-    1, // llvm.hexagon.S2.asl.r.r.and
-    1, // llvm.hexagon.S2.asl.r.r.nac
-    1, // llvm.hexagon.S2.asl.r.r.or
-    1, // llvm.hexagon.S2.asl.r.r.sat
-    1, // llvm.hexagon.S2.asl.r.vh
-    1, // llvm.hexagon.S2.asl.r.vw
-    40, // llvm.hexagon.S2.asr.i.p
-    27, // llvm.hexagon.S2.asr.i.p.acc
-    27, // llvm.hexagon.S2.asr.i.p.and
-    27, // llvm.hexagon.S2.asr.i.p.nac
-    27, // llvm.hexagon.S2.asr.i.p.or
-    40, // llvm.hexagon.S2.asr.i.p.rnd
-    40, // llvm.hexagon.S2.asr.i.p.rnd.goodsyntax
-    40, // llvm.hexagon.S2.asr.i.r
-    27, // llvm.hexagon.S2.asr.i.r.acc
-    27, // llvm.hexagon.S2.asr.i.r.and
-    27, // llvm.hexagon.S2.asr.i.r.nac
-    27, // llvm.hexagon.S2.asr.i.r.or
-    40, // llvm.hexagon.S2.asr.i.r.rnd
-    40, // llvm.hexagon.S2.asr.i.r.rnd.goodsyntax
-    40, // llvm.hexagon.S2.asr.i.svw.trun
-    40, // llvm.hexagon.S2.asr.i.vh
-    40, // llvm.hexagon.S2.asr.i.vw
-    1, // llvm.hexagon.S2.asr.r.p
-    1, // llvm.hexagon.S2.asr.r.p.acc
-    1, // llvm.hexagon.S2.asr.r.p.and
-    1, // llvm.hexagon.S2.asr.r.p.nac
-    1, // llvm.hexagon.S2.asr.r.p.or
-    1, // llvm.hexagon.S2.asr.r.p.xor
-    1, // llvm.hexagon.S2.asr.r.r
-    1, // llvm.hexagon.S2.asr.r.r.acc
-    1, // llvm.hexagon.S2.asr.r.r.and
-    1, // llvm.hexagon.S2.asr.r.r.nac
-    1, // llvm.hexagon.S2.asr.r.r.or
-    1, // llvm.hexagon.S2.asr.r.r.sat
-    1, // llvm.hexagon.S2.asr.r.svw.trun
-    1, // llvm.hexagon.S2.asr.r.vh
-    1, // llvm.hexagon.S2.asr.r.vw
-    1, // llvm.hexagon.S2.brev
-    1, // llvm.hexagon.S2.brevp
-    1, // llvm.hexagon.S2.cl0
-    1, // llvm.hexagon.S2.cl0p
-    1, // llvm.hexagon.S2.cl1
-    1, // llvm.hexagon.S2.cl1p
-    1, // llvm.hexagon.S2.clb
-    1, // llvm.hexagon.S2.clbnorm
-    1, // llvm.hexagon.S2.clbp
-    40, // llvm.hexagon.S2.clrbit.i
-    1, // llvm.hexagon.S2.clrbit.r
-    1, // llvm.hexagon.S2.ct0
-    1, // llvm.hexagon.S2.ct0p
-    1, // llvm.hexagon.S2.ct1
-    1, // llvm.hexagon.S2.ct1p
-    1, // llvm.hexagon.S2.deinterleave
-    39, // llvm.hexagon.S2.extractu
-    1, // llvm.hexagon.S2.extractu.rp
-    39, // llvm.hexagon.S2.extractup
-    1, // llvm.hexagon.S2.extractup.rp
-    124, // llvm.hexagon.S2.insert
-    1, // llvm.hexagon.S2.insert.rp
-    124, // llvm.hexagon.S2.insertp
-    1, // llvm.hexagon.S2.insertp.rp
-    1, // llvm.hexagon.S2.interleave
-    1, // llvm.hexagon.S2.lfsp
-    1, // llvm.hexagon.S2.lsl.r.p
-    1, // llvm.hexagon.S2.lsl.r.p.acc
-    1, // llvm.hexagon.S2.lsl.r.p.and
-    1, // llvm.hexagon.S2.lsl.r.p.nac
-    1, // llvm.hexagon.S2.lsl.r.p.or
-    1, // llvm.hexagon.S2.lsl.r.p.xor
-    1, // llvm.hexagon.S2.lsl.r.r
-    1, // llvm.hexagon.S2.lsl.r.r.acc
-    1, // llvm.hexagon.S2.lsl.r.r.and
-    1, // llvm.hexagon.S2.lsl.r.r.nac
-    1, // llvm.hexagon.S2.lsl.r.r.or
-    1, // llvm.hexagon.S2.lsl.r.vh
-    1, // llvm.hexagon.S2.lsl.r.vw
-    40, // llvm.hexagon.S2.lsr.i.p
-    27, // llvm.hexagon.S2.lsr.i.p.acc
-    27, // llvm.hexagon.S2.lsr.i.p.and
-    27, // llvm.hexagon.S2.lsr.i.p.nac
-    27, // llvm.hexagon.S2.lsr.i.p.or
-    27, // llvm.hexagon.S2.lsr.i.p.xacc
-    40, // llvm.hexagon.S2.lsr.i.r
-    27, // llvm.hexagon.S2.lsr.i.r.acc
-    27, // llvm.hexagon.S2.lsr.i.r.and
-    27, // llvm.hexagon.S2.lsr.i.r.nac
-    27, // llvm.hexagon.S2.lsr.i.r.or
-    27, // llvm.hexagon.S2.lsr.i.r.xacc
-    40, // llvm.hexagon.S2.lsr.i.vh
-    40, // llvm.hexagon.S2.lsr.i.vw
-    1, // llvm.hexagon.S2.lsr.r.p
-    1, // llvm.hexagon.S2.lsr.r.p.acc
-    1, // llvm.hexagon.S2.lsr.r.p.and
-    1, // llvm.hexagon.S2.lsr.r.p.nac
-    1, // llvm.hexagon.S2.lsr.r.p.or
-    1, // llvm.hexagon.S2.lsr.r.p.xor
-    1, // llvm.hexagon.S2.lsr.r.r
-    1, // llvm.hexagon.S2.lsr.r.r.acc
-    1, // llvm.hexagon.S2.lsr.r.r.and
-    1, // llvm.hexagon.S2.lsr.r.r.nac
-    1, // llvm.hexagon.S2.lsr.r.r.or
-    1, // llvm.hexagon.S2.lsr.r.vh
-    1, // llvm.hexagon.S2.lsr.r.vw
-    120, // llvm.hexagon.S2.mask
-    1, // llvm.hexagon.S2.packhl
-    1, // llvm.hexagon.S2.parityp
-    40, // llvm.hexagon.S2.setbit.i
-    1, // llvm.hexagon.S2.setbit.r
-    1, // llvm.hexagon.S2.shuffeb
-    1, // llvm.hexagon.S2.shuffeh
-    1, // llvm.hexagon.S2.shuffob
-    1, // llvm.hexagon.S2.shuffoh
-    50, // llvm.hexagon.S2.storerb.pbr
-    48, // llvm.hexagon.S2.storerb.pci
-    47, // llvm.hexagon.S2.storerb.pcr
-    50, // llvm.hexagon.S2.storerd.pbr
-    48, // llvm.hexagon.S2.storerd.pci
-    47, // llvm.hexagon.S2.storerd.pcr
-    50, // llvm.hexagon.S2.storerf.pbr
-    48, // llvm.hexagon.S2.storerf.pci
-    47, // llvm.hexagon.S2.storerf.pcr
-    50, // llvm.hexagon.S2.storerh.pbr
-    48, // llvm.hexagon.S2.storerh.pci
-    47, // llvm.hexagon.S2.storerh.pcr
-    50, // llvm.hexagon.S2.storeri.pbr
-    48, // llvm.hexagon.S2.storeri.pci
-    47, // llvm.hexagon.S2.storeri.pcr
-    23, // llvm.hexagon.S2.storew.locked
-    1, // llvm.hexagon.S2.svsathb
-    1, // llvm.hexagon.S2.svsathub
-    124, // llvm.hexagon.S2.tableidxb.goodsyntax
-    124, // llvm.hexagon.S2.tableidxd.goodsyntax
-    124, // llvm.hexagon.S2.tableidxh.goodsyntax
-    124, // llvm.hexagon.S2.tableidxw.goodsyntax
-    40, // llvm.hexagon.S2.togglebit.i
-    1, // llvm.hexagon.S2.togglebit.r
-    40, // llvm.hexagon.S2.tstbit.i
-    1, // llvm.hexagon.S2.tstbit.r
-    27, // llvm.hexagon.S2.valignib
-    1, // llvm.hexagon.S2.valignrb
-    1, // llvm.hexagon.S2.vcnegh
-    1, // llvm.hexagon.S2.vcrotate
-    1, // llvm.hexagon.S2.vrcnegh
-    1, // llvm.hexagon.S2.vrndpackwh
-    1, // llvm.hexagon.S2.vrndpackwhs
-    1, // llvm.hexagon.S2.vsathb
-    1, // llvm.hexagon.S2.vsathb.nopack
-    1, // llvm.hexagon.S2.vsathub
-    1, // llvm.hexagon.S2.vsathub.nopack
-    1, // llvm.hexagon.S2.vsatwh
-    1, // llvm.hexagon.S2.vsatwh.nopack
-    1, // llvm.hexagon.S2.vsatwuh
-    1, // llvm.hexagon.S2.vsatwuh.nopack
-    1, // llvm.hexagon.S2.vsplatrb
-    1, // llvm.hexagon.S2.vsplatrh
-    27, // llvm.hexagon.S2.vspliceib
-    1, // llvm.hexagon.S2.vsplicerb
-    1, // llvm.hexagon.S2.vsxtbh
-    1, // llvm.hexagon.S2.vsxthw
-    1, // llvm.hexagon.S2.vtrunehb
-    1, // llvm.hexagon.S2.vtrunewh
-    1, // llvm.hexagon.S2.vtrunohb
-    1, // llvm.hexagon.S2.vtrunowh
-    1, // llvm.hexagon.S2.vzxtbh
-    1, // llvm.hexagon.S2.vzxthw
-    27, // llvm.hexagon.S4.addaddi
-    123, // llvm.hexagon.S4.addi.asl.ri
-    123, // llvm.hexagon.S4.addi.lsr.ri
-    123, // llvm.hexagon.S4.andi.asl.ri
-    123, // llvm.hexagon.S4.andi.lsr.ri
-    40, // llvm.hexagon.S4.clbaddi
-    40, // llvm.hexagon.S4.clbpaddi
-    1, // llvm.hexagon.S4.clbpnorm
-    39, // llvm.hexagon.S4.extract
-    1, // llvm.hexagon.S4.extract.rp
-    39, // llvm.hexagon.S4.extractp
-    1, // llvm.hexagon.S4.extractp.rp
-    20, // llvm.hexagon.S4.lsli
-    40, // llvm.hexagon.S4.ntstbit.i
-    1, // llvm.hexagon.S4.ntstbit.r
-    27, // llvm.hexagon.S4.or.andi
-    27, // llvm.hexagon.S4.or.andix
-    27, // llvm.hexagon.S4.or.ori
-    123, // llvm.hexagon.S4.ori.asl.ri
-    123, // llvm.hexagon.S4.ori.lsr.ri
-    1, // llvm.hexagon.S4.parity
-    23, // llvm.hexagon.S4.stored.locked
-    40, // llvm.hexagon.S4.subaddi
-    123, // llvm.hexagon.S4.subi.asl.ri
-    123, // llvm.hexagon.S4.subi.lsr.ri
-    27, // llvm.hexagon.S4.vrcrotate
-    125, // llvm.hexagon.S4.vrcrotate.acc
-    1, // llvm.hexagon.S4.vxaddsubh
-    1, // llvm.hexagon.S4.vxaddsubhr
-    1, // llvm.hexagon.S4.vxaddsubw
-    1, // llvm.hexagon.S4.vxsubaddh
-    1, // llvm.hexagon.S4.vxsubaddhr
-    1, // llvm.hexagon.S4.vxsubaddw
-    40, // llvm.hexagon.S5.asrhub.rnd.sat.goodsyntax
-    40, // llvm.hexagon.S5.asrhub.sat
-    1, // llvm.hexagon.S5.popcountp
-    40, // llvm.hexagon.S5.vasrhrnd.goodsyntax
-    40, // llvm.hexagon.S6.rol.i.p
-    27, // llvm.hexagon.S6.rol.i.p.acc
-    27, // llvm.hexagon.S6.rol.i.p.and
-    27, // llvm.hexagon.S6.rol.i.p.nac
-    27, // llvm.hexagon.S6.rol.i.p.or
-    27, // llvm.hexagon.S6.rol.i.p.xacc
-    40, // llvm.hexagon.S6.rol.i.r
-    27, // llvm.hexagon.S6.rol.i.r.acc
-    27, // llvm.hexagon.S6.rol.i.r.and
-    27, // llvm.hexagon.S6.rol.i.r.nac
-    27, // llvm.hexagon.S6.rol.i.r.or
-    27, // llvm.hexagon.S6.rol.i.r.xacc
-    1, // llvm.hexagon.S6.vsplatrbp
-    1, // llvm.hexagon.S6.vtrunehb.ppp
-    1, // llvm.hexagon.S6.vtrunohb.ppp
-    1, // llvm.hexagon.V6.extractw
-    1, // llvm.hexagon.V6.extractw.128B
-    1, // llvm.hexagon.V6.hi
-    1, // llvm.hexagon.V6.hi.128B
-    1, // llvm.hexagon.V6.ld0
-    1, // llvm.hexagon.V6.ld0.128B
-    1, // llvm.hexagon.V6.ldcnp0
-    1, // llvm.hexagon.V6.ldcnp0.128B
-    1, // llvm.hexagon.V6.ldcnpnt0
-    1, // llvm.hexagon.V6.ldcnpnt0.128B
-    1, // llvm.hexagon.V6.ldcp0
-    1, // llvm.hexagon.V6.ldcp0.128B
-    1, // llvm.hexagon.V6.ldcpnt0
-    1, // llvm.hexagon.V6.ldcpnt0.128B
-    1, // llvm.hexagon.V6.ldnp0
-    1, // llvm.hexagon.V6.ldnp0.128B
-    1, // llvm.hexagon.V6.ldnpnt0
-    1, // llvm.hexagon.V6.ldnpnt0.128B
-    1, // llvm.hexagon.V6.ldnt0
-    1, // llvm.hexagon.V6.ldnt0.128B
-    1, // llvm.hexagon.V6.ldntnt0
-    1, // llvm.hexagon.V6.ldp0
-    1, // llvm.hexagon.V6.ldp0.128B
-    1, // llvm.hexagon.V6.ldpnt0
-    1, // llvm.hexagon.V6.ldpnt0.128B
-    1, // llvm.hexagon.V6.ldtnp0
-    1, // llvm.hexagon.V6.ldtnp0.128B
-    1, // llvm.hexagon.V6.ldtnpnt0
-    1, // llvm.hexagon.V6.ldtnpnt0.128B
-    1, // llvm.hexagon.V6.ldtp0
-    1, // llvm.hexagon.V6.ldtp0.128B
-    1, // llvm.hexagon.V6.ldtpnt0
-    1, // llvm.hexagon.V6.ldtpnt0.128B
-    1, // llvm.hexagon.V6.ldu0
-    1, // llvm.hexagon.V6.ldu0.128B
-    1, // llvm.hexagon.V6.lo
-    1, // llvm.hexagon.V6.lo.128B
-    1, // llvm.hexagon.V6.lvsplatb
-    1, // llvm.hexagon.V6.lvsplatb.128B
-    1, // llvm.hexagon.V6.lvsplath
-    1, // llvm.hexagon.V6.lvsplath.128B
-    1, // llvm.hexagon.V6.lvsplatw
-    1, // llvm.hexagon.V6.lvsplatw.128B
-    1, // llvm.hexagon.V6.pred.and
-    1, // llvm.hexagon.V6.pred.and.128B
-    1, // llvm.hexagon.V6.pred.and.n
-    1, // llvm.hexagon.V6.pred.and.n.128B
-    1, // llvm.hexagon.V6.pred.not
-    1, // llvm.hexagon.V6.pred.not.128B
-    1, // llvm.hexagon.V6.pred.or
-    1, // llvm.hexagon.V6.pred.or.128B
-    1, // llvm.hexagon.V6.pred.or.n
-    1, // llvm.hexagon.V6.pred.or.n.128B
-    1, // llvm.hexagon.V6.pred.scalar2
-    1, // llvm.hexagon.V6.pred.scalar2.128B
-    1, // llvm.hexagon.V6.pred.scalar2v2
-    1, // llvm.hexagon.V6.pred.scalar2v2.128B
-    1, // llvm.hexagon.V6.pred.xor
-    1, // llvm.hexagon.V6.pred.xor.128B
-    1, // llvm.hexagon.V6.shuffeqh
-    1, // llvm.hexagon.V6.shuffeqh.128B
-    1, // llvm.hexagon.V6.shuffeqw
-    1, // llvm.hexagon.V6.shuffeqw.128B
-    29, // llvm.hexagon.V6.vS32b.nqpred.ai
-    29, // llvm.hexagon.V6.vS32b.nqpred.ai.128B
-    29, // llvm.hexagon.V6.vS32b.nt.nqpred.ai
-    29, // llvm.hexagon.V6.vS32b.nt.nqpred.ai.128B
-    29, // llvm.hexagon.V6.vS32b.nt.qpred.ai
-    29, // llvm.hexagon.V6.vS32b.nt.qpred.ai.128B
-    29, // llvm.hexagon.V6.vS32b.qpred.ai
-    29, // llvm.hexagon.V6.vS32b.qpred.ai.128B
-    1, // llvm.hexagon.V6.vabsb
-    1, // llvm.hexagon.V6.vabsb.128B
-    1, // llvm.hexagon.V6.vabsb.sat
-    1, // llvm.hexagon.V6.vabsb.sat.128B
-    1, // llvm.hexagon.V6.vabsdiffh
-    1, // llvm.hexagon.V6.vabsdiffh.128B
-    1, // llvm.hexagon.V6.vabsdiffub
-    1, // llvm.hexagon.V6.vabsdiffub.128B
-    1, // llvm.hexagon.V6.vabsdiffuh
-    1, // llvm.hexagon.V6.vabsdiffuh.128B
-    1, // llvm.hexagon.V6.vabsdiffw
-    1, // llvm.hexagon.V6.vabsdiffw.128B
-    1, // llvm.hexagon.V6.vabsh
-    1, // llvm.hexagon.V6.vabsh.128B
-    1, // llvm.hexagon.V6.vabsh.sat
-    1, // llvm.hexagon.V6.vabsh.sat.128B
-    1, // llvm.hexagon.V6.vabsw
-    1, // llvm.hexagon.V6.vabsw.128B
-    1, // llvm.hexagon.V6.vabsw.sat
-    1, // llvm.hexagon.V6.vabsw.sat.128B
-    1, // llvm.hexagon.V6.vaddb
-    1, // llvm.hexagon.V6.vaddb.128B
-    1, // llvm.hexagon.V6.vaddb.dv
-    1, // llvm.hexagon.V6.vaddb.dv.128B
-    1, // llvm.hexagon.V6.vaddbnq
-    1, // llvm.hexagon.V6.vaddbnq.128B
-    1, // llvm.hexagon.V6.vaddbq
-    1, // llvm.hexagon.V6.vaddbq.128B
-    1, // llvm.hexagon.V6.vaddbsat
-    1, // llvm.hexagon.V6.vaddbsat.128B
-    1, // llvm.hexagon.V6.vaddbsat.dv
-    1, // llvm.hexagon.V6.vaddbsat.dv.128B
-    1, // llvm.hexagon.V6.vaddcarry
-    1, // llvm.hexagon.V6.vaddcarry.128B
-    1, // llvm.hexagon.V6.vaddcarrysat
-    1, // llvm.hexagon.V6.vaddcarrysat.128B
-    1, // llvm.hexagon.V6.vaddclbh
-    1, // llvm.hexagon.V6.vaddclbh.128B
-    1, // llvm.hexagon.V6.vaddclbw
-    1, // llvm.hexagon.V6.vaddclbw.128B
-    1, // llvm.hexagon.V6.vaddh
-    1, // llvm.hexagon.V6.vaddh.128B
-    1, // llvm.hexagon.V6.vaddh.dv
-    1, // llvm.hexagon.V6.vaddh.dv.128B
-    1, // llvm.hexagon.V6.vaddhnq
-    1, // llvm.hexagon.V6.vaddhnq.128B
-    1, // llvm.hexagon.V6.vaddhq
-    1, // llvm.hexagon.V6.vaddhq.128B
-    1, // llvm.hexagon.V6.vaddhsat
-    1, // llvm.hexagon.V6.vaddhsat.128B
-    1, // llvm.hexagon.V6.vaddhsat.dv
-    1, // llvm.hexagon.V6.vaddhsat.dv.128B
-    1, // llvm.hexagon.V6.vaddhw
-    1, // llvm.hexagon.V6.vaddhw.128B
-    1, // llvm.hexagon.V6.vaddhw.acc
-    1, // llvm.hexagon.V6.vaddhw.acc.128B
-    1, // llvm.hexagon.V6.vaddubh
-    1, // llvm.hexagon.V6.vaddubh.128B
-    1, // llvm.hexagon.V6.vaddubh.acc
-    1, // llvm.hexagon.V6.vaddubh.acc.128B
-    1, // llvm.hexagon.V6.vaddubsat
-    1, // llvm.hexagon.V6.vaddubsat.128B
-    1, // llvm.hexagon.V6.vaddubsat.dv
-    1, // llvm.hexagon.V6.vaddubsat.dv.128B
-    1, // llvm.hexagon.V6.vaddububb.sat
-    1, // llvm.hexagon.V6.vaddububb.sat.128B
-    1, // llvm.hexagon.V6.vadduhsat
-    1, // llvm.hexagon.V6.vadduhsat.128B
-    1, // llvm.hexagon.V6.vadduhsat.dv
-    1, // llvm.hexagon.V6.vadduhsat.dv.128B
-    1, // llvm.hexagon.V6.vadduhw
-    1, // llvm.hexagon.V6.vadduhw.128B
-    1, // llvm.hexagon.V6.vadduhw.acc
-    1, // llvm.hexagon.V6.vadduhw.acc.128B
-    1, // llvm.hexagon.V6.vadduwsat
-    1, // llvm.hexagon.V6.vadduwsat.128B
-    1, // llvm.hexagon.V6.vadduwsat.dv
-    1, // llvm.hexagon.V6.vadduwsat.dv.128B
-    1, // llvm.hexagon.V6.vaddw
-    1, // llvm.hexagon.V6.vaddw.128B
-    1, // llvm.hexagon.V6.vaddw.dv
-    1, // llvm.hexagon.V6.vaddw.dv.128B
-    1, // llvm.hexagon.V6.vaddwnq
-    1, // llvm.hexagon.V6.vaddwnq.128B
-    1, // llvm.hexagon.V6.vaddwq
-    1, // llvm.hexagon.V6.vaddwq.128B
-    1, // llvm.hexagon.V6.vaddwsat
-    1, // llvm.hexagon.V6.vaddwsat.128B
-    1, // llvm.hexagon.V6.vaddwsat.dv
-    1, // llvm.hexagon.V6.vaddwsat.dv.128B
-    1, // llvm.hexagon.V6.valignb
-    1, // llvm.hexagon.V6.valignb.128B
-    27, // llvm.hexagon.V6.valignbi
-    27, // llvm.hexagon.V6.valignbi.128B
-    1, // llvm.hexagon.V6.vand
-    1, // llvm.hexagon.V6.vand.128B
-    1, // llvm.hexagon.V6.vandnqrt
-    1, // llvm.hexagon.V6.vandnqrt.128B
-    1, // llvm.hexagon.V6.vandnqrt.acc
-    1, // llvm.hexagon.V6.vandnqrt.acc.128B
-    1, // llvm.hexagon.V6.vandqrt
-    1, // llvm.hexagon.V6.vandqrt.128B
-    1, // llvm.hexagon.V6.vandqrt.acc
-    1, // llvm.hexagon.V6.vandqrt.acc.128B
-    1, // llvm.hexagon.V6.vandvnqv
-    1, // llvm.hexagon.V6.vandvnqv.128B
-    1, // llvm.hexagon.V6.vandvqv
-    1, // llvm.hexagon.V6.vandvqv.128B
-    1, // llvm.hexagon.V6.vandvrt
-    1, // llvm.hexagon.V6.vandvrt.128B
-    1, // llvm.hexagon.V6.vandvrt.acc
-    1, // llvm.hexagon.V6.vandvrt.acc.128B
-    1, // llvm.hexagon.V6.vaslh
-    1, // llvm.hexagon.V6.vaslh.128B
-    1, // llvm.hexagon.V6.vaslh.acc
-    1, // llvm.hexagon.V6.vaslh.acc.128B
-    1, // llvm.hexagon.V6.vaslhv
-    1, // llvm.hexagon.V6.vaslhv.128B
-    1, // llvm.hexagon.V6.vaslw
-    1, // llvm.hexagon.V6.vaslw.128B
-    1, // llvm.hexagon.V6.vaslw.acc
-    1, // llvm.hexagon.V6.vaslw.acc.128B
-    1, // llvm.hexagon.V6.vaslwv
-    1, // llvm.hexagon.V6.vaslwv.128B
-    1, // llvm.hexagon.V6.vasr.into
-    1, // llvm.hexagon.V6.vasr.into.128B
-    1, // llvm.hexagon.V6.vasrh
-    1, // llvm.hexagon.V6.vasrh.128B
-    1, // llvm.hexagon.V6.vasrh.acc
-    1, // llvm.hexagon.V6.vasrh.acc.128B
-    1, // llvm.hexagon.V6.vasrhbrndsat
-    1, // llvm.hexagon.V6.vasrhbrndsat.128B
-    1, // llvm.hexagon.V6.vasrhbsat
-    1, // llvm.hexagon.V6.vasrhbsat.128B
-    1, // llvm.hexagon.V6.vasrhubrndsat
-    1, // llvm.hexagon.V6.vasrhubrndsat.128B
-    1, // llvm.hexagon.V6.vasrhubsat
-    1, // llvm.hexagon.V6.vasrhubsat.128B
-    1, // llvm.hexagon.V6.vasrhv
-    1, // llvm.hexagon.V6.vasrhv.128B
-    1, // llvm.hexagon.V6.vasruhubrndsat
-    1, // llvm.hexagon.V6.vasruhubrndsat.128B
-    1, // llvm.hexagon.V6.vasruhubsat
-    1, // llvm.hexagon.V6.vasruhubsat.128B
-    1, // llvm.hexagon.V6.vasruwuhrndsat
-    1, // llvm.hexagon.V6.vasruwuhrndsat.128B
-    1, // llvm.hexagon.V6.vasruwuhsat
-    1, // llvm.hexagon.V6.vasruwuhsat.128B
-    1, // llvm.hexagon.V6.vasrw
-    1, // llvm.hexagon.V6.vasrw.128B
-    1, // llvm.hexagon.V6.vasrw.acc
-    1, // llvm.hexagon.V6.vasrw.acc.128B
-    1, // llvm.hexagon.V6.vasrwh
-    1, // llvm.hexagon.V6.vasrwh.128B
-    1, // llvm.hexagon.V6.vasrwhrndsat
-    1, // llvm.hexagon.V6.vasrwhrndsat.128B
-    1, // llvm.hexagon.V6.vasrwhsat
-    1, // llvm.hexagon.V6.vasrwhsat.128B
-    1, // llvm.hexagon.V6.vasrwuhrndsat
-    1, // llvm.hexagon.V6.vasrwuhrndsat.128B
-    1, // llvm.hexagon.V6.vasrwuhsat
-    1, // llvm.hexagon.V6.vasrwuhsat.128B
-    1, // llvm.hexagon.V6.vasrwv
-    1, // llvm.hexagon.V6.vasrwv.128B
-    1, // llvm.hexagon.V6.vassign
-    1, // llvm.hexagon.V6.vassign.128B
-    1, // llvm.hexagon.V6.vassignp
-    1, // llvm.hexagon.V6.vassignp.128B
-    1, // llvm.hexagon.V6.vavgb
-    1, // llvm.hexagon.V6.vavgb.128B
-    1, // llvm.hexagon.V6.vavgbrnd
-    1, // llvm.hexagon.V6.vavgbrnd.128B
-    1, // llvm.hexagon.V6.vavgh
-    1, // llvm.hexagon.V6.vavgh.128B
-    1, // llvm.hexagon.V6.vavghrnd
-    1, // llvm.hexagon.V6.vavghrnd.128B
-    1, // llvm.hexagon.V6.vavgub
-    1, // llvm.hexagon.V6.vavgub.128B
-    1, // llvm.hexagon.V6.vavgubrnd
-    1, // llvm.hexagon.V6.vavgubrnd.128B
-    1, // llvm.hexagon.V6.vavguh
-    1, // llvm.hexagon.V6.vavguh.128B
-    1, // llvm.hexagon.V6.vavguhrnd
-    1, // llvm.hexagon.V6.vavguhrnd.128B
-    1, // llvm.hexagon.V6.vavguw
-    1, // llvm.hexagon.V6.vavguw.128B
-    1, // llvm.hexagon.V6.vavguwrnd
-    1, // llvm.hexagon.V6.vavguwrnd.128B
-    1, // llvm.hexagon.V6.vavgw
-    1, // llvm.hexagon.V6.vavgw.128B
-    1, // llvm.hexagon.V6.vavgwrnd
-    1, // llvm.hexagon.V6.vavgwrnd.128B
-    1, // llvm.hexagon.V6.vcl0h
-    1, // llvm.hexagon.V6.vcl0h.128B
-    1, // llvm.hexagon.V6.vcl0w
-    1, // llvm.hexagon.V6.vcl0w.128B
-    1, // llvm.hexagon.V6.vcombine
-    1, // llvm.hexagon.V6.vcombine.128B
-    1, // llvm.hexagon.V6.vd0
-    1, // llvm.hexagon.V6.vd0.128B
-    1, // llvm.hexagon.V6.vdd0
-    1, // llvm.hexagon.V6.vdd0.128B
-    1, // llvm.hexagon.V6.vdealb
-    1, // llvm.hexagon.V6.vdealb.128B
-    1, // llvm.hexagon.V6.vdealb4w
-    1, // llvm.hexagon.V6.vdealb4w.128B
-    1, // llvm.hexagon.V6.vdealh
-    1, // llvm.hexagon.V6.vdealh.128B
-    1, // llvm.hexagon.V6.vdealvdd
-    1, // llvm.hexagon.V6.vdealvdd.128B
-    1, // llvm.hexagon.V6.vdelta
-    1, // llvm.hexagon.V6.vdelta.128B
-    1, // llvm.hexagon.V6.vdmpybus
-    1, // llvm.hexagon.V6.vdmpybus.128B
-    1, // llvm.hexagon.V6.vdmpybus.acc
-    1, // llvm.hexagon.V6.vdmpybus.acc.128B
-    1, // llvm.hexagon.V6.vdmpybus.dv
-    1, // llvm.hexagon.V6.vdmpybus.dv.128B
-    1, // llvm.hexagon.V6.vdmpybus.dv.acc
-    1, // llvm.hexagon.V6.vdmpybus.dv.acc.128B
-    1, // llvm.hexagon.V6.vdmpyhb
-    1, // llvm.hexagon.V6.vdmpyhb.128B
-    1, // llvm.hexagon.V6.vdmpyhb.acc
-    1, // llvm.hexagon.V6.vdmpyhb.acc.128B
-    1, // llvm.hexagon.V6.vdmpyhb.dv
-    1, // llvm.hexagon.V6.vdmpyhb.dv.128B
-    1, // llvm.hexagon.V6.vdmpyhb.dv.acc
-    1, // llvm.hexagon.V6.vdmpyhb.dv.acc.128B
-    1, // llvm.hexagon.V6.vdmpyhisat
-    1, // llvm.hexagon.V6.vdmpyhisat.128B
-    1, // llvm.hexagon.V6.vdmpyhisat.acc
-    1, // llvm.hexagon.V6.vdmpyhisat.acc.128B
-    1, // llvm.hexagon.V6.vdmpyhsat
-    1, // llvm.hexagon.V6.vdmpyhsat.128B
-    1, // llvm.hexagon.V6.vdmpyhsat.acc
-    1, // llvm.hexagon.V6.vdmpyhsat.acc.128B
-    1, // llvm.hexagon.V6.vdmpyhsuisat
-    1, // llvm.hexagon.V6.vdmpyhsuisat.128B
-    1, // llvm.hexagon.V6.vdmpyhsuisat.acc
-    1, // llvm.hexagon.V6.vdmpyhsuisat.acc.128B
-    1, // llvm.hexagon.V6.vdmpyhsusat
-    1, // llvm.hexagon.V6.vdmpyhsusat.128B
-    1, // llvm.hexagon.V6.vdmpyhsusat.acc
-    1, // llvm.hexagon.V6.vdmpyhsusat.acc.128B
-    1, // llvm.hexagon.V6.vdmpyhvsat
-    1, // llvm.hexagon.V6.vdmpyhvsat.128B
-    1, // llvm.hexagon.V6.vdmpyhvsat.acc
-    1, // llvm.hexagon.V6.vdmpyhvsat.acc.128B
-    1, // llvm.hexagon.V6.vdsaduh
-    1, // llvm.hexagon.V6.vdsaduh.128B
-    1, // llvm.hexagon.V6.vdsaduh.acc
-    1, // llvm.hexagon.V6.vdsaduh.acc.128B
-    1, // llvm.hexagon.V6.veqb
-    1, // llvm.hexagon.V6.veqb.128B
-    1, // llvm.hexagon.V6.veqb.and
-    1, // llvm.hexagon.V6.veqb.and.128B
-    1, // llvm.hexagon.V6.veqb.or
-    1, // llvm.hexagon.V6.veqb.or.128B
-    1, // llvm.hexagon.V6.veqb.xor
-    1, // llvm.hexagon.V6.veqb.xor.128B
-    1, // llvm.hexagon.V6.veqh
-    1, // llvm.hexagon.V6.veqh.128B
-    1, // llvm.hexagon.V6.veqh.and
-    1, // llvm.hexagon.V6.veqh.and.128B
-    1, // llvm.hexagon.V6.veqh.or
-    1, // llvm.hexagon.V6.veqh.or.128B
-    1, // llvm.hexagon.V6.veqh.xor
-    1, // llvm.hexagon.V6.veqh.xor.128B
-    1, // llvm.hexagon.V6.veqw
-    1, // llvm.hexagon.V6.veqw.128B
-    1, // llvm.hexagon.V6.veqw.and
-    1, // llvm.hexagon.V6.veqw.and.128B
-    1, // llvm.hexagon.V6.veqw.or
-    1, // llvm.hexagon.V6.veqw.or.128B
-    1, // llvm.hexagon.V6.veqw.xor
-    1, // llvm.hexagon.V6.veqw.xor.128B
-    29, // llvm.hexagon.V6.vgathermh
-    29, // llvm.hexagon.V6.vgathermh.128B
-    29, // llvm.hexagon.V6.vgathermhq
-    29, // llvm.hexagon.V6.vgathermhq.128B
-    29, // llvm.hexagon.V6.vgathermhw
-    29, // llvm.hexagon.V6.vgathermhw.128B
-    29, // llvm.hexagon.V6.vgathermhwq
-    29, // llvm.hexagon.V6.vgathermhwq.128B
-    29, // llvm.hexagon.V6.vgathermw
-    29, // llvm.hexagon.V6.vgathermw.128B
-    29, // llvm.hexagon.V6.vgathermwq
-    29, // llvm.hexagon.V6.vgathermwq.128B
-    1, // llvm.hexagon.V6.vgtb
-    1, // llvm.hexagon.V6.vgtb.128B
-    1, // llvm.hexagon.V6.vgtb.and
-    1, // llvm.hexagon.V6.vgtb.and.128B
-    1, // llvm.hexagon.V6.vgtb.or
-    1, // llvm.hexagon.V6.vgtb.or.128B
-    1, // llvm.hexagon.V6.vgtb.xor
-    1, // llvm.hexagon.V6.vgtb.xor.128B
-    1, // llvm.hexagon.V6.vgth
-    1, // llvm.hexagon.V6.vgth.128B
-    1, // llvm.hexagon.V6.vgth.and
-    1, // llvm.hexagon.V6.vgth.and.128B
-    1, // llvm.hexagon.V6.vgth.or
-    1, // llvm.hexagon.V6.vgth.or.128B
-    1, // llvm.hexagon.V6.vgth.xor
-    1, // llvm.hexagon.V6.vgth.xor.128B
-    1, // llvm.hexagon.V6.vgtub
-    1, // llvm.hexagon.V6.vgtub.128B
-    1, // llvm.hexagon.V6.vgtub.and
-    1, // llvm.hexagon.V6.vgtub.and.128B
-    1, // llvm.hexagon.V6.vgtub.or
-    1, // llvm.hexagon.V6.vgtub.or.128B
-    1, // llvm.hexagon.V6.vgtub.xor
-    1, // llvm.hexagon.V6.vgtub.xor.128B
-    1, // llvm.hexagon.V6.vgtuh
-    1, // llvm.hexagon.V6.vgtuh.128B
-    1, // llvm.hexagon.V6.vgtuh.and
-    1, // llvm.hexagon.V6.vgtuh.and.128B
-    1, // llvm.hexagon.V6.vgtuh.or
-    1, // llvm.hexagon.V6.vgtuh.or.128B
-    1, // llvm.hexagon.V6.vgtuh.xor
-    1, // llvm.hexagon.V6.vgtuh.xor.128B
-    1, // llvm.hexagon.V6.vgtuw
-    1, // llvm.hexagon.V6.vgtuw.128B
-    1, // llvm.hexagon.V6.vgtuw.and
-    1, // llvm.hexagon.V6.vgtuw.and.128B
-    1, // llvm.hexagon.V6.vgtuw.or
-    1, // llvm.hexagon.V6.vgtuw.or.128B
-    1, // llvm.hexagon.V6.vgtuw.xor
-    1, // llvm.hexagon.V6.vgtuw.xor.128B
-    1, // llvm.hexagon.V6.vgtw
-    1, // llvm.hexagon.V6.vgtw.128B
-    1, // llvm.hexagon.V6.vgtw.and
-    1, // llvm.hexagon.V6.vgtw.and.128B
-    1, // llvm.hexagon.V6.vgtw.or
-    1, // llvm.hexagon.V6.vgtw.or.128B
-    1, // llvm.hexagon.V6.vgtw.xor
-    1, // llvm.hexagon.V6.vgtw.xor.128B
-    1, // llvm.hexagon.V6.vinsertwr
-    1, // llvm.hexagon.V6.vinsertwr.128B
-    1, // llvm.hexagon.V6.vlalignb
-    1, // llvm.hexagon.V6.vlalignb.128B
-    27, // llvm.hexagon.V6.vlalignbi
-    27, // llvm.hexagon.V6.vlalignbi.128B
-    1, // llvm.hexagon.V6.vlsrb
-    1, // llvm.hexagon.V6.vlsrb.128B
-    1, // llvm.hexagon.V6.vlsrh
-    1, // llvm.hexagon.V6.vlsrh.128B
-    1, // llvm.hexagon.V6.vlsrhv
-    1, // llvm.hexagon.V6.vlsrhv.128B
-    1, // llvm.hexagon.V6.vlsrw
-    1, // llvm.hexagon.V6.vlsrw.128B
-    1, // llvm.hexagon.V6.vlsrwv
-    1, // llvm.hexagon.V6.vlsrwv.128B
-    1, // llvm.hexagon.V6.vlut4
-    1, // llvm.hexagon.V6.vlut4.128B
-    1, // llvm.hexagon.V6.vlutvvb
-    1, // llvm.hexagon.V6.vlutvvb.128B
-    1, // llvm.hexagon.V6.vlutvvb.nm
-    1, // llvm.hexagon.V6.vlutvvb.nm.128B
-    1, // llvm.hexagon.V6.vlutvvb.oracc
-    1, // llvm.hexagon.V6.vlutvvb.oracc.128B
-    125, // llvm.hexagon.V6.vlutvvb.oracci
-    125, // llvm.hexagon.V6.vlutvvb.oracci.128B
-    27, // llvm.hexagon.V6.vlutvvbi
-    27, // llvm.hexagon.V6.vlutvvbi.128B
-    1, // llvm.hexagon.V6.vlutvwh
-    1, // llvm.hexagon.V6.vlutvwh.128B
-    1, // llvm.hexagon.V6.vlutvwh.nm
-    1, // llvm.hexagon.V6.vlutvwh.nm.128B
-    1, // llvm.hexagon.V6.vlutvwh.oracc
-    1, // llvm.hexagon.V6.vlutvwh.oracc.128B
-    125, // llvm.hexagon.V6.vlutvwh.oracci
-    125, // llvm.hexagon.V6.vlutvwh.oracci.128B
-    27, // llvm.hexagon.V6.vlutvwhi
-    27, // llvm.hexagon.V6.vlutvwhi.128B
-    29, // llvm.hexagon.V6.vmaskedstorenq
-    29, // llvm.hexagon.V6.vmaskedstorenq.128B
-    29, // llvm.hexagon.V6.vmaskedstorentnq
-    29, // llvm.hexagon.V6.vmaskedstorentnq.128B
-    29, // llvm.hexagon.V6.vmaskedstorentq
-    29, // llvm.hexagon.V6.vmaskedstorentq.128B
-    29, // llvm.hexagon.V6.vmaskedstoreq
-    29, // llvm.hexagon.V6.vmaskedstoreq.128B
-    1, // llvm.hexagon.V6.vmaxb
-    1, // llvm.hexagon.V6.vmaxb.128B
-    1, // llvm.hexagon.V6.vmaxh
-    1, // llvm.hexagon.V6.vmaxh.128B
-    1, // llvm.hexagon.V6.vmaxub
-    1, // llvm.hexagon.V6.vmaxub.128B
-    1, // llvm.hexagon.V6.vmaxuh
-    1, // llvm.hexagon.V6.vmaxuh.128B
-    1, // llvm.hexagon.V6.vmaxw
-    1, // llvm.hexagon.V6.vmaxw.128B
-    1, // llvm.hexagon.V6.vminb
-    1, // llvm.hexagon.V6.vminb.128B
-    1, // llvm.hexagon.V6.vminh
-    1, // llvm.hexagon.V6.vminh.128B
-    1, // llvm.hexagon.V6.vminub
-    1, // llvm.hexagon.V6.vminub.128B
-    1, // llvm.hexagon.V6.vminuh
-    1, // llvm.hexagon.V6.vminuh.128B
-    1, // llvm.hexagon.V6.vminw
-    1, // llvm.hexagon.V6.vminw.128B
-    1, // llvm.hexagon.V6.vmpabus
-    1, // llvm.hexagon.V6.vmpabus.128B
-    1, // llvm.hexagon.V6.vmpabus.acc
-    1, // llvm.hexagon.V6.vmpabus.acc.128B
-    1, // llvm.hexagon.V6.vmpabusv
-    1, // llvm.hexagon.V6.vmpabusv.128B
-    1, // llvm.hexagon.V6.vmpabuu
-    1, // llvm.hexagon.V6.vmpabuu.128B
-    1, // llvm.hexagon.V6.vmpabuu.acc
-    1, // llvm.hexagon.V6.vmpabuu.acc.128B
-    1, // llvm.hexagon.V6.vmpabuuv
-    1, // llvm.hexagon.V6.vmpabuuv.128B
-    1, // llvm.hexagon.V6.vmpahb
-    1, // llvm.hexagon.V6.vmpahb.128B
-    1, // llvm.hexagon.V6.vmpahb.acc
-    1, // llvm.hexagon.V6.vmpahb.acc.128B
-    1, // llvm.hexagon.V6.vmpahhsat
-    1, // llvm.hexagon.V6.vmpahhsat.128B
-    1, // llvm.hexagon.V6.vmpauhb
-    1, // llvm.hexagon.V6.vmpauhb.128B
-    1, // llvm.hexagon.V6.vmpauhb.acc
-    1, // llvm.hexagon.V6.vmpauhb.acc.128B
-    1, // llvm.hexagon.V6.vmpauhuhsat
-    1, // llvm.hexagon.V6.vmpauhuhsat.128B
-    1, // llvm.hexagon.V6.vmpsuhuhsat
-    1, // llvm.hexagon.V6.vmpsuhuhsat.128B
-    1, // llvm.hexagon.V6.vmpybus
-    1, // llvm.hexagon.V6.vmpybus.128B
-    1, // llvm.hexagon.V6.vmpybus.acc
-    1, // llvm.hexagon.V6.vmpybus.acc.128B
-    1, // llvm.hexagon.V6.vmpybusv
-    1, // llvm.hexagon.V6.vmpybusv.128B
-    1, // llvm.hexagon.V6.vmpybusv.acc
-    1, // llvm.hexagon.V6.vmpybusv.acc.128B
-    1, // llvm.hexagon.V6.vmpybv
-    1, // llvm.hexagon.V6.vmpybv.128B
-    1, // llvm.hexagon.V6.vmpybv.acc
-    1, // llvm.hexagon.V6.vmpybv.acc.128B
-    1, // llvm.hexagon.V6.vmpyewuh
-    1, // llvm.hexagon.V6.vmpyewuh.128B
-    1, // llvm.hexagon.V6.vmpyewuh.64
-    1, // llvm.hexagon.V6.vmpyewuh.64.128B
-    1, // llvm.hexagon.V6.vmpyh
-    1, // llvm.hexagon.V6.vmpyh.128B
-    1, // llvm.hexagon.V6.vmpyh.acc
-    1, // llvm.hexagon.V6.vmpyh.acc.128B
-    1, // llvm.hexagon.V6.vmpyhsat.acc
-    1, // llvm.hexagon.V6.vmpyhsat.acc.128B
-    1, // llvm.hexagon.V6.vmpyhsrs
-    1, // llvm.hexagon.V6.vmpyhsrs.128B
-    1, // llvm.hexagon.V6.vmpyhss
-    1, // llvm.hexagon.V6.vmpyhss.128B
-    1, // llvm.hexagon.V6.vmpyhus
-    1, // llvm.hexagon.V6.vmpyhus.128B
-    1, // llvm.hexagon.V6.vmpyhus.acc
-    1, // llvm.hexagon.V6.vmpyhus.acc.128B
-    1, // llvm.hexagon.V6.vmpyhv
-    1, // llvm.hexagon.V6.vmpyhv.128B
-    1, // llvm.hexagon.V6.vmpyhv.acc
-    1, // llvm.hexagon.V6.vmpyhv.acc.128B
-    1, // llvm.hexagon.V6.vmpyhvsrs
-    1, // llvm.hexagon.V6.vmpyhvsrs.128B
-    1, // llvm.hexagon.V6.vmpyieoh
-    1, // llvm.hexagon.V6.vmpyieoh.128B
-    1, // llvm.hexagon.V6.vmpyiewh.acc
-    1, // llvm.hexagon.V6.vmpyiewh.acc.128B
-    1, // llvm.hexagon.V6.vmpyiewuh
-    1, // llvm.hexagon.V6.vmpyiewuh.128B
-    1, // llvm.hexagon.V6.vmpyiewuh.acc
-    1, // llvm.hexagon.V6.vmpyiewuh.acc.128B
-    1, // llvm.hexagon.V6.vmpyih
-    1, // llvm.hexagon.V6.vmpyih.128B
-    1, // llvm.hexagon.V6.vmpyih.acc
-    1, // llvm.hexagon.V6.vmpyih.acc.128B
-    1, // llvm.hexagon.V6.vmpyihb
-    1, // llvm.hexagon.V6.vmpyihb.128B
-    1, // llvm.hexagon.V6.vmpyihb.acc
-    1, // llvm.hexagon.V6.vmpyihb.acc.128B
-    1, // llvm.hexagon.V6.vmpyiowh
-    1, // llvm.hexagon.V6.vmpyiowh.128B
-    1, // llvm.hexagon.V6.vmpyiwb
-    1, // llvm.hexagon.V6.vmpyiwb.128B
-    1, // llvm.hexagon.V6.vmpyiwb.acc
-    1, // llvm.hexagon.V6.vmpyiwb.acc.128B
-    1, // llvm.hexagon.V6.vmpyiwh
-    1, // llvm.hexagon.V6.vmpyiwh.128B
-    1, // llvm.hexagon.V6.vmpyiwh.acc
-    1, // llvm.hexagon.V6.vmpyiwh.acc.128B
-    1, // llvm.hexagon.V6.vmpyiwub
-    1, // llvm.hexagon.V6.vmpyiwub.128B
-    1, // llvm.hexagon.V6.vmpyiwub.acc
-    1, // llvm.hexagon.V6.vmpyiwub.acc.128B
-    1, // llvm.hexagon.V6.vmpyowh
-    1, // llvm.hexagon.V6.vmpyowh.128B
-    1, // llvm.hexagon.V6.vmpyowh.64.acc
-    1, // llvm.hexagon.V6.vmpyowh.64.acc.128B
-    1, // llvm.hexagon.V6.vmpyowh.rnd
-    1, // llvm.hexagon.V6.vmpyowh.rnd.128B
-    1, // llvm.hexagon.V6.vmpyowh.rnd.sacc
-    1, // llvm.hexagon.V6.vmpyowh.rnd.sacc.128B
-    1, // llvm.hexagon.V6.vmpyowh.sacc
-    1, // llvm.hexagon.V6.vmpyowh.sacc.128B
-    1, // llvm.hexagon.V6.vmpyub
-    1, // llvm.hexagon.V6.vmpyub.128B
-    1, // llvm.hexagon.V6.vmpyub.acc
-    1, // llvm.hexagon.V6.vmpyub.acc.128B
-    1, // llvm.hexagon.V6.vmpyubv
-    1, // llvm.hexagon.V6.vmpyubv.128B
-    1, // llvm.hexagon.V6.vmpyubv.acc
-    1, // llvm.hexagon.V6.vmpyubv.acc.128B
-    1, // llvm.hexagon.V6.vmpyuh
-    1, // llvm.hexagon.V6.vmpyuh.128B
-    1, // llvm.hexagon.V6.vmpyuh.acc
-    1, // llvm.hexagon.V6.vmpyuh.acc.128B
-    1, // llvm.hexagon.V6.vmpyuhe
-    1, // llvm.hexagon.V6.vmpyuhe.128B
-    1, // llvm.hexagon.V6.vmpyuhe.acc
-    1, // llvm.hexagon.V6.vmpyuhe.acc.128B
-    1, // llvm.hexagon.V6.vmpyuhv
-    1, // llvm.hexagon.V6.vmpyuhv.128B
-    1, // llvm.hexagon.V6.vmpyuhv.acc
-    1, // llvm.hexagon.V6.vmpyuhv.acc.128B
-    1, // llvm.hexagon.V6.vmux
-    1, // llvm.hexagon.V6.vmux.128B
-    1, // llvm.hexagon.V6.vnavgb
-    1, // llvm.hexagon.V6.vnavgb.128B
-    1, // llvm.hexagon.V6.vnavgh
-    1, // llvm.hexagon.V6.vnavgh.128B
-    1, // llvm.hexagon.V6.vnavgub
-    1, // llvm.hexagon.V6.vnavgub.128B
-    1, // llvm.hexagon.V6.vnavgw
-    1, // llvm.hexagon.V6.vnavgw.128B
-    1, // llvm.hexagon.V6.vnormamth
-    1, // llvm.hexagon.V6.vnormamth.128B
-    1, // llvm.hexagon.V6.vnormamtw
-    1, // llvm.hexagon.V6.vnormamtw.128B
-    1, // llvm.hexagon.V6.vnot
-    1, // llvm.hexagon.V6.vnot.128B
-    1, // llvm.hexagon.V6.vor
-    1, // llvm.hexagon.V6.vor.128B
-    1, // llvm.hexagon.V6.vpackeb
-    1, // llvm.hexagon.V6.vpackeb.128B
-    1, // llvm.hexagon.V6.vpackeh
-    1, // llvm.hexagon.V6.vpackeh.128B
-    1, // llvm.hexagon.V6.vpackhb.sat
-    1, // llvm.hexagon.V6.vpackhb.sat.128B
-    1, // llvm.hexagon.V6.vpackhub.sat
-    1, // llvm.hexagon.V6.vpackhub.sat.128B
-    1, // llvm.hexagon.V6.vpackob
-    1, // llvm.hexagon.V6.vpackob.128B
-    1, // llvm.hexagon.V6.vpackoh
-    1, // llvm.hexagon.V6.vpackoh.128B
-    1, // llvm.hexagon.V6.vpackwh.sat
-    1, // llvm.hexagon.V6.vpackwh.sat.128B
-    1, // llvm.hexagon.V6.vpackwuh.sat
-    1, // llvm.hexagon.V6.vpackwuh.sat.128B
-    1, // llvm.hexagon.V6.vpopcounth
-    1, // llvm.hexagon.V6.vpopcounth.128B
-    1, // llvm.hexagon.V6.vprefixqb
-    1, // llvm.hexagon.V6.vprefixqb.128B
-    1, // llvm.hexagon.V6.vprefixqh
-    1, // llvm.hexagon.V6.vprefixqh.128B
-    1, // llvm.hexagon.V6.vprefixqw
-    1, // llvm.hexagon.V6.vprefixqw.128B
-    1, // llvm.hexagon.V6.vrdelta
-    1, // llvm.hexagon.V6.vrdelta.128B
-    1, // llvm.hexagon.V6.vrmpybub.rtt
-    1, // llvm.hexagon.V6.vrmpybub.rtt.128B
-    1, // llvm.hexagon.V6.vrmpybub.rtt.acc
-    1, // llvm.hexagon.V6.vrmpybub.rtt.acc.128B
-    1, // llvm.hexagon.V6.vrmpybus
-    1, // llvm.hexagon.V6.vrmpybus.128B
-    1, // llvm.hexagon.V6.vrmpybus.acc
-    1, // llvm.hexagon.V6.vrmpybus.acc.128B
-    27, // llvm.hexagon.V6.vrmpybusi
-    27, // llvm.hexagon.V6.vrmpybusi.128B
-    125, // llvm.hexagon.V6.vrmpybusi.acc
-    125, // llvm.hexagon.V6.vrmpybusi.acc.128B
-    1, // llvm.hexagon.V6.vrmpybusv
-    1, // llvm.hexagon.V6.vrmpybusv.128B
-    1, // llvm.hexagon.V6.vrmpybusv.acc
-    1, // llvm.hexagon.V6.vrmpybusv.acc.128B
-    1, // llvm.hexagon.V6.vrmpybv
-    1, // llvm.hexagon.V6.vrmpybv.128B
-    1, // llvm.hexagon.V6.vrmpybv.acc
-    1, // llvm.hexagon.V6.vrmpybv.acc.128B
-    1, // llvm.hexagon.V6.vrmpyub
-    1, // llvm.hexagon.V6.vrmpyub.128B
-    1, // llvm.hexagon.V6.vrmpyub.acc
-    1, // llvm.hexagon.V6.vrmpyub.acc.128B
-    1, // llvm.hexagon.V6.vrmpyub.rtt
-    1, // llvm.hexagon.V6.vrmpyub.rtt.128B
-    1, // llvm.hexagon.V6.vrmpyub.rtt.acc
-    1, // llvm.hexagon.V6.vrmpyub.rtt.acc.128B
-    27, // llvm.hexagon.V6.vrmpyubi
-    27, // llvm.hexagon.V6.vrmpyubi.128B
-    125, // llvm.hexagon.V6.vrmpyubi.acc
-    125, // llvm.hexagon.V6.vrmpyubi.acc.128B
-    1, // llvm.hexagon.V6.vrmpyubv
-    1, // llvm.hexagon.V6.vrmpyubv.128B
-    1, // llvm.hexagon.V6.vrmpyubv.acc
-    1, // llvm.hexagon.V6.vrmpyubv.acc.128B
-    1, // llvm.hexagon.V6.vror
-    1, // llvm.hexagon.V6.vror.128B
-    1, // llvm.hexagon.V6.vrotr
-    1, // llvm.hexagon.V6.vrotr.128B
-    1, // llvm.hexagon.V6.vroundhb
-    1, // llvm.hexagon.V6.vroundhb.128B
-    1, // llvm.hexagon.V6.vroundhub
-    1, // llvm.hexagon.V6.vroundhub.128B
-    1, // llvm.hexagon.V6.vrounduhub
-    1, // llvm.hexagon.V6.vrounduhub.128B
-    1, // llvm.hexagon.V6.vrounduwuh
-    1, // llvm.hexagon.V6.vrounduwuh.128B
-    1, // llvm.hexagon.V6.vroundwh
-    1, // llvm.hexagon.V6.vroundwh.128B
-    1, // llvm.hexagon.V6.vroundwuh
-    1, // llvm.hexagon.V6.vroundwuh.128B
-    27, // llvm.hexagon.V6.vrsadubi
-    27, // llvm.hexagon.V6.vrsadubi.128B
-    125, // llvm.hexagon.V6.vrsadubi.acc
-    125, // llvm.hexagon.V6.vrsadubi.acc.128B
-    1, // llvm.hexagon.V6.vsatdw
-    1, // llvm.hexagon.V6.vsatdw.128B
-    1, // llvm.hexagon.V6.vsathub
-    1, // llvm.hexagon.V6.vsathub.128B
-    1, // llvm.hexagon.V6.vsatuwuh
-    1, // llvm.hexagon.V6.vsatuwuh.128B
-    1, // llvm.hexagon.V6.vsatwh
-    1, // llvm.hexagon.V6.vsatwh.128B
-    1, // llvm.hexagon.V6.vsb
-    1, // llvm.hexagon.V6.vsb.128B
-    50, // llvm.hexagon.V6.vscattermh
-    50, // llvm.hexagon.V6.vscattermh.128B
-    50, // llvm.hexagon.V6.vscattermh.add
-    50, // llvm.hexagon.V6.vscattermh.add.128B
-    50, // llvm.hexagon.V6.vscattermhq
-    50, // llvm.hexagon.V6.vscattermhq.128B
-    50, // llvm.hexagon.V6.vscattermhw
-    50, // llvm.hexagon.V6.vscattermhw.128B
-    50, // llvm.hexagon.V6.vscattermhw.add
-    50, // llvm.hexagon.V6.vscattermhw.add.128B
-    50, // llvm.hexagon.V6.vscattermhwq
-    50, // llvm.hexagon.V6.vscattermhwq.128B
-    50, // llvm.hexagon.V6.vscattermw
-    50, // llvm.hexagon.V6.vscattermw.128B
-    50, // llvm.hexagon.V6.vscattermw.add
-    50, // llvm.hexagon.V6.vscattermw.add.128B
-    50, // llvm.hexagon.V6.vscattermwq
-    50, // llvm.hexagon.V6.vscattermwq.128B
-    1, // llvm.hexagon.V6.vsh
-    1, // llvm.hexagon.V6.vsh.128B
-    1, // llvm.hexagon.V6.vshufeh
-    1, // llvm.hexagon.V6.vshufeh.128B
-    1, // llvm.hexagon.V6.vshuffb
-    1, // llvm.hexagon.V6.vshuffb.128B
-    1, // llvm.hexagon.V6.vshuffeb
-    1, // llvm.hexagon.V6.vshuffeb.128B
-    1, // llvm.hexagon.V6.vshuffh
-    1, // llvm.hexagon.V6.vshuffh.128B
-    1, // llvm.hexagon.V6.vshuffob
-    1, // llvm.hexagon.V6.vshuffob.128B
-    1, // llvm.hexagon.V6.vshuffvdd
-    1, // llvm.hexagon.V6.vshuffvdd.128B
-    1, // llvm.hexagon.V6.vshufoeb
-    1, // llvm.hexagon.V6.vshufoeb.128B
-    1, // llvm.hexagon.V6.vshufoeh
-    1, // llvm.hexagon.V6.vshufoeh.128B
-    1, // llvm.hexagon.V6.vshufoh
-    1, // llvm.hexagon.V6.vshufoh.128B
-    1, // llvm.hexagon.V6.vsubb
-    1, // llvm.hexagon.V6.vsubb.128B
-    1, // llvm.hexagon.V6.vsubb.dv
-    1, // llvm.hexagon.V6.vsubb.dv.128B
-    1, // llvm.hexagon.V6.vsubbnq
-    1, // llvm.hexagon.V6.vsubbnq.128B
-    1, // llvm.hexagon.V6.vsubbq
-    1, // llvm.hexagon.V6.vsubbq.128B
-    1, // llvm.hexagon.V6.vsubbsat
-    1, // llvm.hexagon.V6.vsubbsat.128B
-    1, // llvm.hexagon.V6.vsubbsat.dv
-    1, // llvm.hexagon.V6.vsubbsat.dv.128B
-    1, // llvm.hexagon.V6.vsubcarry
-    1, // llvm.hexagon.V6.vsubcarry.128B
-    1, // llvm.hexagon.V6.vsubh
-    1, // llvm.hexagon.V6.vsubh.128B
-    1, // llvm.hexagon.V6.vsubh.dv
-    1, // llvm.hexagon.V6.vsubh.dv.128B
-    1, // llvm.hexagon.V6.vsubhnq
-    1, // llvm.hexagon.V6.vsubhnq.128B
-    1, // llvm.hexagon.V6.vsubhq
-    1, // llvm.hexagon.V6.vsubhq.128B
-    1, // llvm.hexagon.V6.vsubhsat
-    1, // llvm.hexagon.V6.vsubhsat.128B
-    1, // llvm.hexagon.V6.vsubhsat.dv
-    1, // llvm.hexagon.V6.vsubhsat.dv.128B
-    1, // llvm.hexagon.V6.vsubhw
-    1, // llvm.hexagon.V6.vsubhw.128B
-    1, // llvm.hexagon.V6.vsububh
-    1, // llvm.hexagon.V6.vsububh.128B
-    1, // llvm.hexagon.V6.vsububsat
-    1, // llvm.hexagon.V6.vsububsat.128B
-    1, // llvm.hexagon.V6.vsububsat.dv
-    1, // llvm.hexagon.V6.vsububsat.dv.128B
-    1, // llvm.hexagon.V6.vsubububb.sat
-    1, // llvm.hexagon.V6.vsubububb.sat.128B
-    1, // llvm.hexagon.V6.vsubuhsat
-    1, // llvm.hexagon.V6.vsubuhsat.128B
-    1, // llvm.hexagon.V6.vsubuhsat.dv
-    1, // llvm.hexagon.V6.vsubuhsat.dv.128B
-    1, // llvm.hexagon.V6.vsubuhw
-    1, // llvm.hexagon.V6.vsubuhw.128B
-    1, // llvm.hexagon.V6.vsubuwsat
-    1, // llvm.hexagon.V6.vsubuwsat.128B
-    1, // llvm.hexagon.V6.vsubuwsat.dv
-    1, // llvm.hexagon.V6.vsubuwsat.dv.128B
-    1, // llvm.hexagon.V6.vsubw
-    1, // llvm.hexagon.V6.vsubw.128B
-    1, // llvm.hexagon.V6.vsubw.dv
-    1, // llvm.hexagon.V6.vsubw.dv.128B
-    1, // llvm.hexagon.V6.vsubwnq
-    1, // llvm.hexagon.V6.vsubwnq.128B
-    1, // llvm.hexagon.V6.vsubwq
-    1, // llvm.hexagon.V6.vsubwq.128B
-    1, // llvm.hexagon.V6.vsubwsat
-    1, // llvm.hexagon.V6.vsubwsat.128B
-    1, // llvm.hexagon.V6.vsubwsat.dv
-    1, // llvm.hexagon.V6.vsubwsat.dv.128B
-    1, // llvm.hexagon.V6.vswap
-    1, // llvm.hexagon.V6.vswap.128B
-    1, // llvm.hexagon.V6.vtmpyb
-    1, // llvm.hexagon.V6.vtmpyb.128B
-    1, // llvm.hexagon.V6.vtmpyb.acc
-    1, // llvm.hexagon.V6.vtmpyb.acc.128B
-    1, // llvm.hexagon.V6.vtmpybus
-    1, // llvm.hexagon.V6.vtmpybus.128B
-    1, // llvm.hexagon.V6.vtmpybus.acc
-    1, // llvm.hexagon.V6.vtmpybus.acc.128B
-    1, // llvm.hexagon.V6.vtmpyhb
-    1, // llvm.hexagon.V6.vtmpyhb.128B
-    1, // llvm.hexagon.V6.vtmpyhb.acc
-    1, // llvm.hexagon.V6.vtmpyhb.acc.128B
-    1, // llvm.hexagon.V6.vtran2x2.map
-    1, // llvm.hexagon.V6.vtran2x2.map.128B
-    1, // llvm.hexagon.V6.vunpackb
-    1, // llvm.hexagon.V6.vunpackb.128B
-    1, // llvm.hexagon.V6.vunpackh
-    1, // llvm.hexagon.V6.vunpackh.128B
-    1, // llvm.hexagon.V6.vunpackob
-    1, // llvm.hexagon.V6.vunpackob.128B
-    1, // llvm.hexagon.V6.vunpackoh
-    1, // llvm.hexagon.V6.vunpackoh.128B
-    1, // llvm.hexagon.V6.vunpackub
-    1, // llvm.hexagon.V6.vunpackub.128B
-    1, // llvm.hexagon.V6.vunpackuh
-    1, // llvm.hexagon.V6.vunpackuh.128B
-    1, // llvm.hexagon.V6.vxor
-    1, // llvm.hexagon.V6.vxor.128B
-    1, // llvm.hexagon.V6.vzb
-    1, // llvm.hexagon.V6.vzb.128B
-    1, // llvm.hexagon.V6.vzh
-    1, // llvm.hexagon.V6.vzh.128B
-    3, // llvm.hexagon.Y2.dccleana
-    3, // llvm.hexagon.Y2.dccleaninva
-    3, // llvm.hexagon.Y2.dcinva
-    126, // llvm.hexagon.Y2.dczeroa
-    3, // llvm.hexagon.Y4.l2fetch
-    3, // llvm.hexagon.Y5.l2fetch
-    127, // llvm.hexagon.circ.ldb
-    127, // llvm.hexagon.circ.ldd
-    127, // llvm.hexagon.circ.ldh
-    127, // llvm.hexagon.circ.ldub
-    127, // llvm.hexagon.circ.lduh
-    127, // llvm.hexagon.circ.ldw
-    128, // llvm.hexagon.circ.stb
-    128, // llvm.hexagon.circ.std
-    128, // llvm.hexagon.circ.sth
-    128, // llvm.hexagon.circ.sthhi
-    128, // llvm.hexagon.circ.stw
-    3, // llvm.hexagon.prefetch
-    129, // llvm.hexagon.vmemcpy
-    130, // llvm.hexagon.vmemset
-    3, // llvm.mips.absq.s.ph
-    3, // llvm.mips.absq.s.qb
-    3, // llvm.mips.absq.s.w
-    1, // llvm.mips.add.a.b
-    1, // llvm.mips.add.a.d
-    1, // llvm.mips.add.a.h
-    1, // llvm.mips.add.a.w
-    1, // llvm.mips.addq.ph
-    1, // llvm.mips.addq.s.ph
-    3, // llvm.mips.addq.s.w
-    1, // llvm.mips.addqh.ph
-    1, // llvm.mips.addqh.r.ph
-    1, // llvm.mips.addqh.r.w
-    1, // llvm.mips.addqh.w
-    1, // llvm.mips.adds.a.b
-    1, // llvm.mips.adds.a.d
-    1, // llvm.mips.adds.a.h
-    1, // llvm.mips.adds.a.w
-    1, // llvm.mips.adds.s.b
-    1, // llvm.mips.adds.s.d
-    1, // llvm.mips.adds.s.h
-    1, // llvm.mips.adds.s.w
-    1, // llvm.mips.adds.u.b
-    1, // llvm.mips.adds.u.d
-    1, // llvm.mips.adds.u.h
-    1, // llvm.mips.adds.u.w
-    3, // llvm.mips.addsc
-    3, // llvm.mips.addu.ph
-    1, // llvm.mips.addu.qb
-    3, // llvm.mips.addu.s.ph
-    1, // llvm.mips.addu.s.qb
-    1, // llvm.mips.adduh.qb
-    1, // llvm.mips.adduh.r.qb
-    1, // llvm.mips.addv.b
-    1, // llvm.mips.addv.d
-    1, // llvm.mips.addv.h
-    1, // llvm.mips.addv.w
-    40, // llvm.mips.addvi.b
-    40, // llvm.mips.addvi.d
-    40, // llvm.mips.addvi.h
-    40, // llvm.mips.addvi.w
-    3, // llvm.mips.addwc
-    1, // llvm.mips.and.v
-    40, // llvm.mips.andi.b
-    27, // llvm.mips.append
-    1, // llvm.mips.asub.s.b
-    1, // llvm.mips.asub.s.d
-    1, // llvm.mips.asub.s.h
-    1, // llvm.mips.asub.s.w
-    1, // llvm.mips.asub.u.b
-    1, // llvm.mips.asub.u.d
-    1, // llvm.mips.asub.u.h
-    1, // llvm.mips.asub.u.w
-    1, // llvm.mips.ave.s.b
-    1, // llvm.mips.ave.s.d
-    1, // llvm.mips.ave.s.h
-    1, // llvm.mips.ave.s.w
-    1, // llvm.mips.ave.u.b
-    1, // llvm.mips.ave.u.d
-    1, // llvm.mips.ave.u.h
-    1, // llvm.mips.ave.u.w
-    1, // llvm.mips.aver.s.b
-    1, // llvm.mips.aver.s.d
-    1, // llvm.mips.aver.s.h
-    1, // llvm.mips.aver.s.w
-    1, // llvm.mips.aver.u.b
-    1, // llvm.mips.aver.u.d
-    1, // llvm.mips.aver.u.h
-    1, // llvm.mips.aver.u.w
-    27, // llvm.mips.balign
-    1, // llvm.mips.bclr.b
-    1, // llvm.mips.bclr.d
-    1, // llvm.mips.bclr.h
-    1, // llvm.mips.bclr.w
-    40, // llvm.mips.bclri.b
-    40, // llvm.mips.bclri.d
-    40, // llvm.mips.bclri.h
-    40, // llvm.mips.bclri.w
-    1, // llvm.mips.binsl.b
-    1, // llvm.mips.binsl.d
-    1, // llvm.mips.binsl.h
-    1, // llvm.mips.binsl.w
-    27, // llvm.mips.binsli.b
-    27, // llvm.mips.binsli.d
-    27, // llvm.mips.binsli.h
-    27, // llvm.mips.binsli.w
-    1, // llvm.mips.binsr.b
-    1, // llvm.mips.binsr.d
-    1, // llvm.mips.binsr.h
-    1, // llvm.mips.binsr.w
-    27, // llvm.mips.binsri.b
-    27, // llvm.mips.binsri.d
-    27, // llvm.mips.binsri.h
-    27, // llvm.mips.binsri.w
-    1, // llvm.mips.bitrev
-    1, // llvm.mips.bmnz.v
-    27, // llvm.mips.bmnzi.b
-    1, // llvm.mips.bmz.v
-    27, // llvm.mips.bmzi.b
-    1, // llvm.mips.bneg.b
-    1, // llvm.mips.bneg.d
-    1, // llvm.mips.bneg.h
-    1, // llvm.mips.bneg.w
-    40, // llvm.mips.bnegi.b
-    40, // llvm.mips.bnegi.d
-    40, // llvm.mips.bnegi.h
-    40, // llvm.mips.bnegi.w
-    1, // llvm.mips.bnz.b
-    1, // llvm.mips.bnz.d
-    1, // llvm.mips.bnz.h
-    1, // llvm.mips.bnz.v
-    1, // llvm.mips.bnz.w
-    18, // llvm.mips.bposge32
-    1, // llvm.mips.bsel.v
-    27, // llvm.mips.bseli.b
-    1, // llvm.mips.bset.b
-    1, // llvm.mips.bset.d
-    1, // llvm.mips.bset.h
-    1, // llvm.mips.bset.w
-    40, // llvm.mips.bseti.b
-    40, // llvm.mips.bseti.d
-    40, // llvm.mips.bseti.h
-    40, // llvm.mips.bseti.w
-    1, // llvm.mips.bz.b
-    1, // llvm.mips.bz.d
-    1, // llvm.mips.bz.h
-    1, // llvm.mips.bz.v
-    1, // llvm.mips.bz.w
-    1, // llvm.mips.ceq.b
-    1, // llvm.mips.ceq.d
-    1, // llvm.mips.ceq.h
-    1, // llvm.mips.ceq.w
-    40, // llvm.mips.ceqi.b
-    40, // llvm.mips.ceqi.d
-    40, // llvm.mips.ceqi.h
-    40, // llvm.mips.ceqi.w
-    101, // llvm.mips.cfcmsa
-    1, // llvm.mips.cle.s.b
-    1, // llvm.mips.cle.s.d
-    1, // llvm.mips.cle.s.h
-    1, // llvm.mips.cle.s.w
-    1, // llvm.mips.cle.u.b
-    1, // llvm.mips.cle.u.d
-    1, // llvm.mips.cle.u.h
-    1, // llvm.mips.cle.u.w
-    40, // llvm.mips.clei.s.b
-    40, // llvm.mips.clei.s.d
-    40, // llvm.mips.clei.s.h
-    40, // llvm.mips.clei.s.w
-    40, // llvm.mips.clei.u.b
-    40, // llvm.mips.clei.u.d
-    40, // llvm.mips.clei.u.h
-    40, // llvm.mips.clei.u.w
-    1, // llvm.mips.clt.s.b
-    1, // llvm.mips.clt.s.d
-    1, // llvm.mips.clt.s.h
-    1, // llvm.mips.clt.s.w
-    1, // llvm.mips.clt.u.b
-    1, // llvm.mips.clt.u.d
-    1, // llvm.mips.clt.u.h
-    1, // llvm.mips.clt.u.w
-    40, // llvm.mips.clti.s.b
-    40, // llvm.mips.clti.s.d
-    40, // llvm.mips.clti.s.h
-    40, // llvm.mips.clti.s.w
-    40, // llvm.mips.clti.u.b
-    40, // llvm.mips.clti.u.d
-    40, // llvm.mips.clti.u.h
-    40, // llvm.mips.clti.u.w
-    3, // llvm.mips.cmp.eq.ph
-    3, // llvm.mips.cmp.le.ph
-    3, // llvm.mips.cmp.lt.ph
-    3, // llvm.mips.cmpgdu.eq.qb
-    3, // llvm.mips.cmpgdu.le.qb
-    3, // llvm.mips.cmpgdu.lt.qb
-    3, // llvm.mips.cmpgu.eq.qb
-    3, // llvm.mips.cmpgu.le.qb
-    3, // llvm.mips.cmpgu.lt.qb
-    3, // llvm.mips.cmpu.eq.qb
-    3, // llvm.mips.cmpu.le.qb
-    3, // llvm.mips.cmpu.lt.qb
-    40, // llvm.mips.copy.s.b
-    40, // llvm.mips.copy.s.d
-    40, // llvm.mips.copy.s.h
-    40, // llvm.mips.copy.s.w
-    40, // llvm.mips.copy.u.b
-    40, // llvm.mips.copy.u.d
-    40, // llvm.mips.copy.u.h
-    40, // llvm.mips.copy.u.w
-    101, // llvm.mips.ctcmsa
-    1, // llvm.mips.div.s.b
-    1, // llvm.mips.div.s.d
-    1, // llvm.mips.div.s.h
-    1, // llvm.mips.div.s.w
-    1, // llvm.mips.div.u.b
-    1, // llvm.mips.div.u.d
-    1, // llvm.mips.div.u.h
-    1, // llvm.mips.div.u.w
-    1, // llvm.mips.dlsa
-    1, // llvm.mips.dotp.s.d
-    1, // llvm.mips.dotp.s.h
-    1, // llvm.mips.dotp.s.w
-    1, // llvm.mips.dotp.u.d
-    1, // llvm.mips.dotp.u.h
-    1, // llvm.mips.dotp.u.w
-    1, // llvm.mips.dpa.w.ph
-    1, // llvm.mips.dpadd.s.d
-    1, // llvm.mips.dpadd.s.h
-    1, // llvm.mips.dpadd.s.w
-    1, // llvm.mips.dpadd.u.d
-    1, // llvm.mips.dpadd.u.h
-    1, // llvm.mips.dpadd.u.w
-    3, // llvm.mips.dpaq.s.w.ph
-    3, // llvm.mips.dpaq.sa.l.w
-    3, // llvm.mips.dpaqx.s.w.ph
-    3, // llvm.mips.dpaqx.sa.w.ph
-    1, // llvm.mips.dpau.h.qbl
-    1, // llvm.mips.dpau.h.qbr
-    1, // llvm.mips.dpax.w.ph
-    1, // llvm.mips.dps.w.ph
-    3, // llvm.mips.dpsq.s.w.ph
-    3, // llvm.mips.dpsq.sa.l.w
-    3, // llvm.mips.dpsqx.s.w.ph
-    3, // llvm.mips.dpsqx.sa.w.ph
-    1, // llvm.mips.dpsu.h.qbl
-    1, // llvm.mips.dpsu.h.qbr
-    1, // llvm.mips.dpsub.s.d
-    1, // llvm.mips.dpsub.s.h
-    1, // llvm.mips.dpsub.s.w
-    1, // llvm.mips.dpsub.u.d
-    1, // llvm.mips.dpsub.u.h
-    1, // llvm.mips.dpsub.u.w
-    1, // llvm.mips.dpsx.w.ph
-    3, // llvm.mips.extp
-    3, // llvm.mips.extpdp
-    3, // llvm.mips.extr.r.w
-    3, // llvm.mips.extr.rs.w
-    3, // llvm.mips.extr.s.h
-    3, // llvm.mips.extr.w
-    1, // llvm.mips.fadd.d
-    1, // llvm.mips.fadd.w
-    1, // llvm.mips.fcaf.d
-    1, // llvm.mips.fcaf.w
-    1, // llvm.mips.fceq.d
-    1, // llvm.mips.fceq.w
-    1, // llvm.mips.fclass.d
-    1, // llvm.mips.fclass.w
-    1, // llvm.mips.fcle.d
-    1, // llvm.mips.fcle.w
-    1, // llvm.mips.fclt.d
-    1, // llvm.mips.fclt.w
-    1, // llvm.mips.fcne.d
-    1, // llvm.mips.fcne.w
-    1, // llvm.mips.fcor.d
-    1, // llvm.mips.fcor.w
-    1, // llvm.mips.fcueq.d
-    1, // llvm.mips.fcueq.w
-    1, // llvm.mips.fcule.d
-    1, // llvm.mips.fcule.w
-    1, // llvm.mips.fcult.d
-    1, // llvm.mips.fcult.w
-    1, // llvm.mips.fcun.d
-    1, // llvm.mips.fcun.w
-    1, // llvm.mips.fcune.d
-    1, // llvm.mips.fcune.w
-    1, // llvm.mips.fdiv.d
-    1, // llvm.mips.fdiv.w
-    1, // llvm.mips.fexdo.h
-    1, // llvm.mips.fexdo.w
-    1, // llvm.mips.fexp2.d
-    1, // llvm.mips.fexp2.w
-    1, // llvm.mips.fexupl.d
-    1, // llvm.mips.fexupl.w
-    1, // llvm.mips.fexupr.d
-    1, // llvm.mips.fexupr.w
-    1, // llvm.mips.ffint.s.d
-    1, // llvm.mips.ffint.s.w
-    1, // llvm.mips.ffint.u.d
-    1, // llvm.mips.ffint.u.w
-    1, // llvm.mips.ffql.d
-    1, // llvm.mips.ffql.w
-    1, // llvm.mips.ffqr.d
-    1, // llvm.mips.ffqr.w
-    1, // llvm.mips.fill.b
-    1, // llvm.mips.fill.d
-    1, // llvm.mips.fill.h
-    1, // llvm.mips.fill.w
-    1, // llvm.mips.flog2.d
-    1, // llvm.mips.flog2.w
-    1, // llvm.mips.fmadd.d
-    1, // llvm.mips.fmadd.w
-    1, // llvm.mips.fmax.a.d
-    1, // llvm.mips.fmax.a.w
-    1, // llvm.mips.fmax.d
-    1, // llvm.mips.fmax.w
-    1, // llvm.mips.fmin.a.d
-    1, // llvm.mips.fmin.a.w
-    1, // llvm.mips.fmin.d
-    1, // llvm.mips.fmin.w
-    1, // llvm.mips.fmsub.d
-    1, // llvm.mips.fmsub.w
-    1, // llvm.mips.fmul.d
-    1, // llvm.mips.fmul.w
-    1, // llvm.mips.frcp.d
-    1, // llvm.mips.frcp.w
-    1, // llvm.mips.frint.d
-    1, // llvm.mips.frint.w
-    1, // llvm.mips.frsqrt.d
-    1, // llvm.mips.frsqrt.w
-    1, // llvm.mips.fsaf.d
-    1, // llvm.mips.fsaf.w
-    1, // llvm.mips.fseq.d
-    1, // llvm.mips.fseq.w
-    1, // llvm.mips.fsle.d
-    1, // llvm.mips.fsle.w
-    1, // llvm.mips.fslt.d
-    1, // llvm.mips.fslt.w
-    1, // llvm.mips.fsne.d
-    1, // llvm.mips.fsne.w
-    1, // llvm.mips.fsor.d
-    1, // llvm.mips.fsor.w
-    1, // llvm.mips.fsqrt.d
-    1, // llvm.mips.fsqrt.w
-    1, // llvm.mips.fsub.d
-    1, // llvm.mips.fsub.w
-    1, // llvm.mips.fsueq.d
-    1, // llvm.mips.fsueq.w
-    1, // llvm.mips.fsule.d
-    1, // llvm.mips.fsule.w
-    1, // llvm.mips.fsult.d
-    1, // llvm.mips.fsult.w
-    1, // llvm.mips.fsun.d
-    1, // llvm.mips.fsun.w
-    1, // llvm.mips.fsune.d
-    1, // llvm.mips.fsune.w
-    1, // llvm.mips.ftint.s.d
-    1, // llvm.mips.ftint.s.w
-    1, // llvm.mips.ftint.u.d
-    1, // llvm.mips.ftint.u.w
-    1, // llvm.mips.ftq.h
-    1, // llvm.mips.ftq.w
-    1, // llvm.mips.ftrunc.s.d
-    1, // llvm.mips.ftrunc.s.w
-    1, // llvm.mips.ftrunc.u.d
-    1, // llvm.mips.ftrunc.u.w
-    1, // llvm.mips.hadd.s.d
-    1, // llvm.mips.hadd.s.h
-    1, // llvm.mips.hadd.s.w
-    1, // llvm.mips.hadd.u.d
-    1, // llvm.mips.hadd.u.h
-    1, // llvm.mips.hadd.u.w
-    1, // llvm.mips.hsub.s.d
-    1, // llvm.mips.hsub.s.h
-    1, // llvm.mips.hsub.s.w
-    1, // llvm.mips.hsub.u.d
-    1, // llvm.mips.hsub.u.h
-    1, // llvm.mips.hsub.u.w
-    1, // llvm.mips.ilvev.b
-    1, // llvm.mips.ilvev.d
-    1, // llvm.mips.ilvev.h
-    1, // llvm.mips.ilvev.w
-    1, // llvm.mips.ilvl.b
-    1, // llvm.mips.ilvl.d
-    1, // llvm.mips.ilvl.h
-    1, // llvm.mips.ilvl.w
-    1, // llvm.mips.ilvod.b
-    1, // llvm.mips.ilvod.d
-    1, // llvm.mips.ilvod.h
-    1, // llvm.mips.ilvod.w
-    1, // llvm.mips.ilvr.b
-    1, // llvm.mips.ilvr.d
-    1, // llvm.mips.ilvr.h
-    1, // llvm.mips.ilvr.w
-    40, // llvm.mips.insert.b
-    40, // llvm.mips.insert.d
-    40, // llvm.mips.insert.h
-    40, // llvm.mips.insert.w
-    18, // llvm.mips.insv
-    40, // llvm.mips.insve.b
-    40, // llvm.mips.insve.d
-    40, // llvm.mips.insve.h
-    40, // llvm.mips.insve.w
-    2, // llvm.mips.lbux
-    31, // llvm.mips.ld.b
-    31, // llvm.mips.ld.d
-    31, // llvm.mips.ld.h
-    31, // llvm.mips.ld.w
-    20, // llvm.mips.ldi.b
-    20, // llvm.mips.ldi.d
-    20, // llvm.mips.ldi.h
-    20, // llvm.mips.ldi.w
-    2, // llvm.mips.lhx
-    1, // llvm.mips.lsa
-    2, // llvm.mips.lwx
-    1, // llvm.mips.madd
-    1, // llvm.mips.madd.q.h
-    1, // llvm.mips.madd.q.w
-    1, // llvm.mips.maddr.q.h
-    1, // llvm.mips.maddr.q.w
-    1, // llvm.mips.maddu
-    1, // llvm.mips.maddv.b
-    1, // llvm.mips.maddv.d
-    1, // llvm.mips.maddv.h
-    1, // llvm.mips.maddv.w
-    3, // llvm.mips.maq.s.w.phl
-    3, // llvm.mips.maq.s.w.phr
-    3, // llvm.mips.maq.sa.w.phl
-    3, // llvm.mips.maq.sa.w.phr
-    1, // llvm.mips.max.a.b
-    1, // llvm.mips.max.a.d
-    1, // llvm.mips.max.a.h
-    1, // llvm.mips.max.a.w
-    1, // llvm.mips.max.s.b
-    1, // llvm.mips.max.s.d
-    1, // llvm.mips.max.s.h
-    1, // llvm.mips.max.s.w
-    1, // llvm.mips.max.u.b
-    1, // llvm.mips.max.u.d
-    1, // llvm.mips.max.u.h
-    1, // llvm.mips.max.u.w
-    40, // llvm.mips.maxi.s.b
-    40, // llvm.mips.maxi.s.d
-    40, // llvm.mips.maxi.s.h
-    40, // llvm.mips.maxi.s.w
-    40, // llvm.mips.maxi.u.b
-    40, // llvm.mips.maxi.u.d
-    40, // llvm.mips.maxi.u.h
-    40, // llvm.mips.maxi.u.w
-    1, // llvm.mips.min.a.b
-    1, // llvm.mips.min.a.d
-    1, // llvm.mips.min.a.h
-    1, // llvm.mips.min.a.w
-    1, // llvm.mips.min.s.b
-    1, // llvm.mips.min.s.d
-    1, // llvm.mips.min.s.h
-    1, // llvm.mips.min.s.w
-    1, // llvm.mips.min.u.b
-    1, // llvm.mips.min.u.d
-    1, // llvm.mips.min.u.h
-    1, // llvm.mips.min.u.w
-    40, // llvm.mips.mini.s.b
-    40, // llvm.mips.mini.s.d
-    40, // llvm.mips.mini.s.h
-    40, // llvm.mips.mini.s.w
-    40, // llvm.mips.mini.u.b
-    40, // llvm.mips.mini.u.d
-    40, // llvm.mips.mini.u.h
-    40, // llvm.mips.mini.u.w
-    1, // llvm.mips.mod.s.b
-    1, // llvm.mips.mod.s.d
-    1, // llvm.mips.mod.s.h
-    1, // llvm.mips.mod.s.w
-    1, // llvm.mips.mod.u.b
-    1, // llvm.mips.mod.u.d
-    1, // llvm.mips.mod.u.h
-    1, // llvm.mips.mod.u.w
-    1, // llvm.mips.modsub
-    1, // llvm.mips.move.v
-    1, // llvm.mips.msub
-    1, // llvm.mips.msub.q.h
-    1, // llvm.mips.msub.q.w
-    1, // llvm.mips.msubr.q.h
-    1, // llvm.mips.msubr.q.w
-    1, // llvm.mips.msubu
-    1, // llvm.mips.msubv.b
-    1, // llvm.mips.msubv.d
-    1, // llvm.mips.msubv.h
-    1, // llvm.mips.msubv.w
-    3, // llvm.mips.mthlip
-    3, // llvm.mips.mul.ph
-    1, // llvm.mips.mul.q.h
-    1, // llvm.mips.mul.q.w
-    3, // llvm.mips.mul.s.ph
-    3, // llvm.mips.muleq.s.w.phl
-    3, // llvm.mips.muleq.s.w.phr
-    3, // llvm.mips.muleu.s.ph.qbl
-    3, // llvm.mips.muleu.s.ph.qbr
-    3, // llvm.mips.mulq.rs.ph
-    3, // llvm.mips.mulq.rs.w
-    3, // llvm.mips.mulq.s.ph
-    3, // llvm.mips.mulq.s.w
-    1, // llvm.mips.mulr.q.h
-    1, // llvm.mips.mulr.q.w
-    1, // llvm.mips.mulsa.w.ph
-    3, // llvm.mips.mulsaq.s.w.ph
-    1, // llvm.mips.mult
-    1, // llvm.mips.multu
-    1, // llvm.mips.mulv.b
-    1, // llvm.mips.mulv.d
-    1, // llvm.mips.mulv.h
-    1, // llvm.mips.mulv.w
-    1, // llvm.mips.nloc.b
-    1, // llvm.mips.nloc.d
-    1, // llvm.mips.nloc.h
-    1, // llvm.mips.nloc.w
-    1, // llvm.mips.nlzc.b
-    1, // llvm.mips.nlzc.d
-    1, // llvm.mips.nlzc.h
-    1, // llvm.mips.nlzc.w
-    1, // llvm.mips.nor.v
-    40, // llvm.mips.nori.b
-    1, // llvm.mips.or.v
-    40, // llvm.mips.ori.b
-    1, // llvm.mips.packrl.ph
-    1, // llvm.mips.pckev.b
-    1, // llvm.mips.pckev.d
-    1, // llvm.mips.pckev.h
-    1, // llvm.mips.pckev.w
-    1, // llvm.mips.pckod.b
-    1, // llvm.mips.pckod.d
-    1, // llvm.mips.pckod.h
-    1, // llvm.mips.pckod.w
-    1, // llvm.mips.pcnt.b
-    1, // llvm.mips.pcnt.d
-    1, // llvm.mips.pcnt.h
-    1, // llvm.mips.pcnt.w
-    18, // llvm.mips.pick.ph
-    18, // llvm.mips.pick.qb
-    1, // llvm.mips.preceq.w.phl
-    1, // llvm.mips.preceq.w.phr
-    1, // llvm.mips.precequ.ph.qbl
-    1, // llvm.mips.precequ.ph.qbla
-    1, // llvm.mips.precequ.ph.qbr
-    1, // llvm.mips.precequ.ph.qbra
-    1, // llvm.mips.preceu.ph.qbl
-    1, // llvm.mips.preceu.ph.qbla
-    1, // llvm.mips.preceu.ph.qbr
-    1, // llvm.mips.preceu.ph.qbra
-    3, // llvm.mips.precr.qb.ph
-    27, // llvm.mips.precr.sra.ph.w
-    27, // llvm.mips.precr.sra.r.ph.w
-    1, // llvm.mips.precrq.ph.w
-    1, // llvm.mips.precrq.qb.ph
-    3, // llvm.mips.precrq.rs.ph.w
-    3, // llvm.mips.precrqu.s.qb.ph
-    27, // llvm.mips.prepend
-    1, // llvm.mips.raddu.w.qb
-    131, // llvm.mips.rddsp
-    1, // llvm.mips.repl.ph
-    1, // llvm.mips.repl.qb
-    40, // llvm.mips.sat.s.b
-    40, // llvm.mips.sat.s.d
-    40, // llvm.mips.sat.s.h
-    40, // llvm.mips.sat.s.w
-    40, // llvm.mips.sat.u.b
-    40, // llvm.mips.sat.u.d
-    40, // llvm.mips.sat.u.h
-    40, // llvm.mips.sat.u.w
-    40, // llvm.mips.shf.b
-    40, // llvm.mips.shf.h
-    40, // llvm.mips.shf.w
-    1, // llvm.mips.shilo
-    3, // llvm.mips.shll.ph
-    3, // llvm.mips.shll.qb
-    3, // llvm.mips.shll.s.ph
-    3, // llvm.mips.shll.s.w
-    1, // llvm.mips.shra.ph
-    1, // llvm.mips.shra.qb
-    1, // llvm.mips.shra.r.ph
-    1, // llvm.mips.shra.r.qb
-    1, // llvm.mips.shra.r.w
-    1, // llvm.mips.shrl.ph
-    1, // llvm.mips.shrl.qb
-    1, // llvm.mips.sld.b
-    1, // llvm.mips.sld.d
-    1, // llvm.mips.sld.h
-    1, // llvm.mips.sld.w
-    27, // llvm.mips.sldi.b
-    27, // llvm.mips.sldi.d
-    27, // llvm.mips.sldi.h
-    27, // llvm.mips.sldi.w
-    1, // llvm.mips.sll.b
-    1, // llvm.mips.sll.d
-    1, // llvm.mips.sll.h
-    1, // llvm.mips.sll.w
-    40, // llvm.mips.slli.b
-    40, // llvm.mips.slli.d
-    40, // llvm.mips.slli.h
-    40, // llvm.mips.slli.w
-    1, // llvm.mips.splat.b
-    1, // llvm.mips.splat.d
-    1, // llvm.mips.splat.h
-    1, // llvm.mips.splat.w
-    40, // llvm.mips.splati.b
-    40, // llvm.mips.splati.d
-    40, // llvm.mips.splati.h
-    40, // llvm.mips.splati.w
-    1, // llvm.mips.sra.b
-    1, // llvm.mips.sra.d
-    1, // llvm.mips.sra.h
-    1, // llvm.mips.sra.w
-    40, // llvm.mips.srai.b
-    40, // llvm.mips.srai.d
-    40, // llvm.mips.srai.h
-    40, // llvm.mips.srai.w
-    1, // llvm.mips.srar.b
-    1, // llvm.mips.srar.d
-    1, // llvm.mips.srar.h
-    1, // llvm.mips.srar.w
-    40, // llvm.mips.srari.b
-    40, // llvm.mips.srari.d
-    40, // llvm.mips.srari.h
-    40, // llvm.mips.srari.w
-    1, // llvm.mips.srl.b
-    1, // llvm.mips.srl.d
-    1, // llvm.mips.srl.h
-    1, // llvm.mips.srl.w
-    40, // llvm.mips.srli.b
-    40, // llvm.mips.srli.d
-    40, // llvm.mips.srli.h
-    40, // llvm.mips.srli.w
-    1, // llvm.mips.srlr.b
-    1, // llvm.mips.srlr.d
-    1, // llvm.mips.srlr.h
-    1, // llvm.mips.srlr.w
-    40, // llvm.mips.srlri.b
-    40, // llvm.mips.srlri.d
-    40, // llvm.mips.srlri.h
-    40, // llvm.mips.srlri.w
-    33, // llvm.mips.st.b
-    33, // llvm.mips.st.d
-    33, // llvm.mips.st.h
-    33, // llvm.mips.st.w
-    1, // llvm.mips.subq.ph
-    1, // llvm.mips.subq.s.ph
-    3, // llvm.mips.subq.s.w
-    1, // llvm.mips.subqh.ph
-    1, // llvm.mips.subqh.r.ph
-    1, // llvm.mips.subqh.r.w
-    1, // llvm.mips.subqh.w
-    1, // llvm.mips.subs.s.b
-    1, // llvm.mips.subs.s.d
-    1, // llvm.mips.subs.s.h
-    1, // llvm.mips.subs.s.w
-    1, // llvm.mips.subs.u.b
-    1, // llvm.mips.subs.u.d
-    1, // llvm.mips.subs.u.h
-    1, // llvm.mips.subs.u.w
-    1, // llvm.mips.subsus.u.b
-    1, // llvm.mips.subsus.u.d
-    1, // llvm.mips.subsus.u.h
-    1, // llvm.mips.subsus.u.w
-    1, // llvm.mips.subsuu.s.b
-    1, // llvm.mips.subsuu.s.d
-    1, // llvm.mips.subsuu.s.h
-    1, // llvm.mips.subsuu.s.w
-    3, // llvm.mips.subu.ph
-    1, // llvm.mips.subu.qb
-    3, // llvm.mips.subu.s.ph
-    1, // llvm.mips.subu.s.qb
-    1, // llvm.mips.subuh.qb
-    1, // llvm.mips.subuh.r.qb
-    1, // llvm.mips.subv.b
-    1, // llvm.mips.subv.d
-    1, // llvm.mips.subv.h
-    1, // llvm.mips.subv.w
-    40, // llvm.mips.subvi.b
-    40, // llvm.mips.subvi.d
-    40, // llvm.mips.subvi.h
-    40, // llvm.mips.subvi.w
-    1, // llvm.mips.vshf.b
-    1, // llvm.mips.vshf.d
-    1, // llvm.mips.vshf.h
-    1, // llvm.mips.vshf.w
-    132, // llvm.mips.wrdsp
-    1, // llvm.mips.xor.v
-    40, // llvm.mips.xori.b
-    1, // llvm.nvvm.add.rm.d
-    1, // llvm.nvvm.add.rm.f
-    1, // llvm.nvvm.add.rm.ftz.f
-    1, // llvm.nvvm.add.rn.d
-    1, // llvm.nvvm.add.rn.f
-    1, // llvm.nvvm.add.rn.ftz.f
-    1, // llvm.nvvm.add.rp.d
-    1, // llvm.nvvm.add.rp.f
-    1, // llvm.nvvm.add.rp.ftz.f
-    1, // llvm.nvvm.add.rz.d
-    1, // llvm.nvvm.add.rz.f
-    1, // llvm.nvvm.add.rz.ftz.f
-    23, // llvm.nvvm.atomic.add.gen.f.cta
-    23, // llvm.nvvm.atomic.add.gen.f.sys
-    23, // llvm.nvvm.atomic.add.gen.i.cta
-    23, // llvm.nvvm.atomic.add.gen.i.sys
-    23, // llvm.nvvm.atomic.and.gen.i.cta
-    23, // llvm.nvvm.atomic.and.gen.i.sys
-    23, // llvm.nvvm.atomic.cas.gen.i.cta
-    23, // llvm.nvvm.atomic.cas.gen.i.sys
-    23, // llvm.nvvm.atomic.dec.gen.i.cta
-    23, // llvm.nvvm.atomic.dec.gen.i.sys
-    23, // llvm.nvvm.atomic.exch.gen.i.cta
-    23, // llvm.nvvm.atomic.exch.gen.i.sys
-    23, // llvm.nvvm.atomic.inc.gen.i.cta
-    23, // llvm.nvvm.atomic.inc.gen.i.sys
-    23, // llvm.nvvm.atomic.load.add.f32
-    23, // llvm.nvvm.atomic.load.add.f64
-    23, // llvm.nvvm.atomic.load.dec.32
-    23, // llvm.nvvm.atomic.load.inc.32
-    23, // llvm.nvvm.atomic.max.gen.i.cta
-    23, // llvm.nvvm.atomic.max.gen.i.sys
-    23, // llvm.nvvm.atomic.min.gen.i.cta
-    23, // llvm.nvvm.atomic.min.gen.i.sys
-    23, // llvm.nvvm.atomic.or.gen.i.cta
-    23, // llvm.nvvm.atomic.or.gen.i.sys
-    23, // llvm.nvvm.atomic.xor.gen.i.cta
-    23, // llvm.nvvm.atomic.xor.gen.i.sys
-    62, // llvm.nvvm.bar.sync
-    62, // llvm.nvvm.bar.warp.sync
-    62, // llvm.nvvm.barrier
-    62, // llvm.nvvm.barrier.n
-    62, // llvm.nvvm.barrier.sync
-    62, // llvm.nvvm.barrier.sync.cnt
-    62, // llvm.nvvm.barrier0
-    62, // llvm.nvvm.barrier0.and
-    62, // llvm.nvvm.barrier0.or
-    62, // llvm.nvvm.barrier0.popc
-    1, // llvm.nvvm.bitcast.d2ll
-    1, // llvm.nvvm.bitcast.f2i
-    1, // llvm.nvvm.bitcast.i2f
-    1, // llvm.nvvm.bitcast.ll2d
-    1, // llvm.nvvm.ceil.d
-    1, // llvm.nvvm.ceil.f
-    1, // llvm.nvvm.ceil.ftz.f
-    3, // llvm.nvvm.compiler.error
-    3, // llvm.nvvm.compiler.warn
-    1, // llvm.nvvm.cos.approx.f
-    1, // llvm.nvvm.cos.approx.ftz.f
-    1, // llvm.nvvm.d2f.rm
-    1, // llvm.nvvm.d2f.rm.ftz
-    1, // llvm.nvvm.d2f.rn
-    1, // llvm.nvvm.d2f.rn.ftz
-    1, // llvm.nvvm.d2f.rp
-    1, // llvm.nvvm.d2f.rp.ftz
-    1, // llvm.nvvm.d2f.rz
-    1, // llvm.nvvm.d2f.rz.ftz
-    1, // llvm.nvvm.d2i.hi
-    1, // llvm.nvvm.d2i.lo
-    1, // llvm.nvvm.d2i.rm
-    1, // llvm.nvvm.d2i.rn
-    1, // llvm.nvvm.d2i.rp
-    1, // llvm.nvvm.d2i.rz
-    1, // llvm.nvvm.d2ll.rm
-    1, // llvm.nvvm.d2ll.rn
-    1, // llvm.nvvm.d2ll.rp
-    1, // llvm.nvvm.d2ll.rz
-    1, // llvm.nvvm.d2ui.rm
-    1, // llvm.nvvm.d2ui.rn
-    1, // llvm.nvvm.d2ui.rp
-    1, // llvm.nvvm.d2ui.rz
-    1, // llvm.nvvm.d2ull.rm
-    1, // llvm.nvvm.d2ull.rn
-    1, // llvm.nvvm.d2ull.rp
-    1, // llvm.nvvm.d2ull.rz
-    1, // llvm.nvvm.div.approx.f
-    1, // llvm.nvvm.div.approx.ftz.f
-    1, // llvm.nvvm.div.rm.d
-    1, // llvm.nvvm.div.rm.f
-    1, // llvm.nvvm.div.rm.ftz.f
-    1, // llvm.nvvm.div.rn.d
-    1, // llvm.nvvm.div.rn.f
-    1, // llvm.nvvm.div.rn.ftz.f
-    1, // llvm.nvvm.div.rp.d
-    1, // llvm.nvvm.div.rp.f
-    1, // llvm.nvvm.div.rp.ftz.f
-    1, // llvm.nvvm.div.rz.d
-    1, // llvm.nvvm.div.rz.f
-    1, // llvm.nvvm.div.rz.ftz.f
-    1, // llvm.nvvm.ex2.approx.d
-    1, // llvm.nvvm.ex2.approx.f
-    1, // llvm.nvvm.ex2.approx.ftz.f
-    1, // llvm.nvvm.f2h.rn
-    1, // llvm.nvvm.f2h.rn.ftz
-    1, // llvm.nvvm.f2i.rm
-    1, // llvm.nvvm.f2i.rm.ftz
-    1, // llvm.nvvm.f2i.rn
-    1, // llvm.nvvm.f2i.rn.ftz
-    1, // llvm.nvvm.f2i.rp
-    1, // llvm.nvvm.f2i.rp.ftz
-    1, // llvm.nvvm.f2i.rz
-    1, // llvm.nvvm.f2i.rz.ftz
-    1, // llvm.nvvm.f2ll.rm
-    1, // llvm.nvvm.f2ll.rm.ftz
-    1, // llvm.nvvm.f2ll.rn
-    1, // llvm.nvvm.f2ll.rn.ftz
-    1, // llvm.nvvm.f2ll.rp
-    1, // llvm.nvvm.f2ll.rp.ftz
-    1, // llvm.nvvm.f2ll.rz
-    1, // llvm.nvvm.f2ll.rz.ftz
-    1, // llvm.nvvm.f2ui.rm
-    1, // llvm.nvvm.f2ui.rm.ftz
-    1, // llvm.nvvm.f2ui.rn
-    1, // llvm.nvvm.f2ui.rn.ftz
-    1, // llvm.nvvm.f2ui.rp
-    1, // llvm.nvvm.f2ui.rp.ftz
-    1, // llvm.nvvm.f2ui.rz
-    1, // llvm.nvvm.f2ui.rz.ftz
-    1, // llvm.nvvm.f2ull.rm
-    1, // llvm.nvvm.f2ull.rm.ftz
-    1, // llvm.nvvm.f2ull.rn
-    1, // llvm.nvvm.f2ull.rn.ftz
-    1, // llvm.nvvm.f2ull.rp
-    1, // llvm.nvvm.f2ull.rp.ftz
-    1, // llvm.nvvm.f2ull.rz
-    1, // llvm.nvvm.f2ull.rz.ftz
-    1, // llvm.nvvm.fabs.d
-    1, // llvm.nvvm.fabs.f
-    1, // llvm.nvvm.fabs.ftz.f
-    1, // llvm.nvvm.floor.d
-    1, // llvm.nvvm.floor.f
-    1, // llvm.nvvm.floor.ftz.f
-    1, // llvm.nvvm.fma.rm.d
-    1, // llvm.nvvm.fma.rm.f
-    1, // llvm.nvvm.fma.rm.ftz.f
-    1, // llvm.nvvm.fma.rn.d
-    1, // llvm.nvvm.fma.rn.f
-    1, // llvm.nvvm.fma.rn.ftz.f
-    1, // llvm.nvvm.fma.rp.d
-    1, // llvm.nvvm.fma.rp.f
-    1, // llvm.nvvm.fma.rp.ftz.f
-    1, // llvm.nvvm.fma.rz.d
-    1, // llvm.nvvm.fma.rz.f
-    1, // llvm.nvvm.fma.rz.ftz.f
-    1, // llvm.nvvm.fmax.d
-    1, // llvm.nvvm.fmax.f
-    1, // llvm.nvvm.fmax.ftz.f
-    1, // llvm.nvvm.fmin.d
-    1, // llvm.nvvm.fmin.f
-    1, // llvm.nvvm.fmin.ftz.f
-    1, // llvm.nvvm.fns
-    1, // llvm.nvvm.i2d.rm
-    1, // llvm.nvvm.i2d.rn
-    1, // llvm.nvvm.i2d.rp
-    1, // llvm.nvvm.i2d.rz
-    1, // llvm.nvvm.i2f.rm
-    1, // llvm.nvvm.i2f.rn
-    1, // llvm.nvvm.i2f.rp
-    1, // llvm.nvvm.i2f.rz
-    1, // llvm.nvvm.isspacep.const
-    1, // llvm.nvvm.isspacep.global
-    1, // llvm.nvvm.isspacep.local
-    1, // llvm.nvvm.isspacep.shared
-    1, // llvm.nvvm.istypep.sampler
-    1, // llvm.nvvm.istypep.surface
-    1, // llvm.nvvm.istypep.texture
-    133, // llvm.nvvm.ldg.global.f
-    133, // llvm.nvvm.ldg.global.i
-    133, // llvm.nvvm.ldg.global.p
-    133, // llvm.nvvm.ldu.global.f
-    133, // llvm.nvvm.ldu.global.i
-    133, // llvm.nvvm.ldu.global.p
-    1, // llvm.nvvm.lg2.approx.d
-    1, // llvm.nvvm.lg2.approx.f
-    1, // llvm.nvvm.lg2.approx.ftz.f
-    1, // llvm.nvvm.ll2d.rm
-    1, // llvm.nvvm.ll2d.rn
-    1, // llvm.nvvm.ll2d.rp
-    1, // llvm.nvvm.ll2d.rz
-    1, // llvm.nvvm.ll2f.rm
-    1, // llvm.nvvm.ll2f.rn
-    1, // llvm.nvvm.ll2f.rp
-    1, // llvm.nvvm.ll2f.rz
-    1, // llvm.nvvm.lohi.i2d
-    58, // llvm.nvvm.match.all.sync.i32p
-    58, // llvm.nvvm.match.all.sync.i64p
-    58, // llvm.nvvm.match.any.sync.i32
-    58, // llvm.nvvm.match.any.sync.i64
-    3, // llvm.nvvm.membar.cta
-    3, // llvm.nvvm.membar.gl
-    3, // llvm.nvvm.membar.sys
-    1, // llvm.nvvm.move.double
-    1, // llvm.nvvm.move.float
-    1, // llvm.nvvm.move.i16
-    1, // llvm.nvvm.move.i32
-    1, // llvm.nvvm.move.i64
-    12, // llvm.nvvm.move.ptr
-    1, // llvm.nvvm.mul.rm.d
-    1, // llvm.nvvm.mul.rm.f
-    1, // llvm.nvvm.mul.rm.ftz.f
-    1, // llvm.nvvm.mul.rn.d
-    1, // llvm.nvvm.mul.rn.f
-    1, // llvm.nvvm.mul.rn.ftz.f
-    1, // llvm.nvvm.mul.rp.d
-    1, // llvm.nvvm.mul.rp.f
-    1, // llvm.nvvm.mul.rp.ftz.f
-    1, // llvm.nvvm.mul.rz.d
-    1, // llvm.nvvm.mul.rz.f
-    1, // llvm.nvvm.mul.rz.ftz.f
-    1, // llvm.nvvm.mul24.i
-    1, // llvm.nvvm.mul24.ui
-    1, // llvm.nvvm.mulhi.i
-    1, // llvm.nvvm.mulhi.ll
-    1, // llvm.nvvm.mulhi.ui
-    1, // llvm.nvvm.mulhi.ull
-    1, // llvm.nvvm.prmt
-    1, // llvm.nvvm.ptr.constant.to.gen
-    1, // llvm.nvvm.ptr.gen.to.constant
-    1, // llvm.nvvm.ptr.gen.to.global
-    1, // llvm.nvvm.ptr.gen.to.local
-    1, // llvm.nvvm.ptr.gen.to.param
-    1, // llvm.nvvm.ptr.gen.to.shared
-    1, // llvm.nvvm.ptr.global.to.gen
-    1, // llvm.nvvm.ptr.local.to.gen
-    1, // llvm.nvvm.ptr.shared.to.gen
-    1, // llvm.nvvm.rcp.approx.ftz.d
-    1, // llvm.nvvm.rcp.rm.d
-    1, // llvm.nvvm.rcp.rm.f
-    1, // llvm.nvvm.rcp.rm.ftz.f
-    1, // llvm.nvvm.rcp.rn.d
-    1, // llvm.nvvm.rcp.rn.f
-    1, // llvm.nvvm.rcp.rn.ftz.f
-    1, // llvm.nvvm.rcp.rp.d
-    1, // llvm.nvvm.rcp.rp.f
-    1, // llvm.nvvm.rcp.rp.ftz.f
-    1, // llvm.nvvm.rcp.rz.d
-    1, // llvm.nvvm.rcp.rz.f
-    1, // llvm.nvvm.rcp.rz.ftz.f
-    16, // llvm.nvvm.read.ptx.sreg.clock
-    16, // llvm.nvvm.read.ptx.sreg.clock64
-    1, // llvm.nvvm.read.ptx.sreg.ctaid.w
-    1, // llvm.nvvm.read.ptx.sreg.ctaid.x
-    1, // llvm.nvvm.read.ptx.sreg.ctaid.y
-    1, // llvm.nvvm.read.ptx.sreg.ctaid.z
-    1, // llvm.nvvm.read.ptx.sreg.envreg0
-    1, // llvm.nvvm.read.ptx.sreg.envreg1
-    1, // llvm.nvvm.read.ptx.sreg.envreg10
-    1, // llvm.nvvm.read.ptx.sreg.envreg11
-    1, // llvm.nvvm.read.ptx.sreg.envreg12
-    1, // llvm.nvvm.read.ptx.sreg.envreg13
-    1, // llvm.nvvm.read.ptx.sreg.envreg14
-    1, // llvm.nvvm.read.ptx.sreg.envreg15
-    1, // llvm.nvvm.read.ptx.sreg.envreg16
-    1, // llvm.nvvm.read.ptx.sreg.envreg17
-    1, // llvm.nvvm.read.ptx.sreg.envreg18
-    1, // llvm.nvvm.read.ptx.sreg.envreg19
-    1, // llvm.nvvm.read.ptx.sreg.envreg2
-    1, // llvm.nvvm.read.ptx.sreg.envreg20
-    1, // llvm.nvvm.read.ptx.sreg.envreg21
-    1, // llvm.nvvm.read.ptx.sreg.envreg22
-    1, // llvm.nvvm.read.ptx.sreg.envreg23
-    1, // llvm.nvvm.read.ptx.sreg.envreg24
-    1, // llvm.nvvm.read.ptx.sreg.envreg25
-    1, // llvm.nvvm.read.ptx.sreg.envreg26
-    1, // llvm.nvvm.read.ptx.sreg.envreg27
-    1, // llvm.nvvm.read.ptx.sreg.envreg28
-    1, // llvm.nvvm.read.ptx.sreg.envreg29
-    1, // llvm.nvvm.read.ptx.sreg.envreg3
-    1, // llvm.nvvm.read.ptx.sreg.envreg30
-    1, // llvm.nvvm.read.ptx.sreg.envreg31
-    1, // llvm.nvvm.read.ptx.sreg.envreg4
-    1, // llvm.nvvm.read.ptx.sreg.envreg5
-    1, // llvm.nvvm.read.ptx.sreg.envreg6
-    1, // llvm.nvvm.read.ptx.sreg.envreg7
-    1, // llvm.nvvm.read.ptx.sreg.envreg8
-    1, // llvm.nvvm.read.ptx.sreg.envreg9
-    1, // llvm.nvvm.read.ptx.sreg.gridid
-    1, // llvm.nvvm.read.ptx.sreg.laneid
-    1, // llvm.nvvm.read.ptx.sreg.lanemask.eq
-    1, // llvm.nvvm.read.ptx.sreg.lanemask.ge
-    1, // llvm.nvvm.read.ptx.sreg.lanemask.gt
-    1, // llvm.nvvm.read.ptx.sreg.lanemask.le
-    1, // llvm.nvvm.read.ptx.sreg.lanemask.lt
-    1, // llvm.nvvm.read.ptx.sreg.nctaid.w
-    1, // llvm.nvvm.read.ptx.sreg.nctaid.x
-    1, // llvm.nvvm.read.ptx.sreg.nctaid.y
-    1, // llvm.nvvm.read.ptx.sreg.nctaid.z
-    1, // llvm.nvvm.read.ptx.sreg.nsmid
-    1, // llvm.nvvm.read.ptx.sreg.ntid.w
-    1, // llvm.nvvm.read.ptx.sreg.ntid.x
-    1, // llvm.nvvm.read.ptx.sreg.ntid.y
-    1, // llvm.nvvm.read.ptx.sreg.ntid.z
-    1, // llvm.nvvm.read.ptx.sreg.nwarpid
-    16, // llvm.nvvm.read.ptx.sreg.pm0
-    16, // llvm.nvvm.read.ptx.sreg.pm1
-    16, // llvm.nvvm.read.ptx.sreg.pm2
-    16, // llvm.nvvm.read.ptx.sreg.pm3
-    1, // llvm.nvvm.read.ptx.sreg.smid
-    1, // llvm.nvvm.read.ptx.sreg.tid.w
-    1, // llvm.nvvm.read.ptx.sreg.tid.x
-    1, // llvm.nvvm.read.ptx.sreg.tid.y
-    1, // llvm.nvvm.read.ptx.sreg.tid.z
-    1, // llvm.nvvm.read.ptx.sreg.warpid
-    1, // llvm.nvvm.read.ptx.sreg.warpsize
-    1, // llvm.nvvm.reflect
-    1, // llvm.nvvm.rotate.b32
-    1, // llvm.nvvm.rotate.b64
-    1, // llvm.nvvm.rotate.right.b64
-    1, // llvm.nvvm.round.d
-    1, // llvm.nvvm.round.f
-    1, // llvm.nvvm.round.ftz.f
-    1, // llvm.nvvm.rsqrt.approx.d
-    1, // llvm.nvvm.rsqrt.approx.f
-    1, // llvm.nvvm.rsqrt.approx.ftz.f
-    1, // llvm.nvvm.sad.i
-    1, // llvm.nvvm.sad.ui
-    1, // llvm.nvvm.saturate.d
-    1, // llvm.nvvm.saturate.f
-    1, // llvm.nvvm.saturate.ftz.f
-    58, // llvm.nvvm.shfl.bfly.f32
-    58, // llvm.nvvm.shfl.bfly.i32
-    58, // llvm.nvvm.shfl.down.f32
-    58, // llvm.nvvm.shfl.down.i32
-    58, // llvm.nvvm.shfl.idx.f32
-    58, // llvm.nvvm.shfl.idx.i32
-    58, // llvm.nvvm.shfl.sync.bfly.f32
-    58, // llvm.nvvm.shfl.sync.bfly.i32
-    58, // llvm.nvvm.shfl.sync.down.f32
-    58, // llvm.nvvm.shfl.sync.down.i32
-    58, // llvm.nvvm.shfl.sync.idx.f32
-    58, // llvm.nvvm.shfl.sync.idx.i32
-    58, // llvm.nvvm.shfl.sync.up.f32
-    58, // llvm.nvvm.shfl.sync.up.i32
-    58, // llvm.nvvm.shfl.up.f32
-    58, // llvm.nvvm.shfl.up.i32
-    1, // llvm.nvvm.sin.approx.f
-    1, // llvm.nvvm.sin.approx.ftz.f
-    1, // llvm.nvvm.sqrt.approx.f
-    1, // llvm.nvvm.sqrt.approx.ftz.f
-    1, // llvm.nvvm.sqrt.f
-    1, // llvm.nvvm.sqrt.rm.d
-    1, // llvm.nvvm.sqrt.rm.f
-    1, // llvm.nvvm.sqrt.rm.ftz.f
-    1, // llvm.nvvm.sqrt.rn.d
-    1, // llvm.nvvm.sqrt.rn.f
-    1, // llvm.nvvm.sqrt.rn.ftz.f
-    1, // llvm.nvvm.sqrt.rp.d
-    1, // llvm.nvvm.sqrt.rp.f
-    1, // llvm.nvvm.sqrt.rp.ftz.f
-    1, // llvm.nvvm.sqrt.rz.d
-    1, // llvm.nvvm.sqrt.rz.f
-    1, // llvm.nvvm.sqrt.rz.ftz.f
-    3, // llvm.nvvm.suld.1d.array.i16.clamp
-    3, // llvm.nvvm.suld.1d.array.i16.trap
-    3, // llvm.nvvm.suld.1d.array.i16.zero
-    3, // llvm.nvvm.suld.1d.array.i32.clamp
-    3, // llvm.nvvm.suld.1d.array.i32.trap
-    3, // llvm.nvvm.suld.1d.array.i32.zero
-    3, // llvm.nvvm.suld.1d.array.i64.clamp
-    3, // llvm.nvvm.suld.1d.array.i64.trap
-    3, // llvm.nvvm.suld.1d.array.i64.zero
-    3, // llvm.nvvm.suld.1d.array.i8.clamp
-    3, // llvm.nvvm.suld.1d.array.i8.trap
-    3, // llvm.nvvm.suld.1d.array.i8.zero
-    3, // llvm.nvvm.suld.1d.array.v2i16.clamp
-    3, // llvm.nvvm.suld.1d.array.v2i16.trap
-    3, // llvm.nvvm.suld.1d.array.v2i16.zero
-    3, // llvm.nvvm.suld.1d.array.v2i32.clamp
-    3, // llvm.nvvm.suld.1d.array.v2i32.trap
-    3, // llvm.nvvm.suld.1d.array.v2i32.zero
-    3, // llvm.nvvm.suld.1d.array.v2i64.clamp
-    3, // llvm.nvvm.suld.1d.array.v2i64.trap
-    3, // llvm.nvvm.suld.1d.array.v2i64.zero
-    3, // llvm.nvvm.suld.1d.array.v2i8.clamp
-    3, // llvm.nvvm.suld.1d.array.v2i8.trap
-    3, // llvm.nvvm.suld.1d.array.v2i8.zero
-    3, // llvm.nvvm.suld.1d.array.v4i16.clamp
-    3, // llvm.nvvm.suld.1d.array.v4i16.trap
-    3, // llvm.nvvm.suld.1d.array.v4i16.zero
-    3, // llvm.nvvm.suld.1d.array.v4i32.clamp
-    3, // llvm.nvvm.suld.1d.array.v4i32.trap
-    3, // llvm.nvvm.suld.1d.array.v4i32.zero
-    3, // llvm.nvvm.suld.1d.array.v4i8.clamp
-    3, // llvm.nvvm.suld.1d.array.v4i8.trap
-    3, // llvm.nvvm.suld.1d.array.v4i8.zero
-    3, // llvm.nvvm.suld.1d.i16.clamp
-    3, // llvm.nvvm.suld.1d.i16.trap
-    3, // llvm.nvvm.suld.1d.i16.zero
-    3, // llvm.nvvm.suld.1d.i32.clamp
-    3, // llvm.nvvm.suld.1d.i32.trap
-    3, // llvm.nvvm.suld.1d.i32.zero
-    3, // llvm.nvvm.suld.1d.i64.clamp
-    3, // llvm.nvvm.suld.1d.i64.trap
-    3, // llvm.nvvm.suld.1d.i64.zero
-    3, // llvm.nvvm.suld.1d.i8.clamp
-    3, // llvm.nvvm.suld.1d.i8.trap
-    3, // llvm.nvvm.suld.1d.i8.zero
-    3, // llvm.nvvm.suld.1d.v2i16.clamp
-    3, // llvm.nvvm.suld.1d.v2i16.trap
-    3, // llvm.nvvm.suld.1d.v2i16.zero
-    3, // llvm.nvvm.suld.1d.v2i32.clamp
-    3, // llvm.nvvm.suld.1d.v2i32.trap
-    3, // llvm.nvvm.suld.1d.v2i32.zero
-    3, // llvm.nvvm.suld.1d.v2i64.clamp
-    3, // llvm.nvvm.suld.1d.v2i64.trap
-    3, // llvm.nvvm.suld.1d.v2i64.zero
-    3, // llvm.nvvm.suld.1d.v2i8.clamp
-    3, // llvm.nvvm.suld.1d.v2i8.trap
-    3, // llvm.nvvm.suld.1d.v2i8.zero
-    3, // llvm.nvvm.suld.1d.v4i16.clamp
-    3, // llvm.nvvm.suld.1d.v4i16.trap
-    3, // llvm.nvvm.suld.1d.v4i16.zero
-    3, // llvm.nvvm.suld.1d.v4i32.clamp
-    3, // llvm.nvvm.suld.1d.v4i32.trap
-    3, // llvm.nvvm.suld.1d.v4i32.zero
-    3, // llvm.nvvm.suld.1d.v4i8.clamp
-    3, // llvm.nvvm.suld.1d.v4i8.trap
-    3, // llvm.nvvm.suld.1d.v4i8.zero
-    3, // llvm.nvvm.suld.2d.array.i16.clamp
-    3, // llvm.nvvm.suld.2d.array.i16.trap
-    3, // llvm.nvvm.suld.2d.array.i16.zero
-    3, // llvm.nvvm.suld.2d.array.i32.clamp
-    3, // llvm.nvvm.suld.2d.array.i32.trap
-    3, // llvm.nvvm.suld.2d.array.i32.zero
-    3, // llvm.nvvm.suld.2d.array.i64.clamp
-    3, // llvm.nvvm.suld.2d.array.i64.trap
-    3, // llvm.nvvm.suld.2d.array.i64.zero
-    3, // llvm.nvvm.suld.2d.array.i8.clamp
-    3, // llvm.nvvm.suld.2d.array.i8.trap
-    3, // llvm.nvvm.suld.2d.array.i8.zero
-    3, // llvm.nvvm.suld.2d.array.v2i16.clamp
-    3, // llvm.nvvm.suld.2d.array.v2i16.trap
-    3, // llvm.nvvm.suld.2d.array.v2i16.zero
-    3, // llvm.nvvm.suld.2d.array.v2i32.clamp
-    3, // llvm.nvvm.suld.2d.array.v2i32.trap
-    3, // llvm.nvvm.suld.2d.array.v2i32.zero
-    3, // llvm.nvvm.suld.2d.array.v2i64.clamp
-    3, // llvm.nvvm.suld.2d.array.v2i64.trap
-    3, // llvm.nvvm.suld.2d.array.v2i64.zero
-    3, // llvm.nvvm.suld.2d.array.v2i8.clamp
-    3, // llvm.nvvm.suld.2d.array.v2i8.trap
-    3, // llvm.nvvm.suld.2d.array.v2i8.zero
-    3, // llvm.nvvm.suld.2d.array.v4i16.clamp
-    3, // llvm.nvvm.suld.2d.array.v4i16.trap
-    3, // llvm.nvvm.suld.2d.array.v4i16.zero
-    3, // llvm.nvvm.suld.2d.array.v4i32.clamp
-    3, // llvm.nvvm.suld.2d.array.v4i32.trap
-    3, // llvm.nvvm.suld.2d.array.v4i32.zero
-    3, // llvm.nvvm.suld.2d.array.v4i8.clamp
-    3, // llvm.nvvm.suld.2d.array.v4i8.trap
-    3, // llvm.nvvm.suld.2d.array.v4i8.zero
-    3, // llvm.nvvm.suld.2d.i16.clamp
-    3, // llvm.nvvm.suld.2d.i16.trap
-    3, // llvm.nvvm.suld.2d.i16.zero
-    3, // llvm.nvvm.suld.2d.i32.clamp
-    3, // llvm.nvvm.suld.2d.i32.trap
-    3, // llvm.nvvm.suld.2d.i32.zero
-    3, // llvm.nvvm.suld.2d.i64.clamp
-    3, // llvm.nvvm.suld.2d.i64.trap
-    3, // llvm.nvvm.suld.2d.i64.zero
-    3, // llvm.nvvm.suld.2d.i8.clamp
-    3, // llvm.nvvm.suld.2d.i8.trap
-    3, // llvm.nvvm.suld.2d.i8.zero
-    3, // llvm.nvvm.suld.2d.v2i16.clamp
-    3, // llvm.nvvm.suld.2d.v2i16.trap
-    3, // llvm.nvvm.suld.2d.v2i16.zero
-    3, // llvm.nvvm.suld.2d.v2i32.clamp
-    3, // llvm.nvvm.suld.2d.v2i32.trap
-    3, // llvm.nvvm.suld.2d.v2i32.zero
-    3, // llvm.nvvm.suld.2d.v2i64.clamp
-    3, // llvm.nvvm.suld.2d.v2i64.trap
-    3, // llvm.nvvm.suld.2d.v2i64.zero
-    3, // llvm.nvvm.suld.2d.v2i8.clamp
-    3, // llvm.nvvm.suld.2d.v2i8.trap
-    3, // llvm.nvvm.suld.2d.v2i8.zero
-    3, // llvm.nvvm.suld.2d.v4i16.clamp
-    3, // llvm.nvvm.suld.2d.v4i16.trap
-    3, // llvm.nvvm.suld.2d.v4i16.zero
-    3, // llvm.nvvm.suld.2d.v4i32.clamp
-    3, // llvm.nvvm.suld.2d.v4i32.trap
-    3, // llvm.nvvm.suld.2d.v4i32.zero
-    3, // llvm.nvvm.suld.2d.v4i8.clamp
-    3, // llvm.nvvm.suld.2d.v4i8.trap
-    3, // llvm.nvvm.suld.2d.v4i8.zero
-    3, // llvm.nvvm.suld.3d.i16.clamp
-    3, // llvm.nvvm.suld.3d.i16.trap
-    3, // llvm.nvvm.suld.3d.i16.zero
-    3, // llvm.nvvm.suld.3d.i32.clamp
-    3, // llvm.nvvm.suld.3d.i32.trap
-    3, // llvm.nvvm.suld.3d.i32.zero
-    3, // llvm.nvvm.suld.3d.i64.clamp
-    3, // llvm.nvvm.suld.3d.i64.trap
-    3, // llvm.nvvm.suld.3d.i64.zero
-    3, // llvm.nvvm.suld.3d.i8.clamp
-    3, // llvm.nvvm.suld.3d.i8.trap
-    3, // llvm.nvvm.suld.3d.i8.zero
-    3, // llvm.nvvm.suld.3d.v2i16.clamp
-    3, // llvm.nvvm.suld.3d.v2i16.trap
-    3, // llvm.nvvm.suld.3d.v2i16.zero
-    3, // llvm.nvvm.suld.3d.v2i32.clamp
-    3, // llvm.nvvm.suld.3d.v2i32.trap
-    3, // llvm.nvvm.suld.3d.v2i32.zero
-    3, // llvm.nvvm.suld.3d.v2i64.clamp
-    3, // llvm.nvvm.suld.3d.v2i64.trap
-    3, // llvm.nvvm.suld.3d.v2i64.zero
-    3, // llvm.nvvm.suld.3d.v2i8.clamp
-    3, // llvm.nvvm.suld.3d.v2i8.trap
-    3, // llvm.nvvm.suld.3d.v2i8.zero
-    3, // llvm.nvvm.suld.3d.v4i16.clamp
-    3, // llvm.nvvm.suld.3d.v4i16.trap
-    3, // llvm.nvvm.suld.3d.v4i16.zero
-    3, // llvm.nvvm.suld.3d.v4i32.clamp
-    3, // llvm.nvvm.suld.3d.v4i32.trap
-    3, // llvm.nvvm.suld.3d.v4i32.zero
-    3, // llvm.nvvm.suld.3d.v4i8.clamp
-    3, // llvm.nvvm.suld.3d.v4i8.trap
-    3, // llvm.nvvm.suld.3d.v4i8.zero
-    1, // llvm.nvvm.suq.array.size
-    1, // llvm.nvvm.suq.channel.data.type
-    1, // llvm.nvvm.suq.channel.order
-    1, // llvm.nvvm.suq.depth
-    1, // llvm.nvvm.suq.height
-    1, // llvm.nvvm.suq.width
-    3, // llvm.nvvm.sust.b.1d.array.i16.clamp
-    3, // llvm.nvvm.sust.b.1d.array.i16.trap
-    3, // llvm.nvvm.sust.b.1d.array.i16.zero
-    3, // llvm.nvvm.sust.b.1d.array.i32.clamp
-    3, // llvm.nvvm.sust.b.1d.array.i32.trap
-    3, // llvm.nvvm.sust.b.1d.array.i32.zero
-    3, // llvm.nvvm.sust.b.1d.array.i64.clamp
-    3, // llvm.nvvm.sust.b.1d.array.i64.trap
-    3, // llvm.nvvm.sust.b.1d.array.i64.zero
-    3, // llvm.nvvm.sust.b.1d.array.i8.clamp
-    3, // llvm.nvvm.sust.b.1d.array.i8.trap
-    3, // llvm.nvvm.sust.b.1d.array.i8.zero
-    3, // llvm.nvvm.sust.b.1d.array.v2i16.clamp
-    3, // llvm.nvvm.sust.b.1d.array.v2i16.trap
-    3, // llvm.nvvm.sust.b.1d.array.v2i16.zero
-    3, // llvm.nvvm.sust.b.1d.array.v2i32.clamp
-    3, // llvm.nvvm.sust.b.1d.array.v2i32.trap
-    3, // llvm.nvvm.sust.b.1d.array.v2i32.zero
-    3, // llvm.nvvm.sust.b.1d.array.v2i64.clamp
-    3, // llvm.nvvm.sust.b.1d.array.v2i64.trap
-    3, // llvm.nvvm.sust.b.1d.array.v2i64.zero
-    3, // llvm.nvvm.sust.b.1d.array.v2i8.clamp
-    3, // llvm.nvvm.sust.b.1d.array.v2i8.trap
-    3, // llvm.nvvm.sust.b.1d.array.v2i8.zero
-    3, // llvm.nvvm.sust.b.1d.array.v4i16.clamp
-    3, // llvm.nvvm.sust.b.1d.array.v4i16.trap
-    3, // llvm.nvvm.sust.b.1d.array.v4i16.zero
-    3, // llvm.nvvm.sust.b.1d.array.v4i32.clamp
-    3, // llvm.nvvm.sust.b.1d.array.v4i32.trap
-    3, // llvm.nvvm.sust.b.1d.array.v4i32.zero
-    3, // llvm.nvvm.sust.b.1d.array.v4i8.clamp
-    3, // llvm.nvvm.sust.b.1d.array.v4i8.trap
-    3, // llvm.nvvm.sust.b.1d.array.v4i8.zero
-    3, // llvm.nvvm.sust.b.1d.i16.clamp
-    3, // llvm.nvvm.sust.b.1d.i16.trap
-    3, // llvm.nvvm.sust.b.1d.i16.zero
-    3, // llvm.nvvm.sust.b.1d.i32.clamp
-    3, // llvm.nvvm.sust.b.1d.i32.trap
-    3, // llvm.nvvm.sust.b.1d.i32.zero
-    3, // llvm.nvvm.sust.b.1d.i64.clamp
-    3, // llvm.nvvm.sust.b.1d.i64.trap
-    3, // llvm.nvvm.sust.b.1d.i64.zero
-    3, // llvm.nvvm.sust.b.1d.i8.clamp
-    3, // llvm.nvvm.sust.b.1d.i8.trap
-    3, // llvm.nvvm.sust.b.1d.i8.zero
-    3, // llvm.nvvm.sust.b.1d.v2i16.clamp
-    3, // llvm.nvvm.sust.b.1d.v2i16.trap
-    3, // llvm.nvvm.sust.b.1d.v2i16.zero
-    3, // llvm.nvvm.sust.b.1d.v2i32.clamp
-    3, // llvm.nvvm.sust.b.1d.v2i32.trap
-    3, // llvm.nvvm.sust.b.1d.v2i32.zero
-    3, // llvm.nvvm.sust.b.1d.v2i64.clamp
-    3, // llvm.nvvm.sust.b.1d.v2i64.trap
-    3, // llvm.nvvm.sust.b.1d.v2i64.zero
-    3, // llvm.nvvm.sust.b.1d.v2i8.clamp
-    3, // llvm.nvvm.sust.b.1d.v2i8.trap
-    3, // llvm.nvvm.sust.b.1d.v2i8.zero
-    3, // llvm.nvvm.sust.b.1d.v4i16.clamp
-    3, // llvm.nvvm.sust.b.1d.v4i16.trap
-    3, // llvm.nvvm.sust.b.1d.v4i16.zero
-    3, // llvm.nvvm.sust.b.1d.v4i32.clamp
-    3, // llvm.nvvm.sust.b.1d.v4i32.trap
-    3, // llvm.nvvm.sust.b.1d.v4i32.zero
-    3, // llvm.nvvm.sust.b.1d.v4i8.clamp
-    3, // llvm.nvvm.sust.b.1d.v4i8.trap
-    3, // llvm.nvvm.sust.b.1d.v4i8.zero
-    3, // llvm.nvvm.sust.b.2d.array.i16.clamp
-    3, // llvm.nvvm.sust.b.2d.array.i16.trap
-    3, // llvm.nvvm.sust.b.2d.array.i16.zero
-    3, // llvm.nvvm.sust.b.2d.array.i32.clamp
-    3, // llvm.nvvm.sust.b.2d.array.i32.trap
-    3, // llvm.nvvm.sust.b.2d.array.i32.zero
-    3, // llvm.nvvm.sust.b.2d.array.i64.clamp
-    3, // llvm.nvvm.sust.b.2d.array.i64.trap
-    3, // llvm.nvvm.sust.b.2d.array.i64.zero
-    3, // llvm.nvvm.sust.b.2d.array.i8.clamp
-    3, // llvm.nvvm.sust.b.2d.array.i8.trap
-    3, // llvm.nvvm.sust.b.2d.array.i8.zero
-    3, // llvm.nvvm.sust.b.2d.array.v2i16.clamp
-    3, // llvm.nvvm.sust.b.2d.array.v2i16.trap
-    3, // llvm.nvvm.sust.b.2d.array.v2i16.zero
-    3, // llvm.nvvm.sust.b.2d.array.v2i32.clamp
-    3, // llvm.nvvm.sust.b.2d.array.v2i32.trap
-    3, // llvm.nvvm.sust.b.2d.array.v2i32.zero
-    3, // llvm.nvvm.sust.b.2d.array.v2i64.clamp
-    3, // llvm.nvvm.sust.b.2d.array.v2i64.trap
-    3, // llvm.nvvm.sust.b.2d.array.v2i64.zero
-    3, // llvm.nvvm.sust.b.2d.array.v2i8.clamp
-    3, // llvm.nvvm.sust.b.2d.array.v2i8.trap
-    3, // llvm.nvvm.sust.b.2d.array.v2i8.zero
-    3, // llvm.nvvm.sust.b.2d.array.v4i16.clamp
-    3, // llvm.nvvm.sust.b.2d.array.v4i16.trap
-    3, // llvm.nvvm.sust.b.2d.array.v4i16.zero
-    3, // llvm.nvvm.sust.b.2d.array.v4i32.clamp
-    3, // llvm.nvvm.sust.b.2d.array.v4i32.trap
-    3, // llvm.nvvm.sust.b.2d.array.v4i32.zero
-    3, // llvm.nvvm.sust.b.2d.array.v4i8.clamp
-    3, // llvm.nvvm.sust.b.2d.array.v4i8.trap
-    3, // llvm.nvvm.sust.b.2d.array.v4i8.zero
-    3, // llvm.nvvm.sust.b.2d.i16.clamp
-    3, // llvm.nvvm.sust.b.2d.i16.trap
-    3, // llvm.nvvm.sust.b.2d.i16.zero
-    3, // llvm.nvvm.sust.b.2d.i32.clamp
-    3, // llvm.nvvm.sust.b.2d.i32.trap
-    3, // llvm.nvvm.sust.b.2d.i32.zero
-    3, // llvm.nvvm.sust.b.2d.i64.clamp
-    3, // llvm.nvvm.sust.b.2d.i64.trap
-    3, // llvm.nvvm.sust.b.2d.i64.zero
-    3, // llvm.nvvm.sust.b.2d.i8.clamp
-    3, // llvm.nvvm.sust.b.2d.i8.trap
-    3, // llvm.nvvm.sust.b.2d.i8.zero
-    3, // llvm.nvvm.sust.b.2d.v2i16.clamp
-    3, // llvm.nvvm.sust.b.2d.v2i16.trap
-    3, // llvm.nvvm.sust.b.2d.v2i16.zero
-    3, // llvm.nvvm.sust.b.2d.v2i32.clamp
-    3, // llvm.nvvm.sust.b.2d.v2i32.trap
-    3, // llvm.nvvm.sust.b.2d.v2i32.zero
-    3, // llvm.nvvm.sust.b.2d.v2i64.clamp
-    3, // llvm.nvvm.sust.b.2d.v2i64.trap
-    3, // llvm.nvvm.sust.b.2d.v2i64.zero
-    3, // llvm.nvvm.sust.b.2d.v2i8.clamp
-    3, // llvm.nvvm.sust.b.2d.v2i8.trap
-    3, // llvm.nvvm.sust.b.2d.v2i8.zero
-    3, // llvm.nvvm.sust.b.2d.v4i16.clamp
-    3, // llvm.nvvm.sust.b.2d.v4i16.trap
-    3, // llvm.nvvm.sust.b.2d.v4i16.zero
-    3, // llvm.nvvm.sust.b.2d.v4i32.clamp
-    3, // llvm.nvvm.sust.b.2d.v4i32.trap
-    3, // llvm.nvvm.sust.b.2d.v4i32.zero
-    3, // llvm.nvvm.sust.b.2d.v4i8.clamp
-    3, // llvm.nvvm.sust.b.2d.v4i8.trap
-    3, // llvm.nvvm.sust.b.2d.v4i8.zero
-    3, // llvm.nvvm.sust.b.3d.i16.clamp
-    3, // llvm.nvvm.sust.b.3d.i16.trap
-    3, // llvm.nvvm.sust.b.3d.i16.zero
-    3, // llvm.nvvm.sust.b.3d.i32.clamp
-    3, // llvm.nvvm.sust.b.3d.i32.trap
-    3, // llvm.nvvm.sust.b.3d.i32.zero
-    3, // llvm.nvvm.sust.b.3d.i64.clamp
-    3, // llvm.nvvm.sust.b.3d.i64.trap
-    3, // llvm.nvvm.sust.b.3d.i64.zero
-    3, // llvm.nvvm.sust.b.3d.i8.clamp
-    3, // llvm.nvvm.sust.b.3d.i8.trap
-    3, // llvm.nvvm.sust.b.3d.i8.zero
-    3, // llvm.nvvm.sust.b.3d.v2i16.clamp
-    3, // llvm.nvvm.sust.b.3d.v2i16.trap
-    3, // llvm.nvvm.sust.b.3d.v2i16.zero
-    3, // llvm.nvvm.sust.b.3d.v2i32.clamp
-    3, // llvm.nvvm.sust.b.3d.v2i32.trap
-    3, // llvm.nvvm.sust.b.3d.v2i32.zero
-    3, // llvm.nvvm.sust.b.3d.v2i64.clamp
-    3, // llvm.nvvm.sust.b.3d.v2i64.trap
-    3, // llvm.nvvm.sust.b.3d.v2i64.zero
-    3, // llvm.nvvm.sust.b.3d.v2i8.clamp
-    3, // llvm.nvvm.sust.b.3d.v2i8.trap
-    3, // llvm.nvvm.sust.b.3d.v2i8.zero
-    3, // llvm.nvvm.sust.b.3d.v4i16.clamp
-    3, // llvm.nvvm.sust.b.3d.v4i16.trap
-    3, // llvm.nvvm.sust.b.3d.v4i16.zero
-    3, // llvm.nvvm.sust.b.3d.v4i32.clamp
-    3, // llvm.nvvm.sust.b.3d.v4i32.trap
-    3, // llvm.nvvm.sust.b.3d.v4i32.zero
-    3, // llvm.nvvm.sust.b.3d.v4i8.clamp
-    3, // llvm.nvvm.sust.b.3d.v4i8.trap
-    3, // llvm.nvvm.sust.b.3d.v4i8.zero
-    3, // llvm.nvvm.sust.p.1d.array.i16.trap
-    3, // llvm.nvvm.sust.p.1d.array.i32.trap
-    3, // llvm.nvvm.sust.p.1d.array.i8.trap
-    3, // llvm.nvvm.sust.p.1d.array.v2i16.trap
-    3, // llvm.nvvm.sust.p.1d.array.v2i32.trap
-    3, // llvm.nvvm.sust.p.1d.array.v2i8.trap
-    3, // llvm.nvvm.sust.p.1d.array.v4i16.trap
-    3, // llvm.nvvm.sust.p.1d.array.v4i32.trap
-    3, // llvm.nvvm.sust.p.1d.array.v4i8.trap
-    3, // llvm.nvvm.sust.p.1d.i16.trap
-    3, // llvm.nvvm.sust.p.1d.i32.trap
-    3, // llvm.nvvm.sust.p.1d.i8.trap
-    3, // llvm.nvvm.sust.p.1d.v2i16.trap
-    3, // llvm.nvvm.sust.p.1d.v2i32.trap
-    3, // llvm.nvvm.sust.p.1d.v2i8.trap
-    3, // llvm.nvvm.sust.p.1d.v4i16.trap
-    3, // llvm.nvvm.sust.p.1d.v4i32.trap
-    3, // llvm.nvvm.sust.p.1d.v4i8.trap
-    3, // llvm.nvvm.sust.p.2d.array.i16.trap
-    3, // llvm.nvvm.sust.p.2d.array.i32.trap
-    3, // llvm.nvvm.sust.p.2d.array.i8.trap
-    3, // llvm.nvvm.sust.p.2d.array.v2i16.trap
-    3, // llvm.nvvm.sust.p.2d.array.v2i32.trap
-    3, // llvm.nvvm.sust.p.2d.array.v2i8.trap
-    3, // llvm.nvvm.sust.p.2d.array.v4i16.trap
-    3, // llvm.nvvm.sust.p.2d.array.v4i32.trap
-    3, // llvm.nvvm.sust.p.2d.array.v4i8.trap
-    3, // llvm.nvvm.sust.p.2d.i16.trap
-    3, // llvm.nvvm.sust.p.2d.i32.trap
-    3, // llvm.nvvm.sust.p.2d.i8.trap
-    3, // llvm.nvvm.sust.p.2d.v2i16.trap
-    3, // llvm.nvvm.sust.p.2d.v2i32.trap
-    3, // llvm.nvvm.sust.p.2d.v2i8.trap
-    3, // llvm.nvvm.sust.p.2d.v4i16.trap
-    3, // llvm.nvvm.sust.p.2d.v4i32.trap
-    3, // llvm.nvvm.sust.p.2d.v4i8.trap
-    3, // llvm.nvvm.sust.p.3d.i16.trap
-    3, // llvm.nvvm.sust.p.3d.i32.trap
-    3, // llvm.nvvm.sust.p.3d.i8.trap
-    3, // llvm.nvvm.sust.p.3d.v2i16.trap
-    3, // llvm.nvvm.sust.p.3d.v2i32.trap
-    3, // llvm.nvvm.sust.p.3d.v2i8.trap
-    3, // llvm.nvvm.sust.p.3d.v4i16.trap
-    3, // llvm.nvvm.sust.p.3d.v4i32.trap
-    3, // llvm.nvvm.sust.p.3d.v4i8.trap
-    1, // llvm.nvvm.swap.lo.hi.b64
-    3, // llvm.nvvm.tex.1d.array.grad.v4f32.f32
-    3, // llvm.nvvm.tex.1d.array.grad.v4s32.f32
-    3, // llvm.nvvm.tex.1d.array.grad.v4u32.f32
-    3, // llvm.nvvm.tex.1d.array.level.v4f32.f32
-    3, // llvm.nvvm.tex.1d.array.level.v4s32.f32
-    3, // llvm.nvvm.tex.1d.array.level.v4u32.f32
-    3, // llvm.nvvm.tex.1d.array.v4f32.f32
-    3, // llvm.nvvm.tex.1d.array.v4f32.s32
-    3, // llvm.nvvm.tex.1d.array.v4s32.f32
-    3, // llvm.nvvm.tex.1d.array.v4s32.s32
-    3, // llvm.nvvm.tex.1d.array.v4u32.f32
-    3, // llvm.nvvm.tex.1d.array.v4u32.s32
-    3, // llvm.nvvm.tex.1d.grad.v4f32.f32
-    3, // llvm.nvvm.tex.1d.grad.v4s32.f32
-    3, // llvm.nvvm.tex.1d.grad.v4u32.f32
-    3, // llvm.nvvm.tex.1d.level.v4f32.f32
-    3, // llvm.nvvm.tex.1d.level.v4s32.f32
-    3, // llvm.nvvm.tex.1d.level.v4u32.f32
-    3, // llvm.nvvm.tex.1d.v4f32.f32
-    3, // llvm.nvvm.tex.1d.v4f32.s32
-    3, // llvm.nvvm.tex.1d.v4s32.f32
-    3, // llvm.nvvm.tex.1d.v4s32.s32
-    3, // llvm.nvvm.tex.1d.v4u32.f32
-    3, // llvm.nvvm.tex.1d.v4u32.s32
-    3, // llvm.nvvm.tex.2d.array.grad.v4f32.f32
-    3, // llvm.nvvm.tex.2d.array.grad.v4s32.f32
-    3, // llvm.nvvm.tex.2d.array.grad.v4u32.f32
-    3, // llvm.nvvm.tex.2d.array.level.v4f32.f32
-    3, // llvm.nvvm.tex.2d.array.level.v4s32.f32
-    3, // llvm.nvvm.tex.2d.array.level.v4u32.f32
-    3, // llvm.nvvm.tex.2d.array.v4f32.f32
-    3, // llvm.nvvm.tex.2d.array.v4f32.s32
-    3, // llvm.nvvm.tex.2d.array.v4s32.f32
-    3, // llvm.nvvm.tex.2d.array.v4s32.s32
-    3, // llvm.nvvm.tex.2d.array.v4u32.f32
-    3, // llvm.nvvm.tex.2d.array.v4u32.s32
-    3, // llvm.nvvm.tex.2d.grad.v4f32.f32
-    3, // llvm.nvvm.tex.2d.grad.v4s32.f32
-    3, // llvm.nvvm.tex.2d.grad.v4u32.f32
-    3, // llvm.nvvm.tex.2d.level.v4f32.f32
-    3, // llvm.nvvm.tex.2d.level.v4s32.f32
-    3, // llvm.nvvm.tex.2d.level.v4u32.f32
-    3, // llvm.nvvm.tex.2d.v4f32.f32
-    3, // llvm.nvvm.tex.2d.v4f32.s32
-    3, // llvm.nvvm.tex.2d.v4s32.f32
-    3, // llvm.nvvm.tex.2d.v4s32.s32
-    3, // llvm.nvvm.tex.2d.v4u32.f32
-    3, // llvm.nvvm.tex.2d.v4u32.s32
-    3, // llvm.nvvm.tex.3d.grad.v4f32.f32
-    3, // llvm.nvvm.tex.3d.grad.v4s32.f32
-    3, // llvm.nvvm.tex.3d.grad.v4u32.f32
-    3, // llvm.nvvm.tex.3d.level.v4f32.f32
-    3, // llvm.nvvm.tex.3d.level.v4s32.f32
-    3, // llvm.nvvm.tex.3d.level.v4u32.f32
-    3, // llvm.nvvm.tex.3d.v4f32.f32
-    3, // llvm.nvvm.tex.3d.v4f32.s32
-    3, // llvm.nvvm.tex.3d.v4s32.f32
-    3, // llvm.nvvm.tex.3d.v4s32.s32
-    3, // llvm.nvvm.tex.3d.v4u32.f32
-    3, // llvm.nvvm.tex.3d.v4u32.s32
-    3, // llvm.nvvm.tex.cube.array.level.v4f32.f32
-    3, // llvm.nvvm.tex.cube.array.level.v4s32.f32
-    3, // llvm.nvvm.tex.cube.array.level.v4u32.f32
-    3, // llvm.nvvm.tex.cube.array.v4f32.f32
-    3, // llvm.nvvm.tex.cube.array.v4s32.f32
-    3, // llvm.nvvm.tex.cube.array.v4u32.f32
-    3, // llvm.nvvm.tex.cube.level.v4f32.f32
-    3, // llvm.nvvm.tex.cube.level.v4s32.f32
-    3, // llvm.nvvm.tex.cube.level.v4u32.f32
-    3, // llvm.nvvm.tex.cube.v4f32.f32
-    3, // llvm.nvvm.tex.cube.v4s32.f32
-    3, // llvm.nvvm.tex.cube.v4u32.f32
-    3, // llvm.nvvm.tex.unified.1d.array.grad.v4f32.f32
-    3, // llvm.nvvm.tex.unified.1d.array.grad.v4s32.f32
-    3, // llvm.nvvm.tex.unified.1d.array.grad.v4u32.f32
-    3, // llvm.nvvm.tex.unified.1d.array.level.v4f32.f32
-    3, // llvm.nvvm.tex.unified.1d.array.level.v4s32.f32
-    3, // llvm.nvvm.tex.unified.1d.array.level.v4u32.f32
-    3, // llvm.nvvm.tex.unified.1d.array.v4f32.f32
-    3, // llvm.nvvm.tex.unified.1d.array.v4f32.s32
-    3, // llvm.nvvm.tex.unified.1d.array.v4s32.f32
-    3, // llvm.nvvm.tex.unified.1d.array.v4s32.s32
-    3, // llvm.nvvm.tex.unified.1d.array.v4u32.f32
-    3, // llvm.nvvm.tex.unified.1d.array.v4u32.s32
-    3, // llvm.nvvm.tex.unified.1d.grad.v4f32.f32
-    3, // llvm.nvvm.tex.unified.1d.grad.v4s32.f32
-    3, // llvm.nvvm.tex.unified.1d.grad.v4u32.f32
-    3, // llvm.nvvm.tex.unified.1d.level.v4f32.f32
-    3, // llvm.nvvm.tex.unified.1d.level.v4s32.f32
-    3, // llvm.nvvm.tex.unified.1d.level.v4u32.f32
-    3, // llvm.nvvm.tex.unified.1d.v4f32.f32
-    3, // llvm.nvvm.tex.unified.1d.v4f32.s32
-    3, // llvm.nvvm.tex.unified.1d.v4s32.f32
-    3, // llvm.nvvm.tex.unified.1d.v4s32.s32
-    3, // llvm.nvvm.tex.unified.1d.v4u32.f32
-    3, // llvm.nvvm.tex.unified.1d.v4u32.s32
-    3, // llvm.nvvm.tex.unified.2d.array.grad.v4f32.f32
-    3, // llvm.nvvm.tex.unified.2d.array.grad.v4s32.f32
-    3, // llvm.nvvm.tex.unified.2d.array.grad.v4u32.f32
-    3, // llvm.nvvm.tex.unified.2d.array.level.v4f32.f32
-    3, // llvm.nvvm.tex.unified.2d.array.level.v4s32.f32
-    3, // llvm.nvvm.tex.unified.2d.array.level.v4u32.f32
-    3, // llvm.nvvm.tex.unified.2d.array.v4f32.f32
-    3, // llvm.nvvm.tex.unified.2d.array.v4f32.s32
-    3, // llvm.nvvm.tex.unified.2d.array.v4s32.f32
-    3, // llvm.nvvm.tex.unified.2d.array.v4s32.s32
-    3, // llvm.nvvm.tex.unified.2d.array.v4u32.f32
-    3, // llvm.nvvm.tex.unified.2d.array.v4u32.s32
-    3, // llvm.nvvm.tex.unified.2d.grad.v4f32.f32
-    3, // llvm.nvvm.tex.unified.2d.grad.v4s32.f32
-    3, // llvm.nvvm.tex.unified.2d.grad.v4u32.f32
-    3, // llvm.nvvm.tex.unified.2d.level.v4f32.f32
-    3, // llvm.nvvm.tex.unified.2d.level.v4s32.f32
-    3, // llvm.nvvm.tex.unified.2d.level.v4u32.f32
-    3, // llvm.nvvm.tex.unified.2d.v4f32.f32
-    3, // llvm.nvvm.tex.unified.2d.v4f32.s32
-    3, // llvm.nvvm.tex.unified.2d.v4s32.f32
-    3, // llvm.nvvm.tex.unified.2d.v4s32.s32
-    3, // llvm.nvvm.tex.unified.2d.v4u32.f32
-    3, // llvm.nvvm.tex.unified.2d.v4u32.s32
-    3, // llvm.nvvm.tex.unified.3d.grad.v4f32.f32
-    3, // llvm.nvvm.tex.unified.3d.grad.v4s32.f32
-    3, // llvm.nvvm.tex.unified.3d.grad.v4u32.f32
-    3, // llvm.nvvm.tex.unified.3d.level.v4f32.f32
-    3, // llvm.nvvm.tex.unified.3d.level.v4s32.f32
-    3, // llvm.nvvm.tex.unified.3d.level.v4u32.f32
-    3, // llvm.nvvm.tex.unified.3d.v4f32.f32
-    3, // llvm.nvvm.tex.unified.3d.v4f32.s32
-    3, // llvm.nvvm.tex.unified.3d.v4s32.f32
-    3, // llvm.nvvm.tex.unified.3d.v4s32.s32
-    3, // llvm.nvvm.tex.unified.3d.v4u32.f32
-    3, // llvm.nvvm.tex.unified.3d.v4u32.s32
-    3, // llvm.nvvm.tex.unified.cube.array.level.v4f32.f32
-    3, // llvm.nvvm.tex.unified.cube.array.level.v4s32.f32
-    3, // llvm.nvvm.tex.unified.cube.array.level.v4u32.f32
-    3, // llvm.nvvm.tex.unified.cube.array.v4f32.f32
-    3, // llvm.nvvm.tex.unified.cube.array.v4s32.f32
-    3, // llvm.nvvm.tex.unified.cube.array.v4u32.f32
-    3, // llvm.nvvm.tex.unified.cube.level.v4f32.f32
-    3, // llvm.nvvm.tex.unified.cube.level.v4s32.f32
-    3, // llvm.nvvm.tex.unified.cube.level.v4u32.f32
-    3, // llvm.nvvm.tex.unified.cube.v4f32.f32
-    3, // llvm.nvvm.tex.unified.cube.v4s32.f32
-    3, // llvm.nvvm.tex.unified.cube.v4u32.f32
-    1, // llvm.nvvm.texsurf.handle
-    1, // llvm.nvvm.texsurf.handle.internal
-    3, // llvm.nvvm.tld4.a.2d.v4f32.f32
-    3, // llvm.nvvm.tld4.a.2d.v4s32.f32
-    3, // llvm.nvvm.tld4.a.2d.v4u32.f32
-    3, // llvm.nvvm.tld4.b.2d.v4f32.f32
-    3, // llvm.nvvm.tld4.b.2d.v4s32.f32
-    3, // llvm.nvvm.tld4.b.2d.v4u32.f32
-    3, // llvm.nvvm.tld4.g.2d.v4f32.f32
-    3, // llvm.nvvm.tld4.g.2d.v4s32.f32
-    3, // llvm.nvvm.tld4.g.2d.v4u32.f32
-    3, // llvm.nvvm.tld4.r.2d.v4f32.f32
-    3, // llvm.nvvm.tld4.r.2d.v4s32.f32
-    3, // llvm.nvvm.tld4.r.2d.v4u32.f32
-    3, // llvm.nvvm.tld4.unified.a.2d.v4f32.f32
-    3, // llvm.nvvm.tld4.unified.a.2d.v4s32.f32
-    3, // llvm.nvvm.tld4.unified.a.2d.v4u32.f32
-    3, // llvm.nvvm.tld4.unified.b.2d.v4f32.f32
-    3, // llvm.nvvm.tld4.unified.b.2d.v4s32.f32
-    3, // llvm.nvvm.tld4.unified.b.2d.v4u32.f32
-    3, // llvm.nvvm.tld4.unified.g.2d.v4f32.f32
-    3, // llvm.nvvm.tld4.unified.g.2d.v4s32.f32
-    3, // llvm.nvvm.tld4.unified.g.2d.v4u32.f32
-    3, // llvm.nvvm.tld4.unified.r.2d.v4f32.f32
-    3, // llvm.nvvm.tld4.unified.r.2d.v4s32.f32
-    3, // llvm.nvvm.tld4.unified.r.2d.v4u32.f32
-    1, // llvm.nvvm.trunc.d
-    1, // llvm.nvvm.trunc.f
-    1, // llvm.nvvm.trunc.ftz.f
-    1, // llvm.nvvm.txq.array.size
-    1, // llvm.nvvm.txq.channel.data.type
-    1, // llvm.nvvm.txq.channel.order
-    1, // llvm.nvvm.txq.depth
-    1, // llvm.nvvm.txq.height
-    1, // llvm.nvvm.txq.num.mipmap.levels
-    1, // llvm.nvvm.txq.num.samples
-    1, // llvm.nvvm.txq.width
-    1, // llvm.nvvm.ui2d.rm
-    1, // llvm.nvvm.ui2d.rn
-    1, // llvm.nvvm.ui2d.rp
-    1, // llvm.nvvm.ui2d.rz
-    1, // llvm.nvvm.ui2f.rm
-    1, // llvm.nvvm.ui2f.rn
-    1, // llvm.nvvm.ui2f.rp
-    1, // llvm.nvvm.ui2f.rz
-    1, // llvm.nvvm.ull2d.rm
-    1, // llvm.nvvm.ull2d.rn
-    1, // llvm.nvvm.ull2d.rp
-    1, // llvm.nvvm.ull2d.rz
-    1, // llvm.nvvm.ull2f.rm
-    1, // llvm.nvvm.ull2f.rn
-    1, // llvm.nvvm.ull2f.rp
-    1, // llvm.nvvm.ull2f.rz
-    58, // llvm.nvvm.vote.all
-    58, // llvm.nvvm.vote.all.sync
-    58, // llvm.nvvm.vote.any
-    58, // llvm.nvvm.vote.any.sync
-    58, // llvm.nvvm.vote.ballot
-    58, // llvm.nvvm.vote.ballot.sync
-    58, // llvm.nvvm.vote.uni
-    58, // llvm.nvvm.vote.uni.sync
-    13, // llvm.nvvm.wmma.m16n16k16.load.a.col.f16
-    13, // llvm.nvvm.wmma.m16n16k16.load.a.col.s8
-    13, // llvm.nvvm.wmma.m16n16k16.load.a.col.stride.f16
-    13, // llvm.nvvm.wmma.m16n16k16.load.a.col.stride.s8
-    13, // llvm.nvvm.wmma.m16n16k16.load.a.col.stride.u8
-    13, // llvm.nvvm.wmma.m16n16k16.load.a.col.u8
-    13, // llvm.nvvm.wmma.m16n16k16.load.a.row.f16
-    13, // llvm.nvvm.wmma.m16n16k16.load.a.row.s8
-    13, // llvm.nvvm.wmma.m16n16k16.load.a.row.stride.f16
-    13, // llvm.nvvm.wmma.m16n16k16.load.a.row.stride.s8
-    13, // llvm.nvvm.wmma.m16n16k16.load.a.row.stride.u8
-    13, // llvm.nvvm.wmma.m16n16k16.load.a.row.u8
-    13, // llvm.nvvm.wmma.m16n16k16.load.b.col.f16
-    13, // llvm.nvvm.wmma.m16n16k16.load.b.col.s8
-    13, // llvm.nvvm.wmma.m16n16k16.load.b.col.stride.f16
-    13, // llvm.nvvm.wmma.m16n16k16.load.b.col.stride.s8
-    13, // llvm.nvvm.wmma.m16n16k16.load.b.col.stride.u8
-    13, // llvm.nvvm.wmma.m16n16k16.load.b.col.u8
-    13, // llvm.nvvm.wmma.m16n16k16.load.b.row.f16
-    13, // llvm.nvvm.wmma.m16n16k16.load.b.row.s8
-    13, // llvm.nvvm.wmma.m16n16k16.load.b.row.stride.f16
-    13, // llvm.nvvm.wmma.m16n16k16.load.b.row.stride.s8
-    13, // llvm.nvvm.wmma.m16n16k16.load.b.row.stride.u8
-    13, // llvm.nvvm.wmma.m16n16k16.load.b.row.u8
-    13, // llvm.nvvm.wmma.m16n16k16.load.c.col.f16
-    13, // llvm.nvvm.wmma.m16n16k16.load.c.col.f32
-    13, // llvm.nvvm.wmma.m16n16k16.load.c.col.s32
-    13, // llvm.nvvm.wmma.m16n16k16.load.c.col.stride.f16
-    13, // llvm.nvvm.wmma.m16n16k16.load.c.col.stride.f32
-    13, // llvm.nvvm.wmma.m16n16k16.load.c.col.stride.s32
-    13, // llvm.nvvm.wmma.m16n16k16.load.c.row.f16
-    13, // llvm.nvvm.wmma.m16n16k16.load.c.row.f32
-    13, // llvm.nvvm.wmma.m16n16k16.load.c.row.s32
-    13, // llvm.nvvm.wmma.m16n16k16.load.c.row.stride.f16
-    13, // llvm.nvvm.wmma.m16n16k16.load.c.row.stride.f32
-    13, // llvm.nvvm.wmma.m16n16k16.load.c.row.stride.s32
-    1, // llvm.nvvm.wmma.m16n16k16.mma.col.col.f16.f16
-    1, // llvm.nvvm.wmma.m16n16k16.mma.col.col.f16.f16.satfinite
-    1, // llvm.nvvm.wmma.m16n16k16.mma.col.col.f16.f32
-    1, // llvm.nvvm.wmma.m16n16k16.mma.col.col.f16.f32.satfinite
-    1, // llvm.nvvm.wmma.m16n16k16.mma.col.col.f32.f16
-    1, // llvm.nvvm.wmma.m16n16k16.mma.col.col.f32.f16.satfinite
-    1, // llvm.nvvm.wmma.m16n16k16.mma.col.col.f32.f32
-    1, // llvm.nvvm.wmma.m16n16k16.mma.col.col.f32.f32.satfinite
-    1, // llvm.nvvm.wmma.m16n16k16.mma.col.col.s8
-    1, // llvm.nvvm.wmma.m16n16k16.mma.col.col.s8.satfinite
-    1, // llvm.nvvm.wmma.m16n16k16.mma.col.col.u8
-    1, // llvm.nvvm.wmma.m16n16k16.mma.col.col.u8.satfinite
-    1, // llvm.nvvm.wmma.m16n16k16.mma.col.row.f16.f16
-    1, // llvm.nvvm.wmma.m16n16k16.mma.col.row.f16.f16.satfinite
-    1, // llvm.nvvm.wmma.m16n16k16.mma.col.row.f16.f32
-    1, // llvm.nvvm.wmma.m16n16k16.mma.col.row.f16.f32.satfinite
-    1, // llvm.nvvm.wmma.m16n16k16.mma.col.row.f32.f16
-    1, // llvm.nvvm.wmma.m16n16k16.mma.col.row.f32.f16.satfinite
-    1, // llvm.nvvm.wmma.m16n16k16.mma.col.row.f32.f32
-    1, // llvm.nvvm.wmma.m16n16k16.mma.col.row.f32.f32.satfinite
-    1, // llvm.nvvm.wmma.m16n16k16.mma.col.row.s8
-    1, // llvm.nvvm.wmma.m16n16k16.mma.col.row.s8.satfinite
-    1, // llvm.nvvm.wmma.m16n16k16.mma.col.row.u8
-    1, // llvm.nvvm.wmma.m16n16k16.mma.col.row.u8.satfinite
-    1, // llvm.nvvm.wmma.m16n16k16.mma.row.col.f16.f16
-    1, // llvm.nvvm.wmma.m16n16k16.mma.row.col.f16.f16.satfinite
-    1, // llvm.nvvm.wmma.m16n16k16.mma.row.col.f16.f32
-    1, // llvm.nvvm.wmma.m16n16k16.mma.row.col.f16.f32.satfinite
-    1, // llvm.nvvm.wmma.m16n16k16.mma.row.col.f32.f16
-    1, // llvm.nvvm.wmma.m16n16k16.mma.row.col.f32.f16.satfinite
-    1, // llvm.nvvm.wmma.m16n16k16.mma.row.col.f32.f32
-    1, // llvm.nvvm.wmma.m16n16k16.mma.row.col.f32.f32.satfinite
-    1, // llvm.nvvm.wmma.m16n16k16.mma.row.col.s8
-    1, // llvm.nvvm.wmma.m16n16k16.mma.row.col.s8.satfinite
-    1, // llvm.nvvm.wmma.m16n16k16.mma.row.col.u8
-    1, // llvm.nvvm.wmma.m16n16k16.mma.row.col.u8.satfinite
-    1, // llvm.nvvm.wmma.m16n16k16.mma.row.row.f16.f16
-    1, // llvm.nvvm.wmma.m16n16k16.mma.row.row.f16.f16.satfinite
-    1, // llvm.nvvm.wmma.m16n16k16.mma.row.row.f16.f32
-    1, // llvm.nvvm.wmma.m16n16k16.mma.row.row.f16.f32.satfinite
-    1, // llvm.nvvm.wmma.m16n16k16.mma.row.row.f32.f16
-    1, // llvm.nvvm.wmma.m16n16k16.mma.row.row.f32.f16.satfinite
-    1, // llvm.nvvm.wmma.m16n16k16.mma.row.row.f32.f32
-    1, // llvm.nvvm.wmma.m16n16k16.mma.row.row.f32.f32.satfinite
-    1, // llvm.nvvm.wmma.m16n16k16.mma.row.row.s8
-    1, // llvm.nvvm.wmma.m16n16k16.mma.row.row.s8.satfinite
-    1, // llvm.nvvm.wmma.m16n16k16.mma.row.row.u8
-    1, // llvm.nvvm.wmma.m16n16k16.mma.row.row.u8.satfinite
-    134, // llvm.nvvm.wmma.m16n16k16.store.d.col.f16
-    134, // llvm.nvvm.wmma.m16n16k16.store.d.col.f32
-    134, // llvm.nvvm.wmma.m16n16k16.store.d.col.s32
-    134, // llvm.nvvm.wmma.m16n16k16.store.d.col.stride.f16
-    134, // llvm.nvvm.wmma.m16n16k16.store.d.col.stride.f32
-    134, // llvm.nvvm.wmma.m16n16k16.store.d.col.stride.s32
-    134, // llvm.nvvm.wmma.m16n16k16.store.d.row.f16
-    134, // llvm.nvvm.wmma.m16n16k16.store.d.row.f32
-    134, // llvm.nvvm.wmma.m16n16k16.store.d.row.s32
-    134, // llvm.nvvm.wmma.m16n16k16.store.d.row.stride.f16
-    134, // llvm.nvvm.wmma.m16n16k16.store.d.row.stride.f32
-    134, // llvm.nvvm.wmma.m16n16k16.store.d.row.stride.s32
-    13, // llvm.nvvm.wmma.m32n8k16.load.a.col.f16
-    13, // llvm.nvvm.wmma.m32n8k16.load.a.col.s8
-    13, // llvm.nvvm.wmma.m32n8k16.load.a.col.stride.f16
-    13, // llvm.nvvm.wmma.m32n8k16.load.a.col.stride.s8
-    13, // llvm.nvvm.wmma.m32n8k16.load.a.col.stride.u8
-    13, // llvm.nvvm.wmma.m32n8k16.load.a.col.u8
-    13, // llvm.nvvm.wmma.m32n8k16.load.a.row.f16
-    13, // llvm.nvvm.wmma.m32n8k16.load.a.row.s8
-    13, // llvm.nvvm.wmma.m32n8k16.load.a.row.stride.f16
-    13, // llvm.nvvm.wmma.m32n8k16.load.a.row.stride.s8
-    13, // llvm.nvvm.wmma.m32n8k16.load.a.row.stride.u8
-    13, // llvm.nvvm.wmma.m32n8k16.load.a.row.u8
-    13, // llvm.nvvm.wmma.m32n8k16.load.b.col.f16
-    13, // llvm.nvvm.wmma.m32n8k16.load.b.col.s8
-    13, // llvm.nvvm.wmma.m32n8k16.load.b.col.stride.f16
-    13, // llvm.nvvm.wmma.m32n8k16.load.b.col.stride.s8
-    13, // llvm.nvvm.wmma.m32n8k16.load.b.col.stride.u8
-    13, // llvm.nvvm.wmma.m32n8k16.load.b.col.u8
-    13, // llvm.nvvm.wmma.m32n8k16.load.b.row.f16
-    13, // llvm.nvvm.wmma.m32n8k16.load.b.row.s8
-    13, // llvm.nvvm.wmma.m32n8k16.load.b.row.stride.f16
-    13, // llvm.nvvm.wmma.m32n8k16.load.b.row.stride.s8
-    13, // llvm.nvvm.wmma.m32n8k16.load.b.row.stride.u8
-    13, // llvm.nvvm.wmma.m32n8k16.load.b.row.u8
-    13, // llvm.nvvm.wmma.m32n8k16.load.c.col.f16
-    13, // llvm.nvvm.wmma.m32n8k16.load.c.col.f32
-    13, // llvm.nvvm.wmma.m32n8k16.load.c.col.s32
-    13, // llvm.nvvm.wmma.m32n8k16.load.c.col.stride.f16
-    13, // llvm.nvvm.wmma.m32n8k16.load.c.col.stride.f32
-    13, // llvm.nvvm.wmma.m32n8k16.load.c.col.stride.s32
-    13, // llvm.nvvm.wmma.m32n8k16.load.c.row.f16
-    13, // llvm.nvvm.wmma.m32n8k16.load.c.row.f32
-    13, // llvm.nvvm.wmma.m32n8k16.load.c.row.s32
-    13, // llvm.nvvm.wmma.m32n8k16.load.c.row.stride.f16
-    13, // llvm.nvvm.wmma.m32n8k16.load.c.row.stride.f32
-    13, // llvm.nvvm.wmma.m32n8k16.load.c.row.stride.s32
-    1, // llvm.nvvm.wmma.m32n8k16.mma.col.col.f16.f16
-    1, // llvm.nvvm.wmma.m32n8k16.mma.col.col.f16.f16.satfinite
-    1, // llvm.nvvm.wmma.m32n8k16.mma.col.col.f16.f32
-    1, // llvm.nvvm.wmma.m32n8k16.mma.col.col.f16.f32.satfinite
-    1, // llvm.nvvm.wmma.m32n8k16.mma.col.col.f32.f16
-    1, // llvm.nvvm.wmma.m32n8k16.mma.col.col.f32.f16.satfinite
-    1, // llvm.nvvm.wmma.m32n8k16.mma.col.col.f32.f32
-    1, // llvm.nvvm.wmma.m32n8k16.mma.col.col.f32.f32.satfinite
-    1, // llvm.nvvm.wmma.m32n8k16.mma.col.col.s8
-    1, // llvm.nvvm.wmma.m32n8k16.mma.col.col.s8.satfinite
-    1, // llvm.nvvm.wmma.m32n8k16.mma.col.col.u8
-    1, // llvm.nvvm.wmma.m32n8k16.mma.col.col.u8.satfinite
-    1, // llvm.nvvm.wmma.m32n8k16.mma.col.row.f16.f16
-    1, // llvm.nvvm.wmma.m32n8k16.mma.col.row.f16.f16.satfinite
-    1, // llvm.nvvm.wmma.m32n8k16.mma.col.row.f16.f32
-    1, // llvm.nvvm.wmma.m32n8k16.mma.col.row.f16.f32.satfinite
-    1, // llvm.nvvm.wmma.m32n8k16.mma.col.row.f32.f16
-    1, // llvm.nvvm.wmma.m32n8k16.mma.col.row.f32.f16.satfinite
-    1, // llvm.nvvm.wmma.m32n8k16.mma.col.row.f32.f32
-    1, // llvm.nvvm.wmma.m32n8k16.mma.col.row.f32.f32.satfinite
-    1, // llvm.nvvm.wmma.m32n8k16.mma.col.row.s8
-    1, // llvm.nvvm.wmma.m32n8k16.mma.col.row.s8.satfinite
-    1, // llvm.nvvm.wmma.m32n8k16.mma.col.row.u8
-    1, // llvm.nvvm.wmma.m32n8k16.mma.col.row.u8.satfinite
-    1, // llvm.nvvm.wmma.m32n8k16.mma.row.col.f16.f16
-    1, // llvm.nvvm.wmma.m32n8k16.mma.row.col.f16.f16.satfinite
-    1, // llvm.nvvm.wmma.m32n8k16.mma.row.col.f16.f32
-    1, // llvm.nvvm.wmma.m32n8k16.mma.row.col.f16.f32.satfinite
-    1, // llvm.nvvm.wmma.m32n8k16.mma.row.col.f32.f16
-    1, // llvm.nvvm.wmma.m32n8k16.mma.row.col.f32.f16.satfinite
-    1, // llvm.nvvm.wmma.m32n8k16.mma.row.col.f32.f32
-    1, // llvm.nvvm.wmma.m32n8k16.mma.row.col.f32.f32.satfinite
-    1, // llvm.nvvm.wmma.m32n8k16.mma.row.col.s8
-    1, // llvm.nvvm.wmma.m32n8k16.mma.row.col.s8.satfinite
-    1, // llvm.nvvm.wmma.m32n8k16.mma.row.col.u8
-    1, // llvm.nvvm.wmma.m32n8k16.mma.row.col.u8.satfinite
-    1, // llvm.nvvm.wmma.m32n8k16.mma.row.row.f16.f16
-    1, // llvm.nvvm.wmma.m32n8k16.mma.row.row.f16.f16.satfinite
-    1, // llvm.nvvm.wmma.m32n8k16.mma.row.row.f16.f32
-    1, // llvm.nvvm.wmma.m32n8k16.mma.row.row.f16.f32.satfinite
-    1, // llvm.nvvm.wmma.m32n8k16.mma.row.row.f32.f16
-    1, // llvm.nvvm.wmma.m32n8k16.mma.row.row.f32.f16.satfinite
-    1, // llvm.nvvm.wmma.m32n8k16.mma.row.row.f32.f32
-    1, // llvm.nvvm.wmma.m32n8k16.mma.row.row.f32.f32.satfinite
-    1, // llvm.nvvm.wmma.m32n8k16.mma.row.row.s8
-    1, // llvm.nvvm.wmma.m32n8k16.mma.row.row.s8.satfinite
-    1, // llvm.nvvm.wmma.m32n8k16.mma.row.row.u8
-    1, // llvm.nvvm.wmma.m32n8k16.mma.row.row.u8.satfinite
-    134, // llvm.nvvm.wmma.m32n8k16.store.d.col.f16
-    134, // llvm.nvvm.wmma.m32n8k16.store.d.col.f32
-    134, // llvm.nvvm.wmma.m32n8k16.store.d.col.s32
-    134, // llvm.nvvm.wmma.m32n8k16.store.d.col.stride.f16
-    134, // llvm.nvvm.wmma.m32n8k16.store.d.col.stride.f32
-    134, // llvm.nvvm.wmma.m32n8k16.store.d.col.stride.s32
-    134, // llvm.nvvm.wmma.m32n8k16.store.d.row.f16
-    134, // llvm.nvvm.wmma.m32n8k16.store.d.row.f32
-    134, // llvm.nvvm.wmma.m32n8k16.store.d.row.s32
-    134, // llvm.nvvm.wmma.m32n8k16.store.d.row.stride.f16
-    134, // llvm.nvvm.wmma.m32n8k16.store.d.row.stride.f32
-    134, // llvm.nvvm.wmma.m32n8k16.store.d.row.stride.s32
-    13, // llvm.nvvm.wmma.m8n32k16.load.a.col.f16
-    13, // llvm.nvvm.wmma.m8n32k16.load.a.col.s8
-    13, // llvm.nvvm.wmma.m8n32k16.load.a.col.stride.f16
-    13, // llvm.nvvm.wmma.m8n32k16.load.a.col.stride.s8
-    13, // llvm.nvvm.wmma.m8n32k16.load.a.col.stride.u8
-    13, // llvm.nvvm.wmma.m8n32k16.load.a.col.u8
-    13, // llvm.nvvm.wmma.m8n32k16.load.a.row.f16
-    13, // llvm.nvvm.wmma.m8n32k16.load.a.row.s8
-    13, // llvm.nvvm.wmma.m8n32k16.load.a.row.stride.f16
-    13, // llvm.nvvm.wmma.m8n32k16.load.a.row.stride.s8
-    13, // llvm.nvvm.wmma.m8n32k16.load.a.row.stride.u8
-    13, // llvm.nvvm.wmma.m8n32k16.load.a.row.u8
-    13, // llvm.nvvm.wmma.m8n32k16.load.b.col.f16
-    13, // llvm.nvvm.wmma.m8n32k16.load.b.col.s8
-    13, // llvm.nvvm.wmma.m8n32k16.load.b.col.stride.f16
-    13, // llvm.nvvm.wmma.m8n32k16.load.b.col.stride.s8
-    13, // llvm.nvvm.wmma.m8n32k16.load.b.col.stride.u8
-    13, // llvm.nvvm.wmma.m8n32k16.load.b.col.u8
-    13, // llvm.nvvm.wmma.m8n32k16.load.b.row.f16
-    13, // llvm.nvvm.wmma.m8n32k16.load.b.row.s8
-    13, // llvm.nvvm.wmma.m8n32k16.load.b.row.stride.f16
-    13, // llvm.nvvm.wmma.m8n32k16.load.b.row.stride.s8
-    13, // llvm.nvvm.wmma.m8n32k16.load.b.row.stride.u8
-    13, // llvm.nvvm.wmma.m8n32k16.load.b.row.u8
-    13, // llvm.nvvm.wmma.m8n32k16.load.c.col.f16
-    13, // llvm.nvvm.wmma.m8n32k16.load.c.col.f32
-    13, // llvm.nvvm.wmma.m8n32k16.load.c.col.s32
-    13, // llvm.nvvm.wmma.m8n32k16.load.c.col.stride.f16
-    13, // llvm.nvvm.wmma.m8n32k16.load.c.col.stride.f32
-    13, // llvm.nvvm.wmma.m8n32k16.load.c.col.stride.s32
-    13, // llvm.nvvm.wmma.m8n32k16.load.c.row.f16
-    13, // llvm.nvvm.wmma.m8n32k16.load.c.row.f32
-    13, // llvm.nvvm.wmma.m8n32k16.load.c.row.s32
-    13, // llvm.nvvm.wmma.m8n32k16.load.c.row.stride.f16
-    13, // llvm.nvvm.wmma.m8n32k16.load.c.row.stride.f32
-    13, // llvm.nvvm.wmma.m8n32k16.load.c.row.stride.s32
-    1, // llvm.nvvm.wmma.m8n32k16.mma.col.col.f16.f16
-    1, // llvm.nvvm.wmma.m8n32k16.mma.col.col.f16.f16.satfinite
-    1, // llvm.nvvm.wmma.m8n32k16.mma.col.col.f16.f32
-    1, // llvm.nvvm.wmma.m8n32k16.mma.col.col.f16.f32.satfinite
-    1, // llvm.nvvm.wmma.m8n32k16.mma.col.col.f32.f16
-    1, // llvm.nvvm.wmma.m8n32k16.mma.col.col.f32.f16.satfinite
-    1, // llvm.nvvm.wmma.m8n32k16.mma.col.col.f32.f32
-    1, // llvm.nvvm.wmma.m8n32k16.mma.col.col.f32.f32.satfinite
-    1, // llvm.nvvm.wmma.m8n32k16.mma.col.col.s8
-    1, // llvm.nvvm.wmma.m8n32k16.mma.col.col.s8.satfinite
-    1, // llvm.nvvm.wmma.m8n32k16.mma.col.col.u8
-    1, // llvm.nvvm.wmma.m8n32k16.mma.col.col.u8.satfinite
-    1, // llvm.nvvm.wmma.m8n32k16.mma.col.row.f16.f16
-    1, // llvm.nvvm.wmma.m8n32k16.mma.col.row.f16.f16.satfinite
-    1, // llvm.nvvm.wmma.m8n32k16.mma.col.row.f16.f32
-    1, // llvm.nvvm.wmma.m8n32k16.mma.col.row.f16.f32.satfinite
-    1, // llvm.nvvm.wmma.m8n32k16.mma.col.row.f32.f16
-    1, // llvm.nvvm.wmma.m8n32k16.mma.col.row.f32.f16.satfinite
-    1, // llvm.nvvm.wmma.m8n32k16.mma.col.row.f32.f32
-    1, // llvm.nvvm.wmma.m8n32k16.mma.col.row.f32.f32.satfinite
-    1, // llvm.nvvm.wmma.m8n32k16.mma.col.row.s8
-    1, // llvm.nvvm.wmma.m8n32k16.mma.col.row.s8.satfinite
-    1, // llvm.nvvm.wmma.m8n32k16.mma.col.row.u8
-    1, // llvm.nvvm.wmma.m8n32k16.mma.col.row.u8.satfinite
-    1, // llvm.nvvm.wmma.m8n32k16.mma.row.col.f16.f16
-    1, // llvm.nvvm.wmma.m8n32k16.mma.row.col.f16.f16.satfinite
-    1, // llvm.nvvm.wmma.m8n32k16.mma.row.col.f16.f32
-    1, // llvm.nvvm.wmma.m8n32k16.mma.row.col.f16.f32.satfinite
-    1, // llvm.nvvm.wmma.m8n32k16.mma.row.col.f32.f16
-    1, // llvm.nvvm.wmma.m8n32k16.mma.row.col.f32.f16.satfinite
-    1, // llvm.nvvm.wmma.m8n32k16.mma.row.col.f32.f32
-    1, // llvm.nvvm.wmma.m8n32k16.mma.row.col.f32.f32.satfinite
-    1, // llvm.nvvm.wmma.m8n32k16.mma.row.col.s8
-    1, // llvm.nvvm.wmma.m8n32k16.mma.row.col.s8.satfinite
-    1, // llvm.nvvm.wmma.m8n32k16.mma.row.col.u8
-    1, // llvm.nvvm.wmma.m8n32k16.mma.row.col.u8.satfinite
-    1, // llvm.nvvm.wmma.m8n32k16.mma.row.row.f16.f16
-    1, // llvm.nvvm.wmma.m8n32k16.mma.row.row.f16.f16.satfinite
-    1, // llvm.nvvm.wmma.m8n32k16.mma.row.row.f16.f32
-    1, // llvm.nvvm.wmma.m8n32k16.mma.row.row.f16.f32.satfinite
-    1, // llvm.nvvm.wmma.m8n32k16.mma.row.row.f32.f16
-    1, // llvm.nvvm.wmma.m8n32k16.mma.row.row.f32.f16.satfinite
-    1, // llvm.nvvm.wmma.m8n32k16.mma.row.row.f32.f32
-    1, // llvm.nvvm.wmma.m8n32k16.mma.row.row.f32.f32.satfinite
-    1, // llvm.nvvm.wmma.m8n32k16.mma.row.row.s8
-    1, // llvm.nvvm.wmma.m8n32k16.mma.row.row.s8.satfinite
-    1, // llvm.nvvm.wmma.m8n32k16.mma.row.row.u8
-    1, // llvm.nvvm.wmma.m8n32k16.mma.row.row.u8.satfinite
-    134, // llvm.nvvm.wmma.m8n32k16.store.d.col.f16
-    134, // llvm.nvvm.wmma.m8n32k16.store.d.col.f32
-    134, // llvm.nvvm.wmma.m8n32k16.store.d.col.s32
-    134, // llvm.nvvm.wmma.m8n32k16.store.d.col.stride.f16
-    134, // llvm.nvvm.wmma.m8n32k16.store.d.col.stride.f32
-    134, // llvm.nvvm.wmma.m8n32k16.store.d.col.stride.s32
-    134, // llvm.nvvm.wmma.m8n32k16.store.d.row.f16
-    134, // llvm.nvvm.wmma.m8n32k16.store.d.row.f32
-    134, // llvm.nvvm.wmma.m8n32k16.store.d.row.s32
-    134, // llvm.nvvm.wmma.m8n32k16.store.d.row.stride.f16
-    134, // llvm.nvvm.wmma.m8n32k16.store.d.row.stride.f32
-    134, // llvm.nvvm.wmma.m8n32k16.store.d.row.stride.s32
-    13, // llvm.nvvm.wmma.m8n8k128.load.a.row.b1
-    13, // llvm.nvvm.wmma.m8n8k128.load.a.row.stride.b1
-    13, // llvm.nvvm.wmma.m8n8k128.load.b.col.b1
-    13, // llvm.nvvm.wmma.m8n8k128.load.b.col.stride.b1
-    13, // llvm.nvvm.wmma.m8n8k128.load.c.col.s32
-    13, // llvm.nvvm.wmma.m8n8k128.load.c.col.stride.s32
-    13, // llvm.nvvm.wmma.m8n8k128.load.c.row.s32
-    13, // llvm.nvvm.wmma.m8n8k128.load.c.row.stride.s32
-    1, // llvm.nvvm.wmma.m8n8k128.mma.row.col.b1
-    134, // llvm.nvvm.wmma.m8n8k128.store.d.col.s32
-    134, // llvm.nvvm.wmma.m8n8k128.store.d.col.stride.s32
-    134, // llvm.nvvm.wmma.m8n8k128.store.d.row.s32
-    134, // llvm.nvvm.wmma.m8n8k128.store.d.row.stride.s32
-    13, // llvm.nvvm.wmma.m8n8k32.load.a.row.s4
-    13, // llvm.nvvm.wmma.m8n8k32.load.a.row.stride.s4
-    13, // llvm.nvvm.wmma.m8n8k32.load.a.row.stride.u4
-    13, // llvm.nvvm.wmma.m8n8k32.load.a.row.u4
-    13, // llvm.nvvm.wmma.m8n8k32.load.b.col.s4
-    13, // llvm.nvvm.wmma.m8n8k32.load.b.col.stride.s4
-    13, // llvm.nvvm.wmma.m8n8k32.load.b.col.stride.u4
-    13, // llvm.nvvm.wmma.m8n8k32.load.b.col.u4
-    13, // llvm.nvvm.wmma.m8n8k32.load.c.col.s32
-    13, // llvm.nvvm.wmma.m8n8k32.load.c.col.stride.s32
-    13, // llvm.nvvm.wmma.m8n8k32.load.c.row.s32
-    13, // llvm.nvvm.wmma.m8n8k32.load.c.row.stride.s32
-    1, // llvm.nvvm.wmma.m8n8k32.mma.row.col.s4
-    1, // llvm.nvvm.wmma.m8n8k32.mma.row.col.s4.satfinite
-    1, // llvm.nvvm.wmma.m8n8k32.mma.row.col.u4
-    1, // llvm.nvvm.wmma.m8n8k32.mma.row.col.u4.satfinite
-    134, // llvm.nvvm.wmma.m8n8k32.store.d.col.s32
-    134, // llvm.nvvm.wmma.m8n8k32.store.d.col.stride.s32
-    134, // llvm.nvvm.wmma.m8n8k32.store.d.row.s32
-    134, // llvm.nvvm.wmma.m8n8k32.store.d.row.stride.s32
-    1, // llvm.ppc.addf128.round.to.odd
-    1, // llvm.ppc.altivec.crypto.vcipher
-    1, // llvm.ppc.altivec.crypto.vcipherlast
-    1, // llvm.ppc.altivec.crypto.vncipher
-    1, // llvm.ppc.altivec.crypto.vncipherlast
-    1, // llvm.ppc.altivec.crypto.vpermxor
-    1, // llvm.ppc.altivec.crypto.vpmsumb
-    1, // llvm.ppc.altivec.crypto.vpmsumd
-    1, // llvm.ppc.altivec.crypto.vpmsumh
-    1, // llvm.ppc.altivec.crypto.vpmsumw
-    1, // llvm.ppc.altivec.crypto.vsbox
-    39, // llvm.ppc.altivec.crypto.vshasigmad
-    39, // llvm.ppc.altivec.crypto.vshasigmaw
-    3, // llvm.ppc.altivec.dss
-    3, // llvm.ppc.altivec.dssall
-    3, // llvm.ppc.altivec.dst
-    3, // llvm.ppc.altivec.dstst
-    3, // llvm.ppc.altivec.dststt
-    3, // llvm.ppc.altivec.dstt
-    2, // llvm.ppc.altivec.lvebx
-    2, // llvm.ppc.altivec.lvehx
-    2, // llvm.ppc.altivec.lvewx
-    1, // llvm.ppc.altivec.lvsl
-    1, // llvm.ppc.altivec.lvsr
-    2, // llvm.ppc.altivec.lvx
-    2, // llvm.ppc.altivec.lvxl
-    18, // llvm.ppc.altivec.mfvscr
-    3, // llvm.ppc.altivec.mtvscr
-    135, // llvm.ppc.altivec.stvebx
-    135, // llvm.ppc.altivec.stvehx
-    135, // llvm.ppc.altivec.stvewx
-    135, // llvm.ppc.altivec.stvx
-    135, // llvm.ppc.altivec.stvxl
-    1, // llvm.ppc.altivec.vabsdub
-    1, // llvm.ppc.altivec.vabsduh
-    1, // llvm.ppc.altivec.vabsduw
-    1, // llvm.ppc.altivec.vaddcuq
-    1, // llvm.ppc.altivec.vaddcuw
-    1, // llvm.ppc.altivec.vaddecuq
-    1, // llvm.ppc.altivec.vaddeuqm
-    1, // llvm.ppc.altivec.vaddsbs
-    1, // llvm.ppc.altivec.vaddshs
-    1, // llvm.ppc.altivec.vaddsws
-    1, // llvm.ppc.altivec.vaddubs
-    1, // llvm.ppc.altivec.vadduhs
-    1, // llvm.ppc.altivec.vadduws
-    1, // llvm.ppc.altivec.vavgsb
-    1, // llvm.ppc.altivec.vavgsh
-    1, // llvm.ppc.altivec.vavgsw
-    1, // llvm.ppc.altivec.vavgub
-    1, // llvm.ppc.altivec.vavguh
-    1, // llvm.ppc.altivec.vavguw
-    1, // llvm.ppc.altivec.vbpermq
-    40, // llvm.ppc.altivec.vcfsx
-    40, // llvm.ppc.altivec.vcfux
-    1, // llvm.ppc.altivec.vclzlsbb
-    1, // llvm.ppc.altivec.vcmpbfp
-    1, // llvm.ppc.altivec.vcmpbfp.p
-    1, // llvm.ppc.altivec.vcmpeqfp
-    1, // llvm.ppc.altivec.vcmpeqfp.p
-    1, // llvm.ppc.altivec.vcmpequb
-    1, // llvm.ppc.altivec.vcmpequb.p
-    1, // llvm.ppc.altivec.vcmpequd
-    1, // llvm.ppc.altivec.vcmpequd.p
-    1, // llvm.ppc.altivec.vcmpequh
-    1, // llvm.ppc.altivec.vcmpequh.p
-    1, // llvm.ppc.altivec.vcmpequw
-    1, // llvm.ppc.altivec.vcmpequw.p
-    1, // llvm.ppc.altivec.vcmpgefp
-    1, // llvm.ppc.altivec.vcmpgefp.p
-    1, // llvm.ppc.altivec.vcmpgtfp
-    1, // llvm.ppc.altivec.vcmpgtfp.p
-    1, // llvm.ppc.altivec.vcmpgtsb
-    1, // llvm.ppc.altivec.vcmpgtsb.p
-    1, // llvm.ppc.altivec.vcmpgtsd
-    1, // llvm.ppc.altivec.vcmpgtsd.p
-    1, // llvm.ppc.altivec.vcmpgtsh
-    1, // llvm.ppc.altivec.vcmpgtsh.p
-    1, // llvm.ppc.altivec.vcmpgtsw
-    1, // llvm.ppc.altivec.vcmpgtsw.p
-    1, // llvm.ppc.altivec.vcmpgtub
-    1, // llvm.ppc.altivec.vcmpgtub.p
-    1, // llvm.ppc.altivec.vcmpgtud
-    1, // llvm.ppc.altivec.vcmpgtud.p
-    1, // llvm.ppc.altivec.vcmpgtuh
-    1, // llvm.ppc.altivec.vcmpgtuh.p
-    1, // llvm.ppc.altivec.vcmpgtuw
-    1, // llvm.ppc.altivec.vcmpgtuw.p
-    1, // llvm.ppc.altivec.vcmpneb
-    1, // llvm.ppc.altivec.vcmpneb.p
-    1, // llvm.ppc.altivec.vcmpneh
-    1, // llvm.ppc.altivec.vcmpneh.p
-    1, // llvm.ppc.altivec.vcmpnew
-    1, // llvm.ppc.altivec.vcmpnew.p
-    1, // llvm.ppc.altivec.vcmpnezb
-    1, // llvm.ppc.altivec.vcmpnezb.p
-    1, // llvm.ppc.altivec.vcmpnezh
-    1, // llvm.ppc.altivec.vcmpnezh.p
-    1, // llvm.ppc.altivec.vcmpnezw
-    1, // llvm.ppc.altivec.vcmpnezw.p
-    40, // llvm.ppc.altivec.vctsxs
-    40, // llvm.ppc.altivec.vctuxs
-    1, // llvm.ppc.altivec.vctzlsbb
-    1, // llvm.ppc.altivec.vexptefp
-    1, // llvm.ppc.altivec.vgbbd
-    1, // llvm.ppc.altivec.vlogefp
-    1, // llvm.ppc.altivec.vmaddfp
-    1, // llvm.ppc.altivec.vmaxfp
-    1, // llvm.ppc.altivec.vmaxsb
-    1, // llvm.ppc.altivec.vmaxsd
-    1, // llvm.ppc.altivec.vmaxsh
-    1, // llvm.ppc.altivec.vmaxsw
-    1, // llvm.ppc.altivec.vmaxub
-    1, // llvm.ppc.altivec.vmaxud
-    1, // llvm.ppc.altivec.vmaxuh
-    1, // llvm.ppc.altivec.vmaxuw
-    1, // llvm.ppc.altivec.vmhaddshs
-    1, // llvm.ppc.altivec.vmhraddshs
-    1, // llvm.ppc.altivec.vminfp
-    1, // llvm.ppc.altivec.vminsb
-    1, // llvm.ppc.altivec.vminsd
-    1, // llvm.ppc.altivec.vminsh
-    1, // llvm.ppc.altivec.vminsw
-    1, // llvm.ppc.altivec.vminub
-    1, // llvm.ppc.altivec.vminud
-    1, // llvm.ppc.altivec.vminuh
-    1, // llvm.ppc.altivec.vminuw
-    1, // llvm.ppc.altivec.vmladduhm
-    1, // llvm.ppc.altivec.vmsummbm
-    1, // llvm.ppc.altivec.vmsumshm
-    1, // llvm.ppc.altivec.vmsumshs
-    1, // llvm.ppc.altivec.vmsumubm
-    1, // llvm.ppc.altivec.vmsumuhm
-    1, // llvm.ppc.altivec.vmsumuhs
-    1, // llvm.ppc.altivec.vmulesb
-    1, // llvm.ppc.altivec.vmulesh
-    1, // llvm.ppc.altivec.vmulesw
-    1, // llvm.ppc.altivec.vmuleub
-    1, // llvm.ppc.altivec.vmuleuh
-    1, // llvm.ppc.altivec.vmuleuw
-    1, // llvm.ppc.altivec.vmulosb
-    1, // llvm.ppc.altivec.vmulosh
-    1, // llvm.ppc.altivec.vmulosw
-    1, // llvm.ppc.altivec.vmuloub
-    1, // llvm.ppc.altivec.vmulouh
-    1, // llvm.ppc.altivec.vmulouw
-    1, // llvm.ppc.altivec.vnmsubfp
-    1, // llvm.ppc.altivec.vperm
-    1, // llvm.ppc.altivec.vpkpx
-    1, // llvm.ppc.altivec.vpksdss
-    1, // llvm.ppc.altivec.vpksdus
-    1, // llvm.ppc.altivec.vpkshss
-    1, // llvm.ppc.altivec.vpkshus
-    1, // llvm.ppc.altivec.vpkswss
-    1, // llvm.ppc.altivec.vpkswus
-    1, // llvm.ppc.altivec.vpkudus
-    1, // llvm.ppc.altivec.vpkuhus
-    1, // llvm.ppc.altivec.vpkuwus
-    1, // llvm.ppc.altivec.vprtybd
-    1, // llvm.ppc.altivec.vprtybq
-    1, // llvm.ppc.altivec.vprtybw
-    1, // llvm.ppc.altivec.vrefp
-    1, // llvm.ppc.altivec.vrfim
-    1, // llvm.ppc.altivec.vrfin
-    1, // llvm.ppc.altivec.vrfip
-    1, // llvm.ppc.altivec.vrfiz
-    1, // llvm.ppc.altivec.vrlb
-    1, // llvm.ppc.altivec.vrld
-    1, // llvm.ppc.altivec.vrldmi
-    1, // llvm.ppc.altivec.vrldnm
-    1, // llvm.ppc.altivec.vrlh
-    1, // llvm.ppc.altivec.vrlw
-    1, // llvm.ppc.altivec.vrlwmi
-    1, // llvm.ppc.altivec.vrlwnm
-    1, // llvm.ppc.altivec.vrsqrtefp
-    1, // llvm.ppc.altivec.vsel
-    1, // llvm.ppc.altivec.vsl
-    1, // llvm.ppc.altivec.vslb
-    1, // llvm.ppc.altivec.vslh
-    1, // llvm.ppc.altivec.vslo
-    1, // llvm.ppc.altivec.vslv
-    1, // llvm.ppc.altivec.vslw
-    1, // llvm.ppc.altivec.vsr
-    1, // llvm.ppc.altivec.vsrab
-    1, // llvm.ppc.altivec.vsrah
-    1, // llvm.ppc.altivec.vsraw
-    1, // llvm.ppc.altivec.vsrb
-    1, // llvm.ppc.altivec.vsrh
-    1, // llvm.ppc.altivec.vsro
-    1, // llvm.ppc.altivec.vsrv
-    1, // llvm.ppc.altivec.vsrw
-    1, // llvm.ppc.altivec.vsubcuq
-    1, // llvm.ppc.altivec.vsubcuw
-    1, // llvm.ppc.altivec.vsubecuq
-    1, // llvm.ppc.altivec.vsubeuqm
-    1, // llvm.ppc.altivec.vsubsbs
-    1, // llvm.ppc.altivec.vsubshs
-    1, // llvm.ppc.altivec.vsubsws
-    1, // llvm.ppc.altivec.vsububs
-    1, // llvm.ppc.altivec.vsubuhs
-    1, // llvm.ppc.altivec.vsubuws
-    1, // llvm.ppc.altivec.vsum2sws
-    1, // llvm.ppc.altivec.vsum4sbs
-    1, // llvm.ppc.altivec.vsum4shs
-    1, // llvm.ppc.altivec.vsum4ubs
-    1, // llvm.ppc.altivec.vsumsws
-    1, // llvm.ppc.altivec.vupkhpx
-    1, // llvm.ppc.altivec.vupkhsb
-    1, // llvm.ppc.altivec.vupkhsh
-    1, // llvm.ppc.altivec.vupkhsw
-    1, // llvm.ppc.altivec.vupklpx
-    1, // llvm.ppc.altivec.vupklsb
-    1, // llvm.ppc.altivec.vupklsh
-    1, // llvm.ppc.altivec.vupklsw
-    1, // llvm.ppc.bpermd
-    3, // llvm.ppc.cfence
-    3, // llvm.ppc.dcba
-    3, // llvm.ppc.dcbf
-    3, // llvm.ppc.dcbi
-    3, // llvm.ppc.dcbst
-    23, // llvm.ppc.dcbt
-    23, // llvm.ppc.dcbtst
-    3, // llvm.ppc.dcbz
-    3, // llvm.ppc.dcbzl
-    1, // llvm.ppc.divde
-    1, // llvm.ppc.divdeu
-    1, // llvm.ppc.divf128.round.to.odd
-    1, // llvm.ppc.divwe
-    1, // llvm.ppc.divweu
-    1, // llvm.ppc.fmaf128.round.to.odd
-    3, // llvm.ppc.get.texasr
-    3, // llvm.ppc.get.texasru
-    3, // llvm.ppc.get.tfhar
-    3, // llvm.ppc.get.tfiar
-    28, // llvm.ppc.is.decremented.ctr.nonzero
-    3, // llvm.ppc.lwsync
-    3, // llvm.ppc.mtctr
-    1, // llvm.ppc.mulf128.round.to.odd
-    1, // llvm.ppc.qpx.qvfabs
-    1, // llvm.ppc.qpx.qvfadd
-    1, // llvm.ppc.qpx.qvfadds
-    1, // llvm.ppc.qpx.qvfcfid
-    1, // llvm.ppc.qpx.qvfcfids
-    1, // llvm.ppc.qpx.qvfcfidu
-    1, // llvm.ppc.qpx.qvfcfidus
-    1, // llvm.ppc.qpx.qvfcmpeq
-    1, // llvm.ppc.qpx.qvfcmpgt
-    1, // llvm.ppc.qpx.qvfcmplt
-    1, // llvm.ppc.qpx.qvfcpsgn
-    1, // llvm.ppc.qpx.qvfctid
-    1, // llvm.ppc.qpx.qvfctidu
-    1, // llvm.ppc.qpx.qvfctiduz
-    1, // llvm.ppc.qpx.qvfctidz
-    1, // llvm.ppc.qpx.qvfctiw
-    1, // llvm.ppc.qpx.qvfctiwu
-    1, // llvm.ppc.qpx.qvfctiwuz
-    1, // llvm.ppc.qpx.qvfctiwz
-    1, // llvm.ppc.qpx.qvflogical
-    1, // llvm.ppc.qpx.qvfmadd
-    1, // llvm.ppc.qpx.qvfmadds
-    1, // llvm.ppc.qpx.qvfmsub
-    1, // llvm.ppc.qpx.qvfmsubs
-    1, // llvm.ppc.qpx.qvfmul
-    1, // llvm.ppc.qpx.qvfmuls
-    1, // llvm.ppc.qpx.qvfnabs
-    1, // llvm.ppc.qpx.qvfneg
-    1, // llvm.ppc.qpx.qvfnmadd
-    1, // llvm.ppc.qpx.qvfnmadds
-    1, // llvm.ppc.qpx.qvfnmsub
-    1, // llvm.ppc.qpx.qvfnmsubs
-    1, // llvm.ppc.qpx.qvfperm
-    1, // llvm.ppc.qpx.qvfre
-    1, // llvm.ppc.qpx.qvfres
-    1, // llvm.ppc.qpx.qvfrim
-    1, // llvm.ppc.qpx.qvfrin
-    1, // llvm.ppc.qpx.qvfrip
-    1, // llvm.ppc.qpx.qvfriz
-    1, // llvm.ppc.qpx.qvfrsp
-    1, // llvm.ppc.qpx.qvfrsqrte
-    1, // llvm.ppc.qpx.qvfrsqrtes
-    1, // llvm.ppc.qpx.qvfsel
-    1, // llvm.ppc.qpx.qvfsub
-    1, // llvm.ppc.qpx.qvfsubs
-    1, // llvm.ppc.qpx.qvftstnan
-    1, // llvm.ppc.qpx.qvfxmadd
-    1, // llvm.ppc.qpx.qvfxmadds
-    1, // llvm.ppc.qpx.qvfxmul
-    1, // llvm.ppc.qpx.qvfxmuls
-    1, // llvm.ppc.qpx.qvfxxcpnmadd
-    1, // llvm.ppc.qpx.qvfxxcpnmadds
-    1, // llvm.ppc.qpx.qvfxxmadd
-    1, // llvm.ppc.qpx.qvfxxmadds
-    1, // llvm.ppc.qpx.qvfxxnpmadd
-    1, // llvm.ppc.qpx.qvfxxnpmadds
-    1, // llvm.ppc.qpx.qvgpci
-    2, // llvm.ppc.qpx.qvlfcd
-    2, // llvm.ppc.qpx.qvlfcda
-    2, // llvm.ppc.qpx.qvlfcs
-    2, // llvm.ppc.qpx.qvlfcsa
-    2, // llvm.ppc.qpx.qvlfd
-    2, // llvm.ppc.qpx.qvlfda
-    2, // llvm.ppc.qpx.qvlfiwa
-    2, // llvm.ppc.qpx.qvlfiwaa
-    2, // llvm.ppc.qpx.qvlfiwz
-    2, // llvm.ppc.qpx.qvlfiwza
-    2, // llvm.ppc.qpx.qvlfs
-    2, // llvm.ppc.qpx.qvlfsa
-    1, // llvm.ppc.qpx.qvlpcld
-    1, // llvm.ppc.qpx.qvlpcls
-    1, // llvm.ppc.qpx.qvlpcrd
-    1, // llvm.ppc.qpx.qvlpcrs
-    135, // llvm.ppc.qpx.qvstfcd
-    135, // llvm.ppc.qpx.qvstfcda
-    135, // llvm.ppc.qpx.qvstfcs
-    135, // llvm.ppc.qpx.qvstfcsa
-    135, // llvm.ppc.qpx.qvstfd
-    135, // llvm.ppc.qpx.qvstfda
-    135, // llvm.ppc.qpx.qvstfiw
-    135, // llvm.ppc.qpx.qvstfiwa
-    135, // llvm.ppc.qpx.qvstfs
-    135, // llvm.ppc.qpx.qvstfsa
-    1, // llvm.ppc.scalar.extract.expq
-    1, // llvm.ppc.scalar.insert.exp.qp
-    3, // llvm.ppc.set.texasr
-    3, // llvm.ppc.set.texasru
-    3, // llvm.ppc.set.tfhar
-    3, // llvm.ppc.set.tfiar
-    3, // llvm.ppc.setrnd
-    1, // llvm.ppc.sqrtf128.round.to.odd
-    1, // llvm.ppc.subf128.round.to.odd
-    3, // llvm.ppc.sync
-    3, // llvm.ppc.tabort
-    3, // llvm.ppc.tabortdc
-    3, // llvm.ppc.tabortdci
-    3, // llvm.ppc.tabortwc
-    3, // llvm.ppc.tabortwci
-    101, // llvm.ppc.tbegin
-    3, // llvm.ppc.tcheck
-    101, // llvm.ppc.tend
-    3, // llvm.ppc.tendall
-    3, // llvm.ppc.trechkpt
-    3, // llvm.ppc.treclaim
-    3, // llvm.ppc.tresume
-    1, // llvm.ppc.truncf128.round.to.odd
-    3, // llvm.ppc.tsr
-    3, // llvm.ppc.tsuspend
-    3, // llvm.ppc.ttest
-    2, // llvm.ppc.vsx.lxvd2x
-    2, // llvm.ppc.vsx.lxvd2x.be
-    2, // llvm.ppc.vsx.lxvl
-    2, // llvm.ppc.vsx.lxvll
-    2, // llvm.ppc.vsx.lxvw4x
-    2, // llvm.ppc.vsx.lxvw4x.be
-    135, // llvm.ppc.vsx.stxvd2x
-    135, // llvm.ppc.vsx.stxvd2x.be
-    135, // llvm.ppc.vsx.stxvl
-    135, // llvm.ppc.vsx.stxvll
-    135, // llvm.ppc.vsx.stxvw4x
-    135, // llvm.ppc.vsx.stxvw4x.be
-    1, // llvm.ppc.vsx.xsmaxdp
-    1, // llvm.ppc.vsx.xsmindp
-    1, // llvm.ppc.vsx.xvcmpeqdp
-    1, // llvm.ppc.vsx.xvcmpeqdp.p
-    1, // llvm.ppc.vsx.xvcmpeqsp
-    1, // llvm.ppc.vsx.xvcmpeqsp.p
-    1, // llvm.ppc.vsx.xvcmpgedp
-    1, // llvm.ppc.vsx.xvcmpgedp.p
-    1, // llvm.ppc.vsx.xvcmpgesp
-    1, // llvm.ppc.vsx.xvcmpgesp.p
-    1, // llvm.ppc.vsx.xvcmpgtdp
-    1, // llvm.ppc.vsx.xvcmpgtdp.p
-    1, // llvm.ppc.vsx.xvcmpgtsp
-    1, // llvm.ppc.vsx.xvcmpgtsp.p
-    1, // llvm.ppc.vsx.xvcvdpsp
-    1, // llvm.ppc.vsx.xvcvdpsxws
-    1, // llvm.ppc.vsx.xvcvdpuxws
-    1, // llvm.ppc.vsx.xvcvhpsp
-    1, // llvm.ppc.vsx.xvcvspdp
-    1, // llvm.ppc.vsx.xvcvsphp
-    1, // llvm.ppc.vsx.xvcvsxdsp
-    1, // llvm.ppc.vsx.xvcvsxwdp
-    1, // llvm.ppc.vsx.xvcvuxdsp
-    1, // llvm.ppc.vsx.xvcvuxwdp
-    1, // llvm.ppc.vsx.xvdivdp
-    1, // llvm.ppc.vsx.xvdivsp
-    1, // llvm.ppc.vsx.xviexpdp
-    1, // llvm.ppc.vsx.xviexpsp
-    1, // llvm.ppc.vsx.xvmaxdp
-    1, // llvm.ppc.vsx.xvmaxsp
-    1, // llvm.ppc.vsx.xvmindp
-    1, // llvm.ppc.vsx.xvminsp
-    1, // llvm.ppc.vsx.xvrdpip
-    1, // llvm.ppc.vsx.xvredp
-    1, // llvm.ppc.vsx.xvresp
-    1, // llvm.ppc.vsx.xvrspip
-    1, // llvm.ppc.vsx.xvrsqrtedp
-    1, // llvm.ppc.vsx.xvrsqrtesp
-    40, // llvm.ppc.vsx.xvtstdcdp
-    40, // llvm.ppc.vsx.xvtstdcsp
-    1, // llvm.ppc.vsx.xvxexpdp
-    1, // llvm.ppc.vsx.xvxexpsp
-    1, // llvm.ppc.vsx.xvxsigdp
-    1, // llvm.ppc.vsx.xvxsigsp
-    1, // llvm.ppc.vsx.xxextractuw
-    1, // llvm.ppc.vsx.xxinsertw
-    1, // llvm.ppc.vsx.xxleqv
-    4, // llvm.r600.cube
-    1, // llvm.r600.ddx
-    1, // llvm.r600.ddy
-    4, // llvm.r600.dot4
-    62, // llvm.r600.group.barrier
-    4, // llvm.r600.implicitarg.ptr
-    3, // llvm.r600.kill
-    3, // llvm.r600.rat.store.typed
-    4, // llvm.r600.read.global.size.x
-    4, // llvm.r600.read.global.size.y
-    4, // llvm.r600.read.global.size.z
-    4, // llvm.r600.read.local.size.x
-    4, // llvm.r600.read.local.size.y
-    4, // llvm.r600.read.local.size.z
-    4, // llvm.r600.read.ngroups.x
-    4, // llvm.r600.read.ngroups.y
-    4, // llvm.r600.read.ngroups.z
-    4, // llvm.r600.read.tgid.x
-    4, // llvm.r600.read.tgid.y
-    4, // llvm.r600.read.tgid.z
-    4, // llvm.r600.read.tidig.x
-    4, // llvm.r600.read.tidig.y
-    4, // llvm.r600.read.tidig.z
-    4, // llvm.r600.recipsqrt.clamped
-    4, // llvm.r600.recipsqrt.ieee
-    3, // llvm.r600.store.stream.output
-    3, // llvm.r600.store.swizzle
-    1, // llvm.r600.tex
-    1, // llvm.r600.texc
-    1, // llvm.r600.txb
-    1, // llvm.r600.txbc
-    1, // llvm.r600.txf
-    1, // llvm.r600.txl
-    1, // llvm.r600.txlc
-    1, // llvm.r600.txq
-    136, // llvm.riscv.masked.atomicrmw.add.i32
-    136, // llvm.riscv.masked.atomicrmw.add.i64
-    137, // llvm.riscv.masked.atomicrmw.max.i32
-    137, // llvm.riscv.masked.atomicrmw.max.i64
-    137, // llvm.riscv.masked.atomicrmw.min.i32
-    137, // llvm.riscv.masked.atomicrmw.min.i64
-    136, // llvm.riscv.masked.atomicrmw.nand.i32
-    136, // llvm.riscv.masked.atomicrmw.nand.i64
-    136, // llvm.riscv.masked.atomicrmw.sub.i32
-    136, // llvm.riscv.masked.atomicrmw.sub.i64
-    136, // llvm.riscv.masked.atomicrmw.umax.i32
-    136, // llvm.riscv.masked.atomicrmw.umax.i64
-    136, // llvm.riscv.masked.atomicrmw.umin.i32
-    136, // llvm.riscv.masked.atomicrmw.umin.i64
-    136, // llvm.riscv.masked.atomicrmw.xchg.i32
-    136, // llvm.riscv.masked.atomicrmw.xchg.i64
-    137, // llvm.riscv.masked.cmpxchg.i32
-    137, // llvm.riscv.masked.cmpxchg.i64
-    3, // llvm.s390.efpc
-    1, // llvm.s390.etnd
-    40, // llvm.s390.lcbb
-    135, // llvm.s390.ntstg
-    3, // llvm.s390.ppa.txassist
-    3, // llvm.s390.sfpc
-    138, // llvm.s390.tabort
-    139, // llvm.s390.tbegin
-    139, // llvm.s390.tbegin.nofloat
-    139, // llvm.s390.tbeginc
-    1, // llvm.s390.tdc
-    3, // llvm.s390.tend
-    1, // llvm.s390.vaccb
-    1, // llvm.s390.vacccq
-    1, // llvm.s390.vaccf
-    1, // llvm.s390.vaccg
-    1, // llvm.s390.vacch
-    1, // llvm.s390.vaccq
-    1, // llvm.s390.vacq
-    1, // llvm.s390.vaq
-    1, // llvm.s390.vavgb
-    1, // llvm.s390.vavgf
-    1, // llvm.s390.vavgg
-    1, // llvm.s390.vavgh
-    1, // llvm.s390.vavglb
-    1, // llvm.s390.vavglf
-    1, // llvm.s390.vavglg
-    1, // llvm.s390.vavglh
-    1, // llvm.s390.vbperm
-    1, // llvm.s390.vceqbs
-    1, // llvm.s390.vceqfs
-    1, // llvm.s390.vceqgs
-    1, // llvm.s390.vceqhs
-    1, // llvm.s390.vchbs
-    1, // llvm.s390.vchfs
-    1, // llvm.s390.vchgs
-    1, // llvm.s390.vchhs
-    1, // llvm.s390.vchlbs
-    1, // llvm.s390.vchlfs
-    1, // llvm.s390.vchlgs
-    1, // llvm.s390.vchlhs
-    1, // llvm.s390.vcksm
-    125, // llvm.s390.verimb
-    125, // llvm.s390.verimf
-    125, // llvm.s390.verimg
-    125, // llvm.s390.verimh
-    1, // llvm.s390.verllb
-    1, // llvm.s390.verllf
-    1, // llvm.s390.verllg
-    1, // llvm.s390.verllh
-    1, // llvm.s390.verllvb
-    1, // llvm.s390.verllvf
-    1, // llvm.s390.verllvg
-    1, // llvm.s390.verllvh
-    27, // llvm.s390.vfaeb
-    27, // llvm.s390.vfaebs
-    27, // llvm.s390.vfaef
-    27, // llvm.s390.vfaefs
-    27, // llvm.s390.vfaeh
-    27, // llvm.s390.vfaehs
-    27, // llvm.s390.vfaezb
-    27, // llvm.s390.vfaezbs
-    27, // llvm.s390.vfaezf
-    27, // llvm.s390.vfaezfs
-    27, // llvm.s390.vfaezh
-    27, // llvm.s390.vfaezhs
-    1, // llvm.s390.vfcedbs
-    1, // llvm.s390.vfcesbs
-    1, // llvm.s390.vfchdbs
-    1, // llvm.s390.vfchedbs
-    1, // llvm.s390.vfchesbs
-    1, // llvm.s390.vfchsbs
-    1, // llvm.s390.vfeeb
-    1, // llvm.s390.vfeebs
-    1, // llvm.s390.vfeef
-    1, // llvm.s390.vfeefs
-    1, // llvm.s390.vfeeh
-    1, // llvm.s390.vfeehs
-    1, // llvm.s390.vfeezb
-    1, // llvm.s390.vfeezbs
-    1, // llvm.s390.vfeezf
-    1, // llvm.s390.vfeezfs
-    1, // llvm.s390.vfeezh
-    1, // llvm.s390.vfeezhs
-    1, // llvm.s390.vfeneb
-    1, // llvm.s390.vfenebs
-    1, // llvm.s390.vfenef
-    1, // llvm.s390.vfenefs
-    1, // llvm.s390.vfeneh
-    1, // llvm.s390.vfenehs
-    1, // llvm.s390.vfenezb
-    1, // llvm.s390.vfenezbs
-    1, // llvm.s390.vfenezf
-    1, // llvm.s390.vfenezfs
-    1, // llvm.s390.vfenezh
-    1, // llvm.s390.vfenezhs
-    39, // llvm.s390.vfidb
-    39, // llvm.s390.vfisb
-    27, // llvm.s390.vfmaxdb
-    27, // llvm.s390.vfmaxsb
-    27, // llvm.s390.vfmindb
-    27, // llvm.s390.vfminsb
-    40, // llvm.s390.vftcidb
-    40, // llvm.s390.vftcisb
-    1, // llvm.s390.vgfmab
-    1, // llvm.s390.vgfmaf
-    1, // llvm.s390.vgfmag
-    1, // llvm.s390.vgfmah
-    1, // llvm.s390.vgfmb
-    1, // llvm.s390.vgfmf
-    1, // llvm.s390.vgfmg
-    1, // llvm.s390.vgfmh
-    1, // llvm.s390.vistrb
-    1, // llvm.s390.vistrbs
-    1, // llvm.s390.vistrf
-    1, // llvm.s390.vistrfs
-    1, // llvm.s390.vistrh
-    1, // llvm.s390.vistrhs
-    31, // llvm.s390.vlbb
-    2, // llvm.s390.vll
-    2, // llvm.s390.vlrl
-    1, // llvm.s390.vmaeb
-    1, // llvm.s390.vmaef
-    1, // llvm.s390.vmaeh
-    1, // llvm.s390.vmahb
-    1, // llvm.s390.vmahf
-    1, // llvm.s390.vmahh
-    1, // llvm.s390.vmaleb
-    1, // llvm.s390.vmalef
-    1, // llvm.s390.vmaleh
-    1, // llvm.s390.vmalhb
-    1, // llvm.s390.vmalhf
-    1, // llvm.s390.vmalhh
-    1, // llvm.s390.vmalob
-    1, // llvm.s390.vmalof
-    1, // llvm.s390.vmaloh
-    1, // llvm.s390.vmaob
-    1, // llvm.s390.vmaof
-    1, // llvm.s390.vmaoh
-    1, // llvm.s390.vmeb
-    1, // llvm.s390.vmef
-    1, // llvm.s390.vmeh
-    1, // llvm.s390.vmhb
-    1, // llvm.s390.vmhf
-    1, // llvm.s390.vmhh
-    1, // llvm.s390.vmleb
-    1, // llvm.s390.vmlef
-    1, // llvm.s390.vmleh
-    1, // llvm.s390.vmlhb
-    1, // llvm.s390.vmlhf
-    1, // llvm.s390.vmlhh
-    1, // llvm.s390.vmlob
-    1, // llvm.s390.vmlof
-    1, // llvm.s390.vmloh
-    1, // llvm.s390.vmob
-    1, // llvm.s390.vmof
-    1, // llvm.s390.vmoh
-    125, // llvm.s390.vmslg
-    27, // llvm.s390.vpdi
-    1, // llvm.s390.vperm
-    1, // llvm.s390.vpklsf
-    1, // llvm.s390.vpklsfs
-    1, // llvm.s390.vpklsg
-    1, // llvm.s390.vpklsgs
-    1, // llvm.s390.vpklsh
-    1, // llvm.s390.vpklshs
-    1, // llvm.s390.vpksf
-    1, // llvm.s390.vpksfs
-    1, // llvm.s390.vpksg
-    1, // llvm.s390.vpksgs
-    1, // llvm.s390.vpksh
-    1, // llvm.s390.vpkshs
-    1, // llvm.s390.vsbcbiq
-    1, // llvm.s390.vsbiq
-    1, // llvm.s390.vscbib
-    1, // llvm.s390.vscbif
-    1, // llvm.s390.vscbig
-    1, // llvm.s390.vscbih
-    1, // llvm.s390.vscbiq
-    1, // llvm.s390.vsl
-    1, // llvm.s390.vslb
-    27, // llvm.s390.vsldb
-    1, // llvm.s390.vsq
-    1, // llvm.s390.vsra
-    1, // llvm.s390.vsrab
-    1, // llvm.s390.vsrl
-    1, // llvm.s390.vsrlb
-    135, // llvm.s390.vstl
-    125, // llvm.s390.vstrcb
-    125, // llvm.s390.vstrcbs
-    125, // llvm.s390.vstrcf
-    125, // llvm.s390.vstrcfs
-    125, // llvm.s390.vstrch
-    125, // llvm.s390.vstrchs
-    125, // llvm.s390.vstrczb
-    125, // llvm.s390.vstrczbs
-    125, // llvm.s390.vstrczf
-    125, // llvm.s390.vstrczfs
-    125, // llvm.s390.vstrczh
-    125, // llvm.s390.vstrczhs
-    135, // llvm.s390.vstrl
-    1, // llvm.s390.vsumb
-    1, // llvm.s390.vsumgf
-    1, // llvm.s390.vsumgh
-    1, // llvm.s390.vsumh
-    1, // llvm.s390.vsumqf
-    1, // llvm.s390.vsumqg
-    1, // llvm.s390.vtm
-    1, // llvm.s390.vuphb
-    1, // llvm.s390.vuphf
-    1, // llvm.s390.vuphh
-    1, // llvm.s390.vuplb
-    1, // llvm.s390.vuplf
-    1, // llvm.s390.vuplhb
-    1, // llvm.s390.vuplhf
-    1, // llvm.s390.vuplhh
-    1, // llvm.s390.vuplhw
-    1, // llvm.s390.vupllb
-    1, // llvm.s390.vupllf
-    1, // llvm.s390.vupllh
-    4, // llvm.wasm.alltrue
-    4, // llvm.wasm.anytrue
-    140, // llvm.wasm.atomic.notify
-    141, // llvm.wasm.atomic.wait.i32
-    141, // llvm.wasm.atomic.wait.i64
-    4, // llvm.wasm.bitselect
-    142, // llvm.wasm.data.drop
-    143, // llvm.wasm.extract.exception
-    143, // llvm.wasm.get.ehselector
-    143, // llvm.wasm.get.exception
-    40, // llvm.wasm.landingpad.index
-    1, // llvm.wasm.lsda
-    3, // llvm.wasm.memory.grow
-    144, // llvm.wasm.memory.init
-    18, // llvm.wasm.memory.size
-    145, // llvm.wasm.rethrow.in.catch
-    4, // llvm.wasm.sub.saturate.signed
-    4, // llvm.wasm.sub.saturate.unsigned
-    146, // llvm.wasm.throw
-    4, // llvm.wasm.trunc.saturate.signed
-    4, // llvm.wasm.trunc.saturate.unsigned
-    1, // llvm.x86.3dnow.pavgusb
-    1, // llvm.x86.3dnow.pf2id
-    1, // llvm.x86.3dnow.pfacc
-    1, // llvm.x86.3dnow.pfadd
-    1, // llvm.x86.3dnow.pfcmpeq
-    1, // llvm.x86.3dnow.pfcmpge
-    1, // llvm.x86.3dnow.pfcmpgt
-    1, // llvm.x86.3dnow.pfmax
-    1, // llvm.x86.3dnow.pfmin
-    1, // llvm.x86.3dnow.pfmul
-    1, // llvm.x86.3dnow.pfrcp
-    1, // llvm.x86.3dnow.pfrcpit1
-    1, // llvm.x86.3dnow.pfrcpit2
-    1, // llvm.x86.3dnow.pfrsqit1
-    1, // llvm.x86.3dnow.pfrsqrt
-    1, // llvm.x86.3dnow.pfsub
-    1, // llvm.x86.3dnow.pfsubr
-    1, // llvm.x86.3dnow.pi2fd
-    1, // llvm.x86.3dnow.pmulhrw
-    1, // llvm.x86.3dnowa.pf2iw
-    1, // llvm.x86.3dnowa.pfnacc
-    1, // llvm.x86.3dnowa.pfpnacc
-    1, // llvm.x86.3dnowa.pi2fw
-    1, // llvm.x86.3dnowa.pswapd
-    1, // llvm.x86.addcarry.32
-    1, // llvm.x86.addcarry.64
-    1, // llvm.x86.aesni.aesdec
-    1, // llvm.x86.aesni.aesdec.256
-    1, // llvm.x86.aesni.aesdec.512
-    1, // llvm.x86.aesni.aesdeclast
-    1, // llvm.x86.aesni.aesdeclast.256
-    1, // llvm.x86.aesni.aesdeclast.512
-    1, // llvm.x86.aesni.aesenc
-    1, // llvm.x86.aesni.aesenc.256
-    1, // llvm.x86.aesni.aesenc.512
-    1, // llvm.x86.aesni.aesenclast
-    1, // llvm.x86.aesni.aesenclast.256
-    1, // llvm.x86.aesni.aesenclast.512
-    1, // llvm.x86.aesni.aesimc
-    40, // llvm.x86.aesni.aeskeygenassist
-    1, // llvm.x86.avx.addsub.pd.256
-    1, // llvm.x86.avx.addsub.ps.256
-    1, // llvm.x86.avx.blendv.pd.256
-    1, // llvm.x86.avx.blendv.ps.256
-    27, // llvm.x86.avx.cmp.pd.256
-    27, // llvm.x86.avx.cmp.ps.256
-    1, // llvm.x86.avx.cvt.pd2.ps.256
-    1, // llvm.x86.avx.cvt.pd2dq.256
-    1, // llvm.x86.avx.cvt.ps2dq.256
-    1, // llvm.x86.avx.cvtt.pd2dq.256
-    1, // llvm.x86.avx.cvtt.ps2dq.256
-    27, // llvm.x86.avx.dp.ps.256
-    1, // llvm.x86.avx.hadd.pd.256
-    1, // llvm.x86.avx.hadd.ps.256
-    1, // llvm.x86.avx.hsub.pd.256
-    1, // llvm.x86.avx.hsub.ps.256
-    18, // llvm.x86.avx.ldu.dq.256
-    2, // llvm.x86.avx.maskload.pd
-    2, // llvm.x86.avx.maskload.pd.256
-    2, // llvm.x86.avx.maskload.ps
-    2, // llvm.x86.avx.maskload.ps.256
-    29, // llvm.x86.avx.maskstore.pd
-    29, // llvm.x86.avx.maskstore.pd.256
-    29, // llvm.x86.avx.maskstore.ps
-    29, // llvm.x86.avx.maskstore.ps.256
-    1, // llvm.x86.avx.max.pd.256
-    1, // llvm.x86.avx.max.ps.256
-    1, // llvm.x86.avx.min.pd.256
-    1, // llvm.x86.avx.min.ps.256
-    1, // llvm.x86.avx.movmsk.pd.256
-    1, // llvm.x86.avx.movmsk.ps.256
-    1, // llvm.x86.avx.ptestc.256
-    1, // llvm.x86.avx.ptestnzc.256
-    1, // llvm.x86.avx.ptestz.256
-    1, // llvm.x86.avx.rcp.ps.256
-    40, // llvm.x86.avx.round.pd.256
-    40, // llvm.x86.avx.round.ps.256
-    1, // llvm.x86.avx.rsqrt.ps.256
-    1, // llvm.x86.avx.vpermilvar.pd
-    1, // llvm.x86.avx.vpermilvar.pd.256
-    1, // llvm.x86.avx.vpermilvar.ps
-    1, // llvm.x86.avx.vpermilvar.ps.256
-    1, // llvm.x86.avx.vtestc.pd
-    1, // llvm.x86.avx.vtestc.pd.256
-    1, // llvm.x86.avx.vtestc.ps
-    1, // llvm.x86.avx.vtestc.ps.256
-    1, // llvm.x86.avx.vtestnzc.pd
-    1, // llvm.x86.avx.vtestnzc.pd.256
-    1, // llvm.x86.avx.vtestnzc.ps
-    1, // llvm.x86.avx.vtestnzc.ps.256
-    1, // llvm.x86.avx.vtestz.pd
-    1, // llvm.x86.avx.vtestz.pd.256
-    1, // llvm.x86.avx.vtestz.ps
-    1, // llvm.x86.avx.vtestz.ps.256
-    3, // llvm.x86.avx.vzeroall
-    3, // llvm.x86.avx.vzeroupper
-    105, // llvm.x86.avx2.gather.d.d
-    105, // llvm.x86.avx2.gather.d.d.256
-    105, // llvm.x86.avx2.gather.d.pd
-    105, // llvm.x86.avx2.gather.d.pd.256
-    105, // llvm.x86.avx2.gather.d.ps
-    105, // llvm.x86.avx2.gather.d.ps.256
-    105, // llvm.x86.avx2.gather.d.q
-    105, // llvm.x86.avx2.gather.d.q.256
-    105, // llvm.x86.avx2.gather.q.d
-    105, // llvm.x86.avx2.gather.q.d.256
-    105, // llvm.x86.avx2.gather.q.pd
-    105, // llvm.x86.avx2.gather.q.pd.256
-    105, // llvm.x86.avx2.gather.q.ps
-    105, // llvm.x86.avx2.gather.q.ps.256
-    105, // llvm.x86.avx2.gather.q.q
-    105, // llvm.x86.avx2.gather.q.q.256
-    2, // llvm.x86.avx2.maskload.d
-    2, // llvm.x86.avx2.maskload.d.256
-    2, // llvm.x86.avx2.maskload.q
-    2, // llvm.x86.avx2.maskload.q.256
-    29, // llvm.x86.avx2.maskstore.d
-    29, // llvm.x86.avx2.maskstore.d.256
-    29, // llvm.x86.avx2.maskstore.q
-    29, // llvm.x86.avx2.maskstore.q.256
-    27, // llvm.x86.avx2.mpsadbw
-    1, // llvm.x86.avx2.packssdw
-    1, // llvm.x86.avx2.packsswb
-    1, // llvm.x86.avx2.packusdw
-    1, // llvm.x86.avx2.packuswb
-    1, // llvm.x86.avx2.pavg.b
-    1, // llvm.x86.avx2.pavg.w
-    1, // llvm.x86.avx2.pblendvb
-    1, // llvm.x86.avx2.permd
-    1, // llvm.x86.avx2.permps
-    1, // llvm.x86.avx2.phadd.d
-    1, // llvm.x86.avx2.phadd.sw
-    1, // llvm.x86.avx2.phadd.w
-    1, // llvm.x86.avx2.phsub.d
-    1, // llvm.x86.avx2.phsub.sw
-    1, // llvm.x86.avx2.phsub.w
-    1, // llvm.x86.avx2.pmadd.ub.sw
-    1, // llvm.x86.avx2.pmadd.wd
-    1, // llvm.x86.avx2.pmovmskb
-    1, // llvm.x86.avx2.pmul.hr.sw
-    1, // llvm.x86.avx2.pmulh.w
-    1, // llvm.x86.avx2.pmulhu.w
-    1, // llvm.x86.avx2.psad.bw
-    1, // llvm.x86.avx2.pshuf.b
-    1, // llvm.x86.avx2.psign.b
-    1, // llvm.x86.avx2.psign.d
-    1, // llvm.x86.avx2.psign.w
-    1, // llvm.x86.avx2.psll.d
-    1, // llvm.x86.avx2.psll.q
-    1, // llvm.x86.avx2.psll.w
-    1, // llvm.x86.avx2.pslli.d
-    1, // llvm.x86.avx2.pslli.q
-    1, // llvm.x86.avx2.pslli.w
-    1, // llvm.x86.avx2.psllv.d
-    1, // llvm.x86.avx2.psllv.d.256
-    1, // llvm.x86.avx2.psllv.q
-    1, // llvm.x86.avx2.psllv.q.256
-    1, // llvm.x86.avx2.psra.d
-    1, // llvm.x86.avx2.psra.w
-    1, // llvm.x86.avx2.psrai.d
-    1, // llvm.x86.avx2.psrai.w
-    1, // llvm.x86.avx2.psrav.d
-    1, // llvm.x86.avx2.psrav.d.256
-    1, // llvm.x86.avx2.psrl.d
-    1, // llvm.x86.avx2.psrl.q
-    1, // llvm.x86.avx2.psrl.w
-    1, // llvm.x86.avx2.psrli.d
-    1, // llvm.x86.avx2.psrli.q
-    1, // llvm.x86.avx2.psrli.w
-    1, // llvm.x86.avx2.psrlv.d
-    1, // llvm.x86.avx2.psrlv.d.256
-    1, // llvm.x86.avx2.psrlv.q
-    1, // llvm.x86.avx2.psrlv.q.256
-    27, // llvm.x86.avx512.add.pd.512
-    27, // llvm.x86.avx512.add.ps.512
-    1, // llvm.x86.avx512.broadcastmb.128
-    1, // llvm.x86.avx512.broadcastmb.256
-    1, // llvm.x86.avx512.broadcastmb.512
-    1, // llvm.x86.avx512.broadcastmw.128
-    1, // llvm.x86.avx512.broadcastmw.256
-    1, // llvm.x86.avx512.broadcastmw.512
-    27, // llvm.x86.avx512.cmp.pd.128
-    27, // llvm.x86.avx512.cmp.pd.256
-    124, // llvm.x86.avx512.cmp.pd.512
-    27, // llvm.x86.avx512.cmp.ps.128
-    27, // llvm.x86.avx512.cmp.ps.256
-    124, // llvm.x86.avx512.cmp.ps.512
-    1, // llvm.x86.avx512.conflict.d.128
-    1, // llvm.x86.avx512.conflict.d.256
-    1, // llvm.x86.avx512.conflict.d.512
-    1, // llvm.x86.avx512.conflict.q.128
-    1, // llvm.x86.avx512.conflict.q.256
-    1, // llvm.x86.avx512.conflict.q.512
-    27, // llvm.x86.avx512.cvtsi2sd64
-    27, // llvm.x86.avx512.cvtsi2ss32
-    27, // llvm.x86.avx512.cvtsi2ss64
-    40, // llvm.x86.avx512.cvttsd2si
-    40, // llvm.x86.avx512.cvttsd2si64
-    40, // llvm.x86.avx512.cvttsd2usi
-    40, // llvm.x86.avx512.cvttsd2usi64
-    40, // llvm.x86.avx512.cvttss2si
-    40, // llvm.x86.avx512.cvttss2si64
-    40, // llvm.x86.avx512.cvttss2usi
-    40, // llvm.x86.avx512.cvttss2usi64
-    27, // llvm.x86.avx512.cvtusi2ss
-    27, // llvm.x86.avx512.cvtusi642sd
-    27, // llvm.x86.avx512.cvtusi642ss
-    27, // llvm.x86.avx512.dbpsadbw.128
-    27, // llvm.x86.avx512.dbpsadbw.256
-    27, // llvm.x86.avx512.dbpsadbw.512
-    27, // llvm.x86.avx512.div.pd.512
-    27, // llvm.x86.avx512.div.ps.512
-    125, // llvm.x86.avx512.exp2.pd
-    125, // llvm.x86.avx512.exp2.ps
-    40, // llvm.x86.avx512.fpclass.pd.128
-    40, // llvm.x86.avx512.fpclass.pd.256
-    40, // llvm.x86.avx512.fpclass.pd.512
-    40, // llvm.x86.avx512.fpclass.ps.128
-    40, // llvm.x86.avx512.fpclass.ps.256
-    40, // llvm.x86.avx512.fpclass.ps.512
-    105, // llvm.x86.avx512.gather.dpd.512
-    105, // llvm.x86.avx512.gather.dpi.512
-    105, // llvm.x86.avx512.gather.dpq.512
-    105, // llvm.x86.avx512.gather.dps.512
-    105, // llvm.x86.avx512.gather.qpd.512
-    105, // llvm.x86.avx512.gather.qpi.512
-    105, // llvm.x86.avx512.gather.qpq.512
-    105, // llvm.x86.avx512.gather.qps.512
-    105, // llvm.x86.avx512.gather3div2.df
-    105, // llvm.x86.avx512.gather3div2.di
-    105, // llvm.x86.avx512.gather3div4.df
-    105, // llvm.x86.avx512.gather3div4.di
-    105, // llvm.x86.avx512.gather3div4.sf
-    105, // llvm.x86.avx512.gather3div4.si
-    105, // llvm.x86.avx512.gather3div8.sf
-    105, // llvm.x86.avx512.gather3div8.si
-    105, // llvm.x86.avx512.gather3siv2.df
-    105, // llvm.x86.avx512.gather3siv2.di
-    105, // llvm.x86.avx512.gather3siv4.df
-    105, // llvm.x86.avx512.gather3siv4.di
-    105, // llvm.x86.avx512.gather3siv4.sf
-    105, // llvm.x86.avx512.gather3siv4.si
-    105, // llvm.x86.avx512.gather3siv8.sf
-    105, // llvm.x86.avx512.gather3siv8.si
-    67, // llvm.x86.avx512.gatherpf.dpd.512
-    67, // llvm.x86.avx512.gatherpf.dps.512
-    67, // llvm.x86.avx512.gatherpf.qpd.512
-    67, // llvm.x86.avx512.gatherpf.qps.512
-    1, // llvm.x86.avx512.kadd.b
-    1, // llvm.x86.avx512.kadd.d
-    1, // llvm.x86.avx512.kadd.q
-    1, // llvm.x86.avx512.kadd.w
-    1, // llvm.x86.avx512.ktestc.b
-    1, // llvm.x86.avx512.ktestc.d
-    1, // llvm.x86.avx512.ktestc.q
-    1, // llvm.x86.avx512.ktestc.w
-    1, // llvm.x86.avx512.ktestz.b
-    1, // llvm.x86.avx512.ktestz.d
-    1, // llvm.x86.avx512.ktestz.q
-    1, // llvm.x86.avx512.ktestz.w
-    147, // llvm.x86.avx512.mask.add.sd.round
-    147, // llvm.x86.avx512.mask.add.ss.round
-    148, // llvm.x86.avx512.mask.cmp.sd
-    148, // llvm.x86.avx512.mask.cmp.ss
-    1, // llvm.x86.avx512.mask.compress
-    1, // llvm.x86.avx512.mask.cvtpd2dq.128
-    125, // llvm.x86.avx512.mask.cvtpd2dq.512
-    1, // llvm.x86.avx512.mask.cvtpd2ps
-    125, // llvm.x86.avx512.mask.cvtpd2ps.512
-    1, // llvm.x86.avx512.mask.cvtpd2qq.128
-    1, // llvm.x86.avx512.mask.cvtpd2qq.256
-    125, // llvm.x86.avx512.mask.cvtpd2qq.512
-    1, // llvm.x86.avx512.mask.cvtpd2udq.128
-    1, // llvm.x86.avx512.mask.cvtpd2udq.256
-    125, // llvm.x86.avx512.mask.cvtpd2udq.512
-    1, // llvm.x86.avx512.mask.cvtpd2uqq.128
-    1, // llvm.x86.avx512.mask.cvtpd2uqq.256
-    125, // llvm.x86.avx512.mask.cvtpd2uqq.512
-    1, // llvm.x86.avx512.mask.cvtps2dq.128
-    1, // llvm.x86.avx512.mask.cvtps2dq.256
-    125, // llvm.x86.avx512.mask.cvtps2dq.512
-    125, // llvm.x86.avx512.mask.cvtps2pd.512
-    1, // llvm.x86.avx512.mask.cvtps2qq.128
-    1, // llvm.x86.avx512.mask.cvtps2qq.256
-    125, // llvm.x86.avx512.mask.cvtps2qq.512
-    1, // llvm.x86.avx512.mask.cvtps2udq.128
-    1, // llvm.x86.avx512.mask.cvtps2udq.256
-    125, // llvm.x86.avx512.mask.cvtps2udq.512
-    1, // llvm.x86.avx512.mask.cvtps2uqq.128
-    1, // llvm.x86.avx512.mask.cvtps2uqq.256
-    125, // llvm.x86.avx512.mask.cvtps2uqq.512
-    1, // llvm.x86.avx512.mask.cvtqq2ps.128
-    147, // llvm.x86.avx512.mask.cvtsd2ss.round
-    147, // llvm.x86.avx512.mask.cvtss2sd.round
-    1, // llvm.x86.avx512.mask.cvttpd2dq.128
-    125, // llvm.x86.avx512.mask.cvttpd2dq.512
-    1, // llvm.x86.avx512.mask.cvttpd2qq.128
-    1, // llvm.x86.avx512.mask.cvttpd2qq.256
-    125, // llvm.x86.avx512.mask.cvttpd2qq.512
-    1, // llvm.x86.avx512.mask.cvttpd2udq.128
-    1, // llvm.x86.avx512.mask.cvttpd2udq.256
-    125, // llvm.x86.avx512.mask.cvttpd2udq.512
-    1, // llvm.x86.avx512.mask.cvttpd2uqq.128
-    1, // llvm.x86.avx512.mask.cvttpd2uqq.256
-    125, // llvm.x86.avx512.mask.cvttpd2uqq.512
-    125, // llvm.x86.avx512.mask.cvttps2dq.512
-    1, // llvm.x86.avx512.mask.cvttps2qq.128
-    1, // llvm.x86.avx512.mask.cvttps2qq.256
-    125, // llvm.x86.avx512.mask.cvttps2qq.512
-    1, // llvm.x86.avx512.mask.cvttps2udq.128
-    1, // llvm.x86.avx512.mask.cvttps2udq.256
-    125, // llvm.x86.avx512.mask.cvttps2udq.512
-    1, // llvm.x86.avx512.mask.cvttps2uqq.128
-    1, // llvm.x86.avx512.mask.cvttps2uqq.256
-    125, // llvm.x86.avx512.mask.cvttps2uqq.512
-    1, // llvm.x86.avx512.mask.cvtuqq2ps.128
-    147, // llvm.x86.avx512.mask.div.sd.round
-    147, // llvm.x86.avx512.mask.div.ss.round
-    1, // llvm.x86.avx512.mask.expand
-    125, // llvm.x86.avx512.mask.fixupimm.pd.128
-    125, // llvm.x86.avx512.mask.fixupimm.pd.256
-    149, // llvm.x86.avx512.mask.fixupimm.pd.512
-    125, // llvm.x86.avx512.mask.fixupimm.ps.128
-    125, // llvm.x86.avx512.mask.fixupimm.ps.256
-    149, // llvm.x86.avx512.mask.fixupimm.ps.512
-    149, // llvm.x86.avx512.mask.fixupimm.sd
-    149, // llvm.x86.avx512.mask.fixupimm.ss
-    40, // llvm.x86.avx512.mask.fpclass.sd
-    40, // llvm.x86.avx512.mask.fpclass.ss
-    105, // llvm.x86.avx512.mask.gather.dpd.512
-    105, // llvm.x86.avx512.mask.gather.dpi.512
-    105, // llvm.x86.avx512.mask.gather.dpq.512
-    105, // llvm.x86.avx512.mask.gather.dps.512
-    105, // llvm.x86.avx512.mask.gather.qpd.512
-    105, // llvm.x86.avx512.mask.gather.qpi.512
-    105, // llvm.x86.avx512.mask.gather.qpq.512
-    105, // llvm.x86.avx512.mask.gather.qps.512
-    105, // llvm.x86.avx512.mask.gather3div2.df
-    105, // llvm.x86.avx512.mask.gather3div2.di
-    105, // llvm.x86.avx512.mask.gather3div4.df
-    105, // llvm.x86.avx512.mask.gather3div4.di
-    105, // llvm.x86.avx512.mask.gather3div4.sf
-    105, // llvm.x86.avx512.mask.gather3div4.si
-    105, // llvm.x86.avx512.mask.gather3div8.sf
-    105, // llvm.x86.avx512.mask.gather3div8.si
-    105, // llvm.x86.avx512.mask.gather3siv2.df
-    105, // llvm.x86.avx512.mask.gather3siv2.di
-    105, // llvm.x86.avx512.mask.gather3siv4.df
-    105, // llvm.x86.avx512.mask.gather3siv4.di
-    105, // llvm.x86.avx512.mask.gather3siv4.sf
-    105, // llvm.x86.avx512.mask.gather3siv4.si
-    105, // llvm.x86.avx512.mask.gather3siv8.sf
-    105, // llvm.x86.avx512.mask.gather3siv8.si
-    1, // llvm.x86.avx512.mask.getexp.pd.128
-    1, // llvm.x86.avx512.mask.getexp.pd.256
-    125, // llvm.x86.avx512.mask.getexp.pd.512
-    1, // llvm.x86.avx512.mask.getexp.ps.128
-    1, // llvm.x86.avx512.mask.getexp.ps.256
-    125, // llvm.x86.avx512.mask.getexp.ps.512
-    147, // llvm.x86.avx512.mask.getexp.sd
-    147, // llvm.x86.avx512.mask.getexp.ss
-    40, // llvm.x86.avx512.mask.getmant.pd.128
-    40, // llvm.x86.avx512.mask.getmant.pd.256
-    150, // llvm.x86.avx512.mask.getmant.pd.512
-    40, // llvm.x86.avx512.mask.getmant.ps.128
-    40, // llvm.x86.avx512.mask.getmant.ps.256
-    150, // llvm.x86.avx512.mask.getmant.ps.512
-    151, // llvm.x86.avx512.mask.getmant.sd
-    151, // llvm.x86.avx512.mask.getmant.ss
-    147, // llvm.x86.avx512.mask.max.sd.round
-    147, // llvm.x86.avx512.mask.max.ss.round
-    147, // llvm.x86.avx512.mask.min.sd.round
-    147, // llvm.x86.avx512.mask.min.ss.round
-    147, // llvm.x86.avx512.mask.mul.sd.round
-    147, // llvm.x86.avx512.mask.mul.ss.round
-    1, // llvm.x86.avx512.mask.pmov.db.128
-    1, // llvm.x86.avx512.mask.pmov.db.256
-    1, // llvm.x86.avx512.mask.pmov.db.512
-    29, // llvm.x86.avx512.mask.pmov.db.mem.128
-    29, // llvm.x86.avx512.mask.pmov.db.mem.256
-    29, // llvm.x86.avx512.mask.pmov.db.mem.512
-    1, // llvm.x86.avx512.mask.pmov.dw.128
-    1, // llvm.x86.avx512.mask.pmov.dw.256
-    1, // llvm.x86.avx512.mask.pmov.dw.512
-    29, // llvm.x86.avx512.mask.pmov.dw.mem.128
-    29, // llvm.x86.avx512.mask.pmov.dw.mem.256
-    29, // llvm.x86.avx512.mask.pmov.dw.mem.512
-    1, // llvm.x86.avx512.mask.pmov.qb.128
-    1, // llvm.x86.avx512.mask.pmov.qb.256
-    1, // llvm.x86.avx512.mask.pmov.qb.512
-    29, // llvm.x86.avx512.mask.pmov.qb.mem.128
-    29, // llvm.x86.avx512.mask.pmov.qb.mem.256
-    29, // llvm.x86.avx512.mask.pmov.qb.mem.512
-    1, // llvm.x86.avx512.mask.pmov.qd.128
-    29, // llvm.x86.avx512.mask.pmov.qd.mem.128
-    29, // llvm.x86.avx512.mask.pmov.qd.mem.256
-    29, // llvm.x86.avx512.mask.pmov.qd.mem.512
-    1, // llvm.x86.avx512.mask.pmov.qw.128
-    1, // llvm.x86.avx512.mask.pmov.qw.256
-    1, // llvm.x86.avx512.mask.pmov.qw.512
-    29, // llvm.x86.avx512.mask.pmov.qw.mem.128
-    29, // llvm.x86.avx512.mask.pmov.qw.mem.256
-    29, // llvm.x86.avx512.mask.pmov.qw.mem.512
-    1, // llvm.x86.avx512.mask.pmov.wb.128
-    29, // llvm.x86.avx512.mask.pmov.wb.mem.128
-    29, // llvm.x86.avx512.mask.pmov.wb.mem.256
-    29, // llvm.x86.avx512.mask.pmov.wb.mem.512
-    1, // llvm.x86.avx512.mask.pmovs.db.128
-    1, // llvm.x86.avx512.mask.pmovs.db.256
-    1, // llvm.x86.avx512.mask.pmovs.db.512
-    29, // llvm.x86.avx512.mask.pmovs.db.mem.128
-    29, // llvm.x86.avx512.mask.pmovs.db.mem.256
-    29, // llvm.x86.avx512.mask.pmovs.db.mem.512
-    1, // llvm.x86.avx512.mask.pmovs.dw.128
-    1, // llvm.x86.avx512.mask.pmovs.dw.256
-    1, // llvm.x86.avx512.mask.pmovs.dw.512
-    29, // llvm.x86.avx512.mask.pmovs.dw.mem.128
-    29, // llvm.x86.avx512.mask.pmovs.dw.mem.256
-    29, // llvm.x86.avx512.mask.pmovs.dw.mem.512
-    1, // llvm.x86.avx512.mask.pmovs.qb.128
-    1, // llvm.x86.avx512.mask.pmovs.qb.256
-    1, // llvm.x86.avx512.mask.pmovs.qb.512
-    29, // llvm.x86.avx512.mask.pmovs.qb.mem.128
-    29, // llvm.x86.avx512.mask.pmovs.qb.mem.256
-    29, // llvm.x86.avx512.mask.pmovs.qb.mem.512
-    1, // llvm.x86.avx512.mask.pmovs.qd.128
-    1, // llvm.x86.avx512.mask.pmovs.qd.256
-    1, // llvm.x86.avx512.mask.pmovs.qd.512
-    29, // llvm.x86.avx512.mask.pmovs.qd.mem.128
-    29, // llvm.x86.avx512.mask.pmovs.qd.mem.256
-    29, // llvm.x86.avx512.mask.pmovs.qd.mem.512
-    1, // llvm.x86.avx512.mask.pmovs.qw.128
-    1, // llvm.x86.avx512.mask.pmovs.qw.256
-    1, // llvm.x86.avx512.mask.pmovs.qw.512
-    29, // llvm.x86.avx512.mask.pmovs.qw.mem.128
-    29, // llvm.x86.avx512.mask.pmovs.qw.mem.256
-    29, // llvm.x86.avx512.mask.pmovs.qw.mem.512
-    1, // llvm.x86.avx512.mask.pmovs.wb.128
-    1, // llvm.x86.avx512.mask.pmovs.wb.256
-    1, // llvm.x86.avx512.mask.pmovs.wb.512
-    29, // llvm.x86.avx512.mask.pmovs.wb.mem.128
-    29, // llvm.x86.avx512.mask.pmovs.wb.mem.256
-    29, // llvm.x86.avx512.mask.pmovs.wb.mem.512
-    1, // llvm.x86.avx512.mask.pmovus.db.128
-    1, // llvm.x86.avx512.mask.pmovus.db.256
-    1, // llvm.x86.avx512.mask.pmovus.db.512
-    29, // llvm.x86.avx512.mask.pmovus.db.mem.128
-    29, // llvm.x86.avx512.mask.pmovus.db.mem.256
-    29, // llvm.x86.avx512.mask.pmovus.db.mem.512
-    1, // llvm.x86.avx512.mask.pmovus.dw.128
-    1, // llvm.x86.avx512.mask.pmovus.dw.256
-    1, // llvm.x86.avx512.mask.pmovus.dw.512
-    29, // llvm.x86.avx512.mask.pmovus.dw.mem.128
-    29, // llvm.x86.avx512.mask.pmovus.dw.mem.256
-    29, // llvm.x86.avx512.mask.pmovus.dw.mem.512
-    1, // llvm.x86.avx512.mask.pmovus.qb.128
-    1, // llvm.x86.avx512.mask.pmovus.qb.256
-    1, // llvm.x86.avx512.mask.pmovus.qb.512
-    29, // llvm.x86.avx512.mask.pmovus.qb.mem.128
-    29, // llvm.x86.avx512.mask.pmovus.qb.mem.256
-    29, // llvm.x86.avx512.mask.pmovus.qb.mem.512
-    1, // llvm.x86.avx512.mask.pmovus.qd.128
-    1, // llvm.x86.avx512.mask.pmovus.qd.256
-    1, // llvm.x86.avx512.mask.pmovus.qd.512
-    29, // llvm.x86.avx512.mask.pmovus.qd.mem.128
-    29, // llvm.x86.avx512.mask.pmovus.qd.mem.256
-    29, // llvm.x86.avx512.mask.pmovus.qd.mem.512
-    1, // llvm.x86.avx512.mask.pmovus.qw.128
-    1, // llvm.x86.avx512.mask.pmovus.qw.256
-    1, // llvm.x86.avx512.mask.pmovus.qw.512
-    29, // llvm.x86.avx512.mask.pmovus.qw.mem.128
-    29, // llvm.x86.avx512.mask.pmovus.qw.mem.256
-    29, // llvm.x86.avx512.mask.pmovus.qw.mem.512
-    1, // llvm.x86.avx512.mask.pmovus.wb.128
-    1, // llvm.x86.avx512.mask.pmovus.wb.256
-    1, // llvm.x86.avx512.mask.pmovus.wb.512
-    29, // llvm.x86.avx512.mask.pmovus.wb.mem.128
-    29, // llvm.x86.avx512.mask.pmovus.wb.mem.256
-    29, // llvm.x86.avx512.mask.pmovus.wb.mem.512
-    27, // llvm.x86.avx512.mask.range.pd.128
-    27, // llvm.x86.avx512.mask.range.pd.256
-    151, // llvm.x86.avx512.mask.range.pd.512
-    27, // llvm.x86.avx512.mask.range.ps.128
-    27, // llvm.x86.avx512.mask.range.ps.256
-    151, // llvm.x86.avx512.mask.range.ps.512
-    152, // llvm.x86.avx512.mask.range.sd
-    152, // llvm.x86.avx512.mask.range.ss
-    40, // llvm.x86.avx512.mask.reduce.pd.128
-    40, // llvm.x86.avx512.mask.reduce.pd.256
-    150, // llvm.x86.avx512.mask.reduce.pd.512
-    40, // llvm.x86.avx512.mask.reduce.ps.128
-    40, // llvm.x86.avx512.mask.reduce.ps.256
-    150, // llvm.x86.avx512.mask.reduce.ps.512
-    152, // llvm.x86.avx512.mask.reduce.sd
-    152, // llvm.x86.avx512.mask.reduce.ss
-    40, // llvm.x86.avx512.mask.rndscale.pd.128
-    40, // llvm.x86.avx512.mask.rndscale.pd.256
-    150, // llvm.x86.avx512.mask.rndscale.pd.512
-    40, // llvm.x86.avx512.mask.rndscale.ps.128
-    40, // llvm.x86.avx512.mask.rndscale.ps.256
-    150, // llvm.x86.avx512.mask.rndscale.ps.512
-    152, // llvm.x86.avx512.mask.rndscale.sd
-    152, // llvm.x86.avx512.mask.rndscale.ss
-    1, // llvm.x86.avx512.mask.scalef.pd.128
-    1, // llvm.x86.avx512.mask.scalef.pd.256
-    147, // llvm.x86.avx512.mask.scalef.pd.512
-    1, // llvm.x86.avx512.mask.scalef.ps.128
-    1, // llvm.x86.avx512.mask.scalef.ps.256
-    147, // llvm.x86.avx512.mask.scalef.ps.512
-    147, // llvm.x86.avx512.mask.scalef.sd
-    147, // llvm.x86.avx512.mask.scalef.ss
-    52, // llvm.x86.avx512.mask.scatter.dpd.512
-    52, // llvm.x86.avx512.mask.scatter.dpi.512
-    52, // llvm.x86.avx512.mask.scatter.dpq.512
-    52, // llvm.x86.avx512.mask.scatter.dps.512
-    52, // llvm.x86.avx512.mask.scatter.qpd.512
-    52, // llvm.x86.avx512.mask.scatter.qpi.512
-    52, // llvm.x86.avx512.mask.scatter.qpq.512
-    52, // llvm.x86.avx512.mask.scatter.qps.512
-    52, // llvm.x86.avx512.mask.scatterdiv2.df
-    52, // llvm.x86.avx512.mask.scatterdiv2.di
-    52, // llvm.x86.avx512.mask.scatterdiv4.df
-    52, // llvm.x86.avx512.mask.scatterdiv4.di
-    52, // llvm.x86.avx512.mask.scatterdiv4.sf
-    52, // llvm.x86.avx512.mask.scatterdiv4.si
-    52, // llvm.x86.avx512.mask.scatterdiv8.sf
-    52, // llvm.x86.avx512.mask.scatterdiv8.si
-    52, // llvm.x86.avx512.mask.scattersiv2.df
-    52, // llvm.x86.avx512.mask.scattersiv2.di
-    52, // llvm.x86.avx512.mask.scattersiv4.df
-    52, // llvm.x86.avx512.mask.scattersiv4.di
-    52, // llvm.x86.avx512.mask.scattersiv4.sf
-    52, // llvm.x86.avx512.mask.scattersiv4.si
-    52, // llvm.x86.avx512.mask.scattersiv8.sf
-    52, // llvm.x86.avx512.mask.scattersiv8.si
-    147, // llvm.x86.avx512.mask.sqrt.sd
-    147, // llvm.x86.avx512.mask.sqrt.ss
-    147, // llvm.x86.avx512.mask.sub.sd.round
-    147, // llvm.x86.avx512.mask.sub.ss.round
-    1, // llvm.x86.avx512.mask.vcvtph2ps.128
-    1, // llvm.x86.avx512.mask.vcvtph2ps.256
-    125, // llvm.x86.avx512.mask.vcvtph2ps.512
-    40, // llvm.x86.avx512.mask.vcvtps2ph.128
-    40, // llvm.x86.avx512.mask.vcvtps2ph.256
-    40, // llvm.x86.avx512.mask.vcvtps2ph.512
-    125, // llvm.x86.avx512.maskz.fixupimm.pd.128
-    125, // llvm.x86.avx512.maskz.fixupimm.pd.256
-    149, // llvm.x86.avx512.maskz.fixupimm.pd.512
-    125, // llvm.x86.avx512.maskz.fixupimm.ps.128
-    125, // llvm.x86.avx512.maskz.fixupimm.ps.256
-    149, // llvm.x86.avx512.maskz.fixupimm.ps.512
-    149, // llvm.x86.avx512.maskz.fixupimm.sd
-    149, // llvm.x86.avx512.maskz.fixupimm.ss
-    27, // llvm.x86.avx512.max.pd.512
-    27, // llvm.x86.avx512.max.ps.512
-    27, // llvm.x86.avx512.min.pd.512
-    27, // llvm.x86.avx512.min.ps.512
-    27, // llvm.x86.avx512.mul.pd.512
-    27, // llvm.x86.avx512.mul.ps.512
-    1, // llvm.x86.avx512.packssdw.512
-    1, // llvm.x86.avx512.packsswb.512
-    1, // llvm.x86.avx512.packusdw.512
-    1, // llvm.x86.avx512.packuswb.512
-    1, // llvm.x86.avx512.pavg.b.512
-    1, // llvm.x86.avx512.pavg.w.512
-    1, // llvm.x86.avx512.permvar.df.256
-    1, // llvm.x86.avx512.permvar.df.512
-    1, // llvm.x86.avx512.permvar.di.256
-    1, // llvm.x86.avx512.permvar.di.512
-    1, // llvm.x86.avx512.permvar.hi.128
-    1, // llvm.x86.avx512.permvar.hi.256
-    1, // llvm.x86.avx512.permvar.hi.512
-    1, // llvm.x86.avx512.permvar.qi.128
-    1, // llvm.x86.avx512.permvar.qi.256
-    1, // llvm.x86.avx512.permvar.qi.512
-    1, // llvm.x86.avx512.permvar.sf.512
-    1, // llvm.x86.avx512.permvar.si.512
-    1, // llvm.x86.avx512.pmaddubs.w.512
-    1, // llvm.x86.avx512.pmaddw.d.512
-    1, // llvm.x86.avx512.pmul.hr.sw.512
-    1, // llvm.x86.avx512.pmulh.w.512
-    1, // llvm.x86.avx512.pmulhu.w.512
-    1, // llvm.x86.avx512.pmultishift.qb.128
-    1, // llvm.x86.avx512.pmultishift.qb.256
-    1, // llvm.x86.avx512.pmultishift.qb.512
-    1, // llvm.x86.avx512.psad.bw.512
-    1, // llvm.x86.avx512.pshuf.b.512
-    1, // llvm.x86.avx512.psll.d.512
-    1, // llvm.x86.avx512.psll.q.512
-    1, // llvm.x86.avx512.psll.w.512
-    1, // llvm.x86.avx512.pslli.d.512
-    1, // llvm.x86.avx512.pslli.q.512
-    1, // llvm.x86.avx512.pslli.w.512
-    1, // llvm.x86.avx512.psllv.d.512
-    1, // llvm.x86.avx512.psllv.q.512
-    1, // llvm.x86.avx512.psllv.w.128
-    1, // llvm.x86.avx512.psllv.w.256
-    1, // llvm.x86.avx512.psllv.w.512
-    1, // llvm.x86.avx512.psra.d.512
-    1, // llvm.x86.avx512.psra.q.128
-    1, // llvm.x86.avx512.psra.q.256
-    1, // llvm.x86.avx512.psra.q.512
-    1, // llvm.x86.avx512.psra.w.512
-    1, // llvm.x86.avx512.psrai.d.512
-    1, // llvm.x86.avx512.psrai.q.128
-    1, // llvm.x86.avx512.psrai.q.256
-    1, // llvm.x86.avx512.psrai.q.512
-    1, // llvm.x86.avx512.psrai.w.512
-    1, // llvm.x86.avx512.psrav.d.512
-    1, // llvm.x86.avx512.psrav.q.128
-    1, // llvm.x86.avx512.psrav.q.256
-    1, // llvm.x86.avx512.psrav.q.512
-    1, // llvm.x86.avx512.psrav.w.128
-    1, // llvm.x86.avx512.psrav.w.256
-    1, // llvm.x86.avx512.psrav.w.512
-    1, // llvm.x86.avx512.psrl.d.512
-    1, // llvm.x86.avx512.psrl.q.512
-    1, // llvm.x86.avx512.psrl.w.512
-    1, // llvm.x86.avx512.psrli.d.512
-    1, // llvm.x86.avx512.psrli.q.512
-    1, // llvm.x86.avx512.psrli.w.512
-    1, // llvm.x86.avx512.psrlv.d.512
-    1, // llvm.x86.avx512.psrlv.q.512
-    1, // llvm.x86.avx512.psrlv.w.128
-    1, // llvm.x86.avx512.psrlv.w.256
-    1, // llvm.x86.avx512.psrlv.w.512
-    125, // llvm.x86.avx512.pternlog.d.128
-    125, // llvm.x86.avx512.pternlog.d.256
-    125, // llvm.x86.avx512.pternlog.d.512
-    125, // llvm.x86.avx512.pternlog.q.128
-    125, // llvm.x86.avx512.pternlog.q.256
-    125, // llvm.x86.avx512.pternlog.q.512
-    1, // llvm.x86.avx512.rcp14.pd.128
-    1, // llvm.x86.avx512.rcp14.pd.256
-    1, // llvm.x86.avx512.rcp14.pd.512
-    1, // llvm.x86.avx512.rcp14.ps.128
-    1, // llvm.x86.avx512.rcp14.ps.256
-    1, // llvm.x86.avx512.rcp14.ps.512
-    1, // llvm.x86.avx512.rcp14.sd
-    1, // llvm.x86.avx512.rcp14.ss
-    125, // llvm.x86.avx512.rcp28.pd
-    125, // llvm.x86.avx512.rcp28.ps
-    147, // llvm.x86.avx512.rcp28.sd
-    147, // llvm.x86.avx512.rcp28.ss
-    1, // llvm.x86.avx512.rsqrt14.pd.128
-    1, // llvm.x86.avx512.rsqrt14.pd.256
-    1, // llvm.x86.avx512.rsqrt14.pd.512
-    1, // llvm.x86.avx512.rsqrt14.ps.128
-    1, // llvm.x86.avx512.rsqrt14.ps.256
-    1, // llvm.x86.avx512.rsqrt14.ps.512
-    1, // llvm.x86.avx512.rsqrt14.sd
-    1, // llvm.x86.avx512.rsqrt14.ss
-    125, // llvm.x86.avx512.rsqrt28.pd
-    125, // llvm.x86.avx512.rsqrt28.ps
-    147, // llvm.x86.avx512.rsqrt28.sd
-    147, // llvm.x86.avx512.rsqrt28.ss
-    52, // llvm.x86.avx512.scatter.dpd.512
-    52, // llvm.x86.avx512.scatter.dpi.512
-    52, // llvm.x86.avx512.scatter.dpq.512
-    52, // llvm.x86.avx512.scatter.dps.512
-    52, // llvm.x86.avx512.scatter.qpd.512
-    52, // llvm.x86.avx512.scatter.qpi.512
-    52, // llvm.x86.avx512.scatter.qpq.512
-    52, // llvm.x86.avx512.scatter.qps.512
-    52, // llvm.x86.avx512.scatterdiv2.df
-    52, // llvm.x86.avx512.scatterdiv2.di
-    52, // llvm.x86.avx512.scatterdiv4.df
-    52, // llvm.x86.avx512.scatterdiv4.di
-    52, // llvm.x86.avx512.scatterdiv4.sf
-    52, // llvm.x86.avx512.scatterdiv4.si
-    52, // llvm.x86.avx512.scatterdiv8.sf
-    52, // llvm.x86.avx512.scatterdiv8.si
-    67, // llvm.x86.avx512.scatterpf.dpd.512
-    67, // llvm.x86.avx512.scatterpf.dps.512
-    67, // llvm.x86.avx512.scatterpf.qpd.512
-    67, // llvm.x86.avx512.scatterpf.qps.512
-    52, // llvm.x86.avx512.scattersiv2.df
-    52, // llvm.x86.avx512.scattersiv2.di
-    52, // llvm.x86.avx512.scattersiv4.df
-    52, // llvm.x86.avx512.scattersiv4.di
-    52, // llvm.x86.avx512.scattersiv4.sf
-    52, // llvm.x86.avx512.scattersiv4.si
-    52, // llvm.x86.avx512.scattersiv8.sf
-    52, // llvm.x86.avx512.scattersiv8.si
-    40, // llvm.x86.avx512.sitofp.round
-    40, // llvm.x86.avx512.sqrt.pd.512
-    40, // llvm.x86.avx512.sqrt.ps.512
-    27, // llvm.x86.avx512.sub.pd.512
-    27, // llvm.x86.avx512.sub.ps.512
-    40, // llvm.x86.avx512.uitofp.round
-    124, // llvm.x86.avx512.vcomi.sd
-    124, // llvm.x86.avx512.vcomi.ss
-    40, // llvm.x86.avx512.vcvtsd2si32
-    40, // llvm.x86.avx512.vcvtsd2si64
-    40, // llvm.x86.avx512.vcvtsd2usi32
-    40, // llvm.x86.avx512.vcvtsd2usi64
-    40, // llvm.x86.avx512.vcvtss2si32
-    40, // llvm.x86.avx512.vcvtss2si64
-    40, // llvm.x86.avx512.vcvtss2usi32
-    40, // llvm.x86.avx512.vcvtss2usi64
-    125, // llvm.x86.avx512.vfmadd.f32
-    125, // llvm.x86.avx512.vfmadd.f64
-    125, // llvm.x86.avx512.vfmadd.pd.512
-    125, // llvm.x86.avx512.vfmadd.ps.512
-    125, // llvm.x86.avx512.vfmaddsub.pd.512
-    125, // llvm.x86.avx512.vfmaddsub.ps.512
-    1, // llvm.x86.avx512.vp2intersect.d.128
-    1, // llvm.x86.avx512.vp2intersect.d.256
-    1, // llvm.x86.avx512.vp2intersect.d.512
-    1, // llvm.x86.avx512.vp2intersect.q.128
-    1, // llvm.x86.avx512.vp2intersect.q.256
-    1, // llvm.x86.avx512.vp2intersect.q.512
-    1, // llvm.x86.avx512.vpdpbusd.128
-    1, // llvm.x86.avx512.vpdpbusd.256
-    1, // llvm.x86.avx512.vpdpbusd.512
-    1, // llvm.x86.avx512.vpdpbusds.128
-    1, // llvm.x86.avx512.vpdpbusds.256
-    1, // llvm.x86.avx512.vpdpbusds.512
-    1, // llvm.x86.avx512.vpdpwssd.128
-    1, // llvm.x86.avx512.vpdpwssd.256
-    1, // llvm.x86.avx512.vpdpwssd.512
-    1, // llvm.x86.avx512.vpdpwssds.128
-    1, // llvm.x86.avx512.vpdpwssds.256
-    1, // llvm.x86.avx512.vpdpwssds.512
-    1, // llvm.x86.avx512.vpermi2var.d.128
-    1, // llvm.x86.avx512.vpermi2var.d.256
-    1, // llvm.x86.avx512.vpermi2var.d.512
-    1, // llvm.x86.avx512.vpermi2var.hi.128
-    1, // llvm.x86.avx512.vpermi2var.hi.256
-    1, // llvm.x86.avx512.vpermi2var.hi.512
-    1, // llvm.x86.avx512.vpermi2var.pd.128
-    1, // llvm.x86.avx512.vpermi2var.pd.256
-    1, // llvm.x86.avx512.vpermi2var.pd.512
-    1, // llvm.x86.avx512.vpermi2var.ps.128
-    1, // llvm.x86.avx512.vpermi2var.ps.256
-    1, // llvm.x86.avx512.vpermi2var.ps.512
-    1, // llvm.x86.avx512.vpermi2var.q.128
-    1, // llvm.x86.avx512.vpermi2var.q.256
-    1, // llvm.x86.avx512.vpermi2var.q.512
-    1, // llvm.x86.avx512.vpermi2var.qi.128
-    1, // llvm.x86.avx512.vpermi2var.qi.256
-    1, // llvm.x86.avx512.vpermi2var.qi.512
-    1, // llvm.x86.avx512.vpermilvar.pd.512
-    1, // llvm.x86.avx512.vpermilvar.ps.512
-    1, // llvm.x86.avx512.vpmadd52h.uq.128
-    1, // llvm.x86.avx512.vpmadd52h.uq.256
-    1, // llvm.x86.avx512.vpmadd52h.uq.512
-    1, // llvm.x86.avx512.vpmadd52l.uq.128
-    1, // llvm.x86.avx512.vpmadd52l.uq.256
-    1, // llvm.x86.avx512.vpmadd52l.uq.512
-    1, // llvm.x86.avx512.vpshufbitqmb.128
-    1, // llvm.x86.avx512.vpshufbitqmb.256
-    1, // llvm.x86.avx512.vpshufbitqmb.512
-    1, // llvm.x86.avx512bf16.cvtne2ps2bf16.128
-    1, // llvm.x86.avx512bf16.cvtne2ps2bf16.256
-    1, // llvm.x86.avx512bf16.cvtne2ps2bf16.512
-    1, // llvm.x86.avx512bf16.cvtneps2bf16.256
-    1, // llvm.x86.avx512bf16.cvtneps2bf16.512
-    1, // llvm.x86.avx512bf16.dpbf16ps.128
-    1, // llvm.x86.avx512bf16.dpbf16ps.256
-    1, // llvm.x86.avx512bf16.dpbf16ps.512
-    1, // llvm.x86.avx512bf16.mask.cvtneps2bf16.128
-    1, // llvm.x86.bmi.bextr.32
-    1, // llvm.x86.bmi.bextr.64
-    1, // llvm.x86.bmi.bzhi.32
-    1, // llvm.x86.bmi.bzhi.64
-    1, // llvm.x86.bmi.pdep.32
-    1, // llvm.x86.bmi.pdep.64
-    1, // llvm.x86.bmi.pext.32
-    1, // llvm.x86.bmi.pext.64
-    3, // llvm.x86.cldemote
-    3, // llvm.x86.clflushopt
-    3, // llvm.x86.clrssbsy
-    3, // llvm.x86.clwb
-    3, // llvm.x86.clzero
-    3, // llvm.x86.directstore32
-    3, // llvm.x86.directstore64
-    3, // llvm.x86.enqcmd
-    3, // llvm.x86.enqcmds
-    3, // llvm.x86.flags.read.u32
-    3, // llvm.x86.flags.read.u64
-    3, // llvm.x86.flags.write.u32
-    3, // llvm.x86.flags.write.u64
-    3, // llvm.x86.fxrstor
-    3, // llvm.x86.fxrstor64
-    3, // llvm.x86.fxsave
-    3, // llvm.x86.fxsave64
-    3, // llvm.x86.incsspd
-    3, // llvm.x86.incsspq
-    101, // llvm.x86.int
-    3, // llvm.x86.invpcid
-    3, // llvm.x86.llwpcb
-    3, // llvm.x86.lwpins32
-    3, // llvm.x86.lwpins64
-    3, // llvm.x86.lwpval32
-    3, // llvm.x86.lwpval64
-    3, // llvm.x86.mmx.emms
-    3, // llvm.x86.mmx.femms
-    3, // llvm.x86.mmx.maskmovq
-    3, // llvm.x86.mmx.movnt.dq
-    1, // llvm.x86.mmx.packssdw
-    1, // llvm.x86.mmx.packsswb
-    1, // llvm.x86.mmx.packuswb
-    1, // llvm.x86.mmx.padd.b
-    1, // llvm.x86.mmx.padd.d
-    1, // llvm.x86.mmx.padd.q
-    1, // llvm.x86.mmx.padd.w
-    1, // llvm.x86.mmx.padds.b
-    1, // llvm.x86.mmx.padds.w
-    1, // llvm.x86.mmx.paddus.b
-    1, // llvm.x86.mmx.paddus.w
-    27, // llvm.x86.mmx.palignr.b
-    1, // llvm.x86.mmx.pand
-    1, // llvm.x86.mmx.pandn
-    1, // llvm.x86.mmx.pavg.b
-    1, // llvm.x86.mmx.pavg.w
-    1, // llvm.x86.mmx.pcmpeq.b
-    1, // llvm.x86.mmx.pcmpeq.d
-    1, // llvm.x86.mmx.pcmpeq.w
-    1, // llvm.x86.mmx.pcmpgt.b
-    1, // llvm.x86.mmx.pcmpgt.d
-    1, // llvm.x86.mmx.pcmpgt.w
-    40, // llvm.x86.mmx.pextr.w
-    27, // llvm.x86.mmx.pinsr.w
-    1, // llvm.x86.mmx.pmadd.wd
-    1, // llvm.x86.mmx.pmaxs.w
-    1, // llvm.x86.mmx.pmaxu.b
-    1, // llvm.x86.mmx.pmins.w
-    1, // llvm.x86.mmx.pminu.b
-    1, // llvm.x86.mmx.pmovmskb
-    1, // llvm.x86.mmx.pmulh.w
-    1, // llvm.x86.mmx.pmulhu.w
-    1, // llvm.x86.mmx.pmull.w
-    1, // llvm.x86.mmx.pmulu.dq
-    1, // llvm.x86.mmx.por
-    1, // llvm.x86.mmx.psad.bw
-    1, // llvm.x86.mmx.psll.d
-    1, // llvm.x86.mmx.psll.q
-    1, // llvm.x86.mmx.psll.w
-    1, // llvm.x86.mmx.pslli.d
-    1, // llvm.x86.mmx.pslli.q
-    1, // llvm.x86.mmx.pslli.w
-    1, // llvm.x86.mmx.psra.d
-    1, // llvm.x86.mmx.psra.w
-    1, // llvm.x86.mmx.psrai.d
-    1, // llvm.x86.mmx.psrai.w
-    1, // llvm.x86.mmx.psrl.d
-    1, // llvm.x86.mmx.psrl.q
-    1, // llvm.x86.mmx.psrl.w
-    1, // llvm.x86.mmx.psrli.d
-    1, // llvm.x86.mmx.psrli.q
-    1, // llvm.x86.mmx.psrli.w
-    1, // llvm.x86.mmx.psub.b
-    1, // llvm.x86.mmx.psub.d
-    1, // llvm.x86.mmx.psub.q
-    1, // llvm.x86.mmx.psub.w
-    1, // llvm.x86.mmx.psubs.b
-    1, // llvm.x86.mmx.psubs.w
-    1, // llvm.x86.mmx.psubus.b
-    1, // llvm.x86.mmx.psubus.w
-    1, // llvm.x86.mmx.punpckhbw
-    1, // llvm.x86.mmx.punpckhdq
-    1, // llvm.x86.mmx.punpckhwd
-    1, // llvm.x86.mmx.punpcklbw
-    1, // llvm.x86.mmx.punpckldq
-    1, // llvm.x86.mmx.punpcklwd
-    1, // llvm.x86.mmx.pxor
-    3, // llvm.x86.monitorx
-    3, // llvm.x86.movdir64b
-    3, // llvm.x86.mwaitx
-    27, // llvm.x86.pclmulqdq
-    27, // llvm.x86.pclmulqdq.256
-    27, // llvm.x86.pclmulqdq.512
-    3, // llvm.x86.ptwrite32
-    3, // llvm.x86.ptwrite64
-    3, // llvm.x86.rdfsbase.32
-    3, // llvm.x86.rdfsbase.64
-    3, // llvm.x86.rdgsbase.32
-    3, // llvm.x86.rdgsbase.64
-    3, // llvm.x86.rdpid
-    3, // llvm.x86.rdpkru
-    3, // llvm.x86.rdpmc
-    3, // llvm.x86.rdrand.16
-    3, // llvm.x86.rdrand.32
-    3, // llvm.x86.rdrand.64
-    3, // llvm.x86.rdseed.16
-    3, // llvm.x86.rdseed.32
-    3, // llvm.x86.rdseed.64
-    3, // llvm.x86.rdsspd
-    3, // llvm.x86.rdsspq
-    3, // llvm.x86.rdtsc
-    3, // llvm.x86.rdtscp
-    3, // llvm.x86.rstorssp
-    3, // llvm.x86.saveprevssp
-    3, // llvm.x86.seh.ehguard
-    3, // llvm.x86.seh.ehregnode
-    1, // llvm.x86.seh.lsda
-    3, // llvm.x86.setssbsy
-    1, // llvm.x86.sha1msg1
-    1, // llvm.x86.sha1msg2
-    1, // llvm.x86.sha1nexte
-    27, // llvm.x86.sha1rnds4
-    1, // llvm.x86.sha256msg1
-    1, // llvm.x86.sha256msg2
-    1, // llvm.x86.sha256rnds2
-    3, // llvm.x86.slwpcb
-    27, // llvm.x86.sse.cmp.ps
-    27, // llvm.x86.sse.cmp.ss
-    1, // llvm.x86.sse.comieq.ss
-    1, // llvm.x86.sse.comige.ss
-    1, // llvm.x86.sse.comigt.ss
-    1, // llvm.x86.sse.comile.ss
-    1, // llvm.x86.sse.comilt.ss
-    1, // llvm.x86.sse.comineq.ss
-    1, // llvm.x86.sse.cvtpd2pi
-    1, // llvm.x86.sse.cvtpi2pd
-    1, // llvm.x86.sse.cvtpi2ps
-    1, // llvm.x86.sse.cvtps2pi
-    1, // llvm.x86.sse.cvtss2si
-    1, // llvm.x86.sse.cvtss2si64
-    1, // llvm.x86.sse.cvttpd2pi
-    1, // llvm.x86.sse.cvttps2pi
-    1, // llvm.x86.sse.cvttss2si
-    1, // llvm.x86.sse.cvttss2si64
-    153, // llvm.x86.sse.ldmxcsr
-    1, // llvm.x86.sse.max.ps
-    1, // llvm.x86.sse.max.ss
-    1, // llvm.x86.sse.min.ps
-    1, // llvm.x86.sse.min.ss
-    1, // llvm.x86.sse.movmsk.ps
-    40, // llvm.x86.sse.pshuf.w
-    1, // llvm.x86.sse.rcp.ps
-    1, // llvm.x86.sse.rcp.ss
-    1, // llvm.x86.sse.rsqrt.ps
-    1, // llvm.x86.sse.rsqrt.ss
-    3, // llvm.x86.sse.sfence
-    126, // llvm.x86.sse.stmxcsr
-    1, // llvm.x86.sse.ucomieq.ss
-    1, // llvm.x86.sse.ucomige.ss
-    1, // llvm.x86.sse.ucomigt.ss
-    1, // llvm.x86.sse.ucomile.ss
-    1, // llvm.x86.sse.ucomilt.ss
-    1, // llvm.x86.sse.ucomineq.ss
-    3, // llvm.x86.sse2.clflush
-    27, // llvm.x86.sse2.cmp.pd
-    27, // llvm.x86.sse2.cmp.sd
-    1, // llvm.x86.sse2.comieq.sd
-    1, // llvm.x86.sse2.comige.sd
-    1, // llvm.x86.sse2.comigt.sd
-    1, // llvm.x86.sse2.comile.sd
-    1, // llvm.x86.sse2.comilt.sd
-    1, // llvm.x86.sse2.comineq.sd
-    1, // llvm.x86.sse2.cvtpd2dq
-    1, // llvm.x86.sse2.cvtpd2ps
-    1, // llvm.x86.sse2.cvtps2dq
-    1, // llvm.x86.sse2.cvtsd2si
-    1, // llvm.x86.sse2.cvtsd2si64
-    1, // llvm.x86.sse2.cvtsd2ss
-    1, // llvm.x86.sse2.cvttpd2dq
-    1, // llvm.x86.sse2.cvttps2dq
-    1, // llvm.x86.sse2.cvttsd2si
-    1, // llvm.x86.sse2.cvttsd2si64
-    3, // llvm.x86.sse2.lfence
-    3, // llvm.x86.sse2.maskmov.dqu
-    1, // llvm.x86.sse2.max.pd
-    1, // llvm.x86.sse2.max.sd
-    3, // llvm.x86.sse2.mfence
-    1, // llvm.x86.sse2.min.pd
-    1, // llvm.x86.sse2.min.sd
-    1, // llvm.x86.sse2.movmsk.pd
-    1, // llvm.x86.sse2.packssdw.128
-    1, // llvm.x86.sse2.packsswb.128
-    1, // llvm.x86.sse2.packuswb.128
-    3, // llvm.x86.sse2.pause
-    1, // llvm.x86.sse2.pavg.b
-    1, // llvm.x86.sse2.pavg.w
-    1, // llvm.x86.sse2.pmadd.wd
-    1, // llvm.x86.sse2.pmovmskb.128
-    1, // llvm.x86.sse2.pmulh.w
-    1, // llvm.x86.sse2.pmulhu.w
-    1, // llvm.x86.sse2.psad.bw
-    1, // llvm.x86.sse2.psll.d
-    1, // llvm.x86.sse2.psll.q
-    1, // llvm.x86.sse2.psll.w
-    1, // llvm.x86.sse2.pslli.d
-    1, // llvm.x86.sse2.pslli.q
-    1, // llvm.x86.sse2.pslli.w
-    1, // llvm.x86.sse2.psra.d
-    1, // llvm.x86.sse2.psra.w
-    1, // llvm.x86.sse2.psrai.d
-    1, // llvm.x86.sse2.psrai.w
-    1, // llvm.x86.sse2.psrl.d
-    1, // llvm.x86.sse2.psrl.q
-    1, // llvm.x86.sse2.psrl.w
-    1, // llvm.x86.sse2.psrli.d
-    1, // llvm.x86.sse2.psrli.q
-    1, // llvm.x86.sse2.psrli.w
-    1, // llvm.x86.sse2.ucomieq.sd
-    1, // llvm.x86.sse2.ucomige.sd
-    1, // llvm.x86.sse2.ucomigt.sd
-    1, // llvm.x86.sse2.ucomile.sd
-    1, // llvm.x86.sse2.ucomilt.sd
-    1, // llvm.x86.sse2.ucomineq.sd
-    1, // llvm.x86.sse3.addsub.pd
-    1, // llvm.x86.sse3.addsub.ps
-    1, // llvm.x86.sse3.hadd.pd
-    1, // llvm.x86.sse3.hadd.ps
-    1, // llvm.x86.sse3.hsub.pd
-    1, // llvm.x86.sse3.hsub.ps
-    18, // llvm.x86.sse3.ldu.dq
-    3, // llvm.x86.sse3.monitor
-    3, // llvm.x86.sse3.mwait
-    1, // llvm.x86.sse41.blendvpd
-    1, // llvm.x86.sse41.blendvps
-    27, // llvm.x86.sse41.dppd
-    27, // llvm.x86.sse41.dpps
-    27, // llvm.x86.sse41.insertps
-    27, // llvm.x86.sse41.mpsadbw
-    1, // llvm.x86.sse41.packusdw
-    1, // llvm.x86.sse41.pblendvb
-    1, // llvm.x86.sse41.phminposuw
-    1, // llvm.x86.sse41.ptestc
-    1, // llvm.x86.sse41.ptestnzc
-    1, // llvm.x86.sse41.ptestz
-    40, // llvm.x86.sse41.round.pd
-    40, // llvm.x86.sse41.round.ps
-    27, // llvm.x86.sse41.round.sd
-    27, // llvm.x86.sse41.round.ss
-    1, // llvm.x86.sse42.crc32.32.16
-    1, // llvm.x86.sse42.crc32.32.32
-    1, // llvm.x86.sse42.crc32.32.8
-    1, // llvm.x86.sse42.crc32.64.64
-    147, // llvm.x86.sse42.pcmpestri128
-    147, // llvm.x86.sse42.pcmpestria128
-    147, // llvm.x86.sse42.pcmpestric128
-    147, // llvm.x86.sse42.pcmpestrio128
-    147, // llvm.x86.sse42.pcmpestris128
-    147, // llvm.x86.sse42.pcmpestriz128
-    147, // llvm.x86.sse42.pcmpestrm128
-    27, // llvm.x86.sse42.pcmpistri128
-    27, // llvm.x86.sse42.pcmpistria128
-    27, // llvm.x86.sse42.pcmpistric128
-    27, // llvm.x86.sse42.pcmpistrio128
-    27, // llvm.x86.sse42.pcmpistris128
-    27, // llvm.x86.sse42.pcmpistriz128
-    27, // llvm.x86.sse42.pcmpistrm128
-    1, // llvm.x86.sse4a.extrq
-    39, // llvm.x86.sse4a.extrqi
-    1, // llvm.x86.sse4a.insertq
-    124, // llvm.x86.sse4a.insertqi
-    1, // llvm.x86.ssse3.pabs.b
-    1, // llvm.x86.ssse3.pabs.d
-    1, // llvm.x86.ssse3.pabs.w
-    1, // llvm.x86.ssse3.phadd.d
-    1, // llvm.x86.ssse3.phadd.d.128
-    1, // llvm.x86.ssse3.phadd.sw
-    1, // llvm.x86.ssse3.phadd.sw.128
-    1, // llvm.x86.ssse3.phadd.w
-    1, // llvm.x86.ssse3.phadd.w.128
-    1, // llvm.x86.ssse3.phsub.d
-    1, // llvm.x86.ssse3.phsub.d.128
-    1, // llvm.x86.ssse3.phsub.sw
-    1, // llvm.x86.ssse3.phsub.sw.128
-    1, // llvm.x86.ssse3.phsub.w
-    1, // llvm.x86.ssse3.phsub.w.128
-    1, // llvm.x86.ssse3.pmadd.ub.sw
-    1, // llvm.x86.ssse3.pmadd.ub.sw.128
-    1, // llvm.x86.ssse3.pmul.hr.sw
-    1, // llvm.x86.ssse3.pmul.hr.sw.128
-    1, // llvm.x86.ssse3.pshuf.b
-    1, // llvm.x86.ssse3.pshuf.b.128
-    1, // llvm.x86.ssse3.psign.b
-    1, // llvm.x86.ssse3.psign.b.128
-    1, // llvm.x86.ssse3.psign.d
-    1, // llvm.x86.ssse3.psign.d.128
-    1, // llvm.x86.ssse3.psign.w
-    1, // llvm.x86.ssse3.psign.w.128
-    1, // llvm.x86.subborrow.32
-    1, // llvm.x86.subborrow.64
-    40, // llvm.x86.tbm.bextri.u32
-    40, // llvm.x86.tbm.bextri.u64
-    3, // llvm.x86.tpause
-    3, // llvm.x86.umonitor
-    3, // llvm.x86.umwait
-    1, // llvm.x86.vcvtph2ps.128
-    1, // llvm.x86.vcvtph2ps.256
-    40, // llvm.x86.vcvtps2ph.128
-    40, // llvm.x86.vcvtps2ph.256
-    27, // llvm.x86.vgf2p8affineinvqb.128
-    27, // llvm.x86.vgf2p8affineinvqb.256
-    27, // llvm.x86.vgf2p8affineinvqb.512
-    27, // llvm.x86.vgf2p8affineqb.128
-    27, // llvm.x86.vgf2p8affineqb.256
-    27, // llvm.x86.vgf2p8affineqb.512
-    1, // llvm.x86.vgf2p8mulb.128
-    1, // llvm.x86.vgf2p8mulb.256
-    1, // llvm.x86.vgf2p8mulb.512
-    3, // llvm.x86.wbinvd
-    3, // llvm.x86.wbnoinvd
-    3, // llvm.x86.wrfsbase.32
-    3, // llvm.x86.wrfsbase.64
-    3, // llvm.x86.wrgsbase.32
-    3, // llvm.x86.wrgsbase.64
-    3, // llvm.x86.wrpkru
-    3, // llvm.x86.wrssd
-    3, // llvm.x86.wrssq
-    3, // llvm.x86.wrussd
-    3, // llvm.x86.wrussq
-    101, // llvm.x86.xabort
-    3, // llvm.x86.xbegin
-    3, // llvm.x86.xend
-    3, // llvm.x86.xgetbv
-    1, // llvm.x86.xop.vfrcz.pd
-    1, // llvm.x86.xop.vfrcz.pd.256
-    1, // llvm.x86.xop.vfrcz.ps
-    1, // llvm.x86.xop.vfrcz.ps.256
-    1, // llvm.x86.xop.vfrcz.sd
-    1, // llvm.x86.xop.vfrcz.ss
-    125, // llvm.x86.xop.vpermil2pd
-    125, // llvm.x86.xop.vpermil2pd.256
-    125, // llvm.x86.xop.vpermil2ps
-    125, // llvm.x86.xop.vpermil2ps.256
-    1, // llvm.x86.xop.vphaddbd
-    1, // llvm.x86.xop.vphaddbq
-    1, // llvm.x86.xop.vphaddbw
-    1, // llvm.x86.xop.vphadddq
-    1, // llvm.x86.xop.vphaddubd
-    1, // llvm.x86.xop.vphaddubq
-    1, // llvm.x86.xop.vphaddubw
-    1, // llvm.x86.xop.vphaddudq
-    1, // llvm.x86.xop.vphadduwd
-    1, // llvm.x86.xop.vphadduwq
-    1, // llvm.x86.xop.vphaddwd
-    1, // llvm.x86.xop.vphaddwq
-    1, // llvm.x86.xop.vphsubbw
-    1, // llvm.x86.xop.vphsubdq
-    1, // llvm.x86.xop.vphsubwd
-    1, // llvm.x86.xop.vpmacsdd
-    1, // llvm.x86.xop.vpmacsdqh
-    1, // llvm.x86.xop.vpmacsdql
-    1, // llvm.x86.xop.vpmacssdd
-    1, // llvm.x86.xop.vpmacssdqh
-    1, // llvm.x86.xop.vpmacssdql
-    1, // llvm.x86.xop.vpmacsswd
-    1, // llvm.x86.xop.vpmacssww
-    1, // llvm.x86.xop.vpmacswd
-    1, // llvm.x86.xop.vpmacsww
-    1, // llvm.x86.xop.vpmadcsswd
-    1, // llvm.x86.xop.vpmadcswd
-    1, // llvm.x86.xop.vpperm
-    1, // llvm.x86.xop.vpshab
-    1, // llvm.x86.xop.vpshad
-    1, // llvm.x86.xop.vpshaq
-    1, // llvm.x86.xop.vpshaw
-    1, // llvm.x86.xop.vpshlb
-    1, // llvm.x86.xop.vpshld
-    1, // llvm.x86.xop.vpshlq
-    1, // llvm.x86.xop.vpshlw
-    3, // llvm.x86.xrstor
-    3, // llvm.x86.xrstor64
-    3, // llvm.x86.xrstors
-    3, // llvm.x86.xrstors64
-    3, // llvm.x86.xsave
-    3, // llvm.x86.xsave64
-    3, // llvm.x86.xsavec
-    3, // llvm.x86.xsavec64
-    3, // llvm.x86.xsaveopt
-    3, // llvm.x86.xsaveopt64
-    3, // llvm.x86.xsaves
-    3, // llvm.x86.xsaves64
-    3, // llvm.x86.xsetbv
-    3, // llvm.x86.xtest
-    1, // llvm.xcore.bitrev
-    3, // llvm.xcore.checkevent
-    154, // llvm.xcore.chkct
-    3, // llvm.xcore.clre
-    154, // llvm.xcore.clrpt
-    3, // llvm.xcore.clrsr
-    1, // llvm.xcore.crc32
-    1, // llvm.xcore.crc8
-    154, // llvm.xcore.edu
-    154, // llvm.xcore.eeu
-    154, // llvm.xcore.endin
-    154, // llvm.xcore.freer
-    3, // llvm.xcore.geted
-    3, // llvm.xcore.getet
-    1, // llvm.xcore.getid
-    3, // llvm.xcore.getps
-    3, // llvm.xcore.getr
-    154, // llvm.xcore.getst
-    154, // llvm.xcore.getts
-    154, // llvm.xcore.in
-    154, // llvm.xcore.inct
-    154, // llvm.xcore.initcp
-    154, // llvm.xcore.initdp
-    154, // llvm.xcore.initlr
-    154, // llvm.xcore.initpc
-    154, // llvm.xcore.initsp
-    154, // llvm.xcore.inshr
-    154, // llvm.xcore.int
-    154, // llvm.xcore.mjoin
-    154, // llvm.xcore.msync
-    154, // llvm.xcore.out
-    154, // llvm.xcore.outct
-    154, // llvm.xcore.outshr
-    154, // llvm.xcore.outt
-    154, // llvm.xcore.peek
-    154, // llvm.xcore.setc
-    155, // llvm.xcore.setclk
-    154, // llvm.xcore.setd
-    154, // llvm.xcore.setev
-    3, // llvm.xcore.setps
-    154, // llvm.xcore.setpsc
-    154, // llvm.xcore.setpt
-    155, // llvm.xcore.setrdy
-    3, // llvm.xcore.setsr
-    154, // llvm.xcore.settw
-    154, // llvm.xcore.setv
-    1, // llvm.xcore.sext
-    3, // llvm.xcore.ssync
-    154, // llvm.xcore.syncr
-    154, // llvm.xcore.testct
-    154, // llvm.xcore.testwct
-    18, // llvm.xcore.waitevent
-    1, // llvm.xcore.zext
+    32, // llvm.lifetime.end
+    32, // llvm.lifetime.start
+    6, // llvm.llrint
+    6, // llvm.llround
+    34, // llvm.load.relative
+    2, // llvm.localaddress
+    4, // llvm.localescape
+    25, // llvm.localrecover
+    6, // llvm.log
+    6, // llvm.log10
+    6, // llvm.log2
+    35, // llvm.loop.decrement
+    35, // llvm.loop.decrement.reg
+    6, // llvm.lrint
+    6, // llvm.lround
+    36, // llvm.masked.compressstore
+    37, // llvm.masked.expandload
+    38, // llvm.masked.gather
+    39, // llvm.masked.load
+    40, // llvm.masked.scatter
+    41, // llvm.masked.store
+    42, // llvm.matrix.column.major.load
+    43, // llvm.matrix.column.major.store
+    44, // llvm.matrix.multiply
+    45, // llvm.matrix.transpose
+    6, // llvm.maximum
+    6, // llvm.maxnum
+    46, // llvm.memcpy
+    47, // llvm.memcpy.element.unordered.atomic
+    48, // llvm.memcpy.inline
+    49, // llvm.memmove
+    47, // llvm.memmove.element.unordered.atomic
+    50, // llvm.memset
+    51, // llvm.memset.element.unordered.atomic
+    6, // llvm.minimum
+    6, // llvm.minnum
+    6, // llvm.nearbyint
+    7, // llvm.objc.arc.annotation.bottomup.bbend
+    7, // llvm.objc.arc.annotation.bottomup.bbstart
+    7, // llvm.objc.arc.annotation.topdown.bbend
+    7, // llvm.objc.arc.annotation.topdown.bbstart
+    7, // llvm.objc.autorelease
+    7, // llvm.objc.autoreleasePoolPop
+    7, // llvm.objc.autoreleasePoolPush
+    7, // llvm.objc.autoreleaseReturnValue
+    7, // llvm.objc.clang.arc.use
+    7, // llvm.objc.copyWeak
+    7, // llvm.objc.destroyWeak
+    7, // llvm.objc.initWeak
+    7, // llvm.objc.loadWeak
+    7, // llvm.objc.loadWeakRetained
+    7, // llvm.objc.moveWeak
+    7, // llvm.objc.release
+    7, // llvm.objc.retain
+    7, // llvm.objc.retain.autorelease
+    7, // llvm.objc.retainAutorelease
+    7, // llvm.objc.retainAutoreleaseReturnValue
+    7, // llvm.objc.retainAutoreleasedReturnValue
+    7, // llvm.objc.retainBlock
+    7, // llvm.objc.retainedObject
+    7, // llvm.objc.storeStrong
+    7, // llvm.objc.storeWeak
+    7, // llvm.objc.sync.enter
+    7, // llvm.objc.sync.exit
+    7, // llvm.objc.unretainedObject
+    7, // llvm.objc.unretainedPointer
+    7, // llvm.objc.unsafeClaimAutoreleasedReturnValue
+    52, // llvm.objectsize
+    4, // llvm.pcmarker
+    6, // llvm.pow
+    6, // llvm.powi
+    53, // llvm.prefetch
+    54, // llvm.preserve.array.access.index
+    54, // llvm.preserve.struct.access.index
+    24, // llvm.preserve.union.access.index
+    55, // llvm.pseudoprobe
+    4, // llvm.ptr.annotation
+    6, // llvm.ptrmask
+    21, // llvm.read_register
+    56, // llvm.read_volatile_register
+    4, // llvm.readcyclecounter
+    27, // llvm.returnaddress
+    6, // llvm.rint
+    6, // llvm.round
+    6, // llvm.roundeven
+    6, // llvm.sadd.sat
+    6, // llvm.sadd.with.overflow
+    25, // llvm.sdiv.fix
+    25, // llvm.sdiv.fix.sat
+    35, // llvm.set.loop.iterations
+    19, // llvm.sideeffect
+    6, // llvm.sin
+    6, // llvm.smax
+    6, // llvm.smin
+    57, // llvm.smul.fix
+    57, // llvm.smul.fix.sat
+    6, // llvm.smul.with.overflow
+    2, // llvm.sponentry
+    6, // llvm.sqrt
+    58, // llvm.ssa.copy
+    6, // llvm.sshl.sat
+    6, // llvm.ssub.sat
+    6, // llvm.ssub.with.overflow
+    4, // llvm.stackguard
+    4, // llvm.stackprotector
+    4, // llvm.stackrestore
+    4, // llvm.stacksave
+    35, // llvm.start.loop.iterations
+    6, // llvm.strip.invariant.group
+    35, // llvm.test.set.loop.iterations
+    2, // llvm.thread.pointer
+    59, // llvm.trap
+    6, // llvm.trunc
+    2, // llvm.type.checked.load
+    2, // llvm.type.test
+    6, // llvm.uadd.sat
+    6, // llvm.uadd.with.overflow
+    60, // llvm.ubsantrap
+    25, // llvm.udiv.fix
+    25, // llvm.udiv.fix.sat
+    6, // llvm.umax
+    6, // llvm.umin
+    57, // llvm.umul.fix
+    57, // llvm.umul.fix.sat
+    6, // llvm.umul.with.overflow
+    6, // llvm.ushl.sat
+    6, // llvm.usub.sat
+    6, // llvm.usub.with.overflow
+    4, // llvm.va_copy
+    4, // llvm.va_end
+    4, // llvm.va_start
+    4, // llvm.var.annotation
+    2, // llvm.vector.reduce.add
+    2, // llvm.vector.reduce.and
+    2, // llvm.vector.reduce.fadd
+    2, // llvm.vector.reduce.fmax
+    2, // llvm.vector.reduce.fmin
+    2, // llvm.vector.reduce.fmul
+    2, // llvm.vector.reduce.mul
+    2, // llvm.vector.reduce.or
+    2, // llvm.vector.reduce.smax
+    2, // llvm.vector.reduce.smin
+    2, // llvm.vector.reduce.umax
+    2, // llvm.vector.reduce.umin
+    2, // llvm.vector.reduce.xor
+    6, // llvm.vp.add
+    6, // llvm.vp.and
+    6, // llvm.vp.ashr
+    6, // llvm.vp.lshr
+    6, // llvm.vp.mul
+    6, // llvm.vp.or
+    2, // llvm.vp.sdiv
+    6, // llvm.vp.shl
+    2, // llvm.vp.srem
+    6, // llvm.vp.sub
+    2, // llvm.vp.udiv
+    2, // llvm.vp.urem
+    6, // llvm.vp.xor
+    2, // llvm.vscale
+    7, // llvm.write_register
+    61, // llvm.xray.customevent
+    62, // llvm.xray.typedevent
+    12, // llvm.aarch64.addg
+    7, // llvm.aarch64.clrex
+    12, // llvm.aarch64.cls
+    12, // llvm.aarch64.cls64
+    12, // llvm.aarch64.crc32b
+    12, // llvm.aarch64.crc32cb
+    12, // llvm.aarch64.crc32ch
+    12, // llvm.aarch64.crc32cw
+    12, // llvm.aarch64.crc32cx
+    12, // llvm.aarch64.crc32h
+    12, // llvm.aarch64.crc32w
+    12, // llvm.aarch64.crc32x
+    12, // llvm.aarch64.crypto.aesd
+    12, // llvm.aarch64.crypto.aese
+    12, // llvm.aarch64.crypto.aesimc
+    12, // llvm.aarch64.crypto.aesmc
+    12, // llvm.aarch64.crypto.sha1c
+    12, // llvm.aarch64.crypto.sha1h
+    12, // llvm.aarch64.crypto.sha1m
+    12, // llvm.aarch64.crypto.sha1p
+    12, // llvm.aarch64.crypto.sha1su0
+    12, // llvm.aarch64.crypto.sha1su1
+    12, // llvm.aarch64.crypto.sha256h
+    12, // llvm.aarch64.crypto.sha256h2
+    12, // llvm.aarch64.crypto.sha256su0
+    12, // llvm.aarch64.crypto.sha256su1
+    7, // llvm.aarch64.dmb
+    7, // llvm.aarch64.dsb
+    12, // llvm.aarch64.fjcvtzs
+    63, // llvm.aarch64.get.fpcr
+    12, // llvm.aarch64.gmi
+    7, // llvm.aarch64.hint
+    63, // llvm.aarch64.irg
+    63, // llvm.aarch64.irg.sp
+    7, // llvm.aarch64.isb
+    7, // llvm.aarch64.ld64b
+    7, // llvm.aarch64.ldaxp
+    7, // llvm.aarch64.ldaxr
+    21, // llvm.aarch64.ldg
+    7, // llvm.aarch64.ldxp
+    7, // llvm.aarch64.ldxr
+    12, // llvm.aarch64.neon.abs
+    12, // llvm.aarch64.neon.addhn
+    12, // llvm.aarch64.neon.addp
+    12, // llvm.aarch64.neon.bfcvt
+    12, // llvm.aarch64.neon.bfcvtn
+    12, // llvm.aarch64.neon.bfcvtn2
+    12, // llvm.aarch64.neon.bfdot
+    12, // llvm.aarch64.neon.bfmlalb
+    12, // llvm.aarch64.neon.bfmlalt
+    12, // llvm.aarch64.neon.bfmmla
+    12, // llvm.aarch64.neon.cls
+    12, // llvm.aarch64.neon.fabd
+    12, // llvm.aarch64.neon.facge
+    12, // llvm.aarch64.neon.facgt
+    12, // llvm.aarch64.neon.faddp
+    12, // llvm.aarch64.neon.faddv
+    12, // llvm.aarch64.neon.fcvtas
+    12, // llvm.aarch64.neon.fcvtau
+    12, // llvm.aarch64.neon.fcvtms
+    12, // llvm.aarch64.neon.fcvtmu
+    12, // llvm.aarch64.neon.fcvtns
+    12, // llvm.aarch64.neon.fcvtnu
+    12, // llvm.aarch64.neon.fcvtps
+    12, // llvm.aarch64.neon.fcvtpu
+    12, // llvm.aarch64.neon.fcvtxn
+    12, // llvm.aarch64.neon.fcvtzs
+    12, // llvm.aarch64.neon.fcvtzu
+    12, // llvm.aarch64.neon.fmax
+    12, // llvm.aarch64.neon.fmaxnm
+    12, // llvm.aarch64.neon.fmaxnmp
+    12, // llvm.aarch64.neon.fmaxnmv
+    12, // llvm.aarch64.neon.fmaxp
+    12, // llvm.aarch64.neon.fmaxv
+    12, // llvm.aarch64.neon.fmin
+    12, // llvm.aarch64.neon.fminnm
+    12, // llvm.aarch64.neon.fminnmp
+    12, // llvm.aarch64.neon.fminnmv
+    12, // llvm.aarch64.neon.fminp
+    12, // llvm.aarch64.neon.fminv
+    12, // llvm.aarch64.neon.fmlal
+    12, // llvm.aarch64.neon.fmlal2
+    12, // llvm.aarch64.neon.fmlsl
+    12, // llvm.aarch64.neon.fmlsl2
+    12, // llvm.aarch64.neon.fmulx
+    12, // llvm.aarch64.neon.frecpe
+    12, // llvm.aarch64.neon.frecps
+    12, // llvm.aarch64.neon.frecpx
+    12, // llvm.aarch64.neon.frintn
+    12, // llvm.aarch64.neon.frsqrte
+    12, // llvm.aarch64.neon.frsqrts
+    3, // llvm.aarch64.neon.ld1x2
+    3, // llvm.aarch64.neon.ld1x3
+    3, // llvm.aarch64.neon.ld1x4
+    3, // llvm.aarch64.neon.ld2
+    3, // llvm.aarch64.neon.ld2lane
+    3, // llvm.aarch64.neon.ld2r
+    3, // llvm.aarch64.neon.ld3
+    3, // llvm.aarch64.neon.ld3lane
+    3, // llvm.aarch64.neon.ld3r
+    3, // llvm.aarch64.neon.ld4
+    3, // llvm.aarch64.neon.ld4lane
+    3, // llvm.aarch64.neon.ld4r
+    12, // llvm.aarch64.neon.pmul
+    12, // llvm.aarch64.neon.pmull
+    12, // llvm.aarch64.neon.pmull64
+    12, // llvm.aarch64.neon.raddhn
+    12, // llvm.aarch64.neon.rbit
+    12, // llvm.aarch64.neon.rshrn
+    12, // llvm.aarch64.neon.rsubhn
+    12, // llvm.aarch64.neon.sabd
+    12, // llvm.aarch64.neon.saddlp
+    12, // llvm.aarch64.neon.saddlv
+    12, // llvm.aarch64.neon.saddv
+    12, // llvm.aarch64.neon.scalar.sqxtn
+    12, // llvm.aarch64.neon.scalar.sqxtun
+    12, // llvm.aarch64.neon.scalar.uqxtn
+    12, // llvm.aarch64.neon.sdot
+    12, // llvm.aarch64.neon.shadd
+    12, // llvm.aarch64.neon.shll
+    12, // llvm.aarch64.neon.shsub
+    12, // llvm.aarch64.neon.smax
+    12, // llvm.aarch64.neon.smaxp
+    12, // llvm.aarch64.neon.smaxv
+    12, // llvm.aarch64.neon.smin
+    12, // llvm.aarch64.neon.sminp
+    12, // llvm.aarch64.neon.sminv
+    12, // llvm.aarch64.neon.smmla
+    12, // llvm.aarch64.neon.smull
+    12, // llvm.aarch64.neon.sqabs
+    12, // llvm.aarch64.neon.sqadd
+    12, // llvm.aarch64.neon.sqdmulh
+    12, // llvm.aarch64.neon.sqdmulh.lane
+    12, // llvm.aarch64.neon.sqdmulh.laneq
+    12, // llvm.aarch64.neon.sqdmull
+    12, // llvm.aarch64.neon.sqdmulls.scalar
+    12, // llvm.aarch64.neon.sqneg
+    12, // llvm.aarch64.neon.sqrdmulh
+    12, // llvm.aarch64.neon.sqrdmulh.lane
+    12, // llvm.aarch64.neon.sqrdmulh.laneq
+    12, // llvm.aarch64.neon.sqrshl
+    12, // llvm.aarch64.neon.sqrshrn
+    12, // llvm.aarch64.neon.sqrshrun
+    12, // llvm.aarch64.neon.sqshl
+    12, // llvm.aarch64.neon.sqshlu
+    12, // llvm.aarch64.neon.sqshrn
+    12, // llvm.aarch64.neon.sqshrun
+    12, // llvm.aarch64.neon.sqsub
+    12, // llvm.aarch64.neon.sqxtn
+    12, // llvm.aarch64.neon.sqxtun
+    12, // llvm.aarch64.neon.srhadd
+    12, // llvm.aarch64.neon.srshl
+    12, // llvm.aarch64.neon.sshl
+    12, // llvm.aarch64.neon.sshll
+    64, // llvm.aarch64.neon.st1x2
+    65, // llvm.aarch64.neon.st1x3
+    66, // llvm.aarch64.neon.st1x4
+    64, // llvm.aarch64.neon.st2
+    65, // llvm.aarch64.neon.st2lane
+    65, // llvm.aarch64.neon.st3
+    66, // llvm.aarch64.neon.st3lane
+    66, // llvm.aarch64.neon.st4
+    67, // llvm.aarch64.neon.st4lane
+    12, // llvm.aarch64.neon.subhn
+    12, // llvm.aarch64.neon.suqadd
+    12, // llvm.aarch64.neon.tbl1
+    12, // llvm.aarch64.neon.tbl2
+    12, // llvm.aarch64.neon.tbl3
+    12, // llvm.aarch64.neon.tbl4
+    12, // llvm.aarch64.neon.tbx1
+    12, // llvm.aarch64.neon.tbx2
+    12, // llvm.aarch64.neon.tbx3
+    12, // llvm.aarch64.neon.tbx4
+    12, // llvm.aarch64.neon.uabd
+    12, // llvm.aarch64.neon.uaddlp
+    12, // llvm.aarch64.neon.uaddlv
+    12, // llvm.aarch64.neon.uaddv
+    12, // llvm.aarch64.neon.udot
+    12, // llvm.aarch64.neon.uhadd
+    12, // llvm.aarch64.neon.uhsub
+    12, // llvm.aarch64.neon.umax
+    12, // llvm.aarch64.neon.umaxp
+    12, // llvm.aarch64.neon.umaxv
+    12, // llvm.aarch64.neon.umin
+    12, // llvm.aarch64.neon.uminp
+    12, // llvm.aarch64.neon.uminv
+    12, // llvm.aarch64.neon.ummla
+    12, // llvm.aarch64.neon.umull
+    12, // llvm.aarch64.neon.uqadd
+    12, // llvm.aarch64.neon.uqrshl
+    12, // llvm.aarch64.neon.uqrshrn
+    12, // llvm.aarch64.neon.uqshl
+    12, // llvm.aarch64.neon.uqshrn
+    12, // llvm.aarch64.neon.uqsub
+    12, // llvm.aarch64.neon.uqxtn
+    12, // llvm.aarch64.neon.urecpe
+    12, // llvm.aarch64.neon.urhadd
+    12, // llvm.aarch64.neon.urshl
+    12, // llvm.aarch64.neon.ursqrte
+    12, // llvm.aarch64.neon.usdot
+    12, // llvm.aarch64.neon.ushl
+    12, // llvm.aarch64.neon.ushll
+    12, // llvm.aarch64.neon.usmmla
+    12, // llvm.aarch64.neon.usqadd
+    12, // llvm.aarch64.neon.vcadd.rot270
+    12, // llvm.aarch64.neon.vcadd.rot90
+    12, // llvm.aarch64.neon.vcmla.rot0
+    12, // llvm.aarch64.neon.vcmla.rot180
+    12, // llvm.aarch64.neon.vcmla.rot270
+    12, // llvm.aarch64.neon.vcmla.rot90
+    12, // llvm.aarch64.neon.vcopy.lane
+    12, // llvm.aarch64.neon.vcvtfp2fxs
+    12, // llvm.aarch64.neon.vcvtfp2fxu
+    12, // llvm.aarch64.neon.vcvtfp2hf
+    12, // llvm.aarch64.neon.vcvtfxs2fp
+    12, // llvm.aarch64.neon.vcvtfxu2fp
+    12, // llvm.aarch64.neon.vcvthf2fp
+    12, // llvm.aarch64.neon.vsli
+    12, // llvm.aarch64.neon.vsri
+    12, // llvm.aarch64.sdiv
+    68, // llvm.aarch64.settag
+    68, // llvm.aarch64.settag.zero
+    12, // llvm.aarch64.sisd.fabd
+    12, // llvm.aarch64.sisd.fcvtxn
+    7, // llvm.aarch64.space
+    7, // llvm.aarch64.st64b
+    7, // llvm.aarch64.st64bv
+    7, // llvm.aarch64.st64bv0
+    69, // llvm.aarch64.stg
+    68, // llvm.aarch64.stgp
+    7, // llvm.aarch64.stlxp
+    7, // llvm.aarch64.stlxr
+    7, // llvm.aarch64.stxp
+    7, // llvm.aarch64.stxr
+    12, // llvm.aarch64.subp
+    12, // llvm.aarch64.sve.abs
+    12, // llvm.aarch64.sve.adclb
+    12, // llvm.aarch64.sve.adclt
+    12, // llvm.aarch64.sve.add
+    12, // llvm.aarch64.sve.addhnb
+    12, // llvm.aarch64.sve.addhnt
+    12, // llvm.aarch64.sve.addp
+    12, // llvm.aarch64.sve.adrb
+    12, // llvm.aarch64.sve.adrd
+    12, // llvm.aarch64.sve.adrh
+    12, // llvm.aarch64.sve.adrw
+    12, // llvm.aarch64.sve.aesd
+    12, // llvm.aarch64.sve.aese
+    12, // llvm.aarch64.sve.aesimc
+    12, // llvm.aarch64.sve.aesmc
+    12, // llvm.aarch64.sve.and
+    12, // llvm.aarch64.sve.and.z
+    12, // llvm.aarch64.sve.andv
+    12, // llvm.aarch64.sve.asr
+    12, // llvm.aarch64.sve.asr.wide
+    70, // llvm.aarch64.sve.asrd
+    12, // llvm.aarch64.sve.bcax
+    12, // llvm.aarch64.sve.bdep.x
+    12, // llvm.aarch64.sve.bext.x
+    12, // llvm.aarch64.sve.bfdot
+    71, // llvm.aarch64.sve.bfdot.lane
+    12, // llvm.aarch64.sve.bfmlalb
+    71, // llvm.aarch64.sve.bfmlalb.lane
+    12, // llvm.aarch64.sve.bfmlalt
+    71, // llvm.aarch64.sve.bfmlalt.lane
+    12, // llvm.aarch64.sve.bfmmla
+    12, // llvm.aarch64.sve.bgrp.x
+    12, // llvm.aarch64.sve.bic
+    12, // llvm.aarch64.sve.bic.z
+    12, // llvm.aarch64.sve.brka
+    12, // llvm.aarch64.sve.brka.z
+    12, // llvm.aarch64.sve.brkb
+    12, // llvm.aarch64.sve.brkb.z
+    12, // llvm.aarch64.sve.brkn.z
+    12, // llvm.aarch64.sve.brkpa.z
+    12, // llvm.aarch64.sve.brkpb.z
+    12, // llvm.aarch64.sve.bsl
+    12, // llvm.aarch64.sve.bsl1n
+    12, // llvm.aarch64.sve.bsl2n
+    70, // llvm.aarch64.sve.cadd.x
+    71, // llvm.aarch64.sve.cdot
+    72, // llvm.aarch64.sve.cdot.lane
+    12, // llvm.aarch64.sve.clasta
+    12, // llvm.aarch64.sve.clasta.n
+    12, // llvm.aarch64.sve.clastb
+    12, // llvm.aarch64.sve.clastb.n
+    12, // llvm.aarch64.sve.cls
+    12, // llvm.aarch64.sve.clz
+    72, // llvm.aarch64.sve.cmla.lane.x
+    71, // llvm.aarch64.sve.cmla.x
+    12, // llvm.aarch64.sve.cmpeq
+    12, // llvm.aarch64.sve.cmpeq.wide
+    12, // llvm.aarch64.sve.cmpge
+    12, // llvm.aarch64.sve.cmpge.wide
+    12, // llvm.aarch64.sve.cmpgt
+    12, // llvm.aarch64.sve.cmpgt.wide
+    12, // llvm.aarch64.sve.cmphi
+    12, // llvm.aarch64.sve.cmphi.wide
+    12, // llvm.aarch64.sve.cmphs
+    12, // llvm.aarch64.sve.cmphs.wide
+    12, // llvm.aarch64.sve.cmple.wide
+    12, // llvm.aarch64.sve.cmplo.wide
+    12, // llvm.aarch64.sve.cmpls.wide
+    12, // llvm.aarch64.sve.cmplt.wide
+    12, // llvm.aarch64.sve.cmpne
+    12, // llvm.aarch64.sve.cmpne.wide
+    12, // llvm.aarch64.sve.cnot
+    12, // llvm.aarch64.sve.cnt
+    73, // llvm.aarch64.sve.cntb
+    73, // llvm.aarch64.sve.cntd
+    73, // llvm.aarch64.sve.cnth
+    12, // llvm.aarch64.sve.cntp
+    73, // llvm.aarch64.sve.cntw
+    12, // llvm.aarch64.sve.compact
+    12, // llvm.aarch64.sve.convert.from.svbool
+    12, // llvm.aarch64.sve.convert.to.svbool
+    12, // llvm.aarch64.sve.dup
+    12, // llvm.aarch64.sve.dup.x
+    12, // llvm.aarch64.sve.dupq.lane
+    12, // llvm.aarch64.sve.eor
+    12, // llvm.aarch64.sve.eor.z
+    12, // llvm.aarch64.sve.eor3
+    12, // llvm.aarch64.sve.eorbt
+    12, // llvm.aarch64.sve.eortb
+    12, // llvm.aarch64.sve.eorv
+    70, // llvm.aarch64.sve.ext
+    12, // llvm.aarch64.sve.fabd
+    12, // llvm.aarch64.sve.fabs
+    12, // llvm.aarch64.sve.facge
+    12, // llvm.aarch64.sve.facgt
+    12, // llvm.aarch64.sve.fadd
+    12, // llvm.aarch64.sve.fadda
+    12, // llvm.aarch64.sve.faddp
+    12, // llvm.aarch64.sve.faddv
+    71, // llvm.aarch64.sve.fcadd
+    74, // llvm.aarch64.sve.fcmla
+    72, // llvm.aarch64.sve.fcmla.lane
+    12, // llvm.aarch64.sve.fcmpeq
+    12, // llvm.aarch64.sve.fcmpge
+    12, // llvm.aarch64.sve.fcmpgt
+    12, // llvm.aarch64.sve.fcmpne
+    12, // llvm.aarch64.sve.fcmpuo
+    12, // llvm.aarch64.sve.fcvt
+    12, // llvm.aarch64.sve.fcvt.bf16f32
+    12, // llvm.aarch64.sve.fcvt.f16f32
+    12, // llvm.aarch64.sve.fcvt.f16f64
+    12, // llvm.aarch64.sve.fcvt.f32f16
+    12, // llvm.aarch64.sve.fcvt.f32f64
+    12, // llvm.aarch64.sve.fcvt.f64f16
+    12, // llvm.aarch64.sve.fcvt.f64f32
+    12, // llvm.aarch64.sve.fcvtlt.f32f16
+    12, // llvm.aarch64.sve.fcvtlt.f64f32
+    12, // llvm.aarch64.sve.fcvtnt.bf16f32
+    12, // llvm.aarch64.sve.fcvtnt.f16f32
+    12, // llvm.aarch64.sve.fcvtnt.f32f64
+    12, // llvm.aarch64.sve.fcvtx.f32f64
+    12, // llvm.aarch64.sve.fcvtxnt.f32f64
+    12, // llvm.aarch64.sve.fcvtzs
+    12, // llvm.aarch64.sve.fcvtzs.i32f16
+    12, // llvm.aarch64.sve.fcvtzs.i32f64
+    12, // llvm.aarch64.sve.fcvtzs.i64f16
+    12, // llvm.aarch64.sve.fcvtzs.i64f32
+    12, // llvm.aarch64.sve.fcvtzu
+    12, // llvm.aarch64.sve.fcvtzu.i32f16
+    12, // llvm.aarch64.sve.fcvtzu.i32f64
+    12, // llvm.aarch64.sve.fcvtzu.i64f16
+    12, // llvm.aarch64.sve.fcvtzu.i64f32
+    12, // llvm.aarch64.sve.fdiv
+    12, // llvm.aarch64.sve.fdivr
+    12, // llvm.aarch64.sve.fexpa.x
+    12, // llvm.aarch64.sve.flogb
+    12, // llvm.aarch64.sve.fmad
+    12, // llvm.aarch64.sve.fmax
+    12, // llvm.aarch64.sve.fmaxnm
+    12, // llvm.aarch64.sve.fmaxnmp
+    12, // llvm.aarch64.sve.fmaxnmv
+    12, // llvm.aarch64.sve.fmaxp
+    12, // llvm.aarch64.sve.fmaxv
+    12, // llvm.aarch64.sve.fmin
+    12, // llvm.aarch64.sve.fminnm
+    12, // llvm.aarch64.sve.fminnmp
+    12, // llvm.aarch64.sve.fminnmv
+    12, // llvm.aarch64.sve.fminp
+    12, // llvm.aarch64.sve.fminv
+    12, // llvm.aarch64.sve.fmla
+    71, // llvm.aarch64.sve.fmla.lane
+    12, // llvm.aarch64.sve.fmlalb
+    71, // llvm.aarch64.sve.fmlalb.lane
+    12, // llvm.aarch64.sve.fmlalt
+    71, // llvm.aarch64.sve.fmlalt.lane
+    12, // llvm.aarch64.sve.fmls
+    71, // llvm.aarch64.sve.fmls.lane
+    12, // llvm.aarch64.sve.fmlslb
+    71, // llvm.aarch64.sve.fmlslb.lane
+    12, // llvm.aarch64.sve.fmlslt
+    71, // llvm.aarch64.sve.fmlslt.lane
+    12, // llvm.aarch64.sve.fmmla
+    12, // llvm.aarch64.sve.fmsb
+    12, // llvm.aarch64.sve.fmul
+    70, // llvm.aarch64.sve.fmul.lane
+    12, // llvm.aarch64.sve.fmulx
+    12, // llvm.aarch64.sve.fneg
+    12, // llvm.aarch64.sve.fnmad
+    12, // llvm.aarch64.sve.fnmla
+    12, // llvm.aarch64.sve.fnmls
+    12, // llvm.aarch64.sve.fnmsb
+    12, // llvm.aarch64.sve.frecpe.x
+    12, // llvm.aarch64.sve.frecps.x
+    12, // llvm.aarch64.sve.frecpx
+    12, // llvm.aarch64.sve.frinta
+    12, // llvm.aarch64.sve.frinti
+    12, // llvm.aarch64.sve.frintm
+    12, // llvm.aarch64.sve.frintn
+    12, // llvm.aarch64.sve.frintp
+    12, // llvm.aarch64.sve.frintx
+    12, // llvm.aarch64.sve.frintz
+    12, // llvm.aarch64.sve.frsqrte.x
+    12, // llvm.aarch64.sve.frsqrts.x
+    12, // llvm.aarch64.sve.fscale
+    12, // llvm.aarch64.sve.fsqrt
+    12, // llvm.aarch64.sve.fsub
+    12, // llvm.aarch64.sve.fsubr
+    70, // llvm.aarch64.sve.ftmad.x
+    12, // llvm.aarch64.sve.ftsmul.x
+    12, // llvm.aarch64.sve.ftssel.x
+    12, // llvm.aarch64.sve.histcnt
+    12, // llvm.aarch64.sve.histseg
+    12, // llvm.aarch64.sve.index
+    12, // llvm.aarch64.sve.insr
+    12, // llvm.aarch64.sve.lasta
+    12, // llvm.aarch64.sve.lastb
+    3, // llvm.aarch64.sve.ld1
+    3, // llvm.aarch64.sve.ld1.gather
+    3, // llvm.aarch64.sve.ld1.gather.index
+    21, // llvm.aarch64.sve.ld1.gather.scalar.offset
+    3, // llvm.aarch64.sve.ld1.gather.sxtw
+    3, // llvm.aarch64.sve.ld1.gather.sxtw.index
+    3, // llvm.aarch64.sve.ld1.gather.uxtw
+    3, // llvm.aarch64.sve.ld1.gather.uxtw.index
+    3, // llvm.aarch64.sve.ld1ro
+    3, // llvm.aarch64.sve.ld1rq
+    3, // llvm.aarch64.sve.ld2
+    3, // llvm.aarch64.sve.ld3
+    3, // llvm.aarch64.sve.ld4
+    3, // llvm.aarch64.sve.ldff1
+    3, // llvm.aarch64.sve.ldff1.gather
+    3, // llvm.aarch64.sve.ldff1.gather.index
+    21, // llvm.aarch64.sve.ldff1.gather.scalar.offset
+    3, // llvm.aarch64.sve.ldff1.gather.sxtw
+    3, // llvm.aarch64.sve.ldff1.gather.sxtw.index
+    3, // llvm.aarch64.sve.ldff1.gather.uxtw
+    3, // llvm.aarch64.sve.ldff1.gather.uxtw.index
+    3, // llvm.aarch64.sve.ldnf1
+    3, // llvm.aarch64.sve.ldnt1
+    3, // llvm.aarch64.sve.ldnt1.gather
+    3, // llvm.aarch64.sve.ldnt1.gather.index
+    21, // llvm.aarch64.sve.ldnt1.gather.scalar.offset
+    3, // llvm.aarch64.sve.ldnt1.gather.uxtw
+    12, // llvm.aarch64.sve.lsl
+    12, // llvm.aarch64.sve.lsl.wide
+    12, // llvm.aarch64.sve.lsr
+    12, // llvm.aarch64.sve.lsr.wide
+    12, // llvm.aarch64.sve.mad
+    12, // llvm.aarch64.sve.match
+    12, // llvm.aarch64.sve.mla
+    71, // llvm.aarch64.sve.mla.lane
+    12, // llvm.aarch64.sve.mls
+    71, // llvm.aarch64.sve.mls.lane
+    12, // llvm.aarch64.sve.msb
+    12, // llvm.aarch64.sve.mul
+    70, // llvm.aarch64.sve.mul.lane
+    12, // llvm.aarch64.sve.nand.z
+    12, // llvm.aarch64.sve.nbsl
+    12, // llvm.aarch64.sve.neg
+    12, // llvm.aarch64.sve.nmatch
+    12, // llvm.aarch64.sve.nor.z
+    12, // llvm.aarch64.sve.not
+    12, // llvm.aarch64.sve.orn.z
+    12, // llvm.aarch64.sve.orr
+    12, // llvm.aarch64.sve.orr.z
+    12, // llvm.aarch64.sve.orv
+    12, // llvm.aarch64.sve.pfirst
+    12, // llvm.aarch64.sve.pmul
+    12, // llvm.aarch64.sve.pmullb.pair
+    12, // llvm.aarch64.sve.pmullt.pair
+    12, // llvm.aarch64.sve.pnext
+    75, // llvm.aarch64.sve.prf
+    76, // llvm.aarch64.sve.prfb.gather.index
+    77, // llvm.aarch64.sve.prfb.gather.scalar.offset
+    76, // llvm.aarch64.sve.prfb.gather.sxtw.index
+    76, // llvm.aarch64.sve.prfb.gather.uxtw.index
+    76, // llvm.aarch64.sve.prfd.gather.index
+    77, // llvm.aarch64.sve.prfd.gather.scalar.offset
+    76, // llvm.aarch64.sve.prfd.gather.sxtw.index
+    76, // llvm.aarch64.sve.prfd.gather.uxtw.index
+    76, // llvm.aarch64.sve.prfh.gather.index
+    77, // llvm.aarch64.sve.prfh.gather.scalar.offset
+    76, // llvm.aarch64.sve.prfh.gather.sxtw.index
+    76, // llvm.aarch64.sve.prfh.gather.uxtw.index
+    76, // llvm.aarch64.sve.prfw.gather.index
+    77, // llvm.aarch64.sve.prfw.gather.scalar.offset
+    76, // llvm.aarch64.sve.prfw.gather.sxtw.index
+    76, // llvm.aarch64.sve.prfw.gather.uxtw.index
+    12, // llvm.aarch64.sve.ptest.any
+    12, // llvm.aarch64.sve.ptest.first
+    12, // llvm.aarch64.sve.ptest.last
+    73, // llvm.aarch64.sve.ptrue
+    12, // llvm.aarch64.sve.punpkhi
+    12, // llvm.aarch64.sve.punpklo
+    12, // llvm.aarch64.sve.raddhnb
+    12, // llvm.aarch64.sve.raddhnt
+    12, // llvm.aarch64.sve.rax1
+    12, // llvm.aarch64.sve.rbit
+    7, // llvm.aarch64.sve.rdffr
+    7, // llvm.aarch64.sve.rdffr.z
+    12, // llvm.aarch64.sve.rev
+    12, // llvm.aarch64.sve.revb
+    12, // llvm.aarch64.sve.revh
+    12, // llvm.aarch64.sve.revw
+    78, // llvm.aarch64.sve.rshrnb
+    70, // llvm.aarch64.sve.rshrnt
+    12, // llvm.aarch64.sve.rsubhnb
+    12, // llvm.aarch64.sve.rsubhnt
+    12, // llvm.aarch64.sve.saba
+    12, // llvm.aarch64.sve.sabalb
+    12, // llvm.aarch64.sve.sabalt
+    12, // llvm.aarch64.sve.sabd
+    12, // llvm.aarch64.sve.sabdlb
+    12, // llvm.aarch64.sve.sabdlt
+    12, // llvm.aarch64.sve.sadalp
+    12, // llvm.aarch64.sve.saddlb
+    12, // llvm.aarch64.sve.saddlbt
+    12, // llvm.aarch64.sve.saddlt
+    12, // llvm.aarch64.sve.saddv
+    12, // llvm.aarch64.sve.saddwb
+    12, // llvm.aarch64.sve.saddwt
+    12, // llvm.aarch64.sve.sbclb
+    12, // llvm.aarch64.sve.sbclt
+    12, // llvm.aarch64.sve.scvtf
+    12, // llvm.aarch64.sve.scvtf.f16i32
+    12, // llvm.aarch64.sve.scvtf.f16i64
+    12, // llvm.aarch64.sve.scvtf.f32i64
+    12, // llvm.aarch64.sve.scvtf.f64i32
+    12, // llvm.aarch64.sve.sdiv
+    12, // llvm.aarch64.sve.sdivr
+    12, // llvm.aarch64.sve.sdot
+    71, // llvm.aarch64.sve.sdot.lane
+    12, // llvm.aarch64.sve.sel
+    7, // llvm.aarch64.sve.setffr
+    12, // llvm.aarch64.sve.shadd
+    78, // llvm.aarch64.sve.shrnb
+    70, // llvm.aarch64.sve.shrnt
+    12, // llvm.aarch64.sve.shsub
+    12, // llvm.aarch64.sve.shsubr
+    70, // llvm.aarch64.sve.sli
+    12, // llvm.aarch64.sve.sm4e
+    12, // llvm.aarch64.sve.sm4ekey
+    12, // llvm.aarch64.sve.smax
+    12, // llvm.aarch64.sve.smaxp
+    12, // llvm.aarch64.sve.smaxv
+    12, // llvm.aarch64.sve.smin
+    12, // llvm.aarch64.sve.sminp
+    12, // llvm.aarch64.sve.sminv
+    12, // llvm.aarch64.sve.smlalb
+    71, // llvm.aarch64.sve.smlalb.lane
+    12, // llvm.aarch64.sve.smlalt
+    71, // llvm.aarch64.sve.smlalt.lane
+    12, // llvm.aarch64.sve.smlslb
+    71, // llvm.aarch64.sve.smlslb.lane
+    12, // llvm.aarch64.sve.smlslt
+    71, // llvm.aarch64.sve.smlslt.lane
+    12, // llvm.aarch64.sve.smmla
+    12, // llvm.aarch64.sve.smulh
+    12, // llvm.aarch64.sve.smullb
+    70, // llvm.aarch64.sve.smullb.lane
+    12, // llvm.aarch64.sve.smullt
+    70, // llvm.aarch64.sve.smullt.lane
+    12, // llvm.aarch64.sve.splice
+    12, // llvm.aarch64.sve.sqabs
+    12, // llvm.aarch64.sve.sqadd
+    12, // llvm.aarch64.sve.sqadd.x
+    70, // llvm.aarch64.sve.sqcadd.x
+    79, // llvm.aarch64.sve.sqdecb.n32
+    79, // llvm.aarch64.sve.sqdecb.n64
+    79, // llvm.aarch64.sve.sqdecd
+    79, // llvm.aarch64.sve.sqdecd.n32
+    79, // llvm.aarch64.sve.sqdecd.n64
+    79, // llvm.aarch64.sve.sqdech
+    79, // llvm.aarch64.sve.sqdech.n32
+    79, // llvm.aarch64.sve.sqdech.n64
+    12, // llvm.aarch64.sve.sqdecp
+    12, // llvm.aarch64.sve.sqdecp.n32
+    12, // llvm.aarch64.sve.sqdecp.n64
+    79, // llvm.aarch64.sve.sqdecw
+    79, // llvm.aarch64.sve.sqdecw.n32
+    79, // llvm.aarch64.sve.sqdecw.n64
+    12, // llvm.aarch64.sve.sqdmlalb
+    71, // llvm.aarch64.sve.sqdmlalb.lane
+    12, // llvm.aarch64.sve.sqdmlalbt
+    12, // llvm.aarch64.sve.sqdmlalt
+    71, // llvm.aarch64.sve.sqdmlalt.lane
+    12, // llvm.aarch64.sve.sqdmlslb
+    71, // llvm.aarch64.sve.sqdmlslb.lane
+    12, // llvm.aarch64.sve.sqdmlslbt
+    12, // llvm.aarch64.sve.sqdmlslt
+    71, // llvm.aarch64.sve.sqdmlslt.lane
+    12, // llvm.aarch64.sve.sqdmulh
+    70, // llvm.aarch64.sve.sqdmulh.lane
+    12, // llvm.aarch64.sve.sqdmullb
+    70, // llvm.aarch64.sve.sqdmullb.lane
+    12, // llvm.aarch64.sve.sqdmullt
+    70, // llvm.aarch64.sve.sqdmullt.lane
+    79, // llvm.aarch64.sve.sqincb.n32
+    79, // llvm.aarch64.sve.sqincb.n64
+    79, // llvm.aarch64.sve.sqincd
+    79, // llvm.aarch64.sve.sqincd.n32
+    79, // llvm.aarch64.sve.sqincd.n64
+    79, // llvm.aarch64.sve.sqinch
+    79, // llvm.aarch64.sve.sqinch.n32
+    79, // llvm.aarch64.sve.sqinch.n64
+    12, // llvm.aarch64.sve.sqincp
+    12, // llvm.aarch64.sve.sqincp.n32
+    12, // llvm.aarch64.sve.sqincp.n64
+    79, // llvm.aarch64.sve.sqincw
+    79, // llvm.aarch64.sve.sqincw.n32
+    79, // llvm.aarch64.sve.sqincw.n64
+    12, // llvm.aarch64.sve.sqneg
+    72, // llvm.aarch64.sve.sqrdcmlah.lane.x
+    71, // llvm.aarch64.sve.sqrdcmlah.x
+    12, // llvm.aarch64.sve.sqrdmlah
+    71, // llvm.aarch64.sve.sqrdmlah.lane
+    12, // llvm.aarch64.sve.sqrdmlsh
+    71, // llvm.aarch64.sve.sqrdmlsh.lane
+    12, // llvm.aarch64.sve.sqrdmulh
+    70, // llvm.aarch64.sve.sqrdmulh.lane
+    12, // llvm.aarch64.sve.sqrshl
+    78, // llvm.aarch64.sve.sqrshrnb
+    70, // llvm.aarch64.sve.sqrshrnt
+    78, // llvm.aarch64.sve.sqrshrunb
+    70, // llvm.aarch64.sve.sqrshrunt
+    12, // llvm.aarch64.sve.sqshl
+    70, // llvm.aarch64.sve.sqshlu
+    78, // llvm.aarch64.sve.sqshrnb
+    70, // llvm.aarch64.sve.sqshrnt
+    78, // llvm.aarch64.sve.sqshrunb
+    70, // llvm.aarch64.sve.sqshrunt
+    12, // llvm.aarch64.sve.sqsub
+    12, // llvm.aarch64.sve.sqsub.x
+    12, // llvm.aarch64.sve.sqsubr
+    12, // llvm.aarch64.sve.sqxtnb
+    12, // llvm.aarch64.sve.sqxtnt
+    12, // llvm.aarch64.sve.sqxtunb
+    12, // llvm.aarch64.sve.sqxtunt
+    12, // llvm.aarch64.sve.srhadd
+    70, // llvm.aarch64.sve.sri
+    12, // llvm.aarch64.sve.srshl
+    70, // llvm.aarch64.sve.srshr
+    70, // llvm.aarch64.sve.srsra
+    78, // llvm.aarch64.sve.sshllb
+    78, // llvm.aarch64.sve.sshllt
+    70, // llvm.aarch64.sve.ssra
+    12, // llvm.aarch64.sve.ssublb
+    12, // llvm.aarch64.sve.ssublbt
+    12, // llvm.aarch64.sve.ssublt
+    12, // llvm.aarch64.sve.ssubltb
+    12, // llvm.aarch64.sve.ssubwb
+    12, // llvm.aarch64.sve.ssubwt
+    64, // llvm.aarch64.sve.st1
+    80, // llvm.aarch64.sve.st1.scatter
+    80, // llvm.aarch64.sve.st1.scatter.index
+    69, // llvm.aarch64.sve.st1.scatter.scalar.offset
+    80, // llvm.aarch64.sve.st1.scatter.sxtw
+    80, // llvm.aarch64.sve.st1.scatter.sxtw.index
+    80, // llvm.aarch64.sve.st1.scatter.uxtw
+    80, // llvm.aarch64.sve.st1.scatter.uxtw.index
+    65, // llvm.aarch64.sve.st2
+    66, // llvm.aarch64.sve.st3
+    67, // llvm.aarch64.sve.st4
+    64, // llvm.aarch64.sve.stnt1
+    80, // llvm.aarch64.sve.stnt1.scatter
+    80, // llvm.aarch64.sve.stnt1.scatter.index
+    69, // llvm.aarch64.sve.stnt1.scatter.scalar.offset
+    80, // llvm.aarch64.sve.stnt1.scatter.uxtw
+    12, // llvm.aarch64.sve.sub
+    12, // llvm.aarch64.sve.subhnb
+    12, // llvm.aarch64.sve.subhnt
+    12, // llvm.aarch64.sve.subr
+    71, // llvm.aarch64.sve.sudot.lane
+    12, // llvm.aarch64.sve.sunpkhi
+    12, // llvm.aarch64.sve.sunpklo
+    12, // llvm.aarch64.sve.suqadd
+    12, // llvm.aarch64.sve.sxtb
+    12, // llvm.aarch64.sve.sxth
+    12, // llvm.aarch64.sve.sxtw
+    12, // llvm.aarch64.sve.tbl
+    12, // llvm.aarch64.sve.tbl2
+    12, // llvm.aarch64.sve.tbx
+    12, // llvm.aarch64.sve.trn1
+    12, // llvm.aarch64.sve.trn1q
+    12, // llvm.aarch64.sve.trn2
+    12, // llvm.aarch64.sve.trn2q
+    21, // llvm.aarch64.sve.tuple.create2
+    21, // llvm.aarch64.sve.tuple.create3
+    21, // llvm.aarch64.sve.tuple.create4
+    81, // llvm.aarch64.sve.tuple.get
+    82, // llvm.aarch64.sve.tuple.set
+    12, // llvm.aarch64.sve.uaba
+    12, // llvm.aarch64.sve.uabalb
+    12, // llvm.aarch64.sve.uabalt
+    12, // llvm.aarch64.sve.uabd
+    12, // llvm.aarch64.sve.uabdlb
+    12, // llvm.aarch64.sve.uabdlt
+    12, // llvm.aarch64.sve.uadalp
+    12, // llvm.aarch64.sve.uaddlb
+    12, // llvm.aarch64.sve.uaddlt
+    12, // llvm.aarch64.sve.uaddv
+    12, // llvm.aarch64.sve.uaddwb
+    12, // llvm.aarch64.sve.uaddwt
+    12, // llvm.aarch64.sve.ucvtf
+    12, // llvm.aarch64.sve.ucvtf.f16i32
+    12, // llvm.aarch64.sve.ucvtf.f16i64
+    12, // llvm.aarch64.sve.ucvtf.f32i64
+    12, // llvm.aarch64.sve.ucvtf.f64i32
+    12, // llvm.aarch64.sve.udiv
+    12, // llvm.aarch64.sve.udivr
+    12, // llvm.aarch64.sve.udot
+    71, // llvm.aarch64.sve.udot.lane
+    12, // llvm.aarch64.sve.uhadd
+    12, // llvm.aarch64.sve.uhsub
+    12, // llvm.aarch64.sve.uhsubr
+    12, // llvm.aarch64.sve.umax
+    12, // llvm.aarch64.sve.umaxp
+    12, // llvm.aarch64.sve.umaxv
+    12, // llvm.aarch64.sve.umin
+    12, // llvm.aarch64.sve.uminp
+    12, // llvm.aarch64.sve.uminv
+    12, // llvm.aarch64.sve.umlalb
+    71, // llvm.aarch64.sve.umlalb.lane
+    12, // llvm.aarch64.sve.umlalt
+    71, // llvm.aarch64.sve.umlalt.lane
+    12, // llvm.aarch64.sve.umlslb
+    71, // llvm.aarch64.sve.umlslb.lane
+    12, // llvm.aarch64.sve.umlslt
+    71, // llvm.aarch64.sve.umlslt.lane
+    12, // llvm.aarch64.sve.ummla
+    12, // llvm.aarch64.sve.umulh
+    12, // llvm.aarch64.sve.umullb
+    70, // llvm.aarch64.sve.umullb.lane
+    12, // llvm.aarch64.sve.umullt
+    70, // llvm.aarch64.sve.umullt.lane
+    12, // llvm.aarch64.sve.uqadd
+    12, // llvm.aarch64.sve.uqadd.x
+    79, // llvm.aarch64.sve.uqdecb.n32
+    79, // llvm.aarch64.sve.uqdecb.n64
+    79, // llvm.aarch64.sve.uqdecd
+    79, // llvm.aarch64.sve.uqdecd.n32
+    79, // llvm.aarch64.sve.uqdecd.n64
+    79, // llvm.aarch64.sve.uqdech
+    79, // llvm.aarch64.sve.uqdech.n32
+    79, // llvm.aarch64.sve.uqdech.n64
+    12, // llvm.aarch64.sve.uqdecp
+    12, // llvm.aarch64.sve.uqdecp.n32
+    12, // llvm.aarch64.sve.uqdecp.n64
+    79, // llvm.aarch64.sve.uqdecw
+    79, // llvm.aarch64.sve.uqdecw.n32
+    79, // llvm.aarch64.sve.uqdecw.n64
+    79, // llvm.aarch64.sve.uqincb.n32
+    79, // llvm.aarch64.sve.uqincb.n64
+    79, // llvm.aarch64.sve.uqincd
+    79, // llvm.aarch64.sve.uqincd.n32
+    79, // llvm.aarch64.sve.uqincd.n64
+    79, // llvm.aarch64.sve.uqinch
+    79, // llvm.aarch64.sve.uqinch.n32
+    79, // llvm.aarch64.sve.uqinch.n64
+    12, // llvm.aarch64.sve.uqincp
+    12, // llvm.aarch64.sve.uqincp.n32
+    12, // llvm.aarch64.sve.uqincp.n64
+    79, // llvm.aarch64.sve.uqincw
+    79, // llvm.aarch64.sve.uqincw.n32
+    79, // llvm.aarch64.sve.uqincw.n64
+    12, // llvm.aarch64.sve.uqrshl
+    78, // llvm.aarch64.sve.uqrshrnb
+    70, // llvm.aarch64.sve.uqrshrnt
+    12, // llvm.aarch64.sve.uqshl
+    78, // llvm.aarch64.sve.uqshrnb
+    70, // llvm.aarch64.sve.uqshrnt
+    12, // llvm.aarch64.sve.uqsub
+    12, // llvm.aarch64.sve.uqsub.x
+    12, // llvm.aarch64.sve.uqsubr
+    12, // llvm.aarch64.sve.uqxtnb
+    12, // llvm.aarch64.sve.uqxtnt
+    12, // llvm.aarch64.sve.urecpe
+    12, // llvm.aarch64.sve.urhadd
+    12, // llvm.aarch64.sve.urshl
+    70, // llvm.aarch64.sve.urshr
+    12, // llvm.aarch64.sve.ursqrte
+    70, // llvm.aarch64.sve.ursra
+    12, // llvm.aarch64.sve.usdot
+    71, // llvm.aarch64.sve.usdot.lane
+    78, // llvm.aarch64.sve.ushllb
+    78, // llvm.aarch64.sve.ushllt
+    12, // llvm.aarch64.sve.usmmla
+    12, // llvm.aarch64.sve.usqadd
+    70, // llvm.aarch64.sve.usra
+    12, // llvm.aarch64.sve.usublb
+    12, // llvm.aarch64.sve.usublt
+    12, // llvm.aarch64.sve.usubwb
+    12, // llvm.aarch64.sve.usubwt
+    12, // llvm.aarch64.sve.uunpkhi
+    12, // llvm.aarch64.sve.uunpklo
+    12, // llvm.aarch64.sve.uxtb
+    12, // llvm.aarch64.sve.uxth
+    12, // llvm.aarch64.sve.uxtw
+    12, // llvm.aarch64.sve.uzp1
+    12, // llvm.aarch64.sve.uzp1q
+    12, // llvm.aarch64.sve.uzp2
+    12, // llvm.aarch64.sve.uzp2q
+    12, // llvm.aarch64.sve.whilege
+    12, // llvm.aarch64.sve.whilegt
+    12, // llvm.aarch64.sve.whilehi
+    12, // llvm.aarch64.sve.whilehs
+    12, // llvm.aarch64.sve.whilele
+    12, // llvm.aarch64.sve.whilelo
+    12, // llvm.aarch64.sve.whilels
+    12, // llvm.aarch64.sve.whilelt
+    7, // llvm.aarch64.sve.whilerw.b
+    7, // llvm.aarch64.sve.whilerw.d
+    7, // llvm.aarch64.sve.whilerw.h
+    7, // llvm.aarch64.sve.whilerw.s
+    7, // llvm.aarch64.sve.whilewr.b
+    7, // llvm.aarch64.sve.whilewr.d
+    7, // llvm.aarch64.sve.whilewr.h
+    7, // llvm.aarch64.sve.whilewr.s
+    7, // llvm.aarch64.sve.wrffr
+    70, // llvm.aarch64.sve.xar
+    12, // llvm.aarch64.sve.zip1
+    12, // llvm.aarch64.sve.zip1q
+    12, // llvm.aarch64.sve.zip2
+    12, // llvm.aarch64.sve.zip2q
+    70, // llvm.aarch64.tagp
+    83, // llvm.aarch64.tcancel
+    7, // llvm.aarch64.tcommit
+    7, // llvm.aarch64.tstart
+    63, // llvm.aarch64.ttest
+    12, // llvm.aarch64.udiv
+    84, // llvm.amdgcn.alignbit
+    84, // llvm.amdgcn.alignbyte
+    85, // llvm.amdgcn.atomic.dec
+    85, // llvm.amdgcn.atomic.inc
+    86, // llvm.amdgcn.ballot
+    87, // llvm.amdgcn.buffer.atomic.add
+    87, // llvm.amdgcn.buffer.atomic.and
+    88, // llvm.amdgcn.buffer.atomic.cmpswap
+    87, // llvm.amdgcn.buffer.atomic.csub
+    89, // llvm.amdgcn.buffer.atomic.fadd
+    87, // llvm.amdgcn.buffer.atomic.or
+    87, // llvm.amdgcn.buffer.atomic.smax
+    87, // llvm.amdgcn.buffer.atomic.smin
+    87, // llvm.amdgcn.buffer.atomic.sub
+    87, // llvm.amdgcn.buffer.atomic.swap
+    87, // llvm.amdgcn.buffer.atomic.umax
+    87, // llvm.amdgcn.buffer.atomic.umin
+    87, // llvm.amdgcn.buffer.atomic.xor
+    90, // llvm.amdgcn.buffer.load
+    90, // llvm.amdgcn.buffer.load.format
+    91, // llvm.amdgcn.buffer.store
+    91, // llvm.amdgcn.buffer.store.format
+    92, // llvm.amdgcn.buffer.wbinvl1
+    92, // llvm.amdgcn.buffer.wbinvl1.sc
+    92, // llvm.amdgcn.buffer.wbinvl1.vol
+    84, // llvm.amdgcn.class
+    84, // llvm.amdgcn.cos
+    84, // llvm.amdgcn.cubeid
+    84, // llvm.amdgcn.cubema
+    84, // llvm.amdgcn.cubesc
+    84, // llvm.amdgcn.cubetc
+    84, // llvm.amdgcn.cvt.pk.i16
+    84, // llvm.amdgcn.cvt.pk.u16
+    84, // llvm.amdgcn.cvt.pk.u8.f32
+    84, // llvm.amdgcn.cvt.pknorm.i16
+    84, // llvm.amdgcn.cvt.pknorm.u16
+    84, // llvm.amdgcn.cvt.pkrtz
+    84, // llvm.amdgcn.dispatch.id
+    93, // llvm.amdgcn.dispatch.ptr
+    84, // llvm.amdgcn.div.fixup
+    84, // llvm.amdgcn.div.fmas
+    94, // llvm.amdgcn.div.scale
+    95, // llvm.amdgcn.ds.append
+    86, // llvm.amdgcn.ds.bpermute
+    95, // llvm.amdgcn.ds.consume
+    85, // llvm.amdgcn.ds.fadd
+    85, // llvm.amdgcn.ds.fmax
+    85, // llvm.amdgcn.ds.fmin
+    96, // llvm.amdgcn.ds.gws.barrier
+    97, // llvm.amdgcn.ds.gws.init
+    96, // llvm.amdgcn.ds.gws.sema.br
+    96, // llvm.amdgcn.ds.gws.sema.p
+    96, // llvm.amdgcn.ds.gws.sema.release.all
+    96, // llvm.amdgcn.ds.gws.sema.v
+    98, // llvm.amdgcn.ds.ordered.add
+    98, // llvm.amdgcn.ds.ordered.swap
+    86, // llvm.amdgcn.ds.permute
+    99, // llvm.amdgcn.ds.swizzle
+    100, // llvm.amdgcn.else
+    100, // llvm.amdgcn.end.cf
+    101, // llvm.amdgcn.endpgm
+    102, // llvm.amdgcn.exp
+    103, // llvm.amdgcn.exp.compr
+    104, // llvm.amdgcn.fcmp
+    84, // llvm.amdgcn.fdiv.fast
+    105, // llvm.amdgcn.fdot2
+    84, // llvm.amdgcn.fma.legacy
+    84, // llvm.amdgcn.fmad.ftz
+    84, // llvm.amdgcn.fmed3
+    84, // llvm.amdgcn.fmul.legacy
+    84, // llvm.amdgcn.fract
+    84, // llvm.amdgcn.frexp.exp
+    84, // llvm.amdgcn.frexp.mant
+    106, // llvm.amdgcn.global.atomic.csub
+    106, // llvm.amdgcn.global.atomic.fadd
+    84, // llvm.amdgcn.groupstaticsize
+    104, // llvm.amdgcn.icmp
+    100, // llvm.amdgcn.if
+    86, // llvm.amdgcn.if.break
+    107, // llvm.amdgcn.image.atomic.add.1d
+    108, // llvm.amdgcn.image.atomic.add.1darray
+    108, // llvm.amdgcn.image.atomic.add.2d
+    109, // llvm.amdgcn.image.atomic.add.2darray
+    110, // llvm.amdgcn.image.atomic.add.2darraymsaa
+    109, // llvm.amdgcn.image.atomic.add.2dmsaa
+    109, // llvm.amdgcn.image.atomic.add.3d
+    109, // llvm.amdgcn.image.atomic.add.cube
+    107, // llvm.amdgcn.image.atomic.and.1d
+    108, // llvm.amdgcn.image.atomic.and.1darray
+    108, // llvm.amdgcn.image.atomic.and.2d
+    109, // llvm.amdgcn.image.atomic.and.2darray
+    110, // llvm.amdgcn.image.atomic.and.2darraymsaa
+    109, // llvm.amdgcn.image.atomic.and.2dmsaa
+    109, // llvm.amdgcn.image.atomic.and.3d
+    109, // llvm.amdgcn.image.atomic.and.cube
+    108, // llvm.amdgcn.image.atomic.cmpswap.1d
+    109, // llvm.amdgcn.image.atomic.cmpswap.1darray
+    109, // llvm.amdgcn.image.atomic.cmpswap.2d
+    110, // llvm.amdgcn.image.atomic.cmpswap.2darray
+    111, // llvm.amdgcn.image.atomic.cmpswap.2darraymsaa
+    110, // llvm.amdgcn.image.atomic.cmpswap.2dmsaa
+    110, // llvm.amdgcn.image.atomic.cmpswap.3d
+    110, // llvm.amdgcn.image.atomic.cmpswap.cube
+    107, // llvm.amdgcn.image.atomic.dec.1d
+    108, // llvm.amdgcn.image.atomic.dec.1darray
+    108, // llvm.amdgcn.image.atomic.dec.2d
+    109, // llvm.amdgcn.image.atomic.dec.2darray
+    110, // llvm.amdgcn.image.atomic.dec.2darraymsaa
+    109, // llvm.amdgcn.image.atomic.dec.2dmsaa
+    109, // llvm.amdgcn.image.atomic.dec.3d
+    109, // llvm.amdgcn.image.atomic.dec.cube
+    107, // llvm.amdgcn.image.atomic.inc.1d
+    108, // llvm.amdgcn.image.atomic.inc.1darray
+    108, // llvm.amdgcn.image.atomic.inc.2d
+    109, // llvm.amdgcn.image.atomic.inc.2darray
+    110, // llvm.amdgcn.image.atomic.inc.2darraymsaa
+    109, // llvm.amdgcn.image.atomic.inc.2dmsaa
+    109, // llvm.amdgcn.image.atomic.inc.3d
+    109, // llvm.amdgcn.image.atomic.inc.cube
+    107, // llvm.amdgcn.image.atomic.or.1d
+    108, // llvm.amdgcn.image.atomic.or.1darray
+    108, // llvm.amdgcn.image.atomic.or.2d
+    109, // llvm.amdgcn.image.atomic.or.2darray
+    110, // llvm.amdgcn.image.atomic.or.2darraymsaa
+    109, // llvm.amdgcn.image.atomic.or.2dmsaa
+    109, // llvm.amdgcn.image.atomic.or.3d
+    109, // llvm.amdgcn.image.atomic.or.cube
+    107, // llvm.amdgcn.image.atomic.smax.1d
+    108, // llvm.amdgcn.image.atomic.smax.1darray
+    108, // llvm.amdgcn.image.atomic.smax.2d
+    109, // llvm.amdgcn.image.atomic.smax.2darray
+    110, // llvm.amdgcn.image.atomic.smax.2darraymsaa
+    109, // llvm.amdgcn.image.atomic.smax.2dmsaa
+    109, // llvm.amdgcn.image.atomic.smax.3d
+    109, // llvm.amdgcn.image.atomic.smax.cube
+    107, // llvm.amdgcn.image.atomic.smin.1d
+    108, // llvm.amdgcn.image.atomic.smin.1darray
+    108, // llvm.amdgcn.image.atomic.smin.2d
+    109, // llvm.amdgcn.image.atomic.smin.2darray
+    110, // llvm.amdgcn.image.atomic.smin.2darraymsaa
+    109, // llvm.amdgcn.image.atomic.smin.2dmsaa
+    109, // llvm.amdgcn.image.atomic.smin.3d
+    109, // llvm.amdgcn.image.atomic.smin.cube
+    107, // llvm.amdgcn.image.atomic.sub.1d
+    108, // llvm.amdgcn.image.atomic.sub.1darray
+    108, // llvm.amdgcn.image.atomic.sub.2d
+    109, // llvm.amdgcn.image.atomic.sub.2darray
+    110, // llvm.amdgcn.image.atomic.sub.2darraymsaa
+    109, // llvm.amdgcn.image.atomic.sub.2dmsaa
+    109, // llvm.amdgcn.image.atomic.sub.3d
+    109, // llvm.amdgcn.image.atomic.sub.cube
+    107, // llvm.amdgcn.image.atomic.swap.1d
+    108, // llvm.amdgcn.image.atomic.swap.1darray
+    108, // llvm.amdgcn.image.atomic.swap.2d
+    109, // llvm.amdgcn.image.atomic.swap.2darray
+    110, // llvm.amdgcn.image.atomic.swap.2darraymsaa
+    109, // llvm.amdgcn.image.atomic.swap.2dmsaa
+    109, // llvm.amdgcn.image.atomic.swap.3d
+    109, // llvm.amdgcn.image.atomic.swap.cube
+    107, // llvm.amdgcn.image.atomic.umax.1d
+    108, // llvm.amdgcn.image.atomic.umax.1darray
+    108, // llvm.amdgcn.image.atomic.umax.2d
+    109, // llvm.amdgcn.image.atomic.umax.2darray
+    110, // llvm.amdgcn.image.atomic.umax.2darraymsaa
+    109, // llvm.amdgcn.image.atomic.umax.2dmsaa
+    109, // llvm.amdgcn.image.atomic.umax.3d
+    109, // llvm.amdgcn.image.atomic.umax.cube
+    107, // llvm.amdgcn.image.atomic.umin.1d
+    108, // llvm.amdgcn.image.atomic.umin.1darray
+    108, // llvm.amdgcn.image.atomic.umin.2d
+    109, // llvm.amdgcn.image.atomic.umin.2darray
+    110, // llvm.amdgcn.image.atomic.umin.2darraymsaa
+    109, // llvm.amdgcn.image.atomic.umin.2dmsaa
+    109, // llvm.amdgcn.image.atomic.umin.3d
+    109, // llvm.amdgcn.image.atomic.umin.cube
+    107, // llvm.amdgcn.image.atomic.xor.1d
+    108, // llvm.amdgcn.image.atomic.xor.1darray
+    108, // llvm.amdgcn.image.atomic.xor.2d
+    109, // llvm.amdgcn.image.atomic.xor.2darray
+    110, // llvm.amdgcn.image.atomic.xor.2darraymsaa
+    109, // llvm.amdgcn.image.atomic.xor.2dmsaa
+    109, // llvm.amdgcn.image.atomic.xor.3d
+    109, // llvm.amdgcn.image.atomic.xor.cube
+    21, // llvm.amdgcn.image.bvh.intersect.ray
+    112, // llvm.amdgcn.image.gather4.2d
+    113, // llvm.amdgcn.image.gather4.2darray
+    113, // llvm.amdgcn.image.gather4.b.2d
+    114, // llvm.amdgcn.image.gather4.b.2darray
+    114, // llvm.amdgcn.image.gather4.b.cl.2d
+    115, // llvm.amdgcn.image.gather4.b.cl.2darray
+    115, // llvm.amdgcn.image.gather4.b.cl.cube
+    115, // llvm.amdgcn.image.gather4.b.cl.o.2d
+    116, // llvm.amdgcn.image.gather4.b.cl.o.2darray
+    116, // llvm.amdgcn.image.gather4.b.cl.o.cube
+    114, // llvm.amdgcn.image.gather4.b.cube
+    114, // llvm.amdgcn.image.gather4.b.o.2d
+    115, // llvm.amdgcn.image.gather4.b.o.2darray
+    115, // llvm.amdgcn.image.gather4.b.o.cube
+    113, // llvm.amdgcn.image.gather4.c.2d
+    114, // llvm.amdgcn.image.gather4.c.2darray
+    114, // llvm.amdgcn.image.gather4.c.b.2d
+    115, // llvm.amdgcn.image.gather4.c.b.2darray
+    115, // llvm.amdgcn.image.gather4.c.b.cl.2d
+    116, // llvm.amdgcn.image.gather4.c.b.cl.2darray
+    116, // llvm.amdgcn.image.gather4.c.b.cl.cube
+    116, // llvm.amdgcn.image.gather4.c.b.cl.o.2d
+    117, // llvm.amdgcn.image.gather4.c.b.cl.o.2darray
+    117, // llvm.amdgcn.image.gather4.c.b.cl.o.cube
+    115, // llvm.amdgcn.image.gather4.c.b.cube
+    115, // llvm.amdgcn.image.gather4.c.b.o.2d
+    116, // llvm.amdgcn.image.gather4.c.b.o.2darray
+    116, // llvm.amdgcn.image.gather4.c.b.o.cube
+    114, // llvm.amdgcn.image.gather4.c.cl.2d
+    115, // llvm.amdgcn.image.gather4.c.cl.2darray
+    115, // llvm.amdgcn.image.gather4.c.cl.cube
+    115, // llvm.amdgcn.image.gather4.c.cl.o.2d
+    116, // llvm.amdgcn.image.gather4.c.cl.o.2darray
+    116, // llvm.amdgcn.image.gather4.c.cl.o.cube
+    114, // llvm.amdgcn.image.gather4.c.cube
+    114, // llvm.amdgcn.image.gather4.c.l.2d
+    115, // llvm.amdgcn.image.gather4.c.l.2darray
+    115, // llvm.amdgcn.image.gather4.c.l.cube
+    115, // llvm.amdgcn.image.gather4.c.l.o.2d
+    116, // llvm.amdgcn.image.gather4.c.l.o.2darray
+    116, // llvm.amdgcn.image.gather4.c.l.o.cube
+    113, // llvm.amdgcn.image.gather4.c.lz.2d
+    114, // llvm.amdgcn.image.gather4.c.lz.2darray
+    114, // llvm.amdgcn.image.gather4.c.lz.cube
+    114, // llvm.amdgcn.image.gather4.c.lz.o.2d
+    115, // llvm.amdgcn.image.gather4.c.lz.o.2darray
+    115, // llvm.amdgcn.image.gather4.c.lz.o.cube
+    114, // llvm.amdgcn.image.gather4.c.o.2d
+    115, // llvm.amdgcn.image.gather4.c.o.2darray
+    115, // llvm.amdgcn.image.gather4.c.o.cube
+    113, // llvm.amdgcn.image.gather4.cl.2d
+    114, // llvm.amdgcn.image.gather4.cl.2darray
+    114, // llvm.amdgcn.image.gather4.cl.cube
+    114, // llvm.amdgcn.image.gather4.cl.o.2d
+    115, // llvm.amdgcn.image.gather4.cl.o.2darray
+    115, // llvm.amdgcn.image.gather4.cl.o.cube
+    113, // llvm.amdgcn.image.gather4.cube
+    113, // llvm.amdgcn.image.gather4.l.2d
+    114, // llvm.amdgcn.image.gather4.l.2darray
+    114, // llvm.amdgcn.image.gather4.l.cube
+    114, // llvm.amdgcn.image.gather4.l.o.2d
+    115, // llvm.amdgcn.image.gather4.l.o.2darray
+    115, // llvm.amdgcn.image.gather4.l.o.cube
+    112, // llvm.amdgcn.image.gather4.lz.2d
+    113, // llvm.amdgcn.image.gather4.lz.2darray
+    113, // llvm.amdgcn.image.gather4.lz.cube
+    113, // llvm.amdgcn.image.gather4.lz.o.2d
+    114, // llvm.amdgcn.image.gather4.lz.o.2darray
+    114, // llvm.amdgcn.image.gather4.lz.o.cube
+    113, // llvm.amdgcn.image.gather4.o.2d
+    114, // llvm.amdgcn.image.gather4.o.2darray
+    114, // llvm.amdgcn.image.gather4.o.cube
+    118, // llvm.amdgcn.image.getlod.1d
+    119, // llvm.amdgcn.image.getlod.1darray
+    119, // llvm.amdgcn.image.getlod.2d
+    120, // llvm.amdgcn.image.getlod.2darray
+    120, // llvm.amdgcn.image.getlod.3d
+    120, // llvm.amdgcn.image.getlod.cube
+    121, // llvm.amdgcn.image.getresinfo.1d
+    121, // llvm.amdgcn.image.getresinfo.1darray
+    121, // llvm.amdgcn.image.getresinfo.2d
+    121, // llvm.amdgcn.image.getresinfo.2darray
+    121, // llvm.amdgcn.image.getresinfo.2darraymsaa
+    121, // llvm.amdgcn.image.getresinfo.2dmsaa
+    121, // llvm.amdgcn.image.getresinfo.3d
+    121, // llvm.amdgcn.image.getresinfo.cube
+    122, // llvm.amdgcn.image.load.1d
+    123, // llvm.amdgcn.image.load.1darray
+    123, // llvm.amdgcn.image.load.2d
+    124, // llvm.amdgcn.image.load.2darray
+    125, // llvm.amdgcn.image.load.2darraymsaa
+    124, // llvm.amdgcn.image.load.2dmsaa
+    124, // llvm.amdgcn.image.load.3d
+    124, // llvm.amdgcn.image.load.cube
+    123, // llvm.amdgcn.image.load.mip.1d
+    124, // llvm.amdgcn.image.load.mip.1darray
+    124, // llvm.amdgcn.image.load.mip.2d
+    125, // llvm.amdgcn.image.load.mip.2darray
+    125, // llvm.amdgcn.image.load.mip.3d
+    125, // llvm.amdgcn.image.load.mip.cube
+    122, // llvm.amdgcn.image.msaa.load.1d
+    123, // llvm.amdgcn.image.msaa.load.1darray
+    123, // llvm.amdgcn.image.msaa.load.2d
+    124, // llvm.amdgcn.image.msaa.load.2darray
+    125, // llvm.amdgcn.image.msaa.load.2darraymsaa
+    124, // llvm.amdgcn.image.msaa.load.2dmsaa
+    124, // llvm.amdgcn.image.msaa.load.3d
+    124, // llvm.amdgcn.image.msaa.load.cube
+    126, // llvm.amdgcn.image.sample.1d
+    112, // llvm.amdgcn.image.sample.1darray
+    112, // llvm.amdgcn.image.sample.2d
+    113, // llvm.amdgcn.image.sample.2darray
+    113, // llvm.amdgcn.image.sample.3d
+    112, // llvm.amdgcn.image.sample.b.1d
+    113, // llvm.amdgcn.image.sample.b.1darray
+    113, // llvm.amdgcn.image.sample.b.2d
+    114, // llvm.amdgcn.image.sample.b.2darray
+    114, // llvm.amdgcn.image.sample.b.3d
+    113, // llvm.amdgcn.image.sample.b.cl.1d
+    114, // llvm.amdgcn.image.sample.b.cl.1darray
+    114, // llvm.amdgcn.image.sample.b.cl.2d
+    115, // llvm.amdgcn.image.sample.b.cl.2darray
+    115, // llvm.amdgcn.image.sample.b.cl.3d
+    115, // llvm.amdgcn.image.sample.b.cl.cube
+    114, // llvm.amdgcn.image.sample.b.cl.o.1d
+    115, // llvm.amdgcn.image.sample.b.cl.o.1darray
+    115, // llvm.amdgcn.image.sample.b.cl.o.2d
+    116, // llvm.amdgcn.image.sample.b.cl.o.2darray
+    116, // llvm.amdgcn.image.sample.b.cl.o.3d
+    116, // llvm.amdgcn.image.sample.b.cl.o.cube
+    114, // llvm.amdgcn.image.sample.b.cube
+    113, // llvm.amdgcn.image.sample.b.o.1d
+    114, // llvm.amdgcn.image.sample.b.o.1darray
+    114, // llvm.amdgcn.image.sample.b.o.2d
+    115, // llvm.amdgcn.image.sample.b.o.2darray
+    115, // llvm.amdgcn.image.sample.b.o.3d
+    115, // llvm.amdgcn.image.sample.b.o.cube
+    112, // llvm.amdgcn.image.sample.c.1d
+    113, // llvm.amdgcn.image.sample.c.1darray
+    113, // llvm.amdgcn.image.sample.c.2d
+    114, // llvm.amdgcn.image.sample.c.2darray
+    114, // llvm.amdgcn.image.sample.c.3d
+    113, // llvm.amdgcn.image.sample.c.b.1d
+    114, // llvm.amdgcn.image.sample.c.b.1darray
+    114, // llvm.amdgcn.image.sample.c.b.2d
+    115, // llvm.amdgcn.image.sample.c.b.2darray
+    115, // llvm.amdgcn.image.sample.c.b.3d
+    114, // llvm.amdgcn.image.sample.c.b.cl.1d
+    115, // llvm.amdgcn.image.sample.c.b.cl.1darray
+    115, // llvm.amdgcn.image.sample.c.b.cl.2d
+    116, // llvm.amdgcn.image.sample.c.b.cl.2darray
+    116, // llvm.amdgcn.image.sample.c.b.cl.3d
+    116, // llvm.amdgcn.image.sample.c.b.cl.cube
+    115, // llvm.amdgcn.image.sample.c.b.cl.o.1d
+    116, // llvm.amdgcn.image.sample.c.b.cl.o.1darray
+    116, // llvm.amdgcn.image.sample.c.b.cl.o.2d
+    117, // llvm.amdgcn.image.sample.c.b.cl.o.2darray
+    117, // llvm.amdgcn.image.sample.c.b.cl.o.3d
+    117, // llvm.amdgcn.image.sample.c.b.cl.o.cube
+    115, // llvm.amdgcn.image.sample.c.b.cube
+    114, // llvm.amdgcn.image.sample.c.b.o.1d
+    115, // llvm.amdgcn.image.sample.c.b.o.1darray
+    115, // llvm.amdgcn.image.sample.c.b.o.2d
+    116, // llvm.amdgcn.image.sample.c.b.o.2darray
+    116, // llvm.amdgcn.image.sample.c.b.o.3d
+    116, // llvm.amdgcn.image.sample.c.b.o.cube
+    114, // llvm.amdgcn.image.sample.c.cd.1d
+    115, // llvm.amdgcn.image.sample.c.cd.1darray
+    117, // llvm.amdgcn.image.sample.c.cd.2d
+    127, // llvm.amdgcn.image.sample.c.cd.2darray
+    128, // llvm.amdgcn.image.sample.c.cd.3d
+    115, // llvm.amdgcn.image.sample.c.cd.cl.1d
+    116, // llvm.amdgcn.image.sample.c.cd.cl.1darray
+    127, // llvm.amdgcn.image.sample.c.cd.cl.2d
+    129, // llvm.amdgcn.image.sample.c.cd.cl.2darray
+    130, // llvm.amdgcn.image.sample.c.cd.cl.3d
+    129, // llvm.amdgcn.image.sample.c.cd.cl.cube
+    116, // llvm.amdgcn.image.sample.c.cd.cl.o.1d
+    117, // llvm.amdgcn.image.sample.c.cd.cl.o.1darray
+    129, // llvm.amdgcn.image.sample.c.cd.cl.o.2d
+    128, // llvm.amdgcn.image.sample.c.cd.cl.o.2darray
+    131, // llvm.amdgcn.image.sample.c.cd.cl.o.3d
+    128, // llvm.amdgcn.image.sample.c.cd.cl.o.cube
+    127, // llvm.amdgcn.image.sample.c.cd.cube
+    115, // llvm.amdgcn.image.sample.c.cd.o.1d
+    116, // llvm.amdgcn.image.sample.c.cd.o.1darray
+    127, // llvm.amdgcn.image.sample.c.cd.o.2d
+    129, // llvm.amdgcn.image.sample.c.cd.o.2darray
+    130, // llvm.amdgcn.image.sample.c.cd.o.3d
+    129, // llvm.amdgcn.image.sample.c.cd.o.cube
+    113, // llvm.amdgcn.image.sample.c.cl.1d
+    114, // llvm.amdgcn.image.sample.c.cl.1darray
+    114, // llvm.amdgcn.image.sample.c.cl.2d
+    115, // llvm.amdgcn.image.sample.c.cl.2darray
+    115, // llvm.amdgcn.image.sample.c.cl.3d
+    115, // llvm.amdgcn.image.sample.c.cl.cube
+    114, // llvm.amdgcn.image.sample.c.cl.o.1d
+    115, // llvm.amdgcn.image.sample.c.cl.o.1darray
+    115, // llvm.amdgcn.image.sample.c.cl.o.2d
+    116, // llvm.amdgcn.image.sample.c.cl.o.2darray
+    116, // llvm.amdgcn.image.sample.c.cl.o.3d
+    116, // llvm.amdgcn.image.sample.c.cl.o.cube
+    114, // llvm.amdgcn.image.sample.c.cube
+    114, // llvm.amdgcn.image.sample.c.d.1d
+    115, // llvm.amdgcn.image.sample.c.d.1darray
+    117, // llvm.amdgcn.image.sample.c.d.2d
+    127, // llvm.amdgcn.image.sample.c.d.2darray
+    128, // llvm.amdgcn.image.sample.c.d.3d
+    115, // llvm.amdgcn.image.sample.c.d.cl.1d
+    116, // llvm.amdgcn.image.sample.c.d.cl.1darray
+    127, // llvm.amdgcn.image.sample.c.d.cl.2d
+    129, // llvm.amdgcn.image.sample.c.d.cl.2darray
+    130, // llvm.amdgcn.image.sample.c.d.cl.3d
+    129, // llvm.amdgcn.image.sample.c.d.cl.cube
+    116, // llvm.amdgcn.image.sample.c.d.cl.o.1d
+    117, // llvm.amdgcn.image.sample.c.d.cl.o.1darray
+    129, // llvm.amdgcn.image.sample.c.d.cl.o.2d
+    128, // llvm.amdgcn.image.sample.c.d.cl.o.2darray
+    131, // llvm.amdgcn.image.sample.c.d.cl.o.3d
+    128, // llvm.amdgcn.image.sample.c.d.cl.o.cube
+    127, // llvm.amdgcn.image.sample.c.d.cube
+    115, // llvm.amdgcn.image.sample.c.d.o.1d
+    116, // llvm.amdgcn.image.sample.c.d.o.1darray
+    127, // llvm.amdgcn.image.sample.c.d.o.2d
+    129, // llvm.amdgcn.image.sample.c.d.o.2darray
+    130, // llvm.amdgcn.image.sample.c.d.o.3d
+    129, // llvm.amdgcn.image.sample.c.d.o.cube
+    113, // llvm.amdgcn.image.sample.c.l.1d
+    114, // llvm.amdgcn.image.sample.c.l.1darray
+    114, // llvm.amdgcn.image.sample.c.l.2d
+    115, // llvm.amdgcn.image.sample.c.l.2darray
+    115, // llvm.amdgcn.image.sample.c.l.3d
+    115, // llvm.amdgcn.image.sample.c.l.cube
+    114, // llvm.amdgcn.image.sample.c.l.o.1d
+    115, // llvm.amdgcn.image.sample.c.l.o.1darray
+    115, // llvm.amdgcn.image.sample.c.l.o.2d
+    116, // llvm.amdgcn.image.sample.c.l.o.2darray
+    116, // llvm.amdgcn.image.sample.c.l.o.3d
+    116, // llvm.amdgcn.image.sample.c.l.o.cube
+    112, // llvm.amdgcn.image.sample.c.lz.1d
+    113, // llvm.amdgcn.image.sample.c.lz.1darray
+    113, // llvm.amdgcn.image.sample.c.lz.2d
+    114, // llvm.amdgcn.image.sample.c.lz.2darray
+    114, // llvm.amdgcn.image.sample.c.lz.3d
+    114, // llvm.amdgcn.image.sample.c.lz.cube
+    113, // llvm.amdgcn.image.sample.c.lz.o.1d
+    114, // llvm.amdgcn.image.sample.c.lz.o.1darray
+    114, // llvm.amdgcn.image.sample.c.lz.o.2d
+    115, // llvm.amdgcn.image.sample.c.lz.o.2darray
+    115, // llvm.amdgcn.image.sample.c.lz.o.3d
+    115, // llvm.amdgcn.image.sample.c.lz.o.cube
+    113, // llvm.amdgcn.image.sample.c.o.1d
+    114, // llvm.amdgcn.image.sample.c.o.1darray
+    114, // llvm.amdgcn.image.sample.c.o.2d
+    115, // llvm.amdgcn.image.sample.c.o.2darray
+    115, // llvm.amdgcn.image.sample.c.o.3d
+    115, // llvm.amdgcn.image.sample.c.o.cube
+    113, // llvm.amdgcn.image.sample.cd.1d
+    114, // llvm.amdgcn.image.sample.cd.1darray
+    116, // llvm.amdgcn.image.sample.cd.2d
+    117, // llvm.amdgcn.image.sample.cd.2darray
+    129, // llvm.amdgcn.image.sample.cd.3d
+    114, // llvm.amdgcn.image.sample.cd.cl.1d
+    115, // llvm.amdgcn.image.sample.cd.cl.1darray
+    117, // llvm.amdgcn.image.sample.cd.cl.2d
+    127, // llvm.amdgcn.image.sample.cd.cl.2darray
+    128, // llvm.amdgcn.image.sample.cd.cl.3d
+    127, // llvm.amdgcn.image.sample.cd.cl.cube
+    115, // llvm.amdgcn.image.sample.cd.cl.o.1d
+    116, // llvm.amdgcn.image.sample.cd.cl.o.1darray
+    127, // llvm.amdgcn.image.sample.cd.cl.o.2d
+    129, // llvm.amdgcn.image.sample.cd.cl.o.2darray
+    130, // llvm.amdgcn.image.sample.cd.cl.o.3d
+    129, // llvm.amdgcn.image.sample.cd.cl.o.cube
+    117, // llvm.amdgcn.image.sample.cd.cube
+    114, // llvm.amdgcn.image.sample.cd.o.1d
+    115, // llvm.amdgcn.image.sample.cd.o.1darray
+    117, // llvm.amdgcn.image.sample.cd.o.2d
+    127, // llvm.amdgcn.image.sample.cd.o.2darray
+    128, // llvm.amdgcn.image.sample.cd.o.3d
+    127, // llvm.amdgcn.image.sample.cd.o.cube
+    112, // llvm.amdgcn.image.sample.cl.1d
+    113, // llvm.amdgcn.image.sample.cl.1darray
+    113, // llvm.amdgcn.image.sample.cl.2d
+    114, // llvm.amdgcn.image.sample.cl.2darray
+    114, // llvm.amdgcn.image.sample.cl.3d
+    114, // llvm.amdgcn.image.sample.cl.cube
+    113, // llvm.amdgcn.image.sample.cl.o.1d
+    114, // llvm.amdgcn.image.sample.cl.o.1darray
+    114, // llvm.amdgcn.image.sample.cl.o.2d
+    115, // llvm.amdgcn.image.sample.cl.o.2darray
+    115, // llvm.amdgcn.image.sample.cl.o.3d
+    115, // llvm.amdgcn.image.sample.cl.o.cube
+    113, // llvm.amdgcn.image.sample.cube
+    113, // llvm.amdgcn.image.sample.d.1d
+    114, // llvm.amdgcn.image.sample.d.1darray
+    116, // llvm.amdgcn.image.sample.d.2d
+    117, // llvm.amdgcn.image.sample.d.2darray
+    129, // llvm.amdgcn.image.sample.d.3d
+    114, // llvm.amdgcn.image.sample.d.cl.1d
+    115, // llvm.amdgcn.image.sample.d.cl.1darray
+    117, // llvm.amdgcn.image.sample.d.cl.2d
+    127, // llvm.amdgcn.image.sample.d.cl.2darray
+    128, // llvm.amdgcn.image.sample.d.cl.3d
+    127, // llvm.amdgcn.image.sample.d.cl.cube
+    115, // llvm.amdgcn.image.sample.d.cl.o.1d
+    116, // llvm.amdgcn.image.sample.d.cl.o.1darray
+    127, // llvm.amdgcn.image.sample.d.cl.o.2d
+    129, // llvm.amdgcn.image.sample.d.cl.o.2darray
+    130, // llvm.amdgcn.image.sample.d.cl.o.3d
+    129, // llvm.amdgcn.image.sample.d.cl.o.cube
+    117, // llvm.amdgcn.image.sample.d.cube
+    114, // llvm.amdgcn.image.sample.d.o.1d
+    115, // llvm.amdgcn.image.sample.d.o.1darray
+    117, // llvm.amdgcn.image.sample.d.o.2d
+    127, // llvm.amdgcn.image.sample.d.o.2darray
+    128, // llvm.amdgcn.image.sample.d.o.3d
+    127, // llvm.amdgcn.image.sample.d.o.cube
+    112, // llvm.amdgcn.image.sample.l.1d
+    113, // llvm.amdgcn.image.sample.l.1darray
+    113, // llvm.amdgcn.image.sample.l.2d
+    114, // llvm.amdgcn.image.sample.l.2darray
+    114, // llvm.amdgcn.image.sample.l.3d
+    114, // llvm.amdgcn.image.sample.l.cube
+    113, // llvm.amdgcn.image.sample.l.o.1d
+    114, // llvm.amdgcn.image.sample.l.o.1darray
+    114, // llvm.amdgcn.image.sample.l.o.2d
+    115, // llvm.amdgcn.image.sample.l.o.2darray
+    115, // llvm.amdgcn.image.sample.l.o.3d
+    115, // llvm.amdgcn.image.sample.l.o.cube
+    126, // llvm.amdgcn.image.sample.lz.1d
+    112, // llvm.amdgcn.image.sample.lz.1darray
+    112, // llvm.amdgcn.image.sample.lz.2d
+    113, // llvm.amdgcn.image.sample.lz.2darray
+    113, // llvm.amdgcn.image.sample.lz.3d
+    113, // llvm.amdgcn.image.sample.lz.cube
+    112, // llvm.amdgcn.image.sample.lz.o.1d
+    113, // llvm.amdgcn.image.sample.lz.o.1darray
+    113, // llvm.amdgcn.image.sample.lz.o.2d
+    114, // llvm.amdgcn.image.sample.lz.o.2darray
+    114, // llvm.amdgcn.image.sample.lz.o.3d
+    114, // llvm.amdgcn.image.sample.lz.o.cube
+    112, // llvm.amdgcn.image.sample.o.1d
+    113, // llvm.amdgcn.image.sample.o.1darray
+    113, // llvm.amdgcn.image.sample.o.2d
+    114, // llvm.amdgcn.image.sample.o.2darray
+    114, // llvm.amdgcn.image.sample.o.3d
+    114, // llvm.amdgcn.image.sample.o.cube
+    132, // llvm.amdgcn.image.store.1d
+    133, // llvm.amdgcn.image.store.1darray
+    133, // llvm.amdgcn.image.store.2d
+    134, // llvm.amdgcn.image.store.2darray
+    135, // llvm.amdgcn.image.store.2darraymsaa
+    134, // llvm.amdgcn.image.store.2dmsaa
+    134, // llvm.amdgcn.image.store.3d
+    134, // llvm.amdgcn.image.store.cube
+    133, // llvm.amdgcn.image.store.mip.1d
+    134, // llvm.amdgcn.image.store.mip.1darray
+    134, // llvm.amdgcn.image.store.mip.2d
+    135, // llvm.amdgcn.image.store.mip.2darray
+    135, // llvm.amdgcn.image.store.mip.3d
+    135, // llvm.amdgcn.image.store.mip.cube
+    93, // llvm.amdgcn.implicit.buffer.ptr
+    93, // llvm.amdgcn.implicitarg.ptr
+    136, // llvm.amdgcn.init.exec
+    137, // llvm.amdgcn.init.exec.from.input
+    138, // llvm.amdgcn.interp.mov
+    139, // llvm.amdgcn.interp.p1
+    140, // llvm.amdgcn.interp.p1.f16
+    141, // llvm.amdgcn.interp.p2
+    142, // llvm.amdgcn.interp.p2.f16
+    143, // llvm.amdgcn.is.private
+    143, // llvm.amdgcn.is.shared
+    93, // llvm.amdgcn.kernarg.segment.ptr
+    7, // llvm.amdgcn.kill
+    84, // llvm.amdgcn.ldexp
+    84, // llvm.amdgcn.lerp
+    84, // llvm.amdgcn.log.clamp
+    100, // llvm.amdgcn.loop
+    144, // llvm.amdgcn.mbcnt.hi
+    144, // llvm.amdgcn.mbcnt.lo
+    145, // llvm.amdgcn.mfma.f32.16x16x16f16
+    145, // llvm.amdgcn.mfma.f32.16x16x1f32
+    145, // llvm.amdgcn.mfma.f32.16x16x2bf16
+    145, // llvm.amdgcn.mfma.f32.16x16x4f16
+    145, // llvm.amdgcn.mfma.f32.16x16x4f32
+    145, // llvm.amdgcn.mfma.f32.16x16x8bf16
+    145, // llvm.amdgcn.mfma.f32.32x32x1f32
+    145, // llvm.amdgcn.mfma.f32.32x32x2bf16
+    145, // llvm.amdgcn.mfma.f32.32x32x2f32
+    145, // llvm.amdgcn.mfma.f32.32x32x4bf16
+    145, // llvm.amdgcn.mfma.f32.32x32x4f16
+    145, // llvm.amdgcn.mfma.f32.32x32x8f16
+    145, // llvm.amdgcn.mfma.f32.4x4x1f32
+    145, // llvm.amdgcn.mfma.f32.4x4x2bf16
+    145, // llvm.amdgcn.mfma.f32.4x4x4f16
+    145, // llvm.amdgcn.mfma.i32.16x16x16i8
+    145, // llvm.amdgcn.mfma.i32.16x16x4i8
+    145, // llvm.amdgcn.mfma.i32.32x32x4i8
+    145, // llvm.amdgcn.mfma.i32.32x32x8i8
+    145, // llvm.amdgcn.mfma.i32.4x4x4i8
+    146, // llvm.amdgcn.mov.dpp
+    99, // llvm.amdgcn.mov.dpp8
+    84, // llvm.amdgcn.mqsad.pk.u16.u8
+    84, // llvm.amdgcn.mqsad.u32.u8
+    84, // llvm.amdgcn.msad.u8
+    84, // llvm.amdgcn.mul.i24
+    84, // llvm.amdgcn.mul.u24
+    147, // llvm.amdgcn.permlane16
+    147, // llvm.amdgcn.permlanex16
+    144, // llvm.amdgcn.ps.live
+    84, // llvm.amdgcn.qsad.pk.u16.u8
+    93, // llvm.amdgcn.queue.ptr
+    87, // llvm.amdgcn.raw.buffer.atomic.add
+    87, // llvm.amdgcn.raw.buffer.atomic.and
+    88, // llvm.amdgcn.raw.buffer.atomic.cmpswap
+    87, // llvm.amdgcn.raw.buffer.atomic.dec
+    87, // llvm.amdgcn.raw.buffer.atomic.fadd
+    87, // llvm.amdgcn.raw.buffer.atomic.inc
+    87, // llvm.amdgcn.raw.buffer.atomic.or
+    87, // llvm.amdgcn.raw.buffer.atomic.smax
+    87, // llvm.amdgcn.raw.buffer.atomic.smin
+    87, // llvm.amdgcn.raw.buffer.atomic.sub
+    87, // llvm.amdgcn.raw.buffer.atomic.swap
+    87, // llvm.amdgcn.raw.buffer.atomic.umax
+    87, // llvm.amdgcn.raw.buffer.atomic.umin
+    87, // llvm.amdgcn.raw.buffer.atomic.xor
+    148, // llvm.amdgcn.raw.buffer.load
+    148, // llvm.amdgcn.raw.buffer.load.format
+    149, // llvm.amdgcn.raw.buffer.store
+    149, // llvm.amdgcn.raw.buffer.store.format
+    90, // llvm.amdgcn.raw.tbuffer.load
+    91, // llvm.amdgcn.raw.tbuffer.store
+    84, // llvm.amdgcn.rcp
+    84, // llvm.amdgcn.rcp.legacy
+    86, // llvm.amdgcn.readfirstlane
+    86, // llvm.amdgcn.readlane
+    84, // llvm.amdgcn.reloc.constant
+    84, // llvm.amdgcn.rsq
+    84, // llvm.amdgcn.rsq.clamp
+    84, // llvm.amdgcn.rsq.legacy
+    150, // llvm.amdgcn.s.barrier
+    151, // llvm.amdgcn.s.buffer.load
+    92, // llvm.amdgcn.s.dcache.inv
+    92, // llvm.amdgcn.s.dcache.inv.vol
+    92, // llvm.amdgcn.s.dcache.wb
+    92, // llvm.amdgcn.s.dcache.wb.vol
+    152, // llvm.amdgcn.s.decperflevel
+    153, // llvm.amdgcn.s.get.waveid.in.workgroup
+    84, // llvm.amdgcn.s.getpc
+    154, // llvm.amdgcn.s.getreg
+    152, // llvm.amdgcn.s.incperflevel
+    155, // llvm.amdgcn.s.memrealtime
+    155, // llvm.amdgcn.s.memtime
+    156, // llvm.amdgcn.s.sendmsg
+    156, // llvm.amdgcn.s.sendmsghalt
+    156, // llvm.amdgcn.s.setreg
+    152, // llvm.amdgcn.s.sleep
+    152, // llvm.amdgcn.s.waitcnt
+    84, // llvm.amdgcn.sad.hi.u8
+    84, // llvm.amdgcn.sad.u16
+    84, // llvm.amdgcn.sad.u8
+    84, // llvm.amdgcn.sbfe
+    105, // llvm.amdgcn.sdot2
+    105, // llvm.amdgcn.sdot4
+    105, // llvm.amdgcn.sdot8
+    86, // llvm.amdgcn.set.inactive
+    84, // llvm.amdgcn.sffbh
+    84, // llvm.amdgcn.sin
+    84, // llvm.amdgcn.softwqm
+    84, // llvm.amdgcn.sqrt
+    88, // llvm.amdgcn.struct.buffer.atomic.add
+    88, // llvm.amdgcn.struct.buffer.atomic.and
+    157, // llvm.amdgcn.struct.buffer.atomic.cmpswap
+    88, // llvm.amdgcn.struct.buffer.atomic.dec
+    88, // llvm.amdgcn.struct.buffer.atomic.fadd
+    88, // llvm.amdgcn.struct.buffer.atomic.inc
+    88, // llvm.amdgcn.struct.buffer.atomic.or
+    88, // llvm.amdgcn.struct.buffer.atomic.smax
+    88, // llvm.amdgcn.struct.buffer.atomic.smin
+    88, // llvm.amdgcn.struct.buffer.atomic.sub
+    88, // llvm.amdgcn.struct.buffer.atomic.swap
+    88, // llvm.amdgcn.struct.buffer.atomic.umax
+    88, // llvm.amdgcn.struct.buffer.atomic.umin
+    88, // llvm.amdgcn.struct.buffer.atomic.xor
+    158, // llvm.amdgcn.struct.buffer.load
+    158, // llvm.amdgcn.struct.buffer.load.format
+    159, // llvm.amdgcn.struct.buffer.store
+    159, // llvm.amdgcn.struct.buffer.store.format
+    160, // llvm.amdgcn.struct.tbuffer.load
+    161, // llvm.amdgcn.struct.tbuffer.store
+    162, // llvm.amdgcn.tbuffer.load
+    163, // llvm.amdgcn.tbuffer.store
+    84, // llvm.amdgcn.trig.preop
+    84, // llvm.amdgcn.ubfe
+    105, // llvm.amdgcn.udot2
+    105, // llvm.amdgcn.udot4
+    105, // llvm.amdgcn.udot8
+    164, // llvm.amdgcn.unreachable
+    165, // llvm.amdgcn.update.dpp
+    150, // llvm.amdgcn.wave.barrier
+    84, // llvm.amdgcn.wavefrontsize
+    84, // llvm.amdgcn.workgroup.id.x
+    84, // llvm.amdgcn.workgroup.id.y
+    84, // llvm.amdgcn.workgroup.id.z
+    84, // llvm.amdgcn.workitem.id.x
+    84, // llvm.amdgcn.workitem.id.y
+    84, // llvm.amdgcn.workitem.id.z
+    84, // llvm.amdgcn.wqm
+    86, // llvm.amdgcn.wqm.vote
+    86, // llvm.amdgcn.writelane
+    166, // llvm.amdgcn.wwm
+    167, // llvm.arm.cde.cx1
+    168, // llvm.arm.cde.cx1a
+    167, // llvm.arm.cde.cx1d
+    169, // llvm.arm.cde.cx1da
+    168, // llvm.arm.cde.cx2
+    169, // llvm.arm.cde.cx2a
+    168, // llvm.arm.cde.cx2d
+    170, // llvm.arm.cde.cx2da
+    169, // llvm.arm.cde.cx3
+    170, // llvm.arm.cde.cx3a
+    169, // llvm.arm.cde.cx3d
+    171, // llvm.arm.cde.cx3da
+    167, // llvm.arm.cde.vcx1
+    168, // llvm.arm.cde.vcx1a
+    167, // llvm.arm.cde.vcx1q
+    168, // llvm.arm.cde.vcx1q.predicated
+    168, // llvm.arm.cde.vcx1qa
+    168, // llvm.arm.cde.vcx1qa.predicated
+    168, // llvm.arm.cde.vcx2
+    169, // llvm.arm.cde.vcx2a
+    168, // llvm.arm.cde.vcx2q
+    169, // llvm.arm.cde.vcx2q.predicated
+    169, // llvm.arm.cde.vcx2qa
+    169, // llvm.arm.cde.vcx2qa.predicated
+    169, // llvm.arm.cde.vcx3
+    170, // llvm.arm.cde.vcx3a
+    169, // llvm.arm.cde.vcx3q
+    170, // llvm.arm.cde.vcx3q.predicated
+    170, // llvm.arm.cde.vcx3qa
+    170, // llvm.arm.cde.vcx3qa.predicated
+    172, // llvm.arm.cdp
+    172, // llvm.arm.cdp2
+    7, // llvm.arm.clrex
+    12, // llvm.arm.cls
+    12, // llvm.arm.cls64
+    12, // llvm.arm.cmse.tt
+    12, // llvm.arm.cmse.tta
+    12, // llvm.arm.cmse.ttat
+    12, // llvm.arm.cmse.ttt
+    12, // llvm.arm.crc32b
+    12, // llvm.arm.crc32cb
+    12, // llvm.arm.crc32ch
+    12, // llvm.arm.crc32cw
+    12, // llvm.arm.crc32h
+    12, // llvm.arm.crc32w
+    7, // llvm.arm.dbg
+    7, // llvm.arm.dmb
+    7, // llvm.arm.dsb
+    7, // llvm.arm.get.fpscr
+    7, // llvm.arm.gnu.eabi.mcount
+    7, // llvm.arm.hint
+    7, // llvm.arm.isb
+    7, // llvm.arm.ldaex
+    7, // llvm.arm.ldaexd
+    173, // llvm.arm.ldc
+    173, // llvm.arm.ldc2
+    173, // llvm.arm.ldc2l
+    173, // llvm.arm.ldcl
+    7, // llvm.arm.ldrex
+    7, // llvm.arm.ldrexd
+    174, // llvm.arm.mcr
+    174, // llvm.arm.mcr2
+    175, // llvm.arm.mcrr
+    175, // llvm.arm.mcrr2
+    176, // llvm.arm.mrc
+    176, // llvm.arm.mrc2
+    177, // llvm.arm.mrrc
+    177, // llvm.arm.mrrc2
+    12, // llvm.arm.mve.abd.predicated
+    12, // llvm.arm.mve.abs.predicated
+    12, // llvm.arm.mve.add.predicated
+    12, // llvm.arm.mve.addlv
+    12, // llvm.arm.mve.addlv.predicated
+    12, // llvm.arm.mve.addv
+    12, // llvm.arm.mve.addv.predicated
+    12, // llvm.arm.mve.and.predicated
+    12, // llvm.arm.mve.asrl
+    12, // llvm.arm.mve.bic.predicated
+    12, // llvm.arm.mve.cls.predicated
+    12, // llvm.arm.mve.clz.predicated
+    12, // llvm.arm.mve.eor.predicated
+    12, // llvm.arm.mve.fma.predicated
+    12, // llvm.arm.mve.hadd.predicated
+    12, // llvm.arm.mve.hsub.predicated
+    12, // llvm.arm.mve.lsll
+    12, // llvm.arm.mve.max.predicated
+    12, // llvm.arm.mve.maxav
+    12, // llvm.arm.mve.maxav.predicated
+    12, // llvm.arm.mve.maxnmav
+    12, // llvm.arm.mve.maxnmav.predicated
+    12, // llvm.arm.mve.maxnmv
+    12, // llvm.arm.mve.maxnmv.predicated
+    12, // llvm.arm.mve.maxv
+    12, // llvm.arm.mve.maxv.predicated
+    12, // llvm.arm.mve.min.predicated
+    12, // llvm.arm.mve.minav
+    12, // llvm.arm.mve.minav.predicated
+    12, // llvm.arm.mve.minnmav
+    12, // llvm.arm.mve.minnmav.predicated
+    12, // llvm.arm.mve.minnmv
+    12, // llvm.arm.mve.minnmv.predicated
+    12, // llvm.arm.mve.minv
+    12, // llvm.arm.mve.minv.predicated
+    12, // llvm.arm.mve.mul.predicated
+    12, // llvm.arm.mve.mulh.predicated
+    12, // llvm.arm.mve.mull.int.predicated
+    12, // llvm.arm.mve.mull.poly.predicated
+    12, // llvm.arm.mve.mvn.predicated
+    12, // llvm.arm.mve.neg.predicated
+    12, // llvm.arm.mve.orn.predicated
+    12, // llvm.arm.mve.orr.predicated
+    12, // llvm.arm.mve.pred.i2v
+    12, // llvm.arm.mve.pred.v2i
+    12, // llvm.arm.mve.qabs.predicated
+    12, // llvm.arm.mve.qadd.predicated
+    12, // llvm.arm.mve.qdmulh.predicated
+    12, // llvm.arm.mve.qneg.predicated
+    12, // llvm.arm.mve.qrdmulh.predicated
+    12, // llvm.arm.mve.qsub.predicated
+    12, // llvm.arm.mve.rhadd.predicated
+    12, // llvm.arm.mve.rmulh.predicated
+    12, // llvm.arm.mve.shl.imm.predicated
+    12, // llvm.arm.mve.shr.imm.predicated
+    12, // llvm.arm.mve.sqrshr
+    12, // llvm.arm.mve.sqrshrl
+    12, // llvm.arm.mve.sqshl
+    12, // llvm.arm.mve.sqshll
+    12, // llvm.arm.mve.srshr
+    12, // llvm.arm.mve.srshrl
+    12, // llvm.arm.mve.sub.predicated
+    12, // llvm.arm.mve.uqrshl
+    12, // llvm.arm.mve.uqrshll
+    12, // llvm.arm.mve.uqshl
+    12, // llvm.arm.mve.uqshll
+    12, // llvm.arm.mve.urshr
+    12, // llvm.arm.mve.urshrl
+    12, // llvm.arm.mve.vabav
+    12, // llvm.arm.mve.vabav.predicated
+    12, // llvm.arm.mve.vabd
+    12, // llvm.arm.mve.vadc
+    12, // llvm.arm.mve.vadc.predicated
+    12, // llvm.arm.mve.vbrsr
+    12, // llvm.arm.mve.vbrsr.predicated
+    12, // llvm.arm.mve.vcaddq
+    12, // llvm.arm.mve.vcaddq.predicated
+    12, // llvm.arm.mve.vcls
+    12, // llvm.arm.mve.vcmlaq
+    12, // llvm.arm.mve.vcmlaq.predicated
+    12, // llvm.arm.mve.vcmulq
+    12, // llvm.arm.mve.vcmulq.predicated
+    12, // llvm.arm.mve.vctp16
+    12, // llvm.arm.mve.vctp32
+    12, // llvm.arm.mve.vctp64
+    12, // llvm.arm.mve.vctp8
+    12, // llvm.arm.mve.vcvt.fix
+    12, // llvm.arm.mve.vcvt.fix.predicated
+    12, // llvm.arm.mve.vcvt.fp.int.predicated
+    12, // llvm.arm.mve.vcvt.narrow
+    12, // llvm.arm.mve.vcvt.narrow.predicated
+    12, // llvm.arm.mve.vcvt.widen
+    12, // llvm.arm.mve.vcvt.widen.predicated
+    12, // llvm.arm.mve.vcvta
+    12, // llvm.arm.mve.vcvta.predicated
+    12, // llvm.arm.mve.vcvtm
+    12, // llvm.arm.mve.vcvtm.predicated
+    12, // llvm.arm.mve.vcvtn
+    12, // llvm.arm.mve.vcvtn.predicated
+    12, // llvm.arm.mve.vcvtp
+    12, // llvm.arm.mve.vcvtp.predicated
+    12, // llvm.arm.mve.vddup
+    12, // llvm.arm.mve.vddup.predicated
+    12, // llvm.arm.mve.vdwdup
+    12, // llvm.arm.mve.vdwdup.predicated
+    12, // llvm.arm.mve.vhadd
+    12, // llvm.arm.mve.vhsub
+    12, // llvm.arm.mve.vidup
+    12, // llvm.arm.mve.vidup.predicated
+    12, // llvm.arm.mve.viwdup
+    12, // llvm.arm.mve.viwdup.predicated
+    3, // llvm.arm.mve.vld2q
+    3, // llvm.arm.mve.vld4q
+    21, // llvm.arm.mve.vldr.gather.base
+    21, // llvm.arm.mve.vldr.gather.base.predicated
+    21, // llvm.arm.mve.vldr.gather.base.wb
+    21, // llvm.arm.mve.vldr.gather.base.wb.predicated
+    21, // llvm.arm.mve.vldr.gather.offset
+    21, // llvm.arm.mve.vldr.gather.offset.predicated
+    12, // llvm.arm.mve.vmaxa.predicated
+    12, // llvm.arm.mve.vmaxnma.predicated
+    12, // llvm.arm.mve.vmina.predicated
+    12, // llvm.arm.mve.vminnma.predicated
+    12, // llvm.arm.mve.vmla.n.predicated
+    12, // llvm.arm.mve.vmlas.n.predicated
+    12, // llvm.arm.mve.vmldava
+    12, // llvm.arm.mve.vmldava.predicated
+    12, // llvm.arm.mve.vmlldava
+    12, // llvm.arm.mve.vmlldava.predicated
+    12, // llvm.arm.mve.vmovl.predicated
+    12, // llvm.arm.mve.vmovn.predicated
+    12, // llvm.arm.mve.vmulh
+    12, // llvm.arm.mve.vmull
+    12, // llvm.arm.mve.vmull.poly
+    12, // llvm.arm.mve.vqdmlad
+    12, // llvm.arm.mve.vqdmlad.predicated
+    12, // llvm.arm.mve.vqdmlah
+    12, // llvm.arm.mve.vqdmlah.predicated
+    12, // llvm.arm.mve.vqdmlash
+    12, // llvm.arm.mve.vqdmlash.predicated
+    12, // llvm.arm.mve.vqdmulh
+    12, // llvm.arm.mve.vqdmull
+    12, // llvm.arm.mve.vqdmull.predicated
+    12, // llvm.arm.mve.vqmovn
+    12, // llvm.arm.mve.vqmovn.predicated
+    12, // llvm.arm.mve.vqrdmlah
+    12, // llvm.arm.mve.vqrdmlah.predicated
+    12, // llvm.arm.mve.vqrdmlash
+    12, // llvm.arm.mve.vqrdmlash.predicated
+    12, // llvm.arm.mve.vqrdmulh
+    12, // llvm.arm.mve.vqshl.imm
+    12, // llvm.arm.mve.vqshl.imm.predicated
+    12, // llvm.arm.mve.vqshlu.imm
+    12, // llvm.arm.mve.vqshlu.imm.predicated
+    12, // llvm.arm.mve.vreinterpretq
+    12, // llvm.arm.mve.vrev.predicated
+    12, // llvm.arm.mve.vrhadd
+    12, // llvm.arm.mve.vrinta.predicated
+    12, // llvm.arm.mve.vrintm.predicated
+    12, // llvm.arm.mve.vrintn
+    12, // llvm.arm.mve.vrintn.predicated
+    12, // llvm.arm.mve.vrintp.predicated
+    12, // llvm.arm.mve.vrintx.predicated
+    12, // llvm.arm.mve.vrintz.predicated
+    12, // llvm.arm.mve.vrmlldavha
+    12, // llvm.arm.mve.vrmlldavha.predicated
+    12, // llvm.arm.mve.vrmulh
+    12, // llvm.arm.mve.vrshr.imm
+    12, // llvm.arm.mve.vrshr.imm.predicated
+    12, // llvm.arm.mve.vsbc
+    12, // llvm.arm.mve.vsbc.predicated
+    12, // llvm.arm.mve.vshl.scalar
+    12, // llvm.arm.mve.vshl.scalar.predicated
+    12, // llvm.arm.mve.vshl.vector
+    12, // llvm.arm.mve.vshl.vector.predicated
+    12, // llvm.arm.mve.vshlc
+    12, // llvm.arm.mve.vshlc.predicated
+    12, // llvm.arm.mve.vshll.imm
+    12, // llvm.arm.mve.vshll.imm.predicated
+    12, // llvm.arm.mve.vshrn
+    12, // llvm.arm.mve.vshrn.predicated
+    12, // llvm.arm.mve.vsli
+    12, // llvm.arm.mve.vsli.predicated
+    12, // llvm.arm.mve.vsri
+    12, // llvm.arm.mve.vsri.predicated
+    80, // llvm.arm.mve.vst2q
+    80, // llvm.arm.mve.vst4q
+    69, // llvm.arm.mve.vstr.scatter.base
+    69, // llvm.arm.mve.vstr.scatter.base.predicated
+    69, // llvm.arm.mve.vstr.scatter.base.wb
+    69, // llvm.arm.mve.vstr.scatter.base.wb.predicated
+    69, // llvm.arm.mve.vstr.scatter.offset
+    69, // llvm.arm.mve.vstr.scatter.offset.predicated
+    12, // llvm.arm.neon.aesd
+    12, // llvm.arm.neon.aese
+    12, // llvm.arm.neon.aesimc
+    12, // llvm.arm.neon.aesmc
+    12, // llvm.arm.neon.bfdot
+    12, // llvm.arm.neon.bfmlalb
+    12, // llvm.arm.neon.bfmlalt
+    12, // llvm.arm.neon.bfmmla
+    12, // llvm.arm.neon.sdot
+    12, // llvm.arm.neon.sha1c
+    12, // llvm.arm.neon.sha1h
+    12, // llvm.arm.neon.sha1m
+    12, // llvm.arm.neon.sha1p
+    12, // llvm.arm.neon.sha1su0
+    12, // llvm.arm.neon.sha1su1
+    12, // llvm.arm.neon.sha256h
+    12, // llvm.arm.neon.sha256h2
+    12, // llvm.arm.neon.sha256su0
+    12, // llvm.arm.neon.sha256su1
+    12, // llvm.arm.neon.smmla
+    12, // llvm.arm.neon.udot
+    12, // llvm.arm.neon.ummla
+    12, // llvm.arm.neon.usdot
+    12, // llvm.arm.neon.usmmla
+    12, // llvm.arm.neon.vabds
+    12, // llvm.arm.neon.vabdu
+    12, // llvm.arm.neon.vabs
+    12, // llvm.arm.neon.vacge
+    12, // llvm.arm.neon.vacgt
+    12, // llvm.arm.neon.vbsl
+    12, // llvm.arm.neon.vcadd.rot270
+    12, // llvm.arm.neon.vcadd.rot90
+    12, // llvm.arm.neon.vcls
+    12, // llvm.arm.neon.vcvtas
+    12, // llvm.arm.neon.vcvtau
+    12, // llvm.arm.neon.vcvtbfp2bf
+    12, // llvm.arm.neon.vcvtfp2bf
+    12, // llvm.arm.neon.vcvtfp2fxs
+    12, // llvm.arm.neon.vcvtfp2fxu
+    12, // llvm.arm.neon.vcvtfp2hf
+    12, // llvm.arm.neon.vcvtfxs2fp
+    12, // llvm.arm.neon.vcvtfxu2fp
+    12, // llvm.arm.neon.vcvthf2fp
+    12, // llvm.arm.neon.vcvtms
+    12, // llvm.arm.neon.vcvtmu
+    12, // llvm.arm.neon.vcvtns
+    12, // llvm.arm.neon.vcvtnu
+    12, // llvm.arm.neon.vcvtps
+    12, // llvm.arm.neon.vcvtpu
+    12, // llvm.arm.neon.vhadds
+    12, // llvm.arm.neon.vhaddu
+    12, // llvm.arm.neon.vhsubs
+    12, // llvm.arm.neon.vhsubu
+    3, // llvm.arm.neon.vld1
+    3, // llvm.arm.neon.vld1x2
+    3, // llvm.arm.neon.vld1x3
+    3, // llvm.arm.neon.vld1x4
+    3, // llvm.arm.neon.vld2
+    3, // llvm.arm.neon.vld2dup
+    3, // llvm.arm.neon.vld2lane
+    3, // llvm.arm.neon.vld3
+    3, // llvm.arm.neon.vld3dup
+    3, // llvm.arm.neon.vld3lane
+    3, // llvm.arm.neon.vld4
+    3, // llvm.arm.neon.vld4dup
+    3, // llvm.arm.neon.vld4lane
+    12, // llvm.arm.neon.vmaxnm
+    12, // llvm.arm.neon.vmaxs
+    12, // llvm.arm.neon.vmaxu
+    12, // llvm.arm.neon.vminnm
+    12, // llvm.arm.neon.vmins
+    12, // llvm.arm.neon.vminu
+    12, // llvm.arm.neon.vmullp
+    12, // llvm.arm.neon.vmulls
+    12, // llvm.arm.neon.vmullu
+    12, // llvm.arm.neon.vmulp
+    12, // llvm.arm.neon.vpadals
+    12, // llvm.arm.neon.vpadalu
+    12, // llvm.arm.neon.vpadd
+    12, // llvm.arm.neon.vpaddls
+    12, // llvm.arm.neon.vpaddlu
+    12, // llvm.arm.neon.vpmaxs
+    12, // llvm.arm.neon.vpmaxu
+    12, // llvm.arm.neon.vpmins
+    12, // llvm.arm.neon.vpminu
+    12, // llvm.arm.neon.vqabs
+    12, // llvm.arm.neon.vqdmulh
+    12, // llvm.arm.neon.vqdmull
+    12, // llvm.arm.neon.vqmovns
+    12, // llvm.arm.neon.vqmovnsu
+    12, // llvm.arm.neon.vqmovnu
+    12, // llvm.arm.neon.vqneg
+    12, // llvm.arm.neon.vqrdmulh
+    12, // llvm.arm.neon.vqrshiftns
+    12, // llvm.arm.neon.vqrshiftnsu
+    12, // llvm.arm.neon.vqrshiftnu
+    12, // llvm.arm.neon.vqrshifts
+    12, // llvm.arm.neon.vqrshiftu
+    12, // llvm.arm.neon.vqshiftns
+    12, // llvm.arm.neon.vqshiftnsu
+    12, // llvm.arm.neon.vqshiftnu
+    12, // llvm.arm.neon.vqshifts
+    12, // llvm.arm.neon.vqshiftsu
+    12, // llvm.arm.neon.vqshiftu
+    12, // llvm.arm.neon.vraddhn
+    12, // llvm.arm.neon.vrecpe
+    12, // llvm.arm.neon.vrecps
+    12, // llvm.arm.neon.vrhadds
+    12, // llvm.arm.neon.vrhaddu
+    12, // llvm.arm.neon.vrinta
+    12, // llvm.arm.neon.vrintm
+    12, // llvm.arm.neon.vrintn
+    12, // llvm.arm.neon.vrintp
+    12, // llvm.arm.neon.vrintx
+    12, // llvm.arm.neon.vrintz
+    12, // llvm.arm.neon.vrshiftn
+    12, // llvm.arm.neon.vrshifts
+    12, // llvm.arm.neon.vrshiftu
+    12, // llvm.arm.neon.vrsqrte
+    12, // llvm.arm.neon.vrsqrts
+    12, // llvm.arm.neon.vrsubhn
+    12, // llvm.arm.neon.vshiftins
+    12, // llvm.arm.neon.vshifts
+    12, // llvm.arm.neon.vshiftu
+    178, // llvm.arm.neon.vst1
+    30, // llvm.arm.neon.vst1x2
+    30, // llvm.arm.neon.vst1x3
+    30, // llvm.arm.neon.vst1x4
+    178, // llvm.arm.neon.vst2
+    178, // llvm.arm.neon.vst2lane
+    178, // llvm.arm.neon.vst3
+    178, // llvm.arm.neon.vst3lane
+    178, // llvm.arm.neon.vst4
+    178, // llvm.arm.neon.vst4lane
+    12, // llvm.arm.neon.vtbl1
+    12, // llvm.arm.neon.vtbl2
+    12, // llvm.arm.neon.vtbl3
+    12, // llvm.arm.neon.vtbl4
+    12, // llvm.arm.neon.vtbx1
+    12, // llvm.arm.neon.vtbx2
+    12, // llvm.arm.neon.vtbx3
+    12, // llvm.arm.neon.vtbx4
+    12, // llvm.arm.qadd
+    12, // llvm.arm.qadd16
+    12, // llvm.arm.qadd8
+    12, // llvm.arm.qasx
+    12, // llvm.arm.qsax
+    12, // llvm.arm.qsub
+    12, // llvm.arm.qsub16
+    12, // llvm.arm.qsub8
+    7, // llvm.arm.sadd16
+    7, // llvm.arm.sadd8
+    7, // llvm.arm.sasx
+    21, // llvm.arm.sel
+    7, // llvm.arm.set.fpscr
+    12, // llvm.arm.shadd16
+    12, // llvm.arm.shadd8
+    12, // llvm.arm.shasx
+    12, // llvm.arm.shsax
+    12, // llvm.arm.shsub16
+    12, // llvm.arm.shsub8
+    12, // llvm.arm.smlabb
+    12, // llvm.arm.smlabt
+    12, // llvm.arm.smlad
+    12, // llvm.arm.smladx
+    12, // llvm.arm.smlald
+    12, // llvm.arm.smlaldx
+    12, // llvm.arm.smlatb
+    12, // llvm.arm.smlatt
+    12, // llvm.arm.smlawb
+    12, // llvm.arm.smlawt
+    12, // llvm.arm.smlsd
+    12, // llvm.arm.smlsdx
+    12, // llvm.arm.smlsld
+    12, // llvm.arm.smlsldx
+    12, // llvm.arm.smuad
+    12, // llvm.arm.smuadx
+    12, // llvm.arm.smulbb
+    12, // llvm.arm.smulbt
+    12, // llvm.arm.smultb
+    12, // llvm.arm.smultt
+    12, // llvm.arm.smulwb
+    12, // llvm.arm.smulwt
+    12, // llvm.arm.smusd
+    12, // llvm.arm.smusdx
+    83, // llvm.arm.space
+    12, // llvm.arm.ssat
+    12, // llvm.arm.ssat16
+    7, // llvm.arm.ssax
+    7, // llvm.arm.ssub16
+    7, // llvm.arm.ssub8
+    173, // llvm.arm.stc
+    173, // llvm.arm.stc2
+    173, // llvm.arm.stc2l
+    173, // llvm.arm.stcl
+    7, // llvm.arm.stlex
+    7, // llvm.arm.stlexd
+    7, // llvm.arm.strex
+    7, // llvm.arm.strexd
+    12, // llvm.arm.sxtab16
+    12, // llvm.arm.sxtb16
+    7, // llvm.arm.uadd16
+    7, // llvm.arm.uadd8
+    7, // llvm.arm.uasx
+    12, // llvm.arm.uhadd16
+    12, // llvm.arm.uhadd8
+    12, // llvm.arm.uhasx
+    12, // llvm.arm.uhsax
+    12, // llvm.arm.uhsub16
+    12, // llvm.arm.uhsub8
+    7, // llvm.arm.undefined
+    12, // llvm.arm.uqadd16
+    12, // llvm.arm.uqadd8
+    12, // llvm.arm.uqasx
+    12, // llvm.arm.uqsax
+    12, // llvm.arm.uqsub16
+    12, // llvm.arm.uqsub8
+    12, // llvm.arm.usad8
+    12, // llvm.arm.usada8
+    12, // llvm.arm.usat
+    12, // llvm.arm.usat16
+    7, // llvm.arm.usax
+    7, // llvm.arm.usub16
+    7, // llvm.arm.usub8
+    12, // llvm.arm.uxtab16
+    12, // llvm.arm.uxtb16
+    12, // llvm.arm.vcvtr
+    12, // llvm.arm.vcvtru
+    12, // llvm.bpf.btf.type.id
+    21, // llvm.bpf.load.byte
+    21, // llvm.bpf.load.half
+    21, // llvm.bpf.load.word
+    12, // llvm.bpf.passthrough
+    12, // llvm.bpf.preserve.enum.value
+    78, // llvm.bpf.preserve.field.info
+    12, // llvm.bpf.preserve.type.info
+    7, // llvm.bpf.pseudo
+    12, // llvm.hexagon.A2.abs
+    12, // llvm.hexagon.A2.absp
+    12, // llvm.hexagon.A2.abssat
+    12, // llvm.hexagon.A2.add
+    12, // llvm.hexagon.A2.addh.h16.hh
+    12, // llvm.hexagon.A2.addh.h16.hl
+    12, // llvm.hexagon.A2.addh.h16.lh
+    12, // llvm.hexagon.A2.addh.h16.ll
+    12, // llvm.hexagon.A2.addh.h16.sat.hh
+    12, // llvm.hexagon.A2.addh.h16.sat.hl
+    12, // llvm.hexagon.A2.addh.h16.sat.lh
+    12, // llvm.hexagon.A2.addh.h16.sat.ll
+    12, // llvm.hexagon.A2.addh.l16.hl
+    12, // llvm.hexagon.A2.addh.l16.ll
+    12, // llvm.hexagon.A2.addh.l16.sat.hl
+    12, // llvm.hexagon.A2.addh.l16.sat.ll
+    78, // llvm.hexagon.A2.addi
+    12, // llvm.hexagon.A2.addp
+    12, // llvm.hexagon.A2.addpsat
+    12, // llvm.hexagon.A2.addsat
+    12, // llvm.hexagon.A2.addsp
+    12, // llvm.hexagon.A2.and
+    78, // llvm.hexagon.A2.andir
+    12, // llvm.hexagon.A2.andp
+    12, // llvm.hexagon.A2.aslh
+    12, // llvm.hexagon.A2.asrh
+    12, // llvm.hexagon.A2.combine.hh
+    12, // llvm.hexagon.A2.combine.hl
+    12, // llvm.hexagon.A2.combine.lh
+    12, // llvm.hexagon.A2.combine.ll
+    167, // llvm.hexagon.A2.combineii
+    12, // llvm.hexagon.A2.combinew
+    12, // llvm.hexagon.A2.max
+    12, // llvm.hexagon.A2.maxp
+    12, // llvm.hexagon.A2.maxu
+    12, // llvm.hexagon.A2.maxup
+    12, // llvm.hexagon.A2.min
+    12, // llvm.hexagon.A2.minp
+    12, // llvm.hexagon.A2.minu
+    12, // llvm.hexagon.A2.minup
+    12, // llvm.hexagon.A2.neg
+    12, // llvm.hexagon.A2.negp
+    12, // llvm.hexagon.A2.negsat
+    12, // llvm.hexagon.A2.not
+    12, // llvm.hexagon.A2.notp
+    12, // llvm.hexagon.A2.or
+    78, // llvm.hexagon.A2.orir
+    12, // llvm.hexagon.A2.orp
+    12, // llvm.hexagon.A2.roundsat
+    12, // llvm.hexagon.A2.sat
+    12, // llvm.hexagon.A2.satb
+    12, // llvm.hexagon.A2.sath
+    12, // llvm.hexagon.A2.satub
+    12, // llvm.hexagon.A2.satuh
+    12, // llvm.hexagon.A2.sub
+    12, // llvm.hexagon.A2.subh.h16.hh
+    12, // llvm.hexagon.A2.subh.h16.hl
+    12, // llvm.hexagon.A2.subh.h16.lh
+    12, // llvm.hexagon.A2.subh.h16.ll
+    12, // llvm.hexagon.A2.subh.h16.sat.hh
+    12, // llvm.hexagon.A2.subh.h16.sat.hl
+    12, // llvm.hexagon.A2.subh.h16.sat.lh
+    12, // llvm.hexagon.A2.subh.h16.sat.ll
+    12, // llvm.hexagon.A2.subh.l16.hl
+    12, // llvm.hexagon.A2.subh.l16.ll
+    12, // llvm.hexagon.A2.subh.l16.sat.hl
+    12, // llvm.hexagon.A2.subh.l16.sat.ll
+    12, // llvm.hexagon.A2.subp
+    73, // llvm.hexagon.A2.subri
+    12, // llvm.hexagon.A2.subsat
+    12, // llvm.hexagon.A2.svaddh
+    12, // llvm.hexagon.A2.svaddhs
+    12, // llvm.hexagon.A2.svadduhs
+    12, // llvm.hexagon.A2.svavgh
+    12, // llvm.hexagon.A2.svavghs
+    12, // llvm.hexagon.A2.svnavgh
+    12, // llvm.hexagon.A2.svsubh
+    12, // llvm.hexagon.A2.svsubhs
+    12, // llvm.hexagon.A2.svsubuhs
+    12, // llvm.hexagon.A2.swiz
+    12, // llvm.hexagon.A2.sxtb
+    12, // llvm.hexagon.A2.sxth
+    12, // llvm.hexagon.A2.sxtw
+    12, // llvm.hexagon.A2.tfr
+    78, // llvm.hexagon.A2.tfrih
+    78, // llvm.hexagon.A2.tfril
+    12, // llvm.hexagon.A2.tfrp
+    73, // llvm.hexagon.A2.tfrpi
+    73, // llvm.hexagon.A2.tfrsi
+    12, // llvm.hexagon.A2.vabsh
+    12, // llvm.hexagon.A2.vabshsat
+    12, // llvm.hexagon.A2.vabsw
+    12, // llvm.hexagon.A2.vabswsat
+    12, // llvm.hexagon.A2.vaddb.map
+    12, // llvm.hexagon.A2.vaddh
+    12, // llvm.hexagon.A2.vaddhs
+    12, // llvm.hexagon.A2.vaddub
+    12, // llvm.hexagon.A2.vaddubs
+    12, // llvm.hexagon.A2.vadduhs
+    12, // llvm.hexagon.A2.vaddw
+    12, // llvm.hexagon.A2.vaddws
+    12, // llvm.hexagon.A2.vavgh
+    12, // llvm.hexagon.A2.vavghcr
+    12, // llvm.hexagon.A2.vavghr
+    12, // llvm.hexagon.A2.vavgub
+    12, // llvm.hexagon.A2.vavgubr
+    12, // llvm.hexagon.A2.vavguh
+    12, // llvm.hexagon.A2.vavguhr
+    12, // llvm.hexagon.A2.vavguw
+    12, // llvm.hexagon.A2.vavguwr
+    12, // llvm.hexagon.A2.vavgw
+    12, // llvm.hexagon.A2.vavgwcr
+    12, // llvm.hexagon.A2.vavgwr
+    12, // llvm.hexagon.A2.vcmpbeq
+    12, // llvm.hexagon.A2.vcmpbgtu
+    12, // llvm.hexagon.A2.vcmpheq
+    12, // llvm.hexagon.A2.vcmphgt
+    12, // llvm.hexagon.A2.vcmphgtu
+    12, // llvm.hexagon.A2.vcmpweq
+    12, // llvm.hexagon.A2.vcmpwgt
+    12, // llvm.hexagon.A2.vcmpwgtu
+    12, // llvm.hexagon.A2.vconj
+    12, // llvm.hexagon.A2.vmaxb
+    12, // llvm.hexagon.A2.vmaxh
+    12, // llvm.hexagon.A2.vmaxub
+    12, // llvm.hexagon.A2.vmaxuh
+    12, // llvm.hexagon.A2.vmaxuw
+    12, // llvm.hexagon.A2.vmaxw
+    12, // llvm.hexagon.A2.vminb
+    12, // llvm.hexagon.A2.vminh
+    12, // llvm.hexagon.A2.vminub
+    12, // llvm.hexagon.A2.vminuh
+    12, // llvm.hexagon.A2.vminuw
+    12, // llvm.hexagon.A2.vminw
+    12, // llvm.hexagon.A2.vnavgh
+    12, // llvm.hexagon.A2.vnavghcr
+    12, // llvm.hexagon.A2.vnavghr
+    12, // llvm.hexagon.A2.vnavgw
+    12, // llvm.hexagon.A2.vnavgwcr
+    12, // llvm.hexagon.A2.vnavgwr
+    12, // llvm.hexagon.A2.vraddub
+    12, // llvm.hexagon.A2.vraddub.acc
+    12, // llvm.hexagon.A2.vrsadub
+    12, // llvm.hexagon.A2.vrsadub.acc
+    12, // llvm.hexagon.A2.vsubb.map
+    12, // llvm.hexagon.A2.vsubh
+    12, // llvm.hexagon.A2.vsubhs
+    12, // llvm.hexagon.A2.vsubub
+    12, // llvm.hexagon.A2.vsububs
+    12, // llvm.hexagon.A2.vsubuhs
+    12, // llvm.hexagon.A2.vsubw
+    12, // llvm.hexagon.A2.vsubws
+    12, // llvm.hexagon.A2.xor
+    12, // llvm.hexagon.A2.xorp
+    12, // llvm.hexagon.A2.zxtb
+    12, // llvm.hexagon.A2.zxth
+    12, // llvm.hexagon.A4.andn
+    12, // llvm.hexagon.A4.andnp
+    12, // llvm.hexagon.A4.bitsplit
+    78, // llvm.hexagon.A4.bitspliti
+    12, // llvm.hexagon.A4.boundscheck
+    12, // llvm.hexagon.A4.cmpbeq
+    78, // llvm.hexagon.A4.cmpbeqi
+    12, // llvm.hexagon.A4.cmpbgt
+    78, // llvm.hexagon.A4.cmpbgti
+    12, // llvm.hexagon.A4.cmpbgtu
+    78, // llvm.hexagon.A4.cmpbgtui
+    12, // llvm.hexagon.A4.cmpheq
+    78, // llvm.hexagon.A4.cmpheqi
+    12, // llvm.hexagon.A4.cmphgt
+    78, // llvm.hexagon.A4.cmphgti
+    12, // llvm.hexagon.A4.cmphgtu
+    78, // llvm.hexagon.A4.cmphgtui
+    73, // llvm.hexagon.A4.combineir
+    78, // llvm.hexagon.A4.combineri
+    78, // llvm.hexagon.A4.cround.ri
+    12, // llvm.hexagon.A4.cround.rr
+    12, // llvm.hexagon.A4.modwrapu
+    12, // llvm.hexagon.A4.orn
+    12, // llvm.hexagon.A4.ornp
+    12, // llvm.hexagon.A4.rcmpeq
+    78, // llvm.hexagon.A4.rcmpeqi
+    12, // llvm.hexagon.A4.rcmpneq
+    78, // llvm.hexagon.A4.rcmpneqi
+    78, // llvm.hexagon.A4.round.ri
+    78, // llvm.hexagon.A4.round.ri.sat
+    12, // llvm.hexagon.A4.round.rr
+    12, // llvm.hexagon.A4.round.rr.sat
+    12, // llvm.hexagon.A4.tlbmatch
+    12, // llvm.hexagon.A4.vcmpbeq.any
+    78, // llvm.hexagon.A4.vcmpbeqi
+    12, // llvm.hexagon.A4.vcmpbgt
+    78, // llvm.hexagon.A4.vcmpbgti
+    78, // llvm.hexagon.A4.vcmpbgtui
+    78, // llvm.hexagon.A4.vcmpheqi
+    78, // llvm.hexagon.A4.vcmphgti
+    78, // llvm.hexagon.A4.vcmphgtui
+    78, // llvm.hexagon.A4.vcmpweqi
+    78, // llvm.hexagon.A4.vcmpwgti
+    78, // llvm.hexagon.A4.vcmpwgtui
+    12, // llvm.hexagon.A4.vrmaxh
+    12, // llvm.hexagon.A4.vrmaxuh
+    12, // llvm.hexagon.A4.vrmaxuw
+    12, // llvm.hexagon.A4.vrmaxw
+    12, // llvm.hexagon.A4.vrminh
+    12, // llvm.hexagon.A4.vrminuh
+    12, // llvm.hexagon.A4.vrminuw
+    12, // llvm.hexagon.A4.vrminw
+    12, // llvm.hexagon.A5.vaddhubs
+    12, // llvm.hexagon.A6.vcmpbeq.notany
+    78, // llvm.hexagon.A7.clip
+    78, // llvm.hexagon.A7.croundd.ri
+    12, // llvm.hexagon.A7.croundd.rr
+    78, // llvm.hexagon.A7.vclip
+    12, // llvm.hexagon.C2.all8
+    12, // llvm.hexagon.C2.and
+    12, // llvm.hexagon.C2.andn
+    12, // llvm.hexagon.C2.any8
+    12, // llvm.hexagon.C2.bitsclr
+    78, // llvm.hexagon.C2.bitsclri
+    12, // llvm.hexagon.C2.bitsset
+    12, // llvm.hexagon.C2.cmpeq
+    78, // llvm.hexagon.C2.cmpeqi
+    12, // llvm.hexagon.C2.cmpeqp
+    78, // llvm.hexagon.C2.cmpgei
+    78, // llvm.hexagon.C2.cmpgeui
+    12, // llvm.hexagon.C2.cmpgt
+    78, // llvm.hexagon.C2.cmpgti
+    12, // llvm.hexagon.C2.cmpgtp
+    12, // llvm.hexagon.C2.cmpgtu
+    78, // llvm.hexagon.C2.cmpgtui
+    12, // llvm.hexagon.C2.cmpgtup
+    12, // llvm.hexagon.C2.cmplt
+    12, // llvm.hexagon.C2.cmpltu
+    12, // llvm.hexagon.C2.mask
+    12, // llvm.hexagon.C2.mux
+    79, // llvm.hexagon.C2.muxii
+    70, // llvm.hexagon.C2.muxir
+    78, // llvm.hexagon.C2.muxri
+    12, // llvm.hexagon.C2.not
+    12, // llvm.hexagon.C2.or
+    12, // llvm.hexagon.C2.orn
+    12, // llvm.hexagon.C2.pxfer.map
+    12, // llvm.hexagon.C2.tfrpr
+    12, // llvm.hexagon.C2.tfrrp
+    12, // llvm.hexagon.C2.vitpack
+    12, // llvm.hexagon.C2.vmux
+    12, // llvm.hexagon.C2.xor
+    12, // llvm.hexagon.C4.and.and
+    12, // llvm.hexagon.C4.and.andn
+    12, // llvm.hexagon.C4.and.or
+    12, // llvm.hexagon.C4.and.orn
+    12, // llvm.hexagon.C4.cmplte
+    78, // llvm.hexagon.C4.cmpltei
+    12, // llvm.hexagon.C4.cmplteu
+    78, // llvm.hexagon.C4.cmplteui
+    12, // llvm.hexagon.C4.cmpneq
+    78, // llvm.hexagon.C4.cmpneqi
+    12, // llvm.hexagon.C4.fastcorner9
+    12, // llvm.hexagon.C4.fastcorner9.not
+    12, // llvm.hexagon.C4.nbitsclr
+    78, // llvm.hexagon.C4.nbitsclri
+    12, // llvm.hexagon.C4.nbitsset
+    12, // llvm.hexagon.C4.or.and
+    12, // llvm.hexagon.C4.or.andn
+    12, // llvm.hexagon.C4.or.or
+    12, // llvm.hexagon.C4.or.orn
+    12, // llvm.hexagon.F2.conv.d2df
+    12, // llvm.hexagon.F2.conv.d2sf
+    12, // llvm.hexagon.F2.conv.df2d
+    12, // llvm.hexagon.F2.conv.df2d.chop
+    12, // llvm.hexagon.F2.conv.df2sf
+    12, // llvm.hexagon.F2.conv.df2ud
+    12, // llvm.hexagon.F2.conv.df2ud.chop
+    12, // llvm.hexagon.F2.conv.df2uw
+    12, // llvm.hexagon.F2.conv.df2uw.chop
+    12, // llvm.hexagon.F2.conv.df2w
+    12, // llvm.hexagon.F2.conv.df2w.chop
+    12, // llvm.hexagon.F2.conv.sf2d
+    12, // llvm.hexagon.F2.conv.sf2d.chop
+    12, // llvm.hexagon.F2.conv.sf2df
+    12, // llvm.hexagon.F2.conv.sf2ud
+    12, // llvm.hexagon.F2.conv.sf2ud.chop
+    12, // llvm.hexagon.F2.conv.sf2uw
+    12, // llvm.hexagon.F2.conv.sf2uw.chop
+    12, // llvm.hexagon.F2.conv.sf2w
+    12, // llvm.hexagon.F2.conv.sf2w.chop
+    12, // llvm.hexagon.F2.conv.ud2df
+    12, // llvm.hexagon.F2.conv.ud2sf
+    12, // llvm.hexagon.F2.conv.uw2df
+    12, // llvm.hexagon.F2.conv.uw2sf
+    12, // llvm.hexagon.F2.conv.w2df
+    12, // llvm.hexagon.F2.conv.w2sf
+    179, // llvm.hexagon.F2.dfadd
+    180, // llvm.hexagon.F2.dfclass
+    179, // llvm.hexagon.F2.dfcmpeq
+    179, // llvm.hexagon.F2.dfcmpge
+    179, // llvm.hexagon.F2.dfcmpgt
+    179, // llvm.hexagon.F2.dfcmpuo
+    181, // llvm.hexagon.F2.dfimm.n
+    181, // llvm.hexagon.F2.dfimm.p
+    179, // llvm.hexagon.F2.dfmax
+    179, // llvm.hexagon.F2.dfmin
+    179, // llvm.hexagon.F2.dfmpyfix
+    179, // llvm.hexagon.F2.dfmpyhh
+    179, // llvm.hexagon.F2.dfmpylh
+    179, // llvm.hexagon.F2.dfmpyll
+    179, // llvm.hexagon.F2.dfsub
+    179, // llvm.hexagon.F2.sfadd
+    180, // llvm.hexagon.F2.sfclass
+    179, // llvm.hexagon.F2.sfcmpeq
+    179, // llvm.hexagon.F2.sfcmpge
+    179, // llvm.hexagon.F2.sfcmpgt
+    179, // llvm.hexagon.F2.sfcmpuo
+    179, // llvm.hexagon.F2.sffixupd
+    179, // llvm.hexagon.F2.sffixupn
+    179, // llvm.hexagon.F2.sffixupr
+    179, // llvm.hexagon.F2.sffma
+    179, // llvm.hexagon.F2.sffma.lib
+    179, // llvm.hexagon.F2.sffma.sc
+    179, // llvm.hexagon.F2.sffms
+    179, // llvm.hexagon.F2.sffms.lib
+    181, // llvm.hexagon.F2.sfimm.n
+    181, // llvm.hexagon.F2.sfimm.p
+    179, // llvm.hexagon.F2.sfmax
+    179, // llvm.hexagon.F2.sfmin
+    179, // llvm.hexagon.F2.sfmpy
+    179, // llvm.hexagon.F2.sfsub
+    21, // llvm.hexagon.L2.loadrb.pbr
+    65, // llvm.hexagon.L2.loadrb.pci
+    64, // llvm.hexagon.L2.loadrb.pcr
+    21, // llvm.hexagon.L2.loadrd.pbr
+    65, // llvm.hexagon.L2.loadrd.pci
+    64, // llvm.hexagon.L2.loadrd.pcr
+    21, // llvm.hexagon.L2.loadrh.pbr
+    65, // llvm.hexagon.L2.loadrh.pci
+    64, // llvm.hexagon.L2.loadrh.pcr
+    21, // llvm.hexagon.L2.loadri.pbr
+    65, // llvm.hexagon.L2.loadri.pci
+    64, // llvm.hexagon.L2.loadri.pcr
+    21, // llvm.hexagon.L2.loadrub.pbr
+    65, // llvm.hexagon.L2.loadrub.pci
+    64, // llvm.hexagon.L2.loadrub.pcr
+    21, // llvm.hexagon.L2.loadruh.pbr
+    65, // llvm.hexagon.L2.loadruh.pci
+    64, // llvm.hexagon.L2.loadruh.pcr
+    30, // llvm.hexagon.L2.loadw.locked
+    30, // llvm.hexagon.L4.loadd.locked
+    12, // llvm.hexagon.M2.acci
+    70, // llvm.hexagon.M2.accii
+    12, // llvm.hexagon.M2.cmaci.s0
+    12, // llvm.hexagon.M2.cmacr.s0
+    12, // llvm.hexagon.M2.cmacs.s0
+    12, // llvm.hexagon.M2.cmacs.s1
+    12, // llvm.hexagon.M2.cmacsc.s0
+    12, // llvm.hexagon.M2.cmacsc.s1
+    12, // llvm.hexagon.M2.cmpyi.s0
+    12, // llvm.hexagon.M2.cmpyr.s0
+    12, // llvm.hexagon.M2.cmpyrs.s0
+    12, // llvm.hexagon.M2.cmpyrs.s1
+    12, // llvm.hexagon.M2.cmpyrsc.s0
+    12, // llvm.hexagon.M2.cmpyrsc.s1
+    12, // llvm.hexagon.M2.cmpys.s0
+    12, // llvm.hexagon.M2.cmpys.s1
+    12, // llvm.hexagon.M2.cmpysc.s0
+    12, // llvm.hexagon.M2.cmpysc.s1
+    12, // llvm.hexagon.M2.cnacs.s0
+    12, // llvm.hexagon.M2.cnacs.s1
+    12, // llvm.hexagon.M2.cnacsc.s0
+    12, // llvm.hexagon.M2.cnacsc.s1
+    12, // llvm.hexagon.M2.dpmpyss.acc.s0
+    12, // llvm.hexagon.M2.dpmpyss.nac.s0
+    12, // llvm.hexagon.M2.dpmpyss.rnd.s0
+    12, // llvm.hexagon.M2.dpmpyss.s0
+    12, // llvm.hexagon.M2.dpmpyuu.acc.s0
+    12, // llvm.hexagon.M2.dpmpyuu.nac.s0
+    12, // llvm.hexagon.M2.dpmpyuu.s0
+    12, // llvm.hexagon.M2.hmmpyh.rs1
+    12, // llvm.hexagon.M2.hmmpyh.s1
+    12, // llvm.hexagon.M2.hmmpyl.rs1
+    12, // llvm.hexagon.M2.hmmpyl.s1
+    12, // llvm.hexagon.M2.maci
+    70, // llvm.hexagon.M2.macsin
+    70, // llvm.hexagon.M2.macsip
+    12, // llvm.hexagon.M2.mmachs.rs0
+    12, // llvm.hexagon.M2.mmachs.rs1
+    12, // llvm.hexagon.M2.mmachs.s0
+    12, // llvm.hexagon.M2.mmachs.s1
+    12, // llvm.hexagon.M2.mmacls.rs0
+    12, // llvm.hexagon.M2.mmacls.rs1
+    12, // llvm.hexagon.M2.mmacls.s0
+    12, // llvm.hexagon.M2.mmacls.s1
+    12, // llvm.hexagon.M2.mmacuhs.rs0
+    12, // llvm.hexagon.M2.mmacuhs.rs1
+    12, // llvm.hexagon.M2.mmacuhs.s0
+    12, // llvm.hexagon.M2.mmacuhs.s1
+    12, // llvm.hexagon.M2.mmaculs.rs0
+    12, // llvm.hexagon.M2.mmaculs.rs1
+    12, // llvm.hexagon.M2.mmaculs.s0
+    12, // llvm.hexagon.M2.mmaculs.s1
+    12, // llvm.hexagon.M2.mmpyh.rs0
+    12, // llvm.hexagon.M2.mmpyh.rs1
+    12, // llvm.hexagon.M2.mmpyh.s0
+    12, // llvm.hexagon.M2.mmpyh.s1
+    12, // llvm.hexagon.M2.mmpyl.rs0
+    12, // llvm.hexagon.M2.mmpyl.rs1
+    12, // llvm.hexagon.M2.mmpyl.s0
+    12, // llvm.hexagon.M2.mmpyl.s1
+    12, // llvm.hexagon.M2.mmpyuh.rs0
+    12, // llvm.hexagon.M2.mmpyuh.rs1
+    12, // llvm.hexagon.M2.mmpyuh.s0
+    12, // llvm.hexagon.M2.mmpyuh.s1
+    12, // llvm.hexagon.M2.mmpyul.rs0
+    12, // llvm.hexagon.M2.mmpyul.rs1
+    12, // llvm.hexagon.M2.mmpyul.s0
+    12, // llvm.hexagon.M2.mmpyul.s1
+    12, // llvm.hexagon.M2.mnaci
+    12, // llvm.hexagon.M2.mpy.acc.hh.s0
+    12, // llvm.hexagon.M2.mpy.acc.hh.s1
+    12, // llvm.hexagon.M2.mpy.acc.hl.s0
+    12, // llvm.hexagon.M2.mpy.acc.hl.s1
+    12, // llvm.hexagon.M2.mpy.acc.lh.s0
+    12, // llvm.hexagon.M2.mpy.acc.lh.s1
+    12, // llvm.hexagon.M2.mpy.acc.ll.s0
+    12, // llvm.hexagon.M2.mpy.acc.ll.s1
+    12, // llvm.hexagon.M2.mpy.acc.sat.hh.s0
+    12, // llvm.hexagon.M2.mpy.acc.sat.hh.s1
+    12, // llvm.hexagon.M2.mpy.acc.sat.hl.s0
+    12, // llvm.hexagon.M2.mpy.acc.sat.hl.s1
+    12, // llvm.hexagon.M2.mpy.acc.sat.lh.s0
+    12, // llvm.hexagon.M2.mpy.acc.sat.lh.s1
+    12, // llvm.hexagon.M2.mpy.acc.sat.ll.s0
+    12, // llvm.hexagon.M2.mpy.acc.sat.ll.s1
+    12, // llvm.hexagon.M2.mpy.hh.s0
+    12, // llvm.hexagon.M2.mpy.hh.s1
+    12, // llvm.hexagon.M2.mpy.hl.s0
+    12, // llvm.hexagon.M2.mpy.hl.s1
+    12, // llvm.hexagon.M2.mpy.lh.s0
+    12, // llvm.hexagon.M2.mpy.lh.s1
+    12, // llvm.hexagon.M2.mpy.ll.s0
+    12, // llvm.hexagon.M2.mpy.ll.s1
+    12, // llvm.hexagon.M2.mpy.nac.hh.s0
+    12, // llvm.hexagon.M2.mpy.nac.hh.s1
+    12, // llvm.hexagon.M2.mpy.nac.hl.s0
+    12, // llvm.hexagon.M2.mpy.nac.hl.s1
+    12, // llvm.hexagon.M2.mpy.nac.lh.s0
+    12, // llvm.hexagon.M2.mpy.nac.lh.s1
+    12, // llvm.hexagon.M2.mpy.nac.ll.s0
+    12, // llvm.hexagon.M2.mpy.nac.ll.s1
+    12, // llvm.hexagon.M2.mpy.nac.sat.hh.s0
+    12, // llvm.hexagon.M2.mpy.nac.sat.hh.s1
+    12, // llvm.hexagon.M2.mpy.nac.sat.hl.s0
+    12, // llvm.hexagon.M2.mpy.nac.sat.hl.s1
+    12, // llvm.hexagon.M2.mpy.nac.sat.lh.s0
+    12, // llvm.hexagon.M2.mpy.nac.sat.lh.s1
+    12, // llvm.hexagon.M2.mpy.nac.sat.ll.s0
+    12, // llvm.hexagon.M2.mpy.nac.sat.ll.s1
+    12, // llvm.hexagon.M2.mpy.rnd.hh.s0
+    12, // llvm.hexagon.M2.mpy.rnd.hh.s1
+    12, // llvm.hexagon.M2.mpy.rnd.hl.s0
+    12, // llvm.hexagon.M2.mpy.rnd.hl.s1
+    12, // llvm.hexagon.M2.mpy.rnd.lh.s0
+    12, // llvm.hexagon.M2.mpy.rnd.lh.s1
+    12, // llvm.hexagon.M2.mpy.rnd.ll.s0
+    12, // llvm.hexagon.M2.mpy.rnd.ll.s1
+    12, // llvm.hexagon.M2.mpy.sat.hh.s0
+    12, // llvm.hexagon.M2.mpy.sat.hh.s1
+    12, // llvm.hexagon.M2.mpy.sat.hl.s0
+    12, // llvm.hexagon.M2.mpy.sat.hl.s1
+    12, // llvm.hexagon.M2.mpy.sat.lh.s0
+    12, // llvm.hexagon.M2.mpy.sat.lh.s1
+    12, // llvm.hexagon.M2.mpy.sat.ll.s0
+    12, // llvm.hexagon.M2.mpy.sat.ll.s1
+    12, // llvm.hexagon.M2.mpy.sat.rnd.hh.s0
+    12, // llvm.hexagon.M2.mpy.sat.rnd.hh.s1
+    12, // llvm.hexagon.M2.mpy.sat.rnd.hl.s0
+    12, // llvm.hexagon.M2.mpy.sat.rnd.hl.s1
+    12, // llvm.hexagon.M2.mpy.sat.rnd.lh.s0
+    12, // llvm.hexagon.M2.mpy.sat.rnd.lh.s1
+    12, // llvm.hexagon.M2.mpy.sat.rnd.ll.s0
+    12, // llvm.hexagon.M2.mpy.sat.rnd.ll.s1
+    12, // llvm.hexagon.M2.mpy.up
+    12, // llvm.hexagon.M2.mpy.up.s1
+    12, // llvm.hexagon.M2.mpy.up.s1.sat
+    12, // llvm.hexagon.M2.mpyd.acc.hh.s0
+    12, // llvm.hexagon.M2.mpyd.acc.hh.s1
+    12, // llvm.hexagon.M2.mpyd.acc.hl.s0
+    12, // llvm.hexagon.M2.mpyd.acc.hl.s1
+    12, // llvm.hexagon.M2.mpyd.acc.lh.s0
+    12, // llvm.hexagon.M2.mpyd.acc.lh.s1
+    12, // llvm.hexagon.M2.mpyd.acc.ll.s0
+    12, // llvm.hexagon.M2.mpyd.acc.ll.s1
+    12, // llvm.hexagon.M2.mpyd.hh.s0
+    12, // llvm.hexagon.M2.mpyd.hh.s1
+    12, // llvm.hexagon.M2.mpyd.hl.s0
+    12, // llvm.hexagon.M2.mpyd.hl.s1
+    12, // llvm.hexagon.M2.mpyd.lh.s0
+    12, // llvm.hexagon.M2.mpyd.lh.s1
+    12, // llvm.hexagon.M2.mpyd.ll.s0
+    12, // llvm.hexagon.M2.mpyd.ll.s1
+    12, // llvm.hexagon.M2.mpyd.nac.hh.s0
+    12, // llvm.hexagon.M2.mpyd.nac.hh.s1
+    12, // llvm.hexagon.M2.mpyd.nac.hl.s0
+    12, // llvm.hexagon.M2.mpyd.nac.hl.s1
+    12, // llvm.hexagon.M2.mpyd.nac.lh.s0
+    12, // llvm.hexagon.M2.mpyd.nac.lh.s1
+    12, // llvm.hexagon.M2.mpyd.nac.ll.s0
+    12, // llvm.hexagon.M2.mpyd.nac.ll.s1
+    12, // llvm.hexagon.M2.mpyd.rnd.hh.s0
+    12, // llvm.hexagon.M2.mpyd.rnd.hh.s1
+    12, // llvm.hexagon.M2.mpyd.rnd.hl.s0
+    12, // llvm.hexagon.M2.mpyd.rnd.hl.s1
+    12, // llvm.hexagon.M2.mpyd.rnd.lh.s0
+    12, // llvm.hexagon.M2.mpyd.rnd.lh.s1
+    12, // llvm.hexagon.M2.mpyd.rnd.ll.s0
+    12, // llvm.hexagon.M2.mpyd.rnd.ll.s1
+    12, // llvm.hexagon.M2.mpyi
+    78, // llvm.hexagon.M2.mpysmi
+    12, // llvm.hexagon.M2.mpysu.up
+    12, // llvm.hexagon.M2.mpyu.acc.hh.s0
+    12, // llvm.hexagon.M2.mpyu.acc.hh.s1
+    12, // llvm.hexagon.M2.mpyu.acc.hl.s0
+    12, // llvm.hexagon.M2.mpyu.acc.hl.s1
+    12, // llvm.hexagon.M2.mpyu.acc.lh.s0
+    12, // llvm.hexagon.M2.mpyu.acc.lh.s1
+    12, // llvm.hexagon.M2.mpyu.acc.ll.s0
+    12, // llvm.hexagon.M2.mpyu.acc.ll.s1
+    12, // llvm.hexagon.M2.mpyu.hh.s0
+    12, // llvm.hexagon.M2.mpyu.hh.s1
+    12, // llvm.hexagon.M2.mpyu.hl.s0
+    12, // llvm.hexagon.M2.mpyu.hl.s1
+    12, // llvm.hexagon.M2.mpyu.lh.s0
+    12, // llvm.hexagon.M2.mpyu.lh.s1
+    12, // llvm.hexagon.M2.mpyu.ll.s0
+    12, // llvm.hexagon.M2.mpyu.ll.s1
+    12, // llvm.hexagon.M2.mpyu.nac.hh.s0
+    12, // llvm.hexagon.M2.mpyu.nac.hh.s1
+    12, // llvm.hexagon.M2.mpyu.nac.hl.s0
+    12, // llvm.hexagon.M2.mpyu.nac.hl.s1
+    12, // llvm.hexagon.M2.mpyu.nac.lh.s0
+    12, // llvm.hexagon.M2.mpyu.nac.lh.s1
+    12, // llvm.hexagon.M2.mpyu.nac.ll.s0
+    12, // llvm.hexagon.M2.mpyu.nac.ll.s1
+    12, // llvm.hexagon.M2.mpyu.up
+    12, // llvm.hexagon.M2.mpyud.acc.hh.s0
+    12, // llvm.hexagon.M2.mpyud.acc.hh.s1
+    12, // llvm.hexagon.M2.mpyud.acc.hl.s0
+    12, // llvm.hexagon.M2.mpyud.acc.hl.s1
+    12, // llvm.hexagon.M2.mpyud.acc.lh.s0
+    12, // llvm.hexagon.M2.mpyud.acc.lh.s1
+    12, // llvm.hexagon.M2.mpyud.acc.ll.s0
+    12, // llvm.hexagon.M2.mpyud.acc.ll.s1
+    12, // llvm.hexagon.M2.mpyud.hh.s0
+    12, // llvm.hexagon.M2.mpyud.hh.s1
+    12, // llvm.hexagon.M2.mpyud.hl.s0
+    12, // llvm.hexagon.M2.mpyud.hl.s1
+    12, // llvm.hexagon.M2.mpyud.lh.s0
+    12, // llvm.hexagon.M2.mpyud.lh.s1
+    12, // llvm.hexagon.M2.mpyud.ll.s0
+    12, // llvm.hexagon.M2.mpyud.ll.s1
+    12, // llvm.hexagon.M2.mpyud.nac.hh.s0
+    12, // llvm.hexagon.M2.mpyud.nac.hh.s1
+    12, // llvm.hexagon.M2.mpyud.nac.hl.s0
+    12, // llvm.hexagon.M2.mpyud.nac.hl.s1
+    12, // llvm.hexagon.M2.mpyud.nac.lh.s0
+    12, // llvm.hexagon.M2.mpyud.nac.lh.s1
+    12, // llvm.hexagon.M2.mpyud.nac.ll.s0
+    12, // llvm.hexagon.M2.mpyud.nac.ll.s1
+    12, // llvm.hexagon.M2.mpyui
+    12, // llvm.hexagon.M2.nacci
+    70, // llvm.hexagon.M2.naccii
+    12, // llvm.hexagon.M2.subacc
+    12, // llvm.hexagon.M2.vabsdiffh
+    12, // llvm.hexagon.M2.vabsdiffw
+    12, // llvm.hexagon.M2.vcmac.s0.sat.i
+    12, // llvm.hexagon.M2.vcmac.s0.sat.r
+    12, // llvm.hexagon.M2.vcmpy.s0.sat.i
+    12, // llvm.hexagon.M2.vcmpy.s0.sat.r
+    12, // llvm.hexagon.M2.vcmpy.s1.sat.i
+    12, // llvm.hexagon.M2.vcmpy.s1.sat.r
+    12, // llvm.hexagon.M2.vdmacs.s0
+    12, // llvm.hexagon.M2.vdmacs.s1
+    12, // llvm.hexagon.M2.vdmpyrs.s0
+    12, // llvm.hexagon.M2.vdmpyrs.s1
+    12, // llvm.hexagon.M2.vdmpys.s0
+    12, // llvm.hexagon.M2.vdmpys.s1
+    12, // llvm.hexagon.M2.vmac2
+    12, // llvm.hexagon.M2.vmac2es
+    12, // llvm.hexagon.M2.vmac2es.s0
+    12, // llvm.hexagon.M2.vmac2es.s1
+    12, // llvm.hexagon.M2.vmac2s.s0
+    12, // llvm.hexagon.M2.vmac2s.s1
+    12, // llvm.hexagon.M2.vmac2su.s0
+    12, // llvm.hexagon.M2.vmac2su.s1
+    12, // llvm.hexagon.M2.vmpy2es.s0
+    12, // llvm.hexagon.M2.vmpy2es.s1
+    12, // llvm.hexagon.M2.vmpy2s.s0
+    12, // llvm.hexagon.M2.vmpy2s.s0pack
+    12, // llvm.hexagon.M2.vmpy2s.s1
+    12, // llvm.hexagon.M2.vmpy2s.s1pack
+    12, // llvm.hexagon.M2.vmpy2su.s0
+    12, // llvm.hexagon.M2.vmpy2su.s1
+    12, // llvm.hexagon.M2.vraddh
+    12, // llvm.hexagon.M2.vradduh
+    12, // llvm.hexagon.M2.vrcmaci.s0
+    12, // llvm.hexagon.M2.vrcmaci.s0c
+    12, // llvm.hexagon.M2.vrcmacr.s0
+    12, // llvm.hexagon.M2.vrcmacr.s0c
+    12, // llvm.hexagon.M2.vrcmpyi.s0
+    12, // llvm.hexagon.M2.vrcmpyi.s0c
+    12, // llvm.hexagon.M2.vrcmpyr.s0
+    12, // llvm.hexagon.M2.vrcmpyr.s0c
+    12, // llvm.hexagon.M2.vrcmpys.acc.s1
+    12, // llvm.hexagon.M2.vrcmpys.s1
+    12, // llvm.hexagon.M2.vrcmpys.s1rp
+    12, // llvm.hexagon.M2.vrmac.s0
+    12, // llvm.hexagon.M2.vrmpy.s0
+    12, // llvm.hexagon.M2.xor.xacc
+    12, // llvm.hexagon.M4.and.and
+    12, // llvm.hexagon.M4.and.andn
+    12, // llvm.hexagon.M4.and.or
+    12, // llvm.hexagon.M4.and.xor
+    12, // llvm.hexagon.M4.cmpyi.wh
+    12, // llvm.hexagon.M4.cmpyi.whc
+    12, // llvm.hexagon.M4.cmpyr.wh
+    12, // llvm.hexagon.M4.cmpyr.whc
+    12, // llvm.hexagon.M4.mac.up.s1.sat
+    168, // llvm.hexagon.M4.mpyri.addi
+    70, // llvm.hexagon.M4.mpyri.addr
+    78, // llvm.hexagon.M4.mpyri.addr.u2
+    73, // llvm.hexagon.M4.mpyrr.addi
+    12, // llvm.hexagon.M4.mpyrr.addr
+    12, // llvm.hexagon.M4.nac.up.s1.sat
+    12, // llvm.hexagon.M4.or.and
+    12, // llvm.hexagon.M4.or.andn
+    12, // llvm.hexagon.M4.or.or
+    12, // llvm.hexagon.M4.or.xor
+    12, // llvm.hexagon.M4.pmpyw
+    12, // llvm.hexagon.M4.pmpyw.acc
+    12, // llvm.hexagon.M4.vpmpyh
+    12, // llvm.hexagon.M4.vpmpyh.acc
+    12, // llvm.hexagon.M4.vrmpyeh.acc.s0
+    12, // llvm.hexagon.M4.vrmpyeh.acc.s1
+    12, // llvm.hexagon.M4.vrmpyeh.s0
+    12, // llvm.hexagon.M4.vrmpyeh.s1
+    12, // llvm.hexagon.M4.vrmpyoh.acc.s0
+    12, // llvm.hexagon.M4.vrmpyoh.acc.s1
+    12, // llvm.hexagon.M4.vrmpyoh.s0
+    12, // llvm.hexagon.M4.vrmpyoh.s1
+    12, // llvm.hexagon.M4.xor.and
+    12, // llvm.hexagon.M4.xor.andn
+    12, // llvm.hexagon.M4.xor.or
+    12, // llvm.hexagon.M4.xor.xacc
+    12, // llvm.hexagon.M5.vdmacbsu
+    12, // llvm.hexagon.M5.vdmpybsu
+    12, // llvm.hexagon.M5.vmacbsu
+    12, // llvm.hexagon.M5.vmacbuu
+    12, // llvm.hexagon.M5.vmpybsu
+    12, // llvm.hexagon.M5.vmpybuu
+    12, // llvm.hexagon.M5.vrmacbsu
+    12, // llvm.hexagon.M5.vrmacbuu
+    12, // llvm.hexagon.M5.vrmpybsu
+    12, // llvm.hexagon.M5.vrmpybuu
+    12, // llvm.hexagon.M6.vabsdiffb
+    12, // llvm.hexagon.M6.vabsdiffub
+    12, // llvm.hexagon.M7.dcmpyiw
+    12, // llvm.hexagon.M7.dcmpyiw.acc
+    12, // llvm.hexagon.M7.dcmpyiwc
+    12, // llvm.hexagon.M7.dcmpyiwc.acc
+    12, // llvm.hexagon.M7.dcmpyrw
+    12, // llvm.hexagon.M7.dcmpyrw.acc
+    12, // llvm.hexagon.M7.dcmpyrwc
+    12, // llvm.hexagon.M7.dcmpyrwc.acc
+    12, // llvm.hexagon.M7.vdmpy
+    12, // llvm.hexagon.M7.vdmpy.acc
+    12, // llvm.hexagon.M7.wcmpyiw
+    12, // llvm.hexagon.M7.wcmpyiw.rnd
+    12, // llvm.hexagon.M7.wcmpyiwc
+    12, // llvm.hexagon.M7.wcmpyiwc.rnd
+    12, // llvm.hexagon.M7.wcmpyrw
+    12, // llvm.hexagon.M7.wcmpyrw.rnd
+    12, // llvm.hexagon.M7.wcmpyrwc
+    12, // llvm.hexagon.M7.wcmpyrwc.rnd
+    70, // llvm.hexagon.S2.addasl.rrri
+    78, // llvm.hexagon.S2.asl.i.p
+    70, // llvm.hexagon.S2.asl.i.p.acc
+    70, // llvm.hexagon.S2.asl.i.p.and
+    70, // llvm.hexagon.S2.asl.i.p.nac
+    70, // llvm.hexagon.S2.asl.i.p.or
+    70, // llvm.hexagon.S2.asl.i.p.xacc
+    78, // llvm.hexagon.S2.asl.i.r
+    70, // llvm.hexagon.S2.asl.i.r.acc
+    70, // llvm.hexagon.S2.asl.i.r.and
+    70, // llvm.hexagon.S2.asl.i.r.nac
+    70, // llvm.hexagon.S2.asl.i.r.or
+    78, // llvm.hexagon.S2.asl.i.r.sat
+    70, // llvm.hexagon.S2.asl.i.r.xacc
+    78, // llvm.hexagon.S2.asl.i.vh
+    78, // llvm.hexagon.S2.asl.i.vw
+    12, // llvm.hexagon.S2.asl.r.p
+    12, // llvm.hexagon.S2.asl.r.p.acc
+    12, // llvm.hexagon.S2.asl.r.p.and
+    12, // llvm.hexagon.S2.asl.r.p.nac
+    12, // llvm.hexagon.S2.asl.r.p.or
+    12, // llvm.hexagon.S2.asl.r.p.xor
+    12, // llvm.hexagon.S2.asl.r.r
+    12, // llvm.hexagon.S2.asl.r.r.acc
+    12, // llvm.hexagon.S2.asl.r.r.and
+    12, // llvm.hexagon.S2.asl.r.r.nac
+    12, // llvm.hexagon.S2.asl.r.r.or
+    12, // llvm.hexagon.S2.asl.r.r.sat
+    12, // llvm.hexagon.S2.asl.r.vh
+    12, // llvm.hexagon.S2.asl.r.vw
+    78, // llvm.hexagon.S2.asr.i.p
+    70, // llvm.hexagon.S2.asr.i.p.acc
+    70, // llvm.hexagon.S2.asr.i.p.and
+    70, // llvm.hexagon.S2.asr.i.p.nac
+    70, // llvm.hexagon.S2.asr.i.p.or
+    78, // llvm.hexagon.S2.asr.i.p.rnd
+    78, // llvm.hexagon.S2.asr.i.p.rnd.goodsyntax
+    78, // llvm.hexagon.S2.asr.i.r
+    70, // llvm.hexagon.S2.asr.i.r.acc
+    70, // llvm.hexagon.S2.asr.i.r.and
+    70, // llvm.hexagon.S2.asr.i.r.nac
+    70, // llvm.hexagon.S2.asr.i.r.or
+    78, // llvm.hexagon.S2.asr.i.r.rnd
+    78, // llvm.hexagon.S2.asr.i.r.rnd.goodsyntax
+    78, // llvm.hexagon.S2.asr.i.svw.trun
+    78, // llvm.hexagon.S2.asr.i.vh
+    78, // llvm.hexagon.S2.asr.i.vw
+    12, // llvm.hexagon.S2.asr.r.p
+    12, // llvm.hexagon.S2.asr.r.p.acc
+    12, // llvm.hexagon.S2.asr.r.p.and
+    12, // llvm.hexagon.S2.asr.r.p.nac
+    12, // llvm.hexagon.S2.asr.r.p.or
+    12, // llvm.hexagon.S2.asr.r.p.xor
+    12, // llvm.hexagon.S2.asr.r.r
+    12, // llvm.hexagon.S2.asr.r.r.acc
+    12, // llvm.hexagon.S2.asr.r.r.and
+    12, // llvm.hexagon.S2.asr.r.r.nac
+    12, // llvm.hexagon.S2.asr.r.r.or
+    12, // llvm.hexagon.S2.asr.r.r.sat
+    12, // llvm.hexagon.S2.asr.r.svw.trun
+    12, // llvm.hexagon.S2.asr.r.vh
+    12, // llvm.hexagon.S2.asr.r.vw
+    12, // llvm.hexagon.S2.brev
+    12, // llvm.hexagon.S2.brevp
+    12, // llvm.hexagon.S2.cl0
+    12, // llvm.hexagon.S2.cl0p
+    12, // llvm.hexagon.S2.cl1
+    12, // llvm.hexagon.S2.cl1p
+    12, // llvm.hexagon.S2.clb
+    12, // llvm.hexagon.S2.clbnorm
+    12, // llvm.hexagon.S2.clbp
+    78, // llvm.hexagon.S2.clrbit.i
+    12, // llvm.hexagon.S2.clrbit.r
+    12, // llvm.hexagon.S2.ct0
+    12, // llvm.hexagon.S2.ct0p
+    12, // llvm.hexagon.S2.ct1
+    12, // llvm.hexagon.S2.ct1p
+    12, // llvm.hexagon.S2.deinterleave
+    79, // llvm.hexagon.S2.extractu
+    12, // llvm.hexagon.S2.extractu.rp
+    79, // llvm.hexagon.S2.extractup
+    12, // llvm.hexagon.S2.extractup.rp
+    182, // llvm.hexagon.S2.insert
+    12, // llvm.hexagon.S2.insert.rp
+    182, // llvm.hexagon.S2.insertp
+    12, // llvm.hexagon.S2.insertp.rp
+    12, // llvm.hexagon.S2.interleave
+    12, // llvm.hexagon.S2.lfsp
+    12, // llvm.hexagon.S2.lsl.r.p
+    12, // llvm.hexagon.S2.lsl.r.p.acc
+    12, // llvm.hexagon.S2.lsl.r.p.and
+    12, // llvm.hexagon.S2.lsl.r.p.nac
+    12, // llvm.hexagon.S2.lsl.r.p.or
+    12, // llvm.hexagon.S2.lsl.r.p.xor
+    12, // llvm.hexagon.S2.lsl.r.r
+    12, // llvm.hexagon.S2.lsl.r.r.acc
+    12, // llvm.hexagon.S2.lsl.r.r.and
+    12, // llvm.hexagon.S2.lsl.r.r.nac
+    12, // llvm.hexagon.S2.lsl.r.r.or
+    12, // llvm.hexagon.S2.lsl.r.vh
+    12, // llvm.hexagon.S2.lsl.r.vw
+    78, // llvm.hexagon.S2.lsr.i.p
+    70, // llvm.hexagon.S2.lsr.i.p.acc
+    70, // llvm.hexagon.S2.lsr.i.p.and
+    70, // llvm.hexagon.S2.lsr.i.p.nac
+    70, // llvm.hexagon.S2.lsr.i.p.or
+    70, // llvm.hexagon.S2.lsr.i.p.xacc
+    78, // llvm.hexagon.S2.lsr.i.r
+    70, // llvm.hexagon.S2.lsr.i.r.acc
+    70, // llvm.hexagon.S2.lsr.i.r.and
+    70, // llvm.hexagon.S2.lsr.i.r.nac
+    70, // llvm.hexagon.S2.lsr.i.r.or
+    70, // llvm.hexagon.S2.lsr.i.r.xacc
+    78, // llvm.hexagon.S2.lsr.i.vh
+    78, // llvm.hexagon.S2.lsr.i.vw
+    12, // llvm.hexagon.S2.lsr.r.p
+    12, // llvm.hexagon.S2.lsr.r.p.acc
+    12, // llvm.hexagon.S2.lsr.r.p.and
+    12, // llvm.hexagon.S2.lsr.r.p.nac
+    12, // llvm.hexagon.S2.lsr.r.p.or
+    12, // llvm.hexagon.S2.lsr.r.p.xor
+    12, // llvm.hexagon.S2.lsr.r.r
+    12, // llvm.hexagon.S2.lsr.r.r.acc
+    12, // llvm.hexagon.S2.lsr.r.r.and
+    12, // llvm.hexagon.S2.lsr.r.r.nac
+    12, // llvm.hexagon.S2.lsr.r.r.or
+    12, // llvm.hexagon.S2.lsr.r.vh
+    12, // llvm.hexagon.S2.lsr.r.vw
+    167, // llvm.hexagon.S2.mask
+    12, // llvm.hexagon.S2.packhl
+    12, // llvm.hexagon.S2.parityp
+    78, // llvm.hexagon.S2.setbit.i
+    12, // llvm.hexagon.S2.setbit.r
+    12, // llvm.hexagon.S2.shuffeb
+    12, // llvm.hexagon.S2.shuffeh
+    12, // llvm.hexagon.S2.shuffob
+    12, // llvm.hexagon.S2.shuffoh
+    69, // llvm.hexagon.S2.storerb.pbr
+    66, // llvm.hexagon.S2.storerb.pci
+    65, // llvm.hexagon.S2.storerb.pcr
+    69, // llvm.hexagon.S2.storerd.pbr
+    66, // llvm.hexagon.S2.storerd.pci
+    65, // llvm.hexagon.S2.storerd.pcr
+    69, // llvm.hexagon.S2.storerf.pbr
+    66, // llvm.hexagon.S2.storerf.pci
+    65, // llvm.hexagon.S2.storerf.pcr
+    69, // llvm.hexagon.S2.storerh.pbr
+    66, // llvm.hexagon.S2.storerh.pci
+    65, // llvm.hexagon.S2.storerh.pcr
+    69, // llvm.hexagon.S2.storeri.pbr
+    66, // llvm.hexagon.S2.storeri.pci
+    65, // llvm.hexagon.S2.storeri.pcr
+    30, // llvm.hexagon.S2.storew.locked
+    12, // llvm.hexagon.S2.svsathb
+    12, // llvm.hexagon.S2.svsathub
+    182, // llvm.hexagon.S2.tableidxb.goodsyntax
+    182, // llvm.hexagon.S2.tableidxd.goodsyntax
+    182, // llvm.hexagon.S2.tableidxh.goodsyntax
+    182, // llvm.hexagon.S2.tableidxw.goodsyntax
+    78, // llvm.hexagon.S2.togglebit.i
+    12, // llvm.hexagon.S2.togglebit.r
+    78, // llvm.hexagon.S2.tstbit.i
+    12, // llvm.hexagon.S2.tstbit.r
+    70, // llvm.hexagon.S2.valignib
+    12, // llvm.hexagon.S2.valignrb
+    12, // llvm.hexagon.S2.vcnegh
+    12, // llvm.hexagon.S2.vcrotate
+    12, // llvm.hexagon.S2.vrcnegh
+    12, // llvm.hexagon.S2.vrndpackwh
+    12, // llvm.hexagon.S2.vrndpackwhs
+    12, // llvm.hexagon.S2.vsathb
+    12, // llvm.hexagon.S2.vsathb.nopack
+    12, // llvm.hexagon.S2.vsathub
+    12, // llvm.hexagon.S2.vsathub.nopack
+    12, // llvm.hexagon.S2.vsatwh
+    12, // llvm.hexagon.S2.vsatwh.nopack
+    12, // llvm.hexagon.S2.vsatwuh
+    12, // llvm.hexagon.S2.vsatwuh.nopack
+    12, // llvm.hexagon.S2.vsplatrb
+    12, // llvm.hexagon.S2.vsplatrh
+    70, // llvm.hexagon.S2.vspliceib
+    12, // llvm.hexagon.S2.vsplicerb
+    12, // llvm.hexagon.S2.vsxtbh
+    12, // llvm.hexagon.S2.vsxthw
+    12, // llvm.hexagon.S2.vtrunehb
+    12, // llvm.hexagon.S2.vtrunewh
+    12, // llvm.hexagon.S2.vtrunohb
+    12, // llvm.hexagon.S2.vtrunowh
+    12, // llvm.hexagon.S2.vzxtbh
+    12, // llvm.hexagon.S2.vzxthw
+    70, // llvm.hexagon.S4.addaddi
+    168, // llvm.hexagon.S4.addi.asl.ri
+    168, // llvm.hexagon.S4.addi.lsr.ri
+    168, // llvm.hexagon.S4.andi.asl.ri
+    168, // llvm.hexagon.S4.andi.lsr.ri
+    78, // llvm.hexagon.S4.clbaddi
+    78, // llvm.hexagon.S4.clbpaddi
+    12, // llvm.hexagon.S4.clbpnorm
+    79, // llvm.hexagon.S4.extract
+    12, // llvm.hexagon.S4.extract.rp
+    79, // llvm.hexagon.S4.extractp
+    12, // llvm.hexagon.S4.extractp.rp
+    73, // llvm.hexagon.S4.lsli
+    78, // llvm.hexagon.S4.ntstbit.i
+    12, // llvm.hexagon.S4.ntstbit.r
+    70, // llvm.hexagon.S4.or.andi
+    70, // llvm.hexagon.S4.or.andix
+    70, // llvm.hexagon.S4.or.ori
+    168, // llvm.hexagon.S4.ori.asl.ri
+    168, // llvm.hexagon.S4.ori.lsr.ri
+    12, // llvm.hexagon.S4.parity
+    30, // llvm.hexagon.S4.stored.locked
+    78, // llvm.hexagon.S4.subaddi
+    168, // llvm.hexagon.S4.subi.asl.ri
+    168, // llvm.hexagon.S4.subi.lsr.ri
+    70, // llvm.hexagon.S4.vrcrotate
+    71, // llvm.hexagon.S4.vrcrotate.acc
+    12, // llvm.hexagon.S4.vxaddsubh
+    12, // llvm.hexagon.S4.vxaddsubhr
+    12, // llvm.hexagon.S4.vxaddsubw
+    12, // llvm.hexagon.S4.vxsubaddh
+    12, // llvm.hexagon.S4.vxsubaddhr
+    12, // llvm.hexagon.S4.vxsubaddw
+    78, // llvm.hexagon.S5.asrhub.rnd.sat.goodsyntax
+    78, // llvm.hexagon.S5.asrhub.sat
+    12, // llvm.hexagon.S5.popcountp
+    78, // llvm.hexagon.S5.vasrhrnd.goodsyntax
+    78, // llvm.hexagon.S6.rol.i.p
+    70, // llvm.hexagon.S6.rol.i.p.acc
+    70, // llvm.hexagon.S6.rol.i.p.and
+    70, // llvm.hexagon.S6.rol.i.p.nac
+    70, // llvm.hexagon.S6.rol.i.p.or
+    70, // llvm.hexagon.S6.rol.i.p.xacc
+    78, // llvm.hexagon.S6.rol.i.r
+    70, // llvm.hexagon.S6.rol.i.r.acc
+    70, // llvm.hexagon.S6.rol.i.r.and
+    70, // llvm.hexagon.S6.rol.i.r.nac
+    70, // llvm.hexagon.S6.rol.i.r.or
+    70, // llvm.hexagon.S6.rol.i.r.xacc
+    12, // llvm.hexagon.S6.vsplatrbp
+    12, // llvm.hexagon.S6.vtrunehb.ppp
+    12, // llvm.hexagon.S6.vtrunohb.ppp
+    12, // llvm.hexagon.V6.extractw
+    12, // llvm.hexagon.V6.extractw.128B
+    12, // llvm.hexagon.V6.hi
+    12, // llvm.hexagon.V6.hi.128B
+    12, // llvm.hexagon.V6.lo
+    12, // llvm.hexagon.V6.lo.128B
+    12, // llvm.hexagon.V6.lvsplatb
+    12, // llvm.hexagon.V6.lvsplatb.128B
+    12, // llvm.hexagon.V6.lvsplath
+    12, // llvm.hexagon.V6.lvsplath.128B
+    12, // llvm.hexagon.V6.lvsplatw
+    12, // llvm.hexagon.V6.lvsplatw.128B
+    12, // llvm.hexagon.V6.pred.and
+    12, // llvm.hexagon.V6.pred.and.128B
+    12, // llvm.hexagon.V6.pred.and.n
+    12, // llvm.hexagon.V6.pred.and.n.128B
+    12, // llvm.hexagon.V6.pred.not
+    12, // llvm.hexagon.V6.pred.not.128B
+    12, // llvm.hexagon.V6.pred.or
+    12, // llvm.hexagon.V6.pred.or.128B
+    12, // llvm.hexagon.V6.pred.or.n
+    12, // llvm.hexagon.V6.pred.or.n.128B
+    12, // llvm.hexagon.V6.pred.scalar2
+    12, // llvm.hexagon.V6.pred.scalar2.128B
+    12, // llvm.hexagon.V6.pred.scalar2v2
+    12, // llvm.hexagon.V6.pred.scalar2v2.128B
+    12, // llvm.hexagon.V6.pred.typecast
+    12, // llvm.hexagon.V6.pred.typecast.128B
+    12, // llvm.hexagon.V6.pred.xor
+    12, // llvm.hexagon.V6.pred.xor.128B
+    12, // llvm.hexagon.V6.shuffeqh
+    12, // llvm.hexagon.V6.shuffeqh.128B
+    12, // llvm.hexagon.V6.shuffeqw
+    12, // llvm.hexagon.V6.shuffeqw.128B
+    69, // llvm.hexagon.V6.vS32b.nqpred.ai
+    69, // llvm.hexagon.V6.vS32b.nqpred.ai.128B
+    69, // llvm.hexagon.V6.vS32b.nt.nqpred.ai
+    69, // llvm.hexagon.V6.vS32b.nt.nqpred.ai.128B
+    69, // llvm.hexagon.V6.vS32b.nt.qpred.ai
+    69, // llvm.hexagon.V6.vS32b.nt.qpred.ai.128B
+    69, // llvm.hexagon.V6.vS32b.qpred.ai
+    69, // llvm.hexagon.V6.vS32b.qpred.ai.128B
+    12, // llvm.hexagon.V6.vabsb
+    12, // llvm.hexagon.V6.vabsb.128B
+    12, // llvm.hexagon.V6.vabsb.sat
+    12, // llvm.hexagon.V6.vabsb.sat.128B
+    12, // llvm.hexagon.V6.vabsdiffh
+    12, // llvm.hexagon.V6.vabsdiffh.128B
+    12, // llvm.hexagon.V6.vabsdiffub
+    12, // llvm.hexagon.V6.vabsdiffub.128B
+    12, // llvm.hexagon.V6.vabsdiffuh
+    12, // llvm.hexagon.V6.vabsdiffuh.128B
+    12, // llvm.hexagon.V6.vabsdiffw
+    12, // llvm.hexagon.V6.vabsdiffw.128B
+    12, // llvm.hexagon.V6.vabsh
+    12, // llvm.hexagon.V6.vabsh.128B
+    12, // llvm.hexagon.V6.vabsh.sat
+    12, // llvm.hexagon.V6.vabsh.sat.128B
+    12, // llvm.hexagon.V6.vabsw
+    12, // llvm.hexagon.V6.vabsw.128B
+    12, // llvm.hexagon.V6.vabsw.sat
+    12, // llvm.hexagon.V6.vabsw.sat.128B
+    12, // llvm.hexagon.V6.vaddb
+    12, // llvm.hexagon.V6.vaddb.128B
+    12, // llvm.hexagon.V6.vaddb.dv
+    12, // llvm.hexagon.V6.vaddb.dv.128B
+    12, // llvm.hexagon.V6.vaddbnq
+    12, // llvm.hexagon.V6.vaddbnq.128B
+    12, // llvm.hexagon.V6.vaddbq
+    12, // llvm.hexagon.V6.vaddbq.128B
+    12, // llvm.hexagon.V6.vaddbsat
+    12, // llvm.hexagon.V6.vaddbsat.128B
+    12, // llvm.hexagon.V6.vaddbsat.dv
+    12, // llvm.hexagon.V6.vaddbsat.dv.128B
+    12, // llvm.hexagon.V6.vaddcarry
+    12, // llvm.hexagon.V6.vaddcarry.128B
+    12, // llvm.hexagon.V6.vaddcarrysat
+    12, // llvm.hexagon.V6.vaddcarrysat.128B
+    12, // llvm.hexagon.V6.vaddclbh
+    12, // llvm.hexagon.V6.vaddclbh.128B
+    12, // llvm.hexagon.V6.vaddclbw
+    12, // llvm.hexagon.V6.vaddclbw.128B
+    12, // llvm.hexagon.V6.vaddh
+    12, // llvm.hexagon.V6.vaddh.128B
+    12, // llvm.hexagon.V6.vaddh.dv
+    12, // llvm.hexagon.V6.vaddh.dv.128B
+    12, // llvm.hexagon.V6.vaddhnq
+    12, // llvm.hexagon.V6.vaddhnq.128B
+    12, // llvm.hexagon.V6.vaddhq
+    12, // llvm.hexagon.V6.vaddhq.128B
+    12, // llvm.hexagon.V6.vaddhsat
+    12, // llvm.hexagon.V6.vaddhsat.128B
+    12, // llvm.hexagon.V6.vaddhsat.dv
+    12, // llvm.hexagon.V6.vaddhsat.dv.128B
+    12, // llvm.hexagon.V6.vaddhw
+    12, // llvm.hexagon.V6.vaddhw.128B
+    12, // llvm.hexagon.V6.vaddhw.acc
+    12, // llvm.hexagon.V6.vaddhw.acc.128B
+    12, // llvm.hexagon.V6.vaddubh
+    12, // llvm.hexagon.V6.vaddubh.128B
+    12, // llvm.hexagon.V6.vaddubh.acc
+    12, // llvm.hexagon.V6.vaddubh.acc.128B
+    12, // llvm.hexagon.V6.vaddubsat
+    12, // llvm.hexagon.V6.vaddubsat.128B
+    12, // llvm.hexagon.V6.vaddubsat.dv
+    12, // llvm.hexagon.V6.vaddubsat.dv.128B
+    12, // llvm.hexagon.V6.vaddububb.sat
+    12, // llvm.hexagon.V6.vaddububb.sat.128B
+    12, // llvm.hexagon.V6.vadduhsat
+    12, // llvm.hexagon.V6.vadduhsat.128B
+    12, // llvm.hexagon.V6.vadduhsat.dv
+    12, // llvm.hexagon.V6.vadduhsat.dv.128B
+    12, // llvm.hexagon.V6.vadduhw
+    12, // llvm.hexagon.V6.vadduhw.128B
+    12, // llvm.hexagon.V6.vadduhw.acc
+    12, // llvm.hexagon.V6.vadduhw.acc.128B
+    12, // llvm.hexagon.V6.vadduwsat
+    12, // llvm.hexagon.V6.vadduwsat.128B
+    12, // llvm.hexagon.V6.vadduwsat.dv
+    12, // llvm.hexagon.V6.vadduwsat.dv.128B
+    12, // llvm.hexagon.V6.vaddw
+    12, // llvm.hexagon.V6.vaddw.128B
+    12, // llvm.hexagon.V6.vaddw.dv
+    12, // llvm.hexagon.V6.vaddw.dv.128B
+    12, // llvm.hexagon.V6.vaddwnq
+    12, // llvm.hexagon.V6.vaddwnq.128B
+    12, // llvm.hexagon.V6.vaddwq
+    12, // llvm.hexagon.V6.vaddwq.128B
+    12, // llvm.hexagon.V6.vaddwsat
+    12, // llvm.hexagon.V6.vaddwsat.128B
+    12, // llvm.hexagon.V6.vaddwsat.dv
+    12, // llvm.hexagon.V6.vaddwsat.dv.128B
+    12, // llvm.hexagon.V6.valignb
+    12, // llvm.hexagon.V6.valignb.128B
+    70, // llvm.hexagon.V6.valignbi
+    70, // llvm.hexagon.V6.valignbi.128B
+    12, // llvm.hexagon.V6.vand
+    12, // llvm.hexagon.V6.vand.128B
+    12, // llvm.hexagon.V6.vandnqrt
+    12, // llvm.hexagon.V6.vandnqrt.128B
+    12, // llvm.hexagon.V6.vandnqrt.acc
+    12, // llvm.hexagon.V6.vandnqrt.acc.128B
+    12, // llvm.hexagon.V6.vandqrt
+    12, // llvm.hexagon.V6.vandqrt.128B
+    12, // llvm.hexagon.V6.vandqrt.acc
+    12, // llvm.hexagon.V6.vandqrt.acc.128B
+    12, // llvm.hexagon.V6.vandvnqv
+    12, // llvm.hexagon.V6.vandvnqv.128B
+    12, // llvm.hexagon.V6.vandvqv
+    12, // llvm.hexagon.V6.vandvqv.128B
+    12, // llvm.hexagon.V6.vandvrt
+    12, // llvm.hexagon.V6.vandvrt.128B
+    12, // llvm.hexagon.V6.vandvrt.acc
+    12, // llvm.hexagon.V6.vandvrt.acc.128B
+    12, // llvm.hexagon.V6.vaslh
+    12, // llvm.hexagon.V6.vaslh.128B
+    12, // llvm.hexagon.V6.vaslh.acc
+    12, // llvm.hexagon.V6.vaslh.acc.128B
+    12, // llvm.hexagon.V6.vaslhv
+    12, // llvm.hexagon.V6.vaslhv.128B
+    12, // llvm.hexagon.V6.vaslw
+    12, // llvm.hexagon.V6.vaslw.128B
+    12, // llvm.hexagon.V6.vaslw.acc
+    12, // llvm.hexagon.V6.vaslw.acc.128B
+    12, // llvm.hexagon.V6.vaslwv
+    12, // llvm.hexagon.V6.vaslwv.128B
+    12, // llvm.hexagon.V6.vasr.into
+    12, // llvm.hexagon.V6.vasr.into.128B
+    12, // llvm.hexagon.V6.vasrh
+    12, // llvm.hexagon.V6.vasrh.128B
+    12, // llvm.hexagon.V6.vasrh.acc
+    12, // llvm.hexagon.V6.vasrh.acc.128B
+    12, // llvm.hexagon.V6.vasrhbrndsat
+    12, // llvm.hexagon.V6.vasrhbrndsat.128B
+    12, // llvm.hexagon.V6.vasrhbsat
+    12, // llvm.hexagon.V6.vasrhbsat.128B
+    12, // llvm.hexagon.V6.vasrhubrndsat
+    12, // llvm.hexagon.V6.vasrhubrndsat.128B
+    12, // llvm.hexagon.V6.vasrhubsat
+    12, // llvm.hexagon.V6.vasrhubsat.128B
+    12, // llvm.hexagon.V6.vasrhv
+    12, // llvm.hexagon.V6.vasrhv.128B
+    12, // llvm.hexagon.V6.vasruhubrndsat
+    12, // llvm.hexagon.V6.vasruhubrndsat.128B
+    12, // llvm.hexagon.V6.vasruhubsat
+    12, // llvm.hexagon.V6.vasruhubsat.128B
+    12, // llvm.hexagon.V6.vasruwuhrndsat
+    12, // llvm.hexagon.V6.vasruwuhrndsat.128B
+    12, // llvm.hexagon.V6.vasruwuhsat
+    12, // llvm.hexagon.V6.vasruwuhsat.128B
+    12, // llvm.hexagon.V6.vasrw
+    12, // llvm.hexagon.V6.vasrw.128B
+    12, // llvm.hexagon.V6.vasrw.acc
+    12, // llvm.hexagon.V6.vasrw.acc.128B
+    12, // llvm.hexagon.V6.vasrwh
+    12, // llvm.hexagon.V6.vasrwh.128B
+    12, // llvm.hexagon.V6.vasrwhrndsat
+    12, // llvm.hexagon.V6.vasrwhrndsat.128B
+    12, // llvm.hexagon.V6.vasrwhsat
+    12, // llvm.hexagon.V6.vasrwhsat.128B
+    12, // llvm.hexagon.V6.vasrwuhrndsat
+    12, // llvm.hexagon.V6.vasrwuhrndsat.128B
+    12, // llvm.hexagon.V6.vasrwuhsat
+    12, // llvm.hexagon.V6.vasrwuhsat.128B
+    12, // llvm.hexagon.V6.vasrwv
+    12, // llvm.hexagon.V6.vasrwv.128B
+    12, // llvm.hexagon.V6.vassign
+    12, // llvm.hexagon.V6.vassign.128B
+    12, // llvm.hexagon.V6.vassignp
+    12, // llvm.hexagon.V6.vassignp.128B
+    12, // llvm.hexagon.V6.vavgb
+    12, // llvm.hexagon.V6.vavgb.128B
+    12, // llvm.hexagon.V6.vavgbrnd
+    12, // llvm.hexagon.V6.vavgbrnd.128B
+    12, // llvm.hexagon.V6.vavgh
+    12, // llvm.hexagon.V6.vavgh.128B
+    12, // llvm.hexagon.V6.vavghrnd
+    12, // llvm.hexagon.V6.vavghrnd.128B
+    12, // llvm.hexagon.V6.vavgub
+    12, // llvm.hexagon.V6.vavgub.128B
+    12, // llvm.hexagon.V6.vavgubrnd
+    12, // llvm.hexagon.V6.vavgubrnd.128B
+    12, // llvm.hexagon.V6.vavguh
+    12, // llvm.hexagon.V6.vavguh.128B
+    12, // llvm.hexagon.V6.vavguhrnd
+    12, // llvm.hexagon.V6.vavguhrnd.128B
+    12, // llvm.hexagon.V6.vavguw
+    12, // llvm.hexagon.V6.vavguw.128B
+    12, // llvm.hexagon.V6.vavguwrnd
+    12, // llvm.hexagon.V6.vavguwrnd.128B
+    12, // llvm.hexagon.V6.vavgw
+    12, // llvm.hexagon.V6.vavgw.128B
+    12, // llvm.hexagon.V6.vavgwrnd
+    12, // llvm.hexagon.V6.vavgwrnd.128B
+    12, // llvm.hexagon.V6.vcl0h
+    12, // llvm.hexagon.V6.vcl0h.128B
+    12, // llvm.hexagon.V6.vcl0w
+    12, // llvm.hexagon.V6.vcl0w.128B
+    12, // llvm.hexagon.V6.vcombine
+    12, // llvm.hexagon.V6.vcombine.128B
+    12, // llvm.hexagon.V6.vd0
+    12, // llvm.hexagon.V6.vd0.128B
+    12, // llvm.hexagon.V6.vdd0
+    12, // llvm.hexagon.V6.vdd0.128B
+    12, // llvm.hexagon.V6.vdealb
+    12, // llvm.hexagon.V6.vdealb.128B
+    12, // llvm.hexagon.V6.vdealb4w
+    12, // llvm.hexagon.V6.vdealb4w.128B
+    12, // llvm.hexagon.V6.vdealh
+    12, // llvm.hexagon.V6.vdealh.128B
+    12, // llvm.hexagon.V6.vdealvdd
+    12, // llvm.hexagon.V6.vdealvdd.128B
+    12, // llvm.hexagon.V6.vdelta
+    12, // llvm.hexagon.V6.vdelta.128B
+    12, // llvm.hexagon.V6.vdmpybus
+    12, // llvm.hexagon.V6.vdmpybus.128B
+    12, // llvm.hexagon.V6.vdmpybus.acc
+    12, // llvm.hexagon.V6.vdmpybus.acc.128B
+    12, // llvm.hexagon.V6.vdmpybus.dv
+    12, // llvm.hexagon.V6.vdmpybus.dv.128B
+    12, // llvm.hexagon.V6.vdmpybus.dv.acc
+    12, // llvm.hexagon.V6.vdmpybus.dv.acc.128B
+    12, // llvm.hexagon.V6.vdmpyhb
+    12, // llvm.hexagon.V6.vdmpyhb.128B
+    12, // llvm.hexagon.V6.vdmpyhb.acc
+    12, // llvm.hexagon.V6.vdmpyhb.acc.128B
+    12, // llvm.hexagon.V6.vdmpyhb.dv
+    12, // llvm.hexagon.V6.vdmpyhb.dv.128B
+    12, // llvm.hexagon.V6.vdmpyhb.dv.acc
+    12, // llvm.hexagon.V6.vdmpyhb.dv.acc.128B
+    12, // llvm.hexagon.V6.vdmpyhisat
+    12, // llvm.hexagon.V6.vdmpyhisat.128B
+    12, // llvm.hexagon.V6.vdmpyhisat.acc
+    12, // llvm.hexagon.V6.vdmpyhisat.acc.128B
+    12, // llvm.hexagon.V6.vdmpyhsat
+    12, // llvm.hexagon.V6.vdmpyhsat.128B
+    12, // llvm.hexagon.V6.vdmpyhsat.acc
+    12, // llvm.hexagon.V6.vdmpyhsat.acc.128B
+    12, // llvm.hexagon.V6.vdmpyhsuisat
+    12, // llvm.hexagon.V6.vdmpyhsuisat.128B
+    12, // llvm.hexagon.V6.vdmpyhsuisat.acc
+    12, // llvm.hexagon.V6.vdmpyhsuisat.acc.128B
+    12, // llvm.hexagon.V6.vdmpyhsusat
+    12, // llvm.hexagon.V6.vdmpyhsusat.128B
+    12, // llvm.hexagon.V6.vdmpyhsusat.acc
+    12, // llvm.hexagon.V6.vdmpyhsusat.acc.128B
+    12, // llvm.hexagon.V6.vdmpyhvsat
+    12, // llvm.hexagon.V6.vdmpyhvsat.128B
+    12, // llvm.hexagon.V6.vdmpyhvsat.acc
+    12, // llvm.hexagon.V6.vdmpyhvsat.acc.128B
+    12, // llvm.hexagon.V6.vdsaduh
+    12, // llvm.hexagon.V6.vdsaduh.128B
+    12, // llvm.hexagon.V6.vdsaduh.acc
+    12, // llvm.hexagon.V6.vdsaduh.acc.128B
+    12, // llvm.hexagon.V6.veqb
+    12, // llvm.hexagon.V6.veqb.128B
+    12, // llvm.hexagon.V6.veqb.and
+    12, // llvm.hexagon.V6.veqb.and.128B
+    12, // llvm.hexagon.V6.veqb.or
+    12, // llvm.hexagon.V6.veqb.or.128B
+    12, // llvm.hexagon.V6.veqb.xor
+    12, // llvm.hexagon.V6.veqb.xor.128B
+    12, // llvm.hexagon.V6.veqh
+    12, // llvm.hexagon.V6.veqh.128B
+    12, // llvm.hexagon.V6.veqh.and
+    12, // llvm.hexagon.V6.veqh.and.128B
+    12, // llvm.hexagon.V6.veqh.or
+    12, // llvm.hexagon.V6.veqh.or.128B
+    12, // llvm.hexagon.V6.veqh.xor
+    12, // llvm.hexagon.V6.veqh.xor.128B
+    12, // llvm.hexagon.V6.veqw
+    12, // llvm.hexagon.V6.veqw.128B
+    12, // llvm.hexagon.V6.veqw.and
+    12, // llvm.hexagon.V6.veqw.and.128B
+    12, // llvm.hexagon.V6.veqw.or
+    12, // llvm.hexagon.V6.veqw.or.128B
+    12, // llvm.hexagon.V6.veqw.xor
+    12, // llvm.hexagon.V6.veqw.xor.128B
+    178, // llvm.hexagon.V6.vgathermh
+    178, // llvm.hexagon.V6.vgathermh.128B
+    178, // llvm.hexagon.V6.vgathermhq
+    178, // llvm.hexagon.V6.vgathermhq.128B
+    178, // llvm.hexagon.V6.vgathermhw
+    178, // llvm.hexagon.V6.vgathermhw.128B
+    178, // llvm.hexagon.V6.vgathermhwq
+    178, // llvm.hexagon.V6.vgathermhwq.128B
+    178, // llvm.hexagon.V6.vgathermw
+    178, // llvm.hexagon.V6.vgathermw.128B
+    178, // llvm.hexagon.V6.vgathermwq
+    178, // llvm.hexagon.V6.vgathermwq.128B
+    12, // llvm.hexagon.V6.vgtb
+    12, // llvm.hexagon.V6.vgtb.128B
+    12, // llvm.hexagon.V6.vgtb.and
+    12, // llvm.hexagon.V6.vgtb.and.128B
+    12, // llvm.hexagon.V6.vgtb.or
+    12, // llvm.hexagon.V6.vgtb.or.128B
+    12, // llvm.hexagon.V6.vgtb.xor
+    12, // llvm.hexagon.V6.vgtb.xor.128B
+    12, // llvm.hexagon.V6.vgth
+    12, // llvm.hexagon.V6.vgth.128B
+    12, // llvm.hexagon.V6.vgth.and
+    12, // llvm.hexagon.V6.vgth.and.128B
+    12, // llvm.hexagon.V6.vgth.or
+    12, // llvm.hexagon.V6.vgth.or.128B
+    12, // llvm.hexagon.V6.vgth.xor
+    12, // llvm.hexagon.V6.vgth.xor.128B
+    12, // llvm.hexagon.V6.vgtub
+    12, // llvm.hexagon.V6.vgtub.128B
+    12, // llvm.hexagon.V6.vgtub.and
+    12, // llvm.hexagon.V6.vgtub.and.128B
+    12, // llvm.hexagon.V6.vgtub.or
+    12, // llvm.hexagon.V6.vgtub.or.128B
+    12, // llvm.hexagon.V6.vgtub.xor
+    12, // llvm.hexagon.V6.vgtub.xor.128B
+    12, // llvm.hexagon.V6.vgtuh
+    12, // llvm.hexagon.V6.vgtuh.128B
+    12, // llvm.hexagon.V6.vgtuh.and
+    12, // llvm.hexagon.V6.vgtuh.and.128B
+    12, // llvm.hexagon.V6.vgtuh.or
+    12, // llvm.hexagon.V6.vgtuh.or.128B
+    12, // llvm.hexagon.V6.vgtuh.xor
+    12, // llvm.hexagon.V6.vgtuh.xor.128B
+    12, // llvm.hexagon.V6.vgtuw
+    12, // llvm.hexagon.V6.vgtuw.128B
+    12, // llvm.hexagon.V6.vgtuw.and
+    12, // llvm.hexagon.V6.vgtuw.and.128B
+    12, // llvm.hexagon.V6.vgtuw.or
+    12, // llvm.hexagon.V6.vgtuw.or.128B
+    12, // llvm.hexagon.V6.vgtuw.xor
+    12, // llvm.hexagon.V6.vgtuw.xor.128B
+    12, // llvm.hexagon.V6.vgtw
+    12, // llvm.hexagon.V6.vgtw.128B
+    12, // llvm.hexagon.V6.vgtw.and
+    12, // llvm.hexagon.V6.vgtw.and.128B
+    12, // llvm.hexagon.V6.vgtw.or
+    12, // llvm.hexagon.V6.vgtw.or.128B
+    12, // llvm.hexagon.V6.vgtw.xor
+    12, // llvm.hexagon.V6.vgtw.xor.128B
+    12, // llvm.hexagon.V6.vinsertwr
+    12, // llvm.hexagon.V6.vinsertwr.128B
+    12, // llvm.hexagon.V6.vlalignb
+    12, // llvm.hexagon.V6.vlalignb.128B
+    70, // llvm.hexagon.V6.vlalignbi
+    70, // llvm.hexagon.V6.vlalignbi.128B
+    12, // llvm.hexagon.V6.vlsrb
+    12, // llvm.hexagon.V6.vlsrb.128B
+    12, // llvm.hexagon.V6.vlsrh
+    12, // llvm.hexagon.V6.vlsrh.128B
+    12, // llvm.hexagon.V6.vlsrhv
+    12, // llvm.hexagon.V6.vlsrhv.128B
+    12, // llvm.hexagon.V6.vlsrw
+    12, // llvm.hexagon.V6.vlsrw.128B
+    12, // llvm.hexagon.V6.vlsrwv
+    12, // llvm.hexagon.V6.vlsrwv.128B
+    12, // llvm.hexagon.V6.vlut4
+    12, // llvm.hexagon.V6.vlut4.128B
+    12, // llvm.hexagon.V6.vlutvvb
+    12, // llvm.hexagon.V6.vlutvvb.128B
+    12, // llvm.hexagon.V6.vlutvvb.nm
+    12, // llvm.hexagon.V6.vlutvvb.nm.128B
+    12, // llvm.hexagon.V6.vlutvvb.oracc
+    12, // llvm.hexagon.V6.vlutvvb.oracc.128B
+    71, // llvm.hexagon.V6.vlutvvb.oracci
+    71, // llvm.hexagon.V6.vlutvvb.oracci.128B
+    70, // llvm.hexagon.V6.vlutvvbi
+    70, // llvm.hexagon.V6.vlutvvbi.128B
+    12, // llvm.hexagon.V6.vlutvwh
+    12, // llvm.hexagon.V6.vlutvwh.128B
+    12, // llvm.hexagon.V6.vlutvwh.nm
+    12, // llvm.hexagon.V6.vlutvwh.nm.128B
+    12, // llvm.hexagon.V6.vlutvwh.oracc
+    12, // llvm.hexagon.V6.vlutvwh.oracc.128B
+    71, // llvm.hexagon.V6.vlutvwh.oracci
+    71, // llvm.hexagon.V6.vlutvwh.oracci.128B
+    70, // llvm.hexagon.V6.vlutvwhi
+    70, // llvm.hexagon.V6.vlutvwhi.128B
+    69, // llvm.hexagon.V6.vmaskedstorenq
+    69, // llvm.hexagon.V6.vmaskedstorenq.128B
+    69, // llvm.hexagon.V6.vmaskedstorentnq
+    69, // llvm.hexagon.V6.vmaskedstorentnq.128B
+    69, // llvm.hexagon.V6.vmaskedstorentq
+    69, // llvm.hexagon.V6.vmaskedstorentq.128B
+    69, // llvm.hexagon.V6.vmaskedstoreq
+    69, // llvm.hexagon.V6.vmaskedstoreq.128B
+    12, // llvm.hexagon.V6.vmaxb
+    12, // llvm.hexagon.V6.vmaxb.128B
+    12, // llvm.hexagon.V6.vmaxh
+    12, // llvm.hexagon.V6.vmaxh.128B
+    12, // llvm.hexagon.V6.vmaxub
+    12, // llvm.hexagon.V6.vmaxub.128B
+    12, // llvm.hexagon.V6.vmaxuh
+    12, // llvm.hexagon.V6.vmaxuh.128B
+    12, // llvm.hexagon.V6.vmaxw
+    12, // llvm.hexagon.V6.vmaxw.128B
+    12, // llvm.hexagon.V6.vminb
+    12, // llvm.hexagon.V6.vminb.128B
+    12, // llvm.hexagon.V6.vminh
+    12, // llvm.hexagon.V6.vminh.128B
+    12, // llvm.hexagon.V6.vminub
+    12, // llvm.hexagon.V6.vminub.128B
+    12, // llvm.hexagon.V6.vminuh
+    12, // llvm.hexagon.V6.vminuh.128B
+    12, // llvm.hexagon.V6.vminw
+    12, // llvm.hexagon.V6.vminw.128B
+    12, // llvm.hexagon.V6.vmpabus
+    12, // llvm.hexagon.V6.vmpabus.128B
+    12, // llvm.hexagon.V6.vmpabus.acc
+    12, // llvm.hexagon.V6.vmpabus.acc.128B
+    12, // llvm.hexagon.V6.vmpabusv
+    12, // llvm.hexagon.V6.vmpabusv.128B
+    12, // llvm.hexagon.V6.vmpabuu
+    12, // llvm.hexagon.V6.vmpabuu.128B
+    12, // llvm.hexagon.V6.vmpabuu.acc
+    12, // llvm.hexagon.V6.vmpabuu.acc.128B
+    12, // llvm.hexagon.V6.vmpabuuv
+    12, // llvm.hexagon.V6.vmpabuuv.128B
+    12, // llvm.hexagon.V6.vmpahb
+    12, // llvm.hexagon.V6.vmpahb.128B
+    12, // llvm.hexagon.V6.vmpahb.acc
+    12, // llvm.hexagon.V6.vmpahb.acc.128B
+    12, // llvm.hexagon.V6.vmpahhsat
+    12, // llvm.hexagon.V6.vmpahhsat.128B
+    12, // llvm.hexagon.V6.vmpauhb
+    12, // llvm.hexagon.V6.vmpauhb.128B
+    12, // llvm.hexagon.V6.vmpauhb.acc
+    12, // llvm.hexagon.V6.vmpauhb.acc.128B
+    12, // llvm.hexagon.V6.vmpauhuhsat
+    12, // llvm.hexagon.V6.vmpauhuhsat.128B
+    12, // llvm.hexagon.V6.vmpsuhuhsat
+    12, // llvm.hexagon.V6.vmpsuhuhsat.128B
+    12, // llvm.hexagon.V6.vmpybus
+    12, // llvm.hexagon.V6.vmpybus.128B
+    12, // llvm.hexagon.V6.vmpybus.acc
+    12, // llvm.hexagon.V6.vmpybus.acc.128B
+    12, // llvm.hexagon.V6.vmpybusv
+    12, // llvm.hexagon.V6.vmpybusv.128B
+    12, // llvm.hexagon.V6.vmpybusv.acc
+    12, // llvm.hexagon.V6.vmpybusv.acc.128B
+    12, // llvm.hexagon.V6.vmpybv
+    12, // llvm.hexagon.V6.vmpybv.128B
+    12, // llvm.hexagon.V6.vmpybv.acc
+    12, // llvm.hexagon.V6.vmpybv.acc.128B
+    12, // llvm.hexagon.V6.vmpyewuh
+    12, // llvm.hexagon.V6.vmpyewuh.128B
+    12, // llvm.hexagon.V6.vmpyewuh.64
+    12, // llvm.hexagon.V6.vmpyewuh.64.128B
+    12, // llvm.hexagon.V6.vmpyh
+    12, // llvm.hexagon.V6.vmpyh.128B
+    12, // llvm.hexagon.V6.vmpyh.acc
+    12, // llvm.hexagon.V6.vmpyh.acc.128B
+    12, // llvm.hexagon.V6.vmpyhsat.acc
+    12, // llvm.hexagon.V6.vmpyhsat.acc.128B
+    12, // llvm.hexagon.V6.vmpyhsrs
+    12, // llvm.hexagon.V6.vmpyhsrs.128B
+    12, // llvm.hexagon.V6.vmpyhss
+    12, // llvm.hexagon.V6.vmpyhss.128B
+    12, // llvm.hexagon.V6.vmpyhus
+    12, // llvm.hexagon.V6.vmpyhus.128B
+    12, // llvm.hexagon.V6.vmpyhus.acc
+    12, // llvm.hexagon.V6.vmpyhus.acc.128B
+    12, // llvm.hexagon.V6.vmpyhv
+    12, // llvm.hexagon.V6.vmpyhv.128B
+    12, // llvm.hexagon.V6.vmpyhv.acc
+    12, // llvm.hexagon.V6.vmpyhv.acc.128B
+    12, // llvm.hexagon.V6.vmpyhvsrs
+    12, // llvm.hexagon.V6.vmpyhvsrs.128B
+    12, // llvm.hexagon.V6.vmpyieoh
+    12, // llvm.hexagon.V6.vmpyieoh.128B
+    12, // llvm.hexagon.V6.vmpyiewh.acc
+    12, // llvm.hexagon.V6.vmpyiewh.acc.128B
+    12, // llvm.hexagon.V6.vmpyiewuh
+    12, // llvm.hexagon.V6.vmpyiewuh.128B
+    12, // llvm.hexagon.V6.vmpyiewuh.acc
+    12, // llvm.hexagon.V6.vmpyiewuh.acc.128B
+    12, // llvm.hexagon.V6.vmpyih
+    12, // llvm.hexagon.V6.vmpyih.128B
+    12, // llvm.hexagon.V6.vmpyih.acc
+    12, // llvm.hexagon.V6.vmpyih.acc.128B
+    12, // llvm.hexagon.V6.vmpyihb
+    12, // llvm.hexagon.V6.vmpyihb.128B
+    12, // llvm.hexagon.V6.vmpyihb.acc
+    12, // llvm.hexagon.V6.vmpyihb.acc.128B
+    12, // llvm.hexagon.V6.vmpyiowh
+    12, // llvm.hexagon.V6.vmpyiowh.128B
+    12, // llvm.hexagon.V6.vmpyiwb
+    12, // llvm.hexagon.V6.vmpyiwb.128B
+    12, // llvm.hexagon.V6.vmpyiwb.acc
+    12, // llvm.hexagon.V6.vmpyiwb.acc.128B
+    12, // llvm.hexagon.V6.vmpyiwh
+    12, // llvm.hexagon.V6.vmpyiwh.128B
+    12, // llvm.hexagon.V6.vmpyiwh.acc
+    12, // llvm.hexagon.V6.vmpyiwh.acc.128B
+    12, // llvm.hexagon.V6.vmpyiwub
+    12, // llvm.hexagon.V6.vmpyiwub.128B
+    12, // llvm.hexagon.V6.vmpyiwub.acc
+    12, // llvm.hexagon.V6.vmpyiwub.acc.128B
+    12, // llvm.hexagon.V6.vmpyowh
+    12, // llvm.hexagon.V6.vmpyowh.128B
+    12, // llvm.hexagon.V6.vmpyowh.64.acc
+    12, // llvm.hexagon.V6.vmpyowh.64.acc.128B
+    12, // llvm.hexagon.V6.vmpyowh.rnd
+    12, // llvm.hexagon.V6.vmpyowh.rnd.128B
+    12, // llvm.hexagon.V6.vmpyowh.rnd.sacc
+    12, // llvm.hexagon.V6.vmpyowh.rnd.sacc.128B
+    12, // llvm.hexagon.V6.vmpyowh.sacc
+    12, // llvm.hexagon.V6.vmpyowh.sacc.128B
+    12, // llvm.hexagon.V6.vmpyub
+    12, // llvm.hexagon.V6.vmpyub.128B
+    12, // llvm.hexagon.V6.vmpyub.acc
+    12, // llvm.hexagon.V6.vmpyub.acc.128B
+    12, // llvm.hexagon.V6.vmpyubv
+    12, // llvm.hexagon.V6.vmpyubv.128B
+    12, // llvm.hexagon.V6.vmpyubv.acc
+    12, // llvm.hexagon.V6.vmpyubv.acc.128B
+    12, // llvm.hexagon.V6.vmpyuh
+    12, // llvm.hexagon.V6.vmpyuh.128B
+    12, // llvm.hexagon.V6.vmpyuh.acc
+    12, // llvm.hexagon.V6.vmpyuh.acc.128B
+    12, // llvm.hexagon.V6.vmpyuhe
+    12, // llvm.hexagon.V6.vmpyuhe.128B
+    12, // llvm.hexagon.V6.vmpyuhe.acc
+    12, // llvm.hexagon.V6.vmpyuhe.acc.128B
+    12, // llvm.hexagon.V6.vmpyuhv
+    12, // llvm.hexagon.V6.vmpyuhv.128B
+    12, // llvm.hexagon.V6.vmpyuhv.acc
+    12, // llvm.hexagon.V6.vmpyuhv.acc.128B
+    12, // llvm.hexagon.V6.vmux
+    12, // llvm.hexagon.V6.vmux.128B
+    12, // llvm.hexagon.V6.vnavgb
+    12, // llvm.hexagon.V6.vnavgb.128B
+    12, // llvm.hexagon.V6.vnavgh
+    12, // llvm.hexagon.V6.vnavgh.128B
+    12, // llvm.hexagon.V6.vnavgub
+    12, // llvm.hexagon.V6.vnavgub.128B
+    12, // llvm.hexagon.V6.vnavgw
+    12, // llvm.hexagon.V6.vnavgw.128B
+    12, // llvm.hexagon.V6.vnormamth
+    12, // llvm.hexagon.V6.vnormamth.128B
+    12, // llvm.hexagon.V6.vnormamtw
+    12, // llvm.hexagon.V6.vnormamtw.128B
+    12, // llvm.hexagon.V6.vnot
+    12, // llvm.hexagon.V6.vnot.128B
+    12, // llvm.hexagon.V6.vor
+    12, // llvm.hexagon.V6.vor.128B
+    12, // llvm.hexagon.V6.vpackeb
+    12, // llvm.hexagon.V6.vpackeb.128B
+    12, // llvm.hexagon.V6.vpackeh
+    12, // llvm.hexagon.V6.vpackeh.128B
+    12, // llvm.hexagon.V6.vpackhb.sat
+    12, // llvm.hexagon.V6.vpackhb.sat.128B
+    12, // llvm.hexagon.V6.vpackhub.sat
+    12, // llvm.hexagon.V6.vpackhub.sat.128B
+    12, // llvm.hexagon.V6.vpackob
+    12, // llvm.hexagon.V6.vpackob.128B
+    12, // llvm.hexagon.V6.vpackoh
+    12, // llvm.hexagon.V6.vpackoh.128B
+    12, // llvm.hexagon.V6.vpackwh.sat
+    12, // llvm.hexagon.V6.vpackwh.sat.128B
+    12, // llvm.hexagon.V6.vpackwuh.sat
+    12, // llvm.hexagon.V6.vpackwuh.sat.128B
+    12, // llvm.hexagon.V6.vpopcounth
+    12, // llvm.hexagon.V6.vpopcounth.128B
+    12, // llvm.hexagon.V6.vprefixqb
+    12, // llvm.hexagon.V6.vprefixqb.128B
+    12, // llvm.hexagon.V6.vprefixqh
+    12, // llvm.hexagon.V6.vprefixqh.128B
+    12, // llvm.hexagon.V6.vprefixqw
+    12, // llvm.hexagon.V6.vprefixqw.128B
+    12, // llvm.hexagon.V6.vrdelta
+    12, // llvm.hexagon.V6.vrdelta.128B
+    12, // llvm.hexagon.V6.vrmpybub.rtt
+    12, // llvm.hexagon.V6.vrmpybub.rtt.128B
+    12, // llvm.hexagon.V6.vrmpybub.rtt.acc
+    12, // llvm.hexagon.V6.vrmpybub.rtt.acc.128B
+    12, // llvm.hexagon.V6.vrmpybus
+    12, // llvm.hexagon.V6.vrmpybus.128B
+    12, // llvm.hexagon.V6.vrmpybus.acc
+    12, // llvm.hexagon.V6.vrmpybus.acc.128B
+    70, // llvm.hexagon.V6.vrmpybusi
+    70, // llvm.hexagon.V6.vrmpybusi.128B
+    71, // llvm.hexagon.V6.vrmpybusi.acc
+    71, // llvm.hexagon.V6.vrmpybusi.acc.128B
+    12, // llvm.hexagon.V6.vrmpybusv
+    12, // llvm.hexagon.V6.vrmpybusv.128B
+    12, // llvm.hexagon.V6.vrmpybusv.acc
+    12, // llvm.hexagon.V6.vrmpybusv.acc.128B
+    12, // llvm.hexagon.V6.vrmpybv
+    12, // llvm.hexagon.V6.vrmpybv.128B
+    12, // llvm.hexagon.V6.vrmpybv.acc
+    12, // llvm.hexagon.V6.vrmpybv.acc.128B
+    12, // llvm.hexagon.V6.vrmpyub
+    12, // llvm.hexagon.V6.vrmpyub.128B
+    12, // llvm.hexagon.V6.vrmpyub.acc
+    12, // llvm.hexagon.V6.vrmpyub.acc.128B
+    12, // llvm.hexagon.V6.vrmpyub.rtt
+    12, // llvm.hexagon.V6.vrmpyub.rtt.128B
+    12, // llvm.hexagon.V6.vrmpyub.rtt.acc
+    12, // llvm.hexagon.V6.vrmpyub.rtt.acc.128B
+    70, // llvm.hexagon.V6.vrmpyubi
+    70, // llvm.hexagon.V6.vrmpyubi.128B
+    71, // llvm.hexagon.V6.vrmpyubi.acc
+    71, // llvm.hexagon.V6.vrmpyubi.acc.128B
+    12, // llvm.hexagon.V6.vrmpyubv
+    12, // llvm.hexagon.V6.vrmpyubv.128B
+    12, // llvm.hexagon.V6.vrmpyubv.acc
+    12, // llvm.hexagon.V6.vrmpyubv.acc.128B
+    12, // llvm.hexagon.V6.vror
+    12, // llvm.hexagon.V6.vror.128B
+    12, // llvm.hexagon.V6.vrotr
+    12, // llvm.hexagon.V6.vrotr.128B
+    12, // llvm.hexagon.V6.vroundhb
+    12, // llvm.hexagon.V6.vroundhb.128B
+    12, // llvm.hexagon.V6.vroundhub
+    12, // llvm.hexagon.V6.vroundhub.128B
+    12, // llvm.hexagon.V6.vrounduhub
+    12, // llvm.hexagon.V6.vrounduhub.128B
+    12, // llvm.hexagon.V6.vrounduwuh
+    12, // llvm.hexagon.V6.vrounduwuh.128B
+    12, // llvm.hexagon.V6.vroundwh
+    12, // llvm.hexagon.V6.vroundwh.128B
+    12, // llvm.hexagon.V6.vroundwuh
+    12, // llvm.hexagon.V6.vroundwuh.128B
+    70, // llvm.hexagon.V6.vrsadubi
+    70, // llvm.hexagon.V6.vrsadubi.128B
+    71, // llvm.hexagon.V6.vrsadubi.acc
+    71, // llvm.hexagon.V6.vrsadubi.acc.128B
+    12, // llvm.hexagon.V6.vsatdw
+    12, // llvm.hexagon.V6.vsatdw.128B
+    12, // llvm.hexagon.V6.vsathub
+    12, // llvm.hexagon.V6.vsathub.128B
+    12, // llvm.hexagon.V6.vsatuwuh
+    12, // llvm.hexagon.V6.vsatuwuh.128B
+    12, // llvm.hexagon.V6.vsatwh
+    12, // llvm.hexagon.V6.vsatwh.128B
+    12, // llvm.hexagon.V6.vsb
+    12, // llvm.hexagon.V6.vsb.128B
+    69, // llvm.hexagon.V6.vscattermh
+    69, // llvm.hexagon.V6.vscattermh.128B
+    69, // llvm.hexagon.V6.vscattermh.add
+    69, // llvm.hexagon.V6.vscattermh.add.128B
+    69, // llvm.hexagon.V6.vscattermhq
+    69, // llvm.hexagon.V6.vscattermhq.128B
+    69, // llvm.hexagon.V6.vscattermhw
+    69, // llvm.hexagon.V6.vscattermhw.128B
+    69, // llvm.hexagon.V6.vscattermhw.add
+    69, // llvm.hexagon.V6.vscattermhw.add.128B
+    69, // llvm.hexagon.V6.vscattermhwq
+    69, // llvm.hexagon.V6.vscattermhwq.128B
+    69, // llvm.hexagon.V6.vscattermw
+    69, // llvm.hexagon.V6.vscattermw.128B
+    69, // llvm.hexagon.V6.vscattermw.add
+    69, // llvm.hexagon.V6.vscattermw.add.128B
+    69, // llvm.hexagon.V6.vscattermwq
+    69, // llvm.hexagon.V6.vscattermwq.128B
+    12, // llvm.hexagon.V6.vsh
+    12, // llvm.hexagon.V6.vsh.128B
+    12, // llvm.hexagon.V6.vshufeh
+    12, // llvm.hexagon.V6.vshufeh.128B
+    12, // llvm.hexagon.V6.vshuffb
+    12, // llvm.hexagon.V6.vshuffb.128B
+    12, // llvm.hexagon.V6.vshuffeb
+    12, // llvm.hexagon.V6.vshuffeb.128B
+    12, // llvm.hexagon.V6.vshuffh
+    12, // llvm.hexagon.V6.vshuffh.128B
+    12, // llvm.hexagon.V6.vshuffob
+    12, // llvm.hexagon.V6.vshuffob.128B
+    12, // llvm.hexagon.V6.vshuffvdd
+    12, // llvm.hexagon.V6.vshuffvdd.128B
+    12, // llvm.hexagon.V6.vshufoeb
+    12, // llvm.hexagon.V6.vshufoeb.128B
+    12, // llvm.hexagon.V6.vshufoeh
+    12, // llvm.hexagon.V6.vshufoeh.128B
+    12, // llvm.hexagon.V6.vshufoh
+    12, // llvm.hexagon.V6.vshufoh.128B
+    12, // llvm.hexagon.V6.vsubb
+    12, // llvm.hexagon.V6.vsubb.128B
+    12, // llvm.hexagon.V6.vsubb.dv
+    12, // llvm.hexagon.V6.vsubb.dv.128B
+    12, // llvm.hexagon.V6.vsubbnq
+    12, // llvm.hexagon.V6.vsubbnq.128B
+    12, // llvm.hexagon.V6.vsubbq
+    12, // llvm.hexagon.V6.vsubbq.128B
+    12, // llvm.hexagon.V6.vsubbsat
+    12, // llvm.hexagon.V6.vsubbsat.128B
+    12, // llvm.hexagon.V6.vsubbsat.dv
+    12, // llvm.hexagon.V6.vsubbsat.dv.128B
+    12, // llvm.hexagon.V6.vsubcarry
+    12, // llvm.hexagon.V6.vsubcarry.128B
+    12, // llvm.hexagon.V6.vsubh
+    12, // llvm.hexagon.V6.vsubh.128B
+    12, // llvm.hexagon.V6.vsubh.dv
+    12, // llvm.hexagon.V6.vsubh.dv.128B
+    12, // llvm.hexagon.V6.vsubhnq
+    12, // llvm.hexagon.V6.vsubhnq.128B
+    12, // llvm.hexagon.V6.vsubhq
+    12, // llvm.hexagon.V6.vsubhq.128B
+    12, // llvm.hexagon.V6.vsubhsat
+    12, // llvm.hexagon.V6.vsubhsat.128B
+    12, // llvm.hexagon.V6.vsubhsat.dv
+    12, // llvm.hexagon.V6.vsubhsat.dv.128B
+    12, // llvm.hexagon.V6.vsubhw
+    12, // llvm.hexagon.V6.vsubhw.128B
+    12, // llvm.hexagon.V6.vsububh
+    12, // llvm.hexagon.V6.vsububh.128B
+    12, // llvm.hexagon.V6.vsububsat
+    12, // llvm.hexagon.V6.vsububsat.128B
+    12, // llvm.hexagon.V6.vsububsat.dv
+    12, // llvm.hexagon.V6.vsububsat.dv.128B
+    12, // llvm.hexagon.V6.vsubububb.sat
+    12, // llvm.hexagon.V6.vsubububb.sat.128B
+    12, // llvm.hexagon.V6.vsubuhsat
+    12, // llvm.hexagon.V6.vsubuhsat.128B
+    12, // llvm.hexagon.V6.vsubuhsat.dv
+    12, // llvm.hexagon.V6.vsubuhsat.dv.128B
+    12, // llvm.hexagon.V6.vsubuhw
+    12, // llvm.hexagon.V6.vsubuhw.128B
+    12, // llvm.hexagon.V6.vsubuwsat
+    12, // llvm.hexagon.V6.vsubuwsat.128B
+    12, // llvm.hexagon.V6.vsubuwsat.dv
+    12, // llvm.hexagon.V6.vsubuwsat.dv.128B
+    12, // llvm.hexagon.V6.vsubw
+    12, // llvm.hexagon.V6.vsubw.128B
+    12, // llvm.hexagon.V6.vsubw.dv
+    12, // llvm.hexagon.V6.vsubw.dv.128B
+    12, // llvm.hexagon.V6.vsubwnq
+    12, // llvm.hexagon.V6.vsubwnq.128B
+    12, // llvm.hexagon.V6.vsubwq
+    12, // llvm.hexagon.V6.vsubwq.128B
+    12, // llvm.hexagon.V6.vsubwsat
+    12, // llvm.hexagon.V6.vsubwsat.128B
+    12, // llvm.hexagon.V6.vsubwsat.dv
+    12, // llvm.hexagon.V6.vsubwsat.dv.128B
+    12, // llvm.hexagon.V6.vswap
+    12, // llvm.hexagon.V6.vswap.128B
+    12, // llvm.hexagon.V6.vtmpyb
+    12, // llvm.hexagon.V6.vtmpyb.128B
+    12, // llvm.hexagon.V6.vtmpyb.acc
+    12, // llvm.hexagon.V6.vtmpyb.acc.128B
+    12, // llvm.hexagon.V6.vtmpybus
+    12, // llvm.hexagon.V6.vtmpybus.128B
+    12, // llvm.hexagon.V6.vtmpybus.acc
+    12, // llvm.hexagon.V6.vtmpybus.acc.128B
+    12, // llvm.hexagon.V6.vtmpyhb
+    12, // llvm.hexagon.V6.vtmpyhb.128B
+    12, // llvm.hexagon.V6.vtmpyhb.acc
+    12, // llvm.hexagon.V6.vtmpyhb.acc.128B
+    12, // llvm.hexagon.V6.vunpackb
+    12, // llvm.hexagon.V6.vunpackb.128B
+    12, // llvm.hexagon.V6.vunpackh
+    12, // llvm.hexagon.V6.vunpackh.128B
+    12, // llvm.hexagon.V6.vunpackob
+    12, // llvm.hexagon.V6.vunpackob.128B
+    12, // llvm.hexagon.V6.vunpackoh
+    12, // llvm.hexagon.V6.vunpackoh.128B
+    12, // llvm.hexagon.V6.vunpackub
+    12, // llvm.hexagon.V6.vunpackub.128B
+    12, // llvm.hexagon.V6.vunpackuh
+    12, // llvm.hexagon.V6.vunpackuh.128B
+    12, // llvm.hexagon.V6.vxor
+    12, // llvm.hexagon.V6.vxor.128B
+    12, // llvm.hexagon.V6.vzb
+    12, // llvm.hexagon.V6.vzb.128B
+    12, // llvm.hexagon.V6.vzh
+    12, // llvm.hexagon.V6.vzh.128B
+    7, // llvm.hexagon.Y2.dccleana
+    7, // llvm.hexagon.Y2.dccleaninva
+    7, // llvm.hexagon.Y2.dcfetch
+    7, // llvm.hexagon.Y2.dcinva
+    7, // llvm.hexagon.Y2.dczeroa
+    7, // llvm.hexagon.Y4.l2fetch
+    7, // llvm.hexagon.Y5.l2fetch
+    183, // llvm.hexagon.circ.ldb
+    183, // llvm.hexagon.circ.ldd
+    183, // llvm.hexagon.circ.ldh
+    183, // llvm.hexagon.circ.ldub
+    183, // llvm.hexagon.circ.lduh
+    183, // llvm.hexagon.circ.ldw
+    184, // llvm.hexagon.circ.stb
+    184, // llvm.hexagon.circ.std
+    184, // llvm.hexagon.circ.sth
+    184, // llvm.hexagon.circ.sthhi
+    184, // llvm.hexagon.circ.stw
+    7, // llvm.hexagon.prefetch
+    185, // llvm.hexagon.vmemcpy
+    186, // llvm.hexagon.vmemset
+    7, // llvm.mips.absq.s.ph
+    7, // llvm.mips.absq.s.qb
+    7, // llvm.mips.absq.s.w
+    12, // llvm.mips.add.a.b
+    12, // llvm.mips.add.a.d
+    12, // llvm.mips.add.a.h
+    12, // llvm.mips.add.a.w
+    12, // llvm.mips.addq.ph
+    12, // llvm.mips.addq.s.ph
+    7, // llvm.mips.addq.s.w
+    12, // llvm.mips.addqh.ph
+    12, // llvm.mips.addqh.r.ph
+    12, // llvm.mips.addqh.r.w
+    12, // llvm.mips.addqh.w
+    12, // llvm.mips.adds.a.b
+    12, // llvm.mips.adds.a.d
+    12, // llvm.mips.adds.a.h
+    12, // llvm.mips.adds.a.w
+    12, // llvm.mips.adds.s.b
+    12, // llvm.mips.adds.s.d
+    12, // llvm.mips.adds.s.h
+    12, // llvm.mips.adds.s.w
+    12, // llvm.mips.adds.u.b
+    12, // llvm.mips.adds.u.d
+    12, // llvm.mips.adds.u.h
+    12, // llvm.mips.adds.u.w
+    7, // llvm.mips.addsc
+    7, // llvm.mips.addu.ph
+    12, // llvm.mips.addu.qb
+    7, // llvm.mips.addu.s.ph
+    12, // llvm.mips.addu.s.qb
+    12, // llvm.mips.adduh.qb
+    12, // llvm.mips.adduh.r.qb
+    12, // llvm.mips.addv.b
+    12, // llvm.mips.addv.d
+    12, // llvm.mips.addv.h
+    12, // llvm.mips.addv.w
+    78, // llvm.mips.addvi.b
+    78, // llvm.mips.addvi.d
+    78, // llvm.mips.addvi.h
+    78, // llvm.mips.addvi.w
+    7, // llvm.mips.addwc
+    12, // llvm.mips.and.v
+    78, // llvm.mips.andi.b
+    70, // llvm.mips.append
+    12, // llvm.mips.asub.s.b
+    12, // llvm.mips.asub.s.d
+    12, // llvm.mips.asub.s.h
+    12, // llvm.mips.asub.s.w
+    12, // llvm.mips.asub.u.b
+    12, // llvm.mips.asub.u.d
+    12, // llvm.mips.asub.u.h
+    12, // llvm.mips.asub.u.w
+    12, // llvm.mips.ave.s.b
+    12, // llvm.mips.ave.s.d
+    12, // llvm.mips.ave.s.h
+    12, // llvm.mips.ave.s.w
+    12, // llvm.mips.ave.u.b
+    12, // llvm.mips.ave.u.d
+    12, // llvm.mips.ave.u.h
+    12, // llvm.mips.ave.u.w
+    12, // llvm.mips.aver.s.b
+    12, // llvm.mips.aver.s.d
+    12, // llvm.mips.aver.s.h
+    12, // llvm.mips.aver.s.w
+    12, // llvm.mips.aver.u.b
+    12, // llvm.mips.aver.u.d
+    12, // llvm.mips.aver.u.h
+    12, // llvm.mips.aver.u.w
+    70, // llvm.mips.balign
+    12, // llvm.mips.bclr.b
+    12, // llvm.mips.bclr.d
+    12, // llvm.mips.bclr.h
+    12, // llvm.mips.bclr.w
+    78, // llvm.mips.bclri.b
+    78, // llvm.mips.bclri.d
+    78, // llvm.mips.bclri.h
+    78, // llvm.mips.bclri.w
+    12, // llvm.mips.binsl.b
+    12, // llvm.mips.binsl.d
+    12, // llvm.mips.binsl.h
+    12, // llvm.mips.binsl.w
+    70, // llvm.mips.binsli.b
+    70, // llvm.mips.binsli.d
+    70, // llvm.mips.binsli.h
+    70, // llvm.mips.binsli.w
+    12, // llvm.mips.binsr.b
+    12, // llvm.mips.binsr.d
+    12, // llvm.mips.binsr.h
+    12, // llvm.mips.binsr.w
+    70, // llvm.mips.binsri.b
+    70, // llvm.mips.binsri.d
+    70, // llvm.mips.binsri.h
+    70, // llvm.mips.binsri.w
+    12, // llvm.mips.bitrev
+    12, // llvm.mips.bmnz.v
+    70, // llvm.mips.bmnzi.b
+    12, // llvm.mips.bmz.v
+    70, // llvm.mips.bmzi.b
+    12, // llvm.mips.bneg.b
+    12, // llvm.mips.bneg.d
+    12, // llvm.mips.bneg.h
+    12, // llvm.mips.bneg.w
+    78, // llvm.mips.bnegi.b
+    78, // llvm.mips.bnegi.d
+    78, // llvm.mips.bnegi.h
+    78, // llvm.mips.bnegi.w
+    12, // llvm.mips.bnz.b
+    12, // llvm.mips.bnz.d
+    12, // llvm.mips.bnz.h
+    12, // llvm.mips.bnz.v
+    12, // llvm.mips.bnz.w
+    21, // llvm.mips.bposge32
+    12, // llvm.mips.bsel.v
+    70, // llvm.mips.bseli.b
+    12, // llvm.mips.bset.b
+    12, // llvm.mips.bset.d
+    12, // llvm.mips.bset.h
+    12, // llvm.mips.bset.w
+    78, // llvm.mips.bseti.b
+    78, // llvm.mips.bseti.d
+    78, // llvm.mips.bseti.h
+    78, // llvm.mips.bseti.w
+    12, // llvm.mips.bz.b
+    12, // llvm.mips.bz.d
+    12, // llvm.mips.bz.h
+    12, // llvm.mips.bz.v
+    12, // llvm.mips.bz.w
+    12, // llvm.mips.ceq.b
+    12, // llvm.mips.ceq.d
+    12, // llvm.mips.ceq.h
+    12, // llvm.mips.ceq.w
+    78, // llvm.mips.ceqi.b
+    78, // llvm.mips.ceqi.d
+    78, // llvm.mips.ceqi.h
+    78, // llvm.mips.ceqi.w
+    83, // llvm.mips.cfcmsa
+    12, // llvm.mips.cle.s.b
+    12, // llvm.mips.cle.s.d
+    12, // llvm.mips.cle.s.h
+    12, // llvm.mips.cle.s.w
+    12, // llvm.mips.cle.u.b
+    12, // llvm.mips.cle.u.d
+    12, // llvm.mips.cle.u.h
+    12, // llvm.mips.cle.u.w
+    78, // llvm.mips.clei.s.b
+    78, // llvm.mips.clei.s.d
+    78, // llvm.mips.clei.s.h
+    78, // llvm.mips.clei.s.w
+    78, // llvm.mips.clei.u.b
+    78, // llvm.mips.clei.u.d
+    78, // llvm.mips.clei.u.h
+    78, // llvm.mips.clei.u.w
+    12, // llvm.mips.clt.s.b
+    12, // llvm.mips.clt.s.d
+    12, // llvm.mips.clt.s.h
+    12, // llvm.mips.clt.s.w
+    12, // llvm.mips.clt.u.b
+    12, // llvm.mips.clt.u.d
+    12, // llvm.mips.clt.u.h
+    12, // llvm.mips.clt.u.w
+    78, // llvm.mips.clti.s.b
+    78, // llvm.mips.clti.s.d
+    78, // llvm.mips.clti.s.h
+    78, // llvm.mips.clti.s.w
+    78, // llvm.mips.clti.u.b
+    78, // llvm.mips.clti.u.d
+    78, // llvm.mips.clti.u.h
+    78, // llvm.mips.clti.u.w
+    7, // llvm.mips.cmp.eq.ph
+    7, // llvm.mips.cmp.le.ph
+    7, // llvm.mips.cmp.lt.ph
+    7, // llvm.mips.cmpgdu.eq.qb
+    7, // llvm.mips.cmpgdu.le.qb
+    7, // llvm.mips.cmpgdu.lt.qb
+    7, // llvm.mips.cmpgu.eq.qb
+    7, // llvm.mips.cmpgu.le.qb
+    7, // llvm.mips.cmpgu.lt.qb
+    7, // llvm.mips.cmpu.eq.qb
+    7, // llvm.mips.cmpu.le.qb
+    7, // llvm.mips.cmpu.lt.qb
+    12, // llvm.mips.copy.s.b
+    12, // llvm.mips.copy.s.d
+    12, // llvm.mips.copy.s.h
+    12, // llvm.mips.copy.s.w
+    12, // llvm.mips.copy.u.b
+    12, // llvm.mips.copy.u.d
+    12, // llvm.mips.copy.u.h
+    12, // llvm.mips.copy.u.w
+    83, // llvm.mips.ctcmsa
+    12, // llvm.mips.div.s.b
+    12, // llvm.mips.div.s.d
+    12, // llvm.mips.div.s.h
+    12, // llvm.mips.div.s.w
+    12, // llvm.mips.div.u.b
+    12, // llvm.mips.div.u.d
+    12, // llvm.mips.div.u.h
+    12, // llvm.mips.div.u.w
+    12, // llvm.mips.dlsa
+    12, // llvm.mips.dotp.s.d
+    12, // llvm.mips.dotp.s.h
+    12, // llvm.mips.dotp.s.w
+    12, // llvm.mips.dotp.u.d
+    12, // llvm.mips.dotp.u.h
+    12, // llvm.mips.dotp.u.w
+    12, // llvm.mips.dpa.w.ph
+    12, // llvm.mips.dpadd.s.d
+    12, // llvm.mips.dpadd.s.h
+    12, // llvm.mips.dpadd.s.w
+    12, // llvm.mips.dpadd.u.d
+    12, // llvm.mips.dpadd.u.h
+    12, // llvm.mips.dpadd.u.w
+    7, // llvm.mips.dpaq.s.w.ph
+    7, // llvm.mips.dpaq.sa.l.w
+    7, // llvm.mips.dpaqx.s.w.ph
+    7, // llvm.mips.dpaqx.sa.w.ph
+    12, // llvm.mips.dpau.h.qbl
+    12, // llvm.mips.dpau.h.qbr
+    12, // llvm.mips.dpax.w.ph
+    12, // llvm.mips.dps.w.ph
+    7, // llvm.mips.dpsq.s.w.ph
+    7, // llvm.mips.dpsq.sa.l.w
+    7, // llvm.mips.dpsqx.s.w.ph
+    7, // llvm.mips.dpsqx.sa.w.ph
+    12, // llvm.mips.dpsu.h.qbl
+    12, // llvm.mips.dpsu.h.qbr
+    12, // llvm.mips.dpsub.s.d
+    12, // llvm.mips.dpsub.s.h
+    12, // llvm.mips.dpsub.s.w
+    12, // llvm.mips.dpsub.u.d
+    12, // llvm.mips.dpsub.u.h
+    12, // llvm.mips.dpsub.u.w
+    12, // llvm.mips.dpsx.w.ph
+    7, // llvm.mips.extp
+    7, // llvm.mips.extpdp
+    7, // llvm.mips.extr.r.w
+    7, // llvm.mips.extr.rs.w
+    7, // llvm.mips.extr.s.h
+    7, // llvm.mips.extr.w
+    12, // llvm.mips.fadd.d
+    12, // llvm.mips.fadd.w
+    12, // llvm.mips.fcaf.d
+    12, // llvm.mips.fcaf.w
+    12, // llvm.mips.fceq.d
+    12, // llvm.mips.fceq.w
+    12, // llvm.mips.fclass.d
+    12, // llvm.mips.fclass.w
+    12, // llvm.mips.fcle.d
+    12, // llvm.mips.fcle.w
+    12, // llvm.mips.fclt.d
+    12, // llvm.mips.fclt.w
+    12, // llvm.mips.fcne.d
+    12, // llvm.mips.fcne.w
+    12, // llvm.mips.fcor.d
+    12, // llvm.mips.fcor.w
+    12, // llvm.mips.fcueq.d
+    12, // llvm.mips.fcueq.w
+    12, // llvm.mips.fcule.d
+    12, // llvm.mips.fcule.w
+    12, // llvm.mips.fcult.d
+    12, // llvm.mips.fcult.w
+    12, // llvm.mips.fcun.d
+    12, // llvm.mips.fcun.w
+    12, // llvm.mips.fcune.d
+    12, // llvm.mips.fcune.w
+    12, // llvm.mips.fdiv.d
+    12, // llvm.mips.fdiv.w
+    12, // llvm.mips.fexdo.h
+    12, // llvm.mips.fexdo.w
+    12, // llvm.mips.fexp2.d
+    12, // llvm.mips.fexp2.w
+    12, // llvm.mips.fexupl.d
+    12, // llvm.mips.fexupl.w
+    12, // llvm.mips.fexupr.d
+    12, // llvm.mips.fexupr.w
+    12, // llvm.mips.ffint.s.d
+    12, // llvm.mips.ffint.s.w
+    12, // llvm.mips.ffint.u.d
+    12, // llvm.mips.ffint.u.w
+    12, // llvm.mips.ffql.d
+    12, // llvm.mips.ffql.w
+    12, // llvm.mips.ffqr.d
+    12, // llvm.mips.ffqr.w
+    12, // llvm.mips.fill.b
+    12, // llvm.mips.fill.d
+    12, // llvm.mips.fill.h
+    12, // llvm.mips.fill.w
+    12, // llvm.mips.flog2.d
+    12, // llvm.mips.flog2.w
+    12, // llvm.mips.fmadd.d
+    12, // llvm.mips.fmadd.w
+    12, // llvm.mips.fmax.a.d
+    12, // llvm.mips.fmax.a.w
+    12, // llvm.mips.fmax.d
+    12, // llvm.mips.fmax.w
+    12, // llvm.mips.fmin.a.d
+    12, // llvm.mips.fmin.a.w
+    12, // llvm.mips.fmin.d
+    12, // llvm.mips.fmin.w
+    12, // llvm.mips.fmsub.d
+    12, // llvm.mips.fmsub.w
+    12, // llvm.mips.fmul.d
+    12, // llvm.mips.fmul.w
+    12, // llvm.mips.frcp.d
+    12, // llvm.mips.frcp.w
+    12, // llvm.mips.frint.d
+    12, // llvm.mips.frint.w
+    12, // llvm.mips.frsqrt.d
+    12, // llvm.mips.frsqrt.w
+    12, // llvm.mips.fsaf.d
+    12, // llvm.mips.fsaf.w
+    12, // llvm.mips.fseq.d
+    12, // llvm.mips.fseq.w
+    12, // llvm.mips.fsle.d
+    12, // llvm.mips.fsle.w
+    12, // llvm.mips.fslt.d
+    12, // llvm.mips.fslt.w
+    12, // llvm.mips.fsne.d
+    12, // llvm.mips.fsne.w
+    12, // llvm.mips.fsor.d
+    12, // llvm.mips.fsor.w
+    12, // llvm.mips.fsqrt.d
+    12, // llvm.mips.fsqrt.w
+    12, // llvm.mips.fsub.d
+    12, // llvm.mips.fsub.w
+    12, // llvm.mips.fsueq.d
+    12, // llvm.mips.fsueq.w
+    12, // llvm.mips.fsule.d
+    12, // llvm.mips.fsule.w
+    12, // llvm.mips.fsult.d
+    12, // llvm.mips.fsult.w
+    12, // llvm.mips.fsun.d
+    12, // llvm.mips.fsun.w
+    12, // llvm.mips.fsune.d
+    12, // llvm.mips.fsune.w
+    12, // llvm.mips.ftint.s.d
+    12, // llvm.mips.ftint.s.w
+    12, // llvm.mips.ftint.u.d
+    12, // llvm.mips.ftint.u.w
+    12, // llvm.mips.ftq.h
+    12, // llvm.mips.ftq.w
+    12, // llvm.mips.ftrunc.s.d
+    12, // llvm.mips.ftrunc.s.w
+    12, // llvm.mips.ftrunc.u.d
+    12, // llvm.mips.ftrunc.u.w
+    12, // llvm.mips.hadd.s.d
+    12, // llvm.mips.hadd.s.h
+    12, // llvm.mips.hadd.s.w
+    12, // llvm.mips.hadd.u.d
+    12, // llvm.mips.hadd.u.h
+    12, // llvm.mips.hadd.u.w
+    12, // llvm.mips.hsub.s.d
+    12, // llvm.mips.hsub.s.h
+    12, // llvm.mips.hsub.s.w
+    12, // llvm.mips.hsub.u.d
+    12, // llvm.mips.hsub.u.h
+    12, // llvm.mips.hsub.u.w
+    12, // llvm.mips.ilvev.b
+    12, // llvm.mips.ilvev.d
+    12, // llvm.mips.ilvev.h
+    12, // llvm.mips.ilvev.w
+    12, // llvm.mips.ilvl.b
+    12, // llvm.mips.ilvl.d
+    12, // llvm.mips.ilvl.h
+    12, // llvm.mips.ilvl.w
+    12, // llvm.mips.ilvod.b
+    12, // llvm.mips.ilvod.d
+    12, // llvm.mips.ilvod.h
+    12, // llvm.mips.ilvod.w
+    12, // llvm.mips.ilvr.b
+    12, // llvm.mips.ilvr.d
+    12, // llvm.mips.ilvr.h
+    12, // llvm.mips.ilvr.w
+    12, // llvm.mips.insert.b
+    12, // llvm.mips.insert.d
+    12, // llvm.mips.insert.h
+    12, // llvm.mips.insert.w
+    21, // llvm.mips.insv
+    78, // llvm.mips.insve.b
+    78, // llvm.mips.insve.d
+    78, // llvm.mips.insve.h
+    78, // llvm.mips.insve.w
+    3, // llvm.mips.lbux
+    3, // llvm.mips.ld.b
+    3, // llvm.mips.ld.d
+    3, // llvm.mips.ld.h
+    3, // llvm.mips.ld.w
+    73, // llvm.mips.ldi.b
+    73, // llvm.mips.ldi.d
+    73, // llvm.mips.ldi.h
+    73, // llvm.mips.ldi.w
+    3, // llvm.mips.ldr.d
+    3, // llvm.mips.ldr.w
+    3, // llvm.mips.lhx
+    12, // llvm.mips.lsa
+    3, // llvm.mips.lwx
+    12, // llvm.mips.madd
+    12, // llvm.mips.madd.q.h
+    12, // llvm.mips.madd.q.w
+    12, // llvm.mips.maddr.q.h
+    12, // llvm.mips.maddr.q.w
+    12, // llvm.mips.maddu
+    12, // llvm.mips.maddv.b
+    12, // llvm.mips.maddv.d
+    12, // llvm.mips.maddv.h
+    12, // llvm.mips.maddv.w
+    7, // llvm.mips.maq.s.w.phl
+    7, // llvm.mips.maq.s.w.phr
+    7, // llvm.mips.maq.sa.w.phl
+    7, // llvm.mips.maq.sa.w.phr
+    12, // llvm.mips.max.a.b
+    12, // llvm.mips.max.a.d
+    12, // llvm.mips.max.a.h
+    12, // llvm.mips.max.a.w
+    12, // llvm.mips.max.s.b
+    12, // llvm.mips.max.s.d
+    12, // llvm.mips.max.s.h
+    12, // llvm.mips.max.s.w
+    12, // llvm.mips.max.u.b
+    12, // llvm.mips.max.u.d
+    12, // llvm.mips.max.u.h
+    12, // llvm.mips.max.u.w
+    78, // llvm.mips.maxi.s.b
+    78, // llvm.mips.maxi.s.d
+    78, // llvm.mips.maxi.s.h
+    78, // llvm.mips.maxi.s.w
+    78, // llvm.mips.maxi.u.b
+    78, // llvm.mips.maxi.u.d
+    78, // llvm.mips.maxi.u.h
+    78, // llvm.mips.maxi.u.w
+    12, // llvm.mips.min.a.b
+    12, // llvm.mips.min.a.d
+    12, // llvm.mips.min.a.h
+    12, // llvm.mips.min.a.w
+    12, // llvm.mips.min.s.b
+    12, // llvm.mips.min.s.d
+    12, // llvm.mips.min.s.h
+    12, // llvm.mips.min.s.w
+    12, // llvm.mips.min.u.b
+    12, // llvm.mips.min.u.d
+    12, // llvm.mips.min.u.h
+    12, // llvm.mips.min.u.w
+    78, // llvm.mips.mini.s.b
+    78, // llvm.mips.mini.s.d
+    78, // llvm.mips.mini.s.h
+    78, // llvm.mips.mini.s.w
+    78, // llvm.mips.mini.u.b
+    78, // llvm.mips.mini.u.d
+    78, // llvm.mips.mini.u.h
+    78, // llvm.mips.mini.u.w
+    12, // llvm.mips.mod.s.b
+    12, // llvm.mips.mod.s.d
+    12, // llvm.mips.mod.s.h
+    12, // llvm.mips.mod.s.w
+    12, // llvm.mips.mod.u.b
+    12, // llvm.mips.mod.u.d
+    12, // llvm.mips.mod.u.h
+    12, // llvm.mips.mod.u.w
+    12, // llvm.mips.modsub
+    12, // llvm.mips.move.v
+    12, // llvm.mips.msub
+    12, // llvm.mips.msub.q.h
+    12, // llvm.mips.msub.q.w
+    12, // llvm.mips.msubr.q.h
+    12, // llvm.mips.msubr.q.w
+    12, // llvm.mips.msubu
+    12, // llvm.mips.msubv.b
+    12, // llvm.mips.msubv.d
+    12, // llvm.mips.msubv.h
+    12, // llvm.mips.msubv.w
+    7, // llvm.mips.mthlip
+    7, // llvm.mips.mul.ph
+    12, // llvm.mips.mul.q.h
+    12, // llvm.mips.mul.q.w
+    7, // llvm.mips.mul.s.ph
+    7, // llvm.mips.muleq.s.w.phl
+    7, // llvm.mips.muleq.s.w.phr
+    7, // llvm.mips.muleu.s.ph.qbl
+    7, // llvm.mips.muleu.s.ph.qbr
+    7, // llvm.mips.mulq.rs.ph
+    7, // llvm.mips.mulq.rs.w
+    7, // llvm.mips.mulq.s.ph
+    7, // llvm.mips.mulq.s.w
+    12, // llvm.mips.mulr.q.h
+    12, // llvm.mips.mulr.q.w
+    12, // llvm.mips.mulsa.w.ph
+    7, // llvm.mips.mulsaq.s.w.ph
+    12, // llvm.mips.mult
+    12, // llvm.mips.multu
+    12, // llvm.mips.mulv.b
+    12, // llvm.mips.mulv.d
+    12, // llvm.mips.mulv.h
+    12, // llvm.mips.mulv.w
+    12, // llvm.mips.nloc.b
+    12, // llvm.mips.nloc.d
+    12, // llvm.mips.nloc.h
+    12, // llvm.mips.nloc.w
+    12, // llvm.mips.nlzc.b
+    12, // llvm.mips.nlzc.d
+    12, // llvm.mips.nlzc.h
+    12, // llvm.mips.nlzc.w
+    12, // llvm.mips.nor.v
+    78, // llvm.mips.nori.b
+    12, // llvm.mips.or.v
+    78, // llvm.mips.ori.b
+    12, // llvm.mips.packrl.ph
+    12, // llvm.mips.pckev.b
+    12, // llvm.mips.pckev.d
+    12, // llvm.mips.pckev.h
+    12, // llvm.mips.pckev.w
+    12, // llvm.mips.pckod.b
+    12, // llvm.mips.pckod.d
+    12, // llvm.mips.pckod.h
+    12, // llvm.mips.pckod.w
+    12, // llvm.mips.pcnt.b
+    12, // llvm.mips.pcnt.d
+    12, // llvm.mips.pcnt.h
+    12, // llvm.mips.pcnt.w
+    21, // llvm.mips.pick.ph
+    21, // llvm.mips.pick.qb
+    12, // llvm.mips.preceq.w.phl
+    12, // llvm.mips.preceq.w.phr
+    12, // llvm.mips.precequ.ph.qbl
+    12, // llvm.mips.precequ.ph.qbla
+    12, // llvm.mips.precequ.ph.qbr
+    12, // llvm.mips.precequ.ph.qbra
+    12, // llvm.mips.preceu.ph.qbl
+    12, // llvm.mips.preceu.ph.qbla
+    12, // llvm.mips.preceu.ph.qbr
+    12, // llvm.mips.preceu.ph.qbra
+    7, // llvm.mips.precr.qb.ph
+    70, // llvm.mips.precr.sra.ph.w
+    70, // llvm.mips.precr.sra.r.ph.w
+    12, // llvm.mips.precrq.ph.w
+    12, // llvm.mips.precrq.qb.ph
+    7, // llvm.mips.precrq.rs.ph.w
+    7, // llvm.mips.precrqu.s.qb.ph
+    70, // llvm.mips.prepend
+    12, // llvm.mips.raddu.w.qb
+    187, // llvm.mips.rddsp
+    12, // llvm.mips.repl.ph
+    12, // llvm.mips.repl.qb
+    78, // llvm.mips.sat.s.b
+    78, // llvm.mips.sat.s.d
+    78, // llvm.mips.sat.s.h
+    78, // llvm.mips.sat.s.w
+    78, // llvm.mips.sat.u.b
+    78, // llvm.mips.sat.u.d
+    78, // llvm.mips.sat.u.h
+    78, // llvm.mips.sat.u.w
+    78, // llvm.mips.shf.b
+    78, // llvm.mips.shf.h
+    78, // llvm.mips.shf.w
+    12, // llvm.mips.shilo
+    7, // llvm.mips.shll.ph
+    7, // llvm.mips.shll.qb
+    7, // llvm.mips.shll.s.ph
+    7, // llvm.mips.shll.s.w
+    12, // llvm.mips.shra.ph
+    12, // llvm.mips.shra.qb
+    12, // llvm.mips.shra.r.ph
+    12, // llvm.mips.shra.r.qb
+    12, // llvm.mips.shra.r.w
+    12, // llvm.mips.shrl.ph
+    12, // llvm.mips.shrl.qb
+    12, // llvm.mips.sld.b
+    12, // llvm.mips.sld.d
+    12, // llvm.mips.sld.h
+    12, // llvm.mips.sld.w
+    70, // llvm.mips.sldi.b
+    70, // llvm.mips.sldi.d
+    70, // llvm.mips.sldi.h
+    70, // llvm.mips.sldi.w
+    12, // llvm.mips.sll.b
+    12, // llvm.mips.sll.d
+    12, // llvm.mips.sll.h
+    12, // llvm.mips.sll.w
+    78, // llvm.mips.slli.b
+    78, // llvm.mips.slli.d
+    78, // llvm.mips.slli.h
+    78, // llvm.mips.slli.w
+    12, // llvm.mips.splat.b
+    12, // llvm.mips.splat.d
+    12, // llvm.mips.splat.h
+    12, // llvm.mips.splat.w
+    78, // llvm.mips.splati.b
+    78, // llvm.mips.splati.d
+    78, // llvm.mips.splati.h
+    78, // llvm.mips.splati.w
+    12, // llvm.mips.sra.b
+    12, // llvm.mips.sra.d
+    12, // llvm.mips.sra.h
+    12, // llvm.mips.sra.w
+    78, // llvm.mips.srai.b
+    78, // llvm.mips.srai.d
+    78, // llvm.mips.srai.h
+    78, // llvm.mips.srai.w
+    12, // llvm.mips.srar.b
+    12, // llvm.mips.srar.d
+    12, // llvm.mips.srar.h
+    12, // llvm.mips.srar.w
+    78, // llvm.mips.srari.b
+    78, // llvm.mips.srari.d
+    78, // llvm.mips.srari.h
+    78, // llvm.mips.srari.w
+    12, // llvm.mips.srl.b
+    12, // llvm.mips.srl.d
+    12, // llvm.mips.srl.h
+    12, // llvm.mips.srl.w
+    78, // llvm.mips.srli.b
+    78, // llvm.mips.srli.d
+    78, // llvm.mips.srli.h
+    78, // llvm.mips.srli.w
+    12, // llvm.mips.srlr.b
+    12, // llvm.mips.srlr.d
+    12, // llvm.mips.srlr.h
+    12, // llvm.mips.srlr.w
+    78, // llvm.mips.srlri.b
+    78, // llvm.mips.srlri.d
+    78, // llvm.mips.srlri.h
+    78, // llvm.mips.srlri.w
+    178, // llvm.mips.st.b
+    178, // llvm.mips.st.d
+    178, // llvm.mips.st.h
+    178, // llvm.mips.st.w
+    178, // llvm.mips.str.d
+    178, // llvm.mips.str.w
+    12, // llvm.mips.subq.ph
+    12, // llvm.mips.subq.s.ph
+    7, // llvm.mips.subq.s.w
+    12, // llvm.mips.subqh.ph
+    12, // llvm.mips.subqh.r.ph
+    12, // llvm.mips.subqh.r.w
+    12, // llvm.mips.subqh.w
+    12, // llvm.mips.subs.s.b
+    12, // llvm.mips.subs.s.d
+    12, // llvm.mips.subs.s.h
+    12, // llvm.mips.subs.s.w
+    12, // llvm.mips.subs.u.b
+    12, // llvm.mips.subs.u.d
+    12, // llvm.mips.subs.u.h
+    12, // llvm.mips.subs.u.w
+    12, // llvm.mips.subsus.u.b
+    12, // llvm.mips.subsus.u.d
+    12, // llvm.mips.subsus.u.h
+    12, // llvm.mips.subsus.u.w
+    12, // llvm.mips.subsuu.s.b
+    12, // llvm.mips.subsuu.s.d
+    12, // llvm.mips.subsuu.s.h
+    12, // llvm.mips.subsuu.s.w
+    7, // llvm.mips.subu.ph
+    12, // llvm.mips.subu.qb
+    7, // llvm.mips.subu.s.ph
+    12, // llvm.mips.subu.s.qb
+    12, // llvm.mips.subuh.qb
+    12, // llvm.mips.subuh.r.qb
+    12, // llvm.mips.subv.b
+    12, // llvm.mips.subv.d
+    12, // llvm.mips.subv.h
+    12, // llvm.mips.subv.w
+    78, // llvm.mips.subvi.b
+    78, // llvm.mips.subvi.d
+    78, // llvm.mips.subvi.h
+    78, // llvm.mips.subvi.w
+    12, // llvm.mips.vshf.b
+    12, // llvm.mips.vshf.d
+    12, // llvm.mips.vshf.h
+    12, // llvm.mips.vshf.w
+    188, // llvm.mips.wrdsp
+    12, // llvm.mips.xor.v
+    78, // llvm.mips.xori.b
+    12, // llvm.nvvm.add.rm.d
+    12, // llvm.nvvm.add.rm.f
+    12, // llvm.nvvm.add.rm.ftz.f
+    12, // llvm.nvvm.add.rn.d
+    12, // llvm.nvvm.add.rn.f
+    12, // llvm.nvvm.add.rn.ftz.f
+    12, // llvm.nvvm.add.rp.d
+    12, // llvm.nvvm.add.rp.f
+    12, // llvm.nvvm.add.rp.ftz.f
+    12, // llvm.nvvm.add.rz.d
+    12, // llvm.nvvm.add.rz.f
+    12, // llvm.nvvm.add.rz.ftz.f
+    30, // llvm.nvvm.atomic.add.gen.f.cta
+    30, // llvm.nvvm.atomic.add.gen.f.sys
+    30, // llvm.nvvm.atomic.add.gen.i.cta
+    30, // llvm.nvvm.atomic.add.gen.i.sys
+    30, // llvm.nvvm.atomic.and.gen.i.cta
+    30, // llvm.nvvm.atomic.and.gen.i.sys
+    30, // llvm.nvvm.atomic.cas.gen.i.cta
+    30, // llvm.nvvm.atomic.cas.gen.i.sys
+    30, // llvm.nvvm.atomic.dec.gen.i.cta
+    30, // llvm.nvvm.atomic.dec.gen.i.sys
+    30, // llvm.nvvm.atomic.exch.gen.i.cta
+    30, // llvm.nvvm.atomic.exch.gen.i.sys
+    30, // llvm.nvvm.atomic.inc.gen.i.cta
+    30, // llvm.nvvm.atomic.inc.gen.i.sys
+    30, // llvm.nvvm.atomic.load.dec.32
+    30, // llvm.nvvm.atomic.load.inc.32
+    30, // llvm.nvvm.atomic.max.gen.i.cta
+    30, // llvm.nvvm.atomic.max.gen.i.sys
+    30, // llvm.nvvm.atomic.min.gen.i.cta
+    30, // llvm.nvvm.atomic.min.gen.i.sys
+    30, // llvm.nvvm.atomic.or.gen.i.cta
+    30, // llvm.nvvm.atomic.or.gen.i.sys
+    30, // llvm.nvvm.atomic.xor.gen.i.cta
+    30, // llvm.nvvm.atomic.xor.gen.i.sys
+    164, // llvm.nvvm.bar.sync
+    164, // llvm.nvvm.bar.warp.sync
+    164, // llvm.nvvm.barrier
+    164, // llvm.nvvm.barrier.n
+    164, // llvm.nvvm.barrier.sync
+    164, // llvm.nvvm.barrier.sync.cnt
+    164, // llvm.nvvm.barrier0
+    164, // llvm.nvvm.barrier0.and
+    164, // llvm.nvvm.barrier0.or
+    164, // llvm.nvvm.barrier0.popc
+    12, // llvm.nvvm.bitcast.d2ll
+    12, // llvm.nvvm.bitcast.f2i
+    12, // llvm.nvvm.bitcast.i2f
+    12, // llvm.nvvm.bitcast.ll2d
+    12, // llvm.nvvm.ceil.d
+    12, // llvm.nvvm.ceil.f
+    12, // llvm.nvvm.ceil.ftz.f
+    7, // llvm.nvvm.compiler.error
+    7, // llvm.nvvm.compiler.warn
+    12, // llvm.nvvm.cos.approx.f
+    12, // llvm.nvvm.cos.approx.ftz.f
+    12, // llvm.nvvm.d2f.rm
+    12, // llvm.nvvm.d2f.rm.ftz
+    12, // llvm.nvvm.d2f.rn
+    12, // llvm.nvvm.d2f.rn.ftz
+    12, // llvm.nvvm.d2f.rp
+    12, // llvm.nvvm.d2f.rp.ftz
+    12, // llvm.nvvm.d2f.rz
+    12, // llvm.nvvm.d2f.rz.ftz
+    12, // llvm.nvvm.d2i.hi
+    12, // llvm.nvvm.d2i.lo
+    12, // llvm.nvvm.d2i.rm
+    12, // llvm.nvvm.d2i.rn
+    12, // llvm.nvvm.d2i.rp
+    12, // llvm.nvvm.d2i.rz
+    12, // llvm.nvvm.d2ll.rm
+    12, // llvm.nvvm.d2ll.rn
+    12, // llvm.nvvm.d2ll.rp
+    12, // llvm.nvvm.d2ll.rz
+    12, // llvm.nvvm.d2ui.rm
+    12, // llvm.nvvm.d2ui.rn
+    12, // llvm.nvvm.d2ui.rp
+    12, // llvm.nvvm.d2ui.rz
+    12, // llvm.nvvm.d2ull.rm
+    12, // llvm.nvvm.d2ull.rn
+    12, // llvm.nvvm.d2ull.rp
+    12, // llvm.nvvm.d2ull.rz
+    12, // llvm.nvvm.div.approx.f
+    12, // llvm.nvvm.div.approx.ftz.f
+    12, // llvm.nvvm.div.rm.d
+    12, // llvm.nvvm.div.rm.f
+    12, // llvm.nvvm.div.rm.ftz.f
+    12, // llvm.nvvm.div.rn.d
+    12, // llvm.nvvm.div.rn.f
+    12, // llvm.nvvm.div.rn.ftz.f
+    12, // llvm.nvvm.div.rp.d
+    12, // llvm.nvvm.div.rp.f
+    12, // llvm.nvvm.div.rp.ftz.f
+    12, // llvm.nvvm.div.rz.d
+    12, // llvm.nvvm.div.rz.f
+    12, // llvm.nvvm.div.rz.ftz.f
+    12, // llvm.nvvm.ex2.approx.d
+    12, // llvm.nvvm.ex2.approx.f
+    12, // llvm.nvvm.ex2.approx.ftz.f
+    12, // llvm.nvvm.f2h.rn
+    12, // llvm.nvvm.f2h.rn.ftz
+    12, // llvm.nvvm.f2i.rm
+    12, // llvm.nvvm.f2i.rm.ftz
+    12, // llvm.nvvm.f2i.rn
+    12, // llvm.nvvm.f2i.rn.ftz
+    12, // llvm.nvvm.f2i.rp
+    12, // llvm.nvvm.f2i.rp.ftz
+    12, // llvm.nvvm.f2i.rz
+    12, // llvm.nvvm.f2i.rz.ftz
+    12, // llvm.nvvm.f2ll.rm
+    12, // llvm.nvvm.f2ll.rm.ftz
+    12, // llvm.nvvm.f2ll.rn
+    12, // llvm.nvvm.f2ll.rn.ftz
+    12, // llvm.nvvm.f2ll.rp
+    12, // llvm.nvvm.f2ll.rp.ftz
+    12, // llvm.nvvm.f2ll.rz
+    12, // llvm.nvvm.f2ll.rz.ftz
+    12, // llvm.nvvm.f2ui.rm
+    12, // llvm.nvvm.f2ui.rm.ftz
+    12, // llvm.nvvm.f2ui.rn
+    12, // llvm.nvvm.f2ui.rn.ftz
+    12, // llvm.nvvm.f2ui.rp
+    12, // llvm.nvvm.f2ui.rp.ftz
+    12, // llvm.nvvm.f2ui.rz
+    12, // llvm.nvvm.f2ui.rz.ftz
+    12, // llvm.nvvm.f2ull.rm
+    12, // llvm.nvvm.f2ull.rm.ftz
+    12, // llvm.nvvm.f2ull.rn
+    12, // llvm.nvvm.f2ull.rn.ftz
+    12, // llvm.nvvm.f2ull.rp
+    12, // llvm.nvvm.f2ull.rp.ftz
+    12, // llvm.nvvm.f2ull.rz
+    12, // llvm.nvvm.f2ull.rz.ftz
+    12, // llvm.nvvm.fabs.d
+    12, // llvm.nvvm.fabs.f
+    12, // llvm.nvvm.fabs.ftz.f
+    12, // llvm.nvvm.floor.d
+    12, // llvm.nvvm.floor.f
+    12, // llvm.nvvm.floor.ftz.f
+    12, // llvm.nvvm.fma.rm.d
+    12, // llvm.nvvm.fma.rm.f
+    12, // llvm.nvvm.fma.rm.ftz.f
+    12, // llvm.nvvm.fma.rn.d
+    12, // llvm.nvvm.fma.rn.f
+    12, // llvm.nvvm.fma.rn.ftz.f
+    12, // llvm.nvvm.fma.rp.d
+    12, // llvm.nvvm.fma.rp.f
+    12, // llvm.nvvm.fma.rp.ftz.f
+    12, // llvm.nvvm.fma.rz.d
+    12, // llvm.nvvm.fma.rz.f
+    12, // llvm.nvvm.fma.rz.ftz.f
+    12, // llvm.nvvm.fmax.d
+    12, // llvm.nvvm.fmax.f
+    12, // llvm.nvvm.fmax.ftz.f
+    12, // llvm.nvvm.fmin.d
+    12, // llvm.nvvm.fmin.f
+    12, // llvm.nvvm.fmin.ftz.f
+    12, // llvm.nvvm.fns
+    12, // llvm.nvvm.i2d.rm
+    12, // llvm.nvvm.i2d.rn
+    12, // llvm.nvvm.i2d.rp
+    12, // llvm.nvvm.i2d.rz
+    12, // llvm.nvvm.i2f.rm
+    12, // llvm.nvvm.i2f.rn
+    12, // llvm.nvvm.i2f.rp
+    12, // llvm.nvvm.i2f.rz
+    12, // llvm.nvvm.isspacep.const
+    12, // llvm.nvvm.isspacep.global
+    12, // llvm.nvvm.isspacep.local
+    12, // llvm.nvvm.isspacep.shared
+    12, // llvm.nvvm.istypep.sampler
+    12, // llvm.nvvm.istypep.surface
+    12, // llvm.nvvm.istypep.texture
+    189, // llvm.nvvm.ldg.global.f
+    189, // llvm.nvvm.ldg.global.i
+    189, // llvm.nvvm.ldg.global.p
+    189, // llvm.nvvm.ldu.global.f
+    189, // llvm.nvvm.ldu.global.i
+    189, // llvm.nvvm.ldu.global.p
+    12, // llvm.nvvm.lg2.approx.d
+    12, // llvm.nvvm.lg2.approx.f
+    12, // llvm.nvvm.lg2.approx.ftz.f
+    12, // llvm.nvvm.ll2d.rm
+    12, // llvm.nvvm.ll2d.rn
+    12, // llvm.nvvm.ll2d.rp
+    12, // llvm.nvvm.ll2d.rz
+    12, // llvm.nvvm.ll2f.rm
+    12, // llvm.nvvm.ll2f.rn
+    12, // llvm.nvvm.ll2f.rp
+    12, // llvm.nvvm.ll2f.rz
+    12, // llvm.nvvm.lohi.i2d
+    190, // llvm.nvvm.match.all.sync.i32p
+    190, // llvm.nvvm.match.all.sync.i64p
+    190, // llvm.nvvm.match.any.sync.i32
+    190, // llvm.nvvm.match.any.sync.i64
+    7, // llvm.nvvm.membar.cta
+    7, // llvm.nvvm.membar.gl
+    7, // llvm.nvvm.membar.sys
+    12, // llvm.nvvm.mma.m8n8k4.col.col.f16.f16
+    12, // llvm.nvvm.mma.m8n8k4.col.col.f32.f16
+    12, // llvm.nvvm.mma.m8n8k4.col.col.f32.f32
+    12, // llvm.nvvm.mma.m8n8k4.col.row.f16.f16
+    12, // llvm.nvvm.mma.m8n8k4.col.row.f32.f16
+    12, // llvm.nvvm.mma.m8n8k4.col.row.f32.f32
+    12, // llvm.nvvm.mma.m8n8k4.row.col.f16.f16
+    12, // llvm.nvvm.mma.m8n8k4.row.col.f32.f16
+    12, // llvm.nvvm.mma.m8n8k4.row.col.f32.f32
+    12, // llvm.nvvm.mma.m8n8k4.row.row.f16.f16
+    12, // llvm.nvvm.mma.m8n8k4.row.row.f32.f16
+    12, // llvm.nvvm.mma.m8n8k4.row.row.f32.f32
+    12, // llvm.nvvm.move.double
+    12, // llvm.nvvm.move.float
+    12, // llvm.nvvm.move.i16
+    12, // llvm.nvvm.move.i32
+    12, // llvm.nvvm.move.i64
+    16, // llvm.nvvm.move.ptr
+    12, // llvm.nvvm.mul.rm.d
+    12, // llvm.nvvm.mul.rm.f
+    12, // llvm.nvvm.mul.rm.ftz.f
+    12, // llvm.nvvm.mul.rn.d
+    12, // llvm.nvvm.mul.rn.f
+    12, // llvm.nvvm.mul.rn.ftz.f
+    12, // llvm.nvvm.mul.rp.d
+    12, // llvm.nvvm.mul.rp.f
+    12, // llvm.nvvm.mul.rp.ftz.f
+    12, // llvm.nvvm.mul.rz.d
+    12, // llvm.nvvm.mul.rz.f
+    12, // llvm.nvvm.mul.rz.ftz.f
+    12, // llvm.nvvm.mul24.i
+    12, // llvm.nvvm.mul24.ui
+    12, // llvm.nvvm.mulhi.i
+    12, // llvm.nvvm.mulhi.ll
+    12, // llvm.nvvm.mulhi.ui
+    12, // llvm.nvvm.mulhi.ull
+    12, // llvm.nvvm.prmt
+    12, // llvm.nvvm.ptr.constant.to.gen
+    12, // llvm.nvvm.ptr.gen.to.constant
+    12, // llvm.nvvm.ptr.gen.to.global
+    12, // llvm.nvvm.ptr.gen.to.local
+    12, // llvm.nvvm.ptr.gen.to.param
+    12, // llvm.nvvm.ptr.gen.to.shared
+    12, // llvm.nvvm.ptr.global.to.gen
+    12, // llvm.nvvm.ptr.local.to.gen
+    12, // llvm.nvvm.ptr.shared.to.gen
+    12, // llvm.nvvm.rcp.approx.ftz.d
+    12, // llvm.nvvm.rcp.rm.d
+    12, // llvm.nvvm.rcp.rm.f
+    12, // llvm.nvvm.rcp.rm.ftz.f
+    12, // llvm.nvvm.rcp.rn.d
+    12, // llvm.nvvm.rcp.rn.f
+    12, // llvm.nvvm.rcp.rn.ftz.f
+    12, // llvm.nvvm.rcp.rp.d
+    12, // llvm.nvvm.rcp.rp.f
+    12, // llvm.nvvm.rcp.rp.ftz.f
+    12, // llvm.nvvm.rcp.rz.d
+    12, // llvm.nvvm.rcp.rz.f
+    12, // llvm.nvvm.rcp.rz.ftz.f
+    191, // llvm.nvvm.read.ptx.sreg.clock
+    191, // llvm.nvvm.read.ptx.sreg.clock64
+    12, // llvm.nvvm.read.ptx.sreg.ctaid.w
+    12, // llvm.nvvm.read.ptx.sreg.ctaid.x
+    12, // llvm.nvvm.read.ptx.sreg.ctaid.y
+    12, // llvm.nvvm.read.ptx.sreg.ctaid.z
+    12, // llvm.nvvm.read.ptx.sreg.envreg0
+    12, // llvm.nvvm.read.ptx.sreg.envreg1
+    12, // llvm.nvvm.read.ptx.sreg.envreg10
+    12, // llvm.nvvm.read.ptx.sreg.envreg11
+    12, // llvm.nvvm.read.ptx.sreg.envreg12
+    12, // llvm.nvvm.read.ptx.sreg.envreg13
+    12, // llvm.nvvm.read.ptx.sreg.envreg14
+    12, // llvm.nvvm.read.ptx.sreg.envreg15
+    12, // llvm.nvvm.read.ptx.sreg.envreg16
+    12, // llvm.nvvm.read.ptx.sreg.envreg17
+    12, // llvm.nvvm.read.ptx.sreg.envreg18
+    12, // llvm.nvvm.read.ptx.sreg.envreg19
+    12, // llvm.nvvm.read.ptx.sreg.envreg2
+    12, // llvm.nvvm.read.ptx.sreg.envreg20
+    12, // llvm.nvvm.read.ptx.sreg.envreg21
+    12, // llvm.nvvm.read.ptx.sreg.envreg22
+    12, // llvm.nvvm.read.ptx.sreg.envreg23
+    12, // llvm.nvvm.read.ptx.sreg.envreg24
+    12, // llvm.nvvm.read.ptx.sreg.envreg25
+    12, // llvm.nvvm.read.ptx.sreg.envreg26
+    12, // llvm.nvvm.read.ptx.sreg.envreg27
+    12, // llvm.nvvm.read.ptx.sreg.envreg28
+    12, // llvm.nvvm.read.ptx.sreg.envreg29
+    12, // llvm.nvvm.read.ptx.sreg.envreg3
+    12, // llvm.nvvm.read.ptx.sreg.envreg30
+    12, // llvm.nvvm.read.ptx.sreg.envreg31
+    12, // llvm.nvvm.read.ptx.sreg.envreg4
+    12, // llvm.nvvm.read.ptx.sreg.envreg5
+    12, // llvm.nvvm.read.ptx.sreg.envreg6
+    12, // llvm.nvvm.read.ptx.sreg.envreg7
+    12, // llvm.nvvm.read.ptx.sreg.envreg8
+    12, // llvm.nvvm.read.ptx.sreg.envreg9
+    12, // llvm.nvvm.read.ptx.sreg.gridid
+    12, // llvm.nvvm.read.ptx.sreg.laneid
+    12, // llvm.nvvm.read.ptx.sreg.lanemask.eq
+    12, // llvm.nvvm.read.ptx.sreg.lanemask.ge
+    12, // llvm.nvvm.read.ptx.sreg.lanemask.gt
+    12, // llvm.nvvm.read.ptx.sreg.lanemask.le
+    12, // llvm.nvvm.read.ptx.sreg.lanemask.lt
+    12, // llvm.nvvm.read.ptx.sreg.nctaid.w
+    12, // llvm.nvvm.read.ptx.sreg.nctaid.x
+    12, // llvm.nvvm.read.ptx.sreg.nctaid.y
+    12, // llvm.nvvm.read.ptx.sreg.nctaid.z
+    12, // llvm.nvvm.read.ptx.sreg.nsmid
+    12, // llvm.nvvm.read.ptx.sreg.ntid.w
+    12, // llvm.nvvm.read.ptx.sreg.ntid.x
+    12, // llvm.nvvm.read.ptx.sreg.ntid.y
+    12, // llvm.nvvm.read.ptx.sreg.ntid.z
+    12, // llvm.nvvm.read.ptx.sreg.nwarpid
+    191, // llvm.nvvm.read.ptx.sreg.pm0
+    191, // llvm.nvvm.read.ptx.sreg.pm1
+    191, // llvm.nvvm.read.ptx.sreg.pm2
+    191, // llvm.nvvm.read.ptx.sreg.pm3
+    12, // llvm.nvvm.read.ptx.sreg.smid
+    12, // llvm.nvvm.read.ptx.sreg.tid.w
+    12, // llvm.nvvm.read.ptx.sreg.tid.x
+    12, // llvm.nvvm.read.ptx.sreg.tid.y
+    12, // llvm.nvvm.read.ptx.sreg.tid.z
+    12, // llvm.nvvm.read.ptx.sreg.warpid
+    12, // llvm.nvvm.read.ptx.sreg.warpsize
+    12, // llvm.nvvm.reflect
+    12, // llvm.nvvm.rotate.b32
+    12, // llvm.nvvm.rotate.b64
+    12, // llvm.nvvm.rotate.right.b64
+    12, // llvm.nvvm.round.d
+    12, // llvm.nvvm.round.f
+    12, // llvm.nvvm.round.ftz.f
+    12, // llvm.nvvm.rsqrt.approx.d
+    12, // llvm.nvvm.rsqrt.approx.f
+    12, // llvm.nvvm.rsqrt.approx.ftz.f
+    12, // llvm.nvvm.sad.i
+    12, // llvm.nvvm.sad.ui
+    12, // llvm.nvvm.saturate.d
+    12, // llvm.nvvm.saturate.f
+    12, // llvm.nvvm.saturate.ftz.f
+    190, // llvm.nvvm.shfl.bfly.f32
+    190, // llvm.nvvm.shfl.bfly.f32p
+    190, // llvm.nvvm.shfl.bfly.i32
+    190, // llvm.nvvm.shfl.bfly.i32p
+    190, // llvm.nvvm.shfl.down.f32
+    190, // llvm.nvvm.shfl.down.f32p
+    190, // llvm.nvvm.shfl.down.i32
+    190, // llvm.nvvm.shfl.down.i32p
+    190, // llvm.nvvm.shfl.idx.f32
+    190, // llvm.nvvm.shfl.idx.f32p
+    190, // llvm.nvvm.shfl.idx.i32
+    190, // llvm.nvvm.shfl.idx.i32p
+    190, // llvm.nvvm.shfl.sync.bfly.f32
+    190, // llvm.nvvm.shfl.sync.bfly.f32p
+    190, // llvm.nvvm.shfl.sync.bfly.i32
+    190, // llvm.nvvm.shfl.sync.bfly.i32p
+    190, // llvm.nvvm.shfl.sync.down.f32
+    190, // llvm.nvvm.shfl.sync.down.f32p
+    190, // llvm.nvvm.shfl.sync.down.i32
+    190, // llvm.nvvm.shfl.sync.down.i32p
+    190, // llvm.nvvm.shfl.sync.idx.f32
+    190, // llvm.nvvm.shfl.sync.idx.f32p
+    190, // llvm.nvvm.shfl.sync.idx.i32
+    190, // llvm.nvvm.shfl.sync.idx.i32p
+    190, // llvm.nvvm.shfl.sync.up.f32
+    190, // llvm.nvvm.shfl.sync.up.f32p
+    190, // llvm.nvvm.shfl.sync.up.i32
+    190, // llvm.nvvm.shfl.sync.up.i32p
+    190, // llvm.nvvm.shfl.up.f32
+    190, // llvm.nvvm.shfl.up.f32p
+    190, // llvm.nvvm.shfl.up.i32
+    190, // llvm.nvvm.shfl.up.i32p
+    12, // llvm.nvvm.sin.approx.f
+    12, // llvm.nvvm.sin.approx.ftz.f
+    12, // llvm.nvvm.sqrt.approx.f
+    12, // llvm.nvvm.sqrt.approx.ftz.f
+    12, // llvm.nvvm.sqrt.f
+    12, // llvm.nvvm.sqrt.rm.d
+    12, // llvm.nvvm.sqrt.rm.f
+    12, // llvm.nvvm.sqrt.rm.ftz.f
+    12, // llvm.nvvm.sqrt.rn.d
+    12, // llvm.nvvm.sqrt.rn.f
+    12, // llvm.nvvm.sqrt.rn.ftz.f
+    12, // llvm.nvvm.sqrt.rp.d
+    12, // llvm.nvvm.sqrt.rp.f
+    12, // llvm.nvvm.sqrt.rp.ftz.f
+    12, // llvm.nvvm.sqrt.rz.d
+    12, // llvm.nvvm.sqrt.rz.f
+    12, // llvm.nvvm.sqrt.rz.ftz.f
+    7, // llvm.nvvm.suld.1d.array.i16.clamp
+    7, // llvm.nvvm.suld.1d.array.i16.trap
+    7, // llvm.nvvm.suld.1d.array.i16.zero
+    7, // llvm.nvvm.suld.1d.array.i32.clamp
+    7, // llvm.nvvm.suld.1d.array.i32.trap
+    7, // llvm.nvvm.suld.1d.array.i32.zero
+    7, // llvm.nvvm.suld.1d.array.i64.clamp
+    7, // llvm.nvvm.suld.1d.array.i64.trap
+    7, // llvm.nvvm.suld.1d.array.i64.zero
+    7, // llvm.nvvm.suld.1d.array.i8.clamp
+    7, // llvm.nvvm.suld.1d.array.i8.trap
+    7, // llvm.nvvm.suld.1d.array.i8.zero
+    7, // llvm.nvvm.suld.1d.array.v2i16.clamp
+    7, // llvm.nvvm.suld.1d.array.v2i16.trap
+    7, // llvm.nvvm.suld.1d.array.v2i16.zero
+    7, // llvm.nvvm.suld.1d.array.v2i32.clamp
+    7, // llvm.nvvm.suld.1d.array.v2i32.trap
+    7, // llvm.nvvm.suld.1d.array.v2i32.zero
+    7, // llvm.nvvm.suld.1d.array.v2i64.clamp
+    7, // llvm.nvvm.suld.1d.array.v2i64.trap
+    7, // llvm.nvvm.suld.1d.array.v2i64.zero
+    7, // llvm.nvvm.suld.1d.array.v2i8.clamp
+    7, // llvm.nvvm.suld.1d.array.v2i8.trap
+    7, // llvm.nvvm.suld.1d.array.v2i8.zero
+    7, // llvm.nvvm.suld.1d.array.v4i16.clamp
+    7, // llvm.nvvm.suld.1d.array.v4i16.trap
+    7, // llvm.nvvm.suld.1d.array.v4i16.zero
+    7, // llvm.nvvm.suld.1d.array.v4i32.clamp
+    7, // llvm.nvvm.suld.1d.array.v4i32.trap
+    7, // llvm.nvvm.suld.1d.array.v4i32.zero
+    7, // llvm.nvvm.suld.1d.array.v4i8.clamp
+    7, // llvm.nvvm.suld.1d.array.v4i8.trap
+    7, // llvm.nvvm.suld.1d.array.v4i8.zero
+    7, // llvm.nvvm.suld.1d.i16.clamp
+    7, // llvm.nvvm.suld.1d.i16.trap
+    7, // llvm.nvvm.suld.1d.i16.zero
+    7, // llvm.nvvm.suld.1d.i32.clamp
+    7, // llvm.nvvm.suld.1d.i32.trap
+    7, // llvm.nvvm.suld.1d.i32.zero
+    7, // llvm.nvvm.suld.1d.i64.clamp
+    7, // llvm.nvvm.suld.1d.i64.trap
+    7, // llvm.nvvm.suld.1d.i64.zero
+    7, // llvm.nvvm.suld.1d.i8.clamp
+    7, // llvm.nvvm.suld.1d.i8.trap
+    7, // llvm.nvvm.suld.1d.i8.zero
+    7, // llvm.nvvm.suld.1d.v2i16.clamp
+    7, // llvm.nvvm.suld.1d.v2i16.trap
+    7, // llvm.nvvm.suld.1d.v2i16.zero
+    7, // llvm.nvvm.suld.1d.v2i32.clamp
+    7, // llvm.nvvm.suld.1d.v2i32.trap
+    7, // llvm.nvvm.suld.1d.v2i32.zero
+    7, // llvm.nvvm.suld.1d.v2i64.clamp
+    7, // llvm.nvvm.suld.1d.v2i64.trap
+    7, // llvm.nvvm.suld.1d.v2i64.zero
+    7, // llvm.nvvm.suld.1d.v2i8.clamp
+    7, // llvm.nvvm.suld.1d.v2i8.trap
+    7, // llvm.nvvm.suld.1d.v2i8.zero
+    7, // llvm.nvvm.suld.1d.v4i16.clamp
+    7, // llvm.nvvm.suld.1d.v4i16.trap
+    7, // llvm.nvvm.suld.1d.v4i16.zero
+    7, // llvm.nvvm.suld.1d.v4i32.clamp
+    7, // llvm.nvvm.suld.1d.v4i32.trap
+    7, // llvm.nvvm.suld.1d.v4i32.zero
+    7, // llvm.nvvm.suld.1d.v4i8.clamp
+    7, // llvm.nvvm.suld.1d.v4i8.trap
+    7, // llvm.nvvm.suld.1d.v4i8.zero
+    7, // llvm.nvvm.suld.2d.array.i16.clamp
+    7, // llvm.nvvm.suld.2d.array.i16.trap
+    7, // llvm.nvvm.suld.2d.array.i16.zero
+    7, // llvm.nvvm.suld.2d.array.i32.clamp
+    7, // llvm.nvvm.suld.2d.array.i32.trap
+    7, // llvm.nvvm.suld.2d.array.i32.zero
+    7, // llvm.nvvm.suld.2d.array.i64.clamp
+    7, // llvm.nvvm.suld.2d.array.i64.trap
+    7, // llvm.nvvm.suld.2d.array.i64.zero
+    7, // llvm.nvvm.suld.2d.array.i8.clamp
+    7, // llvm.nvvm.suld.2d.array.i8.trap
+    7, // llvm.nvvm.suld.2d.array.i8.zero
+    7, // llvm.nvvm.suld.2d.array.v2i16.clamp
+    7, // llvm.nvvm.suld.2d.array.v2i16.trap
+    7, // llvm.nvvm.suld.2d.array.v2i16.zero
+    7, // llvm.nvvm.suld.2d.array.v2i32.clamp
+    7, // llvm.nvvm.suld.2d.array.v2i32.trap
+    7, // llvm.nvvm.suld.2d.array.v2i32.zero
+    7, // llvm.nvvm.suld.2d.array.v2i64.clamp
+    7, // llvm.nvvm.suld.2d.array.v2i64.trap
+    7, // llvm.nvvm.suld.2d.array.v2i64.zero
+    7, // llvm.nvvm.suld.2d.array.v2i8.clamp
+    7, // llvm.nvvm.suld.2d.array.v2i8.trap
+    7, // llvm.nvvm.suld.2d.array.v2i8.zero
+    7, // llvm.nvvm.suld.2d.array.v4i16.clamp
+    7, // llvm.nvvm.suld.2d.array.v4i16.trap
+    7, // llvm.nvvm.suld.2d.array.v4i16.zero
+    7, // llvm.nvvm.suld.2d.array.v4i32.clamp
+    7, // llvm.nvvm.suld.2d.array.v4i32.trap
+    7, // llvm.nvvm.suld.2d.array.v4i32.zero
+    7, // llvm.nvvm.suld.2d.array.v4i8.clamp
+    7, // llvm.nvvm.suld.2d.array.v4i8.trap
+    7, // llvm.nvvm.suld.2d.array.v4i8.zero
+    7, // llvm.nvvm.suld.2d.i16.clamp
+    7, // llvm.nvvm.suld.2d.i16.trap
+    7, // llvm.nvvm.suld.2d.i16.zero
+    7, // llvm.nvvm.suld.2d.i32.clamp
+    7, // llvm.nvvm.suld.2d.i32.trap
+    7, // llvm.nvvm.suld.2d.i32.zero
+    7, // llvm.nvvm.suld.2d.i64.clamp
+    7, // llvm.nvvm.suld.2d.i64.trap
+    7, // llvm.nvvm.suld.2d.i64.zero
+    7, // llvm.nvvm.suld.2d.i8.clamp
+    7, // llvm.nvvm.suld.2d.i8.trap
+    7, // llvm.nvvm.suld.2d.i8.zero
+    7, // llvm.nvvm.suld.2d.v2i16.clamp
+    7, // llvm.nvvm.suld.2d.v2i16.trap
+    7, // llvm.nvvm.suld.2d.v2i16.zero
+    7, // llvm.nvvm.suld.2d.v2i32.clamp
+    7, // llvm.nvvm.suld.2d.v2i32.trap
+    7, // llvm.nvvm.suld.2d.v2i32.zero
+    7, // llvm.nvvm.suld.2d.v2i64.clamp
+    7, // llvm.nvvm.suld.2d.v2i64.trap
+    7, // llvm.nvvm.suld.2d.v2i64.zero
+    7, // llvm.nvvm.suld.2d.v2i8.clamp
+    7, // llvm.nvvm.suld.2d.v2i8.trap
+    7, // llvm.nvvm.suld.2d.v2i8.zero
+    7, // llvm.nvvm.suld.2d.v4i16.clamp
+    7, // llvm.nvvm.suld.2d.v4i16.trap
+    7, // llvm.nvvm.suld.2d.v4i16.zero
+    7, // llvm.nvvm.suld.2d.v4i32.clamp
+    7, // llvm.nvvm.suld.2d.v4i32.trap
+    7, // llvm.nvvm.suld.2d.v4i32.zero
+    7, // llvm.nvvm.suld.2d.v4i8.clamp
+    7, // llvm.nvvm.suld.2d.v4i8.trap
+    7, // llvm.nvvm.suld.2d.v4i8.zero
+    7, // llvm.nvvm.suld.3d.i16.clamp
+    7, // llvm.nvvm.suld.3d.i16.trap
+    7, // llvm.nvvm.suld.3d.i16.zero
+    7, // llvm.nvvm.suld.3d.i32.clamp
+    7, // llvm.nvvm.suld.3d.i32.trap
+    7, // llvm.nvvm.suld.3d.i32.zero
+    7, // llvm.nvvm.suld.3d.i64.clamp
+    7, // llvm.nvvm.suld.3d.i64.trap
+    7, // llvm.nvvm.suld.3d.i64.zero
+    7, // llvm.nvvm.suld.3d.i8.clamp
+    7, // llvm.nvvm.suld.3d.i8.trap
+    7, // llvm.nvvm.suld.3d.i8.zero
+    7, // llvm.nvvm.suld.3d.v2i16.clamp
+    7, // llvm.nvvm.suld.3d.v2i16.trap
+    7, // llvm.nvvm.suld.3d.v2i16.zero
+    7, // llvm.nvvm.suld.3d.v2i32.clamp
+    7, // llvm.nvvm.suld.3d.v2i32.trap
+    7, // llvm.nvvm.suld.3d.v2i32.zero
+    7, // llvm.nvvm.suld.3d.v2i64.clamp
+    7, // llvm.nvvm.suld.3d.v2i64.trap
+    7, // llvm.nvvm.suld.3d.v2i64.zero
+    7, // llvm.nvvm.suld.3d.v2i8.clamp
+    7, // llvm.nvvm.suld.3d.v2i8.trap
+    7, // llvm.nvvm.suld.3d.v2i8.zero
+    7, // llvm.nvvm.suld.3d.v4i16.clamp
+    7, // llvm.nvvm.suld.3d.v4i16.trap
+    7, // llvm.nvvm.suld.3d.v4i16.zero
+    7, // llvm.nvvm.suld.3d.v4i32.clamp
+    7, // llvm.nvvm.suld.3d.v4i32.trap
+    7, // llvm.nvvm.suld.3d.v4i32.zero
+    7, // llvm.nvvm.suld.3d.v4i8.clamp
+    7, // llvm.nvvm.suld.3d.v4i8.trap
+    7, // llvm.nvvm.suld.3d.v4i8.zero
+    12, // llvm.nvvm.suq.array.size
+    12, // llvm.nvvm.suq.channel.data.type
+    12, // llvm.nvvm.suq.channel.order
+    12, // llvm.nvvm.suq.depth
+    12, // llvm.nvvm.suq.height
+    12, // llvm.nvvm.suq.width
+    7, // llvm.nvvm.sust.b.1d.array.i16.clamp
+    7, // llvm.nvvm.sust.b.1d.array.i16.trap
+    7, // llvm.nvvm.sust.b.1d.array.i16.zero
+    7, // llvm.nvvm.sust.b.1d.array.i32.clamp
+    7, // llvm.nvvm.sust.b.1d.array.i32.trap
+    7, // llvm.nvvm.sust.b.1d.array.i32.zero
+    7, // llvm.nvvm.sust.b.1d.array.i64.clamp
+    7, // llvm.nvvm.sust.b.1d.array.i64.trap
+    7, // llvm.nvvm.sust.b.1d.array.i64.zero
+    7, // llvm.nvvm.sust.b.1d.array.i8.clamp
+    7, // llvm.nvvm.sust.b.1d.array.i8.trap
+    7, // llvm.nvvm.sust.b.1d.array.i8.zero
+    7, // llvm.nvvm.sust.b.1d.array.v2i16.clamp
+    7, // llvm.nvvm.sust.b.1d.array.v2i16.trap
+    7, // llvm.nvvm.sust.b.1d.array.v2i16.zero
+    7, // llvm.nvvm.sust.b.1d.array.v2i32.clamp
+    7, // llvm.nvvm.sust.b.1d.array.v2i32.trap
+    7, // llvm.nvvm.sust.b.1d.array.v2i32.zero
+    7, // llvm.nvvm.sust.b.1d.array.v2i64.clamp
+    7, // llvm.nvvm.sust.b.1d.array.v2i64.trap
+    7, // llvm.nvvm.sust.b.1d.array.v2i64.zero
+    7, // llvm.nvvm.sust.b.1d.array.v2i8.clamp
+    7, // llvm.nvvm.sust.b.1d.array.v2i8.trap
+    7, // llvm.nvvm.sust.b.1d.array.v2i8.zero
+    7, // llvm.nvvm.sust.b.1d.array.v4i16.clamp
+    7, // llvm.nvvm.sust.b.1d.array.v4i16.trap
+    7, // llvm.nvvm.sust.b.1d.array.v4i16.zero
+    7, // llvm.nvvm.sust.b.1d.array.v4i32.clamp
+    7, // llvm.nvvm.sust.b.1d.array.v4i32.trap
+    7, // llvm.nvvm.sust.b.1d.array.v4i32.zero
+    7, // llvm.nvvm.sust.b.1d.array.v4i8.clamp
+    7, // llvm.nvvm.sust.b.1d.array.v4i8.trap
+    7, // llvm.nvvm.sust.b.1d.array.v4i8.zero
+    7, // llvm.nvvm.sust.b.1d.i16.clamp
+    7, // llvm.nvvm.sust.b.1d.i16.trap
+    7, // llvm.nvvm.sust.b.1d.i16.zero
+    7, // llvm.nvvm.sust.b.1d.i32.clamp
+    7, // llvm.nvvm.sust.b.1d.i32.trap
+    7, // llvm.nvvm.sust.b.1d.i32.zero
+    7, // llvm.nvvm.sust.b.1d.i64.clamp
+    7, // llvm.nvvm.sust.b.1d.i64.trap
+    7, // llvm.nvvm.sust.b.1d.i64.zero
+    7, // llvm.nvvm.sust.b.1d.i8.clamp
+    7, // llvm.nvvm.sust.b.1d.i8.trap
+    7, // llvm.nvvm.sust.b.1d.i8.zero
+    7, // llvm.nvvm.sust.b.1d.v2i16.clamp
+    7, // llvm.nvvm.sust.b.1d.v2i16.trap
+    7, // llvm.nvvm.sust.b.1d.v2i16.zero
+    7, // llvm.nvvm.sust.b.1d.v2i32.clamp
+    7, // llvm.nvvm.sust.b.1d.v2i32.trap
+    7, // llvm.nvvm.sust.b.1d.v2i32.zero
+    7, // llvm.nvvm.sust.b.1d.v2i64.clamp
+    7, // llvm.nvvm.sust.b.1d.v2i64.trap
+    7, // llvm.nvvm.sust.b.1d.v2i64.zero
+    7, // llvm.nvvm.sust.b.1d.v2i8.clamp
+    7, // llvm.nvvm.sust.b.1d.v2i8.trap
+    7, // llvm.nvvm.sust.b.1d.v2i8.zero
+    7, // llvm.nvvm.sust.b.1d.v4i16.clamp
+    7, // llvm.nvvm.sust.b.1d.v4i16.trap
+    7, // llvm.nvvm.sust.b.1d.v4i16.zero
+    7, // llvm.nvvm.sust.b.1d.v4i32.clamp
+    7, // llvm.nvvm.sust.b.1d.v4i32.trap
+    7, // llvm.nvvm.sust.b.1d.v4i32.zero
+    7, // llvm.nvvm.sust.b.1d.v4i8.clamp
+    7, // llvm.nvvm.sust.b.1d.v4i8.trap
+    7, // llvm.nvvm.sust.b.1d.v4i8.zero
+    7, // llvm.nvvm.sust.b.2d.array.i16.clamp
+    7, // llvm.nvvm.sust.b.2d.array.i16.trap
+    7, // llvm.nvvm.sust.b.2d.array.i16.zero
+    7, // llvm.nvvm.sust.b.2d.array.i32.clamp
+    7, // llvm.nvvm.sust.b.2d.array.i32.trap
+    7, // llvm.nvvm.sust.b.2d.array.i32.zero
+    7, // llvm.nvvm.sust.b.2d.array.i64.clamp
+    7, // llvm.nvvm.sust.b.2d.array.i64.trap
+    7, // llvm.nvvm.sust.b.2d.array.i64.zero
+    7, // llvm.nvvm.sust.b.2d.array.i8.clamp
+    7, // llvm.nvvm.sust.b.2d.array.i8.trap
+    7, // llvm.nvvm.sust.b.2d.array.i8.zero
+    7, // llvm.nvvm.sust.b.2d.array.v2i16.clamp
+    7, // llvm.nvvm.sust.b.2d.array.v2i16.trap
+    7, // llvm.nvvm.sust.b.2d.array.v2i16.zero
+    7, // llvm.nvvm.sust.b.2d.array.v2i32.clamp
+    7, // llvm.nvvm.sust.b.2d.array.v2i32.trap
+    7, // llvm.nvvm.sust.b.2d.array.v2i32.zero
+    7, // llvm.nvvm.sust.b.2d.array.v2i64.clamp
+    7, // llvm.nvvm.sust.b.2d.array.v2i64.trap
+    7, // llvm.nvvm.sust.b.2d.array.v2i64.zero
+    7, // llvm.nvvm.sust.b.2d.array.v2i8.clamp
+    7, // llvm.nvvm.sust.b.2d.array.v2i8.trap
+    7, // llvm.nvvm.sust.b.2d.array.v2i8.zero
+    7, // llvm.nvvm.sust.b.2d.array.v4i16.clamp
+    7, // llvm.nvvm.sust.b.2d.array.v4i16.trap
+    7, // llvm.nvvm.sust.b.2d.array.v4i16.zero
+    7, // llvm.nvvm.sust.b.2d.array.v4i32.clamp
+    7, // llvm.nvvm.sust.b.2d.array.v4i32.trap
+    7, // llvm.nvvm.sust.b.2d.array.v4i32.zero
+    7, // llvm.nvvm.sust.b.2d.array.v4i8.clamp
+    7, // llvm.nvvm.sust.b.2d.array.v4i8.trap
+    7, // llvm.nvvm.sust.b.2d.array.v4i8.zero
+    7, // llvm.nvvm.sust.b.2d.i16.clamp
+    7, // llvm.nvvm.sust.b.2d.i16.trap
+    7, // llvm.nvvm.sust.b.2d.i16.zero
+    7, // llvm.nvvm.sust.b.2d.i32.clamp
+    7, // llvm.nvvm.sust.b.2d.i32.trap
+    7, // llvm.nvvm.sust.b.2d.i32.zero
+    7, // llvm.nvvm.sust.b.2d.i64.clamp
+    7, // llvm.nvvm.sust.b.2d.i64.trap
+    7, // llvm.nvvm.sust.b.2d.i64.zero
+    7, // llvm.nvvm.sust.b.2d.i8.clamp
+    7, // llvm.nvvm.sust.b.2d.i8.trap
+    7, // llvm.nvvm.sust.b.2d.i8.zero
+    7, // llvm.nvvm.sust.b.2d.v2i16.clamp
+    7, // llvm.nvvm.sust.b.2d.v2i16.trap
+    7, // llvm.nvvm.sust.b.2d.v2i16.zero
+    7, // llvm.nvvm.sust.b.2d.v2i32.clamp
+    7, // llvm.nvvm.sust.b.2d.v2i32.trap
+    7, // llvm.nvvm.sust.b.2d.v2i32.zero
+    7, // llvm.nvvm.sust.b.2d.v2i64.clamp
+    7, // llvm.nvvm.sust.b.2d.v2i64.trap
+    7, // llvm.nvvm.sust.b.2d.v2i64.zero
+    7, // llvm.nvvm.sust.b.2d.v2i8.clamp
+    7, // llvm.nvvm.sust.b.2d.v2i8.trap
+    7, // llvm.nvvm.sust.b.2d.v2i8.zero
+    7, // llvm.nvvm.sust.b.2d.v4i16.clamp
+    7, // llvm.nvvm.sust.b.2d.v4i16.trap
+    7, // llvm.nvvm.sust.b.2d.v4i16.zero
+    7, // llvm.nvvm.sust.b.2d.v4i32.clamp
+    7, // llvm.nvvm.sust.b.2d.v4i32.trap
+    7, // llvm.nvvm.sust.b.2d.v4i32.zero
+    7, // llvm.nvvm.sust.b.2d.v4i8.clamp
+    7, // llvm.nvvm.sust.b.2d.v4i8.trap
+    7, // llvm.nvvm.sust.b.2d.v4i8.zero
+    7, // llvm.nvvm.sust.b.3d.i16.clamp
+    7, // llvm.nvvm.sust.b.3d.i16.trap
+    7, // llvm.nvvm.sust.b.3d.i16.zero
+    7, // llvm.nvvm.sust.b.3d.i32.clamp
+    7, // llvm.nvvm.sust.b.3d.i32.trap
+    7, // llvm.nvvm.sust.b.3d.i32.zero
+    7, // llvm.nvvm.sust.b.3d.i64.clamp
+    7, // llvm.nvvm.sust.b.3d.i64.trap
+    7, // llvm.nvvm.sust.b.3d.i64.zero
+    7, // llvm.nvvm.sust.b.3d.i8.clamp
+    7, // llvm.nvvm.sust.b.3d.i8.trap
+    7, // llvm.nvvm.sust.b.3d.i8.zero
+    7, // llvm.nvvm.sust.b.3d.v2i16.clamp
+    7, // llvm.nvvm.sust.b.3d.v2i16.trap
+    7, // llvm.nvvm.sust.b.3d.v2i16.zero
+    7, // llvm.nvvm.sust.b.3d.v2i32.clamp
+    7, // llvm.nvvm.sust.b.3d.v2i32.trap
+    7, // llvm.nvvm.sust.b.3d.v2i32.zero
+    7, // llvm.nvvm.sust.b.3d.v2i64.clamp
+    7, // llvm.nvvm.sust.b.3d.v2i64.trap
+    7, // llvm.nvvm.sust.b.3d.v2i64.zero
+    7, // llvm.nvvm.sust.b.3d.v2i8.clamp
+    7, // llvm.nvvm.sust.b.3d.v2i8.trap
+    7, // llvm.nvvm.sust.b.3d.v2i8.zero
+    7, // llvm.nvvm.sust.b.3d.v4i16.clamp
+    7, // llvm.nvvm.sust.b.3d.v4i16.trap
+    7, // llvm.nvvm.sust.b.3d.v4i16.zero
+    7, // llvm.nvvm.sust.b.3d.v4i32.clamp
+    7, // llvm.nvvm.sust.b.3d.v4i32.trap
+    7, // llvm.nvvm.sust.b.3d.v4i32.zero
+    7, // llvm.nvvm.sust.b.3d.v4i8.clamp
+    7, // llvm.nvvm.sust.b.3d.v4i8.trap
+    7, // llvm.nvvm.sust.b.3d.v4i8.zero
+    7, // llvm.nvvm.sust.p.1d.array.i16.trap
+    7, // llvm.nvvm.sust.p.1d.array.i32.trap
+    7, // llvm.nvvm.sust.p.1d.array.i8.trap
+    7, // llvm.nvvm.sust.p.1d.array.v2i16.trap
+    7, // llvm.nvvm.sust.p.1d.array.v2i32.trap
+    7, // llvm.nvvm.sust.p.1d.array.v2i8.trap
+    7, // llvm.nvvm.sust.p.1d.array.v4i16.trap
+    7, // llvm.nvvm.sust.p.1d.array.v4i32.trap
+    7, // llvm.nvvm.sust.p.1d.array.v4i8.trap
+    7, // llvm.nvvm.sust.p.1d.i16.trap
+    7, // llvm.nvvm.sust.p.1d.i32.trap
+    7, // llvm.nvvm.sust.p.1d.i8.trap
+    7, // llvm.nvvm.sust.p.1d.v2i16.trap
+    7, // llvm.nvvm.sust.p.1d.v2i32.trap
+    7, // llvm.nvvm.sust.p.1d.v2i8.trap
+    7, // llvm.nvvm.sust.p.1d.v4i16.trap
+    7, // llvm.nvvm.sust.p.1d.v4i32.trap
+    7, // llvm.nvvm.sust.p.1d.v4i8.trap
+    7, // llvm.nvvm.sust.p.2d.array.i16.trap
+    7, // llvm.nvvm.sust.p.2d.array.i32.trap
+    7, // llvm.nvvm.sust.p.2d.array.i8.trap
+    7, // llvm.nvvm.sust.p.2d.array.v2i16.trap
+    7, // llvm.nvvm.sust.p.2d.array.v2i32.trap
+    7, // llvm.nvvm.sust.p.2d.array.v2i8.trap
+    7, // llvm.nvvm.sust.p.2d.array.v4i16.trap
+    7, // llvm.nvvm.sust.p.2d.array.v4i32.trap
+    7, // llvm.nvvm.sust.p.2d.array.v4i8.trap
+    7, // llvm.nvvm.sust.p.2d.i16.trap
+    7, // llvm.nvvm.sust.p.2d.i32.trap
+    7, // llvm.nvvm.sust.p.2d.i8.trap
+    7, // llvm.nvvm.sust.p.2d.v2i16.trap
+    7, // llvm.nvvm.sust.p.2d.v2i32.trap
+    7, // llvm.nvvm.sust.p.2d.v2i8.trap
+    7, // llvm.nvvm.sust.p.2d.v4i16.trap
+    7, // llvm.nvvm.sust.p.2d.v4i32.trap
+    7, // llvm.nvvm.sust.p.2d.v4i8.trap
+    7, // llvm.nvvm.sust.p.3d.i16.trap
+    7, // llvm.nvvm.sust.p.3d.i32.trap
+    7, // llvm.nvvm.sust.p.3d.i8.trap
+    7, // llvm.nvvm.sust.p.3d.v2i16.trap
+    7, // llvm.nvvm.sust.p.3d.v2i32.trap
+    7, // llvm.nvvm.sust.p.3d.v2i8.trap
+    7, // llvm.nvvm.sust.p.3d.v4i16.trap
+    7, // llvm.nvvm.sust.p.3d.v4i32.trap
+    7, // llvm.nvvm.sust.p.3d.v4i8.trap
+    12, // llvm.nvvm.swap.lo.hi.b64
+    7, // llvm.nvvm.tex.1d.array.grad.v4f32.f32
+    7, // llvm.nvvm.tex.1d.array.grad.v4s32.f32
+    7, // llvm.nvvm.tex.1d.array.grad.v4u32.f32
+    7, // llvm.nvvm.tex.1d.array.level.v4f32.f32
+    7, // llvm.nvvm.tex.1d.array.level.v4s32.f32
+    7, // llvm.nvvm.tex.1d.array.level.v4u32.f32
+    7, // llvm.nvvm.tex.1d.array.v4f32.f32
+    7, // llvm.nvvm.tex.1d.array.v4f32.s32
+    7, // llvm.nvvm.tex.1d.array.v4s32.f32
+    7, // llvm.nvvm.tex.1d.array.v4s32.s32
+    7, // llvm.nvvm.tex.1d.array.v4u32.f32
+    7, // llvm.nvvm.tex.1d.array.v4u32.s32
+    7, // llvm.nvvm.tex.1d.grad.v4f32.f32
+    7, // llvm.nvvm.tex.1d.grad.v4s32.f32
+    7, // llvm.nvvm.tex.1d.grad.v4u32.f32
+    7, // llvm.nvvm.tex.1d.level.v4f32.f32
+    7, // llvm.nvvm.tex.1d.level.v4s32.f32
+    7, // llvm.nvvm.tex.1d.level.v4u32.f32
+    7, // llvm.nvvm.tex.1d.v4f32.f32
+    7, // llvm.nvvm.tex.1d.v4f32.s32
+    7, // llvm.nvvm.tex.1d.v4s32.f32
+    7, // llvm.nvvm.tex.1d.v4s32.s32
+    7, // llvm.nvvm.tex.1d.v4u32.f32
+    7, // llvm.nvvm.tex.1d.v4u32.s32
+    7, // llvm.nvvm.tex.2d.array.grad.v4f32.f32
+    7, // llvm.nvvm.tex.2d.array.grad.v4s32.f32
+    7, // llvm.nvvm.tex.2d.array.grad.v4u32.f32
+    7, // llvm.nvvm.tex.2d.array.level.v4f32.f32
+    7, // llvm.nvvm.tex.2d.array.level.v4s32.f32
+    7, // llvm.nvvm.tex.2d.array.level.v4u32.f32
+    7, // llvm.nvvm.tex.2d.array.v4f32.f32
+    7, // llvm.nvvm.tex.2d.array.v4f32.s32
+    7, // llvm.nvvm.tex.2d.array.v4s32.f32
+    7, // llvm.nvvm.tex.2d.array.v4s32.s32
+    7, // llvm.nvvm.tex.2d.array.v4u32.f32
+    7, // llvm.nvvm.tex.2d.array.v4u32.s32
+    7, // llvm.nvvm.tex.2d.grad.v4f32.f32
+    7, // llvm.nvvm.tex.2d.grad.v4s32.f32
+    7, // llvm.nvvm.tex.2d.grad.v4u32.f32
+    7, // llvm.nvvm.tex.2d.level.v4f32.f32
+    7, // llvm.nvvm.tex.2d.level.v4s32.f32
+    7, // llvm.nvvm.tex.2d.level.v4u32.f32
+    7, // llvm.nvvm.tex.2d.v4f32.f32
+    7, // llvm.nvvm.tex.2d.v4f32.s32
+    7, // llvm.nvvm.tex.2d.v4s32.f32
+    7, // llvm.nvvm.tex.2d.v4s32.s32
+    7, // llvm.nvvm.tex.2d.v4u32.f32
+    7, // llvm.nvvm.tex.2d.v4u32.s32
+    7, // llvm.nvvm.tex.3d.grad.v4f32.f32
+    7, // llvm.nvvm.tex.3d.grad.v4s32.f32
+    7, // llvm.nvvm.tex.3d.grad.v4u32.f32
+    7, // llvm.nvvm.tex.3d.level.v4f32.f32
+    7, // llvm.nvvm.tex.3d.level.v4s32.f32
+    7, // llvm.nvvm.tex.3d.level.v4u32.f32
+    7, // llvm.nvvm.tex.3d.v4f32.f32
+    7, // llvm.nvvm.tex.3d.v4f32.s32
+    7, // llvm.nvvm.tex.3d.v4s32.f32
+    7, // llvm.nvvm.tex.3d.v4s32.s32
+    7, // llvm.nvvm.tex.3d.v4u32.f32
+    7, // llvm.nvvm.tex.3d.v4u32.s32
+    7, // llvm.nvvm.tex.cube.array.level.v4f32.f32
+    7, // llvm.nvvm.tex.cube.array.level.v4s32.f32
+    7, // llvm.nvvm.tex.cube.array.level.v4u32.f32
+    7, // llvm.nvvm.tex.cube.array.v4f32.f32
+    7, // llvm.nvvm.tex.cube.array.v4s32.f32
+    7, // llvm.nvvm.tex.cube.array.v4u32.f32
+    7, // llvm.nvvm.tex.cube.level.v4f32.f32
+    7, // llvm.nvvm.tex.cube.level.v4s32.f32
+    7, // llvm.nvvm.tex.cube.level.v4u32.f32
+    7, // llvm.nvvm.tex.cube.v4f32.f32
+    7, // llvm.nvvm.tex.cube.v4s32.f32
+    7, // llvm.nvvm.tex.cube.v4u32.f32
+    7, // llvm.nvvm.tex.unified.1d.array.grad.v4f32.f32
+    7, // llvm.nvvm.tex.unified.1d.array.grad.v4s32.f32
+    7, // llvm.nvvm.tex.unified.1d.array.grad.v4u32.f32
+    7, // llvm.nvvm.tex.unified.1d.array.level.v4f32.f32
+    7, // llvm.nvvm.tex.unified.1d.array.level.v4s32.f32
+    7, // llvm.nvvm.tex.unified.1d.array.level.v4u32.f32
+    7, // llvm.nvvm.tex.unified.1d.array.v4f32.f32
+    7, // llvm.nvvm.tex.unified.1d.array.v4f32.s32
+    7, // llvm.nvvm.tex.unified.1d.array.v4s32.f32
+    7, // llvm.nvvm.tex.unified.1d.array.v4s32.s32
+    7, // llvm.nvvm.tex.unified.1d.array.v4u32.f32
+    7, // llvm.nvvm.tex.unified.1d.array.v4u32.s32
+    7, // llvm.nvvm.tex.unified.1d.grad.v4f32.f32
+    7, // llvm.nvvm.tex.unified.1d.grad.v4s32.f32
+    7, // llvm.nvvm.tex.unified.1d.grad.v4u32.f32
+    7, // llvm.nvvm.tex.unified.1d.level.v4f32.f32
+    7, // llvm.nvvm.tex.unified.1d.level.v4s32.f32
+    7, // llvm.nvvm.tex.unified.1d.level.v4u32.f32
+    7, // llvm.nvvm.tex.unified.1d.v4f32.f32
+    7, // llvm.nvvm.tex.unified.1d.v4f32.s32
+    7, // llvm.nvvm.tex.unified.1d.v4s32.f32
+    7, // llvm.nvvm.tex.unified.1d.v4s32.s32
+    7, // llvm.nvvm.tex.unified.1d.v4u32.f32
+    7, // llvm.nvvm.tex.unified.1d.v4u32.s32
+    7, // llvm.nvvm.tex.unified.2d.array.grad.v4f32.f32
+    7, // llvm.nvvm.tex.unified.2d.array.grad.v4s32.f32
+    7, // llvm.nvvm.tex.unified.2d.array.grad.v4u32.f32
+    7, // llvm.nvvm.tex.unified.2d.array.level.v4f32.f32
+    7, // llvm.nvvm.tex.unified.2d.array.level.v4s32.f32
+    7, // llvm.nvvm.tex.unified.2d.array.level.v4u32.f32
+    7, // llvm.nvvm.tex.unified.2d.array.v4f32.f32
+    7, // llvm.nvvm.tex.unified.2d.array.v4f32.s32
+    7, // llvm.nvvm.tex.unified.2d.array.v4s32.f32
+    7, // llvm.nvvm.tex.unified.2d.array.v4s32.s32
+    7, // llvm.nvvm.tex.unified.2d.array.v4u32.f32
+    7, // llvm.nvvm.tex.unified.2d.array.v4u32.s32
+    7, // llvm.nvvm.tex.unified.2d.grad.v4f32.f32
+    7, // llvm.nvvm.tex.unified.2d.grad.v4s32.f32
+    7, // llvm.nvvm.tex.unified.2d.grad.v4u32.f32
+    7, // llvm.nvvm.tex.unified.2d.level.v4f32.f32
+    7, // llvm.nvvm.tex.unified.2d.level.v4s32.f32
+    7, // llvm.nvvm.tex.unified.2d.level.v4u32.f32
+    7, // llvm.nvvm.tex.unified.2d.v4f32.f32
+    7, // llvm.nvvm.tex.unified.2d.v4f32.s32
+    7, // llvm.nvvm.tex.unified.2d.v4s32.f32
+    7, // llvm.nvvm.tex.unified.2d.v4s32.s32
+    7, // llvm.nvvm.tex.unified.2d.v4u32.f32
+    7, // llvm.nvvm.tex.unified.2d.v4u32.s32
+    7, // llvm.nvvm.tex.unified.3d.grad.v4f32.f32
+    7, // llvm.nvvm.tex.unified.3d.grad.v4s32.f32
+    7, // llvm.nvvm.tex.unified.3d.grad.v4u32.f32
+    7, // llvm.nvvm.tex.unified.3d.level.v4f32.f32
+    7, // llvm.nvvm.tex.unified.3d.level.v4s32.f32
+    7, // llvm.nvvm.tex.unified.3d.level.v4u32.f32
+    7, // llvm.nvvm.tex.unified.3d.v4f32.f32
+    7, // llvm.nvvm.tex.unified.3d.v4f32.s32
+    7, // llvm.nvvm.tex.unified.3d.v4s32.f32
+    7, // llvm.nvvm.tex.unified.3d.v4s32.s32
+    7, // llvm.nvvm.tex.unified.3d.v4u32.f32
+    7, // llvm.nvvm.tex.unified.3d.v4u32.s32
+    7, // llvm.nvvm.tex.unified.cube.array.level.v4f32.f32
+    7, // llvm.nvvm.tex.unified.cube.array.level.v4s32.f32
+    7, // llvm.nvvm.tex.unified.cube.array.level.v4u32.f32
+    7, // llvm.nvvm.tex.unified.cube.array.v4f32.f32
+    7, // llvm.nvvm.tex.unified.cube.array.v4s32.f32
+    7, // llvm.nvvm.tex.unified.cube.array.v4u32.f32
+    7, // llvm.nvvm.tex.unified.cube.level.v4f32.f32
+    7, // llvm.nvvm.tex.unified.cube.level.v4s32.f32
+    7, // llvm.nvvm.tex.unified.cube.level.v4u32.f32
+    7, // llvm.nvvm.tex.unified.cube.v4f32.f32
+    7, // llvm.nvvm.tex.unified.cube.v4s32.f32
+    7, // llvm.nvvm.tex.unified.cube.v4u32.f32
+    12, // llvm.nvvm.texsurf.handle
+    12, // llvm.nvvm.texsurf.handle.internal
+    7, // llvm.nvvm.tld4.a.2d.v4f32.f32
+    7, // llvm.nvvm.tld4.a.2d.v4s32.f32
+    7, // llvm.nvvm.tld4.a.2d.v4u32.f32
+    7, // llvm.nvvm.tld4.b.2d.v4f32.f32
+    7, // llvm.nvvm.tld4.b.2d.v4s32.f32
+    7, // llvm.nvvm.tld4.b.2d.v4u32.f32
+    7, // llvm.nvvm.tld4.g.2d.v4f32.f32
+    7, // llvm.nvvm.tld4.g.2d.v4s32.f32
+    7, // llvm.nvvm.tld4.g.2d.v4u32.f32
+    7, // llvm.nvvm.tld4.r.2d.v4f32.f32
+    7, // llvm.nvvm.tld4.r.2d.v4s32.f32
+    7, // llvm.nvvm.tld4.r.2d.v4u32.f32
+    7, // llvm.nvvm.tld4.unified.a.2d.v4f32.f32
+    7, // llvm.nvvm.tld4.unified.a.2d.v4s32.f32
+    7, // llvm.nvvm.tld4.unified.a.2d.v4u32.f32
+    7, // llvm.nvvm.tld4.unified.b.2d.v4f32.f32
+    7, // llvm.nvvm.tld4.unified.b.2d.v4s32.f32
+    7, // llvm.nvvm.tld4.unified.b.2d.v4u32.f32
+    7, // llvm.nvvm.tld4.unified.g.2d.v4f32.f32
+    7, // llvm.nvvm.tld4.unified.g.2d.v4s32.f32
+    7, // llvm.nvvm.tld4.unified.g.2d.v4u32.f32
+    7, // llvm.nvvm.tld4.unified.r.2d.v4f32.f32
+    7, // llvm.nvvm.tld4.unified.r.2d.v4s32.f32
+    7, // llvm.nvvm.tld4.unified.r.2d.v4u32.f32
+    12, // llvm.nvvm.trunc.d
+    12, // llvm.nvvm.trunc.f
+    12, // llvm.nvvm.trunc.ftz.f
+    12, // llvm.nvvm.txq.array.size
+    12, // llvm.nvvm.txq.channel.data.type
+    12, // llvm.nvvm.txq.channel.order
+    12, // llvm.nvvm.txq.depth
+    12, // llvm.nvvm.txq.height
+    12, // llvm.nvvm.txq.num.mipmap.levels
+    12, // llvm.nvvm.txq.num.samples
+    12, // llvm.nvvm.txq.width
+    12, // llvm.nvvm.ui2d.rm
+    12, // llvm.nvvm.ui2d.rn
+    12, // llvm.nvvm.ui2d.rp
+    12, // llvm.nvvm.ui2d.rz
+    12, // llvm.nvvm.ui2f.rm
+    12, // llvm.nvvm.ui2f.rn
+    12, // llvm.nvvm.ui2f.rp
+    12, // llvm.nvvm.ui2f.rz
+    12, // llvm.nvvm.ull2d.rm
+    12, // llvm.nvvm.ull2d.rn
+    12, // llvm.nvvm.ull2d.rp
+    12, // llvm.nvvm.ull2d.rz
+    12, // llvm.nvvm.ull2f.rm
+    12, // llvm.nvvm.ull2f.rn
+    12, // llvm.nvvm.ull2f.rp
+    12, // llvm.nvvm.ull2f.rz
+    190, // llvm.nvvm.vote.all
+    190, // llvm.nvvm.vote.all.sync
+    190, // llvm.nvvm.vote.any
+    190, // llvm.nvvm.vote.any.sync
+    190, // llvm.nvvm.vote.ballot
+    190, // llvm.nvvm.vote.ballot.sync
+    190, // llvm.nvvm.vote.uni
+    190, // llvm.nvvm.vote.uni.sync
+    17, // llvm.nvvm.wmma.m16n16k16.load.a.col.f16
+    17, // llvm.nvvm.wmma.m16n16k16.load.a.col.s8
+    17, // llvm.nvvm.wmma.m16n16k16.load.a.col.stride.f16
+    17, // llvm.nvvm.wmma.m16n16k16.load.a.col.stride.s8
+    17, // llvm.nvvm.wmma.m16n16k16.load.a.col.stride.u8
+    17, // llvm.nvvm.wmma.m16n16k16.load.a.col.u8
+    17, // llvm.nvvm.wmma.m16n16k16.load.a.row.f16
+    17, // llvm.nvvm.wmma.m16n16k16.load.a.row.s8
+    17, // llvm.nvvm.wmma.m16n16k16.load.a.row.stride.f16
+    17, // llvm.nvvm.wmma.m16n16k16.load.a.row.stride.s8
+    17, // llvm.nvvm.wmma.m16n16k16.load.a.row.stride.u8
+    17, // llvm.nvvm.wmma.m16n16k16.load.a.row.u8
+    17, // llvm.nvvm.wmma.m16n16k16.load.b.col.f16
+    17, // llvm.nvvm.wmma.m16n16k16.load.b.col.s8
+    17, // llvm.nvvm.wmma.m16n16k16.load.b.col.stride.f16
+    17, // llvm.nvvm.wmma.m16n16k16.load.b.col.stride.s8
+    17, // llvm.nvvm.wmma.m16n16k16.load.b.col.stride.u8
+    17, // llvm.nvvm.wmma.m16n16k16.load.b.col.u8
+    17, // llvm.nvvm.wmma.m16n16k16.load.b.row.f16
+    17, // llvm.nvvm.wmma.m16n16k16.load.b.row.s8
+    17, // llvm.nvvm.wmma.m16n16k16.load.b.row.stride.f16
+    17, // llvm.nvvm.wmma.m16n16k16.load.b.row.stride.s8
+    17, // llvm.nvvm.wmma.m16n16k16.load.b.row.stride.u8
+    17, // llvm.nvvm.wmma.m16n16k16.load.b.row.u8
+    17, // llvm.nvvm.wmma.m16n16k16.load.c.col.f16
+    17, // llvm.nvvm.wmma.m16n16k16.load.c.col.f32
+    17, // llvm.nvvm.wmma.m16n16k16.load.c.col.s32
+    17, // llvm.nvvm.wmma.m16n16k16.load.c.col.stride.f16
+    17, // llvm.nvvm.wmma.m16n16k16.load.c.col.stride.f32
+    17, // llvm.nvvm.wmma.m16n16k16.load.c.col.stride.s32
+    17, // llvm.nvvm.wmma.m16n16k16.load.c.row.f16
+    17, // llvm.nvvm.wmma.m16n16k16.load.c.row.f32
+    17, // llvm.nvvm.wmma.m16n16k16.load.c.row.s32
+    17, // llvm.nvvm.wmma.m16n16k16.load.c.row.stride.f16
+    17, // llvm.nvvm.wmma.m16n16k16.load.c.row.stride.f32
+    17, // llvm.nvvm.wmma.m16n16k16.load.c.row.stride.s32
+    12, // llvm.nvvm.wmma.m16n16k16.mma.col.col.f16.f16
+    12, // llvm.nvvm.wmma.m16n16k16.mma.col.col.f16.f16.satfinite
+    12, // llvm.nvvm.wmma.m16n16k16.mma.col.col.f16.f32
+    12, // llvm.nvvm.wmma.m16n16k16.mma.col.col.f16.f32.satfinite
+    12, // llvm.nvvm.wmma.m16n16k16.mma.col.col.f32.f16
+    12, // llvm.nvvm.wmma.m16n16k16.mma.col.col.f32.f16.satfinite
+    12, // llvm.nvvm.wmma.m16n16k16.mma.col.col.f32.f32
+    12, // llvm.nvvm.wmma.m16n16k16.mma.col.col.f32.f32.satfinite
+    12, // llvm.nvvm.wmma.m16n16k16.mma.col.col.s8
+    12, // llvm.nvvm.wmma.m16n16k16.mma.col.col.s8.satfinite
+    12, // llvm.nvvm.wmma.m16n16k16.mma.col.col.u8
+    12, // llvm.nvvm.wmma.m16n16k16.mma.col.col.u8.satfinite
+    12, // llvm.nvvm.wmma.m16n16k16.mma.col.row.f16.f16
+    12, // llvm.nvvm.wmma.m16n16k16.mma.col.row.f16.f16.satfinite
+    12, // llvm.nvvm.wmma.m16n16k16.mma.col.row.f16.f32
+    12, // llvm.nvvm.wmma.m16n16k16.mma.col.row.f16.f32.satfinite
+    12, // llvm.nvvm.wmma.m16n16k16.mma.col.row.f32.f16
+    12, // llvm.nvvm.wmma.m16n16k16.mma.col.row.f32.f16.satfinite
+    12, // llvm.nvvm.wmma.m16n16k16.mma.col.row.f32.f32
+    12, // llvm.nvvm.wmma.m16n16k16.mma.col.row.f32.f32.satfinite
+    12, // llvm.nvvm.wmma.m16n16k16.mma.col.row.s8
+    12, // llvm.nvvm.wmma.m16n16k16.mma.col.row.s8.satfinite
+    12, // llvm.nvvm.wmma.m16n16k16.mma.col.row.u8
+    12, // llvm.nvvm.wmma.m16n16k16.mma.col.row.u8.satfinite
+    12, // llvm.nvvm.wmma.m16n16k16.mma.row.col.f16.f16
+    12, // llvm.nvvm.wmma.m16n16k16.mma.row.col.f16.f16.satfinite
+    12, // llvm.nvvm.wmma.m16n16k16.mma.row.col.f16.f32
+    12, // llvm.nvvm.wmma.m16n16k16.mma.row.col.f16.f32.satfinite
+    12, // llvm.nvvm.wmma.m16n16k16.mma.row.col.f32.f16
+    12, // llvm.nvvm.wmma.m16n16k16.mma.row.col.f32.f16.satfinite
+    12, // llvm.nvvm.wmma.m16n16k16.mma.row.col.f32.f32
+    12, // llvm.nvvm.wmma.m16n16k16.mma.row.col.f32.f32.satfinite
+    12, // llvm.nvvm.wmma.m16n16k16.mma.row.col.s8
+    12, // llvm.nvvm.wmma.m16n16k16.mma.row.col.s8.satfinite
+    12, // llvm.nvvm.wmma.m16n16k16.mma.row.col.u8
+    12, // llvm.nvvm.wmma.m16n16k16.mma.row.col.u8.satfinite
+    12, // llvm.nvvm.wmma.m16n16k16.mma.row.row.f16.f16
+    12, // llvm.nvvm.wmma.m16n16k16.mma.row.row.f16.f16.satfinite
+    12, // llvm.nvvm.wmma.m16n16k16.mma.row.row.f16.f32
+    12, // llvm.nvvm.wmma.m16n16k16.mma.row.row.f16.f32.satfinite
+    12, // llvm.nvvm.wmma.m16n16k16.mma.row.row.f32.f16
+    12, // llvm.nvvm.wmma.m16n16k16.mma.row.row.f32.f16.satfinite
+    12, // llvm.nvvm.wmma.m16n16k16.mma.row.row.f32.f32
+    12, // llvm.nvvm.wmma.m16n16k16.mma.row.row.f32.f32.satfinite
+    12, // llvm.nvvm.wmma.m16n16k16.mma.row.row.s8
+    12, // llvm.nvvm.wmma.m16n16k16.mma.row.row.s8.satfinite
+    12, // llvm.nvvm.wmma.m16n16k16.mma.row.row.u8
+    12, // llvm.nvvm.wmma.m16n16k16.mma.row.row.u8.satfinite
+    68, // llvm.nvvm.wmma.m16n16k16.store.d.col.f16
+    68, // llvm.nvvm.wmma.m16n16k16.store.d.col.f32
+    68, // llvm.nvvm.wmma.m16n16k16.store.d.col.s32
+    68, // llvm.nvvm.wmma.m16n16k16.store.d.col.stride.f16
+    68, // llvm.nvvm.wmma.m16n16k16.store.d.col.stride.f32
+    68, // llvm.nvvm.wmma.m16n16k16.store.d.col.stride.s32
+    68, // llvm.nvvm.wmma.m16n16k16.store.d.row.f16
+    68, // llvm.nvvm.wmma.m16n16k16.store.d.row.f32
+    68, // llvm.nvvm.wmma.m16n16k16.store.d.row.s32
+    68, // llvm.nvvm.wmma.m16n16k16.store.d.row.stride.f16
+    68, // llvm.nvvm.wmma.m16n16k16.store.d.row.stride.f32
+    68, // llvm.nvvm.wmma.m16n16k16.store.d.row.stride.s32
+    17, // llvm.nvvm.wmma.m32n8k16.load.a.col.f16
+    17, // llvm.nvvm.wmma.m32n8k16.load.a.col.s8
+    17, // llvm.nvvm.wmma.m32n8k16.load.a.col.stride.f16
+    17, // llvm.nvvm.wmma.m32n8k16.load.a.col.stride.s8
+    17, // llvm.nvvm.wmma.m32n8k16.load.a.col.stride.u8
+    17, // llvm.nvvm.wmma.m32n8k16.load.a.col.u8
+    17, // llvm.nvvm.wmma.m32n8k16.load.a.row.f16
+    17, // llvm.nvvm.wmma.m32n8k16.load.a.row.s8
+    17, // llvm.nvvm.wmma.m32n8k16.load.a.row.stride.f16
+    17, // llvm.nvvm.wmma.m32n8k16.load.a.row.stride.s8
+    17, // llvm.nvvm.wmma.m32n8k16.load.a.row.stride.u8
+    17, // llvm.nvvm.wmma.m32n8k16.load.a.row.u8
+    17, // llvm.nvvm.wmma.m32n8k16.load.b.col.f16
+    17, // llvm.nvvm.wmma.m32n8k16.load.b.col.s8
+    17, // llvm.nvvm.wmma.m32n8k16.load.b.col.stride.f16
+    17, // llvm.nvvm.wmma.m32n8k16.load.b.col.stride.s8
+    17, // llvm.nvvm.wmma.m32n8k16.load.b.col.stride.u8
+    17, // llvm.nvvm.wmma.m32n8k16.load.b.col.u8
+    17, // llvm.nvvm.wmma.m32n8k16.load.b.row.f16
+    17, // llvm.nvvm.wmma.m32n8k16.load.b.row.s8
+    17, // llvm.nvvm.wmma.m32n8k16.load.b.row.stride.f16
+    17, // llvm.nvvm.wmma.m32n8k16.load.b.row.stride.s8
+    17, // llvm.nvvm.wmma.m32n8k16.load.b.row.stride.u8
+    17, // llvm.nvvm.wmma.m32n8k16.load.b.row.u8
+    17, // llvm.nvvm.wmma.m32n8k16.load.c.col.f16
+    17, // llvm.nvvm.wmma.m32n8k16.load.c.col.f32
+    17, // llvm.nvvm.wmma.m32n8k16.load.c.col.s32
+    17, // llvm.nvvm.wmma.m32n8k16.load.c.col.stride.f16
+    17, // llvm.nvvm.wmma.m32n8k16.load.c.col.stride.f32
+    17, // llvm.nvvm.wmma.m32n8k16.load.c.col.stride.s32
+    17, // llvm.nvvm.wmma.m32n8k16.load.c.row.f16
+    17, // llvm.nvvm.wmma.m32n8k16.load.c.row.f32
+    17, // llvm.nvvm.wmma.m32n8k16.load.c.row.s32
+    17, // llvm.nvvm.wmma.m32n8k16.load.c.row.stride.f16
+    17, // llvm.nvvm.wmma.m32n8k16.load.c.row.stride.f32
+    17, // llvm.nvvm.wmma.m32n8k16.load.c.row.stride.s32
+    12, // llvm.nvvm.wmma.m32n8k16.mma.col.col.f16.f16
+    12, // llvm.nvvm.wmma.m32n8k16.mma.col.col.f16.f16.satfinite
+    12, // llvm.nvvm.wmma.m32n8k16.mma.col.col.f16.f32
+    12, // llvm.nvvm.wmma.m32n8k16.mma.col.col.f16.f32.satfinite
+    12, // llvm.nvvm.wmma.m32n8k16.mma.col.col.f32.f16
+    12, // llvm.nvvm.wmma.m32n8k16.mma.col.col.f32.f16.satfinite
+    12, // llvm.nvvm.wmma.m32n8k16.mma.col.col.f32.f32
+    12, // llvm.nvvm.wmma.m32n8k16.mma.col.col.f32.f32.satfinite
+    12, // llvm.nvvm.wmma.m32n8k16.mma.col.col.s8
+    12, // llvm.nvvm.wmma.m32n8k16.mma.col.col.s8.satfinite
+    12, // llvm.nvvm.wmma.m32n8k16.mma.col.col.u8
+    12, // llvm.nvvm.wmma.m32n8k16.mma.col.col.u8.satfinite
+    12, // llvm.nvvm.wmma.m32n8k16.mma.col.row.f16.f16
+    12, // llvm.nvvm.wmma.m32n8k16.mma.col.row.f16.f16.satfinite
+    12, // llvm.nvvm.wmma.m32n8k16.mma.col.row.f16.f32
+    12, // llvm.nvvm.wmma.m32n8k16.mma.col.row.f16.f32.satfinite
+    12, // llvm.nvvm.wmma.m32n8k16.mma.col.row.f32.f16
+    12, // llvm.nvvm.wmma.m32n8k16.mma.col.row.f32.f16.satfinite
+    12, // llvm.nvvm.wmma.m32n8k16.mma.col.row.f32.f32
+    12, // llvm.nvvm.wmma.m32n8k16.mma.col.row.f32.f32.satfinite
+    12, // llvm.nvvm.wmma.m32n8k16.mma.col.row.s8
+    12, // llvm.nvvm.wmma.m32n8k16.mma.col.row.s8.satfinite
+    12, // llvm.nvvm.wmma.m32n8k16.mma.col.row.u8
+    12, // llvm.nvvm.wmma.m32n8k16.mma.col.row.u8.satfinite
+    12, // llvm.nvvm.wmma.m32n8k16.mma.row.col.f16.f16
+    12, // llvm.nvvm.wmma.m32n8k16.mma.row.col.f16.f16.satfinite
+    12, // llvm.nvvm.wmma.m32n8k16.mma.row.col.f16.f32
+    12, // llvm.nvvm.wmma.m32n8k16.mma.row.col.f16.f32.satfinite
+    12, // llvm.nvvm.wmma.m32n8k16.mma.row.col.f32.f16
+    12, // llvm.nvvm.wmma.m32n8k16.mma.row.col.f32.f16.satfinite
+    12, // llvm.nvvm.wmma.m32n8k16.mma.row.col.f32.f32
+    12, // llvm.nvvm.wmma.m32n8k16.mma.row.col.f32.f32.satfinite
+    12, // llvm.nvvm.wmma.m32n8k16.mma.row.col.s8
+    12, // llvm.nvvm.wmma.m32n8k16.mma.row.col.s8.satfinite
+    12, // llvm.nvvm.wmma.m32n8k16.mma.row.col.u8
+    12, // llvm.nvvm.wmma.m32n8k16.mma.row.col.u8.satfinite
+    12, // llvm.nvvm.wmma.m32n8k16.mma.row.row.f16.f16
+    12, // llvm.nvvm.wmma.m32n8k16.mma.row.row.f16.f16.satfinite
+    12, // llvm.nvvm.wmma.m32n8k16.mma.row.row.f16.f32
+    12, // llvm.nvvm.wmma.m32n8k16.mma.row.row.f16.f32.satfinite
+    12, // llvm.nvvm.wmma.m32n8k16.mma.row.row.f32.f16
+    12, // llvm.nvvm.wmma.m32n8k16.mma.row.row.f32.f16.satfinite
+    12, // llvm.nvvm.wmma.m32n8k16.mma.row.row.f32.f32
+    12, // llvm.nvvm.wmma.m32n8k16.mma.row.row.f32.f32.satfinite
+    12, // llvm.nvvm.wmma.m32n8k16.mma.row.row.s8
+    12, // llvm.nvvm.wmma.m32n8k16.mma.row.row.s8.satfinite
+    12, // llvm.nvvm.wmma.m32n8k16.mma.row.row.u8
+    12, // llvm.nvvm.wmma.m32n8k16.mma.row.row.u8.satfinite
+    68, // llvm.nvvm.wmma.m32n8k16.store.d.col.f16
+    68, // llvm.nvvm.wmma.m32n8k16.store.d.col.f32
+    68, // llvm.nvvm.wmma.m32n8k16.store.d.col.s32
+    68, // llvm.nvvm.wmma.m32n8k16.store.d.col.stride.f16
+    68, // llvm.nvvm.wmma.m32n8k16.store.d.col.stride.f32
+    68, // llvm.nvvm.wmma.m32n8k16.store.d.col.stride.s32
+    68, // llvm.nvvm.wmma.m32n8k16.store.d.row.f16
+    68, // llvm.nvvm.wmma.m32n8k16.store.d.row.f32
+    68, // llvm.nvvm.wmma.m32n8k16.store.d.row.s32
+    68, // llvm.nvvm.wmma.m32n8k16.store.d.row.stride.f16
+    68, // llvm.nvvm.wmma.m32n8k16.store.d.row.stride.f32
+    68, // llvm.nvvm.wmma.m32n8k16.store.d.row.stride.s32
+    17, // llvm.nvvm.wmma.m8n32k16.load.a.col.f16
+    17, // llvm.nvvm.wmma.m8n32k16.load.a.col.s8
+    17, // llvm.nvvm.wmma.m8n32k16.load.a.col.stride.f16
+    17, // llvm.nvvm.wmma.m8n32k16.load.a.col.stride.s8
+    17, // llvm.nvvm.wmma.m8n32k16.load.a.col.stride.u8
+    17, // llvm.nvvm.wmma.m8n32k16.load.a.col.u8
+    17, // llvm.nvvm.wmma.m8n32k16.load.a.row.f16
+    17, // llvm.nvvm.wmma.m8n32k16.load.a.row.s8
+    17, // llvm.nvvm.wmma.m8n32k16.load.a.row.stride.f16
+    17, // llvm.nvvm.wmma.m8n32k16.load.a.row.stride.s8
+    17, // llvm.nvvm.wmma.m8n32k16.load.a.row.stride.u8
+    17, // llvm.nvvm.wmma.m8n32k16.load.a.row.u8
+    17, // llvm.nvvm.wmma.m8n32k16.load.b.col.f16
+    17, // llvm.nvvm.wmma.m8n32k16.load.b.col.s8
+    17, // llvm.nvvm.wmma.m8n32k16.load.b.col.stride.f16
+    17, // llvm.nvvm.wmma.m8n32k16.load.b.col.stride.s8
+    17, // llvm.nvvm.wmma.m8n32k16.load.b.col.stride.u8
+    17, // llvm.nvvm.wmma.m8n32k16.load.b.col.u8
+    17, // llvm.nvvm.wmma.m8n32k16.load.b.row.f16
+    17, // llvm.nvvm.wmma.m8n32k16.load.b.row.s8
+    17, // llvm.nvvm.wmma.m8n32k16.load.b.row.stride.f16
+    17, // llvm.nvvm.wmma.m8n32k16.load.b.row.stride.s8
+    17, // llvm.nvvm.wmma.m8n32k16.load.b.row.stride.u8
+    17, // llvm.nvvm.wmma.m8n32k16.load.b.row.u8
+    17, // llvm.nvvm.wmma.m8n32k16.load.c.col.f16
+    17, // llvm.nvvm.wmma.m8n32k16.load.c.col.f32
+    17, // llvm.nvvm.wmma.m8n32k16.load.c.col.s32
+    17, // llvm.nvvm.wmma.m8n32k16.load.c.col.stride.f16
+    17, // llvm.nvvm.wmma.m8n32k16.load.c.col.stride.f32
+    17, // llvm.nvvm.wmma.m8n32k16.load.c.col.stride.s32
+    17, // llvm.nvvm.wmma.m8n32k16.load.c.row.f16
+    17, // llvm.nvvm.wmma.m8n32k16.load.c.row.f32
+    17, // llvm.nvvm.wmma.m8n32k16.load.c.row.s32
+    17, // llvm.nvvm.wmma.m8n32k16.load.c.row.stride.f16
+    17, // llvm.nvvm.wmma.m8n32k16.load.c.row.stride.f32
+    17, // llvm.nvvm.wmma.m8n32k16.load.c.row.stride.s32
+    12, // llvm.nvvm.wmma.m8n32k16.mma.col.col.f16.f16
+    12, // llvm.nvvm.wmma.m8n32k16.mma.col.col.f16.f16.satfinite
+    12, // llvm.nvvm.wmma.m8n32k16.mma.col.col.f16.f32
+    12, // llvm.nvvm.wmma.m8n32k16.mma.col.col.f16.f32.satfinite
+    12, // llvm.nvvm.wmma.m8n32k16.mma.col.col.f32.f16
+    12, // llvm.nvvm.wmma.m8n32k16.mma.col.col.f32.f16.satfinite
+    12, // llvm.nvvm.wmma.m8n32k16.mma.col.col.f32.f32
+    12, // llvm.nvvm.wmma.m8n32k16.mma.col.col.f32.f32.satfinite
+    12, // llvm.nvvm.wmma.m8n32k16.mma.col.col.s8
+    12, // llvm.nvvm.wmma.m8n32k16.mma.col.col.s8.satfinite
+    12, // llvm.nvvm.wmma.m8n32k16.mma.col.col.u8
+    12, // llvm.nvvm.wmma.m8n32k16.mma.col.col.u8.satfinite
+    12, // llvm.nvvm.wmma.m8n32k16.mma.col.row.f16.f16
+    12, // llvm.nvvm.wmma.m8n32k16.mma.col.row.f16.f16.satfinite
+    12, // llvm.nvvm.wmma.m8n32k16.mma.col.row.f16.f32
+    12, // llvm.nvvm.wmma.m8n32k16.mma.col.row.f16.f32.satfinite
+    12, // llvm.nvvm.wmma.m8n32k16.mma.col.row.f32.f16
+    12, // llvm.nvvm.wmma.m8n32k16.mma.col.row.f32.f16.satfinite
+    12, // llvm.nvvm.wmma.m8n32k16.mma.col.row.f32.f32
+    12, // llvm.nvvm.wmma.m8n32k16.mma.col.row.f32.f32.satfinite
+    12, // llvm.nvvm.wmma.m8n32k16.mma.col.row.s8
+    12, // llvm.nvvm.wmma.m8n32k16.mma.col.row.s8.satfinite
+    12, // llvm.nvvm.wmma.m8n32k16.mma.col.row.u8
+    12, // llvm.nvvm.wmma.m8n32k16.mma.col.row.u8.satfinite
+    12, // llvm.nvvm.wmma.m8n32k16.mma.row.col.f16.f16
+    12, // llvm.nvvm.wmma.m8n32k16.mma.row.col.f16.f16.satfinite
+    12, // llvm.nvvm.wmma.m8n32k16.mma.row.col.f16.f32
+    12, // llvm.nvvm.wmma.m8n32k16.mma.row.col.f16.f32.satfinite
+    12, // llvm.nvvm.wmma.m8n32k16.mma.row.col.f32.f16
+    12, // llvm.nvvm.wmma.m8n32k16.mma.row.col.f32.f16.satfinite
+    12, // llvm.nvvm.wmma.m8n32k16.mma.row.col.f32.f32
+    12, // llvm.nvvm.wmma.m8n32k16.mma.row.col.f32.f32.satfinite
+    12, // llvm.nvvm.wmma.m8n32k16.mma.row.col.s8
+    12, // llvm.nvvm.wmma.m8n32k16.mma.row.col.s8.satfinite
+    12, // llvm.nvvm.wmma.m8n32k16.mma.row.col.u8
+    12, // llvm.nvvm.wmma.m8n32k16.mma.row.col.u8.satfinite
+    12, // llvm.nvvm.wmma.m8n32k16.mma.row.row.f16.f16
+    12, // llvm.nvvm.wmma.m8n32k16.mma.row.row.f16.f16.satfinite
+    12, // llvm.nvvm.wmma.m8n32k16.mma.row.row.f16.f32
+    12, // llvm.nvvm.wmma.m8n32k16.mma.row.row.f16.f32.satfinite
+    12, // llvm.nvvm.wmma.m8n32k16.mma.row.row.f32.f16
+    12, // llvm.nvvm.wmma.m8n32k16.mma.row.row.f32.f16.satfinite
+    12, // llvm.nvvm.wmma.m8n32k16.mma.row.row.f32.f32
+    12, // llvm.nvvm.wmma.m8n32k16.mma.row.row.f32.f32.satfinite
+    12, // llvm.nvvm.wmma.m8n32k16.mma.row.row.s8
+    12, // llvm.nvvm.wmma.m8n32k16.mma.row.row.s8.satfinite
+    12, // llvm.nvvm.wmma.m8n32k16.mma.row.row.u8
+    12, // llvm.nvvm.wmma.m8n32k16.mma.row.row.u8.satfinite
+    68, // llvm.nvvm.wmma.m8n32k16.store.d.col.f16
+    68, // llvm.nvvm.wmma.m8n32k16.store.d.col.f32
+    68, // llvm.nvvm.wmma.m8n32k16.store.d.col.s32
+    68, // llvm.nvvm.wmma.m8n32k16.store.d.col.stride.f16
+    68, // llvm.nvvm.wmma.m8n32k16.store.d.col.stride.f32
+    68, // llvm.nvvm.wmma.m8n32k16.store.d.col.stride.s32
+    68, // llvm.nvvm.wmma.m8n32k16.store.d.row.f16
+    68, // llvm.nvvm.wmma.m8n32k16.store.d.row.f32
+    68, // llvm.nvvm.wmma.m8n32k16.store.d.row.s32
+    68, // llvm.nvvm.wmma.m8n32k16.store.d.row.stride.f16
+    68, // llvm.nvvm.wmma.m8n32k16.store.d.row.stride.f32
+    68, // llvm.nvvm.wmma.m8n32k16.store.d.row.stride.s32
+    17, // llvm.nvvm.wmma.m8n8k128.load.a.row.b1
+    17, // llvm.nvvm.wmma.m8n8k128.load.a.row.stride.b1
+    17, // llvm.nvvm.wmma.m8n8k128.load.b.col.b1
+    17, // llvm.nvvm.wmma.m8n8k128.load.b.col.stride.b1
+    17, // llvm.nvvm.wmma.m8n8k128.load.c.col.s32
+    17, // llvm.nvvm.wmma.m8n8k128.load.c.col.stride.s32
+    17, // llvm.nvvm.wmma.m8n8k128.load.c.row.s32
+    17, // llvm.nvvm.wmma.m8n8k128.load.c.row.stride.s32
+    12, // llvm.nvvm.wmma.m8n8k128.mma.row.col.b1
+    68, // llvm.nvvm.wmma.m8n8k128.store.d.col.s32
+    68, // llvm.nvvm.wmma.m8n8k128.store.d.col.stride.s32
+    68, // llvm.nvvm.wmma.m8n8k128.store.d.row.s32
+    68, // llvm.nvvm.wmma.m8n8k128.store.d.row.stride.s32
+    17, // llvm.nvvm.wmma.m8n8k32.load.a.row.s4
+    17, // llvm.nvvm.wmma.m8n8k32.load.a.row.stride.s4
+    17, // llvm.nvvm.wmma.m8n8k32.load.a.row.stride.u4
+    17, // llvm.nvvm.wmma.m8n8k32.load.a.row.u4
+    17, // llvm.nvvm.wmma.m8n8k32.load.b.col.s4
+    17, // llvm.nvvm.wmma.m8n8k32.load.b.col.stride.s4
+    17, // llvm.nvvm.wmma.m8n8k32.load.b.col.stride.u4
+    17, // llvm.nvvm.wmma.m8n8k32.load.b.col.u4
+    17, // llvm.nvvm.wmma.m8n8k32.load.c.col.s32
+    17, // llvm.nvvm.wmma.m8n8k32.load.c.col.stride.s32
+    17, // llvm.nvvm.wmma.m8n8k32.load.c.row.s32
+    17, // llvm.nvvm.wmma.m8n8k32.load.c.row.stride.s32
+    12, // llvm.nvvm.wmma.m8n8k32.mma.row.col.s4
+    12, // llvm.nvvm.wmma.m8n8k32.mma.row.col.s4.satfinite
+    12, // llvm.nvvm.wmma.m8n8k32.mma.row.col.u4
+    12, // llvm.nvvm.wmma.m8n8k32.mma.row.col.u4.satfinite
+    68, // llvm.nvvm.wmma.m8n8k32.store.d.col.s32
+    68, // llvm.nvvm.wmma.m8n8k32.store.d.col.stride.s32
+    68, // llvm.nvvm.wmma.m8n8k32.store.d.row.s32
+    68, // llvm.nvvm.wmma.m8n8k32.store.d.row.stride.s32
+    12, // llvm.ppc.addf128.round.to.odd
+    12, // llvm.ppc.altivec.crypto.vcipher
+    12, // llvm.ppc.altivec.crypto.vcipherlast
+    12, // llvm.ppc.altivec.crypto.vncipher
+    12, // llvm.ppc.altivec.crypto.vncipherlast
+    12, // llvm.ppc.altivec.crypto.vpermxor
+    12, // llvm.ppc.altivec.crypto.vpmsumb
+    12, // llvm.ppc.altivec.crypto.vpmsumd
+    12, // llvm.ppc.altivec.crypto.vpmsumh
+    12, // llvm.ppc.altivec.crypto.vpmsumw
+    12, // llvm.ppc.altivec.crypto.vsbox
+    79, // llvm.ppc.altivec.crypto.vshasigmad
+    79, // llvm.ppc.altivec.crypto.vshasigmaw
+    7, // llvm.ppc.altivec.dss
+    7, // llvm.ppc.altivec.dssall
+    7, // llvm.ppc.altivec.dst
+    7, // llvm.ppc.altivec.dstst
+    7, // llvm.ppc.altivec.dststt
+    7, // llvm.ppc.altivec.dstt
+    3, // llvm.ppc.altivec.lvebx
+    3, // llvm.ppc.altivec.lvehx
+    3, // llvm.ppc.altivec.lvewx
+    12, // llvm.ppc.altivec.lvsl
+    12, // llvm.ppc.altivec.lvsr
+    3, // llvm.ppc.altivec.lvx
+    3, // llvm.ppc.altivec.lvxl
+    63, // llvm.ppc.altivec.mfvscr
+    63, // llvm.ppc.altivec.mtvscr
+    12, // llvm.ppc.altivec.mtvsrbm
+    12, // llvm.ppc.altivec.mtvsrdm
+    12, // llvm.ppc.altivec.mtvsrhm
+    12, // llvm.ppc.altivec.mtvsrqm
+    12, // llvm.ppc.altivec.mtvsrwm
+    80, // llvm.ppc.altivec.stvebx
+    80, // llvm.ppc.altivec.stvehx
+    80, // llvm.ppc.altivec.stvewx
+    80, // llvm.ppc.altivec.stvx
+    80, // llvm.ppc.altivec.stvxl
+    12, // llvm.ppc.altivec.vabsdub
+    12, // llvm.ppc.altivec.vabsduh
+    12, // llvm.ppc.altivec.vabsduw
+    12, // llvm.ppc.altivec.vaddcuq
+    12, // llvm.ppc.altivec.vaddcuw
+    12, // llvm.ppc.altivec.vaddecuq
+    12, // llvm.ppc.altivec.vaddeuqm
+    12, // llvm.ppc.altivec.vaddsbs
+    12, // llvm.ppc.altivec.vaddshs
+    12, // llvm.ppc.altivec.vaddsws
+    12, // llvm.ppc.altivec.vaddubs
+    12, // llvm.ppc.altivec.vadduhs
+    12, // llvm.ppc.altivec.vadduws
+    12, // llvm.ppc.altivec.vavgsb
+    12, // llvm.ppc.altivec.vavgsh
+    12, // llvm.ppc.altivec.vavgsw
+    12, // llvm.ppc.altivec.vavgub
+    12, // llvm.ppc.altivec.vavguh
+    12, // llvm.ppc.altivec.vavguw
+    12, // llvm.ppc.altivec.vbpermq
+    78, // llvm.ppc.altivec.vcfsx
+    12, // llvm.ppc.altivec.vcfuged
+    78, // llvm.ppc.altivec.vcfux
+    12, // llvm.ppc.altivec.vclrlb
+    12, // llvm.ppc.altivec.vclrrb
+    12, // llvm.ppc.altivec.vclzdm
+    12, // llvm.ppc.altivec.vclzlsbb
+    12, // llvm.ppc.altivec.vcmpbfp
+    12, // llvm.ppc.altivec.vcmpbfp.p
+    12, // llvm.ppc.altivec.vcmpeqfp
+    12, // llvm.ppc.altivec.vcmpeqfp.p
+    12, // llvm.ppc.altivec.vcmpequb
+    12, // llvm.ppc.altivec.vcmpequb.p
+    12, // llvm.ppc.altivec.vcmpequd
+    12, // llvm.ppc.altivec.vcmpequd.p
+    12, // llvm.ppc.altivec.vcmpequh
+    12, // llvm.ppc.altivec.vcmpequh.p
+    12, // llvm.ppc.altivec.vcmpequq
+    12, // llvm.ppc.altivec.vcmpequq.p
+    12, // llvm.ppc.altivec.vcmpequw
+    12, // llvm.ppc.altivec.vcmpequw.p
+    12, // llvm.ppc.altivec.vcmpgefp
+    12, // llvm.ppc.altivec.vcmpgefp.p
+    12, // llvm.ppc.altivec.vcmpgtfp
+    12, // llvm.ppc.altivec.vcmpgtfp.p
+    12, // llvm.ppc.altivec.vcmpgtsb
+    12, // llvm.ppc.altivec.vcmpgtsb.p
+    12, // llvm.ppc.altivec.vcmpgtsd
+    12, // llvm.ppc.altivec.vcmpgtsd.p
+    12, // llvm.ppc.altivec.vcmpgtsh
+    12, // llvm.ppc.altivec.vcmpgtsh.p
+    12, // llvm.ppc.altivec.vcmpgtsq
+    12, // llvm.ppc.altivec.vcmpgtsq.p
+    12, // llvm.ppc.altivec.vcmpgtsw
+    12, // llvm.ppc.altivec.vcmpgtsw.p
+    12, // llvm.ppc.altivec.vcmpgtub
+    12, // llvm.ppc.altivec.vcmpgtub.p
+    12, // llvm.ppc.altivec.vcmpgtud
+    12, // llvm.ppc.altivec.vcmpgtud.p
+    12, // llvm.ppc.altivec.vcmpgtuh
+    12, // llvm.ppc.altivec.vcmpgtuh.p
+    12, // llvm.ppc.altivec.vcmpgtuq
+    12, // llvm.ppc.altivec.vcmpgtuq.p
+    12, // llvm.ppc.altivec.vcmpgtuw
+    12, // llvm.ppc.altivec.vcmpgtuw.p
+    12, // llvm.ppc.altivec.vcmpneb
+    12, // llvm.ppc.altivec.vcmpneb.p
+    12, // llvm.ppc.altivec.vcmpneh
+    12, // llvm.ppc.altivec.vcmpneh.p
+    12, // llvm.ppc.altivec.vcmpnew
+    12, // llvm.ppc.altivec.vcmpnew.p
+    12, // llvm.ppc.altivec.vcmpnezb
+    12, // llvm.ppc.altivec.vcmpnezb.p
+    12, // llvm.ppc.altivec.vcmpnezh
+    12, // llvm.ppc.altivec.vcmpnezh.p
+    12, // llvm.ppc.altivec.vcmpnezw
+    12, // llvm.ppc.altivec.vcmpnezw.p
+    78, // llvm.ppc.altivec.vcntmbb
+    78, // llvm.ppc.altivec.vcntmbd
+    78, // llvm.ppc.altivec.vcntmbh
+    78, // llvm.ppc.altivec.vcntmbw
+    78, // llvm.ppc.altivec.vctsxs
+    78, // llvm.ppc.altivec.vctuxs
+    12, // llvm.ppc.altivec.vctzdm
+    12, // llvm.ppc.altivec.vctzlsbb
+    12, // llvm.ppc.altivec.vdivesd
+    12, // llvm.ppc.altivec.vdivesq
+    12, // llvm.ppc.altivec.vdivesw
+    12, // llvm.ppc.altivec.vdiveud
+    12, // llvm.ppc.altivec.vdiveuq
+    12, // llvm.ppc.altivec.vdiveuw
+    12, // llvm.ppc.altivec.vexpandbm
+    12, // llvm.ppc.altivec.vexpanddm
+    12, // llvm.ppc.altivec.vexpandhm
+    12, // llvm.ppc.altivec.vexpandqm
+    12, // llvm.ppc.altivec.vexpandwm
+    12, // llvm.ppc.altivec.vexptefp
+    12, // llvm.ppc.altivec.vextddvlx
+    12, // llvm.ppc.altivec.vextddvrx
+    12, // llvm.ppc.altivec.vextdubvlx
+    12, // llvm.ppc.altivec.vextdubvrx
+    12, // llvm.ppc.altivec.vextduhvlx
+    12, // llvm.ppc.altivec.vextduhvrx
+    12, // llvm.ppc.altivec.vextduwvlx
+    12, // llvm.ppc.altivec.vextduwvrx
+    12, // llvm.ppc.altivec.vextractbm
+    12, // llvm.ppc.altivec.vextractdm
+    12, // llvm.ppc.altivec.vextracthm
+    12, // llvm.ppc.altivec.vextractqm
+    12, // llvm.ppc.altivec.vextractwm
+    12, // llvm.ppc.altivec.vextsb2d
+    12, // llvm.ppc.altivec.vextsb2w
+    12, // llvm.ppc.altivec.vextsd2q
+    12, // llvm.ppc.altivec.vextsh2d
+    12, // llvm.ppc.altivec.vextsh2w
+    12, // llvm.ppc.altivec.vextsw2d
+    12, // llvm.ppc.altivec.vgbbd
+    78, // llvm.ppc.altivec.vgnb
+    12, // llvm.ppc.altivec.vinsblx
+    12, // llvm.ppc.altivec.vinsbrx
+    12, // llvm.ppc.altivec.vinsbvlx
+    12, // llvm.ppc.altivec.vinsbvrx
+    70, // llvm.ppc.altivec.vinsd
+    12, // llvm.ppc.altivec.vinsdlx
+    12, // llvm.ppc.altivec.vinsdrx
+    12, // llvm.ppc.altivec.vinshlx
+    12, // llvm.ppc.altivec.vinshrx
+    12, // llvm.ppc.altivec.vinshvlx
+    12, // llvm.ppc.altivec.vinshvrx
+    70, // llvm.ppc.altivec.vinsw
+    12, // llvm.ppc.altivec.vinswlx
+    12, // llvm.ppc.altivec.vinswrx
+    12, // llvm.ppc.altivec.vinswvlx
+    12, // llvm.ppc.altivec.vinswvrx
+    12, // llvm.ppc.altivec.vlogefp
+    12, // llvm.ppc.altivec.vmaddfp
+    12, // llvm.ppc.altivec.vmaxfp
+    12, // llvm.ppc.altivec.vmaxsb
+    12, // llvm.ppc.altivec.vmaxsd
+    12, // llvm.ppc.altivec.vmaxsh
+    12, // llvm.ppc.altivec.vmaxsw
+    12, // llvm.ppc.altivec.vmaxub
+    12, // llvm.ppc.altivec.vmaxud
+    12, // llvm.ppc.altivec.vmaxuh
+    12, // llvm.ppc.altivec.vmaxuw
+    63, // llvm.ppc.altivec.vmhaddshs
+    63, // llvm.ppc.altivec.vmhraddshs
+    12, // llvm.ppc.altivec.vminfp
+    12, // llvm.ppc.altivec.vminsb
+    12, // llvm.ppc.altivec.vminsd
+    12, // llvm.ppc.altivec.vminsh
+    12, // llvm.ppc.altivec.vminsw
+    12, // llvm.ppc.altivec.vminub
+    12, // llvm.ppc.altivec.vminud
+    12, // llvm.ppc.altivec.vminuh
+    12, // llvm.ppc.altivec.vminuw
+    12, // llvm.ppc.altivec.vmladduhm
+    12, // llvm.ppc.altivec.vmsumcud
+    12, // llvm.ppc.altivec.vmsummbm
+    12, // llvm.ppc.altivec.vmsumshm
+    63, // llvm.ppc.altivec.vmsumshs
+    12, // llvm.ppc.altivec.vmsumubm
+    12, // llvm.ppc.altivec.vmsumudm
+    12, // llvm.ppc.altivec.vmsumuhm
+    63, // llvm.ppc.altivec.vmsumuhs
+    12, // llvm.ppc.altivec.vmulesb
+    12, // llvm.ppc.altivec.vmulesd
+    12, // llvm.ppc.altivec.vmulesh
+    12, // llvm.ppc.altivec.vmulesw
+    12, // llvm.ppc.altivec.vmuleub
+    12, // llvm.ppc.altivec.vmuleud
+    12, // llvm.ppc.altivec.vmuleuh
+    12, // llvm.ppc.altivec.vmuleuw
+    12, // llvm.ppc.altivec.vmulhsd
+    12, // llvm.ppc.altivec.vmulhsw
+    12, // llvm.ppc.altivec.vmulhud
+    12, // llvm.ppc.altivec.vmulhuw
+    12, // llvm.ppc.altivec.vmulosb
+    12, // llvm.ppc.altivec.vmulosd
+    12, // llvm.ppc.altivec.vmulosh
+    12, // llvm.ppc.altivec.vmulosw
+    12, // llvm.ppc.altivec.vmuloub
+    12, // llvm.ppc.altivec.vmuloud
+    12, // llvm.ppc.altivec.vmulouh
+    12, // llvm.ppc.altivec.vmulouw
+    12, // llvm.ppc.altivec.vnmsubfp
+    12, // llvm.ppc.altivec.vpdepd
+    12, // llvm.ppc.altivec.vperm
+    12, // llvm.ppc.altivec.vpextd
+    12, // llvm.ppc.altivec.vpkpx
+    63, // llvm.ppc.altivec.vpksdss
+    63, // llvm.ppc.altivec.vpksdus
+    63, // llvm.ppc.altivec.vpkshss
+    63, // llvm.ppc.altivec.vpkshus
+    63, // llvm.ppc.altivec.vpkswss
+    63, // llvm.ppc.altivec.vpkswus
+    63, // llvm.ppc.altivec.vpkudus
+    63, // llvm.ppc.altivec.vpkuhus
+    63, // llvm.ppc.altivec.vpkuwus
+    12, // llvm.ppc.altivec.vprtybd
+    12, // llvm.ppc.altivec.vprtybq
+    12, // llvm.ppc.altivec.vprtybw
+    12, // llvm.ppc.altivec.vrefp
+    12, // llvm.ppc.altivec.vrfim
+    12, // llvm.ppc.altivec.vrfin
+    12, // llvm.ppc.altivec.vrfip
+    12, // llvm.ppc.altivec.vrfiz
+    12, // llvm.ppc.altivec.vrlb
+    12, // llvm.ppc.altivec.vrld
+    12, // llvm.ppc.altivec.vrldmi
+    12, // llvm.ppc.altivec.vrldnm
+    12, // llvm.ppc.altivec.vrlh
+    12, // llvm.ppc.altivec.vrlqmi
+    12, // llvm.ppc.altivec.vrlqnm
+    12, // llvm.ppc.altivec.vrlw
+    12, // llvm.ppc.altivec.vrlwmi
+    12, // llvm.ppc.altivec.vrlwnm
+    12, // llvm.ppc.altivec.vrsqrtefp
+    12, // llvm.ppc.altivec.vsel
+    12, // llvm.ppc.altivec.vsl
+    12, // llvm.ppc.altivec.vslb
+    70, // llvm.ppc.altivec.vsldbi
+    12, // llvm.ppc.altivec.vslh
+    12, // llvm.ppc.altivec.vslo
+    12, // llvm.ppc.altivec.vslv
+    12, // llvm.ppc.altivec.vslw
+    12, // llvm.ppc.altivec.vsr
+    12, // llvm.ppc.altivec.vsrab
+    12, // llvm.ppc.altivec.vsrah
+    12, // llvm.ppc.altivec.vsraw
+    12, // llvm.ppc.altivec.vsrb
+    70, // llvm.ppc.altivec.vsrdbi
+    12, // llvm.ppc.altivec.vsrh
+    12, // llvm.ppc.altivec.vsro
+    12, // llvm.ppc.altivec.vsrv
+    12, // llvm.ppc.altivec.vsrw
+    12, // llvm.ppc.altivec.vstribl
+    12, // llvm.ppc.altivec.vstribl.p
+    12, // llvm.ppc.altivec.vstribr
+    12, // llvm.ppc.altivec.vstribr.p
+    12, // llvm.ppc.altivec.vstrihl
+    12, // llvm.ppc.altivec.vstrihl.p
+    12, // llvm.ppc.altivec.vstrihr
+    12, // llvm.ppc.altivec.vstrihr.p
+    12, // llvm.ppc.altivec.vsubcuq
+    12, // llvm.ppc.altivec.vsubcuw
+    12, // llvm.ppc.altivec.vsubecuq
+    12, // llvm.ppc.altivec.vsubeuqm
+    12, // llvm.ppc.altivec.vsubsbs
+    12, // llvm.ppc.altivec.vsubshs
+    12, // llvm.ppc.altivec.vsubsws
+    12, // llvm.ppc.altivec.vsububs
+    12, // llvm.ppc.altivec.vsubuhs
+    12, // llvm.ppc.altivec.vsubuws
+    63, // llvm.ppc.altivec.vsum2sws
+    63, // llvm.ppc.altivec.vsum4sbs
+    63, // llvm.ppc.altivec.vsum4shs
+    63, // llvm.ppc.altivec.vsum4ubs
+    63, // llvm.ppc.altivec.vsumsws
+    12, // llvm.ppc.altivec.vupkhpx
+    12, // llvm.ppc.altivec.vupkhsb
+    12, // llvm.ppc.altivec.vupkhsh
+    12, // llvm.ppc.altivec.vupkhsw
+    12, // llvm.ppc.altivec.vupklpx
+    12, // llvm.ppc.altivec.vupklsb
+    12, // llvm.ppc.altivec.vupklsh
+    12, // llvm.ppc.altivec.vupklsw
+    12, // llvm.ppc.bpermd
+    7, // llvm.ppc.cfence
+    12, // llvm.ppc.cfuged
+    12, // llvm.ppc.cntlzdm
+    12, // llvm.ppc.cnttzdm
+    12, // llvm.ppc.darn
+    12, // llvm.ppc.darn32
+    12, // llvm.ppc.darnraw
+    7, // llvm.ppc.dcba
+    178, // llvm.ppc.dcbf
+    178, // llvm.ppc.dcbfl
+    178, // llvm.ppc.dcbflp
+    178, // llvm.ppc.dcbfps
+    7, // llvm.ppc.dcbi
+    7, // llvm.ppc.dcbst
+    178, // llvm.ppc.dcbstps
+    30, // llvm.ppc.dcbt
+    192, // llvm.ppc.dcbt.with.hint
+    30, // llvm.ppc.dcbtst
+    192, // llvm.ppc.dcbtst.with.hint
+    7, // llvm.ppc.dcbz
+    7, // llvm.ppc.dcbzl
+    12, // llvm.ppc.divde
+    12, // llvm.ppc.divdeu
+    12, // llvm.ppc.divf128.round.to.odd
+    12, // llvm.ppc.divwe
+    12, // llvm.ppc.divweu
+    7, // llvm.ppc.eieio
+    12, // llvm.ppc.fmaf128.round.to.odd
+    7, // llvm.ppc.get.texasr
+    7, // llvm.ppc.get.texasru
+    7, // llvm.ppc.get.tfhar
+    7, // llvm.ppc.get.tfiar
+    7, // llvm.ppc.isync
+    7, // llvm.ppc.lwsync
+    12, // llvm.ppc.mma.assemble.acc
+    12, // llvm.ppc.mma.disassemble.acc
+    12, // llvm.ppc.mma.pmxvbf16ger2
+    12, // llvm.ppc.mma.pmxvbf16ger2nn
+    12, // llvm.ppc.mma.pmxvbf16ger2np
+    12, // llvm.ppc.mma.pmxvbf16ger2pn
+    12, // llvm.ppc.mma.pmxvbf16ger2pp
+    12, // llvm.ppc.mma.pmxvf16ger2
+    12, // llvm.ppc.mma.pmxvf16ger2nn
+    12, // llvm.ppc.mma.pmxvf16ger2np
+    12, // llvm.ppc.mma.pmxvf16ger2pn
+    12, // llvm.ppc.mma.pmxvf16ger2pp
+    12, // llvm.ppc.mma.pmxvf32ger
+    12, // llvm.ppc.mma.pmxvf32gernn
+    12, // llvm.ppc.mma.pmxvf32gernp
+    12, // llvm.ppc.mma.pmxvf32gerpn
+    12, // llvm.ppc.mma.pmxvf32gerpp
+    12, // llvm.ppc.mma.pmxvf64ger
+    12, // llvm.ppc.mma.pmxvf64gernn
+    12, // llvm.ppc.mma.pmxvf64gernp
+    12, // llvm.ppc.mma.pmxvf64gerpn
+    12, // llvm.ppc.mma.pmxvf64gerpp
+    12, // llvm.ppc.mma.pmxvi16ger2
+    12, // llvm.ppc.mma.pmxvi16ger2pp
+    12, // llvm.ppc.mma.pmxvi16ger2s
+    12, // llvm.ppc.mma.pmxvi16ger2spp
+    12, // llvm.ppc.mma.pmxvi4ger8
+    12, // llvm.ppc.mma.pmxvi4ger8pp
+    12, // llvm.ppc.mma.pmxvi8ger4
+    12, // llvm.ppc.mma.pmxvi8ger4pp
+    12, // llvm.ppc.mma.pmxvi8ger4spp
+    12, // llvm.ppc.mma.xvbf16ger2
+    12, // llvm.ppc.mma.xvbf16ger2nn
+    12, // llvm.ppc.mma.xvbf16ger2np
+    12, // llvm.ppc.mma.xvbf16ger2pn
+    12, // llvm.ppc.mma.xvbf16ger2pp
+    12, // llvm.ppc.mma.xvf16ger2
+    12, // llvm.ppc.mma.xvf16ger2nn
+    12, // llvm.ppc.mma.xvf16ger2np
+    12, // llvm.ppc.mma.xvf16ger2pn
+    12, // llvm.ppc.mma.xvf16ger2pp
+    12, // llvm.ppc.mma.xvf32ger
+    12, // llvm.ppc.mma.xvf32gernn
+    12, // llvm.ppc.mma.xvf32gernp
+    12, // llvm.ppc.mma.xvf32gerpn
+    12, // llvm.ppc.mma.xvf32gerpp
+    12, // llvm.ppc.mma.xvf64ger
+    12, // llvm.ppc.mma.xvf64gernn
+    12, // llvm.ppc.mma.xvf64gernp
+    12, // llvm.ppc.mma.xvf64gerpn
+    12, // llvm.ppc.mma.xvf64gerpp
+    12, // llvm.ppc.mma.xvi16ger2
+    12, // llvm.ppc.mma.xvi16ger2pp
+    12, // llvm.ppc.mma.xvi16ger2s
+    12, // llvm.ppc.mma.xvi16ger2spp
+    12, // llvm.ppc.mma.xvi4ger8
+    12, // llvm.ppc.mma.xvi4ger8pp
+    12, // llvm.ppc.mma.xvi8ger4
+    12, // llvm.ppc.mma.xvi8ger4pp
+    12, // llvm.ppc.mma.xvi8ger4spp
+    12, // llvm.ppc.mma.xxmfacc
+    12, // llvm.ppc.mma.xxmtacc
+    12, // llvm.ppc.mma.xxsetaccz
+    12, // llvm.ppc.mulf128.round.to.odd
+    12, // llvm.ppc.pdepd
+    12, // llvm.ppc.pextd
+    12, // llvm.ppc.popcntb
+    12, // llvm.ppc.readflm
+    12, // llvm.ppc.scalar.extract.expq
+    12, // llvm.ppc.scalar.insert.exp.qp
+    7, // llvm.ppc.set.texasr
+    7, // llvm.ppc.set.texasru
+    7, // llvm.ppc.set.tfhar
+    7, // llvm.ppc.set.tfiar
+    7, // llvm.ppc.setflm
+    7, // llvm.ppc.setrnd
+    12, // llvm.ppc.sqrtf128.round.to.odd
+    12, // llvm.ppc.subf128.round.to.odd
+    7, // llvm.ppc.sync
+    7, // llvm.ppc.tabort
+    7, // llvm.ppc.tabortdc
+    7, // llvm.ppc.tabortdci
+    7, // llvm.ppc.tabortwc
+    7, // llvm.ppc.tabortwci
+    83, // llvm.ppc.tbegin
+    7, // llvm.ppc.tcheck
+    83, // llvm.ppc.tend
+    7, // llvm.ppc.tendall
+    7, // llvm.ppc.trechkpt
+    7, // llvm.ppc.treclaim
+    7, // llvm.ppc.tresume
+    12, // llvm.ppc.truncf128.round.to.odd
+    7, // llvm.ppc.tsr
+    7, // llvm.ppc.tsuspend
+    7, // llvm.ppc.ttest
+    12, // llvm.ppc.vsx.assemble.pair
+    12, // llvm.ppc.vsx.disassemble.pair
+    3, // llvm.ppc.vsx.lxvd2x
+    3, // llvm.ppc.vsx.lxvd2x.be
+    3, // llvm.ppc.vsx.lxvl
+    3, // llvm.ppc.vsx.lxvll
+    3, // llvm.ppc.vsx.lxvp
+    3, // llvm.ppc.vsx.lxvw4x
+    3, // llvm.ppc.vsx.lxvw4x.be
+    80, // llvm.ppc.vsx.stxvd2x
+    80, // llvm.ppc.vsx.stxvd2x.be
+    80, // llvm.ppc.vsx.stxvl
+    80, // llvm.ppc.vsx.stxvll
+    80, // llvm.ppc.vsx.stxvp
+    80, // llvm.ppc.vsx.stxvw4x
+    80, // llvm.ppc.vsx.stxvw4x.be
+    12, // llvm.ppc.vsx.xsmaxdp
+    12, // llvm.ppc.vsx.xsmindp
+    12, // llvm.ppc.vsx.xvcmpeqdp
+    12, // llvm.ppc.vsx.xvcmpeqdp.p
+    12, // llvm.ppc.vsx.xvcmpeqsp
+    12, // llvm.ppc.vsx.xvcmpeqsp.p
+    12, // llvm.ppc.vsx.xvcmpgedp
+    12, // llvm.ppc.vsx.xvcmpgedp.p
+    12, // llvm.ppc.vsx.xvcmpgesp
+    12, // llvm.ppc.vsx.xvcmpgesp.p
+    12, // llvm.ppc.vsx.xvcmpgtdp
+    12, // llvm.ppc.vsx.xvcmpgtdp.p
+    12, // llvm.ppc.vsx.xvcmpgtsp
+    12, // llvm.ppc.vsx.xvcmpgtsp.p
+    12, // llvm.ppc.vsx.xvcvbf16spn
+    12, // llvm.ppc.vsx.xvcvdpsp
+    12, // llvm.ppc.vsx.xvcvdpsxws
+    12, // llvm.ppc.vsx.xvcvdpuxws
+    12, // llvm.ppc.vsx.xvcvhpsp
+    12, // llvm.ppc.vsx.xvcvspbf16
+    12, // llvm.ppc.vsx.xvcvspdp
+    12, // llvm.ppc.vsx.xvcvsphp
+    12, // llvm.ppc.vsx.xvcvsxdsp
+    12, // llvm.ppc.vsx.xvcvsxwdp
+    12, // llvm.ppc.vsx.xvcvuxdsp
+    12, // llvm.ppc.vsx.xvcvuxwdp
+    12, // llvm.ppc.vsx.xvdivdp
+    12, // llvm.ppc.vsx.xvdivsp
+    12, // llvm.ppc.vsx.xviexpdp
+    12, // llvm.ppc.vsx.xviexpsp
+    12, // llvm.ppc.vsx.xvmaxdp
+    12, // llvm.ppc.vsx.xvmaxsp
+    12, // llvm.ppc.vsx.xvmindp
+    12, // llvm.ppc.vsx.xvminsp
+    12, // llvm.ppc.vsx.xvrdpip
+    12, // llvm.ppc.vsx.xvredp
+    12, // llvm.ppc.vsx.xvresp
+    12, // llvm.ppc.vsx.xvrspip
+    12, // llvm.ppc.vsx.xvrsqrtedp
+    12, // llvm.ppc.vsx.xvrsqrtesp
+    12, // llvm.ppc.vsx.xvtdivdp
+    12, // llvm.ppc.vsx.xvtdivsp
+    12, // llvm.ppc.vsx.xvtlsbb
+    12, // llvm.ppc.vsx.xvtsqrtdp
+    12, // llvm.ppc.vsx.xvtsqrtsp
+    78, // llvm.ppc.vsx.xvtstdcdp
+    78, // llvm.ppc.vsx.xvtstdcsp
+    12, // llvm.ppc.vsx.xvxexpdp
+    12, // llvm.ppc.vsx.xvxexpsp
+    12, // llvm.ppc.vsx.xvxsigdp
+    12, // llvm.ppc.vsx.xvxsigsp
+    12, // llvm.ppc.vsx.xxblendvb
+    12, // llvm.ppc.vsx.xxblendvd
+    12, // llvm.ppc.vsx.xxblendvh
+    12, // llvm.ppc.vsx.xxblendvw
+    71, // llvm.ppc.vsx.xxeval
+    12, // llvm.ppc.vsx.xxextractuw
+    12, // llvm.ppc.vsx.xxgenpcvbm
+    12, // llvm.ppc.vsx.xxgenpcvdm
+    12, // llvm.ppc.vsx.xxgenpcvhm
+    12, // llvm.ppc.vsx.xxgenpcvwm
+    12, // llvm.ppc.vsx.xxinsertw
+    12, // llvm.ppc.vsx.xxleqv
+    71, // llvm.ppc.vsx.xxpermx
+    84, // llvm.r600.cube
+    144, // llvm.r600.ddx
+    144, // llvm.r600.ddy
+    84, // llvm.r600.dot4
+    100, // llvm.r600.group.barrier
+    84, // llvm.r600.implicitarg.ptr
+    155, // llvm.r600.kill
+    155, // llvm.r600.rat.store.typed
+    84, // llvm.r600.read.global.size.x
+    84, // llvm.r600.read.global.size.y
+    84, // llvm.r600.read.global.size.z
+    84, // llvm.r600.read.local.size.x
+    84, // llvm.r600.read.local.size.y
+    84, // llvm.r600.read.local.size.z
+    84, // llvm.r600.read.ngroups.x
+    84, // llvm.r600.read.ngroups.y
+    84, // llvm.r600.read.ngroups.z
+    84, // llvm.r600.read.tgid.x
+    84, // llvm.r600.read.tgid.y
+    84, // llvm.r600.read.tgid.z
+    84, // llvm.r600.read.tidig.x
+    84, // llvm.r600.read.tidig.y
+    84, // llvm.r600.read.tidig.z
+    84, // llvm.r600.recipsqrt.clamped
+    84, // llvm.r600.recipsqrt.ieee
+    155, // llvm.r600.store.stream.output
+    155, // llvm.r600.store.swizzle
+    144, // llvm.r600.tex
+    144, // llvm.r600.texc
+    144, // llvm.r600.txb
+    144, // llvm.r600.txbc
+    144, // llvm.r600.txf
+    144, // llvm.r600.txl
+    144, // llvm.r600.txlc
+    144, // llvm.r600.txq
+    193, // llvm.riscv.masked.atomicrmw.add.i32
+    193, // llvm.riscv.masked.atomicrmw.add.i64
+    194, // llvm.riscv.masked.atomicrmw.max.i32
+    194, // llvm.riscv.masked.atomicrmw.max.i64
+    194, // llvm.riscv.masked.atomicrmw.min.i32
+    194, // llvm.riscv.masked.atomicrmw.min.i64
+    193, // llvm.riscv.masked.atomicrmw.nand.i32
+    193, // llvm.riscv.masked.atomicrmw.nand.i64
+    193, // llvm.riscv.masked.atomicrmw.sub.i32
+    193, // llvm.riscv.masked.atomicrmw.sub.i64
+    193, // llvm.riscv.masked.atomicrmw.umax.i32
+    193, // llvm.riscv.masked.atomicrmw.umax.i64
+    193, // llvm.riscv.masked.atomicrmw.umin.i32
+    193, // llvm.riscv.masked.atomicrmw.umin.i64
+    193, // llvm.riscv.masked.atomicrmw.xchg.i32
+    193, // llvm.riscv.masked.atomicrmw.xchg.i64
+    194, // llvm.riscv.masked.cmpxchg.i32
+    194, // llvm.riscv.masked.cmpxchg.i64
+    63, // llvm.riscv.vaadd
+    63, // llvm.riscv.vaadd.mask
+    63, // llvm.riscv.vaaddu
+    63, // llvm.riscv.vaaddu.mask
+    12, // llvm.riscv.vadc
+    12, // llvm.riscv.vadd
+    12, // llvm.riscv.vadd.mask
+    12, // llvm.riscv.vand
+    12, // llvm.riscv.vand.mask
+    63, // llvm.riscv.vasub
+    63, // llvm.riscv.vasub.mask
+    63, // llvm.riscv.vasubu
+    63, // llvm.riscv.vasubu.mask
+    12, // llvm.riscv.vcompress
+    12, // llvm.riscv.vdiv
+    12, // llvm.riscv.vdiv.mask
+    12, // llvm.riscv.vdivu
+    12, // llvm.riscv.vdivu.mask
+    12, // llvm.riscv.vfadd
+    12, // llvm.riscv.vfadd.mask
+    12, // llvm.riscv.vfclass
+    12, // llvm.riscv.vfclass.mask
+    12, // llvm.riscv.vfcvt.f.x.v
+    12, // llvm.riscv.vfcvt.f.x.v.mask
+    12, // llvm.riscv.vfcvt.f.xu.v
+    12, // llvm.riscv.vfcvt.f.xu.v.mask
+    12, // llvm.riscv.vfcvt.rtz.x.f.v
+    12, // llvm.riscv.vfcvt.rtz.x.f.v.mask
+    12, // llvm.riscv.vfcvt.rtz.xu.f.v
+    12, // llvm.riscv.vfcvt.rtz.xu.f.v.mask
+    12, // llvm.riscv.vfcvt.x.f.v
+    12, // llvm.riscv.vfcvt.x.f.v.mask
+    12, // llvm.riscv.vfcvt.xu.f.v
+    12, // llvm.riscv.vfcvt.xu.f.v.mask
+    12, // llvm.riscv.vfdiv
+    12, // llvm.riscv.vfdiv.mask
+    12, // llvm.riscv.vfirst
+    12, // llvm.riscv.vfirst.mask
+    12, // llvm.riscv.vfmacc
+    12, // llvm.riscv.vfmacc.mask
+    12, // llvm.riscv.vfmadd
+    12, // llvm.riscv.vfmadd.mask
+    12, // llvm.riscv.vfmax
+    12, // llvm.riscv.vfmax.mask
+    12, // llvm.riscv.vfmerge
+    12, // llvm.riscv.vfmin
+    12, // llvm.riscv.vfmin.mask
+    12, // llvm.riscv.vfmsac
+    12, // llvm.riscv.vfmsac.mask
+    12, // llvm.riscv.vfmsub
+    12, // llvm.riscv.vfmsub.mask
+    12, // llvm.riscv.vfmul
+    12, // llvm.riscv.vfmul.mask
+    12, // llvm.riscv.vfmv.f.s
+    12, // llvm.riscv.vfmv.s.f
+    12, // llvm.riscv.vfmv.v.f
+    12, // llvm.riscv.vfncvt.f.f.w
+    12, // llvm.riscv.vfncvt.f.f.w.mask
+    12, // llvm.riscv.vfncvt.f.x.w
+    12, // llvm.riscv.vfncvt.f.x.w.mask
+    12, // llvm.riscv.vfncvt.f.xu.w
+    12, // llvm.riscv.vfncvt.f.xu.w.mask
+    12, // llvm.riscv.vfncvt.rod.f.f.w
+    12, // llvm.riscv.vfncvt.rod.f.f.w.mask
+    12, // llvm.riscv.vfncvt.rtz.x.f.w
+    12, // llvm.riscv.vfncvt.rtz.x.f.w.mask
+    12, // llvm.riscv.vfncvt.rtz.xu.f.w
+    12, // llvm.riscv.vfncvt.rtz.xu.f.w.mask
+    12, // llvm.riscv.vfncvt.x.f.w
+    12, // llvm.riscv.vfncvt.x.f.w.mask
+    12, // llvm.riscv.vfncvt.xu.f.w
+    12, // llvm.riscv.vfncvt.xu.f.w.mask
+    12, // llvm.riscv.vfnmacc
+    12, // llvm.riscv.vfnmacc.mask
+    12, // llvm.riscv.vfnmadd
+    12, // llvm.riscv.vfnmadd.mask
+    12, // llvm.riscv.vfnmsac
+    12, // llvm.riscv.vfnmsac.mask
+    12, // llvm.riscv.vfnmsub
+    12, // llvm.riscv.vfnmsub.mask
+    12, // llvm.riscv.vfrdiv
+    12, // llvm.riscv.vfrdiv.mask
+    12, // llvm.riscv.vfredmax
+    12, // llvm.riscv.vfredmax.mask
+    12, // llvm.riscv.vfredmin
+    12, // llvm.riscv.vfredmin.mask
+    12, // llvm.riscv.vfredosum
+    12, // llvm.riscv.vfredosum.mask
+    12, // llvm.riscv.vfredsum
+    12, // llvm.riscv.vfredsum.mask
+    12, // llvm.riscv.vfrsub
+    12, // llvm.riscv.vfrsub.mask
+    12, // llvm.riscv.vfsgnj
+    12, // llvm.riscv.vfsgnj.mask
+    12, // llvm.riscv.vfsgnjn
+    12, // llvm.riscv.vfsgnjn.mask
+    12, // llvm.riscv.vfsgnjx
+    12, // llvm.riscv.vfsgnjx.mask
+    12, // llvm.riscv.vfslide1down
+    12, // llvm.riscv.vfslide1down.mask
+    12, // llvm.riscv.vfslide1up
+    12, // llvm.riscv.vfslide1up.mask
+    12, // llvm.riscv.vfsqrt
+    12, // llvm.riscv.vfsqrt.mask
+    12, // llvm.riscv.vfsub
+    12, // llvm.riscv.vfsub.mask
+    12, // llvm.riscv.vfwadd
+    12, // llvm.riscv.vfwadd.mask
+    12, // llvm.riscv.vfwadd.w
+    12, // llvm.riscv.vfwadd.w.mask
+    12, // llvm.riscv.vfwcvt.f.f.v
+    12, // llvm.riscv.vfwcvt.f.f.v.mask
+    12, // llvm.riscv.vfwcvt.f.x.v
+    12, // llvm.riscv.vfwcvt.f.x.v.mask
+    12, // llvm.riscv.vfwcvt.f.xu.v
+    12, // llvm.riscv.vfwcvt.f.xu.v.mask
+    12, // llvm.riscv.vfwcvt.rtz.x.f.v
+    12, // llvm.riscv.vfwcvt.rtz.x.f.v.mask
+    12, // llvm.riscv.vfwcvt.rtz.xu.f.v
+    12, // llvm.riscv.vfwcvt.rtz.xu.f.v.mask
+    12, // llvm.riscv.vfwcvt.x.f.v
+    12, // llvm.riscv.vfwcvt.x.f.v.mask
+    12, // llvm.riscv.vfwcvt.xu.f.v
+    12, // llvm.riscv.vfwcvt.xu.f.v.mask
+    12, // llvm.riscv.vfwmacc
+    12, // llvm.riscv.vfwmacc.mask
+    12, // llvm.riscv.vfwmsac
+    12, // llvm.riscv.vfwmsac.mask
+    12, // llvm.riscv.vfwmul
+    12, // llvm.riscv.vfwmul.mask
+    12, // llvm.riscv.vfwnmacc
+    12, // llvm.riscv.vfwnmacc.mask
+    12, // llvm.riscv.vfwnmsac
+    12, // llvm.riscv.vfwnmsac.mask
+    12, // llvm.riscv.vfwredosum
+    12, // llvm.riscv.vfwredosum.mask
+    12, // llvm.riscv.vfwredsum
+    12, // llvm.riscv.vfwredsum.mask
+    12, // llvm.riscv.vfwsub
+    12, // llvm.riscv.vfwsub.mask
+    12, // llvm.riscv.vfwsub.w
+    12, // llvm.riscv.vfwsub.w.mask
+    12, // llvm.riscv.vid
+    12, // llvm.riscv.vid.mask
+    12, // llvm.riscv.viota
+    12, // llvm.riscv.viota.mask
+    195, // llvm.riscv.vle
+    196, // llvm.riscv.vle.mask
+    195, // llvm.riscv.vleff
+    196, // llvm.riscv.vleff.mask
+    195, // llvm.riscv.vlse
+    196, // llvm.riscv.vlse.mask
+    195, // llvm.riscv.vlxe
+    196, // llvm.riscv.vlxe.mask
+    12, // llvm.riscv.vmacc
+    12, // llvm.riscv.vmacc.mask
+    12, // llvm.riscv.vmadc
+    12, // llvm.riscv.vmadc.carry.in
+    12, // llvm.riscv.vmadd
+    12, // llvm.riscv.vmadd.mask
+    12, // llvm.riscv.vmand
+    12, // llvm.riscv.vmandnot
+    12, // llvm.riscv.vmax
+    12, // llvm.riscv.vmax.mask
+    12, // llvm.riscv.vmaxu
+    12, // llvm.riscv.vmaxu.mask
+    12, // llvm.riscv.vmclr
+    12, // llvm.riscv.vmerge
+    12, // llvm.riscv.vmfeq
+    12, // llvm.riscv.vmfeq.mask
+    12, // llvm.riscv.vmfge
+    12, // llvm.riscv.vmfge.mask
+    12, // llvm.riscv.vmfgt
+    12, // llvm.riscv.vmfgt.mask
+    12, // llvm.riscv.vmfle
+    12, // llvm.riscv.vmfle.mask
+    12, // llvm.riscv.vmflt
+    12, // llvm.riscv.vmflt.mask
+    12, // llvm.riscv.vmfne
+    12, // llvm.riscv.vmfne.mask
+    12, // llvm.riscv.vmin
+    12, // llvm.riscv.vmin.mask
+    12, // llvm.riscv.vminu
+    12, // llvm.riscv.vminu.mask
+    12, // llvm.riscv.vmnand
+    12, // llvm.riscv.vmnor
+    12, // llvm.riscv.vmor
+    12, // llvm.riscv.vmornot
+    12, // llvm.riscv.vmsbc
+    12, // llvm.riscv.vmsbc.borrow.in
+    12, // llvm.riscv.vmsbf
+    12, // llvm.riscv.vmsbf.mask
+    12, // llvm.riscv.vmseq
+    12, // llvm.riscv.vmseq.mask
+    12, // llvm.riscv.vmset
+    12, // llvm.riscv.vmsgt
+    12, // llvm.riscv.vmsgt.mask
+    12, // llvm.riscv.vmsgtu
+    12, // llvm.riscv.vmsgtu.mask
+    12, // llvm.riscv.vmsif
+    12, // llvm.riscv.vmsif.mask
+    12, // llvm.riscv.vmsle
+    12, // llvm.riscv.vmsle.mask
+    12, // llvm.riscv.vmsleu
+    12, // llvm.riscv.vmsleu.mask
+    12, // llvm.riscv.vmslt
+    12, // llvm.riscv.vmslt.mask
+    12, // llvm.riscv.vmsltu
+    12, // llvm.riscv.vmsltu.mask
+    12, // llvm.riscv.vmsne
+    12, // llvm.riscv.vmsne.mask
+    12, // llvm.riscv.vmsof
+    12, // llvm.riscv.vmsof.mask
+    12, // llvm.riscv.vmul
+    12, // llvm.riscv.vmul.mask
+    12, // llvm.riscv.vmulh
+    12, // llvm.riscv.vmulh.mask
+    12, // llvm.riscv.vmulhsu
+    12, // llvm.riscv.vmulhsu.mask
+    12, // llvm.riscv.vmulhu
+    12, // llvm.riscv.vmulhu.mask
+    12, // llvm.riscv.vmv.s.x
+    12, // llvm.riscv.vmv.v.v
+    12, // llvm.riscv.vmv.v.x
+    12, // llvm.riscv.vmv.x.s
+    12, // llvm.riscv.vmxnor
+    12, // llvm.riscv.vmxor
+    63, // llvm.riscv.vnclip
+    63, // llvm.riscv.vnclip.mask
+    63, // llvm.riscv.vnclipu
+    63, // llvm.riscv.vnclipu.mask
+    12, // llvm.riscv.vnmsac
+    12, // llvm.riscv.vnmsac.mask
+    12, // llvm.riscv.vnmsub
+    12, // llvm.riscv.vnmsub.mask
+    12, // llvm.riscv.vnsra
+    12, // llvm.riscv.vnsra.mask
+    12, // llvm.riscv.vnsrl
+    12, // llvm.riscv.vnsrl.mask
+    12, // llvm.riscv.vor
+    12, // llvm.riscv.vor.mask
+    12, // llvm.riscv.vpopc
+    12, // llvm.riscv.vpopc.mask
+    12, // llvm.riscv.vredand
+    12, // llvm.riscv.vredand.mask
+    12, // llvm.riscv.vredmax
+    12, // llvm.riscv.vredmax.mask
+    12, // llvm.riscv.vredmaxu
+    12, // llvm.riscv.vredmaxu.mask
+    12, // llvm.riscv.vredmin
+    12, // llvm.riscv.vredmin.mask
+    12, // llvm.riscv.vredminu
+    12, // llvm.riscv.vredminu.mask
+    12, // llvm.riscv.vredor
+    12, // llvm.riscv.vredor.mask
+    12, // llvm.riscv.vredsum
+    12, // llvm.riscv.vredsum.mask
+    12, // llvm.riscv.vredxor
+    12, // llvm.riscv.vredxor.mask
+    12, // llvm.riscv.vrem
+    12, // llvm.riscv.vrem.mask
+    12, // llvm.riscv.vremu
+    12, // llvm.riscv.vremu.mask
+    12, // llvm.riscv.vrgather
+    12, // llvm.riscv.vrgather.mask
+    12, // llvm.riscv.vrsub
+    12, // llvm.riscv.vrsub.mask
+    63, // llvm.riscv.vsadd
+    63, // llvm.riscv.vsadd.mask
+    63, // llvm.riscv.vsaddu
+    63, // llvm.riscv.vsaddu.mask
+    12, // llvm.riscv.vsbc
+    197, // llvm.riscv.vse
+    197, // llvm.riscv.vse.mask
+    198, // llvm.riscv.vsetvli
+    199, // llvm.riscv.vsetvlimax
+    12, // llvm.riscv.vsext
+    12, // llvm.riscv.vsext.mask
+    12, // llvm.riscv.vslide1down
+    12, // llvm.riscv.vslide1down.mask
+    12, // llvm.riscv.vslide1up
+    12, // llvm.riscv.vslide1up.mask
+    12, // llvm.riscv.vslidedown
+    12, // llvm.riscv.vslidedown.mask
+    12, // llvm.riscv.vslideup
+    12, // llvm.riscv.vslideup.mask
+    12, // llvm.riscv.vsll
+    12, // llvm.riscv.vsll.mask
+    63, // llvm.riscv.vsmul
+    63, // llvm.riscv.vsmul.mask
+    12, // llvm.riscv.vsra
+    12, // llvm.riscv.vsra.mask
+    12, // llvm.riscv.vsrl
+    12, // llvm.riscv.vsrl.mask
+    197, // llvm.riscv.vsse
+    197, // llvm.riscv.vsse.mask
+    63, // llvm.riscv.vssra
+    63, // llvm.riscv.vssra.mask
+    63, // llvm.riscv.vssrl
+    63, // llvm.riscv.vssrl.mask
+    63, // llvm.riscv.vssub
+    63, // llvm.riscv.vssub.mask
+    63, // llvm.riscv.vssubu
+    63, // llvm.riscv.vssubu.mask
+    12, // llvm.riscv.vsub
+    12, // llvm.riscv.vsub.mask
+    197, // llvm.riscv.vsuxe
+    197, // llvm.riscv.vsuxe.mask
+    197, // llvm.riscv.vsxe
+    197, // llvm.riscv.vsxe.mask
+    12, // llvm.riscv.vwadd
+    12, // llvm.riscv.vwadd.mask
+    12, // llvm.riscv.vwadd.w
+    12, // llvm.riscv.vwadd.w.mask
+    12, // llvm.riscv.vwaddu
+    12, // llvm.riscv.vwaddu.mask
+    12, // llvm.riscv.vwaddu.w
+    12, // llvm.riscv.vwaddu.w.mask
+    12, // llvm.riscv.vwmacc
+    12, // llvm.riscv.vwmacc.mask
+    12, // llvm.riscv.vwmaccsu
+    12, // llvm.riscv.vwmaccsu.mask
+    12, // llvm.riscv.vwmaccu
+    12, // llvm.riscv.vwmaccu.mask
+    12, // llvm.riscv.vwmaccus
+    12, // llvm.riscv.vwmaccus.mask
+    12, // llvm.riscv.vwmul
+    12, // llvm.riscv.vwmul.mask
+    12, // llvm.riscv.vwmulsu
+    12, // llvm.riscv.vwmulsu.mask
+    12, // llvm.riscv.vwmulu
+    12, // llvm.riscv.vwmulu.mask
+    12, // llvm.riscv.vwredsum
+    12, // llvm.riscv.vwredsum.mask
+    12, // llvm.riscv.vwredsumu
+    12, // llvm.riscv.vwredsumu.mask
+    12, // llvm.riscv.vwsub
+    12, // llvm.riscv.vwsub.mask
+    12, // llvm.riscv.vwsub.w
+    12, // llvm.riscv.vwsub.w.mask
+    12, // llvm.riscv.vwsubu
+    12, // llvm.riscv.vwsubu.mask
+    12, // llvm.riscv.vwsubu.w
+    12, // llvm.riscv.vwsubu.w.mask
+    12, // llvm.riscv.vxor
+    12, // llvm.riscv.vxor.mask
+    12, // llvm.riscv.vzext
+    12, // llvm.riscv.vzext.mask
+    7, // llvm.s390.efpc
+    12, // llvm.s390.etnd
+    78, // llvm.s390.lcbb
+    80, // llvm.s390.ntstg
+    7, // llvm.s390.ppa.txassist
+    7, // llvm.s390.sfpc
+    200, // llvm.s390.tabort
+    201, // llvm.s390.tbegin
+    201, // llvm.s390.tbegin.nofloat
+    201, // llvm.s390.tbeginc
+    12, // llvm.s390.tdc
+    7, // llvm.s390.tend
+    12, // llvm.s390.vaccb
+    12, // llvm.s390.vacccq
+    12, // llvm.s390.vaccf
+    12, // llvm.s390.vaccg
+    12, // llvm.s390.vacch
+    12, // llvm.s390.vaccq
+    12, // llvm.s390.vacq
+    12, // llvm.s390.vaq
+    12, // llvm.s390.vavgb
+    12, // llvm.s390.vavgf
+    12, // llvm.s390.vavgg
+    12, // llvm.s390.vavgh
+    12, // llvm.s390.vavglb
+    12, // llvm.s390.vavglf
+    12, // llvm.s390.vavglg
+    12, // llvm.s390.vavglh
+    12, // llvm.s390.vbperm
+    12, // llvm.s390.vceqbs
+    12, // llvm.s390.vceqfs
+    12, // llvm.s390.vceqgs
+    12, // llvm.s390.vceqhs
+    12, // llvm.s390.vchbs
+    12, // llvm.s390.vchfs
+    12, // llvm.s390.vchgs
+    12, // llvm.s390.vchhs
+    12, // llvm.s390.vchlbs
+    12, // llvm.s390.vchlfs
+    12, // llvm.s390.vchlgs
+    12, // llvm.s390.vchlhs
+    12, // llvm.s390.vcksm
+    71, // llvm.s390.verimb
+    71, // llvm.s390.verimf
+    71, // llvm.s390.verimg
+    71, // llvm.s390.verimh
+    12, // llvm.s390.verllb
+    12, // llvm.s390.verllf
+    12, // llvm.s390.verllg
+    12, // llvm.s390.verllh
+    12, // llvm.s390.verllvb
+    12, // llvm.s390.verllvf
+    12, // llvm.s390.verllvg
+    12, // llvm.s390.verllvh
+    70, // llvm.s390.vfaeb
+    70, // llvm.s390.vfaebs
+    70, // llvm.s390.vfaef
+    70, // llvm.s390.vfaefs
+    70, // llvm.s390.vfaeh
+    70, // llvm.s390.vfaehs
+    70, // llvm.s390.vfaezb
+    70, // llvm.s390.vfaezbs
+    70, // llvm.s390.vfaezf
+    70, // llvm.s390.vfaezfs
+    70, // llvm.s390.vfaezh
+    70, // llvm.s390.vfaezhs
+    12, // llvm.s390.vfcedbs
+    12, // llvm.s390.vfcesbs
+    12, // llvm.s390.vfchdbs
+    12, // llvm.s390.vfchedbs
+    12, // llvm.s390.vfchesbs
+    12, // llvm.s390.vfchsbs
+    12, // llvm.s390.vfeeb
+    12, // llvm.s390.vfeebs
+    12, // llvm.s390.vfeef
+    12, // llvm.s390.vfeefs
+    12, // llvm.s390.vfeeh
+    12, // llvm.s390.vfeehs
+    12, // llvm.s390.vfeezb
+    12, // llvm.s390.vfeezbs
+    12, // llvm.s390.vfeezf
+    12, // llvm.s390.vfeezfs
+    12, // llvm.s390.vfeezh
+    12, // llvm.s390.vfeezhs
+    12, // llvm.s390.vfeneb
+    12, // llvm.s390.vfenebs
+    12, // llvm.s390.vfenef
+    12, // llvm.s390.vfenefs
+    12, // llvm.s390.vfeneh
+    12, // llvm.s390.vfenehs
+    12, // llvm.s390.vfenezb
+    12, // llvm.s390.vfenezbs
+    12, // llvm.s390.vfenezf
+    12, // llvm.s390.vfenezfs
+    12, // llvm.s390.vfenezh
+    12, // llvm.s390.vfenezhs
+    79, // llvm.s390.vfidb
+    79, // llvm.s390.vfisb
+    70, // llvm.s390.vfmaxdb
+    70, // llvm.s390.vfmaxsb
+    70, // llvm.s390.vfmindb
+    70, // llvm.s390.vfminsb
+    78, // llvm.s390.vftcidb
+    78, // llvm.s390.vftcisb
+    12, // llvm.s390.vgfmab
+    12, // llvm.s390.vgfmaf
+    12, // llvm.s390.vgfmag
+    12, // llvm.s390.vgfmah
+    12, // llvm.s390.vgfmb
+    12, // llvm.s390.vgfmf
+    12, // llvm.s390.vgfmg
+    12, // llvm.s390.vgfmh
+    12, // llvm.s390.vistrb
+    12, // llvm.s390.vistrbs
+    12, // llvm.s390.vistrf
+    12, // llvm.s390.vistrfs
+    12, // llvm.s390.vistrh
+    12, // llvm.s390.vistrhs
+    81, // llvm.s390.vlbb
+    3, // llvm.s390.vll
+    3, // llvm.s390.vlrl
+    12, // llvm.s390.vmaeb
+    12, // llvm.s390.vmaef
+    12, // llvm.s390.vmaeh
+    12, // llvm.s390.vmahb
+    12, // llvm.s390.vmahf
+    12, // llvm.s390.vmahh
+    12, // llvm.s390.vmaleb
+    12, // llvm.s390.vmalef
+    12, // llvm.s390.vmaleh
+    12, // llvm.s390.vmalhb
+    12, // llvm.s390.vmalhf
+    12, // llvm.s390.vmalhh
+    12, // llvm.s390.vmalob
+    12, // llvm.s390.vmalof
+    12, // llvm.s390.vmaloh
+    12, // llvm.s390.vmaob
+    12, // llvm.s390.vmaof
+    12, // llvm.s390.vmaoh
+    12, // llvm.s390.vmeb
+    12, // llvm.s390.vmef
+    12, // llvm.s390.vmeh
+    12, // llvm.s390.vmhb
+    12, // llvm.s390.vmhf
+    12, // llvm.s390.vmhh
+    12, // llvm.s390.vmleb
+    12, // llvm.s390.vmlef
+    12, // llvm.s390.vmleh
+    12, // llvm.s390.vmlhb
+    12, // llvm.s390.vmlhf
+    12, // llvm.s390.vmlhh
+    12, // llvm.s390.vmlob
+    12, // llvm.s390.vmlof
+    12, // llvm.s390.vmloh
+    12, // llvm.s390.vmob
+    12, // llvm.s390.vmof
+    12, // llvm.s390.vmoh
+    71, // llvm.s390.vmslg
+    70, // llvm.s390.vpdi
+    12, // llvm.s390.vperm
+    12, // llvm.s390.vpklsf
+    12, // llvm.s390.vpklsfs
+    12, // llvm.s390.vpklsg
+    12, // llvm.s390.vpklsgs
+    12, // llvm.s390.vpklsh
+    12, // llvm.s390.vpklshs
+    12, // llvm.s390.vpksf
+    12, // llvm.s390.vpksfs
+    12, // llvm.s390.vpksg
+    12, // llvm.s390.vpksgs
+    12, // llvm.s390.vpksh
+    12, // llvm.s390.vpkshs
+    12, // llvm.s390.vsbcbiq
+    12, // llvm.s390.vsbiq
+    12, // llvm.s390.vscbib
+    12, // llvm.s390.vscbif
+    12, // llvm.s390.vscbig
+    12, // llvm.s390.vscbih
+    12, // llvm.s390.vscbiq
+    12, // llvm.s390.vsl
+    12, // llvm.s390.vslb
+    70, // llvm.s390.vsld
+    70, // llvm.s390.vsldb
+    12, // llvm.s390.vsq
+    12, // llvm.s390.vsra
+    12, // llvm.s390.vsrab
+    70, // llvm.s390.vsrd
+    12, // llvm.s390.vsrl
+    12, // llvm.s390.vsrlb
+    80, // llvm.s390.vstl
+    71, // llvm.s390.vstrcb
+    71, // llvm.s390.vstrcbs
+    71, // llvm.s390.vstrcf
+    71, // llvm.s390.vstrcfs
+    71, // llvm.s390.vstrch
+    71, // llvm.s390.vstrchs
+    71, // llvm.s390.vstrczb
+    71, // llvm.s390.vstrczbs
+    71, // llvm.s390.vstrczf
+    71, // llvm.s390.vstrczfs
+    71, // llvm.s390.vstrczh
+    71, // llvm.s390.vstrczhs
+    80, // llvm.s390.vstrl
+    12, // llvm.s390.vstrsb
+    12, // llvm.s390.vstrsf
+    12, // llvm.s390.vstrsh
+    12, // llvm.s390.vstrszb
+    12, // llvm.s390.vstrszf
+    12, // llvm.s390.vstrszh
+    12, // llvm.s390.vsumb
+    12, // llvm.s390.vsumgf
+    12, // llvm.s390.vsumgh
+    12, // llvm.s390.vsumh
+    12, // llvm.s390.vsumqf
+    12, // llvm.s390.vsumqg
+    12, // llvm.s390.vtm
+    12, // llvm.s390.vuphb
+    12, // llvm.s390.vuphf
+    12, // llvm.s390.vuphh
+    12, // llvm.s390.vuplb
+    12, // llvm.s390.vuplf
+    12, // llvm.s390.vuplhb
+    12, // llvm.s390.vuplhf
+    12, // llvm.s390.vuplhh
+    12, // llvm.s390.vuplhw
+    12, // llvm.s390.vupllb
+    12, // llvm.s390.vupllf
+    12, // llvm.s390.vupllh
+    12, // llvm.ve.vl.andm.MMM
+    12, // llvm.ve.vl.andm.mmm
+    12, // llvm.ve.vl.eqvm.MMM
+    12, // llvm.ve.vl.eqvm.mmm
+    12, // llvm.ve.vl.extract.vm512l
+    12, // llvm.ve.vl.extract.vm512u
+    12, // llvm.ve.vl.insert.vm512l
+    12, // llvm.ve.vl.insert.vm512u
+    12, // llvm.ve.vl.lsv.vvss
+    12, // llvm.ve.vl.lvm.MMss
+    12, // llvm.ve.vl.lvm.mmss
+    12, // llvm.ve.vl.lvsd.svs
+    12, // llvm.ve.vl.lvsl.svs
+    12, // llvm.ve.vl.lvss.svs
+    12, // llvm.ve.vl.lzvm.sml
+    12, // llvm.ve.vl.negm.MM
+    12, // llvm.ve.vl.negm.mm
+    12, // llvm.ve.vl.nndm.MMM
+    12, // llvm.ve.vl.nndm.mmm
+    12, // llvm.ve.vl.orm.MMM
+    12, // llvm.ve.vl.orm.mmm
+    21, // llvm.ve.vl.pack.f32a
+    21, // llvm.ve.vl.pack.f32p
+    12, // llvm.ve.vl.pcvm.sml
+    202, // llvm.ve.vl.pfchv.ssl
+    202, // llvm.ve.vl.pfchvnc.ssl
+    12, // llvm.ve.vl.pvadds.vsvMvl
+    12, // llvm.ve.vl.pvadds.vsvl
+    12, // llvm.ve.vl.pvadds.vsvvl
+    12, // llvm.ve.vl.pvadds.vvvMvl
+    12, // llvm.ve.vl.pvadds.vvvl
+    12, // llvm.ve.vl.pvadds.vvvvl
+    12, // llvm.ve.vl.pvaddu.vsvMvl
+    12, // llvm.ve.vl.pvaddu.vsvl
+    12, // llvm.ve.vl.pvaddu.vsvvl
+    12, // llvm.ve.vl.pvaddu.vvvMvl
+    12, // llvm.ve.vl.pvaddu.vvvl
+    12, // llvm.ve.vl.pvaddu.vvvvl
+    12, // llvm.ve.vl.pvand.vsvMvl
+    12, // llvm.ve.vl.pvand.vsvl
+    12, // llvm.ve.vl.pvand.vsvvl
+    12, // llvm.ve.vl.pvand.vvvMvl
+    12, // llvm.ve.vl.pvand.vvvl
+    12, // llvm.ve.vl.pvand.vvvvl
+    12, // llvm.ve.vl.pvbrd.vsMvl
+    12, // llvm.ve.vl.pvbrd.vsl
+    12, // llvm.ve.vl.pvbrd.vsvl
+    12, // llvm.ve.vl.pvcmps.vsvMvl
+    12, // llvm.ve.vl.pvcmps.vsvl
+    12, // llvm.ve.vl.pvcmps.vsvvl
+    12, // llvm.ve.vl.pvcmps.vvvMvl
+    12, // llvm.ve.vl.pvcmps.vvvl
+    12, // llvm.ve.vl.pvcmps.vvvvl
+    12, // llvm.ve.vl.pvcmpu.vsvMvl
+    12, // llvm.ve.vl.pvcmpu.vsvl
+    12, // llvm.ve.vl.pvcmpu.vsvvl
+    12, // llvm.ve.vl.pvcmpu.vvvMvl
+    12, // llvm.ve.vl.pvcmpu.vvvl
+    12, // llvm.ve.vl.pvcmpu.vvvvl
+    12, // llvm.ve.vl.pvcvtsw.vvl
+    12, // llvm.ve.vl.pvcvtsw.vvvl
+    12, // llvm.ve.vl.pvcvtws.vvMvl
+    12, // llvm.ve.vl.pvcvtws.vvl
+    12, // llvm.ve.vl.pvcvtws.vvvl
+    12, // llvm.ve.vl.pvcvtwsrz.vvMvl
+    12, // llvm.ve.vl.pvcvtwsrz.vvl
+    12, // llvm.ve.vl.pvcvtwsrz.vvvl
+    12, // llvm.ve.vl.pveqv.vsvMvl
+    12, // llvm.ve.vl.pveqv.vsvl
+    12, // llvm.ve.vl.pveqv.vsvvl
+    12, // llvm.ve.vl.pveqv.vvvMvl
+    12, // llvm.ve.vl.pveqv.vvvl
+    12, // llvm.ve.vl.pveqv.vvvvl
+    12, // llvm.ve.vl.pvfadd.vsvMvl
+    12, // llvm.ve.vl.pvfadd.vsvl
+    12, // llvm.ve.vl.pvfadd.vsvvl
+    12, // llvm.ve.vl.pvfadd.vvvMvl
+    12, // llvm.ve.vl.pvfadd.vvvl
+    12, // llvm.ve.vl.pvfadd.vvvvl
+    12, // llvm.ve.vl.pvfcmp.vsvMvl
+    12, // llvm.ve.vl.pvfcmp.vsvl
+    12, // llvm.ve.vl.pvfcmp.vsvvl
+    12, // llvm.ve.vl.pvfcmp.vvvMvl
+    12, // llvm.ve.vl.pvfcmp.vvvl
+    12, // llvm.ve.vl.pvfcmp.vvvvl
+    12, // llvm.ve.vl.pvfmad.vsvvMvl
+    12, // llvm.ve.vl.pvfmad.vsvvl
+    12, // llvm.ve.vl.pvfmad.vsvvvl
+    12, // llvm.ve.vl.pvfmad.vvsvMvl
+    12, // llvm.ve.vl.pvfmad.vvsvl
+    12, // llvm.ve.vl.pvfmad.vvsvvl
+    12, // llvm.ve.vl.pvfmad.vvvvMvl
+    12, // llvm.ve.vl.pvfmad.vvvvl
+    12, // llvm.ve.vl.pvfmad.vvvvvl
+    12, // llvm.ve.vl.pvfmax.vsvMvl
+    12, // llvm.ve.vl.pvfmax.vsvl
+    12, // llvm.ve.vl.pvfmax.vsvvl
+    12, // llvm.ve.vl.pvfmax.vvvMvl
+    12, // llvm.ve.vl.pvfmax.vvvl
+    12, // llvm.ve.vl.pvfmax.vvvvl
+    12, // llvm.ve.vl.pvfmin.vsvMvl
+    12, // llvm.ve.vl.pvfmin.vsvl
+    12, // llvm.ve.vl.pvfmin.vsvvl
+    12, // llvm.ve.vl.pvfmin.vvvMvl
+    12, // llvm.ve.vl.pvfmin.vvvl
+    12, // llvm.ve.vl.pvfmin.vvvvl
+    12, // llvm.ve.vl.pvfmkaf.Ml
+    12, // llvm.ve.vl.pvfmkat.Ml
+    12, // llvm.ve.vl.pvfmkseq.MvMl
+    12, // llvm.ve.vl.pvfmkseq.Mvl
+    12, // llvm.ve.vl.pvfmkseqnan.MvMl
+    12, // llvm.ve.vl.pvfmkseqnan.Mvl
+    12, // llvm.ve.vl.pvfmksge.MvMl
+    12, // llvm.ve.vl.pvfmksge.Mvl
+    12, // llvm.ve.vl.pvfmksgenan.MvMl
+    12, // llvm.ve.vl.pvfmksgenan.Mvl
+    12, // llvm.ve.vl.pvfmksgt.MvMl
+    12, // llvm.ve.vl.pvfmksgt.Mvl
+    12, // llvm.ve.vl.pvfmksgtnan.MvMl
+    12, // llvm.ve.vl.pvfmksgtnan.Mvl
+    12, // llvm.ve.vl.pvfmksle.MvMl
+    12, // llvm.ve.vl.pvfmksle.Mvl
+    12, // llvm.ve.vl.pvfmkslenan.MvMl
+    12, // llvm.ve.vl.pvfmkslenan.Mvl
+    12, // llvm.ve.vl.pvfmksloeq.mvl
+    12, // llvm.ve.vl.pvfmksloeq.mvml
+    12, // llvm.ve.vl.pvfmksloeqnan.mvl
+    12, // llvm.ve.vl.pvfmksloeqnan.mvml
+    12, // llvm.ve.vl.pvfmksloge.mvl
+    12, // llvm.ve.vl.pvfmksloge.mvml
+    12, // llvm.ve.vl.pvfmkslogenan.mvl
+    12, // llvm.ve.vl.pvfmkslogenan.mvml
+    12, // llvm.ve.vl.pvfmkslogt.mvl
+    12, // llvm.ve.vl.pvfmkslogt.mvml
+    12, // llvm.ve.vl.pvfmkslogtnan.mvl
+    12, // llvm.ve.vl.pvfmkslogtnan.mvml
+    12, // llvm.ve.vl.pvfmkslole.mvl
+    12, // llvm.ve.vl.pvfmkslole.mvml
+    12, // llvm.ve.vl.pvfmkslolenan.mvl
+    12, // llvm.ve.vl.pvfmkslolenan.mvml
+    12, // llvm.ve.vl.pvfmkslolt.mvl
+    12, // llvm.ve.vl.pvfmkslolt.mvml
+    12, // llvm.ve.vl.pvfmksloltnan.mvl
+    12, // llvm.ve.vl.pvfmksloltnan.mvml
+    12, // llvm.ve.vl.pvfmkslonan.mvl
+    12, // llvm.ve.vl.pvfmkslonan.mvml
+    12, // llvm.ve.vl.pvfmkslone.mvl
+    12, // llvm.ve.vl.pvfmkslone.mvml
+    12, // llvm.ve.vl.pvfmkslonenan.mvl
+    12, // llvm.ve.vl.pvfmkslonenan.mvml
+    12, // llvm.ve.vl.pvfmkslonum.mvl
+    12, // llvm.ve.vl.pvfmkslonum.mvml
+    12, // llvm.ve.vl.pvfmkslt.MvMl
+    12, // llvm.ve.vl.pvfmkslt.Mvl
+    12, // llvm.ve.vl.pvfmksltnan.MvMl
+    12, // llvm.ve.vl.pvfmksltnan.Mvl
+    12, // llvm.ve.vl.pvfmksnan.MvMl
+    12, // llvm.ve.vl.pvfmksnan.Mvl
+    12, // llvm.ve.vl.pvfmksne.MvMl
+    12, // llvm.ve.vl.pvfmksne.Mvl
+    12, // llvm.ve.vl.pvfmksnenan.MvMl
+    12, // llvm.ve.vl.pvfmksnenan.Mvl
+    12, // llvm.ve.vl.pvfmksnum.MvMl
+    12, // llvm.ve.vl.pvfmksnum.Mvl
+    12, // llvm.ve.vl.pvfmksupeq.mvl
+    12, // llvm.ve.vl.pvfmksupeq.mvml
+    12, // llvm.ve.vl.pvfmksupeqnan.mvl
+    12, // llvm.ve.vl.pvfmksupeqnan.mvml
+    12, // llvm.ve.vl.pvfmksupge.mvl
+    12, // llvm.ve.vl.pvfmksupge.mvml
+    12, // llvm.ve.vl.pvfmksupgenan.mvl
+    12, // llvm.ve.vl.pvfmksupgenan.mvml
+    12, // llvm.ve.vl.pvfmksupgt.mvl
+    12, // llvm.ve.vl.pvfmksupgt.mvml
+    12, // llvm.ve.vl.pvfmksupgtnan.mvl
+    12, // llvm.ve.vl.pvfmksupgtnan.mvml
+    12, // llvm.ve.vl.pvfmksuple.mvl
+    12, // llvm.ve.vl.pvfmksuple.mvml
+    12, // llvm.ve.vl.pvfmksuplenan.mvl
+    12, // llvm.ve.vl.pvfmksuplenan.mvml
+    12, // llvm.ve.vl.pvfmksuplt.mvl
+    12, // llvm.ve.vl.pvfmksuplt.mvml
+    12, // llvm.ve.vl.pvfmksupltnan.mvl
+    12, // llvm.ve.vl.pvfmksupltnan.mvml
+    12, // llvm.ve.vl.pvfmksupnan.mvl
+    12, // llvm.ve.vl.pvfmksupnan.mvml
+    12, // llvm.ve.vl.pvfmksupne.mvl
+    12, // llvm.ve.vl.pvfmksupne.mvml
+    12, // llvm.ve.vl.pvfmksupnenan.mvl
+    12, // llvm.ve.vl.pvfmksupnenan.mvml
+    12, // llvm.ve.vl.pvfmksupnum.mvl
+    12, // llvm.ve.vl.pvfmksupnum.mvml
+    12, // llvm.ve.vl.pvfmkweq.MvMl
+    12, // llvm.ve.vl.pvfmkweq.Mvl
+    12, // llvm.ve.vl.pvfmkweqnan.MvMl
+    12, // llvm.ve.vl.pvfmkweqnan.Mvl
+    12, // llvm.ve.vl.pvfmkwge.MvMl
+    12, // llvm.ve.vl.pvfmkwge.Mvl
+    12, // llvm.ve.vl.pvfmkwgenan.MvMl
+    12, // llvm.ve.vl.pvfmkwgenan.Mvl
+    12, // llvm.ve.vl.pvfmkwgt.MvMl
+    12, // llvm.ve.vl.pvfmkwgt.Mvl
+    12, // llvm.ve.vl.pvfmkwgtnan.MvMl
+    12, // llvm.ve.vl.pvfmkwgtnan.Mvl
+    12, // llvm.ve.vl.pvfmkwle.MvMl
+    12, // llvm.ve.vl.pvfmkwle.Mvl
+    12, // llvm.ve.vl.pvfmkwlenan.MvMl
+    12, // llvm.ve.vl.pvfmkwlenan.Mvl
+    12, // llvm.ve.vl.pvfmkwloeq.mvl
+    12, // llvm.ve.vl.pvfmkwloeq.mvml
+    12, // llvm.ve.vl.pvfmkwloeqnan.mvl
+    12, // llvm.ve.vl.pvfmkwloeqnan.mvml
+    12, // llvm.ve.vl.pvfmkwloge.mvl
+    12, // llvm.ve.vl.pvfmkwloge.mvml
+    12, // llvm.ve.vl.pvfmkwlogenan.mvl
+    12, // llvm.ve.vl.pvfmkwlogenan.mvml
+    12, // llvm.ve.vl.pvfmkwlogt.mvl
+    12, // llvm.ve.vl.pvfmkwlogt.mvml
+    12, // llvm.ve.vl.pvfmkwlogtnan.mvl
+    12, // llvm.ve.vl.pvfmkwlogtnan.mvml
+    12, // llvm.ve.vl.pvfmkwlole.mvl
+    12, // llvm.ve.vl.pvfmkwlole.mvml
+    12, // llvm.ve.vl.pvfmkwlolenan.mvl
+    12, // llvm.ve.vl.pvfmkwlolenan.mvml
+    12, // llvm.ve.vl.pvfmkwlolt.mvl
+    12, // llvm.ve.vl.pvfmkwlolt.mvml
+    12, // llvm.ve.vl.pvfmkwloltnan.mvl
+    12, // llvm.ve.vl.pvfmkwloltnan.mvml
+    12, // llvm.ve.vl.pvfmkwlonan.mvl
+    12, // llvm.ve.vl.pvfmkwlonan.mvml
+    12, // llvm.ve.vl.pvfmkwlone.mvl
+    12, // llvm.ve.vl.pvfmkwlone.mvml
+    12, // llvm.ve.vl.pvfmkwlonenan.mvl
+    12, // llvm.ve.vl.pvfmkwlonenan.mvml
+    12, // llvm.ve.vl.pvfmkwlonum.mvl
+    12, // llvm.ve.vl.pvfmkwlonum.mvml
+    12, // llvm.ve.vl.pvfmkwlt.MvMl
+    12, // llvm.ve.vl.pvfmkwlt.Mvl
+    12, // llvm.ve.vl.pvfmkwltnan.MvMl
+    12, // llvm.ve.vl.pvfmkwltnan.Mvl
+    12, // llvm.ve.vl.pvfmkwnan.MvMl
+    12, // llvm.ve.vl.pvfmkwnan.Mvl
+    12, // llvm.ve.vl.pvfmkwne.MvMl
+    12, // llvm.ve.vl.pvfmkwne.Mvl
+    12, // llvm.ve.vl.pvfmkwnenan.MvMl
+    12, // llvm.ve.vl.pvfmkwnenan.Mvl
+    12, // llvm.ve.vl.pvfmkwnum.MvMl
+    12, // llvm.ve.vl.pvfmkwnum.Mvl
+    12, // llvm.ve.vl.pvfmkwupeq.mvl
+    12, // llvm.ve.vl.pvfmkwupeq.mvml
+    12, // llvm.ve.vl.pvfmkwupeqnan.mvl
+    12, // llvm.ve.vl.pvfmkwupeqnan.mvml
+    12, // llvm.ve.vl.pvfmkwupge.mvl
+    12, // llvm.ve.vl.pvfmkwupge.mvml
+    12, // llvm.ve.vl.pvfmkwupgenan.mvl
+    12, // llvm.ve.vl.pvfmkwupgenan.mvml
+    12, // llvm.ve.vl.pvfmkwupgt.mvl
+    12, // llvm.ve.vl.pvfmkwupgt.mvml
+    12, // llvm.ve.vl.pvfmkwupgtnan.mvl
+    12, // llvm.ve.vl.pvfmkwupgtnan.mvml
+    12, // llvm.ve.vl.pvfmkwuple.mvl
+    12, // llvm.ve.vl.pvfmkwuple.mvml
+    12, // llvm.ve.vl.pvfmkwuplenan.mvl
+    12, // llvm.ve.vl.pvfmkwuplenan.mvml
+    12, // llvm.ve.vl.pvfmkwuplt.mvl
+    12, // llvm.ve.vl.pvfmkwuplt.mvml
+    12, // llvm.ve.vl.pvfmkwupltnan.mvl
+    12, // llvm.ve.vl.pvfmkwupltnan.mvml
+    12, // llvm.ve.vl.pvfmkwupnan.mvl
+    12, // llvm.ve.vl.pvfmkwupnan.mvml
+    12, // llvm.ve.vl.pvfmkwupne.mvl
+    12, // llvm.ve.vl.pvfmkwupne.mvml
+    12, // llvm.ve.vl.pvfmkwupnenan.mvl
+    12, // llvm.ve.vl.pvfmkwupnenan.mvml
+    12, // llvm.ve.vl.pvfmkwupnum.mvl
+    12, // llvm.ve.vl.pvfmkwupnum.mvml
+    12, // llvm.ve.vl.pvfmsb.vsvvMvl
+    12, // llvm.ve.vl.pvfmsb.vsvvl
+    12, // llvm.ve.vl.pvfmsb.vsvvvl
+    12, // llvm.ve.vl.pvfmsb.vvsvMvl
+    12, // llvm.ve.vl.pvfmsb.vvsvl
+    12, // llvm.ve.vl.pvfmsb.vvsvvl
+    12, // llvm.ve.vl.pvfmsb.vvvvMvl
+    12, // llvm.ve.vl.pvfmsb.vvvvl
+    12, // llvm.ve.vl.pvfmsb.vvvvvl
+    12, // llvm.ve.vl.pvfmul.vsvMvl
+    12, // llvm.ve.vl.pvfmul.vsvl
+    12, // llvm.ve.vl.pvfmul.vsvvl
+    12, // llvm.ve.vl.pvfmul.vvvMvl
+    12, // llvm.ve.vl.pvfmul.vvvl
+    12, // llvm.ve.vl.pvfmul.vvvvl
+    12, // llvm.ve.vl.pvfnmad.vsvvMvl
+    12, // llvm.ve.vl.pvfnmad.vsvvl
+    12, // llvm.ve.vl.pvfnmad.vsvvvl
+    12, // llvm.ve.vl.pvfnmad.vvsvMvl
+    12, // llvm.ve.vl.pvfnmad.vvsvl
+    12, // llvm.ve.vl.pvfnmad.vvsvvl
+    12, // llvm.ve.vl.pvfnmad.vvvvMvl
+    12, // llvm.ve.vl.pvfnmad.vvvvl
+    12, // llvm.ve.vl.pvfnmad.vvvvvl
+    12, // llvm.ve.vl.pvfnmsb.vsvvMvl
+    12, // llvm.ve.vl.pvfnmsb.vsvvl
+    12, // llvm.ve.vl.pvfnmsb.vsvvvl
+    12, // llvm.ve.vl.pvfnmsb.vvsvMvl
+    12, // llvm.ve.vl.pvfnmsb.vvsvl
+    12, // llvm.ve.vl.pvfnmsb.vvsvvl
+    12, // llvm.ve.vl.pvfnmsb.vvvvMvl
+    12, // llvm.ve.vl.pvfnmsb.vvvvl
+    12, // llvm.ve.vl.pvfnmsb.vvvvvl
+    12, // llvm.ve.vl.pvfsub.vsvMvl
+    12, // llvm.ve.vl.pvfsub.vsvl
+    12, // llvm.ve.vl.pvfsub.vsvvl
+    12, // llvm.ve.vl.pvfsub.vvvMvl
+    12, // llvm.ve.vl.pvfsub.vvvl
+    12, // llvm.ve.vl.pvfsub.vvvvl
+    12, // llvm.ve.vl.pvmaxs.vsvMvl
+    12, // llvm.ve.vl.pvmaxs.vsvl
+    12, // llvm.ve.vl.pvmaxs.vsvvl
+    12, // llvm.ve.vl.pvmaxs.vvvMvl
+    12, // llvm.ve.vl.pvmaxs.vvvl
+    12, // llvm.ve.vl.pvmaxs.vvvvl
+    12, // llvm.ve.vl.pvmins.vsvMvl
+    12, // llvm.ve.vl.pvmins.vsvl
+    12, // llvm.ve.vl.pvmins.vsvvl
+    12, // llvm.ve.vl.pvmins.vvvMvl
+    12, // llvm.ve.vl.pvmins.vvvl
+    12, // llvm.ve.vl.pvmins.vvvvl
+    12, // llvm.ve.vl.pvor.vsvMvl
+    12, // llvm.ve.vl.pvor.vsvl
+    12, // llvm.ve.vl.pvor.vsvvl
+    12, // llvm.ve.vl.pvor.vvvMvl
+    12, // llvm.ve.vl.pvor.vvvl
+    12, // llvm.ve.vl.pvor.vvvvl
+    12, // llvm.ve.vl.pvrcp.vvl
+    12, // llvm.ve.vl.pvrcp.vvvl
+    12, // llvm.ve.vl.pvrsqrt.vvl
+    12, // llvm.ve.vl.pvrsqrt.vvvl
+    12, // llvm.ve.vl.pvrsqrtnex.vvl
+    12, // llvm.ve.vl.pvrsqrtnex.vvvl
+    12, // llvm.ve.vl.pvseq.vl
+    12, // llvm.ve.vl.pvseq.vvl
+    12, // llvm.ve.vl.pvseqlo.vl
+    12, // llvm.ve.vl.pvseqlo.vvl
+    12, // llvm.ve.vl.pvsequp.vl
+    12, // llvm.ve.vl.pvsequp.vvl
+    12, // llvm.ve.vl.pvsla.vvsMvl
+    12, // llvm.ve.vl.pvsla.vvsl
+    12, // llvm.ve.vl.pvsla.vvsvl
+    12, // llvm.ve.vl.pvsla.vvvMvl
+    12, // llvm.ve.vl.pvsla.vvvl
+    12, // llvm.ve.vl.pvsla.vvvvl
+    12, // llvm.ve.vl.pvsll.vvsMvl
+    12, // llvm.ve.vl.pvsll.vvsl
+    12, // llvm.ve.vl.pvsll.vvsvl
+    12, // llvm.ve.vl.pvsll.vvvMvl
+    12, // llvm.ve.vl.pvsll.vvvl
+    12, // llvm.ve.vl.pvsll.vvvvl
+    12, // llvm.ve.vl.pvsra.vvsMvl
+    12, // llvm.ve.vl.pvsra.vvsl
+    12, // llvm.ve.vl.pvsra.vvsvl
+    12, // llvm.ve.vl.pvsra.vvvMvl
+    12, // llvm.ve.vl.pvsra.vvvl
+    12, // llvm.ve.vl.pvsra.vvvvl
+    12, // llvm.ve.vl.pvsrl.vvsMvl
+    12, // llvm.ve.vl.pvsrl.vvsl
+    12, // llvm.ve.vl.pvsrl.vvsvl
+    12, // llvm.ve.vl.pvsrl.vvvMvl
+    12, // llvm.ve.vl.pvsrl.vvvl
+    12, // llvm.ve.vl.pvsrl.vvvvl
+    12, // llvm.ve.vl.pvsubs.vsvMvl
+    12, // llvm.ve.vl.pvsubs.vsvl
+    12, // llvm.ve.vl.pvsubs.vsvvl
+    12, // llvm.ve.vl.pvsubs.vvvMvl
+    12, // llvm.ve.vl.pvsubs.vvvl
+    12, // llvm.ve.vl.pvsubs.vvvvl
+    12, // llvm.ve.vl.pvsubu.vsvMvl
+    12, // llvm.ve.vl.pvsubu.vsvl
+    12, // llvm.ve.vl.pvsubu.vsvvl
+    12, // llvm.ve.vl.pvsubu.vvvMvl
+    12, // llvm.ve.vl.pvsubu.vvvl
+    12, // llvm.ve.vl.pvsubu.vvvvl
+    12, // llvm.ve.vl.pvxor.vsvMvl
+    12, // llvm.ve.vl.pvxor.vsvl
+    12, // llvm.ve.vl.pvxor.vsvvl
+    12, // llvm.ve.vl.pvxor.vvvMvl
+    12, // llvm.ve.vl.pvxor.vvvl
+    12, // llvm.ve.vl.pvxor.vvvvl
+    12, // llvm.ve.vl.svm.sMs
+    12, // llvm.ve.vl.svm.sms
+    56, // llvm.ve.vl.svob
+    12, // llvm.ve.vl.tovm.sml
+    12, // llvm.ve.vl.vaddsl.vsvl
+    12, // llvm.ve.vl.vaddsl.vsvmvl
+    12, // llvm.ve.vl.vaddsl.vsvvl
+    12, // llvm.ve.vl.vaddsl.vvvl
+    12, // llvm.ve.vl.vaddsl.vvvmvl
+    12, // llvm.ve.vl.vaddsl.vvvvl
+    12, // llvm.ve.vl.vaddswsx.vsvl
+    12, // llvm.ve.vl.vaddswsx.vsvmvl
+    12, // llvm.ve.vl.vaddswsx.vsvvl
+    12, // llvm.ve.vl.vaddswsx.vvvl
+    12, // llvm.ve.vl.vaddswsx.vvvmvl
+    12, // llvm.ve.vl.vaddswsx.vvvvl
+    12, // llvm.ve.vl.vaddswzx.vsvl
+    12, // llvm.ve.vl.vaddswzx.vsvmvl
+    12, // llvm.ve.vl.vaddswzx.vsvvl
+    12, // llvm.ve.vl.vaddswzx.vvvl
+    12, // llvm.ve.vl.vaddswzx.vvvmvl
+    12, // llvm.ve.vl.vaddswzx.vvvvl
+    12, // llvm.ve.vl.vaddul.vsvl
+    12, // llvm.ve.vl.vaddul.vsvmvl
+    12, // llvm.ve.vl.vaddul.vsvvl
+    12, // llvm.ve.vl.vaddul.vvvl
+    12, // llvm.ve.vl.vaddul.vvvmvl
+    12, // llvm.ve.vl.vaddul.vvvvl
+    12, // llvm.ve.vl.vadduw.vsvl
+    12, // llvm.ve.vl.vadduw.vsvmvl
+    12, // llvm.ve.vl.vadduw.vsvvl
+    12, // llvm.ve.vl.vadduw.vvvl
+    12, // llvm.ve.vl.vadduw.vvvmvl
+    12, // llvm.ve.vl.vadduw.vvvvl
+    12, // llvm.ve.vl.vand.vsvl
+    12, // llvm.ve.vl.vand.vsvmvl
+    12, // llvm.ve.vl.vand.vsvvl
+    12, // llvm.ve.vl.vand.vvvl
+    12, // llvm.ve.vl.vand.vvvmvl
+    12, // llvm.ve.vl.vand.vvvvl
+    12, // llvm.ve.vl.vbrdd.vsl
+    12, // llvm.ve.vl.vbrdd.vsmvl
+    12, // llvm.ve.vl.vbrdd.vsvl
+    12, // llvm.ve.vl.vbrdl.vsl
+    12, // llvm.ve.vl.vbrdl.vsmvl
+    12, // llvm.ve.vl.vbrdl.vsvl
+    12, // llvm.ve.vl.vbrds.vsl
+    12, // llvm.ve.vl.vbrds.vsmvl
+    12, // llvm.ve.vl.vbrds.vsvl
+    12, // llvm.ve.vl.vbrdw.vsl
+    12, // llvm.ve.vl.vbrdw.vsmvl
+    12, // llvm.ve.vl.vbrdw.vsvl
+    12, // llvm.ve.vl.vcmpsl.vsvl
+    12, // llvm.ve.vl.vcmpsl.vsvmvl
+    12, // llvm.ve.vl.vcmpsl.vsvvl
+    12, // llvm.ve.vl.vcmpsl.vvvl
+    12, // llvm.ve.vl.vcmpsl.vvvmvl
+    12, // llvm.ve.vl.vcmpsl.vvvvl
+    12, // llvm.ve.vl.vcmpswsx.vsvl
+    12, // llvm.ve.vl.vcmpswsx.vsvmvl
+    12, // llvm.ve.vl.vcmpswsx.vsvvl
+    12, // llvm.ve.vl.vcmpswsx.vvvl
+    12, // llvm.ve.vl.vcmpswsx.vvvmvl
+    12, // llvm.ve.vl.vcmpswsx.vvvvl
+    12, // llvm.ve.vl.vcmpswzx.vsvl
+    12, // llvm.ve.vl.vcmpswzx.vsvmvl
+    12, // llvm.ve.vl.vcmpswzx.vsvvl
+    12, // llvm.ve.vl.vcmpswzx.vvvl
+    12, // llvm.ve.vl.vcmpswzx.vvvmvl
+    12, // llvm.ve.vl.vcmpswzx.vvvvl
+    12, // llvm.ve.vl.vcmpul.vsvl
+    12, // llvm.ve.vl.vcmpul.vsvmvl
+    12, // llvm.ve.vl.vcmpul.vsvvl
+    12, // llvm.ve.vl.vcmpul.vvvl
+    12, // llvm.ve.vl.vcmpul.vvvmvl
+    12, // llvm.ve.vl.vcmpul.vvvvl
+    12, // llvm.ve.vl.vcmpuw.vsvl
+    12, // llvm.ve.vl.vcmpuw.vsvmvl
+    12, // llvm.ve.vl.vcmpuw.vsvvl
+    12, // llvm.ve.vl.vcmpuw.vvvl
+    12, // llvm.ve.vl.vcmpuw.vvvmvl
+    12, // llvm.ve.vl.vcmpuw.vvvvl
+    12, // llvm.ve.vl.vcp.vvmvl
+    12, // llvm.ve.vl.vcvtdl.vvl
+    12, // llvm.ve.vl.vcvtdl.vvvl
+    12, // llvm.ve.vl.vcvtds.vvl
+    12, // llvm.ve.vl.vcvtds.vvvl
+    12, // llvm.ve.vl.vcvtdw.vvl
+    12, // llvm.ve.vl.vcvtdw.vvvl
+    12, // llvm.ve.vl.vcvtld.vvl
+    12, // llvm.ve.vl.vcvtld.vvmvl
+    12, // llvm.ve.vl.vcvtld.vvvl
+    12, // llvm.ve.vl.vcvtldrz.vvl
+    12, // llvm.ve.vl.vcvtldrz.vvmvl
+    12, // llvm.ve.vl.vcvtldrz.vvvl
+    12, // llvm.ve.vl.vcvtsd.vvl
+    12, // llvm.ve.vl.vcvtsd.vvvl
+    12, // llvm.ve.vl.vcvtsw.vvl
+    12, // llvm.ve.vl.vcvtsw.vvvl
+    12, // llvm.ve.vl.vcvtwdsx.vvl
+    12, // llvm.ve.vl.vcvtwdsx.vvmvl
+    12, // llvm.ve.vl.vcvtwdsx.vvvl
+    12, // llvm.ve.vl.vcvtwdsxrz.vvl
+    12, // llvm.ve.vl.vcvtwdsxrz.vvmvl
+    12, // llvm.ve.vl.vcvtwdsxrz.vvvl
+    12, // llvm.ve.vl.vcvtwdzx.vvl
+    12, // llvm.ve.vl.vcvtwdzx.vvmvl
+    12, // llvm.ve.vl.vcvtwdzx.vvvl
+    12, // llvm.ve.vl.vcvtwdzxrz.vvl
+    12, // llvm.ve.vl.vcvtwdzxrz.vvmvl
+    12, // llvm.ve.vl.vcvtwdzxrz.vvvl
+    12, // llvm.ve.vl.vcvtwssx.vvl
+    12, // llvm.ve.vl.vcvtwssx.vvmvl
+    12, // llvm.ve.vl.vcvtwssx.vvvl
+    12, // llvm.ve.vl.vcvtwssxrz.vvl
+    12, // llvm.ve.vl.vcvtwssxrz.vvmvl
+    12, // llvm.ve.vl.vcvtwssxrz.vvvl
+    12, // llvm.ve.vl.vcvtwszx.vvl
+    12, // llvm.ve.vl.vcvtwszx.vvmvl
+    12, // llvm.ve.vl.vcvtwszx.vvvl
+    12, // llvm.ve.vl.vcvtwszxrz.vvl
+    12, // llvm.ve.vl.vcvtwszxrz.vvmvl
+    12, // llvm.ve.vl.vcvtwszxrz.vvvl
+    12, // llvm.ve.vl.vdivsl.vsvl
+    12, // llvm.ve.vl.vdivsl.vsvmvl
+    12, // llvm.ve.vl.vdivsl.vsvvl
+    12, // llvm.ve.vl.vdivsl.vvsl
+    12, // llvm.ve.vl.vdivsl.vvsmvl
+    12, // llvm.ve.vl.vdivsl.vvsvl
+    12, // llvm.ve.vl.vdivsl.vvvl
+    12, // llvm.ve.vl.vdivsl.vvvmvl
+    12, // llvm.ve.vl.vdivsl.vvvvl
+    12, // llvm.ve.vl.vdivswsx.vsvl
+    12, // llvm.ve.vl.vdivswsx.vsvmvl
+    12, // llvm.ve.vl.vdivswsx.vsvvl
+    12, // llvm.ve.vl.vdivswsx.vvsl
+    12, // llvm.ve.vl.vdivswsx.vvsmvl
+    12, // llvm.ve.vl.vdivswsx.vvsvl
+    12, // llvm.ve.vl.vdivswsx.vvvl
+    12, // llvm.ve.vl.vdivswsx.vvvmvl
+    12, // llvm.ve.vl.vdivswsx.vvvvl
+    12, // llvm.ve.vl.vdivswzx.vsvl
+    12, // llvm.ve.vl.vdivswzx.vsvmvl
+    12, // llvm.ve.vl.vdivswzx.vsvvl
+    12, // llvm.ve.vl.vdivswzx.vvsl
+    12, // llvm.ve.vl.vdivswzx.vvsmvl
+    12, // llvm.ve.vl.vdivswzx.vvsvl
+    12, // llvm.ve.vl.vdivswzx.vvvl
+    12, // llvm.ve.vl.vdivswzx.vvvmvl
+    12, // llvm.ve.vl.vdivswzx.vvvvl
+    12, // llvm.ve.vl.vdivul.vsvl
+    12, // llvm.ve.vl.vdivul.vsvmvl
+    12, // llvm.ve.vl.vdivul.vsvvl
+    12, // llvm.ve.vl.vdivul.vvsl
+    12, // llvm.ve.vl.vdivul.vvsmvl
+    12, // llvm.ve.vl.vdivul.vvsvl
+    12, // llvm.ve.vl.vdivul.vvvl
+    12, // llvm.ve.vl.vdivul.vvvmvl
+    12, // llvm.ve.vl.vdivul.vvvvl
+    12, // llvm.ve.vl.vdivuw.vsvl
+    12, // llvm.ve.vl.vdivuw.vsvmvl
+    12, // llvm.ve.vl.vdivuw.vsvvl
+    12, // llvm.ve.vl.vdivuw.vvsl
+    12, // llvm.ve.vl.vdivuw.vvsmvl
+    12, // llvm.ve.vl.vdivuw.vvsvl
+    12, // llvm.ve.vl.vdivuw.vvvl
+    12, // llvm.ve.vl.vdivuw.vvvmvl
+    12, // llvm.ve.vl.vdivuw.vvvvl
+    12, // llvm.ve.vl.veqv.vsvl
+    12, // llvm.ve.vl.veqv.vsvmvl
+    12, // llvm.ve.vl.veqv.vsvvl
+    12, // llvm.ve.vl.veqv.vvvl
+    12, // llvm.ve.vl.veqv.vvvmvl
+    12, // llvm.ve.vl.veqv.vvvvl
+    12, // llvm.ve.vl.vex.vvmvl
+    12, // llvm.ve.vl.vfaddd.vsvl
+    12, // llvm.ve.vl.vfaddd.vsvmvl
+    12, // llvm.ve.vl.vfaddd.vsvvl
+    12, // llvm.ve.vl.vfaddd.vvvl
+    12, // llvm.ve.vl.vfaddd.vvvmvl
+    12, // llvm.ve.vl.vfaddd.vvvvl
+    12, // llvm.ve.vl.vfadds.vsvl
+    12, // llvm.ve.vl.vfadds.vsvmvl
+    12, // llvm.ve.vl.vfadds.vsvvl
+    12, // llvm.ve.vl.vfadds.vvvl
+    12, // llvm.ve.vl.vfadds.vvvmvl
+    12, // llvm.ve.vl.vfadds.vvvvl
+    12, // llvm.ve.vl.vfcmpd.vsvl
+    12, // llvm.ve.vl.vfcmpd.vsvmvl
+    12, // llvm.ve.vl.vfcmpd.vsvvl
+    12, // llvm.ve.vl.vfcmpd.vvvl
+    12, // llvm.ve.vl.vfcmpd.vvvmvl
+    12, // llvm.ve.vl.vfcmpd.vvvvl
+    12, // llvm.ve.vl.vfcmps.vsvl
+    12, // llvm.ve.vl.vfcmps.vsvmvl
+    12, // llvm.ve.vl.vfcmps.vsvvl
+    12, // llvm.ve.vl.vfcmps.vvvl
+    12, // llvm.ve.vl.vfcmps.vvvmvl
+    12, // llvm.ve.vl.vfcmps.vvvvl
+    12, // llvm.ve.vl.vfdivd.vsvl
+    12, // llvm.ve.vl.vfdivd.vsvmvl
+    12, // llvm.ve.vl.vfdivd.vsvvl
+    12, // llvm.ve.vl.vfdivd.vvvl
+    12, // llvm.ve.vl.vfdivd.vvvmvl
+    12, // llvm.ve.vl.vfdivd.vvvvl
+    12, // llvm.ve.vl.vfdivs.vsvl
+    12, // llvm.ve.vl.vfdivs.vsvmvl
+    12, // llvm.ve.vl.vfdivs.vsvvl
+    12, // llvm.ve.vl.vfdivs.vvvl
+    12, // llvm.ve.vl.vfdivs.vvvmvl
+    12, // llvm.ve.vl.vfdivs.vvvvl
+    12, // llvm.ve.vl.vfmadd.vsvvl
+    12, // llvm.ve.vl.vfmadd.vsvvmvl
+    12, // llvm.ve.vl.vfmadd.vsvvvl
+    12, // llvm.ve.vl.vfmadd.vvsvl
+    12, // llvm.ve.vl.vfmadd.vvsvmvl
+    12, // llvm.ve.vl.vfmadd.vvsvvl
+    12, // llvm.ve.vl.vfmadd.vvvvl
+    12, // llvm.ve.vl.vfmadd.vvvvmvl
+    12, // llvm.ve.vl.vfmadd.vvvvvl
+    12, // llvm.ve.vl.vfmads.vsvvl
+    12, // llvm.ve.vl.vfmads.vsvvmvl
+    12, // llvm.ve.vl.vfmads.vsvvvl
+    12, // llvm.ve.vl.vfmads.vvsvl
+    12, // llvm.ve.vl.vfmads.vvsvmvl
+    12, // llvm.ve.vl.vfmads.vvsvvl
+    12, // llvm.ve.vl.vfmads.vvvvl
+    12, // llvm.ve.vl.vfmads.vvvvmvl
+    12, // llvm.ve.vl.vfmads.vvvvvl
+    12, // llvm.ve.vl.vfmaxd.vsvl
+    12, // llvm.ve.vl.vfmaxd.vsvmvl
+    12, // llvm.ve.vl.vfmaxd.vsvvl
+    12, // llvm.ve.vl.vfmaxd.vvvl
+    12, // llvm.ve.vl.vfmaxd.vvvmvl
+    12, // llvm.ve.vl.vfmaxd.vvvvl
+    12, // llvm.ve.vl.vfmaxs.vsvl
+    12, // llvm.ve.vl.vfmaxs.vsvmvl
+    12, // llvm.ve.vl.vfmaxs.vsvvl
+    12, // llvm.ve.vl.vfmaxs.vvvl
+    12, // llvm.ve.vl.vfmaxs.vvvmvl
+    12, // llvm.ve.vl.vfmaxs.vvvvl
+    12, // llvm.ve.vl.vfmind.vsvl
+    12, // llvm.ve.vl.vfmind.vsvmvl
+    12, // llvm.ve.vl.vfmind.vsvvl
+    12, // llvm.ve.vl.vfmind.vvvl
+    12, // llvm.ve.vl.vfmind.vvvmvl
+    12, // llvm.ve.vl.vfmind.vvvvl
+    12, // llvm.ve.vl.vfmins.vsvl
+    12, // llvm.ve.vl.vfmins.vsvmvl
+    12, // llvm.ve.vl.vfmins.vsvvl
+    12, // llvm.ve.vl.vfmins.vvvl
+    12, // llvm.ve.vl.vfmins.vvvmvl
+    12, // llvm.ve.vl.vfmins.vvvvl
+    12, // llvm.ve.vl.vfmkdeq.mvl
+    12, // llvm.ve.vl.vfmkdeq.mvml
+    12, // llvm.ve.vl.vfmkdeqnan.mvl
+    12, // llvm.ve.vl.vfmkdeqnan.mvml
+    12, // llvm.ve.vl.vfmkdge.mvl
+    12, // llvm.ve.vl.vfmkdge.mvml
+    12, // llvm.ve.vl.vfmkdgenan.mvl
+    12, // llvm.ve.vl.vfmkdgenan.mvml
+    12, // llvm.ve.vl.vfmkdgt.mvl
+    12, // llvm.ve.vl.vfmkdgt.mvml
+    12, // llvm.ve.vl.vfmkdgtnan.mvl
+    12, // llvm.ve.vl.vfmkdgtnan.mvml
+    12, // llvm.ve.vl.vfmkdle.mvl
+    12, // llvm.ve.vl.vfmkdle.mvml
+    12, // llvm.ve.vl.vfmkdlenan.mvl
+    12, // llvm.ve.vl.vfmkdlenan.mvml
+    12, // llvm.ve.vl.vfmkdlt.mvl
+    12, // llvm.ve.vl.vfmkdlt.mvml
+    12, // llvm.ve.vl.vfmkdltnan.mvl
+    12, // llvm.ve.vl.vfmkdltnan.mvml
+    12, // llvm.ve.vl.vfmkdnan.mvl
+    12, // llvm.ve.vl.vfmkdnan.mvml
+    12, // llvm.ve.vl.vfmkdne.mvl
+    12, // llvm.ve.vl.vfmkdne.mvml
+    12, // llvm.ve.vl.vfmkdnenan.mvl
+    12, // llvm.ve.vl.vfmkdnenan.mvml
+    12, // llvm.ve.vl.vfmkdnum.mvl
+    12, // llvm.ve.vl.vfmkdnum.mvml
+    12, // llvm.ve.vl.vfmklaf.ml
+    12, // llvm.ve.vl.vfmklat.ml
+    12, // llvm.ve.vl.vfmkleq.mvl
+    12, // llvm.ve.vl.vfmkleq.mvml
+    12, // llvm.ve.vl.vfmkleqnan.mvl
+    12, // llvm.ve.vl.vfmkleqnan.mvml
+    12, // llvm.ve.vl.vfmklge.mvl
+    12, // llvm.ve.vl.vfmklge.mvml
+    12, // llvm.ve.vl.vfmklgenan.mvl
+    12, // llvm.ve.vl.vfmklgenan.mvml
+    12, // llvm.ve.vl.vfmklgt.mvl
+    12, // llvm.ve.vl.vfmklgt.mvml
+    12, // llvm.ve.vl.vfmklgtnan.mvl
+    12, // llvm.ve.vl.vfmklgtnan.mvml
+    12, // llvm.ve.vl.vfmklle.mvl
+    12, // llvm.ve.vl.vfmklle.mvml
+    12, // llvm.ve.vl.vfmkllenan.mvl
+    12, // llvm.ve.vl.vfmkllenan.mvml
+    12, // llvm.ve.vl.vfmkllt.mvl
+    12, // llvm.ve.vl.vfmkllt.mvml
+    12, // llvm.ve.vl.vfmklltnan.mvl
+    12, // llvm.ve.vl.vfmklltnan.mvml
+    12, // llvm.ve.vl.vfmklnan.mvl
+    12, // llvm.ve.vl.vfmklnan.mvml
+    12, // llvm.ve.vl.vfmklne.mvl
+    12, // llvm.ve.vl.vfmklne.mvml
+    12, // llvm.ve.vl.vfmklnenan.mvl
+    12, // llvm.ve.vl.vfmklnenan.mvml
+    12, // llvm.ve.vl.vfmklnum.mvl
+    12, // llvm.ve.vl.vfmklnum.mvml
+    12, // llvm.ve.vl.vfmkseq.mvl
+    12, // llvm.ve.vl.vfmkseq.mvml
+    12, // llvm.ve.vl.vfmkseqnan.mvl
+    12, // llvm.ve.vl.vfmkseqnan.mvml
+    12, // llvm.ve.vl.vfmksge.mvl
+    12, // llvm.ve.vl.vfmksge.mvml
+    12, // llvm.ve.vl.vfmksgenan.mvl
+    12, // llvm.ve.vl.vfmksgenan.mvml
+    12, // llvm.ve.vl.vfmksgt.mvl
+    12, // llvm.ve.vl.vfmksgt.mvml
+    12, // llvm.ve.vl.vfmksgtnan.mvl
+    12, // llvm.ve.vl.vfmksgtnan.mvml
+    12, // llvm.ve.vl.vfmksle.mvl
+    12, // llvm.ve.vl.vfmksle.mvml
+    12, // llvm.ve.vl.vfmkslenan.mvl
+    12, // llvm.ve.vl.vfmkslenan.mvml
+    12, // llvm.ve.vl.vfmkslt.mvl
+    12, // llvm.ve.vl.vfmkslt.mvml
+    12, // llvm.ve.vl.vfmksltnan.mvl
+    12, // llvm.ve.vl.vfmksltnan.mvml
+    12, // llvm.ve.vl.vfmksnan.mvl
+    12, // llvm.ve.vl.vfmksnan.mvml
+    12, // llvm.ve.vl.vfmksne.mvl
+    12, // llvm.ve.vl.vfmksne.mvml
+    12, // llvm.ve.vl.vfmksnenan.mvl
+    12, // llvm.ve.vl.vfmksnenan.mvml
+    12, // llvm.ve.vl.vfmksnum.mvl
+    12, // llvm.ve.vl.vfmksnum.mvml
+    12, // llvm.ve.vl.vfmkweq.mvl
+    12, // llvm.ve.vl.vfmkweq.mvml
+    12, // llvm.ve.vl.vfmkweqnan.mvl
+    12, // llvm.ve.vl.vfmkweqnan.mvml
+    12, // llvm.ve.vl.vfmkwge.mvl
+    12, // llvm.ve.vl.vfmkwge.mvml
+    12, // llvm.ve.vl.vfmkwgenan.mvl
+    12, // llvm.ve.vl.vfmkwgenan.mvml
+    12, // llvm.ve.vl.vfmkwgt.mvl
+    12, // llvm.ve.vl.vfmkwgt.mvml
+    12, // llvm.ve.vl.vfmkwgtnan.mvl
+    12, // llvm.ve.vl.vfmkwgtnan.mvml
+    12, // llvm.ve.vl.vfmkwle.mvl
+    12, // llvm.ve.vl.vfmkwle.mvml
+    12, // llvm.ve.vl.vfmkwlenan.mvl
+    12, // llvm.ve.vl.vfmkwlenan.mvml
+    12, // llvm.ve.vl.vfmkwlt.mvl
+    12, // llvm.ve.vl.vfmkwlt.mvml
+    12, // llvm.ve.vl.vfmkwltnan.mvl
+    12, // llvm.ve.vl.vfmkwltnan.mvml
+    12, // llvm.ve.vl.vfmkwnan.mvl
+    12, // llvm.ve.vl.vfmkwnan.mvml
+    12, // llvm.ve.vl.vfmkwne.mvl
+    12, // llvm.ve.vl.vfmkwne.mvml
+    12, // llvm.ve.vl.vfmkwnenan.mvl
+    12, // llvm.ve.vl.vfmkwnenan.mvml
+    12, // llvm.ve.vl.vfmkwnum.mvl
+    12, // llvm.ve.vl.vfmkwnum.mvml
+    12, // llvm.ve.vl.vfmsbd.vsvvl
+    12, // llvm.ve.vl.vfmsbd.vsvvmvl
+    12, // llvm.ve.vl.vfmsbd.vsvvvl
+    12, // llvm.ve.vl.vfmsbd.vvsvl
+    12, // llvm.ve.vl.vfmsbd.vvsvmvl
+    12, // llvm.ve.vl.vfmsbd.vvsvvl
+    12, // llvm.ve.vl.vfmsbd.vvvvl
+    12, // llvm.ve.vl.vfmsbd.vvvvmvl
+    12, // llvm.ve.vl.vfmsbd.vvvvvl
+    12, // llvm.ve.vl.vfmsbs.vsvvl
+    12, // llvm.ve.vl.vfmsbs.vsvvmvl
+    12, // llvm.ve.vl.vfmsbs.vsvvvl
+    12, // llvm.ve.vl.vfmsbs.vvsvl
+    12, // llvm.ve.vl.vfmsbs.vvsvmvl
+    12, // llvm.ve.vl.vfmsbs.vvsvvl
+    12, // llvm.ve.vl.vfmsbs.vvvvl
+    12, // llvm.ve.vl.vfmsbs.vvvvmvl
+    12, // llvm.ve.vl.vfmsbs.vvvvvl
+    12, // llvm.ve.vl.vfmuld.vsvl
+    12, // llvm.ve.vl.vfmuld.vsvmvl
+    12, // llvm.ve.vl.vfmuld.vsvvl
+    12, // llvm.ve.vl.vfmuld.vvvl
+    12, // llvm.ve.vl.vfmuld.vvvmvl
+    12, // llvm.ve.vl.vfmuld.vvvvl
+    12, // llvm.ve.vl.vfmuls.vsvl
+    12, // llvm.ve.vl.vfmuls.vsvmvl
+    12, // llvm.ve.vl.vfmuls.vsvvl
+    12, // llvm.ve.vl.vfmuls.vvvl
+    12, // llvm.ve.vl.vfmuls.vvvmvl
+    12, // llvm.ve.vl.vfmuls.vvvvl
+    12, // llvm.ve.vl.vfnmadd.vsvvl
+    12, // llvm.ve.vl.vfnmadd.vsvvmvl
+    12, // llvm.ve.vl.vfnmadd.vsvvvl
+    12, // llvm.ve.vl.vfnmadd.vvsvl
+    12, // llvm.ve.vl.vfnmadd.vvsvmvl
+    12, // llvm.ve.vl.vfnmadd.vvsvvl
+    12, // llvm.ve.vl.vfnmadd.vvvvl
+    12, // llvm.ve.vl.vfnmadd.vvvvmvl
+    12, // llvm.ve.vl.vfnmadd.vvvvvl
+    12, // llvm.ve.vl.vfnmads.vsvvl
+    12, // llvm.ve.vl.vfnmads.vsvvmvl
+    12, // llvm.ve.vl.vfnmads.vsvvvl
+    12, // llvm.ve.vl.vfnmads.vvsvl
+    12, // llvm.ve.vl.vfnmads.vvsvmvl
+    12, // llvm.ve.vl.vfnmads.vvsvvl
+    12, // llvm.ve.vl.vfnmads.vvvvl
+    12, // llvm.ve.vl.vfnmads.vvvvmvl
+    12, // llvm.ve.vl.vfnmads.vvvvvl
+    12, // llvm.ve.vl.vfnmsbd.vsvvl
+    12, // llvm.ve.vl.vfnmsbd.vsvvmvl
+    12, // llvm.ve.vl.vfnmsbd.vsvvvl
+    12, // llvm.ve.vl.vfnmsbd.vvsvl
+    12, // llvm.ve.vl.vfnmsbd.vvsvmvl
+    12, // llvm.ve.vl.vfnmsbd.vvsvvl
+    12, // llvm.ve.vl.vfnmsbd.vvvvl
+    12, // llvm.ve.vl.vfnmsbd.vvvvmvl
+    12, // llvm.ve.vl.vfnmsbd.vvvvvl
+    12, // llvm.ve.vl.vfnmsbs.vsvvl
+    12, // llvm.ve.vl.vfnmsbs.vsvvmvl
+    12, // llvm.ve.vl.vfnmsbs.vsvvvl
+    12, // llvm.ve.vl.vfnmsbs.vvsvl
+    12, // llvm.ve.vl.vfnmsbs.vvsvmvl
+    12, // llvm.ve.vl.vfnmsbs.vvsvvl
+    12, // llvm.ve.vl.vfnmsbs.vvvvl
+    12, // llvm.ve.vl.vfnmsbs.vvvvmvl
+    12, // llvm.ve.vl.vfnmsbs.vvvvvl
+    12, // llvm.ve.vl.vfrmaxdfst.vvl
+    12, // llvm.ve.vl.vfrmaxdfst.vvvl
+    12, // llvm.ve.vl.vfrmaxdlst.vvl
+    12, // llvm.ve.vl.vfrmaxdlst.vvvl
+    12, // llvm.ve.vl.vfrmaxsfst.vvl
+    12, // llvm.ve.vl.vfrmaxsfst.vvvl
+    12, // llvm.ve.vl.vfrmaxslst.vvl
+    12, // llvm.ve.vl.vfrmaxslst.vvvl
+    12, // llvm.ve.vl.vfrmindfst.vvl
+    12, // llvm.ve.vl.vfrmindfst.vvvl
+    12, // llvm.ve.vl.vfrmindlst.vvl
+    12, // llvm.ve.vl.vfrmindlst.vvvl
+    12, // llvm.ve.vl.vfrminsfst.vvl
+    12, // llvm.ve.vl.vfrminsfst.vvvl
+    12, // llvm.ve.vl.vfrminslst.vvl
+    12, // llvm.ve.vl.vfrminslst.vvvl
+    12, // llvm.ve.vl.vfsqrtd.vvl
+    12, // llvm.ve.vl.vfsqrtd.vvvl
+    12, // llvm.ve.vl.vfsqrts.vvl
+    12, // llvm.ve.vl.vfsqrts.vvvl
+    12, // llvm.ve.vl.vfsubd.vsvl
+    12, // llvm.ve.vl.vfsubd.vsvmvl
+    12, // llvm.ve.vl.vfsubd.vsvvl
+    12, // llvm.ve.vl.vfsubd.vvvl
+    12, // llvm.ve.vl.vfsubd.vvvmvl
+    12, // llvm.ve.vl.vfsubd.vvvvl
+    12, // llvm.ve.vl.vfsubs.vsvl
+    12, // llvm.ve.vl.vfsubs.vsvmvl
+    12, // llvm.ve.vl.vfsubs.vsvvl
+    12, // llvm.ve.vl.vfsubs.vvvl
+    12, // llvm.ve.vl.vfsubs.vvvmvl
+    12, // llvm.ve.vl.vfsubs.vvvvl
+    12, // llvm.ve.vl.vfsumd.vvl
+    12, // llvm.ve.vl.vfsumd.vvml
+    12, // llvm.ve.vl.vfsums.vvl
+    12, // llvm.ve.vl.vfsums.vvml
+    21, // llvm.ve.vl.vgt.vvssl
+    21, // llvm.ve.vl.vgt.vvssml
+    21, // llvm.ve.vl.vgt.vvssmvl
+    21, // llvm.ve.vl.vgt.vvssvl
+    21, // llvm.ve.vl.vgtlsx.vvssl
+    21, // llvm.ve.vl.vgtlsx.vvssml
+    21, // llvm.ve.vl.vgtlsx.vvssmvl
+    21, // llvm.ve.vl.vgtlsx.vvssvl
+    21, // llvm.ve.vl.vgtlsxnc.vvssl
+    21, // llvm.ve.vl.vgtlsxnc.vvssml
+    21, // llvm.ve.vl.vgtlsxnc.vvssmvl
+    21, // llvm.ve.vl.vgtlsxnc.vvssvl
+    21, // llvm.ve.vl.vgtlzx.vvssl
+    21, // llvm.ve.vl.vgtlzx.vvssml
+    21, // llvm.ve.vl.vgtlzx.vvssmvl
+    21, // llvm.ve.vl.vgtlzx.vvssvl
+    21, // llvm.ve.vl.vgtlzxnc.vvssl
+    21, // llvm.ve.vl.vgtlzxnc.vvssml
+    21, // llvm.ve.vl.vgtlzxnc.vvssmvl
+    21, // llvm.ve.vl.vgtlzxnc.vvssvl
+    21, // llvm.ve.vl.vgtnc.vvssl
+    21, // llvm.ve.vl.vgtnc.vvssml
+    21, // llvm.ve.vl.vgtnc.vvssmvl
+    21, // llvm.ve.vl.vgtnc.vvssvl
+    21, // llvm.ve.vl.vgtu.vvssl
+    21, // llvm.ve.vl.vgtu.vvssml
+    21, // llvm.ve.vl.vgtu.vvssmvl
+    21, // llvm.ve.vl.vgtu.vvssvl
+    21, // llvm.ve.vl.vgtunc.vvssl
+    21, // llvm.ve.vl.vgtunc.vvssml
+    21, // llvm.ve.vl.vgtunc.vvssmvl
+    21, // llvm.ve.vl.vgtunc.vvssvl
+    21, // llvm.ve.vl.vld.vssl
+    21, // llvm.ve.vl.vld.vssvl
+    21, // llvm.ve.vl.vld2d.vssl
+    21, // llvm.ve.vl.vld2d.vssvl
+    21, // llvm.ve.vl.vld2dnc.vssl
+    21, // llvm.ve.vl.vld2dnc.vssvl
+    21, // llvm.ve.vl.vldl2dsx.vssl
+    21, // llvm.ve.vl.vldl2dsx.vssvl
+    21, // llvm.ve.vl.vldl2dsxnc.vssl
+    21, // llvm.ve.vl.vldl2dsxnc.vssvl
+    21, // llvm.ve.vl.vldl2dzx.vssl
+    21, // llvm.ve.vl.vldl2dzx.vssvl
+    21, // llvm.ve.vl.vldl2dzxnc.vssl
+    21, // llvm.ve.vl.vldl2dzxnc.vssvl
+    21, // llvm.ve.vl.vldlsx.vssl
+    21, // llvm.ve.vl.vldlsx.vssvl
+    21, // llvm.ve.vl.vldlsxnc.vssl
+    21, // llvm.ve.vl.vldlsxnc.vssvl
+    21, // llvm.ve.vl.vldlzx.vssl
+    21, // llvm.ve.vl.vldlzx.vssvl
+    21, // llvm.ve.vl.vldlzxnc.vssl
+    21, // llvm.ve.vl.vldlzxnc.vssvl
+    21, // llvm.ve.vl.vldnc.vssl
+    21, // llvm.ve.vl.vldnc.vssvl
+    21, // llvm.ve.vl.vldu.vssl
+    21, // llvm.ve.vl.vldu.vssvl
+    21, // llvm.ve.vl.vldu2d.vssl
+    21, // llvm.ve.vl.vldu2d.vssvl
+    21, // llvm.ve.vl.vldu2dnc.vssl
+    21, // llvm.ve.vl.vldu2dnc.vssvl
+    21, // llvm.ve.vl.vldunc.vssl
+    21, // llvm.ve.vl.vldunc.vssvl
+    12, // llvm.ve.vl.vmaxsl.vsvl
+    12, // llvm.ve.vl.vmaxsl.vsvmvl
+    12, // llvm.ve.vl.vmaxsl.vsvvl
+    12, // llvm.ve.vl.vmaxsl.vvvl
+    12, // llvm.ve.vl.vmaxsl.vvvmvl
+    12, // llvm.ve.vl.vmaxsl.vvvvl
+    12, // llvm.ve.vl.vmaxswsx.vsvl
+    12, // llvm.ve.vl.vmaxswsx.vsvmvl
+    12, // llvm.ve.vl.vmaxswsx.vsvvl
+    12, // llvm.ve.vl.vmaxswsx.vvvl
+    12, // llvm.ve.vl.vmaxswsx.vvvmvl
+    12, // llvm.ve.vl.vmaxswsx.vvvvl
+    12, // llvm.ve.vl.vmaxswzx.vsvl
+    12, // llvm.ve.vl.vmaxswzx.vsvmvl
+    12, // llvm.ve.vl.vmaxswzx.vsvvl
+    12, // llvm.ve.vl.vmaxswzx.vvvl
+    12, // llvm.ve.vl.vmaxswzx.vvvmvl
+    12, // llvm.ve.vl.vmaxswzx.vvvvl
+    12, // llvm.ve.vl.vminsl.vsvl
+    12, // llvm.ve.vl.vminsl.vsvmvl
+    12, // llvm.ve.vl.vminsl.vsvvl
+    12, // llvm.ve.vl.vminsl.vvvl
+    12, // llvm.ve.vl.vminsl.vvvmvl
+    12, // llvm.ve.vl.vminsl.vvvvl
+    12, // llvm.ve.vl.vminswsx.vsvl
+    12, // llvm.ve.vl.vminswsx.vsvmvl
+    12, // llvm.ve.vl.vminswsx.vsvvl
+    12, // llvm.ve.vl.vminswsx.vvvl
+    12, // llvm.ve.vl.vminswsx.vvvmvl
+    12, // llvm.ve.vl.vminswsx.vvvvl
+    12, // llvm.ve.vl.vminswzx.vsvl
+    12, // llvm.ve.vl.vminswzx.vsvmvl
+    12, // llvm.ve.vl.vminswzx.vsvvl
+    12, // llvm.ve.vl.vminswzx.vvvl
+    12, // llvm.ve.vl.vminswzx.vvvmvl
+    12, // llvm.ve.vl.vminswzx.vvvvl
+    12, // llvm.ve.vl.vmrg.vsvml
+    12, // llvm.ve.vl.vmrg.vsvmvl
+    12, // llvm.ve.vl.vmrg.vvvml
+    12, // llvm.ve.vl.vmrg.vvvmvl
+    12, // llvm.ve.vl.vmrgw.vsvMl
+    12, // llvm.ve.vl.vmrgw.vsvMvl
+    12, // llvm.ve.vl.vmrgw.vvvMl
+    12, // llvm.ve.vl.vmrgw.vvvMvl
+    12, // llvm.ve.vl.vmulsl.vsvl
+    12, // llvm.ve.vl.vmulsl.vsvmvl
+    12, // llvm.ve.vl.vmulsl.vsvvl
+    12, // llvm.ve.vl.vmulsl.vvvl
+    12, // llvm.ve.vl.vmulsl.vvvmvl
+    12, // llvm.ve.vl.vmulsl.vvvvl
+    12, // llvm.ve.vl.vmulslw.vsvl
+    12, // llvm.ve.vl.vmulslw.vsvvl
+    12, // llvm.ve.vl.vmulslw.vvvl
+    12, // llvm.ve.vl.vmulslw.vvvvl
+    12, // llvm.ve.vl.vmulswsx.vsvl
+    12, // llvm.ve.vl.vmulswsx.vsvmvl
+    12, // llvm.ve.vl.vmulswsx.vsvvl
+    12, // llvm.ve.vl.vmulswsx.vvvl
+    12, // llvm.ve.vl.vmulswsx.vvvmvl
+    12, // llvm.ve.vl.vmulswsx.vvvvl
+    12, // llvm.ve.vl.vmulswzx.vsvl
+    12, // llvm.ve.vl.vmulswzx.vsvmvl
+    12, // llvm.ve.vl.vmulswzx.vsvvl
+    12, // llvm.ve.vl.vmulswzx.vvvl
+    12, // llvm.ve.vl.vmulswzx.vvvmvl
+    12, // llvm.ve.vl.vmulswzx.vvvvl
+    12, // llvm.ve.vl.vmulul.vsvl
+    12, // llvm.ve.vl.vmulul.vsvmvl
+    12, // llvm.ve.vl.vmulul.vsvvl
+    12, // llvm.ve.vl.vmulul.vvvl
+    12, // llvm.ve.vl.vmulul.vvvmvl
+    12, // llvm.ve.vl.vmulul.vvvvl
+    12, // llvm.ve.vl.vmuluw.vsvl
+    12, // llvm.ve.vl.vmuluw.vsvmvl
+    12, // llvm.ve.vl.vmuluw.vsvvl
+    12, // llvm.ve.vl.vmuluw.vvvl
+    12, // llvm.ve.vl.vmuluw.vvvmvl
+    12, // llvm.ve.vl.vmuluw.vvvvl
+    12, // llvm.ve.vl.vmv.vsvl
+    12, // llvm.ve.vl.vmv.vsvmvl
+    12, // llvm.ve.vl.vmv.vsvvl
+    12, // llvm.ve.vl.vor.vsvl
+    12, // llvm.ve.vl.vor.vsvmvl
+    12, // llvm.ve.vl.vor.vsvvl
+    12, // llvm.ve.vl.vor.vvvl
+    12, // llvm.ve.vl.vor.vvvmvl
+    12, // llvm.ve.vl.vor.vvvvl
+    12, // llvm.ve.vl.vrand.vvl
+    12, // llvm.ve.vl.vrand.vvml
+    12, // llvm.ve.vl.vrcpd.vvl
+    12, // llvm.ve.vl.vrcpd.vvvl
+    12, // llvm.ve.vl.vrcps.vvl
+    12, // llvm.ve.vl.vrcps.vvvl
+    12, // llvm.ve.vl.vrmaxslfst.vvl
+    12, // llvm.ve.vl.vrmaxslfst.vvvl
+    12, // llvm.ve.vl.vrmaxsllst.vvl
+    12, // llvm.ve.vl.vrmaxsllst.vvvl
+    12, // llvm.ve.vl.vrmaxswfstsx.vvl
+    12, // llvm.ve.vl.vrmaxswfstsx.vvvl
+    12, // llvm.ve.vl.vrmaxswfstzx.vvl
+    12, // llvm.ve.vl.vrmaxswfstzx.vvvl
+    12, // llvm.ve.vl.vrmaxswlstsx.vvl
+    12, // llvm.ve.vl.vrmaxswlstsx.vvvl
+    12, // llvm.ve.vl.vrmaxswlstzx.vvl
+    12, // llvm.ve.vl.vrmaxswlstzx.vvvl
+    12, // llvm.ve.vl.vrminslfst.vvl
+    12, // llvm.ve.vl.vrminslfst.vvvl
+    12, // llvm.ve.vl.vrminsllst.vvl
+    12, // llvm.ve.vl.vrminsllst.vvvl
+    12, // llvm.ve.vl.vrminswfstsx.vvl
+    12, // llvm.ve.vl.vrminswfstsx.vvvl
+    12, // llvm.ve.vl.vrminswfstzx.vvl
+    12, // llvm.ve.vl.vrminswfstzx.vvvl
+    12, // llvm.ve.vl.vrminswlstsx.vvl
+    12, // llvm.ve.vl.vrminswlstsx.vvvl
+    12, // llvm.ve.vl.vrminswlstzx.vvl
+    12, // llvm.ve.vl.vrminswlstzx.vvvl
+    12, // llvm.ve.vl.vror.vvl
+    12, // llvm.ve.vl.vror.vvml
+    12, // llvm.ve.vl.vrsqrtd.vvl
+    12, // llvm.ve.vl.vrsqrtd.vvvl
+    12, // llvm.ve.vl.vrsqrtdnex.vvl
+    12, // llvm.ve.vl.vrsqrtdnex.vvvl
+    12, // llvm.ve.vl.vrsqrts.vvl
+    12, // llvm.ve.vl.vrsqrts.vvvl
+    12, // llvm.ve.vl.vrsqrtsnex.vvl
+    12, // llvm.ve.vl.vrsqrtsnex.vvvl
+    12, // llvm.ve.vl.vrxor.vvl
+    12, // llvm.ve.vl.vrxor.vvml
+    69, // llvm.ve.vl.vsc.vvssl
+    69, // llvm.ve.vl.vsc.vvssml
+    69, // llvm.ve.vl.vscl.vvssl
+    69, // llvm.ve.vl.vscl.vvssml
+    69, // llvm.ve.vl.vsclnc.vvssl
+    69, // llvm.ve.vl.vsclnc.vvssml
+    69, // llvm.ve.vl.vsclncot.vvssl
+    69, // llvm.ve.vl.vsclncot.vvssml
+    69, // llvm.ve.vl.vsclot.vvssl
+    69, // llvm.ve.vl.vsclot.vvssml
+    69, // llvm.ve.vl.vscnc.vvssl
+    69, // llvm.ve.vl.vscnc.vvssml
+    69, // llvm.ve.vl.vscncot.vvssl
+    69, // llvm.ve.vl.vscncot.vvssml
+    69, // llvm.ve.vl.vscot.vvssl
+    69, // llvm.ve.vl.vscot.vvssml
+    69, // llvm.ve.vl.vscu.vvssl
+    69, // llvm.ve.vl.vscu.vvssml
+    69, // llvm.ve.vl.vscunc.vvssl
+    69, // llvm.ve.vl.vscunc.vvssml
+    69, // llvm.ve.vl.vscuncot.vvssl
+    69, // llvm.ve.vl.vscuncot.vvssml
+    69, // llvm.ve.vl.vscuot.vvssl
+    69, // llvm.ve.vl.vscuot.vvssml
+    12, // llvm.ve.vl.vseq.vl
+    12, // llvm.ve.vl.vseq.vvl
+    12, // llvm.ve.vl.vsfa.vvssl
+    12, // llvm.ve.vl.vsfa.vvssmvl
+    12, // llvm.ve.vl.vsfa.vvssvl
+    12, // llvm.ve.vl.vshf.vvvsl
+    12, // llvm.ve.vl.vshf.vvvsvl
+    12, // llvm.ve.vl.vslal.vvsl
+    12, // llvm.ve.vl.vslal.vvsmvl
+    12, // llvm.ve.vl.vslal.vvsvl
+    12, // llvm.ve.vl.vslal.vvvl
+    12, // llvm.ve.vl.vslal.vvvmvl
+    12, // llvm.ve.vl.vslal.vvvvl
+    12, // llvm.ve.vl.vslawsx.vvsl
+    12, // llvm.ve.vl.vslawsx.vvsmvl
+    12, // llvm.ve.vl.vslawsx.vvsvl
+    12, // llvm.ve.vl.vslawsx.vvvl
+    12, // llvm.ve.vl.vslawsx.vvvmvl
+    12, // llvm.ve.vl.vslawsx.vvvvl
+    12, // llvm.ve.vl.vslawzx.vvsl
+    12, // llvm.ve.vl.vslawzx.vvsmvl
+    12, // llvm.ve.vl.vslawzx.vvsvl
+    12, // llvm.ve.vl.vslawzx.vvvl
+    12, // llvm.ve.vl.vslawzx.vvvmvl
+    12, // llvm.ve.vl.vslawzx.vvvvl
+    12, // llvm.ve.vl.vsll.vvsl
+    12, // llvm.ve.vl.vsll.vvsmvl
+    12, // llvm.ve.vl.vsll.vvsvl
+    12, // llvm.ve.vl.vsll.vvvl
+    12, // llvm.ve.vl.vsll.vvvmvl
+    12, // llvm.ve.vl.vsll.vvvvl
+    12, // llvm.ve.vl.vsral.vvsl
+    12, // llvm.ve.vl.vsral.vvsmvl
+    12, // llvm.ve.vl.vsral.vvsvl
+    12, // llvm.ve.vl.vsral.vvvl
+    12, // llvm.ve.vl.vsral.vvvmvl
+    12, // llvm.ve.vl.vsral.vvvvl
+    12, // llvm.ve.vl.vsrawsx.vvsl
+    12, // llvm.ve.vl.vsrawsx.vvsmvl
+    12, // llvm.ve.vl.vsrawsx.vvsvl
+    12, // llvm.ve.vl.vsrawsx.vvvl
+    12, // llvm.ve.vl.vsrawsx.vvvmvl
+    12, // llvm.ve.vl.vsrawsx.vvvvl
+    12, // llvm.ve.vl.vsrawzx.vvsl
+    12, // llvm.ve.vl.vsrawzx.vvsmvl
+    12, // llvm.ve.vl.vsrawzx.vvsvl
+    12, // llvm.ve.vl.vsrawzx.vvvl
+    12, // llvm.ve.vl.vsrawzx.vvvmvl
+    12, // llvm.ve.vl.vsrawzx.vvvvl
+    12, // llvm.ve.vl.vsrl.vvsl
+    12, // llvm.ve.vl.vsrl.vvsmvl
+    12, // llvm.ve.vl.vsrl.vvsvl
+    12, // llvm.ve.vl.vsrl.vvvl
+    12, // llvm.ve.vl.vsrl.vvvmvl
+    12, // llvm.ve.vl.vsrl.vvvvl
+    69, // llvm.ve.vl.vst.vssl
+    69, // llvm.ve.vl.vst.vssml
+    69, // llvm.ve.vl.vst2d.vssl
+    69, // llvm.ve.vl.vst2d.vssml
+    69, // llvm.ve.vl.vst2dnc.vssl
+    69, // llvm.ve.vl.vst2dnc.vssml
+    69, // llvm.ve.vl.vst2dncot.vssl
+    69, // llvm.ve.vl.vst2dncot.vssml
+    69, // llvm.ve.vl.vst2dot.vssl
+    69, // llvm.ve.vl.vst2dot.vssml
+    69, // llvm.ve.vl.vstl.vssl
+    69, // llvm.ve.vl.vstl.vssml
+    69, // llvm.ve.vl.vstl2d.vssl
+    69, // llvm.ve.vl.vstl2d.vssml
+    69, // llvm.ve.vl.vstl2dnc.vssl
+    69, // llvm.ve.vl.vstl2dnc.vssml
+    69, // llvm.ve.vl.vstl2dncot.vssl
+    69, // llvm.ve.vl.vstl2dncot.vssml
+    69, // llvm.ve.vl.vstl2dot.vssl
+    69, // llvm.ve.vl.vstl2dot.vssml
+    69, // llvm.ve.vl.vstlnc.vssl
+    69, // llvm.ve.vl.vstlnc.vssml
+    69, // llvm.ve.vl.vstlncot.vssl
+    69, // llvm.ve.vl.vstlncot.vssml
+    69, // llvm.ve.vl.vstlot.vssl
+    69, // llvm.ve.vl.vstlot.vssml
+    69, // llvm.ve.vl.vstnc.vssl
+    69, // llvm.ve.vl.vstnc.vssml
+    69, // llvm.ve.vl.vstncot.vssl
+    69, // llvm.ve.vl.vstncot.vssml
+    69, // llvm.ve.vl.vstot.vssl
+    69, // llvm.ve.vl.vstot.vssml
+    69, // llvm.ve.vl.vstu.vssl
+    69, // llvm.ve.vl.vstu.vssml
+    69, // llvm.ve.vl.vstu2d.vssl
+    69, // llvm.ve.vl.vstu2d.vssml
+    69, // llvm.ve.vl.vstu2dnc.vssl
+    69, // llvm.ve.vl.vstu2dnc.vssml
+    69, // llvm.ve.vl.vstu2dncot.vssl
+    69, // llvm.ve.vl.vstu2dncot.vssml
+    69, // llvm.ve.vl.vstu2dot.vssl
+    69, // llvm.ve.vl.vstu2dot.vssml
+    69, // llvm.ve.vl.vstunc.vssl
+    69, // llvm.ve.vl.vstunc.vssml
+    69, // llvm.ve.vl.vstuncot.vssl
+    69, // llvm.ve.vl.vstuncot.vssml
+    69, // llvm.ve.vl.vstuot.vssl
+    69, // llvm.ve.vl.vstuot.vssml
+    12, // llvm.ve.vl.vsubsl.vsvl
+    12, // llvm.ve.vl.vsubsl.vsvmvl
+    12, // llvm.ve.vl.vsubsl.vsvvl
+    12, // llvm.ve.vl.vsubsl.vvvl
+    12, // llvm.ve.vl.vsubsl.vvvmvl
+    12, // llvm.ve.vl.vsubsl.vvvvl
+    12, // llvm.ve.vl.vsubswsx.vsvl
+    12, // llvm.ve.vl.vsubswsx.vsvmvl
+    12, // llvm.ve.vl.vsubswsx.vsvvl
+    12, // llvm.ve.vl.vsubswsx.vvvl
+    12, // llvm.ve.vl.vsubswsx.vvvmvl
+    12, // llvm.ve.vl.vsubswsx.vvvvl
+    12, // llvm.ve.vl.vsubswzx.vsvl
+    12, // llvm.ve.vl.vsubswzx.vsvmvl
+    12, // llvm.ve.vl.vsubswzx.vsvvl
+    12, // llvm.ve.vl.vsubswzx.vvvl
+    12, // llvm.ve.vl.vsubswzx.vvvmvl
+    12, // llvm.ve.vl.vsubswzx.vvvvl
+    12, // llvm.ve.vl.vsubul.vsvl
+    12, // llvm.ve.vl.vsubul.vsvmvl
+    12, // llvm.ve.vl.vsubul.vsvvl
+    12, // llvm.ve.vl.vsubul.vvvl
+    12, // llvm.ve.vl.vsubul.vvvmvl
+    12, // llvm.ve.vl.vsubul.vvvvl
+    12, // llvm.ve.vl.vsubuw.vsvl
+    12, // llvm.ve.vl.vsubuw.vsvmvl
+    12, // llvm.ve.vl.vsubuw.vsvvl
+    12, // llvm.ve.vl.vsubuw.vvvl
+    12, // llvm.ve.vl.vsubuw.vvvmvl
+    12, // llvm.ve.vl.vsubuw.vvvvl
+    12, // llvm.ve.vl.vsuml.vvl
+    12, // llvm.ve.vl.vsuml.vvml
+    12, // llvm.ve.vl.vsumwsx.vvl
+    12, // llvm.ve.vl.vsumwsx.vvml
+    12, // llvm.ve.vl.vsumwzx.vvl
+    12, // llvm.ve.vl.vsumwzx.vvml
+    12, // llvm.ve.vl.vxor.vsvl
+    12, // llvm.ve.vl.vxor.vsvmvl
+    12, // llvm.ve.vl.vxor.vsvvl
+    12, // llvm.ve.vl.vxor.vvvl
+    12, // llvm.ve.vl.vxor.vvvmvl
+    12, // llvm.ve.vl.vxor.vvvvl
+    12, // llvm.ve.vl.xorm.MMM
+    12, // llvm.ve.vl.xorm.mmm
+    203, // llvm.wasm.alltrue
+    203, // llvm.wasm.anytrue
+    203, // llvm.wasm.avgr.unsigned
+    203, // llvm.wasm.bitmask
+    203, // llvm.wasm.bitselect
+    204, // llvm.wasm.catch
+    203, // llvm.wasm.ceil
+    203, // llvm.wasm.dot
+    203, // llvm.wasm.eq
+    203, // llvm.wasm.extadd.pairwise.signed
+    203, // llvm.wasm.extadd.pairwise.unsigned
+    203, // llvm.wasm.extmul.high.signed
+    203, // llvm.wasm.extmul.high.unsigned
+    203, // llvm.wasm.extmul.low.signed
+    203, // llvm.wasm.extmul.low.unsigned
+    203, // llvm.wasm.floor
+    56, // llvm.wasm.get.ehselector
+    56, // llvm.wasm.get.exception
+    78, // llvm.wasm.landingpad.index
+    3, // llvm.wasm.load16.lane
+    3, // llvm.wasm.load32.lane
+    3, // llvm.wasm.load32.zero
+    3, // llvm.wasm.load64.lane
+    3, // llvm.wasm.load64.zero
+    3, // llvm.wasm.load8.lane
+    12, // llvm.wasm.lsda
+    205, // llvm.wasm.memory.atomic.notify
+    206, // llvm.wasm.memory.atomic.wait32
+    206, // llvm.wasm.memory.atomic.wait64
+    7, // llvm.wasm.memory.grow
+    21, // llvm.wasm.memory.size
+    203, // llvm.wasm.narrow.signed
+    203, // llvm.wasm.narrow.unsigned
+    203, // llvm.wasm.nearest
+    203, // llvm.wasm.pmax
+    203, // llvm.wasm.pmin
+    203, // llvm.wasm.popcnt
+    207, // llvm.wasm.prefetch.nt
+    207, // llvm.wasm.prefetch.t
+    203, // llvm.wasm.q15mulr.saturate.signed
+    203, // llvm.wasm.qfma
+    203, // llvm.wasm.qfms
+    208, // llvm.wasm.rethrow
+    203, // llvm.wasm.shuffle
+    203, // llvm.wasm.signselect
+    80, // llvm.wasm.store16.lane
+    80, // llvm.wasm.store32.lane
+    80, // llvm.wasm.store64.lane
+    80, // llvm.wasm.store8.lane
+    203, // llvm.wasm.sub.saturate.signed
+    203, // llvm.wasm.sub.saturate.unsigned
+    203, // llvm.wasm.swizzle
+    209, // llvm.wasm.throw
+    203, // llvm.wasm.tls.align
+    21, // llvm.wasm.tls.base
+    203, // llvm.wasm.tls.size
+    203, // llvm.wasm.trunc
+    203, // llvm.wasm.trunc.saturate.signed
+    203, // llvm.wasm.trunc.saturate.unsigned
+    12, // llvm.wasm.trunc.signed
+    12, // llvm.wasm.trunc.unsigned
+    203, // llvm.wasm.widen.high.signed
+    203, // llvm.wasm.widen.high.unsigned
+    203, // llvm.wasm.widen.low.signed
+    203, // llvm.wasm.widen.low.unsigned
+    12, // llvm.x86.3dnow.pavgusb
+    12, // llvm.x86.3dnow.pf2id
+    12, // llvm.x86.3dnow.pfacc
+    12, // llvm.x86.3dnow.pfadd
+    12, // llvm.x86.3dnow.pfcmpeq
+    12, // llvm.x86.3dnow.pfcmpge
+    12, // llvm.x86.3dnow.pfcmpgt
+    12, // llvm.x86.3dnow.pfmax
+    12, // llvm.x86.3dnow.pfmin
+    12, // llvm.x86.3dnow.pfmul
+    12, // llvm.x86.3dnow.pfrcp
+    12, // llvm.x86.3dnow.pfrcpit1
+    12, // llvm.x86.3dnow.pfrcpit2
+    12, // llvm.x86.3dnow.pfrsqit1
+    12, // llvm.x86.3dnow.pfrsqrt
+    12, // llvm.x86.3dnow.pfsub
+    12, // llvm.x86.3dnow.pfsubr
+    12, // llvm.x86.3dnow.pi2fd
+    12, // llvm.x86.3dnow.pmulhrw
+    12, // llvm.x86.3dnowa.pf2iw
+    12, // llvm.x86.3dnowa.pfnacc
+    12, // llvm.x86.3dnowa.pfpnacc
+    12, // llvm.x86.3dnowa.pi2fw
+    12, // llvm.x86.3dnowa.pswapd
+    12, // llvm.x86.addcarry.32
+    12, // llvm.x86.addcarry.64
+    7, // llvm.x86.aesdec128kl
+    7, // llvm.x86.aesdec256kl
+    7, // llvm.x86.aesdecwide128kl
+    7, // llvm.x86.aesdecwide256kl
+    7, // llvm.x86.aesenc128kl
+    7, // llvm.x86.aesenc256kl
+    7, // llvm.x86.aesencwide128kl
+    7, // llvm.x86.aesencwide256kl
+    12, // llvm.x86.aesni.aesdec
+    12, // llvm.x86.aesni.aesdec.256
+    12, // llvm.x86.aesni.aesdec.512
+    12, // llvm.x86.aesni.aesdeclast
+    12, // llvm.x86.aesni.aesdeclast.256
+    12, // llvm.x86.aesni.aesdeclast.512
+    12, // llvm.x86.aesni.aesenc
+    12, // llvm.x86.aesni.aesenc.256
+    12, // llvm.x86.aesni.aesenc.512
+    12, // llvm.x86.aesni.aesenclast
+    12, // llvm.x86.aesni.aesenclast.256
+    12, // llvm.x86.aesni.aesenclast.512
+    12, // llvm.x86.aesni.aesimc
+    78, // llvm.x86.aesni.aeskeygenassist
+    12, // llvm.x86.avx.addsub.pd.256
+    12, // llvm.x86.avx.addsub.ps.256
+    12, // llvm.x86.avx.blendv.pd.256
+    12, // llvm.x86.avx.blendv.ps.256
+    70, // llvm.x86.avx.cmp.pd.256
+    70, // llvm.x86.avx.cmp.ps.256
+    12, // llvm.x86.avx.cvt.pd2.ps.256
+    12, // llvm.x86.avx.cvt.pd2dq.256
+    12, // llvm.x86.avx.cvt.ps2dq.256
+    12, // llvm.x86.avx.cvtt.pd2dq.256
+    12, // llvm.x86.avx.cvtt.ps2dq.256
+    70, // llvm.x86.avx.dp.ps.256
+    12, // llvm.x86.avx.hadd.pd.256
+    12, // llvm.x86.avx.hadd.ps.256
+    12, // llvm.x86.avx.hsub.pd.256
+    12, // llvm.x86.avx.hsub.ps.256
+    21, // llvm.x86.avx.ldu.dq.256
+    3, // llvm.x86.avx.maskload.pd
+    3, // llvm.x86.avx.maskload.pd.256
+    3, // llvm.x86.avx.maskload.ps
+    3, // llvm.x86.avx.maskload.ps.256
+    178, // llvm.x86.avx.maskstore.pd
+    178, // llvm.x86.avx.maskstore.pd.256
+    178, // llvm.x86.avx.maskstore.ps
+    178, // llvm.x86.avx.maskstore.ps.256
+    12, // llvm.x86.avx.max.pd.256
+    12, // llvm.x86.avx.max.ps.256
+    12, // llvm.x86.avx.min.pd.256
+    12, // llvm.x86.avx.min.ps.256
+    12, // llvm.x86.avx.movmsk.pd.256
+    12, // llvm.x86.avx.movmsk.ps.256
+    12, // llvm.x86.avx.ptestc.256
+    12, // llvm.x86.avx.ptestnzc.256
+    12, // llvm.x86.avx.ptestz.256
+    12, // llvm.x86.avx.rcp.ps.256
+    78, // llvm.x86.avx.round.pd.256
+    78, // llvm.x86.avx.round.ps.256
+    12, // llvm.x86.avx.rsqrt.ps.256
+    12, // llvm.x86.avx.vpermilvar.pd
+    12, // llvm.x86.avx.vpermilvar.pd.256
+    12, // llvm.x86.avx.vpermilvar.ps
+    12, // llvm.x86.avx.vpermilvar.ps.256
+    12, // llvm.x86.avx.vtestc.pd
+    12, // llvm.x86.avx.vtestc.pd.256
+    12, // llvm.x86.avx.vtestc.ps
+    12, // llvm.x86.avx.vtestc.ps.256
+    12, // llvm.x86.avx.vtestnzc.pd
+    12, // llvm.x86.avx.vtestnzc.pd.256
+    12, // llvm.x86.avx.vtestnzc.ps
+    12, // llvm.x86.avx.vtestnzc.ps.256
+    12, // llvm.x86.avx.vtestz.pd
+    12, // llvm.x86.avx.vtestz.pd.256
+    12, // llvm.x86.avx.vtestz.ps
+    12, // llvm.x86.avx.vtestz.ps.256
+    63, // llvm.x86.avx.vzeroall
+    63, // llvm.x86.avx.vzeroupper
+    210, // llvm.x86.avx2.gather.d.d
+    210, // llvm.x86.avx2.gather.d.d.256
+    210, // llvm.x86.avx2.gather.d.pd
+    210, // llvm.x86.avx2.gather.d.pd.256
+    210, // llvm.x86.avx2.gather.d.ps
+    210, // llvm.x86.avx2.gather.d.ps.256
+    210, // llvm.x86.avx2.gather.d.q
+    210, // llvm.x86.avx2.gather.d.q.256
+    210, // llvm.x86.avx2.gather.q.d
+    210, // llvm.x86.avx2.gather.q.d.256
+    210, // llvm.x86.avx2.gather.q.pd
+    210, // llvm.x86.avx2.gather.q.pd.256
+    210, // llvm.x86.avx2.gather.q.ps
+    210, // llvm.x86.avx2.gather.q.ps.256
+    210, // llvm.x86.avx2.gather.q.q
+    210, // llvm.x86.avx2.gather.q.q.256
+    3, // llvm.x86.avx2.maskload.d
+    3, // llvm.x86.avx2.maskload.d.256
+    3, // llvm.x86.avx2.maskload.q
+    3, // llvm.x86.avx2.maskload.q.256
+    178, // llvm.x86.avx2.maskstore.d
+    178, // llvm.x86.avx2.maskstore.d.256
+    178, // llvm.x86.avx2.maskstore.q
+    178, // llvm.x86.avx2.maskstore.q.256
+    70, // llvm.x86.avx2.mpsadbw
+    12, // llvm.x86.avx2.packssdw
+    12, // llvm.x86.avx2.packsswb
+    12, // llvm.x86.avx2.packusdw
+    12, // llvm.x86.avx2.packuswb
+    12, // llvm.x86.avx2.pavg.b
+    12, // llvm.x86.avx2.pavg.w
+    12, // llvm.x86.avx2.pblendvb
+    12, // llvm.x86.avx2.permd
+    12, // llvm.x86.avx2.permps
+    12, // llvm.x86.avx2.phadd.d
+    12, // llvm.x86.avx2.phadd.sw
+    12, // llvm.x86.avx2.phadd.w
+    12, // llvm.x86.avx2.phsub.d
+    12, // llvm.x86.avx2.phsub.sw
+    12, // llvm.x86.avx2.phsub.w
+    12, // llvm.x86.avx2.pmadd.ub.sw
+    12, // llvm.x86.avx2.pmadd.wd
+    12, // llvm.x86.avx2.pmovmskb
+    12, // llvm.x86.avx2.pmul.hr.sw
+    12, // llvm.x86.avx2.pmulh.w
+    12, // llvm.x86.avx2.pmulhu.w
+    12, // llvm.x86.avx2.psad.bw
+    12, // llvm.x86.avx2.pshuf.b
+    12, // llvm.x86.avx2.psign.b
+    12, // llvm.x86.avx2.psign.d
+    12, // llvm.x86.avx2.psign.w
+    12, // llvm.x86.avx2.psll.d
+    12, // llvm.x86.avx2.psll.q
+    12, // llvm.x86.avx2.psll.w
+    12, // llvm.x86.avx2.pslli.d
+    12, // llvm.x86.avx2.pslli.q
+    12, // llvm.x86.avx2.pslli.w
+    12, // llvm.x86.avx2.psllv.d
+    12, // llvm.x86.avx2.psllv.d.256
+    12, // llvm.x86.avx2.psllv.q
+    12, // llvm.x86.avx2.psllv.q.256
+    12, // llvm.x86.avx2.psra.d
+    12, // llvm.x86.avx2.psra.w
+    12, // llvm.x86.avx2.psrai.d
+    12, // llvm.x86.avx2.psrai.w
+    12, // llvm.x86.avx2.psrav.d
+    12, // llvm.x86.avx2.psrav.d.256
+    12, // llvm.x86.avx2.psrl.d
+    12, // llvm.x86.avx2.psrl.q
+    12, // llvm.x86.avx2.psrl.w
+    12, // llvm.x86.avx2.psrli.d
+    12, // llvm.x86.avx2.psrli.q
+    12, // llvm.x86.avx2.psrli.w
+    12, // llvm.x86.avx2.psrlv.d
+    12, // llvm.x86.avx2.psrlv.d.256
+    12, // llvm.x86.avx2.psrlv.q
+    12, // llvm.x86.avx2.psrlv.q.256
+    70, // llvm.x86.avx512.add.pd.512
+    70, // llvm.x86.avx512.add.ps.512
+    12, // llvm.x86.avx512.broadcastmb.128
+    12, // llvm.x86.avx512.broadcastmb.256
+    12, // llvm.x86.avx512.broadcastmb.512
+    12, // llvm.x86.avx512.broadcastmw.128
+    12, // llvm.x86.avx512.broadcastmw.256
+    12, // llvm.x86.avx512.broadcastmw.512
+    12, // llvm.x86.avx512.conflict.d.128
+    12, // llvm.x86.avx512.conflict.d.256
+    12, // llvm.x86.avx512.conflict.d.512
+    12, // llvm.x86.avx512.conflict.q.128
+    12, // llvm.x86.avx512.conflict.q.256
+    12, // llvm.x86.avx512.conflict.q.512
+    70, // llvm.x86.avx512.cvtsi2sd64
+    70, // llvm.x86.avx512.cvtsi2ss32
+    70, // llvm.x86.avx512.cvtsi2ss64
+    78, // llvm.x86.avx512.cvttsd2si
+    78, // llvm.x86.avx512.cvttsd2si64
+    78, // llvm.x86.avx512.cvttsd2usi
+    78, // llvm.x86.avx512.cvttsd2usi64
+    78, // llvm.x86.avx512.cvttss2si
+    78, // llvm.x86.avx512.cvttss2si64
+    78, // llvm.x86.avx512.cvttss2usi
+    78, // llvm.x86.avx512.cvttss2usi64
+    70, // llvm.x86.avx512.cvtusi2ss
+    70, // llvm.x86.avx512.cvtusi642sd
+    70, // llvm.x86.avx512.cvtusi642ss
+    70, // llvm.x86.avx512.dbpsadbw.128
+    70, // llvm.x86.avx512.dbpsadbw.256
+    70, // llvm.x86.avx512.dbpsadbw.512
+    70, // llvm.x86.avx512.div.pd.512
+    70, // llvm.x86.avx512.div.ps.512
+    71, // llvm.x86.avx512.exp2.pd
+    71, // llvm.x86.avx512.exp2.ps
+    78, // llvm.x86.avx512.fpclass.pd.128
+    78, // llvm.x86.avx512.fpclass.pd.256
+    78, // llvm.x86.avx512.fpclass.pd.512
+    78, // llvm.x86.avx512.fpclass.ps.128
+    78, // llvm.x86.avx512.fpclass.ps.256
+    78, // llvm.x86.avx512.fpclass.ps.512
+    210, // llvm.x86.avx512.gather.dpd.512
+    210, // llvm.x86.avx512.gather.dpi.512
+    210, // llvm.x86.avx512.gather.dpq.512
+    210, // llvm.x86.avx512.gather.dps.512
+    210, // llvm.x86.avx512.gather.qpd.512
+    210, // llvm.x86.avx512.gather.qpi.512
+    210, // llvm.x86.avx512.gather.qpq.512
+    210, // llvm.x86.avx512.gather.qps.512
+    210, // llvm.x86.avx512.gather3div2.df
+    210, // llvm.x86.avx512.gather3div2.di
+    210, // llvm.x86.avx512.gather3div4.df
+    210, // llvm.x86.avx512.gather3div4.di
+    210, // llvm.x86.avx512.gather3div4.sf
+    210, // llvm.x86.avx512.gather3div4.si
+    210, // llvm.x86.avx512.gather3div8.sf
+    210, // llvm.x86.avx512.gather3div8.si
+    210, // llvm.x86.avx512.gather3siv2.df
+    210, // llvm.x86.avx512.gather3siv2.di
+    210, // llvm.x86.avx512.gather3siv4.df
+    210, // llvm.x86.avx512.gather3siv4.di
+    210, // llvm.x86.avx512.gather3siv4.sf
+    210, // llvm.x86.avx512.gather3siv4.si
+    210, // llvm.x86.avx512.gather3siv8.sf
+    210, // llvm.x86.avx512.gather3siv8.si
+    211, // llvm.x86.avx512.gatherpf.dpd.512
+    211, // llvm.x86.avx512.gatherpf.dps.512
+    211, // llvm.x86.avx512.gatherpf.qpd.512
+    211, // llvm.x86.avx512.gatherpf.qps.512
+    12, // llvm.x86.avx512.kadd.b
+    12, // llvm.x86.avx512.kadd.d
+    12, // llvm.x86.avx512.kadd.q
+    12, // llvm.x86.avx512.kadd.w
+    12, // llvm.x86.avx512.ktestc.b
+    12, // llvm.x86.avx512.ktestc.d
+    12, // llvm.x86.avx512.ktestc.q
+    12, // llvm.x86.avx512.ktestc.w
+    12, // llvm.x86.avx512.ktestz.b
+    12, // llvm.x86.avx512.ktestz.d
+    12, // llvm.x86.avx512.ktestz.q
+    12, // llvm.x86.avx512.ktestz.w
+    74, // llvm.x86.avx512.mask.add.sd.round
+    74, // llvm.x86.avx512.mask.add.ss.round
+    70, // llvm.x86.avx512.mask.cmp.pd.128
+    70, // llvm.x86.avx512.mask.cmp.pd.256
+    212, // llvm.x86.avx512.mask.cmp.pd.512
+    70, // llvm.x86.avx512.mask.cmp.ps.128
+    70, // llvm.x86.avx512.mask.cmp.ps.256
+    212, // llvm.x86.avx512.mask.cmp.ps.512
+    212, // llvm.x86.avx512.mask.cmp.sd
+    212, // llvm.x86.avx512.mask.cmp.ss
+    12, // llvm.x86.avx512.mask.compress
+    12, // llvm.x86.avx512.mask.cvtpd2dq.128
+    71, // llvm.x86.avx512.mask.cvtpd2dq.512
+    12, // llvm.x86.avx512.mask.cvtpd2ps
+    71, // llvm.x86.avx512.mask.cvtpd2ps.512
+    12, // llvm.x86.avx512.mask.cvtpd2qq.128
+    12, // llvm.x86.avx512.mask.cvtpd2qq.256
+    71, // llvm.x86.avx512.mask.cvtpd2qq.512
+    12, // llvm.x86.avx512.mask.cvtpd2udq.128
+    12, // llvm.x86.avx512.mask.cvtpd2udq.256
+    71, // llvm.x86.avx512.mask.cvtpd2udq.512
+    12, // llvm.x86.avx512.mask.cvtpd2uqq.128
+    12, // llvm.x86.avx512.mask.cvtpd2uqq.256
+    71, // llvm.x86.avx512.mask.cvtpd2uqq.512
+    12, // llvm.x86.avx512.mask.cvtps2dq.128
+    12, // llvm.x86.avx512.mask.cvtps2dq.256
+    71, // llvm.x86.avx512.mask.cvtps2dq.512
+    71, // llvm.x86.avx512.mask.cvtps2pd.512
+    12, // llvm.x86.avx512.mask.cvtps2qq.128
+    12, // llvm.x86.avx512.mask.cvtps2qq.256
+    71, // llvm.x86.avx512.mask.cvtps2qq.512
+    12, // llvm.x86.avx512.mask.cvtps2udq.128
+    12, // llvm.x86.avx512.mask.cvtps2udq.256
+    71, // llvm.x86.avx512.mask.cvtps2udq.512
+    12, // llvm.x86.avx512.mask.cvtps2uqq.128
+    12, // llvm.x86.avx512.mask.cvtps2uqq.256
+    71, // llvm.x86.avx512.mask.cvtps2uqq.512
+    12, // llvm.x86.avx512.mask.cvtqq2ps.128
+    74, // llvm.x86.avx512.mask.cvtsd2ss.round
+    74, // llvm.x86.avx512.mask.cvtss2sd.round
+    12, // llvm.x86.avx512.mask.cvttpd2dq.128
+    71, // llvm.x86.avx512.mask.cvttpd2dq.512
+    12, // llvm.x86.avx512.mask.cvttpd2qq.128
+    12, // llvm.x86.avx512.mask.cvttpd2qq.256
+    71, // llvm.x86.avx512.mask.cvttpd2qq.512
+    12, // llvm.x86.avx512.mask.cvttpd2udq.128
+    12, // llvm.x86.avx512.mask.cvttpd2udq.256
+    71, // llvm.x86.avx512.mask.cvttpd2udq.512
+    12, // llvm.x86.avx512.mask.cvttpd2uqq.128
+    12, // llvm.x86.avx512.mask.cvttpd2uqq.256
+    71, // llvm.x86.avx512.mask.cvttpd2uqq.512
+    71, // llvm.x86.avx512.mask.cvttps2dq.512
+    12, // llvm.x86.avx512.mask.cvttps2qq.128
+    12, // llvm.x86.avx512.mask.cvttps2qq.256
+    71, // llvm.x86.avx512.mask.cvttps2qq.512
+    12, // llvm.x86.avx512.mask.cvttps2udq.128
+    12, // llvm.x86.avx512.mask.cvttps2udq.256
+    71, // llvm.x86.avx512.mask.cvttps2udq.512
+    12, // llvm.x86.avx512.mask.cvttps2uqq.128
+    12, // llvm.x86.avx512.mask.cvttps2uqq.256
+    71, // llvm.x86.avx512.mask.cvttps2uqq.512
+    12, // llvm.x86.avx512.mask.cvtuqq2ps.128
+    74, // llvm.x86.avx512.mask.div.sd.round
+    74, // llvm.x86.avx512.mask.div.ss.round
+    12, // llvm.x86.avx512.mask.expand
+    71, // llvm.x86.avx512.mask.fixupimm.pd.128
+    71, // llvm.x86.avx512.mask.fixupimm.pd.256
+    213, // llvm.x86.avx512.mask.fixupimm.pd.512
+    71, // llvm.x86.avx512.mask.fixupimm.ps.128
+    71, // llvm.x86.avx512.mask.fixupimm.ps.256
+    213, // llvm.x86.avx512.mask.fixupimm.ps.512
+    213, // llvm.x86.avx512.mask.fixupimm.sd
+    213, // llvm.x86.avx512.mask.fixupimm.ss
+    78, // llvm.x86.avx512.mask.fpclass.sd
+    78, // llvm.x86.avx512.mask.fpclass.ss
+    210, // llvm.x86.avx512.mask.gather.dpd.512
+    210, // llvm.x86.avx512.mask.gather.dpi.512
+    210, // llvm.x86.avx512.mask.gather.dpq.512
+    210, // llvm.x86.avx512.mask.gather.dps.512
+    210, // llvm.x86.avx512.mask.gather.qpd.512
+    210, // llvm.x86.avx512.mask.gather.qpi.512
+    210, // llvm.x86.avx512.mask.gather.qpq.512
+    210, // llvm.x86.avx512.mask.gather.qps.512
+    210, // llvm.x86.avx512.mask.gather3div2.df
+    210, // llvm.x86.avx512.mask.gather3div2.di
+    210, // llvm.x86.avx512.mask.gather3div4.df
+    210, // llvm.x86.avx512.mask.gather3div4.di
+    210, // llvm.x86.avx512.mask.gather3div4.sf
+    210, // llvm.x86.avx512.mask.gather3div4.si
+    210, // llvm.x86.avx512.mask.gather3div8.sf
+    210, // llvm.x86.avx512.mask.gather3div8.si
+    210, // llvm.x86.avx512.mask.gather3siv2.df
+    210, // llvm.x86.avx512.mask.gather3siv2.di
+    210, // llvm.x86.avx512.mask.gather3siv4.df
+    210, // llvm.x86.avx512.mask.gather3siv4.di
+    210, // llvm.x86.avx512.mask.gather3siv4.sf
+    210, // llvm.x86.avx512.mask.gather3siv4.si
+    210, // llvm.x86.avx512.mask.gather3siv8.sf
+    210, // llvm.x86.avx512.mask.gather3siv8.si
+    12, // llvm.x86.avx512.mask.getexp.pd.128
+    12, // llvm.x86.avx512.mask.getexp.pd.256
+    71, // llvm.x86.avx512.mask.getexp.pd.512
+    12, // llvm.x86.avx512.mask.getexp.ps.128
+    12, // llvm.x86.avx512.mask.getexp.ps.256
+    71, // llvm.x86.avx512.mask.getexp.ps.512
+    74, // llvm.x86.avx512.mask.getexp.sd
+    74, // llvm.x86.avx512.mask.getexp.ss
+    78, // llvm.x86.avx512.mask.getmant.pd.128
+    78, // llvm.x86.avx512.mask.getmant.pd.256
+    214, // llvm.x86.avx512.mask.getmant.pd.512
+    78, // llvm.x86.avx512.mask.getmant.ps.128
+    78, // llvm.x86.avx512.mask.getmant.ps.256
+    214, // llvm.x86.avx512.mask.getmant.ps.512
+    215, // llvm.x86.avx512.mask.getmant.sd
+    215, // llvm.x86.avx512.mask.getmant.ss
+    74, // llvm.x86.avx512.mask.max.sd.round
+    74, // llvm.x86.avx512.mask.max.ss.round
+    74, // llvm.x86.avx512.mask.min.sd.round
+    74, // llvm.x86.avx512.mask.min.ss.round
+    74, // llvm.x86.avx512.mask.mul.sd.round
+    74, // llvm.x86.avx512.mask.mul.ss.round
+    12, // llvm.x86.avx512.mask.pmov.db.128
+    12, // llvm.x86.avx512.mask.pmov.db.256
+    12, // llvm.x86.avx512.mask.pmov.db.512
+    178, // llvm.x86.avx512.mask.pmov.db.mem.128
+    178, // llvm.x86.avx512.mask.pmov.db.mem.256
+    178, // llvm.x86.avx512.mask.pmov.db.mem.512
+    12, // llvm.x86.avx512.mask.pmov.dw.128
+    12, // llvm.x86.avx512.mask.pmov.dw.256
+    12, // llvm.x86.avx512.mask.pmov.dw.512
+    178, // llvm.x86.avx512.mask.pmov.dw.mem.128
+    178, // llvm.x86.avx512.mask.pmov.dw.mem.256
+    178, // llvm.x86.avx512.mask.pmov.dw.mem.512
+    12, // llvm.x86.avx512.mask.pmov.qb.128
+    12, // llvm.x86.avx512.mask.pmov.qb.256
+    12, // llvm.x86.avx512.mask.pmov.qb.512
+    178, // llvm.x86.avx512.mask.pmov.qb.mem.128
+    178, // llvm.x86.avx512.mask.pmov.qb.mem.256
+    178, // llvm.x86.avx512.mask.pmov.qb.mem.512
+    12, // llvm.x86.avx512.mask.pmov.qd.128
+    178, // llvm.x86.avx512.mask.pmov.qd.mem.128
+    178, // llvm.x86.avx512.mask.pmov.qd.mem.256
+    178, // llvm.x86.avx512.mask.pmov.qd.mem.512
+    12, // llvm.x86.avx512.mask.pmov.qw.128
+    12, // llvm.x86.avx512.mask.pmov.qw.256
+    12, // llvm.x86.avx512.mask.pmov.qw.512
+    178, // llvm.x86.avx512.mask.pmov.qw.mem.128
+    178, // llvm.x86.avx512.mask.pmov.qw.mem.256
+    178, // llvm.x86.avx512.mask.pmov.qw.mem.512
+    12, // llvm.x86.avx512.mask.pmov.wb.128
+    178, // llvm.x86.avx512.mask.pmov.wb.mem.128
+    178, // llvm.x86.avx512.mask.pmov.wb.mem.256
+    178, // llvm.x86.avx512.mask.pmov.wb.mem.512
+    12, // llvm.x86.avx512.mask.pmovs.db.128
+    12, // llvm.x86.avx512.mask.pmovs.db.256
+    12, // llvm.x86.avx512.mask.pmovs.db.512
+    178, // llvm.x86.avx512.mask.pmovs.db.mem.128
+    178, // llvm.x86.avx512.mask.pmovs.db.mem.256
+    178, // llvm.x86.avx512.mask.pmovs.db.mem.512
+    12, // llvm.x86.avx512.mask.pmovs.dw.128
+    12, // llvm.x86.avx512.mask.pmovs.dw.256
+    12, // llvm.x86.avx512.mask.pmovs.dw.512
+    178, // llvm.x86.avx512.mask.pmovs.dw.mem.128
+    178, // llvm.x86.avx512.mask.pmovs.dw.mem.256
+    178, // llvm.x86.avx512.mask.pmovs.dw.mem.512
+    12, // llvm.x86.avx512.mask.pmovs.qb.128
+    12, // llvm.x86.avx512.mask.pmovs.qb.256
+    12, // llvm.x86.avx512.mask.pmovs.qb.512
+    178, // llvm.x86.avx512.mask.pmovs.qb.mem.128
+    178, // llvm.x86.avx512.mask.pmovs.qb.mem.256
+    178, // llvm.x86.avx512.mask.pmovs.qb.mem.512
+    12, // llvm.x86.avx512.mask.pmovs.qd.128
+    12, // llvm.x86.avx512.mask.pmovs.qd.256
+    12, // llvm.x86.avx512.mask.pmovs.qd.512
+    178, // llvm.x86.avx512.mask.pmovs.qd.mem.128
+    178, // llvm.x86.avx512.mask.pmovs.qd.mem.256
+    178, // llvm.x86.avx512.mask.pmovs.qd.mem.512
+    12, // llvm.x86.avx512.mask.pmovs.qw.128
+    12, // llvm.x86.avx512.mask.pmovs.qw.256
+    12, // llvm.x86.avx512.mask.pmovs.qw.512
+    178, // llvm.x86.avx512.mask.pmovs.qw.mem.128
+    178, // llvm.x86.avx512.mask.pmovs.qw.mem.256
+    178, // llvm.x86.avx512.mask.pmovs.qw.mem.512
+    12, // llvm.x86.avx512.mask.pmovs.wb.128
+    12, // llvm.x86.avx512.mask.pmovs.wb.256
+    12, // llvm.x86.avx512.mask.pmovs.wb.512
+    178, // llvm.x86.avx512.mask.pmovs.wb.mem.128
+    178, // llvm.x86.avx512.mask.pmovs.wb.mem.256
+    178, // llvm.x86.avx512.mask.pmovs.wb.mem.512
+    12, // llvm.x86.avx512.mask.pmovus.db.128
+    12, // llvm.x86.avx512.mask.pmovus.db.256
+    12, // llvm.x86.avx512.mask.pmovus.db.512
+    178, // llvm.x86.avx512.mask.pmovus.db.mem.128
+    178, // llvm.x86.avx512.mask.pmovus.db.mem.256
+    178, // llvm.x86.avx512.mask.pmovus.db.mem.512
+    12, // llvm.x86.avx512.mask.pmovus.dw.128
+    12, // llvm.x86.avx512.mask.pmovus.dw.256
+    12, // llvm.x86.avx512.mask.pmovus.dw.512
+    178, // llvm.x86.avx512.mask.pmovus.dw.mem.128
+    178, // llvm.x86.avx512.mask.pmovus.dw.mem.256
+    178, // llvm.x86.avx512.mask.pmovus.dw.mem.512
+    12, // llvm.x86.avx512.mask.pmovus.qb.128
+    12, // llvm.x86.avx512.mask.pmovus.qb.256
+    12, // llvm.x86.avx512.mask.pmovus.qb.512
+    178, // llvm.x86.avx512.mask.pmovus.qb.mem.128
+    178, // llvm.x86.avx512.mask.pmovus.qb.mem.256
+    178, // llvm.x86.avx512.mask.pmovus.qb.mem.512
+    12, // llvm.x86.avx512.mask.pmovus.qd.128
+    12, // llvm.x86.avx512.mask.pmovus.qd.256
+    12, // llvm.x86.avx512.mask.pmovus.qd.512
+    178, // llvm.x86.avx512.mask.pmovus.qd.mem.128
+    178, // llvm.x86.avx512.mask.pmovus.qd.mem.256
+    178, // llvm.x86.avx512.mask.pmovus.qd.mem.512
+    12, // llvm.x86.avx512.mask.pmovus.qw.128
+    12, // llvm.x86.avx512.mask.pmovus.qw.256
+    12, // llvm.x86.avx512.mask.pmovus.qw.512
+    178, // llvm.x86.avx512.mask.pmovus.qw.mem.128
+    178, // llvm.x86.avx512.mask.pmovus.qw.mem.256
+    178, // llvm.x86.avx512.mask.pmovus.qw.mem.512
+    12, // llvm.x86.avx512.mask.pmovus.wb.128
+    12, // llvm.x86.avx512.mask.pmovus.wb.256
+    12, // llvm.x86.avx512.mask.pmovus.wb.512
+    178, // llvm.x86.avx512.mask.pmovus.wb.mem.128
+    178, // llvm.x86.avx512.mask.pmovus.wb.mem.256
+    178, // llvm.x86.avx512.mask.pmovus.wb.mem.512
+    70, // llvm.x86.avx512.mask.range.pd.128
+    70, // llvm.x86.avx512.mask.range.pd.256
+    215, // llvm.x86.avx512.mask.range.pd.512
+    70, // llvm.x86.avx512.mask.range.ps.128
+    70, // llvm.x86.avx512.mask.range.ps.256
+    215, // llvm.x86.avx512.mask.range.ps.512
+    216, // llvm.x86.avx512.mask.range.sd
+    216, // llvm.x86.avx512.mask.range.ss
+    78, // llvm.x86.avx512.mask.reduce.pd.128
+    78, // llvm.x86.avx512.mask.reduce.pd.256
+    214, // llvm.x86.avx512.mask.reduce.pd.512
+    78, // llvm.x86.avx512.mask.reduce.ps.128
+    78, // llvm.x86.avx512.mask.reduce.ps.256
+    214, // llvm.x86.avx512.mask.reduce.ps.512
+    216, // llvm.x86.avx512.mask.reduce.sd
+    216, // llvm.x86.avx512.mask.reduce.ss
+    78, // llvm.x86.avx512.mask.rndscale.pd.128
+    78, // llvm.x86.avx512.mask.rndscale.pd.256
+    214, // llvm.x86.avx512.mask.rndscale.pd.512
+    78, // llvm.x86.avx512.mask.rndscale.ps.128
+    78, // llvm.x86.avx512.mask.rndscale.ps.256
+    214, // llvm.x86.avx512.mask.rndscale.ps.512
+    216, // llvm.x86.avx512.mask.rndscale.sd
+    216, // llvm.x86.avx512.mask.rndscale.ss
+    12, // llvm.x86.avx512.mask.scalef.pd.128
+    12, // llvm.x86.avx512.mask.scalef.pd.256
+    74, // llvm.x86.avx512.mask.scalef.pd.512
+    12, // llvm.x86.avx512.mask.scalef.ps.128
+    12, // llvm.x86.avx512.mask.scalef.ps.256
+    74, // llvm.x86.avx512.mask.scalef.ps.512
+    74, // llvm.x86.avx512.mask.scalef.sd
+    74, // llvm.x86.avx512.mask.scalef.ss
+    89, // llvm.x86.avx512.mask.scatter.dpd.512
+    89, // llvm.x86.avx512.mask.scatter.dpi.512
+    89, // llvm.x86.avx512.mask.scatter.dpq.512
+    89, // llvm.x86.avx512.mask.scatter.dps.512
+    89, // llvm.x86.avx512.mask.scatter.qpd.512
+    89, // llvm.x86.avx512.mask.scatter.qpi.512
+    89, // llvm.x86.avx512.mask.scatter.qpq.512
+    89, // llvm.x86.avx512.mask.scatter.qps.512
+    89, // llvm.x86.avx512.mask.scatterdiv2.df
+    89, // llvm.x86.avx512.mask.scatterdiv2.di
+    89, // llvm.x86.avx512.mask.scatterdiv4.df
+    89, // llvm.x86.avx512.mask.scatterdiv4.di
+    89, // llvm.x86.avx512.mask.scatterdiv4.sf
+    89, // llvm.x86.avx512.mask.scatterdiv4.si
+    89, // llvm.x86.avx512.mask.scatterdiv8.sf
+    89, // llvm.x86.avx512.mask.scatterdiv8.si
+    89, // llvm.x86.avx512.mask.scattersiv2.df
+    89, // llvm.x86.avx512.mask.scattersiv2.di
+    89, // llvm.x86.avx512.mask.scattersiv4.df
+    89, // llvm.x86.avx512.mask.scattersiv4.di
+    89, // llvm.x86.avx512.mask.scattersiv4.sf
+    89, // llvm.x86.avx512.mask.scattersiv4.si
+    89, // llvm.x86.avx512.mask.scattersiv8.sf
+    89, // llvm.x86.avx512.mask.scattersiv8.si
+    74, // llvm.x86.avx512.mask.sqrt.sd
+    74, // llvm.x86.avx512.mask.sqrt.ss
+    74, // llvm.x86.avx512.mask.sub.sd.round
+    74, // llvm.x86.avx512.mask.sub.ss.round
+    71, // llvm.x86.avx512.mask.vcvtph2ps.512
+    78, // llvm.x86.avx512.mask.vcvtps2ph.128
+    78, // llvm.x86.avx512.mask.vcvtps2ph.256
+    78, // llvm.x86.avx512.mask.vcvtps2ph.512
+    71, // llvm.x86.avx512.maskz.fixupimm.pd.128
+    71, // llvm.x86.avx512.maskz.fixupimm.pd.256
+    213, // llvm.x86.avx512.maskz.fixupimm.pd.512
+    71, // llvm.x86.avx512.maskz.fixupimm.ps.128
+    71, // llvm.x86.avx512.maskz.fixupimm.ps.256
+    213, // llvm.x86.avx512.maskz.fixupimm.ps.512
+    213, // llvm.x86.avx512.maskz.fixupimm.sd
+    213, // llvm.x86.avx512.maskz.fixupimm.ss
+    70, // llvm.x86.avx512.max.pd.512
+    70, // llvm.x86.avx512.max.ps.512
+    70, // llvm.x86.avx512.min.pd.512
+    70, // llvm.x86.avx512.min.ps.512
+    70, // llvm.x86.avx512.mul.pd.512
+    70, // llvm.x86.avx512.mul.ps.512
+    12, // llvm.x86.avx512.packssdw.512
+    12, // llvm.x86.avx512.packsswb.512
+    12, // llvm.x86.avx512.packusdw.512
+    12, // llvm.x86.avx512.packuswb.512
+    12, // llvm.x86.avx512.pavg.b.512
+    12, // llvm.x86.avx512.pavg.w.512
+    12, // llvm.x86.avx512.permvar.df.256
+    12, // llvm.x86.avx512.permvar.df.512
+    12, // llvm.x86.avx512.permvar.di.256
+    12, // llvm.x86.avx512.permvar.di.512
+    12, // llvm.x86.avx512.permvar.hi.128
+    12, // llvm.x86.avx512.permvar.hi.256
+    12, // llvm.x86.avx512.permvar.hi.512
+    12, // llvm.x86.avx512.permvar.qi.128
+    12, // llvm.x86.avx512.permvar.qi.256
+    12, // llvm.x86.avx512.permvar.qi.512
+    12, // llvm.x86.avx512.permvar.sf.512
+    12, // llvm.x86.avx512.permvar.si.512
+    12, // llvm.x86.avx512.pmaddubs.w.512
+    12, // llvm.x86.avx512.pmaddw.d.512
+    12, // llvm.x86.avx512.pmul.hr.sw.512
+    12, // llvm.x86.avx512.pmulh.w.512
+    12, // llvm.x86.avx512.pmulhu.w.512
+    12, // llvm.x86.avx512.pmultishift.qb.128
+    12, // llvm.x86.avx512.pmultishift.qb.256
+    12, // llvm.x86.avx512.pmultishift.qb.512
+    12, // llvm.x86.avx512.psad.bw.512
+    12, // llvm.x86.avx512.pshuf.b.512
+    12, // llvm.x86.avx512.psll.d.512
+    12, // llvm.x86.avx512.psll.q.512
+    12, // llvm.x86.avx512.psll.w.512
+    12, // llvm.x86.avx512.pslli.d.512
+    12, // llvm.x86.avx512.pslli.q.512
+    12, // llvm.x86.avx512.pslli.w.512
+    12, // llvm.x86.avx512.psllv.d.512
+    12, // llvm.x86.avx512.psllv.q.512
+    12, // llvm.x86.avx512.psllv.w.128
+    12, // llvm.x86.avx512.psllv.w.256
+    12, // llvm.x86.avx512.psllv.w.512
+    12, // llvm.x86.avx512.psra.d.512
+    12, // llvm.x86.avx512.psra.q.128
+    12, // llvm.x86.avx512.psra.q.256
+    12, // llvm.x86.avx512.psra.q.512
+    12, // llvm.x86.avx512.psra.w.512
+    12, // llvm.x86.avx512.psrai.d.512
+    12, // llvm.x86.avx512.psrai.q.128
+    12, // llvm.x86.avx512.psrai.q.256
+    12, // llvm.x86.avx512.psrai.q.512
+    12, // llvm.x86.avx512.psrai.w.512
+    12, // llvm.x86.avx512.psrav.d.512
+    12, // llvm.x86.avx512.psrav.q.128
+    12, // llvm.x86.avx512.psrav.q.256
+    12, // llvm.x86.avx512.psrav.q.512
+    12, // llvm.x86.avx512.psrav.w.128
+    12, // llvm.x86.avx512.psrav.w.256
+    12, // llvm.x86.avx512.psrav.w.512
+    12, // llvm.x86.avx512.psrl.d.512
+    12, // llvm.x86.avx512.psrl.q.512
+    12, // llvm.x86.avx512.psrl.w.512
+    12, // llvm.x86.avx512.psrli.d.512
+    12, // llvm.x86.avx512.psrli.q.512
+    12, // llvm.x86.avx512.psrli.w.512
+    12, // llvm.x86.avx512.psrlv.d.512
+    12, // llvm.x86.avx512.psrlv.q.512
+    12, // llvm.x86.avx512.psrlv.w.128
+    12, // llvm.x86.avx512.psrlv.w.256
+    12, // llvm.x86.avx512.psrlv.w.512
+    71, // llvm.x86.avx512.pternlog.d.128
+    71, // llvm.x86.avx512.pternlog.d.256
+    71, // llvm.x86.avx512.pternlog.d.512
+    71, // llvm.x86.avx512.pternlog.q.128
+    71, // llvm.x86.avx512.pternlog.q.256
+    71, // llvm.x86.avx512.pternlog.q.512
+    12, // llvm.x86.avx512.rcp14.pd.128
+    12, // llvm.x86.avx512.rcp14.pd.256
+    12, // llvm.x86.avx512.rcp14.pd.512
+    12, // llvm.x86.avx512.rcp14.ps.128
+    12, // llvm.x86.avx512.rcp14.ps.256
+    12, // llvm.x86.avx512.rcp14.ps.512
+    12, // llvm.x86.avx512.rcp14.sd
+    12, // llvm.x86.avx512.rcp14.ss
+    71, // llvm.x86.avx512.rcp28.pd
+    71, // llvm.x86.avx512.rcp28.ps
+    74, // llvm.x86.avx512.rcp28.sd
+    74, // llvm.x86.avx512.rcp28.ss
+    12, // llvm.x86.avx512.rsqrt14.pd.128
+    12, // llvm.x86.avx512.rsqrt14.pd.256
+    12, // llvm.x86.avx512.rsqrt14.pd.512
+    12, // llvm.x86.avx512.rsqrt14.ps.128
+    12, // llvm.x86.avx512.rsqrt14.ps.256
+    12, // llvm.x86.avx512.rsqrt14.ps.512
+    12, // llvm.x86.avx512.rsqrt14.sd
+    12, // llvm.x86.avx512.rsqrt14.ss
+    71, // llvm.x86.avx512.rsqrt28.pd
+    71, // llvm.x86.avx512.rsqrt28.ps
+    74, // llvm.x86.avx512.rsqrt28.sd
+    74, // llvm.x86.avx512.rsqrt28.ss
+    89, // llvm.x86.avx512.scatter.dpd.512
+    89, // llvm.x86.avx512.scatter.dpi.512
+    89, // llvm.x86.avx512.scatter.dpq.512
+    89, // llvm.x86.avx512.scatter.dps.512
+    89, // llvm.x86.avx512.scatter.qpd.512
+    89, // llvm.x86.avx512.scatter.qpi.512
+    89, // llvm.x86.avx512.scatter.qpq.512
+    89, // llvm.x86.avx512.scatter.qps.512
+    89, // llvm.x86.avx512.scatterdiv2.df
+    89, // llvm.x86.avx512.scatterdiv2.di
+    89, // llvm.x86.avx512.scatterdiv4.df
+    89, // llvm.x86.avx512.scatterdiv4.di
+    89, // llvm.x86.avx512.scatterdiv4.sf
+    89, // llvm.x86.avx512.scatterdiv4.si
+    89, // llvm.x86.avx512.scatterdiv8.sf
+    89, // llvm.x86.avx512.scatterdiv8.si
+    211, // llvm.x86.avx512.scatterpf.dpd.512
+    211, // llvm.x86.avx512.scatterpf.dps.512
+    211, // llvm.x86.avx512.scatterpf.qpd.512
+    211, // llvm.x86.avx512.scatterpf.qps.512
+    89, // llvm.x86.avx512.scattersiv2.df
+    89, // llvm.x86.avx512.scattersiv2.di
+    89, // llvm.x86.avx512.scattersiv4.df
+    89, // llvm.x86.avx512.scattersiv4.di
+    89, // llvm.x86.avx512.scattersiv4.sf
+    89, // llvm.x86.avx512.scattersiv4.si
+    89, // llvm.x86.avx512.scattersiv8.sf
+    89, // llvm.x86.avx512.scattersiv8.si
+    78, // llvm.x86.avx512.sitofp.round
+    78, // llvm.x86.avx512.sqrt.pd.512
+    78, // llvm.x86.avx512.sqrt.ps.512
+    70, // llvm.x86.avx512.sub.pd.512
+    70, // llvm.x86.avx512.sub.ps.512
+    78, // llvm.x86.avx512.uitofp.round
+    182, // llvm.x86.avx512.vcomi.sd
+    182, // llvm.x86.avx512.vcomi.ss
+    78, // llvm.x86.avx512.vcvtsd2si32
+    78, // llvm.x86.avx512.vcvtsd2si64
+    78, // llvm.x86.avx512.vcvtsd2usi32
+    78, // llvm.x86.avx512.vcvtsd2usi64
+    78, // llvm.x86.avx512.vcvtss2si32
+    78, // llvm.x86.avx512.vcvtss2si64
+    78, // llvm.x86.avx512.vcvtss2usi32
+    78, // llvm.x86.avx512.vcvtss2usi64
+    71, // llvm.x86.avx512.vfmadd.f32
+    71, // llvm.x86.avx512.vfmadd.f64
+    71, // llvm.x86.avx512.vfmadd.pd.512
+    71, // llvm.x86.avx512.vfmadd.ps.512
+    71, // llvm.x86.avx512.vfmaddsub.pd.512
+    71, // llvm.x86.avx512.vfmaddsub.ps.512
+    12, // llvm.x86.avx512.vp2intersect.d.128
+    12, // llvm.x86.avx512.vp2intersect.d.256
+    12, // llvm.x86.avx512.vp2intersect.d.512
+    12, // llvm.x86.avx512.vp2intersect.q.128
+    12, // llvm.x86.avx512.vp2intersect.q.256
+    12, // llvm.x86.avx512.vp2intersect.q.512
+    12, // llvm.x86.avx512.vpdpbusd.128
+    12, // llvm.x86.avx512.vpdpbusd.256
+    12, // llvm.x86.avx512.vpdpbusd.512
+    12, // llvm.x86.avx512.vpdpbusds.128
+    12, // llvm.x86.avx512.vpdpbusds.256
+    12, // llvm.x86.avx512.vpdpbusds.512
+    12, // llvm.x86.avx512.vpdpwssd.128
+    12, // llvm.x86.avx512.vpdpwssd.256
+    12, // llvm.x86.avx512.vpdpwssd.512
+    12, // llvm.x86.avx512.vpdpwssds.128
+    12, // llvm.x86.avx512.vpdpwssds.256
+    12, // llvm.x86.avx512.vpdpwssds.512
+    12, // llvm.x86.avx512.vpermi2var.d.128
+    12, // llvm.x86.avx512.vpermi2var.d.256
+    12, // llvm.x86.avx512.vpermi2var.d.512
+    12, // llvm.x86.avx512.vpermi2var.hi.128
+    12, // llvm.x86.avx512.vpermi2var.hi.256
+    12, // llvm.x86.avx512.vpermi2var.hi.512
+    12, // llvm.x86.avx512.vpermi2var.pd.128
+    12, // llvm.x86.avx512.vpermi2var.pd.256
+    12, // llvm.x86.avx512.vpermi2var.pd.512
+    12, // llvm.x86.avx512.vpermi2var.ps.128
+    12, // llvm.x86.avx512.vpermi2var.ps.256
+    12, // llvm.x86.avx512.vpermi2var.ps.512
+    12, // llvm.x86.avx512.vpermi2var.q.128
+    12, // llvm.x86.avx512.vpermi2var.q.256
+    12, // llvm.x86.avx512.vpermi2var.q.512
+    12, // llvm.x86.avx512.vpermi2var.qi.128
+    12, // llvm.x86.avx512.vpermi2var.qi.256
+    12, // llvm.x86.avx512.vpermi2var.qi.512
+    12, // llvm.x86.avx512.vpermilvar.pd.512
+    12, // llvm.x86.avx512.vpermilvar.ps.512
+    12, // llvm.x86.avx512.vpmadd52h.uq.128
+    12, // llvm.x86.avx512.vpmadd52h.uq.256
+    12, // llvm.x86.avx512.vpmadd52h.uq.512
+    12, // llvm.x86.avx512.vpmadd52l.uq.128
+    12, // llvm.x86.avx512.vpmadd52l.uq.256
+    12, // llvm.x86.avx512.vpmadd52l.uq.512
+    12, // llvm.x86.avx512.vpshufbitqmb.128
+    12, // llvm.x86.avx512.vpshufbitqmb.256
+    12, // llvm.x86.avx512.vpshufbitqmb.512
+    12, // llvm.x86.avx512bf16.cvtne2ps2bf16.128
+    12, // llvm.x86.avx512bf16.cvtne2ps2bf16.256
+    12, // llvm.x86.avx512bf16.cvtne2ps2bf16.512
+    12, // llvm.x86.avx512bf16.cvtneps2bf16.256
+    12, // llvm.x86.avx512bf16.cvtneps2bf16.512
+    12, // llvm.x86.avx512bf16.dpbf16ps.128
+    12, // llvm.x86.avx512bf16.dpbf16ps.256
+    12, // llvm.x86.avx512bf16.dpbf16ps.512
+    12, // llvm.x86.avx512bf16.mask.cvtneps2bf16.128
+    12, // llvm.x86.bmi.bextr.32
+    12, // llvm.x86.bmi.bextr.64
+    12, // llvm.x86.bmi.bzhi.32
+    12, // llvm.x86.bmi.bzhi.64
+    12, // llvm.x86.bmi.pdep.32
+    12, // llvm.x86.bmi.pdep.64
+    12, // llvm.x86.bmi.pext.32
+    12, // llvm.x86.bmi.pext.64
+    7, // llvm.x86.cldemote
+    7, // llvm.x86.clflushopt
+    7, // llvm.x86.clrssbsy
+    7, // llvm.x86.clui
+    7, // llvm.x86.clwb
+    7, // llvm.x86.clzero
+    7, // llvm.x86.directstore32
+    7, // llvm.x86.directstore64
+    7, // llvm.x86.encodekey128
+    7, // llvm.x86.encodekey256
+    7, // llvm.x86.enqcmd
+    7, // llvm.x86.enqcmds
+    7, // llvm.x86.flags.read.u32
+    7, // llvm.x86.flags.read.u64
+    7, // llvm.x86.flags.write.u32
+    7, // llvm.x86.flags.write.u64
+    12, // llvm.x86.fma.vfmaddsub.pd
+    12, // llvm.x86.fma.vfmaddsub.pd.256
+    12, // llvm.x86.fma.vfmaddsub.ps
+    12, // llvm.x86.fma.vfmaddsub.ps.256
+    7, // llvm.x86.fxrstor
+    7, // llvm.x86.fxrstor64
+    7, // llvm.x86.fxsave
+    7, // llvm.x86.fxsave64
+    7, // llvm.x86.incsspd
+    7, // llvm.x86.incsspq
+    83, // llvm.x86.int
+    7, // llvm.x86.invpcid
+    7, // llvm.x86.ldtilecfg
+    7, // llvm.x86.llwpcb
+    7, // llvm.x86.loadiwkey
+    217, // llvm.x86.lwpins32
+    217, // llvm.x86.lwpins64
+    217, // llvm.x86.lwpval32
+    217, // llvm.x86.lwpval64
+    7, // llvm.x86.mmx.emms
+    7, // llvm.x86.mmx.femms
+    7, // llvm.x86.mmx.maskmovq
+    7, // llvm.x86.mmx.movnt.dq
+    12, // llvm.x86.mmx.packssdw
+    12, // llvm.x86.mmx.packsswb
+    12, // llvm.x86.mmx.packuswb
+    12, // llvm.x86.mmx.padd.b
+    12, // llvm.x86.mmx.padd.d
+    12, // llvm.x86.mmx.padd.q
+    12, // llvm.x86.mmx.padd.w
+    12, // llvm.x86.mmx.padds.b
+    12, // llvm.x86.mmx.padds.w
+    12, // llvm.x86.mmx.paddus.b
+    12, // llvm.x86.mmx.paddus.w
+    70, // llvm.x86.mmx.palignr.b
+    12, // llvm.x86.mmx.pand
+    12, // llvm.x86.mmx.pandn
+    12, // llvm.x86.mmx.pavg.b
+    12, // llvm.x86.mmx.pavg.w
+    12, // llvm.x86.mmx.pcmpeq.b
+    12, // llvm.x86.mmx.pcmpeq.d
+    12, // llvm.x86.mmx.pcmpeq.w
+    12, // llvm.x86.mmx.pcmpgt.b
+    12, // llvm.x86.mmx.pcmpgt.d
+    12, // llvm.x86.mmx.pcmpgt.w
+    78, // llvm.x86.mmx.pextr.w
+    70, // llvm.x86.mmx.pinsr.w
+    12, // llvm.x86.mmx.pmadd.wd
+    12, // llvm.x86.mmx.pmaxs.w
+    12, // llvm.x86.mmx.pmaxu.b
+    12, // llvm.x86.mmx.pmins.w
+    12, // llvm.x86.mmx.pminu.b
+    12, // llvm.x86.mmx.pmovmskb
+    12, // llvm.x86.mmx.pmulh.w
+    12, // llvm.x86.mmx.pmulhu.w
+    12, // llvm.x86.mmx.pmull.w
+    12, // llvm.x86.mmx.pmulu.dq
+    12, // llvm.x86.mmx.por
+    12, // llvm.x86.mmx.psad.bw
+    12, // llvm.x86.mmx.psll.d
+    12, // llvm.x86.mmx.psll.q
+    12, // llvm.x86.mmx.psll.w
+    12, // llvm.x86.mmx.pslli.d
+    12, // llvm.x86.mmx.pslli.q
+    12, // llvm.x86.mmx.pslli.w
+    12, // llvm.x86.mmx.psra.d
+    12, // llvm.x86.mmx.psra.w
+    12, // llvm.x86.mmx.psrai.d
+    12, // llvm.x86.mmx.psrai.w
+    12, // llvm.x86.mmx.psrl.d
+    12, // llvm.x86.mmx.psrl.q
+    12, // llvm.x86.mmx.psrl.w
+    12, // llvm.x86.mmx.psrli.d
+    12, // llvm.x86.mmx.psrli.q
+    12, // llvm.x86.mmx.psrli.w
+    12, // llvm.x86.mmx.psub.b
+    12, // llvm.x86.mmx.psub.d
+    12, // llvm.x86.mmx.psub.q
+    12, // llvm.x86.mmx.psub.w
+    12, // llvm.x86.mmx.psubs.b
+    12, // llvm.x86.mmx.psubs.w
+    12, // llvm.x86.mmx.psubus.b
+    12, // llvm.x86.mmx.psubus.w
+    12, // llvm.x86.mmx.punpckhbw
+    12, // llvm.x86.mmx.punpckhdq
+    12, // llvm.x86.mmx.punpckhwd
+    12, // llvm.x86.mmx.punpcklbw
+    12, // llvm.x86.mmx.punpckldq
+    12, // llvm.x86.mmx.punpcklwd
+    12, // llvm.x86.mmx.pxor
+    7, // llvm.x86.monitorx
+    7, // llvm.x86.movdir64b
+    7, // llvm.x86.mwaitx
+    70, // llvm.x86.pclmulqdq
+    70, // llvm.x86.pclmulqdq.256
+    70, // llvm.x86.pclmulqdq.512
+    7, // llvm.x86.ptwrite32
+    7, // llvm.x86.ptwrite64
+    7, // llvm.x86.rdfsbase.32
+    7, // llvm.x86.rdfsbase.64
+    7, // llvm.x86.rdgsbase.32
+    7, // llvm.x86.rdgsbase.64
+    7, // llvm.x86.rdpid
+    7, // llvm.x86.rdpkru
+    7, // llvm.x86.rdpmc
+    7, // llvm.x86.rdrand.16
+    7, // llvm.x86.rdrand.32
+    7, // llvm.x86.rdrand.64
+    7, // llvm.x86.rdseed.16
+    7, // llvm.x86.rdseed.32
+    7, // llvm.x86.rdseed.64
+    7, // llvm.x86.rdsspd
+    7, // llvm.x86.rdsspq
+    7, // llvm.x86.rdtsc
+    7, // llvm.x86.rdtscp
+    7, // llvm.x86.rstorssp
+    7, // llvm.x86.saveprevssp
+    7, // llvm.x86.seh.ehguard
+    7, // llvm.x86.seh.ehregnode
+    12, // llvm.x86.seh.lsda
+    7, // llvm.x86.senduipi
+    7, // llvm.x86.serialize
+    7, // llvm.x86.setssbsy
+    12, // llvm.x86.sha1msg1
+    12, // llvm.x86.sha1msg2
+    12, // llvm.x86.sha1nexte
+    70, // llvm.x86.sha1rnds4
+    12, // llvm.x86.sha256msg1
+    12, // llvm.x86.sha256msg2
+    12, // llvm.x86.sha256rnds2
+    7, // llvm.x86.slwpcb
+    70, // llvm.x86.sse.cmp.ps
+    70, // llvm.x86.sse.cmp.ss
+    12, // llvm.x86.sse.comieq.ss
+    12, // llvm.x86.sse.comige.ss
+    12, // llvm.x86.sse.comigt.ss
+    12, // llvm.x86.sse.comile.ss
+    12, // llvm.x86.sse.comilt.ss
+    12, // llvm.x86.sse.comineq.ss
+    12, // llvm.x86.sse.cvtpd2pi
+    12, // llvm.x86.sse.cvtpi2pd
+    12, // llvm.x86.sse.cvtpi2ps
+    12, // llvm.x86.sse.cvtps2pi
+    12, // llvm.x86.sse.cvtss2si
+    12, // llvm.x86.sse.cvtss2si64
+    12, // llvm.x86.sse.cvttpd2pi
+    12, // llvm.x86.sse.cvttps2pi
+    12, // llvm.x86.sse.cvttss2si
+    12, // llvm.x86.sse.cvttss2si64
+    56, // llvm.x86.sse.ldmxcsr
+    12, // llvm.x86.sse.max.ps
+    12, // llvm.x86.sse.max.ss
+    12, // llvm.x86.sse.min.ps
+    12, // llvm.x86.sse.min.ss
+    12, // llvm.x86.sse.movmsk.ps
+    78, // llvm.x86.sse.pshuf.w
+    12, // llvm.x86.sse.rcp.ps
+    12, // llvm.x86.sse.rcp.ss
+    12, // llvm.x86.sse.rsqrt.ps
+    12, // llvm.x86.sse.rsqrt.ss
+    7, // llvm.x86.sse.sfence
+    218, // llvm.x86.sse.stmxcsr
+    12, // llvm.x86.sse.ucomieq.ss
+    12, // llvm.x86.sse.ucomige.ss
+    12, // llvm.x86.sse.ucomigt.ss
+    12, // llvm.x86.sse.ucomile.ss
+    12, // llvm.x86.sse.ucomilt.ss
+    12, // llvm.x86.sse.ucomineq.ss
+    7, // llvm.x86.sse2.clflush
+    70, // llvm.x86.sse2.cmp.pd
+    70, // llvm.x86.sse2.cmp.sd
+    12, // llvm.x86.sse2.comieq.sd
+    12, // llvm.x86.sse2.comige.sd
+    12, // llvm.x86.sse2.comigt.sd
+    12, // llvm.x86.sse2.comile.sd
+    12, // llvm.x86.sse2.comilt.sd
+    12, // llvm.x86.sse2.comineq.sd
+    12, // llvm.x86.sse2.cvtpd2dq
+    12, // llvm.x86.sse2.cvtpd2ps
+    12, // llvm.x86.sse2.cvtps2dq
+    12, // llvm.x86.sse2.cvtsd2si
+    12, // llvm.x86.sse2.cvtsd2si64
+    12, // llvm.x86.sse2.cvtsd2ss
+    12, // llvm.x86.sse2.cvttpd2dq
+    12, // llvm.x86.sse2.cvttps2dq
+    12, // llvm.x86.sse2.cvttsd2si
+    12, // llvm.x86.sse2.cvttsd2si64
+    7, // llvm.x86.sse2.lfence
+    7, // llvm.x86.sse2.maskmov.dqu
+    12, // llvm.x86.sse2.max.pd
+    12, // llvm.x86.sse2.max.sd
+    7, // llvm.x86.sse2.mfence
+    12, // llvm.x86.sse2.min.pd
+    12, // llvm.x86.sse2.min.sd
+    12, // llvm.x86.sse2.movmsk.pd
+    12, // llvm.x86.sse2.packssdw.128
+    12, // llvm.x86.sse2.packsswb.128
+    12, // llvm.x86.sse2.packuswb.128
+    7, // llvm.x86.sse2.pause
+    12, // llvm.x86.sse2.pavg.b
+    12, // llvm.x86.sse2.pavg.w
+    12, // llvm.x86.sse2.pmadd.wd
+    12, // llvm.x86.sse2.pmovmskb.128
+    12, // llvm.x86.sse2.pmulh.w
+    12, // llvm.x86.sse2.pmulhu.w
+    12, // llvm.x86.sse2.psad.bw
+    12, // llvm.x86.sse2.psll.d
+    12, // llvm.x86.sse2.psll.q
+    12, // llvm.x86.sse2.psll.w
+    12, // llvm.x86.sse2.pslli.d
+    12, // llvm.x86.sse2.pslli.q
+    12, // llvm.x86.sse2.pslli.w
+    12, // llvm.x86.sse2.psra.d
+    12, // llvm.x86.sse2.psra.w
+    12, // llvm.x86.sse2.psrai.d
+    12, // llvm.x86.sse2.psrai.w
+    12, // llvm.x86.sse2.psrl.d
+    12, // llvm.x86.sse2.psrl.q
+    12, // llvm.x86.sse2.psrl.w
+    12, // llvm.x86.sse2.psrli.d
+    12, // llvm.x86.sse2.psrli.q
+    12, // llvm.x86.sse2.psrli.w
+    12, // llvm.x86.sse2.ucomieq.sd
+    12, // llvm.x86.sse2.ucomige.sd
+    12, // llvm.x86.sse2.ucomigt.sd
+    12, // llvm.x86.sse2.ucomile.sd
+    12, // llvm.x86.sse2.ucomilt.sd
+    12, // llvm.x86.sse2.ucomineq.sd
+    12, // llvm.x86.sse3.addsub.pd
+    12, // llvm.x86.sse3.addsub.ps
+    12, // llvm.x86.sse3.hadd.pd
+    12, // llvm.x86.sse3.hadd.ps
+    12, // llvm.x86.sse3.hsub.pd
+    12, // llvm.x86.sse3.hsub.ps
+    21, // llvm.x86.sse3.ldu.dq
+    7, // llvm.x86.sse3.monitor
+    7, // llvm.x86.sse3.mwait
+    12, // llvm.x86.sse41.blendvpd
+    12, // llvm.x86.sse41.blendvps
+    70, // llvm.x86.sse41.dppd
+    70, // llvm.x86.sse41.dpps
+    70, // llvm.x86.sse41.insertps
+    70, // llvm.x86.sse41.mpsadbw
+    12, // llvm.x86.sse41.packusdw
+    12, // llvm.x86.sse41.pblendvb
+    12, // llvm.x86.sse41.phminposuw
+    12, // llvm.x86.sse41.ptestc
+    12, // llvm.x86.sse41.ptestnzc
+    12, // llvm.x86.sse41.ptestz
+    78, // llvm.x86.sse41.round.pd
+    78, // llvm.x86.sse41.round.ps
+    70, // llvm.x86.sse41.round.sd
+    70, // llvm.x86.sse41.round.ss
+    12, // llvm.x86.sse42.crc32.32.16
+    12, // llvm.x86.sse42.crc32.32.32
+    12, // llvm.x86.sse42.crc32.32.8
+    12, // llvm.x86.sse42.crc32.64.64
+    74, // llvm.x86.sse42.pcmpestri128
+    74, // llvm.x86.sse42.pcmpestria128
+    74, // llvm.x86.sse42.pcmpestric128
+    74, // llvm.x86.sse42.pcmpestrio128
+    74, // llvm.x86.sse42.pcmpestris128
+    74, // llvm.x86.sse42.pcmpestriz128
+    74, // llvm.x86.sse42.pcmpestrm128
+    70, // llvm.x86.sse42.pcmpistri128
+    70, // llvm.x86.sse42.pcmpistria128
+    70, // llvm.x86.sse42.pcmpistric128
+    70, // llvm.x86.sse42.pcmpistrio128
+    70, // llvm.x86.sse42.pcmpistris128
+    70, // llvm.x86.sse42.pcmpistriz128
+    70, // llvm.x86.sse42.pcmpistrm128
+    12, // llvm.x86.sse4a.extrq
+    79, // llvm.x86.sse4a.extrqi
+    12, // llvm.x86.sse4a.insertq
+    182, // llvm.x86.sse4a.insertqi
+    12, // llvm.x86.ssse3.pabs.b
+    12, // llvm.x86.ssse3.pabs.d
+    12, // llvm.x86.ssse3.pabs.w
+    12, // llvm.x86.ssse3.phadd.d
+    12, // llvm.x86.ssse3.phadd.d.128
+    12, // llvm.x86.ssse3.phadd.sw
+    12, // llvm.x86.ssse3.phadd.sw.128
+    12, // llvm.x86.ssse3.phadd.w
+    12, // llvm.x86.ssse3.phadd.w.128
+    12, // llvm.x86.ssse3.phsub.d
+    12, // llvm.x86.ssse3.phsub.d.128
+    12, // llvm.x86.ssse3.phsub.sw
+    12, // llvm.x86.ssse3.phsub.sw.128
+    12, // llvm.x86.ssse3.phsub.w
+    12, // llvm.x86.ssse3.phsub.w.128
+    12, // llvm.x86.ssse3.pmadd.ub.sw
+    12, // llvm.x86.ssse3.pmadd.ub.sw.128
+    12, // llvm.x86.ssse3.pmul.hr.sw
+    12, // llvm.x86.ssse3.pmul.hr.sw.128
+    12, // llvm.x86.ssse3.pshuf.b
+    12, // llvm.x86.ssse3.pshuf.b.128
+    12, // llvm.x86.ssse3.psign.b
+    12, // llvm.x86.ssse3.psign.b.128
+    12, // llvm.x86.ssse3.psign.d
+    12, // llvm.x86.ssse3.psign.d.128
+    12, // llvm.x86.ssse3.psign.w
+    12, // llvm.x86.ssse3.psign.w.128
+    7, // llvm.x86.sttilecfg
+    7, // llvm.x86.stui
+    12, // llvm.x86.subborrow.32
+    12, // llvm.x86.subborrow.64
+    78, // llvm.x86.tbm.bextri.u32
+    78, // llvm.x86.tbm.bextri.u64
+    177, // llvm.x86.tdpbf16ps
+    177, // llvm.x86.tdpbssd
+    7, // llvm.x86.tdpbssd.internal
+    177, // llvm.x86.tdpbsud
+    177, // llvm.x86.tdpbusd
+    177, // llvm.x86.tdpbuud
+    7, // llvm.x86.testui
+    83, // llvm.x86.tileloadd64
+    7, // llvm.x86.tileloadd64.internal
+    83, // llvm.x86.tileloaddt164
+    7, // llvm.x86.tilerelease
+    83, // llvm.x86.tilestored64
+    7, // llvm.x86.tilestored64.internal
+    83, // llvm.x86.tilezero
+    7, // llvm.x86.tilezero.internal
+    7, // llvm.x86.tpause
+    7, // llvm.x86.umonitor
+    7, // llvm.x86.umwait
+    78, // llvm.x86.vcvtps2ph.128
+    78, // llvm.x86.vcvtps2ph.256
+    70, // llvm.x86.vgf2p8affineinvqb.128
+    70, // llvm.x86.vgf2p8affineinvqb.256
+    70, // llvm.x86.vgf2p8affineinvqb.512
+    70, // llvm.x86.vgf2p8affineqb.128
+    70, // llvm.x86.vgf2p8affineqb.256
+    70, // llvm.x86.vgf2p8affineqb.512
+    12, // llvm.x86.vgf2p8mulb.128
+    12, // llvm.x86.vgf2p8mulb.256
+    12, // llvm.x86.vgf2p8mulb.512
+    7, // llvm.x86.wbinvd
+    7, // llvm.x86.wbnoinvd
+    7, // llvm.x86.wrfsbase.32
+    7, // llvm.x86.wrfsbase.64
+    7, // llvm.x86.wrgsbase.32
+    7, // llvm.x86.wrgsbase.64
+    7, // llvm.x86.wrpkru
+    7, // llvm.x86.wrssd
+    7, // llvm.x86.wrssq
+    7, // llvm.x86.wrussd
+    7, // llvm.x86.wrussq
+    83, // llvm.x86.xabort
+    7, // llvm.x86.xbegin
+    7, // llvm.x86.xend
+    7, // llvm.x86.xgetbv
+    12, // llvm.x86.xop.vfrcz.pd
+    12, // llvm.x86.xop.vfrcz.pd.256
+    12, // llvm.x86.xop.vfrcz.ps
+    12, // llvm.x86.xop.vfrcz.ps.256
+    12, // llvm.x86.xop.vfrcz.sd
+    12, // llvm.x86.xop.vfrcz.ss
+    71, // llvm.x86.xop.vpermil2pd
+    71, // llvm.x86.xop.vpermil2pd.256
+    71, // llvm.x86.xop.vpermil2ps
+    71, // llvm.x86.xop.vpermil2ps.256
+    12, // llvm.x86.xop.vphaddbd
+    12, // llvm.x86.xop.vphaddbq
+    12, // llvm.x86.xop.vphaddbw
+    12, // llvm.x86.xop.vphadddq
+    12, // llvm.x86.xop.vphaddubd
+    12, // llvm.x86.xop.vphaddubq
+    12, // llvm.x86.xop.vphaddubw
+    12, // llvm.x86.xop.vphaddudq
+    12, // llvm.x86.xop.vphadduwd
+    12, // llvm.x86.xop.vphadduwq
+    12, // llvm.x86.xop.vphaddwd
+    12, // llvm.x86.xop.vphaddwq
+    12, // llvm.x86.xop.vphsubbw
+    12, // llvm.x86.xop.vphsubdq
+    12, // llvm.x86.xop.vphsubwd
+    12, // llvm.x86.xop.vpmacsdd
+    12, // llvm.x86.xop.vpmacsdqh
+    12, // llvm.x86.xop.vpmacsdql
+    12, // llvm.x86.xop.vpmacssdd
+    12, // llvm.x86.xop.vpmacssdqh
+    12, // llvm.x86.xop.vpmacssdql
+    12, // llvm.x86.xop.vpmacsswd
+    12, // llvm.x86.xop.vpmacssww
+    12, // llvm.x86.xop.vpmacswd
+    12, // llvm.x86.xop.vpmacsww
+    12, // llvm.x86.xop.vpmadcsswd
+    12, // llvm.x86.xop.vpmadcswd
+    12, // llvm.x86.xop.vpperm
+    12, // llvm.x86.xop.vpshab
+    12, // llvm.x86.xop.vpshad
+    12, // llvm.x86.xop.vpshaq
+    12, // llvm.x86.xop.vpshaw
+    12, // llvm.x86.xop.vpshlb
+    12, // llvm.x86.xop.vpshld
+    12, // llvm.x86.xop.vpshlq
+    12, // llvm.x86.xop.vpshlw
+    7, // llvm.x86.xresldtrk
+    7, // llvm.x86.xrstor
+    7, // llvm.x86.xrstor64
+    7, // llvm.x86.xrstors
+    7, // llvm.x86.xrstors64
+    7, // llvm.x86.xsave
+    7, // llvm.x86.xsave64
+    7, // llvm.x86.xsavec
+    7, // llvm.x86.xsavec64
+    7, // llvm.x86.xsaveopt
+    7, // llvm.x86.xsaveopt64
+    7, // llvm.x86.xsaves
+    7, // llvm.x86.xsaves64
+    7, // llvm.x86.xsetbv
+    7, // llvm.x86.xsusldtrk
+    7, // llvm.x86.xtest
+    12, // llvm.xcore.bitrev
+    7, // llvm.xcore.checkevent
+    219, // llvm.xcore.chkct
+    7, // llvm.xcore.clre
+    219, // llvm.xcore.clrpt
+    7, // llvm.xcore.clrsr
+    12, // llvm.xcore.crc32
+    12, // llvm.xcore.crc8
+    219, // llvm.xcore.edu
+    219, // llvm.xcore.eeu
+    219, // llvm.xcore.endin
+    219, // llvm.xcore.freer
+    7, // llvm.xcore.geted
+    7, // llvm.xcore.getet
+    12, // llvm.xcore.getid
+    7, // llvm.xcore.getps
+    7, // llvm.xcore.getr
+    219, // llvm.xcore.getst
+    219, // llvm.xcore.getts
+    219, // llvm.xcore.in
+    219, // llvm.xcore.inct
+    219, // llvm.xcore.initcp
+    219, // llvm.xcore.initdp
+    219, // llvm.xcore.initlr
+    219, // llvm.xcore.initpc
+    219, // llvm.xcore.initsp
+    219, // llvm.xcore.inshr
+    219, // llvm.xcore.int
+    219, // llvm.xcore.mjoin
+    219, // llvm.xcore.msync
+    219, // llvm.xcore.out
+    219, // llvm.xcore.outct
+    219, // llvm.xcore.outshr
+    219, // llvm.xcore.outt
+    219, // llvm.xcore.peek
+    219, // llvm.xcore.setc
+    220, // llvm.xcore.setclk
+    219, // llvm.xcore.setd
+    219, // llvm.xcore.setev
+    7, // llvm.xcore.setps
+    219, // llvm.xcore.setpsc
+    219, // llvm.xcore.setpt
+    220, // llvm.xcore.setrdy
+    7, // llvm.xcore.setsr
+    219, // llvm.xcore.settw
+    219, // llvm.xcore.setv
+    12, // llvm.xcore.sext
+    7, // llvm.xcore.ssync
+    219, // llvm.xcore.syncr
+    219, // llvm.xcore.testct
+    219, // llvm.xcore.testwct
+    21, // llvm.xcore.waitevent
+    12, // llvm.xcore.zext
   };
 
-  AttributeList AS[8];
+  AttributeList AS[9];
   unsigned NumAttrs = 0;
   if (id != 0) {
     switch(IntrinsicsToAttributesMap[id - 1]) {
     default: llvm_unreachable("Invalid attribute number");
-    case 3: {
+    case 7: {
       const Attribute::AttrKind Atts[] = {Attribute::NoUnwind};
       AS[0] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
       NumAttrs = 1;
       break;
       }
-    case 154: {
+    case 219: {
       const Attribute::AttrKind AttrParam1[]= {Attribute::NoCapture};
       AS[0] = AttributeList::get(C, 1, AttrParam1);
       const Attribute::AttrKind Atts[] = {Attribute::NoUnwind};
@@ -16415,7 +22900,7 @@
       NumAttrs = 2;
       break;
       }
-    case 155: {
+    case 220: {
       const Attribute::AttrKind AttrParam1[]= {Attribute::NoCapture};
       AS[0] = AttributeList::get(C, 1, AttrParam1);
       const Attribute::AttrKind AttrParam2[]= {Attribute::NoCapture};
@@ -16425,27 +22910,7 @@
       NumAttrs = 3;
       break;
       }
-    case 60: {
-      const Attribute::AttrKind AttrParam1[]= {Attribute::NoCapture};
-      AS[0] = AttributeList::get(C, 1, AttrParam1);
-      const Attribute::AttrKind AttrParam3[]= {Attribute::ImmArg};
-      AS[1] = AttributeList::get(C, 3, AttrParam3);
-      const Attribute::AttrKind AttrParam4[]= {Attribute::ImmArg};
-      AS[2] = AttributeList::get(C, 4, AttrParam4);
-      const Attribute::AttrKind AttrParam5[]= {Attribute::ImmArg};
-      AS[3] = AttributeList::get(C, 5, AttrParam5);
-      const Attribute::AttrKind AttrParam6[]= {Attribute::ImmArg};
-      AS[4] = AttributeList::get(C, 6, AttrParam6);
-      const Attribute::AttrKind AttrParam7[]= {Attribute::ImmArg};
-      AS[5] = AttributeList::get(C, 7, AttrParam7);
-      const Attribute::AttrKind AttrParam8[]= {Attribute::ImmArg};
-      AS[6] = AttributeList::get(C, 8, AttrParam8);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind};
-      AS[7] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
-      NumAttrs = 8;
-      break;
-      }
-    case 101: {
+    case 83: {
       const Attribute::AttrKind AttrParam1[]= {Attribute::ImmArg};
       AS[0] = AttributeList::get(C, 1, AttrParam1);
       const Attribute::AttrKind Atts[] = {Attribute::NoUnwind};
@@ -16453,7 +22918,7 @@
       NumAttrs = 2;
       break;
       }
-    case 115: {
+    case 173: {
       const Attribute::AttrKind AttrParam1[]= {Attribute::ImmArg};
       AS[0] = AttributeList::get(C, 1, AttrParam1);
       const Attribute::AttrKind AttrParam2[]= {Attribute::ImmArg};
@@ -16463,7 +22928,7 @@
       NumAttrs = 3;
       break;
       }
-    case 119: {
+    case 177: {
       const Attribute::AttrKind AttrParam1[]= {Attribute::ImmArg};
       AS[0] = AttributeList::get(C, 1, AttrParam1);
       const Attribute::AttrKind AttrParam2[]= {Attribute::ImmArg};
@@ -16475,7 +22940,7 @@
       NumAttrs = 4;
       break;
       }
-    case 118: {
+    case 176: {
       const Attribute::AttrKind AttrParam1[]= {Attribute::ImmArg};
       AS[0] = AttributeList::get(C, 1, AttrParam1);
       const Attribute::AttrKind AttrParam2[]= {Attribute::ImmArg};
@@ -16491,7 +22956,7 @@
       NumAttrs = 6;
       break;
       }
-    case 113: {
+    case 172: {
       const Attribute::AttrKind AttrParam1[]= {Attribute::ImmArg};
       AS[0] = AttributeList::get(C, 1, AttrParam1);
       const Attribute::AttrKind AttrParam2[]= {Attribute::ImmArg};
@@ -16509,7 +22974,7 @@
       NumAttrs = 7;
       break;
       }
-    case 116: {
+    case 174: {
       const Attribute::AttrKind AttrParam1[]= {Attribute::ImmArg};
       AS[0] = AttributeList::get(C, 1, AttrParam1);
       const Attribute::AttrKind AttrParam2[]= {Attribute::ImmArg};
@@ -16525,7 +22990,7 @@
       NumAttrs = 6;
       break;
       }
-    case 117: {
+    case 175: {
       const Attribute::AttrKind AttrParam1[]= {Attribute::ImmArg};
       AS[0] = AttributeList::get(C, 1, AttrParam1);
       const Attribute::AttrKind AttrParam2[]= {Attribute::ImmArg};
@@ -16537,7 +23002,7 @@
       NumAttrs = 4;
       break;
       }
-    case 6: {
+    case 9: {
       const Attribute::AttrKind AttrParam2[]= {Attribute::WriteOnly};
       AS[0] = AttributeList::get(C, 2, AttrParam2);
       const Attribute::AttrKind Atts[] = {Attribute::NoUnwind};
@@ -16545,7 +23010,7 @@
       NumAttrs = 2;
       break;
       }
-    case 132: {
+    case 188: {
       const Attribute::AttrKind AttrParam2[]= {Attribute::ImmArg};
       AS[0] = AttributeList::get(C, 2, AttrParam2);
       const Attribute::AttrKind Atts[] = {Attribute::NoUnwind};
@@ -16553,7 +23018,7 @@
       NumAttrs = 2;
       break;
       }
-    case 32: {
+    case 217: {
       const Attribute::AttrKind AttrParam3[]= {Attribute::ImmArg};
       AS[0] = AttributeList::get(C, 3, AttrParam3);
       const Attribute::AttrKind Atts[] = {Attribute::NoUnwind};
@@ -16561,7 +23026,7 @@
       NumAttrs = 2;
       break;
       }
-    case 67: {
+    case 211: {
       const Attribute::AttrKind AttrParam4[]= {Attribute::ImmArg};
       AS[0] = AttributeList::get(C, 4, AttrParam4);
       const Attribute::AttrKind AttrParam5[]= {Attribute::ImmArg};
@@ -16571,7 +23036,7 @@
       NumAttrs = 3;
       break;
       }
-    case 52: {
+    case 89: {
       const Attribute::AttrKind AttrParam5[]= {Attribute::ImmArg};
       AS[0] = AttributeList::get(C, 5, AttrParam5);
       const Attribute::AttrKind Atts[] = {Attribute::NoUnwind};
@@ -16579,81 +23044,37 @@
       NumAttrs = 2;
       break;
       }
-    case 68: {
-      const Attribute::AttrKind AttrParam5[]= {Attribute::ImmArg};
-      AS[0] = AttributeList::get(C, 5, AttrParam5);
-      const Attribute::AttrKind AttrParam6[]= {Attribute::ImmArg};
-      AS[1] = AttributeList::get(C, 6, AttrParam6);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind};
-      AS[2] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
-      NumAttrs = 3;
-      break;
-      }
-    case 53: {
-      const Attribute::AttrKind AttrParam6[]= {Attribute::ImmArg};
-      AS[0] = AttributeList::get(C, 6, AttrParam6);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind};
-      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
-      NumAttrs = 2;
-      break;
-      }
-    case 69: {
-      const Attribute::AttrKind AttrParam6[]= {Attribute::ImmArg};
-      AS[0] = AttributeList::get(C, 6, AttrParam6);
-      const Attribute::AttrKind AttrParam7[]= {Attribute::ImmArg};
-      AS[1] = AttributeList::get(C, 7, AttrParam7);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind};
-      AS[2] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
-      NumAttrs = 3;
-      break;
-      }
-    case 104: {
-      const Attribute::AttrKind AttrParam7[]= {Attribute::ImmArg};
-      AS[0] = AttributeList::get(C, 7, AttrParam7);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind};
-      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
-      NumAttrs = 2;
-      break;
-      }
-    case 70: {
-      const Attribute::AttrKind AttrParam7[]= {Attribute::ImmArg};
-      AS[0] = AttributeList::get(C, 7, AttrParam7);
-      const Attribute::AttrKind AttrParam8[]= {Attribute::ImmArg};
-      AS[1] = AttributeList::get(C, 8, AttrParam8);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind};
-      AS[2] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
-      NumAttrs = 3;
-      break;
-      }
-    case 71: {
-      const Attribute::AttrKind AttrParam8[]= {Attribute::ImmArg};
-      AS[0] = AttributeList::get(C, 8, AttrParam8);
-      const Attribute::AttrKind AttrParam9[]= {Attribute::ImmArg};
-      AS[1] = AttributeList::get(C, 9, AttrParam9);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind};
-      AS[2] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
-      NumAttrs = 3;
-      break;
-      }
-    case 38: {
-      const Attribute::AttrKind AttrParam1[]= {Attribute::NoCapture,Attribute::ReadOnly};
-      AS[0] = AttributeList::get(C, 1, AttrParam1);
-      const Attribute::AttrKind AttrParam2[]= {Attribute::ImmArg};
-      AS[1] = AttributeList::get(C, 2, AttrParam2);
-      const Attribute::AttrKind AttrParam3[]= {Attribute::ImmArg};
-      AS[2] = AttributeList::get(C, 3, AttrParam3);
+    case 202: {
       const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::InaccessibleMemOrArgMemOnly};
-      AS[3] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
-      NumAttrs = 4;
+      AS[0] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 1;
       break;
       }
-    case 29: {
+    case 76: {
+      const Attribute::AttrKind AttrParam2[]= {Attribute::NoCapture};
+      AS[0] = AttributeList::get(C, 2, AttrParam2);
+      const Attribute::AttrKind AttrParam4[]= {Attribute::ImmArg};
+      AS[1] = AttributeList::get(C, 4, AttrParam4);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::InaccessibleMemOrArgMemOnly};
+      AS[2] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 3;
+      break;
+      }
+    case 77: {
+      const Attribute::AttrKind AttrParam4[]= {Attribute::ImmArg};
+      AS[0] = AttributeList::get(C, 4, AttrParam4);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::InaccessibleMemOrArgMemOnly};
+      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 2;
+      break;
+      }
+    case 178: {
       const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ArgMemOnly};
       AS[0] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
       NumAttrs = 1;
       break;
       }
-    case 23: {
+    case 30: {
       const Attribute::AttrKind AttrParam1[]= {Attribute::NoCapture};
       AS[0] = AttributeList::get(C, 1, AttrParam1);
       const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ArgMemOnly};
@@ -16661,7 +23082,7 @@
       NumAttrs = 2;
       break;
       }
-    case 8: {
+    case 11: {
       const Attribute::AttrKind AttrParam1[]= {Attribute::NoCapture,Attribute::ReadOnly};
       AS[0] = AttributeList::get(C, 1, AttrParam1);
       const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ArgMemOnly};
@@ -16669,7 +23090,7 @@
       NumAttrs = 2;
       break;
       }
-    case 130: {
+    case 186: {
       const Attribute::AttrKind AttrParam1[]= {Attribute::NoCapture,Attribute::WriteOnly};
       AS[0] = AttributeList::get(C, 1, AttrParam1);
       const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ArgMemOnly};
@@ -16677,7 +23098,7 @@
       NumAttrs = 2;
       break;
       }
-    case 129: {
+    case 185: {
       const Attribute::AttrKind AttrParam1[]= {Attribute::NoCapture,Attribute::WriteOnly};
       AS[0] = AttributeList::get(C, 1, AttrParam1);
       const Attribute::AttrKind AttrParam2[]= {Attribute::NoCapture,Attribute::ReadOnly};
@@ -16687,20 +23108,18 @@
       NumAttrs = 3;
       break;
       }
-    case 34: {
-      const Attribute::AttrKind AttrParam1[]= {Attribute::NoCapture,Attribute::WriteOnly};
+    case 192: {
+      const Attribute::AttrKind AttrParam1[]= {Attribute::NoCapture};
       AS[0] = AttributeList::get(C, 1, AttrParam1);
-      const Attribute::AttrKind AttrParam2[]= {Attribute::NoCapture,Attribute::ReadOnly};
+      const Attribute::AttrKind AttrParam2[]= {Attribute::ImmArg};
       AS[1] = AttributeList::get(C, 2, AttrParam2);
-      const Attribute::AttrKind AttrParam4[]= {Attribute::ImmArg};
-      AS[2] = AttributeList::get(C, 4, AttrParam4);
       const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ArgMemOnly};
-      AS[3] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
-      NumAttrs = 4;
+      AS[2] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 3;
       break;
       }
-    case 36: {
-      const Attribute::AttrKind AttrParam1[]= {Attribute::NoCapture,Attribute::WriteOnly};
+    case 193: {
+      const Attribute::AttrKind AttrParam1[]= {Attribute::NoCapture};
       AS[0] = AttributeList::get(C, 1, AttrParam1);
       const Attribute::AttrKind AttrParam4[]= {Attribute::ImmArg};
       AS[1] = AttributeList::get(C, 4, AttrParam4);
@@ -16709,19 +23128,549 @@
       NumAttrs = 3;
       break;
       }
-    case 35: {
+    case 194: {
       const Attribute::AttrKind AttrParam1[]= {Attribute::NoCapture};
       AS[0] = AttributeList::get(C, 1, AttrParam1);
-      const Attribute::AttrKind AttrParam2[]= {Attribute::NoCapture,Attribute::ReadOnly};
-      AS[1] = AttributeList::get(C, 2, AttrParam2);
-      const Attribute::AttrKind AttrParam4[]= {Attribute::ImmArg};
-      AS[2] = AttributeList::get(C, 4, AttrParam4);
+      const Attribute::AttrKind AttrParam5[]= {Attribute::ImmArg};
+      AS[1] = AttributeList::get(C, 5, AttrParam5);
       const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ArgMemOnly};
-      AS[3] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
-      NumAttrs = 4;
+      AS[2] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 3;
       break;
       }
-    case 51: {
+    case 28: {
+      const Attribute::AttrKind AttrParam2[]= {Attribute::NoCapture};
+      AS[0] = AttributeList::get(C, 2, AttrParam2);
+      const Attribute::AttrKind AttrParam3[]= {Attribute::NoCapture};
+      AS[1] = AttributeList::get(C, 3, AttrParam3);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ArgMemOnly};
+      AS[2] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 3;
+      break;
+      }
+    case 64: {
+      const Attribute::AttrKind AttrParam3[]= {Attribute::NoCapture};
+      AS[0] = AttributeList::get(C, 3, AttrParam3);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ArgMemOnly};
+      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 2;
+      break;
+      }
+    case 75: {
+      const Attribute::AttrKind AttrParam3[]= {Attribute::ImmArg};
+      AS[0] = AttributeList::get(C, 3, AttrParam3);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ArgMemOnly};
+      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 2;
+      break;
+      }
+    case 65: {
+      const Attribute::AttrKind AttrParam4[]= {Attribute::NoCapture};
+      AS[0] = AttributeList::get(C, 4, AttrParam4);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ArgMemOnly};
+      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 2;
+      break;
+      }
+    case 183: {
+      const Attribute::AttrKind AttrParam4[]= {Attribute::ImmArg};
+      AS[0] = AttributeList::get(C, 4, AttrParam4);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ArgMemOnly};
+      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 2;
+      break;
+      }
+    case 66: {
+      const Attribute::AttrKind AttrParam5[]= {Attribute::NoCapture};
+      AS[0] = AttributeList::get(C, 5, AttrParam5);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ArgMemOnly};
+      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 2;
+      break;
+      }
+    case 67: {
+      const Attribute::AttrKind AttrParam6[]= {Attribute::NoCapture};
+      AS[0] = AttributeList::get(C, 6, AttrParam6);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ArgMemOnly};
+      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 2;
+      break;
+      }
+    case 191: {
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::InaccessibleMemOnly};
+      AS[0] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 1;
+      break;
+      }
+    case 29: {
+      const Attribute::AttrKind AttrParam3[]= {Attribute::ImmArg};
+      AS[0] = AttributeList::get(C, 3, AttrParam3);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::InaccessibleMemOnly};
+      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 2;
+      break;
+      }
+    case 69: {
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WriteOnly};
+      AS[0] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 1;
+      break;
+      }
+    case 61: {
+      const Attribute::AttrKind AttrParam1[]= {Attribute::NoCapture,Attribute::ReadOnly};
+      AS[0] = AttributeList::get(C, 1, AttrParam1);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WriteOnly};
+      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 2;
+      break;
+      }
+    case 197: {
+      const Attribute::AttrKind AttrParam2[]= {Attribute::NoCapture};
+      AS[0] = AttributeList::get(C, 2, AttrParam2);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WriteOnly};
+      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 2;
+      break;
+      }
+    case 62: {
+      const Attribute::AttrKind AttrParam2[]= {Attribute::NoCapture,Attribute::ReadOnly};
+      AS[0] = AttributeList::get(C, 2, AttrParam2);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WriteOnly};
+      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 2;
+      break;
+      }
+    case 184: {
+      const Attribute::AttrKind AttrParam4[]= {Attribute::ImmArg};
+      AS[0] = AttributeList::get(C, 4, AttrParam4);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WriteOnly};
+      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 2;
+      break;
+      }
+    case 80: {
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WriteOnly,Attribute::ArgMemOnly};
+      AS[0] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 1;
+      break;
+      }
+    case 68: {
+      const Attribute::AttrKind AttrParam1[]= {Attribute::NoCapture,Attribute::WriteOnly};
+      AS[0] = AttributeList::get(C, 1, AttrParam1);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WriteOnly,Attribute::ArgMemOnly};
+      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 2;
+      break;
+      }
+    case 21: {
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadOnly};
+      AS[0] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 1;
+      break;
+      }
+    case 195: {
+      const Attribute::AttrKind AttrParam1[]= {Attribute::NoCapture};
+      AS[0] = AttributeList::get(C, 1, AttrParam1);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadOnly};
+      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 2;
+      break;
+      }
+    case 187: {
+      const Attribute::AttrKind AttrParam1[]= {Attribute::ImmArg};
+      AS[0] = AttributeList::get(C, 1, AttrParam1);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadOnly};
+      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 2;
+      break;
+      }
+    case 196: {
+      const Attribute::AttrKind AttrParam2[]= {Attribute::NoCapture};
+      AS[0] = AttributeList::get(C, 2, AttrParam2);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadOnly};
+      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 2;
+      break;
+      }
+    case 82: {
+      const Attribute::AttrKind AttrParam2[]= {Attribute::ImmArg};
+      AS[0] = AttributeList::get(C, 2, AttrParam2);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadOnly};
+      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 2;
+      break;
+      }
+    case 20: {
+      const Attribute::AttrKind AttrParam2[]= {Attribute::ImmArg};
+      AS[0] = AttributeList::get(C, 2, AttrParam2);
+      const Attribute::AttrKind AttrParam3[]= {Attribute::ImmArg};
+      AS[1] = AttributeList::get(C, 3, AttrParam3);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadOnly};
+      AS[2] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 3;
+      break;
+      }
+    case 210: {
+      const Attribute::AttrKind AttrParam5[]= {Attribute::ImmArg};
+      AS[0] = AttributeList::get(C, 5, AttrParam5);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadOnly};
+      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 2;
+      break;
+      }
+    case 3: {
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadOnly,Attribute::ArgMemOnly};
+      AS[0] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 1;
+      break;
+      }
+    case 189: {
+      const Attribute::AttrKind AttrParam1[]= {Attribute::NoCapture};
+      AS[0] = AttributeList::get(C, 1, AttrParam1);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadOnly,Attribute::ArgMemOnly};
+      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 2;
+      break;
+      }
+    case 17: {
+      const Attribute::AttrKind AttrParam1[]= {Attribute::NoCapture,Attribute::ReadOnly};
+      AS[0] = AttributeList::get(C, 1, AttrParam1);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadOnly,Attribute::ArgMemOnly};
+      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 2;
+      break;
+      }
+    case 13: {
+      const Attribute::AttrKind AttrParam2[]= {Attribute::NoCapture,Attribute::ReadOnly};
+      AS[0] = AttributeList::get(C, 2, AttrParam2);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadOnly,Attribute::ArgMemOnly};
+      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 2;
+      break;
+      }
+    case 14: {
+      const Attribute::AttrKind AttrParam2[]= {Attribute::ReadNone};
+      AS[0] = AttributeList::get(C, 2, AttrParam2);
+      const Attribute::AttrKind AttrParam3[]= {Attribute::NoCapture,Attribute::ReadOnly};
+      AS[1] = AttributeList::get(C, 3, AttrParam3);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadOnly,Attribute::ArgMemOnly};
+      AS[2] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 3;
+      break;
+      }
+    case 81: {
+      const Attribute::AttrKind AttrParam2[]= {Attribute::ImmArg};
+      AS[0] = AttributeList::get(C, 2, AttrParam2);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadOnly,Attribute::ArgMemOnly};
+      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 2;
+      break;
+      }
+    case 12: {
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadNone};
+      AS[0] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 1;
+      break;
+      }
+    case 16: {
+      const Attribute::AttrKind AttrParam1[]= {Attribute::NoCapture};
+      AS[0] = AttributeList::get(C, 1, AttrParam1);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadNone};
+      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 2;
+      break;
+      }
+    case 15: {
+      const Attribute::AttrKind AttrParam1[]= {Attribute::ReadNone};
+      AS[0] = AttributeList::get(C, 1, AttrParam1);
+      const Attribute::AttrKind AttrParam2[]= {Attribute::ReadNone};
+      AS[1] = AttributeList::get(C, 2, AttrParam2);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadNone};
+      AS[2] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 3;
+      break;
+      }
+    case 73: {
+      const Attribute::AttrKind AttrParam1[]= {Attribute::ImmArg};
+      AS[0] = AttributeList::get(C, 1, AttrParam1);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadNone};
+      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 2;
+      break;
+      }
+    case 167: {
+      const Attribute::AttrKind AttrParam1[]= {Attribute::ImmArg};
+      AS[0] = AttributeList::get(C, 1, AttrParam1);
+      const Attribute::AttrKind AttrParam2[]= {Attribute::ImmArg};
+      AS[1] = AttributeList::get(C, 2, AttrParam2);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadNone};
+      AS[2] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 3;
+      break;
+      }
+    case 168: {
+      const Attribute::AttrKind AttrParam1[]= {Attribute::ImmArg};
+      AS[0] = AttributeList::get(C, 1, AttrParam1);
+      const Attribute::AttrKind AttrParam3[]= {Attribute::ImmArg};
+      AS[1] = AttributeList::get(C, 3, AttrParam3);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadNone};
+      AS[2] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 3;
+      break;
+      }
+    case 169: {
+      const Attribute::AttrKind AttrParam1[]= {Attribute::ImmArg};
+      AS[0] = AttributeList::get(C, 1, AttrParam1);
+      const Attribute::AttrKind AttrParam4[]= {Attribute::ImmArg};
+      AS[1] = AttributeList::get(C, 4, AttrParam4);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadNone};
+      AS[2] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 3;
+      break;
+      }
+    case 170: {
+      const Attribute::AttrKind AttrParam1[]= {Attribute::ImmArg};
+      AS[0] = AttributeList::get(C, 1, AttrParam1);
+      const Attribute::AttrKind AttrParam5[]= {Attribute::ImmArg};
+      AS[1] = AttributeList::get(C, 5, AttrParam5);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadNone};
+      AS[2] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 3;
+      break;
+      }
+    case 171: {
+      const Attribute::AttrKind AttrParam1[]= {Attribute::ImmArg};
+      AS[0] = AttributeList::get(C, 1, AttrParam1);
+      const Attribute::AttrKind AttrParam6[]= {Attribute::ImmArg};
+      AS[1] = AttributeList::get(C, 6, AttrParam6);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadNone};
+      AS[2] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 3;
+      break;
+      }
+    case 78: {
+      const Attribute::AttrKind AttrParam2[]= {Attribute::ImmArg};
+      AS[0] = AttributeList::get(C, 2, AttrParam2);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadNone};
+      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 2;
+      break;
+      }
+    case 79: {
+      const Attribute::AttrKind AttrParam2[]= {Attribute::ImmArg};
+      AS[0] = AttributeList::get(C, 2, AttrParam2);
+      const Attribute::AttrKind AttrParam3[]= {Attribute::ImmArg};
+      AS[1] = AttributeList::get(C, 3, AttrParam3);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadNone};
+      AS[2] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 3;
+      break;
+      }
+    case 214: {
+      const Attribute::AttrKind AttrParam2[]= {Attribute::ImmArg};
+      AS[0] = AttributeList::get(C, 2, AttrParam2);
+      const Attribute::AttrKind AttrParam5[]= {Attribute::ImmArg};
+      AS[1] = AttributeList::get(C, 5, AttrParam5);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadNone};
+      AS[2] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 3;
+      break;
+      }
+    case 70: {
+      const Attribute::AttrKind AttrParam3[]= {Attribute::ImmArg};
+      AS[0] = AttributeList::get(C, 3, AttrParam3);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadNone};
+      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 2;
+      break;
+      }
+    case 182: {
+      const Attribute::AttrKind AttrParam3[]= {Attribute::ImmArg};
+      AS[0] = AttributeList::get(C, 3, AttrParam3);
+      const Attribute::AttrKind AttrParam4[]= {Attribute::ImmArg};
+      AS[1] = AttributeList::get(C, 4, AttrParam4);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadNone};
+      AS[2] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 3;
+      break;
+      }
+    case 212: {
+      const Attribute::AttrKind AttrParam3[]= {Attribute::ImmArg};
+      AS[0] = AttributeList::get(C, 3, AttrParam3);
+      const Attribute::AttrKind AttrParam5[]= {Attribute::ImmArg};
+      AS[1] = AttributeList::get(C, 5, AttrParam5);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadNone};
+      AS[2] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 3;
+      break;
+      }
+    case 215: {
+      const Attribute::AttrKind AttrParam3[]= {Attribute::ImmArg};
+      AS[0] = AttributeList::get(C, 3, AttrParam3);
+      const Attribute::AttrKind AttrParam6[]= {Attribute::ImmArg};
+      AS[1] = AttributeList::get(C, 6, AttrParam6);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadNone};
+      AS[2] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 3;
+      break;
+      }
+    case 71: {
+      const Attribute::AttrKind AttrParam4[]= {Attribute::ImmArg};
+      AS[0] = AttributeList::get(C, 4, AttrParam4);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadNone};
+      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 2;
+      break;
+      }
+    case 72: {
+      const Attribute::AttrKind AttrParam4[]= {Attribute::ImmArg};
+      AS[0] = AttributeList::get(C, 4, AttrParam4);
+      const Attribute::AttrKind AttrParam5[]= {Attribute::ImmArg};
+      AS[1] = AttributeList::get(C, 5, AttrParam5);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadNone};
+      AS[2] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 3;
+      break;
+      }
+    case 213: {
+      const Attribute::AttrKind AttrParam4[]= {Attribute::ImmArg};
+      AS[0] = AttributeList::get(C, 4, AttrParam4);
+      const Attribute::AttrKind AttrParam6[]= {Attribute::ImmArg};
+      AS[1] = AttributeList::get(C, 6, AttrParam6);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadNone};
+      AS[2] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 3;
+      break;
+      }
+    case 74: {
+      const Attribute::AttrKind AttrParam5[]= {Attribute::ImmArg};
+      AS[0] = AttributeList::get(C, 5, AttrParam5);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadNone};
+      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 2;
+      break;
+      }
+    case 216: {
+      const Attribute::AttrKind AttrParam5[]= {Attribute::ImmArg};
+      AS[0] = AttributeList::get(C, 5, AttrParam5);
+      const Attribute::AttrKind AttrParam6[]= {Attribute::ImmArg};
+      AS[1] = AttributeList::get(C, 6, AttrParam6);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadNone};
+      AS[2] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 3;
+      break;
+      }
+    case 56: {
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind};
+      AS[0] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 1;
+      break;
+      }
+    case 204: {
+      const Attribute::AttrKind AttrParam1[]= {Attribute::ImmArg};
+      AS[0] = AttributeList::get(C, 1, AttrParam1);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind};
+      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 2;
+      break;
+      }
+    case 206: {
+      const Attribute::AttrKind AttrParam1[]= {Attribute::NoCapture,Attribute::ReadOnly};
+      AS[0] = AttributeList::get(C, 1, AttrParam1);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::InaccessibleMemOrArgMemOnly};
+      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 2;
+      break;
+      }
+    case 205: {
+      const Attribute::AttrKind AttrParam1[]= {Attribute::NoCapture};
+      AS[0] = AttributeList::get(C, 1, AttrParam1);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::InaccessibleMemOnly};
+      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 2;
+      break;
+      }
+    case 218: {
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WriteOnly,Attribute::ArgMemOnly};
+      AS[0] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 1;
+      break;
+      }
+    case 63: {
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind};
+      AS[0] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 1;
+      break;
+      }
+    case 156: {
+      const Attribute::AttrKind AttrParam1[]= {Attribute::ImmArg};
+      AS[0] = AttributeList::get(C, 1, AttrParam1);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind};
+      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 2;
+      break;
+      }
+    case 199: {
+      const Attribute::AttrKind AttrParam1[]= {Attribute::ImmArg};
+      AS[0] = AttributeList::get(C, 1, AttrParam1);
+      const Attribute::AttrKind AttrParam2[]= {Attribute::ImmArg};
+      AS[1] = AttributeList::get(C, 2, AttrParam2);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind};
+      AS[2] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 3;
+      break;
+      }
+    case 198: {
+      const Attribute::AttrKind AttrParam2[]= {Attribute::ImmArg};
+      AS[0] = AttributeList::get(C, 2, AttrParam2);
+      const Attribute::AttrKind AttrParam3[]= {Attribute::ImmArg};
+      AS[1] = AttributeList::get(C, 3, AttrParam3);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind};
+      AS[2] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 3;
+      break;
+      }
+    case 203: {
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::Speculatable,Attribute::ReadNone};
+      AS[0] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 1;
+      break;
+      }
+    case 164: {
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::Convergent};
+      AS[0] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 1;
+      break;
+      }
+    case 136: {
+      const Attribute::AttrKind AttrParam1[]= {Attribute::ImmArg};
+      AS[0] = AttributeList::get(C, 1, AttrParam1);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::Convergent};
+      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 2;
+      break;
+      }
+    case 137: {
+      const Attribute::AttrKind AttrParam2[]= {Attribute::ImmArg};
+      AS[0] = AttributeList::get(C, 2, AttrParam2);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::Convergent};
+      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 2;
+      break;
+      }
+    case 190: {
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::Convergent,Attribute::InaccessibleMemOnly};
+      AS[0] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 1;
+      break;
+      }
+    case 155: {
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn};
+      AS[0] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 1;
+      break;
+      }
+    case 98: {
       const Attribute::AttrKind AttrParam1[]= {Attribute::NoCapture};
       AS[0] = AttributeList::get(C, 1, AttrParam1);
       const Attribute::AttrKind AttrParam3[]= {Attribute::ImmArg};
@@ -16730,266 +23679,224 @@
       AS[2] = AttributeList::get(C, 4, AttrParam4);
       const Attribute::AttrKind AttrParam5[]= {Attribute::ImmArg};
       AS[3] = AttributeList::get(C, 5, AttrParam5);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ArgMemOnly};
-      AS[4] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
-      NumAttrs = 5;
+      const Attribute::AttrKind AttrParam6[]= {Attribute::ImmArg};
+      AS[4] = AttributeList::get(C, 6, AttrParam6);
+      const Attribute::AttrKind AttrParam7[]= {Attribute::ImmArg};
+      AS[5] = AttributeList::get(C, 7, AttrParam7);
+      const Attribute::AttrKind AttrParam8[]= {Attribute::ImmArg};
+      AS[6] = AttributeList::get(C, 8, AttrParam8);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn};
+      AS[7] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 8;
       break;
       }
-    case 136: {
-      const Attribute::AttrKind AttrParam1[]= {Attribute::NoCapture};
-      AS[0] = AttributeList::get(C, 1, AttrParam1);
+    case 107: {
       const Attribute::AttrKind AttrParam4[]= {Attribute::ImmArg};
-      AS[1] = AttributeList::get(C, 4, AttrParam4);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ArgMemOnly};
-      AS[2] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
-      NumAttrs = 3;
-      break;
-      }
-    case 137: {
-      const Attribute::AttrKind AttrParam1[]= {Attribute::NoCapture};
-      AS[0] = AttributeList::get(C, 1, AttrParam1);
+      AS[0] = AttributeList::get(C, 4, AttrParam4);
       const Attribute::AttrKind AttrParam5[]= {Attribute::ImmArg};
       AS[1] = AttributeList::get(C, 5, AttrParam5);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ArgMemOnly};
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn};
       AS[2] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
       NumAttrs = 3;
       break;
       }
-    case 25: {
-      const Attribute::AttrKind AttrParam1[]= {Attribute::ImmArg};
-      AS[0] = AttributeList::get(C, 1, AttrParam1);
-      const Attribute::AttrKind AttrParam2[]= {Attribute::NoCapture};
-      AS[1] = AttributeList::get(C, 2, AttrParam2);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ArgMemOnly};
-      AS[2] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
-      NumAttrs = 3;
-      break;
-      }
-    case 21: {
-      const Attribute::AttrKind AttrParam2[]= {Attribute::NoCapture};
-      AS[0] = AttributeList::get(C, 2, AttrParam2);
-      const Attribute::AttrKind AttrParam3[]= {Attribute::NoCapture};
-      AS[1] = AttributeList::get(C, 3, AttrParam3);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ArgMemOnly};
-      AS[2] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
-      NumAttrs = 3;
-      break;
-      }
-    case 24: {
-      const Attribute::AttrKind AttrParam2[]= {Attribute::ImmArg};
-      AS[0] = AttributeList::get(C, 2, AttrParam2);
-      const Attribute::AttrKind AttrParam3[]= {Attribute::NoCapture};
-      AS[1] = AttributeList::get(C, 3, AttrParam3);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ArgMemOnly};
-      AS[2] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
-      NumAttrs = 3;
-      break;
-      }
-    case 46: {
-      const Attribute::AttrKind AttrParam3[]= {Attribute::NoCapture};
-      AS[0] = AttributeList::get(C, 3, AttrParam3);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ArgMemOnly};
+    case 87: {
+      const Attribute::AttrKind AttrParam5[]= {Attribute::ImmArg};
+      AS[0] = AttributeList::get(C, 5, AttrParam5);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn};
       AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
       NumAttrs = 2;
       break;
       }
-    case 33: {
-      const Attribute::AttrKind AttrParam3[]= {Attribute::ImmArg};
-      AS[0] = AttributeList::get(C, 3, AttrParam3);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ArgMemOnly};
+    case 108: {
+      const Attribute::AttrKind AttrParam5[]= {Attribute::ImmArg};
+      AS[0] = AttributeList::get(C, 5, AttrParam5);
+      const Attribute::AttrKind AttrParam6[]= {Attribute::ImmArg};
+      AS[1] = AttributeList::get(C, 6, AttrParam6);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn};
+      AS[2] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 3;
+      break;
+      }
+    case 88: {
+      const Attribute::AttrKind AttrParam6[]= {Attribute::ImmArg};
+      AS[0] = AttributeList::get(C, 6, AttrParam6);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn};
+      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 2;
+      break;
+      }
+    case 109: {
+      const Attribute::AttrKind AttrParam6[]= {Attribute::ImmArg};
+      AS[0] = AttributeList::get(C, 6, AttrParam6);
+      const Attribute::AttrKind AttrParam7[]= {Attribute::ImmArg};
+      AS[1] = AttributeList::get(C, 7, AttrParam7);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn};
+      AS[2] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 3;
+      break;
+      }
+    case 157: {
+      const Attribute::AttrKind AttrParam7[]= {Attribute::ImmArg};
+      AS[0] = AttributeList::get(C, 7, AttrParam7);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn};
+      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 2;
+      break;
+      }
+    case 110: {
+      const Attribute::AttrKind AttrParam7[]= {Attribute::ImmArg};
+      AS[0] = AttributeList::get(C, 7, AttrParam7);
+      const Attribute::AttrKind AttrParam8[]= {Attribute::ImmArg};
+      AS[1] = AttributeList::get(C, 8, AttrParam8);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn};
+      AS[2] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 3;
+      break;
+      }
+    case 111: {
+      const Attribute::AttrKind AttrParam8[]= {Attribute::ImmArg};
+      AS[0] = AttributeList::get(C, 8, AttrParam8);
+      const Attribute::AttrKind AttrParam9[]= {Attribute::ImmArg};
+      AS[1] = AttributeList::get(C, 9, AttrParam9);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn};
+      AS[2] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 3;
+      break;
+      }
+    case 207: {
+      const Attribute::AttrKind AttrParam1[]= {Attribute::NoCapture,Attribute::ReadOnly};
+      AS[0] = AttributeList::get(C, 1, AttrParam1);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn,Attribute::InaccessibleMemOrArgMemOnly};
+      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 2;
+      break;
+      }
+    case 106: {
+      const Attribute::AttrKind AttrParam1[]= {Attribute::NoCapture};
+      AS[0] = AttributeList::get(C, 1, AttrParam1);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn,Attribute::ArgMemOnly};
       AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
       NumAttrs = 2;
       break;
       }
     case 47: {
-      const Attribute::AttrKind AttrParam4[]= {Attribute::NoCapture};
-      AS[0] = AttributeList::get(C, 4, AttrParam4);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ArgMemOnly};
-      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
-      NumAttrs = 2;
-      break;
-      }
-    case 127: {
-      const Attribute::AttrKind AttrParam4[]= {Attribute::ImmArg};
-      AS[0] = AttributeList::get(C, 4, AttrParam4);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ArgMemOnly};
-      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
-      NumAttrs = 2;
-      break;
-      }
-    case 48: {
-      const Attribute::AttrKind AttrParam5[]= {Attribute::NoCapture};
-      AS[0] = AttributeList::get(C, 5, AttrParam5);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ArgMemOnly};
-      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
-      NumAttrs = 2;
-      break;
-      }
-    case 49: {
-      const Attribute::AttrKind AttrParam6[]= {Attribute::NoCapture};
-      AS[0] = AttributeList::get(C, 6, AttrParam6);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ArgMemOnly};
-      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
-      NumAttrs = 2;
-      break;
-      }
-    case 16: {
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::InaccessibleMemOnly};
-      AS[0] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
-      NumAttrs = 1;
-      break;
-      }
-    case 64: {
-      const Attribute::AttrKind AttrParam1[]= {Attribute::ImmArg};
+      const Attribute::AttrKind AttrParam1[]= {Attribute::NoCapture,Attribute::WriteOnly};
       AS[0] = AttributeList::get(C, 1, AttrParam1);
-      const Attribute::AttrKind AttrParam2[]= {Attribute::ImmArg};
-      AS[1] = AttributeList::get(C, 2, AttrParam2);
-      const Attribute::AttrKind AttrParam5[]= {Attribute::ImmArg};
-      AS[2] = AttributeList::get(C, 5, AttrParam5);
-      const Attribute::AttrKind AttrParam6[]= {Attribute::ImmArg};
-      AS[3] = AttributeList::get(C, 6, AttrParam6);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::InaccessibleMemOnly};
-      AS[4] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
-      NumAttrs = 5;
-      break;
-      }
-    case 63: {
-      const Attribute::AttrKind AttrParam1[]= {Attribute::ImmArg};
-      AS[0] = AttributeList::get(C, 1, AttrParam1);
-      const Attribute::AttrKind AttrParam2[]= {Attribute::ImmArg};
-      AS[1] = AttributeList::get(C, 2, AttrParam2);
-      const Attribute::AttrKind AttrParam7[]= {Attribute::ImmArg};
-      AS[2] = AttributeList::get(C, 7, AttrParam7);
-      const Attribute::AttrKind AttrParam8[]= {Attribute::ImmArg};
-      AS[3] = AttributeList::get(C, 8, AttrParam8);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::InaccessibleMemOnly};
-      AS[4] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
-      NumAttrs = 5;
-      break;
-      }
-    case 22: {
-      const Attribute::AttrKind AttrParam3[]= {Attribute::ImmArg};
-      AS[0] = AttributeList::get(C, 3, AttrParam3);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::InaccessibleMemOnly};
-      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
-      NumAttrs = 2;
-      break;
-      }
-    case 50: {
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WriteOnly};
-      AS[0] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
-      NumAttrs = 1;
-      break;
-      }
-    case 44: {
-      const Attribute::AttrKind AttrParam1[]= {Attribute::NoCapture,Attribute::ReadOnly};
-      AS[0] = AttributeList::get(C, 1, AttrParam1);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WriteOnly};
-      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
-      NumAttrs = 2;
-      break;
-      }
-    case 45: {
       const Attribute::AttrKind AttrParam2[]= {Attribute::NoCapture,Attribute::ReadOnly};
-      AS[0] = AttributeList::get(C, 2, AttrParam2);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WriteOnly};
-      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
-      NumAttrs = 2;
+      AS[1] = AttributeList::get(C, 2, AttrParam2);
+      const Attribute::AttrKind AttrParam4[]= {Attribute::ImmArg};
+      AS[2] = AttributeList::get(C, 4, AttrParam4);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn,Attribute::ArgMemOnly};
+      AS[3] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 4;
       break;
       }
-    case 92: {
+    case 85: {
+      const Attribute::AttrKind AttrParam1[]= {Attribute::NoCapture};
+      AS[0] = AttributeList::get(C, 1, AttrParam1);
+      const Attribute::AttrKind AttrParam3[]= {Attribute::ImmArg};
+      AS[1] = AttributeList::get(C, 3, AttrParam3);
+      const Attribute::AttrKind AttrParam4[]= {Attribute::ImmArg};
+      AS[2] = AttributeList::get(C, 4, AttrParam4);
+      const Attribute::AttrKind AttrParam5[]= {Attribute::ImmArg};
+      AS[3] = AttributeList::get(C, 5, AttrParam5);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn,Attribute::ArgMemOnly};
+      AS[4] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 5;
+      break;
+      }
+    case 55: {
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn,Attribute::InaccessibleMemOnly};
+      AS[0] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 1;
+      break;
+      }
+    case 132: {
       const Attribute::AttrKind AttrParam2[]= {Attribute::ImmArg};
       AS[0] = AttributeList::get(C, 2, AttrParam2);
       const Attribute::AttrKind AttrParam5[]= {Attribute::ImmArg};
       AS[1] = AttributeList::get(C, 5, AttrParam5);
       const Attribute::AttrKind AttrParam6[]= {Attribute::ImmArg};
       AS[2] = AttributeList::get(C, 6, AttrParam6);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WriteOnly};
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn,Attribute::WriteOnly};
       AS[3] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
       NumAttrs = 4;
       break;
       }
-    case 93: {
+    case 133: {
       const Attribute::AttrKind AttrParam2[]= {Attribute::ImmArg};
       AS[0] = AttributeList::get(C, 2, AttrParam2);
       const Attribute::AttrKind AttrParam6[]= {Attribute::ImmArg};
       AS[1] = AttributeList::get(C, 6, AttrParam6);
       const Attribute::AttrKind AttrParam7[]= {Attribute::ImmArg};
       AS[2] = AttributeList::get(C, 7, AttrParam7);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WriteOnly};
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn,Attribute::WriteOnly};
       AS[3] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
       NumAttrs = 4;
       break;
       }
-    case 94: {
+    case 134: {
       const Attribute::AttrKind AttrParam2[]= {Attribute::ImmArg};
       AS[0] = AttributeList::get(C, 2, AttrParam2);
       const Attribute::AttrKind AttrParam7[]= {Attribute::ImmArg};
       AS[1] = AttributeList::get(C, 7, AttrParam7);
       const Attribute::AttrKind AttrParam8[]= {Attribute::ImmArg};
       AS[2] = AttributeList::get(C, 8, AttrParam8);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WriteOnly};
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn,Attribute::WriteOnly};
       AS[3] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
       NumAttrs = 4;
       break;
       }
-    case 95: {
+    case 135: {
       const Attribute::AttrKind AttrParam2[]= {Attribute::ImmArg};
       AS[0] = AttributeList::get(C, 2, AttrParam2);
       const Attribute::AttrKind AttrParam8[]= {Attribute::ImmArg};
       AS[1] = AttributeList::get(C, 8, AttrParam8);
       const Attribute::AttrKind AttrParam9[]= {Attribute::ImmArg};
       AS[2] = AttributeList::get(C, 9, AttrParam9);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WriteOnly};
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn,Attribute::WriteOnly};
       AS[3] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
       NumAttrs = 4;
       break;
       }
-    case 128: {
-      const Attribute::AttrKind AttrParam4[]= {Attribute::ImmArg};
-      AS[0] = AttributeList::get(C, 4, AttrParam4);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WriteOnly};
-      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
-      NumAttrs = 2;
-      break;
-      }
-    case 100: {
+    case 149: {
       const Attribute::AttrKind AttrParam5[]= {Attribute::ImmArg};
       AS[0] = AttributeList::get(C, 5, AttrParam5);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WriteOnly};
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn,Attribute::WriteOnly};
       AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
       NumAttrs = 2;
       break;
       }
-    case 55: {
+    case 91: {
       const Attribute::AttrKind AttrParam5[]= {Attribute::ImmArg};
       AS[0] = AttributeList::get(C, 5, AttrParam5);
       const Attribute::AttrKind AttrParam6[]= {Attribute::ImmArg};
       AS[1] = AttributeList::get(C, 6, AttrParam6);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WriteOnly};
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn,Attribute::WriteOnly};
       AS[2] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
       NumAttrs = 3;
       break;
       }
-    case 106: {
+    case 159: {
       const Attribute::AttrKind AttrParam6[]= {Attribute::ImmArg};
       AS[0] = AttributeList::get(C, 6, AttrParam6);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WriteOnly};
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn,Attribute::WriteOnly};
       AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
       NumAttrs = 2;
       break;
       }
-    case 108: {
+    case 161: {
       const Attribute::AttrKind AttrParam6[]= {Attribute::ImmArg};
       AS[0] = AttributeList::get(C, 6, AttrParam6);
       const Attribute::AttrKind AttrParam7[]= {Attribute::ImmArg};
       AS[1] = AttributeList::get(C, 7, AttrParam7);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WriteOnly};
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn,Attribute::WriteOnly};
       AS[2] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
       NumAttrs = 3;
       break;
       }
-    case 110: {
+    case 163: {
       const Attribute::AttrKind AttrParam6[]= {Attribute::ImmArg};
       AS[0] = AttributeList::get(C, 6, AttrParam6);
       const Attribute::AttrKind AttrParam7[]= {Attribute::ImmArg};
@@ -17000,64 +23907,74 @@
       AS[3] = AttributeList::get(C, 9, AttrParam9);
       const Attribute::AttrKind AttrParam10[]= {Attribute::ImmArg};
       AS[4] = AttributeList::get(C, 10, AttrParam10);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WriteOnly};
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn,Attribute::WriteOnly};
       AS[5] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
       NumAttrs = 6;
       break;
       }
-    case 135: {
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WriteOnly,Attribute::ArgMemOnly};
-      AS[0] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
-      NumAttrs = 1;
-      break;
-      }
-    case 134: {
+    case 51: {
       const Attribute::AttrKind AttrParam1[]= {Attribute::NoCapture,Attribute::WriteOnly};
       AS[0] = AttributeList::get(C, 1, AttrParam1);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WriteOnly,Attribute::ArgMemOnly};
-      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
-      NumAttrs = 2;
+      const Attribute::AttrKind AttrParam4[]= {Attribute::ImmArg};
+      AS[1] = AttributeList::get(C, 4, AttrParam4);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn,Attribute::WriteOnly,Attribute::ArgMemOnly};
+      AS[2] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 3;
       break;
       }
-    case 18: {
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadOnly};
-      AS[0] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
-      NumAttrs = 1;
-      break;
-      }
-    case 131: {
+    case 103: {
       const Attribute::AttrKind AttrParam1[]= {Attribute::ImmArg};
       AS[0] = AttributeList::get(C, 1, AttrParam1);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadOnly};
-      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
-      NumAttrs = 2;
+      const Attribute::AttrKind AttrParam2[]= {Attribute::ImmArg};
+      AS[1] = AttributeList::get(C, 2, AttrParam2);
+      const Attribute::AttrKind AttrParam5[]= {Attribute::ImmArg};
+      AS[2] = AttributeList::get(C, 5, AttrParam5);
+      const Attribute::AttrKind AttrParam6[]= {Attribute::ImmArg};
+      AS[3] = AttributeList::get(C, 6, AttrParam6);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn,Attribute::WriteOnly,Attribute::InaccessibleMemOnly};
+      AS[4] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 5;
       break;
       }
-    case 82: {
+    case 102: {
+      const Attribute::AttrKind AttrParam1[]= {Attribute::ImmArg};
+      AS[0] = AttributeList::get(C, 1, AttrParam1);
+      const Attribute::AttrKind AttrParam2[]= {Attribute::ImmArg};
+      AS[1] = AttributeList::get(C, 2, AttrParam2);
+      const Attribute::AttrKind AttrParam7[]= {Attribute::ImmArg};
+      AS[2] = AttributeList::get(C, 7, AttrParam7);
+      const Attribute::AttrKind AttrParam8[]= {Attribute::ImmArg};
+      AS[3] = AttributeList::get(C, 8, AttrParam8);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn,Attribute::WriteOnly,Attribute::InaccessibleMemOnly};
+      AS[4] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 5;
+      break;
+      }
+    case 122: {
       const Attribute::AttrKind AttrParam1[]= {Attribute::ImmArg};
       AS[0] = AttributeList::get(C, 1, AttrParam1);
       const Attribute::AttrKind AttrParam4[]= {Attribute::ImmArg};
       AS[1] = AttributeList::get(C, 4, AttrParam4);
       const Attribute::AttrKind AttrParam5[]= {Attribute::ImmArg};
       AS[2] = AttributeList::get(C, 5, AttrParam5);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadOnly};
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn,Attribute::ReadOnly};
       AS[3] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
       NumAttrs = 4;
       break;
       }
-    case 83: {
+    case 123: {
       const Attribute::AttrKind AttrParam1[]= {Attribute::ImmArg};
       AS[0] = AttributeList::get(C, 1, AttrParam1);
       const Attribute::AttrKind AttrParam5[]= {Attribute::ImmArg};
       AS[1] = AttributeList::get(C, 5, AttrParam5);
       const Attribute::AttrKind AttrParam6[]= {Attribute::ImmArg};
       AS[2] = AttributeList::get(C, 6, AttrParam6);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadOnly};
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn,Attribute::ReadOnly};
       AS[3] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
       NumAttrs = 4;
       break;
       }
-    case 86: {
+    case 126: {
       const Attribute::AttrKind AttrParam1[]= {Attribute::ImmArg};
       AS[0] = AttributeList::get(C, 1, AttrParam1);
       const Attribute::AttrKind AttrParam5[]= {Attribute::ImmArg};
@@ -17066,24 +23983,24 @@
       AS[2] = AttributeList::get(C, 6, AttrParam6);
       const Attribute::AttrKind AttrParam7[]= {Attribute::ImmArg};
       AS[3] = AttributeList::get(C, 7, AttrParam7);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadOnly};
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn,Attribute::ReadOnly};
       AS[4] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
       NumAttrs = 5;
       break;
       }
-    case 84: {
+    case 124: {
       const Attribute::AttrKind AttrParam1[]= {Attribute::ImmArg};
       AS[0] = AttributeList::get(C, 1, AttrParam1);
       const Attribute::AttrKind AttrParam6[]= {Attribute::ImmArg};
       AS[1] = AttributeList::get(C, 6, AttrParam6);
       const Attribute::AttrKind AttrParam7[]= {Attribute::ImmArg};
       AS[2] = AttributeList::get(C, 7, AttrParam7);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadOnly};
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn,Attribute::ReadOnly};
       AS[3] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
       NumAttrs = 4;
       break;
       }
-    case 72: {
+    case 112: {
       const Attribute::AttrKind AttrParam1[]= {Attribute::ImmArg};
       AS[0] = AttributeList::get(C, 1, AttrParam1);
       const Attribute::AttrKind AttrParam6[]= {Attribute::ImmArg};
@@ -17092,24 +24009,24 @@
       AS[2] = AttributeList::get(C, 7, AttrParam7);
       const Attribute::AttrKind AttrParam8[]= {Attribute::ImmArg};
       AS[3] = AttributeList::get(C, 8, AttrParam8);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadOnly};
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn,Attribute::ReadOnly};
       AS[4] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
       NumAttrs = 5;
       break;
       }
-    case 85: {
+    case 125: {
       const Attribute::AttrKind AttrParam1[]= {Attribute::ImmArg};
       AS[0] = AttributeList::get(C, 1, AttrParam1);
       const Attribute::AttrKind AttrParam7[]= {Attribute::ImmArg};
       AS[1] = AttributeList::get(C, 7, AttrParam7);
       const Attribute::AttrKind AttrParam8[]= {Attribute::ImmArg};
       AS[2] = AttributeList::get(C, 8, AttrParam8);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadOnly};
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn,Attribute::ReadOnly};
       AS[3] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
       NumAttrs = 4;
       break;
       }
-    case 73: {
+    case 113: {
       const Attribute::AttrKind AttrParam1[]= {Attribute::ImmArg};
       AS[0] = AttributeList::get(C, 1, AttrParam1);
       const Attribute::AttrKind AttrParam7[]= {Attribute::ImmArg};
@@ -17118,12 +24035,12 @@
       AS[2] = AttributeList::get(C, 8, AttrParam8);
       const Attribute::AttrKind AttrParam9[]= {Attribute::ImmArg};
       AS[3] = AttributeList::get(C, 9, AttrParam9);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadOnly};
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn,Attribute::ReadOnly};
       AS[4] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
       NumAttrs = 5;
       break;
       }
-    case 74: {
+    case 114: {
       const Attribute::AttrKind AttrParam1[]= {Attribute::ImmArg};
       AS[0] = AttributeList::get(C, 1, AttrParam1);
       const Attribute::AttrKind AttrParam8[]= {Attribute::ImmArg};
@@ -17132,12 +24049,12 @@
       AS[2] = AttributeList::get(C, 9, AttrParam9);
       const Attribute::AttrKind AttrParam10[]= {Attribute::ImmArg};
       AS[3] = AttributeList::get(C, 10, AttrParam10);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadOnly};
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn,Attribute::ReadOnly};
       AS[4] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
       NumAttrs = 5;
       break;
       }
-    case 75: {
+    case 115: {
       const Attribute::AttrKind AttrParam1[]= {Attribute::ImmArg};
       AS[0] = AttributeList::get(C, 1, AttrParam1);
       const Attribute::AttrKind AttrParam9[]= {Attribute::ImmArg};
@@ -17146,12 +24063,12 @@
       AS[2] = AttributeList::get(C, 10, AttrParam10);
       const Attribute::AttrKind AttrParam11[]= {Attribute::ImmArg};
       AS[3] = AttributeList::get(C, 11, AttrParam11);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadOnly};
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn,Attribute::ReadOnly};
       AS[4] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
       NumAttrs = 5;
       break;
       }
-    case 76: {
+    case 116: {
       const Attribute::AttrKind AttrParam1[]= {Attribute::ImmArg};
       AS[0] = AttributeList::get(C, 1, AttrParam1);
       const Attribute::AttrKind AttrParam10[]= {Attribute::ImmArg};
@@ -17160,12 +24077,12 @@
       AS[2] = AttributeList::get(C, 11, AttrParam11);
       const Attribute::AttrKind AttrParam12[]= {Attribute::ImmArg};
       AS[3] = AttributeList::get(C, 12, AttrParam12);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadOnly};
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn,Attribute::ReadOnly};
       AS[4] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
       NumAttrs = 5;
       break;
       }
-    case 77: {
+    case 117: {
       const Attribute::AttrKind AttrParam1[]= {Attribute::ImmArg};
       AS[0] = AttributeList::get(C, 1, AttrParam1);
       const Attribute::AttrKind AttrParam11[]= {Attribute::ImmArg};
@@ -17174,12 +24091,12 @@
       AS[2] = AttributeList::get(C, 12, AttrParam12);
       const Attribute::AttrKind AttrParam13[]= {Attribute::ImmArg};
       AS[3] = AttributeList::get(C, 13, AttrParam13);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadOnly};
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn,Attribute::ReadOnly};
       AS[4] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
       NumAttrs = 5;
       break;
       }
-    case 87: {
+    case 127: {
       const Attribute::AttrKind AttrParam1[]= {Attribute::ImmArg};
       AS[0] = AttributeList::get(C, 1, AttrParam1);
       const Attribute::AttrKind AttrParam12[]= {Attribute::ImmArg};
@@ -17188,12 +24105,12 @@
       AS[2] = AttributeList::get(C, 13, AttrParam13);
       const Attribute::AttrKind AttrParam14[]= {Attribute::ImmArg};
       AS[3] = AttributeList::get(C, 14, AttrParam14);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadOnly};
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn,Attribute::ReadOnly};
       AS[4] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
       NumAttrs = 5;
       break;
       }
-    case 89: {
+    case 129: {
       const Attribute::AttrKind AttrParam1[]= {Attribute::ImmArg};
       AS[0] = AttributeList::get(C, 1, AttrParam1);
       const Attribute::AttrKind AttrParam13[]= {Attribute::ImmArg};
@@ -17202,12 +24119,12 @@
       AS[2] = AttributeList::get(C, 14, AttrParam14);
       const Attribute::AttrKind AttrParam15[]= {Attribute::ImmArg};
       AS[3] = AttributeList::get(C, 15, AttrParam15);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadOnly};
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn,Attribute::ReadOnly};
       AS[4] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
       NumAttrs = 5;
       break;
       }
-    case 88: {
+    case 128: {
       const Attribute::AttrKind AttrParam1[]= {Attribute::ImmArg};
       AS[0] = AttributeList::get(C, 1, AttrParam1);
       const Attribute::AttrKind AttrParam14[]= {Attribute::ImmArg};
@@ -17216,12 +24133,12 @@
       AS[2] = AttributeList::get(C, 15, AttrParam15);
       const Attribute::AttrKind AttrParam16[]= {Attribute::ImmArg};
       AS[3] = AttributeList::get(C, 16, AttrParam16);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadOnly};
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn,Attribute::ReadOnly};
       AS[4] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
       NumAttrs = 5;
       break;
       }
-    case 90: {
+    case 130: {
       const Attribute::AttrKind AttrParam1[]= {Attribute::ImmArg};
       AS[0] = AttributeList::get(C, 1, AttrParam1);
       const Attribute::AttrKind AttrParam15[]= {Attribute::ImmArg};
@@ -17230,12 +24147,12 @@
       AS[2] = AttributeList::get(C, 16, AttrParam16);
       const Attribute::AttrKind AttrParam17[]= {Attribute::ImmArg};
       AS[3] = AttributeList::get(C, 17, AttrParam17);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadOnly};
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn,Attribute::ReadOnly};
       AS[4] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
       NumAttrs = 5;
       break;
       }
-    case 91: {
+    case 131: {
       const Attribute::AttrKind AttrParam1[]= {Attribute::ImmArg};
       AS[0] = AttributeList::get(C, 1, AttrParam1);
       const Attribute::AttrKind AttrParam16[]= {Attribute::ImmArg};
@@ -17244,66 +24161,48 @@
       AS[2] = AttributeList::get(C, 17, AttrParam17);
       const Attribute::AttrKind AttrParam18[]= {Attribute::ImmArg};
       AS[3] = AttributeList::get(C, 18, AttrParam18);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadOnly};
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn,Attribute::ReadOnly};
       AS[4] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
       NumAttrs = 5;
       break;
       }
-    case 30: {
-      const Attribute::AttrKind AttrParam2[]= {Attribute::ImmArg};
-      AS[0] = AttributeList::get(C, 2, AttrParam2);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadOnly};
-      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
-      NumAttrs = 2;
-      break;
-      }
-    case 17: {
-      const Attribute::AttrKind AttrParam2[]= {Attribute::ImmArg};
-      AS[0] = AttributeList::get(C, 2, AttrParam2);
-      const Attribute::AttrKind AttrParam3[]= {Attribute::ImmArg};
-      AS[1] = AttributeList::get(C, 3, AttrParam3);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadOnly};
-      AS[2] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
-      NumAttrs = 3;
-      break;
-      }
-    case 99: {
+    case 148: {
       const Attribute::AttrKind AttrParam4[]= {Attribute::ImmArg};
       AS[0] = AttributeList::get(C, 4, AttrParam4);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadOnly};
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn,Attribute::ReadOnly};
       AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
       NumAttrs = 2;
       break;
       }
-    case 54: {
+    case 90: {
       const Attribute::AttrKind AttrParam4[]= {Attribute::ImmArg};
       AS[0] = AttributeList::get(C, 4, AttrParam4);
       const Attribute::AttrKind AttrParam5[]= {Attribute::ImmArg};
       AS[1] = AttributeList::get(C, 5, AttrParam5);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadOnly};
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn,Attribute::ReadOnly};
       AS[2] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
       NumAttrs = 3;
       break;
       }
-    case 105: {
+    case 158: {
       const Attribute::AttrKind AttrParam5[]= {Attribute::ImmArg};
       AS[0] = AttributeList::get(C, 5, AttrParam5);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadOnly};
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn,Attribute::ReadOnly};
       AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
       NumAttrs = 2;
       break;
       }
-    case 107: {
+    case 160: {
       const Attribute::AttrKind AttrParam5[]= {Attribute::ImmArg};
       AS[0] = AttributeList::get(C, 5, AttrParam5);
       const Attribute::AttrKind AttrParam6[]= {Attribute::ImmArg};
       AS[1] = AttributeList::get(C, 6, AttrParam6);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadOnly};
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn,Attribute::ReadOnly};
       AS[2] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
       NumAttrs = 3;
       break;
       }
-    case 109: {
+    case 162: {
       const Attribute::AttrKind AttrParam5[]= {Attribute::ImmArg};
       AS[0] = AttributeList::get(C, 5, AttrParam5);
       const Attribute::AttrKind AttrParam6[]= {Attribute::ImmArg};
@@ -17314,144 +24213,36 @@
       AS[3] = AttributeList::get(C, 8, AttrParam8);
       const Attribute::AttrKind AttrParam9[]= {Attribute::ImmArg};
       AS[4] = AttributeList::get(C, 9, AttrParam9);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadOnly};
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn,Attribute::ReadOnly};
       AS[5] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
       NumAttrs = 6;
       break;
       }
-    case 2: {
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadOnly,Attribute::ArgMemOnly};
+    case 153: {
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn,Attribute::ReadOnly,Attribute::InaccessibleMemOnly};
       AS[0] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
       NumAttrs = 1;
       break;
       }
-    case 133: {
-      const Attribute::AttrKind AttrParam1[]= {Attribute::NoCapture};
-      AS[0] = AttributeList::get(C, 1, AttrParam1);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadOnly,Attribute::ArgMemOnly};
-      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
-      NumAttrs = 2;
-      break;
-      }
-    case 13: {
-      const Attribute::AttrKind AttrParam1[]= {Attribute::NoCapture,Attribute::ReadOnly};
-      AS[0] = AttributeList::get(C, 1, AttrParam1);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadOnly,Attribute::ArgMemOnly};
-      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
-      NumAttrs = 2;
-      break;
-      }
-    case 9: {
-      const Attribute::AttrKind AttrParam2[]= {Attribute::NoCapture,Attribute::ReadOnly};
-      AS[0] = AttributeList::get(C, 2, AttrParam2);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadOnly,Attribute::ArgMemOnly};
-      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
-      NumAttrs = 2;
-      break;
-      }
-    case 10: {
-      const Attribute::AttrKind AttrParam2[]= {Attribute::ReadNone};
-      AS[0] = AttributeList::get(C, 2, AttrParam2);
-      const Attribute::AttrKind AttrParam3[]= {Attribute::NoCapture,Attribute::ReadOnly};
-      AS[1] = AttributeList::get(C, 3, AttrParam3);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadOnly,Attribute::ArgMemOnly};
-      AS[2] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
-      NumAttrs = 3;
-      break;
-      }
-    case 31: {
-      const Attribute::AttrKind AttrParam2[]= {Attribute::ImmArg};
-      AS[0] = AttributeList::get(C, 2, AttrParam2);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadOnly,Attribute::ArgMemOnly};
-      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
-      NumAttrs = 2;
-      break;
-      }
-    case 102: {
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadOnly,Attribute::InaccessibleMemOnly};
+    case 144: {
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn,Attribute::ReadNone};
       AS[0] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
       NumAttrs = 1;
       break;
       }
-    case 114: {
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind};
-      AS[0] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
-      NumAttrs = 1;
-      break;
-      }
-    case 1: {
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadNone};
-      AS[0] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
-      NumAttrs = 1;
-      break;
-      }
-    case 12: {
-      const Attribute::AttrKind AttrParam1[]= {Attribute::NoCapture};
-      AS[0] = AttributeList::get(C, 1, AttrParam1);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadNone};
-      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
-      NumAttrs = 2;
-      break;
-      }
-    case 42: {
-      const Attribute::AttrKind AttrParam1[]= {Attribute::Returned};
-      AS[0] = AttributeList::get(C, 1, AttrParam1);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadNone};
-      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
-      NumAttrs = 2;
-      break;
-      }
-    case 11: {
-      const Attribute::AttrKind AttrParam1[]= {Attribute::ReadNone};
-      AS[0] = AttributeList::get(C, 1, AttrParam1);
-      const Attribute::AttrKind AttrParam2[]= {Attribute::ReadNone};
-      AS[1] = AttributeList::get(C, 2, AttrParam2);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadNone};
-      AS[2] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
-      NumAttrs = 3;
-      break;
-      }
-    case 20: {
-      const Attribute::AttrKind AttrParam1[]= {Attribute::ImmArg};
-      AS[0] = AttributeList::get(C, 1, AttrParam1);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadNone};
-      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
-      NumAttrs = 2;
-      break;
-      }
-    case 120: {
-      const Attribute::AttrKind AttrParam1[]= {Attribute::ImmArg};
-      AS[0] = AttributeList::get(C, 1, AttrParam1);
-      const Attribute::AttrKind AttrParam2[]= {Attribute::ImmArg};
-      AS[1] = AttributeList::get(C, 2, AttrParam2);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadNone};
-      AS[2] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
-      NumAttrs = 3;
-      break;
-      }
-    case 123: {
-      const Attribute::AttrKind AttrParam1[]= {Attribute::ImmArg};
-      AS[0] = AttributeList::get(C, 1, AttrParam1);
-      const Attribute::AttrKind AttrParam3[]= {Attribute::ImmArg};
-      AS[1] = AttributeList::get(C, 3, AttrParam3);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadNone};
-      AS[2] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
-      NumAttrs = 3;
-      break;
-      }
-    case 81: {
+    case 121: {
       const Attribute::AttrKind AttrParam1[]= {Attribute::ImmArg};
       AS[0] = AttributeList::get(C, 1, AttrParam1);
       const Attribute::AttrKind AttrParam4[]= {Attribute::ImmArg};
       AS[1] = AttributeList::get(C, 4, AttrParam4);
       const Attribute::AttrKind AttrParam5[]= {Attribute::ImmArg};
       AS[2] = AttributeList::get(C, 5, AttrParam5);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadNone};
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn,Attribute::ReadNone};
       AS[3] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
       NumAttrs = 4;
       break;
       }
-    case 78: {
+    case 118: {
       const Attribute::AttrKind AttrParam1[]= {Attribute::ImmArg};
       AS[0] = AttributeList::get(C, 1, AttrParam1);
       const Attribute::AttrKind AttrParam5[]= {Attribute::ImmArg};
@@ -17460,12 +24251,12 @@
       AS[2] = AttributeList::get(C, 6, AttrParam6);
       const Attribute::AttrKind AttrParam7[]= {Attribute::ImmArg};
       AS[3] = AttributeList::get(C, 7, AttrParam7);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadNone};
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn,Attribute::ReadNone};
       AS[4] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
       NumAttrs = 5;
       break;
       }
-    case 79: {
+    case 119: {
       const Attribute::AttrKind AttrParam1[]= {Attribute::ImmArg};
       AS[0] = AttributeList::get(C, 1, AttrParam1);
       const Attribute::AttrKind AttrParam6[]= {Attribute::ImmArg};
@@ -17474,12 +24265,12 @@
       AS[2] = AttributeList::get(C, 7, AttrParam7);
       const Attribute::AttrKind AttrParam8[]= {Attribute::ImmArg};
       AS[3] = AttributeList::get(C, 8, AttrParam8);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadNone};
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn,Attribute::ReadNone};
       AS[4] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
       NumAttrs = 5;
       break;
       }
-    case 80: {
+    case 120: {
       const Attribute::AttrKind AttrParam1[]= {Attribute::ImmArg};
       AS[0] = AttributeList::get(C, 1, AttrParam1);
       const Attribute::AttrKind AttrParam7[]= {Attribute::ImmArg};
@@ -17488,266 +24279,179 @@
       AS[2] = AttributeList::get(C, 8, AttrParam8);
       const Attribute::AttrKind AttrParam9[]= {Attribute::ImmArg};
       AS[3] = AttributeList::get(C, 9, AttrParam9);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadNone};
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn,Attribute::ReadNone};
       AS[4] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
       NumAttrs = 5;
       break;
       }
-    case 40: {
-      const Attribute::AttrKind AttrParam2[]= {Attribute::ImmArg};
-      AS[0] = AttributeList::get(C, 2, AttrParam2);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadNone};
-      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
-      NumAttrs = 2;
-      break;
-      }
-    case 39: {
-      const Attribute::AttrKind AttrParam2[]= {Attribute::ImmArg};
-      AS[0] = AttributeList::get(C, 2, AttrParam2);
-      const Attribute::AttrKind AttrParam3[]= {Attribute::ImmArg};
-      AS[1] = AttributeList::get(C, 3, AttrParam3);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadNone};
-      AS[2] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
-      NumAttrs = 3;
-      break;
-      }
-    case 150: {
-      const Attribute::AttrKind AttrParam2[]= {Attribute::ImmArg};
-      AS[0] = AttributeList::get(C, 2, AttrParam2);
-      const Attribute::AttrKind AttrParam5[]= {Attribute::ImmArg};
-      AS[1] = AttributeList::get(C, 5, AttrParam5);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadNone};
-      AS[2] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
-      NumAttrs = 3;
-      break;
-      }
-    case 27: {
-      const Attribute::AttrKind AttrParam3[]= {Attribute::ImmArg};
-      AS[0] = AttributeList::get(C, 3, AttrParam3);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadNone};
-      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
-      NumAttrs = 2;
-      break;
-      }
-    case 124: {
-      const Attribute::AttrKind AttrParam3[]= {Attribute::ImmArg};
-      AS[0] = AttributeList::get(C, 3, AttrParam3);
-      const Attribute::AttrKind AttrParam4[]= {Attribute::ImmArg};
-      AS[1] = AttributeList::get(C, 4, AttrParam4);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadNone};
-      AS[2] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
-      NumAttrs = 3;
-      break;
-      }
-    case 148: {
-      const Attribute::AttrKind AttrParam3[]= {Attribute::ImmArg};
-      AS[0] = AttributeList::get(C, 3, AttrParam3);
-      const Attribute::AttrKind AttrParam5[]= {Attribute::ImmArg};
-      AS[1] = AttributeList::get(C, 5, AttrParam5);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadNone};
-      AS[2] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
-      NumAttrs = 3;
-      break;
-      }
     case 151: {
       const Attribute::AttrKind AttrParam3[]= {Attribute::ImmArg};
       AS[0] = AttributeList::get(C, 3, AttrParam3);
-      const Attribute::AttrKind AttrParam6[]= {Attribute::ImmArg};
-      AS[1] = AttributeList::get(C, 6, AttrParam6);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadNone};
-      AS[2] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
-      NumAttrs = 3;
-      break;
-      }
-    case 125: {
-      const Attribute::AttrKind AttrParam4[]= {Attribute::ImmArg};
-      AS[0] = AttributeList::get(C, 4, AttrParam4);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadNone};
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn,Attribute::ReadNone};
       AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
       NumAttrs = 2;
       break;
       }
-    case 149: {
-      const Attribute::AttrKind AttrParam4[]= {Attribute::ImmArg};
-      AS[0] = AttributeList::get(C, 4, AttrParam4);
-      const Attribute::AttrKind AttrParam6[]= {Attribute::ImmArg};
-      AS[1] = AttributeList::get(C, 6, AttrParam6);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadNone};
-      AS[2] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
-      NumAttrs = 3;
-      break;
-      }
-    case 147: {
-      const Attribute::AttrKind AttrParam5[]= {Attribute::ImmArg};
-      AS[0] = AttributeList::get(C, 5, AttrParam5);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadNone};
-      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
-      NumAttrs = 2;
-      break;
-      }
-    case 152: {
-      const Attribute::AttrKind AttrParam5[]= {Attribute::ImmArg};
-      AS[0] = AttributeList::get(C, 5, AttrParam5);
-      const Attribute::AttrKind AttrParam6[]= {Attribute::ImmArg};
-      AS[1] = AttributeList::get(C, 6, AttrParam6);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::ReadNone};
-      AS[2] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
-      NumAttrs = 3;
-      break;
-      }
-    case 143: {
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind};
+    case 92: {
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn};
       AS[0] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
       NumAttrs = 1;
       break;
       }
-    case 141: {
-      const Attribute::AttrKind AttrParam1[]= {Attribute::NoCapture,Attribute::ReadOnly};
+    case 152: {
+      const Attribute::AttrKind AttrParam1[]= {Attribute::ImmArg};
       AS[0] = AttributeList::get(C, 1, AttrParam1);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::InaccessibleMemOrArgMemOnly};
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn};
       AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
       NumAttrs = 2;
       break;
       }
-    case 140: {
+    case 154: {
+      const Attribute::AttrKind AttrParam1[]= {Attribute::ImmArg};
+      AS[0] = AttributeList::get(C, 1, AttrParam1);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn,Attribute::Speculatable,Attribute::ReadOnly,Attribute::InaccessibleMemOnly};
+      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 2;
+      break;
+      }
+    case 84: {
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn,Attribute::Speculatable,Attribute::ReadNone};
+      AS[0] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 1;
+      break;
+      }
+    case 93: {
+      const Attribute::AttrKind AttrParam0[]= {Attribute::Alignment};
+      const uint64_t AttrValParam0[]= {4};
+      AS[0] = AttributeList::get(C, 0, AttrParam0, AttrValParam0);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn,Attribute::Speculatable,Attribute::ReadNone};
+      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 2;
+      break;
+      }
+    case 143: {
       const Attribute::AttrKind AttrParam1[]= {Attribute::NoCapture};
       AS[0] = AttributeList::get(C, 1, AttrParam1);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::InaccessibleMemOnly};
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn,Attribute::Speculatable,Attribute::ReadNone};
       AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
       NumAttrs = 2;
       break;
       }
-    case 144: {
+    case 138: {
       const Attribute::AttrKind AttrParam1[]= {Attribute::ImmArg};
       AS[0] = AttributeList::get(C, 1, AttrParam1);
       const Attribute::AttrKind AttrParam2[]= {Attribute::ImmArg};
       AS[1] = AttributeList::get(C, 2, AttrParam2);
-      const Attribute::AttrKind AttrParam3[]= {Attribute::WriteOnly};
+      const Attribute::AttrKind AttrParam3[]= {Attribute::ImmArg};
       AS[2] = AttributeList::get(C, 3, AttrParam3);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WriteOnly,Attribute::InaccessibleMemOrArgMemOnly};
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn,Attribute::Speculatable,Attribute::ReadNone};
       AS[3] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
       NumAttrs = 4;
       break;
       }
-    case 126: {
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WriteOnly,Attribute::ArgMemOnly};
-      AS[0] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
-      NumAttrs = 1;
-      break;
-      }
-    case 153: {
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind};
-      AS[0] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
-      NumAttrs = 1;
-      break;
-      }
-    case 26: {
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::Speculatable,Attribute::InaccessibleMemOnly};
-      AS[0] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
-      NumAttrs = 1;
-      break;
-      }
-    case 103: {
-      const Attribute::AttrKind AttrParam1[]= {Attribute::ImmArg};
-      AS[0] = AttributeList::get(C, 1, AttrParam1);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::Speculatable,Attribute::ReadOnly,Attribute::InaccessibleMemOnly};
-      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
-      NumAttrs = 2;
-      break;
-      }
-    case 4: {
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::Speculatable,Attribute::ReadNone};
-      AS[0] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
-      NumAttrs = 1;
-      break;
-      }
-    case 14: {
+    case 139: {
       const Attribute::AttrKind AttrParam2[]= {Attribute::ImmArg};
       AS[0] = AttributeList::get(C, 2, AttrParam2);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::Speculatable,Attribute::ReadNone};
-      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
-      NumAttrs = 2;
+      const Attribute::AttrKind AttrParam3[]= {Attribute::ImmArg};
+      AS[1] = AttributeList::get(C, 3, AttrParam3);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn,Attribute::Speculatable,Attribute::ReadNone};
+      AS[2] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 3;
       break;
       }
-    case 37: {
+    case 140: {
       const Attribute::AttrKind AttrParam2[]= {Attribute::ImmArg};
       AS[0] = AttributeList::get(C, 2, AttrParam2);
       const Attribute::AttrKind AttrParam3[]= {Attribute::ImmArg};
       AS[1] = AttributeList::get(C, 3, AttrParam3);
       const Attribute::AttrKind AttrParam4[]= {Attribute::ImmArg};
       AS[2] = AttributeList::get(C, 4, AttrParam4);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::Speculatable,Attribute::ReadNone};
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn,Attribute::Speculatable,Attribute::ReadNone};
       AS[3] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
       NumAttrs = 4;
       break;
       }
-    case 41: {
+    case 94: {
       const Attribute::AttrKind AttrParam3[]= {Attribute::ImmArg};
       AS[0] = AttributeList::get(C, 3, AttrParam3);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::Speculatable,Attribute::ReadNone};
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn,Attribute::Speculatable,Attribute::ReadNone};
       AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
       NumAttrs = 2;
       break;
       }
-    case 66: {
+    case 141: {
+      const Attribute::AttrKind AttrParam3[]= {Attribute::ImmArg};
+      AS[0] = AttributeList::get(C, 3, AttrParam3);
       const Attribute::AttrKind AttrParam4[]= {Attribute::ImmArg};
-      AS[0] = AttributeList::get(C, 4, AttrParam4);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::Speculatable,Attribute::ReadNone};
-      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
-      NumAttrs = 2;
-      break;
-      }
-    case 62: {
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::Convergent};
-      AS[0] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
-      NumAttrs = 1;
-      break;
-      }
-    case 96: {
-      const Attribute::AttrKind AttrParam1[]= {Attribute::ImmArg};
-      AS[0] = AttributeList::get(C, 1, AttrParam1);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::Convergent};
-      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
-      NumAttrs = 2;
-      break;
-      }
-    case 56: {
-      const Attribute::AttrKind AttrParam1[]= {Attribute::NoCapture};
-      AS[0] = AttributeList::get(C, 1, AttrParam1);
-      const Attribute::AttrKind AttrParam2[]= {Attribute::ImmArg};
-      AS[1] = AttributeList::get(C, 2, AttrParam2);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::Convergent,Attribute::ArgMemOnly};
+      AS[1] = AttributeList::get(C, 4, AttrParam4);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn,Attribute::Speculatable,Attribute::ReadNone};
       AS[2] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
       NumAttrs = 3;
       break;
       }
-    case 58: {
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::Convergent,Attribute::InaccessibleMemOnly};
-      AS[0] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
-      NumAttrs = 1;
+    case 142: {
+      const Attribute::AttrKind AttrParam3[]= {Attribute::ImmArg};
+      AS[0] = AttributeList::get(C, 3, AttrParam3);
+      const Attribute::AttrKind AttrParam4[]= {Attribute::ImmArg};
+      AS[1] = AttributeList::get(C, 4, AttrParam4);
+      const Attribute::AttrKind AttrParam5[]= {Attribute::ImmArg};
+      AS[2] = AttributeList::get(C, 5, AttrParam5);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn,Attribute::Speculatable,Attribute::ReadNone};
+      AS[3] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 4;
       break;
       }
-    case 59: {
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::Convergent,Attribute::WriteOnly,Attribute::InaccessibleMemOnly};
-      AS[0] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
-      NumAttrs = 1;
-      break;
-      }
-    case 57: {
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::Convergent,Attribute::ReadNone};
-      AS[0] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
-      NumAttrs = 1;
-      break;
-      }
-    case 61: {
-      const Attribute::AttrKind AttrParam2[]= {Attribute::ImmArg};
-      AS[0] = AttributeList::get(C, 2, AttrParam2);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::Convergent,Attribute::ReadNone};
+    case 105: {
+      const Attribute::AttrKind AttrParam4[]= {Attribute::ImmArg};
+      AS[0] = AttributeList::get(C, 4, AttrParam4);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn,Attribute::Speculatable,Attribute::ReadNone};
       AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
       NumAttrs = 2;
       break;
       }
+    case 100: {
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn,Attribute::Convergent};
+      AS[0] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 1;
+      break;
+      }
+    case 95: {
+      const Attribute::AttrKind AttrParam1[]= {Attribute::NoCapture};
+      AS[0] = AttributeList::get(C, 1, AttrParam1);
+      const Attribute::AttrKind AttrParam2[]= {Attribute::ImmArg};
+      AS[1] = AttributeList::get(C, 2, AttrParam2);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn,Attribute::Convergent,Attribute::ArgMemOnly};
+      AS[2] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 3;
+      break;
+      }
+    case 96: {
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn,Attribute::Convergent,Attribute::InaccessibleMemOnly};
+      AS[0] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 1;
+      break;
+      }
     case 97: {
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn,Attribute::Convergent,Attribute::WriteOnly,Attribute::InaccessibleMemOnly};
+      AS[0] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 1;
+      break;
+      }
+    case 86: {
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn,Attribute::Convergent,Attribute::ReadNone};
+      AS[0] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 1;
+      break;
+      }
+    case 99: {
+      const Attribute::AttrKind AttrParam2[]= {Attribute::ImmArg};
+      AS[0] = AttributeList::get(C, 2, AttrParam2);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn,Attribute::Convergent,Attribute::ReadNone};
+      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 2;
+      break;
+      }
+    case 146: {
       const Attribute::AttrKind AttrParam2[]= {Attribute::ImmArg};
       AS[0] = AttributeList::get(C, 2, AttrParam2);
       const Attribute::AttrKind AttrParam3[]= {Attribute::ImmArg};
@@ -17756,20 +24460,20 @@
       AS[2] = AttributeList::get(C, 4, AttrParam4);
       const Attribute::AttrKind AttrParam5[]= {Attribute::ImmArg};
       AS[3] = AttributeList::get(C, 5, AttrParam5);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::Convergent,Attribute::ReadNone};
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn,Attribute::Convergent,Attribute::ReadNone};
       AS[4] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
       NumAttrs = 5;
       break;
       }
-    case 65: {
+    case 104: {
       const Attribute::AttrKind AttrParam3[]= {Attribute::ImmArg};
       AS[0] = AttributeList::get(C, 3, AttrParam3);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::Convergent,Attribute::ReadNone};
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn,Attribute::Convergent,Attribute::ReadNone};
       AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
       NumAttrs = 2;
       break;
       }
-    case 111: {
+    case 165: {
       const Attribute::AttrKind AttrParam3[]= {Attribute::ImmArg};
       AS[0] = AttributeList::get(C, 3, AttrParam3);
       const Attribute::AttrKind AttrParam4[]= {Attribute::ImmArg};
@@ -17778,69 +24482,387 @@
       AS[2] = AttributeList::get(C, 5, AttrParam5);
       const Attribute::AttrKind AttrParam6[]= {Attribute::ImmArg};
       AS[3] = AttributeList::get(C, 6, AttrParam6);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::Convergent,Attribute::ReadNone};
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn,Attribute::Convergent,Attribute::ReadNone};
       AS[4] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
       NumAttrs = 5;
       break;
       }
-    case 98: {
+    case 145: {
+      const Attribute::AttrKind AttrParam4[]= {Attribute::ImmArg};
+      AS[0] = AttributeList::get(C, 4, AttrParam4);
+      const Attribute::AttrKind AttrParam5[]= {Attribute::ImmArg};
+      AS[1] = AttributeList::get(C, 5, AttrParam5);
+      const Attribute::AttrKind AttrParam6[]= {Attribute::ImmArg};
+      AS[2] = AttributeList::get(C, 6, AttrParam6);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn,Attribute::Convergent,Attribute::ReadNone};
+      AS[3] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 4;
+      break;
+      }
+    case 147: {
       const Attribute::AttrKind AttrParam5[]= {Attribute::ImmArg};
       AS[0] = AttributeList::get(C, 5, AttrParam5);
       const Attribute::AttrKind AttrParam6[]= {Attribute::ImmArg};
       AS[1] = AttributeList::get(C, 6, AttrParam6);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::Convergent,Attribute::ReadNone};
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn,Attribute::Convergent,Attribute::ReadNone};
       AS[2] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
       NumAttrs = 3;
       break;
       }
-    case 112: {
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::Convergent,Attribute::Speculatable,Attribute::ReadNone};
+    case 150: {
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn,Attribute::Convergent};
       AS[0] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
       NumAttrs = 1;
       break;
       }
-    case 15: {
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::NoReturn};
+    case 166: {
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::WillReturn,Attribute::Convergent,Attribute::Speculatable,Attribute::ReadNone};
       AS[0] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
       NumAttrs = 1;
       break;
       }
-    case 43: {
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::NoReturn,Attribute::Cold};
-      AS[0] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
-      NumAttrs = 1;
-      break;
-      }
-    case 28: {
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::NoDuplicate};
+    case 4: {
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::NoSync,Attribute::NoFree,Attribute::WillReturn};
       AS[0] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
       NumAttrs = 1;
       break;
       }
     case 5: {
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::NoDuplicate,Attribute::InaccessibleMemOnly};
+      const Attribute::AttrKind AttrParam1[]= {Attribute::NoUndef};
+      AS[0] = AttributeList::get(C, 1, AttrParam1);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::NoSync,Attribute::NoFree,Attribute::WillReturn};
+      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 2;
+      break;
+      }
+    case 53: {
+      const Attribute::AttrKind AttrParam1[]= {Attribute::NoCapture,Attribute::ReadOnly};
+      AS[0] = AttributeList::get(C, 1, AttrParam1);
+      const Attribute::AttrKind AttrParam2[]= {Attribute::ImmArg};
+      AS[1] = AttributeList::get(C, 2, AttrParam2);
+      const Attribute::AttrKind AttrParam3[]= {Attribute::ImmArg};
+      AS[2] = AttributeList::get(C, 3, AttrParam3);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::NoSync,Attribute::NoFree,Attribute::WillReturn,Attribute::InaccessibleMemOrArgMemOnly};
+      AS[3] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 4;
+      break;
+      }
+    case 48: {
+      const Attribute::AttrKind AttrParam1[]= {Attribute::NoCapture,Attribute::NoAlias,Attribute::WriteOnly};
+      AS[0] = AttributeList::get(C, 1, AttrParam1);
+      const Attribute::AttrKind AttrParam2[]= {Attribute::NoCapture,Attribute::NoAlias,Attribute::ReadOnly};
+      AS[1] = AttributeList::get(C, 2, AttrParam2);
+      const Attribute::AttrKind AttrParam3[]= {Attribute::ImmArg};
+      AS[2] = AttributeList::get(C, 3, AttrParam3);
+      const Attribute::AttrKind AttrParam4[]= {Attribute::ImmArg};
+      AS[3] = AttributeList::get(C, 4, AttrParam4);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::NoSync,Attribute::NoFree,Attribute::WillReturn,Attribute::ArgMemOnly};
+      AS[4] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 5;
+      break;
+      }
+    case 46: {
+      const Attribute::AttrKind AttrParam1[]= {Attribute::NoCapture,Attribute::NoAlias,Attribute::WriteOnly};
+      AS[0] = AttributeList::get(C, 1, AttrParam1);
+      const Attribute::AttrKind AttrParam2[]= {Attribute::NoCapture,Attribute::NoAlias,Attribute::ReadOnly};
+      AS[1] = AttributeList::get(C, 2, AttrParam2);
+      const Attribute::AttrKind AttrParam4[]= {Attribute::ImmArg};
+      AS[2] = AttributeList::get(C, 4, AttrParam4);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::NoSync,Attribute::NoFree,Attribute::WillReturn,Attribute::ArgMemOnly};
+      AS[3] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 4;
+      break;
+      }
+    case 49: {
+      const Attribute::AttrKind AttrParam1[]= {Attribute::NoCapture,Attribute::WriteOnly};
+      AS[0] = AttributeList::get(C, 1, AttrParam1);
+      const Attribute::AttrKind AttrParam2[]= {Attribute::NoCapture,Attribute::ReadOnly};
+      AS[1] = AttributeList::get(C, 2, AttrParam2);
+      const Attribute::AttrKind AttrParam4[]= {Attribute::ImmArg};
+      AS[2] = AttributeList::get(C, 4, AttrParam4);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::NoSync,Attribute::NoFree,Attribute::WillReturn,Attribute::ArgMemOnly};
+      AS[3] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 4;
+      break;
+      }
+    case 32: {
+      const Attribute::AttrKind AttrParam1[]= {Attribute::ImmArg};
+      AS[0] = AttributeList::get(C, 1, AttrParam1);
+      const Attribute::AttrKind AttrParam2[]= {Attribute::NoCapture};
+      AS[1] = AttributeList::get(C, 2, AttrParam2);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::NoSync,Attribute::NoFree,Attribute::WillReturn,Attribute::ArgMemOnly};
+      AS[2] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 3;
+      break;
+      }
+    case 31: {
+      const Attribute::AttrKind AttrParam2[]= {Attribute::ImmArg};
+      AS[0] = AttributeList::get(C, 2, AttrParam2);
+      const Attribute::AttrKind AttrParam3[]= {Attribute::NoCapture};
+      AS[1] = AttributeList::get(C, 3, AttrParam3);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::NoSync,Attribute::NoFree,Attribute::WillReturn,Attribute::ArgMemOnly};
+      AS[2] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 3;
+      break;
+      }
+    case 19: {
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::NoSync,Attribute::NoFree,Attribute::WillReturn,Attribute::InaccessibleMemOnly};
       AS[0] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
       NumAttrs = 1;
       break;
       }
-    case 139: {
+    case 40: {
+      const Attribute::AttrKind AttrParam3[]= {Attribute::ImmArg};
+      AS[0] = AttributeList::get(C, 3, AttrParam3);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::NoSync,Attribute::NoFree,Attribute::WillReturn,Attribute::WriteOnly};
+      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 2;
+      break;
+      }
+    case 36: {
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::NoSync,Attribute::NoFree,Attribute::WillReturn,Attribute::WriteOnly,Attribute::ArgMemOnly};
+      AS[0] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 1;
+      break;
+      }
+    case 50: {
+      const Attribute::AttrKind AttrParam1[]= {Attribute::NoCapture,Attribute::WriteOnly};
+      AS[0] = AttributeList::get(C, 1, AttrParam1);
+      const Attribute::AttrKind AttrParam4[]= {Attribute::ImmArg};
+      AS[1] = AttributeList::get(C, 4, AttrParam4);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::NoSync,Attribute::NoFree,Attribute::WillReturn,Attribute::WriteOnly,Attribute::ArgMemOnly};
+      AS[2] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 3;
+      break;
+      }
+    case 43: {
+      const Attribute::AttrKind AttrParam2[]= {Attribute::NoCapture,Attribute::WriteOnly};
+      AS[0] = AttributeList::get(C, 2, AttrParam2);
+      const Attribute::AttrKind AttrParam4[]= {Attribute::ImmArg};
+      AS[1] = AttributeList::get(C, 4, AttrParam4);
+      const Attribute::AttrKind AttrParam5[]= {Attribute::ImmArg};
+      AS[2] = AttributeList::get(C, 5, AttrParam5);
+      const Attribute::AttrKind AttrParam6[]= {Attribute::ImmArg};
+      AS[3] = AttributeList::get(C, 6, AttrParam6);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::NoSync,Attribute::NoFree,Attribute::WillReturn,Attribute::WriteOnly,Attribute::ArgMemOnly};
+      AS[4] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 5;
+      break;
+      }
+    case 41: {
+      const Attribute::AttrKind AttrParam3[]= {Attribute::ImmArg};
+      AS[0] = AttributeList::get(C, 3, AttrParam3);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::NoSync,Attribute::NoFree,Attribute::WillReturn,Attribute::WriteOnly,Attribute::ArgMemOnly};
+      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 2;
+      break;
+      }
+    case 37: {
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::NoSync,Attribute::NoFree,Attribute::WillReturn,Attribute::ReadOnly};
+      AS[0] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 1;
+      break;
+      }
+    case 38: {
+      const Attribute::AttrKind AttrParam2[]= {Attribute::ImmArg};
+      AS[0] = AttributeList::get(C, 2, AttrParam2);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::NoSync,Attribute::NoFree,Attribute::WillReturn,Attribute::ReadOnly};
+      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 2;
+      break;
+      }
+    case 34: {
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::NoSync,Attribute::NoFree,Attribute::WillReturn,Attribute::ReadOnly,Attribute::ArgMemOnly};
+      AS[0] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 1;
+      break;
+      }
+    case 42: {
+      const Attribute::AttrKind AttrParam1[]= {Attribute::NoCapture};
+      AS[0] = AttributeList::get(C, 1, AttrParam1);
+      const Attribute::AttrKind AttrParam3[]= {Attribute::ImmArg};
+      AS[1] = AttributeList::get(C, 3, AttrParam3);
+      const Attribute::AttrKind AttrParam4[]= {Attribute::ImmArg};
+      AS[2] = AttributeList::get(C, 4, AttrParam4);
+      const Attribute::AttrKind AttrParam5[]= {Attribute::ImmArg};
+      AS[3] = AttributeList::get(C, 5, AttrParam5);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::NoSync,Attribute::NoFree,Attribute::WillReturn,Attribute::ReadOnly,Attribute::ArgMemOnly};
+      AS[4] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 5;
+      break;
+      }
+    case 39: {
+      const Attribute::AttrKind AttrParam2[]= {Attribute::ImmArg};
+      AS[0] = AttributeList::get(C, 2, AttrParam2);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::NoSync,Attribute::NoFree,Attribute::WillReturn,Attribute::ReadOnly,Attribute::ArgMemOnly};
+      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 2;
+      break;
+      }
+    case 2: {
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::NoSync,Attribute::NoFree,Attribute::WillReturn,Attribute::ReadNone};
+      AS[0] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 1;
+      break;
+      }
+    case 58: {
+      const Attribute::AttrKind AttrParam1[]= {Attribute::Returned};
+      AS[0] = AttributeList::get(C, 1, AttrParam1);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::NoSync,Attribute::NoFree,Attribute::WillReturn,Attribute::ReadNone};
+      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 2;
+      break;
+      }
+    case 27: {
+      const Attribute::AttrKind AttrParam1[]= {Attribute::ImmArg};
+      AS[0] = AttributeList::get(C, 1, AttrParam1);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::NoSync,Attribute::NoFree,Attribute::WillReturn,Attribute::ReadNone};
+      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 2;
+      break;
+      }
+    case 24: {
+      const Attribute::AttrKind AttrParam2[]= {Attribute::ImmArg};
+      AS[0] = AttributeList::get(C, 2, AttrParam2);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::NoSync,Attribute::NoFree,Attribute::WillReturn,Attribute::ReadNone};
+      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 2;
+      break;
+      }
+    case 54: {
+      const Attribute::AttrKind AttrParam2[]= {Attribute::ImmArg};
+      AS[0] = AttributeList::get(C, 2, AttrParam2);
+      const Attribute::AttrKind AttrParam3[]= {Attribute::ImmArg};
+      AS[1] = AttributeList::get(C, 3, AttrParam3);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::NoSync,Attribute::NoFree,Attribute::WillReturn,Attribute::ReadNone};
+      AS[2] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 3;
+      break;
+      }
+    case 25: {
+      const Attribute::AttrKind AttrParam3[]= {Attribute::ImmArg};
+      AS[0] = AttributeList::get(C, 3, AttrParam3);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::NoSync,Attribute::NoFree,Attribute::WillReturn,Attribute::ReadNone};
+      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 2;
+      break;
+      }
+    case 26: {
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::NoSync,Attribute::NoFree,Attribute::WillReturn,Attribute::Speculatable,Attribute::InaccessibleMemOnly};
+      AS[0] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 1;
+      break;
+      }
+    case 6: {
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::NoSync,Attribute::NoFree,Attribute::WillReturn,Attribute::Speculatable,Attribute::ReadNone};
+      AS[0] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 1;
+      break;
+      }
+    case 1: {
+      const Attribute::AttrKind AttrParam2[]= {Attribute::ImmArg};
+      AS[0] = AttributeList::get(C, 2, AttrParam2);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::NoSync,Attribute::NoFree,Attribute::WillReturn,Attribute::Speculatable,Attribute::ReadNone};
+      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 2;
+      break;
+      }
+    case 45: {
+      const Attribute::AttrKind AttrParam2[]= {Attribute::ImmArg};
+      AS[0] = AttributeList::get(C, 2, AttrParam2);
+      const Attribute::AttrKind AttrParam3[]= {Attribute::ImmArg};
+      AS[1] = AttributeList::get(C, 3, AttrParam3);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::NoSync,Attribute::NoFree,Attribute::WillReturn,Attribute::Speculatable,Attribute::ReadNone};
+      AS[2] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 3;
+      break;
+      }
+    case 52: {
+      const Attribute::AttrKind AttrParam2[]= {Attribute::ImmArg};
+      AS[0] = AttributeList::get(C, 2, AttrParam2);
+      const Attribute::AttrKind AttrParam3[]= {Attribute::ImmArg};
+      AS[1] = AttributeList::get(C, 3, AttrParam3);
+      const Attribute::AttrKind AttrParam4[]= {Attribute::ImmArg};
+      AS[2] = AttributeList::get(C, 4, AttrParam4);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::NoSync,Attribute::NoFree,Attribute::WillReturn,Attribute::Speculatable,Attribute::ReadNone};
+      AS[3] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 4;
+      break;
+      }
+    case 57: {
+      const Attribute::AttrKind AttrParam3[]= {Attribute::ImmArg};
+      AS[0] = AttributeList::get(C, 3, AttrParam3);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::NoSync,Attribute::NoFree,Attribute::WillReturn,Attribute::Speculatable,Attribute::ReadNone};
+      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 2;
+      break;
+      }
+    case 44: {
+      const Attribute::AttrKind AttrParam3[]= {Attribute::ImmArg};
+      AS[0] = AttributeList::get(C, 3, AttrParam3);
+      const Attribute::AttrKind AttrParam4[]= {Attribute::ImmArg};
+      AS[1] = AttributeList::get(C, 4, AttrParam4);
+      const Attribute::AttrKind AttrParam5[]= {Attribute::ImmArg};
+      AS[2] = AttributeList::get(C, 5, AttrParam5);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::NoSync,Attribute::NoFree,Attribute::WillReturn,Attribute::Speculatable,Attribute::ReadNone};
+      AS[3] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 4;
+      break;
+      }
+    case 33: {
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::NoSync,Attribute::NoFree,Attribute::WillReturn,Attribute::Convergent,Attribute::ReadNone};
+      AS[0] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 1;
+      break;
+      }
+    case 18: {
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::NoReturn};
+      AS[0] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 1;
+      break;
+      }
+    case 59: {
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::NoReturn,Attribute::Cold};
+      AS[0] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 1;
+      break;
+      }
+    case 60: {
+      const Attribute::AttrKind AttrParam1[]= {Attribute::ImmArg};
+      AS[0] = AttributeList::get(C, 1, AttrParam1);
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::NoReturn,Attribute::Cold};
+      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 2;
+      break;
+      }
+    case 101: {
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::NoReturn,Attribute::Cold};
+      AS[0] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 1;
+      break;
+      }
+    case 201: {
       const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::NoDuplicate,Attribute::WriteOnly};
       AS[0] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
       NumAttrs = 1;
       break;
       }
-    case 142: {
-      const Attribute::AttrKind AttrParam1[]= {Attribute::ImmArg};
-      AS[0] = AttributeList::get(C, 1, AttrParam1);
-      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::NoDuplicate};
-      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
-      NumAttrs = 2;
+    case 35: {
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::NoSync,Attribute::NoFree,Attribute::WillReturn,Attribute::NoDuplicate};
+      AS[0] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 1;
       break;
       }
-    case 7: {
+    case 8: {
+      const Attribute::AttrKind Atts[] = {Attribute::NoUnwind,Attribute::NoSync,Attribute::NoFree,Attribute::WillReturn,Attribute::NoDuplicate,Attribute::InaccessibleMemOnly};
+      AS[0] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 1;
+      break;
+      }
+    case 10: {
       return AttributeList();
       }
-    case 19: {
+    case 22: {
       const Attribute::AttrKind AttrParam1[]= {Attribute::ImmArg};
       AS[0] = AttributeList::get(C, 1, AttrParam1);
       const Attribute::AttrKind AttrParam2[]= {Attribute::ImmArg};
@@ -17852,13 +24874,21 @@
       NumAttrs = 4;
       break;
       }
-    case 121: {
+    case 179: {
       const Attribute::AttrKind Atts[] = {Attribute::ReadNone};
       AS[0] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
       NumAttrs = 1;
       break;
       }
-    case 122: {
+    case 181: {
+      const Attribute::AttrKind AttrParam1[]= {Attribute::ImmArg};
+      AS[0] = AttributeList::get(C, 1, AttrParam1);
+      const Attribute::AttrKind Atts[] = {Attribute::ReadNone};
+      AS[1] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 2;
+      break;
+      }
+    case 180: {
       const Attribute::AttrKind AttrParam2[]= {Attribute::ImmArg};
       AS[0] = AttributeList::get(C, 2, AttrParam2);
       const Attribute::AttrKind Atts[] = {Attribute::ReadNone};
@@ -17866,13 +24896,19 @@
       NumAttrs = 2;
       break;
       }
-    case 145: {
+    case 23: {
+      const Attribute::AttrKind Atts[] = {Attribute::NoSync,Attribute::NoFree,Attribute::WillReturn};
+      AS[0] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
+      NumAttrs = 1;
+      break;
+      }
+    case 208: {
       const Attribute::AttrKind Atts[] = {Attribute::NoReturn};
       AS[0] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
       NumAttrs = 1;
       break;
       }
-    case 146: {
+    case 209: {
       const Attribute::AttrKind AttrParam1[]= {Attribute::ImmArg};
       AS[0] = AttributeList::get(C, 1, AttrParam1);
       const Attribute::AttrKind Atts[] = {Attribute::NoReturn};
@@ -17880,7 +24916,7 @@
       NumAttrs = 2;
       break;
       }
-    case 138: {
+    case 200: {
       const Attribute::AttrKind Atts[] = {Attribute::NoReturn,Attribute::WriteOnly};
       AS[0] = AttributeList::get(C, AttributeList::FunctionIndex, Atts);
       NumAttrs = 1;
@@ -17904,643 +24940,730 @@
   'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'd', 'e', 'b', 'u', 'g', 't', 'r',
   'a', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'u', 'n',
   'w', 'i', 'n', 'd', '_', 'i', 'n', 'i', 't', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'f', 'l', 't', '_', 'r', 'o', 'u', 'n', 'd', 's',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'n', 'i', 't',
-  '_', 't', 'r', 'a', 'm', 'p', 'o', 'l', 'i', 'n', 'e', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'o', 'b', 'j', 'e', 'c', 't', '_', 's',
-  'i', 'z', 'e', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's',
-  't', 'a', 'c', 'k', '_', 'r', 'e', 's', 't', 'o', 'r', 'e', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', 't', 'a', 'c', 'k', '_', 's',
-  'a', 'v', 'e', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 't',
-  'h', 'r', 'e', 'a', 'd', '_', 'p', 'o', 'i', 'n', 't', 'e', 'r', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 't', 'r', 'a', 'p', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 'd', 'm',
-  'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm',
-  '_', 'd', 's', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'a', 'r', 'm', '_', 'i', 's', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 'b', 'u', 'f', 'f', 'e',
-  'r', '_', 'w', 'b', 'i', 'n', 'v', 'l', '1', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 'b', 'u', 'f',
-  'f', 'e', 'r', '_', 'w', 'b', 'i', 'n', 'v', 'l', '1', '_', 's', 'c', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c',
-  'n', '_', 'b', 'u', 'f', 'f', 'e', 'r', '_', 'w', 'b', 'i', 'n', 'v', 'l',
-  '1', '_', 'v', 'o', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 'c', 'u', 'b', 'e', 'i', 'd', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c',
-  'n', '_', 'c', 'u', 'b', 'e', 'm', 'a', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 'c', 'u', 'b', 'e',
-  's', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'm',
-  'd', 'g', 'c', 'n', '_', 'c', 'u', 'b', 'e', 't', 'c', '\000', '_', '_', 'b',
+  'l', 't', 'i', 'n', '_', 'i', 'n', 'i', 't', '_', 't', 'r', 'a', 'm', 'p',
+  'o', 'l', 'i', 'n', 'e', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'o', 'b', 'j', 'e', 'c', 't', '_', 's', 'i', 'z', 'e', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', 't', 'a', 'c', 'k', '_', 'r',
+  'e', 's', 't', 'o', 'r', 'e', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 's', 't', 'a', 'c', 'k', '_', 's', 'a', 'v', 'e', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 't', 'h', 'r', 'e', 'a', 'd', '_',
+  'p', 'o', 'i', 'n', 't', 'e', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 't', 'r', 'a', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'a', 'r', 'm', '_', 'd', 'm', 'b', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 'd', 's', 'b', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 'i', 's',
+  'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', 'v', 'e',
+  '_', 's', 'v', 'a', 'e', 's', 'd', '_', 'u', '8', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 's', 'v', 'e', '_', 's', 'v', 'a', 'e', 's',
+  'e', '_', 'u', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  's', 'v', 'e', '_', 's', 'v', 'a', 'e', 's', 'i', 'm', 'c', '_', 'u', '8',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', 'v', 'e', '_',
+  's', 'v', 'a', 'e', 's', 'm', 'c', '_', 'u', '8', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 's', 'v', 'e', '_', 's', 'v', 'r', 'a', 'x',
+  '1', '_', 'u', '6', '4', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 's', 'v', 'e', '_', 's', 'v', 'r', 'd', 'f', 'f', 'r', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', 'v', 'e', '_', 's', 'v', 'r',
+  'd', 'f', 'f', 'r', '_', 'z', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 's', 'v', 'e', '_', 's', 'v', 's', 'e', 't', 'f', 'f', 'r', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', 'v', 'e', '_', 's',
+  'v', 's', 'm', '4', 'e', '_', 'u', '3', '2', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 's', 'v', 'e', '_', 's', 'v', 's', 'm', '4', 'e',
+  'k', 'e', 'y', '_', 'u', '3', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 's', 'v', 'e', '_', 's', 'v', 'w', 'r', 'f', 'f', 'r', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 't',
+  'c', 'a', 'n', 'c', 'e', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'a', 'r', 'm', '_', 't', 'c', 'o', 'm', 'm', 'i', 't', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 't', 's',
+  't', 'a', 'r', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'a', 'r', 'm', '_', 't', 't', 'e', 's', 't', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 'a', 'l', 'i',
+  'g', 'n', 'b', 'y', 't', 'e', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 'b', 'u', 'f', 'f', 'e', 'r',
+  '_', 'w', 'b', 'i', 'n', 'v', 'l', '1', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 'b', 'u', 'f', 'f',
+  'e', 'r', '_', 'w', 'b', 'i', 'n', 'v', 'l', '1', '_', 's', 'c', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n',
+  '_', 'b', 'u', 'f', 'f', 'e', 'r', '_', 'w', 'b', 'i', 'n', 'v', 'l', '1',
+  '_', 'v', 'o', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'a', 'm', 'd', 'g', 'c', 'n', '_', 'c', 'u', 'b', 'e', 'i', 'd', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n',
+  '_', 'c', 'u', 'b', 'e', 'm', 'a', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 'c', 'u', 'b', 'e', 's',
+  'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd',
+  'g', 'c', 'n', '_', 'c', 'u', 'b', 'e', 't', 'c', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 'c', 'v',
+  't', '_', 'p', 'k', '_', 'i', '1', '6', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 'c', 'v', 't', '_',
+  'p', 'k', '_', 'u', '1', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 'c', 'v', 't', '_', 'p', 'k',
+  '_', 'u', '8', '_', 'f', '3', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 'c', 'v', 't', '_', 'p',
+  'k', 'n', 'o', 'r', 'm', '_', 'i', '1', '6', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 'c', 'v', 't',
+  '_', 'p', 'k', 'n', 'o', 'r', 'm', '_', 'u', '1', '6', '\000', '_', '_', 'b',
   'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 'c',
-  'v', 't', '_', 'p', 'k', '_', 'u', '8', '_', 'f', '3', '2', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_',
-  'd', 'i', 's', 'p', 'a', 't', 'c', 'h', '_', 'i', 'd', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 'd',
-  'i', 's', 'p', 'a', 't', 'c', 'h', '_', 'p', 't', 'r', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 'd',
-  's', '_', 'b', 'p', 'e', 'r', 'm', 'u', 't', 'e', '\000', '_', '_', 'b', 'u',
+  'v', 't', '_', 'p', 'k', 'r', 't', 'z', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 'd', 'i', 's', 'p',
+  'a', 't', 'c', 'h', '_', 'i', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 'd', 's', '_', 'b', 'p',
+  'e', 'r', 'm', 'u', 't', 'e', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 'd', 's', '_', 'g', 'w', 's',
+  '_', 'b', 'a', 'r', 'r', 'i', 'e', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 'd', 's', '_', 'g',
+  'w', 's', '_', 'i', 'n', 'i', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 'd', 's', '_', 'g', 'w',
+  's', '_', 's', 'e', 'm', 'a', '_', 'b', 'r', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 'd', 's', '_',
+  'g', 'w', 's', '_', 's', 'e', 'm', 'a', '_', 'p', '\000', '_', '_', 'b', 'u',
   'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 'd', 's',
-  '_', 'f', 'a', 'd', 'd', 'f', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 'd', 's', '_', 'f', 'm', 'a',
-  'x', 'f', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'm',
-  'd', 'g', 'c', 'n', '_', 'd', 's', '_', 'f', 'm', 'i', 'n', 'f', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n',
-  '_', 'd', 's', '_', 'g', 'w', 's', '_', 'b', 'a', 'r', 'r', 'i', 'e', 'r',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g',
-  'c', 'n', '_', 'd', 's', '_', 'g', 'w', 's', '_', 'i', 'n', 'i', 't', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c',
-  'n', '_', 'd', 's', '_', 'g', 'w', 's', '_', 's', 'e', 'm', 'a', '_', 'b',
-  'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd',
-  'g', 'c', 'n', '_', 'd', 's', '_', 'g', 'w', 's', '_', 's', 'e', 'm', 'a',
-  '_', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'm',
-  'd', 'g', 'c', 'n', '_', 'd', 's', '_', 'g', 'w', 's', '_', 's', 'e', 'm',
-  'a', '_', 'r', 'e', 'l', 'e', 'a', 's', 'e', '_', 'a', 'l', 'l', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n',
-  '_', 'd', 's', '_', 'g', 'w', 's', '_', 's', 'e', 'm', 'a', '_', 'v', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c',
-  'n', '_', 'd', 's', '_', 'p', 'e', 'r', 'm', 'u', 't', 'e', '\000', '_', '_',
+  '_', 'g', 'w', 's', '_', 's', 'e', 'm', 'a', '_', 'r', 'e', 'l', 'e', 'a',
+  's', 'e', '_', 'a', 'l', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 'd', 's', '_', 'g', 'w', 's',
+  '_', 's', 'e', 'm', 'a', '_', 'v', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 'd', 's', '_', 'p', 'e',
+  'r', 'm', 'u', 't', 'e', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 'd', 's', '_', 's', 'w', 'i', 'z',
+  'z', 'l', 'e', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a',
+  'm', 'd', 'g', 'c', 'n', '_', 'e', 'n', 'd', 'p', 'g', 'm', '\000', '_', '_',
   'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_',
-  'd', 's', '_', 's', 'w', 'i', 'z', 'z', 'l', 'e', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 'f', 'd',
-  'o', 't', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a',
-  'm', 'd', 'g', 'c', 'n', '_', 'f', 'm', 'e', 'd', '3', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 'f',
-  'm', 'u', 'l', '_', 'l', 'e', 'g', 'a', 'c', 'y', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 'g', 'r',
-  'o', 'u', 'p', 's', 't', 'a', 't', 'i', 'c', 's', 'i', 'z', 'e', '\000', '_',
+  'f', 'd', 'o', 't', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 'f', 'm', 'e', 'd', '3', '\000', '_',
   '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n',
-  '_', 'i', 'm', 'p', 'l', 'i', 'c', 'i', 't', '_', 'b', 'u', 'f', 'f', 'e',
-  'r', '_', 'p', 't', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 'i', 'm', 'p', 'l', 'i', 'c', 'i',
-  't', 'a', 'r', 'g', '_', 'p', 't', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  '_', 'f', 'm', 'u', 'l', '_', 'l', 'e', 'g', 'a', 'c', 'y', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_',
+  'g', 'r', 'o', 'u', 'p', 's', 't', 'a', 't', 'i', 'c', 's', 'i', 'z', 'e',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g',
+  'c', 'n', '_', 'i', 'm', 'p', 'l', 'i', 'c', 'i', 't', '_', 'b', 'u', 'f',
+  'f', 'e', 'r', '_', 'p', 't', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 'i', 'm', 'p', 'l', 'i',
+  'c', 'i', 't', 'a', 'r', 'g', '_', 'p', 't', 'r', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 'i', 'n',
+  't', 'e', 'r', 'p', '_', 'm', 'o', 'v', '\000', '_', '_', 'b', 'u', 'i', 'l',
   't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 'i', 'n', 't', 'e',
-  'r', 'p', '_', 'm', 'o', 'v', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'r', 'p', '_', 'p', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 'i', 'n', 't', 'e', 'r', 'p', '_',
+  'p', '1', '_', 'f', '1', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
   'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 'i', 'n', 't', 'e', 'r', 'p',
-  '_', 'p', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a',
-  'm', 'd', 'g', 'c', 'n', '_', 'i', 'n', 't', 'e', 'r', 'p', '_', 'p', '1',
+  '_', 'p', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a',
+  'm', 'd', 'g', 'c', 'n', '_', 'i', 'n', 't', 'e', 'r', 'p', '_', 'p', '2',
   '_', 'f', '1', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'a', 'm', 'd', 'g', 'c', 'n', '_', 'i', 'n', 't', 'e', 'r', 'p', '_', 'p',
-  '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd',
-  'g', 'c', 'n', '_', 'i', 'n', 't', 'e', 'r', 'p', '_', 'p', '2', '_', 'f',
-  '1', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'm',
-  'd', 'g', 'c', 'n', '_', 'k', 'e', 'r', 'n', 'a', 'r', 'g', '_', 's', 'e',
-  'g', 'm', 'e', 'n', 't', '_', 'p', 't', 'r', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 'l', 'e', 'r',
-  'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd',
-  'g', 'c', 'n', '_', 'm', 'b', 'c', 'n', 't', '_', 'h', 'i', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_',
-  'm', 'b', 'c', 'n', 't', '_', 'l', 'o', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 'm', 'q', 's', 'a',
-  'd', '_', 'p', 'k', '_', 'u', '1', '6', '_', 'u', '8', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 'm',
-  'q', 's', 'a', 'd', '_', 'u', '3', '2', '_', 'u', '8', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 'm',
-  's', 'a', 'd', '_', 'u', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 'q', 's', 'a', 'd', '_', 'p',
-  'k', '_', 'u', '1', '6', '_', 'u', '8', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 'q', 'u', 'e', 'u',
-  'e', '_', 'p', 't', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 'r', 'c', 'p', '_', 'l', 'e', 'g',
-  'a', 'c', 'y', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a',
-  'm', 'd', 'g', 'c', 'n', '_', 'r', 'e', 'a', 'd', 'f', 'i', 'r', 's', 't',
-  'l', 'a', 'n', 'e', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'a', 'm', 'd', 'g', 'c', 'n', '_', 'r', 'e', 'a', 'd', 'l', 'a', 'n', 'e',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g',
-  'c', 'n', '_', 'r', 's', 'q', '_', 'l', 'e', 'g', 'a', 'c', 'y', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n',
-  '_', 's', '_', 'b', 'a', 'r', 'r', 'i', 'e', 'r', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 's', '_',
-  'd', 'c', 'a', 'c', 'h', 'e', '_', 'i', 'n', 'v', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 's', '_',
-  'd', 'c', 'a', 'c', 'h', 'e', '_', 'i', 'n', 'v', '_', 'v', 'o', 'l', '\000',
+  'a', 'm', 'd', 'g', 'c', 'n', '_', 'i', 's', '_', 'p', 'r', 'i', 'v', 'a',
+  't', 'e', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'm',
+  'd', 'g', 'c', 'n', '_', 'i', 's', '_', 's', 'h', 'a', 'r', 'e', 'd', '\000',
   '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c',
-  'n', '_', 's', '_', 'd', 'c', 'a', 'c', 'h', 'e', '_', 'w', 'b', '\000', '_',
+  'n', '_', 'k', 'e', 'r', 'n', 'a', 'r', 'g', '_', 's', 'e', 'g', 'm', 'e',
+  'n', 't', '_', 'p', 't', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 'l', 'e', 'r', 'p', '\000', '_',
   '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n',
-  '_', 's', '_', 'd', 'c', 'a', 'c', 'h', 'e', '_', 'w', 'b', '_', 'v', 'o',
-  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd',
-  'g', 'c', 'n', '_', 's', '_', 'd', 'e', 'c', 'p', 'e', 'r', 'f', 'l', 'e',
-  'v', 'e', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a',
-  'm', 'd', 'g', 'c', 'n', '_', 's', '_', 'g', 'e', 't', '_', 'w', 'a', 'v',
-  'e', 'i', 'd', '_', 'i', 'n', '_', 'w', 'o', 'r', 'k', 'g', 'r', 'o', 'u',
-  'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd',
-  'g', 'c', 'n', '_', 's', '_', 'g', 'e', 't', 'p', 'c', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 's',
-  '_', 'g', 'e', 't', 'r', 'e', 'g', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 's', '_', 'i', 'n', 'c',
-  'p', 'e', 'r', 'f', 'l', 'e', 'v', 'e', 'l', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 's', '_', 'm',
-  'e', 'm', 'r', 'e', 'a', 'l', 't', 'i', 'm', 'e', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 's', '_',
-  'm', 'e', 'm', 't', 'i', 'm', 'e', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 's', '_', 's', 'e', 'n',
-  'd', 'm', 's', 'g', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'a', 'm', 'd', 'g', 'c', 'n', '_', 's', '_', 's', 'e', 'n', 'd', 'm', 's',
-  'g', 'h', 'a', 'l', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 's', '_', 's', 'l', 'e', 'e', 'p',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g',
-  'c', 'n', '_', 's', '_', 'w', 'a', 'i', 't', 'c', 'n', 't', '\000', '_', '_',
+  '_', 'm', 'b', 'c', 'n', 't', '_', 'h', 'i', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 'm', 'b', 'c',
+  'n', 't', '_', 'l', 'o', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 'm', 'f', 'm', 'a', '_', 'f', '3',
+  '2', '_', '1', '6', 'x', '1', '6', 'x', '1', '6', 'f', '1', '6', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n',
+  '_', 'm', 'f', 'm', 'a', '_', 'f', '3', '2', '_', '1', '6', 'x', '1', '6',
+  'x', '1', 'f', '3', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 'm', 'f', 'm', 'a', '_', 'f', '3',
+  '2', '_', '1', '6', 'x', '1', '6', 'x', '2', 'b', 'f', '1', '6', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n',
+  '_', 'm', 'f', 'm', 'a', '_', 'f', '3', '2', '_', '1', '6', 'x', '1', '6',
+  'x', '4', 'f', '1', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 'm', 'f', 'm', 'a', '_', 'f', '3',
+  '2', '_', '1', '6', 'x', '1', '6', 'x', '4', 'f', '3', '2', '\000', '_', '_',
   'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_',
-  's', 'a', 'd', '_', 'h', 'i', '_', 'u', '8', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 's', 'a', 'd',
-  '_', 'u', '1', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'a', 'm', 'd', 'g', 'c', 'n', '_', 's', 'a', 'd', '_', 'u', '8', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n',
-  '_', 's', 'd', 'o', 't', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 's', 'd', 'o', 't', '4', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c',
-  'n', '_', 's', 'd', 'o', 't', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 'u', 'd', 'o', 't', '2',
+  'm', 'f', 'm', 'a', '_', 'f', '3', '2', '_', '1', '6', 'x', '1', '6', 'x',
+  '8', 'b', 'f', '1', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 'm', 'f', 'm', 'a', '_', 'f', '3',
+  '2', '_', '3', '2', 'x', '3', '2', 'x', '1', 'f', '3', '2', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_',
+  'm', 'f', 'm', 'a', '_', 'f', '3', '2', '_', '3', '2', 'x', '3', '2', 'x',
+  '2', 'b', 'f', '1', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 'm', 'f', 'm', 'a', '_', 'f', '3',
+  '2', '_', '3', '2', 'x', '3', '2', 'x', '2', 'f', '3', '2', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_',
+  'm', 'f', 'm', 'a', '_', 'f', '3', '2', '_', '3', '2', 'x', '3', '2', 'x',
+  '4', 'b', 'f', '1', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 'm', 'f', 'm', 'a', '_', 'f', '3',
+  '2', '_', '3', '2', 'x', '3', '2', 'x', '4', 'f', '1', '6', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_',
+  'm', 'f', 'm', 'a', '_', 'f', '3', '2', '_', '3', '2', 'x', '3', '2', 'x',
+  '8', 'f', '1', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'a', 'm', 'd', 'g', 'c', 'n', '_', 'm', 'f', 'm', 'a', '_', 'f', '3', '2',
+  '_', '4', 'x', '4', 'x', '1', 'f', '3', '2', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 'm', 'f', 'm',
+  'a', '_', 'f', '3', '2', '_', '4', 'x', '4', 'x', '2', 'b', 'f', '1', '6',
   '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g',
-  'c', 'n', '_', 'u', 'd', 'o', 't', '4', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 'u', 'd', 'o', 't',
+  'c', 'n', '_', 'm', 'f', 'm', 'a', '_', 'f', '3', '2', '_', '4', 'x', '4',
+  'x', '4', 'f', '1', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 'm', 'f', 'm', 'a', '_', 'i', '3',
+  '2', '_', '1', '6', 'x', '1', '6', 'x', '1', '6', 'i', '8', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_',
+  'm', 'f', 'm', 'a', '_', 'i', '3', '2', '_', '1', '6', 'x', '1', '6', 'x',
+  '4', 'i', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a',
+  'm', 'd', 'g', 'c', 'n', '_', 'm', 'f', 'm', 'a', '_', 'i', '3', '2', '_',
+  '3', '2', 'x', '3', '2', 'x', '4', 'i', '8', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 'm', 'f', 'm',
+  'a', '_', 'i', '3', '2', '_', '3', '2', 'x', '3', '2', 'x', '8', 'i', '8',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g',
+  'c', 'n', '_', 'm', 'f', 'm', 'a', '_', 'i', '3', '2', '_', '4', 'x', '4',
+  'x', '4', 'i', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'a', 'm', 'd', 'g', 'c', 'n', '_', 'm', 'q', 's', 'a', 'd', '_', 'p', 'k',
+  '_', 'u', '1', '6', '_', 'u', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 'm', 'q', 's', 'a', 'd',
+  '_', 'u', '3', '2', '_', 'u', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 'm', 's', 'a', 'd', '_',
+  'u', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'm',
+  'd', 'g', 'c', 'n', '_', 'p', 'e', 'r', 'm', 'l', 'a', 'n', 'e', '1', '6',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g',
+  'c', 'n', '_', 'p', 'e', 'r', 'm', 'l', 'a', 'n', 'e', 'x', '1', '6', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c',
+  'n', '_', 'q', 's', 'a', 'd', '_', 'p', 'k', '_', 'u', '1', '6', '_', 'u',
   '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd',
-  'g', 'c', 'n', '_', 'w', 'a', 'v', 'e', '_', 'b', 'a', 'r', 'r', 'i', 'e',
-  'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd',
-  'g', 'c', 'n', '_', 'w', 'a', 'v', 'e', 'f', 'r', 'o', 'n', 't', 's', 'i',
-  'z', 'e', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'm',
-  'd', 'g', 'c', 'n', '_', 'w', 'o', 'r', 'k', 'g', 'r', 'o', 'u', 'p', '_',
-  'i', 'd', '_', 'x', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'a', 'm', 'd', 'g', 'c', 'n', '_', 'w', 'o', 'r', 'k', 'g', 'r', 'o', 'u',
-  'p', '_', 'i', 'd', '_', 'y', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'g', 'c', 'n', '_', 'q', 'u', 'e', 'u', 'e', '_', 'p', 't', 'r', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n',
+  '_', 'r', 'c', 'p', '_', 'l', 'e', 'g', 'a', 'c', 'y', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 'r',
+  'e', 'a', 'd', 'f', 'i', 'r', 's', 't', 'l', 'a', 'n', 'e', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_',
+  'r', 'e', 'a', 'd', 'l', 'a', 'n', 'e', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 'r', 's', 'q', '_',
+  'l', 'e', 'g', 'a', 'c', 'y', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 's', '_', 'b', 'a', 'r', 'r',
+  'i', 'e', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a',
+  'm', 'd', 'g', 'c', 'n', '_', 's', '_', 'd', 'c', 'a', 'c', 'h', 'e', '_',
+  'i', 'n', 'v', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a',
+  'm', 'd', 'g', 'c', 'n', '_', 's', '_', 'd', 'c', 'a', 'c', 'h', 'e', '_',
+  'i', 'n', 'v', '_', 'v', 'o', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 's', '_', 'd', 'c', 'a',
+  'c', 'h', 'e', '_', 'w', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 's', '_', 'd', 'c', 'a', 'c',
+  'h', 'e', '_', 'w', 'b', '_', 'v', 'o', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 's', '_', 'd',
+  'e', 'c', 'p', 'e', 'r', 'f', 'l', 'e', 'v', 'e', 'l', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 's',
+  '_', 'g', 'e', 't', '_', 'w', 'a', 'v', 'e', 'i', 'd', '_', 'i', 'n', '_',
+  'w', 'o', 'r', 'k', 'g', 'r', 'o', 'u', 'p', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 's', '_', 'g',
+  'e', 't', 'p', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'a', 'm', 'd', 'g', 'c', 'n', '_', 's', '_', 'g', 'e', 't', 'r', 'e', 'g',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g',
+  'c', 'n', '_', 's', '_', 'i', 'n', 'c', 'p', 'e', 'r', 'f', 'l', 'e', 'v',
+  'e', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'm',
+  'd', 'g', 'c', 'n', '_', 's', '_', 'm', 'e', 'm', 'r', 'e', 'a', 'l', 't',
+  'i', 'm', 'e', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a',
+  'm', 'd', 'g', 'c', 'n', '_', 's', '_', 'm', 'e', 'm', 't', 'i', 'm', 'e',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g',
+  'c', 'n', '_', 's', '_', 's', 'e', 'n', 'd', 'm', 's', 'g', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_',
+  's', '_', 's', 'e', 'n', 'd', 'm', 's', 'g', 'h', 'a', 'l', 't', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n',
+  '_', 's', '_', 's', 'e', 't', 'r', 'e', 'g', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 's', '_', 's',
+  'l', 'e', 'e', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'a', 'm', 'd', 'g', 'c', 'n', '_', 's', '_', 'w', 'a', 'i', 't', 'c', 'n',
+  't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd',
+  'g', 'c', 'n', '_', 's', 'a', 'd', '_', 'h', 'i', '_', 'u', '8', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n',
+  '_', 's', 'a', 'd', '_', 'u', '1', '6', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 's', 'a', 'd', '_',
+  'u', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'm',
+  'd', 'g', 'c', 'n', '_', 's', 'd', 'o', 't', '2', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 's', 'd',
+  'o', 't', '4', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a',
+  'm', 'd', 'g', 'c', 'n', '_', 's', 'd', 'o', 't', '8', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 'u',
+  'd', 'o', 't', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'a', 'm', 'd', 'g', 'c', 'n', '_', 'u', 'd', 'o', 't', '4', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_',
+  'u', 'd', 'o', 't', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 'w', 'a', 'v', 'e', '_', 'b', 'a',
+  'r', 'r', 'i', 'e', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 'w', 'a', 'v', 'e', 'f', 'r', 'o',
+  'n', 't', 's', 'i', 'z', 'e', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
   'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 'w', 'o', 'r', 'k', 'g', 'r',
-  'o', 'u', 'p', '_', 'i', 'd', '_', 'z', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 'w', 'r', 'i', 't',
-  'e', 'l', 'a', 'n', 'e', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'a', 'r', 'm', '_', 'c', 'd', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'a', 'r', 'm', '_', 'c', 'd', 'p', '2', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 'c', 'm', 's',
-  'e', '_', 'T', 'T', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'a', 'r', 'm', '_', 'c', 'm', 's', 'e', '_', 'T', 'T', 'A', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 'c', 'm', 's',
-  'e', '_', 'T', 'T', 'A', 'T', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'a', 'r', 'm', '_', 'c', 'm', 's', 'e', '_', 'T', 'T', 'T', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 'g',
-  'e', 't', '_', 'f', 'p', 's', 'c', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'a', 'r', 'm', '_', 'l', 'd', 'c', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 'l', 'd', 'c', '2',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_',
-  'l', 'd', 'c', '2', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'a', 'r', 'm', '_', 'l', 'd', 'c', 'l', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 'm', 'c', 'r', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 'm', 'c', 'r',
+  'o', 'u', 'p', '_', 'i', 'd', '_', 'x', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 'w', 'o', 'r', 'k',
+  'g', 'r', 'o', 'u', 'p', '_', 'i', 'd', '_', 'y', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_', 'w', 'o',
+  'r', 'k', 'g', 'r', 'o', 'u', 'p', '_', 'i', 'd', '_', 'z', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'm', 'd', 'g', 'c', 'n', '_',
+  'w', 'r', 'i', 't', 'e', 'l', 'a', 'n', 'e', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 'c', 'd', 'p', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 'c', 'd', 'p',
   '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm',
-  '_', 'm', 'r', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'a', 'r', 'm', '_', 'm', 'r', 'c', '2', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'a', 'r', 'm', '_', 'q', 'a', 'd', 'd', '\000', '_', '_',
+  '_', 'c', 'm', 's', 'e', '_', 'T', 'T', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'a', 'r', 'm', '_', 'c', 'm', 's', 'e', '_', 'T', 'T',
+  'A', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm',
+  '_', 'c', 'm', 's', 'e', '_', 'T', 'T', 'A', 'T', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 'c', 'm', 's', 'e', '_',
+  'T', 'T', 'T', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a',
+  'r', 'm', '_', 'g', 'e', 't', '_', 'f', 'p', 's', 'c', 'r', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 'l', 'd', 'c',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_',
+  'l', 'd', 'c', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'a', 'r', 'm', '_', 'l', 'd', 'c', '2', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 'l', 'd', 'c', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 'm', 'c',
+  'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm',
+  '_', 'm', 'c', 'r', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'a', 'r', 'm', '_', 'm', 'r', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'a', 'r', 'm', '_', 'm', 'r', 'c', '2', '\000', '_', '_',
   'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 'q', 'a', 'd',
-  'd', '1', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a',
-  'r', 'm', '_', 'q', 'a', 'd', 'd', '8', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'a', 'r', 'm', '_', 'q', 'a', 's', 'x', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 'q', 's', 'a',
+  'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm',
+  '_', 'q', 'a', 'd', 'd', '1', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'a', 'r', 'm', '_', 'q', 'a', 'd', 'd', '8', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 'q', 'a', 's',
   'x', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm',
-  '_', 'q', 's', 'u', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'a', 'r', 'm', '_', 'q', 's', 'u', 'b', '1', '6', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 'q', 's', 'u', 'b',
+  '_', 'q', 's', 'a', 'x', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'a', 'r', 'm', '_', 'q', 's', 'u', 'b', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 'q', 's', 'u', 'b', '1', '6',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_',
+  'q', 's', 'u', 'b', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'a', 'r', 'm', '_', 's', 'a', 'd', 'd', '1', '6', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 's', 'a', 'd', 'd',
   '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm',
-  '_', 's', 'a', 'd', 'd', '1', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'a', 'r', 'm', '_', 's', 'a', 'd', 'd', '8', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 's', 'a', 's',
-  'x', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm',
-  '_', 's', 'e', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'a', 'r', 'm', '_', 's', 'e', 't', '_', 'f', 'p', 's', 'c', 'r', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 's', 'h',
-  'a', 'd', 'd', '1', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'a', 'r', 'm', '_', 's', 'h', 'a', 'd', 'd', '8', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 's', 'h', 'a', 's',
-  'x', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm',
-  '_', 's', 'h', 's', 'a', 'x', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'a', 'r', 'm', '_', 's', 'h', 's', 'u', 'b', '1', '6', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 's', 'h',
-  's', 'u', 'b', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'a', 'r', 'm', '_', 's', 'm', 'l', 'a', 'b', 'b', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 's', 'm', 'l', 'a', 'b',
-  't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm',
-  '_', 's', 'm', 'l', 'a', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'a', 'r', 'm', '_', 's', 'm', 'l', 'a', 'd', 'x', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 's', 'm', 'l',
-  'a', 'l', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a',
-  'r', 'm', '_', 's', 'm', 'l', 'a', 'l', 'd', 'x', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 's', 'm', 'l', 'a', 't',
-  'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm',
-  '_', 's', 'm', 'l', 'a', 't', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'a', 'r', 'm', '_', 's', 'm', 'l', 'a', 'w', 'b', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 's', 'm',
-  'l', 'a', 'w', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'a', 'r', 'm', '_', 's', 'm', 'l', 's', 'd', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 's', 'm', 'l', 's', 'd', 'x',
+  '_', 's', 'a', 's', 'x', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'a', 'r', 'm', '_', 's', 'e', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'a', 'r', 'm', '_', 's', 'e', 't', '_', 'f', 'p', 's',
+  'c', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r',
+  'm', '_', 's', 'h', 'a', 'd', 'd', '1', '6', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 's', 'h', 'a', 'd', 'd', '8',
   '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_',
-  's', 'm', 'l', 's', 'l', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'a', 'r', 'm', '_', 's', 'm', 'l', 's', 'l', 'd', 'x', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 's', 'm',
-  'u', 'a', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a',
-  'r', 'm', '_', 's', 'm', 'u', 'a', 'd', 'x', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 's', 'm', 'u', 'l', 'b', 'b',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_',
-  's', 'm', 'u', 'l', 'b', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'a', 'r', 'm', '_', 's', 'm', 'u', 'l', 't', 'b', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 's', 'm', 'u',
-  'l', 't', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a',
-  'r', 'm', '_', 's', 'm', 'u', 'l', 'w', 'b', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 's', 'm', 'u', 'l', 'w', 't',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_',
-  's', 'm', 'u', 's', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'a', 'r', 'm', '_', 's', 'm', 'u', 's', 'd', 'x', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 's', 's', 'a', 't',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_',
-  's', 's', 'a', 't', '1', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'a', 'r', 'm', '_', 's', 's', 'a', 'x', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 's', 's', 'u', 'b', '1',
-  '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm',
-  '_', 's', 's', 'u', 'b', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'a', 'r', 'm', '_', 's', 't', 'c', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 's', 't', 'c', '2', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 's', 't',
-  'c', '2', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a',
-  'r', 'm', '_', 's', 't', 'c', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'a', 'r', 'm', '_', 's', 'x', 't', 'a', 'b', '1', '6', '\000',
+  's', 'h', 'a', 's', 'x', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'a', 'r', 'm', '_', 's', 'h', 's', 'a', 'x', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 's', 'h', 's', 'u', 'b',
+  '1', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r',
+  'm', '_', 's', 'h', 's', 'u', 'b', '8', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'a', 'r', 'm', '_', 's', 'm', 'l', 'a', 'b', 'b', '\000',
   '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 's',
-  'x', 't', 'b', '1', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'a', 'r', 'm', '_', 'u', 'a', 'd', 'd', '1', '6', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 'u', 'a', 'd', 'd',
-  '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm',
-  '_', 'u', 'a', 's', 'x', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'a', 'r', 'm', '_', 'u', 'h', 'a', 'd', 'd', '1', '6', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 'u', 'h', 'a',
-  'd', 'd', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a',
-  'r', 'm', '_', 'u', 'h', 'a', 's', 'x', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'a', 'r', 'm', '_', 'u', 'h', 's', 'a', 'x', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 'u', 'h',
-  's', 'u', 'b', '1', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'a', 'r', 'm', '_', 'u', 'h', 's', 'u', 'b', '8', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 'u', 'q', 'a', 'd',
-  'd', '1', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a',
-  'r', 'm', '_', 'u', 'q', 'a', 'd', 'd', '8', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 'u', 'q', 'a', 's', 'x', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 'u',
-  'q', 's', 'a', 'x', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'a', 'r', 'm', '_', 'u', 'q', 's', 'u', 'b', '1', '6', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 'u', 'q', 's', 'u',
-  'b', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r',
-  'm', '_', 'u', 's', 'a', 'd', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'a', 'r', 'm', '_', 'u', 's', 'a', 'd', 'a', '8', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 'u', 's',
-  'a', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r',
-  'm', '_', 'u', 's', 'a', 't', '1', '6', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'a', 'r', 'm', '_', 'u', 's', 'a', 'x', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 'u', 's', 'u',
-  'b', '1', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a',
-  'r', 'm', '_', 'u', 's', 'u', 'b', '8', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'a', 'r', 'm', '_', 'u', 'x', 't', 'a', 'b', '1', '6',
+  'm', 'l', 'a', 'b', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'a', 'r', 'm', '_', 's', 'm', 'l', 'a', 'd', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 's', 'm', 'l', 'a', 'd',
+  'x', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm',
+  '_', 's', 'm', 'l', 'a', 'l', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'a', 'r', 'm', '_', 's', 'm', 'l', 'a', 'l', 'd', 'x', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 's',
+  'm', 'l', 'a', 't', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'a', 'r', 'm', '_', 's', 'm', 'l', 'a', 't', 't', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 's', 'm', 'l', 'a',
+  'w', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r',
+  'm', '_', 's', 'm', 'l', 'a', 'w', 't', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'a', 'r', 'm', '_', 's', 'm', 'l', 's', 'd', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 's', 'm',
+  'l', 's', 'd', 'x', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'a', 'r', 'm', '_', 's', 'm', 'l', 's', 'l', 'd', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 's', 'm', 'l', 's', 'l',
+  'd', 'x', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r',
+  'm', '_', 's', 'm', 'u', 'a', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'a', 'r', 'm', '_', 's', 'm', 'u', 'a', 'd', 'x', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 's', 'm',
+  'u', 'l', 'b', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'a', 'r', 'm', '_', 's', 'm', 'u', 'l', 'b', 't', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 's', 'm', 'u', 'l', 't',
+  'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm',
+  '_', 's', 'm', 'u', 'l', 't', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'a', 'r', 'm', '_', 's', 'm', 'u', 'l', 'w', 'b', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 's', 'm',
+  'u', 'l', 'w', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'a', 'r', 'm', '_', 's', 'm', 'u', 's', 'd', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 's', 'm', 'u', 's', 'd', 'x',
   '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_',
-  'u', 'x', 't', 'b', '1', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  's', 's', 'a', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'a', 'r', 'm', '_', 's', 's', 'a', 't', '1', '6', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 's', 's', 'a', 'x', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 's',
+  's', 'u', 'b', '1', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'a', 'r', 'm', '_', 's', 's', 'u', 'b', '8', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 's', 't', 'c', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 's', 't',
+  'c', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r',
+  'm', '_', 's', 't', 'c', '2', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'a', 'r', 'm', '_', 's', 't', 'c', 'l', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 's', 'x', 't', 'a',
+  'b', '1', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a',
+  'r', 'm', '_', 's', 'x', 't', 'b', '1', '6', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 'u', 'a', 'd', 'd', '1', '6',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_',
+  'u', 'a', 'd', 'd', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'a', 'r', 'm', '_', 'u', 'a', 's', 'x', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 'u', 'h', 'a', 'd', 'd', '1',
+  '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm',
+  '_', 'u', 'h', 'a', 'd', 'd', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'a', 'r', 'm', '_', 'u', 'h', 'a', 's', 'x', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 'u', 'h', 's',
+  'a', 'x', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r',
+  'm', '_', 'u', 'h', 's', 'u', 'b', '1', '6', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 'u', 'h', 's', 'u', 'b', '8',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_',
+  'u', 'q', 'a', 'd', 'd', '1', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'a', 'r', 'm', '_', 'u', 'q', 'a', 'd', 'd', '8', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 'u', 'q',
+  'a', 's', 'x', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a',
+  'r', 'm', '_', 'u', 'q', 's', 'a', 'x', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'a', 'r', 'm', '_', 'u', 'q', 's', 'u', 'b', '1', '6',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_',
+  'u', 'q', 's', 'u', 'b', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'a', 'r', 'm', '_', 'u', 's', 'a', 'd', '8', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 'u', 's', 'a', 'd',
+  'a', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r',
+  'm', '_', 'u', 's', 'a', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'a', 'r', 'm', '_', 'u', 's', 'a', 't', '1', '6', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 'u', 's', 'a',
+  'x', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm',
+  '_', 'u', 's', 'u', 'b', '1', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'a', 'r', 'm', '_', 'u', 's', 'u', 'b', '8', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'r', 'm', '_', 'u', 'x', 't',
+  'a', 'b', '1', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'a', 'r', 'm', '_', 'u', 'x', 't', 'b', '1', '6', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'b', 'p', 'f', '_', 'b', 't', 'f', '_', 't',
+  'y', 'p', 'e', '_', 'i', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
   'n', '_', 'b', 'p', 'f', '_', 'l', 'o', 'a', 'd', '_', 'b', 'y', 't', 'e',
   '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'b', 'p', 'f', '_',
   'l', 'o', 'a', 'd', '_', 'h', 'a', 'l', 'f', '\000', '_', '_', 'b', 'u', 'i',
   'l', 't', 'i', 'n', '_', 'b', 'p', 'f', '_', 'l', 'o', 'a', 'd', '_', 'w',
   'o', 'r', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'b',
-  'p', 'f', '_', 'p', 's', 'e', 'u', 'd', 'o', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2',
-  '_', 'a', 'b', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'a', 'b', 's', 'p',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'A', '2', '_', 'a', 'b', 's', 's', 'a', 't', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'A', '2', '_', 'a', 'd', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_',
-  'a', 'd', 'd', 'h', '_', 'h', '1', '6', '_', 'h', 'h', '\000', '_', '_', 'b',
+  'p', 'f', '_', 'p', 'a', 's', 's', 't', 'h', 'r', 'o', 'u', 'g', 'h', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'b', 'p', 'f', '_', 'p',
+  'r', 'e', 's', 'e', 'r', 'v', 'e', '_', 'e', 'n', 'u', 'm', '_', 'v', 'a',
+  'l', 'u', 'e', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'b',
+  'p', 'f', '_', 'p', 'r', 'e', 's', 'e', 'r', 'v', 'e', '_', 'f', 'i', 'e',
+  'l', 'd', '_', 'i', 'n', 'f', 'o', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'b', 'p', 'f', '_', 'p', 'r', 'e', 's', 'e', 'r', 'v', 'e',
+  '_', 't', 'y', 'p', 'e', '_', 'i', 'n', 'f', 'o', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'b', 'p', 'f', '_', 'p', 's', 'e', 'u', 'd',
+  'o', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'a', 'b', 's', '\000', '_', '_', 'b',
   'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'A', '2', '_', 'a', 'd', 'd', 'h', '_', 'h', '1', '6', '_', 'h', 'l', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'A', '2', '_', 'a', 'd', 'd', 'h', '_', 'h', '1', '6', '_',
-  'l', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'a', 'd', 'd', 'h', '_', 'h',
-  '1', '6', '_', 'l', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  'A', '2', '_', 'a', 'b', 's', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'a',
+  'b', 's', 's', 'a', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
   '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'a', 'd', 'd',
-  'h', '_', 'h', '1', '6', '_', 's', 'a', 't', '_', 'h', 'h', '\000', '_', '_',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'A', '2', '_', 'a', 'd', 'd', 'h', '_', 'h', '1', '6',
+  '_', 'h', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'a', 'd', 'd', 'h', '_',
+  'h', '1', '6', '_', 'h', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'a', 'd',
+  'd', 'h', '_', 'h', '1', '6', '_', 'l', 'h', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2',
+  '_', 'a', 'd', 'd', 'h', '_', 'h', '1', '6', '_', 'l', 'l', '\000', '_', '_',
   'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
   '_', 'A', '2', '_', 'a', 'd', 'd', 'h', '_', 'h', '1', '6', '_', 's', 'a',
-  't', '_', 'h', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  't', '_', 'h', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
   'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'a', 'd', 'd', 'h',
-  '_', 'h', '1', '6', '_', 's', 'a', 't', '_', 'l', 'h', '\000', '_', '_', 'b',
+  '_', 'h', '1', '6', '_', 's', 'a', 't', '_', 'h', 'l', '\000', '_', '_', 'b',
   'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
   'A', '2', '_', 'a', 'd', 'd', 'h', '_', 'h', '1', '6', '_', 's', 'a', 't',
-  '_', 'l', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  '_', 'l', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
   'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'a', 'd', 'd', 'h', '_',
-  'l', '1', '6', '_', 'h', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'a', 'd',
-  'd', 'h', '_', 'l', '1', '6', '_', 'l', 'l', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2',
-  '_', 'a', 'd', 'd', 'h', '_', 'l', '1', '6', '_', 's', 'a', 't', '_', 'h',
+  'h', '1', '6', '_', 's', 'a', 't', '_', 'l', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A',
+  '2', '_', 'a', 'd', 'd', 'h', '_', 'l', '1', '6', '_', 'h', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'A', '2', '_', 'a', 'd', 'd', 'h', '_', 'l', '1', '6', '_', 'l',
   'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
   'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'a', 'd', 'd', 'h', '_', 'l', '1',
-  '6', '_', 's', 'a', 't', '_', 'l', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  '6', '_', 's', 'a', 't', '_', 'h', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
   't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_',
-  'a', 'd', 'd', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'a', 'd', 'd', 'p',
+  'a', 'd', 'd', 'h', '_', 'l', '1', '6', '_', 's', 'a', 't', '_', 'l', 'l',
   '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'A', '2', '_', 'a', 'd', 'd', 'p', 's', 'a', 't', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'A', '2', '_', 'a', 'd', 'd', 's', 'a', 't', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'A', '2', '_', 'a', 'd', 'd', 's', 'p', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2',
-  '_', 'a', 'n', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'a', 'n', 'd', 'i',
-  'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'a', 'n', 'd', 'p', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'A', '2', '_', 'a', 's', 'l', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  'G', 'O', 'N', '_', 'A', '2', '_', 'a', 'd', 'd', 'i', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'A', '2', '_', 'a', 'd', 'd', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'a',
+  'd', 'd', 'p', 's', 'a', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'a', 'd',
+  'd', 's', 'a', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'a', 'd', 'd', 's',
+  'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'a', 'n', 'd', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'A', '2', '_', 'a', 'n', 'd', 'i', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l',
   't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_',
-  'a', 's', 'r', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'a', 'n', 'd', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'a', 's', 'l', 'h',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'A', '2', '_', 'a', 's', 'r', 'h', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'A', '2', '_', 'c', 'o', 'm', 'b', 'i', 'n', 'e', '_', 'h', 'h', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'A', '2', '_', 'c', 'o', 'm', 'b', 'i', 'n', 'e', '_', 'h', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'A', '2', '_', 'c', 'o', 'm', 'b', 'i', 'n', 'e', '_',
+  'l', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'c', 'o', 'm', 'b', 'i', 'n',
+  'e', '_', 'l', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
   'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'c', 'o', 'm', 'b',
-  'i', 'n', 'e', '_', 'h', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'c', 'o',
-  'm', 'b', 'i', 'n', 'e', '_', 'h', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_',
-  'c', 'o', 'm', 'b', 'i', 'n', 'e', '_', 'l', 'h', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A',
-  '2', '_', 'c', 'o', 'm', 'b', 'i', 'n', 'e', '_', 'l', 'l', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'A', '2', '_', 'c', 'o', 'm', 'b', 'i', 'n', 'e', 'i', 'i', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'A', '2', '_', 'c', 'o', 'm', 'b', 'i', 'n', 'e', 'w', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'A', '2', '_', 'm', 'a', 'x', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_',
-  'm', 'a', 'x', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'm', 'a', 'x', 'u',
+  'i', 'n', 'e', 'i', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'c', 'o', 'm',
+  'b', 'i', 'n', 'e', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'm', 'a', 'x',
   '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'A', '2', '_', 'm', 'a', 'x', 'u', 'p', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'A', '2', '_', 'm', 'i', 'n', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'G', 'O', 'N', '_', 'A', '2', '_', 'm', 'a', 'x', 'p', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'A', '2', '_', 'm', 'a', 'x', 'u', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
   'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'm',
-  'i', 'n', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'm', 'i', 'n', 'u', '\000',
+  'a', 'x', 'u', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'm', 'i', 'n', '\000',
   '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'A', '2', '_', 'm', 'i', 'n', 'u', 'p', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'A', '2', '_', 'n', 'e', 'g', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'n', 'e',
-  'g', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'n', 'e', 'g', 's', 'a', 't',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'A', '2', '_', 'n', 'o', 't', '\000', '_', '_', 'b', 'u',
+  'O', 'N', '_', 'A', '2', '_', 'm', 'i', 'n', 'p', '\000', '_', '_', 'b', 'u',
   'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A',
-  '2', '_', 'n', 'o', 't', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'o', 'r',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'A', '2', '_', 'o', 'r', 'i', 'r', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'A', '2', '_', 'o', 'r', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'p', 'x',
-  'o', 'r', 'f', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'r', 'o', 'u', 'n', 'd',
-  's', 'a', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 's', 'a', 't', '\000', '_',
+  '2', '_', 'm', 'i', 'n', 'u', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'm', 'i',
+  'n', 'u', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'n', 'e', 'g', '\000', '_',
   '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'A', '2', '_', 's', 'a', 't', 'b', '\000', '_', '_', 'b', 'u', 'i',
+  'N', '_', 'A', '2', '_', 'n', 'e', 'g', 'p', '\000', '_', '_', 'b', 'u', 'i',
   'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2',
-  '_', 's', 'a', 't', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 's', 'a', 't',
-  'u', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 's', 'a', 't', 'u', 'h', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'A', '2', '_', 's', 'u', 'b', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2',
-  '_', 's', 'u', 'b', 'h', '_', 'h', '1', '6', '_', 'h', 'h', '\000', '_', '_',
+  '_', 'n', 'e', 'g', 's', 'a', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'n',
+  'o', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'n', 'o', 't', 'p', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'A', '2', '_', 'o', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'o',
+  'r', 'i', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'o', 'r', 'p', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'A', '2', '_', 'r', 'o', 'u', 'n', 'd', 's', 'a', 't', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'A', '2', '_', 's', 'a', 't', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_',
+  's', 'a', 't', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 's', 'a', 't', 'h',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'A', '2', '_', 's', 'a', 't', 'u', 'b', '\000', '_', '_',
   'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'A', '2', '_', 's', 'u', 'b', 'h', '_', 'h', '1', '6', '_', 'h', 'l',
+  '_', 'A', '2', '_', 's', 'a', 't', 'u', 'h', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2',
+  '_', 's', 'u', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 's', 'u', 'b', 'h',
+  '_', 'h', '1', '6', '_', 'h', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 's',
+  'u', 'b', 'h', '_', 'h', '1', '6', '_', 'h', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A',
+  '2', '_', 's', 'u', 'b', 'h', '_', 'h', '1', '6', '_', 'l', 'h', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'A', '2', '_', 's', 'u', 'b', 'h', '_', 'h', '1', '6', '_', 'l',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'A', '2', '_', 's', 'u', 'b', 'h', '_', 'h', '1',
+  '6', '_', 's', 'a', 't', '_', 'h', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_',
+  's', 'u', 'b', 'h', '_', 'h', '1', '6', '_', 's', 'a', 't', '_', 'h', 'l',
   '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
   'G', 'O', 'N', '_', 'A', '2', '_', 's', 'u', 'b', 'h', '_', 'h', '1', '6',
-  '_', 'l', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 's', 'u', 'b', 'h', '_',
-  'h', '1', '6', '_', 'l', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 's', 'u',
-  'b', 'h', '_', 'h', '1', '6', '_', 's', 'a', 't', '_', 'h', 'h', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'A', '2', '_', 's', 'u', 'b', 'h', '_', 'h', '1', '6', '_', 's',
-  'a', 't', '_', 'h', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 's', 'u', 'b',
-  'h', '_', 'h', '1', '6', '_', 's', 'a', 't', '_', 'l', 'h', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'A', '2', '_', 's', 'u', 'b', 'h', '_', 'h', '1', '6', '_', 's', 'a',
-  't', '_', 'l', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 's', 'u', 'b', 'h',
-  '_', 'l', '1', '6', '_', 'h', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  '_', 's', 'a', 't', '_', 'l', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
   'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 's',
-  'u', 'b', 'h', '_', 'l', '1', '6', '_', 'l', 'l', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A',
-  '2', '_', 's', 'u', 'b', 'h', '_', 'l', '1', '6', '_', 's', 'a', 't', '_',
+  'u', 'b', 'h', '_', 'h', '1', '6', '_', 's', 'a', 't', '_', 'l', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'A', '2', '_', 's', 'u', 'b', 'h', '_', 'l', '1', '6', '_',
   'h', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
   'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 's', 'u', 'b', 'h', '_', 'l',
-  '1', '6', '_', 's', 'a', 't', '_', 'l', 'l', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2',
-  '_', 's', 'u', 'b', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '1', '6', '_', 'l', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
   '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 's', 'u', 'b',
-  'r', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 's', 'u', 'b', 's', 'a', 't',
+  'h', '_', 'l', '1', '6', '_', 's', 'a', 't', '_', 'h', 'l', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'A', '2', '_', 's', 'u', 'b', 'h', '_', 'l', '1', '6', '_', 's', 'a',
+  't', '_', 'l', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 's', 'u', 'b', 'p',
   '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'A', '2', '_', 's', 'v', 'a', 'd', 'd', 'h', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'A', '2', '_', 's', 'v', 'a', 'd', 'd', 'h', 's', '\000', '_', '_',
+  'G', 'O', 'N', '_', 'A', '2', '_', 's', 'u', 'b', 'r', 'i', '\000', '_', '_',
   'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'A', '2', '_', 's', 'v', 'a', 'd', 'd', 'u', 'h', 's', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'A', '2', '_', 's', 'v', 'a', 'v', 'g', 'h', '\000', '_', '_', 'b', 'u',
+  '_', 'A', '2', '_', 's', 'u', 'b', 's', 'a', 't', '\000', '_', '_', 'b', 'u',
   'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A',
-  '2', '_', 's', 'v', 'a', 'v', 'g', 'h', 's', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2',
-  '_', 's', 'v', 'n', 'a', 'v', 'g', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  '2', '_', 's', 'v', 'a', 'd', 'd', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l',
   't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_',
-  's', 'v', 's', 'u', 'b', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 's', 'v',
-  's', 'u', 'b', 'h', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 's', 'v', 's',
-  'u', 'b', 'u', 'h', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 's', 'w', 'i',
-  'z', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'A', '2', '_', 's', 'x', 't', 'b', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'A', '2', '_', 's', 'x', 't', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_',
-  's', 'x', 't', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 't', 'f', 'r', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'A', '2', '_', 't', 'f', 'r', 'c', 'r', 'r', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'A', '2', '_', 't', 'f', 'r', 'i', 'h', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2',
-  '_', 't', 'f', 'r', 'i', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 't', 'f',
-  'r', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 't', 'f', 'r', 'p', 'i', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'A', '2', '_', 't', 'f', 'r', 'r', 'c', 'r', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'A', '2', '_', 't', 'f', 'r', 's', 'i', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2',
-  '_', 'v', 'a', 'b', 's', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'v', 'a',
-  'b', 's', 'h', 's', 'a', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'v', 'a',
-  'b', 's', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'v', 'a', 'b', 's', 'w',
-  's', 'a', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'v', 'a', 'd', 'd', 'b',
-  '_', 'm', 'a', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'v', 'a', 'd', 'd',
+  's', 'v', 'a', 'd', 'd', 'h', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 's',
+  'v', 'a', 'd', 'd', 'u', 'h', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 's',
+  'v', 'a', 'v', 'g', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 's', 'v', 'a',
+  'v', 'g', 'h', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 's', 'v', 'n', 'a',
+  'v', 'g', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 's', 'v', 's', 'u', 'b',
   'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'v', 'a', 'd', 'd', 'h', 's', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'A', '2', '_', 'v', 'a', 'd', 'd', 'u', 'b', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'A', '2', '_', 'v', 'a', 'd', 'd', 'u', 'b', 's', '\000', '_', '_', 'b',
+  'A', 'G', 'O', 'N', '_', 'A', '2', '_', 's', 'v', 's', 'u', 'b', 'h', 's',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'A', '2', '_', 's', 'v', 's', 'u', 'b', 'u', 'h', 's',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'A', '2', '_', 's', 'w', 'i', 'z', '\000', '_', '_', 'b',
   'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'A', '2', '_', 'v', 'a', 'd', 'd', 'u', 'h', 's', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A',
-  '2', '_', 'v', 'a', 'd', 'd', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'v',
-  'a', 'd', 'd', 'w', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'v', 'a', 'v',
-  'g', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'v', 'a', 'v', 'g', 'h', 'c',
-  'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'v', 'a', 'v', 'g', 'h', 'r', '\000',
+  'A', '2', '_', 's', 'x', 't', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 's',
+  'x', 't', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 's', 'x', 't', 'w', '\000',
   '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'A', '2', '_', 'v', 'a', 'v', 'g', 'u', 'b', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'A', '2', '_', 'v', 'a', 'v', 'g', 'u', 'b', 'r', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'A', '2', '_', 'v', 'a', 'v', 'g', 'u', 'h', '\000', '_', '_', 'b', 'u', 'i',
+  'O', 'N', '_', 'A', '2', '_', 't', 'f', 'r', '\000', '_', '_', 'b', 'u', 'i',
   'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2',
-  '_', 'v', 'a', 'v', 'g', 'u', 'h', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  '_', 't', 'f', 'r', 'i', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 't', 'f',
+  'r', 'i', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 't', 'f', 'r', 'p', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'A', '2', '_', 't', 'f', 'r', 'p', 'i', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'A', '2', '_', 't', 'f', 'r', 's', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l',
   't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_',
-  'v', 'a', 'v', 'g', 'u', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'v', 'a', 'b', 's', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'v', 'a', 'b',
+  's', 'h', 's', 'a', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'v', 'a', 'b',
+  's', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'v', 'a', 'b', 's', 'w', 's',
+  'a', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'v', 'a', 'd', 'd', 'b', '_',
+  'm', 'a', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'v', 'a', 'd', 'd', 'h',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'A', '2', '_', 'v', 'a', 'd', 'd', 'h', 's', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'A', '2', '_', 'v', 'a', 'd', 'd', 'u', 'b', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'A', '2', '_', 'v', 'a', 'd', 'd', 'u', 'b', 's', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A',
+  '2', '_', 'v', 'a', 'd', 'd', 'u', 'h', 's', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2',
+  '_', 'v', 'a', 'd', 'd', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
   'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'v', 'a',
-  'v', 'g', 'u', 'w', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  'd', 'd', 'w', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'v', 'a', 'v', 'g',
+  'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'v', 'a', 'v', 'g', 'h', 'c', 'r',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'A', '2', '_', 'v', 'a', 'v', 'g', 'h', 'r', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'A', '2', '_', 'v', 'a', 'v', 'g', 'u', 'b', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'A', '2', '_', 'v', 'a', 'v', 'g', 'u', 'b', 'r', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A',
+  '2', '_', 'v', 'a', 'v', 'g', 'u', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_',
+  'v', 'a', 'v', 'g', 'u', 'h', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'v',
+  'a', 'v', 'g', 'u', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
   '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'v', 'a', 'v',
-  'g', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'v', 'a', 'v', 'g', 'w', 'c',
-  'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'v', 'a', 'v', 'g', 'w', 'r', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'A', '2', '_', 'v', 'c', 'm', 'p', 'b', 'e', 'q', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'A', '2', '_', 'v', 'c', 'm', 'p', 'b', 'g', 't', 'u', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'A', '2', '_', 'v', 'c', 'm', 'p', 'h', 'e', 'q', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'A', '2', '_', 'v', 'c', 'm', 'p', 'h', 'g', 't', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'A', '2', '_', 'v', 'c', 'm', 'p', 'h', 'g', 't', 'u', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'A', '2', '_', 'v', 'c', 'm', 'p', 'w', 'e', 'q', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A',
-  '2', '_', 'v', 'c', 'm', 'p', 'w', 'g', 't', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2',
-  '_', 'v', 'c', 'm', 'p', 'w', 'g', 't', 'u', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2',
-  '_', 'v', 'c', 'o', 'n', 'j', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'v', 'm',
-  'a', 'x', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'v', 'm', 'a', 'x', 'h',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'A', '2', '_', 'v', 'm', 'a', 'x', 'u', 'b', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'A', '2', '_', 'v', 'm', 'a', 'x', 'u', 'h', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'A', '2', '_', 'v', 'm', 'a', 'x', 'u', 'w', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2',
-  '_', 'v', 'm', 'a', 'x', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'v', 'm',
-  'i', 'n', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'v', 'm', 'i', 'n', 'h',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'A', '2', '_', 'v', 'm', 'i', 'n', 'u', 'b', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'A', '2', '_', 'v', 'm', 'i', 'n', 'u', 'h', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'A', '2', '_', 'v', 'm', 'i', 'n', 'u', 'w', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2',
-  '_', 'v', 'm', 'i', 'n', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'v', 'n',
-  'a', 'v', 'g', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'v', 'n', 'a', 'v',
-  'g', 'h', 'c', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'v', 'n', 'a', 'v',
-  'g', 'h', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'v', 'n', 'a', 'v', 'g',
+  'g', 'u', 'w', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'v', 'a', 'v', 'g',
   'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'v', 'n', 'a', 'v', 'g', 'w', 'c',
-  'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'v', 'n', 'a', 'v', 'g', 'w', 'r',
+  'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'v', 'a', 'v', 'g', 'w', 'c', 'r',
   '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'A', '2', '_', 'v', 'r', 'a', 'd', 'd', 'u', 'b', '\000',
+  'G', 'O', 'N', '_', 'A', '2', '_', 'v', 'a', 'v', 'g', 'w', 'r', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'A', '2', '_', 'v', 'c', 'm', 'p', 'b', 'e', 'q', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'A', '2', '_', 'v', 'c', 'm', 'p', 'b', 'g', 't', 'u', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'A', '2', '_', 'v', 'c', 'm', 'p', 'h', 'e', 'q', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'A', '2', '_', 'v', 'c', 'm', 'p', 'h', 'g', 't', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A',
+  '2', '_', 'v', 'c', 'm', 'p', 'h', 'g', 't', 'u', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A',
+  '2', '_', 'v', 'c', 'm', 'p', 'w', 'e', 'q', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2',
+  '_', 'v', 'c', 'm', 'p', 'w', 'g', 't', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_',
+  'v', 'c', 'm', 'p', 'w', 'g', 't', 'u', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_',
+  'v', 'c', 'o', 'n', 'j', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'v', 'm', 'a',
+  'x', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'v', 'm', 'a', 'x', 'h', '\000',
   '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'A', '2', '_', 'v', 'r', 'a', 'd', 'd', 'u', 'b', '_', 'a',
-  'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'v', 'r', 's', 'a', 'd', 'u',
-  'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'O', 'N', '_', 'A', '2', '_', 'v', 'm', 'a', 'x', 'u', 'b', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'A', '2', '_', 'v', 'm', 'a', 'x', 'u', 'h', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A',
+  '2', '_', 'v', 'm', 'a', 'x', 'u', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_',
+  'v', 'm', 'a', 'x', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'v', 'm', 'i',
+  'n', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'v', 'm', 'i', 'n', 'h', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'A', '2', '_', 'v', 'm', 'i', 'n', 'u', 'b', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'A', '2', '_', 'v', 'm', 'i', 'n', 'u', 'h', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A',
+  '2', '_', 'v', 'm', 'i', 'n', 'u', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_',
+  'v', 'm', 'i', 'n', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'v', 'n', 'a',
+  'v', 'g', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'v', 'n', 'a', 'v', 'g',
+  'h', 'c', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'v', 'n', 'a', 'v', 'g',
+  'h', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'v', 'n', 'a', 'v', 'g', 'w',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'A', '2', '_', 'v', 'n', 'a', 'v', 'g', 'w', 'c', 'r',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'A', '2', '_', 'v', 'n', 'a', 'v', 'g', 'w', 'r', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'A', '2', '_', 'v', 'r', 'a', 'd', 'd', 'u', 'b', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'A', '2', '_', 'v', 'r', 'a', 'd', 'd', 'u', 'b', '_', 'a', 'c',
+  'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
   'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'v', 'r', 's', 'a', 'd', 'u', 'b',
-  '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'A', '2', '_', 'v', 'r', 's', 'a', 'd', 'u', 'b', '_',
+  'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'v', 's', 'u', 'b', 'b',
+  '_', 'm', 'a', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
   'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'v', 's', 'u', 'b',
-  'b', '_', 'm', 'a', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'v', 's', 'u',
-  'b', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'v', 's', 'u', 'b', 'h', 's',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'A', '2', '_', 'v', 's', 'u', 'b', 'u', 'b', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'A', '2', '_', 'v', 's', 'u', 'b', 'u', 'b', 's', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'A', '2', '_', 'v', 's', 'u', 'b', 'u', 'h', 's', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'A', '2', '_', 'v', 's', 'u', 'b', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_',
-  'v', 's', 'u', 'b', 'w', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'x', 'o',
-  'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'x', 'o', 'r', 'p', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'A', '2', '_', 'z', 'x', 't', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_',
-  'z', 'x', 't', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '4', '_', 'a', 'd', 'd', 'p',
-  '_', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'A', '4', '_', 'a', 'n', 'd', 'n', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'A', '4', '_', 'a', 'n', 'd', 'n', 'p', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A',
-  '4', '_', 'b', 'i', 't', 's', 'p', 'l', 'i', 't', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A',
-  '4', '_', 'b', 'i', 't', 's', 'p', 'l', 'i', 't', 'i', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'A', '4', '_', 'b', 'o', 'u', 'n', 'd', 's', 'c', 'h', 'e', 'c', 'k', '\000',
+  'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'v', 's', 'u', 'b', 'h', 's', '\000',
   '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'A', '4', '_', 'c', 'm', 'p', 'b', 'e', 'q', '\000', '_', '_',
+  'O', 'N', '_', 'A', '2', '_', 'v', 's', 'u', 'b', 'u', 'b', '\000', '_', '_',
   'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'A', '4', '_', 'c', 'm', 'p', 'b', 'e', 'q', 'i', '\000', '_', '_', 'b',
+  '_', 'A', '2', '_', 'v', 's', 'u', 'b', 'u', 'b', 's', '\000', '_', '_', 'b',
   'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'A', '4', '_', 'c', 'm', 'p', 'b', 'g', 't', '\000', '_', '_', 'b', 'u', 'i',
+  'A', '2', '_', 'v', 's', 'u', 'b', 'u', 'h', 's', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A',
+  '2', '_', 'v', 's', 'u', 'b', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'v',
+  's', 'u', 'b', 'w', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'x', 'o', 'r',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'A', '2', '_', 'x', 'o', 'r', 'p', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'A', '2', '_', 'z', 'x', 't', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '2', '_', 'z',
+  'x', 't', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '4', '_', 'a', 'n', 'd', 'n', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'A', '4', '_', 'a', 'n', 'd', 'n', 'p', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'A', '4', '_', 'b', 'i', 't', 's', 'p', 'l', 'i', 't', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'A', '4', '_', 'b', 'i', 't', 's', 'p', 'l', 'i', 't', 'i', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'A', '4', '_', 'b', 'o', 'u', 'n', 'd', 's', 'c', 'h', 'e', 'c', 'k',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'A', '4', '_', 'c', 'm', 'p', 'b', 'e', 'q', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'A', '4', '_', 'c', 'm', 'p', 'b', 'e', 'q', 'i', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'A', '4', '_', 'c', 'm', 'p', 'b', 'g', 't', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A',
+  '4', '_', 'c', 'm', 'p', 'b', 'g', 't', 'i', '\000', '_', '_', 'b', 'u', 'i',
   'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '4',
-  '_', 'c', 'm', 'p', 'b', 'g', 't', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  '_', 'c', 'm', 'p', 'b', 'g', 't', 'u', '\000', '_', '_', 'b', 'u', 'i', 'l',
   't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '4', '_',
-  'c', 'm', 'p', 'b', 'g', 't', 'u', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '4', '_', 'c',
-  'm', 'p', 'b', 'g', 't', 'u', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '4', '_', 'c',
-  'm', 'p', 'h', 'e', 'q', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  'c', 'm', 'p', 'b', 'g', 't', 'u', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '4', '_',
+  'c', 'm', 'p', 'h', 'e', 'q', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '4', '_', 'c', 'm',
+  'p', 'h', 'e', 'q', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
   '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '4', '_', 'c', 'm', 'p',
-  'h', 'e', 'q', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '4', '_', 'c', 'm', 'p', 'h',
-  'g', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'h', 'g', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '4', '_', 'c', 'm', 'p', 'h', 'g',
+  't', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
   'X', 'A', 'G', 'O', 'N', '_', 'A', '4', '_', 'c', 'm', 'p', 'h', 'g', 't',
-  'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'u', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
   'A', 'G', 'O', 'N', '_', 'A', '4', '_', 'c', 'm', 'p', 'h', 'g', 't', 'u',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'A', '4', '_', 'c', 'm', 'p', 'h', 'g', 't', 'u', 'i',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'A', '4', '_', 'c', 'o', 'm', 'b', 'i', 'n', 'e', 'i',
   'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
   'A', 'G', 'O', 'N', '_', 'A', '4', '_', 'c', 'o', 'm', 'b', 'i', 'n', 'e',
   'i', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
@@ -18572,1537 +25695,1514 @@
   'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
   'A', '4', '_', 'r', 'o', 'u', 'n', 'd', '_', 'r', 'r', '_', 's', 'a', 't',
   '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'A', '4', '_', 's', 'u', 'b', 'p', '_', 'c', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'A', '4', '_', 't', 'f', 'r', 'c', 'p', 'p', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'A', '4', '_', 't', 'f', 'r', 'p', 'c', 'p', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '4',
-  '_', 't', 'l', 'b', 'm', 'a', 't', 'c', 'h', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '4',
-  '_', 'v', 'c', 'm', 'p', 'b', 'e', 'q', '_', 'a', 'n', 'y', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'A', '4', '_', 'v', 'c', 'm', 'p', 'b', 'e', 'q', 'i', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'A', '4', '_', 'v', 'c', 'm', 'p', 'b', 'g', 't', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'A', '4', '_', 'v', 'c', 'm', 'p', 'b', 'g', 't', 'i', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'A', '4', '_', 'v', 'c', 'm', 'p', 'b', 'g', 't', 'u', 'i', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'A', '4', '_', 'v', 'c', 'm', 'p', 'h', 'e', 'q', 'i', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'A', '4', '_', 'v', 'c', 'm', 'p', 'h', 'g', 't', 'i', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'A', '4', '_', 'v', 'c', 'm', 'p', 'h', 'g', 't', 'u', 'i', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'A', '4', '_', 'v', 'c', 'm', 'p', 'w', 'e', 'q', 'i', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'A', '4', '_', 'v', 'c', 'm', 'p', 'w', 'g', 't', 'i', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'A', '4', '_', 'v', 'c', 'm', 'p', 'w', 'g', 't', 'u', 'i', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'A', '4', '_', 'v', 'r', 'm', 'a', 'x', 'h', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'A', '4', '_', 'v', 'r', 'm', 'a', 'x', 'u', 'h', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'A', '4', '_', 'v', 'r', 'm', 'a', 'x', 'u', 'w', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A',
-  '4', '_', 'v', 'r', 'm', 'a', 'x', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '4', '_',
-  'v', 'r', 'm', 'i', 'n', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '4', '_', 'v', 'r',
-  'm', 'i', 'n', 'u', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '4', '_', 'v', 'r', 'm',
-  'i', 'n', 'u', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '4', '_', 'v', 'r', 'm', 'i',
-  'n', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'A', '5', '_', 'A', 'C', 'S', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'A', '5', '_', 'v', 'a', 'd', 'd', 'h', 'u', 'b', 's', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'A', '6', '_', 'v', 'c', 'm', 'p', 'b', 'e', 'q', '_', 'n', 'o', 't',
+  'G', 'O', 'N', '_', 'A', '4', '_', 't', 'l', 'b', 'm', 'a', 't', 'c', 'h',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'A', '4', '_', 'v', 'c', 'm', 'p', 'b', 'e', 'q', '_',
   'a', 'n', 'y', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '6', '_', 'v', 'm', 'i', 'n', 'u',
-  'b', '_', 'R', 'd', 'P', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'C', '2', '_', 'a', 'l', 'l',
-  '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'C', '2', '_', 'a', 'n', 'd', '\000', '_', '_', 'b',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '4', '_', 'v', 'c', 'm', 'p', 'b',
+  'e', 'q', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '4', '_', 'v', 'c', 'm', 'p', 'b',
+  'g', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'A', '4', '_', 'v', 'c', 'm', 'p', 'b', 'g',
+  't', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'A', '4', '_', 'v', 'c', 'm', 'p', 'b', 'g',
+  't', 'u', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '4', '_', 'v', 'c', 'm', 'p', 'h',
+  'e', 'q', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '4', '_', 'v', 'c', 'm', 'p', 'h',
+  'g', 't', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '4', '_', 'v', 'c', 'm', 'p', 'h',
+  'g', 't', 'u', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '4', '_', 'v', 'c', 'm', 'p',
+  'w', 'e', 'q', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '4', '_', 'v', 'c', 'm', 'p',
+  'w', 'g', 't', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '4', '_', 'v', 'c', 'm', 'p',
+  'w', 'g', 't', 'u', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '4', '_', 'v', 'r', 'm',
+  'a', 'x', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '4', '_', 'v', 'r', 'm', 'a', 'x',
+  'u', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'A', '4', '_', 'v', 'r', 'm', 'a', 'x', 'u',
+  'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'A', '4', '_', 'v', 'r', 'm', 'a', 'x', 'w', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'A', '4', '_', 'v', 'r', 'm', 'i', 'n', 'h', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'A', '4', '_', 'v', 'r', 'm', 'i', 'n', 'u', 'h', '\000', '_', '_', 'b',
   'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'C', '2', '_', 'a', 'n', 'd', 'n', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'A', '4', '_', 'v', 'r', 'm', 'i', 'n', 'u', 'w', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A',
+  '4', '_', 'v', 'r', 'm', 'i', 'n', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '5', '_',
+  'v', 'a', 'd', 'd', 'h', 'u', 'b', 's', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A', '6', '_',
+  'v', 'c', 'm', 'p', 'b', 'e', 'q', '_', 'n', 'o', 't', 'a', 'n', 'y', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'A', '7', '_', 'c', 'l', 'i', 'p', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'A',
+  '7', '_', 'c', 'r', 'o', 'u', 'n', 'd', 'd', '_', 'r', 'i', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'A', '7', '_', 'c', 'r', 'o', 'u', 'n', 'd', 'd', '_', 'r', 'r', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'A', '7', '_', 'v', 'c', 'l', 'i', 'p', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'C', '2', '_', 'a', 'l', 'l', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
   'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'C', '2', '_', 'a',
-  'n', 'y', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'C', '2', '_', 'b', 'i', 't', 's', 'c',
-  'l', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'C', '2', '_', 'b', 'i', 't', 's', 'c', 'l',
-  'r', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'C', '2', '_', 'b', 'i', 't', 's', 's', 'e',
-  't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'C', '2', '_', 'c', 'm', 'p', 'e', 'q', '\000', '_',
+  'n', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'C', '2', '_', 'a', 'n', 'd', 'n', '\000', '_',
   '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'C', '2', '_', 'c', 'm', 'p', 'e', 'q', 'i', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'C', '2', '_', 'c', 'm', 'p', 'e', 'q', 'p', '\000', '_', '_', 'b', 'u', 'i',
+  'N', '_', 'C', '2', '_', 'a', 'n', 'y', '8', '\000', '_', '_', 'b', 'u', 'i',
   'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'C', '2',
-  '_', 'c', 'm', 'p', 'g', 'e', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'C', '2', '_', 'c',
-  'm', 'p', 'g', 'e', 'u', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'C', '2', '_', 'c', 'm',
-  'p', 'g', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'C', '2', '_', 'c', 'm', 'p', 'g', 't',
-  'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'C', '2', '_', 'c', 'm', 'p', 'g', 't', 'p', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'C', '2', '_', 'c', 'm', 'p', 'g', 't', 'u', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'C', '2', '_', 'c', 'm', 'p', 'g', 't', 'u', 'i', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'C', '2', '_', 'c', 'm', 'p', 'g', 't', 'u', 'p', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'C',
-  '2', '_', 'c', 'm', 'p', 'l', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'C', '2', '_', 'c',
-  'm', 'p', 'l', 't', 'u', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'C', '2', '_', 'm', 'a', 's',
-  'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'C', '2', '_', 'm', 'u', 'x', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'C', '2', '_', 'm', 'u', 'x', 'i', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  '_', 'b', 'i', 't', 's', 'c', 'l', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l',
   't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'C', '2', '_',
-  'm', 'u', 'x', 'i', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'C', '2', '_', 'm', 'u', 'x',
-  'r', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'C', '2', '_', 'n', 'o', 't', '\000', '_', '_',
+  'b', 'i', 't', 's', 'c', 'l', 'r', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'C', '2', '_',
+  'b', 'i', 't', 's', 's', 'e', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'C', '2', '_', 'c',
+  'm', 'p', 'e', 'q', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'C', '2', '_', 'c', 'm', 'p', 'e',
+  'q', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'C', '2', '_', 'c', 'm', 'p', 'e', 'q', 'p',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'C', '2', '_', 'c', 'm', 'p', 'g', 'e', 'i', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'C', '2', '_', 'c', 'm', 'p', 'g', 'e', 'u', 'i', '\000', '_', '_',
   'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'C', '2', '_', 'o', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'C', '2', '_', 'o', 'r',
-  'n', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'C', '2', '_', 'p', 'x', 'f', 'e', 'r', '_', 'm',
-  'a', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'C', '2', '_', 't', 'f', 'r', 'p', 'r', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'C', '2', '_', 't', 'f', 'r', 'r', 'p', '\000', '_', '_', 'b',
+  '_', 'C', '2', '_', 'c', 'm', 'p', 'g', 't', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'C', '2',
+  '_', 'c', 'm', 'p', 'g', 't', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'C', '2', '_', 'c',
+  'm', 'p', 'g', 't', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'C', '2', '_', 'c', 'm', 'p',
+  'g', 't', 'u', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'C', '2', '_', 'c', 'm', 'p', 'g', 't',
+  'u', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'C', '2', '_', 'c', 'm', 'p', 'g', 't', 'u',
+  'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'C', '2', '_', 'c', 'm', 'p', 'l', 't', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'C', '2', '_', 'c', 'm', 'p', 'l', 't', 'u', '\000', '_', '_', 'b',
   'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'C', '2', '_', 'v', 'i', 't', 'p', 'a', 'c', 'k', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'C',
-  '2', '_', 'v', 'm', 'u', 'x', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'C', '2', '_', 'x', 'o',
+  'C', '2', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'C', '2', '_', 'm',
+  'u', 'x', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'C', '2', '_', 'm', 'u', 'x', 'i', 'i', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'C', '2', '_', 'm', 'u', 'x', 'i', 'r', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'C', '2', '_', 'm', 'u', 'x', 'r', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'C', '2', '_',
+  'n', 'o', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'C', '2', '_', 'o', 'r', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'C', '2', '_', 'o', 'r', 'n', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'C', '2', '_', 'p',
+  'x', 'f', 'e', 'r', '_', 'm', 'a', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'C', '2', '_',
+  't', 'f', 'r', 'p', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'C', '2', '_', 't', 'f', 'r',
+  'r', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'C', '2', '_', 'v', 'i', 't', 'p', 'a', 'c',
+  'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'C', '2', '_', 'v', 'm', 'u', 'x', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'C', '2', '_', 'x', 'o', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'C', '4', '_', 'a',
+  'n', 'd', '_', 'a', 'n', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'C', '4', '_', 'a', 'n',
+  'd', '_', 'a', 'n', 'd', 'n', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'C', '4', '_', 'a', 'n',
+  'd', '_', 'o', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'C', '4', '_', 'a', 'n', 'd', '_',
+  'o', 'r', 'n', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'C', '4', '_', 'c', 'm', 'p', 'l', 't',
+  'e', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'C', '4', '_', 'c', 'm', 'p', 'l', 't', 'e', 'i',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'C', '4', '_', 'c', 'm', 'p', 'l', 't', 'e', 'u', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'C', '4', '_', 'c', 'm', 'p', 'l', 't', 'e', 'u', 'i', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'C', '4', '_', 'c', 'm', 'p', 'n', 'e', 'q', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'C', '4', '_', 'c', 'm', 'p', 'n', 'e', 'q', 'i', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'C', '4', '_', 'f', 'a', 's', 't', 'c', 'o', 'r', 'n', 'e', 'r', '9', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'C', '4', '_', 'f', 'a', 's', 't', 'c', 'o', 'r', 'n', 'e',
+  'r', '9', '_', 'n', 'o', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'C', '4', '_', 'n', 'b',
+  'i', 't', 's', 'c', 'l', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'C', '4', '_', 'n', 'b',
+  'i', 't', 's', 'c', 'l', 'r', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'C', '4', '_', 'n',
+  'b', 'i', 't', 's', 's', 'e', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'C', '4', '_', 'o',
+  'r', '_', 'a', 'n', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'C', '4', '_', 'o', 'r', '_',
+  'a', 'n', 'd', 'n', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'C', '4', '_', 'o', 'r', '_', 'o',
   'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'C', '4', '_', 'a', 'n', 'd', '_', 'a', 'n', 'd',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'C', '4', '_', 'a', 'n', 'd', '_', 'a', 'n', 'd', 'n',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'C', '4', '_', 'a', 'n', 'd', '_', 'o', 'r', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'C', '4', '_', 'a', 'n', 'd', '_', 'o', 'r', 'n', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'C', '4', '_', 'c', 'm', 'p', 'l', 't', 'e', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'C',
-  '4', '_', 'c', 'm', 'p', 'l', 't', 'e', 'i', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'C', '4',
-  '_', 'c', 'm', 'p', 'l', 't', 'e', 'u', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'C', '4', '_',
-  'c', 'm', 'p', 'l', 't', 'e', 'u', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'C', '4', '_',
-  'c', 'm', 'p', 'n', 'e', 'q', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'C', '4', '_', 'c', 'm',
-  'p', 'n', 'e', 'q', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'C', '4', '_', 'f', 'a', 's',
-  't', 'c', 'o', 'r', 'n', 'e', 'r', '9', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'C', '4', '_',
-  'f', 'a', 's', 't', 'c', 'o', 'r', 'n', 'e', 'r', '9', '_', 'n', 'o', 't',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'C', '4', '_', 'n', 'b', 'i', 't', 's', 'c', 'l', 'r',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'C', '4', '_', 'n', 'b', 'i', 't', 's', 'c', 'l', 'r',
-  'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'C', '4', '_', 'n', 'b', 'i', 't', 's', 's', 'e',
-  't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'C', '4', '_', 'o', 'r', '_', 'a', 'n', 'd', '\000',
+  'A', 'G', 'O', 'N', '_', 'C', '4', '_', 'o', 'r', '_', 'o', 'r', 'n', '\000',
   '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'C', '4', '_', 'o', 'r', '_', 'a', 'n', 'd', 'n', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'C', '4', '_', 'o', 'r', '_', 'o', 'r', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'C',
-  '4', '_', 'o', 'r', '_', 'o', 'r', 'n', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'F', '2', '_',
-  'c', 'o', 'n', 'v', '_', 'd', '2', 'd', 'f', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'F', '2',
-  '_', 'c', 'o', 'n', 'v', '_', 'd', '2', 's', 'f', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'F',
-  '2', '_', 'c', 'o', 'n', 'v', '_', 'd', 'f', '2', 'd', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'F', '2', '_', 'c', 'o', 'n', 'v', '_', 'd', 'f', '2', 'd', '_', 'c', 'h',
-  'o', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'O', 'N', '_', 'F', '2', '_', 'c', 'o', 'n', 'v', '_', 'd', '2', 'd', 'f',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'F', '2', '_', 'c', 'o', 'n', 'v', '_', 'd', '2', 's',
+  'f', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'F', '2', '_', 'c', 'o', 'n', 'v', '_', 'd', 'f',
+  '2', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
   'X', 'A', 'G', 'O', 'N', '_', 'F', '2', '_', 'c', 'o', 'n', 'v', '_', 'd',
-  'f', '2', 's', 'f', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'F', '2', '_', 'c', 'o', 'n', 'v',
-  '_', 'd', 'f', '2', 'u', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'F', '2', '_', 'c', 'o',
-  'n', 'v', '_', 'd', 'f', '2', 'u', 'd', '_', 'c', 'h', 'o', 'p', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'F', '2', '_', 'c', 'o', 'n', 'v', '_', 'd', 'f', '2', 'u', 'w',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'F', '2', '_', 'c', 'o', 'n', 'v', '_', 'd', 'f', '2',
-  'u', 'w', '_', 'c', 'h', 'o', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'F', '2', '_', 'c',
-  'o', 'n', 'v', '_', 'd', 'f', '2', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  'f', '2', 'd', '_', 'c', 'h', 'o', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l',
   't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'F', '2', '_',
-  'c', 'o', 'n', 'v', '_', 'd', 'f', '2', 'w', '_', 'c', 'h', 'o', 'p', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'F', '2', '_', 'c', 'o', 'n', 'v', '_', 's', 'f', '2', 'd',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'F', '2', '_', 'c', 'o', 'n', 'v', '_', 's', 'f', '2',
-  'd', '_', 'c', 'h', 'o', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'F', '2', '_', 'c', 'o',
-  'n', 'v', '_', 's', 'f', '2', 'd', 'f', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'F', '2', '_',
-  'c', 'o', 'n', 'v', '_', 's', 'f', '2', 'u', 'd', '\000', '_', '_', 'b', 'u',
+  'c', 'o', 'n', 'v', '_', 'd', 'f', '2', 's', 'f', '\000', '_', '_', 'b', 'u',
   'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'F',
-  '2', '_', 'c', 'o', 'n', 'v', '_', 's', 'f', '2', 'u', 'd', '_', 'c', 'h',
+  '2', '_', 'c', 'o', 'n', 'v', '_', 'd', 'f', '2', 'u', 'd', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'F', '2', '_', 'c', 'o', 'n', 'v', '_', 'd', 'f', '2', 'u', 'd', '_',
+  'c', 'h', 'o', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'F', '2', '_', 'c', 'o', 'n', 'v',
+  '_', 'd', 'f', '2', 'u', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'F', '2', '_', 'c', 'o',
+  'n', 'v', '_', 'd', 'f', '2', 'u', 'w', '_', 'c', 'h', 'o', 'p', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'F', '2', '_', 'c', 'o', 'n', 'v', '_', 'd', 'f', '2', 'w', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'F', '2', '_', 'c', 'o', 'n', 'v', '_', 'd', 'f', '2', 'w',
+  '_', 'c', 'h', 'o', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'F', '2', '_', 'c', 'o', 'n',
+  'v', '_', 's', 'f', '2', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'F', '2', '_', 'c', 'o',
+  'n', 'v', '_', 's', 'f', '2', 'd', '_', 'c', 'h', 'o', 'p', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'F', '2', '_', 'c', 'o', 'n', 'v', '_', 's', 'f', '2', 'd', 'f', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'F', '2', '_', 'c', 'o', 'n', 'v', '_', 's', 'f', '2', 'u',
+  'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'F', '2', '_', 'c', 'o', 'n', 'v', '_', 's', 'f',
+  '2', 'u', 'd', '_', 'c', 'h', 'o', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'F', '2', '_',
+  'c', 'o', 'n', 'v', '_', 's', 'f', '2', 'u', 'w', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'F',
+  '2', '_', 'c', 'o', 'n', 'v', '_', 's', 'f', '2', 'u', 'w', '_', 'c', 'h',
   'o', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
   'X', 'A', 'G', 'O', 'N', '_', 'F', '2', '_', 'c', 'o', 'n', 'v', '_', 's',
-  'f', '2', 'u', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'F', '2', '_', 'c', 'o', 'n', 'v',
-  '_', 's', 'f', '2', 'u', 'w', '_', 'c', 'h', 'o', 'p', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'F', '2', '_', 'c', 'o', 'n', 'v', '_', 's', 'f', '2', 'w', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'F', '2', '_', 'c', 'o', 'n', 'v', '_', 's', 'f', '2', 'w', '_', 'c',
-  'h', 'o', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'f', '2', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
   'E', 'X', 'A', 'G', 'O', 'N', '_', 'F', '2', '_', 'c', 'o', 'n', 'v', '_',
-  'u', 'd', '2', 'd', 'f', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'F', '2', '_', 'c', 'o', 'n',
-  'v', '_', 'u', 'd', '2', 's', 'f', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'F', '2', '_', 'c',
-  'o', 'n', 'v', '_', 'u', 'w', '2', 'd', 'f', '\000', '_', '_', 'b', 'u', 'i',
+  's', 'f', '2', 'w', '_', 'c', 'h', 'o', 'p', '\000', '_', '_', 'b', 'u', 'i',
   'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'F', '2',
-  '_', 'c', 'o', 'n', 'v', '_', 'u', 'w', '2', 's', 'f', '\000', '_', '_', 'b',
+  '_', 'c', 'o', 'n', 'v', '_', 'u', 'd', '2', 'd', 'f', '\000', '_', '_', 'b',
   'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'F', '2', '_', 'c', 'o', 'n', 'v', '_', 'w', '2', 'd', 'f', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'F', '2', '_', 'c', 'o', 'n', 'v', '_', 'w', '2', 's', 'f', '\000', '_',
+  'F', '2', '_', 'c', 'o', 'n', 'v', '_', 'u', 'd', '2', 's', 'f', '\000', '_',
   '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'F', '2', '_', 'd', 'f', 'a', 'd', 'd', '\000', '_', '_', 'b', 'u',
+  'N', '_', 'F', '2', '_', 'c', 'o', 'n', 'v', '_', 'u', 'w', '2', 'd', 'f',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'F', '2', '_', 'c', 'o', 'n', 'v', '_', 'u', 'w', '2',
+  's', 'f', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'F', '2', '_', 'c', 'o', 'n', 'v', '_', 'w',
+  '2', 'd', 'f', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'F', '2', '_', 'c', 'o', 'n', 'v', '_',
+  'w', '2', 's', 'f', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'F', '2', '_', 'd', 'f', 'a', 'd',
+  'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'F', '2', '_', 'd', 'f', 'c', 'l', 'a', 's', 's',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'F', '2', '_', 'd', 'f', 'c', 'm', 'p', 'e', 'q', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'F', '2', '_', 'd', 'f', 'c', 'm', 'p', 'g', 'e', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'F', '2', '_', 'd', 'f', 'c', 'm', 'p', 'g', 't', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'F', '2', '_', 'd', 'f', 'c', 'm', 'p', 'u', 'o', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'F', '2', '_', 'd', 'f', 'i', 'm', 'm', '_', 'n', '\000', '_', '_', 'b', 'u',
   'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'F',
-  '2', '_', 'd', 'f', 'c', 'l', 'a', 's', 's', '\000', '_', '_', 'b', 'u', 'i',
+  '2', '_', 'd', 'f', 'i', 'm', 'm', '_', 'p', '\000', '_', '_', 'b', 'u', 'i',
   'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'F', '2',
-  '_', 'd', 'f', 'c', 'm', 'p', 'e', 'q', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'F', '2', '_',
-  'd', 'f', 'c', 'm', 'p', 'g', 'e', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'F', '2', '_', 'd',
-  'f', 'c', 'm', 'p', 'g', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  '_', 'd', 'f', 'm', 'a', 'x', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
   'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'F', '2', '_', 'd', 'f',
-  'c', 'm', 'p', 'u', 'o', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'F', '2', '_', 'd', 'f', 'i',
-  'm', 'm', '_', 'n', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'F', '2', '_', 'd', 'f', 'i', 'm',
-  'm', '_', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'F', '2', '_', 'd', 'f', 's', 'u', 'b',
+  'm', 'i', 'n', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'F', '2', '_', 'd', 'f', 'm', 'p', 'y',
+  'f', 'i', 'x', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'F', '2', '_', 'd', 'f', 'm', 'p', 'y',
+  'h', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'F', '2', '_', 'd', 'f', 'm', 'p', 'y', 'l',
+  'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'F', '2', '_', 'd', 'f', 'm', 'p', 'y', 'l', 'l',
   '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'F', '2', '_', 's', 'f', 'a', 'd', 'd', '\000', '_', '_',
+  'G', 'O', 'N', '_', 'F', '2', '_', 'd', 'f', 's', 'u', 'b', '\000', '_', '_',
   'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'F', '2', '_', 's', 'f', 'c', 'l', 'a', 's', 's', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'F', '2', '_', 's', 'f', 'c', 'm', 'p', 'e', 'q', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'F',
-  '2', '_', 's', 'f', 'c', 'm', 'p', 'g', 'e', '\000', '_', '_', 'b', 'u', 'i',
+  '_', 'F', '2', '_', 's', 'f', 'a', 'd', 'd', '\000', '_', '_', 'b', 'u', 'i',
   'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'F', '2',
-  '_', 's', 'f', 'c', 'm', 'p', 'g', 't', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  '_', 's', 'f', 'c', 'l', 'a', 's', 's', '\000', '_', '_', 'b', 'u', 'i', 'l',
   't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'F', '2', '_',
-  's', 'f', 'c', 'm', 'p', 'u', 'o', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  's', 'f', 'c', 'm', 'p', 'e', 'q', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
   'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'F', '2', '_', 's',
-  'f', 'f', 'i', 'x', 'u', 'p', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'F', '2', '_', 's',
-  'f', 'f', 'i', 'x', 'u', 'p', 'n', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'F', '2', '_', 's',
-  'f', 'f', 'i', 'x', 'u', 'p', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'F', '2', '_', 's',
-  'f', 'f', 'm', 'a', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'f', 'c', 'm', 'p', 'g', 'e', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'F', '2', '_', 's', 'f',
+  'c', 'm', 'p', 'g', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'F', '2', '_', 's', 'f', 'c',
+  'm', 'p', 'u', 'o', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'F', '2', '_', 's', 'f', 'f', 'i',
+  'x', 'u', 'p', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'F', '2', '_', 's', 'f', 'f', 'i',
+  'x', 'u', 'p', 'n', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'F', '2', '_', 's', 'f', 'f', 'i',
+  'x', 'u', 'p', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
   'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'F', '2', '_', 's', 'f', 'f', 'm',
-  'a', '_', 'l', 'i', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'F', '2', '_', 's', 'f', 'f',
-  'm', 'a', '_', 's', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'F', '2', '_', 's', 'f', 'f',
-  'm', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'F', '2', '_', 's', 'f', 'f', 'm', 's', '_',
-  'l', 'i', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'F', '2', '_', 's', 'f', 'i', 'm', 'm',
-  '_', 'n', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'F', '2', '_', 's', 'f', 'i', 'm', 'm', '_',
-  'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'F', '2', '_', 's', 'f', 'i', 'n', 'v', 's', 'q',
-  'r', 't', 'a', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'F', '2', '_', 's', 'f', 'm', 'a', 'x',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'F', '2', '_', 's', 'f', 'm', 'i', 'n', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'F', '2', '_', 's', 'f', 'm', 'p', 'y', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'F', '2',
-  '_', 's', 'f', 'r', 'e', 'c', 'i', 'p', 'a', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'F', '2',
-  '_', 's', 'f', 's', 'u', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'L', '2', '_', 'l', 'o',
-  'a', 'd', 'w', '_', 'l', 'o', 'c', 'k', 'e', 'd', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'L',
-  '4', '_', 'l', 'o', 'a', 'd', 'd', '_', 'l', 'o', 'c', 'k', 'e', 'd', '\000',
+  'a', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'F', '2', '_', 's', 'f', 'f', 'm', 'a', '_', 'l',
+  'i', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'F', '2', '_', 's', 'f', 'f', 'm', 'a', '_',
+  's', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'F', '2', '_', 's', 'f', 'f', 'm', 's', '\000',
   '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'M', '2', '_', 'a', 'c', 'c', 'i', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M',
-  '2', '_', 'a', 'c', 'c', 'i', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'c',
-  'm', 'a', 'c', 'i', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'c',
-  'm', 'a', 'c', 'r', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'c',
-  'm', 'a', 'c', 's', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'c',
-  'm', 'a', 'c', 's', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'c',
-  'm', 'a', 'c', 's', 'c', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_',
-  'c', 'm', 'a', 'c', 's', 'c', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2',
-  '_', 'c', 'm', 'p', 'y', 'i', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2',
-  '_', 'c', 'm', 'p', 'y', 'r', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2',
-  '_', 'c', 'm', 'p', 'y', 'r', 's', '_', 's', '0', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M',
-  '2', '_', 'c', 'm', 'p', 'y', 'r', 's', '_', 's', '1', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'M', '2', '_', 'c', 'm', 'p', 'y', 'r', 's', 'c', '_', 's', '0', '\000', '_',
+  'O', 'N', '_', 'F', '2', '_', 's', 'f', 'f', 'm', 's', '_', 'l', 'i', 'b',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'F', '2', '_', 's', 'f', 'i', 'm', 'm', '_', 'n', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'F', '2', '_', 's', 'f', 'i', 'm', 'm', '_', 'p', '\000', '_',
   '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'M', '2', '_', 'c', 'm', 'p', 'y', 'r', 's', 'c', '_', 's', '1',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'M', '2', '_', 'c', 'm', 'p', 'y', 's', '_', 's', '0',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'M', '2', '_', 'c', 'm', 'p', 'y', 's', '_', 's', '1',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'M', '2', '_', 'c', 'm', 'p', 'y', 's', 'c', '_', 's',
-  '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'c', 'm', 'p', 'y', 's', 'c', '_',
-  's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'c', 'n', 'a', 'c', 's', '_',
+  'N', '_', 'F', '2', '_', 's', 'f', 'm', 'a', 'x', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'F',
+  '2', '_', 's', 'f', 'm', 'i', 'n', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'F', '2', '_', 's',
+  'f', 'm', 'p', 'y', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'F', '2', '_', 's', 'f', 's', 'u',
+  'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'L', '2', '_', 'l', 'o', 'a', 'd', 'w', '_', 'l',
+  'o', 'c', 'k', 'e', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'L', '4', '_', 'l', 'o', 'a',
+  'd', 'd', '_', 'l', 'o', 'c', 'k', 'e', 'd', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2',
+  '_', 'a', 'c', 'c', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'a', 'c', 'c',
+  'i', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'c', 'm', 'a', 'c', 'i', '_',
   's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'c', 'n', 'a', 'c', 's', '_',
+  'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'c', 'm', 'a', 'c', 'r', '_',
+  's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'c', 'm', 'a', 'c', 's', '_',
+  's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'c', 'm', 'a', 'c', 's', '_',
   's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'c', 'n', 'a', 'c', 's', 'c',
+  'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'c', 'm', 'a', 'c', 's', 'c',
   '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'c', 'n', 'a', 'c', 's',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'c', 'm', 'a', 'c', 's',
   'c', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'd', 'p', 'm', 'p',
-  'y', 's', 's', '_', 'a', 'c', 'c', '_', 's', '0', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M',
-  '2', '_', 'd', 'p', 'm', 'p', 'y', 's', 's', '_', 'n', 'a', 'c', '_', 's',
-  '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'd', 'p', 'm', 'p', 'y', 's', 's',
-  '_', 'r', 'n', 'd', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'd',
-  'p', 'm', 'p', 'y', 's', 's', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2',
-  '_', 'd', 'p', 'm', 'p', 'y', 'u', 'u', '_', 'a', 'c', 'c', '_', 's', '0',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'M', '2', '_', 'd', 'p', 'm', 'p', 'y', 'u', 'u', '_',
-  'n', 'a', 'c', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'd', 'p',
-  'm', 'p', 'y', 'u', 'u', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'c', 'm', 'p', 'y',
+  'i', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'c', 'm', 'p', 'y',
+  'r', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'c', 'm', 'p', 'y',
+  'r', 's', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'c', 'm', 'p',
+  'y', 'r', 's', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'c', 'm',
+  'p', 'y', 'r', 's', 'c', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l',
   't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_',
-  'h', 'm', 'm', 'p', 'y', 'h', '_', 'r', 's', '1', '\000', '_', '_', 'b', 'u',
+  'c', 'm', 'p', 'y', 'r', 's', 'c', '_', 's', '1', '\000', '_', '_', 'b', 'u',
   'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M',
-  '2', '_', 'h', 'm', 'm', 'p', 'y', 'h', '_', 's', '1', '\000', '_', '_', 'b',
+  '2', '_', 'c', 'm', 'p', 'y', 's', '_', 's', '0', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M',
+  '2', '_', 'c', 'm', 'p', 'y', 's', '_', 's', '1', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M',
+  '2', '_', 'c', 'm', 'p', 'y', 's', 'c', '_', 's', '0', '\000', '_', '_', 'b',
   'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'M', '2', '_', 'h', 'm', 'm', 'p', 'y', 'l', '_', 'r', 's', '1', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'M', '2', '_', 'h', 'm', 'm', 'p', 'y', 'l', '_', 's', '1', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'M', '2', '_', 'm', 'a', 'c', 'i', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M',
-  '2', '_', 'm', 'a', 'c', 's', 'i', 'n', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_',
-  'm', 'a', 'c', 's', 'i', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'm',
-  'a', 'c', 'h', 's', '_', 'r', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_',
-  'm', 'm', 'a', 'c', 'h', 's', '_', 'r', 's', '1', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M',
-  '2', '_', 'm', 'm', 'a', 'c', 'h', 's', '_', 's', '0', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'M', '2', '_', 'm', 'm', 'a', 'c', 'h', 's', '_', 's', '1', '\000', '_', '_',
+  'M', '2', '_', 'c', 'm', 'p', 'y', 's', 'c', '_', 's', '1', '\000', '_', '_',
   'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'M', '2', '_', 'm', 'm', 'a', 'c', 'l', 's', '_', 'r', 's', '0', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'M', '2', '_', 'm', 'm', 'a', 'c', 'l', 's', '_', 'r', 's',
-  '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'm', 'a', 'c', 'l', 's', '_',
-  's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'm', 'a', 'c', 'l', 's',
-  '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'm', 'a', 'c', 'u',
-  'h', 's', '_', 'r', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'm',
-  'a', 'c', 'u', 'h', 's', '_', 'r', 's', '1', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2',
-  '_', 'm', 'm', 'a', 'c', 'u', 'h', 's', '_', 's', '0', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'M', '2', '_', 'm', 'm', 'a', 'c', 'u', 'h', 's', '_', 's', '1', '\000', '_',
+  '_', 'M', '2', '_', 'c', 'n', 'a', 'c', 's', '_', 's', '0', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'M', '2', '_', 'c', 'n', 'a', 'c', 's', '_', 's', '1', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'M', '2', '_', 'c', 'n', 'a', 'c', 's', 'c', '_', 's', '0', '\000', '_',
   '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'M', '2', '_', 'm', 'm', 'a', 'c', 'u', 'l', 's', '_', 'r', 's',
+  'N', '_', 'M', '2', '_', 'c', 'n', 'a', 'c', 's', 'c', '_', 's', '1', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'M', '2', '_', 'd', 'p', 'm', 'p', 'y', 's', 's', '_', 'a',
+  'c', 'c', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'd', 'p', 'm',
+  'p', 'y', 's', 's', '_', 'n', 'a', 'c', '_', 's', '0', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'M', '2', '_', 'd', 'p', 'm', 'p', 'y', 's', 's', '_', 'r', 'n', 'd', '_',
+  's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'd', 'p', 'm', 'p', 'y', 's',
+  's', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'd', 'p', 'm', 'p',
+  'y', 'u', 'u', '_', 'a', 'c', 'c', '_', 's', '0', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M',
+  '2', '_', 'd', 'p', 'm', 'p', 'y', 'u', 'u', '_', 'n', 'a', 'c', '_', 's',
   '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'm', 'a', 'c', 'u', 'l', 's',
+  'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'd', 'p', 'm', 'p', 'y', 'u', 'u',
+  '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'h', 'm', 'm', 'p', 'y',
+  'h', '_', 'r', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'h', 'm', 'm',
+  'p', 'y', 'h', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'h', 'm',
+  'm', 'p', 'y', 'l', '_', 'r', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_',
+  'h', 'm', 'm', 'p', 'y', 'l', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2',
+  '_', 'm', 'a', 'c', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'a', 'c',
+  's', 'i', 'n', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'a', 'c', 's', 'i',
+  'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'm', 'a', 'c', 'h', 's', '_',
+  'r', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'm', 'a', 'c', 'h',
+  's', '_', 'r', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'm', 'a',
+  'c', 'h', 's', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'm',
+  'a', 'c', 'h', 's', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm',
+  'm', 'a', 'c', 'l', 's', '_', 'r', 's', '0', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2',
+  '_', 'm', 'm', 'a', 'c', 'l', 's', '_', 'r', 's', '1', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'M', '2', '_', 'm', 'm', 'a', 'c', 'l', 's', '_', 's', '0', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'M', '2', '_', 'm', 'm', 'a', 'c', 'l', 's', '_', 's', '1', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'M', '2', '_', 'm', 'm', 'a', 'c', 'u', 'h', 's', '_', 'r', 's',
+  '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'm', 'a', 'c', 'u', 'h', 's',
   '_', 'r', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
   'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'm', 'a', 'c',
-  'u', 'l', 's', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'u', 'h', 's', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
   'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'm',
-  'a', 'c', 'u', 'l', 's', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  'a', 'c', 'u', 'h', 's', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l',
   't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_',
-  'm', 'm', 'p', 'y', 'h', '_', 'r', 's', '0', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2',
-  '_', 'm', 'm', 'p', 'y', 'h', '_', 'r', 's', '1', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M',
-  '2', '_', 'm', 'm', 'p', 'y', 'h', '_', 's', '0', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M',
-  '2', '_', 'm', 'm', 'p', 'y', 'h', '_', 's', '1', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M',
-  '2', '_', 'm', 'm', 'p', 'y', 'l', '_', 'r', 's', '0', '\000', '_', '_', 'b',
+  'm', 'm', 'a', 'c', 'u', 'l', 's', '_', 'r', 's', '0', '\000', '_', '_', 'b',
   'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'M', '2', '_', 'm', 'm', 'p', 'y', 'l', '_', 'r', 's', '1', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'M', '2', '_', 'm', 'm', 'p', 'y', 'l', '_', 's', '0', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'M', '2', '_', 'm', 'm', 'p', 'y', 'l', '_', 's', '1', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'M', '2', '_', 'm', 'm', 'p', 'y', 'u', 'h', '_', 'r', 's', '0', '\000',
+  'M', '2', '_', 'm', 'm', 'a', 'c', 'u', 'l', 's', '_', 'r', 's', '1', '\000',
   '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'M', '2', '_', 'm', 'm', 'p', 'y', 'u', 'h', '_', 'r', 's',
-  '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'm', 'p', 'y', 'u', 'h', '_',
-  's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'm', 'p', 'y', 'u', 'h',
+  'O', 'N', '_', 'M', '2', '_', 'm', 'm', 'a', 'c', 'u', 'l', 's', '_', 's',
+  '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'm', 'a', 'c', 'u', 'l', 's',
   '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'm', 'p', 'y', 'u',
-  'l', '_', 'r', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'm', 'p', 'y', 'h',
+  '_', 'r', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'm', 'p', 'y',
+  'h', '_', 'r', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
   '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'm', 'p',
-  'y', 'u', 'l', '_', 'r', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'y', 'h', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'm', 'p',
+  'y', 'h', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'm', 'p',
+  'y', 'l', '_', 'r', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'm',
+  'p', 'y', 'l', '_', 'r', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
   'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm',
-  'm', 'p', 'y', 'u', 'l', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_',
-  'm', 'm', 'p', 'y', 'u', 'l', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i',
+  'm', 'p', 'y', 'l', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm',
+  'm', 'p', 'y', 'l', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm',
+  'm', 'p', 'y', 'u', 'h', '_', 'r', 's', '0', '\000', '_', '_', 'b', 'u', 'i',
   'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2',
-  '_', 'm', 'n', 'a', 'c', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p',
-  'y', '_', 'a', 'c', 'c', '_', 'h', 'h', '_', 's', '0', '\000', '_', '_', 'b',
+  '_', 'm', 'm', 'p', 'y', 'u', 'h', '_', 'r', 's', '1', '\000', '_', '_', 'b',
   'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'M', '2', '_', 'm', 'p', 'y', '_', 'a', 'c', 'c', '_', 'h', 'h', '_', 's',
-  '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'M', '2', '_', 'm', 'm', 'p', 'y', 'u', 'h', '_', 's', '0', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'M', '2', '_', 'm', 'm', 'p', 'y', 'u', 'h', '_', 's', '1', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'M', '2', '_', 'm', 'm', 'p', 'y', 'u', 'l', '_', 'r', 's', '0',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'm', 'p', 'y', 'u', 'l', '_', 'r',
+  's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'm', 'p', 'y', 'u', 'l',
+  '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'm', 'p', 'y', 'u',
+  'l', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'n', 'a', 'c',
+  'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
   'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', '_', 'a', 'c', 'c',
-  '_', 'h', 'l', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  '_', 'h', 'h', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
   'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p',
-  'y', '_', 'a', 'c', 'c', '_', 'h', 'l', '_', 's', '1', '\000', '_', '_', 'b',
+  'y', '_', 'a', 'c', 'c', '_', 'h', 'h', '_', 's', '1', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'M', '2', '_', 'm', 'p', 'y', '_', 'a', 'c', 'c', '_', 'h', 'l', '_', 's',
+  '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', '_', 'a', 'c', 'c',
+  '_', 'h', 'l', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p',
+  'y', '_', 'a', 'c', 'c', '_', 'l', 'h', '_', 's', '0', '\000', '_', '_', 'b',
   'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
   'M', '2', '_', 'm', 'p', 'y', '_', 'a', 'c', 'c', '_', 'l', 'h', '_', 's',
-  '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', '_', 'a', 'c', 'c',
-  '_', 'l', 'h', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p',
-  'y', '_', 'a', 'c', 'c', '_', 'l', 'l', '_', 's', '0', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'M', '2', '_', 'm', 'p', 'y', '_', 'a', 'c', 'c', '_', 'l', 'l', '_', 's',
   '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
   'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', '_', 'a', 'c', 'c',
-  '_', 's', 'a', 't', '_', 'h', 'h', '_', 's', '0', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M',
-  '2', '_', 'm', 'p', 'y', '_', 'a', 'c', 'c', '_', 's', 'a', 't', '_', 'h',
-  'h', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', '_',
-  'a', 'c', 'c', '_', 's', 'a', 't', '_', 'h', 'l', '_', 's', '0', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'M', '2', '_', 'm', 'p', 'y', '_', 'a', 'c', 'c', '_', 's', 'a',
-  't', '_', 'h', 'l', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm',
-  'p', 'y', '_', 'a', 'c', 'c', '_', 's', 'a', 't', '_', 'l', 'h', '_', 's',
-  '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', '_', 'a', 'c', 'c',
-  '_', 's', 'a', 't', '_', 'l', 'h', '_', 's', '1', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M',
-  '2', '_', 'm', 'p', 'y', '_', 'a', 'c', 'c', '_', 's', 'a', 't', '_', 'l',
-  'l', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', '_',
-  'a', 'c', 'c', '_', 's', 'a', 't', '_', 'l', 'l', '_', 's', '1', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'M', '2', '_', 'm', 'p', 'y', '_', 'h', 'h', '_', 's', '0', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', '_', 'h', 'h', '_', 's', '1',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', '_', 'h', 'l', '_', 's',
-  '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', '_', 'h', 'l', '_',
-  's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', '_', 'l', 'h',
-  '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', '_', 'l',
-  'h', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', '_',
-  'l', 'l', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'l', 'l', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p',
+  'y', '_', 'a', 'c', 'c', '_', 'l', 'l', '_', 's', '1', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'M', '2', '_', 'm', 'p', 'y', '_', 'a', 'c', 'c', '_', 's', 'a', 't', '_',
+  'h', 'h', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
   '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y',
-  '_', 'l', 'l', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p',
-  'y', '_', 'n', 'a', 'c', '_', 'h', 'h', '_', 's', '0', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'M', '2', '_', 'm', 'p', 'y', '_', 'n', 'a', 'c', '_', 'h', 'h', '_', 's',
-  '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', '_', 'n', 'a', 'c',
-  '_', 'h', 'l', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p',
-  'y', '_', 'n', 'a', 'c', '_', 'h', 'l', '_', 's', '1', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'M', '2', '_', 'm', 'p', 'y', '_', 'n', 'a', 'c', '_', 'l', 'h', '_', 's',
-  '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', '_', 'n', 'a', 'c',
-  '_', 'l', 'h', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p',
-  'y', '_', 'n', 'a', 'c', '_', 'l', 'l', '_', 's', '0', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'M', '2', '_', 'm', 'p', 'y', '_', 'n', 'a', 'c', '_', 'l', 'l', '_', 's',
-  '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', '_', 'n', 'a', 'c',
-  '_', 's', 'a', 't', '_', 'h', 'h', '_', 's', '0', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M',
-  '2', '_', 'm', 'p', 'y', '_', 'n', 'a', 'c', '_', 's', 'a', 't', '_', 'h',
-  'h', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', '_',
-  'n', 'a', 'c', '_', 's', 'a', 't', '_', 'h', 'l', '_', 's', '0', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'M', '2', '_', 'm', 'p', 'y', '_', 'n', 'a', 'c', '_', 's', 'a',
-  't', '_', 'h', 'l', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm',
-  'p', 'y', '_', 'n', 'a', 'c', '_', 's', 'a', 't', '_', 'l', 'h', '_', 's',
-  '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', '_', 'n', 'a', 'c',
-  '_', 's', 'a', 't', '_', 'l', 'h', '_', 's', '1', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M',
-  '2', '_', 'm', 'p', 'y', '_', 'n', 'a', 'c', '_', 's', 'a', 't', '_', 'l',
-  'l', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', '_',
-  'n', 'a', 'c', '_', 's', 'a', 't', '_', 'l', 'l', '_', 's', '1', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'M', '2', '_', 'm', 'p', 'y', '_', 'r', 'n', 'd', '_', 'h', 'h',
-  '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', '_', 'r',
-  'n', 'd', '_', 'h', 'h', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_',
-  'm', 'p', 'y', '_', 'r', 'n', 'd', '_', 'h', 'l', '_', 's', '0', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'M', '2', '_', 'm', 'p', 'y', '_', 'r', 'n', 'd', '_', 'h', 'l',
-  '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', '_', 'r',
-  'n', 'd', '_', 'l', 'h', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_',
-  'm', 'p', 'y', '_', 'r', 'n', 'd', '_', 'l', 'h', '_', 's', '1', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'M', '2', '_', 'm', 'p', 'y', '_', 'r', 'n', 'd', '_', 'l', 'l',
-  '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', '_', 'r',
-  'n', 'd', '_', 'l', 'l', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_',
-  'm', 'p', 'y', '_', 's', 'a', 't', '_', 'h', 'h', '_', 's', '0', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'M', '2', '_', 'm', 'p', 'y', '_', 's', 'a', 't', '_', 'h', 'h',
-  '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', '_', 's',
+  '_', 'a', 'c', 'c', '_', 's', 'a', 't', '_', 'h', 'h', '_', 's', '1', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', '_', 'a', 'c', 'c', '_', 's',
   'a', 't', '_', 'h', 'l', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l',
   't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_',
-  'm', 'p', 'y', '_', 's', 'a', 't', '_', 'h', 'l', '_', 's', '1', '\000', '_',
+  'm', 'p', 'y', '_', 'a', 'c', 'c', '_', 's', 'a', 't', '_', 'h', 'l', '_',
+  's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', '_', 'a', 'c',
+  'c', '_', 's', 'a', 't', '_', 'l', 'h', '_', 's', '0', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'M', '2', '_', 'm', 'p', 'y', '_', 'a', 'c', 'c', '_', 's', 'a', 't', '_',
+  'l', 'h', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y',
+  '_', 'a', 'c', 'c', '_', 's', 'a', 't', '_', 'l', 'l', '_', 's', '0', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', '_', 'a', 'c', 'c', '_', 's',
+  'a', 't', '_', 'l', 'l', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_',
+  'm', 'p', 'y', '_', 'h', 'h', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2',
+  '_', 'm', 'p', 'y', '_', 'h', 'h', '_', 's', '1', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M',
+  '2', '_', 'm', 'p', 'y', '_', 'h', 'l', '_', 's', '0', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'M', '2', '_', 'm', 'p', 'y', '_', 'h', 'l', '_', 's', '1', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'M', '2', '_', 'm', 'p', 'y', '_', 'l', 'h', '_', 's', '0', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'M', '2', '_', 'm', 'p', 'y', '_', 'l', 'h', '_', 's', '1', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', '_', 'l', 'l', '_', 's', '0',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', '_', 'l', 'l', '_', 's',
+  '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', '_', 'n', 'a', 'c',
+  '_', 'h', 'h', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p',
+  'y', '_', 'n', 'a', 'c', '_', 'h', 'h', '_', 's', '1', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'M', '2', '_', 'm', 'p', 'y', '_', 'n', 'a', 'c', '_', 'h', 'l', '_', 's',
+  '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', '_', 'n', 'a', 'c',
+  '_', 'h', 'l', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p',
+  'y', '_', 'n', 'a', 'c', '_', 'l', 'h', '_', 's', '0', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'M', '2', '_', 'm', 'p', 'y', '_', 'n', 'a', 'c', '_', 'l', 'h', '_', 's',
+  '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', '_', 'n', 'a', 'c',
+  '_', 'l', 'l', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p',
+  'y', '_', 'n', 'a', 'c', '_', 'l', 'l', '_', 's', '1', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'M', '2', '_', 'm', 'p', 'y', '_', 'n', 'a', 'c', '_', 's', 'a', 't', '_',
+  'h', 'h', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y',
+  '_', 'n', 'a', 'c', '_', 's', 'a', 't', '_', 'h', 'h', '_', 's', '1', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', '_', 'n', 'a', 'c', '_', 's',
+  'a', 't', '_', 'h', 'l', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_',
+  'm', 'p', 'y', '_', 'n', 'a', 'c', '_', 's', 'a', 't', '_', 'h', 'l', '_',
+  's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', '_', 'n', 'a',
+  'c', '_', 's', 'a', 't', '_', 'l', 'h', '_', 's', '0', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'M', '2', '_', 'm', 'p', 'y', '_', 'n', 'a', 'c', '_', 's', 'a', 't', '_',
+  'l', 'h', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y',
+  '_', 'n', 'a', 'c', '_', 's', 'a', 't', '_', 'l', 'l', '_', 's', '0', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', '_', 'n', 'a', 'c', '_', 's',
+  'a', 't', '_', 'l', 'l', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_',
+  'm', 'p', 'y', '_', 'r', 'n', 'd', '_', 'h', 'h', '_', 's', '0', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'M', '2', '_', 'm', 'p', 'y', '_', 'r', 'n', 'd', '_', 'h', 'h',
+  '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', '_', 'r',
+  'n', 'd', '_', 'h', 'l', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_',
+  'm', 'p', 'y', '_', 'r', 'n', 'd', '_', 'h', 'l', '_', 's', '1', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'M', '2', '_', 'm', 'p', 'y', '_', 'r', 'n', 'd', '_', 'l', 'h',
+  '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', '_', 'r',
+  'n', 'd', '_', 'l', 'h', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_',
+  'm', 'p', 'y', '_', 'r', 'n', 'd', '_', 'l', 'l', '_', 's', '0', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'M', '2', '_', 'm', 'p', 'y', '_', 'r', 'n', 'd', '_', 'l', 'l',
+  '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', '_', 's',
+  'a', 't', '_', 'h', 'h', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_',
+  'm', 'p', 'y', '_', 's', 'a', 't', '_', 'h', 'h', '_', 's', '1', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'M', '2', '_', 'm', 'p', 'y', '_', 's', 'a', 't', '_', 'h', 'l',
+  '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', '_', 's',
+  'a', 't', '_', 'h', 'l', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_',
+  'm', 'p', 'y', '_', 's', 'a', 't', '_', 'l', 'h', '_', 's', '0', '\000', '_',
   '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
   'N', '_', 'M', '2', '_', 'm', 'p', 'y', '_', 's', 'a', 't', '_', 'l', 'h',
-  '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', '_', 's',
-  'a', 't', '_', 'l', 'h', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_',
-  'm', 'p', 'y', '_', 's', 'a', 't', '_', 'l', 'l', '_', 's', '0', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'M', '2', '_', 'm', 'p', 'y', '_', 's', 'a', 't', '_', 'l', 'l',
   '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
   'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', '_', 's',
-  'a', 't', '_', 'r', 'n', 'd', '_', 'h', 'h', '_', 's', '0', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'M', '2', '_', 'm', 'p', 'y', '_', 's', 'a', 't', '_', 'r', 'n', 'd',
-  '_', 'h', 'h', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p',
-  'y', '_', 's', 'a', 't', '_', 'r', 'n', 'd', '_', 'h', 'l', '_', 's', '0',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', '_', 's', 'a', 't', '_',
-  'r', 'n', 'd', '_', 'h', 'l', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2',
-  '_', 'm', 'p', 'y', '_', 's', 'a', 't', '_', 'r', 'n', 'd', '_', 'l', 'h',
-  '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', '_', 's',
-  'a', 't', '_', 'r', 'n', 'd', '_', 'l', 'h', '_', 's', '1', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'M', '2', '_', 'm', 'p', 'y', '_', 's', 'a', 't', '_', 'r', 'n', 'd',
-  '_', 'l', 'l', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p',
-  'y', '_', 's', 'a', 't', '_', 'r', 'n', 'd', '_', 'l', 'l', '_', 's', '1',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', '_', 'u', 'p', '\000', '_',
+  'a', 't', '_', 'l', 'l', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_',
+  'm', 'p', 'y', '_', 's', 'a', 't', '_', 'l', 'l', '_', 's', '1', '\000', '_',
   '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'M', '2', '_', 'm', 'p', 'y', '_', 'u', 'p', '_', 's', '1', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', '_', 'u', 'p', '_', 's', '1',
-  '_', 's', 'a', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'd',
-  '_', 'a', 'c', 'c', '_', 'h', 'h', '_', 's', '0', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M',
-  '2', '_', 'm', 'p', 'y', 'd', '_', 'a', 'c', 'c', '_', 'h', 'h', '_', 's',
+  'N', '_', 'M', '2', '_', 'm', 'p', 'y', '_', 's', 'a', 't', '_', 'r', 'n',
+  'd', '_', 'h', 'h', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm',
+  'p', 'y', '_', 's', 'a', 't', '_', 'r', 'n', 'd', '_', 'h', 'h', '_', 's',
   '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'd', '_', 'a', 'c',
-  'c', '_', 'h', 'l', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm',
-  'p', 'y', 'd', '_', 'a', 'c', 'c', '_', 'h', 'l', '_', 's', '1', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'd', '_', 'a', 'c', 'c', '_', 'l',
-  'h', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'd',
-  '_', 'a', 'c', 'c', '_', 'l', 'h', '_', 's', '1', '\000', '_', '_', 'b', 'u',
+  'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', '_', 's', 'a', 't',
+  '_', 'r', 'n', 'd', '_', 'h', 'l', '_', 's', '0', '\000', '_', '_', 'b', 'u',
   'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M',
-  '2', '_', 'm', 'p', 'y', 'd', '_', 'a', 'c', 'c', '_', 'l', 'l', '_', 's',
+  '2', '_', 'm', 'p', 'y', '_', 's', 'a', 't', '_', 'r', 'n', 'd', '_', 'h',
+  'l', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', '_',
+  's', 'a', 't', '_', 'r', 'n', 'd', '_', 'l', 'h', '_', 's', '0', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'M', '2', '_', 'm', 'p', 'y', '_', 's', 'a', 't', '_', 'r', 'n',
+  'd', '_', 'l', 'h', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm',
+  'p', 'y', '_', 's', 'a', 't', '_', 'r', 'n', 'd', '_', 'l', 'l', '_', 's',
   '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'd', '_', 'a', 'c',
-  'c', '_', 'l', 'l', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm',
-  'p', 'y', 'd', '_', 'h', 'h', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i',
+  'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', '_', 's', 'a', 't',
+  '_', 'r', 'n', 'd', '_', 'l', 'l', '_', 's', '1', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M',
+  '2', '_', 'm', 'p', 'y', '_', 'u', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_',
+  'm', 'p', 'y', '_', 'u', 'p', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i',
   'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2',
-  '_', 'm', 'p', 'y', 'd', '_', 'h', 'h', '_', 's', '1', '\000', '_', '_', 'b',
+  '_', 'm', 'p', 'y', '_', 'u', 'p', '_', 's', '1', '_', 's', 'a', 't', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'd', '_', 'a', 'c', 'c', '_',
+  'h', 'h', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y',
+  'd', '_', 'a', 'c', 'c', '_', 'h', 'h', '_', 's', '1', '\000', '_', '_', 'b',
   'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'M', '2', '_', 'm', 'p', 'y', 'd', '_', 'h', 'l', '_', 's', '0', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'd', '_', 'h', 'l', '_', 's', '1',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'd', '_', 'l', 'h', '_',
+  'M', '2', '_', 'm', 'p', 'y', 'd', '_', 'a', 'c', 'c', '_', 'h', 'l', '_',
   's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'd', '_', 'l',
-  'h', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'd',
-  '_', 'l', 'l', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p',
-  'y', 'd', '_', 'l', 'l', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_',
-  'm', 'p', 'y', 'd', '_', 'n', 'a', 'c', '_', 'h', 'h', '_', 's', '0', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'd', '_', 'n', 'a', 'c', '_',
-  'h', 'h', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y',
-  'd', '_', 'n', 'a', 'c', '_', 'h', 'l', '_', 's', '0', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'M', '2', '_', 'm', 'p', 'y', 'd', '_', 'n', 'a', 'c', '_', 'h', 'l', '_',
-  's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'd', '_', 'n',
-  'a', 'c', '_', 'l', 'h', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_',
-  'm', 'p', 'y', 'd', '_', 'n', 'a', 'c', '_', 'l', 'h', '_', 's', '1', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'd', '_', 'n', 'a', 'c', '_',
-  'l', 'l', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y',
-  'd', '_', 'n', 'a', 'c', '_', 'l', 'l', '_', 's', '1', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'M', '2', '_', 'm', 'p', 'y', 'd', '_', 'r', 'n', 'd', '_', 'h', 'h', '_',
-  's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'd', '_', 'r',
-  'n', 'd', '_', 'h', 'h', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_',
-  'm', 'p', 'y', 'd', '_', 'r', 'n', 'd', '_', 'h', 'l', '_', 's', '0', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'd', '_', 'r', 'n', 'd', '_',
-  'h', 'l', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y',
-  'd', '_', 'r', 'n', 'd', '_', 'l', 'h', '_', 's', '0', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'M', '2', '_', 'm', 'p', 'y', 'd', '_', 'r', 'n', 'd', '_', 'l', 'h', '_',
-  's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'd', '_', 'r',
-  'n', 'd', '_', 'l', 'l', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_',
-  'm', 'p', 'y', 'd', '_', 'r', 'n', 'd', '_', 'l', 'l', '_', 's', '1', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'i', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M',
-  '2', '_', 'm', 'p', 'y', 's', 'i', 'n', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_',
-  'm', 'p', 'y', 's', 'i', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p',
-  'y', 's', 'm', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', 's',
-  'u', '_', 'u', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'u',
-  '_', 'a', 'c', 'c', '_', 'h', 'h', '_', 's', '0', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M',
-  '2', '_', 'm', 'p', 'y', 'u', '_', 'a', 'c', 'c', '_', 'h', 'h', '_', 's',
-  '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'u', '_', 'a', 'c',
-  'c', '_', 'h', 'l', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm',
-  'p', 'y', 'u', '_', 'a', 'c', 'c', '_', 'h', 'l', '_', 's', '1', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'u', '_', 'a', 'c', 'c', '_', 'l',
-  'h', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'u',
-  '_', 'a', 'c', 'c', '_', 'l', 'h', '_', 's', '1', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M',
-  '2', '_', 'm', 'p', 'y', 'u', '_', 'a', 'c', 'c', '_', 'l', 'l', '_', 's',
-  '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'u', '_', 'a', 'c',
-  'c', '_', 'l', 'l', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm',
-  'p', 'y', 'u', '_', 'h', 'h', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2',
-  '_', 'm', 'p', 'y', 'u', '_', 'h', 'h', '_', 's', '1', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'M', '2', '_', 'm', 'p', 'y', 'u', '_', 'h', 'l', '_', 's', '0', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'u', '_', 'h', 'l', '_', 's', '1',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'u', '_', 'l', 'h', '_',
-  's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'u', '_', 'l',
-  'h', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'u',
-  '_', 'l', 'l', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p',
-  'y', 'u', '_', 'l', 'l', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_',
-  'm', 'p', 'y', 'u', '_', 'n', 'a', 'c', '_', 'h', 'h', '_', 's', '0', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'u', '_', 'n', 'a', 'c', '_',
-  'h', 'h', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y',
-  'u', '_', 'n', 'a', 'c', '_', 'h', 'l', '_', 's', '0', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'M', '2', '_', 'm', 'p', 'y', 'u', '_', 'n', 'a', 'c', '_', 'h', 'l', '_',
-  's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'u', '_', 'n',
-  'a', 'c', '_', 'l', 'h', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_',
-  'm', 'p', 'y', 'u', '_', 'n', 'a', 'c', '_', 'l', 'h', '_', 's', '1', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'u', '_', 'n', 'a', 'c', '_',
-  'l', 'l', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y',
-  'u', '_', 'n', 'a', 'c', '_', 'l', 'l', '_', 's', '1', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'M', '2', '_', 'm', 'p', 'y', 'u', '_', 'u', 'p', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M',
-  '2', '_', 'm', 'p', 'y', 'u', 'd', '_', 'a', 'c', 'c', '_', 'h', 'h', '_',
-  's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'u', 'd', '_',
-  'a', 'c', 'c', '_', 'h', 'h', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2',
-  '_', 'm', 'p', 'y', 'u', 'd', '_', 'a', 'c', 'c', '_', 'h', 'l', '_', 's',
-  '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'u', 'd', '_', 'a',
+  'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'd', '_', 'a',
   'c', 'c', '_', 'h', 'l', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l',
   't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_',
-  'm', 'p', 'y', 'u', 'd', '_', 'a', 'c', 'c', '_', 'l', 'h', '_', 's', '0',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'u', 'd', '_', 'a', 'c',
-  'c', '_', 'l', 'h', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm',
-  'p', 'y', 'u', 'd', '_', 'a', 'c', 'c', '_', 'l', 'l', '_', 's', '0', '\000',
+  'm', 'p', 'y', 'd', '_', 'a', 'c', 'c', '_', 'l', 'h', '_', 's', '0', '\000',
   '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'u', 'd', '_', 'a', 'c', 'c',
-  '_', 'l', 'l', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'd', '_', 'a', 'c', 'c', '_',
+  'l', 'h', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y',
+  'd', '_', 'a', 'c', 'c', '_', 'l', 'l', '_', 's', '0', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'M', '2', '_', 'm', 'p', 'y', 'd', '_', 'a', 'c', 'c', '_', 'l', 'l', '_',
+  's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'd', '_', 'h',
+  'h', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'd',
+  '_', 'h', 'h', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
   'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p',
-  'y', 'u', 'd', '_', 'h', 'h', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2',
-  '_', 'm', 'p', 'y', 'u', 'd', '_', 'h', 'h', '_', 's', '1', '\000', '_', '_',
+  'y', 'd', '_', 'h', 'l', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_',
+  'm', 'p', 'y', 'd', '_', 'h', 'l', '_', 's', '1', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M',
+  '2', '_', 'm', 'p', 'y', 'd', '_', 'l', 'h', '_', 's', '0', '\000', '_', '_',
   'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'M', '2', '_', 'm', 'p', 'y', 'u', 'd', '_', 'h', 'l', '_', 's', '0',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'u', 'd', '_', 'h', 'l',
+  '_', 'M', '2', '_', 'm', 'p', 'y', 'd', '_', 'l', 'h', '_', 's', '1', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'd', '_', 'l', 'l', '_', 's',
+  '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'd', '_', 'l', 'l',
   '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'u', 'd',
-  '_', 'l', 'h', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p',
-  'y', 'u', 'd', '_', 'l', 'h', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'd', '_',
+  'n', 'a', 'c', '_', 'h', 'h', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i',
   'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2',
-  '_', 'm', 'p', 'y', 'u', 'd', '_', 'l', 'l', '_', 's', '0', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'M', '2', '_', 'm', 'p', 'y', 'u', 'd', '_', 'l', 'l', '_', 's', '1',
+  '_', 'm', 'p', 'y', 'd', '_', 'n', 'a', 'c', '_', 'h', 'h', '_', 's', '1',
   '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'u', 'd', '_', 'n', 'a',
-  'c', '_', 'h', 'h', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm',
-  'p', 'y', 'u', 'd', '_', 'n', 'a', 'c', '_', 'h', 'h', '_', 's', '1', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'u', 'd', '_', 'n', 'a', 'c',
+  'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'd', '_', 'n', 'a', 'c',
   '_', 'h', 'l', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
   'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p',
-  'y', 'u', 'd', '_', 'n', 'a', 'c', '_', 'h', 'l', '_', 's', '1', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'u', 'd', '_', 'n', 'a', 'c', '_',
-  'l', 'h', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y',
-  'u', 'd', '_', 'n', 'a', 'c', '_', 'l', 'h', '_', 's', '1', '\000', '_', '_',
+  'y', 'd', '_', 'n', 'a', 'c', '_', 'h', 'l', '_', 's', '1', '\000', '_', '_',
   'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'M', '2', '_', 'm', 'p', 'y', 'u', 'd', '_', 'n', 'a', 'c', '_', 'l',
+  '_', 'M', '2', '_', 'm', 'p', 'y', 'd', '_', 'n', 'a', 'c', '_', 'l', 'h',
+  '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'd', '_',
+  'n', 'a', 'c', '_', 'l', 'h', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2',
+  '_', 'm', 'p', 'y', 'd', '_', 'n', 'a', 'c', '_', 'l', 'l', '_', 's', '0',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'd', '_', 'n', 'a', 'c',
+  '_', 'l', 'l', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p',
+  'y', 'd', '_', 'r', 'n', 'd', '_', 'h', 'h', '_', 's', '0', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'M', '2', '_', 'm', 'p', 'y', 'd', '_', 'r', 'n', 'd', '_', 'h', 'h',
+  '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'd', '_',
+  'r', 'n', 'd', '_', 'h', 'l', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2',
+  '_', 'm', 'p', 'y', 'd', '_', 'r', 'n', 'd', '_', 'h', 'l', '_', 's', '1',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'd', '_', 'r', 'n', 'd',
+  '_', 'l', 'h', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p',
+  'y', 'd', '_', 'r', 'n', 'd', '_', 'l', 'h', '_', 's', '1', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'M', '2', '_', 'm', 'p', 'y', 'd', '_', 'r', 'n', 'd', '_', 'l', 'l',
+  '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'd', '_',
+  'r', 'n', 'd', '_', 'l', 'l', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2',
+  '_', 'm', 'p', 'y', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y',
+  's', 'm', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', 's', 'u',
+  '_', 'u', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'u', '_',
+  'a', 'c', 'c', '_', 'h', 'h', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2',
+  '_', 'm', 'p', 'y', 'u', '_', 'a', 'c', 'c', '_', 'h', 'h', '_', 's', '1',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'u', '_', 'a', 'c', 'c',
+  '_', 'h', 'l', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p',
+  'y', 'u', '_', 'a', 'c', 'c', '_', 'h', 'l', '_', 's', '1', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'M', '2', '_', 'm', 'p', 'y', 'u', '_', 'a', 'c', 'c', '_', 'l', 'h',
+  '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'u', '_',
+  'a', 'c', 'c', '_', 'l', 'h', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2',
+  '_', 'm', 'p', 'y', 'u', '_', 'a', 'c', 'c', '_', 'l', 'l', '_', 's', '0',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'u', '_', 'a', 'c', 'c',
+  '_', 'l', 'l', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p',
+  'y', 'u', '_', 'h', 'h', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_',
+  'm', 'p', 'y', 'u', '_', 'h', 'h', '_', 's', '1', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M',
+  '2', '_', 'm', 'p', 'y', 'u', '_', 'h', 'l', '_', 's', '0', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'M', '2', '_', 'm', 'p', 'y', 'u', '_', 'h', 'l', '_', 's', '1', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'u', '_', 'l', 'h', '_', 's',
+  '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'u', '_', 'l', 'h',
+  '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'u', '_',
+  'l', 'l', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y',
+  'u', '_', 'l', 'l', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm',
+  'p', 'y', 'u', '_', 'n', 'a', 'c', '_', 'h', 'h', '_', 's', '0', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'u', '_', 'n', 'a', 'c', '_', 'h',
+  'h', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'u',
+  '_', 'n', 'a', 'c', '_', 'h', 'l', '_', 's', '0', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M',
+  '2', '_', 'm', 'p', 'y', 'u', '_', 'n', 'a', 'c', '_', 'h', 'l', '_', 's',
+  '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'u', '_', 'n', 'a',
+  'c', '_', 'l', 'h', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm',
+  'p', 'y', 'u', '_', 'n', 'a', 'c', '_', 'l', 'h', '_', 's', '1', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'u', '_', 'n', 'a', 'c', '_', 'l',
   'l', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
   'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'u',
-  'd', '_', 'n', 'a', 'c', '_', 'l', 'l', '_', 's', '1', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'M', '2', '_', 'm', 'p', 'y', 'u', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_',
-  'n', 'a', 'c', 'c', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'n', 'a', 'c',
-  'c', 'i', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 's', 'u', 'b', 'a', 'c',
-  'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'v', 'a', 'b', 's', 'd', 'i', 'f',
-  'f', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'v', 'a', 'b', 's', 'd', 'i',
-  'f', 'f', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'v', 'c', 'm', 'a', 'c',
-  '_', 's', '0', '_', 's', 'a', 't', '_', 'i', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2',
-  '_', 'v', 'c', 'm', 'a', 'c', '_', 's', '0', '_', 's', 'a', 't', '_', 'r',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'M', '2', '_', 'v', 'c', 'm', 'p', 'y', '_', 's', '0',
-  '_', 's', 'a', 't', '_', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'v', 'c',
-  'm', 'p', 'y', '_', 's', '0', '_', 's', 'a', 't', '_', 'r', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'M', '2', '_', 'v', 'c', 'm', 'p', 'y', '_', 's', '1', '_', 's', 'a',
-  't', '_', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'v', 'c', 'm', 'p', 'y',
-  '_', 's', '1', '_', 's', 'a', 't', '_', 'r', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2',
-  '_', 'v', 'd', 'm', 'a', 'c', 's', '_', 's', '0', '\000', '_', '_', 'b', 'u',
+  '_', 'n', 'a', 'c', '_', 'l', 'l', '_', 's', '1', '\000', '_', '_', 'b', 'u',
   'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M',
-  '2', '_', 'v', 'd', 'm', 'a', 'c', 's', '_', 's', '1', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'M', '2', '_', 'v', 'd', 'm', 'p', 'y', 'r', 's', '_', 's', '0', '\000', '_',
+  '2', '_', 'm', 'p', 'y', 'u', '_', 'u', 'p', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2',
+  '_', 'm', 'p', 'y', 'u', 'd', '_', 'a', 'c', 'c', '_', 'h', 'h', '_', 's',
+  '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'u', 'd', '_', 'a',
+  'c', 'c', '_', 'h', 'h', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_',
+  'm', 'p', 'y', 'u', 'd', '_', 'a', 'c', 'c', '_', 'h', 'l', '_', 's', '0',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'u', 'd', '_', 'a', 'c',
+  'c', '_', 'h', 'l', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm',
+  'p', 'y', 'u', 'd', '_', 'a', 'c', 'c', '_', 'l', 'h', '_', 's', '0', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'u', 'd', '_', 'a', 'c', 'c',
+  '_', 'l', 'h', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p',
+  'y', 'u', 'd', '_', 'a', 'c', 'c', '_', 'l', 'l', '_', 's', '0', '\000', '_',
   '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'M', '2', '_', 'v', 'd', 'm', 'p', 'y', 'r', 's', '_', 's', '1',
+  'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'u', 'd', '_', 'a', 'c', 'c', '_',
+  'l', 'l', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y',
+  'u', 'd', '_', 'h', 'h', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_',
+  'm', 'p', 'y', 'u', 'd', '_', 'h', 'h', '_', 's', '1', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'M', '2', '_', 'm', 'p', 'y', 'u', 'd', '_', 'h', 'l', '_', 's', '0', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'u', 'd', '_', 'h', 'l', '_',
+  's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'u', 'd', '_',
+  'l', 'h', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y',
+  'u', 'd', '_', 'l', 'h', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_',
+  'm', 'p', 'y', 'u', 'd', '_', 'l', 'l', '_', 's', '0', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'M', '2', '_', 'm', 'p', 'y', 'u', 'd', '_', 'l', 'l', '_', 's', '1', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'u', 'd', '_', 'n', 'a', 'c',
+  '_', 'h', 'h', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p',
+  'y', 'u', 'd', '_', 'n', 'a', 'c', '_', 'h', 'h', '_', 's', '1', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'u', 'd', '_', 'n', 'a', 'c', '_',
+  'h', 'l', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y',
+  'u', 'd', '_', 'n', 'a', 'c', '_', 'h', 'l', '_', 's', '1', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'M', '2', '_', 'm', 'p', 'y', 'u', 'd', '_', 'n', 'a', 'c', '_', 'l',
+  'h', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'u',
+  'd', '_', 'n', 'a', 'c', '_', 'l', 'h', '_', 's', '1', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'M', '2', '_', 'm', 'p', 'y', 'u', 'd', '_', 'n', 'a', 'c', '_', 'l', 'l',
+  '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'm', 'p', 'y', 'u', 'd',
+  '_', 'n', 'a', 'c', '_', 'l', 'l', '_', 's', '1', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M',
+  '2', '_', 'm', 'p', 'y', 'u', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'n',
+  'a', 'c', 'c', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'n', 'a', 'c', 'c',
+  'i', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 's', 'u', 'b', 'a', 'c', 'c',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'M', '2', '_', 'v', 'a', 'b', 's', 'd', 'i', 'f', 'f',
+  'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'v', 'a', 'b', 's', 'd', 'i', 'f',
+  'f', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'v', 'c', 'm', 'a', 'c', '_',
+  's', '0', '_', 's', 'a', 't', '_', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_',
+  'v', 'c', 'm', 'a', 'c', '_', 's', '0', '_', 's', 'a', 't', '_', 'r', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'M', '2', '_', 'v', 'c', 'm', 'p', 'y', '_', 's', '0', '_',
+  's', 'a', 't', '_', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'v', 'c', 'm',
+  'p', 'y', '_', 's', '0', '_', 's', 'a', 't', '_', 'r', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'M', '2', '_', 'v', 'c', 'm', 'p', 'y', '_', 's', '1', '_', 's', 'a', 't',
+  '_', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'v', 'c', 'm', 'p', 'y', '_',
+  's', '1', '_', 's', 'a', 't', '_', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_',
+  'v', 'd', 'm', 'a', 'c', 's', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2',
+  '_', 'v', 'd', 'm', 'a', 'c', 's', '_', 's', '1', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M',
+  '2', '_', 'v', 'd', 'm', 'p', 'y', 'r', 's', '_', 's', '0', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'M', '2', '_', 'v', 'd', 'm', 'p', 'y', 'r', 's', '_', 's', '1', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'M', '2', '_', 'v', 'd', 'm', 'p', 'y', 's', '_', 's', '0',
   '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
   'G', 'O', 'N', '_', 'M', '2', '_', 'v', 'd', 'm', 'p', 'y', 's', '_', 's',
-  '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'v', 'd', 'm', 'p', 'y', 's', '_',
-  's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'v', 'm', 'a', 'c', '2', '\000',
+  '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'v', 'm', 'a', 'c', '2', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'M', '2', '_', 'v', 'm', 'a', 'c', '2', 'e', 's', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'M', '2', '_', 'v', 'm', 'a', 'c', '2', 'e', 's', '_', 's', '0', '\000',
   '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'M', '2', '_', 'v', 'm', 'a', 'c', '2', 'e', 's', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'M', '2', '_', 'v', 'm', 'a', 'c', '2', 'e', 's', '_', 's', '0',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'M', '2', '_', 'v', 'm', 'a', 'c', '2', 'e', 's', '_',
-  's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'v', 'm', 'a', 'c', '2', 's',
-  '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'v', 'm', 'a', 'c', '2',
-  's', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'v', 'm', 'a', 'c',
-  '2', 's', 'u', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'v', 'm',
-  'a', 'c', '2', 's', 'u', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_',
-  'v', 'm', 'p', 'y', '2', 'e', 's', '_', 's', '0', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M',
-  '2', '_', 'v', 'm', 'p', 'y', '2', 'e', 's', '_', 's', '1', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'M', '2', '_', 'v', 'm', 'p', 'y', '2', 's', '_', 's', '0', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'M', '2', '_', 'v', 'm', 'p', 'y', '2', 's', '_', 's', '0', 'p',
-  'a', 'c', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'v', 'm', 'p', 'y', '2',
-  's', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'v', 'm', 'p', 'y',
-  '2', 's', '_', 's', '1', 'p', 'a', 'c', 'k', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2',
-  '_', 'v', 'm', 'p', 'y', '2', 's', 'u', '_', 's', '0', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'M', '2', '_', 'v', 'm', 'p', 'y', '2', 's', 'u', '_', 's', '1', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'M', '2', '_', 'v', 'r', 'a', 'd', 'd', 'h', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'M', '2', '_', 'v', 'r', 'a', 'd', 'd', 'u', 'h', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M',
-  '2', '_', 'v', 'r', 'c', 'm', 'a', 'c', 'i', '_', 's', '0', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'M', '2', '_', 'v', 'r', 'c', 'm', 'a', 'c', 'i', '_', 's', '0', 'c',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'M', '2', '_', 'v', 'r', 'c', 'm', 'a', 'c', 'r', '_',
+  'O', 'N', '_', 'M', '2', '_', 'v', 'm', 'a', 'c', '2', 'e', 's', '_', 's',
+  '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'v', 'm', 'a', 'c', '2', 's', '_',
   's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'v', 'r', 'c', 'm', 'a', 'c',
-  'r', '_', 's', '0', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'v', 'r', 'c',
-  'm', 'p', 'y', 'i', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'v', 'm', 'a', 'c', '2', 's',
+  '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'v', 'm', 'a', 'c', '2',
+  's', 'u', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'v', 'm', 'a',
+  'c', '2', 's', 'u', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
   'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'v',
-  'r', 'c', 'm', 'p', 'y', 'i', '_', 's', '0', 'c', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M',
-  '2', '_', 'v', 'r', 'c', 'm', 'p', 'y', 'r', '_', 's', '0', '\000', '_', '_',
+  'm', 'p', 'y', '2', 'e', 's', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2',
+  '_', 'v', 'm', 'p', 'y', '2', 'e', 's', '_', 's', '1', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'M', '2', '_', 'v', 'm', 'p', 'y', '2', 's', '_', 's', '0', '\000', '_', '_',
   'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'M', '2', '_', 'v', 'r', 'c', 'm', 'p', 'y', 'r', '_', 's', '0', 'c',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'M', '2', '_', 'v', 'r', 'c', 'm', 'p', 'y', 's', '_',
-  'a', 'c', 'c', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'v', 'r',
-  'c', 'm', 'p', 'y', 's', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  '_', 'M', '2', '_', 'v', 'm', 'p', 'y', '2', 's', '_', 's', '0', 'p', 'a',
+  'c', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'v', 'm', 'p', 'y', '2', 's',
+  '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'v', 'm', 'p', 'y', '2',
+  's', '_', 's', '1', 'p', 'a', 'c', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l',
   't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_',
-  'v', 'r', 'c', 'm', 'p', 'y', 's', '_', 's', '1', 'r', 'p', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'M', '2', '_', 'v', 'r', 'm', 'a', 'c', '_', 's', '0', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'M', '2', '_', 'v', 'r', 'm', 'p', 'y', '_', 's', '0', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'M', '2', '_', 'x', 'o', 'r', '_', 'x', 'a', 'c', 'c', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'M', '4', '_', 'a', 'n', 'd', '_', 'a', 'n', 'd', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'M', '4', '_', 'a', 'n', 'd', '_', 'a', 'n', 'd', 'n', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'M', '4', '_', 'a', 'n', 'd', '_', 'o', 'r', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '4',
-  '_', 'a', 'n', 'd', '_', 'x', 'o', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '4', '_',
-  'c', 'm', 'p', 'y', 'i', '_', 'w', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '4', '_',
-  'c', 'm', 'p', 'y', 'i', '_', 'w', 'h', 'c', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '4',
-  '_', 'c', 'm', 'p', 'y', 'r', '_', 'w', 'h', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '4',
-  '_', 'c', 'm', 'p', 'y', 'r', '_', 'w', 'h', 'c', '\000', '_', '_', 'b', 'u',
+  'v', 'm', 'p', 'y', '2', 's', 'u', '_', 's', '0', '\000', '_', '_', 'b', 'u',
   'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M',
-  '4', '_', 'm', 'a', 'c', '_', 'u', 'p', '_', 's', '1', '_', 's', 'a', 't',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'M', '4', '_', 'm', 'p', 'y', 'r', 'i', '_', 'a', 'd',
-  'd', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'M', '4', '_', 'm', 'p', 'y', 'r', 'i', '_',
-  'a', 'd', 'd', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '4', '_', 'm', 'p', 'y', 'r',
-  'i', '_', 'a', 'd', 'd', 'r', '_', 'u', '2', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '4',
-  '_', 'm', 'p', 'y', 'r', 'r', '_', 'a', 'd', 'd', 'i', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'M', '4', '_', 'm', 'p', 'y', 'r', 'r', '_', 'a', 'd', 'd', 'r', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'M', '4', '_', 'n', 'a', 'c', '_', 'u', 'p', '_', 's', '1', '_',
-  's', 'a', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '4', '_', 'o', 'r', '_', 'a', 'n',
-  'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'M', '4', '_', 'o', 'r', '_', 'a', 'n', 'd', 'n',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'M', '4', '_', 'o', 'r', '_', 'o', 'r', '\000', '_', '_',
+  '2', '_', 'v', 'm', 'p', 'y', '2', 's', 'u', '_', 's', '1', '\000', '_', '_',
   'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'M', '4', '_', 'o', 'r', '_', 'x', 'o', 'r', '\000', '_', '_', 'b', 'u',
+  '_', 'M', '2', '_', 'v', 'r', 'a', 'd', 'd', 'h', '\000', '_', '_', 'b', 'u',
   'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M',
-  '4', '_', 'p', 'm', 'p', 'y', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '4', '_', 'p',
-  'm', 'p', 'y', 'w', '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '4', '_',
-  'v', 'p', 'm', 'p', 'y', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '4', '_', 'v', 'p',
-  'm', 'p', 'y', 'h', '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '4', '_',
-  'v', 'r', 'm', 'p', 'y', 'e', 'h', '_', 'a', 'c', 'c', '_', 's', '0', '\000',
+  '2', '_', 'v', 'r', 'a', 'd', 'd', 'u', 'h', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2',
+  '_', 'v', 'r', 'c', 'm', 'a', 'c', 'i', '_', 's', '0', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'M', '2', '_', 'v', 'r', 'c', 'm', 'a', 'c', 'i', '_', 's', '0', 'c', '\000',
   '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'M', '4', '_', 'v', 'r', 'm', 'p', 'y', 'e', 'h', '_', 'a',
+  'O', 'N', '_', 'M', '2', '_', 'v', 'r', 'c', 'm', 'a', 'c', 'r', '_', 's',
+  '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'v', 'r', 'c', 'm', 'a', 'c', 'r',
+  '_', 's', '0', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'v', 'r', 'c', 'm',
+  'p', 'y', 'i', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'v', 'r',
+  'c', 'm', 'p', 'y', 'i', '_', 's', '0', 'c', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2',
+  '_', 'v', 'r', 'c', 'm', 'p', 'y', 'r', '_', 's', '0', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'M', '2', '_', 'v', 'r', 'c', 'm', 'p', 'y', 'r', '_', 's', '0', 'c', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'M', '2', '_', 'v', 'r', 'c', 'm', 'p', 'y', 's', '_', 'a',
+  'c', 'c', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'v', 'r', 'c',
+  'm', 'p', 'y', 's', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '2', '_', 'v',
+  'r', 'c', 'm', 'p', 'y', 's', '_', 's', '1', 'r', 'p', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'M', '2', '_', 'v', 'r', 'm', 'a', 'c', '_', 's', '0', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'M', '2', '_', 'v', 'r', 'm', 'p', 'y', '_', 's', '0', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'M', '2', '_', 'x', 'o', 'r', '_', 'x', 'a', 'c', 'c', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'M', '4', '_', 'a', 'n', 'd', '_', 'a', 'n', 'd', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M',
+  '4', '_', 'a', 'n', 'd', '_', 'a', 'n', 'd', 'n', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M',
+  '4', '_', 'a', 'n', 'd', '_', 'o', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '4', '_',
+  'a', 'n', 'd', '_', 'x', 'o', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '4', '_', 'c',
+  'm', 'p', 'y', 'i', '_', 'w', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '4', '_', 'c',
+  'm', 'p', 'y', 'i', '_', 'w', 'h', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '4', '_',
+  'c', 'm', 'p', 'y', 'r', '_', 'w', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '4', '_',
+  'c', 'm', 'p', 'y', 'r', '_', 'w', 'h', 'c', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '4',
+  '_', 'm', 'a', 'c', '_', 'u', 'p', '_', 's', '1', '_', 's', 'a', 't', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'M', '4', '_', 'm', 'p', 'y', 'r', 'i', '_', 'a', 'd', 'd',
+  'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'M', '4', '_', 'm', 'p', 'y', 'r', 'i', '_', 'a',
+  'd', 'd', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '4', '_', 'm', 'p', 'y', 'r', 'i',
+  '_', 'a', 'd', 'd', 'r', '_', 'u', '2', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '4', '_',
+  'm', 'p', 'y', 'r', 'r', '_', 'a', 'd', 'd', 'i', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M',
+  '4', '_', 'm', 'p', 'y', 'r', 'r', '_', 'a', 'd', 'd', 'r', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'M', '4', '_', 'n', 'a', 'c', '_', 'u', 'p', '_', 's', '1', '_', 's',
+  'a', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'M', '4', '_', 'o', 'r', '_', 'a', 'n', 'd',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'M', '4', '_', 'o', 'r', '_', 'a', 'n', 'd', 'n', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'M', '4', '_', 'o', 'r', '_', 'o', 'r', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'M', '4', '_', 'o', 'r', '_', 'x', 'o', 'r', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '4',
+  '_', 'p', 'm', 'p', 'y', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '4', '_', 'p', 'm',
+  'p', 'y', 'w', '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '4', '_', 'v',
+  'p', 'm', 'p', 'y', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '4', '_', 'v', 'p', 'm',
+  'p', 'y', 'h', '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '4', '_', 'v',
+  'r', 'm', 'p', 'y', 'e', 'h', '_', 'a', 'c', 'c', '_', 's', '0', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'M', '4', '_', 'v', 'r', 'm', 'p', 'y', 'e', 'h', '_', 'a', 'c',
+  'c', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '4', '_', 'v', 'r', 'm', 'p',
+  'y', 'e', 'h', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '4', '_', 'v', 'r',
+  'm', 'p', 'y', 'e', 'h', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '4', '_',
+  'v', 'r', 'm', 'p', 'y', 'o', 'h', '_', 'a', 'c', 'c', '_', 's', '0', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'M', '4', '_', 'v', 'r', 'm', 'p', 'y', 'o', 'h', '_', 'a',
   'c', 'c', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
   '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '4', '_', 'v', 'r', 'm',
-  'p', 'y', 'e', 'h', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'p', 'y', 'o', 'h', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
   'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '4', '_', 'v',
-  'r', 'm', 'p', 'y', 'e', 'h', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i',
+  'r', 'm', 'p', 'y', 'o', 'h', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i',
   'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '4',
-  '_', 'v', 'r', 'm', 'p', 'y', 'o', 'h', '_', 'a', 'c', 'c', '_', 's', '0',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'M', '4', '_', 'v', 'r', 'm', 'p', 'y', 'o', 'h', '_',
-  'a', 'c', 'c', '_', 's', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '4', '_', 'v', 'r',
-  'm', 'p', 'y', 'o', 'h', '_', 's', '0', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  '_', 'x', 'o', 'r', '_', 'a', 'n', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l',
   't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '4', '_',
-  'v', 'r', 'm', 'p', 'y', 'o', 'h', '_', 's', '1', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M',
-  '4', '_', 'x', 'o', 'r', '_', 'a', 'n', 'd', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '4',
-  '_', 'x', 'o', 'r', '_', 'a', 'n', 'd', 'n', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '4',
-  '_', 'x', 'o', 'r', '_', 'o', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '4', '_', 'x',
-  'o', 'r', '_', 'x', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '5', '_', 'v',
-  'd', 'm', 'a', 'c', 'b', 's', 'u', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '5', '_', 'v',
-  'd', 'm', 'p', 'y', 'b', 's', 'u', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '5', '_', 'v',
+  'x', 'o', 'r', '_', 'a', 'n', 'd', 'n', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '4', '_',
+  'x', 'o', 'r', '_', 'o', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '4', '_', 'x', 'o',
+  'r', '_', 'x', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '5', '_', 'v', 'd',
   'm', 'a', 'c', 'b', 's', 'u', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '5', '_', 'v', 'd',
+  'm', 'p', 'y', 'b', 's', 'u', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
   'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '5', '_', 'v', 'm',
-  'a', 'c', 'b', 'u', 'u', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '5', '_', 'v', 'm', 'p',
-  'y', 'b', 's', 'u', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'a', 'c', 'b', 's', 'u', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '5', '_', 'v', 'm', 'a',
+  'c', 'b', 'u', 'u', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
   'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '5', '_', 'v', 'm', 'p', 'y',
-  'b', 'u', 'u', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '5', '_', 'v', 'r', 'm', 'a', 'c',
   'b', 's', 'u', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '5', '_', 'v', 'r', 'm', 'a', 'c',
-  'b', 'u', 'u', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '5', '_', 'v', 'r', 'm', 'p', 'y',
-  'b', 's', 'u', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '5', '_', 'v', 'r', 'm', 'p', 'y',
-  'b', 'u', 'u', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '5', '_', 'v', 'm', 'p', 'y', 'b',
+  'u', 'u', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'M', '5', '_', 'v', 'r', 'm', 'a', 'c', 'b',
+  's', 'u', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'M', '5', '_', 'v', 'r', 'm', 'a', 'c', 'b',
+  'u', 'u', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'M', '5', '_', 'v', 'r', 'm', 'p', 'y', 'b',
+  's', 'u', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'M', '5', '_', 'v', 'r', 'm', 'p', 'y', 'b',
+  'u', 'u', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'M', '6', '_', 'v', 'a', 'b', 's', 'd', 'i',
+  'f', 'f', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
   'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '6', '_', 'v', 'a', 'b', 's', 'd',
-  'i', 'f', 'f', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '6', '_', 'v', 'a', 'b', 's',
-  'd', 'i', 'f', 'f', 'u', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'a', 'd',
-  'd', 'a', 's', 'l', '_', 'r', 'r', 'r', 'i', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2',
-  '_', 'a', 's', 'l', '_', 'i', '_', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_',
-  'a', 's', 'l', '_', 'i', '_', 'p', '_', 'a', 'c', 'c', '\000', '_', '_', 'b',
+  'i', 'f', 'f', 'u', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '7', '_', 'd', 'c', 'm',
+  'p', 'y', 'i', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '7', '_', 'd', 'c', 'm', 'p',
+  'y', 'i', 'w', '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '7', '_', 'd',
+  'c', 'm', 'p', 'y', 'i', 'w', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '7', '_', 'd',
+  'c', 'm', 'p', 'y', 'i', 'w', 'c', '_', 'a', 'c', 'c', '\000', '_', '_', 'b',
   'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'S', '2', '_', 'a', 's', 'l', '_', 'i', '_', 'p', '_', 'a', 'n', 'd', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'S', '2', '_', 'a', 's', 'l', '_', 'i', '_', 'p', '_', 'n',
-  'a', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'a', 's', 'l', '_', 'i', '_',
-  'p', '_', 'o', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'a', 's', 'l', '_',
-  'i', '_', 'p', '_', 'x', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_',
-  'a', 's', 'l', '_', 'i', '_', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'a',
-  's', 'l', '_', 'i', '_', 'r', '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S',
-  '2', '_', 'a', 's', 'l', '_', 'i', '_', 'r', '_', 'a', 'n', 'd', '\000', '_',
+  'M', '7', '_', 'd', 'c', 'm', 'p', 'y', 'r', 'w', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M',
+  '7', '_', 'd', 'c', 'm', 'p', 'y', 'r', 'w', '_', 'a', 'c', 'c', '\000', '_',
   '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'S', '2', '_', 'a', 's', 'l', '_', 'i', '_', 'r', '_', 'n', 'a',
+  'N', '_', 'M', '7', '_', 'd', 'c', 'm', 'p', 'y', 'r', 'w', 'c', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'M', '7', '_', 'd', 'c', 'm', 'p', 'y', 'r', 'w', 'c', '_', 'a',
+  'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'M', '7', '_', 'v', 'd', 'm', 'p', 'y', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'M', '7', '_', 'v', 'd', 'm', 'p', 'y', '_', 'a', 'c', 'c',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'M', '7', '_', 'w', 'c', 'm', 'p', 'y', 'i', 'w', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'M', '7', '_', 'w', 'c', 'm', 'p', 'y', 'i', 'w', '_', 'r',
+  'n', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'M', '7', '_', 'w', 'c', 'm', 'p', 'y', 'i',
+  'w', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'M', '7', '_', 'w', 'c', 'm', 'p', 'y', 'i',
+  'w', 'c', '_', 'r', 'n', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '7', '_', 'w', 'c',
+  'm', 'p', 'y', 'r', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '7', '_', 'w', 'c', 'm',
+  'p', 'y', 'r', 'w', '_', 'r', 'n', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '7', '_',
+  'w', 'c', 'm', 'p', 'y', 'r', 'w', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'M', '7', '_',
+  'w', 'c', 'm', 'p', 'y', 'r', 'w', 'c', '_', 'r', 'n', 'd', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'S', '2', '_', 'a', 'd', 'd', 'a', 's', 'l', '_', 'r', 'r', 'r', 'i',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'S', '2', '_', 'a', 's', 'l', '_', 'i', '_', 'p', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'S', '2', '_', 'a', 's', 'l', '_', 'i', '_', 'p', '_', 'a',
+  'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'a', 's', 'l', '_', 'i', '_',
+  'p', '_', 'a', 'n', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'a', 's', 'l',
+  '_', 'i', '_', 'p', '_', 'n', 'a', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_',
+  'a', 's', 'l', '_', 'i', '_', 'p', '_', 'o', 'r', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S',
+  '2', '_', 'a', 's', 'l', '_', 'i', '_', 'p', '_', 'x', 'a', 'c', 'c', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'S', '2', '_', 'a', 's', 'l', '_', 'i', '_', 'r', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'S', '2', '_', 'a', 's', 'l', '_', 'i', '_', 'r', '_', 'a', 'c',
   'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
   'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'a', 's', 'l', '_', 'i', '_', 'r',
-  '_', 'o', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'a', 's', 'l', '_', 'i',
-  '_', 'r', '_', 's', 'a', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'a', 's',
-  'l', '_', 'i', '_', 'r', '_', 'x', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S',
-  '2', '_', 'a', 's', 'l', '_', 'i', '_', 'v', 'h', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S',
-  '2', '_', 'a', 's', 'l', '_', 'i', '_', 'v', 'w', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S',
-  '2', '_', 'a', 's', 'l', '_', 'r', '_', 'p', '\000', '_', '_', 'b', 'u', 'i',
+  '_', 'a', 'n', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'a', 's', 'l', '_',
+  'i', '_', 'r', '_', 'n', 'a', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'a',
+  's', 'l', '_', 'i', '_', 'r', '_', 'o', 'r', '\000', '_', '_', 'b', 'u', 'i',
   'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2',
-  '_', 'a', 's', 'l', '_', 'r', '_', 'p', '_', 'a', 'c', 'c', '\000', '_', '_',
+  '_', 'a', 's', 'l', '_', 'i', '_', 'r', '_', 's', 'a', 't', '\000', '_', '_',
   'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'S', '2', '_', 'a', 's', 'l', '_', 'r', '_', 'p', '_', 'a', 'n', 'd',
+  '_', 'S', '2', '_', 'a', 's', 'l', '_', 'i', '_', 'r', '_', 'x', 'a', 'c',
+  'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'a', 's', 'l', '_', 'i', '_', 'v',
+  'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'a', 's', 'l', '_', 'i', '_', 'v',
+  'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'a', 's', 'l', '_', 'r', '_', 'p',
   '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
   'G', 'O', 'N', '_', 'S', '2', '_', 'a', 's', 'l', '_', 'r', '_', 'p', '_',
-  'n', 'a', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
   'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'a', 's', 'l', '_', 'r',
-  '_', 'p', '_', 'o', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'a', 's', 'l',
-  '_', 'r', '_', 'p', '_', 'x', 'o', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_',
-  'a', 's', 'l', '_', 'r', '_', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'a',
-  's', 'l', '_', 'r', '_', 'r', '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S',
-  '2', '_', 'a', 's', 'l', '_', 'r', '_', 'r', '_', 'a', 'n', 'd', '\000', '_',
+  '_', 'p', '_', 'a', 'n', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'a', 's',
+  'l', '_', 'r', '_', 'p', '_', 'n', 'a', 'c', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2',
+  '_', 'a', 's', 'l', '_', 'r', '_', 'p', '_', 'o', 'r', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'S', '2', '_', 'a', 's', 'l', '_', 'r', '_', 'p', '_', 'x', 'o', 'r', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'S', '2', '_', 'a', 's', 'l', '_', 'r', '_', 'r', '\000', '_',
   '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'S', '2', '_', 'a', 's', 'l', '_', 'r', '_', 'r', '_', 'n', 'a',
+  'N', '_', 'S', '2', '_', 'a', 's', 'l', '_', 'r', '_', 'r', '_', 'a', 'c',
   'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
   'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'a', 's', 'l', '_', 'r', '_', 'r',
-  '_', 'o', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'a', 's', 'l', '_', 'r',
-  '_', 'r', '_', 's', 'a', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'a', 's',
-  'l', '_', 'r', '_', 'v', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'a', 's',
-  'l', '_', 'r', '_', 'v', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'a', 's',
-  'r', '_', 'i', '_', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'a', 's', 'r',
-  '_', 'i', '_', 'p', '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_',
-  'a', 's', 'r', '_', 'i', '_', 'p', '_', 'a', 'n', 'd', '\000', '_', '_', 'b',
+  '_', 'a', 'n', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'a', 's', 'l', '_',
+  'r', '_', 'r', '_', 'n', 'a', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'a',
+  's', 'l', '_', 'r', '_', 'r', '_', 'o', 'r', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2',
+  '_', 'a', 's', 'l', '_', 'r', '_', 'r', '_', 's', 'a', 't', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'S', '2', '_', 'a', 's', 'l', '_', 'r', '_', 'v', 'h', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'S', '2', '_', 'a', 's', 'l', '_', 'r', '_', 'v', 'w', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'S', '2', '_', 'a', 's', 'r', '_', 'i', '_', 'p', '\000', '_', '_', 'b',
   'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'S', '2', '_', 'a', 's', 'r', '_', 'i', '_', 'p', '_', 'n', 'a', 'c', '\000',
+  'S', '2', '_', 'a', 's', 'r', '_', 'i', '_', 'p', '_', 'a', 'c', 'c', '\000',
   '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'S', '2', '_', 'a', 's', 'r', '_', 'i', '_', 'p', '_', 'o',
-  'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'a', 's', 'r', '_', 'i', '_', 'p',
-  '_', 'r', 'n', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'a', 's', 'r', '_',
-  'i', '_', 'p', '_', 'r', 'n', 'd', '_', 'g', 'o', 'o', 'd', 's', 'y', 'n',
-  't', 'a', 'x', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'a', 's', 'r', '_', 'i',
-  '_', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'O', 'N', '_', 'S', '2', '_', 'a', 's', 'r', '_', 'i', '_', 'p', '_', 'a',
+  'n', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
   'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'a', 's', 'r', '_', 'i', '_',
-  'r', '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  'p', '_', 'n', 'a', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
   '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'a', 's', 'r',
-  '_', 'i', '_', 'r', '_', 'a', 'n', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  '_', 'i', '_', 'p', '_', 'o', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'a',
+  's', 'r', '_', 'i', '_', 'p', '_', 'r', 'n', 'd', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S',
+  '2', '_', 'a', 's', 'r', '_', 'i', '_', 'p', '_', 'r', 'n', 'd', '_', 'g',
+  'o', 'o', 'd', 's', 'y', 'n', 't', 'a', 'x', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2',
+  '_', 'a', 's', 'r', '_', 'i', '_', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l',
   't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_',
-  'a', 's', 'r', '_', 'i', '_', 'r', '_', 'n', 'a', 'c', '\000', '_', '_', 'b',
+  'a', 's', 'r', '_', 'i', '_', 'r', '_', 'a', 'c', 'c', '\000', '_', '_', 'b',
   'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'S', '2', '_', 'a', 's', 'r', '_', 'i', '_', 'r', '_', 'o', 'r', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'S', '2', '_', 'a', 's', 'r', '_', 'i', '_', 'r', '_', 'r', 'n',
-  'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'a', 's', 'r', '_', 'i', '_', 'r',
-  '_', 'r', 'n', 'd', '_', 'g', 'o', 'o', 'd', 's', 'y', 'n', 't', 'a', 'x',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'S', '2', '_', 'a', 's', 'r', '_', 'i', '_', 's', 'v',
-  'w', '_', 't', 'r', 'u', 'n', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'a', 's',
-  'r', '_', 'i', '_', 'v', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'a', 's',
-  'r', '_', 'i', '_', 'v', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'a', 's',
-  'r', '_', 'r', '_', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'a', 's', 'r',
-  '_', 'r', '_', 'p', '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_',
-  'a', 's', 'r', '_', 'r', '_', 'p', '_', 'a', 'n', 'd', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'S', '2', '_', 'a', 's', 'r', '_', 'r', '_', 'p', '_', 'n', 'a', 'c', '\000',
+  'S', '2', '_', 'a', 's', 'r', '_', 'i', '_', 'r', '_', 'a', 'n', 'd', '\000',
   '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'S', '2', '_', 'a', 's', 'r', '_', 'r', '_', 'p', '_', 'o',
-  'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'a', 's', 'r', '_', 'r', '_', 'p',
-  '_', 'x', 'o', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'O', 'N', '_', 'S', '2', '_', 'a', 's', 'r', '_', 'i', '_', 'r', '_', 'n',
+  'a', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'a', 's', 'r', '_', 'i', '_',
+  'r', '_', 'o', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
   'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'a', 's', 'r', '_',
-  'r', '_', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'a', 's', 'r', '_', 'r',
-  '_', 'r', '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'i', '_', 'r', '_', 'r', 'n', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'a',
+  's', 'r', '_', 'i', '_', 'r', '_', 'r', 'n', 'd', '_', 'g', 'o', 'o', 'd',
+  's', 'y', 'n', 't', 'a', 'x', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
   'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'a', 's',
-  'r', '_', 'r', '_', 'r', '_', 'a', 'n', 'd', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2',
-  '_', 'a', 's', 'r', '_', 'r', '_', 'r', '_', 'n', 'a', 'c', '\000', '_', '_',
+  'r', '_', 'i', '_', 's', 'v', 'w', '_', 't', 'r', 'u', 'n', '\000', '_', '_',
   'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'S', '2', '_', 'a', 's', 'r', '_', 'r', '_', 'r', '_', 'o', 'r', '\000',
+  '_', 'S', '2', '_', 'a', 's', 'r', '_', 'i', '_', 'v', 'h', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'S', '2', '_', 'a', 's', 'r', '_', 'i', '_', 'v', 'w', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'S', '2', '_', 'a', 's', 'r', '_', 'r', '_', 'p', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'S', '2', '_', 'a', 's', 'r', '_', 'r', '_', 'p', '_', 'a', 'c', 'c', '\000',
   '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'S', '2', '_', 'a', 's', 'r', '_', 'r', '_', 'r', '_', 's',
-  'a', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'O', 'N', '_', 'S', '2', '_', 'a', 's', 'r', '_', 'r', '_', 'p', '_', 'a',
+  'n', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
   'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'a', 's', 'r', '_', 'r', '_',
-  's', 'v', 'w', '_', 't', 'r', 'u', 'n', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_',
-  'a', 's', 'r', '_', 'r', '_', 'v', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_',
-  'a', 's', 'r', '_', 'r', '_', 'v', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_',
-  'b', 'r', 'e', 'v', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'b', 'r', 'e', 'v',
-  'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'c', 'l', '0', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'S', '2', '_', 'c', 'l', '0', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'c',
-  'l', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'c', 'l', '1', 'p', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'S', '2', '_', 'c', 'l', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_',
-  'c', 'l', 'b', 'n', 'o', 'r', 'm', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'c',
-  'l', 'b', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'c', 'l', 'r', 'b', 'i',
-  't', '_', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'c', 'l', 'r', 'b', 'i',
-  't', '_', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'c', 't', '0', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'S', '2', '_', 'c', 't', '0', 'p', '\000', '_', '_', 'b', 'u', 'i',
+  'p', '_', 'n', 'a', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'a', 's', 'r',
+  '_', 'r', '_', 'p', '_', 'o', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'a',
+  's', 'r', '_', 'r', '_', 'p', '_', 'x', 'o', 'r', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S',
+  '2', '_', 'a', 's', 'r', '_', 'r', '_', 'r', '\000', '_', '_', 'b', 'u', 'i',
   'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2',
-  '_', 'c', 't', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'c', 't', '1', 'p',
+  '_', 'a', 's', 'r', '_', 'r', '_', 'r', '_', 'a', 'c', 'c', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'S', '2', '_', 'a', 's', 'r', '_', 'r', '_', 'r', '_', 'a', 'n', 'd',
   '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'S', '2', '_', 'd', 'e', 'i', 'n', 't', 'e', 'r', 'l',
-  'e', 'a', 'v', 'e', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'e', 'x', 't', 'r',
-  'a', 'c', 't', 'u', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'e', 'x', 't', 'r',
-  'a', 'c', 't', 'u', '_', 'r', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'e',
-  'x', 't', 'r', 'a', 'c', 't', 'u', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  'G', 'O', 'N', '_', 'S', '2', '_', 'a', 's', 'r', '_', 'r', '_', 'r', '_',
+  'n', 'a', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'a', 's', 'r', '_', 'r',
+  '_', 'r', '_', 'o', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'a', 's', 'r',
+  '_', 'r', '_', 'r', '_', 's', 'a', 't', '\000', '_', '_', 'b', 'u', 'i', 'l',
   't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_',
-  'e', 'x', 't', 'r', 'a', 'c', 't', 'u', 'p', '_', 'r', 'p', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'S', '2', '_', 'i', 'n', 's', 'e', 'r', 't', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S',
-  '2', '_', 'i', 'n', 's', 'e', 'r', 't', '_', 'r', 'p', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'S', '2', '_', 'i', 'n', 's', 'e', 'r', 't', 'p', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S',
-  '2', '_', 'i', 'n', 's', 'e', 'r', 't', 'p', '_', 'r', 'p', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'S', '2', '_', 'i', 'n', 't', 'e', 'r', 'l', 'e', 'a', 'v', 'e', '\000',
+  'a', 's', 'r', '_', 'r', '_', 's', 'v', 'w', '_', 't', 'r', 'u', 'n', '\000',
   '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'S', '2', '_', 'l', 'f', 's', 'p', '\000', '_', '_', 'b', 'u',
+  'O', 'N', '_', 'S', '2', '_', 'a', 's', 'r', '_', 'r', '_', 'v', 'h', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'S', '2', '_', 'a', 's', 'r', '_', 'r', '_', 'v', 'w', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'S', '2', '_', 'b', 'r', 'e', 'v', '\000', '_', '_', 'b', 'u',
   'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S',
-  '2', '_', 'l', 's', 'l', '_', 'r', '_', 'p', '\000', '_', '_', 'b', 'u', 'i',
+  '2', '_', 'b', 'r', 'e', 'v', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'c',
+  'l', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'c', 'l', '0', 'p', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'S', '2', '_', 'c', 'l', '1', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_',
+  'c', 'l', '1', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'c', 'l', 'b', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'S', '2', '_', 'c', 'l', 'b', 'n', 'o', 'r', 'm', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'S', '2', '_', 'c', 'l', 'b', 'p', '\000', '_', '_', 'b', 'u', 'i',
   'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2',
-  '_', 'l', 's', 'l', '_', 'r', '_', 'p', '_', 'a', 'c', 'c', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'S', '2', '_', 'l', 's', 'l', '_', 'r', '_', 'p', '_', 'a', 'n', 'd',
+  '_', 'c', 'l', 'r', 'b', 'i', 't', '_', 'i', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2',
+  '_', 'c', 'l', 'r', 'b', 'i', 't', '_', 'r', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2',
+  '_', 'c', 't', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'c', 't', '0', 'p',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'S', '2', '_', 'c', 't', '1', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S',
+  '2', '_', 'c', 't', '1', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'd', 'e',
+  'i', 'n', 't', 'e', 'r', 'l', 'e', 'a', 'v', 'e', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S',
+  '2', '_', 'e', 'x', 't', 'r', 'a', 'c', 't', 'u', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S',
+  '2', '_', 'e', 'x', 't', 'r', 'a', 'c', 't', 'u', '_', 'r', 'p', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'S', '2', '_', 'e', 'x', 't', 'r', 'a', 'c', 't', 'u', 'p', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'S', '2', '_', 'e', 'x', 't', 'r', 'a', 'c', 't', 'u', 'p',
+  '_', 'r', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'i', 'n', 's', 'e', 'r',
+  't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'i', 'n', 's', 'e', 'r', 't', '_',
+  'r', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'i', 'n', 's', 'e', 'r', 't',
+  'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'i', 'n', 's', 'e', 'r', 't', 'p',
+  '_', 'r', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'i', 'n', 't', 'e', 'r',
+  'l', 'e', 'a', 'v', 'e', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'l', 'f', 's',
+  'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'l', 's', 'l', '_', 'r', '_', 'p',
   '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
   'G', 'O', 'N', '_', 'S', '2', '_', 'l', 's', 'l', '_', 'r', '_', 'p', '_',
-  'n', 'a', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'l', 's', 'l', '_', 'r',
-  '_', 'p', '_', 'o', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'l', 's', 'l',
-  '_', 'r', '_', 'p', '_', 'x', 'o', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_',
-  'l', 's', 'l', '_', 'r', '_', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'l',
-  's', 'l', '_', 'r', '_', 'r', '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S',
-  '2', '_', 'l', 's', 'l', '_', 'r', '_', 'r', '_', 'a', 'n', 'd', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'S', '2', '_', 'l', 's', 'l', '_', 'r', '_', 'r', '_', 'n', 'a',
-  'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'l', 's', 'l', '_', 'r', '_', 'r',
-  '_', 'o', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'l', 's', 'l', '_', 'r',
-  '_', 'v', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'l', 's', 'l', '_', 'r',
-  '_', 'v', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'l', 's', 'r', '_', 'i',
-  '_', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'l', 's', 'r', '_', 'i', '_',
-  'p', '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'l', 's', 'r',
-  '_', 'i', '_', 'p', '_', 'a', 'n', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_',
-  'l', 's', 'r', '_', 'i', '_', 'p', '_', 'n', 'a', 'c', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'S', '2', '_', 'l', 's', 'r', '_', 'i', '_', 'p', '_', 'o', 'r', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'S', '2', '_', 'l', 's', 'r', '_', 'i', '_', 'p', '_', 'x', 'a',
-  'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'l', 's', 'r', '_', 'i', '_',
-  'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'l', 's', 'r', '_', 'i', '_', 'r',
-  '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'l', 's', 'r', '_',
-  'i', '_', 'r', '_', 'a', 'n', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'l',
-  's', 'r', '_', 'i', '_', 'r', '_', 'n', 'a', 'c', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S',
-  '2', '_', 'l', 's', 'r', '_', 'i', '_', 'r', '_', 'o', 'r', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'S', '2', '_', 'l', 's', 'r', '_', 'i', '_', 'r', '_', 'x', 'a', 'c',
-  'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'l', 's', 'r', '_', 'i', '_', 'v',
-  'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'l', 's', 'r', '_', 'i', '_', 'v',
-  'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'l', 's', 'r', '_', 'r', '_', 'p',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'S', '2', '_', 'l', 's', 'r', '_', 'r', '_', 'p', '_',
   'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'l', 's', 'r', '_', 'r',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'l', 's', 'l', '_', 'r',
   '_', 'p', '_', 'a', 'n', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
   'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'l', 's',
-  'r', '_', 'r', '_', 'p', '_', 'n', 'a', 'c', '\000', '_', '_', 'b', 'u', 'i',
+  'l', '_', 'r', '_', 'p', '_', 'n', 'a', 'c', '\000', '_', '_', 'b', 'u', 'i',
   'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2',
-  '_', 'l', 's', 'r', '_', 'r', '_', 'p', '_', 'o', 'r', '\000', '_', '_', 'b',
+  '_', 'l', 's', 'l', '_', 'r', '_', 'p', '_', 'o', 'r', '\000', '_', '_', 'b',
   'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'S', '2', '_', 'l', 's', 'r', '_', 'r', '_', 'p', '_', 'x', 'o', 'r', '\000',
+  'S', '2', '_', 'l', 's', 'l', '_', 'r', '_', 'p', '_', 'x', 'o', 'r', '\000',
   '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'S', '2', '_', 'l', 's', 'r', '_', 'r', '_', 'r', '\000', '_',
+  'O', 'N', '_', 'S', '2', '_', 'l', 's', 'l', '_', 'r', '_', 'r', '\000', '_',
   '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'S', '2', '_', 'l', 's', 'r', '_', 'r', '_', 'r', '_', 'a', 'c',
+  'N', '_', 'S', '2', '_', 'l', 's', 'l', '_', 'r', '_', 'r', '_', 'a', 'c',
   'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'l', 's', 'r', '_', 'r', '_', 'r',
+  'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'l', 's', 'l', '_', 'r', '_', 'r',
   '_', 'a', 'n', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'l', 's', 'r', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'l', 's', 'l', '_',
   'r', '_', 'r', '_', 'n', 'a', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
   'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'l',
-  's', 'r', '_', 'r', '_', 'r', '_', 'o', 'r', '\000', '_', '_', 'b', 'u', 'i',
+  's', 'l', '_', 'r', '_', 'r', '_', 'o', 'r', '\000', '_', '_', 'b', 'u', 'i',
   'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2',
-  '_', 'l', 's', 'r', '_', 'r', '_', 'v', 'h', '\000', '_', '_', 'b', 'u', 'i',
+  '_', 'l', 's', 'l', '_', 'r', '_', 'v', 'h', '\000', '_', '_', 'b', 'u', 'i',
   'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2',
-  '_', 'l', 's', 'r', '_', 'r', '_', 'v', 'w', '\000', '_', '_', 'b', 'u', 'i',
+  '_', 'l', 's', 'l', '_', 'r', '_', 'v', 'w', '\000', '_', '_', 'b', 'u', 'i',
   'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2',
-  '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'p', 'a', 'c',
-  'k', 'h', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'p', 'a', 'r', 'i', 't',
-  'y', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 's', 'e', 't', 'b', 'i', 't',
-  '_', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 's', 'e', 't', 'b', 'i', 't',
-  '_', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 's', 'h', 'u', 'f', 'f', 'e',
-  'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'S', '2', '_', 's', 'h', 'u', 'f', 'f', 'e', 'h',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'S', '2', '_', 's', 'h', 'u', 'f', 'f', 'o', 'b', '\000',
+  '_', 'l', 's', 'r', '_', 'i', '_', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_',
+  'l', 's', 'r', '_', 'i', '_', 'p', '_', 'a', 'c', 'c', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'S', '2', '_', 'l', 's', 'r', '_', 'i', '_', 'p', '_', 'a', 'n', 'd', '\000',
   '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'S', '2', '_', 's', 'h', 'u', 'f', 'f', 'o', 'h', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'b', 'r', 'e', 'v', '_', 's',
-  't', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'b', 'r',
-  'e', 'v', '_', 's', 't', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'b', 'r', 'e', 'v', '_', 's', 't', 'h', 'h', 'i', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'b', 'r', 'e', 'v', '_', 's', 't',
-  'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'b', 'r', 'e',
-  'v', '_', 's', 't', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 's', 't', 'o',
-  'r', 'e', 'w', '_', 'l', 'o', 'c', 'k', 'e', 'd', '\000', '_', '_', 'b', 'u',
+  'O', 'N', '_', 'S', '2', '_', 'l', 's', 'r', '_', 'i', '_', 'p', '_', 'n',
+  'a', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'l', 's', 'r', '_', 'i', '_',
+  'p', '_', 'o', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'l', 's', 'r', '_',
+  'i', '_', 'p', '_', 'x', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_',
+  'l', 's', 'r', '_', 'i', '_', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'l',
+  's', 'r', '_', 'i', '_', 'r', '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u',
   'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S',
-  '2', '_', 's', 'v', 's', 'a', 't', 'h', 'b', '\000', '_', '_', 'b', 'u', 'i',
+  '2', '_', 'l', 's', 'r', '_', 'i', '_', 'r', '_', 'a', 'n', 'd', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'S', '2', '_', 'l', 's', 'r', '_', 'i', '_', 'r', '_', 'n', 'a',
+  'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'l', 's', 'r', '_', 'i', '_', 'r',
+  '_', 'o', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'l', 's', 'r', '_', 'i',
+  '_', 'r', '_', 'x', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'l',
+  's', 'r', '_', 'i', '_', 'v', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'l',
+  's', 'r', '_', 'i', '_', 'v', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'l',
+  's', 'r', '_', 'r', '_', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'l', 's',
+  'r', '_', 'r', '_', 'p', '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i',
   'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2',
-  '_', 's', 'v', 's', 'a', 't', 'h', 'u', 'b', '\000', '_', '_', 'b', 'u', 'i',
+  '_', 'l', 's', 'r', '_', 'r', '_', 'p', '_', 'a', 'n', 'd', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'S', '2', '_', 'l', 's', 'r', '_', 'r', '_', 'p', '_', 'n', 'a', 'c',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'S', '2', '_', 'l', 's', 'r', '_', 'r', '_', 'p', '_',
+  'o', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'l', 's', 'r', '_', 'r', '_',
+  'p', '_', 'x', 'o', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'l', 's', 'r',
+  '_', 'r', '_', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'l', 's', 'r', '_',
+  'r', '_', 'r', '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'l',
+  's', 'r', '_', 'r', '_', 'r', '_', 'a', 'n', 'd', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S',
+  '2', '_', 'l', 's', 'r', '_', 'r', '_', 'r', '_', 'n', 'a', 'c', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'S', '2', '_', 'l', 's', 'r', '_', 'r', '_', 'r', '_', 'o', 'r',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'S', '2', '_', 'l', 's', 'r', '_', 'r', '_', 'v', 'h',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'S', '2', '_', 'l', 's', 'r', '_', 'r', '_', 'v', 'w',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'S', '2', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'S', '2', '_', 'p', 'a', 'c', 'k', 'h', 'l', '\000', '_', '_', 'b', 'u', 'i',
   'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2',
-  '_', 't', 'a', 'b', 'l', 'e', 'i', 'd', 'x', 'b', '_', 'g', 'o', 'o', 'd',
-  's', 'y', 'n', 't', 'a', 'x', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 't', 'a',
-  'b', 'l', 'e', 'i', 'd', 'x', 'd', '_', 'g', 'o', 'o', 'd', 's', 'y', 'n',
-  't', 'a', 'x', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 't', 'a', 'b', 'l', 'e',
-  'i', 'd', 'x', 'h', '_', 'g', 'o', 'o', 'd', 's', 'y', 'n', 't', 'a', 'x',
+  '_', 'p', 'a', 'r', 'i', 't', 'y', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_',
+  's', 'e', 't', 'b', 'i', 't', '_', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_',
+  's', 'e', 't', 'b', 'i', 't', '_', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_',
+  's', 'h', 'u', 'f', 'f', 'e', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 's',
+  'h', 'u', 'f', 'f', 'e', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 's', 'h',
+  'u', 'f', 'f', 'o', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 's', 'h', 'u',
+  'f', 'f', 'o', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'b', 'r', 'e', 'v', '_', 's', 't', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'b', 'r', 'e', 'v', '_', 's', 't', 'd', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'b', 'r', 'e', 'v', '_', 's', 't',
+  'h', 'h', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'b',
+  'r', 'e', 'v', '_', 's', 't', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'b', 'r', 'e', 'v', '_', 's', 't', 'w', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'S', '2', '_', 's', 't', 'o', 'r', 'e', 'w', '_', 'l', 'o', 'c', 'k', 'e',
+  'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'S', '2', '_', 's', 'v', 's', 'a', 't', 'h', 'b',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'S', '2', '_', 's', 'v', 's', 'a', 't', 'h', 'u', 'b',
   '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
   'G', 'O', 'N', '_', 'S', '2', '_', 't', 'a', 'b', 'l', 'e', 'i', 'd', 'x',
-  'w', '_', 'g', 'o', 'o', 'd', 's', 'y', 'n', 't', 'a', 'x', '\000', '_', '_',
+  'b', '_', 'g', 'o', 'o', 'd', 's', 'y', 'n', 't', 'a', 'x', '\000', '_', '_',
   'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'S', '2', '_', 't', 'o', 'g', 'g', 'l', 'e', 'b', 'i', 't', '_', 'i',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'S', '2', '_', 't', 'o', 'g', 'g', 'l', 'e', 'b', 'i',
-  't', '_', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 't', 's', 't', 'b', 'i',
-  't', '_', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 't', 's', 't', 'b', 'i',
-  't', '_', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'v', 'a', 'l', 'i', 'g',
-  'n', 'i', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'v', 'a', 'l', 'i', 'g',
-  'n', 'r', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'v', 'c', 'n', 'e', 'g',
-  'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'v', 'c', 'r', 'o', 't', 'a', 't',
-  'e', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'v', 'r', 'c', 'n', 'e', 'g', 'h',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'S', '2', '_', 'v', 'r', 'n', 'd', 'p', 'a', 'c', 'k',
-  'w', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'v', 'r', 'n', 'd', 'p', 'a',
-  'c', 'k', 'w', 'h', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'v', 's', 'a',
-  't', 'h', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'v', 's', 'a', 't', 'h',
-  'b', '_', 'n', 'o', 'p', 'a', 'c', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_',
-  'v', 's', 'a', 't', 'h', 'u', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  '_', 'S', '2', '_', 't', 'a', 'b', 'l', 'e', 'i', 'd', 'x', 'd', '_', 'g',
+  'o', 'o', 'd', 's', 'y', 'n', 't', 'a', 'x', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2',
+  '_', 't', 'a', 'b', 'l', 'e', 'i', 'd', 'x', 'h', '_', 'g', 'o', 'o', 'd',
+  's', 'y', 'n', 't', 'a', 'x', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 't', 'a',
+  'b', 'l', 'e', 'i', 'd', 'x', 'w', '_', 'g', 'o', 'o', 'd', 's', 'y', 'n',
+  't', 'a', 'x', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 't', 'o', 'g', 'g', 'l',
+  'e', 'b', 'i', 't', '_', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 't', 'o',
+  'g', 'g', 'l', 'e', 'b', 'i', 't', '_', 'r', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2',
+  '_', 't', 's', 't', 'b', 'i', 't', '_', 'i', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2',
+  '_', 't', 's', 't', 'b', 'i', 't', '_', 'r', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2',
+  '_', 'v', 'a', 'l', 'i', 'g', 'n', 'i', 'b', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2',
+  '_', 'v', 'a', 'l', 'i', 'g', 'n', 'r', 'b', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2',
+  '_', 'v', 'c', 'n', 'e', 'g', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
   'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'v',
-  's', 'a', 't', 'h', 'u', 'b', '_', 'n', 'o', 'p', 'a', 'c', 'k', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'S', '2', '_', 'v', 's', 'a', 't', 'w', 'h', '\000', '_', '_', 'b',
+  'c', 'r', 'o', 't', 'a', 't', 'e', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'v',
+  'r', 'c', 'n', 'e', 'g', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'v', 'r',
+  'n', 'd', 'p', 'a', 'c', 'k', 'w', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_',
+  'v', 'r', 'n', 'd', 'p', 'a', 'c', 'k', 'w', 'h', 's', '\000', '_', '_', 'b',
   'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'S', '2', '_', 'v', 's', 'a', 't', 'w', 'h', '_', 'n', 'o', 'p', 'a', 'c',
-  'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'v', 's', 'a', 't', 'w', 'u', 'h',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'S', '2', '_', 'v', 's', 'a', 't', 'w', 'u', 'h', '_',
-  'n', 'o', 'p', 'a', 'c', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'v', 's',
-  'p', 'l', 'a', 't', 'r', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'v', 's',
-  'p', 'l', 'a', 't', 'r', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'v', 's',
-  'p', 'l', 'i', 'c', 'e', 'i', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'v',
-  's', 'p', 'l', 'i', 'c', 'e', 'r', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_',
-  'v', 's', 'x', 't', 'b', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'v', 's',
-  'x', 't', 'h', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'v', 't', 'r', 'u',
-  'n', 'e', 'h', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'v', 't', 'r', 'u',
-  'n', 'e', 'w', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'v', 't', 'r', 'u',
-  'n', 'o', 'h', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'v', 't', 'r', 'u',
-  'n', 'o', 'w', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'v', 'z', 'x', 't',
-  'b', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'v', 'z', 'x', 't', 'h', 'w',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'S', '4', '_', 'a', 'd', 'd', 'a', 'd', 'd', 'i', '\000',
+  'S', '2', '_', 'v', 's', 'a', 't', 'h', 'b', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2',
+  '_', 'v', 's', 'a', 't', 'h', 'b', '_', 'n', 'o', 'p', 'a', 'c', 'k', '\000',
   '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'S', '4', '_', 'a', 'd', 'd', 'i', '_', 'a', 's', 'l', '_',
-  'r', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'S', '4', '_', 'a', 'd', 'd', 'i', '_', 'l',
-  's', 'r', '_', 'r', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '4', '_', 'a', 'n', 'd',
+  'O', 'N', '_', 'S', '2', '_', 'v', 's', 'a', 't', 'h', 'u', 'b', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'S', '2', '_', 'v', 's', 'a', 't', 'h', 'u', 'b', '_', 'n', 'o',
+  'p', 'a', 'c', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'v', 's', 'a', 't',
+  'w', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'v', 's', 'a', 't', 'w', 'h',
+  '_', 'n', 'o', 'p', 'a', 'c', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'v',
+  's', 'a', 't', 'w', 'u', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_', 'v', 's',
+  'a', 't', 'w', 'u', 'h', '_', 'n', 'o', 'p', 'a', 'c', 'k', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'S', '2', '_', 'v', 's', 'p', 'l', 'a', 't', 'r', 'b', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'S', '2', '_', 'v', 's', 'p', 'l', 'a', 't', 'r', 'h', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'S', '2', '_', 'v', 's', 'p', 'l', 'i', 'c', 'e', 'i', 'b', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'S', '2', '_', 'v', 's', 'p', 'l', 'i', 'c', 'e', 'r', 'b', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'S', '2', '_', 'v', 's', 'x', 't', 'b', 'h', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'S', '2', '_', 'v', 's', 'x', 't', 'h', 'w', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S',
+  '2', '_', 'v', 't', 'r', 'u', 'n', 'e', 'h', 'b', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S',
+  '2', '_', 'v', 't', 'r', 'u', 'n', 'e', 'w', 'h', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S',
+  '2', '_', 'v', 't', 'r', 'u', 'n', 'o', 'h', 'b', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S',
+  '2', '_', 'v', 't', 'r', 'u', 'n', 'o', 'w', 'h', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S',
+  '2', '_', 'v', 'z', 'x', 't', 'b', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '2', '_',
+  'v', 'z', 'x', 't', 'h', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '4', '_', 'a', 'd',
+  'd', 'a', 'd', 'd', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '4', '_', 'a', 'd', 'd',
   'i', '_', 'a', 's', 'l', '_', 'r', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l',
   't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '4', '_',
-  'a', 'n', 'd', 'i', '_', 'l', 's', 'r', '_', 'r', 'i', '\000', '_', '_', 'b',
+  'a', 'd', 'd', 'i', '_', 'l', 's', 'r', '_', 'r', 'i', '\000', '_', '_', 'b',
   'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'S', '4', '_', 'c', 'l', 'b', 'a', 'd', 'd', 'i', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S',
-  '4', '_', 'c', 'l', 'b', 'p', 'a', 'd', 'd', 'i', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S',
-  '4', '_', 'c', 'l', 'b', 'p', 'n', 'o', 'r', 'm', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S',
-  '4', '_', 'e', 'x', 't', 'r', 'a', 'c', 't', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '4',
-  '_', 'e', 'x', 't', 'r', 'a', 'c', 't', '_', 'r', 'p', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'S', '4', '_', 'e', 'x', 't', 'r', 'a', 'c', 't', 'p', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'S', '4', '_', 'e', 'x', 't', 'r', 'a', 'c', 't', 'p', '_', 'r', 'p', '\000',
+  'S', '4', '_', 'a', 'n', 'd', 'i', '_', 'a', 's', 'l', '_', 'r', 'i', '\000',
   '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'S', '4', '_', 'l', 's', 'l', 'i', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S',
-  '4', '_', 'n', 't', 's', 't', 'b', 'i', 't', '_', 'i', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'S', '4', '_', 'n', 't', 's', 't', 'b', 'i', 't', '_', 'r', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'S', '4', '_', 'o', 'r', '_', 'a', 'n', 'd', 'i', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'S', '4', '_', 'o', 'r', '_', 'a', 'n', 'd', 'i', 'x', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'S', '4', '_', 'o', 'r', '_', 'o', 'r', 'i', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '4',
-  '_', 'o', 'r', 'i', '_', 'a', 's', 'l', '_', 'r', 'i', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'S', '4', '_', 'o', 'r', 'i', '_', 'l', 's', 'r', '_', 'r', 'i', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'S', '4', '_', 'p', 'a', 'r', 'i', 't', 'y', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'S', '4', '_', 's', 't', 'o', 'r', 'e', 'd', '_', 'l', 'o', 'c', 'k', 'e',
-  'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'S', '4', '_', 's', 'u', 'b', 'a', 'd', 'd', 'i',
+  'O', 'N', '_', 'S', '4', '_', 'a', 'n', 'd', 'i', '_', 'l', 's', 'r', '_',
+  'r', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'S', '4', '_', 'c', 'l', 'b', 'a', 'd', 'd',
+  'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'S', '4', '_', 'c', 'l', 'b', 'p', 'a', 'd', 'd',
+  'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'S', '4', '_', 'c', 'l', 'b', 'p', 'n', 'o', 'r',
+  'm', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'S', '4', '_', 'e', 'x', 't', 'r', 'a', 'c', 't',
   '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'S', '4', '_', 's', 'u', 'b', 'i', '_', 'a', 's', 'l',
-  '_', 'r', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '4', '_', 's', 'u', 'b', 'i', '_',
-  'l', 's', 'r', '_', 'r', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '4', '_', 'v', 'r',
-  'c', 'r', 'o', 't', 'a', 't', 'e', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'G', 'O', 'N', '_', 'S', '4', '_', 'e', 'x', 't', 'r', 'a', 'c', 't', '_',
+  'r', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'S', '4', '_', 'e', 'x', 't', 'r', 'a', 'c',
+  't', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'S', '4', '_', 'e', 'x', 't', 'r', 'a', 'c',
+  't', 'p', '_', 'r', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '4', '_', 'l', 's', 'l',
+  'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'S', '4', '_', 'n', 't', 's', 't', 'b', 'i', 't',
+  '_', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'S', '4', '_', 'n', 't', 's', 't', 'b', 'i',
+  't', '_', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '4', '_', 'o', 'r', '_', 'a', 'n',
+  'd', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'S', '4', '_', 'o', 'r', '_', 'a', 'n', 'd',
+  'i', 'x', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'S', '4', '_', 'o', 'r', '_', 'o', 'r', 'i',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'S', '4', '_', 'o', 'r', 'i', '_', 'a', 's', 'l', '_',
+  'r', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'S', '4', '_', 'o', 'r', 'i', '_', 'l', 's',
+  'r', '_', 'r', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '4', '_', 'p', 'a', 'r', 'i',
+  't', 'y', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'S', '4', '_', 's', 't', 'o', 'r', 'e', 'd',
+  '_', 'l', 'o', 'c', 'k', 'e', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '4', '_', 's',
+  'u', 'b', 'a', 'd', 'd', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '4', '_', 's', 'u',
+  'b', 'i', '_', 'a', 's', 'l', '_', 'r', 'i', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '4',
+  '_', 's', 'u', 'b', 'i', '_', 'l', 's', 'r', '_', 'r', 'i', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'S', '4', '_', 'v', 'r', 'c', 'r', 'o', 't', 'a', 't', 'e', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'S', '4', '_', 'v', 'r', 'c', 'r', 'o', 't', 'a', 't', 'e', '_',
+  'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '4', '_', 'v', 'x', 'a', 'd', 'd',
+  's', 'u', 'b', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '4', '_', 'v', 'x', 'a', 'd',
+  'd', 's', 'u', 'b', 'h', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '4', '_', 'v', 'x',
+  'a', 'd', 'd', 's', 'u', 'b', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
   'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '4', '_', 'v',
-  'r', 'c', 'r', 'o', 't', 'a', 't', 'e', '_', 'a', 'c', 'c', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'S', '4', '_', 'v', 'x', 'a', 'd', 'd', 's', 'u', 'b', 'h', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'S', '4', '_', 'v', 'x', 'a', 'd', 'd', 's', 'u', 'b', 'h', 'r',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'S', '4', '_', 'v', 'x', 'a', 'd', 'd', 's', 'u', 'b',
-  'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'S', '4', '_', 'v', 'x', 's', 'u', 'b', 'a', 'd',
-  'd', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'S', '4', '_', 'v', 'x', 's', 'u', 'b', 'a',
-  'd', 'd', 'h', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '4', '_', 'v', 'x', 's', 'u',
-  'b', 'a', 'd', 'd', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '5', '_', 'a', 's', 'r',
-  'h', 'u', 'b', '_', 'r', 'n', 'd', '_', 's', 'a', 't', '_', 'g', 'o', 'o',
-  'd', 's', 'y', 'n', 't', 'a', 'x', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '5', '_', 'a',
-  's', 'r', 'h', 'u', 'b', '_', 's', 'a', 't', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '5',
-  '_', 'p', 'o', 'p', 'c', 'o', 'u', 'n', 't', 'p', '\000', '_', '_', 'b', 'u',
+  'x', 's', 'u', 'b', 'a', 'd', 'd', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '4', '_',
+  'v', 'x', 's', 'u', 'b', 'a', 'd', 'd', 'h', 'r', '\000', '_', '_', 'b', 'u',
   'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S',
-  '5', '_', 'v', 'a', 's', 'r', 'h', 'r', 'n', 'd', '_', 'g', 'o', 'o', 'd',
-  's', 'y', 'n', 't', 'a', 'x', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '6', '_', 'r', 'o',
-  'l', '_', 'i', '_', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '6', '_', 'r', 'o', 'l',
-  '_', 'i', '_', 'p', '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '6', '_',
-  'r', 'o', 'l', '_', 'i', '_', 'p', '_', 'a', 'n', 'd', '\000', '_', '_', 'b',
+  '4', '_', 'v', 'x', 's', 'u', 'b', 'a', 'd', 'd', 'w', '\000', '_', '_', 'b',
   'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'S', '6', '_', 'r', 'o', 'l', '_', 'i', '_', 'p', '_', 'n', 'a', 'c', '\000',
+  'S', '5', '_', 'a', 's', 'r', 'h', 'u', 'b', '_', 'r', 'n', 'd', '_', 's',
+  'a', 't', '_', 'g', 'o', 'o', 'd', 's', 'y', 'n', 't', 'a', 'x', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'S', '5', '_', 'a', 's', 'r', 'h', 'u', 'b', '_', 's', 'a', 't',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'S', '5', '_', 'p', 'o', 'p', 'c', 'o', 'u', 'n', 't',
+  'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'S', '5', '_', 'v', 'a', 's', 'r', 'h', 'r', 'n',
+  'd', '_', 'g', 'o', 'o', 'd', 's', 'y', 'n', 't', 'a', 'x', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'S', '6', '_', 'r', 'o', 'l', '_', 'i', '_', 'p', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'S', '6', '_', 'r', 'o', 'l', '_', 'i', '_', 'p', '_', 'a', 'c', 'c', '\000',
   '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'S', '6', '_', 'r', 'o', 'l', '_', 'i', '_', 'p', '_', 'o',
-  'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'S', '6', '_', 'r', 'o', 'l', '_', 'i', '_', 'p',
-  '_', 'x', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  'O', 'N', '_', 'S', '6', '_', 'r', 'o', 'l', '_', 'i', '_', 'p', '_', 'a',
+  'n', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'S', '6', '_', 'r', 'o', 'l', '_', 'i', '_',
+  'p', '_', 'n', 'a', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
   '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '6', '_', 'r', 'o', 'l',
-  '_', 'i', '_', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '6', '_', 'r', 'o', 'l', '_',
-  'i', '_', 'r', '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  '_', 'i', '_', 'p', '_', 'o', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
   'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '6', '_', 'r',
-  'o', 'l', '_', 'i', '_', 'r', '_', 'a', 'n', 'd', '\000', '_', '_', 'b', 'u',
+  'o', 'l', '_', 'i', '_', 'p', '_', 'x', 'a', 'c', 'c', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'S', '6', '_', 'r', 'o', 'l', '_', 'i', '_', 'r', '\000', '_', '_', 'b', 'u',
   'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S',
-  '6', '_', 'r', 'o', 'l', '_', 'i', '_', 'r', '_', 'n', 'a', 'c', '\000', '_',
+  '6', '_', 'r', 'o', 'l', '_', 'i', '_', 'r', '_', 'a', 'c', 'c', '\000', '_',
   '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'S', '6', '_', 'r', 'o', 'l', '_', 'i', '_', 'r', '_', 'o', 'r',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'S', '6', '_', 'r', 'o', 'l', '_', 'i', '_', 'r', '_',
-  'x', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '6', '_', 'v', 's', 'p', 'l',
-  'a', 't', 'r', 'b', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '6', '_', 'v', 't', 'r',
-  'u', 'n', 'e', 'h', 'b', '_', 'p', 'p', 'p', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '6',
-  '_', 'v', 't', 'r', 'u', 'n', 'o', 'h', 'b', '_', 'p', 'p', 'p', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'V', '6', '_', 'e', 'x', 't', 'r', 'a', 'c', 't', 'w', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'V', '6', '_', 'e', 'x', 't', 'r', 'a', 'c', 't', 'w', '_', '1',
-  '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'h', 'i', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'V', '6', '_', 'h', 'i', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b',
+  'N', '_', 'S', '6', '_', 'r', 'o', 'l', '_', 'i', '_', 'r', '_', 'a', 'n',
+  'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'S', '6', '_', 'r', 'o', 'l', '_', 'i', '_', 'r',
+  '_', 'n', 'a', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '6', '_', 'r', 'o', 'l', '_',
+  'i', '_', 'r', '_', 'o', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S', '6', '_', 'r', 'o',
+  'l', '_', 'i', '_', 'r', '_', 'x', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'S',
+  '6', '_', 'v', 's', 'p', 'l', 'a', 't', 'r', 'b', 'p', '\000', '_', '_', 'b',
   'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'V', '6', '_', 'l', 'd', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'l', 'd',
-  '0', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'l', 'd',
-  'c', 'n', 'p', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'l', 'd', 'c', 'n',
-  'p', '0', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'l',
-  'd', 'c', 'n', 'p', 'n', 't', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'l',
-  'd', 'c', 'n', 'p', 'n', 't', '0', '_', '1', '2', '8', 'B', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'V', '6', '_', 'l', 'd', 'c', 'p', '0', '\000', '_', '_', 'b', 'u', 'i',
+  'S', '6', '_', 'v', 't', 'r', 'u', 'n', 'e', 'h', 'b', '_', 'p', 'p', 'p',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'S', '6', '_', 'v', 't', 'r', 'u', 'n', 'o', 'h', 'b',
+  '_', 'p', 'p', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'e', 'x', 't', 'r',
+  'a', 'c', 't', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'e', 'x', 't', 'r',
+  'a', 'c', 't', 'w', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i',
   'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
-  '_', 'l', 'd', 'c', 'p', '0', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'V', '6', '_', 'l', 'd', 'c', 'p', 'n', 't', '0', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
-  '6', '_', 'l', 'd', 'c', 'p', 'n', 't', '0', '_', '1', '2', '8', 'B', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'V', '6', '_', 'l', 'd', 'n', 'p', '0', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'V', '6', '_', 'l', 'd', 'n', 'p', '0', '_', '1', '2', '8', 'B', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'V', '6', '_', 'l', 'd', 'n', 'p', 'n', 't', '0', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'V', '6', '_', 'l', 'd', 'n', 'p', 'n', 't', '0', '_', '1', '2', '8',
-  'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'l', 'd', 'n', 't', '0', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'V', '6', '_', 'l', 'd', 'n', 't', '0', '_', '1', '2', '8', 'B',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'V', '6', '_', 'l', 'd', 'n', 't', 'n', 't', '0', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'V', '6', '_', 'l', 'd', 'p', '0', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
-  '6', '_', 'l', 'd', 'p', '0', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'V', '6', '_', 'l', 'd', 'p', 'n', 't', '0', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
-  '_', 'l', 'd', 'p', 'n', 't', '0', '_', '1', '2', '8', 'B', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'V', '6', '_', 'l', 'd', 't', 'n', 'p', '0', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
-  '6', '_', 'l', 'd', 't', 'n', 'p', '0', '_', '1', '2', '8', 'B', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'V', '6', '_', 'l', 'd', 't', 'n', 'p', 'n', 't', '0', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'V', '6', '_', 'l', 'd', 't', 'n', 'p', 'n', 't', '0', '_', '1',
-  '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'l', 'd', 't', 'p', '0',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'V', '6', '_', 'l', 'd', 't', 'p', '0', '_', '1', '2',
-  '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'l', 'd', 't', 'p', 'n', 't',
-  '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'l', 'd', 't', 'p', 'n', 't', '0',
-  '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'l', 'd', 'u',
-  '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'l', 'd', 'u', '0', '_', '1', '2',
+  '_', 'h', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'h', 'i', '_', '1', '2',
   '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
   'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'l', 'o', '\000', '_', '_', 'b',
   'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
@@ -20121,2713 +27221,2337 @@
   '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'l', 'v', 's',
   'p', 'l', 'a', 't', 'w', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u',
   'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
-  '6', '_', 'p', 'r', 'e', 'd', '_', 'a', 'n', 'd', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
-  '6', '_', 'p', 'r', 'e', 'd', '_', 'a', 'n', 'd', '_', '1', '2', '8', 'B',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'V', '6', '_', 'p', 'r', 'e', 'd', '_', 'a', 'n', 'd',
-  '_', 'n', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'p', 'r', 'e', 'd', '_', 'a',
-  'n', 'd', '_', 'n', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
-  '_', 'p', 'r', 'e', 'd', '_', 'n', 'o', 't', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
-  '_', 'p', 'r', 'e', 'd', '_', 'n', 'o', 't', '_', '1', '2', '8', 'B', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'V', '6', '_', 'p', 'r', 'e', 'd', '_', 'o', 'r', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'V', '6', '_', 'p', 'r', 'e', 'd', '_', 'o', 'r', '_', '1', '2',
-  '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'p', 'r', 'e', 'd', '_', 'o',
-  'r', '_', 'n', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'p', 'r', 'e', 'd', '_',
-  'o', 'r', '_', 'n', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
-  '_', 'p', 'r', 'e', 'd', '_', 's', 'c', 'a', 'l', 'a', 'r', '2', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'V', '6', '_', 'p', 'r', 'e', 'd', '_', 's', 'c', 'a', 'l', 'a',
-  'r', '2', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'p',
-  'r', 'e', 'd', '_', 's', 'c', 'a', 'l', 'a', 'r', '2', 'v', '2', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'V', '6', '_', 'p', 'r', 'e', 'd', '_', 's', 'c', 'a', 'l', 'a',
-  'r', '2', 'v', '2', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
-  '_', 'p', 'r', 'e', 'd', '_', 'x', 'o', 'r', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
-  '_', 'p', 'r', 'e', 'd', '_', 'x', 'o', 'r', '_', '1', '2', '8', 'B', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'V', '6', '_', 's', 'h', 'u', 'f', 'f', 'e', 'q', 'h', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'V', '6', '_', 's', 'h', 'u', 'f', 'f', 'e', 'q', 'h', '_',
-  '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 's', 'h', 'u', 'f',
-  'f', 'e', 'q', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 's', 'h', 'u', 'f',
-  'f', 'e', 'q', 'w', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
-  '_', 'v', 'S', '3', '2', 'b', '_', 'n', 'q', 'p', 'r', 'e', 'd', '_', 'a',
-  'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'S', '3', '2', 'b', '_', 'n',
-  'q', 'p', 'r', 'e', 'd', '_', 'a', 'i', '_', '1', '2', '8', 'B', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'V', '6', '_', 'v', 'S', '3', '2', 'b', '_', 'n', 't', '_', 'n',
-  'q', 'p', 'r', 'e', 'd', '_', 'a', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
-  'v', 'S', '3', '2', 'b', '_', 'n', 't', '_', 'n', 'q', 'p', 'r', 'e', 'd',
-  '_', 'a', 'i', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
-  'v', 'S', '3', '2', 'b', '_', 'n', 't', '_', 'q', 'p', 'r', 'e', 'd', '_',
-  'a', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'S', '3', '2', 'b', '_',
-  'n', 't', '_', 'q', 'p', 'r', 'e', 'd', '_', 'a', 'i', '_', '1', '2', '8',
-  'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'S', '3', '2', 'b', '_', 'q',
-  'p', 'r', 'e', 'd', '_', 'a', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  '6', '_', 'v', 'a', 'b', 's', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
   'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
-  'S', '3', '2', 'b', '_', 'q', 'p', 'r', 'e', 'd', '_', 'a', 'i', '_', '1',
-  '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'b', 's', 'b',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'b', 's', 'b', '_', '1', '2',
-  '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'b', 's', 'b', '_',
-  's', 'a', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'b', 's', 'b',
-  '_', 's', 'a', 't', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i',
+  'a', 'b', 's', 'b', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i',
   'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
-  '_', 'v', 'a', 'b', 's', 'd', 'i', 'f', 'f', 'h', '\000', '_', '_', 'b', 'u',
+  '_', 'v', 'a', 'b', 's', 'b', '_', 's', 'a', 't', '\000', '_', '_', 'b', 'u',
   'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
-  '6', '_', 'v', 'a', 'b', 's', 'd', 'i', 'f', 'f', 'h', '_', '1', '2', '8',
+  '6', '_', 'v', 'a', 'b', 's', 'b', '_', 's', 'a', 't', '_', '1', '2', '8',
   'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
   'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'b', 's', 'd', 'i', 'f',
-  'f', 'u', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'b', 's', 'd',
-  'i', 'f', 'f', 'u', 'b', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u',
+  'f', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'b', 's', 'd', 'i',
+  'f', 'f', 'h', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
+  'v', 'a', 'b', 's', 'd', 'i', 'f', 'f', 'u', 'b', '\000', '_', '_', 'b', 'u',
   'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
-  '6', '_', 'v', 'a', 'b', 's', 'd', 'i', 'f', 'f', 'u', 'h', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'V', '6', '_', 'v', 'a', 'b', 's', 'd', 'i', 'f', 'f', 'u', 'h', '_',
-  '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  '6', '_', 'v', 'a', 'b', 's', 'd', 'i', 'f', 'f', 'u', 'b', '_', '1', '2',
+  '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'b', 's', 'd', 'i',
+  'f', 'f', 'u', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
   'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'b', 's',
-  'd', 'i', 'f', 'f', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'b',
-  's', 'd', 'i', 'f', 'f', 'w', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b',
+  'd', 'i', 'f', 'f', 'u', 'h', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b',
   'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'V', '6', '_', 'v', 'a', 'b', 's', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
-  'v', 'a', 'b', 's', 'h', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
-  '6', '_', 'v', 'a', 'b', 's', 'h', '_', 's', 'a', 't', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'V', '6', '_', 'v', 'a', 'b', 's', 'h', '_', 's', 'a', 't', '_', '1', '2',
-  '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'b', 's', 'w', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'b', 's', 'w', '_', '1', '2', '8',
-  'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'b', 's', 'w', '_', 's',
-  'a', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'b', 's', 'w', '_',
-  's', 'a', 't', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
-  'v', 'a', 'd', 'd', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'd',
-  'd', 'b', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
-  'a', 'd', 'd', 'b', '_', 'd', 'v', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
-  'a', 'd', 'd', 'b', '_', 'd', 'v', '_', '1', '2', '8', 'B', '\000', '_', '_',
+  'V', '6', '_', 'v', 'a', 'b', 's', 'd', 'i', 'f', 'f', 'w', '\000', '_', '_',
   'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'V', '6', '_', 'v', 'a', 'd', 'd', 'b', 'n', 'q', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'V', '6', '_', 'v', 'a', 'd', 'd', 'b', 'n', 'q', '_', '1', '2', '8', 'B',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'd', 'd', 'b', 'q', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'V', '6', '_', 'v', 'a', 'd', 'd', 'b', 'q', '_', '1', '2', '8',
-  'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'd', 'd', 'b', 's', 'a',
-  't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'd', 'd', 'b', 's', 'a',
-  't', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a',
-  'd', 'd', 'b', 's', 'a', 't', '_', 'd', 'v', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
-  '_', 'v', 'a', 'd', 'd', 'b', 's', 'a', 't', '_', 'd', 'v', '_', '1', '2',
-  '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'd', 'd', 'c', 'a',
-  'r', 'r', 'y', 's', 'a', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a',
-  'd', 'd', 'c', 'a', 'r', 'r', 'y', 's', 'a', 't', '_', '1', '2', '8', 'B',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'd', 'd', 'c', 'l', 'b', 'h',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'd', 'd', 'c', 'l', 'b', 'h',
-  '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'd',
-  'd', 'c', 'l', 'b', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'd',
-  'd', 'c', 'l', 'b', 'w', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
-  '6', '_', 'v', 'a', 'd', 'd', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
-  'a', 'd', 'd', 'h', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
-  '_', 'v', 'a', 'd', 'd', 'h', '_', 'd', 'v', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
-  '_', 'v', 'a', 'd', 'd', 'h', '_', 'd', 'v', '_', '1', '2', '8', 'B', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'd', 'd', 'h', 'n', 'q', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'V', '6', '_', 'v', 'a', 'd', 'd', 'h', 'n', 'q', '_', '1', '2',
-  '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'd', 'd', 'h', 'q',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'd', 'd', 'h', 'q', '_', '1',
+  '_', 'V', '6', '_', 'v', 'a', 'b', 's', 'd', 'i', 'f', 'f', 'w', '_', '1',
   '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'd', 'd', 'h',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'b', 's', 'h',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'b', 's', 'h', '_', '1', '2',
+  '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'b', 's', 'h', '_',
   's', 'a', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'd', 'd', 'h',
-  's', 'a', 't', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'b', 's', 'h',
+  '_', 's', 'a', 't', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
+  '_', 'v', 'a', 'b', 's', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a',
+  'b', 's', 'w', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l',
   't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
-  'v', 'a', 'd', 'd', 'h', 's', 'a', 't', '_', 'd', 'v', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'V', '6', '_', 'v', 'a', 'd', 'd', 'h', 's', 'a', 't', '_', 'd', 'v', '_',
+  'v', 'a', 'b', 's', 'w', '_', 's', 'a', 't', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
+  '_', 'v', 'a', 'b', 's', 'w', '_', 's', 'a', 't', '_', '1', '2', '8', 'B',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'd', 'd', 'b', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'V', '6', '_', 'v', 'a', 'd', 'd', 'b', '_', '1', '2', '8', 'B', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'd', 'd', 'b', '_', 'd', 'v', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'd', 'd', 'b', '_', 'd', 'v', '_',
   '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
   'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'd', 'd',
-  'h', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'd', 'd', 'h', 'w',
-  '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'd',
-  'd', 'h', 'w', '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
-  'a', 'd', 'd', 'h', 'w', '_', 'a', 'c', 'c', '_', '1', '2', '8', 'B', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'd', 'd', 'u', 'b', 'h', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'V', '6', '_', 'v', 'a', 'd', 'd', 'u', 'b', 'h', '_', '1', '2',
-  '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'd', 'd', 'u', 'b',
-  'h', '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'd',
-  'd', 'u', 'b', 'h', '_', 'a', 'c', 'c', '_', '1', '2', '8', 'B', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'V', '6', '_', 'v', 'a', 'd', 'd', 'u', 'b', 's', 'a', 't', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'd', 'd', 'u', 'b', 's', 'a', 't',
-  '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'd',
-  'd', 'u', 'b', 's', 'a', 't', '_', 'd', 'v', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
-  '_', 'v', 'a', 'd', 'd', 'u', 'b', 's', 'a', 't', '_', 'd', 'v', '_', '1',
-  '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'd', 'd', 'u',
-  'b', 'u', 'b', 'b', '_', 's', 'a', 't', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
-  'v', 'a', 'd', 'd', 'u', 'b', 'u', 'b', 'b', '_', 's', 'a', 't', '_', '1',
-  '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'd', 'd', 'u',
-  'h', 's', 'a', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'd', 'd',
-  'u', 'h', 's', 'a', 't', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
-  '6', '_', 'v', 'a', 'd', 'd', 'u', 'h', 's', 'a', 't', '_', 'd', 'v', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'd', 'd', 'u', 'h', 's', 'a', 't',
-  '_', 'd', 'v', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
-  'v', 'a', 'd', 'd', 'u', 'h', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
-  'a', 'd', 'd', 'u', 'h', 'w', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'V', '6', '_', 'v', 'a', 'd', 'd', 'u', 'h', 'w', '_', 'a', 'c', 'c', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'd', 'd', 'u', 'h', 'w', '_', 'a',
-  'c', 'c', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
-  'a', 'd', 'd', 'u', 'w', 's', 'a', 't', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
-  'v', 'a', 'd', 'd', 'u', 'w', 's', 'a', 't', '_', '1', '2', '8', 'B', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'd', 'd', 'u', 'w', 's', 'a', 't',
-  '_', 'd', 'v', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'd', 'd', 'u',
-  'w', 's', 'a', 't', '_', 'd', 'v', '_', '1', '2', '8', 'B', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'V', '6', '_', 'v', 'a', 'd', 'd', 'w', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
-  '_', 'v', 'a', 'd', 'd', 'w', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'V', '6', '_', 'v', 'a', 'd', 'd', 'w', '_', 'd', 'v', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'V', '6', '_', 'v', 'a', 'd', 'd', 'w', '_', 'd', 'v', '_', '1', '2', '8',
-  'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'd', 'd', 'w', 'n', 'q',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'd', 'd', 'w', 'n', 'q', '_',
-  '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'd', 'd',
-  'w', 'q', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'd', 'd', 'w', 'q',
-  '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'd',
-  'd', 'w', 's', 'a', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'd',
-  'd', 'w', 's', 'a', 't', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
-  '6', '_', 'v', 'a', 'd', 'd', 'w', 's', 'a', 't', '_', 'd', 'v', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'V', '6', '_', 'v', 'a', 'd', 'd', 'w', 's', 'a', 't', '_', 'd',
-  'v', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a',
-  'l', 'i', 'g', 'n', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'l',
-  'i', 'g', 'n', 'b', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
-  '_', 'v', 'a', 'l', 'i', 'g', 'n', 'b', 'i', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
-  '_', 'v', 'a', 'l', 'i', 'g', 'n', 'b', 'i', '_', '1', '2', '8', 'B', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'n', 'd', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
-  '6', '_', 'v', 'a', 'n', 'd', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'V', '6', '_', 'v', 'a', 'n', 'd', 'n', 'q', 'r', 't', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'V', '6', '_', 'v', 'a', 'n', 'd', 'n', 'q', 'r', 't', '_', '1', '2', '8',
-  'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'n', 'd', 'n', 'q', 'r',
-  't', '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'n',
-  'd', 'n', 'q', 'r', 't', '_', 'a', 'c', 'c', '_', '1', '2', '8', 'B', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'n', 'd', 'q', 'r', 't', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'V', '6', '_', 'v', 'a', 'n', 'd', 'q', 'r', 't', '_', '1', '2',
-  '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'n', 'd', 'q', 'r',
-  't', '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'n',
-  'd', 'q', 'r', 't', '_', 'a', 'c', 'c', '_', '1', '2', '8', 'B', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'V', '6', '_', 'v', 'a', 'n', 'd', 'v', 'n', 'q', 'v', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'V', '6', '_', 'v', 'a', 'n', 'd', 'v', 'n', 'q', 'v', '_', '1',
-  '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'n', 'd', 'v',
-  'q', 'v', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'n', 'd', 'v', 'q',
-  'v', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a',
-  'n', 'd', 'v', 'r', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'n',
-  'd', 'v', 'r', 't', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
-  '_', 'v', 'a', 'n', 'd', 'v', 'r', 't', '_', 'a', 'c', 'c', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'V', '6', '_', 'v', 'a', 'n', 'd', 'v', 'r', 't', '_', 'a', 'c', 'c',
-  '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 's',
-  'l', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 's', 'l', 'h', '_',
-  '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 's', 'l',
-  'h', '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 's',
-  'l', 'h', '_', 'a', 'c', 'c', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'V', '6', '_', 'v', 'a', 's', 'l', 'h', 'v', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
-  '_', 'v', 'a', 's', 'l', 'h', 'v', '_', '1', '2', '8', 'B', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'V', '6', '_', 'v', 'a', 's', 'l', 'w', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
-  '_', 'v', 'a', 's', 'l', 'w', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'V', '6', '_', 'v', 'a', 's', 'l', 'w', '_', 'a', 'c', 'c', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'V', '6', '_', 'v', 'a', 's', 'l', 'w', '_', 'a', 'c', 'c', '_', '1',
-  '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 's', 'l', 'w',
-  'v', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 's', 'l', 'w', 'v', '_',
-  '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 's', 'r',
-  '_', 'i', 'n', 't', 'o', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 's',
-  'r', '_', 'i', 'n', 't', 'o', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'V', '6', '_', 'v', 'a', 's', 'r', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
-  'v', 'a', 's', 'r', 'h', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
-  '6', '_', 'v', 'a', 's', 'r', 'h', '_', 'a', 'c', 'c', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'V', '6', '_', 'v', 'a', 's', 'r', 'h', '_', 'a', 'c', 'c', '_', '1', '2',
-  '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 's', 'r', 'h', 'b',
-  'r', 'n', 'd', 's', 'a', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a',
-  's', 'r', 'h', 'b', 'r', 'n', 'd', 's', 'a', 't', '_', '1', '2', '8', 'B',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 's', 'r', 'h', 'b', 's', 'a',
-  't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 's', 'r', 'h', 'b', 's',
-  'a', 't', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
-  'a', 's', 'r', 'h', 'u', 'b', 'r', 'n', 'd', 's', 'a', 't', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'V', '6', '_', 'v', 'a', 's', 'r', 'h', 'u', 'b', 'r', 'n', 'd', 's',
-  'a', 't', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
-  'a', 's', 'r', 'h', 'u', 'b', 's', 'a', 't', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
-  '_', 'v', 'a', 's', 'r', 'h', 'u', 'b', 's', 'a', 't', '_', '1', '2', '8',
-  'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 's', 'r', 'h', 'v', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'V', '6', '_', 'v', 'a', 's', 'r', 'h', 'v', '_', '1', '2',
-  '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 's', 'r', 'u', 'h',
-  'u', 'b', 'r', 'n', 'd', 's', 'a', 't', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
-  'v', 'a', 's', 'r', 'u', 'h', 'u', 'b', 'r', 'n', 'd', 's', 'a', 't', '_',
-  '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 's', 'r',
-  'u', 'h', 'u', 'b', 's', 'a', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
-  'a', 's', 'r', 'u', 'h', 'u', 'b', 's', 'a', 't', '_', '1', '2', '8', 'B',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 's', 'r', 'u', 'w', 'u', 'h',
-  'r', 'n', 'd', 's', 'a', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a',
-  's', 'r', 'u', 'w', 'u', 'h', 'r', 'n', 'd', 's', 'a', 't', '_', '1', '2',
-  '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 's', 'r', 'u', 'w',
-  'u', 'h', 's', 'a', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 's',
-  'r', 'u', 'w', 'u', 'h', 's', 'a', 't', '_', '1', '2', '8', 'B', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'V', '6', '_', 'v', 'a', 's', 'r', 'w', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
-  '6', '_', 'v', 'a', 's', 'r', 'w', '_', '1', '2', '8', 'B', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'V', '6', '_', 'v', 'a', 's', 'r', 'w', '_', 'a', 'c', 'c', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'V', '6', '_', 'v', 'a', 's', 'r', 'w', '_', 'a', 'c', 'c', '_',
-  '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 's', 'r',
-  'w', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 's', 'r', 'w', 'h',
-  '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 's',
-  'r', 'w', 'h', 'r', 'n', 'd', 's', 'a', 't', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
-  '_', 'v', 'a', 's', 'r', 'w', 'h', 'r', 'n', 'd', 's', 'a', 't', '_', '1',
-  '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 's', 'r', 'w',
-  'h', 's', 'a', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 's', 'r',
-  'w', 'h', 's', 'a', 't', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
-  '6', '_', 'v', 'a', 's', 'r', 'w', 'u', 'h', 'r', 'n', 'd', 's', 'a', 't',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 's', 'r', 'w', 'u', 'h', 'r',
-  'n', 'd', 's', 'a', 't', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
-  '6', '_', 'v', 'a', 's', 'r', 'w', 'u', 'h', 's', 'a', 't', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'V', '6', '_', 'v', 'a', 's', 'r', 'w', 'u', 'h', 's', 'a', 't', '_',
-  '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 's', 'r',
-  'w', 'v', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 's', 'r', 'w', 'v',
-  '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 's',
-  's', 'i', 'g', 'n', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 's', 's',
-  'i', 'g', 'n', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
-  'v', 'a', 's', 's', 'i', 'g', 'n', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
-  'v', 'a', 's', 's', 'i', 'g', 'n', 'p', '_', '1', '2', '8', 'B', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'V', '6', '_', 'v', 'a', 'v', 'g', 'b', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
-  '6', '_', 'v', 'a', 'v', 'g', 'b', '_', '1', '2', '8', 'B', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'V', '6', '_', 'v', 'a', 'v', 'g', 'b', 'r', 'n', 'd', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'V', '6', '_', 'v', 'a', 'v', 'g', 'b', 'r', 'n', 'd', '_', '1', '2',
-  '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'v', 'g', 'h', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'v', 'g', 'h', '_', '1', '2', '8',
-  'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'v', 'g', 'h', 'r', 'n',
-  'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'v', 'g', 'h', 'r', 'n',
-  'd', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a',
-  'v', 'g', 'u', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'v', 'g',
-  'u', 'b', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
-  'a', 'v', 'g', 'u', 'b', 'r', 'n', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
-  'v', 'a', 'v', 'g', 'u', 'b', 'r', 'n', 'd', '_', '1', '2', '8', 'B', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'v', 'g', 'u', 'h', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'V', '6', '_', 'v', 'a', 'v', 'g', 'u', 'h', '_', '1', '2', '8', 'B',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'v', 'g', 'u', 'h', 'r', 'n',
-  'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'v', 'g', 'u', 'h', 'r',
-  'n', 'd', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
-  'a', 'v', 'g', 'u', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'v',
-  'g', 'u', 'w', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
-  'v', 'a', 'v', 'g', 'u', 'w', 'r', 'n', 'd', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
-  '_', 'v', 'a', 'v', 'g', 'u', 'w', 'r', 'n', 'd', '_', '1', '2', '8', 'B',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'v', 'g', 'w', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'V', '6', '_', 'v', 'a', 'v', 'g', 'w', '_', '1', '2', '8', 'B', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'v', 'g', 'w', 'r', 'n', 'd', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'v', 'g', 'w', 'r', 'n', 'd', '_',
-  '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'c', 'l', '0',
-  'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'c', 'l', '0', 'h', '_', '1',
-  '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'c', 'l', '0', 'w',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'c', 'l', '0', 'w', '_', '1', '2',
-  '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'c', 'o', 'm', 'b', 'i',
-  'n', 'e', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'c', 'o', 'm', 'b', 'i',
-  'n', 'e', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
-  'd', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'd', '0', '_', '1', '2',
-  '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'd', 'd', '0', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'V', '6', '_', 'v', 'd', 'd', '0', '_', '1', '2', '8', 'B', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'V', '6', '_', 'v', 'd', 'e', 'a', 'l', 'b', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'V', '6', '_', 'v', 'd', 'e', 'a', 'l', 'b', '_', '1', '2', '8', 'B',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'd', 'e', 'a', 'l', 'b', '4', 'w',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'd', 'e', 'a', 'l', 'b', '4', 'w',
-  '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'd', 'e',
-  'a', 'l', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'd', 'e', 'a', 'l',
-  'h', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'd',
-  'e', 'a', 'l', 'v', 'd', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'd',
-  'e', 'a', 'l', 'v', 'd', 'd', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'V', '6', '_', 'v', 'd', 'e', 'l', 't', 'a', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
-  '_', 'v', 'd', 'e', 'l', 't', 'a', '_', '1', '2', '8', 'B', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'V', '6', '_', 'v', 'd', 'm', 'p', 'y', 'b', 'u', 's', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'V', '6', '_', 'v', 'd', 'm', 'p', 'y', 'b', 'u', 's', '_', '1', '2',
-  '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'd', 'm', 'p', 'y', 'b',
-  'u', 's', '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'd',
-  'm', 'p', 'y', 'b', 'u', 's', '_', 'a', 'c', 'c', '_', '1', '2', '8', 'B',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'd', 'm', 'p', 'y', 'b', 'u', 's',
-  '_', 'd', 'v', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'd', 'm', 'p', 'y',
-  'b', 'u', 's', '_', 'd', 'v', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'V', '6', '_', 'v', 'd', 'm', 'p', 'y', 'b', 'u', 's', '_', 'd', 'v', '_',
-  'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'd', 'm', 'p', 'y',
-  'b', 'u', 's', '_', 'd', 'v', '_', 'a', 'c', 'c', '_', '1', '2', '8', 'B',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'd', 'm', 'p', 'y', 'h', 'b', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'V', '6', '_', 'v', 'd', 'm', 'p', 'y', 'h', 'b', '_', '1',
-  '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'd', 'm', 'p', 'y',
-  'h', 'b', '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'd',
-  'm', 'p', 'y', 'h', 'b', '_', 'a', 'c', 'c', '_', '1', '2', '8', 'B', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'V', '6', '_', 'v', 'd', 'm', 'p', 'y', 'h', 'b', '_', 'd',
-  'v', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'd', 'm', 'p', 'y', 'h', 'b',
-  '_', 'd', 'v', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
-  'v', 'd', 'm', 'p', 'y', 'h', 'b', '_', 'd', 'v', '_', 'a', 'c', 'c', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'V', '6', '_', 'v', 'd', 'm', 'p', 'y', 'h', 'b', '_', 'd',
-  'v', '_', 'a', 'c', 'c', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
-  '6', '_', 'v', 'd', 'm', 'p', 'y', 'h', 'i', 's', 'a', 't', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'V', '6', '_', 'v', 'd', 'm', 'p', 'y', 'h', 'i', 's', 'a', 't', '_',
-  '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'd', 'm', 'p',
-  'y', 'h', 'i', 's', 'a', 't', '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
-  '6', '_', 'v', 'd', 'm', 'p', 'y', 'h', 'i', 's', 'a', 't', '_', 'a', 'c',
-  'c', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'd',
-  'm', 'p', 'y', 'h', 's', 'a', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
-  'd', 'm', 'p', 'y', 'h', 's', 'a', 't', '_', '1', '2', '8', 'B', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'V', '6', '_', 'v', 'd', 'm', 'p', 'y', 'h', 's', 'a', 't', '_',
-  'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'd', 'm', 'p', 'y',
-  'h', 's', 'a', 't', '_', 'a', 'c', 'c', '_', '1', '2', '8', 'B', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'V', '6', '_', 'v', 'd', 'm', 'p', 'y', 'h', 's', 'u', 'i', 's',
-  'a', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'd', 'm', 'p', 'y', 'h',
-  's', 'u', 'i', 's', 'a', 't', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'V', '6', '_', 'v', 'd', 'm', 'p', 'y', 'h', 's', 'u', 'i', 's', 'a', 't',
-  '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'd', 'm', 'p',
-  'y', 'h', 's', 'u', 'i', 's', 'a', 't', '_', 'a', 'c', 'c', '_', '1', '2',
-  '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'd', 'm', 'p', 'y', 'h',
-  's', 'u', 's', 'a', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'd', 'm',
-  'p', 'y', 'h', 's', 'u', 's', 'a', 't', '_', '1', '2', '8', 'B', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'V', '6', '_', 'v', 'd', 'm', 'p', 'y', 'h', 's', 'u', 's', 'a',
-  't', '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'd', 'm',
-  'p', 'y', 'h', 's', 'u', 's', 'a', 't', '_', 'a', 'c', 'c', '_', '1', '2',
-  '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'd', 'm', 'p', 'y', 'h',
-  'v', 's', 'a', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'd', 'm', 'p',
-  'y', 'h', 'v', 's', 'a', 't', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'V', '6', '_', 'v', 'd', 'm', 'p', 'y', 'h', 'v', 's', 'a', 't', '_', 'a',
-  'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'd', 'm', 'p', 'y', 'h',
-  'v', 's', 'a', 't', '_', 'a', 'c', 'c', '_', '1', '2', '8', 'B', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'V', '6', '_', 'v', 'd', 's', 'a', 'd', 'u', 'h', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'V', '6', '_', 'v', 'd', 's', 'a', 'd', 'u', 'h', '_', '1', '2', '8',
-  'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'd', 's', 'a', 'd', 'u', 'h',
-  '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'd', 's', 'a',
-  'd', 'u', 'h', '_', 'a', 'c', 'c', '_', '1', '2', '8', 'B', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'V', '6', '_', 'v', 'e', 'q', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
-  'v', 'e', 'q', 'b', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
-  '_', 'v', 'e', 'q', 'b', '_', 'a', 'n', 'd', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
-  '_', 'v', 'e', 'q', 'b', '_', 'a', 'n', 'd', '_', '1', '2', '8', 'B', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'V', '6', '_', 'v', 'e', 'q', 'b', '_', 'o', 'r', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'V', '6', '_', 'v', 'e', 'q', 'b', '_', 'o', 'r', '_', '1', '2',
-  '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'e', 'q', 'b', '_', 'x',
-  'o', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'e', 'q', 'b', '_', 'x',
-  'o', 'r', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
-  'e', 'q', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'e', 'q', 'h', '_',
-  '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'e', 'q', 'h',
-  '_', 'a', 'n', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'e', 'q', 'h',
-  '_', 'a', 'n', 'd', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
-  '_', 'v', 'e', 'q', 'h', '_', 'o', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
-  'v', 'e', 'q', 'h', '_', 'o', 'r', '_', '1', '2', '8', 'B', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'V', '6', '_', 'v', 'e', 'q', 'h', '_', 'x', 'o', 'r', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'V', '6', '_', 'v', 'e', 'q', 'h', '_', 'x', 'o', 'r', '_', '1', '2',
-  '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'e', 'q', 'w', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'V', '6', '_', 'v', 'e', 'q', 'w', '_', '1', '2', '8', 'B', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'V', '6', '_', 'v', 'e', 'q', 'w', '_', 'a', 'n', 'd', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'V', '6', '_', 'v', 'e', 'q', 'w', '_', 'a', 'n', 'd', '_',
-  '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'e', 'q', 'w',
-  '_', 'o', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'e', 'q', 'w', '_',
-  'o', 'r', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
-  'e', 'q', 'w', '_', 'x', 'o', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
-  'e', 'q', 'w', '_', 'x', 'o', 'r', '_', '1', '2', '8', 'B', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'V', '6', '_', 'v', 'g', 'a', 't', 'h', 'e', 'r', 'm', 'h', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'V', '6', '_', 'v', 'g', 'a', 't', 'h', 'e', 'r', 'm', 'h', '_',
-  '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'g', 'a', 't',
-  'h', 'e', 'r', 'm', 'h', 'q', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'g',
-  'a', 't', 'h', 'e', 'r', 'm', 'h', 'q', '_', '1', '2', '8', 'B', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'V', '6', '_', 'v', 'g', 'a', 't', 'h', 'e', 'r', 'm', 'h', 'w',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'g', 'a', 't', 'h', 'e', 'r', 'm',
-  'h', 'w', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
-  'g', 'a', 't', 'h', 'e', 'r', 'm', 'h', 'w', 'q', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
-  '6', '_', 'v', 'g', 'a', 't', 'h', 'e', 'r', 'm', 'h', 'w', 'q', '_', '1',
-  '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'g', 'a', 't', 'h',
-  'e', 'r', 'm', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'g', 'a', 't',
-  'h', 'e', 'r', 'm', 'w', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
-  '6', '_', 'v', 'g', 'a', 't', 'h', 'e', 'r', 'm', 'w', 'q', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'V', '6', '_', 'v', 'g', 'a', 't', 'h', 'e', 'r', 'm', 'w', 'q', '_',
-  '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'g', 't', 'b',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'g', 't', 'b', '_', '1', '2', '8',
-  'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'g', 't', 'b', '_', 'a', 'n',
-  'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'g', 't', 'b', '_', 'a', 'n',
-  'd', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'g',
-  't', 'b', '_', 'o', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'g', 't',
-  'b', '_', 'o', 'r', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
-  '_', 'v', 'g', 't', 'b', '_', 'x', 'o', 'r', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
-  '_', 'v', 'g', 't', 'b', '_', 'x', 'o', 'r', '_', '1', '2', '8', 'B', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'V', '6', '_', 'v', 'g', 't', 'h', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
-  '6', '_', 'v', 'g', 't', 'h', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'V', '6', '_', 'v', 'g', 't', 'h', '_', 'a', 'n', 'd', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'V', '6', '_', 'v', 'g', 't', 'h', '_', 'a', 'n', 'd', '_', '1', '2', '8',
-  'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'g', 't', 'h', '_', 'o', 'r',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'g', 't', 'h', '_', 'o', 'r', '_',
-  '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'g', 't', 'h',
-  '_', 'x', 'o', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'g', 't', 'h',
-  '_', 'x', 'o', 'r', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
-  '_', 'v', 'g', 't', 'u', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'g',
-  't', 'u', 'b', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
-  'v', 'g', 't', 'u', 'b', '_', 'a', 'n', 'd', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
-  '_', 'v', 'g', 't', 'u', 'b', '_', 'a', 'n', 'd', '_', '1', '2', '8', 'B',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'g', 't', 'u', 'b', '_', 'o', 'r',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'g', 't', 'u', 'b', '_', 'o', 'r',
-  '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'g', 't',
-  'u', 'b', '_', 'x', 'o', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'g',
-  't', 'u', 'b', '_', 'x', 'o', 'r', '_', '1', '2', '8', 'B', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'V', '6', '_', 'v', 'g', 't', 'u', 'h', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
-  '_', 'v', 'g', 't', 'u', 'h', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'V', '6', '_', 'v', 'g', 't', 'u', 'h', '_', 'a', 'n', 'd', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'V', '6', '_', 'v', 'g', 't', 'u', 'h', '_', 'a', 'n', 'd', '_', '1',
-  '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'g', 't', 'u', 'h',
-  '_', 'o', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'g', 't', 'u', 'h',
-  '_', 'o', 'r', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
-  'v', 'g', 't', 'u', 'h', '_', 'x', 'o', 'r', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
-  '_', 'v', 'g', 't', 'u', 'h', '_', 'x', 'o', 'r', '_', '1', '2', '8', 'B',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'g', 't', 'u', 'w', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'V', '6', '_', 'v', 'g', 't', 'u', 'w', '_', '1', '2', '8', 'B', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'V', '6', '_', 'v', 'g', 't', 'u', 'w', '_', 'a', 'n', 'd',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'g', 't', 'u', 'w', '_', 'a', 'n',
-  'd', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'g',
-  't', 'u', 'w', '_', 'o', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'g',
-  't', 'u', 'w', '_', 'o', 'r', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'V', '6', '_', 'v', 'g', 't', 'u', 'w', '_', 'x', 'o', 'r', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'V', '6', '_', 'v', 'g', 't', 'u', 'w', '_', 'x', 'o', 'r', '_', '1',
-  '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'g', 't', 'w', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'V', '6', '_', 'v', 'g', 't', 'w', '_', '1', '2', '8', 'B',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'g', 't', 'w', '_', 'a', 'n', 'd',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'g', 't', 'w', '_', 'a', 'n', 'd',
-  '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'g', 't',
-  'w', '_', 'o', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'g', 't', 'w',
-  '_', 'o', 'r', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
-  'v', 'g', 't', 'w', '_', 'x', 'o', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
-  'v', 'g', 't', 'w', '_', 'x', 'o', 'r', '_', '1', '2', '8', 'B', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'V', '6', '_', 'v', 'i', 'n', 's', 'e', 'r', 't', 'w', 'r', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'V', '6', '_', 'v', 'i', 'n', 's', 'e', 'r', 't', 'w', 'r',
-  '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'l', 'a',
-  'l', 'i', 'g', 'n', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'l', 'a',
-  'l', 'i', 'g', 'n', 'b', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
-  '6', '_', 'v', 'l', 'a', 'l', 'i', 'g', 'n', 'b', 'i', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'V', '6', '_', 'v', 'l', 'a', 'l', 'i', 'g', 'n', 'b', 'i', '_', '1', '2',
-  '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'l', 's', 'r', 'b', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'V', '6', '_', 'v', 'l', 's', 'r', 'b', '_', '1', '2', '8',
-  'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'l', 's', 'r', 'h', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'V', '6', '_', 'v', 'l', 's', 'r', 'h', '_', '1', '2', '8', 'B',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'l', 's', 'r', 'h', 'v', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'V', '6', '_', 'v', 'l', 's', 'r', 'h', 'v', '_', '1', '2', '8',
-  'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'l', 's', 'r', 'w', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'V', '6', '_', 'v', 'l', 's', 'r', 'w', '_', '1', '2', '8', 'B',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'l', 's', 'r', 'w', 'v', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'V', '6', '_', 'v', 'l', 's', 'r', 'w', 'v', '_', '1', '2', '8',
-  'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'l', 'u', 't', '4', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'V', '6', '_', 'v', 'l', 'u', 't', '4', '_', '1', '2', '8', 'B',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'l', 'u', 't', 'v', 'v', 'b', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'V', '6', '_', 'v', 'l', 'u', 't', 'v', 'v', 'b', '_', '1',
-  '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'l', 'u', 't', 'v',
-  'v', 'b', '_', 'n', 'm', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'l', 'u',
-  't', 'v', 'v', 'b', '_', 'n', 'm', '_', '1', '2', '8', 'B', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'V', '6', '_', 'v', 'l', 'u', 't', 'v', 'v', 'b', '_', 'o', 'r', 'a',
-  'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'l', 'u', 't', 'v', 'v',
-  'b', '_', 'o', 'r', 'a', 'c', 'c', '_', '1', '2', '8', 'B', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'V', '6', '_', 'v', 'l', 'u', 't', 'v', 'v', 'b', '_', 'o', 'r', 'a',
-  'c', 'c', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'l', 'u', 't', 'v',
-  'v', 'b', '_', 'o', 'r', 'a', 'c', 'c', 'i', '_', '1', '2', '8', 'B', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'V', '6', '_', 'v', 'l', 'u', 't', 'v', 'v', 'b', 'i', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'V', '6', '_', 'v', 'l', 'u', 't', 'v', 'v', 'b', 'i', '_',
-  '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'l', 'u', 't',
-  'v', 'w', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'l', 'u', 't', 'v',
-  'w', 'h', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
-  'l', 'u', 't', 'v', 'w', 'h', '_', 'n', 'm', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
-  '_', 'v', 'l', 'u', 't', 'v', 'w', 'h', '_', 'n', 'm', '_', '1', '2', '8',
-  'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'l', 'u', 't', 'v', 'w', 'h',
-  '_', 'o', 'r', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'l',
-  'u', 't', 'v', 'w', 'h', '_', 'o', 'r', 'a', 'c', 'c', '_', '1', '2', '8',
-  'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'l', 'u', 't', 'v', 'w', 'h',
-  '_', 'o', 'r', 'a', 'c', 'c', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
-  'l', 'u', 't', 'v', 'w', 'h', '_', 'o', 'r', 'a', 'c', 'c', 'i', '_', '1',
-  '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'l', 'u', 't', 'v',
-  'w', 'h', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'l', 'u', 't', 'v',
-  'w', 'h', 'i', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
-  'v', 'm', 'a', 's', 'k', 'e', 'd', 's', 't', 'o', 'r', 'e', 'n', 'q', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'a', 's', 'k', 'e', 'd', 's', 't',
-  'o', 'r', 'e', 'n', 'q', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
-  '6', '_', 'v', 'm', 'a', 's', 'k', 'e', 'd', 's', 't', 'o', 'r', 'e', 'n',
-  't', 'n', 'q', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'a', 's', 'k',
-  'e', 'd', 's', 't', 'o', 'r', 'e', 'n', 't', 'n', 'q', '_', '1', '2', '8',
-  'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'a', 's', 'k', 'e', 'd',
-  's', 't', 'o', 'r', 'e', 'n', 't', 'q', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
-  'v', 'm', 'a', 's', 'k', 'e', 'd', 's', 't', 'o', 'r', 'e', 'n', 't', 'q',
-  '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'a',
-  's', 'k', 'e', 'd', 's', 't', 'o', 'r', 'e', 'q', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
-  '6', '_', 'v', 'm', 'a', 's', 'k', 'e', 'd', 's', 't', 'o', 'r', 'e', 'q',
-  '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'a',
-  'x', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'a', 'x', 'b', '_',
-  '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'a', 'x',
-  'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'a', 'x', 'h', '_', '1',
-  '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'a', 'x', 'u',
-  'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'a', 'x', 'u', 'b', '_',
-  '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'a', 'x',
-  'u', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'a', 'x', 'u', 'h',
-  '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'a',
-  'x', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'a', 'x', 'w', '_',
-  '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'i', 'n',
-  'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'i', 'n', 'b', '_', '1',
-  '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'i', 'n', 'h',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'i', 'n', 'h', '_', '1', '2',
-  '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'i', 'n', 'u', 'b',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'i', 'n', 'u', 'b', '_', '1',
-  '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'i', 'n', 'u',
-  'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'i', 'n', 'u', 'h', '_',
-  '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'i', 'n',
-  'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'i', 'n', 'w', '_', '1',
-  '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'a', 'b',
-  'u', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'a', 'b', 'u',
-  's', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm',
-  'p', 'a', 'b', 'u', 's', '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
-  '_', 'v', 'm', 'p', 'a', 'b', 'u', 's', '_', 'a', 'c', 'c', '_', '1', '2',
-  '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'a', 'b', 'u',
-  's', 'v', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'a', 'b', 'u',
-  's', 'v', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
-  'm', 'p', 'a', 'b', 'u', 'u', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm',
-  'p', 'a', 'b', 'u', 'u', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
-  '6', '_', 'v', 'm', 'p', 'a', 'b', 'u', 'u', '_', 'a', 'c', 'c', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'a', 'b', 'u', 'u', '_', 'a', 'c',
-  'c', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm',
-  'p', 'a', 'b', 'u', 'u', 'v', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm',
-  'p', 'a', 'b', 'u', 'u', 'v', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'V', '6', '_', 'v', 'm', 'p', 'a', 'h', 'b', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
-  '_', 'v', 'm', 'p', 'a', 'h', 'b', '_', '1', '2', '8', 'B', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'V', '6', '_', 'v', 'm', 'p', 'a', 'h', 'b', '_', 'a', 'c', 'c', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'a', 'h', 'b', '_', 'a', 'c',
-  'c', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm',
-  'p', 'a', 'h', 'h', 's', 'a', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
-  'm', 'p', 'a', 'h', 'h', 's', 'a', 't', '_', '1', '2', '8', 'B', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'a', 'u', 'h', 'b', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'V', '6', '_', 'v', 'm', 'p', 'a', 'u', 'h', 'b', '_', '1', '2', '8',
-  'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'a', 'u', 'h', 'b',
-  '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'a',
-  'u', 'h', 'b', '_', 'a', 'c', 'c', '_', '1', '2', '8', 'B', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'V', '6', '_', 'v', 'm', 'p', 'a', 'u', 'h', 'u', 'h', 's', 'a', 't',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'a', 'u', 'h', 'u', 'h',
-  's', 'a', 't', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
-  'v', 'm', 'p', 's', 'u', 'h', 'u', 'h', 's', 'a', 't', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'V', '6', '_', 'v', 'm', 'p', 's', 'u', 'h', 'u', 'h', 's', 'a', 't', '_',
-  '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y',
-  'b', 'u', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'b',
-  'u', 's', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
-  'm', 'p', 'y', 'b', 'u', 's', '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
-  '6', '_', 'v', 'm', 'p', 'y', 'b', 'u', 's', '_', 'a', 'c', 'c', '_', '1',
-  '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'b',
-  'u', 's', 'v', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'b',
-  'u', 's', 'v', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
-  'v', 'm', 'p', 'y', 'b', 'u', 's', 'v', '_', 'a', 'c', 'c', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'b', 'u', 's', 'v', '_', 'a', 'c',
-  'c', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm',
-  'p', 'y', 'b', 'v', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y',
-  'b', 'v', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
-  'm', 'p', 'y', 'b', 'v', '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
-  '_', 'v', 'm', 'p', 'y', 'b', 'v', '_', 'a', 'c', 'c', '_', '1', '2', '8',
-  'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'e', 'w', 'u',
-  'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'e', 'w', 'u',
-  'h', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm',
-  'p', 'y', 'e', 'w', 'u', 'h', '_', '6', '4', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
-  '_', 'v', 'm', 'p', 'y', 'e', 'w', 'u', 'h', '_', '6', '4', '_', '1', '2',
-  '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'h', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'h', '_', '1', '2', '8',
-  'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'h', '_', 'a',
-  'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'h', '_',
-  'a', 'c', 'c', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
-  'v', 'm', 'p', 'y', 'h', 's', 'a', 't', '_', 'a', 'c', 'c', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'h', 's', 'a', 't', '_', 'a', 'c',
-  'c', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm',
-  'p', 'y', 'h', 's', 'r', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm',
-  'p', 'y', 'h', 's', 'r', 's', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'V', '6', '_', 'v', 'm', 'p', 'y', 'h', 's', 's', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
-  '6', '_', 'v', 'm', 'p', 'y', 'h', 's', 's', '_', '1', '2', '8', 'B', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'h', 'u', 's', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'h', 'u', 's', '_', '1', '2',
-  '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'h', 'u',
-  's', '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p',
-  'y', 'h', 'u', 's', '_', 'a', 'c', 'c', '_', '1', '2', '8', 'B', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'h', 'v', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'V', '6', '_', 'v', 'm', 'p', 'y', 'h', 'v', '_', '1', '2', '8', 'B', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'h', 'v', '_', 'a', 'c',
-  'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'h', 'v', '_',
-  'a', 'c', 'c', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
-  'v', 'm', 'p', 'y', 'h', 'v', 's', 'r', 's', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
-  '_', 'v', 'm', 'p', 'y', 'h', 'v', 's', 'r', 's', '_', '1', '2', '8', 'B',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'i', 'e', 'o', 'h',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'i', 'e', 'o', 'h',
-  '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p',
-  'y', 'i', 'e', 'w', 'h', '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
-  '_', 'v', 'm', 'p', 'y', 'i', 'e', 'w', 'h', '_', 'a', 'c', 'c', '_', '1',
-  '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'i',
-  'e', 'w', 'u', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y',
-  'i', 'e', 'w', 'u', 'h', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
-  '6', '_', 'v', 'm', 'p', 'y', 'i', 'e', 'w', 'u', 'h', '_', 'a', 'c', 'c',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'i', 'e', 'w', 'u',
-  'h', '_', 'a', 'c', 'c', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
-  '6', '_', 'v', 'm', 'p', 'y', 'i', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
-  'v', 'm', 'p', 'y', 'i', 'h', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'V', '6', '_', 'v', 'm', 'p', 'y', 'i', 'h', '_', 'a', 'c', 'c', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'i', 'h', '_', 'a', 'c', 'c',
-  '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p',
-  'y', 'i', 'h', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y',
-  'i', 'h', 'b', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
-  'v', 'm', 'p', 'y', 'i', 'h', 'b', '_', 'a', 'c', 'c', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'V', '6', '_', 'v', 'm', 'p', 'y', 'i', 'h', 'b', '_', 'a', 'c', 'c', '_',
-  '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y',
-  'i', 'o', 'w', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y',
-  'i', 'o', 'w', 'h', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
-  '_', 'v', 'm', 'p', 'y', 'i', 'w', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
-  'v', 'm', 'p', 'y', 'i', 'w', 'b', '_', '1', '2', '8', 'B', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'i', 'w', 'b', '_', 'a', 'c', 'c',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'i', 'w', 'b', '_',
-  'a', 'c', 'c', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
-  'v', 'm', 'p', 'y', 'i', 'w', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
-  'm', 'p', 'y', 'i', 'w', 'h', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'V', '6', '_', 'v', 'm', 'p', 'y', 'i', 'w', 'h', '_', 'a', 'c', 'c', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'i', 'w', 'h', '_', 'a',
-  'c', 'c', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
-  'm', 'p', 'y', 'i', 'w', 'u', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
-  'm', 'p', 'y', 'i', 'w', 'u', 'b', '_', '1', '2', '8', 'B', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'i', 'w', 'u', 'b', '_', 'a', 'c',
-  'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'i', 'w', 'u',
-  'b', '_', 'a', 'c', 'c', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
-  '6', '_', 'v', 'm', 'p', 'y', 'o', 'w', 'h', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
-  '_', 'v', 'm', 'p', 'y', 'o', 'w', 'h', '_', '1', '2', '8', 'B', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'o', 'w', 'h', '_', '6', '4',
-  '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y',
-  'o', 'w', 'h', '_', '6', '4', '_', 'a', 'c', 'c', '_', '1', '2', '8', 'B',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'o', 'w', 'h', '_',
-  'r', 'n', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'o',
-  'w', 'h', '_', 'r', 'n', 'd', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'V', '6', '_', 'v', 'm', 'p', 'y', 'o', 'w', 'h', '_', 'r', 'n', 'd', '_',
-  's', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y',
-  'o', 'w', 'h', '_', 'r', 'n', 'd', '_', 's', 'a', 'c', 'c', '_', '1', '2',
-  '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'o', 'w',
-  'h', '_', 's', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm',
-  'p', 'y', 'o', 'w', 'h', '_', 's', 'a', 'c', 'c', '_', '1', '2', '8', 'B',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'u', 'b', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'u', 'b', '_', '1', '2', '8',
-  'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'u', 'b', '_',
-  'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'u',
-  'b', '_', 'a', 'c', 'c', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
-  '6', '_', 'v', 'm', 'p', 'y', 'u', 'b', 'v', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
-  '_', 'v', 'm', 'p', 'y', 'u', 'b', 'v', '_', '1', '2', '8', 'B', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'u', 'b', 'v', '_', 'a', 'c',
-  'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'u', 'b', 'v',
-  '_', 'a', 'c', 'c', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
-  '_', 'v', 'm', 'p', 'y', 'u', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
-  'm', 'p', 'y', 'u', 'h', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
-  '6', '_', 'v', 'm', 'p', 'y', 'u', 'h', '_', 'a', 'c', 'c', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'u', 'h', '_', 'a', 'c', 'c', '_',
-  '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y',
-  'u', 'h', 'e', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'u',
-  'h', 'e', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
-  'm', 'p', 'y', 'u', 'h', 'e', '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
-  '6', '_', 'v', 'm', 'p', 'y', 'u', 'h', 'e', '_', 'a', 'c', 'c', '_', '1',
-  '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'u',
-  'h', 'v', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'u', 'h',
-  'v', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm',
-  'p', 'y', 'u', 'h', 'v', '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
-  '_', 'v', 'm', 'p', 'y', 'u', 'h', 'v', '_', 'a', 'c', 'c', '_', '1', '2',
-  '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'u', 'x', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'V', '6', '_', 'v', 'm', 'u', 'x', '_', '1', '2', '8', 'B', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'V', '6', '_', 'v', 'n', 'a', 'v', 'g', 'b', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'V', '6', '_', 'v', 'n', 'a', 'v', 'g', 'b', '_', '1', '2', '8', 'B',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'n', 'a', 'v', 'g', 'h', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'V', '6', '_', 'v', 'n', 'a', 'v', 'g', 'h', '_', '1', '2', '8',
-  'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'n', 'a', 'v', 'g', 'u', 'b',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'n', 'a', 'v', 'g', 'u', 'b', '_',
-  '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'n', 'a', 'v',
-  'g', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'n', 'a', 'v', 'g', 'w',
-  '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'n', 'o',
-  'r', 'm', 'a', 'm', 't', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'n',
-  'o', 'r', 'm', 'a', 'm', 't', 'h', '_', '1', '2', '8', 'B', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'V', '6', '_', 'v', 'n', 'o', 'r', 'm', 'a', 'm', 't', 'w', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'V', '6', '_', 'v', 'n', 'o', 'r', 'm', 'a', 'm', 't', 'w', '_',
-  '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'n', 'o', 't',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'n', 'o', 't', '_', '1', '2', '8',
-  'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'o', 'r', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'V', '6', '_', 'v', 'o', 'r', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'V', '6', '_', 'v', 'p', 'a', 'c', 'k', 'e', 'b', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
-  '6', '_', 'v', 'p', 'a', 'c', 'k', 'e', 'b', '_', '1', '2', '8', 'B', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'V', '6', '_', 'v', 'p', 'a', 'c', 'k', 'e', 'h', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'V', '6', '_', 'v', 'p', 'a', 'c', 'k', 'e', 'h', '_', '1', '2',
-  '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'p', 'a', 'c', 'k', 'h',
-  'b', '_', 's', 'a', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'p', 'a',
-  'c', 'k', 'h', 'b', '_', 's', 'a', 't', '_', '1', '2', '8', 'B', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'V', '6', '_', 'v', 'p', 'a', 'c', 'k', 'h', 'u', 'b', '_', 's',
-  'a', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'p', 'a', 'c', 'k', 'h',
-  'u', 'b', '_', 's', 'a', 't', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'V', '6', '_', 'v', 'p', 'a', 'c', 'k', 'o', 'b', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
-  '6', '_', 'v', 'p', 'a', 'c', 'k', 'o', 'b', '_', '1', '2', '8', 'B', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'V', '6', '_', 'v', 'p', 'a', 'c', 'k', 'o', 'h', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'V', '6', '_', 'v', 'p', 'a', 'c', 'k', 'o', 'h', '_', '1', '2',
-  '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'p', 'a', 'c', 'k', 'w',
-  'h', '_', 's', 'a', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'p', 'a',
-  'c', 'k', 'w', 'h', '_', 's', 'a', 't', '_', '1', '2', '8', 'B', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'V', '6', '_', 'v', 'p', 'a', 'c', 'k', 'w', 'u', 'h', '_', 's',
-  'a', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'p', 'a', 'c', 'k', 'w',
-  'u', 'h', '_', 's', 'a', 't', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'V', '6', '_', 'v', 'p', 'o', 'p', 'c', 'o', 'u', 'n', 't', 'h', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'V', '6', '_', 'v', 'p', 'o', 'p', 'c', 'o', 'u', 'n', 't', 'h',
-  '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'p', 'r',
-  'e', 'f', 'i', 'x', 'q', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'p',
-  'r', 'e', 'f', 'i', 'x', 'q', 'b', '_', '1', '2', '8', 'B', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'V', '6', '_', 'v', 'p', 'r', 'e', 'f', 'i', 'x', 'q', 'h', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'V', '6', '_', 'v', 'p', 'r', 'e', 'f', 'i', 'x', 'q', 'h', '_',
-  '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'p', 'r', 'e',
-  'f', 'i', 'x', 'q', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'p', 'r',
-  'e', 'f', 'i', 'x', 'q', 'w', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'V', '6', '_', 'v', 'r', 'd', 'e', 'l', 't', 'a', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
-  '6', '_', 'v', 'r', 'd', 'e', 'l', 't', 'a', '_', '1', '2', '8', 'B', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'V', '6', '_', 'v', 'r', 'm', 'p', 'y', 'b', 'u', 'b', '_',
-  'r', 't', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'r', 'm', 'p', 'y',
-  'b', 'u', 'b', '_', 'r', 't', 't', '_', '1', '2', '8', 'B', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'V', '6', '_', 'v', 'r', 'm', 'p', 'y', 'b', 'u', 'b', '_', 'r', 't',
-  't', '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'r', 'm',
-  'p', 'y', 'b', 'u', 'b', '_', 'r', 't', 't', '_', 'a', 'c', 'c', '_', '1',
-  '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'r', 'm', 'p', 'y',
-  'b', 'u', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'r', 'm', 'p', 'y',
-  'b', 'u', 's', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
-  'v', 'r', 'm', 'p', 'y', 'b', 'u', 's', '_', 'a', 'c', 'c', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'V', '6', '_', 'v', 'r', 'm', 'p', 'y', 'b', 'u', 's', '_', 'a', 'c',
-  'c', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'r',
-  'm', 'p', 'y', 'b', 'u', 's', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
-  'r', 'm', 'p', 'y', 'b', 'u', 's', 'i', '_', '1', '2', '8', 'B', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'V', '6', '_', 'v', 'r', 'm', 'p', 'y', 'b', 'u', 's', 'i', '_',
-  'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'r', 'm', 'p', 'y',
-  'b', 'u', 's', 'i', '_', 'a', 'c', 'c', '_', '1', '2', '8', 'B', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'V', '6', '_', 'v', 'r', 'm', 'p', 'y', 'b', 'u', 's', 'v', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'V', '6', '_', 'v', 'r', 'm', 'p', 'y', 'b', 'u', 's', 'v',
-  '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'r', 'm',
-  'p', 'y', 'b', 'u', 's', 'v', '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
-  '6', '_', 'v', 'r', 'm', 'p', 'y', 'b', 'u', 's', 'v', '_', 'a', 'c', 'c',
-  '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'r', 'm',
-  'p', 'y', 'b', 'v', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'r', 'm', 'p',
-  'y', 'b', 'v', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
-  'v', 'r', 'm', 'p', 'y', 'b', 'v', '_', 'a', 'c', 'c', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'V', '6', '_', 'v', 'r', 'm', 'p', 'y', 'b', 'v', '_', 'a', 'c', 'c', '_',
-  '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'r', 'm', 'p',
-  'y', 'u', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'r', 'm', 'p', 'y',
-  'u', 'b', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
-  'r', 'm', 'p', 'y', 'u', 'b', '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
-  '6', '_', 'v', 'r', 'm', 'p', 'y', 'u', 'b', '_', 'a', 'c', 'c', '_', '1',
-  '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'r', 'm', 'p', 'y',
-  'u', 'b', '_', 'r', 't', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'r',
-  'm', 'p', 'y', 'u', 'b', '_', 'r', 't', 't', '_', '1', '2', '8', 'B', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'V', '6', '_', 'v', 'r', 'm', 'p', 'y', 'u', 'b', '_', 'r',
-  't', 't', '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'r',
-  'm', 'p', 'y', 'u', 'b', '_', 'r', 't', 't', '_', 'a', 'c', 'c', '_', '1',
-  '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'r', 'm', 'p', 'y',
-  'u', 'b', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'r', 'm', 'p', 'y',
-  'u', 'b', 'i', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
-  'v', 'r', 'm', 'p', 'y', 'u', 'b', 'i', '_', 'a', 'c', 'c', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'V', '6', '_', 'v', 'r', 'm', 'p', 'y', 'u', 'b', 'i', '_', 'a', 'c',
-  'c', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'r',
-  'm', 'p', 'y', 'u', 'b', 'v', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'r',
-  'm', 'p', 'y', 'u', 'b', 'v', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'V', '6', '_', 'v', 'r', 'm', 'p', 'y', 'u', 'b', 'v', '_', 'a', 'c', 'c',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'r', 'm', 'p', 'y', 'u', 'b', 'v',
-  '_', 'a', 'c', 'c', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
-  '_', 'v', 'r', 'o', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'r', 'o',
-  'r', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'r',
-  'o', 't', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'r', 'o', 't', 'r',
-  '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'r', 'o',
-  'u', 'n', 'd', 'h', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'r', 'o',
-  'u', 'n', 'd', 'h', 'b', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
-  '6', '_', 'v', 'r', 'o', 'u', 'n', 'd', 'h', 'u', 'b', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'V', '6', '_', 'v', 'r', 'o', 'u', 'n', 'd', 'h', 'u', 'b', '_', '1', '2',
-  '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'r', 'o', 'u', 'n', 'd',
-  'u', 'h', 'u', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'r', 'o', 'u',
-  'n', 'd', 'u', 'h', 'u', 'b', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'V', '6', '_', 'v', 'r', 'o', 'u', 'n', 'd', 'u', 'w', 'u', 'h', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'V', '6', '_', 'v', 'r', 'o', 'u', 'n', 'd', 'u', 'w', 'u', 'h',
-  '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'r', 'o',
-  'u', 'n', 'd', 'w', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'r', 'o',
-  'u', 'n', 'd', 'w', 'h', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
-  '6', '_', 'v', 'r', 'o', 'u', 'n', 'd', 'w', 'u', 'h', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'V', '6', '_', 'v', 'r', 'o', 'u', 'n', 'd', 'w', 'u', 'h', '_', '1', '2',
-  '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'r', 's', 'a', 'd', 'u',
-  'b', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'r', 's', 'a', 'd', 'u',
-  'b', 'i', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
-  'r', 's', 'a', 'd', 'u', 'b', 'i', '_', 'a', 'c', 'c', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'V', '6', '_', 'v', 'r', 's', 'a', 'd', 'u', 'b', 'i', '_', 'a', 'c', 'c',
-  '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'a',
-  't', 'd', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'a', 't', 'd',
-  'w', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's',
-  'a', 't', 'h', 'u', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'a',
-  't', 'h', 'u', 'b', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
-  '_', 'v', 's', 'a', 't', 'u', 'w', 'u', 'h', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
-  '_', 'v', 's', 'a', 't', 'u', 'w', 'u', 'h', '_', '1', '2', '8', 'B', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'V', '6', '_', 'v', 's', 'a', 't', 'w', 'h', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'V', '6', '_', 'v', 's', 'a', 't', 'w', 'h', '_', '1', '2', '8', 'B',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'b', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
-  '6', '_', 'v', 's', 'b', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
-  '6', '_', 'v', 's', 'c', 'a', 't', 't', 'e', 'r', 'm', 'h', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'V', '6', '_', 'v', 's', 'c', 'a', 't', 't', 'e', 'r', 'm', 'h', '_',
-  '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'c', 'a',
-  't', 't', 'e', 'r', 'm', 'h', '_', 'a', 'd', 'd', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
-  '6', '_', 'v', 's', 'c', 'a', 't', 't', 'e', 'r', 'm', 'h', '_', 'a', 'd',
-  'd', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's',
-  'c', 'a', 't', 't', 'e', 'r', 'm', 'h', 'q', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
-  '_', 'v', 's', 'c', 'a', 't', 't', 'e', 'r', 'm', 'h', 'q', '_', '1', '2',
-  '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'c', 'a', 't', 't',
-  'e', 'r', 'm', 'h', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'c',
-  'a', 't', 't', 'e', 'r', 'm', 'h', 'w', '_', '1', '2', '8', 'B', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'V', '6', '_', 'v', 's', 'c', 'a', 't', 't', 'e', 'r', 'm', 'h',
-  'w', '_', 'a', 'd', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'c',
-  'a', 't', 't', 'e', 'r', 'm', 'h', 'w', '_', 'a', 'd', 'd', '_', '1', '2',
-  '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'c', 'a', 't', 't',
-  'e', 'r', 'm', 'h', 'w', 'q', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's',
-  'c', 'a', 't', 't', 'e', 'r', 'm', 'h', 'w', 'q', '_', '1', '2', '8', 'B',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'c', 'a', 't', 't', 'e', 'r',
-  'm', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'c', 'a', 't', 't',
-  'e', 'r', 'm', 'w', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
-  '_', 'v', 's', 'c', 'a', 't', 't', 'e', 'r', 'm', 'w', '_', 'a', 'd', 'd',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'c', 'a', 't', 't', 'e', 'r',
-  'm', 'w', '_', 'a', 'd', 'd', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'V', '6', '_', 'v', 's', 'c', 'a', 't', 't', 'e', 'r', 'm', 'w', 'q', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'V', '6', '_', 'v', 's', 'c', 'a', 't', 't', 'e', 'r', 'm',
-  'w', 'q', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
-  's', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'h', '_', '1', '2',
-  '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'h', 'u', 'f', 'e',
-  'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'h', 'u', 'f', 'e', 'h',
-  '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'h',
-  'u', 'f', 'f', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'h', 'u',
-  'f', 'f', 'b', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
-  'v', 's', 'h', 'u', 'f', 'f', 'e', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
-  'v', 's', 'h', 'u', 'f', 'f', 'e', 'b', '_', '1', '2', '8', 'B', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'V', '6', '_', 'v', 's', 'h', 'u', 'f', 'f', 'h', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'V', '6', '_', 'v', 's', 'h', 'u', 'f', 'f', 'h', '_', '1', '2', '8',
-  'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'h', 'u', 'f', 'f', 'o',
-  'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'h', 'u', 'f', 'f', 'o',
-  'b', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's',
-  'h', 'u', 'f', 'f', 'v', 'd', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
-  's', 'h', 'u', 'f', 'f', 'v', 'd', 'd', '_', '1', '2', '8', 'B', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'V', '6', '_', 'v', 's', 'h', 'u', 'f', 'o', 'e', 'b', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'V', '6', '_', 'v', 's', 'h', 'u', 'f', 'o', 'e', 'b', '_', '1',
-  '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'h', 'u', 'f',
-  'o', 'e', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'h', 'u', 'f',
-  'o', 'e', 'h', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
-  'v', 's', 'h', 'u', 'f', 'o', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
-  's', 'h', 'u', 'f', 'o', 'h', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'V', '6', '_', 'v', 's', 'u', 'b', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
-  'v', 's', 'u', 'b', 'b', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
-  '6', '_', 'v', 's', 'u', 'b', 'b', '_', 'd', 'v', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
-  '6', '_', 'v', 's', 'u', 'b', 'b', '_', 'd', 'v', '_', '1', '2', '8', 'B',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'u', 'b', 'b', 'n', 'q', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'V', '6', '_', 'v', 's', 'u', 'b', 'b', 'n', 'q', '_', '1',
-  '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'u', 'b', 'b',
-  'q', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'u', 'b', 'b', 'q', '_',
-  '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'u', 'b',
   'b', 's', 'a', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'u', 'b',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'd', 'd',
   'b', 's', 'a', 't', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i',
   'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
-  '_', 'v', 's', 'u', 'b', 'b', 's', 'a', 't', '_', 'd', 'v', '\000', '_', '_',
+  '_', 'v', 'a', 'd', 'd', 'b', 's', 'a', 't', '_', 'd', 'v', '\000', '_', '_',
   'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'V', '6', '_', 'v', 's', 'u', 'b', 'b', 's', 'a', 't', '_', 'd', 'v',
+  '_', 'V', '6', '_', 'v', 'a', 'd', 'd', 'b', 's', 'a', 't', '_', 'd', 'v',
   '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'u',
-  'b', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'u', 'b', 'h', '_',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'd',
+  'd', 'c', 'l', 'b', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'd',
+  'd', 'c', 'l', 'b', 'h', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
+  '6', '_', 'v', 'a', 'd', 'd', 'c', 'l', 'b', 'w', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
+  '6', '_', 'v', 'a', 'd', 'd', 'c', 'l', 'b', 'w', '_', '1', '2', '8', 'B',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'd', 'd', 'h', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'V', '6', '_', 'v', 'a', 'd', 'd', 'h', '_', '1', '2', '8', 'B', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'd', 'd', 'h', '_', 'd', 'v', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'd', 'd', 'h', '_', 'd', 'v', '_',
   '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'u', 'b',
-  'h', '_', 'd', 'v', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'u', 'b',
-  'h', '_', 'd', 'v', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'd', 'd',
+  'h', 's', 'a', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'd', 'd',
+  'h', 's', 'a', 't', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i',
   'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
-  '_', 'v', 's', 'u', 'b', 'h', 'n', 'q', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
-  'v', 's', 'u', 'b', 'h', 'n', 'q', '_', '1', '2', '8', 'B', '\000', '_', '_',
+  '_', 'v', 'a', 'd', 'd', 'h', 's', 'a', 't', '_', 'd', 'v', '\000', '_', '_',
   'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'V', '6', '_', 'v', 's', 'u', 'b', 'h', 'q', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
-  '6', '_', 'v', 's', 'u', 'b', 'h', 'q', '_', '1', '2', '8', 'B', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'V', '6', '_', 'v', 's', 'u', 'b', 'h', 's', 'a', 't', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'V', '6', '_', 'v', 's', 'u', 'b', 'h', 's', 'a', 't', '_', '1',
-  '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'u', 'b', 'h',
-  's', 'a', 't', '_', 'd', 'v', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's',
-  'u', 'b', 'h', 's', 'a', 't', '_', 'd', 'v', '_', '1', '2', '8', 'B', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'V', '6', '_', 'v', 's', 'u', 'b', 'h', 'w', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'V', '6', '_', 'v', 's', 'u', 'b', 'h', 'w', '_', '1', '2', '8', 'B',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'u', 'b', 'u', 'b', 'h', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'V', '6', '_', 'v', 's', 'u', 'b', 'u', 'b', 'h', '_', '1',
-  '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'u', 'b', 'u',
-  'b', 's', 'a', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'u', 'b',
-  'u', 'b', 's', 'a', 't', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
-  '6', '_', 'v', 's', 'u', 'b', 'u', 'b', 's', 'a', 't', '_', 'd', 'v', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'V', '6', '_', 'v', 's', 'u', 'b', 'u', 'b', 's', 'a', 't',
-  '_', 'd', 'v', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
-  'v', 's', 'u', 'b', 'u', 'b', 'u', 'b', 'b', '_', 's', 'a', 't', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'V', '6', '_', 'v', 's', 'u', 'b', 'u', 'b', 'u', 'b', 'b', '_',
-  's', 'a', 't', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
-  'v', 's', 'u', 'b', 'u', 'h', 's', 'a', 't', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
-  '_', 'v', 's', 'u', 'b', 'u', 'h', 's', 'a', 't', '_', '1', '2', '8', 'B',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'u', 'b', 'u', 'h', 's', 'a',
-  't', '_', 'd', 'v', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'u', 'b',
-  'u', 'h', 's', 'a', 't', '_', 'd', 'v', '_', '1', '2', '8', 'B', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'V', '6', '_', 'v', 's', 'u', 'b', 'u', 'h', 'w', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'V', '6', '_', 'v', 's', 'u', 'b', 'u', 'h', 'w', '_', '1', '2', '8',
-  'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
-  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'u', 'b', 'u', 'w', 's',
-  'a', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'u', 'b', 'u', 'w',
-  's', 'a', 't', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
-  'v', 's', 'u', 'b', 'u', 'w', 's', 'a', 't', '_', 'd', 'v', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'V', '6', '_', 'v', 's', 'u', 'b', 'u', 'w', 's', 'a', 't', '_', 'd',
-  'v', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's',
-  'u', 'b', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'u', 'b', 'w',
+  '_', 'V', '6', '_', 'v', 'a', 'd', 'd', 'h', 's', 'a', 't', '_', 'd', 'v',
   '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'u',
-  'b', 'w', '_', 'd', 'v', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'u',
-  'b', 'w', '_', 'd', 'v', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'd',
+  'd', 'h', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'd', 'd', 'h',
+  'w', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a',
+  'd', 'd', 'h', 'w', '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
+  'v', 'a', 'd', 'd', 'h', 'w', '_', 'a', 'c', 'c', '_', '1', '2', '8', 'B',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'd', 'd', 'u', 'b', 'h', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'd', 'd', 'u', 'b', 'h', '_', '1',
+  '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'd', 'd', 'u',
+  'b', 'h', '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a',
+  'd', 'd', 'u', 'b', 'h', '_', 'a', 'c', 'c', '_', '1', '2', '8', 'B', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'd', 'd', 'u', 'b', 's', 'a', 't',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'd', 'd', 'u', 'b', 's', 'a',
+  't', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a',
+  'd', 'd', 'u', 'b', 's', 'a', 't', '_', 'd', 'v', '\000', '_', '_', 'b', 'u',
   'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
-  '6', '_', 'v', 's', 'u', 'b', 'w', 'n', 'q', '\000', '_', '_', 'b', 'u', 'i',
+  '6', '_', 'v', 'a', 'd', 'd', 'u', 'b', 's', 'a', 't', '_', 'd', 'v', '_',
+  '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'd', 'd',
+  'u', 'b', 'u', 'b', 'b', '_', 's', 'a', 't', '\000', '_', '_', 'b', 'u', 'i',
   'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
-  '_', 'v', 's', 'u', 'b', 'w', 'n', 'q', '_', '1', '2', '8', 'B', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'V', '6', '_', 'v', 's', 'u', 'b', 'w', 'q', '\000', '_', '_', 'b',
+  '_', 'v', 'a', 'd', 'd', 'u', 'b', 'u', 'b', 'b', '_', 's', 'a', 't', '_',
+  '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'd', 'd',
+  'u', 'h', 's', 'a', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'd',
+  'd', 'u', 'h', 's', 'a', 't', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b',
   'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'V', '6', '_', 'v', 's', 'u', 'b', 'w', 'q', '_', '1', '2', '8', 'B', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'V', '6', '_', 'v', 's', 'u', 'b', 'w', 's', 'a', 't', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'V', '6', '_', 'v', 's', 'u', 'b', 'w', 's', 'a', 't', '_',
-  '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'u', 'b',
-  'w', 's', 'a', 't', '_', 'd', 'v', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'V', '6', '_', 'v', 'a', 'd', 'd', 'u', 'h', 's', 'a', 't', '_', 'd', 'v',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'd', 'd', 'u', 'h', 's', 'a',
+  't', '_', 'd', 'v', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
+  '_', 'v', 'a', 'd', 'd', 'u', 'h', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
+  'v', 'a', 'd', 'd', 'u', 'h', 'w', '_', '1', '2', '8', 'B', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'V', '6', '_', 'v', 'a', 'd', 'd', 'u', 'h', 'w', '_', 'a', 'c', 'c',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'd', 'd', 'u', 'h', 'w', '_',
+  'a', 'c', 'c', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
+  'v', 'a', 'd', 'd', 'u', 'w', 's', 'a', 't', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
+  '_', 'v', 'a', 'd', 'd', 'u', 'w', 's', 'a', 't', '_', '1', '2', '8', 'B',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'd', 'd', 'u', 'w', 's', 'a',
+  't', '_', 'd', 'v', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'd', 'd',
+  'u', 'w', 's', 'a', 't', '_', 'd', 'v', '_', '1', '2', '8', 'B', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'V', '6', '_', 'v', 'a', 'd', 'd', 'w', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
+  '6', '_', 'v', 'a', 'd', 'd', 'w', '_', '1', '2', '8', 'B', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'V', '6', '_', 'v', 'a', 'd', 'd', 'w', '_', 'd', 'v', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'V', '6', '_', 'v', 'a', 'd', 'd', 'w', '_', 'd', 'v', '_', '1', '2',
+  '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'd', 'd', 'w', 's',
+  'a', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'd', 'd', 'w', 's',
+  'a', 't', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
   'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
-  's', 'u', 'b', 'w', 's', 'a', 't', '_', 'd', 'v', '_', '1', '2', '8', 'B',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'w', 'a', 'p', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'V', '6', '_', 'v', 's', 'w', 'a', 'p', '_', '1', '2', '8', 'B', '\000',
+  'a', 'd', 'd', 'w', 's', 'a', 't', '_', 'd', 'v', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
+  '6', '_', 'v', 'a', 'd', 'd', 'w', 's', 'a', 't', '_', 'd', 'v', '_', '1',
+  '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'l', 'i', 'g',
+  'n', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'l', 'i', 'g', 'n',
+  'b', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a',
+  'l', 'i', 'g', 'n', 'b', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a',
+  'l', 'i', 'g', 'n', 'b', 'i', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'V', '6', '_', 'v', 'a', 'n', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
+  'a', 'n', 'd', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
+  'v', 'a', 's', 'l', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 's',
+  'l', 'h', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
+  'a', 's', 'l', 'h', '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
+  'v', 'a', 's', 'l', 'h', '_', 'a', 'c', 'c', '_', '1', '2', '8', 'B', '\000',
   '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'V', '6', '_', 'v', 't', 'm', 'p', 'y', 'b', '\000', '_', '_',
+  'O', 'N', '_', 'V', '6', '_', 'v', 'a', 's', 'l', 'h', 'v', '\000', '_', '_',
   'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'V', '6', '_', 'v', 't', 'm', 'p', 'y', 'b', '_', '1', '2', '8', 'B',
+  '_', 'V', '6', '_', 'v', 'a', 's', 'l', 'h', 'v', '_', '1', '2', '8', 'B',
   '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 't', 'm', 'p', 'y', 'b', '_', 'a',
+  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 's', 'l', 'w', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'V', '6', '_', 'v', 'a', 's', 'l', 'w', '_', '1', '2', '8', 'B', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'V', '6', '_', 'v', 'a', 's', 'l', 'w', '_', 'a', 'c', 'c',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 's', 'l', 'w', '_', 'a', 'c',
+  'c', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a',
+  's', 'l', 'w', 'v', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 's', 'l',
+  'w', 'v', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
+  'a', 's', 'r', '_', 'i', 'n', 't', 'o', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
+  'v', 'a', 's', 'r', '_', 'i', 'n', 't', 'o', '_', '1', '2', '8', 'B', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'V', '6', '_', 'v', 'a', 's', 'r', 'h', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'V', '6', '_', 'v', 'a', 's', 'r', 'h', '_', '1', '2', '8', 'B', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'V', '6', '_', 'v', 'a', 's', 'r', 'h', '_', 'a', 'c', 'c', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'V', '6', '_', 'v', 'a', 's', 'r', 'h', '_', 'a', 'c', 'c',
+  '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 's',
+  'r', 'h', 'b', 'r', 'n', 'd', 's', 'a', 't', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
+  '_', 'v', 'a', 's', 'r', 'h', 'b', 'r', 'n', 'd', 's', 'a', 't', '_', '1',
+  '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 's', 'r', 'h',
+  'b', 's', 'a', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 's', 'r',
+  'h', 'b', 's', 'a', 't', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
+  '6', '_', 'v', 'a', 's', 'r', 'h', 'u', 'b', 'r', 'n', 'd', 's', 'a', 't',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 's', 'r', 'h', 'u', 'b', 'r',
+  'n', 'd', 's', 'a', 't', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
+  '6', '_', 'v', 'a', 's', 'r', 'h', 'u', 'b', 's', 'a', 't', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'V', '6', '_', 'v', 'a', 's', 'r', 'h', 'u', 'b', 's', 'a', 't', '_',
+  '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 's', 'r',
+  'h', 'v', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 's', 'r', 'h', 'v',
+  '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 's',
+  'r', 'u', 'h', 'u', 'b', 'r', 'n', 'd', 's', 'a', 't', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'V', '6', '_', 'v', 'a', 's', 'r', 'u', 'h', 'u', 'b', 'r', 'n', 'd', 's',
+  'a', 't', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
+  'a', 's', 'r', 'u', 'h', 'u', 'b', 's', 'a', 't', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
+  '6', '_', 'v', 'a', 's', 'r', 'u', 'h', 'u', 'b', 's', 'a', 't', '_', '1',
+  '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 's', 'r', 'u',
+  'w', 'u', 'h', 'r', 'n', 'd', 's', 'a', 't', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
+  '_', 'v', 'a', 's', 'r', 'u', 'w', 'u', 'h', 'r', 'n', 'd', 's', 'a', 't',
+  '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 's',
+  'r', 'u', 'w', 'u', 'h', 's', 'a', 't', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
+  'v', 'a', 's', 'r', 'u', 'w', 'u', 'h', 's', 'a', 't', '_', '1', '2', '8',
+  'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 's', 'r', 'w', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'V', '6', '_', 'v', 'a', 's', 'r', 'w', '_', '1', '2', '8', 'B',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 's', 'r', 'w', '_', 'a', 'c',
+  'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 's', 'r', 'w', '_', 'a',
+  'c', 'c', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
+  'a', 's', 'r', 'w', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 's',
+  'r', 'w', 'h', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
+  'v', 'a', 's', 'r', 'w', 'h', 'r', 'n', 'd', 's', 'a', 't', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'V', '6', '_', 'v', 'a', 's', 'r', 'w', 'h', 'r', 'n', 'd', 's', 'a',
+  't', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a',
+  's', 'r', 'w', 'h', 's', 'a', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
+  'a', 's', 'r', 'w', 'h', 's', 'a', 't', '_', '1', '2', '8', 'B', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'V', '6', '_', 'v', 'a', 's', 'r', 'w', 'u', 'h', 'r', 'n', 'd',
+  's', 'a', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 's', 'r', 'w',
+  'u', 'h', 'r', 'n', 'd', 's', 'a', 't', '_', '1', '2', '8', 'B', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'V', '6', '_', 'v', 'a', 's', 'r', 'w', 'u', 'h', 's', 'a', 't',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 's', 'r', 'w', 'u', 'h', 's',
+  'a', 't', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
+  'a', 's', 'r', 'w', 'v', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 's',
+  'r', 'w', 'v', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
+  'v', 'a', 's', 's', 'i', 'g', 'n', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
+  'a', 's', 's', 'i', 'g', 'n', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'V', '6', '_', 'v', 'a', 's', 's', 'i', 'g', 'n', 'p', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'V', '6', '_', 'v', 'a', 's', 's', 'i', 'g', 'n', 'p', '_', '1', '2', '8',
+  'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'v', 'g', 'b', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'V', '6', '_', 'v', 'a', 'v', 'g', 'b', '_', '1', '2', '8', 'B',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'v', 'g', 'b', 'r', 'n', 'd',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'v', 'g', 'b', 'r', 'n', 'd',
+  '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'v',
+  'g', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'v', 'g', 'h', '_',
+  '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'v', 'g',
+  'h', 'r', 'n', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'v', 'g',
+  'h', 'r', 'n', 'd', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
+  '_', 'v', 'a', 'v', 'g', 'u', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
+  'a', 'v', 'g', 'u', 'b', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
+  '6', '_', 'v', 'a', 'v', 'g', 'u', 'b', 'r', 'n', 'd', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'V', '6', '_', 'v', 'a', 'v', 'g', 'u', 'b', 'r', 'n', 'd', '_', '1', '2',
+  '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'v', 'g', 'u', 'h',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'v', 'g', 'u', 'h', '_', '1',
+  '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'v', 'g', 'u',
+  'h', 'r', 'n', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'v', 'g',
+  'u', 'h', 'r', 'n', 'd', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
+  '6', '_', 'v', 'a', 'v', 'g', 'u', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
+  'v', 'a', 'v', 'g', 'u', 'w', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'V', '6', '_', 'v', 'a', 'v', 'g', 'u', 'w', 'r', 'n', 'd', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'V', '6', '_', 'v', 'a', 'v', 'g', 'u', 'w', 'r', 'n', 'd', '_', '1',
+  '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'v', 'g', 'w',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'v', 'g', 'w', '_', '1', '2',
+  '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'v', 'g', 'w', 'r',
+  'n', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'a', 'v', 'g', 'w', 'r',
+  'n', 'd', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
+  'c', 'l', '0', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'c', 'l', '0',
+  'h', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'c',
+  'l', '0', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'c', 'l', '0', 'w',
+  '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'c', 'o',
+  'm', 'b', 'i', 'n', 'e', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'c', 'o',
+  'm', 'b', 'i', 'n', 'e', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
+  '6', '_', 'v', 'd', '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'd', '0',
+  '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'd', 'd',
+  '0', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'd', 'd', '0', '_', '1', '2',
+  '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'd', 'e', 'a', 'l', 'b',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'd', 'e', 'a', 'l', 'b', '_', '1',
+  '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'd', 'e', 'a', 'l',
+  'b', '4', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'd', 'e', 'a', 'l',
+  'b', '4', 'w', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
+  'v', 'd', 'e', 'a', 'l', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'd',
+  'e', 'a', 'l', 'h', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
+  '_', 'v', 'd', 'e', 'a', 'l', 'v', 'd', 'd', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
+  '_', 'v', 'd', 'e', 'a', 'l', 'v', 'd', 'd', '_', '1', '2', '8', 'B', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'V', '6', '_', 'v', 'd', 'e', 'l', 't', 'a', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'V', '6', '_', 'v', 'd', 'e', 'l', 't', 'a', '_', '1', '2', '8', 'B',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'd', 'm', 'p', 'y', 'b', 'u', 's',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'd', 'm', 'p', 'y', 'b', 'u', 's',
+  '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'd', 'm',
+  'p', 'y', 'b', 'u', 's', '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
+  '_', 'v', 'd', 'm', 'p', 'y', 'b', 'u', 's', '_', 'a', 'c', 'c', '_', '1',
+  '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'd', 'm', 'p', 'y',
+  'b', 'u', 's', '_', 'd', 'v', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'd',
+  'm', 'p', 'y', 'b', 'u', 's', '_', 'd', 'v', '_', '1', '2', '8', 'B', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'V', '6', '_', 'v', 'd', 'm', 'p', 'y', 'b', 'u', 's', '_',
+  'd', 'v', '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'd',
+  'm', 'p', 'y', 'b', 'u', 's', '_', 'd', 'v', '_', 'a', 'c', 'c', '_', '1',
+  '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'd', 'm', 'p', 'y',
+  'h', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'd', 'm', 'p', 'y', 'h',
+  'b', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'd',
+  'm', 'p', 'y', 'h', 'b', '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
+  '_', 'v', 'd', 'm', 'p', 'y', 'h', 'b', '_', 'a', 'c', 'c', '_', '1', '2',
+  '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'd', 'm', 'p', 'y', 'h',
+  'b', '_', 'd', 'v', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'd', 'm', 'p',
+  'y', 'h', 'b', '_', 'd', 'v', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'V', '6', '_', 'v', 'd', 'm', 'p', 'y', 'h', 'b', '_', 'd', 'v', '_', 'a',
   'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 't', 'm', 'p', 'y', 'b',
+  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'd', 'm', 'p', 'y', 'h',
+  'b', '_', 'd', 'v', '_', 'a', 'c', 'c', '_', '1', '2', '8', 'B', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'V', '6', '_', 'v', 'd', 'm', 'p', 'y', 'h', 'i', 's', 'a', 't',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'd', 'm', 'p', 'y', 'h', 'i', 's',
+  'a', 't', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
+  'd', 'm', 'p', 'y', 'h', 'i', 's', 'a', 't', '_', 'a', 'c', 'c', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'V', '6', '_', 'v', 'd', 'm', 'p', 'y', 'h', 'i', 's', 'a', 't',
   '_', 'a', 'c', 'c', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i',
   'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
-  '_', 'v', 't', 'm', 'p', 'y', 'b', 'u', 's', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
-  '_', 'v', 't', 'm', 'p', 'y', 'b', 'u', 's', '_', '1', '2', '8', 'B', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'V', '6', '_', 'v', 't', 'm', 'p', 'y', 'b', 'u', 's', '_',
-  'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 't', 'm', 'p', 'y',
-  'b', 'u', 's', '_', 'a', 'c', 'c', '_', '1', '2', '8', 'B', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'V', '6', '_', 'v', 't', 'm', 'p', 'y', 'h', 'b', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'V', '6', '_', 'v', 't', 'm', 'p', 'y', 'h', 'b', '_', '1', '2', '8', 'B',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 't', 'm', 'p', 'y', 'h', 'b', '_',
-  'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 't', 'm', 'p', 'y',
-  'h', 'b', '_', 'a', 'c', 'c', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'V', '6', '_', 'v', 't', 'r', 'a', 'n', '2', 'x', '2', '_', 'm', 'a', 'p',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
-  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 't', 'r', 'a', 'n', '2', 'x', '2',
-  '_', 'm', 'a', 'p', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
-  '_', 'v', 'u', 'n', 'p', 'a', 'c', 'k', 'b', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
-  '_', 'v', 'u', 'n', 'p', 'a', 'c', 'k', 'b', '_', '1', '2', '8', 'B', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'V', '6', '_', 'v', 'u', 'n', 'p', 'a', 'c', 'k', 'h', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'V', '6', '_', 'v', 'u', 'n', 'p', 'a', 'c', 'k', 'h', '_',
-  '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'u', 'n', 'p',
-  'a', 'c', 'k', 'o', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'u', 'n',
-  'p', 'a', 'c', 'k', 'o', 'b', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'V', '6', '_', 'v', 'u', 'n', 'p', 'a', 'c', 'k', 'o', 'h', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
-  '_', 'V', '6', '_', 'v', 'u', 'n', 'p', 'a', 'c', 'k', 'o', 'h', '_', '1',
-  '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'u', 'n', 'p', 'a',
-  'c', 'k', 'u', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'u', 'n', 'p',
-  'a', 'c', 'k', 'u', 'b', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u',
+  '_', 'v', 'd', 'm', 'p', 'y', 'h', 's', 'a', 't', '\000', '_', '_', 'b', 'u',
   'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
-  '6', '_', 'v', 'u', 'n', 'p', 'a', 'c', 'k', 'u', 'h', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
-  'V', '6', '_', 'v', 'u', 'n', 'p', 'a', 'c', 'k', 'u', 'h', '_', '1', '2',
-  '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
-  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'x', 'o', 'r', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
-  'N', '_', 'V', '6', '_', 'v', 'x', 'o', 'r', '_', '1', '2', '8', 'B', '\000',
+  '6', '_', 'v', 'd', 'm', 'p', 'y', 'h', 's', 'a', 't', '_', '1', '2', '8',
+  'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'd', 'm', 'p', 'y', 'h', 's',
+  'a', 't', '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'd',
+  'm', 'p', 'y', 'h', 's', 'a', 't', '_', 'a', 'c', 'c', '_', '1', '2', '8',
+  'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'd', 'm', 'p', 'y', 'h', 's',
+  'u', 'i', 's', 'a', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'd', 'm',
+  'p', 'y', 'h', 's', 'u', 'i', 's', 'a', 't', '_', '1', '2', '8', 'B', '\000',
   '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
-  'O', 'N', '_', 'V', '6', '_', 'v', 'z', 'b', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
-  '_', 'v', 'z', 'b', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
-  '_', 'v', 'z', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'z', 'h', '_',
+  'O', 'N', '_', 'V', '6', '_', 'v', 'd', 'm', 'p', 'y', 'h', 's', 'u', 'i',
+  's', 'a', 't', '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
+  'd', 'm', 'p', 'y', 'h', 's', 'u', 'i', 's', 'a', 't', '_', 'a', 'c', 'c',
+  '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'd', 'm',
+  'p', 'y', 'h', 's', 'u', 's', 'a', 't', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
+  'v', 'd', 'm', 'p', 'y', 'h', 's', 'u', 's', 'a', 't', '_', '1', '2', '8',
+  'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'd', 'm', 'p', 'y', 'h', 's',
+  'u', 's', 'a', 't', '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
+  'v', 'd', 'm', 'p', 'y', 'h', 's', 'u', 's', 'a', 't', '_', 'a', 'c', 'c',
+  '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'd', 'm',
+  'p', 'y', 'h', 'v', 's', 'a', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
+  'd', 'm', 'p', 'y', 'h', 'v', 's', 'a', 't', '_', '1', '2', '8', 'B', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'V', '6', '_', 'v', 'd', 'm', 'p', 'y', 'h', 'v', 's', 'a',
+  't', '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'd', 'm',
+  'p', 'y', 'h', 'v', 's', 'a', 't', '_', 'a', 'c', 'c', '_', '1', '2', '8',
+  'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'd', 's', 'a', 'd', 'u', 'h',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'd', 's', 'a', 'd', 'u', 'h', '_',
   '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'Y', '2', '_', 'd', 'c', 'c', 'l',
-  'e', 'a', 'n', 'a', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'Y', '2', '_', 'd', 'c', 'c', 'l',
-  'e', 'a', 'n', 'i', 'n', 'v', 'a', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'Y', '2', '_', 'd',
-  'c', 'i', 'n', 'v', 'a', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'Y', '2', '_', 'd', 'c', 'z',
-  'e', 'r', 'o', 'a', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'Y', '4', '_', 'l', '2', 'f', 'e',
-  't', 'c', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
-  'E', 'X', 'A', 'G', 'O', 'N', '_', 'Y', '5', '_', 'l', '2', 'f', 'e', 't',
-  'c', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'c', 'i',
-  'r', 'c', '_', 'l', 'd', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'c', 'i', 'r', 'c', '_', 'l', 'd', 'd', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'c', 'i', 'r', 'c', '_', 'l', 'd', 'h', '\000',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'd', 's', 'a',
+  'd', 'u', 'h', '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
+  'd', 's', 'a', 'd', 'u', 'h', '_', 'a', 'c', 'c', '_', '1', '2', '8', 'B',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'g', 'a', 't', 'h', 'e', 'r', 'm',
+  'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'g', 'a', 't', 'h', 'e', 'r',
+  'm', 'h', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
+  'g', 'a', 't', 'h', 'e', 'r', 'm', 'h', 'w', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
+  '_', 'v', 'g', 'a', 't', 'h', 'e', 'r', 'm', 'h', 'w', '_', '1', '2', '8',
+  'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'g', 'a', 't', 'h', 'e', 'r',
+  'm', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'g', 'a', 't', 'h', 'e',
+  'r', 'm', 'w', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
+  'v', 'i', 'n', 's', 'e', 'r', 't', 'w', 'r', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
+  '_', 'v', 'i', 'n', 's', 'e', 'r', 't', 'w', 'r', '_', '1', '2', '8', 'B',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'l', 'a', 'l', 'i', 'g', 'n', 'b',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'l', 'a', 'l', 'i', 'g', 'n', 'b',
+  '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'l', 'a',
+  'l', 'i', 'g', 'n', 'b', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'l',
+  'a', 'l', 'i', 'g', 'n', 'b', 'i', '_', '1', '2', '8', 'B', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'V', '6', '_', 'v', 'l', 's', 'r', 'b', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
+  '_', 'v', 'l', 's', 'r', 'b', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'V', '6', '_', 'v', 'l', 's', 'r', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
+  'v', 'l', 's', 'r', 'h', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
+  '6', '_', 'v', 'l', 's', 'r', 'h', 'v', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
+  'v', 'l', 's', 'r', 'h', 'v', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'V', '6', '_', 'v', 'l', 's', 'r', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
+  'v', 'l', 's', 'r', 'w', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
+  '6', '_', 'v', 'l', 's', 'r', 'w', 'v', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
+  'v', 'l', 's', 'r', 'w', 'v', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'V', '6', '_', 'v', 'l', 'u', 't', '4', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
+  'v', 'l', 'u', 't', '4', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
+  '6', '_', 'v', 'l', 'u', 't', 'v', 'v', 'b', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
+  '_', 'v', 'l', 'u', 't', 'v', 'v', 'b', '_', '1', '2', '8', 'B', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'V', '6', '_', 'v', 'l', 'u', 't', 'v', 'v', 'b', '_', 'n', 'm',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'l', 'u', 't', 'v', 'v', 'b', '_',
+  'n', 'm', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
+  'l', 'u', 't', 'v', 'v', 'b', '_', 'o', 'r', 'a', 'c', 'c', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'V', '6', '_', 'v', 'l', 'u', 't', 'v', 'v', 'b', '_', 'o', 'r', 'a',
+  'c', 'c', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
+  'l', 'u', 't', 'v', 'v', 'b', '_', 'o', 'r', 'a', 'c', 'c', 'i', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'V', '6', '_', 'v', 'l', 'u', 't', 'v', 'v', 'b', '_', 'o', 'r',
+  'a', 'c', 'c', 'i', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
+  '_', 'v', 'l', 'u', 't', 'v', 'v', 'b', 'i', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
+  '_', 'v', 'l', 'u', 't', 'v', 'v', 'b', 'i', '_', '1', '2', '8', 'B', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'V', '6', '_', 'v', 'l', 'u', 't', 'v', 'w', 'h', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'V', '6', '_', 'v', 'l', 'u', 't', 'v', 'w', 'h', '_', '1', '2',
+  '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'l', 'u', 't', 'v', 'w',
+  'h', '_', 'n', 'm', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'l', 'u', 't',
+  'v', 'w', 'h', '_', 'n', 'm', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'V', '6', '_', 'v', 'l', 'u', 't', 'v', 'w', 'h', '_', 'o', 'r', 'a', 'c',
+  'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'l', 'u', 't', 'v', 'w', 'h',
+  '_', 'o', 'r', 'a', 'c', 'c', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'V', '6', '_', 'v', 'l', 'u', 't', 'v', 'w', 'h', '_', 'o', 'r', 'a', 'c',
+  'c', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'l', 'u', 't', 'v', 'w',
+  'h', '_', 'o', 'r', 'a', 'c', 'c', 'i', '_', '1', '2', '8', 'B', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'V', '6', '_', 'v', 'l', 'u', 't', 'v', 'w', 'h', 'i', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'V', '6', '_', 'v', 'l', 'u', 't', 'v', 'w', 'h', 'i', '_', '1',
+  '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'a', 'x', 'b',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'a', 'x', 'b', '_', '1', '2',
+  '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'a', 'x', 'h', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'a', 'x', 'h', '_', '1', '2', '8',
+  'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'a', 'x', 'u', 'b', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'a', 'x', 'u', 'b', '_', '1', '2',
+  '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'a', 'x', 'u', 'h',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'a', 'x', 'u', 'h', '_', '1',
+  '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'a', 'x', 'w',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'a', 'x', 'w', '_', '1', '2',
+  '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'i', 'n', 'b', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'i', 'n', 'b', '_', '1', '2', '8',
+  'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'i', 'n', 'h', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'V', '6', '_', 'v', 'm', 'i', 'n', 'h', '_', '1', '2', '8', 'B',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'i', 'n', 'u', 'b', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'V', '6', '_', 'v', 'm', 'i', 'n', 'u', 'b', '_', '1', '2', '8',
+  'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'i', 'n', 'u', 'h', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'i', 'n', 'u', 'h', '_', '1', '2',
+  '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'i', 'n', 'w', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'i', 'n', 'w', '_', '1', '2', '8',
+  'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'a', 'b', 'u', 's',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'a', 'b', 'u', 's', '_',
+  '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'a',
+  'b', 'u', 's', '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
+  'm', 'p', 'a', 'b', 'u', 's', '_', 'a', 'c', 'c', '_', '1', '2', '8', 'B',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'a', 'b', 'u', 's', 'v',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'a', 'b', 'u', 's', 'v',
+  '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p',
+  'a', 'b', 'u', 'u', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'a',
+  'b', 'u', 'u', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
+  'v', 'm', 'p', 'a', 'b', 'u', 'u', '_', 'a', 'c', 'c', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'V', '6', '_', 'v', 'm', 'p', 'a', 'b', 'u', 'u', '_', 'a', 'c', 'c', '_',
+  '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'a',
+  'b', 'u', 'u', 'v', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'a',
+  'b', 'u', 'u', 'v', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
+  '_', 'v', 'm', 'p', 'a', 'h', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
+  'm', 'p', 'a', 'h', 'b', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
+  '6', '_', 'v', 'm', 'p', 'a', 'h', 'b', '_', 'a', 'c', 'c', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'V', '6', '_', 'v', 'm', 'p', 'a', 'h', 'b', '_', 'a', 'c', 'c', '_',
+  '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'a',
+  'h', 'h', 's', 'a', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p',
+  'a', 'h', 'h', 's', 'a', 't', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'V', '6', '_', 'v', 'm', 'p', 'a', 'u', 'h', 'b', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
+  '6', '_', 'v', 'm', 'p', 'a', 'u', 'h', 'b', '_', '1', '2', '8', 'B', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'a', 'u', 'h', 'b', '_', 'a',
+  'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'a', 'u', 'h',
+  'b', '_', 'a', 'c', 'c', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
+  '6', '_', 'v', 'm', 'p', 'a', 'u', 'h', 'u', 'h', 's', 'a', 't', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'a', 'u', 'h', 'u', 'h', 's', 'a',
+  't', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm',
+  'p', 's', 'u', 'h', 'u', 'h', 's', 'a', 't', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
+  '_', 'v', 'm', 'p', 's', 'u', 'h', 'u', 'h', 's', 'a', 't', '_', '1', '2',
+  '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'b', 'u',
+  's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'b', 'u', 's',
+  '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p',
+  'y', 'b', 'u', 's', '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
+  'v', 'm', 'p', 'y', 'b', 'u', 's', '_', 'a', 'c', 'c', '_', '1', '2', '8',
+  'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'b', 'u', 's',
+  'v', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'b', 'u', 's',
+  'v', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm',
+  'p', 'y', 'b', 'u', 's', 'v', '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
+  '6', '_', 'v', 'm', 'p', 'y', 'b', 'u', 's', 'v', '_', 'a', 'c', 'c', '_',
+  '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y',
+  'b', 'v', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'b', 'v',
+  '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p',
+  'y', 'b', 'v', '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
+  'm', 'p', 'y', 'b', 'v', '_', 'a', 'c', 'c', '_', '1', '2', '8', 'B', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'e', 'w', 'u', 'h', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'e', 'w', 'u', 'h', '_',
+  '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y',
+  'e', 'w', 'u', 'h', '_', '6', '4', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
+  'm', 'p', 'y', 'e', 'w', 'u', 'h', '_', '6', '4', '_', '1', '2', '8', 'B',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'h', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'h', '_', '1', '2', '8', 'B', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'h', '_', 'a', 'c', 'c',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'h', '_', 'a', 'c',
+  'c', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm',
+  'p', 'y', 'h', 's', 'a', 't', '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
+  '6', '_', 'v', 'm', 'p', 'y', 'h', 's', 'a', 't', '_', 'a', 'c', 'c', '_',
+  '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y',
+  'h', 's', 'r', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y',
+  'h', 's', 'r', 's', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
+  '_', 'v', 'm', 'p', 'y', 'h', 's', 's', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
+  'v', 'm', 'p', 'y', 'h', 's', 's', '_', '1', '2', '8', 'B', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'h', 'u', 's', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'V', '6', '_', 'v', 'm', 'p', 'y', 'h', 'u', 's', '_', '1', '2', '8', 'B',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'h', 'u', 's', '_',
+  'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'h',
+  'u', 's', '_', 'a', 'c', 'c', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'V', '6', '_', 'v', 'm', 'p', 'y', 'h', 'v', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
+  '_', 'v', 'm', 'p', 'y', 'h', 'v', '_', '1', '2', '8', 'B', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'h', 'v', '_', 'a', 'c', 'c', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'h', 'v', '_', 'a', 'c',
+  'c', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm',
+  'p', 'y', 'h', 'v', 's', 'r', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
+  'm', 'p', 'y', 'h', 'v', 's', 'r', 's', '_', '1', '2', '8', 'B', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'i', 'e', 'o', 'h', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'i', 'e', 'o', 'h', '_', '1',
+  '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'i',
+  'e', 'w', 'h', '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
+  'm', 'p', 'y', 'i', 'e', 'w', 'h', '_', 'a', 'c', 'c', '_', '1', '2', '8',
+  'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'i', 'e', 'w',
+  'u', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'i', 'e',
+  'w', 'u', 'h', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
+  'v', 'm', 'p', 'y', 'i', 'e', 'w', 'u', 'h', '_', 'a', 'c', 'c', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'i', 'e', 'w', 'u', 'h', '_',
+  'a', 'c', 'c', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
+  'v', 'm', 'p', 'y', 'i', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm',
+  'p', 'y', 'i', 'h', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
+  '_', 'v', 'm', 'p', 'y', 'i', 'h', '_', 'a', 'c', 'c', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'V', '6', '_', 'v', 'm', 'p', 'y', 'i', 'h', '_', 'a', 'c', 'c', '_', '1',
+  '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'i',
+  'h', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'i', 'h',
+  'b', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm',
+  'p', 'y', 'i', 'h', 'b', '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
+  '_', 'v', 'm', 'p', 'y', 'i', 'h', 'b', '_', 'a', 'c', 'c', '_', '1', '2',
+  '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'i', 'o',
+  'w', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'i', 'o',
+  'w', 'h', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
+  'm', 'p', 'y', 'i', 'w', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm',
+  'p', 'y', 'i', 'w', 'b', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
+  '6', '_', 'v', 'm', 'p', 'y', 'i', 'w', 'b', '_', 'a', 'c', 'c', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'i', 'w', 'b', '_', 'a', 'c',
+  'c', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm',
+  'p', 'y', 'i', 'w', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p',
+  'y', 'i', 'w', 'h', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
+  '_', 'v', 'm', 'p', 'y', 'i', 'w', 'h', '_', 'a', 'c', 'c', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'i', 'w', 'h', '_', 'a', 'c', 'c',
+  '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p',
+  'y', 'i', 'w', 'u', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p',
+  'y', 'i', 'w', 'u', 'b', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
+  '6', '_', 'v', 'm', 'p', 'y', 'i', 'w', 'u', 'b', '_', 'a', 'c', 'c', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'i', 'w', 'u', 'b', '_',
+  'a', 'c', 'c', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
+  'v', 'm', 'p', 'y', 'o', 'w', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
+  'm', 'p', 'y', 'o', 'w', 'h', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'V', '6', '_', 'v', 'm', 'p', 'y', 'o', 'w', 'h', '_', '6', '4', '_', 'a',
+  'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'o', 'w',
+  'h', '_', '6', '4', '_', 'a', 'c', 'c', '_', '1', '2', '8', 'B', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'o', 'w', 'h', '_', 'r', 'n',
+  'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'o', 'w', 'h',
+  '_', 'r', 'n', 'd', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
+  '_', 'v', 'm', 'p', 'y', 'o', 'w', 'h', '_', 'r', 'n', 'd', '_', 's', 'a',
+  'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'o', 'w',
+  'h', '_', 'r', 'n', 'd', '_', 's', 'a', 'c', 'c', '_', '1', '2', '8', 'B',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'o', 'w', 'h', '_',
+  's', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y',
+  'o', 'w', 'h', '_', 's', 'a', 'c', 'c', '_', '1', '2', '8', 'B', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'u', 'b', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'V', '6', '_', 'v', 'm', 'p', 'y', 'u', 'b', '_', '1', '2', '8', 'B', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'u', 'b', '_', 'a', 'c',
+  'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'u', 'b', '_',
+  'a', 'c', 'c', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
+  'v', 'm', 'p', 'y', 'u', 'b', 'v', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
+  'm', 'p', 'y', 'u', 'b', 'v', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'V', '6', '_', 'v', 'm', 'p', 'y', 'u', 'b', 'v', '_', 'a', 'c', 'c', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'u', 'b', 'v', '_', 'a',
+  'c', 'c', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
+  'm', 'p', 'y', 'u', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p',
+  'y', 'u', 'h', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
+  'v', 'm', 'p', 'y', 'u', 'h', '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
+  '6', '_', 'v', 'm', 'p', 'y', 'u', 'h', '_', 'a', 'c', 'c', '_', '1', '2',
+  '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'u', 'h',
+  'e', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'u', 'h', 'e',
+  '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p',
+  'y', 'u', 'h', 'e', '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
+  'v', 'm', 'p', 'y', 'u', 'h', 'e', '_', 'a', 'c', 'c', '_', '1', '2', '8',
+  'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'u', 'h', 'v',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y', 'u', 'h', 'v', '_',
+  '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'm', 'p', 'y',
+  'u', 'h', 'v', '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
+  'm', 'p', 'y', 'u', 'h', 'v', '_', 'a', 'c', 'c', '_', '1', '2', '8', 'B',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'n', 'a', 'v', 'g', 'b', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'V', '6', '_', 'v', 'n', 'a', 'v', 'g', 'b', '_', '1', '2', '8',
+  'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'n', 'a', 'v', 'g', 'h', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'V', '6', '_', 'v', 'n', 'a', 'v', 'g', 'h', '_', '1', '2',
+  '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'n', 'a', 'v', 'g', 'u',
+  'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'n', 'a', 'v', 'g', 'u', 'b',
+  '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'n', 'a',
+  'v', 'g', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'n', 'a', 'v', 'g',
+  'w', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'n',
+  'o', 'r', 'm', 'a', 'm', 't', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
+  'n', 'o', 'r', 'm', 'a', 'm', 't', 'h', '_', '1', '2', '8', 'B', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'V', '6', '_', 'v', 'n', 'o', 'r', 'm', 'a', 'm', 't', 'w', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'V', '6', '_', 'v', 'n', 'o', 'r', 'm', 'a', 'm', 't', 'w',
+  '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'n', 'o',
+  't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'n', 'o', 't', '_', '1', '2',
+  '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'o', 'r', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'V', '6', '_', 'v', 'o', 'r', '_', '1', '2', '8', 'B', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'V', '6', '_', 'v', 'p', 'a', 'c', 'k', 'e', 'b', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'V', '6', '_', 'v', 'p', 'a', 'c', 'k', 'e', 'b', '_', '1', '2', '8', 'B',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'p', 'a', 'c', 'k', 'e', 'h', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'V', '6', '_', 'v', 'p', 'a', 'c', 'k', 'e', 'h', '_', '1',
+  '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'p', 'a', 'c', 'k',
+  'h', 'b', '_', 's', 'a', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'p',
+  'a', 'c', 'k', 'h', 'b', '_', 's', 'a', 't', '_', '1', '2', '8', 'B', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'V', '6', '_', 'v', 'p', 'a', 'c', 'k', 'h', 'u', 'b', '_',
+  's', 'a', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'p', 'a', 'c', 'k',
+  'h', 'u', 'b', '_', 's', 'a', 't', '_', '1', '2', '8', 'B', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'V', '6', '_', 'v', 'p', 'a', 'c', 'k', 'o', 'b', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'V', '6', '_', 'v', 'p', 'a', 'c', 'k', 'o', 'b', '_', '1', '2', '8', 'B',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'p', 'a', 'c', 'k', 'o', 'h', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'V', '6', '_', 'v', 'p', 'a', 'c', 'k', 'o', 'h', '_', '1',
+  '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'p', 'a', 'c', 'k',
+  'w', 'h', '_', 's', 'a', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'p',
+  'a', 'c', 'k', 'w', 'h', '_', 's', 'a', 't', '_', '1', '2', '8', 'B', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'V', '6', '_', 'v', 'p', 'a', 'c', 'k', 'w', 'u', 'h', '_',
+  's', 'a', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'p', 'a', 'c', 'k',
+  'w', 'u', 'h', '_', 's', 'a', 't', '_', '1', '2', '8', 'B', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'V', '6', '_', 'v', 'p', 'o', 'p', 'c', 'o', 'u', 'n', 't', 'h', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'V', '6', '_', 'v', 'p', 'o', 'p', 'c', 'o', 'u', 'n', 't',
+  'h', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'r',
+  'd', 'e', 'l', 't', 'a', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'r', 'd',
+  'e', 'l', 't', 'a', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
+  '_', 'v', 'r', 'm', 'p', 'y', 'b', 'u', 'b', '_', 'r', 't', 't', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'V', '6', '_', 'v', 'r', 'm', 'p', 'y', 'b', 'u', 'b', '_', 'r',
+  't', 't', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
+  'r', 'm', 'p', 'y', 'b', 'u', 'b', '_', 'r', 't', 't', '_', 'a', 'c', 'c',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'r', 'm', 'p', 'y', 'b', 'u', 'b',
+  '_', 'r', 't', 't', '_', 'a', 'c', 'c', '_', '1', '2', '8', 'B', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'V', '6', '_', 'v', 'r', 'm', 'p', 'y', 'b', 'u', 's', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'V', '6', '_', 'v', 'r', 'm', 'p', 'y', 'b', 'u', 's', '_', '1',
+  '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'r', 'm', 'p', 'y',
+  'b', 'u', 's', '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
+  'r', 'm', 'p', 'y', 'b', 'u', 's', '_', 'a', 'c', 'c', '_', '1', '2', '8',
+  'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'r', 'm', 'p', 'y', 'b', 'u',
+  's', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'r', 'm', 'p', 'y', 'b',
+  'u', 's', 'i', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
+  'v', 'r', 'm', 'p', 'y', 'b', 'u', 's', 'i', '_', 'a', 'c', 'c', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'V', '6', '_', 'v', 'r', 'm', 'p', 'y', 'b', 'u', 's', 'i', '_',
+  'a', 'c', 'c', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
+  'v', 'r', 'm', 'p', 'y', 'b', 'u', 's', 'v', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
+  '_', 'v', 'r', 'm', 'p', 'y', 'b', 'u', 's', 'v', '_', '1', '2', '8', 'B',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'r', 'm', 'p', 'y', 'b', 'u', 's',
+  'v', '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'r', 'm',
+  'p', 'y', 'b', 'u', 's', 'v', '_', 'a', 'c', 'c', '_', '1', '2', '8', 'B',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'r', 'm', 'p', 'y', 'b', 'v', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'V', '6', '_', 'v', 'r', 'm', 'p', 'y', 'b', 'v', '_', '1',
+  '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'r', 'm', 'p', 'y',
+  'b', 'v', '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'r',
+  'm', 'p', 'y', 'b', 'v', '_', 'a', 'c', 'c', '_', '1', '2', '8', 'B', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'V', '6', '_', 'v', 'r', 'm', 'p', 'y', 'u', 'b', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'V', '6', '_', 'v', 'r', 'm', 'p', 'y', 'u', 'b', '_', '1', '2',
+  '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'r', 'm', 'p', 'y', 'u',
+  'b', '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'r', 'm',
+  'p', 'y', 'u', 'b', '_', 'a', 'c', 'c', '_', '1', '2', '8', 'B', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'V', '6', '_', 'v', 'r', 'm', 'p', 'y', 'u', 'b', '_', 'r', 't',
+  't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'r', 'm', 'p', 'y', 'u', 'b',
+  '_', 'r', 't', 't', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
+  '_', 'v', 'r', 'm', 'p', 'y', 'u', 'b', '_', 'r', 't', 't', '_', 'a', 'c',
+  'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'r', 'm', 'p', 'y', 'u', 'b',
+  '_', 'r', 't', 't', '_', 'a', 'c', 'c', '_', '1', '2', '8', 'B', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'V', '6', '_', 'v', 'r', 'm', 'p', 'y', 'u', 'b', 'i', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'V', '6', '_', 'v', 'r', 'm', 'p', 'y', 'u', 'b', 'i', '_', '1',
+  '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'r', 'm', 'p', 'y',
+  'u', 'b', 'i', '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
+  'r', 'm', 'p', 'y', 'u', 'b', 'i', '_', 'a', 'c', 'c', '_', '1', '2', '8',
+  'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'r', 'm', 'p', 'y', 'u', 'b',
+  'v', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'r', 'm', 'p', 'y', 'u', 'b',
+  'v', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'r',
+  'm', 'p', 'y', 'u', 'b', 'v', '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
+  '6', '_', 'v', 'r', 'm', 'p', 'y', 'u', 'b', 'v', '_', 'a', 'c', 'c', '_',
+  '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'r', 'o', 'r',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'r', 'o', 'r', '_', '1', '2', '8',
+  'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'r', 'o', 't', 'r', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'V', '6', '_', 'v', 'r', 'o', 't', 'r', '_', '1', '2', '8', 'B',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'r', 'o', 'u', 'n', 'd', 'h', 'b',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'r', 'o', 'u', 'n', 'd', 'h', 'b',
+  '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'r', 'o',
+  'u', 'n', 'd', 'h', 'u', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'r',
+  'o', 'u', 'n', 'd', 'h', 'u', 'b', '_', '1', '2', '8', 'B', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'V', '6', '_', 'v', 'r', 'o', 'u', 'n', 'd', 'u', 'h', 'u', 'b', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'V', '6', '_', 'v', 'r', 'o', 'u', 'n', 'd', 'u', 'h', 'u',
+  'b', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'r',
+  'o', 'u', 'n', 'd', 'u', 'w', 'u', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
+  'v', 'r', 'o', 'u', 'n', 'd', 'u', 'w', 'u', 'h', '_', '1', '2', '8', 'B',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'r', 'o', 'u', 'n', 'd', 'w', 'h',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'r', 'o', 'u', 'n', 'd', 'w', 'h',
+  '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'r', 'o',
+  'u', 'n', 'd', 'w', 'u', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'r',
+  'o', 'u', 'n', 'd', 'w', 'u', 'h', '_', '1', '2', '8', 'B', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'V', '6', '_', 'v', 'r', 's', 'a', 'd', 'u', 'b', 'i', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'V', '6', '_', 'v', 'r', 's', 'a', 'd', 'u', 'b', 'i', '_', '1', '2',
+  '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'r', 's', 'a', 'd', 'u',
+  'b', 'i', '_', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'r',
+  's', 'a', 'd', 'u', 'b', 'i', '_', 'a', 'c', 'c', '_', '1', '2', '8', 'B',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'a', 't', 'd', 'w', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'V', '6', '_', 'v', 's', 'a', 't', 'd', 'w', '_', '1', '2', '8',
+  'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'a', 't', 'h', 'u', 'b',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'a', 't', 'h', 'u', 'b', '_',
+  '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'a', 't',
+  'u', 'w', 'u', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'a', 't',
+  'u', 'w', 'u', 'h', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
+  '_', 'v', 's', 'a', 't', 'w', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
+  's', 'a', 't', 'w', 'h', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
+  '6', '_', 'v', 's', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'b',
+  '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'c',
+  'a', 't', 't', 'e', 'r', 'm', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
+  's', 'c', 'a', 't', 't', 'e', 'r', 'm', 'h', '_', '1', '2', '8', 'B', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'V', '6', '_', 'v', 's', 'c', 'a', 't', 't', 'e', 'r', 'm',
+  'h', '_', 'a', 'd', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'c',
+  'a', 't', 't', 'e', 'r', 'm', 'h', '_', 'a', 'd', 'd', '_', '1', '2', '8',
+  'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'c', 'a', 't', 't', 'e',
+  'r', 'm', 'h', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'c', 'a',
+  't', 't', 'e', 'r', 'm', 'h', 'w', '_', '1', '2', '8', 'B', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'V', '6', '_', 'v', 's', 'c', 'a', 't', 't', 'e', 'r', 'm', 'h', 'w',
+  '_', 'a', 'd', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'c', 'a',
+  't', 't', 'e', 'r', 'm', 'h', 'w', '_', 'a', 'd', 'd', '_', '1', '2', '8',
+  'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'c', 'a', 't', 't', 'e',
+  'r', 'm', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'c', 'a', 't',
+  't', 'e', 'r', 'm', 'w', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
+  '6', '_', 'v', 's', 'c', 'a', 't', 't', 'e', 'r', 'm', 'w', '_', 'a', 'd',
+  'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'c', 'a', 't', 't', 'e',
+  'r', 'm', 'w', '_', 'a', 'd', 'd', '_', '1', '2', '8', 'B', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'V', '6', '_', 'v', 's', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
+  's', 'h', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
+  's', 'h', 'u', 'f', 'e', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's',
+  'h', 'u', 'f', 'e', 'h', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
+  '6', '_', 'v', 's', 'h', 'u', 'f', 'f', 'b', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
+  '_', 'v', 's', 'h', 'u', 'f', 'f', 'b', '_', '1', '2', '8', 'B', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'V', '6', '_', 'v', 's', 'h', 'u', 'f', 'f', 'e', 'b', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'V', '6', '_', 'v', 's', 'h', 'u', 'f', 'f', 'e', 'b', '_', '1',
+  '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'h', 'u', 'f',
+  'f', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'h', 'u', 'f', 'f',
+  'h', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's',
+  'h', 'u', 'f', 'f', 'o', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's',
+  'h', 'u', 'f', 'f', 'o', 'b', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'V', '6', '_', 'v', 's', 'h', 'u', 'f', 'f', 'v', 'd', 'd', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'V', '6', '_', 'v', 's', 'h', 'u', 'f', 'f', 'v', 'd', 'd', '_', '1',
+  '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'h', 'u', 'f',
+  'o', 'e', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'h', 'u', 'f',
+  'o', 'e', 'b', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
+  'v', 's', 'h', 'u', 'f', 'o', 'e', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
+  'v', 's', 'h', 'u', 'f', 'o', 'e', 'h', '_', '1', '2', '8', 'B', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'V', '6', '_', 'v', 's', 'h', 'u', 'f', 'o', 'h', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'V', '6', '_', 'v', 's', 'h', 'u', 'f', 'o', 'h', '_', '1', '2', '8',
+  'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'u', 'b', 'b', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'V', '6', '_', 'v', 's', 'u', 'b', 'b', '_', '1', '2', '8', 'B',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'u', 'b', 'b', '_', 'd', 'v',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'u', 'b', 'b', '_', 'd', 'v',
+  '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'u',
+  'b', 'b', 's', 'a', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'u',
+  'b', 'b', 's', 'a', 't', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
+  '6', '_', 'v', 's', 'u', 'b', 'b', 's', 'a', 't', '_', 'd', 'v', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'V', '6', '_', 'v', 's', 'u', 'b', 'b', 's', 'a', 't', '_', 'd',
+  'v', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's',
+  'u', 'b', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'u', 'b', 'h',
+  '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'u',
+  'b', 'h', '_', 'd', 'v', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'u',
+  'b', 'h', '_', 'd', 'v', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
+  '6', '_', 'v', 's', 'u', 'b', 'h', 's', 'a', 't', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
+  '6', '_', 'v', 's', 'u', 'b', 'h', 's', 'a', 't', '_', '1', '2', '8', 'B',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'u', 'b', 'h', 's', 'a', 't',
+  '_', 'd', 'v', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'u', 'b', 'h',
+  's', 'a', 't', '_', 'd', 'v', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'V', '6', '_', 'v', 's', 'u', 'b', 'h', 'w', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
+  '_', 'v', 's', 'u', 'b', 'h', 'w', '_', '1', '2', '8', 'B', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'V', '6', '_', 'v', 's', 'u', 'b', 'u', 'b', 'h', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'V', '6', '_', 'v', 's', 'u', 'b', 'u', 'b', 'h', '_', '1', '2', '8', 'B',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'u', 'b', 'u', 'b', 's', 'a',
+  't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'u', 'b', 'u', 'b', 's',
+  'a', 't', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
+  's', 'u', 'b', 'u', 'b', 's', 'a', 't', '_', 'd', 'v', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'V', '6', '_', 'v', 's', 'u', 'b', 'u', 'b', 's', 'a', 't', '_', 'd', 'v',
+  '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'u',
+  'b', 'u', 'b', 'u', 'b', 'b', '_', 's', 'a', 't', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
+  '6', '_', 'v', 's', 'u', 'b', 'u', 'b', 'u', 'b', 'b', '_', 's', 'a', 't',
+  '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'u',
+  'b', 'u', 'h', 's', 'a', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's',
+  'u', 'b', 'u', 'h', 's', 'a', 't', '_', '1', '2', '8', 'B', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'V', '6', '_', 'v', 's', 'u', 'b', 'u', 'h', 's', 'a', 't', '_', 'd',
+  'v', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'u', 'b', 'u', 'h', 's',
+  'a', 't', '_', 'd', 'v', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
+  '6', '_', 'v', 's', 'u', 'b', 'u', 'h', 'w', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
+  '_', 'v', 's', 'u', 'b', 'u', 'h', 'w', '_', '1', '2', '8', 'B', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'V', '6', '_', 'v', 's', 'u', 'b', 'u', 'w', 's', 'a', 't', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'V', '6', '_', 'v', 's', 'u', 'b', 'u', 'w', 's', 'a', 't',
+  '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'u',
+  'b', 'u', 'w', 's', 'a', 't', '_', 'd', 'v', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
+  '_', 'v', 's', 'u', 'b', 'u', 'w', 's', 'a', 't', '_', 'd', 'v', '_', '1',
+  '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'u', 'b', 'w',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'u', 'b', 'w', '_', '1', '2',
+  '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'u', 'b', 'w', '_',
+  'd', 'v', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'u', 'b', 'w', '_',
+  'd', 'v', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
+  's', 'u', 'b', 'w', 's', 'a', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
+  's', 'u', 'b', 'w', 's', 'a', 't', '_', '1', '2', '8', 'B', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'V', '6', '_', 'v', 's', 'u', 'b', 'w', 's', 'a', 't', '_', 'd', 'v',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 's', 'u', 'b', 'w', 's', 'a', 't',
+  '_', 'd', 'v', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
+  'v', 't', 'm', 'p', 'y', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 't',
+  'm', 'p', 'y', 'b', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
+  '_', 'v', 't', 'm', 'p', 'y', 'b', '_', 'a', 'c', 'c', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_',
+  'V', '6', '_', 'v', 't', 'm', 'p', 'y', 'b', '_', 'a', 'c', 'c', '_', '1',
+  '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 't', 'm', 'p', 'y',
+  'b', 'u', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 't', 'm', 'p', 'y',
+  'b', 'u', 's', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
+  'v', 't', 'm', 'p', 'y', 'b', 'u', 's', '_', 'a', 'c', 'c', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'V', '6', '_', 'v', 't', 'm', 'p', 'y', 'b', 'u', 's', '_', 'a', 'c',
+  'c', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 't',
+  'm', 'p', 'y', 'h', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 't', 'm',
+  'p', 'y', 'h', 'b', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
+  '_', 'v', 't', 'm', 'p', 'y', 'h', 'b', '_', 'a', 'c', 'c', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N',
+  '_', 'V', '6', '_', 'v', 't', 'm', 'p', 'y', 'h', 'b', '_', 'a', 'c', 'c',
+  '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'u', 'n',
+  'p', 'a', 'c', 'k', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'u', 'n',
+  'p', 'a', 'c', 'k', 'b', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
+  '6', '_', 'v', 'u', 'n', 'p', 'a', 'c', 'k', 'h', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
+  '6', '_', 'v', 'u', 'n', 'p', 'a', 'c', 'k', 'h', '_', '1', '2', '8', 'B',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'u', 'n', 'p', 'a', 'c', 'k', 'o',
+  'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X',
+  'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'u', 'n', 'p', 'a', 'c', 'k',
+  'o', 'b', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
+  'u', 'n', 'p', 'a', 'c', 'k', 'o', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_',
+  'v', 'u', 'n', 'p', 'a', 'c', 'k', 'o', 'h', '_', '1', '2', '8', 'B', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'V', '6', '_', 'v', 'u', 'n', 'p', 'a', 'c', 'k', 'u', 'b',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'u', 'n', 'p', 'a', 'c', 'k', 'u',
+  'b', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'u',
+  'n', 'p', 'a', 'c', 'k', 'u', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v',
+  'u', 'n', 'p', 'a', 'c', 'k', 'u', 'h', '_', '1', '2', '8', 'B', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'V', '6', '_', 'v', 'x', 'o', 'r', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6',
+  '_', 'v', 'x', 'o', 'r', '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V',
+  '6', '_', 'v', 'z', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'z', 'b',
+  '_', '1', '2', '8', 'B', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'z', 'h',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'V', '6', '_', 'v', 'z', 'h', '_', '1', '2', '8', 'B',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'Y', '2', '_', 'd', 'c', 'c', 'l', 'e', 'a', 'n', 'a',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'Y', '2', '_', 'd', 'c', 'c', 'l', 'e', 'a', 'n', 'i',
+  'n', 'v', 'a', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H',
+  'E', 'X', 'A', 'G', 'O', 'N', '_', 'Y', '2', '_', 'd', 'c', 'f', 'e', 't',
+  'c', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E',
+  'X', 'A', 'G', 'O', 'N', '_', 'Y', '2', '_', 'd', 'c', 'i', 'n', 'v', 'a',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'Y', '2', '_', 'd', 'c', 'z', 'e', 'r', 'o', 'a', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G',
+  'O', 'N', '_', 'Y', '4', '_', 'l', '2', 'f', 'e', 't', 'c', 'h', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A', 'G', 'O',
+  'N', '_', 'Y', '5', '_', 'l', '2', 'f', 'e', 't', 'c', 'h', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'c', 'i', 'r', 'c', '_', 'l', 'd',
+  'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'c', 'i', 'r',
+  'c', '_', 'l', 'd', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'c', 'i', 'r', 'c', '_', 'l', 'd', 'h', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'c', 'i', 'r', 'c', '_', 'l', 'd', 'u', 'b', '\000',
   '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'c', 'i', 'r', 'c', '_',
-  'l', 'd', 'u', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'c', 'i', 'r', 'c', '_', 'l', 'd', 'u', 'h', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'c', 'i', 'r', 'c', '_', 'l', 'd', 'w', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'c', 'i', 'r', 'c', '_', 's',
-  't', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'c', 'i',
-  'r', 'c', '_', 's', 't', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'c', 'i', 'r', 'c', '_', 's', 't', 'h', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'c', 'i', 'r', 'c', '_', 's', 't', 'h', 'h',
-  'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'c', 'i', 'r',
-  'c', '_', 's', 't', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'H', 'E', 'X', 'A', 'G', 'O', 'N', '_', 'p', 'r', 'e', 'f', 'e', 't',
-  'c', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'h', 'e',
-  'x', 'a', 'g', 'o', 'n', '_', 'v', 'm', 'e', 'm', 'c', 'p', 'y', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'h', 'e', 'x', 'a', 'g', 'o',
-  'n', '_', 'v', 'm', 'e', 'm', 's', 'e', 't', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 'd', 'u', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'c', 'i', 'r', 'c', '_', 'l', 'd', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'c', 'i', 'r', 'c', '_', 's', 't', 'b', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'c', 'i', 'r', 'c', '_', 's', 't',
+  'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'c', 'i', 'r',
+  'c', '_', 's', 't', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'c', 'i', 'r', 'c', '_', 's', 't', 'h', 'h', 'i', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'c', 'i', 'r', 'c', '_', 's', 't', 'w',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'H', 'E', 'X', 'A',
+  'G', 'O', 'N', '_', 'p', 'r', 'e', 'f', 'e', 't', 'c', 'h', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'h', 'e', 'x', 'a', 'g', 'o', 'n',
+  '_', 'v', 'm', 'e', 'm', 'c', 'p', 'y', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'h', 'e', 'x', 'a', 'g', 'o', 'n', '_', 'v', 'm', 'e',
+  'm', 's', 'e', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'm', 'i', 'p', 's', '_', 'a', 'b', 's', 'q', '_', 's', '_', 'p', 'h', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_',
+  'a', 'b', 's', 'q', '_', 's', '_', 'q', 'b', '\000', '_', '_', 'b', 'u', 'i',
   'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'a', 'b', 's', 'q', '_',
-  's', '_', 'p', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'm', 'i', 'p', 's', '_', 'a', 'b', 's', 'q', '_', 's', '_', 'q', 'b', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_',
-  'a', 'b', 's', 'q', '_', 's', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'm', 's', 'a', '_', 'a', 'd', 'd', '_', 'a', '_', 'b',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_',
-  'a', 'd', 'd', '_', 'a', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'm', 's', 'a', '_', 'a', 'd', 'd', '_', 'a', '_', 'h', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'a',
-  'd', 'd', '_', 'a', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'm', 'i', 'p', 's', '_', 'a', 'd', 'd', 'q', '_', 'p', 'h', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_',
-  'a', 'd', 'd', 'q', '_', 's', '_', 'p', 'h', '\000', '_', '_', 'b', 'u', 'i',
+  's', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
+  's', 'a', '_', 'a', 'd', 'd', '_', 'a', '_', 'b', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'a', 'd', 'd', '_', 'a',
+  '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
+  'a', '_', 'a', 'd', 'd', '_', 'a', '_', 'h', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'a', 'd', 'd', '_', 'a', '_',
+  'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p',
+  's', '_', 'a', 'd', 'd', 'q', '_', 'p', 'h', '\000', '_', '_', 'b', 'u', 'i',
   'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'a', 'd', 'd', 'q', '_',
-  's', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
-  'i', 'p', 's', '_', 'a', 'd', 'd', 'q', 'h', '_', 'p', 'h', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'a', 'd',
-  'd', 'q', 'h', '_', 'r', '_', 'p', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'a', 'd', 'd', 'q', 'h', '_',
-  'r', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
-  'i', 'p', 's', '_', 'a', 'd', 'd', 'q', 'h', '_', 'w', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'a', 'd', 'd', 's',
-  '_', 'a', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'm', 's', 'a', '_', 'a', 'd', 'd', 's', '_', 'a', '_', 'd', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'a', 'd', 'd',
-  's', '_', 'a', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'm', 's', 'a', '_', 'a', 'd', 'd', 's', '_', 'a', '_', 'w', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'a', 'd',
-  'd', 's', '_', 's', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'm', 's', 'a', '_', 'a', 'd', 'd', 's', '_', 's', '_', 'd', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'a',
-  'd', 'd', 's', '_', 's', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'm', 's', 'a', '_', 'a', 'd', 'd', 's', '_', 's', '_', 'w',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_',
-  'a', 'd', 'd', 's', '_', 'u', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'm', 's', 'a', '_', 'a', 'd', 'd', 's', '_', 'u', '_',
-  'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
-  '_', 'a', 'd', 'd', 's', '_', 'u', '_', 'h', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'a', 'd', 'd', 's', '_', 'u',
-  '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i',
-  'p', 's', '_', 'a', 'd', 'd', 's', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'a', 'd', 'd', 'u', '_', 'p',
-  'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p',
-  's', '_', 'a', 'd', 'd', 'u', '_', 'q', 'b', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'a', 'd', 'd', 'u', '_',
   's', '_', 'p', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'm', 'i', 'p', 's', '_', 'a', 'd', 'd', 'u', '_', 's', '_', 'q', 'b', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_',
-  'a', 'd', 'd', 'u', 'h', '_', 'q', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'a', 'd', 'd', 'u', 'h', '_',
-  'r', '_', 'q', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'm', 's', 'a', '_', 'a', 'd', 'd', 'v', '_', 'b', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'a', 'd', 'd', 'v', '_',
-  'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
-  '_', 'a', 'd', 'd', 'v', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'm', 's', 'a', '_', 'a', 'd', 'd', 'v', '_', 'w', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'a', 'd',
-  'd', 'v', 'i', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'm', 's', 'a', '_', 'a', 'd', 'd', 'v', 'i', '_', 'd', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'a', 'd', 'd',
-  'v', 'i', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'm', 's', 'a', '_', 'a', 'd', 'd', 'v', 'i', '_', 'w', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'a', 'd', 'd',
-  'w', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
-  'a', '_', 'a', 'n', 'd', '_', 'v', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'm', 's', 'a', '_', 'a', 'n', 'd', 'i', '_', 'b', '\000', '_',
+  'm', 'i', 'p', 's', '_', 'a', 'd', 'd', 'q', '_', 's', '_', 'w', '\000', '_',
   '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'a',
-  'p', 'p', 'e', 'n', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'm', 's', 'a', '_', 'a', 's', 'u', 'b', '_', 's', '_', 'b', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'a', 's',
-  'u', 'b', '_', 's', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'm', 's', 'a', '_', 'a', 's', 'u', 'b', '_', 's', '_', 'h', '\000',
+  'd', 'd', 'q', 'h', '_', 'p', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'a', 'd', 'd', 'q', 'h', '_', 'r',
+  '_', 'p', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
+  'i', 'p', 's', '_', 'a', 'd', 'd', 'q', 'h', '_', 'r', '_', 'w', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'a',
+  'd', 'd', 'q', 'h', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'm', 's', 'a', '_', 'a', 'd', 'd', 's', '_', 'a', '_', 'b', '\000',
   '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'a',
-  's', 'u', 'b', '_', 's', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'm', 's', 'a', '_', 'a', 's', 'u', 'b', '_', 'u', '_', 'b',
+  'd', 'd', 's', '_', 'a', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'm', 's', 'a', '_', 'a', 'd', 'd', 's', '_', 'a', '_', 'h',
   '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_',
-  'a', 's', 'u', 'b', '_', 'u', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'm', 's', 'a', '_', 'a', 's', 'u', 'b', '_', 'u', '_',
-  'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
-  '_', 'a', 's', 'u', 'b', '_', 'u', '_', 'w', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'a', 'v', 'e', '_', 's', '_',
+  'a', 'd', 'd', 's', '_', 'a', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'm', 's', 'a', '_', 'a', 'd', 'd', 's', '_', 's', '_',
   'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
-  '_', 'a', 'v', 'e', '_', 's', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'm', 's', 'a', '_', 'a', 'v', 'e', '_', 's', '_', 'h',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_',
-  'a', 'v', 'e', '_', 's', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'm', 's', 'a', '_', 'a', 'v', 'e', '_', 'u', '_', 'b', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'a',
-  'v', 'e', '_', 'u', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'm', 's', 'a', '_', 'a', 'v', 'e', '_', 'u', '_', 'h', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'a', 'v',
-  'e', '_', 'u', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'm', 's', 'a', '_', 'a', 'v', 'e', 'r', '_', 's', '_', 'b', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'a', 'v',
-  'e', 'r', '_', 's', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'm', 's', 'a', '_', 'a', 'v', 'e', 'r', '_', 's', '_', 'h', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'a',
-  'v', 'e', 'r', '_', 's', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'm', 's', 'a', '_', 'a', 'v', 'e', 'r', '_', 'u', '_', 'b',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_',
-  'a', 'v', 'e', 'r', '_', 'u', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'm', 's', 'a', '_', 'a', 'v', 'e', 'r', '_', 'u', '_',
-  'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
-  '_', 'a', 'v', 'e', 'r', '_', 'u', '_', 'w', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'b', 'a', 'l', 'i', 'g',
-  'n', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
-  '_', 'b', 'c', 'l', 'r', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'm', 's', 'a', '_', 'b', 'c', 'l', 'r', '_', 'd', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'b', 'c',
-  'l', 'r', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'm', 's', 'a', '_', 'b', 'c', 'l', 'r', '_', 'w', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'b', 'c', 'l', 'r', 'i',
-  '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
-  'a', '_', 'b', 'c', 'l', 'r', 'i', '_', 'd', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'b', 'c', 'l', 'r', 'i', '_',
-  'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
-  '_', 'b', 'c', 'l', 'r', 'i', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'm', 's', 'a', '_', 'b', 'i', 'n', 's', 'l', '_', 'b',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_',
-  'b', 'i', 'n', 's', 'l', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'm', 's', 'a', '_', 'b', 'i', 'n', 's', 'l', '_', 'h', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'b',
-  'i', 'n', 's', 'l', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'm', 's', 'a', '_', 'b', 'i', 'n', 's', 'l', 'i', '_', 'b', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'b',
-  'i', 'n', 's', 'l', 'i', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'm', 's', 'a', '_', 'b', 'i', 'n', 's', 'l', 'i', '_', 'h',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_',
-  'b', 'i', 'n', 's', 'l', 'i', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'm', 's', 'a', '_', 'b', 'i', 'n', 's', 'r', '_', 'b',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_',
-  'b', 'i', 'n', 's', 'r', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'm', 's', 'a', '_', 'b', 'i', 'n', 's', 'r', '_', 'h', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'b',
-  'i', 'n', 's', 'r', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'm', 's', 'a', '_', 'b', 'i', 'n', 's', 'r', 'i', '_', 'b', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'b',
-  'i', 'n', 's', 'r', 'i', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'm', 's', 'a', '_', 'b', 'i', 'n', 's', 'r', 'i', '_', 'h',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_',
-  'b', 'i', 'n', 's', 'r', 'i', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'b', 'i', 't', 'r', 'e', 'v',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_',
-  'b', 'm', 'n', 'z', '_', 'v', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'm', 's', 'a', '_', 'b', 'm', 'n', 'z', 'i', '_', 'b', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'b', 'm',
-  'z', '_', 'v', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
-  's', 'a', '_', 'b', 'm', 'z', 'i', '_', 'b', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'b', 'n', 'e', 'g', '_', 'b',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_',
-  'b', 'n', 'e', 'g', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'm', 's', 'a', '_', 'b', 'n', 'e', 'g', '_', 'h', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'b', 'n', 'e',
-  'g', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
-  's', 'a', '_', 'b', 'n', 'e', 'g', 'i', '_', 'b', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'b', 'n', 'e', 'g', 'i',
-  '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
-  'a', '_', 'b', 'n', 'e', 'g', 'i', '_', 'h', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'b', 'n', 'e', 'g', 'i', '_',
-  'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
-  '_', 'b', 'n', 'z', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'm', 's', 'a', '_', 'b', 'n', 'z', '_', 'd', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'b', 'n', 'z', '_',
-  'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
-  '_', 'b', 'n', 'z', '_', 'v', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'm', 's', 'a', '_', 'b', 'n', 'z', '_', 'w', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'b', 'p', 'o',
-  's', 'g', 'e', '3', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'm', 's', 'a', '_', 'b', 's', 'e', 'l', '_', 'v', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'b', 's', 'e', 'l',
-  'i', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
-  's', 'a', '_', 'b', 's', 'e', 't', '_', 'b', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'b', 's', 'e', 't', '_', 'd',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_',
-  'b', 's', 'e', 't', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'm', 's', 'a', '_', 'b', 's', 'e', 't', '_', 'w', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'b', 's', 'e',
-  't', 'i', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'm', 's', 'a', '_', 'b', 's', 'e', 't', 'i', '_', 'd', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'b', 's', 'e', 't',
-  'i', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
-  's', 'a', '_', 'b', 's', 'e', 't', 'i', '_', 'w', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'b', 'z', '_', 'b', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'b',
-  'z', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
-  's', 'a', '_', 'b', 'z', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'm', 's', 'a', '_', 'b', 'z', '_', 'v', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'b', 'z', '_', 'w',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_',
-  'c', 'e', 'q', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'm', 's', 'a', '_', 'c', 'e', 'q', '_', 'd', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'c', 'e', 'q', '_', 'h',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_',
-  'c', 'e', 'q', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'm', 's', 'a', '_', 'c', 'e', 'q', 'i', '_', 'b', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'c', 'e', 'q', 'i',
-  '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
-  'a', '_', 'c', 'e', 'q', 'i', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'm', 's', 'a', '_', 'c', 'e', 'q', 'i', '_', 'w', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'c',
-  'f', 'c', 'm', 's', 'a', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'm', 's', 'a', '_', 'c', 'l', 'e', '_', 's', '_', 'b', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'c', 'l', 'e',
-  '_', 's', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'm', 's', 'a', '_', 'c', 'l', 'e', '_', 's', '_', 'h', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'c', 'l', 'e', '_',
-  's', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
-  's', 'a', '_', 'c', 'l', 'e', '_', 'u', '_', 'b', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'c', 'l', 'e', '_', 'u',
-  '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
-  'a', '_', 'c', 'l', 'e', '_', 'u', '_', 'h', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'c', 'l', 'e', '_', 'u', '_',
-  'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
-  '_', 'c', 'l', 'e', 'i', '_', 's', '_', 'b', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'c', 'l', 'e', 'i', '_', 's',
-  '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
-  'a', '_', 'c', 'l', 'e', 'i', '_', 's', '_', 'h', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'c', 'l', 'e', 'i', '_',
-  's', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
-  's', 'a', '_', 'c', 'l', 'e', 'i', '_', 'u', '_', 'b', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'c', 'l', 'e', 'i',
-  '_', 'u', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'm', 's', 'a', '_', 'c', 'l', 'e', 'i', '_', 'u', '_', 'h', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'c', 'l', 'e',
-  'i', '_', 'u', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'm', 's', 'a', '_', 'c', 'l', 't', '_', 's', '_', 'b', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'c', 'l', 't',
-  '_', 's', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'm', 's', 'a', '_', 'c', 'l', 't', '_', 's', '_', 'h', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'c', 'l', 't', '_',
-  's', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
-  's', 'a', '_', 'c', 'l', 't', '_', 'u', '_', 'b', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'c', 'l', 't', '_', 'u',
-  '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
-  'a', '_', 'c', 'l', 't', '_', 'u', '_', 'h', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'c', 'l', 't', '_', 'u', '_',
-  'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
-  '_', 'c', 'l', 't', 'i', '_', 's', '_', 'b', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'c', 'l', 't', 'i', '_', 's',
-  '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
-  'a', '_', 'c', 'l', 't', 'i', '_', 's', '_', 'h', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'c', 'l', 't', 'i', '_',
-  's', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
-  's', 'a', '_', 'c', 'l', 't', 'i', '_', 'u', '_', 'b', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'c', 'l', 't', 'i',
-  '_', 'u', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'm', 's', 'a', '_', 'c', 'l', 't', 'i', '_', 'u', '_', 'h', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'c', 'l', 't',
-  'i', '_', 'u', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'm', 'i', 'p', 's', '_', 'c', 'm', 'p', '_', 'e', 'q', '_', 'p', 'h',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's',
-  '_', 'c', 'm', 'p', '_', 'l', 'e', '_', 'p', 'h', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'c', 'm', 'p', '_',
-  'l', 't', '_', 'p', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'm', 'i', 'p', 's', '_', 'c', 'm', 'p', 'g', 'd', 'u', '_', 'e', 'q',
-  '_', 'q', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
-  'i', 'p', 's', '_', 'c', 'm', 'p', 'g', 'd', 'u', '_', 'l', 'e', '_', 'q',
-  'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p',
-  's', '_', 'c', 'm', 'p', 'g', 'd', 'u', '_', 'l', 't', '_', 'q', 'b', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_',
-  'c', 'm', 'p', 'g', 'u', '_', 'e', 'q', '_', 'q', 'b', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'c', 'm', 'p',
-  'g', 'u', '_', 'l', 'e', '_', 'q', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'c', 'm', 'p', 'g', 'u', '_',
-  'l', 't', '_', 'q', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'm', 'i', 'p', 's', '_', 'c', 'm', 'p', 'u', '_', 'e', 'q', '_', 'q',
-  'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p',
-  's', '_', 'c', 'm', 'p', 'u', '_', 'l', 'e', '_', 'q', 'b', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'c', 'm',
-  'p', 'u', '_', 'l', 't', '_', 'q', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'm', 's', 'a', '_', 'c', 'o', 'p', 'y', '_', 's', '_',
-  'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
-  '_', 'c', 'o', 'p', 'y', '_', 's', '_', 'd', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'c', 'o', 'p', 'y', '_', 's',
+  '_', 'a', 'd', 'd', 's', '_', 's', '_', 'd', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'a', 'd', 'd', 's', '_', 's',
   '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
-  'a', '_', 'c', 'o', 'p', 'y', '_', 's', '_', 'w', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'c', 'o', 'p', 'y', '_',
+  'a', '_', 'a', 'd', 'd', 's', '_', 's', '_', 'w', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'a', 'd', 'd', 's', '_',
   'u', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
-  's', 'a', '_', 'c', 'o', 'p', 'y', '_', 'u', '_', 'd', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'c', 'o', 'p', 'y',
+  's', 'a', '_', 'a', 'd', 'd', 's', '_', 'u', '_', 'd', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'a', 'd', 'd', 's',
   '_', 'u', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'm', 's', 'a', '_', 'c', 'o', 'p', 'y', '_', 'u', '_', 'w', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'c', 't', 'c',
-  'm', 's', 'a', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
-  's', 'a', '_', 'd', 'i', 'v', '_', 's', '_', 'b', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'd', 'i', 'v', '_', 's',
-  '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
-  'a', '_', 'd', 'i', 'v', '_', 's', '_', 'h', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'd', 'i', 'v', '_', 's', '_',
-  'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
-  '_', 'd', 'i', 'v', '_', 'u', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'm', 's', 'a', '_', 'd', 'i', 'v', '_', 'u', '_', 'd',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_',
-  'd', 'i', 'v', '_', 'u', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'm', 's', 'a', '_', 'd', 'i', 'v', '_', 'u', '_', 'w', '\000',
+  'm', 's', 'a', '_', 'a', 'd', 'd', 's', '_', 'u', '_', 'w', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'a', 'd',
+  'd', 's', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
+  'i', 'p', 's', '_', 'a', 'd', 'd', 'u', '_', 'p', 'h', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'a', 'd', 'd',
+  'u', '_', 'q', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'm', 'i', 'p', 's', '_', 'a', 'd', 'd', 'u', '_', 's', '_', 'p', 'h', '\000',
   '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_',
-  'd', 'l', 's', 'a', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'm', 's', 'a', '_', 'd', 'o', 't', 'p', '_', 's', '_', 'd', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'd', 'o', 't',
-  'p', '_', 's', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'm', 's', 'a', '_', 'd', 'o', 't', 'p', '_', 's', '_', 'w', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'd', 'o',
-  't', 'p', '_', 'u', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'm', 's', 'a', '_', 'd', 'o', 't', 'p', '_', 'u', '_', 'h', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'd',
-  'o', 't', 'p', '_', 'u', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'd', 'p', 'a', '_', 'w', '_', 'p',
-  'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
-  '_', 'd', 'p', 'a', 'd', 'd', '_', 's', '_', 'd', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'd', 'p', 'a', 'd', 'd',
-  '_', 's', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'm', 's', 'a', '_', 'd', 'p', 'a', 'd', 'd', '_', 's', '_', 'w', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'd', 'p',
-  'a', 'd', 'd', '_', 'u', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'm', 's', 'a', '_', 'd', 'p', 'a', 'd', 'd', '_', 'u', '_',
-  'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
-  '_', 'd', 'p', 'a', 'd', 'd', '_', 'u', '_', 'w', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'd', 'p', 'a', 'q',
-  '_', 's', '_', 'w', '_', 'p', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'd', 'p', 'a', 'q', '_', 's', 'a',
-  '_', 'l', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'm', 'i', 'p', 's', '_', 'd', 'p', 'a', 'q', 'x', '_', 's', '_', 'w', '_',
-  'p', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i',
-  'p', 's', '_', 'd', 'p', 'a', 'q', 'x', '_', 's', 'a', '_', 'w', '_', 'p',
-  'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p',
-  's', '_', 'd', 'p', 'a', 'u', '_', 'h', '_', 'q', 'b', 'l', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'd', 'p',
-  'a', 'u', '_', 'h', '_', 'q', 'b', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'd', 'p', 'a', 'x', '_', 'w',
-  '_', 'p', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
-  'i', 'p', 's', '_', 'd', 'p', 's', '_', 'w', '_', 'p', 'h', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'd', 'p',
-  's', 'q', '_', 's', '_', 'w', '_', 'p', 'h', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'd', 'p', 's', 'q', '_',
-  's', 'a', '_', 'l', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'm', 'i', 'p', 's', '_', 'd', 'p', 's', 'q', 'x', '_', 's', '_',
-  'w', '_', 'p', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'm', 'i', 'p', 's', '_', 'd', 'p', 's', 'q', 'x', '_', 's', 'a', '_', 'w',
-  '_', 'p', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
-  'i', 'p', 's', '_', 'd', 'p', 's', 'u', '_', 'h', '_', 'q', 'b', 'l', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_',
-  'd', 'p', 's', 'u', '_', 'h', '_', 'q', 'b', 'r', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'd', 'p', 's', 'u', 'b',
-  '_', 's', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'm', 's', 'a', '_', 'd', 'p', 's', 'u', 'b', '_', 's', '_', 'h', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'd', 'p',
-  's', 'u', 'b', '_', 's', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'm', 's', 'a', '_', 'd', 'p', 's', 'u', 'b', '_', 'u', '_',
-  'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
-  '_', 'd', 'p', 's', 'u', 'b', '_', 'u', '_', 'h', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'd', 'p', 's', 'u', 'b',
-  '_', 'u', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'm', 'i', 'p', 's', '_', 'd', 'p', 's', 'x', '_', 'w', '_', 'p', 'h', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_',
-  'e', 'x', 't', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'm', 'i', 'p', 's', '_', 'e', 'x', 't', 'p', 'd', 'p', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'e', 'x', 't',
-  'r', '_', 'r', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'm', 'i', 'p', 's', '_', 'e', 'x', 't', 'r', '_', 'r', 's', '_', 'w',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's',
-  '_', 'e', 'x', 't', 'r', '_', 's', '_', 'h', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'e', 'x', 't', 'r', '_',
-  'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
-  '_', 'f', 'a', 'd', 'd', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'm', 's', 'a', '_', 'f', 'a', 'd', 'd', '_', 'w', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 'c',
-  'a', 'f', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'm', 's', 'a', '_', 'f', 'c', 'a', 'f', '_', 'w', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 'c', 'e', 'q', '_',
-  'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
-  '_', 'f', 'c', 'e', 'q', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'm', 's', 'a', '_', 'f', 'c', 'l', 'a', 's', 's', '_', 'd',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_',
-  'f', 'c', 'l', 'a', 's', 's', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 'c', 'l', 'e', '_', 'd', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f',
-  'c', 'l', 'e', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'm', 's', 'a', '_', 'f', 'c', 'l', 't', '_', 'd', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 'c', 'l', 't',
-  '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
-  'a', '_', 'f', 'c', 'n', 'e', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 'c', 'n', 'e', '_', 'w', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f',
-  'c', 'o', 'r', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'm', 's', 'a', '_', 'f', 'c', 'o', 'r', '_', 'w', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 'c', 'u', 'e',
-  'q', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
-  's', 'a', '_', 'f', 'c', 'u', 'e', 'q', '_', 'w', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 'c', 'u', 'l', 'e',
-  '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
-  'a', '_', 'f', 'c', 'u', 'l', 'e', '_', 'w', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 'c', 'u', 'l', 't', '_',
-  'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
-  '_', 'f', 'c', 'u', 'l', 't', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 'c', 'u', 'n', '_', 'd', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f',
-  'c', 'u', 'n', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'm', 's', 'a', '_', 'f', 'c', 'u', 'n', 'e', '_', 'd', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 'c', 'u',
-  'n', 'e', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'm', 's', 'a', '_', 'f', 'd', 'i', 'v', '_', 'd', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 'd', 'i', 'v', '_',
-  'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
-  '_', 'f', 'e', 'x', 'd', 'o', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 'e', 'x', 'd', 'o', '_', 'w',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_',
-  'f', 'e', 'x', 'p', '2', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'm', 's', 'a', '_', 'f', 'e', 'x', 'p', '2', '_', 'w', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f',
-  'e', 'x', 'u', 'p', 'l', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'm', 's', 'a', '_', 'f', 'e', 'x', 'u', 'p', 'l', '_', 'w',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_',
-  'f', 'e', 'x', 'u', 'p', 'r', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 'e', 'x', 'u', 'p', 'r', '_',
-  'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
-  '_', 'f', 'f', 'i', 'n', 't', '_', 's', '_', 'd', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 'f', 'i', 'n', 't',
-  '_', 's', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'm', 's', 'a', '_', 'f', 'f', 'i', 'n', 't', '_', 'u', '_', 'd', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 'f',
-  'i', 'n', 't', '_', 'u', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'm', 's', 'a', '_', 'f', 'f', 'q', 'l', '_', 'd', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 'f',
-  'q', 'l', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'm', 's', 'a', '_', 'f', 'f', 'q', 'r', '_', 'd', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 'f', 'q', 'r', '_',
-  'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
-  '_', 'f', 'i', 'l', 'l', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'm', 's', 'a', '_', 'f', 'i', 'l', 'l', '_', 'd', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 'i',
-  'l', 'l', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'm', 's', 'a', '_', 'f', 'i', 'l', 'l', '_', 'w', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 'l', 'o', 'g', '2',
-  '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
-  'a', '_', 'f', 'l', 'o', 'g', '2', '_', 'w', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 'm', 'a', 'd', 'd', '_',
-  'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
-  '_', 'f', 'm', 'a', 'd', 'd', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 'm', 'a', 'x', '_', 'a', '_',
-  'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
-  '_', 'f', 'm', 'a', 'x', '_', 'a', '_', 'w', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 'm', 'a', 'x', '_', 'd',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_',
-  'f', 'm', 'a', 'x', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'm', 's', 'a', '_', 'f', 'm', 'i', 'n', '_', 'a', '_', 'd', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f',
-  'm', 'i', 'n', '_', 'a', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'm', 's', 'a', '_', 'f', 'm', 'i', 'n', '_', 'd', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 'm',
-  'i', 'n', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'm', 's', 'a', '_', 'f', 'm', 's', 'u', 'b', '_', 'd', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 'm', 's', 'u',
-  'b', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
-  's', 'a', '_', 'f', 'm', 'u', 'l', '_', 'd', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 'm', 'u', 'l', '_', 'w',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_',
-  'f', 'r', 'c', 'p', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'm', 's', 'a', '_', 'f', 'r', 'c', 'p', '_', 'w', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 'r', 'i',
-  'n', 't', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'm', 's', 'a', '_', 'f', 'r', 'i', 'n', 't', '_', 'w', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 'r', 's', 'q',
-  'r', 't', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'm', 's', 'a', '_', 'f', 'r', 's', 'q', 'r', 't', '_', 'w', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 's', 'a',
-  'f', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
-  's', 'a', '_', 'f', 's', 'a', 'f', '_', 'w', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 's', 'e', 'q', '_', 'd',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_',
-  'f', 's', 'e', 'q', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'm', 's', 'a', '_', 'f', 's', 'l', 'e', '_', 'd', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 's', 'l',
-  'e', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
-  's', 'a', '_', 'f', 's', 'l', 't', '_', 'd', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 's', 'l', 't', '_', 'w',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_',
-  'f', 's', 'n', 'e', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'm', 's', 'a', '_', 'f', 's', 'n', 'e', '_', 'w', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 's', 'o',
-  'r', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
-  's', 'a', '_', 'f', 's', 'o', 'r', '_', 'w', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 's', 'q', 'r', 't', '_',
-  'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
-  '_', 'f', 's', 'q', 'r', 't', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 's', 'u', 'b', '_', 'd', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f',
-  's', 'u', 'b', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'm', 's', 'a', '_', 'f', 's', 'u', 'e', 'q', '_', 'd', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 's', 'u',
-  'e', 'q', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'm', 's', 'a', '_', 'f', 's', 'u', 'l', 'e', '_', 'd', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 's', 'u', 'l',
-  'e', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
-  's', 'a', '_', 'f', 's', 'u', 'l', 't', '_', 'd', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 's', 'u', 'l', 't',
-  '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
-  'a', '_', 'f', 's', 'u', 'n', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 's', 'u', 'n', '_', 'w', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f',
-  's', 'u', 'n', 'e', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'm', 's', 'a', '_', 'f', 's', 'u', 'n', 'e', '_', 'w', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 't',
-  'i', 'n', 't', '_', 's', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'm', 's', 'a', '_', 'f', 't', 'i', 'n', 't', '_', 's', '_',
-  'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
-  '_', 'f', 't', 'i', 'n', 't', '_', 'u', '_', 'd', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 't', 'i', 'n', 't',
-  '_', 'u', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'm', 's', 'a', '_', 'f', 't', 'q', '_', 'h', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 't', 'q', '_', 'w', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f',
-  't', 'r', 'u', 'n', 'c', '_', 's', '_', 'd', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 't', 'r', 'u', 'n', 'c',
-  '_', 's', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'm', 's', 'a', '_', 'f', 't', 'r', 'u', 'n', 'c', '_', 'u', '_', 'd', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f',
-  't', 'r', 'u', 'n', 'c', '_', 'u', '_', 'w', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'h', 'a', 'd', 'd', '_', 's',
-  '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
-  'a', '_', 'h', 'a', 'd', 'd', '_', 's', '_', 'h', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'h', 'a', 'd', 'd', '_',
-  's', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
-  's', 'a', '_', 'h', 'a', 'd', 'd', '_', 'u', '_', 'd', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'h', 'a', 'd', 'd',
-  '_', 'u', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'm', 's', 'a', '_', 'h', 'a', 'd', 'd', '_', 'u', '_', 'w', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'h', 's', 'u',
-  'b', '_', 's', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'm', 's', 'a', '_', 'h', 's', 'u', 'b', '_', 's', '_', 'h', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'h', 's',
-  'u', 'b', '_', 's', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'm', 's', 'a', '_', 'h', 's', 'u', 'b', '_', 'u', '_', 'd', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'h',
-  's', 'u', 'b', '_', 'u', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'm', 's', 'a', '_', 'h', 's', 'u', 'b', '_', 'u', '_', 'w',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_',
-  'i', 'l', 'v', 'e', 'v', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'm', 's', 'a', '_', 'i', 'l', 'v', 'e', 'v', '_', 'd', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'i',
-  'l', 'v', 'e', 'v', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'm', 's', 'a', '_', 'i', 'l', 'v', 'e', 'v', '_', 'w', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'i', 'l',
-  'v', 'l', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'm', 's', 'a', '_', 'i', 'l', 'v', 'l', '_', 'd', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'i', 'l', 'v', 'l', '_',
-  'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
-  '_', 'i', 'l', 'v', 'l', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'm', 's', 'a', '_', 'i', 'l', 'v', 'o', 'd', '_', 'b', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'i',
-  'l', 'v', 'o', 'd', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'm', 's', 'a', '_', 'i', 'l', 'v', 'o', 'd', '_', 'h', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'i', 'l',
-  'v', 'o', 'd', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'm', 's', 'a', '_', 'i', 'l', 'v', 'r', '_', 'b', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'i', 'l', 'v', 'r',
-  '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
-  'a', '_', 'i', 'l', 'v', 'r', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'm', 's', 'a', '_', 'i', 'l', 'v', 'r', '_', 'w', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'i',
-  'n', 's', 'e', 'r', 't', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'm', 's', 'a', '_', 'i', 'n', 's', 'e', 'r', 't', '_', 'd',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_',
-  'i', 'n', 's', 'e', 'r', 't', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'm', 's', 'a', '_', 'i', 'n', 's', 'e', 'r', 't', '_',
-  'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p',
-  's', '_', 'i', 'n', 's', 'v', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'm', 's', 'a', '_', 'i', 'n', 's', 'v', 'e', '_', 'b', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'i', 'n',
-  's', 'v', 'e', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'm', 's', 'a', '_', 'i', 'n', 's', 'v', 'e', '_', 'h', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'i', 'n', 's',
-  'v', 'e', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'm', 'i', 'p', 's', '_', 'l', 'b', 'u', 'x', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'l', 'd', '_', 'b', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'l', 'd',
-  '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
-  'a', '_', 'l', 'd', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'm', 's', 'a', '_', 'l', 'd', '_', 'w', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'l', 'd', 'i', '_', 'b',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_',
-  'l', 'd', 'i', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'm', 's', 'a', '_', 'l', 'd', 'i', '_', 'h', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'l', 'd', 'i', '_', 'w',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's',
-  '_', 'l', 'h', 'x', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'm', 'i', 'p', 's', '_', 'l', 's', 'a', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'l', 'w', 'x', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'm', 'a',
-  'd', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
-  'a', '_', 'm', 'a', 'd', 'd', '_', 'q', '_', 'h', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'm', 'a', 'd', 'd', '_',
-  'q', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
-  's', 'a', '_', 'm', 'a', 'd', 'd', 'r', '_', 'q', '_', 'h', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'm', 'a', 'd',
-  'd', 'r', '_', 'q', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'm', 'i', 'p', 's', '_', 'm', 'a', 'd', 'd', 'u', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'm', 'a', 'd',
-  'd', 'v', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'm', 's', 'a', '_', 'm', 'a', 'd', 'd', 'v', '_', 'd', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'm', 'a', 'd', 'd',
-  'v', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
-  's', 'a', '_', 'm', 'a', 'd', 'd', 'v', '_', 'w', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'm', 'a', 'q', '_',
-  's', '_', 'w', '_', 'p', 'h', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'm', 'a', 'q', '_', 's', '_', 'w',
-  '_', 'p', 'h', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'm', 'i', 'p', 's', '_', 'm', 'a', 'q', '_', 's', 'a', '_', 'w', '_', 'p',
-  'h', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i',
-  'p', 's', '_', 'm', 'a', 'q', '_', 's', 'a', '_', 'w', '_', 'p', 'h', 'r',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_',
-  'm', 'a', 'x', '_', 'a', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'm', 's', 'a', '_', 'm', 'a', 'x', '_', 'a', '_', 'd', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'm',
-  'a', 'x', '_', 'a', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'm', 's', 'a', '_', 'm', 'a', 'x', '_', 'a', '_', 'w', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'm', 'a',
-  'x', '_', 's', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'm', 's', 'a', '_', 'm', 'a', 'x', '_', 's', '_', 'd', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'm', 'a', 'x',
-  '_', 's', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'm', 's', 'a', '_', 'm', 'a', 'x', '_', 's', '_', 'w', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'm', 'a', 'x', '_',
-  'u', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
-  's', 'a', '_', 'm', 'a', 'x', '_', 'u', '_', 'd', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'm', 'a', 'x', '_', 'u',
-  '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
-  'a', '_', 'm', 'a', 'x', '_', 'u', '_', 'w', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'm', 'a', 'x', 'i', '_', 's',
-  '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
-  'a', '_', 'm', 'a', 'x', 'i', '_', 's', '_', 'd', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'm', 'a', 'x', 'i', '_',
-  's', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
-  's', 'a', '_', 'm', 'a', 'x', 'i', '_', 's', '_', 'w', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'm', 'a', 'x', 'i',
-  '_', 'u', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'm', 's', 'a', '_', 'm', 'a', 'x', 'i', '_', 'u', '_', 'd', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'm', 'a', 'x',
-  'i', '_', 'u', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'm', 's', 'a', '_', 'm', 'a', 'x', 'i', '_', 'u', '_', 'w', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'm', 'i',
-  'n', '_', 'a', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'm', 's', 'a', '_', 'm', 'i', 'n', '_', 'a', '_', 'd', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'm', 'i', 'n',
-  '_', 'a', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'm', 's', 'a', '_', 'm', 'i', 'n', '_', 'a', '_', 'w', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'm', 'i', 'n', '_',
-  's', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
-  's', 'a', '_', 'm', 'i', 'n', '_', 's', '_', 'd', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'm', 'i', 'n', '_', 's',
-  '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
-  'a', '_', 'm', 'i', 'n', '_', 's', '_', 'w', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'm', 'i', 'n', '_', 'u', '_',
-  'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
-  '_', 'm', 'i', 'n', '_', 'u', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'm', 's', 'a', '_', 'm', 'i', 'n', '_', 'u', '_', 'h',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_',
-  'm', 'i', 'n', '_', 'u', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'm', 's', 'a', '_', 'm', 'i', 'n', 'i', '_', 's', '_', 'b',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_',
-  'm', 'i', 'n', 'i', '_', 's', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'm', 's', 'a', '_', 'm', 'i', 'n', 'i', '_', 's', '_',
-  'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
-  '_', 'm', 'i', 'n', 'i', '_', 's', '_', 'w', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'm', 'i', 'n', 'i', '_', 'u',
-  '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
-  'a', '_', 'm', 'i', 'n', 'i', '_', 'u', '_', 'd', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'm', 'i', 'n', 'i', '_',
-  'u', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
-  's', 'a', '_', 'm', 'i', 'n', 'i', '_', 'u', '_', 'w', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'm', 'o', 'd', '_',
-  's', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
-  's', 'a', '_', 'm', 'o', 'd', '_', 's', '_', 'd', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'm', 'o', 'd', '_', 's',
-  '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
-  'a', '_', 'm', 'o', 'd', '_', 's', '_', 'w', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'm', 'o', 'd', '_', 'u', '_',
-  'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
-  '_', 'm', 'o', 'd', '_', 'u', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'm', 's', 'a', '_', 'm', 'o', 'd', '_', 'u', '_', 'h',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_',
-  'm', 'o', 'd', '_', 'u', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'm', 'o', 'd', 's', 'u', 'b', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'm',
-  'o', 'v', 'e', '_', 'v', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'm', 'i', 'p', 's', '_', 'm', 's', 'u', 'b', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'm', 's', 'u', 'b', '_',
-  'q', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
-  's', 'a', '_', 'm', 's', 'u', 'b', '_', 'q', '_', 'w', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'm', 's', 'u', 'b',
-  'r', '_', 'q', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'm', 's', 'a', '_', 'm', 's', 'u', 'b', 'r', '_', 'q', '_', 'w', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_',
-  'm', 's', 'u', 'b', 'u', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'm', 's', 'a', '_', 'm', 's', 'u', 'b', 'v', '_', 'b', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'm', 's', 'u',
-  'b', 'v', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'm', 's', 'a', '_', 'm', 's', 'u', 'b', 'v', '_', 'h', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'm', 's', 'u', 'b',
-  'v', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
-  'i', 'p', 's', '_', 'm', 't', 'h', 'l', 'i', 'p', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'm', 'u', 'l', '_',
-  'p', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
-  'a', '_', 'm', 'u', 'l', '_', 'q', '_', 'h', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'm', 'u', 'l', '_', 'q', '_',
-  'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p',
-  's', '_', 'm', 'u', 'l', '_', 's', '_', 'p', 'h', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'm', 'u', 'l', 'e',
-  'q', '_', 's', '_', 'w', '_', 'p', 'h', 'l', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'm', 'u', 'l', 'e', 'q',
-  '_', 's', '_', 'w', '_', 'p', 'h', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'm', 'u', 'l', 'e', 'u', '_',
-  's', '_', 'p', 'h', '_', 'q', 'b', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'm', 'u', 'l', 'e', 'u', '_',
-  's', '_', 'p', 'h', '_', 'q', 'b', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'm', 'u', 'l', 'q', '_', 'r',
-  's', '_', 'p', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'm', 'i', 'p', 's', '_', 'm', 'u', 'l', 'q', '_', 'r', 's', '_', 'w', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_',
-  'm', 'u', 'l', 'q', '_', 's', '_', 'p', 'h', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'm', 'u', 'l', 'q', '_',
-  's', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
-  's', 'a', '_', 'm', 'u', 'l', 'r', '_', 'q', '_', 'h', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'm', 'u', 'l', 'r',
-  '_', 'q', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'm', 'i', 'p', 's', '_', 'm', 'u', 'l', 's', 'a', '_', 'w', '_', 'p', 'h',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's',
-  '_', 'm', 'u', 'l', 's', 'a', 'q', '_', 's', '_', 'w', '_', 'p', 'h', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_',
-  'm', 'u', 'l', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'm', 'i', 'p', 's', '_', 'm', 'u', 'l', 't', 'u', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'm', 'u', 'l', 'v', '_',
-  'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
-  '_', 'm', 'u', 'l', 'v', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'm', 's', 'a', '_', 'm', 'u', 'l', 'v', '_', 'h', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'm', 'u',
-  'l', 'v', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'm', 's', 'a', '_', 'n', 'l', 'o', 'c', '_', 'b', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'n', 'l', 'o', 'c', '_',
-  'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
-  '_', 'n', 'l', 'o', 'c', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'm', 's', 'a', '_', 'n', 'l', 'o', 'c', '_', 'w', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'n', 'l',
-  'z', 'c', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'm', 's', 'a', '_', 'n', 'l', 'z', 'c', '_', 'd', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'n', 'l', 'z', 'c', '_',
-  'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
-  '_', 'n', 'l', 'z', 'c', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'm', 's', 'a', '_', 'n', 'o', 'r', '_', 'v', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'n', 'o', 'r',
-  'i', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
-  's', 'a', '_', 'o', 'r', '_', 'v', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'm', 's', 'a', '_', 'o', 'r', 'i', '_', 'b', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'p', 'a',
-  'c', 'k', 'r', 'l', '_', 'p', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'm', 's', 'a', '_', 'p', 'c', 'k', 'e', 'v', '_', 'b', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'p',
-  'c', 'k', 'e', 'v', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'm', 's', 'a', '_', 'p', 'c', 'k', 'e', 'v', '_', 'h', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'p', 'c',
-  'k', 'e', 'v', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'm', 's', 'a', '_', 'p', 'c', 'k', 'o', 'd', '_', 'b', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'p', 'c', 'k',
-  'o', 'd', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'm', 's', 'a', '_', 'p', 'c', 'k', 'o', 'd', '_', 'h', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'p', 'c', 'k', 'o',
-  'd', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
-  's', 'a', '_', 'p', 'c', 'n', 't', '_', 'b', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'p', 'c', 'n', 't', '_', 'd',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_',
-  'p', 'c', 'n', 't', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'm', 's', 'a', '_', 'p', 'c', 'n', 't', '_', 'w', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'p', 'i',
-  'c', 'k', '_', 'p', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'm', 'i', 'p', 's', '_', 'p', 'i', 'c', 'k', '_', 'q', 'b', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'p',
-  'r', 'e', 'c', 'e', 'q', '_', 'w', '_', 'p', 'h', 'l', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'p', 'r', 'e',
-  'c', 'e', 'q', '_', 'w', '_', 'p', 'h', 'r', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'p', 'r', 'e', 'c', 'e',
-  'q', 'u', '_', 'p', 'h', '_', 'q', 'b', 'l', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'p', 'r', 'e', 'c', 'e',
-  'q', 'u', '_', 'p', 'h', '_', 'q', 'b', 'l', 'a', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'p', 'r', 'e', 'c',
-  'e', 'q', 'u', '_', 'p', 'h', '_', 'q', 'b', 'r', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'p', 'r', 'e', 'c',
-  'e', 'q', 'u', '_', 'p', 'h', '_', 'q', 'b', 'r', 'a', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'p', 'r', 'e',
-  'c', 'e', 'u', '_', 'p', 'h', '_', 'q', 'b', 'l', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'p', 'r', 'e', 'c',
-  'e', 'u', '_', 'p', 'h', '_', 'q', 'b', 'l', 'a', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'p', 'r', 'e', 'c',
-  'e', 'u', '_', 'p', 'h', '_', 'q', 'b', 'r', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'p', 'r', 'e', 'c', 'e',
-  'u', '_', 'p', 'h', '_', 'q', 'b', 'r', 'a', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'p', 'r', 'e', 'c', 'r',
-  '_', 'q', 'b', '_', 'p', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'm', 'i', 'p', 's', '_', 'p', 'r', 'e', 'c', 'r', '_', 's', 'r',
-  'a', '_', 'p', 'h', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'm', 'i', 'p', 's', '_', 'p', 'r', 'e', 'c', 'r', '_', 's', 'r',
-  'a', '_', 'r', '_', 'p', 'h', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'p', 'r', 'e', 'c', 'r', 'q',
-  '_', 'p', 'h', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'm', 'i', 'p', 's', '_', 'p', 'r', 'e', 'c', 'r', 'q', '_', 'q', 'b',
-  '_', 'p', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
-  'i', 'p', 's', '_', 'p', 'r', 'e', 'c', 'r', 'q', '_', 'r', 's', '_', 'p',
-  'h', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
-  'i', 'p', 's', '_', 'p', 'r', 'e', 'c', 'r', 'q', 'u', '_', 's', '_', 'q',
-  'b', '_', 'p', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'm', 'i', 'p', 's', '_', 'p', 'r', 'e', 'p', 'e', 'n', 'd', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'r', 'a',
-  'd', 'd', 'u', '_', 'w', '_', 'q', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'r', 'd', 'd', 's', 'p', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_',
-  'r', 'e', 'p', 'l', '_', 'p', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'r', 'e', 'p', 'l', '_', 'q', 'b',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_',
-  's', 'a', 't', '_', 's', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'm', 's', 'a', '_', 's', 'a', 't', '_', 's', '_', 'd', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 's',
-  'a', 't', '_', 's', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'm', 's', 'a', '_', 's', 'a', 't', '_', 's', '_', 'w', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 's', 'a',
-  't', '_', 'u', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'm', 's', 'a', '_', 's', 'a', 't', '_', 'u', '_', 'd', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 's', 'a', 't',
-  '_', 'u', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'm', 's', 'a', '_', 's', 'a', 't', '_', 'u', '_', 'w', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 's', 'h', 'f', '_',
-  'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
-  '_', 's', 'h', 'f', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'm', 's', 'a', '_', 's', 'h', 'f', '_', 'w', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 's', 'h', 'i',
-  'l', 'o', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i',
-  'p', 's', '_', 's', 'h', 'l', 'l', '_', 'p', 'h', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 's', 'h', 'l', 'l',
+  'a', 'd', 'd', 'u', '_', 's', '_', 'q', 'b', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'a', 'd', 'd', 'u', 'h',
   '_', 'q', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
-  'i', 'p', 's', '_', 's', 'h', 'l', 'l', '_', 's', '_', 'p', 'h', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 's',
-  'h', 'l', 'l', '_', 's', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'm', 'i', 'p', 's', '_', 's', 'h', 'r', 'a', '_', 'p', 'h',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's',
-  '_', 's', 'h', 'r', 'a', '_', 'q', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 's', 'h', 'r', 'a', '_', 'r',
-  '_', 'p', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
-  'i', 'p', 's', '_', 's', 'h', 'r', 'a', '_', 'r', '_', 'q', 'b', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 's',
-  'h', 'r', 'a', '_', 'r', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'm', 'i', 'p', 's', '_', 's', 'h', 'r', 'l', '_', 'p', 'h',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's',
-  '_', 's', 'h', 'r', 'l', '_', 'q', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'm', 's', 'a', '_', 's', 'l', 'd', '_', 'b', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 's', 'l',
-  'd', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
-  's', 'a', '_', 's', 'l', 'd', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'm', 's', 'a', '_', 's', 'l', 'd', '_', 'w', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 's', 'l',
-  'd', 'i', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'm', 's', 'a', '_', 's', 'l', 'd', 'i', '_', 'd', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 's', 'l', 'd', 'i', '_',
-  'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
-  '_', 's', 'l', 'd', 'i', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'm', 's', 'a', '_', 's', 'l', 'l', '_', 'b', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 's', 'l', 'l',
-  '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
-  'a', '_', 's', 'l', 'l', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'm', 's', 'a', '_', 's', 'l', 'l', '_', 'w', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 's', 'l', 'l',
-  'i', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
-  's', 'a', '_', 's', 'l', 'l', 'i', '_', 'd', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 's', 'l', 'l', 'i', '_', 'h',
+  'i', 'p', 's', '_', 'a', 'd', 'd', 'u', 'h', '_', 'r', '_', 'q', 'b', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'a',
+  'd', 'd', 'v', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'm', 's', 'a', '_', 'a', 'd', 'd', 'v', '_', 'd', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'a', 'd', 'd', 'v',
+  '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
+  'a', '_', 'a', 'd', 'd', 'v', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'm', 's', 'a', '_', 'a', 'd', 'd', 'v', 'i', '_', 'b',
   '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_',
-  's', 'l', 'l', 'i', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'm', 's', 'a', '_', 's', 'p', 'l', 'a', 't', '_', 'b', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 's', 'p',
-  'l', 'a', 't', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'm', 's', 'a', '_', 's', 'p', 'l', 'a', 't', '_', 'h', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 's', 'p', 'l',
-  'a', 't', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'm', 's', 'a', '_', 's', 'p', 'l', 'a', 't', 'i', '_', 'b', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 's', 'p', 'l',
-  'a', 't', 'i', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'm', 's', 'a', '_', 's', 'p', 'l', 'a', 't', 'i', '_', 'h', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 's', 'p',
-  'l', 'a', 't', 'i', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'm', 's', 'a', '_', 's', 'r', 'a', '_', 'b', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 's', 'r', 'a', '_',
+  'a', 'd', 'd', 'v', 'i', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'm', 's', 'a', '_', 'a', 'd', 'd', 'v', 'i', '_', 'h', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'a',
+  'd', 'd', 'v', 'i', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'm', 'i', 'p', 's', '_', 'a', 'd', 'd', 'w', 'c', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'a', 'n', 'd',
+  '_', 'v', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
+  'a', '_', 'a', 'n', 'd', 'i', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'a', 'p', 'p', 'e', 'n', 'd',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_',
+  'a', 's', 'u', 'b', '_', 's', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'm', 's', 'a', '_', 'a', 's', 'u', 'b', '_', 's', '_',
   'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
-  '_', 's', 'r', 'a', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'm', 's', 'a', '_', 's', 'r', 'a', '_', 'w', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 's', 'r', 'a', 'i',
-  '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
-  'a', '_', 's', 'r', 'a', 'i', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'm', 's', 'a', '_', 's', 'r', 'a', 'i', '_', 'h', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 's',
-  'r', 'a', 'i', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'm', 's', 'a', '_', 's', 'r', 'a', 'r', '_', 'b', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 's', 'r', 'a', 'r',
-  '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
-  'a', '_', 's', 'r', 'a', 'r', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'm', 's', 'a', '_', 's', 'r', 'a', 'r', '_', 'w', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 's',
-  'r', 'a', 'r', 'i', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'm', 's', 'a', '_', 's', 'r', 'a', 'r', 'i', '_', 'd', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 's', 'r',
-  'a', 'r', 'i', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'm', 's', 'a', '_', 's', 'r', 'a', 'r', 'i', '_', 'w', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 's', 'r', 'l',
-  '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
-  'a', '_', 's', 'r', 'l', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'm', 's', 'a', '_', 's', 'r', 'l', '_', 'h', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 's', 'r', 'l',
+  '_', 'a', 's', 'u', 'b', '_', 's', '_', 'h', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'a', 's', 'u', 'b', '_', 's',
   '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
-  'a', '_', 's', 'r', 'l', 'i', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'm', 's', 'a', '_', 's', 'r', 'l', 'i', '_', 'd', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 's',
-  'r', 'l', 'i', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'm', 's', 'a', '_', 's', 'r', 'l', 'i', '_', 'w', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 's', 'r', 'l', 'r',
+  'a', '_', 'a', 's', 'u', 'b', '_', 'u', '_', 'b', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'a', 's', 'u', 'b', '_',
+  'u', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
+  's', 'a', '_', 'a', 's', 'u', 'b', '_', 'u', '_', 'h', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'a', 's', 'u', 'b',
+  '_', 'u', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'm', 's', 'a', '_', 'a', 'v', 'e', '_', 's', '_', 'b', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'a', 'v', 'e', '_',
+  's', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
+  's', 'a', '_', 'a', 'v', 'e', '_', 's', '_', 'h', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'a', 'v', 'e', '_', 's',
+  '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
+  'a', '_', 'a', 'v', 'e', '_', 'u', '_', 'b', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'a', 'v', 'e', '_', 'u', '_',
+  'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
+  '_', 'a', 'v', 'e', '_', 'u', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'm', 's', 'a', '_', 'a', 'v', 'e', '_', 'u', '_', 'w',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_',
+  'a', 'v', 'e', 'r', '_', 's', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'm', 's', 'a', '_', 'a', 'v', 'e', 'r', '_', 's', '_',
+  'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
+  '_', 'a', 'v', 'e', 'r', '_', 's', '_', 'h', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'a', 'v', 'e', 'r', '_', 's',
+  '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
+  'a', '_', 'a', 'v', 'e', 'r', '_', 'u', '_', 'b', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'a', 'v', 'e', 'r', '_',
+  'u', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
+  's', 'a', '_', 'a', 'v', 'e', 'r', '_', 'u', '_', 'h', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'a', 'v', 'e', 'r',
+  '_', 'u', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'm', 'i', 'p', 's', '_', 'b', 'a', 'l', 'i', 'g', 'n', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'b', 'c', 'l', 'r',
   '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
-  'a', '_', 's', 'r', 'l', 'r', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'm', 's', 'a', '_', 's', 'r', 'l', 'r', '_', 'h', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 's',
-  'r', 'l', 'r', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'm', 's', 'a', '_', 's', 'r', 'l', 'r', 'i', '_', 'b', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 's', 'r', 'l',
+  'a', '_', 'b', 'c', 'l', 'r', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'm', 's', 'a', '_', 'b', 'c', 'l', 'r', '_', 'h', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'b',
+  'c', 'l', 'r', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'm', 's', 'a', '_', 'b', 'c', 'l', 'r', 'i', '_', 'b', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'b', 'c', 'l',
   'r', 'i', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'm', 's', 'a', '_', 's', 'r', 'l', 'r', 'i', '_', 'h', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 's', 'r', 'l', 'r',
+  'm', 's', 'a', '_', 'b', 'c', 'l', 'r', 'i', '_', 'h', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'b', 'c', 'l', 'r',
   'i', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
-  's', 'a', '_', 's', 't', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'm', 's', 'a', '_', 's', 't', '_', 'd', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 's', 't', '_', 'h',
+  's', 'a', '_', 'b', 'i', 'n', 's', 'l', '_', 'b', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'b', 'i', 'n', 's', 'l',
+  '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
+  'a', '_', 'b', 'i', 'n', 's', 'l', '_', 'h', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'b', 'i', 'n', 's', 'l', '_',
+  'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
+  '_', 'b', 'i', 'n', 's', 'l', 'i', '_', 'b', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'b', 'i', 'n', 's', 'l', 'i',
+  '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
+  'a', '_', 'b', 'i', 'n', 's', 'l', 'i', '_', 'h', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'b', 'i', 'n', 's', 'l',
+  'i', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
+  's', 'a', '_', 'b', 'i', 'n', 's', 'r', '_', 'b', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'b', 'i', 'n', 's', 'r',
+  '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
+  'a', '_', 'b', 'i', 'n', 's', 'r', '_', 'h', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'b', 'i', 'n', 's', 'r', '_',
+  'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
+  '_', 'b', 'i', 'n', 's', 'r', 'i', '_', 'b', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'b', 'i', 'n', 's', 'r', 'i',
+  '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
+  'a', '_', 'b', 'i', 'n', 's', 'r', 'i', '_', 'h', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'b', 'i', 'n', 's', 'r',
+  'i', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
+  'i', 'p', 's', '_', 'b', 'i', 't', 'r', 'e', 'v', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'b', 'm', 'n', 'z', '_',
+  'v', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
+  '_', 'b', 'm', 'n', 'z', 'i', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'm', 's', 'a', '_', 'b', 'm', 'z', '_', 'v', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'b', 'm',
+  'z', 'i', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'm', 's', 'a', '_', 'b', 'n', 'e', 'g', '_', 'b', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'b', 'n', 'e', 'g', '_',
+  'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
+  '_', 'b', 'n', 'e', 'g', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'm', 's', 'a', '_', 'b', 'n', 'e', 'g', '_', 'w', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'b', 'n',
+  'e', 'g', 'i', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'm', 's', 'a', '_', 'b', 'n', 'e', 'g', 'i', '_', 'd', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'b', 'n', 'e',
+  'g', 'i', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'm', 's', 'a', '_', 'b', 'n', 'e', 'g', 'i', '_', 'w', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'b', 'n', 'z', '_',
+  'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
+  '_', 'b', 'n', 'z', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'm', 's', 'a', '_', 'b', 'n', 'z', '_', 'h', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'b', 'n', 'z', '_',
+  'v', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
+  '_', 'b', 'n', 'z', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'm', 'i', 'p', 's', '_', 'b', 'p', 'o', 's', 'g', 'e', '3', '2',
   '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_',
-  's', 't', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'b', 's', 'e', 'l', '_', 'v', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'm', 's', 'a', '_', 'b', 's', 'e', 'l', 'i', '_', 'b', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'b', 's',
+  'e', 't', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'm', 's', 'a', '_', 'b', 's', 'e', 't', '_', 'd', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'b', 's', 'e', 't', '_',
+  'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
+  '_', 'b', 's', 'e', 't', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'm', 's', 'a', '_', 'b', 's', 'e', 't', 'i', '_', 'b', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'b',
+  's', 'e', 't', 'i', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'm', 's', 'a', '_', 'b', 's', 'e', 't', 'i', '_', 'h', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'b', 's',
+  'e', 't', 'i', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'm', 's', 'a', '_', 'b', 'z', '_', 'b', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'b', 'z', '_', 'd', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'b', 'z',
+  '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
+  'a', '_', 'b', 'z', '_', 'v', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'm', 's', 'a', '_', 'b', 'z', '_', 'w', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'c', 'e', 'q', '_', 'b',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_',
+  'c', 'e', 'q', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'm', 's', 'a', '_', 'c', 'e', 'q', '_', 'h', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'c', 'e', 'q', '_', 'w',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_',
+  'c', 'e', 'q', 'i', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'm', 's', 'a', '_', 'c', 'e', 'q', 'i', '_', 'd', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'c', 'e', 'q',
+  'i', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
+  's', 'a', '_', 'c', 'e', 'q', 'i', '_', 'w', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'c', 'f', 'c', 'm', 's', 'a',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_',
+  'c', 'l', 'e', '_', 's', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'm', 's', 'a', '_', 'c', 'l', 'e', '_', 's', '_', 'd', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'c',
+  'l', 'e', '_', 's', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'm', 's', 'a', '_', 'c', 'l', 'e', '_', 's', '_', 'w', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'c', 'l',
+  'e', '_', 'u', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'm', 's', 'a', '_', 'c', 'l', 'e', '_', 'u', '_', 'd', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'c', 'l', 'e',
+  '_', 'u', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'm', 's', 'a', '_', 'c', 'l', 'e', '_', 'u', '_', 'w', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'c', 'l', 'e', 'i',
+  '_', 's', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'm', 's', 'a', '_', 'c', 'l', 'e', 'i', '_', 's', '_', 'd', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'c', 'l', 'e',
+  'i', '_', 's', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'm', 's', 'a', '_', 'c', 'l', 'e', 'i', '_', 's', '_', 'w', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'c', 'l',
+  'e', 'i', '_', 'u', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'm', 's', 'a', '_', 'c', 'l', 'e', 'i', '_', 'u', '_', 'd', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'c',
+  'l', 'e', 'i', '_', 'u', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'm', 's', 'a', '_', 'c', 'l', 'e', 'i', '_', 'u', '_', 'w',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_',
+  'c', 'l', 't', '_', 's', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'm', 's', 'a', '_', 'c', 'l', 't', '_', 's', '_', 'd', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'c',
+  'l', 't', '_', 's', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'm', 's', 'a', '_', 'c', 'l', 't', '_', 's', '_', 'w', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'c', 'l',
+  't', '_', 'u', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'm', 's', 'a', '_', 'c', 'l', 't', '_', 'u', '_', 'd', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'c', 'l', 't',
+  '_', 'u', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'm', 's', 'a', '_', 'c', 'l', 't', '_', 'u', '_', 'w', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'c', 'l', 't', 'i',
+  '_', 's', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'm', 's', 'a', '_', 'c', 'l', 't', 'i', '_', 's', '_', 'd', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'c', 'l', 't',
+  'i', '_', 's', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'm', 's', 'a', '_', 'c', 'l', 't', 'i', '_', 's', '_', 'w', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'c', 'l',
+  't', 'i', '_', 'u', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'm', 's', 'a', '_', 'c', 'l', 't', 'i', '_', 'u', '_', 'd', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'c',
+  'l', 't', 'i', '_', 'u', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'm', 's', 'a', '_', 'c', 'l', 't', 'i', '_', 'u', '_', 'w',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's',
+  '_', 'c', 'm', 'p', '_', 'e', 'q', '_', 'p', 'h', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'c', 'm', 'p', '_',
+  'l', 'e', '_', 'p', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'm', 'i', 'p', 's', '_', 'c', 'm', 'p', '_', 'l', 't', '_', 'p', 'h',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's',
+  '_', 'c', 'm', 'p', 'g', 'd', 'u', '_', 'e', 'q', '_', 'q', 'b', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'c',
+  'm', 'p', 'g', 'd', 'u', '_', 'l', 'e', '_', 'q', 'b', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'c', 'm', 'p',
+  'g', 'd', 'u', '_', 'l', 't', '_', 'q', 'b', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'c', 'm', 'p', 'g', 'u',
+  '_', 'e', 'q', '_', 'q', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'm', 'i', 'p', 's', '_', 'c', 'm', 'p', 'g', 'u', '_', 'l', 'e',
+  '_', 'q', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
+  'i', 'p', 's', '_', 'c', 'm', 'p', 'g', 'u', '_', 'l', 't', '_', 'q', 'b',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's',
+  '_', 'c', 'm', 'p', 'u', '_', 'e', 'q', '_', 'q', 'b', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'c', 'm', 'p',
+  'u', '_', 'l', 'e', '_', 'q', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'c', 'm', 'p', 'u', '_', 'l', 't',
+  '_', 'q', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
+  's', 'a', '_', 'c', 'o', 'p', 'y', '_', 's', '_', 'b', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'c', 'o', 'p', 'y',
+  '_', 's', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'm', 's', 'a', '_', 'c', 'o', 'p', 'y', '_', 's', '_', 'h', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'c', 'o', 'p',
+  'y', '_', 's', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'm', 's', 'a', '_', 'c', 'o', 'p', 'y', '_', 'u', '_', 'b', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'c', 'o',
+  'p', 'y', '_', 'u', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'm', 's', 'a', '_', 'c', 'o', 'p', 'y', '_', 'u', '_', 'h', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'c',
+  'o', 'p', 'y', '_', 'u', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'm', 's', 'a', '_', 'c', 't', 'c', 'm', 's', 'a', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'd', 'i',
+  'v', '_', 's', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'm', 's', 'a', '_', 'd', 'i', 'v', '_', 's', '_', 'd', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'd', 'i', 'v',
+  '_', 's', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'm', 's', 'a', '_', 'd', 'i', 'v', '_', 's', '_', 'w', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'd', 'i', 'v', '_',
+  'u', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
+  's', 'a', '_', 'd', 'i', 'v', '_', 'u', '_', 'd', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'd', 'i', 'v', '_', 'u',
+  '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
+  'a', '_', 'd', 'i', 'v', '_', 'u', '_', 'w', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'd', 'l', 's', 'a', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'd',
+  'o', 't', 'p', '_', 's', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'm', 's', 'a', '_', 'd', 'o', 't', 'p', '_', 's', '_', 'h',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_',
+  'd', 'o', 't', 'p', '_', 's', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'm', 's', 'a', '_', 'd', 'o', 't', 'p', '_', 'u', '_',
+  'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
+  '_', 'd', 'o', 't', 'p', '_', 'u', '_', 'h', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'd', 'o', 't', 'p', '_', 'u',
+  '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i',
+  'p', 's', '_', 'd', 'p', 'a', '_', 'w', '_', 'p', 'h', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'd', 'p', 'a', 'd',
+  'd', '_', 's', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'm', 's', 'a', '_', 'd', 'p', 'a', 'd', 'd', '_', 's', '_', 'h', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'd',
+  'p', 'a', 'd', 'd', '_', 's', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'm', 's', 'a', '_', 'd', 'p', 'a', 'd', 'd', '_', 'u',
+  '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
+  'a', '_', 'd', 'p', 'a', 'd', 'd', '_', 'u', '_', 'h', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'd', 'p', 'a', 'd',
+  'd', '_', 'u', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'm', 'i', 'p', 's', '_', 'd', 'p', 'a', 'q', '_', 's', '_', 'w', '_',
+  'p', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i',
+  'p', 's', '_', 'd', 'p', 'a', 'q', '_', 's', 'a', '_', 'l', '_', 'w', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_',
+  'd', 'p', 'a', 'q', 'x', '_', 's', '_', 'w', '_', 'p', 'h', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'd', 'p',
+  'a', 'q', 'x', '_', 's', 'a', '_', 'w', '_', 'p', 'h', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'd', 'p', 'a',
+  'u', '_', 'h', '_', 'q', 'b', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'd', 'p', 'a', 'u', '_', 'h', '_',
+  'q', 'b', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
+  'i', 'p', 's', '_', 'd', 'p', 'a', 'x', '_', 'w', '_', 'p', 'h', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'd',
+  'p', 's', '_', 'w', '_', 'p', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'd', 'p', 's', 'q', '_', 's', '_',
+  'w', '_', 'p', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'm', 'i', 'p', 's', '_', 'd', 'p', 's', 'q', '_', 's', 'a', '_', 'l', '_',
+  'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p',
+  's', '_', 'd', 'p', 's', 'q', 'x', '_', 's', '_', 'w', '_', 'p', 'h', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_',
+  'd', 'p', 's', 'q', 'x', '_', 's', 'a', '_', 'w', '_', 'p', 'h', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'd',
+  'p', 's', 'u', '_', 'h', '_', 'q', 'b', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'd', 'p', 's', 'u', '_',
+  'h', '_', 'q', 'b', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'm', 's', 'a', '_', 'd', 'p', 's', 'u', 'b', '_', 's', '_', 'd', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'd',
+  'p', 's', 'u', 'b', '_', 's', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'm', 's', 'a', '_', 'd', 'p', 's', 'u', 'b', '_', 's',
+  '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
+  'a', '_', 'd', 'p', 's', 'u', 'b', '_', 'u', '_', 'd', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'd', 'p', 's', 'u',
+  'b', '_', 'u', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'm', 's', 'a', '_', 'd', 'p', 's', 'u', 'b', '_', 'u', '_', 'w', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_',
+  'd', 'p', 's', 'x', '_', 'w', '_', 'p', 'h', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'e', 'x', 't', 'p', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_',
+  'e', 'x', 't', 'p', 'd', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'm', 'i', 'p', 's', '_', 'e', 'x', 't', 'r', '_', 'r', '_', 'w',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's',
+  '_', 'e', 'x', 't', 'r', '_', 'r', 's', '_', 'w', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'e', 'x', 't', 'r',
+  '_', 's', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'm', 'i', 'p', 's', '_', 'e', 'x', 't', 'r', '_', 'w', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 'a', 'd', 'd',
+  '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
+  'a', '_', 'f', 'a', 'd', 'd', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 'c', 'a', 'f', '_', 'd', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f',
+  'c', 'a', 'f', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'm', 's', 'a', '_', 'f', 'c', 'e', 'q', '_', 'd', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 'c', 'e', 'q',
+  '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
+  'a', '_', 'f', 'c', 'l', 'a', 's', 's', '_', 'd', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 'c', 'l', 'a', 's',
+  's', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
+  's', 'a', '_', 'f', 'c', 'l', 'e', '_', 'd', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 'c', 'l', 'e', '_', 'w',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_',
+  'f', 'c', 'l', 't', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'm', 's', 'a', '_', 'f', 'c', 'l', 't', '_', 'w', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 'c', 'n',
+  'e', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
+  's', 'a', '_', 'f', 'c', 'n', 'e', '_', 'w', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 'c', 'o', 'r', '_', 'd',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_',
+  'f', 'c', 'o', 'r', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'm', 's', 'a', '_', 'f', 'c', 'u', 'e', 'q', '_', 'd', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 'c',
+  'u', 'e', 'q', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'm', 's', 'a', '_', 'f', 'c', 'u', 'l', 'e', '_', 'd', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 'c', 'u',
+  'l', 'e', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'm', 's', 'a', '_', 'f', 'c', 'u', 'l', 't', '_', 'd', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 'c', 'u', 'l',
+  't', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
+  's', 'a', '_', 'f', 'c', 'u', 'n', '_', 'd', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 'c', 'u', 'n', '_', 'w',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_',
+  'f', 'c', 'u', 'n', 'e', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'm', 's', 'a', '_', 'f', 'c', 'u', 'n', 'e', '_', 'w', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f',
+  'd', 'i', 'v', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'm', 's', 'a', '_', 'f', 'd', 'i', 'v', '_', 'w', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 'e', 'x', 'd',
+  'o', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
+  's', 'a', '_', 'f', 'e', 'x', 'd', 'o', '_', 'w', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 'e', 'x', 'p', '2',
+  '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
+  'a', '_', 'f', 'e', 'x', 'p', '2', '_', 'w', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 'e', 'x', 'u', 'p', 'l',
+  '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
+  'a', '_', 'f', 'e', 'x', 'u', 'p', 'l', '_', 'w', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 'e', 'x', 'u', 'p',
+  'r', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
+  's', 'a', '_', 'f', 'e', 'x', 'u', 'p', 'r', '_', 'w', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 'f', 'i', 'n',
+  't', '_', 's', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'm', 's', 'a', '_', 'f', 'f', 'i', 'n', 't', '_', 's', '_', 'w', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f',
+  'f', 'i', 'n', 't', '_', 'u', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 'f', 'i', 'n', 't', '_', 'u',
+  '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
+  'a', '_', 'f', 'f', 'q', 'l', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 'f', 'q', 'l', '_', 'w', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f',
+  'f', 'q', 'r', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'm', 's', 'a', '_', 'f', 'f', 'q', 'r', '_', 'w', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 'i', 'l', 'l',
+  '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
+  'a', '_', 'f', 'i', 'l', 'l', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 'i', 'l', 'l', '_', 'h', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f',
+  'i', 'l', 'l', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'm', 's', 'a', '_', 'f', 'l', 'o', 'g', '2', '_', 'd', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 'l', 'o',
+  'g', '2', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'm', 's', 'a', '_', 'f', 'm', 'a', 'd', 'd', '_', 'd', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 'm', 'a', 'd',
+  'd', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
+  's', 'a', '_', 'f', 'm', 'a', 'x', '_', 'a', '_', 'd', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 'm', 'a', 'x',
+  '_', 'a', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'm', 's', 'a', '_', 'f', 'm', 'a', 'x', '_', 'd', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 'm', 'a', 'x', '_',
+  'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
+  '_', 'f', 'm', 'i', 'n', '_', 'a', '_', 'd', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 'm', 'i', 'n', '_', 'a',
+  '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
+  'a', '_', 'f', 'm', 'i', 'n', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 'm', 'i', 'n', '_', 'w', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f',
+  'm', 's', 'u', 'b', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'm', 's', 'a', '_', 'f', 'm', 's', 'u', 'b', '_', 'w', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 'm',
+  'u', 'l', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'm', 's', 'a', '_', 'f', 'm', 'u', 'l', '_', 'w', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 'r', 'c', 'p', '_',
+  'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
+  '_', 'f', 'r', 'c', 'p', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'm', 's', 'a', '_', 'f', 'r', 'i', 'n', 't', '_', 'd', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f',
+  'r', 'i', 'n', 't', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'm', 's', 'a', '_', 'f', 'r', 's', 'q', 'r', 't', '_', 'd', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f',
+  'r', 's', 'q', 'r', 't', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'm', 's', 'a', '_', 'f', 's', 'a', 'f', '_', 'd', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 's',
+  'a', 'f', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'm', 's', 'a', '_', 'f', 's', 'e', 'q', '_', 'd', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 's', 'e', 'q', '_',
+  'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
+  '_', 'f', 's', 'l', 'e', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'm', 's', 'a', '_', 'f', 's', 'l', 'e', '_', 'w', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 's',
+  'l', 't', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'm', 's', 'a', '_', 'f', 's', 'l', 't', '_', 'w', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 's', 'n', 'e', '_',
+  'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
+  '_', 'f', 's', 'n', 'e', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'm', 's', 'a', '_', 'f', 's', 'o', 'r', '_', 'd', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 's',
+  'o', 'r', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'm', 's', 'a', '_', 'f', 's', 'q', 'r', 't', '_', 'd', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 's', 'q', 'r',
+  't', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
+  's', 'a', '_', 'f', 's', 'u', 'b', '_', 'd', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 's', 'u', 'b', '_', 'w',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_',
+  'f', 's', 'u', 'e', 'q', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'm', 's', 'a', '_', 'f', 's', 'u', 'e', 'q', '_', 'w', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f',
+  's', 'u', 'l', 'e', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'm', 's', 'a', '_', 'f', 's', 'u', 'l', 'e', '_', 'w', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 's',
+  'u', 'l', 't', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'm', 's', 'a', '_', 'f', 's', 'u', 'l', 't', '_', 'w', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 's', 'u',
+  'n', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
+  's', 'a', '_', 'f', 's', 'u', 'n', '_', 'w', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 's', 'u', 'n', 'e', '_',
+  'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
+  '_', 'f', 's', 'u', 'n', 'e', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 't', 'i', 'n', 't', '_', 's',
+  '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
+  'a', '_', 'f', 't', 'i', 'n', 't', '_', 's', '_', 'w', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 't', 'i', 'n',
+  't', '_', 'u', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'm', 's', 'a', '_', 'f', 't', 'i', 'n', 't', '_', 'u', '_', 'w', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f',
+  't', 'q', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'm', 's', 'a', '_', 'f', 't', 'q', '_', 'w', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 't', 'r', 'u', 'n', 'c',
+  '_', 's', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'm', 's', 'a', '_', 'f', 't', 'r', 'u', 'n', 'c', '_', 's', '_', 'w', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f',
+  't', 'r', 'u', 'n', 'c', '_', 'u', '_', 'd', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'f', 't', 'r', 'u', 'n', 'c',
+  '_', 'u', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'm', 's', 'a', '_', 'h', 'a', 'd', 'd', '_', 's', '_', 'd', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'h', 'a', 'd',
+  'd', '_', 's', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'm', 's', 'a', '_', 'h', 'a', 'd', 'd', '_', 's', '_', 'w', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'h', 'a',
+  'd', 'd', '_', 'u', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'm', 's', 'a', '_', 'h', 'a', 'd', 'd', '_', 'u', '_', 'h', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'h',
+  'a', 'd', 'd', '_', 'u', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'm', 's', 'a', '_', 'h', 's', 'u', 'b', '_', 's', '_', 'd',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_',
+  'h', 's', 'u', 'b', '_', 's', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'm', 's', 'a', '_', 'h', 's', 'u', 'b', '_', 's', '_',
+  'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
+  '_', 'h', 's', 'u', 'b', '_', 'u', '_', 'd', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'h', 's', 'u', 'b', '_', 'u',
+  '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
+  'a', '_', 'h', 's', 'u', 'b', '_', 'u', '_', 'w', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'i', 'l', 'v', 'e', 'v',
+  '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
+  'a', '_', 'i', 'l', 'v', 'e', 'v', '_', 'd', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'i', 'l', 'v', 'e', 'v', '_',
+  'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
+  '_', 'i', 'l', 'v', 'e', 'v', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'm', 's', 'a', '_', 'i', 'l', 'v', 'l', '_', 'b', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'i',
+  'l', 'v', 'l', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'm', 's', 'a', '_', 'i', 'l', 'v', 'l', '_', 'h', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'i', 'l', 'v', 'l',
+  '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
+  'a', '_', 'i', 'l', 'v', 'o', 'd', '_', 'b', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'i', 'l', 'v', 'o', 'd', '_',
+  'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
+  '_', 'i', 'l', 'v', 'o', 'd', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'm', 's', 'a', '_', 'i', 'l', 'v', 'o', 'd', '_', 'w',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_',
+  'i', 'l', 'v', 'r', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'm', 's', 'a', '_', 'i', 'l', 'v', 'r', '_', 'd', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'i', 'l', 'v',
+  'r', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
+  's', 'a', '_', 'i', 'l', 'v', 'r', '_', 'w', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'i', 'n', 's', 'e', 'r', 't',
+  '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
+  'a', '_', 'i', 'n', 's', 'e', 'r', 't', '_', 'd', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'i', 'n', 's', 'e', 'r',
+  't', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
+  's', 'a', '_', 'i', 'n', 's', 'e', 'r', 't', '_', 'w', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'i', 'n', 's',
+  'v', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
+  '_', 'i', 'n', 's', 'v', 'e', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'm', 's', 'a', '_', 'i', 'n', 's', 'v', 'e', '_', 'd',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_',
+  'i', 'n', 's', 'v', 'e', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'm', 's', 'a', '_', 'i', 'n', 's', 'v', 'e', '_', 'w', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_',
+  'l', 'b', 'u', 'x', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'm', 's', 'a', '_', 'l', 'd', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'm', 's', 'a', '_', 'l', 'd', '_', 'd', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'l', 'd', '_',
+  'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
+  '_', 'l', 'd', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'm', 's', 'a', '_', 'l', 'd', 'i', '_', 'b', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'l', 'd', 'i', '_', 'd',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_',
+  'l', 'd', 'i', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'm', 's', 'a', '_', 'l', 'd', 'i', '_', 'w', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'l', 'd', 'r', '_', 'd',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_',
+  'l', 'd', 'r', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'm', 'i', 'p', 's', '_', 'l', 'h', 'x', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'l', 's', 'a', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'l',
+  'w', 'x', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i',
+  'p', 's', '_', 'm', 'a', 'd', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'm', 's', 'a', '_', 'm', 'a', 'd', 'd', '_', 'q', '_', 'h',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_',
+  'm', 'a', 'd', 'd', '_', 'q', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'm', 's', 'a', '_', 'm', 'a', 'd', 'd', 'r', '_', 'q',
+  '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
+  'a', '_', 'm', 'a', 'd', 'd', 'r', '_', 'q', '_', 'w', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'm', 'a', 'd',
+  'd', 'u', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
+  'a', '_', 'm', 'a', 'd', 'd', 'v', '_', 'b', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'm', 'a', 'd', 'd', 'v', '_',
+  'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
+  '_', 'm', 'a', 'd', 'd', 'v', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'm', 's', 'a', '_', 'm', 'a', 'd', 'd', 'v', '_', 'w',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's',
+  '_', 'm', 'a', 'q', '_', 's', '_', 'w', '_', 'p', 'h', 'l', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'm', 'a',
+  'q', '_', 's', '_', 'w', '_', 'p', 'h', 'r', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'm', 'a', 'q', '_', 's',
+  'a', '_', 'w', '_', 'p', 'h', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'm', 'a', 'q', '_', 's', 'a', '_',
+  'w', '_', 'p', 'h', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'm', 's', 'a', '_', 'm', 'a', 'x', '_', 'a', '_', 'b', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'm', 'a', 'x',
+  '_', 'a', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'm', 's', 'a', '_', 'm', 'a', 'x', '_', 'a', '_', 'h', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'm', 'a', 'x', '_',
+  'a', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
+  's', 'a', '_', 'm', 'a', 'x', '_', 's', '_', 'b', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'm', 'a', 'x', '_', 's',
+  '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
+  'a', '_', 'm', 'a', 'x', '_', 's', '_', 'h', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'm', 'a', 'x', '_', 's', '_',
+  'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
+  '_', 'm', 'a', 'x', '_', 'u', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'm', 's', 'a', '_', 'm', 'a', 'x', '_', 'u', '_', 'd',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_',
+  'm', 'a', 'x', '_', 'u', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'm', 's', 'a', '_', 'm', 'a', 'x', '_', 'u', '_', 'w', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'm',
+  'a', 'x', 'i', '_', 's', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'm', 's', 'a', '_', 'm', 'a', 'x', 'i', '_', 's', '_', 'd',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_',
+  'm', 'a', 'x', 'i', '_', 's', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'm', 's', 'a', '_', 'm', 'a', 'x', 'i', '_', 's', '_',
+  'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
+  '_', 'm', 'a', 'x', 'i', '_', 'u', '_', 'b', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'm', 'a', 'x', 'i', '_', 'u',
+  '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
+  'a', '_', 'm', 'a', 'x', 'i', '_', 'u', '_', 'h', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'm', 'a', 'x', 'i', '_',
+  'u', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
+  's', 'a', '_', 'm', 'i', 'n', '_', 'a', '_', 'b', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'm', 'i', 'n', '_', 'a',
+  '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
+  'a', '_', 'm', 'i', 'n', '_', 'a', '_', 'h', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'm', 'i', 'n', '_', 'a', '_',
+  'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
+  '_', 'm', 'i', 'n', '_', 's', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'm', 's', 'a', '_', 'm', 'i', 'n', '_', 's', '_', 'd',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_',
+  'm', 'i', 'n', '_', 's', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'm', 's', 'a', '_', 'm', 'i', 'n', '_', 's', '_', 'w', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'm',
+  'i', 'n', '_', 'u', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'm', 's', 'a', '_', 'm', 'i', 'n', '_', 'u', '_', 'd', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'm', 'i',
+  'n', '_', 'u', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'm', 's', 'a', '_', 'm', 'i', 'n', '_', 'u', '_', 'w', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'm', 'i', 'n',
+  'i', '_', 's', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'm', 's', 'a', '_', 'm', 'i', 'n', 'i', '_', 's', '_', 'd', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'm', 'i',
+  'n', 'i', '_', 's', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'm', 's', 'a', '_', 'm', 'i', 'n', 'i', '_', 's', '_', 'w', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'm',
+  'i', 'n', 'i', '_', 'u', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'm', 's', 'a', '_', 'm', 'i', 'n', 'i', '_', 'u', '_', 'd',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_',
+  'm', 'i', 'n', 'i', '_', 'u', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'm', 's', 'a', '_', 'm', 'i', 'n', 'i', '_', 'u', '_',
+  'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
+  '_', 'm', 'o', 'd', '_', 's', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'm', 's', 'a', '_', 'm', 'o', 'd', '_', 's', '_', 'd',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_',
+  'm', 'o', 'd', '_', 's', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'm', 's', 'a', '_', 'm', 'o', 'd', '_', 's', '_', 'w', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'm',
+  'o', 'd', '_', 'u', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'm', 's', 'a', '_', 'm', 'o', 'd', '_', 'u', '_', 'd', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'm', 'o',
+  'd', '_', 'u', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'm', 's', 'a', '_', 'm', 'o', 'd', '_', 'u', '_', 'w', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'm', 'o',
+  'd', 's', 'u', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'm', 's', 'a', '_', 'm', 'o', 'v', 'e', '_', 'v', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'm', 's', 'u', 'b',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_',
+  'm', 's', 'u', 'b', '_', 'q', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'm', 's', 'a', '_', 'm', 's', 'u', 'b', '_', 'q', '_',
+  'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
+  '_', 'm', 's', 'u', 'b', 'r', '_', 'q', '_', 'h', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'm', 's', 'u', 'b', 'r',
+  '_', 'q', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'm', 'i', 'p', 's', '_', 'm', 's', 'u', 'b', 'u', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'm', 's', 'u', 'b', 'v',
+  '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
+  'a', '_', 'm', 's', 'u', 'b', 'v', '_', 'd', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'm', 's', 'u', 'b', 'v', '_',
+  'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
+  '_', 'm', 's', 'u', 'b', 'v', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'm', 't', 'h', 'l', 'i', 'p',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's',
+  '_', 'm', 'u', 'l', '_', 'p', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'm', 's', 'a', '_', 'm', 'u', 'l', '_', 'q', '_', 'h', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'm',
+  'u', 'l', '_', 'q', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'm', 'i', 'p', 's', '_', 'm', 'u', 'l', '_', 's', '_', 'p', 'h',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's',
+  '_', 'm', 'u', 'l', 'e', 'q', '_', 's', '_', 'w', '_', 'p', 'h', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_',
+  'm', 'u', 'l', 'e', 'q', '_', 's', '_', 'w', '_', 'p', 'h', 'r', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'm',
+  'u', 'l', 'e', 'u', '_', 's', '_', 'p', 'h', '_', 'q', 'b', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'm',
+  'u', 'l', 'e', 'u', '_', 's', '_', 'p', 'h', '_', 'q', 'b', 'r', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'm',
+  'u', 'l', 'q', '_', 'r', 's', '_', 'p', 'h', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'm', 'u', 'l', 'q', '_',
+  'r', 's', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'm', 'i', 'p', 's', '_', 'm', 'u', 'l', 'q', '_', 's', '_', 'p', 'h', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_',
+  'm', 'u', 'l', 'q', '_', 's', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'm', 's', 'a', '_', 'm', 'u', 'l', 'r', '_', 'q', '_',
+  'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
+  '_', 'm', 'u', 'l', 'r', '_', 'q', '_', 'w', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'm', 'u', 'l', 's', 'a',
+  '_', 'w', '_', 'p', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'm', 'i', 'p', 's', '_', 'm', 'u', 'l', 's', 'a', 'q', '_', 's', '_',
+  'w', '_', 'p', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'm', 'i', 'p', 's', '_', 'm', 'u', 'l', 't', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'm', 'u', 'l', 't', 'u',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_',
+  'm', 'u', 'l', 'v', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'm', 's', 'a', '_', 'm', 'u', 'l', 'v', '_', 'd', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'm', 'u', 'l',
+  'v', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
+  's', 'a', '_', 'm', 'u', 'l', 'v', '_', 'w', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'n', 'l', 'o', 'c', '_', 'b',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_',
+  'n', 'l', 'o', 'c', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'm', 's', 'a', '_', 'n', 'l', 'o', 'c', '_', 'h', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'n', 'l', 'o',
+  'c', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
+  's', 'a', '_', 'n', 'l', 'z', 'c', '_', 'b', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'n', 'l', 'z', 'c', '_', 'd',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_',
+  'n', 'l', 'z', 'c', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'm', 's', 'a', '_', 'n', 'l', 'z', 'c', '_', 'w', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'n', 'o', 'r',
+  '_', 'v', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
+  'a', '_', 'n', 'o', 'r', 'i', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'm', 's', 'a', '_', 'o', 'r', '_', 'v', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'o', 'r', 'i',
+  '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i',
+  'p', 's', '_', 'p', 'a', 'c', 'k', 'r', 'l', '_', 'p', 'h', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'p', 'c', 'k',
+  'e', 'v', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'm', 's', 'a', '_', 'p', 'c', 'k', 'e', 'v', '_', 'd', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'p', 'c', 'k', 'e',
+  'v', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
+  's', 'a', '_', 'p', 'c', 'k', 'e', 'v', '_', 'w', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'p', 'c', 'k', 'o', 'd',
+  '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
+  'a', '_', 'p', 'c', 'k', 'o', 'd', '_', 'd', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'p', 'c', 'k', 'o', 'd', '_',
+  'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
+  '_', 'p', 'c', 'k', 'o', 'd', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'm', 's', 'a', '_', 'p', 'c', 'n', 't', '_', 'b', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'p',
+  'c', 'n', 't', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'm', 's', 'a', '_', 'p', 'c', 'n', 't', '_', 'h', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 'p', 'c', 'n', 't',
+  '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i',
+  'p', 's', '_', 'p', 'i', 'c', 'k', '_', 'p', 'h', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'p', 'i', 'c', 'k',
+  '_', 'q', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
+  'i', 'p', 's', '_', 'p', 'r', 'e', 'c', 'e', 'q', '_', 'w', '_', 'p', 'h',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p',
+  's', '_', 'p', 'r', 'e', 'c', 'e', 'q', '_', 'w', '_', 'p', 'h', 'r', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_',
+  'p', 'r', 'e', 'c', 'e', 'q', 'u', '_', 'p', 'h', '_', 'q', 'b', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_',
+  'p', 'r', 'e', 'c', 'e', 'q', 'u', '_', 'p', 'h', '_', 'q', 'b', 'l', 'a',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's',
+  '_', 'p', 'r', 'e', 'c', 'e', 'q', 'u', '_', 'p', 'h', '_', 'q', 'b', 'r',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's',
+  '_', 'p', 'r', 'e', 'c', 'e', 'q', 'u', '_', 'p', 'h', '_', 'q', 'b', 'r',
+  'a', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p',
+  's', '_', 'p', 'r', 'e', 'c', 'e', 'u', '_', 'p', 'h', '_', 'q', 'b', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's',
+  '_', 'p', 'r', 'e', 'c', 'e', 'u', '_', 'p', 'h', '_', 'q', 'b', 'l', 'a',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's',
+  '_', 'p', 'r', 'e', 'c', 'e', 'u', '_', 'p', 'h', '_', 'q', 'b', 'r', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_',
+  'p', 'r', 'e', 'c', 'e', 'u', '_', 'p', 'h', '_', 'q', 'b', 'r', 'a', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_',
+  'p', 'r', 'e', 'c', 'r', '_', 'q', 'b', '_', 'p', 'h', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'p', 'r', 'e',
+  'c', 'r', '_', 's', 'r', 'a', '_', 'p', 'h', '_', 'w', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'p', 'r', 'e',
+  'c', 'r', '_', 's', 'r', 'a', '_', 'r', '_', 'p', 'h', '_', 'w', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'p',
+  'r', 'e', 'c', 'r', 'q', '_', 'p', 'h', '_', 'w', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'p', 'r', 'e', 'c',
+  'r', 'q', '_', 'q', 'b', '_', 'p', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'p', 'r', 'e', 'c', 'r', 'q',
+  '_', 'r', 's', '_', 'p', 'h', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'p', 'r', 'e', 'c', 'r', 'q',
+  'u', '_', 's', '_', 'q', 'b', '_', 'p', 'h', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'p', 'r', 'e', 'p', 'e',
+  'n', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i',
+  'p', 's', '_', 'r', 'a', 'd', 'd', 'u', '_', 'w', '_', 'q', 'b', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'r',
+  'd', 'd', 's', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'm', 'i', 'p', 's', '_', 'r', 'e', 'p', 'l', '_', 'p', 'h', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 'r', 'e',
+  'p', 'l', '_', 'q', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'm', 's', 'a', '_', 's', 'a', 't', '_', 's', '_', 'b', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 's', 'a', 't',
+  '_', 's', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'm', 's', 'a', '_', 's', 'a', 't', '_', 's', '_', 'h', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 's', 'a', 't', '_',
+  's', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
+  's', 'a', '_', 's', 'a', 't', '_', 'u', '_', 'b', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 's', 'a', 't', '_', 'u',
+  '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
+  'a', '_', 's', 'a', 't', '_', 'u', '_', 'h', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 's', 'a', 't', '_', 'u', '_',
+  'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
+  '_', 's', 'h', 'f', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'm', 's', 'a', '_', 's', 'h', 'f', '_', 'h', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 's', 'h', 'f', '_',
+  'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p',
+  's', '_', 's', 'h', 'i', 'l', 'o', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'm', 'i', 'p', 's', '_', 's', 'h', 'l', 'l', '_', 'p', 'h',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's',
+  '_', 's', 'h', 'l', 'l', '_', 'q', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 's', 'h', 'l', 'l', '_', 's',
+  '_', 'p', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
+  'i', 'p', 's', '_', 's', 'h', 'l', 'l', '_', 's', '_', 'w', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 's', 'h',
+  'r', 'a', '_', 'p', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'm', 'i', 'p', 's', '_', 's', 'h', 'r', 'a', '_', 'q', 'b', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 's',
+  'h', 'r', 'a', '_', 'r', '_', 'p', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 's', 'h', 'r', 'a', '_', 'r',
+  '_', 'q', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
+  'i', 'p', 's', '_', 's', 'h', 'r', 'a', '_', 'r', '_', 'w', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 's', 'h',
+  'r', 'l', '_', 'p', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'm', 'i', 'p', 's', '_', 's', 'h', 'r', 'l', '_', 'q', 'b', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 's', 'l',
+  'd', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
+  's', 'a', '_', 's', 'l', 'd', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'm', 's', 'a', '_', 's', 'l', 'd', '_', 'h', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 's', 'l',
+  'd', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
+  's', 'a', '_', 's', 'l', 'd', 'i', '_', 'b', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 's', 'l', 'd', 'i', '_', 'd',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_',
+  's', 'l', 'd', 'i', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'm', 's', 'a', '_', 's', 'l', 'd', 'i', '_', 'w', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 's', 'l', 'l',
+  '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
+  'a', '_', 's', 'l', 'l', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'm', 's', 'a', '_', 's', 'l', 'l', '_', 'h', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 's', 'l', 'l',
+  '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
+  'a', '_', 's', 'l', 'l', 'i', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'm', 's', 'a', '_', 's', 'l', 'l', 'i', '_', 'd', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 's',
+  'l', 'l', 'i', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'm', 's', 'a', '_', 's', 'l', 'l', 'i', '_', 'w', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 's', 'p', 'l', 'a',
+  't', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
+  's', 'a', '_', 's', 'p', 'l', 'a', 't', '_', 'd', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 's', 'p', 'l', 'a', 't',
+  '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
+  'a', '_', 's', 'p', 'l', 'a', 't', '_', 'w', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 's', 'p', 'l', 'a', 't', 'i',
+  '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
+  'a', '_', 's', 'p', 'l', 'a', 't', 'i', '_', 'd', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 's', 'p', 'l', 'a', 't',
+  'i', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
+  's', 'a', '_', 's', 'p', 'l', 'a', 't', 'i', '_', 'w', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 's', 'r', 'a', '_',
+  'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
+  '_', 's', 'r', 'a', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'm', 's', 'a', '_', 's', 'r', 'a', '_', 'h', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 's', 'r', 'a', '_',
+  'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
+  '_', 's', 'r', 'a', 'i', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'm', 's', 'a', '_', 's', 'r', 'a', 'i', '_', 'd', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 's', 'r',
+  'a', 'i', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'm', 's', 'a', '_', 's', 'r', 'a', 'i', '_', 'w', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 's', 'r', 'a', 'r', '_',
+  'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
+  '_', 's', 'r', 'a', 'r', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'm', 's', 'a', '_', 's', 'r', 'a', 'r', '_', 'h', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 's', 'r',
+  'a', 'r', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'm', 's', 'a', '_', 's', 'r', 'a', 'r', 'i', '_', 'b', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 's', 'r', 'a', 'r',
+  'i', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm',
+  's', 'a', '_', 's', 'r', 'a', 'r', 'i', '_', 'h', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 's', 'r', 'a', 'r', 'i',
+  '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
+  'a', '_', 's', 'r', 'l', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'm', 's', 'a', '_', 's', 'r', 'l', '_', 'd', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 's', 'r', 'l',
+  '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
+  'a', '_', 's', 'r', 'l', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'm', 's', 'a', '_', 's', 'r', 'l', 'i', '_', 'b', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 's', 'r',
+  'l', 'i', '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'm', 's', 'a', '_', 's', 'r', 'l', 'i', '_', 'h', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 's', 'r', 'l', 'i', '_',
+  'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
+  '_', 's', 'r', 'l', 'r', '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'm', 's', 'a', '_', 's', 'r', 'l', 'r', '_', 'd', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 's', 'r',
+  'l', 'r', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'm', 's', 'a', '_', 's', 'r', 'l', 'r', '_', 'w', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 's', 'r', 'l', 'r', 'i',
+  '_', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's',
+  'a', '_', 's', 'r', 'l', 'r', 'i', '_', 'd', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 's', 'r', 'l', 'r', 'i', '_',
+  'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
+  '_', 's', 'r', 'l', 'r', 'i', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'm', 's', 'a', '_', 's', 't', '_', 'b', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 's', 't', '_',
+  'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a',
+  '_', 's', 't', '_', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'm', 's', 'a', '_', 's', 't', '_', 'w', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 's', 't', 'r', '_', 'd', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 's', 'a', '_', 's',
+  't', 'r', '_', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
   'm', 'i', 'p', 's', '_', 's', 'u', 'b', 'q', '_', 'p', 'h', '\000', '_', '_',
   'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'm', 'i', 'p', 's', '_', 's', 'u',
   'b', 'q', '_', 's', '_', 'p', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
@@ -23821,2614 +30545,5145 @@
   'v', 'e', 'c', '_', 'm', 'f', 'v', 's', 'c', 'r', '\000', '_', '_', 'b', 'u',
   'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'm',
   't', 'v', 's', 'c', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'a', 'b', 's', 'd', 'u',
-  'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't',
-  'i', 'v', 'e', 'c', '_', 'v', 'a', 'b', 's', 'd', 'u', 'h', '\000', '_', '_',
+  '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'm', 't', 'v', 's', 'r', 'b',
+  'm', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't',
+  'i', 'v', 'e', 'c', '_', 'm', 't', 'v', 's', 'r', 'd', 'm', '\000', '_', '_',
   'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c',
-  '_', 'v', 'a', 'b', 's', 'd', 'u', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'a', 'd',
-  'd', 'c', 'u', 'q', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'a', 'd', 'd', 'c', 'u', 'w',
+  '_', 'm', 't', 'v', 's', 'r', 'h', 'm', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'm', 't', 'v',
+  's', 'r', 'q', 'm', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'm', 't', 'v', 's', 'r', 'w', 'm',
   '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i',
-  'v', 'e', 'c', '_', 'v', 'a', 'd', 'd', 'e', 'c', 'u', 'q', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c',
-  '_', 'v', 'a', 'd', 'd', 'e', 'u', 'q', 'm', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'a',
-  'd', 'd', 's', 'b', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'a', 'd', 'd', 's', 'h',
-  's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't',
-  'i', 'v', 'e', 'c', '_', 'v', 'a', 'd', 'd', 's', 'w', 's', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c',
-  '_', 'v', 'a', 'd', 'd', 'u', 'b', 's', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'a', 'd',
-  'd', 'u', 'h', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'a', 'd', 'd', 'u', 'w', 's',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i',
-  'v', 'e', 'c', '_', 'v', 'a', 'v', 'g', 's', 'b', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v',
-  'a', 'v', 'g', 's', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'a', 'v', 'g', 's', 'w',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i',
-  'v', 'e', 'c', '_', 'v', 'a', 'v', 'g', 'u', 'b', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v',
-  'a', 'v', 'g', 'u', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'a', 'v', 'g', 'u', 'w',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i',
-  'v', 'e', 'c', '_', 'v', 'b', 'p', 'e', 'r', 'm', 'q', '\000', '_', '_', 'b',
+  'v', 'e', 'c', '_', 'v', 'a', 'b', 's', 'd', 'u', 'b', '\000', '_', '_', 'b',
   'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_',
-  'v', 'c', 'f', 's', 'x', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'c', 'f', 'u', 'x', '\000',
+  'v', 'a', 'b', 's', 'd', 'u', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'a', 'b', 's',
+  'd', 'u', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a',
+  'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'a', 'd', 'd', 'c', 'u', 'q', '\000',
   '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v',
-  'e', 'c', '_', 'v', 'c', 'l', 'z', 'l', 's', 'b', 'b', '\000', '_', '_', 'b',
+  'e', 'c', '_', 'v', 'a', 'd', 'd', 'c', 'u', 'w', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v',
+  'a', 'd', 'd', 'e', 'c', 'u', 'q', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'a', 'd', 'd',
+  'e', 'u', 'q', 'm', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'a', 'd', 'd', 's', 'b', 's',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i',
+  'v', 'e', 'c', '_', 'v', 'a', 'd', 'd', 's', 'h', 's', '\000', '_', '_', 'b',
   'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_',
-  'v', 'c', 'm', 'p', 'b', 'f', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'c', 'm', 'p',
-  'b', 'f', 'p', '_', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'c', 'm', 'p', 'e', 'q',
-  'f', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l',
-  't', 'i', 'v', 'e', 'c', '_', 'v', 'c', 'm', 'p', 'e', 'q', 'f', 'p', '_',
-  'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't',
-  'i', 'v', 'e', 'c', '_', 'v', 'c', 'm', 'p', 'e', 'q', 'u', 'b', '\000', '_',
+  'v', 'a', 'd', 'd', 's', 'w', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'a', 'd', 'd',
+  'u', 'b', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a',
+  'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'a', 'd', 'd', 'u', 'h', 's', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v',
+  'e', 'c', '_', 'v', 'a', 'd', 'd', 'u', 'w', 's', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v',
+  'a', 'v', 'g', 's', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'a', 'v', 'g', 's', 'h',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i',
+  'v', 'e', 'c', '_', 'v', 'a', 'v', 'g', 's', 'w', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v',
+  'a', 'v', 'g', 'u', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'a', 'v', 'g', 'u', 'h',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i',
+  'v', 'e', 'c', '_', 'v', 'a', 'v', 'g', 'u', 'w', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v',
+  'b', 'p', 'e', 'r', 'm', 'q', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'c', 'f', 's', 'x',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i',
+  'v', 'e', 'c', '_', 'v', 'c', 'f', 'u', 'g', 'e', 'd', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_',
+  'v', 'c', 'f', 'u', 'x', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'c', 'l', 'r', 'l', 'b',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i',
+  'v', 'e', 'c', '_', 'v', 'c', 'l', 'r', 'r', 'b', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v',
+  'c', 'l', 'z', 'd', 'm', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'c', 'l', 'z', 'l', 's',
+  'b', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l',
+  't', 'i', 'v', 'e', 'c', '_', 'v', 'c', 'm', 'p', 'b', 'f', 'p', '\000', '_',
   '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e',
-  'c', '_', 'v', 'c', 'm', 'p', 'e', 'q', 'u', 'b', '_', 'p', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c',
-  '_', 'v', 'c', 'm', 'p', 'e', 'q', 'u', 'd', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'c',
-  'm', 'p', 'e', 'q', 'u', 'd', '_', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  'c', '_', 'v', 'c', 'm', 'p', 'b', 'f', 'p', '_', 'p', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_',
+  'v', 'c', 'm', 'p', 'e', 'q', 'f', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l',
   't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'c', 'm',
-  'p', 'e', 'q', 'u', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'c', 'm', 'p', 'e', 'q',
-  'u', 'h', '_', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'p', 'e', 'q', 'f', 'p', '_', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'c', 'm', 'p',
+  'e', 'q', 'u', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
   'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'c', 'm', 'p', 'e', 'q', 'u',
-  'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't',
-  'i', 'v', 'e', 'c', '_', 'v', 'c', 'm', 'p', 'e', 'q', 'u', 'w', '_', 'p',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i',
-  'v', 'e', 'c', '_', 'v', 'c', 'm', 'p', 'g', 'e', 'f', 'p', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c',
-  '_', 'v', 'c', 'm', 'p', 'g', 'e', 'f', 'p', '_', 'p', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_',
-  'v', 'c', 'm', 'p', 'g', 't', 'f', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'c', 'm',
-  'p', 'g', 't', 'f', 'p', '_', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'c', 'm', 'p',
-  'g', 't', 's', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'c', 'm', 'p', 'g', 't', 's',
   'b', '_', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a',
-  'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'c', 'm', 'p', 'g', 't', 's', 'd',
+  'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'c', 'm', 'p', 'e', 'q', 'u', 'd',
   '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i',
-  'v', 'e', 'c', '_', 'v', 'c', 'm', 'p', 'g', 't', 's', 'd', '_', 'p', '\000',
+  'v', 'e', 'c', '_', 'v', 'c', 'm', 'p', 'e', 'q', 'u', 'd', '_', 'p', '\000',
   '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v',
-  'e', 'c', '_', 'v', 'c', 'm', 'p', 'g', 't', 's', 'h', '\000', '_', '_', 'b',
+  'e', 'c', '_', 'v', 'c', 'm', 'p', 'e', 'q', 'u', 'h', '\000', '_', '_', 'b',
   'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_',
-  'v', 'c', 'm', 'p', 'g', 't', 's', 'h', '_', 'p', '\000', '_', '_', 'b', 'u',
+  'v', 'c', 'm', 'p', 'e', 'q', 'u', 'h', '_', 'p', '\000', '_', '_', 'b', 'u',
   'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v',
-  'c', 'm', 'p', 'g', 't', 's', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'c', 'm', 'p', 'e', 'q', 'u', 'q', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
   'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'c', 'm', 'p',
-  'g', 't', 's', 'w', '_', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'c', 'm', 'p', 'g',
-  't', 'u', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a',
-  'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'c', 'm', 'p', 'g', 't', 'u', 'b',
+  'e', 'q', 'u', 'q', '_', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'c', 'm', 'p', 'e',
+  'q', 'u', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a',
+  'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'c', 'm', 'p', 'e', 'q', 'u', 'w',
   '_', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l',
-  't', 'i', 'v', 'e', 'c', '_', 'v', 'c', 'm', 'p', 'g', 't', 'u', 'd', '\000',
+  't', 'i', 'v', 'e', 'c', '_', 'v', 'c', 'm', 'p', 'g', 'e', 'f', 'p', '\000',
   '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v',
-  'e', 'c', '_', 'v', 'c', 'm', 'p', 'g', 't', 'u', 'd', '_', 'p', '\000', '_',
+  'e', 'c', '_', 'v', 'c', 'm', 'p', 'g', 'e', 'f', 'p', '_', 'p', '\000', '_',
   '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e',
-  'c', '_', 'v', 'c', 'm', 'p', 'g', 't', 'u', 'h', '\000', '_', '_', 'b', 'u',
+  'c', '_', 'v', 'c', 'm', 'p', 'g', 't', 'f', 'p', '\000', '_', '_', 'b', 'u',
   'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v',
-  'c', 'm', 'p', 'g', 't', 'u', 'h', '_', 'p', '\000', '_', '_', 'b', 'u', 'i',
+  'c', 'm', 'p', 'g', 't', 'f', 'p', '_', 'p', '\000', '_', '_', 'b', 'u', 'i',
   'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'c',
-  'm', 'p', 'g', 't', 'u', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'm', 'p', 'g', 't', 's', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
   'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'c', 'm', 'p', 'g',
-  't', 'u', 'w', '_', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'c', 'm', 'p', 'n', 'e',
-  'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't',
-  'i', 'v', 'e', 'c', '_', 'v', 'c', 'm', 'p', 'n', 'e', 'b', '_', 'p', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v',
-  'e', 'c', '_', 'v', 'c', 'm', 'p', 'n', 'e', 'h', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v',
-  'c', 'm', 'p', 'n', 'e', 'h', '_', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'c', 'm',
-  'p', 'n', 'e', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'c', 'm', 'p', 'n', 'e', 'w',
-  '_', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l',
-  't', 'i', 'v', 'e', 'c', '_', 'v', 'c', 'm', 'p', 'n', 'e', 'z', 'b', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v',
-  'e', 'c', '_', 'v', 'c', 'm', 'p', 'n', 'e', 'z', 'b', '_', 'p', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e',
-  'c', '_', 'v', 'c', 'm', 'p', 'n', 'e', 'z', 'h', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v',
-  'c', 'm', 'p', 'n', 'e', 'z', 'h', '_', 'p', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'c',
-  'm', 'p', 'n', 'e', 'z', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'c', 'm', 'p', 'n',
-  'e', 'z', 'w', '_', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'c', 't', 's', 'x', 's',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i',
-  'v', 'e', 'c', '_', 'v', 'c', 't', 'u', 'x', 's', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v',
-  'c', 't', 'z', 'l', 's', 'b', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'e', 'x', 'p',
-  't', 'e', 'f', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'g', 'b', 'b', 'd', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e',
-  'c', '_', 'v', 'l', 'o', 'g', 'e', 'f', 'p', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'm',
-  'a', 'd', 'd', 'f', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'm', 'a', 'x', 'f', 'p',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i',
-  'v', 'e', 'c', '_', 'v', 'm', 'a', 'x', 's', 'b', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v',
-  'm', 'a', 'x', 's', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'm', 'a', 'x', 's', 'h',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i',
-  'v', 'e', 'c', '_', 'v', 'm', 'a', 'x', 's', 'w', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v',
-  'm', 'a', 'x', 'u', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'm', 'a', 'x', 'u', 'd',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i',
-  'v', 'e', 'c', '_', 'v', 'm', 'a', 'x', 'u', 'h', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v',
-  'm', 'a', 'x', 'u', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'm', 'h', 'a', 'd', 'd',
-  's', 'h', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a',
-  'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'm', 'h', 'r', 'a', 'd', 'd', 's',
-  'h', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l',
-  't', 'i', 'v', 'e', 'c', '_', 'v', 'm', 'i', 'n', 'f', 'p', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c',
-  '_', 'v', 'm', 'i', 'n', 's', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'm', 'i', 'n',
+  't', 's', 'b', '_', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'c', 'm', 'p', 'g', 't',
   's', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l',
-  't', 'i', 'v', 'e', 'c', '_', 'v', 'm', 'i', 'n', 's', 'h', '\000', '_', '_',
+  't', 'i', 'v', 'e', 'c', '_', 'v', 'c', 'm', 'p', 'g', 't', 's', 'd', '_',
+  'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't',
+  'i', 'v', 'e', 'c', '_', 'v', 'c', 'm', 'p', 'g', 't', 's', 'h', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e',
+  'c', '_', 'v', 'c', 'm', 'p', 'g', 't', 's', 'h', '_', 'p', '\000', '_', '_',
   'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c',
-  '_', 'v', 'm', 'i', 'n', 's', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'm', 'i', 'n',
-  'u', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l',
-  't', 'i', 'v', 'e', 'c', '_', 'v', 'm', 'i', 'n', 'u', 'd', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c',
-  '_', 'v', 'm', 'i', 'n', 'u', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'm', 'i', 'n',
-  'u', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l',
-  't', 'i', 'v', 'e', 'c', '_', 'v', 'm', 'l', 'a', 'd', 'd', 'u', 'h', 'm',
+  '_', 'v', 'c', 'm', 'p', 'g', 't', 's', 'q', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'c',
+  'm', 'p', 'g', 't', 's', 'q', '_', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'c', 'm',
+  'p', 'g', 't', 's', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'c', 'm', 'p', 'g', 't',
+  's', 'w', '_', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'c', 'm', 'p', 'g', 't', 'u',
+  'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't',
+  'i', 'v', 'e', 'c', '_', 'v', 'c', 'm', 'p', 'g', 't', 'u', 'b', '_', 'p',
   '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i',
-  'v', 'e', 'c', '_', 'v', 'm', 's', 'u', 'm', 'm', 'b', 'm', '\000', '_', '_',
+  'v', 'e', 'c', '_', 'v', 'c', 'm', 'p', 'g', 't', 'u', 'd', '\000', '_', '_',
   'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c',
-  '_', 'v', 'm', 's', 'u', 'm', 's', 'h', 'm', '\000', '_', '_', 'b', 'u', 'i',
+  '_', 'v', 'c', 'm', 'p', 'g', 't', 'u', 'd', '_', 'p', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_',
+  'v', 'c', 'm', 'p', 'g', 't', 'u', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'c', 'm',
+  'p', 'g', 't', 'u', 'h', '_', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'c', 'm', 'p',
+  'g', 't', 'u', 'q', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'c', 'm', 'p', 'g', 't', 'u',
+  'q', '_', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a',
+  'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'c', 'm', 'p', 'g', 't', 'u', 'w',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i',
+  'v', 'e', 'c', '_', 'v', 'c', 'm', 'p', 'g', 't', 'u', 'w', '_', 'p', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v',
+  'e', 'c', '_', 'v', 'c', 'm', 'p', 'n', 'e', 'b', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v',
+  'c', 'm', 'p', 'n', 'e', 'b', '_', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'c', 'm',
+  'p', 'n', 'e', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'c', 'm', 'p', 'n', 'e', 'h',
+  '_', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l',
+  't', 'i', 'v', 'e', 'c', '_', 'v', 'c', 'm', 'p', 'n', 'e', 'w', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e',
+  'c', '_', 'v', 'c', 'm', 'p', 'n', 'e', 'w', '_', 'p', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_',
+  'v', 'c', 'm', 'p', 'n', 'e', 'z', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'c', 'm',
+  'p', 'n', 'e', 'z', 'b', '_', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'c', 'm', 'p',
+  'n', 'e', 'z', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'c', 'm', 'p', 'n', 'e', 'z',
+  'h', '_', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a',
+  'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'c', 'm', 'p', 'n', 'e', 'z', 'w',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i',
+  'v', 'e', 'c', '_', 'v', 'c', 'm', 'p', 'n', 'e', 'z', 'w', '_', 'p', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v',
+  'e', 'c', '_', 'v', 'c', 'n', 't', 'm', 'b', 'b', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v',
+  'c', 'n', 't', 'm', 'b', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'c', 'n', 't', 'm',
+  'b', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l',
+  't', 'i', 'v', 'e', 'c', '_', 'v', 'c', 'n', 't', 'm', 'b', 'w', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e',
+  'c', '_', 'v', 'c', 't', 's', 'x', 's', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'c', 't',
+  'u', 'x', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a',
+  'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'c', 't', 'z', 'd', 'm', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e',
+  'c', '_', 'v', 'c', 't', 'z', 'l', 's', 'b', 'b', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v',
+  'd', 'i', 'v', 'e', 's', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'd', 'i', 'v', 'e',
+  's', 'q', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l',
+  't', 'i', 'v', 'e', 'c', '_', 'v', 'd', 'i', 'v', 'e', 's', 'w', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e',
+  'c', '_', 'v', 'd', 'i', 'v', 'e', 'u', 'd', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'd',
+  'i', 'v', 'e', 'u', 'q', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'd', 'i', 'v', 'e', 'u',
+  'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't',
+  'i', 'v', 'e', 'c', '_', 'v', 'e', 'x', 'p', 'a', 'n', 'd', 'b', 'm', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v',
+  'e', 'c', '_', 'v', 'e', 'x', 'p', 'a', 'n', 'd', 'd', 'm', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c',
+  '_', 'v', 'e', 'x', 'p', 'a', 'n', 'd', 'h', 'm', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v',
+  'e', 'x', 'p', 'a', 'n', 'd', 'q', 'm', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'e', 'x',
+  'p', 'a', 'n', 'd', 'w', 'm', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'e', 'x', 'p', 't',
+  'e', 'f', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a',
+  'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'e', 'x', 't', 'd', 'd', 'v', 'l',
+  'x', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't',
+  'i', 'v', 'e', 'c', '_', 'v', 'e', 'x', 't', 'd', 'd', 'v', 'r', 'x', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v',
+  'e', 'c', '_', 'v', 'e', 'x', 't', 'd', 'u', 'b', 'v', 'l', 'x', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e',
+  'c', '_', 'v', 'e', 'x', 't', 'd', 'u', 'b', 'v', 'r', 'x', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c',
+  '_', 'v', 'e', 'x', 't', 'd', 'u', 'h', 'v', 'l', 'x', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_',
+  'v', 'e', 'x', 't', 'd', 'u', 'h', 'v', 'r', 'x', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v',
+  'e', 'x', 't', 'd', 'u', 'w', 'v', 'l', 'x', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'e',
+  'x', 't', 'd', 'u', 'w', 'v', 'r', 'x', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'e', 'x',
+  't', 'r', 'a', 'c', 't', 'b', 'm', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'e', 'x', 't',
+  'r', 'a', 'c', 't', 'd', 'm', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'e', 'x', 't', 'r',
+  'a', 'c', 't', 'h', 'm', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'e', 'x', 't', 'r', 'a',
+  'c', 't', 'q', 'm', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'e', 'x', 't', 'r', 'a', 'c',
+  't', 'w', 'm', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a',
+  'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'e', 'x', 't', 's', 'b', '2', 'd',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i',
+  'v', 'e', 'c', '_', 'v', 'e', 'x', 't', 's', 'b', '2', 'w', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c',
+  '_', 'v', 'e', 'x', 't', 's', 'd', '2', 'q', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'e',
+  'x', 't', 's', 'h', '2', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'e', 'x', 't', 's',
+  'h', '2', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a',
+  'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'e', 'x', 't', 's', 'w', '2', 'd',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i',
+  'v', 'e', 'c', '_', 'v', 'g', 'b', 'b', 'd', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'g',
+  'n', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l',
+  't', 'i', 'v', 'e', 'c', '_', 'v', 'i', 'n', 's', 'b', 'l', 'x', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e',
+  'c', '_', 'v', 'i', 'n', 's', 'b', 'r', 'x', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'i',
+  'n', 's', 'b', 'v', 'l', 'x', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'i', 'n', 's', 'b',
+  'v', 'r', 'x', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a',
+  'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'i', 'n', 's', 'd', 'l', 'x', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v',
+  'e', 'c', '_', 'v', 'i', 'n', 's', 'd', 'r', 'x', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v',
+  'i', 'n', 's', 'h', 'l', 'x', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'i', 'n', 's', 'h',
+  'r', 'x', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l',
+  't', 'i', 'v', 'e', 'c', '_', 'v', 'i', 'n', 's', 'h', 'v', 'l', 'x', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v',
+  'e', 'c', '_', 'v', 'i', 'n', 's', 'h', 'v', 'r', 'x', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_',
+  'v', 'i', 'n', 's', 'w', 'l', 'x', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'i', 'n', 's',
+  'w', 'r', 'x', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a',
+  'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'i', 'n', 's', 'w', 'v', 'l', 'x',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i',
+  'v', 'e', 'c', '_', 'v', 'i', 'n', 's', 'w', 'v', 'r', 'x', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c',
+  '_', 'v', 'l', 'o', 'g', 'e', 'f', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'm', 'a',
+  'd', 'd', 'f', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'm', 'a', 'x', 'f', 'p', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v',
+  'e', 'c', '_', 'v', 'm', 'a', 'x', 's', 'b', '\000', '_', '_', 'b', 'u', 'i',
   'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'm',
-  's', 'u', 'm', 's', 'h', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'm', 's', 'u', 'm',
-  'u', 'b', 'm', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a',
-  'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'm', 's', 'u', 'm', 'u', 'h', 'm',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i',
-  'v', 'e', 'c', '_', 'v', 'm', 's', 'u', 'm', 'u', 'h', 's', '\000', '_', '_',
+  'a', 'x', 's', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'm', 'a', 'x', 's', 'h', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v',
+  'e', 'c', '_', 'v', 'm', 'a', 'x', 's', 'w', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'm',
+  'a', 'x', 'u', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'm', 'a', 'x', 'u', 'd', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v',
+  'e', 'c', '_', 'v', 'm', 'a', 'x', 'u', 'h', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'm',
+  'a', 'x', 'u', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'm', 'h', 'a', 'd', 'd', 's',
+  'h', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l',
+  't', 'i', 'v', 'e', 'c', '_', 'v', 'm', 'h', 'r', 'a', 'd', 'd', 's', 'h',
+  's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't',
+  'i', 'v', 'e', 'c', '_', 'v', 'm', 'i', 'n', 'f', 'p', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_',
+  'v', 'm', 'i', 'n', 's', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'm', 'i', 'n', 's',
+  'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't',
+  'i', 'v', 'e', 'c', '_', 'v', 'm', 'i', 'n', 's', 'h', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_',
+  'v', 'm', 'i', 'n', 's', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'm', 'i', 'n', 'u',
+  'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't',
+  'i', 'v', 'e', 'c', '_', 'v', 'm', 'i', 'n', 'u', 'd', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_',
+  'v', 'm', 'i', 'n', 'u', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'm', 'i', 'n', 'u',
+  'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't',
+  'i', 'v', 'e', 'c', '_', 'v', 'm', 'l', 'a', 'd', 'd', 'u', 'h', 'm', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v',
+  'e', 'c', '_', 'v', 'm', 's', 'u', 'm', 'c', 'u', 'd', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_',
+  'v', 'm', 's', 'u', 'm', 'm', 'b', 'm', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'm', 's',
+  'u', 'm', 's', 'h', 'm', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'm', 's', 'u', 'm', 's',
+  'h', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l',
+  't', 'i', 'v', 'e', 'c', '_', 'v', 'm', 's', 'u', 'm', 'u', 'b', 'm', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v',
+  'e', 'c', '_', 'v', 'm', 's', 'u', 'm', 'u', 'd', 'm', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_',
+  'v', 'm', 's', 'u', 'm', 'u', 'h', 'm', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'm', 's',
+  'u', 'm', 'u', 'h', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'm', 'u', 'l', 'e', 's',
+  'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't',
+  'i', 'v', 'e', 'c', '_', 'v', 'm', 'u', 'l', 'e', 's', 'd', '\000', '_', '_',
   'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c',
-  '_', 'v', 'm', 'u', 'l', 'e', 's', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  '_', 'v', 'm', 'u', 'l', 'e', 's', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l',
   't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'm', 'u',
-  'l', 'e', 's', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'm', 'u', 'l', 'e', 's', 'w',
+  'l', 'e', 's', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'm', 'u', 'l', 'e', 'u', 'b',
   '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i',
-  'v', 'e', 'c', '_', 'v', 'm', 'u', 'l', 'e', 'u', 'b', '\000', '_', '_', 'b',
+  'v', 'e', 'c', '_', 'v', 'm', 'u', 'l', 'e', 'u', 'd', '\000', '_', '_', 'b',
   'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_',
   'v', 'm', 'u', 'l', 'e', 'u', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
   'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'm', 'u', 'l',
   'e', 'u', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a',
-  'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'm', 'u', 'l', 'o', 's', 'b', '\000',
+  'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'm', 'u', 'l', 'h', 's', 'd', '\000',
   '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v',
-  'e', 'c', '_', 'v', 'm', 'u', 'l', 'o', 's', 'h', '\000', '_', '_', 'b', 'u',
+  'e', 'c', '_', 'v', 'm', 'u', 'l', 'h', 's', 'w', '\000', '_', '_', 'b', 'u',
   'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v',
-  'm', 'u', 'l', 'o', 's', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'm', 'u', 'l', 'o',
-  'u', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l',
-  't', 'i', 'v', 'e', 'c', '_', 'v', 'm', 'u', 'l', 'o', 'u', 'h', '\000', '_',
+  'm', 'u', 'l', 'h', 'u', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'm', 'u', 'l', 'h',
+  'u', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l',
+  't', 'i', 'v', 'e', 'c', '_', 'v', 'm', 'u', 'l', 'o', 's', 'b', '\000', '_',
   '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e',
-  'c', '_', 'v', 'm', 'u', 'l', 'o', 'u', 'w', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'n',
-  'm', 's', 'u', 'b', 'f', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'p', 'e', 'r', 'm',
-  '_', '4', 's', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'p', 'k', 'p', 'x', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e',
-  'c', '_', 'v', 'p', 'k', 's', 'd', 's', 's', '\000', '_', '_', 'b', 'u', 'i',
+  'c', '_', 'v', 'm', 'u', 'l', 'o', 's', 'd', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'm',
+  'u', 'l', 'o', 's', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'm', 'u', 'l', 'o', 's',
+  'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't',
+  'i', 'v', 'e', 'c', '_', 'v', 'm', 'u', 'l', 'o', 'u', 'b', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c',
+  '_', 'v', 'm', 'u', 'l', 'o', 'u', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'm', 'u',
+  'l', 'o', 'u', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'm', 'u', 'l', 'o', 'u', 'w',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i',
+  'v', 'e', 'c', '_', 'v', 'n', 'm', 's', 'u', 'b', 'f', 'p', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c',
+  '_', 'v', 'p', 'd', 'e', 'p', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'p', 'e', 'r',
+  'm', '_', '4', 's', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'p', 'e', 'x', 't', 'd',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i',
+  'v', 'e', 'c', '_', 'v', 'p', 'k', 'p', 'x', '\000', '_', '_', 'b', 'u', 'i',
   'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'p',
-  'k', 's', 'd', 'u', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'p', 'k', 's', 'h', 's',
+  'k', 's', 'd', 's', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'p', 'k', 's', 'd', 'u',
   's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't',
-  'i', 'v', 'e', 'c', '_', 'v', 'p', 'k', 's', 'h', 'u', 's', '\000', '_', '_',
+  'i', 'v', 'e', 'c', '_', 'v', 'p', 'k', 's', 'h', 's', 's', '\000', '_', '_',
   'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c',
-  '_', 'v', 'p', 'k', 's', 'w', 's', 's', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  '_', 'v', 'p', 'k', 's', 'h', 'u', 's', '\000', '_', '_', 'b', 'u', 'i', 'l',
   't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'p', 'k',
-  's', 'w', 'u', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'p', 'k', 'u', 'd', 'u', 's',
+  's', 'w', 's', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'p', 'k', 's', 'w', 'u', 's',
   '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i',
-  'v', 'e', 'c', '_', 'v', 'p', 'k', 'u', 'h', 'u', 's', '\000', '_', '_', 'b',
+  'v', 'e', 'c', '_', 'v', 'p', 'k', 'u', 'd', 'u', 's', '\000', '_', '_', 'b',
   'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_',
-  'v', 'p', 'k', 'u', 'w', 'u', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'p', 'r', 't',
-  'y', 'b', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a',
-  'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'p', 'r', 't', 'y', 'b', 'q', '\000',
+  'v', 'p', 'k', 'u', 'h', 'u', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'p', 'k', 'u',
+  'w', 'u', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a',
+  'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'p', 'r', 't', 'y', 'b', 'd', '\000',
   '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v',
-  'e', 'c', '_', 'v', 'p', 'r', 't', 'y', 'b', 'w', '\000', '_', '_', 'b', 'u',
+  'e', 'c', '_', 'v', 'p', 'r', 't', 'y', 'b', 'q', '\000', '_', '_', 'b', 'u',
   'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v',
-  'r', 'e', 'f', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'r', 'f', 'i', 'm', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e',
-  'c', '_', 'v', 'r', 'f', 'i', 'n', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'r', 'f', 'i',
-  'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't',
-  'i', 'v', 'e', 'c', '_', 'v', 'r', 'f', 'i', 'z', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v',
-  'r', 'l', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a',
-  'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'r', 'l', 'd', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_',
-  'v', 'r', 'l', 'd', 'm', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'r', 'l', 'd', 'n',
-  'm', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't',
-  'i', 'v', 'e', 'c', '_', 'v', 'r', 'l', 'h', '\000', '_', '_', 'b', 'u', 'i',
+  'p', 'r', 't', 'y', 'b', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'r', 'e', 'f', 'p',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i',
+  'v', 'e', 'c', '_', 'v', 'r', 'f', 'i', 'm', '\000', '_', '_', 'b', 'u', 'i',
   'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'r',
-  'l', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l',
-  't', 'i', 'v', 'e', 'c', '_', 'v', 'r', 'l', 'w', 'm', 'i', '\000', '_', '_',
+  'f', 'i', 'n', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a',
+  'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'r', 'f', 'i', 'p', '\000', '_', '_',
   'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c',
-  '_', 'v', 'r', 'l', 'w', 'n', 'm', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'r', 's', 'q',
-  'r', 't', 'e', 'f', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 's', 'e', 'l', '_', '4',
-  's', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l',
-  't', 'i', 'v', 'e', 'c', '_', 'v', 's', 'l', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 's',
-  'l', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l',
-  't', 'i', 'v', 'e', 'c', '_', 'v', 's', 'l', 'h', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v',
-  's', 'l', 'o', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a',
-  'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 's', 'l', 'v', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_',
-  'v', 's', 'l', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 's', 'r', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_',
-  'v', 's', 'r', 'a', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 's', 'r', 'a', 'h', '\000',
+  '_', 'v', 'r', 'f', 'i', 'z', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'r', 'l', 'b', '\000',
   '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v',
-  'e', 'c', '_', 'v', 's', 'r', 'a', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 's', 'r',
-  'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't',
-  'i', 'v', 'e', 'c', '_', 'v', 's', 'r', 'h', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 's',
-  'r', 'o', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l',
-  't', 'i', 'v', 'e', 'c', '_', 'v', 's', 'r', 'v', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v',
-  's', 'r', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a',
-  'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 's', 'u', 'b', 'c', 'u', 'q', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v',
-  'e', 'c', '_', 'v', 's', 'u', 'b', 'c', 'u', 'w', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v',
-  's', 'u', 'b', 'e', 'c', 'u', 'q', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 's', 'u', 'b',
-  'e', 'u', 'q', 'm', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 's', 'u', 'b', 's', 'b', 's',
+  'e', 'c', '_', 'v', 'r', 'l', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'r', 'l', 'd',
+  'm', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l',
+  't', 'i', 'v', 'e', 'c', '_', 'v', 'r', 'l', 'd', 'n', 'm', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c',
+  '_', 'v', 'r', 'l', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'r', 'l', 'q', 'm', 'i',
   '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i',
-  'v', 'e', 'c', '_', 'v', 's', 'u', 'b', 's', 'h', 's', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_',
-  'v', 's', 'u', 'b', 's', 'w', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 's', 'u', 'b',
-  'u', 'b', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a',
-  'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 's', 'u', 'b', 'u', 'h', 's', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v',
-  'e', 'c', '_', 'v', 's', 'u', 'b', 'u', 'w', 's', '\000', '_', '_', 'b', 'u',
+  'v', 'e', 'c', '_', 'v', 'r', 'l', 'q', 'n', 'm', '\000', '_', '_', 'b', 'u',
   'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v',
-  's', 'u', 'm', '2', 's', 'w', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 's', 'u', 'm',
-  '4', 's', 'b', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 's', 'u', 'm', '4', 's', 'h',
-  's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't',
-  'i', 'v', 'e', 'c', '_', 'v', 's', 'u', 'm', '4', 'u', 'b', 's', '\000', '_',
+  'r', 'l', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a',
+  'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'r', 'l', 'w', 'm', 'i', '\000', '_',
   '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e',
-  'c', '_', 'v', 's', 'u', 'm', 's', 'w', 's', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'u',
-  'p', 'k', 'h', 'p', 'x', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'u', 'p', 'k', 'h', 's',
-  'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't',
-  'i', 'v', 'e', 'c', '_', 'v', 'u', 'p', 'k', 'h', 's', 'h', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c',
-  '_', 'v', 'u', 'p', 'k', 'h', 's', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'u', 'p',
-  'k', 'l', 'p', 'x', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'u', 'p', 'k', 'l', 's', 'b',
+  'c', '_', 'v', 'r', 'l', 'w', 'n', 'm', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'r', 's',
+  'q', 'r', 't', 'e', 'f', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 's', 'e', 'l', '_',
+  '4', 's', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a',
+  'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 's', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v',
+  's', 'l', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a',
+  'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 's', 'l', 'd', 'b', 'i', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e',
+  'c', '_', 'v', 's', 'l', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 's', 'l', 'o', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v',
+  'e', 'c', '_', 'v', 's', 'l', 'v', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 's', 'l', 'w',
   '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i',
-  'v', 'e', 'c', '_', 'v', 'u', 'p', 'k', 'l', 's', 'h', '\000', '_', '_', 'b',
+  'v', 'e', 'c', '_', 'v', 's', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 's', 'r', 'a',
+  'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't',
+  'i', 'v', 'e', 'c', '_', 'v', 's', 'r', 'a', 'h', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v',
+  's', 'r', 'a', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 's', 'r', 'b', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c',
+  '_', 'v', 's', 'r', 'd', 'b', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 's', 'r', 'h',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i',
+  'v', 'e', 'c', '_', 'v', 's', 'r', 'o', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 's', 'r',
+  'v', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't',
+  'i', 'v', 'e', 'c', '_', 'v', 's', 'r', 'w', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 's',
+  't', 'r', 'i', 'b', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 's', 't', 'r', 'i', 'b',
+  'l', '_', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a',
+  'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 's', 't', 'r', 'i', 'b', 'r', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v',
+  'e', 'c', '_', 'v', 's', 't', 'r', 'i', 'b', 'r', '_', 'p', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c',
+  '_', 'v', 's', 't', 'r', 'i', 'h', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 's', 't',
+  'r', 'i', 'h', 'l', '_', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 's', 't', 'r', 'i',
+  'h', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l',
+  't', 'i', 'v', 'e', 'c', '_', 'v', 's', 't', 'r', 'i', 'h', 'r', '_', 'p',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i',
+  'v', 'e', 'c', '_', 'v', 's', 'u', 'b', 'c', 'u', 'q', '\000', '_', '_', 'b',
   'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_',
-  'v', 'u', 'p', 'k', 'l', 's', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'b', 'p', 'e', 'r', 'm', 'd', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'd', 'c', 'b', 'f', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'd', 'i', 'v', 'd', 'e', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'd', 'i', 'v', 'd', 'e', 'u', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'd', 'i', 'v', 'f', '1', '2', '8',
-  '_', 'r', 'o', 'u', 'n', 'd', '_', 't', 'o', '_', 'o', 'd', 'd', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'd', 'i', 'v', 'w', 'e', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'd', 'i', 'v', 'w', 'e',
-  'u', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'f', 'm', 'a',
-  'f', '1', '2', '8', '_', 'r', 'o', 'u', 'n', 'd', '_', 't', 'o', '_', 'o',
-  'd', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'g', 'e',
-  't', '_', 't', 'e', 'x', 'a', 's', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'g', 'e', 't', '_', 't', 'e', 'x', 'a', 's', 'r', 'u',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'g', 'e', 't', '_',
-  't', 'f', 'h', 'a', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'g', 'e', 't', '_', 't', 'f', 'i', 'a', 'r', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'm', 'u', 'l', 'f', '1', '2', '8', '_', 'r',
-  'o', 'u', 'n', 'd', '_', 't', 'o', '_', 'o', 'd', 'd', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'q', 'p', 'x', '_', 'q', 'v', 'f', 'a',
-  'b', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'q', 'p',
-  'x', '_', 'q', 'v', 'f', 'a', 'd', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'q', 'p', 'x', '_', 'q', 'v', 'f', 'a', 'd', 'd', 's',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'q', 'p', 'x', '_',
-  'q', 'v', 'f', 'c', 'f', 'i', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'q', 'p', 'x', '_', 'q', 'v', 'f', 'c', 'f', 'i', 'd', 's',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'q', 'p', 'x', '_',
-  'q', 'v', 'f', 'c', 'f', 'i', 'd', 'u', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'q', 'p', 'x', '_', 'q', 'v', 'f', 'c', 'f', 'i', 'd',
-  'u', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'q', 'p',
-  'x', '_', 'q', 'v', 'f', 'c', 'm', 'p', 'e', 'q', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'q', 'p', 'x', '_', 'q', 'v', 'f', 'c', 'm',
-  'p', 'g', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'q',
-  'p', 'x', '_', 'q', 'v', 'f', 'c', 'm', 'p', 'l', 't', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'q', 'p', 'x', '_', 'q', 'v', 'f', 'c',
-  'p', 's', 'g', 'n', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'q', 'p', 'x', '_', 'q', 'v', 'f', 'c', 't', 'i', 'd', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'q', 'p', 'x', '_', 'q', 'v', 'f', 'c',
-  't', 'i', 'd', 'u', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'q', 'p', 'x', '_', 'q', 'v', 'f', 'c', 't', 'i', 'd', 'u', 'z', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'q', 'p', 'x', '_', 'q', 'v',
-  'f', 'c', 't', 'i', 'd', 'z', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'q', 'p', 'x', '_', 'q', 'v', 'f', 'c', 't', 'i', 'w', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'q', 'p', 'x', '_', 'q', 'v',
-  'f', 'c', 't', 'i', 'w', 'u', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'q', 'p', 'x', '_', 'q', 'v', 'f', 'c', 't', 'i', 'w', 'u', 'z',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'q', 'p', 'x', '_',
-  'q', 'v', 'f', 'c', 't', 'i', 'w', 'z', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'q', 'p', 'x', '_', 'q', 'v', 'f', 'l', 'o', 'g', 'i',
-  'c', 'a', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'q',
-  'p', 'x', '_', 'q', 'v', 'f', 'm', 'a', 'd', 'd', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'q', 'p', 'x', '_', 'q', 'v', 'f', 'm', 'a',
-  'd', 'd', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'q',
-  'p', 'x', '_', 'q', 'v', 'f', 'm', 's', 'u', 'b', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'q', 'p', 'x', '_', 'q', 'v', 'f', 'm', 's',
-  'u', 'b', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'q',
-  'p', 'x', '_', 'q', 'v', 'f', 'm', 'u', 'l', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'q', 'p', 'x', '_', 'q', 'v', 'f', 'm', 'u', 'l',
-  's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'q', 'p', 'x',
-  '_', 'q', 'v', 'f', 'n', 'a', 'b', 's', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'q', 'p', 'x', '_', 'q', 'v', 'f', 'n', 'e', 'g', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'q', 'p', 'x', '_', 'q',
-  'v', 'f', 'n', 'm', 'a', 'd', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'q', 'p', 'x', '_', 'q', 'v', 'f', 'n', 'm', 'a', 'd', 'd',
-  's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'q', 'p', 'x',
-  '_', 'q', 'v', 'f', 'n', 'm', 's', 'u', 'b', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'q', 'p', 'x', '_', 'q', 'v', 'f', 'n', 'm', 's',
-  'u', 'b', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'q',
-  'p', 'x', '_', 'q', 'v', 'f', 'p', 'e', 'r', 'm', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'q', 'p', 'x', '_', 'q', 'v', 'f', 'r', 'e',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'q', 'p', 'x', '_',
-  'q', 'v', 'f', 'r', 'e', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'q', 'p', 'x', '_', 'q', 'v', 'f', 'r', 'i', 'm', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'q', 'p', 'x', '_', 'q', 'v', 'f',
-  'r', 'i', 'n', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'q',
-  'p', 'x', '_', 'q', 'v', 'f', 'r', 'i', 'p', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'q', 'p', 'x', '_', 'q', 'v', 'f', 'r', 'i', 'z',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'q', 'p', 'x', '_',
-  'q', 'v', 'f', 'r', 's', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'q', 'p', 'x', '_', 'q', 'v', 'f', 'r', 's', 'q', 'r', 't', 'e',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'q', 'p', 'x', '_',
-  'q', 'v', 'f', 'r', 's', 'q', 'r', 't', 'e', 's', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'q', 'p', 'x', '_', 'q', 'v', 'f', 's', 'e',
-  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'q', 'p', 'x',
-  '_', 'q', 'v', 'f', 's', 'u', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'q', 'p', 'x', '_', 'q', 'v', 'f', 's', 'u', 'b', 's', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'q', 'p', 'x', '_', 'q',
-  'v', 'f', 't', 's', 't', 'n', 'a', 'n', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'q', 'p', 'x', '_', 'q', 'v', 'f', 'x', 'm', 'a', 'd',
-  'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'q', 'p', 'x',
-  '_', 'q', 'v', 'f', 'x', 'm', 'a', 'd', 'd', 's', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'q', 'p', 'x', '_', 'q', 'v', 'f', 'x', 'm',
-  'u', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'q', 'p',
-  'x', '_', 'q', 'v', 'f', 'x', 'm', 'u', 'l', 's', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'q', 'p', 'x', '_', 'q', 'v', 'f', 'x', 'x',
-  'c', 'p', 'n', 'm', 'a', 'd', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'q', 'p', 'x', '_', 'q', 'v', 'f', 'x', 'x', 'c', 'p', 'n',
-  'm', 'a', 'd', 'd', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'q', 'p', 'x', '_', 'q', 'v', 'f', 'x', 'x', 'm', 'a', 'd', 'd', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'q', 'p', 'x', '_', 'q',
-  'v', 'f', 'x', 'x', 'm', 'a', 'd', 'd', 's', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'q', 'p', 'x', '_', 'q', 'v', 'f', 'x', 'x', 'n',
-  'p', 'm', 'a', 'd', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'q', 'p', 'x', '_', 'q', 'v', 'f', 'x', 'x', 'n', 'p', 'm', 'a', 'd',
-  'd', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'q', 'p',
-  'x', '_', 'q', 'v', 'g', 'p', 'c', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'q', 'p', 'x', '_', 'q', 'v', 'l', 'f', 'c', 'd', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'q', 'p', 'x', '_', 'q',
-  'v', 'l', 'f', 'c', 'd', 'a', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'q', 'p', 'x', '_', 'q', 'v', 'l', 'f', 'c', 's', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'q', 'p', 'x', '_', 'q', 'v', 'l',
-  'f', 'c', 's', 'a', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'q', 'p', 'x', '_', 'q', 'v', 'l', 'f', 'd', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'q', 'p', 'x', '_', 'q', 'v', 'l', 'f', 'd', 'a',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'q', 'p', 'x', '_',
-  'q', 'v', 'l', 'f', 'i', 'w', 'a', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'q', 'p', 'x', '_', 'q', 'v', 'l', 'f', 'i', 'w', 'a', 'a',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'q', 'p', 'x', '_',
-  'q', 'v', 'l', 'f', 'i', 'w', 'z', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'q', 'p', 'x', '_', 'q', 'v', 'l', 'f', 'i', 'w', 'z', 'a',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'q', 'p', 'x', '_',
-  'q', 'v', 'l', 'f', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'q', 'p', 'x', '_', 'q', 'v', 'l', 'f', 's', 'a', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'q', 'p', 'x', '_', 'q', 'v', 'l', 'p',
-  'c', 'l', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'q',
-  'p', 'x', '_', 'q', 'v', 'l', 'p', 'c', 'l', 's', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'q', 'p', 'x', '_', 'q', 'v', 'l', 'p', 'c',
-  'r', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'q', 'p',
-  'x', '_', 'q', 'v', 'l', 'p', 'c', 'r', 's', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'q', 'p', 'x', '_', 'q', 'v', 's', 't', 'f', 'c',
-  'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'q', 'p', 'x',
-  '_', 'q', 'v', 's', 't', 'f', 'c', 'd', 'a', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'q', 'p', 'x', '_', 'q', 'v', 's', 't', 'f', 'c',
-  's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'q', 'p', 'x',
-  '_', 'q', 'v', 's', 't', 'f', 'c', 's', 'a', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'q', 'p', 'x', '_', 'q', 'v', 's', 't', 'f', 'd',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'q', 'p', 'x', '_',
-  'q', 'v', 's', 't', 'f', 'd', 'a', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'q', 'p', 'x', '_', 'q', 'v', 's', 't', 'f', 'i', 'w', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'q', 'p', 'x', '_', 'q',
-  'v', 's', 't', 'f', 'i', 'w', 'a', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'q', 'p', 'x', '_', 'q', 'v', 's', 't', 'f', 's', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'q', 'p', 'x', '_', 'q', 'v',
-  's', 't', 'f', 's', 'a', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'v', 's', 'x', '_', 's', 'c', 'a', 'l', 'a', 'r', '_', 'e', 'x', 't',
-  'r', 'a', 'c', 't', '_', 'e', 'x', 'p', 'q', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'v', 's', 'x', '_', 's', 'c', 'a', 'l', 'a', 'r',
-  '_', 'i', 'n', 's', 'e', 'r', 't', '_', 'e', 'x', 'p', '_', 'q', 'p', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', 'e', 't', '_', 't',
+  'v', 's', 'u', 'b', 'c', 'u', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 's', 'u', 'b',
+  'e', 'c', 'u', 'q', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 's', 'u', 'b', 'e', 'u', 'q',
+  'm', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't',
+  'i', 'v', 'e', 'c', '_', 'v', 's', 'u', 'b', 's', 'b', 's', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c',
+  '_', 'v', 's', 'u', 'b', 's', 'h', 's', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 's', 'u',
+  'b', 's', 'w', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 's', 'u', 'b', 'u', 'b', 's',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i',
+  'v', 'e', 'c', '_', 'v', 's', 'u', 'b', 'u', 'h', 's', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_',
+  'v', 's', 'u', 'b', 'u', 'w', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 's', 'u', 'm',
+  '2', 's', 'w', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 's', 'u', 'm', '4', 's', 'b',
+  's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't',
+  'i', 'v', 'e', 'c', '_', 'v', 's', 'u', 'm', '4', 's', 'h', 's', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e',
+  'c', '_', 'v', 's', 'u', 'm', '4', 'u', 'b', 's', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v',
+  's', 'u', 'm', 's', 'w', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'u', 'p', 'k', 'h',
+  'p', 'x', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l',
+  't', 'i', 'v', 'e', 'c', '_', 'v', 'u', 'p', 'k', 'h', 's', 'b', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e',
+  'c', '_', 'v', 'u', 'p', 'k', 'h', 's', 'h', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'u',
+  'p', 'k', 'h', 's', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'u', 'p', 'k', 'l', 'p',
+  'x', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't',
+  'i', 'v', 'e', 'c', '_', 'v', 'u', 'p', 'k', 'l', 's', 'b', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c',
+  '_', 'v', 'u', 'p', 'k', 'l', 's', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'a', 'l', 't', 'i', 'v', 'e', 'c', '_', 'v', 'u', 'p',
+  'k', 'l', 's', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'b', 'p', 'e', 'r', 'm', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'c', 'f', 'u', 'g', 'e', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'c', 'n', 't', 'l', 'z', 'd', 'm', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'c', 'n', 't', 't', 'z', 'd', 'm', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'd', 'a', 'r', 'n', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'd', 'a', 'r', 'n', '_',
+  '3', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'd', 'a',
+  'r', 'n', '_', 'r', 'a', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'd', 'c', 'b', 'f', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'd', 'i', 'v', 'd', 'e', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'd', 'i', 'v', 'd', 'e', 'u', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'd', 'i', 'v', 'f', '1', '2', '8', '_', 'r', 'o',
+  'u', 'n', 'd', '_', 't', 'o', '_', 'o', 'd', 'd', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'd', 'i', 'v', 'w', 'e', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'd', 'i', 'v', 'w', 'e', 'u', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'f', 'm', 'a', 'f', '1', '2',
+  '8', '_', 'r', 'o', 'u', 'n', 'd', '_', 't', 'o', '_', 'o', 'd', 'd', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'g', 'e', 't', '_', 't',
   'e', 'x', 'a', 's', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 's', 'e', 't', '_', 't', 'e', 'x', 'a', 's', 'r', 'u', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', 'e', 't', '_', 't', 'f', 'h',
-  'a', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', 'e',
+  '_', 'g', 'e', 't', '_', 't', 'e', 'x', 'a', 's', 'r', 'u', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'g', 'e', 't', '_', 't', 'f', 'h',
+  'a', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'g', 'e',
   't', '_', 't', 'f', 'i', 'a', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 's', 'e', 't', 'r', 'n', 'd', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 's', 'q', 'r', 't', 'f', '1', '2', '8', '_', 'r',
-  'o', 'u', 'n', 'd', '_', 't', 'o', '_', 'o', 'd', 'd', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 's', 'u', 'b', 'f', '1', '2', '8', '_',
-  'r', 'o', 'u', 'n', 'd', '_', 't', 'o', '_', 'o', 'd', 'd', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 't', 'a', 'b', 'o', 'r', 't', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 't', 'a', 'b', 'o', 'r',
-  't', 'd', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 't',
-  'a', 'b', 'o', 'r', 't', 'd', 'c', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 't', 'a', 'b', 'o', 'r', 't', 'w', 'c', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 't', 'a', 'b', 'o', 'r', 't', 'w',
-  'c', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 't', 'b',
-  'e', 'g', 'i', 'n', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  't', 'c', 'h', 'e', 'c', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 't', 'e', 'n', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 't', 'e', 'n', 'd', 'a', 'l', 'l', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 't', 'r', 'e', 'c', 'h', 'k', 'p', 't', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 't', 'r', 'e', 'c', 'l', 'a',
-  'i', 'm', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 't', 'r',
-  'e', 's', 'u', 'm', 'e', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 't', 'r', 'u', 'n', 'c', 'f', '1', '2', '8', '_', 'r', 'o', 'u', 'n',
+  'i', 'n', '_', 'm', 'u', 'l', 'f', '1', '2', '8', '_', 'r', 'o', 'u', 'n',
   'd', '_', 't', 'o', '_', 'o', 'd', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 't', 's', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 't', 's', 'u', 's', 'p', 'e', 'n', 'd', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 't', 't', 'e', 's', 't', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 's', 'x', '_', 'x', 's', 'm',
-  'a', 'x', 'd', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'v', 's', 'x', '_', 'x', 's', 'm', 'i', 'n', 'd', 'p', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 's', 'x', '_', 'x', 'v', 'c', 'm',
-  'p', 'e', 'q', 'd', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'v', 's', 'x', '_', 'x', 'v', 'c', 'm', 'p', 'e', 'q', 'd', 'p', '_',
-  'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 's', 'x',
-  '_', 'x', 'v', 'c', 'm', 'p', 'e', 'q', 's', 'p', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'v', 's', 'x', '_', 'x', 'v', 'c', 'm', 'p',
-  'e', 'q', 's', 'p', '_', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'v', 's', 'x', '_', 'x', 'v', 'c', 'm', 'p', 'g', 'e', 'd', 'p',
+  't', 'i', 'n', '_', 'p', 'd', 'e', 'p', 'd', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'p', 'e', 'x', 't', 'd', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'r', 'e', 'a', 'd', 'f', 'l', 'm', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 's', 'x', '_', 's', 'c',
+  'a', 'l', 'a', 'r', '_', 'e', 'x', 't', 'r', 'a', 'c', 't', '_', 'e', 'x',
+  'p', 'q', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 's',
+  'x', '_', 's', 'c', 'a', 'l', 'a', 'r', '_', 'i', 'n', 's', 'e', 'r', 't',
+  '_', 'e', 'x', 'p', '_', 'q', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 's', 'e', 't', '_', 't', 'e', 'x', 'a', 's', 'r', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', 'e', 't', '_', 't', 'e',
+  'x', 'a', 's', 'r', 'u', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 's', 'e', 't', '_', 't', 'f', 'h', 'a', 'r', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 's', 'e', 't', '_', 't', 'f', 'i', 'a', 'r',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', 'e', 't', 'f',
+  'l', 'm', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', 'e',
+  't', 'r', 'n', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  's', 'q', 'r', 't', 'f', '1', '2', '8', '_', 'r', 'o', 'u', 'n', 'd', '_',
+  't', 'o', '_', 'o', 'd', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 's', 'u', 'b', 'f', '1', '2', '8', '_', 'r', 'o', 'u', 'n', 'd',
+  '_', 't', 'o', '_', 'o', 'd', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 't', 'a', 'b', 'o', 'r', 't', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 't', 'a', 'b', 'o', 'r', 't', 'd', 'c', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 't', 'a', 'b', 'o', 'r', 't',
+  'd', 'c', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 't',
+  'a', 'b', 'o', 'r', 't', 'w', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 't', 'a', 'b', 'o', 'r', 't', 'w', 'c', 'i', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 't', 'b', 'e', 'g', 'i', 'n', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 't', 'c', 'h', 'e', 'c',
+  'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 't', 'e', 'n',
+  'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 't', 'e', 'n',
+  'd', 'a', 'l', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  't', 'r', 'e', 'c', 'h', 'k', 'p', 't', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 't', 'r', 'e', 'c', 'l', 'a', 'i', 'm', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 't', 'r', 'e', 's', 'u', 'm', 'e',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 't', 'r', 'u', 'n',
+  'c', 'f', '1', '2', '8', '_', 'r', 'o', 'u', 'n', 'd', '_', 't', 'o', '_',
+  'o', 'd', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 't',
+  's', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 't', 's',
+  'u', 's', 'p', 'e', 'n', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 't', 't', 'e', 's', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 's', 'x', '_', 'x', 's', 'm', 'a', 'x', 'd', 'p', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 's', 'x', '_', 'x',
+  's', 'm', 'i', 'n', 'd', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'v', 's', 'x', '_', 'x', 'v', 'c', 'm', 'p', 'e', 'q', 'd', 'p',
   '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 's', 'x', '_',
-  'x', 'v', 'c', 'm', 'p', 'g', 'e', 'd', 'p', '_', 'p', '\000', '_', '_', 'b',
+  'x', 'v', 'c', 'm', 'p', 'e', 'q', 'd', 'p', '_', 'p', '\000', '_', '_', 'b',
   'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 's', 'x', '_', 'x', 'v', 'c', 'm',
-  'p', 'g', 'e', 's', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'v', 's', 'x', '_', 'x', 'v', 'c', 'm', 'p', 'g', 'e', 's', 'p', '_',
+  'p', 'e', 'q', 's', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 's', 'x', '_', 'x', 'v', 'c', 'm', 'p', 'e', 'q', 's', 'p', '_',
   'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 's', 'x',
-  '_', 'x', 'v', 'c', 'm', 'p', 'g', 't', 'd', 'p', '\000', '_', '_', 'b', 'u',
+  '_', 'x', 'v', 'c', 'm', 'p', 'g', 'e', 'd', 'p', '\000', '_', '_', 'b', 'u',
   'i', 'l', 't', 'i', 'n', '_', 'v', 's', 'x', '_', 'x', 'v', 'c', 'm', 'p',
-  'g', 't', 'd', 'p', '_', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'v', 's', 'x', '_', 'x', 'v', 'c', 'm', 'p', 'g', 't', 's', 'p',
+  'g', 'e', 'd', 'p', '_', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'v', 's', 'x', '_', 'x', 'v', 'c', 'm', 'p', 'g', 'e', 's', 'p',
   '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 's', 'x', '_',
-  'x', 'v', 'c', 'm', 'p', 'g', 't', 's', 'p', '_', 'p', '\000', '_', '_', 'b',
+  'x', 'v', 'c', 'm', 'p', 'g', 'e', 's', 'p', '_', 'p', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 's', 'x', '_', 'x', 'v', 'c', 'm',
+  'p', 'g', 't', 'd', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 's', 'x', '_', 'x', 'v', 'c', 'm', 'p', 'g', 't', 'd', 'p', '_',
+  'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 's', 'x',
+  '_', 'x', 'v', 'c', 'm', 'p', 'g', 't', 's', 'p', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 's', 'x', '_', 'x', 'v', 'c', 'm', 'p',
+  'g', 't', 's', 'p', '_', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'v', 's', 'x', '_', 'x', 'v', 'c', 'v', 'b', 'f', '1', '6', 's',
+  'p', 'n', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 's',
+  'x', '_', 'x', 'v', 'c', 'v', 'd', 'p', 's', 'p', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 's', 'x', '_', 'x', 'v', 'c', 'v', 'd',
+  'p', 's', 'x', 'w', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 's', 'x', '_', 'x', 'v', 'c', 'v', 'd', 'p', 'u', 'x', 'w', 's',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 's', 'x', '_',
+  'x', 'v', 'c', 'v', 'h', 'p', 's', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 's', 'x', '_', 'x', 'v', 'c', 'v', 's', 'p', 'b',
+  'f', '1', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  's', 'x', '_', 'x', 'v', 'c', 'v', 's', 'p', 'd', 'p', '\000', '_', '_', 'b',
   'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 's', 'x', '_', 'x', 'v', 'c', 'v',
-  'd', 'p', 's', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'v', 's', 'x', '_', 'x', 'v', 'c', 'v', 'd', 'p', 's', 'x', 'w', 's', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 's', 'x', '_', 'x',
-  'v', 'c', 'v', 'd', 'p', 'u', 'x', 'w', 's', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'v', 's', 'x', '_', 'x', 'v', 'c', 'v', 'h', 'p',
-  's', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 's',
-  'x', '_', 'x', 'v', 'c', 'v', 's', 'p', 'd', 'p', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'v', 's', 'x', '_', 'x', 'v', 'c', 'v', 's',
-  'p', 'h', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
-  's', 'x', '_', 'x', 'v', 'c', 'v', 's', 'x', 'd', 's', 'p', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 's', 'x', '_', 'x', 'v', 'c',
-  'v', 's', 'x', 'w', 'd', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'v', 's', 'x', '_', 'x', 'v', 'c', 'v', 'u', 'x', 'd', 's', 'p',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 's', 'x', '_',
-  'x', 'v', 'c', 'v', 'u', 'x', 'w', 'd', 'p', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'v', 's', 'x', '_', 'x', 'v', 'd', 'i', 'v', 'd',
-  'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 's', 'x',
-  '_', 'x', 'v', 'd', 'i', 'v', 's', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'v', 's', 'x', '_', 'x', 'v', 'i', 'e', 'x', 'p', 'd',
-  'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 's', 'x',
-  '_', 'x', 'v', 'i', 'e', 'x', 'p', 's', 'p', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'v', 's', 'x', '_', 'x', 'v', 'm', 'a', 'x', 'd',
-  'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 's', 'x',
-  '_', 'x', 'v', 'm', 'a', 'x', 's', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'v', 's', 'x', '_', 'x', 'v', 'm', 'i', 'n', 'd', 'p',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 's', 'x', '_',
-  'x', 'v', 'm', 'i', 'n', 's', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'v', 's', 'x', '_', 'x', 'v', 'r', 'e', 'd', 'p', '\000', '_',
+  's', 'p', 'h', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 's', 'x', '_', 'x', 'v', 'c', 'v', 's', 'x', 'd', 's', 'p', '\000', '_',
   '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 's', 'x', '_', 'x', 'v',
-  'r', 'e', 's', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'v', 's', 'x', '_', 'x', 'v', 'r', 's', 'q', 'r', 't', 'e', 'd', 'p', '\000',
+  'c', 'v', 's', 'x', 'w', 'd', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 's', 'x', '_', 'x', 'v', 'c', 'v', 'u', 'x', 'd', 's',
+  'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 's', 'x',
+  '_', 'x', 'v', 'c', 'v', 'u', 'x', 'w', 'd', 'p', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 's', 'x', '_', 'x', 'v', 'd', 'i', 'v',
+  'd', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 's',
+  'x', '_', 'x', 'v', 'd', 'i', 'v', 's', 'p', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 's', 'x', '_', 'x', 'v', 'i', 'e', 'x', 'p',
+  'd', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 's',
+  'x', '_', 'x', 'v', 'i', 'e', 'x', 'p', 's', 'p', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 's', 'x', '_', 'x', 'v', 'm', 'a', 'x',
+  'd', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 's',
+  'x', '_', 'x', 'v', 'm', 'a', 'x', 's', 'p', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 's', 'x', '_', 'x', 'v', 'm', 'i', 'n', 'd',
+  'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 's', 'x',
+  '_', 'x', 'v', 'm', 'i', 'n', 's', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 's', 'x', '_', 'x', 'v', 'r', 'e', 'd', 'p', '\000',
   '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 's', 'x', '_', 'x',
-  'v', 'r', 's', 'q', 'r', 't', 'e', 's', 'p', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'v', 's', 'x', '_', 'x', 'v', 't', 's', 't', 'd',
-  'c', 'd', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
-  's', 'x', '_', 'x', 'v', 't', 's', 't', 'd', 'c', 's', 'p', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 's', 'x', '_', 'x', 'v', 'x',
-  'e', 'x', 'p', 'd', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'v', 's', 'x', '_', 'x', 'v', 'x', 'e', 'x', 'p', 's', 'p', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 's', 'x', '_', 'x', 'v',
-  'x', 's', 'i', 'g', 'd', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'v', 's', 'x', '_', 'x', 'v', 'x', 's', 'i', 'g', 's', 'p', '\000',
+  'v', 'r', 'e', 's', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 's', 'x', '_', 'x', 'v', 'r', 's', 'q', 'r', 't', 'e', 'd', 'p',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 's', 'x', '_',
+  'x', 'v', 'r', 's', 'q', 'r', 't', 'e', 's', 'p', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 's', 'x', '_', 'x', 'v', 't', 'd', 'i',
+  'v', 'd', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  's', 'x', '_', 'x', 'v', 't', 'd', 'i', 'v', 's', 'p', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 's', 'x', '_', 'x', 'v', 't', 'l',
+  's', 'b', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  's', 'x', '_', 'x', 'v', 't', 's', 'q', 'r', 't', 'd', 'p', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 's', 'x', '_', 'x', 'v', 't',
+  's', 'q', 'r', 't', 's', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'v', 's', 'x', '_', 'x', 'v', 't', 's', 't', 'd', 'c', 'd', 'p',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 's', 'x', '_',
+  'x', 'v', 't', 's', 't', 'd', 'c', 's', 'p', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 's', 'x', '_', 'x', 'v', 'x', 'e', 'x', 'p',
+  'd', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 's',
+  'x', '_', 'x', 'v', 'x', 'e', 'x', 'p', 's', 'p', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 's', 'x', '_', 'x', 'v', 'x', 's', 'i',
+  'g', 'd', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  's', 'x', '_', 'x', 'v', 'x', 's', 'i', 'g', 's', 'p', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 's', 'x', '_', 'x', 'x', 'b', 'l',
+  'e', 'n', 'd', 'v', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 's', 'x', '_', 'x', 'x', 'b', 'l', 'e', 'n', 'd', 'v', 'd', '\000',
   '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 's', 'x', '_', 'x',
-  'x', 'e', 'x', 't', 'r', 'a', 'c', 't', 'u', 'w', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'v', 's', 'x', '_', 'x', 'x', 'i', 'n', 's',
-  'e', 'r', 't', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'v', 's', 'x', '_', 'x', 'x', 'l', 'e', 'q', 'v', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'r', '6', '0', '0', '_', 'g', 'r', 'o', 'u',
-  'p', '_', 'b', 'a', 'r', 'r', 'i', 'e', 'r', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'r', '6', '0', '0', '_', 'i', 'm', 'p', 'l', 'i',
-  'c', 'i', 't', 'a', 'r', 'g', '_', 'p', 't', 'r', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'r', '6', '0', '0', '_', 'r', 'a', 't', '_',
-  's', 't', 'o', 'r', 'e', '_', 't', 'y', 'p', 'e', 'd', '\000', '_', '_', 'b',
+  'x', 'b', 'l', 'e', 'n', 'd', 'v', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 's', 'x', '_', 'x', 'x', 'b', 'l', 'e', 'n', 'd',
+  'v', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 's',
+  'x', '_', 'x', 'x', 'e', 'v', 'a', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 's', 'x', '_', 'x', 'x', 'e', 'x', 't', 'r', 'a',
+  'c', 't', 'u', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 's', 'x', '_', 'x', 'x', 'g', 'e', 'n', 'p', 'c', 'v', 'b', 'm', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 's', 'x', '_', 'x',
+  'x', 'g', 'e', 'n', 'p', 'c', 'v', 'd', 'm', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 's', 'x', '_', 'x', 'x', 'g', 'e', 'n', 'p',
+  'c', 'v', 'h', 'm', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 's', 'x', '_', 'x', 'x', 'g', 'e', 'n', 'p', 'c', 'v', 'w', 'm', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 's', 'x', '_', 'x',
+  'x', 'i', 'n', 's', 'e', 'r', 't', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 's', 'x', '_', 'x', 'x', 'l', 'e', 'q', 'v', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 's', 'x', '_', 'x',
+  'x', 'p', 'e', 'r', 'm', 'x', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'r', '6', '0', '0', '_', 'g', 'r', 'o', 'u', 'p', '_', 'b', 'a',
+  'r', 'r', 'i', 'e', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'r', '6', '0', '0', '_', 'i', 'm', 'p', 'l', 'i', 'c', 'i', 't', 'a',
+  'r', 'g', '_', 'p', 't', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'r', '6', '0', '0', '_', 'r', 'a', 't', '_', 's', 't', 'o', 'r',
+  'e', '_', 't', 'y', 'p', 'e', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'r', '6', '0', '0', '_', 'r', 'e', 'a', 'd', '_', 'g', 'l',
+  'o', 'b', 'a', 'l', '_', 's', 'i', 'z', 'e', '_', 'x', '\000', '_', '_', 'b',
   'u', 'i', 'l', 't', 'i', 'n', '_', 'r', '6', '0', '0', '_', 'r', 'e', 'a',
-  'd', '_', 'g', 'l', 'o', 'b', 'a', 'l', '_', 's', 'i', 'z', 'e', '_', 'x',
+  'd', '_', 'g', 'l', 'o', 'b', 'a', 'l', '_', 's', 'i', 'z', 'e', '_', 'y',
   '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'r', '6', '0', '0',
   '_', 'r', 'e', 'a', 'd', '_', 'g', 'l', 'o', 'b', 'a', 'l', '_', 's', 'i',
-  'z', 'e', '_', 'y', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'r', '6', '0', '0', '_', 'r', 'e', 'a', 'd', '_', 'g', 'l', 'o', 'b', 'a',
-  'l', '_', 's', 'i', 'z', 'e', '_', 'z', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'r', '6', '0', '0', '_', 'r', 'e', 'a', 'd', '_', 'n',
-  'g', 'r', 'o', 'u', 'p', 's', '_', 'x', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'r', '6', '0', '0', '_', 'r', 'e', 'a', 'd', '_', 'n',
-  'g', 'r', 'o', 'u', 'p', 's', '_', 'y', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'r', '6', '0', '0', '_', 'r', 'e', 'a', 'd', '_', 'n',
-  'g', 'r', 'o', 'u', 'p', 's', '_', 'z', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'r', '6', '0', '0', '_', 'r', 'e', 'a', 'd', '_', 't',
-  'g', 'i', 'd', '_', 'x', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'r', '6', '0', '0', '_', 'r', 'e', 'a', 'd', '_', 't', 'g', 'i', 'd',
-  '_', 'y', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'r', '6',
-  '0', '0', '_', 'r', 'e', 'a', 'd', '_', 't', 'g', 'i', 'd', '_', 'z', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_',
-  'e', 'f', 'p', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  't', 'x', '_', 'n', 'e', 's', 't', 'i', 'n', 'g', '_', 'd', 'e', 'p', 't',
-  'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9',
-  '0', '_', 'l', 'c', 'b', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 't', 'x', '_', 'a', 's', 's', 'i', 's', 't', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 's', 'f', 'p',
-  'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9',
-  '0', '_', 'v', 'a', 'c', 'c', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'a', 'c', 'c', 'c', 'q', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_',
-  'v', 'a', 'c', 'c', 'f', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 's', '3', '9', '0', '_', 'v', 'a', 'c', 'c', 'g', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'a', 'c',
-  'c', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3',
-  '9', '0', '_', 'v', 'a', 'c', 'c', 'q', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'a', 'c', 'q', '\000', '_',
+  'z', 'e', '_', 'z', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'r', '6', '0', '0', '_', 'r', 'e', 'a', 'd', '_', 'n', 'g', 'r', 'o', 'u',
+  'p', 's', '_', 'x', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'r', '6', '0', '0', '_', 'r', 'e', 'a', 'd', '_', 'n', 'g', 'r', 'o', 'u',
+  'p', 's', '_', 'y', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'r', '6', '0', '0', '_', 'r', 'e', 'a', 'd', '_', 'n', 'g', 'r', 'o', 'u',
+  'p', 's', '_', 'z', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'r', '6', '0', '0', '_', 'r', 'e', 'a', 'd', '_', 't', 'g', 'i', 'd', '_',
+  'x', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'r', '6', '0',
+  '0', '_', 'r', 'e', 'a', 'd', '_', 't', 'g', 'i', 'd', '_', 'y', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'r', '6', '0', '0', '_', 'r',
+  'e', 'a', 'd', '_', 't', 'g', 'i', 'd', '_', 'z', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'e', 'f', 'p', 'c',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 't', 'x', '_', 'n',
+  'e', 's', 't', 'i', 'n', 'g', '_', 'd', 'e', 'p', 't', 'h', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'l', 'c',
+  'b', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 't', 'x',
+  '_', 'a', 's', 's', 'i', 's', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 's', '3', '9', '0', '_', 's', 'f', 'p', 'c', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'a',
+  'c', 'c', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's',
+  '3', '9', '0', '_', 'v', 'a', 'c', 'c', 'c', 'q', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'a', 'c', 'c',
+  'f', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9',
+  '0', '_', 'v', 'a', 'c', 'c', 'g', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'a', 'c', 'c', 'h', '\000', '_',
   '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v',
-  'a', 'q', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3',
-  '9', '0', '_', 'v', 'a', 'v', 'g', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'a', 'v', 'g', 'f', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_',
-  'v', 'a', 'v', 'g', 'g', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 's', '3', '9', '0', '_', 'v', 'a', 'v', 'g', 'h', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'a', 'v',
-  'g', 'l', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's',
-  '3', '9', '0', '_', 'v', 'a', 'v', 'g', 'l', 'f', '\000', '_', '_', 'b', 'u',
+  'a', 'c', 'c', 'q', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  's', '3', '9', '0', '_', 'v', 'a', 'c', 'q', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'a', 'q', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v',
+  'a', 'v', 'g', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  's', '3', '9', '0', '_', 'v', 'a', 'v', 'g', 'f', '\000', '_', '_', 'b', 'u',
   'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'a', 'v', 'g',
-  'l', 'g', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3',
-  '9', '0', '_', 'v', 'a', 'v', 'g', 'l', 'h', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'b', 'p', 'e', 'r',
-  'm', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9',
-  '0', '_', 'v', 'c', 'k', 's', 'm', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'e', 'r', 'i', 'm', 'b', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_',
-  'v', 'e', 'r', 'i', 'm', 'f', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 's', '3', '9', '0', '_', 'v', 'e', 'r', 'i', 'm', 'g', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v',
-  'e', 'r', 'i', 'm', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 's', '3', '9', '0', '_', 'v', 'e', 'r', 'l', 'l', 'b', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'e',
-  'r', 'l', 'l', 'f', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  's', '3', '9', '0', '_', 'v', 'e', 'r', 'l', 'l', 'g', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'e', 'r',
-  'l', 'l', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's',
-  '3', '9', '0', '_', 'v', 'e', 'r', 'l', 'l', 'v', 'b', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'e', 'r',
-  'l', 'l', 'v', 'f', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  's', '3', '9', '0', '_', 'v', 'e', 'r', 'l', 'l', 'v', 'g', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'e',
-  'r', 'l', 'l', 'v', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 's', '3', '9', '0', '_', 'v', 'f', 'a', 'e', 'b', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'f', 'a',
-  'e', 'f', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3',
-  '9', '0', '_', 'v', 'f', 'a', 'e', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'f', 'a', 'e', 'z', 'b',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0',
-  '_', 'v', 'f', 'a', 'e', 'z', 'f', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'f', 'a', 'e', 'z', 'h', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_',
-  'v', 'f', 'e', 'e', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 's', '3', '9', '0', '_', 'v', 'f', 'e', 'e', 'f', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'f', 'e',
-  'e', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3',
-  '9', '0', '_', 'v', 'f', 'e', 'e', 'z', 'b', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'f', 'e', 'e', 'z',
-  'f', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9',
-  '0', '_', 'v', 'f', 'e', 'e', 'z', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'f', 'e', 'n', 'e', 'b',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0',
-  '_', 'v', 'f', 'e', 'n', 'e', 'f', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'f', 'e', 'n', 'e', 'h', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_',
-  'v', 'f', 'e', 'n', 'e', 'z', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'f', 'e', 'n', 'e', 'z', 'f',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0',
-  '_', 'v', 'f', 'e', 'n', 'e', 'z', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'g', 'f', 'm', 'a', 'b',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0',
-  '_', 'v', 'g', 'f', 'm', 'a', 'f', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'g', 'f', 'm', 'a', 'g', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_',
-  'v', 'g', 'f', 'm', 'a', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 's', '3', '9', '0', '_', 'v', 'g', 'f', 'm', 'b', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'g',
-  'f', 'm', 'f', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's',
-  '3', '9', '0', '_', 'v', 'g', 'f', 'm', 'g', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'g', 'f', 'm', 'h',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0',
-  '_', 'v', 'i', 's', 't', 'r', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'i', 's', 't', 'r', 'f', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_',
-  'v', 'i', 's', 't', 'r', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 's', '3', '9', '0', '_', 'v', 'l', 'b', 'b', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'l', 'l',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0',
-  '_', 'v', 'l', 'r', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 's', '3', '9', '0', '_', 'v', 'm', 'a', 'e', 'b', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'm', 'a',
-  'e', 'f', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3',
-  '9', '0', '_', 'v', 'm', 'a', 'e', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'm', 'a', 'h', 'b', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_',
-  'v', 'm', 'a', 'h', 'f', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 's', '3', '9', '0', '_', 'v', 'm', 'a', 'h', 'h', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'm', 'a',
-  'l', 'e', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's',
-  '3', '9', '0', '_', 'v', 'm', 'a', 'l', 'e', 'f', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'm', 'a', 'l',
-  'e', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3',
-  '9', '0', '_', 'v', 'm', 'a', 'l', 'h', 'b', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'm', 'a', 'l', 'h',
-  'f', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9',
-  '0', '_', 'v', 'm', 'a', 'l', 'h', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'm', 'a', 'l', 'o', 'b',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0',
-  '_', 'v', 'm', 'a', 'l', 'o', 'f', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'm', 'a', 'l', 'o', 'h', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_',
-  'v', 'm', 'a', 'o', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 's', '3', '9', '0', '_', 'v', 'm', 'a', 'o', 'f', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'm', 'a',
-  'o', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3',
-  '9', '0', '_', 'v', 'm', 'e', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'm', 'e', 'f', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'm',
-  'e', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3',
-  '9', '0', '_', 'v', 'm', 'h', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'm', 'h', 'f', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'm',
-  'h', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3',
-  '9', '0', '_', 'v', 'm', 'l', 'e', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'm', 'l', 'e', 'f', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_',
-  'v', 'm', 'l', 'e', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 's', '3', '9', '0', '_', 'v', 'm', 'l', 'h', 'b', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'm', 'l',
-  'h', 'f', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3',
-  '9', '0', '_', 'v', 'm', 'l', 'h', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'm', 'l', 'o', 'b', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_',
-  'v', 'm', 'l', 'o', 'f', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 's', '3', '9', '0', '_', 'v', 'm', 'l', 'o', 'h', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'm', 'o',
-  'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9',
-  '0', '_', 'v', 'm', 'o', 'f', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 's', '3', '9', '0', '_', 'v', 'm', 'o', 'h', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'm', 's',
-  'l', 'g', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3',
-  '9', '0', '_', 'v', 'p', 'd', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'p', 'e', 'r', 'm', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v',
-  'p', 'k', 'l', 's', 'f', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 's', '3', '9', '0', '_', 'v', 'p', 'k', 'l', 's', 'g', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'p',
-  'k', 'l', 's', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  's', '3', '9', '0', '_', 'v', 'p', 'k', 's', 'f', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'p', 'k', 's',
   'g', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9',
-  '0', '_', 'v', 'p', 'k', 's', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 's', 'b', 'c', 'b', 'i', 'q',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0',
-  '_', 'v', 's', 'b', 'i', 'q', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 's', '3', '9', '0', '_', 'v', 's', 'c', 'b', 'i', 'b', '\000', '_',
+  '0', '_', 'v', 'a', 'v', 'g', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'a', 'v', 'g', 'l', 'b', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_',
+  'v', 'a', 'v', 'g', 'l', 'f', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 's', '3', '9', '0', '_', 'v', 'a', 'v', 'g', 'l', 'g', '\000', '_',
   '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v',
-  's', 'c', 'b', 'i', 'f', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 's', '3', '9', '0', '_', 'v', 's', 'c', 'b', 'i', 'g', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 's',
-  'c', 'b', 'i', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  's', '3', '9', '0', '_', 'v', 's', 'c', 'b', 'i', 'q', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 's', 'l',
+  'a', 'v', 'g', 'l', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 's', '3', '9', '0', '_', 'v', 'b', 'p', 'e', 'r', 'm', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'c',
+  'k', 's', 'm', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's',
+  '3', '9', '0', '_', 'v', 'e', 'r', 'i', 'm', 'b', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'e', 'r', 'i',
+  'm', 'f', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3',
+  '9', '0', '_', 'v', 'e', 'r', 'i', 'm', 'g', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'e', 'r', 'i', 'm',
+  'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9',
+  '0', '_', 'v', 'e', 'r', 'l', 'l', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'e', 'r', 'l', 'l', 'f',
   '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0',
-  '_', 'v', 's', 'l', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 's', '3', '9', '0', '_', 'v', 's', 'l', 'd', 'b', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 's', 'q',
+  '_', 'v', 'e', 'r', 'l', 'l', 'g', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'e', 'r', 'l', 'l', 'h', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_',
+  'v', 'e', 'r', 'l', 'l', 'v', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'e', 'r', 'l', 'l', 'v', 'f',
   '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0',
-  '_', 'v', 's', 'r', 'a', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 's', '3', '9', '0', '_', 'v', 's', 'r', 'a', 'b', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 's', 'r',
+  '_', 'v', 'e', 'r', 'l', 'l', 'v', 'g', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'e', 'r', 'l', 'l', 'v',
+  'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9',
+  '0', '_', 'v', 'f', 'a', 'e', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'f', 'a', 'e', 'f', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v',
+  'f', 'a', 'e', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  's', '3', '9', '0', '_', 'v', 'f', 'a', 'e', 'z', 'b', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'f', 'a',
+  'e', 'z', 'f', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's',
+  '3', '9', '0', '_', 'v', 'f', 'a', 'e', 'z', 'h', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'f', 'e', 'e',
+  'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9',
+  '0', '_', 'v', 'f', 'e', 'e', 'f', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'f', 'e', 'e', 'h', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v',
+  'f', 'e', 'e', 'z', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 's', '3', '9', '0', '_', 'v', 'f', 'e', 'e', 'z', 'f', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'f',
+  'e', 'e', 'z', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  's', '3', '9', '0', '_', 'v', 'f', 'e', 'n', 'e', 'b', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'f', 'e',
+  'n', 'e', 'f', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's',
+  '3', '9', '0', '_', 'v', 'f', 'e', 'n', 'e', 'h', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'f', 'e', 'n',
+  'e', 'z', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's',
+  '3', '9', '0', '_', 'v', 'f', 'e', 'n', 'e', 'z', 'f', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'f', 'e',
+  'n', 'e', 'z', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  's', '3', '9', '0', '_', 'v', 'g', 'f', 'm', 'a', 'b', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'g', 'f',
+  'm', 'a', 'f', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's',
+  '3', '9', '0', '_', 'v', 'g', 'f', 'm', 'a', 'g', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'g', 'f', 'm',
+  'a', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3',
+  '9', '0', '_', 'v', 'g', 'f', 'm', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'g', 'f', 'm', 'f', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_',
+  'v', 'g', 'f', 'm', 'g', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 's', '3', '9', '0', '_', 'v', 'g', 'f', 'm', 'h', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'i', 's',
+  't', 'r', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's',
+  '3', '9', '0', '_', 'v', 'i', 's', 't', 'r', 'f', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'i', 's', 't',
+  'r', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3',
+  '9', '0', '_', 'v', 'l', 'b', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'l', 'l', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'l', 'r',
   'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9',
-  '0', '_', 'v', 's', 'r', 'l', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 's', 't', 'l', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 's',
-  't', 'r', 'c', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  's', '3', '9', '0', '_', 'v', 's', 't', 'r', 'c', 'f', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 's', 't',
-  'r', 'c', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's',
-  '3', '9', '0', '_', 'v', 's', 't', 'r', 'c', 'z', 'b', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 's', 't',
-  'r', 'c', 'z', 'f', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  's', '3', '9', '0', '_', 'v', 's', 't', 'r', 'c', 'z', 'h', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 's',
-  't', 'r', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's',
-  '3', '9', '0', '_', 'v', 's', 'u', 'm', 'b', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 's', 'u', 'm', 'g',
-  'f', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9',
-  '0', '_', 'v', 's', 'u', 'm', 'g', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 's', 'u', 'm', 'h', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_',
-  'v', 's', 'u', 'm', 'q', 'f', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 's', '3', '9', '0', '_', 'v', 's', 'u', 'm', 'q', 'g', '\000', '_',
+  '0', '_', 'v', 'm', 'a', 'e', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'm', 'a', 'e', 'f', '\000', '_',
   '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v',
-  't', 'm', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3',
-  '9', '0', '_', 'v', 'u', 'p', 'h', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'u', 'p', 'h', 'f', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_',
-  'v', 'u', 'p', 'h', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 's', '3', '9', '0', '_', 'v', 'u', 'p', 'l', 'b', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'u', 'p',
-  'l', 'f', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3',
-  '9', '0', '_', 'v', 'u', 'p', 'l', 'h', 'b', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'u', 'p', 'l', 'h',
+  'm', 'a', 'e', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  's', '3', '9', '0', '_', 'v', 'm', 'a', 'h', 'b', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'm', 'a', 'h',
   'f', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9',
-  '0', '_', 'v', 'u', 'p', 'l', 'h', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'u', 'p', 'l', 'h', 'w',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0',
-  '_', 'v', 'u', 'p', 'l', 'l', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'u', 'p', 'l', 'l', 'f', '\000',
+  '0', '_', 'v', 'm', 'a', 'h', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'm', 'a', 'l', 'e', 'b', '\000',
   '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_',
-  'v', 'u', 'p', 'l', 'l', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'i', 'a', '3', '2', '_', 'p', 'a', 'v', 'g', 'u', 's', 'b', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
-  'p', 'f', '2', 'i', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'i', 'a', '3', '2', '_', 'p', 'f', 'a', 'c', 'c', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'f', 'a',
-  'd', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
-  '3', '2', '_', 'p', 'f', 'c', 'm', 'p', 'e', 'q', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'f', 'c', 'm',
-  'p', 'g', 'e', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'p', 'f', 'c', 'm', 'p', 'g', 't', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'f', 'm',
-  'a', 'x', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
-  '3', '2', '_', 'p', 'f', 'm', 'i', 'n', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'f', 'm', 'u', 'l', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
-  'p', 'f', 'r', 'c', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'i', 'a', '3', '2', '_', 'p', 'f', 'r', 'c', 'p', 'i', 't', '1', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
-  'p', 'f', 'r', 'c', 'p', 'i', 't', '2', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'f', 'r', 's', 'q', 'i',
-  't', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
-  '3', '2', '_', 'p', 'f', 'r', 's', 'q', 'r', 't', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'f', 's', 'u',
+  'v', 'm', 'a', 'l', 'e', 'f', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 's', '3', '9', '0', '_', 'v', 'm', 'a', 'l', 'e', 'h', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v',
+  'm', 'a', 'l', 'h', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 's', '3', '9', '0', '_', 'v', 'm', 'a', 'l', 'h', 'f', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'm',
+  'a', 'l', 'h', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  's', '3', '9', '0', '_', 'v', 'm', 'a', 'l', 'o', 'b', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'm', 'a',
+  'l', 'o', 'f', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's',
+  '3', '9', '0', '_', 'v', 'm', 'a', 'l', 'o', 'h', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'm', 'a', 'o',
+  'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9',
+  '0', '_', 'v', 'm', 'a', 'o', 'f', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'm', 'a', 'o', 'h', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v',
+  'm', 'e', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's',
+  '3', '9', '0', '_', 'v', 'm', 'e', 'f', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'm', 'e', 'h', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v',
+  'm', 'h', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's',
+  '3', '9', '0', '_', 'v', 'm', 'h', 'f', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'm', 'h', 'h', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v',
+  'm', 'l', 'e', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  's', '3', '9', '0', '_', 'v', 'm', 'l', 'e', 'f', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'm', 'l', 'e',
+  'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9',
+  '0', '_', 'v', 'm', 'l', 'h', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'm', 'l', 'h', 'f', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v',
+  'm', 'l', 'h', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  's', '3', '9', '0', '_', 'v', 'm', 'l', 'o', 'b', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'm', 'l', 'o',
+  'f', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9',
+  '0', '_', 'v', 'm', 'l', 'o', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'm', 'o', 'b', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'm',
+  'o', 'f', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3',
+  '9', '0', '_', 'v', 'm', 'o', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'm', 's', 'l', 'g', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v',
+  'p', 'd', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's',
+  '3', '9', '0', '_', 'v', 'p', 'e', 'r', 'm', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'p', 'k', 'l', 's',
+  'f', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9',
+  '0', '_', 'v', 'p', 'k', 'l', 's', 'g', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'p', 'k', 'l', 's', 'h',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0',
+  '_', 'v', 'p', 'k', 's', 'f', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 's', '3', '9', '0', '_', 'v', 'p', 'k', 's', 'g', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'p',
+  'k', 's', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's',
+  '3', '9', '0', '_', 'v', 's', 'b', 'c', 'b', 'i', 'q', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 's', 'b',
+  'i', 'q', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3',
+  '9', '0', '_', 'v', 's', 'c', 'b', 'i', 'b', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 's', 'c', 'b', 'i',
+  'f', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9',
+  '0', '_', 'v', 's', 'c', 'b', 'i', 'g', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 's', 'c', 'b', 'i', 'h',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0',
+  '_', 'v', 's', 'c', 'b', 'i', 'q', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 's', 'l', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 's', 'l',
+  'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9',
+  '0', '_', 'v', 's', 'l', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 's', '3', '9', '0', '_', 'v', 's', 'l', 'd', 'b', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 's',
+  'q', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9',
+  '0', '_', 'v', 's', 'r', 'a', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 's', '3', '9', '0', '_', 'v', 's', 'r', 'a', 'b', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 's',
+  'r', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3',
+  '9', '0', '_', 'v', 's', 'r', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 's', 'r', 'l', 'b', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v',
+  's', 't', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's',
+  '3', '9', '0', '_', 'v', 's', 't', 'r', 'c', 'b', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 's', 't', 'r',
+  'c', 'f', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3',
+  '9', '0', '_', 'v', 's', 't', 'r', 'c', 'h', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 's', 't', 'r', 'c',
+  'z', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3',
+  '9', '0', '_', 'v', 's', 't', 'r', 'c', 'z', 'f', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 's', 't', 'r',
+  'c', 'z', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's',
+  '3', '9', '0', '_', 'v', 's', 't', 'r', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 's', 'u', 'm', 'b',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0',
+  '_', 'v', 's', 'u', 'm', 'g', 'f', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 's', 'u', 'm', 'g', 'h', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_',
+  'v', 's', 'u', 'm', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 's', '3', '9', '0', '_', 'v', 's', 'u', 'm', 'q', 'f', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 's',
+  'u', 'm', 'q', 'g', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  's', '3', '9', '0', '_', 'v', 't', 'm', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'u', 'p', 'h', 'b', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_',
+  'v', 'u', 'p', 'h', 'f', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 's', '3', '9', '0', '_', 'v', 'u', 'p', 'h', 'h', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'u', 'p',
+  'l', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3',
+  '9', '0', '_', 'v', 'u', 'p', 'l', 'f', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'u', 'p', 'l', 'h', 'b',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0',
+  '_', 'v', 'u', 'p', 'l', 'h', 'f', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 's', '3', '9', '0', '_', 'v', 'u', 'p', 'l', 'h', 'h', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_',
+  'v', 'u', 'p', 'l', 'h', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 's', '3', '9', '0', '_', 'v', 'u', 'p', 'l', 'l', 'b', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', '3', '9', '0', '_', 'v',
+  'u', 'p', 'l', 'l', 'f', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 's', '3', '9', '0', '_', 'v', 'u', 'p', 'l', 'l', 'h', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'a',
+  'n', 'd', 'm', '_', 'M', 'M', 'M', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'a', 'n', 'd', 'm', '_', 'm',
+  'm', 'm', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'e', 'q', 'v', 'm', '_', 'M', 'M', 'M', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'e',
+  'q', 'v', 'm', '_', 'm', 'm', 'm', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'e', 'x', 't', 'r', 'a', 'c',
+  't', '_', 'v', 'm', '5', '1', '2', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'e', 'x', 't', 'r', 'a',
+  'c', 't', '_', 'v', 'm', '5', '1', '2', 'u', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'i', 'n', 's', 'e',
+  'r', 't', '_', 'v', 'm', '5', '1', '2', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'i', 'n', 's', 'e',
+  'r', 't', '_', 'v', 'm', '5', '1', '2', 'u', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'l', 's', 'v', '_',
+  'v', 'v', 's', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'l', 'v', 'm', '_', 'M', 'M', 's', 's', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'l', 'v', 'm', '_', 'm', 'm', 's', 's', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'l', 'v', 's', 'd',
+  '_', 's', 'v', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'l', 'v', 's', 'l', '_', 's', 'v', 's', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'l', 'v', 's', 's', '_', 's', 'v', 's', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'l', 'z', 'v', 'm',
+  '_', 's', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'n', 'e', 'g', 'm', '_', 'M', 'M', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'n', 'e', 'g', 'm', '_', 'm', 'm', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'n', 'n', 'd', 'm', '_', 'M',
+  'M', 'M', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'n', 'n', 'd', 'm', '_', 'm', 'm', 'm', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'o',
+  'r', 'm', '_', 'M', 'M', 'M', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'o', 'r', 'm', '_', 'm', 'm', 'm',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'p', 'a', 'c', 'k', '_', 'f', '3', '2', 'a', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'a',
+  'c', 'k', '_', 'f', '3', '2', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'c', 'v', 'm', '_', 's',
+  'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'p', 'f', 'c', 'h', 'v', '_', 's', 's', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'p', 'f', 'c', 'h', 'v', 'n', 'c', '_', 's', 's', 'l', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v',
+  'a', 'd', 'd', 's', '_', 'v', 's', 'v', 'M', 'v', 'l', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v',
+  'a', 'd', 'd', 's', '_', 'v', 's', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'a', 'd',
+  'd', 's', '_', 'v', 's', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'a', 'd', 'd',
+  's', '_', 'v', 'v', 'v', 'M', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'a', 'd', 'd',
+  's', '_', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'a', 'd', 'd', 's', '_',
+  'v', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'a', 'd', 'd', 'u', '_', 'v',
+  's', 'v', 'M', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'a', 'd', 'd', 'u', '_', 'v',
+  's', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'p', 'v', 'a', 'd', 'd', 'u', '_', 'v', 's', 'v',
+  'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'p', 'v', 'a', 'd', 'd', 'u', '_', 'v', 'v', 'v', 'M',
+  'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'p', 'v', 'a', 'd', 'd', 'u', '_', 'v', 'v', 'v', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'p', 'v', 'a', 'd', 'd', 'u', '_', 'v', 'v', 'v', 'v', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'p', 'v', 'a', 'n', 'd', '_', 'v', 's', 'v', 'M', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'p', 'v', 'a', 'n', 'd', '_', 'v', 's', 'v', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'a',
+  'n', 'd', '_', 'v', 's', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'a', 'n', 'd',
+  '_', 'v', 'v', 'v', 'M', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'a', 'n', 'd', '_',
+  'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'a', 'n', 'd', '_', 'v', 'v', 'v',
+  'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'p', 'v', 'b', 'r', 'd', '_', 'v', 's', 'M', 'v', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'p', 'v', 'b', 'r', 'd', '_', 'v', 's', 'l', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v',
+  'b', 'r', 'd', '_', 'v', 's', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'c', 'm', 'p',
+  's', '_', 'v', 's', 'v', 'M', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'c', 'm', 'p',
+  's', '_', 'v', 's', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'c', 'm', 'p', 's', '_',
+  'v', 's', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'c', 'm', 'p', 's', '_', 'v',
+  'v', 'v', 'M', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'c', 'm', 'p', 's', '_', 'v',
+  'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'p', 'v', 'c', 'm', 'p', 's', '_', 'v', 'v', 'v',
+  'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'p', 'v', 'c', 'm', 'p', 'u', '_', 'v', 's', 'v', 'M',
+  'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'p', 'v', 'c', 'm', 'p', 'u', '_', 'v', 's', 'v', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'p', 'v', 'c', 'm', 'p', 'u', '_', 'v', 's', 'v', 'v', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'p', 'v', 'c', 'm', 'p', 'u', '_', 'v', 'v', 'v', 'M', 'v', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'p', 'v', 'c', 'm', 'p', 'u', '_', 'v', 'v', 'v', 'l', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p',
+  'v', 'c', 'm', 'p', 'u', '_', 'v', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v',
+  'c', 'v', 't', 's', 'w', '_', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'c', 'v',
+  't', 's', 'w', '_', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'c', 'v', 't',
+  'w', 's', '_', 'v', 'v', 'M', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'c', 'v', 't',
+  'w', 's', '_', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'c', 'v', 't', 'w', 's',
+  '_', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'c', 'v', 't', 'w', 's', 'r',
+  'z', '_', 'v', 'v', 'M', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'c', 'v', 't', 'w',
+  's', 'r', 'z', '_', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'c', 'v', 't', 'w',
+  's', 'r', 'z', '_', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'e', 'q', 'v',
+  '_', 'v', 's', 'v', 'M', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'e', 'q', 'v', '_',
+  'v', 's', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'e', 'q', 'v', '_', 'v', 's', 'v',
+  'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'p', 'v', 'e', 'q', 'v', '_', 'v', 'v', 'v', 'M', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'p', 'v', 'e', 'q', 'v', '_', 'v', 'v', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'p', 'v', 'e', 'q', 'v', '_', 'v', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v',
+  'f', 'a', 'd', 'd', '_', 'v', 's', 'v', 'M', 'v', 'l', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v',
+  'f', 'a', 'd', 'd', '_', 'v', 's', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'a',
+  'd', 'd', '_', 'v', 's', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'a', 'd',
+  'd', '_', 'v', 'v', 'v', 'M', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'a', 'd',
+  'd', '_', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'a', 'd', 'd', '_',
+  'v', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'c', 'm', 'p', '_', 'v',
+  's', 'v', 'M', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'c', 'm', 'p', '_', 'v',
+  's', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'c', 'm', 'p', '_', 'v', 's', 'v',
+  'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'p', 'v', 'f', 'c', 'm', 'p', '_', 'v', 'v', 'v', 'M',
+  'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'p', 'v', 'f', 'c', 'm', 'p', '_', 'v', 'v', 'v', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'p', 'v', 'f', 'c', 'm', 'p', '_', 'v', 'v', 'v', 'v', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'p', 'v', 'f', 'm', 'a', 'd', '_', 'v', 's', 'v', 'v', 'M', 'v', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'p', 'v', 'f', 'm', 'a', 'd', '_', 'v', 's', 'v', 'v', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'p', 'v', 'f', 'm', 'a', 'd', '_', 'v', 's', 'v', 'v', 'v', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'p', 'v', 'f', 'm', 'a', 'd', '_', 'v', 'v', 's', 'v', 'M', 'v', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'p', 'v', 'f', 'm', 'a', 'd', '_', 'v', 'v', 's', 'v', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'p', 'v', 'f', 'm', 'a', 'd', '_', 'v', 'v', 's', 'v', 'v', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'p', 'v', 'f', 'm', 'a', 'd', '_', 'v', 'v', 'v', 'v', 'M', 'v', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'p', 'v', 'f', 'm', 'a', 'd', '_', 'v', 'v', 'v', 'v', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'p', 'v', 'f', 'm', 'a', 'd', '_', 'v', 'v', 'v', 'v', 'v', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'p', 'v', 'f', 'm', 'a', 'x', '_', 'v', 's', 'v', 'M', 'v', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'p', 'v', 'f', 'm', 'a', 'x', '_', 'v', 's', 'v', 'l', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p',
+  'v', 'f', 'm', 'a', 'x', '_', 'v', 's', 'v', 'v', 'l', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v',
+  'f', 'm', 'a', 'x', '_', 'v', 'v', 'v', 'M', 'v', 'l', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v',
+  'f', 'm', 'a', 'x', '_', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm',
+  'a', 'x', '_', 'v', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'i',
+  'n', '_', 'v', 's', 'v', 'M', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'i',
+  'n', '_', 'v', 's', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'i', 'n', '_',
+  'v', 's', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'i', 'n', '_', 'v',
+  'v', 'v', 'M', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'i', 'n', '_', 'v',
+  'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'i', 'n', '_', 'v', 'v', 'v',
+  'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 'a', 'f', '_', 'M', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'p', 'v', 'f', 'm', 'k', 'a', 't', '_', 'M', 'l', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v',
+  'f', 'm', 'k', 's', 'e', 'q', '_', 'M', 'v', 'M', 'l', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v',
+  'f', 'm', 'k', 's', 'e', 'q', '_', 'M', 'v', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f',
+  'm', 'k', 's', 'e', 'q', 'n', 'a', 'n', '_', 'M', 'v', 'M', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'p', 'v', 'f', 'm', 'k', 's', 'e', 'q', 'n', 'a', 'n', '_', 'M', 'v', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'p', 'v', 'f', 'm', 'k', 's', 'g', 'e', '_', 'M', 'v', 'M', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'p', 'v', 'f', 'm', 'k', 's', 'g', 'e', '_', 'M', 'v', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'p', 'v', 'f', 'm', 'k', 's', 'g', 'e', 'n', 'a', 'n', '_', 'M', 'v',
+  'M', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 's', 'g', 'e', 'n', 'a', 'n',
+  '_', 'M', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 's', 'g', 't', '_',
+  'M', 'v', 'M', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 's', 'g', 't', '_',
+  'M', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 's', 'g', 't', 'n', 'a',
+  'n', '_', 'M', 'v', 'M', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 's', 'g',
+  't', 'n', 'a', 'n', '_', 'M', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k',
+  's', 'l', 'e', '_', 'M', 'v', 'M', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k',
+  's', 'l', 'e', '_', 'M', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 's',
+  'l', 'e', 'n', 'a', 'n', '_', 'M', 'v', 'M', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f',
+  'm', 'k', 's', 'l', 'e', 'n', 'a', 'n', '_', 'M', 'v', 'l', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p',
+  'v', 'f', 'm', 'k', 's', 'l', 'o', 'e', 'q', '_', 'm', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'p', 'v', 'f', 'm', 'k', 's', 'l', 'o', 'e', 'q', '_', 'm', 'v', 'm', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'p', 'v', 'f', 'm', 'k', 's', 'l', 'o', 'e', 'q', 'n', 'a', 'n',
+  '_', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 's', 'l', 'o', 'e',
+  'q', 'n', 'a', 'n', '_', 'm', 'v', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm',
+  'k', 's', 'l', 'o', 'g', 'e', '_', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f',
+  'm', 'k', 's', 'l', 'o', 'g', 'e', '_', 'm', 'v', 'm', 'l', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p',
+  'v', 'f', 'm', 'k', 's', 'l', 'o', 'g', 'e', 'n', 'a', 'n', '_', 'm', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 's', 'l', 'o', 'g', 'e', 'n', 'a',
+  'n', '_', 'm', 'v', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 's', 'l',
+  'o', 'g', 't', '_', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 's',
+  'l', 'o', 'g', 't', '_', 'm', 'v', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm',
+  'k', 's', 'l', 'o', 'g', 't', 'n', 'a', 'n', '_', 'm', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'p', 'v', 'f', 'm', 'k', 's', 'l', 'o', 'g', 't', 'n', 'a', 'n', '_', 'm',
+  'v', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 's', 'l', 'o', 'l', 'e',
+  '_', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 's', 'l', 'o', 'l',
+  'e', '_', 'm', 'v', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 's', 'l',
+  'o', 'l', 'e', 'n', 'a', 'n', '_', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f',
+  'm', 'k', 's', 'l', 'o', 'l', 'e', 'n', 'a', 'n', '_', 'm', 'v', 'm', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'p', 'v', 'f', 'm', 'k', 's', 'l', 'o', 'l', 't', '_', 'm', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 's', 'l', 'o', 'l', 't', '_', 'm',
+  'v', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 's', 'l', 'o', 'l', 't',
+  'n', 'a', 'n', '_', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 's',
+  'l', 'o', 'l', 't', 'n', 'a', 'n', '_', 'm', 'v', 'm', 'l', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p',
+  'v', 'f', 'm', 'k', 's', 'l', 'o', 'n', 'a', 'n', '_', 'm', 'v', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'p', 'v', 'f', 'm', 'k', 's', 'l', 'o', 'n', 'a', 'n', '_', 'm', 'v',
+  'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 's', 'l', 'o', 'n', 'e', '_',
+  'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 's', 'l', 'o', 'n', 'e',
+  '_', 'm', 'v', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 's', 'l', 'o',
+  'n', 'e', 'n', 'a', 'n', '_', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm',
+  'k', 's', 'l', 'o', 'n', 'e', 'n', 'a', 'n', '_', 'm', 'v', 'm', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'p', 'v', 'f', 'm', 'k', 's', 'l', 'o', 'n', 'u', 'm', '_', 'm', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 's', 'l', 'o', 'n', 'u', 'm', '_',
+  'm', 'v', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 's', 'l', 't', '_',
+  'M', 'v', 'M', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 's', 'l', 't', '_',
+  'M', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 's', 'l', 't', 'n', 'a',
+  'n', '_', 'M', 'v', 'M', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 's', 'l',
+  't', 'n', 'a', 'n', '_', 'M', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k',
+  's', 'n', 'a', 'n', '_', 'M', 'v', 'M', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm',
+  'k', 's', 'n', 'a', 'n', '_', 'M', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm',
+  'k', 's', 'n', 'e', '_', 'M', 'v', 'M', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm',
+  'k', 's', 'n', 'e', '_', 'M', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k',
+  's', 'n', 'e', 'n', 'a', 'n', '_', 'M', 'v', 'M', 'l', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v',
+  'f', 'm', 'k', 's', 'n', 'e', 'n', 'a', 'n', '_', 'M', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'p', 'v', 'f', 'm', 'k', 's', 'n', 'u', 'm', '_', 'M', 'v', 'M', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'p', 'v', 'f', 'm', 'k', 's', 'n', 'u', 'm', '_', 'M', 'v', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'p', 'v', 'f', 'm', 'k', 's', 'u', 'p', 'e', 'q', '_', 'm', 'v', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'p', 'v', 'f', 'm', 'k', 's', 'u', 'p', 'e', 'q', '_', 'm', 'v',
+  'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 's', 'u', 'p', 'e', 'q', 'n',
+  'a', 'n', '_', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 's', 'u',
+  'p', 'e', 'q', 'n', 'a', 'n', '_', 'm', 'v', 'm', 'l', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v',
+  'f', 'm', 'k', 's', 'u', 'p', 'g', 'e', '_', 'm', 'v', 'l', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p',
+  'v', 'f', 'm', 'k', 's', 'u', 'p', 'g', 'e', '_', 'm', 'v', 'm', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'p', 'v', 'f', 'm', 'k', 's', 'u', 'p', 'g', 'e', 'n', 'a', 'n', '_',
+  'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 's', 'u', 'p', 'g', 'e',
+  'n', 'a', 'n', '_', 'm', 'v', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k',
+  's', 'u', 'p', 'g', 't', '_', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm',
+  'k', 's', 'u', 'p', 'g', 't', '_', 'm', 'v', 'm', 'l', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v',
+  'f', 'm', 'k', 's', 'u', 'p', 'g', 't', 'n', 'a', 'n', '_', 'm', 'v', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'p', 'v', 'f', 'm', 'k', 's', 'u', 'p', 'g', 't', 'n', 'a', 'n',
+  '_', 'm', 'v', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 's', 'u', 'p',
+  'l', 'e', '_', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 's', 'u',
+  'p', 'l', 'e', '_', 'm', 'v', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k',
+  's', 'u', 'p', 'l', 'e', 'n', 'a', 'n', '_', 'm', 'v', 'l', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p',
+  'v', 'f', 'm', 'k', 's', 'u', 'p', 'l', 'e', 'n', 'a', 'n', '_', 'm', 'v',
+  'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 's', 'u', 'p', 'l', 't', '_',
+  'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 's', 'u', 'p', 'l', 't',
+  '_', 'm', 'v', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 's', 'u', 'p',
+  'l', 't', 'n', 'a', 'n', '_', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm',
+  'k', 's', 'u', 'p', 'l', 't', 'n', 'a', 'n', '_', 'm', 'v', 'm', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'p', 'v', 'f', 'm', 'k', 's', 'u', 'p', 'n', 'a', 'n', '_', 'm', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 's', 'u', 'p', 'n', 'a', 'n', '_',
+  'm', 'v', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 's', 'u', 'p', 'n',
+  'e', '_', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 's', 'u', 'p',
+  'n', 'e', '_', 'm', 'v', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 's',
+  'u', 'p', 'n', 'e', 'n', 'a', 'n', '_', 'm', 'v', 'l', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v',
+  'f', 'm', 'k', 's', 'u', 'p', 'n', 'e', 'n', 'a', 'n', '_', 'm', 'v', 'm',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 's', 'u', 'p', 'n', 'u', 'm', '_',
+  'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 's', 'u', 'p', 'n', 'u',
+  'm', '_', 'm', 'v', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 'w', 'e',
+  'q', '_', 'M', 'v', 'M', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 'w', 'e',
+  'q', '_', 'M', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 'w', 'e', 'q',
+  'n', 'a', 'n', '_', 'M', 'v', 'M', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k',
+  'w', 'e', 'q', 'n', 'a', 'n', '_', 'M', 'v', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f',
+  'm', 'k', 'w', 'g', 'e', '_', 'M', 'v', 'M', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f',
+  'm', 'k', 'w', 'g', 'e', '_', 'M', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm',
+  'k', 'w', 'g', 'e', 'n', 'a', 'n', '_', 'M', 'v', 'M', 'l', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p',
+  'v', 'f', 'm', 'k', 'w', 'g', 'e', 'n', 'a', 'n', '_', 'M', 'v', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'p', 'v', 'f', 'm', 'k', 'w', 'g', 't', '_', 'M', 'v', 'M', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'p', 'v', 'f', 'm', 'k', 'w', 'g', 't', '_', 'M', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'p', 'v', 'f', 'm', 'k', 'w', 'g', 't', 'n', 'a', 'n', '_', 'M', 'v', 'M',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 'w', 'g', 't', 'n', 'a', 'n', '_',
+  'M', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 'w', 'l', 'e', '_', 'M',
+  'v', 'M', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 'w', 'l', 'e', '_', 'M',
+  'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 'w', 'l', 'e', 'n', 'a', 'n',
+  '_', 'M', 'v', 'M', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 'w', 'l', 'e',
+  'n', 'a', 'n', '_', 'M', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 'w',
+  'l', 'o', 'e', 'q', '_', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k',
+  'w', 'l', 'o', 'e', 'q', '_', 'm', 'v', 'm', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f',
+  'm', 'k', 'w', 'l', 'o', 'e', 'q', 'n', 'a', 'n', '_', 'm', 'v', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'p', 'v', 'f', 'm', 'k', 'w', 'l', 'o', 'e', 'q', 'n', 'a', 'n', '_',
+  'm', 'v', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 'w', 'l', 'o', 'g',
+  'e', '_', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 'w', 'l', 'o',
+  'g', 'e', '_', 'm', 'v', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 'w',
+  'l', 'o', 'g', 'e', 'n', 'a', 'n', '_', 'm', 'v', 'l', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v',
+  'f', 'm', 'k', 'w', 'l', 'o', 'g', 'e', 'n', 'a', 'n', '_', 'm', 'v', 'm',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 'w', 'l', 'o', 'g', 't', '_', 'm',
+  'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 'w', 'l', 'o', 'g', 't', '_',
+  'm', 'v', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 'w', 'l', 'o', 'g',
+  't', 'n', 'a', 'n', '_', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k',
+  'w', 'l', 'o', 'g', 't', 'n', 'a', 'n', '_', 'm', 'v', 'm', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'p', 'v', 'f', 'm', 'k', 'w', 'l', 'o', 'l', 'e', '_', 'm', 'v', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'p', 'v', 'f', 'm', 'k', 'w', 'l', 'o', 'l', 'e', '_', 'm', 'v', 'm',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 'w', 'l', 'o', 'l', 'e', 'n', 'a',
+  'n', '_', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 'w', 'l', 'o',
+  'l', 'e', 'n', 'a', 'n', '_', 'm', 'v', 'm', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f',
+  'm', 'k', 'w', 'l', 'o', 'l', 't', '_', 'm', 'v', 'l', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v',
+  'f', 'm', 'k', 'w', 'l', 'o', 'l', 't', '_', 'm', 'v', 'm', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'p', 'v', 'f', 'm', 'k', 'w', 'l', 'o', 'l', 't', 'n', 'a', 'n', '_', 'm',
+  'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 'w', 'l', 'o', 'l', 't', 'n',
+  'a', 'n', '_', 'm', 'v', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 'w',
+  'l', 'o', 'n', 'a', 'n', '_', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm',
+  'k', 'w', 'l', 'o', 'n', 'a', 'n', '_', 'm', 'v', 'm', 'l', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p',
+  'v', 'f', 'm', 'k', 'w', 'l', 'o', 'n', 'e', '_', 'm', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'p', 'v', 'f', 'm', 'k', 'w', 'l', 'o', 'n', 'e', '_', 'm', 'v', 'm', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'p', 'v', 'f', 'm', 'k', 'w', 'l', 'o', 'n', 'e', 'n', 'a', 'n',
+  '_', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 'w', 'l', 'o', 'n',
+  'e', 'n', 'a', 'n', '_', 'm', 'v', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm',
+  'k', 'w', 'l', 'o', 'n', 'u', 'm', '_', 'm', 'v', 'l', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v',
+  'f', 'm', 'k', 'w', 'l', 'o', 'n', 'u', 'm', '_', 'm', 'v', 'm', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'p', 'v', 'f', 'm', 'k', 'w', 'l', 't', '_', 'M', 'v', 'M', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'p', 'v', 'f', 'm', 'k', 'w', 'l', 't', '_', 'M', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'p', 'v', 'f', 'm', 'k', 'w', 'l', 't', 'n', 'a', 'n', '_', 'M', 'v', 'M',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 'w', 'l', 't', 'n', 'a', 'n', '_',
+  'M', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 'w', 'n', 'a', 'n', '_',
+  'M', 'v', 'M', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 'w', 'n', 'a', 'n',
+  '_', 'M', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 'w', 'n', 'e', '_',
+  'M', 'v', 'M', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 'w', 'n', 'e', '_',
+  'M', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 'w', 'n', 'e', 'n', 'a',
+  'n', '_', 'M', 'v', 'M', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 'w', 'n',
+  'e', 'n', 'a', 'n', '_', 'M', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k',
+  'w', 'n', 'u', 'm', '_', 'M', 'v', 'M', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm',
+  'k', 'w', 'n', 'u', 'm', '_', 'M', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm',
+  'k', 'w', 'u', 'p', 'e', 'q', '_', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f',
+  'm', 'k', 'w', 'u', 'p', 'e', 'q', '_', 'm', 'v', 'm', 'l', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p',
+  'v', 'f', 'm', 'k', 'w', 'u', 'p', 'e', 'q', 'n', 'a', 'n', '_', 'm', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 'w', 'u', 'p', 'e', 'q', 'n', 'a',
+  'n', '_', 'm', 'v', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 'w', 'u',
+  'p', 'g', 'e', '_', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 'w',
+  'u', 'p', 'g', 'e', '_', 'm', 'v', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm',
+  'k', 'w', 'u', 'p', 'g', 'e', 'n', 'a', 'n', '_', 'm', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'p', 'v', 'f', 'm', 'k', 'w', 'u', 'p', 'g', 'e', 'n', 'a', 'n', '_', 'm',
+  'v', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 'w', 'u', 'p', 'g', 't',
+  '_', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 'w', 'u', 'p', 'g',
+  't', '_', 'm', 'v', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 'w', 'u',
+  'p', 'g', 't', 'n', 'a', 'n', '_', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f',
+  'm', 'k', 'w', 'u', 'p', 'g', 't', 'n', 'a', 'n', '_', 'm', 'v', 'm', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'p', 'v', 'f', 'm', 'k', 'w', 'u', 'p', 'l', 'e', '_', 'm', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 'w', 'u', 'p', 'l', 'e', '_', 'm',
+  'v', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 'w', 'u', 'p', 'l', 'e',
+  'n', 'a', 'n', '_', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 'w',
+  'u', 'p', 'l', 'e', 'n', 'a', 'n', '_', 'm', 'v', 'm', 'l', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p',
+  'v', 'f', 'm', 'k', 'w', 'u', 'p', 'l', 't', '_', 'm', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'p', 'v', 'f', 'm', 'k', 'w', 'u', 'p', 'l', 't', '_', 'm', 'v', 'm', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'p', 'v', 'f', 'm', 'k', 'w', 'u', 'p', 'l', 't', 'n', 'a', 'n',
+  '_', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 'w', 'u', 'p', 'l',
+  't', 'n', 'a', 'n', '_', 'm', 'v', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm',
+  'k', 'w', 'u', 'p', 'n', 'a', 'n', '_', 'm', 'v', 'l', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v',
+  'f', 'm', 'k', 'w', 'u', 'p', 'n', 'a', 'n', '_', 'm', 'v', 'm', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'p', 'v', 'f', 'm', 'k', 'w', 'u', 'p', 'n', 'e', '_', 'm', 'v', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'p', 'v', 'f', 'm', 'k', 'w', 'u', 'p', 'n', 'e', '_', 'm', 'v',
+  'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 'w', 'u', 'p', 'n', 'e', 'n',
+  'a', 'n', '_', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 'k', 'w', 'u',
+  'p', 'n', 'e', 'n', 'a', 'n', '_', 'm', 'v', 'm', 'l', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v',
+  'f', 'm', 'k', 'w', 'u', 'p', 'n', 'u', 'm', '_', 'm', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'p', 'v', 'f', 'm', 'k', 'w', 'u', 'p', 'n', 'u', 'm', '_', 'm', 'v', 'm',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'p', 'v', 'f', 'm', 's', 'b', '_', 'v', 's', 'v', 'v', 'M',
+  'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 's', 'b', '_', 'v', 's', 'v', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'p', 'v', 'f', 'm', 's', 'b', '_', 'v', 's', 'v', 'v', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'p', 'v', 'f', 'm', 's', 'b', '_', 'v', 'v', 's', 'v', 'M',
+  'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 's', 'b', '_', 'v', 'v', 's', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'p', 'v', 'f', 'm', 's', 'b', '_', 'v', 'v', 's', 'v', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'p', 'v', 'f', 'm', 's', 'b', '_', 'v', 'v', 'v', 'v', 'M',
+  'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'p', 'v', 'f', 'm', 's', 'b', '_', 'v', 'v', 'v', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'p', 'v', 'f', 'm', 's', 'b', '_', 'v', 'v', 'v', 'v', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'p', 'v', 'f', 'm', 'u', 'l', '_', 'v', 's', 'v', 'M', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'p', 'v', 'f', 'm', 'u', 'l', '_', 'v', 's', 'v', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'p', 'v', 'f', 'm', 'u', 'l', '_', 'v', 's', 'v', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'p', 'v', 'f', 'm', 'u', 'l', '_', 'v', 'v', 'v', 'M', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'p', 'v', 'f', 'm', 'u', 'l', '_', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v',
+  'f', 'm', 'u', 'l', '_', 'v', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f',
+  'n', 'm', 'a', 'd', '_', 'v', 's', 'v', 'v', 'M', 'v', 'l', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p',
+  'v', 'f', 'n', 'm', 'a', 'd', '_', 'v', 's', 'v', 'v', 'l', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p',
+  'v', 'f', 'n', 'm', 'a', 'd', '_', 'v', 's', 'v', 'v', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'p', 'v', 'f', 'n', 'm', 'a', 'd', '_', 'v', 'v', 's', 'v', 'M', 'v', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'p', 'v', 'f', 'n', 'm', 'a', 'd', '_', 'v', 'v', 's', 'v', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'p', 'v', 'f', 'n', 'm', 'a', 'd', '_', 'v', 'v', 's', 'v', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'p', 'v', 'f', 'n', 'm', 'a', 'd', '_', 'v', 'v', 'v', 'v',
+  'M', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'n', 'm', 'a', 'd', '_', 'v', 'v',
+  'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'n', 'm', 'a', 'd', '_', 'v', 'v',
+  'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'n', 'm', 's', 'b', '_', 'v',
+  's', 'v', 'v', 'M', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'n', 'm', 's', 'b',
+  '_', 'v', 's', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'n', 'm', 's', 'b',
+  '_', 'v', 's', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'n', 'm', 's',
+  'b', '_', 'v', 'v', 's', 'v', 'M', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'n',
+  'm', 's', 'b', '_', 'v', 'v', 's', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 'n',
+  'm', 's', 'b', '_', 'v', 'v', 's', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f',
+  'n', 'm', 's', 'b', '_', 'v', 'v', 'v', 'v', 'M', 'v', 'l', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p',
+  'v', 'f', 'n', 'm', 's', 'b', '_', 'v', 'v', 'v', 'v', 'l', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p',
+  'v', 'f', 'n', 'm', 's', 'b', '_', 'v', 'v', 'v', 'v', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'p', 'v', 'f', 's', 'u', 'b', '_', 'v', 's', 'v', 'M', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'p', 'v', 'f', 's', 'u', 'b', '_', 'v', 's', 'v', 'l', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v',
+  'f', 's', 'u', 'b', '_', 'v', 's', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f',
+  's', 'u', 'b', '_', 'v', 'v', 'v', 'M', 'v', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f',
+  's', 'u', 'b', '_', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'f', 's', 'u',
+  'b', '_', 'v', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'm', 'a', 'x', 's',
+  '_', 'v', 's', 'v', 'M', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'm', 'a', 'x', 's',
+  '_', 'v', 's', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'm', 'a', 'x', 's', '_', 'v',
+  's', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'm', 'a', 'x', 's', '_', 'v', 'v',
+  'v', 'M', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'm', 'a', 'x', 's', '_', 'v', 'v',
+  'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'p', 'v', 'm', 'a', 'x', 's', '_', 'v', 'v', 'v', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'p', 'v', 'm', 'i', 'n', 's', '_', 'v', 's', 'v', 'M', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'p', 'v', 'm', 'i', 'n', 's', '_', 'v', 's', 'v', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'p', 'v', 'm', 'i', 'n', 's', '_', 'v', 's', 'v', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'p', 'v', 'm', 'i', 'n', 's', '_', 'v', 'v', 'v', 'M', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'p', 'v', 'm', 'i', 'n', 's', '_', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v',
+  'm', 'i', 'n', 's', '_', 'v', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'o',
+  'r', '_', 'v', 's', 'v', 'M', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'o', 'r', '_',
+  'v', 's', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'o', 'r', '_', 'v', 's', 'v', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'p', 'v', 'o', 'r', '_', 'v', 'v', 'v', 'M', 'v', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'p', 'v', 'o', 'r', '_', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'o',
+  'r', '_', 'v', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'r', 'c', 'p', '_',
+  'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'p', 'v', 'r', 'c', 'p', '_', 'v', 'v', 'v', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'p', 'v', 'r', 's', 'q', 'r', 't', '_', 'v', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'p', 'v', 'r', 's', 'q', 'r', 't', '_', 'v', 'v', 'v', 'l', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p',
+  'v', 'r', 's', 'q', 'r', 't', 'n', 'e', 'x', '_', 'v', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'p', 'v', 'r', 's', 'q', 'r', 't', 'n', 'e', 'x', '_', 'v', 'v', 'v', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'p', 'v', 's', 'e', 'q', '_', 'v', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 's',
+  'e', 'q', '_', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 's', 'e', 'q', 'l', 'o',
+  '_', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'p', 'v', 's', 'e', 'q', 'l', 'o', '_', 'v', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'p', 'v', 's', 'e', 'q', 'u', 'p', '_', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'p', 'v', 's', 'e', 'q', 'u', 'p', '_', 'v', 'v', 'l', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v',
+  's', 'l', 'a', '_', 'v', 'v', 's', 'M', 'v', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 's',
+  'l', 'a', '_', 'v', 'v', 's', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 's', 'l', 'a', '_',
+  'v', 'v', 's', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 's', 'l', 'a', '_', 'v', 'v',
+  'v', 'M', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 's', 'l', 'a', '_', 'v', 'v', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'p', 'v', 's', 'l', 'a', '_', 'v', 'v', 'v', 'v', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'p', 'v', 's', 'l', 'l', '_', 'v', 'v', 's', 'M', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'p', 'v', 's', 'l', 'l', '_', 'v', 'v', 's', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 's',
+  'l', 'l', '_', 'v', 'v', 's', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 's', 'l', 'l',
+  '_', 'v', 'v', 'v', 'M', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 's', 'l', 'l', '_',
+  'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 's', 'l', 'l', '_', 'v', 'v', 'v',
+  'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'p', 'v', 's', 'r', 'a', '_', 'v', 'v', 's', 'M', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'p', 'v', 's', 'r', 'a', '_', 'v', 'v', 's', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'p', 'v', 's', 'r', 'a', '_', 'v', 'v', 's', 'v', 'l', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v',
+  's', 'r', 'a', '_', 'v', 'v', 'v', 'M', 'v', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 's',
+  'r', 'a', '_', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 's', 'r', 'a', '_',
+  'v', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 's', 'r', 'l', '_', 'v', 'v',
+  's', 'M', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 's', 'r', 'l', '_', 'v', 'v', 's',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'p', 'v', 's', 'r', 'l', '_', 'v', 'v', 's', 'v', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'p', 'v', 's', 'r', 'l', '_', 'v', 'v', 'v', 'M', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'p', 'v', 's', 'r', 'l', '_', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 's',
+  'r', 'l', '_', 'v', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 's', 'u', 'b',
+  's', '_', 'v', 's', 'v', 'M', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 's', 'u', 'b',
+  's', '_', 'v', 's', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 's', 'u', 'b', 's', '_',
+  'v', 's', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 's', 'u', 'b', 's', '_', 'v',
+  'v', 'v', 'M', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 's', 'u', 'b', 's', '_', 'v',
+  'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'p', 'v', 's', 'u', 'b', 's', '_', 'v', 'v', 'v',
+  'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'p', 'v', 's', 'u', 'b', 'u', '_', 'v', 's', 'v', 'M',
+  'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'p', 'v', 's', 'u', 'b', 'u', '_', 'v', 's', 'v', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'p', 'v', 's', 'u', 'b', 'u', '_', 'v', 's', 'v', 'v', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'p', 'v', 's', 'u', 'b', 'u', '_', 'v', 'v', 'v', 'M', 'v', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'p', 'v', 's', 'u', 'b', 'u', '_', 'v', 'v', 'v', 'l', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p',
+  'v', 's', 'u', 'b', 'u', '_', 'v', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v',
+  'x', 'o', 'r', '_', 'v', 's', 'v', 'M', 'v', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'x',
+  'o', 'r', '_', 'v', 's', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'x', 'o', 'r', '_',
+  'v', 's', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'x', 'o', 'r', '_', 'v', 'v',
+  'v', 'M', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'p', 'v', 'x', 'o', 'r', '_', 'v', 'v', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'p', 'v', 'x', 'o', 'r', '_', 'v', 'v', 'v', 'v', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 's', 'v', 'm', '_', 's', 'M', 's', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 's', 'v', 'm', '_', 's',
+  'm', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 's', 'v', 'o', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 't', 'o', 'v', 'm', '_',
+  's', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'v', 'a', 'd', 'd', 's', 'l', '_', 'v', 's', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'a', 'd', 'd', 's', 'l', '_', 'v', 's', 'v', 'm', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'a', 'd', 'd', 's', 'l', '_', 'v', 's', 'v', 'v', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'v', 'a', 'd', 'd', 's', 'l', '_', 'v', 'v', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 'a', 'd', 'd', 's', 'l', '_', 'v', 'v', 'v', 'm', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 'a', 'd', 'd', 's', 'l', '_', 'v', 'v', 'v', 'v', 'l', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v',
+  'a', 'd', 'd', 's', 'w', 's', 'x', '_', 'v', 's', 'v', 'l', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v',
+  'a', 'd', 'd', 's', 'w', 's', 'x', '_', 'v', 's', 'v', 'm', 'v', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'v', 'a', 'd', 'd', 's', 'w', 's', 'x', '_', 'v', 's', 'v', 'v', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'v', 'a', 'd', 'd', 's', 'w', 's', 'x', '_', 'v', 'v', 'v', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'v', 'a', 'd', 'd', 's', 'w', 's', 'x', '_', 'v', 'v', 'v', 'm',
+  'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'v', 'a', 'd', 'd', 's', 'w', 's', 'x', '_', 'v', 'v',
+  'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'v', 'a', 'd', 'd', 's', 'w', 'z', 'x', '_', 'v',
+  's', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'v', 'a', 'd', 'd', 's', 'w', 'z', 'x', '_', 'v',
+  's', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'a', 'd', 'd', 's', 'w', 'z', 'x',
+  '_', 'v', 's', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'a', 'd', 'd', 's', 'w', 'z',
+  'x', '_', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'a', 'd', 'd', 's', 'w', 'z',
+  'x', '_', 'v', 'v', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'a', 'd', 'd', 's',
+  'w', 'z', 'x', '_', 'v', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'a', 'd', 'd',
+  'u', 'l', '_', 'v', 's', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'a', 'd', 'd', 'u', 'l',
+  '_', 'v', 's', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'a', 'd', 'd', 'u', 'l',
+  '_', 'v', 's', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'a', 'd', 'd', 'u', 'l', '_',
+  'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'v', 'a', 'd', 'd', 'u', 'l', '_', 'v', 'v',
+  'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'v', 'a', 'd', 'd', 'u', 'l', '_', 'v', 'v',
+  'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'v', 'a', 'd', 'd', 'u', 'w', '_', 'v', 's', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'a', 'd', 'd', 'u', 'w', '_', 'v', 's', 'v', 'm', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'a', 'd', 'd', 'u', 'w', '_', 'v', 's', 'v', 'v', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'v', 'a', 'd', 'd', 'u', 'w', '_', 'v', 'v', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 'a', 'd', 'd', 'u', 'w', '_', 'v', 'v', 'v', 'm', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 'a', 'd', 'd', 'u', 'w', '_', 'v', 'v', 'v', 'v', 'l', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v',
+  'a', 'n', 'd', '_', 'v', 's', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'a', 'n', 'd', '_',
+  'v', 's', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'a', 'n', 'd', '_', 'v', 's',
+  'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'v', 'a', 'n', 'd', '_', 'v', 'v', 'v', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'v', 'a', 'n', 'd', '_', 'v', 'v', 'v', 'm', 'v', 'l', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v',
+  'a', 'n', 'd', '_', 'v', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'b', 'r', 'd',
+  'd', '_', 'v', 's', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'b', 'r', 'd', 'd', '_', 'v', 's',
+  'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'v', 'b', 'r', 'd', 'd', '_', 'v', 's', 'v', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'v', 'b', 'r', 'd', 'l', '_', 'v', 's', 'l', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'b',
+  'r', 'd', 'l', '_', 'v', 's', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'b', 'r', 'd',
+  'l', '_', 'v', 's', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'b', 'r', 'd', 's', '_', 'v',
+  's', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'v', 'b', 'r', 'd', 's', '_', 'v', 's', 'm', 'v', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'v', 'b', 'r', 'd', 's', '_', 'v', 's', 'v', 'l', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v',
+  'b', 'r', 'd', 'w', '_', 'v', 's', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'b', 'r', 'd', 'w',
+  '_', 'v', 's', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'b', 'r', 'd', 'w', '_', 'v',
+  's', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'v', 'c', 'm', 'p', 's', 'l', '_', 'v', 's', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'c', 'm', 'p', 's', 'l', '_', 'v', 's', 'v', 'm', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'c', 'm', 'p', 's', 'l', '_', 'v', 's', 'v', 'v', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'v', 'c', 'm', 'p', 's', 'l', '_', 'v', 'v', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 'c', 'm', 'p', 's', 'l', '_', 'v', 'v', 'v', 'm', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 'c', 'm', 'p', 's', 'l', '_', 'v', 'v', 'v', 'v', 'l', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v',
+  'c', 'm', 'p', 's', 'w', 's', 'x', '_', 'v', 's', 'v', 'l', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v',
+  'c', 'm', 'p', 's', 'w', 's', 'x', '_', 'v', 's', 'v', 'm', 'v', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'v', 'c', 'm', 'p', 's', 'w', 's', 'x', '_', 'v', 's', 'v', 'v', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'v', 'c', 'm', 'p', 's', 'w', 's', 'x', '_', 'v', 'v', 'v', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'v', 'c', 'm', 'p', 's', 'w', 's', 'x', '_', 'v', 'v', 'v', 'm',
+  'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'v', 'c', 'm', 'p', 's', 'w', 's', 'x', '_', 'v', 'v',
+  'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'v', 'c', 'm', 'p', 's', 'w', 'z', 'x', '_', 'v',
+  's', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'v', 'c', 'm', 'p', 's', 'w', 'z', 'x', '_', 'v',
+  's', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'c', 'm', 'p', 's', 'w', 'z', 'x',
+  '_', 'v', 's', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'c', 'm', 'p', 's', 'w', 'z',
+  'x', '_', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'c', 'm', 'p', 's', 'w', 'z',
+  'x', '_', 'v', 'v', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'c', 'm', 'p', 's',
+  'w', 'z', 'x', '_', 'v', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'c', 'm', 'p',
+  'u', 'l', '_', 'v', 's', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'c', 'm', 'p', 'u', 'l',
+  '_', 'v', 's', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'c', 'm', 'p', 'u', 'l',
+  '_', 'v', 's', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'c', 'm', 'p', 'u', 'l', '_',
+  'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'v', 'c', 'm', 'p', 'u', 'l', '_', 'v', 'v',
+  'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'v', 'c', 'm', 'p', 'u', 'l', '_', 'v', 'v',
+  'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'v', 'c', 'm', 'p', 'u', 'w', '_', 'v', 's', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'c', 'm', 'p', 'u', 'w', '_', 'v', 's', 'v', 'm', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'c', 'm', 'p', 'u', 'w', '_', 'v', 's', 'v', 'v', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'v', 'c', 'm', 'p', 'u', 'w', '_', 'v', 'v', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 'c', 'm', 'p', 'u', 'w', '_', 'v', 'v', 'v', 'm', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 'c', 'm', 'p', 'u', 'w', '_', 'v', 'v', 'v', 'v', 'l', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v',
+  'c', 'p', '_', 'v', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'c', 'v', 't', 'd',
+  'l', '_', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'c', 'v', 't', 'd', 'l', '_', 'v',
+  'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'v', 'c', 'v', 't', 'd', 's', '_', 'v', 'v', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'v', 'c', 'v', 't', 'd', 's', '_', 'v', 'v', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 'c', 'v', 't', 'd', 'w', '_', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'c', 'v',
+  't', 'd', 'w', '_', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'c', 'v', 't', 'l',
+  'd', '_', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'c', 'v', 't', 'l', 'd', '_', 'v',
+  'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'v', 'c', 'v', 't', 'l', 'd', '_', 'v', 'v',
+  'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'v', 'c', 'v', 't', 'l', 'd', 'r', 'z', '_', 'v', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'c', 'v', 't', 'l', 'd', 'r', 'z', '_', 'v', 'v', 'm',
+  'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'v', 'c', 'v', 't', 'l', 'd', 'r', 'z', '_', 'v', 'v',
+  'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'v', 'c', 'v', 't', 's', 'd', '_', 'v', 'v', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'v', 'c', 'v', 't', 's', 'd', '_', 'v', 'v', 'v', 'l', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v',
+  'c', 'v', 't', 's', 'w', '_', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'c', 'v', 't',
+  's', 'w', '_', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'c', 'v', 't', 'w', 'd',
+  's', 'x', '_', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'c', 'v', 't', 'w', 'd', 's',
+  'x', '_', 'v', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'c', 'v', 't', 'w', 'd',
+  's', 'x', '_', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'c', 'v', 't', 'w', 'd',
+  's', 'x', 'r', 'z', '_', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'c', 'v', 't', 'w',
+  'd', 's', 'x', 'r', 'z', '_', 'v', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'c',
+  'v', 't', 'w', 'd', 's', 'x', 'r', 'z', '_', 'v', 'v', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 'c', 'v', 't', 'w', 'd', 'z', 'x', '_', 'v', 'v', 'l', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v',
+  'c', 'v', 't', 'w', 'd', 'z', 'x', '_', 'v', 'v', 'm', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 'c', 'v', 't', 'w', 'd', 'z', 'x', '_', 'v', 'v', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 'c', 'v', 't', 'w', 'd', 'z', 'x', 'r', 'z', '_', 'v', 'v', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'v', 'c', 'v', 't', 'w', 'd', 'z', 'x', 'r', 'z', '_', 'v', 'v', 'm',
+  'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'v', 'c', 'v', 't', 'w', 'd', 'z', 'x', 'r', 'z', '_',
+  'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'v', 'c', 'v', 't', 'w', 's', 's', 'x', '_',
+  'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'v', 'c', 'v', 't', 'w', 's', 's', 'x', '_', 'v',
+  'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'v', 'c', 'v', 't', 'w', 's', 's', 'x', '_',
+  'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'v', 'c', 'v', 't', 'w', 's', 's', 'x', 'r',
+  'z', '_', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'c', 'v', 't', 'w', 's', 's', 'x',
+  'r', 'z', '_', 'v', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'c', 'v', 't', 'w',
+  's', 's', 'x', 'r', 'z', '_', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'c', 'v',
+  't', 'w', 's', 'z', 'x', '_', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'c', 'v', 't',
+  'w', 's', 'z', 'x', '_', 'v', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'c', 'v',
+  't', 'w', 's', 'z', 'x', '_', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'c', 'v',
+  't', 'w', 's', 'z', 'x', 'r', 'z', '_', 'v', 'v', 'l', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'c',
+  'v', 't', 'w', 's', 'z', 'x', 'r', 'z', '_', 'v', 'v', 'm', 'v', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'v', 'c', 'v', 't', 'w', 's', 'z', 'x', 'r', 'z', '_', 'v', 'v', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'd', 'i', 'v', 's', 'l', '_', 'v', 's', 'v', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'v', 'd', 'i', 'v', 's', 'l', '_', 'v', 's', 'v', 'm', 'v', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'v', 'd', 'i', 'v', 's', 'l', '_', 'v', 's', 'v', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 'd', 'i', 'v', 's', 'l', '_', 'v', 'v', 's', 'l', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'd',
+  'i', 'v', 's', 'l', '_', 'v', 'v', 's', 'm', 'v', 'l', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'd',
+  'i', 'v', 's', 'l', '_', 'v', 'v', 's', 'v', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'd', 'i',
+  'v', 's', 'l', '_', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'd', 'i', 'v', 's',
+  'l', '_', 'v', 'v', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'd', 'i', 'v', 's',
+  'l', '_', 'v', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'd', 'i', 'v', 's', 'w',
+  's', 'x', '_', 'v', 's', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'd', 'i', 'v', 's', 'w',
+  's', 'x', '_', 'v', 's', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'd', 'i', 'v',
+  's', 'w', 's', 'x', '_', 'v', 's', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'd', 'i',
+  'v', 's', 'w', 's', 'x', '_', 'v', 'v', 's', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'd', 'i',
+  'v', 's', 'w', 's', 'x', '_', 'v', 'v', 's', 'm', 'v', 'l', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v',
+  'd', 'i', 'v', 's', 'w', 's', 'x', '_', 'v', 'v', 's', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 'd', 'i', 'v', 's', 'w', 's', 'x', '_', 'v', 'v', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 'd', 'i', 'v', 's', 'w', 's', 'x', '_', 'v', 'v', 'v', 'm', 'v', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'v', 'd', 'i', 'v', 's', 'w', 's', 'x', '_', 'v', 'v', 'v', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'd', 'i', 'v', 's', 'w', 'z', 'x', '_', 'v', 's', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'd', 'i', 'v', 's', 'w', 'z', 'x', '_', 'v', 's', 'v',
+  'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'v', 'd', 'i', 'v', 's', 'w', 'z', 'x', '_', 'v',
+  's', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'v', 'd', 'i', 'v', 's', 'w', 'z', 'x', '_',
+  'v', 'v', 's', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'v', 'd', 'i', 'v', 's', 'w', 'z', 'x', '_',
+  'v', 'v', 's', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'd', 'i', 'v', 's', 'w', 'z',
+  'x', '_', 'v', 'v', 's', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'd', 'i', 'v', 's', 'w',
+  'z', 'x', '_', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'd', 'i', 'v', 's', 'w',
+  'z', 'x', '_', 'v', 'v', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'd', 'i', 'v',
+  's', 'w', 'z', 'x', '_', 'v', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'd', 'i',
+  'v', 'u', 'l', '_', 'v', 's', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'd', 'i', 'v', 'u',
+  'l', '_', 'v', 's', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'd', 'i', 'v', 'u',
+  'l', '_', 'v', 's', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'd', 'i', 'v', 'u', 'l',
+  '_', 'v', 'v', 's', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'd', 'i', 'v', 'u', 'l', '_', 'v',
+  'v', 's', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'd', 'i', 'v', 'u', 'l', '_', 'v',
+  'v', 's', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'v', 'd', 'i', 'v', 'u', 'l', '_', 'v', 'v',
+  'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'v', 'd', 'i', 'v', 'u', 'l', '_', 'v', 'v', 'v', 'm',
+  'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'v', 'd', 'i', 'v', 'u', 'l', '_', 'v', 'v', 'v', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'd', 'i', 'v', 'u', 'w', '_', 'v', 's', 'v', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'v', 'd', 'i', 'v', 'u', 'w', '_', 'v', 's', 'v', 'm', 'v', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'v', 'd', 'i', 'v', 'u', 'w', '_', 'v', 's', 'v', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 'd', 'i', 'v', 'u', 'w', '_', 'v', 'v', 's', 'l', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'd',
+  'i', 'v', 'u', 'w', '_', 'v', 'v', 's', 'm', 'v', 'l', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'd',
+  'i', 'v', 'u', 'w', '_', 'v', 'v', 's', 'v', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'd', 'i',
+  'v', 'u', 'w', '_', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'd', 'i', 'v', 'u',
+  'w', '_', 'v', 'v', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'd', 'i', 'v', 'u',
+  'w', '_', 'v', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'e', 'q', 'v', '_', 'v',
+  's', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'v', 'e', 'q', 'v', '_', 'v', 's', 'v', 'm', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'e', 'q', 'v', '_', 'v', 's', 'v', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 'e', 'q', 'v', '_', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'e', 'q', 'v',
+  '_', 'v', 'v', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'e', 'q', 'v', '_', 'v',
+  'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'v', 'e', 'x', '_', 'v', 'v', 'm', 'v', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'v', 'f', 'a', 'd', 'd', 'd', '_', 'v', 's', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 'f', 'a', 'd', 'd', 'd', '_', 'v', 's', 'v', 'm', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 'f', 'a', 'd', 'd', 'd', '_', 'v', 's', 'v', 'v', 'l', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v',
+  'f', 'a', 'd', 'd', 'd', '_', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'a',
+  'd', 'd', 'd', '_', 'v', 'v', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'a',
+  'd', 'd', 'd', '_', 'v', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'a', 'd',
+  'd', 's', '_', 'v', 's', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'a', 'd', 'd', 's',
+  '_', 'v', 's', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'a', 'd', 'd', 's',
+  '_', 'v', 's', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'a', 'd', 'd', 's', '_',
+  'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'a', 'd', 'd', 's', '_', 'v', 'v',
+  'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'a', 'd', 'd', 's', '_', 'v', 'v',
+  'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'v', 'f', 'c', 'm', 'p', 'd', '_', 'v', 's', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'f', 'c', 'm', 'p', 'd', '_', 'v', 's', 'v', 'm', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'f', 'c', 'm', 'p', 'd', '_', 'v', 's', 'v', 'v', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'v', 'f', 'c', 'm', 'p', 'd', '_', 'v', 'v', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 'f', 'c', 'm', 'p', 'd', '_', 'v', 'v', 'v', 'm', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 'f', 'c', 'm', 'p', 'd', '_', 'v', 'v', 'v', 'v', 'l', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v',
+  'f', 'c', 'm', 'p', 's', '_', 'v', 's', 'v', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'c',
+  'm', 'p', 's', '_', 'v', 's', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'c',
+  'm', 'p', 's', '_', 'v', 's', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'c', 'm',
+  'p', 's', '_', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'c', 'm', 'p', 's',
+  '_', 'v', 'v', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'c', 'm', 'p', 's',
+  '_', 'v', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'd', 'i', 'v', 'd', '_',
+  'v', 's', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'd', 'i', 'v', 'd', '_', 'v', 's',
+  'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'd', 'i', 'v', 'd', '_', 'v', 's',
+  'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'v', 'f', 'd', 'i', 'v', 'd', '_', 'v', 'v', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'f', 'd', 'i', 'v', 'd', '_', 'v', 'v', 'v', 'm', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'f', 'd', 'i', 'v', 'd', '_', 'v', 'v', 'v', 'v', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'v', 'f', 'd', 'i', 'v', 's', '_', 'v', 's', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 'f', 'd', 'i', 'v', 's', '_', 'v', 's', 'v', 'm', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 'f', 'd', 'i', 'v', 's', '_', 'v', 's', 'v', 'v', 'l', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v',
+  'f', 'd', 'i', 'v', 's', '_', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'd',
+  'i', 'v', 's', '_', 'v', 'v', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'd',
+  'i', 'v', 's', '_', 'v', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'a',
+  'd', 'd', '_', 'v', 's', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'a', 'd',
+  'd', '_', 'v', 's', 'v', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'a',
+  'd', 'd', '_', 'v', 's', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'a',
+  'd', 'd', '_', 'v', 'v', 's', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'a', 'd',
+  'd', '_', 'v', 'v', 's', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'a',
+  'd', 'd', '_', 'v', 'v', 's', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'a',
+  'd', 'd', '_', 'v', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'a', 'd',
+  'd', '_', 'v', 'v', 'v', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'a',
+  'd', 'd', '_', 'v', 'v', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'a',
+  'd', 's', '_', 'v', 's', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'a', 'd',
+  's', '_', 'v', 's', 'v', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'a',
+  'd', 's', '_', 'v', 's', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'a',
+  'd', 's', '_', 'v', 'v', 's', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'a', 'd',
+  's', '_', 'v', 'v', 's', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'a',
+  'd', 's', '_', 'v', 'v', 's', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'a',
+  'd', 's', '_', 'v', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'a', 'd',
+  's', '_', 'v', 'v', 'v', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'a',
+  'd', 's', '_', 'v', 'v', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'a',
+  'x', 'd', '_', 'v', 's', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'a', 'x', 'd',
+  '_', 'v', 's', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'a', 'x', 'd',
+  '_', 'v', 's', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'a', 'x', 'd', '_',
+  'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'a', 'x', 'd', '_', 'v', 'v',
+  'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'a', 'x', 'd', '_', 'v', 'v',
+  'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'a', 'x', 's', '_', 'v', 's', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'f', 'm', 'a', 'x', 's', '_', 'v', 's', 'v', 'm', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'f', 'm', 'a', 'x', 's', '_', 'v', 's', 'v', 'v', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'v', 'f', 'm', 'a', 'x', 's', '_', 'v', 'v', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 'f', 'm', 'a', 'x', 's', '_', 'v', 'v', 'v', 'm', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 'f', 'm', 'a', 'x', 's', '_', 'v', 'v', 'v', 'v', 'l', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v',
+  'f', 'm', 'i', 'n', 'd', '_', 'v', 's', 'v', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm',
+  'i', 'n', 'd', '_', 'v', 's', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm',
+  'i', 'n', 'd', '_', 'v', 's', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'i',
+  'n', 'd', '_', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'i', 'n', 'd',
+  '_', 'v', 'v', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'i', 'n', 'd',
+  '_', 'v', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'i', 'n', 's', '_',
+  'v', 's', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'i', 'n', 's', '_', 'v', 's',
+  'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'i', 'n', 's', '_', 'v', 's',
+  'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'i', 'n', 's', '_', 'v', 'v', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'f', 'm', 'i', 'n', 's', '_', 'v', 'v', 'v', 'm', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'f', 'm', 'i', 'n', 's', '_', 'v', 'v', 'v', 'v', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'v', 'f', 'm', 'k', 'd', 'e', 'q', '_', 'm', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 'f', 'm', 'k', 'd', 'e', 'q', '_', 'm', 'v', 'm', 'l', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v',
+  'f', 'm', 'k', 'd', 'e', 'q', 'n', 'a', 'n', '_', 'm', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 'f', 'm', 'k', 'd', 'e', 'q', 'n', 'a', 'n', '_', 'm', 'v', 'm', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'v', 'f', 'm', 'k', 'd', 'g', 'e', '_', 'm', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 'f', 'm', 'k', 'd', 'g', 'e', '_', 'm', 'v', 'm', 'l', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v',
+  'f', 'm', 'k', 'd', 'g', 'e', 'n', 'a', 'n', '_', 'm', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 'f', 'm', 'k', 'd', 'g', 'e', 'n', 'a', 'n', '_', 'm', 'v', 'm', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'v', 'f', 'm', 'k', 'd', 'g', 't', '_', 'm', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 'f', 'm', 'k', 'd', 'g', 't', '_', 'm', 'v', 'm', 'l', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v',
+  'f', 'm', 'k', 'd', 'g', 't', 'n', 'a', 'n', '_', 'm', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 'f', 'm', 'k', 'd', 'g', 't', 'n', 'a', 'n', '_', 'm', 'v', 'm', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'v', 'f', 'm', 'k', 'd', 'l', 'e', '_', 'm', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 'f', 'm', 'k', 'd', 'l', 'e', '_', 'm', 'v', 'm', 'l', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v',
+  'f', 'm', 'k', 'd', 'l', 'e', 'n', 'a', 'n', '_', 'm', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 'f', 'm', 'k', 'd', 'l', 'e', 'n', 'a', 'n', '_', 'm', 'v', 'm', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'v', 'f', 'm', 'k', 'd', 'l', 't', '_', 'm', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 'f', 'm', 'k', 'd', 'l', 't', '_', 'm', 'v', 'm', 'l', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v',
+  'f', 'm', 'k', 'd', 'l', 't', 'n', 'a', 'n', '_', 'm', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 'f', 'm', 'k', 'd', 'l', 't', 'n', 'a', 'n', '_', 'm', 'v', 'm', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'v', 'f', 'm', 'k', 'd', 'n', 'a', 'n', '_', 'm', 'v', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'v', 'f', 'm', 'k', 'd', 'n', 'a', 'n', '_', 'm', 'v', 'm', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'v', 'f', 'm', 'k', 'd', 'n', 'e', '_', 'm', 'v', 'l', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v',
+  'f', 'm', 'k', 'd', 'n', 'e', '_', 'm', 'v', 'm', 'l', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f',
+  'm', 'k', 'd', 'n', 'e', 'n', 'a', 'n', '_', 'm', 'v', 'l', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v',
+  'f', 'm', 'k', 'd', 'n', 'e', 'n', 'a', 'n', '_', 'm', 'v', 'm', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'v', 'f', 'm', 'k', 'd', 'n', 'u', 'm', '_', 'm', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 'f', 'm', 'k', 'd', 'n', 'u', 'm', '_', 'm', 'v', 'm', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 'f', 'm', 'k', 'l', 'a', 'f', '_', 'm', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm',
+  'k', 'l', 'a', 't', '_', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'k', 'l', 'e',
+  'q', '_', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'k', 'l', 'e', 'q', '_',
+  'm', 'v', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'k', 'l', 'e', 'q', 'n', 'a',
+  'n', '_', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'k', 'l', 'e', 'q', 'n',
+  'a', 'n', '_', 'm', 'v', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'k', 'l', 'g',
+  'e', '_', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'k', 'l', 'g', 'e', '_',
+  'm', 'v', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'k', 'l', 'g', 'e', 'n', 'a',
+  'n', '_', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'k', 'l', 'g', 'e', 'n',
+  'a', 'n', '_', 'm', 'v', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'k', 'l', 'g',
+  't', '_', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'k', 'l', 'g', 't', '_',
+  'm', 'v', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'k', 'l', 'g', 't', 'n', 'a',
+  'n', '_', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'k', 'l', 'g', 't', 'n',
+  'a', 'n', '_', 'm', 'v', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'k', 'l', 'l',
+  'e', '_', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'k', 'l', 'l', 'e', '_',
+  'm', 'v', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'k', 'l', 'l', 'e', 'n', 'a',
+  'n', '_', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'k', 'l', 'l', 'e', 'n',
+  'a', 'n', '_', 'm', 'v', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'k', 'l', 'l',
+  't', '_', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'k', 'l', 'l', 't', '_',
+  'm', 'v', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'k', 'l', 'l', 't', 'n', 'a',
+  'n', '_', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'k', 'l', 'l', 't', 'n',
+  'a', 'n', '_', 'm', 'v', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'k', 'l', 'n',
+  'a', 'n', '_', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'k', 'l', 'n', 'a',
+  'n', '_', 'm', 'v', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'k', 'l', 'n', 'e',
+  '_', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'k', 'l', 'n', 'e', '_', 'm',
+  'v', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'k', 'l', 'n', 'e', 'n', 'a', 'n',
+  '_', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'k', 'l', 'n', 'e', 'n', 'a',
+  'n', '_', 'm', 'v', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'k', 'l', 'n', 'u',
+  'm', '_', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'k', 'l', 'n', 'u', 'm',
+  '_', 'm', 'v', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'k', 's', 'e', 'q', '_',
+  'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'k', 's', 'e', 'q', '_', 'm', 'v',
+  'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'v', 'f', 'm', 'k', 's', 'e', 'q', 'n', 'a', 'n', '_',
+  'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'k', 's', 'e', 'q', 'n', 'a', 'n',
+  '_', 'm', 'v', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'k', 's', 'g', 'e', '_',
+  'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'k', 's', 'g', 'e', '_', 'm', 'v',
+  'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'v', 'f', 'm', 'k', 's', 'g', 'e', 'n', 'a', 'n', '_',
+  'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'k', 's', 'g', 'e', 'n', 'a', 'n',
+  '_', 'm', 'v', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'k', 's', 'g', 't', '_',
+  'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'k', 's', 'g', 't', '_', 'm', 'v',
+  'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'v', 'f', 'm', 'k', 's', 'g', 't', 'n', 'a', 'n', '_',
+  'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'k', 's', 'g', 't', 'n', 'a', 'n',
+  '_', 'm', 'v', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'k', 's', 'l', 'e', '_',
+  'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'k', 's', 'l', 'e', '_', 'm', 'v',
+  'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'v', 'f', 'm', 'k', 's', 'l', 'e', 'n', 'a', 'n', '_',
+  'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'k', 's', 'l', 'e', 'n', 'a', 'n',
+  '_', 'm', 'v', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'k', 's', 'l', 't', '_',
+  'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'k', 's', 'l', 't', '_', 'm', 'v',
+  'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'v', 'f', 'm', 'k', 's', 'l', 't', 'n', 'a', 'n', '_',
+  'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'k', 's', 'l', 't', 'n', 'a', 'n',
+  '_', 'm', 'v', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'k', 's', 'n', 'a', 'n',
+  '_', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'k', 's', 'n', 'a', 'n', '_',
+  'm', 'v', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'k', 's', 'n', 'e', '_', 'm',
+  'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'v', 'f', 'm', 'k', 's', 'n', 'e', '_', 'm', 'v', 'm',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'f', 'm', 'k', 's', 'n', 'e', 'n', 'a', 'n', '_', 'm',
+  'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'v', 'f', 'm', 'k', 's', 'n', 'e', 'n', 'a', 'n', '_',
+  'm', 'v', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'k', 's', 'n', 'u', 'm', '_',
+  'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'k', 's', 'n', 'u', 'm', '_', 'm',
+  'v', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'k', 'w', 'e', 'q', '_', 'm', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'f', 'm', 'k', 'w', 'e', 'q', '_', 'm', 'v', 'm', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'v', 'f', 'm', 'k', 'w', 'e', 'q', 'n', 'a', 'n', '_', 'm', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'f', 'm', 'k', 'w', 'e', 'q', 'n', 'a', 'n', '_', 'm',
+  'v', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'k', 'w', 'g', 'e', '_', 'm', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'f', 'm', 'k', 'w', 'g', 'e', '_', 'm', 'v', 'm', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'v', 'f', 'm', 'k', 'w', 'g', 'e', 'n', 'a', 'n', '_', 'm', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'f', 'm', 'k', 'w', 'g', 'e', 'n', 'a', 'n', '_', 'm',
+  'v', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'k', 'w', 'g', 't', '_', 'm', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'f', 'm', 'k', 'w', 'g', 't', '_', 'm', 'v', 'm', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'v', 'f', 'm', 'k', 'w', 'g', 't', 'n', 'a', 'n', '_', 'm', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'f', 'm', 'k', 'w', 'g', 't', 'n', 'a', 'n', '_', 'm',
+  'v', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'k', 'w', 'l', 'e', '_', 'm', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'f', 'm', 'k', 'w', 'l', 'e', '_', 'm', 'v', 'm', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'v', 'f', 'm', 'k', 'w', 'l', 'e', 'n', 'a', 'n', '_', 'm', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'f', 'm', 'k', 'w', 'l', 'e', 'n', 'a', 'n', '_', 'm',
+  'v', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'k', 'w', 'l', 't', '_', 'm', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'f', 'm', 'k', 'w', 'l', 't', '_', 'm', 'v', 'm', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'v', 'f', 'm', 'k', 'w', 'l', 't', 'n', 'a', 'n', '_', 'm', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'f', 'm', 'k', 'w', 'l', 't', 'n', 'a', 'n', '_', 'm',
+  'v', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'k', 'w', 'n', 'a', 'n', '_', 'm',
+  'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'v', 'f', 'm', 'k', 'w', 'n', 'a', 'n', '_', 'm', 'v',
+  'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'v', 'f', 'm', 'k', 'w', 'n', 'e', '_', 'm', 'v', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'v', 'f', 'm', 'k', 'w', 'n', 'e', '_', 'm', 'v', 'm', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'v', 'f', 'm', 'k', 'w', 'n', 'e', 'n', 'a', 'n', '_', 'm', 'v', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'v', 'f', 'm', 'k', 'w', 'n', 'e', 'n', 'a', 'n', '_', 'm', 'v',
+  'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'v', 'f', 'm', 'k', 'w', 'n', 'u', 'm', '_', 'm', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'f', 'm', 'k', 'w', 'n', 'u', 'm', '_', 'm', 'v', 'm',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'f', 'm', 's', 'b', 'd', '_', 'v', 's', 'v', 'v', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'v', 'f', 'm', 's', 'b', 'd', '_', 'v', 's', 'v', 'v', 'm', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'f', 'm', 's', 'b', 'd', '_', 'v', 's', 'v', 'v', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'f', 'm', 's', 'b', 'd', '_', 'v', 'v', 's', 'v', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'v', 'f', 'm', 's', 'b', 'd', '_', 'v', 'v', 's', 'v', 'm', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'f', 'm', 's', 'b', 'd', '_', 'v', 'v', 's', 'v', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'f', 'm', 's', 'b', 'd', '_', 'v', 'v', 'v', 'v', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'v', 'f', 'm', 's', 'b', 'd', '_', 'v', 'v', 'v', 'v', 'm', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'f', 'm', 's', 'b', 'd', '_', 'v', 'v', 'v', 'v', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'f', 'm', 's', 'b', 's', '_', 'v', 's', 'v', 'v', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'v', 'f', 'm', 's', 'b', 's', '_', 'v', 's', 'v', 'v', 'm', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'f', 'm', 's', 'b', 's', '_', 'v', 's', 'v', 'v', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'f', 'm', 's', 'b', 's', '_', 'v', 'v', 's', 'v', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'v', 'f', 'm', 's', 'b', 's', '_', 'v', 'v', 's', 'v', 'm', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'f', 'm', 's', 'b', 's', '_', 'v', 'v', 's', 'v', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'f', 'm', 's', 'b', 's', '_', 'v', 'v', 'v', 'v', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'v', 'f', 'm', 's', 'b', 's', '_', 'v', 'v', 'v', 'v', 'm', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'f', 'm', 's', 'b', 's', '_', 'v', 'v', 'v', 'v', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'f', 'm', 'u', 'l', 'd', '_', 'v', 's', 'v', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'v', 'f', 'm', 'u', 'l', 'd', '_', 'v', 's', 'v', 'm', 'v', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'v', 'f', 'm', 'u', 'l', 'd', '_', 'v', 's', 'v', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 'f', 'm', 'u', 'l', 'd', '_', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f',
+  'm', 'u', 'l', 'd', '_', 'v', 'v', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f',
+  'm', 'u', 'l', 'd', '_', 'v', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm',
+  'u', 'l', 's', '_', 'v', 's', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'u', 'l',
+  's', '_', 'v', 's', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'u', 'l',
+  's', '_', 'v', 's', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'u', 'l', 's',
+  '_', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'u', 'l', 's', '_', 'v',
+  'v', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'm', 'u', 'l', 's', '_', 'v',
+  'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'n', 'm', 'a', 'd', 'd', '_', 'v',
+  's', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'n', 'm', 'a', 'd', 'd', '_', 'v',
+  's', 'v', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'n', 'm', 'a', 'd', 'd',
+  '_', 'v', 's', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'n', 'm', 'a', 'd',
+  'd', '_', 'v', 'v', 's', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'n', 'm', 'a', 'd',
+  'd', '_', 'v', 'v', 's', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'n', 'm',
+  'a', 'd', 'd', '_', 'v', 'v', 's', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'n',
+  'm', 'a', 'd', 'd', '_', 'v', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'n',
+  'm', 'a', 'd', 'd', '_', 'v', 'v', 'v', 'v', 'm', 'v', 'l', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v',
+  'f', 'n', 'm', 'a', 'd', 'd', '_', 'v', 'v', 'v', 'v', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 'f', 'n', 'm', 'a', 'd', 's', '_', 'v', 's', 'v', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 'f', 'n', 'm', 'a', 'd', 's', '_', 'v', 's', 'v', 'v', 'm', 'v', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'v', 'f', 'n', 'm', 'a', 'd', 's', '_', 'v', 's', 'v', 'v', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'f', 'n', 'm', 'a', 'd', 's', '_', 'v', 'v', 's', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'f', 'n', 'm', 'a', 'd', 's', '_', 'v', 'v', 's', 'v',
+  'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'v', 'f', 'n', 'm', 'a', 'd', 's', '_', 'v', 'v',
+  's', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'n', 'm', 'a', 'd', 's', '_', 'v',
+  'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'n', 'm', 'a', 'd', 's', '_', 'v',
+  'v', 'v', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'n', 'm', 'a', 'd', 's',
+  '_', 'v', 'v', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'n', 'm', 's', 'b',
+  'd', '_', 'v', 's', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'n', 'm', 's', 'b',
+  'd', '_', 'v', 's', 'v', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'n', 'm',
+  's', 'b', 'd', '_', 'v', 's', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'n',
+  'm', 's', 'b', 'd', '_', 'v', 'v', 's', 'v', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'n',
+  'm', 's', 'b', 'd', '_', 'v', 'v', 's', 'v', 'm', 'v', 'l', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v',
+  'f', 'n', 'm', 's', 'b', 'd', '_', 'v', 'v', 's', 'v', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 'f', 'n', 'm', 's', 'b', 'd', '_', 'v', 'v', 'v', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 'f', 'n', 'm', 's', 'b', 'd', '_', 'v', 'v', 'v', 'v', 'm', 'v', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'v', 'f', 'n', 'm', 's', 'b', 'd', '_', 'v', 'v', 'v', 'v', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'f', 'n', 'm', 's', 'b', 's', '_', 'v', 's', 'v', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'f', 'n', 'm', 's', 'b', 's', '_', 'v', 's', 'v', 'v',
+  'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'v', 'f', 'n', 'm', 's', 'b', 's', '_', 'v', 's',
+  'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'n', 'm', 's', 'b', 's', '_', 'v',
+  'v', 's', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'n', 'm', 's', 'b', 's', '_', 'v',
+  'v', 's', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'n', 'm', 's', 'b', 's',
+  '_', 'v', 'v', 's', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'n', 'm', 's', 'b',
+  's', '_', 'v', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'n', 'm', 's', 'b',
+  's', '_', 'v', 'v', 'v', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'n', 'm',
+  's', 'b', 's', '_', 'v', 'v', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'r',
+  'm', 'a', 'x', 'd', 'f', 's', 't', '_', 'v', 'v', 'l', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f',
+  'r', 'm', 'a', 'x', 'd', 'f', 's', 't', '_', 'v', 'v', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 'f', 'r', 'm', 'a', 'x', 'd', 'l', 's', 't', '_', 'v', 'v', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'v', 'f', 'r', 'm', 'a', 'x', 'd', 'l', 's', 't', '_', 'v', 'v', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'f', 'r', 'm', 'a', 'x', 's', 'f', 's', 't', '_', 'v',
+  'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'v', 'f', 'r', 'm', 'a', 'x', 's', 'f', 's', 't', '_',
+  'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'r', 'm', 'a', 'x', 's', 'l', 's',
+  't', '_', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'r', 'm', 'a', 'x', 's', 'l',
+  's', 't', '_', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'r', 'm', 'i', 'n',
+  'd', 'f', 's', 't', '_', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'r', 'm', 'i',
+  'n', 'd', 'f', 's', 't', '_', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 'r',
+  'm', 'i', 'n', 'd', 'l', 's', 't', '_', 'v', 'v', 'l', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f',
+  'r', 'm', 'i', 'n', 'd', 'l', 's', 't', '_', 'v', 'v', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 'f', 'r', 'm', 'i', 'n', 's', 'f', 's', 't', '_', 'v', 'v', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'v', 'f', 'r', 'm', 'i', 'n', 's', 'f', 's', 't', '_', 'v', 'v', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'f', 'r', 'm', 'i', 'n', 's', 'l', 's', 't', '_', 'v',
+  'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'v', 'f', 'r', 'm', 'i', 'n', 's', 'l', 's', 't', '_',
+  'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 's', 'q', 'r', 't', 'd', '_', 'v',
+  'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'v', 'f', 's', 'q', 'r', 't', 'd', '_', 'v', 'v', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'f', 's', 'q', 'r', 't', 's', '_', 'v', 'v', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'v', 'f', 's', 'q', 'r', 't', 's', '_', 'v', 'v', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 'f', 's', 'u', 'b', 'd', '_', 'v', 's', 'v', 'l', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f',
+  's', 'u', 'b', 'd', '_', 'v', 's', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f',
+  's', 'u', 'b', 'd', '_', 'v', 's', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 's',
+  'u', 'b', 'd', '_', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 's', 'u', 'b',
+  'd', '_', 'v', 'v', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 's', 'u', 'b',
+  'd', '_', 'v', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 's', 'u', 'b', 's',
+  '_', 'v', 's', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 's', 'u', 'b', 's', '_', 'v',
+  's', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 's', 'u', 'b', 's', '_', 'v',
+  's', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 's', 'u', 'b', 's', '_', 'v', 'v',
+  'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'v', 'f', 's', 'u', 'b', 's', '_', 'v', 'v', 'v', 'm',
+  'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'v', 'f', 's', 'u', 'b', 's', '_', 'v', 'v', 'v', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'f', 's', 'u', 'm', 'd', '_', 'v', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 'f', 's', 'u', 'm', 'd', '_', 'v', 'v', 'm', 'l', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f',
+  's', 'u', 'm', 's', '_', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'f', 's', 'u', 'm',
+  's', '_', 'v', 'v', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'g', 't', '_', 'v', 'v', 's',
+  's', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'v', 'g', 't', '_', 'v', 'v', 's', 's', 'm', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'v', 'g', 't', '_', 'v', 'v', 's', 's', 'm', 'v', 'l', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v',
+  'g', 't', '_', 'v', 'v', 's', 's', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'g', 't', 'l',
+  's', 'x', '_', 'v', 'v', 's', 's', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'g', 't', 'l', 's',
+  'x', '_', 'v', 'v', 's', 's', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'g', 't', 'l', 's',
+  'x', '_', 'v', 'v', 's', 's', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'g', 't', 'l',
+  's', 'x', '_', 'v', 'v', 's', 's', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'g', 't', 'l',
+  's', 'x', 'n', 'c', '_', 'v', 'v', 's', 's', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'g', 't',
+  'l', 's', 'x', 'n', 'c', '_', 'v', 'v', 's', 's', 'm', 'l', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v',
+  'g', 't', 'l', 's', 'x', 'n', 'c', '_', 'v', 'v', 's', 's', 'm', 'v', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'v', 'g', 't', 'l', 's', 'x', 'n', 'c', '_', 'v', 'v', 's', 's',
+  'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'v', 'g', 't', 'l', 'z', 'x', '_', 'v', 'v', 's', 's',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'g', 't', 'l', 'z', 'x', '_', 'v', 'v', 's', 's', 'm',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'g', 't', 'l', 'z', 'x', '_', 'v', 'v', 's', 's', 'm',
+  'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'v', 'g', 't', 'l', 'z', 'x', '_', 'v', 'v', 's', 's',
+  'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'v', 'g', 't', 'l', 'z', 'x', 'n', 'c', '_', 'v', 'v',
+  's', 's', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'v', 'g', 't', 'l', 'z', 'x', 'n', 'c', '_', 'v',
+  'v', 's', 's', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'g', 't', 'l', 'z', 'x', 'n', 'c',
+  '_', 'v', 'v', 's', 's', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'g', 't', 'l', 'z',
+  'x', 'n', 'c', '_', 'v', 'v', 's', 's', 'v', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'g', 't',
+  'n', 'c', '_', 'v', 'v', 's', 's', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'g', 't', 'n', 'c',
+  '_', 'v', 'v', 's', 's', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'g', 't', 'n', 'c', '_',
+  'v', 'v', 's', 's', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'g', 't', 'n', 'c', '_',
+  'v', 'v', 's', 's', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'g', 't', 'u', '_', 'v', 'v',
+  's', 's', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'v', 'g', 't', 'u', '_', 'v', 'v', 's', 's', 'm',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'g', 't', 'u', '_', 'v', 'v', 's', 's', 'm', 'v', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'v', 'g', 't', 'u', '_', 'v', 'v', 's', 's', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 'g', 't', 'u', 'n', 'c', '_', 'v', 'v', 's', 's', 'l', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v',
+  'g', 't', 'u', 'n', 'c', '_', 'v', 'v', 's', 's', 'm', 'l', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v',
+  'g', 't', 'u', 'n', 'c', '_', 'v', 'v', 's', 's', 'm', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 'g', 't', 'u', 'n', 'c', '_', 'v', 'v', 's', 's', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 'l', 'd', '_', 'v', 's', 's', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'l', 'd', '_', 'v',
+  's', 's', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'v', 'l', 'd', '2', 'd', '_', 'v', 's', 's',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'l', 'd', '2', 'd', '_', 'v', 's', 's', 'v', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'v', 'l', 'd', '2', 'd', 'n', 'c', '_', 'v', 's', 's', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 'l', 'd', '2', 'd', 'n', 'c', '_', 'v', 's', 's', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 'l', 'd', 'l', '2', 'd', 's', 'x', '_', 'v', 's', 's', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 'l', 'd', 'l', '2', 'd', 's', 'x', '_', 'v', 's', 's', 'v', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'v', 'l', 'd', 'l', '2', 'd', 's', 'x', 'n', 'c', '_', 'v', 's', 's',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'l', 'd', 'l', '2', 'd', 's', 'x', 'n', 'c', '_', 'v',
+  's', 's', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'v', 'l', 'd', 'l', '2', 'd', 'z', 'x', '_',
+  'v', 's', 's', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'v', 'l', 'd', 'l', '2', 'd', 'z', 'x', '_',
+  'v', 's', 's', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'l', 'd', 'l', '2', 'd', 'z', 'x',
+  'n', 'c', '_', 'v', 's', 's', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'l', 'd', 'l', '2', 'd',
+  'z', 'x', 'n', 'c', '_', 'v', 's', 's', 'v', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'l', 'd',
+  'l', 's', 'x', '_', 'v', 's', 's', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'l', 'd', 'l', 's',
+  'x', '_', 'v', 's', 's', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'l', 'd', 'l', 's', 'x',
+  'n', 'c', '_', 'v', 's', 's', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'l', 'd', 'l', 's', 'x',
+  'n', 'c', '_', 'v', 's', 's', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'l', 'd', 'l', 'z',
+  'x', '_', 'v', 's', 's', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'l', 'd', 'l', 'z', 'x', '_',
+  'v', 's', 's', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'l', 'd', 'l', 'z', 'x', 'n', 'c',
+  '_', 'v', 's', 's', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'l', 'd', 'l', 'z', 'x', 'n', 'c',
+  '_', 'v', 's', 's', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'l', 'd', 'n', 'c', '_', 'v',
+  's', 's', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'v', 'l', 'd', 'n', 'c', '_', 'v', 's', 's', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'l', 'd', 'u', '_', 'v', 's', 's', 'l', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v',
+  'l', 'd', 'u', '_', 'v', 's', 's', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'l', 'd', 'u',
+  '2', 'd', '_', 'v', 's', 's', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'l', 'd', 'u', '2', 'd',
+  '_', 'v', 's', 's', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'l', 'd', 'u', '2', 'd', 'n',
+  'c', '_', 'v', 's', 's', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'l', 'd', 'u', '2', 'd', 'n',
+  'c', '_', 'v', 's', 's', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'l', 'd', 'u', 'n', 'c',
+  '_', 'v', 's', 's', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'l', 'd', 'u', 'n', 'c', '_', 'v',
+  's', 's', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'v', 'm', 'a', 'x', 's', 'l', '_', 'v', 's',
+  'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'v', 'm', 'a', 'x', 's', 'l', '_', 'v', 's', 'v', 'm',
+  'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'v', 'm', 'a', 'x', 's', 'l', '_', 'v', 's', 'v', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'm', 'a', 'x', 's', 'l', '_', 'v', 'v', 'v', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'v', 'm', 'a', 'x', 's', 'l', '_', 'v', 'v', 'v', 'm', 'v', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'v', 'm', 'a', 'x', 's', 'l', '_', 'v', 'v', 'v', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 'm', 'a', 'x', 's', 'w', 's', 'x', '_', 'v', 's', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 'm', 'a', 'x', 's', 'w', 's', 'x', '_', 'v', 's', 'v', 'm', 'v', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'v', 'm', 'a', 'x', 's', 'w', 's', 'x', '_', 'v', 's', 'v', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'm', 'a', 'x', 's', 'w', 's', 'x', '_', 'v', 'v', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'm', 'a', 'x', 's', 'w', 's', 'x', '_', 'v', 'v', 'v',
+  'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'v', 'm', 'a', 'x', 's', 'w', 's', 'x', '_', 'v',
+  'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'v', 'm', 'a', 'x', 's', 'w', 'z', 'x', '_',
+  'v', 's', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'v', 'm', 'a', 'x', 's', 'w', 'z', 'x', '_',
+  'v', 's', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'm', 'a', 'x', 's', 'w', 'z',
+  'x', '_', 'v', 's', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'm', 'a', 'x', 's', 'w',
+  'z', 'x', '_', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'm', 'a', 'x', 's', 'w',
+  'z', 'x', '_', 'v', 'v', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'm', 'a', 'x',
+  's', 'w', 'z', 'x', '_', 'v', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'm', 'i',
+  'n', 's', 'l', '_', 'v', 's', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'm', 'i', 'n', 's',
+  'l', '_', 'v', 's', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'm', 'i', 'n', 's',
+  'l', '_', 'v', 's', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'm', 'i', 'n', 's', 'l',
+  '_', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'm', 'i', 'n', 's', 'l', '_', 'v',
+  'v', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'm', 'i', 'n', 's', 'l', '_', 'v',
+  'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'v', 'm', 'i', 'n', 's', 'w', 's', 'x', '_',
+  'v', 's', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'v', 'm', 'i', 'n', 's', 'w', 's', 'x', '_',
+  'v', 's', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'm', 'i', 'n', 's', 'w', 's',
+  'x', '_', 'v', 's', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'm', 'i', 'n', 's', 'w',
+  's', 'x', '_', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'm', 'i', 'n', 's', 'w',
+  's', 'x', '_', 'v', 'v', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'm', 'i', 'n',
+  's', 'w', 's', 'x', '_', 'v', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'm', 'i',
+  'n', 's', 'w', 'z', 'x', '_', 'v', 's', 'v', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'm', 'i',
+  'n', 's', 'w', 'z', 'x', '_', 'v', 's', 'v', 'm', 'v', 'l', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v',
+  'm', 'i', 'n', 's', 'w', 'z', 'x', '_', 'v', 's', 'v', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 'm', 'i', 'n', 's', 'w', 'z', 'x', '_', 'v', 'v', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 'm', 'i', 'n', 's', 'w', 'z', 'x', '_', 'v', 'v', 'v', 'm', 'v', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'v', 'm', 'i', 'n', 's', 'w', 'z', 'x', '_', 'v', 'v', 'v', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'm', 'r', 'g', '_', 'v', 's', 'v', 'm', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 'm', 'r', 'g', '_', 'v', 's', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'm',
+  'r', 'g', '_', 'v', 'v', 'v', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'm', 'r', 'g', '_',
+  'v', 'v', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'm', 'r', 'g', 'w', '_', 'v',
+  's', 'v', 'M', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'v', 'm', 'r', 'g', 'w', '_', 'v', 's', 'v',
+  'M', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'v', 'm', 'r', 'g', 'w', '_', 'v', 'v', 'v', 'M',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'm', 'r', 'g', 'w', '_', 'v', 'v', 'v', 'M', 'v', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'v', 'm', 'u', 'l', 's', 'l', '_', 'v', 's', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 'm', 'u', 'l', 's', 'l', '_', 'v', 's', 'v', 'm', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 'm', 'u', 'l', 's', 'l', '_', 'v', 's', 'v', 'v', 'l', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v',
+  'm', 'u', 'l', 's', 'l', '_', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'm', 'u',
+  'l', 's', 'l', '_', 'v', 'v', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'm', 'u',
+  'l', 's', 'l', '_', 'v', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'm', 'u', 'l',
+  's', 'l', 'w', '_', 'v', 's', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'm', 'u', 'l', 's',
+  'l', 'w', '_', 'v', 's', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'm', 'u', 'l', 's',
+  'l', 'w', '_', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'm', 'u', 'l', 's', 'l',
+  'w', '_', 'v', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'm', 'u', 'l', 's', 'w',
+  's', 'x', '_', 'v', 's', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'm', 'u', 'l', 's', 'w',
+  's', 'x', '_', 'v', 's', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'm', 'u', 'l',
+  's', 'w', 's', 'x', '_', 'v', 's', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'm', 'u',
+  'l', 's', 'w', 's', 'x', '_', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'm', 'u',
+  'l', 's', 'w', 's', 'x', '_', 'v', 'v', 'v', 'm', 'v', 'l', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v',
+  'm', 'u', 'l', 's', 'w', 's', 'x', '_', 'v', 'v', 'v', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 'm', 'u', 'l', 's', 'w', 'z', 'x', '_', 'v', 's', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 'm', 'u', 'l', 's', 'w', 'z', 'x', '_', 'v', 's', 'v', 'm', 'v', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'v', 'm', 'u', 'l', 's', 'w', 'z', 'x', '_', 'v', 's', 'v', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'm', 'u', 'l', 's', 'w', 'z', 'x', '_', 'v', 'v', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'm', 'u', 'l', 's', 'w', 'z', 'x', '_', 'v', 'v', 'v',
+  'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'v', 'm', 'u', 'l', 's', 'w', 'z', 'x', '_', 'v',
+  'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'v', 'm', 'u', 'l', 'u', 'l', '_', 'v', 's',
+  'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'v', 'm', 'u', 'l', 'u', 'l', '_', 'v', 's', 'v', 'm',
+  'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'v', 'm', 'u', 'l', 'u', 'l', '_', 'v', 's', 'v', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'm', 'u', 'l', 'u', 'l', '_', 'v', 'v', 'v', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'v', 'm', 'u', 'l', 'u', 'l', '_', 'v', 'v', 'v', 'm', 'v', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'v', 'm', 'u', 'l', 'u', 'l', '_', 'v', 'v', 'v', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 'm', 'u', 'l', 'u', 'w', '_', 'v', 's', 'v', 'l', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'm',
+  'u', 'l', 'u', 'w', '_', 'v', 's', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'm',
+  'u', 'l', 'u', 'w', '_', 'v', 's', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'm', 'u',
+  'l', 'u', 'w', '_', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'm', 'u', 'l', 'u',
+  'w', '_', 'v', 'v', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'm', 'u', 'l', 'u',
+  'w', '_', 'v', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'm', 'v', '_', 'v', 's',
+  'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'v', 'm', 'v', '_', 'v', 's', 'v', 'm', 'v', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'v', 'm', 'v', '_', 'v', 's', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'o', 'r',
+  '_', 'v', 's', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'o', 'r', '_', 'v', 's', 'v', 'm',
+  'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'v', 'o', 'r', '_', 'v', 's', 'v', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 'o', 'r', '_', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'o', 'r', '_', 'v',
+  'v', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'o', 'r', '_', 'v', 'v', 'v', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'r', 'a', 'n', 'd', '_', 'v', 'v', 'l', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v',
+  'r', 'a', 'n', 'd', '_', 'v', 'v', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'r', 'c', 'p',
+  'd', '_', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'r', 'c', 'p', 'd', '_', 'v', 'v',
+  'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'v', 'r', 'c', 'p', 's', '_', 'v', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 'r', 'c', 'p', 's', '_', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'r', 'm',
+  'a', 'x', 's', 'l', 'f', 's', 't', '_', 'v', 'v', 'l', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'r',
+  'm', 'a', 'x', 's', 'l', 'f', 's', 't', '_', 'v', 'v', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 'r', 'm', 'a', 'x', 's', 'l', 'l', 's', 't', '_', 'v', 'v', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'v', 'r', 'm', 'a', 'x', 's', 'l', 'l', 's', 't', '_', 'v', 'v', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 'r', 'm', 'a', 'x', 's', 'w', 'f', 's', 't', 's', 'x',
+  '_', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'v', 'r', 'm', 'a', 'x', 's', 'w', 'f', 's',
+  't', 's', 'x', '_', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'r', 'm', 'a', 'x',
+  's', 'w', 'f', 's', 't', 'z', 'x', '_', 'v', 'v', 'l', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'r',
+  'm', 'a', 'x', 's', 'w', 'f', 's', 't', 'z', 'x', '_', 'v', 'v', 'v', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'v', 'r', 'm', 'a', 'x', 's', 'w', 'l', 's', 't', 's', 'x', '_',
+  'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'v', 'r', 'm', 'a', 'x', 's', 'w', 'l', 's', 't',
+  's', 'x', '_', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'r', 'm', 'a', 'x', 's',
+  'w', 'l', 's', 't', 'z', 'x', '_', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'r', 'm',
+  'a', 'x', 's', 'w', 'l', 's', 't', 'z', 'x', '_', 'v', 'v', 'v', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'v', 'r', 'm', 'i', 'n', 's', 'l', 'f', 's', 't', '_', 'v', 'v', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'v', 'r', 'm', 'i', 'n', 's', 'l', 'f', 's', 't', '_', 'v', 'v',
+  'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'v', 'r', 'm', 'i', 'n', 's', 'l', 'l', 's', 't', '_',
+  'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'v', 'r', 'm', 'i', 'n', 's', 'l', 'l', 's', 't',
+  '_', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'r', 'm', 'i', 'n', 's', 'w', 'f',
+  's', 't', 's', 'x', '_', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'r', 'm', 'i', 'n',
+  's', 'w', 'f', 's', 't', 's', 'x', '_', 'v', 'v', 'v', 'l', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v',
+  'r', 'm', 'i', 'n', 's', 'w', 'f', 's', 't', 'z', 'x', '_', 'v', 'v', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'v', 'r', 'm', 'i', 'n', 's', 'w', 'f', 's', 't', 'z', 'x', '_',
+  'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'v', 'r', 'm', 'i', 'n', 's', 'w', 'l', 's',
+  't', 's', 'x', '_', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'r', 'm', 'i', 'n', 's',
+  'w', 'l', 's', 't', 's', 'x', '_', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'r',
+  'm', 'i', 'n', 's', 'w', 'l', 's', 't', 'z', 'x', '_', 'v', 'v', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'v', 'r', 'm', 'i', 'n', 's', 'w', 'l', 's', 't', 'z', 'x', '_', 'v',
+  'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'v', 'r', 'o', 'r', '_', 'v', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 'r', 'o', 'r', '_', 'v', 'v', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'r', 's', 'q',
+  'r', 't', 'd', '_', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'r', 's', 'q', 'r', 't',
+  'd', '_', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'r', 's', 'q', 'r', 't', 'd',
+  'n', 'e', 'x', '_', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'r', 's', 'q', 'r', 't',
+  'd', 'n', 'e', 'x', '_', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'r', 's', 'q',
+  'r', 't', 's', '_', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'r', 's', 'q', 'r', 't',
+  's', '_', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'r', 's', 'q', 'r', 't', 's',
+  'n', 'e', 'x', '_', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'r', 's', 'q', 'r', 't',
+  's', 'n', 'e', 'x', '_', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'r', 'x', 'o',
+  'r', '_', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'r', 'x', 'o', 'r', '_', 'v', 'v',
+  'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'v', 's', 'c', '_', 'v', 'v', 's', 's', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 's', 'c', '_', 'v', 'v', 's', 's', 'm', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'c',
+  'l', '_', 'v', 'v', 's', 's', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'c', 'l', '_', 'v',
+  'v', 's', 's', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'c', 'l', 'n', 'c', '_', 'v',
+  'v', 's', 's', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'c', 'l', 'n', 'c', '_', 'v', 'v',
+  's', 's', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'c', 'l', 'n', 'c', 'o', 't', '_',
+  'v', 'v', 's', 's', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'c', 'l', 'n', 'c', 'o', 't',
+  '_', 'v', 'v', 's', 's', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'c', 'l', 'o', 't',
+  '_', 'v', 'v', 's', 's', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'c', 'l', 'o', 't', '_',
+  'v', 'v', 's', 's', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'c', 'n', 'c', '_', 'v',
+  'v', 's', 's', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'c', 'n', 'c', '_', 'v', 'v', 's',
+  's', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'v', 's', 'c', 'n', 'c', 'o', 't', '_', 'v', 'v',
+  's', 's', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'v', 's', 'c', 'n', 'c', 'o', 't', '_', 'v', 'v',
+  's', 's', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'c', 'o', 't', '_', 'v', 'v', 's',
+  's', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'v', 's', 'c', 'o', 't', '_', 'v', 'v', 's', 's', 'm',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 's', 'c', 'u', '_', 'v', 'v', 's', 's', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 's', 'c', 'u', '_', 'v', 'v', 's', 's', 'm', 'l', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's',
+  'c', 'u', 'n', 'c', '_', 'v', 'v', 's', 's', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'c',
+  'u', 'n', 'c', '_', 'v', 'v', 's', 's', 'm', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'c',
+  'u', 'n', 'c', 'o', 't', '_', 'v', 'v', 's', 's', 'l', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's',
+  'c', 'u', 'n', 'c', 'o', 't', '_', 'v', 'v', 's', 's', 'm', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 's', 'c', 'u', 'o', 't', '_', 'v', 'v', 's', 's', 'l', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v',
+  's', 'c', 'u', 'o', 't', '_', 'v', 'v', 's', 's', 'm', 'l', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v',
+  's', 'e', 'q', '_', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'e', 'q', '_', 'v', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 's', 'f', 'a', '_', 'v', 'v', 's', 's', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 's', 'f', 'a', '_', 'v', 'v', 's', 's', 'm', 'v', 'l', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v',
+  's', 'f', 'a', '_', 'v', 'v', 's', 's', 'v', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'h',
+  'f', '_', 'v', 'v', 'v', 's', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'h', 'f', '_', 'v',
+  'v', 'v', 's', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'l', 'a', 'l', '_', 'v', 'v',
+  's', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'v', 's', 'l', 'a', 'l', '_', 'v', 'v', 's', 'm', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 's', 'l', 'a', 'l', '_', 'v', 'v', 's', 'v', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'v', 's', 'l', 'a', 'l', '_', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's',
+  'l', 'a', 'l', '_', 'v', 'v', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'l',
+  'a', 'l', '_', 'v', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'l', 'a', 'w',
+  's', 'x', '_', 'v', 'v', 's', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'l', 'a', 'w', 's',
+  'x', '_', 'v', 'v', 's', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'l', 'a', 'w',
+  's', 'x', '_', 'v', 'v', 's', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'l', 'a', 'w',
+  's', 'x', '_', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'l', 'a', 'w', 's',
+  'x', '_', 'v', 'v', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'l', 'a', 'w',
+  's', 'x', '_', 'v', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'l', 'a', 'w',
+  'z', 'x', '_', 'v', 'v', 's', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'l', 'a', 'w', 'z',
+  'x', '_', 'v', 'v', 's', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'l', 'a', 'w',
+  'z', 'x', '_', 'v', 'v', 's', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'l', 'a', 'w',
+  'z', 'x', '_', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'l', 'a', 'w', 'z',
+  'x', '_', 'v', 'v', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'l', 'a', 'w',
+  'z', 'x', '_', 'v', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'l', 'l', '_',
+  'v', 'v', 's', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'l', 'l', '_', 'v', 'v', 's', 'm',
+  'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'v', 's', 'l', 'l', '_', 'v', 'v', 's', 'v', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'v', 's', 'l', 'l', '_', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'l',
+  'l', '_', 'v', 'v', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'l', 'l', '_',
+  'v', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'r', 'a', 'l', '_', 'v', 'v',
+  's', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'v', 's', 'r', 'a', 'l', '_', 'v', 'v', 's', 'm', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 's', 'r', 'a', 'l', '_', 'v', 'v', 's', 'v', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'v', 's', 'r', 'a', 'l', '_', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's',
+  'r', 'a', 'l', '_', 'v', 'v', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'r',
+  'a', 'l', '_', 'v', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'r', 'a', 'w',
+  's', 'x', '_', 'v', 'v', 's', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'r', 'a', 'w', 's',
+  'x', '_', 'v', 'v', 's', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'r', 'a', 'w',
+  's', 'x', '_', 'v', 'v', 's', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'r', 'a', 'w',
+  's', 'x', '_', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'r', 'a', 'w', 's',
+  'x', '_', 'v', 'v', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'r', 'a', 'w',
+  's', 'x', '_', 'v', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'r', 'a', 'w',
+  'z', 'x', '_', 'v', 'v', 's', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'r', 'a', 'w', 'z',
+  'x', '_', 'v', 'v', 's', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'r', 'a', 'w',
+  'z', 'x', '_', 'v', 'v', 's', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'r', 'a', 'w',
+  'z', 'x', '_', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'r', 'a', 'w', 'z',
+  'x', '_', 'v', 'v', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'r', 'a', 'w',
+  'z', 'x', '_', 'v', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'r', 'l', '_',
+  'v', 'v', 's', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'r', 'l', '_', 'v', 'v', 's', 'm',
+  'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'v', 's', 'r', 'l', '_', 'v', 'v', 's', 'v', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'v', 's', 'r', 'l', '_', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'r',
+  'l', '_', 'v', 'v', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'r', 'l', '_',
+  'v', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 't', '_', 'v', 's', 's', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'v', 's', 't', '_', 'v', 's', 's', 'm', 'l', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's',
+  't', '2', 'd', '_', 'v', 's', 's', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 't', '2', 'd',
+  '_', 'v', 's', 's', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 't', '2', 'd', 'n', 'c',
+  '_', 'v', 's', 's', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 't', '2', 'd', 'n', 'c', '_',
+  'v', 's', 's', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 't', '2', 'd', 'n', 'c', 'o',
+  't', '_', 'v', 's', 's', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 't', '2', 'd', 'n', 'c',
+  'o', 't', '_', 'v', 's', 's', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 't', '2', 'd',
+  'o', 't', '_', 'v', 's', 's', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 't', '2', 'd', 'o',
+  't', '_', 'v', 's', 's', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 't', 'l', '_', 'v',
+  's', 's', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'v', 's', 't', 'l', '_', 'v', 's', 's', 'm', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'v', 's', 't', 'l', '2', 'd', '_', 'v', 's', 's', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 's', 't', 'l', '2', 'd', '_', 'v', 's', 's', 'm', 'l', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v',
+  's', 't', 'l', '2', 'd', 'n', 'c', '_', 'v', 's', 's', 'l', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v',
+  's', 't', 'l', '2', 'd', 'n', 'c', '_', 'v', 's', 's', 'm', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 's', 't', 'l', '2', 'd', 'n', 'c', 'o', 't', '_', 'v', 's', 's', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'v', 's', 't', 'l', '2', 'd', 'n', 'c', 'o', 't', '_', 'v', 's',
+  's', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'v', 's', 't', 'l', '2', 'd', 'o', 't', '_', 'v',
+  's', 's', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'v', 's', 't', 'l', '2', 'd', 'o', 't', '_', 'v',
+  's', 's', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'v', 's', 't', 'l', 'n', 'c', '_', 'v', 's',
+  's', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'v', 's', 't', 'l', 'n', 'c', '_', 'v', 's', 's', 'm',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 's', 't', 'l', 'n', 'c', 'o', 't', '_', 'v', 's', 's',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 's', 't', 'l', 'n', 'c', 'o', 't', '_', 'v', 's', 's',
+  'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'v', 's', 't', 'l', 'o', 't', '_', 'v', 's', 's', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'v', 's', 't', 'l', 'o', 't', '_', 'v', 's', 's', 'm', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'v', 's', 't', 'n', 'c', '_', 'v', 's', 's', 'l', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's',
+  't', 'n', 'c', '_', 'v', 's', 's', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 't', 'n',
+  'c', 'o', 't', '_', 'v', 's', 's', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 't', 'n', 'c',
+  'o', 't', '_', 'v', 's', 's', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 't', 'o', 't',
+  '_', 'v', 's', 's', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 't', 'o', 't', '_', 'v', 's',
+  's', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'v', 's', 't', 'u', '_', 'v', 's', 's', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'v', 's', 't', 'u', '_', 'v', 's', 's', 'm', 'l', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's',
+  't', 'u', '2', 'd', '_', 'v', 's', 's', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 't', 'u',
+  '2', 'd', '_', 'v', 's', 's', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 't', 'u', '2',
+  'd', 'n', 'c', '_', 'v', 's', 's', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 't', 'u', '2',
+  'd', 'n', 'c', '_', 'v', 's', 's', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 't', 'u',
+  '2', 'd', 'n', 'c', 'o', 't', '_', 'v', 's', 's', 'l', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's',
+  't', 'u', '2', 'd', 'n', 'c', 'o', 't', '_', 'v', 's', 's', 'm', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'v', 's', 't', 'u', '2', 'd', 'o', 't', '_', 'v', 's', 's', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'v', 's', 't', 'u', '2', 'd', 'o', 't', '_', 'v', 's', 's', 'm', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'v', 's', 't', 'u', 'n', 'c', '_', 'v', 's', 's', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 's', 't', 'u', 'n', 'c', '_', 'v', 's', 's', 'm', 'l', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v',
+  's', 't', 'u', 'n', 'c', 'o', 't', '_', 'v', 's', 's', 'l', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v',
+  's', 't', 'u', 'n', 'c', 'o', 't', '_', 'v', 's', 's', 'm', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 's', 't', 'u', 'o', 't', '_', 'v', 's', 's', 'l', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's',
+  't', 'u', 'o', 't', '_', 'v', 's', 's', 'm', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'u',
+  'b', 's', 'l', '_', 'v', 's', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'u', 'b', 's',
+  'l', '_', 'v', 's', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'u', 'b', 's',
+  'l', '_', 'v', 's', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'u', 'b', 's', 'l',
+  '_', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'u', 'b', 's', 'l', '_', 'v',
+  'v', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'u', 'b', 's', 'l', '_', 'v',
+  'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'u', 'b', 's', 'w', 's', 'x', '_',
+  'v', 's', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'u', 'b', 's', 'w', 's', 'x', '_',
+  'v', 's', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'u', 'b', 's', 'w', 's',
+  'x', '_', 'v', 's', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'u', 'b', 's', 'w',
+  's', 'x', '_', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'u', 'b', 's', 'w',
+  's', 'x', '_', 'v', 'v', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'u', 'b',
+  's', 'w', 's', 'x', '_', 'v', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'u',
+  'b', 's', 'w', 'z', 'x', '_', 'v', 's', 'v', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'u',
+  'b', 's', 'w', 'z', 'x', '_', 'v', 's', 'v', 'm', 'v', 'l', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v',
+  's', 'u', 'b', 's', 'w', 'z', 'x', '_', 'v', 's', 'v', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 's', 'u', 'b', 's', 'w', 'z', 'x', '_', 'v', 'v', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 's', 'u', 'b', 's', 'w', 'z', 'x', '_', 'v', 'v', 'v', 'm', 'v', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'v', 's', 'u', 'b', 's', 'w', 'z', 'x', '_', 'v', 'v', 'v', 'v',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_',
+  'v', 'l', '_', 'v', 's', 'u', 'b', 'u', 'l', '_', 'v', 's', 'v', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'v', 's', 'u', 'b', 'u', 'l', '_', 'v', 's', 'v', 'm', 'v', 'l', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l',
+  '_', 'v', 's', 'u', 'b', 'u', 'l', '_', 'v', 's', 'v', 'v', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'v', 's', 'u', 'b', 'u', 'l', '_', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's',
+  'u', 'b', 'u', 'l', '_', 'v', 'v', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's',
+  'u', 'b', 'u', 'l', '_', 'v', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'u',
+  'b', 'u', 'w', '_', 'v', 's', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'u', 'b', 'u',
+  'w', '_', 'v', 's', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'u', 'b', 'u',
+  'w', '_', 'v', 's', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'u', 'b', 'u', 'w',
+  '_', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'u', 'b', 'u', 'w', '_', 'v',
+  'v', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'u', 'b', 'u', 'w', '_', 'v',
+  'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'u', 'm', 'l', '_', 'v', 'v', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'v', 's', 'u', 'm', 'l', '_', 'v', 'v', 'm', 'l', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v',
+  's', 'u', 'm', 'w', 's', 'x', '_', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'u',
+  'm', 'w', 's', 'x', '_', 'v', 'v', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'u', 'm',
+  'w', 'z', 'x', '_', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 's', 'u', 'm', 'w', 'z',
+  'x', '_', 'v', 'v', 'm', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'x', 'o', 'r', '_', 'v', 's',
+  'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e',
+  '_', 'v', 'l', '_', 'v', 'x', 'o', 'r', '_', 'v', 's', 'v', 'm', 'v', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v',
+  'l', '_', 'v', 'x', 'o', 'r', '_', 'v', 's', 'v', 'v', 'l', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v',
+  'x', 'o', 'r', '_', 'v', 'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'x', 'o', 'r', '_',
+  'v', 'v', 'v', 'm', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'v', 'e', '_', 'v', 'l', '_', 'v', 'x', 'o', 'r', '_', 'v', 'v',
+  'v', 'v', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v',
+  'e', '_', 'v', 'l', '_', 'x', 'o', 'r', 'm', '_', 'M', 'M', 'M', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'v', 'e', '_', 'v', 'l', '_',
+  'x', 'o', 'r', 'm', '_', 'm', 'm', 'm', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'a', 'v', 'g', 'u', 's',
   'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
-  '2', '_', 'p', 'f', 's', 'u', 'b', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'i', '2', 'f', 'd', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
-  'p', 'm', 'u', 'l', 'h', 'r', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'f', '2', 'i', 'w', '\000', '_',
+  '2', '_', 'p', 'f', '2', 'i', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'f', 'a', 'c', 'c', '\000', '_',
   '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p',
-  'f', 'n', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'i', 'a', '3', '2', '_', 'p', 'f', 'p', 'n', 'a', 'c', 'c', '\000', '_',
+  'f', 'a', 'd', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'i', 'a', '3', '2', '_', 'p', 'f', 'c', 'm', 'p', 'e', 'q', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'f',
+  'c', 'm', 'p', 'g', 'e', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'i', 'a', '3', '2', '_', 'p', 'f', 'c', 'm', 'p', 'g', 't', '\000', '_',
   '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p',
-  'i', '2', 'f', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'a', 'e', 's', 'd', 'e', 'c', '1', '2', '8', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
-  'a', 'e', 's', 'd', 'e', 'c', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'a', 'e', 's', 'd', 'e',
-  'c', '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'a', 'e', 's', 'd', 'e', 'c', 'l', 'a', 's', 't',
-  '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'a', 'e', 's', 'd', 'e', 'c', 'l', 'a', 's', 't', '2',
-  '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
-  '3', '2', '_', 'a', 'e', 's', 'd', 'e', 'c', 'l', 'a', 's', 't', '5', '1',
-  '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
-  '2', '_', 'a', 'e', 's', 'e', 'n', 'c', '1', '2', '8', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'a', 'e', 's',
-  'e', 'n', 'c', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'i', 'a', '3', '2', '_', 'a', 'e', 's', 'e', 'n', 'c', '5', '1',
-  '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
-  '2', '_', 'a', 'e', 's', 'e', 'n', 'c', 'l', 'a', 's', 't', '1', '2', '8',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'a', 'e', 's', 'e', 'n', 'c', 'l', 'a', 's', 't', '2', '5', '6', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
-  'a', 'e', 's', 'e', 'n', 'c', 'l', 'a', 's', 't', '5', '1', '2', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'a',
-  'e', 's', 'i', 'm', 'c', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'a', 'e', 's', 'k', 'e', 'y',
-  'g', 'e', 'n', 'a', 's', 's', 'i', 's', 't', '1', '2', '8', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'a', 'd',
-  'd', 's', 'u', 'b', 'p', 'd', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'a', 'd', 'd', 's', 'u',
-  'b', 'p', 's', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'i', 'a', '3', '2', '_', 'b', 'l', 'e', 'n', 'd', 'v', 'p', 'd',
-  '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'b', 'l', 'e', 'n', 'd', 'v', 'p', 's', '2', '5', '6',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'c', 'v', 't', 'p', 'd', '2', 'p', 's', '2', '5', '6', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v',
-  't', 'p', 'd', '2', 'd', 'q', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't', 'p', 's',
-  '2', 'd', 'q', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't', 't', 'p', 'd', '2', 'd',
-  'q', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'c', 'v', 't', 't', 'p', 's', '2', 'd', 'q', '2',
-  '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
-  '3', '2', '_', 'd', 'p', 'p', 's', '2', '5', '6', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'h', 'a', 'd', 'd',
-  'p', 'd', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'i', 'a', '3', '2', '_', 'h', 'a', 'd', 'd', 'p', 's', '2', '5', '6',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'h', 's', 'u', 'b', 'p', 'd', '2', '5', '6', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'h', 's', 'u', 'b',
-  'p', 's', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'i', 'a', '3', '2', '_', 'l', 'd', 'd', 'q', 'u', '2', '5', '6', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
-  'm', 'a', 's', 'k', 'l', 'o', 'a', 'd', 'p', 'd', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'm', 'a', 's', 'k',
-  'l', 'o', 'a', 'd', 'p', 'd', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'm', 'a', 's', 'k', 'l',
-  'o', 'a', 'd', 'p', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'i', 'a', '3', '2', '_', 'm', 'a', 's', 'k', 'l', 'o', 'a', 'd', 'p',
-  's', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'm', 'a', 's', 'k', 's', 't', 'o', 'r', 'e', 'p',
+  'f', 'm', 'a', 'x', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'i', 'a', '3', '2', '_', 'p', 'f', 'm', 'i', 'n', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'f', 'm', 'u',
+  'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
+  '2', '_', 'p', 'f', 'r', 'c', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'f', 'r', 'c', 'p', 'i', 't',
+  '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
+  '2', '_', 'p', 'f', 'r', 'c', 'p', 'i', 't', '2', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'f', 'r', 's',
+  'q', 'i', 't', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'i', 'a', '3', '2', '_', 'p', 'f', 'r', 's', 'q', 'r', 't', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'f',
+  's', 'u', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
+  'a', '3', '2', '_', 'p', 'f', 's', 'u', 'b', 'r', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'i', '2', 'f',
   'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
-  '2', '_', 'm', 'a', 's', 'k', 's', 't', 'o', 'r', 'e', 'p', 'd', '2', '5',
-  '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
-  '2', '_', 'm', 'a', 's', 'k', 's', 't', 'o', 'r', 'e', 'p', 's', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'm',
-  'a', 's', 'k', 's', 't', 'o', 'r', 'e', 'p', 's', '2', '5', '6', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'm',
-  'a', 'x', 'p', 'd', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'm', 'a', 'x', 'p', 's', '2', '5',
-  '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
-  '2', '_', 'm', 'i', 'n', 'p', 'd', '2', '5', '6', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'm', 'i', 'n', 'p',
-  's', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'm', 'o', 'v', 'm', 's', 'k', 'p', 'd', '2', '5',
-  '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
-  '2', '_', 'm', 'o', 'v', 'm', 's', 'k', 'p', 's', '2', '5', '6', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p',
-  't', 'e', 's', 't', 'c', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 't', 'e', 's', 't', 'n',
-  'z', 'c', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'i', 'a', '3', '2', '_', 'p', 't', 'e', 's', 't', 'z', '2', '5', '6',
+  '2', '_', 'p', 'm', 'u', 'l', 'h', 'r', 'w', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'f', '2', 'i', 'w',
   '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'r', 'c', 'p', 'p', 's', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'r', 'o', 'u', 'n', 'd',
+  '_', 'p', 'f', 'n', 'a', 'c', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'f', 'p', 'n', 'a', 'c', 'c',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
+  '_', 'p', 'i', '2', 'f', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'a', 'e', 's', 'd', 'e', 'c', '1', '2',
+  '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
+  '2', '_', 'a', 'e', 's', 'd', 'e', 'c', '2', '5', '6', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'a', 'e', 's',
+  'd', 'e', 'c', '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'a', 'e', 's', 'd', 'e', 'c', 'l', 'a',
+  's', 't', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'i', 'a', '3', '2', '_', 'a', 'e', 's', 'd', 'e', 'c', 'l', 'a', 's',
+  't', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'i', 'a', '3', '2', '_', 'a', 'e', 's', 'd', 'e', 'c', 'l', 'a', 's', 't',
+  '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
+  'a', '3', '2', '_', 'a', 'e', 's', 'e', 'n', 'c', '1', '2', '8', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'a',
+  'e', 's', 'e', 'n', 'c', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'a', 'e', 's', 'e', 'n', 'c',
+  '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
+  'a', '3', '2', '_', 'a', 'e', 's', 'e', 'n', 'c', 'l', 'a', 's', 't', '1',
+  '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
+  '3', '2', '_', 'a', 'e', 's', 'e', 'n', 'c', 'l', 'a', 's', 't', '2', '5',
+  '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
+  '2', '_', 'a', 'e', 's', 'e', 'n', 'c', 'l', 'a', 's', 't', '5', '1', '2',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
+  '_', 'a', 'e', 's', 'i', 'm', 'c', '1', '2', '8', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'a', 'e', 's', 'k',
+  'e', 'y', 'g', 'e', 'n', 'a', 's', 's', 'i', 's', 't', '1', '2', '8', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
+  'a', 'd', 'd', 's', 'u', 'b', 'p', 'd', '2', '5', '6', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'a', 'd', 'd',
+  's', 'u', 'b', 'p', 's', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'b', 'l', 'e', 'n', 'd', 'v',
   'p', 'd', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'i', 'a', '3', '2', '_', 'r', 'o', 'u', 'n', 'd', 'p', 's', '2', '5',
-  '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
-  '2', '_', 'r', 's', 'q', 'r', 't', 'p', 's', '2', '5', '6', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p',
-  'e', 'r', 'm', 'i', 'l', 'v', 'a', 'r', 'p', 'd', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 'e', 'r',
-  'm', 'i', 'l', 'v', 'a', 'r', 'p', 'd', '2', '5', '6', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 'e',
-  'r', 'm', 'i', 'l', 'v', 'a', 'r', 'p', 's', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 'e', 'r', 'm',
-  'i', 'l', 'v', 'a', 'r', 'p', 's', '2', '5', '6', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 't', 'e', 's',
-  't', 'c', 'p', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'v', 't', 'e', 's', 't', 'c', 'p', 'd', '2', '5',
-  '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
-  '2', '_', 'v', 't', 'e', 's', 't', 'c', 'p', 's', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 't', 'e', 's',
-  't', 'c', 'p', 's', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 't', 'e', 's', 't', 'n', 'z',
-  'c', 'p', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'v', 't', 'e', 's', 't', 'n', 'z', 'c', 'p', 'd', '2',
+  '_', 'i', 'a', '3', '2', '_', 'b', 'l', 'e', 'n', 'd', 'v', 'p', 's', '2',
   '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
-  '3', '2', '_', 'v', 't', 'e', 's', 't', 'n', 'z', 'c', 'p', 's', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v',
-  't', 'e', 's', 't', 'n', 'z', 'c', 'p', 's', '2', '5', '6', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 't',
-  'e', 's', 't', 'z', 'p', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'i', 'a', '3', '2', '_', 'v', 't', 'e', 's', 't', 'z', 'p', 'd',
-  '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'v', 't', 'e', 's', 't', 'z', 'p', 's', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 't',
-  'e', 's', 't', 'z', 'p', 's', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'z', 'e', 'r', 'o',
-  'a', 'l', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'v', 'z', 'e', 'r', 'o', 'u', 'p', 'p', 'e', 'r', '\000',
+  '3', '2', '_', 'c', 'v', 't', 'p', 'd', '2', 'p', 's', '2', '5', '6', '\000',
   '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
-  'g', 'a', 't', 'h', 'e', 'r', 'd', '_', 'd', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'g', 'a', 't', 'h', 'e',
-  'r', 'd', '_', 'd', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'g', 'a', 't', 'h', 'e', 'r', 'd',
-  '_', 'p', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'g', 'a', 't', 'h', 'e', 'r', 'd', '_', 'p', 'd', '2',
-  '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
-  '3', '2', '_', 'g', 'a', 't', 'h', 'e', 'r', 'd', '_', 'p', 's', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'g',
-  'a', 't', 'h', 'e', 'r', 'd', '_', 'p', 's', '2', '5', '6', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'g', 'a',
-  't', 'h', 'e', 'r', 'd', '_', 'q', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'g', 'a', 't', 'h', 'e', 'r', 'd',
-  '_', 'q', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'i', 'a', '3', '2', '_', 'g', 'a', 't', 'h', 'e', 'r', 'q', '_', 'd',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'g', 'a', 't', 'h', 'e', 'r', 'q', '_', 'd', '2', '5', '6', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'g',
-  'a', 't', 'h', 'e', 'r', 'q', '_', 'p', 'd', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'g', 'a', 't', 'h', 'e',
-  'r', 'q', '_', 'p', 'd', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'g', 'a', 't', 'h', 'e', 'r',
-  'q', '_', 'p', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'g', 'a', 't', 'h', 'e', 'r', 'q', '_', 'p', 's',
-  '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'g', 'a', 't', 'h', 'e', 'r', 'q', '_', 'q', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'g',
-  'a', 't', 'h', 'e', 'r', 'q', '_', 'q', '2', '5', '6', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'm', 'a', 's',
-  'k', 'l', 'o', 'a', 'd', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'i', 'a', '3', '2', '_', 'm', 'a', 's', 'k', 'l', 'o', 'a', 'd',
-  'd', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'm', 'a', 's', 'k', 'l', 'o', 'a', 'd', 'q', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
-  'm', 'a', 's', 'k', 'l', 'o', 'a', 'd', 'q', '2', '5', '6', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'm', 'a',
-  's', 'k', 's', 't', 'o', 'r', 'e', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'm', 'a', 's', 'k', 's', 't',
-  'o', 'r', 'e', 'd', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'm', 'a', 's', 'k', 's', 't', 'o',
-  'r', 'e', 'q', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'm', 'a', 's', 'k', 's', 't', 'o', 'r', 'e', 'q', '2',
-  '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
-  '3', '2', '_', 'm', 'p', 's', 'a', 'd', 'b', 'w', '2', '5', '6', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p',
-  'a', 'c', 'k', 's', 's', 'd', 'w', '2', '5', '6', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'a', 'c', 'k',
-  's', 's', 'w', 'b', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'a', 'c', 'k', 'u', 's', 'd',
-  'w', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'p', 'a', 'c', 'k', 'u', 's', 'w', 'b', '2', '5',
-  '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
-  '2', '_', 'p', 'a', 'v', 'g', 'b', '2', '5', '6', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'a', 'v', 'g',
-  'w', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'p', 'b', 'l', 'e', 'n', 'd', 'v', 'b', '2', '5',
-  '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
-  '2', '_', 'p', 'e', 'r', 'm', 'v', 'a', 'r', 's', 'i', '2', '5', '6', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
-  'p', 'e', 'r', 'm', 'v', 'a', 'r', 's', 'f', '2', '5', '6', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'h',
-  'a', 'd', 'd', 'd', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'h', 'a', 'd', 'd', 's', 'w',
-  '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'p', 'h', 'a', 'd', 'd', 'w', '2', '5', '6', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p',
-  'h', 's', 'u', 'b', 'd', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'h', 's', 'u', 'b', 's',
-  'w', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'p', 'h', 's', 'u', 'b', 'w', '2', '5', '6', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
-  'p', 'm', 'a', 'd', 'd', 'u', 'b', 's', 'w', '2', '5', '6', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm',
-  'a', 'd', 'd', 'w', 'd', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 'm', 's',
-  'k', 'b', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'u', 'l', 'h', 'r', 's', 'w', '2',
-  '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
-  '3', '2', '_', 'p', 'm', 'u', 'l', 'h', 'w', '2', '5', '6', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm',
-  'u', 'l', 'h', 'u', 'w', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'a', 'd', 'b', 'w',
-  '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'p', 's', 'h', 'u', 'f', 'b', '2', '5', '6', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p',
-  's', 'i', 'g', 'n', 'b', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'i', 'g', 'n', 'd',
-  '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'p', 's', 'i', 'g', 'n', 'w', '2', '5', '6', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p',
-  's', 'l', 'l', 'd', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'l', 'l', 'q', '2', '5',
-  '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
-  '2', '_', 'p', 's', 'l', 'l', 'w', '2', '5', '6', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'l', 'l',
-  'd', 'i', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'i', 'a', '3', '2', '_', 'p', 's', 'l', 'l', 'q', 'i', '2', '5', '6',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'p', 's', 'l', 'l', 'w', 'i', '2', '5', '6', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'l', 'l',
-  'v', '4', 's', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'p', 's', 'l', 'l', 'v', '8', 's', 'i', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p',
-  's', 'l', 'l', 'v', '2', 'd', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'l', 'l', 'v', '4', 'd',
-  'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
-  '2', '_', 'p', 's', 'r', 'a', 'd', '2', '5', '6', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'r', 'a',
-  'w', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'p', 's', 'r', 'a', 'd', 'i', '2', '5', '6', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
-  'p', 's', 'r', 'a', 'w', 'i', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'r', 'a', 'v',
-  '4', 's', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'p', 's', 'r', 'a', 'v', '8', 's', 'i', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's',
-  'r', 'l', 'd', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'r', 'l', 'q', '2', '5', '6',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'p', 's', 'r', 'l', 'w', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'r', 'l', 'd',
-  'i', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'p', 's', 'r', 'l', 'q', 'i', '2', '5', '6', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
-  'p', 's', 'r', 'l', 'w', 'i', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'r', 'l', 'v',
-  '4', 's', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'p', 's', 'r', 'l', 'v', '8', 's', 'i', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's',
-  'r', 'l', 'v', '2', 'd', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'r', 'l', 'v', '4', 'd', 'i',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'a', 'd', 'd', 'p', 'd', '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'a', 'd', 'd', 'p', 's',
-  '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'b', 'r', 'o', 'a', 'd', 'c', 'a', 's', 't', 'm', 'b',
-  '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'b', 'r', 'o', 'a', 'd', 'c', 'a', 's', 't', 'm', 'b',
-  '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'b', 'r', 'o', 'a', 'd', 'c', 'a', 's', 't', 'm', 'b',
-  '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'b', 'r', 'o', 'a', 'd', 'c', 'a', 's', 't', 'm', 'w',
-  '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'b', 'r', 'o', 'a', 'd', 'c', 'a', 's', 't', 'm', 'w',
-  '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'b', 'r', 'o', 'a', 'd', 'c', 'a', 's', 't', 'm', 'w',
-  '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'v', 'p', 'c', 'o', 'n', 'f', 'l', 'i', 'c', 't', 's',
-  'i', '_', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'i', 'a', '3', '2', '_', 'v', 'p', 'c', 'o', 'n', 'f', 'l', 'i', 'c',
-  't', 's', 'i', '_', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 'c', 'o', 'n', 'f', 'l',
-  'i', 'c', 't', 's', 'i', '_', '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 'c', 'o', 'n',
-  'f', 'l', 'i', 'c', 't', 'd', 'i', '_', '1', '2', '8', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 'c',
-  'o', 'n', 'f', 'l', 'i', 'c', 't', 'd', 'i', '_', '2', '5', '6', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v',
-  'p', 'c', 'o', 'n', 'f', 'l', 'i', 'c', 't', 'd', 'i', '_', '5', '1', '2',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'c', 'v', 't', 's', 'i', '2', 's', 'd', '6', '4', '\000', '_', '_', 'b',
+  'c', 'v', 't', 'p', 'd', '2', 'd', 'q', '2', '5', '6', '\000', '_', '_', 'b',
   'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't',
-  's', 'i', '2', 's', 's', '3', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't', 's', 'i', '2', 's',
-  's', '6', '4', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'v', 'c', 'v', 't', 't', 's', 'd', '2', 's', 'i', '3',
-  '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
-  '2', '_', 'v', 'c', 'v', 't', 't', 's', 'd', '2', 's', 'i', '6', '4', '\000',
+  'p', 's', '2', 'd', 'q', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't', 't', 'p', 'd',
+  '2', 'd', 'q', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't', 't', 'p', 's', '2', 'd',
+  'q', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'i', 'a', '3', '2', '_', 'd', 'p', 'p', 's', '2', '5', '6', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'h', 'a',
+  'd', 'd', 'p', 'd', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'h', 'a', 'd', 'd', 'p', 's', '2',
+  '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
+  '3', '2', '_', 'h', 's', 'u', 'b', 'p', 'd', '2', '5', '6', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'h', 's',
+  'u', 'b', 'p', 's', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'l', 'd', 'd', 'q', 'u', '2', '5',
+  '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
+  '2', '_', 'm', 'a', 's', 'k', 'l', 'o', 'a', 'd', 'p', 'd', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'm', 'a',
+  's', 'k', 'l', 'o', 'a', 'd', 'p', 'd', '2', '5', '6', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'm', 'a', 's',
+  'k', 'l', 'o', 'a', 'd', 'p', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'm', 'a', 's', 'k', 'l', 'o', 'a',
+  'd', 'p', 's', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'm', 'a', 's', 'k', 's', 't', 'o', 'r',
+  'e', 'p', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
+  'a', '3', '2', '_', 'm', 'a', 's', 'k', 's', 't', 'o', 'r', 'e', 'p', 'd',
+  '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
+  'a', '3', '2', '_', 'm', 'a', 's', 'k', 's', 't', 'o', 'r', 'e', 'p', 's',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
+  '_', 'm', 'a', 's', 'k', 's', 't', 'o', 'r', 'e', 'p', 's', '2', '5', '6',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
+  '_', 'm', 'a', 'x', 'p', 'd', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'm', 'a', 'x', 'p', 's',
+  '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
+  'a', '3', '2', '_', 'm', 'i', 'n', 'p', 'd', '2', '5', '6', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'm', 'i',
+  'n', 'p', 's', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'm', 'o', 'v', 'm', 's', 'k', 'p', 'd',
+  '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
+  'a', '3', '2', '_', 'm', 'o', 'v', 'm', 's', 'k', 'p', 's', '2', '5', '6',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
+  '_', 'p', 't', 'e', 's', 't', 'c', '2', '5', '6', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 't', 'e', 's',
+  't', 'n', 'z', 'c', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 't', 'e', 's', 't', 'z', '2',
+  '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
+  '3', '2', '_', 'r', 'c', 'p', 'p', 's', '2', '5', '6', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'r', 'o', 'u',
+  'n', 'd', 'p', 'd', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'r', 'o', 'u', 'n', 'd', 'p', 's',
+  '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
+  'a', '3', '2', '_', 'r', 's', 'q', 'r', 't', 'p', 's', '2', '5', '6', '\000',
   '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
-  'v', 'c', 'v', 't', 't', 's', 'd', '2', 'u', 's', 'i', '3', '2', '\000', '_',
+  'v', 'p', 'e', 'r', 'm', 'i', 'l', 'v', 'a', 'r', 'p', 'd', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p',
+  'e', 'r', 'm', 'i', 'l', 'v', 'a', 'r', 'p', 'd', '2', '5', '6', '\000', '_',
   '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v',
-  'c', 'v', 't', 't', 's', 'd', '2', 'u', 's', 'i', '6', '4', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'c',
-  'v', 't', 't', 's', 's', '2', 's', 'i', '3', '2', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'c', 'v', 't',
-  't', 's', 's', '2', 's', 'i', '6', '4', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'c', 'v', 't', 't', 's',
-  's', '2', 'u', 's', 'i', '3', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'c', 'v', 't', 't', 's', 's',
-  '2', 'u', 's', 'i', '6', '4', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't', 'u', 's', 'i', '2', 's',
-  's', '3', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'c', 'v', 't', 'u', 's', 'i', '2', 's', 'd', '6', '4',
+  'p', 'e', 'r', 'm', 'i', 'l', 'v', 'a', 'r', 'p', 's', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 'e',
+  'r', 'm', 'i', 'l', 'v', 'a', 'r', 'p', 's', '2', '5', '6', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 't',
+  'e', 's', 't', 'c', 'p', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'v', 't', 'e', 's', 't', 'c', 'p', 'd',
+  '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
+  'a', '3', '2', '_', 'v', 't', 'e', 's', 't', 'c', 'p', 's', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 't',
+  'e', 's', 't', 'c', 'p', 's', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 't', 'e', 's', 't',
+  'n', 'z', 'c', 'p', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'i', 'a', '3', '2', '_', 'v', 't', 'e', 's', 't', 'n', 'z', 'c', 'p',
+  'd', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'i', 'a', '3', '2', '_', 'v', 't', 'e', 's', 't', 'n', 'z', 'c', 'p', 's',
   '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'c', 'v', 't', 'u', 's', 'i', '2', 's', 's', '6', '4', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'd', 'b',
-  'p', 's', 'a', 'd', 'b', 'w', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'd', 'b', 'p', 's', 'a',
-  'd', 'b', 'w', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'i', 'a', '3', '2', '_', 'd', 'b', 'p', 's', 'a', 'd', 'b', 'w',
-  '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'd', 'i', 'v', 'p', 'd', '5', '1', '2', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'd', 'i',
-  'v', 'p', 's', '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'i', 'a', '3', '2', '_', 'e', 'x', 'p', '2', 'p', 'd', '_', 'm',
-  'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'e', 'x', 'p', '2', 'p', 's', '_', 'm', 'a', 's', 'k',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'g', 'a', 't', 'h', 'e', 'r', 'p', 'f', 'd', 'p', 'd', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'g', 'a',
-  't', 'h', 'e', 'r', 'p', 'f', 'd', 'p', 's', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'g', 'a', 't', 'h', 'e',
-  'r', 'p', 'f', 'q', 'p', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'i', 'a', '3', '2', '_', 'g', 'a', 't', 'h', 'e', 'r', 'p', 'f',
-  'q', 'p', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'a', 'd', 'd', 's', 'd', '_', 'r', 'o', 'u', 'n', 'd',
-  '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'i', 'a', '3', '2', '_', 'a', 'd', 'd', 's', 's', '_', 'r', 'o', 'u',
-  'n', 'd', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'm', 'p', 's', 'd', '_', 'm',
-  'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'c', 'm', 'p', 's', 's', '_', 'm', 'a', 's', 'k', '\000',
+  '_', 'v', 't', 'e', 's', 't', 'n', 'z', 'c', 'p', 's', '2', '5', '6', '\000',
   '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
-  'c', 'v', 't', 'p', 'd', '2', 'd', 'q', '1', '2', '8', '_', 'm', 'a', 's',
-  'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
-  '2', '_', 'c', 'v', 't', 'p', 'd', '2', 'd', 'q', '5', '1', '2', '_', 'm',
-  'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'c', 'v', 't', 'p', 'd', '2', 'p', 's', '_', 'm', 'a',
-  's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
-  '3', '2', '_', 'c', 'v', 't', 'p', 'd', '2', 'p', 's', '5', '1', '2', '_',
-  'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'c', 'v', 't', 'p', 'd', '2', 'q', 'q', '1', '2',
-  '8', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't', 'p', 'd', '2', 'q', 'q',
-  '2', '5', '6', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't', 'p', 'd', '2',
-  'q', 'q', '5', '1', '2', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't', 'p',
-  'd', '2', 'u', 'd', 'q', '1', '2', '8', '_', 'm', 'a', 's', 'k', '\000', '_',
+  'v', 't', 'e', 's', 't', 'z', 'p', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 't', 'e', 's', 't', 'z',
+  'p', 'd', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'i', 'a', '3', '2', '_', 'v', 't', 'e', 's', 't', 'z', 'p', 's', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
+  'v', 't', 'e', 's', 't', 'z', 'p', 's', '2', '5', '6', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'z', 'e',
+  'r', 'o', 'a', 'l', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'i', 'a', '3', '2', '_', 'v', 'z', 'e', 'r', 'o', 'u', 'p', 'p', 'e',
+  'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
+  '2', '_', 'g', 'a', 't', 'h', 'e', 'r', 'd', '_', 'd', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'g', 'a', 't',
+  'h', 'e', 'r', 'd', '_', 'd', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'g', 'a', 't', 'h', 'e',
+  'r', 'd', '_', 'p', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'i', 'a', '3', '2', '_', 'g', 'a', 't', 'h', 'e', 'r', 'd', '_', 'p',
+  'd', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'i', 'a', '3', '2', '_', 'g', 'a', 't', 'h', 'e', 'r', 'd', '_', 'p', 's',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
+  '_', 'g', 'a', 't', 'h', 'e', 'r', 'd', '_', 'p', 's', '2', '5', '6', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
+  'g', 'a', 't', 'h', 'e', 'r', 'd', '_', 'q', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'g', 'a', 't', 'h', 'e',
+  'r', 'd', '_', 'q', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'g', 'a', 't', 'h', 'e', 'r', 'q',
+  '_', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
+  '3', '2', '_', 'g', 'a', 't', 'h', 'e', 'r', 'q', '_', 'd', '2', '5', '6',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
+  '_', 'g', 'a', 't', 'h', 'e', 'r', 'q', '_', 'p', 'd', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'g', 'a', 't',
+  'h', 'e', 'r', 'q', '_', 'p', 'd', '2', '5', '6', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'g', 'a', 't', 'h',
+  'e', 'r', 'q', '_', 'p', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'g', 'a', 't', 'h', 'e', 'r', 'q', '_',
+  'p', 's', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'i', 'a', '3', '2', '_', 'g', 'a', 't', 'h', 'e', 'r', 'q', '_', 'q',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
+  '_', 'g', 'a', 't', 'h', 'e', 'r', 'q', '_', 'q', '2', '5', '6', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'm',
+  'a', 's', 'k', 'l', 'o', 'a', 'd', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'm', 'a', 's', 'k', 'l', 'o',
+  'a', 'd', 'd', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'm', 'a', 's', 'k', 'l', 'o', 'a', 'd',
+  'q', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
+  '2', '_', 'm', 'a', 's', 'k', 'l', 'o', 'a', 'd', 'q', '2', '5', '6', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
+  'm', 'a', 's', 'k', 's', 't', 'o', 'r', 'e', 'd', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'm', 'a', 's', 'k',
+  's', 't', 'o', 'r', 'e', 'd', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'm', 'a', 's', 'k', 's',
+  't', 'o', 'r', 'e', 'q', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'i', 'a', '3', '2', '_', 'm', 'a', 's', 'k', 's', 't', 'o', 'r', 'e',
+  'q', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'i', 'a', '3', '2', '_', 'm', 'p', 's', 'a', 'd', 'b', 'w', '2', '5', '6',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
+  '_', 'p', 'a', 'c', 'k', 's', 's', 'd', 'w', '2', '5', '6', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'a',
+  'c', 'k', 's', 's', 'w', 'b', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'a', 'c', 'k', 'u',
+  's', 'd', 'w', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'p', 'a', 'c', 'k', 'u', 's', 'w', 'b',
+  '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
+  'a', '3', '2', '_', 'p', 'a', 'v', 'g', 'b', '2', '5', '6', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'a',
+  'v', 'g', 'w', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'p', 'b', 'l', 'e', 'n', 'd', 'v', 'b',
+  '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
+  'a', '3', '2', '_', 'p', 'e', 'r', 'm', 'v', 'a', 'r', 's', 'i', '2', '5',
+  '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
+  '2', '_', 'p', 'e', 'r', 'm', 'v', 'a', 'r', 's', 'f', '2', '5', '6', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
+  'p', 'h', 'a', 'd', 'd', 'd', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'h', 'a', 'd', 'd',
+  's', 'w', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'i', 'a', '3', '2', '_', 'p', 'h', 'a', 'd', 'd', 'w', '2', '5', '6',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
+  '_', 'p', 'h', 's', 'u', 'b', 'd', '2', '5', '6', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'h', 's', 'u',
+  'b', 's', 'w', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'p', 'h', 's', 'u', 'b', 'w', '2', '5',
+  '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
+  '2', '_', 'p', 'm', 'a', 'd', 'd', 'u', 'b', 's', 'w', '2', '5', '6', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
+  'p', 'm', 'a', 'd', 'd', 'w', 'd', '2', '5', '6', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v',
+  'm', 's', 'k', 'b', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'u', 'l', 'h', 'r', 's',
+  'w', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'i', 'a', '3', '2', '_', 'p', 'm', 'u', 'l', 'h', 'w', '2', '5', '6', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
+  'p', 'm', 'u', 'l', 'h', 'u', 'w', '2', '5', '6', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'a', 'd',
+  'b', 'w', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'i', 'a', '3', '2', '_', 'p', 's', 'h', 'u', 'f', 'b', '2', '5', '6',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
+  '_', 'p', 's', 'i', 'g', 'n', 'b', '2', '5', '6', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'i', 'g',
+  'n', 'd', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'i', 'a', '3', '2', '_', 'p', 's', 'i', 'g', 'n', 'w', '2', '5', '6',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
+  '_', 'p', 's', 'l', 'l', 'd', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'l', 'l', 'q',
+  '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
+  'a', '3', '2', '_', 'p', 's', 'l', 'l', 'w', '2', '5', '6', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's',
+  'l', 'l', 'd', 'i', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'l', 'l', 'q', 'i', '2',
+  '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
+  '3', '2', '_', 'p', 's', 'l', 'l', 'w', 'i', '2', '5', '6', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's',
+  'l', 'l', 'v', '4', 's', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'l', 'l', 'v', '8', 's', 'i',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
+  '_', 'p', 's', 'l', 'l', 'v', '2', 'd', 'i', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'l', 'l', 'v',
+  '4', 'd', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
+  'a', '3', '2', '_', 'p', 's', 'r', 'a', 'd', '2', '5', '6', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's',
+  'r', 'a', 'w', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'r', 'a', 'd', 'i', '2', '5',
+  '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
+  '2', '_', 'p', 's', 'r', 'a', 'w', 'i', '2', '5', '6', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'r',
+  'a', 'v', '4', 's', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'i', 'a', '3', '2', '_', 'p', 's', 'r', 'a', 'v', '8', 's', 'i', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
+  'p', 's', 'r', 'l', 'd', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'r', 'l', 'q', '2',
+  '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
+  '3', '2', '_', 'p', 's', 'r', 'l', 'w', '2', '5', '6', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'r',
+  'l', 'd', 'i', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'r', 'l', 'q', 'i', '2', '5',
+  '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
+  '2', '_', 'p', 's', 'r', 'l', 'w', 'i', '2', '5', '6', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'r',
+  'l', 'v', '4', 's', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'i', 'a', '3', '2', '_', 'p', 's', 'r', 'l', 'v', '8', 's', 'i', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
+  'p', 's', 'r', 'l', 'v', '2', 'd', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'r', 'l', 'v', '4',
+  'd', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
+  '3', '2', '_', 'a', 'd', 'd', 'p', 'd', '5', '1', '2', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'a', 'd', 'd',
+  'p', 's', '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'i', 'a', '3', '2', '_', 'b', 'r', 'o', 'a', 'd', 'c', 'a', 's', 't',
+  'm', 'b', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'i', 'a', '3', '2', '_', 'b', 'r', 'o', 'a', 'd', 'c', 'a', 's', 't',
+  'm', 'b', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'i', 'a', '3', '2', '_', 'b', 'r', 'o', 'a', 'd', 'c', 'a', 's', 't',
+  'm', 'b', '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'i', 'a', '3', '2', '_', 'b', 'r', 'o', 'a', 'd', 'c', 'a', 's', 't',
+  'm', 'w', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'i', 'a', '3', '2', '_', 'b', 'r', 'o', 'a', 'd', 'c', 'a', 's', 't',
+  'm', 'w', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'i', 'a', '3', '2', '_', 'b', 'r', 'o', 'a', 'd', 'c', 'a', 's', 't',
+  'm', 'w', '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'i', 'a', '3', '2', '_', 'v', 'p', 'c', 'o', 'n', 'f', 'l', 'i', 'c',
+  't', 's', 'i', '_', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 'c', 'o', 'n', 'f', 'l',
+  'i', 'c', 't', 's', 'i', '_', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 'c', 'o', 'n',
+  'f', 'l', 'i', 'c', 't', 's', 'i', '_', '5', '1', '2', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 'c',
+  'o', 'n', 'f', 'l', 'i', 'c', 't', 'd', 'i', '_', '1', '2', '8', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v',
+  'p', 'c', 'o', 'n', 'f', 'l', 'i', 'c', 't', 'd', 'i', '_', '2', '5', '6',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
+  '_', 'v', 'p', 'c', 'o', 'n', 'f', 'l', 'i', 'c', 't', 'd', 'i', '_', '5',
+  '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
+  '3', '2', '_', 'c', 'v', 't', 's', 'i', '2', 's', 'd', '6', '4', '\000', '_',
   '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c',
-  'v', 't', 'p', 'd', '2', 'u', 'd', 'q', '2', '5', '6', '_', 'm', 'a', 's',
-  'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
-  '2', '_', 'c', 'v', 't', 'p', 'd', '2', 'u', 'd', 'q', '5', '1', '2', '_',
-  'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'c', 'v', 't', 'p', 'd', '2', 'u', 'q', 'q', '1',
-  '2', '8', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't', 'p', 'd', '2', 'u',
-  'q', 'q', '2', '5', '6', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't', 'p',
-  'd', '2', 'u', 'q', 'q', '5', '1', '2', '_', 'm', 'a', 's', 'k', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c',
-  'v', 't', 'p', 's', '2', 'd', 'q', '1', '2', '8', '_', 'm', 'a', 's', 'k',
+  'v', 't', 's', 'i', '2', 's', 's', '3', '2', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't', 's', 'i',
+  '2', 's', 's', '6', '4', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'i', 'a', '3', '2', '_', 'v', 'c', 'v', 't', 't', 's', 'd', '2', 's',
+  'i', '3', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
+  'a', '3', '2', '_', 'v', 'c', 'v', 't', 't', 's', 'd', '2', 's', 'i', '6',
+  '4', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
+  '2', '_', 'v', 'c', 'v', 't', 't', 's', 'd', '2', 'u', 's', 'i', '3', '2',
   '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'c', 'v', 't', 'p', 's', '2', 'd', 'q', '2', '5', '6', '_', 'm', 'a',
+  '_', 'v', 'c', 'v', 't', 't', 's', 'd', '2', 'u', 's', 'i', '6', '4', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
+  'v', 'c', 'v', 't', 't', 's', 's', '2', 's', 'i', '3', '2', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'c',
+  'v', 't', 't', 's', 's', '2', 's', 'i', '6', '4', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'c', 'v', 't',
+  't', 's', 's', '2', 'u', 's', 'i', '3', '2', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'c', 'v', 't', 't',
+  's', 's', '2', 'u', 's', 'i', '6', '4', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't', 'u', 's', 'i',
+  '2', 's', 's', '3', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't', 'u', 's', 'i', '2', 's', 'd',
+  '6', '4', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
+  '3', '2', '_', 'c', 'v', 't', 'u', 's', 'i', '2', 's', 's', '6', '4', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
+  'd', 'b', 'p', 's', 'a', 'd', 'b', 'w', '1', '2', '8', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'd', 'b', 'p',
+  's', 'a', 'd', 'b', 'w', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'd', 'b', 'p', 's', 'a', 'd',
+  'b', 'w', '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'i', 'a', '3', '2', '_', 'd', 'i', 'v', 'p', 'd', '5', '1', '2', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
+  'd', 'i', 'v', 'p', 's', '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'e', 'x', 'p', '2', 'p', 'd',
+  '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'i', 'a', '3', '2', '_', 'e', 'x', 'p', '2', 'p', 's', '_', 'm', 'a',
   's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
-  '3', '2', '_', 'c', 'v', 't', 'p', 's', '2', 'd', 'q', '5', '1', '2', '_',
-  'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'c', 'v', 't', 'p', 's', '2', 'p', 'd', '5', '1',
-  '2', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't', 'p', 's', '2', 'q', 'q',
-  '1', '2', '8', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't', 'p', 's', '2',
-  'q', 'q', '2', '5', '6', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't', 'p',
-  's', '2', 'q', 'q', '5', '1', '2', '_', 'm', 'a', 's', 'k', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v',
-  't', 'p', 's', '2', 'u', 'd', 'q', '1', '2', '8', '_', 'm', 'a', 's', 'k',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'c', 'v', 't', 'p', 's', '2', 'u', 'd', 'q', '2', '5', '6', '_', 'm',
-  'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'c', 'v', 't', 'p', 's', '2', 'u', 'd', 'q', '5', '1',
-  '2', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't', 'p', 's', '2', 'u', 'q',
-  'q', '1', '2', '8', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't', 'p', 's',
-  '2', 'u', 'q', 'q', '2', '5', '6', '_', 'm', 'a', 's', 'k', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v',
-  't', 'p', 's', '2', 'u', 'q', 'q', '5', '1', '2', '_', 'm', 'a', 's', 'k',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'c', 'v', 't', 'q', 'q', '2', 'p', 's', '1', '2', '8', '_', 'm', 'a',
-  's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
-  '3', '2', '_', 'c', 'v', 't', 's', 'd', '2', 's', 's', '_', 'r', 'o', 'u',
+  '3', '2', '_', 'g', 'a', 't', 'h', 'e', 'r', 'p', 'f', 'd', 'p', 'd', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
+  'g', 'a', 't', 'h', 'e', 'r', 'p', 'f', 'd', 'p', 's', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'g', 'a', 't',
+  'h', 'e', 'r', 'p', 'f', 'q', 'p', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'g', 'a', 't', 'h', 'e', 'r',
+  'p', 'f', 'q', 'p', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'i', 'a', '3', '2', '_', 'a', 'd', 'd', 's', 'd', '_', 'r', 'o', 'u',
   'n', 'd', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't', 's', 's', '2', 's',
-  'd', '_', 'r', 'o', 'u', 'n', 'd', '_', 'm', 'a', 's', 'k', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v',
-  't', 't', 'p', 'd', '2', 'd', 'q', '1', '2', '8', '_', 'm', 'a', 's', 'k',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'c', 'v', 't', 't', 'p', 'd', '2', 'd', 'q', '5', '1', '2', '_', 'm',
+  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'a', 'd', 'd', 's', 's', '_', 'r',
+  'o', 'u', 'n', 'd', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'm', 'p', 's', 'd',
+  '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'i', 'a', '3', '2', '_', 'c', 'm', 'p', 's', 's', '_', 'm', 'a', 's',
+  'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
+  '2', '_', 'c', 'v', 't', 'p', 'd', '2', 'd', 'q', '1', '2', '8', '_', 'm',
   'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'c', 'v', 't', 't', 'p', 'd', '2', 'q', 'q', '1', '2',
-  '8', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't', 't', 'p', 'd', '2', 'q',
-  'q', '2', '5', '6', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't', 't', 'p',
+  'a', '3', '2', '_', 'c', 'v', 't', 'p', 'd', '2', 'd', 'q', '5', '1', '2',
+  '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't', 'p', 'd', '2', 'p', 's', '_',
+  'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'i', 'a', '3', '2', '_', 'c', 'v', 't', 'p', 'd', '2', 'p', 's', '5', '1',
+  '2', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't', 'p', 'd', '2', 'q', 'q',
+  '1', '2', '8', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't', 'p', 'd', '2',
+  'q', 'q', '2', '5', '6', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't', 'p',
   'd', '2', 'q', 'q', '5', '1', '2', '_', 'm', 'a', 's', 'k', '\000', '_', '_',
   'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v',
-  't', 't', 'p', 'd', '2', 'u', 'd', 'q', '1', '2', '8', '_', 'm', 'a', 's',
-  'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
-  '2', '_', 'c', 'v', 't', 't', 'p', 'd', '2', 'u', 'd', 'q', '2', '5', '6',
-  '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't', 't', 'p', 'd', '2', 'u', 'd',
-  'q', '5', '1', '2', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't', 't', 'p',
-  'd', '2', 'u', 'q', 'q', '1', '2', '8', '_', 'm', 'a', 's', 'k', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c',
-  'v', 't', 't', 'p', 'd', '2', 'u', 'q', 'q', '2', '5', '6', '_', 'm', 'a',
-  's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
-  '3', '2', '_', 'c', 'v', 't', 't', 'p', 'd', '2', 'u', 'q', 'q', '5', '1',
-  '2', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't', 't', 'p', 's', '2', 'd',
-  'q', '5', '1', '2', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't', 't', 'p',
-  's', '2', 'q', 'q', '1', '2', '8', '_', 'm', 'a', 's', 'k', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v',
-  't', 't', 'p', 's', '2', 'q', 'q', '2', '5', '6', '_', 'm', 'a', 's', 'k',
+  't', 'p', 'd', '2', 'u', 'd', 'q', '1', '2', '8', '_', 'm', 'a', 's', 'k',
   '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'c', 'v', 't', 't', 'p', 's', '2', 'q', 'q', '5', '1', '2', '_', 'm',
+  '_', 'c', 'v', 't', 'p', 'd', '2', 'u', 'd', 'q', '2', '5', '6', '_', 'm',
   'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'c', 'v', 't', 't', 'p', 's', '2', 'u', 'd', 'q', '1',
-  '2', '8', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't', 't', 'p', 's', '2',
-  'u', 'd', 'q', '2', '5', '6', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b',
+  'a', '3', '2', '_', 'c', 'v', 't', 'p', 'd', '2', 'u', 'd', 'q', '5', '1',
+  '2', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't', 'p', 'd', '2', 'u', 'q',
+  'q', '1', '2', '8', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't', 'p', 'd',
+  '2', 'u', 'q', 'q', '2', '5', '6', '_', 'm', 'a', 's', 'k', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v',
+  't', 'p', 'd', '2', 'u', 'q', 'q', '5', '1', '2', '_', 'm', 'a', 's', 'k',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
+  '_', 'c', 'v', 't', 'p', 's', '2', 'd', 'q', '1', '2', '8', '_', 'm', 'a',
+  's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
+  '3', '2', '_', 'c', 'v', 't', 'p', 's', '2', 'd', 'q', '2', '5', '6', '_',
+  'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'i', 'a', '3', '2', '_', 'c', 'v', 't', 'p', 's', '2', 'd', 'q', '5', '1',
+  '2', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't', 'p', 's', '2', 'p', 'd',
+  '5', '1', '2', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't', 'p', 's', '2',
+  'q', 'q', '1', '2', '8', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't', 'p',
+  's', '2', 'q', 'q', '2', '5', '6', '_', 'm', 'a', 's', 'k', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v',
+  't', 'p', 's', '2', 'q', 'q', '5', '1', '2', '_', 'm', 'a', 's', 'k', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
+  'c', 'v', 't', 'p', 's', '2', 'u', 'd', 'q', '1', '2', '8', '_', 'm', 'a',
+  's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
+  '3', '2', '_', 'c', 'v', 't', 'p', 's', '2', 'u', 'd', 'q', '2', '5', '6',
+  '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't', 'p', 's', '2', 'u', 'd', 'q',
+  '5', '1', '2', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't', 'p', 's', '2',
+  'u', 'q', 'q', '1', '2', '8', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b',
   'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't',
-  't', 'p', 's', '2', 'u', 'd', 'q', '5', '1', '2', '_', 'm', 'a', 's', 'k',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'c', 'v', 't', 't', 'p', 's', '2', 'u', 'q', 'q', '1', '2', '8', '_',
+  'p', 's', '2', 'u', 'q', 'q', '2', '5', '6', '_', 'm', 'a', 's', 'k', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
+  'c', 'v', 't', 'p', 's', '2', 'u', 'q', 'q', '5', '1', '2', '_', 'm', 'a',
+  's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
+  '3', '2', '_', 'c', 'v', 't', 'q', 'q', '2', 'p', 's', '1', '2', '8', '_',
   'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'c', 'v', 't', 't', 'p', 's', '2', 'u', 'q', 'q',
-  '2', '5', '6', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  'i', 'a', '3', '2', '_', 'c', 'v', 't', 's', 'd', '2', 's', 's', '_', 'r',
+  'o', 'u', 'n', 'd', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't', 's', 's',
+  '2', 's', 'd', '_', 'r', 'o', 'u', 'n', 'd', '_', 'm', 'a', 's', 'k', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
+  'c', 'v', 't', 't', 'p', 'd', '2', 'd', 'q', '1', '2', '8', '_', 'm', 'a',
+  's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
+  '3', '2', '_', 'c', 'v', 't', 't', 'p', 'd', '2', 'd', 'q', '5', '1', '2',
+  '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't', 't', 'p', 'd', '2', 'q', 'q',
+  '1', '2', '8', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't', 't', 'p', 'd',
+  '2', 'q', 'q', '2', '5', '6', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't',
+  't', 'p', 'd', '2', 'q', 'q', '5', '1', '2', '_', 'm', 'a', 's', 'k', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
+  'c', 'v', 't', 't', 'p', 'd', '2', 'u', 'd', 'q', '1', '2', '8', '_', 'm',
+  'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
+  'a', '3', '2', '_', 'c', 'v', 't', 't', 'p', 'd', '2', 'u', 'd', 'q', '2',
+  '5', '6', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't', 't', 'p', 'd', '2',
+  'u', 'd', 'q', '5', '1', '2', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't',
+  't', 'p', 'd', '2', 'u', 'q', 'q', '1', '2', '8', '_', 'm', 'a', 's', 'k',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
+  '_', 'c', 'v', 't', 't', 'p', 'd', '2', 'u', 'q', 'q', '2', '5', '6', '_',
+  'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'i', 'a', '3', '2', '_', 'c', 'v', 't', 't', 'p', 'd', '2', 'u', 'q', 'q',
+  '5', '1', '2', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l',
   't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't', 't', 'p', 's',
-  '2', 'u', 'q', 'q', '5', '1', '2', '_', 'm', 'a', 's', 'k', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v',
-  't', 'u', 'q', 'q', '2', 'p', 's', '1', '2', '8', '_', 'm', 'a', 's', 'k',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'd', 'i', 'v', 's', 'd', '_', 'r', 'o', 'u', 'n', 'd', '_', 'm', 'a',
-  's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
-  '3', '2', '_', 'd', 'i', 'v', 's', 's', '_', 'r', 'o', 'u', 'n', 'd', '_',
-  'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'f', 'i', 'x', 'u', 'p', 'i', 'm', 'm', 'p', 'd',
-  '1', '2', '8', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'f', 'i', 'x', 'u', 'p', 'i',
-  'm', 'm', 'p', 'd', '2', '5', '6', '_', 'm', 'a', 's', 'k', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'f', 'i',
-  'x', 'u', 'p', 'i', 'm', 'm', 'p', 'd', '5', '1', '2', '_', 'm', 'a', 's',
-  'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
-  '2', '_', 'f', 'i', 'x', 'u', 'p', 'i', 'm', 'm', 'p', 's', '1', '2', '8',
-  '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'i', 'a', '3', '2', '_', 'f', 'i', 'x', 'u', 'p', 'i', 'm', 'm', 'p',
-  's', '2', '5', '6', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'f', 'i', 'x', 'u', 'p',
-  'i', 'm', 'm', 'p', 's', '5', '1', '2', '_', 'm', 'a', 's', 'k', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'f',
-  'i', 'x', 'u', 'p', 'i', 'm', 'm', 's', 'd', '_', 'm', 'a', 's', 'k', '\000',
+  '2', 'd', 'q', '5', '1', '2', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't',
+  't', 'p', 's', '2', 'q', 'q', '1', '2', '8', '_', 'm', 'a', 's', 'k', '\000',
   '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
-  'f', 'i', 'x', 'u', 'p', 'i', 'm', 'm', 's', 's', '_', 'm', 'a', 's', 'k',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'f', 'p', 'c', 'l', 'a', 's', 's', 's', 'd', '_', 'm', 'a', 's', 'k',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'f', 'p', 'c', 'l', 'a', 's', 's', 's', 's', '_', 'm', 'a', 's', 'k',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'g', 'e', 't', 'e', 'x', 'p', 'p', 'd', '1', '2', '8', '_', 'm', 'a',
+  'c', 'v', 't', 't', 'p', 's', '2', 'q', 'q', '2', '5', '6', '_', 'm', 'a',
   's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
-  '3', '2', '_', 'g', 'e', 't', 'e', 'x', 'p', 'p', 'd', '2', '5', '6', '_',
-  'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'g', 'e', 't', 'e', 'x', 'p', 'p', 'd', '5', '1',
-  '2', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'i', 'a', '3', '2', '_', 'g', 'e', 't', 'e', 'x', 'p', 'p', 's',
-  '1', '2', '8', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'g', 'e', 't', 'e', 'x', 'p',
-  'p', 's', '2', '5', '6', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'g', 'e', 't', 'e',
-  'x', 'p', 'p', 's', '5', '1', '2', '_', 'm', 'a', 's', 'k', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'g', 'e',
-  't', 'e', 'x', 'p', 's', 'd', '1', '2', '8', '_', 'r', 'o', 'u', 'n', 'd',
+  '3', '2', '_', 'c', 'v', 't', 't', 'p', 's', '2', 'q', 'q', '5', '1', '2',
   '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'i', 'a', '3', '2', '_', 'g', 'e', 't', 'e', 'x', 'p', 's', 's', '1',
-  '2', '8', '_', 'r', 'o', 'u', 'n', 'd', '_', 'm', 'a', 's', 'k', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'g',
-  'e', 't', 'm', 'a', 'n', 't', 'p', 'd', '1', '2', '8', '_', 'm', 'a', 's',
-  'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
-  '2', '_', 'g', 'e', 't', 'm', 'a', 'n', 't', 'p', 'd', '2', '5', '6', '_',
-  'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'g', 'e', 't', 'm', 'a', 'n', 't', 'p', 'd', '5',
-  '1', '2', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'g', 'e', 't', 'm', 'a', 'n', 't',
-  'p', 's', '1', '2', '8', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'g', 'e', 't', 'm',
-  'a', 'n', 't', 'p', 's', '2', '5', '6', '_', 'm', 'a', 's', 'k', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'g',
-  'e', 't', 'm', 'a', 'n', 't', 'p', 's', '5', '1', '2', '_', 'm', 'a', 's',
-  'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
-  '2', '_', 'g', 'e', 't', 'm', 'a', 'n', 't', 's', 'd', '_', 'r', 'o', 'u',
-  'n', 'd', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'g', 'e', 't', 'm', 'a', 'n', 't',
-  's', 's', '_', 'r', 'o', 'u', 'n', 'd', '_', 'm', 'a', 's', 'k', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'm',
-  'a', 'x', 's', 'd', '_', 'r', 'o', 'u', 'n', 'd', '_', 'm', 'a', 's', 'k',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'm', 'a', 'x', 's', 's', '_', 'r', 'o', 'u', 'n', 'd', '_', 'm', 'a',
+  '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't', 't', 'p', 's', '2', 'u', 'd',
+  'q', '1', '2', '8', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't', 't', 'p',
+  's', '2', 'u', 'd', 'q', '2', '5', '6', '_', 'm', 'a', 's', 'k', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c',
+  'v', 't', 't', 'p', 's', '2', 'u', 'd', 'q', '5', '1', '2', '_', 'm', 'a',
   's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
-  '3', '2', '_', 'm', 'i', 'n', 's', 'd', '_', 'r', 'o', 'u', 'n', 'd', '_',
+  '3', '2', '_', 'c', 'v', 't', 't', 'p', 's', '2', 'u', 'q', 'q', '1', '2',
+  '8', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't', 't', 'p', 's', '2', 'u',
+  'q', 'q', '2', '5', '6', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't', 't',
+  'p', 's', '2', 'u', 'q', 'q', '5', '1', '2', '_', 'm', 'a', 's', 'k', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
+  'c', 'v', 't', 'u', 'q', 'q', '2', 'p', 's', '1', '2', '8', '_', 'm', 'a',
+  's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
+  '3', '2', '_', 'd', 'i', 'v', 's', 'd', '_', 'r', 'o', 'u', 'n', 'd', '_',
   'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'm', 'i', 'n', 's', 's', '_', 'r', 'o', 'u', 'n',
+  'i', 'a', '3', '2', '_', 'd', 'i', 'v', 's', 's', '_', 'r', 'o', 'u', 'n',
   'd', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'i', 'a', '3', '2', '_', 'm', 'u', 'l', 's', 'd', '_', 'r', 'o',
-  'u', 'n', 'd', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'm', 'u', 'l', 's', 's', '_',
-  'r', 'o', 'u', 'n', 'd', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v',
-  'd', 'b', '1', '2', '8', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v',
-  'd', 'b', '2', '5', '6', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v',
-  'd', 'b', '1', '2', '8', 'm', 'e', 'm', '_', 'm', 'a', 's', 'k', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p',
-  'm', 'o', 'v', 'd', 'b', '2', '5', '6', 'm', 'e', 'm', '_', 'm', 'a', 's',
-  'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
-  '2', '_', 'p', 'm', 'o', 'v', 'd', 'b', '5', '1', '2', 'm', 'e', 'm', '_',
-  'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 'd', 'w', '1', '2', '8', '_',
-  'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 'd', 'w', '2', '5', '6', '_',
-  'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 'd', 'w', '1', '2', '8', 'm',
-  'e', 'm', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 'd', 'w', '2',
-  '5', '6', 'm', 'e', 'm', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v',
-  'd', 'w', '5', '1', '2', 'm', 'e', 'm', '_', 'm', 'a', 's', 'k', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p',
-  'm', 'o', 'v', 'q', 'b', '1', '2', '8', '_', 'm', 'a', 's', 'k', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p',
-  'm', 'o', 'v', 'q', 'b', '2', '5', '6', '_', 'm', 'a', 's', 'k', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p',
-  'm', 'o', 'v', 'q', 'b', '5', '1', '2', '_', 'm', 'a', 's', 'k', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p',
-  'm', 'o', 'v', 'q', 'b', '1', '2', '8', 'm', 'e', 'm', '_', 'm', 'a', 's',
-  'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
-  '2', '_', 'p', 'm', 'o', 'v', 'q', 'b', '2', '5', '6', 'm', 'e', 'm', '_',
-  'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 'q', 'b', '5', '1', '2', 'm',
-  'e', 'm', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 'q', 'd', '1',
+  'n', '_', 'i', 'a', '3', '2', '_', 'f', 'i', 'x', 'u', 'p', 'i', 'm', 'm',
+  'p', 'd', '1', '2', '8', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'f', 'i', 'x', 'u',
+  'p', 'i', 'm', 'm', 'p', 'd', '2', '5', '6', '_', 'm', 'a', 's', 'k', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
+  'f', 'i', 'x', 'u', 'p', 'i', 'm', 'm', 'p', 'd', '5', '1', '2', '_', 'm',
+  'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
+  'a', '3', '2', '_', 'f', 'i', 'x', 'u', 'p', 'i', 'm', 'm', 'p', 's', '1',
   '2', '8', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 'q', 'd', '1',
-  '2', '8', 'm', 'e', 'm', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v',
-  'q', 'd', '2', '5', '6', 'm', 'e', 'm', '_', 'm', 'a', 's', 'k', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p',
-  'm', 'o', 'v', 'q', 'd', '5', '1', '2', 'm', 'e', 'm', '_', 'm', 'a', 's',
+  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'f', 'i', 'x', 'u', 'p', 'i', 'm',
+  'm', 'p', 's', '2', '5', '6', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'f', 'i', 'x',
+  'u', 'p', 'i', 'm', 'm', 'p', 's', '5', '1', '2', '_', 'm', 'a', 's', 'k',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
+  '_', 'f', 'i', 'x', 'u', 'p', 'i', 'm', 'm', 's', 'd', '_', 'm', 'a', 's',
   'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
-  '2', '_', 'p', 'm', 'o', 'v', 'q', 'w', '1', '2', '8', '_', 'm', 'a', 's',
-  'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
-  '2', '_', 'p', 'm', 'o', 'v', 'q', 'w', '2', '5', '6', '_', 'm', 'a', 's',
-  'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
-  '2', '_', 'p', 'm', 'o', 'v', 'q', 'w', '1', '2', '8', 'm', 'e', 'm', '_',
-  'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 'q', 'w', '2', '5', '6', 'm',
-  'e', 'm', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 'q', 'w', '5',
-  '1', '2', 'm', 'e', 'm', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v',
-  'w', 'b', '1', '2', '8', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v',
-  'w', 'b', '1', '2', '8', 'm', 'e', 'm', '_', 'm', 'a', 's', 'k', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p',
-  'm', 'o', 'v', 'w', 'b', '2', '5', '6', 'm', 'e', 'm', '_', 'm', 'a', 's',
-  'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
-  '2', '_', 'p', 'm', 'o', 'v', 'w', 'b', '5', '1', '2', 'm', 'e', 'm', '_',
-  'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 's', 'd', 'b', '1', '2', '8',
-  '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 's', 'd', 'b', '2', '5',
-  '6', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 's', 'd', 'b', '5',
-  '1', '2', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 's', 'd', 'b',
-  '1', '2', '8', 'm', 'e', 'm', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o',
-  'v', 's', 'd', 'b', '2', '5', '6', 'm', 'e', 'm', '_', 'm', 'a', 's', 'k',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'p', 'm', 'o', 'v', 's', 'd', 'b', '5', '1', '2', 'm', 'e', 'm', '_',
-  'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 's', 'd', 'w', '1', '2', '8',
-  '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 's', 'd', 'w', '2', '5',
-  '6', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 's', 'd', 'w', '5',
-  '1', '2', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 's', 'd', 'w',
-  '1', '2', '8', 'm', 'e', 'm', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o',
-  'v', 's', 'd', 'w', '2', '5', '6', 'm', 'e', 'm', '_', 'm', 'a', 's', 'k',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'p', 'm', 'o', 'v', 's', 'd', 'w', '5', '1', '2', 'm', 'e', 'm', '_',
-  'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 's', 'q', 'b', '1', '2', '8',
-  '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 's', 'q', 'b', '2', '5',
-  '6', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 's', 'q', 'b', '5',
-  '1', '2', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 's', 'q', 'b',
-  '1', '2', '8', 'm', 'e', 'm', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o',
-  'v', 's', 'q', 'b', '2', '5', '6', 'm', 'e', 'm', '_', 'm', 'a', 's', 'k',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'p', 'm', 'o', 'v', 's', 'q', 'b', '5', '1', '2', 'm', 'e', 'm', '_',
-  'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 's', 'q', 'd', '1', '2', '8',
-  '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 's', 'q', 'd', '2', '5',
-  '6', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 's', 'q', 'd', '5',
-  '1', '2', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 's', 'q', 'd',
-  '1', '2', '8', 'm', 'e', 'm', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o',
-  'v', 's', 'q', 'd', '2', '5', '6', 'm', 'e', 'm', '_', 'm', 'a', 's', 'k',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'p', 'm', 'o', 'v', 's', 'q', 'd', '5', '1', '2', 'm', 'e', 'm', '_',
-  'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 's', 'q', 'w', '1', '2', '8',
-  '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 's', 'q', 'w', '2', '5',
-  '6', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 's', 'q', 'w', '5',
-  '1', '2', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 's', 'q', 'w',
-  '1', '2', '8', 'm', 'e', 'm', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o',
-  'v', 's', 'q', 'w', '2', '5', '6', 'm', 'e', 'm', '_', 'm', 'a', 's', 'k',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'p', 'm', 'o', 'v', 's', 'q', 'w', '5', '1', '2', 'm', 'e', 'm', '_',
-  'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 's', 'w', 'b', '1', '2', '8',
-  '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 's', 'w', 'b', '2', '5',
-  '6', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 's', 'w', 'b', '5',
-  '1', '2', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 's', 'w', 'b',
-  '1', '2', '8', 'm', 'e', 'm', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o',
-  'v', 's', 'w', 'b', '2', '5', '6', 'm', 'e', 'm', '_', 'm', 'a', 's', 'k',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'p', 'm', 'o', 'v', 's', 'w', 'b', '5', '1', '2', 'm', 'e', 'm', '_',
-  'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 'u', 's', 'd', 'b', '1', '2',
-  '8', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 'u', 's', 'd', 'b',
-  '2', '5', '6', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 'u', 's',
-  'd', 'b', '5', '1', '2', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v',
-  'u', 's', 'd', 'b', '1', '2', '8', 'm', 'e', 'm', '_', 'm', 'a', 's', 'k',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'p', 'm', 'o', 'v', 'u', 's', 'd', 'b', '2', '5', '6', 'm', 'e', 'm',
-  '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 'u', 's', 'd', 'b', '5',
-  '1', '2', 'm', 'e', 'm', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v',
-  'u', 's', 'd', 'w', '1', '2', '8', '_', 'm', 'a', 's', 'k', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm',
-  'o', 'v', 'u', 's', 'd', 'w', '2', '5', '6', '_', 'm', 'a', 's', 'k', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
-  'p', 'm', 'o', 'v', 'u', 's', 'd', 'w', '5', '1', '2', '_', 'm', 'a', 's',
-  'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
-  '2', '_', 'p', 'm', 'o', 'v', 'u', 's', 'd', 'w', '1', '2', '8', 'm', 'e',
-  'm', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 'u', 's', 'd', 'w',
-  '2', '5', '6', 'm', 'e', 'm', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o',
-  'v', 'u', 's', 'd', 'w', '5', '1', '2', 'm', 'e', 'm', '_', 'm', 'a', 's',
-  'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
-  '2', '_', 'p', 'm', 'o', 'v', 'u', 's', 'q', 'b', '1', '2', '8', '_', 'm',
-  'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'p', 'm', 'o', 'v', 'u', 's', 'q', 'b', '2', '5', '6',
-  '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 'u', 's', 'q', 'b', '5',
-  '1', '2', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 'u', 's', 'q',
-  'b', '1', '2', '8', 'm', 'e', 'm', '_', 'm', 'a', 's', 'k', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm',
-  'o', 'v', 'u', 's', 'q', 'b', '2', '5', '6', 'm', 'e', 'm', '_', 'm', 'a',
+  '2', '_', 'f', 'i', 'x', 'u', 'p', 'i', 'm', 'm', 's', 's', '_', 'm', 'a',
   's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
-  '3', '2', '_', 'p', 'm', 'o', 'v', 'u', 's', 'q', 'b', '5', '1', '2', 'm',
-  'e', 'm', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 'u', 's', 'q',
-  'd', '1', '2', '8', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 'u',
-  's', 'q', 'd', '2', '5', '6', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o',
-  'v', 'u', 's', 'q', 'd', '5', '1', '2', '_', 'm', 'a', 's', 'k', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p',
-  'm', 'o', 'v', 'u', 's', 'q', 'd', '1', '2', '8', 'm', 'e', 'm', '_', 'm',
-  'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'p', 'm', 'o', 'v', 'u', 's', 'q', 'd', '2', '5', '6',
-  'm', 'e', 'm', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 'u', 's',
-  'q', 'd', '5', '1', '2', 'm', 'e', 'm', '_', 'm', 'a', 's', 'k', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p',
-  'm', 'o', 'v', 'u', 's', 'q', 'w', '1', '2', '8', '_', 'm', 'a', 's', 'k',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'p', 'm', 'o', 'v', 'u', 's', 'q', 'w', '2', '5', '6', '_', 'm', 'a',
+  '3', '2', '_', 'f', 'p', 'c', 'l', 'a', 's', 's', 's', 'd', '_', 'm', 'a',
   's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
-  '3', '2', '_', 'p', 'm', 'o', 'v', 'u', 's', 'q', 'w', '5', '1', '2', '_',
+  '3', '2', '_', 'f', 'p', 'c', 'l', 'a', 's', 's', 's', 's', '_', 'm', 'a',
+  's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
+  '3', '2', '_', 'g', 'e', 't', 'e', 'x', 'p', 'p', 'd', '1', '2', '8', '_',
   'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 'u', 's', 'q', 'w', '1', '2',
-  '8', 'm', 'e', 'm', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 'u',
-  's', 'q', 'w', '2', '5', '6', 'm', 'e', 'm', '_', 'm', 'a', 's', 'k', '\000',
+  'i', 'a', '3', '2', '_', 'g', 'e', 't', 'e', 'x', 'p', 'p', 'd', '2', '5',
+  '6', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'g', 'e', 't', 'e', 'x', 'p', 'p', 'd',
+  '5', '1', '2', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'g', 'e', 't', 'e', 'x', 'p',
+  'p', 's', '1', '2', '8', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'g', 'e', 't', 'e',
+  'x', 'p', 'p', 's', '2', '5', '6', '_', 'm', 'a', 's', 'k', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'g', 'e',
+  't', 'e', 'x', 'p', 'p', 's', '5', '1', '2', '_', 'm', 'a', 's', 'k', '\000',
   '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
-  'p', 'm', 'o', 'v', 'u', 's', 'q', 'w', '5', '1', '2', 'm', 'e', 'm', '_',
-  'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 'u', 's', 'w', 'b', '1', '2',
-  '8', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 'u', 's', 'w', 'b',
-  '2', '5', '6', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 'u', 's',
-  'w', 'b', '5', '1', '2', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v',
-  'u', 's', 'w', 'b', '1', '2', '8', 'm', 'e', 'm', '_', 'm', 'a', 's', 'k',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'p', 'm', 'o', 'v', 'u', 's', 'w', 'b', '2', '5', '6', 'm', 'e', 'm',
-  '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 'u', 's', 'w', 'b', '5',
-  '1', '2', 'm', 'e', 'm', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'r', 'a', 'n', 'g',
-  'e', 'p', 'd', '1', '2', '8', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'r', 'a', 'n',
-  'g', 'e', 'p', 'd', '2', '5', '6', '_', 'm', 'a', 's', 'k', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'r', 'a',
-  'n', 'g', 'e', 'p', 'd', '5', '1', '2', '_', 'm', 'a', 's', 'k', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'r',
-  'a', 'n', 'g', 'e', 'p', 's', '1', '2', '8', '_', 'm', 'a', 's', 'k', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
-  'r', 'a', 'n', 'g', 'e', 'p', 's', '2', '5', '6', '_', 'm', 'a', 's', 'k',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'r', 'a', 'n', 'g', 'e', 'p', 's', '5', '1', '2', '_', 'm', 'a', 's',
-  'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
-  '2', '_', 'r', 'a', 'n', 'g', 'e', 's', 'd', '1', '2', '8', '_', 'r', 'o',
-  'u', 'n', 'd', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'r', 'a', 'n', 'g', 'e', 's',
+  'g', 'e', 't', 'e', 'x', 'p', 's', 'd', '1', '2', '8', '_', 'r', 'o', 'u',
+  'n', 'd', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'g', 'e', 't', 'e', 'x', 'p', 's',
   's', '1', '2', '8', '_', 'r', 'o', 'u', 'n', 'd', '_', 'm', 'a', 's', 'k',
   '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'r', 'e', 'd', 'u', 'c', 'e', 'p', 'd', '1', '2', '8', '_', 'm', 'a',
-  's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
-  '3', '2', '_', 'r', 'e', 'd', 'u', 'c', 'e', 'p', 'd', '2', '5', '6', '_',
-  'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'r', 'e', 'd', 'u', 'c', 'e', 'p', 'd', '5', '1',
-  '2', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'i', 'a', '3', '2', '_', 'r', 'e', 'd', 'u', 'c', 'e', 'p', 's',
-  '1', '2', '8', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'r', 'e', 'd', 'u', 'c', 'e',
-  'p', 's', '2', '5', '6', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'r', 'e', 'd', 'u',
-  'c', 'e', 'p', 's', '5', '1', '2', '_', 'm', 'a', 's', 'k', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'r', 'e',
-  'd', 'u', 'c', 'e', 's', 'd', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'r', 'e', 'd',
-  'u', 'c', 'e', 's', 's', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'r', 'n', 'd', 's',
-  'c', 'a', 'l', 'e', 'p', 'd', '_', '1', '2', '8', '_', 'm', 'a', 's', 'k',
+  '_', 'g', 'e', 't', 'm', 'a', 'n', 't', 'p', 'd', '1', '2', '8', '_', 'm',
+  'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
+  'a', '3', '2', '_', 'g', 'e', 't', 'm', 'a', 'n', 't', 'p', 'd', '2', '5',
+  '6', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'g', 'e', 't', 'm', 'a', 'n', 't', 'p',
+  'd', '5', '1', '2', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'g', 'e', 't', 'm', 'a',
+  'n', 't', 'p', 's', '1', '2', '8', '_', 'm', 'a', 's', 'k', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'g', 'e',
+  't', 'm', 'a', 'n', 't', 'p', 's', '2', '5', '6', '_', 'm', 'a', 's', 'k',
   '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'r', 'n', 'd', 's', 'c', 'a', 'l', 'e', 'p', 'd', '_', '2', '5', '6',
-  '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'i', 'a', '3', '2', '_', 'r', 'n', 'd', 's', 'c', 'a', 'l', 'e', 'p',
-  'd', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'i', 'a', '3', '2', '_', 'r', 'n', 'd', 's', 'c', 'a', 'l', 'e',
-  'p', 's', '_', '1', '2', '8', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'r', 'n', 'd',
-  's', 'c', 'a', 'l', 'e', 'p', 's', '_', '2', '5', '6', '_', 'm', 'a', 's',
-  'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
-  '2', '_', 'r', 'n', 'd', 's', 'c', 'a', 'l', 'e', 'p', 's', '_', 'm', 'a',
-  's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
-  '3', '2', '_', 'r', 'n', 'd', 's', 'c', 'a', 'l', 'e', 's', 'd', '_', 'r',
+  '_', 'g', 'e', 't', 'm', 'a', 'n', 't', 'p', 's', '5', '1', '2', '_', 'm',
+  'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
+  'a', '3', '2', '_', 'g', 'e', 't', 'm', 'a', 'n', 't', 's', 'd', '_', 'r',
   'o', 'u', 'n', 'd', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'r', 'n', 'd', 's', 'c',
-  'a', 'l', 'e', 's', 's', '_', 'r', 'o', 'u', 'n', 'd', '_', 'm', 'a', 's',
-  'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
-  '2', '_', 's', 'c', 'a', 'l', 'e', 'f', 'p', 'd', '1', '2', '8', '_', 'm',
-  'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 's', 'c', 'a', 'l', 'e', 'f', 'p', 'd', '2', '5', '6',
-  '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'i', 'a', '3', '2', '_', 's', 'c', 'a', 'l', 'e', 'f', 'p', 'd', '5',
-  '1', '2', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 's', 'c', 'a', 'l', 'e', 'f', 'p',
-  's', '1', '2', '8', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 's', 'c', 'a', 'l', 'e',
-  'f', 'p', 's', '2', '5', '6', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 's', 'c', 'a',
-  'l', 'e', 'f', 'p', 's', '5', '1', '2', '_', 'm', 'a', 's', 'k', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 's',
-  'c', 'a', 'l', 'e', 'f', 's', 'd', '_', 'r', 'o', 'u', 'n', 'd', '_', 'm',
-  'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 's', 'c', 'a', 'l', 'e', 'f', 's', 's', '_', 'r', 'o',
+  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'g', 'e', 't', 'm', 'a',
+  'n', 't', 's', 's', '_', 'r', 'o', 'u', 'n', 'd', '_', 'm', 'a', 's', 'k',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
+  '_', 'm', 'a', 'x', 's', 'd', '_', 'r', 'o', 'u', 'n', 'd', '_', 'm', 'a',
+  's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
+  '3', '2', '_', 'm', 'a', 'x', 's', 's', '_', 'r', 'o', 'u', 'n', 'd', '_',
+  'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'i', 'a', '3', '2', '_', 'm', 'i', 'n', 's', 'd', '_', 'r', 'o', 'u', 'n',
+  'd', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'm', 'i', 'n', 's', 's', '_', 'r', 'o',
   'u', 'n', 'd', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 's', 'u', 'b', 's', 'd', '_',
+  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'm', 'u', 'l', 's', 'd', '_',
+  'r', 'o', 'u', 'n', 'd', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'm', 'u', 'l', 's',
+  's', '_', 'r', 'o', 'u', 'n', 'd', '_', 'm', 'a', 's', 'k', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm',
+  'o', 'v', 'd', 'b', '1', '2', '8', '_', 'm', 'a', 's', 'k', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm',
+  'o', 'v', 'd', 'b', '2', '5', '6', '_', 'm', 'a', 's', 'k', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm',
+  'o', 'v', 'd', 'b', '1', '2', '8', 'm', 'e', 'm', '_', 'm', 'a', 's', 'k',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
+  '_', 'p', 'm', 'o', 'v', 'd', 'b', '2', '5', '6', 'm', 'e', 'm', '_', 'm',
+  'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
+  'a', '3', '2', '_', 'p', 'm', 'o', 'v', 'd', 'b', '5', '1', '2', 'm', 'e',
+  'm', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 'd', 'w', '1', '2',
+  '8', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 'd', 'w', '2', '5',
+  '6', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 'd', 'w', '1', '2',
+  '8', 'm', 'e', 'm', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 'd',
+  'w', '2', '5', '6', 'm', 'e', 'm', '_', 'm', 'a', 's', 'k', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm',
+  'o', 'v', 'd', 'w', '5', '1', '2', 'm', 'e', 'm', '_', 'm', 'a', 's', 'k',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
+  '_', 'p', 'm', 'o', 'v', 'q', 'b', '1', '2', '8', '_', 'm', 'a', 's', 'k',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
+  '_', 'p', 'm', 'o', 'v', 'q', 'b', '2', '5', '6', '_', 'm', 'a', 's', 'k',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
+  '_', 'p', 'm', 'o', 'v', 'q', 'b', '5', '1', '2', '_', 'm', 'a', 's', 'k',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
+  '_', 'p', 'm', 'o', 'v', 'q', 'b', '1', '2', '8', 'm', 'e', 'm', '_', 'm',
+  'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
+  'a', '3', '2', '_', 'p', 'm', 'o', 'v', 'q', 'b', '2', '5', '6', 'm', 'e',
+  'm', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 'q', 'b', '5', '1',
+  '2', 'm', 'e', 'm', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 'q',
+  'd', '1', '2', '8', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 'q',
+  'd', '1', '2', '8', 'm', 'e', 'm', '_', 'm', 'a', 's', 'k', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm',
+  'o', 'v', 'q', 'd', '2', '5', '6', 'm', 'e', 'm', '_', 'm', 'a', 's', 'k',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
+  '_', 'p', 'm', 'o', 'v', 'q', 'd', '5', '1', '2', 'm', 'e', 'm', '_', 'm',
+  'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
+  'a', '3', '2', '_', 'p', 'm', 'o', 'v', 'q', 'w', '1', '2', '8', '_', 'm',
+  'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
+  'a', '3', '2', '_', 'p', 'm', 'o', 'v', 'q', 'w', '2', '5', '6', '_', 'm',
+  'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
+  'a', '3', '2', '_', 'p', 'm', 'o', 'v', 'q', 'w', '1', '2', '8', 'm', 'e',
+  'm', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 'q', 'w', '2', '5',
+  '6', 'm', 'e', 'm', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 'q',
+  'w', '5', '1', '2', 'm', 'e', 'm', '_', 'm', 'a', 's', 'k', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm',
+  'o', 'v', 'w', 'b', '1', '2', '8', '_', 'm', 'a', 's', 'k', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm',
+  'o', 'v', 'w', 'b', '1', '2', '8', 'm', 'e', 'm', '_', 'm', 'a', 's', 'k',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
+  '_', 'p', 'm', 'o', 'v', 'w', 'b', '2', '5', '6', 'm', 'e', 'm', '_', 'm',
+  'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
+  'a', '3', '2', '_', 'p', 'm', 'o', 'v', 'w', 'b', '5', '1', '2', 'm', 'e',
+  'm', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 's', 'd', 'b', '1',
+  '2', '8', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 's', 'd', 'b',
+  '2', '5', '6', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 's', 'd',
+  'b', '5', '1', '2', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 's',
+  'd', 'b', '1', '2', '8', 'm', 'e', 'm', '_', 'm', 'a', 's', 'k', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p',
+  'm', 'o', 'v', 's', 'd', 'b', '2', '5', '6', 'm', 'e', 'm', '_', 'm', 'a',
+  's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
+  '3', '2', '_', 'p', 'm', 'o', 'v', 's', 'd', 'b', '5', '1', '2', 'm', 'e',
+  'm', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 's', 'd', 'w', '1',
+  '2', '8', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 's', 'd', 'w',
+  '2', '5', '6', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 's', 'd',
+  'w', '5', '1', '2', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 's',
+  'd', 'w', '1', '2', '8', 'm', 'e', 'm', '_', 'm', 'a', 's', 'k', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p',
+  'm', 'o', 'v', 's', 'd', 'w', '2', '5', '6', 'm', 'e', 'm', '_', 'm', 'a',
+  's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
+  '3', '2', '_', 'p', 'm', 'o', 'v', 's', 'd', 'w', '5', '1', '2', 'm', 'e',
+  'm', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 's', 'q', 'b', '1',
+  '2', '8', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 's', 'q', 'b',
+  '2', '5', '6', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 's', 'q',
+  'b', '5', '1', '2', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 's',
+  'q', 'b', '1', '2', '8', 'm', 'e', 'm', '_', 'm', 'a', 's', 'k', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p',
+  'm', 'o', 'v', 's', 'q', 'b', '2', '5', '6', 'm', 'e', 'm', '_', 'm', 'a',
+  's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
+  '3', '2', '_', 'p', 'm', 'o', 'v', 's', 'q', 'b', '5', '1', '2', 'm', 'e',
+  'm', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 's', 'q', 'd', '1',
+  '2', '8', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 's', 'q', 'd',
+  '2', '5', '6', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 's', 'q',
+  'd', '5', '1', '2', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 's',
+  'q', 'd', '1', '2', '8', 'm', 'e', 'm', '_', 'm', 'a', 's', 'k', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p',
+  'm', 'o', 'v', 's', 'q', 'd', '2', '5', '6', 'm', 'e', 'm', '_', 'm', 'a',
+  's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
+  '3', '2', '_', 'p', 'm', 'o', 'v', 's', 'q', 'd', '5', '1', '2', 'm', 'e',
+  'm', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 's', 'q', 'w', '1',
+  '2', '8', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 's', 'q', 'w',
+  '2', '5', '6', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 's', 'q',
+  'w', '5', '1', '2', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 's',
+  'q', 'w', '1', '2', '8', 'm', 'e', 'm', '_', 'm', 'a', 's', 'k', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p',
+  'm', 'o', 'v', 's', 'q', 'w', '2', '5', '6', 'm', 'e', 'm', '_', 'm', 'a',
+  's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
+  '3', '2', '_', 'p', 'm', 'o', 'v', 's', 'q', 'w', '5', '1', '2', 'm', 'e',
+  'm', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 's', 'w', 'b', '1',
+  '2', '8', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 's', 'w', 'b',
+  '2', '5', '6', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 's', 'w',
+  'b', '5', '1', '2', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 's',
+  'w', 'b', '1', '2', '8', 'm', 'e', 'm', '_', 'm', 'a', 's', 'k', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p',
+  'm', 'o', 'v', 's', 'w', 'b', '2', '5', '6', 'm', 'e', 'm', '_', 'm', 'a',
+  's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
+  '3', '2', '_', 'p', 'm', 'o', 'v', 's', 'w', 'b', '5', '1', '2', 'm', 'e',
+  'm', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 'u', 's', 'd', 'b',
+  '1', '2', '8', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 'u', 's',
+  'd', 'b', '2', '5', '6', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v',
+  'u', 's', 'd', 'b', '5', '1', '2', '_', 'm', 'a', 's', 'k', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm',
+  'o', 'v', 'u', 's', 'd', 'b', '1', '2', '8', 'm', 'e', 'm', '_', 'm', 'a',
+  's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
+  '3', '2', '_', 'p', 'm', 'o', 'v', 'u', 's', 'd', 'b', '2', '5', '6', 'm',
+  'e', 'm', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 'u', 's', 'd',
+  'b', '5', '1', '2', 'm', 'e', 'm', '_', 'm', 'a', 's', 'k', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm',
+  'o', 'v', 'u', 's', 'd', 'w', '1', '2', '8', '_', 'm', 'a', 's', 'k', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
+  'p', 'm', 'o', 'v', 'u', 's', 'd', 'w', '2', '5', '6', '_', 'm', 'a', 's',
+  'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
+  '2', '_', 'p', 'm', 'o', 'v', 'u', 's', 'd', 'w', '5', '1', '2', '_', 'm',
+  'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
+  'a', '3', '2', '_', 'p', 'm', 'o', 'v', 'u', 's', 'd', 'w', '1', '2', '8',
+  'm', 'e', 'm', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 'u', 's',
+  'd', 'w', '2', '5', '6', 'm', 'e', 'm', '_', 'm', 'a', 's', 'k', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p',
+  'm', 'o', 'v', 'u', 's', 'd', 'w', '5', '1', '2', 'm', 'e', 'm', '_', 'm',
+  'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
+  'a', '3', '2', '_', 'p', 'm', 'o', 'v', 'u', 's', 'q', 'b', '1', '2', '8',
+  '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 'u', 's', 'q', 'b', '2',
+  '5', '6', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 'u', 's', 'q',
+  'b', '5', '1', '2', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 'u',
+  's', 'q', 'b', '1', '2', '8', 'm', 'e', 'm', '_', 'm', 'a', 's', 'k', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
+  'p', 'm', 'o', 'v', 'u', 's', 'q', 'b', '2', '5', '6', 'm', 'e', 'm', '_',
+  'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 'u', 's', 'q', 'b', '5', '1',
+  '2', 'm', 'e', 'm', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 'u',
+  's', 'q', 'd', '1', '2', '8', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o',
+  'v', 'u', 's', 'q', 'd', '2', '5', '6', '_', 'm', 'a', 's', 'k', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p',
+  'm', 'o', 'v', 'u', 's', 'q', 'd', '5', '1', '2', '_', 'm', 'a', 's', 'k',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
+  '_', 'p', 'm', 'o', 'v', 'u', 's', 'q', 'd', '1', '2', '8', 'm', 'e', 'm',
+  '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 'u', 's', 'q', 'd', '2',
+  '5', '6', 'm', 'e', 'm', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v',
+  'u', 's', 'q', 'd', '5', '1', '2', 'm', 'e', 'm', '_', 'm', 'a', 's', 'k',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
+  '_', 'p', 'm', 'o', 'v', 'u', 's', 'q', 'w', '1', '2', '8', '_', 'm', 'a',
+  's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
+  '3', '2', '_', 'p', 'm', 'o', 'v', 'u', 's', 'q', 'w', '2', '5', '6', '_',
+  'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 'u', 's', 'q', 'w', '5', '1',
+  '2', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 'u', 's', 'q', 'w',
+  '1', '2', '8', 'm', 'e', 'm', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o',
+  'v', 'u', 's', 'q', 'w', '2', '5', '6', 'm', 'e', 'm', '_', 'm', 'a', 's',
+  'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
+  '2', '_', 'p', 'm', 'o', 'v', 'u', 's', 'q', 'w', '5', '1', '2', 'm', 'e',
+  'm', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 'u', 's', 'w', 'b',
+  '1', '2', '8', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 'u', 's',
+  'w', 'b', '2', '5', '6', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v',
+  'u', 's', 'w', 'b', '5', '1', '2', '_', 'm', 'a', 's', 'k', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm',
+  'o', 'v', 'u', 's', 'w', 'b', '1', '2', '8', 'm', 'e', 'm', '_', 'm', 'a',
+  's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
+  '3', '2', '_', 'p', 'm', 'o', 'v', 'u', 's', 'w', 'b', '2', '5', '6', 'm',
+  'e', 'm', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 'u', 's', 'w',
+  'b', '5', '1', '2', 'm', 'e', 'm', '_', 'm', 'a', 's', 'k', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'r', 'a',
+  'n', 'g', 'e', 'p', 'd', '1', '2', '8', '_', 'm', 'a', 's', 'k', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'r',
+  'a', 'n', 'g', 'e', 'p', 'd', '2', '5', '6', '_', 'm', 'a', 's', 'k', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
+  'r', 'a', 'n', 'g', 'e', 'p', 'd', '5', '1', '2', '_', 'm', 'a', 's', 'k',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
+  '_', 'r', 'a', 'n', 'g', 'e', 'p', 's', '1', '2', '8', '_', 'm', 'a', 's',
+  'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
+  '2', '_', 'r', 'a', 'n', 'g', 'e', 'p', 's', '2', '5', '6', '_', 'm', 'a',
+  's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
+  '3', '2', '_', 'r', 'a', 'n', 'g', 'e', 'p', 's', '5', '1', '2', '_', 'm',
+  'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
+  'a', '3', '2', '_', 'r', 'a', 'n', 'g', 'e', 's', 'd', '1', '2', '8', '_',
+  'r', 'o', 'u', 'n', 'd', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'r', 'a', 'n', 'g',
+  'e', 's', 's', '1', '2', '8', '_', 'r', 'o', 'u', 'n', 'd', '_', 'm', 'a',
+  's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
+  '3', '2', '_', 'r', 'e', 'd', 'u', 'c', 'e', 'p', 'd', '1', '2', '8', '_',
+  'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'i', 'a', '3', '2', '_', 'r', 'e', 'd', 'u', 'c', 'e', 'p', 'd', '2', '5',
+  '6', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'r', 'e', 'd', 'u', 'c', 'e', 'p', 'd',
+  '5', '1', '2', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'r', 'e', 'd', 'u', 'c', 'e',
+  'p', 's', '1', '2', '8', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'r', 'e', 'd', 'u',
+  'c', 'e', 'p', 's', '2', '5', '6', '_', 'm', 'a', 's', 'k', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'r', 'e',
+  'd', 'u', 'c', 'e', 'p', 's', '5', '1', '2', '_', 'm', 'a', 's', 'k', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
+  'r', 'e', 'd', 'u', 'c', 'e', 's', 'd', '_', 'm', 'a', 's', 'k', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'r',
+  'e', 'd', 'u', 'c', 'e', 's', 's', '_', 'm', 'a', 's', 'k', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'r', 'n',
+  'd', 's', 'c', 'a', 'l', 'e', 'p', 'd', '_', '1', '2', '8', '_', 'm', 'a',
+  's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
+  '3', '2', '_', 'r', 'n', 'd', 's', 'c', 'a', 'l', 'e', 'p', 'd', '_', '2',
+  '5', '6', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'r', 'n', 'd', 's', 'c', 'a', 'l',
+  'e', 'p', 'd', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'r', 'n', 'd', 's', 'c', 'a',
+  'l', 'e', 'p', 's', '_', '1', '2', '8', '_', 'm', 'a', 's', 'k', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'r',
+  'n', 'd', 's', 'c', 'a', 'l', 'e', 'p', 's', '_', '2', '5', '6', '_', 'm',
+  'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
+  'a', '3', '2', '_', 'r', 'n', 'd', 's', 'c', 'a', 'l', 'e', 'p', 's', '_',
+  'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'i', 'a', '3', '2', '_', 'r', 'n', 'd', 's', 'c', 'a', 'l', 'e', 's', 'd',
+  '_', 'r', 'o', 'u', 'n', 'd', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'r', 'n', 'd',
+  's', 'c', 'a', 'l', 'e', 's', 's', '_', 'r', 'o', 'u', 'n', 'd', '_', 'm',
+  'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
+  'a', '3', '2', '_', 's', 'c', 'a', 'l', 'e', 'f', 'p', 'd', '1', '2', '8',
+  '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'i', 'a', '3', '2', '_', 's', 'c', 'a', 'l', 'e', 'f', 'p', 'd', '2',
+  '5', '6', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'i', 'a', '3', '2', '_', 's', 'c', 'a', 'l', 'e', 'f', 'p',
+  'd', '5', '1', '2', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 's', 'c', 'a', 'l', 'e',
+  'f', 'p', 's', '1', '2', '8', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 's', 'c', 'a',
+  'l', 'e', 'f', 'p', 's', '2', '5', '6', '_', 'm', 'a', 's', 'k', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 's',
+  'c', 'a', 'l', 'e', 'f', 'p', 's', '5', '1', '2', '_', 'm', 'a', 's', 'k',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
+  '_', 's', 'c', 'a', 'l', 'e', 'f', 's', 'd', '_', 'r', 'o', 'u', 'n', 'd',
+  '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'i', 'a', '3', '2', '_', 's', 'c', 'a', 'l', 'e', 'f', 's', 's', '_',
   'r', 'o', 'u', 'n', 'd', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u',
   'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 's', 'u', 'b', 's',
-  's', '_', 'r', 'o', 'u', 'n', 'd', '_', 'm', 'a', 's', 'k', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'c',
-  'v', 't', 'p', 'h', '2', 'p', 's', '_', 'm', 'a', 's', 'k', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'c',
-  'v', 't', 'p', 'h', '2', 'p', 's', '2', '5', '6', '_', 'm', 'a', 's', 'k',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'v', 'c', 'v', 't', 'p', 'h', '2', 'p', 's', '5', '1', '2', '_', 'm',
-  'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'v', 'c', 'v', 't', 'p', 's', '2', 'p', 'h', '_', 'm',
-  'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'v', 'c', 'v', 't', 'p', 's', '2', 'p', 'h', '2', '5',
-  '6', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'i', 'a', '3', '2', '_', 'v', 'c', 'v', 't', 'p', 's', '2', 'p',
-  'h', '5', '1', '2', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'f', 'i', 'x', 'u', 'p',
-  'i', 'm', 'm', 'p', 'd', '1', '2', '8', '_', 'm', 'a', 's', 'k', 'z', '\000',
+  'd', '_', 'r', 'o', 'u', 'n', 'd', '_', 'm', 'a', 's', 'k', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 's', 'u',
+  'b', 's', 's', '_', 'r', 'o', 'u', 'n', 'd', '_', 'm', 'a', 's', 'k', '\000',
   '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
-  'f', 'i', 'x', 'u', 'p', 'i', 'm', 'm', 'p', 'd', '2', '5', '6', '_', 'm',
-  'a', 's', 'k', 'z', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'f', 'i', 'x', 'u', 'p', 'i', 'm', 'm', 'p', 'd',
-  '5', '1', '2', '_', 'm', 'a', 's', 'k', 'z', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'f', 'i', 'x', 'u', 'p',
-  'i', 'm', 'm', 'p', 's', '1', '2', '8', '_', 'm', 'a', 's', 'k', 'z', '\000',
+  'v', 'c', 'v', 't', 'p', 's', '2', 'p', 'h', '_', 'm', 'a', 's', 'k', '\000',
   '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
-  'f', 'i', 'x', 'u', 'p', 'i', 'm', 'm', 'p', 's', '2', '5', '6', '_', 'm',
-  'a', 's', 'k', 'z', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'f', 'i', 'x', 'u', 'p', 'i', 'm', 'm', 'p', 's',
-  '5', '1', '2', '_', 'm', 'a', 's', 'k', 'z', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'f', 'i', 'x', 'u', 'p',
-  'i', 'm', 'm', 's', 'd', '_', 'm', 'a', 's', 'k', 'z', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'f', 'i', 'x',
-  'u', 'p', 'i', 'm', 'm', 's', 's', '_', 'm', 'a', 's', 'k', 'z', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'm',
-  'a', 'x', 'p', 'd', '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'm', 'a', 'x', 'p', 's', '5', '1',
-  '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
-  '2', '_', 'm', 'i', 'n', 'p', 'd', '5', '1', '2', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'm', 'i', 'n', 'p',
-  's', '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'm', 'u', 'l', 'p', 'd', '5', '1', '2', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'm',
-  'u', 'l', 'p', 's', '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'a', 'c', 'k', 's', 's', 'd',
-  'w', '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'p', 'a', 'c', 'k', 's', 's', 'w', 'b', '5', '1',
-  '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
-  '2', '_', 'p', 'a', 'c', 'k', 'u', 's', 'd', 'w', '5', '1', '2', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p',
-  'a', 'c', 'k', 'u', 's', 'w', 'b', '5', '1', '2', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'a', 'v', 'g',
-  'b', '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'p', 'a', 'v', 'g', 'w', '5', '1', '2', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p',
-  'e', 'r', 'm', 'v', 'a', 'r', 'd', 'f', '2', '5', '6', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'e', 'r',
-  'm', 'v', 'a', 'r', 'd', 'f', '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'e', 'r', 'm', 'v',
-  'a', 'r', 'd', 'i', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'e', 'r', 'm', 'v', 'a', 'r',
-  'd', 'i', '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'i', 'a', '3', '2', '_', 'p', 'e', 'r', 'm', 'v', 'a', 'r', 'h', 'i',
-  '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'p', 'e', 'r', 'm', 'v', 'a', 'r', 'h', 'i', '2', '5',
-  '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
-  '2', '_', 'p', 'e', 'r', 'm', 'v', 'a', 'r', 'h', 'i', '5', '1', '2', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
-  'p', 'e', 'r', 'm', 'v', 'a', 'r', 'q', 'i', '1', '2', '8', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'e',
-  'r', 'm', 'v', 'a', 'r', 'q', 'i', '2', '5', '6', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'e', 'r', 'm',
-  'v', 'a', 'r', 'q', 'i', '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'e', 'r', 'm', 'v', 'a',
-  'r', 's', 'f', '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'i', 'a', '3', '2', '_', 'p', 'e', 'r', 'm', 'v', 'a', 'r', 's',
-  'i', '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'p', 'm', 'a', 'd', 'd', 'u', 'b', 's', 'w', '5',
-  '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
-  '3', '2', '_', 'p', 'm', 'a', 'd', 'd', 'w', 'd', '5', '1', '2', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p',
-  'm', 'u', 'l', 'h', 'r', 's', 'w', '5', '1', '2', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'u', 'l',
-  'h', 'w', '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'u', 'l', 'h', 'u', 'w', '5', '1',
-  '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
-  '2', '_', 'v', 'p', 'm', 'u', 'l', 't', 'i', 's', 'h', 'i', 'f', 't', 'q',
-  'b', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'v', 'p', 'm', 'u', 'l', 't', 'i', 's', 'h', 'i',
-  'f', 't', 'q', 'b', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 'm', 'u', 'l', 't', 'i',
-  's', 'h', 'i', 'f', 't', 'q', 'b', '5', '1', '2', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'a', 'd',
-  'b', 'w', '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'i', 'a', '3', '2', '_', 'p', 's', 'h', 'u', 'f', 'b', '5', '1', '2',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'p', 's', 'l', 'l', 'd', '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'l', 'l', 'q',
-  '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'p', 's', 'l', 'l', 'w', '5', '1', '2', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's',
-  'l', 'l', 'd', 'i', '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'l', 'l', 'q', 'i', '5',
-  '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
-  '3', '2', '_', 'p', 's', 'l', 'l', 'w', 'i', '5', '1', '2', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's',
-  'l', 'l', 'v', '1', '6', 's', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'l', 'l', 'v', '8', 'd',
-  'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
-  '2', '_', 'p', 's', 'l', 'l', 'v', '8', 'h', 'i', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'l', 'l',
-  'v', '1', '6', 'h', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'i', 'a', '3', '2', '_', 'p', 's', 'l', 'l', 'v', '3', '2', 'h', 'i',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'p', 's', 'r', 'a', 'd', '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'r', 'a', 'q',
-  '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'p', 's', 'r', 'a', 'q', '2', '5', '6', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's',
-  'r', 'a', 'q', '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'r', 'a', 'w', '5', '1', '2',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'p', 's', 'r', 'a', 'd', 'i', '5', '1', '2', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'r', 'a',
-  'q', 'i', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'i', 'a', '3', '2', '_', 'p', 's', 'r', 'a', 'q', 'i', '2', '5', '6',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'p', 's', 'r', 'a', 'q', 'i', '5', '1', '2', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'r', 'a',
-  'w', 'i', '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'i', 'a', '3', '2', '_', 'p', 's', 'r', 'a', 'v', '1', '6', 's', 'i',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'p', 's', 'r', 'a', 'v', 'q', '1', '2', '8', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'r', 'a',
-  'v', 'q', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'i', 'a', '3', '2', '_', 'p', 's', 'r', 'a', 'v', '8', 'd', 'i', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
-  'p', 's', 'r', 'a', 'v', '8', 'h', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'r', 'a', 'v', '1',
-  '6', 'h', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'p', 's', 'r', 'a', 'v', '3', '2', 'h', 'i', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p',
-  's', 'r', 'l', 'd', '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'r', 'l', 'q', '5', '1',
-  '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
-  '2', '_', 'p', 's', 'r', 'l', 'w', '5', '1', '2', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'r', 'l',
-  'd', 'i', '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'i', 'a', '3', '2', '_', 'p', 's', 'r', 'l', 'q', 'i', '5', '1', '2',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'p', 's', 'r', 'l', 'w', 'i', '5', '1', '2', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'r', 'l',
-  'v', '1', '6', 's', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'i', 'a', '3', '2', '_', 'p', 's', 'r', 'l', 'v', '8', 'd', 'i', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
-  'p', 's', 'r', 'l', 'v', '8', 'h', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'r', 'l', 'v', '1',
-  '6', 'h', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'p', 's', 'r', 'l', 'v', '3', '2', 'h', 'i', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p',
-  't', 'e', 'r', 'n', 'l', 'o', 'g', 'd', '1', '2', '8', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 't', 'e',
-  'r', 'n', 'l', 'o', 'g', 'd', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 't', 'e', 'r', 'n',
-  'l', 'o', 'g', 'd', '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 't', 'e', 'r', 'n', 'l', 'o',
-  'g', 'q', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'i', 'a', '3', '2', '_', 'p', 't', 'e', 'r', 'n', 'l', 'o', 'g', 'q',
-  '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'p', 't', 'e', 'r', 'n', 'l', 'o', 'g', 'q', '5', '1',
-  '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
-  '2', '_', 'r', 'c', 'p', '1', '4', 'p', 'd', '1', '2', '8', '_', 'm', 'a',
+  'v', 'c', 'v', 't', 'p', 's', '2', 'p', 'h', '2', '5', '6', '_', 'm', 'a',
   's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
-  '3', '2', '_', 'r', 'c', 'p', '1', '4', 'p', 'd', '2', '5', '6', '_', 'm',
-  'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'r', 'c', 'p', '1', '4', 'p', 'd', '5', '1', '2', '_',
-  'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'r', 'c', 'p', '1', '4', 'p', 's', '1', '2', '8',
+  '3', '2', '_', 'v', 'c', 'v', 't', 'p', 's', '2', 'p', 'h', '5', '1', '2',
   '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'i', 'a', '3', '2', '_', 'r', 'c', 'p', '1', '4', 'p', 's', '2', '5',
-  '6', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'i', 'a', '3', '2', '_', 'r', 'c', 'p', '1', '4', 'p', 's', '5',
-  '1', '2', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'r', 'c', 'p', '1', '4', 's', 'd',
-  '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'i', 'a', '3', '2', '_', 'r', 'c', 'p', '1', '4', 's', 's', '_', 'm',
-  'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'r', 'c', 'p', '2', '8', 'p', 'd', '_', 'm', 'a', 's',
-  'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
-  '2', '_', 'r', 'c', 'p', '2', '8', 'p', 's', '_', 'm', 'a', 's', 'k', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
-  'r', 'c', 'p', '2', '8', 's', 'd', '_', 'r', 'o', 'u', 'n', 'd', '_', 'm',
-  'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'r', 'c', 'p', '2', '8', 's', 's', '_', 'r', 'o', 'u',
-  'n', 'd', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'r', 's', 'q', 'r', 't', '1', '4',
-  'p', 'd', '1', '2', '8', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'r', 's', 'q', 'r',
-  't', '1', '4', 'p', 'd', '2', '5', '6', '_', 'm', 'a', 's', 'k', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'r',
-  's', 'q', 'r', 't', '1', '4', 'p', 'd', '5', '1', '2', '_', 'm', 'a', 's',
-  'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
-  '2', '_', 'r', 's', 'q', 'r', 't', '1', '4', 'p', 's', '1', '2', '8', '_',
-  'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'r', 's', 'q', 'r', 't', '1', '4', 'p', 's', '2',
-  '5', '6', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'r', 's', 'q', 'r', 't', '1', '4',
-  'p', 's', '5', '1', '2', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'r', 's', 'q', 'r',
-  't', '1', '4', 's', 'd', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'r', 's', 'q', 'r',
-  't', '1', '4', 's', 's', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'r', 's', 'q', 'r',
-  't', '2', '8', 'p', 'd', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'r', 's', 'q', 'r',
-  't', '2', '8', 'p', 's', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'r', 's', 'q', 'r',
-  't', '2', '8', 's', 'd', '_', 'r', 'o', 'u', 'n', 'd', '_', 'm', 'a', 's',
-  'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
-  '2', '_', 'r', 's', 'q', 'r', 't', '2', '8', 's', 's', '_', 'r', 'o', 'u',
-  'n', 'd', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 's', 'c', 'a', 't', 't', 'e', 'r',
-  'p', 'f', 'd', 'p', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'i', 'a', '3', '2', '_', 's', 'c', 'a', 't', 't', 'e', 'r', 'p', 'f',
-  'd', 'p', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 's', 'c', 'a', 't', 't', 'e', 'r', 'p', 'f', 'q', 'p',
-  'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
-  '2', '_', 's', 'c', 'a', 't', 't', 'e', 'r', 'p', 'f', 'q', 'p', 's', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
-  's', 'u', 'b', 'p', 'd', '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 's', 'u', 'b', 'p', 's', '5',
-  '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
-  '3', '2', '_', 'v', 'c', 'o', 'm', 'i', 's', 'd', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'c', 'o', 'm',
-  'i', 's', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'v', 'c', 'v', 't', 's', 'd', '2', 's', 'i', '3', '2',
+  '_', 'i', 'a', '3', '2', '_', 'f', 'i', 'x', 'u', 'p', 'i', 'm', 'm', 'p',
+  'd', '1', '2', '8', '_', 'm', 'a', 's', 'k', 'z', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'f', 'i', 'x', 'u',
+  'p', 'i', 'm', 'm', 'p', 'd', '2', '5', '6', '_', 'm', 'a', 's', 'k', 'z',
   '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'v', 'c', 'v', 't', 's', 'd', '2', 's', 'i', '6', '4', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'c',
-  'v', 't', 's', 'd', '2', 'u', 's', 'i', '3', '2', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'c', 'v', 't',
-  's', 'd', '2', 'u', 's', 'i', '6', '4', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'c', 'v', 't', 's', 's',
-  '2', 's', 'i', '3', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'i', 'a', '3', '2', '_', 'v', 'c', 'v', 't', 's', 's', '2', 's', 'i',
-  '6', '4', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
-  '3', '2', '_', 'v', 'c', 'v', 't', 's', 's', '2', 'u', 's', 'i', '3', '2',
+  '_', 'f', 'i', 'x', 'u', 'p', 'i', 'm', 'm', 'p', 'd', '5', '1', '2', '_',
+  'm', 'a', 's', 'k', 'z', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'i', 'a', '3', '2', '_', 'f', 'i', 'x', 'u', 'p', 'i', 'm', 'm', 'p',
+  's', '1', '2', '8', '_', 'm', 'a', 's', 'k', 'z', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'f', 'i', 'x', 'u',
+  'p', 'i', 'm', 'm', 'p', 's', '2', '5', '6', '_', 'm', 'a', 's', 'k', 'z',
   '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'v', 'c', 'v', 't', 's', 's', '2', 'u', 's', 'i', '6', '4', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v',
-  'p', 'd', 'p', 'b', 'u', 's', 'd', '1', '2', '8', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 'd', 'p',
-  'b', 'u', 's', 'd', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 'd', 'p', 'b', 'u', 's',
-  'd', '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'v', 'p', 'd', 'p', 'b', 'u', 's', 'd', 's', '1',
-  '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
-  '3', '2', '_', 'v', 'p', 'd', 'p', 'b', 'u', 's', 'd', 's', '2', '5', '6',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'v', 'p', 'd', 'p', 'b', 'u', 's', 'd', 's', '5', '1', '2', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v',
-  'p', 'd', 'p', 'w', 's', 's', 'd', '1', '2', '8', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 'd', 'p',
-  'w', 's', 's', 'd', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 'd', 'p', 'w', 's', 's',
-  'd', '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'v', 'p', 'd', 'p', 'w', 's', 's', 'd', 's', '1',
-  '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
-  '3', '2', '_', 'v', 'p', 'd', 'p', 'w', 's', 's', 'd', 's', '2', '5', '6',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'v', 'p', 'd', 'p', 'w', 's', 's', 'd', 's', '5', '1', '2', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v',
-  'p', 'e', 'r', 'm', 'i', '2', 'v', 'a', 'r', 'd', '1', '2', '8', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v',
-  'p', 'e', 'r', 'm', 'i', '2', 'v', 'a', 'r', 'd', '2', '5', '6', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v',
-  'p', 'e', 'r', 'm', 'i', '2', 'v', 'a', 'r', 'd', '5', '1', '2', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v',
-  'p', 'e', 'r', 'm', 'i', '2', 'v', 'a', 'r', 'h', 'i', '1', '2', '8', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
-  'v', 'p', 'e', 'r', 'm', 'i', '2', 'v', 'a', 'r', 'h', 'i', '2', '5', '6',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'v', 'p', 'e', 'r', 'm', 'i', '2', 'v', 'a', 'r', 'h', 'i', '5', '1',
-  '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
-  '2', '_', 'v', 'p', 'e', 'r', 'm', 'i', '2', 'v', 'a', 'r', 'p', 'd', '1',
-  '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
-  '3', '2', '_', 'v', 'p', 'e', 'r', 'm', 'i', '2', 'v', 'a', 'r', 'p', 'd',
-  '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'v', 'p', 'e', 'r', 'm', 'i', '2', 'v', 'a', 'r', 'p',
-  'd', '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'v', 'p', 'e', 'r', 'm', 'i', '2', 'v', 'a', 'r',
-  'p', 's', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'i', 'a', '3', '2', '_', 'v', 'p', 'e', 'r', 'm', 'i', '2', 'v', 'a',
-  'r', 'p', 's', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 'e', 'r', 'm', 'i', '2', 'v',
-  'a', 'r', 'p', 's', '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 'e', 'r', 'm', 'i', '2',
-  'v', 'a', 'r', 'q', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 'e', 'r', 'm', 'i', '2',
-  'v', 'a', 'r', 'q', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 'e', 'r', 'm', 'i', '2',
-  'v', 'a', 'r', 'q', '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 'e', 'r', 'm', 'i', '2',
-  'v', 'a', 'r', 'q', 'i', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 'e', 'r', 'm', 'i',
-  '2', 'v', 'a', 'r', 'q', 'i', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 'e', 'r', 'm',
-  'i', '2', 'v', 'a', 'r', 'q', 'i', '5', '1', '2', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 'e', 'r',
-  'm', 'i', 'l', 'v', 'a', 'r', 'p', 'd', '5', '1', '2', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 'e',
-  'r', 'm', 'i', 'l', 'v', 'a', 'r', 'p', 's', '5', '1', '2', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p',
-  'm', 'a', 'd', 'd', '5', '2', 'h', 'u', 'q', '1', '2', '8', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p',
-  'm', 'a', 'd', 'd', '5', '2', 'h', 'u', 'q', '2', '5', '6', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p',
-  'm', 'a', 'd', 'd', '5', '2', 'h', 'u', 'q', '5', '1', '2', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p',
-  'm', 'a', 'd', 'd', '5', '2', 'l', 'u', 'q', '1', '2', '8', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p',
-  'm', 'a', 'd', 'd', '5', '2', 'l', 'u', 'q', '2', '5', '6', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p',
-  'm', 'a', 'd', 'd', '5', '2', 'l', 'u', 'q', '5', '1', '2', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v',
-  't', 'n', 'e', '2', 'p', 's', '2', 'b', 'f', '1', '6', '_', '1', '2', '8',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'c', 'v', 't', 'n', 'e', '2', 'p', 's', '2', 'b', 'f', '1', '6', '_',
-  '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'c', 'v', 't', 'n', 'e', '2', 'p', 's', '2', 'b', 'f',
-  '1', '6', '_', '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't', 'n', 'e', 'p', 's', '2',
-  'b', 'f', '1', '6', '_', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't', 'n', 'e', 'p',
-  's', '2', 'b', 'f', '1', '6', '_', '5', '1', '2', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'd', 'p', 'b', 'f',
-  '1', '6', 'p', 's', '_', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'd', 'p', 'b', 'f', '1', '6',
-  'p', 's', '_', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'i', 'a', '3', '2', '_', 'd', 'p', 'b', 'f', '1', '6', 'p', 's',
-  '_', '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'b', 'e', 'x', 't', 'r', '_', 'u', '3', '2', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
-  'b', 'e', 'x', 't', 'r', '_', 'u', '6', '4', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'b', 'z', 'h', 'i', '_',
-  's', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
-  '3', '2', '_', 'b', 'z', 'h', 'i', '_', 'd', 'i', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'd', 'e', 'p',
-  '_', 's', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'p', 'd', 'e', 'p', '_', 'd', 'i', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'e', 'x',
-  't', '_', 's', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'p', 'e', 'x', 't', '_', 'd', 'i', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'l',
-  'd', 'e', 'm', 'o', 't', 'e', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'i', 'a', '3', '2', '_', 'c', 'l', 'f', 'l', 'u', 's', 'h', 'o',
-  'p', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
-  '3', '2', '_', 'c', 'l', 'r', 's', 's', 'b', 's', 'y', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'l', 'w',
-  'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
-  '2', '_', 'c', 'l', 'z', 'e', 'r', 'o', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'd', 'i', 'r', 'e', 'c', 't',
-  's', 't', 'o', 'r', 'e', '_', 'u', '3', '2', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'd', 'i', 'r', 'e', 'c',
-  't', 's', 't', 'o', 'r', 'e', '_', 'u', '6', '4', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'e', 'n', 'q', 'c',
-  'm', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
-  '3', '2', '_', 'e', 'n', 'q', 'c', 'm', 'd', 's', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'r', 'e', 'a', 'd',
-  'e', 'f', 'l', 'a', 'g', 's', '_', 'u', '3', '2', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'r', 'e', 'a', 'd',
-  'e', 'f', 'l', 'a', 'g', 's', '_', 'u', '6', '4', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'w', 'r', 'i', 't',
-  'e', 'e', 'f', 'l', 'a', 'g', 's', '_', 'u', '3', '2', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'w', 'r', 'i',
-  't', 'e', 'e', 'f', 'l', 'a', 'g', 's', '_', 'u', '6', '4', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'f', 'x',
-  'r', 's', 't', 'o', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'i', 'a', '3', '2', '_', 'f', 'x', 'r', 's', 't', 'o', 'r', '6', '4',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'f', 'x', 's', 'a', 'v', 'e', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'f', 'x', 's', 'a', 'v', 'e', '6',
-  '4', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
-  '2', '_', 'i', 'n', 'c', 's', 's', 'p', 'd', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'i', 'n', 'c', 's', 's',
-  'p', 'q', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
-  '3', '2', '_', 'i', 'n', 'v', 'p', 'c', 'i', 'd', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'l', 'l', 'w', 'p',
-  'c', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
-  '3', '2', '_', 'l', 'w', 'p', 'i', 'n', 's', '3', '2', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'l', 'w', 'p',
-  'i', 'n', 's', '6', '4', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'i', 'a', '3', '2', '_', 'l', 'w', 'p', 'v', 'a', 'l', '3', '2', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
-  'l', 'w', 'p', 'v', 'a', 'l', '6', '4', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'e', 'm', 'm', 's', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'f',
-  'e', 'm', 'm', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'm', 'a', 's', 'k', 'm', 'o', 'v', 'q', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'm',
-  'o', 'v', 'n', 't', 'q', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'i', 'a', '3', '2', '_', 'p', 'a', 'c', 'k', 's', 's', 'd', 'w', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
-  'p', 'a', 'c', 'k', 's', 's', 'w', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'a', 'c', 'k', 'u', 's',
-  'w', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
-  '3', '2', '_', 'p', 'a', 'd', 'd', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'a', 'd', 'd', 'd', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
-  'p', 'a', 'd', 'd', 'q', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'i', 'a', '3', '2', '_', 'p', 'a', 'd', 'd', 'w', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'a', 'd',
-  'd', 's', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'p', 'a', 'd', 'd', 's', 'w', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'a', 'd', 'd',
-  'u', 's', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'p', 'a', 'd', 'd', 'u', 's', 'w', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'a', 'l',
-  'i', 'g', 'n', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'p', 'a', 'n', 'd', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'a', 'n', 'd', 'n',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'p', 'a', 'v', 'g', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'i', 'a', '3', '2', '_', 'p', 'a', 'v', 'g', 'w', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'c',
-  'm', 'p', 'e', 'q', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'i', 'a', '3', '2', '_', 'p', 'c', 'm', 'p', 'e', 'q', 'd', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p',
-  'c', 'm', 'p', 'e', 'q', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'i', 'a', '3', '2', '_', 'p', 'c', 'm', 'p', 'g', 't', 'b', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
-  'p', 'c', 'm', 'p', 'g', 't', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'c', 'm', 'p', 'g', 't', 'w',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'v', 'e', 'c', '_', 'e', 'x', 't', '_', 'v', '4', 'h', 'i', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v',
-  'e', 'c', '_', 's', 'e', 't', '_', 'v', '4', 'h', 'i', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'a',
-  'd', 'd', 'w', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'p', 'm', 'a', 'x', 's', 'w', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'a',
-  'x', 'u', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'p', 'm', 'i', 'n', 's', 'w', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'i', 'n',
-  'u', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
-  '3', '2', '_', 'p', 'm', 'o', 'v', 'm', 's', 'k', 'b', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'u',
-  'l', 'h', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'p', 'm', 'u', 'l', 'h', 'u', 'w', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'u',
-  'l', 'l', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'p', 'm', 'u', 'l', 'u', 'd', 'q', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'o', 'r',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'p', 's', 'a', 'd', 'b', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'l', 'l', 'd', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p',
-  's', 'l', 'l', 'q', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'p', 's', 'l', 'l', 'w', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'l', 'l',
-  'd', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
-  '3', '2', '_', 'p', 's', 'l', 'l', 'q', 'i', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'l', 'l', 'w',
-  'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
-  '2', '_', 'p', 's', 'r', 'a', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'r', 'a', 'w', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p',
-  's', 'r', 'a', 'd', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'i', 'a', '3', '2', '_', 'p', 's', 'r', 'a', 'w', 'i', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's',
-  'r', 'l', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'p', 's', 'r', 'l', 'q', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'r', 'l', 'w',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'p', 's', 'r', 'l', 'd', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'r', 'l', 'q', 'i', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
-  'p', 's', 'r', 'l', 'w', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'u', 'b', 'b', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's',
-  'u', 'b', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'p', 's', 'u', 'b', 'q', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'u', 'b', 'w',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'p', 's', 'u', 'b', 's', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'u', 'b', 's', 'w', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
-  'p', 's', 'u', 'b', 'u', 's', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'u', 'b', 'u', 's', 'w',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'p', 'u', 'n', 'p', 'c', 'k', 'h', 'b', 'w', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'u', 'n', 'p',
-  'c', 'k', 'h', 'd', 'q', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'i', 'a', '3', '2', '_', 'p', 'u', 'n', 'p', 'c', 'k', 'h', 'w', 'd',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'p', 'u', 'n', 'p', 'c', 'k', 'l', 'b', 'w', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'u', 'n', 'p',
-  'c', 'k', 'l', 'd', 'q', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'i', 'a', '3', '2', '_', 'p', 'u', 'n', 'p', 'c', 'k', 'l', 'w', 'd',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'p', 'x', 'o', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'i', 'a', '3', '2', '_', 'm', 'o', 'n', 'i', 't', 'o', 'r', 'x', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
-  'm', 'o', 'v', 'd', 'i', 'r', '6', '4', 'b', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'm', 'w', 'a', 'i', 't',
-  'x', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
-  '2', '_', 'p', 'c', 'l', 'm', 'u', 'l', 'q', 'd', 'q', '1', '2', '8', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
-  'p', 'c', 'l', 'm', 'u', 'l', 'q', 'd', 'q', '2', '5', '6', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'c',
-  'l', 'm', 'u', 'l', 'q', 'd', 'q', '5', '1', '2', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 't', 'w', 'r',
-  'i', 't', 'e', '3', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'i', 'a', '3', '2', '_', 'p', 't', 'w', 'r', 'i', 't', 'e', '6', '4',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'r', 'd', 'f', 's', 'b', 'a', 's', 'e', '3', '2', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'r', 'd', 'f',
-  's', 'b', 'a', 's', 'e', '6', '4', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'r', 'd', 'g', 's', 'b', 'a', 's',
-  'e', '3', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'r', 'd', 'g', 's', 'b', 'a', 's', 'e', '6', '4', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
-  'r', 'd', 'p', 'i', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'i', 'a', '3', '2', '_', 'r', 'd', 'p', 'k', 'r', 'u', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'r', 'd',
-  'p', 'm', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'r', 'd', 's', 's', 'p', 'd', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'r', 'd', 's', 's',
-  'p', 'q', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
-  '3', '2', '_', 'r', 'd', 't', 's', 'c', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'r', 's', 't', 'o', 'r', 's',
-  's', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
-  '3', '2', '_', 's', 'a', 'v', 'e', 'p', 'r', 'e', 'v', 's', 's', 'p', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
-  's', 'e', 't', 's', 's', 'b', 's', 'y', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 's', 'h', 'a', '1', 'm', 's',
-  'g', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
-  '3', '2', '_', 's', 'h', 'a', '1', 'm', 's', 'g', '2', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 's', 'h', 'a',
-  '1', 'n', 'e', 'x', 't', 'e', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'i', 'a', '3', '2', '_', 's', 'h', 'a', '1', 'r', 'n', 'd', 's',
-  '4', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
-  '2', '_', 's', 'h', 'a', '2', '5', '6', 'm', 's', 'g', '1', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 's', 'h',
-  'a', '2', '5', '6', 'm', 's', 'g', '2', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 's', 'h', 'a', '2', '5', '6',
-  'r', 'n', 'd', 's', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'i', 'a', '3', '2', '_', 's', 'l', 'w', 'p', 'c', 'b', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'm',
-  'p', 's', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'c', 'o', 'm', 'i', 'e', 'q', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'o', 'm', 'i',
-  'g', 'e', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
-  '3', '2', '_', 'c', 'o', 'm', 'i', 'g', 't', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'o', 'm', 'i', 'l',
-  'e', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
-  '2', '_', 'c', 'o', 'm', 'i', 'l', 't', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'o', 'm', 'i', 'n', 'e',
-  'q', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
-  '2', '_', 'c', 'v', 't', 'p', 'd', '2', 'p', 'i', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't', 'p',
-  'i', '2', 'p', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'c', 'v', 't', 'p', 'i', '2', 'p', 's', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c',
-  'v', 't', 'p', 's', '2', 'p', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't', 's', 's', '2', 's',
-  'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
-  '2', '_', 'c', 'v', 't', 's', 's', '2', 's', 'i', '6', '4', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v',
-  't', 't', 'p', 'd', '2', 'p', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't', 't', 'p', 's', '2',
-  'p', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
-  '3', '2', '_', 'c', 'v', 't', 't', 's', 's', '2', 's', 'i', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v',
-  't', 't', 's', 's', '2', 's', 'i', '6', '4', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'm', 'a', 'x', 'p', 's',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'm', 'a', 'x', 's', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'i', 'a', '3', '2', '_', 'm', 'i', 'n', 'p', 's', '\000', '_', '_',
+  '_', 'f', 'i', 'x', 'u', 'p', 'i', 'm', 'm', 'p', 's', '5', '1', '2', '_',
+  'm', 'a', 's', 'k', 'z', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'i', 'a', '3', '2', '_', 'f', 'i', 'x', 'u', 'p', 'i', 'm', 'm', 's',
+  'd', '_', 'm', 'a', 's', 'k', 'z', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'f', 'i', 'x', 'u', 'p', 'i', 'm',
+  'm', 's', 's', '_', 'm', 'a', 's', 'k', 'z', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'm', 'a', 'x', 'p', 'd',
+  '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
+  'a', '3', '2', '_', 'm', 'a', 'x', 'p', 's', '5', '1', '2', '\000', '_', '_',
   'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'm', 'i',
-  'n', 's', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'm', 'o', 'v', 'm', 's', 'k', 'p', 's', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's',
-  'h', 'u', 'f', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'r', 'c', 'p', 'p', 's', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'r', 'c', 'p', 's',
-  's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
-  '2', '_', 'r', 's', 'q', 'r', 't', 'p', 's', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'r', 's', 'q', 'r', 't',
-  's', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
-  '3', '2', '_', 's', 'f', 'e', 'n', 'c', 'e', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'u', 'c', 'o', 'm', 'i',
-  'e', 'q', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
-  '3', '2', '_', 'u', 'c', 'o', 'm', 'i', 'g', 'e', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'u', 'c', 'o', 'm',
-  'i', 'g', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'u', 'c', 'o', 'm', 'i', 'l', 'e', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'u', 'c', 'o',
-  'm', 'i', 'l', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'u', 'c', 'o', 'm', 'i', 'n', 'e', 'q', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c',
-  'l', 'f', 'l', 'u', 's', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'i', 'a', '3', '2', '_', 'c', 'm', 'p', 's', 'd', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'o',
-  'm', 'i', 's', 'd', 'e', 'q', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'i', 'a', '3', '2', '_', 'c', 'o', 'm', 'i', 's', 'd', 'g', 'e',
+  'n', 'p', 'd', '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'm', 'i', 'n', 'p', 's', '5', '1', '2',
   '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'c', 'o', 'm', 'i', 's', 'd', 'g', 't', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'o', 'm', 'i', 's',
-  'd', 'l', 'e', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'c', 'o', 'm', 'i', 's', 'd', 'l', 't', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'o',
-  'm', 'i', 's', 'd', 'n', 'e', 'q', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't', 'p', 'd', '2', 'd',
-  'q', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
-  '2', '_', 'c', 'v', 't', 'p', 'd', '2', 'p', 's', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't', 'p',
-  's', '2', 'd', 'q', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'c', 'v', 't', 's', 'd', '2', 's', 'i', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c',
-  'v', 't', 's', 'd', '2', 's', 'i', '6', '4', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't', 's', 'd',
-  '2', 's', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'c', 'v', 't', 't', 'p', 'd', '2', 'd', 'q', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c',
-  'v', 't', 't', 'p', 's', '2', 'd', 'q', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't', 't', 's', 'd',
-  '2', 's', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'c', 'v', 't', 't', 's', 'd', '2', 's', 'i', '6', '4',
+  '_', 'm', 'u', 'l', 'p', 'd', '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'm', 'u', 'l', 'p', 's',
+  '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
+  'a', '3', '2', '_', 'p', 'a', 'c', 'k', 's', 's', 'd', 'w', '5', '1', '2',
   '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'l', 'f', 'e', 'n', 'c', 'e', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'm', 'a', 's', 'k', 'm', 'o', 'v',
-  'd', 'q', 'u', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'm', 'a', 'x', 'p', 'd', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'm', 'a', 'x', 's', 'd',
+  '_', 'p', 'a', 'c', 'k', 's', 's', 'w', 'b', '5', '1', '2', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'a',
+  'c', 'k', 'u', 's', 'd', 'w', '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'a', 'c', 'k', 'u',
+  's', 'w', 'b', '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'p', 'a', 'v', 'g', 'b', '5', '1', '2',
   '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'm', 'f', 'e', 'n', 'c', 'e', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'm', 'i', 'n', 'p', 'd', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'm',
-  'i', 'n', 's', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'm', 'o', 'v', 'm', 's', 'k', 'p', 'd', '\000', '_',
+  '_', 'p', 'a', 'v', 'g', 'w', '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'e', 'r', 'm', 'v',
+  'a', 'r', 'd', 'f', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'e', 'r', 'm', 'v', 'a', 'r',
+  'd', 'f', '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'i', 'a', '3', '2', '_', 'p', 'e', 'r', 'm', 'v', 'a', 'r', 'd', 'i',
+  '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
+  'a', '3', '2', '_', 'p', 'e', 'r', 'm', 'v', 'a', 'r', 'd', 'i', '5', '1',
+  '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
+  '2', '_', 'p', 'e', 'r', 'm', 'v', 'a', 'r', 'h', 'i', '1', '2', '8', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
+  'p', 'e', 'r', 'm', 'v', 'a', 'r', 'h', 'i', '2', '5', '6', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'e',
+  'r', 'm', 'v', 'a', 'r', 'h', 'i', '5', '1', '2', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'e', 'r', 'm',
+  'v', 'a', 'r', 'q', 'i', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'e', 'r', 'm', 'v', 'a',
+  'r', 'q', 'i', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'p', 'e', 'r', 'm', 'v', 'a', 'r', 'q',
+  'i', '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'i', 'a', '3', '2', '_', 'p', 'e', 'r', 'm', 'v', 'a', 'r', 's', 'f', '5',
+  '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
+  '3', '2', '_', 'p', 'e', 'r', 'm', 'v', 'a', 'r', 's', 'i', '5', '1', '2',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
+  '_', 'p', 'm', 'a', 'd', 'd', 'u', 'b', 's', 'w', '5', '1', '2', '\000', '_',
   '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p',
-  'a', 'c', 'k', 's', 's', 'd', 'w', '1', '2', '8', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'a', 'c', 'k',
-  's', 's', 'w', 'b', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'a', 'c', 'k', 'u', 's', 'w',
-  'b', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'p', 'a', 'u', 's', 'e', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'a', 'v', 'g',
-  'b', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'p', 'a', 'v', 'g', 'w', '1', '2', '8', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p',
-  'm', 'a', 'd', 'd', 'w', 'd', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 'm',
-  's', 'k', 'b', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'u', 'l', 'h', 'w', '1', '2',
-  '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
-  '2', '_', 'p', 'm', 'u', 'l', 'h', 'u', 'w', '1', '2', '8', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's',
-  'a', 'd', 'b', 'w', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'l', 'l', 'd', '1', '2',
-  '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
-  '2', '_', 'p', 's', 'l', 'l', 'q', '1', '2', '8', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'l', 'l',
-  'w', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'p', 's', 'l', 'l', 'd', 'i', '1', '2', '8', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
-  'p', 's', 'l', 'l', 'q', 'i', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'l', 'l', 'w',
-  'i', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'p', 's', 'r', 'a', 'd', '1', '2', '8', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p',
-  's', 'r', 'a', 'w', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'r', 'a', 'd', 'i', '1',
-  '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
-  '3', '2', '_', 'p', 's', 'r', 'a', 'w', 'i', '1', '2', '8', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's',
-  'r', 'l', 'd', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'r', 'l', 'q', '1', '2', '8',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'p', 's', 'r', 'l', 'w', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'r', 'l', 'd',
-  'i', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'p', 's', 'r', 'l', 'q', 'i', '1', '2', '8', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
-  'p', 's', 'r', 'l', 'w', 'i', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'u', 'c', 'o', 'm', 'i',
-  's', 'd', 'e', 'q', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'u', 'c', 'o', 'm', 'i', 's', 'd', 'g', 'e', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
-  'u', 'c', 'o', 'm', 'i', 's', 'd', 'g', 't', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'u', 'c', 'o', 'm', 'i',
-  's', 'd', 'l', 'e', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'u', 'c', 'o', 'm', 'i', 's', 'd', 'l', 't', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
-  'u', 'c', 'o', 'm', 'i', 's', 'd', 'n', 'e', 'q', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'a', 'd', 'd', 's',
-  'u', 'b', 'p', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'a', 'd', 'd', 's', 'u', 'b', 'p', 's', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'h',
-  'a', 'd', 'd', 'p', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'i', 'a', '3', '2', '_', 'h', 'a', 'd', 'd', 'p', 's', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'h', 's',
-  'u', 'b', 'p', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'h', 's', 'u', 'b', 'p', 's', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'l', 'd', 'd',
-  'q', 'u', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
-  '3', '2', '_', 'm', 'o', 'n', 'i', 't', 'o', 'r', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'm', 'w', 'a', 'i',
-  't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
-  '2', '_', 'b', 'l', 'e', 'n', 'd', 'v', 'p', 'd', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'b', 'l', 'e', 'n',
-  'd', 'v', 'p', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'd', 'p', 'p', 'd', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'd', 'p', 'p', 's', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
-  'i', 'n', 's', 'e', 'r', 't', 'p', 's', '1', '2', '8', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'm', 'p', 's',
-  'a', 'd', 'b', 'w', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'a', 'c', 'k', 'u', 's', 'd',
-  'w', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'p', 'b', 'l', 'e', 'n', 'd', 'v', 'b', '1', '2',
-  '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
-  '2', '_', 'p', 'h', 'm', 'i', 'n', 'p', 'o', 's', 'u', 'w', '1', '2', '8',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'p', 't', 'e', 's', 't', 'c', '1', '2', '8', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 't', 'e', 's',
-  't', 'n', 'z', 'c', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 't', 'e', 's', 't', 'z', '1',
-  '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
-  '3', '2', '_', 'r', 'o', 'u', 'n', 'd', 'p', 'd', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'r', 'o', 'u', 'n',
-  'd', 'p', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'r', 'o', 'u', 'n', 'd', 's', 'd', '\000', '_', '_', 'b',
-  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'r', 'o', 'u',
-  'n', 'd', 's', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'c', 'r', 'c', '3', '2', 'h', 'i', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'r',
-  'c', '3', '2', 's', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'i', 'a', '3', '2', '_', 'c', 'r', 'c', '3', '2', 'q', 'i', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c',
-  'r', 'c', '3', '2', 'd', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'i', 'a', '3', '2', '_', 'p', 'c', 'm', 'p', 'e', 's', 't', 'r',
-  'i', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'p', 'c', 'm', 'p', 'e', 's', 't', 'r', 'i', 'a',
-  '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'p', 'c', 'm', 'p', 'e', 's', 't', 'r', 'i', 'c', '1',
-  '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
-  '3', '2', '_', 'p', 'c', 'm', 'p', 'e', 's', 't', 'r', 'i', 'o', '1', '2',
-  '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
-  '2', '_', 'p', 'c', 'm', 'p', 'e', 's', 't', 'r', 'i', 's', '1', '2', '8',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'p', 'c', 'm', 'p', 'e', 's', 't', 'r', 'i', 'z', '1', '2', '8', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
-  'p', 'c', 'm', 'p', 'e', 's', 't', 'r', 'm', '1', '2', '8', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'c',
-  'm', 'p', 'i', 's', 't', 'r', 'i', '1', '2', '8', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'c', 'm', 'p',
-  'i', 's', 't', 'r', 'i', 'a', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'c', 'm', 'p', 'i',
-  's', 't', 'r', 'i', 'c', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'c', 'm', 'p', 'i', 's',
-  't', 'r', 'i', 'o', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'c', 'm', 'p', 'i', 's', 't',
-  'r', 'i', 's', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'i', 'a', '3', '2', '_', 'p', 'c', 'm', 'p', 'i', 's', 't', 'r',
-  'i', 'z', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'i', 'a', '3', '2', '_', 'p', 'c', 'm', 'p', 'i', 's', 't', 'r', 'm',
-  '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'e', 'x', 't', 'r', 'q', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'e', 'x', 't', 'r', 'q',
-  'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
-  '2', '_', 'i', 'n', 's', 'e', 'r', 't', 'q', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'i', 'n', 's', 'e', 'r',
-  't', 'q', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'p', 'a', 'b', 's', 'b', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'a', 'b', 's', 'd',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'p', 'a', 'b', 's', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'i', 'a', '3', '2', '_', 'p', 'h', 'a', 'd', 'd', 'd', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p',
-  'h', 'a', 'd', 'd', 'd', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'h', 'a', 'd', 'd', 's',
-  'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
-  '2', '_', 'p', 'h', 'a', 'd', 'd', 's', 'w', '1', '2', '8', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'h',
-  'a', 'd', 'd', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'p', 'h', 'a', 'd', 'd', 'w', '1', '2', '8', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
-  'p', 'h', 's', 'u', 'b', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'i', 'a', '3', '2', '_', 'p', 'h', 's', 'u', 'b', 'd', '1', '2',
-  '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
-  '2', '_', 'p', 'h', 's', 'u', 'b', 's', 'w', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'h', 's', 'u', 'b',
-  's', 'w', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
-  '_', 'i', 'a', '3', '2', '_', 'p', 'h', 's', 'u', 'b', 'w', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'h',
-  's', 'u', 'b', 'w', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'a', 'd', 'd', 'u', 'b',
-  's', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
-  '3', '2', '_', 'p', 'm', 'a', 'd', 'd', 'u', 'b', 's', 'w', '1', '2', '8',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'p', 'm', 'u', 'l', 'h', 'r', 's', 'w', '\000', '_', '_', 'b', 'u', 'i',
+  'm', 'a', 'd', 'd', 'w', 'd', '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i',
   'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'u', 'l', 'h',
-  'r', 's', 'w', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'h', 'u', 'f', 'b', '\000', '_',
+  'r', 's', 'w', '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'u', 'l', 'h', 'w', '5', '1',
+  '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
+  '2', '_', 'p', 'm', 'u', 'l', 'h', 'u', 'w', '5', '1', '2', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p',
+  'm', 'u', 'l', 't', 'i', 's', 'h', 'i', 'f', 't', 'q', 'b', '1', '2', '8',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
+  '_', 'v', 'p', 'm', 'u', 'l', 't', 'i', 's', 'h', 'i', 'f', 't', 'q', 'b',
+  '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
+  'a', '3', '2', '_', 'v', 'p', 'm', 'u', 'l', 't', 'i', 's', 'h', 'i', 'f',
+  't', 'q', 'b', '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'a', 'd', 'b', 'w', '5', '1',
+  '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
+  '2', '_', 'p', 's', 'h', 'u', 'f', 'b', '5', '1', '2', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'l',
+  'l', 'd', '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'i', 'a', '3', '2', '_', 'p', 's', 'l', 'l', 'q', '5', '1', '2', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
+  'p', 's', 'l', 'l', 'w', '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'l', 'l', 'd', 'i',
+  '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
+  'a', '3', '2', '_', 'p', 's', 'l', 'l', 'q', 'i', '5', '1', '2', '\000', '_',
   '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p',
-  's', 'h', 'u', 'f', 'b', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'i', 'g', 'n', 'b',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'p', 's', 'i', 'g', 'n', 'b', '1', '2', '8', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'i', 'g',
-  'n', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
-  '3', '2', '_', 'p', 's', 'i', 'g', 'n', 'd', '1', '2', '8', '\000', '_', '_',
+  's', 'l', 'l', 'w', 'i', '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'l', 'l', 'v', '1',
+  '6', 's', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
+  'a', '3', '2', '_', 'p', 's', 'l', 'l', 'v', '8', 'd', 'i', '\000', '_', '_',
   'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's',
-  'i', 'g', 'n', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'p', 's', 'i', 'g', 'n', 'w', '1', '2', '8', '\000',
+  'l', 'l', 'v', '8', 'h', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'l', 'l', 'v', '1', '6', 'h',
+  'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
+  '2', '_', 'p', 's', 'l', 'l', 'v', '3', '2', 'h', 'i', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'r',
+  'a', 'd', '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'i', 'a', '3', '2', '_', 'p', 's', 'r', 'a', 'q', '1', '2', '8', '\000',
   '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
-  'b', 'e', 'x', 't', 'r', 'i', '_', 'u', '3', '2', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'b', 'e', 'x', 't',
-  'r', 'i', '_', 'u', '6', '4', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'i', 'a', '3', '2', '_', 't', 'p', 'a', 'u', 's', 'e', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'u',
-  'm', 'o', 'n', 'i', 't', 'o', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'u', 'm', 'w', 'a', 'i', 't', '\000',
+  'p', 's', 'r', 'a', 'q', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'r', 'a', 'q', '5',
+  '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
+  '3', '2', '_', 'p', 's', 'r', 'a', 'w', '5', '1', '2', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'r',
+  'a', 'd', 'i', '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'r', 'a', 'q', 'i', '1', '2',
+  '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
+  '2', '_', 'p', 's', 'r', 'a', 'q', 'i', '2', '5', '6', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'r',
+  'a', 'q', 'i', '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'r', 'a', 'w', 'i', '5', '1',
+  '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
+  '2', '_', 'p', 's', 'r', 'a', 'v', '1', '6', 's', 'i', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'r',
+  'a', 'v', 'q', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'r', 'a', 'v', 'q', '2', '5',
+  '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
+  '2', '_', 'p', 's', 'r', 'a', 'v', '8', 'd', 'i', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'r', 'a',
+  'v', '8', 'h', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'i', 'a', '3', '2', '_', 'p', 's', 'r', 'a', 'v', '1', '6', 'h', 'i', '\000',
   '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
-  'v', 'c', 'v', 't', 'p', 'h', '2', 'p', 's', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'c', 'v', 't', 'p',
-  'h', '2', 'p', 's', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'c', 'v', 't', 'p', 's', '2',
-  'p', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
-  '3', '2', '_', 'v', 'c', 'v', 't', 'p', 's', '2', 'p', 'h', '2', '5', '6',
+  'p', 's', 'r', 'a', 'v', '3', '2', 'h', 'i', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'r', 'l', 'd',
+  '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
+  'a', '3', '2', '_', 'p', 's', 'r', 'l', 'q', '5', '1', '2', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's',
+  'r', 'l', 'w', '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'r', 'l', 'd', 'i', '5', '1',
+  '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
+  '2', '_', 'p', 's', 'r', 'l', 'q', 'i', '5', '1', '2', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'r',
+  'l', 'w', 'i', '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'r', 'l', 'v', '1', '6', 's',
+  'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
+  '2', '_', 'p', 's', 'r', 'l', 'v', '8', 'd', 'i', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'r', 'l',
+  'v', '8', 'h', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'i', 'a', '3', '2', '_', 'p', 's', 'r', 'l', 'v', '1', '6', 'h', 'i', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
+  'p', 's', 'r', 'l', 'v', '3', '2', 'h', 'i', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 't', 'e', 'r', 'n',
+  'l', 'o', 'g', 'd', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 't', 'e', 'r', 'n', 'l', 'o',
+  'g', 'd', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'i', 'a', '3', '2', '_', 'p', 't', 'e', 'r', 'n', 'l', 'o', 'g', 'd',
+  '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
+  'a', '3', '2', '_', 'p', 't', 'e', 'r', 'n', 'l', 'o', 'g', 'q', '1', '2',
+  '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
+  '2', '_', 'p', 't', 'e', 'r', 'n', 'l', 'o', 'g', 'q', '2', '5', '6', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
+  'p', 't', 'e', 'r', 'n', 'l', 'o', 'g', 'q', '5', '1', '2', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'r', 'c',
+  'p', '1', '4', 'p', 'd', '1', '2', '8', '_', 'm', 'a', 's', 'k', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'r',
+  'c', 'p', '1', '4', 'p', 'd', '2', '5', '6', '_', 'm', 'a', 's', 'k', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
+  'r', 'c', 'p', '1', '4', 'p', 'd', '5', '1', '2', '_', 'm', 'a', 's', 'k',
   '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'v', 'g', 'f', '2', 'p', '8', 'a', 'f', 'f', 'i', 'n', 'e', 'i', 'n',
-  'v', 'q', 'b', '_', 'v', '1', '6', 'q', 'i', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'g', 'f', '2', 'p',
-  '8', 'a', 'f', 'f', 'i', 'n', 'e', 'i', 'n', 'v', 'q', 'b', '_', 'v', '3',
-  '2', 'q', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'v', 'g', 'f', '2', 'p', '8', 'a', 'f', 'f', 'i', 'n',
-  'e', 'i', 'n', 'v', 'q', 'b', '_', 'v', '6', '4', 'q', 'i', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'g',
-  'f', '2', 'p', '8', 'a', 'f', 'f', 'i', 'n', 'e', 'q', 'b', '_', 'v', '1',
-  '6', 'q', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'v', 'g', 'f', '2', 'p', '8', 'a', 'f', 'f', 'i', 'n',
-  'e', 'q', 'b', '_', 'v', '3', '2', 'q', 'i', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'g', 'f', '2', 'p',
-  '8', 'a', 'f', 'f', 'i', 'n', 'e', 'q', 'b', '_', 'v', '6', '4', 'q', 'i',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'v', 'g', 'f', '2', 'p', '8', 'm', 'u', 'l', 'b', '_', 'v', '1', '6',
-  'q', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
-  '3', '2', '_', 'v', 'g', 'f', '2', 'p', '8', 'm', 'u', 'l', 'b', '_', 'v',
-  '3', '2', 'q', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'v', 'g', 'f', '2', 'p', '8', 'm', 'u', 'l', 'b',
-  '_', 'v', '6', '4', 'q', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'i', 'a', '3', '2', '_', 'w', 'b', 'i', 'n', 'v', 'd', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'w',
-  'b', 'n', 'o', 'i', 'n', 'v', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'w', 'r', 'f', 's', 'b', 'a', 's',
-  'e', '3', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'w', 'r', 'f', 's', 'b', 'a', 's', 'e', '6', '4', '\000',
+  '_', 'r', 'c', 'p', '1', '4', 'p', 's', '1', '2', '8', '_', 'm', 'a', 's',
+  'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
+  '2', '_', 'r', 'c', 'p', '1', '4', 'p', 's', '2', '5', '6', '_', 'm', 'a',
+  's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
+  '3', '2', '_', 'r', 'c', 'p', '1', '4', 'p', 's', '5', '1', '2', '_', 'm',
+  'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
+  'a', '3', '2', '_', 'r', 'c', 'p', '1', '4', 's', 'd', '_', 'm', 'a', 's',
+  'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
+  '2', '_', 'r', 'c', 'p', '1', '4', 's', 's', '_', 'm', 'a', 's', 'k', '\000',
   '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
-  'w', 'r', 'g', 's', 'b', 'a', 's', 'e', '3', '2', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'w', 'r', 'g', 's',
-  'b', 'a', 's', 'e', '6', '4', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'i', 'a', '3', '2', '_', 'w', 'r', 'p', 'k', 'r', 'u', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'w',
-  'r', 's', 's', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'w', 'r', 's', 's', 'q', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'w', 'r', 'u', 's',
-  's', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
-  '3', '2', '_', 'w', 'r', 'u', 's', 's', 'q', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'x', 'a', 'b', 'o', 'r',
-  't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
-  '2', '_', 'x', 'b', 'e', 'g', 'i', 'n', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'x', 'e', 'n', 'd', '\000', '_',
+  'r', 'c', 'p', '2', '8', 'p', 'd', '_', 'm', 'a', 's', 'k', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'r', 'c',
+  'p', '2', '8', 'p', 's', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'r', 'c', 'p', '2',
+  '8', 's', 'd', '_', 'r', 'o', 'u', 'n', 'd', '_', 'm', 'a', 's', 'k', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
+  'r', 'c', 'p', '2', '8', 's', 's', '_', 'r', 'o', 'u', 'n', 'd', '_', 'm',
+  'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
+  'a', '3', '2', '_', 'r', 's', 'q', 'r', 't', '1', '4', 'p', 'd', '1', '2',
+  '8', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'r', 's', 'q', 'r', 't', '1', '4', 'p',
+  'd', '2', '5', '6', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'r', 's', 'q', 'r', 't',
+  '1', '4', 'p', 'd', '5', '1', '2', '_', 'm', 'a', 's', 'k', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'r', 's',
+  'q', 'r', 't', '1', '4', 'p', 's', '1', '2', '8', '_', 'm', 'a', 's', 'k',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
+  '_', 'r', 's', 'q', 'r', 't', '1', '4', 'p', 's', '2', '5', '6', '_', 'm',
+  'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
+  'a', '3', '2', '_', 'r', 's', 'q', 'r', 't', '1', '4', 'p', 's', '5', '1',
+  '2', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'r', 's', 'q', 'r', 't', '1', '4', 's',
+  'd', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'r', 's', 'q', 'r', 't', '1', '4', 's',
+  's', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'r', 's', 'q', 'r', 't', '2', '8', 'p',
+  'd', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'r', 's', 'q', 'r', 't', '2', '8', 'p',
+  's', '_', 'm', 'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'r', 's', 'q', 'r', 't', '2', '8', 's',
+  'd', '_', 'r', 'o', 'u', 'n', 'd', '_', 'm', 'a', 's', 'k', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'r', 's',
+  'q', 'r', 't', '2', '8', 's', 's', '_', 'r', 'o', 'u', 'n', 'd', '_', 'm',
+  'a', 's', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
+  'a', '3', '2', '_', 's', 'c', 'a', 't', 't', 'e', 'r', 'p', 'f', 'd', 'p',
+  'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
+  '2', '_', 's', 'c', 'a', 't', 't', 'e', 'r', 'p', 'f', 'd', 'p', 's', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
+  's', 'c', 'a', 't', 't', 'e', 'r', 'p', 'f', 'q', 'p', 'd', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 's', 'c',
+  'a', 't', 't', 'e', 'r', 'p', 'f', 'q', 'p', 's', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 's', 'u', 'b', 'p',
+  'd', '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'i', 'a', '3', '2', '_', 's', 'u', 'b', 'p', 's', '5', '1', '2', '\000', '_',
   '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v',
-  'f', 'r', 'c', 'z', 'p', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'i', 'a', '3', '2', '_', 'v', 'f', 'r', 'c', 'z', 'p', 'd', '2',
-  '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
-  '3', '2', '_', 'v', 'f', 'r', 'c', 'z', 'p', 's', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'f', 'r', 'c',
-  'z', 'p', 's', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'i', 'a', '3', '2', '_', 'v', 'f', 'r', 'c', 'z', 's', 'd', '\000',
+  'c', 'o', 'm', 'i', 's', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'v', 'c', 'o', 'm', 'i', 's', 's', '\000',
   '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
-  'v', 'f', 'r', 'c', 'z', 's', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'v', 'c', 'v', 't', 's', 'd', '2', 's', 'i', '3', '2', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'c', 'v',
+  't', 's', 'd', '2', 's', 'i', '6', '4', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'c', 'v', 't', 's', 'd',
+  '2', 'u', 's', 'i', '3', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'v', 'c', 'v', 't', 's', 'd', '2', 'u',
+  's', 'i', '6', '4', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'i', 'a', '3', '2', '_', 'v', 'c', 'v', 't', 's', 's', '2', 's', 'i', '3',
+  '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
+  '2', '_', 'v', 'c', 'v', 't', 's', 's', '2', 's', 'i', '6', '4', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v',
+  'c', 'v', 't', 's', 's', '2', 'u', 's', 'i', '3', '2', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'c', 'v',
+  't', 's', 's', '2', 'u', 's', 'i', '6', '4', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 'd', 'p', 'b',
+  'u', 's', 'd', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 'd', 'p', 'b', 'u', 's', 'd',
+  '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
+  'a', '3', '2', '_', 'v', 'p', 'd', 'p', 'b', 'u', 's', 'd', '5', '1', '2',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
+  '_', 'v', 'p', 'd', 'p', 'b', 'u', 's', 'd', 's', '1', '2', '8', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v',
+  'p', 'd', 'p', 'b', 'u', 's', 'd', 's', '2', '5', '6', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 'd',
+  'p', 'b', 'u', 's', 'd', 's', '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 'd', 'p', 'w',
+  's', 's', 'd', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 'd', 'p', 'w', 's', 's', 'd',
+  '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
+  'a', '3', '2', '_', 'v', 'p', 'd', 'p', 'w', 's', 's', 'd', '5', '1', '2',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
+  '_', 'v', 'p', 'd', 'p', 'w', 's', 's', 'd', 's', '1', '2', '8', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v',
+  'p', 'd', 'p', 'w', 's', 's', 'd', 's', '2', '5', '6', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 'd',
+  'p', 'w', 's', 's', 'd', 's', '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 'e', 'r', 'm',
+  'i', '2', 'v', 'a', 'r', 'd', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 'e', 'r', 'm',
+  'i', '2', 'v', 'a', 'r', 'd', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 'e', 'r', 'm',
+  'i', '2', 'v', 'a', 'r', 'd', '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 'e', 'r', 'm',
+  'i', '2', 'v', 'a', 'r', 'h', 'i', '1', '2', '8', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 'e', 'r',
+  'm', 'i', '2', 'v', 'a', 'r', 'h', 'i', '2', '5', '6', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 'e',
+  'r', 'm', 'i', '2', 'v', 'a', 'r', 'h', 'i', '5', '1', '2', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p',
+  'e', 'r', 'm', 'i', '2', 'v', 'a', 'r', 'p', 'd', '1', '2', '8', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v',
+  'p', 'e', 'r', 'm', 'i', '2', 'v', 'a', 'r', 'p', 'd', '2', '5', '6', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
+  'v', 'p', 'e', 'r', 'm', 'i', '2', 'v', 'a', 'r', 'p', 'd', '5', '1', '2',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
+  '_', 'v', 'p', 'e', 'r', 'm', 'i', '2', 'v', 'a', 'r', 'p', 's', '1', '2',
+  '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
+  '2', '_', 'v', 'p', 'e', 'r', 'm', 'i', '2', 'v', 'a', 'r', 'p', 's', '2',
+  '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
+  '3', '2', '_', 'v', 'p', 'e', 'r', 'm', 'i', '2', 'v', 'a', 'r', 'p', 's',
+  '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
+  'a', '3', '2', '_', 'v', 'p', 'e', 'r', 'm', 'i', '2', 'v', 'a', 'r', 'q',
+  '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
+  'a', '3', '2', '_', 'v', 'p', 'e', 'r', 'm', 'i', '2', 'v', 'a', 'r', 'q',
+  '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
+  'a', '3', '2', '_', 'v', 'p', 'e', 'r', 'm', 'i', '2', 'v', 'a', 'r', 'q',
+  '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
+  'a', '3', '2', '_', 'v', 'p', 'e', 'r', 'm', 'i', '2', 'v', 'a', 'r', 'q',
+  'i', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'i', 'a', '3', '2', '_', 'v', 'p', 'e', 'r', 'm', 'i', '2', 'v', 'a', 'r',
+  'q', 'i', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'i', 'a', '3', '2', '_', 'v', 'p', 'e', 'r', 'm', 'i', '2', 'v', 'a',
+  'r', 'q', 'i', '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 'e', 'r', 'm', 'i', 'l', 'v',
+  'a', 'r', 'p', 'd', '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
   'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 'e', 'r', 'm', 'i', 'l',
-  '2', 'p', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'v', 'p', 'e', 'r', 'm', 'i', 'l', '2', 'p', 'd', '2',
+  'v', 'a', 'r', 'p', 's', '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 'm', 'a', 'd', 'd',
+  '5', '2', 'h', 'u', 'q', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 'm', 'a', 'd', 'd',
+  '5', '2', 'h', 'u', 'q', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 'm', 'a', 'd', 'd',
+  '5', '2', 'h', 'u', 'q', '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 'm', 'a', 'd', 'd',
+  '5', '2', 'l', 'u', 'q', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 'm', 'a', 'd', 'd',
+  '5', '2', 'l', 'u', 'q', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 'm', 'a', 'd', 'd',
+  '5', '2', 'l', 'u', 'q', '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't', 'n', 'e', '2',
+  'p', 's', '2', 'b', 'f', '1', '6', '_', '1', '2', '8', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't',
+  'n', 'e', '2', 'p', 's', '2', 'b', 'f', '1', '6', '_', '2', '5', '6', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
+  'c', 'v', 't', 'n', 'e', '2', 'p', 's', '2', 'b', 'f', '1', '6', '_', '5',
+  '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
+  '3', '2', '_', 'c', 'v', 't', 'n', 'e', 'p', 's', '2', 'b', 'f', '1', '6',
+  '_', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'i', 'a', '3', '2', '_', 'c', 'v', 't', 'n', 'e', 'p', 's', '2', 'b', 'f',
+  '1', '6', '_', '5', '1', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'd', 'p', 'b', 'f', '1', '6', 'p', 's',
+  '_', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'i', 'a', '3', '2', '_', 'd', 'p', 'b', 'f', '1', '6', 'p', 's', '_', '2',
   '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
-  '3', '2', '_', 'v', 'p', 'e', 'r', 'm', 'i', 'l', '2', 'p', 's', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v',
-  'p', 'e', 'r', 'm', 'i', 'l', '2', 'p', 's', '2', '5', '6', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p',
-  'h', 'a', 'd', 'd', 'b', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 'h', 'a', 'd', 'd', 'b', 'q',
+  '3', '2', '_', 'd', 'p', 'b', 'f', '1', '6', 'p', 's', '_', '5', '1', '2',
   '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'v', 'p', 'h', 'a', 'd', 'd', 'b', 'w', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 'h', 'a', 'd',
-  'd', 'd', 'q', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'v', 'p', 'h', 'a', 'd', 'd', 'u', 'b', 'd', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v',
-  'p', 'h', 'a', 'd', 'd', 'u', 'b', 'q', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 'h', 'a', 'd', 'd',
-  'u', 'b', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'v', 'p', 'h', 'a', 'd', 'd', 'u', 'd', 'q', '\000', '_',
-  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v',
-  'p', 'h', 'a', 'd', 'd', 'u', 'w', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 'h', 'a', 'd', 'd',
-  'u', 'w', 'q', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'v', 'p', 'h', 'a', 'd', 'd', 'w', 'd', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p',
-  'h', 'a', 'd', 'd', 'w', 'q', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 'h', 's', 'u', 'b', 'b', 'w',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'v', 'p', 'h', 's', 'u', 'b', 'd', 'q', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 'h', 's', 'u',
-  'b', 'w', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'v', 'p', 'm', 'a', 'c', 's', 'd', 'd', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p',
-  'm', 'a', 'c', 's', 'd', 'q', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 'm', 'a', 'c', 's', 'd',
-  'q', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
-  '3', '2', '_', 'v', 'p', 'm', 'a', 'c', 's', 's', 'd', 'd', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p',
-  'm', 'a', 'c', 's', 's', 'd', 'q', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 'm', 'a', 'c', 's',
-  's', 'd', 'q', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
-  'i', 'a', '3', '2', '_', 'v', 'p', 'm', 'a', 'c', 's', 's', 'w', 'd', '\000',
+  '_', 'b', 'e', 'x', 't', 'r', '_', 'u', '3', '2', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'b', 'e', 'x', 't',
+  'r', '_', 'u', '6', '4', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'i', 'a', '3', '2', '_', 'b', 'z', 'h', 'i', '_', 's', 'i', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'b',
+  'z', 'h', 'i', '_', 'd', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'p', 'd', 'e', 'p', '_', 's', 'i', '\000',
   '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
-  'v', 'p', 'm', 'a', 'c', 's', 's', 'w', 'w', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 'm', 'a', 'c',
-  's', 'w', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'v', 'p', 'm', 'a', 'c', 's', 'w', 'w', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p',
-  'm', 'a', 'd', 'c', 's', 's', 'w', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 'm', 'a', 'd', 'c',
-  's', 'w', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
-  'a', '3', '2', '_', 'v', 'p', 'p', 'e', 'r', 'm', '\000', '_', '_', 'b', 'u',
-  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 's', 'h',
-  'a', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
-  '3', '2', '_', 'v', 'p', 's', 'h', 'a', 'd', '\000', '_', '_', 'b', 'u', 'i',
-  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 's', 'h', 'a',
+  'p', 'd', 'e', 'p', '_', 'd', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'e', 'x', 't', '_', 's', 'i',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
+  '_', 'p', 'e', 'x', 't', '_', 'd', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'l', 'd', 'e', 'm', 'o',
+  't', 'e', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
+  '3', '2', '_', 'c', 'l', 'f', 'l', 'u', 's', 'h', 'o', 'p', 't', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c',
+  'l', 'r', 's', 's', 'b', 's', 'y', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'l', 'u', 'i', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'l',
+  'w', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
+  '3', '2', '_', 'c', 'l', 'z', 'e', 'r', 'o', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'd', 'i', 'r', 'e', 'c',
+  't', 's', 't', 'o', 'r', 'e', '_', 'u', '3', '2', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'd', 'i', 'r', 'e',
+  'c', 't', 's', 't', 'o', 'r', 'e', '_', 'u', '6', '4', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'e', 'n', 'q',
+  'c', 'm', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
+  'a', '3', '2', '_', 'e', 'n', 'q', 'c', 'm', 'd', 's', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'r', 'e', 'a',
+  'd', 'e', 'f', 'l', 'a', 'g', 's', '_', 'u', '3', '2', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'r', 'e', 'a',
+  'd', 'e', 'f', 'l', 'a', 'g', 's', '_', 'u', '6', '4', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'w', 'r', 'i',
+  't', 'e', 'e', 'f', 'l', 'a', 'g', 's', '_', 'u', '3', '2', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'w', 'r',
+  'i', 't', 'e', 'e', 'f', 'l', 'a', 'g', 's', '_', 'u', '6', '4', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v',
+  'f', 'm', 'a', 'd', 'd', 's', 'u', 'b', 'p', 'd', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'f', 'm', 'a',
+  'd', 'd', 's', 'u', 'b', 'p', 'd', '2', '5', '6', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'f', 'm', 'a',
+  'd', 'd', 's', 'u', 'b', 'p', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'f', 'm', 'a', 'd', 'd', 's',
+  'u', 'b', 'p', 's', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'f', 'x', 'r', 's', 't', 'o', 'r',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
+  '_', 'f', 'x', 'r', 's', 't', 'o', 'r', '6', '4', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'f', 'x', 's', 'a',
+  'v', 'e', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
+  '3', '2', '_', 'f', 'x', 's', 'a', 'v', 'e', '6', '4', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'i', 'n', 'c',
+  's', 's', 'p', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'i', 'a', '3', '2', '_', 'i', 'n', 'c', 's', 's', 'p', 'q', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'i', 'n',
+  'v', 'p', 'c', 'i', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'i', 'a', '3', '2', '_', 't', 'i', 'l', 'e', '_', 'l', 'o', 'a', 'd',
+  'c', 'o', 'n', 'f', 'i', 'g', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'l', 'l', 'w', 'p', 'c', 'b', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'l',
+  'o', 'a', 'd', 'i', 'w', 'k', 'e', 'y', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'l', 'w', 'p', 'i', 'n', 's',
+  '3', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
+  '3', '2', '_', 'l', 'w', 'p', 'i', 'n', 's', '6', '4', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'l', 'w', 'p',
+  'v', 'a', 'l', '3', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'i', 'a', '3', '2', '_', 'l', 'w', 'p', 'v', 'a', 'l', '6', '4', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
+  'e', 'm', 'm', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'i', 'a', '3', '2', '_', 'f', 'e', 'm', 'm', 's', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'm', 'a', 's', 'k',
+  'm', 'o', 'v', 'q', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'i', 'a', '3', '2', '_', 'm', 'o', 'v', 'n', 't', 'q', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'a', 'c',
+  'k', 's', 's', 'd', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'i', 'a', '3', '2', '_', 'p', 'a', 'c', 'k', 's', 's', 'w', 'b', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
+  'p', 'a', 'c', 'k', 'u', 's', 'w', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'a', 'd', 'd', 'b', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
+  'p', 'a', 'd', 'd', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'i', 'a', '3', '2', '_', 'p', 'a', 'd', 'd', 'q', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'a', 'd',
+  'd', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
+  '3', '2', '_', 'p', 'a', 'd', 'd', 's', 'b', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'a', 'd', 'd', 's',
+  'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
+  '2', '_', 'p', 'a', 'd', 'd', 'u', 's', 'b', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'a', 'd', 'd', 'u',
+  's', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
+  '3', '2', '_', 'p', 'a', 'l', 'i', 'g', 'n', 'r', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'a', 'n', 'd',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
+  '_', 'p', 'a', 'n', 'd', 'n', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'p', 'a', 'v', 'g', 'b', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'a',
+  'v', 'g', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
+  'a', '3', '2', '_', 'p', 'c', 'm', 'p', 'e', 'q', 'b', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'c', 'm',
+  'p', 'e', 'q', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'i', 'a', '3', '2', '_', 'p', 'c', 'm', 'p', 'e', 'q', 'w', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'c',
+  'm', 'p', 'g', 't', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'i', 'a', '3', '2', '_', 'p', 'c', 'm', 'p', 'g', 't', 'd', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p',
+  'c', 'm', 'p', 'g', 't', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'v', 'e', 'c', '_', 'e', 'x', 't', '_',
+  'v', '4', 'h', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'i', 'a', '3', '2', '_', 'v', 'e', 'c', '_', 's', 'e', 't', '_', 'v', '4',
+  'h', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
+  '3', '2', '_', 'p', 'm', 'a', 'd', 'd', 'w', 'd', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'a', 'x',
+  's', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
+  '3', '2', '_', 'p', 'm', 'a', 'x', 'u', 'b', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'i', 'n', 's',
+  'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
+  '2', '_', 'p', 'm', 'i', 'n', 'u', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 'm', 's',
+  'k', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
+  '3', '2', '_', 'p', 'm', 'u', 'l', 'h', 'w', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'u', 'l', 'h',
+  'u', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
+  '3', '2', '_', 'p', 'm', 'u', 'l', 'l', 'w', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'u', 'l', 'u',
+  'd', 'q', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
+  '3', '2', '_', 'p', 'o', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'a', 'd', 'b', 'w', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p',
+  's', 'l', 'l', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'i', 'a', '3', '2', '_', 'p', 's', 'l', 'l', 'q', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'l', 'l',
+  'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
+  '2', '_', 'p', 's', 'l', 'l', 'd', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'l', 'l', 'q', 'i',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
+  '_', 'p', 's', 'l', 'l', 'w', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'r', 'a', 'd', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p',
+  's', 'r', 'a', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'i', 'a', '3', '2', '_', 'p', 's', 'r', 'a', 'd', 'i', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'r',
+  'a', 'w', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
+  'a', '3', '2', '_', 'p', 's', 'r', 'l', 'd', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'r', 'l', 'q',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
+  '_', 'p', 's', 'r', 'l', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'r', 'l', 'd', 'i', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p',
+  's', 'r', 'l', 'q', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'i', 'a', '3', '2', '_', 'p', 's', 'r', 'l', 'w', 'i', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's',
+  'u', 'b', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
+  'a', '3', '2', '_', 'p', 's', 'u', 'b', 'd', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'u', 'b', 'q',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
+  '_', 'p', 's', 'u', 'b', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'u', 'b', 's', 'b', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p',
+  's', 'u', 'b', 's', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'i', 'a', '3', '2', '_', 'p', 's', 'u', 'b', 'u', 's', 'b', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p',
+  's', 'u', 'b', 'u', 's', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'p', 'u', 'n', 'p', 'c', 'k', 'h', 'b',
+  'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
+  '2', '_', 'p', 'u', 'n', 'p', 'c', 'k', 'h', 'd', 'q', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'u', 'n',
+  'p', 'c', 'k', 'h', 'w', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'p', 'u', 'n', 'p', 'c', 'k', 'l', 'b',
+  'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
+  '2', '_', 'p', 'u', 'n', 'p', 'c', 'k', 'l', 'd', 'q', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'u', 'n',
+  'p', 'c', 'k', 'l', 'w', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'p', 'x', 'o', 'r', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'm', 'o', 'n',
+  'i', 't', 'o', 'r', 'x', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'i', 'a', '3', '2', '_', 'm', 'o', 'v', 'd', 'i', 'r', '6', '4', 'b',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
+  '_', 'm', 'w', 'a', 'i', 't', 'x', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'c', 'l', 'm', 'u', 'l', 'q',
+  'd', 'q', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'i', 'a', '3', '2', '_', 'p', 'c', 'l', 'm', 'u', 'l', 'q', 'd', 'q',
+  '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
+  'a', '3', '2', '_', 'p', 'c', 'l', 'm', 'u', 'l', 'q', 'd', 'q', '5', '1',
+  '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
+  '2', '_', 'p', 't', 'w', 'r', 'i', 't', 'e', '3', '2', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 't', 'w',
+  'r', 'i', 't', 'e', '6', '4', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'r', 'd', 'f', 's', 'b', 'a', 's', 'e',
+  '3', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
+  '3', '2', '_', 'r', 'd', 'f', 's', 'b', 'a', 's', 'e', '6', '4', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'r',
+  'd', 'g', 's', 'b', 'a', 's', 'e', '3', '2', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'r', 'd', 'g', 's', 'b',
+  'a', 's', 'e', '6', '4', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'i', 'a', '3', '2', '_', 'r', 'd', 'p', 'i', 'd', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'r', 'd', 'p',
+  'k', 'r', 'u', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
+  'a', '3', '2', '_', 'r', 'd', 'p', 'm', 'c', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'r', 'd', 's', 's', 'p',
+  'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
+  '2', '_', 'r', 'd', 's', 's', 'p', 'q', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'r', 'd', 't', 's', 'c', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
+  'r', 's', 't', 'o', 'r', 's', 's', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 's', 'a', 'v', 'e', 'p', 'r',
+  'e', 'v', 's', 's', 'p', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'i', 'a', '3', '2', '_', 's', 'e', 'n', 'd', 'u', 'i', 'p', 'i', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
+  's', 'e', 'r', 'i', 'a', 'l', 'i', 'z', 'e', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 's', 'e', 't', 's', 's',
+  'b', 's', 'y', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
+  'a', '3', '2', '_', 's', 'h', 'a', '1', 'm', 's', 'g', '1', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 's', 'h',
+  'a', '1', 'm', 's', 'g', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 's', 'h', 'a', '1', 'n', 'e', 'x', 't',
+  'e', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
+  '2', '_', 's', 'h', 'a', '1', 'r', 'n', 'd', 's', '4', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 's', 'h', 'a',
+  '2', '5', '6', 'm', 's', 'g', '1', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'i', 'a', '3', '2', '_', 's', 'h', 'a', '2', '5', '6', 'm',
+  's', 'g', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
+  'a', '3', '2', '_', 's', 'h', 'a', '2', '5', '6', 'r', 'n', 'd', 's', '2',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
+  '_', 's', 'l', 'w', 'p', 'c', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'm', 'p', 's', 's', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c',
+  'o', 'm', 'i', 'e', 'q', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'i', 'a', '3', '2', '_', 'c', 'o', 'm', 'i', 'g', 'e', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'o',
+  'm', 'i', 'g', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'i', 'a', '3', '2', '_', 'c', 'o', 'm', 'i', 'l', 'e', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'o', 'm',
+  'i', 'l', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
+  'a', '3', '2', '_', 'c', 'o', 'm', 'i', 'n', 'e', 'q', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't',
+  'p', 'd', '2', 'p', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't', 'p', 'i', '2', 'p', 'd', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
+  'c', 'v', 't', 'p', 'i', '2', 'p', 's', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't', 'p', 's', '2',
+  'p', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
+  '3', '2', '_', 'c', 'v', 't', 's', 's', '2', 's', 'i', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't',
+  's', 's', '2', 's', 'i', '6', '4', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't', 't', 'p', 'd', '2',
+  'p', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
+  '3', '2', '_', 'c', 'v', 't', 't', 'p', 's', '2', 'p', 'i', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v',
+  't', 't', 's', 's', '2', 's', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't', 't', 's', 's', '2',
+  's', 'i', '6', '4', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'i', 'a', '3', '2', '_', 'm', 'a', 'x', 'p', 's', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'm', 'a', 'x', 's',
+  's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
+  '2', '_', 'm', 'i', 'n', 'p', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'm', 'i', 'n', 's', 's', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'm',
+  'o', 'v', 'm', 's', 'k', 'p', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'h', 'u', 'f', 'w', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
+  'r', 'c', 'p', 'p', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'i', 'a', '3', '2', '_', 'r', 'c', 'p', 's', 's', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'r', 's', 'q',
+  'r', 't', 'p', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'i', 'a', '3', '2', '_', 'r', 's', 'q', 'r', 't', 's', 's', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 's', 'f',
+  'e', 'n', 'c', 'e', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'i', 'a', '3', '2', '_', 'u', 'c', 'o', 'm', 'i', 'e', 'q', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'u', 'c',
+  'o', 'm', 'i', 'g', 'e', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'i', 'a', '3', '2', '_', 'u', 'c', 'o', 'm', 'i', 'g', 't', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'u',
+  'c', 'o', 'm', 'i', 'l', 'e', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'u', 'c', 'o', 'm', 'i', 'l', 't', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
+  'u', 'c', 'o', 'm', 'i', 'n', 'e', 'q', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'l', 'f', 'l', 'u', 's',
+  'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
+  '2', '_', 'c', 'm', 'p', 's', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'o', 'm', 'i', 's', 'd', 'e',
   'q', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
-  '2', '_', 'v', 'p', 's', 'h', 'a', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l',
-  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 's', 'h', 'l', 'b',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
-  '_', 'v', 'p', 's', 'h', 'l', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
-  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 's', 'h', 'l', 'q', '\000',
+  '2', '_', 'c', 'o', 'm', 'i', 's', 'd', 'g', 'e', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'o', 'm', 'i',
+  's', 'd', 'g', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'i', 'a', '3', '2', '_', 'c', 'o', 'm', 'i', 's', 'd', 'l', 'e', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c',
+  'o', 'm', 'i', 's', 'd', 'l', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'o', 'm', 'i', 's', 'd', 'n',
+  'e', 'q', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
+  '3', '2', '_', 'c', 'v', 't', 'p', 'd', '2', 'd', 'q', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't',
+  'p', 'd', '2', 'p', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't', 'p', 's', '2', 'd', 'q', '\000',
   '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
-  'v', 'p', 's', 'h', 'l', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
-  'n', '_', 'i', 'a', '3', '2', '_', 'x', 't', 'e', 's', 't', '\000', '_', '_',
-  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'b', 'i', 't', 'r', 'e', 'v', '\000',
-  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'g', 'e', 't', 'i', 'd',
-  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'g', 'e', 't', 'p',
-  's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 's', 'e', 't',
-  'p', 's', '\000',
+  'c', 'v', 't', 's', 'd', '2', 's', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't', 's', 'd', '2',
+  's', 'i', '6', '4', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'i', 'a', '3', '2', '_', 'c', 'v', 't', 's', 'd', '2', 's', 's', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c',
+  'v', 't', 't', 'p', 'd', '2', 'd', 'q', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'v', 't', 't', 'p', 's',
+  '2', 'd', 'q', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
+  'a', '3', '2', '_', 'c', 'v', 't', 't', 's', 'd', '2', 's', 'i', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c',
+  'v', 't', 't', 's', 'd', '2', 's', 'i', '6', '4', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'l', 'f', 'e', 'n',
+  'c', 'e', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
+  '3', '2', '_', 'm', 'a', 's', 'k', 'm', 'o', 'v', 'd', 'q', 'u', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'm',
+  'a', 'x', 'p', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'i', 'a', '3', '2', '_', 'm', 'a', 'x', 's', 'd', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'm', 'f', 'e', 'n',
+  'c', 'e', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
+  '3', '2', '_', 'm', 'i', 'n', 'p', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'm', 'i', 'n', 's', 'd', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
+  'm', 'o', 'v', 'm', 's', 'k', 'p', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'a', 'c', 'k', 's', 's',
+  'd', 'w', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'i', 'a', '3', '2', '_', 'p', 'a', 'c', 'k', 's', 's', 'w', 'b', '1',
+  '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
+  '3', '2', '_', 'p', 'a', 'c', 'k', 'u', 's', 'w', 'b', '1', '2', '8', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
+  'p', 'a', 'u', 's', 'e', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'i', 'a', '3', '2', '_', 'p', 'a', 'v', 'g', 'b', '1', '2', '8', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
+  'p', 'a', 'v', 'g', 'w', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'a', 'd', 'd', 'w',
+  'd', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'i', 'a', '3', '2', '_', 'p', 'm', 'o', 'v', 'm', 's', 'k', 'b', '1', '2',
+  '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
+  '2', '_', 'p', 'm', 'u', 'l', 'h', 'w', '1', '2', '8', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'u',
+  'l', 'h', 'u', 'w', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'a', 'd', 'b', 'w', '1',
+  '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
+  '3', '2', '_', 'p', 's', 'l', 'l', 'd', '1', '2', '8', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'l',
+  'l', 'q', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'i', 'a', '3', '2', '_', 'p', 's', 'l', 'l', 'w', '1', '2', '8', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
+  'p', 's', 'l', 'l', 'd', 'i', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'l', 'l', 'q',
+  'i', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'i', 'a', '3', '2', '_', 'p', 's', 'l', 'l', 'w', 'i', '1', '2', '8', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
+  'p', 's', 'r', 'a', 'd', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'r', 'a', 'w', '1',
+  '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
+  '3', '2', '_', 'p', 's', 'r', 'a', 'd', 'i', '1', '2', '8', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's',
+  'r', 'a', 'w', 'i', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'r', 'l', 'd', '1', '2',
+  '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
+  '2', '_', 'p', 's', 'r', 'l', 'q', '1', '2', '8', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'r', 'l',
+  'w', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'i', 'a', '3', '2', '_', 'p', 's', 'r', 'l', 'd', 'i', '1', '2', '8', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
+  'p', 's', 'r', 'l', 'q', 'i', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'r', 'l', 'w',
+  'i', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'i', 'a', '3', '2', '_', 'u', 'c', 'o', 'm', 'i', 's', 'd', 'e', 'q', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
+  'u', 'c', 'o', 'm', 'i', 's', 'd', 'g', 'e', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'u', 'c', 'o', 'm', 'i',
+  's', 'd', 'g', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'i', 'a', '3', '2', '_', 'u', 'c', 'o', 'm', 'i', 's', 'd', 'l', 'e', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
+  'u', 'c', 'o', 'm', 'i', 's', 'd', 'l', 't', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'u', 'c', 'o', 'm', 'i',
+  's', 'd', 'n', 'e', 'q', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'i', 'a', '3', '2', '_', 'a', 'd', 'd', 's', 'u', 'b', 'p', 'd', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
+  'a', 'd', 'd', 's', 'u', 'b', 'p', 's', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'h', 'a', 'd', 'd', 'p', 'd',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
+  '_', 'h', 'a', 'd', 'd', 'p', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'h', 's', 'u', 'b', 'p', 'd', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
+  'h', 's', 'u', 'b', 'p', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'l', 'd', 'd', 'q', 'u', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'm', 'o',
+  'n', 'i', 't', 'o', 'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'i', 'a', '3', '2', '_', 'm', 'w', 'a', 'i', 't', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'b', 'l', 'e',
+  'n', 'd', 'v', 'p', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'i', 'a', '3', '2', '_', 'b', 'l', 'e', 'n', 'd', 'v', 'p', 's', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
+  'd', 'p', 'p', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'i', 'a', '3', '2', '_', 'd', 'p', 'p', 's', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'i', 'n', 's', 'e', 'r',
+  't', 'p', 's', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'm', 'p', 's', 'a', 'd', 'b', 'w', '1',
+  '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
+  '3', '2', '_', 'p', 'a', 'c', 'k', 'u', 's', 'd', 'w', '1', '2', '8', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
+  'p', 'b', 'l', 'e', 'n', 'd', 'v', 'b', '1', '2', '8', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'h', 'm',
+  'i', 'n', 'p', 'o', 's', 'u', 'w', '1', '2', '8', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 't', 'e', 's',
+  't', 'c', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'i', 'a', '3', '2', '_', 'p', 't', 'e', 's', 't', 'n', 'z', 'c', '1',
+  '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
+  '3', '2', '_', 'p', 't', 'e', 's', 't', 'z', '1', '2', '8', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'r', 'o',
+  'u', 'n', 'd', 'p', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'i', 'a', '3', '2', '_', 'r', 'o', 'u', 'n', 'd', 'p', 's', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'r',
+  'o', 'u', 'n', 'd', 's', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 'r', 'o', 'u', 'n', 'd', 's', 's', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
+  'c', 'r', 'c', '3', '2', 'h', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'r', 'c', '3', '2', 's', 'i',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
+  '_', 'c', 'r', 'c', '3', '2', 'q', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'c', 'r', 'c', '3', '2', 'd',
+  'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
+  '2', '_', 'p', 'c', 'm', 'p', 'e', 's', 't', 'r', 'i', '1', '2', '8', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
+  'p', 'c', 'm', 'p', 'e', 's', 't', 'r', 'i', 'a', '1', '2', '8', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p',
+  'c', 'm', 'p', 'e', 's', 't', 'r', 'i', 'c', '1', '2', '8', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'c',
+  'm', 'p', 'e', 's', 't', 'r', 'i', 'o', '1', '2', '8', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'c', 'm',
+  'p', 'e', 's', 't', 'r', 'i', 's', '1', '2', '8', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'c', 'm', 'p',
+  'e', 's', 't', 'r', 'i', 'z', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'c', 'm', 'p', 'e',
+  's', 't', 'r', 'm', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'c', 'm', 'p', 'i', 's', 't',
+  'r', 'i', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'i', 'a', '3', '2', '_', 'p', 'c', 'm', 'p', 'i', 's', 't', 'r', 'i',
+  'a', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'i', 'a', '3', '2', '_', 'p', 'c', 'm', 'p', 'i', 's', 't', 'r', 'i', 'c',
+  '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
+  'a', '3', '2', '_', 'p', 'c', 'm', 'p', 'i', 's', 't', 'r', 'i', 'o', '1',
+  '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
+  '3', '2', '_', 'p', 'c', 'm', 'p', 'i', 's', 't', 'r', 'i', 's', '1', '2',
+  '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
+  '2', '_', 'p', 'c', 'm', 'p', 'i', 's', 't', 'r', 'i', 'z', '1', '2', '8',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
+  '_', 'p', 'c', 'm', 'p', 'i', 's', 't', 'r', 'm', '1', '2', '8', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'e',
+  'x', 't', 'r', 'q', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'i', 'a', '3', '2', '_', 'e', 'x', 't', 'r', 'q', 'i', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'i', 'n', 's',
+  'e', 'r', 't', 'q', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'i', 'a', '3', '2', '_', 'i', 'n', 's', 'e', 'r', 't', 'q', 'i', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p',
+  'a', 'b', 's', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'i', 'a', '3', '2', '_', 'p', 'a', 'b', 's', 'd', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'a', 'b', 's',
+  'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
+  '2', '_', 'p', 'h', 'a', 'd', 'd', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'h', 'a', 'd', 'd', 'd',
+  '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
+  'a', '3', '2', '_', 'p', 'h', 'a', 'd', 'd', 's', 'w', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'h', 'a',
+  'd', 'd', 's', 'w', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'h', 'a', 'd', 'd', 'w', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
+  'p', 'h', 'a', 'd', 'd', 'w', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'h', 's', 'u', 'b',
+  'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
+  '2', '_', 'p', 'h', 's', 'u', 'b', 'd', '1', '2', '8', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'h', 's',
+  'u', 'b', 's', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'i', 'a', '3', '2', '_', 'p', 'h', 's', 'u', 'b', 's', 'w', '1', '2', '8',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
+  '_', 'p', 'h', 's', 'u', 'b', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'h', 's', 'u', 'b', 'w', '1',
+  '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
+  '3', '2', '_', 'p', 'm', 'a', 'd', 'd', 'u', 'b', 's', 'w', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm',
+  'a', 'd', 'd', 'u', 'b', 's', 'w', '1', '2', '8', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 'm', 'u', 'l',
+  'h', 'r', 's', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'i', 'a', '3', '2', '_', 'p', 'm', 'u', 'l', 'h', 'r', 's', 'w', '1', '2',
+  '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
+  '2', '_', 'p', 's', 'h', 'u', 'f', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'h', 'u', 'f', 'b',
+  '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
+  'a', '3', '2', '_', 'p', 's', 'i', 'g', 'n', 'b', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'i', 'g',
+  'n', 'b', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'i', 'a', '3', '2', '_', 'p', 's', 'i', 'g', 'n', 'd', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's',
+  'i', 'g', 'n', 'd', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'p', 's', 'i', 'g', 'n', 'w', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
+  'p', 's', 'i', 'g', 'n', 'w', '1', '2', '8', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 't', 'i', 'l', 'e', '_',
+  's', 't', 'o', 'r', 'e', 'c', 'o', 'n', 'f', 'i', 'g', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 's', 't', 'u',
+  'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
+  '2', '_', 'b', 'e', 'x', 't', 'r', 'i', '_', 'u', '3', '2', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'b', 'e',
+  'x', 't', 'r', 'i', '_', 'u', '6', '4', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 't', 'd', 'p', 'b', 'f', '1',
+  '6', 'p', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
+  'a', '3', '2', '_', 't', 'd', 'p', 'b', 's', 's', 'd', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 't', 'd', 'p',
+  'b', 's', 's', 'd', '_', 'i', 'n', 't', 'e', 'r', 'n', 'a', 'l', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 't',
+  'd', 'p', 'b', 's', 'u', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'i', 'a', '3', '2', '_', 't', 'd', 'p', 'b', 'u', 's', 'd', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
+  't', 'd', 'p', 'b', 'u', 'u', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'i', 'a', '3', '2', '_', 't', 'e', 's', 't', 'u', 'i', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
+  't', 'i', 'l', 'e', 'l', 'o', 'a', 'd', 'd', '6', '4', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 't', 'i', 'l',
+  'e', 'l', 'o', 'a', 'd', 'd', '6', '4', '_', 'i', 'n', 't', 'e', 'r', 'n',
+  'a', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
+  '3', '2', '_', 't', 'i', 'l', 'e', 'l', 'o', 'a', 'd', 'd', 't', '1', '6',
+  '4', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
+  '2', '_', 't', 'i', 'l', 'e', 'r', 'e', 'l', 'e', 'a', 's', 'e', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 't',
+  'i', 'l', 'e', 's', 't', 'o', 'r', 'e', 'd', '6', '4', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 't', 'i', 'l',
+  'e', 's', 't', 'o', 'r', 'e', 'd', '6', '4', '_', 'i', 'n', 't', 'e', 'r',
+  'n', 'a', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
+  'a', '3', '2', '_', 't', 'i', 'l', 'e', 'z', 'e', 'r', 'o', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 't', 'i',
+  'l', 'e', 'z', 'e', 'r', 'o', '_', 'i', 'n', 't', 'e', 'r', 'n', 'a', 'l',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
+  '_', 't', 'p', 'a', 'u', 's', 'e', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'u', 'm', 'o', 'n', 'i', 't', 'o',
+  'r', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
+  '2', '_', 'u', 'm', 'w', 'a', 'i', 't', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'c', 'v', 't', 'p', 's',
+  '2', 'p', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
+  'a', '3', '2', '_', 'v', 'c', 'v', 't', 'p', 's', '2', 'p', 'h', '2', '5',
+  '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
+  '2', '_', 'v', 'g', 'f', '2', 'p', '8', 'a', 'f', 'f', 'i', 'n', 'e', 'i',
+  'n', 'v', 'q', 'b', '_', 'v', '1', '6', 'q', 'i', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'g', 'f', '2',
+  'p', '8', 'a', 'f', 'f', 'i', 'n', 'e', 'i', 'n', 'v', 'q', 'b', '_', 'v',
+  '3', '2', 'q', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'i', 'a', '3', '2', '_', 'v', 'g', 'f', '2', 'p', '8', 'a', 'f', 'f', 'i',
+  'n', 'e', 'i', 'n', 'v', 'q', 'b', '_', 'v', '6', '4', 'q', 'i', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v',
+  'g', 'f', '2', 'p', '8', 'a', 'f', 'f', 'i', 'n', 'e', 'q', 'b', '_', 'v',
+  '1', '6', 'q', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'i', 'a', '3', '2', '_', 'v', 'g', 'f', '2', 'p', '8', 'a', 'f', 'f', 'i',
+  'n', 'e', 'q', 'b', '_', 'v', '3', '2', 'q', 'i', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'g', 'f', '2',
+  'p', '8', 'a', 'f', 'f', 'i', 'n', 'e', 'q', 'b', '_', 'v', '6', '4', 'q',
+  'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
+  '2', '_', 'v', 'g', 'f', '2', 'p', '8', 'm', 'u', 'l', 'b', '_', 'v', '1',
+  '6', 'q', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
+  'a', '3', '2', '_', 'v', 'g', 'f', '2', 'p', '8', 'm', 'u', 'l', 'b', '_',
+  'v', '3', '2', 'q', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'i', 'a', '3', '2', '_', 'v', 'g', 'f', '2', 'p', '8', 'm', 'u', 'l',
+  'b', '_', 'v', '6', '4', 'q', 'i', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'w', 'b', 'i', 'n', 'v', 'd', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
+  'w', 'b', 'n', 'o', 'i', 'n', 'v', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'w', 'r', 'f', 's', 'b', 'a',
+  's', 'e', '3', '2', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'i', 'a', '3', '2', '_', 'w', 'r', 'f', 's', 'b', 'a', 's', 'e', '6', '4',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
+  '_', 'w', 'r', 'g', 's', 'b', 'a', 's', 'e', '3', '2', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'w', 'r', 'g',
+  's', 'b', 'a', 's', 'e', '6', '4', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'w', 'r', 'p', 'k', 'r', 'u', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
+  'w', 'r', 's', 's', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'i', 'a', '3', '2', '_', 'w', 'r', 's', 's', 'q', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'w', 'r', 'u',
+  's', 's', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
+  'a', '3', '2', '_', 'w', 'r', 'u', 's', 's', 'q', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'x', 'a', 'b', 'o',
+  'r', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
+  '3', '2', '_', 'x', 'b', 'e', 'g', 'i', 'n', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'x', 'e', 'n', 'd', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
+  'v', 'f', 'r', 'c', 'z', 'p', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'f', 'r', 'c', 'z', 'p', 'd',
+  '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
+  'a', '3', '2', '_', 'v', 'f', 'r', 'c', 'z', 'p', 's', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'f', 'r',
+  'c', 'z', 'p', 's', '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'f', 'r', 'c', 'z', 's', 'd',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
+  '_', 'v', 'f', 'r', 'c', 'z', 's', 's', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 'e', 'r', 'm', 'i',
+  'l', '2', 'p', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'i', 'a', '3', '2', '_', 'v', 'p', 'e', 'r', 'm', 'i', 'l', '2', 'p', 'd',
+  '2', '5', '6', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
+  'a', '3', '2', '_', 'v', 'p', 'e', 'r', 'm', 'i', 'l', '2', 'p', 's', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
+  'v', 'p', 'e', 'r', 'm', 'i', 'l', '2', 'p', 's', '2', '5', '6', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v',
+  'p', 'h', 'a', 'd', 'd', 'b', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 'h', 'a', 'd', 'd', 'b',
+  'q', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
+  '2', '_', 'v', 'p', 'h', 'a', 'd', 'd', 'b', 'w', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 'h', 'a',
+  'd', 'd', 'd', 'q', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'i', 'a', '3', '2', '_', 'v', 'p', 'h', 'a', 'd', 'd', 'u', 'b', 'd', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
+  'v', 'p', 'h', 'a', 'd', 'd', 'u', 'b', 'q', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 'h', 'a', 'd',
+  'd', 'u', 'b', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'i', 'a', '3', '2', '_', 'v', 'p', 'h', 'a', 'd', 'd', 'u', 'd', 'q', '\000',
+  '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_',
+  'v', 'p', 'h', 'a', 'd', 'd', 'u', 'w', 'd', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 'h', 'a', 'd',
+  'd', 'u', 'w', 'q', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'i', 'a', '3', '2', '_', 'v', 'p', 'h', 'a', 'd', 'd', 'w', 'd', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v',
+  'p', 'h', 'a', 'd', 'd', 'w', 'q', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 'h', 's', 'u', 'b', 'b',
+  'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
+  '2', '_', 'v', 'p', 'h', 's', 'u', 'b', 'd', 'q', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 'h', 's',
+  'u', 'b', 'w', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'i', 'a', '3', '2', '_', 'v', 'p', 'm', 'a', 'c', 's', 'd', 'd', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v',
+  'p', 'm', 'a', 'c', 's', 'd', 'q', 'h', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 'm', 'a', 'c', 's',
+  'd', 'q', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
+  'a', '3', '2', '_', 'v', 'p', 'm', 'a', 'c', 's', 's', 'd', 'd', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v',
+  'p', 'm', 'a', 'c', 's', 's', 'd', 'q', 'h', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 'm', 'a', 'c',
+  's', 's', 'd', 'q', 'l', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'i', 'a', '3', '2', '_', 'v', 'p', 'm', 'a', 'c', 's', 's', 'w', 'd',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
+  '_', 'v', 'p', 'm', 'a', 'c', 's', 's', 'w', 'w', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 'm', 'a',
+  'c', 's', 'w', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'i', 'a', '3', '2', '_', 'v', 'p', 'm', 'a', 'c', 's', 'w', 'w', '\000', '_',
+  '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v',
+  'p', 'm', 'a', 'd', 'c', 's', 's', 'w', 'd', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 'm', 'a', 'd',
+  'c', 's', 'w', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_',
+  'i', 'a', '3', '2', '_', 'v', 'p', 'p', 'e', 'r', 'm', '\000', '_', '_', 'b',
+  'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 's',
+  'h', 'a', 'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i',
+  'a', '3', '2', '_', 'v', 'p', 's', 'h', 'a', 'd', '\000', '_', '_', 'b', 'u',
+  'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 's', 'h',
+  'a', 'q', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
+  '3', '2', '_', 'v', 'p', 's', 'h', 'a', 'w', '\000', '_', '_', 'b', 'u', 'i',
+  'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 's', 'h', 'l',
+  'b', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3',
+  '2', '_', 'v', 'p', 's', 'h', 'l', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l',
+  't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'v', 'p', 's', 'h', 'l', 'q',
+  '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2',
+  '_', 'v', 'p', 's', 'h', 'l', 'w', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 'i', 'a', '3', '2', '_', 'x', 'r', 'e', 's', 'l', 'd', 't',
+  'r', 'k', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a',
+  '3', '2', '_', 'x', 's', 'u', 's', 'l', 'd', 't', 'r', 'k', '\000', '_', '_',
+  'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'i', 'a', '3', '2', '_', 'x', 't',
+  'e', 's', 't', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n', '_', 'b',
+  'i', 't', 'r', 'e', 'v', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i', 'n',
+  '_', 'g', 'e', 't', 'i', 'd', '\000', '_', '_', 'b', 'u', 'i', 'l', 't', 'i',
+  'n', '_', 'g', 'e', 't', 'p', 's', '\000', '_', '_', 'b', 'u', 'i', 'l', 't',
+  'i', 'n', '_', 's', 'e', 't', 'p', 's', '\000',
   };
 
   struct BuiltinEntry {
@@ -26447,13 +35702,12 @@
     static const BuiltinEntry Names[] = {
       {Intrinsic::adjust_trampoline, 0}, // __builtin_adjust_trampoline
       {Intrinsic::debugtrap, 28}, // __builtin_debugtrap
-      {Intrinsic::flt_rounds, 70}, // __builtin_flt_rounds
-      {Intrinsic::init_trampoline, 91}, // __builtin_init_trampoline
-      {Intrinsic::objectsize, 117}, // __builtin_object_size
-      {Intrinsic::stackrestore, 139}, // __builtin_stack_restore
-      {Intrinsic::stacksave, 163}, // __builtin_stack_save
-      {Intrinsic::thread_pointer, 184}, // __builtin_thread_pointer
-      {Intrinsic::trap, 209}, // __builtin_trap
+      {Intrinsic::init_trampoline, 70}, // __builtin_init_trampoline
+      {Intrinsic::objectsize, 96}, // __builtin_object_size
+      {Intrinsic::stackrestore, 118}, // __builtin_stack_restore
+      {Intrinsic::stacksave, 142}, // __builtin_stack_save
+      {Intrinsic::thread_pointer, 163}, // __builtin_thread_pointer
+      {Intrinsic::trap, 188}, // __builtin_trap
       {Intrinsic::eh_unwind_init, 48}, // __builtin_unwind_init
     };
     auto I = std::lower_bound(std::begin(Names),
@@ -26465,9 +35719,24 @@
   }
   if (TargetPrefix == "aarch64") {
     static const BuiltinEntry aarch64Names[] = {
-      {Intrinsic::aarch64_dmb, 224}, // __builtin_arm_dmb
-      {Intrinsic::aarch64_dsb, 242}, // __builtin_arm_dsb
-      {Intrinsic::aarch64_isb, 260}, // __builtin_arm_isb
+      {Intrinsic::aarch64_dmb, 203}, // __builtin_arm_dmb
+      {Intrinsic::aarch64_dsb, 221}, // __builtin_arm_dsb
+      {Intrinsic::aarch64_isb, 239}, // __builtin_arm_isb
+      {Intrinsic::aarch64_tcancel, 525}, // __builtin_arm_tcancel
+      {Intrinsic::aarch64_tcommit, 547}, // __builtin_arm_tcommit
+      {Intrinsic::aarch64_tstart, 569}, // __builtin_arm_tstart
+      {Intrinsic::aarch64_ttest, 590}, // __builtin_arm_ttest
+      {Intrinsic::aarch64_sve_aesd, 257}, // __builtin_sve_svaesd_u8
+      {Intrinsic::aarch64_sve_aese, 281}, // __builtin_sve_svaese_u8
+      {Intrinsic::aarch64_sve_aesimc, 305}, // __builtin_sve_svaesimc_u8
+      {Intrinsic::aarch64_sve_aesmc, 331}, // __builtin_sve_svaesmc_u8
+      {Intrinsic::aarch64_sve_rax1, 356}, // __builtin_sve_svrax1_u64
+      {Intrinsic::aarch64_sve_rdffr, 381}, // __builtin_sve_svrdffr
+      {Intrinsic::aarch64_sve_rdffr_z, 403}, // __builtin_sve_svrdffr_z
+      {Intrinsic::aarch64_sve_setffr, 427}, // __builtin_sve_svsetffr
+      {Intrinsic::aarch64_sve_sm4e, 450}, // __builtin_sve_svsm4e_u32
+      {Intrinsic::aarch64_sve_sm4ekey, 475}, // __builtin_sve_svsm4ekey_u32
+      {Intrinsic::aarch64_sve_wrffr, 503}, // __builtin_sve_svwrffr
     };
     auto I = std::lower_bound(std::begin(aarch64Names),
                               std::end(aarch64Names),
@@ -26478,83 +35747,111 @@
   }
   if (TargetPrefix == "amdgcn") {
     static const BuiltinEntry amdgcnNames[] = {
-      {Intrinsic::amdgcn_buffer_wbinvl1, 278}, // __builtin_amdgcn_buffer_wbinvl1
-      {Intrinsic::amdgcn_buffer_wbinvl1_sc, 310}, // __builtin_amdgcn_buffer_wbinvl1_sc
-      {Intrinsic::amdgcn_buffer_wbinvl1_vol, 345}, // __builtin_amdgcn_buffer_wbinvl1_vol
-      {Intrinsic::amdgcn_cubeid, 381}, // __builtin_amdgcn_cubeid
-      {Intrinsic::amdgcn_cubema, 405}, // __builtin_amdgcn_cubema
-      {Intrinsic::amdgcn_cubesc, 429}, // __builtin_amdgcn_cubesc
-      {Intrinsic::amdgcn_cubetc, 453}, // __builtin_amdgcn_cubetc
-      {Intrinsic::amdgcn_cvt_pk_u8_f32, 477}, // __builtin_amdgcn_cvt_pk_u8_f32
-      {Intrinsic::amdgcn_dispatch_id, 508}, // __builtin_amdgcn_dispatch_id
-      {Intrinsic::amdgcn_dispatch_ptr, 537}, // __builtin_amdgcn_dispatch_ptr
-      {Intrinsic::amdgcn_ds_bpermute, 567}, // __builtin_amdgcn_ds_bpermute
-      {Intrinsic::amdgcn_ds_fadd, 596}, // __builtin_amdgcn_ds_faddf
-      {Intrinsic::amdgcn_ds_fmax, 622}, // __builtin_amdgcn_ds_fmaxf
-      {Intrinsic::amdgcn_ds_fmin, 648}, // __builtin_amdgcn_ds_fminf
-      {Intrinsic::amdgcn_ds_gws_barrier, 674}, // __builtin_amdgcn_ds_gws_barrier
-      {Intrinsic::amdgcn_ds_gws_init, 706}, // __builtin_amdgcn_ds_gws_init
-      {Intrinsic::amdgcn_ds_gws_sema_br, 735}, // __builtin_amdgcn_ds_gws_sema_br
-      {Intrinsic::amdgcn_ds_gws_sema_p, 767}, // __builtin_amdgcn_ds_gws_sema_p
-      {Intrinsic::amdgcn_ds_gws_sema_release_all, 798}, // __builtin_amdgcn_ds_gws_sema_release_all
-      {Intrinsic::amdgcn_ds_gws_sema_v, 839}, // __builtin_amdgcn_ds_gws_sema_v
-      {Intrinsic::amdgcn_ds_permute, 870}, // __builtin_amdgcn_ds_permute
-      {Intrinsic::amdgcn_ds_swizzle, 898}, // __builtin_amdgcn_ds_swizzle
-      {Intrinsic::amdgcn_fdot2, 926}, // __builtin_amdgcn_fdot2
-      {Intrinsic::amdgcn_fmed3, 949}, // __builtin_amdgcn_fmed3
-      {Intrinsic::amdgcn_fmul_legacy, 972}, // __builtin_amdgcn_fmul_legacy
-      {Intrinsic::amdgcn_groupstaticsize, 1001}, // __builtin_amdgcn_groupstaticsize
-      {Intrinsic::amdgcn_implicit_buffer_ptr, 1034}, // __builtin_amdgcn_implicit_buffer_ptr
-      {Intrinsic::amdgcn_implicitarg_ptr, 1071}, // __builtin_amdgcn_implicitarg_ptr
-      {Intrinsic::amdgcn_interp_mov, 1104}, // __builtin_amdgcn_interp_mov
-      {Intrinsic::amdgcn_interp_p1, 1132}, // __builtin_amdgcn_interp_p1
-      {Intrinsic::amdgcn_interp_p1_f16, 1159}, // __builtin_amdgcn_interp_p1_f16
-      {Intrinsic::amdgcn_interp_p2, 1190}, // __builtin_amdgcn_interp_p2
-      {Intrinsic::amdgcn_interp_p2_f16, 1217}, // __builtin_amdgcn_interp_p2_f16
-      {Intrinsic::amdgcn_kernarg_segment_ptr, 1248}, // __builtin_amdgcn_kernarg_segment_ptr
-      {Intrinsic::amdgcn_lerp, 1285}, // __builtin_amdgcn_lerp
-      {Intrinsic::amdgcn_mbcnt_hi, 1307}, // __builtin_amdgcn_mbcnt_hi
-      {Intrinsic::amdgcn_mbcnt_lo, 1333}, // __builtin_amdgcn_mbcnt_lo
-      {Intrinsic::amdgcn_mqsad_pk_u16_u8, 1359}, // __builtin_amdgcn_mqsad_pk_u16_u8
-      {Intrinsic::amdgcn_mqsad_u32_u8, 1392}, // __builtin_amdgcn_mqsad_u32_u8
-      {Intrinsic::amdgcn_msad_u8, 1422}, // __builtin_amdgcn_msad_u8
-      {Intrinsic::amdgcn_qsad_pk_u16_u8, 1447}, // __builtin_amdgcn_qsad_pk_u16_u8
-      {Intrinsic::amdgcn_queue_ptr, 1479}, // __builtin_amdgcn_queue_ptr
-      {Intrinsic::amdgcn_rcp_legacy, 1506}, // __builtin_amdgcn_rcp_legacy
-      {Intrinsic::amdgcn_readfirstlane, 1534}, // __builtin_amdgcn_readfirstlane
-      {Intrinsic::amdgcn_readlane, 1565}, // __builtin_amdgcn_readlane
-      {Intrinsic::amdgcn_rsq_legacy, 1591}, // __builtin_amdgcn_rsq_legacy
-      {Intrinsic::amdgcn_s_barrier, 1619}, // __builtin_amdgcn_s_barrier
-      {Intrinsic::amdgcn_s_dcache_inv, 1646}, // __builtin_amdgcn_s_dcache_inv
-      {Intrinsic::amdgcn_s_dcache_inv_vol, 1676}, // __builtin_amdgcn_s_dcache_inv_vol
-      {Intrinsic::amdgcn_s_dcache_wb, 1710}, // __builtin_amdgcn_s_dcache_wb
-      {Intrinsic::amdgcn_s_dcache_wb_vol, 1739}, // __builtin_amdgcn_s_dcache_wb_vol
-      {Intrinsic::amdgcn_s_decperflevel, 1772}, // __builtin_amdgcn_s_decperflevel
-      {Intrinsic::amdgcn_s_get_waveid_in_workgroup, 1804}, // __builtin_amdgcn_s_get_waveid_in_workgroup
-      {Intrinsic::amdgcn_s_getpc, 1847}, // __builtin_amdgcn_s_getpc
-      {Intrinsic::amdgcn_s_getreg, 1872}, // __builtin_amdgcn_s_getreg
-      {Intrinsic::amdgcn_s_incperflevel, 1898}, // __builtin_amdgcn_s_incperflevel
-      {Intrinsic::amdgcn_s_memrealtime, 1930}, // __builtin_amdgcn_s_memrealtime
-      {Intrinsic::amdgcn_s_memtime, 1961}, // __builtin_amdgcn_s_memtime
-      {Intrinsic::amdgcn_s_sendmsg, 1988}, // __builtin_amdgcn_s_sendmsg
-      {Intrinsic::amdgcn_s_sendmsghalt, 2015}, // __builtin_amdgcn_s_sendmsghalt
-      {Intrinsic::amdgcn_s_sleep, 2046}, // __builtin_amdgcn_s_sleep
-      {Intrinsic::amdgcn_s_waitcnt, 2071}, // __builtin_amdgcn_s_waitcnt
-      {Intrinsic::amdgcn_sad_hi_u8, 2098}, // __builtin_amdgcn_sad_hi_u8
-      {Intrinsic::amdgcn_sad_u16, 2125}, // __builtin_amdgcn_sad_u16
-      {Intrinsic::amdgcn_sad_u8, 2150}, // __builtin_amdgcn_sad_u8
-      {Intrinsic::amdgcn_sdot2, 2174}, // __builtin_amdgcn_sdot2
-      {Intrinsic::amdgcn_sdot4, 2197}, // __builtin_amdgcn_sdot4
-      {Intrinsic::amdgcn_sdot8, 2220}, // __builtin_amdgcn_sdot8
-      {Intrinsic::amdgcn_udot2, 2243}, // __builtin_amdgcn_udot2
-      {Intrinsic::amdgcn_udot4, 2266}, // __builtin_amdgcn_udot4
-      {Intrinsic::amdgcn_udot8, 2289}, // __builtin_amdgcn_udot8
-      {Intrinsic::amdgcn_wave_barrier, 2312}, // __builtin_amdgcn_wave_barrier
-      {Intrinsic::amdgcn_wavefrontsize, 2342}, // __builtin_amdgcn_wavefrontsize
-      {Intrinsic::amdgcn_workgroup_id_x, 2373}, // __builtin_amdgcn_workgroup_id_x
-      {Intrinsic::amdgcn_workgroup_id_y, 2405}, // __builtin_amdgcn_workgroup_id_y
-      {Intrinsic::amdgcn_workgroup_id_z, 2437}, // __builtin_amdgcn_workgroup_id_z
-      {Intrinsic::amdgcn_writelane, 2469}, // __builtin_amdgcn_writelane
+      {Intrinsic::amdgcn_alignbyte, 610}, // __builtin_amdgcn_alignbyte
+      {Intrinsic::amdgcn_buffer_wbinvl1, 637}, // __builtin_amdgcn_buffer_wbinvl1
+      {Intrinsic::amdgcn_buffer_wbinvl1_sc, 669}, // __builtin_amdgcn_buffer_wbinvl1_sc
+      {Intrinsic::amdgcn_buffer_wbinvl1_vol, 704}, // __builtin_amdgcn_buffer_wbinvl1_vol
+      {Intrinsic::amdgcn_cubeid, 740}, // __builtin_amdgcn_cubeid
+      {Intrinsic::amdgcn_cubema, 764}, // __builtin_amdgcn_cubema
+      {Intrinsic::amdgcn_cubesc, 788}, // __builtin_amdgcn_cubesc
+      {Intrinsic::amdgcn_cubetc, 812}, // __builtin_amdgcn_cubetc
+      {Intrinsic::amdgcn_cvt_pk_i16, 836}, // __builtin_amdgcn_cvt_pk_i16
+      {Intrinsic::amdgcn_cvt_pk_u16, 864}, // __builtin_amdgcn_cvt_pk_u16
+      {Intrinsic::amdgcn_cvt_pk_u8_f32, 892}, // __builtin_amdgcn_cvt_pk_u8_f32
+      {Intrinsic::amdgcn_cvt_pknorm_i16, 923}, // __builtin_amdgcn_cvt_pknorm_i16
+      {Intrinsic::amdgcn_cvt_pknorm_u16, 955}, // __builtin_amdgcn_cvt_pknorm_u16
+      {Intrinsic::amdgcn_cvt_pkrtz, 987}, // __builtin_amdgcn_cvt_pkrtz
+      {Intrinsic::amdgcn_dispatch_id, 1014}, // __builtin_amdgcn_dispatch_id
+      {Intrinsic::amdgcn_ds_bpermute, 1043}, // __builtin_amdgcn_ds_bpermute
+      {Intrinsic::amdgcn_ds_gws_barrier, 1072}, // __builtin_amdgcn_ds_gws_barrier
+      {Intrinsic::amdgcn_ds_gws_init, 1104}, // __builtin_amdgcn_ds_gws_init
+      {Intrinsic::amdgcn_ds_gws_sema_br, 1133}, // __builtin_amdgcn_ds_gws_sema_br
+      {Intrinsic::amdgcn_ds_gws_sema_p, 1165}, // __builtin_amdgcn_ds_gws_sema_p
+      {Intrinsic::amdgcn_ds_gws_sema_release_all, 1196}, // __builtin_amdgcn_ds_gws_sema_release_all
+      {Intrinsic::amdgcn_ds_gws_sema_v, 1237}, // __builtin_amdgcn_ds_gws_sema_v
+      {Intrinsic::amdgcn_ds_permute, 1268}, // __builtin_amdgcn_ds_permute
+      {Intrinsic::amdgcn_ds_swizzle, 1296}, // __builtin_amdgcn_ds_swizzle
+      {Intrinsic::amdgcn_endpgm, 1324}, // __builtin_amdgcn_endpgm
+      {Intrinsic::amdgcn_fdot2, 1348}, // __builtin_amdgcn_fdot2
+      {Intrinsic::amdgcn_fmed3, 1371}, // __builtin_amdgcn_fmed3
+      {Intrinsic::amdgcn_fmul_legacy, 1394}, // __builtin_amdgcn_fmul_legacy
+      {Intrinsic::amdgcn_groupstaticsize, 1423}, // __builtin_amdgcn_groupstaticsize
+      {Intrinsic::amdgcn_implicit_buffer_ptr, 1456}, // __builtin_amdgcn_implicit_buffer_ptr
+      {Intrinsic::amdgcn_implicitarg_ptr, 1493}, // __builtin_amdgcn_implicitarg_ptr
+      {Intrinsic::amdgcn_interp_mov, 1526}, // __builtin_amdgcn_interp_mov
+      {Intrinsic::amdgcn_interp_p1, 1554}, // __builtin_amdgcn_interp_p1
+      {Intrinsic::amdgcn_interp_p1_f16, 1581}, // __builtin_amdgcn_interp_p1_f16
+      {Intrinsic::amdgcn_interp_p2, 1612}, // __builtin_amdgcn_interp_p2
+      {Intrinsic::amdgcn_interp_p2_f16, 1639}, // __builtin_amdgcn_interp_p2_f16
+      {Intrinsic::amdgcn_is_private, 1670}, // __builtin_amdgcn_is_private
+      {Intrinsic::amdgcn_is_shared, 1698}, // __builtin_amdgcn_is_shared
+      {Intrinsic::amdgcn_kernarg_segment_ptr, 1725}, // __builtin_amdgcn_kernarg_segment_ptr
+      {Intrinsic::amdgcn_lerp, 1762}, // __builtin_amdgcn_lerp
+      {Intrinsic::amdgcn_mbcnt_hi, 1784}, // __builtin_amdgcn_mbcnt_hi
+      {Intrinsic::amdgcn_mbcnt_lo, 1810}, // __builtin_amdgcn_mbcnt_lo
+      {Intrinsic::amdgcn_mfma_f32_16x16x16f16, 1836}, // __builtin_amdgcn_mfma_f32_16x16x16f16
+      {Intrinsic::amdgcn_mfma_f32_16x16x1f32, 1874}, // __builtin_amdgcn_mfma_f32_16x16x1f32
+      {Intrinsic::amdgcn_mfma_f32_16x16x2bf16, 1911}, // __builtin_amdgcn_mfma_f32_16x16x2bf16
+      {Intrinsic::amdgcn_mfma_f32_16x16x4f16, 1949}, // __builtin_amdgcn_mfma_f32_16x16x4f16
+      {Intrinsic::amdgcn_mfma_f32_16x16x4f32, 1986}, // __builtin_amdgcn_mfma_f32_16x16x4f32
+      {Intrinsic::amdgcn_mfma_f32_16x16x8bf16, 2023}, // __builtin_amdgcn_mfma_f32_16x16x8bf16
+      {Intrinsic::amdgcn_mfma_f32_32x32x1f32, 2061}, // __builtin_amdgcn_mfma_f32_32x32x1f32
+      {Intrinsic::amdgcn_mfma_f32_32x32x2bf16, 2098}, // __builtin_amdgcn_mfma_f32_32x32x2bf16
+      {Intrinsic::amdgcn_mfma_f32_32x32x2f32, 2136}, // __builtin_amdgcn_mfma_f32_32x32x2f32
+      {Intrinsic::amdgcn_mfma_f32_32x32x4bf16, 2173}, // __builtin_amdgcn_mfma_f32_32x32x4bf16
+      {Intrinsic::amdgcn_mfma_f32_32x32x4f16, 2211}, // __builtin_amdgcn_mfma_f32_32x32x4f16
+      {Intrinsic::amdgcn_mfma_f32_32x32x8f16, 2248}, // __builtin_amdgcn_mfma_f32_32x32x8f16
+      {Intrinsic::amdgcn_mfma_f32_4x4x1f32, 2285}, // __builtin_amdgcn_mfma_f32_4x4x1f32
+      {Intrinsic::amdgcn_mfma_f32_4x4x2bf16, 2320}, // __builtin_amdgcn_mfma_f32_4x4x2bf16
+      {Intrinsic::amdgcn_mfma_f32_4x4x4f16, 2356}, // __builtin_amdgcn_mfma_f32_4x4x4f16
+      {Intrinsic::amdgcn_mfma_i32_16x16x16i8, 2391}, // __builtin_amdgcn_mfma_i32_16x16x16i8
+      {Intrinsic::amdgcn_mfma_i32_16x16x4i8, 2428}, // __builtin_amdgcn_mfma_i32_16x16x4i8
+      {Intrinsic::amdgcn_mfma_i32_32x32x4i8, 2464}, // __builtin_amdgcn_mfma_i32_32x32x4i8
+      {Intrinsic::amdgcn_mfma_i32_32x32x8i8, 2500}, // __builtin_amdgcn_mfma_i32_32x32x8i8
+      {Intrinsic::amdgcn_mfma_i32_4x4x4i8, 2536}, // __builtin_amdgcn_mfma_i32_4x4x4i8
+      {Intrinsic::amdgcn_mqsad_pk_u16_u8, 2570}, // __builtin_amdgcn_mqsad_pk_u16_u8
+      {Intrinsic::amdgcn_mqsad_u32_u8, 2603}, // __builtin_amdgcn_mqsad_u32_u8
+      {Intrinsic::amdgcn_msad_u8, 2633}, // __builtin_amdgcn_msad_u8
+      {Intrinsic::amdgcn_permlane16, 2658}, // __builtin_amdgcn_permlane16
+      {Intrinsic::amdgcn_permlanex16, 2686}, // __builtin_amdgcn_permlanex16
+      {Intrinsic::amdgcn_qsad_pk_u16_u8, 2715}, // __builtin_amdgcn_qsad_pk_u16_u8
+      {Intrinsic::amdgcn_queue_ptr, 2747}, // __builtin_amdgcn_queue_ptr
+      {Intrinsic::amdgcn_rcp_legacy, 2774}, // __builtin_amdgcn_rcp_legacy
+      {Intrinsic::amdgcn_readfirstlane, 2802}, // __builtin_amdgcn_readfirstlane
+      {Intrinsic::amdgcn_readlane, 2833}, // __builtin_amdgcn_readlane
+      {Intrinsic::amdgcn_rsq_legacy, 2859}, // __builtin_amdgcn_rsq_legacy
+      {Intrinsic::amdgcn_s_barrier, 2887}, // __builtin_amdgcn_s_barrier
+      {Intrinsic::amdgcn_s_dcache_inv, 2914}, // __builtin_amdgcn_s_dcache_inv
+      {Intrinsic::amdgcn_s_dcache_inv_vol, 2944}, // __builtin_amdgcn_s_dcache_inv_vol
+      {Intrinsic::amdgcn_s_dcache_wb, 2978}, // __builtin_amdgcn_s_dcache_wb
+      {Intrinsic::amdgcn_s_dcache_wb_vol, 3007}, // __builtin_amdgcn_s_dcache_wb_vol
+      {Intrinsic::amdgcn_s_decperflevel, 3040}, // __builtin_amdgcn_s_decperflevel
+      {Intrinsic::amdgcn_s_get_waveid_in_workgroup, 3072}, // __builtin_amdgcn_s_get_waveid_in_workgroup
+      {Intrinsic::amdgcn_s_getpc, 3115}, // __builtin_amdgcn_s_getpc
+      {Intrinsic::amdgcn_s_getreg, 3140}, // __builtin_amdgcn_s_getreg
+      {Intrinsic::amdgcn_s_incperflevel, 3166}, // __builtin_amdgcn_s_incperflevel
+      {Intrinsic::amdgcn_s_memrealtime, 3198}, // __builtin_amdgcn_s_memrealtime
+      {Intrinsic::amdgcn_s_memtime, 3229}, // __builtin_amdgcn_s_memtime
+      {Intrinsic::amdgcn_s_sendmsg, 3256}, // __builtin_amdgcn_s_sendmsg
+      {Intrinsic::amdgcn_s_sendmsghalt, 3283}, // __builtin_amdgcn_s_sendmsghalt
+      {Intrinsic::amdgcn_s_setreg, 3314}, // __builtin_amdgcn_s_setreg
+      {Intrinsic::amdgcn_s_sleep, 3340}, // __builtin_amdgcn_s_sleep
+      {Intrinsic::amdgcn_s_waitcnt, 3365}, // __builtin_amdgcn_s_waitcnt
+      {Intrinsic::amdgcn_sad_hi_u8, 3392}, // __builtin_amdgcn_sad_hi_u8
+      {Intrinsic::amdgcn_sad_u16, 3419}, // __builtin_amdgcn_sad_u16
+      {Intrinsic::amdgcn_sad_u8, 3444}, // __builtin_amdgcn_sad_u8
+      {Intrinsic::amdgcn_sdot2, 3468}, // __builtin_amdgcn_sdot2
+      {Intrinsic::amdgcn_sdot4, 3491}, // __builtin_amdgcn_sdot4
+      {Intrinsic::amdgcn_sdot8, 3514}, // __builtin_amdgcn_sdot8
+      {Intrinsic::amdgcn_udot2, 3537}, // __builtin_amdgcn_udot2
+      {Intrinsic::amdgcn_udot4, 3560}, // __builtin_amdgcn_udot4
+      {Intrinsic::amdgcn_udot8, 3583}, // __builtin_amdgcn_udot8
+      {Intrinsic::amdgcn_wave_barrier, 3606}, // __builtin_amdgcn_wave_barrier
+      {Intrinsic::amdgcn_wavefrontsize, 3636}, // __builtin_amdgcn_wavefrontsize
+      {Intrinsic::amdgcn_workgroup_id_x, 3667}, // __builtin_amdgcn_workgroup_id_x
+      {Intrinsic::amdgcn_workgroup_id_y, 3699}, // __builtin_amdgcn_workgroup_id_y
+      {Intrinsic::amdgcn_workgroup_id_z, 3731}, // __builtin_amdgcn_workgroup_id_z
+      {Intrinsic::amdgcn_writelane, 3763}, // __builtin_amdgcn_writelane
     };
     auto I = std::lower_bound(std::begin(amdgcnNames),
                               std::end(amdgcnNames),
@@ -26565,102 +35862,102 @@
   }
   if (TargetPrefix == "arm") {
     static const BuiltinEntry armNames[] = {
-      {Intrinsic::arm_cdp, 2496}, // __builtin_arm_cdp
-      {Intrinsic::arm_cdp2, 2514}, // __builtin_arm_cdp2
-      {Intrinsic::arm_cmse_tt, 2533}, // __builtin_arm_cmse_TT
-      {Intrinsic::arm_cmse_tta, 2555}, // __builtin_arm_cmse_TTA
-      {Intrinsic::arm_cmse_ttat, 2578}, // __builtin_arm_cmse_TTAT
-      {Intrinsic::arm_cmse_ttt, 2602}, // __builtin_arm_cmse_TTT
-      {Intrinsic::arm_dmb, 224}, // __builtin_arm_dmb
-      {Intrinsic::arm_dsb, 242}, // __builtin_arm_dsb
-      {Intrinsic::arm_get_fpscr, 2625}, // __builtin_arm_get_fpscr
-      {Intrinsic::arm_isb, 260}, // __builtin_arm_isb
-      {Intrinsic::arm_ldc, 2649}, // __builtin_arm_ldc
-      {Intrinsic::arm_ldc2, 2667}, // __builtin_arm_ldc2
-      {Intrinsic::arm_ldc2l, 2686}, // __builtin_arm_ldc2l
-      {Intrinsic::arm_ldcl, 2706}, // __builtin_arm_ldcl
-      {Intrinsic::arm_mcr, 2725}, // __builtin_arm_mcr
-      {Intrinsic::arm_mcr2, 2743}, // __builtin_arm_mcr2
-      {Intrinsic::arm_mrc, 2762}, // __builtin_arm_mrc
-      {Intrinsic::arm_mrc2, 2780}, // __builtin_arm_mrc2
-      {Intrinsic::arm_qadd, 2799}, // __builtin_arm_qadd
-      {Intrinsic::arm_qadd16, 2818}, // __builtin_arm_qadd16
-      {Intrinsic::arm_qadd8, 2839}, // __builtin_arm_qadd8
-      {Intrinsic::arm_qasx, 2859}, // __builtin_arm_qasx
-      {Intrinsic::arm_qsax, 2878}, // __builtin_arm_qsax
-      {Intrinsic::arm_qsub, 2897}, // __builtin_arm_qsub
-      {Intrinsic::arm_qsub16, 2916}, // __builtin_arm_qsub16
-      {Intrinsic::arm_qsub8, 2937}, // __builtin_arm_qsub8
-      {Intrinsic::arm_sadd16, 2957}, // __builtin_arm_sadd16
-      {Intrinsic::arm_sadd8, 2978}, // __builtin_arm_sadd8
-      {Intrinsic::arm_sasx, 2998}, // __builtin_arm_sasx
-      {Intrinsic::arm_sel, 3017}, // __builtin_arm_sel
-      {Intrinsic::arm_set_fpscr, 3035}, // __builtin_arm_set_fpscr
-      {Intrinsic::arm_shadd16, 3059}, // __builtin_arm_shadd16
-      {Intrinsic::arm_shadd8, 3081}, // __builtin_arm_shadd8
-      {Intrinsic::arm_shasx, 3102}, // __builtin_arm_shasx
-      {Intrinsic::arm_shsax, 3122}, // __builtin_arm_shsax
-      {Intrinsic::arm_shsub16, 3142}, // __builtin_arm_shsub16
-      {Intrinsic::arm_shsub8, 3164}, // __builtin_arm_shsub8
-      {Intrinsic::arm_smlabb, 3185}, // __builtin_arm_smlabb
-      {Intrinsic::arm_smlabt, 3206}, // __builtin_arm_smlabt
-      {Intrinsic::arm_smlad, 3227}, // __builtin_arm_smlad
-      {Intrinsic::arm_smladx, 3247}, // __builtin_arm_smladx
-      {Intrinsic::arm_smlald, 3268}, // __builtin_arm_smlald
-      {Intrinsic::arm_smlaldx, 3289}, // __builtin_arm_smlaldx
-      {Intrinsic::arm_smlatb, 3311}, // __builtin_arm_smlatb
-      {Intrinsic::arm_smlatt, 3332}, // __builtin_arm_smlatt
-      {Intrinsic::arm_smlawb, 3353}, // __builtin_arm_smlawb
-      {Intrinsic::arm_smlawt, 3374}, // __builtin_arm_smlawt
-      {Intrinsic::arm_smlsd, 3395}, // __builtin_arm_smlsd
-      {Intrinsic::arm_smlsdx, 3415}, // __builtin_arm_smlsdx
-      {Intrinsic::arm_smlsld, 3436}, // __builtin_arm_smlsld
-      {Intrinsic::arm_smlsldx, 3457}, // __builtin_arm_smlsldx
-      {Intrinsic::arm_smuad, 3479}, // __builtin_arm_smuad
-      {Intrinsic::arm_smuadx, 3499}, // __builtin_arm_smuadx
-      {Intrinsic::arm_smulbb, 3520}, // __builtin_arm_smulbb
-      {Intrinsic::arm_smulbt, 3541}, // __builtin_arm_smulbt
-      {Intrinsic::arm_smultb, 3562}, // __builtin_arm_smultb
-      {Intrinsic::arm_smultt, 3583}, // __builtin_arm_smultt
-      {Intrinsic::arm_smulwb, 3604}, // __builtin_arm_smulwb
-      {Intrinsic::arm_smulwt, 3625}, // __builtin_arm_smulwt
-      {Intrinsic::arm_smusd, 3646}, // __builtin_arm_smusd
-      {Intrinsic::arm_smusdx, 3666}, // __builtin_arm_smusdx
-      {Intrinsic::arm_ssat, 3687}, // __builtin_arm_ssat
-      {Intrinsic::arm_ssat16, 3706}, // __builtin_arm_ssat16
-      {Intrinsic::arm_ssax, 3727}, // __builtin_arm_ssax
-      {Intrinsic::arm_ssub16, 3746}, // __builtin_arm_ssub16
-      {Intrinsic::arm_ssub8, 3767}, // __builtin_arm_ssub8
-      {Intrinsic::arm_stc, 3787}, // __builtin_arm_stc
-      {Intrinsic::arm_stc2, 3805}, // __builtin_arm_stc2
-      {Intrinsic::arm_stc2l, 3824}, // __builtin_arm_stc2l
-      {Intrinsic::arm_stcl, 3844}, // __builtin_arm_stcl
-      {Intrinsic::arm_sxtab16, 3863}, // __builtin_arm_sxtab16
-      {Intrinsic::arm_sxtb16, 3885}, // __builtin_arm_sxtb16
-      {Intrinsic::arm_uadd16, 3906}, // __builtin_arm_uadd16
-      {Intrinsic::arm_uadd8, 3927}, // __builtin_arm_uadd8
-      {Intrinsic::arm_uasx, 3947}, // __builtin_arm_uasx
-      {Intrinsic::arm_uhadd16, 3966}, // __builtin_arm_uhadd16
-      {Intrinsic::arm_uhadd8, 3988}, // __builtin_arm_uhadd8
-      {Intrinsic::arm_uhasx, 4009}, // __builtin_arm_uhasx
-      {Intrinsic::arm_uhsax, 4029}, // __builtin_arm_uhsax
-      {Intrinsic::arm_uhsub16, 4049}, // __builtin_arm_uhsub16
-      {Intrinsic::arm_uhsub8, 4071}, // __builtin_arm_uhsub8
-      {Intrinsic::arm_uqadd16, 4092}, // __builtin_arm_uqadd16
-      {Intrinsic::arm_uqadd8, 4114}, // __builtin_arm_uqadd8
-      {Intrinsic::arm_uqasx, 4135}, // __builtin_arm_uqasx
-      {Intrinsic::arm_uqsax, 4155}, // __builtin_arm_uqsax
-      {Intrinsic::arm_uqsub16, 4175}, // __builtin_arm_uqsub16
-      {Intrinsic::arm_uqsub8, 4197}, // __builtin_arm_uqsub8
-      {Intrinsic::arm_usad8, 4218}, // __builtin_arm_usad8
-      {Intrinsic::arm_usada8, 4238}, // __builtin_arm_usada8
-      {Intrinsic::arm_usat, 4259}, // __builtin_arm_usat
-      {Intrinsic::arm_usat16, 4278}, // __builtin_arm_usat16
-      {Intrinsic::arm_usax, 4299}, // __builtin_arm_usax
-      {Intrinsic::arm_usub16, 4318}, // __builtin_arm_usub16
-      {Intrinsic::arm_usub8, 4339}, // __builtin_arm_usub8
-      {Intrinsic::arm_uxtab16, 4359}, // __builtin_arm_uxtab16
-      {Intrinsic::arm_uxtb16, 4381}, // __builtin_arm_uxtb16
+      {Intrinsic::arm_cdp, 3790}, // __builtin_arm_cdp
+      {Intrinsic::arm_cdp2, 3808}, // __builtin_arm_cdp2
+      {Intrinsic::arm_cmse_tt, 3827}, // __builtin_arm_cmse_TT
+      {Intrinsic::arm_cmse_tta, 3849}, // __builtin_arm_cmse_TTA
+      {Intrinsic::arm_cmse_ttat, 3872}, // __builtin_arm_cmse_TTAT
+      {Intrinsic::arm_cmse_ttt, 3896}, // __builtin_arm_cmse_TTT
+      {Intrinsic::arm_dmb, 203}, // __builtin_arm_dmb
+      {Intrinsic::arm_dsb, 221}, // __builtin_arm_dsb
+      {Intrinsic::arm_get_fpscr, 3919}, // __builtin_arm_get_fpscr
+      {Intrinsic::arm_isb, 239}, // __builtin_arm_isb
+      {Intrinsic::arm_ldc, 3943}, // __builtin_arm_ldc
+      {Intrinsic::arm_ldc2, 3961}, // __builtin_arm_ldc2
+      {Intrinsic::arm_ldc2l, 3980}, // __builtin_arm_ldc2l
+      {Intrinsic::arm_ldcl, 4000}, // __builtin_arm_ldcl
+      {Intrinsic::arm_mcr, 4019}, // __builtin_arm_mcr
+      {Intrinsic::arm_mcr2, 4037}, // __builtin_arm_mcr2
+      {Intrinsic::arm_mrc, 4056}, // __builtin_arm_mrc
+      {Intrinsic::arm_mrc2, 4074}, // __builtin_arm_mrc2
+      {Intrinsic::arm_qadd, 4093}, // __builtin_arm_qadd
+      {Intrinsic::arm_qadd16, 4112}, // __builtin_arm_qadd16
+      {Intrinsic::arm_qadd8, 4133}, // __builtin_arm_qadd8
+      {Intrinsic::arm_qasx, 4153}, // __builtin_arm_qasx
+      {Intrinsic::arm_qsax, 4172}, // __builtin_arm_qsax
+      {Intrinsic::arm_qsub, 4191}, // __builtin_arm_qsub
+      {Intrinsic::arm_qsub16, 4210}, // __builtin_arm_qsub16
+      {Intrinsic::arm_qsub8, 4231}, // __builtin_arm_qsub8
+      {Intrinsic::arm_sadd16, 4251}, // __builtin_arm_sadd16
+      {Intrinsic::arm_sadd8, 4272}, // __builtin_arm_sadd8
+      {Intrinsic::arm_sasx, 4292}, // __builtin_arm_sasx
+      {Intrinsic::arm_sel, 4311}, // __builtin_arm_sel
+      {Intrinsic::arm_set_fpscr, 4329}, // __builtin_arm_set_fpscr
+      {Intrinsic::arm_shadd16, 4353}, // __builtin_arm_shadd16
+      {Intrinsic::arm_shadd8, 4375}, // __builtin_arm_shadd8
+      {Intrinsic::arm_shasx, 4396}, // __builtin_arm_shasx
+      {Intrinsic::arm_shsax, 4416}, // __builtin_arm_shsax
+      {Intrinsic::arm_shsub16, 4436}, // __builtin_arm_shsub16
+      {Intrinsic::arm_shsub8, 4458}, // __builtin_arm_shsub8
+      {Intrinsic::arm_smlabb, 4479}, // __builtin_arm_smlabb
+      {Intrinsic::arm_smlabt, 4500}, // __builtin_arm_smlabt
+      {Intrinsic::arm_smlad, 4521}, // __builtin_arm_smlad
+      {Intrinsic::arm_smladx, 4541}, // __builtin_arm_smladx
+      {Intrinsic::arm_smlald, 4562}, // __builtin_arm_smlald
+      {Intrinsic::arm_smlaldx, 4583}, // __builtin_arm_smlaldx
+      {Intrinsic::arm_smlatb, 4605}, // __builtin_arm_smlatb
+      {Intrinsic::arm_smlatt, 4626}, // __builtin_arm_smlatt
+      {Intrinsic::arm_smlawb, 4647}, // __builtin_arm_smlawb
+      {Intrinsic::arm_smlawt, 4668}, // __builtin_arm_smlawt
+      {Intrinsic::arm_smlsd, 4689}, // __builtin_arm_smlsd
+      {Intrinsic::arm_smlsdx, 4709}, // __builtin_arm_smlsdx
+      {Intrinsic::arm_smlsld, 4730}, // __builtin_arm_smlsld
+      {Intrinsic::arm_smlsldx, 4751}, // __builtin_arm_smlsldx
+      {Intrinsic::arm_smuad, 4773}, // __builtin_arm_smuad
+      {Intrinsic::arm_smuadx, 4793}, // __builtin_arm_smuadx
+      {Intrinsic::arm_smulbb, 4814}, // __builtin_arm_smulbb
+      {Intrinsic::arm_smulbt, 4835}, // __builtin_arm_smulbt
+      {Intrinsic::arm_smultb, 4856}, // __builtin_arm_smultb
+      {Intrinsic::arm_smultt, 4877}, // __builtin_arm_smultt
+      {Intrinsic::arm_smulwb, 4898}, // __builtin_arm_smulwb
+      {Intrinsic::arm_smulwt, 4919}, // __builtin_arm_smulwt
+      {Intrinsic::arm_smusd, 4940}, // __builtin_arm_smusd
+      {Intrinsic::arm_smusdx, 4960}, // __builtin_arm_smusdx
+      {Intrinsic::arm_ssat, 4981}, // __builtin_arm_ssat
+      {Intrinsic::arm_ssat16, 5000}, // __builtin_arm_ssat16
+      {Intrinsic::arm_ssax, 5021}, // __builtin_arm_ssax
+      {Intrinsic::arm_ssub16, 5040}, // __builtin_arm_ssub16
+      {Intrinsic::arm_ssub8, 5061}, // __builtin_arm_ssub8
+      {Intrinsic::arm_stc, 5081}, // __builtin_arm_stc
+      {Intrinsic::arm_stc2, 5099}, // __builtin_arm_stc2
+      {Intrinsic::arm_stc2l, 5118}, // __builtin_arm_stc2l
+      {Intrinsic::arm_stcl, 5138}, // __builtin_arm_stcl
+      {Intrinsic::arm_sxtab16, 5157}, // __builtin_arm_sxtab16
+      {Intrinsic::arm_sxtb16, 5179}, // __builtin_arm_sxtb16
+      {Intrinsic::arm_uadd16, 5200}, // __builtin_arm_uadd16
+      {Intrinsic::arm_uadd8, 5221}, // __builtin_arm_uadd8
+      {Intrinsic::arm_uasx, 5241}, // __builtin_arm_uasx
+      {Intrinsic::arm_uhadd16, 5260}, // __builtin_arm_uhadd16
+      {Intrinsic::arm_uhadd8, 5282}, // __builtin_arm_uhadd8
+      {Intrinsic::arm_uhasx, 5303}, // __builtin_arm_uhasx
+      {Intrinsic::arm_uhsax, 5323}, // __builtin_arm_uhsax
+      {Intrinsic::arm_uhsub16, 5343}, // __builtin_arm_uhsub16
+      {Intrinsic::arm_uhsub8, 5365}, // __builtin_arm_uhsub8
+      {Intrinsic::arm_uqadd16, 5386}, // __builtin_arm_uqadd16
+      {Intrinsic::arm_uqadd8, 5408}, // __builtin_arm_uqadd8
+      {Intrinsic::arm_uqasx, 5429}, // __builtin_arm_uqasx
+      {Intrinsic::arm_uqsax, 5449}, // __builtin_arm_uqsax
+      {Intrinsic::arm_uqsub16, 5469}, // __builtin_arm_uqsub16
+      {Intrinsic::arm_uqsub8, 5491}, // __builtin_arm_uqsub8
+      {Intrinsic::arm_usad8, 5512}, // __builtin_arm_usad8
+      {Intrinsic::arm_usada8, 5532}, // __builtin_arm_usada8
+      {Intrinsic::arm_usat, 5553}, // __builtin_arm_usat
+      {Intrinsic::arm_usat16, 5572}, // __builtin_arm_usat16
+      {Intrinsic::arm_usax, 5593}, // __builtin_arm_usax
+      {Intrinsic::arm_usub16, 5612}, // __builtin_arm_usub16
+      {Intrinsic::arm_usub8, 5633}, // __builtin_arm_usub8
+      {Intrinsic::arm_uxtab16, 5653}, // __builtin_arm_uxtab16
+      {Intrinsic::arm_uxtb16, 5675}, // __builtin_arm_uxtb16
     };
     auto I = std::lower_bound(std::begin(armNames),
                               std::end(armNames),
@@ -26671,10 +35968,15 @@
   }
   if (TargetPrefix == "bpf") {
     static const BuiltinEntry bpfNames[] = {
-      {Intrinsic::bpf_load_byte, 4402}, // __builtin_bpf_load_byte
-      {Intrinsic::bpf_load_half, 4426}, // __builtin_bpf_load_half
-      {Intrinsic::bpf_load_word, 4450}, // __builtin_bpf_load_word
-      {Intrinsic::bpf_pseudo, 4474}, // __builtin_bpf_pseudo
+      {Intrinsic::bpf_btf_type_id, 5696}, // __builtin_bpf_btf_type_id
+      {Intrinsic::bpf_load_byte, 5722}, // __builtin_bpf_load_byte
+      {Intrinsic::bpf_load_half, 5746}, // __builtin_bpf_load_half
+      {Intrinsic::bpf_load_word, 5770}, // __builtin_bpf_load_word
+      {Intrinsic::bpf_passthrough, 5794}, // __builtin_bpf_passthrough
+      {Intrinsic::bpf_preserve_enum_value, 5820}, // __builtin_bpf_preserve_enum_value
+      {Intrinsic::bpf_preserve_field_info, 5854}, // __builtin_bpf_preserve_field_info
+      {Intrinsic::bpf_preserve_type_info, 5888}, // __builtin_bpf_preserve_type_info
+      {Intrinsic::bpf_pseudo, 5921}, // __builtin_bpf_pseudo
     };
     auto I = std::lower_bound(std::begin(bpfNames),
                               std::end(bpfNames),
@@ -26685,1740 +35987,1550 @@
   }
   if (TargetPrefix == "hexagon") {
     static const BuiltinEntry hexagonNames[] = {
-      {Intrinsic::hexagon_A2_abs, 4495}, // __builtin_HEXAGON_A2_abs
-      {Intrinsic::hexagon_A2_absp, 4520}, // __builtin_HEXAGON_A2_absp
-      {Intrinsic::hexagon_A2_abssat, 4546}, // __builtin_HEXAGON_A2_abssat
-      {Intrinsic::hexagon_A2_add, 4574}, // __builtin_HEXAGON_A2_add
-      {Intrinsic::hexagon_A2_addh_h16_hh, 4599}, // __builtin_HEXAGON_A2_addh_h16_hh
-      {Intrinsic::hexagon_A2_addh_h16_hl, 4632}, // __builtin_HEXAGON_A2_addh_h16_hl
-      {Intrinsic::hexagon_A2_addh_h16_lh, 4665}, // __builtin_HEXAGON_A2_addh_h16_lh
-      {Intrinsic::hexagon_A2_addh_h16_ll, 4698}, // __builtin_HEXAGON_A2_addh_h16_ll
-      {Intrinsic::hexagon_A2_addh_h16_sat_hh, 4731}, // __builtin_HEXAGON_A2_addh_h16_sat_hh
-      {Intrinsic::hexagon_A2_addh_h16_sat_hl, 4768}, // __builtin_HEXAGON_A2_addh_h16_sat_hl
-      {Intrinsic::hexagon_A2_addh_h16_sat_lh, 4805}, // __builtin_HEXAGON_A2_addh_h16_sat_lh
-      {Intrinsic::hexagon_A2_addh_h16_sat_ll, 4842}, // __builtin_HEXAGON_A2_addh_h16_sat_ll
-      {Intrinsic::hexagon_A2_addh_l16_hl, 4879}, // __builtin_HEXAGON_A2_addh_l16_hl
-      {Intrinsic::hexagon_A2_addh_l16_ll, 4912}, // __builtin_HEXAGON_A2_addh_l16_ll
-      {Intrinsic::hexagon_A2_addh_l16_sat_hl, 4945}, // __builtin_HEXAGON_A2_addh_l16_sat_hl
-      {Intrinsic::hexagon_A2_addh_l16_sat_ll, 4982}, // __builtin_HEXAGON_A2_addh_l16_sat_ll
-      {Intrinsic::hexagon_A2_addi, 5019}, // __builtin_HEXAGON_A2_addi
-      {Intrinsic::hexagon_A2_addp, 5045}, // __builtin_HEXAGON_A2_addp
-      {Intrinsic::hexagon_A2_addpsat, 5071}, // __builtin_HEXAGON_A2_addpsat
-      {Intrinsic::hexagon_A2_addsat, 5100}, // __builtin_HEXAGON_A2_addsat
-      {Intrinsic::hexagon_A2_addsp, 5128}, // __builtin_HEXAGON_A2_addsp
-      {Intrinsic::hexagon_A2_and, 5155}, // __builtin_HEXAGON_A2_and
-      {Intrinsic::hexagon_A2_andir, 5180}, // __builtin_HEXAGON_A2_andir
-      {Intrinsic::hexagon_A2_andp, 5207}, // __builtin_HEXAGON_A2_andp
-      {Intrinsic::hexagon_A2_aslh, 5233}, // __builtin_HEXAGON_A2_aslh
-      {Intrinsic::hexagon_A2_asrh, 5259}, // __builtin_HEXAGON_A2_asrh
-      {Intrinsic::hexagon_A2_combine_hh, 5285}, // __builtin_HEXAGON_A2_combine_hh
-      {Intrinsic::hexagon_A2_combine_hl, 5317}, // __builtin_HEXAGON_A2_combine_hl
-      {Intrinsic::hexagon_A2_combine_lh, 5349}, // __builtin_HEXAGON_A2_combine_lh
-      {Intrinsic::hexagon_A2_combine_ll, 5381}, // __builtin_HEXAGON_A2_combine_ll
-      {Intrinsic::hexagon_A2_combineii, 5413}, // __builtin_HEXAGON_A2_combineii
-      {Intrinsic::hexagon_A2_combinew, 5444}, // __builtin_HEXAGON_A2_combinew
-      {Intrinsic::hexagon_A2_max, 5474}, // __builtin_HEXAGON_A2_max
-      {Intrinsic::hexagon_A2_maxp, 5499}, // __builtin_HEXAGON_A2_maxp
-      {Intrinsic::hexagon_A2_maxu, 5525}, // __builtin_HEXAGON_A2_maxu
-      {Intrinsic::hexagon_A2_maxup, 5551}, // __builtin_HEXAGON_A2_maxup
-      {Intrinsic::hexagon_A2_min, 5578}, // __builtin_HEXAGON_A2_min
-      {Intrinsic::hexagon_A2_minp, 5603}, // __builtin_HEXAGON_A2_minp
-      {Intrinsic::hexagon_A2_minu, 5629}, // __builtin_HEXAGON_A2_minu
-      {Intrinsic::hexagon_A2_minup, 5655}, // __builtin_HEXAGON_A2_minup
-      {Intrinsic::hexagon_A2_neg, 5682}, // __builtin_HEXAGON_A2_neg
-      {Intrinsic::hexagon_A2_negp, 5707}, // __builtin_HEXAGON_A2_negp
-      {Intrinsic::hexagon_A2_negsat, 5733}, // __builtin_HEXAGON_A2_negsat
-      {Intrinsic::hexagon_A2_not, 5761}, // __builtin_HEXAGON_A2_not
-      {Intrinsic::hexagon_A2_notp, 5786}, // __builtin_HEXAGON_A2_notp
-      {Intrinsic::hexagon_A2_or, 5812}, // __builtin_HEXAGON_A2_or
-      {Intrinsic::hexagon_A2_orir, 5836}, // __builtin_HEXAGON_A2_orir
-      {Intrinsic::hexagon_A2_orp, 5862}, // __builtin_HEXAGON_A2_orp
-      {Intrinsic::hexagon_A2_pxorf, 5887}, // __builtin_HEXAGON_A2_pxorf
-      {Intrinsic::hexagon_A2_roundsat, 5914}, // __builtin_HEXAGON_A2_roundsat
-      {Intrinsic::hexagon_A2_sat, 5944}, // __builtin_HEXAGON_A2_sat
-      {Intrinsic::hexagon_A2_satb, 5969}, // __builtin_HEXAGON_A2_satb
-      {Intrinsic::hexagon_A2_sath, 5995}, // __builtin_HEXAGON_A2_sath
-      {Intrinsic::hexagon_A2_satub, 6021}, // __builtin_HEXAGON_A2_satub
-      {Intrinsic::hexagon_A2_satuh, 6048}, // __builtin_HEXAGON_A2_satuh
-      {Intrinsic::hexagon_A2_sub, 6075}, // __builtin_HEXAGON_A2_sub
-      {Intrinsic::hexagon_A2_subh_h16_hh, 6100}, // __builtin_HEXAGON_A2_subh_h16_hh
-      {Intrinsic::hexagon_A2_subh_h16_hl, 6133}, // __builtin_HEXAGON_A2_subh_h16_hl
-      {Intrinsic::hexagon_A2_subh_h16_lh, 6166}, // __builtin_HEXAGON_A2_subh_h16_lh
-      {Intrinsic::hexagon_A2_subh_h16_ll, 6199}, // __builtin_HEXAGON_A2_subh_h16_ll
-      {Intrinsic::hexagon_A2_subh_h16_sat_hh, 6232}, // __builtin_HEXAGON_A2_subh_h16_sat_hh
-      {Intrinsic::hexagon_A2_subh_h16_sat_hl, 6269}, // __builtin_HEXAGON_A2_subh_h16_sat_hl
-      {Intrinsic::hexagon_A2_subh_h16_sat_lh, 6306}, // __builtin_HEXAGON_A2_subh_h16_sat_lh
-      {Intrinsic::hexagon_A2_subh_h16_sat_ll, 6343}, // __builtin_HEXAGON_A2_subh_h16_sat_ll
-      {Intrinsic::hexagon_A2_subh_l16_hl, 6380}, // __builtin_HEXAGON_A2_subh_l16_hl
-      {Intrinsic::hexagon_A2_subh_l16_ll, 6413}, // __builtin_HEXAGON_A2_subh_l16_ll
-      {Intrinsic::hexagon_A2_subh_l16_sat_hl, 6446}, // __builtin_HEXAGON_A2_subh_l16_sat_hl
-      {Intrinsic::hexagon_A2_subh_l16_sat_ll, 6483}, // __builtin_HEXAGON_A2_subh_l16_sat_ll
-      {Intrinsic::hexagon_A2_subp, 6520}, // __builtin_HEXAGON_A2_subp
-      {Intrinsic::hexagon_A2_subri, 6546}, // __builtin_HEXAGON_A2_subri
-      {Intrinsic::hexagon_A2_subsat, 6573}, // __builtin_HEXAGON_A2_subsat
-      {Intrinsic::hexagon_A2_svaddh, 6601}, // __builtin_HEXAGON_A2_svaddh
-      {Intrinsic::hexagon_A2_svaddhs, 6629}, // __builtin_HEXAGON_A2_svaddhs
-      {Intrinsic::hexagon_A2_svadduhs, 6658}, // __builtin_HEXAGON_A2_svadduhs
-      {Intrinsic::hexagon_A2_svavgh, 6688}, // __builtin_HEXAGON_A2_svavgh
-      {Intrinsic::hexagon_A2_svavghs, 6716}, // __builtin_HEXAGON_A2_svavghs
-      {Intrinsic::hexagon_A2_svnavgh, 6745}, // __builtin_HEXAGON_A2_svnavgh
-      {Intrinsic::hexagon_A2_svsubh, 6774}, // __builtin_HEXAGON_A2_svsubh
-      {Intrinsic::hexagon_A2_svsubhs, 6802}, // __builtin_HEXAGON_A2_svsubhs
-      {Intrinsic::hexagon_A2_svsubuhs, 6831}, // __builtin_HEXAGON_A2_svsubuhs
-      {Intrinsic::hexagon_A2_swiz, 6861}, // __builtin_HEXAGON_A2_swiz
-      {Intrinsic::hexagon_A2_sxtb, 6887}, // __builtin_HEXAGON_A2_sxtb
-      {Intrinsic::hexagon_A2_sxth, 6913}, // __builtin_HEXAGON_A2_sxth
-      {Intrinsic::hexagon_A2_sxtw, 6939}, // __builtin_HEXAGON_A2_sxtw
-      {Intrinsic::hexagon_A2_tfr, 6965}, // __builtin_HEXAGON_A2_tfr
-      {Intrinsic::hexagon_A2_tfrcrr, 6990}, // __builtin_HEXAGON_A2_tfrcrr
-      {Intrinsic::hexagon_A2_tfrih, 7018}, // __builtin_HEXAGON_A2_tfrih
-      {Intrinsic::hexagon_A2_tfril, 7045}, // __builtin_HEXAGON_A2_tfril
-      {Intrinsic::hexagon_A2_tfrp, 7072}, // __builtin_HEXAGON_A2_tfrp
-      {Intrinsic::hexagon_A2_tfrpi, 7098}, // __builtin_HEXAGON_A2_tfrpi
-      {Intrinsic::hexagon_A2_tfrrcr, 7125}, // __builtin_HEXAGON_A2_tfrrcr
-      {Intrinsic::hexagon_A2_tfrsi, 7153}, // __builtin_HEXAGON_A2_tfrsi
-      {Intrinsic::hexagon_A2_vabsh, 7180}, // __builtin_HEXAGON_A2_vabsh
-      {Intrinsic::hexagon_A2_vabshsat, 7207}, // __builtin_HEXAGON_A2_vabshsat
-      {Intrinsic::hexagon_A2_vabsw, 7237}, // __builtin_HEXAGON_A2_vabsw
-      {Intrinsic::hexagon_A2_vabswsat, 7264}, // __builtin_HEXAGON_A2_vabswsat
-      {Intrinsic::hexagon_A2_vaddb_map, 7294}, // __builtin_HEXAGON_A2_vaddb_map
-      {Intrinsic::hexagon_A2_vaddh, 7325}, // __builtin_HEXAGON_A2_vaddh
-      {Intrinsic::hexagon_A2_vaddhs, 7352}, // __builtin_HEXAGON_A2_vaddhs
-      {Intrinsic::hexagon_A2_vaddub, 7380}, // __builtin_HEXAGON_A2_vaddub
-      {Intrinsic::hexagon_A2_vaddubs, 7408}, // __builtin_HEXAGON_A2_vaddubs
-      {Intrinsic::hexagon_A2_vadduhs, 7437}, // __builtin_HEXAGON_A2_vadduhs
-      {Intrinsic::hexagon_A2_vaddw, 7466}, // __builtin_HEXAGON_A2_vaddw
-      {Intrinsic::hexagon_A2_vaddws, 7493}, // __builtin_HEXAGON_A2_vaddws
-      {Intrinsic::hexagon_A2_vavgh, 7521}, // __builtin_HEXAGON_A2_vavgh
-      {Intrinsic::hexagon_A2_vavghcr, 7548}, // __builtin_HEXAGON_A2_vavghcr
-      {Intrinsic::hexagon_A2_vavghr, 7577}, // __builtin_HEXAGON_A2_vavghr
-      {Intrinsic::hexagon_A2_vavgub, 7605}, // __builtin_HEXAGON_A2_vavgub
-      {Intrinsic::hexagon_A2_vavgubr, 7633}, // __builtin_HEXAGON_A2_vavgubr
-      {Intrinsic::hexagon_A2_vavguh, 7662}, // __builtin_HEXAGON_A2_vavguh
-      {Intrinsic::hexagon_A2_vavguhr, 7690}, // __builtin_HEXAGON_A2_vavguhr
-      {Intrinsic::hexagon_A2_vavguw, 7719}, // __builtin_HEXAGON_A2_vavguw
-      {Intrinsic::hexagon_A2_vavguwr, 7747}, // __builtin_HEXAGON_A2_vavguwr
-      {Intrinsic::hexagon_A2_vavgw, 7776}, // __builtin_HEXAGON_A2_vavgw
-      {Intrinsic::hexagon_A2_vavgwcr, 7803}, // __builtin_HEXAGON_A2_vavgwcr
-      {Intrinsic::hexagon_A2_vavgwr, 7832}, // __builtin_HEXAGON_A2_vavgwr
-      {Intrinsic::hexagon_A2_vcmpbeq, 7860}, // __builtin_HEXAGON_A2_vcmpbeq
-      {Intrinsic::hexagon_A2_vcmpbgtu, 7889}, // __builtin_HEXAGON_A2_vcmpbgtu
-      {Intrinsic::hexagon_A2_vcmpheq, 7919}, // __builtin_HEXAGON_A2_vcmpheq
-      {Intrinsic::hexagon_A2_vcmphgt, 7948}, // __builtin_HEXAGON_A2_vcmphgt
-      {Intrinsic::hexagon_A2_vcmphgtu, 7977}, // __builtin_HEXAGON_A2_vcmphgtu
-      {Intrinsic::hexagon_A2_vcmpweq, 8007}, // __builtin_HEXAGON_A2_vcmpweq
-      {Intrinsic::hexagon_A2_vcmpwgt, 8036}, // __builtin_HEXAGON_A2_vcmpwgt
-      {Intrinsic::hexagon_A2_vcmpwgtu, 8065}, // __builtin_HEXAGON_A2_vcmpwgtu
-      {Intrinsic::hexagon_A2_vconj, 8095}, // __builtin_HEXAGON_A2_vconj
-      {Intrinsic::hexagon_A2_vmaxb, 8122}, // __builtin_HEXAGON_A2_vmaxb
-      {Intrinsic::hexagon_A2_vmaxh, 8149}, // __builtin_HEXAGON_A2_vmaxh
-      {Intrinsic::hexagon_A2_vmaxub, 8176}, // __builtin_HEXAGON_A2_vmaxub
-      {Intrinsic::hexagon_A2_vmaxuh, 8204}, // __builtin_HEXAGON_A2_vmaxuh
-      {Intrinsic::hexagon_A2_vmaxuw, 8232}, // __builtin_HEXAGON_A2_vmaxuw
-      {Intrinsic::hexagon_A2_vmaxw, 8260}, // __builtin_HEXAGON_A2_vmaxw
-      {Intrinsic::hexagon_A2_vminb, 8287}, // __builtin_HEXAGON_A2_vminb
-      {Intrinsic::hexagon_A2_vminh, 8314}, // __builtin_HEXAGON_A2_vminh
-      {Intrinsic::hexagon_A2_vminub, 8341}, // __builtin_HEXAGON_A2_vminub
-      {Intrinsic::hexagon_A2_vminuh, 8369}, // __builtin_HEXAGON_A2_vminuh
-      {Intrinsic::hexagon_A2_vminuw, 8397}, // __builtin_HEXAGON_A2_vminuw
-      {Intrinsic::hexagon_A2_vminw, 8425}, // __builtin_HEXAGON_A2_vminw
-      {Intrinsic::hexagon_A2_vnavgh, 8452}, // __builtin_HEXAGON_A2_vnavgh
-      {Intrinsic::hexagon_A2_vnavghcr, 8480}, // __builtin_HEXAGON_A2_vnavghcr
-      {Intrinsic::hexagon_A2_vnavghr, 8510}, // __builtin_HEXAGON_A2_vnavghr
-      {Intrinsic::hexagon_A2_vnavgw, 8539}, // __builtin_HEXAGON_A2_vnavgw
-      {Intrinsic::hexagon_A2_vnavgwcr, 8567}, // __builtin_HEXAGON_A2_vnavgwcr
-      {Intrinsic::hexagon_A2_vnavgwr, 8597}, // __builtin_HEXAGON_A2_vnavgwr
-      {Intrinsic::hexagon_A2_vraddub, 8626}, // __builtin_HEXAGON_A2_vraddub
-      {Intrinsic::hexagon_A2_vraddub_acc, 8655}, // __builtin_HEXAGON_A2_vraddub_acc
-      {Intrinsic::hexagon_A2_vrsadub, 8688}, // __builtin_HEXAGON_A2_vrsadub
-      {Intrinsic::hexagon_A2_vrsadub_acc, 8717}, // __builtin_HEXAGON_A2_vrsadub_acc
-      {Intrinsic::hexagon_A2_vsubb_map, 8750}, // __builtin_HEXAGON_A2_vsubb_map
-      {Intrinsic::hexagon_A2_vsubh, 8781}, // __builtin_HEXAGON_A2_vsubh
-      {Intrinsic::hexagon_A2_vsubhs, 8808}, // __builtin_HEXAGON_A2_vsubhs
-      {Intrinsic::hexagon_A2_vsubub, 8836}, // __builtin_HEXAGON_A2_vsubub
-      {Intrinsic::hexagon_A2_vsububs, 8864}, // __builtin_HEXAGON_A2_vsububs
-      {Intrinsic::hexagon_A2_vsubuhs, 8893}, // __builtin_HEXAGON_A2_vsubuhs
-      {Intrinsic::hexagon_A2_vsubw, 8922}, // __builtin_HEXAGON_A2_vsubw
-      {Intrinsic::hexagon_A2_vsubws, 8949}, // __builtin_HEXAGON_A2_vsubws
-      {Intrinsic::hexagon_A2_xor, 8977}, // __builtin_HEXAGON_A2_xor
-      {Intrinsic::hexagon_A2_xorp, 9002}, // __builtin_HEXAGON_A2_xorp
-      {Intrinsic::hexagon_A2_zxtb, 9028}, // __builtin_HEXAGON_A2_zxtb
-      {Intrinsic::hexagon_A2_zxth, 9054}, // __builtin_HEXAGON_A2_zxth
-      {Intrinsic::hexagon_A4_addp_c, 9080}, // __builtin_HEXAGON_A4_addp_c
-      {Intrinsic::hexagon_A4_andn, 9108}, // __builtin_HEXAGON_A4_andn
-      {Intrinsic::hexagon_A4_andnp, 9134}, // __builtin_HEXAGON_A4_andnp
-      {Intrinsic::hexagon_A4_bitsplit, 9161}, // __builtin_HEXAGON_A4_bitsplit
-      {Intrinsic::hexagon_A4_bitspliti, 9191}, // __builtin_HEXAGON_A4_bitspliti
-      {Intrinsic::hexagon_A4_boundscheck, 9222}, // __builtin_HEXAGON_A4_boundscheck
-      {Intrinsic::hexagon_A4_cmpbeq, 9255}, // __builtin_HEXAGON_A4_cmpbeq
-      {Intrinsic::hexagon_A4_cmpbeqi, 9283}, // __builtin_HEXAGON_A4_cmpbeqi
-      {Intrinsic::hexagon_A4_cmpbgt, 9312}, // __builtin_HEXAGON_A4_cmpbgt
-      {Intrinsic::hexagon_A4_cmpbgti, 9340}, // __builtin_HEXAGON_A4_cmpbgti
-      {Intrinsic::hexagon_A4_cmpbgtu, 9369}, // __builtin_HEXAGON_A4_cmpbgtu
-      {Intrinsic::hexagon_A4_cmpbgtui, 9398}, // __builtin_HEXAGON_A4_cmpbgtui
-      {Intrinsic::hexagon_A4_cmpheq, 9428}, // __builtin_HEXAGON_A4_cmpheq
-      {Intrinsic::hexagon_A4_cmpheqi, 9456}, // __builtin_HEXAGON_A4_cmpheqi
-      {Intrinsic::hexagon_A4_cmphgt, 9485}, // __builtin_HEXAGON_A4_cmphgt
-      {Intrinsic::hexagon_A4_cmphgti, 9513}, // __builtin_HEXAGON_A4_cmphgti
-      {Intrinsic::hexagon_A4_cmphgtu, 9542}, // __builtin_HEXAGON_A4_cmphgtu
-      {Intrinsic::hexagon_A4_cmphgtui, 9571}, // __builtin_HEXAGON_A4_cmphgtui
-      {Intrinsic::hexagon_A4_combineii, 9601}, // __builtin_HEXAGON_A4_combineii
-      {Intrinsic::hexagon_A4_combineir, 9632}, // __builtin_HEXAGON_A4_combineir
-      {Intrinsic::hexagon_A4_combineri, 9663}, // __builtin_HEXAGON_A4_combineri
-      {Intrinsic::hexagon_A4_cround_ri, 9694}, // __builtin_HEXAGON_A4_cround_ri
-      {Intrinsic::hexagon_A4_cround_rr, 9725}, // __builtin_HEXAGON_A4_cround_rr
-      {Intrinsic::hexagon_A4_modwrapu, 9756}, // __builtin_HEXAGON_A4_modwrapu
-      {Intrinsic::hexagon_A4_orn, 9786}, // __builtin_HEXAGON_A4_orn
-      {Intrinsic::hexagon_A4_ornp, 9811}, // __builtin_HEXAGON_A4_ornp
-      {Intrinsic::hexagon_A4_rcmpeq, 9837}, // __builtin_HEXAGON_A4_rcmpeq
-      {Intrinsic::hexagon_A4_rcmpeqi, 9865}, // __builtin_HEXAGON_A4_rcmpeqi
-      {Intrinsic::hexagon_A4_rcmpneq, 9894}, // __builtin_HEXAGON_A4_rcmpneq
-      {Intrinsic::hexagon_A4_rcmpneqi, 9923}, // __builtin_HEXAGON_A4_rcmpneqi
-      {Intrinsic::hexagon_A4_round_ri, 9953}, // __builtin_HEXAGON_A4_round_ri
-      {Intrinsic::hexagon_A4_round_ri_sat, 9983}, // __builtin_HEXAGON_A4_round_ri_sat
-      {Intrinsic::hexagon_A4_round_rr, 10017}, // __builtin_HEXAGON_A4_round_rr
-      {Intrinsic::hexagon_A4_round_rr_sat, 10047}, // __builtin_HEXAGON_A4_round_rr_sat
-      {Intrinsic::hexagon_A4_subp_c, 10081}, // __builtin_HEXAGON_A4_subp_c
-      {Intrinsic::hexagon_A4_tfrcpp, 10109}, // __builtin_HEXAGON_A4_tfrcpp
-      {Intrinsic::hexagon_A4_tfrpcp, 10137}, // __builtin_HEXAGON_A4_tfrpcp
-      {Intrinsic::hexagon_A4_tlbmatch, 10165}, // __builtin_HEXAGON_A4_tlbmatch
-      {Intrinsic::hexagon_A4_vcmpbeq_any, 10195}, // __builtin_HEXAGON_A4_vcmpbeq_any
-      {Intrinsic::hexagon_A4_vcmpbeqi, 10228}, // __builtin_HEXAGON_A4_vcmpbeqi
-      {Intrinsic::hexagon_A4_vcmpbgt, 10258}, // __builtin_HEXAGON_A4_vcmpbgt
-      {Intrinsic::hexagon_A4_vcmpbgti, 10287}, // __builtin_HEXAGON_A4_vcmpbgti
-      {Intrinsic::hexagon_A4_vcmpbgtui, 10317}, // __builtin_HEXAGON_A4_vcmpbgtui
-      {Intrinsic::hexagon_A4_vcmpheqi, 10348}, // __builtin_HEXAGON_A4_vcmpheqi
-      {Intrinsic::hexagon_A4_vcmphgti, 10378}, // __builtin_HEXAGON_A4_vcmphgti
-      {Intrinsic::hexagon_A4_vcmphgtui, 10408}, // __builtin_HEXAGON_A4_vcmphgtui
-      {Intrinsic::hexagon_A4_vcmpweqi, 10439}, // __builtin_HEXAGON_A4_vcmpweqi
-      {Intrinsic::hexagon_A4_vcmpwgti, 10469}, // __builtin_HEXAGON_A4_vcmpwgti
-      {Intrinsic::hexagon_A4_vcmpwgtui, 10499}, // __builtin_HEXAGON_A4_vcmpwgtui
-      {Intrinsic::hexagon_A4_vrmaxh, 10530}, // __builtin_HEXAGON_A4_vrmaxh
-      {Intrinsic::hexagon_A4_vrmaxuh, 10558}, // __builtin_HEXAGON_A4_vrmaxuh
-      {Intrinsic::hexagon_A4_vrmaxuw, 10587}, // __builtin_HEXAGON_A4_vrmaxuw
-      {Intrinsic::hexagon_A4_vrmaxw, 10616}, // __builtin_HEXAGON_A4_vrmaxw
-      {Intrinsic::hexagon_A4_vrminh, 10644}, // __builtin_HEXAGON_A4_vrminh
-      {Intrinsic::hexagon_A4_vrminuh, 10672}, // __builtin_HEXAGON_A4_vrminuh
-      {Intrinsic::hexagon_A4_vrminuw, 10701}, // __builtin_HEXAGON_A4_vrminuw
-      {Intrinsic::hexagon_A4_vrminw, 10730}, // __builtin_HEXAGON_A4_vrminw
-      {Intrinsic::hexagon_A5_ACS, 10758}, // __builtin_HEXAGON_A5_ACS
-      {Intrinsic::hexagon_A5_vaddhubs, 10783}, // __builtin_HEXAGON_A5_vaddhubs
-      {Intrinsic::hexagon_A6_vcmpbeq_notany, 10813}, // __builtin_HEXAGON_A6_vcmpbeq_notany
-      {Intrinsic::hexagon_A6_vminub_RdP, 10849}, // __builtin_HEXAGON_A6_vminub_RdP
-      {Intrinsic::hexagon_C2_all8, 10881}, // __builtin_HEXAGON_C2_all8
-      {Intrinsic::hexagon_C2_and, 10907}, // __builtin_HEXAGON_C2_and
-      {Intrinsic::hexagon_C2_andn, 10932}, // __builtin_HEXAGON_C2_andn
-      {Intrinsic::hexagon_C2_any8, 10958}, // __builtin_HEXAGON_C2_any8
-      {Intrinsic::hexagon_C2_bitsclr, 10984}, // __builtin_HEXAGON_C2_bitsclr
-      {Intrinsic::hexagon_C2_bitsclri, 11013}, // __builtin_HEXAGON_C2_bitsclri
-      {Intrinsic::hexagon_C2_bitsset, 11043}, // __builtin_HEXAGON_C2_bitsset
-      {Intrinsic::hexagon_C2_cmpeq, 11072}, // __builtin_HEXAGON_C2_cmpeq
-      {Intrinsic::hexagon_C2_cmpeqi, 11099}, // __builtin_HEXAGON_C2_cmpeqi
-      {Intrinsic::hexagon_C2_cmpeqp, 11127}, // __builtin_HEXAGON_C2_cmpeqp
-      {Intrinsic::hexagon_C2_cmpgei, 11155}, // __builtin_HEXAGON_C2_cmpgei
-      {Intrinsic::hexagon_C2_cmpgeui, 11183}, // __builtin_HEXAGON_C2_cmpgeui
-      {Intrinsic::hexagon_C2_cmpgt, 11212}, // __builtin_HEXAGON_C2_cmpgt
-      {Intrinsic::hexagon_C2_cmpgti, 11239}, // __builtin_HEXAGON_C2_cmpgti
-      {Intrinsic::hexagon_C2_cmpgtp, 11267}, // __builtin_HEXAGON_C2_cmpgtp
-      {Intrinsic::hexagon_C2_cmpgtu, 11295}, // __builtin_HEXAGON_C2_cmpgtu
-      {Intrinsic::hexagon_C2_cmpgtui, 11323}, // __builtin_HEXAGON_C2_cmpgtui
-      {Intrinsic::hexagon_C2_cmpgtup, 11352}, // __builtin_HEXAGON_C2_cmpgtup
-      {Intrinsic::hexagon_C2_cmplt, 11381}, // __builtin_HEXAGON_C2_cmplt
-      {Intrinsic::hexagon_C2_cmpltu, 11408}, // __builtin_HEXAGON_C2_cmpltu
-      {Intrinsic::hexagon_C2_mask, 11436}, // __builtin_HEXAGON_C2_mask
-      {Intrinsic::hexagon_C2_mux, 11462}, // __builtin_HEXAGON_C2_mux
-      {Intrinsic::hexagon_C2_muxii, 11487}, // __builtin_HEXAGON_C2_muxii
-      {Intrinsic::hexagon_C2_muxir, 11514}, // __builtin_HEXAGON_C2_muxir
-      {Intrinsic::hexagon_C2_muxri, 11541}, // __builtin_HEXAGON_C2_muxri
-      {Intrinsic::hexagon_C2_not, 11568}, // __builtin_HEXAGON_C2_not
-      {Intrinsic::hexagon_C2_or, 11593}, // __builtin_HEXAGON_C2_or
-      {Intrinsic::hexagon_C2_orn, 11617}, // __builtin_HEXAGON_C2_orn
-      {Intrinsic::hexagon_C2_pxfer_map, 11642}, // __builtin_HEXAGON_C2_pxfer_map
-      {Intrinsic::hexagon_C2_tfrpr, 11673}, // __builtin_HEXAGON_C2_tfrpr
-      {Intrinsic::hexagon_C2_tfrrp, 11700}, // __builtin_HEXAGON_C2_tfrrp
-      {Intrinsic::hexagon_C2_vitpack, 11727}, // __builtin_HEXAGON_C2_vitpack
-      {Intrinsic::hexagon_C2_vmux, 11756}, // __builtin_HEXAGON_C2_vmux
-      {Intrinsic::hexagon_C2_xor, 11782}, // __builtin_HEXAGON_C2_xor
-      {Intrinsic::hexagon_C4_and_and, 11807}, // __builtin_HEXAGON_C4_and_and
-      {Intrinsic::hexagon_C4_and_andn, 11836}, // __builtin_HEXAGON_C4_and_andn
-      {Intrinsic::hexagon_C4_and_or, 11866}, // __builtin_HEXAGON_C4_and_or
-      {Intrinsic::hexagon_C4_and_orn, 11894}, // __builtin_HEXAGON_C4_and_orn
-      {Intrinsic::hexagon_C4_cmplte, 11923}, // __builtin_HEXAGON_C4_cmplte
-      {Intrinsic::hexagon_C4_cmpltei, 11951}, // __builtin_HEXAGON_C4_cmpltei
-      {Intrinsic::hexagon_C4_cmplteu, 11980}, // __builtin_HEXAGON_C4_cmplteu
-      {Intrinsic::hexagon_C4_cmplteui, 12009}, // __builtin_HEXAGON_C4_cmplteui
-      {Intrinsic::hexagon_C4_cmpneq, 12039}, // __builtin_HEXAGON_C4_cmpneq
-      {Intrinsic::hexagon_C4_cmpneqi, 12067}, // __builtin_HEXAGON_C4_cmpneqi
-      {Intrinsic::hexagon_C4_fastcorner9, 12096}, // __builtin_HEXAGON_C4_fastcorner9
-      {Intrinsic::hexagon_C4_fastcorner9_not, 12129}, // __builtin_HEXAGON_C4_fastcorner9_not
-      {Intrinsic::hexagon_C4_nbitsclr, 12166}, // __builtin_HEXAGON_C4_nbitsclr
-      {Intrinsic::hexagon_C4_nbitsclri, 12196}, // __builtin_HEXAGON_C4_nbitsclri
-      {Intrinsic::hexagon_C4_nbitsset, 12227}, // __builtin_HEXAGON_C4_nbitsset
-      {Intrinsic::hexagon_C4_or_and, 12257}, // __builtin_HEXAGON_C4_or_and
-      {Intrinsic::hexagon_C4_or_andn, 12285}, // __builtin_HEXAGON_C4_or_andn
-      {Intrinsic::hexagon_C4_or_or, 12314}, // __builtin_HEXAGON_C4_or_or
-      {Intrinsic::hexagon_C4_or_orn, 12341}, // __builtin_HEXAGON_C4_or_orn
-      {Intrinsic::hexagon_F2_conv_d2df, 12369}, // __builtin_HEXAGON_F2_conv_d2df
-      {Intrinsic::hexagon_F2_conv_d2sf, 12400}, // __builtin_HEXAGON_F2_conv_d2sf
-      {Intrinsic::hexagon_F2_conv_df2d, 12431}, // __builtin_HEXAGON_F2_conv_df2d
-      {Intrinsic::hexagon_F2_conv_df2d_chop, 12462}, // __builtin_HEXAGON_F2_conv_df2d_chop
-      {Intrinsic::hexagon_F2_conv_df2sf, 12498}, // __builtin_HEXAGON_F2_conv_df2sf
-      {Intrinsic::hexagon_F2_conv_df2ud, 12530}, // __builtin_HEXAGON_F2_conv_df2ud
-      {Intrinsic::hexagon_F2_conv_df2ud_chop, 12562}, // __builtin_HEXAGON_F2_conv_df2ud_chop
-      {Intrinsic::hexagon_F2_conv_df2uw, 12599}, // __builtin_HEXAGON_F2_conv_df2uw
-      {Intrinsic::hexagon_F2_conv_df2uw_chop, 12631}, // __builtin_HEXAGON_F2_conv_df2uw_chop
-      {Intrinsic::hexagon_F2_conv_df2w, 12668}, // __builtin_HEXAGON_F2_conv_df2w
-      {Intrinsic::hexagon_F2_conv_df2w_chop, 12699}, // __builtin_HEXAGON_F2_conv_df2w_chop
-      {Intrinsic::hexagon_F2_conv_sf2d, 12735}, // __builtin_HEXAGON_F2_conv_sf2d
-      {Intrinsic::hexagon_F2_conv_sf2d_chop, 12766}, // __builtin_HEXAGON_F2_conv_sf2d_chop
-      {Intrinsic::hexagon_F2_conv_sf2df, 12802}, // __builtin_HEXAGON_F2_conv_sf2df
-      {Intrinsic::hexagon_F2_conv_sf2ud, 12834}, // __builtin_HEXAGON_F2_conv_sf2ud
-      {Intrinsic::hexagon_F2_conv_sf2ud_chop, 12866}, // __builtin_HEXAGON_F2_conv_sf2ud_chop
-      {Intrinsic::hexagon_F2_conv_sf2uw, 12903}, // __builtin_HEXAGON_F2_conv_sf2uw
-      {Intrinsic::hexagon_F2_conv_sf2uw_chop, 12935}, // __builtin_HEXAGON_F2_conv_sf2uw_chop
-      {Intrinsic::hexagon_F2_conv_sf2w, 12972}, // __builtin_HEXAGON_F2_conv_sf2w
-      {Intrinsic::hexagon_F2_conv_sf2w_chop, 13003}, // __builtin_HEXAGON_F2_conv_sf2w_chop
-      {Intrinsic::hexagon_F2_conv_ud2df, 13039}, // __builtin_HEXAGON_F2_conv_ud2df
-      {Intrinsic::hexagon_F2_conv_ud2sf, 13071}, // __builtin_HEXAGON_F2_conv_ud2sf
-      {Intrinsic::hexagon_F2_conv_uw2df, 13103}, // __builtin_HEXAGON_F2_conv_uw2df
-      {Intrinsic::hexagon_F2_conv_uw2sf, 13135}, // __builtin_HEXAGON_F2_conv_uw2sf
-      {Intrinsic::hexagon_F2_conv_w2df, 13167}, // __builtin_HEXAGON_F2_conv_w2df
-      {Intrinsic::hexagon_F2_conv_w2sf, 13198}, // __builtin_HEXAGON_F2_conv_w2sf
-      {Intrinsic::hexagon_F2_dfadd, 13229}, // __builtin_HEXAGON_F2_dfadd
-      {Intrinsic::hexagon_F2_dfclass, 13256}, // __builtin_HEXAGON_F2_dfclass
-      {Intrinsic::hexagon_F2_dfcmpeq, 13285}, // __builtin_HEXAGON_F2_dfcmpeq
-      {Intrinsic::hexagon_F2_dfcmpge, 13314}, // __builtin_HEXAGON_F2_dfcmpge
-      {Intrinsic::hexagon_F2_dfcmpgt, 13343}, // __builtin_HEXAGON_F2_dfcmpgt
-      {Intrinsic::hexagon_F2_dfcmpuo, 13372}, // __builtin_HEXAGON_F2_dfcmpuo
-      {Intrinsic::hexagon_F2_dfimm_n, 13401}, // __builtin_HEXAGON_F2_dfimm_n
-      {Intrinsic::hexagon_F2_dfimm_p, 13430}, // __builtin_HEXAGON_F2_dfimm_p
-      {Intrinsic::hexagon_F2_dfsub, 13459}, // __builtin_HEXAGON_F2_dfsub
-      {Intrinsic::hexagon_F2_sfadd, 13486}, // __builtin_HEXAGON_F2_sfadd
-      {Intrinsic::hexagon_F2_sfclass, 13513}, // __builtin_HEXAGON_F2_sfclass
-      {Intrinsic::hexagon_F2_sfcmpeq, 13542}, // __builtin_HEXAGON_F2_sfcmpeq
-      {Intrinsic::hexagon_F2_sfcmpge, 13571}, // __builtin_HEXAGON_F2_sfcmpge
-      {Intrinsic::hexagon_F2_sfcmpgt, 13600}, // __builtin_HEXAGON_F2_sfcmpgt
-      {Intrinsic::hexagon_F2_sfcmpuo, 13629}, // __builtin_HEXAGON_F2_sfcmpuo
-      {Intrinsic::hexagon_F2_sffixupd, 13658}, // __builtin_HEXAGON_F2_sffixupd
-      {Intrinsic::hexagon_F2_sffixupn, 13688}, // __builtin_HEXAGON_F2_sffixupn
-      {Intrinsic::hexagon_F2_sffixupr, 13718}, // __builtin_HEXAGON_F2_sffixupr
-      {Intrinsic::hexagon_F2_sffma, 13748}, // __builtin_HEXAGON_F2_sffma
-      {Intrinsic::hexagon_F2_sffma_lib, 13775}, // __builtin_HEXAGON_F2_sffma_lib
-      {Intrinsic::hexagon_F2_sffma_sc, 13806}, // __builtin_HEXAGON_F2_sffma_sc
-      {Intrinsic::hexagon_F2_sffms, 13836}, // __builtin_HEXAGON_F2_sffms
-      {Intrinsic::hexagon_F2_sffms_lib, 13863}, // __builtin_HEXAGON_F2_sffms_lib
-      {Intrinsic::hexagon_F2_sfimm_n, 13894}, // __builtin_HEXAGON_F2_sfimm_n
-      {Intrinsic::hexagon_F2_sfimm_p, 13923}, // __builtin_HEXAGON_F2_sfimm_p
-      {Intrinsic::hexagon_F2_sfinvsqrta, 13952}, // __builtin_HEXAGON_F2_sfinvsqrta
-      {Intrinsic::hexagon_F2_sfmax, 13984}, // __builtin_HEXAGON_F2_sfmax
-      {Intrinsic::hexagon_F2_sfmin, 14011}, // __builtin_HEXAGON_F2_sfmin
-      {Intrinsic::hexagon_F2_sfmpy, 14038}, // __builtin_HEXAGON_F2_sfmpy
-      {Intrinsic::hexagon_F2_sfrecipa, 14065}, // __builtin_HEXAGON_F2_sfrecipa
-      {Intrinsic::hexagon_F2_sfsub, 14095}, // __builtin_HEXAGON_F2_sfsub
-      {Intrinsic::hexagon_L2_loadw_locked, 14122}, // __builtin_HEXAGON_L2_loadw_locked
-      {Intrinsic::hexagon_L4_loadd_locked, 14156}, // __builtin_HEXAGON_L4_loadd_locked
-      {Intrinsic::hexagon_M2_acci, 14190}, // __builtin_HEXAGON_M2_acci
-      {Intrinsic::hexagon_M2_accii, 14216}, // __builtin_HEXAGON_M2_accii
-      {Intrinsic::hexagon_M2_cmaci_s0, 14243}, // __builtin_HEXAGON_M2_cmaci_s0
-      {Intrinsic::hexagon_M2_cmacr_s0, 14273}, // __builtin_HEXAGON_M2_cmacr_s0
-      {Intrinsic::hexagon_M2_cmacs_s0, 14303}, // __builtin_HEXAGON_M2_cmacs_s0
-      {Intrinsic::hexagon_M2_cmacs_s1, 14333}, // __builtin_HEXAGON_M2_cmacs_s1
-      {Intrinsic::hexagon_M2_cmacsc_s0, 14363}, // __builtin_HEXAGON_M2_cmacsc_s0
-      {Intrinsic::hexagon_M2_cmacsc_s1, 14394}, // __builtin_HEXAGON_M2_cmacsc_s1
-      {Intrinsic::hexagon_M2_cmpyi_s0, 14425}, // __builtin_HEXAGON_M2_cmpyi_s0
-      {Intrinsic::hexagon_M2_cmpyr_s0, 14455}, // __builtin_HEXAGON_M2_cmpyr_s0
-      {Intrinsic::hexagon_M2_cmpyrs_s0, 14485}, // __builtin_HEXAGON_M2_cmpyrs_s0
-      {Intrinsic::hexagon_M2_cmpyrs_s1, 14516}, // __builtin_HEXAGON_M2_cmpyrs_s1
-      {Intrinsic::hexagon_M2_cmpyrsc_s0, 14547}, // __builtin_HEXAGON_M2_cmpyrsc_s0
-      {Intrinsic::hexagon_M2_cmpyrsc_s1, 14579}, // __builtin_HEXAGON_M2_cmpyrsc_s1
-      {Intrinsic::hexagon_M2_cmpys_s0, 14611}, // __builtin_HEXAGON_M2_cmpys_s0
-      {Intrinsic::hexagon_M2_cmpys_s1, 14641}, // __builtin_HEXAGON_M2_cmpys_s1
-      {Intrinsic::hexagon_M2_cmpysc_s0, 14671}, // __builtin_HEXAGON_M2_cmpysc_s0
-      {Intrinsic::hexagon_M2_cmpysc_s1, 14702}, // __builtin_HEXAGON_M2_cmpysc_s1
-      {Intrinsic::hexagon_M2_cnacs_s0, 14733}, // __builtin_HEXAGON_M2_cnacs_s0
-      {Intrinsic::hexagon_M2_cnacs_s1, 14763}, // __builtin_HEXAGON_M2_cnacs_s1
-      {Intrinsic::hexagon_M2_cnacsc_s0, 14793}, // __builtin_HEXAGON_M2_cnacsc_s0
-      {Intrinsic::hexagon_M2_cnacsc_s1, 14824}, // __builtin_HEXAGON_M2_cnacsc_s1
-      {Intrinsic::hexagon_M2_dpmpyss_acc_s0, 14855}, // __builtin_HEXAGON_M2_dpmpyss_acc_s0
-      {Intrinsic::hexagon_M2_dpmpyss_nac_s0, 14891}, // __builtin_HEXAGON_M2_dpmpyss_nac_s0
-      {Intrinsic::hexagon_M2_dpmpyss_rnd_s0, 14927}, // __builtin_HEXAGON_M2_dpmpyss_rnd_s0
-      {Intrinsic::hexagon_M2_dpmpyss_s0, 14963}, // __builtin_HEXAGON_M2_dpmpyss_s0
-      {Intrinsic::hexagon_M2_dpmpyuu_acc_s0, 14995}, // __builtin_HEXAGON_M2_dpmpyuu_acc_s0
-      {Intrinsic::hexagon_M2_dpmpyuu_nac_s0, 15031}, // __builtin_HEXAGON_M2_dpmpyuu_nac_s0
-      {Intrinsic::hexagon_M2_dpmpyuu_s0, 15067}, // __builtin_HEXAGON_M2_dpmpyuu_s0
-      {Intrinsic::hexagon_M2_hmmpyh_rs1, 15099}, // __builtin_HEXAGON_M2_hmmpyh_rs1
-      {Intrinsic::hexagon_M2_hmmpyh_s1, 15131}, // __builtin_HEXAGON_M2_hmmpyh_s1
-      {Intrinsic::hexagon_M2_hmmpyl_rs1, 15162}, // __builtin_HEXAGON_M2_hmmpyl_rs1
-      {Intrinsic::hexagon_M2_hmmpyl_s1, 15194}, // __builtin_HEXAGON_M2_hmmpyl_s1
-      {Intrinsic::hexagon_M2_maci, 15225}, // __builtin_HEXAGON_M2_maci
-      {Intrinsic::hexagon_M2_macsin, 15251}, // __builtin_HEXAGON_M2_macsin
-      {Intrinsic::hexagon_M2_macsip, 15279}, // __builtin_HEXAGON_M2_macsip
-      {Intrinsic::hexagon_M2_mmachs_rs0, 15307}, // __builtin_HEXAGON_M2_mmachs_rs0
-      {Intrinsic::hexagon_M2_mmachs_rs1, 15339}, // __builtin_HEXAGON_M2_mmachs_rs1
-      {Intrinsic::hexagon_M2_mmachs_s0, 15371}, // __builtin_HEXAGON_M2_mmachs_s0
-      {Intrinsic::hexagon_M2_mmachs_s1, 15402}, // __builtin_HEXAGON_M2_mmachs_s1
-      {Intrinsic::hexagon_M2_mmacls_rs0, 15433}, // __builtin_HEXAGON_M2_mmacls_rs0
-      {Intrinsic::hexagon_M2_mmacls_rs1, 15465}, // __builtin_HEXAGON_M2_mmacls_rs1
-      {Intrinsic::hexagon_M2_mmacls_s0, 15497}, // __builtin_HEXAGON_M2_mmacls_s0
-      {Intrinsic::hexagon_M2_mmacls_s1, 15528}, // __builtin_HEXAGON_M2_mmacls_s1
-      {Intrinsic::hexagon_M2_mmacuhs_rs0, 15559}, // __builtin_HEXAGON_M2_mmacuhs_rs0
-      {Intrinsic::hexagon_M2_mmacuhs_rs1, 15592}, // __builtin_HEXAGON_M2_mmacuhs_rs1
-      {Intrinsic::hexagon_M2_mmacuhs_s0, 15625}, // __builtin_HEXAGON_M2_mmacuhs_s0
-      {Intrinsic::hexagon_M2_mmacuhs_s1, 15657}, // __builtin_HEXAGON_M2_mmacuhs_s1
-      {Intrinsic::hexagon_M2_mmaculs_rs0, 15689}, // __builtin_HEXAGON_M2_mmaculs_rs0
-      {Intrinsic::hexagon_M2_mmaculs_rs1, 15722}, // __builtin_HEXAGON_M2_mmaculs_rs1
-      {Intrinsic::hexagon_M2_mmaculs_s0, 15755}, // __builtin_HEXAGON_M2_mmaculs_s0
-      {Intrinsic::hexagon_M2_mmaculs_s1, 15787}, // __builtin_HEXAGON_M2_mmaculs_s1
-      {Intrinsic::hexagon_M2_mmpyh_rs0, 15819}, // __builtin_HEXAGON_M2_mmpyh_rs0
-      {Intrinsic::hexagon_M2_mmpyh_rs1, 15850}, // __builtin_HEXAGON_M2_mmpyh_rs1
-      {Intrinsic::hexagon_M2_mmpyh_s0, 15881}, // __builtin_HEXAGON_M2_mmpyh_s0
-      {Intrinsic::hexagon_M2_mmpyh_s1, 15911}, // __builtin_HEXAGON_M2_mmpyh_s1
-      {Intrinsic::hexagon_M2_mmpyl_rs0, 15941}, // __builtin_HEXAGON_M2_mmpyl_rs0
-      {Intrinsic::hexagon_M2_mmpyl_rs1, 15972}, // __builtin_HEXAGON_M2_mmpyl_rs1
-      {Intrinsic::hexagon_M2_mmpyl_s0, 16003}, // __builtin_HEXAGON_M2_mmpyl_s0
-      {Intrinsic::hexagon_M2_mmpyl_s1, 16033}, // __builtin_HEXAGON_M2_mmpyl_s1
-      {Intrinsic::hexagon_M2_mmpyuh_rs0, 16063}, // __builtin_HEXAGON_M2_mmpyuh_rs0
-      {Intrinsic::hexagon_M2_mmpyuh_rs1, 16095}, // __builtin_HEXAGON_M2_mmpyuh_rs1
-      {Intrinsic::hexagon_M2_mmpyuh_s0, 16127}, // __builtin_HEXAGON_M2_mmpyuh_s0
-      {Intrinsic::hexagon_M2_mmpyuh_s1, 16158}, // __builtin_HEXAGON_M2_mmpyuh_s1
-      {Intrinsic::hexagon_M2_mmpyul_rs0, 16189}, // __builtin_HEXAGON_M2_mmpyul_rs0
-      {Intrinsic::hexagon_M2_mmpyul_rs1, 16221}, // __builtin_HEXAGON_M2_mmpyul_rs1
-      {Intrinsic::hexagon_M2_mmpyul_s0, 16253}, // __builtin_HEXAGON_M2_mmpyul_s0
-      {Intrinsic::hexagon_M2_mmpyul_s1, 16284}, // __builtin_HEXAGON_M2_mmpyul_s1
-      {Intrinsic::hexagon_M2_mnaci, 16315}, // __builtin_HEXAGON_M2_mnaci
-      {Intrinsic::hexagon_M2_mpy_acc_hh_s0, 16342}, // __builtin_HEXAGON_M2_mpy_acc_hh_s0
-      {Intrinsic::hexagon_M2_mpy_acc_hh_s1, 16377}, // __builtin_HEXAGON_M2_mpy_acc_hh_s1
-      {Intrinsic::hexagon_M2_mpy_acc_hl_s0, 16412}, // __builtin_HEXAGON_M2_mpy_acc_hl_s0
-      {Intrinsic::hexagon_M2_mpy_acc_hl_s1, 16447}, // __builtin_HEXAGON_M2_mpy_acc_hl_s1
-      {Intrinsic::hexagon_M2_mpy_acc_lh_s0, 16482}, // __builtin_HEXAGON_M2_mpy_acc_lh_s0
-      {Intrinsic::hexagon_M2_mpy_acc_lh_s1, 16517}, // __builtin_HEXAGON_M2_mpy_acc_lh_s1
-      {Intrinsic::hexagon_M2_mpy_acc_ll_s0, 16552}, // __builtin_HEXAGON_M2_mpy_acc_ll_s0
-      {Intrinsic::hexagon_M2_mpy_acc_ll_s1, 16587}, // __builtin_HEXAGON_M2_mpy_acc_ll_s1
-      {Intrinsic::hexagon_M2_mpy_acc_sat_hh_s0, 16622}, // __builtin_HEXAGON_M2_mpy_acc_sat_hh_s0
-      {Intrinsic::hexagon_M2_mpy_acc_sat_hh_s1, 16661}, // __builtin_HEXAGON_M2_mpy_acc_sat_hh_s1
-      {Intrinsic::hexagon_M2_mpy_acc_sat_hl_s0, 16700}, // __builtin_HEXAGON_M2_mpy_acc_sat_hl_s0
-      {Intrinsic::hexagon_M2_mpy_acc_sat_hl_s1, 16739}, // __builtin_HEXAGON_M2_mpy_acc_sat_hl_s1
-      {Intrinsic::hexagon_M2_mpy_acc_sat_lh_s0, 16778}, // __builtin_HEXAGON_M2_mpy_acc_sat_lh_s0
-      {Intrinsic::hexagon_M2_mpy_acc_sat_lh_s1, 16817}, // __builtin_HEXAGON_M2_mpy_acc_sat_lh_s1
-      {Intrinsic::hexagon_M2_mpy_acc_sat_ll_s0, 16856}, // __builtin_HEXAGON_M2_mpy_acc_sat_ll_s0
-      {Intrinsic::hexagon_M2_mpy_acc_sat_ll_s1, 16895}, // __builtin_HEXAGON_M2_mpy_acc_sat_ll_s1
-      {Intrinsic::hexagon_M2_mpy_hh_s0, 16934}, // __builtin_HEXAGON_M2_mpy_hh_s0
-      {Intrinsic::hexagon_M2_mpy_hh_s1, 16965}, // __builtin_HEXAGON_M2_mpy_hh_s1
-      {Intrinsic::hexagon_M2_mpy_hl_s0, 16996}, // __builtin_HEXAGON_M2_mpy_hl_s0
-      {Intrinsic::hexagon_M2_mpy_hl_s1, 17027}, // __builtin_HEXAGON_M2_mpy_hl_s1
-      {Intrinsic::hexagon_M2_mpy_lh_s0, 17058}, // __builtin_HEXAGON_M2_mpy_lh_s0
-      {Intrinsic::hexagon_M2_mpy_lh_s1, 17089}, // __builtin_HEXAGON_M2_mpy_lh_s1
-      {Intrinsic::hexagon_M2_mpy_ll_s0, 17120}, // __builtin_HEXAGON_M2_mpy_ll_s0
-      {Intrinsic::hexagon_M2_mpy_ll_s1, 17151}, // __builtin_HEXAGON_M2_mpy_ll_s1
-      {Intrinsic::hexagon_M2_mpy_nac_hh_s0, 17182}, // __builtin_HEXAGON_M2_mpy_nac_hh_s0
-      {Intrinsic::hexagon_M2_mpy_nac_hh_s1, 17217}, // __builtin_HEXAGON_M2_mpy_nac_hh_s1
-      {Intrinsic::hexagon_M2_mpy_nac_hl_s0, 17252}, // __builtin_HEXAGON_M2_mpy_nac_hl_s0
-      {Intrinsic::hexagon_M2_mpy_nac_hl_s1, 17287}, // __builtin_HEXAGON_M2_mpy_nac_hl_s1
-      {Intrinsic::hexagon_M2_mpy_nac_lh_s0, 17322}, // __builtin_HEXAGON_M2_mpy_nac_lh_s0
-      {Intrinsic::hexagon_M2_mpy_nac_lh_s1, 17357}, // __builtin_HEXAGON_M2_mpy_nac_lh_s1
-      {Intrinsic::hexagon_M2_mpy_nac_ll_s0, 17392}, // __builtin_HEXAGON_M2_mpy_nac_ll_s0
-      {Intrinsic::hexagon_M2_mpy_nac_ll_s1, 17427}, // __builtin_HEXAGON_M2_mpy_nac_ll_s1
-      {Intrinsic::hexagon_M2_mpy_nac_sat_hh_s0, 17462}, // __builtin_HEXAGON_M2_mpy_nac_sat_hh_s0
-      {Intrinsic::hexagon_M2_mpy_nac_sat_hh_s1, 17501}, // __builtin_HEXAGON_M2_mpy_nac_sat_hh_s1
-      {Intrinsic::hexagon_M2_mpy_nac_sat_hl_s0, 17540}, // __builtin_HEXAGON_M2_mpy_nac_sat_hl_s0
-      {Intrinsic::hexagon_M2_mpy_nac_sat_hl_s1, 17579}, // __builtin_HEXAGON_M2_mpy_nac_sat_hl_s1
-      {Intrinsic::hexagon_M2_mpy_nac_sat_lh_s0, 17618}, // __builtin_HEXAGON_M2_mpy_nac_sat_lh_s0
-      {Intrinsic::hexagon_M2_mpy_nac_sat_lh_s1, 17657}, // __builtin_HEXAGON_M2_mpy_nac_sat_lh_s1
-      {Intrinsic::hexagon_M2_mpy_nac_sat_ll_s0, 17696}, // __builtin_HEXAGON_M2_mpy_nac_sat_ll_s0
-      {Intrinsic::hexagon_M2_mpy_nac_sat_ll_s1, 17735}, // __builtin_HEXAGON_M2_mpy_nac_sat_ll_s1
-      {Intrinsic::hexagon_M2_mpy_rnd_hh_s0, 17774}, // __builtin_HEXAGON_M2_mpy_rnd_hh_s0
-      {Intrinsic::hexagon_M2_mpy_rnd_hh_s1, 17809}, // __builtin_HEXAGON_M2_mpy_rnd_hh_s1
-      {Intrinsic::hexagon_M2_mpy_rnd_hl_s0, 17844}, // __builtin_HEXAGON_M2_mpy_rnd_hl_s0
-      {Intrinsic::hexagon_M2_mpy_rnd_hl_s1, 17879}, // __builtin_HEXAGON_M2_mpy_rnd_hl_s1
-      {Intrinsic::hexagon_M2_mpy_rnd_lh_s0, 17914}, // __builtin_HEXAGON_M2_mpy_rnd_lh_s0
-      {Intrinsic::hexagon_M2_mpy_rnd_lh_s1, 17949}, // __builtin_HEXAGON_M2_mpy_rnd_lh_s1
-      {Intrinsic::hexagon_M2_mpy_rnd_ll_s0, 17984}, // __builtin_HEXAGON_M2_mpy_rnd_ll_s0
-      {Intrinsic::hexagon_M2_mpy_rnd_ll_s1, 18019}, // __builtin_HEXAGON_M2_mpy_rnd_ll_s1
-      {Intrinsic::hexagon_M2_mpy_sat_hh_s0, 18054}, // __builtin_HEXAGON_M2_mpy_sat_hh_s0
-      {Intrinsic::hexagon_M2_mpy_sat_hh_s1, 18089}, // __builtin_HEXAGON_M2_mpy_sat_hh_s1
-      {Intrinsic::hexagon_M2_mpy_sat_hl_s0, 18124}, // __builtin_HEXAGON_M2_mpy_sat_hl_s0
-      {Intrinsic::hexagon_M2_mpy_sat_hl_s1, 18159}, // __builtin_HEXAGON_M2_mpy_sat_hl_s1
-      {Intrinsic::hexagon_M2_mpy_sat_lh_s0, 18194}, // __builtin_HEXAGON_M2_mpy_sat_lh_s0
-      {Intrinsic::hexagon_M2_mpy_sat_lh_s1, 18229}, // __builtin_HEXAGON_M2_mpy_sat_lh_s1
-      {Intrinsic::hexagon_M2_mpy_sat_ll_s0, 18264}, // __builtin_HEXAGON_M2_mpy_sat_ll_s0
-      {Intrinsic::hexagon_M2_mpy_sat_ll_s1, 18299}, // __builtin_HEXAGON_M2_mpy_sat_ll_s1
-      {Intrinsic::hexagon_M2_mpy_sat_rnd_hh_s0, 18334}, // __builtin_HEXAGON_M2_mpy_sat_rnd_hh_s0
-      {Intrinsic::hexagon_M2_mpy_sat_rnd_hh_s1, 18373}, // __builtin_HEXAGON_M2_mpy_sat_rnd_hh_s1
-      {Intrinsic::hexagon_M2_mpy_sat_rnd_hl_s0, 18412}, // __builtin_HEXAGON_M2_mpy_sat_rnd_hl_s0
-      {Intrinsic::hexagon_M2_mpy_sat_rnd_hl_s1, 18451}, // __builtin_HEXAGON_M2_mpy_sat_rnd_hl_s1
-      {Intrinsic::hexagon_M2_mpy_sat_rnd_lh_s0, 18490}, // __builtin_HEXAGON_M2_mpy_sat_rnd_lh_s0
-      {Intrinsic::hexagon_M2_mpy_sat_rnd_lh_s1, 18529}, // __builtin_HEXAGON_M2_mpy_sat_rnd_lh_s1
-      {Intrinsic::hexagon_M2_mpy_sat_rnd_ll_s0, 18568}, // __builtin_HEXAGON_M2_mpy_sat_rnd_ll_s0
-      {Intrinsic::hexagon_M2_mpy_sat_rnd_ll_s1, 18607}, // __builtin_HEXAGON_M2_mpy_sat_rnd_ll_s1
-      {Intrinsic::hexagon_M2_mpy_up, 18646}, // __builtin_HEXAGON_M2_mpy_up
-      {Intrinsic::hexagon_M2_mpy_up_s1, 18674}, // __builtin_HEXAGON_M2_mpy_up_s1
-      {Intrinsic::hexagon_M2_mpy_up_s1_sat, 18705}, // __builtin_HEXAGON_M2_mpy_up_s1_sat
-      {Intrinsic::hexagon_M2_mpyd_acc_hh_s0, 18740}, // __builtin_HEXAGON_M2_mpyd_acc_hh_s0
-      {Intrinsic::hexagon_M2_mpyd_acc_hh_s1, 18776}, // __builtin_HEXAGON_M2_mpyd_acc_hh_s1
-      {Intrinsic::hexagon_M2_mpyd_acc_hl_s0, 18812}, // __builtin_HEXAGON_M2_mpyd_acc_hl_s0
-      {Intrinsic::hexagon_M2_mpyd_acc_hl_s1, 18848}, // __builtin_HEXAGON_M2_mpyd_acc_hl_s1
-      {Intrinsic::hexagon_M2_mpyd_acc_lh_s0, 18884}, // __builtin_HEXAGON_M2_mpyd_acc_lh_s0
-      {Intrinsic::hexagon_M2_mpyd_acc_lh_s1, 18920}, // __builtin_HEXAGON_M2_mpyd_acc_lh_s1
-      {Intrinsic::hexagon_M2_mpyd_acc_ll_s0, 18956}, // __builtin_HEXAGON_M2_mpyd_acc_ll_s0
-      {Intrinsic::hexagon_M2_mpyd_acc_ll_s1, 18992}, // __builtin_HEXAGON_M2_mpyd_acc_ll_s1
-      {Intrinsic::hexagon_M2_mpyd_hh_s0, 19028}, // __builtin_HEXAGON_M2_mpyd_hh_s0
-      {Intrinsic::hexagon_M2_mpyd_hh_s1, 19060}, // __builtin_HEXAGON_M2_mpyd_hh_s1
-      {Intrinsic::hexagon_M2_mpyd_hl_s0, 19092}, // __builtin_HEXAGON_M2_mpyd_hl_s0
-      {Intrinsic::hexagon_M2_mpyd_hl_s1, 19124}, // __builtin_HEXAGON_M2_mpyd_hl_s1
-      {Intrinsic::hexagon_M2_mpyd_lh_s0, 19156}, // __builtin_HEXAGON_M2_mpyd_lh_s0
-      {Intrinsic::hexagon_M2_mpyd_lh_s1, 19188}, // __builtin_HEXAGON_M2_mpyd_lh_s1
-      {Intrinsic::hexagon_M2_mpyd_ll_s0, 19220}, // __builtin_HEXAGON_M2_mpyd_ll_s0
-      {Intrinsic::hexagon_M2_mpyd_ll_s1, 19252}, // __builtin_HEXAGON_M2_mpyd_ll_s1
-      {Intrinsic::hexagon_M2_mpyd_nac_hh_s0, 19284}, // __builtin_HEXAGON_M2_mpyd_nac_hh_s0
-      {Intrinsic::hexagon_M2_mpyd_nac_hh_s1, 19320}, // __builtin_HEXAGON_M2_mpyd_nac_hh_s1
-      {Intrinsic::hexagon_M2_mpyd_nac_hl_s0, 19356}, // __builtin_HEXAGON_M2_mpyd_nac_hl_s0
-      {Intrinsic::hexagon_M2_mpyd_nac_hl_s1, 19392}, // __builtin_HEXAGON_M2_mpyd_nac_hl_s1
-      {Intrinsic::hexagon_M2_mpyd_nac_lh_s0, 19428}, // __builtin_HEXAGON_M2_mpyd_nac_lh_s0
-      {Intrinsic::hexagon_M2_mpyd_nac_lh_s1, 19464}, // __builtin_HEXAGON_M2_mpyd_nac_lh_s1
-      {Intrinsic::hexagon_M2_mpyd_nac_ll_s0, 19500}, // __builtin_HEXAGON_M2_mpyd_nac_ll_s0
-      {Intrinsic::hexagon_M2_mpyd_nac_ll_s1, 19536}, // __builtin_HEXAGON_M2_mpyd_nac_ll_s1
-      {Intrinsic::hexagon_M2_mpyd_rnd_hh_s0, 19572}, // __builtin_HEXAGON_M2_mpyd_rnd_hh_s0
-      {Intrinsic::hexagon_M2_mpyd_rnd_hh_s1, 19608}, // __builtin_HEXAGON_M2_mpyd_rnd_hh_s1
-      {Intrinsic::hexagon_M2_mpyd_rnd_hl_s0, 19644}, // __builtin_HEXAGON_M2_mpyd_rnd_hl_s0
-      {Intrinsic::hexagon_M2_mpyd_rnd_hl_s1, 19680}, // __builtin_HEXAGON_M2_mpyd_rnd_hl_s1
-      {Intrinsic::hexagon_M2_mpyd_rnd_lh_s0, 19716}, // __builtin_HEXAGON_M2_mpyd_rnd_lh_s0
-      {Intrinsic::hexagon_M2_mpyd_rnd_lh_s1, 19752}, // __builtin_HEXAGON_M2_mpyd_rnd_lh_s1
-      {Intrinsic::hexagon_M2_mpyd_rnd_ll_s0, 19788}, // __builtin_HEXAGON_M2_mpyd_rnd_ll_s0
-      {Intrinsic::hexagon_M2_mpyd_rnd_ll_s1, 19824}, // __builtin_HEXAGON_M2_mpyd_rnd_ll_s1
-      {Intrinsic::hexagon_M2_mpyi, 19860}, // __builtin_HEXAGON_M2_mpyi
-      {Intrinsic::hexagon_M2_mpysin, 19886}, // __builtin_HEXAGON_M2_mpysin
-      {Intrinsic::hexagon_M2_mpysip, 19914}, // __builtin_HEXAGON_M2_mpysip
-      {Intrinsic::hexagon_M2_mpysmi, 19942}, // __builtin_HEXAGON_M2_mpysmi
-      {Intrinsic::hexagon_M2_mpysu_up, 19970}, // __builtin_HEXAGON_M2_mpysu_up
-      {Intrinsic::hexagon_M2_mpyu_acc_hh_s0, 20000}, // __builtin_HEXAGON_M2_mpyu_acc_hh_s0
-      {Intrinsic::hexagon_M2_mpyu_acc_hh_s1, 20036}, // __builtin_HEXAGON_M2_mpyu_acc_hh_s1
-      {Intrinsic::hexagon_M2_mpyu_acc_hl_s0, 20072}, // __builtin_HEXAGON_M2_mpyu_acc_hl_s0
-      {Intrinsic::hexagon_M2_mpyu_acc_hl_s1, 20108}, // __builtin_HEXAGON_M2_mpyu_acc_hl_s1
-      {Intrinsic::hexagon_M2_mpyu_acc_lh_s0, 20144}, // __builtin_HEXAGON_M2_mpyu_acc_lh_s0
-      {Intrinsic::hexagon_M2_mpyu_acc_lh_s1, 20180}, // __builtin_HEXAGON_M2_mpyu_acc_lh_s1
-      {Intrinsic::hexagon_M2_mpyu_acc_ll_s0, 20216}, // __builtin_HEXAGON_M2_mpyu_acc_ll_s0
-      {Intrinsic::hexagon_M2_mpyu_acc_ll_s1, 20252}, // __builtin_HEXAGON_M2_mpyu_acc_ll_s1
-      {Intrinsic::hexagon_M2_mpyu_hh_s0, 20288}, // __builtin_HEXAGON_M2_mpyu_hh_s0
-      {Intrinsic::hexagon_M2_mpyu_hh_s1, 20320}, // __builtin_HEXAGON_M2_mpyu_hh_s1
-      {Intrinsic::hexagon_M2_mpyu_hl_s0, 20352}, // __builtin_HEXAGON_M2_mpyu_hl_s0
-      {Intrinsic::hexagon_M2_mpyu_hl_s1, 20384}, // __builtin_HEXAGON_M2_mpyu_hl_s1
-      {Intrinsic::hexagon_M2_mpyu_lh_s0, 20416}, // __builtin_HEXAGON_M2_mpyu_lh_s0
-      {Intrinsic::hexagon_M2_mpyu_lh_s1, 20448}, // __builtin_HEXAGON_M2_mpyu_lh_s1
-      {Intrinsic::hexagon_M2_mpyu_ll_s0, 20480}, // __builtin_HEXAGON_M2_mpyu_ll_s0
-      {Intrinsic::hexagon_M2_mpyu_ll_s1, 20512}, // __builtin_HEXAGON_M2_mpyu_ll_s1
-      {Intrinsic::hexagon_M2_mpyu_nac_hh_s0, 20544}, // __builtin_HEXAGON_M2_mpyu_nac_hh_s0
-      {Intrinsic::hexagon_M2_mpyu_nac_hh_s1, 20580}, // __builtin_HEXAGON_M2_mpyu_nac_hh_s1
-      {Intrinsic::hexagon_M2_mpyu_nac_hl_s0, 20616}, // __builtin_HEXAGON_M2_mpyu_nac_hl_s0
-      {Intrinsic::hexagon_M2_mpyu_nac_hl_s1, 20652}, // __builtin_HEXAGON_M2_mpyu_nac_hl_s1
-      {Intrinsic::hexagon_M2_mpyu_nac_lh_s0, 20688}, // __builtin_HEXAGON_M2_mpyu_nac_lh_s0
-      {Intrinsic::hexagon_M2_mpyu_nac_lh_s1, 20724}, // __builtin_HEXAGON_M2_mpyu_nac_lh_s1
-      {Intrinsic::hexagon_M2_mpyu_nac_ll_s0, 20760}, // __builtin_HEXAGON_M2_mpyu_nac_ll_s0
-      {Intrinsic::hexagon_M2_mpyu_nac_ll_s1, 20796}, // __builtin_HEXAGON_M2_mpyu_nac_ll_s1
-      {Intrinsic::hexagon_M2_mpyu_up, 20832}, // __builtin_HEXAGON_M2_mpyu_up
-      {Intrinsic::hexagon_M2_mpyud_acc_hh_s0, 20861}, // __builtin_HEXAGON_M2_mpyud_acc_hh_s0
-      {Intrinsic::hexagon_M2_mpyud_acc_hh_s1, 20898}, // __builtin_HEXAGON_M2_mpyud_acc_hh_s1
-      {Intrinsic::hexagon_M2_mpyud_acc_hl_s0, 20935}, // __builtin_HEXAGON_M2_mpyud_acc_hl_s0
-      {Intrinsic::hexagon_M2_mpyud_acc_hl_s1, 20972}, // __builtin_HEXAGON_M2_mpyud_acc_hl_s1
-      {Intrinsic::hexagon_M2_mpyud_acc_lh_s0, 21009}, // __builtin_HEXAGON_M2_mpyud_acc_lh_s0
-      {Intrinsic::hexagon_M2_mpyud_acc_lh_s1, 21046}, // __builtin_HEXAGON_M2_mpyud_acc_lh_s1
-      {Intrinsic::hexagon_M2_mpyud_acc_ll_s0, 21083}, // __builtin_HEXAGON_M2_mpyud_acc_ll_s0
-      {Intrinsic::hexagon_M2_mpyud_acc_ll_s1, 21120}, // __builtin_HEXAGON_M2_mpyud_acc_ll_s1
-      {Intrinsic::hexagon_M2_mpyud_hh_s0, 21157}, // __builtin_HEXAGON_M2_mpyud_hh_s0
-      {Intrinsic::hexagon_M2_mpyud_hh_s1, 21190}, // __builtin_HEXAGON_M2_mpyud_hh_s1
-      {Intrinsic::hexagon_M2_mpyud_hl_s0, 21223}, // __builtin_HEXAGON_M2_mpyud_hl_s0
-      {Intrinsic::hexagon_M2_mpyud_hl_s1, 21256}, // __builtin_HEXAGON_M2_mpyud_hl_s1
-      {Intrinsic::hexagon_M2_mpyud_lh_s0, 21289}, // __builtin_HEXAGON_M2_mpyud_lh_s0
-      {Intrinsic::hexagon_M2_mpyud_lh_s1, 21322}, // __builtin_HEXAGON_M2_mpyud_lh_s1
-      {Intrinsic::hexagon_M2_mpyud_ll_s0, 21355}, // __builtin_HEXAGON_M2_mpyud_ll_s0
-      {Intrinsic::hexagon_M2_mpyud_ll_s1, 21388}, // __builtin_HEXAGON_M2_mpyud_ll_s1
-      {Intrinsic::hexagon_M2_mpyud_nac_hh_s0, 21421}, // __builtin_HEXAGON_M2_mpyud_nac_hh_s0
-      {Intrinsic::hexagon_M2_mpyud_nac_hh_s1, 21458}, // __builtin_HEXAGON_M2_mpyud_nac_hh_s1
-      {Intrinsic::hexagon_M2_mpyud_nac_hl_s0, 21495}, // __builtin_HEXAGON_M2_mpyud_nac_hl_s0
-      {Intrinsic::hexagon_M2_mpyud_nac_hl_s1, 21532}, // __builtin_HEXAGON_M2_mpyud_nac_hl_s1
-      {Intrinsic::hexagon_M2_mpyud_nac_lh_s0, 21569}, // __builtin_HEXAGON_M2_mpyud_nac_lh_s0
-      {Intrinsic::hexagon_M2_mpyud_nac_lh_s1, 21606}, // __builtin_HEXAGON_M2_mpyud_nac_lh_s1
-      {Intrinsic::hexagon_M2_mpyud_nac_ll_s0, 21643}, // __builtin_HEXAGON_M2_mpyud_nac_ll_s0
-      {Intrinsic::hexagon_M2_mpyud_nac_ll_s1, 21680}, // __builtin_HEXAGON_M2_mpyud_nac_ll_s1
-      {Intrinsic::hexagon_M2_mpyui, 21717}, // __builtin_HEXAGON_M2_mpyui
-      {Intrinsic::hexagon_M2_nacci, 21744}, // __builtin_HEXAGON_M2_nacci
-      {Intrinsic::hexagon_M2_naccii, 21771}, // __builtin_HEXAGON_M2_naccii
-      {Intrinsic::hexagon_M2_subacc, 21799}, // __builtin_HEXAGON_M2_subacc
-      {Intrinsic::hexagon_M2_vabsdiffh, 21827}, // __builtin_HEXAGON_M2_vabsdiffh
-      {Intrinsic::hexagon_M2_vabsdiffw, 21858}, // __builtin_HEXAGON_M2_vabsdiffw
-      {Intrinsic::hexagon_M2_vcmac_s0_sat_i, 21889}, // __builtin_HEXAGON_M2_vcmac_s0_sat_i
-      {Intrinsic::hexagon_M2_vcmac_s0_sat_r, 21925}, // __builtin_HEXAGON_M2_vcmac_s0_sat_r
-      {Intrinsic::hexagon_M2_vcmpy_s0_sat_i, 21961}, // __builtin_HEXAGON_M2_vcmpy_s0_sat_i
-      {Intrinsic::hexagon_M2_vcmpy_s0_sat_r, 21997}, // __builtin_HEXAGON_M2_vcmpy_s0_sat_r
-      {Intrinsic::hexagon_M2_vcmpy_s1_sat_i, 22033}, // __builtin_HEXAGON_M2_vcmpy_s1_sat_i
-      {Intrinsic::hexagon_M2_vcmpy_s1_sat_r, 22069}, // __builtin_HEXAGON_M2_vcmpy_s1_sat_r
-      {Intrinsic::hexagon_M2_vdmacs_s0, 22105}, // __builtin_HEXAGON_M2_vdmacs_s0
-      {Intrinsic::hexagon_M2_vdmacs_s1, 22136}, // __builtin_HEXAGON_M2_vdmacs_s1
-      {Intrinsic::hexagon_M2_vdmpyrs_s0, 22167}, // __builtin_HEXAGON_M2_vdmpyrs_s0
-      {Intrinsic::hexagon_M2_vdmpyrs_s1, 22199}, // __builtin_HEXAGON_M2_vdmpyrs_s1
-      {Intrinsic::hexagon_M2_vdmpys_s0, 22231}, // __builtin_HEXAGON_M2_vdmpys_s0
-      {Intrinsic::hexagon_M2_vdmpys_s1, 22262}, // __builtin_HEXAGON_M2_vdmpys_s1
-      {Intrinsic::hexagon_M2_vmac2, 22293}, // __builtin_HEXAGON_M2_vmac2
-      {Intrinsic::hexagon_M2_vmac2es, 22320}, // __builtin_HEXAGON_M2_vmac2es
-      {Intrinsic::hexagon_M2_vmac2es_s0, 22349}, // __builtin_HEXAGON_M2_vmac2es_s0
-      {Intrinsic::hexagon_M2_vmac2es_s1, 22381}, // __builtin_HEXAGON_M2_vmac2es_s1
-      {Intrinsic::hexagon_M2_vmac2s_s0, 22413}, // __builtin_HEXAGON_M2_vmac2s_s0
-      {Intrinsic::hexagon_M2_vmac2s_s1, 22444}, // __builtin_HEXAGON_M2_vmac2s_s1
-      {Intrinsic::hexagon_M2_vmac2su_s0, 22475}, // __builtin_HEXAGON_M2_vmac2su_s0
-      {Intrinsic::hexagon_M2_vmac2su_s1, 22507}, // __builtin_HEXAGON_M2_vmac2su_s1
-      {Intrinsic::hexagon_M2_vmpy2es_s0, 22539}, // __builtin_HEXAGON_M2_vmpy2es_s0
-      {Intrinsic::hexagon_M2_vmpy2es_s1, 22571}, // __builtin_HEXAGON_M2_vmpy2es_s1
-      {Intrinsic::hexagon_M2_vmpy2s_s0, 22603}, // __builtin_HEXAGON_M2_vmpy2s_s0
-      {Intrinsic::hexagon_M2_vmpy2s_s0pack, 22634}, // __builtin_HEXAGON_M2_vmpy2s_s0pack
-      {Intrinsic::hexagon_M2_vmpy2s_s1, 22669}, // __builtin_HEXAGON_M2_vmpy2s_s1
-      {Intrinsic::hexagon_M2_vmpy2s_s1pack, 22700}, // __builtin_HEXAGON_M2_vmpy2s_s1pack
-      {Intrinsic::hexagon_M2_vmpy2su_s0, 22735}, // __builtin_HEXAGON_M2_vmpy2su_s0
-      {Intrinsic::hexagon_M2_vmpy2su_s1, 22767}, // __builtin_HEXAGON_M2_vmpy2su_s1
-      {Intrinsic::hexagon_M2_vraddh, 22799}, // __builtin_HEXAGON_M2_vraddh
-      {Intrinsic::hexagon_M2_vradduh, 22827}, // __builtin_HEXAGON_M2_vradduh
-      {Intrinsic::hexagon_M2_vrcmaci_s0, 22856}, // __builtin_HEXAGON_M2_vrcmaci_s0
-      {Intrinsic::hexagon_M2_vrcmaci_s0c, 22888}, // __builtin_HEXAGON_M2_vrcmaci_s0c
-      {Intrinsic::hexagon_M2_vrcmacr_s0, 22921}, // __builtin_HEXAGON_M2_vrcmacr_s0
-      {Intrinsic::hexagon_M2_vrcmacr_s0c, 22953}, // __builtin_HEXAGON_M2_vrcmacr_s0c
-      {Intrinsic::hexagon_M2_vrcmpyi_s0, 22986}, // __builtin_HEXAGON_M2_vrcmpyi_s0
-      {Intrinsic::hexagon_M2_vrcmpyi_s0c, 23018}, // __builtin_HEXAGON_M2_vrcmpyi_s0c
-      {Intrinsic::hexagon_M2_vrcmpyr_s0, 23051}, // __builtin_HEXAGON_M2_vrcmpyr_s0
-      {Intrinsic::hexagon_M2_vrcmpyr_s0c, 23083}, // __builtin_HEXAGON_M2_vrcmpyr_s0c
-      {Intrinsic::hexagon_M2_vrcmpys_acc_s1, 23116}, // __builtin_HEXAGON_M2_vrcmpys_acc_s1
-      {Intrinsic::hexagon_M2_vrcmpys_s1, 23152}, // __builtin_HEXAGON_M2_vrcmpys_s1
-      {Intrinsic::hexagon_M2_vrcmpys_s1rp, 23184}, // __builtin_HEXAGON_M2_vrcmpys_s1rp
-      {Intrinsic::hexagon_M2_vrmac_s0, 23218}, // __builtin_HEXAGON_M2_vrmac_s0
-      {Intrinsic::hexagon_M2_vrmpy_s0, 23248}, // __builtin_HEXAGON_M2_vrmpy_s0
-      {Intrinsic::hexagon_M2_xor_xacc, 23278}, // __builtin_HEXAGON_M2_xor_xacc
-      {Intrinsic::hexagon_M4_and_and, 23308}, // __builtin_HEXAGON_M4_and_and
-      {Intrinsic::hexagon_M4_and_andn, 23337}, // __builtin_HEXAGON_M4_and_andn
-      {Intrinsic::hexagon_M4_and_or, 23367}, // __builtin_HEXAGON_M4_and_or
-      {Intrinsic::hexagon_M4_and_xor, 23395}, // __builtin_HEXAGON_M4_and_xor
-      {Intrinsic::hexagon_M4_cmpyi_wh, 23424}, // __builtin_HEXAGON_M4_cmpyi_wh
-      {Intrinsic::hexagon_M4_cmpyi_whc, 23454}, // __builtin_HEXAGON_M4_cmpyi_whc
-      {Intrinsic::hexagon_M4_cmpyr_wh, 23485}, // __builtin_HEXAGON_M4_cmpyr_wh
-      {Intrinsic::hexagon_M4_cmpyr_whc, 23515}, // __builtin_HEXAGON_M4_cmpyr_whc
-      {Intrinsic::hexagon_M4_mac_up_s1_sat, 23546}, // __builtin_HEXAGON_M4_mac_up_s1_sat
-      {Intrinsic::hexagon_M4_mpyri_addi, 23581}, // __builtin_HEXAGON_M4_mpyri_addi
-      {Intrinsic::hexagon_M4_mpyri_addr, 23613}, // __builtin_HEXAGON_M4_mpyri_addr
-      {Intrinsic::hexagon_M4_mpyri_addr_u2, 23645}, // __builtin_HEXAGON_M4_mpyri_addr_u2
-      {Intrinsic::hexagon_M4_mpyrr_addi, 23680}, // __builtin_HEXAGON_M4_mpyrr_addi
-      {Intrinsic::hexagon_M4_mpyrr_addr, 23712}, // __builtin_HEXAGON_M4_mpyrr_addr
-      {Intrinsic::hexagon_M4_nac_up_s1_sat, 23744}, // __builtin_HEXAGON_M4_nac_up_s1_sat
-      {Intrinsic::hexagon_M4_or_and, 23779}, // __builtin_HEXAGON_M4_or_and
-      {Intrinsic::hexagon_M4_or_andn, 23807}, // __builtin_HEXAGON_M4_or_andn
-      {Intrinsic::hexagon_M4_or_or, 23836}, // __builtin_HEXAGON_M4_or_or
-      {Intrinsic::hexagon_M4_or_xor, 23863}, // __builtin_HEXAGON_M4_or_xor
-      {Intrinsic::hexagon_M4_pmpyw, 23891}, // __builtin_HEXAGON_M4_pmpyw
-      {Intrinsic::hexagon_M4_pmpyw_acc, 23918}, // __builtin_HEXAGON_M4_pmpyw_acc
-      {Intrinsic::hexagon_M4_vpmpyh, 23949}, // __builtin_HEXAGON_M4_vpmpyh
-      {Intrinsic::hexagon_M4_vpmpyh_acc, 23977}, // __builtin_HEXAGON_M4_vpmpyh_acc
-      {Intrinsic::hexagon_M4_vrmpyeh_acc_s0, 24009}, // __builtin_HEXAGON_M4_vrmpyeh_acc_s0
-      {Intrinsic::hexagon_M4_vrmpyeh_acc_s1, 24045}, // __builtin_HEXAGON_M4_vrmpyeh_acc_s1
-      {Intrinsic::hexagon_M4_vrmpyeh_s0, 24081}, // __builtin_HEXAGON_M4_vrmpyeh_s0
-      {Intrinsic::hexagon_M4_vrmpyeh_s1, 24113}, // __builtin_HEXAGON_M4_vrmpyeh_s1
-      {Intrinsic::hexagon_M4_vrmpyoh_acc_s0, 24145}, // __builtin_HEXAGON_M4_vrmpyoh_acc_s0
-      {Intrinsic::hexagon_M4_vrmpyoh_acc_s1, 24181}, // __builtin_HEXAGON_M4_vrmpyoh_acc_s1
-      {Intrinsic::hexagon_M4_vrmpyoh_s0, 24217}, // __builtin_HEXAGON_M4_vrmpyoh_s0
-      {Intrinsic::hexagon_M4_vrmpyoh_s1, 24249}, // __builtin_HEXAGON_M4_vrmpyoh_s1
-      {Intrinsic::hexagon_M4_xor_and, 24281}, // __builtin_HEXAGON_M4_xor_and
-      {Intrinsic::hexagon_M4_xor_andn, 24310}, // __builtin_HEXAGON_M4_xor_andn
-      {Intrinsic::hexagon_M4_xor_or, 24340}, // __builtin_HEXAGON_M4_xor_or
-      {Intrinsic::hexagon_M4_xor_xacc, 24368}, // __builtin_HEXAGON_M4_xor_xacc
-      {Intrinsic::hexagon_M5_vdmacbsu, 24398}, // __builtin_HEXAGON_M5_vdmacbsu
-      {Intrinsic::hexagon_M5_vdmpybsu, 24428}, // __builtin_HEXAGON_M5_vdmpybsu
-      {Intrinsic::hexagon_M5_vmacbsu, 24458}, // __builtin_HEXAGON_M5_vmacbsu
-      {Intrinsic::hexagon_M5_vmacbuu, 24487}, // __builtin_HEXAGON_M5_vmacbuu
-      {Intrinsic::hexagon_M5_vmpybsu, 24516}, // __builtin_HEXAGON_M5_vmpybsu
-      {Intrinsic::hexagon_M5_vmpybuu, 24545}, // __builtin_HEXAGON_M5_vmpybuu
-      {Intrinsic::hexagon_M5_vrmacbsu, 24574}, // __builtin_HEXAGON_M5_vrmacbsu
-      {Intrinsic::hexagon_M5_vrmacbuu, 24604}, // __builtin_HEXAGON_M5_vrmacbuu
-      {Intrinsic::hexagon_M5_vrmpybsu, 24634}, // __builtin_HEXAGON_M5_vrmpybsu
-      {Intrinsic::hexagon_M5_vrmpybuu, 24664}, // __builtin_HEXAGON_M5_vrmpybuu
-      {Intrinsic::hexagon_M6_vabsdiffb, 24694}, // __builtin_HEXAGON_M6_vabsdiffb
-      {Intrinsic::hexagon_M6_vabsdiffub, 24725}, // __builtin_HEXAGON_M6_vabsdiffub
-      {Intrinsic::hexagon_S2_addasl_rrri, 24757}, // __builtin_HEXAGON_S2_addasl_rrri
-      {Intrinsic::hexagon_S2_asl_i_p, 24790}, // __builtin_HEXAGON_S2_asl_i_p
-      {Intrinsic::hexagon_S2_asl_i_p_acc, 24819}, // __builtin_HEXAGON_S2_asl_i_p_acc
-      {Intrinsic::hexagon_S2_asl_i_p_and, 24852}, // __builtin_HEXAGON_S2_asl_i_p_and
-      {Intrinsic::hexagon_S2_asl_i_p_nac, 24885}, // __builtin_HEXAGON_S2_asl_i_p_nac
-      {Intrinsic::hexagon_S2_asl_i_p_or, 24918}, // __builtin_HEXAGON_S2_asl_i_p_or
-      {Intrinsic::hexagon_S2_asl_i_p_xacc, 24950}, // __builtin_HEXAGON_S2_asl_i_p_xacc
-      {Intrinsic::hexagon_S2_asl_i_r, 24984}, // __builtin_HEXAGON_S2_asl_i_r
-      {Intrinsic::hexagon_S2_asl_i_r_acc, 25013}, // __builtin_HEXAGON_S2_asl_i_r_acc
-      {Intrinsic::hexagon_S2_asl_i_r_and, 25046}, // __builtin_HEXAGON_S2_asl_i_r_and
-      {Intrinsic::hexagon_S2_asl_i_r_nac, 25079}, // __builtin_HEXAGON_S2_asl_i_r_nac
-      {Intrinsic::hexagon_S2_asl_i_r_or, 25112}, // __builtin_HEXAGON_S2_asl_i_r_or
-      {Intrinsic::hexagon_S2_asl_i_r_sat, 25144}, // __builtin_HEXAGON_S2_asl_i_r_sat
-      {Intrinsic::hexagon_S2_asl_i_r_xacc, 25177}, // __builtin_HEXAGON_S2_asl_i_r_xacc
-      {Intrinsic::hexagon_S2_asl_i_vh, 25211}, // __builtin_HEXAGON_S2_asl_i_vh
-      {Intrinsic::hexagon_S2_asl_i_vw, 25241}, // __builtin_HEXAGON_S2_asl_i_vw
-      {Intrinsic::hexagon_S2_asl_r_p, 25271}, // __builtin_HEXAGON_S2_asl_r_p
-      {Intrinsic::hexagon_S2_asl_r_p_acc, 25300}, // __builtin_HEXAGON_S2_asl_r_p_acc
-      {Intrinsic::hexagon_S2_asl_r_p_and, 25333}, // __builtin_HEXAGON_S2_asl_r_p_and
-      {Intrinsic::hexagon_S2_asl_r_p_nac, 25366}, // __builtin_HEXAGON_S2_asl_r_p_nac
-      {Intrinsic::hexagon_S2_asl_r_p_or, 25399}, // __builtin_HEXAGON_S2_asl_r_p_or
-      {Intrinsic::hexagon_S2_asl_r_p_xor, 25431}, // __builtin_HEXAGON_S2_asl_r_p_xor
-      {Intrinsic::hexagon_S2_asl_r_r, 25464}, // __builtin_HEXAGON_S2_asl_r_r
-      {Intrinsic::hexagon_S2_asl_r_r_acc, 25493}, // __builtin_HEXAGON_S2_asl_r_r_acc
-      {Intrinsic::hexagon_S2_asl_r_r_and, 25526}, // __builtin_HEXAGON_S2_asl_r_r_and
-      {Intrinsic::hexagon_S2_asl_r_r_nac, 25559}, // __builtin_HEXAGON_S2_asl_r_r_nac
-      {Intrinsic::hexagon_S2_asl_r_r_or, 25592}, // __builtin_HEXAGON_S2_asl_r_r_or
-      {Intrinsic::hexagon_S2_asl_r_r_sat, 25624}, // __builtin_HEXAGON_S2_asl_r_r_sat
-      {Intrinsic::hexagon_S2_asl_r_vh, 25657}, // __builtin_HEXAGON_S2_asl_r_vh
-      {Intrinsic::hexagon_S2_asl_r_vw, 25687}, // __builtin_HEXAGON_S2_asl_r_vw
-      {Intrinsic::hexagon_S2_asr_i_p, 25717}, // __builtin_HEXAGON_S2_asr_i_p
-      {Intrinsic::hexagon_S2_asr_i_p_acc, 25746}, // __builtin_HEXAGON_S2_asr_i_p_acc
-      {Intrinsic::hexagon_S2_asr_i_p_and, 25779}, // __builtin_HEXAGON_S2_asr_i_p_and
-      {Intrinsic::hexagon_S2_asr_i_p_nac, 25812}, // __builtin_HEXAGON_S2_asr_i_p_nac
-      {Intrinsic::hexagon_S2_asr_i_p_or, 25845}, // __builtin_HEXAGON_S2_asr_i_p_or
-      {Intrinsic::hexagon_S2_asr_i_p_rnd, 25877}, // __builtin_HEXAGON_S2_asr_i_p_rnd
-      {Intrinsic::hexagon_S2_asr_i_p_rnd_goodsyntax, 25910}, // __builtin_HEXAGON_S2_asr_i_p_rnd_goodsyntax
-      {Intrinsic::hexagon_S2_asr_i_r, 25954}, // __builtin_HEXAGON_S2_asr_i_r
-      {Intrinsic::hexagon_S2_asr_i_r_acc, 25983}, // __builtin_HEXAGON_S2_asr_i_r_acc
-      {Intrinsic::hexagon_S2_asr_i_r_and, 26016}, // __builtin_HEXAGON_S2_asr_i_r_and
-      {Intrinsic::hexagon_S2_asr_i_r_nac, 26049}, // __builtin_HEXAGON_S2_asr_i_r_nac
-      {Intrinsic::hexagon_S2_asr_i_r_or, 26082}, // __builtin_HEXAGON_S2_asr_i_r_or
-      {Intrinsic::hexagon_S2_asr_i_r_rnd, 26114}, // __builtin_HEXAGON_S2_asr_i_r_rnd
-      {Intrinsic::hexagon_S2_asr_i_r_rnd_goodsyntax, 26147}, // __builtin_HEXAGON_S2_asr_i_r_rnd_goodsyntax
-      {Intrinsic::hexagon_S2_asr_i_svw_trun, 26191}, // __builtin_HEXAGON_S2_asr_i_svw_trun
-      {Intrinsic::hexagon_S2_asr_i_vh, 26227}, // __builtin_HEXAGON_S2_asr_i_vh
-      {Intrinsic::hexagon_S2_asr_i_vw, 26257}, // __builtin_HEXAGON_S2_asr_i_vw
-      {Intrinsic::hexagon_S2_asr_r_p, 26287}, // __builtin_HEXAGON_S2_asr_r_p
-      {Intrinsic::hexagon_S2_asr_r_p_acc, 26316}, // __builtin_HEXAGON_S2_asr_r_p_acc
-      {Intrinsic::hexagon_S2_asr_r_p_and, 26349}, // __builtin_HEXAGON_S2_asr_r_p_and
-      {Intrinsic::hexagon_S2_asr_r_p_nac, 26382}, // __builtin_HEXAGON_S2_asr_r_p_nac
-      {Intrinsic::hexagon_S2_asr_r_p_or, 26415}, // __builtin_HEXAGON_S2_asr_r_p_or
-      {Intrinsic::hexagon_S2_asr_r_p_xor, 26447}, // __builtin_HEXAGON_S2_asr_r_p_xor
-      {Intrinsic::hexagon_S2_asr_r_r, 26480}, // __builtin_HEXAGON_S2_asr_r_r
-      {Intrinsic::hexagon_S2_asr_r_r_acc, 26509}, // __builtin_HEXAGON_S2_asr_r_r_acc
-      {Intrinsic::hexagon_S2_asr_r_r_and, 26542}, // __builtin_HEXAGON_S2_asr_r_r_and
-      {Intrinsic::hexagon_S2_asr_r_r_nac, 26575}, // __builtin_HEXAGON_S2_asr_r_r_nac
-      {Intrinsic::hexagon_S2_asr_r_r_or, 26608}, // __builtin_HEXAGON_S2_asr_r_r_or
-      {Intrinsic::hexagon_S2_asr_r_r_sat, 26640}, // __builtin_HEXAGON_S2_asr_r_r_sat
-      {Intrinsic::hexagon_S2_asr_r_svw_trun, 26673}, // __builtin_HEXAGON_S2_asr_r_svw_trun
-      {Intrinsic::hexagon_S2_asr_r_vh, 26709}, // __builtin_HEXAGON_S2_asr_r_vh
-      {Intrinsic::hexagon_S2_asr_r_vw, 26739}, // __builtin_HEXAGON_S2_asr_r_vw
-      {Intrinsic::hexagon_S2_brev, 26769}, // __builtin_HEXAGON_S2_brev
-      {Intrinsic::hexagon_S2_brevp, 26795}, // __builtin_HEXAGON_S2_brevp
-      {Intrinsic::hexagon_S2_cl0, 26822}, // __builtin_HEXAGON_S2_cl0
-      {Intrinsic::hexagon_S2_cl0p, 26847}, // __builtin_HEXAGON_S2_cl0p
-      {Intrinsic::hexagon_S2_cl1, 26873}, // __builtin_HEXAGON_S2_cl1
-      {Intrinsic::hexagon_S2_cl1p, 26898}, // __builtin_HEXAGON_S2_cl1p
-      {Intrinsic::hexagon_S2_clb, 26924}, // __builtin_HEXAGON_S2_clb
-      {Intrinsic::hexagon_S2_clbnorm, 26949}, // __builtin_HEXAGON_S2_clbnorm
-      {Intrinsic::hexagon_S2_clbp, 26978}, // __builtin_HEXAGON_S2_clbp
-      {Intrinsic::hexagon_S2_clrbit_i, 27004}, // __builtin_HEXAGON_S2_clrbit_i
-      {Intrinsic::hexagon_S2_clrbit_r, 27034}, // __builtin_HEXAGON_S2_clrbit_r
-      {Intrinsic::hexagon_S2_ct0, 27064}, // __builtin_HEXAGON_S2_ct0
-      {Intrinsic::hexagon_S2_ct0p, 27089}, // __builtin_HEXAGON_S2_ct0p
-      {Intrinsic::hexagon_S2_ct1, 27115}, // __builtin_HEXAGON_S2_ct1
-      {Intrinsic::hexagon_S2_ct1p, 27140}, // __builtin_HEXAGON_S2_ct1p
-      {Intrinsic::hexagon_S2_deinterleave, 27166}, // __builtin_HEXAGON_S2_deinterleave
-      {Intrinsic::hexagon_S2_extractu, 27200}, // __builtin_HEXAGON_S2_extractu
-      {Intrinsic::hexagon_S2_extractu_rp, 27230}, // __builtin_HEXAGON_S2_extractu_rp
-      {Intrinsic::hexagon_S2_extractup, 27263}, // __builtin_HEXAGON_S2_extractup
-      {Intrinsic::hexagon_S2_extractup_rp, 27294}, // __builtin_HEXAGON_S2_extractup_rp
-      {Intrinsic::hexagon_S2_insert, 27328}, // __builtin_HEXAGON_S2_insert
-      {Intrinsic::hexagon_S2_insert_rp, 27356}, // __builtin_HEXAGON_S2_insert_rp
-      {Intrinsic::hexagon_S2_insertp, 27387}, // __builtin_HEXAGON_S2_insertp
-      {Intrinsic::hexagon_S2_insertp_rp, 27416}, // __builtin_HEXAGON_S2_insertp_rp
-      {Intrinsic::hexagon_S2_interleave, 27448}, // __builtin_HEXAGON_S2_interleave
-      {Intrinsic::hexagon_S2_lfsp, 27480}, // __builtin_HEXAGON_S2_lfsp
-      {Intrinsic::hexagon_S2_lsl_r_p, 27506}, // __builtin_HEXAGON_S2_lsl_r_p
-      {Intrinsic::hexagon_S2_lsl_r_p_acc, 27535}, // __builtin_HEXAGON_S2_lsl_r_p_acc
-      {Intrinsic::hexagon_S2_lsl_r_p_and, 27568}, // __builtin_HEXAGON_S2_lsl_r_p_and
-      {Intrinsic::hexagon_S2_lsl_r_p_nac, 27601}, // __builtin_HEXAGON_S2_lsl_r_p_nac
-      {Intrinsic::hexagon_S2_lsl_r_p_or, 27634}, // __builtin_HEXAGON_S2_lsl_r_p_or
-      {Intrinsic::hexagon_S2_lsl_r_p_xor, 27666}, // __builtin_HEXAGON_S2_lsl_r_p_xor
-      {Intrinsic::hexagon_S2_lsl_r_r, 27699}, // __builtin_HEXAGON_S2_lsl_r_r
-      {Intrinsic::hexagon_S2_lsl_r_r_acc, 27728}, // __builtin_HEXAGON_S2_lsl_r_r_acc
-      {Intrinsic::hexagon_S2_lsl_r_r_and, 27761}, // __builtin_HEXAGON_S2_lsl_r_r_and
-      {Intrinsic::hexagon_S2_lsl_r_r_nac, 27794}, // __builtin_HEXAGON_S2_lsl_r_r_nac
-      {Intrinsic::hexagon_S2_lsl_r_r_or, 27827}, // __builtin_HEXAGON_S2_lsl_r_r_or
-      {Intrinsic::hexagon_S2_lsl_r_vh, 27859}, // __builtin_HEXAGON_S2_lsl_r_vh
-      {Intrinsic::hexagon_S2_lsl_r_vw, 27889}, // __builtin_HEXAGON_S2_lsl_r_vw
-      {Intrinsic::hexagon_S2_lsr_i_p, 27919}, // __builtin_HEXAGON_S2_lsr_i_p
-      {Intrinsic::hexagon_S2_lsr_i_p_acc, 27948}, // __builtin_HEXAGON_S2_lsr_i_p_acc
-      {Intrinsic::hexagon_S2_lsr_i_p_and, 27981}, // __builtin_HEXAGON_S2_lsr_i_p_and
-      {Intrinsic::hexagon_S2_lsr_i_p_nac, 28014}, // __builtin_HEXAGON_S2_lsr_i_p_nac
-      {Intrinsic::hexagon_S2_lsr_i_p_or, 28047}, // __builtin_HEXAGON_S2_lsr_i_p_or
-      {Intrinsic::hexagon_S2_lsr_i_p_xacc, 28079}, // __builtin_HEXAGON_S2_lsr_i_p_xacc
-      {Intrinsic::hexagon_S2_lsr_i_r, 28113}, // __builtin_HEXAGON_S2_lsr_i_r
-      {Intrinsic::hexagon_S2_lsr_i_r_acc, 28142}, // __builtin_HEXAGON_S2_lsr_i_r_acc
-      {Intrinsic::hexagon_S2_lsr_i_r_and, 28175}, // __builtin_HEXAGON_S2_lsr_i_r_and
-      {Intrinsic::hexagon_S2_lsr_i_r_nac, 28208}, // __builtin_HEXAGON_S2_lsr_i_r_nac
-      {Intrinsic::hexagon_S2_lsr_i_r_or, 28241}, // __builtin_HEXAGON_S2_lsr_i_r_or
-      {Intrinsic::hexagon_S2_lsr_i_r_xacc, 28273}, // __builtin_HEXAGON_S2_lsr_i_r_xacc
-      {Intrinsic::hexagon_S2_lsr_i_vh, 28307}, // __builtin_HEXAGON_S2_lsr_i_vh
-      {Intrinsic::hexagon_S2_lsr_i_vw, 28337}, // __builtin_HEXAGON_S2_lsr_i_vw
-      {Intrinsic::hexagon_S2_lsr_r_p, 28367}, // __builtin_HEXAGON_S2_lsr_r_p
-      {Intrinsic::hexagon_S2_lsr_r_p_acc, 28396}, // __builtin_HEXAGON_S2_lsr_r_p_acc
-      {Intrinsic::hexagon_S2_lsr_r_p_and, 28429}, // __builtin_HEXAGON_S2_lsr_r_p_and
-      {Intrinsic::hexagon_S2_lsr_r_p_nac, 28462}, // __builtin_HEXAGON_S2_lsr_r_p_nac
-      {Intrinsic::hexagon_S2_lsr_r_p_or, 28495}, // __builtin_HEXAGON_S2_lsr_r_p_or
-      {Intrinsic::hexagon_S2_lsr_r_p_xor, 28527}, // __builtin_HEXAGON_S2_lsr_r_p_xor
-      {Intrinsic::hexagon_S2_lsr_r_r, 28560}, // __builtin_HEXAGON_S2_lsr_r_r
-      {Intrinsic::hexagon_S2_lsr_r_r_acc, 28589}, // __builtin_HEXAGON_S2_lsr_r_r_acc
-      {Intrinsic::hexagon_S2_lsr_r_r_and, 28622}, // __builtin_HEXAGON_S2_lsr_r_r_and
-      {Intrinsic::hexagon_S2_lsr_r_r_nac, 28655}, // __builtin_HEXAGON_S2_lsr_r_r_nac
-      {Intrinsic::hexagon_S2_lsr_r_r_or, 28688}, // __builtin_HEXAGON_S2_lsr_r_r_or
-      {Intrinsic::hexagon_S2_lsr_r_vh, 28720}, // __builtin_HEXAGON_S2_lsr_r_vh
-      {Intrinsic::hexagon_S2_lsr_r_vw, 28750}, // __builtin_HEXAGON_S2_lsr_r_vw
-      {Intrinsic::hexagon_S2_mask, 28780}, // __builtin_HEXAGON_S2_mask
-      {Intrinsic::hexagon_S2_packhl, 28806}, // __builtin_HEXAGON_S2_packhl
-      {Intrinsic::hexagon_S2_parityp, 28834}, // __builtin_HEXAGON_S2_parityp
-      {Intrinsic::hexagon_S2_setbit_i, 28863}, // __builtin_HEXAGON_S2_setbit_i
-      {Intrinsic::hexagon_S2_setbit_r, 28893}, // __builtin_HEXAGON_S2_setbit_r
-      {Intrinsic::hexagon_S2_shuffeb, 28923}, // __builtin_HEXAGON_S2_shuffeb
-      {Intrinsic::hexagon_S2_shuffeh, 28952}, // __builtin_HEXAGON_S2_shuffeh
-      {Intrinsic::hexagon_S2_shuffob, 28981}, // __builtin_HEXAGON_S2_shuffob
-      {Intrinsic::hexagon_S2_shuffoh, 29010}, // __builtin_HEXAGON_S2_shuffoh
-      {Intrinsic::hexagon_S2_storew_locked, 29136}, // __builtin_HEXAGON_S2_storew_locked
-      {Intrinsic::hexagon_S2_svsathb, 29171}, // __builtin_HEXAGON_S2_svsathb
-      {Intrinsic::hexagon_S2_svsathub, 29200}, // __builtin_HEXAGON_S2_svsathub
-      {Intrinsic::hexagon_S2_tableidxb_goodsyntax, 29230}, // __builtin_HEXAGON_S2_tableidxb_goodsyntax
-      {Intrinsic::hexagon_S2_tableidxd_goodsyntax, 29272}, // __builtin_HEXAGON_S2_tableidxd_goodsyntax
-      {Intrinsic::hexagon_S2_tableidxh_goodsyntax, 29314}, // __builtin_HEXAGON_S2_tableidxh_goodsyntax
-      {Intrinsic::hexagon_S2_tableidxw_goodsyntax, 29356}, // __builtin_HEXAGON_S2_tableidxw_goodsyntax
-      {Intrinsic::hexagon_S2_togglebit_i, 29398}, // __builtin_HEXAGON_S2_togglebit_i
-      {Intrinsic::hexagon_S2_togglebit_r, 29431}, // __builtin_HEXAGON_S2_togglebit_r
-      {Intrinsic::hexagon_S2_tstbit_i, 29464}, // __builtin_HEXAGON_S2_tstbit_i
-      {Intrinsic::hexagon_S2_tstbit_r, 29494}, // __builtin_HEXAGON_S2_tstbit_r
-      {Intrinsic::hexagon_S2_valignib, 29524}, // __builtin_HEXAGON_S2_valignib
-      {Intrinsic::hexagon_S2_valignrb, 29554}, // __builtin_HEXAGON_S2_valignrb
-      {Intrinsic::hexagon_S2_vcnegh, 29584}, // __builtin_HEXAGON_S2_vcnegh
-      {Intrinsic::hexagon_S2_vcrotate, 29612}, // __builtin_HEXAGON_S2_vcrotate
-      {Intrinsic::hexagon_S2_vrcnegh, 29642}, // __builtin_HEXAGON_S2_vrcnegh
-      {Intrinsic::hexagon_S2_vrndpackwh, 29671}, // __builtin_HEXAGON_S2_vrndpackwh
-      {Intrinsic::hexagon_S2_vrndpackwhs, 29703}, // __builtin_HEXAGON_S2_vrndpackwhs
-      {Intrinsic::hexagon_S2_vsathb, 29736}, // __builtin_HEXAGON_S2_vsathb
-      {Intrinsic::hexagon_S2_vsathb_nopack, 29764}, // __builtin_HEXAGON_S2_vsathb_nopack
-      {Intrinsic::hexagon_S2_vsathub, 29799}, // __builtin_HEXAGON_S2_vsathub
-      {Intrinsic::hexagon_S2_vsathub_nopack, 29828}, // __builtin_HEXAGON_S2_vsathub_nopack
-      {Intrinsic::hexagon_S2_vsatwh, 29864}, // __builtin_HEXAGON_S2_vsatwh
-      {Intrinsic::hexagon_S2_vsatwh_nopack, 29892}, // __builtin_HEXAGON_S2_vsatwh_nopack
-      {Intrinsic::hexagon_S2_vsatwuh, 29927}, // __builtin_HEXAGON_S2_vsatwuh
-      {Intrinsic::hexagon_S2_vsatwuh_nopack, 29956}, // __builtin_HEXAGON_S2_vsatwuh_nopack
-      {Intrinsic::hexagon_S2_vsplatrb, 29992}, // __builtin_HEXAGON_S2_vsplatrb
-      {Intrinsic::hexagon_S2_vsplatrh, 30022}, // __builtin_HEXAGON_S2_vsplatrh
-      {Intrinsic::hexagon_S2_vspliceib, 30052}, // __builtin_HEXAGON_S2_vspliceib
-      {Intrinsic::hexagon_S2_vsplicerb, 30083}, // __builtin_HEXAGON_S2_vsplicerb
-      {Intrinsic::hexagon_S2_vsxtbh, 30114}, // __builtin_HEXAGON_S2_vsxtbh
-      {Intrinsic::hexagon_S2_vsxthw, 30142}, // __builtin_HEXAGON_S2_vsxthw
-      {Intrinsic::hexagon_S2_vtrunehb, 30170}, // __builtin_HEXAGON_S2_vtrunehb
-      {Intrinsic::hexagon_S2_vtrunewh, 30200}, // __builtin_HEXAGON_S2_vtrunewh
-      {Intrinsic::hexagon_S2_vtrunohb, 30230}, // __builtin_HEXAGON_S2_vtrunohb
-      {Intrinsic::hexagon_S2_vtrunowh, 30260}, // __builtin_HEXAGON_S2_vtrunowh
-      {Intrinsic::hexagon_S2_vzxtbh, 30290}, // __builtin_HEXAGON_S2_vzxtbh
-      {Intrinsic::hexagon_S2_vzxthw, 30318}, // __builtin_HEXAGON_S2_vzxthw
-      {Intrinsic::hexagon_S4_addaddi, 30346}, // __builtin_HEXAGON_S4_addaddi
-      {Intrinsic::hexagon_S4_addi_asl_ri, 30375}, // __builtin_HEXAGON_S4_addi_asl_ri
-      {Intrinsic::hexagon_S4_addi_lsr_ri, 30408}, // __builtin_HEXAGON_S4_addi_lsr_ri
-      {Intrinsic::hexagon_S4_andi_asl_ri, 30441}, // __builtin_HEXAGON_S4_andi_asl_ri
-      {Intrinsic::hexagon_S4_andi_lsr_ri, 30474}, // __builtin_HEXAGON_S4_andi_lsr_ri
-      {Intrinsic::hexagon_S4_clbaddi, 30507}, // __builtin_HEXAGON_S4_clbaddi
-      {Intrinsic::hexagon_S4_clbpaddi, 30536}, // __builtin_HEXAGON_S4_clbpaddi
-      {Intrinsic::hexagon_S4_clbpnorm, 30566}, // __builtin_HEXAGON_S4_clbpnorm
-      {Intrinsic::hexagon_S4_extract, 30596}, // __builtin_HEXAGON_S4_extract
-      {Intrinsic::hexagon_S4_extract_rp, 30625}, // __builtin_HEXAGON_S4_extract_rp
-      {Intrinsic::hexagon_S4_extractp, 30657}, // __builtin_HEXAGON_S4_extractp
-      {Intrinsic::hexagon_S4_extractp_rp, 30687}, // __builtin_HEXAGON_S4_extractp_rp
-      {Intrinsic::hexagon_S4_lsli, 30720}, // __builtin_HEXAGON_S4_lsli
-      {Intrinsic::hexagon_S4_ntstbit_i, 30746}, // __builtin_HEXAGON_S4_ntstbit_i
-      {Intrinsic::hexagon_S4_ntstbit_r, 30777}, // __builtin_HEXAGON_S4_ntstbit_r
-      {Intrinsic::hexagon_S4_or_andi, 30808}, // __builtin_HEXAGON_S4_or_andi
-      {Intrinsic::hexagon_S4_or_andix, 30837}, // __builtin_HEXAGON_S4_or_andix
-      {Intrinsic::hexagon_S4_or_ori, 30867}, // __builtin_HEXAGON_S4_or_ori
-      {Intrinsic::hexagon_S4_ori_asl_ri, 30895}, // __builtin_HEXAGON_S4_ori_asl_ri
-      {Intrinsic::hexagon_S4_ori_lsr_ri, 30927}, // __builtin_HEXAGON_S4_ori_lsr_ri
-      {Intrinsic::hexagon_S4_parity, 30959}, // __builtin_HEXAGON_S4_parity
-      {Intrinsic::hexagon_S4_stored_locked, 30987}, // __builtin_HEXAGON_S4_stored_locked
-      {Intrinsic::hexagon_S4_subaddi, 31022}, // __builtin_HEXAGON_S4_subaddi
-      {Intrinsic::hexagon_S4_subi_asl_ri, 31051}, // __builtin_HEXAGON_S4_subi_asl_ri
-      {Intrinsic::hexagon_S4_subi_lsr_ri, 31084}, // __builtin_HEXAGON_S4_subi_lsr_ri
-      {Intrinsic::hexagon_S4_vrcrotate, 31117}, // __builtin_HEXAGON_S4_vrcrotate
-      {Intrinsic::hexagon_S4_vrcrotate_acc, 31148}, // __builtin_HEXAGON_S4_vrcrotate_acc
-      {Intrinsic::hexagon_S4_vxaddsubh, 31183}, // __builtin_HEXAGON_S4_vxaddsubh
-      {Intrinsic::hexagon_S4_vxaddsubhr, 31214}, // __builtin_HEXAGON_S4_vxaddsubhr
-      {Intrinsic::hexagon_S4_vxaddsubw, 31246}, // __builtin_HEXAGON_S4_vxaddsubw
-      {Intrinsic::hexagon_S4_vxsubaddh, 31277}, // __builtin_HEXAGON_S4_vxsubaddh
-      {Intrinsic::hexagon_S4_vxsubaddhr, 31308}, // __builtin_HEXAGON_S4_vxsubaddhr
-      {Intrinsic::hexagon_S4_vxsubaddw, 31340}, // __builtin_HEXAGON_S4_vxsubaddw
-      {Intrinsic::hexagon_S5_asrhub_rnd_sat_goodsyntax, 31371}, // __builtin_HEXAGON_S5_asrhub_rnd_sat_goodsyntax
-      {Intrinsic::hexagon_S5_asrhub_sat, 31418}, // __builtin_HEXAGON_S5_asrhub_sat
-      {Intrinsic::hexagon_S5_popcountp, 31450}, // __builtin_HEXAGON_S5_popcountp
-      {Intrinsic::hexagon_S5_vasrhrnd_goodsyntax, 31481}, // __builtin_HEXAGON_S5_vasrhrnd_goodsyntax
-      {Intrinsic::hexagon_S6_rol_i_p, 31522}, // __builtin_HEXAGON_S6_rol_i_p
-      {Intrinsic::hexagon_S6_rol_i_p_acc, 31551}, // __builtin_HEXAGON_S6_rol_i_p_acc
-      {Intrinsic::hexagon_S6_rol_i_p_and, 31584}, // __builtin_HEXAGON_S6_rol_i_p_and
-      {Intrinsic::hexagon_S6_rol_i_p_nac, 31617}, // __builtin_HEXAGON_S6_rol_i_p_nac
-      {Intrinsic::hexagon_S6_rol_i_p_or, 31650}, // __builtin_HEXAGON_S6_rol_i_p_or
-      {Intrinsic::hexagon_S6_rol_i_p_xacc, 31682}, // __builtin_HEXAGON_S6_rol_i_p_xacc
-      {Intrinsic::hexagon_S6_rol_i_r, 31716}, // __builtin_HEXAGON_S6_rol_i_r
-      {Intrinsic::hexagon_S6_rol_i_r_acc, 31745}, // __builtin_HEXAGON_S6_rol_i_r_acc
-      {Intrinsic::hexagon_S6_rol_i_r_and, 31778}, // __builtin_HEXAGON_S6_rol_i_r_and
-      {Intrinsic::hexagon_S6_rol_i_r_nac, 31811}, // __builtin_HEXAGON_S6_rol_i_r_nac
-      {Intrinsic::hexagon_S6_rol_i_r_or, 31844}, // __builtin_HEXAGON_S6_rol_i_r_or
-      {Intrinsic::hexagon_S6_rol_i_r_xacc, 31876}, // __builtin_HEXAGON_S6_rol_i_r_xacc
-      {Intrinsic::hexagon_S6_vsplatrbp, 31910}, // __builtin_HEXAGON_S6_vsplatrbp
-      {Intrinsic::hexagon_S6_vtrunehb_ppp, 31941}, // __builtin_HEXAGON_S6_vtrunehb_ppp
-      {Intrinsic::hexagon_S6_vtrunohb_ppp, 31975}, // __builtin_HEXAGON_S6_vtrunohb_ppp
-      {Intrinsic::hexagon_V6_extractw, 32009}, // __builtin_HEXAGON_V6_extractw
-      {Intrinsic::hexagon_V6_extractw_128B, 32039}, // __builtin_HEXAGON_V6_extractw_128B
-      {Intrinsic::hexagon_V6_hi, 32074}, // __builtin_HEXAGON_V6_hi
-      {Intrinsic::hexagon_V6_hi_128B, 32098}, // __builtin_HEXAGON_V6_hi_128B
-      {Intrinsic::hexagon_V6_ld0, 32127}, // __builtin_HEXAGON_V6_ld0
-      {Intrinsic::hexagon_V6_ld0_128B, 32152}, // __builtin_HEXAGON_V6_ld0_128B
-      {Intrinsic::hexagon_V6_ldcnp0, 32182}, // __builtin_HEXAGON_V6_ldcnp0
-      {Intrinsic::hexagon_V6_ldcnp0_128B, 32210}, // __builtin_HEXAGON_V6_ldcnp0_128B
-      {Intrinsic::hexagon_V6_ldcnpnt0, 32243}, // __builtin_HEXAGON_V6_ldcnpnt0
-      {Intrinsic::hexagon_V6_ldcnpnt0_128B, 32273}, // __builtin_HEXAGON_V6_ldcnpnt0_128B
-      {Intrinsic::hexagon_V6_ldcp0, 32308}, // __builtin_HEXAGON_V6_ldcp0
-      {Intrinsic::hexagon_V6_ldcp0_128B, 32335}, // __builtin_HEXAGON_V6_ldcp0_128B
-      {Intrinsic::hexagon_V6_ldcpnt0, 32367}, // __builtin_HEXAGON_V6_ldcpnt0
-      {Intrinsic::hexagon_V6_ldcpnt0_128B, 32396}, // __builtin_HEXAGON_V6_ldcpnt0_128B
-      {Intrinsic::hexagon_V6_ldnp0, 32430}, // __builtin_HEXAGON_V6_ldnp0
-      {Intrinsic::hexagon_V6_ldnp0_128B, 32457}, // __builtin_HEXAGON_V6_ldnp0_128B
-      {Intrinsic::hexagon_V6_ldnpnt0, 32489}, // __builtin_HEXAGON_V6_ldnpnt0
-      {Intrinsic::hexagon_V6_ldnpnt0_128B, 32518}, // __builtin_HEXAGON_V6_ldnpnt0_128B
-      {Intrinsic::hexagon_V6_ldnt0, 32552}, // __builtin_HEXAGON_V6_ldnt0
-      {Intrinsic::hexagon_V6_ldnt0_128B, 32579}, // __builtin_HEXAGON_V6_ldnt0_128B
-      {Intrinsic::hexagon_V6_ldntnt0, 32611}, // __builtin_HEXAGON_V6_ldntnt0
-      {Intrinsic::hexagon_V6_ldp0, 32640}, // __builtin_HEXAGON_V6_ldp0
-      {Intrinsic::hexagon_V6_ldp0_128B, 32666}, // __builtin_HEXAGON_V6_ldp0_128B
-      {Intrinsic::hexagon_V6_ldpnt0, 32697}, // __builtin_HEXAGON_V6_ldpnt0
-      {Intrinsic::hexagon_V6_ldpnt0_128B, 32725}, // __builtin_HEXAGON_V6_ldpnt0_128B
-      {Intrinsic::hexagon_V6_ldtnp0, 32758}, // __builtin_HEXAGON_V6_ldtnp0
-      {Intrinsic::hexagon_V6_ldtnp0_128B, 32786}, // __builtin_HEXAGON_V6_ldtnp0_128B
-      {Intrinsic::hexagon_V6_ldtnpnt0, 32819}, // __builtin_HEXAGON_V6_ldtnpnt0
-      {Intrinsic::hexagon_V6_ldtnpnt0_128B, 32849}, // __builtin_HEXAGON_V6_ldtnpnt0_128B
-      {Intrinsic::hexagon_V6_ldtp0, 32884}, // __builtin_HEXAGON_V6_ldtp0
-      {Intrinsic::hexagon_V6_ldtp0_128B, 32911}, // __builtin_HEXAGON_V6_ldtp0_128B
-      {Intrinsic::hexagon_V6_ldtpnt0, 32943}, // __builtin_HEXAGON_V6_ldtpnt0
-      {Intrinsic::hexagon_V6_ldtpnt0_128B, 32972}, // __builtin_HEXAGON_V6_ldtpnt0_128B
-      {Intrinsic::hexagon_V6_ldu0, 33006}, // __builtin_HEXAGON_V6_ldu0
-      {Intrinsic::hexagon_V6_ldu0_128B, 33032}, // __builtin_HEXAGON_V6_ldu0_128B
-      {Intrinsic::hexagon_V6_lo, 33063}, // __builtin_HEXAGON_V6_lo
-      {Intrinsic::hexagon_V6_lo_128B, 33087}, // __builtin_HEXAGON_V6_lo_128B
-      {Intrinsic::hexagon_V6_lvsplatb, 33116}, // __builtin_HEXAGON_V6_lvsplatb
-      {Intrinsic::hexagon_V6_lvsplatb_128B, 33146}, // __builtin_HEXAGON_V6_lvsplatb_128B
-      {Intrinsic::hexagon_V6_lvsplath, 33181}, // __builtin_HEXAGON_V6_lvsplath
-      {Intrinsic::hexagon_V6_lvsplath_128B, 33211}, // __builtin_HEXAGON_V6_lvsplath_128B
-      {Intrinsic::hexagon_V6_lvsplatw, 33246}, // __builtin_HEXAGON_V6_lvsplatw
-      {Intrinsic::hexagon_V6_lvsplatw_128B, 33276}, // __builtin_HEXAGON_V6_lvsplatw_128B
-      {Intrinsic::hexagon_V6_pred_and, 33311}, // __builtin_HEXAGON_V6_pred_and
-      {Intrinsic::hexagon_V6_pred_and_128B, 33341}, // __builtin_HEXAGON_V6_pred_and_128B
-      {Intrinsic::hexagon_V6_pred_and_n, 33376}, // __builtin_HEXAGON_V6_pred_and_n
-      {Intrinsic::hexagon_V6_pred_and_n_128B, 33408}, // __builtin_HEXAGON_V6_pred_and_n_128B
-      {Intrinsic::hexagon_V6_pred_not, 33445}, // __builtin_HEXAGON_V6_pred_not
-      {Intrinsic::hexagon_V6_pred_not_128B, 33475}, // __builtin_HEXAGON_V6_pred_not_128B
-      {Intrinsic::hexagon_V6_pred_or, 33510}, // __builtin_HEXAGON_V6_pred_or
-      {Intrinsic::hexagon_V6_pred_or_128B, 33539}, // __builtin_HEXAGON_V6_pred_or_128B
-      {Intrinsic::hexagon_V6_pred_or_n, 33573}, // __builtin_HEXAGON_V6_pred_or_n
-      {Intrinsic::hexagon_V6_pred_or_n_128B, 33604}, // __builtin_HEXAGON_V6_pred_or_n_128B
-      {Intrinsic::hexagon_V6_pred_scalar2, 33640}, // __builtin_HEXAGON_V6_pred_scalar2
-      {Intrinsic::hexagon_V6_pred_scalar2_128B, 33674}, // __builtin_HEXAGON_V6_pred_scalar2_128B
-      {Intrinsic::hexagon_V6_pred_scalar2v2, 33713}, // __builtin_HEXAGON_V6_pred_scalar2v2
-      {Intrinsic::hexagon_V6_pred_scalar2v2_128B, 33749}, // __builtin_HEXAGON_V6_pred_scalar2v2_128B
-      {Intrinsic::hexagon_V6_pred_xor, 33790}, // __builtin_HEXAGON_V6_pred_xor
-      {Intrinsic::hexagon_V6_pred_xor_128B, 33820}, // __builtin_HEXAGON_V6_pred_xor_128B
-      {Intrinsic::hexagon_V6_shuffeqh, 33855}, // __builtin_HEXAGON_V6_shuffeqh
-      {Intrinsic::hexagon_V6_shuffeqh_128B, 33885}, // __builtin_HEXAGON_V6_shuffeqh_128B
-      {Intrinsic::hexagon_V6_shuffeqw, 33920}, // __builtin_HEXAGON_V6_shuffeqw
-      {Intrinsic::hexagon_V6_shuffeqw_128B, 33950}, // __builtin_HEXAGON_V6_shuffeqw_128B
-      {Intrinsic::hexagon_V6_vS32b_nqpred_ai, 33985}, // __builtin_HEXAGON_V6_vS32b_nqpred_ai
-      {Intrinsic::hexagon_V6_vS32b_nqpred_ai_128B, 34022}, // __builtin_HEXAGON_V6_vS32b_nqpred_ai_128B
-      {Intrinsic::hexagon_V6_vS32b_nt_nqpred_ai, 34064}, // __builtin_HEXAGON_V6_vS32b_nt_nqpred_ai
-      {Intrinsic::hexagon_V6_vS32b_nt_nqpred_ai_128B, 34104}, // __builtin_HEXAGON_V6_vS32b_nt_nqpred_ai_128B
-      {Intrinsic::hexagon_V6_vS32b_nt_qpred_ai, 34149}, // __builtin_HEXAGON_V6_vS32b_nt_qpred_ai
-      {Intrinsic::hexagon_V6_vS32b_nt_qpred_ai_128B, 34188}, // __builtin_HEXAGON_V6_vS32b_nt_qpred_ai_128B
-      {Intrinsic::hexagon_V6_vS32b_qpred_ai, 34232}, // __builtin_HEXAGON_V6_vS32b_qpred_ai
-      {Intrinsic::hexagon_V6_vS32b_qpred_ai_128B, 34268}, // __builtin_HEXAGON_V6_vS32b_qpred_ai_128B
-      {Intrinsic::hexagon_V6_vabsb, 34309}, // __builtin_HEXAGON_V6_vabsb
-      {Intrinsic::hexagon_V6_vabsb_128B, 34336}, // __builtin_HEXAGON_V6_vabsb_128B
-      {Intrinsic::hexagon_V6_vabsb_sat, 34368}, // __builtin_HEXAGON_V6_vabsb_sat
-      {Intrinsic::hexagon_V6_vabsb_sat_128B, 34399}, // __builtin_HEXAGON_V6_vabsb_sat_128B
-      {Intrinsic::hexagon_V6_vabsdiffh, 34435}, // __builtin_HEXAGON_V6_vabsdiffh
-      {Intrinsic::hexagon_V6_vabsdiffh_128B, 34466}, // __builtin_HEXAGON_V6_vabsdiffh_128B
-      {Intrinsic::hexagon_V6_vabsdiffub, 34502}, // __builtin_HEXAGON_V6_vabsdiffub
-      {Intrinsic::hexagon_V6_vabsdiffub_128B, 34534}, // __builtin_HEXAGON_V6_vabsdiffub_128B
-      {Intrinsic::hexagon_V6_vabsdiffuh, 34571}, // __builtin_HEXAGON_V6_vabsdiffuh
-      {Intrinsic::hexagon_V6_vabsdiffuh_128B, 34603}, // __builtin_HEXAGON_V6_vabsdiffuh_128B
-      {Intrinsic::hexagon_V6_vabsdiffw, 34640}, // __builtin_HEXAGON_V6_vabsdiffw
-      {Intrinsic::hexagon_V6_vabsdiffw_128B, 34671}, // __builtin_HEXAGON_V6_vabsdiffw_128B
-      {Intrinsic::hexagon_V6_vabsh, 34707}, // __builtin_HEXAGON_V6_vabsh
-      {Intrinsic::hexagon_V6_vabsh_128B, 34734}, // __builtin_HEXAGON_V6_vabsh_128B
-      {Intrinsic::hexagon_V6_vabsh_sat, 34766}, // __builtin_HEXAGON_V6_vabsh_sat
-      {Intrinsic::hexagon_V6_vabsh_sat_128B, 34797}, // __builtin_HEXAGON_V6_vabsh_sat_128B
-      {Intrinsic::hexagon_V6_vabsw, 34833}, // __builtin_HEXAGON_V6_vabsw
-      {Intrinsic::hexagon_V6_vabsw_128B, 34860}, // __builtin_HEXAGON_V6_vabsw_128B
-      {Intrinsic::hexagon_V6_vabsw_sat, 34892}, // __builtin_HEXAGON_V6_vabsw_sat
-      {Intrinsic::hexagon_V6_vabsw_sat_128B, 34923}, // __builtin_HEXAGON_V6_vabsw_sat_128B
-      {Intrinsic::hexagon_V6_vaddb, 34959}, // __builtin_HEXAGON_V6_vaddb
-      {Intrinsic::hexagon_V6_vaddb_128B, 34986}, // __builtin_HEXAGON_V6_vaddb_128B
-      {Intrinsic::hexagon_V6_vaddb_dv, 35018}, // __builtin_HEXAGON_V6_vaddb_dv
-      {Intrinsic::hexagon_V6_vaddb_dv_128B, 35048}, // __builtin_HEXAGON_V6_vaddb_dv_128B
-      {Intrinsic::hexagon_V6_vaddbnq, 35083}, // __builtin_HEXAGON_V6_vaddbnq
-      {Intrinsic::hexagon_V6_vaddbnq_128B, 35112}, // __builtin_HEXAGON_V6_vaddbnq_128B
-      {Intrinsic::hexagon_V6_vaddbq, 35146}, // __builtin_HEXAGON_V6_vaddbq
-      {Intrinsic::hexagon_V6_vaddbq_128B, 35174}, // __builtin_HEXAGON_V6_vaddbq_128B
-      {Intrinsic::hexagon_V6_vaddbsat, 35207}, // __builtin_HEXAGON_V6_vaddbsat
-      {Intrinsic::hexagon_V6_vaddbsat_128B, 35237}, // __builtin_HEXAGON_V6_vaddbsat_128B
-      {Intrinsic::hexagon_V6_vaddbsat_dv, 35272}, // __builtin_HEXAGON_V6_vaddbsat_dv
-      {Intrinsic::hexagon_V6_vaddbsat_dv_128B, 35305}, // __builtin_HEXAGON_V6_vaddbsat_dv_128B
-      {Intrinsic::hexagon_V6_vaddcarrysat, 35343}, // __builtin_HEXAGON_V6_vaddcarrysat
-      {Intrinsic::hexagon_V6_vaddcarrysat_128B, 35377}, // __builtin_HEXAGON_V6_vaddcarrysat_128B
-      {Intrinsic::hexagon_V6_vaddclbh, 35416}, // __builtin_HEXAGON_V6_vaddclbh
-      {Intrinsic::hexagon_V6_vaddclbh_128B, 35446}, // __builtin_HEXAGON_V6_vaddclbh_128B
-      {Intrinsic::hexagon_V6_vaddclbw, 35481}, // __builtin_HEXAGON_V6_vaddclbw
-      {Intrinsic::hexagon_V6_vaddclbw_128B, 35511}, // __builtin_HEXAGON_V6_vaddclbw_128B
-      {Intrinsic::hexagon_V6_vaddh, 35546}, // __builtin_HEXAGON_V6_vaddh
-      {Intrinsic::hexagon_V6_vaddh_128B, 35573}, // __builtin_HEXAGON_V6_vaddh_128B
-      {Intrinsic::hexagon_V6_vaddh_dv, 35605}, // __builtin_HEXAGON_V6_vaddh_dv
-      {Intrinsic::hexagon_V6_vaddh_dv_128B, 35635}, // __builtin_HEXAGON_V6_vaddh_dv_128B
-      {Intrinsic::hexagon_V6_vaddhnq, 35670}, // __builtin_HEXAGON_V6_vaddhnq
-      {Intrinsic::hexagon_V6_vaddhnq_128B, 35699}, // __builtin_HEXAGON_V6_vaddhnq_128B
-      {Intrinsic::hexagon_V6_vaddhq, 35733}, // __builtin_HEXAGON_V6_vaddhq
-      {Intrinsic::hexagon_V6_vaddhq_128B, 35761}, // __builtin_HEXAGON_V6_vaddhq_128B
-      {Intrinsic::hexagon_V6_vaddhsat, 35794}, // __builtin_HEXAGON_V6_vaddhsat
-      {Intrinsic::hexagon_V6_vaddhsat_128B, 35824}, // __builtin_HEXAGON_V6_vaddhsat_128B
-      {Intrinsic::hexagon_V6_vaddhsat_dv, 35859}, // __builtin_HEXAGON_V6_vaddhsat_dv
-      {Intrinsic::hexagon_V6_vaddhsat_dv_128B, 35892}, // __builtin_HEXAGON_V6_vaddhsat_dv_128B
-      {Intrinsic::hexagon_V6_vaddhw, 35930}, // __builtin_HEXAGON_V6_vaddhw
-      {Intrinsic::hexagon_V6_vaddhw_128B, 35958}, // __builtin_HEXAGON_V6_vaddhw_128B
-      {Intrinsic::hexagon_V6_vaddhw_acc, 35991}, // __builtin_HEXAGON_V6_vaddhw_acc
-      {Intrinsic::hexagon_V6_vaddhw_acc_128B, 36023}, // __builtin_HEXAGON_V6_vaddhw_acc_128B
-      {Intrinsic::hexagon_V6_vaddubh, 36060}, // __builtin_HEXAGON_V6_vaddubh
-      {Intrinsic::hexagon_V6_vaddubh_128B, 36089}, // __builtin_HEXAGON_V6_vaddubh_128B
-      {Intrinsic::hexagon_V6_vaddubh_acc, 36123}, // __builtin_HEXAGON_V6_vaddubh_acc
-      {Intrinsic::hexagon_V6_vaddubh_acc_128B, 36156}, // __builtin_HEXAGON_V6_vaddubh_acc_128B
-      {Intrinsic::hexagon_V6_vaddubsat, 36194}, // __builtin_HEXAGON_V6_vaddubsat
-      {Intrinsic::hexagon_V6_vaddubsat_128B, 36225}, // __builtin_HEXAGON_V6_vaddubsat_128B
-      {Intrinsic::hexagon_V6_vaddubsat_dv, 36261}, // __builtin_HEXAGON_V6_vaddubsat_dv
-      {Intrinsic::hexagon_V6_vaddubsat_dv_128B, 36295}, // __builtin_HEXAGON_V6_vaddubsat_dv_128B
-      {Intrinsic::hexagon_V6_vaddububb_sat, 36334}, // __builtin_HEXAGON_V6_vaddububb_sat
-      {Intrinsic::hexagon_V6_vaddububb_sat_128B, 36369}, // __builtin_HEXAGON_V6_vaddububb_sat_128B
-      {Intrinsic::hexagon_V6_vadduhsat, 36409}, // __builtin_HEXAGON_V6_vadduhsat
-      {Intrinsic::hexagon_V6_vadduhsat_128B, 36440}, // __builtin_HEXAGON_V6_vadduhsat_128B
-      {Intrinsic::hexagon_V6_vadduhsat_dv, 36476}, // __builtin_HEXAGON_V6_vadduhsat_dv
-      {Intrinsic::hexagon_V6_vadduhsat_dv_128B, 36510}, // __builtin_HEXAGON_V6_vadduhsat_dv_128B
-      {Intrinsic::hexagon_V6_vadduhw, 36549}, // __builtin_HEXAGON_V6_vadduhw
-      {Intrinsic::hexagon_V6_vadduhw_128B, 36578}, // __builtin_HEXAGON_V6_vadduhw_128B
-      {Intrinsic::hexagon_V6_vadduhw_acc, 36612}, // __builtin_HEXAGON_V6_vadduhw_acc
-      {Intrinsic::hexagon_V6_vadduhw_acc_128B, 36645}, // __builtin_HEXAGON_V6_vadduhw_acc_128B
-      {Intrinsic::hexagon_V6_vadduwsat, 36683}, // __builtin_HEXAGON_V6_vadduwsat
-      {Intrinsic::hexagon_V6_vadduwsat_128B, 36714}, // __builtin_HEXAGON_V6_vadduwsat_128B
-      {Intrinsic::hexagon_V6_vadduwsat_dv, 36750}, // __builtin_HEXAGON_V6_vadduwsat_dv
-      {Intrinsic::hexagon_V6_vadduwsat_dv_128B, 36784}, // __builtin_HEXAGON_V6_vadduwsat_dv_128B
-      {Intrinsic::hexagon_V6_vaddw, 36823}, // __builtin_HEXAGON_V6_vaddw
-      {Intrinsic::hexagon_V6_vaddw_128B, 36850}, // __builtin_HEXAGON_V6_vaddw_128B
-      {Intrinsic::hexagon_V6_vaddw_dv, 36882}, // __builtin_HEXAGON_V6_vaddw_dv
-      {Intrinsic::hexagon_V6_vaddw_dv_128B, 36912}, // __builtin_HEXAGON_V6_vaddw_dv_128B
-      {Intrinsic::hexagon_V6_vaddwnq, 36947}, // __builtin_HEXAGON_V6_vaddwnq
-      {Intrinsic::hexagon_V6_vaddwnq_128B, 36976}, // __builtin_HEXAGON_V6_vaddwnq_128B
-      {Intrinsic::hexagon_V6_vaddwq, 37010}, // __builtin_HEXAGON_V6_vaddwq
-      {Intrinsic::hexagon_V6_vaddwq_128B, 37038}, // __builtin_HEXAGON_V6_vaddwq_128B
-      {Intrinsic::hexagon_V6_vaddwsat, 37071}, // __builtin_HEXAGON_V6_vaddwsat
-      {Intrinsic::hexagon_V6_vaddwsat_128B, 37101}, // __builtin_HEXAGON_V6_vaddwsat_128B
-      {Intrinsic::hexagon_V6_vaddwsat_dv, 37136}, // __builtin_HEXAGON_V6_vaddwsat_dv
-      {Intrinsic::hexagon_V6_vaddwsat_dv_128B, 37169}, // __builtin_HEXAGON_V6_vaddwsat_dv_128B
-      {Intrinsic::hexagon_V6_valignb, 37207}, // __builtin_HEXAGON_V6_valignb
-      {Intrinsic::hexagon_V6_valignb_128B, 37236}, // __builtin_HEXAGON_V6_valignb_128B
-      {Intrinsic::hexagon_V6_valignbi, 37270}, // __builtin_HEXAGON_V6_valignbi
-      {Intrinsic::hexagon_V6_valignbi_128B, 37300}, // __builtin_HEXAGON_V6_valignbi_128B
-      {Intrinsic::hexagon_V6_vand, 37335}, // __builtin_HEXAGON_V6_vand
-      {Intrinsic::hexagon_V6_vand_128B, 37361}, // __builtin_HEXAGON_V6_vand_128B
-      {Intrinsic::hexagon_V6_vandnqrt, 37392}, // __builtin_HEXAGON_V6_vandnqrt
-      {Intrinsic::hexagon_V6_vandnqrt_128B, 37422}, // __builtin_HEXAGON_V6_vandnqrt_128B
-      {Intrinsic::hexagon_V6_vandnqrt_acc, 37457}, // __builtin_HEXAGON_V6_vandnqrt_acc
-      {Intrinsic::hexagon_V6_vandnqrt_acc_128B, 37491}, // __builtin_HEXAGON_V6_vandnqrt_acc_128B
-      {Intrinsic::hexagon_V6_vandqrt, 37530}, // __builtin_HEXAGON_V6_vandqrt
-      {Intrinsic::hexagon_V6_vandqrt_128B, 37559}, // __builtin_HEXAGON_V6_vandqrt_128B
-      {Intrinsic::hexagon_V6_vandqrt_acc, 37593}, // __builtin_HEXAGON_V6_vandqrt_acc
-      {Intrinsic::hexagon_V6_vandqrt_acc_128B, 37626}, // __builtin_HEXAGON_V6_vandqrt_acc_128B
-      {Intrinsic::hexagon_V6_vandvnqv, 37664}, // __builtin_HEXAGON_V6_vandvnqv
-      {Intrinsic::hexagon_V6_vandvnqv_128B, 37694}, // __builtin_HEXAGON_V6_vandvnqv_128B
-      {Intrinsic::hexagon_V6_vandvqv, 37729}, // __builtin_HEXAGON_V6_vandvqv
-      {Intrinsic::hexagon_V6_vandvqv_128B, 37758}, // __builtin_HEXAGON_V6_vandvqv_128B
-      {Intrinsic::hexagon_V6_vandvrt, 37792}, // __builtin_HEXAGON_V6_vandvrt
-      {Intrinsic::hexagon_V6_vandvrt_128B, 37821}, // __builtin_HEXAGON_V6_vandvrt_128B
-      {Intrinsic::hexagon_V6_vandvrt_acc, 37855}, // __builtin_HEXAGON_V6_vandvrt_acc
-      {Intrinsic::hexagon_V6_vandvrt_acc_128B, 37888}, // __builtin_HEXAGON_V6_vandvrt_acc_128B
-      {Intrinsic::hexagon_V6_vaslh, 37926}, // __builtin_HEXAGON_V6_vaslh
-      {Intrinsic::hexagon_V6_vaslh_128B, 37953}, // __builtin_HEXAGON_V6_vaslh_128B
-      {Intrinsic::hexagon_V6_vaslh_acc, 37985}, // __builtin_HEXAGON_V6_vaslh_acc
-      {Intrinsic::hexagon_V6_vaslh_acc_128B, 38016}, // __builtin_HEXAGON_V6_vaslh_acc_128B
-      {Intrinsic::hexagon_V6_vaslhv, 38052}, // __builtin_HEXAGON_V6_vaslhv
-      {Intrinsic::hexagon_V6_vaslhv_128B, 38080}, // __builtin_HEXAGON_V6_vaslhv_128B
-      {Intrinsic::hexagon_V6_vaslw, 38113}, // __builtin_HEXAGON_V6_vaslw
-      {Intrinsic::hexagon_V6_vaslw_128B, 38140}, // __builtin_HEXAGON_V6_vaslw_128B
-      {Intrinsic::hexagon_V6_vaslw_acc, 38172}, // __builtin_HEXAGON_V6_vaslw_acc
-      {Intrinsic::hexagon_V6_vaslw_acc_128B, 38203}, // __builtin_HEXAGON_V6_vaslw_acc_128B
-      {Intrinsic::hexagon_V6_vaslwv, 38239}, // __builtin_HEXAGON_V6_vaslwv
-      {Intrinsic::hexagon_V6_vaslwv_128B, 38267}, // __builtin_HEXAGON_V6_vaslwv_128B
-      {Intrinsic::hexagon_V6_vasr_into, 38300}, // __builtin_HEXAGON_V6_vasr_into
-      {Intrinsic::hexagon_V6_vasr_into_128B, 38331}, // __builtin_HEXAGON_V6_vasr_into_128B
-      {Intrinsic::hexagon_V6_vasrh, 38367}, // __builtin_HEXAGON_V6_vasrh
-      {Intrinsic::hexagon_V6_vasrh_128B, 38394}, // __builtin_HEXAGON_V6_vasrh_128B
-      {Intrinsic::hexagon_V6_vasrh_acc, 38426}, // __builtin_HEXAGON_V6_vasrh_acc
-      {Intrinsic::hexagon_V6_vasrh_acc_128B, 38457}, // __builtin_HEXAGON_V6_vasrh_acc_128B
-      {Intrinsic::hexagon_V6_vasrhbrndsat, 38493}, // __builtin_HEXAGON_V6_vasrhbrndsat
-      {Intrinsic::hexagon_V6_vasrhbrndsat_128B, 38527}, // __builtin_HEXAGON_V6_vasrhbrndsat_128B
-      {Intrinsic::hexagon_V6_vasrhbsat, 38566}, // __builtin_HEXAGON_V6_vasrhbsat
-      {Intrinsic::hexagon_V6_vasrhbsat_128B, 38597}, // __builtin_HEXAGON_V6_vasrhbsat_128B
-      {Intrinsic::hexagon_V6_vasrhubrndsat, 38633}, // __builtin_HEXAGON_V6_vasrhubrndsat
-      {Intrinsic::hexagon_V6_vasrhubrndsat_128B, 38668}, // __builtin_HEXAGON_V6_vasrhubrndsat_128B
-      {Intrinsic::hexagon_V6_vasrhubsat, 38708}, // __builtin_HEXAGON_V6_vasrhubsat
-      {Intrinsic::hexagon_V6_vasrhubsat_128B, 38740}, // __builtin_HEXAGON_V6_vasrhubsat_128B
-      {Intrinsic::hexagon_V6_vasrhv, 38777}, // __builtin_HEXAGON_V6_vasrhv
-      {Intrinsic::hexagon_V6_vasrhv_128B, 38805}, // __builtin_HEXAGON_V6_vasrhv_128B
-      {Intrinsic::hexagon_V6_vasruhubrndsat, 38838}, // __builtin_HEXAGON_V6_vasruhubrndsat
-      {Intrinsic::hexagon_V6_vasruhubrndsat_128B, 38874}, // __builtin_HEXAGON_V6_vasruhubrndsat_128B
-      {Intrinsic::hexagon_V6_vasruhubsat, 38915}, // __builtin_HEXAGON_V6_vasruhubsat
-      {Intrinsic::hexagon_V6_vasruhubsat_128B, 38948}, // __builtin_HEXAGON_V6_vasruhubsat_128B
-      {Intrinsic::hexagon_V6_vasruwuhrndsat, 38986}, // __builtin_HEXAGON_V6_vasruwuhrndsat
-      {Intrinsic::hexagon_V6_vasruwuhrndsat_128B, 39022}, // __builtin_HEXAGON_V6_vasruwuhrndsat_128B
-      {Intrinsic::hexagon_V6_vasruwuhsat, 39063}, // __builtin_HEXAGON_V6_vasruwuhsat
-      {Intrinsic::hexagon_V6_vasruwuhsat_128B, 39096}, // __builtin_HEXAGON_V6_vasruwuhsat_128B
-      {Intrinsic::hexagon_V6_vasrw, 39134}, // __builtin_HEXAGON_V6_vasrw
-      {Intrinsic::hexagon_V6_vasrw_128B, 39161}, // __builtin_HEXAGON_V6_vasrw_128B
-      {Intrinsic::hexagon_V6_vasrw_acc, 39193}, // __builtin_HEXAGON_V6_vasrw_acc
-      {Intrinsic::hexagon_V6_vasrw_acc_128B, 39224}, // __builtin_HEXAGON_V6_vasrw_acc_128B
-      {Intrinsic::hexagon_V6_vasrwh, 39260}, // __builtin_HEXAGON_V6_vasrwh
-      {Intrinsic::hexagon_V6_vasrwh_128B, 39288}, // __builtin_HEXAGON_V6_vasrwh_128B
-      {Intrinsic::hexagon_V6_vasrwhrndsat, 39321}, // __builtin_HEXAGON_V6_vasrwhrndsat
-      {Intrinsic::hexagon_V6_vasrwhrndsat_128B, 39355}, // __builtin_HEXAGON_V6_vasrwhrndsat_128B
-      {Intrinsic::hexagon_V6_vasrwhsat, 39394}, // __builtin_HEXAGON_V6_vasrwhsat
-      {Intrinsic::hexagon_V6_vasrwhsat_128B, 39425}, // __builtin_HEXAGON_V6_vasrwhsat_128B
-      {Intrinsic::hexagon_V6_vasrwuhrndsat, 39461}, // __builtin_HEXAGON_V6_vasrwuhrndsat
-      {Intrinsic::hexagon_V6_vasrwuhrndsat_128B, 39496}, // __builtin_HEXAGON_V6_vasrwuhrndsat_128B
-      {Intrinsic::hexagon_V6_vasrwuhsat, 39536}, // __builtin_HEXAGON_V6_vasrwuhsat
-      {Intrinsic::hexagon_V6_vasrwuhsat_128B, 39568}, // __builtin_HEXAGON_V6_vasrwuhsat_128B
-      {Intrinsic::hexagon_V6_vasrwv, 39605}, // __builtin_HEXAGON_V6_vasrwv
-      {Intrinsic::hexagon_V6_vasrwv_128B, 39633}, // __builtin_HEXAGON_V6_vasrwv_128B
-      {Intrinsic::hexagon_V6_vassign, 39666}, // __builtin_HEXAGON_V6_vassign
-      {Intrinsic::hexagon_V6_vassign_128B, 39695}, // __builtin_HEXAGON_V6_vassign_128B
-      {Intrinsic::hexagon_V6_vassignp, 39729}, // __builtin_HEXAGON_V6_vassignp
-      {Intrinsic::hexagon_V6_vassignp_128B, 39759}, // __builtin_HEXAGON_V6_vassignp_128B
-      {Intrinsic::hexagon_V6_vavgb, 39794}, // __builtin_HEXAGON_V6_vavgb
-      {Intrinsic::hexagon_V6_vavgb_128B, 39821}, // __builtin_HEXAGON_V6_vavgb_128B
-      {Intrinsic::hexagon_V6_vavgbrnd, 39853}, // __builtin_HEXAGON_V6_vavgbrnd
-      {Intrinsic::hexagon_V6_vavgbrnd_128B, 39883}, // __builtin_HEXAGON_V6_vavgbrnd_128B
-      {Intrinsic::hexagon_V6_vavgh, 39918}, // __builtin_HEXAGON_V6_vavgh
-      {Intrinsic::hexagon_V6_vavgh_128B, 39945}, // __builtin_HEXAGON_V6_vavgh_128B
-      {Intrinsic::hexagon_V6_vavghrnd, 39977}, // __builtin_HEXAGON_V6_vavghrnd
-      {Intrinsic::hexagon_V6_vavghrnd_128B, 40007}, // __builtin_HEXAGON_V6_vavghrnd_128B
-      {Intrinsic::hexagon_V6_vavgub, 40042}, // __builtin_HEXAGON_V6_vavgub
-      {Intrinsic::hexagon_V6_vavgub_128B, 40070}, // __builtin_HEXAGON_V6_vavgub_128B
-      {Intrinsic::hexagon_V6_vavgubrnd, 40103}, // __builtin_HEXAGON_V6_vavgubrnd
-      {Intrinsic::hexagon_V6_vavgubrnd_128B, 40134}, // __builtin_HEXAGON_V6_vavgubrnd_128B
-      {Intrinsic::hexagon_V6_vavguh, 40170}, // __builtin_HEXAGON_V6_vavguh
-      {Intrinsic::hexagon_V6_vavguh_128B, 40198}, // __builtin_HEXAGON_V6_vavguh_128B
-      {Intrinsic::hexagon_V6_vavguhrnd, 40231}, // __builtin_HEXAGON_V6_vavguhrnd
-      {Intrinsic::hexagon_V6_vavguhrnd_128B, 40262}, // __builtin_HEXAGON_V6_vavguhrnd_128B
-      {Intrinsic::hexagon_V6_vavguw, 40298}, // __builtin_HEXAGON_V6_vavguw
-      {Intrinsic::hexagon_V6_vavguw_128B, 40326}, // __builtin_HEXAGON_V6_vavguw_128B
-      {Intrinsic::hexagon_V6_vavguwrnd, 40359}, // __builtin_HEXAGON_V6_vavguwrnd
-      {Intrinsic::hexagon_V6_vavguwrnd_128B, 40390}, // __builtin_HEXAGON_V6_vavguwrnd_128B
-      {Intrinsic::hexagon_V6_vavgw, 40426}, // __builtin_HEXAGON_V6_vavgw
-      {Intrinsic::hexagon_V6_vavgw_128B, 40453}, // __builtin_HEXAGON_V6_vavgw_128B
-      {Intrinsic::hexagon_V6_vavgwrnd, 40485}, // __builtin_HEXAGON_V6_vavgwrnd
-      {Intrinsic::hexagon_V6_vavgwrnd_128B, 40515}, // __builtin_HEXAGON_V6_vavgwrnd_128B
-      {Intrinsic::hexagon_V6_vcl0h, 40550}, // __builtin_HEXAGON_V6_vcl0h
-      {Intrinsic::hexagon_V6_vcl0h_128B, 40577}, // __builtin_HEXAGON_V6_vcl0h_128B
-      {Intrinsic::hexagon_V6_vcl0w, 40609}, // __builtin_HEXAGON_V6_vcl0w
-      {Intrinsic::hexagon_V6_vcl0w_128B, 40636}, // __builtin_HEXAGON_V6_vcl0w_128B
-      {Intrinsic::hexagon_V6_vcombine, 40668}, // __builtin_HEXAGON_V6_vcombine
-      {Intrinsic::hexagon_V6_vcombine_128B, 40698}, // __builtin_HEXAGON_V6_vcombine_128B
-      {Intrinsic::hexagon_V6_vd0, 40733}, // __builtin_HEXAGON_V6_vd0
-      {Intrinsic::hexagon_V6_vd0_128B, 40758}, // __builtin_HEXAGON_V6_vd0_128B
-      {Intrinsic::hexagon_V6_vdd0, 40788}, // __builtin_HEXAGON_V6_vdd0
-      {Intrinsic::hexagon_V6_vdd0_128B, 40814}, // __builtin_HEXAGON_V6_vdd0_128B
-      {Intrinsic::hexagon_V6_vdealb, 40845}, // __builtin_HEXAGON_V6_vdealb
-      {Intrinsic::hexagon_V6_vdealb4w, 40906}, // __builtin_HEXAGON_V6_vdealb4w
-      {Intrinsic::hexagon_V6_vdealb4w_128B, 40936}, // __builtin_HEXAGON_V6_vdealb4w_128B
-      {Intrinsic::hexagon_V6_vdealb_128B, 40873}, // __builtin_HEXAGON_V6_vdealb_128B
-      {Intrinsic::hexagon_V6_vdealh, 40971}, // __builtin_HEXAGON_V6_vdealh
-      {Intrinsic::hexagon_V6_vdealh_128B, 40999}, // __builtin_HEXAGON_V6_vdealh_128B
-      {Intrinsic::hexagon_V6_vdealvdd, 41032}, // __builtin_HEXAGON_V6_vdealvdd
-      {Intrinsic::hexagon_V6_vdealvdd_128B, 41062}, // __builtin_HEXAGON_V6_vdealvdd_128B
-      {Intrinsic::hexagon_V6_vdelta, 41097}, // __builtin_HEXAGON_V6_vdelta
-      {Intrinsic::hexagon_V6_vdelta_128B, 41125}, // __builtin_HEXAGON_V6_vdelta_128B
-      {Intrinsic::hexagon_V6_vdmpybus, 41158}, // __builtin_HEXAGON_V6_vdmpybus
-      {Intrinsic::hexagon_V6_vdmpybus_128B, 41188}, // __builtin_HEXAGON_V6_vdmpybus_128B
-      {Intrinsic::hexagon_V6_vdmpybus_acc, 41223}, // __builtin_HEXAGON_V6_vdmpybus_acc
-      {Intrinsic::hexagon_V6_vdmpybus_acc_128B, 41257}, // __builtin_HEXAGON_V6_vdmpybus_acc_128B
-      {Intrinsic::hexagon_V6_vdmpybus_dv, 41296}, // __builtin_HEXAGON_V6_vdmpybus_dv
-      {Intrinsic::hexagon_V6_vdmpybus_dv_128B, 41329}, // __builtin_HEXAGON_V6_vdmpybus_dv_128B
-      {Intrinsic::hexagon_V6_vdmpybus_dv_acc, 41367}, // __builtin_HEXAGON_V6_vdmpybus_dv_acc
-      {Intrinsic::hexagon_V6_vdmpybus_dv_acc_128B, 41404}, // __builtin_HEXAGON_V6_vdmpybus_dv_acc_128B
-      {Intrinsic::hexagon_V6_vdmpyhb, 41446}, // __builtin_HEXAGON_V6_vdmpyhb
-      {Intrinsic::hexagon_V6_vdmpyhb_128B, 41475}, // __builtin_HEXAGON_V6_vdmpyhb_128B
-      {Intrinsic::hexagon_V6_vdmpyhb_acc, 41509}, // __builtin_HEXAGON_V6_vdmpyhb_acc
-      {Intrinsic::hexagon_V6_vdmpyhb_acc_128B, 41542}, // __builtin_HEXAGON_V6_vdmpyhb_acc_128B
-      {Intrinsic::hexagon_V6_vdmpyhb_dv, 41580}, // __builtin_HEXAGON_V6_vdmpyhb_dv
-      {Intrinsic::hexagon_V6_vdmpyhb_dv_128B, 41612}, // __builtin_HEXAGON_V6_vdmpyhb_dv_128B
-      {Intrinsic::hexagon_V6_vdmpyhb_dv_acc, 41649}, // __builtin_HEXAGON_V6_vdmpyhb_dv_acc
-      {Intrinsic::hexagon_V6_vdmpyhb_dv_acc_128B, 41685}, // __builtin_HEXAGON_V6_vdmpyhb_dv_acc_128B
-      {Intrinsic::hexagon_V6_vdmpyhisat, 41726}, // __builtin_HEXAGON_V6_vdmpyhisat
-      {Intrinsic::hexagon_V6_vdmpyhisat_128B, 41758}, // __builtin_HEXAGON_V6_vdmpyhisat_128B
-      {Intrinsic::hexagon_V6_vdmpyhisat_acc, 41795}, // __builtin_HEXAGON_V6_vdmpyhisat_acc
-      {Intrinsic::hexagon_V6_vdmpyhisat_acc_128B, 41831}, // __builtin_HEXAGON_V6_vdmpyhisat_acc_128B
-      {Intrinsic::hexagon_V6_vdmpyhsat, 41872}, // __builtin_HEXAGON_V6_vdmpyhsat
-      {Intrinsic::hexagon_V6_vdmpyhsat_128B, 41903}, // __builtin_HEXAGON_V6_vdmpyhsat_128B
-      {Intrinsic::hexagon_V6_vdmpyhsat_acc, 41939}, // __builtin_HEXAGON_V6_vdmpyhsat_acc
-      {Intrinsic::hexagon_V6_vdmpyhsat_acc_128B, 41974}, // __builtin_HEXAGON_V6_vdmpyhsat_acc_128B
-      {Intrinsic::hexagon_V6_vdmpyhsuisat, 42014}, // __builtin_HEXAGON_V6_vdmpyhsuisat
-      {Intrinsic::hexagon_V6_vdmpyhsuisat_128B, 42048}, // __builtin_HEXAGON_V6_vdmpyhsuisat_128B
-      {Intrinsic::hexagon_V6_vdmpyhsuisat_acc, 42087}, // __builtin_HEXAGON_V6_vdmpyhsuisat_acc
-      {Intrinsic::hexagon_V6_vdmpyhsuisat_acc_128B, 42125}, // __builtin_HEXAGON_V6_vdmpyhsuisat_acc_128B
-      {Intrinsic::hexagon_V6_vdmpyhsusat, 42168}, // __builtin_HEXAGON_V6_vdmpyhsusat
-      {Intrinsic::hexagon_V6_vdmpyhsusat_128B, 42201}, // __builtin_HEXAGON_V6_vdmpyhsusat_128B
-      {Intrinsic::hexagon_V6_vdmpyhsusat_acc, 42239}, // __builtin_HEXAGON_V6_vdmpyhsusat_acc
-      {Intrinsic::hexagon_V6_vdmpyhsusat_acc_128B, 42276}, // __builtin_HEXAGON_V6_vdmpyhsusat_acc_128B
-      {Intrinsic::hexagon_V6_vdmpyhvsat, 42318}, // __builtin_HEXAGON_V6_vdmpyhvsat
-      {Intrinsic::hexagon_V6_vdmpyhvsat_128B, 42350}, // __builtin_HEXAGON_V6_vdmpyhvsat_128B
-      {Intrinsic::hexagon_V6_vdmpyhvsat_acc, 42387}, // __builtin_HEXAGON_V6_vdmpyhvsat_acc
-      {Intrinsic::hexagon_V6_vdmpyhvsat_acc_128B, 42423}, // __builtin_HEXAGON_V6_vdmpyhvsat_acc_128B
-      {Intrinsic::hexagon_V6_vdsaduh, 42464}, // __builtin_HEXAGON_V6_vdsaduh
-      {Intrinsic::hexagon_V6_vdsaduh_128B, 42493}, // __builtin_HEXAGON_V6_vdsaduh_128B
-      {Intrinsic::hexagon_V6_vdsaduh_acc, 42527}, // __builtin_HEXAGON_V6_vdsaduh_acc
-      {Intrinsic::hexagon_V6_vdsaduh_acc_128B, 42560}, // __builtin_HEXAGON_V6_vdsaduh_acc_128B
-      {Intrinsic::hexagon_V6_veqb, 42598}, // __builtin_HEXAGON_V6_veqb
-      {Intrinsic::hexagon_V6_veqb_128B, 42624}, // __builtin_HEXAGON_V6_veqb_128B
-      {Intrinsic::hexagon_V6_veqb_and, 42655}, // __builtin_HEXAGON_V6_veqb_and
-      {Intrinsic::hexagon_V6_veqb_and_128B, 42685}, // __builtin_HEXAGON_V6_veqb_and_128B
-      {Intrinsic::hexagon_V6_veqb_or, 42720}, // __builtin_HEXAGON_V6_veqb_or
-      {Intrinsic::hexagon_V6_veqb_or_128B, 42749}, // __builtin_HEXAGON_V6_veqb_or_128B
-      {Intrinsic::hexagon_V6_veqb_xor, 42783}, // __builtin_HEXAGON_V6_veqb_xor
-      {Intrinsic::hexagon_V6_veqb_xor_128B, 42813}, // __builtin_HEXAGON_V6_veqb_xor_128B
-      {Intrinsic::hexagon_V6_veqh, 42848}, // __builtin_HEXAGON_V6_veqh
-      {Intrinsic::hexagon_V6_veqh_128B, 42874}, // __builtin_HEXAGON_V6_veqh_128B
-      {Intrinsic::hexagon_V6_veqh_and, 42905}, // __builtin_HEXAGON_V6_veqh_and
-      {Intrinsic::hexagon_V6_veqh_and_128B, 42935}, // __builtin_HEXAGON_V6_veqh_and_128B
-      {Intrinsic::hexagon_V6_veqh_or, 42970}, // __builtin_HEXAGON_V6_veqh_or
-      {Intrinsic::hexagon_V6_veqh_or_128B, 42999}, // __builtin_HEXAGON_V6_veqh_or_128B
-      {Intrinsic::hexagon_V6_veqh_xor, 43033}, // __builtin_HEXAGON_V6_veqh_xor
-      {Intrinsic::hexagon_V6_veqh_xor_128B, 43063}, // __builtin_HEXAGON_V6_veqh_xor_128B
-      {Intrinsic::hexagon_V6_veqw, 43098}, // __builtin_HEXAGON_V6_veqw
-      {Intrinsic::hexagon_V6_veqw_128B, 43124}, // __builtin_HEXAGON_V6_veqw_128B
-      {Intrinsic::hexagon_V6_veqw_and, 43155}, // __builtin_HEXAGON_V6_veqw_and
-      {Intrinsic::hexagon_V6_veqw_and_128B, 43185}, // __builtin_HEXAGON_V6_veqw_and_128B
-      {Intrinsic::hexagon_V6_veqw_or, 43220}, // __builtin_HEXAGON_V6_veqw_or
-      {Intrinsic::hexagon_V6_veqw_or_128B, 43249}, // __builtin_HEXAGON_V6_veqw_or_128B
-      {Intrinsic::hexagon_V6_veqw_xor, 43283}, // __builtin_HEXAGON_V6_veqw_xor
-      {Intrinsic::hexagon_V6_veqw_xor_128B, 43313}, // __builtin_HEXAGON_V6_veqw_xor_128B
-      {Intrinsic::hexagon_V6_vgathermh, 43348}, // __builtin_HEXAGON_V6_vgathermh
-      {Intrinsic::hexagon_V6_vgathermh_128B, 43379}, // __builtin_HEXAGON_V6_vgathermh_128B
-      {Intrinsic::hexagon_V6_vgathermhq, 43415}, // __builtin_HEXAGON_V6_vgathermhq
-      {Intrinsic::hexagon_V6_vgathermhq_128B, 43447}, // __builtin_HEXAGON_V6_vgathermhq_128B
-      {Intrinsic::hexagon_V6_vgathermhw, 43484}, // __builtin_HEXAGON_V6_vgathermhw
-      {Intrinsic::hexagon_V6_vgathermhw_128B, 43516}, // __builtin_HEXAGON_V6_vgathermhw_128B
-      {Intrinsic::hexagon_V6_vgathermhwq, 43553}, // __builtin_HEXAGON_V6_vgathermhwq
-      {Intrinsic::hexagon_V6_vgathermhwq_128B, 43586}, // __builtin_HEXAGON_V6_vgathermhwq_128B
-      {Intrinsic::hexagon_V6_vgathermw, 43624}, // __builtin_HEXAGON_V6_vgathermw
-      {Intrinsic::hexagon_V6_vgathermw_128B, 43655}, // __builtin_HEXAGON_V6_vgathermw_128B
-      {Intrinsic::hexagon_V6_vgathermwq, 43691}, // __builtin_HEXAGON_V6_vgathermwq
-      {Intrinsic::hexagon_V6_vgathermwq_128B, 43723}, // __builtin_HEXAGON_V6_vgathermwq_128B
-      {Intrinsic::hexagon_V6_vgtb, 43760}, // __builtin_HEXAGON_V6_vgtb
-      {Intrinsic::hexagon_V6_vgtb_128B, 43786}, // __builtin_HEXAGON_V6_vgtb_128B
-      {Intrinsic::hexagon_V6_vgtb_and, 43817}, // __builtin_HEXAGON_V6_vgtb_and
-      {Intrinsic::hexagon_V6_vgtb_and_128B, 43847}, // __builtin_HEXAGON_V6_vgtb_and_128B
-      {Intrinsic::hexagon_V6_vgtb_or, 43882}, // __builtin_HEXAGON_V6_vgtb_or
-      {Intrinsic::hexagon_V6_vgtb_or_128B, 43911}, // __builtin_HEXAGON_V6_vgtb_or_128B
-      {Intrinsic::hexagon_V6_vgtb_xor, 43945}, // __builtin_HEXAGON_V6_vgtb_xor
-      {Intrinsic::hexagon_V6_vgtb_xor_128B, 43975}, // __builtin_HEXAGON_V6_vgtb_xor_128B
-      {Intrinsic::hexagon_V6_vgth, 44010}, // __builtin_HEXAGON_V6_vgth
-      {Intrinsic::hexagon_V6_vgth_128B, 44036}, // __builtin_HEXAGON_V6_vgth_128B
-      {Intrinsic::hexagon_V6_vgth_and, 44067}, // __builtin_HEXAGON_V6_vgth_and
-      {Intrinsic::hexagon_V6_vgth_and_128B, 44097}, // __builtin_HEXAGON_V6_vgth_and_128B
-      {Intrinsic::hexagon_V6_vgth_or, 44132}, // __builtin_HEXAGON_V6_vgth_or
-      {Intrinsic::hexagon_V6_vgth_or_128B, 44161}, // __builtin_HEXAGON_V6_vgth_or_128B
-      {Intrinsic::hexagon_V6_vgth_xor, 44195}, // __builtin_HEXAGON_V6_vgth_xor
-      {Intrinsic::hexagon_V6_vgth_xor_128B, 44225}, // __builtin_HEXAGON_V6_vgth_xor_128B
-      {Intrinsic::hexagon_V6_vgtub, 44260}, // __builtin_HEXAGON_V6_vgtub
-      {Intrinsic::hexagon_V6_vgtub_128B, 44287}, // __builtin_HEXAGON_V6_vgtub_128B
-      {Intrinsic::hexagon_V6_vgtub_and, 44319}, // __builtin_HEXAGON_V6_vgtub_and
-      {Intrinsic::hexagon_V6_vgtub_and_128B, 44350}, // __builtin_HEXAGON_V6_vgtub_and_128B
-      {Intrinsic::hexagon_V6_vgtub_or, 44386}, // __builtin_HEXAGON_V6_vgtub_or
-      {Intrinsic::hexagon_V6_vgtub_or_128B, 44416}, // __builtin_HEXAGON_V6_vgtub_or_128B
-      {Intrinsic::hexagon_V6_vgtub_xor, 44451}, // __builtin_HEXAGON_V6_vgtub_xor
-      {Intrinsic::hexagon_V6_vgtub_xor_128B, 44482}, // __builtin_HEXAGON_V6_vgtub_xor_128B
-      {Intrinsic::hexagon_V6_vgtuh, 44518}, // __builtin_HEXAGON_V6_vgtuh
-      {Intrinsic::hexagon_V6_vgtuh_128B, 44545}, // __builtin_HEXAGON_V6_vgtuh_128B
-      {Intrinsic::hexagon_V6_vgtuh_and, 44577}, // __builtin_HEXAGON_V6_vgtuh_and
-      {Intrinsic::hexagon_V6_vgtuh_and_128B, 44608}, // __builtin_HEXAGON_V6_vgtuh_and_128B
-      {Intrinsic::hexagon_V6_vgtuh_or, 44644}, // __builtin_HEXAGON_V6_vgtuh_or
-      {Intrinsic::hexagon_V6_vgtuh_or_128B, 44674}, // __builtin_HEXAGON_V6_vgtuh_or_128B
-      {Intrinsic::hexagon_V6_vgtuh_xor, 44709}, // __builtin_HEXAGON_V6_vgtuh_xor
-      {Intrinsic::hexagon_V6_vgtuh_xor_128B, 44740}, // __builtin_HEXAGON_V6_vgtuh_xor_128B
-      {Intrinsic::hexagon_V6_vgtuw, 44776}, // __builtin_HEXAGON_V6_vgtuw
-      {Intrinsic::hexagon_V6_vgtuw_128B, 44803}, // __builtin_HEXAGON_V6_vgtuw_128B
-      {Intrinsic::hexagon_V6_vgtuw_and, 44835}, // __builtin_HEXAGON_V6_vgtuw_and
-      {Intrinsic::hexagon_V6_vgtuw_and_128B, 44866}, // __builtin_HEXAGON_V6_vgtuw_and_128B
-      {Intrinsic::hexagon_V6_vgtuw_or, 44902}, // __builtin_HEXAGON_V6_vgtuw_or
-      {Intrinsic::hexagon_V6_vgtuw_or_128B, 44932}, // __builtin_HEXAGON_V6_vgtuw_or_128B
-      {Intrinsic::hexagon_V6_vgtuw_xor, 44967}, // __builtin_HEXAGON_V6_vgtuw_xor
-      {Intrinsic::hexagon_V6_vgtuw_xor_128B, 44998}, // __builtin_HEXAGON_V6_vgtuw_xor_128B
-      {Intrinsic::hexagon_V6_vgtw, 45034}, // __builtin_HEXAGON_V6_vgtw
-      {Intrinsic::hexagon_V6_vgtw_128B, 45060}, // __builtin_HEXAGON_V6_vgtw_128B
-      {Intrinsic::hexagon_V6_vgtw_and, 45091}, // __builtin_HEXAGON_V6_vgtw_and
-      {Intrinsic::hexagon_V6_vgtw_and_128B, 45121}, // __builtin_HEXAGON_V6_vgtw_and_128B
-      {Intrinsic::hexagon_V6_vgtw_or, 45156}, // __builtin_HEXAGON_V6_vgtw_or
-      {Intrinsic::hexagon_V6_vgtw_or_128B, 45185}, // __builtin_HEXAGON_V6_vgtw_or_128B
-      {Intrinsic::hexagon_V6_vgtw_xor, 45219}, // __builtin_HEXAGON_V6_vgtw_xor
-      {Intrinsic::hexagon_V6_vgtw_xor_128B, 45249}, // __builtin_HEXAGON_V6_vgtw_xor_128B
-      {Intrinsic::hexagon_V6_vinsertwr, 45284}, // __builtin_HEXAGON_V6_vinsertwr
-      {Intrinsic::hexagon_V6_vinsertwr_128B, 45315}, // __builtin_HEXAGON_V6_vinsertwr_128B
-      {Intrinsic::hexagon_V6_vlalignb, 45351}, // __builtin_HEXAGON_V6_vlalignb
-      {Intrinsic::hexagon_V6_vlalignb_128B, 45381}, // __builtin_HEXAGON_V6_vlalignb_128B
-      {Intrinsic::hexagon_V6_vlalignbi, 45416}, // __builtin_HEXAGON_V6_vlalignbi
-      {Intrinsic::hexagon_V6_vlalignbi_128B, 45447}, // __builtin_HEXAGON_V6_vlalignbi_128B
-      {Intrinsic::hexagon_V6_vlsrb, 45483}, // __builtin_HEXAGON_V6_vlsrb
-      {Intrinsic::hexagon_V6_vlsrb_128B, 45510}, // __builtin_HEXAGON_V6_vlsrb_128B
-      {Intrinsic::hexagon_V6_vlsrh, 45542}, // __builtin_HEXAGON_V6_vlsrh
-      {Intrinsic::hexagon_V6_vlsrh_128B, 45569}, // __builtin_HEXAGON_V6_vlsrh_128B
-      {Intrinsic::hexagon_V6_vlsrhv, 45601}, // __builtin_HEXAGON_V6_vlsrhv
-      {Intrinsic::hexagon_V6_vlsrhv_128B, 45629}, // __builtin_HEXAGON_V6_vlsrhv_128B
-      {Intrinsic::hexagon_V6_vlsrw, 45662}, // __builtin_HEXAGON_V6_vlsrw
-      {Intrinsic::hexagon_V6_vlsrw_128B, 45689}, // __builtin_HEXAGON_V6_vlsrw_128B
-      {Intrinsic::hexagon_V6_vlsrwv, 45721}, // __builtin_HEXAGON_V6_vlsrwv
-      {Intrinsic::hexagon_V6_vlsrwv_128B, 45749}, // __builtin_HEXAGON_V6_vlsrwv_128B
-      {Intrinsic::hexagon_V6_vlut4, 45782}, // __builtin_HEXAGON_V6_vlut4
-      {Intrinsic::hexagon_V6_vlut4_128B, 45809}, // __builtin_HEXAGON_V6_vlut4_128B
-      {Intrinsic::hexagon_V6_vlutvvb, 45841}, // __builtin_HEXAGON_V6_vlutvvb
-      {Intrinsic::hexagon_V6_vlutvvb_128B, 45870}, // __builtin_HEXAGON_V6_vlutvvb_128B
-      {Intrinsic::hexagon_V6_vlutvvb_nm, 45904}, // __builtin_HEXAGON_V6_vlutvvb_nm
-      {Intrinsic::hexagon_V6_vlutvvb_nm_128B, 45936}, // __builtin_HEXAGON_V6_vlutvvb_nm_128B
-      {Intrinsic::hexagon_V6_vlutvvb_oracc, 45973}, // __builtin_HEXAGON_V6_vlutvvb_oracc
-      {Intrinsic::hexagon_V6_vlutvvb_oracc_128B, 46008}, // __builtin_HEXAGON_V6_vlutvvb_oracc_128B
-      {Intrinsic::hexagon_V6_vlutvvb_oracci, 46048}, // __builtin_HEXAGON_V6_vlutvvb_oracci
-      {Intrinsic::hexagon_V6_vlutvvb_oracci_128B, 46084}, // __builtin_HEXAGON_V6_vlutvvb_oracci_128B
-      {Intrinsic::hexagon_V6_vlutvvbi, 46125}, // __builtin_HEXAGON_V6_vlutvvbi
-      {Intrinsic::hexagon_V6_vlutvvbi_128B, 46155}, // __builtin_HEXAGON_V6_vlutvvbi_128B
-      {Intrinsic::hexagon_V6_vlutvwh, 46190}, // __builtin_HEXAGON_V6_vlutvwh
-      {Intrinsic::hexagon_V6_vlutvwh_128B, 46219}, // __builtin_HEXAGON_V6_vlutvwh_128B
-      {Intrinsic::hexagon_V6_vlutvwh_nm, 46253}, // __builtin_HEXAGON_V6_vlutvwh_nm
-      {Intrinsic::hexagon_V6_vlutvwh_nm_128B, 46285}, // __builtin_HEXAGON_V6_vlutvwh_nm_128B
-      {Intrinsic::hexagon_V6_vlutvwh_oracc, 46322}, // __builtin_HEXAGON_V6_vlutvwh_oracc
-      {Intrinsic::hexagon_V6_vlutvwh_oracc_128B, 46357}, // __builtin_HEXAGON_V6_vlutvwh_oracc_128B
-      {Intrinsic::hexagon_V6_vlutvwh_oracci, 46397}, // __builtin_HEXAGON_V6_vlutvwh_oracci
-      {Intrinsic::hexagon_V6_vlutvwh_oracci_128B, 46433}, // __builtin_HEXAGON_V6_vlutvwh_oracci_128B
-      {Intrinsic::hexagon_V6_vlutvwhi, 46474}, // __builtin_HEXAGON_V6_vlutvwhi
-      {Intrinsic::hexagon_V6_vlutvwhi_128B, 46504}, // __builtin_HEXAGON_V6_vlutvwhi_128B
-      {Intrinsic::hexagon_V6_vmaskedstorenq, 46539}, // __builtin_HEXAGON_V6_vmaskedstorenq
-      {Intrinsic::hexagon_V6_vmaskedstorenq_128B, 46575}, // __builtin_HEXAGON_V6_vmaskedstorenq_128B
-      {Intrinsic::hexagon_V6_vmaskedstorentnq, 46616}, // __builtin_HEXAGON_V6_vmaskedstorentnq
-      {Intrinsic::hexagon_V6_vmaskedstorentnq_128B, 46654}, // __builtin_HEXAGON_V6_vmaskedstorentnq_128B
-      {Intrinsic::hexagon_V6_vmaskedstorentq, 46697}, // __builtin_HEXAGON_V6_vmaskedstorentq
-      {Intrinsic::hexagon_V6_vmaskedstorentq_128B, 46734}, // __builtin_HEXAGON_V6_vmaskedstorentq_128B
-      {Intrinsic::hexagon_V6_vmaskedstoreq, 46776}, // __builtin_HEXAGON_V6_vmaskedstoreq
-      {Intrinsic::hexagon_V6_vmaskedstoreq_128B, 46811}, // __builtin_HEXAGON_V6_vmaskedstoreq_128B
-      {Intrinsic::hexagon_V6_vmaxb, 46851}, // __builtin_HEXAGON_V6_vmaxb
-      {Intrinsic::hexagon_V6_vmaxb_128B, 46878}, // __builtin_HEXAGON_V6_vmaxb_128B
-      {Intrinsic::hexagon_V6_vmaxh, 46910}, // __builtin_HEXAGON_V6_vmaxh
-      {Intrinsic::hexagon_V6_vmaxh_128B, 46937}, // __builtin_HEXAGON_V6_vmaxh_128B
-      {Intrinsic::hexagon_V6_vmaxub, 46969}, // __builtin_HEXAGON_V6_vmaxub
-      {Intrinsic::hexagon_V6_vmaxub_128B, 46997}, // __builtin_HEXAGON_V6_vmaxub_128B
-      {Intrinsic::hexagon_V6_vmaxuh, 47030}, // __builtin_HEXAGON_V6_vmaxuh
-      {Intrinsic::hexagon_V6_vmaxuh_128B, 47058}, // __builtin_HEXAGON_V6_vmaxuh_128B
-      {Intrinsic::hexagon_V6_vmaxw, 47091}, // __builtin_HEXAGON_V6_vmaxw
-      {Intrinsic::hexagon_V6_vmaxw_128B, 47118}, // __builtin_HEXAGON_V6_vmaxw_128B
-      {Intrinsic::hexagon_V6_vminb, 47150}, // __builtin_HEXAGON_V6_vminb
-      {Intrinsic::hexagon_V6_vminb_128B, 47177}, // __builtin_HEXAGON_V6_vminb_128B
-      {Intrinsic::hexagon_V6_vminh, 47209}, // __builtin_HEXAGON_V6_vminh
-      {Intrinsic::hexagon_V6_vminh_128B, 47236}, // __builtin_HEXAGON_V6_vminh_128B
-      {Intrinsic::hexagon_V6_vminub, 47268}, // __builtin_HEXAGON_V6_vminub
-      {Intrinsic::hexagon_V6_vminub_128B, 47296}, // __builtin_HEXAGON_V6_vminub_128B
-      {Intrinsic::hexagon_V6_vminuh, 47329}, // __builtin_HEXAGON_V6_vminuh
-      {Intrinsic::hexagon_V6_vminuh_128B, 47357}, // __builtin_HEXAGON_V6_vminuh_128B
-      {Intrinsic::hexagon_V6_vminw, 47390}, // __builtin_HEXAGON_V6_vminw
-      {Intrinsic::hexagon_V6_vminw_128B, 47417}, // __builtin_HEXAGON_V6_vminw_128B
-      {Intrinsic::hexagon_V6_vmpabus, 47449}, // __builtin_HEXAGON_V6_vmpabus
-      {Intrinsic::hexagon_V6_vmpabus_128B, 47478}, // __builtin_HEXAGON_V6_vmpabus_128B
-      {Intrinsic::hexagon_V6_vmpabus_acc, 47512}, // __builtin_HEXAGON_V6_vmpabus_acc
-      {Intrinsic::hexagon_V6_vmpabus_acc_128B, 47545}, // __builtin_HEXAGON_V6_vmpabus_acc_128B
-      {Intrinsic::hexagon_V6_vmpabusv, 47583}, // __builtin_HEXAGON_V6_vmpabusv
-      {Intrinsic::hexagon_V6_vmpabusv_128B, 47613}, // __builtin_HEXAGON_V6_vmpabusv_128B
-      {Intrinsic::hexagon_V6_vmpabuu, 47648}, // __builtin_HEXAGON_V6_vmpabuu
-      {Intrinsic::hexagon_V6_vmpabuu_128B, 47677}, // __builtin_HEXAGON_V6_vmpabuu_128B
-      {Intrinsic::hexagon_V6_vmpabuu_acc, 47711}, // __builtin_HEXAGON_V6_vmpabuu_acc
-      {Intrinsic::hexagon_V6_vmpabuu_acc_128B, 47744}, // __builtin_HEXAGON_V6_vmpabuu_acc_128B
-      {Intrinsic::hexagon_V6_vmpabuuv, 47782}, // __builtin_HEXAGON_V6_vmpabuuv
-      {Intrinsic::hexagon_V6_vmpabuuv_128B, 47812}, // __builtin_HEXAGON_V6_vmpabuuv_128B
-      {Intrinsic::hexagon_V6_vmpahb, 47847}, // __builtin_HEXAGON_V6_vmpahb
-      {Intrinsic::hexagon_V6_vmpahb_128B, 47875}, // __builtin_HEXAGON_V6_vmpahb_128B
-      {Intrinsic::hexagon_V6_vmpahb_acc, 47908}, // __builtin_HEXAGON_V6_vmpahb_acc
-      {Intrinsic::hexagon_V6_vmpahb_acc_128B, 47940}, // __builtin_HEXAGON_V6_vmpahb_acc_128B
-      {Intrinsic::hexagon_V6_vmpahhsat, 47977}, // __builtin_HEXAGON_V6_vmpahhsat
-      {Intrinsic::hexagon_V6_vmpahhsat_128B, 48008}, // __builtin_HEXAGON_V6_vmpahhsat_128B
-      {Intrinsic::hexagon_V6_vmpauhb, 48044}, // __builtin_HEXAGON_V6_vmpauhb
-      {Intrinsic::hexagon_V6_vmpauhb_128B, 48073}, // __builtin_HEXAGON_V6_vmpauhb_128B
-      {Intrinsic::hexagon_V6_vmpauhb_acc, 48107}, // __builtin_HEXAGON_V6_vmpauhb_acc
-      {Intrinsic::hexagon_V6_vmpauhb_acc_128B, 48140}, // __builtin_HEXAGON_V6_vmpauhb_acc_128B
-      {Intrinsic::hexagon_V6_vmpauhuhsat, 48178}, // __builtin_HEXAGON_V6_vmpauhuhsat
-      {Intrinsic::hexagon_V6_vmpauhuhsat_128B, 48211}, // __builtin_HEXAGON_V6_vmpauhuhsat_128B
-      {Intrinsic::hexagon_V6_vmpsuhuhsat, 48249}, // __builtin_HEXAGON_V6_vmpsuhuhsat
-      {Intrinsic::hexagon_V6_vmpsuhuhsat_128B, 48282}, // __builtin_HEXAGON_V6_vmpsuhuhsat_128B
-      {Intrinsic::hexagon_V6_vmpybus, 48320}, // __builtin_HEXAGON_V6_vmpybus
-      {Intrinsic::hexagon_V6_vmpybus_128B, 48349}, // __builtin_HEXAGON_V6_vmpybus_128B
-      {Intrinsic::hexagon_V6_vmpybus_acc, 48383}, // __builtin_HEXAGON_V6_vmpybus_acc
-      {Intrinsic::hexagon_V6_vmpybus_acc_128B, 48416}, // __builtin_HEXAGON_V6_vmpybus_acc_128B
-      {Intrinsic::hexagon_V6_vmpybusv, 48454}, // __builtin_HEXAGON_V6_vmpybusv
-      {Intrinsic::hexagon_V6_vmpybusv_128B, 48484}, // __builtin_HEXAGON_V6_vmpybusv_128B
-      {Intrinsic::hexagon_V6_vmpybusv_acc, 48519}, // __builtin_HEXAGON_V6_vmpybusv_acc
-      {Intrinsic::hexagon_V6_vmpybusv_acc_128B, 48553}, // __builtin_HEXAGON_V6_vmpybusv_acc_128B
-      {Intrinsic::hexagon_V6_vmpybv, 48592}, // __builtin_HEXAGON_V6_vmpybv
-      {Intrinsic::hexagon_V6_vmpybv_128B, 48620}, // __builtin_HEXAGON_V6_vmpybv_128B
-      {Intrinsic::hexagon_V6_vmpybv_acc, 48653}, // __builtin_HEXAGON_V6_vmpybv_acc
-      {Intrinsic::hexagon_V6_vmpybv_acc_128B, 48685}, // __builtin_HEXAGON_V6_vmpybv_acc_128B
-      {Intrinsic::hexagon_V6_vmpyewuh, 48722}, // __builtin_HEXAGON_V6_vmpyewuh
-      {Intrinsic::hexagon_V6_vmpyewuh_128B, 48752}, // __builtin_HEXAGON_V6_vmpyewuh_128B
-      {Intrinsic::hexagon_V6_vmpyewuh_64, 48787}, // __builtin_HEXAGON_V6_vmpyewuh_64
-      {Intrinsic::hexagon_V6_vmpyewuh_64_128B, 48820}, // __builtin_HEXAGON_V6_vmpyewuh_64_128B
-      {Intrinsic::hexagon_V6_vmpyh, 48858}, // __builtin_HEXAGON_V6_vmpyh
-      {Intrinsic::hexagon_V6_vmpyh_128B, 48885}, // __builtin_HEXAGON_V6_vmpyh_128B
-      {Intrinsic::hexagon_V6_vmpyh_acc, 48917}, // __builtin_HEXAGON_V6_vmpyh_acc
-      {Intrinsic::hexagon_V6_vmpyh_acc_128B, 48948}, // __builtin_HEXAGON_V6_vmpyh_acc_128B
-      {Intrinsic::hexagon_V6_vmpyhsat_acc, 48984}, // __builtin_HEXAGON_V6_vmpyhsat_acc
-      {Intrinsic::hexagon_V6_vmpyhsat_acc_128B, 49018}, // __builtin_HEXAGON_V6_vmpyhsat_acc_128B
-      {Intrinsic::hexagon_V6_vmpyhsrs, 49057}, // __builtin_HEXAGON_V6_vmpyhsrs
-      {Intrinsic::hexagon_V6_vmpyhsrs_128B, 49087}, // __builtin_HEXAGON_V6_vmpyhsrs_128B
-      {Intrinsic::hexagon_V6_vmpyhss, 49122}, // __builtin_HEXAGON_V6_vmpyhss
-      {Intrinsic::hexagon_V6_vmpyhss_128B, 49151}, // __builtin_HEXAGON_V6_vmpyhss_128B
-      {Intrinsic::hexagon_V6_vmpyhus, 49185}, // __builtin_HEXAGON_V6_vmpyhus
-      {Intrinsic::hexagon_V6_vmpyhus_128B, 49214}, // __builtin_HEXAGON_V6_vmpyhus_128B
-      {Intrinsic::hexagon_V6_vmpyhus_acc, 49248}, // __builtin_HEXAGON_V6_vmpyhus_acc
-      {Intrinsic::hexagon_V6_vmpyhus_acc_128B, 49281}, // __builtin_HEXAGON_V6_vmpyhus_acc_128B
-      {Intrinsic::hexagon_V6_vmpyhv, 49319}, // __builtin_HEXAGON_V6_vmpyhv
-      {Intrinsic::hexagon_V6_vmpyhv_128B, 49347}, // __builtin_HEXAGON_V6_vmpyhv_128B
-      {Intrinsic::hexagon_V6_vmpyhv_acc, 49380}, // __builtin_HEXAGON_V6_vmpyhv_acc
-      {Intrinsic::hexagon_V6_vmpyhv_acc_128B, 49412}, // __builtin_HEXAGON_V6_vmpyhv_acc_128B
-      {Intrinsic::hexagon_V6_vmpyhvsrs, 49449}, // __builtin_HEXAGON_V6_vmpyhvsrs
-      {Intrinsic::hexagon_V6_vmpyhvsrs_128B, 49480}, // __builtin_HEXAGON_V6_vmpyhvsrs_128B
-      {Intrinsic::hexagon_V6_vmpyieoh, 49516}, // __builtin_HEXAGON_V6_vmpyieoh
-      {Intrinsic::hexagon_V6_vmpyieoh_128B, 49546}, // __builtin_HEXAGON_V6_vmpyieoh_128B
-      {Intrinsic::hexagon_V6_vmpyiewh_acc, 49581}, // __builtin_HEXAGON_V6_vmpyiewh_acc
-      {Intrinsic::hexagon_V6_vmpyiewh_acc_128B, 49615}, // __builtin_HEXAGON_V6_vmpyiewh_acc_128B
-      {Intrinsic::hexagon_V6_vmpyiewuh, 49654}, // __builtin_HEXAGON_V6_vmpyiewuh
-      {Intrinsic::hexagon_V6_vmpyiewuh_128B, 49685}, // __builtin_HEXAGON_V6_vmpyiewuh_128B
-      {Intrinsic::hexagon_V6_vmpyiewuh_acc, 49721}, // __builtin_HEXAGON_V6_vmpyiewuh_acc
-      {Intrinsic::hexagon_V6_vmpyiewuh_acc_128B, 49756}, // __builtin_HEXAGON_V6_vmpyiewuh_acc_128B
-      {Intrinsic::hexagon_V6_vmpyih, 49796}, // __builtin_HEXAGON_V6_vmpyih
-      {Intrinsic::hexagon_V6_vmpyih_128B, 49824}, // __builtin_HEXAGON_V6_vmpyih_128B
-      {Intrinsic::hexagon_V6_vmpyih_acc, 49857}, // __builtin_HEXAGON_V6_vmpyih_acc
-      {Intrinsic::hexagon_V6_vmpyih_acc_128B, 49889}, // __builtin_HEXAGON_V6_vmpyih_acc_128B
-      {Intrinsic::hexagon_V6_vmpyihb, 49926}, // __builtin_HEXAGON_V6_vmpyihb
-      {Intrinsic::hexagon_V6_vmpyihb_128B, 49955}, // __builtin_HEXAGON_V6_vmpyihb_128B
-      {Intrinsic::hexagon_V6_vmpyihb_acc, 49989}, // __builtin_HEXAGON_V6_vmpyihb_acc
-      {Intrinsic::hexagon_V6_vmpyihb_acc_128B, 50022}, // __builtin_HEXAGON_V6_vmpyihb_acc_128B
-      {Intrinsic::hexagon_V6_vmpyiowh, 50060}, // __builtin_HEXAGON_V6_vmpyiowh
-      {Intrinsic::hexagon_V6_vmpyiowh_128B, 50090}, // __builtin_HEXAGON_V6_vmpyiowh_128B
-      {Intrinsic::hexagon_V6_vmpyiwb, 50125}, // __builtin_HEXAGON_V6_vmpyiwb
-      {Intrinsic::hexagon_V6_vmpyiwb_128B, 50154}, // __builtin_HEXAGON_V6_vmpyiwb_128B
-      {Intrinsic::hexagon_V6_vmpyiwb_acc, 50188}, // __builtin_HEXAGON_V6_vmpyiwb_acc
-      {Intrinsic::hexagon_V6_vmpyiwb_acc_128B, 50221}, // __builtin_HEXAGON_V6_vmpyiwb_acc_128B
-      {Intrinsic::hexagon_V6_vmpyiwh, 50259}, // __builtin_HEXAGON_V6_vmpyiwh
-      {Intrinsic::hexagon_V6_vmpyiwh_128B, 50288}, // __builtin_HEXAGON_V6_vmpyiwh_128B
-      {Intrinsic::hexagon_V6_vmpyiwh_acc, 50322}, // __builtin_HEXAGON_V6_vmpyiwh_acc
-      {Intrinsic::hexagon_V6_vmpyiwh_acc_128B, 50355}, // __builtin_HEXAGON_V6_vmpyiwh_acc_128B
-      {Intrinsic::hexagon_V6_vmpyiwub, 50393}, // __builtin_HEXAGON_V6_vmpyiwub
-      {Intrinsic::hexagon_V6_vmpyiwub_128B, 50423}, // __builtin_HEXAGON_V6_vmpyiwub_128B
-      {Intrinsic::hexagon_V6_vmpyiwub_acc, 50458}, // __builtin_HEXAGON_V6_vmpyiwub_acc
-      {Intrinsic::hexagon_V6_vmpyiwub_acc_128B, 50492}, // __builtin_HEXAGON_V6_vmpyiwub_acc_128B
-      {Intrinsic::hexagon_V6_vmpyowh, 50531}, // __builtin_HEXAGON_V6_vmpyowh
-      {Intrinsic::hexagon_V6_vmpyowh_128B, 50560}, // __builtin_HEXAGON_V6_vmpyowh_128B
-      {Intrinsic::hexagon_V6_vmpyowh_64_acc, 50594}, // __builtin_HEXAGON_V6_vmpyowh_64_acc
-      {Intrinsic::hexagon_V6_vmpyowh_64_acc_128B, 50630}, // __builtin_HEXAGON_V6_vmpyowh_64_acc_128B
-      {Intrinsic::hexagon_V6_vmpyowh_rnd, 50671}, // __builtin_HEXAGON_V6_vmpyowh_rnd
-      {Intrinsic::hexagon_V6_vmpyowh_rnd_128B, 50704}, // __builtin_HEXAGON_V6_vmpyowh_rnd_128B
-      {Intrinsic::hexagon_V6_vmpyowh_rnd_sacc, 50742}, // __builtin_HEXAGON_V6_vmpyowh_rnd_sacc
-      {Intrinsic::hexagon_V6_vmpyowh_rnd_sacc_128B, 50780}, // __builtin_HEXAGON_V6_vmpyowh_rnd_sacc_128B
-      {Intrinsic::hexagon_V6_vmpyowh_sacc, 50823}, // __builtin_HEXAGON_V6_vmpyowh_sacc
-      {Intrinsic::hexagon_V6_vmpyowh_sacc_128B, 50857}, // __builtin_HEXAGON_V6_vmpyowh_sacc_128B
-      {Intrinsic::hexagon_V6_vmpyub, 50896}, // __builtin_HEXAGON_V6_vmpyub
-      {Intrinsic::hexagon_V6_vmpyub_128B, 50924}, // __builtin_HEXAGON_V6_vmpyub_128B
-      {Intrinsic::hexagon_V6_vmpyub_acc, 50957}, // __builtin_HEXAGON_V6_vmpyub_acc
-      {Intrinsic::hexagon_V6_vmpyub_acc_128B, 50989}, // __builtin_HEXAGON_V6_vmpyub_acc_128B
-      {Intrinsic::hexagon_V6_vmpyubv, 51026}, // __builtin_HEXAGON_V6_vmpyubv
-      {Intrinsic::hexagon_V6_vmpyubv_128B, 51055}, // __builtin_HEXAGON_V6_vmpyubv_128B
-      {Intrinsic::hexagon_V6_vmpyubv_acc, 51089}, // __builtin_HEXAGON_V6_vmpyubv_acc
-      {Intrinsic::hexagon_V6_vmpyubv_acc_128B, 51122}, // __builtin_HEXAGON_V6_vmpyubv_acc_128B
-      {Intrinsic::hexagon_V6_vmpyuh, 51160}, // __builtin_HEXAGON_V6_vmpyuh
-      {Intrinsic::hexagon_V6_vmpyuh_128B, 51188}, // __builtin_HEXAGON_V6_vmpyuh_128B
-      {Intrinsic::hexagon_V6_vmpyuh_acc, 51221}, // __builtin_HEXAGON_V6_vmpyuh_acc
-      {Intrinsic::hexagon_V6_vmpyuh_acc_128B, 51253}, // __builtin_HEXAGON_V6_vmpyuh_acc_128B
-      {Intrinsic::hexagon_V6_vmpyuhe, 51290}, // __builtin_HEXAGON_V6_vmpyuhe
-      {Intrinsic::hexagon_V6_vmpyuhe_128B, 51319}, // __builtin_HEXAGON_V6_vmpyuhe_128B
-      {Intrinsic::hexagon_V6_vmpyuhe_acc, 51353}, // __builtin_HEXAGON_V6_vmpyuhe_acc
-      {Intrinsic::hexagon_V6_vmpyuhe_acc_128B, 51386}, // __builtin_HEXAGON_V6_vmpyuhe_acc_128B
-      {Intrinsic::hexagon_V6_vmpyuhv, 51424}, // __builtin_HEXAGON_V6_vmpyuhv
-      {Intrinsic::hexagon_V6_vmpyuhv_128B, 51453}, // __builtin_HEXAGON_V6_vmpyuhv_128B
-      {Intrinsic::hexagon_V6_vmpyuhv_acc, 51487}, // __builtin_HEXAGON_V6_vmpyuhv_acc
-      {Intrinsic::hexagon_V6_vmpyuhv_acc_128B, 51520}, // __builtin_HEXAGON_V6_vmpyuhv_acc_128B
-      {Intrinsic::hexagon_V6_vmux, 51558}, // __builtin_HEXAGON_V6_vmux
-      {Intrinsic::hexagon_V6_vmux_128B, 51584}, // __builtin_HEXAGON_V6_vmux_128B
-      {Intrinsic::hexagon_V6_vnavgb, 51615}, // __builtin_HEXAGON_V6_vnavgb
-      {Intrinsic::hexagon_V6_vnavgb_128B, 51643}, // __builtin_HEXAGON_V6_vnavgb_128B
-      {Intrinsic::hexagon_V6_vnavgh, 51676}, // __builtin_HEXAGON_V6_vnavgh
-      {Intrinsic::hexagon_V6_vnavgh_128B, 51704}, // __builtin_HEXAGON_V6_vnavgh_128B
-      {Intrinsic::hexagon_V6_vnavgub, 51737}, // __builtin_HEXAGON_V6_vnavgub
-      {Intrinsic::hexagon_V6_vnavgub_128B, 51766}, // __builtin_HEXAGON_V6_vnavgub_128B
-      {Intrinsic::hexagon_V6_vnavgw, 51800}, // __builtin_HEXAGON_V6_vnavgw
-      {Intrinsic::hexagon_V6_vnavgw_128B, 51828}, // __builtin_HEXAGON_V6_vnavgw_128B
-      {Intrinsic::hexagon_V6_vnormamth, 51861}, // __builtin_HEXAGON_V6_vnormamth
-      {Intrinsic::hexagon_V6_vnormamth_128B, 51892}, // __builtin_HEXAGON_V6_vnormamth_128B
-      {Intrinsic::hexagon_V6_vnormamtw, 51928}, // __builtin_HEXAGON_V6_vnormamtw
-      {Intrinsic::hexagon_V6_vnormamtw_128B, 51959}, // __builtin_HEXAGON_V6_vnormamtw_128B
-      {Intrinsic::hexagon_V6_vnot, 51995}, // __builtin_HEXAGON_V6_vnot
-      {Intrinsic::hexagon_V6_vnot_128B, 52021}, // __builtin_HEXAGON_V6_vnot_128B
-      {Intrinsic::hexagon_V6_vor, 52052}, // __builtin_HEXAGON_V6_vor
-      {Intrinsic::hexagon_V6_vor_128B, 52077}, // __builtin_HEXAGON_V6_vor_128B
-      {Intrinsic::hexagon_V6_vpackeb, 52107}, // __builtin_HEXAGON_V6_vpackeb
-      {Intrinsic::hexagon_V6_vpackeb_128B, 52136}, // __builtin_HEXAGON_V6_vpackeb_128B
-      {Intrinsic::hexagon_V6_vpackeh, 52170}, // __builtin_HEXAGON_V6_vpackeh
-      {Intrinsic::hexagon_V6_vpackeh_128B, 52199}, // __builtin_HEXAGON_V6_vpackeh_128B
-      {Intrinsic::hexagon_V6_vpackhb_sat, 52233}, // __builtin_HEXAGON_V6_vpackhb_sat
-      {Intrinsic::hexagon_V6_vpackhb_sat_128B, 52266}, // __builtin_HEXAGON_V6_vpackhb_sat_128B
-      {Intrinsic::hexagon_V6_vpackhub_sat, 52304}, // __builtin_HEXAGON_V6_vpackhub_sat
-      {Intrinsic::hexagon_V6_vpackhub_sat_128B, 52338}, // __builtin_HEXAGON_V6_vpackhub_sat_128B
-      {Intrinsic::hexagon_V6_vpackob, 52377}, // __builtin_HEXAGON_V6_vpackob
-      {Intrinsic::hexagon_V6_vpackob_128B, 52406}, // __builtin_HEXAGON_V6_vpackob_128B
-      {Intrinsic::hexagon_V6_vpackoh, 52440}, // __builtin_HEXAGON_V6_vpackoh
-      {Intrinsic::hexagon_V6_vpackoh_128B, 52469}, // __builtin_HEXAGON_V6_vpackoh_128B
-      {Intrinsic::hexagon_V6_vpackwh_sat, 52503}, // __builtin_HEXAGON_V6_vpackwh_sat
-      {Intrinsic::hexagon_V6_vpackwh_sat_128B, 52536}, // __builtin_HEXAGON_V6_vpackwh_sat_128B
-      {Intrinsic::hexagon_V6_vpackwuh_sat, 52574}, // __builtin_HEXAGON_V6_vpackwuh_sat
-      {Intrinsic::hexagon_V6_vpackwuh_sat_128B, 52608}, // __builtin_HEXAGON_V6_vpackwuh_sat_128B
-      {Intrinsic::hexagon_V6_vpopcounth, 52647}, // __builtin_HEXAGON_V6_vpopcounth
-      {Intrinsic::hexagon_V6_vpopcounth_128B, 52679}, // __builtin_HEXAGON_V6_vpopcounth_128B
-      {Intrinsic::hexagon_V6_vprefixqb, 52716}, // __builtin_HEXAGON_V6_vprefixqb
-      {Intrinsic::hexagon_V6_vprefixqb_128B, 52747}, // __builtin_HEXAGON_V6_vprefixqb_128B
-      {Intrinsic::hexagon_V6_vprefixqh, 52783}, // __builtin_HEXAGON_V6_vprefixqh
-      {Intrinsic::hexagon_V6_vprefixqh_128B, 52814}, // __builtin_HEXAGON_V6_vprefixqh_128B
-      {Intrinsic::hexagon_V6_vprefixqw, 52850}, // __builtin_HEXAGON_V6_vprefixqw
-      {Intrinsic::hexagon_V6_vprefixqw_128B, 52881}, // __builtin_HEXAGON_V6_vprefixqw_128B
-      {Intrinsic::hexagon_V6_vrdelta, 52917}, // __builtin_HEXAGON_V6_vrdelta
-      {Intrinsic::hexagon_V6_vrdelta_128B, 52946}, // __builtin_HEXAGON_V6_vrdelta_128B
-      {Intrinsic::hexagon_V6_vrmpybub_rtt, 52980}, // __builtin_HEXAGON_V6_vrmpybub_rtt
-      {Intrinsic::hexagon_V6_vrmpybub_rtt_128B, 53014}, // __builtin_HEXAGON_V6_vrmpybub_rtt_128B
-      {Intrinsic::hexagon_V6_vrmpybub_rtt_acc, 53053}, // __builtin_HEXAGON_V6_vrmpybub_rtt_acc
-      {Intrinsic::hexagon_V6_vrmpybub_rtt_acc_128B, 53091}, // __builtin_HEXAGON_V6_vrmpybub_rtt_acc_128B
-      {Intrinsic::hexagon_V6_vrmpybus, 53134}, // __builtin_HEXAGON_V6_vrmpybus
-      {Intrinsic::hexagon_V6_vrmpybus_128B, 53164}, // __builtin_HEXAGON_V6_vrmpybus_128B
-      {Intrinsic::hexagon_V6_vrmpybus_acc, 53199}, // __builtin_HEXAGON_V6_vrmpybus_acc
-      {Intrinsic::hexagon_V6_vrmpybus_acc_128B, 53233}, // __builtin_HEXAGON_V6_vrmpybus_acc_128B
-      {Intrinsic::hexagon_V6_vrmpybusi, 53272}, // __builtin_HEXAGON_V6_vrmpybusi
-      {Intrinsic::hexagon_V6_vrmpybusi_128B, 53303}, // __builtin_HEXAGON_V6_vrmpybusi_128B
-      {Intrinsic::hexagon_V6_vrmpybusi_acc, 53339}, // __builtin_HEXAGON_V6_vrmpybusi_acc
-      {Intrinsic::hexagon_V6_vrmpybusi_acc_128B, 53374}, // __builtin_HEXAGON_V6_vrmpybusi_acc_128B
-      {Intrinsic::hexagon_V6_vrmpybusv, 53414}, // __builtin_HEXAGON_V6_vrmpybusv
-      {Intrinsic::hexagon_V6_vrmpybusv_128B, 53445}, // __builtin_HEXAGON_V6_vrmpybusv_128B
-      {Intrinsic::hexagon_V6_vrmpybusv_acc, 53481}, // __builtin_HEXAGON_V6_vrmpybusv_acc
-      {Intrinsic::hexagon_V6_vrmpybusv_acc_128B, 53516}, // __builtin_HEXAGON_V6_vrmpybusv_acc_128B
-      {Intrinsic::hexagon_V6_vrmpybv, 53556}, // __builtin_HEXAGON_V6_vrmpybv
-      {Intrinsic::hexagon_V6_vrmpybv_128B, 53585}, // __builtin_HEXAGON_V6_vrmpybv_128B
-      {Intrinsic::hexagon_V6_vrmpybv_acc, 53619}, // __builtin_HEXAGON_V6_vrmpybv_acc
-      {Intrinsic::hexagon_V6_vrmpybv_acc_128B, 53652}, // __builtin_HEXAGON_V6_vrmpybv_acc_128B
-      {Intrinsic::hexagon_V6_vrmpyub, 53690}, // __builtin_HEXAGON_V6_vrmpyub
-      {Intrinsic::hexagon_V6_vrmpyub_128B, 53719}, // __builtin_HEXAGON_V6_vrmpyub_128B
-      {Intrinsic::hexagon_V6_vrmpyub_acc, 53753}, // __builtin_HEXAGON_V6_vrmpyub_acc
-      {Intrinsic::hexagon_V6_vrmpyub_acc_128B, 53786}, // __builtin_HEXAGON_V6_vrmpyub_acc_128B
-      {Intrinsic::hexagon_V6_vrmpyub_rtt, 53824}, // __builtin_HEXAGON_V6_vrmpyub_rtt
-      {Intrinsic::hexagon_V6_vrmpyub_rtt_128B, 53857}, // __builtin_HEXAGON_V6_vrmpyub_rtt_128B
-      {Intrinsic::hexagon_V6_vrmpyub_rtt_acc, 53895}, // __builtin_HEXAGON_V6_vrmpyub_rtt_acc
-      {Intrinsic::hexagon_V6_vrmpyub_rtt_acc_128B, 53932}, // __builtin_HEXAGON_V6_vrmpyub_rtt_acc_128B
-      {Intrinsic::hexagon_V6_vrmpyubi, 53974}, // __builtin_HEXAGON_V6_vrmpyubi
-      {Intrinsic::hexagon_V6_vrmpyubi_128B, 54004}, // __builtin_HEXAGON_V6_vrmpyubi_128B
-      {Intrinsic::hexagon_V6_vrmpyubi_acc, 54039}, // __builtin_HEXAGON_V6_vrmpyubi_acc
-      {Intrinsic::hexagon_V6_vrmpyubi_acc_128B, 54073}, // __builtin_HEXAGON_V6_vrmpyubi_acc_128B
-      {Intrinsic::hexagon_V6_vrmpyubv, 54112}, // __builtin_HEXAGON_V6_vrmpyubv
-      {Intrinsic::hexagon_V6_vrmpyubv_128B, 54142}, // __builtin_HEXAGON_V6_vrmpyubv_128B
-      {Intrinsic::hexagon_V6_vrmpyubv_acc, 54177}, // __builtin_HEXAGON_V6_vrmpyubv_acc
-      {Intrinsic::hexagon_V6_vrmpyubv_acc_128B, 54211}, // __builtin_HEXAGON_V6_vrmpyubv_acc_128B
-      {Intrinsic::hexagon_V6_vror, 54250}, // __builtin_HEXAGON_V6_vror
-      {Intrinsic::hexagon_V6_vror_128B, 54276}, // __builtin_HEXAGON_V6_vror_128B
-      {Intrinsic::hexagon_V6_vrotr, 54307}, // __builtin_HEXAGON_V6_vrotr
-      {Intrinsic::hexagon_V6_vrotr_128B, 54334}, // __builtin_HEXAGON_V6_vrotr_128B
-      {Intrinsic::hexagon_V6_vroundhb, 54366}, // __builtin_HEXAGON_V6_vroundhb
-      {Intrinsic::hexagon_V6_vroundhb_128B, 54396}, // __builtin_HEXAGON_V6_vroundhb_128B
-      {Intrinsic::hexagon_V6_vroundhub, 54431}, // __builtin_HEXAGON_V6_vroundhub
-      {Intrinsic::hexagon_V6_vroundhub_128B, 54462}, // __builtin_HEXAGON_V6_vroundhub_128B
-      {Intrinsic::hexagon_V6_vrounduhub, 54498}, // __builtin_HEXAGON_V6_vrounduhub
-      {Intrinsic::hexagon_V6_vrounduhub_128B, 54530}, // __builtin_HEXAGON_V6_vrounduhub_128B
-      {Intrinsic::hexagon_V6_vrounduwuh, 54567}, // __builtin_HEXAGON_V6_vrounduwuh
-      {Intrinsic::hexagon_V6_vrounduwuh_128B, 54599}, // __builtin_HEXAGON_V6_vrounduwuh_128B
-      {Intrinsic::hexagon_V6_vroundwh, 54636}, // __builtin_HEXAGON_V6_vroundwh
-      {Intrinsic::hexagon_V6_vroundwh_128B, 54666}, // __builtin_HEXAGON_V6_vroundwh_128B
-      {Intrinsic::hexagon_V6_vroundwuh, 54701}, // __builtin_HEXAGON_V6_vroundwuh
-      {Intrinsic::hexagon_V6_vroundwuh_128B, 54732}, // __builtin_HEXAGON_V6_vroundwuh_128B
-      {Intrinsic::hexagon_V6_vrsadubi, 54768}, // __builtin_HEXAGON_V6_vrsadubi
-      {Intrinsic::hexagon_V6_vrsadubi_128B, 54798}, // __builtin_HEXAGON_V6_vrsadubi_128B
-      {Intrinsic::hexagon_V6_vrsadubi_acc, 54833}, // __builtin_HEXAGON_V6_vrsadubi_acc
-      {Intrinsic::hexagon_V6_vrsadubi_acc_128B, 54867}, // __builtin_HEXAGON_V6_vrsadubi_acc_128B
-      {Intrinsic::hexagon_V6_vsatdw, 54906}, // __builtin_HEXAGON_V6_vsatdw
-      {Intrinsic::hexagon_V6_vsatdw_128B, 54934}, // __builtin_HEXAGON_V6_vsatdw_128B
-      {Intrinsic::hexagon_V6_vsathub, 54967}, // __builtin_HEXAGON_V6_vsathub
-      {Intrinsic::hexagon_V6_vsathub_128B, 54996}, // __builtin_HEXAGON_V6_vsathub_128B
-      {Intrinsic::hexagon_V6_vsatuwuh, 55030}, // __builtin_HEXAGON_V6_vsatuwuh
-      {Intrinsic::hexagon_V6_vsatuwuh_128B, 55060}, // __builtin_HEXAGON_V6_vsatuwuh_128B
-      {Intrinsic::hexagon_V6_vsatwh, 55095}, // __builtin_HEXAGON_V6_vsatwh
-      {Intrinsic::hexagon_V6_vsatwh_128B, 55123}, // __builtin_HEXAGON_V6_vsatwh_128B
-      {Intrinsic::hexagon_V6_vsb, 55156}, // __builtin_HEXAGON_V6_vsb
-      {Intrinsic::hexagon_V6_vsb_128B, 55181}, // __builtin_HEXAGON_V6_vsb_128B
-      {Intrinsic::hexagon_V6_vscattermh, 55211}, // __builtin_HEXAGON_V6_vscattermh
-      {Intrinsic::hexagon_V6_vscattermh_128B, 55243}, // __builtin_HEXAGON_V6_vscattermh_128B
-      {Intrinsic::hexagon_V6_vscattermh_add, 55280}, // __builtin_HEXAGON_V6_vscattermh_add
-      {Intrinsic::hexagon_V6_vscattermh_add_128B, 55316}, // __builtin_HEXAGON_V6_vscattermh_add_128B
-      {Intrinsic::hexagon_V6_vscattermhq, 55357}, // __builtin_HEXAGON_V6_vscattermhq
-      {Intrinsic::hexagon_V6_vscattermhq_128B, 55390}, // __builtin_HEXAGON_V6_vscattermhq_128B
-      {Intrinsic::hexagon_V6_vscattermhw, 55428}, // __builtin_HEXAGON_V6_vscattermhw
-      {Intrinsic::hexagon_V6_vscattermhw_128B, 55461}, // __builtin_HEXAGON_V6_vscattermhw_128B
-      {Intrinsic::hexagon_V6_vscattermhw_add, 55499}, // __builtin_HEXAGON_V6_vscattermhw_add
-      {Intrinsic::hexagon_V6_vscattermhw_add_128B, 55536}, // __builtin_HEXAGON_V6_vscattermhw_add_128B
-      {Intrinsic::hexagon_V6_vscattermhwq, 55578}, // __builtin_HEXAGON_V6_vscattermhwq
-      {Intrinsic::hexagon_V6_vscattermhwq_128B, 55612}, // __builtin_HEXAGON_V6_vscattermhwq_128B
-      {Intrinsic::hexagon_V6_vscattermw, 55651}, // __builtin_HEXAGON_V6_vscattermw
-      {Intrinsic::hexagon_V6_vscattermw_128B, 55683}, // __builtin_HEXAGON_V6_vscattermw_128B
-      {Intrinsic::hexagon_V6_vscattermw_add, 55720}, // __builtin_HEXAGON_V6_vscattermw_add
-      {Intrinsic::hexagon_V6_vscattermw_add_128B, 55756}, // __builtin_HEXAGON_V6_vscattermw_add_128B
-      {Intrinsic::hexagon_V6_vscattermwq, 55797}, // __builtin_HEXAGON_V6_vscattermwq
-      {Intrinsic::hexagon_V6_vscattermwq_128B, 55830}, // __builtin_HEXAGON_V6_vscattermwq_128B
-      {Intrinsic::hexagon_V6_vsh, 55868}, // __builtin_HEXAGON_V6_vsh
-      {Intrinsic::hexagon_V6_vsh_128B, 55893}, // __builtin_HEXAGON_V6_vsh_128B
-      {Intrinsic::hexagon_V6_vshufeh, 55923}, // __builtin_HEXAGON_V6_vshufeh
-      {Intrinsic::hexagon_V6_vshufeh_128B, 55952}, // __builtin_HEXAGON_V6_vshufeh_128B
-      {Intrinsic::hexagon_V6_vshuffb, 55986}, // __builtin_HEXAGON_V6_vshuffb
-      {Intrinsic::hexagon_V6_vshuffb_128B, 56015}, // __builtin_HEXAGON_V6_vshuffb_128B
-      {Intrinsic::hexagon_V6_vshuffeb, 56049}, // __builtin_HEXAGON_V6_vshuffeb
-      {Intrinsic::hexagon_V6_vshuffeb_128B, 56079}, // __builtin_HEXAGON_V6_vshuffeb_128B
-      {Intrinsic::hexagon_V6_vshuffh, 56114}, // __builtin_HEXAGON_V6_vshuffh
-      {Intrinsic::hexagon_V6_vshuffh_128B, 56143}, // __builtin_HEXAGON_V6_vshuffh_128B
-      {Intrinsic::hexagon_V6_vshuffob, 56177}, // __builtin_HEXAGON_V6_vshuffob
-      {Intrinsic::hexagon_V6_vshuffob_128B, 56207}, // __builtin_HEXAGON_V6_vshuffob_128B
-      {Intrinsic::hexagon_V6_vshuffvdd, 56242}, // __builtin_HEXAGON_V6_vshuffvdd
-      {Intrinsic::hexagon_V6_vshuffvdd_128B, 56273}, // __builtin_HEXAGON_V6_vshuffvdd_128B
-      {Intrinsic::hexagon_V6_vshufoeb, 56309}, // __builtin_HEXAGON_V6_vshufoeb
-      {Intrinsic::hexagon_V6_vshufoeb_128B, 56339}, // __builtin_HEXAGON_V6_vshufoeb_128B
-      {Intrinsic::hexagon_V6_vshufoeh, 56374}, // __builtin_HEXAGON_V6_vshufoeh
-      {Intrinsic::hexagon_V6_vshufoeh_128B, 56404}, // __builtin_HEXAGON_V6_vshufoeh_128B
-      {Intrinsic::hexagon_V6_vshufoh, 56439}, // __builtin_HEXAGON_V6_vshufoh
-      {Intrinsic::hexagon_V6_vshufoh_128B, 56468}, // __builtin_HEXAGON_V6_vshufoh_128B
-      {Intrinsic::hexagon_V6_vsubb, 56502}, // __builtin_HEXAGON_V6_vsubb
-      {Intrinsic::hexagon_V6_vsubb_128B, 56529}, // __builtin_HEXAGON_V6_vsubb_128B
-      {Intrinsic::hexagon_V6_vsubb_dv, 56561}, // __builtin_HEXAGON_V6_vsubb_dv
-      {Intrinsic::hexagon_V6_vsubb_dv_128B, 56591}, // __builtin_HEXAGON_V6_vsubb_dv_128B
-      {Intrinsic::hexagon_V6_vsubbnq, 56626}, // __builtin_HEXAGON_V6_vsubbnq
-      {Intrinsic::hexagon_V6_vsubbnq_128B, 56655}, // __builtin_HEXAGON_V6_vsubbnq_128B
-      {Intrinsic::hexagon_V6_vsubbq, 56689}, // __builtin_HEXAGON_V6_vsubbq
-      {Intrinsic::hexagon_V6_vsubbq_128B, 56717}, // __builtin_HEXAGON_V6_vsubbq_128B
-      {Intrinsic::hexagon_V6_vsubbsat, 56750}, // __builtin_HEXAGON_V6_vsubbsat
-      {Intrinsic::hexagon_V6_vsubbsat_128B, 56780}, // __builtin_HEXAGON_V6_vsubbsat_128B
-      {Intrinsic::hexagon_V6_vsubbsat_dv, 56815}, // __builtin_HEXAGON_V6_vsubbsat_dv
-      {Intrinsic::hexagon_V6_vsubbsat_dv_128B, 56848}, // __builtin_HEXAGON_V6_vsubbsat_dv_128B
-      {Intrinsic::hexagon_V6_vsubh, 56886}, // __builtin_HEXAGON_V6_vsubh
-      {Intrinsic::hexagon_V6_vsubh_128B, 56913}, // __builtin_HEXAGON_V6_vsubh_128B
-      {Intrinsic::hexagon_V6_vsubh_dv, 56945}, // __builtin_HEXAGON_V6_vsubh_dv
-      {Intrinsic::hexagon_V6_vsubh_dv_128B, 56975}, // __builtin_HEXAGON_V6_vsubh_dv_128B
-      {Intrinsic::hexagon_V6_vsubhnq, 57010}, // __builtin_HEXAGON_V6_vsubhnq
-      {Intrinsic::hexagon_V6_vsubhnq_128B, 57039}, // __builtin_HEXAGON_V6_vsubhnq_128B
-      {Intrinsic::hexagon_V6_vsubhq, 57073}, // __builtin_HEXAGON_V6_vsubhq
-      {Intrinsic::hexagon_V6_vsubhq_128B, 57101}, // __builtin_HEXAGON_V6_vsubhq_128B
-      {Intrinsic::hexagon_V6_vsubhsat, 57134}, // __builtin_HEXAGON_V6_vsubhsat
-      {Intrinsic::hexagon_V6_vsubhsat_128B, 57164}, // __builtin_HEXAGON_V6_vsubhsat_128B
-      {Intrinsic::hexagon_V6_vsubhsat_dv, 57199}, // __builtin_HEXAGON_V6_vsubhsat_dv
-      {Intrinsic::hexagon_V6_vsubhsat_dv_128B, 57232}, // __builtin_HEXAGON_V6_vsubhsat_dv_128B
-      {Intrinsic::hexagon_V6_vsubhw, 57270}, // __builtin_HEXAGON_V6_vsubhw
-      {Intrinsic::hexagon_V6_vsubhw_128B, 57298}, // __builtin_HEXAGON_V6_vsubhw_128B
-      {Intrinsic::hexagon_V6_vsububh, 57331}, // __builtin_HEXAGON_V6_vsububh
-      {Intrinsic::hexagon_V6_vsububh_128B, 57360}, // __builtin_HEXAGON_V6_vsububh_128B
-      {Intrinsic::hexagon_V6_vsububsat, 57394}, // __builtin_HEXAGON_V6_vsububsat
-      {Intrinsic::hexagon_V6_vsububsat_128B, 57425}, // __builtin_HEXAGON_V6_vsububsat_128B
-      {Intrinsic::hexagon_V6_vsububsat_dv, 57461}, // __builtin_HEXAGON_V6_vsububsat_dv
-      {Intrinsic::hexagon_V6_vsububsat_dv_128B, 57495}, // __builtin_HEXAGON_V6_vsububsat_dv_128B
-      {Intrinsic::hexagon_V6_vsubububb_sat, 57534}, // __builtin_HEXAGON_V6_vsubububb_sat
-      {Intrinsic::hexagon_V6_vsubububb_sat_128B, 57569}, // __builtin_HEXAGON_V6_vsubububb_sat_128B
-      {Intrinsic::hexagon_V6_vsubuhsat, 57609}, // __builtin_HEXAGON_V6_vsubuhsat
-      {Intrinsic::hexagon_V6_vsubuhsat_128B, 57640}, // __builtin_HEXAGON_V6_vsubuhsat_128B
-      {Intrinsic::hexagon_V6_vsubuhsat_dv, 57676}, // __builtin_HEXAGON_V6_vsubuhsat_dv
-      {Intrinsic::hexagon_V6_vsubuhsat_dv_128B, 57710}, // __builtin_HEXAGON_V6_vsubuhsat_dv_128B
-      {Intrinsic::hexagon_V6_vsubuhw, 57749}, // __builtin_HEXAGON_V6_vsubuhw
-      {Intrinsic::hexagon_V6_vsubuhw_128B, 57778}, // __builtin_HEXAGON_V6_vsubuhw_128B
-      {Intrinsic::hexagon_V6_vsubuwsat, 57812}, // __builtin_HEXAGON_V6_vsubuwsat
-      {Intrinsic::hexagon_V6_vsubuwsat_128B, 57843}, // __builtin_HEXAGON_V6_vsubuwsat_128B
-      {Intrinsic::hexagon_V6_vsubuwsat_dv, 57879}, // __builtin_HEXAGON_V6_vsubuwsat_dv
-      {Intrinsic::hexagon_V6_vsubuwsat_dv_128B, 57913}, // __builtin_HEXAGON_V6_vsubuwsat_dv_128B
-      {Intrinsic::hexagon_V6_vsubw, 57952}, // __builtin_HEXAGON_V6_vsubw
-      {Intrinsic::hexagon_V6_vsubw_128B, 57979}, // __builtin_HEXAGON_V6_vsubw_128B
-      {Intrinsic::hexagon_V6_vsubw_dv, 58011}, // __builtin_HEXAGON_V6_vsubw_dv
-      {Intrinsic::hexagon_V6_vsubw_dv_128B, 58041}, // __builtin_HEXAGON_V6_vsubw_dv_128B
-      {Intrinsic::hexagon_V6_vsubwnq, 58076}, // __builtin_HEXAGON_V6_vsubwnq
-      {Intrinsic::hexagon_V6_vsubwnq_128B, 58105}, // __builtin_HEXAGON_V6_vsubwnq_128B
-      {Intrinsic::hexagon_V6_vsubwq, 58139}, // __builtin_HEXAGON_V6_vsubwq
-      {Intrinsic::hexagon_V6_vsubwq_128B, 58167}, // __builtin_HEXAGON_V6_vsubwq_128B
-      {Intrinsic::hexagon_V6_vsubwsat, 58200}, // __builtin_HEXAGON_V6_vsubwsat
-      {Intrinsic::hexagon_V6_vsubwsat_128B, 58230}, // __builtin_HEXAGON_V6_vsubwsat_128B
-      {Intrinsic::hexagon_V6_vsubwsat_dv, 58265}, // __builtin_HEXAGON_V6_vsubwsat_dv
-      {Intrinsic::hexagon_V6_vsubwsat_dv_128B, 58298}, // __builtin_HEXAGON_V6_vsubwsat_dv_128B
-      {Intrinsic::hexagon_V6_vswap, 58336}, // __builtin_HEXAGON_V6_vswap
-      {Intrinsic::hexagon_V6_vswap_128B, 58363}, // __builtin_HEXAGON_V6_vswap_128B
-      {Intrinsic::hexagon_V6_vtmpyb, 58395}, // __builtin_HEXAGON_V6_vtmpyb
-      {Intrinsic::hexagon_V6_vtmpyb_128B, 58423}, // __builtin_HEXAGON_V6_vtmpyb_128B
-      {Intrinsic::hexagon_V6_vtmpyb_acc, 58456}, // __builtin_HEXAGON_V6_vtmpyb_acc
-      {Intrinsic::hexagon_V6_vtmpyb_acc_128B, 58488}, // __builtin_HEXAGON_V6_vtmpyb_acc_128B
-      {Intrinsic::hexagon_V6_vtmpybus, 58525}, // __builtin_HEXAGON_V6_vtmpybus
-      {Intrinsic::hexagon_V6_vtmpybus_128B, 58555}, // __builtin_HEXAGON_V6_vtmpybus_128B
-      {Intrinsic::hexagon_V6_vtmpybus_acc, 58590}, // __builtin_HEXAGON_V6_vtmpybus_acc
-      {Intrinsic::hexagon_V6_vtmpybus_acc_128B, 58624}, // __builtin_HEXAGON_V6_vtmpybus_acc_128B
-      {Intrinsic::hexagon_V6_vtmpyhb, 58663}, // __builtin_HEXAGON_V6_vtmpyhb
-      {Intrinsic::hexagon_V6_vtmpyhb_128B, 58692}, // __builtin_HEXAGON_V6_vtmpyhb_128B
-      {Intrinsic::hexagon_V6_vtmpyhb_acc, 58726}, // __builtin_HEXAGON_V6_vtmpyhb_acc
-      {Intrinsic::hexagon_V6_vtmpyhb_acc_128B, 58759}, // __builtin_HEXAGON_V6_vtmpyhb_acc_128B
-      {Intrinsic::hexagon_V6_vtran2x2_map, 58797}, // __builtin_HEXAGON_V6_vtran2x2_map
-      {Intrinsic::hexagon_V6_vtran2x2_map_128B, 58831}, // __builtin_HEXAGON_V6_vtran2x2_map_128B
-      {Intrinsic::hexagon_V6_vunpackb, 58870}, // __builtin_HEXAGON_V6_vunpackb
-      {Intrinsic::hexagon_V6_vunpackb_128B, 58900}, // __builtin_HEXAGON_V6_vunpackb_128B
-      {Intrinsic::hexagon_V6_vunpackh, 58935}, // __builtin_HEXAGON_V6_vunpackh
-      {Intrinsic::hexagon_V6_vunpackh_128B, 58965}, // __builtin_HEXAGON_V6_vunpackh_128B
-      {Intrinsic::hexagon_V6_vunpackob, 59000}, // __builtin_HEXAGON_V6_vunpackob
-      {Intrinsic::hexagon_V6_vunpackob_128B, 59031}, // __builtin_HEXAGON_V6_vunpackob_128B
-      {Intrinsic::hexagon_V6_vunpackoh, 59067}, // __builtin_HEXAGON_V6_vunpackoh
-      {Intrinsic::hexagon_V6_vunpackoh_128B, 59098}, // __builtin_HEXAGON_V6_vunpackoh_128B
-      {Intrinsic::hexagon_V6_vunpackub, 59134}, // __builtin_HEXAGON_V6_vunpackub
-      {Intrinsic::hexagon_V6_vunpackub_128B, 59165}, // __builtin_HEXAGON_V6_vunpackub_128B
-      {Intrinsic::hexagon_V6_vunpackuh, 59201}, // __builtin_HEXAGON_V6_vunpackuh
-      {Intrinsic::hexagon_V6_vunpackuh_128B, 59232}, // __builtin_HEXAGON_V6_vunpackuh_128B
-      {Intrinsic::hexagon_V6_vxor, 59268}, // __builtin_HEXAGON_V6_vxor
-      {Intrinsic::hexagon_V6_vxor_128B, 59294}, // __builtin_HEXAGON_V6_vxor_128B
-      {Intrinsic::hexagon_V6_vzb, 59325}, // __builtin_HEXAGON_V6_vzb
-      {Intrinsic::hexagon_V6_vzb_128B, 59350}, // __builtin_HEXAGON_V6_vzb_128B
-      {Intrinsic::hexagon_V6_vzh, 59380}, // __builtin_HEXAGON_V6_vzh
-      {Intrinsic::hexagon_V6_vzh_128B, 59405}, // __builtin_HEXAGON_V6_vzh_128B
-      {Intrinsic::hexagon_Y2_dccleana, 59435}, // __builtin_HEXAGON_Y2_dccleana
-      {Intrinsic::hexagon_Y2_dccleaninva, 59465}, // __builtin_HEXAGON_Y2_dccleaninva
-      {Intrinsic::hexagon_Y2_dcinva, 59498}, // __builtin_HEXAGON_Y2_dcinva
-      {Intrinsic::hexagon_Y2_dczeroa, 59526}, // __builtin_HEXAGON_Y2_dczeroa
-      {Intrinsic::hexagon_Y4_l2fetch, 59555}, // __builtin_HEXAGON_Y4_l2fetch
-      {Intrinsic::hexagon_Y5_l2fetch, 59584}, // __builtin_HEXAGON_Y5_l2fetch
-      {Intrinsic::hexagon_prefetch, 59826}, // __builtin_HEXAGON_prefetch
-      {Intrinsic::hexagon_S2_storerb_pbr, 29039}, // __builtin_brev_stb
-      {Intrinsic::hexagon_S2_storerd_pbr, 29058}, // __builtin_brev_std
-      {Intrinsic::hexagon_S2_storerh_pbr, 29098}, // __builtin_brev_sth
-      {Intrinsic::hexagon_S2_storerf_pbr, 29077}, // __builtin_brev_sthhi
-      {Intrinsic::hexagon_S2_storeri_pbr, 29117}, // __builtin_brev_stw
-      {Intrinsic::hexagon_circ_ldb, 59613}, // __builtin_circ_ldb
-      {Intrinsic::hexagon_circ_ldd, 59632}, // __builtin_circ_ldd
-      {Intrinsic::hexagon_circ_ldh, 59651}, // __builtin_circ_ldh
-      {Intrinsic::hexagon_circ_ldub, 59670}, // __builtin_circ_ldub
-      {Intrinsic::hexagon_circ_lduh, 59690}, // __builtin_circ_lduh
-      {Intrinsic::hexagon_circ_ldw, 59710}, // __builtin_circ_ldw
-      {Intrinsic::hexagon_circ_stb, 59729}, // __builtin_circ_stb
-      {Intrinsic::hexagon_circ_std, 59748}, // __builtin_circ_std
-      {Intrinsic::hexagon_circ_sth, 59767}, // __builtin_circ_sth
-      {Intrinsic::hexagon_circ_sthhi, 59786}, // __builtin_circ_sthhi
-      {Intrinsic::hexagon_circ_stw, 59807}, // __builtin_circ_stw
-      {Intrinsic::hexagon_vmemcpy, 59853}, // __builtin_hexagon_vmemcpy
-      {Intrinsic::hexagon_vmemset, 59879}, // __builtin_hexagon_vmemset
+      {Intrinsic::hexagon_A2_abs, 5942}, // __builtin_HEXAGON_A2_abs
+      {Intrinsic::hexagon_A2_absp, 5967}, // __builtin_HEXAGON_A2_absp
+      {Intrinsic::hexagon_A2_abssat, 5993}, // __builtin_HEXAGON_A2_abssat
+      {Intrinsic::hexagon_A2_add, 6021}, // __builtin_HEXAGON_A2_add
+      {Intrinsic::hexagon_A2_addh_h16_hh, 6046}, // __builtin_HEXAGON_A2_addh_h16_hh
+      {Intrinsic::hexagon_A2_addh_h16_hl, 6079}, // __builtin_HEXAGON_A2_addh_h16_hl
+      {Intrinsic::hexagon_A2_addh_h16_lh, 6112}, // __builtin_HEXAGON_A2_addh_h16_lh
+      {Intrinsic::hexagon_A2_addh_h16_ll, 6145}, // __builtin_HEXAGON_A2_addh_h16_ll
+      {Intrinsic::hexagon_A2_addh_h16_sat_hh, 6178}, // __builtin_HEXAGON_A2_addh_h16_sat_hh
+      {Intrinsic::hexagon_A2_addh_h16_sat_hl, 6215}, // __builtin_HEXAGON_A2_addh_h16_sat_hl
+      {Intrinsic::hexagon_A2_addh_h16_sat_lh, 6252}, // __builtin_HEXAGON_A2_addh_h16_sat_lh
+      {Intrinsic::hexagon_A2_addh_h16_sat_ll, 6289}, // __builtin_HEXAGON_A2_addh_h16_sat_ll
+      {Intrinsic::hexagon_A2_addh_l16_hl, 6326}, // __builtin_HEXAGON_A2_addh_l16_hl
+      {Intrinsic::hexagon_A2_addh_l16_ll, 6359}, // __builtin_HEXAGON_A2_addh_l16_ll
+      {Intrinsic::hexagon_A2_addh_l16_sat_hl, 6392}, // __builtin_HEXAGON_A2_addh_l16_sat_hl
+      {Intrinsic::hexagon_A2_addh_l16_sat_ll, 6429}, // __builtin_HEXAGON_A2_addh_l16_sat_ll
+      {Intrinsic::hexagon_A2_addi, 6466}, // __builtin_HEXAGON_A2_addi
+      {Intrinsic::hexagon_A2_addp, 6492}, // __builtin_HEXAGON_A2_addp
+      {Intrinsic::hexagon_A2_addpsat, 6518}, // __builtin_HEXAGON_A2_addpsat
+      {Intrinsic::hexagon_A2_addsat, 6547}, // __builtin_HEXAGON_A2_addsat
+      {Intrinsic::hexagon_A2_addsp, 6575}, // __builtin_HEXAGON_A2_addsp
+      {Intrinsic::hexagon_A2_and, 6602}, // __builtin_HEXAGON_A2_and
+      {Intrinsic::hexagon_A2_andir, 6627}, // __builtin_HEXAGON_A2_andir
+      {Intrinsic::hexagon_A2_andp, 6654}, // __builtin_HEXAGON_A2_andp
+      {Intrinsic::hexagon_A2_aslh, 6680}, // __builtin_HEXAGON_A2_aslh
+      {Intrinsic::hexagon_A2_asrh, 6706}, // __builtin_HEXAGON_A2_asrh
+      {Intrinsic::hexagon_A2_combine_hh, 6732}, // __builtin_HEXAGON_A2_combine_hh
+      {Intrinsic::hexagon_A2_combine_hl, 6764}, // __builtin_HEXAGON_A2_combine_hl
+      {Intrinsic::hexagon_A2_combine_lh, 6796}, // __builtin_HEXAGON_A2_combine_lh
+      {Intrinsic::hexagon_A2_combine_ll, 6828}, // __builtin_HEXAGON_A2_combine_ll
+      {Intrinsic::hexagon_A2_combineii, 6860}, // __builtin_HEXAGON_A2_combineii
+      {Intrinsic::hexagon_A2_combinew, 6891}, // __builtin_HEXAGON_A2_combinew
+      {Intrinsic::hexagon_A2_max, 6921}, // __builtin_HEXAGON_A2_max
+      {Intrinsic::hexagon_A2_maxp, 6946}, // __builtin_HEXAGON_A2_maxp
+      {Intrinsic::hexagon_A2_maxu, 6972}, // __builtin_HEXAGON_A2_maxu
+      {Intrinsic::hexagon_A2_maxup, 6998}, // __builtin_HEXAGON_A2_maxup
+      {Intrinsic::hexagon_A2_min, 7025}, // __builtin_HEXAGON_A2_min
+      {Intrinsic::hexagon_A2_minp, 7050}, // __builtin_HEXAGON_A2_minp
+      {Intrinsic::hexagon_A2_minu, 7076}, // __builtin_HEXAGON_A2_minu
+      {Intrinsic::hexagon_A2_minup, 7102}, // __builtin_HEXAGON_A2_minup
+      {Intrinsic::hexagon_A2_neg, 7129}, // __builtin_HEXAGON_A2_neg
+      {Intrinsic::hexagon_A2_negp, 7154}, // __builtin_HEXAGON_A2_negp
+      {Intrinsic::hexagon_A2_negsat, 7180}, // __builtin_HEXAGON_A2_negsat
+      {Intrinsic::hexagon_A2_not, 7208}, // __builtin_HEXAGON_A2_not
+      {Intrinsic::hexagon_A2_notp, 7233}, // __builtin_HEXAGON_A2_notp
+      {Intrinsic::hexagon_A2_or, 7259}, // __builtin_HEXAGON_A2_or
+      {Intrinsic::hexagon_A2_orir, 7283}, // __builtin_HEXAGON_A2_orir
+      {Intrinsic::hexagon_A2_orp, 7309}, // __builtin_HEXAGON_A2_orp
+      {Intrinsic::hexagon_A2_roundsat, 7334}, // __builtin_HEXAGON_A2_roundsat
+      {Intrinsic::hexagon_A2_sat, 7364}, // __builtin_HEXAGON_A2_sat
+      {Intrinsic::hexagon_A2_satb, 7389}, // __builtin_HEXAGON_A2_satb
+      {Intrinsic::hexagon_A2_sath, 7415}, // __builtin_HEXAGON_A2_sath
+      {Intrinsic::hexagon_A2_satub, 7441}, // __builtin_HEXAGON_A2_satub
+      {Intrinsic::hexagon_A2_satuh, 7468}, // __builtin_HEXAGON_A2_satuh
+      {Intrinsic::hexagon_A2_sub, 7495}, // __builtin_HEXAGON_A2_sub
+      {Intrinsic::hexagon_A2_subh_h16_hh, 7520}, // __builtin_HEXAGON_A2_subh_h16_hh
+      {Intrinsic::hexagon_A2_subh_h16_hl, 7553}, // __builtin_HEXAGON_A2_subh_h16_hl
+      {Intrinsic::hexagon_A2_subh_h16_lh, 7586}, // __builtin_HEXAGON_A2_subh_h16_lh
+      {Intrinsic::hexagon_A2_subh_h16_ll, 7619}, // __builtin_HEXAGON_A2_subh_h16_ll
+      {Intrinsic::hexagon_A2_subh_h16_sat_hh, 7652}, // __builtin_HEXAGON_A2_subh_h16_sat_hh
+      {Intrinsic::hexagon_A2_subh_h16_sat_hl, 7689}, // __builtin_HEXAGON_A2_subh_h16_sat_hl
+      {Intrinsic::hexagon_A2_subh_h16_sat_lh, 7726}, // __builtin_HEXAGON_A2_subh_h16_sat_lh
+      {Intrinsic::hexagon_A2_subh_h16_sat_ll, 7763}, // __builtin_HEXAGON_A2_subh_h16_sat_ll
+      {Intrinsic::hexagon_A2_subh_l16_hl, 7800}, // __builtin_HEXAGON_A2_subh_l16_hl
+      {Intrinsic::hexagon_A2_subh_l16_ll, 7833}, // __builtin_HEXAGON_A2_subh_l16_ll
+      {Intrinsic::hexagon_A2_subh_l16_sat_hl, 7866}, // __builtin_HEXAGON_A2_subh_l16_sat_hl
+      {Intrinsic::hexagon_A2_subh_l16_sat_ll, 7903}, // __builtin_HEXAGON_A2_subh_l16_sat_ll
+      {Intrinsic::hexagon_A2_subp, 7940}, // __builtin_HEXAGON_A2_subp
+      {Intrinsic::hexagon_A2_subri, 7966}, // __builtin_HEXAGON_A2_subri
+      {Intrinsic::hexagon_A2_subsat, 7993}, // __builtin_HEXAGON_A2_subsat
+      {Intrinsic::hexagon_A2_svaddh, 8021}, // __builtin_HEXAGON_A2_svaddh
+      {Intrinsic::hexagon_A2_svaddhs, 8049}, // __builtin_HEXAGON_A2_svaddhs
+      {Intrinsic::hexagon_A2_svadduhs, 8078}, // __builtin_HEXAGON_A2_svadduhs
+      {Intrinsic::hexagon_A2_svavgh, 8108}, // __builtin_HEXAGON_A2_svavgh
+      {Intrinsic::hexagon_A2_svavghs, 8136}, // __builtin_HEXAGON_A2_svavghs
+      {Intrinsic::hexagon_A2_svnavgh, 8165}, // __builtin_HEXAGON_A2_svnavgh
+      {Intrinsic::hexagon_A2_svsubh, 8194}, // __builtin_HEXAGON_A2_svsubh
+      {Intrinsic::hexagon_A2_svsubhs, 8222}, // __builtin_HEXAGON_A2_svsubhs
+      {Intrinsic::hexagon_A2_svsubuhs, 8251}, // __builtin_HEXAGON_A2_svsubuhs
+      {Intrinsic::hexagon_A2_swiz, 8281}, // __builtin_HEXAGON_A2_swiz
+      {Intrinsic::hexagon_A2_sxtb, 8307}, // __builtin_HEXAGON_A2_sxtb
+      {Intrinsic::hexagon_A2_sxth, 8333}, // __builtin_HEXAGON_A2_sxth
+      {Intrinsic::hexagon_A2_sxtw, 8359}, // __builtin_HEXAGON_A2_sxtw
+      {Intrinsic::hexagon_A2_tfr, 8385}, // __builtin_HEXAGON_A2_tfr
+      {Intrinsic::hexagon_A2_tfrih, 8410}, // __builtin_HEXAGON_A2_tfrih
+      {Intrinsic::hexagon_A2_tfril, 8437}, // __builtin_HEXAGON_A2_tfril
+      {Intrinsic::hexagon_A2_tfrp, 8464}, // __builtin_HEXAGON_A2_tfrp
+      {Intrinsic::hexagon_A2_tfrpi, 8490}, // __builtin_HEXAGON_A2_tfrpi
+      {Intrinsic::hexagon_A2_tfrsi, 8517}, // __builtin_HEXAGON_A2_tfrsi
+      {Intrinsic::hexagon_A2_vabsh, 8544}, // __builtin_HEXAGON_A2_vabsh
+      {Intrinsic::hexagon_A2_vabshsat, 8571}, // __builtin_HEXAGON_A2_vabshsat
+      {Intrinsic::hexagon_A2_vabsw, 8601}, // __builtin_HEXAGON_A2_vabsw
+      {Intrinsic::hexagon_A2_vabswsat, 8628}, // __builtin_HEXAGON_A2_vabswsat
+      {Intrinsic::hexagon_A2_vaddb_map, 8658}, // __builtin_HEXAGON_A2_vaddb_map
+      {Intrinsic::hexagon_A2_vaddh, 8689}, // __builtin_HEXAGON_A2_vaddh
+      {Intrinsic::hexagon_A2_vaddhs, 8716}, // __builtin_HEXAGON_A2_vaddhs
+      {Intrinsic::hexagon_A2_vaddub, 8744}, // __builtin_HEXAGON_A2_vaddub
+      {Intrinsic::hexagon_A2_vaddubs, 8772}, // __builtin_HEXAGON_A2_vaddubs
+      {Intrinsic::hexagon_A2_vadduhs, 8801}, // __builtin_HEXAGON_A2_vadduhs
+      {Intrinsic::hexagon_A2_vaddw, 8830}, // __builtin_HEXAGON_A2_vaddw
+      {Intrinsic::hexagon_A2_vaddws, 8857}, // __builtin_HEXAGON_A2_vaddws
+      {Intrinsic::hexagon_A2_vavgh, 8885}, // __builtin_HEXAGON_A2_vavgh
+      {Intrinsic::hexagon_A2_vavghcr, 8912}, // __builtin_HEXAGON_A2_vavghcr
+      {Intrinsic::hexagon_A2_vavghr, 8941}, // __builtin_HEXAGON_A2_vavghr
+      {Intrinsic::hexagon_A2_vavgub, 8969}, // __builtin_HEXAGON_A2_vavgub
+      {Intrinsic::hexagon_A2_vavgubr, 8997}, // __builtin_HEXAGON_A2_vavgubr
+      {Intrinsic::hexagon_A2_vavguh, 9026}, // __builtin_HEXAGON_A2_vavguh
+      {Intrinsic::hexagon_A2_vavguhr, 9054}, // __builtin_HEXAGON_A2_vavguhr
+      {Intrinsic::hexagon_A2_vavguw, 9083}, // __builtin_HEXAGON_A2_vavguw
+      {Intrinsic::hexagon_A2_vavguwr, 9111}, // __builtin_HEXAGON_A2_vavguwr
+      {Intrinsic::hexagon_A2_vavgw, 9140}, // __builtin_HEXAGON_A2_vavgw
+      {Intrinsic::hexagon_A2_vavgwcr, 9167}, // __builtin_HEXAGON_A2_vavgwcr
+      {Intrinsic::hexagon_A2_vavgwr, 9196}, // __builtin_HEXAGON_A2_vavgwr
+      {Intrinsic::hexagon_A2_vcmpbeq, 9224}, // __builtin_HEXAGON_A2_vcmpbeq
+      {Intrinsic::hexagon_A2_vcmpbgtu, 9253}, // __builtin_HEXAGON_A2_vcmpbgtu
+      {Intrinsic::hexagon_A2_vcmpheq, 9283}, // __builtin_HEXAGON_A2_vcmpheq
+      {Intrinsic::hexagon_A2_vcmphgt, 9312}, // __builtin_HEXAGON_A2_vcmphgt
+      {Intrinsic::hexagon_A2_vcmphgtu, 9341}, // __builtin_HEXAGON_A2_vcmphgtu
+      {Intrinsic::hexagon_A2_vcmpweq, 9371}, // __builtin_HEXAGON_A2_vcmpweq
+      {Intrinsic::hexagon_A2_vcmpwgt, 9400}, // __builtin_HEXAGON_A2_vcmpwgt
+      {Intrinsic::hexagon_A2_vcmpwgtu, 9429}, // __builtin_HEXAGON_A2_vcmpwgtu
+      {Intrinsic::hexagon_A2_vconj, 9459}, // __builtin_HEXAGON_A2_vconj
+      {Intrinsic::hexagon_A2_vmaxb, 9486}, // __builtin_HEXAGON_A2_vmaxb
+      {Intrinsic::hexagon_A2_vmaxh, 9513}, // __builtin_HEXAGON_A2_vmaxh
+      {Intrinsic::hexagon_A2_vmaxub, 9540}, // __builtin_HEXAGON_A2_vmaxub
+      {Intrinsic::hexagon_A2_vmaxuh, 9568}, // __builtin_HEXAGON_A2_vmaxuh
+      {Intrinsic::hexagon_A2_vmaxuw, 9596}, // __builtin_HEXAGON_A2_vmaxuw
+      {Intrinsic::hexagon_A2_vmaxw, 9624}, // __builtin_HEXAGON_A2_vmaxw
+      {Intrinsic::hexagon_A2_vminb, 9651}, // __builtin_HEXAGON_A2_vminb
+      {Intrinsic::hexagon_A2_vminh, 9678}, // __builtin_HEXAGON_A2_vminh
+      {Intrinsic::hexagon_A2_vminub, 9705}, // __builtin_HEXAGON_A2_vminub
+      {Intrinsic::hexagon_A2_vminuh, 9733}, // __builtin_HEXAGON_A2_vminuh
+      {Intrinsic::hexagon_A2_vminuw, 9761}, // __builtin_HEXAGON_A2_vminuw
+      {Intrinsic::hexagon_A2_vminw, 9789}, // __builtin_HEXAGON_A2_vminw
+      {Intrinsic::hexagon_A2_vnavgh, 9816}, // __builtin_HEXAGON_A2_vnavgh
+      {Intrinsic::hexagon_A2_vnavghcr, 9844}, // __builtin_HEXAGON_A2_vnavghcr
+      {Intrinsic::hexagon_A2_vnavghr, 9874}, // __builtin_HEXAGON_A2_vnavghr
+      {Intrinsic::hexagon_A2_vnavgw, 9903}, // __builtin_HEXAGON_A2_vnavgw
+      {Intrinsic::hexagon_A2_vnavgwcr, 9931}, // __builtin_HEXAGON_A2_vnavgwcr
+      {Intrinsic::hexagon_A2_vnavgwr, 9961}, // __builtin_HEXAGON_A2_vnavgwr
+      {Intrinsic::hexagon_A2_vraddub, 9990}, // __builtin_HEXAGON_A2_vraddub
+      {Intrinsic::hexagon_A2_vraddub_acc, 10019}, // __builtin_HEXAGON_A2_vraddub_acc
+      {Intrinsic::hexagon_A2_vrsadub, 10052}, // __builtin_HEXAGON_A2_vrsadub
+      {Intrinsic::hexagon_A2_vrsadub_acc, 10081}, // __builtin_HEXAGON_A2_vrsadub_acc
+      {Intrinsic::hexagon_A2_vsubb_map, 10114}, // __builtin_HEXAGON_A2_vsubb_map
+      {Intrinsic::hexagon_A2_vsubh, 10145}, // __builtin_HEXAGON_A2_vsubh
+      {Intrinsic::hexagon_A2_vsubhs, 10172}, // __builtin_HEXAGON_A2_vsubhs
+      {Intrinsic::hexagon_A2_vsubub, 10200}, // __builtin_HEXAGON_A2_vsubub
+      {Intrinsic::hexagon_A2_vsububs, 10228}, // __builtin_HEXAGON_A2_vsububs
+      {Intrinsic::hexagon_A2_vsubuhs, 10257}, // __builtin_HEXAGON_A2_vsubuhs
+      {Intrinsic::hexagon_A2_vsubw, 10286}, // __builtin_HEXAGON_A2_vsubw
+      {Intrinsic::hexagon_A2_vsubws, 10313}, // __builtin_HEXAGON_A2_vsubws
+      {Intrinsic::hexagon_A2_xor, 10341}, // __builtin_HEXAGON_A2_xor
+      {Intrinsic::hexagon_A2_xorp, 10366}, // __builtin_HEXAGON_A2_xorp
+      {Intrinsic::hexagon_A2_zxtb, 10392}, // __builtin_HEXAGON_A2_zxtb
+      {Intrinsic::hexagon_A2_zxth, 10418}, // __builtin_HEXAGON_A2_zxth
+      {Intrinsic::hexagon_A4_andn, 10444}, // __builtin_HEXAGON_A4_andn
+      {Intrinsic::hexagon_A4_andnp, 10470}, // __builtin_HEXAGON_A4_andnp
+      {Intrinsic::hexagon_A4_bitsplit, 10497}, // __builtin_HEXAGON_A4_bitsplit
+      {Intrinsic::hexagon_A4_bitspliti, 10527}, // __builtin_HEXAGON_A4_bitspliti
+      {Intrinsic::hexagon_A4_boundscheck, 10558}, // __builtin_HEXAGON_A4_boundscheck
+      {Intrinsic::hexagon_A4_cmpbeq, 10591}, // __builtin_HEXAGON_A4_cmpbeq
+      {Intrinsic::hexagon_A4_cmpbeqi, 10619}, // __builtin_HEXAGON_A4_cmpbeqi
+      {Intrinsic::hexagon_A4_cmpbgt, 10648}, // __builtin_HEXAGON_A4_cmpbgt
+      {Intrinsic::hexagon_A4_cmpbgti, 10676}, // __builtin_HEXAGON_A4_cmpbgti
+      {Intrinsic::hexagon_A4_cmpbgtu, 10705}, // __builtin_HEXAGON_A4_cmpbgtu
+      {Intrinsic::hexagon_A4_cmpbgtui, 10734}, // __builtin_HEXAGON_A4_cmpbgtui
+      {Intrinsic::hexagon_A4_cmpheq, 10764}, // __builtin_HEXAGON_A4_cmpheq
+      {Intrinsic::hexagon_A4_cmpheqi, 10792}, // __builtin_HEXAGON_A4_cmpheqi
+      {Intrinsic::hexagon_A4_cmphgt, 10821}, // __builtin_HEXAGON_A4_cmphgt
+      {Intrinsic::hexagon_A4_cmphgti, 10849}, // __builtin_HEXAGON_A4_cmphgti
+      {Intrinsic::hexagon_A4_cmphgtu, 10878}, // __builtin_HEXAGON_A4_cmphgtu
+      {Intrinsic::hexagon_A4_cmphgtui, 10907}, // __builtin_HEXAGON_A4_cmphgtui
+      {Intrinsic::hexagon_A4_combineir, 10937}, // __builtin_HEXAGON_A4_combineir
+      {Intrinsic::hexagon_A4_combineri, 10968}, // __builtin_HEXAGON_A4_combineri
+      {Intrinsic::hexagon_A4_cround_ri, 10999}, // __builtin_HEXAGON_A4_cround_ri
+      {Intrinsic::hexagon_A4_cround_rr, 11030}, // __builtin_HEXAGON_A4_cround_rr
+      {Intrinsic::hexagon_A4_modwrapu, 11061}, // __builtin_HEXAGON_A4_modwrapu
+      {Intrinsic::hexagon_A4_orn, 11091}, // __builtin_HEXAGON_A4_orn
+      {Intrinsic::hexagon_A4_ornp, 11116}, // __builtin_HEXAGON_A4_ornp
+      {Intrinsic::hexagon_A4_rcmpeq, 11142}, // __builtin_HEXAGON_A4_rcmpeq
+      {Intrinsic::hexagon_A4_rcmpeqi, 11170}, // __builtin_HEXAGON_A4_rcmpeqi
+      {Intrinsic::hexagon_A4_rcmpneq, 11199}, // __builtin_HEXAGON_A4_rcmpneq
+      {Intrinsic::hexagon_A4_rcmpneqi, 11228}, // __builtin_HEXAGON_A4_rcmpneqi
+      {Intrinsic::hexagon_A4_round_ri, 11258}, // __builtin_HEXAGON_A4_round_ri
+      {Intrinsic::hexagon_A4_round_ri_sat, 11288}, // __builtin_HEXAGON_A4_round_ri_sat
+      {Intrinsic::hexagon_A4_round_rr, 11322}, // __builtin_HEXAGON_A4_round_rr
+      {Intrinsic::hexagon_A4_round_rr_sat, 11352}, // __builtin_HEXAGON_A4_round_rr_sat
+      {Intrinsic::hexagon_A4_tlbmatch, 11386}, // __builtin_HEXAGON_A4_tlbmatch
+      {Intrinsic::hexagon_A4_vcmpbeq_any, 11416}, // __builtin_HEXAGON_A4_vcmpbeq_any
+      {Intrinsic::hexagon_A4_vcmpbeqi, 11449}, // __builtin_HEXAGON_A4_vcmpbeqi
+      {Intrinsic::hexagon_A4_vcmpbgt, 11479}, // __builtin_HEXAGON_A4_vcmpbgt
+      {Intrinsic::hexagon_A4_vcmpbgti, 11508}, // __builtin_HEXAGON_A4_vcmpbgti
+      {Intrinsic::hexagon_A4_vcmpbgtui, 11538}, // __builtin_HEXAGON_A4_vcmpbgtui
+      {Intrinsic::hexagon_A4_vcmpheqi, 11569}, // __builtin_HEXAGON_A4_vcmpheqi
+      {Intrinsic::hexagon_A4_vcmphgti, 11599}, // __builtin_HEXAGON_A4_vcmphgti
+      {Intrinsic::hexagon_A4_vcmphgtui, 11629}, // __builtin_HEXAGON_A4_vcmphgtui
+      {Intrinsic::hexagon_A4_vcmpweqi, 11660}, // __builtin_HEXAGON_A4_vcmpweqi
+      {Intrinsic::hexagon_A4_vcmpwgti, 11690}, // __builtin_HEXAGON_A4_vcmpwgti
+      {Intrinsic::hexagon_A4_vcmpwgtui, 11720}, // __builtin_HEXAGON_A4_vcmpwgtui
+      {Intrinsic::hexagon_A4_vrmaxh, 11751}, // __builtin_HEXAGON_A4_vrmaxh
+      {Intrinsic::hexagon_A4_vrmaxuh, 11779}, // __builtin_HEXAGON_A4_vrmaxuh
+      {Intrinsic::hexagon_A4_vrmaxuw, 11808}, // __builtin_HEXAGON_A4_vrmaxuw
+      {Intrinsic::hexagon_A4_vrmaxw, 11837}, // __builtin_HEXAGON_A4_vrmaxw
+      {Intrinsic::hexagon_A4_vrminh, 11865}, // __builtin_HEXAGON_A4_vrminh
+      {Intrinsic::hexagon_A4_vrminuh, 11893}, // __builtin_HEXAGON_A4_vrminuh
+      {Intrinsic::hexagon_A4_vrminuw, 11922}, // __builtin_HEXAGON_A4_vrminuw
+      {Intrinsic::hexagon_A4_vrminw, 11951}, // __builtin_HEXAGON_A4_vrminw
+      {Intrinsic::hexagon_A5_vaddhubs, 11979}, // __builtin_HEXAGON_A5_vaddhubs
+      {Intrinsic::hexagon_A6_vcmpbeq_notany, 12009}, // __builtin_HEXAGON_A6_vcmpbeq_notany
+      {Intrinsic::hexagon_A7_clip, 12045}, // __builtin_HEXAGON_A7_clip
+      {Intrinsic::hexagon_A7_croundd_ri, 12071}, // __builtin_HEXAGON_A7_croundd_ri
+      {Intrinsic::hexagon_A7_croundd_rr, 12103}, // __builtin_HEXAGON_A7_croundd_rr
+      {Intrinsic::hexagon_A7_vclip, 12135}, // __builtin_HEXAGON_A7_vclip
+      {Intrinsic::hexagon_C2_all8, 12162}, // __builtin_HEXAGON_C2_all8
+      {Intrinsic::hexagon_C2_and, 12188}, // __builtin_HEXAGON_C2_and
+      {Intrinsic::hexagon_C2_andn, 12213}, // __builtin_HEXAGON_C2_andn
+      {Intrinsic::hexagon_C2_any8, 12239}, // __builtin_HEXAGON_C2_any8
+      {Intrinsic::hexagon_C2_bitsclr, 12265}, // __builtin_HEXAGON_C2_bitsclr
+      {Intrinsic::hexagon_C2_bitsclri, 12294}, // __builtin_HEXAGON_C2_bitsclri
+      {Intrinsic::hexagon_C2_bitsset, 12324}, // __builtin_HEXAGON_C2_bitsset
+      {Intrinsic::hexagon_C2_cmpeq, 12353}, // __builtin_HEXAGON_C2_cmpeq
+      {Intrinsic::hexagon_C2_cmpeqi, 12380}, // __builtin_HEXAGON_C2_cmpeqi
+      {Intrinsic::hexagon_C2_cmpeqp, 12408}, // __builtin_HEXAGON_C2_cmpeqp
+      {Intrinsic::hexagon_C2_cmpgei, 12436}, // __builtin_HEXAGON_C2_cmpgei
+      {Intrinsic::hexagon_C2_cmpgeui, 12464}, // __builtin_HEXAGON_C2_cmpgeui
+      {Intrinsic::hexagon_C2_cmpgt, 12493}, // __builtin_HEXAGON_C2_cmpgt
+      {Intrinsic::hexagon_C2_cmpgti, 12520}, // __builtin_HEXAGON_C2_cmpgti
+      {Intrinsic::hexagon_C2_cmpgtp, 12548}, // __builtin_HEXAGON_C2_cmpgtp
+      {Intrinsic::hexagon_C2_cmpgtu, 12576}, // __builtin_HEXAGON_C2_cmpgtu
+      {Intrinsic::hexagon_C2_cmpgtui, 12604}, // __builtin_HEXAGON_C2_cmpgtui
+      {Intrinsic::hexagon_C2_cmpgtup, 12633}, // __builtin_HEXAGON_C2_cmpgtup
+      {Intrinsic::hexagon_C2_cmplt, 12662}, // __builtin_HEXAGON_C2_cmplt
+      {Intrinsic::hexagon_C2_cmpltu, 12689}, // __builtin_HEXAGON_C2_cmpltu
+      {Intrinsic::hexagon_C2_mask, 12717}, // __builtin_HEXAGON_C2_mask
+      {Intrinsic::hexagon_C2_mux, 12743}, // __builtin_HEXAGON_C2_mux
+      {Intrinsic::hexagon_C2_muxii, 12768}, // __builtin_HEXAGON_C2_muxii
+      {Intrinsic::hexagon_C2_muxir, 12795}, // __builtin_HEXAGON_C2_muxir
+      {Intrinsic::hexagon_C2_muxri, 12822}, // __builtin_HEXAGON_C2_muxri
+      {Intrinsic::hexagon_C2_not, 12849}, // __builtin_HEXAGON_C2_not
+      {Intrinsic::hexagon_C2_or, 12874}, // __builtin_HEXAGON_C2_or
+      {Intrinsic::hexagon_C2_orn, 12898}, // __builtin_HEXAGON_C2_orn
+      {Intrinsic::hexagon_C2_pxfer_map, 12923}, // __builtin_HEXAGON_C2_pxfer_map
+      {Intrinsic::hexagon_C2_tfrpr, 12954}, // __builtin_HEXAGON_C2_tfrpr
+      {Intrinsic::hexagon_C2_tfrrp, 12981}, // __builtin_HEXAGON_C2_tfrrp
+      {Intrinsic::hexagon_C2_vitpack, 13008}, // __builtin_HEXAGON_C2_vitpack
+      {Intrinsic::hexagon_C2_vmux, 13037}, // __builtin_HEXAGON_C2_vmux
+      {Intrinsic::hexagon_C2_xor, 13063}, // __builtin_HEXAGON_C2_xor
+      {Intrinsic::hexagon_C4_and_and, 13088}, // __builtin_HEXAGON_C4_and_and
+      {Intrinsic::hexagon_C4_and_andn, 13117}, // __builtin_HEXAGON_C4_and_andn
+      {Intrinsic::hexagon_C4_and_or, 13147}, // __builtin_HEXAGON_C4_and_or
+      {Intrinsic::hexagon_C4_and_orn, 13175}, // __builtin_HEXAGON_C4_and_orn
+      {Intrinsic::hexagon_C4_cmplte, 13204}, // __builtin_HEXAGON_C4_cmplte
+      {Intrinsic::hexagon_C4_cmpltei, 13232}, // __builtin_HEXAGON_C4_cmpltei
+      {Intrinsic::hexagon_C4_cmplteu, 13261}, // __builtin_HEXAGON_C4_cmplteu
+      {Intrinsic::hexagon_C4_cmplteui, 13290}, // __builtin_HEXAGON_C4_cmplteui
+      {Intrinsic::hexagon_C4_cmpneq, 13320}, // __builtin_HEXAGON_C4_cmpneq
+      {Intrinsic::hexagon_C4_cmpneqi, 13348}, // __builtin_HEXAGON_C4_cmpneqi
+      {Intrinsic::hexagon_C4_fastcorner9, 13377}, // __builtin_HEXAGON_C4_fastcorner9
+      {Intrinsic::hexagon_C4_fastcorner9_not, 13410}, // __builtin_HEXAGON_C4_fastcorner9_not
+      {Intrinsic::hexagon_C4_nbitsclr, 13447}, // __builtin_HEXAGON_C4_nbitsclr
+      {Intrinsic::hexagon_C4_nbitsclri, 13477}, // __builtin_HEXAGON_C4_nbitsclri
+      {Intrinsic::hexagon_C4_nbitsset, 13508}, // __builtin_HEXAGON_C4_nbitsset
+      {Intrinsic::hexagon_C4_or_and, 13538}, // __builtin_HEXAGON_C4_or_and
+      {Intrinsic::hexagon_C4_or_andn, 13566}, // __builtin_HEXAGON_C4_or_andn
+      {Intrinsic::hexagon_C4_or_or, 13595}, // __builtin_HEXAGON_C4_or_or
+      {Intrinsic::hexagon_C4_or_orn, 13622}, // __builtin_HEXAGON_C4_or_orn
+      {Intrinsic::hexagon_F2_conv_d2df, 13650}, // __builtin_HEXAGON_F2_conv_d2df
+      {Intrinsic::hexagon_F2_conv_d2sf, 13681}, // __builtin_HEXAGON_F2_conv_d2sf
+      {Intrinsic::hexagon_F2_conv_df2d, 13712}, // __builtin_HEXAGON_F2_conv_df2d
+      {Intrinsic::hexagon_F2_conv_df2d_chop, 13743}, // __builtin_HEXAGON_F2_conv_df2d_chop
+      {Intrinsic::hexagon_F2_conv_df2sf, 13779}, // __builtin_HEXAGON_F2_conv_df2sf
+      {Intrinsic::hexagon_F2_conv_df2ud, 13811}, // __builtin_HEXAGON_F2_conv_df2ud
+      {Intrinsic::hexagon_F2_conv_df2ud_chop, 13843}, // __builtin_HEXAGON_F2_conv_df2ud_chop
+      {Intrinsic::hexagon_F2_conv_df2uw, 13880}, // __builtin_HEXAGON_F2_conv_df2uw
+      {Intrinsic::hexagon_F2_conv_df2uw_chop, 13912}, // __builtin_HEXAGON_F2_conv_df2uw_chop
+      {Intrinsic::hexagon_F2_conv_df2w, 13949}, // __builtin_HEXAGON_F2_conv_df2w
+      {Intrinsic::hexagon_F2_conv_df2w_chop, 13980}, // __builtin_HEXAGON_F2_conv_df2w_chop
+      {Intrinsic::hexagon_F2_conv_sf2d, 14016}, // __builtin_HEXAGON_F2_conv_sf2d
+      {Intrinsic::hexagon_F2_conv_sf2d_chop, 14047}, // __builtin_HEXAGON_F2_conv_sf2d_chop
+      {Intrinsic::hexagon_F2_conv_sf2df, 14083}, // __builtin_HEXAGON_F2_conv_sf2df
+      {Intrinsic::hexagon_F2_conv_sf2ud, 14115}, // __builtin_HEXAGON_F2_conv_sf2ud
+      {Intrinsic::hexagon_F2_conv_sf2ud_chop, 14147}, // __builtin_HEXAGON_F2_conv_sf2ud_chop
+      {Intrinsic::hexagon_F2_conv_sf2uw, 14184}, // __builtin_HEXAGON_F2_conv_sf2uw
+      {Intrinsic::hexagon_F2_conv_sf2uw_chop, 14216}, // __builtin_HEXAGON_F2_conv_sf2uw_chop
+      {Intrinsic::hexagon_F2_conv_sf2w, 14253}, // __builtin_HEXAGON_F2_conv_sf2w
+      {Intrinsic::hexagon_F2_conv_sf2w_chop, 14284}, // __builtin_HEXAGON_F2_conv_sf2w_chop
+      {Intrinsic::hexagon_F2_conv_ud2df, 14320}, // __builtin_HEXAGON_F2_conv_ud2df
+      {Intrinsic::hexagon_F2_conv_ud2sf, 14352}, // __builtin_HEXAGON_F2_conv_ud2sf
+      {Intrinsic::hexagon_F2_conv_uw2df, 14384}, // __builtin_HEXAGON_F2_conv_uw2df
+      {Intrinsic::hexagon_F2_conv_uw2sf, 14416}, // __builtin_HEXAGON_F2_conv_uw2sf
+      {Intrinsic::hexagon_F2_conv_w2df, 14448}, // __builtin_HEXAGON_F2_conv_w2df
+      {Intrinsic::hexagon_F2_conv_w2sf, 14479}, // __builtin_HEXAGON_F2_conv_w2sf
+      {Intrinsic::hexagon_F2_dfadd, 14510}, // __builtin_HEXAGON_F2_dfadd
+      {Intrinsic::hexagon_F2_dfclass, 14537}, // __builtin_HEXAGON_F2_dfclass
+      {Intrinsic::hexagon_F2_dfcmpeq, 14566}, // __builtin_HEXAGON_F2_dfcmpeq
+      {Intrinsic::hexagon_F2_dfcmpge, 14595}, // __builtin_HEXAGON_F2_dfcmpge
+      {Intrinsic::hexagon_F2_dfcmpgt, 14624}, // __builtin_HEXAGON_F2_dfcmpgt
+      {Intrinsic::hexagon_F2_dfcmpuo, 14653}, // __builtin_HEXAGON_F2_dfcmpuo
+      {Intrinsic::hexagon_F2_dfimm_n, 14682}, // __builtin_HEXAGON_F2_dfimm_n
+      {Intrinsic::hexagon_F2_dfimm_p, 14711}, // __builtin_HEXAGON_F2_dfimm_p
+      {Intrinsic::hexagon_F2_dfmax, 14740}, // __builtin_HEXAGON_F2_dfmax
+      {Intrinsic::hexagon_F2_dfmin, 14767}, // __builtin_HEXAGON_F2_dfmin
+      {Intrinsic::hexagon_F2_dfmpyfix, 14794}, // __builtin_HEXAGON_F2_dfmpyfix
+      {Intrinsic::hexagon_F2_dfmpyhh, 14824}, // __builtin_HEXAGON_F2_dfmpyhh
+      {Intrinsic::hexagon_F2_dfmpylh, 14853}, // __builtin_HEXAGON_F2_dfmpylh
+      {Intrinsic::hexagon_F2_dfmpyll, 14882}, // __builtin_HEXAGON_F2_dfmpyll
+      {Intrinsic::hexagon_F2_dfsub, 14911}, // __builtin_HEXAGON_F2_dfsub
+      {Intrinsic::hexagon_F2_sfadd, 14938}, // __builtin_HEXAGON_F2_sfadd
+      {Intrinsic::hexagon_F2_sfclass, 14965}, // __builtin_HEXAGON_F2_sfclass
+      {Intrinsic::hexagon_F2_sfcmpeq, 14994}, // __builtin_HEXAGON_F2_sfcmpeq
+      {Intrinsic::hexagon_F2_sfcmpge, 15023}, // __builtin_HEXAGON_F2_sfcmpge
+      {Intrinsic::hexagon_F2_sfcmpgt, 15052}, // __builtin_HEXAGON_F2_sfcmpgt
+      {Intrinsic::hexagon_F2_sfcmpuo, 15081}, // __builtin_HEXAGON_F2_sfcmpuo
+      {Intrinsic::hexagon_F2_sffixupd, 15110}, // __builtin_HEXAGON_F2_sffixupd
+      {Intrinsic::hexagon_F2_sffixupn, 15140}, // __builtin_HEXAGON_F2_sffixupn
+      {Intrinsic::hexagon_F2_sffixupr, 15170}, // __builtin_HEXAGON_F2_sffixupr
+      {Intrinsic::hexagon_F2_sffma, 15200}, // __builtin_HEXAGON_F2_sffma
+      {Intrinsic::hexagon_F2_sffma_lib, 15227}, // __builtin_HEXAGON_F2_sffma_lib
+      {Intrinsic::hexagon_F2_sffma_sc, 15258}, // __builtin_HEXAGON_F2_sffma_sc
+      {Intrinsic::hexagon_F2_sffms, 15288}, // __builtin_HEXAGON_F2_sffms
+      {Intrinsic::hexagon_F2_sffms_lib, 15315}, // __builtin_HEXAGON_F2_sffms_lib
+      {Intrinsic::hexagon_F2_sfimm_n, 15346}, // __builtin_HEXAGON_F2_sfimm_n
+      {Intrinsic::hexagon_F2_sfimm_p, 15375}, // __builtin_HEXAGON_F2_sfimm_p
+      {Intrinsic::hexagon_F2_sfmax, 15404}, // __builtin_HEXAGON_F2_sfmax
+      {Intrinsic::hexagon_F2_sfmin, 15431}, // __builtin_HEXAGON_F2_sfmin
+      {Intrinsic::hexagon_F2_sfmpy, 15458}, // __builtin_HEXAGON_F2_sfmpy
+      {Intrinsic::hexagon_F2_sfsub, 15485}, // __builtin_HEXAGON_F2_sfsub
+      {Intrinsic::hexagon_L2_loadw_locked, 15512}, // __builtin_HEXAGON_L2_loadw_locked
+      {Intrinsic::hexagon_L4_loadd_locked, 15546}, // __builtin_HEXAGON_L4_loadd_locked
+      {Intrinsic::hexagon_M2_acci, 15580}, // __builtin_HEXAGON_M2_acci
+      {Intrinsic::hexagon_M2_accii, 15606}, // __builtin_HEXAGON_M2_accii
+      {Intrinsic::hexagon_M2_cmaci_s0, 15633}, // __builtin_HEXAGON_M2_cmaci_s0
+      {Intrinsic::hexagon_M2_cmacr_s0, 15663}, // __builtin_HEXAGON_M2_cmacr_s0
+      {Intrinsic::hexagon_M2_cmacs_s0, 15693}, // __builtin_HEXAGON_M2_cmacs_s0
+      {Intrinsic::hexagon_M2_cmacs_s1, 15723}, // __builtin_HEXAGON_M2_cmacs_s1
+      {Intrinsic::hexagon_M2_cmacsc_s0, 15753}, // __builtin_HEXAGON_M2_cmacsc_s0
+      {Intrinsic::hexagon_M2_cmacsc_s1, 15784}, // __builtin_HEXAGON_M2_cmacsc_s1
+      {Intrinsic::hexagon_M2_cmpyi_s0, 15815}, // __builtin_HEXAGON_M2_cmpyi_s0
+      {Intrinsic::hexagon_M2_cmpyr_s0, 15845}, // __builtin_HEXAGON_M2_cmpyr_s0
+      {Intrinsic::hexagon_M2_cmpyrs_s0, 15875}, // __builtin_HEXAGON_M2_cmpyrs_s0
+      {Intrinsic::hexagon_M2_cmpyrs_s1, 15906}, // __builtin_HEXAGON_M2_cmpyrs_s1
+      {Intrinsic::hexagon_M2_cmpyrsc_s0, 15937}, // __builtin_HEXAGON_M2_cmpyrsc_s0
+      {Intrinsic::hexagon_M2_cmpyrsc_s1, 15969}, // __builtin_HEXAGON_M2_cmpyrsc_s1
+      {Intrinsic::hexagon_M2_cmpys_s0, 16001}, // __builtin_HEXAGON_M2_cmpys_s0
+      {Intrinsic::hexagon_M2_cmpys_s1, 16031}, // __builtin_HEXAGON_M2_cmpys_s1
+      {Intrinsic::hexagon_M2_cmpysc_s0, 16061}, // __builtin_HEXAGON_M2_cmpysc_s0
+      {Intrinsic::hexagon_M2_cmpysc_s1, 16092}, // __builtin_HEXAGON_M2_cmpysc_s1
+      {Intrinsic::hexagon_M2_cnacs_s0, 16123}, // __builtin_HEXAGON_M2_cnacs_s0
+      {Intrinsic::hexagon_M2_cnacs_s1, 16153}, // __builtin_HEXAGON_M2_cnacs_s1
+      {Intrinsic::hexagon_M2_cnacsc_s0, 16183}, // __builtin_HEXAGON_M2_cnacsc_s0
+      {Intrinsic::hexagon_M2_cnacsc_s1, 16214}, // __builtin_HEXAGON_M2_cnacsc_s1
+      {Intrinsic::hexagon_M2_dpmpyss_acc_s0, 16245}, // __builtin_HEXAGON_M2_dpmpyss_acc_s0
+      {Intrinsic::hexagon_M2_dpmpyss_nac_s0, 16281}, // __builtin_HEXAGON_M2_dpmpyss_nac_s0
+      {Intrinsic::hexagon_M2_dpmpyss_rnd_s0, 16317}, // __builtin_HEXAGON_M2_dpmpyss_rnd_s0
+      {Intrinsic::hexagon_M2_dpmpyss_s0, 16353}, // __builtin_HEXAGON_M2_dpmpyss_s0
+      {Intrinsic::hexagon_M2_dpmpyuu_acc_s0, 16385}, // __builtin_HEXAGON_M2_dpmpyuu_acc_s0
+      {Intrinsic::hexagon_M2_dpmpyuu_nac_s0, 16421}, // __builtin_HEXAGON_M2_dpmpyuu_nac_s0
+      {Intrinsic::hexagon_M2_dpmpyuu_s0, 16457}, // __builtin_HEXAGON_M2_dpmpyuu_s0
+      {Intrinsic::hexagon_M2_hmmpyh_rs1, 16489}, // __builtin_HEXAGON_M2_hmmpyh_rs1
+      {Intrinsic::hexagon_M2_hmmpyh_s1, 16521}, // __builtin_HEXAGON_M2_hmmpyh_s1
+      {Intrinsic::hexagon_M2_hmmpyl_rs1, 16552}, // __builtin_HEXAGON_M2_hmmpyl_rs1
+      {Intrinsic::hexagon_M2_hmmpyl_s1, 16584}, // __builtin_HEXAGON_M2_hmmpyl_s1
+      {Intrinsic::hexagon_M2_maci, 16615}, // __builtin_HEXAGON_M2_maci
+      {Intrinsic::hexagon_M2_macsin, 16641}, // __builtin_HEXAGON_M2_macsin
+      {Intrinsic::hexagon_M2_macsip, 16669}, // __builtin_HEXAGON_M2_macsip
+      {Intrinsic::hexagon_M2_mmachs_rs0, 16697}, // __builtin_HEXAGON_M2_mmachs_rs0
+      {Intrinsic::hexagon_M2_mmachs_rs1, 16729}, // __builtin_HEXAGON_M2_mmachs_rs1
+      {Intrinsic::hexagon_M2_mmachs_s0, 16761}, // __builtin_HEXAGON_M2_mmachs_s0
+      {Intrinsic::hexagon_M2_mmachs_s1, 16792}, // __builtin_HEXAGON_M2_mmachs_s1
+      {Intrinsic::hexagon_M2_mmacls_rs0, 16823}, // __builtin_HEXAGON_M2_mmacls_rs0
+      {Intrinsic::hexagon_M2_mmacls_rs1, 16855}, // __builtin_HEXAGON_M2_mmacls_rs1
+      {Intrinsic::hexagon_M2_mmacls_s0, 16887}, // __builtin_HEXAGON_M2_mmacls_s0
+      {Intrinsic::hexagon_M2_mmacls_s1, 16918}, // __builtin_HEXAGON_M2_mmacls_s1
+      {Intrinsic::hexagon_M2_mmacuhs_rs0, 16949}, // __builtin_HEXAGON_M2_mmacuhs_rs0
+      {Intrinsic::hexagon_M2_mmacuhs_rs1, 16982}, // __builtin_HEXAGON_M2_mmacuhs_rs1
+      {Intrinsic::hexagon_M2_mmacuhs_s0, 17015}, // __builtin_HEXAGON_M2_mmacuhs_s0
+      {Intrinsic::hexagon_M2_mmacuhs_s1, 17047}, // __builtin_HEXAGON_M2_mmacuhs_s1
+      {Intrinsic::hexagon_M2_mmaculs_rs0, 17079}, // __builtin_HEXAGON_M2_mmaculs_rs0
+      {Intrinsic::hexagon_M2_mmaculs_rs1, 17112}, // __builtin_HEXAGON_M2_mmaculs_rs1
+      {Intrinsic::hexagon_M2_mmaculs_s0, 17145}, // __builtin_HEXAGON_M2_mmaculs_s0
+      {Intrinsic::hexagon_M2_mmaculs_s1, 17177}, // __builtin_HEXAGON_M2_mmaculs_s1
+      {Intrinsic::hexagon_M2_mmpyh_rs0, 17209}, // __builtin_HEXAGON_M2_mmpyh_rs0
+      {Intrinsic::hexagon_M2_mmpyh_rs1, 17240}, // __builtin_HEXAGON_M2_mmpyh_rs1
+      {Intrinsic::hexagon_M2_mmpyh_s0, 17271}, // __builtin_HEXAGON_M2_mmpyh_s0
+      {Intrinsic::hexagon_M2_mmpyh_s1, 17301}, // __builtin_HEXAGON_M2_mmpyh_s1
+      {Intrinsic::hexagon_M2_mmpyl_rs0, 17331}, // __builtin_HEXAGON_M2_mmpyl_rs0
+      {Intrinsic::hexagon_M2_mmpyl_rs1, 17362}, // __builtin_HEXAGON_M2_mmpyl_rs1
+      {Intrinsic::hexagon_M2_mmpyl_s0, 17393}, // __builtin_HEXAGON_M2_mmpyl_s0
+      {Intrinsic::hexagon_M2_mmpyl_s1, 17423}, // __builtin_HEXAGON_M2_mmpyl_s1
+      {Intrinsic::hexagon_M2_mmpyuh_rs0, 17453}, // __builtin_HEXAGON_M2_mmpyuh_rs0
+      {Intrinsic::hexagon_M2_mmpyuh_rs1, 17485}, // __builtin_HEXAGON_M2_mmpyuh_rs1
+      {Intrinsic::hexagon_M2_mmpyuh_s0, 17517}, // __builtin_HEXAGON_M2_mmpyuh_s0
+      {Intrinsic::hexagon_M2_mmpyuh_s1, 17548}, // __builtin_HEXAGON_M2_mmpyuh_s1
+      {Intrinsic::hexagon_M2_mmpyul_rs0, 17579}, // __builtin_HEXAGON_M2_mmpyul_rs0
+      {Intrinsic::hexagon_M2_mmpyul_rs1, 17611}, // __builtin_HEXAGON_M2_mmpyul_rs1
+      {Intrinsic::hexagon_M2_mmpyul_s0, 17643}, // __builtin_HEXAGON_M2_mmpyul_s0
+      {Intrinsic::hexagon_M2_mmpyul_s1, 17674}, // __builtin_HEXAGON_M2_mmpyul_s1
+      {Intrinsic::hexagon_M2_mnaci, 17705}, // __builtin_HEXAGON_M2_mnaci
+      {Intrinsic::hexagon_M2_mpy_acc_hh_s0, 17732}, // __builtin_HEXAGON_M2_mpy_acc_hh_s0
+      {Intrinsic::hexagon_M2_mpy_acc_hh_s1, 17767}, // __builtin_HEXAGON_M2_mpy_acc_hh_s1
+      {Intrinsic::hexagon_M2_mpy_acc_hl_s0, 17802}, // __builtin_HEXAGON_M2_mpy_acc_hl_s0
+      {Intrinsic::hexagon_M2_mpy_acc_hl_s1, 17837}, // __builtin_HEXAGON_M2_mpy_acc_hl_s1
+      {Intrinsic::hexagon_M2_mpy_acc_lh_s0, 17872}, // __builtin_HEXAGON_M2_mpy_acc_lh_s0
+      {Intrinsic::hexagon_M2_mpy_acc_lh_s1, 17907}, // __builtin_HEXAGON_M2_mpy_acc_lh_s1
+      {Intrinsic::hexagon_M2_mpy_acc_ll_s0, 17942}, // __builtin_HEXAGON_M2_mpy_acc_ll_s0
+      {Intrinsic::hexagon_M2_mpy_acc_ll_s1, 17977}, // __builtin_HEXAGON_M2_mpy_acc_ll_s1
+      {Intrinsic::hexagon_M2_mpy_acc_sat_hh_s0, 18012}, // __builtin_HEXAGON_M2_mpy_acc_sat_hh_s0
+      {Intrinsic::hexagon_M2_mpy_acc_sat_hh_s1, 18051}, // __builtin_HEXAGON_M2_mpy_acc_sat_hh_s1
+      {Intrinsic::hexagon_M2_mpy_acc_sat_hl_s0, 18090}, // __builtin_HEXAGON_M2_mpy_acc_sat_hl_s0
+      {Intrinsic::hexagon_M2_mpy_acc_sat_hl_s1, 18129}, // __builtin_HEXAGON_M2_mpy_acc_sat_hl_s1
+      {Intrinsic::hexagon_M2_mpy_acc_sat_lh_s0, 18168}, // __builtin_HEXAGON_M2_mpy_acc_sat_lh_s0
+      {Intrinsic::hexagon_M2_mpy_acc_sat_lh_s1, 18207}, // __builtin_HEXAGON_M2_mpy_acc_sat_lh_s1
+      {Intrinsic::hexagon_M2_mpy_acc_sat_ll_s0, 18246}, // __builtin_HEXAGON_M2_mpy_acc_sat_ll_s0
+      {Intrinsic::hexagon_M2_mpy_acc_sat_ll_s1, 18285}, // __builtin_HEXAGON_M2_mpy_acc_sat_ll_s1
+      {Intrinsic::hexagon_M2_mpy_hh_s0, 18324}, // __builtin_HEXAGON_M2_mpy_hh_s0
+      {Intrinsic::hexagon_M2_mpy_hh_s1, 18355}, // __builtin_HEXAGON_M2_mpy_hh_s1
+      {Intrinsic::hexagon_M2_mpy_hl_s0, 18386}, // __builtin_HEXAGON_M2_mpy_hl_s0
+      {Intrinsic::hexagon_M2_mpy_hl_s1, 18417}, // __builtin_HEXAGON_M2_mpy_hl_s1
+      {Intrinsic::hexagon_M2_mpy_lh_s0, 18448}, // __builtin_HEXAGON_M2_mpy_lh_s0
+      {Intrinsic::hexagon_M2_mpy_lh_s1, 18479}, // __builtin_HEXAGON_M2_mpy_lh_s1
+      {Intrinsic::hexagon_M2_mpy_ll_s0, 18510}, // __builtin_HEXAGON_M2_mpy_ll_s0
+      {Intrinsic::hexagon_M2_mpy_ll_s1, 18541}, // __builtin_HEXAGON_M2_mpy_ll_s1
+      {Intrinsic::hexagon_M2_mpy_nac_hh_s0, 18572}, // __builtin_HEXAGON_M2_mpy_nac_hh_s0
+      {Intrinsic::hexagon_M2_mpy_nac_hh_s1, 18607}, // __builtin_HEXAGON_M2_mpy_nac_hh_s1
+      {Intrinsic::hexagon_M2_mpy_nac_hl_s0, 18642}, // __builtin_HEXAGON_M2_mpy_nac_hl_s0
+      {Intrinsic::hexagon_M2_mpy_nac_hl_s1, 18677}, // __builtin_HEXAGON_M2_mpy_nac_hl_s1
+      {Intrinsic::hexagon_M2_mpy_nac_lh_s0, 18712}, // __builtin_HEXAGON_M2_mpy_nac_lh_s0
+      {Intrinsic::hexagon_M2_mpy_nac_lh_s1, 18747}, // __builtin_HEXAGON_M2_mpy_nac_lh_s1
+      {Intrinsic::hexagon_M2_mpy_nac_ll_s0, 18782}, // __builtin_HEXAGON_M2_mpy_nac_ll_s0
+      {Intrinsic::hexagon_M2_mpy_nac_ll_s1, 18817}, // __builtin_HEXAGON_M2_mpy_nac_ll_s1
+      {Intrinsic::hexagon_M2_mpy_nac_sat_hh_s0, 18852}, // __builtin_HEXAGON_M2_mpy_nac_sat_hh_s0
+      {Intrinsic::hexagon_M2_mpy_nac_sat_hh_s1, 18891}, // __builtin_HEXAGON_M2_mpy_nac_sat_hh_s1
+      {Intrinsic::hexagon_M2_mpy_nac_sat_hl_s0, 18930}, // __builtin_HEXAGON_M2_mpy_nac_sat_hl_s0
+      {Intrinsic::hexagon_M2_mpy_nac_sat_hl_s1, 18969}, // __builtin_HEXAGON_M2_mpy_nac_sat_hl_s1
+      {Intrinsic::hexagon_M2_mpy_nac_sat_lh_s0, 19008}, // __builtin_HEXAGON_M2_mpy_nac_sat_lh_s0
+      {Intrinsic::hexagon_M2_mpy_nac_sat_lh_s1, 19047}, // __builtin_HEXAGON_M2_mpy_nac_sat_lh_s1
+      {Intrinsic::hexagon_M2_mpy_nac_sat_ll_s0, 19086}, // __builtin_HEXAGON_M2_mpy_nac_sat_ll_s0
+      {Intrinsic::hexagon_M2_mpy_nac_sat_ll_s1, 19125}, // __builtin_HEXAGON_M2_mpy_nac_sat_ll_s1
+      {Intrinsic::hexagon_M2_mpy_rnd_hh_s0, 19164}, // __builtin_HEXAGON_M2_mpy_rnd_hh_s0
+      {Intrinsic::hexagon_M2_mpy_rnd_hh_s1, 19199}, // __builtin_HEXAGON_M2_mpy_rnd_hh_s1
+      {Intrinsic::hexagon_M2_mpy_rnd_hl_s0, 19234}, // __builtin_HEXAGON_M2_mpy_rnd_hl_s0
+      {Intrinsic::hexagon_M2_mpy_rnd_hl_s1, 19269}, // __builtin_HEXAGON_M2_mpy_rnd_hl_s1
+      {Intrinsic::hexagon_M2_mpy_rnd_lh_s0, 19304}, // __builtin_HEXAGON_M2_mpy_rnd_lh_s0
+      {Intrinsic::hexagon_M2_mpy_rnd_lh_s1, 19339}, // __builtin_HEXAGON_M2_mpy_rnd_lh_s1
+      {Intrinsic::hexagon_M2_mpy_rnd_ll_s0, 19374}, // __builtin_HEXAGON_M2_mpy_rnd_ll_s0
+      {Intrinsic::hexagon_M2_mpy_rnd_ll_s1, 19409}, // __builtin_HEXAGON_M2_mpy_rnd_ll_s1
+      {Intrinsic::hexagon_M2_mpy_sat_hh_s0, 19444}, // __builtin_HEXAGON_M2_mpy_sat_hh_s0
+      {Intrinsic::hexagon_M2_mpy_sat_hh_s1, 19479}, // __builtin_HEXAGON_M2_mpy_sat_hh_s1
+      {Intrinsic::hexagon_M2_mpy_sat_hl_s0, 19514}, // __builtin_HEXAGON_M2_mpy_sat_hl_s0
+      {Intrinsic::hexagon_M2_mpy_sat_hl_s1, 19549}, // __builtin_HEXAGON_M2_mpy_sat_hl_s1
+      {Intrinsic::hexagon_M2_mpy_sat_lh_s0, 19584}, // __builtin_HEXAGON_M2_mpy_sat_lh_s0
+      {Intrinsic::hexagon_M2_mpy_sat_lh_s1, 19619}, // __builtin_HEXAGON_M2_mpy_sat_lh_s1
+      {Intrinsic::hexagon_M2_mpy_sat_ll_s0, 19654}, // __builtin_HEXAGON_M2_mpy_sat_ll_s0
+      {Intrinsic::hexagon_M2_mpy_sat_ll_s1, 19689}, // __builtin_HEXAGON_M2_mpy_sat_ll_s1
+      {Intrinsic::hexagon_M2_mpy_sat_rnd_hh_s0, 19724}, // __builtin_HEXAGON_M2_mpy_sat_rnd_hh_s0
+      {Intrinsic::hexagon_M2_mpy_sat_rnd_hh_s1, 19763}, // __builtin_HEXAGON_M2_mpy_sat_rnd_hh_s1
+      {Intrinsic::hexagon_M2_mpy_sat_rnd_hl_s0, 19802}, // __builtin_HEXAGON_M2_mpy_sat_rnd_hl_s0
+      {Intrinsic::hexagon_M2_mpy_sat_rnd_hl_s1, 19841}, // __builtin_HEXAGON_M2_mpy_sat_rnd_hl_s1
+      {Intrinsic::hexagon_M2_mpy_sat_rnd_lh_s0, 19880}, // __builtin_HEXAGON_M2_mpy_sat_rnd_lh_s0
+      {Intrinsic::hexagon_M2_mpy_sat_rnd_lh_s1, 19919}, // __builtin_HEXAGON_M2_mpy_sat_rnd_lh_s1
+      {Intrinsic::hexagon_M2_mpy_sat_rnd_ll_s0, 19958}, // __builtin_HEXAGON_M2_mpy_sat_rnd_ll_s0
+      {Intrinsic::hexagon_M2_mpy_sat_rnd_ll_s1, 19997}, // __builtin_HEXAGON_M2_mpy_sat_rnd_ll_s1
+      {Intrinsic::hexagon_M2_mpy_up, 20036}, // __builtin_HEXAGON_M2_mpy_up
+      {Intrinsic::hexagon_M2_mpy_up_s1, 20064}, // __builtin_HEXAGON_M2_mpy_up_s1
+      {Intrinsic::hexagon_M2_mpy_up_s1_sat, 20095}, // __builtin_HEXAGON_M2_mpy_up_s1_sat
+      {Intrinsic::hexagon_M2_mpyd_acc_hh_s0, 20130}, // __builtin_HEXAGON_M2_mpyd_acc_hh_s0
+      {Intrinsic::hexagon_M2_mpyd_acc_hh_s1, 20166}, // __builtin_HEXAGON_M2_mpyd_acc_hh_s1
+      {Intrinsic::hexagon_M2_mpyd_acc_hl_s0, 20202}, // __builtin_HEXAGON_M2_mpyd_acc_hl_s0
+      {Intrinsic::hexagon_M2_mpyd_acc_hl_s1, 20238}, // __builtin_HEXAGON_M2_mpyd_acc_hl_s1
+      {Intrinsic::hexagon_M2_mpyd_acc_lh_s0, 20274}, // __builtin_HEXAGON_M2_mpyd_acc_lh_s0
+      {Intrinsic::hexagon_M2_mpyd_acc_lh_s1, 20310}, // __builtin_HEXAGON_M2_mpyd_acc_lh_s1
+      {Intrinsic::hexagon_M2_mpyd_acc_ll_s0, 20346}, // __builtin_HEXAGON_M2_mpyd_acc_ll_s0
+      {Intrinsic::hexagon_M2_mpyd_acc_ll_s1, 20382}, // __builtin_HEXAGON_M2_mpyd_acc_ll_s1
+      {Intrinsic::hexagon_M2_mpyd_hh_s0, 20418}, // __builtin_HEXAGON_M2_mpyd_hh_s0
+      {Intrinsic::hexagon_M2_mpyd_hh_s1, 20450}, // __builtin_HEXAGON_M2_mpyd_hh_s1
+      {Intrinsic::hexagon_M2_mpyd_hl_s0, 20482}, // __builtin_HEXAGON_M2_mpyd_hl_s0
+      {Intrinsic::hexagon_M2_mpyd_hl_s1, 20514}, // __builtin_HEXAGON_M2_mpyd_hl_s1
+      {Intrinsic::hexagon_M2_mpyd_lh_s0, 20546}, // __builtin_HEXAGON_M2_mpyd_lh_s0
+      {Intrinsic::hexagon_M2_mpyd_lh_s1, 20578}, // __builtin_HEXAGON_M2_mpyd_lh_s1
+      {Intrinsic::hexagon_M2_mpyd_ll_s0, 20610}, // __builtin_HEXAGON_M2_mpyd_ll_s0
+      {Intrinsic::hexagon_M2_mpyd_ll_s1, 20642}, // __builtin_HEXAGON_M2_mpyd_ll_s1
+      {Intrinsic::hexagon_M2_mpyd_nac_hh_s0, 20674}, // __builtin_HEXAGON_M2_mpyd_nac_hh_s0
+      {Intrinsic::hexagon_M2_mpyd_nac_hh_s1, 20710}, // __builtin_HEXAGON_M2_mpyd_nac_hh_s1
+      {Intrinsic::hexagon_M2_mpyd_nac_hl_s0, 20746}, // __builtin_HEXAGON_M2_mpyd_nac_hl_s0
+      {Intrinsic::hexagon_M2_mpyd_nac_hl_s1, 20782}, // __builtin_HEXAGON_M2_mpyd_nac_hl_s1
+      {Intrinsic::hexagon_M2_mpyd_nac_lh_s0, 20818}, // __builtin_HEXAGON_M2_mpyd_nac_lh_s0
+      {Intrinsic::hexagon_M2_mpyd_nac_lh_s1, 20854}, // __builtin_HEXAGON_M2_mpyd_nac_lh_s1
+      {Intrinsic::hexagon_M2_mpyd_nac_ll_s0, 20890}, // __builtin_HEXAGON_M2_mpyd_nac_ll_s0
+      {Intrinsic::hexagon_M2_mpyd_nac_ll_s1, 20926}, // __builtin_HEXAGON_M2_mpyd_nac_ll_s1
+      {Intrinsic::hexagon_M2_mpyd_rnd_hh_s0, 20962}, // __builtin_HEXAGON_M2_mpyd_rnd_hh_s0
+      {Intrinsic::hexagon_M2_mpyd_rnd_hh_s1, 20998}, // __builtin_HEXAGON_M2_mpyd_rnd_hh_s1
+      {Intrinsic::hexagon_M2_mpyd_rnd_hl_s0, 21034}, // __builtin_HEXAGON_M2_mpyd_rnd_hl_s0
+      {Intrinsic::hexagon_M2_mpyd_rnd_hl_s1, 21070}, // __builtin_HEXAGON_M2_mpyd_rnd_hl_s1
+      {Intrinsic::hexagon_M2_mpyd_rnd_lh_s0, 21106}, // __builtin_HEXAGON_M2_mpyd_rnd_lh_s0
+      {Intrinsic::hexagon_M2_mpyd_rnd_lh_s1, 21142}, // __builtin_HEXAGON_M2_mpyd_rnd_lh_s1
+      {Intrinsic::hexagon_M2_mpyd_rnd_ll_s0, 21178}, // __builtin_HEXAGON_M2_mpyd_rnd_ll_s0
+      {Intrinsic::hexagon_M2_mpyd_rnd_ll_s1, 21214}, // __builtin_HEXAGON_M2_mpyd_rnd_ll_s1
+      {Intrinsic::hexagon_M2_mpyi, 21250}, // __builtin_HEXAGON_M2_mpyi
+      {Intrinsic::hexagon_M2_mpysmi, 21276}, // __builtin_HEXAGON_M2_mpysmi
+      {Intrinsic::hexagon_M2_mpysu_up, 21304}, // __builtin_HEXAGON_M2_mpysu_up
+      {Intrinsic::hexagon_M2_mpyu_acc_hh_s0, 21334}, // __builtin_HEXAGON_M2_mpyu_acc_hh_s0
+      {Intrinsic::hexagon_M2_mpyu_acc_hh_s1, 21370}, // __builtin_HEXAGON_M2_mpyu_acc_hh_s1
+      {Intrinsic::hexagon_M2_mpyu_acc_hl_s0, 21406}, // __builtin_HEXAGON_M2_mpyu_acc_hl_s0
+      {Intrinsic::hexagon_M2_mpyu_acc_hl_s1, 21442}, // __builtin_HEXAGON_M2_mpyu_acc_hl_s1
+      {Intrinsic::hexagon_M2_mpyu_acc_lh_s0, 21478}, // __builtin_HEXAGON_M2_mpyu_acc_lh_s0
+      {Intrinsic::hexagon_M2_mpyu_acc_lh_s1, 21514}, // __builtin_HEXAGON_M2_mpyu_acc_lh_s1
+      {Intrinsic::hexagon_M2_mpyu_acc_ll_s0, 21550}, // __builtin_HEXAGON_M2_mpyu_acc_ll_s0
+      {Intrinsic::hexagon_M2_mpyu_acc_ll_s1, 21586}, // __builtin_HEXAGON_M2_mpyu_acc_ll_s1
+      {Intrinsic::hexagon_M2_mpyu_hh_s0, 21622}, // __builtin_HEXAGON_M2_mpyu_hh_s0
+      {Intrinsic::hexagon_M2_mpyu_hh_s1, 21654}, // __builtin_HEXAGON_M2_mpyu_hh_s1
+      {Intrinsic::hexagon_M2_mpyu_hl_s0, 21686}, // __builtin_HEXAGON_M2_mpyu_hl_s0
+      {Intrinsic::hexagon_M2_mpyu_hl_s1, 21718}, // __builtin_HEXAGON_M2_mpyu_hl_s1
+      {Intrinsic::hexagon_M2_mpyu_lh_s0, 21750}, // __builtin_HEXAGON_M2_mpyu_lh_s0
+      {Intrinsic::hexagon_M2_mpyu_lh_s1, 21782}, // __builtin_HEXAGON_M2_mpyu_lh_s1
+      {Intrinsic::hexagon_M2_mpyu_ll_s0, 21814}, // __builtin_HEXAGON_M2_mpyu_ll_s0
+      {Intrinsic::hexagon_M2_mpyu_ll_s1, 21846}, // __builtin_HEXAGON_M2_mpyu_ll_s1
+      {Intrinsic::hexagon_M2_mpyu_nac_hh_s0, 21878}, // __builtin_HEXAGON_M2_mpyu_nac_hh_s0
+      {Intrinsic::hexagon_M2_mpyu_nac_hh_s1, 21914}, // __builtin_HEXAGON_M2_mpyu_nac_hh_s1
+      {Intrinsic::hexagon_M2_mpyu_nac_hl_s0, 21950}, // __builtin_HEXAGON_M2_mpyu_nac_hl_s0
+      {Intrinsic::hexagon_M2_mpyu_nac_hl_s1, 21986}, // __builtin_HEXAGON_M2_mpyu_nac_hl_s1
+      {Intrinsic::hexagon_M2_mpyu_nac_lh_s0, 22022}, // __builtin_HEXAGON_M2_mpyu_nac_lh_s0
+      {Intrinsic::hexagon_M2_mpyu_nac_lh_s1, 22058}, // __builtin_HEXAGON_M2_mpyu_nac_lh_s1
+      {Intrinsic::hexagon_M2_mpyu_nac_ll_s0, 22094}, // __builtin_HEXAGON_M2_mpyu_nac_ll_s0
+      {Intrinsic::hexagon_M2_mpyu_nac_ll_s1, 22130}, // __builtin_HEXAGON_M2_mpyu_nac_ll_s1
+      {Intrinsic::hexagon_M2_mpyu_up, 22166}, // __builtin_HEXAGON_M2_mpyu_up
+      {Intrinsic::hexagon_M2_mpyud_acc_hh_s0, 22195}, // __builtin_HEXAGON_M2_mpyud_acc_hh_s0
+      {Intrinsic::hexagon_M2_mpyud_acc_hh_s1, 22232}, // __builtin_HEXAGON_M2_mpyud_acc_hh_s1
+      {Intrinsic::hexagon_M2_mpyud_acc_hl_s0, 22269}, // __builtin_HEXAGON_M2_mpyud_acc_hl_s0
+      {Intrinsic::hexagon_M2_mpyud_acc_hl_s1, 22306}, // __builtin_HEXAGON_M2_mpyud_acc_hl_s1
+      {Intrinsic::hexagon_M2_mpyud_acc_lh_s0, 22343}, // __builtin_HEXAGON_M2_mpyud_acc_lh_s0
+      {Intrinsic::hexagon_M2_mpyud_acc_lh_s1, 22380}, // __builtin_HEXAGON_M2_mpyud_acc_lh_s1
+      {Intrinsic::hexagon_M2_mpyud_acc_ll_s0, 22417}, // __builtin_HEXAGON_M2_mpyud_acc_ll_s0
+      {Intrinsic::hexagon_M2_mpyud_acc_ll_s1, 22454}, // __builtin_HEXAGON_M2_mpyud_acc_ll_s1
+      {Intrinsic::hexagon_M2_mpyud_hh_s0, 22491}, // __builtin_HEXAGON_M2_mpyud_hh_s0
+      {Intrinsic::hexagon_M2_mpyud_hh_s1, 22524}, // __builtin_HEXAGON_M2_mpyud_hh_s1
+      {Intrinsic::hexagon_M2_mpyud_hl_s0, 22557}, // __builtin_HEXAGON_M2_mpyud_hl_s0
+      {Intrinsic::hexagon_M2_mpyud_hl_s1, 22590}, // __builtin_HEXAGON_M2_mpyud_hl_s1
+      {Intrinsic::hexagon_M2_mpyud_lh_s0, 22623}, // __builtin_HEXAGON_M2_mpyud_lh_s0
+      {Intrinsic::hexagon_M2_mpyud_lh_s1, 22656}, // __builtin_HEXAGON_M2_mpyud_lh_s1
+      {Intrinsic::hexagon_M2_mpyud_ll_s0, 22689}, // __builtin_HEXAGON_M2_mpyud_ll_s0
+      {Intrinsic::hexagon_M2_mpyud_ll_s1, 22722}, // __builtin_HEXAGON_M2_mpyud_ll_s1
+      {Intrinsic::hexagon_M2_mpyud_nac_hh_s0, 22755}, // __builtin_HEXAGON_M2_mpyud_nac_hh_s0
+      {Intrinsic::hexagon_M2_mpyud_nac_hh_s1, 22792}, // __builtin_HEXAGON_M2_mpyud_nac_hh_s1
+      {Intrinsic::hexagon_M2_mpyud_nac_hl_s0, 22829}, // __builtin_HEXAGON_M2_mpyud_nac_hl_s0
+      {Intrinsic::hexagon_M2_mpyud_nac_hl_s1, 22866}, // __builtin_HEXAGON_M2_mpyud_nac_hl_s1
+      {Intrinsic::hexagon_M2_mpyud_nac_lh_s0, 22903}, // __builtin_HEXAGON_M2_mpyud_nac_lh_s0
+      {Intrinsic::hexagon_M2_mpyud_nac_lh_s1, 22940}, // __builtin_HEXAGON_M2_mpyud_nac_lh_s1
+      {Intrinsic::hexagon_M2_mpyud_nac_ll_s0, 22977}, // __builtin_HEXAGON_M2_mpyud_nac_ll_s0
+      {Intrinsic::hexagon_M2_mpyud_nac_ll_s1, 23014}, // __builtin_HEXAGON_M2_mpyud_nac_ll_s1
+      {Intrinsic::hexagon_M2_mpyui, 23051}, // __builtin_HEXAGON_M2_mpyui
+      {Intrinsic::hexagon_M2_nacci, 23078}, // __builtin_HEXAGON_M2_nacci
+      {Intrinsic::hexagon_M2_naccii, 23105}, // __builtin_HEXAGON_M2_naccii
+      {Intrinsic::hexagon_M2_subacc, 23133}, // __builtin_HEXAGON_M2_subacc
+      {Intrinsic::hexagon_M2_vabsdiffh, 23161}, // __builtin_HEXAGON_M2_vabsdiffh
+      {Intrinsic::hexagon_M2_vabsdiffw, 23192}, // __builtin_HEXAGON_M2_vabsdiffw
+      {Intrinsic::hexagon_M2_vcmac_s0_sat_i, 23223}, // __builtin_HEXAGON_M2_vcmac_s0_sat_i
+      {Intrinsic::hexagon_M2_vcmac_s0_sat_r, 23259}, // __builtin_HEXAGON_M2_vcmac_s0_sat_r
+      {Intrinsic::hexagon_M2_vcmpy_s0_sat_i, 23295}, // __builtin_HEXAGON_M2_vcmpy_s0_sat_i
+      {Intrinsic::hexagon_M2_vcmpy_s0_sat_r, 23331}, // __builtin_HEXAGON_M2_vcmpy_s0_sat_r
+      {Intrinsic::hexagon_M2_vcmpy_s1_sat_i, 23367}, // __builtin_HEXAGON_M2_vcmpy_s1_sat_i
+      {Intrinsic::hexagon_M2_vcmpy_s1_sat_r, 23403}, // __builtin_HEXAGON_M2_vcmpy_s1_sat_r
+      {Intrinsic::hexagon_M2_vdmacs_s0, 23439}, // __builtin_HEXAGON_M2_vdmacs_s0
+      {Intrinsic::hexagon_M2_vdmacs_s1, 23470}, // __builtin_HEXAGON_M2_vdmacs_s1
+      {Intrinsic::hexagon_M2_vdmpyrs_s0, 23501}, // __builtin_HEXAGON_M2_vdmpyrs_s0
+      {Intrinsic::hexagon_M2_vdmpyrs_s1, 23533}, // __builtin_HEXAGON_M2_vdmpyrs_s1
+      {Intrinsic::hexagon_M2_vdmpys_s0, 23565}, // __builtin_HEXAGON_M2_vdmpys_s0
+      {Intrinsic::hexagon_M2_vdmpys_s1, 23596}, // __builtin_HEXAGON_M2_vdmpys_s1
+      {Intrinsic::hexagon_M2_vmac2, 23627}, // __builtin_HEXAGON_M2_vmac2
+      {Intrinsic::hexagon_M2_vmac2es, 23654}, // __builtin_HEXAGON_M2_vmac2es
+      {Intrinsic::hexagon_M2_vmac2es_s0, 23683}, // __builtin_HEXAGON_M2_vmac2es_s0
+      {Intrinsic::hexagon_M2_vmac2es_s1, 23715}, // __builtin_HEXAGON_M2_vmac2es_s1
+      {Intrinsic::hexagon_M2_vmac2s_s0, 23747}, // __builtin_HEXAGON_M2_vmac2s_s0
+      {Intrinsic::hexagon_M2_vmac2s_s1, 23778}, // __builtin_HEXAGON_M2_vmac2s_s1
+      {Intrinsic::hexagon_M2_vmac2su_s0, 23809}, // __builtin_HEXAGON_M2_vmac2su_s0
+      {Intrinsic::hexagon_M2_vmac2su_s1, 23841}, // __builtin_HEXAGON_M2_vmac2su_s1
+      {Intrinsic::hexagon_M2_vmpy2es_s0, 23873}, // __builtin_HEXAGON_M2_vmpy2es_s0
+      {Intrinsic::hexagon_M2_vmpy2es_s1, 23905}, // __builtin_HEXAGON_M2_vmpy2es_s1
+      {Intrinsic::hexagon_M2_vmpy2s_s0, 23937}, // __builtin_HEXAGON_M2_vmpy2s_s0
+      {Intrinsic::hexagon_M2_vmpy2s_s0pack, 23968}, // __builtin_HEXAGON_M2_vmpy2s_s0pack
+      {Intrinsic::hexagon_M2_vmpy2s_s1, 24003}, // __builtin_HEXAGON_M2_vmpy2s_s1
+      {Intrinsic::hexagon_M2_vmpy2s_s1pack, 24034}, // __builtin_HEXAGON_M2_vmpy2s_s1pack
+      {Intrinsic::hexagon_M2_vmpy2su_s0, 24069}, // __builtin_HEXAGON_M2_vmpy2su_s0
+      {Intrinsic::hexagon_M2_vmpy2su_s1, 24101}, // __builtin_HEXAGON_M2_vmpy2su_s1
+      {Intrinsic::hexagon_M2_vraddh, 24133}, // __builtin_HEXAGON_M2_vraddh
+      {Intrinsic::hexagon_M2_vradduh, 24161}, // __builtin_HEXAGON_M2_vradduh
+      {Intrinsic::hexagon_M2_vrcmaci_s0, 24190}, // __builtin_HEXAGON_M2_vrcmaci_s0
+      {Intrinsic::hexagon_M2_vrcmaci_s0c, 24222}, // __builtin_HEXAGON_M2_vrcmaci_s0c
+      {Intrinsic::hexagon_M2_vrcmacr_s0, 24255}, // __builtin_HEXAGON_M2_vrcmacr_s0
+      {Intrinsic::hexagon_M2_vrcmacr_s0c, 24287}, // __builtin_HEXAGON_M2_vrcmacr_s0c
+      {Intrinsic::hexagon_M2_vrcmpyi_s0, 24320}, // __builtin_HEXAGON_M2_vrcmpyi_s0
+      {Intrinsic::hexagon_M2_vrcmpyi_s0c, 24352}, // __builtin_HEXAGON_M2_vrcmpyi_s0c
+      {Intrinsic::hexagon_M2_vrcmpyr_s0, 24385}, // __builtin_HEXAGON_M2_vrcmpyr_s0
+      {Intrinsic::hexagon_M2_vrcmpyr_s0c, 24417}, // __builtin_HEXAGON_M2_vrcmpyr_s0c
+      {Intrinsic::hexagon_M2_vrcmpys_acc_s1, 24450}, // __builtin_HEXAGON_M2_vrcmpys_acc_s1
+      {Intrinsic::hexagon_M2_vrcmpys_s1, 24486}, // __builtin_HEXAGON_M2_vrcmpys_s1
+      {Intrinsic::hexagon_M2_vrcmpys_s1rp, 24518}, // __builtin_HEXAGON_M2_vrcmpys_s1rp
+      {Intrinsic::hexagon_M2_vrmac_s0, 24552}, // __builtin_HEXAGON_M2_vrmac_s0
+      {Intrinsic::hexagon_M2_vrmpy_s0, 24582}, // __builtin_HEXAGON_M2_vrmpy_s0
+      {Intrinsic::hexagon_M2_xor_xacc, 24612}, // __builtin_HEXAGON_M2_xor_xacc
+      {Intrinsic::hexagon_M4_and_and, 24642}, // __builtin_HEXAGON_M4_and_and
+      {Intrinsic::hexagon_M4_and_andn, 24671}, // __builtin_HEXAGON_M4_and_andn
+      {Intrinsic::hexagon_M4_and_or, 24701}, // __builtin_HEXAGON_M4_and_or
+      {Intrinsic::hexagon_M4_and_xor, 24729}, // __builtin_HEXAGON_M4_and_xor
+      {Intrinsic::hexagon_M4_cmpyi_wh, 24758}, // __builtin_HEXAGON_M4_cmpyi_wh
+      {Intrinsic::hexagon_M4_cmpyi_whc, 24788}, // __builtin_HEXAGON_M4_cmpyi_whc
+      {Intrinsic::hexagon_M4_cmpyr_wh, 24819}, // __builtin_HEXAGON_M4_cmpyr_wh
+      {Intrinsic::hexagon_M4_cmpyr_whc, 24849}, // __builtin_HEXAGON_M4_cmpyr_whc
+      {Intrinsic::hexagon_M4_mac_up_s1_sat, 24880}, // __builtin_HEXAGON_M4_mac_up_s1_sat
+      {Intrinsic::hexagon_M4_mpyri_addi, 24915}, // __builtin_HEXAGON_M4_mpyri_addi
+      {Intrinsic::hexagon_M4_mpyri_addr, 24947}, // __builtin_HEXAGON_M4_mpyri_addr
+      {Intrinsic::hexagon_M4_mpyri_addr_u2, 24979}, // __builtin_HEXAGON_M4_mpyri_addr_u2
+      {Intrinsic::hexagon_M4_mpyrr_addi, 25014}, // __builtin_HEXAGON_M4_mpyrr_addi
+      {Intrinsic::hexagon_M4_mpyrr_addr, 25046}, // __builtin_HEXAGON_M4_mpyrr_addr
+      {Intrinsic::hexagon_M4_nac_up_s1_sat, 25078}, // __builtin_HEXAGON_M4_nac_up_s1_sat
+      {Intrinsic::hexagon_M4_or_and, 25113}, // __builtin_HEXAGON_M4_or_and
+      {Intrinsic::hexagon_M4_or_andn, 25141}, // __builtin_HEXAGON_M4_or_andn
+      {Intrinsic::hexagon_M4_or_or, 25170}, // __builtin_HEXAGON_M4_or_or
+      {Intrinsic::hexagon_M4_or_xor, 25197}, // __builtin_HEXAGON_M4_or_xor
+      {Intrinsic::hexagon_M4_pmpyw, 25225}, // __builtin_HEXAGON_M4_pmpyw
+      {Intrinsic::hexagon_M4_pmpyw_acc, 25252}, // __builtin_HEXAGON_M4_pmpyw_acc
+      {Intrinsic::hexagon_M4_vpmpyh, 25283}, // __builtin_HEXAGON_M4_vpmpyh
+      {Intrinsic::hexagon_M4_vpmpyh_acc, 25311}, // __builtin_HEXAGON_M4_vpmpyh_acc
+      {Intrinsic::hexagon_M4_vrmpyeh_acc_s0, 25343}, // __builtin_HEXAGON_M4_vrmpyeh_acc_s0
+      {Intrinsic::hexagon_M4_vrmpyeh_acc_s1, 25379}, // __builtin_HEXAGON_M4_vrmpyeh_acc_s1
+      {Intrinsic::hexagon_M4_vrmpyeh_s0, 25415}, // __builtin_HEXAGON_M4_vrmpyeh_s0
+      {Intrinsic::hexagon_M4_vrmpyeh_s1, 25447}, // __builtin_HEXAGON_M4_vrmpyeh_s1
+      {Intrinsic::hexagon_M4_vrmpyoh_acc_s0, 25479}, // __builtin_HEXAGON_M4_vrmpyoh_acc_s0
+      {Intrinsic::hexagon_M4_vrmpyoh_acc_s1, 25515}, // __builtin_HEXAGON_M4_vrmpyoh_acc_s1
+      {Intrinsic::hexagon_M4_vrmpyoh_s0, 25551}, // __builtin_HEXAGON_M4_vrmpyoh_s0
+      {Intrinsic::hexagon_M4_vrmpyoh_s1, 25583}, // __builtin_HEXAGON_M4_vrmpyoh_s1
+      {Intrinsic::hexagon_M4_xor_and, 25615}, // __builtin_HEXAGON_M4_xor_and
+      {Intrinsic::hexagon_M4_xor_andn, 25644}, // __builtin_HEXAGON_M4_xor_andn
+      {Intrinsic::hexagon_M4_xor_or, 25674}, // __builtin_HEXAGON_M4_xor_or
+      {Intrinsic::hexagon_M4_xor_xacc, 25702}, // __builtin_HEXAGON_M4_xor_xacc
+      {Intrinsic::hexagon_M5_vdmacbsu, 25732}, // __builtin_HEXAGON_M5_vdmacbsu
+      {Intrinsic::hexagon_M5_vdmpybsu, 25762}, // __builtin_HEXAGON_M5_vdmpybsu
+      {Intrinsic::hexagon_M5_vmacbsu, 25792}, // __builtin_HEXAGON_M5_vmacbsu
+      {Intrinsic::hexagon_M5_vmacbuu, 25821}, // __builtin_HEXAGON_M5_vmacbuu
+      {Intrinsic::hexagon_M5_vmpybsu, 25850}, // __builtin_HEXAGON_M5_vmpybsu
+      {Intrinsic::hexagon_M5_vmpybuu, 25879}, // __builtin_HEXAGON_M5_vmpybuu
+      {Intrinsic::hexagon_M5_vrmacbsu, 25908}, // __builtin_HEXAGON_M5_vrmacbsu
+      {Intrinsic::hexagon_M5_vrmacbuu, 25938}, // __builtin_HEXAGON_M5_vrmacbuu
+      {Intrinsic::hexagon_M5_vrmpybsu, 25968}, // __builtin_HEXAGON_M5_vrmpybsu
+      {Intrinsic::hexagon_M5_vrmpybuu, 25998}, // __builtin_HEXAGON_M5_vrmpybuu
+      {Intrinsic::hexagon_M6_vabsdiffb, 26028}, // __builtin_HEXAGON_M6_vabsdiffb
+      {Intrinsic::hexagon_M6_vabsdiffub, 26059}, // __builtin_HEXAGON_M6_vabsdiffub
+      {Intrinsic::hexagon_M7_dcmpyiw, 26091}, // __builtin_HEXAGON_M7_dcmpyiw
+      {Intrinsic::hexagon_M7_dcmpyiw_acc, 26120}, // __builtin_HEXAGON_M7_dcmpyiw_acc
+      {Intrinsic::hexagon_M7_dcmpyiwc, 26153}, // __builtin_HEXAGON_M7_dcmpyiwc
+      {Intrinsic::hexagon_M7_dcmpyiwc_acc, 26183}, // __builtin_HEXAGON_M7_dcmpyiwc_acc
+      {Intrinsic::hexagon_M7_dcmpyrw, 26217}, // __builtin_HEXAGON_M7_dcmpyrw
+      {Intrinsic::hexagon_M7_dcmpyrw_acc, 26246}, // __builtin_HEXAGON_M7_dcmpyrw_acc
+      {Intrinsic::hexagon_M7_dcmpyrwc, 26279}, // __builtin_HEXAGON_M7_dcmpyrwc
+      {Intrinsic::hexagon_M7_dcmpyrwc_acc, 26309}, // __builtin_HEXAGON_M7_dcmpyrwc_acc
+      {Intrinsic::hexagon_M7_vdmpy, 26343}, // __builtin_HEXAGON_M7_vdmpy
+      {Intrinsic::hexagon_M7_vdmpy_acc, 26370}, // __builtin_HEXAGON_M7_vdmpy_acc
+      {Intrinsic::hexagon_M7_wcmpyiw, 26401}, // __builtin_HEXAGON_M7_wcmpyiw
+      {Intrinsic::hexagon_M7_wcmpyiw_rnd, 26430}, // __builtin_HEXAGON_M7_wcmpyiw_rnd
+      {Intrinsic::hexagon_M7_wcmpyiwc, 26463}, // __builtin_HEXAGON_M7_wcmpyiwc
+      {Intrinsic::hexagon_M7_wcmpyiwc_rnd, 26493}, // __builtin_HEXAGON_M7_wcmpyiwc_rnd
+      {Intrinsic::hexagon_M7_wcmpyrw, 26527}, // __builtin_HEXAGON_M7_wcmpyrw
+      {Intrinsic::hexagon_M7_wcmpyrw_rnd, 26556}, // __builtin_HEXAGON_M7_wcmpyrw_rnd
+      {Intrinsic::hexagon_M7_wcmpyrwc, 26589}, // __builtin_HEXAGON_M7_wcmpyrwc
+      {Intrinsic::hexagon_M7_wcmpyrwc_rnd, 26619}, // __builtin_HEXAGON_M7_wcmpyrwc_rnd
+      {Intrinsic::hexagon_S2_addasl_rrri, 26653}, // __builtin_HEXAGON_S2_addasl_rrri
+      {Intrinsic::hexagon_S2_asl_i_p, 26686}, // __builtin_HEXAGON_S2_asl_i_p
+      {Intrinsic::hexagon_S2_asl_i_p_acc, 26715}, // __builtin_HEXAGON_S2_asl_i_p_acc
+      {Intrinsic::hexagon_S2_asl_i_p_and, 26748}, // __builtin_HEXAGON_S2_asl_i_p_and
+      {Intrinsic::hexagon_S2_asl_i_p_nac, 26781}, // __builtin_HEXAGON_S2_asl_i_p_nac
+      {Intrinsic::hexagon_S2_asl_i_p_or, 26814}, // __builtin_HEXAGON_S2_asl_i_p_or
+      {Intrinsic::hexagon_S2_asl_i_p_xacc, 26846}, // __builtin_HEXAGON_S2_asl_i_p_xacc
+      {Intrinsic::hexagon_S2_asl_i_r, 26880}, // __builtin_HEXAGON_S2_asl_i_r
+      {Intrinsic::hexagon_S2_asl_i_r_acc, 26909}, // __builtin_HEXAGON_S2_asl_i_r_acc
+      {Intrinsic::hexagon_S2_asl_i_r_and, 26942}, // __builtin_HEXAGON_S2_asl_i_r_and
+      {Intrinsic::hexagon_S2_asl_i_r_nac, 26975}, // __builtin_HEXAGON_S2_asl_i_r_nac
+      {Intrinsic::hexagon_S2_asl_i_r_or, 27008}, // __builtin_HEXAGON_S2_asl_i_r_or
+      {Intrinsic::hexagon_S2_asl_i_r_sat, 27040}, // __builtin_HEXAGON_S2_asl_i_r_sat
+      {Intrinsic::hexagon_S2_asl_i_r_xacc, 27073}, // __builtin_HEXAGON_S2_asl_i_r_xacc
+      {Intrinsic::hexagon_S2_asl_i_vh, 27107}, // __builtin_HEXAGON_S2_asl_i_vh
+      {Intrinsic::hexagon_S2_asl_i_vw, 27137}, // __builtin_HEXAGON_S2_asl_i_vw
+      {Intrinsic::hexagon_S2_asl_r_p, 27167}, // __builtin_HEXAGON_S2_asl_r_p
+      {Intrinsic::hexagon_S2_asl_r_p_acc, 27196}, // __builtin_HEXAGON_S2_asl_r_p_acc
+      {Intrinsic::hexagon_S2_asl_r_p_and, 27229}, // __builtin_HEXAGON_S2_asl_r_p_and
+      {Intrinsic::hexagon_S2_asl_r_p_nac, 27262}, // __builtin_HEXAGON_S2_asl_r_p_nac
+      {Intrinsic::hexagon_S2_asl_r_p_or, 27295}, // __builtin_HEXAGON_S2_asl_r_p_or
+      {Intrinsic::hexagon_S2_asl_r_p_xor, 27327}, // __builtin_HEXAGON_S2_asl_r_p_xor
+      {Intrinsic::hexagon_S2_asl_r_r, 27360}, // __builtin_HEXAGON_S2_asl_r_r
+      {Intrinsic::hexagon_S2_asl_r_r_acc, 27389}, // __builtin_HEXAGON_S2_asl_r_r_acc
+      {Intrinsic::hexagon_S2_asl_r_r_and, 27422}, // __builtin_HEXAGON_S2_asl_r_r_and
+      {Intrinsic::hexagon_S2_asl_r_r_nac, 27455}, // __builtin_HEXAGON_S2_asl_r_r_nac
+      {Intrinsic::hexagon_S2_asl_r_r_or, 27488}, // __builtin_HEXAGON_S2_asl_r_r_or
+      {Intrinsic::hexagon_S2_asl_r_r_sat, 27520}, // __builtin_HEXAGON_S2_asl_r_r_sat
+      {Intrinsic::hexagon_S2_asl_r_vh, 27553}, // __builtin_HEXAGON_S2_asl_r_vh
+      {Intrinsic::hexagon_S2_asl_r_vw, 27583}, // __builtin_HEXAGON_S2_asl_r_vw
+      {Intrinsic::hexagon_S2_asr_i_p, 27613}, // __builtin_HEXAGON_S2_asr_i_p
+      {Intrinsic::hexagon_S2_asr_i_p_acc, 27642}, // __builtin_HEXAGON_S2_asr_i_p_acc
+      {Intrinsic::hexagon_S2_asr_i_p_and, 27675}, // __builtin_HEXAGON_S2_asr_i_p_and
+      {Intrinsic::hexagon_S2_asr_i_p_nac, 27708}, // __builtin_HEXAGON_S2_asr_i_p_nac
+      {Intrinsic::hexagon_S2_asr_i_p_or, 27741}, // __builtin_HEXAGON_S2_asr_i_p_or
+      {Intrinsic::hexagon_S2_asr_i_p_rnd, 27773}, // __builtin_HEXAGON_S2_asr_i_p_rnd
+      {Intrinsic::hexagon_S2_asr_i_p_rnd_goodsyntax, 27806}, // __builtin_HEXAGON_S2_asr_i_p_rnd_goodsyntax
+      {Intrinsic::hexagon_S2_asr_i_r, 27850}, // __builtin_HEXAGON_S2_asr_i_r
+      {Intrinsic::hexagon_S2_asr_i_r_acc, 27879}, // __builtin_HEXAGON_S2_asr_i_r_acc
+      {Intrinsic::hexagon_S2_asr_i_r_and, 27912}, // __builtin_HEXAGON_S2_asr_i_r_and
+      {Intrinsic::hexagon_S2_asr_i_r_nac, 27945}, // __builtin_HEXAGON_S2_asr_i_r_nac
+      {Intrinsic::hexagon_S2_asr_i_r_or, 27978}, // __builtin_HEXAGON_S2_asr_i_r_or
+      {Intrinsic::hexagon_S2_asr_i_r_rnd, 28010}, // __builtin_HEXAGON_S2_asr_i_r_rnd
+      {Intrinsic::hexagon_S2_asr_i_r_rnd_goodsyntax, 28043}, // __builtin_HEXAGON_S2_asr_i_r_rnd_goodsyntax
+      {Intrinsic::hexagon_S2_asr_i_svw_trun, 28087}, // __builtin_HEXAGON_S2_asr_i_svw_trun
+      {Intrinsic::hexagon_S2_asr_i_vh, 28123}, // __builtin_HEXAGON_S2_asr_i_vh
+      {Intrinsic::hexagon_S2_asr_i_vw, 28153}, // __builtin_HEXAGON_S2_asr_i_vw
+      {Intrinsic::hexagon_S2_asr_r_p, 28183}, // __builtin_HEXAGON_S2_asr_r_p
+      {Intrinsic::hexagon_S2_asr_r_p_acc, 28212}, // __builtin_HEXAGON_S2_asr_r_p_acc
+      {Intrinsic::hexagon_S2_asr_r_p_and, 28245}, // __builtin_HEXAGON_S2_asr_r_p_and
+      {Intrinsic::hexagon_S2_asr_r_p_nac, 28278}, // __builtin_HEXAGON_S2_asr_r_p_nac
+      {Intrinsic::hexagon_S2_asr_r_p_or, 28311}, // __builtin_HEXAGON_S2_asr_r_p_or
+      {Intrinsic::hexagon_S2_asr_r_p_xor, 28343}, // __builtin_HEXAGON_S2_asr_r_p_xor
+      {Intrinsic::hexagon_S2_asr_r_r, 28376}, // __builtin_HEXAGON_S2_asr_r_r
+      {Intrinsic::hexagon_S2_asr_r_r_acc, 28405}, // __builtin_HEXAGON_S2_asr_r_r_acc
+      {Intrinsic::hexagon_S2_asr_r_r_and, 28438}, // __builtin_HEXAGON_S2_asr_r_r_and
+      {Intrinsic::hexagon_S2_asr_r_r_nac, 28471}, // __builtin_HEXAGON_S2_asr_r_r_nac
+      {Intrinsic::hexagon_S2_asr_r_r_or, 28504}, // __builtin_HEXAGON_S2_asr_r_r_or
+      {Intrinsic::hexagon_S2_asr_r_r_sat, 28536}, // __builtin_HEXAGON_S2_asr_r_r_sat
+      {Intrinsic::hexagon_S2_asr_r_svw_trun, 28569}, // __builtin_HEXAGON_S2_asr_r_svw_trun
+      {Intrinsic::hexagon_S2_asr_r_vh, 28605}, // __builtin_HEXAGON_S2_asr_r_vh
+      {Intrinsic::hexagon_S2_asr_r_vw, 28635}, // __builtin_HEXAGON_S2_asr_r_vw
+      {Intrinsic::hexagon_S2_brev, 28665}, // __builtin_HEXAGON_S2_brev
+      {Intrinsic::hexagon_S2_brevp, 28691}, // __builtin_HEXAGON_S2_brevp
+      {Intrinsic::hexagon_S2_cl0, 28718}, // __builtin_HEXAGON_S2_cl0
+      {Intrinsic::hexagon_S2_cl0p, 28743}, // __builtin_HEXAGON_S2_cl0p
+      {Intrinsic::hexagon_S2_cl1, 28769}, // __builtin_HEXAGON_S2_cl1
+      {Intrinsic::hexagon_S2_cl1p, 28794}, // __builtin_HEXAGON_S2_cl1p
+      {Intrinsic::hexagon_S2_clb, 28820}, // __builtin_HEXAGON_S2_clb
+      {Intrinsic::hexagon_S2_clbnorm, 28845}, // __builtin_HEXAGON_S2_clbnorm
+      {Intrinsic::hexagon_S2_clbp, 28874}, // __builtin_HEXAGON_S2_clbp
+      {Intrinsic::hexagon_S2_clrbit_i, 28900}, // __builtin_HEXAGON_S2_clrbit_i
+      {Intrinsic::hexagon_S2_clrbit_r, 28930}, // __builtin_HEXAGON_S2_clrbit_r
+      {Intrinsic::hexagon_S2_ct0, 28960}, // __builtin_HEXAGON_S2_ct0
+      {Intrinsic::hexagon_S2_ct0p, 28985}, // __builtin_HEXAGON_S2_ct0p
+      {Intrinsic::hexagon_S2_ct1, 29011}, // __builtin_HEXAGON_S2_ct1
+      {Intrinsic::hexagon_S2_ct1p, 29036}, // __builtin_HEXAGON_S2_ct1p
+      {Intrinsic::hexagon_S2_deinterleave, 29062}, // __builtin_HEXAGON_S2_deinterleave
+      {Intrinsic::hexagon_S2_extractu, 29096}, // __builtin_HEXAGON_S2_extractu
+      {Intrinsic::hexagon_S2_extractu_rp, 29126}, // __builtin_HEXAGON_S2_extractu_rp
+      {Intrinsic::hexagon_S2_extractup, 29159}, // __builtin_HEXAGON_S2_extractup
+      {Intrinsic::hexagon_S2_extractup_rp, 29190}, // __builtin_HEXAGON_S2_extractup_rp
+      {Intrinsic::hexagon_S2_insert, 29224}, // __builtin_HEXAGON_S2_insert
+      {Intrinsic::hexagon_S2_insert_rp, 29252}, // __builtin_HEXAGON_S2_insert_rp
+      {Intrinsic::hexagon_S2_insertp, 29283}, // __builtin_HEXAGON_S2_insertp
+      {Intrinsic::hexagon_S2_insertp_rp, 29312}, // __builtin_HEXAGON_S2_insertp_rp
+      {Intrinsic::hexagon_S2_interleave, 29344}, // __builtin_HEXAGON_S2_interleave
+      {Intrinsic::hexagon_S2_lfsp, 29376}, // __builtin_HEXAGON_S2_lfsp
+      {Intrinsic::hexagon_S2_lsl_r_p, 29402}, // __builtin_HEXAGON_S2_lsl_r_p
+      {Intrinsic::hexagon_S2_lsl_r_p_acc, 29431}, // __builtin_HEXAGON_S2_lsl_r_p_acc
+      {Intrinsic::hexagon_S2_lsl_r_p_and, 29464}, // __builtin_HEXAGON_S2_lsl_r_p_and
+      {Intrinsic::hexagon_S2_lsl_r_p_nac, 29497}, // __builtin_HEXAGON_S2_lsl_r_p_nac
+      {Intrinsic::hexagon_S2_lsl_r_p_or, 29530}, // __builtin_HEXAGON_S2_lsl_r_p_or
+      {Intrinsic::hexagon_S2_lsl_r_p_xor, 29562}, // __builtin_HEXAGON_S2_lsl_r_p_xor
+      {Intrinsic::hexagon_S2_lsl_r_r, 29595}, // __builtin_HEXAGON_S2_lsl_r_r
+      {Intrinsic::hexagon_S2_lsl_r_r_acc, 29624}, // __builtin_HEXAGON_S2_lsl_r_r_acc
+      {Intrinsic::hexagon_S2_lsl_r_r_and, 29657}, // __builtin_HEXAGON_S2_lsl_r_r_and
+      {Intrinsic::hexagon_S2_lsl_r_r_nac, 29690}, // __builtin_HEXAGON_S2_lsl_r_r_nac
+      {Intrinsic::hexagon_S2_lsl_r_r_or, 29723}, // __builtin_HEXAGON_S2_lsl_r_r_or
+      {Intrinsic::hexagon_S2_lsl_r_vh, 29755}, // __builtin_HEXAGON_S2_lsl_r_vh
+      {Intrinsic::hexagon_S2_lsl_r_vw, 29785}, // __builtin_HEXAGON_S2_lsl_r_vw
+      {Intrinsic::hexagon_S2_lsr_i_p, 29815}, // __builtin_HEXAGON_S2_lsr_i_p
+      {Intrinsic::hexagon_S2_lsr_i_p_acc, 29844}, // __builtin_HEXAGON_S2_lsr_i_p_acc
+      {Intrinsic::hexagon_S2_lsr_i_p_and, 29877}, // __builtin_HEXAGON_S2_lsr_i_p_and
+      {Intrinsic::hexagon_S2_lsr_i_p_nac, 29910}, // __builtin_HEXAGON_S2_lsr_i_p_nac
+      {Intrinsic::hexagon_S2_lsr_i_p_or, 29943}, // __builtin_HEXAGON_S2_lsr_i_p_or
+      {Intrinsic::hexagon_S2_lsr_i_p_xacc, 29975}, // __builtin_HEXAGON_S2_lsr_i_p_xacc
+      {Intrinsic::hexagon_S2_lsr_i_r, 30009}, // __builtin_HEXAGON_S2_lsr_i_r
+      {Intrinsic::hexagon_S2_lsr_i_r_acc, 30038}, // __builtin_HEXAGON_S2_lsr_i_r_acc
+      {Intrinsic::hexagon_S2_lsr_i_r_and, 30071}, // __builtin_HEXAGON_S2_lsr_i_r_and
+      {Intrinsic::hexagon_S2_lsr_i_r_nac, 30104}, // __builtin_HEXAGON_S2_lsr_i_r_nac
+      {Intrinsic::hexagon_S2_lsr_i_r_or, 30137}, // __builtin_HEXAGON_S2_lsr_i_r_or
+      {Intrinsic::hexagon_S2_lsr_i_r_xacc, 30169}, // __builtin_HEXAGON_S2_lsr_i_r_xacc
+      {Intrinsic::hexagon_S2_lsr_i_vh, 30203}, // __builtin_HEXAGON_S2_lsr_i_vh
+      {Intrinsic::hexagon_S2_lsr_i_vw, 30233}, // __builtin_HEXAGON_S2_lsr_i_vw
+      {Intrinsic::hexagon_S2_lsr_r_p, 30263}, // __builtin_HEXAGON_S2_lsr_r_p
+      {Intrinsic::hexagon_S2_lsr_r_p_acc, 30292}, // __builtin_HEXAGON_S2_lsr_r_p_acc
+      {Intrinsic::hexagon_S2_lsr_r_p_and, 30325}, // __builtin_HEXAGON_S2_lsr_r_p_and
+      {Intrinsic::hexagon_S2_lsr_r_p_nac, 30358}, // __builtin_HEXAGON_S2_lsr_r_p_nac
+      {Intrinsic::hexagon_S2_lsr_r_p_or, 30391}, // __builtin_HEXAGON_S2_lsr_r_p_or
+      {Intrinsic::hexagon_S2_lsr_r_p_xor, 30423}, // __builtin_HEXAGON_S2_lsr_r_p_xor
+      {Intrinsic::hexagon_S2_lsr_r_r, 30456}, // __builtin_HEXAGON_S2_lsr_r_r
+      {Intrinsic::hexagon_S2_lsr_r_r_acc, 30485}, // __builtin_HEXAGON_S2_lsr_r_r_acc
+      {Intrinsic::hexagon_S2_lsr_r_r_and, 30518}, // __builtin_HEXAGON_S2_lsr_r_r_and
+      {Intrinsic::hexagon_S2_lsr_r_r_nac, 30551}, // __builtin_HEXAGON_S2_lsr_r_r_nac
+      {Intrinsic::hexagon_S2_lsr_r_r_or, 30584}, // __builtin_HEXAGON_S2_lsr_r_r_or
+      {Intrinsic::hexagon_S2_lsr_r_vh, 30616}, // __builtin_HEXAGON_S2_lsr_r_vh
+      {Intrinsic::hexagon_S2_lsr_r_vw, 30646}, // __builtin_HEXAGON_S2_lsr_r_vw
+      {Intrinsic::hexagon_S2_mask, 30676}, // __builtin_HEXAGON_S2_mask
+      {Intrinsic::hexagon_S2_packhl, 30702}, // __builtin_HEXAGON_S2_packhl
+      {Intrinsic::hexagon_S2_parityp, 30730}, // __builtin_HEXAGON_S2_parityp
+      {Intrinsic::hexagon_S2_setbit_i, 30759}, // __builtin_HEXAGON_S2_setbit_i
+      {Intrinsic::hexagon_S2_setbit_r, 30789}, // __builtin_HEXAGON_S2_setbit_r
+      {Intrinsic::hexagon_S2_shuffeb, 30819}, // __builtin_HEXAGON_S2_shuffeb
+      {Intrinsic::hexagon_S2_shuffeh, 30848}, // __builtin_HEXAGON_S2_shuffeh
+      {Intrinsic::hexagon_S2_shuffob, 30877}, // __builtin_HEXAGON_S2_shuffob
+      {Intrinsic::hexagon_S2_shuffoh, 30906}, // __builtin_HEXAGON_S2_shuffoh
+      {Intrinsic::hexagon_S2_storew_locked, 31032}, // __builtin_HEXAGON_S2_storew_locked
+      {Intrinsic::hexagon_S2_svsathb, 31067}, // __builtin_HEXAGON_S2_svsathb
+      {Intrinsic::hexagon_S2_svsathub, 31096}, // __builtin_HEXAGON_S2_svsathub
+      {Intrinsic::hexagon_S2_tableidxb_goodsyntax, 31126}, // __builtin_HEXAGON_S2_tableidxb_goodsyntax
+      {Intrinsic::hexagon_S2_tableidxd_goodsyntax, 31168}, // __builtin_HEXAGON_S2_tableidxd_goodsyntax
+      {Intrinsic::hexagon_S2_tableidxh_goodsyntax, 31210}, // __builtin_HEXAGON_S2_tableidxh_goodsyntax
+      {Intrinsic::hexagon_S2_tableidxw_goodsyntax, 31252}, // __builtin_HEXAGON_S2_tableidxw_goodsyntax
+      {Intrinsic::hexagon_S2_togglebit_i, 31294}, // __builtin_HEXAGON_S2_togglebit_i
+      {Intrinsic::hexagon_S2_togglebit_r, 31327}, // __builtin_HEXAGON_S2_togglebit_r
+      {Intrinsic::hexagon_S2_tstbit_i, 31360}, // __builtin_HEXAGON_S2_tstbit_i
+      {Intrinsic::hexagon_S2_tstbit_r, 31390}, // __builtin_HEXAGON_S2_tstbit_r
+      {Intrinsic::hexagon_S2_valignib, 31420}, // __builtin_HEXAGON_S2_valignib
+      {Intrinsic::hexagon_S2_valignrb, 31450}, // __builtin_HEXAGON_S2_valignrb
+      {Intrinsic::hexagon_S2_vcnegh, 31480}, // __builtin_HEXAGON_S2_vcnegh
+      {Intrinsic::hexagon_S2_vcrotate, 31508}, // __builtin_HEXAGON_S2_vcrotate
+      {Intrinsic::hexagon_S2_vrcnegh, 31538}, // __builtin_HEXAGON_S2_vrcnegh
+      {Intrinsic::hexagon_S2_vrndpackwh, 31567}, // __builtin_HEXAGON_S2_vrndpackwh
+      {Intrinsic::hexagon_S2_vrndpackwhs, 31599}, // __builtin_HEXAGON_S2_vrndpackwhs
+      {Intrinsic::hexagon_S2_vsathb, 31632}, // __builtin_HEXAGON_S2_vsathb
+      {Intrinsic::hexagon_S2_vsathb_nopack, 31660}, // __builtin_HEXAGON_S2_vsathb_nopack
+      {Intrinsic::hexagon_S2_vsathub, 31695}, // __builtin_HEXAGON_S2_vsathub
+      {Intrinsic::hexagon_S2_vsathub_nopack, 31724}, // __builtin_HEXAGON_S2_vsathub_nopack
+      {Intrinsic::hexagon_S2_vsatwh, 31760}, // __builtin_HEXAGON_S2_vsatwh
+      {Intrinsic::hexagon_S2_vsatwh_nopack, 31788}, // __builtin_HEXAGON_S2_vsatwh_nopack
+      {Intrinsic::hexagon_S2_vsatwuh, 31823}, // __builtin_HEXAGON_S2_vsatwuh
+      {Intrinsic::hexagon_S2_vsatwuh_nopack, 31852}, // __builtin_HEXAGON_S2_vsatwuh_nopack
+      {Intrinsic::hexagon_S2_vsplatrb, 31888}, // __builtin_HEXAGON_S2_vsplatrb
+      {Intrinsic::hexagon_S2_vsplatrh, 31918}, // __builtin_HEXAGON_S2_vsplatrh
+      {Intrinsic::hexagon_S2_vspliceib, 31948}, // __builtin_HEXAGON_S2_vspliceib
+      {Intrinsic::hexagon_S2_vsplicerb, 31979}, // __builtin_HEXAGON_S2_vsplicerb
+      {Intrinsic::hexagon_S2_vsxtbh, 32010}, // __builtin_HEXAGON_S2_vsxtbh
+      {Intrinsic::hexagon_S2_vsxthw, 32038}, // __builtin_HEXAGON_S2_vsxthw
+      {Intrinsic::hexagon_S2_vtrunehb, 32066}, // __builtin_HEXAGON_S2_vtrunehb
+      {Intrinsic::hexagon_S2_vtrunewh, 32096}, // __builtin_HEXAGON_S2_vtrunewh
+      {Intrinsic::hexagon_S2_vtrunohb, 32126}, // __builtin_HEXAGON_S2_vtrunohb
+      {Intrinsic::hexagon_S2_vtrunowh, 32156}, // __builtin_HEXAGON_S2_vtrunowh
+      {Intrinsic::hexagon_S2_vzxtbh, 32186}, // __builtin_HEXAGON_S2_vzxtbh
+      {Intrinsic::hexagon_S2_vzxthw, 32214}, // __builtin_HEXAGON_S2_vzxthw
+      {Intrinsic::hexagon_S4_addaddi, 32242}, // __builtin_HEXAGON_S4_addaddi
+      {Intrinsic::hexagon_S4_addi_asl_ri, 32271}, // __builtin_HEXAGON_S4_addi_asl_ri
+      {Intrinsic::hexagon_S4_addi_lsr_ri, 32304}, // __builtin_HEXAGON_S4_addi_lsr_ri
+      {Intrinsic::hexagon_S4_andi_asl_ri, 32337}, // __builtin_HEXAGON_S4_andi_asl_ri
+      {Intrinsic::hexagon_S4_andi_lsr_ri, 32370}, // __builtin_HEXAGON_S4_andi_lsr_ri
+      {Intrinsic::hexagon_S4_clbaddi, 32403}, // __builtin_HEXAGON_S4_clbaddi
+      {Intrinsic::hexagon_S4_clbpaddi, 32432}, // __builtin_HEXAGON_S4_clbpaddi
+      {Intrinsic::hexagon_S4_clbpnorm, 32462}, // __builtin_HEXAGON_S4_clbpnorm
+      {Intrinsic::hexagon_S4_extract, 32492}, // __builtin_HEXAGON_S4_extract
+      {Intrinsic::hexagon_S4_extract_rp, 32521}, // __builtin_HEXAGON_S4_extract_rp
+      {Intrinsic::hexagon_S4_extractp, 32553}, // __builtin_HEXAGON_S4_extractp
+      {Intrinsic::hexagon_S4_extractp_rp, 32583}, // __builtin_HEXAGON_S4_extractp_rp
+      {Intrinsic::hexagon_S4_lsli, 32616}, // __builtin_HEXAGON_S4_lsli
+      {Intrinsic::hexagon_S4_ntstbit_i, 32642}, // __builtin_HEXAGON_S4_ntstbit_i
+      {Intrinsic::hexagon_S4_ntstbit_r, 32673}, // __builtin_HEXAGON_S4_ntstbit_r
+      {Intrinsic::hexagon_S4_or_andi, 32704}, // __builtin_HEXAGON_S4_or_andi
+      {Intrinsic::hexagon_S4_or_andix, 32733}, // __builtin_HEXAGON_S4_or_andix
+      {Intrinsic::hexagon_S4_or_ori, 32763}, // __builtin_HEXAGON_S4_or_ori
+      {Intrinsic::hexagon_S4_ori_asl_ri, 32791}, // __builtin_HEXAGON_S4_ori_asl_ri
+      {Intrinsic::hexagon_S4_ori_lsr_ri, 32823}, // __builtin_HEXAGON_S4_ori_lsr_ri
+      {Intrinsic::hexagon_S4_parity, 32855}, // __builtin_HEXAGON_S4_parity
+      {Intrinsic::hexagon_S4_stored_locked, 32883}, // __builtin_HEXAGON_S4_stored_locked
+      {Intrinsic::hexagon_S4_subaddi, 32918}, // __builtin_HEXAGON_S4_subaddi
+      {Intrinsic::hexagon_S4_subi_asl_ri, 32947}, // __builtin_HEXAGON_S4_subi_asl_ri
+      {Intrinsic::hexagon_S4_subi_lsr_ri, 32980}, // __builtin_HEXAGON_S4_subi_lsr_ri
+      {Intrinsic::hexagon_S4_vrcrotate, 33013}, // __builtin_HEXAGON_S4_vrcrotate
+      {Intrinsic::hexagon_S4_vrcrotate_acc, 33044}, // __builtin_HEXAGON_S4_vrcrotate_acc
+      {Intrinsic::hexagon_S4_vxaddsubh, 33079}, // __builtin_HEXAGON_S4_vxaddsubh
+      {Intrinsic::hexagon_S4_vxaddsubhr, 33110}, // __builtin_HEXAGON_S4_vxaddsubhr
+      {Intrinsic::hexagon_S4_vxaddsubw, 33142}, // __builtin_HEXAGON_S4_vxaddsubw
+      {Intrinsic::hexagon_S4_vxsubaddh, 33173}, // __builtin_HEXAGON_S4_vxsubaddh
+      {Intrinsic::hexagon_S4_vxsubaddhr, 33204}, // __builtin_HEXAGON_S4_vxsubaddhr
+      {Intrinsic::hexagon_S4_vxsubaddw, 33236}, // __builtin_HEXAGON_S4_vxsubaddw
+      {Intrinsic::hexagon_S5_asrhub_rnd_sat_goodsyntax, 33267}, // __builtin_HEXAGON_S5_asrhub_rnd_sat_goodsyntax
+      {Intrinsic::hexagon_S5_asrhub_sat, 33314}, // __builtin_HEXAGON_S5_asrhub_sat
+      {Intrinsic::hexagon_S5_popcountp, 33346}, // __builtin_HEXAGON_S5_popcountp
+      {Intrinsic::hexagon_S5_vasrhrnd_goodsyntax, 33377}, // __builtin_HEXAGON_S5_vasrhrnd_goodsyntax
+      {Intrinsic::hexagon_S6_rol_i_p, 33418}, // __builtin_HEXAGON_S6_rol_i_p
+      {Intrinsic::hexagon_S6_rol_i_p_acc, 33447}, // __builtin_HEXAGON_S6_rol_i_p_acc
+      {Intrinsic::hexagon_S6_rol_i_p_and, 33480}, // __builtin_HEXAGON_S6_rol_i_p_and
+      {Intrinsic::hexagon_S6_rol_i_p_nac, 33513}, // __builtin_HEXAGON_S6_rol_i_p_nac
+      {Intrinsic::hexagon_S6_rol_i_p_or, 33546}, // __builtin_HEXAGON_S6_rol_i_p_or
+      {Intrinsic::hexagon_S6_rol_i_p_xacc, 33578}, // __builtin_HEXAGON_S6_rol_i_p_xacc
+      {Intrinsic::hexagon_S6_rol_i_r, 33612}, // __builtin_HEXAGON_S6_rol_i_r
+      {Intrinsic::hexagon_S6_rol_i_r_acc, 33641}, // __builtin_HEXAGON_S6_rol_i_r_acc
+      {Intrinsic::hexagon_S6_rol_i_r_and, 33674}, // __builtin_HEXAGON_S6_rol_i_r_and
+      {Intrinsic::hexagon_S6_rol_i_r_nac, 33707}, // __builtin_HEXAGON_S6_rol_i_r_nac
+      {Intrinsic::hexagon_S6_rol_i_r_or, 33740}, // __builtin_HEXAGON_S6_rol_i_r_or
+      {Intrinsic::hexagon_S6_rol_i_r_xacc, 33772}, // __builtin_HEXAGON_S6_rol_i_r_xacc
+      {Intrinsic::hexagon_S6_vsplatrbp, 33806}, // __builtin_HEXAGON_S6_vsplatrbp
+      {Intrinsic::hexagon_S6_vtrunehb_ppp, 33837}, // __builtin_HEXAGON_S6_vtrunehb_ppp
+      {Intrinsic::hexagon_S6_vtrunohb_ppp, 33871}, // __builtin_HEXAGON_S6_vtrunohb_ppp
+      {Intrinsic::hexagon_V6_extractw, 33905}, // __builtin_HEXAGON_V6_extractw
+      {Intrinsic::hexagon_V6_extractw_128B, 33935}, // __builtin_HEXAGON_V6_extractw_128B
+      {Intrinsic::hexagon_V6_hi, 33970}, // __builtin_HEXAGON_V6_hi
+      {Intrinsic::hexagon_V6_hi_128B, 33994}, // __builtin_HEXAGON_V6_hi_128B
+      {Intrinsic::hexagon_V6_lo, 34023}, // __builtin_HEXAGON_V6_lo
+      {Intrinsic::hexagon_V6_lo_128B, 34047}, // __builtin_HEXAGON_V6_lo_128B
+      {Intrinsic::hexagon_V6_lvsplatb, 34076}, // __builtin_HEXAGON_V6_lvsplatb
+      {Intrinsic::hexagon_V6_lvsplatb_128B, 34106}, // __builtin_HEXAGON_V6_lvsplatb_128B
+      {Intrinsic::hexagon_V6_lvsplath, 34141}, // __builtin_HEXAGON_V6_lvsplath
+      {Intrinsic::hexagon_V6_lvsplath_128B, 34171}, // __builtin_HEXAGON_V6_lvsplath_128B
+      {Intrinsic::hexagon_V6_lvsplatw, 34206}, // __builtin_HEXAGON_V6_lvsplatw
+      {Intrinsic::hexagon_V6_lvsplatw_128B, 34236}, // __builtin_HEXAGON_V6_lvsplatw_128B
+      {Intrinsic::hexagon_V6_vabsb, 34271}, // __builtin_HEXAGON_V6_vabsb
+      {Intrinsic::hexagon_V6_vabsb_128B, 34298}, // __builtin_HEXAGON_V6_vabsb_128B
+      {Intrinsic::hexagon_V6_vabsb_sat, 34330}, // __builtin_HEXAGON_V6_vabsb_sat
+      {Intrinsic::hexagon_V6_vabsb_sat_128B, 34361}, // __builtin_HEXAGON_V6_vabsb_sat_128B
+      {Intrinsic::hexagon_V6_vabsdiffh, 34397}, // __builtin_HEXAGON_V6_vabsdiffh
+      {Intrinsic::hexagon_V6_vabsdiffh_128B, 34428}, // __builtin_HEXAGON_V6_vabsdiffh_128B
+      {Intrinsic::hexagon_V6_vabsdiffub, 34464}, // __builtin_HEXAGON_V6_vabsdiffub
+      {Intrinsic::hexagon_V6_vabsdiffub_128B, 34496}, // __builtin_HEXAGON_V6_vabsdiffub_128B
+      {Intrinsic::hexagon_V6_vabsdiffuh, 34533}, // __builtin_HEXAGON_V6_vabsdiffuh
+      {Intrinsic::hexagon_V6_vabsdiffuh_128B, 34565}, // __builtin_HEXAGON_V6_vabsdiffuh_128B
+      {Intrinsic::hexagon_V6_vabsdiffw, 34602}, // __builtin_HEXAGON_V6_vabsdiffw
+      {Intrinsic::hexagon_V6_vabsdiffw_128B, 34633}, // __builtin_HEXAGON_V6_vabsdiffw_128B
+      {Intrinsic::hexagon_V6_vabsh, 34669}, // __builtin_HEXAGON_V6_vabsh
+      {Intrinsic::hexagon_V6_vabsh_128B, 34696}, // __builtin_HEXAGON_V6_vabsh_128B
+      {Intrinsic::hexagon_V6_vabsh_sat, 34728}, // __builtin_HEXAGON_V6_vabsh_sat
+      {Intrinsic::hexagon_V6_vabsh_sat_128B, 34759}, // __builtin_HEXAGON_V6_vabsh_sat_128B
+      {Intrinsic::hexagon_V6_vabsw, 34795}, // __builtin_HEXAGON_V6_vabsw
+      {Intrinsic::hexagon_V6_vabsw_128B, 34822}, // __builtin_HEXAGON_V6_vabsw_128B
+      {Intrinsic::hexagon_V6_vabsw_sat, 34854}, // __builtin_HEXAGON_V6_vabsw_sat
+      {Intrinsic::hexagon_V6_vabsw_sat_128B, 34885}, // __builtin_HEXAGON_V6_vabsw_sat_128B
+      {Intrinsic::hexagon_V6_vaddb, 34921}, // __builtin_HEXAGON_V6_vaddb
+      {Intrinsic::hexagon_V6_vaddb_128B, 34948}, // __builtin_HEXAGON_V6_vaddb_128B
+      {Intrinsic::hexagon_V6_vaddb_dv, 34980}, // __builtin_HEXAGON_V6_vaddb_dv
+      {Intrinsic::hexagon_V6_vaddb_dv_128B, 35010}, // __builtin_HEXAGON_V6_vaddb_dv_128B
+      {Intrinsic::hexagon_V6_vaddbsat, 35045}, // __builtin_HEXAGON_V6_vaddbsat
+      {Intrinsic::hexagon_V6_vaddbsat_128B, 35075}, // __builtin_HEXAGON_V6_vaddbsat_128B
+      {Intrinsic::hexagon_V6_vaddbsat_dv, 35110}, // __builtin_HEXAGON_V6_vaddbsat_dv
+      {Intrinsic::hexagon_V6_vaddbsat_dv_128B, 35143}, // __builtin_HEXAGON_V6_vaddbsat_dv_128B
+      {Intrinsic::hexagon_V6_vaddclbh, 35181}, // __builtin_HEXAGON_V6_vaddclbh
+      {Intrinsic::hexagon_V6_vaddclbh_128B, 35211}, // __builtin_HEXAGON_V6_vaddclbh_128B
+      {Intrinsic::hexagon_V6_vaddclbw, 35246}, // __builtin_HEXAGON_V6_vaddclbw
+      {Intrinsic::hexagon_V6_vaddclbw_128B, 35276}, // __builtin_HEXAGON_V6_vaddclbw_128B
+      {Intrinsic::hexagon_V6_vaddh, 35311}, // __builtin_HEXAGON_V6_vaddh
+      {Intrinsic::hexagon_V6_vaddh_128B, 35338}, // __builtin_HEXAGON_V6_vaddh_128B
+      {Intrinsic::hexagon_V6_vaddh_dv, 35370}, // __builtin_HEXAGON_V6_vaddh_dv
+      {Intrinsic::hexagon_V6_vaddh_dv_128B, 35400}, // __builtin_HEXAGON_V6_vaddh_dv_128B
+      {Intrinsic::hexagon_V6_vaddhsat, 35435}, // __builtin_HEXAGON_V6_vaddhsat
+      {Intrinsic::hexagon_V6_vaddhsat_128B, 35465}, // __builtin_HEXAGON_V6_vaddhsat_128B
+      {Intrinsic::hexagon_V6_vaddhsat_dv, 35500}, // __builtin_HEXAGON_V6_vaddhsat_dv
+      {Intrinsic::hexagon_V6_vaddhsat_dv_128B, 35533}, // __builtin_HEXAGON_V6_vaddhsat_dv_128B
+      {Intrinsic::hexagon_V6_vaddhw, 35571}, // __builtin_HEXAGON_V6_vaddhw
+      {Intrinsic::hexagon_V6_vaddhw_128B, 35599}, // __builtin_HEXAGON_V6_vaddhw_128B
+      {Intrinsic::hexagon_V6_vaddhw_acc, 35632}, // __builtin_HEXAGON_V6_vaddhw_acc
+      {Intrinsic::hexagon_V6_vaddhw_acc_128B, 35664}, // __builtin_HEXAGON_V6_vaddhw_acc_128B
+      {Intrinsic::hexagon_V6_vaddubh, 35701}, // __builtin_HEXAGON_V6_vaddubh
+      {Intrinsic::hexagon_V6_vaddubh_128B, 35730}, // __builtin_HEXAGON_V6_vaddubh_128B
+      {Intrinsic::hexagon_V6_vaddubh_acc, 35764}, // __builtin_HEXAGON_V6_vaddubh_acc
+      {Intrinsic::hexagon_V6_vaddubh_acc_128B, 35797}, // __builtin_HEXAGON_V6_vaddubh_acc_128B
+      {Intrinsic::hexagon_V6_vaddubsat, 35835}, // __builtin_HEXAGON_V6_vaddubsat
+      {Intrinsic::hexagon_V6_vaddubsat_128B, 35866}, // __builtin_HEXAGON_V6_vaddubsat_128B
+      {Intrinsic::hexagon_V6_vaddubsat_dv, 35902}, // __builtin_HEXAGON_V6_vaddubsat_dv
+      {Intrinsic::hexagon_V6_vaddubsat_dv_128B, 35936}, // __builtin_HEXAGON_V6_vaddubsat_dv_128B
+      {Intrinsic::hexagon_V6_vaddububb_sat, 35975}, // __builtin_HEXAGON_V6_vaddububb_sat
+      {Intrinsic::hexagon_V6_vaddububb_sat_128B, 36010}, // __builtin_HEXAGON_V6_vaddububb_sat_128B
+      {Intrinsic::hexagon_V6_vadduhsat, 36050}, // __builtin_HEXAGON_V6_vadduhsat
+      {Intrinsic::hexagon_V6_vadduhsat_128B, 36081}, // __builtin_HEXAGON_V6_vadduhsat_128B
+      {Intrinsic::hexagon_V6_vadduhsat_dv, 36117}, // __builtin_HEXAGON_V6_vadduhsat_dv
+      {Intrinsic::hexagon_V6_vadduhsat_dv_128B, 36151}, // __builtin_HEXAGON_V6_vadduhsat_dv_128B
+      {Intrinsic::hexagon_V6_vadduhw, 36190}, // __builtin_HEXAGON_V6_vadduhw
+      {Intrinsic::hexagon_V6_vadduhw_128B, 36219}, // __builtin_HEXAGON_V6_vadduhw_128B
+      {Intrinsic::hexagon_V6_vadduhw_acc, 36253}, // __builtin_HEXAGON_V6_vadduhw_acc
+      {Intrinsic::hexagon_V6_vadduhw_acc_128B, 36286}, // __builtin_HEXAGON_V6_vadduhw_acc_128B
+      {Intrinsic::hexagon_V6_vadduwsat, 36324}, // __builtin_HEXAGON_V6_vadduwsat
+      {Intrinsic::hexagon_V6_vadduwsat_128B, 36355}, // __builtin_HEXAGON_V6_vadduwsat_128B
+      {Intrinsic::hexagon_V6_vadduwsat_dv, 36391}, // __builtin_HEXAGON_V6_vadduwsat_dv
+      {Intrinsic::hexagon_V6_vadduwsat_dv_128B, 36425}, // __builtin_HEXAGON_V6_vadduwsat_dv_128B
+      {Intrinsic::hexagon_V6_vaddw, 36464}, // __builtin_HEXAGON_V6_vaddw
+      {Intrinsic::hexagon_V6_vaddw_128B, 36491}, // __builtin_HEXAGON_V6_vaddw_128B
+      {Intrinsic::hexagon_V6_vaddw_dv, 36523}, // __builtin_HEXAGON_V6_vaddw_dv
+      {Intrinsic::hexagon_V6_vaddw_dv_128B, 36553}, // __builtin_HEXAGON_V6_vaddw_dv_128B
+      {Intrinsic::hexagon_V6_vaddwsat, 36588}, // __builtin_HEXAGON_V6_vaddwsat
+      {Intrinsic::hexagon_V6_vaddwsat_128B, 36618}, // __builtin_HEXAGON_V6_vaddwsat_128B
+      {Intrinsic::hexagon_V6_vaddwsat_dv, 36653}, // __builtin_HEXAGON_V6_vaddwsat_dv
+      {Intrinsic::hexagon_V6_vaddwsat_dv_128B, 36686}, // __builtin_HEXAGON_V6_vaddwsat_dv_128B
+      {Intrinsic::hexagon_V6_valignb, 36724}, // __builtin_HEXAGON_V6_valignb
+      {Intrinsic::hexagon_V6_valignb_128B, 36753}, // __builtin_HEXAGON_V6_valignb_128B
+      {Intrinsic::hexagon_V6_valignbi, 36787}, // __builtin_HEXAGON_V6_valignbi
+      {Intrinsic::hexagon_V6_valignbi_128B, 36817}, // __builtin_HEXAGON_V6_valignbi_128B
+      {Intrinsic::hexagon_V6_vand, 36852}, // __builtin_HEXAGON_V6_vand
+      {Intrinsic::hexagon_V6_vand_128B, 36878}, // __builtin_HEXAGON_V6_vand_128B
+      {Intrinsic::hexagon_V6_vaslh, 36909}, // __builtin_HEXAGON_V6_vaslh
+      {Intrinsic::hexagon_V6_vaslh_128B, 36936}, // __builtin_HEXAGON_V6_vaslh_128B
+      {Intrinsic::hexagon_V6_vaslh_acc, 36968}, // __builtin_HEXAGON_V6_vaslh_acc
+      {Intrinsic::hexagon_V6_vaslh_acc_128B, 36999}, // __builtin_HEXAGON_V6_vaslh_acc_128B
+      {Intrinsic::hexagon_V6_vaslhv, 37035}, // __builtin_HEXAGON_V6_vaslhv
+      {Intrinsic::hexagon_V6_vaslhv_128B, 37063}, // __builtin_HEXAGON_V6_vaslhv_128B
+      {Intrinsic::hexagon_V6_vaslw, 37096}, // __builtin_HEXAGON_V6_vaslw
+      {Intrinsic::hexagon_V6_vaslw_128B, 37123}, // __builtin_HEXAGON_V6_vaslw_128B
+      {Intrinsic::hexagon_V6_vaslw_acc, 37155}, // __builtin_HEXAGON_V6_vaslw_acc
+      {Intrinsic::hexagon_V6_vaslw_acc_128B, 37186}, // __builtin_HEXAGON_V6_vaslw_acc_128B
+      {Intrinsic::hexagon_V6_vaslwv, 37222}, // __builtin_HEXAGON_V6_vaslwv
+      {Intrinsic::hexagon_V6_vaslwv_128B, 37250}, // __builtin_HEXAGON_V6_vaslwv_128B
+      {Intrinsic::hexagon_V6_vasr_into, 37283}, // __builtin_HEXAGON_V6_vasr_into
+      {Intrinsic::hexagon_V6_vasr_into_128B, 37314}, // __builtin_HEXAGON_V6_vasr_into_128B
+      {Intrinsic::hexagon_V6_vasrh, 37350}, // __builtin_HEXAGON_V6_vasrh
+      {Intrinsic::hexagon_V6_vasrh_128B, 37377}, // __builtin_HEXAGON_V6_vasrh_128B
+      {Intrinsic::hexagon_V6_vasrh_acc, 37409}, // __builtin_HEXAGON_V6_vasrh_acc
+      {Intrinsic::hexagon_V6_vasrh_acc_128B, 37440}, // __builtin_HEXAGON_V6_vasrh_acc_128B
+      {Intrinsic::hexagon_V6_vasrhbrndsat, 37476}, // __builtin_HEXAGON_V6_vasrhbrndsat
+      {Intrinsic::hexagon_V6_vasrhbrndsat_128B, 37510}, // __builtin_HEXAGON_V6_vasrhbrndsat_128B
+      {Intrinsic::hexagon_V6_vasrhbsat, 37549}, // __builtin_HEXAGON_V6_vasrhbsat
+      {Intrinsic::hexagon_V6_vasrhbsat_128B, 37580}, // __builtin_HEXAGON_V6_vasrhbsat_128B
+      {Intrinsic::hexagon_V6_vasrhubrndsat, 37616}, // __builtin_HEXAGON_V6_vasrhubrndsat
+      {Intrinsic::hexagon_V6_vasrhubrndsat_128B, 37651}, // __builtin_HEXAGON_V6_vasrhubrndsat_128B
+      {Intrinsic::hexagon_V6_vasrhubsat, 37691}, // __builtin_HEXAGON_V6_vasrhubsat
+      {Intrinsic::hexagon_V6_vasrhubsat_128B, 37723}, // __builtin_HEXAGON_V6_vasrhubsat_128B
+      {Intrinsic::hexagon_V6_vasrhv, 37760}, // __builtin_HEXAGON_V6_vasrhv
+      {Intrinsic::hexagon_V6_vasrhv_128B, 37788}, // __builtin_HEXAGON_V6_vasrhv_128B
+      {Intrinsic::hexagon_V6_vasruhubrndsat, 37821}, // __builtin_HEXAGON_V6_vasruhubrndsat
+      {Intrinsic::hexagon_V6_vasruhubrndsat_128B, 37857}, // __builtin_HEXAGON_V6_vasruhubrndsat_128B
+      {Intrinsic::hexagon_V6_vasruhubsat, 37898}, // __builtin_HEXAGON_V6_vasruhubsat
+      {Intrinsic::hexagon_V6_vasruhubsat_128B, 37931}, // __builtin_HEXAGON_V6_vasruhubsat_128B
+      {Intrinsic::hexagon_V6_vasruwuhrndsat, 37969}, // __builtin_HEXAGON_V6_vasruwuhrndsat
+      {Intrinsic::hexagon_V6_vasruwuhrndsat_128B, 38005}, // __builtin_HEXAGON_V6_vasruwuhrndsat_128B
+      {Intrinsic::hexagon_V6_vasruwuhsat, 38046}, // __builtin_HEXAGON_V6_vasruwuhsat
+      {Intrinsic::hexagon_V6_vasruwuhsat_128B, 38079}, // __builtin_HEXAGON_V6_vasruwuhsat_128B
+      {Intrinsic::hexagon_V6_vasrw, 38117}, // __builtin_HEXAGON_V6_vasrw
+      {Intrinsic::hexagon_V6_vasrw_128B, 38144}, // __builtin_HEXAGON_V6_vasrw_128B
+      {Intrinsic::hexagon_V6_vasrw_acc, 38176}, // __builtin_HEXAGON_V6_vasrw_acc
+      {Intrinsic::hexagon_V6_vasrw_acc_128B, 38207}, // __builtin_HEXAGON_V6_vasrw_acc_128B
+      {Intrinsic::hexagon_V6_vasrwh, 38243}, // __builtin_HEXAGON_V6_vasrwh
+      {Intrinsic::hexagon_V6_vasrwh_128B, 38271}, // __builtin_HEXAGON_V6_vasrwh_128B
+      {Intrinsic::hexagon_V6_vasrwhrndsat, 38304}, // __builtin_HEXAGON_V6_vasrwhrndsat
+      {Intrinsic::hexagon_V6_vasrwhrndsat_128B, 38338}, // __builtin_HEXAGON_V6_vasrwhrndsat_128B
+      {Intrinsic::hexagon_V6_vasrwhsat, 38377}, // __builtin_HEXAGON_V6_vasrwhsat
+      {Intrinsic::hexagon_V6_vasrwhsat_128B, 38408}, // __builtin_HEXAGON_V6_vasrwhsat_128B
+      {Intrinsic::hexagon_V6_vasrwuhrndsat, 38444}, // __builtin_HEXAGON_V6_vasrwuhrndsat
+      {Intrinsic::hexagon_V6_vasrwuhrndsat_128B, 38479}, // __builtin_HEXAGON_V6_vasrwuhrndsat_128B
+      {Intrinsic::hexagon_V6_vasrwuhsat, 38519}, // __builtin_HEXAGON_V6_vasrwuhsat
+      {Intrinsic::hexagon_V6_vasrwuhsat_128B, 38551}, // __builtin_HEXAGON_V6_vasrwuhsat_128B
+      {Intrinsic::hexagon_V6_vasrwv, 38588}, // __builtin_HEXAGON_V6_vasrwv
+      {Intrinsic::hexagon_V6_vasrwv_128B, 38616}, // __builtin_HEXAGON_V6_vasrwv_128B
+      {Intrinsic::hexagon_V6_vassign, 38649}, // __builtin_HEXAGON_V6_vassign
+      {Intrinsic::hexagon_V6_vassign_128B, 38678}, // __builtin_HEXAGON_V6_vassign_128B
+      {Intrinsic::hexagon_V6_vassignp, 38712}, // __builtin_HEXAGON_V6_vassignp
+      {Intrinsic::hexagon_V6_vassignp_128B, 38742}, // __builtin_HEXAGON_V6_vassignp_128B
+      {Intrinsic::hexagon_V6_vavgb, 38777}, // __builtin_HEXAGON_V6_vavgb
+      {Intrinsic::hexagon_V6_vavgb_128B, 38804}, // __builtin_HEXAGON_V6_vavgb_128B
+      {Intrinsic::hexagon_V6_vavgbrnd, 38836}, // __builtin_HEXAGON_V6_vavgbrnd
+      {Intrinsic::hexagon_V6_vavgbrnd_128B, 38866}, // __builtin_HEXAGON_V6_vavgbrnd_128B
+      {Intrinsic::hexagon_V6_vavgh, 38901}, // __builtin_HEXAGON_V6_vavgh
+      {Intrinsic::hexagon_V6_vavgh_128B, 38928}, // __builtin_HEXAGON_V6_vavgh_128B
+      {Intrinsic::hexagon_V6_vavghrnd, 38960}, // __builtin_HEXAGON_V6_vavghrnd
+      {Intrinsic::hexagon_V6_vavghrnd_128B, 38990}, // __builtin_HEXAGON_V6_vavghrnd_128B
+      {Intrinsic::hexagon_V6_vavgub, 39025}, // __builtin_HEXAGON_V6_vavgub
+      {Intrinsic::hexagon_V6_vavgub_128B, 39053}, // __builtin_HEXAGON_V6_vavgub_128B
+      {Intrinsic::hexagon_V6_vavgubrnd, 39086}, // __builtin_HEXAGON_V6_vavgubrnd
+      {Intrinsic::hexagon_V6_vavgubrnd_128B, 39117}, // __builtin_HEXAGON_V6_vavgubrnd_128B
+      {Intrinsic::hexagon_V6_vavguh, 39153}, // __builtin_HEXAGON_V6_vavguh
+      {Intrinsic::hexagon_V6_vavguh_128B, 39181}, // __builtin_HEXAGON_V6_vavguh_128B
+      {Intrinsic::hexagon_V6_vavguhrnd, 39214}, // __builtin_HEXAGON_V6_vavguhrnd
+      {Intrinsic::hexagon_V6_vavguhrnd_128B, 39245}, // __builtin_HEXAGON_V6_vavguhrnd_128B
+      {Intrinsic::hexagon_V6_vavguw, 39281}, // __builtin_HEXAGON_V6_vavguw
+      {Intrinsic::hexagon_V6_vavguw_128B, 39309}, // __builtin_HEXAGON_V6_vavguw_128B
+      {Intrinsic::hexagon_V6_vavguwrnd, 39342}, // __builtin_HEXAGON_V6_vavguwrnd
+      {Intrinsic::hexagon_V6_vavguwrnd_128B, 39373}, // __builtin_HEXAGON_V6_vavguwrnd_128B
+      {Intrinsic::hexagon_V6_vavgw, 39409}, // __builtin_HEXAGON_V6_vavgw
+      {Intrinsic::hexagon_V6_vavgw_128B, 39436}, // __builtin_HEXAGON_V6_vavgw_128B
+      {Intrinsic::hexagon_V6_vavgwrnd, 39468}, // __builtin_HEXAGON_V6_vavgwrnd
+      {Intrinsic::hexagon_V6_vavgwrnd_128B, 39498}, // __builtin_HEXAGON_V6_vavgwrnd_128B
+      {Intrinsic::hexagon_V6_vcl0h, 39533}, // __builtin_HEXAGON_V6_vcl0h
+      {Intrinsic::hexagon_V6_vcl0h_128B, 39560}, // __builtin_HEXAGON_V6_vcl0h_128B
+      {Intrinsic::hexagon_V6_vcl0w, 39592}, // __builtin_HEXAGON_V6_vcl0w
+      {Intrinsic::hexagon_V6_vcl0w_128B, 39619}, // __builtin_HEXAGON_V6_vcl0w_128B
+      {Intrinsic::hexagon_V6_vcombine, 39651}, // __builtin_HEXAGON_V6_vcombine
+      {Intrinsic::hexagon_V6_vcombine_128B, 39681}, // __builtin_HEXAGON_V6_vcombine_128B
+      {Intrinsic::hexagon_V6_vd0, 39716}, // __builtin_HEXAGON_V6_vd0
+      {Intrinsic::hexagon_V6_vd0_128B, 39741}, // __builtin_HEXAGON_V6_vd0_128B
+      {Intrinsic::hexagon_V6_vdd0, 39771}, // __builtin_HEXAGON_V6_vdd0
+      {Intrinsic::hexagon_V6_vdd0_128B, 39797}, // __builtin_HEXAGON_V6_vdd0_128B
+      {Intrinsic::hexagon_V6_vdealb, 39828}, // __builtin_HEXAGON_V6_vdealb
+      {Intrinsic::hexagon_V6_vdealb4w, 39889}, // __builtin_HEXAGON_V6_vdealb4w
+      {Intrinsic::hexagon_V6_vdealb4w_128B, 39919}, // __builtin_HEXAGON_V6_vdealb4w_128B
+      {Intrinsic::hexagon_V6_vdealb_128B, 39856}, // __builtin_HEXAGON_V6_vdealb_128B
+      {Intrinsic::hexagon_V6_vdealh, 39954}, // __builtin_HEXAGON_V6_vdealh
+      {Intrinsic::hexagon_V6_vdealh_128B, 39982}, // __builtin_HEXAGON_V6_vdealh_128B
+      {Intrinsic::hexagon_V6_vdealvdd, 40015}, // __builtin_HEXAGON_V6_vdealvdd
+      {Intrinsic::hexagon_V6_vdealvdd_128B, 40045}, // __builtin_HEXAGON_V6_vdealvdd_128B
+      {Intrinsic::hexagon_V6_vdelta, 40080}, // __builtin_HEXAGON_V6_vdelta
+      {Intrinsic::hexagon_V6_vdelta_128B, 40108}, // __builtin_HEXAGON_V6_vdelta_128B
+      {Intrinsic::hexagon_V6_vdmpybus, 40141}, // __builtin_HEXAGON_V6_vdmpybus
+      {Intrinsic::hexagon_V6_vdmpybus_128B, 40171}, // __builtin_HEXAGON_V6_vdmpybus_128B
+      {Intrinsic::hexagon_V6_vdmpybus_acc, 40206}, // __builtin_HEXAGON_V6_vdmpybus_acc
+      {Intrinsic::hexagon_V6_vdmpybus_acc_128B, 40240}, // __builtin_HEXAGON_V6_vdmpybus_acc_128B
+      {Intrinsic::hexagon_V6_vdmpybus_dv, 40279}, // __builtin_HEXAGON_V6_vdmpybus_dv
+      {Intrinsic::hexagon_V6_vdmpybus_dv_128B, 40312}, // __builtin_HEXAGON_V6_vdmpybus_dv_128B
+      {Intrinsic::hexagon_V6_vdmpybus_dv_acc, 40350}, // __builtin_HEXAGON_V6_vdmpybus_dv_acc
+      {Intrinsic::hexagon_V6_vdmpybus_dv_acc_128B, 40387}, // __builtin_HEXAGON_V6_vdmpybus_dv_acc_128B
+      {Intrinsic::hexagon_V6_vdmpyhb, 40429}, // __builtin_HEXAGON_V6_vdmpyhb
+      {Intrinsic::hexagon_V6_vdmpyhb_128B, 40458}, // __builtin_HEXAGON_V6_vdmpyhb_128B
+      {Intrinsic::hexagon_V6_vdmpyhb_acc, 40492}, // __builtin_HEXAGON_V6_vdmpyhb_acc
+      {Intrinsic::hexagon_V6_vdmpyhb_acc_128B, 40525}, // __builtin_HEXAGON_V6_vdmpyhb_acc_128B
+      {Intrinsic::hexagon_V6_vdmpyhb_dv, 40563}, // __builtin_HEXAGON_V6_vdmpyhb_dv
+      {Intrinsic::hexagon_V6_vdmpyhb_dv_128B, 40595}, // __builtin_HEXAGON_V6_vdmpyhb_dv_128B
+      {Intrinsic::hexagon_V6_vdmpyhb_dv_acc, 40632}, // __builtin_HEXAGON_V6_vdmpyhb_dv_acc
+      {Intrinsic::hexagon_V6_vdmpyhb_dv_acc_128B, 40668}, // __builtin_HEXAGON_V6_vdmpyhb_dv_acc_128B
+      {Intrinsic::hexagon_V6_vdmpyhisat, 40709}, // __builtin_HEXAGON_V6_vdmpyhisat
+      {Intrinsic::hexagon_V6_vdmpyhisat_128B, 40741}, // __builtin_HEXAGON_V6_vdmpyhisat_128B
+      {Intrinsic::hexagon_V6_vdmpyhisat_acc, 40778}, // __builtin_HEXAGON_V6_vdmpyhisat_acc
+      {Intrinsic::hexagon_V6_vdmpyhisat_acc_128B, 40814}, // __builtin_HEXAGON_V6_vdmpyhisat_acc_128B
+      {Intrinsic::hexagon_V6_vdmpyhsat, 40855}, // __builtin_HEXAGON_V6_vdmpyhsat
+      {Intrinsic::hexagon_V6_vdmpyhsat_128B, 40886}, // __builtin_HEXAGON_V6_vdmpyhsat_128B
+      {Intrinsic::hexagon_V6_vdmpyhsat_acc, 40922}, // __builtin_HEXAGON_V6_vdmpyhsat_acc
+      {Intrinsic::hexagon_V6_vdmpyhsat_acc_128B, 40957}, // __builtin_HEXAGON_V6_vdmpyhsat_acc_128B
+      {Intrinsic::hexagon_V6_vdmpyhsuisat, 40997}, // __builtin_HEXAGON_V6_vdmpyhsuisat
+      {Intrinsic::hexagon_V6_vdmpyhsuisat_128B, 41031}, // __builtin_HEXAGON_V6_vdmpyhsuisat_128B
+      {Intrinsic::hexagon_V6_vdmpyhsuisat_acc, 41070}, // __builtin_HEXAGON_V6_vdmpyhsuisat_acc
+      {Intrinsic::hexagon_V6_vdmpyhsuisat_acc_128B, 41108}, // __builtin_HEXAGON_V6_vdmpyhsuisat_acc_128B
+      {Intrinsic::hexagon_V6_vdmpyhsusat, 41151}, // __builtin_HEXAGON_V6_vdmpyhsusat
+      {Intrinsic::hexagon_V6_vdmpyhsusat_128B, 41184}, // __builtin_HEXAGON_V6_vdmpyhsusat_128B
+      {Intrinsic::hexagon_V6_vdmpyhsusat_acc, 41222}, // __builtin_HEXAGON_V6_vdmpyhsusat_acc
+      {Intrinsic::hexagon_V6_vdmpyhsusat_acc_128B, 41259}, // __builtin_HEXAGON_V6_vdmpyhsusat_acc_128B
+      {Intrinsic::hexagon_V6_vdmpyhvsat, 41301}, // __builtin_HEXAGON_V6_vdmpyhvsat
+      {Intrinsic::hexagon_V6_vdmpyhvsat_128B, 41333}, // __builtin_HEXAGON_V6_vdmpyhvsat_128B
+      {Intrinsic::hexagon_V6_vdmpyhvsat_acc, 41370}, // __builtin_HEXAGON_V6_vdmpyhvsat_acc
+      {Intrinsic::hexagon_V6_vdmpyhvsat_acc_128B, 41406}, // __builtin_HEXAGON_V6_vdmpyhvsat_acc_128B
+      {Intrinsic::hexagon_V6_vdsaduh, 41447}, // __builtin_HEXAGON_V6_vdsaduh
+      {Intrinsic::hexagon_V6_vdsaduh_128B, 41476}, // __builtin_HEXAGON_V6_vdsaduh_128B
+      {Intrinsic::hexagon_V6_vdsaduh_acc, 41510}, // __builtin_HEXAGON_V6_vdsaduh_acc
+      {Intrinsic::hexagon_V6_vdsaduh_acc_128B, 41543}, // __builtin_HEXAGON_V6_vdsaduh_acc_128B
+      {Intrinsic::hexagon_V6_vgathermh, 41581}, // __builtin_HEXAGON_V6_vgathermh
+      {Intrinsic::hexagon_V6_vgathermh_128B, 41612}, // __builtin_HEXAGON_V6_vgathermh_128B
+      {Intrinsic::hexagon_V6_vgathermhw, 41648}, // __builtin_HEXAGON_V6_vgathermhw
+      {Intrinsic::hexagon_V6_vgathermhw_128B, 41680}, // __builtin_HEXAGON_V6_vgathermhw_128B
+      {Intrinsic::hexagon_V6_vgathermw, 41717}, // __builtin_HEXAGON_V6_vgathermw
+      {Intrinsic::hexagon_V6_vgathermw_128B, 41748}, // __builtin_HEXAGON_V6_vgathermw_128B
+      {Intrinsic::hexagon_V6_vinsertwr, 41784}, // __builtin_HEXAGON_V6_vinsertwr
+      {Intrinsic::hexagon_V6_vinsertwr_128B, 41815}, // __builtin_HEXAGON_V6_vinsertwr_128B
+      {Intrinsic::hexagon_V6_vlalignb, 41851}, // __builtin_HEXAGON_V6_vlalignb
+      {Intrinsic::hexagon_V6_vlalignb_128B, 41881}, // __builtin_HEXAGON_V6_vlalignb_128B
+      {Intrinsic::hexagon_V6_vlalignbi, 41916}, // __builtin_HEXAGON_V6_vlalignbi
+      {Intrinsic::hexagon_V6_vlalignbi_128B, 41947}, // __builtin_HEXAGON_V6_vlalignbi_128B
+      {Intrinsic::hexagon_V6_vlsrb, 41983}, // __builtin_HEXAGON_V6_vlsrb
+      {Intrinsic::hexagon_V6_vlsrb_128B, 42010}, // __builtin_HEXAGON_V6_vlsrb_128B
+      {Intrinsic::hexagon_V6_vlsrh, 42042}, // __builtin_HEXAGON_V6_vlsrh
+      {Intrinsic::hexagon_V6_vlsrh_128B, 42069}, // __builtin_HEXAGON_V6_vlsrh_128B
+      {Intrinsic::hexagon_V6_vlsrhv, 42101}, // __builtin_HEXAGON_V6_vlsrhv
+      {Intrinsic::hexagon_V6_vlsrhv_128B, 42129}, // __builtin_HEXAGON_V6_vlsrhv_128B
+      {Intrinsic::hexagon_V6_vlsrw, 42162}, // __builtin_HEXAGON_V6_vlsrw
+      {Intrinsic::hexagon_V6_vlsrw_128B, 42189}, // __builtin_HEXAGON_V6_vlsrw_128B
+      {Intrinsic::hexagon_V6_vlsrwv, 42221}, // __builtin_HEXAGON_V6_vlsrwv
+      {Intrinsic::hexagon_V6_vlsrwv_128B, 42249}, // __builtin_HEXAGON_V6_vlsrwv_128B
+      {Intrinsic::hexagon_V6_vlut4, 42282}, // __builtin_HEXAGON_V6_vlut4
+      {Intrinsic::hexagon_V6_vlut4_128B, 42309}, // __builtin_HEXAGON_V6_vlut4_128B
+      {Intrinsic::hexagon_V6_vlutvvb, 42341}, // __builtin_HEXAGON_V6_vlutvvb
+      {Intrinsic::hexagon_V6_vlutvvb_128B, 42370}, // __builtin_HEXAGON_V6_vlutvvb_128B
+      {Intrinsic::hexagon_V6_vlutvvb_nm, 42404}, // __builtin_HEXAGON_V6_vlutvvb_nm
+      {Intrinsic::hexagon_V6_vlutvvb_nm_128B, 42436}, // __builtin_HEXAGON_V6_vlutvvb_nm_128B
+      {Intrinsic::hexagon_V6_vlutvvb_oracc, 42473}, // __builtin_HEXAGON_V6_vlutvvb_oracc
+      {Intrinsic::hexagon_V6_vlutvvb_oracc_128B, 42508}, // __builtin_HEXAGON_V6_vlutvvb_oracc_128B
+      {Intrinsic::hexagon_V6_vlutvvb_oracci, 42548}, // __builtin_HEXAGON_V6_vlutvvb_oracci
+      {Intrinsic::hexagon_V6_vlutvvb_oracci_128B, 42584}, // __builtin_HEXAGON_V6_vlutvvb_oracci_128B
+      {Intrinsic::hexagon_V6_vlutvvbi, 42625}, // __builtin_HEXAGON_V6_vlutvvbi
+      {Intrinsic::hexagon_V6_vlutvvbi_128B, 42655}, // __builtin_HEXAGON_V6_vlutvvbi_128B
+      {Intrinsic::hexagon_V6_vlutvwh, 42690}, // __builtin_HEXAGON_V6_vlutvwh
+      {Intrinsic::hexagon_V6_vlutvwh_128B, 42719}, // __builtin_HEXAGON_V6_vlutvwh_128B
+      {Intrinsic::hexagon_V6_vlutvwh_nm, 42753}, // __builtin_HEXAGON_V6_vlutvwh_nm
+      {Intrinsic::hexagon_V6_vlutvwh_nm_128B, 42785}, // __builtin_HEXAGON_V6_vlutvwh_nm_128B
+      {Intrinsic::hexagon_V6_vlutvwh_oracc, 42822}, // __builtin_HEXAGON_V6_vlutvwh_oracc
+      {Intrinsic::hexagon_V6_vlutvwh_oracc_128B, 42857}, // __builtin_HEXAGON_V6_vlutvwh_oracc_128B
+      {Intrinsic::hexagon_V6_vlutvwh_oracci, 42897}, // __builtin_HEXAGON_V6_vlutvwh_oracci
+      {Intrinsic::hexagon_V6_vlutvwh_oracci_128B, 42933}, // __builtin_HEXAGON_V6_vlutvwh_oracci_128B
+      {Intrinsic::hexagon_V6_vlutvwhi, 42974}, // __builtin_HEXAGON_V6_vlutvwhi
+      {Intrinsic::hexagon_V6_vlutvwhi_128B, 43004}, // __builtin_HEXAGON_V6_vlutvwhi_128B
+      {Intrinsic::hexagon_V6_vmaxb, 43039}, // __builtin_HEXAGON_V6_vmaxb
+      {Intrinsic::hexagon_V6_vmaxb_128B, 43066}, // __builtin_HEXAGON_V6_vmaxb_128B
+      {Intrinsic::hexagon_V6_vmaxh, 43098}, // __builtin_HEXAGON_V6_vmaxh
+      {Intrinsic::hexagon_V6_vmaxh_128B, 43125}, // __builtin_HEXAGON_V6_vmaxh_128B
+      {Intrinsic::hexagon_V6_vmaxub, 43157}, // __builtin_HEXAGON_V6_vmaxub
+      {Intrinsic::hexagon_V6_vmaxub_128B, 43185}, // __builtin_HEXAGON_V6_vmaxub_128B
+      {Intrinsic::hexagon_V6_vmaxuh, 43218}, // __builtin_HEXAGON_V6_vmaxuh
+      {Intrinsic::hexagon_V6_vmaxuh_128B, 43246}, // __builtin_HEXAGON_V6_vmaxuh_128B
+      {Intrinsic::hexagon_V6_vmaxw, 43279}, // __builtin_HEXAGON_V6_vmaxw
+      {Intrinsic::hexagon_V6_vmaxw_128B, 43306}, // __builtin_HEXAGON_V6_vmaxw_128B
+      {Intrinsic::hexagon_V6_vminb, 43338}, // __builtin_HEXAGON_V6_vminb
+      {Intrinsic::hexagon_V6_vminb_128B, 43365}, // __builtin_HEXAGON_V6_vminb_128B
+      {Intrinsic::hexagon_V6_vminh, 43397}, // __builtin_HEXAGON_V6_vminh
+      {Intrinsic::hexagon_V6_vminh_128B, 43424}, // __builtin_HEXAGON_V6_vminh_128B
+      {Intrinsic::hexagon_V6_vminub, 43456}, // __builtin_HEXAGON_V6_vminub
+      {Intrinsic::hexagon_V6_vminub_128B, 43484}, // __builtin_HEXAGON_V6_vminub_128B
+      {Intrinsic::hexagon_V6_vminuh, 43517}, // __builtin_HEXAGON_V6_vminuh
+      {Intrinsic::hexagon_V6_vminuh_128B, 43545}, // __builtin_HEXAGON_V6_vminuh_128B
+      {Intrinsic::hexagon_V6_vminw, 43578}, // __builtin_HEXAGON_V6_vminw
+      {Intrinsic::hexagon_V6_vminw_128B, 43605}, // __builtin_HEXAGON_V6_vminw_128B
+      {Intrinsic::hexagon_V6_vmpabus, 43637}, // __builtin_HEXAGON_V6_vmpabus
+      {Intrinsic::hexagon_V6_vmpabus_128B, 43666}, // __builtin_HEXAGON_V6_vmpabus_128B
+      {Intrinsic::hexagon_V6_vmpabus_acc, 43700}, // __builtin_HEXAGON_V6_vmpabus_acc
+      {Intrinsic::hexagon_V6_vmpabus_acc_128B, 43733}, // __builtin_HEXAGON_V6_vmpabus_acc_128B
+      {Intrinsic::hexagon_V6_vmpabusv, 43771}, // __builtin_HEXAGON_V6_vmpabusv
+      {Intrinsic::hexagon_V6_vmpabusv_128B, 43801}, // __builtin_HEXAGON_V6_vmpabusv_128B
+      {Intrinsic::hexagon_V6_vmpabuu, 43836}, // __builtin_HEXAGON_V6_vmpabuu
+      {Intrinsic::hexagon_V6_vmpabuu_128B, 43865}, // __builtin_HEXAGON_V6_vmpabuu_128B
+      {Intrinsic::hexagon_V6_vmpabuu_acc, 43899}, // __builtin_HEXAGON_V6_vmpabuu_acc
+      {Intrinsic::hexagon_V6_vmpabuu_acc_128B, 43932}, // __builtin_HEXAGON_V6_vmpabuu_acc_128B
+      {Intrinsic::hexagon_V6_vmpabuuv, 43970}, // __builtin_HEXAGON_V6_vmpabuuv
+      {Intrinsic::hexagon_V6_vmpabuuv_128B, 44000}, // __builtin_HEXAGON_V6_vmpabuuv_128B
+      {Intrinsic::hexagon_V6_vmpahb, 44035}, // __builtin_HEXAGON_V6_vmpahb
+      {Intrinsic::hexagon_V6_vmpahb_128B, 44063}, // __builtin_HEXAGON_V6_vmpahb_128B
+      {Intrinsic::hexagon_V6_vmpahb_acc, 44096}, // __builtin_HEXAGON_V6_vmpahb_acc
+      {Intrinsic::hexagon_V6_vmpahb_acc_128B, 44128}, // __builtin_HEXAGON_V6_vmpahb_acc_128B
+      {Intrinsic::hexagon_V6_vmpahhsat, 44165}, // __builtin_HEXAGON_V6_vmpahhsat
+      {Intrinsic::hexagon_V6_vmpahhsat_128B, 44196}, // __builtin_HEXAGON_V6_vmpahhsat_128B
+      {Intrinsic::hexagon_V6_vmpauhb, 44232}, // __builtin_HEXAGON_V6_vmpauhb
+      {Intrinsic::hexagon_V6_vmpauhb_128B, 44261}, // __builtin_HEXAGON_V6_vmpauhb_128B
+      {Intrinsic::hexagon_V6_vmpauhb_acc, 44295}, // __builtin_HEXAGON_V6_vmpauhb_acc
+      {Intrinsic::hexagon_V6_vmpauhb_acc_128B, 44328}, // __builtin_HEXAGON_V6_vmpauhb_acc_128B
+      {Intrinsic::hexagon_V6_vmpauhuhsat, 44366}, // __builtin_HEXAGON_V6_vmpauhuhsat
+      {Intrinsic::hexagon_V6_vmpauhuhsat_128B, 44399}, // __builtin_HEXAGON_V6_vmpauhuhsat_128B
+      {Intrinsic::hexagon_V6_vmpsuhuhsat, 44437}, // __builtin_HEXAGON_V6_vmpsuhuhsat
+      {Intrinsic::hexagon_V6_vmpsuhuhsat_128B, 44470}, // __builtin_HEXAGON_V6_vmpsuhuhsat_128B
+      {Intrinsic::hexagon_V6_vmpybus, 44508}, // __builtin_HEXAGON_V6_vmpybus
+      {Intrinsic::hexagon_V6_vmpybus_128B, 44537}, // __builtin_HEXAGON_V6_vmpybus_128B
+      {Intrinsic::hexagon_V6_vmpybus_acc, 44571}, // __builtin_HEXAGON_V6_vmpybus_acc
+      {Intrinsic::hexagon_V6_vmpybus_acc_128B, 44604}, // __builtin_HEXAGON_V6_vmpybus_acc_128B
+      {Intrinsic::hexagon_V6_vmpybusv, 44642}, // __builtin_HEXAGON_V6_vmpybusv
+      {Intrinsic::hexagon_V6_vmpybusv_128B, 44672}, // __builtin_HEXAGON_V6_vmpybusv_128B
+      {Intrinsic::hexagon_V6_vmpybusv_acc, 44707}, // __builtin_HEXAGON_V6_vmpybusv_acc
+      {Intrinsic::hexagon_V6_vmpybusv_acc_128B, 44741}, // __builtin_HEXAGON_V6_vmpybusv_acc_128B
+      {Intrinsic::hexagon_V6_vmpybv, 44780}, // __builtin_HEXAGON_V6_vmpybv
+      {Intrinsic::hexagon_V6_vmpybv_128B, 44808}, // __builtin_HEXAGON_V6_vmpybv_128B
+      {Intrinsic::hexagon_V6_vmpybv_acc, 44841}, // __builtin_HEXAGON_V6_vmpybv_acc
+      {Intrinsic::hexagon_V6_vmpybv_acc_128B, 44873}, // __builtin_HEXAGON_V6_vmpybv_acc_128B
+      {Intrinsic::hexagon_V6_vmpyewuh, 44910}, // __builtin_HEXAGON_V6_vmpyewuh
+      {Intrinsic::hexagon_V6_vmpyewuh_128B, 44940}, // __builtin_HEXAGON_V6_vmpyewuh_128B
+      {Intrinsic::hexagon_V6_vmpyewuh_64, 44975}, // __builtin_HEXAGON_V6_vmpyewuh_64
+      {Intrinsic::hexagon_V6_vmpyewuh_64_128B, 45008}, // __builtin_HEXAGON_V6_vmpyewuh_64_128B
+      {Intrinsic::hexagon_V6_vmpyh, 45046}, // __builtin_HEXAGON_V6_vmpyh
+      {Intrinsic::hexagon_V6_vmpyh_128B, 45073}, // __builtin_HEXAGON_V6_vmpyh_128B
+      {Intrinsic::hexagon_V6_vmpyh_acc, 45105}, // __builtin_HEXAGON_V6_vmpyh_acc
+      {Intrinsic::hexagon_V6_vmpyh_acc_128B, 45136}, // __builtin_HEXAGON_V6_vmpyh_acc_128B
+      {Intrinsic::hexagon_V6_vmpyhsat_acc, 45172}, // __builtin_HEXAGON_V6_vmpyhsat_acc
+      {Intrinsic::hexagon_V6_vmpyhsat_acc_128B, 45206}, // __builtin_HEXAGON_V6_vmpyhsat_acc_128B
+      {Intrinsic::hexagon_V6_vmpyhsrs, 45245}, // __builtin_HEXAGON_V6_vmpyhsrs
+      {Intrinsic::hexagon_V6_vmpyhsrs_128B, 45275}, // __builtin_HEXAGON_V6_vmpyhsrs_128B
+      {Intrinsic::hexagon_V6_vmpyhss, 45310}, // __builtin_HEXAGON_V6_vmpyhss
+      {Intrinsic::hexagon_V6_vmpyhss_128B, 45339}, // __builtin_HEXAGON_V6_vmpyhss_128B
+      {Intrinsic::hexagon_V6_vmpyhus, 45373}, // __builtin_HEXAGON_V6_vmpyhus
+      {Intrinsic::hexagon_V6_vmpyhus_128B, 45402}, // __builtin_HEXAGON_V6_vmpyhus_128B
+      {Intrinsic::hexagon_V6_vmpyhus_acc, 45436}, // __builtin_HEXAGON_V6_vmpyhus_acc
+      {Intrinsic::hexagon_V6_vmpyhus_acc_128B, 45469}, // __builtin_HEXAGON_V6_vmpyhus_acc_128B
+      {Intrinsic::hexagon_V6_vmpyhv, 45507}, // __builtin_HEXAGON_V6_vmpyhv
+      {Intrinsic::hexagon_V6_vmpyhv_128B, 45535}, // __builtin_HEXAGON_V6_vmpyhv_128B
+      {Intrinsic::hexagon_V6_vmpyhv_acc, 45568}, // __builtin_HEXAGON_V6_vmpyhv_acc
+      {Intrinsic::hexagon_V6_vmpyhv_acc_128B, 45600}, // __builtin_HEXAGON_V6_vmpyhv_acc_128B
+      {Intrinsic::hexagon_V6_vmpyhvsrs, 45637}, // __builtin_HEXAGON_V6_vmpyhvsrs
+      {Intrinsic::hexagon_V6_vmpyhvsrs_128B, 45668}, // __builtin_HEXAGON_V6_vmpyhvsrs_128B
+      {Intrinsic::hexagon_V6_vmpyieoh, 45704}, // __builtin_HEXAGON_V6_vmpyieoh
+      {Intrinsic::hexagon_V6_vmpyieoh_128B, 45734}, // __builtin_HEXAGON_V6_vmpyieoh_128B
+      {Intrinsic::hexagon_V6_vmpyiewh_acc, 45769}, // __builtin_HEXAGON_V6_vmpyiewh_acc
+      {Intrinsic::hexagon_V6_vmpyiewh_acc_128B, 45803}, // __builtin_HEXAGON_V6_vmpyiewh_acc_128B
+      {Intrinsic::hexagon_V6_vmpyiewuh, 45842}, // __builtin_HEXAGON_V6_vmpyiewuh
+      {Intrinsic::hexagon_V6_vmpyiewuh_128B, 45873}, // __builtin_HEXAGON_V6_vmpyiewuh_128B
+      {Intrinsic::hexagon_V6_vmpyiewuh_acc, 45909}, // __builtin_HEXAGON_V6_vmpyiewuh_acc
+      {Intrinsic::hexagon_V6_vmpyiewuh_acc_128B, 45944}, // __builtin_HEXAGON_V6_vmpyiewuh_acc_128B
+      {Intrinsic::hexagon_V6_vmpyih, 45984}, // __builtin_HEXAGON_V6_vmpyih
+      {Intrinsic::hexagon_V6_vmpyih_128B, 46012}, // __builtin_HEXAGON_V6_vmpyih_128B
+      {Intrinsic::hexagon_V6_vmpyih_acc, 46045}, // __builtin_HEXAGON_V6_vmpyih_acc
+      {Intrinsic::hexagon_V6_vmpyih_acc_128B, 46077}, // __builtin_HEXAGON_V6_vmpyih_acc_128B
+      {Intrinsic::hexagon_V6_vmpyihb, 46114}, // __builtin_HEXAGON_V6_vmpyihb
+      {Intrinsic::hexagon_V6_vmpyihb_128B, 46143}, // __builtin_HEXAGON_V6_vmpyihb_128B
+      {Intrinsic::hexagon_V6_vmpyihb_acc, 46177}, // __builtin_HEXAGON_V6_vmpyihb_acc
+      {Intrinsic::hexagon_V6_vmpyihb_acc_128B, 46210}, // __builtin_HEXAGON_V6_vmpyihb_acc_128B
+      {Intrinsic::hexagon_V6_vmpyiowh, 46248}, // __builtin_HEXAGON_V6_vmpyiowh
+      {Intrinsic::hexagon_V6_vmpyiowh_128B, 46278}, // __builtin_HEXAGON_V6_vmpyiowh_128B
+      {Intrinsic::hexagon_V6_vmpyiwb, 46313}, // __builtin_HEXAGON_V6_vmpyiwb
+      {Intrinsic::hexagon_V6_vmpyiwb_128B, 46342}, // __builtin_HEXAGON_V6_vmpyiwb_128B
+      {Intrinsic::hexagon_V6_vmpyiwb_acc, 46376}, // __builtin_HEXAGON_V6_vmpyiwb_acc
+      {Intrinsic::hexagon_V6_vmpyiwb_acc_128B, 46409}, // __builtin_HEXAGON_V6_vmpyiwb_acc_128B
+      {Intrinsic::hexagon_V6_vmpyiwh, 46447}, // __builtin_HEXAGON_V6_vmpyiwh
+      {Intrinsic::hexagon_V6_vmpyiwh_128B, 46476}, // __builtin_HEXAGON_V6_vmpyiwh_128B
+      {Intrinsic::hexagon_V6_vmpyiwh_acc, 46510}, // __builtin_HEXAGON_V6_vmpyiwh_acc
+      {Intrinsic::hexagon_V6_vmpyiwh_acc_128B, 46543}, // __builtin_HEXAGON_V6_vmpyiwh_acc_128B
+      {Intrinsic::hexagon_V6_vmpyiwub, 46581}, // __builtin_HEXAGON_V6_vmpyiwub
+      {Intrinsic::hexagon_V6_vmpyiwub_128B, 46611}, // __builtin_HEXAGON_V6_vmpyiwub_128B
+      {Intrinsic::hexagon_V6_vmpyiwub_acc, 46646}, // __builtin_HEXAGON_V6_vmpyiwub_acc
+      {Intrinsic::hexagon_V6_vmpyiwub_acc_128B, 46680}, // __builtin_HEXAGON_V6_vmpyiwub_acc_128B
+      {Intrinsic::hexagon_V6_vmpyowh, 46719}, // __builtin_HEXAGON_V6_vmpyowh
+      {Intrinsic::hexagon_V6_vmpyowh_128B, 46748}, // __builtin_HEXAGON_V6_vmpyowh_128B
+      {Intrinsic::hexagon_V6_vmpyowh_64_acc, 46782}, // __builtin_HEXAGON_V6_vmpyowh_64_acc
+      {Intrinsic::hexagon_V6_vmpyowh_64_acc_128B, 46818}, // __builtin_HEXAGON_V6_vmpyowh_64_acc_128B
+      {Intrinsic::hexagon_V6_vmpyowh_rnd, 46859}, // __builtin_HEXAGON_V6_vmpyowh_rnd
+      {Intrinsic::hexagon_V6_vmpyowh_rnd_128B, 46892}, // __builtin_HEXAGON_V6_vmpyowh_rnd_128B
+      {Intrinsic::hexagon_V6_vmpyowh_rnd_sacc, 46930}, // __builtin_HEXAGON_V6_vmpyowh_rnd_sacc
+      {Intrinsic::hexagon_V6_vmpyowh_rnd_sacc_128B, 46968}, // __builtin_HEXAGON_V6_vmpyowh_rnd_sacc_128B
+      {Intrinsic::hexagon_V6_vmpyowh_sacc, 47011}, // __builtin_HEXAGON_V6_vmpyowh_sacc
+      {Intrinsic::hexagon_V6_vmpyowh_sacc_128B, 47045}, // __builtin_HEXAGON_V6_vmpyowh_sacc_128B
+      {Intrinsic::hexagon_V6_vmpyub, 47084}, // __builtin_HEXAGON_V6_vmpyub
+      {Intrinsic::hexagon_V6_vmpyub_128B, 47112}, // __builtin_HEXAGON_V6_vmpyub_128B
+      {Intrinsic::hexagon_V6_vmpyub_acc, 47145}, // __builtin_HEXAGON_V6_vmpyub_acc
+      {Intrinsic::hexagon_V6_vmpyub_acc_128B, 47177}, // __builtin_HEXAGON_V6_vmpyub_acc_128B
+      {Intrinsic::hexagon_V6_vmpyubv, 47214}, // __builtin_HEXAGON_V6_vmpyubv
+      {Intrinsic::hexagon_V6_vmpyubv_128B, 47243}, // __builtin_HEXAGON_V6_vmpyubv_128B
+      {Intrinsic::hexagon_V6_vmpyubv_acc, 47277}, // __builtin_HEXAGON_V6_vmpyubv_acc
+      {Intrinsic::hexagon_V6_vmpyubv_acc_128B, 47310}, // __builtin_HEXAGON_V6_vmpyubv_acc_128B
+      {Intrinsic::hexagon_V6_vmpyuh, 47348}, // __builtin_HEXAGON_V6_vmpyuh
+      {Intrinsic::hexagon_V6_vmpyuh_128B, 47376}, // __builtin_HEXAGON_V6_vmpyuh_128B
+      {Intrinsic::hexagon_V6_vmpyuh_acc, 47409}, // __builtin_HEXAGON_V6_vmpyuh_acc
+      {Intrinsic::hexagon_V6_vmpyuh_acc_128B, 47441}, // __builtin_HEXAGON_V6_vmpyuh_acc_128B
+      {Intrinsic::hexagon_V6_vmpyuhe, 47478}, // __builtin_HEXAGON_V6_vmpyuhe
+      {Intrinsic::hexagon_V6_vmpyuhe_128B, 47507}, // __builtin_HEXAGON_V6_vmpyuhe_128B
+      {Intrinsic::hexagon_V6_vmpyuhe_acc, 47541}, // __builtin_HEXAGON_V6_vmpyuhe_acc
+      {Intrinsic::hexagon_V6_vmpyuhe_acc_128B, 47574}, // __builtin_HEXAGON_V6_vmpyuhe_acc_128B
+      {Intrinsic::hexagon_V6_vmpyuhv, 47612}, // __builtin_HEXAGON_V6_vmpyuhv
+      {Intrinsic::hexagon_V6_vmpyuhv_128B, 47641}, // __builtin_HEXAGON_V6_vmpyuhv_128B
+      {Intrinsic::hexagon_V6_vmpyuhv_acc, 47675}, // __builtin_HEXAGON_V6_vmpyuhv_acc
+      {Intrinsic::hexagon_V6_vmpyuhv_acc_128B, 47708}, // __builtin_HEXAGON_V6_vmpyuhv_acc_128B
+      {Intrinsic::hexagon_V6_vnavgb, 47746}, // __builtin_HEXAGON_V6_vnavgb
+      {Intrinsic::hexagon_V6_vnavgb_128B, 47774}, // __builtin_HEXAGON_V6_vnavgb_128B
+      {Intrinsic::hexagon_V6_vnavgh, 47807}, // __builtin_HEXAGON_V6_vnavgh
+      {Intrinsic::hexagon_V6_vnavgh_128B, 47835}, // __builtin_HEXAGON_V6_vnavgh_128B
+      {Intrinsic::hexagon_V6_vnavgub, 47868}, // __builtin_HEXAGON_V6_vnavgub
+      {Intrinsic::hexagon_V6_vnavgub_128B, 47897}, // __builtin_HEXAGON_V6_vnavgub_128B
+      {Intrinsic::hexagon_V6_vnavgw, 47931}, // __builtin_HEXAGON_V6_vnavgw
+      {Intrinsic::hexagon_V6_vnavgw_128B, 47959}, // __builtin_HEXAGON_V6_vnavgw_128B
+      {Intrinsic::hexagon_V6_vnormamth, 47992}, // __builtin_HEXAGON_V6_vnormamth
+      {Intrinsic::hexagon_V6_vnormamth_128B, 48023}, // __builtin_HEXAGON_V6_vnormamth_128B
+      {Intrinsic::hexagon_V6_vnormamtw, 48059}, // __builtin_HEXAGON_V6_vnormamtw
+      {Intrinsic::hexagon_V6_vnormamtw_128B, 48090}, // __builtin_HEXAGON_V6_vnormamtw_128B
+      {Intrinsic::hexagon_V6_vnot, 48126}, // __builtin_HEXAGON_V6_vnot
+      {Intrinsic::hexagon_V6_vnot_128B, 48152}, // __builtin_HEXAGON_V6_vnot_128B
+      {Intrinsic::hexagon_V6_vor, 48183}, // __builtin_HEXAGON_V6_vor
+      {Intrinsic::hexagon_V6_vor_128B, 48208}, // __builtin_HEXAGON_V6_vor_128B
+      {Intrinsic::hexagon_V6_vpackeb, 48238}, // __builtin_HEXAGON_V6_vpackeb
+      {Intrinsic::hexagon_V6_vpackeb_128B, 48267}, // __builtin_HEXAGON_V6_vpackeb_128B
+      {Intrinsic::hexagon_V6_vpackeh, 48301}, // __builtin_HEXAGON_V6_vpackeh
+      {Intrinsic::hexagon_V6_vpackeh_128B, 48330}, // __builtin_HEXAGON_V6_vpackeh_128B
+      {Intrinsic::hexagon_V6_vpackhb_sat, 48364}, // __builtin_HEXAGON_V6_vpackhb_sat
+      {Intrinsic::hexagon_V6_vpackhb_sat_128B, 48397}, // __builtin_HEXAGON_V6_vpackhb_sat_128B
+      {Intrinsic::hexagon_V6_vpackhub_sat, 48435}, // __builtin_HEXAGON_V6_vpackhub_sat
+      {Intrinsic::hexagon_V6_vpackhub_sat_128B, 48469}, // __builtin_HEXAGON_V6_vpackhub_sat_128B
+      {Intrinsic::hexagon_V6_vpackob, 48508}, // __builtin_HEXAGON_V6_vpackob
+      {Intrinsic::hexagon_V6_vpackob_128B, 48537}, // __builtin_HEXAGON_V6_vpackob_128B
+      {Intrinsic::hexagon_V6_vpackoh, 48571}, // __builtin_HEXAGON_V6_vpackoh
+      {Intrinsic::hexagon_V6_vpackoh_128B, 48600}, // __builtin_HEXAGON_V6_vpackoh_128B
+      {Intrinsic::hexagon_V6_vpackwh_sat, 48634}, // __builtin_HEXAGON_V6_vpackwh_sat
+      {Intrinsic::hexagon_V6_vpackwh_sat_128B, 48667}, // __builtin_HEXAGON_V6_vpackwh_sat_128B
+      {Intrinsic::hexagon_V6_vpackwuh_sat, 48705}, // __builtin_HEXAGON_V6_vpackwuh_sat
+      {Intrinsic::hexagon_V6_vpackwuh_sat_128B, 48739}, // __builtin_HEXAGON_V6_vpackwuh_sat_128B
+      {Intrinsic::hexagon_V6_vpopcounth, 48778}, // __builtin_HEXAGON_V6_vpopcounth
+      {Intrinsic::hexagon_V6_vpopcounth_128B, 48810}, // __builtin_HEXAGON_V6_vpopcounth_128B
+      {Intrinsic::hexagon_V6_vrdelta, 48847}, // __builtin_HEXAGON_V6_vrdelta
+      {Intrinsic::hexagon_V6_vrdelta_128B, 48876}, // __builtin_HEXAGON_V6_vrdelta_128B
+      {Intrinsic::hexagon_V6_vrmpybub_rtt, 48910}, // __builtin_HEXAGON_V6_vrmpybub_rtt
+      {Intrinsic::hexagon_V6_vrmpybub_rtt_128B, 48944}, // __builtin_HEXAGON_V6_vrmpybub_rtt_128B
+      {Intrinsic::hexagon_V6_vrmpybub_rtt_acc, 48983}, // __builtin_HEXAGON_V6_vrmpybub_rtt_acc
+      {Intrinsic::hexagon_V6_vrmpybub_rtt_acc_128B, 49021}, // __builtin_HEXAGON_V6_vrmpybub_rtt_acc_128B
+      {Intrinsic::hexagon_V6_vrmpybus, 49064}, // __builtin_HEXAGON_V6_vrmpybus
+      {Intrinsic::hexagon_V6_vrmpybus_128B, 49094}, // __builtin_HEXAGON_V6_vrmpybus_128B
+      {Intrinsic::hexagon_V6_vrmpybus_acc, 49129}, // __builtin_HEXAGON_V6_vrmpybus_acc
+      {Intrinsic::hexagon_V6_vrmpybus_acc_128B, 49163}, // __builtin_HEXAGON_V6_vrmpybus_acc_128B
+      {Intrinsic::hexagon_V6_vrmpybusi, 49202}, // __builtin_HEXAGON_V6_vrmpybusi
+      {Intrinsic::hexagon_V6_vrmpybusi_128B, 49233}, // __builtin_HEXAGON_V6_vrmpybusi_128B
+      {Intrinsic::hexagon_V6_vrmpybusi_acc, 49269}, // __builtin_HEXAGON_V6_vrmpybusi_acc
+      {Intrinsic::hexagon_V6_vrmpybusi_acc_128B, 49304}, // __builtin_HEXAGON_V6_vrmpybusi_acc_128B
+      {Intrinsic::hexagon_V6_vrmpybusv, 49344}, // __builtin_HEXAGON_V6_vrmpybusv
+      {Intrinsic::hexagon_V6_vrmpybusv_128B, 49375}, // __builtin_HEXAGON_V6_vrmpybusv_128B
+      {Intrinsic::hexagon_V6_vrmpybusv_acc, 49411}, // __builtin_HEXAGON_V6_vrmpybusv_acc
+      {Intrinsic::hexagon_V6_vrmpybusv_acc_128B, 49446}, // __builtin_HEXAGON_V6_vrmpybusv_acc_128B
+      {Intrinsic::hexagon_V6_vrmpybv, 49486}, // __builtin_HEXAGON_V6_vrmpybv
+      {Intrinsic::hexagon_V6_vrmpybv_128B, 49515}, // __builtin_HEXAGON_V6_vrmpybv_128B
+      {Intrinsic::hexagon_V6_vrmpybv_acc, 49549}, // __builtin_HEXAGON_V6_vrmpybv_acc
+      {Intrinsic::hexagon_V6_vrmpybv_acc_128B, 49582}, // __builtin_HEXAGON_V6_vrmpybv_acc_128B
+      {Intrinsic::hexagon_V6_vrmpyub, 49620}, // __builtin_HEXAGON_V6_vrmpyub
+      {Intrinsic::hexagon_V6_vrmpyub_128B, 49649}, // __builtin_HEXAGON_V6_vrmpyub_128B
+      {Intrinsic::hexagon_V6_vrmpyub_acc, 49683}, // __builtin_HEXAGON_V6_vrmpyub_acc
+      {Intrinsic::hexagon_V6_vrmpyub_acc_128B, 49716}, // __builtin_HEXAGON_V6_vrmpyub_acc_128B
+      {Intrinsic::hexagon_V6_vrmpyub_rtt, 49754}, // __builtin_HEXAGON_V6_vrmpyub_rtt
+      {Intrinsic::hexagon_V6_vrmpyub_rtt_128B, 49787}, // __builtin_HEXAGON_V6_vrmpyub_rtt_128B
+      {Intrinsic::hexagon_V6_vrmpyub_rtt_acc, 49825}, // __builtin_HEXAGON_V6_vrmpyub_rtt_acc
+      {Intrinsic::hexagon_V6_vrmpyub_rtt_acc_128B, 49862}, // __builtin_HEXAGON_V6_vrmpyub_rtt_acc_128B
+      {Intrinsic::hexagon_V6_vrmpyubi, 49904}, // __builtin_HEXAGON_V6_vrmpyubi
+      {Intrinsic::hexagon_V6_vrmpyubi_128B, 49934}, // __builtin_HEXAGON_V6_vrmpyubi_128B
+      {Intrinsic::hexagon_V6_vrmpyubi_acc, 49969}, // __builtin_HEXAGON_V6_vrmpyubi_acc
+      {Intrinsic::hexagon_V6_vrmpyubi_acc_128B, 50003}, // __builtin_HEXAGON_V6_vrmpyubi_acc_128B
+      {Intrinsic::hexagon_V6_vrmpyubv, 50042}, // __builtin_HEXAGON_V6_vrmpyubv
+      {Intrinsic::hexagon_V6_vrmpyubv_128B, 50072}, // __builtin_HEXAGON_V6_vrmpyubv_128B
+      {Intrinsic::hexagon_V6_vrmpyubv_acc, 50107}, // __builtin_HEXAGON_V6_vrmpyubv_acc
+      {Intrinsic::hexagon_V6_vrmpyubv_acc_128B, 50141}, // __builtin_HEXAGON_V6_vrmpyubv_acc_128B
+      {Intrinsic::hexagon_V6_vror, 50180}, // __builtin_HEXAGON_V6_vror
+      {Intrinsic::hexagon_V6_vror_128B, 50206}, // __builtin_HEXAGON_V6_vror_128B
+      {Intrinsic::hexagon_V6_vrotr, 50237}, // __builtin_HEXAGON_V6_vrotr
+      {Intrinsic::hexagon_V6_vrotr_128B, 50264}, // __builtin_HEXAGON_V6_vrotr_128B
+      {Intrinsic::hexagon_V6_vroundhb, 50296}, // __builtin_HEXAGON_V6_vroundhb
+      {Intrinsic::hexagon_V6_vroundhb_128B, 50326}, // __builtin_HEXAGON_V6_vroundhb_128B
+      {Intrinsic::hexagon_V6_vroundhub, 50361}, // __builtin_HEXAGON_V6_vroundhub
+      {Intrinsic::hexagon_V6_vroundhub_128B, 50392}, // __builtin_HEXAGON_V6_vroundhub_128B
+      {Intrinsic::hexagon_V6_vrounduhub, 50428}, // __builtin_HEXAGON_V6_vrounduhub
+      {Intrinsic::hexagon_V6_vrounduhub_128B, 50460}, // __builtin_HEXAGON_V6_vrounduhub_128B
+      {Intrinsic::hexagon_V6_vrounduwuh, 50497}, // __builtin_HEXAGON_V6_vrounduwuh
+      {Intrinsic::hexagon_V6_vrounduwuh_128B, 50529}, // __builtin_HEXAGON_V6_vrounduwuh_128B
+      {Intrinsic::hexagon_V6_vroundwh, 50566}, // __builtin_HEXAGON_V6_vroundwh
+      {Intrinsic::hexagon_V6_vroundwh_128B, 50596}, // __builtin_HEXAGON_V6_vroundwh_128B
+      {Intrinsic::hexagon_V6_vroundwuh, 50631}, // __builtin_HEXAGON_V6_vroundwuh
+      {Intrinsic::hexagon_V6_vroundwuh_128B, 50662}, // __builtin_HEXAGON_V6_vroundwuh_128B
+      {Intrinsic::hexagon_V6_vrsadubi, 50698}, // __builtin_HEXAGON_V6_vrsadubi
+      {Intrinsic::hexagon_V6_vrsadubi_128B, 50728}, // __builtin_HEXAGON_V6_vrsadubi_128B
+      {Intrinsic::hexagon_V6_vrsadubi_acc, 50763}, // __builtin_HEXAGON_V6_vrsadubi_acc
+      {Intrinsic::hexagon_V6_vrsadubi_acc_128B, 50797}, // __builtin_HEXAGON_V6_vrsadubi_acc_128B
+      {Intrinsic::hexagon_V6_vsatdw, 50836}, // __builtin_HEXAGON_V6_vsatdw
+      {Intrinsic::hexagon_V6_vsatdw_128B, 50864}, // __builtin_HEXAGON_V6_vsatdw_128B
+      {Intrinsic::hexagon_V6_vsathub, 50897}, // __builtin_HEXAGON_V6_vsathub
+      {Intrinsic::hexagon_V6_vsathub_128B, 50926}, // __builtin_HEXAGON_V6_vsathub_128B
+      {Intrinsic::hexagon_V6_vsatuwuh, 50960}, // __builtin_HEXAGON_V6_vsatuwuh
+      {Intrinsic::hexagon_V6_vsatuwuh_128B, 50990}, // __builtin_HEXAGON_V6_vsatuwuh_128B
+      {Intrinsic::hexagon_V6_vsatwh, 51025}, // __builtin_HEXAGON_V6_vsatwh
+      {Intrinsic::hexagon_V6_vsatwh_128B, 51053}, // __builtin_HEXAGON_V6_vsatwh_128B
+      {Intrinsic::hexagon_V6_vsb, 51086}, // __builtin_HEXAGON_V6_vsb
+      {Intrinsic::hexagon_V6_vsb_128B, 51111}, // __builtin_HEXAGON_V6_vsb_128B
+      {Intrinsic::hexagon_V6_vscattermh, 51141}, // __builtin_HEXAGON_V6_vscattermh
+      {Intrinsic::hexagon_V6_vscattermh_128B, 51173}, // __builtin_HEXAGON_V6_vscattermh_128B
+      {Intrinsic::hexagon_V6_vscattermh_add, 51210}, // __builtin_HEXAGON_V6_vscattermh_add
+      {Intrinsic::hexagon_V6_vscattermh_add_128B, 51246}, // __builtin_HEXAGON_V6_vscattermh_add_128B
+      {Intrinsic::hexagon_V6_vscattermhw, 51287}, // __builtin_HEXAGON_V6_vscattermhw
+      {Intrinsic::hexagon_V6_vscattermhw_128B, 51320}, // __builtin_HEXAGON_V6_vscattermhw_128B
+      {Intrinsic::hexagon_V6_vscattermhw_add, 51358}, // __builtin_HEXAGON_V6_vscattermhw_add
+      {Intrinsic::hexagon_V6_vscattermhw_add_128B, 51395}, // __builtin_HEXAGON_V6_vscattermhw_add_128B
+      {Intrinsic::hexagon_V6_vscattermw, 51437}, // __builtin_HEXAGON_V6_vscattermw
+      {Intrinsic::hexagon_V6_vscattermw_128B, 51469}, // __builtin_HEXAGON_V6_vscattermw_128B
+      {Intrinsic::hexagon_V6_vscattermw_add, 51506}, // __builtin_HEXAGON_V6_vscattermw_add
+      {Intrinsic::hexagon_V6_vscattermw_add_128B, 51542}, // __builtin_HEXAGON_V6_vscattermw_add_128B
+      {Intrinsic::hexagon_V6_vsh, 51583}, // __builtin_HEXAGON_V6_vsh
+      {Intrinsic::hexagon_V6_vsh_128B, 51608}, // __builtin_HEXAGON_V6_vsh_128B
+      {Intrinsic::hexagon_V6_vshufeh, 51638}, // __builtin_HEXAGON_V6_vshufeh
+      {Intrinsic::hexagon_V6_vshufeh_128B, 51667}, // __builtin_HEXAGON_V6_vshufeh_128B
+      {Intrinsic::hexagon_V6_vshuffb, 51701}, // __builtin_HEXAGON_V6_vshuffb
+      {Intrinsic::hexagon_V6_vshuffb_128B, 51730}, // __builtin_HEXAGON_V6_vshuffb_128B
+      {Intrinsic::hexagon_V6_vshuffeb, 51764}, // __builtin_HEXAGON_V6_vshuffeb
+      {Intrinsic::hexagon_V6_vshuffeb_128B, 51794}, // __builtin_HEXAGON_V6_vshuffeb_128B
+      {Intrinsic::hexagon_V6_vshuffh, 51829}, // __builtin_HEXAGON_V6_vshuffh
+      {Intrinsic::hexagon_V6_vshuffh_128B, 51858}, // __builtin_HEXAGON_V6_vshuffh_128B
+      {Intrinsic::hexagon_V6_vshuffob, 51892}, // __builtin_HEXAGON_V6_vshuffob
+      {Intrinsic::hexagon_V6_vshuffob_128B, 51922}, // __builtin_HEXAGON_V6_vshuffob_128B
+      {Intrinsic::hexagon_V6_vshuffvdd, 51957}, // __builtin_HEXAGON_V6_vshuffvdd
+      {Intrinsic::hexagon_V6_vshuffvdd_128B, 51988}, // __builtin_HEXAGON_V6_vshuffvdd_128B
+      {Intrinsic::hexagon_V6_vshufoeb, 52024}, // __builtin_HEXAGON_V6_vshufoeb
+      {Intrinsic::hexagon_V6_vshufoeb_128B, 52054}, // __builtin_HEXAGON_V6_vshufoeb_128B
+      {Intrinsic::hexagon_V6_vshufoeh, 52089}, // __builtin_HEXAGON_V6_vshufoeh
+      {Intrinsic::hexagon_V6_vshufoeh_128B, 52119}, // __builtin_HEXAGON_V6_vshufoeh_128B
+      {Intrinsic::hexagon_V6_vshufoh, 52154}, // __builtin_HEXAGON_V6_vshufoh
+      {Intrinsic::hexagon_V6_vshufoh_128B, 52183}, // __builtin_HEXAGON_V6_vshufoh_128B
+      {Intrinsic::hexagon_V6_vsubb, 52217}, // __builtin_HEXAGON_V6_vsubb
+      {Intrinsic::hexagon_V6_vsubb_128B, 52244}, // __builtin_HEXAGON_V6_vsubb_128B
+      {Intrinsic::hexagon_V6_vsubb_dv, 52276}, // __builtin_HEXAGON_V6_vsubb_dv
+      {Intrinsic::hexagon_V6_vsubb_dv_128B, 52306}, // __builtin_HEXAGON_V6_vsubb_dv_128B
+      {Intrinsic::hexagon_V6_vsubbsat, 52341}, // __builtin_HEXAGON_V6_vsubbsat
+      {Intrinsic::hexagon_V6_vsubbsat_128B, 52371}, // __builtin_HEXAGON_V6_vsubbsat_128B
+      {Intrinsic::hexagon_V6_vsubbsat_dv, 52406}, // __builtin_HEXAGON_V6_vsubbsat_dv
+      {Intrinsic::hexagon_V6_vsubbsat_dv_128B, 52439}, // __builtin_HEXAGON_V6_vsubbsat_dv_128B
+      {Intrinsic::hexagon_V6_vsubh, 52477}, // __builtin_HEXAGON_V6_vsubh
+      {Intrinsic::hexagon_V6_vsubh_128B, 52504}, // __builtin_HEXAGON_V6_vsubh_128B
+      {Intrinsic::hexagon_V6_vsubh_dv, 52536}, // __builtin_HEXAGON_V6_vsubh_dv
+      {Intrinsic::hexagon_V6_vsubh_dv_128B, 52566}, // __builtin_HEXAGON_V6_vsubh_dv_128B
+      {Intrinsic::hexagon_V6_vsubhsat, 52601}, // __builtin_HEXAGON_V6_vsubhsat
+      {Intrinsic::hexagon_V6_vsubhsat_128B, 52631}, // __builtin_HEXAGON_V6_vsubhsat_128B
+      {Intrinsic::hexagon_V6_vsubhsat_dv, 52666}, // __builtin_HEXAGON_V6_vsubhsat_dv
+      {Intrinsic::hexagon_V6_vsubhsat_dv_128B, 52699}, // __builtin_HEXAGON_V6_vsubhsat_dv_128B
+      {Intrinsic::hexagon_V6_vsubhw, 52737}, // __builtin_HEXAGON_V6_vsubhw
+      {Intrinsic::hexagon_V6_vsubhw_128B, 52765}, // __builtin_HEXAGON_V6_vsubhw_128B
+      {Intrinsic::hexagon_V6_vsububh, 52798}, // __builtin_HEXAGON_V6_vsububh
+      {Intrinsic::hexagon_V6_vsububh_128B, 52827}, // __builtin_HEXAGON_V6_vsububh_128B
+      {Intrinsic::hexagon_V6_vsububsat, 52861}, // __builtin_HEXAGON_V6_vsububsat
+      {Intrinsic::hexagon_V6_vsububsat_128B, 52892}, // __builtin_HEXAGON_V6_vsububsat_128B
+      {Intrinsic::hexagon_V6_vsububsat_dv, 52928}, // __builtin_HEXAGON_V6_vsububsat_dv
+      {Intrinsic::hexagon_V6_vsububsat_dv_128B, 52962}, // __builtin_HEXAGON_V6_vsububsat_dv_128B
+      {Intrinsic::hexagon_V6_vsubububb_sat, 53001}, // __builtin_HEXAGON_V6_vsubububb_sat
+      {Intrinsic::hexagon_V6_vsubububb_sat_128B, 53036}, // __builtin_HEXAGON_V6_vsubububb_sat_128B
+      {Intrinsic::hexagon_V6_vsubuhsat, 53076}, // __builtin_HEXAGON_V6_vsubuhsat
+      {Intrinsic::hexagon_V6_vsubuhsat_128B, 53107}, // __builtin_HEXAGON_V6_vsubuhsat_128B
+      {Intrinsic::hexagon_V6_vsubuhsat_dv, 53143}, // __builtin_HEXAGON_V6_vsubuhsat_dv
+      {Intrinsic::hexagon_V6_vsubuhsat_dv_128B, 53177}, // __builtin_HEXAGON_V6_vsubuhsat_dv_128B
+      {Intrinsic::hexagon_V6_vsubuhw, 53216}, // __builtin_HEXAGON_V6_vsubuhw
+      {Intrinsic::hexagon_V6_vsubuhw_128B, 53245}, // __builtin_HEXAGON_V6_vsubuhw_128B
+      {Intrinsic::hexagon_V6_vsubuwsat, 53279}, // __builtin_HEXAGON_V6_vsubuwsat
+      {Intrinsic::hexagon_V6_vsubuwsat_128B, 53310}, // __builtin_HEXAGON_V6_vsubuwsat_128B
+      {Intrinsic::hexagon_V6_vsubuwsat_dv, 53346}, // __builtin_HEXAGON_V6_vsubuwsat_dv
+      {Intrinsic::hexagon_V6_vsubuwsat_dv_128B, 53380}, // __builtin_HEXAGON_V6_vsubuwsat_dv_128B
+      {Intrinsic::hexagon_V6_vsubw, 53419}, // __builtin_HEXAGON_V6_vsubw
+      {Intrinsic::hexagon_V6_vsubw_128B, 53446}, // __builtin_HEXAGON_V6_vsubw_128B
+      {Intrinsic::hexagon_V6_vsubw_dv, 53478}, // __builtin_HEXAGON_V6_vsubw_dv
+      {Intrinsic::hexagon_V6_vsubw_dv_128B, 53508}, // __builtin_HEXAGON_V6_vsubw_dv_128B
+      {Intrinsic::hexagon_V6_vsubwsat, 53543}, // __builtin_HEXAGON_V6_vsubwsat
+      {Intrinsic::hexagon_V6_vsubwsat_128B, 53573}, // __builtin_HEXAGON_V6_vsubwsat_128B
+      {Intrinsic::hexagon_V6_vsubwsat_dv, 53608}, // __builtin_HEXAGON_V6_vsubwsat_dv
+      {Intrinsic::hexagon_V6_vsubwsat_dv_128B, 53641}, // __builtin_HEXAGON_V6_vsubwsat_dv_128B
+      {Intrinsic::hexagon_V6_vtmpyb, 53679}, // __builtin_HEXAGON_V6_vtmpyb
+      {Intrinsic::hexagon_V6_vtmpyb_128B, 53707}, // __builtin_HEXAGON_V6_vtmpyb_128B
+      {Intrinsic::hexagon_V6_vtmpyb_acc, 53740}, // __builtin_HEXAGON_V6_vtmpyb_acc
+      {Intrinsic::hexagon_V6_vtmpyb_acc_128B, 53772}, // __builtin_HEXAGON_V6_vtmpyb_acc_128B
+      {Intrinsic::hexagon_V6_vtmpybus, 53809}, // __builtin_HEXAGON_V6_vtmpybus
+      {Intrinsic::hexagon_V6_vtmpybus_128B, 53839}, // __builtin_HEXAGON_V6_vtmpybus_128B
+      {Intrinsic::hexagon_V6_vtmpybus_acc, 53874}, // __builtin_HEXAGON_V6_vtmpybus_acc
+      {Intrinsic::hexagon_V6_vtmpybus_acc_128B, 53908}, // __builtin_HEXAGON_V6_vtmpybus_acc_128B
+      {Intrinsic::hexagon_V6_vtmpyhb, 53947}, // __builtin_HEXAGON_V6_vtmpyhb
+      {Intrinsic::hexagon_V6_vtmpyhb_128B, 53976}, // __builtin_HEXAGON_V6_vtmpyhb_128B
+      {Intrinsic::hexagon_V6_vtmpyhb_acc, 54010}, // __builtin_HEXAGON_V6_vtmpyhb_acc
+      {Intrinsic::hexagon_V6_vtmpyhb_acc_128B, 54043}, // __builtin_HEXAGON_V6_vtmpyhb_acc_128B
+      {Intrinsic::hexagon_V6_vunpackb, 54081}, // __builtin_HEXAGON_V6_vunpackb
+      {Intrinsic::hexagon_V6_vunpackb_128B, 54111}, // __builtin_HEXAGON_V6_vunpackb_128B
+      {Intrinsic::hexagon_V6_vunpackh, 54146}, // __builtin_HEXAGON_V6_vunpackh
+      {Intrinsic::hexagon_V6_vunpackh_128B, 54176}, // __builtin_HEXAGON_V6_vunpackh_128B
+      {Intrinsic::hexagon_V6_vunpackob, 54211}, // __builtin_HEXAGON_V6_vunpackob
+      {Intrinsic::hexagon_V6_vunpackob_128B, 54242}, // __builtin_HEXAGON_V6_vunpackob_128B
+      {Intrinsic::hexagon_V6_vunpackoh, 54278}, // __builtin_HEXAGON_V6_vunpackoh
+      {Intrinsic::hexagon_V6_vunpackoh_128B, 54309}, // __builtin_HEXAGON_V6_vunpackoh_128B
+      {Intrinsic::hexagon_V6_vunpackub, 54345}, // __builtin_HEXAGON_V6_vunpackub
+      {Intrinsic::hexagon_V6_vunpackub_128B, 54376}, // __builtin_HEXAGON_V6_vunpackub_128B
+      {Intrinsic::hexagon_V6_vunpackuh, 54412}, // __builtin_HEXAGON_V6_vunpackuh
+      {Intrinsic::hexagon_V6_vunpackuh_128B, 54443}, // __builtin_HEXAGON_V6_vunpackuh_128B
+      {Intrinsic::hexagon_V6_vxor, 54479}, // __builtin_HEXAGON_V6_vxor
+      {Intrinsic::hexagon_V6_vxor_128B, 54505}, // __builtin_HEXAGON_V6_vxor_128B
+      {Intrinsic::hexagon_V6_vzb, 54536}, // __builtin_HEXAGON_V6_vzb
+      {Intrinsic::hexagon_V6_vzb_128B, 54561}, // __builtin_HEXAGON_V6_vzb_128B
+      {Intrinsic::hexagon_V6_vzh, 54591}, // __builtin_HEXAGON_V6_vzh
+      {Intrinsic::hexagon_V6_vzh_128B, 54616}, // __builtin_HEXAGON_V6_vzh_128B
+      {Intrinsic::hexagon_Y2_dccleana, 54646}, // __builtin_HEXAGON_Y2_dccleana
+      {Intrinsic::hexagon_Y2_dccleaninva, 54676}, // __builtin_HEXAGON_Y2_dccleaninva
+      {Intrinsic::hexagon_Y2_dcfetch, 54709}, // __builtin_HEXAGON_Y2_dcfetch
+      {Intrinsic::hexagon_Y2_dcinva, 54738}, // __builtin_HEXAGON_Y2_dcinva
+      {Intrinsic::hexagon_Y2_dczeroa, 54766}, // __builtin_HEXAGON_Y2_dczeroa
+      {Intrinsic::hexagon_Y4_l2fetch, 54795}, // __builtin_HEXAGON_Y4_l2fetch
+      {Intrinsic::hexagon_Y5_l2fetch, 54824}, // __builtin_HEXAGON_Y5_l2fetch
+      {Intrinsic::hexagon_prefetch, 55066}, // __builtin_HEXAGON_prefetch
+      {Intrinsic::hexagon_S2_storerb_pbr, 30935}, // __builtin_brev_stb
+      {Intrinsic::hexagon_S2_storerd_pbr, 30954}, // __builtin_brev_std
+      {Intrinsic::hexagon_S2_storerh_pbr, 30994}, // __builtin_brev_sth
+      {Intrinsic::hexagon_S2_storerf_pbr, 30973}, // __builtin_brev_sthhi
+      {Intrinsic::hexagon_S2_storeri_pbr, 31013}, // __builtin_brev_stw
+      {Intrinsic::hexagon_circ_ldb, 54853}, // __builtin_circ_ldb
+      {Intrinsic::hexagon_circ_ldd, 54872}, // __builtin_circ_ldd
+      {Intrinsic::hexagon_circ_ldh, 54891}, // __builtin_circ_ldh
+      {Intrinsic::hexagon_circ_ldub, 54910}, // __builtin_circ_ldub
+      {Intrinsic::hexagon_circ_lduh, 54930}, // __builtin_circ_lduh
+      {Intrinsic::hexagon_circ_ldw, 54950}, // __builtin_circ_ldw
+      {Intrinsic::hexagon_circ_stb, 54969}, // __builtin_circ_stb
+      {Intrinsic::hexagon_circ_std, 54988}, // __builtin_circ_std
+      {Intrinsic::hexagon_circ_sth, 55007}, // __builtin_circ_sth
+      {Intrinsic::hexagon_circ_sthhi, 55026}, // __builtin_circ_sthhi
+      {Intrinsic::hexagon_circ_stw, 55047}, // __builtin_circ_stw
+      {Intrinsic::hexagon_vmemcpy, 55093}, // __builtin_hexagon_vmemcpy
+      {Intrinsic::hexagon_vmemset, 55119}, // __builtin_hexagon_vmemset
     };
     auto I = std::lower_bound(std::begin(hexagonNames),
                               std::end(hexagonNames),
@@ -28429,673 +37541,677 @@
   }
   if (TargetPrefix == "mips") {
     static const BuiltinEntry mipsNames[] = {
-      {Intrinsic::mips_absq_s_ph, 59905}, // __builtin_mips_absq_s_ph
-      {Intrinsic::mips_absq_s_qb, 59930}, // __builtin_mips_absq_s_qb
-      {Intrinsic::mips_absq_s_w, 59955}, // __builtin_mips_absq_s_w
-      {Intrinsic::mips_addq_ph, 60067}, // __builtin_mips_addq_ph
-      {Intrinsic::mips_addq_s_ph, 60090}, // __builtin_mips_addq_s_ph
-      {Intrinsic::mips_addq_s_w, 60115}, // __builtin_mips_addq_s_w
-      {Intrinsic::mips_addqh_ph, 60139}, // __builtin_mips_addqh_ph
-      {Intrinsic::mips_addqh_r_ph, 60163}, // __builtin_mips_addqh_r_ph
-      {Intrinsic::mips_addqh_r_w, 60189}, // __builtin_mips_addqh_r_w
-      {Intrinsic::mips_addqh_w, 60214}, // __builtin_mips_addqh_w
-      {Intrinsic::mips_addsc, 60513}, // __builtin_mips_addsc
-      {Intrinsic::mips_addu_ph, 60534}, // __builtin_mips_addu_ph
-      {Intrinsic::mips_addu_qb, 60557}, // __builtin_mips_addu_qb
-      {Intrinsic::mips_addu_s_ph, 60580}, // __builtin_mips_addu_s_ph
-      {Intrinsic::mips_addu_s_qb, 60605}, // __builtin_mips_addu_s_qb
-      {Intrinsic::mips_adduh_qb, 60630}, // __builtin_mips_adduh_qb
-      {Intrinsic::mips_adduh_r_qb, 60654}, // __builtin_mips_adduh_r_qb
-      {Intrinsic::mips_addwc, 60852}, // __builtin_mips_addwc
-      {Intrinsic::mips_append, 60914}, // __builtin_mips_append
-      {Intrinsic::mips_balign, 61480}, // __builtin_mips_balign
-      {Intrinsic::mips_bitrev, 62034}, // __builtin_mips_bitrev
-      {Intrinsic::mips_bposge32, 62412}, // __builtin_mips_bposge32
-      {Intrinsic::mips_cmp_eq_ph, 63651}, // __builtin_mips_cmp_eq_ph
-      {Intrinsic::mips_cmp_le_ph, 63676}, // __builtin_mips_cmp_le_ph
-      {Intrinsic::mips_cmp_lt_ph, 63701}, // __builtin_mips_cmp_lt_ph
-      {Intrinsic::mips_cmpgdu_eq_qb, 63726}, // __builtin_mips_cmpgdu_eq_qb
-      {Intrinsic::mips_cmpgdu_le_qb, 63754}, // __builtin_mips_cmpgdu_le_qb
-      {Intrinsic::mips_cmpgdu_lt_qb, 63782}, // __builtin_mips_cmpgdu_lt_qb
-      {Intrinsic::mips_cmpgu_eq_qb, 63810}, // __builtin_mips_cmpgu_eq_qb
-      {Intrinsic::mips_cmpgu_le_qb, 63837}, // __builtin_mips_cmpgu_le_qb
-      {Intrinsic::mips_cmpgu_lt_qb, 63864}, // __builtin_mips_cmpgu_lt_qb
-      {Intrinsic::mips_cmpu_eq_qb, 63891}, // __builtin_mips_cmpu_eq_qb
-      {Intrinsic::mips_cmpu_le_qb, 63917}, // __builtin_mips_cmpu_le_qb
-      {Intrinsic::mips_cmpu_lt_qb, 63943}, // __builtin_mips_cmpu_lt_qb
-      {Intrinsic::mips_dlsa, 64350}, // __builtin_mips_dlsa
-      {Intrinsic::mips_dpa_w_ph, 64508}, // __builtin_mips_dpa_w_ph
-      {Intrinsic::mips_dpaq_s_w_ph, 64676}, // __builtin_mips_dpaq_s_w_ph
-      {Intrinsic::mips_dpaq_sa_l_w, 64703}, // __builtin_mips_dpaq_sa_l_w
-      {Intrinsic::mips_dpaqx_s_w_ph, 64730}, // __builtin_mips_dpaqx_s_w_ph
-      {Intrinsic::mips_dpaqx_sa_w_ph, 64758}, // __builtin_mips_dpaqx_sa_w_ph
-      {Intrinsic::mips_dpau_h_qbl, 64787}, // __builtin_mips_dpau_h_qbl
-      {Intrinsic::mips_dpau_h_qbr, 64813}, // __builtin_mips_dpau_h_qbr
-      {Intrinsic::mips_dpax_w_ph, 64839}, // __builtin_mips_dpax_w_ph
-      {Intrinsic::mips_dps_w_ph, 64864}, // __builtin_mips_dps_w_ph
-      {Intrinsic::mips_dpsq_s_w_ph, 64888}, // __builtin_mips_dpsq_s_w_ph
-      {Intrinsic::mips_dpsq_sa_l_w, 64915}, // __builtin_mips_dpsq_sa_l_w
-      {Intrinsic::mips_dpsqx_s_w_ph, 64942}, // __builtin_mips_dpsqx_s_w_ph
-      {Intrinsic::mips_dpsqx_sa_w_ph, 64970}, // __builtin_mips_dpsqx_sa_w_ph
-      {Intrinsic::mips_dpsu_h_qbl, 64999}, // __builtin_mips_dpsu_h_qbl
-      {Intrinsic::mips_dpsu_h_qbr, 65025}, // __builtin_mips_dpsu_h_qbr
-      {Intrinsic::mips_dpsx_w_ph, 65195}, // __builtin_mips_dpsx_w_ph
-      {Intrinsic::mips_extp, 65220}, // __builtin_mips_extp
-      {Intrinsic::mips_extpdp, 65240}, // __builtin_mips_extpdp
-      {Intrinsic::mips_extr_r_w, 65262}, // __builtin_mips_extr_r_w
-      {Intrinsic::mips_extr_rs_w, 65286}, // __builtin_mips_extr_rs_w
-      {Intrinsic::mips_extr_s_h, 65311}, // __builtin_mips_extr_s_h
-      {Intrinsic::mips_extr_w, 65335}, // __builtin_mips_extr_w
-      {Intrinsic::mips_insv, 68387}, // __builtin_mips_insv
-      {Intrinsic::mips_lbux, 68495}, // __builtin_mips_lbux
-      {Intrinsic::mips_lhx, 68671}, // __builtin_mips_lhx
-      {Intrinsic::mips_lsa, 68690}, // __builtin_mips_lsa
-      {Intrinsic::mips_lwx, 68709}, // __builtin_mips_lwx
-      {Intrinsic::mips_madd, 68728}, // __builtin_mips_madd
-      {Intrinsic::mips_maddu, 68842}, // __builtin_mips_maddu
-      {Intrinsic::mips_maq_s_w_phl, 68951}, // __builtin_mips_maq_s_w_phl
-      {Intrinsic::mips_maq_s_w_phr, 68978}, // __builtin_mips_maq_s_w_phr
-      {Intrinsic::mips_maq_sa_w_phl, 69005}, // __builtin_mips_maq_sa_w_phl
-      {Intrinsic::mips_maq_sa_w_phr, 69033}, // __builtin_mips_maq_sa_w_phr
-      {Intrinsic::mips_modsub, 70133}, // __builtin_mips_modsub
-      {Intrinsic::mips_msub, 70176}, // __builtin_mips_msub
-      {Intrinsic::mips_msubu, 70290}, // __builtin_mips_msubu
-      {Intrinsic::mips_mthlip, 70399}, // __builtin_mips_mthlip
-      {Intrinsic::mips_mul_ph, 70421}, // __builtin_mips_mul_ph
-      {Intrinsic::mips_mul_s_ph, 70487}, // __builtin_mips_mul_s_ph
-      {Intrinsic::mips_muleq_s_w_phl, 70511}, // __builtin_mips_muleq_s_w_phl
-      {Intrinsic::mips_muleq_s_w_phr, 70540}, // __builtin_mips_muleq_s_w_phr
-      {Intrinsic::mips_muleu_s_ph_qbl, 70569}, // __builtin_mips_muleu_s_ph_qbl
-      {Intrinsic::mips_muleu_s_ph_qbr, 70599}, // __builtin_mips_muleu_s_ph_qbr
-      {Intrinsic::mips_mulq_rs_ph, 70629}, // __builtin_mips_mulq_rs_ph
-      {Intrinsic::mips_mulq_rs_w, 70655}, // __builtin_mips_mulq_rs_w
-      {Intrinsic::mips_mulq_s_ph, 70680}, // __builtin_mips_mulq_s_ph
-      {Intrinsic::mips_mulq_s_w, 70705}, // __builtin_mips_mulq_s_w
-      {Intrinsic::mips_mulsa_w_ph, 70775}, // __builtin_mips_mulsa_w_ph
-      {Intrinsic::mips_mulsaq_s_w_ph, 70801}, // __builtin_mips_mulsaq_s_w_ph
-      {Intrinsic::mips_mult, 70830}, // __builtin_mips_mult
-      {Intrinsic::mips_multu, 70850}, // __builtin_mips_multu
-      {Intrinsic::mips_packrl_ph, 71203}, // __builtin_mips_packrl_ph
-      {Intrinsic::mips_pick_ph, 71488}, // __builtin_mips_pick_ph
-      {Intrinsic::mips_pick_qb, 71511}, // __builtin_mips_pick_qb
-      {Intrinsic::mips_preceq_w_phl, 71534}, // __builtin_mips_preceq_w_phl
-      {Intrinsic::mips_preceq_w_phr, 71562}, // __builtin_mips_preceq_w_phr
-      {Intrinsic::mips_precequ_ph_qbl, 71590}, // __builtin_mips_precequ_ph_qbl
-      {Intrinsic::mips_precequ_ph_qbla, 71620}, // __builtin_mips_precequ_ph_qbla
-      {Intrinsic::mips_precequ_ph_qbr, 71651}, // __builtin_mips_precequ_ph_qbr
-      {Intrinsic::mips_precequ_ph_qbra, 71681}, // __builtin_mips_precequ_ph_qbra
-      {Intrinsic::mips_preceu_ph_qbl, 71712}, // __builtin_mips_preceu_ph_qbl
-      {Intrinsic::mips_preceu_ph_qbla, 71741}, // __builtin_mips_preceu_ph_qbla
-      {Intrinsic::mips_preceu_ph_qbr, 71771}, // __builtin_mips_preceu_ph_qbr
-      {Intrinsic::mips_preceu_ph_qbra, 71800}, // __builtin_mips_preceu_ph_qbra
-      {Intrinsic::mips_precr_qb_ph, 71830}, // __builtin_mips_precr_qb_ph
-      {Intrinsic::mips_precr_sra_ph_w, 71857}, // __builtin_mips_precr_sra_ph_w
-      {Intrinsic::mips_precr_sra_r_ph_w, 71887}, // __builtin_mips_precr_sra_r_ph_w
-      {Intrinsic::mips_precrq_ph_w, 71919}, // __builtin_mips_precrq_ph_w
-      {Intrinsic::mips_precrq_qb_ph, 71946}, // __builtin_mips_precrq_qb_ph
-      {Intrinsic::mips_precrq_rs_ph_w, 71974}, // __builtin_mips_precrq_rs_ph_w
-      {Intrinsic::mips_precrqu_s_qb_ph, 72004}, // __builtin_mips_precrqu_s_qb_ph
-      {Intrinsic::mips_prepend, 72035}, // __builtin_mips_prepend
-      {Intrinsic::mips_raddu_w_qb, 72058}, // __builtin_mips_raddu_w_qb
-      {Intrinsic::mips_rddsp, 72084}, // __builtin_mips_rddsp
-      {Intrinsic::mips_repl_ph, 72105}, // __builtin_mips_repl_ph
-      {Intrinsic::mips_repl_qb, 72128}, // __builtin_mips_repl_qb
-      {Intrinsic::mips_shilo, 72387}, // __builtin_mips_shilo
-      {Intrinsic::mips_shll_ph, 72408}, // __builtin_mips_shll_ph
-      {Intrinsic::mips_shll_qb, 72431}, // __builtin_mips_shll_qb
-      {Intrinsic::mips_shll_s_ph, 72454}, // __builtin_mips_shll_s_ph
-      {Intrinsic::mips_shll_s_w, 72479}, // __builtin_mips_shll_s_w
-      {Intrinsic::mips_shra_ph, 72503}, // __builtin_mips_shra_ph
-      {Intrinsic::mips_shra_qb, 72526}, // __builtin_mips_shra_qb
-      {Intrinsic::mips_shra_r_ph, 72549}, // __builtin_mips_shra_r_ph
-      {Intrinsic::mips_shra_r_qb, 72574}, // __builtin_mips_shra_r_qb
-      {Intrinsic::mips_shra_r_w, 72599}, // __builtin_mips_shra_r_w
-      {Intrinsic::mips_shrl_ph, 72623}, // __builtin_mips_shrl_ph
-      {Intrinsic::mips_shrl_qb, 72646}, // __builtin_mips_shrl_qb
-      {Intrinsic::mips_subq_ph, 73925}, // __builtin_mips_subq_ph
-      {Intrinsic::mips_subq_s_ph, 73948}, // __builtin_mips_subq_s_ph
-      {Intrinsic::mips_subq_s_w, 73973}, // __builtin_mips_subq_s_w
-      {Intrinsic::mips_subqh_ph, 73997}, // __builtin_mips_subqh_ph
-      {Intrinsic::mips_subqh_r_ph, 74021}, // __builtin_mips_subqh_r_ph
-      {Intrinsic::mips_subqh_r_w, 74047}, // __builtin_mips_subqh_r_w
-      {Intrinsic::mips_subqh_w, 74072}, // __builtin_mips_subqh_w
-      {Intrinsic::mips_subu_ph, 74479}, // __builtin_mips_subu_ph
-      {Intrinsic::mips_subu_qb, 74502}, // __builtin_mips_subu_qb
-      {Intrinsic::mips_subu_s_ph, 74525}, // __builtin_mips_subu_s_ph
-      {Intrinsic::mips_subu_s_qb, 74550}, // __builtin_mips_subu_s_qb
-      {Intrinsic::mips_subuh_qb, 74575}, // __builtin_mips_subuh_qb
-      {Intrinsic::mips_subuh_r_qb, 74599}, // __builtin_mips_subuh_r_qb
-      {Intrinsic::mips_wrdsp, 74881}, // __builtin_mips_wrdsp
-      {Intrinsic::mips_add_a_b, 59979}, // __builtin_msa_add_a_b
-      {Intrinsic::mips_add_a_d, 60001}, // __builtin_msa_add_a_d
-      {Intrinsic::mips_add_a_h, 60023}, // __builtin_msa_add_a_h
-      {Intrinsic::mips_add_a_w, 60045}, // __builtin_msa_add_a_w
-      {Intrinsic::mips_adds_a_b, 60237}, // __builtin_msa_adds_a_b
-      {Intrinsic::mips_adds_a_d, 60260}, // __builtin_msa_adds_a_d
-      {Intrinsic::mips_adds_a_h, 60283}, // __builtin_msa_adds_a_h
-      {Intrinsic::mips_adds_a_w, 60306}, // __builtin_msa_adds_a_w
-      {Intrinsic::mips_adds_s_b, 60329}, // __builtin_msa_adds_s_b
-      {Intrinsic::mips_adds_s_d, 60352}, // __builtin_msa_adds_s_d
-      {Intrinsic::mips_adds_s_h, 60375}, // __builtin_msa_adds_s_h
-      {Intrinsic::mips_adds_s_w, 60398}, // __builtin_msa_adds_s_w
-      {Intrinsic::mips_adds_u_b, 60421}, // __builtin_msa_adds_u_b
-      {Intrinsic::mips_adds_u_d, 60444}, // __builtin_msa_adds_u_d
-      {Intrinsic::mips_adds_u_h, 60467}, // __builtin_msa_adds_u_h
-      {Intrinsic::mips_adds_u_w, 60490}, // __builtin_msa_adds_u_w
-      {Intrinsic::mips_addv_b, 60680}, // __builtin_msa_addv_b
-      {Intrinsic::mips_addv_d, 60701}, // __builtin_msa_addv_d
-      {Intrinsic::mips_addv_h, 60722}, // __builtin_msa_addv_h
-      {Intrinsic::mips_addv_w, 60743}, // __builtin_msa_addv_w
-      {Intrinsic::mips_addvi_b, 60764}, // __builtin_msa_addvi_b
-      {Intrinsic::mips_addvi_d, 60786}, // __builtin_msa_addvi_d
-      {Intrinsic::mips_addvi_h, 60808}, // __builtin_msa_addvi_h
-      {Intrinsic::mips_addvi_w, 60830}, // __builtin_msa_addvi_w
-      {Intrinsic::mips_and_v, 60873}, // __builtin_msa_and_v
-      {Intrinsic::mips_andi_b, 60893}, // __builtin_msa_andi_b
-      {Intrinsic::mips_asub_s_b, 60936}, // __builtin_msa_asub_s_b
-      {Intrinsic::mips_asub_s_d, 60959}, // __builtin_msa_asub_s_d
-      {Intrinsic::mips_asub_s_h, 60982}, // __builtin_msa_asub_s_h
-      {Intrinsic::mips_asub_s_w, 61005}, // __builtin_msa_asub_s_w
-      {Intrinsic::mips_asub_u_b, 61028}, // __builtin_msa_asub_u_b
-      {Intrinsic::mips_asub_u_d, 61051}, // __builtin_msa_asub_u_d
-      {Intrinsic::mips_asub_u_h, 61074}, // __builtin_msa_asub_u_h
-      {Intrinsic::mips_asub_u_w, 61097}, // __builtin_msa_asub_u_w
-      {Intrinsic::mips_ave_s_b, 61120}, // __builtin_msa_ave_s_b
-      {Intrinsic::mips_ave_s_d, 61142}, // __builtin_msa_ave_s_d
-      {Intrinsic::mips_ave_s_h, 61164}, // __builtin_msa_ave_s_h
-      {Intrinsic::mips_ave_s_w, 61186}, // __builtin_msa_ave_s_w
-      {Intrinsic::mips_ave_u_b, 61208}, // __builtin_msa_ave_u_b
-      {Intrinsic::mips_ave_u_d, 61230}, // __builtin_msa_ave_u_d
-      {Intrinsic::mips_ave_u_h, 61252}, // __builtin_msa_ave_u_h
-      {Intrinsic::mips_ave_u_w, 61274}, // __builtin_msa_ave_u_w
-      {Intrinsic::mips_aver_s_b, 61296}, // __builtin_msa_aver_s_b
-      {Intrinsic::mips_aver_s_d, 61319}, // __builtin_msa_aver_s_d
-      {Intrinsic::mips_aver_s_h, 61342}, // __builtin_msa_aver_s_h
-      {Intrinsic::mips_aver_s_w, 61365}, // __builtin_msa_aver_s_w
-      {Intrinsic::mips_aver_u_b, 61388}, // __builtin_msa_aver_u_b
-      {Intrinsic::mips_aver_u_d, 61411}, // __builtin_msa_aver_u_d
-      {Intrinsic::mips_aver_u_h, 61434}, // __builtin_msa_aver_u_h
-      {Intrinsic::mips_aver_u_w, 61457}, // __builtin_msa_aver_u_w
-      {Intrinsic::mips_bclr_b, 61502}, // __builtin_msa_bclr_b
-      {Intrinsic::mips_bclr_d, 61523}, // __builtin_msa_bclr_d
-      {Intrinsic::mips_bclr_h, 61544}, // __builtin_msa_bclr_h
-      {Intrinsic::mips_bclr_w, 61565}, // __builtin_msa_bclr_w
-      {Intrinsic::mips_bclri_b, 61586}, // __builtin_msa_bclri_b
-      {Intrinsic::mips_bclri_d, 61608}, // __builtin_msa_bclri_d
-      {Intrinsic::mips_bclri_h, 61630}, // __builtin_msa_bclri_h
-      {Intrinsic::mips_bclri_w, 61652}, // __builtin_msa_bclri_w
-      {Intrinsic::mips_binsl_b, 61674}, // __builtin_msa_binsl_b
-      {Intrinsic::mips_binsl_d, 61696}, // __builtin_msa_binsl_d
-      {Intrinsic::mips_binsl_h, 61718}, // __builtin_msa_binsl_h
-      {Intrinsic::mips_binsl_w, 61740}, // __builtin_msa_binsl_w
-      {Intrinsic::mips_binsli_b, 61762}, // __builtin_msa_binsli_b
-      {Intrinsic::mips_binsli_d, 61785}, // __builtin_msa_binsli_d
-      {Intrinsic::mips_binsli_h, 61808}, // __builtin_msa_binsli_h
-      {Intrinsic::mips_binsli_w, 61831}, // __builtin_msa_binsli_w
-      {Intrinsic::mips_binsr_b, 61854}, // __builtin_msa_binsr_b
-      {Intrinsic::mips_binsr_d, 61876}, // __builtin_msa_binsr_d
-      {Intrinsic::mips_binsr_h, 61898}, // __builtin_msa_binsr_h
-      {Intrinsic::mips_binsr_w, 61920}, // __builtin_msa_binsr_w
-      {Intrinsic::mips_binsri_b, 61942}, // __builtin_msa_binsri_b
-      {Intrinsic::mips_binsri_d, 61965}, // __builtin_msa_binsri_d
-      {Intrinsic::mips_binsri_h, 61988}, // __builtin_msa_binsri_h
-      {Intrinsic::mips_binsri_w, 62011}, // __builtin_msa_binsri_w
-      {Intrinsic::mips_bmnz_v, 62056}, // __builtin_msa_bmnz_v
-      {Intrinsic::mips_bmnzi_b, 62077}, // __builtin_msa_bmnzi_b
-      {Intrinsic::mips_bmz_v, 62099}, // __builtin_msa_bmz_v
-      {Intrinsic::mips_bmzi_b, 62119}, // __builtin_msa_bmzi_b
-      {Intrinsic::mips_bneg_b, 62140}, // __builtin_msa_bneg_b
-      {Intrinsic::mips_bneg_d, 62161}, // __builtin_msa_bneg_d
-      {Intrinsic::mips_bneg_h, 62182}, // __builtin_msa_bneg_h
-      {Intrinsic::mips_bneg_w, 62203}, // __builtin_msa_bneg_w
-      {Intrinsic::mips_bnegi_b, 62224}, // __builtin_msa_bnegi_b
-      {Intrinsic::mips_bnegi_d, 62246}, // __builtin_msa_bnegi_d
-      {Intrinsic::mips_bnegi_h, 62268}, // __builtin_msa_bnegi_h
-      {Intrinsic::mips_bnegi_w, 62290}, // __builtin_msa_bnegi_w
-      {Intrinsic::mips_bnz_b, 62312}, // __builtin_msa_bnz_b
-      {Intrinsic::mips_bnz_d, 62332}, // __builtin_msa_bnz_d
-      {Intrinsic::mips_bnz_h, 62352}, // __builtin_msa_bnz_h
-      {Intrinsic::mips_bnz_v, 62372}, // __builtin_msa_bnz_v
-      {Intrinsic::mips_bnz_w, 62392}, // __builtin_msa_bnz_w
-      {Intrinsic::mips_bsel_v, 62436}, // __builtin_msa_bsel_v
-      {Intrinsic::mips_bseli_b, 62457}, // __builtin_msa_bseli_b
-      {Intrinsic::mips_bset_b, 62479}, // __builtin_msa_bset_b
-      {Intrinsic::mips_bset_d, 62500}, // __builtin_msa_bset_d
-      {Intrinsic::mips_bset_h, 62521}, // __builtin_msa_bset_h
-      {Intrinsic::mips_bset_w, 62542}, // __builtin_msa_bset_w
-      {Intrinsic::mips_bseti_b, 62563}, // __builtin_msa_bseti_b
-      {Intrinsic::mips_bseti_d, 62585}, // __builtin_msa_bseti_d
-      {Intrinsic::mips_bseti_h, 62607}, // __builtin_msa_bseti_h
-      {Intrinsic::mips_bseti_w, 62629}, // __builtin_msa_bseti_w
-      {Intrinsic::mips_bz_b, 62651}, // __builtin_msa_bz_b
-      {Intrinsic::mips_bz_d, 62670}, // __builtin_msa_bz_d
-      {Intrinsic::mips_bz_h, 62689}, // __builtin_msa_bz_h
-      {Intrinsic::mips_bz_v, 62708}, // __builtin_msa_bz_v
-      {Intrinsic::mips_bz_w, 62727}, // __builtin_msa_bz_w
-      {Intrinsic::mips_ceq_b, 62746}, // __builtin_msa_ceq_b
-      {Intrinsic::mips_ceq_d, 62766}, // __builtin_msa_ceq_d
-      {Intrinsic::mips_ceq_h, 62786}, // __builtin_msa_ceq_h
-      {Intrinsic::mips_ceq_w, 62806}, // __builtin_msa_ceq_w
-      {Intrinsic::mips_ceqi_b, 62826}, // __builtin_msa_ceqi_b
-      {Intrinsic::mips_ceqi_d, 62847}, // __builtin_msa_ceqi_d
-      {Intrinsic::mips_ceqi_h, 62868}, // __builtin_msa_ceqi_h
-      {Intrinsic::mips_ceqi_w, 62889}, // __builtin_msa_ceqi_w
-      {Intrinsic::mips_cfcmsa, 62910}, // __builtin_msa_cfcmsa
-      {Intrinsic::mips_cle_s_b, 62931}, // __builtin_msa_cle_s_b
-      {Intrinsic::mips_cle_s_d, 62953}, // __builtin_msa_cle_s_d
-      {Intrinsic::mips_cle_s_h, 62975}, // __builtin_msa_cle_s_h
-      {Intrinsic::mips_cle_s_w, 62997}, // __builtin_msa_cle_s_w
-      {Intrinsic::mips_cle_u_b, 63019}, // __builtin_msa_cle_u_b
-      {Intrinsic::mips_cle_u_d, 63041}, // __builtin_msa_cle_u_d
-      {Intrinsic::mips_cle_u_h, 63063}, // __builtin_msa_cle_u_h
-      {Intrinsic::mips_cle_u_w, 63085}, // __builtin_msa_cle_u_w
-      {Intrinsic::mips_clei_s_b, 63107}, // __builtin_msa_clei_s_b
-      {Intrinsic::mips_clei_s_d, 63130}, // __builtin_msa_clei_s_d
-      {Intrinsic::mips_clei_s_h, 63153}, // __builtin_msa_clei_s_h
-      {Intrinsic::mips_clei_s_w, 63176}, // __builtin_msa_clei_s_w
-      {Intrinsic::mips_clei_u_b, 63199}, // __builtin_msa_clei_u_b
-      {Intrinsic::mips_clei_u_d, 63222}, // __builtin_msa_clei_u_d
-      {Intrinsic::mips_clei_u_h, 63245}, // __builtin_msa_clei_u_h
-      {Intrinsic::mips_clei_u_w, 63268}, // __builtin_msa_clei_u_w
-      {Intrinsic::mips_clt_s_b, 63291}, // __builtin_msa_clt_s_b
-      {Intrinsic::mips_clt_s_d, 63313}, // __builtin_msa_clt_s_d
-      {Intrinsic::mips_clt_s_h, 63335}, // __builtin_msa_clt_s_h
-      {Intrinsic::mips_clt_s_w, 63357}, // __builtin_msa_clt_s_w
-      {Intrinsic::mips_clt_u_b, 63379}, // __builtin_msa_clt_u_b
-      {Intrinsic::mips_clt_u_d, 63401}, // __builtin_msa_clt_u_d
-      {Intrinsic::mips_clt_u_h, 63423}, // __builtin_msa_clt_u_h
-      {Intrinsic::mips_clt_u_w, 63445}, // __builtin_msa_clt_u_w
-      {Intrinsic::mips_clti_s_b, 63467}, // __builtin_msa_clti_s_b
-      {Intrinsic::mips_clti_s_d, 63490}, // __builtin_msa_clti_s_d
-      {Intrinsic::mips_clti_s_h, 63513}, // __builtin_msa_clti_s_h
-      {Intrinsic::mips_clti_s_w, 63536}, // __builtin_msa_clti_s_w
-      {Intrinsic::mips_clti_u_b, 63559}, // __builtin_msa_clti_u_b
-      {Intrinsic::mips_clti_u_d, 63582}, // __builtin_msa_clti_u_d
-      {Intrinsic::mips_clti_u_h, 63605}, // __builtin_msa_clti_u_h
-      {Intrinsic::mips_clti_u_w, 63628}, // __builtin_msa_clti_u_w
-      {Intrinsic::mips_copy_s_b, 63969}, // __builtin_msa_copy_s_b
-      {Intrinsic::mips_copy_s_d, 63992}, // __builtin_msa_copy_s_d
-      {Intrinsic::mips_copy_s_h, 64015}, // __builtin_msa_copy_s_h
-      {Intrinsic::mips_copy_s_w, 64038}, // __builtin_msa_copy_s_w
-      {Intrinsic::mips_copy_u_b, 64061}, // __builtin_msa_copy_u_b
-      {Intrinsic::mips_copy_u_d, 64084}, // __builtin_msa_copy_u_d
-      {Intrinsic::mips_copy_u_h, 64107}, // __builtin_msa_copy_u_h
-      {Intrinsic::mips_copy_u_w, 64130}, // __builtin_msa_copy_u_w
-      {Intrinsic::mips_ctcmsa, 64153}, // __builtin_msa_ctcmsa
-      {Intrinsic::mips_div_s_b, 64174}, // __builtin_msa_div_s_b
-      {Intrinsic::mips_div_s_d, 64196}, // __builtin_msa_div_s_d
-      {Intrinsic::mips_div_s_h, 64218}, // __builtin_msa_div_s_h
-      {Intrinsic::mips_div_s_w, 64240}, // __builtin_msa_div_s_w
-      {Intrinsic::mips_div_u_b, 64262}, // __builtin_msa_div_u_b
-      {Intrinsic::mips_div_u_d, 64284}, // __builtin_msa_div_u_d
-      {Intrinsic::mips_div_u_h, 64306}, // __builtin_msa_div_u_h
-      {Intrinsic::mips_div_u_w, 64328}, // __builtin_msa_div_u_w
-      {Intrinsic::mips_dotp_s_d, 64370}, // __builtin_msa_dotp_s_d
-      {Intrinsic::mips_dotp_s_h, 64393}, // __builtin_msa_dotp_s_h
-      {Intrinsic::mips_dotp_s_w, 64416}, // __builtin_msa_dotp_s_w
-      {Intrinsic::mips_dotp_u_d, 64439}, // __builtin_msa_dotp_u_d
-      {Intrinsic::mips_dotp_u_h, 64462}, // __builtin_msa_dotp_u_h
-      {Intrinsic::mips_dotp_u_w, 64485}, // __builtin_msa_dotp_u_w
-      {Intrinsic::mips_dpadd_s_d, 64532}, // __builtin_msa_dpadd_s_d
-      {Intrinsic::mips_dpadd_s_h, 64556}, // __builtin_msa_dpadd_s_h
-      {Intrinsic::mips_dpadd_s_w, 64580}, // __builtin_msa_dpadd_s_w
-      {Intrinsic::mips_dpadd_u_d, 64604}, // __builtin_msa_dpadd_u_d
-      {Intrinsic::mips_dpadd_u_h, 64628}, // __builtin_msa_dpadd_u_h
-      {Intrinsic::mips_dpadd_u_w, 64652}, // __builtin_msa_dpadd_u_w
-      {Intrinsic::mips_dpsub_s_d, 65051}, // __builtin_msa_dpsub_s_d
-      {Intrinsic::mips_dpsub_s_h, 65075}, // __builtin_msa_dpsub_s_h
-      {Intrinsic::mips_dpsub_s_w, 65099}, // __builtin_msa_dpsub_s_w
-      {Intrinsic::mips_dpsub_u_d, 65123}, // __builtin_msa_dpsub_u_d
-      {Intrinsic::mips_dpsub_u_h, 65147}, // __builtin_msa_dpsub_u_h
-      {Intrinsic::mips_dpsub_u_w, 65171}, // __builtin_msa_dpsub_u_w
-      {Intrinsic::mips_fadd_d, 65357}, // __builtin_msa_fadd_d
-      {Intrinsic::mips_fadd_w, 65378}, // __builtin_msa_fadd_w
-      {Intrinsic::mips_fcaf_d, 65399}, // __builtin_msa_fcaf_d
-      {Intrinsic::mips_fcaf_w, 65420}, // __builtin_msa_fcaf_w
-      {Intrinsic::mips_fceq_d, 65441}, // __builtin_msa_fceq_d
-      {Intrinsic::mips_fceq_w, 65462}, // __builtin_msa_fceq_w
-      {Intrinsic::mips_fclass_d, 65483}, // __builtin_msa_fclass_d
-      {Intrinsic::mips_fclass_w, 65506}, // __builtin_msa_fclass_w
-      {Intrinsic::mips_fcle_d, 65529}, // __builtin_msa_fcle_d
-      {Intrinsic::mips_fcle_w, 65550}, // __builtin_msa_fcle_w
-      {Intrinsic::mips_fclt_d, 65571}, // __builtin_msa_fclt_d
-      {Intrinsic::mips_fclt_w, 65592}, // __builtin_msa_fclt_w
-      {Intrinsic::mips_fcne_d, 65613}, // __builtin_msa_fcne_d
-      {Intrinsic::mips_fcne_w, 65634}, // __builtin_msa_fcne_w
-      {Intrinsic::mips_fcor_d, 65655}, // __builtin_msa_fcor_d
-      {Intrinsic::mips_fcor_w, 65676}, // __builtin_msa_fcor_w
-      {Intrinsic::mips_fcueq_d, 65697}, // __builtin_msa_fcueq_d
-      {Intrinsic::mips_fcueq_w, 65719}, // __builtin_msa_fcueq_w
-      {Intrinsic::mips_fcule_d, 65741}, // __builtin_msa_fcule_d
-      {Intrinsic::mips_fcule_w, 65763}, // __builtin_msa_fcule_w
-      {Intrinsic::mips_fcult_d, 65785}, // __builtin_msa_fcult_d
-      {Intrinsic::mips_fcult_w, 65807}, // __builtin_msa_fcult_w
-      {Intrinsic::mips_fcun_d, 65829}, // __builtin_msa_fcun_d
-      {Intrinsic::mips_fcun_w, 65850}, // __builtin_msa_fcun_w
-      {Intrinsic::mips_fcune_d, 65871}, // __builtin_msa_fcune_d
-      {Intrinsic::mips_fcune_w, 65893}, // __builtin_msa_fcune_w
-      {Intrinsic::mips_fdiv_d, 65915}, // __builtin_msa_fdiv_d
-      {Intrinsic::mips_fdiv_w, 65936}, // __builtin_msa_fdiv_w
-      {Intrinsic::mips_fexdo_h, 65957}, // __builtin_msa_fexdo_h
-      {Intrinsic::mips_fexdo_w, 65979}, // __builtin_msa_fexdo_w
-      {Intrinsic::mips_fexp2_d, 66001}, // __builtin_msa_fexp2_d
-      {Intrinsic::mips_fexp2_w, 66023}, // __builtin_msa_fexp2_w
-      {Intrinsic::mips_fexupl_d, 66045}, // __builtin_msa_fexupl_d
-      {Intrinsic::mips_fexupl_w, 66068}, // __builtin_msa_fexupl_w
-      {Intrinsic::mips_fexupr_d, 66091}, // __builtin_msa_fexupr_d
-      {Intrinsic::mips_fexupr_w, 66114}, // __builtin_msa_fexupr_w
-      {Intrinsic::mips_ffint_s_d, 66137}, // __builtin_msa_ffint_s_d
-      {Intrinsic::mips_ffint_s_w, 66161}, // __builtin_msa_ffint_s_w
-      {Intrinsic::mips_ffint_u_d, 66185}, // __builtin_msa_ffint_u_d
-      {Intrinsic::mips_ffint_u_w, 66209}, // __builtin_msa_ffint_u_w
-      {Intrinsic::mips_ffql_d, 66233}, // __builtin_msa_ffql_d
-      {Intrinsic::mips_ffql_w, 66254}, // __builtin_msa_ffql_w
-      {Intrinsic::mips_ffqr_d, 66275}, // __builtin_msa_ffqr_d
-      {Intrinsic::mips_ffqr_w, 66296}, // __builtin_msa_ffqr_w
-      {Intrinsic::mips_fill_b, 66317}, // __builtin_msa_fill_b
-      {Intrinsic::mips_fill_d, 66338}, // __builtin_msa_fill_d
-      {Intrinsic::mips_fill_h, 66359}, // __builtin_msa_fill_h
-      {Intrinsic::mips_fill_w, 66380}, // __builtin_msa_fill_w
-      {Intrinsic::mips_flog2_d, 66401}, // __builtin_msa_flog2_d
-      {Intrinsic::mips_flog2_w, 66423}, // __builtin_msa_flog2_w
-      {Intrinsic::mips_fmadd_d, 66445}, // __builtin_msa_fmadd_d
-      {Intrinsic::mips_fmadd_w, 66467}, // __builtin_msa_fmadd_w
-      {Intrinsic::mips_fmax_a_d, 66489}, // __builtin_msa_fmax_a_d
-      {Intrinsic::mips_fmax_a_w, 66512}, // __builtin_msa_fmax_a_w
-      {Intrinsic::mips_fmax_d, 66535}, // __builtin_msa_fmax_d
-      {Intrinsic::mips_fmax_w, 66556}, // __builtin_msa_fmax_w
-      {Intrinsic::mips_fmin_a_d, 66577}, // __builtin_msa_fmin_a_d
-      {Intrinsic::mips_fmin_a_w, 66600}, // __builtin_msa_fmin_a_w
-      {Intrinsic::mips_fmin_d, 66623}, // __builtin_msa_fmin_d
-      {Intrinsic::mips_fmin_w, 66644}, // __builtin_msa_fmin_w
-      {Intrinsic::mips_fmsub_d, 66665}, // __builtin_msa_fmsub_d
-      {Intrinsic::mips_fmsub_w, 66687}, // __builtin_msa_fmsub_w
-      {Intrinsic::mips_fmul_d, 66709}, // __builtin_msa_fmul_d
-      {Intrinsic::mips_fmul_w, 66730}, // __builtin_msa_fmul_w
-      {Intrinsic::mips_frcp_d, 66751}, // __builtin_msa_frcp_d
-      {Intrinsic::mips_frcp_w, 66772}, // __builtin_msa_frcp_w
-      {Intrinsic::mips_frint_d, 66793}, // __builtin_msa_frint_d
-      {Intrinsic::mips_frint_w, 66815}, // __builtin_msa_frint_w
-      {Intrinsic::mips_frsqrt_d, 66837}, // __builtin_msa_frsqrt_d
-      {Intrinsic::mips_frsqrt_w, 66860}, // __builtin_msa_frsqrt_w
-      {Intrinsic::mips_fsaf_d, 66883}, // __builtin_msa_fsaf_d
-      {Intrinsic::mips_fsaf_w, 66904}, // __builtin_msa_fsaf_w
-      {Intrinsic::mips_fseq_d, 66925}, // __builtin_msa_fseq_d
-      {Intrinsic::mips_fseq_w, 66946}, // __builtin_msa_fseq_w
-      {Intrinsic::mips_fsle_d, 66967}, // __builtin_msa_fsle_d
-      {Intrinsic::mips_fsle_w, 66988}, // __builtin_msa_fsle_w
-      {Intrinsic::mips_fslt_d, 67009}, // __builtin_msa_fslt_d
-      {Intrinsic::mips_fslt_w, 67030}, // __builtin_msa_fslt_w
-      {Intrinsic::mips_fsne_d, 67051}, // __builtin_msa_fsne_d
-      {Intrinsic::mips_fsne_w, 67072}, // __builtin_msa_fsne_w
-      {Intrinsic::mips_fsor_d, 67093}, // __builtin_msa_fsor_d
-      {Intrinsic::mips_fsor_w, 67114}, // __builtin_msa_fsor_w
-      {Intrinsic::mips_fsqrt_d, 67135}, // __builtin_msa_fsqrt_d
-      {Intrinsic::mips_fsqrt_w, 67157}, // __builtin_msa_fsqrt_w
-      {Intrinsic::mips_fsub_d, 67179}, // __builtin_msa_fsub_d
-      {Intrinsic::mips_fsub_w, 67200}, // __builtin_msa_fsub_w
-      {Intrinsic::mips_fsueq_d, 67221}, // __builtin_msa_fsueq_d
-      {Intrinsic::mips_fsueq_w, 67243}, // __builtin_msa_fsueq_w
-      {Intrinsic::mips_fsule_d, 67265}, // __builtin_msa_fsule_d
-      {Intrinsic::mips_fsule_w, 67287}, // __builtin_msa_fsule_w
-      {Intrinsic::mips_fsult_d, 67309}, // __builtin_msa_fsult_d
-      {Intrinsic::mips_fsult_w, 67331}, // __builtin_msa_fsult_w
-      {Intrinsic::mips_fsun_d, 67353}, // __builtin_msa_fsun_d
-      {Intrinsic::mips_fsun_w, 67374}, // __builtin_msa_fsun_w
-      {Intrinsic::mips_fsune_d, 67395}, // __builtin_msa_fsune_d
-      {Intrinsic::mips_fsune_w, 67417}, // __builtin_msa_fsune_w
-      {Intrinsic::mips_ftint_s_d, 67439}, // __builtin_msa_ftint_s_d
-      {Intrinsic::mips_ftint_s_w, 67463}, // __builtin_msa_ftint_s_w
-      {Intrinsic::mips_ftint_u_d, 67487}, // __builtin_msa_ftint_u_d
-      {Intrinsic::mips_ftint_u_w, 67511}, // __builtin_msa_ftint_u_w
-      {Intrinsic::mips_ftq_h, 67535}, // __builtin_msa_ftq_h
-      {Intrinsic::mips_ftq_w, 67555}, // __builtin_msa_ftq_w
-      {Intrinsic::mips_ftrunc_s_d, 67575}, // __builtin_msa_ftrunc_s_d
-      {Intrinsic::mips_ftrunc_s_w, 67600}, // __builtin_msa_ftrunc_s_w
-      {Intrinsic::mips_ftrunc_u_d, 67625}, // __builtin_msa_ftrunc_u_d
-      {Intrinsic::mips_ftrunc_u_w, 67650}, // __builtin_msa_ftrunc_u_w
-      {Intrinsic::mips_hadd_s_d, 67675}, // __builtin_msa_hadd_s_d
-      {Intrinsic::mips_hadd_s_h, 67698}, // __builtin_msa_hadd_s_h
-      {Intrinsic::mips_hadd_s_w, 67721}, // __builtin_msa_hadd_s_w
-      {Intrinsic::mips_hadd_u_d, 67744}, // __builtin_msa_hadd_u_d
-      {Intrinsic::mips_hadd_u_h, 67767}, // __builtin_msa_hadd_u_h
-      {Intrinsic::mips_hadd_u_w, 67790}, // __builtin_msa_hadd_u_w
-      {Intrinsic::mips_hsub_s_d, 67813}, // __builtin_msa_hsub_s_d
-      {Intrinsic::mips_hsub_s_h, 67836}, // __builtin_msa_hsub_s_h
-      {Intrinsic::mips_hsub_s_w, 67859}, // __builtin_msa_hsub_s_w
-      {Intrinsic::mips_hsub_u_d, 67882}, // __builtin_msa_hsub_u_d
-      {Intrinsic::mips_hsub_u_h, 67905}, // __builtin_msa_hsub_u_h
-      {Intrinsic::mips_hsub_u_w, 67928}, // __builtin_msa_hsub_u_w
-      {Intrinsic::mips_ilvev_b, 67951}, // __builtin_msa_ilvev_b
-      {Intrinsic::mips_ilvev_d, 67973}, // __builtin_msa_ilvev_d
-      {Intrinsic::mips_ilvev_h, 67995}, // __builtin_msa_ilvev_h
-      {Intrinsic::mips_ilvev_w, 68017}, // __builtin_msa_ilvev_w
-      {Intrinsic::mips_ilvl_b, 68039}, // __builtin_msa_ilvl_b
-      {Intrinsic::mips_ilvl_d, 68060}, // __builtin_msa_ilvl_d
-      {Intrinsic::mips_ilvl_h, 68081}, // __builtin_msa_ilvl_h
-      {Intrinsic::mips_ilvl_w, 68102}, // __builtin_msa_ilvl_w
-      {Intrinsic::mips_ilvod_b, 68123}, // __builtin_msa_ilvod_b
-      {Intrinsic::mips_ilvod_d, 68145}, // __builtin_msa_ilvod_d
-      {Intrinsic::mips_ilvod_h, 68167}, // __builtin_msa_ilvod_h
-      {Intrinsic::mips_ilvod_w, 68189}, // __builtin_msa_ilvod_w
-      {Intrinsic::mips_ilvr_b, 68211}, // __builtin_msa_ilvr_b
-      {Intrinsic::mips_ilvr_d, 68232}, // __builtin_msa_ilvr_d
-      {Intrinsic::mips_ilvr_h, 68253}, // __builtin_msa_ilvr_h
-      {Intrinsic::mips_ilvr_w, 68274}, // __builtin_msa_ilvr_w
-      {Intrinsic::mips_insert_b, 68295}, // __builtin_msa_insert_b
-      {Intrinsic::mips_insert_d, 68318}, // __builtin_msa_insert_d
-      {Intrinsic::mips_insert_h, 68341}, // __builtin_msa_insert_h
-      {Intrinsic::mips_insert_w, 68364}, // __builtin_msa_insert_w
-      {Intrinsic::mips_insve_b, 68407}, // __builtin_msa_insve_b
-      {Intrinsic::mips_insve_d, 68429}, // __builtin_msa_insve_d
-      {Intrinsic::mips_insve_h, 68451}, // __builtin_msa_insve_h
-      {Intrinsic::mips_insve_w, 68473}, // __builtin_msa_insve_w
-      {Intrinsic::mips_ld_b, 68515}, // __builtin_msa_ld_b
-      {Intrinsic::mips_ld_d, 68534}, // __builtin_msa_ld_d
-      {Intrinsic::mips_ld_h, 68553}, // __builtin_msa_ld_h
-      {Intrinsic::mips_ld_w, 68572}, // __builtin_msa_ld_w
-      {Intrinsic::mips_ldi_b, 68591}, // __builtin_msa_ldi_b
-      {Intrinsic::mips_ldi_d, 68611}, // __builtin_msa_ldi_d
-      {Intrinsic::mips_ldi_h, 68631}, // __builtin_msa_ldi_h
-      {Intrinsic::mips_ldi_w, 68651}, // __builtin_msa_ldi_w
-      {Intrinsic::mips_madd_q_h, 68748}, // __builtin_msa_madd_q_h
-      {Intrinsic::mips_madd_q_w, 68771}, // __builtin_msa_madd_q_w
-      {Intrinsic::mips_maddr_q_h, 68794}, // __builtin_msa_maddr_q_h
-      {Intrinsic::mips_maddr_q_w, 68818}, // __builtin_msa_maddr_q_w
-      {Intrinsic::mips_maddv_b, 68863}, // __builtin_msa_maddv_b
-      {Intrinsic::mips_maddv_d, 68885}, // __builtin_msa_maddv_d
-      {Intrinsic::mips_maddv_h, 68907}, // __builtin_msa_maddv_h
-      {Intrinsic::mips_maddv_w, 68929}, // __builtin_msa_maddv_w
-      {Intrinsic::mips_max_a_b, 69061}, // __builtin_msa_max_a_b
-      {Intrinsic::mips_max_a_d, 69083}, // __builtin_msa_max_a_d
-      {Intrinsic::mips_max_a_h, 69105}, // __builtin_msa_max_a_h
-      {Intrinsic::mips_max_a_w, 69127}, // __builtin_msa_max_a_w
-      {Intrinsic::mips_max_s_b, 69149}, // __builtin_msa_max_s_b
-      {Intrinsic::mips_max_s_d, 69171}, // __builtin_msa_max_s_d
-      {Intrinsic::mips_max_s_h, 69193}, // __builtin_msa_max_s_h
-      {Intrinsic::mips_max_s_w, 69215}, // __builtin_msa_max_s_w
-      {Intrinsic::mips_max_u_b, 69237}, // __builtin_msa_max_u_b
-      {Intrinsic::mips_max_u_d, 69259}, // __builtin_msa_max_u_d
-      {Intrinsic::mips_max_u_h, 69281}, // __builtin_msa_max_u_h
-      {Intrinsic::mips_max_u_w, 69303}, // __builtin_msa_max_u_w
-      {Intrinsic::mips_maxi_s_b, 69325}, // __builtin_msa_maxi_s_b
-      {Intrinsic::mips_maxi_s_d, 69348}, // __builtin_msa_maxi_s_d
-      {Intrinsic::mips_maxi_s_h, 69371}, // __builtin_msa_maxi_s_h
-      {Intrinsic::mips_maxi_s_w, 69394}, // __builtin_msa_maxi_s_w
-      {Intrinsic::mips_maxi_u_b, 69417}, // __builtin_msa_maxi_u_b
-      {Intrinsic::mips_maxi_u_d, 69440}, // __builtin_msa_maxi_u_d
-      {Intrinsic::mips_maxi_u_h, 69463}, // __builtin_msa_maxi_u_h
-      {Intrinsic::mips_maxi_u_w, 69486}, // __builtin_msa_maxi_u_w
-      {Intrinsic::mips_min_a_b, 69509}, // __builtin_msa_min_a_b
-      {Intrinsic::mips_min_a_d, 69531}, // __builtin_msa_min_a_d
-      {Intrinsic::mips_min_a_h, 69553}, // __builtin_msa_min_a_h
-      {Intrinsic::mips_min_a_w, 69575}, // __builtin_msa_min_a_w
-      {Intrinsic::mips_min_s_b, 69597}, // __builtin_msa_min_s_b
-      {Intrinsic::mips_min_s_d, 69619}, // __builtin_msa_min_s_d
-      {Intrinsic::mips_min_s_h, 69641}, // __builtin_msa_min_s_h
-      {Intrinsic::mips_min_s_w, 69663}, // __builtin_msa_min_s_w
-      {Intrinsic::mips_min_u_b, 69685}, // __builtin_msa_min_u_b
-      {Intrinsic::mips_min_u_d, 69707}, // __builtin_msa_min_u_d
-      {Intrinsic::mips_min_u_h, 69729}, // __builtin_msa_min_u_h
-      {Intrinsic::mips_min_u_w, 69751}, // __builtin_msa_min_u_w
-      {Intrinsic::mips_mini_s_b, 69773}, // __builtin_msa_mini_s_b
-      {Intrinsic::mips_mini_s_d, 69796}, // __builtin_msa_mini_s_d
-      {Intrinsic::mips_mini_s_h, 69819}, // __builtin_msa_mini_s_h
-      {Intrinsic::mips_mini_s_w, 69842}, // __builtin_msa_mini_s_w
-      {Intrinsic::mips_mini_u_b, 69865}, // __builtin_msa_mini_u_b
-      {Intrinsic::mips_mini_u_d, 69888}, // __builtin_msa_mini_u_d
-      {Intrinsic::mips_mini_u_h, 69911}, // __builtin_msa_mini_u_h
-      {Intrinsic::mips_mini_u_w, 69934}, // __builtin_msa_mini_u_w
-      {Intrinsic::mips_mod_s_b, 69957}, // __builtin_msa_mod_s_b
-      {Intrinsic::mips_mod_s_d, 69979}, // __builtin_msa_mod_s_d
-      {Intrinsic::mips_mod_s_h, 70001}, // __builtin_msa_mod_s_h
-      {Intrinsic::mips_mod_s_w, 70023}, // __builtin_msa_mod_s_w
-      {Intrinsic::mips_mod_u_b, 70045}, // __builtin_msa_mod_u_b
-      {Intrinsic::mips_mod_u_d, 70067}, // __builtin_msa_mod_u_d
-      {Intrinsic::mips_mod_u_h, 70089}, // __builtin_msa_mod_u_h
-      {Intrinsic::mips_mod_u_w, 70111}, // __builtin_msa_mod_u_w
-      {Intrinsic::mips_move_v, 70155}, // __builtin_msa_move_v
-      {Intrinsic::mips_msub_q_h, 70196}, // __builtin_msa_msub_q_h
-      {Intrinsic::mips_msub_q_w, 70219}, // __builtin_msa_msub_q_w
-      {Intrinsic::mips_msubr_q_h, 70242}, // __builtin_msa_msubr_q_h
-      {Intrinsic::mips_msubr_q_w, 70266}, // __builtin_msa_msubr_q_w
-      {Intrinsic::mips_msubv_b, 70311}, // __builtin_msa_msubv_b
-      {Intrinsic::mips_msubv_d, 70333}, // __builtin_msa_msubv_d
-      {Intrinsic::mips_msubv_h, 70355}, // __builtin_msa_msubv_h
-      {Intrinsic::mips_msubv_w, 70377}, // __builtin_msa_msubv_w
-      {Intrinsic::mips_mul_q_h, 70443}, // __builtin_msa_mul_q_h
-      {Intrinsic::mips_mul_q_w, 70465}, // __builtin_msa_mul_q_w
-      {Intrinsic::mips_mulr_q_h, 70729}, // __builtin_msa_mulr_q_h
-      {Intrinsic::mips_mulr_q_w, 70752}, // __builtin_msa_mulr_q_w
-      {Intrinsic::mips_mulv_b, 70871}, // __builtin_msa_mulv_b
-      {Intrinsic::mips_mulv_d, 70892}, // __builtin_msa_mulv_d
-      {Intrinsic::mips_mulv_h, 70913}, // __builtin_msa_mulv_h
-      {Intrinsic::mips_mulv_w, 70934}, // __builtin_msa_mulv_w
-      {Intrinsic::mips_nloc_b, 70955}, // __builtin_msa_nloc_b
-      {Intrinsic::mips_nloc_d, 70976}, // __builtin_msa_nloc_d
-      {Intrinsic::mips_nloc_h, 70997}, // __builtin_msa_nloc_h
-      {Intrinsic::mips_nloc_w, 71018}, // __builtin_msa_nloc_w
-      {Intrinsic::mips_nlzc_b, 71039}, // __builtin_msa_nlzc_b
-      {Intrinsic::mips_nlzc_d, 71060}, // __builtin_msa_nlzc_d
-      {Intrinsic::mips_nlzc_h, 71081}, // __builtin_msa_nlzc_h
-      {Intrinsic::mips_nlzc_w, 71102}, // __builtin_msa_nlzc_w
-      {Intrinsic::mips_nor_v, 71123}, // __builtin_msa_nor_v
-      {Intrinsic::mips_nori_b, 71143}, // __builtin_msa_nori_b
-      {Intrinsic::mips_or_v, 71164}, // __builtin_msa_or_v
-      {Intrinsic::mips_ori_b, 71183}, // __builtin_msa_ori_b
-      {Intrinsic::mips_pckev_b, 71228}, // __builtin_msa_pckev_b
-      {Intrinsic::mips_pckev_d, 71250}, // __builtin_msa_pckev_d
-      {Intrinsic::mips_pckev_h, 71272}, // __builtin_msa_pckev_h
-      {Intrinsic::mips_pckev_w, 71294}, // __builtin_msa_pckev_w
-      {Intrinsic::mips_pckod_b, 71316}, // __builtin_msa_pckod_b
-      {Intrinsic::mips_pckod_d, 71338}, // __builtin_msa_pckod_d
-      {Intrinsic::mips_pckod_h, 71360}, // __builtin_msa_pckod_h
-      {Intrinsic::mips_pckod_w, 71382}, // __builtin_msa_pckod_w
-      {Intrinsic::mips_pcnt_b, 71404}, // __builtin_msa_pcnt_b
-      {Intrinsic::mips_pcnt_d, 71425}, // __builtin_msa_pcnt_d
-      {Intrinsic::mips_pcnt_h, 71446}, // __builtin_msa_pcnt_h
-      {Intrinsic::mips_pcnt_w, 71467}, // __builtin_msa_pcnt_w
-      {Intrinsic::mips_sat_s_b, 72151}, // __builtin_msa_sat_s_b
-      {Intrinsic::mips_sat_s_d, 72173}, // __builtin_msa_sat_s_d
-      {Intrinsic::mips_sat_s_h, 72195}, // __builtin_msa_sat_s_h
-      {Intrinsic::mips_sat_s_w, 72217}, // __builtin_msa_sat_s_w
-      {Intrinsic::mips_sat_u_b, 72239}, // __builtin_msa_sat_u_b
-      {Intrinsic::mips_sat_u_d, 72261}, // __builtin_msa_sat_u_d
-      {Intrinsic::mips_sat_u_h, 72283}, // __builtin_msa_sat_u_h
-      {Intrinsic::mips_sat_u_w, 72305}, // __builtin_msa_sat_u_w
-      {Intrinsic::mips_shf_b, 72327}, // __builtin_msa_shf_b
-      {Intrinsic::mips_shf_h, 72347}, // __builtin_msa_shf_h
-      {Intrinsic::mips_shf_w, 72367}, // __builtin_msa_shf_w
-      {Intrinsic::mips_sld_b, 72669}, // __builtin_msa_sld_b
-      {Intrinsic::mips_sld_d, 72689}, // __builtin_msa_sld_d
-      {Intrinsic::mips_sld_h, 72709}, // __builtin_msa_sld_h
-      {Intrinsic::mips_sld_w, 72729}, // __builtin_msa_sld_w
-      {Intrinsic::mips_sldi_b, 72749}, // __builtin_msa_sldi_b
-      {Intrinsic::mips_sldi_d, 72770}, // __builtin_msa_sldi_d
-      {Intrinsic::mips_sldi_h, 72791}, // __builtin_msa_sldi_h
-      {Intrinsic::mips_sldi_w, 72812}, // __builtin_msa_sldi_w
-      {Intrinsic::mips_sll_b, 72833}, // __builtin_msa_sll_b
-      {Intrinsic::mips_sll_d, 72853}, // __builtin_msa_sll_d
-      {Intrinsic::mips_sll_h, 72873}, // __builtin_msa_sll_h
-      {Intrinsic::mips_sll_w, 72893}, // __builtin_msa_sll_w
-      {Intrinsic::mips_slli_b, 72913}, // __builtin_msa_slli_b
-      {Intrinsic::mips_slli_d, 72934}, // __builtin_msa_slli_d
-      {Intrinsic::mips_slli_h, 72955}, // __builtin_msa_slli_h
-      {Intrinsic::mips_slli_w, 72976}, // __builtin_msa_slli_w
-      {Intrinsic::mips_splat_b, 72997}, // __builtin_msa_splat_b
-      {Intrinsic::mips_splat_d, 73019}, // __builtin_msa_splat_d
-      {Intrinsic::mips_splat_h, 73041}, // __builtin_msa_splat_h
-      {Intrinsic::mips_splat_w, 73063}, // __builtin_msa_splat_w
-      {Intrinsic::mips_splati_b, 73085}, // __builtin_msa_splati_b
-      {Intrinsic::mips_splati_d, 73108}, // __builtin_msa_splati_d
-      {Intrinsic::mips_splati_h, 73131}, // __builtin_msa_splati_h
-      {Intrinsic::mips_splati_w, 73154}, // __builtin_msa_splati_w
-      {Intrinsic::mips_sra_b, 73177}, // __builtin_msa_sra_b
-      {Intrinsic::mips_sra_d, 73197}, // __builtin_msa_sra_d
-      {Intrinsic::mips_sra_h, 73217}, // __builtin_msa_sra_h
-      {Intrinsic::mips_sra_w, 73237}, // __builtin_msa_sra_w
-      {Intrinsic::mips_srai_b, 73257}, // __builtin_msa_srai_b
-      {Intrinsic::mips_srai_d, 73278}, // __builtin_msa_srai_d
-      {Intrinsic::mips_srai_h, 73299}, // __builtin_msa_srai_h
-      {Intrinsic::mips_srai_w, 73320}, // __builtin_msa_srai_w
-      {Intrinsic::mips_srar_b, 73341}, // __builtin_msa_srar_b
-      {Intrinsic::mips_srar_d, 73362}, // __builtin_msa_srar_d
-      {Intrinsic::mips_srar_h, 73383}, // __builtin_msa_srar_h
-      {Intrinsic::mips_srar_w, 73404}, // __builtin_msa_srar_w
-      {Intrinsic::mips_srari_b, 73425}, // __builtin_msa_srari_b
-      {Intrinsic::mips_srari_d, 73447}, // __builtin_msa_srari_d
-      {Intrinsic::mips_srari_h, 73469}, // __builtin_msa_srari_h
-      {Intrinsic::mips_srari_w, 73491}, // __builtin_msa_srari_w
-      {Intrinsic::mips_srl_b, 73513}, // __builtin_msa_srl_b
-      {Intrinsic::mips_srl_d, 73533}, // __builtin_msa_srl_d
-      {Intrinsic::mips_srl_h, 73553}, // __builtin_msa_srl_h
-      {Intrinsic::mips_srl_w, 73573}, // __builtin_msa_srl_w
-      {Intrinsic::mips_srli_b, 73593}, // __builtin_msa_srli_b
-      {Intrinsic::mips_srli_d, 73614}, // __builtin_msa_srli_d
-      {Intrinsic::mips_srli_h, 73635}, // __builtin_msa_srli_h
-      {Intrinsic::mips_srli_w, 73656}, // __builtin_msa_srli_w
-      {Intrinsic::mips_srlr_b, 73677}, // __builtin_msa_srlr_b
-      {Intrinsic::mips_srlr_d, 73698}, // __builtin_msa_srlr_d
-      {Intrinsic::mips_srlr_h, 73719}, // __builtin_msa_srlr_h
-      {Intrinsic::mips_srlr_w, 73740}, // __builtin_msa_srlr_w
-      {Intrinsic::mips_srlri_b, 73761}, // __builtin_msa_srlri_b
-      {Intrinsic::mips_srlri_d, 73783}, // __builtin_msa_srlri_d
-      {Intrinsic::mips_srlri_h, 73805}, // __builtin_msa_srlri_h
-      {Intrinsic::mips_srlri_w, 73827}, // __builtin_msa_srlri_w
-      {Intrinsic::mips_st_b, 73849}, // __builtin_msa_st_b
-      {Intrinsic::mips_st_d, 73868}, // __builtin_msa_st_d
-      {Intrinsic::mips_st_h, 73887}, // __builtin_msa_st_h
-      {Intrinsic::mips_st_w, 73906}, // __builtin_msa_st_w
-      {Intrinsic::mips_subs_s_b, 74095}, // __builtin_msa_subs_s_b
-      {Intrinsic::mips_subs_s_d, 74118}, // __builtin_msa_subs_s_d
-      {Intrinsic::mips_subs_s_h, 74141}, // __builtin_msa_subs_s_h
-      {Intrinsic::mips_subs_s_w, 74164}, // __builtin_msa_subs_s_w
-      {Intrinsic::mips_subs_u_b, 74187}, // __builtin_msa_subs_u_b
-      {Intrinsic::mips_subs_u_d, 74210}, // __builtin_msa_subs_u_d
-      {Intrinsic::mips_subs_u_h, 74233}, // __builtin_msa_subs_u_h
-      {Intrinsic::mips_subs_u_w, 74256}, // __builtin_msa_subs_u_w
-      {Intrinsic::mips_subsus_u_b, 74279}, // __builtin_msa_subsus_u_b
-      {Intrinsic::mips_subsus_u_d, 74304}, // __builtin_msa_subsus_u_d
-      {Intrinsic::mips_subsus_u_h, 74329}, // __builtin_msa_subsus_u_h
-      {Intrinsic::mips_subsus_u_w, 74354}, // __builtin_msa_subsus_u_w
-      {Intrinsic::mips_subsuu_s_b, 74379}, // __builtin_msa_subsuu_s_b
-      {Intrinsic::mips_subsuu_s_d, 74404}, // __builtin_msa_subsuu_s_d
-      {Intrinsic::mips_subsuu_s_h, 74429}, // __builtin_msa_subsuu_s_h
-      {Intrinsic::mips_subsuu_s_w, 74454}, // __builtin_msa_subsuu_s_w
-      {Intrinsic::mips_subv_b, 74625}, // __builtin_msa_subv_b
-      {Intrinsic::mips_subv_d, 74646}, // __builtin_msa_subv_d
-      {Intrinsic::mips_subv_h, 74667}, // __builtin_msa_subv_h
-      {Intrinsic::mips_subv_w, 74688}, // __builtin_msa_subv_w
-      {Intrinsic::mips_subvi_b, 74709}, // __builtin_msa_subvi_b
-      {Intrinsic::mips_subvi_d, 74731}, // __builtin_msa_subvi_d
-      {Intrinsic::mips_subvi_h, 74753}, // __builtin_msa_subvi_h
-      {Intrinsic::mips_subvi_w, 74775}, // __builtin_msa_subvi_w
-      {Intrinsic::mips_vshf_b, 74797}, // __builtin_msa_vshf_b
-      {Intrinsic::mips_vshf_d, 74818}, // __builtin_msa_vshf_d
-      {Intrinsic::mips_vshf_h, 74839}, // __builtin_msa_vshf_h
-      {Intrinsic::mips_vshf_w, 74860}, // __builtin_msa_vshf_w
-      {Intrinsic::mips_xor_v, 74902}, // __builtin_msa_xor_v
-      {Intrinsic::mips_xori_b, 74922}, // __builtin_msa_xori_b
+      {Intrinsic::mips_absq_s_ph, 55145}, // __builtin_mips_absq_s_ph
+      {Intrinsic::mips_absq_s_qb, 55170}, // __builtin_mips_absq_s_qb
+      {Intrinsic::mips_absq_s_w, 55195}, // __builtin_mips_absq_s_w
+      {Intrinsic::mips_addq_ph, 55307}, // __builtin_mips_addq_ph
+      {Intrinsic::mips_addq_s_ph, 55330}, // __builtin_mips_addq_s_ph
+      {Intrinsic::mips_addq_s_w, 55355}, // __builtin_mips_addq_s_w
+      {Intrinsic::mips_addqh_ph, 55379}, // __builtin_mips_addqh_ph
+      {Intrinsic::mips_addqh_r_ph, 55403}, // __builtin_mips_addqh_r_ph
+      {Intrinsic::mips_addqh_r_w, 55429}, // __builtin_mips_addqh_r_w
+      {Intrinsic::mips_addqh_w, 55454}, // __builtin_mips_addqh_w
+      {Intrinsic::mips_addsc, 55753}, // __builtin_mips_addsc
+      {Intrinsic::mips_addu_ph, 55774}, // __builtin_mips_addu_ph
+      {Intrinsic::mips_addu_qb, 55797}, // __builtin_mips_addu_qb
+      {Intrinsic::mips_addu_s_ph, 55820}, // __builtin_mips_addu_s_ph
+      {Intrinsic::mips_addu_s_qb, 55845}, // __builtin_mips_addu_s_qb
+      {Intrinsic::mips_adduh_qb, 55870}, // __builtin_mips_adduh_qb
+      {Intrinsic::mips_adduh_r_qb, 55894}, // __builtin_mips_adduh_r_qb
+      {Intrinsic::mips_addwc, 56092}, // __builtin_mips_addwc
+      {Intrinsic::mips_append, 56154}, // __builtin_mips_append
+      {Intrinsic::mips_balign, 56720}, // __builtin_mips_balign
+      {Intrinsic::mips_bitrev, 57274}, // __builtin_mips_bitrev
+      {Intrinsic::mips_bposge32, 57652}, // __builtin_mips_bposge32
+      {Intrinsic::mips_cmp_eq_ph, 58891}, // __builtin_mips_cmp_eq_ph
+      {Intrinsic::mips_cmp_le_ph, 58916}, // __builtin_mips_cmp_le_ph
+      {Intrinsic::mips_cmp_lt_ph, 58941}, // __builtin_mips_cmp_lt_ph
+      {Intrinsic::mips_cmpgdu_eq_qb, 58966}, // __builtin_mips_cmpgdu_eq_qb
+      {Intrinsic::mips_cmpgdu_le_qb, 58994}, // __builtin_mips_cmpgdu_le_qb
+      {Intrinsic::mips_cmpgdu_lt_qb, 59022}, // __builtin_mips_cmpgdu_lt_qb
+      {Intrinsic::mips_cmpgu_eq_qb, 59050}, // __builtin_mips_cmpgu_eq_qb
+      {Intrinsic::mips_cmpgu_le_qb, 59077}, // __builtin_mips_cmpgu_le_qb
+      {Intrinsic::mips_cmpgu_lt_qb, 59104}, // __builtin_mips_cmpgu_lt_qb
+      {Intrinsic::mips_cmpu_eq_qb, 59131}, // __builtin_mips_cmpu_eq_qb
+      {Intrinsic::mips_cmpu_le_qb, 59157}, // __builtin_mips_cmpu_le_qb
+      {Intrinsic::mips_cmpu_lt_qb, 59183}, // __builtin_mips_cmpu_lt_qb
+      {Intrinsic::mips_dlsa, 59590}, // __builtin_mips_dlsa
+      {Intrinsic::mips_dpa_w_ph, 59748}, // __builtin_mips_dpa_w_ph
+      {Intrinsic::mips_dpaq_s_w_ph, 59916}, // __builtin_mips_dpaq_s_w_ph
+      {Intrinsic::mips_dpaq_sa_l_w, 59943}, // __builtin_mips_dpaq_sa_l_w
+      {Intrinsic::mips_dpaqx_s_w_ph, 59970}, // __builtin_mips_dpaqx_s_w_ph
+      {Intrinsic::mips_dpaqx_sa_w_ph, 59998}, // __builtin_mips_dpaqx_sa_w_ph
+      {Intrinsic::mips_dpau_h_qbl, 60027}, // __builtin_mips_dpau_h_qbl
+      {Intrinsic::mips_dpau_h_qbr, 60053}, // __builtin_mips_dpau_h_qbr
+      {Intrinsic::mips_dpax_w_ph, 60079}, // __builtin_mips_dpax_w_ph
+      {Intrinsic::mips_dps_w_ph, 60104}, // __builtin_mips_dps_w_ph
+      {Intrinsic::mips_dpsq_s_w_ph, 60128}, // __builtin_mips_dpsq_s_w_ph
+      {Intrinsic::mips_dpsq_sa_l_w, 60155}, // __builtin_mips_dpsq_sa_l_w
+      {Intrinsic::mips_dpsqx_s_w_ph, 60182}, // __builtin_mips_dpsqx_s_w_ph
+      {Intrinsic::mips_dpsqx_sa_w_ph, 60210}, // __builtin_mips_dpsqx_sa_w_ph
+      {Intrinsic::mips_dpsu_h_qbl, 60239}, // __builtin_mips_dpsu_h_qbl
+      {Intrinsic::mips_dpsu_h_qbr, 60265}, // __builtin_mips_dpsu_h_qbr
+      {Intrinsic::mips_dpsx_w_ph, 60435}, // __builtin_mips_dpsx_w_ph
+      {Intrinsic::mips_extp, 60460}, // __builtin_mips_extp
+      {Intrinsic::mips_extpdp, 60480}, // __builtin_mips_extpdp
+      {Intrinsic::mips_extr_r_w, 60502}, // __builtin_mips_extr_r_w
+      {Intrinsic::mips_extr_rs_w, 60526}, // __builtin_mips_extr_rs_w
+      {Intrinsic::mips_extr_s_h, 60551}, // __builtin_mips_extr_s_h
+      {Intrinsic::mips_extr_w, 60575}, // __builtin_mips_extr_w
+      {Intrinsic::mips_insv, 63627}, // __builtin_mips_insv
+      {Intrinsic::mips_lbux, 63735}, // __builtin_mips_lbux
+      {Intrinsic::mips_lhx, 63951}, // __builtin_mips_lhx
+      {Intrinsic::mips_lsa, 63970}, // __builtin_mips_lsa
+      {Intrinsic::mips_lwx, 63989}, // __builtin_mips_lwx
+      {Intrinsic::mips_madd, 64008}, // __builtin_mips_madd
+      {Intrinsic::mips_maddu, 64122}, // __builtin_mips_maddu
+      {Intrinsic::mips_maq_s_w_phl, 64231}, // __builtin_mips_maq_s_w_phl
+      {Intrinsic::mips_maq_s_w_phr, 64258}, // __builtin_mips_maq_s_w_phr
+      {Intrinsic::mips_maq_sa_w_phl, 64285}, // __builtin_mips_maq_sa_w_phl
+      {Intrinsic::mips_maq_sa_w_phr, 64313}, // __builtin_mips_maq_sa_w_phr
+      {Intrinsic::mips_modsub, 65413}, // __builtin_mips_modsub
+      {Intrinsic::mips_msub, 65456}, // __builtin_mips_msub
+      {Intrinsic::mips_msubu, 65570}, // __builtin_mips_msubu
+      {Intrinsic::mips_mthlip, 65679}, // __builtin_mips_mthlip
+      {Intrinsic::mips_mul_ph, 65701}, // __builtin_mips_mul_ph
+      {Intrinsic::mips_mul_s_ph, 65767}, // __builtin_mips_mul_s_ph
+      {Intrinsic::mips_muleq_s_w_phl, 65791}, // __builtin_mips_muleq_s_w_phl
+      {Intrinsic::mips_muleq_s_w_phr, 65820}, // __builtin_mips_muleq_s_w_phr
+      {Intrinsic::mips_muleu_s_ph_qbl, 65849}, // __builtin_mips_muleu_s_ph_qbl
+      {Intrinsic::mips_muleu_s_ph_qbr, 65879}, // __builtin_mips_muleu_s_ph_qbr
+      {Intrinsic::mips_mulq_rs_ph, 65909}, // __builtin_mips_mulq_rs_ph
+      {Intrinsic::mips_mulq_rs_w, 65935}, // __builtin_mips_mulq_rs_w
+      {Intrinsic::mips_mulq_s_ph, 65960}, // __builtin_mips_mulq_s_ph
+      {Intrinsic::mips_mulq_s_w, 65985}, // __builtin_mips_mulq_s_w
+      {Intrinsic::mips_mulsa_w_ph, 66055}, // __builtin_mips_mulsa_w_ph
+      {Intrinsic::mips_mulsaq_s_w_ph, 66081}, // __builtin_mips_mulsaq_s_w_ph
+      {Intrinsic::mips_mult, 66110}, // __builtin_mips_mult
+      {Intrinsic::mips_multu, 66130}, // __builtin_mips_multu
+      {Intrinsic::mips_packrl_ph, 66483}, // __builtin_mips_packrl_ph
+      {Intrinsic::mips_pick_ph, 66768}, // __builtin_mips_pick_ph
+      {Intrinsic::mips_pick_qb, 66791}, // __builtin_mips_pick_qb
+      {Intrinsic::mips_preceq_w_phl, 66814}, // __builtin_mips_preceq_w_phl
+      {Intrinsic::mips_preceq_w_phr, 66842}, // __builtin_mips_preceq_w_phr
+      {Intrinsic::mips_precequ_ph_qbl, 66870}, // __builtin_mips_precequ_ph_qbl
+      {Intrinsic::mips_precequ_ph_qbla, 66900}, // __builtin_mips_precequ_ph_qbla
+      {Intrinsic::mips_precequ_ph_qbr, 66931}, // __builtin_mips_precequ_ph_qbr
+      {Intrinsic::mips_precequ_ph_qbra, 66961}, // __builtin_mips_precequ_ph_qbra
+      {Intrinsic::mips_preceu_ph_qbl, 66992}, // __builtin_mips_preceu_ph_qbl
+      {Intrinsic::mips_preceu_ph_qbla, 67021}, // __builtin_mips_preceu_ph_qbla
+      {Intrinsic::mips_preceu_ph_qbr, 67051}, // __builtin_mips_preceu_ph_qbr
+      {Intrinsic::mips_preceu_ph_qbra, 67080}, // __builtin_mips_preceu_ph_qbra
+      {Intrinsic::mips_precr_qb_ph, 67110}, // __builtin_mips_precr_qb_ph
+      {Intrinsic::mips_precr_sra_ph_w, 67137}, // __builtin_mips_precr_sra_ph_w
+      {Intrinsic::mips_precr_sra_r_ph_w, 67167}, // __builtin_mips_precr_sra_r_ph_w
+      {Intrinsic::mips_precrq_ph_w, 67199}, // __builtin_mips_precrq_ph_w
+      {Intrinsic::mips_precrq_qb_ph, 67226}, // __builtin_mips_precrq_qb_ph
+      {Intrinsic::mips_precrq_rs_ph_w, 67254}, // __builtin_mips_precrq_rs_ph_w
+      {Intrinsic::mips_precrqu_s_qb_ph, 67284}, // __builtin_mips_precrqu_s_qb_ph
+      {Intrinsic::mips_prepend, 67315}, // __builtin_mips_prepend
+      {Intrinsic::mips_raddu_w_qb, 67338}, // __builtin_mips_raddu_w_qb
+      {Intrinsic::mips_rddsp, 67364}, // __builtin_mips_rddsp
+      {Intrinsic::mips_repl_ph, 67385}, // __builtin_mips_repl_ph
+      {Intrinsic::mips_repl_qb, 67408}, // __builtin_mips_repl_qb
+      {Intrinsic::mips_shilo, 67667}, // __builtin_mips_shilo
+      {Intrinsic::mips_shll_ph, 67688}, // __builtin_mips_shll_ph
+      {Intrinsic::mips_shll_qb, 67711}, // __builtin_mips_shll_qb
+      {Intrinsic::mips_shll_s_ph, 67734}, // __builtin_mips_shll_s_ph
+      {Intrinsic::mips_shll_s_w, 67759}, // __builtin_mips_shll_s_w
+      {Intrinsic::mips_shra_ph, 67783}, // __builtin_mips_shra_ph
+      {Intrinsic::mips_shra_qb, 67806}, // __builtin_mips_shra_qb
+      {Intrinsic::mips_shra_r_ph, 67829}, // __builtin_mips_shra_r_ph
+      {Intrinsic::mips_shra_r_qb, 67854}, // __builtin_mips_shra_r_qb
+      {Intrinsic::mips_shra_r_w, 67879}, // __builtin_mips_shra_r_w
+      {Intrinsic::mips_shrl_ph, 67903}, // __builtin_mips_shrl_ph
+      {Intrinsic::mips_shrl_qb, 67926}, // __builtin_mips_shrl_qb
+      {Intrinsic::mips_subq_ph, 69245}, // __builtin_mips_subq_ph
+      {Intrinsic::mips_subq_s_ph, 69268}, // __builtin_mips_subq_s_ph
+      {Intrinsic::mips_subq_s_w, 69293}, // __builtin_mips_subq_s_w
+      {Intrinsic::mips_subqh_ph, 69317}, // __builtin_mips_subqh_ph
+      {Intrinsic::mips_subqh_r_ph, 69341}, // __builtin_mips_subqh_r_ph
+      {Intrinsic::mips_subqh_r_w, 69367}, // __builtin_mips_subqh_r_w
+      {Intrinsic::mips_subqh_w, 69392}, // __builtin_mips_subqh_w
+      {Intrinsic::mips_subu_ph, 69799}, // __builtin_mips_subu_ph
+      {Intrinsic::mips_subu_qb, 69822}, // __builtin_mips_subu_qb
+      {Intrinsic::mips_subu_s_ph, 69845}, // __builtin_mips_subu_s_ph
+      {Intrinsic::mips_subu_s_qb, 69870}, // __builtin_mips_subu_s_qb
+      {Intrinsic::mips_subuh_qb, 69895}, // __builtin_mips_subuh_qb
+      {Intrinsic::mips_subuh_r_qb, 69919}, // __builtin_mips_subuh_r_qb
+      {Intrinsic::mips_wrdsp, 70201}, // __builtin_mips_wrdsp
+      {Intrinsic::mips_add_a_b, 55219}, // __builtin_msa_add_a_b
+      {Intrinsic::mips_add_a_d, 55241}, // __builtin_msa_add_a_d
+      {Intrinsic::mips_add_a_h, 55263}, // __builtin_msa_add_a_h
+      {Intrinsic::mips_add_a_w, 55285}, // __builtin_msa_add_a_w
+      {Intrinsic::mips_adds_a_b, 55477}, // __builtin_msa_adds_a_b
+      {Intrinsic::mips_adds_a_d, 55500}, // __builtin_msa_adds_a_d
+      {Intrinsic::mips_adds_a_h, 55523}, // __builtin_msa_adds_a_h
+      {Intrinsic::mips_adds_a_w, 55546}, // __builtin_msa_adds_a_w
+      {Intrinsic::mips_adds_s_b, 55569}, // __builtin_msa_adds_s_b
+      {Intrinsic::mips_adds_s_d, 55592}, // __builtin_msa_adds_s_d
+      {Intrinsic::mips_adds_s_h, 55615}, // __builtin_msa_adds_s_h
+      {Intrinsic::mips_adds_s_w, 55638}, // __builtin_msa_adds_s_w
+      {Intrinsic::mips_adds_u_b, 55661}, // __builtin_msa_adds_u_b
+      {Intrinsic::mips_adds_u_d, 55684}, // __builtin_msa_adds_u_d
+      {Intrinsic::mips_adds_u_h, 55707}, // __builtin_msa_adds_u_h
+      {Intrinsic::mips_adds_u_w, 55730}, // __builtin_msa_adds_u_w
+      {Intrinsic::mips_addv_b, 55920}, // __builtin_msa_addv_b
+      {Intrinsic::mips_addv_d, 55941}, // __builtin_msa_addv_d
+      {Intrinsic::mips_addv_h, 55962}, // __builtin_msa_addv_h
+      {Intrinsic::mips_addv_w, 55983}, // __builtin_msa_addv_w
+      {Intrinsic::mips_addvi_b, 56004}, // __builtin_msa_addvi_b
+      {Intrinsic::mips_addvi_d, 56026}, // __builtin_msa_addvi_d
+      {Intrinsic::mips_addvi_h, 56048}, // __builtin_msa_addvi_h
+      {Intrinsic::mips_addvi_w, 56070}, // __builtin_msa_addvi_w
+      {Intrinsic::mips_and_v, 56113}, // __builtin_msa_and_v
+      {Intrinsic::mips_andi_b, 56133}, // __builtin_msa_andi_b
+      {Intrinsic::mips_asub_s_b, 56176}, // __builtin_msa_asub_s_b
+      {Intrinsic::mips_asub_s_d, 56199}, // __builtin_msa_asub_s_d
+      {Intrinsic::mips_asub_s_h, 56222}, // __builtin_msa_asub_s_h
+      {Intrinsic::mips_asub_s_w, 56245}, // __builtin_msa_asub_s_w
+      {Intrinsic::mips_asub_u_b, 56268}, // __builtin_msa_asub_u_b
+      {Intrinsic::mips_asub_u_d, 56291}, // __builtin_msa_asub_u_d
+      {Intrinsic::mips_asub_u_h, 56314}, // __builtin_msa_asub_u_h
+      {Intrinsic::mips_asub_u_w, 56337}, // __builtin_msa_asub_u_w
+      {Intrinsic::mips_ave_s_b, 56360}, // __builtin_msa_ave_s_b
+      {Intrinsic::mips_ave_s_d, 56382}, // __builtin_msa_ave_s_d
+      {Intrinsic::mips_ave_s_h, 56404}, // __builtin_msa_ave_s_h
+      {Intrinsic::mips_ave_s_w, 56426}, // __builtin_msa_ave_s_w
+      {Intrinsic::mips_ave_u_b, 56448}, // __builtin_msa_ave_u_b
+      {Intrinsic::mips_ave_u_d, 56470}, // __builtin_msa_ave_u_d
+      {Intrinsic::mips_ave_u_h, 56492}, // __builtin_msa_ave_u_h
+      {Intrinsic::mips_ave_u_w, 56514}, // __builtin_msa_ave_u_w
+      {Intrinsic::mips_aver_s_b, 56536}, // __builtin_msa_aver_s_b
+      {Intrinsic::mips_aver_s_d, 56559}, // __builtin_msa_aver_s_d
+      {Intrinsic::mips_aver_s_h, 56582}, // __builtin_msa_aver_s_h
+      {Intrinsic::mips_aver_s_w, 56605}, // __builtin_msa_aver_s_w
+      {Intrinsic::mips_aver_u_b, 56628}, // __builtin_msa_aver_u_b
+      {Intrinsic::mips_aver_u_d, 56651}, // __builtin_msa_aver_u_d
+      {Intrinsic::mips_aver_u_h, 56674}, // __builtin_msa_aver_u_h
+      {Intrinsic::mips_aver_u_w, 56697}, // __builtin_msa_aver_u_w
+      {Intrinsic::mips_bclr_b, 56742}, // __builtin_msa_bclr_b
+      {Intrinsic::mips_bclr_d, 56763}, // __builtin_msa_bclr_d
+      {Intrinsic::mips_bclr_h, 56784}, // __builtin_msa_bclr_h
+      {Intrinsic::mips_bclr_w, 56805}, // __builtin_msa_bclr_w
+      {Intrinsic::mips_bclri_b, 56826}, // __builtin_msa_bclri_b
+      {Intrinsic::mips_bclri_d, 56848}, // __builtin_msa_bclri_d
+      {Intrinsic::mips_bclri_h, 56870}, // __builtin_msa_bclri_h
+      {Intrinsic::mips_bclri_w, 56892}, // __builtin_msa_bclri_w
+      {Intrinsic::mips_binsl_b, 56914}, // __builtin_msa_binsl_b
+      {Intrinsic::mips_binsl_d, 56936}, // __builtin_msa_binsl_d
+      {Intrinsic::mips_binsl_h, 56958}, // __builtin_msa_binsl_h
+      {Intrinsic::mips_binsl_w, 56980}, // __builtin_msa_binsl_w
+      {Intrinsic::mips_binsli_b, 57002}, // __builtin_msa_binsli_b
+      {Intrinsic::mips_binsli_d, 57025}, // __builtin_msa_binsli_d
+      {Intrinsic::mips_binsli_h, 57048}, // __builtin_msa_binsli_h
+      {Intrinsic::mips_binsli_w, 57071}, // __builtin_msa_binsli_w
+      {Intrinsic::mips_binsr_b, 57094}, // __builtin_msa_binsr_b
+      {Intrinsic::mips_binsr_d, 57116}, // __builtin_msa_binsr_d
+      {Intrinsic::mips_binsr_h, 57138}, // __builtin_msa_binsr_h
+      {Intrinsic::mips_binsr_w, 57160}, // __builtin_msa_binsr_w
+      {Intrinsic::mips_binsri_b, 57182}, // __builtin_msa_binsri_b
+      {Intrinsic::mips_binsri_d, 57205}, // __builtin_msa_binsri_d
+      {Intrinsic::mips_binsri_h, 57228}, // __builtin_msa_binsri_h
+      {Intrinsic::mips_binsri_w, 57251}, // __builtin_msa_binsri_w
+      {Intrinsic::mips_bmnz_v, 57296}, // __builtin_msa_bmnz_v
+      {Intrinsic::mips_bmnzi_b, 57317}, // __builtin_msa_bmnzi_b
+      {Intrinsic::mips_bmz_v, 57339}, // __builtin_msa_bmz_v
+      {Intrinsic::mips_bmzi_b, 57359}, // __builtin_msa_bmzi_b
+      {Intrinsic::mips_bneg_b, 57380}, // __builtin_msa_bneg_b
+      {Intrinsic::mips_bneg_d, 57401}, // __builtin_msa_bneg_d
+      {Intrinsic::mips_bneg_h, 57422}, // __builtin_msa_bneg_h
+      {Intrinsic::mips_bneg_w, 57443}, // __builtin_msa_bneg_w
+      {Intrinsic::mips_bnegi_b, 57464}, // __builtin_msa_bnegi_b
+      {Intrinsic::mips_bnegi_d, 57486}, // __builtin_msa_bnegi_d
+      {Intrinsic::mips_bnegi_h, 57508}, // __builtin_msa_bnegi_h
+      {Intrinsic::mips_bnegi_w, 57530}, // __builtin_msa_bnegi_w
+      {Intrinsic::mips_bnz_b, 57552}, // __builtin_msa_bnz_b
+      {Intrinsic::mips_bnz_d, 57572}, // __builtin_msa_bnz_d
+      {Intrinsic::mips_bnz_h, 57592}, // __builtin_msa_bnz_h
+      {Intrinsic::mips_bnz_v, 57612}, // __builtin_msa_bnz_v
+      {Intrinsic::mips_bnz_w, 57632}, // __builtin_msa_bnz_w
+      {Intrinsic::mips_bsel_v, 57676}, // __builtin_msa_bsel_v
+      {Intrinsic::mips_bseli_b, 57697}, // __builtin_msa_bseli_b
+      {Intrinsic::mips_bset_b, 57719}, // __builtin_msa_bset_b
+      {Intrinsic::mips_bset_d, 57740}, // __builtin_msa_bset_d
+      {Intrinsic::mips_bset_h, 57761}, // __builtin_msa_bset_h
+      {Intrinsic::mips_bset_w, 57782}, // __builtin_msa_bset_w
+      {Intrinsic::mips_bseti_b, 57803}, // __builtin_msa_bseti_b
+      {Intrinsic::mips_bseti_d, 57825}, // __builtin_msa_bseti_d
+      {Intrinsic::mips_bseti_h, 57847}, // __builtin_msa_bseti_h
+      {Intrinsic::mips_bseti_w, 57869}, // __builtin_msa_bseti_w
+      {Intrinsic::mips_bz_b, 57891}, // __builtin_msa_bz_b
+      {Intrinsic::mips_bz_d, 57910}, // __builtin_msa_bz_d
+      {Intrinsic::mips_bz_h, 57929}, // __builtin_msa_bz_h
+      {Intrinsic::mips_bz_v, 57948}, // __builtin_msa_bz_v
+      {Intrinsic::mips_bz_w, 57967}, // __builtin_msa_bz_w
+      {Intrinsic::mips_ceq_b, 57986}, // __builtin_msa_ceq_b
+      {Intrinsic::mips_ceq_d, 58006}, // __builtin_msa_ceq_d
+      {Intrinsic::mips_ceq_h, 58026}, // __builtin_msa_ceq_h
+      {Intrinsic::mips_ceq_w, 58046}, // __builtin_msa_ceq_w
+      {Intrinsic::mips_ceqi_b, 58066}, // __builtin_msa_ceqi_b
+      {Intrinsic::mips_ceqi_d, 58087}, // __builtin_msa_ceqi_d
+      {Intrinsic::mips_ceqi_h, 58108}, // __builtin_msa_ceqi_h
+      {Intrinsic::mips_ceqi_w, 58129}, // __builtin_msa_ceqi_w
+      {Intrinsic::mips_cfcmsa, 58150}, // __builtin_msa_cfcmsa
+      {Intrinsic::mips_cle_s_b, 58171}, // __builtin_msa_cle_s_b
+      {Intrinsic::mips_cle_s_d, 58193}, // __builtin_msa_cle_s_d
+      {Intrinsic::mips_cle_s_h, 58215}, // __builtin_msa_cle_s_h
+      {Intrinsic::mips_cle_s_w, 58237}, // __builtin_msa_cle_s_w
+      {Intrinsic::mips_cle_u_b, 58259}, // __builtin_msa_cle_u_b
+      {Intrinsic::mips_cle_u_d, 58281}, // __builtin_msa_cle_u_d
+      {Intrinsic::mips_cle_u_h, 58303}, // __builtin_msa_cle_u_h
+      {Intrinsic::mips_cle_u_w, 58325}, // __builtin_msa_cle_u_w
+      {Intrinsic::mips_clei_s_b, 58347}, // __builtin_msa_clei_s_b
+      {Intrinsic::mips_clei_s_d, 58370}, // __builtin_msa_clei_s_d
+      {Intrinsic::mips_clei_s_h, 58393}, // __builtin_msa_clei_s_h
+      {Intrinsic::mips_clei_s_w, 58416}, // __builtin_msa_clei_s_w
+      {Intrinsic::mips_clei_u_b, 58439}, // __builtin_msa_clei_u_b
+      {Intrinsic::mips_clei_u_d, 58462}, // __builtin_msa_clei_u_d
+      {Intrinsic::mips_clei_u_h, 58485}, // __builtin_msa_clei_u_h
+      {Intrinsic::mips_clei_u_w, 58508}, // __builtin_msa_clei_u_w
+      {Intrinsic::mips_clt_s_b, 58531}, // __builtin_msa_clt_s_b
+      {Intrinsic::mips_clt_s_d, 58553}, // __builtin_msa_clt_s_d
+      {Intrinsic::mips_clt_s_h, 58575}, // __builtin_msa_clt_s_h
+      {Intrinsic::mips_clt_s_w, 58597}, // __builtin_msa_clt_s_w
+      {Intrinsic::mips_clt_u_b, 58619}, // __builtin_msa_clt_u_b
+      {Intrinsic::mips_clt_u_d, 58641}, // __builtin_msa_clt_u_d
+      {Intrinsic::mips_clt_u_h, 58663}, // __builtin_msa_clt_u_h
+      {Intrinsic::mips_clt_u_w, 58685}, // __builtin_msa_clt_u_w
+      {Intrinsic::mips_clti_s_b, 58707}, // __builtin_msa_clti_s_b
+      {Intrinsic::mips_clti_s_d, 58730}, // __builtin_msa_clti_s_d
+      {Intrinsic::mips_clti_s_h, 58753}, // __builtin_msa_clti_s_h
+      {Intrinsic::mips_clti_s_w, 58776}, // __builtin_msa_clti_s_w
+      {Intrinsic::mips_clti_u_b, 58799}, // __builtin_msa_clti_u_b
+      {Intrinsic::mips_clti_u_d, 58822}, // __builtin_msa_clti_u_d
+      {Intrinsic::mips_clti_u_h, 58845}, // __builtin_msa_clti_u_h
+      {Intrinsic::mips_clti_u_w, 58868}, // __builtin_msa_clti_u_w
+      {Intrinsic::mips_copy_s_b, 59209}, // __builtin_msa_copy_s_b
+      {Intrinsic::mips_copy_s_d, 59232}, // __builtin_msa_copy_s_d
+      {Intrinsic::mips_copy_s_h, 59255}, // __builtin_msa_copy_s_h
+      {Intrinsic::mips_copy_s_w, 59278}, // __builtin_msa_copy_s_w
+      {Intrinsic::mips_copy_u_b, 59301}, // __builtin_msa_copy_u_b
+      {Intrinsic::mips_copy_u_d, 59324}, // __builtin_msa_copy_u_d
+      {Intrinsic::mips_copy_u_h, 59347}, // __builtin_msa_copy_u_h
+      {Intrinsic::mips_copy_u_w, 59370}, // __builtin_msa_copy_u_w
+      {Intrinsic::mips_ctcmsa, 59393}, // __builtin_msa_ctcmsa
+      {Intrinsic::mips_div_s_b, 59414}, // __builtin_msa_div_s_b
+      {Intrinsic::mips_div_s_d, 59436}, // __builtin_msa_div_s_d
+      {Intrinsic::mips_div_s_h, 59458}, // __builtin_msa_div_s_h
+      {Intrinsic::mips_div_s_w, 59480}, // __builtin_msa_div_s_w
+      {Intrinsic::mips_div_u_b, 59502}, // __builtin_msa_div_u_b
+      {Intrinsic::mips_div_u_d, 59524}, // __builtin_msa_div_u_d
+      {Intrinsic::mips_div_u_h, 59546}, // __builtin_msa_div_u_h
+      {Intrinsic::mips_div_u_w, 59568}, // __builtin_msa_div_u_w
+      {Intrinsic::mips_dotp_s_d, 59610}, // __builtin_msa_dotp_s_d
+      {Intrinsic::mips_dotp_s_h, 59633}, // __builtin_msa_dotp_s_h
+      {Intrinsic::mips_dotp_s_w, 59656}, // __builtin_msa_dotp_s_w
+      {Intrinsic::mips_dotp_u_d, 59679}, // __builtin_msa_dotp_u_d
+      {Intrinsic::mips_dotp_u_h, 59702}, // __builtin_msa_dotp_u_h
+      {Intrinsic::mips_dotp_u_w, 59725}, // __builtin_msa_dotp_u_w
+      {Intrinsic::mips_dpadd_s_d, 59772}, // __builtin_msa_dpadd_s_d
+      {Intrinsic::mips_dpadd_s_h, 59796}, // __builtin_msa_dpadd_s_h
+      {Intrinsic::mips_dpadd_s_w, 59820}, // __builtin_msa_dpadd_s_w
+      {Intrinsic::mips_dpadd_u_d, 59844}, // __builtin_msa_dpadd_u_d
+      {Intrinsic::mips_dpadd_u_h, 59868}, // __builtin_msa_dpadd_u_h
+      {Intrinsic::mips_dpadd_u_w, 59892}, // __builtin_msa_dpadd_u_w
+      {Intrinsic::mips_dpsub_s_d, 60291}, // __builtin_msa_dpsub_s_d
+      {Intrinsic::mips_dpsub_s_h, 60315}, // __builtin_msa_dpsub_s_h
+      {Intrinsic::mips_dpsub_s_w, 60339}, // __builtin_msa_dpsub_s_w
+      {Intrinsic::mips_dpsub_u_d, 60363}, // __builtin_msa_dpsub_u_d
+      {Intrinsic::mips_dpsub_u_h, 60387}, // __builtin_msa_dpsub_u_h
+      {Intrinsic::mips_dpsub_u_w, 60411}, // __builtin_msa_dpsub_u_w
+      {Intrinsic::mips_fadd_d, 60597}, // __builtin_msa_fadd_d
+      {Intrinsic::mips_fadd_w, 60618}, // __builtin_msa_fadd_w
+      {Intrinsic::mips_fcaf_d, 60639}, // __builtin_msa_fcaf_d
+      {Intrinsic::mips_fcaf_w, 60660}, // __builtin_msa_fcaf_w
+      {Intrinsic::mips_fceq_d, 60681}, // __builtin_msa_fceq_d
+      {Intrinsic::mips_fceq_w, 60702}, // __builtin_msa_fceq_w
+      {Intrinsic::mips_fclass_d, 60723}, // __builtin_msa_fclass_d
+      {Intrinsic::mips_fclass_w, 60746}, // __builtin_msa_fclass_w
+      {Intrinsic::mips_fcle_d, 60769}, // __builtin_msa_fcle_d
+      {Intrinsic::mips_fcle_w, 60790}, // __builtin_msa_fcle_w
+      {Intrinsic::mips_fclt_d, 60811}, // __builtin_msa_fclt_d
+      {Intrinsic::mips_fclt_w, 60832}, // __builtin_msa_fclt_w
+      {Intrinsic::mips_fcne_d, 60853}, // __builtin_msa_fcne_d
+      {Intrinsic::mips_fcne_w, 60874}, // __builtin_msa_fcne_w
+      {Intrinsic::mips_fcor_d, 60895}, // __builtin_msa_fcor_d
+      {Intrinsic::mips_fcor_w, 60916}, // __builtin_msa_fcor_w
+      {Intrinsic::mips_fcueq_d, 60937}, // __builtin_msa_fcueq_d
+      {Intrinsic::mips_fcueq_w, 60959}, // __builtin_msa_fcueq_w
+      {Intrinsic::mips_fcule_d, 60981}, // __builtin_msa_fcule_d
+      {Intrinsic::mips_fcule_w, 61003}, // __builtin_msa_fcule_w
+      {Intrinsic::mips_fcult_d, 61025}, // __builtin_msa_fcult_d
+      {Intrinsic::mips_fcult_w, 61047}, // __builtin_msa_fcult_w
+      {Intrinsic::mips_fcun_d, 61069}, // __builtin_msa_fcun_d
+      {Intrinsic::mips_fcun_w, 61090}, // __builtin_msa_fcun_w
+      {Intrinsic::mips_fcune_d, 61111}, // __builtin_msa_fcune_d
+      {Intrinsic::mips_fcune_w, 61133}, // __builtin_msa_fcune_w
+      {Intrinsic::mips_fdiv_d, 61155}, // __builtin_msa_fdiv_d
+      {Intrinsic::mips_fdiv_w, 61176}, // __builtin_msa_fdiv_w
+      {Intrinsic::mips_fexdo_h, 61197}, // __builtin_msa_fexdo_h
+      {Intrinsic::mips_fexdo_w, 61219}, // __builtin_msa_fexdo_w
+      {Intrinsic::mips_fexp2_d, 61241}, // __builtin_msa_fexp2_d
+      {Intrinsic::mips_fexp2_w, 61263}, // __builtin_msa_fexp2_w
+      {Intrinsic::mips_fexupl_d, 61285}, // __builtin_msa_fexupl_d
+      {Intrinsic::mips_fexupl_w, 61308}, // __builtin_msa_fexupl_w
+      {Intrinsic::mips_fexupr_d, 61331}, // __builtin_msa_fexupr_d
+      {Intrinsic::mips_fexupr_w, 61354}, // __builtin_msa_fexupr_w
+      {Intrinsic::mips_ffint_s_d, 61377}, // __builtin_msa_ffint_s_d
+      {Intrinsic::mips_ffint_s_w, 61401}, // __builtin_msa_ffint_s_w
+      {Intrinsic::mips_ffint_u_d, 61425}, // __builtin_msa_ffint_u_d
+      {Intrinsic::mips_ffint_u_w, 61449}, // __builtin_msa_ffint_u_w
+      {Intrinsic::mips_ffql_d, 61473}, // __builtin_msa_ffql_d
+      {Intrinsic::mips_ffql_w, 61494}, // __builtin_msa_ffql_w
+      {Intrinsic::mips_ffqr_d, 61515}, // __builtin_msa_ffqr_d
+      {Intrinsic::mips_ffqr_w, 61536}, // __builtin_msa_ffqr_w
+      {Intrinsic::mips_fill_b, 61557}, // __builtin_msa_fill_b
+      {Intrinsic::mips_fill_d, 61578}, // __builtin_msa_fill_d
+      {Intrinsic::mips_fill_h, 61599}, // __builtin_msa_fill_h
+      {Intrinsic::mips_fill_w, 61620}, // __builtin_msa_fill_w
+      {Intrinsic::mips_flog2_d, 61641}, // __builtin_msa_flog2_d
+      {Intrinsic::mips_flog2_w, 61663}, // __builtin_msa_flog2_w
+      {Intrinsic::mips_fmadd_d, 61685}, // __builtin_msa_fmadd_d
+      {Intrinsic::mips_fmadd_w, 61707}, // __builtin_msa_fmadd_w
+      {Intrinsic::mips_fmax_a_d, 61729}, // __builtin_msa_fmax_a_d
+      {Intrinsic::mips_fmax_a_w, 61752}, // __builtin_msa_fmax_a_w
+      {Intrinsic::mips_fmax_d, 61775}, // __builtin_msa_fmax_d
+      {Intrinsic::mips_fmax_w, 61796}, // __builtin_msa_fmax_w
+      {Intrinsic::mips_fmin_a_d, 61817}, // __builtin_msa_fmin_a_d
+      {Intrinsic::mips_fmin_a_w, 61840}, // __builtin_msa_fmin_a_w
+      {Intrinsic::mips_fmin_d, 61863}, // __builtin_msa_fmin_d
+      {Intrinsic::mips_fmin_w, 61884}, // __builtin_msa_fmin_w
+      {Intrinsic::mips_fmsub_d, 61905}, // __builtin_msa_fmsub_d
+      {Intrinsic::mips_fmsub_w, 61927}, // __builtin_msa_fmsub_w
+      {Intrinsic::mips_fmul_d, 61949}, // __builtin_msa_fmul_d
+      {Intrinsic::mips_fmul_w, 61970}, // __builtin_msa_fmul_w
+      {Intrinsic::mips_frcp_d, 61991}, // __builtin_msa_frcp_d
+      {Intrinsic::mips_frcp_w, 62012}, // __builtin_msa_frcp_w
+      {Intrinsic::mips_frint_d, 62033}, // __builtin_msa_frint_d
+      {Intrinsic::mips_frint_w, 62055}, // __builtin_msa_frint_w
+      {Intrinsic::mips_frsqrt_d, 62077}, // __builtin_msa_frsqrt_d
+      {Intrinsic::mips_frsqrt_w, 62100}, // __builtin_msa_frsqrt_w
+      {Intrinsic::mips_fsaf_d, 62123}, // __builtin_msa_fsaf_d
+      {Intrinsic::mips_fsaf_w, 62144}, // __builtin_msa_fsaf_w
+      {Intrinsic::mips_fseq_d, 62165}, // __builtin_msa_fseq_d
+      {Intrinsic::mips_fseq_w, 62186}, // __builtin_msa_fseq_w
+      {Intrinsic::mips_fsle_d, 62207}, // __builtin_msa_fsle_d
+      {Intrinsic::mips_fsle_w, 62228}, // __builtin_msa_fsle_w
+      {Intrinsic::mips_fslt_d, 62249}, // __builtin_msa_fslt_d
+      {Intrinsic::mips_fslt_w, 62270}, // __builtin_msa_fslt_w
+      {Intrinsic::mips_fsne_d, 62291}, // __builtin_msa_fsne_d
+      {Intrinsic::mips_fsne_w, 62312}, // __builtin_msa_fsne_w
+      {Intrinsic::mips_fsor_d, 62333}, // __builtin_msa_fsor_d
+      {Intrinsic::mips_fsor_w, 62354}, // __builtin_msa_fsor_w
+      {Intrinsic::mips_fsqrt_d, 62375}, // __builtin_msa_fsqrt_d
+      {Intrinsic::mips_fsqrt_w, 62397}, // __builtin_msa_fsqrt_w
+      {Intrinsic::mips_fsub_d, 62419}, // __builtin_msa_fsub_d
+      {Intrinsic::mips_fsub_w, 62440}, // __builtin_msa_fsub_w
+      {Intrinsic::mips_fsueq_d, 62461}, // __builtin_msa_fsueq_d
+      {Intrinsic::mips_fsueq_w, 62483}, // __builtin_msa_fsueq_w
+      {Intrinsic::mips_fsule_d, 62505}, // __builtin_msa_fsule_d
+      {Intrinsic::mips_fsule_w, 62527}, // __builtin_msa_fsule_w
+      {Intrinsic::mips_fsult_d, 62549}, // __builtin_msa_fsult_d
+      {Intrinsic::mips_fsult_w, 62571}, // __builtin_msa_fsult_w
+      {Intrinsic::mips_fsun_d, 62593}, // __builtin_msa_fsun_d
+      {Intrinsic::mips_fsun_w, 62614}, // __builtin_msa_fsun_w
+      {Intrinsic::mips_fsune_d, 62635}, // __builtin_msa_fsune_d
+      {Intrinsic::mips_fsune_w, 62657}, // __builtin_msa_fsune_w
+      {Intrinsic::mips_ftint_s_d, 62679}, // __builtin_msa_ftint_s_d
+      {Intrinsic::mips_ftint_s_w, 62703}, // __builtin_msa_ftint_s_w
+      {Intrinsic::mips_ftint_u_d, 62727}, // __builtin_msa_ftint_u_d
+      {Intrinsic::mips_ftint_u_w, 62751}, // __builtin_msa_ftint_u_w
+      {Intrinsic::mips_ftq_h, 62775}, // __builtin_msa_ftq_h
+      {Intrinsic::mips_ftq_w, 62795}, // __builtin_msa_ftq_w
+      {Intrinsic::mips_ftrunc_s_d, 62815}, // __builtin_msa_ftrunc_s_d
+      {Intrinsic::mips_ftrunc_s_w, 62840}, // __builtin_msa_ftrunc_s_w
+      {Intrinsic::mips_ftrunc_u_d, 62865}, // __builtin_msa_ftrunc_u_d
+      {Intrinsic::mips_ftrunc_u_w, 62890}, // __builtin_msa_ftrunc_u_w
+      {Intrinsic::mips_hadd_s_d, 62915}, // __builtin_msa_hadd_s_d
+      {Intrinsic::mips_hadd_s_h, 62938}, // __builtin_msa_hadd_s_h
+      {Intrinsic::mips_hadd_s_w, 62961}, // __builtin_msa_hadd_s_w
+      {Intrinsic::mips_hadd_u_d, 62984}, // __builtin_msa_hadd_u_d
+      {Intrinsic::mips_hadd_u_h, 63007}, // __builtin_msa_hadd_u_h
+      {Intrinsic::mips_hadd_u_w, 63030}, // __builtin_msa_hadd_u_w
+      {Intrinsic::mips_hsub_s_d, 63053}, // __builtin_msa_hsub_s_d
+      {Intrinsic::mips_hsub_s_h, 63076}, // __builtin_msa_hsub_s_h
+      {Intrinsic::mips_hsub_s_w, 63099}, // __builtin_msa_hsub_s_w
+      {Intrinsic::mips_hsub_u_d, 63122}, // __builtin_msa_hsub_u_d
+      {Intrinsic::mips_hsub_u_h, 63145}, // __builtin_msa_hsub_u_h
+      {Intrinsic::mips_hsub_u_w, 63168}, // __builtin_msa_hsub_u_w
+      {Intrinsic::mips_ilvev_b, 63191}, // __builtin_msa_ilvev_b
+      {Intrinsic::mips_ilvev_d, 63213}, // __builtin_msa_ilvev_d
+      {Intrinsic::mips_ilvev_h, 63235}, // __builtin_msa_ilvev_h
+      {Intrinsic::mips_ilvev_w, 63257}, // __builtin_msa_ilvev_w
+      {Intrinsic::mips_ilvl_b, 63279}, // __builtin_msa_ilvl_b
+      {Intrinsic::mips_ilvl_d, 63300}, // __builtin_msa_ilvl_d
+      {Intrinsic::mips_ilvl_h, 63321}, // __builtin_msa_ilvl_h
+      {Intrinsic::mips_ilvl_w, 63342}, // __builtin_msa_ilvl_w
+      {Intrinsic::mips_ilvod_b, 63363}, // __builtin_msa_ilvod_b
+      {Intrinsic::mips_ilvod_d, 63385}, // __builtin_msa_ilvod_d
+      {Intrinsic::mips_ilvod_h, 63407}, // __builtin_msa_ilvod_h
+      {Intrinsic::mips_ilvod_w, 63429}, // __builtin_msa_ilvod_w
+      {Intrinsic::mips_ilvr_b, 63451}, // __builtin_msa_ilvr_b
+      {Intrinsic::mips_ilvr_d, 63472}, // __builtin_msa_ilvr_d
+      {Intrinsic::mips_ilvr_h, 63493}, // __builtin_msa_ilvr_h
+      {Intrinsic::mips_ilvr_w, 63514}, // __builtin_msa_ilvr_w
+      {Intrinsic::mips_insert_b, 63535}, // __builtin_msa_insert_b
+      {Intrinsic::mips_insert_d, 63558}, // __builtin_msa_insert_d
+      {Intrinsic::mips_insert_h, 63581}, // __builtin_msa_insert_h
+      {Intrinsic::mips_insert_w, 63604}, // __builtin_msa_insert_w
+      {Intrinsic::mips_insve_b, 63647}, // __builtin_msa_insve_b
+      {Intrinsic::mips_insve_d, 63669}, // __builtin_msa_insve_d
+      {Intrinsic::mips_insve_h, 63691}, // __builtin_msa_insve_h
+      {Intrinsic::mips_insve_w, 63713}, // __builtin_msa_insve_w
+      {Intrinsic::mips_ld_b, 63755}, // __builtin_msa_ld_b
+      {Intrinsic::mips_ld_d, 63774}, // __builtin_msa_ld_d
+      {Intrinsic::mips_ld_h, 63793}, // __builtin_msa_ld_h
+      {Intrinsic::mips_ld_w, 63812}, // __builtin_msa_ld_w
+      {Intrinsic::mips_ldi_b, 63831}, // __builtin_msa_ldi_b
+      {Intrinsic::mips_ldi_d, 63851}, // __builtin_msa_ldi_d
+      {Intrinsic::mips_ldi_h, 63871}, // __builtin_msa_ldi_h
+      {Intrinsic::mips_ldi_w, 63891}, // __builtin_msa_ldi_w
+      {Intrinsic::mips_ldr_d, 63911}, // __builtin_msa_ldr_d
+      {Intrinsic::mips_ldr_w, 63931}, // __builtin_msa_ldr_w
+      {Intrinsic::mips_madd_q_h, 64028}, // __builtin_msa_madd_q_h
+      {Intrinsic::mips_madd_q_w, 64051}, // __builtin_msa_madd_q_w
+      {Intrinsic::mips_maddr_q_h, 64074}, // __builtin_msa_maddr_q_h
+      {Intrinsic::mips_maddr_q_w, 64098}, // __builtin_msa_maddr_q_w
+      {Intrinsic::mips_maddv_b, 64143}, // __builtin_msa_maddv_b
+      {Intrinsic::mips_maddv_d, 64165}, // __builtin_msa_maddv_d
+      {Intrinsic::mips_maddv_h, 64187}, // __builtin_msa_maddv_h
+      {Intrinsic::mips_maddv_w, 64209}, // __builtin_msa_maddv_w
+      {Intrinsic::mips_max_a_b, 64341}, // __builtin_msa_max_a_b
+      {Intrinsic::mips_max_a_d, 64363}, // __builtin_msa_max_a_d
+      {Intrinsic::mips_max_a_h, 64385}, // __builtin_msa_max_a_h
+      {Intrinsic::mips_max_a_w, 64407}, // __builtin_msa_max_a_w
+      {Intrinsic::mips_max_s_b, 64429}, // __builtin_msa_max_s_b
+      {Intrinsic::mips_max_s_d, 64451}, // __builtin_msa_max_s_d
+      {Intrinsic::mips_max_s_h, 64473}, // __builtin_msa_max_s_h
+      {Intrinsic::mips_max_s_w, 64495}, // __builtin_msa_max_s_w
+      {Intrinsic::mips_max_u_b, 64517}, // __builtin_msa_max_u_b
+      {Intrinsic::mips_max_u_d, 64539}, // __builtin_msa_max_u_d
+      {Intrinsic::mips_max_u_h, 64561}, // __builtin_msa_max_u_h
+      {Intrinsic::mips_max_u_w, 64583}, // __builtin_msa_max_u_w
+      {Intrinsic::mips_maxi_s_b, 64605}, // __builtin_msa_maxi_s_b
+      {Intrinsic::mips_maxi_s_d, 64628}, // __builtin_msa_maxi_s_d
+      {Intrinsic::mips_maxi_s_h, 64651}, // __builtin_msa_maxi_s_h
+      {Intrinsic::mips_maxi_s_w, 64674}, // __builtin_msa_maxi_s_w
+      {Intrinsic::mips_maxi_u_b, 64697}, // __builtin_msa_maxi_u_b
+      {Intrinsic::mips_maxi_u_d, 64720}, // __builtin_msa_maxi_u_d
+      {Intrinsic::mips_maxi_u_h, 64743}, // __builtin_msa_maxi_u_h
+      {Intrinsic::mips_maxi_u_w, 64766}, // __builtin_msa_maxi_u_w
+      {Intrinsic::mips_min_a_b, 64789}, // __builtin_msa_min_a_b
+      {Intrinsic::mips_min_a_d, 64811}, // __builtin_msa_min_a_d
+      {Intrinsic::mips_min_a_h, 64833}, // __builtin_msa_min_a_h
+      {Intrinsic::mips_min_a_w, 64855}, // __builtin_msa_min_a_w
+      {Intrinsic::mips_min_s_b, 64877}, // __builtin_msa_min_s_b
+      {Intrinsic::mips_min_s_d, 64899}, // __builtin_msa_min_s_d
+      {Intrinsic::mips_min_s_h, 64921}, // __builtin_msa_min_s_h
+      {Intrinsic::mips_min_s_w, 64943}, // __builtin_msa_min_s_w
+      {Intrinsic::mips_min_u_b, 64965}, // __builtin_msa_min_u_b
+      {Intrinsic::mips_min_u_d, 64987}, // __builtin_msa_min_u_d
+      {Intrinsic::mips_min_u_h, 65009}, // __builtin_msa_min_u_h
+      {Intrinsic::mips_min_u_w, 65031}, // __builtin_msa_min_u_w
+      {Intrinsic::mips_mini_s_b, 65053}, // __builtin_msa_mini_s_b
+      {Intrinsic::mips_mini_s_d, 65076}, // __builtin_msa_mini_s_d
+      {Intrinsic::mips_mini_s_h, 65099}, // __builtin_msa_mini_s_h
+      {Intrinsic::mips_mini_s_w, 65122}, // __builtin_msa_mini_s_w
+      {Intrinsic::mips_mini_u_b, 65145}, // __builtin_msa_mini_u_b
+      {Intrinsic::mips_mini_u_d, 65168}, // __builtin_msa_mini_u_d
+      {Intrinsic::mips_mini_u_h, 65191}, // __builtin_msa_mini_u_h
+      {Intrinsic::mips_mini_u_w, 65214}, // __builtin_msa_mini_u_w
+      {Intrinsic::mips_mod_s_b, 65237}, // __builtin_msa_mod_s_b
+      {Intrinsic::mips_mod_s_d, 65259}, // __builtin_msa_mod_s_d
+      {Intrinsic::mips_mod_s_h, 65281}, // __builtin_msa_mod_s_h
+      {Intrinsic::mips_mod_s_w, 65303}, // __builtin_msa_mod_s_w
+      {Intrinsic::mips_mod_u_b, 65325}, // __builtin_msa_mod_u_b
+      {Intrinsic::mips_mod_u_d, 65347}, // __builtin_msa_mod_u_d
+      {Intrinsic::mips_mod_u_h, 65369}, // __builtin_msa_mod_u_h
+      {Intrinsic::mips_mod_u_w, 65391}, // __builtin_msa_mod_u_w
+      {Intrinsic::mips_move_v, 65435}, // __builtin_msa_move_v
+      {Intrinsic::mips_msub_q_h, 65476}, // __builtin_msa_msub_q_h
+      {Intrinsic::mips_msub_q_w, 65499}, // __builtin_msa_msub_q_w
+      {Intrinsic::mips_msubr_q_h, 65522}, // __builtin_msa_msubr_q_h
+      {Intrinsic::mips_msubr_q_w, 65546}, // __builtin_msa_msubr_q_w
+      {Intrinsic::mips_msubv_b, 65591}, // __builtin_msa_msubv_b
+      {Intrinsic::mips_msubv_d, 65613}, // __builtin_msa_msubv_d
+      {Intrinsic::mips_msubv_h, 65635}, // __builtin_msa_msubv_h
+      {Intrinsic::mips_msubv_w, 65657}, // __builtin_msa_msubv_w
+      {Intrinsic::mips_mul_q_h, 65723}, // __builtin_msa_mul_q_h
+      {Intrinsic::mips_mul_q_w, 65745}, // __builtin_msa_mul_q_w
+      {Intrinsic::mips_mulr_q_h, 66009}, // __builtin_msa_mulr_q_h
+      {Intrinsic::mips_mulr_q_w, 66032}, // __builtin_msa_mulr_q_w
+      {Intrinsic::mips_mulv_b, 66151}, // __builtin_msa_mulv_b
+      {Intrinsic::mips_mulv_d, 66172}, // __builtin_msa_mulv_d
+      {Intrinsic::mips_mulv_h, 66193}, // __builtin_msa_mulv_h
+      {Intrinsic::mips_mulv_w, 66214}, // __builtin_msa_mulv_w
+      {Intrinsic::mips_nloc_b, 66235}, // __builtin_msa_nloc_b
+      {Intrinsic::mips_nloc_d, 66256}, // __builtin_msa_nloc_d
+      {Intrinsic::mips_nloc_h, 66277}, // __builtin_msa_nloc_h
+      {Intrinsic::mips_nloc_w, 66298}, // __builtin_msa_nloc_w
+      {Intrinsic::mips_nlzc_b, 66319}, // __builtin_msa_nlzc_b
+      {Intrinsic::mips_nlzc_d, 66340}, // __builtin_msa_nlzc_d
+      {Intrinsic::mips_nlzc_h, 66361}, // __builtin_msa_nlzc_h
+      {Intrinsic::mips_nlzc_w, 66382}, // __builtin_msa_nlzc_w
+      {Intrinsic::mips_nor_v, 66403}, // __builtin_msa_nor_v
+      {Intrinsic::mips_nori_b, 66423}, // __builtin_msa_nori_b
+      {Intrinsic::mips_or_v, 66444}, // __builtin_msa_or_v
+      {Intrinsic::mips_ori_b, 66463}, // __builtin_msa_ori_b
+      {Intrinsic::mips_pckev_b, 66508}, // __builtin_msa_pckev_b
+      {Intrinsic::mips_pckev_d, 66530}, // __builtin_msa_pckev_d
+      {Intrinsic::mips_pckev_h, 66552}, // __builtin_msa_pckev_h
+      {Intrinsic::mips_pckev_w, 66574}, // __builtin_msa_pckev_w
+      {Intrinsic::mips_pckod_b, 66596}, // __builtin_msa_pckod_b
+      {Intrinsic::mips_pckod_d, 66618}, // __builtin_msa_pckod_d
+      {Intrinsic::mips_pckod_h, 66640}, // __builtin_msa_pckod_h
+      {Intrinsic::mips_pckod_w, 66662}, // __builtin_msa_pckod_w
+      {Intrinsic::mips_pcnt_b, 66684}, // __builtin_msa_pcnt_b
+      {Intrinsic::mips_pcnt_d, 66705}, // __builtin_msa_pcnt_d
+      {Intrinsic::mips_pcnt_h, 66726}, // __builtin_msa_pcnt_h
+      {Intrinsic::mips_pcnt_w, 66747}, // __builtin_msa_pcnt_w
+      {Intrinsic::mips_sat_s_b, 67431}, // __builtin_msa_sat_s_b
+      {Intrinsic::mips_sat_s_d, 67453}, // __builtin_msa_sat_s_d
+      {Intrinsic::mips_sat_s_h, 67475}, // __builtin_msa_sat_s_h
+      {Intrinsic::mips_sat_s_w, 67497}, // __builtin_msa_sat_s_w
+      {Intrinsic::mips_sat_u_b, 67519}, // __builtin_msa_sat_u_b
+      {Intrinsic::mips_sat_u_d, 67541}, // __builtin_msa_sat_u_d
+      {Intrinsic::mips_sat_u_h, 67563}, // __builtin_msa_sat_u_h
+      {Intrinsic::mips_sat_u_w, 67585}, // __builtin_msa_sat_u_w
+      {Intrinsic::mips_shf_b, 67607}, // __builtin_msa_shf_b
+      {Intrinsic::mips_shf_h, 67627}, // __builtin_msa_shf_h
+      {Intrinsic::mips_shf_w, 67647}, // __builtin_msa_shf_w
+      {Intrinsic::mips_sld_b, 67949}, // __builtin_msa_sld_b
+      {Intrinsic::mips_sld_d, 67969}, // __builtin_msa_sld_d
+      {Intrinsic::mips_sld_h, 67989}, // __builtin_msa_sld_h
+      {Intrinsic::mips_sld_w, 68009}, // __builtin_msa_sld_w
+      {Intrinsic::mips_sldi_b, 68029}, // __builtin_msa_sldi_b
+      {Intrinsic::mips_sldi_d, 68050}, // __builtin_msa_sldi_d
+      {Intrinsic::mips_sldi_h, 68071}, // __builtin_msa_sldi_h
+      {Intrinsic::mips_sldi_w, 68092}, // __builtin_msa_sldi_w
+      {Intrinsic::mips_sll_b, 68113}, // __builtin_msa_sll_b
+      {Intrinsic::mips_sll_d, 68133}, // __builtin_msa_sll_d
+      {Intrinsic::mips_sll_h, 68153}, // __builtin_msa_sll_h
+      {Intrinsic::mips_sll_w, 68173}, // __builtin_msa_sll_w
+      {Intrinsic::mips_slli_b, 68193}, // __builtin_msa_slli_b
+      {Intrinsic::mips_slli_d, 68214}, // __builtin_msa_slli_d
+      {Intrinsic::mips_slli_h, 68235}, // __builtin_msa_slli_h
+      {Intrinsic::mips_slli_w, 68256}, // __builtin_msa_slli_w
+      {Intrinsic::mips_splat_b, 68277}, // __builtin_msa_splat_b
+      {Intrinsic::mips_splat_d, 68299}, // __builtin_msa_splat_d
+      {Intrinsic::mips_splat_h, 68321}, // __builtin_msa_splat_h
+      {Intrinsic::mips_splat_w, 68343}, // __builtin_msa_splat_w
+      {Intrinsic::mips_splati_b, 68365}, // __builtin_msa_splati_b
+      {Intrinsic::mips_splati_d, 68388}, // __builtin_msa_splati_d
+      {Intrinsic::mips_splati_h, 68411}, // __builtin_msa_splati_h
+      {Intrinsic::mips_splati_w, 68434}, // __builtin_msa_splati_w
+      {Intrinsic::mips_sra_b, 68457}, // __builtin_msa_sra_b
+      {Intrinsic::mips_sra_d, 68477}, // __builtin_msa_sra_d
+      {Intrinsic::mips_sra_h, 68497}, // __builtin_msa_sra_h
+      {Intrinsic::mips_sra_w, 68517}, // __builtin_msa_sra_w
+      {Intrinsic::mips_srai_b, 68537}, // __builtin_msa_srai_b
+      {Intrinsic::mips_srai_d, 68558}, // __builtin_msa_srai_d
+      {Intrinsic::mips_srai_h, 68579}, // __builtin_msa_srai_h
+      {Intrinsic::mips_srai_w, 68600}, // __builtin_msa_srai_w
+      {Intrinsic::mips_srar_b, 68621}, // __builtin_msa_srar_b
+      {Intrinsic::mips_srar_d, 68642}, // __builtin_msa_srar_d
+      {Intrinsic::mips_srar_h, 68663}, // __builtin_msa_srar_h
+      {Intrinsic::mips_srar_w, 68684}, // __builtin_msa_srar_w
+      {Intrinsic::mips_srari_b, 68705}, // __builtin_msa_srari_b
+      {Intrinsic::mips_srari_d, 68727}, // __builtin_msa_srari_d
+      {Intrinsic::mips_srari_h, 68749}, // __builtin_msa_srari_h
+      {Intrinsic::mips_srari_w, 68771}, // __builtin_msa_srari_w
+      {Intrinsic::mips_srl_b, 68793}, // __builtin_msa_srl_b
+      {Intrinsic::mips_srl_d, 68813}, // __builtin_msa_srl_d
+      {Intrinsic::mips_srl_h, 68833}, // __builtin_msa_srl_h
+      {Intrinsic::mips_srl_w, 68853}, // __builtin_msa_srl_w
+      {Intrinsic::mips_srli_b, 68873}, // __builtin_msa_srli_b
+      {Intrinsic::mips_srli_d, 68894}, // __builtin_msa_srli_d
+      {Intrinsic::mips_srli_h, 68915}, // __builtin_msa_srli_h
+      {Intrinsic::mips_srli_w, 68936}, // __builtin_msa_srli_w
+      {Intrinsic::mips_srlr_b, 68957}, // __builtin_msa_srlr_b
+      {Intrinsic::mips_srlr_d, 68978}, // __builtin_msa_srlr_d
+      {Intrinsic::mips_srlr_h, 68999}, // __builtin_msa_srlr_h
+      {Intrinsic::mips_srlr_w, 69020}, // __builtin_msa_srlr_w
+      {Intrinsic::mips_srlri_b, 69041}, // __builtin_msa_srlri_b
+      {Intrinsic::mips_srlri_d, 69063}, // __builtin_msa_srlri_d
+      {Intrinsic::mips_srlri_h, 69085}, // __builtin_msa_srlri_h
+      {Intrinsic::mips_srlri_w, 69107}, // __builtin_msa_srlri_w
+      {Intrinsic::mips_st_b, 69129}, // __builtin_msa_st_b
+      {Intrinsic::mips_st_d, 69148}, // __builtin_msa_st_d
+      {Intrinsic::mips_st_h, 69167}, // __builtin_msa_st_h
+      {Intrinsic::mips_st_w, 69186}, // __builtin_msa_st_w
+      {Intrinsic::mips_str_d, 69205}, // __builtin_msa_str_d
+      {Intrinsic::mips_str_w, 69225}, // __builtin_msa_str_w
+      {Intrinsic::mips_subs_s_b, 69415}, // __builtin_msa_subs_s_b
+      {Intrinsic::mips_subs_s_d, 69438}, // __builtin_msa_subs_s_d
+      {Intrinsic::mips_subs_s_h, 69461}, // __builtin_msa_subs_s_h
+      {Intrinsic::mips_subs_s_w, 69484}, // __builtin_msa_subs_s_w
+      {Intrinsic::mips_subs_u_b, 69507}, // __builtin_msa_subs_u_b
+      {Intrinsic::mips_subs_u_d, 69530}, // __builtin_msa_subs_u_d
+      {Intrinsic::mips_subs_u_h, 69553}, // __builtin_msa_subs_u_h
+      {Intrinsic::mips_subs_u_w, 69576}, // __builtin_msa_subs_u_w
+      {Intrinsic::mips_subsus_u_b, 69599}, // __builtin_msa_subsus_u_b
+      {Intrinsic::mips_subsus_u_d, 69624}, // __builtin_msa_subsus_u_d
+      {Intrinsic::mips_subsus_u_h, 69649}, // __builtin_msa_subsus_u_h
+      {Intrinsic::mips_subsus_u_w, 69674}, // __builtin_msa_subsus_u_w
+      {Intrinsic::mips_subsuu_s_b, 69699}, // __builtin_msa_subsuu_s_b
+      {Intrinsic::mips_subsuu_s_d, 69724}, // __builtin_msa_subsuu_s_d
+      {Intrinsic::mips_subsuu_s_h, 69749}, // __builtin_msa_subsuu_s_h
+      {Intrinsic::mips_subsuu_s_w, 69774}, // __builtin_msa_subsuu_s_w
+      {Intrinsic::mips_subv_b, 69945}, // __builtin_msa_subv_b
+      {Intrinsic::mips_subv_d, 69966}, // __builtin_msa_subv_d
+      {Intrinsic::mips_subv_h, 69987}, // __builtin_msa_subv_h
+      {Intrinsic::mips_subv_w, 70008}, // __builtin_msa_subv_w
+      {Intrinsic::mips_subvi_b, 70029}, // __builtin_msa_subvi_b
+      {Intrinsic::mips_subvi_d, 70051}, // __builtin_msa_subvi_d
+      {Intrinsic::mips_subvi_h, 70073}, // __builtin_msa_subvi_h
+      {Intrinsic::mips_subvi_w, 70095}, // __builtin_msa_subvi_w
+      {Intrinsic::mips_vshf_b, 70117}, // __builtin_msa_vshf_b
+      {Intrinsic::mips_vshf_d, 70138}, // __builtin_msa_vshf_d
+      {Intrinsic::mips_vshf_h, 70159}, // __builtin_msa_vshf_h
+      {Intrinsic::mips_vshf_w, 70180}, // __builtin_msa_vshf_w
+      {Intrinsic::mips_xor_v, 70222}, // __builtin_msa_xor_v
+      {Intrinsic::mips_xori_b, 70242}, // __builtin_msa_xori_b
     };
     auto I = std::lower_bound(std::begin(mipsNames),
                               std::end(mipsNames),
@@ -29106,568 +38222,568 @@
   }
   if (TargetPrefix == "nvvm") {
     static const BuiltinEntry nvvmNames[] = {
-      {Intrinsic::nvvm_add_rm_d, 74943}, // __nvvm_add_rm_d
-      {Intrinsic::nvvm_add_rm_f, 74959}, // __nvvm_add_rm_f
-      {Intrinsic::nvvm_add_rm_ftz_f, 74975}, // __nvvm_add_rm_ftz_f
-      {Intrinsic::nvvm_add_rn_d, 74995}, // __nvvm_add_rn_d
-      {Intrinsic::nvvm_add_rn_f, 75011}, // __nvvm_add_rn_f
-      {Intrinsic::nvvm_add_rn_ftz_f, 75027}, // __nvvm_add_rn_ftz_f
-      {Intrinsic::nvvm_add_rp_d, 75047}, // __nvvm_add_rp_d
-      {Intrinsic::nvvm_add_rp_f, 75063}, // __nvvm_add_rp_f
-      {Intrinsic::nvvm_add_rp_ftz_f, 75079}, // __nvvm_add_rp_ftz_f
-      {Intrinsic::nvvm_add_rz_d, 75099}, // __nvvm_add_rz_d
-      {Intrinsic::nvvm_add_rz_f, 75115}, // __nvvm_add_rz_f
-      {Intrinsic::nvvm_add_rz_ftz_f, 75131}, // __nvvm_add_rz_ftz_f
-      {Intrinsic::nvvm_barrier, 75188}, // __nvvm_bar
-      {Intrinsic::nvvm_barrier0_and, 75270}, // __nvvm_bar0_and
-      {Intrinsic::nvvm_barrier0_or, 75286}, // __nvvm_bar0_or
-      {Intrinsic::nvvm_barrier0_popc, 75301}, // __nvvm_bar0_popc
-      {Intrinsic::nvvm_barrier_n, 75199}, // __nvvm_bar_n
-      {Intrinsic::nvvm_bar_sync, 75151}, // __nvvm_bar_sync
-      {Intrinsic::nvvm_bar_warp_sync, 75167}, // __nvvm_bar_warp_sync
-      {Intrinsic::nvvm_barrier_sync, 75212}, // __nvvm_barrier_sync
-      {Intrinsic::nvvm_barrier_sync_cnt, 75232}, // __nvvm_barrier_sync_cnt
-      {Intrinsic::nvvm_bitcast_d2ll, 75318}, // __nvvm_bitcast_d2ll
-      {Intrinsic::nvvm_bitcast_f2i, 75338}, // __nvvm_bitcast_f2i
-      {Intrinsic::nvvm_bitcast_i2f, 75357}, // __nvvm_bitcast_i2f
-      {Intrinsic::nvvm_bitcast_ll2d, 75376}, // __nvvm_bitcast_ll2d
-      {Intrinsic::nvvm_ceil_d, 75396}, // __nvvm_ceil_d
-      {Intrinsic::nvvm_ceil_f, 75410}, // __nvvm_ceil_f
-      {Intrinsic::nvvm_ceil_ftz_f, 75424}, // __nvvm_ceil_ftz_f
-      {Intrinsic::nvvm_cos_approx_f, 75442}, // __nvvm_cos_approx_f
-      {Intrinsic::nvvm_cos_approx_ftz_f, 75462}, // __nvvm_cos_approx_ftz_f
-      {Intrinsic::nvvm_d2f_rm, 75486}, // __nvvm_d2f_rm
-      {Intrinsic::nvvm_d2f_rm_ftz, 75500}, // __nvvm_d2f_rm_ftz
-      {Intrinsic::nvvm_d2f_rn, 75518}, // __nvvm_d2f_rn
-      {Intrinsic::nvvm_d2f_rn_ftz, 75532}, // __nvvm_d2f_rn_ftz
-      {Intrinsic::nvvm_d2f_rp, 75550}, // __nvvm_d2f_rp
-      {Intrinsic::nvvm_d2f_rp_ftz, 75564}, // __nvvm_d2f_rp_ftz
-      {Intrinsic::nvvm_d2f_rz, 75582}, // __nvvm_d2f_rz
-      {Intrinsic::nvvm_d2f_rz_ftz, 75596}, // __nvvm_d2f_rz_ftz
-      {Intrinsic::nvvm_d2i_hi, 75614}, // __nvvm_d2i_hi
-      {Intrinsic::nvvm_d2i_lo, 75628}, // __nvvm_d2i_lo
-      {Intrinsic::nvvm_d2i_rm, 75642}, // __nvvm_d2i_rm
-      {Intrinsic::nvvm_d2i_rn, 75656}, // __nvvm_d2i_rn
-      {Intrinsic::nvvm_d2i_rp, 75670}, // __nvvm_d2i_rp
-      {Intrinsic::nvvm_d2i_rz, 75684}, // __nvvm_d2i_rz
-      {Intrinsic::nvvm_d2ll_rm, 75698}, // __nvvm_d2ll_rm
-      {Intrinsic::nvvm_d2ll_rn, 75713}, // __nvvm_d2ll_rn
-      {Intrinsic::nvvm_d2ll_rp, 75728}, // __nvvm_d2ll_rp
-      {Intrinsic::nvvm_d2ll_rz, 75743}, // __nvvm_d2ll_rz
-      {Intrinsic::nvvm_d2ui_rm, 75758}, // __nvvm_d2ui_rm
-      {Intrinsic::nvvm_d2ui_rn, 75773}, // __nvvm_d2ui_rn
-      {Intrinsic::nvvm_d2ui_rp, 75788}, // __nvvm_d2ui_rp
-      {Intrinsic::nvvm_d2ui_rz, 75803}, // __nvvm_d2ui_rz
-      {Intrinsic::nvvm_d2ull_rm, 75818}, // __nvvm_d2ull_rm
-      {Intrinsic::nvvm_d2ull_rn, 75834}, // __nvvm_d2ull_rn
-      {Intrinsic::nvvm_d2ull_rp, 75850}, // __nvvm_d2ull_rp
-      {Intrinsic::nvvm_d2ull_rz, 75866}, // __nvvm_d2ull_rz
-      {Intrinsic::nvvm_div_approx_f, 75882}, // __nvvm_div_approx_f
-      {Intrinsic::nvvm_div_approx_ftz_f, 75902}, // __nvvm_div_approx_ftz_f
-      {Intrinsic::nvvm_div_rm_d, 75926}, // __nvvm_div_rm_d
-      {Intrinsic::nvvm_div_rm_f, 75942}, // __nvvm_div_rm_f
-      {Intrinsic::nvvm_div_rm_ftz_f, 75958}, // __nvvm_div_rm_ftz_f
-      {Intrinsic::nvvm_div_rn_d, 75978}, // __nvvm_div_rn_d
-      {Intrinsic::nvvm_div_rn_f, 75994}, // __nvvm_div_rn_f
-      {Intrinsic::nvvm_div_rn_ftz_f, 76010}, // __nvvm_div_rn_ftz_f
-      {Intrinsic::nvvm_div_rp_d, 76030}, // __nvvm_div_rp_d
-      {Intrinsic::nvvm_div_rp_f, 76046}, // __nvvm_div_rp_f
-      {Intrinsic::nvvm_div_rp_ftz_f, 76062}, // __nvvm_div_rp_ftz_f
-      {Intrinsic::nvvm_div_rz_d, 76082}, // __nvvm_div_rz_d
-      {Intrinsic::nvvm_div_rz_f, 76098}, // __nvvm_div_rz_f
-      {Intrinsic::nvvm_div_rz_ftz_f, 76114}, // __nvvm_div_rz_ftz_f
-      {Intrinsic::nvvm_ex2_approx_d, 76134}, // __nvvm_ex2_approx_d
-      {Intrinsic::nvvm_ex2_approx_f, 76154}, // __nvvm_ex2_approx_f
-      {Intrinsic::nvvm_ex2_approx_ftz_f, 76174}, // __nvvm_ex2_approx_ftz_f
-      {Intrinsic::nvvm_f2h_rn, 76198}, // __nvvm_f2h_rn
-      {Intrinsic::nvvm_f2h_rn_ftz, 76212}, // __nvvm_f2h_rn_ftz
-      {Intrinsic::nvvm_f2i_rm, 76230}, // __nvvm_f2i_rm
-      {Intrinsic::nvvm_f2i_rm_ftz, 76244}, // __nvvm_f2i_rm_ftz
-      {Intrinsic::nvvm_f2i_rn, 76262}, // __nvvm_f2i_rn
-      {Intrinsic::nvvm_f2i_rn_ftz, 76276}, // __nvvm_f2i_rn_ftz
-      {Intrinsic::nvvm_f2i_rp, 76294}, // __nvvm_f2i_rp
-      {Intrinsic::nvvm_f2i_rp_ftz, 76308}, // __nvvm_f2i_rp_ftz
-      {Intrinsic::nvvm_f2i_rz, 76326}, // __nvvm_f2i_rz
-      {Intrinsic::nvvm_f2i_rz_ftz, 76340}, // __nvvm_f2i_rz_ftz
-      {Intrinsic::nvvm_f2ll_rm, 76358}, // __nvvm_f2ll_rm
-      {Intrinsic::nvvm_f2ll_rm_ftz, 76373}, // __nvvm_f2ll_rm_ftz
-      {Intrinsic::nvvm_f2ll_rn, 76392}, // __nvvm_f2ll_rn
-      {Intrinsic::nvvm_f2ll_rn_ftz, 76407}, // __nvvm_f2ll_rn_ftz
-      {Intrinsic::nvvm_f2ll_rp, 76426}, // __nvvm_f2ll_rp
-      {Intrinsic::nvvm_f2ll_rp_ftz, 76441}, // __nvvm_f2ll_rp_ftz
-      {Intrinsic::nvvm_f2ll_rz, 76460}, // __nvvm_f2ll_rz
-      {Intrinsic::nvvm_f2ll_rz_ftz, 76475}, // __nvvm_f2ll_rz_ftz
-      {Intrinsic::nvvm_f2ui_rm, 76494}, // __nvvm_f2ui_rm
-      {Intrinsic::nvvm_f2ui_rm_ftz, 76509}, // __nvvm_f2ui_rm_ftz
-      {Intrinsic::nvvm_f2ui_rn, 76528}, // __nvvm_f2ui_rn
-      {Intrinsic::nvvm_f2ui_rn_ftz, 76543}, // __nvvm_f2ui_rn_ftz
-      {Intrinsic::nvvm_f2ui_rp, 76562}, // __nvvm_f2ui_rp
-      {Intrinsic::nvvm_f2ui_rp_ftz, 76577}, // __nvvm_f2ui_rp_ftz
-      {Intrinsic::nvvm_f2ui_rz, 76596}, // __nvvm_f2ui_rz
-      {Intrinsic::nvvm_f2ui_rz_ftz, 76611}, // __nvvm_f2ui_rz_ftz
-      {Intrinsic::nvvm_f2ull_rm, 76630}, // __nvvm_f2ull_rm
-      {Intrinsic::nvvm_f2ull_rm_ftz, 76646}, // __nvvm_f2ull_rm_ftz
-      {Intrinsic::nvvm_f2ull_rn, 76666}, // __nvvm_f2ull_rn
-      {Intrinsic::nvvm_f2ull_rn_ftz, 76682}, // __nvvm_f2ull_rn_ftz
-      {Intrinsic::nvvm_f2ull_rp, 76702}, // __nvvm_f2ull_rp
-      {Intrinsic::nvvm_f2ull_rp_ftz, 76718}, // __nvvm_f2ull_rp_ftz
-      {Intrinsic::nvvm_f2ull_rz, 76738}, // __nvvm_f2ull_rz
-      {Intrinsic::nvvm_f2ull_rz_ftz, 76754}, // __nvvm_f2ull_rz_ftz
-      {Intrinsic::nvvm_fabs_d, 76774}, // __nvvm_fabs_d
-      {Intrinsic::nvvm_fabs_f, 76788}, // __nvvm_fabs_f
-      {Intrinsic::nvvm_fabs_ftz_f, 76802}, // __nvvm_fabs_ftz_f
-      {Intrinsic::nvvm_floor_d, 76820}, // __nvvm_floor_d
-      {Intrinsic::nvvm_floor_f, 76835}, // __nvvm_floor_f
-      {Intrinsic::nvvm_floor_ftz_f, 76850}, // __nvvm_floor_ftz_f
-      {Intrinsic::nvvm_fma_rm_d, 76869}, // __nvvm_fma_rm_d
-      {Intrinsic::nvvm_fma_rm_f, 76885}, // __nvvm_fma_rm_f
-      {Intrinsic::nvvm_fma_rm_ftz_f, 76901}, // __nvvm_fma_rm_ftz_f
-      {Intrinsic::nvvm_fma_rn_d, 76921}, // __nvvm_fma_rn_d
-      {Intrinsic::nvvm_fma_rn_f, 76937}, // __nvvm_fma_rn_f
-      {Intrinsic::nvvm_fma_rn_ftz_f, 76953}, // __nvvm_fma_rn_ftz_f
-      {Intrinsic::nvvm_fma_rp_d, 76973}, // __nvvm_fma_rp_d
-      {Intrinsic::nvvm_fma_rp_f, 76989}, // __nvvm_fma_rp_f
-      {Intrinsic::nvvm_fma_rp_ftz_f, 77005}, // __nvvm_fma_rp_ftz_f
-      {Intrinsic::nvvm_fma_rz_d, 77025}, // __nvvm_fma_rz_d
-      {Intrinsic::nvvm_fma_rz_f, 77041}, // __nvvm_fma_rz_f
-      {Intrinsic::nvvm_fma_rz_ftz_f, 77057}, // __nvvm_fma_rz_ftz_f
-      {Intrinsic::nvvm_fmax_d, 77077}, // __nvvm_fmax_d
-      {Intrinsic::nvvm_fmax_f, 77091}, // __nvvm_fmax_f
-      {Intrinsic::nvvm_fmax_ftz_f, 77105}, // __nvvm_fmax_ftz_f
-      {Intrinsic::nvvm_fmin_d, 77123}, // __nvvm_fmin_d
-      {Intrinsic::nvvm_fmin_f, 77137}, // __nvvm_fmin_f
-      {Intrinsic::nvvm_fmin_ftz_f, 77151}, // __nvvm_fmin_ftz_f
-      {Intrinsic::nvvm_fns, 77169}, // __nvvm_fns
-      {Intrinsic::nvvm_i2d_rm, 77180}, // __nvvm_i2d_rm
-      {Intrinsic::nvvm_i2d_rn, 77194}, // __nvvm_i2d_rn
-      {Intrinsic::nvvm_i2d_rp, 77208}, // __nvvm_i2d_rp
-      {Intrinsic::nvvm_i2d_rz, 77222}, // __nvvm_i2d_rz
-      {Intrinsic::nvvm_i2f_rm, 77236}, // __nvvm_i2f_rm
-      {Intrinsic::nvvm_i2f_rn, 77250}, // __nvvm_i2f_rn
-      {Intrinsic::nvvm_i2f_rp, 77264}, // __nvvm_i2f_rp
-      {Intrinsic::nvvm_i2f_rz, 77278}, // __nvvm_i2f_rz
-      {Intrinsic::nvvm_isspacep_const, 77292}, // __nvvm_isspacep_const
-      {Intrinsic::nvvm_isspacep_global, 77314}, // __nvvm_isspacep_global
-      {Intrinsic::nvvm_isspacep_local, 77337}, // __nvvm_isspacep_local
-      {Intrinsic::nvvm_isspacep_shared, 77359}, // __nvvm_isspacep_shared
-      {Intrinsic::nvvm_istypep_sampler, 77382}, // __nvvm_istypep_sampler
-      {Intrinsic::nvvm_istypep_surface, 77405}, // __nvvm_istypep_surface
-      {Intrinsic::nvvm_istypep_texture, 77428}, // __nvvm_istypep_texture
-      {Intrinsic::nvvm_lg2_approx_d, 77451}, // __nvvm_lg2_approx_d
-      {Intrinsic::nvvm_lg2_approx_f, 77471}, // __nvvm_lg2_approx_f
-      {Intrinsic::nvvm_lg2_approx_ftz_f, 77491}, // __nvvm_lg2_approx_ftz_f
-      {Intrinsic::nvvm_ll2d_rm, 77515}, // __nvvm_ll2d_rm
-      {Intrinsic::nvvm_ll2d_rn, 77530}, // __nvvm_ll2d_rn
-      {Intrinsic::nvvm_ll2d_rp, 77545}, // __nvvm_ll2d_rp
-      {Intrinsic::nvvm_ll2d_rz, 77560}, // __nvvm_ll2d_rz
-      {Intrinsic::nvvm_ll2f_rm, 77575}, // __nvvm_ll2f_rm
-      {Intrinsic::nvvm_ll2f_rn, 77590}, // __nvvm_ll2f_rn
-      {Intrinsic::nvvm_ll2f_rp, 77605}, // __nvvm_ll2f_rp
-      {Intrinsic::nvvm_ll2f_rz, 77620}, // __nvvm_ll2f_rz
-      {Intrinsic::nvvm_lohi_i2d, 77635}, // __nvvm_lohi_i2d
-      {Intrinsic::nvvm_match_any_sync_i32, 77651}, // __nvvm_match_any_sync_i32
-      {Intrinsic::nvvm_match_any_sync_i64, 77677}, // __nvvm_match_any_sync_i64
-      {Intrinsic::nvvm_membar_cta, 77703}, // __nvvm_membar_cta
-      {Intrinsic::nvvm_membar_gl, 77721}, // __nvvm_membar_gl
-      {Intrinsic::nvvm_membar_sys, 77738}, // __nvvm_membar_sys
-      {Intrinsic::nvvm_mul24_i, 77964}, // __nvvm_mul24_i
-      {Intrinsic::nvvm_mul24_ui, 77979}, // __nvvm_mul24_ui
-      {Intrinsic::nvvm_mul_rm_d, 77756}, // __nvvm_mul_rm_d
-      {Intrinsic::nvvm_mul_rm_f, 77772}, // __nvvm_mul_rm_f
-      {Intrinsic::nvvm_mul_rm_ftz_f, 77788}, // __nvvm_mul_rm_ftz_f
-      {Intrinsic::nvvm_mul_rn_d, 77808}, // __nvvm_mul_rn_d
-      {Intrinsic::nvvm_mul_rn_f, 77824}, // __nvvm_mul_rn_f
-      {Intrinsic::nvvm_mul_rn_ftz_f, 77840}, // __nvvm_mul_rn_ftz_f
-      {Intrinsic::nvvm_mul_rp_d, 77860}, // __nvvm_mul_rp_d
-      {Intrinsic::nvvm_mul_rp_f, 77876}, // __nvvm_mul_rp_f
-      {Intrinsic::nvvm_mul_rp_ftz_f, 77892}, // __nvvm_mul_rp_ftz_f
-      {Intrinsic::nvvm_mul_rz_d, 77912}, // __nvvm_mul_rz_d
-      {Intrinsic::nvvm_mul_rz_f, 77928}, // __nvvm_mul_rz_f
-      {Intrinsic::nvvm_mul_rz_ftz_f, 77944}, // __nvvm_mul_rz_ftz_f
-      {Intrinsic::nvvm_mulhi_i, 77995}, // __nvvm_mulhi_i
-      {Intrinsic::nvvm_mulhi_ll, 78010}, // __nvvm_mulhi_ll
-      {Intrinsic::nvvm_mulhi_ui, 78026}, // __nvvm_mulhi_ui
-      {Intrinsic::nvvm_mulhi_ull, 78042}, // __nvvm_mulhi_ull
-      {Intrinsic::nvvm_prmt, 78059}, // __nvvm_prmt
-      {Intrinsic::nvvm_rcp_approx_ftz_d, 78071}, // __nvvm_rcp_approx_ftz_d
-      {Intrinsic::nvvm_rcp_rm_d, 78095}, // __nvvm_rcp_rm_d
-      {Intrinsic::nvvm_rcp_rm_f, 78111}, // __nvvm_rcp_rm_f
-      {Intrinsic::nvvm_rcp_rm_ftz_f, 78127}, // __nvvm_rcp_rm_ftz_f
-      {Intrinsic::nvvm_rcp_rn_d, 78147}, // __nvvm_rcp_rn_d
-      {Intrinsic::nvvm_rcp_rn_f, 78163}, // __nvvm_rcp_rn_f
-      {Intrinsic::nvvm_rcp_rn_ftz_f, 78179}, // __nvvm_rcp_rn_ftz_f
-      {Intrinsic::nvvm_rcp_rp_d, 78199}, // __nvvm_rcp_rp_d
-      {Intrinsic::nvvm_rcp_rp_f, 78215}, // __nvvm_rcp_rp_f
-      {Intrinsic::nvvm_rcp_rp_ftz_f, 78231}, // __nvvm_rcp_rp_ftz_f
-      {Intrinsic::nvvm_rcp_rz_d, 78251}, // __nvvm_rcp_rz_d
-      {Intrinsic::nvvm_rcp_rz_f, 78267}, // __nvvm_rcp_rz_f
-      {Intrinsic::nvvm_rcp_rz_ftz_f, 78283}, // __nvvm_rcp_rz_ftz_f
-      {Intrinsic::nvvm_read_ptx_sreg_clock, 78303}, // __nvvm_read_ptx_sreg_clock
-      {Intrinsic::nvvm_read_ptx_sreg_clock64, 78330}, // __nvvm_read_ptx_sreg_clock64
-      {Intrinsic::nvvm_read_ptx_sreg_ctaid_w, 78359}, // __nvvm_read_ptx_sreg_ctaid_w
-      {Intrinsic::nvvm_read_ptx_sreg_ctaid_x, 78388}, // __nvvm_read_ptx_sreg_ctaid_x
-      {Intrinsic::nvvm_read_ptx_sreg_ctaid_y, 78417}, // __nvvm_read_ptx_sreg_ctaid_y
-      {Intrinsic::nvvm_read_ptx_sreg_ctaid_z, 78446}, // __nvvm_read_ptx_sreg_ctaid_z
-      {Intrinsic::nvvm_read_ptx_sreg_envreg0, 78475}, // __nvvm_read_ptx_sreg_envreg0
-      {Intrinsic::nvvm_read_ptx_sreg_envreg1, 78504}, // __nvvm_read_ptx_sreg_envreg1
-      {Intrinsic::nvvm_read_ptx_sreg_envreg10, 78533}, // __nvvm_read_ptx_sreg_envreg10
-      {Intrinsic::nvvm_read_ptx_sreg_envreg11, 78563}, // __nvvm_read_ptx_sreg_envreg11
-      {Intrinsic::nvvm_read_ptx_sreg_envreg12, 78593}, // __nvvm_read_ptx_sreg_envreg12
-      {Intrinsic::nvvm_read_ptx_sreg_envreg13, 78623}, // __nvvm_read_ptx_sreg_envreg13
-      {Intrinsic::nvvm_read_ptx_sreg_envreg14, 78653}, // __nvvm_read_ptx_sreg_envreg14
-      {Intrinsic::nvvm_read_ptx_sreg_envreg15, 78683}, // __nvvm_read_ptx_sreg_envreg15
-      {Intrinsic::nvvm_read_ptx_sreg_envreg16, 78713}, // __nvvm_read_ptx_sreg_envreg16
-      {Intrinsic::nvvm_read_ptx_sreg_envreg17, 78743}, // __nvvm_read_ptx_sreg_envreg17
-      {Intrinsic::nvvm_read_ptx_sreg_envreg18, 78773}, // __nvvm_read_ptx_sreg_envreg18
-      {Intrinsic::nvvm_read_ptx_sreg_envreg19, 78803}, // __nvvm_read_ptx_sreg_envreg19
-      {Intrinsic::nvvm_read_ptx_sreg_envreg2, 78833}, // __nvvm_read_ptx_sreg_envreg2
-      {Intrinsic::nvvm_read_ptx_sreg_envreg20, 78862}, // __nvvm_read_ptx_sreg_envreg20
-      {Intrinsic::nvvm_read_ptx_sreg_envreg21, 78892}, // __nvvm_read_ptx_sreg_envreg21
-      {Intrinsic::nvvm_read_ptx_sreg_envreg22, 78922}, // __nvvm_read_ptx_sreg_envreg22
-      {Intrinsic::nvvm_read_ptx_sreg_envreg23, 78952}, // __nvvm_read_ptx_sreg_envreg23
-      {Intrinsic::nvvm_read_ptx_sreg_envreg24, 78982}, // __nvvm_read_ptx_sreg_envreg24
-      {Intrinsic::nvvm_read_ptx_sreg_envreg25, 79012}, // __nvvm_read_ptx_sreg_envreg25
-      {Intrinsic::nvvm_read_ptx_sreg_envreg26, 79042}, // __nvvm_read_ptx_sreg_envreg26
-      {Intrinsic::nvvm_read_ptx_sreg_envreg27, 79072}, // __nvvm_read_ptx_sreg_envreg27
-      {Intrinsic::nvvm_read_ptx_sreg_envreg28, 79102}, // __nvvm_read_ptx_sreg_envreg28
-      {Intrinsic::nvvm_read_ptx_sreg_envreg29, 79132}, // __nvvm_read_ptx_sreg_envreg29
-      {Intrinsic::nvvm_read_ptx_sreg_envreg3, 79162}, // __nvvm_read_ptx_sreg_envreg3
-      {Intrinsic::nvvm_read_ptx_sreg_envreg30, 79191}, // __nvvm_read_ptx_sreg_envreg30
-      {Intrinsic::nvvm_read_ptx_sreg_envreg31, 79221}, // __nvvm_read_ptx_sreg_envreg31
-      {Intrinsic::nvvm_read_ptx_sreg_envreg4, 79251}, // __nvvm_read_ptx_sreg_envreg4
-      {Intrinsic::nvvm_read_ptx_sreg_envreg5, 79280}, // __nvvm_read_ptx_sreg_envreg5
-      {Intrinsic::nvvm_read_ptx_sreg_envreg6, 79309}, // __nvvm_read_ptx_sreg_envreg6
-      {Intrinsic::nvvm_read_ptx_sreg_envreg7, 79338}, // __nvvm_read_ptx_sreg_envreg7
-      {Intrinsic::nvvm_read_ptx_sreg_envreg8, 79367}, // __nvvm_read_ptx_sreg_envreg8
-      {Intrinsic::nvvm_read_ptx_sreg_envreg9, 79396}, // __nvvm_read_ptx_sreg_envreg9
-      {Intrinsic::nvvm_read_ptx_sreg_gridid, 79425}, // __nvvm_read_ptx_sreg_gridid
-      {Intrinsic::nvvm_read_ptx_sreg_laneid, 79453}, // __nvvm_read_ptx_sreg_laneid
-      {Intrinsic::nvvm_read_ptx_sreg_lanemask_eq, 79481}, // __nvvm_read_ptx_sreg_lanemask_eq
-      {Intrinsic::nvvm_read_ptx_sreg_lanemask_ge, 79514}, // __nvvm_read_ptx_sreg_lanemask_ge
-      {Intrinsic::nvvm_read_ptx_sreg_lanemask_gt, 79547}, // __nvvm_read_ptx_sreg_lanemask_gt
-      {Intrinsic::nvvm_read_ptx_sreg_lanemask_le, 79580}, // __nvvm_read_ptx_sreg_lanemask_le
-      {Intrinsic::nvvm_read_ptx_sreg_lanemask_lt, 79613}, // __nvvm_read_ptx_sreg_lanemask_lt
-      {Intrinsic::nvvm_read_ptx_sreg_nctaid_w, 79646}, // __nvvm_read_ptx_sreg_nctaid_w
-      {Intrinsic::nvvm_read_ptx_sreg_nctaid_x, 79676}, // __nvvm_read_ptx_sreg_nctaid_x
-      {Intrinsic::nvvm_read_ptx_sreg_nctaid_y, 79706}, // __nvvm_read_ptx_sreg_nctaid_y
-      {Intrinsic::nvvm_read_ptx_sreg_nctaid_z, 79736}, // __nvvm_read_ptx_sreg_nctaid_z
-      {Intrinsic::nvvm_read_ptx_sreg_nsmid, 79766}, // __nvvm_read_ptx_sreg_nsmid
-      {Intrinsic::nvvm_read_ptx_sreg_ntid_w, 79793}, // __nvvm_read_ptx_sreg_ntid_w
-      {Intrinsic::nvvm_read_ptx_sreg_ntid_x, 79821}, // __nvvm_read_ptx_sreg_ntid_x
-      {Intrinsic::nvvm_read_ptx_sreg_ntid_y, 79849}, // __nvvm_read_ptx_sreg_ntid_y
-      {Intrinsic::nvvm_read_ptx_sreg_ntid_z, 79877}, // __nvvm_read_ptx_sreg_ntid_z
-      {Intrinsic::nvvm_read_ptx_sreg_nwarpid, 79905}, // __nvvm_read_ptx_sreg_nwarpid
-      {Intrinsic::nvvm_read_ptx_sreg_pm0, 79934}, // __nvvm_read_ptx_sreg_pm0
-      {Intrinsic::nvvm_read_ptx_sreg_pm1, 79959}, // __nvvm_read_ptx_sreg_pm1
-      {Intrinsic::nvvm_read_ptx_sreg_pm2, 79984}, // __nvvm_read_ptx_sreg_pm2
-      {Intrinsic::nvvm_read_ptx_sreg_pm3, 80009}, // __nvvm_read_ptx_sreg_pm3
-      {Intrinsic::nvvm_read_ptx_sreg_smid, 80034}, // __nvvm_read_ptx_sreg_smid
-      {Intrinsic::nvvm_read_ptx_sreg_tid_w, 80060}, // __nvvm_read_ptx_sreg_tid_w
-      {Intrinsic::nvvm_read_ptx_sreg_tid_x, 80087}, // __nvvm_read_ptx_sreg_tid_x
-      {Intrinsic::nvvm_read_ptx_sreg_tid_y, 80114}, // __nvvm_read_ptx_sreg_tid_y
-      {Intrinsic::nvvm_read_ptx_sreg_tid_z, 80141}, // __nvvm_read_ptx_sreg_tid_z
-      {Intrinsic::nvvm_read_ptx_sreg_warpid, 80168}, // __nvvm_read_ptx_sreg_warpid
-      {Intrinsic::nvvm_read_ptx_sreg_warpsize, 80196}, // __nvvm_read_ptx_sreg_warpsize
-      {Intrinsic::nvvm_rotate_b32, 80226}, // __nvvm_rotate_b32
-      {Intrinsic::nvvm_rotate_b64, 80244}, // __nvvm_rotate_b64
-      {Intrinsic::nvvm_rotate_right_b64, 80262}, // __nvvm_rotate_right_b64
-      {Intrinsic::nvvm_round_d, 80286}, // __nvvm_round_d
-      {Intrinsic::nvvm_round_f, 80301}, // __nvvm_round_f
-      {Intrinsic::nvvm_round_ftz_f, 80316}, // __nvvm_round_ftz_f
-      {Intrinsic::nvvm_rsqrt_approx_d, 80335}, // __nvvm_rsqrt_approx_d
-      {Intrinsic::nvvm_rsqrt_approx_f, 80357}, // __nvvm_rsqrt_approx_f
-      {Intrinsic::nvvm_rsqrt_approx_ftz_f, 80379}, // __nvvm_rsqrt_approx_ftz_f
-      {Intrinsic::nvvm_sad_i, 80405}, // __nvvm_sad_i
-      {Intrinsic::nvvm_sad_ui, 80418}, // __nvvm_sad_ui
-      {Intrinsic::nvvm_saturate_d, 80432}, // __nvvm_saturate_d
-      {Intrinsic::nvvm_saturate_f, 80450}, // __nvvm_saturate_f
-      {Intrinsic::nvvm_saturate_ftz_f, 80468}, // __nvvm_saturate_ftz_f
-      {Intrinsic::nvvm_shfl_bfly_f32, 80490}, // __nvvm_shfl_bfly_f32
-      {Intrinsic::nvvm_shfl_bfly_i32, 80511}, // __nvvm_shfl_bfly_i32
-      {Intrinsic::nvvm_shfl_down_f32, 80532}, // __nvvm_shfl_down_f32
-      {Intrinsic::nvvm_shfl_down_i32, 80553}, // __nvvm_shfl_down_i32
-      {Intrinsic::nvvm_shfl_idx_f32, 80574}, // __nvvm_shfl_idx_f32
-      {Intrinsic::nvvm_shfl_idx_i32, 80594}, // __nvvm_shfl_idx_i32
-      {Intrinsic::nvvm_shfl_sync_bfly_f32, 80614}, // __nvvm_shfl_sync_bfly_f32
-      {Intrinsic::nvvm_shfl_sync_bfly_i32, 80640}, // __nvvm_shfl_sync_bfly_i32
-      {Intrinsic::nvvm_shfl_sync_down_f32, 80666}, // __nvvm_shfl_sync_down_f32
-      {Intrinsic::nvvm_shfl_sync_down_i32, 80692}, // __nvvm_shfl_sync_down_i32
-      {Intrinsic::nvvm_shfl_sync_idx_f32, 80718}, // __nvvm_shfl_sync_idx_f32
-      {Intrinsic::nvvm_shfl_sync_idx_i32, 80743}, // __nvvm_shfl_sync_idx_i32
-      {Intrinsic::nvvm_shfl_sync_up_f32, 80768}, // __nvvm_shfl_sync_up_f32
-      {Intrinsic::nvvm_shfl_sync_up_i32, 80792}, // __nvvm_shfl_sync_up_i32
-      {Intrinsic::nvvm_shfl_up_f32, 80816}, // __nvvm_shfl_up_f32
-      {Intrinsic::nvvm_shfl_up_i32, 80835}, // __nvvm_shfl_up_i32
-      {Intrinsic::nvvm_sin_approx_f, 80854}, // __nvvm_sin_approx_f
-      {Intrinsic::nvvm_sin_approx_ftz_f, 80874}, // __nvvm_sin_approx_ftz_f
-      {Intrinsic::nvvm_sqrt_approx_f, 80898}, // __nvvm_sqrt_approx_f
-      {Intrinsic::nvvm_sqrt_approx_ftz_f, 80919}, // __nvvm_sqrt_approx_ftz_f
-      {Intrinsic::nvvm_sqrt_f, 80944}, // __nvvm_sqrt_f
-      {Intrinsic::nvvm_sqrt_rm_d, 80958}, // __nvvm_sqrt_rm_d
-      {Intrinsic::nvvm_sqrt_rm_f, 80975}, // __nvvm_sqrt_rm_f
-      {Intrinsic::nvvm_sqrt_rm_ftz_f, 80992}, // __nvvm_sqrt_rm_ftz_f
-      {Intrinsic::nvvm_sqrt_rn_d, 81013}, // __nvvm_sqrt_rn_d
-      {Intrinsic::nvvm_sqrt_rn_f, 81030}, // __nvvm_sqrt_rn_f
-      {Intrinsic::nvvm_sqrt_rn_ftz_f, 81047}, // __nvvm_sqrt_rn_ftz_f
-      {Intrinsic::nvvm_sqrt_rp_d, 81068}, // __nvvm_sqrt_rp_d
-      {Intrinsic::nvvm_sqrt_rp_f, 81085}, // __nvvm_sqrt_rp_f
-      {Intrinsic::nvvm_sqrt_rp_ftz_f, 81102}, // __nvvm_sqrt_rp_ftz_f
-      {Intrinsic::nvvm_sqrt_rz_d, 81123}, // __nvvm_sqrt_rz_d
-      {Intrinsic::nvvm_sqrt_rz_f, 81140}, // __nvvm_sqrt_rz_f
-      {Intrinsic::nvvm_sqrt_rz_ftz_f, 81157}, // __nvvm_sqrt_rz_ftz_f
-      {Intrinsic::nvvm_suq_array_size, 81178}, // __nvvm_suq_array_size
-      {Intrinsic::nvvm_suq_channel_data_type, 81200}, // __nvvm_suq_channel_data_type
-      {Intrinsic::nvvm_suq_channel_order, 81229}, // __nvvm_suq_channel_order
-      {Intrinsic::nvvm_suq_depth, 81254}, // __nvvm_suq_depth
-      {Intrinsic::nvvm_suq_height, 81271}, // __nvvm_suq_height
-      {Intrinsic::nvvm_suq_width, 81289}, // __nvvm_suq_width
-      {Intrinsic::nvvm_sust_b_1d_array_i16_clamp, 81306}, // __nvvm_sust_b_1d_array_i16_clamp
-      {Intrinsic::nvvm_sust_b_1d_array_i16_trap, 81339}, // __nvvm_sust_b_1d_array_i16_trap
-      {Intrinsic::nvvm_sust_b_1d_array_i16_zero, 81371}, // __nvvm_sust_b_1d_array_i16_zero
-      {Intrinsic::nvvm_sust_b_1d_array_i32_clamp, 81403}, // __nvvm_sust_b_1d_array_i32_clamp
-      {Intrinsic::nvvm_sust_b_1d_array_i32_trap, 81436}, // __nvvm_sust_b_1d_array_i32_trap
-      {Intrinsic::nvvm_sust_b_1d_array_i32_zero, 81468}, // __nvvm_sust_b_1d_array_i32_zero
-      {Intrinsic::nvvm_sust_b_1d_array_i64_clamp, 81500}, // __nvvm_sust_b_1d_array_i64_clamp
-      {Intrinsic::nvvm_sust_b_1d_array_i64_trap, 81533}, // __nvvm_sust_b_1d_array_i64_trap
-      {Intrinsic::nvvm_sust_b_1d_array_i64_zero, 81565}, // __nvvm_sust_b_1d_array_i64_zero
-      {Intrinsic::nvvm_sust_b_1d_array_i8_clamp, 81597}, // __nvvm_sust_b_1d_array_i8_clamp
-      {Intrinsic::nvvm_sust_b_1d_array_i8_trap, 81629}, // __nvvm_sust_b_1d_array_i8_trap
-      {Intrinsic::nvvm_sust_b_1d_array_i8_zero, 81660}, // __nvvm_sust_b_1d_array_i8_zero
-      {Intrinsic::nvvm_sust_b_1d_array_v2i16_clamp, 81691}, // __nvvm_sust_b_1d_array_v2i16_clamp
-      {Intrinsic::nvvm_sust_b_1d_array_v2i16_trap, 81726}, // __nvvm_sust_b_1d_array_v2i16_trap
-      {Intrinsic::nvvm_sust_b_1d_array_v2i16_zero, 81760}, // __nvvm_sust_b_1d_array_v2i16_zero
-      {Intrinsic::nvvm_sust_b_1d_array_v2i32_clamp, 81794}, // __nvvm_sust_b_1d_array_v2i32_clamp
-      {Intrinsic::nvvm_sust_b_1d_array_v2i32_trap, 81829}, // __nvvm_sust_b_1d_array_v2i32_trap
-      {Intrinsic::nvvm_sust_b_1d_array_v2i32_zero, 81863}, // __nvvm_sust_b_1d_array_v2i32_zero
-      {Intrinsic::nvvm_sust_b_1d_array_v2i64_clamp, 81897}, // __nvvm_sust_b_1d_array_v2i64_clamp
-      {Intrinsic::nvvm_sust_b_1d_array_v2i64_trap, 81932}, // __nvvm_sust_b_1d_array_v2i64_trap
-      {Intrinsic::nvvm_sust_b_1d_array_v2i64_zero, 81966}, // __nvvm_sust_b_1d_array_v2i64_zero
-      {Intrinsic::nvvm_sust_b_1d_array_v2i8_clamp, 82000}, // __nvvm_sust_b_1d_array_v2i8_clamp
-      {Intrinsic::nvvm_sust_b_1d_array_v2i8_trap, 82034}, // __nvvm_sust_b_1d_array_v2i8_trap
-      {Intrinsic::nvvm_sust_b_1d_array_v2i8_zero, 82067}, // __nvvm_sust_b_1d_array_v2i8_zero
-      {Intrinsic::nvvm_sust_b_1d_array_v4i16_clamp, 82100}, // __nvvm_sust_b_1d_array_v4i16_clamp
-      {Intrinsic::nvvm_sust_b_1d_array_v4i16_trap, 82135}, // __nvvm_sust_b_1d_array_v4i16_trap
-      {Intrinsic::nvvm_sust_b_1d_array_v4i16_zero, 82169}, // __nvvm_sust_b_1d_array_v4i16_zero
-      {Intrinsic::nvvm_sust_b_1d_array_v4i32_clamp, 82203}, // __nvvm_sust_b_1d_array_v4i32_clamp
-      {Intrinsic::nvvm_sust_b_1d_array_v4i32_trap, 82238}, // __nvvm_sust_b_1d_array_v4i32_trap
-      {Intrinsic::nvvm_sust_b_1d_array_v4i32_zero, 82272}, // __nvvm_sust_b_1d_array_v4i32_zero
-      {Intrinsic::nvvm_sust_b_1d_array_v4i8_clamp, 82306}, // __nvvm_sust_b_1d_array_v4i8_clamp
-      {Intrinsic::nvvm_sust_b_1d_array_v4i8_trap, 82340}, // __nvvm_sust_b_1d_array_v4i8_trap
-      {Intrinsic::nvvm_sust_b_1d_array_v4i8_zero, 82373}, // __nvvm_sust_b_1d_array_v4i8_zero
-      {Intrinsic::nvvm_sust_b_1d_i16_clamp, 82406}, // __nvvm_sust_b_1d_i16_clamp
-      {Intrinsic::nvvm_sust_b_1d_i16_trap, 82433}, // __nvvm_sust_b_1d_i16_trap
-      {Intrinsic::nvvm_sust_b_1d_i16_zero, 82459}, // __nvvm_sust_b_1d_i16_zero
-      {Intrinsic::nvvm_sust_b_1d_i32_clamp, 82485}, // __nvvm_sust_b_1d_i32_clamp
-      {Intrinsic::nvvm_sust_b_1d_i32_trap, 82512}, // __nvvm_sust_b_1d_i32_trap
-      {Intrinsic::nvvm_sust_b_1d_i32_zero, 82538}, // __nvvm_sust_b_1d_i32_zero
-      {Intrinsic::nvvm_sust_b_1d_i64_clamp, 82564}, // __nvvm_sust_b_1d_i64_clamp
-      {Intrinsic::nvvm_sust_b_1d_i64_trap, 82591}, // __nvvm_sust_b_1d_i64_trap
-      {Intrinsic::nvvm_sust_b_1d_i64_zero, 82617}, // __nvvm_sust_b_1d_i64_zero
-      {Intrinsic::nvvm_sust_b_1d_i8_clamp, 82643}, // __nvvm_sust_b_1d_i8_clamp
-      {Intrinsic::nvvm_sust_b_1d_i8_trap, 82669}, // __nvvm_sust_b_1d_i8_trap
-      {Intrinsic::nvvm_sust_b_1d_i8_zero, 82694}, // __nvvm_sust_b_1d_i8_zero
-      {Intrinsic::nvvm_sust_b_1d_v2i16_clamp, 82719}, // __nvvm_sust_b_1d_v2i16_clamp
-      {Intrinsic::nvvm_sust_b_1d_v2i16_trap, 82748}, // __nvvm_sust_b_1d_v2i16_trap
-      {Intrinsic::nvvm_sust_b_1d_v2i16_zero, 82776}, // __nvvm_sust_b_1d_v2i16_zero
-      {Intrinsic::nvvm_sust_b_1d_v2i32_clamp, 82804}, // __nvvm_sust_b_1d_v2i32_clamp
-      {Intrinsic::nvvm_sust_b_1d_v2i32_trap, 82833}, // __nvvm_sust_b_1d_v2i32_trap
-      {Intrinsic::nvvm_sust_b_1d_v2i32_zero, 82861}, // __nvvm_sust_b_1d_v2i32_zero
-      {Intrinsic::nvvm_sust_b_1d_v2i64_clamp, 82889}, // __nvvm_sust_b_1d_v2i64_clamp
-      {Intrinsic::nvvm_sust_b_1d_v2i64_trap, 82918}, // __nvvm_sust_b_1d_v2i64_trap
-      {Intrinsic::nvvm_sust_b_1d_v2i64_zero, 82946}, // __nvvm_sust_b_1d_v2i64_zero
-      {Intrinsic::nvvm_sust_b_1d_v2i8_clamp, 82974}, // __nvvm_sust_b_1d_v2i8_clamp
-      {Intrinsic::nvvm_sust_b_1d_v2i8_trap, 83002}, // __nvvm_sust_b_1d_v2i8_trap
-      {Intrinsic::nvvm_sust_b_1d_v2i8_zero, 83029}, // __nvvm_sust_b_1d_v2i8_zero
-      {Intrinsic::nvvm_sust_b_1d_v4i16_clamp, 83056}, // __nvvm_sust_b_1d_v4i16_clamp
-      {Intrinsic::nvvm_sust_b_1d_v4i16_trap, 83085}, // __nvvm_sust_b_1d_v4i16_trap
-      {Intrinsic::nvvm_sust_b_1d_v4i16_zero, 83113}, // __nvvm_sust_b_1d_v4i16_zero
-      {Intrinsic::nvvm_sust_b_1d_v4i32_clamp, 83141}, // __nvvm_sust_b_1d_v4i32_clamp
-      {Intrinsic::nvvm_sust_b_1d_v4i32_trap, 83170}, // __nvvm_sust_b_1d_v4i32_trap
-      {Intrinsic::nvvm_sust_b_1d_v4i32_zero, 83198}, // __nvvm_sust_b_1d_v4i32_zero
-      {Intrinsic::nvvm_sust_b_1d_v4i8_clamp, 83226}, // __nvvm_sust_b_1d_v4i8_clamp
-      {Intrinsic::nvvm_sust_b_1d_v4i8_trap, 83254}, // __nvvm_sust_b_1d_v4i8_trap
-      {Intrinsic::nvvm_sust_b_1d_v4i8_zero, 83281}, // __nvvm_sust_b_1d_v4i8_zero
-      {Intrinsic::nvvm_sust_b_2d_array_i16_clamp, 83308}, // __nvvm_sust_b_2d_array_i16_clamp
-      {Intrinsic::nvvm_sust_b_2d_array_i16_trap, 83341}, // __nvvm_sust_b_2d_array_i16_trap
-      {Intrinsic::nvvm_sust_b_2d_array_i16_zero, 83373}, // __nvvm_sust_b_2d_array_i16_zero
-      {Intrinsic::nvvm_sust_b_2d_array_i32_clamp, 83405}, // __nvvm_sust_b_2d_array_i32_clamp
-      {Intrinsic::nvvm_sust_b_2d_array_i32_trap, 83438}, // __nvvm_sust_b_2d_array_i32_trap
-      {Intrinsic::nvvm_sust_b_2d_array_i32_zero, 83470}, // __nvvm_sust_b_2d_array_i32_zero
-      {Intrinsic::nvvm_sust_b_2d_array_i64_clamp, 83502}, // __nvvm_sust_b_2d_array_i64_clamp
-      {Intrinsic::nvvm_sust_b_2d_array_i64_trap, 83535}, // __nvvm_sust_b_2d_array_i64_trap
-      {Intrinsic::nvvm_sust_b_2d_array_i64_zero, 83567}, // __nvvm_sust_b_2d_array_i64_zero
-      {Intrinsic::nvvm_sust_b_2d_array_i8_clamp, 83599}, // __nvvm_sust_b_2d_array_i8_clamp
-      {Intrinsic::nvvm_sust_b_2d_array_i8_trap, 83631}, // __nvvm_sust_b_2d_array_i8_trap
-      {Intrinsic::nvvm_sust_b_2d_array_i8_zero, 83662}, // __nvvm_sust_b_2d_array_i8_zero
-      {Intrinsic::nvvm_sust_b_2d_array_v2i16_clamp, 83693}, // __nvvm_sust_b_2d_array_v2i16_clamp
-      {Intrinsic::nvvm_sust_b_2d_array_v2i16_trap, 83728}, // __nvvm_sust_b_2d_array_v2i16_trap
-      {Intrinsic::nvvm_sust_b_2d_array_v2i16_zero, 83762}, // __nvvm_sust_b_2d_array_v2i16_zero
-      {Intrinsic::nvvm_sust_b_2d_array_v2i32_clamp, 83796}, // __nvvm_sust_b_2d_array_v2i32_clamp
-      {Intrinsic::nvvm_sust_b_2d_array_v2i32_trap, 83831}, // __nvvm_sust_b_2d_array_v2i32_trap
-      {Intrinsic::nvvm_sust_b_2d_array_v2i32_zero, 83865}, // __nvvm_sust_b_2d_array_v2i32_zero
-      {Intrinsic::nvvm_sust_b_2d_array_v2i64_clamp, 83899}, // __nvvm_sust_b_2d_array_v2i64_clamp
-      {Intrinsic::nvvm_sust_b_2d_array_v2i64_trap, 83934}, // __nvvm_sust_b_2d_array_v2i64_trap
-      {Intrinsic::nvvm_sust_b_2d_array_v2i64_zero, 83968}, // __nvvm_sust_b_2d_array_v2i64_zero
-      {Intrinsic::nvvm_sust_b_2d_array_v2i8_clamp, 84002}, // __nvvm_sust_b_2d_array_v2i8_clamp
-      {Intrinsic::nvvm_sust_b_2d_array_v2i8_trap, 84036}, // __nvvm_sust_b_2d_array_v2i8_trap
-      {Intrinsic::nvvm_sust_b_2d_array_v2i8_zero, 84069}, // __nvvm_sust_b_2d_array_v2i8_zero
-      {Intrinsic::nvvm_sust_b_2d_array_v4i16_clamp, 84102}, // __nvvm_sust_b_2d_array_v4i16_clamp
-      {Intrinsic::nvvm_sust_b_2d_array_v4i16_trap, 84137}, // __nvvm_sust_b_2d_array_v4i16_trap
-      {Intrinsic::nvvm_sust_b_2d_array_v4i16_zero, 84171}, // __nvvm_sust_b_2d_array_v4i16_zero
-      {Intrinsic::nvvm_sust_b_2d_array_v4i32_clamp, 84205}, // __nvvm_sust_b_2d_array_v4i32_clamp
-      {Intrinsic::nvvm_sust_b_2d_array_v4i32_trap, 84240}, // __nvvm_sust_b_2d_array_v4i32_trap
-      {Intrinsic::nvvm_sust_b_2d_array_v4i32_zero, 84274}, // __nvvm_sust_b_2d_array_v4i32_zero
-      {Intrinsic::nvvm_sust_b_2d_array_v4i8_clamp, 84308}, // __nvvm_sust_b_2d_array_v4i8_clamp
-      {Intrinsic::nvvm_sust_b_2d_array_v4i8_trap, 84342}, // __nvvm_sust_b_2d_array_v4i8_trap
-      {Intrinsic::nvvm_sust_b_2d_array_v4i8_zero, 84375}, // __nvvm_sust_b_2d_array_v4i8_zero
-      {Intrinsic::nvvm_sust_b_2d_i16_clamp, 84408}, // __nvvm_sust_b_2d_i16_clamp
-      {Intrinsic::nvvm_sust_b_2d_i16_trap, 84435}, // __nvvm_sust_b_2d_i16_trap
-      {Intrinsic::nvvm_sust_b_2d_i16_zero, 84461}, // __nvvm_sust_b_2d_i16_zero
-      {Intrinsic::nvvm_sust_b_2d_i32_clamp, 84487}, // __nvvm_sust_b_2d_i32_clamp
-      {Intrinsic::nvvm_sust_b_2d_i32_trap, 84514}, // __nvvm_sust_b_2d_i32_trap
-      {Intrinsic::nvvm_sust_b_2d_i32_zero, 84540}, // __nvvm_sust_b_2d_i32_zero
-      {Intrinsic::nvvm_sust_b_2d_i64_clamp, 84566}, // __nvvm_sust_b_2d_i64_clamp
-      {Intrinsic::nvvm_sust_b_2d_i64_trap, 84593}, // __nvvm_sust_b_2d_i64_trap
-      {Intrinsic::nvvm_sust_b_2d_i64_zero, 84619}, // __nvvm_sust_b_2d_i64_zero
-      {Intrinsic::nvvm_sust_b_2d_i8_clamp, 84645}, // __nvvm_sust_b_2d_i8_clamp
-      {Intrinsic::nvvm_sust_b_2d_i8_trap, 84671}, // __nvvm_sust_b_2d_i8_trap
-      {Intrinsic::nvvm_sust_b_2d_i8_zero, 84696}, // __nvvm_sust_b_2d_i8_zero
-      {Intrinsic::nvvm_sust_b_2d_v2i16_clamp, 84721}, // __nvvm_sust_b_2d_v2i16_clamp
-      {Intrinsic::nvvm_sust_b_2d_v2i16_trap, 84750}, // __nvvm_sust_b_2d_v2i16_trap
-      {Intrinsic::nvvm_sust_b_2d_v2i16_zero, 84778}, // __nvvm_sust_b_2d_v2i16_zero
-      {Intrinsic::nvvm_sust_b_2d_v2i32_clamp, 84806}, // __nvvm_sust_b_2d_v2i32_clamp
-      {Intrinsic::nvvm_sust_b_2d_v2i32_trap, 84835}, // __nvvm_sust_b_2d_v2i32_trap
-      {Intrinsic::nvvm_sust_b_2d_v2i32_zero, 84863}, // __nvvm_sust_b_2d_v2i32_zero
-      {Intrinsic::nvvm_sust_b_2d_v2i64_clamp, 84891}, // __nvvm_sust_b_2d_v2i64_clamp
-      {Intrinsic::nvvm_sust_b_2d_v2i64_trap, 84920}, // __nvvm_sust_b_2d_v2i64_trap
-      {Intrinsic::nvvm_sust_b_2d_v2i64_zero, 84948}, // __nvvm_sust_b_2d_v2i64_zero
-      {Intrinsic::nvvm_sust_b_2d_v2i8_clamp, 84976}, // __nvvm_sust_b_2d_v2i8_clamp
-      {Intrinsic::nvvm_sust_b_2d_v2i8_trap, 85004}, // __nvvm_sust_b_2d_v2i8_trap
-      {Intrinsic::nvvm_sust_b_2d_v2i8_zero, 85031}, // __nvvm_sust_b_2d_v2i8_zero
-      {Intrinsic::nvvm_sust_b_2d_v4i16_clamp, 85058}, // __nvvm_sust_b_2d_v4i16_clamp
-      {Intrinsic::nvvm_sust_b_2d_v4i16_trap, 85087}, // __nvvm_sust_b_2d_v4i16_trap
-      {Intrinsic::nvvm_sust_b_2d_v4i16_zero, 85115}, // __nvvm_sust_b_2d_v4i16_zero
-      {Intrinsic::nvvm_sust_b_2d_v4i32_clamp, 85143}, // __nvvm_sust_b_2d_v4i32_clamp
-      {Intrinsic::nvvm_sust_b_2d_v4i32_trap, 85172}, // __nvvm_sust_b_2d_v4i32_trap
-      {Intrinsic::nvvm_sust_b_2d_v4i32_zero, 85200}, // __nvvm_sust_b_2d_v4i32_zero
-      {Intrinsic::nvvm_sust_b_2d_v4i8_clamp, 85228}, // __nvvm_sust_b_2d_v4i8_clamp
-      {Intrinsic::nvvm_sust_b_2d_v4i8_trap, 85256}, // __nvvm_sust_b_2d_v4i8_trap
-      {Intrinsic::nvvm_sust_b_2d_v4i8_zero, 85283}, // __nvvm_sust_b_2d_v4i8_zero
-      {Intrinsic::nvvm_sust_b_3d_i16_clamp, 85310}, // __nvvm_sust_b_3d_i16_clamp
-      {Intrinsic::nvvm_sust_b_3d_i16_trap, 85337}, // __nvvm_sust_b_3d_i16_trap
-      {Intrinsic::nvvm_sust_b_3d_i16_zero, 85363}, // __nvvm_sust_b_3d_i16_zero
-      {Intrinsic::nvvm_sust_b_3d_i32_clamp, 85389}, // __nvvm_sust_b_3d_i32_clamp
-      {Intrinsic::nvvm_sust_b_3d_i32_trap, 85416}, // __nvvm_sust_b_3d_i32_trap
-      {Intrinsic::nvvm_sust_b_3d_i32_zero, 85442}, // __nvvm_sust_b_3d_i32_zero
-      {Intrinsic::nvvm_sust_b_3d_i64_clamp, 85468}, // __nvvm_sust_b_3d_i64_clamp
-      {Intrinsic::nvvm_sust_b_3d_i64_trap, 85495}, // __nvvm_sust_b_3d_i64_trap
-      {Intrinsic::nvvm_sust_b_3d_i64_zero, 85521}, // __nvvm_sust_b_3d_i64_zero
-      {Intrinsic::nvvm_sust_b_3d_i8_clamp, 85547}, // __nvvm_sust_b_3d_i8_clamp
-      {Intrinsic::nvvm_sust_b_3d_i8_trap, 85573}, // __nvvm_sust_b_3d_i8_trap
-      {Intrinsic::nvvm_sust_b_3d_i8_zero, 85598}, // __nvvm_sust_b_3d_i8_zero
-      {Intrinsic::nvvm_sust_b_3d_v2i16_clamp, 85623}, // __nvvm_sust_b_3d_v2i16_clamp
-      {Intrinsic::nvvm_sust_b_3d_v2i16_trap, 85652}, // __nvvm_sust_b_3d_v2i16_trap
-      {Intrinsic::nvvm_sust_b_3d_v2i16_zero, 85680}, // __nvvm_sust_b_3d_v2i16_zero
-      {Intrinsic::nvvm_sust_b_3d_v2i32_clamp, 85708}, // __nvvm_sust_b_3d_v2i32_clamp
-      {Intrinsic::nvvm_sust_b_3d_v2i32_trap, 85737}, // __nvvm_sust_b_3d_v2i32_trap
-      {Intrinsic::nvvm_sust_b_3d_v2i32_zero, 85765}, // __nvvm_sust_b_3d_v2i32_zero
-      {Intrinsic::nvvm_sust_b_3d_v2i64_clamp, 85793}, // __nvvm_sust_b_3d_v2i64_clamp
-      {Intrinsic::nvvm_sust_b_3d_v2i64_trap, 85822}, // __nvvm_sust_b_3d_v2i64_trap
-      {Intrinsic::nvvm_sust_b_3d_v2i64_zero, 85850}, // __nvvm_sust_b_3d_v2i64_zero
-      {Intrinsic::nvvm_sust_b_3d_v2i8_clamp, 85878}, // __nvvm_sust_b_3d_v2i8_clamp
-      {Intrinsic::nvvm_sust_b_3d_v2i8_trap, 85906}, // __nvvm_sust_b_3d_v2i8_trap
-      {Intrinsic::nvvm_sust_b_3d_v2i8_zero, 85933}, // __nvvm_sust_b_3d_v2i8_zero
-      {Intrinsic::nvvm_sust_b_3d_v4i16_clamp, 85960}, // __nvvm_sust_b_3d_v4i16_clamp
-      {Intrinsic::nvvm_sust_b_3d_v4i16_trap, 85989}, // __nvvm_sust_b_3d_v4i16_trap
-      {Intrinsic::nvvm_sust_b_3d_v4i16_zero, 86017}, // __nvvm_sust_b_3d_v4i16_zero
-      {Intrinsic::nvvm_sust_b_3d_v4i32_clamp, 86045}, // __nvvm_sust_b_3d_v4i32_clamp
-      {Intrinsic::nvvm_sust_b_3d_v4i32_trap, 86074}, // __nvvm_sust_b_3d_v4i32_trap
-      {Intrinsic::nvvm_sust_b_3d_v4i32_zero, 86102}, // __nvvm_sust_b_3d_v4i32_zero
-      {Intrinsic::nvvm_sust_b_3d_v4i8_clamp, 86130}, // __nvvm_sust_b_3d_v4i8_clamp
-      {Intrinsic::nvvm_sust_b_3d_v4i8_trap, 86158}, // __nvvm_sust_b_3d_v4i8_trap
-      {Intrinsic::nvvm_sust_b_3d_v4i8_zero, 86185}, // __nvvm_sust_b_3d_v4i8_zero
-      {Intrinsic::nvvm_sust_p_1d_array_i16_trap, 86212}, // __nvvm_sust_p_1d_array_i16_trap
-      {Intrinsic::nvvm_sust_p_1d_array_i32_trap, 86244}, // __nvvm_sust_p_1d_array_i32_trap
-      {Intrinsic::nvvm_sust_p_1d_array_i8_trap, 86276}, // __nvvm_sust_p_1d_array_i8_trap
-      {Intrinsic::nvvm_sust_p_1d_array_v2i16_trap, 86307}, // __nvvm_sust_p_1d_array_v2i16_trap
-      {Intrinsic::nvvm_sust_p_1d_array_v2i32_trap, 86341}, // __nvvm_sust_p_1d_array_v2i32_trap
-      {Intrinsic::nvvm_sust_p_1d_array_v2i8_trap, 86375}, // __nvvm_sust_p_1d_array_v2i8_trap
-      {Intrinsic::nvvm_sust_p_1d_array_v4i16_trap, 86408}, // __nvvm_sust_p_1d_array_v4i16_trap
-      {Intrinsic::nvvm_sust_p_1d_array_v4i32_trap, 86442}, // __nvvm_sust_p_1d_array_v4i32_trap
-      {Intrinsic::nvvm_sust_p_1d_array_v4i8_trap, 86476}, // __nvvm_sust_p_1d_array_v4i8_trap
-      {Intrinsic::nvvm_sust_p_1d_i16_trap, 86509}, // __nvvm_sust_p_1d_i16_trap
-      {Intrinsic::nvvm_sust_p_1d_i32_trap, 86535}, // __nvvm_sust_p_1d_i32_trap
-      {Intrinsic::nvvm_sust_p_1d_i8_trap, 86561}, // __nvvm_sust_p_1d_i8_trap
-      {Intrinsic::nvvm_sust_p_1d_v2i16_trap, 86586}, // __nvvm_sust_p_1d_v2i16_trap
-      {Intrinsic::nvvm_sust_p_1d_v2i32_trap, 86614}, // __nvvm_sust_p_1d_v2i32_trap
-      {Intrinsic::nvvm_sust_p_1d_v2i8_trap, 86642}, // __nvvm_sust_p_1d_v2i8_trap
-      {Intrinsic::nvvm_sust_p_1d_v4i16_trap, 86669}, // __nvvm_sust_p_1d_v4i16_trap
-      {Intrinsic::nvvm_sust_p_1d_v4i32_trap, 86697}, // __nvvm_sust_p_1d_v4i32_trap
-      {Intrinsic::nvvm_sust_p_1d_v4i8_trap, 86725}, // __nvvm_sust_p_1d_v4i8_trap
-      {Intrinsic::nvvm_sust_p_2d_array_i16_trap, 86752}, // __nvvm_sust_p_2d_array_i16_trap
-      {Intrinsic::nvvm_sust_p_2d_array_i32_trap, 86784}, // __nvvm_sust_p_2d_array_i32_trap
-      {Intrinsic::nvvm_sust_p_2d_array_i8_trap, 86816}, // __nvvm_sust_p_2d_array_i8_trap
-      {Intrinsic::nvvm_sust_p_2d_array_v2i16_trap, 86847}, // __nvvm_sust_p_2d_array_v2i16_trap
-      {Intrinsic::nvvm_sust_p_2d_array_v2i32_trap, 86881}, // __nvvm_sust_p_2d_array_v2i32_trap
-      {Intrinsic::nvvm_sust_p_2d_array_v2i8_trap, 86915}, // __nvvm_sust_p_2d_array_v2i8_trap
-      {Intrinsic::nvvm_sust_p_2d_array_v4i16_trap, 86948}, // __nvvm_sust_p_2d_array_v4i16_trap
-      {Intrinsic::nvvm_sust_p_2d_array_v4i32_trap, 86982}, // __nvvm_sust_p_2d_array_v4i32_trap
-      {Intrinsic::nvvm_sust_p_2d_array_v4i8_trap, 87016}, // __nvvm_sust_p_2d_array_v4i8_trap
-      {Intrinsic::nvvm_sust_p_2d_i16_trap, 87049}, // __nvvm_sust_p_2d_i16_trap
-      {Intrinsic::nvvm_sust_p_2d_i32_trap, 87075}, // __nvvm_sust_p_2d_i32_trap
-      {Intrinsic::nvvm_sust_p_2d_i8_trap, 87101}, // __nvvm_sust_p_2d_i8_trap
-      {Intrinsic::nvvm_sust_p_2d_v2i16_trap, 87126}, // __nvvm_sust_p_2d_v2i16_trap
-      {Intrinsic::nvvm_sust_p_2d_v2i32_trap, 87154}, // __nvvm_sust_p_2d_v2i32_trap
-      {Intrinsic::nvvm_sust_p_2d_v2i8_trap, 87182}, // __nvvm_sust_p_2d_v2i8_trap
-      {Intrinsic::nvvm_sust_p_2d_v4i16_trap, 87209}, // __nvvm_sust_p_2d_v4i16_trap
-      {Intrinsic::nvvm_sust_p_2d_v4i32_trap, 87237}, // __nvvm_sust_p_2d_v4i32_trap
-      {Intrinsic::nvvm_sust_p_2d_v4i8_trap, 87265}, // __nvvm_sust_p_2d_v4i8_trap
-      {Intrinsic::nvvm_sust_p_3d_i16_trap, 87292}, // __nvvm_sust_p_3d_i16_trap
-      {Intrinsic::nvvm_sust_p_3d_i32_trap, 87318}, // __nvvm_sust_p_3d_i32_trap
-      {Intrinsic::nvvm_sust_p_3d_i8_trap, 87344}, // __nvvm_sust_p_3d_i8_trap
-      {Intrinsic::nvvm_sust_p_3d_v2i16_trap, 87369}, // __nvvm_sust_p_3d_v2i16_trap
-      {Intrinsic::nvvm_sust_p_3d_v2i32_trap, 87397}, // __nvvm_sust_p_3d_v2i32_trap
-      {Intrinsic::nvvm_sust_p_3d_v2i8_trap, 87425}, // __nvvm_sust_p_3d_v2i8_trap
-      {Intrinsic::nvvm_sust_p_3d_v4i16_trap, 87452}, // __nvvm_sust_p_3d_v4i16_trap
-      {Intrinsic::nvvm_sust_p_3d_v4i32_trap, 87480}, // __nvvm_sust_p_3d_v4i32_trap
-      {Intrinsic::nvvm_sust_p_3d_v4i8_trap, 87508}, // __nvvm_sust_p_3d_v4i8_trap
-      {Intrinsic::nvvm_swap_lo_hi_b64, 87535}, // __nvvm_swap_lo_hi_b64
-      {Intrinsic::nvvm_trunc_d, 87557}, // __nvvm_trunc_d
-      {Intrinsic::nvvm_trunc_f, 87572}, // __nvvm_trunc_f
-      {Intrinsic::nvvm_trunc_ftz_f, 87587}, // __nvvm_trunc_ftz_f
-      {Intrinsic::nvvm_txq_array_size, 87606}, // __nvvm_txq_array_size
-      {Intrinsic::nvvm_txq_channel_data_type, 87628}, // __nvvm_txq_channel_data_type
-      {Intrinsic::nvvm_txq_channel_order, 87657}, // __nvvm_txq_channel_order
-      {Intrinsic::nvvm_txq_depth, 87682}, // __nvvm_txq_depth
-      {Intrinsic::nvvm_txq_height, 87699}, // __nvvm_txq_height
-      {Intrinsic::nvvm_txq_num_mipmap_levels, 87717}, // __nvvm_txq_num_mipmap_levels
-      {Intrinsic::nvvm_txq_num_samples, 87746}, // __nvvm_txq_num_samples
-      {Intrinsic::nvvm_txq_width, 87769}, // __nvvm_txq_width
-      {Intrinsic::nvvm_ui2d_rm, 87786}, // __nvvm_ui2d_rm
-      {Intrinsic::nvvm_ui2d_rn, 87801}, // __nvvm_ui2d_rn
-      {Intrinsic::nvvm_ui2d_rp, 87816}, // __nvvm_ui2d_rp
-      {Intrinsic::nvvm_ui2d_rz, 87831}, // __nvvm_ui2d_rz
-      {Intrinsic::nvvm_ui2f_rm, 87846}, // __nvvm_ui2f_rm
-      {Intrinsic::nvvm_ui2f_rn, 87861}, // __nvvm_ui2f_rn
-      {Intrinsic::nvvm_ui2f_rp, 87876}, // __nvvm_ui2f_rp
-      {Intrinsic::nvvm_ui2f_rz, 87891}, // __nvvm_ui2f_rz
-      {Intrinsic::nvvm_ull2d_rm, 87906}, // __nvvm_ull2d_rm
-      {Intrinsic::nvvm_ull2d_rn, 87922}, // __nvvm_ull2d_rn
-      {Intrinsic::nvvm_ull2d_rp, 87938}, // __nvvm_ull2d_rp
-      {Intrinsic::nvvm_ull2d_rz, 87954}, // __nvvm_ull2d_rz
-      {Intrinsic::nvvm_ull2f_rm, 87970}, // __nvvm_ull2f_rm
-      {Intrinsic::nvvm_ull2f_rn, 87986}, // __nvvm_ull2f_rn
-      {Intrinsic::nvvm_ull2f_rp, 88002}, // __nvvm_ull2f_rp
-      {Intrinsic::nvvm_ull2f_rz, 88018}, // __nvvm_ull2f_rz
-      {Intrinsic::nvvm_vote_all, 88034}, // __nvvm_vote_all
-      {Intrinsic::nvvm_vote_all_sync, 88050}, // __nvvm_vote_all_sync
-      {Intrinsic::nvvm_vote_any, 88071}, // __nvvm_vote_any
-      {Intrinsic::nvvm_vote_any_sync, 88087}, // __nvvm_vote_any_sync
-      {Intrinsic::nvvm_vote_ballot, 88108}, // __nvvm_vote_ballot
-      {Intrinsic::nvvm_vote_ballot_sync, 88127}, // __nvvm_vote_ballot_sync
-      {Intrinsic::nvvm_vote_uni, 88151}, // __nvvm_vote_uni
-      {Intrinsic::nvvm_vote_uni_sync, 88167}, // __nvvm_vote_uni_sync
-      {Intrinsic::nvvm_barrier0, 75256}, // __syncthreads
+      {Intrinsic::nvvm_add_rm_d, 70263}, // __nvvm_add_rm_d
+      {Intrinsic::nvvm_add_rm_f, 70279}, // __nvvm_add_rm_f
+      {Intrinsic::nvvm_add_rm_ftz_f, 70295}, // __nvvm_add_rm_ftz_f
+      {Intrinsic::nvvm_add_rn_d, 70315}, // __nvvm_add_rn_d
+      {Intrinsic::nvvm_add_rn_f, 70331}, // __nvvm_add_rn_f
+      {Intrinsic::nvvm_add_rn_ftz_f, 70347}, // __nvvm_add_rn_ftz_f
+      {Intrinsic::nvvm_add_rp_d, 70367}, // __nvvm_add_rp_d
+      {Intrinsic::nvvm_add_rp_f, 70383}, // __nvvm_add_rp_f
+      {Intrinsic::nvvm_add_rp_ftz_f, 70399}, // __nvvm_add_rp_ftz_f
+      {Intrinsic::nvvm_add_rz_d, 70419}, // __nvvm_add_rz_d
+      {Intrinsic::nvvm_add_rz_f, 70435}, // __nvvm_add_rz_f
+      {Intrinsic::nvvm_add_rz_ftz_f, 70451}, // __nvvm_add_rz_ftz_f
+      {Intrinsic::nvvm_barrier, 70508}, // __nvvm_bar
+      {Intrinsic::nvvm_barrier0_and, 70590}, // __nvvm_bar0_and
+      {Intrinsic::nvvm_barrier0_or, 70606}, // __nvvm_bar0_or
+      {Intrinsic::nvvm_barrier0_popc, 70621}, // __nvvm_bar0_popc
+      {Intrinsic::nvvm_barrier_n, 70519}, // __nvvm_bar_n
+      {Intrinsic::nvvm_bar_sync, 70471}, // __nvvm_bar_sync
+      {Intrinsic::nvvm_bar_warp_sync, 70487}, // __nvvm_bar_warp_sync
+      {Intrinsic::nvvm_barrier_sync, 70532}, // __nvvm_barrier_sync
+      {Intrinsic::nvvm_barrier_sync_cnt, 70552}, // __nvvm_barrier_sync_cnt
+      {Intrinsic::nvvm_bitcast_d2ll, 70638}, // __nvvm_bitcast_d2ll
+      {Intrinsic::nvvm_bitcast_f2i, 70658}, // __nvvm_bitcast_f2i
+      {Intrinsic::nvvm_bitcast_i2f, 70677}, // __nvvm_bitcast_i2f
+      {Intrinsic::nvvm_bitcast_ll2d, 70696}, // __nvvm_bitcast_ll2d
+      {Intrinsic::nvvm_ceil_d, 70716}, // __nvvm_ceil_d
+      {Intrinsic::nvvm_ceil_f, 70730}, // __nvvm_ceil_f
+      {Intrinsic::nvvm_ceil_ftz_f, 70744}, // __nvvm_ceil_ftz_f
+      {Intrinsic::nvvm_cos_approx_f, 70762}, // __nvvm_cos_approx_f
+      {Intrinsic::nvvm_cos_approx_ftz_f, 70782}, // __nvvm_cos_approx_ftz_f
+      {Intrinsic::nvvm_d2f_rm, 70806}, // __nvvm_d2f_rm
+      {Intrinsic::nvvm_d2f_rm_ftz, 70820}, // __nvvm_d2f_rm_ftz
+      {Intrinsic::nvvm_d2f_rn, 70838}, // __nvvm_d2f_rn
+      {Intrinsic::nvvm_d2f_rn_ftz, 70852}, // __nvvm_d2f_rn_ftz
+      {Intrinsic::nvvm_d2f_rp, 70870}, // __nvvm_d2f_rp
+      {Intrinsic::nvvm_d2f_rp_ftz, 70884}, // __nvvm_d2f_rp_ftz
+      {Intrinsic::nvvm_d2f_rz, 70902}, // __nvvm_d2f_rz
+      {Intrinsic::nvvm_d2f_rz_ftz, 70916}, // __nvvm_d2f_rz_ftz
+      {Intrinsic::nvvm_d2i_hi, 70934}, // __nvvm_d2i_hi
+      {Intrinsic::nvvm_d2i_lo, 70948}, // __nvvm_d2i_lo
+      {Intrinsic::nvvm_d2i_rm, 70962}, // __nvvm_d2i_rm
+      {Intrinsic::nvvm_d2i_rn, 70976}, // __nvvm_d2i_rn
+      {Intrinsic::nvvm_d2i_rp, 70990}, // __nvvm_d2i_rp
+      {Intrinsic::nvvm_d2i_rz, 71004}, // __nvvm_d2i_rz
+      {Intrinsic::nvvm_d2ll_rm, 71018}, // __nvvm_d2ll_rm
+      {Intrinsic::nvvm_d2ll_rn, 71033}, // __nvvm_d2ll_rn
+      {Intrinsic::nvvm_d2ll_rp, 71048}, // __nvvm_d2ll_rp
+      {Intrinsic::nvvm_d2ll_rz, 71063}, // __nvvm_d2ll_rz
+      {Intrinsic::nvvm_d2ui_rm, 71078}, // __nvvm_d2ui_rm
+      {Intrinsic::nvvm_d2ui_rn, 71093}, // __nvvm_d2ui_rn
+      {Intrinsic::nvvm_d2ui_rp, 71108}, // __nvvm_d2ui_rp
+      {Intrinsic::nvvm_d2ui_rz, 71123}, // __nvvm_d2ui_rz
+      {Intrinsic::nvvm_d2ull_rm, 71138}, // __nvvm_d2ull_rm
+      {Intrinsic::nvvm_d2ull_rn, 71154}, // __nvvm_d2ull_rn
+      {Intrinsic::nvvm_d2ull_rp, 71170}, // __nvvm_d2ull_rp
+      {Intrinsic::nvvm_d2ull_rz, 71186}, // __nvvm_d2ull_rz
+      {Intrinsic::nvvm_div_approx_f, 71202}, // __nvvm_div_approx_f
+      {Intrinsic::nvvm_div_approx_ftz_f, 71222}, // __nvvm_div_approx_ftz_f
+      {Intrinsic::nvvm_div_rm_d, 71246}, // __nvvm_div_rm_d
+      {Intrinsic::nvvm_div_rm_f, 71262}, // __nvvm_div_rm_f
+      {Intrinsic::nvvm_div_rm_ftz_f, 71278}, // __nvvm_div_rm_ftz_f
+      {Intrinsic::nvvm_div_rn_d, 71298}, // __nvvm_div_rn_d
+      {Intrinsic::nvvm_div_rn_f, 71314}, // __nvvm_div_rn_f
+      {Intrinsic::nvvm_div_rn_ftz_f, 71330}, // __nvvm_div_rn_ftz_f
+      {Intrinsic::nvvm_div_rp_d, 71350}, // __nvvm_div_rp_d
+      {Intrinsic::nvvm_div_rp_f, 71366}, // __nvvm_div_rp_f
+      {Intrinsic::nvvm_div_rp_ftz_f, 71382}, // __nvvm_div_rp_ftz_f
+      {Intrinsic::nvvm_div_rz_d, 71402}, // __nvvm_div_rz_d
+      {Intrinsic::nvvm_div_rz_f, 71418}, // __nvvm_div_rz_f
+      {Intrinsic::nvvm_div_rz_ftz_f, 71434}, // __nvvm_div_rz_ftz_f
+      {Intrinsic::nvvm_ex2_approx_d, 71454}, // __nvvm_ex2_approx_d
+      {Intrinsic::nvvm_ex2_approx_f, 71474}, // __nvvm_ex2_approx_f
+      {Intrinsic::nvvm_ex2_approx_ftz_f, 71494}, // __nvvm_ex2_approx_ftz_f
+      {Intrinsic::nvvm_f2h_rn, 71518}, // __nvvm_f2h_rn
+      {Intrinsic::nvvm_f2h_rn_ftz, 71532}, // __nvvm_f2h_rn_ftz
+      {Intrinsic::nvvm_f2i_rm, 71550}, // __nvvm_f2i_rm
+      {Intrinsic::nvvm_f2i_rm_ftz, 71564}, // __nvvm_f2i_rm_ftz
+      {Intrinsic::nvvm_f2i_rn, 71582}, // __nvvm_f2i_rn
+      {Intrinsic::nvvm_f2i_rn_ftz, 71596}, // __nvvm_f2i_rn_ftz
+      {Intrinsic::nvvm_f2i_rp, 71614}, // __nvvm_f2i_rp
+      {Intrinsic::nvvm_f2i_rp_ftz, 71628}, // __nvvm_f2i_rp_ftz
+      {Intrinsic::nvvm_f2i_rz, 71646}, // __nvvm_f2i_rz
+      {Intrinsic::nvvm_f2i_rz_ftz, 71660}, // __nvvm_f2i_rz_ftz
+      {Intrinsic::nvvm_f2ll_rm, 71678}, // __nvvm_f2ll_rm
+      {Intrinsic::nvvm_f2ll_rm_ftz, 71693}, // __nvvm_f2ll_rm_ftz
+      {Intrinsic::nvvm_f2ll_rn, 71712}, // __nvvm_f2ll_rn
+      {Intrinsic::nvvm_f2ll_rn_ftz, 71727}, // __nvvm_f2ll_rn_ftz
+      {Intrinsic::nvvm_f2ll_rp, 71746}, // __nvvm_f2ll_rp
+      {Intrinsic::nvvm_f2ll_rp_ftz, 71761}, // __nvvm_f2ll_rp_ftz
+      {Intrinsic::nvvm_f2ll_rz, 71780}, // __nvvm_f2ll_rz
+      {Intrinsic::nvvm_f2ll_rz_ftz, 71795}, // __nvvm_f2ll_rz_ftz
+      {Intrinsic::nvvm_f2ui_rm, 71814}, // __nvvm_f2ui_rm
+      {Intrinsic::nvvm_f2ui_rm_ftz, 71829}, // __nvvm_f2ui_rm_ftz
+      {Intrinsic::nvvm_f2ui_rn, 71848}, // __nvvm_f2ui_rn
+      {Intrinsic::nvvm_f2ui_rn_ftz, 71863}, // __nvvm_f2ui_rn_ftz
+      {Intrinsic::nvvm_f2ui_rp, 71882}, // __nvvm_f2ui_rp
+      {Intrinsic::nvvm_f2ui_rp_ftz, 71897}, // __nvvm_f2ui_rp_ftz
+      {Intrinsic::nvvm_f2ui_rz, 71916}, // __nvvm_f2ui_rz
+      {Intrinsic::nvvm_f2ui_rz_ftz, 71931}, // __nvvm_f2ui_rz_ftz
+      {Intrinsic::nvvm_f2ull_rm, 71950}, // __nvvm_f2ull_rm
+      {Intrinsic::nvvm_f2ull_rm_ftz, 71966}, // __nvvm_f2ull_rm_ftz
+      {Intrinsic::nvvm_f2ull_rn, 71986}, // __nvvm_f2ull_rn
+      {Intrinsic::nvvm_f2ull_rn_ftz, 72002}, // __nvvm_f2ull_rn_ftz
+      {Intrinsic::nvvm_f2ull_rp, 72022}, // __nvvm_f2ull_rp
+      {Intrinsic::nvvm_f2ull_rp_ftz, 72038}, // __nvvm_f2ull_rp_ftz
+      {Intrinsic::nvvm_f2ull_rz, 72058}, // __nvvm_f2ull_rz
+      {Intrinsic::nvvm_f2ull_rz_ftz, 72074}, // __nvvm_f2ull_rz_ftz
+      {Intrinsic::nvvm_fabs_d, 72094}, // __nvvm_fabs_d
+      {Intrinsic::nvvm_fabs_f, 72108}, // __nvvm_fabs_f
+      {Intrinsic::nvvm_fabs_ftz_f, 72122}, // __nvvm_fabs_ftz_f
+      {Intrinsic::nvvm_floor_d, 72140}, // __nvvm_floor_d
+      {Intrinsic::nvvm_floor_f, 72155}, // __nvvm_floor_f
+      {Intrinsic::nvvm_floor_ftz_f, 72170}, // __nvvm_floor_ftz_f
+      {Intrinsic::nvvm_fma_rm_d, 72189}, // __nvvm_fma_rm_d
+      {Intrinsic::nvvm_fma_rm_f, 72205}, // __nvvm_fma_rm_f
+      {Intrinsic::nvvm_fma_rm_ftz_f, 72221}, // __nvvm_fma_rm_ftz_f
+      {Intrinsic::nvvm_fma_rn_d, 72241}, // __nvvm_fma_rn_d
+      {Intrinsic::nvvm_fma_rn_f, 72257}, // __nvvm_fma_rn_f
+      {Intrinsic::nvvm_fma_rn_ftz_f, 72273}, // __nvvm_fma_rn_ftz_f
+      {Intrinsic::nvvm_fma_rp_d, 72293}, // __nvvm_fma_rp_d
+      {Intrinsic::nvvm_fma_rp_f, 72309}, // __nvvm_fma_rp_f
+      {Intrinsic::nvvm_fma_rp_ftz_f, 72325}, // __nvvm_fma_rp_ftz_f
+      {Intrinsic::nvvm_fma_rz_d, 72345}, // __nvvm_fma_rz_d
+      {Intrinsic::nvvm_fma_rz_f, 72361}, // __nvvm_fma_rz_f
+      {Intrinsic::nvvm_fma_rz_ftz_f, 72377}, // __nvvm_fma_rz_ftz_f
+      {Intrinsic::nvvm_fmax_d, 72397}, // __nvvm_fmax_d
+      {Intrinsic::nvvm_fmax_f, 72411}, // __nvvm_fmax_f
+      {Intrinsic::nvvm_fmax_ftz_f, 72425}, // __nvvm_fmax_ftz_f
+      {Intrinsic::nvvm_fmin_d, 72443}, // __nvvm_fmin_d
+      {Intrinsic::nvvm_fmin_f, 72457}, // __nvvm_fmin_f
+      {Intrinsic::nvvm_fmin_ftz_f, 72471}, // __nvvm_fmin_ftz_f
+      {Intrinsic::nvvm_fns, 72489}, // __nvvm_fns
+      {Intrinsic::nvvm_i2d_rm, 72500}, // __nvvm_i2d_rm
+      {Intrinsic::nvvm_i2d_rn, 72514}, // __nvvm_i2d_rn
+      {Intrinsic::nvvm_i2d_rp, 72528}, // __nvvm_i2d_rp
+      {Intrinsic::nvvm_i2d_rz, 72542}, // __nvvm_i2d_rz
+      {Intrinsic::nvvm_i2f_rm, 72556}, // __nvvm_i2f_rm
+      {Intrinsic::nvvm_i2f_rn, 72570}, // __nvvm_i2f_rn
+      {Intrinsic::nvvm_i2f_rp, 72584}, // __nvvm_i2f_rp
+      {Intrinsic::nvvm_i2f_rz, 72598}, // __nvvm_i2f_rz
+      {Intrinsic::nvvm_isspacep_const, 72612}, // __nvvm_isspacep_const
+      {Intrinsic::nvvm_isspacep_global, 72634}, // __nvvm_isspacep_global
+      {Intrinsic::nvvm_isspacep_local, 72657}, // __nvvm_isspacep_local
+      {Intrinsic::nvvm_isspacep_shared, 72679}, // __nvvm_isspacep_shared
+      {Intrinsic::nvvm_istypep_sampler, 72702}, // __nvvm_istypep_sampler
+      {Intrinsic::nvvm_istypep_surface, 72725}, // __nvvm_istypep_surface
+      {Intrinsic::nvvm_istypep_texture, 72748}, // __nvvm_istypep_texture
+      {Intrinsic::nvvm_lg2_approx_d, 72771}, // __nvvm_lg2_approx_d
+      {Intrinsic::nvvm_lg2_approx_f, 72791}, // __nvvm_lg2_approx_f
+      {Intrinsic::nvvm_lg2_approx_ftz_f, 72811}, // __nvvm_lg2_approx_ftz_f
+      {Intrinsic::nvvm_ll2d_rm, 72835}, // __nvvm_ll2d_rm
+      {Intrinsic::nvvm_ll2d_rn, 72850}, // __nvvm_ll2d_rn
+      {Intrinsic::nvvm_ll2d_rp, 72865}, // __nvvm_ll2d_rp
+      {Intrinsic::nvvm_ll2d_rz, 72880}, // __nvvm_ll2d_rz
+      {Intrinsic::nvvm_ll2f_rm, 72895}, // __nvvm_ll2f_rm
+      {Intrinsic::nvvm_ll2f_rn, 72910}, // __nvvm_ll2f_rn
+      {Intrinsic::nvvm_ll2f_rp, 72925}, // __nvvm_ll2f_rp
+      {Intrinsic::nvvm_ll2f_rz, 72940}, // __nvvm_ll2f_rz
+      {Intrinsic::nvvm_lohi_i2d, 72955}, // __nvvm_lohi_i2d
+      {Intrinsic::nvvm_match_any_sync_i32, 72971}, // __nvvm_match_any_sync_i32
+      {Intrinsic::nvvm_match_any_sync_i64, 72997}, // __nvvm_match_any_sync_i64
+      {Intrinsic::nvvm_membar_cta, 73023}, // __nvvm_membar_cta
+      {Intrinsic::nvvm_membar_gl, 73041}, // __nvvm_membar_gl
+      {Intrinsic::nvvm_membar_sys, 73058}, // __nvvm_membar_sys
+      {Intrinsic::nvvm_mul24_i, 73284}, // __nvvm_mul24_i
+      {Intrinsic::nvvm_mul24_ui, 73299}, // __nvvm_mul24_ui
+      {Intrinsic::nvvm_mul_rm_d, 73076}, // __nvvm_mul_rm_d
+      {Intrinsic::nvvm_mul_rm_f, 73092}, // __nvvm_mul_rm_f
+      {Intrinsic::nvvm_mul_rm_ftz_f, 73108}, // __nvvm_mul_rm_ftz_f
+      {Intrinsic::nvvm_mul_rn_d, 73128}, // __nvvm_mul_rn_d
+      {Intrinsic::nvvm_mul_rn_f, 73144}, // __nvvm_mul_rn_f
+      {Intrinsic::nvvm_mul_rn_ftz_f, 73160}, // __nvvm_mul_rn_ftz_f
+      {Intrinsic::nvvm_mul_rp_d, 73180}, // __nvvm_mul_rp_d
+      {Intrinsic::nvvm_mul_rp_f, 73196}, // __nvvm_mul_rp_f
+      {Intrinsic::nvvm_mul_rp_ftz_f, 73212}, // __nvvm_mul_rp_ftz_f
+      {Intrinsic::nvvm_mul_rz_d, 73232}, // __nvvm_mul_rz_d
+      {Intrinsic::nvvm_mul_rz_f, 73248}, // __nvvm_mul_rz_f
+      {Intrinsic::nvvm_mul_rz_ftz_f, 73264}, // __nvvm_mul_rz_ftz_f
+      {Intrinsic::nvvm_mulhi_i, 73315}, // __nvvm_mulhi_i
+      {Intrinsic::nvvm_mulhi_ll, 73330}, // __nvvm_mulhi_ll
+      {Intrinsic::nvvm_mulhi_ui, 73346}, // __nvvm_mulhi_ui
+      {Intrinsic::nvvm_mulhi_ull, 73362}, // __nvvm_mulhi_ull
+      {Intrinsic::nvvm_prmt, 73379}, // __nvvm_prmt
+      {Intrinsic::nvvm_rcp_approx_ftz_d, 73391}, // __nvvm_rcp_approx_ftz_d
+      {Intrinsic::nvvm_rcp_rm_d, 73415}, // __nvvm_rcp_rm_d
+      {Intrinsic::nvvm_rcp_rm_f, 73431}, // __nvvm_rcp_rm_f
+      {Intrinsic::nvvm_rcp_rm_ftz_f, 73447}, // __nvvm_rcp_rm_ftz_f
+      {Intrinsic::nvvm_rcp_rn_d, 73467}, // __nvvm_rcp_rn_d
+      {Intrinsic::nvvm_rcp_rn_f, 73483}, // __nvvm_rcp_rn_f
+      {Intrinsic::nvvm_rcp_rn_ftz_f, 73499}, // __nvvm_rcp_rn_ftz_f
+      {Intrinsic::nvvm_rcp_rp_d, 73519}, // __nvvm_rcp_rp_d
+      {Intrinsic::nvvm_rcp_rp_f, 73535}, // __nvvm_rcp_rp_f
+      {Intrinsic::nvvm_rcp_rp_ftz_f, 73551}, // __nvvm_rcp_rp_ftz_f
+      {Intrinsic::nvvm_rcp_rz_d, 73571}, // __nvvm_rcp_rz_d
+      {Intrinsic::nvvm_rcp_rz_f, 73587}, // __nvvm_rcp_rz_f
+      {Intrinsic::nvvm_rcp_rz_ftz_f, 73603}, // __nvvm_rcp_rz_ftz_f
+      {Intrinsic::nvvm_read_ptx_sreg_clock, 73623}, // __nvvm_read_ptx_sreg_clock
+      {Intrinsic::nvvm_read_ptx_sreg_clock64, 73650}, // __nvvm_read_ptx_sreg_clock64
+      {Intrinsic::nvvm_read_ptx_sreg_ctaid_w, 73679}, // __nvvm_read_ptx_sreg_ctaid_w
+      {Intrinsic::nvvm_read_ptx_sreg_ctaid_x, 73708}, // __nvvm_read_ptx_sreg_ctaid_x
+      {Intrinsic::nvvm_read_ptx_sreg_ctaid_y, 73737}, // __nvvm_read_ptx_sreg_ctaid_y
+      {Intrinsic::nvvm_read_ptx_sreg_ctaid_z, 73766}, // __nvvm_read_ptx_sreg_ctaid_z
+      {Intrinsic::nvvm_read_ptx_sreg_envreg0, 73795}, // __nvvm_read_ptx_sreg_envreg0
+      {Intrinsic::nvvm_read_ptx_sreg_envreg1, 73824}, // __nvvm_read_ptx_sreg_envreg1
+      {Intrinsic::nvvm_read_ptx_sreg_envreg10, 73853}, // __nvvm_read_ptx_sreg_envreg10
+      {Intrinsic::nvvm_read_ptx_sreg_envreg11, 73883}, // __nvvm_read_ptx_sreg_envreg11
+      {Intrinsic::nvvm_read_ptx_sreg_envreg12, 73913}, // __nvvm_read_ptx_sreg_envreg12
+      {Intrinsic::nvvm_read_ptx_sreg_envreg13, 73943}, // __nvvm_read_ptx_sreg_envreg13
+      {Intrinsic::nvvm_read_ptx_sreg_envreg14, 73973}, // __nvvm_read_ptx_sreg_envreg14
+      {Intrinsic::nvvm_read_ptx_sreg_envreg15, 74003}, // __nvvm_read_ptx_sreg_envreg15
+      {Intrinsic::nvvm_read_ptx_sreg_envreg16, 74033}, // __nvvm_read_ptx_sreg_envreg16
+      {Intrinsic::nvvm_read_ptx_sreg_envreg17, 74063}, // __nvvm_read_ptx_sreg_envreg17
+      {Intrinsic::nvvm_read_ptx_sreg_envreg18, 74093}, // __nvvm_read_ptx_sreg_envreg18
+      {Intrinsic::nvvm_read_ptx_sreg_envreg19, 74123}, // __nvvm_read_ptx_sreg_envreg19
+      {Intrinsic::nvvm_read_ptx_sreg_envreg2, 74153}, // __nvvm_read_ptx_sreg_envreg2
+      {Intrinsic::nvvm_read_ptx_sreg_envreg20, 74182}, // __nvvm_read_ptx_sreg_envreg20
+      {Intrinsic::nvvm_read_ptx_sreg_envreg21, 74212}, // __nvvm_read_ptx_sreg_envreg21
+      {Intrinsic::nvvm_read_ptx_sreg_envreg22, 74242}, // __nvvm_read_ptx_sreg_envreg22
+      {Intrinsic::nvvm_read_ptx_sreg_envreg23, 74272}, // __nvvm_read_ptx_sreg_envreg23
+      {Intrinsic::nvvm_read_ptx_sreg_envreg24, 74302}, // __nvvm_read_ptx_sreg_envreg24
+      {Intrinsic::nvvm_read_ptx_sreg_envreg25, 74332}, // __nvvm_read_ptx_sreg_envreg25
+      {Intrinsic::nvvm_read_ptx_sreg_envreg26, 74362}, // __nvvm_read_ptx_sreg_envreg26
+      {Intrinsic::nvvm_read_ptx_sreg_envreg27, 74392}, // __nvvm_read_ptx_sreg_envreg27
+      {Intrinsic::nvvm_read_ptx_sreg_envreg28, 74422}, // __nvvm_read_ptx_sreg_envreg28
+      {Intrinsic::nvvm_read_ptx_sreg_envreg29, 74452}, // __nvvm_read_ptx_sreg_envreg29
+      {Intrinsic::nvvm_read_ptx_sreg_envreg3, 74482}, // __nvvm_read_ptx_sreg_envreg3
+      {Intrinsic::nvvm_read_ptx_sreg_envreg30, 74511}, // __nvvm_read_ptx_sreg_envreg30
+      {Intrinsic::nvvm_read_ptx_sreg_envreg31, 74541}, // __nvvm_read_ptx_sreg_envreg31
+      {Intrinsic::nvvm_read_ptx_sreg_envreg4, 74571}, // __nvvm_read_ptx_sreg_envreg4
+      {Intrinsic::nvvm_read_ptx_sreg_envreg5, 74600}, // __nvvm_read_ptx_sreg_envreg5
+      {Intrinsic::nvvm_read_ptx_sreg_envreg6, 74629}, // __nvvm_read_ptx_sreg_envreg6
+      {Intrinsic::nvvm_read_ptx_sreg_envreg7, 74658}, // __nvvm_read_ptx_sreg_envreg7
+      {Intrinsic::nvvm_read_ptx_sreg_envreg8, 74687}, // __nvvm_read_ptx_sreg_envreg8
+      {Intrinsic::nvvm_read_ptx_sreg_envreg9, 74716}, // __nvvm_read_ptx_sreg_envreg9
+      {Intrinsic::nvvm_read_ptx_sreg_gridid, 74745}, // __nvvm_read_ptx_sreg_gridid
+      {Intrinsic::nvvm_read_ptx_sreg_laneid, 74773}, // __nvvm_read_ptx_sreg_laneid
+      {Intrinsic::nvvm_read_ptx_sreg_lanemask_eq, 74801}, // __nvvm_read_ptx_sreg_lanemask_eq
+      {Intrinsic::nvvm_read_ptx_sreg_lanemask_ge, 74834}, // __nvvm_read_ptx_sreg_lanemask_ge
+      {Intrinsic::nvvm_read_ptx_sreg_lanemask_gt, 74867}, // __nvvm_read_ptx_sreg_lanemask_gt
+      {Intrinsic::nvvm_read_ptx_sreg_lanemask_le, 74900}, // __nvvm_read_ptx_sreg_lanemask_le
+      {Intrinsic::nvvm_read_ptx_sreg_lanemask_lt, 74933}, // __nvvm_read_ptx_sreg_lanemask_lt
+      {Intrinsic::nvvm_read_ptx_sreg_nctaid_w, 74966}, // __nvvm_read_ptx_sreg_nctaid_w
+      {Intrinsic::nvvm_read_ptx_sreg_nctaid_x, 74996}, // __nvvm_read_ptx_sreg_nctaid_x
+      {Intrinsic::nvvm_read_ptx_sreg_nctaid_y, 75026}, // __nvvm_read_ptx_sreg_nctaid_y
+      {Intrinsic::nvvm_read_ptx_sreg_nctaid_z, 75056}, // __nvvm_read_ptx_sreg_nctaid_z
+      {Intrinsic::nvvm_read_ptx_sreg_nsmid, 75086}, // __nvvm_read_ptx_sreg_nsmid
+      {Intrinsic::nvvm_read_ptx_sreg_ntid_w, 75113}, // __nvvm_read_ptx_sreg_ntid_w
+      {Intrinsic::nvvm_read_ptx_sreg_ntid_x, 75141}, // __nvvm_read_ptx_sreg_ntid_x
+      {Intrinsic::nvvm_read_ptx_sreg_ntid_y, 75169}, // __nvvm_read_ptx_sreg_ntid_y
+      {Intrinsic::nvvm_read_ptx_sreg_ntid_z, 75197}, // __nvvm_read_ptx_sreg_ntid_z
+      {Intrinsic::nvvm_read_ptx_sreg_nwarpid, 75225}, // __nvvm_read_ptx_sreg_nwarpid
+      {Intrinsic::nvvm_read_ptx_sreg_pm0, 75254}, // __nvvm_read_ptx_sreg_pm0
+      {Intrinsic::nvvm_read_ptx_sreg_pm1, 75279}, // __nvvm_read_ptx_sreg_pm1
+      {Intrinsic::nvvm_read_ptx_sreg_pm2, 75304}, // __nvvm_read_ptx_sreg_pm2
+      {Intrinsic::nvvm_read_ptx_sreg_pm3, 75329}, // __nvvm_read_ptx_sreg_pm3
+      {Intrinsic::nvvm_read_ptx_sreg_smid, 75354}, // __nvvm_read_ptx_sreg_smid
+      {Intrinsic::nvvm_read_ptx_sreg_tid_w, 75380}, // __nvvm_read_ptx_sreg_tid_w
+      {Intrinsic::nvvm_read_ptx_sreg_tid_x, 75407}, // __nvvm_read_ptx_sreg_tid_x
+      {Intrinsic::nvvm_read_ptx_sreg_tid_y, 75434}, // __nvvm_read_ptx_sreg_tid_y
+      {Intrinsic::nvvm_read_ptx_sreg_tid_z, 75461}, // __nvvm_read_ptx_sreg_tid_z
+      {Intrinsic::nvvm_read_ptx_sreg_warpid, 75488}, // __nvvm_read_ptx_sreg_warpid
+      {Intrinsic::nvvm_read_ptx_sreg_warpsize, 75516}, // __nvvm_read_ptx_sreg_warpsize
+      {Intrinsic::nvvm_rotate_b32, 75546}, // __nvvm_rotate_b32
+      {Intrinsic::nvvm_rotate_b64, 75564}, // __nvvm_rotate_b64
+      {Intrinsic::nvvm_rotate_right_b64, 75582}, // __nvvm_rotate_right_b64
+      {Intrinsic::nvvm_round_d, 75606}, // __nvvm_round_d
+      {Intrinsic::nvvm_round_f, 75621}, // __nvvm_round_f
+      {Intrinsic::nvvm_round_ftz_f, 75636}, // __nvvm_round_ftz_f
+      {Intrinsic::nvvm_rsqrt_approx_d, 75655}, // __nvvm_rsqrt_approx_d
+      {Intrinsic::nvvm_rsqrt_approx_f, 75677}, // __nvvm_rsqrt_approx_f
+      {Intrinsic::nvvm_rsqrt_approx_ftz_f, 75699}, // __nvvm_rsqrt_approx_ftz_f
+      {Intrinsic::nvvm_sad_i, 75725}, // __nvvm_sad_i
+      {Intrinsic::nvvm_sad_ui, 75738}, // __nvvm_sad_ui
+      {Intrinsic::nvvm_saturate_d, 75752}, // __nvvm_saturate_d
+      {Intrinsic::nvvm_saturate_f, 75770}, // __nvvm_saturate_f
+      {Intrinsic::nvvm_saturate_ftz_f, 75788}, // __nvvm_saturate_ftz_f
+      {Intrinsic::nvvm_shfl_bfly_f32, 75810}, // __nvvm_shfl_bfly_f32
+      {Intrinsic::nvvm_shfl_bfly_i32, 75831}, // __nvvm_shfl_bfly_i32
+      {Intrinsic::nvvm_shfl_down_f32, 75852}, // __nvvm_shfl_down_f32
+      {Intrinsic::nvvm_shfl_down_i32, 75873}, // __nvvm_shfl_down_i32
+      {Intrinsic::nvvm_shfl_idx_f32, 75894}, // __nvvm_shfl_idx_f32
+      {Intrinsic::nvvm_shfl_idx_i32, 75914}, // __nvvm_shfl_idx_i32
+      {Intrinsic::nvvm_shfl_sync_bfly_f32, 75934}, // __nvvm_shfl_sync_bfly_f32
+      {Intrinsic::nvvm_shfl_sync_bfly_i32, 75960}, // __nvvm_shfl_sync_bfly_i32
+      {Intrinsic::nvvm_shfl_sync_down_f32, 75986}, // __nvvm_shfl_sync_down_f32
+      {Intrinsic::nvvm_shfl_sync_down_i32, 76012}, // __nvvm_shfl_sync_down_i32
+      {Intrinsic::nvvm_shfl_sync_idx_f32, 76038}, // __nvvm_shfl_sync_idx_f32
+      {Intrinsic::nvvm_shfl_sync_idx_i32, 76063}, // __nvvm_shfl_sync_idx_i32
+      {Intrinsic::nvvm_shfl_sync_up_f32, 76088}, // __nvvm_shfl_sync_up_f32
+      {Intrinsic::nvvm_shfl_sync_up_i32, 76112}, // __nvvm_shfl_sync_up_i32
+      {Intrinsic::nvvm_shfl_up_f32, 76136}, // __nvvm_shfl_up_f32
+      {Intrinsic::nvvm_shfl_up_i32, 76155}, // __nvvm_shfl_up_i32
+      {Intrinsic::nvvm_sin_approx_f, 76174}, // __nvvm_sin_approx_f
+      {Intrinsic::nvvm_sin_approx_ftz_f, 76194}, // __nvvm_sin_approx_ftz_f
+      {Intrinsic::nvvm_sqrt_approx_f, 76218}, // __nvvm_sqrt_approx_f
+      {Intrinsic::nvvm_sqrt_approx_ftz_f, 76239}, // __nvvm_sqrt_approx_ftz_f
+      {Intrinsic::nvvm_sqrt_f, 76264}, // __nvvm_sqrt_f
+      {Intrinsic::nvvm_sqrt_rm_d, 76278}, // __nvvm_sqrt_rm_d
+      {Intrinsic::nvvm_sqrt_rm_f, 76295}, // __nvvm_sqrt_rm_f
+      {Intrinsic::nvvm_sqrt_rm_ftz_f, 76312}, // __nvvm_sqrt_rm_ftz_f
+      {Intrinsic::nvvm_sqrt_rn_d, 76333}, // __nvvm_sqrt_rn_d
+      {Intrinsic::nvvm_sqrt_rn_f, 76350}, // __nvvm_sqrt_rn_f
+      {Intrinsic::nvvm_sqrt_rn_ftz_f, 76367}, // __nvvm_sqrt_rn_ftz_f
+      {Intrinsic::nvvm_sqrt_rp_d, 76388}, // __nvvm_sqrt_rp_d
+      {Intrinsic::nvvm_sqrt_rp_f, 76405}, // __nvvm_sqrt_rp_f
+      {Intrinsic::nvvm_sqrt_rp_ftz_f, 76422}, // __nvvm_sqrt_rp_ftz_f
+      {Intrinsic::nvvm_sqrt_rz_d, 76443}, // __nvvm_sqrt_rz_d
+      {Intrinsic::nvvm_sqrt_rz_f, 76460}, // __nvvm_sqrt_rz_f
+      {Intrinsic::nvvm_sqrt_rz_ftz_f, 76477}, // __nvvm_sqrt_rz_ftz_f
+      {Intrinsic::nvvm_suq_array_size, 76498}, // __nvvm_suq_array_size
+      {Intrinsic::nvvm_suq_channel_data_type, 76520}, // __nvvm_suq_channel_data_type
+      {Intrinsic::nvvm_suq_channel_order, 76549}, // __nvvm_suq_channel_order
+      {Intrinsic::nvvm_suq_depth, 76574}, // __nvvm_suq_depth
+      {Intrinsic::nvvm_suq_height, 76591}, // __nvvm_suq_height
+      {Intrinsic::nvvm_suq_width, 76609}, // __nvvm_suq_width
+      {Intrinsic::nvvm_sust_b_1d_array_i16_clamp, 76626}, // __nvvm_sust_b_1d_array_i16_clamp
+      {Intrinsic::nvvm_sust_b_1d_array_i16_trap, 76659}, // __nvvm_sust_b_1d_array_i16_trap
+      {Intrinsic::nvvm_sust_b_1d_array_i16_zero, 76691}, // __nvvm_sust_b_1d_array_i16_zero
+      {Intrinsic::nvvm_sust_b_1d_array_i32_clamp, 76723}, // __nvvm_sust_b_1d_array_i32_clamp
+      {Intrinsic::nvvm_sust_b_1d_array_i32_trap, 76756}, // __nvvm_sust_b_1d_array_i32_trap
+      {Intrinsic::nvvm_sust_b_1d_array_i32_zero, 76788}, // __nvvm_sust_b_1d_array_i32_zero
+      {Intrinsic::nvvm_sust_b_1d_array_i64_clamp, 76820}, // __nvvm_sust_b_1d_array_i64_clamp
+      {Intrinsic::nvvm_sust_b_1d_array_i64_trap, 76853}, // __nvvm_sust_b_1d_array_i64_trap
+      {Intrinsic::nvvm_sust_b_1d_array_i64_zero, 76885}, // __nvvm_sust_b_1d_array_i64_zero
+      {Intrinsic::nvvm_sust_b_1d_array_i8_clamp, 76917}, // __nvvm_sust_b_1d_array_i8_clamp
+      {Intrinsic::nvvm_sust_b_1d_array_i8_trap, 76949}, // __nvvm_sust_b_1d_array_i8_trap
+      {Intrinsic::nvvm_sust_b_1d_array_i8_zero, 76980}, // __nvvm_sust_b_1d_array_i8_zero
+      {Intrinsic::nvvm_sust_b_1d_array_v2i16_clamp, 77011}, // __nvvm_sust_b_1d_array_v2i16_clamp
+      {Intrinsic::nvvm_sust_b_1d_array_v2i16_trap, 77046}, // __nvvm_sust_b_1d_array_v2i16_trap
+      {Intrinsic::nvvm_sust_b_1d_array_v2i16_zero, 77080}, // __nvvm_sust_b_1d_array_v2i16_zero
+      {Intrinsic::nvvm_sust_b_1d_array_v2i32_clamp, 77114}, // __nvvm_sust_b_1d_array_v2i32_clamp
+      {Intrinsic::nvvm_sust_b_1d_array_v2i32_trap, 77149}, // __nvvm_sust_b_1d_array_v2i32_trap
+      {Intrinsic::nvvm_sust_b_1d_array_v2i32_zero, 77183}, // __nvvm_sust_b_1d_array_v2i32_zero
+      {Intrinsic::nvvm_sust_b_1d_array_v2i64_clamp, 77217}, // __nvvm_sust_b_1d_array_v2i64_clamp
+      {Intrinsic::nvvm_sust_b_1d_array_v2i64_trap, 77252}, // __nvvm_sust_b_1d_array_v2i64_trap
+      {Intrinsic::nvvm_sust_b_1d_array_v2i64_zero, 77286}, // __nvvm_sust_b_1d_array_v2i64_zero
+      {Intrinsic::nvvm_sust_b_1d_array_v2i8_clamp, 77320}, // __nvvm_sust_b_1d_array_v2i8_clamp
+      {Intrinsic::nvvm_sust_b_1d_array_v2i8_trap, 77354}, // __nvvm_sust_b_1d_array_v2i8_trap
+      {Intrinsic::nvvm_sust_b_1d_array_v2i8_zero, 77387}, // __nvvm_sust_b_1d_array_v2i8_zero
+      {Intrinsic::nvvm_sust_b_1d_array_v4i16_clamp, 77420}, // __nvvm_sust_b_1d_array_v4i16_clamp
+      {Intrinsic::nvvm_sust_b_1d_array_v4i16_trap, 77455}, // __nvvm_sust_b_1d_array_v4i16_trap
+      {Intrinsic::nvvm_sust_b_1d_array_v4i16_zero, 77489}, // __nvvm_sust_b_1d_array_v4i16_zero
+      {Intrinsic::nvvm_sust_b_1d_array_v4i32_clamp, 77523}, // __nvvm_sust_b_1d_array_v4i32_clamp
+      {Intrinsic::nvvm_sust_b_1d_array_v4i32_trap, 77558}, // __nvvm_sust_b_1d_array_v4i32_trap
+      {Intrinsic::nvvm_sust_b_1d_array_v4i32_zero, 77592}, // __nvvm_sust_b_1d_array_v4i32_zero
+      {Intrinsic::nvvm_sust_b_1d_array_v4i8_clamp, 77626}, // __nvvm_sust_b_1d_array_v4i8_clamp
+      {Intrinsic::nvvm_sust_b_1d_array_v4i8_trap, 77660}, // __nvvm_sust_b_1d_array_v4i8_trap
+      {Intrinsic::nvvm_sust_b_1d_array_v4i8_zero, 77693}, // __nvvm_sust_b_1d_array_v4i8_zero
+      {Intrinsic::nvvm_sust_b_1d_i16_clamp, 77726}, // __nvvm_sust_b_1d_i16_clamp
+      {Intrinsic::nvvm_sust_b_1d_i16_trap, 77753}, // __nvvm_sust_b_1d_i16_trap
+      {Intrinsic::nvvm_sust_b_1d_i16_zero, 77779}, // __nvvm_sust_b_1d_i16_zero
+      {Intrinsic::nvvm_sust_b_1d_i32_clamp, 77805}, // __nvvm_sust_b_1d_i32_clamp
+      {Intrinsic::nvvm_sust_b_1d_i32_trap, 77832}, // __nvvm_sust_b_1d_i32_trap
+      {Intrinsic::nvvm_sust_b_1d_i32_zero, 77858}, // __nvvm_sust_b_1d_i32_zero
+      {Intrinsic::nvvm_sust_b_1d_i64_clamp, 77884}, // __nvvm_sust_b_1d_i64_clamp
+      {Intrinsic::nvvm_sust_b_1d_i64_trap, 77911}, // __nvvm_sust_b_1d_i64_trap
+      {Intrinsic::nvvm_sust_b_1d_i64_zero, 77937}, // __nvvm_sust_b_1d_i64_zero
+      {Intrinsic::nvvm_sust_b_1d_i8_clamp, 77963}, // __nvvm_sust_b_1d_i8_clamp
+      {Intrinsic::nvvm_sust_b_1d_i8_trap, 77989}, // __nvvm_sust_b_1d_i8_trap
+      {Intrinsic::nvvm_sust_b_1d_i8_zero, 78014}, // __nvvm_sust_b_1d_i8_zero
+      {Intrinsic::nvvm_sust_b_1d_v2i16_clamp, 78039}, // __nvvm_sust_b_1d_v2i16_clamp
+      {Intrinsic::nvvm_sust_b_1d_v2i16_trap, 78068}, // __nvvm_sust_b_1d_v2i16_trap
+      {Intrinsic::nvvm_sust_b_1d_v2i16_zero, 78096}, // __nvvm_sust_b_1d_v2i16_zero
+      {Intrinsic::nvvm_sust_b_1d_v2i32_clamp, 78124}, // __nvvm_sust_b_1d_v2i32_clamp
+      {Intrinsic::nvvm_sust_b_1d_v2i32_trap, 78153}, // __nvvm_sust_b_1d_v2i32_trap
+      {Intrinsic::nvvm_sust_b_1d_v2i32_zero, 78181}, // __nvvm_sust_b_1d_v2i32_zero
+      {Intrinsic::nvvm_sust_b_1d_v2i64_clamp, 78209}, // __nvvm_sust_b_1d_v2i64_clamp
+      {Intrinsic::nvvm_sust_b_1d_v2i64_trap, 78238}, // __nvvm_sust_b_1d_v2i64_trap
+      {Intrinsic::nvvm_sust_b_1d_v2i64_zero, 78266}, // __nvvm_sust_b_1d_v2i64_zero
+      {Intrinsic::nvvm_sust_b_1d_v2i8_clamp, 78294}, // __nvvm_sust_b_1d_v2i8_clamp
+      {Intrinsic::nvvm_sust_b_1d_v2i8_trap, 78322}, // __nvvm_sust_b_1d_v2i8_trap
+      {Intrinsic::nvvm_sust_b_1d_v2i8_zero, 78349}, // __nvvm_sust_b_1d_v2i8_zero
+      {Intrinsic::nvvm_sust_b_1d_v4i16_clamp, 78376}, // __nvvm_sust_b_1d_v4i16_clamp
+      {Intrinsic::nvvm_sust_b_1d_v4i16_trap, 78405}, // __nvvm_sust_b_1d_v4i16_trap
+      {Intrinsic::nvvm_sust_b_1d_v4i16_zero, 78433}, // __nvvm_sust_b_1d_v4i16_zero
+      {Intrinsic::nvvm_sust_b_1d_v4i32_clamp, 78461}, // __nvvm_sust_b_1d_v4i32_clamp
+      {Intrinsic::nvvm_sust_b_1d_v4i32_trap, 78490}, // __nvvm_sust_b_1d_v4i32_trap
+      {Intrinsic::nvvm_sust_b_1d_v4i32_zero, 78518}, // __nvvm_sust_b_1d_v4i32_zero
+      {Intrinsic::nvvm_sust_b_1d_v4i8_clamp, 78546}, // __nvvm_sust_b_1d_v4i8_clamp
+      {Intrinsic::nvvm_sust_b_1d_v4i8_trap, 78574}, // __nvvm_sust_b_1d_v4i8_trap
+      {Intrinsic::nvvm_sust_b_1d_v4i8_zero, 78601}, // __nvvm_sust_b_1d_v4i8_zero
+      {Intrinsic::nvvm_sust_b_2d_array_i16_clamp, 78628}, // __nvvm_sust_b_2d_array_i16_clamp
+      {Intrinsic::nvvm_sust_b_2d_array_i16_trap, 78661}, // __nvvm_sust_b_2d_array_i16_trap
+      {Intrinsic::nvvm_sust_b_2d_array_i16_zero, 78693}, // __nvvm_sust_b_2d_array_i16_zero
+      {Intrinsic::nvvm_sust_b_2d_array_i32_clamp, 78725}, // __nvvm_sust_b_2d_array_i32_clamp
+      {Intrinsic::nvvm_sust_b_2d_array_i32_trap, 78758}, // __nvvm_sust_b_2d_array_i32_trap
+      {Intrinsic::nvvm_sust_b_2d_array_i32_zero, 78790}, // __nvvm_sust_b_2d_array_i32_zero
+      {Intrinsic::nvvm_sust_b_2d_array_i64_clamp, 78822}, // __nvvm_sust_b_2d_array_i64_clamp
+      {Intrinsic::nvvm_sust_b_2d_array_i64_trap, 78855}, // __nvvm_sust_b_2d_array_i64_trap
+      {Intrinsic::nvvm_sust_b_2d_array_i64_zero, 78887}, // __nvvm_sust_b_2d_array_i64_zero
+      {Intrinsic::nvvm_sust_b_2d_array_i8_clamp, 78919}, // __nvvm_sust_b_2d_array_i8_clamp
+      {Intrinsic::nvvm_sust_b_2d_array_i8_trap, 78951}, // __nvvm_sust_b_2d_array_i8_trap
+      {Intrinsic::nvvm_sust_b_2d_array_i8_zero, 78982}, // __nvvm_sust_b_2d_array_i8_zero
+      {Intrinsic::nvvm_sust_b_2d_array_v2i16_clamp, 79013}, // __nvvm_sust_b_2d_array_v2i16_clamp
+      {Intrinsic::nvvm_sust_b_2d_array_v2i16_trap, 79048}, // __nvvm_sust_b_2d_array_v2i16_trap
+      {Intrinsic::nvvm_sust_b_2d_array_v2i16_zero, 79082}, // __nvvm_sust_b_2d_array_v2i16_zero
+      {Intrinsic::nvvm_sust_b_2d_array_v2i32_clamp, 79116}, // __nvvm_sust_b_2d_array_v2i32_clamp
+      {Intrinsic::nvvm_sust_b_2d_array_v2i32_trap, 79151}, // __nvvm_sust_b_2d_array_v2i32_trap
+      {Intrinsic::nvvm_sust_b_2d_array_v2i32_zero, 79185}, // __nvvm_sust_b_2d_array_v2i32_zero
+      {Intrinsic::nvvm_sust_b_2d_array_v2i64_clamp, 79219}, // __nvvm_sust_b_2d_array_v2i64_clamp
+      {Intrinsic::nvvm_sust_b_2d_array_v2i64_trap, 79254}, // __nvvm_sust_b_2d_array_v2i64_trap
+      {Intrinsic::nvvm_sust_b_2d_array_v2i64_zero, 79288}, // __nvvm_sust_b_2d_array_v2i64_zero
+      {Intrinsic::nvvm_sust_b_2d_array_v2i8_clamp, 79322}, // __nvvm_sust_b_2d_array_v2i8_clamp
+      {Intrinsic::nvvm_sust_b_2d_array_v2i8_trap, 79356}, // __nvvm_sust_b_2d_array_v2i8_trap
+      {Intrinsic::nvvm_sust_b_2d_array_v2i8_zero, 79389}, // __nvvm_sust_b_2d_array_v2i8_zero
+      {Intrinsic::nvvm_sust_b_2d_array_v4i16_clamp, 79422}, // __nvvm_sust_b_2d_array_v4i16_clamp
+      {Intrinsic::nvvm_sust_b_2d_array_v4i16_trap, 79457}, // __nvvm_sust_b_2d_array_v4i16_trap
+      {Intrinsic::nvvm_sust_b_2d_array_v4i16_zero, 79491}, // __nvvm_sust_b_2d_array_v4i16_zero
+      {Intrinsic::nvvm_sust_b_2d_array_v4i32_clamp, 79525}, // __nvvm_sust_b_2d_array_v4i32_clamp
+      {Intrinsic::nvvm_sust_b_2d_array_v4i32_trap, 79560}, // __nvvm_sust_b_2d_array_v4i32_trap
+      {Intrinsic::nvvm_sust_b_2d_array_v4i32_zero, 79594}, // __nvvm_sust_b_2d_array_v4i32_zero
+      {Intrinsic::nvvm_sust_b_2d_array_v4i8_clamp, 79628}, // __nvvm_sust_b_2d_array_v4i8_clamp
+      {Intrinsic::nvvm_sust_b_2d_array_v4i8_trap, 79662}, // __nvvm_sust_b_2d_array_v4i8_trap
+      {Intrinsic::nvvm_sust_b_2d_array_v4i8_zero, 79695}, // __nvvm_sust_b_2d_array_v4i8_zero
+      {Intrinsic::nvvm_sust_b_2d_i16_clamp, 79728}, // __nvvm_sust_b_2d_i16_clamp
+      {Intrinsic::nvvm_sust_b_2d_i16_trap, 79755}, // __nvvm_sust_b_2d_i16_trap
+      {Intrinsic::nvvm_sust_b_2d_i16_zero, 79781}, // __nvvm_sust_b_2d_i16_zero
+      {Intrinsic::nvvm_sust_b_2d_i32_clamp, 79807}, // __nvvm_sust_b_2d_i32_clamp
+      {Intrinsic::nvvm_sust_b_2d_i32_trap, 79834}, // __nvvm_sust_b_2d_i32_trap
+      {Intrinsic::nvvm_sust_b_2d_i32_zero, 79860}, // __nvvm_sust_b_2d_i32_zero
+      {Intrinsic::nvvm_sust_b_2d_i64_clamp, 79886}, // __nvvm_sust_b_2d_i64_clamp
+      {Intrinsic::nvvm_sust_b_2d_i64_trap, 79913}, // __nvvm_sust_b_2d_i64_trap
+      {Intrinsic::nvvm_sust_b_2d_i64_zero, 79939}, // __nvvm_sust_b_2d_i64_zero
+      {Intrinsic::nvvm_sust_b_2d_i8_clamp, 79965}, // __nvvm_sust_b_2d_i8_clamp
+      {Intrinsic::nvvm_sust_b_2d_i8_trap, 79991}, // __nvvm_sust_b_2d_i8_trap
+      {Intrinsic::nvvm_sust_b_2d_i8_zero, 80016}, // __nvvm_sust_b_2d_i8_zero
+      {Intrinsic::nvvm_sust_b_2d_v2i16_clamp, 80041}, // __nvvm_sust_b_2d_v2i16_clamp
+      {Intrinsic::nvvm_sust_b_2d_v2i16_trap, 80070}, // __nvvm_sust_b_2d_v2i16_trap
+      {Intrinsic::nvvm_sust_b_2d_v2i16_zero, 80098}, // __nvvm_sust_b_2d_v2i16_zero
+      {Intrinsic::nvvm_sust_b_2d_v2i32_clamp, 80126}, // __nvvm_sust_b_2d_v2i32_clamp
+      {Intrinsic::nvvm_sust_b_2d_v2i32_trap, 80155}, // __nvvm_sust_b_2d_v2i32_trap
+      {Intrinsic::nvvm_sust_b_2d_v2i32_zero, 80183}, // __nvvm_sust_b_2d_v2i32_zero
+      {Intrinsic::nvvm_sust_b_2d_v2i64_clamp, 80211}, // __nvvm_sust_b_2d_v2i64_clamp
+      {Intrinsic::nvvm_sust_b_2d_v2i64_trap, 80240}, // __nvvm_sust_b_2d_v2i64_trap
+      {Intrinsic::nvvm_sust_b_2d_v2i64_zero, 80268}, // __nvvm_sust_b_2d_v2i64_zero
+      {Intrinsic::nvvm_sust_b_2d_v2i8_clamp, 80296}, // __nvvm_sust_b_2d_v2i8_clamp
+      {Intrinsic::nvvm_sust_b_2d_v2i8_trap, 80324}, // __nvvm_sust_b_2d_v2i8_trap
+      {Intrinsic::nvvm_sust_b_2d_v2i8_zero, 80351}, // __nvvm_sust_b_2d_v2i8_zero
+      {Intrinsic::nvvm_sust_b_2d_v4i16_clamp, 80378}, // __nvvm_sust_b_2d_v4i16_clamp
+      {Intrinsic::nvvm_sust_b_2d_v4i16_trap, 80407}, // __nvvm_sust_b_2d_v4i16_trap
+      {Intrinsic::nvvm_sust_b_2d_v4i16_zero, 80435}, // __nvvm_sust_b_2d_v4i16_zero
+      {Intrinsic::nvvm_sust_b_2d_v4i32_clamp, 80463}, // __nvvm_sust_b_2d_v4i32_clamp
+      {Intrinsic::nvvm_sust_b_2d_v4i32_trap, 80492}, // __nvvm_sust_b_2d_v4i32_trap
+      {Intrinsic::nvvm_sust_b_2d_v4i32_zero, 80520}, // __nvvm_sust_b_2d_v4i32_zero
+      {Intrinsic::nvvm_sust_b_2d_v4i8_clamp, 80548}, // __nvvm_sust_b_2d_v4i8_clamp
+      {Intrinsic::nvvm_sust_b_2d_v4i8_trap, 80576}, // __nvvm_sust_b_2d_v4i8_trap
+      {Intrinsic::nvvm_sust_b_2d_v4i8_zero, 80603}, // __nvvm_sust_b_2d_v4i8_zero
+      {Intrinsic::nvvm_sust_b_3d_i16_clamp, 80630}, // __nvvm_sust_b_3d_i16_clamp
+      {Intrinsic::nvvm_sust_b_3d_i16_trap, 80657}, // __nvvm_sust_b_3d_i16_trap
+      {Intrinsic::nvvm_sust_b_3d_i16_zero, 80683}, // __nvvm_sust_b_3d_i16_zero
+      {Intrinsic::nvvm_sust_b_3d_i32_clamp, 80709}, // __nvvm_sust_b_3d_i32_clamp
+      {Intrinsic::nvvm_sust_b_3d_i32_trap, 80736}, // __nvvm_sust_b_3d_i32_trap
+      {Intrinsic::nvvm_sust_b_3d_i32_zero, 80762}, // __nvvm_sust_b_3d_i32_zero
+      {Intrinsic::nvvm_sust_b_3d_i64_clamp, 80788}, // __nvvm_sust_b_3d_i64_clamp
+      {Intrinsic::nvvm_sust_b_3d_i64_trap, 80815}, // __nvvm_sust_b_3d_i64_trap
+      {Intrinsic::nvvm_sust_b_3d_i64_zero, 80841}, // __nvvm_sust_b_3d_i64_zero
+      {Intrinsic::nvvm_sust_b_3d_i8_clamp, 80867}, // __nvvm_sust_b_3d_i8_clamp
+      {Intrinsic::nvvm_sust_b_3d_i8_trap, 80893}, // __nvvm_sust_b_3d_i8_trap
+      {Intrinsic::nvvm_sust_b_3d_i8_zero, 80918}, // __nvvm_sust_b_3d_i8_zero
+      {Intrinsic::nvvm_sust_b_3d_v2i16_clamp, 80943}, // __nvvm_sust_b_3d_v2i16_clamp
+      {Intrinsic::nvvm_sust_b_3d_v2i16_trap, 80972}, // __nvvm_sust_b_3d_v2i16_trap
+      {Intrinsic::nvvm_sust_b_3d_v2i16_zero, 81000}, // __nvvm_sust_b_3d_v2i16_zero
+      {Intrinsic::nvvm_sust_b_3d_v2i32_clamp, 81028}, // __nvvm_sust_b_3d_v2i32_clamp
+      {Intrinsic::nvvm_sust_b_3d_v2i32_trap, 81057}, // __nvvm_sust_b_3d_v2i32_trap
+      {Intrinsic::nvvm_sust_b_3d_v2i32_zero, 81085}, // __nvvm_sust_b_3d_v2i32_zero
+      {Intrinsic::nvvm_sust_b_3d_v2i64_clamp, 81113}, // __nvvm_sust_b_3d_v2i64_clamp
+      {Intrinsic::nvvm_sust_b_3d_v2i64_trap, 81142}, // __nvvm_sust_b_3d_v2i64_trap
+      {Intrinsic::nvvm_sust_b_3d_v2i64_zero, 81170}, // __nvvm_sust_b_3d_v2i64_zero
+      {Intrinsic::nvvm_sust_b_3d_v2i8_clamp, 81198}, // __nvvm_sust_b_3d_v2i8_clamp
+      {Intrinsic::nvvm_sust_b_3d_v2i8_trap, 81226}, // __nvvm_sust_b_3d_v2i8_trap
+      {Intrinsic::nvvm_sust_b_3d_v2i8_zero, 81253}, // __nvvm_sust_b_3d_v2i8_zero
+      {Intrinsic::nvvm_sust_b_3d_v4i16_clamp, 81280}, // __nvvm_sust_b_3d_v4i16_clamp
+      {Intrinsic::nvvm_sust_b_3d_v4i16_trap, 81309}, // __nvvm_sust_b_3d_v4i16_trap
+      {Intrinsic::nvvm_sust_b_3d_v4i16_zero, 81337}, // __nvvm_sust_b_3d_v4i16_zero
+      {Intrinsic::nvvm_sust_b_3d_v4i32_clamp, 81365}, // __nvvm_sust_b_3d_v4i32_clamp
+      {Intrinsic::nvvm_sust_b_3d_v4i32_trap, 81394}, // __nvvm_sust_b_3d_v4i32_trap
+      {Intrinsic::nvvm_sust_b_3d_v4i32_zero, 81422}, // __nvvm_sust_b_3d_v4i32_zero
+      {Intrinsic::nvvm_sust_b_3d_v4i8_clamp, 81450}, // __nvvm_sust_b_3d_v4i8_clamp
+      {Intrinsic::nvvm_sust_b_3d_v4i8_trap, 81478}, // __nvvm_sust_b_3d_v4i8_trap
+      {Intrinsic::nvvm_sust_b_3d_v4i8_zero, 81505}, // __nvvm_sust_b_3d_v4i8_zero
+      {Intrinsic::nvvm_sust_p_1d_array_i16_trap, 81532}, // __nvvm_sust_p_1d_array_i16_trap
+      {Intrinsic::nvvm_sust_p_1d_array_i32_trap, 81564}, // __nvvm_sust_p_1d_array_i32_trap
+      {Intrinsic::nvvm_sust_p_1d_array_i8_trap, 81596}, // __nvvm_sust_p_1d_array_i8_trap
+      {Intrinsic::nvvm_sust_p_1d_array_v2i16_trap, 81627}, // __nvvm_sust_p_1d_array_v2i16_trap
+      {Intrinsic::nvvm_sust_p_1d_array_v2i32_trap, 81661}, // __nvvm_sust_p_1d_array_v2i32_trap
+      {Intrinsic::nvvm_sust_p_1d_array_v2i8_trap, 81695}, // __nvvm_sust_p_1d_array_v2i8_trap
+      {Intrinsic::nvvm_sust_p_1d_array_v4i16_trap, 81728}, // __nvvm_sust_p_1d_array_v4i16_trap
+      {Intrinsic::nvvm_sust_p_1d_array_v4i32_trap, 81762}, // __nvvm_sust_p_1d_array_v4i32_trap
+      {Intrinsic::nvvm_sust_p_1d_array_v4i8_trap, 81796}, // __nvvm_sust_p_1d_array_v4i8_trap
+      {Intrinsic::nvvm_sust_p_1d_i16_trap, 81829}, // __nvvm_sust_p_1d_i16_trap
+      {Intrinsic::nvvm_sust_p_1d_i32_trap, 81855}, // __nvvm_sust_p_1d_i32_trap
+      {Intrinsic::nvvm_sust_p_1d_i8_trap, 81881}, // __nvvm_sust_p_1d_i8_trap
+      {Intrinsic::nvvm_sust_p_1d_v2i16_trap, 81906}, // __nvvm_sust_p_1d_v2i16_trap
+      {Intrinsic::nvvm_sust_p_1d_v2i32_trap, 81934}, // __nvvm_sust_p_1d_v2i32_trap
+      {Intrinsic::nvvm_sust_p_1d_v2i8_trap, 81962}, // __nvvm_sust_p_1d_v2i8_trap
+      {Intrinsic::nvvm_sust_p_1d_v4i16_trap, 81989}, // __nvvm_sust_p_1d_v4i16_trap
+      {Intrinsic::nvvm_sust_p_1d_v4i32_trap, 82017}, // __nvvm_sust_p_1d_v4i32_trap
+      {Intrinsic::nvvm_sust_p_1d_v4i8_trap, 82045}, // __nvvm_sust_p_1d_v4i8_trap
+      {Intrinsic::nvvm_sust_p_2d_array_i16_trap, 82072}, // __nvvm_sust_p_2d_array_i16_trap
+      {Intrinsic::nvvm_sust_p_2d_array_i32_trap, 82104}, // __nvvm_sust_p_2d_array_i32_trap
+      {Intrinsic::nvvm_sust_p_2d_array_i8_trap, 82136}, // __nvvm_sust_p_2d_array_i8_trap
+      {Intrinsic::nvvm_sust_p_2d_array_v2i16_trap, 82167}, // __nvvm_sust_p_2d_array_v2i16_trap
+      {Intrinsic::nvvm_sust_p_2d_array_v2i32_trap, 82201}, // __nvvm_sust_p_2d_array_v2i32_trap
+      {Intrinsic::nvvm_sust_p_2d_array_v2i8_trap, 82235}, // __nvvm_sust_p_2d_array_v2i8_trap
+      {Intrinsic::nvvm_sust_p_2d_array_v4i16_trap, 82268}, // __nvvm_sust_p_2d_array_v4i16_trap
+      {Intrinsic::nvvm_sust_p_2d_array_v4i32_trap, 82302}, // __nvvm_sust_p_2d_array_v4i32_trap
+      {Intrinsic::nvvm_sust_p_2d_array_v4i8_trap, 82336}, // __nvvm_sust_p_2d_array_v4i8_trap
+      {Intrinsic::nvvm_sust_p_2d_i16_trap, 82369}, // __nvvm_sust_p_2d_i16_trap
+      {Intrinsic::nvvm_sust_p_2d_i32_trap, 82395}, // __nvvm_sust_p_2d_i32_trap
+      {Intrinsic::nvvm_sust_p_2d_i8_trap, 82421}, // __nvvm_sust_p_2d_i8_trap
+      {Intrinsic::nvvm_sust_p_2d_v2i16_trap, 82446}, // __nvvm_sust_p_2d_v2i16_trap
+      {Intrinsic::nvvm_sust_p_2d_v2i32_trap, 82474}, // __nvvm_sust_p_2d_v2i32_trap
+      {Intrinsic::nvvm_sust_p_2d_v2i8_trap, 82502}, // __nvvm_sust_p_2d_v2i8_trap
+      {Intrinsic::nvvm_sust_p_2d_v4i16_trap, 82529}, // __nvvm_sust_p_2d_v4i16_trap
+      {Intrinsic::nvvm_sust_p_2d_v4i32_trap, 82557}, // __nvvm_sust_p_2d_v4i32_trap
+      {Intrinsic::nvvm_sust_p_2d_v4i8_trap, 82585}, // __nvvm_sust_p_2d_v4i8_trap
+      {Intrinsic::nvvm_sust_p_3d_i16_trap, 82612}, // __nvvm_sust_p_3d_i16_trap
+      {Intrinsic::nvvm_sust_p_3d_i32_trap, 82638}, // __nvvm_sust_p_3d_i32_trap
+      {Intrinsic::nvvm_sust_p_3d_i8_trap, 82664}, // __nvvm_sust_p_3d_i8_trap
+      {Intrinsic::nvvm_sust_p_3d_v2i16_trap, 82689}, // __nvvm_sust_p_3d_v2i16_trap
+      {Intrinsic::nvvm_sust_p_3d_v2i32_trap, 82717}, // __nvvm_sust_p_3d_v2i32_trap
+      {Intrinsic::nvvm_sust_p_3d_v2i8_trap, 82745}, // __nvvm_sust_p_3d_v2i8_trap
+      {Intrinsic::nvvm_sust_p_3d_v4i16_trap, 82772}, // __nvvm_sust_p_3d_v4i16_trap
+      {Intrinsic::nvvm_sust_p_3d_v4i32_trap, 82800}, // __nvvm_sust_p_3d_v4i32_trap
+      {Intrinsic::nvvm_sust_p_3d_v4i8_trap, 82828}, // __nvvm_sust_p_3d_v4i8_trap
+      {Intrinsic::nvvm_swap_lo_hi_b64, 82855}, // __nvvm_swap_lo_hi_b64
+      {Intrinsic::nvvm_trunc_d, 82877}, // __nvvm_trunc_d
+      {Intrinsic::nvvm_trunc_f, 82892}, // __nvvm_trunc_f
+      {Intrinsic::nvvm_trunc_ftz_f, 82907}, // __nvvm_trunc_ftz_f
+      {Intrinsic::nvvm_txq_array_size, 82926}, // __nvvm_txq_array_size
+      {Intrinsic::nvvm_txq_channel_data_type, 82948}, // __nvvm_txq_channel_data_type
+      {Intrinsic::nvvm_txq_channel_order, 82977}, // __nvvm_txq_channel_order
+      {Intrinsic::nvvm_txq_depth, 83002}, // __nvvm_txq_depth
+      {Intrinsic::nvvm_txq_height, 83019}, // __nvvm_txq_height
+      {Intrinsic::nvvm_txq_num_mipmap_levels, 83037}, // __nvvm_txq_num_mipmap_levels
+      {Intrinsic::nvvm_txq_num_samples, 83066}, // __nvvm_txq_num_samples
+      {Intrinsic::nvvm_txq_width, 83089}, // __nvvm_txq_width
+      {Intrinsic::nvvm_ui2d_rm, 83106}, // __nvvm_ui2d_rm
+      {Intrinsic::nvvm_ui2d_rn, 83121}, // __nvvm_ui2d_rn
+      {Intrinsic::nvvm_ui2d_rp, 83136}, // __nvvm_ui2d_rp
+      {Intrinsic::nvvm_ui2d_rz, 83151}, // __nvvm_ui2d_rz
+      {Intrinsic::nvvm_ui2f_rm, 83166}, // __nvvm_ui2f_rm
+      {Intrinsic::nvvm_ui2f_rn, 83181}, // __nvvm_ui2f_rn
+      {Intrinsic::nvvm_ui2f_rp, 83196}, // __nvvm_ui2f_rp
+      {Intrinsic::nvvm_ui2f_rz, 83211}, // __nvvm_ui2f_rz
+      {Intrinsic::nvvm_ull2d_rm, 83226}, // __nvvm_ull2d_rm
+      {Intrinsic::nvvm_ull2d_rn, 83242}, // __nvvm_ull2d_rn
+      {Intrinsic::nvvm_ull2d_rp, 83258}, // __nvvm_ull2d_rp
+      {Intrinsic::nvvm_ull2d_rz, 83274}, // __nvvm_ull2d_rz
+      {Intrinsic::nvvm_ull2f_rm, 83290}, // __nvvm_ull2f_rm
+      {Intrinsic::nvvm_ull2f_rn, 83306}, // __nvvm_ull2f_rn
+      {Intrinsic::nvvm_ull2f_rp, 83322}, // __nvvm_ull2f_rp
+      {Intrinsic::nvvm_ull2f_rz, 83338}, // __nvvm_ull2f_rz
+      {Intrinsic::nvvm_vote_all, 83354}, // __nvvm_vote_all
+      {Intrinsic::nvvm_vote_all_sync, 83370}, // __nvvm_vote_all_sync
+      {Intrinsic::nvvm_vote_any, 83391}, // __nvvm_vote_any
+      {Intrinsic::nvvm_vote_any_sync, 83407}, // __nvvm_vote_any_sync
+      {Intrinsic::nvvm_vote_ballot, 83428}, // __nvvm_vote_ballot
+      {Intrinsic::nvvm_vote_ballot_sync, 83447}, // __nvvm_vote_ballot_sync
+      {Intrinsic::nvvm_vote_uni, 83471}, // __nvvm_vote_uni
+      {Intrinsic::nvvm_vote_uni_sync, 83487}, // __nvvm_vote_uni_sync
+      {Intrinsic::nvvm_barrier0, 70576}, // __syncthreads
     };
     auto I = std::lower_bound(std::begin(nvvmNames),
                               std::end(nvvmNames),
@@ -29678,374 +38794,407 @@
   }
   if (TargetPrefix == "ppc") {
     static const BuiltinEntry ppcNames[] = {
-      {Intrinsic::ppc_addf128_round_to_odd, 88188}, // __builtin_addf128_round_to_odd
-      {Intrinsic::ppc_altivec_crypto_vcipher, 88219}, // __builtin_altivec_crypto_vcipher
-      {Intrinsic::ppc_altivec_crypto_vcipherlast, 88252}, // __builtin_altivec_crypto_vcipherlast
-      {Intrinsic::ppc_altivec_crypto_vncipher, 88289}, // __builtin_altivec_crypto_vncipher
-      {Intrinsic::ppc_altivec_crypto_vncipherlast, 88323}, // __builtin_altivec_crypto_vncipherlast
-      {Intrinsic::ppc_altivec_crypto_vpermxor, 88361}, // __builtin_altivec_crypto_vpermxor
-      {Intrinsic::ppc_altivec_crypto_vpmsumb, 88395}, // __builtin_altivec_crypto_vpmsumb
-      {Intrinsic::ppc_altivec_crypto_vpmsumd, 88428}, // __builtin_altivec_crypto_vpmsumd
-      {Intrinsic::ppc_altivec_crypto_vpmsumh, 88461}, // __builtin_altivec_crypto_vpmsumh
-      {Intrinsic::ppc_altivec_crypto_vpmsumw, 88494}, // __builtin_altivec_crypto_vpmsumw
-      {Intrinsic::ppc_altivec_crypto_vsbox, 88527}, // __builtin_altivec_crypto_vsbox
-      {Intrinsic::ppc_altivec_crypto_vshasigmad, 88558}, // __builtin_altivec_crypto_vshasigmad
-      {Intrinsic::ppc_altivec_crypto_vshasigmaw, 88594}, // __builtin_altivec_crypto_vshasigmaw
-      {Intrinsic::ppc_altivec_dss, 88630}, // __builtin_altivec_dss
-      {Intrinsic::ppc_altivec_dssall, 88652}, // __builtin_altivec_dssall
-      {Intrinsic::ppc_altivec_dst, 88677}, // __builtin_altivec_dst
-      {Intrinsic::ppc_altivec_dstst, 88699}, // __builtin_altivec_dstst
-      {Intrinsic::ppc_altivec_dststt, 88723}, // __builtin_altivec_dststt
-      {Intrinsic::ppc_altivec_dstt, 88748}, // __builtin_altivec_dstt
-      {Intrinsic::ppc_altivec_mfvscr, 88771}, // __builtin_altivec_mfvscr
-      {Intrinsic::ppc_altivec_mtvscr, 88796}, // __builtin_altivec_mtvscr
-      {Intrinsic::ppc_altivec_vabsdub, 88821}, // __builtin_altivec_vabsdub
-      {Intrinsic::ppc_altivec_vabsduh, 88847}, // __builtin_altivec_vabsduh
-      {Intrinsic::ppc_altivec_vabsduw, 88873}, // __builtin_altivec_vabsduw
-      {Intrinsic::ppc_altivec_vaddcuq, 88899}, // __builtin_altivec_vaddcuq
-      {Intrinsic::ppc_altivec_vaddcuw, 88925}, // __builtin_altivec_vaddcuw
-      {Intrinsic::ppc_altivec_vaddecuq, 88951}, // __builtin_altivec_vaddecuq
-      {Intrinsic::ppc_altivec_vaddeuqm, 88978}, // __builtin_altivec_vaddeuqm
-      {Intrinsic::ppc_altivec_vaddsbs, 89005}, // __builtin_altivec_vaddsbs
-      {Intrinsic::ppc_altivec_vaddshs, 89031}, // __builtin_altivec_vaddshs
-      {Intrinsic::ppc_altivec_vaddsws, 89057}, // __builtin_altivec_vaddsws
-      {Intrinsic::ppc_altivec_vaddubs, 89083}, // __builtin_altivec_vaddubs
-      {Intrinsic::ppc_altivec_vadduhs, 89109}, // __builtin_altivec_vadduhs
-      {Intrinsic::ppc_altivec_vadduws, 89135}, // __builtin_altivec_vadduws
-      {Intrinsic::ppc_altivec_vavgsb, 89161}, // __builtin_altivec_vavgsb
-      {Intrinsic::ppc_altivec_vavgsh, 89186}, // __builtin_altivec_vavgsh
-      {Intrinsic::ppc_altivec_vavgsw, 89211}, // __builtin_altivec_vavgsw
-      {Intrinsic::ppc_altivec_vavgub, 89236}, // __builtin_altivec_vavgub
-      {Intrinsic::ppc_altivec_vavguh, 89261}, // __builtin_altivec_vavguh
-      {Intrinsic::ppc_altivec_vavguw, 89286}, // __builtin_altivec_vavguw
-      {Intrinsic::ppc_altivec_vbpermq, 89311}, // __builtin_altivec_vbpermq
-      {Intrinsic::ppc_altivec_vcfsx, 89337}, // __builtin_altivec_vcfsx
-      {Intrinsic::ppc_altivec_vcfux, 89361}, // __builtin_altivec_vcfux
-      {Intrinsic::ppc_altivec_vclzlsbb, 89385}, // __builtin_altivec_vclzlsbb
-      {Intrinsic::ppc_altivec_vcmpbfp, 89412}, // __builtin_altivec_vcmpbfp
-      {Intrinsic::ppc_altivec_vcmpbfp_p, 89438}, // __builtin_altivec_vcmpbfp_p
-      {Intrinsic::ppc_altivec_vcmpeqfp, 89466}, // __builtin_altivec_vcmpeqfp
-      {Intrinsic::ppc_altivec_vcmpeqfp_p, 89493}, // __builtin_altivec_vcmpeqfp_p
-      {Intrinsic::ppc_altivec_vcmpequb, 89522}, // __builtin_altivec_vcmpequb
-      {Intrinsic::ppc_altivec_vcmpequb_p, 89549}, // __builtin_altivec_vcmpequb_p
-      {Intrinsic::ppc_altivec_vcmpequd, 89578}, // __builtin_altivec_vcmpequd
-      {Intrinsic::ppc_altivec_vcmpequd_p, 89605}, // __builtin_altivec_vcmpequd_p
-      {Intrinsic::ppc_altivec_vcmpequh, 89634}, // __builtin_altivec_vcmpequh
-      {Intrinsic::ppc_altivec_vcmpequh_p, 89661}, // __builtin_altivec_vcmpequh_p
-      {Intrinsic::ppc_altivec_vcmpequw, 89690}, // __builtin_altivec_vcmpequw
-      {Intrinsic::ppc_altivec_vcmpequw_p, 89717}, // __builtin_altivec_vcmpequw_p
-      {Intrinsic::ppc_altivec_vcmpgefp, 89746}, // __builtin_altivec_vcmpgefp
-      {Intrinsic::ppc_altivec_vcmpgefp_p, 89773}, // __builtin_altivec_vcmpgefp_p
-      {Intrinsic::ppc_altivec_vcmpgtfp, 89802}, // __builtin_altivec_vcmpgtfp
-      {Intrinsic::ppc_altivec_vcmpgtfp_p, 89829}, // __builtin_altivec_vcmpgtfp_p
-      {Intrinsic::ppc_altivec_vcmpgtsb, 89858}, // __builtin_altivec_vcmpgtsb
-      {Intrinsic::ppc_altivec_vcmpgtsb_p, 89885}, // __builtin_altivec_vcmpgtsb_p
-      {Intrinsic::ppc_altivec_vcmpgtsd, 89914}, // __builtin_altivec_vcmpgtsd
-      {Intrinsic::ppc_altivec_vcmpgtsd_p, 89941}, // __builtin_altivec_vcmpgtsd_p
-      {Intrinsic::ppc_altivec_vcmpgtsh, 89970}, // __builtin_altivec_vcmpgtsh
-      {Intrinsic::ppc_altivec_vcmpgtsh_p, 89997}, // __builtin_altivec_vcmpgtsh_p
-      {Intrinsic::ppc_altivec_vcmpgtsw, 90026}, // __builtin_altivec_vcmpgtsw
-      {Intrinsic::ppc_altivec_vcmpgtsw_p, 90053}, // __builtin_altivec_vcmpgtsw_p
-      {Intrinsic::ppc_altivec_vcmpgtub, 90082}, // __builtin_altivec_vcmpgtub
-      {Intrinsic::ppc_altivec_vcmpgtub_p, 90109}, // __builtin_altivec_vcmpgtub_p
-      {Intrinsic::ppc_altivec_vcmpgtud, 90138}, // __builtin_altivec_vcmpgtud
-      {Intrinsic::ppc_altivec_vcmpgtud_p, 90165}, // __builtin_altivec_vcmpgtud_p
-      {Intrinsic::ppc_altivec_vcmpgtuh, 90194}, // __builtin_altivec_vcmpgtuh
-      {Intrinsic::ppc_altivec_vcmpgtuh_p, 90221}, // __builtin_altivec_vcmpgtuh_p
-      {Intrinsic::ppc_altivec_vcmpgtuw, 90250}, // __builtin_altivec_vcmpgtuw
-      {Intrinsic::ppc_altivec_vcmpgtuw_p, 90277}, // __builtin_altivec_vcmpgtuw_p
-      {Intrinsic::ppc_altivec_vcmpneb, 90306}, // __builtin_altivec_vcmpneb
-      {Intrinsic::ppc_altivec_vcmpneb_p, 90332}, // __builtin_altivec_vcmpneb_p
-      {Intrinsic::ppc_altivec_vcmpneh, 90360}, // __builtin_altivec_vcmpneh
-      {Intrinsic::ppc_altivec_vcmpneh_p, 90386}, // __builtin_altivec_vcmpneh_p
-      {Intrinsic::ppc_altivec_vcmpnew, 90414}, // __builtin_altivec_vcmpnew
-      {Intrinsic::ppc_altivec_vcmpnew_p, 90440}, // __builtin_altivec_vcmpnew_p
-      {Intrinsic::ppc_altivec_vcmpnezb, 90468}, // __builtin_altivec_vcmpnezb
-      {Intrinsic::ppc_altivec_vcmpnezb_p, 90495}, // __builtin_altivec_vcmpnezb_p
-      {Intrinsic::ppc_altivec_vcmpnezh, 90524}, // __builtin_altivec_vcmpnezh
-      {Intrinsic::ppc_altivec_vcmpnezh_p, 90551}, // __builtin_altivec_vcmpnezh_p
-      {Intrinsic::ppc_altivec_vcmpnezw, 90580}, // __builtin_altivec_vcmpnezw
-      {Intrinsic::ppc_altivec_vcmpnezw_p, 90607}, // __builtin_altivec_vcmpnezw_p
-      {Intrinsic::ppc_altivec_vctsxs, 90636}, // __builtin_altivec_vctsxs
-      {Intrinsic::ppc_altivec_vctuxs, 90661}, // __builtin_altivec_vctuxs
-      {Intrinsic::ppc_altivec_vctzlsbb, 90686}, // __builtin_altivec_vctzlsbb
-      {Intrinsic::ppc_altivec_vexptefp, 90713}, // __builtin_altivec_vexptefp
-      {Intrinsic::ppc_altivec_vgbbd, 90740}, // __builtin_altivec_vgbbd
-      {Intrinsic::ppc_altivec_vlogefp, 90764}, // __builtin_altivec_vlogefp
-      {Intrinsic::ppc_altivec_vmaddfp, 90790}, // __builtin_altivec_vmaddfp
-      {Intrinsic::ppc_altivec_vmaxfp, 90816}, // __builtin_altivec_vmaxfp
-      {Intrinsic::ppc_altivec_vmaxsb, 90841}, // __builtin_altivec_vmaxsb
-      {Intrinsic::ppc_altivec_vmaxsd, 90866}, // __builtin_altivec_vmaxsd
-      {Intrinsic::ppc_altivec_vmaxsh, 90891}, // __builtin_altivec_vmaxsh
-      {Intrinsic::ppc_altivec_vmaxsw, 90916}, // __builtin_altivec_vmaxsw
-      {Intrinsic::ppc_altivec_vmaxub, 90941}, // __builtin_altivec_vmaxub
-      {Intrinsic::ppc_altivec_vmaxud, 90966}, // __builtin_altivec_vmaxud
-      {Intrinsic::ppc_altivec_vmaxuh, 90991}, // __builtin_altivec_vmaxuh
-      {Intrinsic::ppc_altivec_vmaxuw, 91016}, // __builtin_altivec_vmaxuw
-      {Intrinsic::ppc_altivec_vmhaddshs, 91041}, // __builtin_altivec_vmhaddshs
-      {Intrinsic::ppc_altivec_vmhraddshs, 91069}, // __builtin_altivec_vmhraddshs
-      {Intrinsic::ppc_altivec_vminfp, 91098}, // __builtin_altivec_vminfp
-      {Intrinsic::ppc_altivec_vminsb, 91123}, // __builtin_altivec_vminsb
-      {Intrinsic::ppc_altivec_vminsd, 91148}, // __builtin_altivec_vminsd
-      {Intrinsic::ppc_altivec_vminsh, 91173}, // __builtin_altivec_vminsh
-      {Intrinsic::ppc_altivec_vminsw, 91198}, // __builtin_altivec_vminsw
-      {Intrinsic::ppc_altivec_vminub, 91223}, // __builtin_altivec_vminub
-      {Intrinsic::ppc_altivec_vminud, 91248}, // __builtin_altivec_vminud
-      {Intrinsic::ppc_altivec_vminuh, 91273}, // __builtin_altivec_vminuh
-      {Intrinsic::ppc_altivec_vminuw, 91298}, // __builtin_altivec_vminuw
-      {Intrinsic::ppc_altivec_vmladduhm, 91323}, // __builtin_altivec_vmladduhm
-      {Intrinsic::ppc_altivec_vmsummbm, 91351}, // __builtin_altivec_vmsummbm
-      {Intrinsic::ppc_altivec_vmsumshm, 91378}, // __builtin_altivec_vmsumshm
-      {Intrinsic::ppc_altivec_vmsumshs, 91405}, // __builtin_altivec_vmsumshs
-      {Intrinsic::ppc_altivec_vmsumubm, 91432}, // __builtin_altivec_vmsumubm
-      {Intrinsic::ppc_altivec_vmsumuhm, 91459}, // __builtin_altivec_vmsumuhm
-      {Intrinsic::ppc_altivec_vmsumuhs, 91486}, // __builtin_altivec_vmsumuhs
-      {Intrinsic::ppc_altivec_vmulesb, 91513}, // __builtin_altivec_vmulesb
-      {Intrinsic::ppc_altivec_vmulesh, 91539}, // __builtin_altivec_vmulesh
-      {Intrinsic::ppc_altivec_vmulesw, 91565}, // __builtin_altivec_vmulesw
-      {Intrinsic::ppc_altivec_vmuleub, 91591}, // __builtin_altivec_vmuleub
-      {Intrinsic::ppc_altivec_vmuleuh, 91617}, // __builtin_altivec_vmuleuh
-      {Intrinsic::ppc_altivec_vmuleuw, 91643}, // __builtin_altivec_vmuleuw
-      {Intrinsic::ppc_altivec_vmulosb, 91669}, // __builtin_altivec_vmulosb
-      {Intrinsic::ppc_altivec_vmulosh, 91695}, // __builtin_altivec_vmulosh
-      {Intrinsic::ppc_altivec_vmulosw, 91721}, // __builtin_altivec_vmulosw
-      {Intrinsic::ppc_altivec_vmuloub, 91747}, // __builtin_altivec_vmuloub
-      {Intrinsic::ppc_altivec_vmulouh, 91773}, // __builtin_altivec_vmulouh
-      {Intrinsic::ppc_altivec_vmulouw, 91799}, // __builtin_altivec_vmulouw
-      {Intrinsic::ppc_altivec_vnmsubfp, 91825}, // __builtin_altivec_vnmsubfp
-      {Intrinsic::ppc_altivec_vperm, 91852}, // __builtin_altivec_vperm_4si
-      {Intrinsic::ppc_altivec_vpkpx, 91880}, // __builtin_altivec_vpkpx
-      {Intrinsic::ppc_altivec_vpksdss, 91904}, // __builtin_altivec_vpksdss
-      {Intrinsic::ppc_altivec_vpksdus, 91930}, // __builtin_altivec_vpksdus
-      {Intrinsic::ppc_altivec_vpkshss, 91956}, // __builtin_altivec_vpkshss
-      {Intrinsic::ppc_altivec_vpkshus, 91982}, // __builtin_altivec_vpkshus
-      {Intrinsic::ppc_altivec_vpkswss, 92008}, // __builtin_altivec_vpkswss
-      {Intrinsic::ppc_altivec_vpkswus, 92034}, // __builtin_altivec_vpkswus
-      {Intrinsic::ppc_altivec_vpkudus, 92060}, // __builtin_altivec_vpkudus
-      {Intrinsic::ppc_altivec_vpkuhus, 92086}, // __builtin_altivec_vpkuhus
-      {Intrinsic::ppc_altivec_vpkuwus, 92112}, // __builtin_altivec_vpkuwus
-      {Intrinsic::ppc_altivec_vprtybd, 92138}, // __builtin_altivec_vprtybd
-      {Intrinsic::ppc_altivec_vprtybq, 92164}, // __builtin_altivec_vprtybq
-      {Intrinsic::ppc_altivec_vprtybw, 92190}, // __builtin_altivec_vprtybw
-      {Intrinsic::ppc_altivec_vrefp, 92216}, // __builtin_altivec_vrefp
-      {Intrinsic::ppc_altivec_vrfim, 92240}, // __builtin_altivec_vrfim
-      {Intrinsic::ppc_altivec_vrfin, 92264}, // __builtin_altivec_vrfin
-      {Intrinsic::ppc_altivec_vrfip, 92288}, // __builtin_altivec_vrfip
-      {Intrinsic::ppc_altivec_vrfiz, 92312}, // __builtin_altivec_vrfiz
-      {Intrinsic::ppc_altivec_vrlb, 92336}, // __builtin_altivec_vrlb
-      {Intrinsic::ppc_altivec_vrld, 92359}, // __builtin_altivec_vrld
-      {Intrinsic::ppc_altivec_vrldmi, 92382}, // __builtin_altivec_vrldmi
-      {Intrinsic::ppc_altivec_vrldnm, 92407}, // __builtin_altivec_vrldnm
-      {Intrinsic::ppc_altivec_vrlh, 92432}, // __builtin_altivec_vrlh
-      {Intrinsic::ppc_altivec_vrlw, 92455}, // __builtin_altivec_vrlw
-      {Intrinsic::ppc_altivec_vrlwmi, 92478}, // __builtin_altivec_vrlwmi
-      {Intrinsic::ppc_altivec_vrlwnm, 92503}, // __builtin_altivec_vrlwnm
-      {Intrinsic::ppc_altivec_vrsqrtefp, 92528}, // __builtin_altivec_vrsqrtefp
-      {Intrinsic::ppc_altivec_vsel, 92556}, // __builtin_altivec_vsel_4si
-      {Intrinsic::ppc_altivec_vsl, 92583}, // __builtin_altivec_vsl
-      {Intrinsic::ppc_altivec_vslb, 92605}, // __builtin_altivec_vslb
-      {Intrinsic::ppc_altivec_vslh, 92628}, // __builtin_altivec_vslh
-      {Intrinsic::ppc_altivec_vslo, 92651}, // __builtin_altivec_vslo
-      {Intrinsic::ppc_altivec_vslv, 92674}, // __builtin_altivec_vslv
-      {Intrinsic::ppc_altivec_vslw, 92697}, // __builtin_altivec_vslw
-      {Intrinsic::ppc_altivec_vsr, 92720}, // __builtin_altivec_vsr
-      {Intrinsic::ppc_altivec_vsrab, 92742}, // __builtin_altivec_vsrab
-      {Intrinsic::ppc_altivec_vsrah, 92766}, // __builtin_altivec_vsrah
-      {Intrinsic::ppc_altivec_vsraw, 92790}, // __builtin_altivec_vsraw
-      {Intrinsic::ppc_altivec_vsrb, 92814}, // __builtin_altivec_vsrb
-      {Intrinsic::ppc_altivec_vsrh, 92837}, // __builtin_altivec_vsrh
-      {Intrinsic::ppc_altivec_vsro, 92860}, // __builtin_altivec_vsro
-      {Intrinsic::ppc_altivec_vsrv, 92883}, // __builtin_altivec_vsrv
-      {Intrinsic::ppc_altivec_vsrw, 92906}, // __builtin_altivec_vsrw
-      {Intrinsic::ppc_altivec_vsubcuq, 92929}, // __builtin_altivec_vsubcuq
-      {Intrinsic::ppc_altivec_vsubcuw, 92955}, // __builtin_altivec_vsubcuw
-      {Intrinsic::ppc_altivec_vsubecuq, 92981}, // __builtin_altivec_vsubecuq
-      {Intrinsic::ppc_altivec_vsubeuqm, 93008}, // __builtin_altivec_vsubeuqm
-      {Intrinsic::ppc_altivec_vsubsbs, 93035}, // __builtin_altivec_vsubsbs
-      {Intrinsic::ppc_altivec_vsubshs, 93061}, // __builtin_altivec_vsubshs
-      {Intrinsic::ppc_altivec_vsubsws, 93087}, // __builtin_altivec_vsubsws
-      {Intrinsic::ppc_altivec_vsububs, 93113}, // __builtin_altivec_vsububs
-      {Intrinsic::ppc_altivec_vsubuhs, 93139}, // __builtin_altivec_vsubuhs
-      {Intrinsic::ppc_altivec_vsubuws, 93165}, // __builtin_altivec_vsubuws
-      {Intrinsic::ppc_altivec_vsum2sws, 93191}, // __builtin_altivec_vsum2sws
-      {Intrinsic::ppc_altivec_vsum4sbs, 93218}, // __builtin_altivec_vsum4sbs
-      {Intrinsic::ppc_altivec_vsum4shs, 93245}, // __builtin_altivec_vsum4shs
-      {Intrinsic::ppc_altivec_vsum4ubs, 93272}, // __builtin_altivec_vsum4ubs
-      {Intrinsic::ppc_altivec_vsumsws, 93299}, // __builtin_altivec_vsumsws
-      {Intrinsic::ppc_altivec_vupkhpx, 93325}, // __builtin_altivec_vupkhpx
-      {Intrinsic::ppc_altivec_vupkhsb, 93351}, // __builtin_altivec_vupkhsb
-      {Intrinsic::ppc_altivec_vupkhsh, 93377}, // __builtin_altivec_vupkhsh
-      {Intrinsic::ppc_altivec_vupkhsw, 93403}, // __builtin_altivec_vupkhsw
-      {Intrinsic::ppc_altivec_vupklpx, 93429}, // __builtin_altivec_vupklpx
-      {Intrinsic::ppc_altivec_vupklsb, 93455}, // __builtin_altivec_vupklsb
-      {Intrinsic::ppc_altivec_vupklsh, 93481}, // __builtin_altivec_vupklsh
-      {Intrinsic::ppc_altivec_vupklsw, 93507}, // __builtin_altivec_vupklsw
-      {Intrinsic::ppc_bpermd, 93533}, // __builtin_bpermd
-      {Intrinsic::ppc_dcbf, 93550}, // __builtin_dcbf
-      {Intrinsic::ppc_divde, 93565}, // __builtin_divde
-      {Intrinsic::ppc_divdeu, 93581}, // __builtin_divdeu
-      {Intrinsic::ppc_divf128_round_to_odd, 93598}, // __builtin_divf128_round_to_odd
-      {Intrinsic::ppc_divwe, 93629}, // __builtin_divwe
-      {Intrinsic::ppc_divweu, 93645}, // __builtin_divweu
-      {Intrinsic::ppc_fmaf128_round_to_odd, 93662}, // __builtin_fmaf128_round_to_odd
-      {Intrinsic::ppc_get_texasr, 93693}, // __builtin_get_texasr
-      {Intrinsic::ppc_get_texasru, 93714}, // __builtin_get_texasru
-      {Intrinsic::ppc_get_tfhar, 93736}, // __builtin_get_tfhar
-      {Intrinsic::ppc_get_tfiar, 93756}, // __builtin_get_tfiar
-      {Intrinsic::ppc_mulf128_round_to_odd, 93776}, // __builtin_mulf128_round_to_odd
-      {Intrinsic::ppc_qpx_qvfabs, 93807}, // __builtin_qpx_qvfabs
-      {Intrinsic::ppc_qpx_qvfadd, 93828}, // __builtin_qpx_qvfadd
-      {Intrinsic::ppc_qpx_qvfadds, 93849}, // __builtin_qpx_qvfadds
-      {Intrinsic::ppc_qpx_qvfcfid, 93871}, // __builtin_qpx_qvfcfid
-      {Intrinsic::ppc_qpx_qvfcfids, 93893}, // __builtin_qpx_qvfcfids
-      {Intrinsic::ppc_qpx_qvfcfidu, 93916}, // __builtin_qpx_qvfcfidu
-      {Intrinsic::ppc_qpx_qvfcfidus, 93939}, // __builtin_qpx_qvfcfidus
-      {Intrinsic::ppc_qpx_qvfcmpeq, 93963}, // __builtin_qpx_qvfcmpeq
-      {Intrinsic::ppc_qpx_qvfcmpgt, 93986}, // __builtin_qpx_qvfcmpgt
-      {Intrinsic::ppc_qpx_qvfcmplt, 94009}, // __builtin_qpx_qvfcmplt
-      {Intrinsic::ppc_qpx_qvfcpsgn, 94032}, // __builtin_qpx_qvfcpsgn
-      {Intrinsic::ppc_qpx_qvfctid, 94055}, // __builtin_qpx_qvfctid
-      {Intrinsic::ppc_qpx_qvfctidu, 94077}, // __builtin_qpx_qvfctidu
-      {Intrinsic::ppc_qpx_qvfctiduz, 94100}, // __builtin_qpx_qvfctiduz
-      {Intrinsic::ppc_qpx_qvfctidz, 94124}, // __builtin_qpx_qvfctidz
-      {Intrinsic::ppc_qpx_qvfctiw, 94147}, // __builtin_qpx_qvfctiw
-      {Intrinsic::ppc_qpx_qvfctiwu, 94169}, // __builtin_qpx_qvfctiwu
-      {Intrinsic::ppc_qpx_qvfctiwuz, 94192}, // __builtin_qpx_qvfctiwuz
-      {Intrinsic::ppc_qpx_qvfctiwz, 94216}, // __builtin_qpx_qvfctiwz
-      {Intrinsic::ppc_qpx_qvflogical, 94239}, // __builtin_qpx_qvflogical
-      {Intrinsic::ppc_qpx_qvfmadd, 94264}, // __builtin_qpx_qvfmadd
-      {Intrinsic::ppc_qpx_qvfmadds, 94286}, // __builtin_qpx_qvfmadds
-      {Intrinsic::ppc_qpx_qvfmsub, 94309}, // __builtin_qpx_qvfmsub
-      {Intrinsic::ppc_qpx_qvfmsubs, 94331}, // __builtin_qpx_qvfmsubs
-      {Intrinsic::ppc_qpx_qvfmul, 94354}, // __builtin_qpx_qvfmul
-      {Intrinsic::ppc_qpx_qvfmuls, 94375}, // __builtin_qpx_qvfmuls
-      {Intrinsic::ppc_qpx_qvfnabs, 94397}, // __builtin_qpx_qvfnabs
-      {Intrinsic::ppc_qpx_qvfneg, 94419}, // __builtin_qpx_qvfneg
-      {Intrinsic::ppc_qpx_qvfnmadd, 94440}, // __builtin_qpx_qvfnmadd
-      {Intrinsic::ppc_qpx_qvfnmadds, 94463}, // __builtin_qpx_qvfnmadds
-      {Intrinsic::ppc_qpx_qvfnmsub, 94487}, // __builtin_qpx_qvfnmsub
-      {Intrinsic::ppc_qpx_qvfnmsubs, 94510}, // __builtin_qpx_qvfnmsubs
-      {Intrinsic::ppc_qpx_qvfperm, 94534}, // __builtin_qpx_qvfperm
-      {Intrinsic::ppc_qpx_qvfre, 94556}, // __builtin_qpx_qvfre
-      {Intrinsic::ppc_qpx_qvfres, 94576}, // __builtin_qpx_qvfres
-      {Intrinsic::ppc_qpx_qvfrim, 94597}, // __builtin_qpx_qvfrim
-      {Intrinsic::ppc_qpx_qvfrin, 94618}, // __builtin_qpx_qvfrin
-      {Intrinsic::ppc_qpx_qvfrip, 94639}, // __builtin_qpx_qvfrip
-      {Intrinsic::ppc_qpx_qvfriz, 94660}, // __builtin_qpx_qvfriz
-      {Intrinsic::ppc_qpx_qvfrsp, 94681}, // __builtin_qpx_qvfrsp
-      {Intrinsic::ppc_qpx_qvfrsqrte, 94702}, // __builtin_qpx_qvfrsqrte
-      {Intrinsic::ppc_qpx_qvfrsqrtes, 94726}, // __builtin_qpx_qvfrsqrtes
-      {Intrinsic::ppc_qpx_qvfsel, 94751}, // __builtin_qpx_qvfsel
-      {Intrinsic::ppc_qpx_qvfsub, 94772}, // __builtin_qpx_qvfsub
-      {Intrinsic::ppc_qpx_qvfsubs, 94793}, // __builtin_qpx_qvfsubs
-      {Intrinsic::ppc_qpx_qvftstnan, 94815}, // __builtin_qpx_qvftstnan
-      {Intrinsic::ppc_qpx_qvfxmadd, 94839}, // __builtin_qpx_qvfxmadd
-      {Intrinsic::ppc_qpx_qvfxmadds, 94862}, // __builtin_qpx_qvfxmadds
-      {Intrinsic::ppc_qpx_qvfxmul, 94886}, // __builtin_qpx_qvfxmul
-      {Intrinsic::ppc_qpx_qvfxmuls, 94908}, // __builtin_qpx_qvfxmuls
-      {Intrinsic::ppc_qpx_qvfxxcpnmadd, 94931}, // __builtin_qpx_qvfxxcpnmadd
-      {Intrinsic::ppc_qpx_qvfxxcpnmadds, 94958}, // __builtin_qpx_qvfxxcpnmadds
-      {Intrinsic::ppc_qpx_qvfxxmadd, 94986}, // __builtin_qpx_qvfxxmadd
-      {Intrinsic::ppc_qpx_qvfxxmadds, 95010}, // __builtin_qpx_qvfxxmadds
-      {Intrinsic::ppc_qpx_qvfxxnpmadd, 95035}, // __builtin_qpx_qvfxxnpmadd
-      {Intrinsic::ppc_qpx_qvfxxnpmadds, 95061}, // __builtin_qpx_qvfxxnpmadds
-      {Intrinsic::ppc_qpx_qvgpci, 95088}, // __builtin_qpx_qvgpci
-      {Intrinsic::ppc_qpx_qvlfcd, 95109}, // __builtin_qpx_qvlfcd
-      {Intrinsic::ppc_qpx_qvlfcda, 95130}, // __builtin_qpx_qvlfcda
-      {Intrinsic::ppc_qpx_qvlfcs, 95152}, // __builtin_qpx_qvlfcs
-      {Intrinsic::ppc_qpx_qvlfcsa, 95173}, // __builtin_qpx_qvlfcsa
-      {Intrinsic::ppc_qpx_qvlfd, 95195}, // __builtin_qpx_qvlfd
-      {Intrinsic::ppc_qpx_qvlfda, 95215}, // __builtin_qpx_qvlfda
-      {Intrinsic::ppc_qpx_qvlfiwa, 95236}, // __builtin_qpx_qvlfiwa
-      {Intrinsic::ppc_qpx_qvlfiwaa, 95258}, // __builtin_qpx_qvlfiwaa
-      {Intrinsic::ppc_qpx_qvlfiwz, 95281}, // __builtin_qpx_qvlfiwz
-      {Intrinsic::ppc_qpx_qvlfiwza, 95303}, // __builtin_qpx_qvlfiwza
-      {Intrinsic::ppc_qpx_qvlfs, 95326}, // __builtin_qpx_qvlfs
-      {Intrinsic::ppc_qpx_qvlfsa, 95346}, // __builtin_qpx_qvlfsa
-      {Intrinsic::ppc_qpx_qvlpcld, 95367}, // __builtin_qpx_qvlpcld
-      {Intrinsic::ppc_qpx_qvlpcls, 95389}, // __builtin_qpx_qvlpcls
-      {Intrinsic::ppc_qpx_qvlpcrd, 95411}, // __builtin_qpx_qvlpcrd
-      {Intrinsic::ppc_qpx_qvlpcrs, 95433}, // __builtin_qpx_qvlpcrs
-      {Intrinsic::ppc_qpx_qvstfcd, 95455}, // __builtin_qpx_qvstfcd
-      {Intrinsic::ppc_qpx_qvstfcda, 95477}, // __builtin_qpx_qvstfcda
-      {Intrinsic::ppc_qpx_qvstfcs, 95500}, // __builtin_qpx_qvstfcs
-      {Intrinsic::ppc_qpx_qvstfcsa, 95522}, // __builtin_qpx_qvstfcsa
-      {Intrinsic::ppc_qpx_qvstfd, 95545}, // __builtin_qpx_qvstfd
-      {Intrinsic::ppc_qpx_qvstfda, 95566}, // __builtin_qpx_qvstfda
-      {Intrinsic::ppc_qpx_qvstfiw, 95588}, // __builtin_qpx_qvstfiw
-      {Intrinsic::ppc_qpx_qvstfiwa, 95610}, // __builtin_qpx_qvstfiwa
-      {Intrinsic::ppc_qpx_qvstfs, 95633}, // __builtin_qpx_qvstfs
-      {Intrinsic::ppc_qpx_qvstfsa, 95654}, // __builtin_qpx_qvstfsa
-      {Intrinsic::ppc_set_texasr, 95745}, // __builtin_set_texasr
-      {Intrinsic::ppc_set_texasru, 95766}, // __builtin_set_texasru
-      {Intrinsic::ppc_set_tfhar, 95788}, // __builtin_set_tfhar
-      {Intrinsic::ppc_set_tfiar, 95808}, // __builtin_set_tfiar
-      {Intrinsic::ppc_setrnd, 95828}, // __builtin_setrnd
-      {Intrinsic::ppc_sqrtf128_round_to_odd, 95845}, // __builtin_sqrtf128_round_to_odd
-      {Intrinsic::ppc_subf128_round_to_odd, 95877}, // __builtin_subf128_round_to_odd
-      {Intrinsic::ppc_tabort, 95908}, // __builtin_tabort
-      {Intrinsic::ppc_tabortdc, 95925}, // __builtin_tabortdc
-      {Intrinsic::ppc_tabortdci, 95944}, // __builtin_tabortdci
-      {Intrinsic::ppc_tabortwc, 95964}, // __builtin_tabortwc
-      {Intrinsic::ppc_tabortwci, 95983}, // __builtin_tabortwci
-      {Intrinsic::ppc_tbegin, 96003}, // __builtin_tbegin
-      {Intrinsic::ppc_tcheck, 96020}, // __builtin_tcheck
-      {Intrinsic::ppc_tend, 96037}, // __builtin_tend
-      {Intrinsic::ppc_tendall, 96052}, // __builtin_tendall
-      {Intrinsic::ppc_trechkpt, 96070}, // __builtin_trechkpt
-      {Intrinsic::ppc_treclaim, 96089}, // __builtin_treclaim
-      {Intrinsic::ppc_tresume, 96108}, // __builtin_tresume
-      {Intrinsic::ppc_truncf128_round_to_odd, 96126}, // __builtin_truncf128_round_to_odd
-      {Intrinsic::ppc_tsr, 96159}, // __builtin_tsr
-      {Intrinsic::ppc_tsuspend, 96173}, // __builtin_tsuspend
-      {Intrinsic::ppc_ttest, 96192}, // __builtin_ttest
-      {Intrinsic::ppc_scalar_extract_expq, 95676}, // __builtin_vsx_scalar_extract_expq
-      {Intrinsic::ppc_scalar_insert_exp_qp, 95710}, // __builtin_vsx_scalar_insert_exp_qp
-      {Intrinsic::ppc_vsx_xsmaxdp, 96208}, // __builtin_vsx_xsmaxdp
-      {Intrinsic::ppc_vsx_xsmindp, 96230}, // __builtin_vsx_xsmindp
-      {Intrinsic::ppc_vsx_xvcmpeqdp, 96252}, // __builtin_vsx_xvcmpeqdp
-      {Intrinsic::ppc_vsx_xvcmpeqdp_p, 96276}, // __builtin_vsx_xvcmpeqdp_p
-      {Intrinsic::ppc_vsx_xvcmpeqsp, 96302}, // __builtin_vsx_xvcmpeqsp
-      {Intrinsic::ppc_vsx_xvcmpeqsp_p, 96326}, // __builtin_vsx_xvcmpeqsp_p
-      {Intrinsic::ppc_vsx_xvcmpgedp, 96352}, // __builtin_vsx_xvcmpgedp
-      {Intrinsic::ppc_vsx_xvcmpgedp_p, 96376}, // __builtin_vsx_xvcmpgedp_p
-      {Intrinsic::ppc_vsx_xvcmpgesp, 96402}, // __builtin_vsx_xvcmpgesp
-      {Intrinsic::ppc_vsx_xvcmpgesp_p, 96426}, // __builtin_vsx_xvcmpgesp_p
-      {Intrinsic::ppc_vsx_xvcmpgtdp, 96452}, // __builtin_vsx_xvcmpgtdp
-      {Intrinsic::ppc_vsx_xvcmpgtdp_p, 96476}, // __builtin_vsx_xvcmpgtdp_p
-      {Intrinsic::ppc_vsx_xvcmpgtsp, 96502}, // __builtin_vsx_xvcmpgtsp
-      {Intrinsic::ppc_vsx_xvcmpgtsp_p, 96526}, // __builtin_vsx_xvcmpgtsp_p
-      {Intrinsic::ppc_vsx_xvcvdpsp, 96552}, // __builtin_vsx_xvcvdpsp
-      {Intrinsic::ppc_vsx_xvcvdpsxws, 96575}, // __builtin_vsx_xvcvdpsxws
-      {Intrinsic::ppc_vsx_xvcvdpuxws, 96600}, // __builtin_vsx_xvcvdpuxws
-      {Intrinsic::ppc_vsx_xvcvhpsp, 96625}, // __builtin_vsx_xvcvhpsp
-      {Intrinsic::ppc_vsx_xvcvspdp, 96648}, // __builtin_vsx_xvcvspdp
-      {Intrinsic::ppc_vsx_xvcvsphp, 96671}, // __builtin_vsx_xvcvsphp
-      {Intrinsic::ppc_vsx_xvcvsxdsp, 96694}, // __builtin_vsx_xvcvsxdsp
-      {Intrinsic::ppc_vsx_xvcvsxwdp, 96718}, // __builtin_vsx_xvcvsxwdp
-      {Intrinsic::ppc_vsx_xvcvuxdsp, 96742}, // __builtin_vsx_xvcvuxdsp
-      {Intrinsic::ppc_vsx_xvcvuxwdp, 96766}, // __builtin_vsx_xvcvuxwdp
-      {Intrinsic::ppc_vsx_xvdivdp, 96790}, // __builtin_vsx_xvdivdp
-      {Intrinsic::ppc_vsx_xvdivsp, 96812}, // __builtin_vsx_xvdivsp
-      {Intrinsic::ppc_vsx_xviexpdp, 96834}, // __builtin_vsx_xviexpdp
-      {Intrinsic::ppc_vsx_xviexpsp, 96857}, // __builtin_vsx_xviexpsp
-      {Intrinsic::ppc_vsx_xvmaxdp, 96880}, // __builtin_vsx_xvmaxdp
-      {Intrinsic::ppc_vsx_xvmaxsp, 96902}, // __builtin_vsx_xvmaxsp
-      {Intrinsic::ppc_vsx_xvmindp, 96924}, // __builtin_vsx_xvmindp
-      {Intrinsic::ppc_vsx_xvminsp, 96946}, // __builtin_vsx_xvminsp
-      {Intrinsic::ppc_vsx_xvredp, 96968}, // __builtin_vsx_xvredp
-      {Intrinsic::ppc_vsx_xvresp, 96989}, // __builtin_vsx_xvresp
-      {Intrinsic::ppc_vsx_xvrsqrtedp, 97010}, // __builtin_vsx_xvrsqrtedp
-      {Intrinsic::ppc_vsx_xvrsqrtesp, 97035}, // __builtin_vsx_xvrsqrtesp
-      {Intrinsic::ppc_vsx_xvtstdcdp, 97060}, // __builtin_vsx_xvtstdcdp
-      {Intrinsic::ppc_vsx_xvtstdcsp, 97084}, // __builtin_vsx_xvtstdcsp
-      {Intrinsic::ppc_vsx_xvxexpdp, 97108}, // __builtin_vsx_xvxexpdp
-      {Intrinsic::ppc_vsx_xvxexpsp, 97131}, // __builtin_vsx_xvxexpsp
-      {Intrinsic::ppc_vsx_xvxsigdp, 97154}, // __builtin_vsx_xvxsigdp
-      {Intrinsic::ppc_vsx_xvxsigsp, 97177}, // __builtin_vsx_xvxsigsp
-      {Intrinsic::ppc_vsx_xxextractuw, 97200}, // __builtin_vsx_xxextractuw
-      {Intrinsic::ppc_vsx_xxinsertw, 97226}, // __builtin_vsx_xxinsertw
-      {Intrinsic::ppc_vsx_xxleqv, 97250}, // __builtin_vsx_xxleqv
+      {Intrinsic::ppc_addf128_round_to_odd, 83508}, // __builtin_addf128_round_to_odd
+      {Intrinsic::ppc_altivec_crypto_vcipher, 83539}, // __builtin_altivec_crypto_vcipher
+      {Intrinsic::ppc_altivec_crypto_vcipherlast, 83572}, // __builtin_altivec_crypto_vcipherlast
+      {Intrinsic::ppc_altivec_crypto_vncipher, 83609}, // __builtin_altivec_crypto_vncipher
+      {Intrinsic::ppc_altivec_crypto_vncipherlast, 83643}, // __builtin_altivec_crypto_vncipherlast
+      {Intrinsic::ppc_altivec_crypto_vpermxor, 83681}, // __builtin_altivec_crypto_vpermxor
+      {Intrinsic::ppc_altivec_crypto_vpmsumb, 83715}, // __builtin_altivec_crypto_vpmsumb
+      {Intrinsic::ppc_altivec_crypto_vpmsumd, 83748}, // __builtin_altivec_crypto_vpmsumd
+      {Intrinsic::ppc_altivec_crypto_vpmsumh, 83781}, // __builtin_altivec_crypto_vpmsumh
+      {Intrinsic::ppc_altivec_crypto_vpmsumw, 83814}, // __builtin_altivec_crypto_vpmsumw
+      {Intrinsic::ppc_altivec_crypto_vsbox, 83847}, // __builtin_altivec_crypto_vsbox
+      {Intrinsic::ppc_altivec_crypto_vshasigmad, 83878}, // __builtin_altivec_crypto_vshasigmad
+      {Intrinsic::ppc_altivec_crypto_vshasigmaw, 83914}, // __builtin_altivec_crypto_vshasigmaw
+      {Intrinsic::ppc_altivec_dss, 83950}, // __builtin_altivec_dss
+      {Intrinsic::ppc_altivec_dssall, 83972}, // __builtin_altivec_dssall
+      {Intrinsic::ppc_altivec_dst, 83997}, // __builtin_altivec_dst
+      {Intrinsic::ppc_altivec_dstst, 84019}, // __builtin_altivec_dstst
+      {Intrinsic::ppc_altivec_dststt, 84043}, // __builtin_altivec_dststt
+      {Intrinsic::ppc_altivec_dstt, 84068}, // __builtin_altivec_dstt
+      {Intrinsic::ppc_altivec_mfvscr, 84091}, // __builtin_altivec_mfvscr
+      {Intrinsic::ppc_altivec_mtvscr, 84116}, // __builtin_altivec_mtvscr
+      {Intrinsic::ppc_altivec_mtvsrbm, 84141}, // __builtin_altivec_mtvsrbm
+      {Intrinsic::ppc_altivec_mtvsrdm, 84167}, // __builtin_altivec_mtvsrdm
+      {Intrinsic::ppc_altivec_mtvsrhm, 84193}, // __builtin_altivec_mtvsrhm
+      {Intrinsic::ppc_altivec_mtvsrqm, 84219}, // __builtin_altivec_mtvsrqm
+      {Intrinsic::ppc_altivec_mtvsrwm, 84245}, // __builtin_altivec_mtvsrwm
+      {Intrinsic::ppc_altivec_vabsdub, 84271}, // __builtin_altivec_vabsdub
+      {Intrinsic::ppc_altivec_vabsduh, 84297}, // __builtin_altivec_vabsduh
+      {Intrinsic::ppc_altivec_vabsduw, 84323}, // __builtin_altivec_vabsduw
+      {Intrinsic::ppc_altivec_vaddcuq, 84349}, // __builtin_altivec_vaddcuq
+      {Intrinsic::ppc_altivec_vaddcuw, 84375}, // __builtin_altivec_vaddcuw
+      {Intrinsic::ppc_altivec_vaddecuq, 84401}, // __builtin_altivec_vaddecuq
+      {Intrinsic::ppc_altivec_vaddeuqm, 84428}, // __builtin_altivec_vaddeuqm
+      {Intrinsic::ppc_altivec_vaddsbs, 84455}, // __builtin_altivec_vaddsbs
+      {Intrinsic::ppc_altivec_vaddshs, 84481}, // __builtin_altivec_vaddshs
+      {Intrinsic::ppc_altivec_vaddsws, 84507}, // __builtin_altivec_vaddsws
+      {Intrinsic::ppc_altivec_vaddubs, 84533}, // __builtin_altivec_vaddubs
+      {Intrinsic::ppc_altivec_vadduhs, 84559}, // __builtin_altivec_vadduhs
+      {Intrinsic::ppc_altivec_vadduws, 84585}, // __builtin_altivec_vadduws
+      {Intrinsic::ppc_altivec_vavgsb, 84611}, // __builtin_altivec_vavgsb
+      {Intrinsic::ppc_altivec_vavgsh, 84636}, // __builtin_altivec_vavgsh
+      {Intrinsic::ppc_altivec_vavgsw, 84661}, // __builtin_altivec_vavgsw
+      {Intrinsic::ppc_altivec_vavgub, 84686}, // __builtin_altivec_vavgub
+      {Intrinsic::ppc_altivec_vavguh, 84711}, // __builtin_altivec_vavguh
+      {Intrinsic::ppc_altivec_vavguw, 84736}, // __builtin_altivec_vavguw
+      {Intrinsic::ppc_altivec_vbpermq, 84761}, // __builtin_altivec_vbpermq
+      {Intrinsic::ppc_altivec_vcfsx, 84787}, // __builtin_altivec_vcfsx
+      {Intrinsic::ppc_altivec_vcfuged, 84811}, // __builtin_altivec_vcfuged
+      {Intrinsic::ppc_altivec_vcfux, 84837}, // __builtin_altivec_vcfux
+      {Intrinsic::ppc_altivec_vclrlb, 84861}, // __builtin_altivec_vclrlb
+      {Intrinsic::ppc_altivec_vclrrb, 84886}, // __builtin_altivec_vclrrb
+      {Intrinsic::ppc_altivec_vclzdm, 84911}, // __builtin_altivec_vclzdm
+      {Intrinsic::ppc_altivec_vclzlsbb, 84936}, // __builtin_altivec_vclzlsbb
+      {Intrinsic::ppc_altivec_vcmpbfp, 84963}, // __builtin_altivec_vcmpbfp
+      {Intrinsic::ppc_altivec_vcmpbfp_p, 84989}, // __builtin_altivec_vcmpbfp_p
+      {Intrinsic::ppc_altivec_vcmpeqfp, 85017}, // __builtin_altivec_vcmpeqfp
+      {Intrinsic::ppc_altivec_vcmpeqfp_p, 85044}, // __builtin_altivec_vcmpeqfp_p
+      {Intrinsic::ppc_altivec_vcmpequb, 85073}, // __builtin_altivec_vcmpequb
+      {Intrinsic::ppc_altivec_vcmpequb_p, 85100}, // __builtin_altivec_vcmpequb_p
+      {Intrinsic::ppc_altivec_vcmpequd, 85129}, // __builtin_altivec_vcmpequd
+      {Intrinsic::ppc_altivec_vcmpequd_p, 85156}, // __builtin_altivec_vcmpequd_p
+      {Intrinsic::ppc_altivec_vcmpequh, 85185}, // __builtin_altivec_vcmpequh
+      {Intrinsic::ppc_altivec_vcmpequh_p, 85212}, // __builtin_altivec_vcmpequh_p
+      {Intrinsic::ppc_altivec_vcmpequq, 85241}, // __builtin_altivec_vcmpequq
+      {Intrinsic::ppc_altivec_vcmpequq_p, 85268}, // __builtin_altivec_vcmpequq_p
+      {Intrinsic::ppc_altivec_vcmpequw, 85297}, // __builtin_altivec_vcmpequw
+      {Intrinsic::ppc_altivec_vcmpequw_p, 85324}, // __builtin_altivec_vcmpequw_p
+      {Intrinsic::ppc_altivec_vcmpgefp, 85353}, // __builtin_altivec_vcmpgefp
+      {Intrinsic::ppc_altivec_vcmpgefp_p, 85380}, // __builtin_altivec_vcmpgefp_p
+      {Intrinsic::ppc_altivec_vcmpgtfp, 85409}, // __builtin_altivec_vcmpgtfp
+      {Intrinsic::ppc_altivec_vcmpgtfp_p, 85436}, // __builtin_altivec_vcmpgtfp_p
+      {Intrinsic::ppc_altivec_vcmpgtsb, 85465}, // __builtin_altivec_vcmpgtsb
+      {Intrinsic::ppc_altivec_vcmpgtsb_p, 85492}, // __builtin_altivec_vcmpgtsb_p
+      {Intrinsic::ppc_altivec_vcmpgtsd, 85521}, // __builtin_altivec_vcmpgtsd
+      {Intrinsic::ppc_altivec_vcmpgtsd_p, 85548}, // __builtin_altivec_vcmpgtsd_p
+      {Intrinsic::ppc_altivec_vcmpgtsh, 85577}, // __builtin_altivec_vcmpgtsh
+      {Intrinsic::ppc_altivec_vcmpgtsh_p, 85604}, // __builtin_altivec_vcmpgtsh_p
+      {Intrinsic::ppc_altivec_vcmpgtsq, 85633}, // __builtin_altivec_vcmpgtsq
+      {Intrinsic::ppc_altivec_vcmpgtsq_p, 85660}, // __builtin_altivec_vcmpgtsq_p
+      {Intrinsic::ppc_altivec_vcmpgtsw, 85689}, // __builtin_altivec_vcmpgtsw
+      {Intrinsic::ppc_altivec_vcmpgtsw_p, 85716}, // __builtin_altivec_vcmpgtsw_p
+      {Intrinsic::ppc_altivec_vcmpgtub, 85745}, // __builtin_altivec_vcmpgtub
+      {Intrinsic::ppc_altivec_vcmpgtub_p, 85772}, // __builtin_altivec_vcmpgtub_p
+      {Intrinsic::ppc_altivec_vcmpgtud, 85801}, // __builtin_altivec_vcmpgtud
+      {Intrinsic::ppc_altivec_vcmpgtud_p, 85828}, // __builtin_altivec_vcmpgtud_p
+      {Intrinsic::ppc_altivec_vcmpgtuh, 85857}, // __builtin_altivec_vcmpgtuh
+      {Intrinsic::ppc_altivec_vcmpgtuh_p, 85884}, // __builtin_altivec_vcmpgtuh_p
+      {Intrinsic::ppc_altivec_vcmpgtuq, 85913}, // __builtin_altivec_vcmpgtuq
+      {Intrinsic::ppc_altivec_vcmpgtuq_p, 85940}, // __builtin_altivec_vcmpgtuq_p
+      {Intrinsic::ppc_altivec_vcmpgtuw, 85969}, // __builtin_altivec_vcmpgtuw
+      {Intrinsic::ppc_altivec_vcmpgtuw_p, 85996}, // __builtin_altivec_vcmpgtuw_p
+      {Intrinsic::ppc_altivec_vcmpneb, 86025}, // __builtin_altivec_vcmpneb
+      {Intrinsic::ppc_altivec_vcmpneb_p, 86051}, // __builtin_altivec_vcmpneb_p
+      {Intrinsic::ppc_altivec_vcmpneh, 86079}, // __builtin_altivec_vcmpneh
+      {Intrinsic::ppc_altivec_vcmpneh_p, 86105}, // __builtin_altivec_vcmpneh_p
+      {Intrinsic::ppc_altivec_vcmpnew, 86133}, // __builtin_altivec_vcmpnew
+      {Intrinsic::ppc_altivec_vcmpnew_p, 86159}, // __builtin_altivec_vcmpnew_p
+      {Intrinsic::ppc_altivec_vcmpnezb, 86187}, // __builtin_altivec_vcmpnezb
+      {Intrinsic::ppc_altivec_vcmpnezb_p, 86214}, // __builtin_altivec_vcmpnezb_p
+      {Intrinsic::ppc_altivec_vcmpnezh, 86243}, // __builtin_altivec_vcmpnezh
+      {Intrinsic::ppc_altivec_vcmpnezh_p, 86270}, // __builtin_altivec_vcmpnezh_p
+      {Intrinsic::ppc_altivec_vcmpnezw, 86299}, // __builtin_altivec_vcmpnezw
+      {Intrinsic::ppc_altivec_vcmpnezw_p, 86326}, // __builtin_altivec_vcmpnezw_p
+      {Intrinsic::ppc_altivec_vcntmbb, 86355}, // __builtin_altivec_vcntmbb
+      {Intrinsic::ppc_altivec_vcntmbd, 86381}, // __builtin_altivec_vcntmbd
+      {Intrinsic::ppc_altivec_vcntmbh, 86407}, // __builtin_altivec_vcntmbh
+      {Intrinsic::ppc_altivec_vcntmbw, 86433}, // __builtin_altivec_vcntmbw
+      {Intrinsic::ppc_altivec_vctsxs, 86459}, // __builtin_altivec_vctsxs
+      {Intrinsic::ppc_altivec_vctuxs, 86484}, // __builtin_altivec_vctuxs
+      {Intrinsic::ppc_altivec_vctzdm, 86509}, // __builtin_altivec_vctzdm
+      {Intrinsic::ppc_altivec_vctzlsbb, 86534}, // __builtin_altivec_vctzlsbb
+      {Intrinsic::ppc_altivec_vdivesd, 86561}, // __builtin_altivec_vdivesd
+      {Intrinsic::ppc_altivec_vdivesq, 86587}, // __builtin_altivec_vdivesq
+      {Intrinsic::ppc_altivec_vdivesw, 86613}, // __builtin_altivec_vdivesw
+      {Intrinsic::ppc_altivec_vdiveud, 86639}, // __builtin_altivec_vdiveud
+      {Intrinsic::ppc_altivec_vdiveuq, 86665}, // __builtin_altivec_vdiveuq
+      {Intrinsic::ppc_altivec_vdiveuw, 86691}, // __builtin_altivec_vdiveuw
+      {Intrinsic::ppc_altivec_vexpandbm, 86717}, // __builtin_altivec_vexpandbm
+      {Intrinsic::ppc_altivec_vexpanddm, 86745}, // __builtin_altivec_vexpanddm
+      {Intrinsic::ppc_altivec_vexpandhm, 86773}, // __builtin_altivec_vexpandhm
+      {Intrinsic::ppc_altivec_vexpandqm, 86801}, // __builtin_altivec_vexpandqm
+      {Intrinsic::ppc_altivec_vexpandwm, 86829}, // __builtin_altivec_vexpandwm
+      {Intrinsic::ppc_altivec_vexptefp, 86857}, // __builtin_altivec_vexptefp
+      {Intrinsic::ppc_altivec_vextddvlx, 86884}, // __builtin_altivec_vextddvlx
+      {Intrinsic::ppc_altivec_vextddvrx, 86912}, // __builtin_altivec_vextddvrx
+      {Intrinsic::ppc_altivec_vextdubvlx, 86940}, // __builtin_altivec_vextdubvlx
+      {Intrinsic::ppc_altivec_vextdubvrx, 86969}, // __builtin_altivec_vextdubvrx
+      {Intrinsic::ppc_altivec_vextduhvlx, 86998}, // __builtin_altivec_vextduhvlx
+      {Intrinsic::ppc_altivec_vextduhvrx, 87027}, // __builtin_altivec_vextduhvrx
+      {Intrinsic::ppc_altivec_vextduwvlx, 87056}, // __builtin_altivec_vextduwvlx
+      {Intrinsic::ppc_altivec_vextduwvrx, 87085}, // __builtin_altivec_vextduwvrx
+      {Intrinsic::ppc_altivec_vextractbm, 87114}, // __builtin_altivec_vextractbm
+      {Intrinsic::ppc_altivec_vextractdm, 87143}, // __builtin_altivec_vextractdm
+      {Intrinsic::ppc_altivec_vextracthm, 87172}, // __builtin_altivec_vextracthm
+      {Intrinsic::ppc_altivec_vextractqm, 87201}, // __builtin_altivec_vextractqm
+      {Intrinsic::ppc_altivec_vextractwm, 87230}, // __builtin_altivec_vextractwm
+      {Intrinsic::ppc_altivec_vextsb2d, 87259}, // __builtin_altivec_vextsb2d
+      {Intrinsic::ppc_altivec_vextsb2w, 87286}, // __builtin_altivec_vextsb2w
+      {Intrinsic::ppc_altivec_vextsd2q, 87313}, // __builtin_altivec_vextsd2q
+      {Intrinsic::ppc_altivec_vextsh2d, 87340}, // __builtin_altivec_vextsh2d
+      {Intrinsic::ppc_altivec_vextsh2w, 87367}, // __builtin_altivec_vextsh2w
+      {Intrinsic::ppc_altivec_vextsw2d, 87394}, // __builtin_altivec_vextsw2d
+      {Intrinsic::ppc_altivec_vgbbd, 87421}, // __builtin_altivec_vgbbd
+      {Intrinsic::ppc_altivec_vgnb, 87445}, // __builtin_altivec_vgnb
+      {Intrinsic::ppc_altivec_vinsblx, 87468}, // __builtin_altivec_vinsblx
+      {Intrinsic::ppc_altivec_vinsbrx, 87494}, // __builtin_altivec_vinsbrx
+      {Intrinsic::ppc_altivec_vinsbvlx, 87520}, // __builtin_altivec_vinsbvlx
+      {Intrinsic::ppc_altivec_vinsbvrx, 87547}, // __builtin_altivec_vinsbvrx
+      {Intrinsic::ppc_altivec_vinsdlx, 87574}, // __builtin_altivec_vinsdlx
+      {Intrinsic::ppc_altivec_vinsdrx, 87600}, // __builtin_altivec_vinsdrx
+      {Intrinsic::ppc_altivec_vinshlx, 87626}, // __builtin_altivec_vinshlx
+      {Intrinsic::ppc_altivec_vinshrx, 87652}, // __builtin_altivec_vinshrx
+      {Intrinsic::ppc_altivec_vinshvlx, 87678}, // __builtin_altivec_vinshvlx
+      {Intrinsic::ppc_altivec_vinshvrx, 87705}, // __builtin_altivec_vinshvrx
+      {Intrinsic::ppc_altivec_vinswlx, 87732}, // __builtin_altivec_vinswlx
+      {Intrinsic::ppc_altivec_vinswrx, 87758}, // __builtin_altivec_vinswrx
+      {Intrinsic::ppc_altivec_vinswvlx, 87784}, // __builtin_altivec_vinswvlx
+      {Intrinsic::ppc_altivec_vinswvrx, 87811}, // __builtin_altivec_vinswvrx
+      {Intrinsic::ppc_altivec_vlogefp, 87838}, // __builtin_altivec_vlogefp
+      {Intrinsic::ppc_altivec_vmaddfp, 87864}, // __builtin_altivec_vmaddfp
+      {Intrinsic::ppc_altivec_vmaxfp, 87890}, // __builtin_altivec_vmaxfp
+      {Intrinsic::ppc_altivec_vmaxsb, 87915}, // __builtin_altivec_vmaxsb
+      {Intrinsic::ppc_altivec_vmaxsd, 87940}, // __builtin_altivec_vmaxsd
+      {Intrinsic::ppc_altivec_vmaxsh, 87965}, // __builtin_altivec_vmaxsh
+      {Intrinsic::ppc_altivec_vmaxsw, 87990}, // __builtin_altivec_vmaxsw
+      {Intrinsic::ppc_altivec_vmaxub, 88015}, // __builtin_altivec_vmaxub
+      {Intrinsic::ppc_altivec_vmaxud, 88040}, // __builtin_altivec_vmaxud
+      {Intrinsic::ppc_altivec_vmaxuh, 88065}, // __builtin_altivec_vmaxuh
+      {Intrinsic::ppc_altivec_vmaxuw, 88090}, // __builtin_altivec_vmaxuw
+      {Intrinsic::ppc_altivec_vmhaddshs, 88115}, // __builtin_altivec_vmhaddshs
+      {Intrinsic::ppc_altivec_vmhraddshs, 88143}, // __builtin_altivec_vmhraddshs
+      {Intrinsic::ppc_altivec_vminfp, 88172}, // __builtin_altivec_vminfp
+      {Intrinsic::ppc_altivec_vminsb, 88197}, // __builtin_altivec_vminsb
+      {Intrinsic::ppc_altivec_vminsd, 88222}, // __builtin_altivec_vminsd
+      {Intrinsic::ppc_altivec_vminsh, 88247}, // __builtin_altivec_vminsh
+      {Intrinsic::ppc_altivec_vminsw, 88272}, // __builtin_altivec_vminsw
+      {Intrinsic::ppc_altivec_vminub, 88297}, // __builtin_altivec_vminub
+      {Intrinsic::ppc_altivec_vminud, 88322}, // __builtin_altivec_vminud
+      {Intrinsic::ppc_altivec_vminuh, 88347}, // __builtin_altivec_vminuh
+      {Intrinsic::ppc_altivec_vminuw, 88372}, // __builtin_altivec_vminuw
+      {Intrinsic::ppc_altivec_vmladduhm, 88397}, // __builtin_altivec_vmladduhm
+      {Intrinsic::ppc_altivec_vmsumcud, 88425}, // __builtin_altivec_vmsumcud
+      {Intrinsic::ppc_altivec_vmsummbm, 88452}, // __builtin_altivec_vmsummbm
+      {Intrinsic::ppc_altivec_vmsumshm, 88479}, // __builtin_altivec_vmsumshm
+      {Intrinsic::ppc_altivec_vmsumshs, 88506}, // __builtin_altivec_vmsumshs
+      {Intrinsic::ppc_altivec_vmsumubm, 88533}, // __builtin_altivec_vmsumubm
+      {Intrinsic::ppc_altivec_vmsumudm, 88560}, // __builtin_altivec_vmsumudm
+      {Intrinsic::ppc_altivec_vmsumuhm, 88587}, // __builtin_altivec_vmsumuhm
+      {Intrinsic::ppc_altivec_vmsumuhs, 88614}, // __builtin_altivec_vmsumuhs
+      {Intrinsic::ppc_altivec_vmulesb, 88641}, // __builtin_altivec_vmulesb
+      {Intrinsic::ppc_altivec_vmulesd, 88667}, // __builtin_altivec_vmulesd
+      {Intrinsic::ppc_altivec_vmulesh, 88693}, // __builtin_altivec_vmulesh
+      {Intrinsic::ppc_altivec_vmulesw, 88719}, // __builtin_altivec_vmulesw
+      {Intrinsic::ppc_altivec_vmuleub, 88745}, // __builtin_altivec_vmuleub
+      {Intrinsic::ppc_altivec_vmuleud, 88771}, // __builtin_altivec_vmuleud
+      {Intrinsic::ppc_altivec_vmuleuh, 88797}, // __builtin_altivec_vmuleuh
+      {Intrinsic::ppc_altivec_vmuleuw, 88823}, // __builtin_altivec_vmuleuw
+      {Intrinsic::ppc_altivec_vmulhsd, 88849}, // __builtin_altivec_vmulhsd
+      {Intrinsic::ppc_altivec_vmulhsw, 88875}, // __builtin_altivec_vmulhsw
+      {Intrinsic::ppc_altivec_vmulhud, 88901}, // __builtin_altivec_vmulhud
+      {Intrinsic::ppc_altivec_vmulhuw, 88927}, // __builtin_altivec_vmulhuw
+      {Intrinsic::ppc_altivec_vmulosb, 88953}, // __builtin_altivec_vmulosb
+      {Intrinsic::ppc_altivec_vmulosd, 88979}, // __builtin_altivec_vmulosd
+      {Intrinsic::ppc_altivec_vmulosh, 89005}, // __builtin_altivec_vmulosh
+      {Intrinsic::ppc_altivec_vmulosw, 89031}, // __builtin_altivec_vmulosw
+      {Intrinsic::ppc_altivec_vmuloub, 89057}, // __builtin_altivec_vmuloub
+      {Intrinsic::ppc_altivec_vmuloud, 89083}, // __builtin_altivec_vmuloud
+      {Intrinsic::ppc_altivec_vmulouh, 89109}, // __builtin_altivec_vmulouh
+      {Intrinsic::ppc_altivec_vmulouw, 89135}, // __builtin_altivec_vmulouw
+      {Intrinsic::ppc_altivec_vnmsubfp, 89161}, // __builtin_altivec_vnmsubfp
+      {Intrinsic::ppc_altivec_vpdepd, 89188}, // __builtin_altivec_vpdepd
+      {Intrinsic::ppc_altivec_vperm, 89213}, // __builtin_altivec_vperm_4si
+      {Intrinsic::ppc_altivec_vpextd, 89241}, // __builtin_altivec_vpextd
+      {Intrinsic::ppc_altivec_vpkpx, 89266}, // __builtin_altivec_vpkpx
+      {Intrinsic::ppc_altivec_vpksdss, 89290}, // __builtin_altivec_vpksdss
+      {Intrinsic::ppc_altivec_vpksdus, 89316}, // __builtin_altivec_vpksdus
+      {Intrinsic::ppc_altivec_vpkshss, 89342}, // __builtin_altivec_vpkshss
+      {Intrinsic::ppc_altivec_vpkshus, 89368}, // __builtin_altivec_vpkshus
+      {Intrinsic::ppc_altivec_vpkswss, 89394}, // __builtin_altivec_vpkswss
+      {Intrinsic::ppc_altivec_vpkswus, 89420}, // __builtin_altivec_vpkswus
+      {Intrinsic::ppc_altivec_vpkudus, 89446}, // __builtin_altivec_vpkudus
+      {Intrinsic::ppc_altivec_vpkuhus, 89472}, // __builtin_altivec_vpkuhus
+      {Intrinsic::ppc_altivec_vpkuwus, 89498}, // __builtin_altivec_vpkuwus
+      {Intrinsic::ppc_altivec_vprtybd, 89524}, // __builtin_altivec_vprtybd
+      {Intrinsic::ppc_altivec_vprtybq, 89550}, // __builtin_altivec_vprtybq
+      {Intrinsic::ppc_altivec_vprtybw, 89576}, // __builtin_altivec_vprtybw
+      {Intrinsic::ppc_altivec_vrefp, 89602}, // __builtin_altivec_vrefp
+      {Intrinsic::ppc_altivec_vrfim, 89626}, // __builtin_altivec_vrfim
+      {Intrinsic::ppc_altivec_vrfin, 89650}, // __builtin_altivec_vrfin
+      {Intrinsic::ppc_altivec_vrfip, 89674}, // __builtin_altivec_vrfip
+      {Intrinsic::ppc_altivec_vrfiz, 89698}, // __builtin_altivec_vrfiz
+      {Intrinsic::ppc_altivec_vrlb, 89722}, // __builtin_altivec_vrlb
+      {Intrinsic::ppc_altivec_vrld, 89745}, // __builtin_altivec_vrld
+      {Intrinsic::ppc_altivec_vrldmi, 89768}, // __builtin_altivec_vrldmi
+      {Intrinsic::ppc_altivec_vrldnm, 89793}, // __builtin_altivec_vrldnm
+      {Intrinsic::ppc_altivec_vrlh, 89818}, // __builtin_altivec_vrlh
+      {Intrinsic::ppc_altivec_vrlqmi, 89841}, // __builtin_altivec_vrlqmi
+      {Intrinsic::ppc_altivec_vrlqnm, 89866}, // __builtin_altivec_vrlqnm
+      {Intrinsic::ppc_altivec_vrlw, 89891}, // __builtin_altivec_vrlw
+      {Intrinsic::ppc_altivec_vrlwmi, 89914}, // __builtin_altivec_vrlwmi
+      {Intrinsic::ppc_altivec_vrlwnm, 89939}, // __builtin_altivec_vrlwnm
+      {Intrinsic::ppc_altivec_vrsqrtefp, 89964}, // __builtin_altivec_vrsqrtefp
+      {Intrinsic::ppc_altivec_vsel, 89992}, // __builtin_altivec_vsel_4si
+      {Intrinsic::ppc_altivec_vsl, 90019}, // __builtin_altivec_vsl
+      {Intrinsic::ppc_altivec_vslb, 90041}, // __builtin_altivec_vslb
+      {Intrinsic::ppc_altivec_vsldbi, 90064}, // __builtin_altivec_vsldbi
+      {Intrinsic::ppc_altivec_vslh, 90089}, // __builtin_altivec_vslh
+      {Intrinsic::ppc_altivec_vslo, 90112}, // __builtin_altivec_vslo
+      {Intrinsic::ppc_altivec_vslv, 90135}, // __builtin_altivec_vslv
+      {Intrinsic::ppc_altivec_vslw, 90158}, // __builtin_altivec_vslw
+      {Intrinsic::ppc_altivec_vsr, 90181}, // __builtin_altivec_vsr
+      {Intrinsic::ppc_altivec_vsrab, 90203}, // __builtin_altivec_vsrab
+      {Intrinsic::ppc_altivec_vsrah, 90227}, // __builtin_altivec_vsrah
+      {Intrinsic::ppc_altivec_vsraw, 90251}, // __builtin_altivec_vsraw
+      {Intrinsic::ppc_altivec_vsrb, 90275}, // __builtin_altivec_vsrb
+      {Intrinsic::ppc_altivec_vsrdbi, 90298}, // __builtin_altivec_vsrdbi
+      {Intrinsic::ppc_altivec_vsrh, 90323}, // __builtin_altivec_vsrh
+      {Intrinsic::ppc_altivec_vsro, 90346}, // __builtin_altivec_vsro
+      {Intrinsic::ppc_altivec_vsrv, 90369}, // __builtin_altivec_vsrv
+      {Intrinsic::ppc_altivec_vsrw, 90392}, // __builtin_altivec_vsrw
+      {Intrinsic::ppc_altivec_vstribl, 90415}, // __builtin_altivec_vstribl
+      {Intrinsic::ppc_altivec_vstribl_p, 90441}, // __builtin_altivec_vstribl_p
+      {Intrinsic::ppc_altivec_vstribr, 90469}, // __builtin_altivec_vstribr
+      {Intrinsic::ppc_altivec_vstribr_p, 90495}, // __builtin_altivec_vstribr_p
+      {Intrinsic::ppc_altivec_vstrihl, 90523}, // __builtin_altivec_vstrihl
+      {Intrinsic::ppc_altivec_vstrihl_p, 90549}, // __builtin_altivec_vstrihl_p
+      {Intrinsic::ppc_altivec_vstrihr, 90577}, // __builtin_altivec_vstrihr
+      {Intrinsic::ppc_altivec_vstrihr_p, 90603}, // __builtin_altivec_vstrihr_p
+      {Intrinsic::ppc_altivec_vsubcuq, 90631}, // __builtin_altivec_vsubcuq
+      {Intrinsic::ppc_altivec_vsubcuw, 90657}, // __builtin_altivec_vsubcuw
+      {Intrinsic::ppc_altivec_vsubecuq, 90683}, // __builtin_altivec_vsubecuq
+      {Intrinsic::ppc_altivec_vsubeuqm, 90710}, // __builtin_altivec_vsubeuqm
+      {Intrinsic::ppc_altivec_vsubsbs, 90737}, // __builtin_altivec_vsubsbs
+      {Intrinsic::ppc_altivec_vsubshs, 90763}, // __builtin_altivec_vsubshs
+      {Intrinsic::ppc_altivec_vsubsws, 90789}, // __builtin_altivec_vsubsws
+      {Intrinsic::ppc_altivec_vsububs, 90815}, // __builtin_altivec_vsububs
+      {Intrinsic::ppc_altivec_vsubuhs, 90841}, // __builtin_altivec_vsubuhs
+      {Intrinsic::ppc_altivec_vsubuws, 90867}, // __builtin_altivec_vsubuws
+      {Intrinsic::ppc_altivec_vsum2sws, 90893}, // __builtin_altivec_vsum2sws
+      {Intrinsic::ppc_altivec_vsum4sbs, 90920}, // __builtin_altivec_vsum4sbs
+      {Intrinsic::ppc_altivec_vsum4shs, 90947}, // __builtin_altivec_vsum4shs
+      {Intrinsic::ppc_altivec_vsum4ubs, 90974}, // __builtin_altivec_vsum4ubs
+      {Intrinsic::ppc_altivec_vsumsws, 91001}, // __builtin_altivec_vsumsws
+      {Intrinsic::ppc_altivec_vupkhpx, 91027}, // __builtin_altivec_vupkhpx
+      {Intrinsic::ppc_altivec_vupkhsb, 91053}, // __builtin_altivec_vupkhsb
+      {Intrinsic::ppc_altivec_vupkhsh, 91079}, // __builtin_altivec_vupkhsh
+      {Intrinsic::ppc_altivec_vupkhsw, 91105}, // __builtin_altivec_vupkhsw
+      {Intrinsic::ppc_altivec_vupklpx, 91131}, // __builtin_altivec_vupklpx
+      {Intrinsic::ppc_altivec_vupklsb, 91157}, // __builtin_altivec_vupklsb
+      {Intrinsic::ppc_altivec_vupklsh, 91183}, // __builtin_altivec_vupklsh
+      {Intrinsic::ppc_altivec_vupklsw, 91209}, // __builtin_altivec_vupklsw
+      {Intrinsic::ppc_bpermd, 91235}, // __builtin_bpermd
+      {Intrinsic::ppc_cfuged, 91252}, // __builtin_cfuged
+      {Intrinsic::ppc_cntlzdm, 91269}, // __builtin_cntlzdm
+      {Intrinsic::ppc_cnttzdm, 91287}, // __builtin_cnttzdm
+      {Intrinsic::ppc_darn, 91305}, // __builtin_darn
+      {Intrinsic::ppc_darn32, 91320}, // __builtin_darn_32
+      {Intrinsic::ppc_darnraw, 91338}, // __builtin_darn_raw
+      {Intrinsic::ppc_dcbf, 91357}, // __builtin_dcbf
+      {Intrinsic::ppc_divde, 91372}, // __builtin_divde
+      {Intrinsic::ppc_divdeu, 91388}, // __builtin_divdeu
+      {Intrinsic::ppc_divf128_round_to_odd, 91405}, // __builtin_divf128_round_to_odd
+      {Intrinsic::ppc_divwe, 91436}, // __builtin_divwe
+      {Intrinsic::ppc_divweu, 91452}, // __builtin_divweu
+      {Intrinsic::ppc_fmaf128_round_to_odd, 91469}, // __builtin_fmaf128_round_to_odd
+      {Intrinsic::ppc_get_texasr, 91500}, // __builtin_get_texasr
+      {Intrinsic::ppc_get_texasru, 91521}, // __builtin_get_texasru
+      {Intrinsic::ppc_get_tfhar, 91543}, // __builtin_get_tfhar
+      {Intrinsic::ppc_get_tfiar, 91563}, // __builtin_get_tfiar
+      {Intrinsic::ppc_mulf128_round_to_odd, 91583}, // __builtin_mulf128_round_to_odd
+      {Intrinsic::ppc_pdepd, 91614}, // __builtin_pdepd
+      {Intrinsic::ppc_pextd, 91630}, // __builtin_pextd
+      {Intrinsic::ppc_readflm, 91646}, // __builtin_readflm
+      {Intrinsic::ppc_set_texasr, 91733}, // __builtin_set_texasr
+      {Intrinsic::ppc_set_texasru, 91754}, // __builtin_set_texasru
+      {Intrinsic::ppc_set_tfhar, 91776}, // __builtin_set_tfhar
+      {Intrinsic::ppc_set_tfiar, 91796}, // __builtin_set_tfiar
+      {Intrinsic::ppc_setflm, 91816}, // __builtin_setflm
+      {Intrinsic::ppc_setrnd, 91833}, // __builtin_setrnd
+      {Intrinsic::ppc_sqrtf128_round_to_odd, 91850}, // __builtin_sqrtf128_round_to_odd
+      {Intrinsic::ppc_subf128_round_to_odd, 91882}, // __builtin_subf128_round_to_odd
+      {Intrinsic::ppc_tabort, 91913}, // __builtin_tabort
+      {Intrinsic::ppc_tabortdc, 91930}, // __builtin_tabortdc
+      {Intrinsic::ppc_tabortdci, 91949}, // __builtin_tabortdci
+      {Intrinsic::ppc_tabortwc, 91969}, // __builtin_tabortwc
+      {Intrinsic::ppc_tabortwci, 91988}, // __builtin_tabortwci
+      {Intrinsic::ppc_tbegin, 92008}, // __builtin_tbegin
+      {Intrinsic::ppc_tcheck, 92025}, // __builtin_tcheck
+      {Intrinsic::ppc_tend, 92042}, // __builtin_tend
+      {Intrinsic::ppc_tendall, 92057}, // __builtin_tendall
+      {Intrinsic::ppc_trechkpt, 92075}, // __builtin_trechkpt
+      {Intrinsic::ppc_treclaim, 92094}, // __builtin_treclaim
+      {Intrinsic::ppc_tresume, 92113}, // __builtin_tresume
+      {Intrinsic::ppc_truncf128_round_to_odd, 92131}, // __builtin_truncf128_round_to_odd
+      {Intrinsic::ppc_tsr, 92164}, // __builtin_tsr
+      {Intrinsic::ppc_tsuspend, 92178}, // __builtin_tsuspend
+      {Intrinsic::ppc_ttest, 92197}, // __builtin_ttest
+      {Intrinsic::ppc_scalar_extract_expq, 91664}, // __builtin_vsx_scalar_extract_expq
+      {Intrinsic::ppc_scalar_insert_exp_qp, 91698}, // __builtin_vsx_scalar_insert_exp_qp
+      {Intrinsic::ppc_vsx_xsmaxdp, 92213}, // __builtin_vsx_xsmaxdp
+      {Intrinsic::ppc_vsx_xsmindp, 92235}, // __builtin_vsx_xsmindp
+      {Intrinsic::ppc_vsx_xvcmpeqdp, 92257}, // __builtin_vsx_xvcmpeqdp
+      {Intrinsic::ppc_vsx_xvcmpeqdp_p, 92281}, // __builtin_vsx_xvcmpeqdp_p
+      {Intrinsic::ppc_vsx_xvcmpeqsp, 92307}, // __builtin_vsx_xvcmpeqsp
+      {Intrinsic::ppc_vsx_xvcmpeqsp_p, 92331}, // __builtin_vsx_xvcmpeqsp_p
+      {Intrinsic::ppc_vsx_xvcmpgedp, 92357}, // __builtin_vsx_xvcmpgedp
+      {Intrinsic::ppc_vsx_xvcmpgedp_p, 92381}, // __builtin_vsx_xvcmpgedp_p
+      {Intrinsic::ppc_vsx_xvcmpgesp, 92407}, // __builtin_vsx_xvcmpgesp
+      {Intrinsic::ppc_vsx_xvcmpgesp_p, 92431}, // __builtin_vsx_xvcmpgesp_p
+      {Intrinsic::ppc_vsx_xvcmpgtdp, 92457}, // __builtin_vsx_xvcmpgtdp
+      {Intrinsic::ppc_vsx_xvcmpgtdp_p, 92481}, // __builtin_vsx_xvcmpgtdp_p
+      {Intrinsic::ppc_vsx_xvcmpgtsp, 92507}, // __builtin_vsx_xvcmpgtsp
+      {Intrinsic::ppc_vsx_xvcmpgtsp_p, 92531}, // __builtin_vsx_xvcmpgtsp_p
+      {Intrinsic::ppc_vsx_xvcvbf16spn, 92557}, // __builtin_vsx_xvcvbf16spn
+      {Intrinsic::ppc_vsx_xvcvdpsp, 92583}, // __builtin_vsx_xvcvdpsp
+      {Intrinsic::ppc_vsx_xvcvdpsxws, 92606}, // __builtin_vsx_xvcvdpsxws
+      {Intrinsic::ppc_vsx_xvcvdpuxws, 92631}, // __builtin_vsx_xvcvdpuxws
+      {Intrinsic::ppc_vsx_xvcvhpsp, 92656}, // __builtin_vsx_xvcvhpsp
+      {Intrinsic::ppc_vsx_xvcvspbf16, 92679}, // __builtin_vsx_xvcvspbf16
+      {Intrinsic::ppc_vsx_xvcvspdp, 92704}, // __builtin_vsx_xvcvspdp
+      {Intrinsic::ppc_vsx_xvcvsphp, 92727}, // __builtin_vsx_xvcvsphp
+      {Intrinsic::ppc_vsx_xvcvsxdsp, 92750}, // __builtin_vsx_xvcvsxdsp
+      {Intrinsic::ppc_vsx_xvcvsxwdp, 92774}, // __builtin_vsx_xvcvsxwdp
+      {Intrinsic::ppc_vsx_xvcvuxdsp, 92798}, // __builtin_vsx_xvcvuxdsp
+      {Intrinsic::ppc_vsx_xvcvuxwdp, 92822}, // __builtin_vsx_xvcvuxwdp
+      {Intrinsic::ppc_vsx_xvdivdp, 92846}, // __builtin_vsx_xvdivdp
+      {Intrinsic::ppc_vsx_xvdivsp, 92868}, // __builtin_vsx_xvdivsp
+      {Intrinsic::ppc_vsx_xviexpdp, 92890}, // __builtin_vsx_xviexpdp
+      {Intrinsic::ppc_vsx_xviexpsp, 92913}, // __builtin_vsx_xviexpsp
+      {Intrinsic::ppc_vsx_xvmaxdp, 92936}, // __builtin_vsx_xvmaxdp
+      {Intrinsic::ppc_vsx_xvmaxsp, 92958}, // __builtin_vsx_xvmaxsp
+      {Intrinsic::ppc_vsx_xvmindp, 92980}, // __builtin_vsx_xvmindp
+      {Intrinsic::ppc_vsx_xvminsp, 93002}, // __builtin_vsx_xvminsp
+      {Intrinsic::ppc_vsx_xvredp, 93024}, // __builtin_vsx_xvredp
+      {Intrinsic::ppc_vsx_xvresp, 93045}, // __builtin_vsx_xvresp
+      {Intrinsic::ppc_vsx_xvrsqrtedp, 93066}, // __builtin_vsx_xvrsqrtedp
+      {Intrinsic::ppc_vsx_xvrsqrtesp, 93091}, // __builtin_vsx_xvrsqrtesp
+      {Intrinsic::ppc_vsx_xvtdivdp, 93116}, // __builtin_vsx_xvtdivdp
+      {Intrinsic::ppc_vsx_xvtdivsp, 93139}, // __builtin_vsx_xvtdivsp
+      {Intrinsic::ppc_vsx_xvtlsbb, 93162}, // __builtin_vsx_xvtlsbb
+      {Intrinsic::ppc_vsx_xvtsqrtdp, 93184}, // __builtin_vsx_xvtsqrtdp
+      {Intrinsic::ppc_vsx_xvtsqrtsp, 93208}, // __builtin_vsx_xvtsqrtsp
+      {Intrinsic::ppc_vsx_xvtstdcdp, 93232}, // __builtin_vsx_xvtstdcdp
+      {Intrinsic::ppc_vsx_xvtstdcsp, 93256}, // __builtin_vsx_xvtstdcsp
+      {Intrinsic::ppc_vsx_xvxexpdp, 93280}, // __builtin_vsx_xvxexpdp
+      {Intrinsic::ppc_vsx_xvxexpsp, 93303}, // __builtin_vsx_xvxexpsp
+      {Intrinsic::ppc_vsx_xvxsigdp, 93326}, // __builtin_vsx_xvxsigdp
+      {Intrinsic::ppc_vsx_xvxsigsp, 93349}, // __builtin_vsx_xvxsigsp
+      {Intrinsic::ppc_vsx_xxblendvb, 93372}, // __builtin_vsx_xxblendvb
+      {Intrinsic::ppc_vsx_xxblendvd, 93396}, // __builtin_vsx_xxblendvd
+      {Intrinsic::ppc_vsx_xxblendvh, 93420}, // __builtin_vsx_xxblendvh
+      {Intrinsic::ppc_vsx_xxblendvw, 93444}, // __builtin_vsx_xxblendvw
+      {Intrinsic::ppc_vsx_xxeval, 93468}, // __builtin_vsx_xxeval
+      {Intrinsic::ppc_vsx_xxextractuw, 93489}, // __builtin_vsx_xxextractuw
+      {Intrinsic::ppc_vsx_xxgenpcvbm, 93515}, // __builtin_vsx_xxgenpcvbm
+      {Intrinsic::ppc_vsx_xxgenpcvdm, 93540}, // __builtin_vsx_xxgenpcvdm
+      {Intrinsic::ppc_vsx_xxgenpcvhm, 93565}, // __builtin_vsx_xxgenpcvhm
+      {Intrinsic::ppc_vsx_xxgenpcvwm, 93590}, // __builtin_vsx_xxgenpcvwm
+      {Intrinsic::ppc_vsx_xxinsertw, 93615}, // __builtin_vsx_xxinsertw
+      {Intrinsic::ppc_vsx_xxleqv, 93639}, // __builtin_vsx_xxleqv
+      {Intrinsic::ppc_vsx_xxpermx, 93660}, // __builtin_vsx_xxpermx
     };
     auto I = std::lower_bound(std::begin(ppcNames),
                               std::end(ppcNames),
@@ -30056,18 +39205,18 @@
   }
   if (TargetPrefix == "r600") {
     static const BuiltinEntry r600Names[] = {
-      {Intrinsic::r600_group_barrier, 97271}, // __builtin_r600_group_barrier
-      {Intrinsic::r600_implicitarg_ptr, 97300}, // __builtin_r600_implicitarg_ptr
-      {Intrinsic::r600_rat_store_typed, 97331}, // __builtin_r600_rat_store_typed
-      {Intrinsic::r600_read_global_size_x, 97362}, // __builtin_r600_read_global_size_x
-      {Intrinsic::r600_read_global_size_y, 97396}, // __builtin_r600_read_global_size_y
-      {Intrinsic::r600_read_global_size_z, 97430}, // __builtin_r600_read_global_size_z
-      {Intrinsic::r600_read_ngroups_x, 97464}, // __builtin_r600_read_ngroups_x
-      {Intrinsic::r600_read_ngroups_y, 97494}, // __builtin_r600_read_ngroups_y
-      {Intrinsic::r600_read_ngroups_z, 97524}, // __builtin_r600_read_ngroups_z
-      {Intrinsic::r600_read_tgid_x, 97554}, // __builtin_r600_read_tgid_x
-      {Intrinsic::r600_read_tgid_y, 97581}, // __builtin_r600_read_tgid_y
-      {Intrinsic::r600_read_tgid_z, 97608}, // __builtin_r600_read_tgid_z
+      {Intrinsic::r600_group_barrier, 93682}, // __builtin_r600_group_barrier
+      {Intrinsic::r600_implicitarg_ptr, 93711}, // __builtin_r600_implicitarg_ptr
+      {Intrinsic::r600_rat_store_typed, 93742}, // __builtin_r600_rat_store_typed
+      {Intrinsic::r600_read_global_size_x, 93773}, // __builtin_r600_read_global_size_x
+      {Intrinsic::r600_read_global_size_y, 93807}, // __builtin_r600_read_global_size_y
+      {Intrinsic::r600_read_global_size_z, 93841}, // __builtin_r600_read_global_size_z
+      {Intrinsic::r600_read_ngroups_x, 93875}, // __builtin_r600_read_ngroups_x
+      {Intrinsic::r600_read_ngroups_y, 93905}, // __builtin_r600_read_ngroups_y
+      {Intrinsic::r600_read_ngroups_z, 93935}, // __builtin_r600_read_ngroups_z
+      {Intrinsic::r600_read_tgid_x, 93965}, // __builtin_r600_read_tgid_x
+      {Intrinsic::r600_read_tgid_y, 93992}, // __builtin_r600_read_tgid_y
+      {Intrinsic::r600_read_tgid_z, 94019}, // __builtin_r600_read_tgid_z
     };
     auto I = std::lower_bound(std::begin(r600Names),
                               std::end(r600Names),
@@ -30078,161 +39227,163 @@
   }
   if (TargetPrefix == "s390") {
     static const BuiltinEntry s390Names[] = {
-      {Intrinsic::s390_efpc, 97635}, // __builtin_s390_efpc
-      {Intrinsic::s390_lcbb, 97682}, // __builtin_s390_lcbb
-      {Intrinsic::s390_sfpc, 97722}, // __builtin_s390_sfpc
-      {Intrinsic::s390_vaccb, 97742}, // __builtin_s390_vaccb
-      {Intrinsic::s390_vacccq, 97763}, // __builtin_s390_vacccq
-      {Intrinsic::s390_vaccf, 97785}, // __builtin_s390_vaccf
-      {Intrinsic::s390_vaccg, 97806}, // __builtin_s390_vaccg
-      {Intrinsic::s390_vacch, 97827}, // __builtin_s390_vacch
-      {Intrinsic::s390_vaccq, 97848}, // __builtin_s390_vaccq
-      {Intrinsic::s390_vacq, 97869}, // __builtin_s390_vacq
-      {Intrinsic::s390_vaq, 97889}, // __builtin_s390_vaq
-      {Intrinsic::s390_vavgb, 97908}, // __builtin_s390_vavgb
-      {Intrinsic::s390_vavgf, 97929}, // __builtin_s390_vavgf
-      {Intrinsic::s390_vavgg, 97950}, // __builtin_s390_vavgg
-      {Intrinsic::s390_vavgh, 97971}, // __builtin_s390_vavgh
-      {Intrinsic::s390_vavglb, 97992}, // __builtin_s390_vavglb
-      {Intrinsic::s390_vavglf, 98014}, // __builtin_s390_vavglf
-      {Intrinsic::s390_vavglg, 98036}, // __builtin_s390_vavglg
-      {Intrinsic::s390_vavglh, 98058}, // __builtin_s390_vavglh
-      {Intrinsic::s390_vbperm, 98080}, // __builtin_s390_vbperm
-      {Intrinsic::s390_vcksm, 98102}, // __builtin_s390_vcksm
-      {Intrinsic::s390_verimb, 98123}, // __builtin_s390_verimb
-      {Intrinsic::s390_verimf, 98145}, // __builtin_s390_verimf
-      {Intrinsic::s390_verimg, 98167}, // __builtin_s390_verimg
-      {Intrinsic::s390_verimh, 98189}, // __builtin_s390_verimh
-      {Intrinsic::s390_verllb, 98211}, // __builtin_s390_verllb
-      {Intrinsic::s390_verllf, 98233}, // __builtin_s390_verllf
-      {Intrinsic::s390_verllg, 98255}, // __builtin_s390_verllg
-      {Intrinsic::s390_verllh, 98277}, // __builtin_s390_verllh
-      {Intrinsic::s390_verllvb, 98299}, // __builtin_s390_verllvb
-      {Intrinsic::s390_verllvf, 98322}, // __builtin_s390_verllvf
-      {Intrinsic::s390_verllvg, 98345}, // __builtin_s390_verllvg
-      {Intrinsic::s390_verllvh, 98368}, // __builtin_s390_verllvh
-      {Intrinsic::s390_vfaeb, 98391}, // __builtin_s390_vfaeb
-      {Intrinsic::s390_vfaef, 98412}, // __builtin_s390_vfaef
-      {Intrinsic::s390_vfaeh, 98433}, // __builtin_s390_vfaeh
-      {Intrinsic::s390_vfaezb, 98454}, // __builtin_s390_vfaezb
-      {Intrinsic::s390_vfaezf, 98476}, // __builtin_s390_vfaezf
-      {Intrinsic::s390_vfaezh, 98498}, // __builtin_s390_vfaezh
-      {Intrinsic::s390_vfeeb, 98520}, // __builtin_s390_vfeeb
-      {Intrinsic::s390_vfeef, 98541}, // __builtin_s390_vfeef
-      {Intrinsic::s390_vfeeh, 98562}, // __builtin_s390_vfeeh
-      {Intrinsic::s390_vfeezb, 98583}, // __builtin_s390_vfeezb
-      {Intrinsic::s390_vfeezf, 98605}, // __builtin_s390_vfeezf
-      {Intrinsic::s390_vfeezh, 98627}, // __builtin_s390_vfeezh
-      {Intrinsic::s390_vfeneb, 98649}, // __builtin_s390_vfeneb
-      {Intrinsic::s390_vfenef, 98671}, // __builtin_s390_vfenef
-      {Intrinsic::s390_vfeneh, 98693}, // __builtin_s390_vfeneh
-      {Intrinsic::s390_vfenezb, 98715}, // __builtin_s390_vfenezb
-      {Intrinsic::s390_vfenezf, 98738}, // __builtin_s390_vfenezf
-      {Intrinsic::s390_vfenezh, 98761}, // __builtin_s390_vfenezh
-      {Intrinsic::s390_vgfmab, 98784}, // __builtin_s390_vgfmab
-      {Intrinsic::s390_vgfmaf, 98806}, // __builtin_s390_vgfmaf
-      {Intrinsic::s390_vgfmag, 98828}, // __builtin_s390_vgfmag
-      {Intrinsic::s390_vgfmah, 98850}, // __builtin_s390_vgfmah
-      {Intrinsic::s390_vgfmb, 98872}, // __builtin_s390_vgfmb
-      {Intrinsic::s390_vgfmf, 98893}, // __builtin_s390_vgfmf
-      {Intrinsic::s390_vgfmg, 98914}, // __builtin_s390_vgfmg
-      {Intrinsic::s390_vgfmh, 98935}, // __builtin_s390_vgfmh
-      {Intrinsic::s390_vistrb, 98956}, // __builtin_s390_vistrb
-      {Intrinsic::s390_vistrf, 98978}, // __builtin_s390_vistrf
-      {Intrinsic::s390_vistrh, 99000}, // __builtin_s390_vistrh
-      {Intrinsic::s390_vlbb, 99022}, // __builtin_s390_vlbb
-      {Intrinsic::s390_vll, 99042}, // __builtin_s390_vll
-      {Intrinsic::s390_vlrl, 99061}, // __builtin_s390_vlrl
-      {Intrinsic::s390_vmaeb, 99081}, // __builtin_s390_vmaeb
-      {Intrinsic::s390_vmaef, 99102}, // __builtin_s390_vmaef
-      {Intrinsic::s390_vmaeh, 99123}, // __builtin_s390_vmaeh
-      {Intrinsic::s390_vmahb, 99144}, // __builtin_s390_vmahb
-      {Intrinsic::s390_vmahf, 99165}, // __builtin_s390_vmahf
-      {Intrinsic::s390_vmahh, 99186}, // __builtin_s390_vmahh
-      {Intrinsic::s390_vmaleb, 99207}, // __builtin_s390_vmaleb
-      {Intrinsic::s390_vmalef, 99229}, // __builtin_s390_vmalef
-      {Intrinsic::s390_vmaleh, 99251}, // __builtin_s390_vmaleh
-      {Intrinsic::s390_vmalhb, 99273}, // __builtin_s390_vmalhb
-      {Intrinsic::s390_vmalhf, 99295}, // __builtin_s390_vmalhf
-      {Intrinsic::s390_vmalhh, 99317}, // __builtin_s390_vmalhh
-      {Intrinsic::s390_vmalob, 99339}, // __builtin_s390_vmalob
-      {Intrinsic::s390_vmalof, 99361}, // __builtin_s390_vmalof
-      {Intrinsic::s390_vmaloh, 99383}, // __builtin_s390_vmaloh
-      {Intrinsic::s390_vmaob, 99405}, // __builtin_s390_vmaob
-      {Intrinsic::s390_vmaof, 99426}, // __builtin_s390_vmaof
-      {Intrinsic::s390_vmaoh, 99447}, // __builtin_s390_vmaoh
-      {Intrinsic::s390_vmeb, 99468}, // __builtin_s390_vmeb
-      {Intrinsic::s390_vmef, 99488}, // __builtin_s390_vmef
-      {Intrinsic::s390_vmeh, 99508}, // __builtin_s390_vmeh
-      {Intrinsic::s390_vmhb, 99528}, // __builtin_s390_vmhb
-      {Intrinsic::s390_vmhf, 99548}, // __builtin_s390_vmhf
-      {Intrinsic::s390_vmhh, 99568}, // __builtin_s390_vmhh
-      {Intrinsic::s390_vmleb, 99588}, // __builtin_s390_vmleb
-      {Intrinsic::s390_vmlef, 99609}, // __builtin_s390_vmlef
-      {Intrinsic::s390_vmleh, 99630}, // __builtin_s390_vmleh
-      {Intrinsic::s390_vmlhb, 99651}, // __builtin_s390_vmlhb
-      {Intrinsic::s390_vmlhf, 99672}, // __builtin_s390_vmlhf
-      {Intrinsic::s390_vmlhh, 99693}, // __builtin_s390_vmlhh
-      {Intrinsic::s390_vmlob, 99714}, // __builtin_s390_vmlob
-      {Intrinsic::s390_vmlof, 99735}, // __builtin_s390_vmlof
-      {Intrinsic::s390_vmloh, 99756}, // __builtin_s390_vmloh
-      {Intrinsic::s390_vmob, 99777}, // __builtin_s390_vmob
-      {Intrinsic::s390_vmof, 99797}, // __builtin_s390_vmof
-      {Intrinsic::s390_vmoh, 99817}, // __builtin_s390_vmoh
-      {Intrinsic::s390_vmslg, 99837}, // __builtin_s390_vmslg
-      {Intrinsic::s390_vpdi, 99858}, // __builtin_s390_vpdi
-      {Intrinsic::s390_vperm, 99878}, // __builtin_s390_vperm
-      {Intrinsic::s390_vpklsf, 99899}, // __builtin_s390_vpklsf
-      {Intrinsic::s390_vpklsg, 99921}, // __builtin_s390_vpklsg
-      {Intrinsic::s390_vpklsh, 99943}, // __builtin_s390_vpklsh
-      {Intrinsic::s390_vpksf, 99965}, // __builtin_s390_vpksf
-      {Intrinsic::s390_vpksg, 99986}, // __builtin_s390_vpksg
-      {Intrinsic::s390_vpksh, 100007}, // __builtin_s390_vpksh
-      {Intrinsic::s390_vsbcbiq, 100028}, // __builtin_s390_vsbcbiq
-      {Intrinsic::s390_vsbiq, 100051}, // __builtin_s390_vsbiq
-      {Intrinsic::s390_vscbib, 100072}, // __builtin_s390_vscbib
-      {Intrinsic::s390_vscbif, 100094}, // __builtin_s390_vscbif
-      {Intrinsic::s390_vscbig, 100116}, // __builtin_s390_vscbig
-      {Intrinsic::s390_vscbih, 100138}, // __builtin_s390_vscbih
-      {Intrinsic::s390_vscbiq, 100160}, // __builtin_s390_vscbiq
-      {Intrinsic::s390_vsl, 100182}, // __builtin_s390_vsl
-      {Intrinsic::s390_vslb, 100201}, // __builtin_s390_vslb
-      {Intrinsic::s390_vsldb, 100221}, // __builtin_s390_vsldb
-      {Intrinsic::s390_vsq, 100242}, // __builtin_s390_vsq
-      {Intrinsic::s390_vsra, 100261}, // __builtin_s390_vsra
-      {Intrinsic::s390_vsrab, 100281}, // __builtin_s390_vsrab
-      {Intrinsic::s390_vsrl, 100302}, // __builtin_s390_vsrl
-      {Intrinsic::s390_vsrlb, 100322}, // __builtin_s390_vsrlb
-      {Intrinsic::s390_vstl, 100343}, // __builtin_s390_vstl
-      {Intrinsic::s390_vstrcb, 100363}, // __builtin_s390_vstrcb
-      {Intrinsic::s390_vstrcf, 100385}, // __builtin_s390_vstrcf
-      {Intrinsic::s390_vstrch, 100407}, // __builtin_s390_vstrch
-      {Intrinsic::s390_vstrczb, 100429}, // __builtin_s390_vstrczb
-      {Intrinsic::s390_vstrczf, 100452}, // __builtin_s390_vstrczf
-      {Intrinsic::s390_vstrczh, 100475}, // __builtin_s390_vstrczh
-      {Intrinsic::s390_vstrl, 100498}, // __builtin_s390_vstrl
-      {Intrinsic::s390_vsumb, 100519}, // __builtin_s390_vsumb
-      {Intrinsic::s390_vsumgf, 100540}, // __builtin_s390_vsumgf
-      {Intrinsic::s390_vsumgh, 100562}, // __builtin_s390_vsumgh
-      {Intrinsic::s390_vsumh, 100584}, // __builtin_s390_vsumh
-      {Intrinsic::s390_vsumqf, 100605}, // __builtin_s390_vsumqf
-      {Intrinsic::s390_vsumqg, 100627}, // __builtin_s390_vsumqg
-      {Intrinsic::s390_vtm, 100649}, // __builtin_s390_vtm
-      {Intrinsic::s390_vuphb, 100668}, // __builtin_s390_vuphb
-      {Intrinsic::s390_vuphf, 100689}, // __builtin_s390_vuphf
-      {Intrinsic::s390_vuphh, 100710}, // __builtin_s390_vuphh
-      {Intrinsic::s390_vuplb, 100731}, // __builtin_s390_vuplb
-      {Intrinsic::s390_vuplf, 100752}, // __builtin_s390_vuplf
-      {Intrinsic::s390_vuplhb, 100773}, // __builtin_s390_vuplhb
-      {Intrinsic::s390_vuplhf, 100795}, // __builtin_s390_vuplhf
-      {Intrinsic::s390_vuplhh, 100817}, // __builtin_s390_vuplhh
-      {Intrinsic::s390_vuplhw, 100839}, // __builtin_s390_vuplhw
-      {Intrinsic::s390_vupllb, 100861}, // __builtin_s390_vupllb
-      {Intrinsic::s390_vupllf, 100883}, // __builtin_s390_vupllf
-      {Intrinsic::s390_vupllh, 100905}, // __builtin_s390_vupllh
-      {Intrinsic::s390_tend, 96037}, // __builtin_tend
-      {Intrinsic::s390_ppa_txassist, 97702}, // __builtin_tx_assist
-      {Intrinsic::s390_etnd, 97655}, // __builtin_tx_nesting_depth
+      {Intrinsic::s390_efpc, 94046}, // __builtin_s390_efpc
+      {Intrinsic::s390_lcbb, 94093}, // __builtin_s390_lcbb
+      {Intrinsic::s390_sfpc, 94133}, // __builtin_s390_sfpc
+      {Intrinsic::s390_vaccb, 94153}, // __builtin_s390_vaccb
+      {Intrinsic::s390_vacccq, 94174}, // __builtin_s390_vacccq
+      {Intrinsic::s390_vaccf, 94196}, // __builtin_s390_vaccf
+      {Intrinsic::s390_vaccg, 94217}, // __builtin_s390_vaccg
+      {Intrinsic::s390_vacch, 94238}, // __builtin_s390_vacch
+      {Intrinsic::s390_vaccq, 94259}, // __builtin_s390_vaccq
+      {Intrinsic::s390_vacq, 94280}, // __builtin_s390_vacq
+      {Intrinsic::s390_vaq, 94300}, // __builtin_s390_vaq
+      {Intrinsic::s390_vavgb, 94319}, // __builtin_s390_vavgb
+      {Intrinsic::s390_vavgf, 94340}, // __builtin_s390_vavgf
+      {Intrinsic::s390_vavgg, 94361}, // __builtin_s390_vavgg
+      {Intrinsic::s390_vavgh, 94382}, // __builtin_s390_vavgh
+      {Intrinsic::s390_vavglb, 94403}, // __builtin_s390_vavglb
+      {Intrinsic::s390_vavglf, 94425}, // __builtin_s390_vavglf
+      {Intrinsic::s390_vavglg, 94447}, // __builtin_s390_vavglg
+      {Intrinsic::s390_vavglh, 94469}, // __builtin_s390_vavglh
+      {Intrinsic::s390_vbperm, 94491}, // __builtin_s390_vbperm
+      {Intrinsic::s390_vcksm, 94513}, // __builtin_s390_vcksm
+      {Intrinsic::s390_verimb, 94534}, // __builtin_s390_verimb
+      {Intrinsic::s390_verimf, 94556}, // __builtin_s390_verimf
+      {Intrinsic::s390_verimg, 94578}, // __builtin_s390_verimg
+      {Intrinsic::s390_verimh, 94600}, // __builtin_s390_verimh
+      {Intrinsic::s390_verllb, 94622}, // __builtin_s390_verllb
+      {Intrinsic::s390_verllf, 94644}, // __builtin_s390_verllf
+      {Intrinsic::s390_verllg, 94666}, // __builtin_s390_verllg
+      {Intrinsic::s390_verllh, 94688}, // __builtin_s390_verllh
+      {Intrinsic::s390_verllvb, 94710}, // __builtin_s390_verllvb
+      {Intrinsic::s390_verllvf, 94733}, // __builtin_s390_verllvf
+      {Intrinsic::s390_verllvg, 94756}, // __builtin_s390_verllvg
+      {Intrinsic::s390_verllvh, 94779}, // __builtin_s390_verllvh
+      {Intrinsic::s390_vfaeb, 94802}, // __builtin_s390_vfaeb
+      {Intrinsic::s390_vfaef, 94823}, // __builtin_s390_vfaef
+      {Intrinsic::s390_vfaeh, 94844}, // __builtin_s390_vfaeh
+      {Intrinsic::s390_vfaezb, 94865}, // __builtin_s390_vfaezb
+      {Intrinsic::s390_vfaezf, 94887}, // __builtin_s390_vfaezf
+      {Intrinsic::s390_vfaezh, 94909}, // __builtin_s390_vfaezh
+      {Intrinsic::s390_vfeeb, 94931}, // __builtin_s390_vfeeb
+      {Intrinsic::s390_vfeef, 94952}, // __builtin_s390_vfeef
+      {Intrinsic::s390_vfeeh, 94973}, // __builtin_s390_vfeeh
+      {Intrinsic::s390_vfeezb, 94994}, // __builtin_s390_vfeezb
+      {Intrinsic::s390_vfeezf, 95016}, // __builtin_s390_vfeezf
+      {Intrinsic::s390_vfeezh, 95038}, // __builtin_s390_vfeezh
+      {Intrinsic::s390_vfeneb, 95060}, // __builtin_s390_vfeneb
+      {Intrinsic::s390_vfenef, 95082}, // __builtin_s390_vfenef
+      {Intrinsic::s390_vfeneh, 95104}, // __builtin_s390_vfeneh
+      {Intrinsic::s390_vfenezb, 95126}, // __builtin_s390_vfenezb
+      {Intrinsic::s390_vfenezf, 95149}, // __builtin_s390_vfenezf
+      {Intrinsic::s390_vfenezh, 95172}, // __builtin_s390_vfenezh
+      {Intrinsic::s390_vgfmab, 95195}, // __builtin_s390_vgfmab
+      {Intrinsic::s390_vgfmaf, 95217}, // __builtin_s390_vgfmaf
+      {Intrinsic::s390_vgfmag, 95239}, // __builtin_s390_vgfmag
+      {Intrinsic::s390_vgfmah, 95261}, // __builtin_s390_vgfmah
+      {Intrinsic::s390_vgfmb, 95283}, // __builtin_s390_vgfmb
+      {Intrinsic::s390_vgfmf, 95304}, // __builtin_s390_vgfmf
+      {Intrinsic::s390_vgfmg, 95325}, // __builtin_s390_vgfmg
+      {Intrinsic::s390_vgfmh, 95346}, // __builtin_s390_vgfmh
+      {Intrinsic::s390_vistrb, 95367}, // __builtin_s390_vistrb
+      {Intrinsic::s390_vistrf, 95389}, // __builtin_s390_vistrf
+      {Intrinsic::s390_vistrh, 95411}, // __builtin_s390_vistrh
+      {Intrinsic::s390_vlbb, 95433}, // __builtin_s390_vlbb
+      {Intrinsic::s390_vll, 95453}, // __builtin_s390_vll
+      {Intrinsic::s390_vlrl, 95472}, // __builtin_s390_vlrl
+      {Intrinsic::s390_vmaeb, 95492}, // __builtin_s390_vmaeb
+      {Intrinsic::s390_vmaef, 95513}, // __builtin_s390_vmaef
+      {Intrinsic::s390_vmaeh, 95534}, // __builtin_s390_vmaeh
+      {Intrinsic::s390_vmahb, 95555}, // __builtin_s390_vmahb
+      {Intrinsic::s390_vmahf, 95576}, // __builtin_s390_vmahf
+      {Intrinsic::s390_vmahh, 95597}, // __builtin_s390_vmahh
+      {Intrinsic::s390_vmaleb, 95618}, // __builtin_s390_vmaleb
+      {Intrinsic::s390_vmalef, 95640}, // __builtin_s390_vmalef
+      {Intrinsic::s390_vmaleh, 95662}, // __builtin_s390_vmaleh
+      {Intrinsic::s390_vmalhb, 95684}, // __builtin_s390_vmalhb
+      {Intrinsic::s390_vmalhf, 95706}, // __builtin_s390_vmalhf
+      {Intrinsic::s390_vmalhh, 95728}, // __builtin_s390_vmalhh
+      {Intrinsic::s390_vmalob, 95750}, // __builtin_s390_vmalob
+      {Intrinsic::s390_vmalof, 95772}, // __builtin_s390_vmalof
+      {Intrinsic::s390_vmaloh, 95794}, // __builtin_s390_vmaloh
+      {Intrinsic::s390_vmaob, 95816}, // __builtin_s390_vmaob
+      {Intrinsic::s390_vmaof, 95837}, // __builtin_s390_vmaof
+      {Intrinsic::s390_vmaoh, 95858}, // __builtin_s390_vmaoh
+      {Intrinsic::s390_vmeb, 95879}, // __builtin_s390_vmeb
+      {Intrinsic::s390_vmef, 95899}, // __builtin_s390_vmef
+      {Intrinsic::s390_vmeh, 95919}, // __builtin_s390_vmeh
+      {Intrinsic::s390_vmhb, 95939}, // __builtin_s390_vmhb
+      {Intrinsic::s390_vmhf, 95959}, // __builtin_s390_vmhf
+      {Intrinsic::s390_vmhh, 95979}, // __builtin_s390_vmhh
+      {Intrinsic::s390_vmleb, 95999}, // __builtin_s390_vmleb
+      {Intrinsic::s390_vmlef, 96020}, // __builtin_s390_vmlef
+      {Intrinsic::s390_vmleh, 96041}, // __builtin_s390_vmleh
+      {Intrinsic::s390_vmlhb, 96062}, // __builtin_s390_vmlhb
+      {Intrinsic::s390_vmlhf, 96083}, // __builtin_s390_vmlhf
+      {Intrinsic::s390_vmlhh, 96104}, // __builtin_s390_vmlhh
+      {Intrinsic::s390_vmlob, 96125}, // __builtin_s390_vmlob
+      {Intrinsic::s390_vmlof, 96146}, // __builtin_s390_vmlof
+      {Intrinsic::s390_vmloh, 96167}, // __builtin_s390_vmloh
+      {Intrinsic::s390_vmob, 96188}, // __builtin_s390_vmob
+      {Intrinsic::s390_vmof, 96208}, // __builtin_s390_vmof
+      {Intrinsic::s390_vmoh, 96228}, // __builtin_s390_vmoh
+      {Intrinsic::s390_vmslg, 96248}, // __builtin_s390_vmslg
+      {Intrinsic::s390_vpdi, 96269}, // __builtin_s390_vpdi
+      {Intrinsic::s390_vperm, 96289}, // __builtin_s390_vperm
+      {Intrinsic::s390_vpklsf, 96310}, // __builtin_s390_vpklsf
+      {Intrinsic::s390_vpklsg, 96332}, // __builtin_s390_vpklsg
+      {Intrinsic::s390_vpklsh, 96354}, // __builtin_s390_vpklsh
+      {Intrinsic::s390_vpksf, 96376}, // __builtin_s390_vpksf
+      {Intrinsic::s390_vpksg, 96397}, // __builtin_s390_vpksg
+      {Intrinsic::s390_vpksh, 96418}, // __builtin_s390_vpksh
+      {Intrinsic::s390_vsbcbiq, 96439}, // __builtin_s390_vsbcbiq
+      {Intrinsic::s390_vsbiq, 96462}, // __builtin_s390_vsbiq
+      {Intrinsic::s390_vscbib, 96483}, // __builtin_s390_vscbib
+      {Intrinsic::s390_vscbif, 96505}, // __builtin_s390_vscbif
+      {Intrinsic::s390_vscbig, 96527}, // __builtin_s390_vscbig
+      {Intrinsic::s390_vscbih, 96549}, // __builtin_s390_vscbih
+      {Intrinsic::s390_vscbiq, 96571}, // __builtin_s390_vscbiq
+      {Intrinsic::s390_vsl, 96593}, // __builtin_s390_vsl
+      {Intrinsic::s390_vslb, 96612}, // __builtin_s390_vslb
+      {Intrinsic::s390_vsld, 96632}, // __builtin_s390_vsld
+      {Intrinsic::s390_vsldb, 96652}, // __builtin_s390_vsldb
+      {Intrinsic::s390_vsq, 96673}, // __builtin_s390_vsq
+      {Intrinsic::s390_vsra, 96692}, // __builtin_s390_vsra
+      {Intrinsic::s390_vsrab, 96712}, // __builtin_s390_vsrab
+      {Intrinsic::s390_vsrd, 96733}, // __builtin_s390_vsrd
+      {Intrinsic::s390_vsrl, 96753}, // __builtin_s390_vsrl
+      {Intrinsic::s390_vsrlb, 96773}, // __builtin_s390_vsrlb
+      {Intrinsic::s390_vstl, 96794}, // __builtin_s390_vstl
+      {Intrinsic::s390_vstrcb, 96814}, // __builtin_s390_vstrcb
+      {Intrinsic::s390_vstrcf, 96836}, // __builtin_s390_vstrcf
+      {Intrinsic::s390_vstrch, 96858}, // __builtin_s390_vstrch
+      {Intrinsic::s390_vstrczb, 96880}, // __builtin_s390_vstrczb
+      {Intrinsic::s390_vstrczf, 96903}, // __builtin_s390_vstrczf
+      {Intrinsic::s390_vstrczh, 96926}, // __builtin_s390_vstrczh
+      {Intrinsic::s390_vstrl, 96949}, // __builtin_s390_vstrl
+      {Intrinsic::s390_vsumb, 96970}, // __builtin_s390_vsumb
+      {Intrinsic::s390_vsumgf, 96991}, // __builtin_s390_vsumgf
+      {Intrinsic::s390_vsumgh, 97013}, // __builtin_s390_vsumgh
+      {Intrinsic::s390_vsumh, 97035}, // __builtin_s390_vsumh
+      {Intrinsic::s390_vsumqf, 97056}, // __builtin_s390_vsumqf
+      {Intrinsic::s390_vsumqg, 97078}, // __builtin_s390_vsumqg
+      {Intrinsic::s390_vtm, 97100}, // __builtin_s390_vtm
+      {Intrinsic::s390_vuphb, 97119}, // __builtin_s390_vuphb
+      {Intrinsic::s390_vuphf, 97140}, // __builtin_s390_vuphf
+      {Intrinsic::s390_vuphh, 97161}, // __builtin_s390_vuphh
+      {Intrinsic::s390_vuplb, 97182}, // __builtin_s390_vuplb
+      {Intrinsic::s390_vuplf, 97203}, // __builtin_s390_vuplf
+      {Intrinsic::s390_vuplhb, 97224}, // __builtin_s390_vuplhb
+      {Intrinsic::s390_vuplhf, 97246}, // __builtin_s390_vuplhf
+      {Intrinsic::s390_vuplhh, 97268}, // __builtin_s390_vuplhh
+      {Intrinsic::s390_vuplhw, 97290}, // __builtin_s390_vuplhw
+      {Intrinsic::s390_vupllb, 97312}, // __builtin_s390_vupllb
+      {Intrinsic::s390_vupllf, 97334}, // __builtin_s390_vupllf
+      {Intrinsic::s390_vupllh, 97356}, // __builtin_s390_vupllh
+      {Intrinsic::s390_tend, 92042}, // __builtin_tend
+      {Intrinsic::s390_ppa_txassist, 94113}, // __builtin_tx_assist
+      {Intrinsic::s390_etnd, 94066}, // __builtin_tx_nesting_depth
     };
     auto I = std::lower_bound(std::begin(s390Names),
                               std::end(s390Names),
@@ -30241,997 +39392,2250 @@
         I->getName() == BuiltinNameStr)
       return I->IntrinID;
   }
+  if (TargetPrefix == "ve") {
+    static const BuiltinEntry veNames[] = {
+      {Intrinsic::ve_vl_andm_MMM, 97378}, // __builtin_ve_vl_andm_MMM
+      {Intrinsic::ve_vl_andm_mmm, 97403}, // __builtin_ve_vl_andm_mmm
+      {Intrinsic::ve_vl_eqvm_MMM, 97428}, // __builtin_ve_vl_eqvm_MMM
+      {Intrinsic::ve_vl_eqvm_mmm, 97453}, // __builtin_ve_vl_eqvm_mmm
+      {Intrinsic::ve_vl_extract_vm512l, 97478}, // __builtin_ve_vl_extract_vm512l
+      {Intrinsic::ve_vl_extract_vm512u, 97509}, // __builtin_ve_vl_extract_vm512u
+      {Intrinsic::ve_vl_insert_vm512l, 97540}, // __builtin_ve_vl_insert_vm512l
+      {Intrinsic::ve_vl_insert_vm512u, 97570}, // __builtin_ve_vl_insert_vm512u
+      {Intrinsic::ve_vl_lsv_vvss, 97600}, // __builtin_ve_vl_lsv_vvss
+      {Intrinsic::ve_vl_lvm_MMss, 97625}, // __builtin_ve_vl_lvm_MMss
+      {Intrinsic::ve_vl_lvm_mmss, 97650}, // __builtin_ve_vl_lvm_mmss
+      {Intrinsic::ve_vl_lvsd_svs, 97675}, // __builtin_ve_vl_lvsd_svs
+      {Intrinsic::ve_vl_lvsl_svs, 97700}, // __builtin_ve_vl_lvsl_svs
+      {Intrinsic::ve_vl_lvss_svs, 97725}, // __builtin_ve_vl_lvss_svs
+      {Intrinsic::ve_vl_lzvm_sml, 97750}, // __builtin_ve_vl_lzvm_sml
+      {Intrinsic::ve_vl_negm_MM, 97775}, // __builtin_ve_vl_negm_MM
+      {Intrinsic::ve_vl_negm_mm, 97799}, // __builtin_ve_vl_negm_mm
+      {Intrinsic::ve_vl_nndm_MMM, 97823}, // __builtin_ve_vl_nndm_MMM
+      {Intrinsic::ve_vl_nndm_mmm, 97848}, // __builtin_ve_vl_nndm_mmm
+      {Intrinsic::ve_vl_orm_MMM, 97873}, // __builtin_ve_vl_orm_MMM
+      {Intrinsic::ve_vl_orm_mmm, 97897}, // __builtin_ve_vl_orm_mmm
+      {Intrinsic::ve_vl_pack_f32a, 97921}, // __builtin_ve_vl_pack_f32a
+      {Intrinsic::ve_vl_pack_f32p, 97947}, // __builtin_ve_vl_pack_f32p
+      {Intrinsic::ve_vl_pcvm_sml, 97973}, // __builtin_ve_vl_pcvm_sml
+      {Intrinsic::ve_vl_pfchv_ssl, 97998}, // __builtin_ve_vl_pfchv_ssl
+      {Intrinsic::ve_vl_pfchvnc_ssl, 98024}, // __builtin_ve_vl_pfchvnc_ssl
+      {Intrinsic::ve_vl_pvadds_vsvMvl, 98052}, // __builtin_ve_vl_pvadds_vsvMvl
+      {Intrinsic::ve_vl_pvadds_vsvl, 98082}, // __builtin_ve_vl_pvadds_vsvl
+      {Intrinsic::ve_vl_pvadds_vsvvl, 98110}, // __builtin_ve_vl_pvadds_vsvvl
+      {Intrinsic::ve_vl_pvadds_vvvMvl, 98139}, // __builtin_ve_vl_pvadds_vvvMvl
+      {Intrinsic::ve_vl_pvadds_vvvl, 98169}, // __builtin_ve_vl_pvadds_vvvl
+      {Intrinsic::ve_vl_pvadds_vvvvl, 98197}, // __builtin_ve_vl_pvadds_vvvvl
+      {Intrinsic::ve_vl_pvaddu_vsvMvl, 98226}, // __builtin_ve_vl_pvaddu_vsvMvl
+      {Intrinsic::ve_vl_pvaddu_vsvl, 98256}, // __builtin_ve_vl_pvaddu_vsvl
+      {Intrinsic::ve_vl_pvaddu_vsvvl, 98284}, // __builtin_ve_vl_pvaddu_vsvvl
+      {Intrinsic::ve_vl_pvaddu_vvvMvl, 98313}, // __builtin_ve_vl_pvaddu_vvvMvl
+      {Intrinsic::ve_vl_pvaddu_vvvl, 98343}, // __builtin_ve_vl_pvaddu_vvvl
+      {Intrinsic::ve_vl_pvaddu_vvvvl, 98371}, // __builtin_ve_vl_pvaddu_vvvvl
+      {Intrinsic::ve_vl_pvand_vsvMvl, 98400}, // __builtin_ve_vl_pvand_vsvMvl
+      {Intrinsic::ve_vl_pvand_vsvl, 98429}, // __builtin_ve_vl_pvand_vsvl
+      {Intrinsic::ve_vl_pvand_vsvvl, 98456}, // __builtin_ve_vl_pvand_vsvvl
+      {Intrinsic::ve_vl_pvand_vvvMvl, 98484}, // __builtin_ve_vl_pvand_vvvMvl
+      {Intrinsic::ve_vl_pvand_vvvl, 98513}, // __builtin_ve_vl_pvand_vvvl
+      {Intrinsic::ve_vl_pvand_vvvvl, 98540}, // __builtin_ve_vl_pvand_vvvvl
+      {Intrinsic::ve_vl_pvbrd_vsMvl, 98568}, // __builtin_ve_vl_pvbrd_vsMvl
+      {Intrinsic::ve_vl_pvbrd_vsl, 98596}, // __builtin_ve_vl_pvbrd_vsl
+      {Intrinsic::ve_vl_pvbrd_vsvl, 98622}, // __builtin_ve_vl_pvbrd_vsvl
+      {Intrinsic::ve_vl_pvcmps_vsvMvl, 98649}, // __builtin_ve_vl_pvcmps_vsvMvl
+      {Intrinsic::ve_vl_pvcmps_vsvl, 98679}, // __builtin_ve_vl_pvcmps_vsvl
+      {Intrinsic::ve_vl_pvcmps_vsvvl, 98707}, // __builtin_ve_vl_pvcmps_vsvvl
+      {Intrinsic::ve_vl_pvcmps_vvvMvl, 98736}, // __builtin_ve_vl_pvcmps_vvvMvl
+      {Intrinsic::ve_vl_pvcmps_vvvl, 98766}, // __builtin_ve_vl_pvcmps_vvvl
+      {Intrinsic::ve_vl_pvcmps_vvvvl, 98794}, // __builtin_ve_vl_pvcmps_vvvvl
+      {Intrinsic::ve_vl_pvcmpu_vsvMvl, 98823}, // __builtin_ve_vl_pvcmpu_vsvMvl
+      {Intrinsic::ve_vl_pvcmpu_vsvl, 98853}, // __builtin_ve_vl_pvcmpu_vsvl
+      {Intrinsic::ve_vl_pvcmpu_vsvvl, 98881}, // __builtin_ve_vl_pvcmpu_vsvvl
+      {Intrinsic::ve_vl_pvcmpu_vvvMvl, 98910}, // __builtin_ve_vl_pvcmpu_vvvMvl
+      {Intrinsic::ve_vl_pvcmpu_vvvl, 98940}, // __builtin_ve_vl_pvcmpu_vvvl
+      {Intrinsic::ve_vl_pvcmpu_vvvvl, 98968}, // __builtin_ve_vl_pvcmpu_vvvvl
+      {Intrinsic::ve_vl_pvcvtsw_vvl, 98997}, // __builtin_ve_vl_pvcvtsw_vvl
+      {Intrinsic::ve_vl_pvcvtsw_vvvl, 99025}, // __builtin_ve_vl_pvcvtsw_vvvl
+      {Intrinsic::ve_vl_pvcvtws_vvMvl, 99054}, // __builtin_ve_vl_pvcvtws_vvMvl
+      {Intrinsic::ve_vl_pvcvtws_vvl, 99084}, // __builtin_ve_vl_pvcvtws_vvl
+      {Intrinsic::ve_vl_pvcvtws_vvvl, 99112}, // __builtin_ve_vl_pvcvtws_vvvl
+      {Intrinsic::ve_vl_pvcvtwsrz_vvMvl, 99141}, // __builtin_ve_vl_pvcvtwsrz_vvMvl
+      {Intrinsic::ve_vl_pvcvtwsrz_vvl, 99173}, // __builtin_ve_vl_pvcvtwsrz_vvl
+      {Intrinsic::ve_vl_pvcvtwsrz_vvvl, 99203}, // __builtin_ve_vl_pvcvtwsrz_vvvl
+      {Intrinsic::ve_vl_pveqv_vsvMvl, 99234}, // __builtin_ve_vl_pveqv_vsvMvl
+      {Intrinsic::ve_vl_pveqv_vsvl, 99263}, // __builtin_ve_vl_pveqv_vsvl
+      {Intrinsic::ve_vl_pveqv_vsvvl, 99290}, // __builtin_ve_vl_pveqv_vsvvl
+      {Intrinsic::ve_vl_pveqv_vvvMvl, 99318}, // __builtin_ve_vl_pveqv_vvvMvl
+      {Intrinsic::ve_vl_pveqv_vvvl, 99347}, // __builtin_ve_vl_pveqv_vvvl
+      {Intrinsic::ve_vl_pveqv_vvvvl, 99374}, // __builtin_ve_vl_pveqv_vvvvl
+      {Intrinsic::ve_vl_pvfadd_vsvMvl, 99402}, // __builtin_ve_vl_pvfadd_vsvMvl
+      {Intrinsic::ve_vl_pvfadd_vsvl, 99432}, // __builtin_ve_vl_pvfadd_vsvl
+      {Intrinsic::ve_vl_pvfadd_vsvvl, 99460}, // __builtin_ve_vl_pvfadd_vsvvl
+      {Intrinsic::ve_vl_pvfadd_vvvMvl, 99489}, // __builtin_ve_vl_pvfadd_vvvMvl
+      {Intrinsic::ve_vl_pvfadd_vvvl, 99519}, // __builtin_ve_vl_pvfadd_vvvl
+      {Intrinsic::ve_vl_pvfadd_vvvvl, 99547}, // __builtin_ve_vl_pvfadd_vvvvl
+      {Intrinsic::ve_vl_pvfcmp_vsvMvl, 99576}, // __builtin_ve_vl_pvfcmp_vsvMvl
+      {Intrinsic::ve_vl_pvfcmp_vsvl, 99606}, // __builtin_ve_vl_pvfcmp_vsvl
+      {Intrinsic::ve_vl_pvfcmp_vsvvl, 99634}, // __builtin_ve_vl_pvfcmp_vsvvl
+      {Intrinsic::ve_vl_pvfcmp_vvvMvl, 99663}, // __builtin_ve_vl_pvfcmp_vvvMvl
+      {Intrinsic::ve_vl_pvfcmp_vvvl, 99693}, // __builtin_ve_vl_pvfcmp_vvvl
+      {Intrinsic::ve_vl_pvfcmp_vvvvl, 99721}, // __builtin_ve_vl_pvfcmp_vvvvl
+      {Intrinsic::ve_vl_pvfmad_vsvvMvl, 99750}, // __builtin_ve_vl_pvfmad_vsvvMvl
+      {Intrinsic::ve_vl_pvfmad_vsvvl, 99781}, // __builtin_ve_vl_pvfmad_vsvvl
+      {Intrinsic::ve_vl_pvfmad_vsvvvl, 99810}, // __builtin_ve_vl_pvfmad_vsvvvl
+      {Intrinsic::ve_vl_pvfmad_vvsvMvl, 99840}, // __builtin_ve_vl_pvfmad_vvsvMvl
+      {Intrinsic::ve_vl_pvfmad_vvsvl, 99871}, // __builtin_ve_vl_pvfmad_vvsvl
+      {Intrinsic::ve_vl_pvfmad_vvsvvl, 99900}, // __builtin_ve_vl_pvfmad_vvsvvl
+      {Intrinsic::ve_vl_pvfmad_vvvvMvl, 99930}, // __builtin_ve_vl_pvfmad_vvvvMvl
+      {Intrinsic::ve_vl_pvfmad_vvvvl, 99961}, // __builtin_ve_vl_pvfmad_vvvvl
+      {Intrinsic::ve_vl_pvfmad_vvvvvl, 99990}, // __builtin_ve_vl_pvfmad_vvvvvl
+      {Intrinsic::ve_vl_pvfmax_vsvMvl, 100020}, // __builtin_ve_vl_pvfmax_vsvMvl
+      {Intrinsic::ve_vl_pvfmax_vsvl, 100050}, // __builtin_ve_vl_pvfmax_vsvl
+      {Intrinsic::ve_vl_pvfmax_vsvvl, 100078}, // __builtin_ve_vl_pvfmax_vsvvl
+      {Intrinsic::ve_vl_pvfmax_vvvMvl, 100107}, // __builtin_ve_vl_pvfmax_vvvMvl
+      {Intrinsic::ve_vl_pvfmax_vvvl, 100137}, // __builtin_ve_vl_pvfmax_vvvl
+      {Intrinsic::ve_vl_pvfmax_vvvvl, 100165}, // __builtin_ve_vl_pvfmax_vvvvl
+      {Intrinsic::ve_vl_pvfmin_vsvMvl, 100194}, // __builtin_ve_vl_pvfmin_vsvMvl
+      {Intrinsic::ve_vl_pvfmin_vsvl, 100224}, // __builtin_ve_vl_pvfmin_vsvl
+      {Intrinsic::ve_vl_pvfmin_vsvvl, 100252}, // __builtin_ve_vl_pvfmin_vsvvl
+      {Intrinsic::ve_vl_pvfmin_vvvMvl, 100281}, // __builtin_ve_vl_pvfmin_vvvMvl
+      {Intrinsic::ve_vl_pvfmin_vvvl, 100311}, // __builtin_ve_vl_pvfmin_vvvl
+      {Intrinsic::ve_vl_pvfmin_vvvvl, 100339}, // __builtin_ve_vl_pvfmin_vvvvl
+      {Intrinsic::ve_vl_pvfmkaf_Ml, 100368}, // __builtin_ve_vl_pvfmkaf_Ml
+      {Intrinsic::ve_vl_pvfmkat_Ml, 100395}, // __builtin_ve_vl_pvfmkat_Ml
+      {Intrinsic::ve_vl_pvfmkseq_MvMl, 100422}, // __builtin_ve_vl_pvfmkseq_MvMl
+      {Intrinsic::ve_vl_pvfmkseq_Mvl, 100452}, // __builtin_ve_vl_pvfmkseq_Mvl
+      {Intrinsic::ve_vl_pvfmkseqnan_MvMl, 100481}, // __builtin_ve_vl_pvfmkseqnan_MvMl
+      {Intrinsic::ve_vl_pvfmkseqnan_Mvl, 100514}, // __builtin_ve_vl_pvfmkseqnan_Mvl
+      {Intrinsic::ve_vl_pvfmksge_MvMl, 100546}, // __builtin_ve_vl_pvfmksge_MvMl
+      {Intrinsic::ve_vl_pvfmksge_Mvl, 100576}, // __builtin_ve_vl_pvfmksge_Mvl
+      {Intrinsic::ve_vl_pvfmksgenan_MvMl, 100605}, // __builtin_ve_vl_pvfmksgenan_MvMl
+      {Intrinsic::ve_vl_pvfmksgenan_Mvl, 100638}, // __builtin_ve_vl_pvfmksgenan_Mvl
+      {Intrinsic::ve_vl_pvfmksgt_MvMl, 100670}, // __builtin_ve_vl_pvfmksgt_MvMl
+      {Intrinsic::ve_vl_pvfmksgt_Mvl, 100700}, // __builtin_ve_vl_pvfmksgt_Mvl
+      {Intrinsic::ve_vl_pvfmksgtnan_MvMl, 100729}, // __builtin_ve_vl_pvfmksgtnan_MvMl
+      {Intrinsic::ve_vl_pvfmksgtnan_Mvl, 100762}, // __builtin_ve_vl_pvfmksgtnan_Mvl
+      {Intrinsic::ve_vl_pvfmksle_MvMl, 100794}, // __builtin_ve_vl_pvfmksle_MvMl
+      {Intrinsic::ve_vl_pvfmksle_Mvl, 100824}, // __builtin_ve_vl_pvfmksle_Mvl
+      {Intrinsic::ve_vl_pvfmkslenan_MvMl, 100853}, // __builtin_ve_vl_pvfmkslenan_MvMl
+      {Intrinsic::ve_vl_pvfmkslenan_Mvl, 100886}, // __builtin_ve_vl_pvfmkslenan_Mvl
+      {Intrinsic::ve_vl_pvfmksloeq_mvl, 100918}, // __builtin_ve_vl_pvfmksloeq_mvl
+      {Intrinsic::ve_vl_pvfmksloeq_mvml, 100949}, // __builtin_ve_vl_pvfmksloeq_mvml
+      {Intrinsic::ve_vl_pvfmksloeqnan_mvl, 100981}, // __builtin_ve_vl_pvfmksloeqnan_mvl
+      {Intrinsic::ve_vl_pvfmksloeqnan_mvml, 101015}, // __builtin_ve_vl_pvfmksloeqnan_mvml
+      {Intrinsic::ve_vl_pvfmksloge_mvl, 101050}, // __builtin_ve_vl_pvfmksloge_mvl
+      {Intrinsic::ve_vl_pvfmksloge_mvml, 101081}, // __builtin_ve_vl_pvfmksloge_mvml
+      {Intrinsic::ve_vl_pvfmkslogenan_mvl, 101113}, // __builtin_ve_vl_pvfmkslogenan_mvl
+      {Intrinsic::ve_vl_pvfmkslogenan_mvml, 101147}, // __builtin_ve_vl_pvfmkslogenan_mvml
+      {Intrinsic::ve_vl_pvfmkslogt_mvl, 101182}, // __builtin_ve_vl_pvfmkslogt_mvl
+      {Intrinsic::ve_vl_pvfmkslogt_mvml, 101213}, // __builtin_ve_vl_pvfmkslogt_mvml
+      {Intrinsic::ve_vl_pvfmkslogtnan_mvl, 101245}, // __builtin_ve_vl_pvfmkslogtnan_mvl
+      {Intrinsic::ve_vl_pvfmkslogtnan_mvml, 101279}, // __builtin_ve_vl_pvfmkslogtnan_mvml
+      {Intrinsic::ve_vl_pvfmkslole_mvl, 101314}, // __builtin_ve_vl_pvfmkslole_mvl
+      {Intrinsic::ve_vl_pvfmkslole_mvml, 101345}, // __builtin_ve_vl_pvfmkslole_mvml
+      {Intrinsic::ve_vl_pvfmkslolenan_mvl, 101377}, // __builtin_ve_vl_pvfmkslolenan_mvl
+      {Intrinsic::ve_vl_pvfmkslolenan_mvml, 101411}, // __builtin_ve_vl_pvfmkslolenan_mvml
+      {Intrinsic::ve_vl_pvfmkslolt_mvl, 101446}, // __builtin_ve_vl_pvfmkslolt_mvl
+      {Intrinsic::ve_vl_pvfmkslolt_mvml, 101477}, // __builtin_ve_vl_pvfmkslolt_mvml
+      {Intrinsic::ve_vl_pvfmksloltnan_mvl, 101509}, // __builtin_ve_vl_pvfmksloltnan_mvl
+      {Intrinsic::ve_vl_pvfmksloltnan_mvml, 101543}, // __builtin_ve_vl_pvfmksloltnan_mvml
+      {Intrinsic::ve_vl_pvfmkslonan_mvl, 101578}, // __builtin_ve_vl_pvfmkslonan_mvl
+      {Intrinsic::ve_vl_pvfmkslonan_mvml, 101610}, // __builtin_ve_vl_pvfmkslonan_mvml
+      {Intrinsic::ve_vl_pvfmkslone_mvl, 101643}, // __builtin_ve_vl_pvfmkslone_mvl
+      {Intrinsic::ve_vl_pvfmkslone_mvml, 101674}, // __builtin_ve_vl_pvfmkslone_mvml
+      {Intrinsic::ve_vl_pvfmkslonenan_mvl, 101706}, // __builtin_ve_vl_pvfmkslonenan_mvl
+      {Intrinsic::ve_vl_pvfmkslonenan_mvml, 101740}, // __builtin_ve_vl_pvfmkslonenan_mvml
+      {Intrinsic::ve_vl_pvfmkslonum_mvl, 101775}, // __builtin_ve_vl_pvfmkslonum_mvl
+      {Intrinsic::ve_vl_pvfmkslonum_mvml, 101807}, // __builtin_ve_vl_pvfmkslonum_mvml
+      {Intrinsic::ve_vl_pvfmkslt_MvMl, 101840}, // __builtin_ve_vl_pvfmkslt_MvMl
+      {Intrinsic::ve_vl_pvfmkslt_Mvl, 101870}, // __builtin_ve_vl_pvfmkslt_Mvl
+      {Intrinsic::ve_vl_pvfmksltnan_MvMl, 101899}, // __builtin_ve_vl_pvfmksltnan_MvMl
+      {Intrinsic::ve_vl_pvfmksltnan_Mvl, 101932}, // __builtin_ve_vl_pvfmksltnan_Mvl
+      {Intrinsic::ve_vl_pvfmksnan_MvMl, 101964}, // __builtin_ve_vl_pvfmksnan_MvMl
+      {Intrinsic::ve_vl_pvfmksnan_Mvl, 101995}, // __builtin_ve_vl_pvfmksnan_Mvl
+      {Intrinsic::ve_vl_pvfmksne_MvMl, 102025}, // __builtin_ve_vl_pvfmksne_MvMl
+      {Intrinsic::ve_vl_pvfmksne_Mvl, 102055}, // __builtin_ve_vl_pvfmksne_Mvl
+      {Intrinsic::ve_vl_pvfmksnenan_MvMl, 102084}, // __builtin_ve_vl_pvfmksnenan_MvMl
+      {Intrinsic::ve_vl_pvfmksnenan_Mvl, 102117}, // __builtin_ve_vl_pvfmksnenan_Mvl
+      {Intrinsic::ve_vl_pvfmksnum_MvMl, 102149}, // __builtin_ve_vl_pvfmksnum_MvMl
+      {Intrinsic::ve_vl_pvfmksnum_Mvl, 102180}, // __builtin_ve_vl_pvfmksnum_Mvl
+      {Intrinsic::ve_vl_pvfmksupeq_mvl, 102210}, // __builtin_ve_vl_pvfmksupeq_mvl
+      {Intrinsic::ve_vl_pvfmksupeq_mvml, 102241}, // __builtin_ve_vl_pvfmksupeq_mvml
+      {Intrinsic::ve_vl_pvfmksupeqnan_mvl, 102273}, // __builtin_ve_vl_pvfmksupeqnan_mvl
+      {Intrinsic::ve_vl_pvfmksupeqnan_mvml, 102307}, // __builtin_ve_vl_pvfmksupeqnan_mvml
+      {Intrinsic::ve_vl_pvfmksupge_mvl, 102342}, // __builtin_ve_vl_pvfmksupge_mvl
+      {Intrinsic::ve_vl_pvfmksupge_mvml, 102373}, // __builtin_ve_vl_pvfmksupge_mvml
+      {Intrinsic::ve_vl_pvfmksupgenan_mvl, 102405}, // __builtin_ve_vl_pvfmksupgenan_mvl
+      {Intrinsic::ve_vl_pvfmksupgenan_mvml, 102439}, // __builtin_ve_vl_pvfmksupgenan_mvml
+      {Intrinsic::ve_vl_pvfmksupgt_mvl, 102474}, // __builtin_ve_vl_pvfmksupgt_mvl
+      {Intrinsic::ve_vl_pvfmksupgt_mvml, 102505}, // __builtin_ve_vl_pvfmksupgt_mvml
+      {Intrinsic::ve_vl_pvfmksupgtnan_mvl, 102537}, // __builtin_ve_vl_pvfmksupgtnan_mvl
+      {Intrinsic::ve_vl_pvfmksupgtnan_mvml, 102571}, // __builtin_ve_vl_pvfmksupgtnan_mvml
+      {Intrinsic::ve_vl_pvfmksuple_mvl, 102606}, // __builtin_ve_vl_pvfmksuple_mvl
+      {Intrinsic::ve_vl_pvfmksuple_mvml, 102637}, // __builtin_ve_vl_pvfmksuple_mvml
+      {Intrinsic::ve_vl_pvfmksuplenan_mvl, 102669}, // __builtin_ve_vl_pvfmksuplenan_mvl
+      {Intrinsic::ve_vl_pvfmksuplenan_mvml, 102703}, // __builtin_ve_vl_pvfmksuplenan_mvml
+      {Intrinsic::ve_vl_pvfmksuplt_mvl, 102738}, // __builtin_ve_vl_pvfmksuplt_mvl
+      {Intrinsic::ve_vl_pvfmksuplt_mvml, 102769}, // __builtin_ve_vl_pvfmksuplt_mvml
+      {Intrinsic::ve_vl_pvfmksupltnan_mvl, 102801}, // __builtin_ve_vl_pvfmksupltnan_mvl
+      {Intrinsic::ve_vl_pvfmksupltnan_mvml, 102835}, // __builtin_ve_vl_pvfmksupltnan_mvml
+      {Intrinsic::ve_vl_pvfmksupnan_mvl, 102870}, // __builtin_ve_vl_pvfmksupnan_mvl
+      {Intrinsic::ve_vl_pvfmksupnan_mvml, 102902}, // __builtin_ve_vl_pvfmksupnan_mvml
+      {Intrinsic::ve_vl_pvfmksupne_mvl, 102935}, // __builtin_ve_vl_pvfmksupne_mvl
+      {Intrinsic::ve_vl_pvfmksupne_mvml, 102966}, // __builtin_ve_vl_pvfmksupne_mvml
+      {Intrinsic::ve_vl_pvfmksupnenan_mvl, 102998}, // __builtin_ve_vl_pvfmksupnenan_mvl
+      {Intrinsic::ve_vl_pvfmksupnenan_mvml, 103032}, // __builtin_ve_vl_pvfmksupnenan_mvml
+      {Intrinsic::ve_vl_pvfmksupnum_mvl, 103067}, // __builtin_ve_vl_pvfmksupnum_mvl
+      {Intrinsic::ve_vl_pvfmksupnum_mvml, 103099}, // __builtin_ve_vl_pvfmksupnum_mvml
+      {Intrinsic::ve_vl_pvfmkweq_MvMl, 103132}, // __builtin_ve_vl_pvfmkweq_MvMl
+      {Intrinsic::ve_vl_pvfmkweq_Mvl, 103162}, // __builtin_ve_vl_pvfmkweq_Mvl
+      {Intrinsic::ve_vl_pvfmkweqnan_MvMl, 103191}, // __builtin_ve_vl_pvfmkweqnan_MvMl
+      {Intrinsic::ve_vl_pvfmkweqnan_Mvl, 103224}, // __builtin_ve_vl_pvfmkweqnan_Mvl
+      {Intrinsic::ve_vl_pvfmkwge_MvMl, 103256}, // __builtin_ve_vl_pvfmkwge_MvMl
+      {Intrinsic::ve_vl_pvfmkwge_Mvl, 103286}, // __builtin_ve_vl_pvfmkwge_Mvl
+      {Intrinsic::ve_vl_pvfmkwgenan_MvMl, 103315}, // __builtin_ve_vl_pvfmkwgenan_MvMl
+      {Intrinsic::ve_vl_pvfmkwgenan_Mvl, 103348}, // __builtin_ve_vl_pvfmkwgenan_Mvl
+      {Intrinsic::ve_vl_pvfmkwgt_MvMl, 103380}, // __builtin_ve_vl_pvfmkwgt_MvMl
+      {Intrinsic::ve_vl_pvfmkwgt_Mvl, 103410}, // __builtin_ve_vl_pvfmkwgt_Mvl
+      {Intrinsic::ve_vl_pvfmkwgtnan_MvMl, 103439}, // __builtin_ve_vl_pvfmkwgtnan_MvMl
+      {Intrinsic::ve_vl_pvfmkwgtnan_Mvl, 103472}, // __builtin_ve_vl_pvfmkwgtnan_Mvl
+      {Intrinsic::ve_vl_pvfmkwle_MvMl, 103504}, // __builtin_ve_vl_pvfmkwle_MvMl
+      {Intrinsic::ve_vl_pvfmkwle_Mvl, 103534}, // __builtin_ve_vl_pvfmkwle_Mvl
+      {Intrinsic::ve_vl_pvfmkwlenan_MvMl, 103563}, // __builtin_ve_vl_pvfmkwlenan_MvMl
+      {Intrinsic::ve_vl_pvfmkwlenan_Mvl, 103596}, // __builtin_ve_vl_pvfmkwlenan_Mvl
+      {Intrinsic::ve_vl_pvfmkwloeq_mvl, 103628}, // __builtin_ve_vl_pvfmkwloeq_mvl
+      {Intrinsic::ve_vl_pvfmkwloeq_mvml, 103659}, // __builtin_ve_vl_pvfmkwloeq_mvml
+      {Intrinsic::ve_vl_pvfmkwloeqnan_mvl, 103691}, // __builtin_ve_vl_pvfmkwloeqnan_mvl
+      {Intrinsic::ve_vl_pvfmkwloeqnan_mvml, 103725}, // __builtin_ve_vl_pvfmkwloeqnan_mvml
+      {Intrinsic::ve_vl_pvfmkwloge_mvl, 103760}, // __builtin_ve_vl_pvfmkwloge_mvl
+      {Intrinsic::ve_vl_pvfmkwloge_mvml, 103791}, // __builtin_ve_vl_pvfmkwloge_mvml
+      {Intrinsic::ve_vl_pvfmkwlogenan_mvl, 103823}, // __builtin_ve_vl_pvfmkwlogenan_mvl
+      {Intrinsic::ve_vl_pvfmkwlogenan_mvml, 103857}, // __builtin_ve_vl_pvfmkwlogenan_mvml
+      {Intrinsic::ve_vl_pvfmkwlogt_mvl, 103892}, // __builtin_ve_vl_pvfmkwlogt_mvl
+      {Intrinsic::ve_vl_pvfmkwlogt_mvml, 103923}, // __builtin_ve_vl_pvfmkwlogt_mvml
+      {Intrinsic::ve_vl_pvfmkwlogtnan_mvl, 103955}, // __builtin_ve_vl_pvfmkwlogtnan_mvl
+      {Intrinsic::ve_vl_pvfmkwlogtnan_mvml, 103989}, // __builtin_ve_vl_pvfmkwlogtnan_mvml
+      {Intrinsic::ve_vl_pvfmkwlole_mvl, 104024}, // __builtin_ve_vl_pvfmkwlole_mvl
+      {Intrinsic::ve_vl_pvfmkwlole_mvml, 104055}, // __builtin_ve_vl_pvfmkwlole_mvml
+      {Intrinsic::ve_vl_pvfmkwlolenan_mvl, 104087}, // __builtin_ve_vl_pvfmkwlolenan_mvl
+      {Intrinsic::ve_vl_pvfmkwlolenan_mvml, 104121}, // __builtin_ve_vl_pvfmkwlolenan_mvml
+      {Intrinsic::ve_vl_pvfmkwlolt_mvl, 104156}, // __builtin_ve_vl_pvfmkwlolt_mvl
+      {Intrinsic::ve_vl_pvfmkwlolt_mvml, 104187}, // __builtin_ve_vl_pvfmkwlolt_mvml
+      {Intrinsic::ve_vl_pvfmkwloltnan_mvl, 104219}, // __builtin_ve_vl_pvfmkwloltnan_mvl
+      {Intrinsic::ve_vl_pvfmkwloltnan_mvml, 104253}, // __builtin_ve_vl_pvfmkwloltnan_mvml
+      {Intrinsic::ve_vl_pvfmkwlonan_mvl, 104288}, // __builtin_ve_vl_pvfmkwlonan_mvl
+      {Intrinsic::ve_vl_pvfmkwlonan_mvml, 104320}, // __builtin_ve_vl_pvfmkwlonan_mvml
+      {Intrinsic::ve_vl_pvfmkwlone_mvl, 104353}, // __builtin_ve_vl_pvfmkwlone_mvl
+      {Intrinsic::ve_vl_pvfmkwlone_mvml, 104384}, // __builtin_ve_vl_pvfmkwlone_mvml
+      {Intrinsic::ve_vl_pvfmkwlonenan_mvl, 104416}, // __builtin_ve_vl_pvfmkwlonenan_mvl
+      {Intrinsic::ve_vl_pvfmkwlonenan_mvml, 104450}, // __builtin_ve_vl_pvfmkwlonenan_mvml
+      {Intrinsic::ve_vl_pvfmkwlonum_mvl, 104485}, // __builtin_ve_vl_pvfmkwlonum_mvl
+      {Intrinsic::ve_vl_pvfmkwlonum_mvml, 104517}, // __builtin_ve_vl_pvfmkwlonum_mvml
+      {Intrinsic::ve_vl_pvfmkwlt_MvMl, 104550}, // __builtin_ve_vl_pvfmkwlt_MvMl
+      {Intrinsic::ve_vl_pvfmkwlt_Mvl, 104580}, // __builtin_ve_vl_pvfmkwlt_Mvl
+      {Intrinsic::ve_vl_pvfmkwltnan_MvMl, 104609}, // __builtin_ve_vl_pvfmkwltnan_MvMl
+      {Intrinsic::ve_vl_pvfmkwltnan_Mvl, 104642}, // __builtin_ve_vl_pvfmkwltnan_Mvl
+      {Intrinsic::ve_vl_pvfmkwnan_MvMl, 104674}, // __builtin_ve_vl_pvfmkwnan_MvMl
+      {Intrinsic::ve_vl_pvfmkwnan_Mvl, 104705}, // __builtin_ve_vl_pvfmkwnan_Mvl
+      {Intrinsic::ve_vl_pvfmkwne_MvMl, 104735}, // __builtin_ve_vl_pvfmkwne_MvMl
+      {Intrinsic::ve_vl_pvfmkwne_Mvl, 104765}, // __builtin_ve_vl_pvfmkwne_Mvl
+      {Intrinsic::ve_vl_pvfmkwnenan_MvMl, 104794}, // __builtin_ve_vl_pvfmkwnenan_MvMl
+      {Intrinsic::ve_vl_pvfmkwnenan_Mvl, 104827}, // __builtin_ve_vl_pvfmkwnenan_Mvl
+      {Intrinsic::ve_vl_pvfmkwnum_MvMl, 104859}, // __builtin_ve_vl_pvfmkwnum_MvMl
+      {Intrinsic::ve_vl_pvfmkwnum_Mvl, 104890}, // __builtin_ve_vl_pvfmkwnum_Mvl
+      {Intrinsic::ve_vl_pvfmkwupeq_mvl, 104920}, // __builtin_ve_vl_pvfmkwupeq_mvl
+      {Intrinsic::ve_vl_pvfmkwupeq_mvml, 104951}, // __builtin_ve_vl_pvfmkwupeq_mvml
+      {Intrinsic::ve_vl_pvfmkwupeqnan_mvl, 104983}, // __builtin_ve_vl_pvfmkwupeqnan_mvl
+      {Intrinsic::ve_vl_pvfmkwupeqnan_mvml, 105017}, // __builtin_ve_vl_pvfmkwupeqnan_mvml
+      {Intrinsic::ve_vl_pvfmkwupge_mvl, 105052}, // __builtin_ve_vl_pvfmkwupge_mvl
+      {Intrinsic::ve_vl_pvfmkwupge_mvml, 105083}, // __builtin_ve_vl_pvfmkwupge_mvml
+      {Intrinsic::ve_vl_pvfmkwupgenan_mvl, 105115}, // __builtin_ve_vl_pvfmkwupgenan_mvl
+      {Intrinsic::ve_vl_pvfmkwupgenan_mvml, 105149}, // __builtin_ve_vl_pvfmkwupgenan_mvml
+      {Intrinsic::ve_vl_pvfmkwupgt_mvl, 105184}, // __builtin_ve_vl_pvfmkwupgt_mvl
+      {Intrinsic::ve_vl_pvfmkwupgt_mvml, 105215}, // __builtin_ve_vl_pvfmkwupgt_mvml
+      {Intrinsic::ve_vl_pvfmkwupgtnan_mvl, 105247}, // __builtin_ve_vl_pvfmkwupgtnan_mvl
+      {Intrinsic::ve_vl_pvfmkwupgtnan_mvml, 105281}, // __builtin_ve_vl_pvfmkwupgtnan_mvml
+      {Intrinsic::ve_vl_pvfmkwuple_mvl, 105316}, // __builtin_ve_vl_pvfmkwuple_mvl
+      {Intrinsic::ve_vl_pvfmkwuple_mvml, 105347}, // __builtin_ve_vl_pvfmkwuple_mvml
+      {Intrinsic::ve_vl_pvfmkwuplenan_mvl, 105379}, // __builtin_ve_vl_pvfmkwuplenan_mvl
+      {Intrinsic::ve_vl_pvfmkwuplenan_mvml, 105413}, // __builtin_ve_vl_pvfmkwuplenan_mvml
+      {Intrinsic::ve_vl_pvfmkwuplt_mvl, 105448}, // __builtin_ve_vl_pvfmkwuplt_mvl
+      {Intrinsic::ve_vl_pvfmkwuplt_mvml, 105479}, // __builtin_ve_vl_pvfmkwuplt_mvml
+      {Intrinsic::ve_vl_pvfmkwupltnan_mvl, 105511}, // __builtin_ve_vl_pvfmkwupltnan_mvl
+      {Intrinsic::ve_vl_pvfmkwupltnan_mvml, 105545}, // __builtin_ve_vl_pvfmkwupltnan_mvml
+      {Intrinsic::ve_vl_pvfmkwupnan_mvl, 105580}, // __builtin_ve_vl_pvfmkwupnan_mvl
+      {Intrinsic::ve_vl_pvfmkwupnan_mvml, 105612}, // __builtin_ve_vl_pvfmkwupnan_mvml
+      {Intrinsic::ve_vl_pvfmkwupne_mvl, 105645}, // __builtin_ve_vl_pvfmkwupne_mvl
+      {Intrinsic::ve_vl_pvfmkwupne_mvml, 105676}, // __builtin_ve_vl_pvfmkwupne_mvml
+      {Intrinsic::ve_vl_pvfmkwupnenan_mvl, 105708}, // __builtin_ve_vl_pvfmkwupnenan_mvl
+      {Intrinsic::ve_vl_pvfmkwupnenan_mvml, 105742}, // __builtin_ve_vl_pvfmkwupnenan_mvml
+      {Intrinsic::ve_vl_pvfmkwupnum_mvl, 105777}, // __builtin_ve_vl_pvfmkwupnum_mvl
+      {Intrinsic::ve_vl_pvfmkwupnum_mvml, 105809}, // __builtin_ve_vl_pvfmkwupnum_mvml
+      {Intrinsic::ve_vl_pvfmsb_vsvvMvl, 105842}, // __builtin_ve_vl_pvfmsb_vsvvMvl
+      {Intrinsic::ve_vl_pvfmsb_vsvvl, 105873}, // __builtin_ve_vl_pvfmsb_vsvvl
+      {Intrinsic::ve_vl_pvfmsb_vsvvvl, 105902}, // __builtin_ve_vl_pvfmsb_vsvvvl
+      {Intrinsic::ve_vl_pvfmsb_vvsvMvl, 105932}, // __builtin_ve_vl_pvfmsb_vvsvMvl
+      {Intrinsic::ve_vl_pvfmsb_vvsvl, 105963}, // __builtin_ve_vl_pvfmsb_vvsvl
+      {Intrinsic::ve_vl_pvfmsb_vvsvvl, 105992}, // __builtin_ve_vl_pvfmsb_vvsvvl
+      {Intrinsic::ve_vl_pvfmsb_vvvvMvl, 106022}, // __builtin_ve_vl_pvfmsb_vvvvMvl
+      {Intrinsic::ve_vl_pvfmsb_vvvvl, 106053}, // __builtin_ve_vl_pvfmsb_vvvvl
+      {Intrinsic::ve_vl_pvfmsb_vvvvvl, 106082}, // __builtin_ve_vl_pvfmsb_vvvvvl
+      {Intrinsic::ve_vl_pvfmul_vsvMvl, 106112}, // __builtin_ve_vl_pvfmul_vsvMvl
+      {Intrinsic::ve_vl_pvfmul_vsvl, 106142}, // __builtin_ve_vl_pvfmul_vsvl
+      {Intrinsic::ve_vl_pvfmul_vsvvl, 106170}, // __builtin_ve_vl_pvfmul_vsvvl
+      {Intrinsic::ve_vl_pvfmul_vvvMvl, 106199}, // __builtin_ve_vl_pvfmul_vvvMvl
+      {Intrinsic::ve_vl_pvfmul_vvvl, 106229}, // __builtin_ve_vl_pvfmul_vvvl
+      {Intrinsic::ve_vl_pvfmul_vvvvl, 106257}, // __builtin_ve_vl_pvfmul_vvvvl
+      {Intrinsic::ve_vl_pvfnmad_vsvvMvl, 106286}, // __builtin_ve_vl_pvfnmad_vsvvMvl
+      {Intrinsic::ve_vl_pvfnmad_vsvvl, 106318}, // __builtin_ve_vl_pvfnmad_vsvvl
+      {Intrinsic::ve_vl_pvfnmad_vsvvvl, 106348}, // __builtin_ve_vl_pvfnmad_vsvvvl
+      {Intrinsic::ve_vl_pvfnmad_vvsvMvl, 106379}, // __builtin_ve_vl_pvfnmad_vvsvMvl
+      {Intrinsic::ve_vl_pvfnmad_vvsvl, 106411}, // __builtin_ve_vl_pvfnmad_vvsvl
+      {Intrinsic::ve_vl_pvfnmad_vvsvvl, 106441}, // __builtin_ve_vl_pvfnmad_vvsvvl
+      {Intrinsic::ve_vl_pvfnmad_vvvvMvl, 106472}, // __builtin_ve_vl_pvfnmad_vvvvMvl
+      {Intrinsic::ve_vl_pvfnmad_vvvvl, 106504}, // __builtin_ve_vl_pvfnmad_vvvvl
+      {Intrinsic::ve_vl_pvfnmad_vvvvvl, 106534}, // __builtin_ve_vl_pvfnmad_vvvvvl
+      {Intrinsic::ve_vl_pvfnmsb_vsvvMvl, 106565}, // __builtin_ve_vl_pvfnmsb_vsvvMvl
+      {Intrinsic::ve_vl_pvfnmsb_vsvvl, 106597}, // __builtin_ve_vl_pvfnmsb_vsvvl
+      {Intrinsic::ve_vl_pvfnmsb_vsvvvl, 106627}, // __builtin_ve_vl_pvfnmsb_vsvvvl
+      {Intrinsic::ve_vl_pvfnmsb_vvsvMvl, 106658}, // __builtin_ve_vl_pvfnmsb_vvsvMvl
+      {Intrinsic::ve_vl_pvfnmsb_vvsvl, 106690}, // __builtin_ve_vl_pvfnmsb_vvsvl
+      {Intrinsic::ve_vl_pvfnmsb_vvsvvl, 106720}, // __builtin_ve_vl_pvfnmsb_vvsvvl
+      {Intrinsic::ve_vl_pvfnmsb_vvvvMvl, 106751}, // __builtin_ve_vl_pvfnmsb_vvvvMvl
+      {Intrinsic::ve_vl_pvfnmsb_vvvvl, 106783}, // __builtin_ve_vl_pvfnmsb_vvvvl
+      {Intrinsic::ve_vl_pvfnmsb_vvvvvl, 106813}, // __builtin_ve_vl_pvfnmsb_vvvvvl
+      {Intrinsic::ve_vl_pvfsub_vsvMvl, 106844}, // __builtin_ve_vl_pvfsub_vsvMvl
+      {Intrinsic::ve_vl_pvfsub_vsvl, 106874}, // __builtin_ve_vl_pvfsub_vsvl
+      {Intrinsic::ve_vl_pvfsub_vsvvl, 106902}, // __builtin_ve_vl_pvfsub_vsvvl
+      {Intrinsic::ve_vl_pvfsub_vvvMvl, 106931}, // __builtin_ve_vl_pvfsub_vvvMvl
+      {Intrinsic::ve_vl_pvfsub_vvvl, 106961}, // __builtin_ve_vl_pvfsub_vvvl
+      {Intrinsic::ve_vl_pvfsub_vvvvl, 106989}, // __builtin_ve_vl_pvfsub_vvvvl
+      {Intrinsic::ve_vl_pvmaxs_vsvMvl, 107018}, // __builtin_ve_vl_pvmaxs_vsvMvl
+      {Intrinsic::ve_vl_pvmaxs_vsvl, 107048}, // __builtin_ve_vl_pvmaxs_vsvl
+      {Intrinsic::ve_vl_pvmaxs_vsvvl, 107076}, // __builtin_ve_vl_pvmaxs_vsvvl
+      {Intrinsic::ve_vl_pvmaxs_vvvMvl, 107105}, // __builtin_ve_vl_pvmaxs_vvvMvl
+      {Intrinsic::ve_vl_pvmaxs_vvvl, 107135}, // __builtin_ve_vl_pvmaxs_vvvl
+      {Intrinsic::ve_vl_pvmaxs_vvvvl, 107163}, // __builtin_ve_vl_pvmaxs_vvvvl
+      {Intrinsic::ve_vl_pvmins_vsvMvl, 107192}, // __builtin_ve_vl_pvmins_vsvMvl
+      {Intrinsic::ve_vl_pvmins_vsvl, 107222}, // __builtin_ve_vl_pvmins_vsvl
+      {Intrinsic::ve_vl_pvmins_vsvvl, 107250}, // __builtin_ve_vl_pvmins_vsvvl
+      {Intrinsic::ve_vl_pvmins_vvvMvl, 107279}, // __builtin_ve_vl_pvmins_vvvMvl
+      {Intrinsic::ve_vl_pvmins_vvvl, 107309}, // __builtin_ve_vl_pvmins_vvvl
+      {Intrinsic::ve_vl_pvmins_vvvvl, 107337}, // __builtin_ve_vl_pvmins_vvvvl
+      {Intrinsic::ve_vl_pvor_vsvMvl, 107366}, // __builtin_ve_vl_pvor_vsvMvl
+      {Intrinsic::ve_vl_pvor_vsvl, 107394}, // __builtin_ve_vl_pvor_vsvl
+      {Intrinsic::ve_vl_pvor_vsvvl, 107420}, // __builtin_ve_vl_pvor_vsvvl
+      {Intrinsic::ve_vl_pvor_vvvMvl, 107447}, // __builtin_ve_vl_pvor_vvvMvl
+      {Intrinsic::ve_vl_pvor_vvvl, 107475}, // __builtin_ve_vl_pvor_vvvl
+      {Intrinsic::ve_vl_pvor_vvvvl, 107501}, // __builtin_ve_vl_pvor_vvvvl
+      {Intrinsic::ve_vl_pvrcp_vvl, 107528}, // __builtin_ve_vl_pvrcp_vvl
+      {Intrinsic::ve_vl_pvrcp_vvvl, 107554}, // __builtin_ve_vl_pvrcp_vvvl
+      {Intrinsic::ve_vl_pvrsqrt_vvl, 107581}, // __builtin_ve_vl_pvrsqrt_vvl
+      {Intrinsic::ve_vl_pvrsqrt_vvvl, 107609}, // __builtin_ve_vl_pvrsqrt_vvvl
+      {Intrinsic::ve_vl_pvrsqrtnex_vvl, 107638}, // __builtin_ve_vl_pvrsqrtnex_vvl
+      {Intrinsic::ve_vl_pvrsqrtnex_vvvl, 107669}, // __builtin_ve_vl_pvrsqrtnex_vvvl
+      {Intrinsic::ve_vl_pvseq_vl, 107701}, // __builtin_ve_vl_pvseq_vl
+      {Intrinsic::ve_vl_pvseq_vvl, 107726}, // __builtin_ve_vl_pvseq_vvl
+      {Intrinsic::ve_vl_pvseqlo_vl, 107752}, // __builtin_ve_vl_pvseqlo_vl
+      {Intrinsic::ve_vl_pvseqlo_vvl, 107779}, // __builtin_ve_vl_pvseqlo_vvl
+      {Intrinsic::ve_vl_pvsequp_vl, 107807}, // __builtin_ve_vl_pvsequp_vl
+      {Intrinsic::ve_vl_pvsequp_vvl, 107834}, // __builtin_ve_vl_pvsequp_vvl
+      {Intrinsic::ve_vl_pvsla_vvsMvl, 107862}, // __builtin_ve_vl_pvsla_vvsMvl
+      {Intrinsic::ve_vl_pvsla_vvsl, 107891}, // __builtin_ve_vl_pvsla_vvsl
+      {Intrinsic::ve_vl_pvsla_vvsvl, 107918}, // __builtin_ve_vl_pvsla_vvsvl
+      {Intrinsic::ve_vl_pvsla_vvvMvl, 107946}, // __builtin_ve_vl_pvsla_vvvMvl
+      {Intrinsic::ve_vl_pvsla_vvvl, 107975}, // __builtin_ve_vl_pvsla_vvvl
+      {Intrinsic::ve_vl_pvsla_vvvvl, 108002}, // __builtin_ve_vl_pvsla_vvvvl
+      {Intrinsic::ve_vl_pvsll_vvsMvl, 108030}, // __builtin_ve_vl_pvsll_vvsMvl
+      {Intrinsic::ve_vl_pvsll_vvsl, 108059}, // __builtin_ve_vl_pvsll_vvsl
+      {Intrinsic::ve_vl_pvsll_vvsvl, 108086}, // __builtin_ve_vl_pvsll_vvsvl
+      {Intrinsic::ve_vl_pvsll_vvvMvl, 108114}, // __builtin_ve_vl_pvsll_vvvMvl
+      {Intrinsic::ve_vl_pvsll_vvvl, 108143}, // __builtin_ve_vl_pvsll_vvvl
+      {Intrinsic::ve_vl_pvsll_vvvvl, 108170}, // __builtin_ve_vl_pvsll_vvvvl
+      {Intrinsic::ve_vl_pvsra_vvsMvl, 108198}, // __builtin_ve_vl_pvsra_vvsMvl
+      {Intrinsic::ve_vl_pvsra_vvsl, 108227}, // __builtin_ve_vl_pvsra_vvsl
+      {Intrinsic::ve_vl_pvsra_vvsvl, 108254}, // __builtin_ve_vl_pvsra_vvsvl
+      {Intrinsic::ve_vl_pvsra_vvvMvl, 108282}, // __builtin_ve_vl_pvsra_vvvMvl
+      {Intrinsic::ve_vl_pvsra_vvvl, 108311}, // __builtin_ve_vl_pvsra_vvvl
+      {Intrinsic::ve_vl_pvsra_vvvvl, 108338}, // __builtin_ve_vl_pvsra_vvvvl
+      {Intrinsic::ve_vl_pvsrl_vvsMvl, 108366}, // __builtin_ve_vl_pvsrl_vvsMvl
+      {Intrinsic::ve_vl_pvsrl_vvsl, 108395}, // __builtin_ve_vl_pvsrl_vvsl
+      {Intrinsic::ve_vl_pvsrl_vvsvl, 108422}, // __builtin_ve_vl_pvsrl_vvsvl
+      {Intrinsic::ve_vl_pvsrl_vvvMvl, 108450}, // __builtin_ve_vl_pvsrl_vvvMvl
+      {Intrinsic::ve_vl_pvsrl_vvvl, 108479}, // __builtin_ve_vl_pvsrl_vvvl
+      {Intrinsic::ve_vl_pvsrl_vvvvl, 108506}, // __builtin_ve_vl_pvsrl_vvvvl
+      {Intrinsic::ve_vl_pvsubs_vsvMvl, 108534}, // __builtin_ve_vl_pvsubs_vsvMvl
+      {Intrinsic::ve_vl_pvsubs_vsvl, 108564}, // __builtin_ve_vl_pvsubs_vsvl
+      {Intrinsic::ve_vl_pvsubs_vsvvl, 108592}, // __builtin_ve_vl_pvsubs_vsvvl
+      {Intrinsic::ve_vl_pvsubs_vvvMvl, 108621}, // __builtin_ve_vl_pvsubs_vvvMvl
+      {Intrinsic::ve_vl_pvsubs_vvvl, 108651}, // __builtin_ve_vl_pvsubs_vvvl
+      {Intrinsic::ve_vl_pvsubs_vvvvl, 108679}, // __builtin_ve_vl_pvsubs_vvvvl
+      {Intrinsic::ve_vl_pvsubu_vsvMvl, 108708}, // __builtin_ve_vl_pvsubu_vsvMvl
+      {Intrinsic::ve_vl_pvsubu_vsvl, 108738}, // __builtin_ve_vl_pvsubu_vsvl
+      {Intrinsic::ve_vl_pvsubu_vsvvl, 108766}, // __builtin_ve_vl_pvsubu_vsvvl
+      {Intrinsic::ve_vl_pvsubu_vvvMvl, 108795}, // __builtin_ve_vl_pvsubu_vvvMvl
+      {Intrinsic::ve_vl_pvsubu_vvvl, 108825}, // __builtin_ve_vl_pvsubu_vvvl
+      {Intrinsic::ve_vl_pvsubu_vvvvl, 108853}, // __builtin_ve_vl_pvsubu_vvvvl
+      {Intrinsic::ve_vl_pvxor_vsvMvl, 108882}, // __builtin_ve_vl_pvxor_vsvMvl
+      {Intrinsic::ve_vl_pvxor_vsvl, 108911}, // __builtin_ve_vl_pvxor_vsvl
+      {Intrinsic::ve_vl_pvxor_vsvvl, 108938}, // __builtin_ve_vl_pvxor_vsvvl
+      {Intrinsic::ve_vl_pvxor_vvvMvl, 108966}, // __builtin_ve_vl_pvxor_vvvMvl
+      {Intrinsic::ve_vl_pvxor_vvvl, 108995}, // __builtin_ve_vl_pvxor_vvvl
+      {Intrinsic::ve_vl_pvxor_vvvvl, 109022}, // __builtin_ve_vl_pvxor_vvvvl
+      {Intrinsic::ve_vl_svm_sMs, 109050}, // __builtin_ve_vl_svm_sMs
+      {Intrinsic::ve_vl_svm_sms, 109074}, // __builtin_ve_vl_svm_sms
+      {Intrinsic::ve_vl_svob, 109098}, // __builtin_ve_vl_svob
+      {Intrinsic::ve_vl_tovm_sml, 109119}, // __builtin_ve_vl_tovm_sml
+      {Intrinsic::ve_vl_vaddsl_vsvl, 109144}, // __builtin_ve_vl_vaddsl_vsvl
+      {Intrinsic::ve_vl_vaddsl_vsvmvl, 109172}, // __builtin_ve_vl_vaddsl_vsvmvl
+      {Intrinsic::ve_vl_vaddsl_vsvvl, 109202}, // __builtin_ve_vl_vaddsl_vsvvl
+      {Intrinsic::ve_vl_vaddsl_vvvl, 109231}, // __builtin_ve_vl_vaddsl_vvvl
+      {Intrinsic::ve_vl_vaddsl_vvvmvl, 109259}, // __builtin_ve_vl_vaddsl_vvvmvl
+      {Intrinsic::ve_vl_vaddsl_vvvvl, 109289}, // __builtin_ve_vl_vaddsl_vvvvl
+      {Intrinsic::ve_vl_vaddswsx_vsvl, 109318}, // __builtin_ve_vl_vaddswsx_vsvl
+      {Intrinsic::ve_vl_vaddswsx_vsvmvl, 109348}, // __builtin_ve_vl_vaddswsx_vsvmvl
+      {Intrinsic::ve_vl_vaddswsx_vsvvl, 109380}, // __builtin_ve_vl_vaddswsx_vsvvl
+      {Intrinsic::ve_vl_vaddswsx_vvvl, 109411}, // __builtin_ve_vl_vaddswsx_vvvl
+      {Intrinsic::ve_vl_vaddswsx_vvvmvl, 109441}, // __builtin_ve_vl_vaddswsx_vvvmvl
+      {Intrinsic::ve_vl_vaddswsx_vvvvl, 109473}, // __builtin_ve_vl_vaddswsx_vvvvl
+      {Intrinsic::ve_vl_vaddswzx_vsvl, 109504}, // __builtin_ve_vl_vaddswzx_vsvl
+      {Intrinsic::ve_vl_vaddswzx_vsvmvl, 109534}, // __builtin_ve_vl_vaddswzx_vsvmvl
+      {Intrinsic::ve_vl_vaddswzx_vsvvl, 109566}, // __builtin_ve_vl_vaddswzx_vsvvl
+      {Intrinsic::ve_vl_vaddswzx_vvvl, 109597}, // __builtin_ve_vl_vaddswzx_vvvl
+      {Intrinsic::ve_vl_vaddswzx_vvvmvl, 109627}, // __builtin_ve_vl_vaddswzx_vvvmvl
+      {Intrinsic::ve_vl_vaddswzx_vvvvl, 109659}, // __builtin_ve_vl_vaddswzx_vvvvl
+      {Intrinsic::ve_vl_vaddul_vsvl, 109690}, // __builtin_ve_vl_vaddul_vsvl
+      {Intrinsic::ve_vl_vaddul_vsvmvl, 109718}, // __builtin_ve_vl_vaddul_vsvmvl
+      {Intrinsic::ve_vl_vaddul_vsvvl, 109748}, // __builtin_ve_vl_vaddul_vsvvl
+      {Intrinsic::ve_vl_vaddul_vvvl, 109777}, // __builtin_ve_vl_vaddul_vvvl
+      {Intrinsic::ve_vl_vaddul_vvvmvl, 109805}, // __builtin_ve_vl_vaddul_vvvmvl
+      {Intrinsic::ve_vl_vaddul_vvvvl, 109835}, // __builtin_ve_vl_vaddul_vvvvl
+      {Intrinsic::ve_vl_vadduw_vsvl, 109864}, // __builtin_ve_vl_vadduw_vsvl
+      {Intrinsic::ve_vl_vadduw_vsvmvl, 109892}, // __builtin_ve_vl_vadduw_vsvmvl
+      {Intrinsic::ve_vl_vadduw_vsvvl, 109922}, // __builtin_ve_vl_vadduw_vsvvl
+      {Intrinsic::ve_vl_vadduw_vvvl, 109951}, // __builtin_ve_vl_vadduw_vvvl
+      {Intrinsic::ve_vl_vadduw_vvvmvl, 109979}, // __builtin_ve_vl_vadduw_vvvmvl
+      {Intrinsic::ve_vl_vadduw_vvvvl, 110009}, // __builtin_ve_vl_vadduw_vvvvl
+      {Intrinsic::ve_vl_vand_vsvl, 110038}, // __builtin_ve_vl_vand_vsvl
+      {Intrinsic::ve_vl_vand_vsvmvl, 110064}, // __builtin_ve_vl_vand_vsvmvl
+      {Intrinsic::ve_vl_vand_vsvvl, 110092}, // __builtin_ve_vl_vand_vsvvl
+      {Intrinsic::ve_vl_vand_vvvl, 110119}, // __builtin_ve_vl_vand_vvvl
+      {Intrinsic::ve_vl_vand_vvvmvl, 110145}, // __builtin_ve_vl_vand_vvvmvl
+      {Intrinsic::ve_vl_vand_vvvvl, 110173}, // __builtin_ve_vl_vand_vvvvl
+      {Intrinsic::ve_vl_vbrdd_vsl, 110200}, // __builtin_ve_vl_vbrdd_vsl
+      {Intrinsic::ve_vl_vbrdd_vsmvl, 110226}, // __builtin_ve_vl_vbrdd_vsmvl
+      {Intrinsic::ve_vl_vbrdd_vsvl, 110254}, // __builtin_ve_vl_vbrdd_vsvl
+      {Intrinsic::ve_vl_vbrdl_vsl, 110281}, // __builtin_ve_vl_vbrdl_vsl
+      {Intrinsic::ve_vl_vbrdl_vsmvl, 110307}, // __builtin_ve_vl_vbrdl_vsmvl
+      {Intrinsic::ve_vl_vbrdl_vsvl, 110335}, // __builtin_ve_vl_vbrdl_vsvl
+      {Intrinsic::ve_vl_vbrds_vsl, 110362}, // __builtin_ve_vl_vbrds_vsl
+      {Intrinsic::ve_vl_vbrds_vsmvl, 110388}, // __builtin_ve_vl_vbrds_vsmvl
+      {Intrinsic::ve_vl_vbrds_vsvl, 110416}, // __builtin_ve_vl_vbrds_vsvl
+      {Intrinsic::ve_vl_vbrdw_vsl, 110443}, // __builtin_ve_vl_vbrdw_vsl
+      {Intrinsic::ve_vl_vbrdw_vsmvl, 110469}, // __builtin_ve_vl_vbrdw_vsmvl
+      {Intrinsic::ve_vl_vbrdw_vsvl, 110497}, // __builtin_ve_vl_vbrdw_vsvl
+      {Intrinsic::ve_vl_vcmpsl_vsvl, 110524}, // __builtin_ve_vl_vcmpsl_vsvl
+      {Intrinsic::ve_vl_vcmpsl_vsvmvl, 110552}, // __builtin_ve_vl_vcmpsl_vsvmvl
+      {Intrinsic::ve_vl_vcmpsl_vsvvl, 110582}, // __builtin_ve_vl_vcmpsl_vsvvl
+      {Intrinsic::ve_vl_vcmpsl_vvvl, 110611}, // __builtin_ve_vl_vcmpsl_vvvl
+      {Intrinsic::ve_vl_vcmpsl_vvvmvl, 110639}, // __builtin_ve_vl_vcmpsl_vvvmvl
+      {Intrinsic::ve_vl_vcmpsl_vvvvl, 110669}, // __builtin_ve_vl_vcmpsl_vvvvl
+      {Intrinsic::ve_vl_vcmpswsx_vsvl, 110698}, // __builtin_ve_vl_vcmpswsx_vsvl
+      {Intrinsic::ve_vl_vcmpswsx_vsvmvl, 110728}, // __builtin_ve_vl_vcmpswsx_vsvmvl
+      {Intrinsic::ve_vl_vcmpswsx_vsvvl, 110760}, // __builtin_ve_vl_vcmpswsx_vsvvl
+      {Intrinsic::ve_vl_vcmpswsx_vvvl, 110791}, // __builtin_ve_vl_vcmpswsx_vvvl
+      {Intrinsic::ve_vl_vcmpswsx_vvvmvl, 110821}, // __builtin_ve_vl_vcmpswsx_vvvmvl
+      {Intrinsic::ve_vl_vcmpswsx_vvvvl, 110853}, // __builtin_ve_vl_vcmpswsx_vvvvl
+      {Intrinsic::ve_vl_vcmpswzx_vsvl, 110884}, // __builtin_ve_vl_vcmpswzx_vsvl
+      {Intrinsic::ve_vl_vcmpswzx_vsvmvl, 110914}, // __builtin_ve_vl_vcmpswzx_vsvmvl
+      {Intrinsic::ve_vl_vcmpswzx_vsvvl, 110946}, // __builtin_ve_vl_vcmpswzx_vsvvl
+      {Intrinsic::ve_vl_vcmpswzx_vvvl, 110977}, // __builtin_ve_vl_vcmpswzx_vvvl
+      {Intrinsic::ve_vl_vcmpswzx_vvvmvl, 111007}, // __builtin_ve_vl_vcmpswzx_vvvmvl
+      {Intrinsic::ve_vl_vcmpswzx_vvvvl, 111039}, // __builtin_ve_vl_vcmpswzx_vvvvl
+      {Intrinsic::ve_vl_vcmpul_vsvl, 111070}, // __builtin_ve_vl_vcmpul_vsvl
+      {Intrinsic::ve_vl_vcmpul_vsvmvl, 111098}, // __builtin_ve_vl_vcmpul_vsvmvl
+      {Intrinsic::ve_vl_vcmpul_vsvvl, 111128}, // __builtin_ve_vl_vcmpul_vsvvl
+      {Intrinsic::ve_vl_vcmpul_vvvl, 111157}, // __builtin_ve_vl_vcmpul_vvvl
+      {Intrinsic::ve_vl_vcmpul_vvvmvl, 111185}, // __builtin_ve_vl_vcmpul_vvvmvl
+      {Intrinsic::ve_vl_vcmpul_vvvvl, 111215}, // __builtin_ve_vl_vcmpul_vvvvl
+      {Intrinsic::ve_vl_vcmpuw_vsvl, 111244}, // __builtin_ve_vl_vcmpuw_vsvl
+      {Intrinsic::ve_vl_vcmpuw_vsvmvl, 111272}, // __builtin_ve_vl_vcmpuw_vsvmvl
+      {Intrinsic::ve_vl_vcmpuw_vsvvl, 111302}, // __builtin_ve_vl_vcmpuw_vsvvl
+      {Intrinsic::ve_vl_vcmpuw_vvvl, 111331}, // __builtin_ve_vl_vcmpuw_vvvl
+      {Intrinsic::ve_vl_vcmpuw_vvvmvl, 111359}, // __builtin_ve_vl_vcmpuw_vvvmvl
+      {Intrinsic::ve_vl_vcmpuw_vvvvl, 111389}, // __builtin_ve_vl_vcmpuw_vvvvl
+      {Intrinsic::ve_vl_vcp_vvmvl, 111418}, // __builtin_ve_vl_vcp_vvmvl
+      {Intrinsic::ve_vl_vcvtdl_vvl, 111444}, // __builtin_ve_vl_vcvtdl_vvl
+      {Intrinsic::ve_vl_vcvtdl_vvvl, 111471}, // __builtin_ve_vl_vcvtdl_vvvl
+      {Intrinsic::ve_vl_vcvtds_vvl, 111499}, // __builtin_ve_vl_vcvtds_vvl
+      {Intrinsic::ve_vl_vcvtds_vvvl, 111526}, // __builtin_ve_vl_vcvtds_vvvl
+      {Intrinsic::ve_vl_vcvtdw_vvl, 111554}, // __builtin_ve_vl_vcvtdw_vvl
+      {Intrinsic::ve_vl_vcvtdw_vvvl, 111581}, // __builtin_ve_vl_vcvtdw_vvvl
+      {Intrinsic::ve_vl_vcvtld_vvl, 111609}, // __builtin_ve_vl_vcvtld_vvl
+      {Intrinsic::ve_vl_vcvtld_vvmvl, 111636}, // __builtin_ve_vl_vcvtld_vvmvl
+      {Intrinsic::ve_vl_vcvtld_vvvl, 111665}, // __builtin_ve_vl_vcvtld_vvvl
+      {Intrinsic::ve_vl_vcvtldrz_vvl, 111693}, // __builtin_ve_vl_vcvtldrz_vvl
+      {Intrinsic::ve_vl_vcvtldrz_vvmvl, 111722}, // __builtin_ve_vl_vcvtldrz_vvmvl
+      {Intrinsic::ve_vl_vcvtldrz_vvvl, 111753}, // __builtin_ve_vl_vcvtldrz_vvvl
+      {Intrinsic::ve_vl_vcvtsd_vvl, 111783}, // __builtin_ve_vl_vcvtsd_vvl
+      {Intrinsic::ve_vl_vcvtsd_vvvl, 111810}, // __builtin_ve_vl_vcvtsd_vvvl
+      {Intrinsic::ve_vl_vcvtsw_vvl, 111838}, // __builtin_ve_vl_vcvtsw_vvl
+      {Intrinsic::ve_vl_vcvtsw_vvvl, 111865}, // __builtin_ve_vl_vcvtsw_vvvl
+      {Intrinsic::ve_vl_vcvtwdsx_vvl, 111893}, // __builtin_ve_vl_vcvtwdsx_vvl
+      {Intrinsic::ve_vl_vcvtwdsx_vvmvl, 111922}, // __builtin_ve_vl_vcvtwdsx_vvmvl
+      {Intrinsic::ve_vl_vcvtwdsx_vvvl, 111953}, // __builtin_ve_vl_vcvtwdsx_vvvl
+      {Intrinsic::ve_vl_vcvtwdsxrz_vvl, 111983}, // __builtin_ve_vl_vcvtwdsxrz_vvl
+      {Intrinsic::ve_vl_vcvtwdsxrz_vvmvl, 112014}, // __builtin_ve_vl_vcvtwdsxrz_vvmvl
+      {Intrinsic::ve_vl_vcvtwdsxrz_vvvl, 112047}, // __builtin_ve_vl_vcvtwdsxrz_vvvl
+      {Intrinsic::ve_vl_vcvtwdzx_vvl, 112079}, // __builtin_ve_vl_vcvtwdzx_vvl
+      {Intrinsic::ve_vl_vcvtwdzx_vvmvl, 112108}, // __builtin_ve_vl_vcvtwdzx_vvmvl
+      {Intrinsic::ve_vl_vcvtwdzx_vvvl, 112139}, // __builtin_ve_vl_vcvtwdzx_vvvl
+      {Intrinsic::ve_vl_vcvtwdzxrz_vvl, 112169}, // __builtin_ve_vl_vcvtwdzxrz_vvl
+      {Intrinsic::ve_vl_vcvtwdzxrz_vvmvl, 112200}, // __builtin_ve_vl_vcvtwdzxrz_vvmvl
+      {Intrinsic::ve_vl_vcvtwdzxrz_vvvl, 112233}, // __builtin_ve_vl_vcvtwdzxrz_vvvl
+      {Intrinsic::ve_vl_vcvtwssx_vvl, 112265}, // __builtin_ve_vl_vcvtwssx_vvl
+      {Intrinsic::ve_vl_vcvtwssx_vvmvl, 112294}, // __builtin_ve_vl_vcvtwssx_vvmvl
+      {Intrinsic::ve_vl_vcvtwssx_vvvl, 112325}, // __builtin_ve_vl_vcvtwssx_vvvl
+      {Intrinsic::ve_vl_vcvtwssxrz_vvl, 112355}, // __builtin_ve_vl_vcvtwssxrz_vvl
+      {Intrinsic::ve_vl_vcvtwssxrz_vvmvl, 112386}, // __builtin_ve_vl_vcvtwssxrz_vvmvl
+      {Intrinsic::ve_vl_vcvtwssxrz_vvvl, 112419}, // __builtin_ve_vl_vcvtwssxrz_vvvl
+      {Intrinsic::ve_vl_vcvtwszx_vvl, 112451}, // __builtin_ve_vl_vcvtwszx_vvl
+      {Intrinsic::ve_vl_vcvtwszx_vvmvl, 112480}, // __builtin_ve_vl_vcvtwszx_vvmvl
+      {Intrinsic::ve_vl_vcvtwszx_vvvl, 112511}, // __builtin_ve_vl_vcvtwszx_vvvl
+      {Intrinsic::ve_vl_vcvtwszxrz_vvl, 112541}, // __builtin_ve_vl_vcvtwszxrz_vvl
+      {Intrinsic::ve_vl_vcvtwszxrz_vvmvl, 112572}, // __builtin_ve_vl_vcvtwszxrz_vvmvl
+      {Intrinsic::ve_vl_vcvtwszxrz_vvvl, 112605}, // __builtin_ve_vl_vcvtwszxrz_vvvl
+      {Intrinsic::ve_vl_vdivsl_vsvl, 112637}, // __builtin_ve_vl_vdivsl_vsvl
+      {Intrinsic::ve_vl_vdivsl_vsvmvl, 112665}, // __builtin_ve_vl_vdivsl_vsvmvl
+      {Intrinsic::ve_vl_vdivsl_vsvvl, 112695}, // __builtin_ve_vl_vdivsl_vsvvl
+      {Intrinsic::ve_vl_vdivsl_vvsl, 112724}, // __builtin_ve_vl_vdivsl_vvsl
+      {Intrinsic::ve_vl_vdivsl_vvsmvl, 112752}, // __builtin_ve_vl_vdivsl_vvsmvl
+      {Intrinsic::ve_vl_vdivsl_vvsvl, 112782}, // __builtin_ve_vl_vdivsl_vvsvl
+      {Intrinsic::ve_vl_vdivsl_vvvl, 112811}, // __builtin_ve_vl_vdivsl_vvvl
+      {Intrinsic::ve_vl_vdivsl_vvvmvl, 112839}, // __builtin_ve_vl_vdivsl_vvvmvl
+      {Intrinsic::ve_vl_vdivsl_vvvvl, 112869}, // __builtin_ve_vl_vdivsl_vvvvl
+      {Intrinsic::ve_vl_vdivswsx_vsvl, 112898}, // __builtin_ve_vl_vdivswsx_vsvl
+      {Intrinsic::ve_vl_vdivswsx_vsvmvl, 112928}, // __builtin_ve_vl_vdivswsx_vsvmvl
+      {Intrinsic::ve_vl_vdivswsx_vsvvl, 112960}, // __builtin_ve_vl_vdivswsx_vsvvl
+      {Intrinsic::ve_vl_vdivswsx_vvsl, 112991}, // __builtin_ve_vl_vdivswsx_vvsl
+      {Intrinsic::ve_vl_vdivswsx_vvsmvl, 113021}, // __builtin_ve_vl_vdivswsx_vvsmvl
+      {Intrinsic::ve_vl_vdivswsx_vvsvl, 113053}, // __builtin_ve_vl_vdivswsx_vvsvl
+      {Intrinsic::ve_vl_vdivswsx_vvvl, 113084}, // __builtin_ve_vl_vdivswsx_vvvl
+      {Intrinsic::ve_vl_vdivswsx_vvvmvl, 113114}, // __builtin_ve_vl_vdivswsx_vvvmvl
+      {Intrinsic::ve_vl_vdivswsx_vvvvl, 113146}, // __builtin_ve_vl_vdivswsx_vvvvl
+      {Intrinsic::ve_vl_vdivswzx_vsvl, 113177}, // __builtin_ve_vl_vdivswzx_vsvl
+      {Intrinsic::ve_vl_vdivswzx_vsvmvl, 113207}, // __builtin_ve_vl_vdivswzx_vsvmvl
+      {Intrinsic::ve_vl_vdivswzx_vsvvl, 113239}, // __builtin_ve_vl_vdivswzx_vsvvl
+      {Intrinsic::ve_vl_vdivswzx_vvsl, 113270}, // __builtin_ve_vl_vdivswzx_vvsl
+      {Intrinsic::ve_vl_vdivswzx_vvsmvl, 113300}, // __builtin_ve_vl_vdivswzx_vvsmvl
+      {Intrinsic::ve_vl_vdivswzx_vvsvl, 113332}, // __builtin_ve_vl_vdivswzx_vvsvl
+      {Intrinsic::ve_vl_vdivswzx_vvvl, 113363}, // __builtin_ve_vl_vdivswzx_vvvl
+      {Intrinsic::ve_vl_vdivswzx_vvvmvl, 113393}, // __builtin_ve_vl_vdivswzx_vvvmvl
+      {Intrinsic::ve_vl_vdivswzx_vvvvl, 113425}, // __builtin_ve_vl_vdivswzx_vvvvl
+      {Intrinsic::ve_vl_vdivul_vsvl, 113456}, // __builtin_ve_vl_vdivul_vsvl
+      {Intrinsic::ve_vl_vdivul_vsvmvl, 113484}, // __builtin_ve_vl_vdivul_vsvmvl
+      {Intrinsic::ve_vl_vdivul_vsvvl, 113514}, // __builtin_ve_vl_vdivul_vsvvl
+      {Intrinsic::ve_vl_vdivul_vvsl, 113543}, // __builtin_ve_vl_vdivul_vvsl
+      {Intrinsic::ve_vl_vdivul_vvsmvl, 113571}, // __builtin_ve_vl_vdivul_vvsmvl
+      {Intrinsic::ve_vl_vdivul_vvsvl, 113601}, // __builtin_ve_vl_vdivul_vvsvl
+      {Intrinsic::ve_vl_vdivul_vvvl, 113630}, // __builtin_ve_vl_vdivul_vvvl
+      {Intrinsic::ve_vl_vdivul_vvvmvl, 113658}, // __builtin_ve_vl_vdivul_vvvmvl
+      {Intrinsic::ve_vl_vdivul_vvvvl, 113688}, // __builtin_ve_vl_vdivul_vvvvl
+      {Intrinsic::ve_vl_vdivuw_vsvl, 113717}, // __builtin_ve_vl_vdivuw_vsvl
+      {Intrinsic::ve_vl_vdivuw_vsvmvl, 113745}, // __builtin_ve_vl_vdivuw_vsvmvl
+      {Intrinsic::ve_vl_vdivuw_vsvvl, 113775}, // __builtin_ve_vl_vdivuw_vsvvl
+      {Intrinsic::ve_vl_vdivuw_vvsl, 113804}, // __builtin_ve_vl_vdivuw_vvsl
+      {Intrinsic::ve_vl_vdivuw_vvsmvl, 113832}, // __builtin_ve_vl_vdivuw_vvsmvl
+      {Intrinsic::ve_vl_vdivuw_vvsvl, 113862}, // __builtin_ve_vl_vdivuw_vvsvl
+      {Intrinsic::ve_vl_vdivuw_vvvl, 113891}, // __builtin_ve_vl_vdivuw_vvvl
+      {Intrinsic::ve_vl_vdivuw_vvvmvl, 113919}, // __builtin_ve_vl_vdivuw_vvvmvl
+      {Intrinsic::ve_vl_vdivuw_vvvvl, 113949}, // __builtin_ve_vl_vdivuw_vvvvl
+      {Intrinsic::ve_vl_veqv_vsvl, 113978}, // __builtin_ve_vl_veqv_vsvl
+      {Intrinsic::ve_vl_veqv_vsvmvl, 114004}, // __builtin_ve_vl_veqv_vsvmvl
+      {Intrinsic::ve_vl_veqv_vsvvl, 114032}, // __builtin_ve_vl_veqv_vsvvl
+      {Intrinsic::ve_vl_veqv_vvvl, 114059}, // __builtin_ve_vl_veqv_vvvl
+      {Intrinsic::ve_vl_veqv_vvvmvl, 114085}, // __builtin_ve_vl_veqv_vvvmvl
+      {Intrinsic::ve_vl_veqv_vvvvl, 114113}, // __builtin_ve_vl_veqv_vvvvl
+      {Intrinsic::ve_vl_vex_vvmvl, 114140}, // __builtin_ve_vl_vex_vvmvl
+      {Intrinsic::ve_vl_vfaddd_vsvl, 114166}, // __builtin_ve_vl_vfaddd_vsvl
+      {Intrinsic::ve_vl_vfaddd_vsvmvl, 114194}, // __builtin_ve_vl_vfaddd_vsvmvl
+      {Intrinsic::ve_vl_vfaddd_vsvvl, 114224}, // __builtin_ve_vl_vfaddd_vsvvl
+      {Intrinsic::ve_vl_vfaddd_vvvl, 114253}, // __builtin_ve_vl_vfaddd_vvvl
+      {Intrinsic::ve_vl_vfaddd_vvvmvl, 114281}, // __builtin_ve_vl_vfaddd_vvvmvl
+      {Intrinsic::ve_vl_vfaddd_vvvvl, 114311}, // __builtin_ve_vl_vfaddd_vvvvl
+      {Intrinsic::ve_vl_vfadds_vsvl, 114340}, // __builtin_ve_vl_vfadds_vsvl
+      {Intrinsic::ve_vl_vfadds_vsvmvl, 114368}, // __builtin_ve_vl_vfadds_vsvmvl
+      {Intrinsic::ve_vl_vfadds_vsvvl, 114398}, // __builtin_ve_vl_vfadds_vsvvl
+      {Intrinsic::ve_vl_vfadds_vvvl, 114427}, // __builtin_ve_vl_vfadds_vvvl
+      {Intrinsic::ve_vl_vfadds_vvvmvl, 114455}, // __builtin_ve_vl_vfadds_vvvmvl
+      {Intrinsic::ve_vl_vfadds_vvvvl, 114485}, // __builtin_ve_vl_vfadds_vvvvl
+      {Intrinsic::ve_vl_vfcmpd_vsvl, 114514}, // __builtin_ve_vl_vfcmpd_vsvl
+      {Intrinsic::ve_vl_vfcmpd_vsvmvl, 114542}, // __builtin_ve_vl_vfcmpd_vsvmvl
+      {Intrinsic::ve_vl_vfcmpd_vsvvl, 114572}, // __builtin_ve_vl_vfcmpd_vsvvl
+      {Intrinsic::ve_vl_vfcmpd_vvvl, 114601}, // __builtin_ve_vl_vfcmpd_vvvl
+      {Intrinsic::ve_vl_vfcmpd_vvvmvl, 114629}, // __builtin_ve_vl_vfcmpd_vvvmvl
+      {Intrinsic::ve_vl_vfcmpd_vvvvl, 114659}, // __builtin_ve_vl_vfcmpd_vvvvl
+      {Intrinsic::ve_vl_vfcmps_vsvl, 114688}, // __builtin_ve_vl_vfcmps_vsvl
+      {Intrinsic::ve_vl_vfcmps_vsvmvl, 114716}, // __builtin_ve_vl_vfcmps_vsvmvl
+      {Intrinsic::ve_vl_vfcmps_vsvvl, 114746}, // __builtin_ve_vl_vfcmps_vsvvl
+      {Intrinsic::ve_vl_vfcmps_vvvl, 114775}, // __builtin_ve_vl_vfcmps_vvvl
+      {Intrinsic::ve_vl_vfcmps_vvvmvl, 114803}, // __builtin_ve_vl_vfcmps_vvvmvl
+      {Intrinsic::ve_vl_vfcmps_vvvvl, 114833}, // __builtin_ve_vl_vfcmps_vvvvl
+      {Intrinsic::ve_vl_vfdivd_vsvl, 114862}, // __builtin_ve_vl_vfdivd_vsvl
+      {Intrinsic::ve_vl_vfdivd_vsvmvl, 114890}, // __builtin_ve_vl_vfdivd_vsvmvl
+      {Intrinsic::ve_vl_vfdivd_vsvvl, 114920}, // __builtin_ve_vl_vfdivd_vsvvl
+      {Intrinsic::ve_vl_vfdivd_vvvl, 114949}, // __builtin_ve_vl_vfdivd_vvvl
+      {Intrinsic::ve_vl_vfdivd_vvvmvl, 114977}, // __builtin_ve_vl_vfdivd_vvvmvl
+      {Intrinsic::ve_vl_vfdivd_vvvvl, 115007}, // __builtin_ve_vl_vfdivd_vvvvl
+      {Intrinsic::ve_vl_vfdivs_vsvl, 115036}, // __builtin_ve_vl_vfdivs_vsvl
+      {Intrinsic::ve_vl_vfdivs_vsvmvl, 115064}, // __builtin_ve_vl_vfdivs_vsvmvl
+      {Intrinsic::ve_vl_vfdivs_vsvvl, 115094}, // __builtin_ve_vl_vfdivs_vsvvl
+      {Intrinsic::ve_vl_vfdivs_vvvl, 115123}, // __builtin_ve_vl_vfdivs_vvvl
+      {Intrinsic::ve_vl_vfdivs_vvvmvl, 115151}, // __builtin_ve_vl_vfdivs_vvvmvl
+      {Intrinsic::ve_vl_vfdivs_vvvvl, 115181}, // __builtin_ve_vl_vfdivs_vvvvl
+      {Intrinsic::ve_vl_vfmadd_vsvvl, 115210}, // __builtin_ve_vl_vfmadd_vsvvl
+      {Intrinsic::ve_vl_vfmadd_vsvvmvl, 115239}, // __builtin_ve_vl_vfmadd_vsvvmvl
+      {Intrinsic::ve_vl_vfmadd_vsvvvl, 115270}, // __builtin_ve_vl_vfmadd_vsvvvl
+      {Intrinsic::ve_vl_vfmadd_vvsvl, 115300}, // __builtin_ve_vl_vfmadd_vvsvl
+      {Intrinsic::ve_vl_vfmadd_vvsvmvl, 115329}, // __builtin_ve_vl_vfmadd_vvsvmvl
+      {Intrinsic::ve_vl_vfmadd_vvsvvl, 115360}, // __builtin_ve_vl_vfmadd_vvsvvl
+      {Intrinsic::ve_vl_vfmadd_vvvvl, 115390}, // __builtin_ve_vl_vfmadd_vvvvl
+      {Intrinsic::ve_vl_vfmadd_vvvvmvl, 115419}, // __builtin_ve_vl_vfmadd_vvvvmvl
+      {Intrinsic::ve_vl_vfmadd_vvvvvl, 115450}, // __builtin_ve_vl_vfmadd_vvvvvl
+      {Intrinsic::ve_vl_vfmads_vsvvl, 115480}, // __builtin_ve_vl_vfmads_vsvvl
+      {Intrinsic::ve_vl_vfmads_vsvvmvl, 115509}, // __builtin_ve_vl_vfmads_vsvvmvl
+      {Intrinsic::ve_vl_vfmads_vsvvvl, 115540}, // __builtin_ve_vl_vfmads_vsvvvl
+      {Intrinsic::ve_vl_vfmads_vvsvl, 115570}, // __builtin_ve_vl_vfmads_vvsvl
+      {Intrinsic::ve_vl_vfmads_vvsvmvl, 115599}, // __builtin_ve_vl_vfmads_vvsvmvl
+      {Intrinsic::ve_vl_vfmads_vvsvvl, 115630}, // __builtin_ve_vl_vfmads_vvsvvl
+      {Intrinsic::ve_vl_vfmads_vvvvl, 115660}, // __builtin_ve_vl_vfmads_vvvvl
+      {Intrinsic::ve_vl_vfmads_vvvvmvl, 115689}, // __builtin_ve_vl_vfmads_vvvvmvl
+      {Intrinsic::ve_vl_vfmads_vvvvvl, 115720}, // __builtin_ve_vl_vfmads_vvvvvl
+      {Intrinsic::ve_vl_vfmaxd_vsvl, 115750}, // __builtin_ve_vl_vfmaxd_vsvl
+      {Intrinsic::ve_vl_vfmaxd_vsvmvl, 115778}, // __builtin_ve_vl_vfmaxd_vsvmvl
+      {Intrinsic::ve_vl_vfmaxd_vsvvl, 115808}, // __builtin_ve_vl_vfmaxd_vsvvl
+      {Intrinsic::ve_vl_vfmaxd_vvvl, 115837}, // __builtin_ve_vl_vfmaxd_vvvl
+      {Intrinsic::ve_vl_vfmaxd_vvvmvl, 115865}, // __builtin_ve_vl_vfmaxd_vvvmvl
+      {Intrinsic::ve_vl_vfmaxd_vvvvl, 115895}, // __builtin_ve_vl_vfmaxd_vvvvl
+      {Intrinsic::ve_vl_vfmaxs_vsvl, 115924}, // __builtin_ve_vl_vfmaxs_vsvl
+      {Intrinsic::ve_vl_vfmaxs_vsvmvl, 115952}, // __builtin_ve_vl_vfmaxs_vsvmvl
+      {Intrinsic::ve_vl_vfmaxs_vsvvl, 115982}, // __builtin_ve_vl_vfmaxs_vsvvl
+      {Intrinsic::ve_vl_vfmaxs_vvvl, 116011}, // __builtin_ve_vl_vfmaxs_vvvl
+      {Intrinsic::ve_vl_vfmaxs_vvvmvl, 116039}, // __builtin_ve_vl_vfmaxs_vvvmvl
+      {Intrinsic::ve_vl_vfmaxs_vvvvl, 116069}, // __builtin_ve_vl_vfmaxs_vvvvl
+      {Intrinsic::ve_vl_vfmind_vsvl, 116098}, // __builtin_ve_vl_vfmind_vsvl
+      {Intrinsic::ve_vl_vfmind_vsvmvl, 116126}, // __builtin_ve_vl_vfmind_vsvmvl
+      {Intrinsic::ve_vl_vfmind_vsvvl, 116156}, // __builtin_ve_vl_vfmind_vsvvl
+      {Intrinsic::ve_vl_vfmind_vvvl, 116185}, // __builtin_ve_vl_vfmind_vvvl
+      {Intrinsic::ve_vl_vfmind_vvvmvl, 116213}, // __builtin_ve_vl_vfmind_vvvmvl
+      {Intrinsic::ve_vl_vfmind_vvvvl, 116243}, // __builtin_ve_vl_vfmind_vvvvl
+      {Intrinsic::ve_vl_vfmins_vsvl, 116272}, // __builtin_ve_vl_vfmins_vsvl
+      {Intrinsic::ve_vl_vfmins_vsvmvl, 116300}, // __builtin_ve_vl_vfmins_vsvmvl
+      {Intrinsic::ve_vl_vfmins_vsvvl, 116330}, // __builtin_ve_vl_vfmins_vsvvl
+      {Intrinsic::ve_vl_vfmins_vvvl, 116359}, // __builtin_ve_vl_vfmins_vvvl
+      {Intrinsic::ve_vl_vfmins_vvvmvl, 116387}, // __builtin_ve_vl_vfmins_vvvmvl
+      {Intrinsic::ve_vl_vfmins_vvvvl, 116417}, // __builtin_ve_vl_vfmins_vvvvl
+      {Intrinsic::ve_vl_vfmkdeq_mvl, 116446}, // __builtin_ve_vl_vfmkdeq_mvl
+      {Intrinsic::ve_vl_vfmkdeq_mvml, 116474}, // __builtin_ve_vl_vfmkdeq_mvml
+      {Intrinsic::ve_vl_vfmkdeqnan_mvl, 116503}, // __builtin_ve_vl_vfmkdeqnan_mvl
+      {Intrinsic::ve_vl_vfmkdeqnan_mvml, 116534}, // __builtin_ve_vl_vfmkdeqnan_mvml
+      {Intrinsic::ve_vl_vfmkdge_mvl, 116566}, // __builtin_ve_vl_vfmkdge_mvl
+      {Intrinsic::ve_vl_vfmkdge_mvml, 116594}, // __builtin_ve_vl_vfmkdge_mvml
+      {Intrinsic::ve_vl_vfmkdgenan_mvl, 116623}, // __builtin_ve_vl_vfmkdgenan_mvl
+      {Intrinsic::ve_vl_vfmkdgenan_mvml, 116654}, // __builtin_ve_vl_vfmkdgenan_mvml
+      {Intrinsic::ve_vl_vfmkdgt_mvl, 116686}, // __builtin_ve_vl_vfmkdgt_mvl
+      {Intrinsic::ve_vl_vfmkdgt_mvml, 116714}, // __builtin_ve_vl_vfmkdgt_mvml
+      {Intrinsic::ve_vl_vfmkdgtnan_mvl, 116743}, // __builtin_ve_vl_vfmkdgtnan_mvl
+      {Intrinsic::ve_vl_vfmkdgtnan_mvml, 116774}, // __builtin_ve_vl_vfmkdgtnan_mvml
+      {Intrinsic::ve_vl_vfmkdle_mvl, 116806}, // __builtin_ve_vl_vfmkdle_mvl
+      {Intrinsic::ve_vl_vfmkdle_mvml, 116834}, // __builtin_ve_vl_vfmkdle_mvml
+      {Intrinsic::ve_vl_vfmkdlenan_mvl, 116863}, // __builtin_ve_vl_vfmkdlenan_mvl
+      {Intrinsic::ve_vl_vfmkdlenan_mvml, 116894}, // __builtin_ve_vl_vfmkdlenan_mvml
+      {Intrinsic::ve_vl_vfmkdlt_mvl, 116926}, // __builtin_ve_vl_vfmkdlt_mvl
+      {Intrinsic::ve_vl_vfmkdlt_mvml, 116954}, // __builtin_ve_vl_vfmkdlt_mvml
+      {Intrinsic::ve_vl_vfmkdltnan_mvl, 116983}, // __builtin_ve_vl_vfmkdltnan_mvl
+      {Intrinsic::ve_vl_vfmkdltnan_mvml, 117014}, // __builtin_ve_vl_vfmkdltnan_mvml
+      {Intrinsic::ve_vl_vfmkdnan_mvl, 117046}, // __builtin_ve_vl_vfmkdnan_mvl
+      {Intrinsic::ve_vl_vfmkdnan_mvml, 117075}, // __builtin_ve_vl_vfmkdnan_mvml
+      {Intrinsic::ve_vl_vfmkdne_mvl, 117105}, // __builtin_ve_vl_vfmkdne_mvl
+      {Intrinsic::ve_vl_vfmkdne_mvml, 117133}, // __builtin_ve_vl_vfmkdne_mvml
+      {Intrinsic::ve_vl_vfmkdnenan_mvl, 117162}, // __builtin_ve_vl_vfmkdnenan_mvl
+      {Intrinsic::ve_vl_vfmkdnenan_mvml, 117193}, // __builtin_ve_vl_vfmkdnenan_mvml
+      {Intrinsic::ve_vl_vfmkdnum_mvl, 117225}, // __builtin_ve_vl_vfmkdnum_mvl
+      {Intrinsic::ve_vl_vfmkdnum_mvml, 117254}, // __builtin_ve_vl_vfmkdnum_mvml
+      {Intrinsic::ve_vl_vfmklaf_ml, 117284}, // __builtin_ve_vl_vfmklaf_ml
+      {Intrinsic::ve_vl_vfmklat_ml, 117311}, // __builtin_ve_vl_vfmklat_ml
+      {Intrinsic::ve_vl_vfmkleq_mvl, 117338}, // __builtin_ve_vl_vfmkleq_mvl
+      {Intrinsic::ve_vl_vfmkleq_mvml, 117366}, // __builtin_ve_vl_vfmkleq_mvml
+      {Intrinsic::ve_vl_vfmkleqnan_mvl, 117395}, // __builtin_ve_vl_vfmkleqnan_mvl
+      {Intrinsic::ve_vl_vfmkleqnan_mvml, 117426}, // __builtin_ve_vl_vfmkleqnan_mvml
+      {Intrinsic::ve_vl_vfmklge_mvl, 117458}, // __builtin_ve_vl_vfmklge_mvl
+      {Intrinsic::ve_vl_vfmklge_mvml, 117486}, // __builtin_ve_vl_vfmklge_mvml
+      {Intrinsic::ve_vl_vfmklgenan_mvl, 117515}, // __builtin_ve_vl_vfmklgenan_mvl
+      {Intrinsic::ve_vl_vfmklgenan_mvml, 117546}, // __builtin_ve_vl_vfmklgenan_mvml
+      {Intrinsic::ve_vl_vfmklgt_mvl, 117578}, // __builtin_ve_vl_vfmklgt_mvl
+      {Intrinsic::ve_vl_vfmklgt_mvml, 117606}, // __builtin_ve_vl_vfmklgt_mvml
+      {Intrinsic::ve_vl_vfmklgtnan_mvl, 117635}, // __builtin_ve_vl_vfmklgtnan_mvl
+      {Intrinsic::ve_vl_vfmklgtnan_mvml, 117666}, // __builtin_ve_vl_vfmklgtnan_mvml
+      {Intrinsic::ve_vl_vfmklle_mvl, 117698}, // __builtin_ve_vl_vfmklle_mvl
+      {Intrinsic::ve_vl_vfmklle_mvml, 117726}, // __builtin_ve_vl_vfmklle_mvml
+      {Intrinsic::ve_vl_vfmkllenan_mvl, 117755}, // __builtin_ve_vl_vfmkllenan_mvl
+      {Intrinsic::ve_vl_vfmkllenan_mvml, 117786}, // __builtin_ve_vl_vfmkllenan_mvml
+      {Intrinsic::ve_vl_vfmkllt_mvl, 117818}, // __builtin_ve_vl_vfmkllt_mvl
+      {Intrinsic::ve_vl_vfmkllt_mvml, 117846}, // __builtin_ve_vl_vfmkllt_mvml
+      {Intrinsic::ve_vl_vfmklltnan_mvl, 117875}, // __builtin_ve_vl_vfmklltnan_mvl
+      {Intrinsic::ve_vl_vfmklltnan_mvml, 117906}, // __builtin_ve_vl_vfmklltnan_mvml
+      {Intrinsic::ve_vl_vfmklnan_mvl, 117938}, // __builtin_ve_vl_vfmklnan_mvl
+      {Intrinsic::ve_vl_vfmklnan_mvml, 117967}, // __builtin_ve_vl_vfmklnan_mvml
+      {Intrinsic::ve_vl_vfmklne_mvl, 117997}, // __builtin_ve_vl_vfmklne_mvl
+      {Intrinsic::ve_vl_vfmklne_mvml, 118025}, // __builtin_ve_vl_vfmklne_mvml
+      {Intrinsic::ve_vl_vfmklnenan_mvl, 118054}, // __builtin_ve_vl_vfmklnenan_mvl
+      {Intrinsic::ve_vl_vfmklnenan_mvml, 118085}, // __builtin_ve_vl_vfmklnenan_mvml
+      {Intrinsic::ve_vl_vfmklnum_mvl, 118117}, // __builtin_ve_vl_vfmklnum_mvl
+      {Intrinsic::ve_vl_vfmklnum_mvml, 118146}, // __builtin_ve_vl_vfmklnum_mvml
+      {Intrinsic::ve_vl_vfmkseq_mvl, 118176}, // __builtin_ve_vl_vfmkseq_mvl
+      {Intrinsic::ve_vl_vfmkseq_mvml, 118204}, // __builtin_ve_vl_vfmkseq_mvml
+      {Intrinsic::ve_vl_vfmkseqnan_mvl, 118233}, // __builtin_ve_vl_vfmkseqnan_mvl
+      {Intrinsic::ve_vl_vfmkseqnan_mvml, 118264}, // __builtin_ve_vl_vfmkseqnan_mvml
+      {Intrinsic::ve_vl_vfmksge_mvl, 118296}, // __builtin_ve_vl_vfmksge_mvl
+      {Intrinsic::ve_vl_vfmksge_mvml, 118324}, // __builtin_ve_vl_vfmksge_mvml
+      {Intrinsic::ve_vl_vfmksgenan_mvl, 118353}, // __builtin_ve_vl_vfmksgenan_mvl
+      {Intrinsic::ve_vl_vfmksgenan_mvml, 118384}, // __builtin_ve_vl_vfmksgenan_mvml
+      {Intrinsic::ve_vl_vfmksgt_mvl, 118416}, // __builtin_ve_vl_vfmksgt_mvl
+      {Intrinsic::ve_vl_vfmksgt_mvml, 118444}, // __builtin_ve_vl_vfmksgt_mvml
+      {Intrinsic::ve_vl_vfmksgtnan_mvl, 118473}, // __builtin_ve_vl_vfmksgtnan_mvl
+      {Intrinsic::ve_vl_vfmksgtnan_mvml, 118504}, // __builtin_ve_vl_vfmksgtnan_mvml
+      {Intrinsic::ve_vl_vfmksle_mvl, 118536}, // __builtin_ve_vl_vfmksle_mvl
+      {Intrinsic::ve_vl_vfmksle_mvml, 118564}, // __builtin_ve_vl_vfmksle_mvml
+      {Intrinsic::ve_vl_vfmkslenan_mvl, 118593}, // __builtin_ve_vl_vfmkslenan_mvl
+      {Intrinsic::ve_vl_vfmkslenan_mvml, 118624}, // __builtin_ve_vl_vfmkslenan_mvml
+      {Intrinsic::ve_vl_vfmkslt_mvl, 118656}, // __builtin_ve_vl_vfmkslt_mvl
+      {Intrinsic::ve_vl_vfmkslt_mvml, 118684}, // __builtin_ve_vl_vfmkslt_mvml
+      {Intrinsic::ve_vl_vfmksltnan_mvl, 118713}, // __builtin_ve_vl_vfmksltnan_mvl
+      {Intrinsic::ve_vl_vfmksltnan_mvml, 118744}, // __builtin_ve_vl_vfmksltnan_mvml
+      {Intrinsic::ve_vl_vfmksnan_mvl, 118776}, // __builtin_ve_vl_vfmksnan_mvl
+      {Intrinsic::ve_vl_vfmksnan_mvml, 118805}, // __builtin_ve_vl_vfmksnan_mvml
+      {Intrinsic::ve_vl_vfmksne_mvl, 118835}, // __builtin_ve_vl_vfmksne_mvl
+      {Intrinsic::ve_vl_vfmksne_mvml, 118863}, // __builtin_ve_vl_vfmksne_mvml
+      {Intrinsic::ve_vl_vfmksnenan_mvl, 118892}, // __builtin_ve_vl_vfmksnenan_mvl
+      {Intrinsic::ve_vl_vfmksnenan_mvml, 118923}, // __builtin_ve_vl_vfmksnenan_mvml
+      {Intrinsic::ve_vl_vfmksnum_mvl, 118955}, // __builtin_ve_vl_vfmksnum_mvl
+      {Intrinsic::ve_vl_vfmksnum_mvml, 118984}, // __builtin_ve_vl_vfmksnum_mvml
+      {Intrinsic::ve_vl_vfmkweq_mvl, 119014}, // __builtin_ve_vl_vfmkweq_mvl
+      {Intrinsic::ve_vl_vfmkweq_mvml, 119042}, // __builtin_ve_vl_vfmkweq_mvml
+      {Intrinsic::ve_vl_vfmkweqnan_mvl, 119071}, // __builtin_ve_vl_vfmkweqnan_mvl
+      {Intrinsic::ve_vl_vfmkweqnan_mvml, 119102}, // __builtin_ve_vl_vfmkweqnan_mvml
+      {Intrinsic::ve_vl_vfmkwge_mvl, 119134}, // __builtin_ve_vl_vfmkwge_mvl
+      {Intrinsic::ve_vl_vfmkwge_mvml, 119162}, // __builtin_ve_vl_vfmkwge_mvml
+      {Intrinsic::ve_vl_vfmkwgenan_mvl, 119191}, // __builtin_ve_vl_vfmkwgenan_mvl
+      {Intrinsic::ve_vl_vfmkwgenan_mvml, 119222}, // __builtin_ve_vl_vfmkwgenan_mvml
+      {Intrinsic::ve_vl_vfmkwgt_mvl, 119254}, // __builtin_ve_vl_vfmkwgt_mvl
+      {Intrinsic::ve_vl_vfmkwgt_mvml, 119282}, // __builtin_ve_vl_vfmkwgt_mvml
+      {Intrinsic::ve_vl_vfmkwgtnan_mvl, 119311}, // __builtin_ve_vl_vfmkwgtnan_mvl
+      {Intrinsic::ve_vl_vfmkwgtnan_mvml, 119342}, // __builtin_ve_vl_vfmkwgtnan_mvml
+      {Intrinsic::ve_vl_vfmkwle_mvl, 119374}, // __builtin_ve_vl_vfmkwle_mvl
+      {Intrinsic::ve_vl_vfmkwle_mvml, 119402}, // __builtin_ve_vl_vfmkwle_mvml
+      {Intrinsic::ve_vl_vfmkwlenan_mvl, 119431}, // __builtin_ve_vl_vfmkwlenan_mvl
+      {Intrinsic::ve_vl_vfmkwlenan_mvml, 119462}, // __builtin_ve_vl_vfmkwlenan_mvml
+      {Intrinsic::ve_vl_vfmkwlt_mvl, 119494}, // __builtin_ve_vl_vfmkwlt_mvl
+      {Intrinsic::ve_vl_vfmkwlt_mvml, 119522}, // __builtin_ve_vl_vfmkwlt_mvml
+      {Intrinsic::ve_vl_vfmkwltnan_mvl, 119551}, // __builtin_ve_vl_vfmkwltnan_mvl
+      {Intrinsic::ve_vl_vfmkwltnan_mvml, 119582}, // __builtin_ve_vl_vfmkwltnan_mvml
+      {Intrinsic::ve_vl_vfmkwnan_mvl, 119614}, // __builtin_ve_vl_vfmkwnan_mvl
+      {Intrinsic::ve_vl_vfmkwnan_mvml, 119643}, // __builtin_ve_vl_vfmkwnan_mvml
+      {Intrinsic::ve_vl_vfmkwne_mvl, 119673}, // __builtin_ve_vl_vfmkwne_mvl
+      {Intrinsic::ve_vl_vfmkwne_mvml, 119701}, // __builtin_ve_vl_vfmkwne_mvml
+      {Intrinsic::ve_vl_vfmkwnenan_mvl, 119730}, // __builtin_ve_vl_vfmkwnenan_mvl
+      {Intrinsic::ve_vl_vfmkwnenan_mvml, 119761}, // __builtin_ve_vl_vfmkwnenan_mvml
+      {Intrinsic::ve_vl_vfmkwnum_mvl, 119793}, // __builtin_ve_vl_vfmkwnum_mvl
+      {Intrinsic::ve_vl_vfmkwnum_mvml, 119822}, // __builtin_ve_vl_vfmkwnum_mvml
+      {Intrinsic::ve_vl_vfmsbd_vsvvl, 119852}, // __builtin_ve_vl_vfmsbd_vsvvl
+      {Intrinsic::ve_vl_vfmsbd_vsvvmvl, 119881}, // __builtin_ve_vl_vfmsbd_vsvvmvl
+      {Intrinsic::ve_vl_vfmsbd_vsvvvl, 119912}, // __builtin_ve_vl_vfmsbd_vsvvvl
+      {Intrinsic::ve_vl_vfmsbd_vvsvl, 119942}, // __builtin_ve_vl_vfmsbd_vvsvl
+      {Intrinsic::ve_vl_vfmsbd_vvsvmvl, 119971}, // __builtin_ve_vl_vfmsbd_vvsvmvl
+      {Intrinsic::ve_vl_vfmsbd_vvsvvl, 120002}, // __builtin_ve_vl_vfmsbd_vvsvvl
+      {Intrinsic::ve_vl_vfmsbd_vvvvl, 120032}, // __builtin_ve_vl_vfmsbd_vvvvl
+      {Intrinsic::ve_vl_vfmsbd_vvvvmvl, 120061}, // __builtin_ve_vl_vfmsbd_vvvvmvl
+      {Intrinsic::ve_vl_vfmsbd_vvvvvl, 120092}, // __builtin_ve_vl_vfmsbd_vvvvvl
+      {Intrinsic::ve_vl_vfmsbs_vsvvl, 120122}, // __builtin_ve_vl_vfmsbs_vsvvl
+      {Intrinsic::ve_vl_vfmsbs_vsvvmvl, 120151}, // __builtin_ve_vl_vfmsbs_vsvvmvl
+      {Intrinsic::ve_vl_vfmsbs_vsvvvl, 120182}, // __builtin_ve_vl_vfmsbs_vsvvvl
+      {Intrinsic::ve_vl_vfmsbs_vvsvl, 120212}, // __builtin_ve_vl_vfmsbs_vvsvl
+      {Intrinsic::ve_vl_vfmsbs_vvsvmvl, 120241}, // __builtin_ve_vl_vfmsbs_vvsvmvl
+      {Intrinsic::ve_vl_vfmsbs_vvsvvl, 120272}, // __builtin_ve_vl_vfmsbs_vvsvvl
+      {Intrinsic::ve_vl_vfmsbs_vvvvl, 120302}, // __builtin_ve_vl_vfmsbs_vvvvl
+      {Intrinsic::ve_vl_vfmsbs_vvvvmvl, 120331}, // __builtin_ve_vl_vfmsbs_vvvvmvl
+      {Intrinsic::ve_vl_vfmsbs_vvvvvl, 120362}, // __builtin_ve_vl_vfmsbs_vvvvvl
+      {Intrinsic::ve_vl_vfmuld_vsvl, 120392}, // __builtin_ve_vl_vfmuld_vsvl
+      {Intrinsic::ve_vl_vfmuld_vsvmvl, 120420}, // __builtin_ve_vl_vfmuld_vsvmvl
+      {Intrinsic::ve_vl_vfmuld_vsvvl, 120450}, // __builtin_ve_vl_vfmuld_vsvvl
+      {Intrinsic::ve_vl_vfmuld_vvvl, 120479}, // __builtin_ve_vl_vfmuld_vvvl
+      {Intrinsic::ve_vl_vfmuld_vvvmvl, 120507}, // __builtin_ve_vl_vfmuld_vvvmvl
+      {Intrinsic::ve_vl_vfmuld_vvvvl, 120537}, // __builtin_ve_vl_vfmuld_vvvvl
+      {Intrinsic::ve_vl_vfmuls_vsvl, 120566}, // __builtin_ve_vl_vfmuls_vsvl
+      {Intrinsic::ve_vl_vfmuls_vsvmvl, 120594}, // __builtin_ve_vl_vfmuls_vsvmvl
+      {Intrinsic::ve_vl_vfmuls_vsvvl, 120624}, // __builtin_ve_vl_vfmuls_vsvvl
+      {Intrinsic::ve_vl_vfmuls_vvvl, 120653}, // __builtin_ve_vl_vfmuls_vvvl
+      {Intrinsic::ve_vl_vfmuls_vvvmvl, 120681}, // __builtin_ve_vl_vfmuls_vvvmvl
+      {Intrinsic::ve_vl_vfmuls_vvvvl, 120711}, // __builtin_ve_vl_vfmuls_vvvvl
+      {Intrinsic::ve_vl_vfnmadd_vsvvl, 120740}, // __builtin_ve_vl_vfnmadd_vsvvl
+      {Intrinsic::ve_vl_vfnmadd_vsvvmvl, 120770}, // __builtin_ve_vl_vfnmadd_vsvvmvl
+      {Intrinsic::ve_vl_vfnmadd_vsvvvl, 120802}, // __builtin_ve_vl_vfnmadd_vsvvvl
+      {Intrinsic::ve_vl_vfnmadd_vvsvl, 120833}, // __builtin_ve_vl_vfnmadd_vvsvl
+      {Intrinsic::ve_vl_vfnmadd_vvsvmvl, 120863}, // __builtin_ve_vl_vfnmadd_vvsvmvl
+      {Intrinsic::ve_vl_vfnmadd_vvsvvl, 120895}, // __builtin_ve_vl_vfnmadd_vvsvvl
+      {Intrinsic::ve_vl_vfnmadd_vvvvl, 120926}, // __builtin_ve_vl_vfnmadd_vvvvl
+      {Intrinsic::ve_vl_vfnmadd_vvvvmvl, 120956}, // __builtin_ve_vl_vfnmadd_vvvvmvl
+      {Intrinsic::ve_vl_vfnmadd_vvvvvl, 120988}, // __builtin_ve_vl_vfnmadd_vvvvvl
+      {Intrinsic::ve_vl_vfnmads_vsvvl, 121019}, // __builtin_ve_vl_vfnmads_vsvvl
+      {Intrinsic::ve_vl_vfnmads_vsvvmvl, 121049}, // __builtin_ve_vl_vfnmads_vsvvmvl
+      {Intrinsic::ve_vl_vfnmads_vsvvvl, 121081}, // __builtin_ve_vl_vfnmads_vsvvvl
+      {Intrinsic::ve_vl_vfnmads_vvsvl, 121112}, // __builtin_ve_vl_vfnmads_vvsvl
+      {Intrinsic::ve_vl_vfnmads_vvsvmvl, 121142}, // __builtin_ve_vl_vfnmads_vvsvmvl
+      {Intrinsic::ve_vl_vfnmads_vvsvvl, 121174}, // __builtin_ve_vl_vfnmads_vvsvvl
+      {Intrinsic::ve_vl_vfnmads_vvvvl, 121205}, // __builtin_ve_vl_vfnmads_vvvvl
+      {Intrinsic::ve_vl_vfnmads_vvvvmvl, 121235}, // __builtin_ve_vl_vfnmads_vvvvmvl
+      {Intrinsic::ve_vl_vfnmads_vvvvvl, 121267}, // __builtin_ve_vl_vfnmads_vvvvvl
+      {Intrinsic::ve_vl_vfnmsbd_vsvvl, 121298}, // __builtin_ve_vl_vfnmsbd_vsvvl
+      {Intrinsic::ve_vl_vfnmsbd_vsvvmvl, 121328}, // __builtin_ve_vl_vfnmsbd_vsvvmvl
+      {Intrinsic::ve_vl_vfnmsbd_vsvvvl, 121360}, // __builtin_ve_vl_vfnmsbd_vsvvvl
+      {Intrinsic::ve_vl_vfnmsbd_vvsvl, 121391}, // __builtin_ve_vl_vfnmsbd_vvsvl
+      {Intrinsic::ve_vl_vfnmsbd_vvsvmvl, 121421}, // __builtin_ve_vl_vfnmsbd_vvsvmvl
+      {Intrinsic::ve_vl_vfnmsbd_vvsvvl, 121453}, // __builtin_ve_vl_vfnmsbd_vvsvvl
+      {Intrinsic::ve_vl_vfnmsbd_vvvvl, 121484}, // __builtin_ve_vl_vfnmsbd_vvvvl
+      {Intrinsic::ve_vl_vfnmsbd_vvvvmvl, 121514}, // __builtin_ve_vl_vfnmsbd_vvvvmvl
+      {Intrinsic::ve_vl_vfnmsbd_vvvvvl, 121546}, // __builtin_ve_vl_vfnmsbd_vvvvvl
+      {Intrinsic::ve_vl_vfnmsbs_vsvvl, 121577}, // __builtin_ve_vl_vfnmsbs_vsvvl
+      {Intrinsic::ve_vl_vfnmsbs_vsvvmvl, 121607}, // __builtin_ve_vl_vfnmsbs_vsvvmvl
+      {Intrinsic::ve_vl_vfnmsbs_vsvvvl, 121639}, // __builtin_ve_vl_vfnmsbs_vsvvvl
+      {Intrinsic::ve_vl_vfnmsbs_vvsvl, 121670}, // __builtin_ve_vl_vfnmsbs_vvsvl
+      {Intrinsic::ve_vl_vfnmsbs_vvsvmvl, 121700}, // __builtin_ve_vl_vfnmsbs_vvsvmvl
+      {Intrinsic::ve_vl_vfnmsbs_vvsvvl, 121732}, // __builtin_ve_vl_vfnmsbs_vvsvvl
+      {Intrinsic::ve_vl_vfnmsbs_vvvvl, 121763}, // __builtin_ve_vl_vfnmsbs_vvvvl
+      {Intrinsic::ve_vl_vfnmsbs_vvvvmvl, 121793}, // __builtin_ve_vl_vfnmsbs_vvvvmvl
+      {Intrinsic::ve_vl_vfnmsbs_vvvvvl, 121825}, // __builtin_ve_vl_vfnmsbs_vvvvvl
+      {Intrinsic::ve_vl_vfrmaxdfst_vvl, 121856}, // __builtin_ve_vl_vfrmaxdfst_vvl
+      {Intrinsic::ve_vl_vfrmaxdfst_vvvl, 121887}, // __builtin_ve_vl_vfrmaxdfst_vvvl
+      {Intrinsic::ve_vl_vfrmaxdlst_vvl, 121919}, // __builtin_ve_vl_vfrmaxdlst_vvl
+      {Intrinsic::ve_vl_vfrmaxdlst_vvvl, 121950}, // __builtin_ve_vl_vfrmaxdlst_vvvl
+      {Intrinsic::ve_vl_vfrmaxsfst_vvl, 121982}, // __builtin_ve_vl_vfrmaxsfst_vvl
+      {Intrinsic::ve_vl_vfrmaxsfst_vvvl, 122013}, // __builtin_ve_vl_vfrmaxsfst_vvvl
+      {Intrinsic::ve_vl_vfrmaxslst_vvl, 122045}, // __builtin_ve_vl_vfrmaxslst_vvl
+      {Intrinsic::ve_vl_vfrmaxslst_vvvl, 122076}, // __builtin_ve_vl_vfrmaxslst_vvvl
+      {Intrinsic::ve_vl_vfrmindfst_vvl, 122108}, // __builtin_ve_vl_vfrmindfst_vvl
+      {Intrinsic::ve_vl_vfrmindfst_vvvl, 122139}, // __builtin_ve_vl_vfrmindfst_vvvl
+      {Intrinsic::ve_vl_vfrmindlst_vvl, 122171}, // __builtin_ve_vl_vfrmindlst_vvl
+      {Intrinsic::ve_vl_vfrmindlst_vvvl, 122202}, // __builtin_ve_vl_vfrmindlst_vvvl
+      {Intrinsic::ve_vl_vfrminsfst_vvl, 122234}, // __builtin_ve_vl_vfrminsfst_vvl
+      {Intrinsic::ve_vl_vfrminsfst_vvvl, 122265}, // __builtin_ve_vl_vfrminsfst_vvvl
+      {Intrinsic::ve_vl_vfrminslst_vvl, 122297}, // __builtin_ve_vl_vfrminslst_vvl
+      {Intrinsic::ve_vl_vfrminslst_vvvl, 122328}, // __builtin_ve_vl_vfrminslst_vvvl
+      {Intrinsic::ve_vl_vfsqrtd_vvl, 122360}, // __builtin_ve_vl_vfsqrtd_vvl
+      {Intrinsic::ve_vl_vfsqrtd_vvvl, 122388}, // __builtin_ve_vl_vfsqrtd_vvvl
+      {Intrinsic::ve_vl_vfsqrts_vvl, 122417}, // __builtin_ve_vl_vfsqrts_vvl
+      {Intrinsic::ve_vl_vfsqrts_vvvl, 122445}, // __builtin_ve_vl_vfsqrts_vvvl
+      {Intrinsic::ve_vl_vfsubd_vsvl, 122474}, // __builtin_ve_vl_vfsubd_vsvl
+      {Intrinsic::ve_vl_vfsubd_vsvmvl, 122502}, // __builtin_ve_vl_vfsubd_vsvmvl
+      {Intrinsic::ve_vl_vfsubd_vsvvl, 122532}, // __builtin_ve_vl_vfsubd_vsvvl
+      {Intrinsic::ve_vl_vfsubd_vvvl, 122561}, // __builtin_ve_vl_vfsubd_vvvl
+      {Intrinsic::ve_vl_vfsubd_vvvmvl, 122589}, // __builtin_ve_vl_vfsubd_vvvmvl
+      {Intrinsic::ve_vl_vfsubd_vvvvl, 122619}, // __builtin_ve_vl_vfsubd_vvvvl
+      {Intrinsic::ve_vl_vfsubs_vsvl, 122648}, // __builtin_ve_vl_vfsubs_vsvl
+      {Intrinsic::ve_vl_vfsubs_vsvmvl, 122676}, // __builtin_ve_vl_vfsubs_vsvmvl
+      {Intrinsic::ve_vl_vfsubs_vsvvl, 122706}, // __builtin_ve_vl_vfsubs_vsvvl
+      {Intrinsic::ve_vl_vfsubs_vvvl, 122735}, // __builtin_ve_vl_vfsubs_vvvl
+      {Intrinsic::ve_vl_vfsubs_vvvmvl, 122763}, // __builtin_ve_vl_vfsubs_vvvmvl
+      {Intrinsic::ve_vl_vfsubs_vvvvl, 122793}, // __builtin_ve_vl_vfsubs_vvvvl
+      {Intrinsic::ve_vl_vfsumd_vvl, 122822}, // __builtin_ve_vl_vfsumd_vvl
+      {Intrinsic::ve_vl_vfsumd_vvml, 122849}, // __builtin_ve_vl_vfsumd_vvml
+      {Intrinsic::ve_vl_vfsums_vvl, 122877}, // __builtin_ve_vl_vfsums_vvl
+      {Intrinsic::ve_vl_vfsums_vvml, 122904}, // __builtin_ve_vl_vfsums_vvml
+      {Intrinsic::ve_vl_vgt_vvssl, 122932}, // __builtin_ve_vl_vgt_vvssl
+      {Intrinsic::ve_vl_vgt_vvssml, 122958}, // __builtin_ve_vl_vgt_vvssml
+      {Intrinsic::ve_vl_vgt_vvssmvl, 122985}, // __builtin_ve_vl_vgt_vvssmvl
+      {Intrinsic::ve_vl_vgt_vvssvl, 123013}, // __builtin_ve_vl_vgt_vvssvl
+      {Intrinsic::ve_vl_vgtlsx_vvssl, 123040}, // __builtin_ve_vl_vgtlsx_vvssl
+      {Intrinsic::ve_vl_vgtlsx_vvssml, 123069}, // __builtin_ve_vl_vgtlsx_vvssml
+      {Intrinsic::ve_vl_vgtlsx_vvssmvl, 123099}, // __builtin_ve_vl_vgtlsx_vvssmvl
+      {Intrinsic::ve_vl_vgtlsx_vvssvl, 123130}, // __builtin_ve_vl_vgtlsx_vvssvl
+      {Intrinsic::ve_vl_vgtlsxnc_vvssl, 123160}, // __builtin_ve_vl_vgtlsxnc_vvssl
+      {Intrinsic::ve_vl_vgtlsxnc_vvssml, 123191}, // __builtin_ve_vl_vgtlsxnc_vvssml
+      {Intrinsic::ve_vl_vgtlsxnc_vvssmvl, 123223}, // __builtin_ve_vl_vgtlsxnc_vvssmvl
+      {Intrinsic::ve_vl_vgtlsxnc_vvssvl, 123256}, // __builtin_ve_vl_vgtlsxnc_vvssvl
+      {Intrinsic::ve_vl_vgtlzx_vvssl, 123288}, // __builtin_ve_vl_vgtlzx_vvssl
+      {Intrinsic::ve_vl_vgtlzx_vvssml, 123317}, // __builtin_ve_vl_vgtlzx_vvssml
+      {Intrinsic::ve_vl_vgtlzx_vvssmvl, 123347}, // __builtin_ve_vl_vgtlzx_vvssmvl
+      {Intrinsic::ve_vl_vgtlzx_vvssvl, 123378}, // __builtin_ve_vl_vgtlzx_vvssvl
+      {Intrinsic::ve_vl_vgtlzxnc_vvssl, 123408}, // __builtin_ve_vl_vgtlzxnc_vvssl
+      {Intrinsic::ve_vl_vgtlzxnc_vvssml, 123439}, // __builtin_ve_vl_vgtlzxnc_vvssml
+      {Intrinsic::ve_vl_vgtlzxnc_vvssmvl, 123471}, // __builtin_ve_vl_vgtlzxnc_vvssmvl
+      {Intrinsic::ve_vl_vgtlzxnc_vvssvl, 123504}, // __builtin_ve_vl_vgtlzxnc_vvssvl
+      {Intrinsic::ve_vl_vgtnc_vvssl, 123536}, // __builtin_ve_vl_vgtnc_vvssl
+      {Intrinsic::ve_vl_vgtnc_vvssml, 123564}, // __builtin_ve_vl_vgtnc_vvssml
+      {Intrinsic::ve_vl_vgtnc_vvssmvl, 123593}, // __builtin_ve_vl_vgtnc_vvssmvl
+      {Intrinsic::ve_vl_vgtnc_vvssvl, 123623}, // __builtin_ve_vl_vgtnc_vvssvl
+      {Intrinsic::ve_vl_vgtu_vvssl, 123652}, // __builtin_ve_vl_vgtu_vvssl
+      {Intrinsic::ve_vl_vgtu_vvssml, 123679}, // __builtin_ve_vl_vgtu_vvssml
+      {Intrinsic::ve_vl_vgtu_vvssmvl, 123707}, // __builtin_ve_vl_vgtu_vvssmvl
+      {Intrinsic::ve_vl_vgtu_vvssvl, 123736}, // __builtin_ve_vl_vgtu_vvssvl
+      {Intrinsic::ve_vl_vgtunc_vvssl, 123764}, // __builtin_ve_vl_vgtunc_vvssl
+      {Intrinsic::ve_vl_vgtunc_vvssml, 123793}, // __builtin_ve_vl_vgtunc_vvssml
+      {Intrinsic::ve_vl_vgtunc_vvssmvl, 123823}, // __builtin_ve_vl_vgtunc_vvssmvl
+      {Intrinsic::ve_vl_vgtunc_vvssvl, 123854}, // __builtin_ve_vl_vgtunc_vvssvl
+      {Intrinsic::ve_vl_vld2d_vssl, 123935}, // __builtin_ve_vl_vld2d_vssl
+      {Intrinsic::ve_vl_vld2d_vssvl, 123962}, // __builtin_ve_vl_vld2d_vssvl
+      {Intrinsic::ve_vl_vld2dnc_vssl, 123990}, // __builtin_ve_vl_vld2dnc_vssl
+      {Intrinsic::ve_vl_vld2dnc_vssvl, 124019}, // __builtin_ve_vl_vld2dnc_vssvl
+      {Intrinsic::ve_vl_vld_vssl, 123884}, // __builtin_ve_vl_vld_vssl
+      {Intrinsic::ve_vl_vld_vssvl, 123909}, // __builtin_ve_vl_vld_vssvl
+      {Intrinsic::ve_vl_vldl2dsx_vssl, 124049}, // __builtin_ve_vl_vldl2dsx_vssl
+      {Intrinsic::ve_vl_vldl2dsx_vssvl, 124079}, // __builtin_ve_vl_vldl2dsx_vssvl
+      {Intrinsic::ve_vl_vldl2dsxnc_vssl, 124110}, // __builtin_ve_vl_vldl2dsxnc_vssl
+      {Intrinsic::ve_vl_vldl2dsxnc_vssvl, 124142}, // __builtin_ve_vl_vldl2dsxnc_vssvl
+      {Intrinsic::ve_vl_vldl2dzx_vssl, 124175}, // __builtin_ve_vl_vldl2dzx_vssl
+      {Intrinsic::ve_vl_vldl2dzx_vssvl, 124205}, // __builtin_ve_vl_vldl2dzx_vssvl
+      {Intrinsic::ve_vl_vldl2dzxnc_vssl, 124236}, // __builtin_ve_vl_vldl2dzxnc_vssl
+      {Intrinsic::ve_vl_vldl2dzxnc_vssvl, 124268}, // __builtin_ve_vl_vldl2dzxnc_vssvl
+      {Intrinsic::ve_vl_vldlsx_vssl, 124301}, // __builtin_ve_vl_vldlsx_vssl
+      {Intrinsic::ve_vl_vldlsx_vssvl, 124329}, // __builtin_ve_vl_vldlsx_vssvl
+      {Intrinsic::ve_vl_vldlsxnc_vssl, 124358}, // __builtin_ve_vl_vldlsxnc_vssl
+      {Intrinsic::ve_vl_vldlsxnc_vssvl, 124388}, // __builtin_ve_vl_vldlsxnc_vssvl
+      {Intrinsic::ve_vl_vldlzx_vssl, 124419}, // __builtin_ve_vl_vldlzx_vssl
+      {Intrinsic::ve_vl_vldlzx_vssvl, 124447}, // __builtin_ve_vl_vldlzx_vssvl
+      {Intrinsic::ve_vl_vldlzxnc_vssl, 124476}, // __builtin_ve_vl_vldlzxnc_vssl
+      {Intrinsic::ve_vl_vldlzxnc_vssvl, 124506}, // __builtin_ve_vl_vldlzxnc_vssvl
+      {Intrinsic::ve_vl_vldnc_vssl, 124537}, // __builtin_ve_vl_vldnc_vssl
+      {Intrinsic::ve_vl_vldnc_vssvl, 124564}, // __builtin_ve_vl_vldnc_vssvl
+      {Intrinsic::ve_vl_vldu2d_vssl, 124645}, // __builtin_ve_vl_vldu2d_vssl
+      {Intrinsic::ve_vl_vldu2d_vssvl, 124673}, // __builtin_ve_vl_vldu2d_vssvl
+      {Intrinsic::ve_vl_vldu2dnc_vssl, 124702}, // __builtin_ve_vl_vldu2dnc_vssl
+      {Intrinsic::ve_vl_vldu2dnc_vssvl, 124732}, // __builtin_ve_vl_vldu2dnc_vssvl
+      {Intrinsic::ve_vl_vldu_vssl, 124592}, // __builtin_ve_vl_vldu_vssl
+      {Intrinsic::ve_vl_vldu_vssvl, 124618}, // __builtin_ve_vl_vldu_vssvl
+      {Intrinsic::ve_vl_vldunc_vssl, 124763}, // __builtin_ve_vl_vldunc_vssl
+      {Intrinsic::ve_vl_vldunc_vssvl, 124791}, // __builtin_ve_vl_vldunc_vssvl
+      {Intrinsic::ve_vl_vmaxsl_vsvl, 124820}, // __builtin_ve_vl_vmaxsl_vsvl
+      {Intrinsic::ve_vl_vmaxsl_vsvmvl, 124848}, // __builtin_ve_vl_vmaxsl_vsvmvl
+      {Intrinsic::ve_vl_vmaxsl_vsvvl, 124878}, // __builtin_ve_vl_vmaxsl_vsvvl
+      {Intrinsic::ve_vl_vmaxsl_vvvl, 124907}, // __builtin_ve_vl_vmaxsl_vvvl
+      {Intrinsic::ve_vl_vmaxsl_vvvmvl, 124935}, // __builtin_ve_vl_vmaxsl_vvvmvl
+      {Intrinsic::ve_vl_vmaxsl_vvvvl, 124965}, // __builtin_ve_vl_vmaxsl_vvvvl
+      {Intrinsic::ve_vl_vmaxswsx_vsvl, 124994}, // __builtin_ve_vl_vmaxswsx_vsvl
+      {Intrinsic::ve_vl_vmaxswsx_vsvmvl, 125024}, // __builtin_ve_vl_vmaxswsx_vsvmvl
+      {Intrinsic::ve_vl_vmaxswsx_vsvvl, 125056}, // __builtin_ve_vl_vmaxswsx_vsvvl
+      {Intrinsic::ve_vl_vmaxswsx_vvvl, 125087}, // __builtin_ve_vl_vmaxswsx_vvvl
+      {Intrinsic::ve_vl_vmaxswsx_vvvmvl, 125117}, // __builtin_ve_vl_vmaxswsx_vvvmvl
+      {Intrinsic::ve_vl_vmaxswsx_vvvvl, 125149}, // __builtin_ve_vl_vmaxswsx_vvvvl
+      {Intrinsic::ve_vl_vmaxswzx_vsvl, 125180}, // __builtin_ve_vl_vmaxswzx_vsvl
+      {Intrinsic::ve_vl_vmaxswzx_vsvmvl, 125210}, // __builtin_ve_vl_vmaxswzx_vsvmvl
+      {Intrinsic::ve_vl_vmaxswzx_vsvvl, 125242}, // __builtin_ve_vl_vmaxswzx_vsvvl
+      {Intrinsic::ve_vl_vmaxswzx_vvvl, 125273}, // __builtin_ve_vl_vmaxswzx_vvvl
+      {Intrinsic::ve_vl_vmaxswzx_vvvmvl, 125303}, // __builtin_ve_vl_vmaxswzx_vvvmvl
+      {Intrinsic::ve_vl_vmaxswzx_vvvvl, 125335}, // __builtin_ve_vl_vmaxswzx_vvvvl
+      {Intrinsic::ve_vl_vminsl_vsvl, 125366}, // __builtin_ve_vl_vminsl_vsvl
+      {Intrinsic::ve_vl_vminsl_vsvmvl, 125394}, // __builtin_ve_vl_vminsl_vsvmvl
+      {Intrinsic::ve_vl_vminsl_vsvvl, 125424}, // __builtin_ve_vl_vminsl_vsvvl
+      {Intrinsic::ve_vl_vminsl_vvvl, 125453}, // __builtin_ve_vl_vminsl_vvvl
+      {Intrinsic::ve_vl_vminsl_vvvmvl, 125481}, // __builtin_ve_vl_vminsl_vvvmvl
+      {Intrinsic::ve_vl_vminsl_vvvvl, 125511}, // __builtin_ve_vl_vminsl_vvvvl
+      {Intrinsic::ve_vl_vminswsx_vsvl, 125540}, // __builtin_ve_vl_vminswsx_vsvl
+      {Intrinsic::ve_vl_vminswsx_vsvmvl, 125570}, // __builtin_ve_vl_vminswsx_vsvmvl
+      {Intrinsic::ve_vl_vminswsx_vsvvl, 125602}, // __builtin_ve_vl_vminswsx_vsvvl
+      {Intrinsic::ve_vl_vminswsx_vvvl, 125633}, // __builtin_ve_vl_vminswsx_vvvl
+      {Intrinsic::ve_vl_vminswsx_vvvmvl, 125663}, // __builtin_ve_vl_vminswsx_vvvmvl
+      {Intrinsic::ve_vl_vminswsx_vvvvl, 125695}, // __builtin_ve_vl_vminswsx_vvvvl
+      {Intrinsic::ve_vl_vminswzx_vsvl, 125726}, // __builtin_ve_vl_vminswzx_vsvl
+      {Intrinsic::ve_vl_vminswzx_vsvmvl, 125756}, // __builtin_ve_vl_vminswzx_vsvmvl
+      {Intrinsic::ve_vl_vminswzx_vsvvl, 125788}, // __builtin_ve_vl_vminswzx_vsvvl
+      {Intrinsic::ve_vl_vminswzx_vvvl, 125819}, // __builtin_ve_vl_vminswzx_vvvl
+      {Intrinsic::ve_vl_vminswzx_vvvmvl, 125849}, // __builtin_ve_vl_vminswzx_vvvmvl
+      {Intrinsic::ve_vl_vminswzx_vvvvl, 125881}, // __builtin_ve_vl_vminswzx_vvvvl
+      {Intrinsic::ve_vl_vmrg_vsvml, 125912}, // __builtin_ve_vl_vmrg_vsvml
+      {Intrinsic::ve_vl_vmrg_vsvmvl, 125939}, // __builtin_ve_vl_vmrg_vsvmvl
+      {Intrinsic::ve_vl_vmrg_vvvml, 125967}, // __builtin_ve_vl_vmrg_vvvml
+      {Intrinsic::ve_vl_vmrg_vvvmvl, 125994}, // __builtin_ve_vl_vmrg_vvvmvl
+      {Intrinsic::ve_vl_vmrgw_vsvMl, 126022}, // __builtin_ve_vl_vmrgw_vsvMl
+      {Intrinsic::ve_vl_vmrgw_vsvMvl, 126050}, // __builtin_ve_vl_vmrgw_vsvMvl
+      {Intrinsic::ve_vl_vmrgw_vvvMl, 126079}, // __builtin_ve_vl_vmrgw_vvvMl
+      {Intrinsic::ve_vl_vmrgw_vvvMvl, 126107}, // __builtin_ve_vl_vmrgw_vvvMvl
+      {Intrinsic::ve_vl_vmulsl_vsvl, 126136}, // __builtin_ve_vl_vmulsl_vsvl
+      {Intrinsic::ve_vl_vmulsl_vsvmvl, 126164}, // __builtin_ve_vl_vmulsl_vsvmvl
+      {Intrinsic::ve_vl_vmulsl_vsvvl, 126194}, // __builtin_ve_vl_vmulsl_vsvvl
+      {Intrinsic::ve_vl_vmulsl_vvvl, 126223}, // __builtin_ve_vl_vmulsl_vvvl
+      {Intrinsic::ve_vl_vmulsl_vvvmvl, 126251}, // __builtin_ve_vl_vmulsl_vvvmvl
+      {Intrinsic::ve_vl_vmulsl_vvvvl, 126281}, // __builtin_ve_vl_vmulsl_vvvvl
+      {Intrinsic::ve_vl_vmulslw_vsvl, 126310}, // __builtin_ve_vl_vmulslw_vsvl
+      {Intrinsic::ve_vl_vmulslw_vsvvl, 126339}, // __builtin_ve_vl_vmulslw_vsvvl
+      {Intrinsic::ve_vl_vmulslw_vvvl, 126369}, // __builtin_ve_vl_vmulslw_vvvl
+      {Intrinsic::ve_vl_vmulslw_vvvvl, 126398}, // __builtin_ve_vl_vmulslw_vvvvl
+      {Intrinsic::ve_vl_vmulswsx_vsvl, 126428}, // __builtin_ve_vl_vmulswsx_vsvl
+      {Intrinsic::ve_vl_vmulswsx_vsvmvl, 126458}, // __builtin_ve_vl_vmulswsx_vsvmvl
+      {Intrinsic::ve_vl_vmulswsx_vsvvl, 126490}, // __builtin_ve_vl_vmulswsx_vsvvl
+      {Intrinsic::ve_vl_vmulswsx_vvvl, 126521}, // __builtin_ve_vl_vmulswsx_vvvl
+      {Intrinsic::ve_vl_vmulswsx_vvvmvl, 126551}, // __builtin_ve_vl_vmulswsx_vvvmvl
+      {Intrinsic::ve_vl_vmulswsx_vvvvl, 126583}, // __builtin_ve_vl_vmulswsx_vvvvl
+      {Intrinsic::ve_vl_vmulswzx_vsvl, 126614}, // __builtin_ve_vl_vmulswzx_vsvl
+      {Intrinsic::ve_vl_vmulswzx_vsvmvl, 126644}, // __builtin_ve_vl_vmulswzx_vsvmvl
+      {Intrinsic::ve_vl_vmulswzx_vsvvl, 126676}, // __builtin_ve_vl_vmulswzx_vsvvl
+      {Intrinsic::ve_vl_vmulswzx_vvvl, 126707}, // __builtin_ve_vl_vmulswzx_vvvl
+      {Intrinsic::ve_vl_vmulswzx_vvvmvl, 126737}, // __builtin_ve_vl_vmulswzx_vvvmvl
+      {Intrinsic::ve_vl_vmulswzx_vvvvl, 126769}, // __builtin_ve_vl_vmulswzx_vvvvl
+      {Intrinsic::ve_vl_vmulul_vsvl, 126800}, // __builtin_ve_vl_vmulul_vsvl
+      {Intrinsic::ve_vl_vmulul_vsvmvl, 126828}, // __builtin_ve_vl_vmulul_vsvmvl
+      {Intrinsic::ve_vl_vmulul_vsvvl, 126858}, // __builtin_ve_vl_vmulul_vsvvl
+      {Intrinsic::ve_vl_vmulul_vvvl, 126887}, // __builtin_ve_vl_vmulul_vvvl
+      {Intrinsic::ve_vl_vmulul_vvvmvl, 126915}, // __builtin_ve_vl_vmulul_vvvmvl
+      {Intrinsic::ve_vl_vmulul_vvvvl, 126945}, // __builtin_ve_vl_vmulul_vvvvl
+      {Intrinsic::ve_vl_vmuluw_vsvl, 126974}, // __builtin_ve_vl_vmuluw_vsvl
+      {Intrinsic::ve_vl_vmuluw_vsvmvl, 127002}, // __builtin_ve_vl_vmuluw_vsvmvl
+      {Intrinsic::ve_vl_vmuluw_vsvvl, 127032}, // __builtin_ve_vl_vmuluw_vsvvl
+      {Intrinsic::ve_vl_vmuluw_vvvl, 127061}, // __builtin_ve_vl_vmuluw_vvvl
+      {Intrinsic::ve_vl_vmuluw_vvvmvl, 127089}, // __builtin_ve_vl_vmuluw_vvvmvl
+      {Intrinsic::ve_vl_vmuluw_vvvvl, 127119}, // __builtin_ve_vl_vmuluw_vvvvl
+      {Intrinsic::ve_vl_vmv_vsvl, 127148}, // __builtin_ve_vl_vmv_vsvl
+      {Intrinsic::ve_vl_vmv_vsvmvl, 127173}, // __builtin_ve_vl_vmv_vsvmvl
+      {Intrinsic::ve_vl_vmv_vsvvl, 127200}, // __builtin_ve_vl_vmv_vsvvl
+      {Intrinsic::ve_vl_vor_vsvl, 127226}, // __builtin_ve_vl_vor_vsvl
+      {Intrinsic::ve_vl_vor_vsvmvl, 127251}, // __builtin_ve_vl_vor_vsvmvl
+      {Intrinsic::ve_vl_vor_vsvvl, 127278}, // __builtin_ve_vl_vor_vsvvl
+      {Intrinsic::ve_vl_vor_vvvl, 127304}, // __builtin_ve_vl_vor_vvvl
+      {Intrinsic::ve_vl_vor_vvvmvl, 127329}, // __builtin_ve_vl_vor_vvvmvl
+      {Intrinsic::ve_vl_vor_vvvvl, 127356}, // __builtin_ve_vl_vor_vvvvl
+      {Intrinsic::ve_vl_vrand_vvl, 127382}, // __builtin_ve_vl_vrand_vvl
+      {Intrinsic::ve_vl_vrand_vvml, 127408}, // __builtin_ve_vl_vrand_vvml
+      {Intrinsic::ve_vl_vrcpd_vvl, 127435}, // __builtin_ve_vl_vrcpd_vvl
+      {Intrinsic::ve_vl_vrcpd_vvvl, 127461}, // __builtin_ve_vl_vrcpd_vvvl
+      {Intrinsic::ve_vl_vrcps_vvl, 127488}, // __builtin_ve_vl_vrcps_vvl
+      {Intrinsic::ve_vl_vrcps_vvvl, 127514}, // __builtin_ve_vl_vrcps_vvvl
+      {Intrinsic::ve_vl_vrmaxslfst_vvl, 127541}, // __builtin_ve_vl_vrmaxslfst_vvl
+      {Intrinsic::ve_vl_vrmaxslfst_vvvl, 127572}, // __builtin_ve_vl_vrmaxslfst_vvvl
+      {Intrinsic::ve_vl_vrmaxsllst_vvl, 127604}, // __builtin_ve_vl_vrmaxsllst_vvl
+      {Intrinsic::ve_vl_vrmaxsllst_vvvl, 127635}, // __builtin_ve_vl_vrmaxsllst_vvvl
+      {Intrinsic::ve_vl_vrmaxswfstsx_vvl, 127667}, // __builtin_ve_vl_vrmaxswfstsx_vvl
+      {Intrinsic::ve_vl_vrmaxswfstsx_vvvl, 127700}, // __builtin_ve_vl_vrmaxswfstsx_vvvl
+      {Intrinsic::ve_vl_vrmaxswfstzx_vvl, 127734}, // __builtin_ve_vl_vrmaxswfstzx_vvl
+      {Intrinsic::ve_vl_vrmaxswfstzx_vvvl, 127767}, // __builtin_ve_vl_vrmaxswfstzx_vvvl
+      {Intrinsic::ve_vl_vrmaxswlstsx_vvl, 127801}, // __builtin_ve_vl_vrmaxswlstsx_vvl
+      {Intrinsic::ve_vl_vrmaxswlstsx_vvvl, 127834}, // __builtin_ve_vl_vrmaxswlstsx_vvvl
+      {Intrinsic::ve_vl_vrmaxswlstzx_vvl, 127868}, // __builtin_ve_vl_vrmaxswlstzx_vvl
+      {Intrinsic::ve_vl_vrmaxswlstzx_vvvl, 127901}, // __builtin_ve_vl_vrmaxswlstzx_vvvl
+      {Intrinsic::ve_vl_vrminslfst_vvl, 127935}, // __builtin_ve_vl_vrminslfst_vvl
+      {Intrinsic::ve_vl_vrminslfst_vvvl, 127966}, // __builtin_ve_vl_vrminslfst_vvvl
+      {Intrinsic::ve_vl_vrminsllst_vvl, 127998}, // __builtin_ve_vl_vrminsllst_vvl
+      {Intrinsic::ve_vl_vrminsllst_vvvl, 128029}, // __builtin_ve_vl_vrminsllst_vvvl
+      {Intrinsic::ve_vl_vrminswfstsx_vvl, 128061}, // __builtin_ve_vl_vrminswfstsx_vvl
+      {Intrinsic::ve_vl_vrminswfstsx_vvvl, 128094}, // __builtin_ve_vl_vrminswfstsx_vvvl
+      {Intrinsic::ve_vl_vrminswfstzx_vvl, 128128}, // __builtin_ve_vl_vrminswfstzx_vvl
+      {Intrinsic::ve_vl_vrminswfstzx_vvvl, 128161}, // __builtin_ve_vl_vrminswfstzx_vvvl
+      {Intrinsic::ve_vl_vrminswlstsx_vvl, 128195}, // __builtin_ve_vl_vrminswlstsx_vvl
+      {Intrinsic::ve_vl_vrminswlstsx_vvvl, 128228}, // __builtin_ve_vl_vrminswlstsx_vvvl
+      {Intrinsic::ve_vl_vrminswlstzx_vvl, 128262}, // __builtin_ve_vl_vrminswlstzx_vvl
+      {Intrinsic::ve_vl_vrminswlstzx_vvvl, 128295}, // __builtin_ve_vl_vrminswlstzx_vvvl
+      {Intrinsic::ve_vl_vror_vvl, 128329}, // __builtin_ve_vl_vror_vvl
+      {Intrinsic::ve_vl_vror_vvml, 128354}, // __builtin_ve_vl_vror_vvml
+      {Intrinsic::ve_vl_vrsqrtd_vvl, 128380}, // __builtin_ve_vl_vrsqrtd_vvl
+      {Intrinsic::ve_vl_vrsqrtd_vvvl, 128408}, // __builtin_ve_vl_vrsqrtd_vvvl
+      {Intrinsic::ve_vl_vrsqrtdnex_vvl, 128437}, // __builtin_ve_vl_vrsqrtdnex_vvl
+      {Intrinsic::ve_vl_vrsqrtdnex_vvvl, 128468}, // __builtin_ve_vl_vrsqrtdnex_vvvl
+      {Intrinsic::ve_vl_vrsqrts_vvl, 128500}, // __builtin_ve_vl_vrsqrts_vvl
+      {Intrinsic::ve_vl_vrsqrts_vvvl, 128528}, // __builtin_ve_vl_vrsqrts_vvvl
+      {Intrinsic::ve_vl_vrsqrtsnex_vvl, 128557}, // __builtin_ve_vl_vrsqrtsnex_vvl
+      {Intrinsic::ve_vl_vrsqrtsnex_vvvl, 128588}, // __builtin_ve_vl_vrsqrtsnex_vvvl
+      {Intrinsic::ve_vl_vrxor_vvl, 128620}, // __builtin_ve_vl_vrxor_vvl
+      {Intrinsic::ve_vl_vrxor_vvml, 128646}, // __builtin_ve_vl_vrxor_vvml
+      {Intrinsic::ve_vl_vsc_vvssl, 128673}, // __builtin_ve_vl_vsc_vvssl
+      {Intrinsic::ve_vl_vsc_vvssml, 128699}, // __builtin_ve_vl_vsc_vvssml
+      {Intrinsic::ve_vl_vscl_vvssl, 128726}, // __builtin_ve_vl_vscl_vvssl
+      {Intrinsic::ve_vl_vscl_vvssml, 128753}, // __builtin_ve_vl_vscl_vvssml
+      {Intrinsic::ve_vl_vsclnc_vvssl, 128781}, // __builtin_ve_vl_vsclnc_vvssl
+      {Intrinsic::ve_vl_vsclnc_vvssml, 128810}, // __builtin_ve_vl_vsclnc_vvssml
+      {Intrinsic::ve_vl_vsclncot_vvssl, 128840}, // __builtin_ve_vl_vsclncot_vvssl
+      {Intrinsic::ve_vl_vsclncot_vvssml, 128871}, // __builtin_ve_vl_vsclncot_vvssml
+      {Intrinsic::ve_vl_vsclot_vvssl, 128903}, // __builtin_ve_vl_vsclot_vvssl
+      {Intrinsic::ve_vl_vsclot_vvssml, 128932}, // __builtin_ve_vl_vsclot_vvssml
+      {Intrinsic::ve_vl_vscnc_vvssl, 128962}, // __builtin_ve_vl_vscnc_vvssl
+      {Intrinsic::ve_vl_vscnc_vvssml, 128990}, // __builtin_ve_vl_vscnc_vvssml
+      {Intrinsic::ve_vl_vscncot_vvssl, 129019}, // __builtin_ve_vl_vscncot_vvssl
+      {Intrinsic::ve_vl_vscncot_vvssml, 129049}, // __builtin_ve_vl_vscncot_vvssml
+      {Intrinsic::ve_vl_vscot_vvssl, 129080}, // __builtin_ve_vl_vscot_vvssl
+      {Intrinsic::ve_vl_vscot_vvssml, 129108}, // __builtin_ve_vl_vscot_vvssml
+      {Intrinsic::ve_vl_vscu_vvssl, 129137}, // __builtin_ve_vl_vscu_vvssl
+      {Intrinsic::ve_vl_vscu_vvssml, 129164}, // __builtin_ve_vl_vscu_vvssml
+      {Intrinsic::ve_vl_vscunc_vvssl, 129192}, // __builtin_ve_vl_vscunc_vvssl
+      {Intrinsic::ve_vl_vscunc_vvssml, 129221}, // __builtin_ve_vl_vscunc_vvssml
+      {Intrinsic::ve_vl_vscuncot_vvssl, 129251}, // __builtin_ve_vl_vscuncot_vvssl
+      {Intrinsic::ve_vl_vscuncot_vvssml, 129282}, // __builtin_ve_vl_vscuncot_vvssml
+      {Intrinsic::ve_vl_vscuot_vvssl, 129314}, // __builtin_ve_vl_vscuot_vvssl
+      {Intrinsic::ve_vl_vscuot_vvssml, 129343}, // __builtin_ve_vl_vscuot_vvssml
+      {Intrinsic::ve_vl_vseq_vl, 129373}, // __builtin_ve_vl_vseq_vl
+      {Intrinsic::ve_vl_vseq_vvl, 129397}, // __builtin_ve_vl_vseq_vvl
+      {Intrinsic::ve_vl_vsfa_vvssl, 129422}, // __builtin_ve_vl_vsfa_vvssl
+      {Intrinsic::ve_vl_vsfa_vvssmvl, 129449}, // __builtin_ve_vl_vsfa_vvssmvl
+      {Intrinsic::ve_vl_vsfa_vvssvl, 129478}, // __builtin_ve_vl_vsfa_vvssvl
+      {Intrinsic::ve_vl_vshf_vvvsl, 129506}, // __builtin_ve_vl_vshf_vvvsl
+      {Intrinsic::ve_vl_vshf_vvvsvl, 129533}, // __builtin_ve_vl_vshf_vvvsvl
+      {Intrinsic::ve_vl_vslal_vvsl, 129561}, // __builtin_ve_vl_vslal_vvsl
+      {Intrinsic::ve_vl_vslal_vvsmvl, 129588}, // __builtin_ve_vl_vslal_vvsmvl
+      {Intrinsic::ve_vl_vslal_vvsvl, 129617}, // __builtin_ve_vl_vslal_vvsvl
+      {Intrinsic::ve_vl_vslal_vvvl, 129645}, // __builtin_ve_vl_vslal_vvvl
+      {Intrinsic::ve_vl_vslal_vvvmvl, 129672}, // __builtin_ve_vl_vslal_vvvmvl
+      {Intrinsic::ve_vl_vslal_vvvvl, 129701}, // __builtin_ve_vl_vslal_vvvvl
+      {Intrinsic::ve_vl_vslawsx_vvsl, 129729}, // __builtin_ve_vl_vslawsx_vvsl
+      {Intrinsic::ve_vl_vslawsx_vvsmvl, 129758}, // __builtin_ve_vl_vslawsx_vvsmvl
+      {Intrinsic::ve_vl_vslawsx_vvsvl, 129789}, // __builtin_ve_vl_vslawsx_vvsvl
+      {Intrinsic::ve_vl_vslawsx_vvvl, 129819}, // __builtin_ve_vl_vslawsx_vvvl
+      {Intrinsic::ve_vl_vslawsx_vvvmvl, 129848}, // __builtin_ve_vl_vslawsx_vvvmvl
+      {Intrinsic::ve_vl_vslawsx_vvvvl, 129879}, // __builtin_ve_vl_vslawsx_vvvvl
+      {Intrinsic::ve_vl_vslawzx_vvsl, 129909}, // __builtin_ve_vl_vslawzx_vvsl
+      {Intrinsic::ve_vl_vslawzx_vvsmvl, 129938}, // __builtin_ve_vl_vslawzx_vvsmvl
+      {Intrinsic::ve_vl_vslawzx_vvsvl, 129969}, // __builtin_ve_vl_vslawzx_vvsvl
+      {Intrinsic::ve_vl_vslawzx_vvvl, 129999}, // __builtin_ve_vl_vslawzx_vvvl
+      {Intrinsic::ve_vl_vslawzx_vvvmvl, 130028}, // __builtin_ve_vl_vslawzx_vvvmvl
+      {Intrinsic::ve_vl_vslawzx_vvvvl, 130059}, // __builtin_ve_vl_vslawzx_vvvvl
+      {Intrinsic::ve_vl_vsll_vvsl, 130089}, // __builtin_ve_vl_vsll_vvsl
+      {Intrinsic::ve_vl_vsll_vvsmvl, 130115}, // __builtin_ve_vl_vsll_vvsmvl
+      {Intrinsic::ve_vl_vsll_vvsvl, 130143}, // __builtin_ve_vl_vsll_vvsvl
+      {Intrinsic::ve_vl_vsll_vvvl, 130170}, // __builtin_ve_vl_vsll_vvvl
+      {Intrinsic::ve_vl_vsll_vvvmvl, 130196}, // __builtin_ve_vl_vsll_vvvmvl
+      {Intrinsic::ve_vl_vsll_vvvvl, 130224}, // __builtin_ve_vl_vsll_vvvvl
+      {Intrinsic::ve_vl_vsral_vvsl, 130251}, // __builtin_ve_vl_vsral_vvsl
+      {Intrinsic::ve_vl_vsral_vvsmvl, 130278}, // __builtin_ve_vl_vsral_vvsmvl
+      {Intrinsic::ve_vl_vsral_vvsvl, 130307}, // __builtin_ve_vl_vsral_vvsvl
+      {Intrinsic::ve_vl_vsral_vvvl, 130335}, // __builtin_ve_vl_vsral_vvvl
+      {Intrinsic::ve_vl_vsral_vvvmvl, 130362}, // __builtin_ve_vl_vsral_vvvmvl
+      {Intrinsic::ve_vl_vsral_vvvvl, 130391}, // __builtin_ve_vl_vsral_vvvvl
+      {Intrinsic::ve_vl_vsrawsx_vvsl, 130419}, // __builtin_ve_vl_vsrawsx_vvsl
+      {Intrinsic::ve_vl_vsrawsx_vvsmvl, 130448}, // __builtin_ve_vl_vsrawsx_vvsmvl
+      {Intrinsic::ve_vl_vsrawsx_vvsvl, 130479}, // __builtin_ve_vl_vsrawsx_vvsvl
+      {Intrinsic::ve_vl_vsrawsx_vvvl, 130509}, // __builtin_ve_vl_vsrawsx_vvvl
+      {Intrinsic::ve_vl_vsrawsx_vvvmvl, 130538}, // __builtin_ve_vl_vsrawsx_vvvmvl
+      {Intrinsic::ve_vl_vsrawsx_vvvvl, 130569}, // __builtin_ve_vl_vsrawsx_vvvvl
+      {Intrinsic::ve_vl_vsrawzx_vvsl, 130599}, // __builtin_ve_vl_vsrawzx_vvsl
+      {Intrinsic::ve_vl_vsrawzx_vvsmvl, 130628}, // __builtin_ve_vl_vsrawzx_vvsmvl
+      {Intrinsic::ve_vl_vsrawzx_vvsvl, 130659}, // __builtin_ve_vl_vsrawzx_vvsvl
+      {Intrinsic::ve_vl_vsrawzx_vvvl, 130689}, // __builtin_ve_vl_vsrawzx_vvvl
+      {Intrinsic::ve_vl_vsrawzx_vvvmvl, 130718}, // __builtin_ve_vl_vsrawzx_vvvmvl
+      {Intrinsic::ve_vl_vsrawzx_vvvvl, 130749}, // __builtin_ve_vl_vsrawzx_vvvvl
+      {Intrinsic::ve_vl_vsrl_vvsl, 130779}, // __builtin_ve_vl_vsrl_vvsl
+      {Intrinsic::ve_vl_vsrl_vvsmvl, 130805}, // __builtin_ve_vl_vsrl_vvsmvl
+      {Intrinsic::ve_vl_vsrl_vvsvl, 130833}, // __builtin_ve_vl_vsrl_vvsvl
+      {Intrinsic::ve_vl_vsrl_vvvl, 130860}, // __builtin_ve_vl_vsrl_vvvl
+      {Intrinsic::ve_vl_vsrl_vvvmvl, 130886}, // __builtin_ve_vl_vsrl_vvvmvl
+      {Intrinsic::ve_vl_vsrl_vvvvl, 130914}, // __builtin_ve_vl_vsrl_vvvvl
+      {Intrinsic::ve_vl_vst2d_vssl, 130992}, // __builtin_ve_vl_vst2d_vssl
+      {Intrinsic::ve_vl_vst2d_vssml, 131019}, // __builtin_ve_vl_vst2d_vssml
+      {Intrinsic::ve_vl_vst2dnc_vssl, 131047}, // __builtin_ve_vl_vst2dnc_vssl
+      {Intrinsic::ve_vl_vst2dnc_vssml, 131076}, // __builtin_ve_vl_vst2dnc_vssml
+      {Intrinsic::ve_vl_vst2dncot_vssl, 131106}, // __builtin_ve_vl_vst2dncot_vssl
+      {Intrinsic::ve_vl_vst2dncot_vssml, 131137}, // __builtin_ve_vl_vst2dncot_vssml
+      {Intrinsic::ve_vl_vst2dot_vssl, 131169}, // __builtin_ve_vl_vst2dot_vssl
+      {Intrinsic::ve_vl_vst2dot_vssml, 131198}, // __builtin_ve_vl_vst2dot_vssml
+      {Intrinsic::ve_vl_vst_vssl, 130941}, // __builtin_ve_vl_vst_vssl
+      {Intrinsic::ve_vl_vst_vssml, 130966}, // __builtin_ve_vl_vst_vssml
+      {Intrinsic::ve_vl_vstl2d_vssl, 131281}, // __builtin_ve_vl_vstl2d_vssl
+      {Intrinsic::ve_vl_vstl2d_vssml, 131309}, // __builtin_ve_vl_vstl2d_vssml
+      {Intrinsic::ve_vl_vstl2dnc_vssl, 131338}, // __builtin_ve_vl_vstl2dnc_vssl
+      {Intrinsic::ve_vl_vstl2dnc_vssml, 131368}, // __builtin_ve_vl_vstl2dnc_vssml
+      {Intrinsic::ve_vl_vstl2dncot_vssl, 131399}, // __builtin_ve_vl_vstl2dncot_vssl
+      {Intrinsic::ve_vl_vstl2dncot_vssml, 131431}, // __builtin_ve_vl_vstl2dncot_vssml
+      {Intrinsic::ve_vl_vstl2dot_vssl, 131464}, // __builtin_ve_vl_vstl2dot_vssl
+      {Intrinsic::ve_vl_vstl2dot_vssml, 131494}, // __builtin_ve_vl_vstl2dot_vssml
+      {Intrinsic::ve_vl_vstl_vssl, 131228}, // __builtin_ve_vl_vstl_vssl
+      {Intrinsic::ve_vl_vstl_vssml, 131254}, // __builtin_ve_vl_vstl_vssml
+      {Intrinsic::ve_vl_vstlnc_vssl, 131525}, // __builtin_ve_vl_vstlnc_vssl
+      {Intrinsic::ve_vl_vstlnc_vssml, 131553}, // __builtin_ve_vl_vstlnc_vssml
+      {Intrinsic::ve_vl_vstlncot_vssl, 131582}, // __builtin_ve_vl_vstlncot_vssl
+      {Intrinsic::ve_vl_vstlncot_vssml, 131612}, // __builtin_ve_vl_vstlncot_vssml
+      {Intrinsic::ve_vl_vstlot_vssl, 131643}, // __builtin_ve_vl_vstlot_vssl
+      {Intrinsic::ve_vl_vstlot_vssml, 131671}, // __builtin_ve_vl_vstlot_vssml
+      {Intrinsic::ve_vl_vstnc_vssl, 131700}, // __builtin_ve_vl_vstnc_vssl
+      {Intrinsic::ve_vl_vstnc_vssml, 131727}, // __builtin_ve_vl_vstnc_vssml
+      {Intrinsic::ve_vl_vstncot_vssl, 131755}, // __builtin_ve_vl_vstncot_vssl
+      {Intrinsic::ve_vl_vstncot_vssml, 131784}, // __builtin_ve_vl_vstncot_vssml
+      {Intrinsic::ve_vl_vstot_vssl, 131814}, // __builtin_ve_vl_vstot_vssl
+      {Intrinsic::ve_vl_vstot_vssml, 131841}, // __builtin_ve_vl_vstot_vssml
+      {Intrinsic::ve_vl_vstu2d_vssl, 131922}, // __builtin_ve_vl_vstu2d_vssl
+      {Intrinsic::ve_vl_vstu2d_vssml, 131950}, // __builtin_ve_vl_vstu2d_vssml
+      {Intrinsic::ve_vl_vstu2dnc_vssl, 131979}, // __builtin_ve_vl_vstu2dnc_vssl
+      {Intrinsic::ve_vl_vstu2dnc_vssml, 132009}, // __builtin_ve_vl_vstu2dnc_vssml
+      {Intrinsic::ve_vl_vstu2dncot_vssl, 132040}, // __builtin_ve_vl_vstu2dncot_vssl
+      {Intrinsic::ve_vl_vstu2dncot_vssml, 132072}, // __builtin_ve_vl_vstu2dncot_vssml
+      {Intrinsic::ve_vl_vstu2dot_vssl, 132105}, // __builtin_ve_vl_vstu2dot_vssl
+      {Intrinsic::ve_vl_vstu2dot_vssml, 132135}, // __builtin_ve_vl_vstu2dot_vssml
+      {Intrinsic::ve_vl_vstu_vssl, 131869}, // __builtin_ve_vl_vstu_vssl
+      {Intrinsic::ve_vl_vstu_vssml, 131895}, // __builtin_ve_vl_vstu_vssml
+      {Intrinsic::ve_vl_vstunc_vssl, 132166}, // __builtin_ve_vl_vstunc_vssl
+      {Intrinsic::ve_vl_vstunc_vssml, 132194}, // __builtin_ve_vl_vstunc_vssml
+      {Intrinsic::ve_vl_vstuncot_vssl, 132223}, // __builtin_ve_vl_vstuncot_vssl
+      {Intrinsic::ve_vl_vstuncot_vssml, 132253}, // __builtin_ve_vl_vstuncot_vssml
+      {Intrinsic::ve_vl_vstuot_vssl, 132284}, // __builtin_ve_vl_vstuot_vssl
+      {Intrinsic::ve_vl_vstuot_vssml, 132312}, // __builtin_ve_vl_vstuot_vssml
+      {Intrinsic::ve_vl_vsubsl_vsvl, 132341}, // __builtin_ve_vl_vsubsl_vsvl
+      {Intrinsic::ve_vl_vsubsl_vsvmvl, 132369}, // __builtin_ve_vl_vsubsl_vsvmvl
+      {Intrinsic::ve_vl_vsubsl_vsvvl, 132399}, // __builtin_ve_vl_vsubsl_vsvvl
+      {Intrinsic::ve_vl_vsubsl_vvvl, 132428}, // __builtin_ve_vl_vsubsl_vvvl
+      {Intrinsic::ve_vl_vsubsl_vvvmvl, 132456}, // __builtin_ve_vl_vsubsl_vvvmvl
+      {Intrinsic::ve_vl_vsubsl_vvvvl, 132486}, // __builtin_ve_vl_vsubsl_vvvvl
+      {Intrinsic::ve_vl_vsubswsx_vsvl, 132515}, // __builtin_ve_vl_vsubswsx_vsvl
+      {Intrinsic::ve_vl_vsubswsx_vsvmvl, 132545}, // __builtin_ve_vl_vsubswsx_vsvmvl
+      {Intrinsic::ve_vl_vsubswsx_vsvvl, 132577}, // __builtin_ve_vl_vsubswsx_vsvvl
+      {Intrinsic::ve_vl_vsubswsx_vvvl, 132608}, // __builtin_ve_vl_vsubswsx_vvvl
+      {Intrinsic::ve_vl_vsubswsx_vvvmvl, 132638}, // __builtin_ve_vl_vsubswsx_vvvmvl
+      {Intrinsic::ve_vl_vsubswsx_vvvvl, 132670}, // __builtin_ve_vl_vsubswsx_vvvvl
+      {Intrinsic::ve_vl_vsubswzx_vsvl, 132701}, // __builtin_ve_vl_vsubswzx_vsvl
+      {Intrinsic::ve_vl_vsubswzx_vsvmvl, 132731}, // __builtin_ve_vl_vsubswzx_vsvmvl
+      {Intrinsic::ve_vl_vsubswzx_vsvvl, 132763}, // __builtin_ve_vl_vsubswzx_vsvvl
+      {Intrinsic::ve_vl_vsubswzx_vvvl, 132794}, // __builtin_ve_vl_vsubswzx_vvvl
+      {Intrinsic::ve_vl_vsubswzx_vvvmvl, 132824}, // __builtin_ve_vl_vsubswzx_vvvmvl
+      {Intrinsic::ve_vl_vsubswzx_vvvvl, 132856}, // __builtin_ve_vl_vsubswzx_vvvvl
+      {Intrinsic::ve_vl_vsubul_vsvl, 132887}, // __builtin_ve_vl_vsubul_vsvl
+      {Intrinsic::ve_vl_vsubul_vsvmvl, 132915}, // __builtin_ve_vl_vsubul_vsvmvl
+      {Intrinsic::ve_vl_vsubul_vsvvl, 132945}, // __builtin_ve_vl_vsubul_vsvvl
+      {Intrinsic::ve_vl_vsubul_vvvl, 132974}, // __builtin_ve_vl_vsubul_vvvl
+      {Intrinsic::ve_vl_vsubul_vvvmvl, 133002}, // __builtin_ve_vl_vsubul_vvvmvl
+      {Intrinsic::ve_vl_vsubul_vvvvl, 133032}, // __builtin_ve_vl_vsubul_vvvvl
+      {Intrinsic::ve_vl_vsubuw_vsvl, 133061}, // __builtin_ve_vl_vsubuw_vsvl
+      {Intrinsic::ve_vl_vsubuw_vsvmvl, 133089}, // __builtin_ve_vl_vsubuw_vsvmvl
+      {Intrinsic::ve_vl_vsubuw_vsvvl, 133119}, // __builtin_ve_vl_vsubuw_vsvvl
+      {Intrinsic::ve_vl_vsubuw_vvvl, 133148}, // __builtin_ve_vl_vsubuw_vvvl
+      {Intrinsic::ve_vl_vsubuw_vvvmvl, 133176}, // __builtin_ve_vl_vsubuw_vvvmvl
+      {Intrinsic::ve_vl_vsubuw_vvvvl, 133206}, // __builtin_ve_vl_vsubuw_vvvvl
+      {Intrinsic::ve_vl_vsuml_vvl, 133235}, // __builtin_ve_vl_vsuml_vvl
+      {Intrinsic::ve_vl_vsuml_vvml, 133261}, // __builtin_ve_vl_vsuml_vvml
+      {Intrinsic::ve_vl_vsumwsx_vvl, 133288}, // __builtin_ve_vl_vsumwsx_vvl
+      {Intrinsic::ve_vl_vsumwsx_vvml, 133316}, // __builtin_ve_vl_vsumwsx_vvml
+      {Intrinsic::ve_vl_vsumwzx_vvl, 133345}, // __builtin_ve_vl_vsumwzx_vvl
+      {Intrinsic::ve_vl_vsumwzx_vvml, 133373}, // __builtin_ve_vl_vsumwzx_vvml
+      {Intrinsic::ve_vl_vxor_vsvl, 133402}, // __builtin_ve_vl_vxor_vsvl
+      {Intrinsic::ve_vl_vxor_vsvmvl, 133428}, // __builtin_ve_vl_vxor_vsvmvl
+      {Intrinsic::ve_vl_vxor_vsvvl, 133456}, // __builtin_ve_vl_vxor_vsvvl
+      {Intrinsic::ve_vl_vxor_vvvl, 133483}, // __builtin_ve_vl_vxor_vvvl
+      {Intrinsic::ve_vl_vxor_vvvmvl, 133509}, // __builtin_ve_vl_vxor_vvvmvl
+      {Intrinsic::ve_vl_vxor_vvvvl, 133537}, // __builtin_ve_vl_vxor_vvvvl
+      {Intrinsic::ve_vl_xorm_MMM, 133564}, // __builtin_ve_vl_xorm_MMM
+      {Intrinsic::ve_vl_xorm_mmm, 133589}, // __builtin_ve_vl_xorm_mmm
+    };
+    auto I = std::lower_bound(std::begin(veNames),
+                              std::end(veNames),
+                              BuiltinNameStr);
+    if (I != std::end(veNames) &&
+        I->getName() == BuiltinNameStr)
+      return I->IntrinID;
+  }
   if (TargetPrefix == "x86") {
     static const BuiltinEntry x86Names[] = {
-      {Intrinsic::x86_avx512_add_pd_512, 105226}, // __builtin_ia32_addpd512
-      {Intrinsic::x86_avx512_add_ps_512, 105250}, // __builtin_ia32_addps512
-      {Intrinsic::x86_avx512_mask_add_sd_round, 106324}, // __builtin_ia32_addsd_round_mask
-      {Intrinsic::x86_avx512_mask_add_ss_round, 106356}, // __builtin_ia32_addss_round_mask
-      {Intrinsic::x86_sse3_addsub_pd, 124046}, // __builtin_ia32_addsubpd
-      {Intrinsic::x86_avx_addsub_pd_256, 101818}, // __builtin_ia32_addsubpd256
-      {Intrinsic::x86_sse3_addsub_ps, 124070}, // __builtin_ia32_addsubps
-      {Intrinsic::x86_avx_addsub_ps_256, 101845}, // __builtin_ia32_addsubps256
-      {Intrinsic::x86_aesni_aesdec, 101435}, // __builtin_ia32_aesdec128
-      {Intrinsic::x86_aesni_aesdec_256, 101460}, // __builtin_ia32_aesdec256
-      {Intrinsic::x86_aesni_aesdec_512, 101485}, // __builtin_ia32_aesdec512
-      {Intrinsic::x86_aesni_aesdeclast, 101510}, // __builtin_ia32_aesdeclast128
-      {Intrinsic::x86_aesni_aesdeclast_256, 101539}, // __builtin_ia32_aesdeclast256
-      {Intrinsic::x86_aesni_aesdeclast_512, 101568}, // __builtin_ia32_aesdeclast512
-      {Intrinsic::x86_aesni_aesenc, 101597}, // __builtin_ia32_aesenc128
-      {Intrinsic::x86_aesni_aesenc_256, 101622}, // __builtin_ia32_aesenc256
-      {Intrinsic::x86_aesni_aesenc_512, 101647}, // __builtin_ia32_aesenc512
-      {Intrinsic::x86_aesni_aesenclast, 101672}, // __builtin_ia32_aesenclast128
-      {Intrinsic::x86_aesni_aesenclast_256, 101701}, // __builtin_ia32_aesenclast256
-      {Intrinsic::x86_aesni_aesenclast_512, 101730}, // __builtin_ia32_aesenclast512
-      {Intrinsic::x86_aesni_aesimc, 101759}, // __builtin_ia32_aesimc128
-      {Intrinsic::x86_aesni_aeskeygenassist, 101784}, // __builtin_ia32_aeskeygenassist128
-      {Intrinsic::x86_bmi_bextr_32, 118715}, // __builtin_ia32_bextr_u32
-      {Intrinsic::x86_bmi_bextr_64, 118740}, // __builtin_ia32_bextr_u64
-      {Intrinsic::x86_tbm_bextri_u32, 125865}, // __builtin_ia32_bextri_u32
-      {Intrinsic::x86_tbm_bextri_u64, 125891}, // __builtin_ia32_bextri_u64
-      {Intrinsic::x86_sse41_blendvpd, 124247}, // __builtin_ia32_blendvpd
-      {Intrinsic::x86_avx_blendv_pd_256, 101872}, // __builtin_ia32_blendvpd256
-      {Intrinsic::x86_sse41_blendvps, 124271}, // __builtin_ia32_blendvps
-      {Intrinsic::x86_avx_blendv_ps_256, 101899}, // __builtin_ia32_blendvps256
-      {Intrinsic::x86_avx512_broadcastmb_128, 105274}, // __builtin_ia32_broadcastmb128
-      {Intrinsic::x86_avx512_broadcastmb_256, 105304}, // __builtin_ia32_broadcastmb256
-      {Intrinsic::x86_avx512_broadcastmb_512, 105334}, // __builtin_ia32_broadcastmb512
-      {Intrinsic::x86_avx512_broadcastmw_128, 105364}, // __builtin_ia32_broadcastmw128
-      {Intrinsic::x86_avx512_broadcastmw_256, 105394}, // __builtin_ia32_broadcastmw256
-      {Intrinsic::x86_avx512_broadcastmw_512, 105424}, // __builtin_ia32_broadcastmw512
-      {Intrinsic::x86_bmi_bzhi_64, 118788}, // __builtin_ia32_bzhi_di
-      {Intrinsic::x86_bmi_bzhi_32, 118765}, // __builtin_ia32_bzhi_si
-      {Intrinsic::x86_cldemote, 118903}, // __builtin_ia32_cldemote
-      {Intrinsic::x86_sse2_clflush, 122609}, // __builtin_ia32_clflush
-      {Intrinsic::x86_clflushopt, 118927}, // __builtin_ia32_clflushopt
-      {Intrinsic::x86_clrssbsy, 118953}, // __builtin_ia32_clrssbsy
-      {Intrinsic::x86_clwb, 118977}, // __builtin_ia32_clwb
-      {Intrinsic::x86_clzero, 118997}, // __builtin_ia32_clzero
-      {Intrinsic::x86_sse2_cmp_sd, 122632}, // __builtin_ia32_cmpsd
-      {Intrinsic::x86_avx512_mask_cmp_sd, 106388}, // __builtin_ia32_cmpsd_mask
-      {Intrinsic::x86_sse_cmp_ss, 121828}, // __builtin_ia32_cmpss
-      {Intrinsic::x86_avx512_mask_cmp_ss, 106414}, // __builtin_ia32_cmpss_mask
-      {Intrinsic::x86_sse_comieq_ss, 121849}, // __builtin_ia32_comieq
-      {Intrinsic::x86_sse_comige_ss, 121871}, // __builtin_ia32_comige
-      {Intrinsic::x86_sse_comigt_ss, 121893}, // __builtin_ia32_comigt
-      {Intrinsic::x86_sse_comile_ss, 121915}, // __builtin_ia32_comile
-      {Intrinsic::x86_sse_comilt_ss, 121937}, // __builtin_ia32_comilt
-      {Intrinsic::x86_sse_comineq_ss, 121959}, // __builtin_ia32_comineq
-      {Intrinsic::x86_sse2_comieq_sd, 122653}, // __builtin_ia32_comisdeq
-      {Intrinsic::x86_sse2_comige_sd, 122677}, // __builtin_ia32_comisdge
-      {Intrinsic::x86_sse2_comigt_sd, 122701}, // __builtin_ia32_comisdgt
-      {Intrinsic::x86_sse2_comile_sd, 122725}, // __builtin_ia32_comisdle
-      {Intrinsic::x86_sse2_comilt_sd, 122749}, // __builtin_ia32_comisdlt
-      {Intrinsic::x86_sse2_comineq_sd, 122773}, // __builtin_ia32_comisdneq
-      {Intrinsic::x86_sse42_crc32_64_64, 124709}, // __builtin_ia32_crc32di
-      {Intrinsic::x86_sse42_crc32_32_16, 124640}, // __builtin_ia32_crc32hi
-      {Intrinsic::x86_sse42_crc32_32_8, 124686}, // __builtin_ia32_crc32qi
-      {Intrinsic::x86_sse42_crc32_32_32, 124663}, // __builtin_ia32_crc32si
-      {Intrinsic::x86_avx512bf16_cvtne2ps2bf16_128, 118468}, // __builtin_ia32_cvtne2ps2bf16_128
-      {Intrinsic::x86_avx512bf16_cvtne2ps2bf16_256, 118501}, // __builtin_ia32_cvtne2ps2bf16_256
-      {Intrinsic::x86_avx512bf16_cvtne2ps2bf16_512, 118534}, // __builtin_ia32_cvtne2ps2bf16_512
-      {Intrinsic::x86_avx512bf16_cvtneps2bf16_256, 118567}, // __builtin_ia32_cvtneps2bf16_256
-      {Intrinsic::x86_avx512bf16_cvtneps2bf16_512, 118599}, // __builtin_ia32_cvtneps2bf16_512
-      {Intrinsic::x86_sse2_cvtpd2dq, 122798}, // __builtin_ia32_cvtpd2dq
-      {Intrinsic::x86_avx512_mask_cvtpd2dq_128, 106440}, // __builtin_ia32_cvtpd2dq128_mask
-      {Intrinsic::x86_avx_cvt_pd2dq_256, 101953}, // __builtin_ia32_cvtpd2dq256
-      {Intrinsic::x86_avx512_mask_cvtpd2dq_512, 106472}, // __builtin_ia32_cvtpd2dq512_mask
-      {Intrinsic::x86_sse_cvtpd2pi, 121982}, // __builtin_ia32_cvtpd2pi
-      {Intrinsic::x86_sse2_cvtpd2ps, 122822}, // __builtin_ia32_cvtpd2ps
-      {Intrinsic::x86_avx_cvt_pd2_ps_256, 101926}, // __builtin_ia32_cvtpd2ps256
-      {Intrinsic::x86_avx512_mask_cvtpd2ps_512, 106533}, // __builtin_ia32_cvtpd2ps512_mask
-      {Intrinsic::x86_avx512_mask_cvtpd2ps, 106504}, // __builtin_ia32_cvtpd2ps_mask
-      {Intrinsic::x86_avx512_mask_cvtpd2qq_128, 106565}, // __builtin_ia32_cvtpd2qq128_mask
-      {Intrinsic::x86_avx512_mask_cvtpd2qq_256, 106597}, // __builtin_ia32_cvtpd2qq256_mask
-      {Intrinsic::x86_avx512_mask_cvtpd2qq_512, 106629}, // __builtin_ia32_cvtpd2qq512_mask
-      {Intrinsic::x86_avx512_mask_cvtpd2udq_128, 106661}, // __builtin_ia32_cvtpd2udq128_mask
-      {Intrinsic::x86_avx512_mask_cvtpd2udq_256, 106694}, // __builtin_ia32_cvtpd2udq256_mask
-      {Intrinsic::x86_avx512_mask_cvtpd2udq_512, 106727}, // __builtin_ia32_cvtpd2udq512_mask
-      {Intrinsic::x86_avx512_mask_cvtpd2uqq_128, 106760}, // __builtin_ia32_cvtpd2uqq128_mask
-      {Intrinsic::x86_avx512_mask_cvtpd2uqq_256, 106793}, // __builtin_ia32_cvtpd2uqq256_mask
-      {Intrinsic::x86_avx512_mask_cvtpd2uqq_512, 106826}, // __builtin_ia32_cvtpd2uqq512_mask
-      {Intrinsic::x86_sse_cvtpi2pd, 122006}, // __builtin_ia32_cvtpi2pd
-      {Intrinsic::x86_sse_cvtpi2ps, 122030}, // __builtin_ia32_cvtpi2ps
-      {Intrinsic::x86_sse2_cvtps2dq, 122846}, // __builtin_ia32_cvtps2dq
-      {Intrinsic::x86_avx512_mask_cvtps2dq_128, 106859}, // __builtin_ia32_cvtps2dq128_mask
-      {Intrinsic::x86_avx_cvt_ps2dq_256, 101980}, // __builtin_ia32_cvtps2dq256
-      {Intrinsic::x86_avx512_mask_cvtps2dq_256, 106891}, // __builtin_ia32_cvtps2dq256_mask
-      {Intrinsic::x86_avx512_mask_cvtps2dq_512, 106923}, // __builtin_ia32_cvtps2dq512_mask
-      {Intrinsic::x86_avx512_mask_cvtps2pd_512, 106955}, // __builtin_ia32_cvtps2pd512_mask
-      {Intrinsic::x86_sse_cvtps2pi, 122054}, // __builtin_ia32_cvtps2pi
-      {Intrinsic::x86_avx512_mask_cvtps2qq_128, 106987}, // __builtin_ia32_cvtps2qq128_mask
-      {Intrinsic::x86_avx512_mask_cvtps2qq_256, 107019}, // __builtin_ia32_cvtps2qq256_mask
-      {Intrinsic::x86_avx512_mask_cvtps2qq_512, 107051}, // __builtin_ia32_cvtps2qq512_mask
-      {Intrinsic::x86_avx512_mask_cvtps2udq_128, 107083}, // __builtin_ia32_cvtps2udq128_mask
-      {Intrinsic::x86_avx512_mask_cvtps2udq_256, 107116}, // __builtin_ia32_cvtps2udq256_mask
-      {Intrinsic::x86_avx512_mask_cvtps2udq_512, 107149}, // __builtin_ia32_cvtps2udq512_mask
-      {Intrinsic::x86_avx512_mask_cvtps2uqq_128, 107182}, // __builtin_ia32_cvtps2uqq128_mask
-      {Intrinsic::x86_avx512_mask_cvtps2uqq_256, 107215}, // __builtin_ia32_cvtps2uqq256_mask
-      {Intrinsic::x86_avx512_mask_cvtps2uqq_512, 107248}, // __builtin_ia32_cvtps2uqq512_mask
-      {Intrinsic::x86_avx512_mask_cvtqq2ps_128, 107281}, // __builtin_ia32_cvtqq2ps128_mask
-      {Intrinsic::x86_sse2_cvtsd2si, 122870}, // __builtin_ia32_cvtsd2si
-      {Intrinsic::x86_sse2_cvtsd2si64, 122894}, // __builtin_ia32_cvtsd2si64
-      {Intrinsic::x86_sse2_cvtsd2ss, 122920}, // __builtin_ia32_cvtsd2ss
-      {Intrinsic::x86_avx512_mask_cvtsd2ss_round, 107313}, // __builtin_ia32_cvtsd2ss_round_mask
-      {Intrinsic::x86_avx512_cvtsi2sd64, 105646}, // __builtin_ia32_cvtsi2sd64
-      {Intrinsic::x86_avx512_cvtsi2ss32, 105672}, // __builtin_ia32_cvtsi2ss32
-      {Intrinsic::x86_avx512_cvtsi2ss64, 105698}, // __builtin_ia32_cvtsi2ss64
-      {Intrinsic::x86_avx512_mask_cvtss2sd_round, 107348}, // __builtin_ia32_cvtss2sd_round_mask
-      {Intrinsic::x86_sse_cvtss2si, 122078}, // __builtin_ia32_cvtss2si
-      {Intrinsic::x86_sse_cvtss2si64, 122102}, // __builtin_ia32_cvtss2si64
-      {Intrinsic::x86_sse2_cvttpd2dq, 122944}, // __builtin_ia32_cvttpd2dq
-      {Intrinsic::x86_avx512_mask_cvttpd2dq_128, 107383}, // __builtin_ia32_cvttpd2dq128_mask
-      {Intrinsic::x86_avx_cvtt_pd2dq_256, 102007}, // __builtin_ia32_cvttpd2dq256
-      {Intrinsic::x86_avx512_mask_cvttpd2dq_512, 107416}, // __builtin_ia32_cvttpd2dq512_mask
-      {Intrinsic::x86_sse_cvttpd2pi, 122128}, // __builtin_ia32_cvttpd2pi
-      {Intrinsic::x86_avx512_mask_cvttpd2qq_128, 107449}, // __builtin_ia32_cvttpd2qq128_mask
-      {Intrinsic::x86_avx512_mask_cvttpd2qq_256, 107482}, // __builtin_ia32_cvttpd2qq256_mask
-      {Intrinsic::x86_avx512_mask_cvttpd2qq_512, 107515}, // __builtin_ia32_cvttpd2qq512_mask
-      {Intrinsic::x86_avx512_mask_cvttpd2udq_128, 107548}, // __builtin_ia32_cvttpd2udq128_mask
-      {Intrinsic::x86_avx512_mask_cvttpd2udq_256, 107582}, // __builtin_ia32_cvttpd2udq256_mask
-      {Intrinsic::x86_avx512_mask_cvttpd2udq_512, 107616}, // __builtin_ia32_cvttpd2udq512_mask
-      {Intrinsic::x86_avx512_mask_cvttpd2uqq_128, 107650}, // __builtin_ia32_cvttpd2uqq128_mask
-      {Intrinsic::x86_avx512_mask_cvttpd2uqq_256, 107684}, // __builtin_ia32_cvttpd2uqq256_mask
-      {Intrinsic::x86_avx512_mask_cvttpd2uqq_512, 107718}, // __builtin_ia32_cvttpd2uqq512_mask
-      {Intrinsic::x86_sse2_cvttps2dq, 122969}, // __builtin_ia32_cvttps2dq
-      {Intrinsic::x86_avx_cvtt_ps2dq_256, 102035}, // __builtin_ia32_cvttps2dq256
-      {Intrinsic::x86_avx512_mask_cvttps2dq_512, 107752}, // __builtin_ia32_cvttps2dq512_mask
-      {Intrinsic::x86_sse_cvttps2pi, 122153}, // __builtin_ia32_cvttps2pi
-      {Intrinsic::x86_avx512_mask_cvttps2qq_128, 107785}, // __builtin_ia32_cvttps2qq128_mask
-      {Intrinsic::x86_avx512_mask_cvttps2qq_256, 107818}, // __builtin_ia32_cvttps2qq256_mask
-      {Intrinsic::x86_avx512_mask_cvttps2qq_512, 107851}, // __builtin_ia32_cvttps2qq512_mask
-      {Intrinsic::x86_avx512_mask_cvttps2udq_128, 107884}, // __builtin_ia32_cvttps2udq128_mask
-      {Intrinsic::x86_avx512_mask_cvttps2udq_256, 107918}, // __builtin_ia32_cvttps2udq256_mask
-      {Intrinsic::x86_avx512_mask_cvttps2udq_512, 107952}, // __builtin_ia32_cvttps2udq512_mask
-      {Intrinsic::x86_avx512_mask_cvttps2uqq_128, 107986}, // __builtin_ia32_cvttps2uqq128_mask
-      {Intrinsic::x86_avx512_mask_cvttps2uqq_256, 108020}, // __builtin_ia32_cvttps2uqq256_mask
-      {Intrinsic::x86_avx512_mask_cvttps2uqq_512, 108054}, // __builtin_ia32_cvttps2uqq512_mask
-      {Intrinsic::x86_sse2_cvttsd2si, 122994}, // __builtin_ia32_cvttsd2si
-      {Intrinsic::x86_sse2_cvttsd2si64, 123019}, // __builtin_ia32_cvttsd2si64
-      {Intrinsic::x86_sse_cvttss2si, 122178}, // __builtin_ia32_cvttss2si
-      {Intrinsic::x86_sse_cvttss2si64, 122203}, // __builtin_ia32_cvttss2si64
-      {Intrinsic::x86_avx512_mask_cvtuqq2ps_128, 108088}, // __builtin_ia32_cvtuqq2ps128_mask
-      {Intrinsic::x86_avx512_cvtusi642sd, 105979}, // __builtin_ia32_cvtusi2sd64
-      {Intrinsic::x86_avx512_cvtusi2ss, 105952}, // __builtin_ia32_cvtusi2ss32
-      {Intrinsic::x86_avx512_cvtusi642ss, 106006}, // __builtin_ia32_cvtusi2ss64
-      {Intrinsic::x86_avx512_dbpsadbw_128, 106033}, // __builtin_ia32_dbpsadbw128
-      {Intrinsic::x86_avx512_dbpsadbw_256, 106060}, // __builtin_ia32_dbpsadbw256
-      {Intrinsic::x86_avx512_dbpsadbw_512, 106087}, // __builtin_ia32_dbpsadbw512
-      {Intrinsic::x86_directstore32, 119019}, // __builtin_ia32_directstore_u32
-      {Intrinsic::x86_directstore64, 119050}, // __builtin_ia32_directstore_u64
-      {Intrinsic::x86_avx512_div_pd_512, 106114}, // __builtin_ia32_divpd512
-      {Intrinsic::x86_avx512_div_ps_512, 106138}, // __builtin_ia32_divps512
-      {Intrinsic::x86_avx512_mask_div_sd_round, 108121}, // __builtin_ia32_divsd_round_mask
-      {Intrinsic::x86_avx512_mask_div_ss_round, 108153}, // __builtin_ia32_divss_round_mask
-      {Intrinsic::x86_avx512bf16_dpbf16ps_128, 118631}, // __builtin_ia32_dpbf16ps_128
-      {Intrinsic::x86_avx512bf16_dpbf16ps_256, 118659}, // __builtin_ia32_dpbf16ps_256
-      {Intrinsic::x86_avx512bf16_dpbf16ps_512, 118687}, // __builtin_ia32_dpbf16ps_512
-      {Intrinsic::x86_sse41_dppd, 124295}, // __builtin_ia32_dppd
-      {Intrinsic::x86_sse41_dpps, 124315}, // __builtin_ia32_dpps
-      {Intrinsic::x86_avx_dp_ps_256, 102063}, // __builtin_ia32_dpps256
-      {Intrinsic::x86_mmx_emms, 119529}, // __builtin_ia32_emms
-      {Intrinsic::x86_enqcmd, 119081}, // __builtin_ia32_enqcmd
-      {Intrinsic::x86_enqcmds, 119103}, // __builtin_ia32_enqcmds
-      {Intrinsic::x86_avx512_exp2_pd, 106162}, // __builtin_ia32_exp2pd_mask
-      {Intrinsic::x86_avx512_exp2_ps, 106189}, // __builtin_ia32_exp2ps_mask
-      {Intrinsic::x86_sse4a_extrq, 125134}, // __builtin_ia32_extrq
-      {Intrinsic::x86_sse4a_extrqi, 125155}, // __builtin_ia32_extrqi
-      {Intrinsic::x86_mmx_femms, 119549}, // __builtin_ia32_femms
-      {Intrinsic::x86_avx512_mask_fixupimm_pd_128, 108185}, // __builtin_ia32_fixupimmpd128_mask
-      {Intrinsic::x86_avx512_maskz_fixupimm_pd_128, 113845}, // __builtin_ia32_fixupimmpd128_maskz
-      {Intrinsic::x86_avx512_mask_fixupimm_pd_256, 108219}, // __builtin_ia32_fixupimmpd256_mask
-      {Intrinsic::x86_avx512_maskz_fixupimm_pd_256, 113880}, // __builtin_ia32_fixupimmpd256_maskz
-      {Intrinsic::x86_avx512_mask_fixupimm_pd_512, 108253}, // __builtin_ia32_fixupimmpd512_mask
-      {Intrinsic::x86_avx512_maskz_fixupimm_pd_512, 113915}, // __builtin_ia32_fixupimmpd512_maskz
-      {Intrinsic::x86_avx512_mask_fixupimm_ps_128, 108287}, // __builtin_ia32_fixupimmps128_mask
-      {Intrinsic::x86_avx512_maskz_fixupimm_ps_128, 113950}, // __builtin_ia32_fixupimmps128_maskz
-      {Intrinsic::x86_avx512_mask_fixupimm_ps_256, 108321}, // __builtin_ia32_fixupimmps256_mask
-      {Intrinsic::x86_avx512_maskz_fixupimm_ps_256, 113985}, // __builtin_ia32_fixupimmps256_maskz
-      {Intrinsic::x86_avx512_mask_fixupimm_ps_512, 108355}, // __builtin_ia32_fixupimmps512_mask
-      {Intrinsic::x86_avx512_maskz_fixupimm_ps_512, 114020}, // __builtin_ia32_fixupimmps512_maskz
-      {Intrinsic::x86_avx512_mask_fixupimm_sd, 108389}, // __builtin_ia32_fixupimmsd_mask
-      {Intrinsic::x86_avx512_maskz_fixupimm_sd, 114055}, // __builtin_ia32_fixupimmsd_maskz
-      {Intrinsic::x86_avx512_mask_fixupimm_ss, 108420}, // __builtin_ia32_fixupimmss_mask
-      {Intrinsic::x86_avx512_maskz_fixupimm_ss, 114087}, // __builtin_ia32_fixupimmss_maskz
-      {Intrinsic::x86_avx512_mask_fpclass_sd, 108451}, // __builtin_ia32_fpclasssd_mask
-      {Intrinsic::x86_avx512_mask_fpclass_ss, 108481}, // __builtin_ia32_fpclassss_mask
-      {Intrinsic::x86_fxrstor, 119248}, // __builtin_ia32_fxrstor
-      {Intrinsic::x86_fxrstor64, 119271}, // __builtin_ia32_fxrstor64
-      {Intrinsic::x86_fxsave, 119296}, // __builtin_ia32_fxsave
-      {Intrinsic::x86_fxsave64, 119318}, // __builtin_ia32_fxsave64
-      {Intrinsic::x86_avx2_gather_d_d, 103245}, // __builtin_ia32_gatherd_d
-      {Intrinsic::x86_avx2_gather_d_d_256, 103270}, // __builtin_ia32_gatherd_d256
-      {Intrinsic::x86_avx2_gather_d_pd, 103298}, // __builtin_ia32_gatherd_pd
-      {Intrinsic::x86_avx2_gather_d_pd_256, 103324}, // __builtin_ia32_gatherd_pd256
-      {Intrinsic::x86_avx2_gather_d_ps, 103353}, // __builtin_ia32_gatherd_ps
-      {Intrinsic::x86_avx2_gather_d_ps_256, 103379}, // __builtin_ia32_gatherd_ps256
-      {Intrinsic::x86_avx2_gather_d_q, 103408}, // __builtin_ia32_gatherd_q
-      {Intrinsic::x86_avx2_gather_d_q_256, 103433}, // __builtin_ia32_gatherd_q256
-      {Intrinsic::x86_avx512_gatherpf_dpd_512, 106216}, // __builtin_ia32_gatherpfdpd
-      {Intrinsic::x86_avx512_gatherpf_dps_512, 106243}, // __builtin_ia32_gatherpfdps
-      {Intrinsic::x86_avx512_gatherpf_qpd_512, 106270}, // __builtin_ia32_gatherpfqpd
-      {Intrinsic::x86_avx512_gatherpf_qps_512, 106297}, // __builtin_ia32_gatherpfqps
-      {Intrinsic::x86_avx2_gather_q_d, 103461}, // __builtin_ia32_gatherq_d
-      {Intrinsic::x86_avx2_gather_q_d_256, 103486}, // __builtin_ia32_gatherq_d256
-      {Intrinsic::x86_avx2_gather_q_pd, 103514}, // __builtin_ia32_gatherq_pd
-      {Intrinsic::x86_avx2_gather_q_pd_256, 103540}, // __builtin_ia32_gatherq_pd256
-      {Intrinsic::x86_avx2_gather_q_ps, 103569}, // __builtin_ia32_gatherq_ps
-      {Intrinsic::x86_avx2_gather_q_ps_256, 103595}, // __builtin_ia32_gatherq_ps256
-      {Intrinsic::x86_avx2_gather_q_q, 103624}, // __builtin_ia32_gatherq_q
-      {Intrinsic::x86_avx2_gather_q_q_256, 103649}, // __builtin_ia32_gatherq_q256
-      {Intrinsic::x86_avx512_mask_getexp_pd_128, 108511}, // __builtin_ia32_getexppd128_mask
-      {Intrinsic::x86_avx512_mask_getexp_pd_256, 108543}, // __builtin_ia32_getexppd256_mask
-      {Intrinsic::x86_avx512_mask_getexp_pd_512, 108575}, // __builtin_ia32_getexppd512_mask
-      {Intrinsic::x86_avx512_mask_getexp_ps_128, 108607}, // __builtin_ia32_getexpps128_mask
-      {Intrinsic::x86_avx512_mask_getexp_ps_256, 108639}, // __builtin_ia32_getexpps256_mask
-      {Intrinsic::x86_avx512_mask_getexp_ps_512, 108671}, // __builtin_ia32_getexpps512_mask
-      {Intrinsic::x86_avx512_mask_getexp_sd, 108703}, // __builtin_ia32_getexpsd128_round_mask
-      {Intrinsic::x86_avx512_mask_getexp_ss, 108741}, // __builtin_ia32_getexpss128_round_mask
-      {Intrinsic::x86_avx512_mask_getmant_pd_128, 108779}, // __builtin_ia32_getmantpd128_mask
-      {Intrinsic::x86_avx512_mask_getmant_pd_256, 108812}, // __builtin_ia32_getmantpd256_mask
-      {Intrinsic::x86_avx512_mask_getmant_pd_512, 108845}, // __builtin_ia32_getmantpd512_mask
-      {Intrinsic::x86_avx512_mask_getmant_ps_128, 108878}, // __builtin_ia32_getmantps128_mask
-      {Intrinsic::x86_avx512_mask_getmant_ps_256, 108911}, // __builtin_ia32_getmantps256_mask
-      {Intrinsic::x86_avx512_mask_getmant_ps_512, 108944}, // __builtin_ia32_getmantps512_mask
-      {Intrinsic::x86_avx512_mask_getmant_sd, 108977}, // __builtin_ia32_getmantsd_round_mask
-      {Intrinsic::x86_avx512_mask_getmant_ss, 109013}, // __builtin_ia32_getmantss_round_mask
-      {Intrinsic::x86_sse3_hadd_pd, 124094}, // __builtin_ia32_haddpd
-      {Intrinsic::x86_avx_hadd_pd_256, 102086}, // __builtin_ia32_haddpd256
-      {Intrinsic::x86_sse3_hadd_ps, 124116}, // __builtin_ia32_haddps
-      {Intrinsic::x86_avx_hadd_ps_256, 102111}, // __builtin_ia32_haddps256
-      {Intrinsic::x86_sse3_hsub_pd, 124138}, // __builtin_ia32_hsubpd
-      {Intrinsic::x86_avx_hsub_pd_256, 102136}, // __builtin_ia32_hsubpd256
-      {Intrinsic::x86_sse3_hsub_ps, 124160}, // __builtin_ia32_hsubps
-      {Intrinsic::x86_avx_hsub_ps_256, 102161}, // __builtin_ia32_hsubps256
-      {Intrinsic::x86_incsspd, 119342}, // __builtin_ia32_incsspd
-      {Intrinsic::x86_incsspq, 119365}, // __builtin_ia32_incsspq
-      {Intrinsic::x86_sse41_insertps, 124335}, // __builtin_ia32_insertps128
-      {Intrinsic::x86_sse4a_insertq, 125177}, // __builtin_ia32_insertq
-      {Intrinsic::x86_sse4a_insertqi, 125200}, // __builtin_ia32_insertqi
-      {Intrinsic::x86_invpcid, 119388}, // __builtin_ia32_invpcid
-      {Intrinsic::x86_sse3_ldu_dq, 124182}, // __builtin_ia32_lddqu
-      {Intrinsic::x86_avx_ldu_dq_256, 102186}, // __builtin_ia32_lddqu256
-      {Intrinsic::x86_sse2_lfence, 123046}, // __builtin_ia32_lfence
-      {Intrinsic::x86_llwpcb, 119411}, // __builtin_ia32_llwpcb
-      {Intrinsic::x86_lwpins32, 119433}, // __builtin_ia32_lwpins32
-      {Intrinsic::x86_lwpins64, 119457}, // __builtin_ia32_lwpins64
-      {Intrinsic::x86_lwpval32, 119481}, // __builtin_ia32_lwpval32
-      {Intrinsic::x86_lwpval64, 119505}, // __builtin_ia32_lwpval64
-      {Intrinsic::x86_avx2_maskload_d, 103677}, // __builtin_ia32_maskloadd
-      {Intrinsic::x86_avx2_maskload_d_256, 103702}, // __builtin_ia32_maskloadd256
-      {Intrinsic::x86_avx_maskload_pd, 102210}, // __builtin_ia32_maskloadpd
-      {Intrinsic::x86_avx_maskload_pd_256, 102236}, // __builtin_ia32_maskloadpd256
-      {Intrinsic::x86_avx_maskload_ps, 102265}, // __builtin_ia32_maskloadps
-      {Intrinsic::x86_avx_maskload_ps_256, 102291}, // __builtin_ia32_maskloadps256
-      {Intrinsic::x86_avx2_maskload_q, 103730}, // __builtin_ia32_maskloadq
-      {Intrinsic::x86_avx2_maskload_q_256, 103755}, // __builtin_ia32_maskloadq256
-      {Intrinsic::x86_sse2_maskmov_dqu, 123068}, // __builtin_ia32_maskmovdqu
-      {Intrinsic::x86_mmx_maskmovq, 119570}, // __builtin_ia32_maskmovq
-      {Intrinsic::x86_avx2_maskstore_d, 103783}, // __builtin_ia32_maskstored
-      {Intrinsic::x86_avx2_maskstore_d_256, 103809}, // __builtin_ia32_maskstored256
-      {Intrinsic::x86_avx_maskstore_pd, 102320}, // __builtin_ia32_maskstorepd
-      {Intrinsic::x86_avx_maskstore_pd_256, 102347}, // __builtin_ia32_maskstorepd256
-      {Intrinsic::x86_avx_maskstore_ps, 102377}, // __builtin_ia32_maskstoreps
-      {Intrinsic::x86_avx_maskstore_ps_256, 102404}, // __builtin_ia32_maskstoreps256
-      {Intrinsic::x86_avx2_maskstore_q, 103838}, // __builtin_ia32_maskstoreq
-      {Intrinsic::x86_avx2_maskstore_q_256, 103864}, // __builtin_ia32_maskstoreq256
-      {Intrinsic::x86_sse2_max_pd, 123094}, // __builtin_ia32_maxpd
-      {Intrinsic::x86_avx_max_pd_256, 102434}, // __builtin_ia32_maxpd256
-      {Intrinsic::x86_avx512_max_pd_512, 114119}, // __builtin_ia32_maxpd512
-      {Intrinsic::x86_sse_max_ps, 122230}, // __builtin_ia32_maxps
-      {Intrinsic::x86_avx_max_ps_256, 102458}, // __builtin_ia32_maxps256
-      {Intrinsic::x86_avx512_max_ps_512, 114143}, // __builtin_ia32_maxps512
-      {Intrinsic::x86_sse2_max_sd, 123115}, // __builtin_ia32_maxsd
-      {Intrinsic::x86_avx512_mask_max_sd_round, 109049}, // __builtin_ia32_maxsd_round_mask
-      {Intrinsic::x86_sse_max_ss, 122251}, // __builtin_ia32_maxss
-      {Intrinsic::x86_avx512_mask_max_ss_round, 109081}, // __builtin_ia32_maxss_round_mask
-      {Intrinsic::x86_sse2_mfence, 123136}, // __builtin_ia32_mfence
-      {Intrinsic::x86_sse2_min_pd, 123158}, // __builtin_ia32_minpd
-      {Intrinsic::x86_avx_min_pd_256, 102482}, // __builtin_ia32_minpd256
-      {Intrinsic::x86_avx512_min_pd_512, 114167}, // __builtin_ia32_minpd512
-      {Intrinsic::x86_sse_min_ps, 122272}, // __builtin_ia32_minps
-      {Intrinsic::x86_avx_min_ps_256, 102506}, // __builtin_ia32_minps256
-      {Intrinsic::x86_avx512_min_ps_512, 114191}, // __builtin_ia32_minps512
-      {Intrinsic::x86_sse2_min_sd, 123179}, // __builtin_ia32_minsd
-      {Intrinsic::x86_avx512_mask_min_sd_round, 109113}, // __builtin_ia32_minsd_round_mask
-      {Intrinsic::x86_sse_min_ss, 122293}, // __builtin_ia32_minss
-      {Intrinsic::x86_avx512_mask_min_ss_round, 109145}, // __builtin_ia32_minss_round_mask
-      {Intrinsic::x86_sse3_monitor, 124203}, // __builtin_ia32_monitor
-      {Intrinsic::x86_monitorx, 121116}, // __builtin_ia32_monitorx
-      {Intrinsic::x86_movdir64b, 121140}, // __builtin_ia32_movdir64b
-      {Intrinsic::x86_sse2_movmsk_pd, 123200}, // __builtin_ia32_movmskpd
-      {Intrinsic::x86_avx_movmsk_pd_256, 102530}, // __builtin_ia32_movmskpd256
-      {Intrinsic::x86_sse_movmsk_ps, 122314}, // __builtin_ia32_movmskps
-      {Intrinsic::x86_avx_movmsk_ps_256, 102557}, // __builtin_ia32_movmskps256
-      {Intrinsic::x86_mmx_movnt_dq, 119594}, // __builtin_ia32_movntq
-      {Intrinsic::x86_sse41_mpsadbw, 124362}, // __builtin_ia32_mpsadbw128
-      {Intrinsic::x86_avx2_mpsadbw, 103893}, // __builtin_ia32_mpsadbw256
-      {Intrinsic::x86_avx512_mul_pd_512, 114215}, // __builtin_ia32_mulpd512
-      {Intrinsic::x86_avx512_mul_ps_512, 114239}, // __builtin_ia32_mulps512
-      {Intrinsic::x86_avx512_mask_mul_sd_round, 109177}, // __builtin_ia32_mulsd_round_mask
-      {Intrinsic::x86_avx512_mask_mul_ss_round, 109209}, // __builtin_ia32_mulss_round_mask
-      {Intrinsic::x86_sse3_mwait, 124226}, // __builtin_ia32_mwait
-      {Intrinsic::x86_mwaitx, 121165}, // __builtin_ia32_mwaitx
-      {Intrinsic::x86_ssse3_pabs_b, 125224}, // __builtin_ia32_pabsb
-      {Intrinsic::x86_ssse3_pabs_d, 125245}, // __builtin_ia32_pabsd
-      {Intrinsic::x86_ssse3_pabs_w, 125266}, // __builtin_ia32_pabsw
-      {Intrinsic::x86_mmx_packssdw, 119616}, // __builtin_ia32_packssdw
-      {Intrinsic::x86_sse2_packssdw_128, 123224}, // __builtin_ia32_packssdw128
-      {Intrinsic::x86_avx2_packssdw, 103919}, // __builtin_ia32_packssdw256
-      {Intrinsic::x86_avx512_packssdw_512, 114263}, // __builtin_ia32_packssdw512
-      {Intrinsic::x86_mmx_packsswb, 119640}, // __builtin_ia32_packsswb
-      {Intrinsic::x86_sse2_packsswb_128, 123251}, // __builtin_ia32_packsswb128
-      {Intrinsic::x86_avx2_packsswb, 103946}, // __builtin_ia32_packsswb256
-      {Intrinsic::x86_avx512_packsswb_512, 114290}, // __builtin_ia32_packsswb512
-      {Intrinsic::x86_sse41_packusdw, 124388}, // __builtin_ia32_packusdw128
-      {Intrinsic::x86_avx2_packusdw, 103973}, // __builtin_ia32_packusdw256
-      {Intrinsic::x86_avx512_packusdw_512, 114317}, // __builtin_ia32_packusdw512
-      {Intrinsic::x86_mmx_packuswb, 119664}, // __builtin_ia32_packuswb
-      {Intrinsic::x86_sse2_packuswb_128, 123278}, // __builtin_ia32_packuswb128
-      {Intrinsic::x86_avx2_packuswb, 104000}, // __builtin_ia32_packuswb256
-      {Intrinsic::x86_avx512_packuswb_512, 114344}, // __builtin_ia32_packuswb512
-      {Intrinsic::x86_mmx_padd_b, 119688}, // __builtin_ia32_paddb
-      {Intrinsic::x86_mmx_padd_d, 119709}, // __builtin_ia32_paddd
-      {Intrinsic::x86_mmx_padd_q, 119730}, // __builtin_ia32_paddq
-      {Intrinsic::x86_mmx_padds_b, 119772}, // __builtin_ia32_paddsb
-      {Intrinsic::x86_mmx_padds_w, 119794}, // __builtin_ia32_paddsw
-      {Intrinsic::x86_mmx_paddus_b, 119816}, // __builtin_ia32_paddusb
-      {Intrinsic::x86_mmx_paddus_w, 119839}, // __builtin_ia32_paddusw
-      {Intrinsic::x86_mmx_padd_w, 119751}, // __builtin_ia32_paddw
-      {Intrinsic::x86_mmx_palignr_b, 119862}, // __builtin_ia32_palignr
-      {Intrinsic::x86_mmx_pand, 119885}, // __builtin_ia32_pand
-      {Intrinsic::x86_mmx_pandn, 119905}, // __builtin_ia32_pandn
-      {Intrinsic::x86_sse2_pause, 123305}, // __builtin_ia32_pause
-      {Intrinsic::x86_mmx_pavg_b, 119926}, // __builtin_ia32_pavgb
-      {Intrinsic::x86_sse2_pavg_b, 123326}, // __builtin_ia32_pavgb128
-      {Intrinsic::x86_avx2_pavg_b, 104027}, // __builtin_ia32_pavgb256
-      {Intrinsic::x86_avx512_pavg_b_512, 114371}, // __builtin_ia32_pavgb512
-      {Intrinsic::x86_3dnow_pavgusb, 100927}, // __builtin_ia32_pavgusb
-      {Intrinsic::x86_mmx_pavg_w, 119947}, // __builtin_ia32_pavgw
-      {Intrinsic::x86_sse2_pavg_w, 123350}, // __builtin_ia32_pavgw128
-      {Intrinsic::x86_avx2_pavg_w, 104051}, // __builtin_ia32_pavgw256
-      {Intrinsic::x86_avx512_pavg_w_512, 114395}, // __builtin_ia32_pavgw512
-      {Intrinsic::x86_sse41_pblendvb, 124415}, // __builtin_ia32_pblendvb128
-      {Intrinsic::x86_avx2_pblendvb, 104075}, // __builtin_ia32_pblendvb256
-      {Intrinsic::x86_pclmulqdq, 121187}, // __builtin_ia32_pclmulqdq128
-      {Intrinsic::x86_pclmulqdq_256, 121215}, // __builtin_ia32_pclmulqdq256
-      {Intrinsic::x86_pclmulqdq_512, 121243}, // __builtin_ia32_pclmulqdq512
-      {Intrinsic::x86_mmx_pcmpeq_b, 119968}, // __builtin_ia32_pcmpeqb
-      {Intrinsic::x86_mmx_pcmpeq_d, 119991}, // __builtin_ia32_pcmpeqd
-      {Intrinsic::x86_mmx_pcmpeq_w, 120014}, // __builtin_ia32_pcmpeqw
-      {Intrinsic::x86_sse42_pcmpestri128, 124732}, // __builtin_ia32_pcmpestri128
-      {Intrinsic::x86_sse42_pcmpestria128, 124760}, // __builtin_ia32_pcmpestria128
-      {Intrinsic::x86_sse42_pcmpestric128, 124789}, // __builtin_ia32_pcmpestric128
-      {Intrinsic::x86_sse42_pcmpestrio128, 124818}, // __builtin_ia32_pcmpestrio128
-      {Intrinsic::x86_sse42_pcmpestris128, 124847}, // __builtin_ia32_pcmpestris128
-      {Intrinsic::x86_sse42_pcmpestriz128, 124876}, // __builtin_ia32_pcmpestriz128
-      {Intrinsic::x86_sse42_pcmpestrm128, 124905}, // __builtin_ia32_pcmpestrm128
-      {Intrinsic::x86_mmx_pcmpgt_b, 120037}, // __builtin_ia32_pcmpgtb
-      {Intrinsic::x86_mmx_pcmpgt_d, 120060}, // __builtin_ia32_pcmpgtd
-      {Intrinsic::x86_mmx_pcmpgt_w, 120083}, // __builtin_ia32_pcmpgtw
-      {Intrinsic::x86_sse42_pcmpistri128, 124933}, // __builtin_ia32_pcmpistri128
-      {Intrinsic::x86_sse42_pcmpistria128, 124961}, // __builtin_ia32_pcmpistria128
-      {Intrinsic::x86_sse42_pcmpistric128, 124990}, // __builtin_ia32_pcmpistric128
-      {Intrinsic::x86_sse42_pcmpistrio128, 125019}, // __builtin_ia32_pcmpistrio128
-      {Intrinsic::x86_sse42_pcmpistris128, 125048}, // __builtin_ia32_pcmpistris128
-      {Intrinsic::x86_sse42_pcmpistriz128, 125077}, // __builtin_ia32_pcmpistriz128
-      {Intrinsic::x86_sse42_pcmpistrm128, 125106}, // __builtin_ia32_pcmpistrm128
-      {Intrinsic::x86_bmi_pdep_64, 118834}, // __builtin_ia32_pdep_di
-      {Intrinsic::x86_bmi_pdep_32, 118811}, // __builtin_ia32_pdep_si
-      {Intrinsic::x86_avx512_permvar_df_256, 114419}, // __builtin_ia32_permvardf256
-      {Intrinsic::x86_avx512_permvar_df_512, 114447}, // __builtin_ia32_permvardf512
-      {Intrinsic::x86_avx512_permvar_di_256, 114475}, // __builtin_ia32_permvardi256
-      {Intrinsic::x86_avx512_permvar_di_512, 114503}, // __builtin_ia32_permvardi512
-      {Intrinsic::x86_avx512_permvar_hi_128, 114531}, // __builtin_ia32_permvarhi128
-      {Intrinsic::x86_avx512_permvar_hi_256, 114559}, // __builtin_ia32_permvarhi256
-      {Intrinsic::x86_avx512_permvar_hi_512, 114587}, // __builtin_ia32_permvarhi512
-      {Intrinsic::x86_avx512_permvar_qi_128, 114615}, // __builtin_ia32_permvarqi128
-      {Intrinsic::x86_avx512_permvar_qi_256, 114643}, // __builtin_ia32_permvarqi256
-      {Intrinsic::x86_avx512_permvar_qi_512, 114671}, // __builtin_ia32_permvarqi512
-      {Intrinsic::x86_avx2_permps, 104130}, // __builtin_ia32_permvarsf256
-      {Intrinsic::x86_avx512_permvar_sf_512, 114699}, // __builtin_ia32_permvarsf512
-      {Intrinsic::x86_avx2_permd, 104102}, // __builtin_ia32_permvarsi256
-      {Intrinsic::x86_avx512_permvar_si_512, 114727}, // __builtin_ia32_permvarsi512
-      {Intrinsic::x86_bmi_pext_64, 118880}, // __builtin_ia32_pext_di
-      {Intrinsic::x86_bmi_pext_32, 118857}, // __builtin_ia32_pext_si
-      {Intrinsic::x86_3dnow_pf2id, 100950}, // __builtin_ia32_pf2id
-      {Intrinsic::x86_3dnowa_pf2iw, 101348}, // __builtin_ia32_pf2iw
-      {Intrinsic::x86_3dnow_pfacc, 100971}, // __builtin_ia32_pfacc
-      {Intrinsic::x86_3dnow_pfadd, 100992}, // __builtin_ia32_pfadd
-      {Intrinsic::x86_3dnow_pfcmpeq, 101013}, // __builtin_ia32_pfcmpeq
-      {Intrinsic::x86_3dnow_pfcmpge, 101036}, // __builtin_ia32_pfcmpge
-      {Intrinsic::x86_3dnow_pfcmpgt, 101059}, // __builtin_ia32_pfcmpgt
-      {Intrinsic::x86_3dnow_pfmax, 101082}, // __builtin_ia32_pfmax
-      {Intrinsic::x86_3dnow_pfmin, 101103}, // __builtin_ia32_pfmin
-      {Intrinsic::x86_3dnow_pfmul, 101124}, // __builtin_ia32_pfmul
-      {Intrinsic::x86_3dnowa_pfnacc, 101369}, // __builtin_ia32_pfnacc
-      {Intrinsic::x86_3dnowa_pfpnacc, 101391}, // __builtin_ia32_pfpnacc
-      {Intrinsic::x86_3dnow_pfrcp, 101145}, // __builtin_ia32_pfrcp
-      {Intrinsic::x86_3dnow_pfrcpit1, 101166}, // __builtin_ia32_pfrcpit1
-      {Intrinsic::x86_3dnow_pfrcpit2, 101190}, // __builtin_ia32_pfrcpit2
-      {Intrinsic::x86_3dnow_pfrsqit1, 101214}, // __builtin_ia32_pfrsqit1
-      {Intrinsic::x86_3dnow_pfrsqrt, 101238}, // __builtin_ia32_pfrsqrt
-      {Intrinsic::x86_3dnow_pfsub, 101261}, // __builtin_ia32_pfsub
-      {Intrinsic::x86_3dnow_pfsubr, 101282}, // __builtin_ia32_pfsubr
-      {Intrinsic::x86_ssse3_phadd_d, 125287}, // __builtin_ia32_phaddd
-      {Intrinsic::x86_ssse3_phadd_d_128, 125309}, // __builtin_ia32_phaddd128
-      {Intrinsic::x86_avx2_phadd_d, 104158}, // __builtin_ia32_phaddd256
-      {Intrinsic::x86_ssse3_phadd_sw, 125334}, // __builtin_ia32_phaddsw
-      {Intrinsic::x86_ssse3_phadd_sw_128, 125357}, // __builtin_ia32_phaddsw128
-      {Intrinsic::x86_avx2_phadd_sw, 104183}, // __builtin_ia32_phaddsw256
-      {Intrinsic::x86_ssse3_phadd_w, 125383}, // __builtin_ia32_phaddw
-      {Intrinsic::x86_ssse3_phadd_w_128, 125405}, // __builtin_ia32_phaddw128
-      {Intrinsic::x86_avx2_phadd_w, 104209}, // __builtin_ia32_phaddw256
-      {Intrinsic::x86_sse41_phminposuw, 124442}, // __builtin_ia32_phminposuw128
-      {Intrinsic::x86_ssse3_phsub_d, 125430}, // __builtin_ia32_phsubd
-      {Intrinsic::x86_ssse3_phsub_d_128, 125452}, // __builtin_ia32_phsubd128
-      {Intrinsic::x86_avx2_phsub_d, 104234}, // __builtin_ia32_phsubd256
-      {Intrinsic::x86_ssse3_phsub_sw, 125477}, // __builtin_ia32_phsubsw
-      {Intrinsic::x86_ssse3_phsub_sw_128, 125500}, // __builtin_ia32_phsubsw128
-      {Intrinsic::x86_avx2_phsub_sw, 104259}, // __builtin_ia32_phsubsw256
-      {Intrinsic::x86_ssse3_phsub_w, 125526}, // __builtin_ia32_phsubw
-      {Intrinsic::x86_ssse3_phsub_w_128, 125548}, // __builtin_ia32_phsubw128
-      {Intrinsic::x86_avx2_phsub_w, 104285}, // __builtin_ia32_phsubw256
-      {Intrinsic::x86_3dnow_pi2fd, 101304}, // __builtin_ia32_pi2fd
-      {Intrinsic::x86_3dnowa_pi2fw, 101414}, // __builtin_ia32_pi2fw
-      {Intrinsic::x86_ssse3_pmadd_ub_sw, 125573}, // __builtin_ia32_pmaddubsw
-      {Intrinsic::x86_ssse3_pmadd_ub_sw_128, 125598}, // __builtin_ia32_pmaddubsw128
-      {Intrinsic::x86_avx2_pmadd_ub_sw, 104310}, // __builtin_ia32_pmaddubsw256
-      {Intrinsic::x86_avx512_pmaddubs_w_512, 114755}, // __builtin_ia32_pmaddubsw512
-      {Intrinsic::x86_mmx_pmadd_wd, 120162}, // __builtin_ia32_pmaddwd
-      {Intrinsic::x86_sse2_pmadd_wd, 123374}, // __builtin_ia32_pmaddwd128
-      {Intrinsic::x86_avx2_pmadd_wd, 104338}, // __builtin_ia32_pmaddwd256
-      {Intrinsic::x86_avx512_pmaddw_d_512, 114783}, // __builtin_ia32_pmaddwd512
-      {Intrinsic::x86_mmx_pmaxs_w, 120185}, // __builtin_ia32_pmaxsw
-      {Intrinsic::x86_mmx_pmaxu_b, 120207}, // __builtin_ia32_pmaxub
-      {Intrinsic::x86_mmx_pmins_w, 120229}, // __builtin_ia32_pminsw
-      {Intrinsic::x86_mmx_pminu_b, 120251}, // __builtin_ia32_pminub
-      {Intrinsic::x86_avx512_mask_pmov_db_128, 109241}, // __builtin_ia32_pmovdb128_mask
-      {Intrinsic::x86_avx512_mask_pmov_db_mem_128, 109301}, // __builtin_ia32_pmovdb128mem_mask
-      {Intrinsic::x86_avx512_mask_pmov_db_256, 109271}, // __builtin_ia32_pmovdb256_mask
-      {Intrinsic::x86_avx512_mask_pmov_db_mem_256, 109334}, // __builtin_ia32_pmovdb256mem_mask
-      {Intrinsic::x86_avx512_mask_pmov_db_mem_512, 109367}, // __builtin_ia32_pmovdb512mem_mask
-      {Intrinsic::x86_avx512_mask_pmov_dw_128, 109400}, // __builtin_ia32_pmovdw128_mask
-      {Intrinsic::x86_avx512_mask_pmov_dw_mem_128, 109460}, // __builtin_ia32_pmovdw128mem_mask
-      {Intrinsic::x86_avx512_mask_pmov_dw_256, 109430}, // __builtin_ia32_pmovdw256_mask
-      {Intrinsic::x86_avx512_mask_pmov_dw_mem_256, 109493}, // __builtin_ia32_pmovdw256mem_mask
-      {Intrinsic::x86_avx512_mask_pmov_dw_mem_512, 109526}, // __builtin_ia32_pmovdw512mem_mask
-      {Intrinsic::x86_mmx_pmovmskb, 120273}, // __builtin_ia32_pmovmskb
-      {Intrinsic::x86_sse2_pmovmskb_128, 123400}, // __builtin_ia32_pmovmskb128
-      {Intrinsic::x86_avx2_pmovmskb, 104364}, // __builtin_ia32_pmovmskb256
-      {Intrinsic::x86_avx512_mask_pmov_qb_128, 109559}, // __builtin_ia32_pmovqb128_mask
-      {Intrinsic::x86_avx512_mask_pmov_qb_mem_128, 109649}, // __builtin_ia32_pmovqb128mem_mask
-      {Intrinsic::x86_avx512_mask_pmov_qb_256, 109589}, // __builtin_ia32_pmovqb256_mask
-      {Intrinsic::x86_avx512_mask_pmov_qb_mem_256, 109682}, // __builtin_ia32_pmovqb256mem_mask
-      {Intrinsic::x86_avx512_mask_pmov_qb_512, 109619}, // __builtin_ia32_pmovqb512_mask
-      {Intrinsic::x86_avx512_mask_pmov_qb_mem_512, 109715}, // __builtin_ia32_pmovqb512mem_mask
-      {Intrinsic::x86_avx512_mask_pmov_qd_128, 109748}, // __builtin_ia32_pmovqd128_mask
-      {Intrinsic::x86_avx512_mask_pmov_qd_mem_128, 109778}, // __builtin_ia32_pmovqd128mem_mask
-      {Intrinsic::x86_avx512_mask_pmov_qd_mem_256, 109811}, // __builtin_ia32_pmovqd256mem_mask
-      {Intrinsic::x86_avx512_mask_pmov_qd_mem_512, 109844}, // __builtin_ia32_pmovqd512mem_mask
-      {Intrinsic::x86_avx512_mask_pmov_qw_128, 109877}, // __builtin_ia32_pmovqw128_mask
-      {Intrinsic::x86_avx512_mask_pmov_qw_mem_128, 109937}, // __builtin_ia32_pmovqw128mem_mask
-      {Intrinsic::x86_avx512_mask_pmov_qw_256, 109907}, // __builtin_ia32_pmovqw256_mask
-      {Intrinsic::x86_avx512_mask_pmov_qw_mem_256, 109970}, // __builtin_ia32_pmovqw256mem_mask
-      {Intrinsic::x86_avx512_mask_pmov_qw_mem_512, 110003}, // __builtin_ia32_pmovqw512mem_mask
-      {Intrinsic::x86_avx512_mask_pmovs_db_128, 110165}, // __builtin_ia32_pmovsdb128_mask
-      {Intrinsic::x86_avx512_mask_pmovs_db_mem_128, 110258}, // __builtin_ia32_pmovsdb128mem_mask
-      {Intrinsic::x86_avx512_mask_pmovs_db_256, 110196}, // __builtin_ia32_pmovsdb256_mask
-      {Intrinsic::x86_avx512_mask_pmovs_db_mem_256, 110292}, // __builtin_ia32_pmovsdb256mem_mask
-      {Intrinsic::x86_avx512_mask_pmovs_db_512, 110227}, // __builtin_ia32_pmovsdb512_mask
-      {Intrinsic::x86_avx512_mask_pmovs_db_mem_512, 110326}, // __builtin_ia32_pmovsdb512mem_mask
-      {Intrinsic::x86_avx512_mask_pmovs_dw_128, 110360}, // __builtin_ia32_pmovsdw128_mask
-      {Intrinsic::x86_avx512_mask_pmovs_dw_mem_128, 110453}, // __builtin_ia32_pmovsdw128mem_mask
-      {Intrinsic::x86_avx512_mask_pmovs_dw_256, 110391}, // __builtin_ia32_pmovsdw256_mask
-      {Intrinsic::x86_avx512_mask_pmovs_dw_mem_256, 110487}, // __builtin_ia32_pmovsdw256mem_mask
-      {Intrinsic::x86_avx512_mask_pmovs_dw_512, 110422}, // __builtin_ia32_pmovsdw512_mask
-      {Intrinsic::x86_avx512_mask_pmovs_dw_mem_512, 110521}, // __builtin_ia32_pmovsdw512mem_mask
-      {Intrinsic::x86_avx512_mask_pmovs_qb_128, 110555}, // __builtin_ia32_pmovsqb128_mask
-      {Intrinsic::x86_avx512_mask_pmovs_qb_mem_128, 110648}, // __builtin_ia32_pmovsqb128mem_mask
-      {Intrinsic::x86_avx512_mask_pmovs_qb_256, 110586}, // __builtin_ia32_pmovsqb256_mask
-      {Intrinsic::x86_avx512_mask_pmovs_qb_mem_256, 110682}, // __builtin_ia32_pmovsqb256mem_mask
-      {Intrinsic::x86_avx512_mask_pmovs_qb_512, 110617}, // __builtin_ia32_pmovsqb512_mask
-      {Intrinsic::x86_avx512_mask_pmovs_qb_mem_512, 110716}, // __builtin_ia32_pmovsqb512mem_mask
-      {Intrinsic::x86_avx512_mask_pmovs_qd_128, 110750}, // __builtin_ia32_pmovsqd128_mask
-      {Intrinsic::x86_avx512_mask_pmovs_qd_mem_128, 110843}, // __builtin_ia32_pmovsqd128mem_mask
-      {Intrinsic::x86_avx512_mask_pmovs_qd_256, 110781}, // __builtin_ia32_pmovsqd256_mask
-      {Intrinsic::x86_avx512_mask_pmovs_qd_mem_256, 110877}, // __builtin_ia32_pmovsqd256mem_mask
-      {Intrinsic::x86_avx512_mask_pmovs_qd_512, 110812}, // __builtin_ia32_pmovsqd512_mask
-      {Intrinsic::x86_avx512_mask_pmovs_qd_mem_512, 110911}, // __builtin_ia32_pmovsqd512mem_mask
-      {Intrinsic::x86_avx512_mask_pmovs_qw_128, 110945}, // __builtin_ia32_pmovsqw128_mask
-      {Intrinsic::x86_avx512_mask_pmovs_qw_mem_128, 111038}, // __builtin_ia32_pmovsqw128mem_mask
-      {Intrinsic::x86_avx512_mask_pmovs_qw_256, 110976}, // __builtin_ia32_pmovsqw256_mask
-      {Intrinsic::x86_avx512_mask_pmovs_qw_mem_256, 111072}, // __builtin_ia32_pmovsqw256mem_mask
-      {Intrinsic::x86_avx512_mask_pmovs_qw_512, 111007}, // __builtin_ia32_pmovsqw512_mask
-      {Intrinsic::x86_avx512_mask_pmovs_qw_mem_512, 111106}, // __builtin_ia32_pmovsqw512mem_mask
-      {Intrinsic::x86_avx512_mask_pmovs_wb_128, 111140}, // __builtin_ia32_pmovswb128_mask
-      {Intrinsic::x86_avx512_mask_pmovs_wb_mem_128, 111233}, // __builtin_ia32_pmovswb128mem_mask
-      {Intrinsic::x86_avx512_mask_pmovs_wb_256, 111171}, // __builtin_ia32_pmovswb256_mask
-      {Intrinsic::x86_avx512_mask_pmovs_wb_mem_256, 111267}, // __builtin_ia32_pmovswb256mem_mask
-      {Intrinsic::x86_avx512_mask_pmovs_wb_512, 111202}, // __builtin_ia32_pmovswb512_mask
-      {Intrinsic::x86_avx512_mask_pmovs_wb_mem_512, 111301}, // __builtin_ia32_pmovswb512mem_mask
-      {Intrinsic::x86_avx512_mask_pmovus_db_128, 111335}, // __builtin_ia32_pmovusdb128_mask
-      {Intrinsic::x86_avx512_mask_pmovus_db_mem_128, 111431}, // __builtin_ia32_pmovusdb128mem_mask
-      {Intrinsic::x86_avx512_mask_pmovus_db_256, 111367}, // __builtin_ia32_pmovusdb256_mask
-      {Intrinsic::x86_avx512_mask_pmovus_db_mem_256, 111466}, // __builtin_ia32_pmovusdb256mem_mask
-      {Intrinsic::x86_avx512_mask_pmovus_db_512, 111399}, // __builtin_ia32_pmovusdb512_mask
-      {Intrinsic::x86_avx512_mask_pmovus_db_mem_512, 111501}, // __builtin_ia32_pmovusdb512mem_mask
-      {Intrinsic::x86_avx512_mask_pmovus_dw_128, 111536}, // __builtin_ia32_pmovusdw128_mask
-      {Intrinsic::x86_avx512_mask_pmovus_dw_mem_128, 111632}, // __builtin_ia32_pmovusdw128mem_mask
-      {Intrinsic::x86_avx512_mask_pmovus_dw_256, 111568}, // __builtin_ia32_pmovusdw256_mask
-      {Intrinsic::x86_avx512_mask_pmovus_dw_mem_256, 111667}, // __builtin_ia32_pmovusdw256mem_mask
-      {Intrinsic::x86_avx512_mask_pmovus_dw_512, 111600}, // __builtin_ia32_pmovusdw512_mask
-      {Intrinsic::x86_avx512_mask_pmovus_dw_mem_512, 111702}, // __builtin_ia32_pmovusdw512mem_mask
-      {Intrinsic::x86_avx512_mask_pmovus_qb_128, 111737}, // __builtin_ia32_pmovusqb128_mask
-      {Intrinsic::x86_avx512_mask_pmovus_qb_mem_128, 111833}, // __builtin_ia32_pmovusqb128mem_mask
-      {Intrinsic::x86_avx512_mask_pmovus_qb_256, 111769}, // __builtin_ia32_pmovusqb256_mask
-      {Intrinsic::x86_avx512_mask_pmovus_qb_mem_256, 111868}, // __builtin_ia32_pmovusqb256mem_mask
-      {Intrinsic::x86_avx512_mask_pmovus_qb_512, 111801}, // __builtin_ia32_pmovusqb512_mask
-      {Intrinsic::x86_avx512_mask_pmovus_qb_mem_512, 111903}, // __builtin_ia32_pmovusqb512mem_mask
-      {Intrinsic::x86_avx512_mask_pmovus_qd_128, 111938}, // __builtin_ia32_pmovusqd128_mask
-      {Intrinsic::x86_avx512_mask_pmovus_qd_mem_128, 112034}, // __builtin_ia32_pmovusqd128mem_mask
-      {Intrinsic::x86_avx512_mask_pmovus_qd_256, 111970}, // __builtin_ia32_pmovusqd256_mask
-      {Intrinsic::x86_avx512_mask_pmovus_qd_mem_256, 112069}, // __builtin_ia32_pmovusqd256mem_mask
-      {Intrinsic::x86_avx512_mask_pmovus_qd_512, 112002}, // __builtin_ia32_pmovusqd512_mask
-      {Intrinsic::x86_avx512_mask_pmovus_qd_mem_512, 112104}, // __builtin_ia32_pmovusqd512mem_mask
-      {Intrinsic::x86_avx512_mask_pmovus_qw_128, 112139}, // __builtin_ia32_pmovusqw128_mask
-      {Intrinsic::x86_avx512_mask_pmovus_qw_mem_128, 112235}, // __builtin_ia32_pmovusqw128mem_mask
-      {Intrinsic::x86_avx512_mask_pmovus_qw_256, 112171}, // __builtin_ia32_pmovusqw256_mask
-      {Intrinsic::x86_avx512_mask_pmovus_qw_mem_256, 112270}, // __builtin_ia32_pmovusqw256mem_mask
-      {Intrinsic::x86_avx512_mask_pmovus_qw_512, 112203}, // __builtin_ia32_pmovusqw512_mask
-      {Intrinsic::x86_avx512_mask_pmovus_qw_mem_512, 112305}, // __builtin_ia32_pmovusqw512mem_mask
-      {Intrinsic::x86_avx512_mask_pmovus_wb_128, 112340}, // __builtin_ia32_pmovuswb128_mask
-      {Intrinsic::x86_avx512_mask_pmovus_wb_mem_128, 112436}, // __builtin_ia32_pmovuswb128mem_mask
-      {Intrinsic::x86_avx512_mask_pmovus_wb_256, 112372}, // __builtin_ia32_pmovuswb256_mask
-      {Intrinsic::x86_avx512_mask_pmovus_wb_mem_256, 112471}, // __builtin_ia32_pmovuswb256mem_mask
-      {Intrinsic::x86_avx512_mask_pmovus_wb_512, 112404}, // __builtin_ia32_pmovuswb512_mask
-      {Intrinsic::x86_avx512_mask_pmovus_wb_mem_512, 112506}, // __builtin_ia32_pmovuswb512mem_mask
-      {Intrinsic::x86_avx512_mask_pmov_wb_128, 110036}, // __builtin_ia32_pmovwb128_mask
-      {Intrinsic::x86_avx512_mask_pmov_wb_mem_128, 110066}, // __builtin_ia32_pmovwb128mem_mask
-      {Intrinsic::x86_avx512_mask_pmov_wb_mem_256, 110099}, // __builtin_ia32_pmovwb256mem_mask
-      {Intrinsic::x86_avx512_mask_pmov_wb_mem_512, 110132}, // __builtin_ia32_pmovwb512mem_mask
-      {Intrinsic::x86_ssse3_pmul_hr_sw, 125626}, // __builtin_ia32_pmulhrsw
-      {Intrinsic::x86_ssse3_pmul_hr_sw_128, 125650}, // __builtin_ia32_pmulhrsw128
-      {Intrinsic::x86_avx2_pmul_hr_sw, 104391}, // __builtin_ia32_pmulhrsw256
-      {Intrinsic::x86_avx512_pmul_hr_sw_512, 114809}, // __builtin_ia32_pmulhrsw512
-      {Intrinsic::x86_3dnow_pmulhrw, 101325}, // __builtin_ia32_pmulhrw
-      {Intrinsic::x86_mmx_pmulhu_w, 120319}, // __builtin_ia32_pmulhuw
-      {Intrinsic::x86_sse2_pmulhu_w, 123452}, // __builtin_ia32_pmulhuw128
-      {Intrinsic::x86_avx2_pmulhu_w, 104443}, // __builtin_ia32_pmulhuw256
-      {Intrinsic::x86_avx512_pmulhu_w_512, 114861}, // __builtin_ia32_pmulhuw512
-      {Intrinsic::x86_mmx_pmulh_w, 120297}, // __builtin_ia32_pmulhw
-      {Intrinsic::x86_sse2_pmulh_w, 123427}, // __builtin_ia32_pmulhw128
-      {Intrinsic::x86_avx2_pmulh_w, 104418}, // __builtin_ia32_pmulhw256
-      {Intrinsic::x86_avx512_pmulh_w_512, 114836}, // __builtin_ia32_pmulhw512
-      {Intrinsic::x86_mmx_pmull_w, 120342}, // __builtin_ia32_pmullw
-      {Intrinsic::x86_mmx_pmulu_dq, 120364}, // __builtin_ia32_pmuludq
-      {Intrinsic::x86_mmx_por, 120387}, // __builtin_ia32_por
-      {Intrinsic::x86_mmx_psad_bw, 120406}, // __builtin_ia32_psadbw
-      {Intrinsic::x86_sse2_psad_bw, 123478}, // __builtin_ia32_psadbw128
-      {Intrinsic::x86_avx2_psad_bw, 104469}, // __builtin_ia32_psadbw256
-      {Intrinsic::x86_avx512_psad_bw_512, 114986}, // __builtin_ia32_psadbw512
-      {Intrinsic::x86_ssse3_pshuf_b, 125677}, // __builtin_ia32_pshufb
-      {Intrinsic::x86_ssse3_pshuf_b_128, 125699}, // __builtin_ia32_pshufb128
-      {Intrinsic::x86_avx2_pshuf_b, 104494}, // __builtin_ia32_pshufb256
-      {Intrinsic::x86_avx512_pshuf_b_512, 115011}, // __builtin_ia32_pshufb512
-      {Intrinsic::x86_sse_pshuf_w, 122338}, // __builtin_ia32_pshufw
-      {Intrinsic::x86_ssse3_psign_b, 125724}, // __builtin_ia32_psignb
-      {Intrinsic::x86_ssse3_psign_b_128, 125746}, // __builtin_ia32_psignb128
-      {Intrinsic::x86_avx2_psign_b, 104519}, // __builtin_ia32_psignb256
-      {Intrinsic::x86_ssse3_psign_d, 125771}, // __builtin_ia32_psignd
-      {Intrinsic::x86_ssse3_psign_d_128, 125793}, // __builtin_ia32_psignd128
-      {Intrinsic::x86_avx2_psign_d, 104544}, // __builtin_ia32_psignd256
-      {Intrinsic::x86_ssse3_psign_w, 125818}, // __builtin_ia32_psignw
-      {Intrinsic::x86_ssse3_psign_w_128, 125840}, // __builtin_ia32_psignw128
-      {Intrinsic::x86_avx2_psign_w, 104569}, // __builtin_ia32_psignw256
-      {Intrinsic::x86_mmx_psll_d, 120428}, // __builtin_ia32_pslld
-      {Intrinsic::x86_sse2_psll_d, 123503}, // __builtin_ia32_pslld128
-      {Intrinsic::x86_avx2_psll_d, 104594}, // __builtin_ia32_pslld256
-      {Intrinsic::x86_avx512_psll_d_512, 115036}, // __builtin_ia32_pslld512
-      {Intrinsic::x86_mmx_pslli_d, 120491}, // __builtin_ia32_pslldi
-      {Intrinsic::x86_sse2_pslli_d, 123575}, // __builtin_ia32_pslldi128
-      {Intrinsic::x86_avx2_pslli_d, 104666}, // __builtin_ia32_pslldi256
-      {Intrinsic::x86_avx512_pslli_d_512, 115108}, // __builtin_ia32_pslldi512
-      {Intrinsic::x86_mmx_psll_q, 120449}, // __builtin_ia32_psllq
-      {Intrinsic::x86_sse2_psll_q, 123527}, // __builtin_ia32_psllq128
-      {Intrinsic::x86_avx2_psll_q, 104618}, // __builtin_ia32_psllq256
-      {Intrinsic::x86_avx512_psll_q_512, 115060}, // __builtin_ia32_psllq512
-      {Intrinsic::x86_mmx_pslli_q, 120513}, // __builtin_ia32_psllqi
-      {Intrinsic::x86_sse2_pslli_q, 123600}, // __builtin_ia32_psllqi128
-      {Intrinsic::x86_avx2_pslli_q, 104691}, // __builtin_ia32_psllqi256
-      {Intrinsic::x86_avx512_pslli_q_512, 115133}, // __builtin_ia32_psllqi512
-      {Intrinsic::x86_avx512_psllv_w_256, 115256}, // __builtin_ia32_psllv16hi
-      {Intrinsic::x86_avx512_psllv_d_512, 115183}, // __builtin_ia32_psllv16si
-      {Intrinsic::x86_avx2_psllv_q, 104789}, // __builtin_ia32_psllv2di
-      {Intrinsic::x86_avx512_psllv_w_512, 115281}, // __builtin_ia32_psllv32hi
-      {Intrinsic::x86_avx2_psllv_q_256, 104813}, // __builtin_ia32_psllv4di
-      {Intrinsic::x86_avx2_psllv_d, 104741}, // __builtin_ia32_psllv4si
-      {Intrinsic::x86_avx512_psllv_q_512, 115208}, // __builtin_ia32_psllv8di
-      {Intrinsic::x86_avx512_psllv_w_128, 115232}, // __builtin_ia32_psllv8hi
-      {Intrinsic::x86_avx2_psllv_d_256, 104765}, // __builtin_ia32_psllv8si
-      {Intrinsic::x86_mmx_psll_w, 120470}, // __builtin_ia32_psllw
-      {Intrinsic::x86_sse2_psll_w, 123551}, // __builtin_ia32_psllw128
-      {Intrinsic::x86_avx2_psll_w, 104642}, // __builtin_ia32_psllw256
-      {Intrinsic::x86_avx512_psll_w_512, 115084}, // __builtin_ia32_psllw512
-      {Intrinsic::x86_mmx_pslli_w, 120535}, // __builtin_ia32_psllwi
-      {Intrinsic::x86_sse2_pslli_w, 123625}, // __builtin_ia32_psllwi128
-      {Intrinsic::x86_avx2_pslli_w, 104716}, // __builtin_ia32_psllwi256
-      {Intrinsic::x86_avx512_pslli_w_512, 115158}, // __builtin_ia32_psllwi512
-      {Intrinsic::x86_mmx_psra_d, 120557}, // __builtin_ia32_psrad
-      {Intrinsic::x86_sse2_psra_d, 123650}, // __builtin_ia32_psrad128
-      {Intrinsic::x86_avx2_psra_d, 104837}, // __builtin_ia32_psrad256
-      {Intrinsic::x86_avx512_psra_d_512, 115306}, // __builtin_ia32_psrad512
-      {Intrinsic::x86_mmx_psrai_d, 120599}, // __builtin_ia32_psradi
-      {Intrinsic::x86_sse2_psrai_d, 123698}, // __builtin_ia32_psradi128
-      {Intrinsic::x86_avx2_psrai_d, 104885}, // __builtin_ia32_psradi256
-      {Intrinsic::x86_avx512_psrai_d_512, 115426}, // __builtin_ia32_psradi512
-      {Intrinsic::x86_avx512_psra_q_128, 115330}, // __builtin_ia32_psraq128
-      {Intrinsic::x86_avx512_psra_q_256, 115354}, // __builtin_ia32_psraq256
-      {Intrinsic::x86_avx512_psra_q_512, 115378}, // __builtin_ia32_psraq512
-      {Intrinsic::x86_avx512_psrai_q_128, 115451}, // __builtin_ia32_psraqi128
-      {Intrinsic::x86_avx512_psrai_q_256, 115476}, // __builtin_ia32_psraqi256
-      {Intrinsic::x86_avx512_psrai_q_512, 115501}, // __builtin_ia32_psraqi512
-      {Intrinsic::x86_avx512_psrav_w_256, 115674}, // __builtin_ia32_psrav16hi
-      {Intrinsic::x86_avx512_psrav_d_512, 115551}, // __builtin_ia32_psrav16si
-      {Intrinsic::x86_avx512_psrav_w_512, 115699}, // __builtin_ia32_psrav32hi
-      {Intrinsic::x86_avx2_psrav_d, 104935}, // __builtin_ia32_psrav4si
-      {Intrinsic::x86_avx512_psrav_q_512, 115626}, // __builtin_ia32_psrav8di
-      {Intrinsic::x86_avx512_psrav_w_128, 115650}, // __builtin_ia32_psrav8hi
-      {Intrinsic::x86_avx2_psrav_d_256, 104959}, // __builtin_ia32_psrav8si
-      {Intrinsic::x86_avx512_psrav_q_128, 115576}, // __builtin_ia32_psravq128
-      {Intrinsic::x86_avx512_psrav_q_256, 115601}, // __builtin_ia32_psravq256
-      {Intrinsic::x86_mmx_psra_w, 120578}, // __builtin_ia32_psraw
-      {Intrinsic::x86_sse2_psra_w, 123674}, // __builtin_ia32_psraw128
-      {Intrinsic::x86_avx2_psra_w, 104861}, // __builtin_ia32_psraw256
-      {Intrinsic::x86_avx512_psra_w_512, 115402}, // __builtin_ia32_psraw512
-      {Intrinsic::x86_mmx_psrai_w, 120621}, // __builtin_ia32_psrawi
-      {Intrinsic::x86_sse2_psrai_w, 123723}, // __builtin_ia32_psrawi128
-      {Intrinsic::x86_avx2_psrai_w, 104910}, // __builtin_ia32_psrawi256
-      {Intrinsic::x86_avx512_psrai_w_512, 115526}, // __builtin_ia32_psrawi512
-      {Intrinsic::x86_mmx_psrl_d, 120643}, // __builtin_ia32_psrld
-      {Intrinsic::x86_sse2_psrl_d, 123748}, // __builtin_ia32_psrld128
-      {Intrinsic::x86_avx2_psrl_d, 104983}, // __builtin_ia32_psrld256
-      {Intrinsic::x86_avx512_psrl_d_512, 115724}, // __builtin_ia32_psrld512
-      {Intrinsic::x86_mmx_psrli_d, 120706}, // __builtin_ia32_psrldi
-      {Intrinsic::x86_sse2_psrli_d, 123820}, // __builtin_ia32_psrldi128
-      {Intrinsic::x86_avx2_psrli_d, 105055}, // __builtin_ia32_psrldi256
-      {Intrinsic::x86_avx512_psrli_d_512, 115796}, // __builtin_ia32_psrldi512
-      {Intrinsic::x86_mmx_psrl_q, 120664}, // __builtin_ia32_psrlq
-      {Intrinsic::x86_sse2_psrl_q, 123772}, // __builtin_ia32_psrlq128
-      {Intrinsic::x86_avx2_psrl_q, 105007}, // __builtin_ia32_psrlq256
-      {Intrinsic::x86_avx512_psrl_q_512, 115748}, // __builtin_ia32_psrlq512
-      {Intrinsic::x86_mmx_psrli_q, 120728}, // __builtin_ia32_psrlqi
-      {Intrinsic::x86_sse2_psrli_q, 123845}, // __builtin_ia32_psrlqi128
-      {Intrinsic::x86_avx2_psrli_q, 105080}, // __builtin_ia32_psrlqi256
-      {Intrinsic::x86_avx512_psrli_q_512, 115821}, // __builtin_ia32_psrlqi512
-      {Intrinsic::x86_avx512_psrlv_w_256, 115944}, // __builtin_ia32_psrlv16hi
-      {Intrinsic::x86_avx512_psrlv_d_512, 115871}, // __builtin_ia32_psrlv16si
-      {Intrinsic::x86_avx2_psrlv_q, 105178}, // __builtin_ia32_psrlv2di
-      {Intrinsic::x86_avx512_psrlv_w_512, 115969}, // __builtin_ia32_psrlv32hi
-      {Intrinsic::x86_avx2_psrlv_q_256, 105202}, // __builtin_ia32_psrlv4di
-      {Intrinsic::x86_avx2_psrlv_d, 105130}, // __builtin_ia32_psrlv4si
-      {Intrinsic::x86_avx512_psrlv_q_512, 115896}, // __builtin_ia32_psrlv8di
-      {Intrinsic::x86_avx512_psrlv_w_128, 115920}, // __builtin_ia32_psrlv8hi
-      {Intrinsic::x86_avx2_psrlv_d_256, 105154}, // __builtin_ia32_psrlv8si
-      {Intrinsic::x86_mmx_psrl_w, 120685}, // __builtin_ia32_psrlw
-      {Intrinsic::x86_sse2_psrl_w, 123796}, // __builtin_ia32_psrlw128
-      {Intrinsic::x86_avx2_psrl_w, 105031}, // __builtin_ia32_psrlw256
-      {Intrinsic::x86_avx512_psrl_w_512, 115772}, // __builtin_ia32_psrlw512
-      {Intrinsic::x86_mmx_psrli_w, 120750}, // __builtin_ia32_psrlwi
-      {Intrinsic::x86_sse2_psrli_w, 123870}, // __builtin_ia32_psrlwi128
-      {Intrinsic::x86_avx2_psrli_w, 105105}, // __builtin_ia32_psrlwi256
-      {Intrinsic::x86_avx512_psrli_w_512, 115846}, // __builtin_ia32_psrlwi512
-      {Intrinsic::x86_mmx_psub_b, 120772}, // __builtin_ia32_psubb
-      {Intrinsic::x86_mmx_psub_d, 120793}, // __builtin_ia32_psubd
-      {Intrinsic::x86_mmx_psub_q, 120814}, // __builtin_ia32_psubq
-      {Intrinsic::x86_mmx_psubs_b, 120856}, // __builtin_ia32_psubsb
-      {Intrinsic::x86_mmx_psubs_w, 120878}, // __builtin_ia32_psubsw
-      {Intrinsic::x86_mmx_psubus_b, 120900}, // __builtin_ia32_psubusb
-      {Intrinsic::x86_mmx_psubus_w, 120923}, // __builtin_ia32_psubusw
-      {Intrinsic::x86_mmx_psub_w, 120835}, // __builtin_ia32_psubw
-      {Intrinsic::x86_avx512_pternlog_d_128, 115994}, // __builtin_ia32_pternlogd128
-      {Intrinsic::x86_avx512_pternlog_d_256, 116022}, // __builtin_ia32_pternlogd256
-      {Intrinsic::x86_avx512_pternlog_d_512, 116050}, // __builtin_ia32_pternlogd512
-      {Intrinsic::x86_avx512_pternlog_q_128, 116078}, // __builtin_ia32_pternlogq128
-      {Intrinsic::x86_avx512_pternlog_q_256, 116106}, // __builtin_ia32_pternlogq256
-      {Intrinsic::x86_avx512_pternlog_q_512, 116134}, // __builtin_ia32_pternlogq512
-      {Intrinsic::x86_sse41_ptestc, 124471}, // __builtin_ia32_ptestc128
-      {Intrinsic::x86_avx_ptestc_256, 102584}, // __builtin_ia32_ptestc256
-      {Intrinsic::x86_sse41_ptestnzc, 124496}, // __builtin_ia32_ptestnzc128
-      {Intrinsic::x86_avx_ptestnzc_256, 102609}, // __builtin_ia32_ptestnzc256
-      {Intrinsic::x86_sse41_ptestz, 124523}, // __builtin_ia32_ptestz128
-      {Intrinsic::x86_avx_ptestz_256, 102636}, // __builtin_ia32_ptestz256
-      {Intrinsic::x86_ptwrite32, 121271}, // __builtin_ia32_ptwrite32
-      {Intrinsic::x86_ptwrite64, 121296}, // __builtin_ia32_ptwrite64
-      {Intrinsic::x86_mmx_punpckhbw, 120946}, // __builtin_ia32_punpckhbw
-      {Intrinsic::x86_mmx_punpckhdq, 120971}, // __builtin_ia32_punpckhdq
-      {Intrinsic::x86_mmx_punpckhwd, 120996}, // __builtin_ia32_punpckhwd
-      {Intrinsic::x86_mmx_punpcklbw, 121021}, // __builtin_ia32_punpcklbw
-      {Intrinsic::x86_mmx_punpckldq, 121046}, // __builtin_ia32_punpckldq
-      {Intrinsic::x86_mmx_punpcklwd, 121071}, // __builtin_ia32_punpcklwd
-      {Intrinsic::x86_mmx_pxor, 121096}, // __builtin_ia32_pxor
-      {Intrinsic::x86_avx512_mask_range_pd_128, 112541}, // __builtin_ia32_rangepd128_mask
-      {Intrinsic::x86_avx512_mask_range_pd_256, 112572}, // __builtin_ia32_rangepd256_mask
-      {Intrinsic::x86_avx512_mask_range_pd_512, 112603}, // __builtin_ia32_rangepd512_mask
-      {Intrinsic::x86_avx512_mask_range_ps_128, 112634}, // __builtin_ia32_rangeps128_mask
-      {Intrinsic::x86_avx512_mask_range_ps_256, 112665}, // __builtin_ia32_rangeps256_mask
-      {Intrinsic::x86_avx512_mask_range_ps_512, 112696}, // __builtin_ia32_rangeps512_mask
-      {Intrinsic::x86_avx512_mask_range_sd, 112727}, // __builtin_ia32_rangesd128_round_mask
-      {Intrinsic::x86_avx512_mask_range_ss, 112764}, // __builtin_ia32_rangess128_round_mask
-      {Intrinsic::x86_avx512_rcp14_pd_128, 116162}, // __builtin_ia32_rcp14pd128_mask
-      {Intrinsic::x86_avx512_rcp14_pd_256, 116193}, // __builtin_ia32_rcp14pd256_mask
-      {Intrinsic::x86_avx512_rcp14_pd_512, 116224}, // __builtin_ia32_rcp14pd512_mask
-      {Intrinsic::x86_avx512_rcp14_ps_128, 116255}, // __builtin_ia32_rcp14ps128_mask
-      {Intrinsic::x86_avx512_rcp14_ps_256, 116286}, // __builtin_ia32_rcp14ps256_mask
-      {Intrinsic::x86_avx512_rcp14_ps_512, 116317}, // __builtin_ia32_rcp14ps512_mask
-      {Intrinsic::x86_avx512_rcp14_sd, 116348}, // __builtin_ia32_rcp14sd_mask
-      {Intrinsic::x86_avx512_rcp14_ss, 116376}, // __builtin_ia32_rcp14ss_mask
-      {Intrinsic::x86_avx512_rcp28_pd, 116404}, // __builtin_ia32_rcp28pd_mask
-      {Intrinsic::x86_avx512_rcp28_ps, 116432}, // __builtin_ia32_rcp28ps_mask
-      {Intrinsic::x86_avx512_rcp28_sd, 116460}, // __builtin_ia32_rcp28sd_round_mask
-      {Intrinsic::x86_avx512_rcp28_ss, 116494}, // __builtin_ia32_rcp28ss_round_mask
-      {Intrinsic::x86_sse_rcp_ps, 122360}, // __builtin_ia32_rcpps
-      {Intrinsic::x86_avx_rcp_ps_256, 102661}, // __builtin_ia32_rcpps256
-      {Intrinsic::x86_sse_rcp_ss, 122381}, // __builtin_ia32_rcpss
-      {Intrinsic::x86_rdfsbase_32, 121321}, // __builtin_ia32_rdfsbase32
-      {Intrinsic::x86_rdfsbase_64, 121347}, // __builtin_ia32_rdfsbase64
-      {Intrinsic::x86_rdgsbase_32, 121373}, // __builtin_ia32_rdgsbase32
-      {Intrinsic::x86_rdgsbase_64, 121399}, // __builtin_ia32_rdgsbase64
-      {Intrinsic::x86_rdpid, 121425}, // __builtin_ia32_rdpid
-      {Intrinsic::x86_rdpkru, 121446}, // __builtin_ia32_rdpkru
-      {Intrinsic::x86_rdpmc, 121468}, // __builtin_ia32_rdpmc
-      {Intrinsic::x86_rdsspd, 121489}, // __builtin_ia32_rdsspd
-      {Intrinsic::x86_rdsspq, 121511}, // __builtin_ia32_rdsspq
-      {Intrinsic::x86_rdtsc, 121533}, // __builtin_ia32_rdtsc
-      {Intrinsic::x86_flags_read_u32, 119126}, // __builtin_ia32_readeflags_u32
-      {Intrinsic::x86_flags_read_u64, 119156}, // __builtin_ia32_readeflags_u64
-      {Intrinsic::x86_avx512_mask_reduce_pd_128, 112801}, // __builtin_ia32_reducepd128_mask
-      {Intrinsic::x86_avx512_mask_reduce_pd_256, 112833}, // __builtin_ia32_reducepd256_mask
-      {Intrinsic::x86_avx512_mask_reduce_pd_512, 112865}, // __builtin_ia32_reducepd512_mask
-      {Intrinsic::x86_avx512_mask_reduce_ps_128, 112897}, // __builtin_ia32_reduceps128_mask
-      {Intrinsic::x86_avx512_mask_reduce_ps_256, 112929}, // __builtin_ia32_reduceps256_mask
-      {Intrinsic::x86_avx512_mask_reduce_ps_512, 112961}, // __builtin_ia32_reduceps512_mask
-      {Intrinsic::x86_avx512_mask_reduce_sd, 112993}, // __builtin_ia32_reducesd_mask
-      {Intrinsic::x86_avx512_mask_reduce_ss, 113022}, // __builtin_ia32_reducess_mask
-      {Intrinsic::x86_avx512_mask_rndscale_pd_128, 113051}, // __builtin_ia32_rndscalepd_128_mask
-      {Intrinsic::x86_avx512_mask_rndscale_pd_256, 113086}, // __builtin_ia32_rndscalepd_256_mask
-      {Intrinsic::x86_avx512_mask_rndscale_pd_512, 113121}, // __builtin_ia32_rndscalepd_mask
-      {Intrinsic::x86_avx512_mask_rndscale_ps_128, 113152}, // __builtin_ia32_rndscaleps_128_mask
-      {Intrinsic::x86_avx512_mask_rndscale_ps_256, 113187}, // __builtin_ia32_rndscaleps_256_mask
-      {Intrinsic::x86_avx512_mask_rndscale_ps_512, 113222}, // __builtin_ia32_rndscaleps_mask
-      {Intrinsic::x86_avx512_mask_rndscale_sd, 113253}, // __builtin_ia32_rndscalesd_round_mask
-      {Intrinsic::x86_avx512_mask_rndscale_ss, 113290}, // __builtin_ia32_rndscaless_round_mask
-      {Intrinsic::x86_sse41_round_pd, 124548}, // __builtin_ia32_roundpd
-      {Intrinsic::x86_avx_round_pd_256, 102685}, // __builtin_ia32_roundpd256
-      {Intrinsic::x86_sse41_round_ps, 124571}, // __builtin_ia32_roundps
-      {Intrinsic::x86_avx_round_ps_256, 102711}, // __builtin_ia32_roundps256
-      {Intrinsic::x86_sse41_round_sd, 124594}, // __builtin_ia32_roundsd
-      {Intrinsic::x86_sse41_round_ss, 124617}, // __builtin_ia32_roundss
-      {Intrinsic::x86_avx512_rsqrt14_pd_128, 116528}, // __builtin_ia32_rsqrt14pd128_mask
-      {Intrinsic::x86_avx512_rsqrt14_pd_256, 116561}, // __builtin_ia32_rsqrt14pd256_mask
-      {Intrinsic::x86_avx512_rsqrt14_pd_512, 116594}, // __builtin_ia32_rsqrt14pd512_mask
-      {Intrinsic::x86_avx512_rsqrt14_ps_128, 116627}, // __builtin_ia32_rsqrt14ps128_mask
-      {Intrinsic::x86_avx512_rsqrt14_ps_256, 116660}, // __builtin_ia32_rsqrt14ps256_mask
-      {Intrinsic::x86_avx512_rsqrt14_ps_512, 116693}, // __builtin_ia32_rsqrt14ps512_mask
-      {Intrinsic::x86_avx512_rsqrt14_sd, 116726}, // __builtin_ia32_rsqrt14sd_mask
-      {Intrinsic::x86_avx512_rsqrt14_ss, 116756}, // __builtin_ia32_rsqrt14ss_mask
-      {Intrinsic::x86_avx512_rsqrt28_pd, 116786}, // __builtin_ia32_rsqrt28pd_mask
-      {Intrinsic::x86_avx512_rsqrt28_ps, 116816}, // __builtin_ia32_rsqrt28ps_mask
-      {Intrinsic::x86_avx512_rsqrt28_sd, 116846}, // __builtin_ia32_rsqrt28sd_round_mask
-      {Intrinsic::x86_avx512_rsqrt28_ss, 116882}, // __builtin_ia32_rsqrt28ss_round_mask
-      {Intrinsic::x86_sse_rsqrt_ps, 122402}, // __builtin_ia32_rsqrtps
-      {Intrinsic::x86_avx_rsqrt_ps_256, 102737}, // __builtin_ia32_rsqrtps256
-      {Intrinsic::x86_sse_rsqrt_ss, 122425}, // __builtin_ia32_rsqrtss
-      {Intrinsic::x86_rstorssp, 121554}, // __builtin_ia32_rstorssp
-      {Intrinsic::x86_saveprevssp, 121578}, // __builtin_ia32_saveprevssp
-      {Intrinsic::x86_avx512_mask_scalef_pd_128, 113327}, // __builtin_ia32_scalefpd128_mask
-      {Intrinsic::x86_avx512_mask_scalef_pd_256, 113359}, // __builtin_ia32_scalefpd256_mask
-      {Intrinsic::x86_avx512_mask_scalef_pd_512, 113391}, // __builtin_ia32_scalefpd512_mask
-      {Intrinsic::x86_avx512_mask_scalef_ps_128, 113423}, // __builtin_ia32_scalefps128_mask
-      {Intrinsic::x86_avx512_mask_scalef_ps_256, 113455}, // __builtin_ia32_scalefps256_mask
-      {Intrinsic::x86_avx512_mask_scalef_ps_512, 113487}, // __builtin_ia32_scalefps512_mask
-      {Intrinsic::x86_avx512_mask_scalef_sd, 113519}, // __builtin_ia32_scalefsd_round_mask
-      {Intrinsic::x86_avx512_mask_scalef_ss, 113554}, // __builtin_ia32_scalefss_round_mask
-      {Intrinsic::x86_avx512_scatterpf_dpd_512, 116918}, // __builtin_ia32_scatterpfdpd
-      {Intrinsic::x86_avx512_scatterpf_dps_512, 116946}, // __builtin_ia32_scatterpfdps
-      {Intrinsic::x86_avx512_scatterpf_qpd_512, 116974}, // __builtin_ia32_scatterpfqpd
-      {Intrinsic::x86_avx512_scatterpf_qps_512, 117002}, // __builtin_ia32_scatterpfqps
-      {Intrinsic::x86_setssbsy, 121605}, // __builtin_ia32_setssbsy
-      {Intrinsic::x86_sse_sfence, 122448}, // __builtin_ia32_sfence
-      {Intrinsic::x86_sha1msg1, 121629}, // __builtin_ia32_sha1msg1
-      {Intrinsic::x86_sha1msg2, 121653}, // __builtin_ia32_sha1msg2
-      {Intrinsic::x86_sha1nexte, 121677}, // __builtin_ia32_sha1nexte
-      {Intrinsic::x86_sha1rnds4, 121702}, // __builtin_ia32_sha1rnds4
-      {Intrinsic::x86_sha256msg1, 121727}, // __builtin_ia32_sha256msg1
-      {Intrinsic::x86_sha256msg2, 121753}, // __builtin_ia32_sha256msg2
-      {Intrinsic::x86_sha256rnds2, 121779}, // __builtin_ia32_sha256rnds2
-      {Intrinsic::x86_slwpcb, 121806}, // __builtin_ia32_slwpcb
-      {Intrinsic::x86_avx512_sub_pd_512, 117030}, // __builtin_ia32_subpd512
-      {Intrinsic::x86_avx512_sub_ps_512, 117054}, // __builtin_ia32_subps512
-      {Intrinsic::x86_avx512_mask_sub_sd_round, 113589}, // __builtin_ia32_subsd_round_mask
-      {Intrinsic::x86_avx512_mask_sub_ss_round, 113621}, // __builtin_ia32_subss_round_mask
-      {Intrinsic::x86_tpause, 125917}, // __builtin_ia32_tpause
-      {Intrinsic::x86_sse_ucomieq_ss, 122470}, // __builtin_ia32_ucomieq
-      {Intrinsic::x86_sse_ucomige_ss, 122493}, // __builtin_ia32_ucomige
-      {Intrinsic::x86_sse_ucomigt_ss, 122516}, // __builtin_ia32_ucomigt
-      {Intrinsic::x86_sse_ucomile_ss, 122539}, // __builtin_ia32_ucomile
-      {Intrinsic::x86_sse_ucomilt_ss, 122562}, // __builtin_ia32_ucomilt
-      {Intrinsic::x86_sse_ucomineq_ss, 122585}, // __builtin_ia32_ucomineq
-      {Intrinsic::x86_sse2_ucomieq_sd, 123895}, // __builtin_ia32_ucomisdeq
-      {Intrinsic::x86_sse2_ucomige_sd, 123920}, // __builtin_ia32_ucomisdge
-      {Intrinsic::x86_sse2_ucomigt_sd, 123945}, // __builtin_ia32_ucomisdgt
-      {Intrinsic::x86_sse2_ucomile_sd, 123970}, // __builtin_ia32_ucomisdle
-      {Intrinsic::x86_sse2_ucomilt_sd, 123995}, // __builtin_ia32_ucomisdlt
-      {Intrinsic::x86_sse2_ucomineq_sd, 124020}, // __builtin_ia32_ucomisdneq
-      {Intrinsic::x86_umonitor, 125939}, // __builtin_ia32_umonitor
-      {Intrinsic::x86_umwait, 125963}, // __builtin_ia32_umwait
-      {Intrinsic::x86_avx512_vcomi_sd, 117078}, // __builtin_ia32_vcomisd
-      {Intrinsic::x86_avx512_vcomi_ss, 117101}, // __builtin_ia32_vcomiss
-      {Intrinsic::x86_vcvtph2ps_128, 125985}, // __builtin_ia32_vcvtph2ps
-      {Intrinsic::x86_vcvtph2ps_256, 126010}, // __builtin_ia32_vcvtph2ps256
-      {Intrinsic::x86_avx512_mask_vcvtph2ps_256, 113683}, // __builtin_ia32_vcvtph2ps256_mask
-      {Intrinsic::x86_avx512_mask_vcvtph2ps_512, 113716}, // __builtin_ia32_vcvtph2ps512_mask
-      {Intrinsic::x86_avx512_mask_vcvtph2ps_128, 113653}, // __builtin_ia32_vcvtph2ps_mask
-      {Intrinsic::x86_vcvtps2ph_128, 126038}, // __builtin_ia32_vcvtps2ph
-      {Intrinsic::x86_vcvtps2ph_256, 126063}, // __builtin_ia32_vcvtps2ph256
-      {Intrinsic::x86_avx512_mask_vcvtps2ph_256, 113779}, // __builtin_ia32_vcvtps2ph256_mask
-      {Intrinsic::x86_avx512_mask_vcvtps2ph_512, 113812}, // __builtin_ia32_vcvtps2ph512_mask
-      {Intrinsic::x86_avx512_mask_vcvtps2ph_128, 113749}, // __builtin_ia32_vcvtps2ph_mask
-      {Intrinsic::x86_avx512_vcvtsd2si32, 117124}, // __builtin_ia32_vcvtsd2si32
-      {Intrinsic::x86_avx512_vcvtsd2si64, 117151}, // __builtin_ia32_vcvtsd2si64
-      {Intrinsic::x86_avx512_vcvtsd2usi32, 117178}, // __builtin_ia32_vcvtsd2usi32
-      {Intrinsic::x86_avx512_vcvtsd2usi64, 117206}, // __builtin_ia32_vcvtsd2usi64
-      {Intrinsic::x86_avx512_vcvtss2si32, 117234}, // __builtin_ia32_vcvtss2si32
-      {Intrinsic::x86_avx512_vcvtss2si64, 117261}, // __builtin_ia32_vcvtss2si64
-      {Intrinsic::x86_avx512_vcvtss2usi32, 117288}, // __builtin_ia32_vcvtss2usi32
-      {Intrinsic::x86_avx512_vcvtss2usi64, 117316}, // __builtin_ia32_vcvtss2usi64
-      {Intrinsic::x86_avx512_cvttsd2si, 105724}, // __builtin_ia32_vcvttsd2si32
-      {Intrinsic::x86_avx512_cvttsd2si64, 105752}, // __builtin_ia32_vcvttsd2si64
-      {Intrinsic::x86_avx512_cvttsd2usi, 105780}, // __builtin_ia32_vcvttsd2usi32
-      {Intrinsic::x86_avx512_cvttsd2usi64, 105809}, // __builtin_ia32_vcvttsd2usi64
-      {Intrinsic::x86_avx512_cvttss2si, 105838}, // __builtin_ia32_vcvttss2si32
-      {Intrinsic::x86_avx512_cvttss2si64, 105866}, // __builtin_ia32_vcvttss2si64
-      {Intrinsic::x86_avx512_cvttss2usi, 105894}, // __builtin_ia32_vcvttss2usi32
-      {Intrinsic::x86_avx512_cvttss2usi64, 105923}, // __builtin_ia32_vcvttss2usi64
-      {Intrinsic::x86_mmx_pextr_w, 120106}, // __builtin_ia32_vec_ext_v4hi
-      {Intrinsic::x86_mmx_pinsr_w, 120134}, // __builtin_ia32_vec_set_v4hi
-      {Intrinsic::x86_xop_vfrcz_pd, 126734}, // __builtin_ia32_vfrczpd
-      {Intrinsic::x86_xop_vfrcz_pd_256, 126757}, // __builtin_ia32_vfrczpd256
-      {Intrinsic::x86_xop_vfrcz_ps, 126783}, // __builtin_ia32_vfrczps
-      {Intrinsic::x86_xop_vfrcz_ps_256, 126806}, // __builtin_ia32_vfrczps256
-      {Intrinsic::x86_xop_vfrcz_sd, 126832}, // __builtin_ia32_vfrczsd
-      {Intrinsic::x86_xop_vfrcz_ss, 126855}, // __builtin_ia32_vfrczss
-      {Intrinsic::x86_vgf2p8affineinvqb_128, 126091}, // __builtin_ia32_vgf2p8affineinvqb_v16qi
-      {Intrinsic::x86_vgf2p8affineinvqb_256, 126130}, // __builtin_ia32_vgf2p8affineinvqb_v32qi
-      {Intrinsic::x86_vgf2p8affineinvqb_512, 126169}, // __builtin_ia32_vgf2p8affineinvqb_v64qi
-      {Intrinsic::x86_vgf2p8affineqb_128, 126208}, // __builtin_ia32_vgf2p8affineqb_v16qi
-      {Intrinsic::x86_vgf2p8affineqb_256, 126244}, // __builtin_ia32_vgf2p8affineqb_v32qi
-      {Intrinsic::x86_vgf2p8affineqb_512, 126280}, // __builtin_ia32_vgf2p8affineqb_v64qi
-      {Intrinsic::x86_vgf2p8mulb_128, 126316}, // __builtin_ia32_vgf2p8mulb_v16qi
-      {Intrinsic::x86_vgf2p8mulb_256, 126348}, // __builtin_ia32_vgf2p8mulb_v32qi
-      {Intrinsic::x86_vgf2p8mulb_512, 126380}, // __builtin_ia32_vgf2p8mulb_v64qi
-      {Intrinsic::x86_avx512_conflict_q_128, 105550}, // __builtin_ia32_vpconflictdi_128
-      {Intrinsic::x86_avx512_conflict_q_256, 105582}, // __builtin_ia32_vpconflictdi_256
-      {Intrinsic::x86_avx512_conflict_q_512, 105614}, // __builtin_ia32_vpconflictdi_512
-      {Intrinsic::x86_avx512_conflict_d_128, 105454}, // __builtin_ia32_vpconflictsi_128
-      {Intrinsic::x86_avx512_conflict_d_256, 105486}, // __builtin_ia32_vpconflictsi_256
-      {Intrinsic::x86_avx512_conflict_d_512, 105518}, // __builtin_ia32_vpconflictsi_512
-      {Intrinsic::x86_avx512_vpdpbusd_128, 117344}, // __builtin_ia32_vpdpbusd128
-      {Intrinsic::x86_avx512_vpdpbusd_256, 117371}, // __builtin_ia32_vpdpbusd256
-      {Intrinsic::x86_avx512_vpdpbusd_512, 117398}, // __builtin_ia32_vpdpbusd512
-      {Intrinsic::x86_avx512_vpdpbusds_128, 117425}, // __builtin_ia32_vpdpbusds128
-      {Intrinsic::x86_avx512_vpdpbusds_256, 117453}, // __builtin_ia32_vpdpbusds256
-      {Intrinsic::x86_avx512_vpdpbusds_512, 117481}, // __builtin_ia32_vpdpbusds512
-      {Intrinsic::x86_avx512_vpdpwssd_128, 117509}, // __builtin_ia32_vpdpwssd128
-      {Intrinsic::x86_avx512_vpdpwssd_256, 117536}, // __builtin_ia32_vpdpwssd256
-      {Intrinsic::x86_avx512_vpdpwssd_512, 117563}, // __builtin_ia32_vpdpwssd512
-      {Intrinsic::x86_avx512_vpdpwssds_128, 117590}, // __builtin_ia32_vpdpwssds128
-      {Intrinsic::x86_avx512_vpdpwssds_256, 117618}, // __builtin_ia32_vpdpwssds256
-      {Intrinsic::x86_avx512_vpdpwssds_512, 117646}, // __builtin_ia32_vpdpwssds512
-      {Intrinsic::x86_avx512_vpermi2var_d_128, 117674}, // __builtin_ia32_vpermi2vard128
-      {Intrinsic::x86_avx512_vpermi2var_d_256, 117704}, // __builtin_ia32_vpermi2vard256
-      {Intrinsic::x86_avx512_vpermi2var_d_512, 117734}, // __builtin_ia32_vpermi2vard512
-      {Intrinsic::x86_avx512_vpermi2var_hi_128, 117764}, // __builtin_ia32_vpermi2varhi128
-      {Intrinsic::x86_avx512_vpermi2var_hi_256, 117795}, // __builtin_ia32_vpermi2varhi256
-      {Intrinsic::x86_avx512_vpermi2var_hi_512, 117826}, // __builtin_ia32_vpermi2varhi512
-      {Intrinsic::x86_avx512_vpermi2var_pd_128, 117857}, // __builtin_ia32_vpermi2varpd128
-      {Intrinsic::x86_avx512_vpermi2var_pd_256, 117888}, // __builtin_ia32_vpermi2varpd256
-      {Intrinsic::x86_avx512_vpermi2var_pd_512, 117919}, // __builtin_ia32_vpermi2varpd512
-      {Intrinsic::x86_avx512_vpermi2var_ps_128, 117950}, // __builtin_ia32_vpermi2varps128
-      {Intrinsic::x86_avx512_vpermi2var_ps_256, 117981}, // __builtin_ia32_vpermi2varps256
-      {Intrinsic::x86_avx512_vpermi2var_ps_512, 118012}, // __builtin_ia32_vpermi2varps512
-      {Intrinsic::x86_avx512_vpermi2var_q_128, 118043}, // __builtin_ia32_vpermi2varq128
-      {Intrinsic::x86_avx512_vpermi2var_q_256, 118073}, // __builtin_ia32_vpermi2varq256
-      {Intrinsic::x86_avx512_vpermi2var_q_512, 118103}, // __builtin_ia32_vpermi2varq512
-      {Intrinsic::x86_avx512_vpermi2var_qi_128, 118133}, // __builtin_ia32_vpermi2varqi128
-      {Intrinsic::x86_avx512_vpermi2var_qi_256, 118164}, // __builtin_ia32_vpermi2varqi256
-      {Intrinsic::x86_avx512_vpermi2var_qi_512, 118195}, // __builtin_ia32_vpermi2varqi512
-      {Intrinsic::x86_xop_vpermil2pd, 126878}, // __builtin_ia32_vpermil2pd
-      {Intrinsic::x86_xop_vpermil2pd_256, 126904}, // __builtin_ia32_vpermil2pd256
-      {Intrinsic::x86_xop_vpermil2ps, 126933}, // __builtin_ia32_vpermil2ps
-      {Intrinsic::x86_xop_vpermil2ps_256, 126959}, // __builtin_ia32_vpermil2ps256
-      {Intrinsic::x86_avx_vpermilvar_pd, 102763}, // __builtin_ia32_vpermilvarpd
-      {Intrinsic::x86_avx_vpermilvar_pd_256, 102791}, // __builtin_ia32_vpermilvarpd256
-      {Intrinsic::x86_avx512_vpermilvar_pd_512, 118226}, // __builtin_ia32_vpermilvarpd512
-      {Intrinsic::x86_avx_vpermilvar_ps, 102822}, // __builtin_ia32_vpermilvarps
-      {Intrinsic::x86_avx_vpermilvar_ps_256, 102850}, // __builtin_ia32_vpermilvarps256
-      {Intrinsic::x86_avx512_vpermilvar_ps_512, 118257}, // __builtin_ia32_vpermilvarps512
-      {Intrinsic::x86_xop_vphaddbd, 126988}, // __builtin_ia32_vphaddbd
-      {Intrinsic::x86_xop_vphaddbq, 127012}, // __builtin_ia32_vphaddbq
-      {Intrinsic::x86_xop_vphaddbw, 127036}, // __builtin_ia32_vphaddbw
-      {Intrinsic::x86_xop_vphadddq, 127060}, // __builtin_ia32_vphadddq
-      {Intrinsic::x86_xop_vphaddubd, 127084}, // __builtin_ia32_vphaddubd
-      {Intrinsic::x86_xop_vphaddubq, 127109}, // __builtin_ia32_vphaddubq
-      {Intrinsic::x86_xop_vphaddubw, 127134}, // __builtin_ia32_vphaddubw
-      {Intrinsic::x86_xop_vphaddudq, 127159}, // __builtin_ia32_vphaddudq
-      {Intrinsic::x86_xop_vphadduwd, 127184}, // __builtin_ia32_vphadduwd
-      {Intrinsic::x86_xop_vphadduwq, 127209}, // __builtin_ia32_vphadduwq
-      {Intrinsic::x86_xop_vphaddwd, 127234}, // __builtin_ia32_vphaddwd
-      {Intrinsic::x86_xop_vphaddwq, 127258}, // __builtin_ia32_vphaddwq
-      {Intrinsic::x86_xop_vphsubbw, 127282}, // __builtin_ia32_vphsubbw
-      {Intrinsic::x86_xop_vphsubdq, 127306}, // __builtin_ia32_vphsubdq
-      {Intrinsic::x86_xop_vphsubwd, 127330}, // __builtin_ia32_vphsubwd
-      {Intrinsic::x86_xop_vpmacsdd, 127354}, // __builtin_ia32_vpmacsdd
-      {Intrinsic::x86_xop_vpmacsdqh, 127378}, // __builtin_ia32_vpmacsdqh
-      {Intrinsic::x86_xop_vpmacsdql, 127403}, // __builtin_ia32_vpmacsdql
-      {Intrinsic::x86_xop_vpmacssdd, 127428}, // __builtin_ia32_vpmacssdd
-      {Intrinsic::x86_xop_vpmacssdqh, 127453}, // __builtin_ia32_vpmacssdqh
-      {Intrinsic::x86_xop_vpmacssdql, 127479}, // __builtin_ia32_vpmacssdql
-      {Intrinsic::x86_xop_vpmacsswd, 127505}, // __builtin_ia32_vpmacsswd
-      {Intrinsic::x86_xop_vpmacssww, 127530}, // __builtin_ia32_vpmacssww
-      {Intrinsic::x86_xop_vpmacswd, 127555}, // __builtin_ia32_vpmacswd
-      {Intrinsic::x86_xop_vpmacsww, 127579}, // __builtin_ia32_vpmacsww
-      {Intrinsic::x86_xop_vpmadcsswd, 127603}, // __builtin_ia32_vpmadcsswd
-      {Intrinsic::x86_xop_vpmadcswd, 127629}, // __builtin_ia32_vpmadcswd
-      {Intrinsic::x86_avx512_vpmadd52h_uq_128, 118288}, // __builtin_ia32_vpmadd52huq128
-      {Intrinsic::x86_avx512_vpmadd52h_uq_256, 118318}, // __builtin_ia32_vpmadd52huq256
-      {Intrinsic::x86_avx512_vpmadd52h_uq_512, 118348}, // __builtin_ia32_vpmadd52huq512
-      {Intrinsic::x86_avx512_vpmadd52l_uq_128, 118378}, // __builtin_ia32_vpmadd52luq128
-      {Intrinsic::x86_avx512_vpmadd52l_uq_256, 118408}, // __builtin_ia32_vpmadd52luq256
-      {Intrinsic::x86_avx512_vpmadd52l_uq_512, 118438}, // __builtin_ia32_vpmadd52luq512
-      {Intrinsic::x86_avx512_pmultishift_qb_128, 114887}, // __builtin_ia32_vpmultishiftqb128
-      {Intrinsic::x86_avx512_pmultishift_qb_256, 114920}, // __builtin_ia32_vpmultishiftqb256
-      {Intrinsic::x86_avx512_pmultishift_qb_512, 114953}, // __builtin_ia32_vpmultishiftqb512
-      {Intrinsic::x86_xop_vpperm, 127654}, // __builtin_ia32_vpperm
-      {Intrinsic::x86_xop_vpshab, 127676}, // __builtin_ia32_vpshab
-      {Intrinsic::x86_xop_vpshad, 127698}, // __builtin_ia32_vpshad
-      {Intrinsic::x86_xop_vpshaq, 127720}, // __builtin_ia32_vpshaq
-      {Intrinsic::x86_xop_vpshaw, 127742}, // __builtin_ia32_vpshaw
-      {Intrinsic::x86_xop_vpshlb, 127764}, // __builtin_ia32_vpshlb
-      {Intrinsic::x86_xop_vpshld, 127786}, // __builtin_ia32_vpshld
-      {Intrinsic::x86_xop_vpshlq, 127808}, // __builtin_ia32_vpshlq
-      {Intrinsic::x86_xop_vpshlw, 127830}, // __builtin_ia32_vpshlw
-      {Intrinsic::x86_avx_vtestc_pd, 102881}, // __builtin_ia32_vtestcpd
-      {Intrinsic::x86_avx_vtestc_pd_256, 102905}, // __builtin_ia32_vtestcpd256
-      {Intrinsic::x86_avx_vtestc_ps, 102932}, // __builtin_ia32_vtestcps
-      {Intrinsic::x86_avx_vtestc_ps_256, 102956}, // __builtin_ia32_vtestcps256
-      {Intrinsic::x86_avx_vtestnzc_pd, 102983}, // __builtin_ia32_vtestnzcpd
-      {Intrinsic::x86_avx_vtestnzc_pd_256, 103009}, // __builtin_ia32_vtestnzcpd256
-      {Intrinsic::x86_avx_vtestnzc_ps, 103038}, // __builtin_ia32_vtestnzcps
-      {Intrinsic::x86_avx_vtestnzc_ps_256, 103064}, // __builtin_ia32_vtestnzcps256
-      {Intrinsic::x86_avx_vtestz_pd, 103093}, // __builtin_ia32_vtestzpd
-      {Intrinsic::x86_avx_vtestz_pd_256, 103117}, // __builtin_ia32_vtestzpd256
-      {Intrinsic::x86_avx_vtestz_ps, 103144}, // __builtin_ia32_vtestzps
-      {Intrinsic::x86_avx_vtestz_ps_256, 103168}, // __builtin_ia32_vtestzps256
-      {Intrinsic::x86_avx_vzeroall, 103195}, // __builtin_ia32_vzeroall
-      {Intrinsic::x86_avx_vzeroupper, 103219}, // __builtin_ia32_vzeroupper
-      {Intrinsic::x86_wbinvd, 126412}, // __builtin_ia32_wbinvd
-      {Intrinsic::x86_wbnoinvd, 126434}, // __builtin_ia32_wbnoinvd
-      {Intrinsic::x86_wrfsbase_32, 126458}, // __builtin_ia32_wrfsbase32
-      {Intrinsic::x86_wrfsbase_64, 126484}, // __builtin_ia32_wrfsbase64
-      {Intrinsic::x86_wrgsbase_32, 126510}, // __builtin_ia32_wrgsbase32
-      {Intrinsic::x86_wrgsbase_64, 126536}, // __builtin_ia32_wrgsbase64
-      {Intrinsic::x86_flags_write_u32, 119186}, // __builtin_ia32_writeeflags_u32
-      {Intrinsic::x86_flags_write_u64, 119217}, // __builtin_ia32_writeeflags_u64
-      {Intrinsic::x86_wrpkru, 126562}, // __builtin_ia32_wrpkru
-      {Intrinsic::x86_wrssd, 126584}, // __builtin_ia32_wrssd
-      {Intrinsic::x86_wrssq, 126605}, // __builtin_ia32_wrssq
-      {Intrinsic::x86_wrussd, 126626}, // __builtin_ia32_wrussd
-      {Intrinsic::x86_wrussq, 126648}, // __builtin_ia32_wrussq
-      {Intrinsic::x86_xabort, 126670}, // __builtin_ia32_xabort
-      {Intrinsic::x86_xbegin, 126692}, // __builtin_ia32_xbegin
-      {Intrinsic::x86_xend, 126714}, // __builtin_ia32_xend
-      {Intrinsic::x86_xtest, 127852}, // __builtin_ia32_xtest
+      {Intrinsic::x86_avx512_add_pd_512, 137913}, // __builtin_ia32_addpd512
+      {Intrinsic::x86_avx512_add_ps_512, 137937}, // __builtin_ia32_addps512
+      {Intrinsic::x86_avx512_mask_add_sd_round, 139011}, // __builtin_ia32_addsd_round_mask
+      {Intrinsic::x86_avx512_mask_add_ss_round, 139043}, // __builtin_ia32_addss_round_mask
+      {Intrinsic::x86_sse3_addsub_pd, 156876}, // __builtin_ia32_addsubpd
+      {Intrinsic::x86_avx_addsub_pd_256, 134505}, // __builtin_ia32_addsubpd256
+      {Intrinsic::x86_sse3_addsub_ps, 156900}, // __builtin_ia32_addsubps
+      {Intrinsic::x86_avx_addsub_ps_256, 134532}, // __builtin_ia32_addsubps256
+      {Intrinsic::x86_aesni_aesdec, 134122}, // __builtin_ia32_aesdec128
+      {Intrinsic::x86_aesni_aesdec_256, 134147}, // __builtin_ia32_aesdec256
+      {Intrinsic::x86_aesni_aesdec_512, 134172}, // __builtin_ia32_aesdec512
+      {Intrinsic::x86_aesni_aesdeclast, 134197}, // __builtin_ia32_aesdeclast128
+      {Intrinsic::x86_aesni_aesdeclast_256, 134226}, // __builtin_ia32_aesdeclast256
+      {Intrinsic::x86_aesni_aesdeclast_512, 134255}, // __builtin_ia32_aesdeclast512
+      {Intrinsic::x86_aesni_aesenc, 134284}, // __builtin_ia32_aesenc128
+      {Intrinsic::x86_aesni_aesenc_256, 134309}, // __builtin_ia32_aesenc256
+      {Intrinsic::x86_aesni_aesenc_512, 134334}, // __builtin_ia32_aesenc512
+      {Intrinsic::x86_aesni_aesenclast, 134359}, // __builtin_ia32_aesenclast128
+      {Intrinsic::x86_aesni_aesenclast_256, 134388}, // __builtin_ia32_aesenclast256
+      {Intrinsic::x86_aesni_aesenclast_512, 134417}, // __builtin_ia32_aesenclast512
+      {Intrinsic::x86_aesni_aesimc, 134446}, // __builtin_ia32_aesimc128
+      {Intrinsic::x86_aesni_aeskeygenassist, 134471}, // __builtin_ia32_aeskeygenassist128
+      {Intrinsic::x86_bmi_bextr_32, 151306}, // __builtin_ia32_bextr_u32
+      {Intrinsic::x86_bmi_bextr_64, 151331}, // __builtin_ia32_bextr_u64
+      {Intrinsic::x86_tbm_bextri_u32, 158747}, // __builtin_ia32_bextri_u32
+      {Intrinsic::x86_tbm_bextri_u64, 158773}, // __builtin_ia32_bextri_u64
+      {Intrinsic::x86_sse41_blendvpd, 157077}, // __builtin_ia32_blendvpd
+      {Intrinsic::x86_avx_blendv_pd_256, 134559}, // __builtin_ia32_blendvpd256
+      {Intrinsic::x86_sse41_blendvps, 157101}, // __builtin_ia32_blendvps
+      {Intrinsic::x86_avx_blendv_ps_256, 134586}, // __builtin_ia32_blendvps256
+      {Intrinsic::x86_avx512_broadcastmb_128, 137961}, // __builtin_ia32_broadcastmb128
+      {Intrinsic::x86_avx512_broadcastmb_256, 137991}, // __builtin_ia32_broadcastmb256
+      {Intrinsic::x86_avx512_broadcastmb_512, 138021}, // __builtin_ia32_broadcastmb512
+      {Intrinsic::x86_avx512_broadcastmw_128, 138051}, // __builtin_ia32_broadcastmw128
+      {Intrinsic::x86_avx512_broadcastmw_256, 138081}, // __builtin_ia32_broadcastmw256
+      {Intrinsic::x86_avx512_broadcastmw_512, 138111}, // __builtin_ia32_broadcastmw512
+      {Intrinsic::x86_bmi_bzhi_64, 151379}, // __builtin_ia32_bzhi_di
+      {Intrinsic::x86_bmi_bzhi_32, 151356}, // __builtin_ia32_bzhi_si
+      {Intrinsic::x86_cldemote, 151494}, // __builtin_ia32_cldemote
+      {Intrinsic::x86_sse2_clflush, 155439}, // __builtin_ia32_clflush
+      {Intrinsic::x86_clflushopt, 151518}, // __builtin_ia32_clflushopt
+      {Intrinsic::x86_clrssbsy, 151544}, // __builtin_ia32_clrssbsy
+      {Intrinsic::x86_clui, 151568}, // __builtin_ia32_clui
+      {Intrinsic::x86_clwb, 151588}, // __builtin_ia32_clwb
+      {Intrinsic::x86_clzero, 151608}, // __builtin_ia32_clzero
+      {Intrinsic::x86_sse2_cmp_sd, 155462}, // __builtin_ia32_cmpsd
+      {Intrinsic::x86_avx512_mask_cmp_sd, 139075}, // __builtin_ia32_cmpsd_mask
+      {Intrinsic::x86_sse_cmp_ss, 154658}, // __builtin_ia32_cmpss
+      {Intrinsic::x86_avx512_mask_cmp_ss, 139101}, // __builtin_ia32_cmpss_mask
+      {Intrinsic::x86_sse_comieq_ss, 154679}, // __builtin_ia32_comieq
+      {Intrinsic::x86_sse_comige_ss, 154701}, // __builtin_ia32_comige
+      {Intrinsic::x86_sse_comigt_ss, 154723}, // __builtin_ia32_comigt
+      {Intrinsic::x86_sse_comile_ss, 154745}, // __builtin_ia32_comile
+      {Intrinsic::x86_sse_comilt_ss, 154767}, // __builtin_ia32_comilt
+      {Intrinsic::x86_sse_comineq_ss, 154789}, // __builtin_ia32_comineq
+      {Intrinsic::x86_sse2_comieq_sd, 155483}, // __builtin_ia32_comisdeq
+      {Intrinsic::x86_sse2_comige_sd, 155507}, // __builtin_ia32_comisdge
+      {Intrinsic::x86_sse2_comigt_sd, 155531}, // __builtin_ia32_comisdgt
+      {Intrinsic::x86_sse2_comile_sd, 155555}, // __builtin_ia32_comisdle
+      {Intrinsic::x86_sse2_comilt_sd, 155579}, // __builtin_ia32_comisdlt
+      {Intrinsic::x86_sse2_comineq_sd, 155603}, // __builtin_ia32_comisdneq
+      {Intrinsic::x86_sse42_crc32_64_64, 157539}, // __builtin_ia32_crc32di
+      {Intrinsic::x86_sse42_crc32_32_16, 157470}, // __builtin_ia32_crc32hi
+      {Intrinsic::x86_sse42_crc32_32_8, 157516}, // __builtin_ia32_crc32qi
+      {Intrinsic::x86_sse42_crc32_32_32, 157493}, // __builtin_ia32_crc32si
+      {Intrinsic::x86_avx512bf16_cvtne2ps2bf16_128, 151059}, // __builtin_ia32_cvtne2ps2bf16_128
+      {Intrinsic::x86_avx512bf16_cvtne2ps2bf16_256, 151092}, // __builtin_ia32_cvtne2ps2bf16_256
+      {Intrinsic::x86_avx512bf16_cvtne2ps2bf16_512, 151125}, // __builtin_ia32_cvtne2ps2bf16_512
+      {Intrinsic::x86_avx512bf16_cvtneps2bf16_256, 151158}, // __builtin_ia32_cvtneps2bf16_256
+      {Intrinsic::x86_avx512bf16_cvtneps2bf16_512, 151190}, // __builtin_ia32_cvtneps2bf16_512
+      {Intrinsic::x86_sse2_cvtpd2dq, 155628}, // __builtin_ia32_cvtpd2dq
+      {Intrinsic::x86_avx512_mask_cvtpd2dq_128, 139127}, // __builtin_ia32_cvtpd2dq128_mask
+      {Intrinsic::x86_avx_cvt_pd2dq_256, 134640}, // __builtin_ia32_cvtpd2dq256
+      {Intrinsic::x86_avx512_mask_cvtpd2dq_512, 139159}, // __builtin_ia32_cvtpd2dq512_mask
+      {Intrinsic::x86_sse_cvtpd2pi, 154812}, // __builtin_ia32_cvtpd2pi
+      {Intrinsic::x86_sse2_cvtpd2ps, 155652}, // __builtin_ia32_cvtpd2ps
+      {Intrinsic::x86_avx_cvt_pd2_ps_256, 134613}, // __builtin_ia32_cvtpd2ps256
+      {Intrinsic::x86_avx512_mask_cvtpd2ps_512, 139220}, // __builtin_ia32_cvtpd2ps512_mask
+      {Intrinsic::x86_avx512_mask_cvtpd2ps, 139191}, // __builtin_ia32_cvtpd2ps_mask
+      {Intrinsic::x86_avx512_mask_cvtpd2qq_128, 139252}, // __builtin_ia32_cvtpd2qq128_mask
+      {Intrinsic::x86_avx512_mask_cvtpd2qq_256, 139284}, // __builtin_ia32_cvtpd2qq256_mask
+      {Intrinsic::x86_avx512_mask_cvtpd2qq_512, 139316}, // __builtin_ia32_cvtpd2qq512_mask
+      {Intrinsic::x86_avx512_mask_cvtpd2udq_128, 139348}, // __builtin_ia32_cvtpd2udq128_mask
+      {Intrinsic::x86_avx512_mask_cvtpd2udq_256, 139381}, // __builtin_ia32_cvtpd2udq256_mask
+      {Intrinsic::x86_avx512_mask_cvtpd2udq_512, 139414}, // __builtin_ia32_cvtpd2udq512_mask
+      {Intrinsic::x86_avx512_mask_cvtpd2uqq_128, 139447}, // __builtin_ia32_cvtpd2uqq128_mask
+      {Intrinsic::x86_avx512_mask_cvtpd2uqq_256, 139480}, // __builtin_ia32_cvtpd2uqq256_mask
+      {Intrinsic::x86_avx512_mask_cvtpd2uqq_512, 139513}, // __builtin_ia32_cvtpd2uqq512_mask
+      {Intrinsic::x86_sse_cvtpi2pd, 154836}, // __builtin_ia32_cvtpi2pd
+      {Intrinsic::x86_sse_cvtpi2ps, 154860}, // __builtin_ia32_cvtpi2ps
+      {Intrinsic::x86_sse2_cvtps2dq, 155676}, // __builtin_ia32_cvtps2dq
+      {Intrinsic::x86_avx512_mask_cvtps2dq_128, 139546}, // __builtin_ia32_cvtps2dq128_mask
+      {Intrinsic::x86_avx_cvt_ps2dq_256, 134667}, // __builtin_ia32_cvtps2dq256
+      {Intrinsic::x86_avx512_mask_cvtps2dq_256, 139578}, // __builtin_ia32_cvtps2dq256_mask
+      {Intrinsic::x86_avx512_mask_cvtps2dq_512, 139610}, // __builtin_ia32_cvtps2dq512_mask
+      {Intrinsic::x86_avx512_mask_cvtps2pd_512, 139642}, // __builtin_ia32_cvtps2pd512_mask
+      {Intrinsic::x86_sse_cvtps2pi, 154884}, // __builtin_ia32_cvtps2pi
+      {Intrinsic::x86_avx512_mask_cvtps2qq_128, 139674}, // __builtin_ia32_cvtps2qq128_mask
+      {Intrinsic::x86_avx512_mask_cvtps2qq_256, 139706}, // __builtin_ia32_cvtps2qq256_mask
+      {Intrinsic::x86_avx512_mask_cvtps2qq_512, 139738}, // __builtin_ia32_cvtps2qq512_mask
+      {Intrinsic::x86_avx512_mask_cvtps2udq_128, 139770}, // __builtin_ia32_cvtps2udq128_mask
+      {Intrinsic::x86_avx512_mask_cvtps2udq_256, 139803}, // __builtin_ia32_cvtps2udq256_mask
+      {Intrinsic::x86_avx512_mask_cvtps2udq_512, 139836}, // __builtin_ia32_cvtps2udq512_mask
+      {Intrinsic::x86_avx512_mask_cvtps2uqq_128, 139869}, // __builtin_ia32_cvtps2uqq128_mask
+      {Intrinsic::x86_avx512_mask_cvtps2uqq_256, 139902}, // __builtin_ia32_cvtps2uqq256_mask
+      {Intrinsic::x86_avx512_mask_cvtps2uqq_512, 139935}, // __builtin_ia32_cvtps2uqq512_mask
+      {Intrinsic::x86_avx512_mask_cvtqq2ps_128, 139968}, // __builtin_ia32_cvtqq2ps128_mask
+      {Intrinsic::x86_sse2_cvtsd2si, 155700}, // __builtin_ia32_cvtsd2si
+      {Intrinsic::x86_sse2_cvtsd2si64, 155724}, // __builtin_ia32_cvtsd2si64
+      {Intrinsic::x86_sse2_cvtsd2ss, 155750}, // __builtin_ia32_cvtsd2ss
+      {Intrinsic::x86_avx512_mask_cvtsd2ss_round, 140000}, // __builtin_ia32_cvtsd2ss_round_mask
+      {Intrinsic::x86_avx512_cvtsi2sd64, 138333}, // __builtin_ia32_cvtsi2sd64
+      {Intrinsic::x86_avx512_cvtsi2ss32, 138359}, // __builtin_ia32_cvtsi2ss32
+      {Intrinsic::x86_avx512_cvtsi2ss64, 138385}, // __builtin_ia32_cvtsi2ss64
+      {Intrinsic::x86_avx512_mask_cvtss2sd_round, 140035}, // __builtin_ia32_cvtss2sd_round_mask
+      {Intrinsic::x86_sse_cvtss2si, 154908}, // __builtin_ia32_cvtss2si
+      {Intrinsic::x86_sse_cvtss2si64, 154932}, // __builtin_ia32_cvtss2si64
+      {Intrinsic::x86_sse2_cvttpd2dq, 155774}, // __builtin_ia32_cvttpd2dq
+      {Intrinsic::x86_avx512_mask_cvttpd2dq_128, 140070}, // __builtin_ia32_cvttpd2dq128_mask
+      {Intrinsic::x86_avx_cvtt_pd2dq_256, 134694}, // __builtin_ia32_cvttpd2dq256
+      {Intrinsic::x86_avx512_mask_cvttpd2dq_512, 140103}, // __builtin_ia32_cvttpd2dq512_mask
+      {Intrinsic::x86_sse_cvttpd2pi, 154958}, // __builtin_ia32_cvttpd2pi
+      {Intrinsic::x86_avx512_mask_cvttpd2qq_128, 140136}, // __builtin_ia32_cvttpd2qq128_mask
+      {Intrinsic::x86_avx512_mask_cvttpd2qq_256, 140169}, // __builtin_ia32_cvttpd2qq256_mask
+      {Intrinsic::x86_avx512_mask_cvttpd2qq_512, 140202}, // __builtin_ia32_cvttpd2qq512_mask
+      {Intrinsic::x86_avx512_mask_cvttpd2udq_128, 140235}, // __builtin_ia32_cvttpd2udq128_mask
+      {Intrinsic::x86_avx512_mask_cvttpd2udq_256, 140269}, // __builtin_ia32_cvttpd2udq256_mask
+      {Intrinsic::x86_avx512_mask_cvttpd2udq_512, 140303}, // __builtin_ia32_cvttpd2udq512_mask
+      {Intrinsic::x86_avx512_mask_cvttpd2uqq_128, 140337}, // __builtin_ia32_cvttpd2uqq128_mask
+      {Intrinsic::x86_avx512_mask_cvttpd2uqq_256, 140371}, // __builtin_ia32_cvttpd2uqq256_mask
+      {Intrinsic::x86_avx512_mask_cvttpd2uqq_512, 140405}, // __builtin_ia32_cvttpd2uqq512_mask
+      {Intrinsic::x86_sse2_cvttps2dq, 155799}, // __builtin_ia32_cvttps2dq
+      {Intrinsic::x86_avx_cvtt_ps2dq_256, 134722}, // __builtin_ia32_cvttps2dq256
+      {Intrinsic::x86_avx512_mask_cvttps2dq_512, 140439}, // __builtin_ia32_cvttps2dq512_mask
+      {Intrinsic::x86_sse_cvttps2pi, 154983}, // __builtin_ia32_cvttps2pi
+      {Intrinsic::x86_avx512_mask_cvttps2qq_128, 140472}, // __builtin_ia32_cvttps2qq128_mask
+      {Intrinsic::x86_avx512_mask_cvttps2qq_256, 140505}, // __builtin_ia32_cvttps2qq256_mask
+      {Intrinsic::x86_avx512_mask_cvttps2qq_512, 140538}, // __builtin_ia32_cvttps2qq512_mask
+      {Intrinsic::x86_avx512_mask_cvttps2udq_128, 140571}, // __builtin_ia32_cvttps2udq128_mask
+      {Intrinsic::x86_avx512_mask_cvttps2udq_256, 140605}, // __builtin_ia32_cvttps2udq256_mask
+      {Intrinsic::x86_avx512_mask_cvttps2udq_512, 140639}, // __builtin_ia32_cvttps2udq512_mask
+      {Intrinsic::x86_avx512_mask_cvttps2uqq_128, 140673}, // __builtin_ia32_cvttps2uqq128_mask
+      {Intrinsic::x86_avx512_mask_cvttps2uqq_256, 140707}, // __builtin_ia32_cvttps2uqq256_mask
+      {Intrinsic::x86_avx512_mask_cvttps2uqq_512, 140741}, // __builtin_ia32_cvttps2uqq512_mask
+      {Intrinsic::x86_sse2_cvttsd2si, 155824}, // __builtin_ia32_cvttsd2si
+      {Intrinsic::x86_sse2_cvttsd2si64, 155849}, // __builtin_ia32_cvttsd2si64
+      {Intrinsic::x86_sse_cvttss2si, 155008}, // __builtin_ia32_cvttss2si
+      {Intrinsic::x86_sse_cvttss2si64, 155033}, // __builtin_ia32_cvttss2si64
+      {Intrinsic::x86_avx512_mask_cvtuqq2ps_128, 140775}, // __builtin_ia32_cvtuqq2ps128_mask
+      {Intrinsic::x86_avx512_cvtusi642sd, 138666}, // __builtin_ia32_cvtusi2sd64
+      {Intrinsic::x86_avx512_cvtusi2ss, 138639}, // __builtin_ia32_cvtusi2ss32
+      {Intrinsic::x86_avx512_cvtusi642ss, 138693}, // __builtin_ia32_cvtusi2ss64
+      {Intrinsic::x86_avx512_dbpsadbw_128, 138720}, // __builtin_ia32_dbpsadbw128
+      {Intrinsic::x86_avx512_dbpsadbw_256, 138747}, // __builtin_ia32_dbpsadbw256
+      {Intrinsic::x86_avx512_dbpsadbw_512, 138774}, // __builtin_ia32_dbpsadbw512
+      {Intrinsic::x86_directstore32, 151630}, // __builtin_ia32_directstore_u32
+      {Intrinsic::x86_directstore64, 151661}, // __builtin_ia32_directstore_u64
+      {Intrinsic::x86_avx512_div_pd_512, 138801}, // __builtin_ia32_divpd512
+      {Intrinsic::x86_avx512_div_ps_512, 138825}, // __builtin_ia32_divps512
+      {Intrinsic::x86_avx512_mask_div_sd_round, 140808}, // __builtin_ia32_divsd_round_mask
+      {Intrinsic::x86_avx512_mask_div_ss_round, 140840}, // __builtin_ia32_divss_round_mask
+      {Intrinsic::x86_avx512bf16_dpbf16ps_128, 151222}, // __builtin_ia32_dpbf16ps_128
+      {Intrinsic::x86_avx512bf16_dpbf16ps_256, 151250}, // __builtin_ia32_dpbf16ps_256
+      {Intrinsic::x86_avx512bf16_dpbf16ps_512, 151278}, // __builtin_ia32_dpbf16ps_512
+      {Intrinsic::x86_sse41_dppd, 157125}, // __builtin_ia32_dppd
+      {Intrinsic::x86_sse41_dpps, 157145}, // __builtin_ia32_dpps
+      {Intrinsic::x86_avx_dp_ps_256, 134750}, // __builtin_ia32_dpps256
+      {Intrinsic::x86_mmx_emms, 152310}, // __builtin_ia32_emms
+      {Intrinsic::x86_enqcmd, 151692}, // __builtin_ia32_enqcmd
+      {Intrinsic::x86_enqcmds, 151714}, // __builtin_ia32_enqcmds
+      {Intrinsic::x86_avx512_exp2_pd, 138849}, // __builtin_ia32_exp2pd_mask
+      {Intrinsic::x86_avx512_exp2_ps, 138876}, // __builtin_ia32_exp2ps_mask
+      {Intrinsic::x86_sse4a_extrq, 157964}, // __builtin_ia32_extrq
+      {Intrinsic::x86_sse4a_extrqi, 157985}, // __builtin_ia32_extrqi
+      {Intrinsic::x86_mmx_femms, 152330}, // __builtin_ia32_femms
+      {Intrinsic::x86_avx512_mask_fixupimm_pd_128, 140872}, // __builtin_ia32_fixupimmpd128_mask
+      {Intrinsic::x86_avx512_maskz_fixupimm_pd_128, 146436}, // __builtin_ia32_fixupimmpd128_maskz
+      {Intrinsic::x86_avx512_mask_fixupimm_pd_256, 140906}, // __builtin_ia32_fixupimmpd256_mask
+      {Intrinsic::x86_avx512_maskz_fixupimm_pd_256, 146471}, // __builtin_ia32_fixupimmpd256_maskz
+      {Intrinsic::x86_avx512_mask_fixupimm_pd_512, 140940}, // __builtin_ia32_fixupimmpd512_mask
+      {Intrinsic::x86_avx512_maskz_fixupimm_pd_512, 146506}, // __builtin_ia32_fixupimmpd512_maskz
+      {Intrinsic::x86_avx512_mask_fixupimm_ps_128, 140974}, // __builtin_ia32_fixupimmps128_mask
+      {Intrinsic::x86_avx512_maskz_fixupimm_ps_128, 146541}, // __builtin_ia32_fixupimmps128_maskz
+      {Intrinsic::x86_avx512_mask_fixupimm_ps_256, 141008}, // __builtin_ia32_fixupimmps256_mask
+      {Intrinsic::x86_avx512_maskz_fixupimm_ps_256, 146576}, // __builtin_ia32_fixupimmps256_maskz
+      {Intrinsic::x86_avx512_mask_fixupimm_ps_512, 141042}, // __builtin_ia32_fixupimmps512_mask
+      {Intrinsic::x86_avx512_maskz_fixupimm_ps_512, 146611}, // __builtin_ia32_fixupimmps512_maskz
+      {Intrinsic::x86_avx512_mask_fixupimm_sd, 141076}, // __builtin_ia32_fixupimmsd_mask
+      {Intrinsic::x86_avx512_maskz_fixupimm_sd, 146646}, // __builtin_ia32_fixupimmsd_maskz
+      {Intrinsic::x86_avx512_mask_fixupimm_ss, 141107}, // __builtin_ia32_fixupimmss_mask
+      {Intrinsic::x86_avx512_maskz_fixupimm_ss, 146678}, // __builtin_ia32_fixupimmss_maskz
+      {Intrinsic::x86_avx512_mask_fpclass_sd, 141138}, // __builtin_ia32_fpclasssd_mask
+      {Intrinsic::x86_avx512_mask_fpclass_ss, 141168}, // __builtin_ia32_fpclassss_mask
+      {Intrinsic::x86_fxrstor, 151973}, // __builtin_ia32_fxrstor
+      {Intrinsic::x86_fxrstor64, 151996}, // __builtin_ia32_fxrstor64
+      {Intrinsic::x86_fxsave, 152021}, // __builtin_ia32_fxsave
+      {Intrinsic::x86_fxsave64, 152043}, // __builtin_ia32_fxsave64
+      {Intrinsic::x86_avx2_gather_d_d, 135932}, // __builtin_ia32_gatherd_d
+      {Intrinsic::x86_avx2_gather_d_d_256, 135957}, // __builtin_ia32_gatherd_d256
+      {Intrinsic::x86_avx2_gather_d_pd, 135985}, // __builtin_ia32_gatherd_pd
+      {Intrinsic::x86_avx2_gather_d_pd_256, 136011}, // __builtin_ia32_gatherd_pd256
+      {Intrinsic::x86_avx2_gather_d_ps, 136040}, // __builtin_ia32_gatherd_ps
+      {Intrinsic::x86_avx2_gather_d_ps_256, 136066}, // __builtin_ia32_gatherd_ps256
+      {Intrinsic::x86_avx2_gather_d_q, 136095}, // __builtin_ia32_gatherd_q
+      {Intrinsic::x86_avx2_gather_d_q_256, 136120}, // __builtin_ia32_gatherd_q256
+      {Intrinsic::x86_avx512_gatherpf_dpd_512, 138903}, // __builtin_ia32_gatherpfdpd
+      {Intrinsic::x86_avx512_gatherpf_dps_512, 138930}, // __builtin_ia32_gatherpfdps
+      {Intrinsic::x86_avx512_gatherpf_qpd_512, 138957}, // __builtin_ia32_gatherpfqpd
+      {Intrinsic::x86_avx512_gatherpf_qps_512, 138984}, // __builtin_ia32_gatherpfqps
+      {Intrinsic::x86_avx2_gather_q_d, 136148}, // __builtin_ia32_gatherq_d
+      {Intrinsic::x86_avx2_gather_q_d_256, 136173}, // __builtin_ia32_gatherq_d256
+      {Intrinsic::x86_avx2_gather_q_pd, 136201}, // __builtin_ia32_gatherq_pd
+      {Intrinsic::x86_avx2_gather_q_pd_256, 136227}, // __builtin_ia32_gatherq_pd256
+      {Intrinsic::x86_avx2_gather_q_ps, 136256}, // __builtin_ia32_gatherq_ps
+      {Intrinsic::x86_avx2_gather_q_ps_256, 136282}, // __builtin_ia32_gatherq_ps256
+      {Intrinsic::x86_avx2_gather_q_q, 136311}, // __builtin_ia32_gatherq_q
+      {Intrinsic::x86_avx2_gather_q_q_256, 136336}, // __builtin_ia32_gatherq_q256
+      {Intrinsic::x86_avx512_mask_getexp_pd_128, 141198}, // __builtin_ia32_getexppd128_mask
+      {Intrinsic::x86_avx512_mask_getexp_pd_256, 141230}, // __builtin_ia32_getexppd256_mask
+      {Intrinsic::x86_avx512_mask_getexp_pd_512, 141262}, // __builtin_ia32_getexppd512_mask
+      {Intrinsic::x86_avx512_mask_getexp_ps_128, 141294}, // __builtin_ia32_getexpps128_mask
+      {Intrinsic::x86_avx512_mask_getexp_ps_256, 141326}, // __builtin_ia32_getexpps256_mask
+      {Intrinsic::x86_avx512_mask_getexp_ps_512, 141358}, // __builtin_ia32_getexpps512_mask
+      {Intrinsic::x86_avx512_mask_getexp_sd, 141390}, // __builtin_ia32_getexpsd128_round_mask
+      {Intrinsic::x86_avx512_mask_getexp_ss, 141428}, // __builtin_ia32_getexpss128_round_mask
+      {Intrinsic::x86_avx512_mask_getmant_pd_128, 141466}, // __builtin_ia32_getmantpd128_mask
+      {Intrinsic::x86_avx512_mask_getmant_pd_256, 141499}, // __builtin_ia32_getmantpd256_mask
+      {Intrinsic::x86_avx512_mask_getmant_pd_512, 141532}, // __builtin_ia32_getmantpd512_mask
+      {Intrinsic::x86_avx512_mask_getmant_ps_128, 141565}, // __builtin_ia32_getmantps128_mask
+      {Intrinsic::x86_avx512_mask_getmant_ps_256, 141598}, // __builtin_ia32_getmantps256_mask
+      {Intrinsic::x86_avx512_mask_getmant_ps_512, 141631}, // __builtin_ia32_getmantps512_mask
+      {Intrinsic::x86_avx512_mask_getmant_sd, 141664}, // __builtin_ia32_getmantsd_round_mask
+      {Intrinsic::x86_avx512_mask_getmant_ss, 141700}, // __builtin_ia32_getmantss_round_mask
+      {Intrinsic::x86_sse3_hadd_pd, 156924}, // __builtin_ia32_haddpd
+      {Intrinsic::x86_avx_hadd_pd_256, 134773}, // __builtin_ia32_haddpd256
+      {Intrinsic::x86_sse3_hadd_ps, 156946}, // __builtin_ia32_haddps
+      {Intrinsic::x86_avx_hadd_ps_256, 134798}, // __builtin_ia32_haddps256
+      {Intrinsic::x86_sse3_hsub_pd, 156968}, // __builtin_ia32_hsubpd
+      {Intrinsic::x86_avx_hsub_pd_256, 134823}, // __builtin_ia32_hsubpd256
+      {Intrinsic::x86_sse3_hsub_ps, 156990}, // __builtin_ia32_hsubps
+      {Intrinsic::x86_avx_hsub_ps_256, 134848}, // __builtin_ia32_hsubps256
+      {Intrinsic::x86_incsspd, 152067}, // __builtin_ia32_incsspd
+      {Intrinsic::x86_incsspq, 152090}, // __builtin_ia32_incsspq
+      {Intrinsic::x86_sse41_insertps, 157165}, // __builtin_ia32_insertps128
+      {Intrinsic::x86_sse4a_insertq, 158007}, // __builtin_ia32_insertq
+      {Intrinsic::x86_sse4a_insertqi, 158030}, // __builtin_ia32_insertqi
+      {Intrinsic::x86_invpcid, 152113}, // __builtin_ia32_invpcid
+      {Intrinsic::x86_sse3_ldu_dq, 157012}, // __builtin_ia32_lddqu
+      {Intrinsic::x86_avx_ldu_dq_256, 134873}, // __builtin_ia32_lddqu256
+      {Intrinsic::x86_sse2_lfence, 155876}, // __builtin_ia32_lfence
+      {Intrinsic::x86_llwpcb, 152167}, // __builtin_ia32_llwpcb
+      {Intrinsic::x86_loadiwkey, 152189}, // __builtin_ia32_loadiwkey
+      {Intrinsic::x86_lwpins32, 152214}, // __builtin_ia32_lwpins32
+      {Intrinsic::x86_lwpins64, 152238}, // __builtin_ia32_lwpins64
+      {Intrinsic::x86_lwpval32, 152262}, // __builtin_ia32_lwpval32
+      {Intrinsic::x86_lwpval64, 152286}, // __builtin_ia32_lwpval64
+      {Intrinsic::x86_avx2_maskload_d, 136364}, // __builtin_ia32_maskloadd
+      {Intrinsic::x86_avx2_maskload_d_256, 136389}, // __builtin_ia32_maskloadd256
+      {Intrinsic::x86_avx_maskload_pd, 134897}, // __builtin_ia32_maskloadpd
+      {Intrinsic::x86_avx_maskload_pd_256, 134923}, // __builtin_ia32_maskloadpd256
+      {Intrinsic::x86_avx_maskload_ps, 134952}, // __builtin_ia32_maskloadps
+      {Intrinsic::x86_avx_maskload_ps_256, 134978}, // __builtin_ia32_maskloadps256
+      {Intrinsic::x86_avx2_maskload_q, 136417}, // __builtin_ia32_maskloadq
+      {Intrinsic::x86_avx2_maskload_q_256, 136442}, // __builtin_ia32_maskloadq256
+      {Intrinsic::x86_sse2_maskmov_dqu, 155898}, // __builtin_ia32_maskmovdqu
+      {Intrinsic::x86_mmx_maskmovq, 152351}, // __builtin_ia32_maskmovq
+      {Intrinsic::x86_avx2_maskstore_d, 136470}, // __builtin_ia32_maskstored
+      {Intrinsic::x86_avx2_maskstore_d_256, 136496}, // __builtin_ia32_maskstored256
+      {Intrinsic::x86_avx_maskstore_pd, 135007}, // __builtin_ia32_maskstorepd
+      {Intrinsic::x86_avx_maskstore_pd_256, 135034}, // __builtin_ia32_maskstorepd256
+      {Intrinsic::x86_avx_maskstore_ps, 135064}, // __builtin_ia32_maskstoreps
+      {Intrinsic::x86_avx_maskstore_ps_256, 135091}, // __builtin_ia32_maskstoreps256
+      {Intrinsic::x86_avx2_maskstore_q, 136525}, // __builtin_ia32_maskstoreq
+      {Intrinsic::x86_avx2_maskstore_q_256, 136551}, // __builtin_ia32_maskstoreq256
+      {Intrinsic::x86_sse2_max_pd, 155924}, // __builtin_ia32_maxpd
+      {Intrinsic::x86_avx_max_pd_256, 135121}, // __builtin_ia32_maxpd256
+      {Intrinsic::x86_avx512_max_pd_512, 146710}, // __builtin_ia32_maxpd512
+      {Intrinsic::x86_sse_max_ps, 155060}, // __builtin_ia32_maxps
+      {Intrinsic::x86_avx_max_ps_256, 135145}, // __builtin_ia32_maxps256
+      {Intrinsic::x86_avx512_max_ps_512, 146734}, // __builtin_ia32_maxps512
+      {Intrinsic::x86_sse2_max_sd, 155945}, // __builtin_ia32_maxsd
+      {Intrinsic::x86_avx512_mask_max_sd_round, 141736}, // __builtin_ia32_maxsd_round_mask
+      {Intrinsic::x86_sse_max_ss, 155081}, // __builtin_ia32_maxss
+      {Intrinsic::x86_avx512_mask_max_ss_round, 141768}, // __builtin_ia32_maxss_round_mask
+      {Intrinsic::x86_sse2_mfence, 155966}, // __builtin_ia32_mfence
+      {Intrinsic::x86_sse2_min_pd, 155988}, // __builtin_ia32_minpd
+      {Intrinsic::x86_avx_min_pd_256, 135169}, // __builtin_ia32_minpd256
+      {Intrinsic::x86_avx512_min_pd_512, 146758}, // __builtin_ia32_minpd512
+      {Intrinsic::x86_sse_min_ps, 155102}, // __builtin_ia32_minps
+      {Intrinsic::x86_avx_min_ps_256, 135193}, // __builtin_ia32_minps256
+      {Intrinsic::x86_avx512_min_ps_512, 146782}, // __builtin_ia32_minps512
+      {Intrinsic::x86_sse2_min_sd, 156009}, // __builtin_ia32_minsd
+      {Intrinsic::x86_avx512_mask_min_sd_round, 141800}, // __builtin_ia32_minsd_round_mask
+      {Intrinsic::x86_sse_min_ss, 155123}, // __builtin_ia32_minss
+      {Intrinsic::x86_avx512_mask_min_ss_round, 141832}, // __builtin_ia32_minss_round_mask
+      {Intrinsic::x86_sse3_monitor, 157033}, // __builtin_ia32_monitor
+      {Intrinsic::x86_monitorx, 153897}, // __builtin_ia32_monitorx
+      {Intrinsic::x86_movdir64b, 153921}, // __builtin_ia32_movdir64b
+      {Intrinsic::x86_sse2_movmsk_pd, 156030}, // __builtin_ia32_movmskpd
+      {Intrinsic::x86_avx_movmsk_pd_256, 135217}, // __builtin_ia32_movmskpd256
+      {Intrinsic::x86_sse_movmsk_ps, 155144}, // __builtin_ia32_movmskps
+      {Intrinsic::x86_avx_movmsk_ps_256, 135244}, // __builtin_ia32_movmskps256
+      {Intrinsic::x86_mmx_movnt_dq, 152375}, // __builtin_ia32_movntq
+      {Intrinsic::x86_sse41_mpsadbw, 157192}, // __builtin_ia32_mpsadbw128
+      {Intrinsic::x86_avx2_mpsadbw, 136580}, // __builtin_ia32_mpsadbw256
+      {Intrinsic::x86_avx512_mul_pd_512, 146806}, // __builtin_ia32_mulpd512
+      {Intrinsic::x86_avx512_mul_ps_512, 146830}, // __builtin_ia32_mulps512
+      {Intrinsic::x86_avx512_mask_mul_sd_round, 141864}, // __builtin_ia32_mulsd_round_mask
+      {Intrinsic::x86_avx512_mask_mul_ss_round, 141896}, // __builtin_ia32_mulss_round_mask
+      {Intrinsic::x86_sse3_mwait, 157056}, // __builtin_ia32_mwait
+      {Intrinsic::x86_mwaitx, 153946}, // __builtin_ia32_mwaitx
+      {Intrinsic::x86_ssse3_pabs_b, 158054}, // __builtin_ia32_pabsb
+      {Intrinsic::x86_ssse3_pabs_d, 158075}, // __builtin_ia32_pabsd
+      {Intrinsic::x86_ssse3_pabs_w, 158096}, // __builtin_ia32_pabsw
+      {Intrinsic::x86_mmx_packssdw, 152397}, // __builtin_ia32_packssdw
+      {Intrinsic::x86_sse2_packssdw_128, 156054}, // __builtin_ia32_packssdw128
+      {Intrinsic::x86_avx2_packssdw, 136606}, // __builtin_ia32_packssdw256
+      {Intrinsic::x86_avx512_packssdw_512, 146854}, // __builtin_ia32_packssdw512
+      {Intrinsic::x86_mmx_packsswb, 152421}, // __builtin_ia32_packsswb
+      {Intrinsic::x86_sse2_packsswb_128, 156081}, // __builtin_ia32_packsswb128
+      {Intrinsic::x86_avx2_packsswb, 136633}, // __builtin_ia32_packsswb256
+      {Intrinsic::x86_avx512_packsswb_512, 146881}, // __builtin_ia32_packsswb512
+      {Intrinsic::x86_sse41_packusdw, 157218}, // __builtin_ia32_packusdw128
+      {Intrinsic::x86_avx2_packusdw, 136660}, // __builtin_ia32_packusdw256
+      {Intrinsic::x86_avx512_packusdw_512, 146908}, // __builtin_ia32_packusdw512
+      {Intrinsic::x86_mmx_packuswb, 152445}, // __builtin_ia32_packuswb
+      {Intrinsic::x86_sse2_packuswb_128, 156108}, // __builtin_ia32_packuswb128
+      {Intrinsic::x86_avx2_packuswb, 136687}, // __builtin_ia32_packuswb256
+      {Intrinsic::x86_avx512_packuswb_512, 146935}, // __builtin_ia32_packuswb512
+      {Intrinsic::x86_mmx_padd_b, 152469}, // __builtin_ia32_paddb
+      {Intrinsic::x86_mmx_padd_d, 152490}, // __builtin_ia32_paddd
+      {Intrinsic::x86_mmx_padd_q, 152511}, // __builtin_ia32_paddq
+      {Intrinsic::x86_mmx_padds_b, 152553}, // __builtin_ia32_paddsb
+      {Intrinsic::x86_mmx_padds_w, 152575}, // __builtin_ia32_paddsw
+      {Intrinsic::x86_mmx_paddus_b, 152597}, // __builtin_ia32_paddusb
+      {Intrinsic::x86_mmx_paddus_w, 152620}, // __builtin_ia32_paddusw
+      {Intrinsic::x86_mmx_padd_w, 152532}, // __builtin_ia32_paddw
+      {Intrinsic::x86_mmx_palignr_b, 152643}, // __builtin_ia32_palignr
+      {Intrinsic::x86_mmx_pand, 152666}, // __builtin_ia32_pand
+      {Intrinsic::x86_mmx_pandn, 152686}, // __builtin_ia32_pandn
+      {Intrinsic::x86_sse2_pause, 156135}, // __builtin_ia32_pause
+      {Intrinsic::x86_mmx_pavg_b, 152707}, // __builtin_ia32_pavgb
+      {Intrinsic::x86_sse2_pavg_b, 156156}, // __builtin_ia32_pavgb128
+      {Intrinsic::x86_avx2_pavg_b, 136714}, // __builtin_ia32_pavgb256
+      {Intrinsic::x86_avx512_pavg_b_512, 146962}, // __builtin_ia32_pavgb512
+      {Intrinsic::x86_3dnow_pavgusb, 133614}, // __builtin_ia32_pavgusb
+      {Intrinsic::x86_mmx_pavg_w, 152728}, // __builtin_ia32_pavgw
+      {Intrinsic::x86_sse2_pavg_w, 156180}, // __builtin_ia32_pavgw128
+      {Intrinsic::x86_avx2_pavg_w, 136738}, // __builtin_ia32_pavgw256
+      {Intrinsic::x86_avx512_pavg_w_512, 146986}, // __builtin_ia32_pavgw512
+      {Intrinsic::x86_sse41_pblendvb, 157245}, // __builtin_ia32_pblendvb128
+      {Intrinsic::x86_avx2_pblendvb, 136762}, // __builtin_ia32_pblendvb256
+      {Intrinsic::x86_pclmulqdq, 153968}, // __builtin_ia32_pclmulqdq128
+      {Intrinsic::x86_pclmulqdq_256, 153996}, // __builtin_ia32_pclmulqdq256
+      {Intrinsic::x86_pclmulqdq_512, 154024}, // __builtin_ia32_pclmulqdq512
+      {Intrinsic::x86_mmx_pcmpeq_b, 152749}, // __builtin_ia32_pcmpeqb
+      {Intrinsic::x86_mmx_pcmpeq_d, 152772}, // __builtin_ia32_pcmpeqd
+      {Intrinsic::x86_mmx_pcmpeq_w, 152795}, // __builtin_ia32_pcmpeqw
+      {Intrinsic::x86_sse42_pcmpestri128, 157562}, // __builtin_ia32_pcmpestri128
+      {Intrinsic::x86_sse42_pcmpestria128, 157590}, // __builtin_ia32_pcmpestria128
+      {Intrinsic::x86_sse42_pcmpestric128, 157619}, // __builtin_ia32_pcmpestric128
+      {Intrinsic::x86_sse42_pcmpestrio128, 157648}, // __builtin_ia32_pcmpestrio128
+      {Intrinsic::x86_sse42_pcmpestris128, 157677}, // __builtin_ia32_pcmpestris128
+      {Intrinsic::x86_sse42_pcmpestriz128, 157706}, // __builtin_ia32_pcmpestriz128
+      {Intrinsic::x86_sse42_pcmpestrm128, 157735}, // __builtin_ia32_pcmpestrm128
+      {Intrinsic::x86_mmx_pcmpgt_b, 152818}, // __builtin_ia32_pcmpgtb
+      {Intrinsic::x86_mmx_pcmpgt_d, 152841}, // __builtin_ia32_pcmpgtd
+      {Intrinsic::x86_mmx_pcmpgt_w, 152864}, // __builtin_ia32_pcmpgtw
+      {Intrinsic::x86_sse42_pcmpistri128, 157763}, // __builtin_ia32_pcmpistri128
+      {Intrinsic::x86_sse42_pcmpistria128, 157791}, // __builtin_ia32_pcmpistria128
+      {Intrinsic::x86_sse42_pcmpistric128, 157820}, // __builtin_ia32_pcmpistric128
+      {Intrinsic::x86_sse42_pcmpistrio128, 157849}, // __builtin_ia32_pcmpistrio128
+      {Intrinsic::x86_sse42_pcmpistris128, 157878}, // __builtin_ia32_pcmpistris128
+      {Intrinsic::x86_sse42_pcmpistriz128, 157907}, // __builtin_ia32_pcmpistriz128
+      {Intrinsic::x86_sse42_pcmpistrm128, 157936}, // __builtin_ia32_pcmpistrm128
+      {Intrinsic::x86_bmi_pdep_64, 151425}, // __builtin_ia32_pdep_di
+      {Intrinsic::x86_bmi_pdep_32, 151402}, // __builtin_ia32_pdep_si
+      {Intrinsic::x86_avx512_permvar_df_256, 147010}, // __builtin_ia32_permvardf256
+      {Intrinsic::x86_avx512_permvar_df_512, 147038}, // __builtin_ia32_permvardf512
+      {Intrinsic::x86_avx512_permvar_di_256, 147066}, // __builtin_ia32_permvardi256
+      {Intrinsic::x86_avx512_permvar_di_512, 147094}, // __builtin_ia32_permvardi512
+      {Intrinsic::x86_avx512_permvar_hi_128, 147122}, // __builtin_ia32_permvarhi128
+      {Intrinsic::x86_avx512_permvar_hi_256, 147150}, // __builtin_ia32_permvarhi256
+      {Intrinsic::x86_avx512_permvar_hi_512, 147178}, // __builtin_ia32_permvarhi512
+      {Intrinsic::x86_avx512_permvar_qi_128, 147206}, // __builtin_ia32_permvarqi128
+      {Intrinsic::x86_avx512_permvar_qi_256, 147234}, // __builtin_ia32_permvarqi256
+      {Intrinsic::x86_avx512_permvar_qi_512, 147262}, // __builtin_ia32_permvarqi512
+      {Intrinsic::x86_avx2_permps, 136817}, // __builtin_ia32_permvarsf256
+      {Intrinsic::x86_avx512_permvar_sf_512, 147290}, // __builtin_ia32_permvarsf512
+      {Intrinsic::x86_avx2_permd, 136789}, // __builtin_ia32_permvarsi256
+      {Intrinsic::x86_avx512_permvar_si_512, 147318}, // __builtin_ia32_permvarsi512
+      {Intrinsic::x86_bmi_pext_64, 151471}, // __builtin_ia32_pext_di
+      {Intrinsic::x86_bmi_pext_32, 151448}, // __builtin_ia32_pext_si
+      {Intrinsic::x86_3dnow_pf2id, 133637}, // __builtin_ia32_pf2id
+      {Intrinsic::x86_3dnowa_pf2iw, 134035}, // __builtin_ia32_pf2iw
+      {Intrinsic::x86_3dnow_pfacc, 133658}, // __builtin_ia32_pfacc
+      {Intrinsic::x86_3dnow_pfadd, 133679}, // __builtin_ia32_pfadd
+      {Intrinsic::x86_3dnow_pfcmpeq, 133700}, // __builtin_ia32_pfcmpeq
+      {Intrinsic::x86_3dnow_pfcmpge, 133723}, // __builtin_ia32_pfcmpge
+      {Intrinsic::x86_3dnow_pfcmpgt, 133746}, // __builtin_ia32_pfcmpgt
+      {Intrinsic::x86_3dnow_pfmax, 133769}, // __builtin_ia32_pfmax
+      {Intrinsic::x86_3dnow_pfmin, 133790}, // __builtin_ia32_pfmin
+      {Intrinsic::x86_3dnow_pfmul, 133811}, // __builtin_ia32_pfmul
+      {Intrinsic::x86_3dnowa_pfnacc, 134056}, // __builtin_ia32_pfnacc
+      {Intrinsic::x86_3dnowa_pfpnacc, 134078}, // __builtin_ia32_pfpnacc
+      {Intrinsic::x86_3dnow_pfrcp, 133832}, // __builtin_ia32_pfrcp
+      {Intrinsic::x86_3dnow_pfrcpit1, 133853}, // __builtin_ia32_pfrcpit1
+      {Intrinsic::x86_3dnow_pfrcpit2, 133877}, // __builtin_ia32_pfrcpit2
+      {Intrinsic::x86_3dnow_pfrsqit1, 133901}, // __builtin_ia32_pfrsqit1
+      {Intrinsic::x86_3dnow_pfrsqrt, 133925}, // __builtin_ia32_pfrsqrt
+      {Intrinsic::x86_3dnow_pfsub, 133948}, // __builtin_ia32_pfsub
+      {Intrinsic::x86_3dnow_pfsubr, 133969}, // __builtin_ia32_pfsubr
+      {Intrinsic::x86_ssse3_phadd_d, 158117}, // __builtin_ia32_phaddd
+      {Intrinsic::x86_ssse3_phadd_d_128, 158139}, // __builtin_ia32_phaddd128
+      {Intrinsic::x86_avx2_phadd_d, 136845}, // __builtin_ia32_phaddd256
+      {Intrinsic::x86_ssse3_phadd_sw, 158164}, // __builtin_ia32_phaddsw
+      {Intrinsic::x86_ssse3_phadd_sw_128, 158187}, // __builtin_ia32_phaddsw128
+      {Intrinsic::x86_avx2_phadd_sw, 136870}, // __builtin_ia32_phaddsw256
+      {Intrinsic::x86_ssse3_phadd_w, 158213}, // __builtin_ia32_phaddw
+      {Intrinsic::x86_ssse3_phadd_w_128, 158235}, // __builtin_ia32_phaddw128
+      {Intrinsic::x86_avx2_phadd_w, 136896}, // __builtin_ia32_phaddw256
+      {Intrinsic::x86_sse41_phminposuw, 157272}, // __builtin_ia32_phminposuw128
+      {Intrinsic::x86_ssse3_phsub_d, 158260}, // __builtin_ia32_phsubd
+      {Intrinsic::x86_ssse3_phsub_d_128, 158282}, // __builtin_ia32_phsubd128
+      {Intrinsic::x86_avx2_phsub_d, 136921}, // __builtin_ia32_phsubd256
+      {Intrinsic::x86_ssse3_phsub_sw, 158307}, // __builtin_ia32_phsubsw
+      {Intrinsic::x86_ssse3_phsub_sw_128, 158330}, // __builtin_ia32_phsubsw128
+      {Intrinsic::x86_avx2_phsub_sw, 136946}, // __builtin_ia32_phsubsw256
+      {Intrinsic::x86_ssse3_phsub_w, 158356}, // __builtin_ia32_phsubw
+      {Intrinsic::x86_ssse3_phsub_w_128, 158378}, // __builtin_ia32_phsubw128
+      {Intrinsic::x86_avx2_phsub_w, 136972}, // __builtin_ia32_phsubw256
+      {Intrinsic::x86_3dnow_pi2fd, 133991}, // __builtin_ia32_pi2fd
+      {Intrinsic::x86_3dnowa_pi2fw, 134101}, // __builtin_ia32_pi2fw
+      {Intrinsic::x86_ssse3_pmadd_ub_sw, 158403}, // __builtin_ia32_pmaddubsw
+      {Intrinsic::x86_ssse3_pmadd_ub_sw_128, 158428}, // __builtin_ia32_pmaddubsw128
+      {Intrinsic::x86_avx2_pmadd_ub_sw, 136997}, // __builtin_ia32_pmaddubsw256
+      {Intrinsic::x86_avx512_pmaddubs_w_512, 147346}, // __builtin_ia32_pmaddubsw512
+      {Intrinsic::x86_mmx_pmadd_wd, 152943}, // __builtin_ia32_pmaddwd
+      {Intrinsic::x86_sse2_pmadd_wd, 156204}, // __builtin_ia32_pmaddwd128
+      {Intrinsic::x86_avx2_pmadd_wd, 137025}, // __builtin_ia32_pmaddwd256
+      {Intrinsic::x86_avx512_pmaddw_d_512, 147374}, // __builtin_ia32_pmaddwd512
+      {Intrinsic::x86_mmx_pmaxs_w, 152966}, // __builtin_ia32_pmaxsw
+      {Intrinsic::x86_mmx_pmaxu_b, 152988}, // __builtin_ia32_pmaxub
+      {Intrinsic::x86_mmx_pmins_w, 153010}, // __builtin_ia32_pminsw
+      {Intrinsic::x86_mmx_pminu_b, 153032}, // __builtin_ia32_pminub
+      {Intrinsic::x86_avx512_mask_pmov_db_128, 141928}, // __builtin_ia32_pmovdb128_mask
+      {Intrinsic::x86_avx512_mask_pmov_db_mem_128, 141988}, // __builtin_ia32_pmovdb128mem_mask
+      {Intrinsic::x86_avx512_mask_pmov_db_256, 141958}, // __builtin_ia32_pmovdb256_mask
+      {Intrinsic::x86_avx512_mask_pmov_db_mem_256, 142021}, // __builtin_ia32_pmovdb256mem_mask
+      {Intrinsic::x86_avx512_mask_pmov_db_mem_512, 142054}, // __builtin_ia32_pmovdb512mem_mask
+      {Intrinsic::x86_avx512_mask_pmov_dw_128, 142087}, // __builtin_ia32_pmovdw128_mask
+      {Intrinsic::x86_avx512_mask_pmov_dw_mem_128, 142147}, // __builtin_ia32_pmovdw128mem_mask
+      {Intrinsic::x86_avx512_mask_pmov_dw_256, 142117}, // __builtin_ia32_pmovdw256_mask
+      {Intrinsic::x86_avx512_mask_pmov_dw_mem_256, 142180}, // __builtin_ia32_pmovdw256mem_mask
+      {Intrinsic::x86_avx512_mask_pmov_dw_mem_512, 142213}, // __builtin_ia32_pmovdw512mem_mask
+      {Intrinsic::x86_mmx_pmovmskb, 153054}, // __builtin_ia32_pmovmskb
+      {Intrinsic::x86_sse2_pmovmskb_128, 156230}, // __builtin_ia32_pmovmskb128
+      {Intrinsic::x86_avx2_pmovmskb, 137051}, // __builtin_ia32_pmovmskb256
+      {Intrinsic::x86_avx512_mask_pmov_qb_128, 142246}, // __builtin_ia32_pmovqb128_mask
+      {Intrinsic::x86_avx512_mask_pmov_qb_mem_128, 142336}, // __builtin_ia32_pmovqb128mem_mask
+      {Intrinsic::x86_avx512_mask_pmov_qb_256, 142276}, // __builtin_ia32_pmovqb256_mask
+      {Intrinsic::x86_avx512_mask_pmov_qb_mem_256, 142369}, // __builtin_ia32_pmovqb256mem_mask
+      {Intrinsic::x86_avx512_mask_pmov_qb_512, 142306}, // __builtin_ia32_pmovqb512_mask
+      {Intrinsic::x86_avx512_mask_pmov_qb_mem_512, 142402}, // __builtin_ia32_pmovqb512mem_mask
+      {Intrinsic::x86_avx512_mask_pmov_qd_128, 142435}, // __builtin_ia32_pmovqd128_mask
+      {Intrinsic::x86_avx512_mask_pmov_qd_mem_128, 142465}, // __builtin_ia32_pmovqd128mem_mask
+      {Intrinsic::x86_avx512_mask_pmov_qd_mem_256, 142498}, // __builtin_ia32_pmovqd256mem_mask
+      {Intrinsic::x86_avx512_mask_pmov_qd_mem_512, 142531}, // __builtin_ia32_pmovqd512mem_mask
+      {Intrinsic::x86_avx512_mask_pmov_qw_128, 142564}, // __builtin_ia32_pmovqw128_mask
+      {Intrinsic::x86_avx512_mask_pmov_qw_mem_128, 142624}, // __builtin_ia32_pmovqw128mem_mask
+      {Intrinsic::x86_avx512_mask_pmov_qw_256, 142594}, // __builtin_ia32_pmovqw256_mask
+      {Intrinsic::x86_avx512_mask_pmov_qw_mem_256, 142657}, // __builtin_ia32_pmovqw256mem_mask
+      {Intrinsic::x86_avx512_mask_pmov_qw_mem_512, 142690}, // __builtin_ia32_pmovqw512mem_mask
+      {Intrinsic::x86_avx512_mask_pmovs_db_128, 142852}, // __builtin_ia32_pmovsdb128_mask
+      {Intrinsic::x86_avx512_mask_pmovs_db_mem_128, 142945}, // __builtin_ia32_pmovsdb128mem_mask
+      {Intrinsic::x86_avx512_mask_pmovs_db_256, 142883}, // __builtin_ia32_pmovsdb256_mask
+      {Intrinsic::x86_avx512_mask_pmovs_db_mem_256, 142979}, // __builtin_ia32_pmovsdb256mem_mask
+      {Intrinsic::x86_avx512_mask_pmovs_db_512, 142914}, // __builtin_ia32_pmovsdb512_mask
+      {Intrinsic::x86_avx512_mask_pmovs_db_mem_512, 143013}, // __builtin_ia32_pmovsdb512mem_mask
+      {Intrinsic::x86_avx512_mask_pmovs_dw_128, 143047}, // __builtin_ia32_pmovsdw128_mask
+      {Intrinsic::x86_avx512_mask_pmovs_dw_mem_128, 143140}, // __builtin_ia32_pmovsdw128mem_mask
+      {Intrinsic::x86_avx512_mask_pmovs_dw_256, 143078}, // __builtin_ia32_pmovsdw256_mask
+      {Intrinsic::x86_avx512_mask_pmovs_dw_mem_256, 143174}, // __builtin_ia32_pmovsdw256mem_mask
+      {Intrinsic::x86_avx512_mask_pmovs_dw_512, 143109}, // __builtin_ia32_pmovsdw512_mask
+      {Intrinsic::x86_avx512_mask_pmovs_dw_mem_512, 143208}, // __builtin_ia32_pmovsdw512mem_mask
+      {Intrinsic::x86_avx512_mask_pmovs_qb_128, 143242}, // __builtin_ia32_pmovsqb128_mask
+      {Intrinsic::x86_avx512_mask_pmovs_qb_mem_128, 143335}, // __builtin_ia32_pmovsqb128mem_mask
+      {Intrinsic::x86_avx512_mask_pmovs_qb_256, 143273}, // __builtin_ia32_pmovsqb256_mask
+      {Intrinsic::x86_avx512_mask_pmovs_qb_mem_256, 143369}, // __builtin_ia32_pmovsqb256mem_mask
+      {Intrinsic::x86_avx512_mask_pmovs_qb_512, 143304}, // __builtin_ia32_pmovsqb512_mask
+      {Intrinsic::x86_avx512_mask_pmovs_qb_mem_512, 143403}, // __builtin_ia32_pmovsqb512mem_mask
+      {Intrinsic::x86_avx512_mask_pmovs_qd_128, 143437}, // __builtin_ia32_pmovsqd128_mask
+      {Intrinsic::x86_avx512_mask_pmovs_qd_mem_128, 143530}, // __builtin_ia32_pmovsqd128mem_mask
+      {Intrinsic::x86_avx512_mask_pmovs_qd_256, 143468}, // __builtin_ia32_pmovsqd256_mask
+      {Intrinsic::x86_avx512_mask_pmovs_qd_mem_256, 143564}, // __builtin_ia32_pmovsqd256mem_mask
+      {Intrinsic::x86_avx512_mask_pmovs_qd_512, 143499}, // __builtin_ia32_pmovsqd512_mask
+      {Intrinsic::x86_avx512_mask_pmovs_qd_mem_512, 143598}, // __builtin_ia32_pmovsqd512mem_mask
+      {Intrinsic::x86_avx512_mask_pmovs_qw_128, 143632}, // __builtin_ia32_pmovsqw128_mask
+      {Intrinsic::x86_avx512_mask_pmovs_qw_mem_128, 143725}, // __builtin_ia32_pmovsqw128mem_mask
+      {Intrinsic::x86_avx512_mask_pmovs_qw_256, 143663}, // __builtin_ia32_pmovsqw256_mask
+      {Intrinsic::x86_avx512_mask_pmovs_qw_mem_256, 143759}, // __builtin_ia32_pmovsqw256mem_mask
+      {Intrinsic::x86_avx512_mask_pmovs_qw_512, 143694}, // __builtin_ia32_pmovsqw512_mask
+      {Intrinsic::x86_avx512_mask_pmovs_qw_mem_512, 143793}, // __builtin_ia32_pmovsqw512mem_mask
+      {Intrinsic::x86_avx512_mask_pmovs_wb_128, 143827}, // __builtin_ia32_pmovswb128_mask
+      {Intrinsic::x86_avx512_mask_pmovs_wb_mem_128, 143920}, // __builtin_ia32_pmovswb128mem_mask
+      {Intrinsic::x86_avx512_mask_pmovs_wb_256, 143858}, // __builtin_ia32_pmovswb256_mask
+      {Intrinsic::x86_avx512_mask_pmovs_wb_mem_256, 143954}, // __builtin_ia32_pmovswb256mem_mask
+      {Intrinsic::x86_avx512_mask_pmovs_wb_512, 143889}, // __builtin_ia32_pmovswb512_mask
+      {Intrinsic::x86_avx512_mask_pmovs_wb_mem_512, 143988}, // __builtin_ia32_pmovswb512mem_mask
+      {Intrinsic::x86_avx512_mask_pmovus_db_128, 144022}, // __builtin_ia32_pmovusdb128_mask
+      {Intrinsic::x86_avx512_mask_pmovus_db_mem_128, 144118}, // __builtin_ia32_pmovusdb128mem_mask
+      {Intrinsic::x86_avx512_mask_pmovus_db_256, 144054}, // __builtin_ia32_pmovusdb256_mask
+      {Intrinsic::x86_avx512_mask_pmovus_db_mem_256, 144153}, // __builtin_ia32_pmovusdb256mem_mask
+      {Intrinsic::x86_avx512_mask_pmovus_db_512, 144086}, // __builtin_ia32_pmovusdb512_mask
+      {Intrinsic::x86_avx512_mask_pmovus_db_mem_512, 144188}, // __builtin_ia32_pmovusdb512mem_mask
+      {Intrinsic::x86_avx512_mask_pmovus_dw_128, 144223}, // __builtin_ia32_pmovusdw128_mask
+      {Intrinsic::x86_avx512_mask_pmovus_dw_mem_128, 144319}, // __builtin_ia32_pmovusdw128mem_mask
+      {Intrinsic::x86_avx512_mask_pmovus_dw_256, 144255}, // __builtin_ia32_pmovusdw256_mask
+      {Intrinsic::x86_avx512_mask_pmovus_dw_mem_256, 144354}, // __builtin_ia32_pmovusdw256mem_mask
+      {Intrinsic::x86_avx512_mask_pmovus_dw_512, 144287}, // __builtin_ia32_pmovusdw512_mask
+      {Intrinsic::x86_avx512_mask_pmovus_dw_mem_512, 144389}, // __builtin_ia32_pmovusdw512mem_mask
+      {Intrinsic::x86_avx512_mask_pmovus_qb_128, 144424}, // __builtin_ia32_pmovusqb128_mask
+      {Intrinsic::x86_avx512_mask_pmovus_qb_mem_128, 144520}, // __builtin_ia32_pmovusqb128mem_mask
+      {Intrinsic::x86_avx512_mask_pmovus_qb_256, 144456}, // __builtin_ia32_pmovusqb256_mask
+      {Intrinsic::x86_avx512_mask_pmovus_qb_mem_256, 144555}, // __builtin_ia32_pmovusqb256mem_mask
+      {Intrinsic::x86_avx512_mask_pmovus_qb_512, 144488}, // __builtin_ia32_pmovusqb512_mask
+      {Intrinsic::x86_avx512_mask_pmovus_qb_mem_512, 144590}, // __builtin_ia32_pmovusqb512mem_mask
+      {Intrinsic::x86_avx512_mask_pmovus_qd_128, 144625}, // __builtin_ia32_pmovusqd128_mask
+      {Intrinsic::x86_avx512_mask_pmovus_qd_mem_128, 144721}, // __builtin_ia32_pmovusqd128mem_mask
+      {Intrinsic::x86_avx512_mask_pmovus_qd_256, 144657}, // __builtin_ia32_pmovusqd256_mask
+      {Intrinsic::x86_avx512_mask_pmovus_qd_mem_256, 144756}, // __builtin_ia32_pmovusqd256mem_mask
+      {Intrinsic::x86_avx512_mask_pmovus_qd_512, 144689}, // __builtin_ia32_pmovusqd512_mask
+      {Intrinsic::x86_avx512_mask_pmovus_qd_mem_512, 144791}, // __builtin_ia32_pmovusqd512mem_mask
+      {Intrinsic::x86_avx512_mask_pmovus_qw_128, 144826}, // __builtin_ia32_pmovusqw128_mask
+      {Intrinsic::x86_avx512_mask_pmovus_qw_mem_128, 144922}, // __builtin_ia32_pmovusqw128mem_mask
+      {Intrinsic::x86_avx512_mask_pmovus_qw_256, 144858}, // __builtin_ia32_pmovusqw256_mask
+      {Intrinsic::x86_avx512_mask_pmovus_qw_mem_256, 144957}, // __builtin_ia32_pmovusqw256mem_mask
+      {Intrinsic::x86_avx512_mask_pmovus_qw_512, 144890}, // __builtin_ia32_pmovusqw512_mask
+      {Intrinsic::x86_avx512_mask_pmovus_qw_mem_512, 144992}, // __builtin_ia32_pmovusqw512mem_mask
+      {Intrinsic::x86_avx512_mask_pmovus_wb_128, 145027}, // __builtin_ia32_pmovuswb128_mask
+      {Intrinsic::x86_avx512_mask_pmovus_wb_mem_128, 145123}, // __builtin_ia32_pmovuswb128mem_mask
+      {Intrinsic::x86_avx512_mask_pmovus_wb_256, 145059}, // __builtin_ia32_pmovuswb256_mask
+      {Intrinsic::x86_avx512_mask_pmovus_wb_mem_256, 145158}, // __builtin_ia32_pmovuswb256mem_mask
+      {Intrinsic::x86_avx512_mask_pmovus_wb_512, 145091}, // __builtin_ia32_pmovuswb512_mask
+      {Intrinsic::x86_avx512_mask_pmovus_wb_mem_512, 145193}, // __builtin_ia32_pmovuswb512mem_mask
+      {Intrinsic::x86_avx512_mask_pmov_wb_128, 142723}, // __builtin_ia32_pmovwb128_mask
+      {Intrinsic::x86_avx512_mask_pmov_wb_mem_128, 142753}, // __builtin_ia32_pmovwb128mem_mask
+      {Intrinsic::x86_avx512_mask_pmov_wb_mem_256, 142786}, // __builtin_ia32_pmovwb256mem_mask
+      {Intrinsic::x86_avx512_mask_pmov_wb_mem_512, 142819}, // __builtin_ia32_pmovwb512mem_mask
+      {Intrinsic::x86_ssse3_pmul_hr_sw, 158456}, // __builtin_ia32_pmulhrsw
+      {Intrinsic::x86_ssse3_pmul_hr_sw_128, 158480}, // __builtin_ia32_pmulhrsw128
+      {Intrinsic::x86_avx2_pmul_hr_sw, 137078}, // __builtin_ia32_pmulhrsw256
+      {Intrinsic::x86_avx512_pmul_hr_sw_512, 147400}, // __builtin_ia32_pmulhrsw512
+      {Intrinsic::x86_3dnow_pmulhrw, 134012}, // __builtin_ia32_pmulhrw
+      {Intrinsic::x86_mmx_pmulhu_w, 153100}, // __builtin_ia32_pmulhuw
+      {Intrinsic::x86_sse2_pmulhu_w, 156282}, // __builtin_ia32_pmulhuw128
+      {Intrinsic::x86_avx2_pmulhu_w, 137130}, // __builtin_ia32_pmulhuw256
+      {Intrinsic::x86_avx512_pmulhu_w_512, 147452}, // __builtin_ia32_pmulhuw512
+      {Intrinsic::x86_mmx_pmulh_w, 153078}, // __builtin_ia32_pmulhw
+      {Intrinsic::x86_sse2_pmulh_w, 156257}, // __builtin_ia32_pmulhw128
+      {Intrinsic::x86_avx2_pmulh_w, 137105}, // __builtin_ia32_pmulhw256
+      {Intrinsic::x86_avx512_pmulh_w_512, 147427}, // __builtin_ia32_pmulhw512
+      {Intrinsic::x86_mmx_pmull_w, 153123}, // __builtin_ia32_pmullw
+      {Intrinsic::x86_mmx_pmulu_dq, 153145}, // __builtin_ia32_pmuludq
+      {Intrinsic::x86_mmx_por, 153168}, // __builtin_ia32_por
+      {Intrinsic::x86_mmx_psad_bw, 153187}, // __builtin_ia32_psadbw
+      {Intrinsic::x86_sse2_psad_bw, 156308}, // __builtin_ia32_psadbw128
+      {Intrinsic::x86_avx2_psad_bw, 137156}, // __builtin_ia32_psadbw256
+      {Intrinsic::x86_avx512_psad_bw_512, 147577}, // __builtin_ia32_psadbw512
+      {Intrinsic::x86_ssse3_pshuf_b, 158507}, // __builtin_ia32_pshufb
+      {Intrinsic::x86_ssse3_pshuf_b_128, 158529}, // __builtin_ia32_pshufb128
+      {Intrinsic::x86_avx2_pshuf_b, 137181}, // __builtin_ia32_pshufb256
+      {Intrinsic::x86_avx512_pshuf_b_512, 147602}, // __builtin_ia32_pshufb512
+      {Intrinsic::x86_sse_pshuf_w, 155168}, // __builtin_ia32_pshufw
+      {Intrinsic::x86_ssse3_psign_b, 158554}, // __builtin_ia32_psignb
+      {Intrinsic::x86_ssse3_psign_b_128, 158576}, // __builtin_ia32_psignb128
+      {Intrinsic::x86_avx2_psign_b, 137206}, // __builtin_ia32_psignb256
+      {Intrinsic::x86_ssse3_psign_d, 158601}, // __builtin_ia32_psignd
+      {Intrinsic::x86_ssse3_psign_d_128, 158623}, // __builtin_ia32_psignd128
+      {Intrinsic::x86_avx2_psign_d, 137231}, // __builtin_ia32_psignd256
+      {Intrinsic::x86_ssse3_psign_w, 158648}, // __builtin_ia32_psignw
+      {Intrinsic::x86_ssse3_psign_w_128, 158670}, // __builtin_ia32_psignw128
+      {Intrinsic::x86_avx2_psign_w, 137256}, // __builtin_ia32_psignw256
+      {Intrinsic::x86_mmx_psll_d, 153209}, // __builtin_ia32_pslld
+      {Intrinsic::x86_sse2_psll_d, 156333}, // __builtin_ia32_pslld128
+      {Intrinsic::x86_avx2_psll_d, 137281}, // __builtin_ia32_pslld256
+      {Intrinsic::x86_avx512_psll_d_512, 147627}, // __builtin_ia32_pslld512
+      {Intrinsic::x86_mmx_pslli_d, 153272}, // __builtin_ia32_pslldi
+      {Intrinsic::x86_sse2_pslli_d, 156405}, // __builtin_ia32_pslldi128
+      {Intrinsic::x86_avx2_pslli_d, 137353}, // __builtin_ia32_pslldi256
+      {Intrinsic::x86_avx512_pslli_d_512, 147699}, // __builtin_ia32_pslldi512
+      {Intrinsic::x86_mmx_psll_q, 153230}, // __builtin_ia32_psllq
+      {Intrinsic::x86_sse2_psll_q, 156357}, // __builtin_ia32_psllq128
+      {Intrinsic::x86_avx2_psll_q, 137305}, // __builtin_ia32_psllq256
+      {Intrinsic::x86_avx512_psll_q_512, 147651}, // __builtin_ia32_psllq512
+      {Intrinsic::x86_mmx_pslli_q, 153294}, // __builtin_ia32_psllqi
+      {Intrinsic::x86_sse2_pslli_q, 156430}, // __builtin_ia32_psllqi128
+      {Intrinsic::x86_avx2_pslli_q, 137378}, // __builtin_ia32_psllqi256
+      {Intrinsic::x86_avx512_pslli_q_512, 147724}, // __builtin_ia32_psllqi512
+      {Intrinsic::x86_avx512_psllv_w_256, 147847}, // __builtin_ia32_psllv16hi
+      {Intrinsic::x86_avx512_psllv_d_512, 147774}, // __builtin_ia32_psllv16si
+      {Intrinsic::x86_avx2_psllv_q, 137476}, // __builtin_ia32_psllv2di
+      {Intrinsic::x86_avx512_psllv_w_512, 147872}, // __builtin_ia32_psllv32hi
+      {Intrinsic::x86_avx2_psllv_q_256, 137500}, // __builtin_ia32_psllv4di
+      {Intrinsic::x86_avx2_psllv_d, 137428}, // __builtin_ia32_psllv4si
+      {Intrinsic::x86_avx512_psllv_q_512, 147799}, // __builtin_ia32_psllv8di
+      {Intrinsic::x86_avx512_psllv_w_128, 147823}, // __builtin_ia32_psllv8hi
+      {Intrinsic::x86_avx2_psllv_d_256, 137452}, // __builtin_ia32_psllv8si
+      {Intrinsic::x86_mmx_psll_w, 153251}, // __builtin_ia32_psllw
+      {Intrinsic::x86_sse2_psll_w, 156381}, // __builtin_ia32_psllw128
+      {Intrinsic::x86_avx2_psll_w, 137329}, // __builtin_ia32_psllw256
+      {Intrinsic::x86_avx512_psll_w_512, 147675}, // __builtin_ia32_psllw512
+      {Intrinsic::x86_mmx_pslli_w, 153316}, // __builtin_ia32_psllwi
+      {Intrinsic::x86_sse2_pslli_w, 156455}, // __builtin_ia32_psllwi128
+      {Intrinsic::x86_avx2_pslli_w, 137403}, // __builtin_ia32_psllwi256
+      {Intrinsic::x86_avx512_pslli_w_512, 147749}, // __builtin_ia32_psllwi512
+      {Intrinsic::x86_mmx_psra_d, 153338}, // __builtin_ia32_psrad
+      {Intrinsic::x86_sse2_psra_d, 156480}, // __builtin_ia32_psrad128
+      {Intrinsic::x86_avx2_psra_d, 137524}, // __builtin_ia32_psrad256
+      {Intrinsic::x86_avx512_psra_d_512, 147897}, // __builtin_ia32_psrad512
+      {Intrinsic::x86_mmx_psrai_d, 153380}, // __builtin_ia32_psradi
+      {Intrinsic::x86_sse2_psrai_d, 156528}, // __builtin_ia32_psradi128
+      {Intrinsic::x86_avx2_psrai_d, 137572}, // __builtin_ia32_psradi256
+      {Intrinsic::x86_avx512_psrai_d_512, 148017}, // __builtin_ia32_psradi512
+      {Intrinsic::x86_avx512_psra_q_128, 147921}, // __builtin_ia32_psraq128
+      {Intrinsic::x86_avx512_psra_q_256, 147945}, // __builtin_ia32_psraq256
+      {Intrinsic::x86_avx512_psra_q_512, 147969}, // __builtin_ia32_psraq512
+      {Intrinsic::x86_avx512_psrai_q_128, 148042}, // __builtin_ia32_psraqi128
+      {Intrinsic::x86_avx512_psrai_q_256, 148067}, // __builtin_ia32_psraqi256
+      {Intrinsic::x86_avx512_psrai_q_512, 148092}, // __builtin_ia32_psraqi512
+      {Intrinsic::x86_avx512_psrav_w_256, 148265}, // __builtin_ia32_psrav16hi
+      {Intrinsic::x86_avx512_psrav_d_512, 148142}, // __builtin_ia32_psrav16si
+      {Intrinsic::x86_avx512_psrav_w_512, 148290}, // __builtin_ia32_psrav32hi
+      {Intrinsic::x86_avx2_psrav_d, 137622}, // __builtin_ia32_psrav4si
+      {Intrinsic::x86_avx512_psrav_q_512, 148217}, // __builtin_ia32_psrav8di
+      {Intrinsic::x86_avx512_psrav_w_128, 148241}, // __builtin_ia32_psrav8hi
+      {Intrinsic::x86_avx2_psrav_d_256, 137646}, // __builtin_ia32_psrav8si
+      {Intrinsic::x86_avx512_psrav_q_128, 148167}, // __builtin_ia32_psravq128
+      {Intrinsic::x86_avx512_psrav_q_256, 148192}, // __builtin_ia32_psravq256
+      {Intrinsic::x86_mmx_psra_w, 153359}, // __builtin_ia32_psraw
+      {Intrinsic::x86_sse2_psra_w, 156504}, // __builtin_ia32_psraw128
+      {Intrinsic::x86_avx2_psra_w, 137548}, // __builtin_ia32_psraw256
+      {Intrinsic::x86_avx512_psra_w_512, 147993}, // __builtin_ia32_psraw512
+      {Intrinsic::x86_mmx_psrai_w, 153402}, // __builtin_ia32_psrawi
+      {Intrinsic::x86_sse2_psrai_w, 156553}, // __builtin_ia32_psrawi128
+      {Intrinsic::x86_avx2_psrai_w, 137597}, // __builtin_ia32_psrawi256
+      {Intrinsic::x86_avx512_psrai_w_512, 148117}, // __builtin_ia32_psrawi512
+      {Intrinsic::x86_mmx_psrl_d, 153424}, // __builtin_ia32_psrld
+      {Intrinsic::x86_sse2_psrl_d, 156578}, // __builtin_ia32_psrld128
+      {Intrinsic::x86_avx2_psrl_d, 137670}, // __builtin_ia32_psrld256
+      {Intrinsic::x86_avx512_psrl_d_512, 148315}, // __builtin_ia32_psrld512
+      {Intrinsic::x86_mmx_psrli_d, 153487}, // __builtin_ia32_psrldi
+      {Intrinsic::x86_sse2_psrli_d, 156650}, // __builtin_ia32_psrldi128
+      {Intrinsic::x86_avx2_psrli_d, 137742}, // __builtin_ia32_psrldi256
+      {Intrinsic::x86_avx512_psrli_d_512, 148387}, // __builtin_ia32_psrldi512
+      {Intrinsic::x86_mmx_psrl_q, 153445}, // __builtin_ia32_psrlq
+      {Intrinsic::x86_sse2_psrl_q, 156602}, // __builtin_ia32_psrlq128
+      {Intrinsic::x86_avx2_psrl_q, 137694}, // __builtin_ia32_psrlq256
+      {Intrinsic::x86_avx512_psrl_q_512, 148339}, // __builtin_ia32_psrlq512
+      {Intrinsic::x86_mmx_psrli_q, 153509}, // __builtin_ia32_psrlqi
+      {Intrinsic::x86_sse2_psrli_q, 156675}, // __builtin_ia32_psrlqi128
+      {Intrinsic::x86_avx2_psrli_q, 137767}, // __builtin_ia32_psrlqi256
+      {Intrinsic::x86_avx512_psrli_q_512, 148412}, // __builtin_ia32_psrlqi512
+      {Intrinsic::x86_avx512_psrlv_w_256, 148535}, // __builtin_ia32_psrlv16hi
+      {Intrinsic::x86_avx512_psrlv_d_512, 148462}, // __builtin_ia32_psrlv16si
+      {Intrinsic::x86_avx2_psrlv_q, 137865}, // __builtin_ia32_psrlv2di
+      {Intrinsic::x86_avx512_psrlv_w_512, 148560}, // __builtin_ia32_psrlv32hi
+      {Intrinsic::x86_avx2_psrlv_q_256, 137889}, // __builtin_ia32_psrlv4di
+      {Intrinsic::x86_avx2_psrlv_d, 137817}, // __builtin_ia32_psrlv4si
+      {Intrinsic::x86_avx512_psrlv_q_512, 148487}, // __builtin_ia32_psrlv8di
+      {Intrinsic::x86_avx512_psrlv_w_128, 148511}, // __builtin_ia32_psrlv8hi
+      {Intrinsic::x86_avx2_psrlv_d_256, 137841}, // __builtin_ia32_psrlv8si
+      {Intrinsic::x86_mmx_psrl_w, 153466}, // __builtin_ia32_psrlw
+      {Intrinsic::x86_sse2_psrl_w, 156626}, // __builtin_ia32_psrlw128
+      {Intrinsic::x86_avx2_psrl_w, 137718}, // __builtin_ia32_psrlw256
+      {Intrinsic::x86_avx512_psrl_w_512, 148363}, // __builtin_ia32_psrlw512
+      {Intrinsic::x86_mmx_psrli_w, 153531}, // __builtin_ia32_psrlwi
+      {Intrinsic::x86_sse2_psrli_w, 156700}, // __builtin_ia32_psrlwi128
+      {Intrinsic::x86_avx2_psrli_w, 137792}, // __builtin_ia32_psrlwi256
+      {Intrinsic::x86_avx512_psrli_w_512, 148437}, // __builtin_ia32_psrlwi512
+      {Intrinsic::x86_mmx_psub_b, 153553}, // __builtin_ia32_psubb
+      {Intrinsic::x86_mmx_psub_d, 153574}, // __builtin_ia32_psubd
+      {Intrinsic::x86_mmx_psub_q, 153595}, // __builtin_ia32_psubq
+      {Intrinsic::x86_mmx_psubs_b, 153637}, // __builtin_ia32_psubsb
+      {Intrinsic::x86_mmx_psubs_w, 153659}, // __builtin_ia32_psubsw
+      {Intrinsic::x86_mmx_psubus_b, 153681}, // __builtin_ia32_psubusb
+      {Intrinsic::x86_mmx_psubus_w, 153704}, // __builtin_ia32_psubusw
+      {Intrinsic::x86_mmx_psub_w, 153616}, // __builtin_ia32_psubw
+      {Intrinsic::x86_avx512_pternlog_d_128, 148585}, // __builtin_ia32_pternlogd128
+      {Intrinsic::x86_avx512_pternlog_d_256, 148613}, // __builtin_ia32_pternlogd256
+      {Intrinsic::x86_avx512_pternlog_d_512, 148641}, // __builtin_ia32_pternlogd512
+      {Intrinsic::x86_avx512_pternlog_q_128, 148669}, // __builtin_ia32_pternlogq128
+      {Intrinsic::x86_avx512_pternlog_q_256, 148697}, // __builtin_ia32_pternlogq256
+      {Intrinsic::x86_avx512_pternlog_q_512, 148725}, // __builtin_ia32_pternlogq512
+      {Intrinsic::x86_sse41_ptestc, 157301}, // __builtin_ia32_ptestc128
+      {Intrinsic::x86_avx_ptestc_256, 135271}, // __builtin_ia32_ptestc256
+      {Intrinsic::x86_sse41_ptestnzc, 157326}, // __builtin_ia32_ptestnzc128
+      {Intrinsic::x86_avx_ptestnzc_256, 135296}, // __builtin_ia32_ptestnzc256
+      {Intrinsic::x86_sse41_ptestz, 157353}, // __builtin_ia32_ptestz128
+      {Intrinsic::x86_avx_ptestz_256, 135323}, // __builtin_ia32_ptestz256
+      {Intrinsic::x86_ptwrite32, 154052}, // __builtin_ia32_ptwrite32
+      {Intrinsic::x86_ptwrite64, 154077}, // __builtin_ia32_ptwrite64
+      {Intrinsic::x86_mmx_punpckhbw, 153727}, // __builtin_ia32_punpckhbw
+      {Intrinsic::x86_mmx_punpckhdq, 153752}, // __builtin_ia32_punpckhdq
+      {Intrinsic::x86_mmx_punpckhwd, 153777}, // __builtin_ia32_punpckhwd
+      {Intrinsic::x86_mmx_punpcklbw, 153802}, // __builtin_ia32_punpcklbw
+      {Intrinsic::x86_mmx_punpckldq, 153827}, // __builtin_ia32_punpckldq
+      {Intrinsic::x86_mmx_punpcklwd, 153852}, // __builtin_ia32_punpcklwd
+      {Intrinsic::x86_mmx_pxor, 153877}, // __builtin_ia32_pxor
+      {Intrinsic::x86_avx512_mask_range_pd_128, 145228}, // __builtin_ia32_rangepd128_mask
+      {Intrinsic::x86_avx512_mask_range_pd_256, 145259}, // __builtin_ia32_rangepd256_mask
+      {Intrinsic::x86_avx512_mask_range_pd_512, 145290}, // __builtin_ia32_rangepd512_mask
+      {Intrinsic::x86_avx512_mask_range_ps_128, 145321}, // __builtin_ia32_rangeps128_mask
+      {Intrinsic::x86_avx512_mask_range_ps_256, 145352}, // __builtin_ia32_rangeps256_mask
+      {Intrinsic::x86_avx512_mask_range_ps_512, 145383}, // __builtin_ia32_rangeps512_mask
+      {Intrinsic::x86_avx512_mask_range_sd, 145414}, // __builtin_ia32_rangesd128_round_mask
+      {Intrinsic::x86_avx512_mask_range_ss, 145451}, // __builtin_ia32_rangess128_round_mask
+      {Intrinsic::x86_avx512_rcp14_pd_128, 148753}, // __builtin_ia32_rcp14pd128_mask
+      {Intrinsic::x86_avx512_rcp14_pd_256, 148784}, // __builtin_ia32_rcp14pd256_mask
+      {Intrinsic::x86_avx512_rcp14_pd_512, 148815}, // __builtin_ia32_rcp14pd512_mask
+      {Intrinsic::x86_avx512_rcp14_ps_128, 148846}, // __builtin_ia32_rcp14ps128_mask
+      {Intrinsic::x86_avx512_rcp14_ps_256, 148877}, // __builtin_ia32_rcp14ps256_mask
+      {Intrinsic::x86_avx512_rcp14_ps_512, 148908}, // __builtin_ia32_rcp14ps512_mask
+      {Intrinsic::x86_avx512_rcp14_sd, 148939}, // __builtin_ia32_rcp14sd_mask
+      {Intrinsic::x86_avx512_rcp14_ss, 148967}, // __builtin_ia32_rcp14ss_mask
+      {Intrinsic::x86_avx512_rcp28_pd, 148995}, // __builtin_ia32_rcp28pd_mask
+      {Intrinsic::x86_avx512_rcp28_ps, 149023}, // __builtin_ia32_rcp28ps_mask
+      {Intrinsic::x86_avx512_rcp28_sd, 149051}, // __builtin_ia32_rcp28sd_round_mask
+      {Intrinsic::x86_avx512_rcp28_ss, 149085}, // __builtin_ia32_rcp28ss_round_mask
+      {Intrinsic::x86_sse_rcp_ps, 155190}, // __builtin_ia32_rcpps
+      {Intrinsic::x86_avx_rcp_ps_256, 135348}, // __builtin_ia32_rcpps256
+      {Intrinsic::x86_sse_rcp_ss, 155211}, // __builtin_ia32_rcpss
+      {Intrinsic::x86_rdfsbase_32, 154102}, // __builtin_ia32_rdfsbase32
+      {Intrinsic::x86_rdfsbase_64, 154128}, // __builtin_ia32_rdfsbase64
+      {Intrinsic::x86_rdgsbase_32, 154154}, // __builtin_ia32_rdgsbase32
+      {Intrinsic::x86_rdgsbase_64, 154180}, // __builtin_ia32_rdgsbase64
+      {Intrinsic::x86_rdpid, 154206}, // __builtin_ia32_rdpid
+      {Intrinsic::x86_rdpkru, 154227}, // __builtin_ia32_rdpkru
+      {Intrinsic::x86_rdpmc, 154249}, // __builtin_ia32_rdpmc
+      {Intrinsic::x86_rdsspd, 154270}, // __builtin_ia32_rdsspd
+      {Intrinsic::x86_rdsspq, 154292}, // __builtin_ia32_rdsspq
+      {Intrinsic::x86_rdtsc, 154314}, // __builtin_ia32_rdtsc
+      {Intrinsic::x86_flags_read_u32, 151737}, // __builtin_ia32_readeflags_u32
+      {Intrinsic::x86_flags_read_u64, 151767}, // __builtin_ia32_readeflags_u64
+      {Intrinsic::x86_avx512_mask_reduce_pd_128, 145488}, // __builtin_ia32_reducepd128_mask
+      {Intrinsic::x86_avx512_mask_reduce_pd_256, 145520}, // __builtin_ia32_reducepd256_mask
+      {Intrinsic::x86_avx512_mask_reduce_pd_512, 145552}, // __builtin_ia32_reducepd512_mask
+      {Intrinsic::x86_avx512_mask_reduce_ps_128, 145584}, // __builtin_ia32_reduceps128_mask
+      {Intrinsic::x86_avx512_mask_reduce_ps_256, 145616}, // __builtin_ia32_reduceps256_mask
+      {Intrinsic::x86_avx512_mask_reduce_ps_512, 145648}, // __builtin_ia32_reduceps512_mask
+      {Intrinsic::x86_avx512_mask_reduce_sd, 145680}, // __builtin_ia32_reducesd_mask
+      {Intrinsic::x86_avx512_mask_reduce_ss, 145709}, // __builtin_ia32_reducess_mask
+      {Intrinsic::x86_avx512_mask_rndscale_pd_128, 145738}, // __builtin_ia32_rndscalepd_128_mask
+      {Intrinsic::x86_avx512_mask_rndscale_pd_256, 145773}, // __builtin_ia32_rndscalepd_256_mask
+      {Intrinsic::x86_avx512_mask_rndscale_pd_512, 145808}, // __builtin_ia32_rndscalepd_mask
+      {Intrinsic::x86_avx512_mask_rndscale_ps_128, 145839}, // __builtin_ia32_rndscaleps_128_mask
+      {Intrinsic::x86_avx512_mask_rndscale_ps_256, 145874}, // __builtin_ia32_rndscaleps_256_mask
+      {Intrinsic::x86_avx512_mask_rndscale_ps_512, 145909}, // __builtin_ia32_rndscaleps_mask
+      {Intrinsic::x86_avx512_mask_rndscale_sd, 145940}, // __builtin_ia32_rndscalesd_round_mask
+      {Intrinsic::x86_avx512_mask_rndscale_ss, 145977}, // __builtin_ia32_rndscaless_round_mask
+      {Intrinsic::x86_sse41_round_pd, 157378}, // __builtin_ia32_roundpd
+      {Intrinsic::x86_avx_round_pd_256, 135372}, // __builtin_ia32_roundpd256
+      {Intrinsic::x86_sse41_round_ps, 157401}, // __builtin_ia32_roundps
+      {Intrinsic::x86_avx_round_ps_256, 135398}, // __builtin_ia32_roundps256
+      {Intrinsic::x86_sse41_round_sd, 157424}, // __builtin_ia32_roundsd
+      {Intrinsic::x86_sse41_round_ss, 157447}, // __builtin_ia32_roundss
+      {Intrinsic::x86_avx512_rsqrt14_pd_128, 149119}, // __builtin_ia32_rsqrt14pd128_mask
+      {Intrinsic::x86_avx512_rsqrt14_pd_256, 149152}, // __builtin_ia32_rsqrt14pd256_mask
+      {Intrinsic::x86_avx512_rsqrt14_pd_512, 149185}, // __builtin_ia32_rsqrt14pd512_mask
+      {Intrinsic::x86_avx512_rsqrt14_ps_128, 149218}, // __builtin_ia32_rsqrt14ps128_mask
+      {Intrinsic::x86_avx512_rsqrt14_ps_256, 149251}, // __builtin_ia32_rsqrt14ps256_mask
+      {Intrinsic::x86_avx512_rsqrt14_ps_512, 149284}, // __builtin_ia32_rsqrt14ps512_mask
+      {Intrinsic::x86_avx512_rsqrt14_sd, 149317}, // __builtin_ia32_rsqrt14sd_mask
+      {Intrinsic::x86_avx512_rsqrt14_ss, 149347}, // __builtin_ia32_rsqrt14ss_mask
+      {Intrinsic::x86_avx512_rsqrt28_pd, 149377}, // __builtin_ia32_rsqrt28pd_mask
+      {Intrinsic::x86_avx512_rsqrt28_ps, 149407}, // __builtin_ia32_rsqrt28ps_mask
+      {Intrinsic::x86_avx512_rsqrt28_sd, 149437}, // __builtin_ia32_rsqrt28sd_round_mask
+      {Intrinsic::x86_avx512_rsqrt28_ss, 149473}, // __builtin_ia32_rsqrt28ss_round_mask
+      {Intrinsic::x86_sse_rsqrt_ps, 155232}, // __builtin_ia32_rsqrtps
+      {Intrinsic::x86_avx_rsqrt_ps_256, 135424}, // __builtin_ia32_rsqrtps256
+      {Intrinsic::x86_sse_rsqrt_ss, 155255}, // __builtin_ia32_rsqrtss
+      {Intrinsic::x86_rstorssp, 154335}, // __builtin_ia32_rstorssp
+      {Intrinsic::x86_saveprevssp, 154359}, // __builtin_ia32_saveprevssp
+      {Intrinsic::x86_avx512_mask_scalef_pd_128, 146014}, // __builtin_ia32_scalefpd128_mask
+      {Intrinsic::x86_avx512_mask_scalef_pd_256, 146046}, // __builtin_ia32_scalefpd256_mask
+      {Intrinsic::x86_avx512_mask_scalef_pd_512, 146078}, // __builtin_ia32_scalefpd512_mask
+      {Intrinsic::x86_avx512_mask_scalef_ps_128, 146110}, // __builtin_ia32_scalefps128_mask
+      {Intrinsic::x86_avx512_mask_scalef_ps_256, 146142}, // __builtin_ia32_scalefps256_mask
+      {Intrinsic::x86_avx512_mask_scalef_ps_512, 146174}, // __builtin_ia32_scalefps512_mask
+      {Intrinsic::x86_avx512_mask_scalef_sd, 146206}, // __builtin_ia32_scalefsd_round_mask
+      {Intrinsic::x86_avx512_mask_scalef_ss, 146241}, // __builtin_ia32_scalefss_round_mask
+      {Intrinsic::x86_avx512_scatterpf_dpd_512, 149509}, // __builtin_ia32_scatterpfdpd
+      {Intrinsic::x86_avx512_scatterpf_dps_512, 149537}, // __builtin_ia32_scatterpfdps
+      {Intrinsic::x86_avx512_scatterpf_qpd_512, 149565}, // __builtin_ia32_scatterpfqpd
+      {Intrinsic::x86_avx512_scatterpf_qps_512, 149593}, // __builtin_ia32_scatterpfqps
+      {Intrinsic::x86_senduipi, 154386}, // __builtin_ia32_senduipi
+      {Intrinsic::x86_serialize, 154410}, // __builtin_ia32_serialize
+      {Intrinsic::x86_setssbsy, 154435}, // __builtin_ia32_setssbsy
+      {Intrinsic::x86_sse_sfence, 155278}, // __builtin_ia32_sfence
+      {Intrinsic::x86_sha1msg1, 154459}, // __builtin_ia32_sha1msg1
+      {Intrinsic::x86_sha1msg2, 154483}, // __builtin_ia32_sha1msg2
+      {Intrinsic::x86_sha1nexte, 154507}, // __builtin_ia32_sha1nexte
+      {Intrinsic::x86_sha1rnds4, 154532}, // __builtin_ia32_sha1rnds4
+      {Intrinsic::x86_sha256msg1, 154557}, // __builtin_ia32_sha256msg1
+      {Intrinsic::x86_sha256msg2, 154583}, // __builtin_ia32_sha256msg2
+      {Intrinsic::x86_sha256rnds2, 154609}, // __builtin_ia32_sha256rnds2
+      {Intrinsic::x86_slwpcb, 154636}, // __builtin_ia32_slwpcb
+      {Intrinsic::x86_stui, 158727}, // __builtin_ia32_stui
+      {Intrinsic::x86_avx512_sub_pd_512, 149621}, // __builtin_ia32_subpd512
+      {Intrinsic::x86_avx512_sub_ps_512, 149645}, // __builtin_ia32_subps512
+      {Intrinsic::x86_avx512_mask_sub_sd_round, 146276}, // __builtin_ia32_subsd_round_mask
+      {Intrinsic::x86_avx512_mask_sub_ss_round, 146308}, // __builtin_ia32_subss_round_mask
+      {Intrinsic::x86_tdpbf16ps, 158799}, // __builtin_ia32_tdpbf16ps
+      {Intrinsic::x86_tdpbssd, 158824}, // __builtin_ia32_tdpbssd
+      {Intrinsic::x86_tdpbssd_internal, 158847}, // __builtin_ia32_tdpbssd_internal
+      {Intrinsic::x86_tdpbsud, 158879}, // __builtin_ia32_tdpbsud
+      {Intrinsic::x86_tdpbusd, 158902}, // __builtin_ia32_tdpbusd
+      {Intrinsic::x86_tdpbuud, 158925}, // __builtin_ia32_tdpbuud
+      {Intrinsic::x86_testui, 158948}, // __builtin_ia32_testui
+      {Intrinsic::x86_ldtilecfg, 152136}, // __builtin_ia32_tile_loadconfig
+      {Intrinsic::x86_sttilecfg, 158695}, // __builtin_ia32_tile_storeconfig
+      {Intrinsic::x86_tileloadd64, 158970}, // __builtin_ia32_tileloadd64
+      {Intrinsic::x86_tileloadd64_internal, 158997}, // __builtin_ia32_tileloadd64_internal
+      {Intrinsic::x86_tileloaddt164, 159033}, // __builtin_ia32_tileloaddt164
+      {Intrinsic::x86_tilerelease, 159062}, // __builtin_ia32_tilerelease
+      {Intrinsic::x86_tilestored64, 159089}, // __builtin_ia32_tilestored64
+      {Intrinsic::x86_tilestored64_internal, 159117}, // __builtin_ia32_tilestored64_internal
+      {Intrinsic::x86_tilezero, 159154}, // __builtin_ia32_tilezero
+      {Intrinsic::x86_tilezero_internal, 159178}, // __builtin_ia32_tilezero_internal
+      {Intrinsic::x86_tpause, 159211}, // __builtin_ia32_tpause
+      {Intrinsic::x86_sse_ucomieq_ss, 155300}, // __builtin_ia32_ucomieq
+      {Intrinsic::x86_sse_ucomige_ss, 155323}, // __builtin_ia32_ucomige
+      {Intrinsic::x86_sse_ucomigt_ss, 155346}, // __builtin_ia32_ucomigt
+      {Intrinsic::x86_sse_ucomile_ss, 155369}, // __builtin_ia32_ucomile
+      {Intrinsic::x86_sse_ucomilt_ss, 155392}, // __builtin_ia32_ucomilt
+      {Intrinsic::x86_sse_ucomineq_ss, 155415}, // __builtin_ia32_ucomineq
+      {Intrinsic::x86_sse2_ucomieq_sd, 156725}, // __builtin_ia32_ucomisdeq
+      {Intrinsic::x86_sse2_ucomige_sd, 156750}, // __builtin_ia32_ucomisdge
+      {Intrinsic::x86_sse2_ucomigt_sd, 156775}, // __builtin_ia32_ucomisdgt
+      {Intrinsic::x86_sse2_ucomile_sd, 156800}, // __builtin_ia32_ucomisdle
+      {Intrinsic::x86_sse2_ucomilt_sd, 156825}, // __builtin_ia32_ucomisdlt
+      {Intrinsic::x86_sse2_ucomineq_sd, 156850}, // __builtin_ia32_ucomisdneq
+      {Intrinsic::x86_umonitor, 159233}, // __builtin_ia32_umonitor
+      {Intrinsic::x86_umwait, 159257}, // __builtin_ia32_umwait
+      {Intrinsic::x86_avx512_vcomi_sd, 149669}, // __builtin_ia32_vcomisd
+      {Intrinsic::x86_avx512_vcomi_ss, 149692}, // __builtin_ia32_vcomiss
+      {Intrinsic::x86_vcvtps2ph_128, 159279}, // __builtin_ia32_vcvtps2ph
+      {Intrinsic::x86_vcvtps2ph_256, 159304}, // __builtin_ia32_vcvtps2ph256
+      {Intrinsic::x86_avx512_mask_vcvtps2ph_256, 146370}, // __builtin_ia32_vcvtps2ph256_mask
+      {Intrinsic::x86_avx512_mask_vcvtps2ph_512, 146403}, // __builtin_ia32_vcvtps2ph512_mask
+      {Intrinsic::x86_avx512_mask_vcvtps2ph_128, 146340}, // __builtin_ia32_vcvtps2ph_mask
+      {Intrinsic::x86_avx512_vcvtsd2si32, 149715}, // __builtin_ia32_vcvtsd2si32
+      {Intrinsic::x86_avx512_vcvtsd2si64, 149742}, // __builtin_ia32_vcvtsd2si64
+      {Intrinsic::x86_avx512_vcvtsd2usi32, 149769}, // __builtin_ia32_vcvtsd2usi32
+      {Intrinsic::x86_avx512_vcvtsd2usi64, 149797}, // __builtin_ia32_vcvtsd2usi64
+      {Intrinsic::x86_avx512_vcvtss2si32, 149825}, // __builtin_ia32_vcvtss2si32
+      {Intrinsic::x86_avx512_vcvtss2si64, 149852}, // __builtin_ia32_vcvtss2si64
+      {Intrinsic::x86_avx512_vcvtss2usi32, 149879}, // __builtin_ia32_vcvtss2usi32
+      {Intrinsic::x86_avx512_vcvtss2usi64, 149907}, // __builtin_ia32_vcvtss2usi64
+      {Intrinsic::x86_avx512_cvttsd2si, 138411}, // __builtin_ia32_vcvttsd2si32
+      {Intrinsic::x86_avx512_cvttsd2si64, 138439}, // __builtin_ia32_vcvttsd2si64
+      {Intrinsic::x86_avx512_cvttsd2usi, 138467}, // __builtin_ia32_vcvttsd2usi32
+      {Intrinsic::x86_avx512_cvttsd2usi64, 138496}, // __builtin_ia32_vcvttsd2usi64
+      {Intrinsic::x86_avx512_cvttss2si, 138525}, // __builtin_ia32_vcvttss2si32
+      {Intrinsic::x86_avx512_cvttss2si64, 138553}, // __builtin_ia32_vcvttss2si64
+      {Intrinsic::x86_avx512_cvttss2usi, 138581}, // __builtin_ia32_vcvttss2usi32
+      {Intrinsic::x86_avx512_cvttss2usi64, 138610}, // __builtin_ia32_vcvttss2usi64
+      {Intrinsic::x86_mmx_pextr_w, 152887}, // __builtin_ia32_vec_ext_v4hi
+      {Intrinsic::x86_mmx_pinsr_w, 152915}, // __builtin_ia32_vec_set_v4hi
+      {Intrinsic::x86_fma_vfmaddsub_pd, 151859}, // __builtin_ia32_vfmaddsubpd
+      {Intrinsic::x86_fma_vfmaddsub_pd_256, 151886}, // __builtin_ia32_vfmaddsubpd256
+      {Intrinsic::x86_fma_vfmaddsub_ps, 151916}, // __builtin_ia32_vfmaddsubps
+      {Intrinsic::x86_fma_vfmaddsub_ps_256, 151943}, // __builtin_ia32_vfmaddsubps256
+      {Intrinsic::x86_xop_vfrcz_pd, 159975}, // __builtin_ia32_vfrczpd
+      {Intrinsic::x86_xop_vfrcz_pd_256, 159998}, // __builtin_ia32_vfrczpd256
+      {Intrinsic::x86_xop_vfrcz_ps, 160024}, // __builtin_ia32_vfrczps
+      {Intrinsic::x86_xop_vfrcz_ps_256, 160047}, // __builtin_ia32_vfrczps256
+      {Intrinsic::x86_xop_vfrcz_sd, 160073}, // __builtin_ia32_vfrczsd
+      {Intrinsic::x86_xop_vfrcz_ss, 160096}, // __builtin_ia32_vfrczss
+      {Intrinsic::x86_vgf2p8affineinvqb_128, 159332}, // __builtin_ia32_vgf2p8affineinvqb_v16qi
+      {Intrinsic::x86_vgf2p8affineinvqb_256, 159371}, // __builtin_ia32_vgf2p8affineinvqb_v32qi
+      {Intrinsic::x86_vgf2p8affineinvqb_512, 159410}, // __builtin_ia32_vgf2p8affineinvqb_v64qi
+      {Intrinsic::x86_vgf2p8affineqb_128, 159449}, // __builtin_ia32_vgf2p8affineqb_v16qi
+      {Intrinsic::x86_vgf2p8affineqb_256, 159485}, // __builtin_ia32_vgf2p8affineqb_v32qi
+      {Intrinsic::x86_vgf2p8affineqb_512, 159521}, // __builtin_ia32_vgf2p8affineqb_v64qi
+      {Intrinsic::x86_vgf2p8mulb_128, 159557}, // __builtin_ia32_vgf2p8mulb_v16qi
+      {Intrinsic::x86_vgf2p8mulb_256, 159589}, // __builtin_ia32_vgf2p8mulb_v32qi
+      {Intrinsic::x86_vgf2p8mulb_512, 159621}, // __builtin_ia32_vgf2p8mulb_v64qi
+      {Intrinsic::x86_avx512_conflict_q_128, 138237}, // __builtin_ia32_vpconflictdi_128
+      {Intrinsic::x86_avx512_conflict_q_256, 138269}, // __builtin_ia32_vpconflictdi_256
+      {Intrinsic::x86_avx512_conflict_q_512, 138301}, // __builtin_ia32_vpconflictdi_512
+      {Intrinsic::x86_avx512_conflict_d_128, 138141}, // __builtin_ia32_vpconflictsi_128
+      {Intrinsic::x86_avx512_conflict_d_256, 138173}, // __builtin_ia32_vpconflictsi_256
+      {Intrinsic::x86_avx512_conflict_d_512, 138205}, // __builtin_ia32_vpconflictsi_512
+      {Intrinsic::x86_avx512_vpdpbusd_128, 149935}, // __builtin_ia32_vpdpbusd128
+      {Intrinsic::x86_avx512_vpdpbusd_256, 149962}, // __builtin_ia32_vpdpbusd256
+      {Intrinsic::x86_avx512_vpdpbusd_512, 149989}, // __builtin_ia32_vpdpbusd512
+      {Intrinsic::x86_avx512_vpdpbusds_128, 150016}, // __builtin_ia32_vpdpbusds128
+      {Intrinsic::x86_avx512_vpdpbusds_256, 150044}, // __builtin_ia32_vpdpbusds256
+      {Intrinsic::x86_avx512_vpdpbusds_512, 150072}, // __builtin_ia32_vpdpbusds512
+      {Intrinsic::x86_avx512_vpdpwssd_128, 150100}, // __builtin_ia32_vpdpwssd128
+      {Intrinsic::x86_avx512_vpdpwssd_256, 150127}, // __builtin_ia32_vpdpwssd256
+      {Intrinsic::x86_avx512_vpdpwssd_512, 150154}, // __builtin_ia32_vpdpwssd512
+      {Intrinsic::x86_avx512_vpdpwssds_128, 150181}, // __builtin_ia32_vpdpwssds128
+      {Intrinsic::x86_avx512_vpdpwssds_256, 150209}, // __builtin_ia32_vpdpwssds256
+      {Intrinsic::x86_avx512_vpdpwssds_512, 150237}, // __builtin_ia32_vpdpwssds512
+      {Intrinsic::x86_avx512_vpermi2var_d_128, 150265}, // __builtin_ia32_vpermi2vard128
+      {Intrinsic::x86_avx512_vpermi2var_d_256, 150295}, // __builtin_ia32_vpermi2vard256
+      {Intrinsic::x86_avx512_vpermi2var_d_512, 150325}, // __builtin_ia32_vpermi2vard512
+      {Intrinsic::x86_avx512_vpermi2var_hi_128, 150355}, // __builtin_ia32_vpermi2varhi128
+      {Intrinsic::x86_avx512_vpermi2var_hi_256, 150386}, // __builtin_ia32_vpermi2varhi256
+      {Intrinsic::x86_avx512_vpermi2var_hi_512, 150417}, // __builtin_ia32_vpermi2varhi512
+      {Intrinsic::x86_avx512_vpermi2var_pd_128, 150448}, // __builtin_ia32_vpermi2varpd128
+      {Intrinsic::x86_avx512_vpermi2var_pd_256, 150479}, // __builtin_ia32_vpermi2varpd256
+      {Intrinsic::x86_avx512_vpermi2var_pd_512, 150510}, // __builtin_ia32_vpermi2varpd512
+      {Intrinsic::x86_avx512_vpermi2var_ps_128, 150541}, // __builtin_ia32_vpermi2varps128
+      {Intrinsic::x86_avx512_vpermi2var_ps_256, 150572}, // __builtin_ia32_vpermi2varps256
+      {Intrinsic::x86_avx512_vpermi2var_ps_512, 150603}, // __builtin_ia32_vpermi2varps512
+      {Intrinsic::x86_avx512_vpermi2var_q_128, 150634}, // __builtin_ia32_vpermi2varq128
+      {Intrinsic::x86_avx512_vpermi2var_q_256, 150664}, // __builtin_ia32_vpermi2varq256
+      {Intrinsic::x86_avx512_vpermi2var_q_512, 150694}, // __builtin_ia32_vpermi2varq512
+      {Intrinsic::x86_avx512_vpermi2var_qi_128, 150724}, // __builtin_ia32_vpermi2varqi128
+      {Intrinsic::x86_avx512_vpermi2var_qi_256, 150755}, // __builtin_ia32_vpermi2varqi256
+      {Intrinsic::x86_avx512_vpermi2var_qi_512, 150786}, // __builtin_ia32_vpermi2varqi512
+      {Intrinsic::x86_xop_vpermil2pd, 160119}, // __builtin_ia32_vpermil2pd
+      {Intrinsic::x86_xop_vpermil2pd_256, 160145}, // __builtin_ia32_vpermil2pd256
+      {Intrinsic::x86_xop_vpermil2ps, 160174}, // __builtin_ia32_vpermil2ps
+      {Intrinsic::x86_xop_vpermil2ps_256, 160200}, // __builtin_ia32_vpermil2ps256
+      {Intrinsic::x86_avx_vpermilvar_pd, 135450}, // __builtin_ia32_vpermilvarpd
+      {Intrinsic::x86_avx_vpermilvar_pd_256, 135478}, // __builtin_ia32_vpermilvarpd256
+      {Intrinsic::x86_avx512_vpermilvar_pd_512, 150817}, // __builtin_ia32_vpermilvarpd512
+      {Intrinsic::x86_avx_vpermilvar_ps, 135509}, // __builtin_ia32_vpermilvarps
+      {Intrinsic::x86_avx_vpermilvar_ps_256, 135537}, // __builtin_ia32_vpermilvarps256
+      {Intrinsic::x86_avx512_vpermilvar_ps_512, 150848}, // __builtin_ia32_vpermilvarps512
+      {Intrinsic::x86_xop_vphaddbd, 160229}, // __builtin_ia32_vphaddbd
+      {Intrinsic::x86_xop_vphaddbq, 160253}, // __builtin_ia32_vphaddbq
+      {Intrinsic::x86_xop_vphaddbw, 160277}, // __builtin_ia32_vphaddbw
+      {Intrinsic::x86_xop_vphadddq, 160301}, // __builtin_ia32_vphadddq
+      {Intrinsic::x86_xop_vphaddubd, 160325}, // __builtin_ia32_vphaddubd
+      {Intrinsic::x86_xop_vphaddubq, 160350}, // __builtin_ia32_vphaddubq
+      {Intrinsic::x86_xop_vphaddubw, 160375}, // __builtin_ia32_vphaddubw
+      {Intrinsic::x86_xop_vphaddudq, 160400}, // __builtin_ia32_vphaddudq
+      {Intrinsic::x86_xop_vphadduwd, 160425}, // __builtin_ia32_vphadduwd
+      {Intrinsic::x86_xop_vphadduwq, 160450}, // __builtin_ia32_vphadduwq
+      {Intrinsic::x86_xop_vphaddwd, 160475}, // __builtin_ia32_vphaddwd
+      {Intrinsic::x86_xop_vphaddwq, 160499}, // __builtin_ia32_vphaddwq
+      {Intrinsic::x86_xop_vphsubbw, 160523}, // __builtin_ia32_vphsubbw
+      {Intrinsic::x86_xop_vphsubdq, 160547}, // __builtin_ia32_vphsubdq
+      {Intrinsic::x86_xop_vphsubwd, 160571}, // __builtin_ia32_vphsubwd
+      {Intrinsic::x86_xop_vpmacsdd, 160595}, // __builtin_ia32_vpmacsdd
+      {Intrinsic::x86_xop_vpmacsdqh, 160619}, // __builtin_ia32_vpmacsdqh
+      {Intrinsic::x86_xop_vpmacsdql, 160644}, // __builtin_ia32_vpmacsdql
+      {Intrinsic::x86_xop_vpmacssdd, 160669}, // __builtin_ia32_vpmacssdd
+      {Intrinsic::x86_xop_vpmacssdqh, 160694}, // __builtin_ia32_vpmacssdqh
+      {Intrinsic::x86_xop_vpmacssdql, 160720}, // __builtin_ia32_vpmacssdql
+      {Intrinsic::x86_xop_vpmacsswd, 160746}, // __builtin_ia32_vpmacsswd
+      {Intrinsic::x86_xop_vpmacssww, 160771}, // __builtin_ia32_vpmacssww
+      {Intrinsic::x86_xop_vpmacswd, 160796}, // __builtin_ia32_vpmacswd
+      {Intrinsic::x86_xop_vpmacsww, 160820}, // __builtin_ia32_vpmacsww
+      {Intrinsic::x86_xop_vpmadcsswd, 160844}, // __builtin_ia32_vpmadcsswd
+      {Intrinsic::x86_xop_vpmadcswd, 160870}, // __builtin_ia32_vpmadcswd
+      {Intrinsic::x86_avx512_vpmadd52h_uq_128, 150879}, // __builtin_ia32_vpmadd52huq128
+      {Intrinsic::x86_avx512_vpmadd52h_uq_256, 150909}, // __builtin_ia32_vpmadd52huq256
+      {Intrinsic::x86_avx512_vpmadd52h_uq_512, 150939}, // __builtin_ia32_vpmadd52huq512
+      {Intrinsic::x86_avx512_vpmadd52l_uq_128, 150969}, // __builtin_ia32_vpmadd52luq128
+      {Intrinsic::x86_avx512_vpmadd52l_uq_256, 150999}, // __builtin_ia32_vpmadd52luq256
+      {Intrinsic::x86_avx512_vpmadd52l_uq_512, 151029}, // __builtin_ia32_vpmadd52luq512
+      {Intrinsic::x86_avx512_pmultishift_qb_128, 147478}, // __builtin_ia32_vpmultishiftqb128
+      {Intrinsic::x86_avx512_pmultishift_qb_256, 147511}, // __builtin_ia32_vpmultishiftqb256
+      {Intrinsic::x86_avx512_pmultishift_qb_512, 147544}, // __builtin_ia32_vpmultishiftqb512
+      {Intrinsic::x86_xop_vpperm, 160895}, // __builtin_ia32_vpperm
+      {Intrinsic::x86_xop_vpshab, 160917}, // __builtin_ia32_vpshab
+      {Intrinsic::x86_xop_vpshad, 160939}, // __builtin_ia32_vpshad
+      {Intrinsic::x86_xop_vpshaq, 160961}, // __builtin_ia32_vpshaq
+      {Intrinsic::x86_xop_vpshaw, 160983}, // __builtin_ia32_vpshaw
+      {Intrinsic::x86_xop_vpshlb, 161005}, // __builtin_ia32_vpshlb
+      {Intrinsic::x86_xop_vpshld, 161027}, // __builtin_ia32_vpshld
+      {Intrinsic::x86_xop_vpshlq, 161049}, // __builtin_ia32_vpshlq
+      {Intrinsic::x86_xop_vpshlw, 161071}, // __builtin_ia32_vpshlw
+      {Intrinsic::x86_avx_vtestc_pd, 135568}, // __builtin_ia32_vtestcpd
+      {Intrinsic::x86_avx_vtestc_pd_256, 135592}, // __builtin_ia32_vtestcpd256
+      {Intrinsic::x86_avx_vtestc_ps, 135619}, // __builtin_ia32_vtestcps
+      {Intrinsic::x86_avx_vtestc_ps_256, 135643}, // __builtin_ia32_vtestcps256
+      {Intrinsic::x86_avx_vtestnzc_pd, 135670}, // __builtin_ia32_vtestnzcpd
+      {Intrinsic::x86_avx_vtestnzc_pd_256, 135696}, // __builtin_ia32_vtestnzcpd256
+      {Intrinsic::x86_avx_vtestnzc_ps, 135725}, // __builtin_ia32_vtestnzcps
+      {Intrinsic::x86_avx_vtestnzc_ps_256, 135751}, // __builtin_ia32_vtestnzcps256
+      {Intrinsic::x86_avx_vtestz_pd, 135780}, // __builtin_ia32_vtestzpd
+      {Intrinsic::x86_avx_vtestz_pd_256, 135804}, // __builtin_ia32_vtestzpd256
+      {Intrinsic::x86_avx_vtestz_ps, 135831}, // __builtin_ia32_vtestzps
+      {Intrinsic::x86_avx_vtestz_ps_256, 135855}, // __builtin_ia32_vtestzps256
+      {Intrinsic::x86_avx_vzeroall, 135882}, // __builtin_ia32_vzeroall
+      {Intrinsic::x86_avx_vzeroupper, 135906}, // __builtin_ia32_vzeroupper
+      {Intrinsic::x86_wbinvd, 159653}, // __builtin_ia32_wbinvd
+      {Intrinsic::x86_wbnoinvd, 159675}, // __builtin_ia32_wbnoinvd
+      {Intrinsic::x86_wrfsbase_32, 159699}, // __builtin_ia32_wrfsbase32
+      {Intrinsic::x86_wrfsbase_64, 159725}, // __builtin_ia32_wrfsbase64
+      {Intrinsic::x86_wrgsbase_32, 159751}, // __builtin_ia32_wrgsbase32
+      {Intrinsic::x86_wrgsbase_64, 159777}, // __builtin_ia32_wrgsbase64
+      {Intrinsic::x86_flags_write_u32, 151797}, // __builtin_ia32_writeeflags_u32
+      {Intrinsic::x86_flags_write_u64, 151828}, // __builtin_ia32_writeeflags_u64
+      {Intrinsic::x86_wrpkru, 159803}, // __builtin_ia32_wrpkru
+      {Intrinsic::x86_wrssd, 159825}, // __builtin_ia32_wrssd
+      {Intrinsic::x86_wrssq, 159846}, // __builtin_ia32_wrssq
+      {Intrinsic::x86_wrussd, 159867}, // __builtin_ia32_wrussd
+      {Intrinsic::x86_wrussq, 159889}, // __builtin_ia32_wrussq
+      {Intrinsic::x86_xabort, 159911}, // __builtin_ia32_xabort
+      {Intrinsic::x86_xbegin, 159933}, // __builtin_ia32_xbegin
+      {Intrinsic::x86_xend, 159955}, // __builtin_ia32_xend
+      {Intrinsic::x86_xresldtrk, 161093}, // __builtin_ia32_xresldtrk
+      {Intrinsic::x86_xsusldtrk, 161118}, // __builtin_ia32_xsusldtrk
+      {Intrinsic::x86_xtest, 161143}, // __builtin_ia32_xtest
     };
     auto I = std::lower_bound(std::begin(x86Names),
                               std::end(x86Names),
@@ -31242,10 +41646,10 @@
   }
   if (TargetPrefix == "xcore") {
     static const BuiltinEntry xcoreNames[] = {
-      {Intrinsic::xcore_bitrev, 127873}, // __builtin_bitrev
-      {Intrinsic::xcore_getid, 127890}, // __builtin_getid
-      {Intrinsic::xcore_getps, 127906}, // __builtin_getps
-      {Intrinsic::xcore_setps, 127922}, // __builtin_setps
+      {Intrinsic::xcore_bitrev, 161164}, // __builtin_bitrev
+      {Intrinsic::xcore_getid, 161181}, // __builtin_getid
+      {Intrinsic::xcore_getps, 161197}, // __builtin_getps
+      {Intrinsic::xcore_setps, 161213}, // __builtin_setps
     };
     auto I = std::lower_bound(std::begin(xcoreNames),
                               std::end(xcoreNames),
@@ -31316,9 +41720,3 @@
 }
 #endif
 
-#if defined(_MSC_VER) && defined(setjmp_undefined_for_msvc)
-// let's return it to _setjmp state
-#  pragma pop_macro("setjmp")
-#  undef setjmp_undefined_for_msvc
-#endif
-
diff --git a/linux-x64/clang/include/llvm/IR/IntrinsicInst.h b/linux-x64/clang/include/llvm/IR/IntrinsicInst.h
index 438bdb2..5250458 100644
--- a/linux-x64/clang/include/llvm/IR/IntrinsicInst.h
+++ b/linux-x64/clang/include/llvm/IR/IntrinsicInst.h
@@ -25,6 +25,7 @@
 
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DerivedTypes.h"
+#include "llvm/IR/FPEnv.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/GlobalVariable.h"
 #include "llvm/IR/Instructions.h"
@@ -37,850 +38,957 @@
 
 namespace llvm {
 
-  /// A wrapper class for inspecting calls to intrinsic functions.
-  /// This allows the standard isa/dyncast/cast functionality to work with calls
-  /// to intrinsic functions.
-  class IntrinsicInst : public CallInst {
-  public:
-    IntrinsicInst() = delete;
-    IntrinsicInst(const IntrinsicInst &) = delete;
-    IntrinsicInst &operator=(const IntrinsicInst &) = delete;
+/// A wrapper class for inspecting calls to intrinsic functions.
+/// This allows the standard isa/dyncast/cast functionality to work with calls
+/// to intrinsic functions.
+class IntrinsicInst : public CallInst {
+public:
+  IntrinsicInst() = delete;
+  IntrinsicInst(const IntrinsicInst &) = delete;
+  IntrinsicInst &operator=(const IntrinsicInst &) = delete;
 
-    /// Return the intrinsic ID of this intrinsic.
-    Intrinsic::ID getIntrinsicID() const {
-      return getCalledFunction()->getIntrinsicID();
-    }
+  /// Return the intrinsic ID of this intrinsic.
+  Intrinsic::ID getIntrinsicID() const {
+    return getCalledFunction()->getIntrinsicID();
+  }
 
-    // Methods for support type inquiry through isa, cast, and dyn_cast:
-    static bool classof(const CallInst *I) {
-      if (const Function *CF = I->getCalledFunction())
-        return CF->isIntrinsic();
+  /// Return true if swapping the first two arguments to the intrinsic produces
+  /// the same result.
+  bool isCommutative() const {
+    switch (getIntrinsicID()) {
+    case Intrinsic::maxnum:
+    case Intrinsic::minnum:
+    case Intrinsic::maximum:
+    case Intrinsic::minimum:
+    case Intrinsic::smax:
+    case Intrinsic::smin:
+    case Intrinsic::umax:
+    case Intrinsic::umin:
+    case Intrinsic::sadd_sat:
+    case Intrinsic::uadd_sat:
+    case Intrinsic::sadd_with_overflow:
+    case Intrinsic::uadd_with_overflow:
+    case Intrinsic::smul_with_overflow:
+    case Intrinsic::umul_with_overflow:
+    case Intrinsic::smul_fix:
+    case Intrinsic::umul_fix:
+    case Intrinsic::smul_fix_sat:
+    case Intrinsic::umul_fix_sat:
+    case Intrinsic::fma:
+    case Intrinsic::fmuladd:
+      return true;
+    default:
       return false;
     }
-    static bool classof(const Value *V) {
-      return isa<CallInst>(V) && classof(cast<CallInst>(V));
-    }
-  };
+  }
 
-  /// This is the common base class for debug info intrinsics.
-  class DbgInfoIntrinsic : public IntrinsicInst {
-  public:
-    /// \name Casting methods
-    /// @{
-    static bool classof(const IntrinsicInst *I) {
-      switch (I->getIntrinsicID()) {
-      case Intrinsic::dbg_declare:
-      case Intrinsic::dbg_value:
-      case Intrinsic::dbg_addr:
-      case Intrinsic::dbg_label:
-        return true;
-      default: return false;
-      }
-    }
-    static bool classof(const Value *V) {
-      return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
-    }
-    /// @}
-  };
+  // Methods for support type inquiry through isa, cast, and dyn_cast:
+  static bool classof(const CallInst *I) {
+    if (const Function *CF = I->getCalledFunction())
+      return CF->isIntrinsic();
+    return false;
+  }
+  static bool classof(const Value *V) {
+    return isa<CallInst>(V) && classof(cast<CallInst>(V));
+  }
+};
 
-  /// This is the common base class for debug info intrinsics for variables.
-  class DbgVariableIntrinsic : public DbgInfoIntrinsic {
-  public:
-    /// Get the location corresponding to the variable referenced by the debug
-    /// info intrinsic.  Depending on the intrinsic, this could be the
-    /// variable's value or its address.
-    Value *getVariableLocation(bool AllowNullOp = true) const;
+/// Check if \p ID corresponds to a debug info intrinsic.
+static inline bool isDbgInfoIntrinsic(Intrinsic::ID ID) {
+  switch (ID) {
+  case Intrinsic::dbg_declare:
+  case Intrinsic::dbg_value:
+  case Intrinsic::dbg_addr:
+  case Intrinsic::dbg_label:
+    return true;
+  default:
+    return false;
+  }
+}
 
-    /// Does this describe the address of a local variable. True for dbg.addr
-    /// and dbg.declare, but not dbg.value, which describes its value.
-    bool isAddressOfVariable() const {
-      return getIntrinsicID() != Intrinsic::dbg_value;
-    }
+/// This is the common base class for debug info intrinsics.
+class DbgInfoIntrinsic : public IntrinsicInst {
+public:
+  /// \name Casting methods
+  /// @{
+  static bool classof(const IntrinsicInst *I) {
+    return isDbgInfoIntrinsic(I->getIntrinsicID());
+  }
+  static bool classof(const Value *V) {
+    return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
+  }
+  /// @}
+};
 
-    DILocalVariable *getVariable() const {
-      return cast<DILocalVariable>(getRawVariable());
-    }
+/// This is the common base class for debug info intrinsics for variables.
+class DbgVariableIntrinsic : public DbgInfoIntrinsic {
+public:
+  /// Get the location corresponding to the variable referenced by the debug
+  /// info intrinsic.  Depending on the intrinsic, this could be the
+  /// variable's value or its address.
+  Value *getVariableLocation(bool AllowNullOp = true) const;
 
-    DIExpression *getExpression() const {
-      return cast<DIExpression>(getRawExpression());
-    }
+  /// Does this describe the address of a local variable. True for dbg.addr
+  /// and dbg.declare, but not dbg.value, which describes its value.
+  bool isAddressOfVariable() const {
+    return getIntrinsicID() != Intrinsic::dbg_value;
+  }
 
-    Metadata *getRawVariable() const {
-      return cast<MetadataAsValue>(getArgOperand(1))->getMetadata();
-    }
+  DILocalVariable *getVariable() const {
+    return cast<DILocalVariable>(getRawVariable());
+  }
 
-    Metadata *getRawExpression() const {
-      return cast<MetadataAsValue>(getArgOperand(2))->getMetadata();
-    }
+  DIExpression *getExpression() const {
+    return cast<DIExpression>(getRawExpression());
+  }
 
-    /// Get the size (in bits) of the variable, or fragment of the variable that
-    /// is described.
-    Optional<uint64_t> getFragmentSizeInBits() const;
+  Metadata *getRawVariable() const {
+    return cast<MetadataAsValue>(getArgOperand(1))->getMetadata();
+  }
 
-    /// \name Casting methods
-    /// @{
-    static bool classof(const IntrinsicInst *I) {
-      switch (I->getIntrinsicID()) {
-      case Intrinsic::dbg_declare:
-      case Intrinsic::dbg_value:
-      case Intrinsic::dbg_addr:
-        return true;
-      default: return false;
-      }
-    }
-    static bool classof(const Value *V) {
-      return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
-    }
-    /// @}
-  };
+  Metadata *getRawExpression() const {
+    return cast<MetadataAsValue>(getArgOperand(2))->getMetadata();
+  }
 
-  /// This represents the llvm.dbg.declare instruction.
-  class DbgDeclareInst : public DbgVariableIntrinsic {
-  public:
-    Value *getAddress() const { return getVariableLocation(); }
+  /// Get the size (in bits) of the variable, or fragment of the variable that
+  /// is described.
+  Optional<uint64_t> getFragmentSizeInBits() const;
 
-    /// \name Casting methods
-    /// @{
-    static bool classof(const IntrinsicInst *I) {
-      return I->getIntrinsicID() == Intrinsic::dbg_declare;
-    }
-    static bool classof(const Value *V) {
-      return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
-    }
-    /// @}
-  };
-
-  /// This represents the llvm.dbg.addr instruction.
-  class DbgAddrIntrinsic : public DbgVariableIntrinsic {
-  public:
-    Value *getAddress() const { return getVariableLocation(); }
-
-    /// \name Casting methods
-    /// @{
-    static bool classof(const IntrinsicInst *I) {
-      return I->getIntrinsicID() == Intrinsic::dbg_addr;
-    }
-    static bool classof(const Value *V) {
-      return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
-    }
-  };
-
-  /// This represents the llvm.dbg.value instruction.
-  class DbgValueInst : public DbgVariableIntrinsic {
-  public:
-    Value *getValue() const {
-      return getVariableLocation(/* AllowNullOp = */ false);
-    }
-
-    /// \name Casting methods
-    /// @{
-    static bool classof(const IntrinsicInst *I) {
-      return I->getIntrinsicID() == Intrinsic::dbg_value;
-    }
-    static bool classof(const Value *V) {
-      return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
-    }
-    /// @}
-  };
-
-  /// This represents the llvm.dbg.label instruction.
-  class DbgLabelInst : public DbgInfoIntrinsic {
-  public:
-    DILabel *getLabel() const {
-      return cast<DILabel>(getRawLabel());
-    }
-
-    Metadata *getRawLabel() const {
-      return cast<MetadataAsValue>(getArgOperand(0))->getMetadata();
-    }
-
-    /// Methods for support type inquiry through isa, cast, and dyn_cast:
-    /// @{
-    static bool classof(const IntrinsicInst *I) {
-      return I->getIntrinsicID() == Intrinsic::dbg_label;
-    }
-    static bool classof(const Value *V) {
-      return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
-    }
-    /// @}
-  };
-
-  /// This is the common base class for constrained floating point intrinsics.
-  class ConstrainedFPIntrinsic : public IntrinsicInst {
-  public:
-    /// Specifies the rounding mode to be assumed. This is only used when
-    /// when constrained floating point is enabled. See the LLVM Language
-    /// Reference Manual for details.
-    enum RoundingMode : uint8_t {
-      rmDynamic,         ///< This corresponds to "fpround.dynamic".
-      rmToNearest,       ///< This corresponds to "fpround.tonearest".
-      rmDownward,        ///< This corresponds to "fpround.downward".
-      rmUpward,          ///< This corresponds to "fpround.upward".
-      rmTowardZero       ///< This corresponds to "fpround.tozero".
-    };
-
-    /// Specifies the required exception behavior. This is only used when
-    /// when constrained floating point is used. See the LLVM Language
-    /// Reference Manual for details.
-    enum ExceptionBehavior : uint8_t {
-      ebIgnore,          ///< This corresponds to "fpexcept.ignore".
-      ebMayTrap,         ///< This corresponds to "fpexcept.maytrap".
-      ebStrict           ///< This corresponds to "fpexcept.strict".
-    };
-
-    bool isUnaryOp() const;
-    bool isTernaryOp() const;
-    Optional<RoundingMode> getRoundingMode() const;
-    Optional<ExceptionBehavior> getExceptionBehavior() const;
-
-    /// Returns a valid RoundingMode enumerator when given a string
-    /// that is valid as input in constrained intrinsic rounding mode
-    /// metadata.
-    static Optional<RoundingMode> StrToRoundingMode(StringRef);
-
-    /// For any RoundingMode enumerator, returns a string valid as input in
-    /// constrained intrinsic rounding mode metadata.
-    static Optional<StringRef> RoundingModeToStr(RoundingMode);
-
-    /// Returns a valid ExceptionBehavior enumerator when given a string
-    /// valid as input in constrained intrinsic exception behavior metadata.
-    static Optional<ExceptionBehavior> StrToExceptionBehavior(StringRef);
-
-    /// For any ExceptionBehavior enumerator, returns a string valid as 
-    /// input in constrained intrinsic exception behavior metadata.
-    static Optional<StringRef> ExceptionBehaviorToStr(ExceptionBehavior);
-
-    // Methods for support type inquiry through isa, cast, and dyn_cast:
-    static bool classof(const IntrinsicInst *I) {
-      switch (I->getIntrinsicID()) {
-      case Intrinsic::experimental_constrained_fadd:
-      case Intrinsic::experimental_constrained_fsub:
-      case Intrinsic::experimental_constrained_fmul:
-      case Intrinsic::experimental_constrained_fdiv:
-      case Intrinsic::experimental_constrained_frem:
-      case Intrinsic::experimental_constrained_fma:
-      case Intrinsic::experimental_constrained_fptrunc:
-      case Intrinsic::experimental_constrained_fpext:
-      case Intrinsic::experimental_constrained_sqrt:
-      case Intrinsic::experimental_constrained_pow:
-      case Intrinsic::experimental_constrained_powi:
-      case Intrinsic::experimental_constrained_sin:
-      case Intrinsic::experimental_constrained_cos:
-      case Intrinsic::experimental_constrained_exp:
-      case Intrinsic::experimental_constrained_exp2:
-      case Intrinsic::experimental_constrained_log:
-      case Intrinsic::experimental_constrained_log10:
-      case Intrinsic::experimental_constrained_log2:
-      case Intrinsic::experimental_constrained_rint:
-      case Intrinsic::experimental_constrained_nearbyint:
-      case Intrinsic::experimental_constrained_maxnum:
-      case Intrinsic::experimental_constrained_minnum:
-      case Intrinsic::experimental_constrained_ceil:
-      case Intrinsic::experimental_constrained_floor:
-      case Intrinsic::experimental_constrained_round:
-      case Intrinsic::experimental_constrained_trunc:
-        return true;
-      default: return false;
-      }
-    }
-    static bool classof(const Value *V) {
-      return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
-    }
-  };
-
-  /// This class represents an intrinsic that is based on a binary operation.
-  /// This includes op.with.overflow and saturating add/sub intrinsics.
-  class BinaryOpIntrinsic : public IntrinsicInst {
-  public:
-    static bool classof(const IntrinsicInst *I) {
-      switch (I->getIntrinsicID()) {
-      case Intrinsic::uadd_with_overflow:
-      case Intrinsic::sadd_with_overflow:
-      case Intrinsic::usub_with_overflow:
-      case Intrinsic::ssub_with_overflow:
-      case Intrinsic::umul_with_overflow:
-      case Intrinsic::smul_with_overflow:
-      case Intrinsic::uadd_sat:
-      case Intrinsic::sadd_sat:
-      case Intrinsic::usub_sat:
-      case Intrinsic::ssub_sat:
-        return true;
-      default:
-        return false;
-      }
-    }
-    static bool classof(const Value *V) {
-      return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
-    }
-
-    Value *getLHS() const { return const_cast<Value*>(getArgOperand(0)); }
-    Value *getRHS() const { return const_cast<Value*>(getArgOperand(1)); }
-
-    /// Returns the binary operation underlying the intrinsic.
-    Instruction::BinaryOps getBinaryOp() const;
-
-    /// Whether the intrinsic is signed or unsigned.
-    bool isSigned() const;
-
-    /// Returns one of OBO::NoSignedWrap or OBO::NoUnsignedWrap.
-    unsigned getNoWrapKind() const;
-  };
-
-  /// Represents an op.with.overflow intrinsic.
-  class WithOverflowInst : public BinaryOpIntrinsic {
-  public:
-    static bool classof(const IntrinsicInst *I) {
-      switch (I->getIntrinsicID()) {
-      case Intrinsic::uadd_with_overflow:
-      case Intrinsic::sadd_with_overflow:
-      case Intrinsic::usub_with_overflow:
-      case Intrinsic::ssub_with_overflow:
-      case Intrinsic::umul_with_overflow:
-      case Intrinsic::smul_with_overflow:
-        return true;
-      default:
-        return false;
-      }
-    }
-    static bool classof(const Value *V) {
-      return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
-    }
-  };
-
-  /// Represents a saturating add/sub intrinsic.
-  class SaturatingInst : public BinaryOpIntrinsic {
-  public:
-    static bool classof(const IntrinsicInst *I) {
-      switch (I->getIntrinsicID()) {
-      case Intrinsic::uadd_sat:
-      case Intrinsic::sadd_sat:
-      case Intrinsic::usub_sat:
-      case Intrinsic::ssub_sat:
-        return true;
-      default:
-        return false;
-      }
-    }
-    static bool classof(const Value *V) {
-      return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
-    }
-  };
-
-  /// Common base class for all memory intrinsics. Simply provides
-  /// common methods.
-  /// Written as CRTP to avoid a common base class amongst the
-  /// three atomicity hierarchies.
-  template <typename Derived> class MemIntrinsicBase : public IntrinsicInst {
-  private:
-    enum { ARG_DEST = 0, ARG_LENGTH = 2 };
-
-  public:
-    Value *getRawDest() const {
-      return const_cast<Value *>(getArgOperand(ARG_DEST));
-    }
-    const Use &getRawDestUse() const { return getArgOperandUse(ARG_DEST); }
-    Use &getRawDestUse() { return getArgOperandUse(ARG_DEST); }
-
-    Value *getLength() const {
-      return const_cast<Value *>(getArgOperand(ARG_LENGTH));
-    }
-    const Use &getLengthUse() const { return getArgOperandUse(ARG_LENGTH); }
-    Use &getLengthUse() { return getArgOperandUse(ARG_LENGTH); }
-
-    /// This is just like getRawDest, but it strips off any cast
-    /// instructions (including addrspacecast) that feed it, giving the
-    /// original input.  The returned value is guaranteed to be a pointer.
-    Value *getDest() const { return getRawDest()->stripPointerCasts(); }
-
-    unsigned getDestAddressSpace() const {
-      return cast<PointerType>(getRawDest()->getType())->getAddressSpace();
-    }
-
-    unsigned getDestAlignment() const { return getParamAlignment(ARG_DEST); }
-
-    /// Set the specified arguments of the instruction.
-    void setDest(Value *Ptr) {
-      assert(getRawDest()->getType() == Ptr->getType() &&
-             "setDest called with pointer of wrong type!");
-      setArgOperand(ARG_DEST, Ptr);
-    }
-
-    void setDestAlignment(unsigned Align) {
-      removeParamAttr(ARG_DEST, Attribute::Alignment);
-      if (Align > 0)
-        addParamAttr(ARG_DEST,
-                     Attribute::getWithAlignment(getContext(), Align));
-    }
-
-    void setLength(Value *L) {
-      assert(getLength()->getType() == L->getType() &&
-             "setLength called with value of wrong type!");
-      setArgOperand(ARG_LENGTH, L);
-    }
-  };
-
-  /// Common base class for all memory transfer intrinsics. Simply provides
-  /// common methods.
-  template <class BaseCL> class MemTransferBase : public BaseCL {
-  private:
-    enum { ARG_SOURCE = 1 };
-
-  public:
-    /// Return the arguments to the instruction.
-    Value *getRawSource() const {
-      return const_cast<Value *>(BaseCL::getArgOperand(ARG_SOURCE));
-    }
-    const Use &getRawSourceUse() const {
-      return BaseCL::getArgOperandUse(ARG_SOURCE);
-    }
-    Use &getRawSourceUse() { return BaseCL::getArgOperandUse(ARG_SOURCE); }
-
-    /// This is just like getRawSource, but it strips off any cast
-    /// instructions that feed it, giving the original input.  The returned
-    /// value is guaranteed to be a pointer.
-    Value *getSource() const { return getRawSource()->stripPointerCasts(); }
-
-    unsigned getSourceAddressSpace() const {
-      return cast<PointerType>(getRawSource()->getType())->getAddressSpace();
-    }
-
-    unsigned getSourceAlignment() const {
-      return BaseCL::getParamAlignment(ARG_SOURCE);
-    }
-
-    void setSource(Value *Ptr) {
-      assert(getRawSource()->getType() == Ptr->getType() &&
-             "setSource called with pointer of wrong type!");
-      BaseCL::setArgOperand(ARG_SOURCE, Ptr);
-    }
-
-    void setSourceAlignment(unsigned Align) {
-      BaseCL::removeParamAttr(ARG_SOURCE, Attribute::Alignment);
-      if (Align > 0)
-        BaseCL::addParamAttr(ARG_SOURCE, Attribute::getWithAlignment(
-                                             BaseCL::getContext(), Align));
-    }
-  };
-
-  /// Common base class for all memset intrinsics. Simply provides
-  /// common methods.
-  template <class BaseCL> class MemSetBase : public BaseCL {
-  private:
-    enum { ARG_VALUE = 1 };
-
-  public:
-    Value *getValue() const {
-      return const_cast<Value *>(BaseCL::getArgOperand(ARG_VALUE));
-    }
-    const Use &getValueUse() const {
-      return BaseCL::getArgOperandUse(ARG_VALUE);
-    }
-    Use &getValueUse() { return BaseCL::getArgOperandUse(ARG_VALUE); }
-
-    void setValue(Value *Val) {
-      assert(getValue()->getType() == Val->getType() &&
-             "setValue called with value of wrong type!");
-      BaseCL::setArgOperand(ARG_VALUE, Val);
-    }
-  };
-
-  // The common base class for the atomic memset/memmove/memcpy intrinsics
-  // i.e. llvm.element.unordered.atomic.memset/memcpy/memmove
-  class AtomicMemIntrinsic : public MemIntrinsicBase<AtomicMemIntrinsic> {
-  private:
-    enum { ARG_ELEMENTSIZE = 3 };
-
-  public:
-    Value *getRawElementSizeInBytes() const {
-      return const_cast<Value *>(getArgOperand(ARG_ELEMENTSIZE));
-    }
-
-    ConstantInt *getElementSizeInBytesCst() const {
-      return cast<ConstantInt>(getRawElementSizeInBytes());
-    }
-
-    uint32_t getElementSizeInBytes() const {
-      return getElementSizeInBytesCst()->getZExtValue();
-    }
-
-    void setElementSizeInBytes(Constant *V) {
-      assert(V->getType() == Type::getInt8Ty(getContext()) &&
-             "setElementSizeInBytes called with value of wrong type!");
-      setArgOperand(ARG_ELEMENTSIZE, V);
-    }
-
-    static bool classof(const IntrinsicInst *I) {
-      switch (I->getIntrinsicID()) {
-      case Intrinsic::memcpy_element_unordered_atomic:
-      case Intrinsic::memmove_element_unordered_atomic:
-      case Intrinsic::memset_element_unordered_atomic:
-        return true;
-      default:
-        return false;
-      }
-    }
-    static bool classof(const Value *V) {
-      return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
-    }
-  };
-
-  /// This class represents atomic memset intrinsic
-  // i.e. llvm.element.unordered.atomic.memset
-  class AtomicMemSetInst : public MemSetBase<AtomicMemIntrinsic> {
-  public:
-    static bool classof(const IntrinsicInst *I) {
-      return I->getIntrinsicID() == Intrinsic::memset_element_unordered_atomic;
-    }
-    static bool classof(const Value *V) {
-      return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
-    }
-  };
-
-  // This class wraps the atomic memcpy/memmove intrinsics
-  // i.e. llvm.element.unordered.atomic.memcpy/memmove
-  class AtomicMemTransferInst : public MemTransferBase<AtomicMemIntrinsic> {
-  public:
-    static bool classof(const IntrinsicInst *I) {
-      switch (I->getIntrinsicID()) {
-      case Intrinsic::memcpy_element_unordered_atomic:
-      case Intrinsic::memmove_element_unordered_atomic:
-        return true;
-      default:
-        return false;
-      }
-    }
-    static bool classof(const Value *V) {
-      return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
-    }
-  };
-
-  /// This class represents the atomic memcpy intrinsic
-  /// i.e. llvm.element.unordered.atomic.memcpy
-  class AtomicMemCpyInst : public AtomicMemTransferInst {
-  public:
-    static bool classof(const IntrinsicInst *I) {
-      return I->getIntrinsicID() == Intrinsic::memcpy_element_unordered_atomic;
-    }
-    static bool classof(const Value *V) {
-      return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
-    }
-  };
-
-  /// This class represents the atomic memmove intrinsic
-  /// i.e. llvm.element.unordered.atomic.memmove
-  class AtomicMemMoveInst : public AtomicMemTransferInst {
-  public:
-    static bool classof(const IntrinsicInst *I) {
-      return I->getIntrinsicID() == Intrinsic::memmove_element_unordered_atomic;
-    }
-    static bool classof(const Value *V) {
-      return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
-    }
-  };
-
-  /// This is the common base class for memset/memcpy/memmove.
-  class MemIntrinsic : public MemIntrinsicBase<MemIntrinsic> {
-  private:
-    enum { ARG_VOLATILE = 3 };
-
-  public:
-    ConstantInt *getVolatileCst() const {
-      return cast<ConstantInt>(
-          const_cast<Value *>(getArgOperand(ARG_VOLATILE)));
-    }
-
-    bool isVolatile() const {
-      return !getVolatileCst()->isZero();
-    }
-
-    void setVolatile(Constant *V) { setArgOperand(ARG_VOLATILE, V); }
-
-    // Methods for support type inquiry through isa, cast, and dyn_cast:
-    static bool classof(const IntrinsicInst *I) {
-      switch (I->getIntrinsicID()) {
-      case Intrinsic::memcpy:
-      case Intrinsic::memmove:
-      case Intrinsic::memset:
-        return true;
-      default: return false;
-      }
-    }
-    static bool classof(const Value *V) {
-      return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
-    }
-  };
-
-  /// This class wraps the llvm.memset intrinsic.
-  class MemSetInst : public MemSetBase<MemIntrinsic> {
-  public:
-    // Methods for support type inquiry through isa, cast, and dyn_cast:
-    static bool classof(const IntrinsicInst *I) {
-      return I->getIntrinsicID() == Intrinsic::memset;
-    }
-    static bool classof(const Value *V) {
-      return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
-    }
-  };
-
-  /// This class wraps the llvm.memcpy/memmove intrinsics.
-  class MemTransferInst : public MemTransferBase<MemIntrinsic> {
-  public:
-    // Methods for support type inquiry through isa, cast, and dyn_cast:
-    static bool classof(const IntrinsicInst *I) {
-      return I->getIntrinsicID() == Intrinsic::memcpy ||
-             I->getIntrinsicID() == Intrinsic::memmove;
-    }
-    static bool classof(const Value *V) {
-      return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
-    }
-  };
-
-  /// This class wraps the llvm.memcpy intrinsic.
-  class MemCpyInst : public MemTransferInst {
-  public:
-    // Methods for support type inquiry through isa, cast, and dyn_cast:
-    static bool classof(const IntrinsicInst *I) {
-      return I->getIntrinsicID() == Intrinsic::memcpy;
-    }
-    static bool classof(const Value *V) {
-      return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
-    }
-  };
-
-  /// This class wraps the llvm.memmove intrinsic.
-  class MemMoveInst : public MemTransferInst {
-  public:
-    // Methods for support type inquiry through isa, cast, and dyn_cast:
-    static bool classof(const IntrinsicInst *I) {
-      return I->getIntrinsicID() == Intrinsic::memmove;
-    }
-    static bool classof(const Value *V) {
-      return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
-    }
-  };
-
-  // The common base class for any memset/memmove/memcpy intrinsics;
-  // whether they be atomic or non-atomic.
-  // i.e. llvm.element.unordered.atomic.memset/memcpy/memmove
-  //  and llvm.memset/memcpy/memmove
-  class AnyMemIntrinsic : public MemIntrinsicBase<AnyMemIntrinsic> {
-  public:
-    bool isVolatile() const {
-      // Only the non-atomic intrinsics can be volatile
-      if (auto *MI = dyn_cast<MemIntrinsic>(this))
-        return MI->isVolatile();
+  /// \name Casting methods
+  /// @{
+  static bool classof(const IntrinsicInst *I) {
+    switch (I->getIntrinsicID()) {
+    case Intrinsic::dbg_declare:
+    case Intrinsic::dbg_value:
+    case Intrinsic::dbg_addr:
+      return true;
+    default:
       return false;
     }
+  }
+  static bool classof(const Value *V) {
+    return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
+  }
+  /// @}
+};
 
-    static bool classof(const IntrinsicInst *I) {
-      switch (I->getIntrinsicID()) {
-      case Intrinsic::memcpy:
-      case Intrinsic::memmove:
-      case Intrinsic::memset:
-      case Intrinsic::memcpy_element_unordered_atomic:
-      case Intrinsic::memmove_element_unordered_atomic:
-      case Intrinsic::memset_element_unordered_atomic:
-        return true;
-      default:
-        return false;
-      }
-    }
-    static bool classof(const Value *V) {
-      return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
-    }
-  };
+/// This represents the llvm.dbg.declare instruction.
+class DbgDeclareInst : public DbgVariableIntrinsic {
+public:
+  Value *getAddress() const { return getVariableLocation(); }
 
-  /// This class represents any memset intrinsic
-  // i.e. llvm.element.unordered.atomic.memset
-  // and  llvm.memset
-  class AnyMemSetInst : public MemSetBase<AnyMemIntrinsic> {
-  public:
-    static bool classof(const IntrinsicInst *I) {
-      switch (I->getIntrinsicID()) {
-      case Intrinsic::memset:
-      case Intrinsic::memset_element_unordered_atomic:
-        return true;
-      default:
-        return false;
-      }
-    }
-    static bool classof(const Value *V) {
-      return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
-    }
-  };
+  /// \name Casting methods
+  /// @{
+  static bool classof(const IntrinsicInst *I) {
+    return I->getIntrinsicID() == Intrinsic::dbg_declare;
+  }
+  static bool classof(const Value *V) {
+    return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
+  }
+  /// @}
+};
 
-  // This class wraps any memcpy/memmove intrinsics
-  // i.e. llvm.element.unordered.atomic.memcpy/memmove
-  // and  llvm.memcpy/memmove
-  class AnyMemTransferInst : public MemTransferBase<AnyMemIntrinsic> {
-  public:
-    static bool classof(const IntrinsicInst *I) {
-      switch (I->getIntrinsicID()) {
-      case Intrinsic::memcpy:
-      case Intrinsic::memmove:
-      case Intrinsic::memcpy_element_unordered_atomic:
-      case Intrinsic::memmove_element_unordered_atomic:
-        return true;
-      default:
-        return false;
-      }
-    }
-    static bool classof(const Value *V) {
-      return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
-    }
-  };
+/// This represents the llvm.dbg.addr instruction.
+class DbgAddrIntrinsic : public DbgVariableIntrinsic {
+public:
+  Value *getAddress() const { return getVariableLocation(); }
 
-  /// This class represents any memcpy intrinsic
-  /// i.e. llvm.element.unordered.atomic.memcpy
-  ///  and llvm.memcpy
-  class AnyMemCpyInst : public AnyMemTransferInst {
-  public:
-    static bool classof(const IntrinsicInst *I) {
-      switch (I->getIntrinsicID()) {
-      case Intrinsic::memcpy:
-      case Intrinsic::memcpy_element_unordered_atomic:
-        return true;
-      default:
-        return false;
-      }
-    }
-    static bool classof(const Value *V) {
-      return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
-    }
-  };
+  /// \name Casting methods
+  /// @{
+  static bool classof(const IntrinsicInst *I) {
+    return I->getIntrinsicID() == Intrinsic::dbg_addr;
+  }
+  static bool classof(const Value *V) {
+    return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
+  }
+};
 
-  /// This class represents any memmove intrinsic
-  /// i.e. llvm.element.unordered.atomic.memmove
-  ///  and llvm.memmove
-  class AnyMemMoveInst : public AnyMemTransferInst {
-  public:
-    static bool classof(const IntrinsicInst *I) {
-      switch (I->getIntrinsicID()) {
-      case Intrinsic::memmove:
-      case Intrinsic::memmove_element_unordered_atomic:
-        return true;
-      default:
-        return false;
-      }
-    }
-    static bool classof(const Value *V) {
-      return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
-    }
-  };
+/// This represents the llvm.dbg.value instruction.
+class DbgValueInst : public DbgVariableIntrinsic {
+public:
+  Value *getValue() const {
+    return getVariableLocation(/* AllowNullOp = */ false);
+  }
 
-  /// This represents the llvm.va_start intrinsic.
-  class VAStartInst : public IntrinsicInst {
-  public:
-    static bool classof(const IntrinsicInst *I) {
-      return I->getIntrinsicID() == Intrinsic::vastart;
-    }
-    static bool classof(const Value *V) {
-      return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
-    }
+  /// \name Casting methods
+  /// @{
+  static bool classof(const IntrinsicInst *I) {
+    return I->getIntrinsicID() == Intrinsic::dbg_value;
+  }
+  static bool classof(const Value *V) {
+    return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
+  }
+  /// @}
+};
 
-    Value *getArgList() const { return const_cast<Value*>(getArgOperand(0)); }
-  };
+/// This represents the llvm.dbg.label instruction.
+class DbgLabelInst : public DbgInfoIntrinsic {
+public:
+  DILabel *getLabel() const { return cast<DILabel>(getRawLabel()); }
 
-  /// This represents the llvm.va_end intrinsic.
-  class VAEndInst : public IntrinsicInst {
-  public:
-    static bool classof(const IntrinsicInst *I) {
-      return I->getIntrinsicID() == Intrinsic::vaend;
-    }
-    static bool classof(const Value *V) {
-      return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
-    }
+  Metadata *getRawLabel() const {
+    return cast<MetadataAsValue>(getArgOperand(0))->getMetadata();
+  }
 
-    Value *getArgList() const { return const_cast<Value*>(getArgOperand(0)); }
-  };
+  /// Methods for support type inquiry through isa, cast, and dyn_cast:
+  /// @{
+  static bool classof(const IntrinsicInst *I) {
+    return I->getIntrinsicID() == Intrinsic::dbg_label;
+  }
+  static bool classof(const Value *V) {
+    return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
+  }
+  /// @}
+};
 
-  /// This represents the llvm.va_copy intrinsic.
-  class VACopyInst : public IntrinsicInst {
-  public:
-    static bool classof(const IntrinsicInst *I) {
-      return I->getIntrinsicID() == Intrinsic::vacopy;
-    }
-    static bool classof(const Value *V) {
-      return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
-    }
+/// This is the common base class for vector predication intrinsics.
+class VPIntrinsic : public IntrinsicInst {
+public:
+  static Optional<int> GetMaskParamPos(Intrinsic::ID IntrinsicID);
+  static Optional<int> GetVectorLengthParamPos(Intrinsic::ID IntrinsicID);
 
-    Value *getDest() const { return const_cast<Value*>(getArgOperand(0)); }
-    Value *getSrc() const { return const_cast<Value*>(getArgOperand(1)); }
-  };
+  /// The llvm.vp.* intrinsics for this instruction Opcode
+  static Intrinsic::ID GetForOpcode(unsigned OC);
 
-  /// This represents the llvm.instrprof_increment intrinsic.
-  class InstrProfIncrementInst : public IntrinsicInst {
-  public:
-    static bool classof(const IntrinsicInst *I) {
-      return I->getIntrinsicID() == Intrinsic::instrprof_increment;
-    }
-    static bool classof(const Value *V) {
-      return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
-    }
+  // Whether \p ID is a VP intrinsic ID.
+  static bool IsVPIntrinsic(Intrinsic::ID);
 
-    GlobalVariable *getName() const {
-      return cast<GlobalVariable>(
-          const_cast<Value *>(getArgOperand(0))->stripPointerCasts());
-    }
+  /// \return the mask parameter or nullptr.
+  Value *getMaskParam() const;
 
-    ConstantInt *getHash() const {
-      return cast<ConstantInt>(const_cast<Value *>(getArgOperand(1)));
-    }
+  /// \return the vector length parameter or nullptr.
+  Value *getVectorLengthParam() const;
 
-    ConstantInt *getNumCounters() const {
-      return cast<ConstantInt>(const_cast<Value *>(getArgOperand(2)));
-    }
+  /// \return whether the vector length param can be ignored.
+  bool canIgnoreVectorLengthParam() const;
 
-    ConstantInt *getIndex() const {
-      return cast<ConstantInt>(const_cast<Value *>(getArgOperand(3)));
-    }
+  /// \return the static element count (vector number of elements) the vector
+  /// length parameter applies to.
+  ElementCount getStaticVectorLength() const;
 
-    Value *getStep() const;
-  };
+  // Methods for support type inquiry through isa, cast, and dyn_cast:
+  static bool classof(const IntrinsicInst *I) {
+    return IsVPIntrinsic(I->getIntrinsicID());
+  }
+  static bool classof(const Value *V) {
+    return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
+  }
 
-  class InstrProfIncrementInstStep : public InstrProfIncrementInst {
-  public:
-    static bool classof(const IntrinsicInst *I) {
-      return I->getIntrinsicID() == Intrinsic::instrprof_increment_step;
-    }
-    static bool classof(const Value *V) {
-      return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
-    }
-  };
+  // Equivalent non-predicated opcode
+  unsigned getFunctionalOpcode() const {
+    return GetFunctionalOpcodeForVP(getIntrinsicID());
+  }
 
-  /// This represents the llvm.instrprof_value_profile intrinsic.
-  class InstrProfValueProfileInst : public IntrinsicInst {
-  public:
-    static bool classof(const IntrinsicInst *I) {
-      return I->getIntrinsicID() == Intrinsic::instrprof_value_profile;
-    }
-    static bool classof(const Value *V) {
-      return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
-    }
+  // Equivalent non-predicated opcode
+  static unsigned GetFunctionalOpcodeForVP(Intrinsic::ID ID);
+};
 
-    GlobalVariable *getName() const {
-      return cast<GlobalVariable>(
-          const_cast<Value *>(getArgOperand(0))->stripPointerCasts());
-    }
+/// This is the common base class for constrained floating point intrinsics.
+class ConstrainedFPIntrinsic : public IntrinsicInst {
+public:
+  bool isUnaryOp() const;
+  bool isTernaryOp() const;
+  Optional<RoundingMode> getRoundingMode() const;
+  Optional<fp::ExceptionBehavior> getExceptionBehavior() const;
 
-    ConstantInt *getHash() const {
-      return cast<ConstantInt>(const_cast<Value *>(getArgOperand(1)));
-    }
+  // Methods for support type inquiry through isa, cast, and dyn_cast:
+  static bool classof(const IntrinsicInst *I);
+  static bool classof(const Value *V) {
+    return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
+  }
+};
 
-    Value *getTargetValue() const {
-      return cast<Value>(const_cast<Value *>(getArgOperand(2)));
-    }
+/// Constrained floating point compare intrinsics.
+class ConstrainedFPCmpIntrinsic : public ConstrainedFPIntrinsic {
+public:
+  FCmpInst::Predicate getPredicate() const;
 
-    ConstantInt *getValueKind() const {
-      return cast<ConstantInt>(const_cast<Value *>(getArgOperand(3)));
+  // Methods for support type inquiry through isa, cast, and dyn_cast:
+  static bool classof(const IntrinsicInst *I) {
+    switch (I->getIntrinsicID()) {
+    case Intrinsic::experimental_constrained_fcmp:
+    case Intrinsic::experimental_constrained_fcmps:
+      return true;
+    default:
+      return false;
     }
+  }
+  static bool classof(const Value *V) {
+    return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
+  }
+};
 
-    // Returns the value site index.
-    ConstantInt *getIndex() const {
-      return cast<ConstantInt>(const_cast<Value *>(getArgOperand(4)));
+/// This class represents an intrinsic that is based on a binary operation.
+/// This includes op.with.overflow and saturating add/sub intrinsics.
+class BinaryOpIntrinsic : public IntrinsicInst {
+public:
+  static bool classof(const IntrinsicInst *I) {
+    switch (I->getIntrinsicID()) {
+    case Intrinsic::uadd_with_overflow:
+    case Intrinsic::sadd_with_overflow:
+    case Intrinsic::usub_with_overflow:
+    case Intrinsic::ssub_with_overflow:
+    case Intrinsic::umul_with_overflow:
+    case Intrinsic::smul_with_overflow:
+    case Intrinsic::uadd_sat:
+    case Intrinsic::sadd_sat:
+    case Intrinsic::usub_sat:
+    case Intrinsic::ssub_sat:
+      return true;
+    default:
+      return false;
     }
-  };
+  }
+  static bool classof(const Value *V) {
+    return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
+  }
 
+  Value *getLHS() const { return const_cast<Value *>(getArgOperand(0)); }
+  Value *getRHS() const { return const_cast<Value *>(getArgOperand(1)); }
+
+  /// Returns the binary operation underlying the intrinsic.
+  Instruction::BinaryOps getBinaryOp() const;
+
+  /// Whether the intrinsic is signed or unsigned.
+  bool isSigned() const;
+
+  /// Returns one of OBO::NoSignedWrap or OBO::NoUnsignedWrap.
+  unsigned getNoWrapKind() const;
+};
+
+/// Represents an op.with.overflow intrinsic.
+class WithOverflowInst : public BinaryOpIntrinsic {
+public:
+  static bool classof(const IntrinsicInst *I) {
+    switch (I->getIntrinsicID()) {
+    case Intrinsic::uadd_with_overflow:
+    case Intrinsic::sadd_with_overflow:
+    case Intrinsic::usub_with_overflow:
+    case Intrinsic::ssub_with_overflow:
+    case Intrinsic::umul_with_overflow:
+    case Intrinsic::smul_with_overflow:
+      return true;
+    default:
+      return false;
+    }
+  }
+  static bool classof(const Value *V) {
+    return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
+  }
+};
+
+/// Represents a saturating add/sub intrinsic.
+class SaturatingInst : public BinaryOpIntrinsic {
+public:
+  static bool classof(const IntrinsicInst *I) {
+    switch (I->getIntrinsicID()) {
+    case Intrinsic::uadd_sat:
+    case Intrinsic::sadd_sat:
+    case Intrinsic::usub_sat:
+    case Intrinsic::ssub_sat:
+      return true;
+    default:
+      return false;
+    }
+  }
+  static bool classof(const Value *V) {
+    return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
+  }
+};
+
+/// Common base class for all memory intrinsics. Simply provides
+/// common methods.
+/// Written as CRTP to avoid a common base class amongst the
+/// three atomicity hierarchies.
+template <typename Derived> class MemIntrinsicBase : public IntrinsicInst {
+private:
+  enum { ARG_DEST = 0, ARG_LENGTH = 2 };
+
+public:
+  Value *getRawDest() const {
+    return const_cast<Value *>(getArgOperand(ARG_DEST));
+  }
+  const Use &getRawDestUse() const { return getArgOperandUse(ARG_DEST); }
+  Use &getRawDestUse() { return getArgOperandUse(ARG_DEST); }
+
+  Value *getLength() const {
+    return const_cast<Value *>(getArgOperand(ARG_LENGTH));
+  }
+  const Use &getLengthUse() const { return getArgOperandUse(ARG_LENGTH); }
+  Use &getLengthUse() { return getArgOperandUse(ARG_LENGTH); }
+
+  /// This is just like getRawDest, but it strips off any cast
+  /// instructions (including addrspacecast) that feed it, giving the
+  /// original input.  The returned value is guaranteed to be a pointer.
+  Value *getDest() const { return getRawDest()->stripPointerCasts(); }
+
+  unsigned getDestAddressSpace() const {
+    return cast<PointerType>(getRawDest()->getType())->getAddressSpace();
+  }
+
+  /// FIXME: Remove this function once transition to Align is over.
+  /// Use getDestAlign() instead.
+  unsigned getDestAlignment() const {
+    if (auto MA = getParamAlign(ARG_DEST))
+      return MA->value();
+    return 0;
+  }
+  MaybeAlign getDestAlign() const { return getParamAlign(ARG_DEST); }
+
+  /// Set the specified arguments of the instruction.
+  void setDest(Value *Ptr) {
+    assert(getRawDest()->getType() == Ptr->getType() &&
+           "setDest called with pointer of wrong type!");
+    setArgOperand(ARG_DEST, Ptr);
+  }
+
+  /// FIXME: Remove this function once transition to Align is over.
+  /// Use the version that takes MaybeAlign instead of this one.
+  void setDestAlignment(unsigned Alignment) {
+    setDestAlignment(MaybeAlign(Alignment));
+  }
+  void setDestAlignment(MaybeAlign Alignment) {
+    removeParamAttr(ARG_DEST, Attribute::Alignment);
+    if (Alignment)
+      addParamAttr(ARG_DEST,
+                   Attribute::getWithAlignment(getContext(), *Alignment));
+  }
+  void setDestAlignment(Align Alignment) {
+    removeParamAttr(ARG_DEST, Attribute::Alignment);
+    addParamAttr(ARG_DEST,
+                 Attribute::getWithAlignment(getContext(), Alignment));
+  }
+
+  void setLength(Value *L) {
+    assert(getLength()->getType() == L->getType() &&
+           "setLength called with value of wrong type!");
+    setArgOperand(ARG_LENGTH, L);
+  }
+};
+
+/// Common base class for all memory transfer intrinsics. Simply provides
+/// common methods.
+template <class BaseCL> class MemTransferBase : public BaseCL {
+private:
+  enum { ARG_SOURCE = 1 };
+
+public:
+  /// Return the arguments to the instruction.
+  Value *getRawSource() const {
+    return const_cast<Value *>(BaseCL::getArgOperand(ARG_SOURCE));
+  }
+  const Use &getRawSourceUse() const {
+    return BaseCL::getArgOperandUse(ARG_SOURCE);
+  }
+  Use &getRawSourceUse() { return BaseCL::getArgOperandUse(ARG_SOURCE); }
+
+  /// This is just like getRawSource, but it strips off any cast
+  /// instructions that feed it, giving the original input.  The returned
+  /// value is guaranteed to be a pointer.
+  Value *getSource() const { return getRawSource()->stripPointerCasts(); }
+
+  unsigned getSourceAddressSpace() const {
+    return cast<PointerType>(getRawSource()->getType())->getAddressSpace();
+  }
+
+  /// FIXME: Remove this function once transition to Align is over.
+  /// Use getSourceAlign() instead.
+  unsigned getSourceAlignment() const {
+    if (auto MA = BaseCL::getParamAlign(ARG_SOURCE))
+      return MA->value();
+    return 0;
+  }
+
+  MaybeAlign getSourceAlign() const {
+    return BaseCL::getParamAlign(ARG_SOURCE);
+  }
+
+  void setSource(Value *Ptr) {
+    assert(getRawSource()->getType() == Ptr->getType() &&
+           "setSource called with pointer of wrong type!");
+    BaseCL::setArgOperand(ARG_SOURCE, Ptr);
+  }
+
+  /// FIXME: Remove this function once transition to Align is over.
+  /// Use the version that takes MaybeAlign instead of this one.
+  void setSourceAlignment(unsigned Alignment) {
+    setSourceAlignment(MaybeAlign(Alignment));
+  }
+  void setSourceAlignment(MaybeAlign Alignment) {
+    BaseCL::removeParamAttr(ARG_SOURCE, Attribute::Alignment);
+    if (Alignment)
+      BaseCL::addParamAttr(ARG_SOURCE, Attribute::getWithAlignment(
+                                           BaseCL::getContext(), *Alignment));
+  }
+  void setSourceAlignment(Align Alignment) {
+    BaseCL::removeParamAttr(ARG_SOURCE, Attribute::Alignment);
+    BaseCL::addParamAttr(ARG_SOURCE, Attribute::getWithAlignment(
+                                         BaseCL::getContext(), Alignment));
+  }
+};
+
+/// Common base class for all memset intrinsics. Simply provides
+/// common methods.
+template <class BaseCL> class MemSetBase : public BaseCL {
+private:
+  enum { ARG_VALUE = 1 };
+
+public:
+  Value *getValue() const {
+    return const_cast<Value *>(BaseCL::getArgOperand(ARG_VALUE));
+  }
+  const Use &getValueUse() const { return BaseCL::getArgOperandUse(ARG_VALUE); }
+  Use &getValueUse() { return BaseCL::getArgOperandUse(ARG_VALUE); }
+
+  void setValue(Value *Val) {
+    assert(getValue()->getType() == Val->getType() &&
+           "setValue called with value of wrong type!");
+    BaseCL::setArgOperand(ARG_VALUE, Val);
+  }
+};
+
+// The common base class for the atomic memset/memmove/memcpy intrinsics
+// i.e. llvm.element.unordered.atomic.memset/memcpy/memmove
+class AtomicMemIntrinsic : public MemIntrinsicBase<AtomicMemIntrinsic> {
+private:
+  enum { ARG_ELEMENTSIZE = 3 };
+
+public:
+  Value *getRawElementSizeInBytes() const {
+    return const_cast<Value *>(getArgOperand(ARG_ELEMENTSIZE));
+  }
+
+  ConstantInt *getElementSizeInBytesCst() const {
+    return cast<ConstantInt>(getRawElementSizeInBytes());
+  }
+
+  uint32_t getElementSizeInBytes() const {
+    return getElementSizeInBytesCst()->getZExtValue();
+  }
+
+  void setElementSizeInBytes(Constant *V) {
+    assert(V->getType() == Type::getInt8Ty(getContext()) &&
+           "setElementSizeInBytes called with value of wrong type!");
+    setArgOperand(ARG_ELEMENTSIZE, V);
+  }
+
+  static bool classof(const IntrinsicInst *I) {
+    switch (I->getIntrinsicID()) {
+    case Intrinsic::memcpy_element_unordered_atomic:
+    case Intrinsic::memmove_element_unordered_atomic:
+    case Intrinsic::memset_element_unordered_atomic:
+      return true;
+    default:
+      return false;
+    }
+  }
+  static bool classof(const Value *V) {
+    return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
+  }
+};
+
+/// This class represents atomic memset intrinsic
+// i.e. llvm.element.unordered.atomic.memset
+class AtomicMemSetInst : public MemSetBase<AtomicMemIntrinsic> {
+public:
+  static bool classof(const IntrinsicInst *I) {
+    return I->getIntrinsicID() == Intrinsic::memset_element_unordered_atomic;
+  }
+  static bool classof(const Value *V) {
+    return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
+  }
+};
+
+// This class wraps the atomic memcpy/memmove intrinsics
+// i.e. llvm.element.unordered.atomic.memcpy/memmove
+class AtomicMemTransferInst : public MemTransferBase<AtomicMemIntrinsic> {
+public:
+  static bool classof(const IntrinsicInst *I) {
+    switch (I->getIntrinsicID()) {
+    case Intrinsic::memcpy_element_unordered_atomic:
+    case Intrinsic::memmove_element_unordered_atomic:
+      return true;
+    default:
+      return false;
+    }
+  }
+  static bool classof(const Value *V) {
+    return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
+  }
+};
+
+/// This class represents the atomic memcpy intrinsic
+/// i.e. llvm.element.unordered.atomic.memcpy
+class AtomicMemCpyInst : public AtomicMemTransferInst {
+public:
+  static bool classof(const IntrinsicInst *I) {
+    return I->getIntrinsicID() == Intrinsic::memcpy_element_unordered_atomic;
+  }
+  static bool classof(const Value *V) {
+    return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
+  }
+};
+
+/// This class represents the atomic memmove intrinsic
+/// i.e. llvm.element.unordered.atomic.memmove
+class AtomicMemMoveInst : public AtomicMemTransferInst {
+public:
+  static bool classof(const IntrinsicInst *I) {
+    return I->getIntrinsicID() == Intrinsic::memmove_element_unordered_atomic;
+  }
+  static bool classof(const Value *V) {
+    return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
+  }
+};
+
+/// This is the common base class for memset/memcpy/memmove.
+class MemIntrinsic : public MemIntrinsicBase<MemIntrinsic> {
+private:
+  enum { ARG_VOLATILE = 3 };
+
+public:
+  ConstantInt *getVolatileCst() const {
+    return cast<ConstantInt>(const_cast<Value *>(getArgOperand(ARG_VOLATILE)));
+  }
+
+  bool isVolatile() const { return !getVolatileCst()->isZero(); }
+
+  void setVolatile(Constant *V) { setArgOperand(ARG_VOLATILE, V); }
+
+  // Methods for support type inquiry through isa, cast, and dyn_cast:
+  static bool classof(const IntrinsicInst *I) {
+    switch (I->getIntrinsicID()) {
+    case Intrinsic::memcpy:
+    case Intrinsic::memmove:
+    case Intrinsic::memset:
+    case Intrinsic::memcpy_inline:
+      return true;
+    default:
+      return false;
+    }
+  }
+  static bool classof(const Value *V) {
+    return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
+  }
+};
+
+/// This class wraps the llvm.memset intrinsic.
+class MemSetInst : public MemSetBase<MemIntrinsic> {
+public:
+  // Methods for support type inquiry through isa, cast, and dyn_cast:
+  static bool classof(const IntrinsicInst *I) {
+    return I->getIntrinsicID() == Intrinsic::memset;
+  }
+  static bool classof(const Value *V) {
+    return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
+  }
+};
+
+/// This class wraps the llvm.memcpy/memmove intrinsics.
+class MemTransferInst : public MemTransferBase<MemIntrinsic> {
+public:
+  // Methods for support type inquiry through isa, cast, and dyn_cast:
+  static bool classof(const IntrinsicInst *I) {
+    switch (I->getIntrinsicID()) {
+    case Intrinsic::memcpy:
+    case Intrinsic::memmove:
+    case Intrinsic::memcpy_inline:
+      return true;
+    default:
+      return false;
+    }
+  }
+  static bool classof(const Value *V) {
+    return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
+  }
+};
+
+/// This class wraps the llvm.memcpy intrinsic.
+class MemCpyInst : public MemTransferInst {
+public:
+  // Methods for support type inquiry through isa, cast, and dyn_cast:
+  static bool classof(const IntrinsicInst *I) {
+    return I->getIntrinsicID() == Intrinsic::memcpy;
+  }
+  static bool classof(const Value *V) {
+    return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
+  }
+};
+
+/// This class wraps the llvm.memmove intrinsic.
+class MemMoveInst : public MemTransferInst {
+public:
+  // Methods for support type inquiry through isa, cast, and dyn_cast:
+  static bool classof(const IntrinsicInst *I) {
+    return I->getIntrinsicID() == Intrinsic::memmove;
+  }
+  static bool classof(const Value *V) {
+    return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
+  }
+};
+
+/// This class wraps the llvm.memcpy.inline intrinsic.
+class MemCpyInlineInst : public MemTransferInst {
+public:
+  ConstantInt *getLength() const {
+    return cast<ConstantInt>(MemTransferInst::getLength());
+  }
+  // Methods for support type inquiry through isa, cast, and dyn_cast:
+  static bool classof(const IntrinsicInst *I) {
+    return I->getIntrinsicID() == Intrinsic::memcpy_inline;
+  }
+  static bool classof(const Value *V) {
+    return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
+  }
+};
+
+// The common base class for any memset/memmove/memcpy intrinsics;
+// whether they be atomic or non-atomic.
+// i.e. llvm.element.unordered.atomic.memset/memcpy/memmove
+//  and llvm.memset/memcpy/memmove
+class AnyMemIntrinsic : public MemIntrinsicBase<AnyMemIntrinsic> {
+public:
+  bool isVolatile() const {
+    // Only the non-atomic intrinsics can be volatile
+    if (auto *MI = dyn_cast<MemIntrinsic>(this))
+      return MI->isVolatile();
+    return false;
+  }
+
+  static bool classof(const IntrinsicInst *I) {
+    switch (I->getIntrinsicID()) {
+    case Intrinsic::memcpy:
+    case Intrinsic::memcpy_inline:
+    case Intrinsic::memmove:
+    case Intrinsic::memset:
+    case Intrinsic::memcpy_element_unordered_atomic:
+    case Intrinsic::memmove_element_unordered_atomic:
+    case Intrinsic::memset_element_unordered_atomic:
+      return true;
+    default:
+      return false;
+    }
+  }
+  static bool classof(const Value *V) {
+    return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
+  }
+};
+
+/// This class represents any memset intrinsic
+// i.e. llvm.element.unordered.atomic.memset
+// and  llvm.memset
+class AnyMemSetInst : public MemSetBase<AnyMemIntrinsic> {
+public:
+  static bool classof(const IntrinsicInst *I) {
+    switch (I->getIntrinsicID()) {
+    case Intrinsic::memset:
+    case Intrinsic::memset_element_unordered_atomic:
+      return true;
+    default:
+      return false;
+    }
+  }
+  static bool classof(const Value *V) {
+    return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
+  }
+};
+
+// This class wraps any memcpy/memmove intrinsics
+// i.e. llvm.element.unordered.atomic.memcpy/memmove
+// and  llvm.memcpy/memmove
+class AnyMemTransferInst : public MemTransferBase<AnyMemIntrinsic> {
+public:
+  static bool classof(const IntrinsicInst *I) {
+    switch (I->getIntrinsicID()) {
+    case Intrinsic::memcpy:
+    case Intrinsic::memcpy_inline:
+    case Intrinsic::memmove:
+    case Intrinsic::memcpy_element_unordered_atomic:
+    case Intrinsic::memmove_element_unordered_atomic:
+      return true;
+    default:
+      return false;
+    }
+  }
+  static bool classof(const Value *V) {
+    return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
+  }
+};
+
+/// This class represents any memcpy intrinsic
+/// i.e. llvm.element.unordered.atomic.memcpy
+///  and llvm.memcpy
+class AnyMemCpyInst : public AnyMemTransferInst {
+public:
+  static bool classof(const IntrinsicInst *I) {
+    switch (I->getIntrinsicID()) {
+    case Intrinsic::memcpy:
+    case Intrinsic::memcpy_inline:
+    case Intrinsic::memcpy_element_unordered_atomic:
+      return true;
+    default:
+      return false;
+    }
+  }
+  static bool classof(const Value *V) {
+    return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
+  }
+};
+
+/// This class represents any memmove intrinsic
+/// i.e. llvm.element.unordered.atomic.memmove
+///  and llvm.memmove
+class AnyMemMoveInst : public AnyMemTransferInst {
+public:
+  static bool classof(const IntrinsicInst *I) {
+    switch (I->getIntrinsicID()) {
+    case Intrinsic::memmove:
+    case Intrinsic::memmove_element_unordered_atomic:
+      return true;
+    default:
+      return false;
+    }
+  }
+  static bool classof(const Value *V) {
+    return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
+  }
+};
+
+/// This represents the llvm.va_start intrinsic.
+class VAStartInst : public IntrinsicInst {
+public:
+  static bool classof(const IntrinsicInst *I) {
+    return I->getIntrinsicID() == Intrinsic::vastart;
+  }
+  static bool classof(const Value *V) {
+    return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
+  }
+
+  Value *getArgList() const { return const_cast<Value *>(getArgOperand(0)); }
+};
+
+/// This represents the llvm.va_end intrinsic.
+class VAEndInst : public IntrinsicInst {
+public:
+  static bool classof(const IntrinsicInst *I) {
+    return I->getIntrinsicID() == Intrinsic::vaend;
+  }
+  static bool classof(const Value *V) {
+    return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
+  }
+
+  Value *getArgList() const { return const_cast<Value *>(getArgOperand(0)); }
+};
+
+/// This represents the llvm.va_copy intrinsic.
+class VACopyInst : public IntrinsicInst {
+public:
+  static bool classof(const IntrinsicInst *I) {
+    return I->getIntrinsicID() == Intrinsic::vacopy;
+  }
+  static bool classof(const Value *V) {
+    return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
+  }
+
+  Value *getDest() const { return const_cast<Value *>(getArgOperand(0)); }
+  Value *getSrc() const { return const_cast<Value *>(getArgOperand(1)); }
+};
+
+/// This represents the llvm.instrprof_increment intrinsic.
+class InstrProfIncrementInst : public IntrinsicInst {
+public:
+  static bool classof(const IntrinsicInst *I) {
+    return I->getIntrinsicID() == Intrinsic::instrprof_increment;
+  }
+  static bool classof(const Value *V) {
+    return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
+  }
+
+  GlobalVariable *getName() const {
+    return cast<GlobalVariable>(
+        const_cast<Value *>(getArgOperand(0))->stripPointerCasts());
+  }
+
+  ConstantInt *getHash() const {
+    return cast<ConstantInt>(const_cast<Value *>(getArgOperand(1)));
+  }
+
+  ConstantInt *getNumCounters() const {
+    return cast<ConstantInt>(const_cast<Value *>(getArgOperand(2)));
+  }
+
+  ConstantInt *getIndex() const {
+    return cast<ConstantInt>(const_cast<Value *>(getArgOperand(3)));
+  }
+
+  Value *getStep() const;
+};
+
+class InstrProfIncrementInstStep : public InstrProfIncrementInst {
+public:
+  static bool classof(const IntrinsicInst *I) {
+    return I->getIntrinsicID() == Intrinsic::instrprof_increment_step;
+  }
+  static bool classof(const Value *V) {
+    return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
+  }
+};
+
+/// This represents the llvm.instrprof_value_profile intrinsic.
+class InstrProfValueProfileInst : public IntrinsicInst {
+public:
+  static bool classof(const IntrinsicInst *I) {
+    return I->getIntrinsicID() == Intrinsic::instrprof_value_profile;
+  }
+  static bool classof(const Value *V) {
+    return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
+  }
+
+  GlobalVariable *getName() const {
+    return cast<GlobalVariable>(
+        const_cast<Value *>(getArgOperand(0))->stripPointerCasts());
+  }
+
+  ConstantInt *getHash() const {
+    return cast<ConstantInt>(const_cast<Value *>(getArgOperand(1)));
+  }
+
+  Value *getTargetValue() const {
+    return cast<Value>(const_cast<Value *>(getArgOperand(2)));
+  }
+
+  ConstantInt *getValueKind() const {
+    return cast<ConstantInt>(const_cast<Value *>(getArgOperand(3)));
+  }
+
+  // Returns the value site index.
+  ConstantInt *getIndex() const {
+    return cast<ConstantInt>(const_cast<Value *>(getArgOperand(4)));
+  }
+};
+
+class PseudoProbeInst : public IntrinsicInst {
+public:
+  static bool classof(const IntrinsicInst *I) {
+    return I->getIntrinsicID() == Intrinsic::pseudoprobe;
+  }
+
+  static bool classof(const Value *V) {
+    return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
+  }
+
+  ConstantInt *getFuncGuid() const {
+    return cast<ConstantInt>(const_cast<Value *>(getArgOperand(0)));
+  }
+
+  ConstantInt *getAttributes() const {
+    return cast<ConstantInt>(const_cast<Value *>(getArgOperand(2)));
+  }
+
+  ConstantInt *getIndex() const {
+    return cast<ConstantInt>(const_cast<Value *>(getArgOperand(1)));
+  }
+};
 } // end namespace llvm
 
 #endif // LLVM_IR_INTRINSICINST_H
diff --git a/linux-x64/clang/include/llvm/IR/Intrinsics.h b/linux-x64/clang/include/llvm/IR/Intrinsics.h
index f38f920..08f64be 100644
--- a/linux-x64/clang/include/llvm/IR/Intrinsics.h
+++ b/linux-x64/clang/include/llvm/IR/Intrinsics.h
@@ -18,6 +18,7 @@
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/None.h"
 #include "llvm/ADT/Optional.h"
+#include "llvm/Support/TypeSize.h"
 #include <string>
 
 namespace llvm {
@@ -33,14 +34,17 @@
 /// function known by LLVM. The enum values are returned by
 /// Function::getIntrinsicID().
 namespace Intrinsic {
-  enum ID : unsigned {
-    not_intrinsic = 0,   // Must be zero
+  // Intrinsic ID type. This is an opaque typedef to facilitate splitting up
+  // the enum into target-specific enums.
+  typedef unsigned ID;
 
-    // Get the intrinsic enums generated from Intrinsics.td
+  enum IndependentIntrinsics : unsigned {
+    not_intrinsic = 0, // Must be zero
+
+  // Get the intrinsic enums generated from Intrinsics.td
 #define GET_INTRINSIC_ENUM_VALUES
 #include "llvm/IR/IntrinsicEnums.inc"
 #undef GET_INTRINSIC_ENUM_VALUES
-    , num_intrinsics
   };
 
   /// Return the LLVM name for an intrinsic, such as "llvm.ppc.altivec.lvx".
@@ -96,20 +100,42 @@
   /// intrinsic. This is returned by getIntrinsicInfoTableEntries.
   struct IITDescriptor {
     enum IITDescriptorKind {
-      Void, VarArg, MMX, Token, Metadata, Half, Float, Double, Quad,
-      Integer, Vector, Pointer, Struct,
-      Argument, ExtendArgument, TruncArgument, HalfVecArgument,
-      SameVecWidthArgument, PtrToArgument, PtrToElt, VecOfAnyPtrsToElt,
-      VecElementArgument
+      Void,
+      VarArg,
+      MMX,
+      Token,
+      Metadata,
+      Half,
+      BFloat,
+      Float,
+      Double,
+      Quad,
+      Integer,
+      Vector,
+      Pointer,
+      Struct,
+      Argument,
+      ExtendArgument,
+      TruncArgument,
+      HalfVecArgument,
+      SameVecWidthArgument,
+      PtrToArgument,
+      PtrToElt,
+      VecOfAnyPtrsToElt,
+      VecElementArgument,
+      Subdivide2Argument,
+      Subdivide4Argument,
+      VecOfBitcastsToInt,
+      AMX
     } Kind;
 
     union {
       unsigned Integer_Width;
       unsigned Float_Width;
-      unsigned Vector_Width;
       unsigned Pointer_AddressSpace;
       unsigned Struct_NumElements;
       unsigned Argument_Info;
+      ElementCount Vector_Width;
     };
 
     enum ArgKind {
@@ -125,14 +151,17 @@
       assert(Kind == Argument || Kind == ExtendArgument ||
              Kind == TruncArgument || Kind == HalfVecArgument ||
              Kind == SameVecWidthArgument || Kind == PtrToArgument ||
-             Kind == PtrToElt || Kind == VecElementArgument);
+             Kind == PtrToElt || Kind == VecElementArgument ||
+             Kind == Subdivide2Argument || Kind == Subdivide4Argument ||
+             Kind == VecOfBitcastsToInt);
       return Argument_Info >> 3;
     }
     ArgKind getArgumentKind() const {
       assert(Kind == Argument || Kind == ExtendArgument ||
              Kind == TruncArgument || Kind == HalfVecArgument ||
              Kind == SameVecWidthArgument || Kind == PtrToArgument ||
-             Kind == VecElementArgument);
+             Kind == VecElementArgument || Kind == Subdivide2Argument ||
+             Kind == Subdivide4Argument || Kind == VecOfBitcastsToInt);
       return (ArgKind)(Argument_Info & 7);
     }
 
@@ -158,6 +187,12 @@
       IITDescriptor Result = {K, {Field}};
       return Result;
     }
+
+    static IITDescriptor getVector(unsigned Width, bool IsScalable) {
+      IITDescriptor Result = {Vector, {0}};
+      Result.Vector_Width = ElementCount::get(Width, IsScalable);
+      return Result;
+    }
   };
 
   /// Return the IIT table descriptor for the specified intrinsic into an array
@@ -186,6 +221,13 @@
   /// This method returns true on error.
   bool matchIntrinsicVarArg(bool isVarArg, ArrayRef<IITDescriptor> &Infos);
 
+  /// Gets the type arguments of an intrinsic call by matching type contraints
+  /// specified by the .td file. The overloaded types are pushed into the
+  /// AgTys vector.
+  ///
+  /// Returns false if the given function is not a valid intrinsic call.
+  bool getIntrinsicSignature(Function *F, SmallVectorImpl<Type *> &ArgTys);
+
   // Checks if the intrinsic name matches with its signature and if not
   // returns the declaration with the same signature and remangled name.
   llvm::Optional<Function*> remangleIntrinsicFunction(Function *F);
diff --git a/linux-x64/clang/include/llvm/IR/Intrinsics.td b/linux-x64/clang/include/llvm/IR/Intrinsics.td
index 62e9410..5380395 100644
--- a/linux-x64/clang/include/llvm/IR/Intrinsics.td
+++ b/linux-x64/clang/include/llvm/IR/Intrinsics.td
@@ -17,7 +17,9 @@
 //  Properties we keep track of for intrinsics.
 //===----------------------------------------------------------------------===//
 
-class IntrinsicProperty;
+class IntrinsicProperty<bit is_default = false> {
+  bit IsDefault = is_default;
+}
 
 // Intr*Mem - Memory properties.  If no property is set, the worst case
 // is assumed (it may read and write any memory it can get access to and it may
@@ -58,42 +60,76 @@
 // Throws - This intrinsic can throw.
 def Throws : IntrinsicProperty;
 
+// Attribute index needs to match `AttrIndex` defined `Attributes.h`.
+class AttrIndex<int idx> {
+  int Value = idx;
+}
+def FuncIndex : AttrIndex<-1>;
+def RetIndex : AttrIndex<0>;
+class ArgIndex<int argNo> : AttrIndex<!add(argNo, 1)>;
+
 // NoCapture - The specified argument pointer is not captured by the intrinsic.
-class NoCapture<int argNo> : IntrinsicProperty {
-  int ArgNo = argNo;
+class NoCapture<AttrIndex idx> : IntrinsicProperty {
+  int ArgNo = idx.Value;
+}
+
+// NoAlias - The specified argument pointer is not aliasing other "noalias" pointer
+// arguments of the intrinsic wrt. the intrinsic scope.
+class NoAlias<AttrIndex idx> : IntrinsicProperty {
+  int ArgNo = idx.Value;
+}
+
+// NoUndef - The specified argument is neither undef nor poison.
+class NoUndef<AttrIndex idx> : IntrinsicProperty {
+  int ArgNo = idx.Value;
+}
+
+class Align<AttrIndex idx, int align> : IntrinsicProperty {
+  int ArgNo = idx.Value;
+  int Align = align;
 }
 
 // Returned - The specified argument is always the return value of the
 // intrinsic.
-class Returned<int argNo> : IntrinsicProperty {
-  int ArgNo = argNo;
+class Returned<AttrIndex idx> : IntrinsicProperty {
+  int ArgNo = idx.Value;
 }
 
 // ImmArg - The specified argument must be an immediate.
-class ImmArg<int argNo> : IntrinsicProperty {
-  int ArgNo = argNo;
+class ImmArg<AttrIndex idx> : IntrinsicProperty {
+  int ArgNo = idx.Value;
 }
 
 // ReadOnly - The specified argument pointer is not written to through the
 // pointer by the intrinsic.
-class ReadOnly<int argNo> : IntrinsicProperty {
-  int ArgNo = argNo;
+class ReadOnly<AttrIndex idx> : IntrinsicProperty {
+  int ArgNo = idx.Value;
 }
 
 // WriteOnly - The intrinsic does not read memory through the specified
 // argument pointer.
-class WriteOnly<int argNo> : IntrinsicProperty {
-  int ArgNo = argNo;
+class WriteOnly<AttrIndex idx> : IntrinsicProperty {
+  int ArgNo = idx.Value;
 }
 
 // ReadNone - The specified argument pointer is not dereferenced by the
 // intrinsic.
-class ReadNone<int argNo> : IntrinsicProperty {
-  int ArgNo = argNo;
+class ReadNone<AttrIndex idx> : IntrinsicProperty {
+  int ArgNo = idx.Value;
 }
 
 def IntrNoReturn : IntrinsicProperty;
 
+// IntrNoSync - Threads executing the intrinsic will not synchronize using
+// memory or other means. Applied by default.
+def IntrNoSync : IntrinsicProperty<1>;
+
+// Applied by default.
+def IntrNoFree : IntrinsicProperty<1>;
+
+// Applied by default.
+def IntrWillReturn : IntrinsicProperty<1>;
+
 // IntrCold - Calls to this intrinsic are cold.
 // Parallels the cold attribute on LLVM IR functions.
 def IntrCold : IntrinsicProperty;
@@ -125,7 +161,7 @@
 
 class LLVMType<ValueType vt> {
   ValueType VT = vt;
-  int isAny = 0;
+  int isAny = false;
 }
 
 class LLVMQualPointerType<LLVMType elty, int addrspace>
@@ -141,7 +177,7 @@
   : LLVMType<iPTRAny>{
   LLVMType ElTy = elty;
 
-  let isAny = 1;
+  let isAny = true;
 }
 
 // Match the type of another intrinsic parameter.  Number is an index into the
@@ -179,8 +215,18 @@
 // vector type, but change the element count to be half as many
 class LLVMHalfElementsVectorType<int num> : LLVMMatchType<num>;
 
+// Match the type of another intrinsic parameter that is expected to be a
+// vector type (i.e. <N x iM>) but with each element subdivided to
+// form a vector with more elements that are smaller than the original.
+class LLVMSubdivide2VectorType<int num> : LLVMMatchType<num>;
+class LLVMSubdivide4VectorType<int num> : LLVMMatchType<num>;
+
+// Match the element count and bit width of another intrinsic parameter, but
+// change the element type to an integer.
+class LLVMVectorOfBitcastsToInt<int num> : LLVMMatchType<num>;
+
 def llvm_void_ty       : LLVMType<isVoid>;
-let isAny = 1 in {
+let isAny = true in {
   def llvm_any_ty        : LLVMType<Any>;
   def llvm_anyint_ty     : LLVMType<iAny>;
   def llvm_anyfloat_ty   : LLVMType<fAny>;
@@ -192,6 +238,7 @@
 def llvm_i32_ty        : LLVMType<i32>;
 def llvm_i64_ty        : LLVMType<i64>;
 def llvm_half_ty       : LLVMType<f16>;
+def llvm_bfloat_ty     : LLVMType<bf16>;
 def llvm_float_ty      : LLVMType<f32>;
 def llvm_double_ty     : LLVMType<f64>;
 def llvm_f80_ty        : LLVMType<f80>;
@@ -208,12 +255,16 @@
 def llvm_x86mmx_ty     : LLVMType<x86mmx>;
 def llvm_ptrx86mmx_ty  : LLVMPointerType<llvm_x86mmx_ty>;         // <1 x i64>*
 
+def llvm_x86amx_ty     : LLVMType<x86amx>;
+
 def llvm_v2i1_ty       : LLVMType<v2i1>;     //   2 x i1
 def llvm_v4i1_ty       : LLVMType<v4i1>;     //   4 x i1
 def llvm_v8i1_ty       : LLVMType<v8i1>;     //   8 x i1
 def llvm_v16i1_ty      : LLVMType<v16i1>;    //  16 x i1
 def llvm_v32i1_ty      : LLVMType<v32i1>;    //  32 x i1
 def llvm_v64i1_ty      : LLVMType<v64i1>;    //  64 x i1
+def llvm_v128i1_ty     : LLVMType<v128i1>;   // 128 x i1
+def llvm_v256i1_ty     : LLVMType<v256i1>;   // 256 x i1
 def llvm_v512i1_ty     : LLVMType<v512i1>;   // 512 x i1
 def llvm_v1024i1_ty    : LLVMType<v1024i1>;  //1024 x i1
 
@@ -243,6 +294,7 @@
 def llvm_v16i32_ty     : LLVMType<v16i32>;   // 16 x i32
 def llvm_v32i32_ty     : LLVMType<v32i32>;   // 32 x i32
 def llvm_v64i32_ty     : LLVMType<v64i32>;   // 64 x i32
+def llvm_v256i32_ty    : LLVMType<v256i32>;  //256 x i32
 
 def llvm_v1i64_ty      : LLVMType<v1i64>;    //  1 x i64
 def llvm_v2i64_ty      : LLVMType<v2i64>;    //  2 x i64
@@ -256,15 +308,20 @@
 def llvm_v2f16_ty      : LLVMType<v2f16>;    //  2 x half (__fp16)
 def llvm_v4f16_ty      : LLVMType<v4f16>;    //  4 x half (__fp16)
 def llvm_v8f16_ty      : LLVMType<v8f16>;    //  8 x half (__fp16)
+def llvm_v2bf16_ty     : LLVMType<v2bf16>;   //  2 x bfloat (__bf16)
+def llvm_v4bf16_ty     : LLVMType<v4bf16>;   //  4 x bfloat (__bf16)
+def llvm_v8bf16_ty     : LLVMType<v8bf16>;   //  8 x bfloat (__bf16)
 def llvm_v1f32_ty      : LLVMType<v1f32>;    //  1 x float
 def llvm_v2f32_ty      : LLVMType<v2f32>;    //  2 x float
 def llvm_v4f32_ty      : LLVMType<v4f32>;    //  4 x float
 def llvm_v8f32_ty      : LLVMType<v8f32>;    //  8 x float
 def llvm_v16f32_ty     : LLVMType<v16f32>;   // 16 x float
+def llvm_v32f32_ty     : LLVMType<v32f32>;   // 32 x float
 def llvm_v1f64_ty      : LLVMType<v1f64>;    //  1 x double
 def llvm_v2f64_ty      : LLVMType<v2f64>;    //  2 x double
 def llvm_v4f64_ty      : LLVMType<v4f64>;    //  4 x double
 def llvm_v8f64_ty      : LLVMType<v8f64>;    //  8 x double
+def llvm_v16f64_ty     : LLVMType<v16f64>;   // 16 x double
 
 def llvm_vararg_ty     : LLVMType<isVoid>;   // this means vararg here
 
@@ -287,7 +344,8 @@
                 list<LLVMType> param_types = [],
                 list<IntrinsicProperty> intr_properties = [],
                 string name = "",
-                list<SDNodeProperty> sd_properties = []> : SDPatternOperator {
+                list<SDNodeProperty> sd_properties = [],
+                bit disable_default_attributes = true> : SDPatternOperator {
   string LLVMName = name;
   string TargetPrefix = "";   // Set to a prefix for target-specific intrinsics.
   list<LLVMType> RetTypes = ret_types;
@@ -295,9 +353,23 @@
   list<IntrinsicProperty> IntrProperties = intr_properties;
   let Properties = sd_properties;
 
-  bit isTarget = 0;
+  // Disable applying IntrinsicProperties that are marked default with
+  // IntrinsicProperty<1>
+  bit DisableDefaultAttributes = disable_default_attributes;
+
+  bit isTarget = false;
 }
 
+// Intrinisc with default attributes (disable_default_attributes = false).
+class DefaultAttrsIntrinsic<list<LLVMType> ret_types,
+                list<LLVMType> param_types = [],
+                list<IntrinsicProperty> intr_properties = [],
+                string name = "",
+                list<SDNodeProperty> sd_properties = []>
+                : Intrinsic<ret_types, param_types,
+                            intr_properties, name,
+                            sd_properties, /*disable_default_attributes*/ 0> {}
+
 /// GCCBuiltin - If this intrinsic exactly corresponds to a GCC builtin, this
 /// specifies the name of the builtin.  This provides automatic CBE and CFE
 /// support.
@@ -313,10 +385,10 @@
 //===--------------- Variable Argument Handling Intrinsics ----------------===//
 //
 
-def int_vastart : Intrinsic<[], [llvm_ptr_ty], [], "llvm.va_start">;
-def int_vacopy  : Intrinsic<[], [llvm_ptr_ty, llvm_ptr_ty], [],
+def int_vastart : DefaultAttrsIntrinsic<[], [llvm_ptr_ty], [], "llvm.va_start">;
+def int_vacopy  : DefaultAttrsIntrinsic<[], [llvm_ptr_ty, llvm_ptr_ty], [],
                             "llvm.va_copy">;
-def int_vaend   : Intrinsic<[], [llvm_ptr_ty], [], "llvm.va_end">;
+def int_vaend   : DefaultAttrsIntrinsic<[], [llvm_ptr_ty], [], "llvm.va_end">;
 
 //===------------------- Garbage Collection Intrinsics --------------------===//
 //
@@ -327,7 +399,8 @@
                             [IntrReadMem, IntrArgMemOnly]>;
 def int_gcwrite : Intrinsic<[],
                             [llvm_ptr_ty, llvm_ptr_ty, llvm_ptrptr_ty],
-                            [IntrArgMemOnly, NoCapture<1>, NoCapture<2>]>;
+                            [IntrArgMemOnly, NoCapture<ArgIndex<1>>,
+                             NoCapture<ArgIndex<2>>]>;
 
 //===------------------- ObjC ARC runtime Intrinsics --------------------===//
 //
@@ -403,44 +476,49 @@
 
 //===--------------------- Code Generator Intrinsics ----------------------===//
 //
-def int_returnaddress : Intrinsic<[llvm_ptr_ty], [llvm_i32_ty], [IntrNoMem, ImmArg<0>]>;
-def int_addressofreturnaddress : Intrinsic<[llvm_ptr_ty], [], [IntrNoMem]>;
-def int_frameaddress : Intrinsic<[llvm_ptr_ty], [llvm_i32_ty], [IntrNoMem, ImmArg<0>]>;
-def int_sponentry  : Intrinsic<[llvm_ptr_ty], [], [IntrNoMem]>;
+def int_returnaddress : DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty],
+                                  [IntrNoMem, ImmArg<ArgIndex<0>>]>;
+def int_addressofreturnaddress : DefaultAttrsIntrinsic<[llvm_anyptr_ty], [], [IntrNoMem]>;
+def int_frameaddress : DefaultAttrsIntrinsic<[llvm_anyptr_ty], [llvm_i32_ty],
+                                 [IntrNoMem, ImmArg<ArgIndex<0>>]>;
+def int_sponentry  : DefaultAttrsIntrinsic<[llvm_anyptr_ty], [], [IntrNoMem]>;
 def int_read_register  : Intrinsic<[llvm_anyint_ty], [llvm_metadata_ty],
                                    [IntrReadMem], "llvm.read_register">;
 def int_write_register : Intrinsic<[], [llvm_metadata_ty, llvm_anyint_ty],
                                    [], "llvm.write_register">;
+def int_read_volatile_register  : Intrinsic<[llvm_anyint_ty], [llvm_metadata_ty],
+                                            [IntrHasSideEffects],
+                                             "llvm.read_volatile_register">;
 
 // Gets the address of the local variable area. This is typically a copy of the
 // stack, frame, or base pointer depending on the type of prologue.
-def int_localaddress : Intrinsic<[llvm_ptr_ty], [], [IntrNoMem]>;
+def int_localaddress : DefaultAttrsIntrinsic<[llvm_ptr_ty], [], [IntrNoMem]>;
 
 // Escapes local variables to allow access from other functions.
-def int_localescape : Intrinsic<[], [llvm_vararg_ty]>;
+def int_localescape : DefaultAttrsIntrinsic<[], [llvm_vararg_ty]>;
 
 // Given a function and the localaddress of a parent frame, returns a pointer
 // to an escaped allocation indicated by the index.
-def int_localrecover : Intrinsic<[llvm_ptr_ty],
+def int_localrecover : DefaultAttrsIntrinsic<[llvm_ptr_ty],
                                  [llvm_ptr_ty, llvm_ptr_ty, llvm_i32_ty],
-                                 [IntrNoMem, ImmArg<2>]>;
+                                 [IntrNoMem, ImmArg<ArgIndex<2>>]>;
 
 // Given the frame pointer passed into an SEH filter function, returns a
 // pointer to the local variable area suitable for use with llvm.localrecover.
-def int_eh_recoverfp : Intrinsic<[llvm_ptr_ty],
+def int_eh_recoverfp : DefaultAttrsIntrinsic<[llvm_ptr_ty],
                                  [llvm_ptr_ty, llvm_ptr_ty],
                                  [IntrNoMem]>;
 
 // Note: we treat stacksave/stackrestore as writemem because we don't otherwise
 // model their dependencies on allocas.
-def int_stacksave     : Intrinsic<[llvm_ptr_ty]>,
+def int_stacksave     : DefaultAttrsIntrinsic<[llvm_ptr_ty]>,
                         GCCBuiltin<"__builtin_stack_save">;
-def int_stackrestore  : Intrinsic<[], [llvm_ptr_ty]>,
+def int_stackrestore  : DefaultAttrsIntrinsic<[], [llvm_ptr_ty]>,
                         GCCBuiltin<"__builtin_stack_restore">;
 
-def int_get_dynamic_area_offset : Intrinsic<[llvm_anyint_ty]>;
+def int_get_dynamic_area_offset : DefaultAttrsIntrinsic<[llvm_anyint_ty]>;
 
-def int_thread_pointer : Intrinsic<[llvm_ptr_ty], [], [IntrNoMem]>,
+def int_thread_pointer : DefaultAttrsIntrinsic<[llvm_ptr_ty], [], [IntrNoMem]>,
                          GCCBuiltin<"__builtin_thread_pointer">;
 
 // IntrInaccessibleMemOrArgMemOnly is a little more pessimistic than strictly
@@ -448,177 +526,229 @@
 // from being reordered overly much with respect to nearby access to the same
 // memory while not impeding optimization.
 def int_prefetch
-    : Intrinsic<[], [ llvm_ptr_ty, llvm_i32_ty, llvm_i32_ty, llvm_i32_ty ],
-                [ IntrInaccessibleMemOrArgMemOnly, ReadOnly<0>, NoCapture<0>,
-                  ImmArg<1>, ImmArg<2>]>;
-def int_pcmarker      : Intrinsic<[], [llvm_i32_ty]>;
+    : DefaultAttrsIntrinsic<[], [ llvm_anyptr_ty, llvm_i32_ty, llvm_i32_ty, llvm_i32_ty ],
+                [IntrInaccessibleMemOrArgMemOnly, IntrWillReturn,
+                 ReadOnly<ArgIndex<0>>, NoCapture<ArgIndex<0>>,
+                 ImmArg<ArgIndex<1>>, ImmArg<ArgIndex<2>>]>;
+def int_pcmarker      : DefaultAttrsIntrinsic<[], [llvm_i32_ty]>;
 
-def int_readcyclecounter : Intrinsic<[llvm_i64_ty]>;
+def int_readcyclecounter : DefaultAttrsIntrinsic<[llvm_i64_ty]>;
 
 // The assume intrinsic is marked as arbitrarily writing so that proper
 // control dependencies will be maintained.
-def int_assume        : Intrinsic<[], [llvm_i1_ty], []>;
+def int_assume        : DefaultAttrsIntrinsic<[], [llvm_i1_ty], [IntrWillReturn,
+                                                     NoUndef<ArgIndex<0>>]>;
 
 // Stack Protector Intrinsic - The stackprotector intrinsic writes the stack
 // guard to the correct place on the stack frame.
-def int_stackprotector : Intrinsic<[], [llvm_ptr_ty, llvm_ptrptr_ty], []>;
-def int_stackguard : Intrinsic<[llvm_ptr_ty], [], []>;
+def int_stackprotector : DefaultAttrsIntrinsic<[], [llvm_ptr_ty, llvm_ptrptr_ty], []>;
+def int_stackguard : DefaultAttrsIntrinsic<[llvm_ptr_ty], [], []>;
 
 // A counter increment for instrumentation based profiling.
 def int_instrprof_increment : Intrinsic<[],
                                         [llvm_ptr_ty, llvm_i64_ty,
-                                         llvm_i32_ty, llvm_i32_ty],
-                                        []>;
+                                         llvm_i32_ty, llvm_i32_ty]>;
 
 // A counter increment with step for instrumentation based profiling.
 def int_instrprof_increment_step : Intrinsic<[],
                                         [llvm_ptr_ty, llvm_i64_ty,
-                                         llvm_i32_ty, llvm_i32_ty, llvm_i64_ty],
-                                        []>;
+                                         llvm_i32_ty, llvm_i32_ty, llvm_i64_ty]>;
 
 // A call to profile runtime for value profiling of target expressions
 // through instrumentation based profiling.
 def int_instrprof_value_profile : Intrinsic<[],
                                             [llvm_ptr_ty, llvm_i64_ty,
                                              llvm_i64_ty, llvm_i32_ty,
-                                             llvm_i32_ty],
-                                            []>;
+                                             llvm_i32_ty]>;
+
+def int_call_preallocated_setup : DefaultAttrsIntrinsic<[llvm_token_ty], [llvm_i32_ty]>;
+def int_call_preallocated_arg : DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_token_ty, llvm_i32_ty]>;
+def int_call_preallocated_teardown : DefaultAttrsIntrinsic<[], [llvm_token_ty]>;
 
 //===------------------- Standard C Library Intrinsics --------------------===//
 //
 
-def int_memcpy  : Intrinsic<[],
-                             [llvm_anyptr_ty, llvm_anyptr_ty, llvm_anyint_ty,
-                              llvm_i1_ty],
-                            [IntrArgMemOnly, NoCapture<0>, NoCapture<1>,
-                             WriteOnly<0>, ReadOnly<1>, ImmArg<3>]>;
-def int_memmove : Intrinsic<[],
+def int_memcpy  : DefaultAttrsIntrinsic<[],
                             [llvm_anyptr_ty, llvm_anyptr_ty, llvm_anyint_ty,
                              llvm_i1_ty],
-                            [IntrArgMemOnly, NoCapture<0>, NoCapture<1>,
-                             ReadOnly<1>, ImmArg<3>]>;
-def int_memset  : Intrinsic<[],
+                            [IntrArgMemOnly, IntrWillReturn,
+                             NoCapture<ArgIndex<0>>, NoCapture<ArgIndex<1>>,
+                             NoAlias<ArgIndex<0>>, NoAlias<ArgIndex<1>>,
+                             WriteOnly<ArgIndex<0>>, ReadOnly<ArgIndex<1>>,
+                             ImmArg<ArgIndex<3>>]>;
+
+// Memcpy semantic that is guaranteed to be inlined.
+// In particular this means that the generated code is not allowed to call any
+// external function.
+// The third argument (specifying the size) must be a constant.
+def int_memcpy_inline
+    : DefaultAttrsIntrinsic<[],
+      [llvm_anyptr_ty, llvm_anyptr_ty, llvm_anyint_ty, llvm_i1_ty],
+      [IntrArgMemOnly, IntrWillReturn,
+       NoCapture<ArgIndex<0>>, NoCapture<ArgIndex<1>>,
+       NoAlias<ArgIndex<0>>, NoAlias<ArgIndex<1>>,
+       WriteOnly<ArgIndex<0>>, ReadOnly<ArgIndex<1>>,
+       ImmArg<ArgIndex<2>>, ImmArg<ArgIndex<3>>]>;
+
+def int_memmove : DefaultAttrsIntrinsic<[],
+                            [llvm_anyptr_ty, llvm_anyptr_ty, llvm_anyint_ty,
+                             llvm_i1_ty],
+                            [IntrArgMemOnly, IntrWillReturn,
+                             NoCapture<ArgIndex<0>>, NoCapture<ArgIndex<1>>,
+                             WriteOnly<ArgIndex<0>>, ReadOnly<ArgIndex<1>>,
+                             ImmArg<ArgIndex<3>>]>;
+def int_memset  : DefaultAttrsIntrinsic<[],
                             [llvm_anyptr_ty, llvm_i8_ty, llvm_anyint_ty,
                              llvm_i1_ty],
-                            [IntrArgMemOnly, NoCapture<0>, WriteOnly<0>,
-                            ImmArg<3>]>;
+                            [IntrWriteMem, IntrArgMemOnly, IntrWillReturn,
+                             NoCapture<ArgIndex<0>>, WriteOnly<ArgIndex<0>>,
+                             ImmArg<ArgIndex<3>>]>;
 
 // FIXME: Add version of these floating point intrinsics which allow non-default
 // rounding modes and FP exception handling.
 
-let IntrProperties = [IntrNoMem, IntrSpeculatable] in {
-  def int_fma  : Intrinsic<[llvm_anyfloat_ty],
+let IntrProperties = [IntrNoMem, IntrSpeculatable, IntrWillReturn] in {
+  def int_fma  : DefaultAttrsIntrinsic<[llvm_anyfloat_ty],
                            [LLVMMatchType<0>, LLVMMatchType<0>,
                             LLVMMatchType<0>]>;
-  def int_fmuladd : Intrinsic<[llvm_anyfloat_ty],
+  def int_fmuladd : DefaultAttrsIntrinsic<[llvm_anyfloat_ty],
                               [LLVMMatchType<0>, LLVMMatchType<0>,
                                LLVMMatchType<0>]>;
 
   // These functions do not read memory, but are sensitive to the
   // rounding mode. LLVM purposely does not model changes to the FP
   // environment so they can be treated as readnone.
-  def int_sqrt : Intrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>]>;
-  def int_powi : Intrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>, llvm_i32_ty]>;
-  def int_sin  : Intrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>]>;
-  def int_cos  : Intrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>]>;
-  def int_pow  : Intrinsic<[llvm_anyfloat_ty],
+  def int_sqrt : DefaultAttrsIntrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>]>;
+  def int_powi : DefaultAttrsIntrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>, llvm_i32_ty]>;
+  def int_sin  : DefaultAttrsIntrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>]>;
+  def int_cos  : DefaultAttrsIntrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>]>;
+  def int_pow  : DefaultAttrsIntrinsic<[llvm_anyfloat_ty],
                            [LLVMMatchType<0>, LLVMMatchType<0>]>;
-  def int_log  : Intrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>]>;
-  def int_log10: Intrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>]>;
-  def int_log2 : Intrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>]>;
-  def int_exp  : Intrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>]>;
-  def int_exp2 : Intrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>]>;
-  def int_fabs : Intrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>]>;
-  def int_copysign : Intrinsic<[llvm_anyfloat_ty],
+  def int_log  : DefaultAttrsIntrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>]>;
+  def int_log10: DefaultAttrsIntrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>]>;
+  def int_log2 : DefaultAttrsIntrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>]>;
+  def int_exp  : DefaultAttrsIntrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>]>;
+  def int_exp2 : DefaultAttrsIntrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>]>;
+  def int_fabs : DefaultAttrsIntrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>]>;
+  def int_copysign : DefaultAttrsIntrinsic<[llvm_anyfloat_ty],
                                [LLVMMatchType<0>, LLVMMatchType<0>]>;
-  def int_floor : Intrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>]>;
-  def int_ceil  : Intrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>]>;
-  def int_trunc : Intrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>]>;
-  def int_rint  : Intrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>]>;
-  def int_nearbyint : Intrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>]>;
-  def int_round : Intrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>]>;
-  def int_canonicalize : Intrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>],
+  def int_floor : DefaultAttrsIntrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>]>;
+  def int_ceil  : DefaultAttrsIntrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>]>;
+  def int_trunc : DefaultAttrsIntrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>]>;
+  def int_rint  : DefaultAttrsIntrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>]>;
+  def int_nearbyint : DefaultAttrsIntrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>]>;
+  def int_round : DefaultAttrsIntrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>]>;
+  def int_roundeven    : DefaultAttrsIntrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>]>;
+  def int_canonicalize : DefaultAttrsIntrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>],
                                    [IntrNoMem]>;
 
-  def int_lround : Intrinsic<[llvm_anyint_ty], [llvm_anyfloat_ty]>;
-  def int_llround : Intrinsic<[llvm_anyint_ty], [llvm_anyfloat_ty]>;
-  def int_lrint : Intrinsic<[llvm_anyint_ty], [llvm_anyfloat_ty]>;
-  def int_llrint : Intrinsic<[llvm_anyint_ty], [llvm_anyfloat_ty]>;
+  def int_lround : DefaultAttrsIntrinsic<[llvm_anyint_ty], [llvm_anyfloat_ty]>;
+  def int_llround : DefaultAttrsIntrinsic<[llvm_anyint_ty], [llvm_anyfloat_ty]>;
+  def int_lrint : DefaultAttrsIntrinsic<[llvm_anyint_ty], [llvm_anyfloat_ty]>;
+  def int_llrint : DefaultAttrsIntrinsic<[llvm_anyint_ty], [llvm_anyfloat_ty]>;
 }
 
-def int_minnum : Intrinsic<[llvm_anyfloat_ty],
+def int_minnum : DefaultAttrsIntrinsic<[llvm_anyfloat_ty],
   [LLVMMatchType<0>, LLVMMatchType<0>],
-  [IntrNoMem, IntrSpeculatable, Commutative]
+  [IntrNoMem, IntrSpeculatable, IntrWillReturn, Commutative]
 >;
-def int_maxnum : Intrinsic<[llvm_anyfloat_ty],
+def int_maxnum : DefaultAttrsIntrinsic<[llvm_anyfloat_ty],
   [LLVMMatchType<0>, LLVMMatchType<0>],
-  [IntrNoMem, IntrSpeculatable, Commutative]
+  [IntrNoMem, IntrSpeculatable, IntrWillReturn, Commutative]
 >;
-def int_minimum : Intrinsic<[llvm_anyfloat_ty],
+def int_minimum : DefaultAttrsIntrinsic<[llvm_anyfloat_ty],
   [LLVMMatchType<0>, LLVMMatchType<0>],
-  [IntrNoMem, IntrSpeculatable, Commutative]
+  [IntrNoMem, IntrSpeculatable, IntrWillReturn, Commutative]
 >;
-def int_maximum : Intrinsic<[llvm_anyfloat_ty],
+def int_maximum : DefaultAttrsIntrinsic<[llvm_anyfloat_ty],
   [LLVMMatchType<0>, LLVMMatchType<0>],
-  [IntrNoMem, IntrSpeculatable, Commutative]
+  [IntrNoMem, IntrSpeculatable, IntrWillReturn, Commutative]
 >;
 
-// NOTE: these are internal interfaces.
-def int_setjmp     : Intrinsic<[llvm_i32_ty],  [llvm_ptr_ty]>;
-def int_longjmp    : Intrinsic<[], [llvm_ptr_ty, llvm_i32_ty], [IntrNoReturn]>;
-def int_sigsetjmp  : Intrinsic<[llvm_i32_ty] , [llvm_ptr_ty, llvm_i32_ty]>;
-def int_siglongjmp : Intrinsic<[], [llvm_ptr_ty, llvm_i32_ty], [IntrNoReturn]>;
-
 // Internal interface for object size checking
-def int_objectsize : Intrinsic<[llvm_anyint_ty],
+def int_objectsize : DefaultAttrsIntrinsic<[llvm_anyint_ty],
                                [llvm_anyptr_ty, llvm_i1_ty,
                                 llvm_i1_ty, llvm_i1_ty],
-                               [IntrNoMem, IntrSpeculatable, ImmArg<1>, ImmArg<2>, ImmArg<3>]>,
+                               [IntrNoMem, IntrSpeculatable, IntrWillReturn,
+                                ImmArg<ArgIndex<1>>, ImmArg<ArgIndex<2>>,
+                                ImmArg<ArgIndex<3>>]>,
                                GCCBuiltin<"__builtin_object_size">;
 
+//===--------------- Access to Floating Point Environment -----------------===//
+//
+
+let IntrProperties = [IntrInaccessibleMemOnly, IntrWillReturn] in {
+  def int_flt_rounds    : DefaultAttrsIntrinsic<[llvm_i32_ty], []>;
+}
+
 //===--------------- Constrained Floating Point Intrinsics ----------------===//
 //
 
-let IntrProperties = [IntrInaccessibleMemOnly] in {
-  def int_experimental_constrained_fadd : Intrinsic<[ llvm_anyfloat_ty ],
+let IntrProperties = [IntrInaccessibleMemOnly, IntrWillReturn] in {
+  def int_experimental_constrained_fadd : DefaultAttrsIntrinsic<[ llvm_anyfloat_ty ],
                                                     [ LLVMMatchType<0>,
                                                       LLVMMatchType<0>,
                                                       llvm_metadata_ty,
                                                       llvm_metadata_ty ]>;
-  def int_experimental_constrained_fsub : Intrinsic<[ llvm_anyfloat_ty ],
+  def int_experimental_constrained_fsub : DefaultAttrsIntrinsic<[ llvm_anyfloat_ty ],
                                                     [ LLVMMatchType<0>,
                                                       LLVMMatchType<0>,
                                                       llvm_metadata_ty,
                                                       llvm_metadata_ty ]>;
-  def int_experimental_constrained_fmul : Intrinsic<[ llvm_anyfloat_ty ],
+  def int_experimental_constrained_fmul : DefaultAttrsIntrinsic<[ llvm_anyfloat_ty ],
                                                     [ LLVMMatchType<0>,
                                                       LLVMMatchType<0>,
                                                       llvm_metadata_ty,
                                                       llvm_metadata_ty ]>;
-  def int_experimental_constrained_fdiv : Intrinsic<[ llvm_anyfloat_ty ],
+  def int_experimental_constrained_fdiv : DefaultAttrsIntrinsic<[ llvm_anyfloat_ty ],
                                                     [ LLVMMatchType<0>,
                                                       LLVMMatchType<0>,
                                                       llvm_metadata_ty,
                                                       llvm_metadata_ty ]>;
-  def int_experimental_constrained_frem : Intrinsic<[ llvm_anyfloat_ty ],
+  def int_experimental_constrained_frem : DefaultAttrsIntrinsic<[ llvm_anyfloat_ty ],
                                                     [ LLVMMatchType<0>,
                                                       LLVMMatchType<0>,
                                                       llvm_metadata_ty,
                                                       llvm_metadata_ty ]>;
 
-  def int_experimental_constrained_fma : Intrinsic<[ llvm_anyfloat_ty ],
+  def int_experimental_constrained_fma : DefaultAttrsIntrinsic<[ llvm_anyfloat_ty ],
                                                     [ LLVMMatchType<0>,
                                                       LLVMMatchType<0>,
                                                       LLVMMatchType<0>,
                                                       llvm_metadata_ty,
                                                       llvm_metadata_ty ]>;
 
-  def int_experimental_constrained_fptrunc : Intrinsic<[ llvm_anyfloat_ty ],
+  def int_experimental_constrained_fmuladd : DefaultAttrsIntrinsic<[ llvm_anyfloat_ty ],
+                                                       [ LLVMMatchType<0>,
+                                                         LLVMMatchType<0>,
+                                                         LLVMMatchType<0>,
+                                                         llvm_metadata_ty,
+                                                         llvm_metadata_ty ]>;
+
+  def int_experimental_constrained_fptosi : DefaultAttrsIntrinsic<[ llvm_anyint_ty ],
+                                                    [ llvm_anyfloat_ty,
+                                                      llvm_metadata_ty ]>;
+
+  def int_experimental_constrained_fptoui : DefaultAttrsIntrinsic<[ llvm_anyint_ty ],
+                                                    [ llvm_anyfloat_ty,
+                                                      llvm_metadata_ty ]>;
+
+  def int_experimental_constrained_sitofp : DefaultAttrsIntrinsic<[ llvm_anyfloat_ty ],
+                                                       [ llvm_anyint_ty,
+                                                         llvm_metadata_ty,
+                                                         llvm_metadata_ty ]>;
+
+  def int_experimental_constrained_uitofp : DefaultAttrsIntrinsic<[ llvm_anyfloat_ty ],
+                                                       [ llvm_anyint_ty,
+                                                         llvm_metadata_ty,
+                                                         llvm_metadata_ty ]>;
+
+  def int_experimental_constrained_fptrunc : DefaultAttrsIntrinsic<[ llvm_anyfloat_ty ],
                                                        [ llvm_anyfloat_ty,
                                                          llvm_metadata_ty,
                                                          llvm_metadata_ty ]>;
 
-  def int_experimental_constrained_fpext : Intrinsic<[ llvm_anyfloat_ty ],
+  def int_experimental_constrained_fpext : DefaultAttrsIntrinsic<[ llvm_anyfloat_ty ],
                                                      [ llvm_anyfloat_ty,
                                                        llvm_metadata_ty ]>;
 
@@ -626,107 +756,142 @@
   // versions of each of them.  When strict rounding and exception control are
   // not required the non-constrained versions of these intrinsics should be
   // used.
-  def int_experimental_constrained_sqrt : Intrinsic<[ llvm_anyfloat_ty ],
+  def int_experimental_constrained_sqrt : DefaultAttrsIntrinsic<[ llvm_anyfloat_ty ],
                                                     [ LLVMMatchType<0>,
                                                       llvm_metadata_ty,
                                                       llvm_metadata_ty ]>;
-  def int_experimental_constrained_powi : Intrinsic<[ llvm_anyfloat_ty ],
+  def int_experimental_constrained_powi : DefaultAttrsIntrinsic<[ llvm_anyfloat_ty ],
                                                     [ LLVMMatchType<0>,
                                                       llvm_i32_ty,
                                                       llvm_metadata_ty,
                                                       llvm_metadata_ty ]>;
-  def int_experimental_constrained_sin  : Intrinsic<[ llvm_anyfloat_ty ],
+  def int_experimental_constrained_sin  : DefaultAttrsIntrinsic<[ llvm_anyfloat_ty ],
                                                     [ LLVMMatchType<0>,
                                                       llvm_metadata_ty,
                                                       llvm_metadata_ty ]>;
-  def int_experimental_constrained_cos  : Intrinsic<[ llvm_anyfloat_ty ],
+  def int_experimental_constrained_cos  : DefaultAttrsIntrinsic<[ llvm_anyfloat_ty ],
                                                     [ LLVMMatchType<0>,
                                                       llvm_metadata_ty,
                                                       llvm_metadata_ty ]>;
-  def int_experimental_constrained_pow  : Intrinsic<[ llvm_anyfloat_ty ],
+  def int_experimental_constrained_pow  : DefaultAttrsIntrinsic<[ llvm_anyfloat_ty ],
                                                     [ LLVMMatchType<0>,
                                                       LLVMMatchType<0>,
                                                       llvm_metadata_ty,
                                                       llvm_metadata_ty ]>;
-  def int_experimental_constrained_log  : Intrinsic<[ llvm_anyfloat_ty ],
+  def int_experimental_constrained_log  : DefaultAttrsIntrinsic<[ llvm_anyfloat_ty ],
                                                     [ LLVMMatchType<0>,
                                                       llvm_metadata_ty,
                                                       llvm_metadata_ty ]>;
-  def int_experimental_constrained_log10: Intrinsic<[ llvm_anyfloat_ty ],
+  def int_experimental_constrained_log10: DefaultAttrsIntrinsic<[ llvm_anyfloat_ty ],
                                                     [ LLVMMatchType<0>,
                                                       llvm_metadata_ty,
                                                       llvm_metadata_ty ]>;
-  def int_experimental_constrained_log2 : Intrinsic<[ llvm_anyfloat_ty ],
+  def int_experimental_constrained_log2 : DefaultAttrsIntrinsic<[ llvm_anyfloat_ty ],
                                                     [ LLVMMatchType<0>,
                                                       llvm_metadata_ty,
                                                       llvm_metadata_ty ]>;
-  def int_experimental_constrained_exp  : Intrinsic<[ llvm_anyfloat_ty ],
+  def int_experimental_constrained_exp  : DefaultAttrsIntrinsic<[ llvm_anyfloat_ty ],
                                                     [ LLVMMatchType<0>,
                                                       llvm_metadata_ty,
                                                       llvm_metadata_ty ]>;
-  def int_experimental_constrained_exp2 : Intrinsic<[ llvm_anyfloat_ty ],
+  def int_experimental_constrained_exp2 : DefaultAttrsIntrinsic<[ llvm_anyfloat_ty ],
                                                     [ LLVMMatchType<0>,
                                                       llvm_metadata_ty,
                                                       llvm_metadata_ty ]>;
-  def int_experimental_constrained_rint  : Intrinsic<[ llvm_anyfloat_ty ],
+  def int_experimental_constrained_rint  : DefaultAttrsIntrinsic<[ llvm_anyfloat_ty ],
                                                      [ LLVMMatchType<0>,
                                                        llvm_metadata_ty,
                                                        llvm_metadata_ty ]>;
-  def int_experimental_constrained_nearbyint : Intrinsic<[ llvm_anyfloat_ty ],
+  def int_experimental_constrained_nearbyint : DefaultAttrsIntrinsic<[ llvm_anyfloat_ty ],
                                                          [ LLVMMatchType<0>,
                                                            llvm_metadata_ty,
                                                            llvm_metadata_ty ]>;
-  def int_experimental_constrained_maxnum : Intrinsic<[ llvm_anyfloat_ty ],
-                                                      [ LLVMMatchType<0>,
-                                                        LLVMMatchType<0>,
+  def int_experimental_constrained_lrint : DefaultAttrsIntrinsic<[ llvm_anyint_ty ],
+                                                     [ llvm_anyfloat_ty,
+                                                       llvm_metadata_ty,
+                                                       llvm_metadata_ty ]>;
+  def int_experimental_constrained_llrint : DefaultAttrsIntrinsic<[ llvm_anyint_ty ],
+                                                      [ llvm_anyfloat_ty,
                                                         llvm_metadata_ty,
                                                         llvm_metadata_ty ]>;
-  def int_experimental_constrained_minnum : Intrinsic<[ llvm_anyfloat_ty ],
+  def int_experimental_constrained_maxnum : DefaultAttrsIntrinsic<[ llvm_anyfloat_ty ],
                                                       [ LLVMMatchType<0>,
                                                         LLVMMatchType<0>,
-                                                        llvm_metadata_ty,
                                                         llvm_metadata_ty ]>;
-  def int_experimental_constrained_ceil : Intrinsic<[ llvm_anyfloat_ty ],
+  def int_experimental_constrained_minnum : DefaultAttrsIntrinsic<[ llvm_anyfloat_ty ],
+                                                      [ LLVMMatchType<0>,
+                                                        LLVMMatchType<0>,
+                                                        llvm_metadata_ty ]>;
+  def int_experimental_constrained_maximum : DefaultAttrsIntrinsic<[ llvm_anyfloat_ty ],
+                                                       [ LLVMMatchType<0>,
+                                                         LLVMMatchType<0>,
+                                                         llvm_metadata_ty ]>;
+  def int_experimental_constrained_minimum : DefaultAttrsIntrinsic<[ llvm_anyfloat_ty ],
+                                                       [ LLVMMatchType<0>,
+                                                         LLVMMatchType<0>,
+                                                         llvm_metadata_ty ]>;
+  def int_experimental_constrained_ceil : DefaultAttrsIntrinsic<[ llvm_anyfloat_ty ],
                                                     [ LLVMMatchType<0>,
-                                                      llvm_metadata_ty,
                                                       llvm_metadata_ty ]>;
-  def int_experimental_constrained_floor : Intrinsic<[ llvm_anyfloat_ty ],
+  def int_experimental_constrained_floor : DefaultAttrsIntrinsic<[ llvm_anyfloat_ty ],
                                                      [ LLVMMatchType<0>,
-                                                       llvm_metadata_ty,
                                                        llvm_metadata_ty ]>;
-  def int_experimental_constrained_round : Intrinsic<[ llvm_anyfloat_ty ],
+  def int_experimental_constrained_lround : DefaultAttrsIntrinsic<[ llvm_anyint_ty ],
+                                                      [ llvm_anyfloat_ty,
+                                                        llvm_metadata_ty ]>;
+  def int_experimental_constrained_llround : DefaultAttrsIntrinsic<[ llvm_anyint_ty ],
+                                                       [ llvm_anyfloat_ty,
+                                                         llvm_metadata_ty ]>;
+  def int_experimental_constrained_round : DefaultAttrsIntrinsic<[ llvm_anyfloat_ty ],
                                                      [ LLVMMatchType<0>,
-                                                      llvm_metadata_ty,
                                                       llvm_metadata_ty ]>;
-  def int_experimental_constrained_trunc : Intrinsic<[ llvm_anyfloat_ty ],
+  def int_experimental_constrained_roundeven : DefaultAttrsIntrinsic<[ llvm_anyfloat_ty ],
+                                                         [ LLVMMatchType<0>,
+                                                           llvm_metadata_ty ]>;
+  def int_experimental_constrained_trunc : DefaultAttrsIntrinsic<[ llvm_anyfloat_ty ],
                                                      [ LLVMMatchType<0>,
-                                                       llvm_metadata_ty,
                                                        llvm_metadata_ty ]>;
+
+  // Constrained floating-point comparison (quiet and signaling variants).
+  // Third operand is the predicate represented as a metadata string.
+  def int_experimental_constrained_fcmp
+      : DefaultAttrsIntrinsic<[ LLVMScalarOrSameVectorWidth<0, llvm_i1_ty> ],
+                  [ llvm_anyfloat_ty, LLVMMatchType<0>,
+                    llvm_metadata_ty, llvm_metadata_ty ]>;
+  def int_experimental_constrained_fcmps
+      : DefaultAttrsIntrinsic<[ LLVMScalarOrSameVectorWidth<0, llvm_i1_ty> ],
+                  [ llvm_anyfloat_ty, LLVMMatchType<0>,
+                    llvm_metadata_ty, llvm_metadata_ty ]>;
 }
-// FIXME: Add intrinsics for fcmp, fptoui and fptosi.
+// FIXME: Consider maybe adding intrinsics for sitofp, uitofp.
 
 //===------------------------- Expect Intrinsics --------------------------===//
 //
-def int_expect : Intrinsic<[llvm_anyint_ty],
-  [LLVMMatchType<0>, LLVMMatchType<0>], [IntrNoMem]>;
+def int_expect : DefaultAttrsIntrinsic<[llvm_anyint_ty],
+  [LLVMMatchType<0>, LLVMMatchType<0>], [IntrNoMem, IntrWillReturn]>;
+
+def int_expect_with_probability : DefaultAttrsIntrinsic<[llvm_anyint_ty],
+  [LLVMMatchType<0>, LLVMMatchType<0>, llvm_double_ty],
+  [IntrNoMem, IntrWillReturn]>;
 
 //===-------------------- Bit Manipulation Intrinsics ---------------------===//
 //
 
 // None of these intrinsics accesses memory at all.
-let IntrProperties = [IntrNoMem, IntrSpeculatable] in {
-  def int_bswap: Intrinsic<[llvm_anyint_ty], [LLVMMatchType<0>]>;
-  def int_ctpop: Intrinsic<[llvm_anyint_ty], [LLVMMatchType<0>]>;
-  def int_bitreverse : Intrinsic<[llvm_anyint_ty], [LLVMMatchType<0>]>;
-  def int_fshl : Intrinsic<[llvm_anyint_ty],
+let IntrProperties = [IntrNoMem, IntrSpeculatable, IntrWillReturn] in {
+  def int_bswap: DefaultAttrsIntrinsic<[llvm_anyint_ty], [LLVMMatchType<0>]>;
+  def int_ctpop: DefaultAttrsIntrinsic<[llvm_anyint_ty], [LLVMMatchType<0>]>;
+  def int_bitreverse : DefaultAttrsIntrinsic<[llvm_anyint_ty], [LLVMMatchType<0>]>;
+  def int_fshl : DefaultAttrsIntrinsic<[llvm_anyint_ty],
       [LLVMMatchType<0>, LLVMMatchType<0>, LLVMMatchType<0>]>;
-  def int_fshr : Intrinsic<[llvm_anyint_ty],
+  def int_fshr : DefaultAttrsIntrinsic<[llvm_anyint_ty],
       [LLVMMatchType<0>, LLVMMatchType<0>, LLVMMatchType<0>]>;
 }
 
-let IntrProperties = [IntrNoMem, IntrSpeculatable, ImmArg<1>] in {
-  def int_ctlz : Intrinsic<[llvm_anyint_ty], [LLVMMatchType<0>, llvm_i1_ty]>;
-  def int_cttz : Intrinsic<[llvm_anyint_ty], [LLVMMatchType<0>, llvm_i1_ty]>;
+let IntrProperties = [IntrNoMem, IntrSpeculatable, IntrWillReturn,
+                      ImmArg<ArgIndex<1>>] in {
+  def int_ctlz : DefaultAttrsIntrinsic<[llvm_anyint_ty], [LLVMMatchType<0>, llvm_i1_ty]>;
+  def int_cttz : DefaultAttrsIntrinsic<[llvm_anyint_ty], [LLVMMatchType<0>, llvm_i1_ty]>;
 }
 
 //===------------------------ Debugger Intrinsics -------------------------===//
@@ -736,20 +901,20 @@
 // mean the optimizers can change them aggressively.  Special handling
 // needed in a few places. These synthetic intrinsics have no
 // side-effects and just mark information about their operands.
-let IntrProperties = [IntrNoMem, IntrSpeculatable] in {
-  def int_dbg_declare      : Intrinsic<[],
+let IntrProperties = [IntrNoMem, IntrSpeculatable, IntrWillReturn] in {
+  def int_dbg_declare      : DefaultAttrsIntrinsic<[],
                                        [llvm_metadata_ty,
                                         llvm_metadata_ty,
                                         llvm_metadata_ty]>;
-  def int_dbg_value        : Intrinsic<[],
+  def int_dbg_value        : DefaultAttrsIntrinsic<[],
                                        [llvm_metadata_ty,
                                         llvm_metadata_ty,
                                         llvm_metadata_ty]>;
-  def int_dbg_addr         : Intrinsic<[],
+  def int_dbg_addr         : DefaultAttrsIntrinsic<[],
                                        [llvm_metadata_ty,
                                         llvm_metadata_ty,
                                         llvm_metadata_ty]>;
-  def int_dbg_label        : Intrinsic<[],
+  def int_dbg_label        : DefaultAttrsIntrinsic<[],
                                        [llvm_metadata_ty]>;
 }
 
@@ -779,10 +944,9 @@
 
 def int_eh_dwarf_cfa  : Intrinsic<[llvm_ptr_ty], [llvm_i32_ty]>;
 
-let IntrProperties = [IntrNoMem] in {
-  def int_eh_sjlj_lsda             : Intrinsic<[llvm_ptr_ty]>;
-  def int_eh_sjlj_callsite         : Intrinsic<[], [llvm_i32_ty]>;
-}
+def int_eh_sjlj_lsda             : Intrinsic<[llvm_ptr_ty], [], [IntrNoMem]>;
+def int_eh_sjlj_callsite         : Intrinsic<[], [llvm_i32_ty], [IntrNoMem]>;
+
 def int_eh_sjlj_functioncontext : Intrinsic<[], [llvm_ptr_ty]>;
 def int_eh_sjlj_setjmp          : Intrinsic<[llvm_i32_ty], [llvm_ptr_ty]>;
 def int_eh_sjlj_longjmp         : Intrinsic<[], [llvm_ptr_ty], [IntrNoReturn]>;
@@ -790,114 +954,165 @@
 
 //===---------------- Generic Variable Attribute Intrinsics----------------===//
 //
-def int_var_annotation : Intrinsic<[],
+def int_var_annotation : DefaultAttrsIntrinsic<[],
                                    [llvm_ptr_ty, llvm_ptr_ty,
-                                    llvm_ptr_ty, llvm_i32_ty],
-                                   [], "llvm.var.annotation">;
-def int_ptr_annotation : Intrinsic<[LLVMAnyPointerType<llvm_anyint_ty>],
+                                    llvm_ptr_ty, llvm_i32_ty, llvm_ptr_ty],
+                                   [IntrWillReturn], "llvm.var.annotation">;
+def int_ptr_annotation : DefaultAttrsIntrinsic<[LLVMAnyPointerType<llvm_anyint_ty>],
                                    [LLVMMatchType<0>, llvm_ptr_ty, llvm_ptr_ty,
-                                    llvm_i32_ty],
-                                   [], "llvm.ptr.annotation">;
-def int_annotation : Intrinsic<[llvm_anyint_ty],
+                                    llvm_i32_ty, llvm_ptr_ty],
+                                   [IntrWillReturn], "llvm.ptr.annotation">;
+def int_annotation : DefaultAttrsIntrinsic<[llvm_anyint_ty],
                                [LLVMMatchType<0>, llvm_ptr_ty,
                                 llvm_ptr_ty, llvm_i32_ty],
-                               [], "llvm.annotation">;
+                               [IntrWillReturn], "llvm.annotation">;
 
 // Annotates the current program point with metadata strings which are emitted
 // as CodeView debug info records. This is expensive, as it disables inlining
 // and is modelled as having side effects.
-def int_codeview_annotation : Intrinsic<[], [llvm_metadata_ty],
-                                        [IntrInaccessibleMemOnly, IntrNoDuplicate],
+def int_codeview_annotation : DefaultAttrsIntrinsic<[], [llvm_metadata_ty],
+                                        [IntrInaccessibleMemOnly, IntrNoDuplicate, IntrWillReturn],
                                         "llvm.codeview.annotation">;
 
 //===------------------------ Trampoline Intrinsics -----------------------===//
 //
 def int_init_trampoline : Intrinsic<[],
                                     [llvm_ptr_ty, llvm_ptr_ty, llvm_ptr_ty],
-                                    [IntrArgMemOnly, NoCapture<0>]>,
-                                   GCCBuiltin<"__builtin_init_trampoline">;
+                                    [IntrArgMemOnly, NoCapture<ArgIndex<0>>]>,
+                                    GCCBuiltin<"__builtin_init_trampoline">;
 
 def int_adjust_trampoline : Intrinsic<[llvm_ptr_ty], [llvm_ptr_ty],
                                       [IntrReadMem, IntrArgMemOnly]>,
-                                     GCCBuiltin<"__builtin_adjust_trampoline">;
+                                      GCCBuiltin<"__builtin_adjust_trampoline">;
 
 //===------------------------ Overflow Intrinsics -------------------------===//
 //
 
 // Expose the carry flag from add operations on two integrals.
-def int_sadd_with_overflow : Intrinsic<[llvm_anyint_ty,
-                                        LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>],
-                                       [LLVMMatchType<0>, LLVMMatchType<0>],
-                                       [IntrNoMem, IntrSpeculatable]>;
-def int_uadd_with_overflow : Intrinsic<[llvm_anyint_ty,
-                                        LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>],
-                                       [LLVMMatchType<0>, LLVMMatchType<0>],
-                                       [IntrNoMem, IntrSpeculatable]>;
+let IntrProperties = [IntrNoMem, IntrSpeculatable, IntrWillReturn] in {
+  def int_sadd_with_overflow : DefaultAttrsIntrinsic<[llvm_anyint_ty,
+                                          LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>],
+                                         [LLVMMatchType<0>, LLVMMatchType<0>]>;
+  def int_uadd_with_overflow : DefaultAttrsIntrinsic<[llvm_anyint_ty,
+                                          LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>],
+                                         [LLVMMatchType<0>, LLVMMatchType<0>]>;
 
-def int_ssub_with_overflow : Intrinsic<[llvm_anyint_ty,
-                                        LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>],
-                                       [LLVMMatchType<0>, LLVMMatchType<0>],
-                                       [IntrNoMem, IntrSpeculatable]>;
-def int_usub_with_overflow : Intrinsic<[llvm_anyint_ty,
-                                        LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>],
-                                       [LLVMMatchType<0>, LLVMMatchType<0>],
-                                       [IntrNoMem, IntrSpeculatable]>;
+  def int_ssub_with_overflow : DefaultAttrsIntrinsic<[llvm_anyint_ty,
+                                          LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>],
+                                         [LLVMMatchType<0>, LLVMMatchType<0>]>;
+  def int_usub_with_overflow : DefaultAttrsIntrinsic<[llvm_anyint_ty,
+                                          LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>],
+                                         [LLVMMatchType<0>, LLVMMatchType<0>]>;
 
-def int_smul_with_overflow : Intrinsic<[llvm_anyint_ty,
-                                        LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>],
-                                       [LLVMMatchType<0>, LLVMMatchType<0>],
-                                       [IntrNoMem, IntrSpeculatable]>;
-def int_umul_with_overflow : Intrinsic<[llvm_anyint_ty,
-                                        LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>],
-                                       [LLVMMatchType<0>, LLVMMatchType<0>],
-                                       [IntrNoMem, IntrSpeculatable]>;
-
+  def int_smul_with_overflow : DefaultAttrsIntrinsic<[llvm_anyint_ty,
+                                          LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>],
+                                         [LLVMMatchType<0>, LLVMMatchType<0>]>;
+  def int_umul_with_overflow : DefaultAttrsIntrinsic<[llvm_anyint_ty,
+                                          LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>],
+                                         [LLVMMatchType<0>, LLVMMatchType<0>]>;
+}
 //===------------------------- Saturation Arithmetic Intrinsics ---------------------===//
 //
-def int_sadd_sat : Intrinsic<[llvm_anyint_ty],
+def int_sadd_sat : DefaultAttrsIntrinsic<[llvm_anyint_ty],
                              [LLVMMatchType<0>, LLVMMatchType<0>],
-                             [IntrNoMem, IntrSpeculatable, Commutative]>;
-def int_uadd_sat : Intrinsic<[llvm_anyint_ty],
+                             [IntrNoMem, IntrSpeculatable, IntrWillReturn, Commutative]>;
+def int_uadd_sat : DefaultAttrsIntrinsic<[llvm_anyint_ty],
                              [LLVMMatchType<0>, LLVMMatchType<0>],
-                             [IntrNoMem, IntrSpeculatable, Commutative]>;
-def int_ssub_sat : Intrinsic<[llvm_anyint_ty],
+                             [IntrNoMem, IntrSpeculatable, IntrWillReturn, Commutative]>;
+def int_ssub_sat : DefaultAttrsIntrinsic<[llvm_anyint_ty],
                              [LLVMMatchType<0>, LLVMMatchType<0>],
-                             [IntrNoMem, IntrSpeculatable]>;
-def int_usub_sat : Intrinsic<[llvm_anyint_ty],
+                             [IntrNoMem, IntrSpeculatable, IntrWillReturn]>;
+def int_usub_sat : DefaultAttrsIntrinsic<[llvm_anyint_ty],
                              [LLVMMatchType<0>, LLVMMatchType<0>],
-                             [IntrNoMem, IntrSpeculatable]>;
+                             [IntrNoMem, IntrSpeculatable, IntrWillReturn]>;
+def int_sshl_sat : DefaultAttrsIntrinsic<[llvm_anyint_ty],
+                             [LLVMMatchType<0>, LLVMMatchType<0>],
+                             [IntrNoMem, IntrSpeculatable, IntrWillReturn]>;
+def int_ushl_sat : DefaultAttrsIntrinsic<[llvm_anyint_ty],
+                             [LLVMMatchType<0>, LLVMMatchType<0>],
+                             [IntrNoMem, IntrSpeculatable, IntrWillReturn]>;
 
 //===------------------------- Fixed Point Arithmetic Intrinsics ---------------------===//
 //
-def int_smul_fix : Intrinsic<[llvm_anyint_ty],
+def int_smul_fix : DefaultAttrsIntrinsic<[llvm_anyint_ty],
                              [LLVMMatchType<0>, LLVMMatchType<0>, llvm_i32_ty],
-                             [IntrNoMem, IntrSpeculatable, Commutative, ImmArg<2>]>;
+                             [IntrNoMem, IntrSpeculatable, IntrWillReturn,
+                              Commutative, ImmArg<ArgIndex<2>>]>;
 
-def int_umul_fix : Intrinsic<[llvm_anyint_ty],
+def int_umul_fix : DefaultAttrsIntrinsic<[llvm_anyint_ty],
                              [LLVMMatchType<0>, LLVMMatchType<0>, llvm_i32_ty],
-                             [IntrNoMem, IntrSpeculatable, Commutative, ImmArg<2>]>;
+                             [IntrNoMem, IntrSpeculatable, IntrWillReturn,
+                              Commutative, ImmArg<ArgIndex<2>>]>;
+
+def int_sdiv_fix : DefaultAttrsIntrinsic<[llvm_anyint_ty],
+                             [LLVMMatchType<0>, LLVMMatchType<0>, llvm_i32_ty],
+                             [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+def int_udiv_fix : DefaultAttrsIntrinsic<[llvm_anyint_ty],
+                             [LLVMMatchType<0>, LLVMMatchType<0>, llvm_i32_ty],
+                             [IntrNoMem, ImmArg<ArgIndex<2>>]>;
 
 //===------------------- Fixed Point Saturation Arithmetic Intrinsics ----------------===//
 //
-def int_smul_fix_sat : Intrinsic<[llvm_anyint_ty],
+def int_smul_fix_sat : DefaultAttrsIntrinsic<[llvm_anyint_ty],
                                  [LLVMMatchType<0>, LLVMMatchType<0>, llvm_i32_ty],
-                                 [IntrNoMem, IntrSpeculatable, Commutative, ImmArg<2>]>;
+                                 [IntrNoMem, IntrSpeculatable, IntrWillReturn,
+                                  Commutative, ImmArg<ArgIndex<2>>]>;
+def int_umul_fix_sat : DefaultAttrsIntrinsic<[llvm_anyint_ty],
+                                 [LLVMMatchType<0>, LLVMMatchType<0>, llvm_i32_ty],
+                                 [IntrNoMem, IntrSpeculatable, IntrWillReturn,
+                                  Commutative, ImmArg<ArgIndex<2>>]>;
+
+def int_sdiv_fix_sat : DefaultAttrsIntrinsic<[llvm_anyint_ty],
+                                 [LLVMMatchType<0>, LLVMMatchType<0>, llvm_i32_ty],
+                                 [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+def int_udiv_fix_sat : DefaultAttrsIntrinsic<[llvm_anyint_ty],
+                                 [LLVMMatchType<0>, LLVMMatchType<0>, llvm_i32_ty],
+                                 [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+//===------------------ Integer Min/Max/Abs Intrinsics --------------------===//
+//
+def int_abs : DefaultAttrsIntrinsic<
+    [llvm_anyint_ty], [LLVMMatchType<0>, llvm_i1_ty],
+    [IntrNoMem, IntrSpeculatable, IntrWillReturn, ImmArg<ArgIndex<1>>]>;
+
+def int_smax : DefaultAttrsIntrinsic<
+    [llvm_anyint_ty], [LLVMMatchType<0>, LLVMMatchType<0>],
+    [IntrNoMem, IntrSpeculatable, IntrWillReturn]>;
+def int_smin : DefaultAttrsIntrinsic<
+    [llvm_anyint_ty], [LLVMMatchType<0>, LLVMMatchType<0>],
+    [IntrNoMem, IntrSpeculatable, IntrWillReturn]>;
+def int_umax : DefaultAttrsIntrinsic<
+    [llvm_anyint_ty], [LLVMMatchType<0>, LLVMMatchType<0>],
+    [IntrNoMem, IntrSpeculatable, IntrWillReturn]>;
+def int_umin : DefaultAttrsIntrinsic<
+    [llvm_anyint_ty], [LLVMMatchType<0>, LLVMMatchType<0>],
+    [IntrNoMem, IntrSpeculatable, IntrWillReturn]>;
 
 //===------------------------- Memory Use Markers -------------------------===//
 //
-def int_lifetime_start  : Intrinsic<[],
+def int_lifetime_start  : DefaultAttrsIntrinsic<[],
                                     [llvm_i64_ty, llvm_anyptr_ty],
-                                    [IntrArgMemOnly, NoCapture<1>, ImmArg<0>]>;
-def int_lifetime_end    : Intrinsic<[],
+                                    [IntrArgMemOnly, IntrWillReturn,
+                                     NoCapture<ArgIndex<1>>,
+                                     ImmArg<ArgIndex<0>>]>;
+def int_lifetime_end    : DefaultAttrsIntrinsic<[],
                                     [llvm_i64_ty, llvm_anyptr_ty],
-                                    [IntrArgMemOnly, NoCapture<1>, ImmArg<0>]>;
-def int_invariant_start : Intrinsic<[llvm_descriptor_ty],
+                                    [IntrArgMemOnly, IntrWillReturn,
+                                     NoCapture<ArgIndex<1>>,
+                                     ImmArg<ArgIndex<0>>]>;
+def int_invariant_start : DefaultAttrsIntrinsic<[llvm_descriptor_ty],
                                     [llvm_i64_ty, llvm_anyptr_ty],
-                                    [IntrArgMemOnly, NoCapture<1>, ImmArg<0>]>;
-def int_invariant_end   : Intrinsic<[],
+                                    [IntrArgMemOnly, IntrWillReturn,
+                                     NoCapture<ArgIndex<1>>,
+                                     ImmArg<ArgIndex<0>>]>;
+def int_invariant_end   : DefaultAttrsIntrinsic<[],
                                     [llvm_descriptor_ty, llvm_i64_ty,
                                      llvm_anyptr_ty],
-                                    [IntrArgMemOnly, NoCapture<2>, ImmArg<1>]>;
+                                    [IntrArgMemOnly, IntrWillReturn,
+                                     NoCapture<ArgIndex<2>>,
+                                     ImmArg<ArgIndex<1>>]>;
 
 // launder.invariant.group can't be marked with 'readnone' (IntrNoMem),
 // because it would cause CSE of two barriers with the same argument.
@@ -911,26 +1126,26 @@
 // it would remove barrier.
 // Note that it is still experimental, which means that its semantics
 // might change in the future.
-def int_launder_invariant_group : Intrinsic<[llvm_anyptr_ty],
+def int_launder_invariant_group : DefaultAttrsIntrinsic<[llvm_anyptr_ty],
                                             [LLVMMatchType<0>],
-                                            [IntrInaccessibleMemOnly, IntrSpeculatable]>;
+                                            [IntrInaccessibleMemOnly, IntrSpeculatable, IntrWillReturn]>;
 
 
-def int_strip_invariant_group : Intrinsic<[llvm_anyptr_ty],
+def int_strip_invariant_group : DefaultAttrsIntrinsic<[llvm_anyptr_ty],
                                           [LLVMMatchType<0>],
-                                          [IntrSpeculatable, IntrNoMem]>;
+                                          [IntrSpeculatable, IntrNoMem, IntrWillReturn]>;
 
 //===------------------------ Stackmap Intrinsics -------------------------===//
 //
-def int_experimental_stackmap : Intrinsic<[],
+def int_experimental_stackmap : DefaultAttrsIntrinsic<[],
                                   [llvm_i64_ty, llvm_i32_ty, llvm_vararg_ty],
                                   [Throws]>;
-def int_experimental_patchpoint_void : Intrinsic<[],
+def int_experimental_patchpoint_void : DefaultAttrsIntrinsic<[],
                                                  [llvm_i64_ty, llvm_i32_ty,
                                                   llvm_ptr_ty, llvm_i32_ty,
                                                   llvm_vararg_ty],
                                                   [Throws]>;
-def int_experimental_patchpoint_i64 : Intrinsic<[llvm_i64_ty],
+def int_experimental_patchpoint_i64 : DefaultAttrsIntrinsic<[llvm_i64_ty],
                                                 [llvm_i64_ty, llvm_i32_ty,
                                                  llvm_ptr_ty, llvm_i32_ty,
                                                  llvm_vararg_ty],
@@ -944,13 +1159,17 @@
                                [llvm_i64_ty, llvm_i32_ty,
                                 llvm_anyptr_ty, llvm_i32_ty,
                                 llvm_i32_ty, llvm_vararg_ty],
-                                [Throws, ImmArg<0>, ImmArg<1>, ImmArg<3>, ImmArg<4>]>;
+                               [Throws, ImmArg<ArgIndex<0>>,
+                                ImmArg<ArgIndex<1>>, ImmArg<ArgIndex<3>>,
+                                ImmArg<ArgIndex<4>>]>;
 
 def int_experimental_gc_result   : Intrinsic<[llvm_any_ty], [llvm_token_ty],
                                              [IntrReadMem]>;
 def int_experimental_gc_relocate : Intrinsic<[llvm_any_ty],
-                                [llvm_token_ty, llvm_i32_ty, llvm_i32_ty],
-                                [IntrReadMem, ImmArg<1>, ImmArg<2>]>;
+                                             [llvm_token_ty, llvm_i32_ty,
+                                              llvm_i32_ty],
+                                             [IntrReadMem, ImmArg<ArgIndex<1>>,
+                                              ImmArg<ArgIndex<2>>]>;
 
 //===------------------------ Coroutine Intrinsics ---------------===//
 // These are documented in docs/Coroutines.rst
@@ -960,15 +1179,44 @@
 def int_coro_id : Intrinsic<[llvm_token_ty], [llvm_i32_ty, llvm_ptr_ty,
                              llvm_ptr_ty, llvm_ptr_ty],
                             [IntrArgMemOnly, IntrReadMem,
-                             ReadNone<1>, ReadOnly<2>, NoCapture<2>]>;
+                             ReadNone<ArgIndex<1>>, ReadOnly<ArgIndex<2>>,
+                             NoCapture<ArgIndex<2>>]>;
+def int_coro_id_retcon : Intrinsic<[llvm_token_ty],
+    [llvm_i32_ty, llvm_i32_ty, llvm_ptr_ty,
+     llvm_ptr_ty, llvm_ptr_ty, llvm_ptr_ty],
+    []>;
+def int_coro_id_retcon_once : Intrinsic<[llvm_token_ty],
+    [llvm_i32_ty, llvm_i32_ty, llvm_ptr_ty,
+     llvm_ptr_ty, llvm_ptr_ty, llvm_ptr_ty],
+    []>;
 def int_coro_alloc : Intrinsic<[llvm_i1_ty], [llvm_token_ty], []>;
+def int_coro_id_async : Intrinsic<[llvm_token_ty],
+  [llvm_i32_ty, llvm_i32_ty, llvm_i32_ty, llvm_ptr_ty],
+  []>;
+def int_coro_async_context_alloc : Intrinsic<[llvm_ptr_ty],
+    [llvm_ptr_ty, llvm_ptr_ty],
+    []>;
+def int_coro_async_context_dealloc : Intrinsic<[],
+    [llvm_ptr_ty],
+    []>;
+def int_coro_async_resume : Intrinsic<[llvm_ptr_ty],
+    [],
+    []>;
+def int_coro_suspend_async : Intrinsic<[llvm_ptr_ty, llvm_ptr_ty, llvm_ptr_ty],
+    [llvm_ptr_ty, llvm_ptr_ty, llvm_vararg_ty],
+    []>;
+def int_coro_prepare_async : Intrinsic<[llvm_ptr_ty], [llvm_ptr_ty],
+                                       [IntrNoMem]>;
 def int_coro_begin : Intrinsic<[llvm_ptr_ty], [llvm_token_ty, llvm_ptr_ty],
-                               [WriteOnly<1>]>;
+                               [WriteOnly<ArgIndex<1>>]>;
 
 def int_coro_free : Intrinsic<[llvm_ptr_ty], [llvm_token_ty, llvm_ptr_ty],
-                              [IntrReadMem, IntrArgMemOnly, ReadOnly<1>,
-                               NoCapture<1>]>;
+                              [IntrReadMem, IntrArgMemOnly,
+                               ReadOnly<ArgIndex<1>>,
+                               NoCapture<ArgIndex<1>>]>;
 def int_coro_end : Intrinsic<[llvm_i1_ty], [llvm_ptr_ty, llvm_i1_ty], []>;
+def int_coro_end_async
+    : Intrinsic<[llvm_i1_ty], [llvm_ptr_ty, llvm_i1_ty, llvm_vararg_ty], []>;
 
 def int_coro_frame : Intrinsic<[llvm_ptr_ty], [], [IntrNoMem]>;
 def int_coro_noop : Intrinsic<[llvm_ptr_ty], [], [IntrNoMem]>;
@@ -976,60 +1224,83 @@
 
 def int_coro_save : Intrinsic<[llvm_token_ty], [llvm_ptr_ty], []>;
 def int_coro_suspend : Intrinsic<[llvm_i8_ty], [llvm_token_ty, llvm_i1_ty], []>;
+def int_coro_suspend_retcon : Intrinsic<[llvm_any_ty], [llvm_vararg_ty], []>;
+def int_coro_prepare_retcon : Intrinsic<[llvm_ptr_ty], [llvm_ptr_ty],
+                                        [IntrNoMem]>;
+def int_coro_alloca_alloc : Intrinsic<[llvm_token_ty],
+                                      [llvm_anyint_ty, llvm_i32_ty], []>;
+def int_coro_alloca_get : Intrinsic<[llvm_ptr_ty], [llvm_token_ty], []>;
+def int_coro_alloca_free : Intrinsic<[], [llvm_token_ty], []>;
 
 def int_coro_param : Intrinsic<[llvm_i1_ty], [llvm_ptr_ty, llvm_ptr_ty],
-                               [IntrNoMem, ReadNone<0>, ReadNone<1>]>;
+                               [IntrNoMem, ReadNone<ArgIndex<0>>,
+                                ReadNone<ArgIndex<1>>]>;
 
 // Coroutine Manipulation Intrinsics.
 
 def int_coro_resume : Intrinsic<[], [llvm_ptr_ty], [Throws]>;
 def int_coro_destroy : Intrinsic<[], [llvm_ptr_ty], [Throws]>;
 def int_coro_done : Intrinsic<[llvm_i1_ty], [llvm_ptr_ty],
-                              [IntrArgMemOnly, ReadOnly<0>, NoCapture<0>]>;
+                              [IntrArgMemOnly, ReadOnly<ArgIndex<0>>,
+                               NoCapture<ArgIndex<0>>]>;
 def int_coro_promise : Intrinsic<[llvm_ptr_ty],
                                  [llvm_ptr_ty, llvm_i32_ty, llvm_i1_ty],
-                                 [IntrNoMem, NoCapture<0>]>;
+                                 [IntrNoMem, NoCapture<ArgIndex<0>>]>;
 
 // Coroutine Lowering Intrinsics. Used internally by coroutine passes.
 
 def int_coro_subfn_addr : Intrinsic<[llvm_ptr_ty], [llvm_ptr_ty, llvm_i8_ty],
-                                    [IntrReadMem, IntrArgMemOnly, ReadOnly<0>,
-                                     NoCapture<0>]>;
+                                    [IntrReadMem, IntrArgMemOnly,
+                                     ReadOnly<ArgIndex<0>>,
+                                     NoCapture<ArgIndex<0>>]>;
 
 ///===-------------------------- Other Intrinsics --------------------------===//
 //
-def int_flt_rounds : Intrinsic<[llvm_i32_ty]>,
-                     GCCBuiltin<"__builtin_flt_rounds">;
 def int_trap : Intrinsic<[], [], [IntrNoReturn, IntrCold]>,
                GCCBuiltin<"__builtin_trap">;
 def int_debugtrap : Intrinsic<[]>,
                     GCCBuiltin<"__builtin_debugtrap">;
+def int_ubsantrap : Intrinsic<[], [llvm_i8_ty],
+                              [IntrNoReturn, IntrCold, ImmArg<ArgIndex<0>>]>;
 
 // Support for dynamic deoptimization (or de-specialization)
 def int_experimental_deoptimize : Intrinsic<[llvm_any_ty], [llvm_vararg_ty],
                                             [Throws]>;
 
 // Support for speculative runtime guards
-def int_experimental_guard : Intrinsic<[], [llvm_i1_ty, llvm_vararg_ty],
+def int_experimental_guard : DefaultAttrsIntrinsic<[], [llvm_i1_ty, llvm_vararg_ty],
                                        [Throws]>;
 
 // Supports widenable conditions for guards represented as explicit branches.
-def int_experimental_widenable_condition : Intrinsic<[llvm_i1_ty], [],
-                                           [IntrInaccessibleMemOnly]>;
+def int_experimental_widenable_condition : DefaultAttrsIntrinsic<[llvm_i1_ty], [],
+        [IntrInaccessibleMemOnly, IntrWillReturn, IntrSpeculatable]>;
 
 // NOP: calls/invokes to this intrinsic are removed by codegen
-def int_donothing : Intrinsic<[], [], [IntrNoMem]>;
+def int_donothing : DefaultAttrsIntrinsic<[], [], [IntrNoMem, IntrWillReturn]>;
 
 // This instruction has no actual effect, though it is treated by the optimizer
 // has having opaque side effects. This may be inserted into loops to ensure
 // that they are not removed even if they turn out to be empty, for languages
 // which specify that infinite loops must be preserved.
-def int_sideeffect : Intrinsic<[], [], [IntrInaccessibleMemOnly]>;
+def int_sideeffect : DefaultAttrsIntrinsic<[], [], [IntrInaccessibleMemOnly, IntrWillReturn]>;
 
-// Intrisics to support half precision floating point format
-let IntrProperties = [IntrNoMem] in {
-def int_convert_to_fp16   : Intrinsic<[llvm_i16_ty], [llvm_anyfloat_ty]>;
-def int_convert_from_fp16 : Intrinsic<[llvm_anyfloat_ty], [llvm_i16_ty]>;
+// The pseudoprobe intrinsic works as a place holder to the block it probes.
+// Like the sideeffect intrinsic defined above, this intrinsic is treated by the 
+// optimizer as having opaque side effects so that it won't be get rid of or moved 
+// out of the block it probes.
+def int_pseudoprobe : Intrinsic<[], [llvm_i64_ty, llvm_i64_ty, llvm_i32_ty],
+                                    [IntrInaccessibleMemOnly, IntrWillReturn]>;
+
+// Intrinsics to support half precision floating point format
+let IntrProperties = [IntrNoMem, IntrWillReturn] in {
+def int_convert_to_fp16   : DefaultAttrsIntrinsic<[llvm_i16_ty], [llvm_anyfloat_ty]>;
+def int_convert_from_fp16 : DefaultAttrsIntrinsic<[llvm_anyfloat_ty], [llvm_i16_ty]>;
+}
+
+// Saturating floating point to integer intrinsics
+let IntrProperties = [IntrNoMem, IntrSpeculatable, IntrWillReturn] in {
+def int_fptoui_sat : DefaultAttrsIntrinsic<[llvm_anyint_ty], [llvm_anyfloat_ty]>;
+def int_fptosi_sat : DefaultAttrsIntrinsic<[llvm_anyint_ty], [llvm_anyfloat_ty]>;
 }
 
 // Clear cache intrinsic, default to ignore (ie. emit nothing)
@@ -1038,74 +1309,168 @@
                                 [], "llvm.clear_cache">;
 
 // Intrinsic to detect whether its argument is a constant.
-def int_is_constant : Intrinsic<[llvm_i1_ty], [llvm_any_ty], [IntrNoMem], "llvm.is.constant">;
+def int_is_constant : DefaultAttrsIntrinsic<[llvm_i1_ty], [llvm_any_ty],
+                                [IntrNoMem, IntrWillReturn, IntrConvergent],
+                                "llvm.is.constant">;
+
+// Intrinsic to mask out bits of a pointer.
+def int_ptrmask: DefaultAttrsIntrinsic<[llvm_anyptr_ty], [LLVMMatchType<0>, llvm_anyint_ty],
+                           [IntrNoMem, IntrSpeculatable, IntrWillReturn]>;
+
+//===---------------- Vector Predication Intrinsics --------------===//
+
+// Speculatable Binary operators
+let IntrProperties = [IntrSpeculatable, IntrNoMem, IntrNoSync, IntrWillReturn] in {
+  def int_vp_add : DefaultAttrsIntrinsic<[ llvm_anyvector_ty ],
+                             [ LLVMMatchType<0>,
+                               LLVMMatchType<0>,
+                               LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>,
+                               llvm_i32_ty]>;
+  def int_vp_sub : DefaultAttrsIntrinsic<[ llvm_anyvector_ty ],
+                             [ LLVMMatchType<0>,
+                               LLVMMatchType<0>,
+                               LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>,
+                               llvm_i32_ty]>;
+  def int_vp_mul  : DefaultAttrsIntrinsic<[ llvm_anyvector_ty ],
+                              [ LLVMMatchType<0>,
+                                LLVMMatchType<0>,
+                                LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>,
+                                llvm_i32_ty]>;
+  def int_vp_ashr : DefaultAttrsIntrinsic<[ llvm_anyvector_ty ],
+                              [ LLVMMatchType<0>,
+                                LLVMMatchType<0>,
+                                LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>,
+                                llvm_i32_ty]>;
+  def int_vp_lshr : DefaultAttrsIntrinsic<[ llvm_anyvector_ty ],
+                              [ LLVMMatchType<0>,
+                                LLVMMatchType<0>,
+                                LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>,
+                                llvm_i32_ty]>;
+  def int_vp_shl : DefaultAttrsIntrinsic<[ llvm_anyvector_ty ],
+                             [ LLVMMatchType<0>,
+                               LLVMMatchType<0>,
+                               LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>,
+                               llvm_i32_ty]>;
+  def int_vp_or : DefaultAttrsIntrinsic<[ llvm_anyvector_ty ],
+                            [ LLVMMatchType<0>,
+                              LLVMMatchType<0>,
+                              LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>,
+                              llvm_i32_ty]>;
+  def int_vp_and : DefaultAttrsIntrinsic<[ llvm_anyvector_ty ],
+                             [ LLVMMatchType<0>,
+                               LLVMMatchType<0>,
+                               LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>,
+                               llvm_i32_ty]>;
+  def int_vp_xor : DefaultAttrsIntrinsic<[ llvm_anyvector_ty ],
+                             [ LLVMMatchType<0>,
+                               LLVMMatchType<0>,
+                               LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>,
+                               llvm_i32_ty]>;
+}
+
+// Non-speculatable binary operators.
+let IntrProperties = [IntrNoMem, IntrNoSync, IntrWillReturn] in {
+  def int_vp_sdiv : DefaultAttrsIntrinsic<[ llvm_anyvector_ty ],
+                              [ LLVMMatchType<0>,
+                                LLVMMatchType<0>,
+                                LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>,
+                                llvm_i32_ty]>;
+  def int_vp_udiv : DefaultAttrsIntrinsic<[ llvm_anyvector_ty ],
+                              [ LLVMMatchType<0>,
+                                LLVMMatchType<0>,
+                                LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>,
+                                llvm_i32_ty]>;
+  def int_vp_srem : DefaultAttrsIntrinsic<[ llvm_anyvector_ty ],
+                              [ LLVMMatchType<0>,
+                                LLVMMatchType<0>,
+                                LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>,
+                                llvm_i32_ty]>;
+  def int_vp_urem : DefaultAttrsIntrinsic<[ llvm_anyvector_ty ],
+                              [ LLVMMatchType<0>,
+                                LLVMMatchType<0>,
+                                LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>,
+                                llvm_i32_ty]>;
+}
+
+def int_get_active_lane_mask:
+  DefaultAttrsIntrinsic<[llvm_anyvector_ty],
+            [llvm_anyint_ty, LLVMMatchType<1>],
+            [IntrNoMem, IntrNoSync, IntrWillReturn]>;
 
 //===-------------------------- Masked Intrinsics -------------------------===//
 //
-def int_masked_store : Intrinsic<[], [llvm_anyvector_ty,
-                                      LLVMAnyPointerType<LLVMMatchType<0>>,
-                                      llvm_i32_ty,
-                                      LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>],
-                                 [IntrArgMemOnly, ImmArg<2>]>;
+def int_masked_load:
+  DefaultAttrsIntrinsic<[llvm_anyvector_ty],
+            [LLVMAnyPointerType<LLVMMatchType<0>>, llvm_i32_ty,
+             LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>, LLVMMatchType<0>],
+            [IntrReadMem, IntrArgMemOnly, IntrWillReturn, ImmArg<ArgIndex<1>>]>;
 
-def int_masked_load  : Intrinsic<[llvm_anyvector_ty],
-                                 [LLVMAnyPointerType<LLVMMatchType<0>>, llvm_i32_ty,
-                                  LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>, LLVMMatchType<0>],
-                                 [IntrReadMem, IntrArgMemOnly, ImmArg<1>]>;
+def int_masked_store:
+  DefaultAttrsIntrinsic<[],
+            [llvm_anyvector_ty, LLVMAnyPointerType<LLVMMatchType<0>>,
+             llvm_i32_ty, LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>],
+            [IntrWriteMem, IntrArgMemOnly, IntrWillReturn,
+             ImmArg<ArgIndex<2>>]>;
 
-def int_masked_gather: Intrinsic<[llvm_anyvector_ty],
-                                 [LLVMVectorOfAnyPointersToElt<0>, llvm_i32_ty,
-                                  LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>,
-                                  LLVMMatchType<0>],
-                                 [IntrReadMem, ImmArg<1>]>;
+def int_masked_gather:
+  DefaultAttrsIntrinsic<[llvm_anyvector_ty],
+            [LLVMVectorOfAnyPointersToElt<0>, llvm_i32_ty,
+             LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>, LLVMMatchType<0>],
+            [IntrReadMem, IntrWillReturn, ImmArg<ArgIndex<1>>]>;
 
-def int_masked_scatter: Intrinsic<[],
-                                  [llvm_anyvector_ty,
-                                   LLVMVectorOfAnyPointersToElt<0>, llvm_i32_ty,
-                                   LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>],
-                                   [ImmArg<2>]>;
+def int_masked_scatter:
+  DefaultAttrsIntrinsic<[],
+            [llvm_anyvector_ty, LLVMVectorOfAnyPointersToElt<0>, llvm_i32_ty,
+             LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>],
+            [IntrWriteMem, IntrWillReturn, ImmArg<ArgIndex<2>>]>;
 
-def int_masked_expandload: Intrinsic<[llvm_anyvector_ty],
-                                     [LLVMPointerToElt<0>,
-                                      LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>,
-                                      LLVMMatchType<0>],
-                                     [IntrReadMem]>;
+def int_masked_expandload:
+  DefaultAttrsIntrinsic<[llvm_anyvector_ty],
+            [LLVMPointerToElt<0>, LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>,
+             LLVMMatchType<0>],
+            [IntrReadMem, IntrWillReturn]>;
 
-def int_masked_compressstore: Intrinsic<[],
-                                     [llvm_anyvector_ty,
-                                      LLVMPointerToElt<0>,
-                                      LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>],
-                                     [IntrArgMemOnly]>;
+def int_masked_compressstore:
+  DefaultAttrsIntrinsic<[],
+            [llvm_anyvector_ty, LLVMPointerToElt<0>,
+             LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>],
+            [IntrWriteMem, IntrArgMemOnly, IntrWillReturn]>;
 
 // Test whether a pointer is associated with a type metadata identifier.
-def int_type_test : Intrinsic<[llvm_i1_ty], [llvm_ptr_ty, llvm_metadata_ty],
-                              [IntrNoMem]>;
+def int_type_test : DefaultAttrsIntrinsic<[llvm_i1_ty], [llvm_ptr_ty, llvm_metadata_ty],
+                              [IntrNoMem, IntrWillReturn]>;
 
 // Safely loads a function pointer from a virtual table pointer using type metadata.
-def int_type_checked_load : Intrinsic<[llvm_ptr_ty, llvm_i1_ty],
+def int_type_checked_load : DefaultAttrsIntrinsic<[llvm_ptr_ty, llvm_i1_ty],
                                       [llvm_ptr_ty, llvm_i32_ty, llvm_metadata_ty],
-                                      [IntrNoMem]>;
+                                      [IntrNoMem, IntrWillReturn]>;
 
 // Create a branch funnel that implements an indirect call to a limited set of
 // callees. This needs to be a musttail call.
-def int_icall_branch_funnel : Intrinsic<[], [llvm_vararg_ty], []>;
+def int_icall_branch_funnel : DefaultAttrsIntrinsic<[], [llvm_vararg_ty], []>;
 
-def int_load_relative: Intrinsic<[llvm_ptr_ty], [llvm_ptr_ty, llvm_anyint_ty],
+def int_load_relative: DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_ptr_ty, llvm_anyint_ty],
                                  [IntrReadMem, IntrArgMemOnly]>;
 
 def int_hwasan_check_memaccess :
-  Intrinsic<[], [llvm_ptr_ty, llvm_ptr_ty, llvm_i32_ty], [IntrInaccessibleMemOnly, ImmArg<2>]>;
+  Intrinsic<[], [llvm_ptr_ty, llvm_ptr_ty, llvm_i32_ty],
+            [IntrInaccessibleMemOnly, ImmArg<ArgIndex<2>>]>;
+def int_hwasan_check_memaccess_shortgranules :
+  Intrinsic<[], [llvm_ptr_ty, llvm_ptr_ty, llvm_i32_ty],
+            [IntrInaccessibleMemOnly, ImmArg<ArgIndex<2>>]>;
 
 // Xray intrinsics
 //===----------------------------------------------------------------------===//
 // Custom event logging for x-ray.
 // Takes a pointer to a string and the length of the string.
 def int_xray_customevent : Intrinsic<[], [llvm_ptr_ty, llvm_i32_ty],
-                                     [NoCapture<0>, ReadOnly<0>, IntrWriteMem]>;
+                                     [IntrWriteMem, NoCapture<ArgIndex<0>>,
+                                      ReadOnly<ArgIndex<0>>]>;
 // Typed event logging for x-ray.
 // Takes a numeric type tag, a pointer to a string and the length of the string.
 def int_xray_typedevent : Intrinsic<[], [llvm_i16_ty, llvm_ptr_ty, llvm_i32_ty],
-                                        [NoCapture<1>, ReadOnly<1>, IntrWriteMem]>;
+                                        [IntrWriteMem, NoCapture<ArgIndex<1>>,
+                                         ReadOnly<ArgIndex<1>>]>;
 //===----------------------------------------------------------------------===//
 
 //===------ Memory intrinsics with element-wise atomicity guarantees ------===//
@@ -1114,120 +1479,162 @@
 // @llvm.memcpy.element.unordered.atomic.*(dest, src, length, elementsize)
 def int_memcpy_element_unordered_atomic
     : Intrinsic<[],
-                [
-                  llvm_anyptr_ty, llvm_anyptr_ty, llvm_anyint_ty, llvm_i32_ty
-                ],
-                [
-                  IntrArgMemOnly, NoCapture<0>, NoCapture<1>, WriteOnly<0>,
-                  ReadOnly<1>, ImmArg<3>
-                ]>;
+                [llvm_anyptr_ty, llvm_anyptr_ty, llvm_anyint_ty, llvm_i32_ty],
+                [IntrArgMemOnly, IntrWillReturn, NoCapture<ArgIndex<0>>,
+                 NoCapture<ArgIndex<1>>, WriteOnly<ArgIndex<0>>,
+                 ReadOnly<ArgIndex<1>>, ImmArg<ArgIndex<3>>]>;
 
 // @llvm.memmove.element.unordered.atomic.*(dest, src, length, elementsize)
 def int_memmove_element_unordered_atomic
     : Intrinsic<[],
-                [
-                  llvm_anyptr_ty, llvm_anyptr_ty, llvm_anyint_ty, llvm_i32_ty
-                ],
-                [
-                  IntrArgMemOnly, NoCapture<0>, NoCapture<1>, WriteOnly<0>,
-                  ReadOnly<1>, ImmArg<3>
-                ]>;
+                [llvm_anyptr_ty, llvm_anyptr_ty, llvm_anyint_ty, llvm_i32_ty],
+                [IntrArgMemOnly, IntrWillReturn, NoCapture<ArgIndex<0>>,
+                 NoCapture<ArgIndex<1>>, WriteOnly<ArgIndex<0>>,
+                 ReadOnly<ArgIndex<1>>, ImmArg<ArgIndex<3>>]>;
 
 // @llvm.memset.element.unordered.atomic.*(dest, value, length, elementsize)
 def int_memset_element_unordered_atomic
-    : Intrinsic<[], [ llvm_anyptr_ty, llvm_i8_ty, llvm_anyint_ty, llvm_i32_ty ],
-                [ IntrArgMemOnly, NoCapture<0>, WriteOnly<0>, ImmArg<3> ]>;
+    : Intrinsic<[], [llvm_anyptr_ty, llvm_i8_ty, llvm_anyint_ty, llvm_i32_ty],
+                [IntrWriteMem, IntrArgMemOnly, IntrWillReturn,
+                 NoCapture<ArgIndex<0>>, WriteOnly<ArgIndex<0>>,
+                 ImmArg<ArgIndex<3>>]>;
 
 //===------------------------ Reduction Intrinsics ------------------------===//
 //
-def int_experimental_vector_reduce_v2_fadd : Intrinsic<[llvm_anyfloat_ty],
-                                                       [LLVMMatchType<0>,
-                                                        llvm_anyvector_ty],
-                                                       [IntrNoMem]>;
-def int_experimental_vector_reduce_v2_fmul : Intrinsic<[llvm_anyfloat_ty],
-                                                       [LLVMMatchType<0>,
-                                                        llvm_anyvector_ty],
-                                                       [IntrNoMem]>;
-def int_experimental_vector_reduce_add : Intrinsic<[LLVMVectorElementType<0>],
-                                                   [llvm_anyvector_ty],
-                                                   [IntrNoMem]>;
-def int_experimental_vector_reduce_mul : Intrinsic<[LLVMVectorElementType<0>],
-                                                   [llvm_anyvector_ty],
-                                                   [IntrNoMem]>;
-def int_experimental_vector_reduce_and : Intrinsic<[LLVMVectorElementType<0>],
-                                                   [llvm_anyvector_ty],
-                                                   [IntrNoMem]>;
-def int_experimental_vector_reduce_or : Intrinsic<[LLVMVectorElementType<0>],
-                                                  [llvm_anyvector_ty],
-                                                  [IntrNoMem]>;
-def int_experimental_vector_reduce_xor : Intrinsic<[LLVMVectorElementType<0>],
-                                                   [llvm_anyvector_ty],
-                                                   [IntrNoMem]>;
-def int_experimental_vector_reduce_smax : Intrinsic<[LLVMVectorElementType<0>],
-                                                    [llvm_anyvector_ty],
-                                                    [IntrNoMem]>;
-def int_experimental_vector_reduce_smin : Intrinsic<[LLVMVectorElementType<0>],
-                                                    [llvm_anyvector_ty],
-                                                    [IntrNoMem]>;
-def int_experimental_vector_reduce_umax : Intrinsic<[LLVMVectorElementType<0>],
-                                                    [llvm_anyvector_ty],
-                                                    [IntrNoMem]>;
-def int_experimental_vector_reduce_umin : Intrinsic<[LLVMVectorElementType<0>],
-                                                    [llvm_anyvector_ty],
-                                                    [IntrNoMem]>;
-def int_experimental_vector_reduce_fmax : Intrinsic<[LLVMVectorElementType<0>],
-                                                    [llvm_anyvector_ty],
-                                                    [IntrNoMem]>;
-def int_experimental_vector_reduce_fmin : Intrinsic<[LLVMVectorElementType<0>],
-                                                    [llvm_anyvector_ty],
-                                                    [IntrNoMem]>;
+let IntrProperties = [IntrNoMem] in {
+
+  def int_vector_reduce_fadd : DefaultAttrsIntrinsic<[LLVMVectorElementType<0>],
+                                         [LLVMVectorElementType<0>,
+                                          llvm_anyvector_ty]>;
+  def int_vector_reduce_fmul : DefaultAttrsIntrinsic<[LLVMVectorElementType<0>],
+                                         [LLVMVectorElementType<0>,
+                                          llvm_anyvector_ty]>;
+  def int_vector_reduce_add : DefaultAttrsIntrinsic<[LLVMVectorElementType<0>],
+                                        [llvm_anyvector_ty]>;
+  def int_vector_reduce_mul : DefaultAttrsIntrinsic<[LLVMVectorElementType<0>],
+                                        [llvm_anyvector_ty]>;
+  def int_vector_reduce_and : DefaultAttrsIntrinsic<[LLVMVectorElementType<0>],
+                                        [llvm_anyvector_ty]>;
+  def int_vector_reduce_or : DefaultAttrsIntrinsic<[LLVMVectorElementType<0>],
+                                       [llvm_anyvector_ty]>;
+  def int_vector_reduce_xor : DefaultAttrsIntrinsic<[LLVMVectorElementType<0>],
+                                        [llvm_anyvector_ty]>;
+  def int_vector_reduce_smax : DefaultAttrsIntrinsic<[LLVMVectorElementType<0>],
+                                         [llvm_anyvector_ty]>;
+  def int_vector_reduce_smin : DefaultAttrsIntrinsic<[LLVMVectorElementType<0>],
+                                         [llvm_anyvector_ty]>;
+  def int_vector_reduce_umax : DefaultAttrsIntrinsic<[LLVMVectorElementType<0>],
+                                         [llvm_anyvector_ty]>;
+  def int_vector_reduce_umin : DefaultAttrsIntrinsic<[LLVMVectorElementType<0>],
+                                         [llvm_anyvector_ty]>;
+  def int_vector_reduce_fmax : DefaultAttrsIntrinsic<[LLVMVectorElementType<0>],
+                                         [llvm_anyvector_ty]>;
+  def int_vector_reduce_fmin : DefaultAttrsIntrinsic<[LLVMVectorElementType<0>],
+                                         [llvm_anyvector_ty]>;
+}
+
+//===----- Matrix intrinsics ---------------------------------------------===//
+
+def int_matrix_transpose
+  : DefaultAttrsIntrinsic<[llvm_anyvector_ty],
+              [LLVMMatchType<0>, llvm_i32_ty, llvm_i32_ty],
+              [ IntrNoSync, IntrWillReturn, IntrNoMem, IntrSpeculatable, ImmArg<ArgIndex<1>>,
+               ImmArg<ArgIndex<2>>]>;
+
+def int_matrix_multiply
+  : DefaultAttrsIntrinsic<[llvm_anyvector_ty],
+              [llvm_anyvector_ty, llvm_anyvector_ty, llvm_i32_ty, llvm_i32_ty,
+               llvm_i32_ty],
+              [IntrNoSync, IntrWillReturn, IntrNoMem, IntrSpeculatable, ImmArg<ArgIndex<2>>,
+               ImmArg<ArgIndex<3>>, ImmArg<ArgIndex<4>>]>;
+
+def int_matrix_column_major_load
+  : DefaultAttrsIntrinsic<[llvm_anyvector_ty],
+              [LLVMPointerToElt<0>, llvm_i64_ty, llvm_i1_ty,
+               llvm_i32_ty, llvm_i32_ty],
+              [IntrNoSync, IntrWillReturn, IntrArgMemOnly, IntrReadMem,
+               NoCapture<ArgIndex<0>>, ImmArg<ArgIndex<2>>, ImmArg<ArgIndex<3>>,
+               ImmArg<ArgIndex<4>>]>;
+
+def int_matrix_column_major_store
+  : DefaultAttrsIntrinsic<[],
+              [llvm_anyvector_ty, LLVMPointerToElt<0>,
+               llvm_i64_ty, llvm_i1_ty, llvm_i32_ty, llvm_i32_ty],
+              [IntrNoSync, IntrWillReturn, IntrArgMemOnly, IntrWriteMem,
+               WriteOnly<ArgIndex<1>>, NoCapture<ArgIndex<1>>,
+               ImmArg<ArgIndex<3>>, ImmArg<ArgIndex<4>>, ImmArg<ArgIndex<5>>]>;
 
 //===---------- Intrinsics to control hardware supported loops ----------===//
 
 // Specify that the value given is the number of iterations that the next loop
 // will execute.
 def int_set_loop_iterations :
-  Intrinsic<[], [llvm_anyint_ty], [IntrNoDuplicate]>;
+  DefaultAttrsIntrinsic<[], [llvm_anyint_ty], [IntrNoDuplicate]>;
+
+// Same as the above, but produces a value (the same as the input operand) to
+// be fed into the loop.
+def int_start_loop_iterations :
+  DefaultAttrsIntrinsic<[llvm_anyint_ty], [LLVMMatchType<0>], [IntrNoDuplicate]>;
 
 // Specify that the value given is the number of iterations that the next loop
 // will execute. Also test that the given count is not zero, allowing it to
 // control entry to a 'while' loop.
 def int_test_set_loop_iterations :
-  Intrinsic<[llvm_i1_ty], [llvm_anyint_ty], [IntrNoDuplicate]>;
+  DefaultAttrsIntrinsic<[llvm_i1_ty], [llvm_anyint_ty], [IntrNoDuplicate]>;
 
 // Decrement loop counter by the given argument. Return false if the loop
 // should exit.
 def int_loop_decrement :
-  Intrinsic<[llvm_i1_ty], [llvm_anyint_ty], [IntrNoDuplicate]>;
+  DefaultAttrsIntrinsic<[llvm_i1_ty], [llvm_anyint_ty], [IntrNoDuplicate]>;
 
 // Decrement the first operand (the loop counter) by the second operand (the
 // maximum number of elements processed in an iteration). Return the remaining
 // number of iterations still to be executed. This is effectively a sub which
 // can be used with a phi, icmp and br to control the number of iterations
-// executed, as usual.
+// executed, as usual. Any optimisations are allowed to treat it is a sub, and
+// it's scevable, so it's the backends responsibility to handle cases where it
+// may be optimised.
 def int_loop_decrement_reg :
-  Intrinsic<[llvm_anyint_ty],
-            [llvm_anyint_ty, llvm_anyint_ty], [IntrNoDuplicate]>;
+  DefaultAttrsIntrinsic<[llvm_anyint_ty],
+            [LLVMMatchType<0>, LLVMMatchType<0>], [IntrNoDuplicate]>;
 
 //===----- Intrinsics that are used to provide predicate information -----===//
 
-def int_ssa_copy : Intrinsic<[llvm_any_ty], [LLVMMatchType<0>],
-                             [IntrNoMem, Returned<0>]>;
+def int_ssa_copy : DefaultAttrsIntrinsic<[llvm_any_ty], [LLVMMatchType<0>],
+                             [IntrNoMem, Returned<ArgIndex<0>>]>;
 
 //===------- Intrinsics that are used to preserve debug information -------===//
 
-def int_preserve_array_access_index : Intrinsic<[llvm_anyptr_ty],
+def int_preserve_array_access_index : DefaultAttrsIntrinsic<[llvm_anyptr_ty],
                                                 [llvm_anyptr_ty, llvm_i32_ty,
                                                  llvm_i32_ty],
-                                                [IntrNoMem, ImmArg<1>, ImmArg<2>]>;
-def int_preserve_union_access_index : Intrinsic<[llvm_anyptr_ty],
+                                                [IntrNoMem,
+                                                 ImmArg<ArgIndex<1>>,
+                                                 ImmArg<ArgIndex<2>>]>;
+def int_preserve_union_access_index : DefaultAttrsIntrinsic<[llvm_anyptr_ty],
                                                 [llvm_anyptr_ty, llvm_i32_ty],
-                                                [IntrNoMem, ImmArg<1>]>;
-def int_preserve_struct_access_index : Intrinsic<[llvm_anyptr_ty],
+                                                [IntrNoMem,
+                                                 ImmArg<ArgIndex<1>>]>;
+def int_preserve_struct_access_index : DefaultAttrsIntrinsic<[llvm_anyptr_ty],
                                                  [llvm_anyptr_ty, llvm_i32_ty,
                                                   llvm_i32_ty],
-                                                 [IntrNoMem, ImmArg<1>,
-                                                  ImmArg<2>]>;
+                                                 [IntrNoMem,
+                                                  ImmArg<ArgIndex<1>>,
+                                                  ImmArg<ArgIndex<2>>]>;
+
+//===---------- Intrinsics to query properties of scalable vectors --------===//
+def int_vscale : DefaultAttrsIntrinsic<[llvm_anyint_ty], [], [IntrNoMem]>;
+
+//===---------- Intrinsics to perform subvector insertion/extraction ------===//
+def int_experimental_vector_insert : DefaultAttrsIntrinsic<[llvm_anyvector_ty],
+                                                           [LLVMMatchType<0>, llvm_anyvector_ty, llvm_i64_ty],
+                                                           [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+def int_experimental_vector_extract : DefaultAttrsIntrinsic<[llvm_anyvector_ty],
+                                                            [llvm_anyvector_ty, llvm_i64_ty],
+                                                            [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+//===----------------------------------------------------------------------===//
 
 //===----------------------------------------------------------------------===//
 // Target-specific intrinsics
@@ -1246,3 +1653,4 @@
 include "llvm/IR/IntrinsicsSystemZ.td"
 include "llvm/IR/IntrinsicsWebAssembly.td"
 include "llvm/IR/IntrinsicsRISCV.td"
+include "llvm/IR/IntrinsicsVE.td"
diff --git a/linux-x64/clang/include/llvm/IR/IntrinsicsAArch64.h b/linux-x64/clang/include/llvm/IR/IntrinsicsAArch64.h
new file mode 100644
index 0000000..2459390
--- /dev/null
+++ b/linux-x64/clang/include/llvm/IR/IntrinsicsAArch64.h
@@ -0,0 +1,865 @@
+/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
+|*                                                                            *|
+|* Intrinsic Function Source Fragment                                         *|
+|*                                                                            *|
+|* Automatically generated file, do not edit!                                 *|
+|*                                                                            *|
+\*===----------------------------------------------------------------------===*/
+
+#ifndef LLVM_IR_INTRINSIC_AARCH64_ENUMS_H
+#define LLVM_IR_INTRINSIC_AARCH64_ENUMS_H
+
+namespace llvm {
+namespace Intrinsic {
+enum AARCH64Intrinsics : unsigned {
+// Enum values for intrinsics
+    aarch64_addg = 315,                              // llvm.aarch64.addg
+    aarch64_clrex,                             // llvm.aarch64.clrex
+    aarch64_cls,                               // llvm.aarch64.cls
+    aarch64_cls64,                             // llvm.aarch64.cls64
+    aarch64_crc32b,                            // llvm.aarch64.crc32b
+    aarch64_crc32cb,                           // llvm.aarch64.crc32cb
+    aarch64_crc32ch,                           // llvm.aarch64.crc32ch
+    aarch64_crc32cw,                           // llvm.aarch64.crc32cw
+    aarch64_crc32cx,                           // llvm.aarch64.crc32cx
+    aarch64_crc32h,                            // llvm.aarch64.crc32h
+    aarch64_crc32w,                            // llvm.aarch64.crc32w
+    aarch64_crc32x,                            // llvm.aarch64.crc32x
+    aarch64_crypto_aesd,                       // llvm.aarch64.crypto.aesd
+    aarch64_crypto_aese,                       // llvm.aarch64.crypto.aese
+    aarch64_crypto_aesimc,                     // llvm.aarch64.crypto.aesimc
+    aarch64_crypto_aesmc,                      // llvm.aarch64.crypto.aesmc
+    aarch64_crypto_sha1c,                      // llvm.aarch64.crypto.sha1c
+    aarch64_crypto_sha1h,                      // llvm.aarch64.crypto.sha1h
+    aarch64_crypto_sha1m,                      // llvm.aarch64.crypto.sha1m
+    aarch64_crypto_sha1p,                      // llvm.aarch64.crypto.sha1p
+    aarch64_crypto_sha1su0,                    // llvm.aarch64.crypto.sha1su0
+    aarch64_crypto_sha1su1,                    // llvm.aarch64.crypto.sha1su1
+    aarch64_crypto_sha256h,                    // llvm.aarch64.crypto.sha256h
+    aarch64_crypto_sha256h2,                   // llvm.aarch64.crypto.sha256h2
+    aarch64_crypto_sha256su0,                  // llvm.aarch64.crypto.sha256su0
+    aarch64_crypto_sha256su1,                  // llvm.aarch64.crypto.sha256su1
+    aarch64_dmb,                               // llvm.aarch64.dmb
+    aarch64_dsb,                               // llvm.aarch64.dsb
+    aarch64_fjcvtzs,                           // llvm.aarch64.fjcvtzs
+    aarch64_get_fpcr,                          // llvm.aarch64.get.fpcr
+    aarch64_gmi,                               // llvm.aarch64.gmi
+    aarch64_hint,                              // llvm.aarch64.hint
+    aarch64_irg,                               // llvm.aarch64.irg
+    aarch64_irg_sp,                            // llvm.aarch64.irg.sp
+    aarch64_isb,                               // llvm.aarch64.isb
+    aarch64_ld64b,                             // llvm.aarch64.ld64b
+    aarch64_ldaxp,                             // llvm.aarch64.ldaxp
+    aarch64_ldaxr,                             // llvm.aarch64.ldaxr
+    aarch64_ldg,                               // llvm.aarch64.ldg
+    aarch64_ldxp,                              // llvm.aarch64.ldxp
+    aarch64_ldxr,                              // llvm.aarch64.ldxr
+    aarch64_neon_abs,                          // llvm.aarch64.neon.abs
+    aarch64_neon_addhn,                        // llvm.aarch64.neon.addhn
+    aarch64_neon_addp,                         // llvm.aarch64.neon.addp
+    aarch64_neon_bfcvt,                        // llvm.aarch64.neon.bfcvt
+    aarch64_neon_bfcvtn,                       // llvm.aarch64.neon.bfcvtn
+    aarch64_neon_bfcvtn2,                      // llvm.aarch64.neon.bfcvtn2
+    aarch64_neon_bfdot,                        // llvm.aarch64.neon.bfdot
+    aarch64_neon_bfmlalb,                      // llvm.aarch64.neon.bfmlalb
+    aarch64_neon_bfmlalt,                      // llvm.aarch64.neon.bfmlalt
+    aarch64_neon_bfmmla,                       // llvm.aarch64.neon.bfmmla
+    aarch64_neon_cls,                          // llvm.aarch64.neon.cls
+    aarch64_neon_fabd,                         // llvm.aarch64.neon.fabd
+    aarch64_neon_facge,                        // llvm.aarch64.neon.facge
+    aarch64_neon_facgt,                        // llvm.aarch64.neon.facgt
+    aarch64_neon_faddp,                        // llvm.aarch64.neon.faddp
+    aarch64_neon_faddv,                        // llvm.aarch64.neon.faddv
+    aarch64_neon_fcvtas,                       // llvm.aarch64.neon.fcvtas
+    aarch64_neon_fcvtau,                       // llvm.aarch64.neon.fcvtau
+    aarch64_neon_fcvtms,                       // llvm.aarch64.neon.fcvtms
+    aarch64_neon_fcvtmu,                       // llvm.aarch64.neon.fcvtmu
+    aarch64_neon_fcvtns,                       // llvm.aarch64.neon.fcvtns
+    aarch64_neon_fcvtnu,                       // llvm.aarch64.neon.fcvtnu
+    aarch64_neon_fcvtps,                       // llvm.aarch64.neon.fcvtps
+    aarch64_neon_fcvtpu,                       // llvm.aarch64.neon.fcvtpu
+    aarch64_neon_fcvtxn,                       // llvm.aarch64.neon.fcvtxn
+    aarch64_neon_fcvtzs,                       // llvm.aarch64.neon.fcvtzs
+    aarch64_neon_fcvtzu,                       // llvm.aarch64.neon.fcvtzu
+    aarch64_neon_fmax,                         // llvm.aarch64.neon.fmax
+    aarch64_neon_fmaxnm,                       // llvm.aarch64.neon.fmaxnm
+    aarch64_neon_fmaxnmp,                      // llvm.aarch64.neon.fmaxnmp
+    aarch64_neon_fmaxnmv,                      // llvm.aarch64.neon.fmaxnmv
+    aarch64_neon_fmaxp,                        // llvm.aarch64.neon.fmaxp
+    aarch64_neon_fmaxv,                        // llvm.aarch64.neon.fmaxv
+    aarch64_neon_fmin,                         // llvm.aarch64.neon.fmin
+    aarch64_neon_fminnm,                       // llvm.aarch64.neon.fminnm
+    aarch64_neon_fminnmp,                      // llvm.aarch64.neon.fminnmp
+    aarch64_neon_fminnmv,                      // llvm.aarch64.neon.fminnmv
+    aarch64_neon_fminp,                        // llvm.aarch64.neon.fminp
+    aarch64_neon_fminv,                        // llvm.aarch64.neon.fminv
+    aarch64_neon_fmlal,                        // llvm.aarch64.neon.fmlal
+    aarch64_neon_fmlal2,                       // llvm.aarch64.neon.fmlal2
+    aarch64_neon_fmlsl,                        // llvm.aarch64.neon.fmlsl
+    aarch64_neon_fmlsl2,                       // llvm.aarch64.neon.fmlsl2
+    aarch64_neon_fmulx,                        // llvm.aarch64.neon.fmulx
+    aarch64_neon_frecpe,                       // llvm.aarch64.neon.frecpe
+    aarch64_neon_frecps,                       // llvm.aarch64.neon.frecps
+    aarch64_neon_frecpx,                       // llvm.aarch64.neon.frecpx
+    aarch64_neon_frintn,                       // llvm.aarch64.neon.frintn
+    aarch64_neon_frsqrte,                      // llvm.aarch64.neon.frsqrte
+    aarch64_neon_frsqrts,                      // llvm.aarch64.neon.frsqrts
+    aarch64_neon_ld1x2,                        // llvm.aarch64.neon.ld1x2
+    aarch64_neon_ld1x3,                        // llvm.aarch64.neon.ld1x3
+    aarch64_neon_ld1x4,                        // llvm.aarch64.neon.ld1x4
+    aarch64_neon_ld2,                          // llvm.aarch64.neon.ld2
+    aarch64_neon_ld2lane,                      // llvm.aarch64.neon.ld2lane
+    aarch64_neon_ld2r,                         // llvm.aarch64.neon.ld2r
+    aarch64_neon_ld3,                          // llvm.aarch64.neon.ld3
+    aarch64_neon_ld3lane,                      // llvm.aarch64.neon.ld3lane
+    aarch64_neon_ld3r,                         // llvm.aarch64.neon.ld3r
+    aarch64_neon_ld4,                          // llvm.aarch64.neon.ld4
+    aarch64_neon_ld4lane,                      // llvm.aarch64.neon.ld4lane
+    aarch64_neon_ld4r,                         // llvm.aarch64.neon.ld4r
+    aarch64_neon_pmul,                         // llvm.aarch64.neon.pmul
+    aarch64_neon_pmull,                        // llvm.aarch64.neon.pmull
+    aarch64_neon_pmull64,                      // llvm.aarch64.neon.pmull64
+    aarch64_neon_raddhn,                       // llvm.aarch64.neon.raddhn
+    aarch64_neon_rbit,                         // llvm.aarch64.neon.rbit
+    aarch64_neon_rshrn,                        // llvm.aarch64.neon.rshrn
+    aarch64_neon_rsubhn,                       // llvm.aarch64.neon.rsubhn
+    aarch64_neon_sabd,                         // llvm.aarch64.neon.sabd
+    aarch64_neon_saddlp,                       // llvm.aarch64.neon.saddlp
+    aarch64_neon_saddlv,                       // llvm.aarch64.neon.saddlv
+    aarch64_neon_saddv,                        // llvm.aarch64.neon.saddv
+    aarch64_neon_scalar_sqxtn,                 // llvm.aarch64.neon.scalar.sqxtn
+    aarch64_neon_scalar_sqxtun,                // llvm.aarch64.neon.scalar.sqxtun
+    aarch64_neon_scalar_uqxtn,                 // llvm.aarch64.neon.scalar.uqxtn
+    aarch64_neon_sdot,                         // llvm.aarch64.neon.sdot
+    aarch64_neon_shadd,                        // llvm.aarch64.neon.shadd
+    aarch64_neon_shll,                         // llvm.aarch64.neon.shll
+    aarch64_neon_shsub,                        // llvm.aarch64.neon.shsub
+    aarch64_neon_smax,                         // llvm.aarch64.neon.smax
+    aarch64_neon_smaxp,                        // llvm.aarch64.neon.smaxp
+    aarch64_neon_smaxv,                        // llvm.aarch64.neon.smaxv
+    aarch64_neon_smin,                         // llvm.aarch64.neon.smin
+    aarch64_neon_sminp,                        // llvm.aarch64.neon.sminp
+    aarch64_neon_sminv,                        // llvm.aarch64.neon.sminv
+    aarch64_neon_smmla,                        // llvm.aarch64.neon.smmla
+    aarch64_neon_smull,                        // llvm.aarch64.neon.smull
+    aarch64_neon_sqabs,                        // llvm.aarch64.neon.sqabs
+    aarch64_neon_sqadd,                        // llvm.aarch64.neon.sqadd
+    aarch64_neon_sqdmulh,                      // llvm.aarch64.neon.sqdmulh
+    aarch64_neon_sqdmulh_lane,                 // llvm.aarch64.neon.sqdmulh.lane
+    aarch64_neon_sqdmulh_laneq,                // llvm.aarch64.neon.sqdmulh.laneq
+    aarch64_neon_sqdmull,                      // llvm.aarch64.neon.sqdmull
+    aarch64_neon_sqdmulls_scalar,              // llvm.aarch64.neon.sqdmulls.scalar
+    aarch64_neon_sqneg,                        // llvm.aarch64.neon.sqneg
+    aarch64_neon_sqrdmulh,                     // llvm.aarch64.neon.sqrdmulh
+    aarch64_neon_sqrdmulh_lane,                // llvm.aarch64.neon.sqrdmulh.lane
+    aarch64_neon_sqrdmulh_laneq,               // llvm.aarch64.neon.sqrdmulh.laneq
+    aarch64_neon_sqrshl,                       // llvm.aarch64.neon.sqrshl
+    aarch64_neon_sqrshrn,                      // llvm.aarch64.neon.sqrshrn
+    aarch64_neon_sqrshrun,                     // llvm.aarch64.neon.sqrshrun
+    aarch64_neon_sqshl,                        // llvm.aarch64.neon.sqshl
+    aarch64_neon_sqshlu,                       // llvm.aarch64.neon.sqshlu
+    aarch64_neon_sqshrn,                       // llvm.aarch64.neon.sqshrn
+    aarch64_neon_sqshrun,                      // llvm.aarch64.neon.sqshrun
+    aarch64_neon_sqsub,                        // llvm.aarch64.neon.sqsub
+    aarch64_neon_sqxtn,                        // llvm.aarch64.neon.sqxtn
+    aarch64_neon_sqxtun,                       // llvm.aarch64.neon.sqxtun
+    aarch64_neon_srhadd,                       // llvm.aarch64.neon.srhadd
+    aarch64_neon_srshl,                        // llvm.aarch64.neon.srshl
+    aarch64_neon_sshl,                         // llvm.aarch64.neon.sshl
+    aarch64_neon_sshll,                        // llvm.aarch64.neon.sshll
+    aarch64_neon_st1x2,                        // llvm.aarch64.neon.st1x2
+    aarch64_neon_st1x3,                        // llvm.aarch64.neon.st1x3
+    aarch64_neon_st1x4,                        // llvm.aarch64.neon.st1x4
+    aarch64_neon_st2,                          // llvm.aarch64.neon.st2
+    aarch64_neon_st2lane,                      // llvm.aarch64.neon.st2lane
+    aarch64_neon_st3,                          // llvm.aarch64.neon.st3
+    aarch64_neon_st3lane,                      // llvm.aarch64.neon.st3lane
+    aarch64_neon_st4,                          // llvm.aarch64.neon.st4
+    aarch64_neon_st4lane,                      // llvm.aarch64.neon.st4lane
+    aarch64_neon_subhn,                        // llvm.aarch64.neon.subhn
+    aarch64_neon_suqadd,                       // llvm.aarch64.neon.suqadd
+    aarch64_neon_tbl1,                         // llvm.aarch64.neon.tbl1
+    aarch64_neon_tbl2,                         // llvm.aarch64.neon.tbl2
+    aarch64_neon_tbl3,                         // llvm.aarch64.neon.tbl3
+    aarch64_neon_tbl4,                         // llvm.aarch64.neon.tbl4
+    aarch64_neon_tbx1,                         // llvm.aarch64.neon.tbx1
+    aarch64_neon_tbx2,                         // llvm.aarch64.neon.tbx2
+    aarch64_neon_tbx3,                         // llvm.aarch64.neon.tbx3
+    aarch64_neon_tbx4,                         // llvm.aarch64.neon.tbx4
+    aarch64_neon_uabd,                         // llvm.aarch64.neon.uabd
+    aarch64_neon_uaddlp,                       // llvm.aarch64.neon.uaddlp
+    aarch64_neon_uaddlv,                       // llvm.aarch64.neon.uaddlv
+    aarch64_neon_uaddv,                        // llvm.aarch64.neon.uaddv
+    aarch64_neon_udot,                         // llvm.aarch64.neon.udot
+    aarch64_neon_uhadd,                        // llvm.aarch64.neon.uhadd
+    aarch64_neon_uhsub,                        // llvm.aarch64.neon.uhsub
+    aarch64_neon_umax,                         // llvm.aarch64.neon.umax
+    aarch64_neon_umaxp,                        // llvm.aarch64.neon.umaxp
+    aarch64_neon_umaxv,                        // llvm.aarch64.neon.umaxv
+    aarch64_neon_umin,                         // llvm.aarch64.neon.umin
+    aarch64_neon_uminp,                        // llvm.aarch64.neon.uminp
+    aarch64_neon_uminv,                        // llvm.aarch64.neon.uminv
+    aarch64_neon_ummla,                        // llvm.aarch64.neon.ummla
+    aarch64_neon_umull,                        // llvm.aarch64.neon.umull
+    aarch64_neon_uqadd,                        // llvm.aarch64.neon.uqadd
+    aarch64_neon_uqrshl,                       // llvm.aarch64.neon.uqrshl
+    aarch64_neon_uqrshrn,                      // llvm.aarch64.neon.uqrshrn
+    aarch64_neon_uqshl,                        // llvm.aarch64.neon.uqshl
+    aarch64_neon_uqshrn,                       // llvm.aarch64.neon.uqshrn
+    aarch64_neon_uqsub,                        // llvm.aarch64.neon.uqsub
+    aarch64_neon_uqxtn,                        // llvm.aarch64.neon.uqxtn
+    aarch64_neon_urecpe,                       // llvm.aarch64.neon.urecpe
+    aarch64_neon_urhadd,                       // llvm.aarch64.neon.urhadd
+    aarch64_neon_urshl,                        // llvm.aarch64.neon.urshl
+    aarch64_neon_ursqrte,                      // llvm.aarch64.neon.ursqrte
+    aarch64_neon_usdot,                        // llvm.aarch64.neon.usdot
+    aarch64_neon_ushl,                         // llvm.aarch64.neon.ushl
+    aarch64_neon_ushll,                        // llvm.aarch64.neon.ushll
+    aarch64_neon_usmmla,                       // llvm.aarch64.neon.usmmla
+    aarch64_neon_usqadd,                       // llvm.aarch64.neon.usqadd
+    aarch64_neon_vcadd_rot270,                 // llvm.aarch64.neon.vcadd.rot270
+    aarch64_neon_vcadd_rot90,                  // llvm.aarch64.neon.vcadd.rot90
+    aarch64_neon_vcmla_rot0,                   // llvm.aarch64.neon.vcmla.rot0
+    aarch64_neon_vcmla_rot180,                 // llvm.aarch64.neon.vcmla.rot180
+    aarch64_neon_vcmla_rot270,                 // llvm.aarch64.neon.vcmla.rot270
+    aarch64_neon_vcmla_rot90,                  // llvm.aarch64.neon.vcmla.rot90
+    aarch64_neon_vcopy_lane,                   // llvm.aarch64.neon.vcopy.lane
+    aarch64_neon_vcvtfp2fxs,                   // llvm.aarch64.neon.vcvtfp2fxs
+    aarch64_neon_vcvtfp2fxu,                   // llvm.aarch64.neon.vcvtfp2fxu
+    aarch64_neon_vcvtfp2hf,                    // llvm.aarch64.neon.vcvtfp2hf
+    aarch64_neon_vcvtfxs2fp,                   // llvm.aarch64.neon.vcvtfxs2fp
+    aarch64_neon_vcvtfxu2fp,                   // llvm.aarch64.neon.vcvtfxu2fp
+    aarch64_neon_vcvthf2fp,                    // llvm.aarch64.neon.vcvthf2fp
+    aarch64_neon_vsli,                         // llvm.aarch64.neon.vsli
+    aarch64_neon_vsri,                         // llvm.aarch64.neon.vsri
+    aarch64_sdiv,                              // llvm.aarch64.sdiv
+    aarch64_settag,                            // llvm.aarch64.settag
+    aarch64_settag_zero,                       // llvm.aarch64.settag.zero
+    aarch64_sisd_fabd,                         // llvm.aarch64.sisd.fabd
+    aarch64_sisd_fcvtxn,                       // llvm.aarch64.sisd.fcvtxn
+    aarch64_space,                             // llvm.aarch64.space
+    aarch64_st64b,                             // llvm.aarch64.st64b
+    aarch64_st64bv,                            // llvm.aarch64.st64bv
+    aarch64_st64bv0,                           // llvm.aarch64.st64bv0
+    aarch64_stg,                               // llvm.aarch64.stg
+    aarch64_stgp,                              // llvm.aarch64.stgp
+    aarch64_stlxp,                             // llvm.aarch64.stlxp
+    aarch64_stlxr,                             // llvm.aarch64.stlxr
+    aarch64_stxp,                              // llvm.aarch64.stxp
+    aarch64_stxr,                              // llvm.aarch64.stxr
+    aarch64_subp,                              // llvm.aarch64.subp
+    aarch64_sve_abs,                           // llvm.aarch64.sve.abs
+    aarch64_sve_adclb,                         // llvm.aarch64.sve.adclb
+    aarch64_sve_adclt,                         // llvm.aarch64.sve.adclt
+    aarch64_sve_add,                           // llvm.aarch64.sve.add
+    aarch64_sve_addhnb,                        // llvm.aarch64.sve.addhnb
+    aarch64_sve_addhnt,                        // llvm.aarch64.sve.addhnt
+    aarch64_sve_addp,                          // llvm.aarch64.sve.addp
+    aarch64_sve_adrb,                          // llvm.aarch64.sve.adrb
+    aarch64_sve_adrd,                          // llvm.aarch64.sve.adrd
+    aarch64_sve_adrh,                          // llvm.aarch64.sve.adrh
+    aarch64_sve_adrw,                          // llvm.aarch64.sve.adrw
+    aarch64_sve_aesd,                          // llvm.aarch64.sve.aesd
+    aarch64_sve_aese,                          // llvm.aarch64.sve.aese
+    aarch64_sve_aesimc,                        // llvm.aarch64.sve.aesimc
+    aarch64_sve_aesmc,                         // llvm.aarch64.sve.aesmc
+    aarch64_sve_and,                           // llvm.aarch64.sve.and
+    aarch64_sve_and_z,                         // llvm.aarch64.sve.and.z
+    aarch64_sve_andv,                          // llvm.aarch64.sve.andv
+    aarch64_sve_asr,                           // llvm.aarch64.sve.asr
+    aarch64_sve_asr_wide,                      // llvm.aarch64.sve.asr.wide
+    aarch64_sve_asrd,                          // llvm.aarch64.sve.asrd
+    aarch64_sve_bcax,                          // llvm.aarch64.sve.bcax
+    aarch64_sve_bdep_x,                        // llvm.aarch64.sve.bdep.x
+    aarch64_sve_bext_x,                        // llvm.aarch64.sve.bext.x
+    aarch64_sve_bfdot,                         // llvm.aarch64.sve.bfdot
+    aarch64_sve_bfdot_lane,                    // llvm.aarch64.sve.bfdot.lane
+    aarch64_sve_bfmlalb,                       // llvm.aarch64.sve.bfmlalb
+    aarch64_sve_bfmlalb_lane,                  // llvm.aarch64.sve.bfmlalb.lane
+    aarch64_sve_bfmlalt,                       // llvm.aarch64.sve.bfmlalt
+    aarch64_sve_bfmlalt_lane,                  // llvm.aarch64.sve.bfmlalt.lane
+    aarch64_sve_bfmmla,                        // llvm.aarch64.sve.bfmmla
+    aarch64_sve_bgrp_x,                        // llvm.aarch64.sve.bgrp.x
+    aarch64_sve_bic,                           // llvm.aarch64.sve.bic
+    aarch64_sve_bic_z,                         // llvm.aarch64.sve.bic.z
+    aarch64_sve_brka,                          // llvm.aarch64.sve.brka
+    aarch64_sve_brka_z,                        // llvm.aarch64.sve.brka.z
+    aarch64_sve_brkb,                          // llvm.aarch64.sve.brkb
+    aarch64_sve_brkb_z,                        // llvm.aarch64.sve.brkb.z
+    aarch64_sve_brkn_z,                        // llvm.aarch64.sve.brkn.z
+    aarch64_sve_brkpa_z,                       // llvm.aarch64.sve.brkpa.z
+    aarch64_sve_brkpb_z,                       // llvm.aarch64.sve.brkpb.z
+    aarch64_sve_bsl,                           // llvm.aarch64.sve.bsl
+    aarch64_sve_bsl1n,                         // llvm.aarch64.sve.bsl1n
+    aarch64_sve_bsl2n,                         // llvm.aarch64.sve.bsl2n
+    aarch64_sve_cadd_x,                        // llvm.aarch64.sve.cadd.x
+    aarch64_sve_cdot,                          // llvm.aarch64.sve.cdot
+    aarch64_sve_cdot_lane,                     // llvm.aarch64.sve.cdot.lane
+    aarch64_sve_clasta,                        // llvm.aarch64.sve.clasta
+    aarch64_sve_clasta_n,                      // llvm.aarch64.sve.clasta.n
+    aarch64_sve_clastb,                        // llvm.aarch64.sve.clastb
+    aarch64_sve_clastb_n,                      // llvm.aarch64.sve.clastb.n
+    aarch64_sve_cls,                           // llvm.aarch64.sve.cls
+    aarch64_sve_clz,                           // llvm.aarch64.sve.clz
+    aarch64_sve_cmla_lane_x,                   // llvm.aarch64.sve.cmla.lane.x
+    aarch64_sve_cmla_x,                        // llvm.aarch64.sve.cmla.x
+    aarch64_sve_cmpeq,                         // llvm.aarch64.sve.cmpeq
+    aarch64_sve_cmpeq_wide,                    // llvm.aarch64.sve.cmpeq.wide
+    aarch64_sve_cmpge,                         // llvm.aarch64.sve.cmpge
+    aarch64_sve_cmpge_wide,                    // llvm.aarch64.sve.cmpge.wide
+    aarch64_sve_cmpgt,                         // llvm.aarch64.sve.cmpgt
+    aarch64_sve_cmpgt_wide,                    // llvm.aarch64.sve.cmpgt.wide
+    aarch64_sve_cmphi,                         // llvm.aarch64.sve.cmphi
+    aarch64_sve_cmphi_wide,                    // llvm.aarch64.sve.cmphi.wide
+    aarch64_sve_cmphs,                         // llvm.aarch64.sve.cmphs
+    aarch64_sve_cmphs_wide,                    // llvm.aarch64.sve.cmphs.wide
+    aarch64_sve_cmple_wide,                    // llvm.aarch64.sve.cmple.wide
+    aarch64_sve_cmplo_wide,                    // llvm.aarch64.sve.cmplo.wide
+    aarch64_sve_cmpls_wide,                    // llvm.aarch64.sve.cmpls.wide
+    aarch64_sve_cmplt_wide,                    // llvm.aarch64.sve.cmplt.wide
+    aarch64_sve_cmpne,                         // llvm.aarch64.sve.cmpne
+    aarch64_sve_cmpne_wide,                    // llvm.aarch64.sve.cmpne.wide
+    aarch64_sve_cnot,                          // llvm.aarch64.sve.cnot
+    aarch64_sve_cnt,                           // llvm.aarch64.sve.cnt
+    aarch64_sve_cntb,                          // llvm.aarch64.sve.cntb
+    aarch64_sve_cntd,                          // llvm.aarch64.sve.cntd
+    aarch64_sve_cnth,                          // llvm.aarch64.sve.cnth
+    aarch64_sve_cntp,                          // llvm.aarch64.sve.cntp
+    aarch64_sve_cntw,                          // llvm.aarch64.sve.cntw
+    aarch64_sve_compact,                       // llvm.aarch64.sve.compact
+    aarch64_sve_convert_from_svbool,           // llvm.aarch64.sve.convert.from.svbool
+    aarch64_sve_convert_to_svbool,             // llvm.aarch64.sve.convert.to.svbool
+    aarch64_sve_dup,                           // llvm.aarch64.sve.dup
+    aarch64_sve_dup_x,                         // llvm.aarch64.sve.dup.x
+    aarch64_sve_dupq_lane,                     // llvm.aarch64.sve.dupq.lane
+    aarch64_sve_eor,                           // llvm.aarch64.sve.eor
+    aarch64_sve_eor_z,                         // llvm.aarch64.sve.eor.z
+    aarch64_sve_eor3,                          // llvm.aarch64.sve.eor3
+    aarch64_sve_eorbt,                         // llvm.aarch64.sve.eorbt
+    aarch64_sve_eortb,                         // llvm.aarch64.sve.eortb
+    aarch64_sve_eorv,                          // llvm.aarch64.sve.eorv
+    aarch64_sve_ext,                           // llvm.aarch64.sve.ext
+    aarch64_sve_fabd,                          // llvm.aarch64.sve.fabd
+    aarch64_sve_fabs,                          // llvm.aarch64.sve.fabs
+    aarch64_sve_facge,                         // llvm.aarch64.sve.facge
+    aarch64_sve_facgt,                         // llvm.aarch64.sve.facgt
+    aarch64_sve_fadd,                          // llvm.aarch64.sve.fadd
+    aarch64_sve_fadda,                         // llvm.aarch64.sve.fadda
+    aarch64_sve_faddp,                         // llvm.aarch64.sve.faddp
+    aarch64_sve_faddv,                         // llvm.aarch64.sve.faddv
+    aarch64_sve_fcadd,                         // llvm.aarch64.sve.fcadd
+    aarch64_sve_fcmla,                         // llvm.aarch64.sve.fcmla
+    aarch64_sve_fcmla_lane,                    // llvm.aarch64.sve.fcmla.lane
+    aarch64_sve_fcmpeq,                        // llvm.aarch64.sve.fcmpeq
+    aarch64_sve_fcmpge,                        // llvm.aarch64.sve.fcmpge
+    aarch64_sve_fcmpgt,                        // llvm.aarch64.sve.fcmpgt
+    aarch64_sve_fcmpne,                        // llvm.aarch64.sve.fcmpne
+    aarch64_sve_fcmpuo,                        // llvm.aarch64.sve.fcmpuo
+    aarch64_sve_fcvt,                          // llvm.aarch64.sve.fcvt
+    aarch64_sve_fcvt_bf16f32,                  // llvm.aarch64.sve.fcvt.bf16f32
+    aarch64_sve_fcvt_f16f32,                   // llvm.aarch64.sve.fcvt.f16f32
+    aarch64_sve_fcvt_f16f64,                   // llvm.aarch64.sve.fcvt.f16f64
+    aarch64_sve_fcvt_f32f16,                   // llvm.aarch64.sve.fcvt.f32f16
+    aarch64_sve_fcvt_f32f64,                   // llvm.aarch64.sve.fcvt.f32f64
+    aarch64_sve_fcvt_f64f16,                   // llvm.aarch64.sve.fcvt.f64f16
+    aarch64_sve_fcvt_f64f32,                   // llvm.aarch64.sve.fcvt.f64f32
+    aarch64_sve_fcvtlt_f32f16,                 // llvm.aarch64.sve.fcvtlt.f32f16
+    aarch64_sve_fcvtlt_f64f32,                 // llvm.aarch64.sve.fcvtlt.f64f32
+    aarch64_sve_fcvtnt_bf16f32,                // llvm.aarch64.sve.fcvtnt.bf16f32
+    aarch64_sve_fcvtnt_f16f32,                 // llvm.aarch64.sve.fcvtnt.f16f32
+    aarch64_sve_fcvtnt_f32f64,                 // llvm.aarch64.sve.fcvtnt.f32f64
+    aarch64_sve_fcvtx_f32f64,                  // llvm.aarch64.sve.fcvtx.f32f64
+    aarch64_sve_fcvtxnt_f32f64,                // llvm.aarch64.sve.fcvtxnt.f32f64
+    aarch64_sve_fcvtzs,                        // llvm.aarch64.sve.fcvtzs
+    aarch64_sve_fcvtzs_i32f16,                 // llvm.aarch64.sve.fcvtzs.i32f16
+    aarch64_sve_fcvtzs_i32f64,                 // llvm.aarch64.sve.fcvtzs.i32f64
+    aarch64_sve_fcvtzs_i64f16,                 // llvm.aarch64.sve.fcvtzs.i64f16
+    aarch64_sve_fcvtzs_i64f32,                 // llvm.aarch64.sve.fcvtzs.i64f32
+    aarch64_sve_fcvtzu,                        // llvm.aarch64.sve.fcvtzu
+    aarch64_sve_fcvtzu_i32f16,                 // llvm.aarch64.sve.fcvtzu.i32f16
+    aarch64_sve_fcvtzu_i32f64,                 // llvm.aarch64.sve.fcvtzu.i32f64
+    aarch64_sve_fcvtzu_i64f16,                 // llvm.aarch64.sve.fcvtzu.i64f16
+    aarch64_sve_fcvtzu_i64f32,                 // llvm.aarch64.sve.fcvtzu.i64f32
+    aarch64_sve_fdiv,                          // llvm.aarch64.sve.fdiv
+    aarch64_sve_fdivr,                         // llvm.aarch64.sve.fdivr
+    aarch64_sve_fexpa_x,                       // llvm.aarch64.sve.fexpa.x
+    aarch64_sve_flogb,                         // llvm.aarch64.sve.flogb
+    aarch64_sve_fmad,                          // llvm.aarch64.sve.fmad
+    aarch64_sve_fmax,                          // llvm.aarch64.sve.fmax
+    aarch64_sve_fmaxnm,                        // llvm.aarch64.sve.fmaxnm
+    aarch64_sve_fmaxnmp,                       // llvm.aarch64.sve.fmaxnmp
+    aarch64_sve_fmaxnmv,                       // llvm.aarch64.sve.fmaxnmv
+    aarch64_sve_fmaxp,                         // llvm.aarch64.sve.fmaxp
+    aarch64_sve_fmaxv,                         // llvm.aarch64.sve.fmaxv
+    aarch64_sve_fmin,                          // llvm.aarch64.sve.fmin
+    aarch64_sve_fminnm,                        // llvm.aarch64.sve.fminnm
+    aarch64_sve_fminnmp,                       // llvm.aarch64.sve.fminnmp
+    aarch64_sve_fminnmv,                       // llvm.aarch64.sve.fminnmv
+    aarch64_sve_fminp,                         // llvm.aarch64.sve.fminp
+    aarch64_sve_fminv,                         // llvm.aarch64.sve.fminv
+    aarch64_sve_fmla,                          // llvm.aarch64.sve.fmla
+    aarch64_sve_fmla_lane,                     // llvm.aarch64.sve.fmla.lane
+    aarch64_sve_fmlalb,                        // llvm.aarch64.sve.fmlalb
+    aarch64_sve_fmlalb_lane,                   // llvm.aarch64.sve.fmlalb.lane
+    aarch64_sve_fmlalt,                        // llvm.aarch64.sve.fmlalt
+    aarch64_sve_fmlalt_lane,                   // llvm.aarch64.sve.fmlalt.lane
+    aarch64_sve_fmls,                          // llvm.aarch64.sve.fmls
+    aarch64_sve_fmls_lane,                     // llvm.aarch64.sve.fmls.lane
+    aarch64_sve_fmlslb,                        // llvm.aarch64.sve.fmlslb
+    aarch64_sve_fmlslb_lane,                   // llvm.aarch64.sve.fmlslb.lane
+    aarch64_sve_fmlslt,                        // llvm.aarch64.sve.fmlslt
+    aarch64_sve_fmlslt_lane,                   // llvm.aarch64.sve.fmlslt.lane
+    aarch64_sve_fmmla,                         // llvm.aarch64.sve.fmmla
+    aarch64_sve_fmsb,                          // llvm.aarch64.sve.fmsb
+    aarch64_sve_fmul,                          // llvm.aarch64.sve.fmul
+    aarch64_sve_fmul_lane,                     // llvm.aarch64.sve.fmul.lane
+    aarch64_sve_fmulx,                         // llvm.aarch64.sve.fmulx
+    aarch64_sve_fneg,                          // llvm.aarch64.sve.fneg
+    aarch64_sve_fnmad,                         // llvm.aarch64.sve.fnmad
+    aarch64_sve_fnmla,                         // llvm.aarch64.sve.fnmla
+    aarch64_sve_fnmls,                         // llvm.aarch64.sve.fnmls
+    aarch64_sve_fnmsb,                         // llvm.aarch64.sve.fnmsb
+    aarch64_sve_frecpe_x,                      // llvm.aarch64.sve.frecpe.x
+    aarch64_sve_frecps_x,                      // llvm.aarch64.sve.frecps.x
+    aarch64_sve_frecpx,                        // llvm.aarch64.sve.frecpx
+    aarch64_sve_frinta,                        // llvm.aarch64.sve.frinta
+    aarch64_sve_frinti,                        // llvm.aarch64.sve.frinti
+    aarch64_sve_frintm,                        // llvm.aarch64.sve.frintm
+    aarch64_sve_frintn,                        // llvm.aarch64.sve.frintn
+    aarch64_sve_frintp,                        // llvm.aarch64.sve.frintp
+    aarch64_sve_frintx,                        // llvm.aarch64.sve.frintx
+    aarch64_sve_frintz,                        // llvm.aarch64.sve.frintz
+    aarch64_sve_frsqrte_x,                     // llvm.aarch64.sve.frsqrte.x
+    aarch64_sve_frsqrts_x,                     // llvm.aarch64.sve.frsqrts.x
+    aarch64_sve_fscale,                        // llvm.aarch64.sve.fscale
+    aarch64_sve_fsqrt,                         // llvm.aarch64.sve.fsqrt
+    aarch64_sve_fsub,                          // llvm.aarch64.sve.fsub
+    aarch64_sve_fsubr,                         // llvm.aarch64.sve.fsubr
+    aarch64_sve_ftmad_x,                       // llvm.aarch64.sve.ftmad.x
+    aarch64_sve_ftsmul_x,                      // llvm.aarch64.sve.ftsmul.x
+    aarch64_sve_ftssel_x,                      // llvm.aarch64.sve.ftssel.x
+    aarch64_sve_histcnt,                       // llvm.aarch64.sve.histcnt
+    aarch64_sve_histseg,                       // llvm.aarch64.sve.histseg
+    aarch64_sve_index,                         // llvm.aarch64.sve.index
+    aarch64_sve_insr,                          // llvm.aarch64.sve.insr
+    aarch64_sve_lasta,                         // llvm.aarch64.sve.lasta
+    aarch64_sve_lastb,                         // llvm.aarch64.sve.lastb
+    aarch64_sve_ld1,                           // llvm.aarch64.sve.ld1
+    aarch64_sve_ld1_gather,                    // llvm.aarch64.sve.ld1.gather
+    aarch64_sve_ld1_gather_index,              // llvm.aarch64.sve.ld1.gather.index
+    aarch64_sve_ld1_gather_scalar_offset,      // llvm.aarch64.sve.ld1.gather.scalar.offset
+    aarch64_sve_ld1_gather_sxtw,               // llvm.aarch64.sve.ld1.gather.sxtw
+    aarch64_sve_ld1_gather_sxtw_index,         // llvm.aarch64.sve.ld1.gather.sxtw.index
+    aarch64_sve_ld1_gather_uxtw,               // llvm.aarch64.sve.ld1.gather.uxtw
+    aarch64_sve_ld1_gather_uxtw_index,         // llvm.aarch64.sve.ld1.gather.uxtw.index
+    aarch64_sve_ld1ro,                         // llvm.aarch64.sve.ld1ro
+    aarch64_sve_ld1rq,                         // llvm.aarch64.sve.ld1rq
+    aarch64_sve_ld2,                           // llvm.aarch64.sve.ld2
+    aarch64_sve_ld3,                           // llvm.aarch64.sve.ld3
+    aarch64_sve_ld4,                           // llvm.aarch64.sve.ld4
+    aarch64_sve_ldff1,                         // llvm.aarch64.sve.ldff1
+    aarch64_sve_ldff1_gather,                  // llvm.aarch64.sve.ldff1.gather
+    aarch64_sve_ldff1_gather_index,            // llvm.aarch64.sve.ldff1.gather.index
+    aarch64_sve_ldff1_gather_scalar_offset,    // llvm.aarch64.sve.ldff1.gather.scalar.offset
+    aarch64_sve_ldff1_gather_sxtw,             // llvm.aarch64.sve.ldff1.gather.sxtw
+    aarch64_sve_ldff1_gather_sxtw_index,       // llvm.aarch64.sve.ldff1.gather.sxtw.index
+    aarch64_sve_ldff1_gather_uxtw,             // llvm.aarch64.sve.ldff1.gather.uxtw
+    aarch64_sve_ldff1_gather_uxtw_index,       // llvm.aarch64.sve.ldff1.gather.uxtw.index
+    aarch64_sve_ldnf1,                         // llvm.aarch64.sve.ldnf1
+    aarch64_sve_ldnt1,                         // llvm.aarch64.sve.ldnt1
+    aarch64_sve_ldnt1_gather,                  // llvm.aarch64.sve.ldnt1.gather
+    aarch64_sve_ldnt1_gather_index,            // llvm.aarch64.sve.ldnt1.gather.index
+    aarch64_sve_ldnt1_gather_scalar_offset,    // llvm.aarch64.sve.ldnt1.gather.scalar.offset
+    aarch64_sve_ldnt1_gather_uxtw,             // llvm.aarch64.sve.ldnt1.gather.uxtw
+    aarch64_sve_lsl,                           // llvm.aarch64.sve.lsl
+    aarch64_sve_lsl_wide,                      // llvm.aarch64.sve.lsl.wide
+    aarch64_sve_lsr,                           // llvm.aarch64.sve.lsr
+    aarch64_sve_lsr_wide,                      // llvm.aarch64.sve.lsr.wide
+    aarch64_sve_mad,                           // llvm.aarch64.sve.mad
+    aarch64_sve_match,                         // llvm.aarch64.sve.match
+    aarch64_sve_mla,                           // llvm.aarch64.sve.mla
+    aarch64_sve_mla_lane,                      // llvm.aarch64.sve.mla.lane
+    aarch64_sve_mls,                           // llvm.aarch64.sve.mls
+    aarch64_sve_mls_lane,                      // llvm.aarch64.sve.mls.lane
+    aarch64_sve_msb,                           // llvm.aarch64.sve.msb
+    aarch64_sve_mul,                           // llvm.aarch64.sve.mul
+    aarch64_sve_mul_lane,                      // llvm.aarch64.sve.mul.lane
+    aarch64_sve_nand_z,                        // llvm.aarch64.sve.nand.z
+    aarch64_sve_nbsl,                          // llvm.aarch64.sve.nbsl
+    aarch64_sve_neg,                           // llvm.aarch64.sve.neg
+    aarch64_sve_nmatch,                        // llvm.aarch64.sve.nmatch
+    aarch64_sve_nor_z,                         // llvm.aarch64.sve.nor.z
+    aarch64_sve_not,                           // llvm.aarch64.sve.not
+    aarch64_sve_orn_z,                         // llvm.aarch64.sve.orn.z
+    aarch64_sve_orr,                           // llvm.aarch64.sve.orr
+    aarch64_sve_orr_z,                         // llvm.aarch64.sve.orr.z
+    aarch64_sve_orv,                           // llvm.aarch64.sve.orv
+    aarch64_sve_pfirst,                        // llvm.aarch64.sve.pfirst
+    aarch64_sve_pmul,                          // llvm.aarch64.sve.pmul
+    aarch64_sve_pmullb_pair,                   // llvm.aarch64.sve.pmullb.pair
+    aarch64_sve_pmullt_pair,                   // llvm.aarch64.sve.pmullt.pair
+    aarch64_sve_pnext,                         // llvm.aarch64.sve.pnext
+    aarch64_sve_prf,                           // llvm.aarch64.sve.prf
+    aarch64_sve_prfb_gather_index,             // llvm.aarch64.sve.prfb.gather.index
+    aarch64_sve_prfb_gather_scalar_offset,     // llvm.aarch64.sve.prfb.gather.scalar.offset
+    aarch64_sve_prfb_gather_sxtw_index,        // llvm.aarch64.sve.prfb.gather.sxtw.index
+    aarch64_sve_prfb_gather_uxtw_index,        // llvm.aarch64.sve.prfb.gather.uxtw.index
+    aarch64_sve_prfd_gather_index,             // llvm.aarch64.sve.prfd.gather.index
+    aarch64_sve_prfd_gather_scalar_offset,     // llvm.aarch64.sve.prfd.gather.scalar.offset
+    aarch64_sve_prfd_gather_sxtw_index,        // llvm.aarch64.sve.prfd.gather.sxtw.index
+    aarch64_sve_prfd_gather_uxtw_index,        // llvm.aarch64.sve.prfd.gather.uxtw.index
+    aarch64_sve_prfh_gather_index,             // llvm.aarch64.sve.prfh.gather.index
+    aarch64_sve_prfh_gather_scalar_offset,     // llvm.aarch64.sve.prfh.gather.scalar.offset
+    aarch64_sve_prfh_gather_sxtw_index,        // llvm.aarch64.sve.prfh.gather.sxtw.index
+    aarch64_sve_prfh_gather_uxtw_index,        // llvm.aarch64.sve.prfh.gather.uxtw.index
+    aarch64_sve_prfw_gather_index,             // llvm.aarch64.sve.prfw.gather.index
+    aarch64_sve_prfw_gather_scalar_offset,     // llvm.aarch64.sve.prfw.gather.scalar.offset
+    aarch64_sve_prfw_gather_sxtw_index,        // llvm.aarch64.sve.prfw.gather.sxtw.index
+    aarch64_sve_prfw_gather_uxtw_index,        // llvm.aarch64.sve.prfw.gather.uxtw.index
+    aarch64_sve_ptest_any,                     // llvm.aarch64.sve.ptest.any
+    aarch64_sve_ptest_first,                   // llvm.aarch64.sve.ptest.first
+    aarch64_sve_ptest_last,                    // llvm.aarch64.sve.ptest.last
+    aarch64_sve_ptrue,                         // llvm.aarch64.sve.ptrue
+    aarch64_sve_punpkhi,                       // llvm.aarch64.sve.punpkhi
+    aarch64_sve_punpklo,                       // llvm.aarch64.sve.punpklo
+    aarch64_sve_raddhnb,                       // llvm.aarch64.sve.raddhnb
+    aarch64_sve_raddhnt,                       // llvm.aarch64.sve.raddhnt
+    aarch64_sve_rax1,                          // llvm.aarch64.sve.rax1
+    aarch64_sve_rbit,                          // llvm.aarch64.sve.rbit
+    aarch64_sve_rdffr,                         // llvm.aarch64.sve.rdffr
+    aarch64_sve_rdffr_z,                       // llvm.aarch64.sve.rdffr.z
+    aarch64_sve_rev,                           // llvm.aarch64.sve.rev
+    aarch64_sve_revb,                          // llvm.aarch64.sve.revb
+    aarch64_sve_revh,                          // llvm.aarch64.sve.revh
+    aarch64_sve_revw,                          // llvm.aarch64.sve.revw
+    aarch64_sve_rshrnb,                        // llvm.aarch64.sve.rshrnb
+    aarch64_sve_rshrnt,                        // llvm.aarch64.sve.rshrnt
+    aarch64_sve_rsubhnb,                       // llvm.aarch64.sve.rsubhnb
+    aarch64_sve_rsubhnt,                       // llvm.aarch64.sve.rsubhnt
+    aarch64_sve_saba,                          // llvm.aarch64.sve.saba
+    aarch64_sve_sabalb,                        // llvm.aarch64.sve.sabalb
+    aarch64_sve_sabalt,                        // llvm.aarch64.sve.sabalt
+    aarch64_sve_sabd,                          // llvm.aarch64.sve.sabd
+    aarch64_sve_sabdlb,                        // llvm.aarch64.sve.sabdlb
+    aarch64_sve_sabdlt,                        // llvm.aarch64.sve.sabdlt
+    aarch64_sve_sadalp,                        // llvm.aarch64.sve.sadalp
+    aarch64_sve_saddlb,                        // llvm.aarch64.sve.saddlb
+    aarch64_sve_saddlbt,                       // llvm.aarch64.sve.saddlbt
+    aarch64_sve_saddlt,                        // llvm.aarch64.sve.saddlt
+    aarch64_sve_saddv,                         // llvm.aarch64.sve.saddv
+    aarch64_sve_saddwb,                        // llvm.aarch64.sve.saddwb
+    aarch64_sve_saddwt,                        // llvm.aarch64.sve.saddwt
+    aarch64_sve_sbclb,                         // llvm.aarch64.sve.sbclb
+    aarch64_sve_sbclt,                         // llvm.aarch64.sve.sbclt
+    aarch64_sve_scvtf,                         // llvm.aarch64.sve.scvtf
+    aarch64_sve_scvtf_f16i32,                  // llvm.aarch64.sve.scvtf.f16i32
+    aarch64_sve_scvtf_f16i64,                  // llvm.aarch64.sve.scvtf.f16i64
+    aarch64_sve_scvtf_f32i64,                  // llvm.aarch64.sve.scvtf.f32i64
+    aarch64_sve_scvtf_f64i32,                  // llvm.aarch64.sve.scvtf.f64i32
+    aarch64_sve_sdiv,                          // llvm.aarch64.sve.sdiv
+    aarch64_sve_sdivr,                         // llvm.aarch64.sve.sdivr
+    aarch64_sve_sdot,                          // llvm.aarch64.sve.sdot
+    aarch64_sve_sdot_lane,                     // llvm.aarch64.sve.sdot.lane
+    aarch64_sve_sel,                           // llvm.aarch64.sve.sel
+    aarch64_sve_setffr,                        // llvm.aarch64.sve.setffr
+    aarch64_sve_shadd,                         // llvm.aarch64.sve.shadd
+    aarch64_sve_shrnb,                         // llvm.aarch64.sve.shrnb
+    aarch64_sve_shrnt,                         // llvm.aarch64.sve.shrnt
+    aarch64_sve_shsub,                         // llvm.aarch64.sve.shsub
+    aarch64_sve_shsubr,                        // llvm.aarch64.sve.shsubr
+    aarch64_sve_sli,                           // llvm.aarch64.sve.sli
+    aarch64_sve_sm4e,                          // llvm.aarch64.sve.sm4e
+    aarch64_sve_sm4ekey,                       // llvm.aarch64.sve.sm4ekey
+    aarch64_sve_smax,                          // llvm.aarch64.sve.smax
+    aarch64_sve_smaxp,                         // llvm.aarch64.sve.smaxp
+    aarch64_sve_smaxv,                         // llvm.aarch64.sve.smaxv
+    aarch64_sve_smin,                          // llvm.aarch64.sve.smin
+    aarch64_sve_sminp,                         // llvm.aarch64.sve.sminp
+    aarch64_sve_sminv,                         // llvm.aarch64.sve.sminv
+    aarch64_sve_smlalb,                        // llvm.aarch64.sve.smlalb
+    aarch64_sve_smlalb_lane,                   // llvm.aarch64.sve.smlalb.lane
+    aarch64_sve_smlalt,                        // llvm.aarch64.sve.smlalt
+    aarch64_sve_smlalt_lane,                   // llvm.aarch64.sve.smlalt.lane
+    aarch64_sve_smlslb,                        // llvm.aarch64.sve.smlslb
+    aarch64_sve_smlslb_lane,                   // llvm.aarch64.sve.smlslb.lane
+    aarch64_sve_smlslt,                        // llvm.aarch64.sve.smlslt
+    aarch64_sve_smlslt_lane,                   // llvm.aarch64.sve.smlslt.lane
+    aarch64_sve_smmla,                         // llvm.aarch64.sve.smmla
+    aarch64_sve_smulh,                         // llvm.aarch64.sve.smulh
+    aarch64_sve_smullb,                        // llvm.aarch64.sve.smullb
+    aarch64_sve_smullb_lane,                   // llvm.aarch64.sve.smullb.lane
+    aarch64_sve_smullt,                        // llvm.aarch64.sve.smullt
+    aarch64_sve_smullt_lane,                   // llvm.aarch64.sve.smullt.lane
+    aarch64_sve_splice,                        // llvm.aarch64.sve.splice
+    aarch64_sve_sqabs,                         // llvm.aarch64.sve.sqabs
+    aarch64_sve_sqadd,                         // llvm.aarch64.sve.sqadd
+    aarch64_sve_sqadd_x,                       // llvm.aarch64.sve.sqadd.x
+    aarch64_sve_sqcadd_x,                      // llvm.aarch64.sve.sqcadd.x
+    aarch64_sve_sqdecb_n32,                    // llvm.aarch64.sve.sqdecb.n32
+    aarch64_sve_sqdecb_n64,                    // llvm.aarch64.sve.sqdecb.n64
+    aarch64_sve_sqdecd,                        // llvm.aarch64.sve.sqdecd
+    aarch64_sve_sqdecd_n32,                    // llvm.aarch64.sve.sqdecd.n32
+    aarch64_sve_sqdecd_n64,                    // llvm.aarch64.sve.sqdecd.n64
+    aarch64_sve_sqdech,                        // llvm.aarch64.sve.sqdech
+    aarch64_sve_sqdech_n32,                    // llvm.aarch64.sve.sqdech.n32
+    aarch64_sve_sqdech_n64,                    // llvm.aarch64.sve.sqdech.n64
+    aarch64_sve_sqdecp,                        // llvm.aarch64.sve.sqdecp
+    aarch64_sve_sqdecp_n32,                    // llvm.aarch64.sve.sqdecp.n32
+    aarch64_sve_sqdecp_n64,                    // llvm.aarch64.sve.sqdecp.n64
+    aarch64_sve_sqdecw,                        // llvm.aarch64.sve.sqdecw
+    aarch64_sve_sqdecw_n32,                    // llvm.aarch64.sve.sqdecw.n32
+    aarch64_sve_sqdecw_n64,                    // llvm.aarch64.sve.sqdecw.n64
+    aarch64_sve_sqdmlalb,                      // llvm.aarch64.sve.sqdmlalb
+    aarch64_sve_sqdmlalb_lane,                 // llvm.aarch64.sve.sqdmlalb.lane
+    aarch64_sve_sqdmlalbt,                     // llvm.aarch64.sve.sqdmlalbt
+    aarch64_sve_sqdmlalt,                      // llvm.aarch64.sve.sqdmlalt
+    aarch64_sve_sqdmlalt_lane,                 // llvm.aarch64.sve.sqdmlalt.lane
+    aarch64_sve_sqdmlslb,                      // llvm.aarch64.sve.sqdmlslb
+    aarch64_sve_sqdmlslb_lane,                 // llvm.aarch64.sve.sqdmlslb.lane
+    aarch64_sve_sqdmlslbt,                     // llvm.aarch64.sve.sqdmlslbt
+    aarch64_sve_sqdmlslt,                      // llvm.aarch64.sve.sqdmlslt
+    aarch64_sve_sqdmlslt_lane,                 // llvm.aarch64.sve.sqdmlslt.lane
+    aarch64_sve_sqdmulh,                       // llvm.aarch64.sve.sqdmulh
+    aarch64_sve_sqdmulh_lane,                  // llvm.aarch64.sve.sqdmulh.lane
+    aarch64_sve_sqdmullb,                      // llvm.aarch64.sve.sqdmullb
+    aarch64_sve_sqdmullb_lane,                 // llvm.aarch64.sve.sqdmullb.lane
+    aarch64_sve_sqdmullt,                      // llvm.aarch64.sve.sqdmullt
+    aarch64_sve_sqdmullt_lane,                 // llvm.aarch64.sve.sqdmullt.lane
+    aarch64_sve_sqincb_n32,                    // llvm.aarch64.sve.sqincb.n32
+    aarch64_sve_sqincb_n64,                    // llvm.aarch64.sve.sqincb.n64
+    aarch64_sve_sqincd,                        // llvm.aarch64.sve.sqincd
+    aarch64_sve_sqincd_n32,                    // llvm.aarch64.sve.sqincd.n32
+    aarch64_sve_sqincd_n64,                    // llvm.aarch64.sve.sqincd.n64
+    aarch64_sve_sqinch,                        // llvm.aarch64.sve.sqinch
+    aarch64_sve_sqinch_n32,                    // llvm.aarch64.sve.sqinch.n32
+    aarch64_sve_sqinch_n64,                    // llvm.aarch64.sve.sqinch.n64
+    aarch64_sve_sqincp,                        // llvm.aarch64.sve.sqincp
+    aarch64_sve_sqincp_n32,                    // llvm.aarch64.sve.sqincp.n32
+    aarch64_sve_sqincp_n64,                    // llvm.aarch64.sve.sqincp.n64
+    aarch64_sve_sqincw,                        // llvm.aarch64.sve.sqincw
+    aarch64_sve_sqincw_n32,                    // llvm.aarch64.sve.sqincw.n32
+    aarch64_sve_sqincw_n64,                    // llvm.aarch64.sve.sqincw.n64
+    aarch64_sve_sqneg,                         // llvm.aarch64.sve.sqneg
+    aarch64_sve_sqrdcmlah_lane_x,              // llvm.aarch64.sve.sqrdcmlah.lane.x
+    aarch64_sve_sqrdcmlah_x,                   // llvm.aarch64.sve.sqrdcmlah.x
+    aarch64_sve_sqrdmlah,                      // llvm.aarch64.sve.sqrdmlah
+    aarch64_sve_sqrdmlah_lane,                 // llvm.aarch64.sve.sqrdmlah.lane
+    aarch64_sve_sqrdmlsh,                      // llvm.aarch64.sve.sqrdmlsh
+    aarch64_sve_sqrdmlsh_lane,                 // llvm.aarch64.sve.sqrdmlsh.lane
+    aarch64_sve_sqrdmulh,                      // llvm.aarch64.sve.sqrdmulh
+    aarch64_sve_sqrdmulh_lane,                 // llvm.aarch64.sve.sqrdmulh.lane
+    aarch64_sve_sqrshl,                        // llvm.aarch64.sve.sqrshl
+    aarch64_sve_sqrshrnb,                      // llvm.aarch64.sve.sqrshrnb
+    aarch64_sve_sqrshrnt,                      // llvm.aarch64.sve.sqrshrnt
+    aarch64_sve_sqrshrunb,                     // llvm.aarch64.sve.sqrshrunb
+    aarch64_sve_sqrshrunt,                     // llvm.aarch64.sve.sqrshrunt
+    aarch64_sve_sqshl,                         // llvm.aarch64.sve.sqshl
+    aarch64_sve_sqshlu,                        // llvm.aarch64.sve.sqshlu
+    aarch64_sve_sqshrnb,                       // llvm.aarch64.sve.sqshrnb
+    aarch64_sve_sqshrnt,                       // llvm.aarch64.sve.sqshrnt
+    aarch64_sve_sqshrunb,                      // llvm.aarch64.sve.sqshrunb
+    aarch64_sve_sqshrunt,                      // llvm.aarch64.sve.sqshrunt
+    aarch64_sve_sqsub,                         // llvm.aarch64.sve.sqsub
+    aarch64_sve_sqsub_x,                       // llvm.aarch64.sve.sqsub.x
+    aarch64_sve_sqsubr,                        // llvm.aarch64.sve.sqsubr
+    aarch64_sve_sqxtnb,                        // llvm.aarch64.sve.sqxtnb
+    aarch64_sve_sqxtnt,                        // llvm.aarch64.sve.sqxtnt
+    aarch64_sve_sqxtunb,                       // llvm.aarch64.sve.sqxtunb
+    aarch64_sve_sqxtunt,                       // llvm.aarch64.sve.sqxtunt
+    aarch64_sve_srhadd,                        // llvm.aarch64.sve.srhadd
+    aarch64_sve_sri,                           // llvm.aarch64.sve.sri
+    aarch64_sve_srshl,                         // llvm.aarch64.sve.srshl
+    aarch64_sve_srshr,                         // llvm.aarch64.sve.srshr
+    aarch64_sve_srsra,                         // llvm.aarch64.sve.srsra
+    aarch64_sve_sshllb,                        // llvm.aarch64.sve.sshllb
+    aarch64_sve_sshllt,                        // llvm.aarch64.sve.sshllt
+    aarch64_sve_ssra,                          // llvm.aarch64.sve.ssra
+    aarch64_sve_ssublb,                        // llvm.aarch64.sve.ssublb
+    aarch64_sve_ssublbt,                       // llvm.aarch64.sve.ssublbt
+    aarch64_sve_ssublt,                        // llvm.aarch64.sve.ssublt
+    aarch64_sve_ssubltb,                       // llvm.aarch64.sve.ssubltb
+    aarch64_sve_ssubwb,                        // llvm.aarch64.sve.ssubwb
+    aarch64_sve_ssubwt,                        // llvm.aarch64.sve.ssubwt
+    aarch64_sve_st1,                           // llvm.aarch64.sve.st1
+    aarch64_sve_st1_scatter,                   // llvm.aarch64.sve.st1.scatter
+    aarch64_sve_st1_scatter_index,             // llvm.aarch64.sve.st1.scatter.index
+    aarch64_sve_st1_scatter_scalar_offset,     // llvm.aarch64.sve.st1.scatter.scalar.offset
+    aarch64_sve_st1_scatter_sxtw,              // llvm.aarch64.sve.st1.scatter.sxtw
+    aarch64_sve_st1_scatter_sxtw_index,        // llvm.aarch64.sve.st1.scatter.sxtw.index
+    aarch64_sve_st1_scatter_uxtw,              // llvm.aarch64.sve.st1.scatter.uxtw
+    aarch64_sve_st1_scatter_uxtw_index,        // llvm.aarch64.sve.st1.scatter.uxtw.index
+    aarch64_sve_st2,                           // llvm.aarch64.sve.st2
+    aarch64_sve_st3,                           // llvm.aarch64.sve.st3
+    aarch64_sve_st4,                           // llvm.aarch64.sve.st4
+    aarch64_sve_stnt1,                         // llvm.aarch64.sve.stnt1
+    aarch64_sve_stnt1_scatter,                 // llvm.aarch64.sve.stnt1.scatter
+    aarch64_sve_stnt1_scatter_index,           // llvm.aarch64.sve.stnt1.scatter.index
+    aarch64_sve_stnt1_scatter_scalar_offset,   // llvm.aarch64.sve.stnt1.scatter.scalar.offset
+    aarch64_sve_stnt1_scatter_uxtw,            // llvm.aarch64.sve.stnt1.scatter.uxtw
+    aarch64_sve_sub,                           // llvm.aarch64.sve.sub
+    aarch64_sve_subhnb,                        // llvm.aarch64.sve.subhnb
+    aarch64_sve_subhnt,                        // llvm.aarch64.sve.subhnt
+    aarch64_sve_subr,                          // llvm.aarch64.sve.subr
+    aarch64_sve_sudot_lane,                    // llvm.aarch64.sve.sudot.lane
+    aarch64_sve_sunpkhi,                       // llvm.aarch64.sve.sunpkhi
+    aarch64_sve_sunpklo,                       // llvm.aarch64.sve.sunpklo
+    aarch64_sve_suqadd,                        // llvm.aarch64.sve.suqadd
+    aarch64_sve_sxtb,                          // llvm.aarch64.sve.sxtb
+    aarch64_sve_sxth,                          // llvm.aarch64.sve.sxth
+    aarch64_sve_sxtw,                          // llvm.aarch64.sve.sxtw
+    aarch64_sve_tbl,                           // llvm.aarch64.sve.tbl
+    aarch64_sve_tbl2,                          // llvm.aarch64.sve.tbl2
+    aarch64_sve_tbx,                           // llvm.aarch64.sve.tbx
+    aarch64_sve_trn1,                          // llvm.aarch64.sve.trn1
+    aarch64_sve_trn1q,                         // llvm.aarch64.sve.trn1q
+    aarch64_sve_trn2,                          // llvm.aarch64.sve.trn2
+    aarch64_sve_trn2q,                         // llvm.aarch64.sve.trn2q
+    aarch64_sve_tuple_create2,                 // llvm.aarch64.sve.tuple.create2
+    aarch64_sve_tuple_create3,                 // llvm.aarch64.sve.tuple.create3
+    aarch64_sve_tuple_create4,                 // llvm.aarch64.sve.tuple.create4
+    aarch64_sve_tuple_get,                     // llvm.aarch64.sve.tuple.get
+    aarch64_sve_tuple_set,                     // llvm.aarch64.sve.tuple.set
+    aarch64_sve_uaba,                          // llvm.aarch64.sve.uaba
+    aarch64_sve_uabalb,                        // llvm.aarch64.sve.uabalb
+    aarch64_sve_uabalt,                        // llvm.aarch64.sve.uabalt
+    aarch64_sve_uabd,                          // llvm.aarch64.sve.uabd
+    aarch64_sve_uabdlb,                        // llvm.aarch64.sve.uabdlb
+    aarch64_sve_uabdlt,                        // llvm.aarch64.sve.uabdlt
+    aarch64_sve_uadalp,                        // llvm.aarch64.sve.uadalp
+    aarch64_sve_uaddlb,                        // llvm.aarch64.sve.uaddlb
+    aarch64_sve_uaddlt,                        // llvm.aarch64.sve.uaddlt
+    aarch64_sve_uaddv,                         // llvm.aarch64.sve.uaddv
+    aarch64_sve_uaddwb,                        // llvm.aarch64.sve.uaddwb
+    aarch64_sve_uaddwt,                        // llvm.aarch64.sve.uaddwt
+    aarch64_sve_ucvtf,                         // llvm.aarch64.sve.ucvtf
+    aarch64_sve_ucvtf_f16i32,                  // llvm.aarch64.sve.ucvtf.f16i32
+    aarch64_sve_ucvtf_f16i64,                  // llvm.aarch64.sve.ucvtf.f16i64
+    aarch64_sve_ucvtf_f32i64,                  // llvm.aarch64.sve.ucvtf.f32i64
+    aarch64_sve_ucvtf_f64i32,                  // llvm.aarch64.sve.ucvtf.f64i32
+    aarch64_sve_udiv,                          // llvm.aarch64.sve.udiv
+    aarch64_sve_udivr,                         // llvm.aarch64.sve.udivr
+    aarch64_sve_udot,                          // llvm.aarch64.sve.udot
+    aarch64_sve_udot_lane,                     // llvm.aarch64.sve.udot.lane
+    aarch64_sve_uhadd,                         // llvm.aarch64.sve.uhadd
+    aarch64_sve_uhsub,                         // llvm.aarch64.sve.uhsub
+    aarch64_sve_uhsubr,                        // llvm.aarch64.sve.uhsubr
+    aarch64_sve_umax,                          // llvm.aarch64.sve.umax
+    aarch64_sve_umaxp,                         // llvm.aarch64.sve.umaxp
+    aarch64_sve_umaxv,                         // llvm.aarch64.sve.umaxv
+    aarch64_sve_umin,                          // llvm.aarch64.sve.umin
+    aarch64_sve_uminp,                         // llvm.aarch64.sve.uminp
+    aarch64_sve_uminv,                         // llvm.aarch64.sve.uminv
+    aarch64_sve_umlalb,                        // llvm.aarch64.sve.umlalb
+    aarch64_sve_umlalb_lane,                   // llvm.aarch64.sve.umlalb.lane
+    aarch64_sve_umlalt,                        // llvm.aarch64.sve.umlalt
+    aarch64_sve_umlalt_lane,                   // llvm.aarch64.sve.umlalt.lane
+    aarch64_sve_umlslb,                        // llvm.aarch64.sve.umlslb
+    aarch64_sve_umlslb_lane,                   // llvm.aarch64.sve.umlslb.lane
+    aarch64_sve_umlslt,                        // llvm.aarch64.sve.umlslt
+    aarch64_sve_umlslt_lane,                   // llvm.aarch64.sve.umlslt.lane
+    aarch64_sve_ummla,                         // llvm.aarch64.sve.ummla
+    aarch64_sve_umulh,                         // llvm.aarch64.sve.umulh
+    aarch64_sve_umullb,                        // llvm.aarch64.sve.umullb
+    aarch64_sve_umullb_lane,                   // llvm.aarch64.sve.umullb.lane
+    aarch64_sve_umullt,                        // llvm.aarch64.sve.umullt
+    aarch64_sve_umullt_lane,                   // llvm.aarch64.sve.umullt.lane
+    aarch64_sve_uqadd,                         // llvm.aarch64.sve.uqadd
+    aarch64_sve_uqadd_x,                       // llvm.aarch64.sve.uqadd.x
+    aarch64_sve_uqdecb_n32,                    // llvm.aarch64.sve.uqdecb.n32
+    aarch64_sve_uqdecb_n64,                    // llvm.aarch64.sve.uqdecb.n64
+    aarch64_sve_uqdecd,                        // llvm.aarch64.sve.uqdecd
+    aarch64_sve_uqdecd_n32,                    // llvm.aarch64.sve.uqdecd.n32
+    aarch64_sve_uqdecd_n64,                    // llvm.aarch64.sve.uqdecd.n64
+    aarch64_sve_uqdech,                        // llvm.aarch64.sve.uqdech
+    aarch64_sve_uqdech_n32,                    // llvm.aarch64.sve.uqdech.n32
+    aarch64_sve_uqdech_n64,                    // llvm.aarch64.sve.uqdech.n64
+    aarch64_sve_uqdecp,                        // llvm.aarch64.sve.uqdecp
+    aarch64_sve_uqdecp_n32,                    // llvm.aarch64.sve.uqdecp.n32
+    aarch64_sve_uqdecp_n64,                    // llvm.aarch64.sve.uqdecp.n64
+    aarch64_sve_uqdecw,                        // llvm.aarch64.sve.uqdecw
+    aarch64_sve_uqdecw_n32,                    // llvm.aarch64.sve.uqdecw.n32
+    aarch64_sve_uqdecw_n64,                    // llvm.aarch64.sve.uqdecw.n64
+    aarch64_sve_uqincb_n32,                    // llvm.aarch64.sve.uqincb.n32
+    aarch64_sve_uqincb_n64,                    // llvm.aarch64.sve.uqincb.n64
+    aarch64_sve_uqincd,                        // llvm.aarch64.sve.uqincd
+    aarch64_sve_uqincd_n32,                    // llvm.aarch64.sve.uqincd.n32
+    aarch64_sve_uqincd_n64,                    // llvm.aarch64.sve.uqincd.n64
+    aarch64_sve_uqinch,                        // llvm.aarch64.sve.uqinch
+    aarch64_sve_uqinch_n32,                    // llvm.aarch64.sve.uqinch.n32
+    aarch64_sve_uqinch_n64,                    // llvm.aarch64.sve.uqinch.n64
+    aarch64_sve_uqincp,                        // llvm.aarch64.sve.uqincp
+    aarch64_sve_uqincp_n32,                    // llvm.aarch64.sve.uqincp.n32
+    aarch64_sve_uqincp_n64,                    // llvm.aarch64.sve.uqincp.n64
+    aarch64_sve_uqincw,                        // llvm.aarch64.sve.uqincw
+    aarch64_sve_uqincw_n32,                    // llvm.aarch64.sve.uqincw.n32
+    aarch64_sve_uqincw_n64,                    // llvm.aarch64.sve.uqincw.n64
+    aarch64_sve_uqrshl,                        // llvm.aarch64.sve.uqrshl
+    aarch64_sve_uqrshrnb,                      // llvm.aarch64.sve.uqrshrnb
+    aarch64_sve_uqrshrnt,                      // llvm.aarch64.sve.uqrshrnt
+    aarch64_sve_uqshl,                         // llvm.aarch64.sve.uqshl
+    aarch64_sve_uqshrnb,                       // llvm.aarch64.sve.uqshrnb
+    aarch64_sve_uqshrnt,                       // llvm.aarch64.sve.uqshrnt
+    aarch64_sve_uqsub,                         // llvm.aarch64.sve.uqsub
+    aarch64_sve_uqsub_x,                       // llvm.aarch64.sve.uqsub.x
+    aarch64_sve_uqsubr,                        // llvm.aarch64.sve.uqsubr
+    aarch64_sve_uqxtnb,                        // llvm.aarch64.sve.uqxtnb
+    aarch64_sve_uqxtnt,                        // llvm.aarch64.sve.uqxtnt
+    aarch64_sve_urecpe,                        // llvm.aarch64.sve.urecpe
+    aarch64_sve_urhadd,                        // llvm.aarch64.sve.urhadd
+    aarch64_sve_urshl,                         // llvm.aarch64.sve.urshl
+    aarch64_sve_urshr,                         // llvm.aarch64.sve.urshr
+    aarch64_sve_ursqrte,                       // llvm.aarch64.sve.ursqrte
+    aarch64_sve_ursra,                         // llvm.aarch64.sve.ursra
+    aarch64_sve_usdot,                         // llvm.aarch64.sve.usdot
+    aarch64_sve_usdot_lane,                    // llvm.aarch64.sve.usdot.lane
+    aarch64_sve_ushllb,                        // llvm.aarch64.sve.ushllb
+    aarch64_sve_ushllt,                        // llvm.aarch64.sve.ushllt
+    aarch64_sve_usmmla,                        // llvm.aarch64.sve.usmmla
+    aarch64_sve_usqadd,                        // llvm.aarch64.sve.usqadd
+    aarch64_sve_usra,                          // llvm.aarch64.sve.usra
+    aarch64_sve_usublb,                        // llvm.aarch64.sve.usublb
+    aarch64_sve_usublt,                        // llvm.aarch64.sve.usublt
+    aarch64_sve_usubwb,                        // llvm.aarch64.sve.usubwb
+    aarch64_sve_usubwt,                        // llvm.aarch64.sve.usubwt
+    aarch64_sve_uunpkhi,                       // llvm.aarch64.sve.uunpkhi
+    aarch64_sve_uunpklo,                       // llvm.aarch64.sve.uunpklo
+    aarch64_sve_uxtb,                          // llvm.aarch64.sve.uxtb
+    aarch64_sve_uxth,                          // llvm.aarch64.sve.uxth
+    aarch64_sve_uxtw,                          // llvm.aarch64.sve.uxtw
+    aarch64_sve_uzp1,                          // llvm.aarch64.sve.uzp1
+    aarch64_sve_uzp1q,                         // llvm.aarch64.sve.uzp1q
+    aarch64_sve_uzp2,                          // llvm.aarch64.sve.uzp2
+    aarch64_sve_uzp2q,                         // llvm.aarch64.sve.uzp2q
+    aarch64_sve_whilege,                       // llvm.aarch64.sve.whilege
+    aarch64_sve_whilegt,                       // llvm.aarch64.sve.whilegt
+    aarch64_sve_whilehi,                       // llvm.aarch64.sve.whilehi
+    aarch64_sve_whilehs,                       // llvm.aarch64.sve.whilehs
+    aarch64_sve_whilele,                       // llvm.aarch64.sve.whilele
+    aarch64_sve_whilelo,                       // llvm.aarch64.sve.whilelo
+    aarch64_sve_whilels,                       // llvm.aarch64.sve.whilels
+    aarch64_sve_whilelt,                       // llvm.aarch64.sve.whilelt
+    aarch64_sve_whilerw_b,                     // llvm.aarch64.sve.whilerw.b
+    aarch64_sve_whilerw_d,                     // llvm.aarch64.sve.whilerw.d
+    aarch64_sve_whilerw_h,                     // llvm.aarch64.sve.whilerw.h
+    aarch64_sve_whilerw_s,                     // llvm.aarch64.sve.whilerw.s
+    aarch64_sve_whilewr_b,                     // llvm.aarch64.sve.whilewr.b
+    aarch64_sve_whilewr_d,                     // llvm.aarch64.sve.whilewr.d
+    aarch64_sve_whilewr_h,                     // llvm.aarch64.sve.whilewr.h
+    aarch64_sve_whilewr_s,                     // llvm.aarch64.sve.whilewr.s
+    aarch64_sve_wrffr,                         // llvm.aarch64.sve.wrffr
+    aarch64_sve_xar,                           // llvm.aarch64.sve.xar
+    aarch64_sve_zip1,                          // llvm.aarch64.sve.zip1
+    aarch64_sve_zip1q,                         // llvm.aarch64.sve.zip1q
+    aarch64_sve_zip2,                          // llvm.aarch64.sve.zip2
+    aarch64_sve_zip2q,                         // llvm.aarch64.sve.zip2q
+    aarch64_tagp,                              // llvm.aarch64.tagp
+    aarch64_tcancel,                           // llvm.aarch64.tcancel
+    aarch64_tcommit,                           // llvm.aarch64.tcommit
+    aarch64_tstart,                            // llvm.aarch64.tstart
+    aarch64_ttest,                             // llvm.aarch64.ttest
+    aarch64_udiv,                              // llvm.aarch64.udiv
+}; // enum
+} // namespace Intrinsic
+} // namespace llvm
+
+#endif
diff --git a/linux-x64/clang/include/llvm/IR/IntrinsicsAArch64.td b/linux-x64/clang/include/llvm/IR/IntrinsicsAArch64.td
index 720a7bd..9e4d626 100644
--- a/linux-x64/clang/include/llvm/IR/IntrinsicsAArch64.td
+++ b/linux-x64/clang/include/llvm/IR/IntrinsicsAArch64.td
@@ -31,6 +31,11 @@
 def int_aarch64_udiv : Intrinsic<[llvm_anyint_ty], [LLVMMatchType<0>,
                                 LLVMMatchType<0>], [IntrNoMem]>;
 
+def int_aarch64_fjcvtzs : Intrinsic<[llvm_i32_ty], [llvm_double_ty], [IntrNoMem]>;
+
+def int_aarch64_cls: Intrinsic<[llvm_i32_ty], [llvm_i32_ty], [IntrNoMem]>;
+def int_aarch64_cls64: Intrinsic<[llvm_i32_ty], [llvm_i64_ty], [IntrNoMem]>;
+
 //===----------------------------------------------------------------------===//
 // HINT
 
@@ -128,6 +133,10 @@
     : Intrinsic<[llvm_anyvector_ty],
                 [LLVMHalfElementsVectorType<0>, llvm_anyvector_ty],
                 [IntrNoMem]>;
+  class AdvSIMD_2VectorArg_Lane_Intrinsic
+    : Intrinsic<[llvm_anyint_ty],
+                [LLVMMatchType<0>, llvm_anyint_ty, llvm_i32_ty],
+                [IntrNoMem]>;
 
   class AdvSIMD_3VectorArg_Intrinsic
       : Intrinsic<[llvm_anyvector_ty],
@@ -164,6 +173,21 @@
     : Intrinsic<[llvm_anyvector_ty],
                 [LLVMMatchType<0>, llvm_anyvector_ty, LLVMMatchType<1>],
                 [IntrNoMem]>;
+
+  class AdvSIMD_MatMul_Intrinsic
+    : Intrinsic<[llvm_anyvector_ty],
+                [LLVMMatchType<0>, llvm_anyvector_ty, LLVMMatchType<1>],
+                [IntrNoMem]>;
+
+  class AdvSIMD_FML_Intrinsic
+    : Intrinsic<[llvm_anyvector_ty],
+                [LLVMMatchType<0>, llvm_anyvector_ty, LLVMMatchType<1>],
+                [IntrNoMem]>;
+
+  class AdvSIMD_BF16FML_Intrinsic
+    : Intrinsic<[llvm_v4f32_ty],
+                [llvm_v4f32_ty, llvm_v8bf16_ty, llvm_v8bf16_ty],
+                [IntrNoMem]>;
 }
 
 // Arithmetic ops
@@ -202,9 +226,13 @@
 
   // Vector Saturating Doubling Multiply High
   def int_aarch64_neon_sqdmulh : AdvSIMD_2IntArg_Intrinsic;
+  def int_aarch64_neon_sqdmulh_lane : AdvSIMD_2VectorArg_Lane_Intrinsic;
+  def int_aarch64_neon_sqdmulh_laneq : AdvSIMD_2VectorArg_Lane_Intrinsic;
 
   // Vector Saturating Rounding Doubling Multiply High
   def int_aarch64_neon_sqrdmulh : AdvSIMD_2IntArg_Intrinsic;
+  def int_aarch64_neon_sqrdmulh_lane : AdvSIMD_2VectorArg_Lane_Intrinsic;
+  def int_aarch64_neon_sqrdmulh_laneq : AdvSIMD_2VectorArg_Lane_Intrinsic;
 
   // Vector Polynominal Multiply
   def int_aarch64_neon_pmul : AdvSIMD_2VectorArg_Intrinsic;
@@ -436,11 +464,44 @@
   def int_aarch64_neon_udot : AdvSIMD_Dot_Intrinsic;
   def int_aarch64_neon_sdot : AdvSIMD_Dot_Intrinsic;
 
+// v8.6-A Matrix Multiply Intrinsics
+  def int_aarch64_neon_ummla : AdvSIMD_MatMul_Intrinsic;
+  def int_aarch64_neon_smmla : AdvSIMD_MatMul_Intrinsic;
+  def int_aarch64_neon_usmmla : AdvSIMD_MatMul_Intrinsic;
+  def int_aarch64_neon_usdot : AdvSIMD_Dot_Intrinsic;
+  def int_aarch64_neon_bfdot : AdvSIMD_Dot_Intrinsic;
+  def int_aarch64_neon_bfmmla
+    : Intrinsic<[llvm_v4f32_ty],
+                [llvm_v4f32_ty, llvm_v8bf16_ty, llvm_v8bf16_ty],
+                [IntrNoMem]>;
+  def int_aarch64_neon_bfmlalb : AdvSIMD_BF16FML_Intrinsic;
+  def int_aarch64_neon_bfmlalt : AdvSIMD_BF16FML_Intrinsic;
+
+
+  // v8.6-A Bfloat Intrinsics
+  def int_aarch64_neon_bfcvt
+    : Intrinsic<[llvm_bfloat_ty], [llvm_float_ty], [IntrNoMem]>;
+  def int_aarch64_neon_bfcvtn
+    : Intrinsic<[llvm_v8bf16_ty], [llvm_v4f32_ty], [IntrNoMem]>;
+  def int_aarch64_neon_bfcvtn2
+    : Intrinsic<[llvm_v8bf16_ty],
+                [llvm_v8bf16_ty, llvm_v4f32_ty],
+                [IntrNoMem]>;
+
   // v8.2-A FP16 Fused Multiply-Add Long
   def int_aarch64_neon_fmlal : AdvSIMD_FP16FML_Intrinsic;
   def int_aarch64_neon_fmlsl : AdvSIMD_FP16FML_Intrinsic;
   def int_aarch64_neon_fmlal2 : AdvSIMD_FP16FML_Intrinsic;
   def int_aarch64_neon_fmlsl2 : AdvSIMD_FP16FML_Intrinsic;
+
+  // v8.3-A Floating-point complex add
+  def int_aarch64_neon_vcadd_rot90  : AdvSIMD_2VectorArg_Intrinsic;
+  def int_aarch64_neon_vcadd_rot270 : AdvSIMD_2VectorArg_Intrinsic;
+
+  def int_aarch64_neon_vcmla_rot0   : AdvSIMD_3VectorArg_Intrinsic;
+  def int_aarch64_neon_vcmla_rot90  : AdvSIMD_3VectorArg_Intrinsic;
+  def int_aarch64_neon_vcmla_rot180 : AdvSIMD_3VectorArg_Intrinsic;
+  def int_aarch64_neon_vcmla_rot270 : AdvSIMD_3VectorArg_Intrinsic;
 }
 
 let TargetPrefix = "aarch64" in {  // All intrinsics start with "llvm.aarch64.".
@@ -459,7 +520,7 @@
                   [IntrReadMem, IntrArgMemOnly]>;
   class AdvSIMD_1Vec_Store_Lane_Intrinsic
     : Intrinsic<[], [llvm_anyvector_ty, llvm_i64_ty, llvm_anyptr_ty],
-                [IntrArgMemOnly, NoCapture<2>]>;
+                [IntrArgMemOnly, NoCapture<ArgIndex<2>>]>;
 
   class AdvSIMD_2Vec_Load_Intrinsic
     : Intrinsic<[LLVMMatchType<0>, llvm_anyvector_ty],
@@ -473,11 +534,11 @@
   class AdvSIMD_2Vec_Store_Intrinsic
     : Intrinsic<[], [llvm_anyvector_ty, LLVMMatchType<0>,
                      LLVMAnyPointerType<LLVMMatchType<0>>],
-                [IntrArgMemOnly, NoCapture<2>]>;
+                [IntrArgMemOnly, NoCapture<ArgIndex<2>>]>;
   class AdvSIMD_2Vec_Store_Lane_Intrinsic
     : Intrinsic<[], [llvm_anyvector_ty, LLVMMatchType<0>,
                  llvm_i64_ty, llvm_anyptr_ty],
-                [IntrArgMemOnly, NoCapture<3>]>;
+                [IntrArgMemOnly, NoCapture<ArgIndex<3>>]>;
 
   class AdvSIMD_3Vec_Load_Intrinsic
     : Intrinsic<[LLVMMatchType<0>, LLVMMatchType<0>, llvm_anyvector_ty],
@@ -491,12 +552,12 @@
   class AdvSIMD_3Vec_Store_Intrinsic
     : Intrinsic<[], [llvm_anyvector_ty, LLVMMatchType<0>,
                      LLVMMatchType<0>, LLVMAnyPointerType<LLVMMatchType<0>>],
-                [IntrArgMemOnly, NoCapture<3>]>;
+                [IntrArgMemOnly, NoCapture<ArgIndex<3>>]>;
   class AdvSIMD_3Vec_Store_Lane_Intrinsic
     : Intrinsic<[], [llvm_anyvector_ty,
                  LLVMMatchType<0>, LLVMMatchType<0>,
                  llvm_i64_ty, llvm_anyptr_ty],
-                [IntrArgMemOnly, NoCapture<4>]>;
+                [IntrArgMemOnly, NoCapture<ArgIndex<4>>]>;
 
   class AdvSIMD_4Vec_Load_Intrinsic
     : Intrinsic<[LLVMMatchType<0>, LLVMMatchType<0>,
@@ -514,12 +575,12 @@
     : Intrinsic<[], [llvm_anyvector_ty, LLVMMatchType<0>,
                  LLVMMatchType<0>, LLVMMatchType<0>,
                  LLVMAnyPointerType<LLVMMatchType<0>>],
-                [IntrArgMemOnly, NoCapture<4>]>;
+                [IntrArgMemOnly, NoCapture<ArgIndex<4>>]>;
   class AdvSIMD_4Vec_Store_Lane_Intrinsic
     : Intrinsic<[], [llvm_anyvector_ty, LLVMMatchType<0>,
                  LLVMMatchType<0>, LLVMMatchType<0>,
                  llvm_i64_ty, llvm_anyptr_ty],
-                [IntrArgMemOnly, NoCapture<5>]>;
+                [IntrArgMemOnly, NoCapture<ArgIndex<5>>]>;
 }
 
 // Memory ops
@@ -602,7 +663,7 @@
 
 let TargetPrefix = "aarch64" in {
   class FPCR_Get_Intrinsic
-    : Intrinsic<[llvm_i64_ty], [], [IntrNoMem]>;
+    : Intrinsic<[llvm_i64_ty], [], [IntrNoMem, IntrHasSideEffects]>;
 }
 
 // FPCR
@@ -689,7 +750,7 @@
 // Memory Tagging Extensions (MTE) Intrinsics
 let TargetPrefix = "aarch64" in {
 def int_aarch64_irg   : Intrinsic<[llvm_ptr_ty], [llvm_ptr_ty, llvm_i64_ty],
-    [IntrInaccessibleMemOnly]>;
+    [IntrNoMem, IntrHasSideEffects]>;
 def int_aarch64_addg  : Intrinsic<[llvm_ptr_ty], [llvm_ptr_ty, llvm_i64_ty],
     [IntrNoMem]>;
 def int_aarch64_gmi   : Intrinsic<[llvm_i64_ty], [llvm_ptr_ty, llvm_i64_ty],
@@ -700,4 +761,1659 @@
     [IntrWriteMem]>;
 def int_aarch64_subp :  Intrinsic<[llvm_i64_ty], [llvm_ptr_ty, llvm_ptr_ty],
     [IntrNoMem]>;
+
+// The following are codegen-only intrinsics for stack instrumentation.
+
+// Generate a randomly tagged stack base pointer.
+def int_aarch64_irg_sp   : Intrinsic<[llvm_ptr_ty], [llvm_i64_ty],
+    [IntrNoMem, IntrHasSideEffects]>;
+
+// Transfer pointer tag with offset.
+// ptr1 = tagp(ptr0, baseptr, tag_offset) returns a pointer where
+// * address is the address in ptr0
+// * tag is a function of (tag in baseptr, tag_offset).
+// ** Beware, this is not the same function as implemented by the ADDG instruction!
+//    Backend optimizations may change tag_offset; the only guarantee is that calls
+//    to tagp with the same pair of (baseptr, tag_offset) will produce pointers
+//    with the same tag value, assuming the set of excluded tags has not changed.
+// Address bits in baseptr and tag bits in ptr0 are ignored.
+// When offset between ptr0 and baseptr is a compile time constant, this can be emitted as
+//   ADDG ptr1, baseptr, (ptr0 - baseptr), tag_offset
+// It is intended that ptr0 is an alloca address, and baseptr is the direct output of llvm.aarch64.irg.sp.
+def int_aarch64_tagp : Intrinsic<[llvm_anyptr_ty], [LLVMMatchType<0>, llvm_ptr_ty, llvm_i64_ty],
+    [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+// Update allocation tags for the memory range to match the tag in the pointer argument.
+def int_aarch64_settag  : Intrinsic<[], [llvm_ptr_ty, llvm_i64_ty],
+    [IntrWriteMem, IntrArgMemOnly, NoCapture<ArgIndex<0>>, WriteOnly<ArgIndex<0>>]>;
+
+// Update allocation tags for the memory range to match the tag in the pointer argument,
+// and set memory contents to zero.
+def int_aarch64_settag_zero  : Intrinsic<[], [llvm_ptr_ty, llvm_i64_ty],
+    [IntrWriteMem, IntrArgMemOnly, NoCapture<ArgIndex<0>>, WriteOnly<ArgIndex<0>>]>;
+
+// Update allocation tags for 16-aligned, 16-sized memory region, and store a pair 8-byte values.
+def int_aarch64_stgp  : Intrinsic<[], [llvm_ptr_ty, llvm_i64_ty, llvm_i64_ty],
+    [IntrWriteMem, IntrArgMemOnly, NoCapture<ArgIndex<0>>, WriteOnly<ArgIndex<0>>]>;
 }
+
+// Transactional Memory Extension (TME) Intrinsics
+let TargetPrefix = "aarch64" in {
+def int_aarch64_tstart  : GCCBuiltin<"__builtin_arm_tstart">,
+                         Intrinsic<[llvm_i64_ty]>;
+
+def int_aarch64_tcommit : GCCBuiltin<"__builtin_arm_tcommit">, Intrinsic<[]>;
+
+def int_aarch64_tcancel : GCCBuiltin<"__builtin_arm_tcancel">,
+                          Intrinsic<[], [llvm_i64_ty], [ImmArg<ArgIndex<0>>]>;
+
+def int_aarch64_ttest   : GCCBuiltin<"__builtin_arm_ttest">,
+                          Intrinsic<[llvm_i64_ty], [],
+                                    [IntrNoMem, IntrHasSideEffects]>;
+
+// Armv8.7-A load/store 64-byte intrinsics
+defvar data512 = !listsplat(llvm_i64_ty, 8);
+def int_aarch64_ld64b: Intrinsic<data512, [llvm_ptr_ty]>;
+def int_aarch64_st64b: Intrinsic<[], !listconcat([llvm_ptr_ty], data512)>;
+def int_aarch64_st64bv: Intrinsic<[llvm_i64_ty], !listconcat([llvm_ptr_ty], data512)>;
+def int_aarch64_st64bv0: Intrinsic<[llvm_i64_ty], !listconcat([llvm_ptr_ty], data512)>;
+
+}
+
+def llvm_nxv2i1_ty  : LLVMType<nxv2i1>;
+def llvm_nxv4i1_ty  : LLVMType<nxv4i1>;
+def llvm_nxv8i1_ty  : LLVMType<nxv8i1>;
+def llvm_nxv16i1_ty : LLVMType<nxv16i1>;
+def llvm_nxv16i8_ty : LLVMType<nxv16i8>;
+def llvm_nxv4i32_ty : LLVMType<nxv4i32>;
+def llvm_nxv2i64_ty : LLVMType<nxv2i64>;
+def llvm_nxv8f16_ty : LLVMType<nxv8f16>;
+def llvm_nxv8bf16_ty : LLVMType<nxv8bf16>;
+def llvm_nxv4f32_ty : LLVMType<nxv4f32>;
+def llvm_nxv2f64_ty : LLVMType<nxv2f64>;
+
+let TargetPrefix = "aarch64" in {  // All intrinsics start with "llvm.aarch64.".
+
+  class AdvSIMD_SVE_Create_2Vector_Tuple
+    : Intrinsic<[llvm_anyvector_ty],
+                [llvm_anyvector_ty, LLVMMatchType<1>],
+                [IntrReadMem]>;
+
+  class AdvSIMD_SVE_Create_3Vector_Tuple
+    : Intrinsic<[llvm_anyvector_ty],
+                [llvm_anyvector_ty, LLVMMatchType<1>, LLVMMatchType<1>],
+                [IntrReadMem]>;
+
+  class AdvSIMD_SVE_Create_4Vector_Tuple
+    : Intrinsic<[llvm_anyvector_ty],
+                [llvm_anyvector_ty, LLVMMatchType<1>, LLVMMatchType<1>,
+                 LLVMMatchType<1>],
+                [IntrReadMem]>;
+
+  class AdvSIMD_SVE_Set_Vector_Tuple
+    : Intrinsic<[llvm_anyvector_ty],
+                [LLVMMatchType<0>, llvm_i32_ty, llvm_anyvector_ty],
+                [IntrReadMem, ImmArg<ArgIndex<1>>]>;
+
+  class AdvSIMD_SVE_Get_Vector_Tuple
+    : Intrinsic<[llvm_anyvector_ty], [llvm_anyvector_ty, llvm_i32_ty],
+                [IntrReadMem, IntrArgMemOnly, ImmArg<ArgIndex<1>>]>;
+
+  class AdvSIMD_ManyVec_PredLoad_Intrinsic
+    : Intrinsic<[llvm_anyvector_ty], [llvm_anyvector_ty, LLVMPointerToElt<0>],
+                [IntrReadMem, IntrArgMemOnly]>;
+
+  class AdvSIMD_1Vec_PredLoad_Intrinsic
+    : Intrinsic<[llvm_anyvector_ty],
+                [LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>,
+                 LLVMPointerToElt<0>],
+                [IntrReadMem, IntrArgMemOnly]>;
+
+  class AdvSIMD_1Vec_PredStore_Intrinsic
+    : Intrinsic<[],
+                [llvm_anyvector_ty,
+                 LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>,
+                 LLVMPointerToElt<0>],
+                [IntrArgMemOnly, NoCapture<ArgIndex<2>>]>;
+
+  class AdvSIMD_2Vec_PredStore_Intrinsic
+      : Intrinsic<[],
+                  [llvm_anyvector_ty, LLVMMatchType<0>,
+                   LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>, LLVMPointerToElt<0>],
+                  [IntrArgMemOnly, NoCapture<ArgIndex<3>>]>;
+
+  class AdvSIMD_3Vec_PredStore_Intrinsic
+      : Intrinsic<[],
+                  [llvm_anyvector_ty, LLVMMatchType<0>, LLVMMatchType<0>,
+                   LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>, LLVMPointerToElt<0>],
+                  [IntrArgMemOnly, NoCapture<ArgIndex<4>>]>;
+
+  class AdvSIMD_4Vec_PredStore_Intrinsic
+      : Intrinsic<[],
+                  [llvm_anyvector_ty, LLVMMatchType<0>, LLVMMatchType<0>,
+                   LLVMMatchType<0>,
+                   LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>, LLVMPointerToElt<0>],
+                  [IntrArgMemOnly, NoCapture<ArgIndex<5>>]>;
+
+  class AdvSIMD_SVE_Index_Intrinsic
+    : Intrinsic<[llvm_anyvector_ty],
+                [LLVMVectorElementType<0>,
+                 LLVMVectorElementType<0>],
+                [IntrNoMem]>;
+
+  class AdvSIMD_Merged1VectorArg_Intrinsic
+    : Intrinsic<[llvm_anyvector_ty],
+                [LLVMMatchType<0>,
+                 LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>,
+                 LLVMMatchType<0>],
+                [IntrNoMem]>;
+
+  class AdvSIMD_2VectorArgIndexed_Intrinsic
+    : Intrinsic<[llvm_anyvector_ty],
+                [LLVMMatchType<0>,
+                 LLVMMatchType<0>,
+                 llvm_i32_ty],
+                [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+  class AdvSIMD_3VectorArgIndexed_Intrinsic
+    : Intrinsic<[llvm_anyvector_ty],
+                [LLVMMatchType<0>,
+                 LLVMMatchType<0>,
+                 LLVMMatchType<0>,
+                 llvm_i32_ty],
+                [IntrNoMem, ImmArg<ArgIndex<3>>]>;
+
+  class AdvSIMD_Pred1VectorArg_Intrinsic
+    : Intrinsic<[llvm_anyvector_ty],
+                [LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>,
+                 LLVMMatchType<0>],
+                [IntrNoMem]>;
+
+  class AdvSIMD_Pred2VectorArg_Intrinsic
+    : Intrinsic<[llvm_anyvector_ty],
+                [LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>,
+                 LLVMMatchType<0>,
+                 LLVMMatchType<0>],
+                [IntrNoMem]>;
+
+  class AdvSIMD_Pred3VectorArg_Intrinsic
+    : Intrinsic<[llvm_anyvector_ty],
+                [LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>,
+                 LLVMMatchType<0>,
+                 LLVMMatchType<0>,
+                 LLVMMatchType<0>],
+                [IntrNoMem]>;
+
+  class AdvSIMD_SVE_Compare_Intrinsic
+    : Intrinsic<[LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>],
+                [LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>,
+                 llvm_anyvector_ty,
+                 LLVMMatchType<0>],
+                [IntrNoMem]>;
+
+  class AdvSIMD_SVE_CompareWide_Intrinsic
+    : Intrinsic<[LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>],
+                [LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>,
+                 llvm_anyvector_ty,
+                 llvm_nxv2i64_ty],
+                [IntrNoMem]>;
+
+  class AdvSIMD_SVE_Saturating_Intrinsic
+    : Intrinsic<[llvm_anyvector_ty],
+                [LLVMMatchType<0>,
+                 LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>],
+                [IntrNoMem]>;
+
+  class AdvSIMD_SVE_SaturatingWithPattern_Intrinsic
+    : Intrinsic<[llvm_anyvector_ty],
+                [LLVMMatchType<0>,
+                 llvm_i32_ty,
+                 llvm_i32_ty],
+                [IntrNoMem, ImmArg<ArgIndex<1>>, ImmArg<ArgIndex<2>>]>;
+
+  class AdvSIMD_SVE_Saturating_N_Intrinsic<LLVMType T>
+    : Intrinsic<[T],
+                [T, llvm_anyvector_ty],
+                [IntrNoMem]>;
+
+  class AdvSIMD_SVE_SaturatingWithPattern_N_Intrinsic<LLVMType T>
+    : Intrinsic<[T],
+                [T, llvm_i32_ty, llvm_i32_ty],
+                [IntrNoMem, ImmArg<ArgIndex<1>>, ImmArg<ArgIndex<2>>]>;
+
+  class AdvSIMD_SVE_CNT_Intrinsic
+    : Intrinsic<[LLVMVectorOfBitcastsToInt<0>],
+                [LLVMVectorOfBitcastsToInt<0>,
+                 LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>,
+                 llvm_anyvector_ty],
+                [IntrNoMem]>;
+
+  class AdvSIMD_SVE_ReduceWithInit_Intrinsic
+    : Intrinsic<[LLVMVectorElementType<0>],
+                [LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>,
+                 LLVMVectorElementType<0>,
+                 llvm_anyvector_ty],
+                [IntrNoMem]>;
+
+  class AdvSIMD_SVE_ShiftByImm_Intrinsic
+    : Intrinsic<[llvm_anyvector_ty],
+                [LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>,
+                 LLVMMatchType<0>,
+                 llvm_i32_ty],
+                [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+  class AdvSIMD_SVE_ShiftWide_Intrinsic
+    : Intrinsic<[llvm_anyvector_ty],
+                [LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>,
+                 LLVMMatchType<0>,
+                 llvm_nxv2i64_ty],
+                [IntrNoMem]>;
+
+  class AdvSIMD_SVE_Unpack_Intrinsic
+    : Intrinsic<[llvm_anyvector_ty],
+               [LLVMSubdivide2VectorType<0>],
+               [IntrNoMem]>;
+
+  class AdvSIMD_SVE_CADD_Intrinsic
+    : Intrinsic<[llvm_anyvector_ty],
+                [LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>,
+                 LLVMMatchType<0>,
+                 LLVMMatchType<0>,
+                 llvm_i32_ty],
+                [IntrNoMem, ImmArg<ArgIndex<3>>]>;
+
+  class AdvSIMD_SVE_CMLA_Intrinsic
+    : Intrinsic<[llvm_anyvector_ty],
+                [LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>,
+                 LLVMMatchType<0>,
+                 LLVMMatchType<0>,
+                 LLVMMatchType<0>,
+                 llvm_i32_ty],
+                [IntrNoMem, ImmArg<ArgIndex<4>>]>;
+
+  class AdvSIMD_SVE_CMLA_LANE_Intrinsic
+    : Intrinsic<[llvm_anyvector_ty],
+                [LLVMMatchType<0>,
+                 LLVMMatchType<0>,
+                 LLVMMatchType<0>,
+                 llvm_i32_ty,
+                 llvm_i32_ty],
+                [IntrNoMem, ImmArg<ArgIndex<3>>, ImmArg<ArgIndex<4>>]>;
+
+  class AdvSIMD_SVE_DUP_Intrinsic
+    : Intrinsic<[llvm_anyvector_ty],
+                [LLVMMatchType<0>,
+                 LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>,
+                 LLVMVectorElementType<0>],
+                [IntrNoMem]>;
+
+  class AdvSIMD_SVE_DUP_Unpred_Intrinsic
+    : Intrinsic<[llvm_anyvector_ty], [LLVMVectorElementType<0>],
+                [IntrNoMem]>;
+
+  class AdvSIMD_SVE_DUPQ_Intrinsic
+    : Intrinsic<[llvm_anyvector_ty],
+                [LLVMMatchType<0>,
+                 llvm_i64_ty],
+                [IntrNoMem]>;
+
+  class AdvSIMD_SVE_EXPA_Intrinsic
+    : Intrinsic<[llvm_anyvector_ty],
+                [LLVMVectorOfBitcastsToInt<0>],
+                [IntrNoMem]>;
+
+  class AdvSIMD_SVE_FCVT_Intrinsic
+    : Intrinsic<[llvm_anyvector_ty],
+                [LLVMMatchType<0>,
+                 LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>,
+                 llvm_anyvector_ty],
+                [IntrNoMem]>;
+
+  class AdvSIMD_SVE_FCVTZS_Intrinsic
+    : Intrinsic<[llvm_anyvector_ty],
+                [LLVMVectorOfBitcastsToInt<0>,
+                 LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>,
+                 llvm_anyvector_ty],
+                [IntrNoMem]>;
+
+  class AdvSIMD_SVE_INSR_Intrinsic
+    : Intrinsic<[llvm_anyvector_ty],
+                [LLVMMatchType<0>,
+                 LLVMVectorElementType<0>],
+                [IntrNoMem]>;
+
+  class AdvSIMD_SVE_PTRUE_Intrinsic
+    : Intrinsic<[llvm_anyvector_ty],
+                [llvm_i32_ty],
+                [IntrNoMem, ImmArg<ArgIndex<0>>]>;
+
+  class AdvSIMD_SVE_PUNPKHI_Intrinsic
+    : Intrinsic<[LLVMHalfElementsVectorType<0>],
+                [llvm_anyvector_ty],
+                [IntrNoMem]>;
+
+  class AdvSIMD_SVE_SCALE_Intrinsic
+    : Intrinsic<[llvm_anyvector_ty],
+                [LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>,
+                 LLVMMatchType<0>,
+                 LLVMVectorOfBitcastsToInt<0>],
+                [IntrNoMem]>;
+
+  class AdvSIMD_SVE_SCVTF_Intrinsic
+    : Intrinsic<[llvm_anyvector_ty],
+                [LLVMMatchType<0>,
+                 LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>,
+                 llvm_anyvector_ty],
+                [IntrNoMem]>;
+
+  class AdvSIMD_SVE_TSMUL_Intrinsic
+    : Intrinsic<[llvm_anyvector_ty],
+                [LLVMMatchType<0>,
+                 LLVMVectorOfBitcastsToInt<0>],
+                [IntrNoMem]>;
+
+  class AdvSIMD_SVE_CNTB_Intrinsic
+    : Intrinsic<[llvm_i64_ty],
+                [llvm_i32_ty],
+                [IntrNoMem, ImmArg<ArgIndex<0>>]>;
+
+  class AdvSIMD_SVE_CNTP_Intrinsic
+    : Intrinsic<[llvm_i64_ty],
+                [llvm_anyvector_ty, LLVMMatchType<0>],
+                [IntrNoMem]>;
+
+  class AdvSIMD_SVE_DOT_Intrinsic
+    : Intrinsic<[llvm_anyvector_ty],
+                [LLVMMatchType<0>,
+                 LLVMSubdivide4VectorType<0>,
+                 LLVMSubdivide4VectorType<0>],
+                [IntrNoMem]>;
+
+  class AdvSIMD_SVE_DOT_Indexed_Intrinsic
+    : Intrinsic<[llvm_anyvector_ty],
+                [LLVMMatchType<0>,
+                 LLVMSubdivide4VectorType<0>,
+                 LLVMSubdivide4VectorType<0>,
+                 llvm_i32_ty],
+                [IntrNoMem, ImmArg<ArgIndex<3>>]>;
+
+  class AdvSIMD_SVE_PTEST_Intrinsic
+    : Intrinsic<[llvm_i1_ty],
+                [llvm_anyvector_ty,
+                 LLVMMatchType<0>],
+                [IntrNoMem]>;
+
+  class AdvSIMD_SVE_TBL_Intrinsic
+    : Intrinsic<[llvm_anyvector_ty],
+                [LLVMMatchType<0>,
+                 LLVMVectorOfBitcastsToInt<0>],
+                [IntrNoMem]>;
+
+  class AdvSIMD_SVE2_TBX_Intrinsic
+    : Intrinsic<[llvm_anyvector_ty],
+                [LLVMMatchType<0>,
+                 LLVMMatchType<0>,
+                 LLVMVectorOfBitcastsToInt<0>],
+                [IntrNoMem]>;
+
+  class SVE2_1VectorArg_Long_Intrinsic
+    : Intrinsic<[llvm_anyvector_ty],
+                [LLVMSubdivide2VectorType<0>,
+                 llvm_i32_ty],
+                [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+  class SVE2_2VectorArg_Long_Intrinsic
+    : Intrinsic<[llvm_anyvector_ty],
+                [LLVMSubdivide2VectorType<0>,
+                 LLVMSubdivide2VectorType<0>],
+                [IntrNoMem]>;
+
+  class SVE2_2VectorArgIndexed_Long_Intrinsic
+  : Intrinsic<[llvm_anyvector_ty],
+              [LLVMSubdivide2VectorType<0>,
+               LLVMSubdivide2VectorType<0>,
+               llvm_i32_ty],
+              [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+  class SVE2_2VectorArg_Wide_Intrinsic
+    : Intrinsic<[llvm_anyvector_ty],
+                [LLVMMatchType<0>,
+                 LLVMSubdivide2VectorType<0>],
+                [IntrNoMem]>;
+
+  class SVE2_2VectorArg_Pred_Long_Intrinsic
+    : Intrinsic<[llvm_anyvector_ty],
+                [LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>,
+                 LLVMMatchType<0>,
+                 LLVMSubdivide2VectorType<0>],
+                [IntrNoMem]>;
+
+  class SVE2_3VectorArg_Long_Intrinsic
+    : Intrinsic<[llvm_anyvector_ty],
+                [LLVMMatchType<0>,
+                 LLVMSubdivide2VectorType<0>,
+                 LLVMSubdivide2VectorType<0>],
+                [IntrNoMem]>;
+
+  class SVE2_3VectorArgIndexed_Long_Intrinsic
+    : Intrinsic<[llvm_anyvector_ty],
+                [LLVMMatchType<0>,
+                 LLVMSubdivide2VectorType<0>,
+                 LLVMSubdivide2VectorType<0>,
+                 llvm_i32_ty],
+                [IntrNoMem, ImmArg<ArgIndex<3>>]>;
+
+  class SVE2_1VectorArg_Narrowing_Intrinsic
+    : Intrinsic<[LLVMSubdivide2VectorType<0>],
+                [llvm_anyvector_ty],
+                [IntrNoMem]>;
+
+  class SVE2_Merged1VectorArg_Narrowing_Intrinsic
+    : Intrinsic<[LLVMSubdivide2VectorType<0>],
+                [LLVMSubdivide2VectorType<0>,
+                 llvm_anyvector_ty],
+                [IntrNoMem]>;
+  class SVE2_2VectorArg_Narrowing_Intrinsic
+      : Intrinsic<
+            [LLVMSubdivide2VectorType<0>],
+            [llvm_anyvector_ty, LLVMMatchType<0>],
+            [IntrNoMem]>;
+
+  class SVE2_Merged2VectorArg_Narrowing_Intrinsic
+      : Intrinsic<
+            [LLVMSubdivide2VectorType<0>],
+            [LLVMSubdivide2VectorType<0>, llvm_anyvector_ty, LLVMMatchType<0>],
+            [IntrNoMem]>;
+
+  class SVE2_1VectorArg_Imm_Narrowing_Intrinsic
+      : Intrinsic<[LLVMSubdivide2VectorType<0>],
+                  [llvm_anyvector_ty, llvm_i32_ty],
+                  [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+  class SVE2_2VectorArg_Imm_Narrowing_Intrinsic
+      : Intrinsic<[LLVMSubdivide2VectorType<0>],
+                  [LLVMSubdivide2VectorType<0>, llvm_anyvector_ty,
+                   llvm_i32_ty],
+                  [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+  class SVE2_CONFLICT_DETECT_Intrinsic
+    : Intrinsic<[llvm_anyvector_ty],
+                [LLVMAnyPointerType<llvm_any_ty>,
+                 LLVMMatchType<1>]>;
+
+  class SVE2_3VectorArg_Indexed_Intrinsic
+    : Intrinsic<[llvm_anyvector_ty],
+                [LLVMMatchType<0>,
+                 LLVMSubdivide2VectorType<0>,
+                 LLVMSubdivide2VectorType<0>,
+                 llvm_i32_ty],
+                [IntrNoMem, ImmArg<ArgIndex<3>>]>;
+
+  class AdvSIMD_SVE_CDOT_LANE_Intrinsic
+    : Intrinsic<[llvm_anyvector_ty],
+                [LLVMMatchType<0>,
+                 LLVMSubdivide4VectorType<0>,
+                 LLVMSubdivide4VectorType<0>,
+                 llvm_i32_ty,
+                 llvm_i32_ty],
+                [IntrNoMem, ImmArg<ArgIndex<3>>, ImmArg<ArgIndex<4>>]>;
+
+  // NOTE: There is no relationship between these intrinsics beyond an attempt
+  // to reuse currently identical class definitions.
+  class AdvSIMD_SVE_LOGB_Intrinsic  : AdvSIMD_SVE_CNT_Intrinsic;
+  class AdvSIMD_SVE2_CADD_Intrinsic : AdvSIMD_2VectorArgIndexed_Intrinsic;
+  class AdvSIMD_SVE2_CMLA_Intrinsic : AdvSIMD_3VectorArgIndexed_Intrinsic;
+
+  // This class of intrinsics are not intended to be useful within LLVM IR but
+  // are instead here to support some of the more regid parts of the ACLE.
+  class Builtin_SVCVT<string name, LLVMType OUT, LLVMType PRED, LLVMType IN>
+      : Intrinsic<[OUT], [OUT, PRED, IN], [IntrNoMem]>;
+}
+
+//===----------------------------------------------------------------------===//
+// SVE
+
+let TargetPrefix = "aarch64" in {  // All intrinsics start with "llvm.aarch64.".
+
+class AdvSIMD_SVE_Reduce_Intrinsic
+  : Intrinsic<[LLVMVectorElementType<0>],
+              [LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>,
+               llvm_anyvector_ty],
+              [IntrNoMem]>;
+
+class AdvSIMD_SVE_SADDV_Reduce_Intrinsic
+  : Intrinsic<[llvm_i64_ty],
+              [LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>,
+               llvm_anyvector_ty],
+              [IntrNoMem]>;
+
+class AdvSIMD_SVE_WHILE_Intrinsic
+    : Intrinsic<[llvm_anyvector_ty],
+                [llvm_anyint_ty, LLVMMatchType<1>],
+                [IntrNoMem]>;
+
+class AdvSIMD_GatherLoad_SV_64b_Offsets_Intrinsic
+    : Intrinsic<[llvm_anyvector_ty],
+                [
+                  LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>,
+                  LLVMPointerToElt<0>,
+                  LLVMScalarOrSameVectorWidth<0, llvm_i64_ty>
+                ],
+                [IntrReadMem, IntrArgMemOnly]>;
+
+class AdvSIMD_GatherLoad_SV_32b_Offsets_Intrinsic
+    : Intrinsic<[llvm_anyvector_ty],
+                [
+                  LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>,
+                  LLVMPointerToElt<0>,
+                  LLVMScalarOrSameVectorWidth<0, llvm_i32_ty>
+                ],
+                [IntrReadMem, IntrArgMemOnly]>;
+
+class AdvSIMD_GatherLoad_VS_Intrinsic
+    : Intrinsic<[llvm_anyvector_ty],
+                [
+                  LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>,
+                  llvm_anyvector_ty,
+                  llvm_i64_ty
+                ],
+                [IntrReadMem]>;
+
+class AdvSIMD_ScatterStore_SV_64b_Offsets_Intrinsic
+    : Intrinsic<[],
+               [
+                 llvm_anyvector_ty,
+                 LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>,
+                 LLVMPointerToElt<0>,
+                 LLVMScalarOrSameVectorWidth<0, llvm_i64_ty>
+               ],
+               [IntrWriteMem, IntrArgMemOnly]>;
+
+class AdvSIMD_ScatterStore_SV_32b_Offsets_Intrinsic
+    : Intrinsic<[],
+               [
+                 llvm_anyvector_ty,
+                 LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>,
+                 LLVMPointerToElt<0>,
+                 LLVMScalarOrSameVectorWidth<0, llvm_i32_ty>
+               ],
+               [IntrWriteMem, IntrArgMemOnly]>;
+
+class AdvSIMD_ScatterStore_VS_Intrinsic
+    : Intrinsic<[],
+               [
+                 llvm_anyvector_ty,
+                 LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>,
+                 llvm_anyvector_ty, llvm_i64_ty
+               ],
+               [IntrWriteMem]>;
+
+
+class SVE_gather_prf_SV
+    : Intrinsic<[],
+                [
+                  LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>, // Predicate
+                  llvm_ptr_ty, // Base address
+                  llvm_anyvector_ty, // Offsets
+                  llvm_i32_ty // Prfop
+                ],
+                [IntrInaccessibleMemOrArgMemOnly, NoCapture<ArgIndex<1>>, ImmArg<ArgIndex<3>>]>;
+
+class SVE_gather_prf_VS
+    : Intrinsic<[],
+                [
+                  LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>, // Predicate
+                  llvm_anyvector_ty, // Base addresses
+                  llvm_i64_ty, // Scalar offset
+                  llvm_i32_ty // Prfop
+                ],
+                [IntrInaccessibleMemOrArgMemOnly, ImmArg<ArgIndex<3>>]>;
+
+class SVE_MatMul_Intrinsic
+    : Intrinsic<[llvm_anyvector_ty],
+                [LLVMMatchType<0>, LLVMSubdivide4VectorType<0>, LLVMSubdivide4VectorType<0>],
+                [IntrNoMem]>;
+
+class SVE_4Vec_BF16
+    : Intrinsic<[llvm_nxv4f32_ty],
+                [llvm_nxv4f32_ty, llvm_nxv8bf16_ty, llvm_nxv8bf16_ty],
+                [IntrNoMem]>;
+
+class SVE_4Vec_BF16_Indexed
+    : Intrinsic<[llvm_nxv4f32_ty],
+                [llvm_nxv4f32_ty, llvm_nxv8bf16_ty, llvm_nxv8bf16_ty, llvm_i64_ty],
+                [IntrNoMem, ImmArg<ArgIndex<3>>]>;
+
+//
+// Vector tuple creation intrinsics (ACLE)
+//
+
+def int_aarch64_sve_tuple_create2 : AdvSIMD_SVE_Create_2Vector_Tuple;
+def int_aarch64_sve_tuple_create3 : AdvSIMD_SVE_Create_3Vector_Tuple;
+def int_aarch64_sve_tuple_create4 : AdvSIMD_SVE_Create_4Vector_Tuple;
+
+//
+// Vector tuple insertion/extraction intrinsics (ACLE)
+//
+
+def int_aarch64_sve_tuple_get : AdvSIMD_SVE_Get_Vector_Tuple;
+def int_aarch64_sve_tuple_set : AdvSIMD_SVE_Set_Vector_Tuple;
+
+//
+// Loads
+//
+
+def int_aarch64_sve_ld1   : AdvSIMD_1Vec_PredLoad_Intrinsic;
+
+def int_aarch64_sve_ld2 : AdvSIMD_ManyVec_PredLoad_Intrinsic;
+def int_aarch64_sve_ld3 : AdvSIMD_ManyVec_PredLoad_Intrinsic;
+def int_aarch64_sve_ld4 : AdvSIMD_ManyVec_PredLoad_Intrinsic;
+
+def int_aarch64_sve_ldnt1 : AdvSIMD_1Vec_PredLoad_Intrinsic;
+def int_aarch64_sve_ldnf1 : AdvSIMD_1Vec_PredLoad_Intrinsic;
+def int_aarch64_sve_ldff1 : AdvSIMD_1Vec_PredLoad_Intrinsic;
+
+def int_aarch64_sve_ld1rq : AdvSIMD_1Vec_PredLoad_Intrinsic;
+def int_aarch64_sve_ld1ro : AdvSIMD_1Vec_PredLoad_Intrinsic;
+
+//
+// Stores
+//
+
+def int_aarch64_sve_st1  : AdvSIMD_1Vec_PredStore_Intrinsic;
+def int_aarch64_sve_st2  : AdvSIMD_2Vec_PredStore_Intrinsic;
+def int_aarch64_sve_st3  : AdvSIMD_3Vec_PredStore_Intrinsic;
+def int_aarch64_sve_st4  : AdvSIMD_4Vec_PredStore_Intrinsic;
+
+def int_aarch64_sve_stnt1 : AdvSIMD_1Vec_PredStore_Intrinsic;
+
+//
+// Prefetches
+//
+
+def int_aarch64_sve_prf
+  : Intrinsic<[], [llvm_anyvector_ty, llvm_ptr_ty, llvm_i32_ty],
+                  [IntrArgMemOnly, ImmArg<ArgIndex<2>>]>;
+
+// Scalar + 32-bit scaled offset vector, zero extend, packed and
+// unpacked.
+def int_aarch64_sve_prfb_gather_uxtw_index : SVE_gather_prf_SV;
+def int_aarch64_sve_prfh_gather_uxtw_index : SVE_gather_prf_SV;
+def int_aarch64_sve_prfw_gather_uxtw_index : SVE_gather_prf_SV;
+def int_aarch64_sve_prfd_gather_uxtw_index : SVE_gather_prf_SV;
+
+// Scalar + 32-bit scaled offset vector, sign extend, packed and
+// unpacked.
+def int_aarch64_sve_prfb_gather_sxtw_index : SVE_gather_prf_SV;
+def int_aarch64_sve_prfw_gather_sxtw_index : SVE_gather_prf_SV;
+def int_aarch64_sve_prfh_gather_sxtw_index : SVE_gather_prf_SV;
+def int_aarch64_sve_prfd_gather_sxtw_index : SVE_gather_prf_SV;
+
+// Scalar + 64-bit scaled offset vector.
+def int_aarch64_sve_prfb_gather_index : SVE_gather_prf_SV;
+def int_aarch64_sve_prfh_gather_index : SVE_gather_prf_SV;
+def int_aarch64_sve_prfw_gather_index : SVE_gather_prf_SV;
+def int_aarch64_sve_prfd_gather_index : SVE_gather_prf_SV;
+
+// Vector + scalar.
+def int_aarch64_sve_prfb_gather_scalar_offset : SVE_gather_prf_VS;
+def int_aarch64_sve_prfh_gather_scalar_offset : SVE_gather_prf_VS;
+def int_aarch64_sve_prfw_gather_scalar_offset : SVE_gather_prf_VS;
+def int_aarch64_sve_prfd_gather_scalar_offset : SVE_gather_prf_VS;
+
+//
+// Scalar to vector operations
+//
+
+def int_aarch64_sve_dup : AdvSIMD_SVE_DUP_Intrinsic;
+def int_aarch64_sve_dup_x : AdvSIMD_SVE_DUP_Unpred_Intrinsic;
+
+
+def int_aarch64_sve_index : AdvSIMD_SVE_Index_Intrinsic;
+
+//
+// Address calculation
+//
+
+def int_aarch64_sve_adrb : AdvSIMD_2VectorArg_Intrinsic;
+def int_aarch64_sve_adrh : AdvSIMD_2VectorArg_Intrinsic;
+def int_aarch64_sve_adrw : AdvSIMD_2VectorArg_Intrinsic;
+def int_aarch64_sve_adrd : AdvSIMD_2VectorArg_Intrinsic;
+
+//
+// Integer arithmetic
+//
+
+def int_aarch64_sve_add   : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_sub   : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_subr  : AdvSIMD_Pred2VectorArg_Intrinsic;
+
+def int_aarch64_sve_pmul       : AdvSIMD_2VectorArg_Intrinsic;
+
+def int_aarch64_sve_mul        : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_mul_lane   : AdvSIMD_2VectorArgIndexed_Intrinsic;
+def int_aarch64_sve_smulh      : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_umulh      : AdvSIMD_Pred2VectorArg_Intrinsic;
+
+def int_aarch64_sve_sdiv       : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_udiv       : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_sdivr      : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_udivr      : AdvSIMD_Pred2VectorArg_Intrinsic;
+
+def int_aarch64_sve_smax       : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_umax       : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_smin       : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_umin       : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_sabd       : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_uabd       : AdvSIMD_Pred2VectorArg_Intrinsic;
+
+def int_aarch64_sve_mad        : AdvSIMD_Pred3VectorArg_Intrinsic;
+def int_aarch64_sve_msb        : AdvSIMD_Pred3VectorArg_Intrinsic;
+def int_aarch64_sve_mla        : AdvSIMD_Pred3VectorArg_Intrinsic;
+def int_aarch64_sve_mla_lane   : AdvSIMD_3VectorArgIndexed_Intrinsic;
+def int_aarch64_sve_mls        : AdvSIMD_Pred3VectorArg_Intrinsic;
+def int_aarch64_sve_mls_lane   : AdvSIMD_3VectorArgIndexed_Intrinsic;
+
+def int_aarch64_sve_saddv      : AdvSIMD_SVE_SADDV_Reduce_Intrinsic;
+def int_aarch64_sve_uaddv      : AdvSIMD_SVE_SADDV_Reduce_Intrinsic;
+
+def int_aarch64_sve_smaxv      : AdvSIMD_SVE_Reduce_Intrinsic;
+def int_aarch64_sve_umaxv      : AdvSIMD_SVE_Reduce_Intrinsic;
+def int_aarch64_sve_sminv      : AdvSIMD_SVE_Reduce_Intrinsic;
+def int_aarch64_sve_uminv      : AdvSIMD_SVE_Reduce_Intrinsic;
+
+def int_aarch64_sve_orv        : AdvSIMD_SVE_Reduce_Intrinsic;
+def int_aarch64_sve_eorv       : AdvSIMD_SVE_Reduce_Intrinsic;
+def int_aarch64_sve_andv       : AdvSIMD_SVE_Reduce_Intrinsic;
+
+def int_aarch64_sve_abs : AdvSIMD_Merged1VectorArg_Intrinsic;
+def int_aarch64_sve_neg : AdvSIMD_Merged1VectorArg_Intrinsic;
+
+def int_aarch64_sve_sdot      : AdvSIMD_SVE_DOT_Intrinsic;
+def int_aarch64_sve_sdot_lane : AdvSIMD_SVE_DOT_Indexed_Intrinsic;
+
+def int_aarch64_sve_udot      : AdvSIMD_SVE_DOT_Intrinsic;
+def int_aarch64_sve_udot_lane : AdvSIMD_SVE_DOT_Indexed_Intrinsic;
+
+def int_aarch64_sve_sqadd_x   : AdvSIMD_2VectorArg_Intrinsic;
+def int_aarch64_sve_sqsub_x   : AdvSIMD_2VectorArg_Intrinsic;
+def int_aarch64_sve_uqadd_x   : AdvSIMD_2VectorArg_Intrinsic;
+def int_aarch64_sve_uqsub_x   : AdvSIMD_2VectorArg_Intrinsic;
+
+// Shifts
+
+def int_aarch64_sve_asr      : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_asr_wide : AdvSIMD_SVE_ShiftWide_Intrinsic;
+def int_aarch64_sve_asrd     : AdvSIMD_SVE_ShiftByImm_Intrinsic;
+def int_aarch64_sve_insr     : AdvSIMD_SVE_INSR_Intrinsic;
+def int_aarch64_sve_lsl      : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_lsl_wide : AdvSIMD_SVE_ShiftWide_Intrinsic;
+def int_aarch64_sve_lsr      : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_lsr_wide : AdvSIMD_SVE_ShiftWide_Intrinsic;
+
+//
+// Integer comparisons
+//
+
+def int_aarch64_sve_cmpeq : AdvSIMD_SVE_Compare_Intrinsic;
+def int_aarch64_sve_cmpge : AdvSIMD_SVE_Compare_Intrinsic;
+def int_aarch64_sve_cmpgt : AdvSIMD_SVE_Compare_Intrinsic;
+def int_aarch64_sve_cmphi : AdvSIMD_SVE_Compare_Intrinsic;
+def int_aarch64_sve_cmphs : AdvSIMD_SVE_Compare_Intrinsic;
+def int_aarch64_sve_cmpne : AdvSIMD_SVE_Compare_Intrinsic;
+
+def int_aarch64_sve_cmpeq_wide : AdvSIMD_SVE_CompareWide_Intrinsic;
+def int_aarch64_sve_cmpge_wide : AdvSIMD_SVE_CompareWide_Intrinsic;
+def int_aarch64_sve_cmpgt_wide : AdvSIMD_SVE_CompareWide_Intrinsic;
+def int_aarch64_sve_cmphi_wide : AdvSIMD_SVE_CompareWide_Intrinsic;
+def int_aarch64_sve_cmphs_wide : AdvSIMD_SVE_CompareWide_Intrinsic;
+def int_aarch64_sve_cmple_wide : AdvSIMD_SVE_CompareWide_Intrinsic;
+def int_aarch64_sve_cmplo_wide : AdvSIMD_SVE_CompareWide_Intrinsic;
+def int_aarch64_sve_cmpls_wide : AdvSIMD_SVE_CompareWide_Intrinsic;
+def int_aarch64_sve_cmplt_wide : AdvSIMD_SVE_CompareWide_Intrinsic;
+def int_aarch64_sve_cmpne_wide : AdvSIMD_SVE_CompareWide_Intrinsic;
+
+//
+// Counting bits
+//
+
+def int_aarch64_sve_cls : AdvSIMD_Merged1VectorArg_Intrinsic;
+def int_aarch64_sve_clz : AdvSIMD_Merged1VectorArg_Intrinsic;
+def int_aarch64_sve_cnt : AdvSIMD_SVE_CNT_Intrinsic;
+
+//
+// Counting elements
+//
+
+def int_aarch64_sve_cntb : AdvSIMD_SVE_CNTB_Intrinsic;
+def int_aarch64_sve_cnth : AdvSIMD_SVE_CNTB_Intrinsic;
+def int_aarch64_sve_cntw : AdvSIMD_SVE_CNTB_Intrinsic;
+def int_aarch64_sve_cntd : AdvSIMD_SVE_CNTB_Intrinsic;
+
+def int_aarch64_sve_cntp : AdvSIMD_SVE_CNTP_Intrinsic;
+
+//
+// FFR manipulation
+//
+
+def int_aarch64_sve_rdffr   : GCCBuiltin<"__builtin_sve_svrdffr">,   Intrinsic<[llvm_nxv16i1_ty], []>;
+def int_aarch64_sve_rdffr_z : GCCBuiltin<"__builtin_sve_svrdffr_z">, Intrinsic<[llvm_nxv16i1_ty], [llvm_nxv16i1_ty]>;
+def int_aarch64_sve_setffr  : GCCBuiltin<"__builtin_sve_svsetffr">,  Intrinsic<[], []>;
+def int_aarch64_sve_wrffr   : GCCBuiltin<"__builtin_sve_svwrffr">,   Intrinsic<[], [llvm_nxv16i1_ty]>;
+
+//
+// Saturating scalar arithmetic
+//
+
+def int_aarch64_sve_sqdech : AdvSIMD_SVE_SaturatingWithPattern_Intrinsic;
+def int_aarch64_sve_sqdecw : AdvSIMD_SVE_SaturatingWithPattern_Intrinsic;
+def int_aarch64_sve_sqdecd : AdvSIMD_SVE_SaturatingWithPattern_Intrinsic;
+def int_aarch64_sve_sqdecp : AdvSIMD_SVE_Saturating_Intrinsic;
+
+def int_aarch64_sve_sqdecb_n32 : AdvSIMD_SVE_SaturatingWithPattern_N_Intrinsic<llvm_i32_ty>;
+def int_aarch64_sve_sqdecb_n64 : AdvSIMD_SVE_SaturatingWithPattern_N_Intrinsic<llvm_i64_ty>;
+def int_aarch64_sve_sqdech_n32 : AdvSIMD_SVE_SaturatingWithPattern_N_Intrinsic<llvm_i32_ty>;
+def int_aarch64_sve_sqdech_n64 : AdvSIMD_SVE_SaturatingWithPattern_N_Intrinsic<llvm_i64_ty>;
+def int_aarch64_sve_sqdecw_n32 : AdvSIMD_SVE_SaturatingWithPattern_N_Intrinsic<llvm_i32_ty>;
+def int_aarch64_sve_sqdecw_n64 : AdvSIMD_SVE_SaturatingWithPattern_N_Intrinsic<llvm_i64_ty>;
+def int_aarch64_sve_sqdecd_n32 : AdvSIMD_SVE_SaturatingWithPattern_N_Intrinsic<llvm_i32_ty>;
+def int_aarch64_sve_sqdecd_n64 : AdvSIMD_SVE_SaturatingWithPattern_N_Intrinsic<llvm_i64_ty>;
+def int_aarch64_sve_sqdecp_n32 : AdvSIMD_SVE_Saturating_N_Intrinsic<llvm_i32_ty>;
+def int_aarch64_sve_sqdecp_n64 : AdvSIMD_SVE_Saturating_N_Intrinsic<llvm_i64_ty>;
+
+def int_aarch64_sve_sqinch : AdvSIMD_SVE_SaturatingWithPattern_Intrinsic;
+def int_aarch64_sve_sqincw : AdvSIMD_SVE_SaturatingWithPattern_Intrinsic;
+def int_aarch64_sve_sqincd : AdvSIMD_SVE_SaturatingWithPattern_Intrinsic;
+def int_aarch64_sve_sqincp : AdvSIMD_SVE_Saturating_Intrinsic;
+
+def int_aarch64_sve_sqincb_n32 : AdvSIMD_SVE_SaturatingWithPattern_N_Intrinsic<llvm_i32_ty>;
+def int_aarch64_sve_sqincb_n64 : AdvSIMD_SVE_SaturatingWithPattern_N_Intrinsic<llvm_i64_ty>;
+def int_aarch64_sve_sqinch_n32 : AdvSIMD_SVE_SaturatingWithPattern_N_Intrinsic<llvm_i32_ty>;
+def int_aarch64_sve_sqinch_n64 : AdvSIMD_SVE_SaturatingWithPattern_N_Intrinsic<llvm_i64_ty>;
+def int_aarch64_sve_sqincw_n32 : AdvSIMD_SVE_SaturatingWithPattern_N_Intrinsic<llvm_i32_ty>;
+def int_aarch64_sve_sqincw_n64 : AdvSIMD_SVE_SaturatingWithPattern_N_Intrinsic<llvm_i64_ty>;
+def int_aarch64_sve_sqincd_n32 : AdvSIMD_SVE_SaturatingWithPattern_N_Intrinsic<llvm_i32_ty>;
+def int_aarch64_sve_sqincd_n64 : AdvSIMD_SVE_SaturatingWithPattern_N_Intrinsic<llvm_i64_ty>;
+def int_aarch64_sve_sqincp_n32 : AdvSIMD_SVE_Saturating_N_Intrinsic<llvm_i32_ty>;
+def int_aarch64_sve_sqincp_n64 : AdvSIMD_SVE_Saturating_N_Intrinsic<llvm_i64_ty>;
+
+def int_aarch64_sve_uqdech : AdvSIMD_SVE_SaturatingWithPattern_Intrinsic;
+def int_aarch64_sve_uqdecw : AdvSIMD_SVE_SaturatingWithPattern_Intrinsic;
+def int_aarch64_sve_uqdecd : AdvSIMD_SVE_SaturatingWithPattern_Intrinsic;
+def int_aarch64_sve_uqdecp : AdvSIMD_SVE_Saturating_Intrinsic;
+
+def int_aarch64_sve_uqdecb_n32 : AdvSIMD_SVE_SaturatingWithPattern_N_Intrinsic<llvm_i32_ty>;
+def int_aarch64_sve_uqdecb_n64 : AdvSIMD_SVE_SaturatingWithPattern_N_Intrinsic<llvm_i64_ty>;
+def int_aarch64_sve_uqdech_n32 : AdvSIMD_SVE_SaturatingWithPattern_N_Intrinsic<llvm_i32_ty>;
+def int_aarch64_sve_uqdech_n64 : AdvSIMD_SVE_SaturatingWithPattern_N_Intrinsic<llvm_i64_ty>;
+def int_aarch64_sve_uqdecw_n32 : AdvSIMD_SVE_SaturatingWithPattern_N_Intrinsic<llvm_i32_ty>;
+def int_aarch64_sve_uqdecw_n64 : AdvSIMD_SVE_SaturatingWithPattern_N_Intrinsic<llvm_i64_ty>;
+def int_aarch64_sve_uqdecd_n32 : AdvSIMD_SVE_SaturatingWithPattern_N_Intrinsic<llvm_i32_ty>;
+def int_aarch64_sve_uqdecd_n64 : AdvSIMD_SVE_SaturatingWithPattern_N_Intrinsic<llvm_i64_ty>;
+def int_aarch64_sve_uqdecp_n32 : AdvSIMD_SVE_Saturating_N_Intrinsic<llvm_i32_ty>;
+def int_aarch64_sve_uqdecp_n64 : AdvSIMD_SVE_Saturating_N_Intrinsic<llvm_i64_ty>;
+
+def int_aarch64_sve_uqinch : AdvSIMD_SVE_SaturatingWithPattern_Intrinsic;
+def int_aarch64_sve_uqincw : AdvSIMD_SVE_SaturatingWithPattern_Intrinsic;
+def int_aarch64_sve_uqincd : AdvSIMD_SVE_SaturatingWithPattern_Intrinsic;
+def int_aarch64_sve_uqincp : AdvSIMD_SVE_Saturating_Intrinsic;
+
+def int_aarch64_sve_uqincb_n32 : AdvSIMD_SVE_SaturatingWithPattern_N_Intrinsic<llvm_i32_ty>;
+def int_aarch64_sve_uqincb_n64 : AdvSIMD_SVE_SaturatingWithPattern_N_Intrinsic<llvm_i64_ty>;
+def int_aarch64_sve_uqinch_n32 : AdvSIMD_SVE_SaturatingWithPattern_N_Intrinsic<llvm_i32_ty>;
+def int_aarch64_sve_uqinch_n64 : AdvSIMD_SVE_SaturatingWithPattern_N_Intrinsic<llvm_i64_ty>;
+def int_aarch64_sve_uqincw_n32 : AdvSIMD_SVE_SaturatingWithPattern_N_Intrinsic<llvm_i32_ty>;
+def int_aarch64_sve_uqincw_n64 : AdvSIMD_SVE_SaturatingWithPattern_N_Intrinsic<llvm_i64_ty>;
+def int_aarch64_sve_uqincd_n32 : AdvSIMD_SVE_SaturatingWithPattern_N_Intrinsic<llvm_i32_ty>;
+def int_aarch64_sve_uqincd_n64 : AdvSIMD_SVE_SaturatingWithPattern_N_Intrinsic<llvm_i64_ty>;
+def int_aarch64_sve_uqincp_n32 : AdvSIMD_SVE_Saturating_N_Intrinsic<llvm_i32_ty>;
+def int_aarch64_sve_uqincp_n64 : AdvSIMD_SVE_Saturating_N_Intrinsic<llvm_i64_ty>;
+
+//
+// Reversal
+//
+
+def int_aarch64_sve_rbit : AdvSIMD_Merged1VectorArg_Intrinsic;
+def int_aarch64_sve_revb : AdvSIMD_Merged1VectorArg_Intrinsic;
+def int_aarch64_sve_revh : AdvSIMD_Merged1VectorArg_Intrinsic;
+def int_aarch64_sve_revw : AdvSIMD_Merged1VectorArg_Intrinsic;
+
+//
+// Permutations and selection
+//
+
+def int_aarch64_sve_clasta    : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_clasta_n  : AdvSIMD_SVE_ReduceWithInit_Intrinsic;
+def int_aarch64_sve_clastb    : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_clastb_n  : AdvSIMD_SVE_ReduceWithInit_Intrinsic;
+def int_aarch64_sve_compact   : AdvSIMD_Pred1VectorArg_Intrinsic;
+def int_aarch64_sve_dupq_lane : AdvSIMD_SVE_DUPQ_Intrinsic;
+def int_aarch64_sve_ext       : AdvSIMD_2VectorArgIndexed_Intrinsic;
+def int_aarch64_sve_sel       : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_lasta     : AdvSIMD_SVE_Reduce_Intrinsic;
+def int_aarch64_sve_lastb     : AdvSIMD_SVE_Reduce_Intrinsic;
+def int_aarch64_sve_rev       : AdvSIMD_1VectorArg_Intrinsic;
+def int_aarch64_sve_splice    : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_sunpkhi   : AdvSIMD_SVE_Unpack_Intrinsic;
+def int_aarch64_sve_sunpklo   : AdvSIMD_SVE_Unpack_Intrinsic;
+def int_aarch64_sve_tbl       : AdvSIMD_SVE_TBL_Intrinsic;
+def int_aarch64_sve_trn1      : AdvSIMD_2VectorArg_Intrinsic;
+def int_aarch64_sve_trn2      : AdvSIMD_2VectorArg_Intrinsic;
+def int_aarch64_sve_trn1q     : AdvSIMD_2VectorArg_Intrinsic;
+def int_aarch64_sve_trn2q     : AdvSIMD_2VectorArg_Intrinsic;
+def int_aarch64_sve_uunpkhi   : AdvSIMD_SVE_Unpack_Intrinsic;
+def int_aarch64_sve_uunpklo   : AdvSIMD_SVE_Unpack_Intrinsic;
+def int_aarch64_sve_uzp1      : AdvSIMD_2VectorArg_Intrinsic;
+def int_aarch64_sve_uzp2      : AdvSIMD_2VectorArg_Intrinsic;
+def int_aarch64_sve_uzp1q     : AdvSIMD_2VectorArg_Intrinsic;
+def int_aarch64_sve_uzp2q     : AdvSIMD_2VectorArg_Intrinsic;
+def int_aarch64_sve_zip1      : AdvSIMD_2VectorArg_Intrinsic;
+def int_aarch64_sve_zip2      : AdvSIMD_2VectorArg_Intrinsic;
+def int_aarch64_sve_zip1q     : AdvSIMD_2VectorArg_Intrinsic;
+def int_aarch64_sve_zip2q     : AdvSIMD_2VectorArg_Intrinsic;
+
+//
+// Logical operations
+//
+
+def int_aarch64_sve_and  : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_bic  : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_cnot : AdvSIMD_Merged1VectorArg_Intrinsic;
+def int_aarch64_sve_eor  : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_not  : AdvSIMD_Merged1VectorArg_Intrinsic;
+def int_aarch64_sve_orr  : AdvSIMD_Pred2VectorArg_Intrinsic;
+
+//
+// Conversion
+//
+
+def int_aarch64_sve_sxtb : AdvSIMD_Merged1VectorArg_Intrinsic;
+def int_aarch64_sve_sxth : AdvSIMD_Merged1VectorArg_Intrinsic;
+def int_aarch64_sve_sxtw : AdvSIMD_Merged1VectorArg_Intrinsic;
+def int_aarch64_sve_uxtb : AdvSIMD_Merged1VectorArg_Intrinsic;
+def int_aarch64_sve_uxth : AdvSIMD_Merged1VectorArg_Intrinsic;
+def int_aarch64_sve_uxtw : AdvSIMD_Merged1VectorArg_Intrinsic;
+
+//
+// While comparisons
+//
+
+def int_aarch64_sve_whilele : AdvSIMD_SVE_WHILE_Intrinsic;
+def int_aarch64_sve_whilelo : AdvSIMD_SVE_WHILE_Intrinsic;
+def int_aarch64_sve_whilels : AdvSIMD_SVE_WHILE_Intrinsic;
+def int_aarch64_sve_whilelt : AdvSIMD_SVE_WHILE_Intrinsic;
+def int_aarch64_sve_whilege : AdvSIMD_SVE_WHILE_Intrinsic;
+def int_aarch64_sve_whilegt : AdvSIMD_SVE_WHILE_Intrinsic;
+def int_aarch64_sve_whilehs : AdvSIMD_SVE_WHILE_Intrinsic;
+def int_aarch64_sve_whilehi : AdvSIMD_SVE_WHILE_Intrinsic;
+
+//
+// Floating-point arithmetic
+//
+
+def int_aarch64_sve_fabd       : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_fabs       : AdvSIMD_Merged1VectorArg_Intrinsic;
+def int_aarch64_sve_fadd       : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_fcadd      : AdvSIMD_SVE_CADD_Intrinsic;
+def int_aarch64_sve_fcmla      : AdvSIMD_SVE_CMLA_Intrinsic;
+def int_aarch64_sve_fcmla_lane : AdvSIMD_SVE_CMLA_LANE_Intrinsic;
+def int_aarch64_sve_fdiv       : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_fdivr      : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_fexpa_x    : AdvSIMD_SVE_EXPA_Intrinsic;
+def int_aarch64_sve_fmad       : AdvSIMD_Pred3VectorArg_Intrinsic;
+def int_aarch64_sve_fmax       : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_fmaxnm     : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_fmin       : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_fminnm     : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_fmla       : AdvSIMD_Pred3VectorArg_Intrinsic;
+def int_aarch64_sve_fmla_lane  : AdvSIMD_3VectorArgIndexed_Intrinsic;
+def int_aarch64_sve_fmls       : AdvSIMD_Pred3VectorArg_Intrinsic;
+def int_aarch64_sve_fmls_lane  : AdvSIMD_3VectorArgIndexed_Intrinsic;
+def int_aarch64_sve_fmsb       : AdvSIMD_Pred3VectorArg_Intrinsic;
+def int_aarch64_sve_fmul       : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_fmulx      : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_fneg       : AdvSIMD_Merged1VectorArg_Intrinsic;
+def int_aarch64_sve_fmul_lane  : AdvSIMD_2VectorArgIndexed_Intrinsic;
+def int_aarch64_sve_fnmad      : AdvSIMD_Pred3VectorArg_Intrinsic;
+def int_aarch64_sve_fnmla      : AdvSIMD_Pred3VectorArg_Intrinsic;
+def int_aarch64_sve_fnmls      : AdvSIMD_Pred3VectorArg_Intrinsic;
+def int_aarch64_sve_fnmsb      : AdvSIMD_Pred3VectorArg_Intrinsic;
+def int_aarch64_sve_frecpe_x   : AdvSIMD_1VectorArg_Intrinsic;
+def int_aarch64_sve_frecps_x   : AdvSIMD_2VectorArg_Intrinsic;
+def int_aarch64_sve_frecpx     : AdvSIMD_Merged1VectorArg_Intrinsic;
+def int_aarch64_sve_frinta     : AdvSIMD_Merged1VectorArg_Intrinsic;
+def int_aarch64_sve_frinti     : AdvSIMD_Merged1VectorArg_Intrinsic;
+def int_aarch64_sve_frintm     : AdvSIMD_Merged1VectorArg_Intrinsic;
+def int_aarch64_sve_frintn     : AdvSIMD_Merged1VectorArg_Intrinsic;
+def int_aarch64_sve_frintp     : AdvSIMD_Merged1VectorArg_Intrinsic;
+def int_aarch64_sve_frintx     : AdvSIMD_Merged1VectorArg_Intrinsic;
+def int_aarch64_sve_frintz     : AdvSIMD_Merged1VectorArg_Intrinsic;
+def int_aarch64_sve_frsqrte_x  : AdvSIMD_1VectorArg_Intrinsic;
+def int_aarch64_sve_frsqrts_x  : AdvSIMD_2VectorArg_Intrinsic;
+def int_aarch64_sve_fscale     : AdvSIMD_SVE_SCALE_Intrinsic;
+def int_aarch64_sve_fsqrt      : AdvSIMD_Merged1VectorArg_Intrinsic;
+def int_aarch64_sve_fsub       : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_fsubr      : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_ftmad_x    : AdvSIMD_2VectorArgIndexed_Intrinsic;
+def int_aarch64_sve_ftsmul_x   : AdvSIMD_SVE_TSMUL_Intrinsic;
+def int_aarch64_sve_ftssel_x   : AdvSIMD_SVE_TSMUL_Intrinsic;
+
+//
+// Floating-point reductions
+//
+
+def int_aarch64_sve_fadda   : AdvSIMD_SVE_ReduceWithInit_Intrinsic;
+def int_aarch64_sve_faddv   : AdvSIMD_SVE_Reduce_Intrinsic;
+def int_aarch64_sve_fmaxv   : AdvSIMD_SVE_Reduce_Intrinsic;
+def int_aarch64_sve_fmaxnmv : AdvSIMD_SVE_Reduce_Intrinsic;
+def int_aarch64_sve_fminv   : AdvSIMD_SVE_Reduce_Intrinsic;
+def int_aarch64_sve_fminnmv : AdvSIMD_SVE_Reduce_Intrinsic;
+
+//
+// Floating-point conversions
+//
+
+def int_aarch64_sve_fcvt   : AdvSIMD_SVE_FCVT_Intrinsic;
+def int_aarch64_sve_fcvtzs : AdvSIMD_SVE_FCVTZS_Intrinsic;
+def int_aarch64_sve_fcvtzu : AdvSIMD_SVE_FCVTZS_Intrinsic;
+def int_aarch64_sve_scvtf  : AdvSIMD_SVE_SCVTF_Intrinsic;
+def int_aarch64_sve_ucvtf  : AdvSIMD_SVE_SCVTF_Intrinsic;
+
+//
+// Floating-point comparisons
+//
+
+def int_aarch64_sve_facge : AdvSIMD_SVE_Compare_Intrinsic;
+def int_aarch64_sve_facgt : AdvSIMD_SVE_Compare_Intrinsic;
+
+def int_aarch64_sve_fcmpeq : AdvSIMD_SVE_Compare_Intrinsic;
+def int_aarch64_sve_fcmpge : AdvSIMD_SVE_Compare_Intrinsic;
+def int_aarch64_sve_fcmpgt : AdvSIMD_SVE_Compare_Intrinsic;
+def int_aarch64_sve_fcmpne : AdvSIMD_SVE_Compare_Intrinsic;
+def int_aarch64_sve_fcmpuo : AdvSIMD_SVE_Compare_Intrinsic;
+
+def int_aarch64_sve_fcvtzs_i32f16   : Builtin_SVCVT<"svcvt_s32_f16_m", llvm_nxv4i32_ty, llvm_nxv4i1_ty, llvm_nxv8f16_ty>;
+def int_aarch64_sve_fcvtzs_i32f64   : Builtin_SVCVT<"svcvt_s32_f64_m", llvm_nxv4i32_ty, llvm_nxv2i1_ty, llvm_nxv2f64_ty>;
+def int_aarch64_sve_fcvtzs_i64f16   : Builtin_SVCVT<"svcvt_s64_f16_m", llvm_nxv2i64_ty, llvm_nxv2i1_ty, llvm_nxv8f16_ty>;
+def int_aarch64_sve_fcvtzs_i64f32   : Builtin_SVCVT<"svcvt_s64_f32_m", llvm_nxv2i64_ty, llvm_nxv2i1_ty, llvm_nxv4f32_ty>;
+
+def int_aarch64_sve_fcvt_bf16f32    : Builtin_SVCVT<"svcvt_bf16_f32_m",   llvm_nxv8bf16_ty, llvm_nxv8i1_ty, llvm_nxv4f32_ty>;
+def int_aarch64_sve_fcvtnt_bf16f32  : Builtin_SVCVT<"svcvtnt_bf16_f32_m", llvm_nxv8bf16_ty, llvm_nxv8i1_ty, llvm_nxv4f32_ty>;
+
+def int_aarch64_sve_fcvtzu_i32f16   : Builtin_SVCVT<"svcvt_u32_f16_m", llvm_nxv4i32_ty, llvm_nxv4i1_ty, llvm_nxv8f16_ty>;
+def int_aarch64_sve_fcvtzu_i32f64   : Builtin_SVCVT<"svcvt_u32_f64_m", llvm_nxv4i32_ty, llvm_nxv2i1_ty, llvm_nxv2f64_ty>;
+def int_aarch64_sve_fcvtzu_i64f16   : Builtin_SVCVT<"svcvt_u64_f16_m", llvm_nxv2i64_ty, llvm_nxv2i1_ty, llvm_nxv8f16_ty>;
+def int_aarch64_sve_fcvtzu_i64f32   : Builtin_SVCVT<"svcvt_u64_f32_m", llvm_nxv2i64_ty, llvm_nxv2i1_ty, llvm_nxv4f32_ty>;
+
+def int_aarch64_sve_fcvt_f16f32     : Builtin_SVCVT<"svcvt_f16_f32_m", llvm_nxv8f16_ty, llvm_nxv4i1_ty, llvm_nxv4f32_ty>;
+def int_aarch64_sve_fcvt_f16f64     : Builtin_SVCVT<"svcvt_f16_f64_m", llvm_nxv8f16_ty, llvm_nxv2i1_ty, llvm_nxv2f64_ty>;
+def int_aarch64_sve_fcvt_f32f64     : Builtin_SVCVT<"svcvt_f32_f64_m", llvm_nxv4f32_ty, llvm_nxv2i1_ty, llvm_nxv2f64_ty>;
+
+def int_aarch64_sve_fcvt_f32f16     : Builtin_SVCVT<"svcvt_f32_f16_m", llvm_nxv4f32_ty, llvm_nxv4i1_ty, llvm_nxv8f16_ty>;
+def int_aarch64_sve_fcvt_f64f16     : Builtin_SVCVT<"svcvt_f64_f16_m", llvm_nxv2f64_ty, llvm_nxv2i1_ty, llvm_nxv8f16_ty>;
+def int_aarch64_sve_fcvt_f64f32     : Builtin_SVCVT<"svcvt_f64_f32_m", llvm_nxv2f64_ty, llvm_nxv2i1_ty, llvm_nxv4f32_ty>;
+
+def int_aarch64_sve_fcvtlt_f32f16   : Builtin_SVCVT<"svcvtlt_f32_f16_m", llvm_nxv4f32_ty, llvm_nxv4i1_ty, llvm_nxv8f16_ty>;
+def int_aarch64_sve_fcvtlt_f64f32   : Builtin_SVCVT<"svcvtlt_f64_f32_m", llvm_nxv2f64_ty, llvm_nxv2i1_ty, llvm_nxv4f32_ty>;
+def int_aarch64_sve_fcvtnt_f16f32   : Builtin_SVCVT<"svcvtnt_f16_f32_m", llvm_nxv8f16_ty, llvm_nxv4i1_ty, llvm_nxv4f32_ty>;
+def int_aarch64_sve_fcvtnt_f32f64   : Builtin_SVCVT<"svcvtnt_f32_f64_m", llvm_nxv4f32_ty, llvm_nxv2i1_ty, llvm_nxv2f64_ty>;
+
+def int_aarch64_sve_fcvtx_f32f64    : Builtin_SVCVT<"svcvtx_f32_f64_m", llvm_nxv4f32_ty, llvm_nxv2i1_ty, llvm_nxv2f64_ty>;
+def int_aarch64_sve_fcvtxnt_f32f64  : Builtin_SVCVT<"svcvtxnt_f32_f64_m", llvm_nxv4f32_ty, llvm_nxv2i1_ty, llvm_nxv2f64_ty>;
+
+def int_aarch64_sve_scvtf_f16i32    : Builtin_SVCVT<"svcvt_f16_s32_m", llvm_nxv8f16_ty, llvm_nxv4i1_ty, llvm_nxv4i32_ty>;
+def int_aarch64_sve_scvtf_f16i64    : Builtin_SVCVT<"svcvt_f16_s64_m", llvm_nxv8f16_ty, llvm_nxv2i1_ty, llvm_nxv2i64_ty>;
+def int_aarch64_sve_scvtf_f32i64    : Builtin_SVCVT<"svcvt_f32_s64_m", llvm_nxv4f32_ty, llvm_nxv2i1_ty, llvm_nxv2i64_ty>;
+def int_aarch64_sve_scvtf_f64i32    : Builtin_SVCVT<"svcvt_f64_s32_m", llvm_nxv2f64_ty, llvm_nxv2i1_ty, llvm_nxv4i32_ty>;
+
+def int_aarch64_sve_ucvtf_f16i32    : Builtin_SVCVT<"svcvt_f16_u32_m", llvm_nxv8f16_ty, llvm_nxv4i1_ty, llvm_nxv4i32_ty>;
+def int_aarch64_sve_ucvtf_f16i64    : Builtin_SVCVT<"svcvt_f16_u64_m", llvm_nxv8f16_ty, llvm_nxv2i1_ty, llvm_nxv2i64_ty>;
+def int_aarch64_sve_ucvtf_f32i64    : Builtin_SVCVT<"svcvt_f32_u64_m", llvm_nxv4f32_ty, llvm_nxv2i1_ty, llvm_nxv2i64_ty>;
+def int_aarch64_sve_ucvtf_f64i32    : Builtin_SVCVT<"svcvt_f64_u32_m", llvm_nxv2f64_ty, llvm_nxv2i1_ty, llvm_nxv4i32_ty>;
+
+//
+// Predicate creation
+//
+
+def int_aarch64_sve_ptrue : AdvSIMD_SVE_PTRUE_Intrinsic;
+
+//
+// Predicate operations
+//
+
+def int_aarch64_sve_and_z   : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_bic_z   : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_brka    : AdvSIMD_Merged1VectorArg_Intrinsic;
+def int_aarch64_sve_brka_z  : AdvSIMD_Pred1VectorArg_Intrinsic;
+def int_aarch64_sve_brkb    : AdvSIMD_Merged1VectorArg_Intrinsic;
+def int_aarch64_sve_brkb_z  : AdvSIMD_Pred1VectorArg_Intrinsic;
+def int_aarch64_sve_brkn_z  : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_brkpa_z : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_brkpb_z : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_eor_z   : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_nand_z  : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_nor_z   : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_orn_z   : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_orr_z   : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_pfirst  : AdvSIMD_Pred1VectorArg_Intrinsic;
+def int_aarch64_sve_pnext   : AdvSIMD_Pred1VectorArg_Intrinsic;
+def int_aarch64_sve_punpkhi : AdvSIMD_SVE_PUNPKHI_Intrinsic;
+def int_aarch64_sve_punpklo : AdvSIMD_SVE_PUNPKHI_Intrinsic;
+
+//
+// Testing predicates
+//
+
+def int_aarch64_sve_ptest_any   : AdvSIMD_SVE_PTEST_Intrinsic;
+def int_aarch64_sve_ptest_first : AdvSIMD_SVE_PTEST_Intrinsic;
+def int_aarch64_sve_ptest_last  : AdvSIMD_SVE_PTEST_Intrinsic;
+
+//
+// Reinterpreting data
+//
+
+def int_aarch64_sve_convert_from_svbool : Intrinsic<[llvm_anyvector_ty],
+                                                    [llvm_nxv16i1_ty],
+                                                    [IntrNoMem]>;
+
+def int_aarch64_sve_convert_to_svbool : Intrinsic<[llvm_nxv16i1_ty],
+                                                  [llvm_anyvector_ty],
+                                                  [IntrNoMem]>;
+
+//
+// Gather loads: scalar base + vector offsets
+//
+
+// 64 bit unscaled offsets
+def int_aarch64_sve_ld1_gather : AdvSIMD_GatherLoad_SV_64b_Offsets_Intrinsic;
+
+// 64 bit scaled offsets
+def int_aarch64_sve_ld1_gather_index : AdvSIMD_GatherLoad_SV_64b_Offsets_Intrinsic;
+
+// 32 bit unscaled offsets, sign (sxtw) or zero (zxtw) extended to 64 bits
+def int_aarch64_sve_ld1_gather_sxtw : AdvSIMD_GatherLoad_SV_32b_Offsets_Intrinsic;
+def int_aarch64_sve_ld1_gather_uxtw : AdvSIMD_GatherLoad_SV_32b_Offsets_Intrinsic;
+
+// 32 bit scaled offsets, sign (sxtw) or zero (zxtw) extended to 64 bits
+def int_aarch64_sve_ld1_gather_sxtw_index : AdvSIMD_GatherLoad_SV_32b_Offsets_Intrinsic;
+def int_aarch64_sve_ld1_gather_uxtw_index : AdvSIMD_GatherLoad_SV_32b_Offsets_Intrinsic;
+
+//
+// Gather loads: vector base + scalar offset
+//
+
+def int_aarch64_sve_ld1_gather_scalar_offset : AdvSIMD_GatherLoad_VS_Intrinsic;
+
+
+//
+// First-faulting gather loads: scalar base + vector offsets
+//
+
+// 64 bit unscaled offsets
+def int_aarch64_sve_ldff1_gather : AdvSIMD_GatherLoad_SV_64b_Offsets_Intrinsic;
+
+// 64 bit scaled offsets
+def int_aarch64_sve_ldff1_gather_index : AdvSIMD_GatherLoad_SV_64b_Offsets_Intrinsic;
+
+// 32 bit unscaled offsets, sign (sxtw) or zero (uxtw) extended to 64 bits
+def int_aarch64_sve_ldff1_gather_sxtw : AdvSIMD_GatherLoad_SV_32b_Offsets_Intrinsic;
+def int_aarch64_sve_ldff1_gather_uxtw : AdvSIMD_GatherLoad_SV_32b_Offsets_Intrinsic;
+
+// 32 bit scaled offsets, sign (sxtw) or zero (uxtw) extended to 64 bits
+def int_aarch64_sve_ldff1_gather_sxtw_index : AdvSIMD_GatherLoad_SV_32b_Offsets_Intrinsic;
+def int_aarch64_sve_ldff1_gather_uxtw_index : AdvSIMD_GatherLoad_SV_32b_Offsets_Intrinsic;
+
+//
+// First-faulting gather loads: vector base + scalar offset
+//
+
+def int_aarch64_sve_ldff1_gather_scalar_offset : AdvSIMD_GatherLoad_VS_Intrinsic;
+
+
+//
+// Non-temporal gather loads: scalar base + vector offsets
+//
+
+// 64 bit unscaled offsets
+def int_aarch64_sve_ldnt1_gather : AdvSIMD_GatherLoad_SV_64b_Offsets_Intrinsic;
+
+// 64 bit indices
+def int_aarch64_sve_ldnt1_gather_index : AdvSIMD_GatherLoad_SV_64b_Offsets_Intrinsic;
+
+// 32 bit unscaled offsets, zero (zxtw) extended to 64 bits
+def int_aarch64_sve_ldnt1_gather_uxtw : AdvSIMD_GatherLoad_SV_32b_Offsets_Intrinsic;
+
+//
+// Non-temporal gather loads: vector base + scalar offset
+//
+
+def int_aarch64_sve_ldnt1_gather_scalar_offset  : AdvSIMD_GatherLoad_VS_Intrinsic;
+
+//
+// Scatter stores: scalar base + vector offsets
+//
+
+// 64 bit unscaled offsets
+def int_aarch64_sve_st1_scatter : AdvSIMD_ScatterStore_SV_64b_Offsets_Intrinsic;
+
+// 64 bit scaled offsets
+def int_aarch64_sve_st1_scatter_index
+    : AdvSIMD_ScatterStore_SV_64b_Offsets_Intrinsic;
+
+// 32 bit unscaled offsets, sign (sxtw) or zero (zxtw) extended to 64 bits
+def int_aarch64_sve_st1_scatter_sxtw
+    : AdvSIMD_ScatterStore_SV_32b_Offsets_Intrinsic;
+
+def int_aarch64_sve_st1_scatter_uxtw
+    : AdvSIMD_ScatterStore_SV_32b_Offsets_Intrinsic;
+
+// 32 bit scaled offsets, sign (sxtw) or zero (zxtw) extended to 64 bits
+def int_aarch64_sve_st1_scatter_sxtw_index
+    : AdvSIMD_ScatterStore_SV_32b_Offsets_Intrinsic;
+
+def int_aarch64_sve_st1_scatter_uxtw_index
+    : AdvSIMD_ScatterStore_SV_32b_Offsets_Intrinsic;
+
+//
+// Scatter stores: vector base + scalar offset
+//
+
+def int_aarch64_sve_st1_scatter_scalar_offset : AdvSIMD_ScatterStore_VS_Intrinsic;
+
+//
+// Non-temporal scatter stores: scalar base + vector offsets
+//
+
+// 64 bit unscaled offsets
+def int_aarch64_sve_stnt1_scatter : AdvSIMD_ScatterStore_SV_64b_Offsets_Intrinsic;
+
+// 64 bit indices
+def int_aarch64_sve_stnt1_scatter_index
+    : AdvSIMD_ScatterStore_SV_64b_Offsets_Intrinsic;
+
+// 32 bit unscaled offsets, zero (zxtw) extended to 64 bits
+def int_aarch64_sve_stnt1_scatter_uxtw : AdvSIMD_ScatterStore_SV_32b_Offsets_Intrinsic;
+
+//
+// Non-temporal scatter stores: vector base + scalar offset
+//
+
+def int_aarch64_sve_stnt1_scatter_scalar_offset  : AdvSIMD_ScatterStore_VS_Intrinsic;
+
+//
+// SVE2 - Uniform DSP operations
+//
+
+def int_aarch64_sve_saba          : AdvSIMD_3VectorArg_Intrinsic;
+def int_aarch64_sve_shadd         : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_shsub         : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_shsubr        : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_sli           : AdvSIMD_2VectorArgIndexed_Intrinsic;
+def int_aarch64_sve_sqabs         : AdvSIMD_Merged1VectorArg_Intrinsic;
+def int_aarch64_sve_sqadd         : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_sqdmulh       : AdvSIMD_2VectorArg_Intrinsic;
+def int_aarch64_sve_sqdmulh_lane  : AdvSIMD_2VectorArgIndexed_Intrinsic;
+def int_aarch64_sve_sqneg         : AdvSIMD_Merged1VectorArg_Intrinsic;
+def int_aarch64_sve_sqrdmlah      : AdvSIMD_3VectorArg_Intrinsic;
+def int_aarch64_sve_sqrdmlah_lane : AdvSIMD_3VectorArgIndexed_Intrinsic;
+def int_aarch64_sve_sqrdmlsh      : AdvSIMD_3VectorArg_Intrinsic;
+def int_aarch64_sve_sqrdmlsh_lane : AdvSIMD_3VectorArgIndexed_Intrinsic;
+def int_aarch64_sve_sqrdmulh      : AdvSIMD_2VectorArg_Intrinsic;
+def int_aarch64_sve_sqrdmulh_lane : AdvSIMD_2VectorArgIndexed_Intrinsic;
+def int_aarch64_sve_sqrshl        : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_sqshl         : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_sqshlu        : AdvSIMD_SVE_ShiftByImm_Intrinsic;
+def int_aarch64_sve_sqsub         : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_sqsubr        : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_srhadd        : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_sri           : AdvSIMD_2VectorArgIndexed_Intrinsic;
+def int_aarch64_sve_srshl         : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_srshr         : AdvSIMD_SVE_ShiftByImm_Intrinsic;
+def int_aarch64_sve_srsra         : AdvSIMD_2VectorArgIndexed_Intrinsic;
+def int_aarch64_sve_ssra          : AdvSIMD_2VectorArgIndexed_Intrinsic;
+def int_aarch64_sve_suqadd        : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_uaba          : AdvSIMD_3VectorArg_Intrinsic;
+def int_aarch64_sve_uhadd         : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_uhsub         : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_uhsubr        : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_uqadd         : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_uqrshl        : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_uqshl         : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_uqsub         : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_uqsubr        : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_urecpe        : AdvSIMD_Merged1VectorArg_Intrinsic;
+def int_aarch64_sve_urhadd        : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_urshl         : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_urshr         : AdvSIMD_SVE_ShiftByImm_Intrinsic;
+def int_aarch64_sve_ursqrte       : AdvSIMD_Merged1VectorArg_Intrinsic;
+def int_aarch64_sve_ursra         : AdvSIMD_2VectorArgIndexed_Intrinsic;
+def int_aarch64_sve_usqadd        : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_usra          : AdvSIMD_2VectorArgIndexed_Intrinsic;
+
+//
+// SVE2 - Widening DSP operations
+//
+
+def int_aarch64_sve_sabalb : SVE2_3VectorArg_Long_Intrinsic;
+def int_aarch64_sve_sabalt : SVE2_3VectorArg_Long_Intrinsic;
+def int_aarch64_sve_sabdlb : SVE2_2VectorArg_Long_Intrinsic;
+def int_aarch64_sve_sabdlt : SVE2_2VectorArg_Long_Intrinsic;
+def int_aarch64_sve_saddlb : SVE2_2VectorArg_Long_Intrinsic;
+def int_aarch64_sve_saddlt : SVE2_2VectorArg_Long_Intrinsic;
+def int_aarch64_sve_saddwb : SVE2_2VectorArg_Wide_Intrinsic;
+def int_aarch64_sve_saddwt : SVE2_2VectorArg_Wide_Intrinsic;
+def int_aarch64_sve_sshllb : SVE2_1VectorArg_Long_Intrinsic;
+def int_aarch64_sve_sshllt : SVE2_1VectorArg_Long_Intrinsic;
+def int_aarch64_sve_ssublb : SVE2_2VectorArg_Long_Intrinsic;
+def int_aarch64_sve_ssublt : SVE2_2VectorArg_Long_Intrinsic;
+def int_aarch64_sve_ssubwb : SVE2_2VectorArg_Wide_Intrinsic;
+def int_aarch64_sve_ssubwt : SVE2_2VectorArg_Wide_Intrinsic;
+def int_aarch64_sve_uabalb : SVE2_3VectorArg_Long_Intrinsic;
+def int_aarch64_sve_uabalt : SVE2_3VectorArg_Long_Intrinsic;
+def int_aarch64_sve_uabdlb : SVE2_2VectorArg_Long_Intrinsic;
+def int_aarch64_sve_uabdlt : SVE2_2VectorArg_Long_Intrinsic;
+def int_aarch64_sve_uaddlb : SVE2_2VectorArg_Long_Intrinsic;
+def int_aarch64_sve_uaddlt : SVE2_2VectorArg_Long_Intrinsic;
+def int_aarch64_sve_uaddwb : SVE2_2VectorArg_Wide_Intrinsic;
+def int_aarch64_sve_uaddwt : SVE2_2VectorArg_Wide_Intrinsic;
+def int_aarch64_sve_ushllb : SVE2_1VectorArg_Long_Intrinsic;
+def int_aarch64_sve_ushllt : SVE2_1VectorArg_Long_Intrinsic;
+def int_aarch64_sve_usublb : SVE2_2VectorArg_Long_Intrinsic;
+def int_aarch64_sve_usublt : SVE2_2VectorArg_Long_Intrinsic;
+def int_aarch64_sve_usubwb : SVE2_2VectorArg_Wide_Intrinsic;
+def int_aarch64_sve_usubwt : SVE2_2VectorArg_Wide_Intrinsic;
+
+//
+// SVE2 - Non-widening pairwise arithmetic
+//
+
+def int_aarch64_sve_addp    : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_faddp   : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_fmaxp   : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_fmaxnmp : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_fminp   : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_fminnmp : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_smaxp   : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_sminp   : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_umaxp   : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_uminp   : AdvSIMD_Pred2VectorArg_Intrinsic;
+
+//
+// SVE2 - Widening pairwise arithmetic
+//
+
+def int_aarch64_sve_sadalp : SVE2_2VectorArg_Pred_Long_Intrinsic;
+def int_aarch64_sve_uadalp : SVE2_2VectorArg_Pred_Long_Intrinsic;
+
+//
+// SVE2 - Uniform complex integer arithmetic
+//
+
+def int_aarch64_sve_cadd_x           : AdvSIMD_SVE2_CADD_Intrinsic;
+def int_aarch64_sve_sqcadd_x         : AdvSIMD_SVE2_CADD_Intrinsic;
+def int_aarch64_sve_cmla_x           : AdvSIMD_SVE2_CMLA_Intrinsic;
+def int_aarch64_sve_cmla_lane_x      : AdvSIMD_SVE_CMLA_LANE_Intrinsic;
+def int_aarch64_sve_sqrdcmlah_x      : AdvSIMD_SVE2_CMLA_Intrinsic;
+def int_aarch64_sve_sqrdcmlah_lane_x : AdvSIMD_SVE_CMLA_LANE_Intrinsic;
+
+//
+// SVE2 - Widening complex integer arithmetic
+//
+
+def int_aarch64_sve_saddlbt   : SVE2_2VectorArg_Long_Intrinsic;
+def int_aarch64_sve_ssublbt   : SVE2_2VectorArg_Long_Intrinsic;
+def int_aarch64_sve_ssubltb   : SVE2_2VectorArg_Long_Intrinsic;
+
+//
+// SVE2 - Widening complex integer dot product
+//
+
+def int_aarch64_sve_cdot      : AdvSIMD_SVE_DOT_Indexed_Intrinsic;
+def int_aarch64_sve_cdot_lane : AdvSIMD_SVE_CDOT_LANE_Intrinsic;
+
+//
+// SVE2 - Floating-point widening multiply-accumulate
+//
+
+def int_aarch64_sve_fmlalb        : SVE2_3VectorArg_Long_Intrinsic;
+def int_aarch64_sve_fmlalb_lane   : SVE2_3VectorArgIndexed_Long_Intrinsic;
+def int_aarch64_sve_fmlalt        : SVE2_3VectorArg_Long_Intrinsic;
+def int_aarch64_sve_fmlalt_lane   : SVE2_3VectorArgIndexed_Long_Intrinsic;
+def int_aarch64_sve_fmlslb        : SVE2_3VectorArg_Long_Intrinsic;
+def int_aarch64_sve_fmlslb_lane   : SVE2_3VectorArgIndexed_Long_Intrinsic;
+def int_aarch64_sve_fmlslt        : SVE2_3VectorArg_Long_Intrinsic;
+def int_aarch64_sve_fmlslt_lane   : SVE2_3VectorArgIndexed_Long_Intrinsic;
+
+//
+// SVE2 - Floating-point integer binary logarithm
+//
+
+def int_aarch64_sve_flogb : AdvSIMD_SVE_LOGB_Intrinsic;
+
+//
+// SVE2 - Vector histogram count
+//
+
+def int_aarch64_sve_histcnt : AdvSIMD_Pred2VectorArg_Intrinsic;
+def int_aarch64_sve_histseg : AdvSIMD_2VectorArg_Intrinsic;
+
+//
+// SVE2 - Character match
+//
+
+def int_aarch64_sve_match   : AdvSIMD_SVE_Compare_Intrinsic;
+def int_aarch64_sve_nmatch  : AdvSIMD_SVE_Compare_Intrinsic;
+
+//
+// SVE2 - Unary narrowing operations
+//
+
+def int_aarch64_sve_sqxtnb  : SVE2_1VectorArg_Narrowing_Intrinsic;
+def int_aarch64_sve_sqxtnt  : SVE2_Merged1VectorArg_Narrowing_Intrinsic;
+def int_aarch64_sve_sqxtunb : SVE2_1VectorArg_Narrowing_Intrinsic;
+def int_aarch64_sve_sqxtunt : SVE2_Merged1VectorArg_Narrowing_Intrinsic;
+def int_aarch64_sve_uqxtnb  : SVE2_1VectorArg_Narrowing_Intrinsic;
+def int_aarch64_sve_uqxtnt  : SVE2_Merged1VectorArg_Narrowing_Intrinsic;
+
+//
+// SVE2 - Binary narrowing DSP operations
+//
+def int_aarch64_sve_addhnb    : SVE2_2VectorArg_Narrowing_Intrinsic;
+def int_aarch64_sve_addhnt    : SVE2_Merged2VectorArg_Narrowing_Intrinsic;
+
+def int_aarch64_sve_raddhnb   : SVE2_2VectorArg_Narrowing_Intrinsic;
+def int_aarch64_sve_raddhnt   : SVE2_Merged2VectorArg_Narrowing_Intrinsic;
+
+def int_aarch64_sve_subhnb    : SVE2_2VectorArg_Narrowing_Intrinsic;
+def int_aarch64_sve_subhnt    : SVE2_Merged2VectorArg_Narrowing_Intrinsic;
+
+def int_aarch64_sve_rsubhnb   : SVE2_2VectorArg_Narrowing_Intrinsic;
+def int_aarch64_sve_rsubhnt   : SVE2_Merged2VectorArg_Narrowing_Intrinsic;
+
+// Narrowing shift right
+def int_aarch64_sve_shrnb     : SVE2_1VectorArg_Imm_Narrowing_Intrinsic;
+def int_aarch64_sve_shrnt     : SVE2_2VectorArg_Imm_Narrowing_Intrinsic;
+
+def int_aarch64_sve_rshrnb    : SVE2_1VectorArg_Imm_Narrowing_Intrinsic;
+def int_aarch64_sve_rshrnt    : SVE2_2VectorArg_Imm_Narrowing_Intrinsic;
+
+// Saturating shift right - signed input/output
+def int_aarch64_sve_sqshrnb   : SVE2_1VectorArg_Imm_Narrowing_Intrinsic;
+def int_aarch64_sve_sqshrnt   : SVE2_2VectorArg_Imm_Narrowing_Intrinsic;
+
+def int_aarch64_sve_sqrshrnb  : SVE2_1VectorArg_Imm_Narrowing_Intrinsic;
+def int_aarch64_sve_sqrshrnt  : SVE2_2VectorArg_Imm_Narrowing_Intrinsic;
+
+// Saturating shift right - unsigned input/output
+def int_aarch64_sve_uqshrnb   : SVE2_1VectorArg_Imm_Narrowing_Intrinsic;
+def int_aarch64_sve_uqshrnt   : SVE2_2VectorArg_Imm_Narrowing_Intrinsic;
+
+def int_aarch64_sve_uqrshrnb  : SVE2_1VectorArg_Imm_Narrowing_Intrinsic;
+def int_aarch64_sve_uqrshrnt  : SVE2_2VectorArg_Imm_Narrowing_Intrinsic;
+
+// Saturating shift right - signed input, unsigned output
+def int_aarch64_sve_sqshrunb  : SVE2_1VectorArg_Imm_Narrowing_Intrinsic;
+def int_aarch64_sve_sqshrunt  : SVE2_2VectorArg_Imm_Narrowing_Intrinsic;
+
+def int_aarch64_sve_sqrshrunb : SVE2_1VectorArg_Imm_Narrowing_Intrinsic;
+def int_aarch64_sve_sqrshrunt : SVE2_2VectorArg_Imm_Narrowing_Intrinsic;
+
+// SVE2 MLA LANE.
+def int_aarch64_sve_smlalb_lane   : SVE2_3VectorArg_Indexed_Intrinsic;
+def int_aarch64_sve_smlalt_lane   : SVE2_3VectorArg_Indexed_Intrinsic;
+def int_aarch64_sve_umlalb_lane   : SVE2_3VectorArg_Indexed_Intrinsic;
+def int_aarch64_sve_umlalt_lane   : SVE2_3VectorArg_Indexed_Intrinsic;
+def int_aarch64_sve_smlslb_lane   : SVE2_3VectorArg_Indexed_Intrinsic;
+def int_aarch64_sve_smlslt_lane   : SVE2_3VectorArg_Indexed_Intrinsic;
+def int_aarch64_sve_umlslb_lane   : SVE2_3VectorArg_Indexed_Intrinsic;
+def int_aarch64_sve_umlslt_lane   : SVE2_3VectorArg_Indexed_Intrinsic;
+def int_aarch64_sve_smullb_lane   : SVE2_2VectorArgIndexed_Long_Intrinsic;
+def int_aarch64_sve_smullt_lane   : SVE2_2VectorArgIndexed_Long_Intrinsic;
+def int_aarch64_sve_umullb_lane   : SVE2_2VectorArgIndexed_Long_Intrinsic;
+def int_aarch64_sve_umullt_lane   : SVE2_2VectorArgIndexed_Long_Intrinsic;
+def int_aarch64_sve_sqdmlalb_lane : SVE2_3VectorArg_Indexed_Intrinsic;
+def int_aarch64_sve_sqdmlalt_lane : SVE2_3VectorArg_Indexed_Intrinsic;
+def int_aarch64_sve_sqdmlslb_lane : SVE2_3VectorArg_Indexed_Intrinsic;
+def int_aarch64_sve_sqdmlslt_lane : SVE2_3VectorArg_Indexed_Intrinsic;
+def int_aarch64_sve_sqdmullb_lane : SVE2_2VectorArgIndexed_Long_Intrinsic;
+def int_aarch64_sve_sqdmullt_lane : SVE2_2VectorArgIndexed_Long_Intrinsic;
+
+// SVE2 MLA Unpredicated.
+def int_aarch64_sve_smlalb      : SVE2_3VectorArg_Long_Intrinsic;
+def int_aarch64_sve_smlalt      : SVE2_3VectorArg_Long_Intrinsic;
+def int_aarch64_sve_umlalb      : SVE2_3VectorArg_Long_Intrinsic;
+def int_aarch64_sve_umlalt      : SVE2_3VectorArg_Long_Intrinsic;
+def int_aarch64_sve_smlslb      : SVE2_3VectorArg_Long_Intrinsic;
+def int_aarch64_sve_smlslt      : SVE2_3VectorArg_Long_Intrinsic;
+def int_aarch64_sve_umlslb      : SVE2_3VectorArg_Long_Intrinsic;
+def int_aarch64_sve_umlslt      : SVE2_3VectorArg_Long_Intrinsic;
+def int_aarch64_sve_smullb      : SVE2_2VectorArg_Long_Intrinsic;
+def int_aarch64_sve_smullt      : SVE2_2VectorArg_Long_Intrinsic;
+def int_aarch64_sve_umullb      : SVE2_2VectorArg_Long_Intrinsic;
+def int_aarch64_sve_umullt      : SVE2_2VectorArg_Long_Intrinsic;
+
+def int_aarch64_sve_sqdmlalb    : SVE2_3VectorArg_Long_Intrinsic;
+def int_aarch64_sve_sqdmlalt    : SVE2_3VectorArg_Long_Intrinsic;
+def int_aarch64_sve_sqdmlslb    : SVE2_3VectorArg_Long_Intrinsic;
+def int_aarch64_sve_sqdmlslt    : SVE2_3VectorArg_Long_Intrinsic;
+def int_aarch64_sve_sqdmullb    : SVE2_2VectorArg_Long_Intrinsic;
+def int_aarch64_sve_sqdmullt    : SVE2_2VectorArg_Long_Intrinsic;
+def int_aarch64_sve_sqdmlalbt   : SVE2_3VectorArg_Long_Intrinsic;
+def int_aarch64_sve_sqdmlslbt   : SVE2_3VectorArg_Long_Intrinsic;
+
+// SVE2 ADDSUB Long Unpredicated.
+def int_aarch64_sve_adclb       : AdvSIMD_3VectorArg_Intrinsic;
+def int_aarch64_sve_adclt       : AdvSIMD_3VectorArg_Intrinsic;
+def int_aarch64_sve_sbclb       : AdvSIMD_3VectorArg_Intrinsic;
+def int_aarch64_sve_sbclt       : AdvSIMD_3VectorArg_Intrinsic;
+
+//
+// SVE2 - Polynomial arithmetic
+//
+def int_aarch64_sve_eorbt       : AdvSIMD_3VectorArg_Intrinsic;
+def int_aarch64_sve_eortb       : AdvSIMD_3VectorArg_Intrinsic;
+def int_aarch64_sve_pmullb_pair : AdvSIMD_2VectorArg_Intrinsic;
+def int_aarch64_sve_pmullt_pair : AdvSIMD_2VectorArg_Intrinsic;
+
+//
+// SVE2 bitwise ternary operations.
+//
+def int_aarch64_sve_eor3   : AdvSIMD_3VectorArg_Intrinsic;
+def int_aarch64_sve_bcax   : AdvSIMD_3VectorArg_Intrinsic;
+def int_aarch64_sve_bsl    : AdvSIMD_3VectorArg_Intrinsic;
+def int_aarch64_sve_bsl1n  : AdvSIMD_3VectorArg_Intrinsic;
+def int_aarch64_sve_bsl2n  : AdvSIMD_3VectorArg_Intrinsic;
+def int_aarch64_sve_nbsl   : AdvSIMD_3VectorArg_Intrinsic;
+def int_aarch64_sve_xar    : AdvSIMD_2VectorArgIndexed_Intrinsic;
+
+//
+// SVE2 - Optional AES, SHA-3 and SM4
+//
+
+def int_aarch64_sve_aesd    : GCCBuiltin<"__builtin_sve_svaesd_u8">,
+                              Intrinsic<[llvm_nxv16i8_ty],
+                                        [llvm_nxv16i8_ty, llvm_nxv16i8_ty],
+                                        [IntrNoMem]>;
+def int_aarch64_sve_aesimc  : GCCBuiltin<"__builtin_sve_svaesimc_u8">,
+                              Intrinsic<[llvm_nxv16i8_ty],
+                                        [llvm_nxv16i8_ty],
+                                        [IntrNoMem]>;
+def int_aarch64_sve_aese    : GCCBuiltin<"__builtin_sve_svaese_u8">,
+                              Intrinsic<[llvm_nxv16i8_ty],
+                                        [llvm_nxv16i8_ty, llvm_nxv16i8_ty],
+                                        [IntrNoMem]>;
+def int_aarch64_sve_aesmc   : GCCBuiltin<"__builtin_sve_svaesmc_u8">,
+                              Intrinsic<[llvm_nxv16i8_ty],
+                                        [llvm_nxv16i8_ty],
+                                        [IntrNoMem]>;
+def int_aarch64_sve_rax1    : GCCBuiltin<"__builtin_sve_svrax1_u64">,
+                              Intrinsic<[llvm_nxv2i64_ty],
+                                        [llvm_nxv2i64_ty, llvm_nxv2i64_ty],
+                                        [IntrNoMem]>;
+def int_aarch64_sve_sm4e    : GCCBuiltin<"__builtin_sve_svsm4e_u32">,
+                              Intrinsic<[llvm_nxv4i32_ty],
+                                        [llvm_nxv4i32_ty, llvm_nxv4i32_ty],
+                                        [IntrNoMem]>;
+def int_aarch64_sve_sm4ekey : GCCBuiltin<"__builtin_sve_svsm4ekey_u32">,
+                              Intrinsic<[llvm_nxv4i32_ty],
+                                        [llvm_nxv4i32_ty, llvm_nxv4i32_ty],
+                                        [IntrNoMem]>;
+//
+// SVE2 - Extended table lookup/permute
+//
+
+def int_aarch64_sve_tbl2 : AdvSIMD_SVE2_TBX_Intrinsic;
+def int_aarch64_sve_tbx  : AdvSIMD_SVE2_TBX_Intrinsic;
+
+//
+// SVE2 - Optional bit permutation
+//
+
+def int_aarch64_sve_bdep_x : AdvSIMD_2VectorArg_Intrinsic;
+def int_aarch64_sve_bext_x : AdvSIMD_2VectorArg_Intrinsic;
+def int_aarch64_sve_bgrp_x : AdvSIMD_2VectorArg_Intrinsic;
+
+
+//
+// SVE ACLE: 7.3. INT8 matrix multiply extensions
+//
+def int_aarch64_sve_ummla : SVE_MatMul_Intrinsic;
+def int_aarch64_sve_smmla : SVE_MatMul_Intrinsic;
+def int_aarch64_sve_usmmla : SVE_MatMul_Intrinsic;
+
+def int_aarch64_sve_usdot : AdvSIMD_SVE_DOT_Intrinsic;
+def int_aarch64_sve_usdot_lane : AdvSIMD_SVE_DOT_Indexed_Intrinsic;
+def int_aarch64_sve_sudot_lane : AdvSIMD_SVE_DOT_Indexed_Intrinsic;
+
+//
+// SVE ACLE: 7.4/5. FP64/FP32 matrix multiply extensions
+//
+def int_aarch64_sve_fmmla : AdvSIMD_3VectorArg_Intrinsic;
+
+//
+// SVE ACLE: 7.2. BFloat16 extensions
+//
+
+def int_aarch64_sve_bfdot   : SVE_4Vec_BF16;
+def int_aarch64_sve_bfmlalb : SVE_4Vec_BF16;
+def int_aarch64_sve_bfmlalt : SVE_4Vec_BF16;
+
+def int_aarch64_sve_bfmmla  : SVE_4Vec_BF16;
+
+def int_aarch64_sve_bfdot_lane   : SVE_4Vec_BF16_Indexed;
+def int_aarch64_sve_bfmlalb_lane : SVE_4Vec_BF16_Indexed;
+def int_aarch64_sve_bfmlalt_lane : SVE_4Vec_BF16_Indexed;
+}
+
+//
+// SVE2 - Contiguous conflict detection
+//
+
+def int_aarch64_sve_whilerw_b : SVE2_CONFLICT_DETECT_Intrinsic;
+def int_aarch64_sve_whilerw_h : SVE2_CONFLICT_DETECT_Intrinsic;
+def int_aarch64_sve_whilerw_s : SVE2_CONFLICT_DETECT_Intrinsic;
+def int_aarch64_sve_whilerw_d : SVE2_CONFLICT_DETECT_Intrinsic;
+def int_aarch64_sve_whilewr_b : SVE2_CONFLICT_DETECT_Intrinsic;
+def int_aarch64_sve_whilewr_h : SVE2_CONFLICT_DETECT_Intrinsic;
+def int_aarch64_sve_whilewr_s : SVE2_CONFLICT_DETECT_Intrinsic;
+def int_aarch64_sve_whilewr_d : SVE2_CONFLICT_DETECT_Intrinsic;
diff --git a/linux-x64/clang/include/llvm/IR/IntrinsicsAMDGPU.h b/linux-x64/clang/include/llvm/IR/IntrinsicsAMDGPU.h
new file mode 100644
index 0000000..0f1b2d9
--- /dev/null
+++ b/linux-x64/clang/include/llvm/IR/IntrinsicsAMDGPU.h
@@ -0,0 +1,716 @@
+/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
+|*                                                                            *|
+|* Intrinsic Function Source Fragment                                         *|
+|*                                                                            *|
+|* Automatically generated file, do not edit!                                 *|
+|*                                                                            *|
+\*===----------------------------------------------------------------------===*/
+
+#ifndef LLVM_IR_INTRINSIC_AMDGCN_ENUMS_H
+#define LLVM_IR_INTRINSIC_AMDGCN_ENUMS_H
+
+namespace llvm {
+namespace Intrinsic {
+enum AMDGCNIntrinsics : unsigned {
+// Enum values for intrinsics
+    amdgcn_alignbit = 1160,                           // llvm.amdgcn.alignbit
+    amdgcn_alignbyte,                          // llvm.amdgcn.alignbyte
+    amdgcn_atomic_dec,                         // llvm.amdgcn.atomic.dec
+    amdgcn_atomic_inc,                         // llvm.amdgcn.atomic.inc
+    amdgcn_ballot,                             // llvm.amdgcn.ballot
+    amdgcn_buffer_atomic_add,                  // llvm.amdgcn.buffer.atomic.add
+    amdgcn_buffer_atomic_and,                  // llvm.amdgcn.buffer.atomic.and
+    amdgcn_buffer_atomic_cmpswap,              // llvm.amdgcn.buffer.atomic.cmpswap
+    amdgcn_buffer_atomic_csub,                 // llvm.amdgcn.buffer.atomic.csub
+    amdgcn_buffer_atomic_fadd,                 // llvm.amdgcn.buffer.atomic.fadd
+    amdgcn_buffer_atomic_or,                   // llvm.amdgcn.buffer.atomic.or
+    amdgcn_buffer_atomic_smax,                 // llvm.amdgcn.buffer.atomic.smax
+    amdgcn_buffer_atomic_smin,                 // llvm.amdgcn.buffer.atomic.smin
+    amdgcn_buffer_atomic_sub,                  // llvm.amdgcn.buffer.atomic.sub
+    amdgcn_buffer_atomic_swap,                 // llvm.amdgcn.buffer.atomic.swap
+    amdgcn_buffer_atomic_umax,                 // llvm.amdgcn.buffer.atomic.umax
+    amdgcn_buffer_atomic_umin,                 // llvm.amdgcn.buffer.atomic.umin
+    amdgcn_buffer_atomic_xor,                  // llvm.amdgcn.buffer.atomic.xor
+    amdgcn_buffer_load,                        // llvm.amdgcn.buffer.load
+    amdgcn_buffer_load_format,                 // llvm.amdgcn.buffer.load.format
+    amdgcn_buffer_store,                       // llvm.amdgcn.buffer.store
+    amdgcn_buffer_store_format,                // llvm.amdgcn.buffer.store.format
+    amdgcn_buffer_wbinvl1,                     // llvm.amdgcn.buffer.wbinvl1
+    amdgcn_buffer_wbinvl1_sc,                  // llvm.amdgcn.buffer.wbinvl1.sc
+    amdgcn_buffer_wbinvl1_vol,                 // llvm.amdgcn.buffer.wbinvl1.vol
+    amdgcn_class,                              // llvm.amdgcn.class
+    amdgcn_cos,                                // llvm.amdgcn.cos
+    amdgcn_cubeid,                             // llvm.amdgcn.cubeid
+    amdgcn_cubema,                             // llvm.amdgcn.cubema
+    amdgcn_cubesc,                             // llvm.amdgcn.cubesc
+    amdgcn_cubetc,                             // llvm.amdgcn.cubetc
+    amdgcn_cvt_pk_i16,                         // llvm.amdgcn.cvt.pk.i16
+    amdgcn_cvt_pk_u16,                         // llvm.amdgcn.cvt.pk.u16
+    amdgcn_cvt_pk_u8_f32,                      // llvm.amdgcn.cvt.pk.u8.f32
+    amdgcn_cvt_pknorm_i16,                     // llvm.amdgcn.cvt.pknorm.i16
+    amdgcn_cvt_pknorm_u16,                     // llvm.amdgcn.cvt.pknorm.u16
+    amdgcn_cvt_pkrtz,                          // llvm.amdgcn.cvt.pkrtz
+    amdgcn_dispatch_id,                        // llvm.amdgcn.dispatch.id
+    amdgcn_dispatch_ptr,                       // llvm.amdgcn.dispatch.ptr
+    amdgcn_div_fixup,                          // llvm.amdgcn.div.fixup
+    amdgcn_div_fmas,                           // llvm.amdgcn.div.fmas
+    amdgcn_div_scale,                          // llvm.amdgcn.div.scale
+    amdgcn_ds_append,                          // llvm.amdgcn.ds.append
+    amdgcn_ds_bpermute,                        // llvm.amdgcn.ds.bpermute
+    amdgcn_ds_consume,                         // llvm.amdgcn.ds.consume
+    amdgcn_ds_fadd,                            // llvm.amdgcn.ds.fadd
+    amdgcn_ds_fmax,                            // llvm.amdgcn.ds.fmax
+    amdgcn_ds_fmin,                            // llvm.amdgcn.ds.fmin
+    amdgcn_ds_gws_barrier,                     // llvm.amdgcn.ds.gws.barrier
+    amdgcn_ds_gws_init,                        // llvm.amdgcn.ds.gws.init
+    amdgcn_ds_gws_sema_br,                     // llvm.amdgcn.ds.gws.sema.br
+    amdgcn_ds_gws_sema_p,                      // llvm.amdgcn.ds.gws.sema.p
+    amdgcn_ds_gws_sema_release_all,            // llvm.amdgcn.ds.gws.sema.release.all
+    amdgcn_ds_gws_sema_v,                      // llvm.amdgcn.ds.gws.sema.v
+    amdgcn_ds_ordered_add,                     // llvm.amdgcn.ds.ordered.add
+    amdgcn_ds_ordered_swap,                    // llvm.amdgcn.ds.ordered.swap
+    amdgcn_ds_permute,                         // llvm.amdgcn.ds.permute
+    amdgcn_ds_swizzle,                         // llvm.amdgcn.ds.swizzle
+    amdgcn_else,                               // llvm.amdgcn.else
+    amdgcn_end_cf,                             // llvm.amdgcn.end.cf
+    amdgcn_endpgm,                             // llvm.amdgcn.endpgm
+    amdgcn_exp,                                // llvm.amdgcn.exp
+    amdgcn_exp_compr,                          // llvm.amdgcn.exp.compr
+    amdgcn_fcmp,                               // llvm.amdgcn.fcmp
+    amdgcn_fdiv_fast,                          // llvm.amdgcn.fdiv.fast
+    amdgcn_fdot2,                              // llvm.amdgcn.fdot2
+    amdgcn_fma_legacy,                         // llvm.amdgcn.fma.legacy
+    amdgcn_fmad_ftz,                           // llvm.amdgcn.fmad.ftz
+    amdgcn_fmed3,                              // llvm.amdgcn.fmed3
+    amdgcn_fmul_legacy,                        // llvm.amdgcn.fmul.legacy
+    amdgcn_fract,                              // llvm.amdgcn.fract
+    amdgcn_frexp_exp,                          // llvm.amdgcn.frexp.exp
+    amdgcn_frexp_mant,                         // llvm.amdgcn.frexp.mant
+    amdgcn_global_atomic_csub,                 // llvm.amdgcn.global.atomic.csub
+    amdgcn_global_atomic_fadd,                 // llvm.amdgcn.global.atomic.fadd
+    amdgcn_groupstaticsize,                    // llvm.amdgcn.groupstaticsize
+    amdgcn_icmp,                               // llvm.amdgcn.icmp
+    amdgcn_if,                                 // llvm.amdgcn.if
+    amdgcn_if_break,                           // llvm.amdgcn.if.break
+    amdgcn_image_atomic_add_1d,                // llvm.amdgcn.image.atomic.add.1d
+    amdgcn_image_atomic_add_1darray,           // llvm.amdgcn.image.atomic.add.1darray
+    amdgcn_image_atomic_add_2d,                // llvm.amdgcn.image.atomic.add.2d
+    amdgcn_image_atomic_add_2darray,           // llvm.amdgcn.image.atomic.add.2darray
+    amdgcn_image_atomic_add_2darraymsaa,       // llvm.amdgcn.image.atomic.add.2darraymsaa
+    amdgcn_image_atomic_add_2dmsaa,            // llvm.amdgcn.image.atomic.add.2dmsaa
+    amdgcn_image_atomic_add_3d,                // llvm.amdgcn.image.atomic.add.3d
+    amdgcn_image_atomic_add_cube,              // llvm.amdgcn.image.atomic.add.cube
+    amdgcn_image_atomic_and_1d,                // llvm.amdgcn.image.atomic.and.1d
+    amdgcn_image_atomic_and_1darray,           // llvm.amdgcn.image.atomic.and.1darray
+    amdgcn_image_atomic_and_2d,                // llvm.amdgcn.image.atomic.and.2d
+    amdgcn_image_atomic_and_2darray,           // llvm.amdgcn.image.atomic.and.2darray
+    amdgcn_image_atomic_and_2darraymsaa,       // llvm.amdgcn.image.atomic.and.2darraymsaa
+    amdgcn_image_atomic_and_2dmsaa,            // llvm.amdgcn.image.atomic.and.2dmsaa
+    amdgcn_image_atomic_and_3d,                // llvm.amdgcn.image.atomic.and.3d
+    amdgcn_image_atomic_and_cube,              // llvm.amdgcn.image.atomic.and.cube
+    amdgcn_image_atomic_cmpswap_1d,            // llvm.amdgcn.image.atomic.cmpswap.1d
+    amdgcn_image_atomic_cmpswap_1darray,       // llvm.amdgcn.image.atomic.cmpswap.1darray
+    amdgcn_image_atomic_cmpswap_2d,            // llvm.amdgcn.image.atomic.cmpswap.2d
+    amdgcn_image_atomic_cmpswap_2darray,       // llvm.amdgcn.image.atomic.cmpswap.2darray
+    amdgcn_image_atomic_cmpswap_2darraymsaa,   // llvm.amdgcn.image.atomic.cmpswap.2darraymsaa
+    amdgcn_image_atomic_cmpswap_2dmsaa,        // llvm.amdgcn.image.atomic.cmpswap.2dmsaa
+    amdgcn_image_atomic_cmpswap_3d,            // llvm.amdgcn.image.atomic.cmpswap.3d
+    amdgcn_image_atomic_cmpswap_cube,          // llvm.amdgcn.image.atomic.cmpswap.cube
+    amdgcn_image_atomic_dec_1d,                // llvm.amdgcn.image.atomic.dec.1d
+    amdgcn_image_atomic_dec_1darray,           // llvm.amdgcn.image.atomic.dec.1darray
+    amdgcn_image_atomic_dec_2d,                // llvm.amdgcn.image.atomic.dec.2d
+    amdgcn_image_atomic_dec_2darray,           // llvm.amdgcn.image.atomic.dec.2darray
+    amdgcn_image_atomic_dec_2darraymsaa,       // llvm.amdgcn.image.atomic.dec.2darraymsaa
+    amdgcn_image_atomic_dec_2dmsaa,            // llvm.amdgcn.image.atomic.dec.2dmsaa
+    amdgcn_image_atomic_dec_3d,                // llvm.amdgcn.image.atomic.dec.3d
+    amdgcn_image_atomic_dec_cube,              // llvm.amdgcn.image.atomic.dec.cube
+    amdgcn_image_atomic_inc_1d,                // llvm.amdgcn.image.atomic.inc.1d
+    amdgcn_image_atomic_inc_1darray,           // llvm.amdgcn.image.atomic.inc.1darray
+    amdgcn_image_atomic_inc_2d,                // llvm.amdgcn.image.atomic.inc.2d
+    amdgcn_image_atomic_inc_2darray,           // llvm.amdgcn.image.atomic.inc.2darray
+    amdgcn_image_atomic_inc_2darraymsaa,       // llvm.amdgcn.image.atomic.inc.2darraymsaa
+    amdgcn_image_atomic_inc_2dmsaa,            // llvm.amdgcn.image.atomic.inc.2dmsaa
+    amdgcn_image_atomic_inc_3d,                // llvm.amdgcn.image.atomic.inc.3d
+    amdgcn_image_atomic_inc_cube,              // llvm.amdgcn.image.atomic.inc.cube
+    amdgcn_image_atomic_or_1d,                 // llvm.amdgcn.image.atomic.or.1d
+    amdgcn_image_atomic_or_1darray,            // llvm.amdgcn.image.atomic.or.1darray
+    amdgcn_image_atomic_or_2d,                 // llvm.amdgcn.image.atomic.or.2d
+    amdgcn_image_atomic_or_2darray,            // llvm.amdgcn.image.atomic.or.2darray
+    amdgcn_image_atomic_or_2darraymsaa,        // llvm.amdgcn.image.atomic.or.2darraymsaa
+    amdgcn_image_atomic_or_2dmsaa,             // llvm.amdgcn.image.atomic.or.2dmsaa
+    amdgcn_image_atomic_or_3d,                 // llvm.amdgcn.image.atomic.or.3d
+    amdgcn_image_atomic_or_cube,               // llvm.amdgcn.image.atomic.or.cube
+    amdgcn_image_atomic_smax_1d,               // llvm.amdgcn.image.atomic.smax.1d
+    amdgcn_image_atomic_smax_1darray,          // llvm.amdgcn.image.atomic.smax.1darray
+    amdgcn_image_atomic_smax_2d,               // llvm.amdgcn.image.atomic.smax.2d
+    amdgcn_image_atomic_smax_2darray,          // llvm.amdgcn.image.atomic.smax.2darray
+    amdgcn_image_atomic_smax_2darraymsaa,      // llvm.amdgcn.image.atomic.smax.2darraymsaa
+    amdgcn_image_atomic_smax_2dmsaa,           // llvm.amdgcn.image.atomic.smax.2dmsaa
+    amdgcn_image_atomic_smax_3d,               // llvm.amdgcn.image.atomic.smax.3d
+    amdgcn_image_atomic_smax_cube,             // llvm.amdgcn.image.atomic.smax.cube
+    amdgcn_image_atomic_smin_1d,               // llvm.amdgcn.image.atomic.smin.1d
+    amdgcn_image_atomic_smin_1darray,          // llvm.amdgcn.image.atomic.smin.1darray
+    amdgcn_image_atomic_smin_2d,               // llvm.amdgcn.image.atomic.smin.2d
+    amdgcn_image_atomic_smin_2darray,          // llvm.amdgcn.image.atomic.smin.2darray
+    amdgcn_image_atomic_smin_2darraymsaa,      // llvm.amdgcn.image.atomic.smin.2darraymsaa
+    amdgcn_image_atomic_smin_2dmsaa,           // llvm.amdgcn.image.atomic.smin.2dmsaa
+    amdgcn_image_atomic_smin_3d,               // llvm.amdgcn.image.atomic.smin.3d
+    amdgcn_image_atomic_smin_cube,             // llvm.amdgcn.image.atomic.smin.cube
+    amdgcn_image_atomic_sub_1d,                // llvm.amdgcn.image.atomic.sub.1d
+    amdgcn_image_atomic_sub_1darray,           // llvm.amdgcn.image.atomic.sub.1darray
+    amdgcn_image_atomic_sub_2d,                // llvm.amdgcn.image.atomic.sub.2d
+    amdgcn_image_atomic_sub_2darray,           // llvm.amdgcn.image.atomic.sub.2darray
+    amdgcn_image_atomic_sub_2darraymsaa,       // llvm.amdgcn.image.atomic.sub.2darraymsaa
+    amdgcn_image_atomic_sub_2dmsaa,            // llvm.amdgcn.image.atomic.sub.2dmsaa
+    amdgcn_image_atomic_sub_3d,                // llvm.amdgcn.image.atomic.sub.3d
+    amdgcn_image_atomic_sub_cube,              // llvm.amdgcn.image.atomic.sub.cube
+    amdgcn_image_atomic_swap_1d,               // llvm.amdgcn.image.atomic.swap.1d
+    amdgcn_image_atomic_swap_1darray,          // llvm.amdgcn.image.atomic.swap.1darray
+    amdgcn_image_atomic_swap_2d,               // llvm.amdgcn.image.atomic.swap.2d
+    amdgcn_image_atomic_swap_2darray,          // llvm.amdgcn.image.atomic.swap.2darray
+    amdgcn_image_atomic_swap_2darraymsaa,      // llvm.amdgcn.image.atomic.swap.2darraymsaa
+    amdgcn_image_atomic_swap_2dmsaa,           // llvm.amdgcn.image.atomic.swap.2dmsaa
+    amdgcn_image_atomic_swap_3d,               // llvm.amdgcn.image.atomic.swap.3d
+    amdgcn_image_atomic_swap_cube,             // llvm.amdgcn.image.atomic.swap.cube
+    amdgcn_image_atomic_umax_1d,               // llvm.amdgcn.image.atomic.umax.1d
+    amdgcn_image_atomic_umax_1darray,          // llvm.amdgcn.image.atomic.umax.1darray
+    amdgcn_image_atomic_umax_2d,               // llvm.amdgcn.image.atomic.umax.2d
+    amdgcn_image_atomic_umax_2darray,          // llvm.amdgcn.image.atomic.umax.2darray
+    amdgcn_image_atomic_umax_2darraymsaa,      // llvm.amdgcn.image.atomic.umax.2darraymsaa
+    amdgcn_image_atomic_umax_2dmsaa,           // llvm.amdgcn.image.atomic.umax.2dmsaa
+    amdgcn_image_atomic_umax_3d,               // llvm.amdgcn.image.atomic.umax.3d
+    amdgcn_image_atomic_umax_cube,             // llvm.amdgcn.image.atomic.umax.cube
+    amdgcn_image_atomic_umin_1d,               // llvm.amdgcn.image.atomic.umin.1d
+    amdgcn_image_atomic_umin_1darray,          // llvm.amdgcn.image.atomic.umin.1darray
+    amdgcn_image_atomic_umin_2d,               // llvm.amdgcn.image.atomic.umin.2d
+    amdgcn_image_atomic_umin_2darray,          // llvm.amdgcn.image.atomic.umin.2darray
+    amdgcn_image_atomic_umin_2darraymsaa,      // llvm.amdgcn.image.atomic.umin.2darraymsaa
+    amdgcn_image_atomic_umin_2dmsaa,           // llvm.amdgcn.image.atomic.umin.2dmsaa
+    amdgcn_image_atomic_umin_3d,               // llvm.amdgcn.image.atomic.umin.3d
+    amdgcn_image_atomic_umin_cube,             // llvm.amdgcn.image.atomic.umin.cube
+    amdgcn_image_atomic_xor_1d,                // llvm.amdgcn.image.atomic.xor.1d
+    amdgcn_image_atomic_xor_1darray,           // llvm.amdgcn.image.atomic.xor.1darray
+    amdgcn_image_atomic_xor_2d,                // llvm.amdgcn.image.atomic.xor.2d
+    amdgcn_image_atomic_xor_2darray,           // llvm.amdgcn.image.atomic.xor.2darray
+    amdgcn_image_atomic_xor_2darraymsaa,       // llvm.amdgcn.image.atomic.xor.2darraymsaa
+    amdgcn_image_atomic_xor_2dmsaa,            // llvm.amdgcn.image.atomic.xor.2dmsaa
+    amdgcn_image_atomic_xor_3d,                // llvm.amdgcn.image.atomic.xor.3d
+    amdgcn_image_atomic_xor_cube,              // llvm.amdgcn.image.atomic.xor.cube
+    amdgcn_image_bvh_intersect_ray,            // llvm.amdgcn.image.bvh.intersect.ray
+    amdgcn_image_gather4_2d,                   // llvm.amdgcn.image.gather4.2d
+    amdgcn_image_gather4_2darray,              // llvm.amdgcn.image.gather4.2darray
+    amdgcn_image_gather4_b_2d,                 // llvm.amdgcn.image.gather4.b.2d
+    amdgcn_image_gather4_b_2darray,            // llvm.amdgcn.image.gather4.b.2darray
+    amdgcn_image_gather4_b_cl_2d,              // llvm.amdgcn.image.gather4.b.cl.2d
+    amdgcn_image_gather4_b_cl_2darray,         // llvm.amdgcn.image.gather4.b.cl.2darray
+    amdgcn_image_gather4_b_cl_cube,            // llvm.amdgcn.image.gather4.b.cl.cube
+    amdgcn_image_gather4_b_cl_o_2d,            // llvm.amdgcn.image.gather4.b.cl.o.2d
+    amdgcn_image_gather4_b_cl_o_2darray,       // llvm.amdgcn.image.gather4.b.cl.o.2darray
+    amdgcn_image_gather4_b_cl_o_cube,          // llvm.amdgcn.image.gather4.b.cl.o.cube
+    amdgcn_image_gather4_b_cube,               // llvm.amdgcn.image.gather4.b.cube
+    amdgcn_image_gather4_b_o_2d,               // llvm.amdgcn.image.gather4.b.o.2d
+    amdgcn_image_gather4_b_o_2darray,          // llvm.amdgcn.image.gather4.b.o.2darray
+    amdgcn_image_gather4_b_o_cube,             // llvm.amdgcn.image.gather4.b.o.cube
+    amdgcn_image_gather4_c_2d,                 // llvm.amdgcn.image.gather4.c.2d
+    amdgcn_image_gather4_c_2darray,            // llvm.amdgcn.image.gather4.c.2darray
+    amdgcn_image_gather4_c_b_2d,               // llvm.amdgcn.image.gather4.c.b.2d
+    amdgcn_image_gather4_c_b_2darray,          // llvm.amdgcn.image.gather4.c.b.2darray
+    amdgcn_image_gather4_c_b_cl_2d,            // llvm.amdgcn.image.gather4.c.b.cl.2d
+    amdgcn_image_gather4_c_b_cl_2darray,       // llvm.amdgcn.image.gather4.c.b.cl.2darray
+    amdgcn_image_gather4_c_b_cl_cube,          // llvm.amdgcn.image.gather4.c.b.cl.cube
+    amdgcn_image_gather4_c_b_cl_o_2d,          // llvm.amdgcn.image.gather4.c.b.cl.o.2d
+    amdgcn_image_gather4_c_b_cl_o_2darray,     // llvm.amdgcn.image.gather4.c.b.cl.o.2darray
+    amdgcn_image_gather4_c_b_cl_o_cube,        // llvm.amdgcn.image.gather4.c.b.cl.o.cube
+    amdgcn_image_gather4_c_b_cube,             // llvm.amdgcn.image.gather4.c.b.cube
+    amdgcn_image_gather4_c_b_o_2d,             // llvm.amdgcn.image.gather4.c.b.o.2d
+    amdgcn_image_gather4_c_b_o_2darray,        // llvm.amdgcn.image.gather4.c.b.o.2darray
+    amdgcn_image_gather4_c_b_o_cube,           // llvm.amdgcn.image.gather4.c.b.o.cube
+    amdgcn_image_gather4_c_cl_2d,              // llvm.amdgcn.image.gather4.c.cl.2d
+    amdgcn_image_gather4_c_cl_2darray,         // llvm.amdgcn.image.gather4.c.cl.2darray
+    amdgcn_image_gather4_c_cl_cube,            // llvm.amdgcn.image.gather4.c.cl.cube
+    amdgcn_image_gather4_c_cl_o_2d,            // llvm.amdgcn.image.gather4.c.cl.o.2d
+    amdgcn_image_gather4_c_cl_o_2darray,       // llvm.amdgcn.image.gather4.c.cl.o.2darray
+    amdgcn_image_gather4_c_cl_o_cube,          // llvm.amdgcn.image.gather4.c.cl.o.cube
+    amdgcn_image_gather4_c_cube,               // llvm.amdgcn.image.gather4.c.cube
+    amdgcn_image_gather4_c_l_2d,               // llvm.amdgcn.image.gather4.c.l.2d
+    amdgcn_image_gather4_c_l_2darray,          // llvm.amdgcn.image.gather4.c.l.2darray
+    amdgcn_image_gather4_c_l_cube,             // llvm.amdgcn.image.gather4.c.l.cube
+    amdgcn_image_gather4_c_l_o_2d,             // llvm.amdgcn.image.gather4.c.l.o.2d
+    amdgcn_image_gather4_c_l_o_2darray,        // llvm.amdgcn.image.gather4.c.l.o.2darray
+    amdgcn_image_gather4_c_l_o_cube,           // llvm.amdgcn.image.gather4.c.l.o.cube
+    amdgcn_image_gather4_c_lz_2d,              // llvm.amdgcn.image.gather4.c.lz.2d
+    amdgcn_image_gather4_c_lz_2darray,         // llvm.amdgcn.image.gather4.c.lz.2darray
+    amdgcn_image_gather4_c_lz_cube,            // llvm.amdgcn.image.gather4.c.lz.cube
+    amdgcn_image_gather4_c_lz_o_2d,            // llvm.amdgcn.image.gather4.c.lz.o.2d
+    amdgcn_image_gather4_c_lz_o_2darray,       // llvm.amdgcn.image.gather4.c.lz.o.2darray
+    amdgcn_image_gather4_c_lz_o_cube,          // llvm.amdgcn.image.gather4.c.lz.o.cube
+    amdgcn_image_gather4_c_o_2d,               // llvm.amdgcn.image.gather4.c.o.2d
+    amdgcn_image_gather4_c_o_2darray,          // llvm.amdgcn.image.gather4.c.o.2darray
+    amdgcn_image_gather4_c_o_cube,             // llvm.amdgcn.image.gather4.c.o.cube
+    amdgcn_image_gather4_cl_2d,                // llvm.amdgcn.image.gather4.cl.2d
+    amdgcn_image_gather4_cl_2darray,           // llvm.amdgcn.image.gather4.cl.2darray
+    amdgcn_image_gather4_cl_cube,              // llvm.amdgcn.image.gather4.cl.cube
+    amdgcn_image_gather4_cl_o_2d,              // llvm.amdgcn.image.gather4.cl.o.2d
+    amdgcn_image_gather4_cl_o_2darray,         // llvm.amdgcn.image.gather4.cl.o.2darray
+    amdgcn_image_gather4_cl_o_cube,            // llvm.amdgcn.image.gather4.cl.o.cube
+    amdgcn_image_gather4_cube,                 // llvm.amdgcn.image.gather4.cube
+    amdgcn_image_gather4_l_2d,                 // llvm.amdgcn.image.gather4.l.2d
+    amdgcn_image_gather4_l_2darray,            // llvm.amdgcn.image.gather4.l.2darray
+    amdgcn_image_gather4_l_cube,               // llvm.amdgcn.image.gather4.l.cube
+    amdgcn_image_gather4_l_o_2d,               // llvm.amdgcn.image.gather4.l.o.2d
+    amdgcn_image_gather4_l_o_2darray,          // llvm.amdgcn.image.gather4.l.o.2darray
+    amdgcn_image_gather4_l_o_cube,             // llvm.amdgcn.image.gather4.l.o.cube
+    amdgcn_image_gather4_lz_2d,                // llvm.amdgcn.image.gather4.lz.2d
+    amdgcn_image_gather4_lz_2darray,           // llvm.amdgcn.image.gather4.lz.2darray
+    amdgcn_image_gather4_lz_cube,              // llvm.amdgcn.image.gather4.lz.cube
+    amdgcn_image_gather4_lz_o_2d,              // llvm.amdgcn.image.gather4.lz.o.2d
+    amdgcn_image_gather4_lz_o_2darray,         // llvm.amdgcn.image.gather4.lz.o.2darray
+    amdgcn_image_gather4_lz_o_cube,            // llvm.amdgcn.image.gather4.lz.o.cube
+    amdgcn_image_gather4_o_2d,                 // llvm.amdgcn.image.gather4.o.2d
+    amdgcn_image_gather4_o_2darray,            // llvm.amdgcn.image.gather4.o.2darray
+    amdgcn_image_gather4_o_cube,               // llvm.amdgcn.image.gather4.o.cube
+    amdgcn_image_getlod_1d,                    // llvm.amdgcn.image.getlod.1d
+    amdgcn_image_getlod_1darray,               // llvm.amdgcn.image.getlod.1darray
+    amdgcn_image_getlod_2d,                    // llvm.amdgcn.image.getlod.2d
+    amdgcn_image_getlod_2darray,               // llvm.amdgcn.image.getlod.2darray
+    amdgcn_image_getlod_3d,                    // llvm.amdgcn.image.getlod.3d
+    amdgcn_image_getlod_cube,                  // llvm.amdgcn.image.getlod.cube
+    amdgcn_image_getresinfo_1d,                // llvm.amdgcn.image.getresinfo.1d
+    amdgcn_image_getresinfo_1darray,           // llvm.amdgcn.image.getresinfo.1darray
+    amdgcn_image_getresinfo_2d,                // llvm.amdgcn.image.getresinfo.2d
+    amdgcn_image_getresinfo_2darray,           // llvm.amdgcn.image.getresinfo.2darray
+    amdgcn_image_getresinfo_2darraymsaa,       // llvm.amdgcn.image.getresinfo.2darraymsaa
+    amdgcn_image_getresinfo_2dmsaa,            // llvm.amdgcn.image.getresinfo.2dmsaa
+    amdgcn_image_getresinfo_3d,                // llvm.amdgcn.image.getresinfo.3d
+    amdgcn_image_getresinfo_cube,              // llvm.amdgcn.image.getresinfo.cube
+    amdgcn_image_load_1d,                      // llvm.amdgcn.image.load.1d
+    amdgcn_image_load_1darray,                 // llvm.amdgcn.image.load.1darray
+    amdgcn_image_load_2d,                      // llvm.amdgcn.image.load.2d
+    amdgcn_image_load_2darray,                 // llvm.amdgcn.image.load.2darray
+    amdgcn_image_load_2darraymsaa,             // llvm.amdgcn.image.load.2darraymsaa
+    amdgcn_image_load_2dmsaa,                  // llvm.amdgcn.image.load.2dmsaa
+    amdgcn_image_load_3d,                      // llvm.amdgcn.image.load.3d
+    amdgcn_image_load_cube,                    // llvm.amdgcn.image.load.cube
+    amdgcn_image_load_mip_1d,                  // llvm.amdgcn.image.load.mip.1d
+    amdgcn_image_load_mip_1darray,             // llvm.amdgcn.image.load.mip.1darray
+    amdgcn_image_load_mip_2d,                  // llvm.amdgcn.image.load.mip.2d
+    amdgcn_image_load_mip_2darray,             // llvm.amdgcn.image.load.mip.2darray
+    amdgcn_image_load_mip_3d,                  // llvm.amdgcn.image.load.mip.3d
+    amdgcn_image_load_mip_cube,                // llvm.amdgcn.image.load.mip.cube
+    amdgcn_image_msaa_load_1d,                 // llvm.amdgcn.image.msaa.load.1d
+    amdgcn_image_msaa_load_1darray,            // llvm.amdgcn.image.msaa.load.1darray
+    amdgcn_image_msaa_load_2d,                 // llvm.amdgcn.image.msaa.load.2d
+    amdgcn_image_msaa_load_2darray,            // llvm.amdgcn.image.msaa.load.2darray
+    amdgcn_image_msaa_load_2darraymsaa,        // llvm.amdgcn.image.msaa.load.2darraymsaa
+    amdgcn_image_msaa_load_2dmsaa,             // llvm.amdgcn.image.msaa.load.2dmsaa
+    amdgcn_image_msaa_load_3d,                 // llvm.amdgcn.image.msaa.load.3d
+    amdgcn_image_msaa_load_cube,               // llvm.amdgcn.image.msaa.load.cube
+    amdgcn_image_sample_1d,                    // llvm.amdgcn.image.sample.1d
+    amdgcn_image_sample_1darray,               // llvm.amdgcn.image.sample.1darray
+    amdgcn_image_sample_2d,                    // llvm.amdgcn.image.sample.2d
+    amdgcn_image_sample_2darray,               // llvm.amdgcn.image.sample.2darray
+    amdgcn_image_sample_3d,                    // llvm.amdgcn.image.sample.3d
+    amdgcn_image_sample_b_1d,                  // llvm.amdgcn.image.sample.b.1d
+    amdgcn_image_sample_b_1darray,             // llvm.amdgcn.image.sample.b.1darray
+    amdgcn_image_sample_b_2d,                  // llvm.amdgcn.image.sample.b.2d
+    amdgcn_image_sample_b_2darray,             // llvm.amdgcn.image.sample.b.2darray
+    amdgcn_image_sample_b_3d,                  // llvm.amdgcn.image.sample.b.3d
+    amdgcn_image_sample_b_cl_1d,               // llvm.amdgcn.image.sample.b.cl.1d
+    amdgcn_image_sample_b_cl_1darray,          // llvm.amdgcn.image.sample.b.cl.1darray
+    amdgcn_image_sample_b_cl_2d,               // llvm.amdgcn.image.sample.b.cl.2d
+    amdgcn_image_sample_b_cl_2darray,          // llvm.amdgcn.image.sample.b.cl.2darray
+    amdgcn_image_sample_b_cl_3d,               // llvm.amdgcn.image.sample.b.cl.3d
+    amdgcn_image_sample_b_cl_cube,             // llvm.amdgcn.image.sample.b.cl.cube
+    amdgcn_image_sample_b_cl_o_1d,             // llvm.amdgcn.image.sample.b.cl.o.1d
+    amdgcn_image_sample_b_cl_o_1darray,        // llvm.amdgcn.image.sample.b.cl.o.1darray
+    amdgcn_image_sample_b_cl_o_2d,             // llvm.amdgcn.image.sample.b.cl.o.2d
+    amdgcn_image_sample_b_cl_o_2darray,        // llvm.amdgcn.image.sample.b.cl.o.2darray
+    amdgcn_image_sample_b_cl_o_3d,             // llvm.amdgcn.image.sample.b.cl.o.3d
+    amdgcn_image_sample_b_cl_o_cube,           // llvm.amdgcn.image.sample.b.cl.o.cube
+    amdgcn_image_sample_b_cube,                // llvm.amdgcn.image.sample.b.cube
+    amdgcn_image_sample_b_o_1d,                // llvm.amdgcn.image.sample.b.o.1d
+    amdgcn_image_sample_b_o_1darray,           // llvm.amdgcn.image.sample.b.o.1darray
+    amdgcn_image_sample_b_o_2d,                // llvm.amdgcn.image.sample.b.o.2d
+    amdgcn_image_sample_b_o_2darray,           // llvm.amdgcn.image.sample.b.o.2darray
+    amdgcn_image_sample_b_o_3d,                // llvm.amdgcn.image.sample.b.o.3d
+    amdgcn_image_sample_b_o_cube,              // llvm.amdgcn.image.sample.b.o.cube
+    amdgcn_image_sample_c_1d,                  // llvm.amdgcn.image.sample.c.1d
+    amdgcn_image_sample_c_1darray,             // llvm.amdgcn.image.sample.c.1darray
+    amdgcn_image_sample_c_2d,                  // llvm.amdgcn.image.sample.c.2d
+    amdgcn_image_sample_c_2darray,             // llvm.amdgcn.image.sample.c.2darray
+    amdgcn_image_sample_c_3d,                  // llvm.amdgcn.image.sample.c.3d
+    amdgcn_image_sample_c_b_1d,                // llvm.amdgcn.image.sample.c.b.1d
+    amdgcn_image_sample_c_b_1darray,           // llvm.amdgcn.image.sample.c.b.1darray
+    amdgcn_image_sample_c_b_2d,                // llvm.amdgcn.image.sample.c.b.2d
+    amdgcn_image_sample_c_b_2darray,           // llvm.amdgcn.image.sample.c.b.2darray
+    amdgcn_image_sample_c_b_3d,                // llvm.amdgcn.image.sample.c.b.3d
+    amdgcn_image_sample_c_b_cl_1d,             // llvm.amdgcn.image.sample.c.b.cl.1d
+    amdgcn_image_sample_c_b_cl_1darray,        // llvm.amdgcn.image.sample.c.b.cl.1darray
+    amdgcn_image_sample_c_b_cl_2d,             // llvm.amdgcn.image.sample.c.b.cl.2d
+    amdgcn_image_sample_c_b_cl_2darray,        // llvm.amdgcn.image.sample.c.b.cl.2darray
+    amdgcn_image_sample_c_b_cl_3d,             // llvm.amdgcn.image.sample.c.b.cl.3d
+    amdgcn_image_sample_c_b_cl_cube,           // llvm.amdgcn.image.sample.c.b.cl.cube
+    amdgcn_image_sample_c_b_cl_o_1d,           // llvm.amdgcn.image.sample.c.b.cl.o.1d
+    amdgcn_image_sample_c_b_cl_o_1darray,      // llvm.amdgcn.image.sample.c.b.cl.o.1darray
+    amdgcn_image_sample_c_b_cl_o_2d,           // llvm.amdgcn.image.sample.c.b.cl.o.2d
+    amdgcn_image_sample_c_b_cl_o_2darray,      // llvm.amdgcn.image.sample.c.b.cl.o.2darray
+    amdgcn_image_sample_c_b_cl_o_3d,           // llvm.amdgcn.image.sample.c.b.cl.o.3d
+    amdgcn_image_sample_c_b_cl_o_cube,         // llvm.amdgcn.image.sample.c.b.cl.o.cube
+    amdgcn_image_sample_c_b_cube,              // llvm.amdgcn.image.sample.c.b.cube
+    amdgcn_image_sample_c_b_o_1d,              // llvm.amdgcn.image.sample.c.b.o.1d
+    amdgcn_image_sample_c_b_o_1darray,         // llvm.amdgcn.image.sample.c.b.o.1darray
+    amdgcn_image_sample_c_b_o_2d,              // llvm.amdgcn.image.sample.c.b.o.2d
+    amdgcn_image_sample_c_b_o_2darray,         // llvm.amdgcn.image.sample.c.b.o.2darray
+    amdgcn_image_sample_c_b_o_3d,              // llvm.amdgcn.image.sample.c.b.o.3d
+    amdgcn_image_sample_c_b_o_cube,            // llvm.amdgcn.image.sample.c.b.o.cube
+    amdgcn_image_sample_c_cd_1d,               // llvm.amdgcn.image.sample.c.cd.1d
+    amdgcn_image_sample_c_cd_1darray,          // llvm.amdgcn.image.sample.c.cd.1darray
+    amdgcn_image_sample_c_cd_2d,               // llvm.amdgcn.image.sample.c.cd.2d
+    amdgcn_image_sample_c_cd_2darray,          // llvm.amdgcn.image.sample.c.cd.2darray
+    amdgcn_image_sample_c_cd_3d,               // llvm.amdgcn.image.sample.c.cd.3d
+    amdgcn_image_sample_c_cd_cl_1d,            // llvm.amdgcn.image.sample.c.cd.cl.1d
+    amdgcn_image_sample_c_cd_cl_1darray,       // llvm.amdgcn.image.sample.c.cd.cl.1darray
+    amdgcn_image_sample_c_cd_cl_2d,            // llvm.amdgcn.image.sample.c.cd.cl.2d
+    amdgcn_image_sample_c_cd_cl_2darray,       // llvm.amdgcn.image.sample.c.cd.cl.2darray
+    amdgcn_image_sample_c_cd_cl_3d,            // llvm.amdgcn.image.sample.c.cd.cl.3d
+    amdgcn_image_sample_c_cd_cl_cube,          // llvm.amdgcn.image.sample.c.cd.cl.cube
+    amdgcn_image_sample_c_cd_cl_o_1d,          // llvm.amdgcn.image.sample.c.cd.cl.o.1d
+    amdgcn_image_sample_c_cd_cl_o_1darray,     // llvm.amdgcn.image.sample.c.cd.cl.o.1darray
+    amdgcn_image_sample_c_cd_cl_o_2d,          // llvm.amdgcn.image.sample.c.cd.cl.o.2d
+    amdgcn_image_sample_c_cd_cl_o_2darray,     // llvm.amdgcn.image.sample.c.cd.cl.o.2darray
+    amdgcn_image_sample_c_cd_cl_o_3d,          // llvm.amdgcn.image.sample.c.cd.cl.o.3d
+    amdgcn_image_sample_c_cd_cl_o_cube,        // llvm.amdgcn.image.sample.c.cd.cl.o.cube
+    amdgcn_image_sample_c_cd_cube,             // llvm.amdgcn.image.sample.c.cd.cube
+    amdgcn_image_sample_c_cd_o_1d,             // llvm.amdgcn.image.sample.c.cd.o.1d
+    amdgcn_image_sample_c_cd_o_1darray,        // llvm.amdgcn.image.sample.c.cd.o.1darray
+    amdgcn_image_sample_c_cd_o_2d,             // llvm.amdgcn.image.sample.c.cd.o.2d
+    amdgcn_image_sample_c_cd_o_2darray,        // llvm.amdgcn.image.sample.c.cd.o.2darray
+    amdgcn_image_sample_c_cd_o_3d,             // llvm.amdgcn.image.sample.c.cd.o.3d
+    amdgcn_image_sample_c_cd_o_cube,           // llvm.amdgcn.image.sample.c.cd.o.cube
+    amdgcn_image_sample_c_cl_1d,               // llvm.amdgcn.image.sample.c.cl.1d
+    amdgcn_image_sample_c_cl_1darray,          // llvm.amdgcn.image.sample.c.cl.1darray
+    amdgcn_image_sample_c_cl_2d,               // llvm.amdgcn.image.sample.c.cl.2d
+    amdgcn_image_sample_c_cl_2darray,          // llvm.amdgcn.image.sample.c.cl.2darray
+    amdgcn_image_sample_c_cl_3d,               // llvm.amdgcn.image.sample.c.cl.3d
+    amdgcn_image_sample_c_cl_cube,             // llvm.amdgcn.image.sample.c.cl.cube
+    amdgcn_image_sample_c_cl_o_1d,             // llvm.amdgcn.image.sample.c.cl.o.1d
+    amdgcn_image_sample_c_cl_o_1darray,        // llvm.amdgcn.image.sample.c.cl.o.1darray
+    amdgcn_image_sample_c_cl_o_2d,             // llvm.amdgcn.image.sample.c.cl.o.2d
+    amdgcn_image_sample_c_cl_o_2darray,        // llvm.amdgcn.image.sample.c.cl.o.2darray
+    amdgcn_image_sample_c_cl_o_3d,             // llvm.amdgcn.image.sample.c.cl.o.3d
+    amdgcn_image_sample_c_cl_o_cube,           // llvm.amdgcn.image.sample.c.cl.o.cube
+    amdgcn_image_sample_c_cube,                // llvm.amdgcn.image.sample.c.cube
+    amdgcn_image_sample_c_d_1d,                // llvm.amdgcn.image.sample.c.d.1d
+    amdgcn_image_sample_c_d_1darray,           // llvm.amdgcn.image.sample.c.d.1darray
+    amdgcn_image_sample_c_d_2d,                // llvm.amdgcn.image.sample.c.d.2d
+    amdgcn_image_sample_c_d_2darray,           // llvm.amdgcn.image.sample.c.d.2darray
+    amdgcn_image_sample_c_d_3d,                // llvm.amdgcn.image.sample.c.d.3d
+    amdgcn_image_sample_c_d_cl_1d,             // llvm.amdgcn.image.sample.c.d.cl.1d
+    amdgcn_image_sample_c_d_cl_1darray,        // llvm.amdgcn.image.sample.c.d.cl.1darray
+    amdgcn_image_sample_c_d_cl_2d,             // llvm.amdgcn.image.sample.c.d.cl.2d
+    amdgcn_image_sample_c_d_cl_2darray,        // llvm.amdgcn.image.sample.c.d.cl.2darray
+    amdgcn_image_sample_c_d_cl_3d,             // llvm.amdgcn.image.sample.c.d.cl.3d
+    amdgcn_image_sample_c_d_cl_cube,           // llvm.amdgcn.image.sample.c.d.cl.cube
+    amdgcn_image_sample_c_d_cl_o_1d,           // llvm.amdgcn.image.sample.c.d.cl.o.1d
+    amdgcn_image_sample_c_d_cl_o_1darray,      // llvm.amdgcn.image.sample.c.d.cl.o.1darray
+    amdgcn_image_sample_c_d_cl_o_2d,           // llvm.amdgcn.image.sample.c.d.cl.o.2d
+    amdgcn_image_sample_c_d_cl_o_2darray,      // llvm.amdgcn.image.sample.c.d.cl.o.2darray
+    amdgcn_image_sample_c_d_cl_o_3d,           // llvm.amdgcn.image.sample.c.d.cl.o.3d
+    amdgcn_image_sample_c_d_cl_o_cube,         // llvm.amdgcn.image.sample.c.d.cl.o.cube
+    amdgcn_image_sample_c_d_cube,              // llvm.amdgcn.image.sample.c.d.cube
+    amdgcn_image_sample_c_d_o_1d,              // llvm.amdgcn.image.sample.c.d.o.1d
+    amdgcn_image_sample_c_d_o_1darray,         // llvm.amdgcn.image.sample.c.d.o.1darray
+    amdgcn_image_sample_c_d_o_2d,              // llvm.amdgcn.image.sample.c.d.o.2d
+    amdgcn_image_sample_c_d_o_2darray,         // llvm.amdgcn.image.sample.c.d.o.2darray
+    amdgcn_image_sample_c_d_o_3d,              // llvm.amdgcn.image.sample.c.d.o.3d
+    amdgcn_image_sample_c_d_o_cube,            // llvm.amdgcn.image.sample.c.d.o.cube
+    amdgcn_image_sample_c_l_1d,                // llvm.amdgcn.image.sample.c.l.1d
+    amdgcn_image_sample_c_l_1darray,           // llvm.amdgcn.image.sample.c.l.1darray
+    amdgcn_image_sample_c_l_2d,                // llvm.amdgcn.image.sample.c.l.2d
+    amdgcn_image_sample_c_l_2darray,           // llvm.amdgcn.image.sample.c.l.2darray
+    amdgcn_image_sample_c_l_3d,                // llvm.amdgcn.image.sample.c.l.3d
+    amdgcn_image_sample_c_l_cube,              // llvm.amdgcn.image.sample.c.l.cube
+    amdgcn_image_sample_c_l_o_1d,              // llvm.amdgcn.image.sample.c.l.o.1d
+    amdgcn_image_sample_c_l_o_1darray,         // llvm.amdgcn.image.sample.c.l.o.1darray
+    amdgcn_image_sample_c_l_o_2d,              // llvm.amdgcn.image.sample.c.l.o.2d
+    amdgcn_image_sample_c_l_o_2darray,         // llvm.amdgcn.image.sample.c.l.o.2darray
+    amdgcn_image_sample_c_l_o_3d,              // llvm.amdgcn.image.sample.c.l.o.3d
+    amdgcn_image_sample_c_l_o_cube,            // llvm.amdgcn.image.sample.c.l.o.cube
+    amdgcn_image_sample_c_lz_1d,               // llvm.amdgcn.image.sample.c.lz.1d
+    amdgcn_image_sample_c_lz_1darray,          // llvm.amdgcn.image.sample.c.lz.1darray
+    amdgcn_image_sample_c_lz_2d,               // llvm.amdgcn.image.sample.c.lz.2d
+    amdgcn_image_sample_c_lz_2darray,          // llvm.amdgcn.image.sample.c.lz.2darray
+    amdgcn_image_sample_c_lz_3d,               // llvm.amdgcn.image.sample.c.lz.3d
+    amdgcn_image_sample_c_lz_cube,             // llvm.amdgcn.image.sample.c.lz.cube
+    amdgcn_image_sample_c_lz_o_1d,             // llvm.amdgcn.image.sample.c.lz.o.1d
+    amdgcn_image_sample_c_lz_o_1darray,        // llvm.amdgcn.image.sample.c.lz.o.1darray
+    amdgcn_image_sample_c_lz_o_2d,             // llvm.amdgcn.image.sample.c.lz.o.2d
+    amdgcn_image_sample_c_lz_o_2darray,        // llvm.amdgcn.image.sample.c.lz.o.2darray
+    amdgcn_image_sample_c_lz_o_3d,             // llvm.amdgcn.image.sample.c.lz.o.3d
+    amdgcn_image_sample_c_lz_o_cube,           // llvm.amdgcn.image.sample.c.lz.o.cube
+    amdgcn_image_sample_c_o_1d,                // llvm.amdgcn.image.sample.c.o.1d
+    amdgcn_image_sample_c_o_1darray,           // llvm.amdgcn.image.sample.c.o.1darray
+    amdgcn_image_sample_c_o_2d,                // llvm.amdgcn.image.sample.c.o.2d
+    amdgcn_image_sample_c_o_2darray,           // llvm.amdgcn.image.sample.c.o.2darray
+    amdgcn_image_sample_c_o_3d,                // llvm.amdgcn.image.sample.c.o.3d
+    amdgcn_image_sample_c_o_cube,              // llvm.amdgcn.image.sample.c.o.cube
+    amdgcn_image_sample_cd_1d,                 // llvm.amdgcn.image.sample.cd.1d
+    amdgcn_image_sample_cd_1darray,            // llvm.amdgcn.image.sample.cd.1darray
+    amdgcn_image_sample_cd_2d,                 // llvm.amdgcn.image.sample.cd.2d
+    amdgcn_image_sample_cd_2darray,            // llvm.amdgcn.image.sample.cd.2darray
+    amdgcn_image_sample_cd_3d,                 // llvm.amdgcn.image.sample.cd.3d
+    amdgcn_image_sample_cd_cl_1d,              // llvm.amdgcn.image.sample.cd.cl.1d
+    amdgcn_image_sample_cd_cl_1darray,         // llvm.amdgcn.image.sample.cd.cl.1darray
+    amdgcn_image_sample_cd_cl_2d,              // llvm.amdgcn.image.sample.cd.cl.2d
+    amdgcn_image_sample_cd_cl_2darray,         // llvm.amdgcn.image.sample.cd.cl.2darray
+    amdgcn_image_sample_cd_cl_3d,              // llvm.amdgcn.image.sample.cd.cl.3d
+    amdgcn_image_sample_cd_cl_cube,            // llvm.amdgcn.image.sample.cd.cl.cube
+    amdgcn_image_sample_cd_cl_o_1d,            // llvm.amdgcn.image.sample.cd.cl.o.1d
+    amdgcn_image_sample_cd_cl_o_1darray,       // llvm.amdgcn.image.sample.cd.cl.o.1darray
+    amdgcn_image_sample_cd_cl_o_2d,            // llvm.amdgcn.image.sample.cd.cl.o.2d
+    amdgcn_image_sample_cd_cl_o_2darray,       // llvm.amdgcn.image.sample.cd.cl.o.2darray
+    amdgcn_image_sample_cd_cl_o_3d,            // llvm.amdgcn.image.sample.cd.cl.o.3d
+    amdgcn_image_sample_cd_cl_o_cube,          // llvm.amdgcn.image.sample.cd.cl.o.cube
+    amdgcn_image_sample_cd_cube,               // llvm.amdgcn.image.sample.cd.cube
+    amdgcn_image_sample_cd_o_1d,               // llvm.amdgcn.image.sample.cd.o.1d
+    amdgcn_image_sample_cd_o_1darray,          // llvm.amdgcn.image.sample.cd.o.1darray
+    amdgcn_image_sample_cd_o_2d,               // llvm.amdgcn.image.sample.cd.o.2d
+    amdgcn_image_sample_cd_o_2darray,          // llvm.amdgcn.image.sample.cd.o.2darray
+    amdgcn_image_sample_cd_o_3d,               // llvm.amdgcn.image.sample.cd.o.3d
+    amdgcn_image_sample_cd_o_cube,             // llvm.amdgcn.image.sample.cd.o.cube
+    amdgcn_image_sample_cl_1d,                 // llvm.amdgcn.image.sample.cl.1d
+    amdgcn_image_sample_cl_1darray,            // llvm.amdgcn.image.sample.cl.1darray
+    amdgcn_image_sample_cl_2d,                 // llvm.amdgcn.image.sample.cl.2d
+    amdgcn_image_sample_cl_2darray,            // llvm.amdgcn.image.sample.cl.2darray
+    amdgcn_image_sample_cl_3d,                 // llvm.amdgcn.image.sample.cl.3d
+    amdgcn_image_sample_cl_cube,               // llvm.amdgcn.image.sample.cl.cube
+    amdgcn_image_sample_cl_o_1d,               // llvm.amdgcn.image.sample.cl.o.1d
+    amdgcn_image_sample_cl_o_1darray,          // llvm.amdgcn.image.sample.cl.o.1darray
+    amdgcn_image_sample_cl_o_2d,               // llvm.amdgcn.image.sample.cl.o.2d
+    amdgcn_image_sample_cl_o_2darray,          // llvm.amdgcn.image.sample.cl.o.2darray
+    amdgcn_image_sample_cl_o_3d,               // llvm.amdgcn.image.sample.cl.o.3d
+    amdgcn_image_sample_cl_o_cube,             // llvm.amdgcn.image.sample.cl.o.cube
+    amdgcn_image_sample_cube,                  // llvm.amdgcn.image.sample.cube
+    amdgcn_image_sample_d_1d,                  // llvm.amdgcn.image.sample.d.1d
+    amdgcn_image_sample_d_1darray,             // llvm.amdgcn.image.sample.d.1darray
+    amdgcn_image_sample_d_2d,                  // llvm.amdgcn.image.sample.d.2d
+    amdgcn_image_sample_d_2darray,             // llvm.amdgcn.image.sample.d.2darray
+    amdgcn_image_sample_d_3d,                  // llvm.amdgcn.image.sample.d.3d
+    amdgcn_image_sample_d_cl_1d,               // llvm.amdgcn.image.sample.d.cl.1d
+    amdgcn_image_sample_d_cl_1darray,          // llvm.amdgcn.image.sample.d.cl.1darray
+    amdgcn_image_sample_d_cl_2d,               // llvm.amdgcn.image.sample.d.cl.2d
+    amdgcn_image_sample_d_cl_2darray,          // llvm.amdgcn.image.sample.d.cl.2darray
+    amdgcn_image_sample_d_cl_3d,               // llvm.amdgcn.image.sample.d.cl.3d
+    amdgcn_image_sample_d_cl_cube,             // llvm.amdgcn.image.sample.d.cl.cube
+    amdgcn_image_sample_d_cl_o_1d,             // llvm.amdgcn.image.sample.d.cl.o.1d
+    amdgcn_image_sample_d_cl_o_1darray,        // llvm.amdgcn.image.sample.d.cl.o.1darray
+    amdgcn_image_sample_d_cl_o_2d,             // llvm.amdgcn.image.sample.d.cl.o.2d
+    amdgcn_image_sample_d_cl_o_2darray,        // llvm.amdgcn.image.sample.d.cl.o.2darray
+    amdgcn_image_sample_d_cl_o_3d,             // llvm.amdgcn.image.sample.d.cl.o.3d
+    amdgcn_image_sample_d_cl_o_cube,           // llvm.amdgcn.image.sample.d.cl.o.cube
+    amdgcn_image_sample_d_cube,                // llvm.amdgcn.image.sample.d.cube
+    amdgcn_image_sample_d_o_1d,                // llvm.amdgcn.image.sample.d.o.1d
+    amdgcn_image_sample_d_o_1darray,           // llvm.amdgcn.image.sample.d.o.1darray
+    amdgcn_image_sample_d_o_2d,                // llvm.amdgcn.image.sample.d.o.2d
+    amdgcn_image_sample_d_o_2darray,           // llvm.amdgcn.image.sample.d.o.2darray
+    amdgcn_image_sample_d_o_3d,                // llvm.amdgcn.image.sample.d.o.3d
+    amdgcn_image_sample_d_o_cube,              // llvm.amdgcn.image.sample.d.o.cube
+    amdgcn_image_sample_l_1d,                  // llvm.amdgcn.image.sample.l.1d
+    amdgcn_image_sample_l_1darray,             // llvm.amdgcn.image.sample.l.1darray
+    amdgcn_image_sample_l_2d,                  // llvm.amdgcn.image.sample.l.2d
+    amdgcn_image_sample_l_2darray,             // llvm.amdgcn.image.sample.l.2darray
+    amdgcn_image_sample_l_3d,                  // llvm.amdgcn.image.sample.l.3d
+    amdgcn_image_sample_l_cube,                // llvm.amdgcn.image.sample.l.cube
+    amdgcn_image_sample_l_o_1d,                // llvm.amdgcn.image.sample.l.o.1d
+    amdgcn_image_sample_l_o_1darray,           // llvm.amdgcn.image.sample.l.o.1darray
+    amdgcn_image_sample_l_o_2d,                // llvm.amdgcn.image.sample.l.o.2d
+    amdgcn_image_sample_l_o_2darray,           // llvm.amdgcn.image.sample.l.o.2darray
+    amdgcn_image_sample_l_o_3d,                // llvm.amdgcn.image.sample.l.o.3d
+    amdgcn_image_sample_l_o_cube,              // llvm.amdgcn.image.sample.l.o.cube
+    amdgcn_image_sample_lz_1d,                 // llvm.amdgcn.image.sample.lz.1d
+    amdgcn_image_sample_lz_1darray,            // llvm.amdgcn.image.sample.lz.1darray
+    amdgcn_image_sample_lz_2d,                 // llvm.amdgcn.image.sample.lz.2d
+    amdgcn_image_sample_lz_2darray,            // llvm.amdgcn.image.sample.lz.2darray
+    amdgcn_image_sample_lz_3d,                 // llvm.amdgcn.image.sample.lz.3d
+    amdgcn_image_sample_lz_cube,               // llvm.amdgcn.image.sample.lz.cube
+    amdgcn_image_sample_lz_o_1d,               // llvm.amdgcn.image.sample.lz.o.1d
+    amdgcn_image_sample_lz_o_1darray,          // llvm.amdgcn.image.sample.lz.o.1darray
+    amdgcn_image_sample_lz_o_2d,               // llvm.amdgcn.image.sample.lz.o.2d
+    amdgcn_image_sample_lz_o_2darray,          // llvm.amdgcn.image.sample.lz.o.2darray
+    amdgcn_image_sample_lz_o_3d,               // llvm.amdgcn.image.sample.lz.o.3d
+    amdgcn_image_sample_lz_o_cube,             // llvm.amdgcn.image.sample.lz.o.cube
+    amdgcn_image_sample_o_1d,                  // llvm.amdgcn.image.sample.o.1d
+    amdgcn_image_sample_o_1darray,             // llvm.amdgcn.image.sample.o.1darray
+    amdgcn_image_sample_o_2d,                  // llvm.amdgcn.image.sample.o.2d
+    amdgcn_image_sample_o_2darray,             // llvm.amdgcn.image.sample.o.2darray
+    amdgcn_image_sample_o_3d,                  // llvm.amdgcn.image.sample.o.3d
+    amdgcn_image_sample_o_cube,                // llvm.amdgcn.image.sample.o.cube
+    amdgcn_image_store_1d,                     // llvm.amdgcn.image.store.1d
+    amdgcn_image_store_1darray,                // llvm.amdgcn.image.store.1darray
+    amdgcn_image_store_2d,                     // llvm.amdgcn.image.store.2d
+    amdgcn_image_store_2darray,                // llvm.amdgcn.image.store.2darray
+    amdgcn_image_store_2darraymsaa,            // llvm.amdgcn.image.store.2darraymsaa
+    amdgcn_image_store_2dmsaa,                 // llvm.amdgcn.image.store.2dmsaa
+    amdgcn_image_store_3d,                     // llvm.amdgcn.image.store.3d
+    amdgcn_image_store_cube,                   // llvm.amdgcn.image.store.cube
+    amdgcn_image_store_mip_1d,                 // llvm.amdgcn.image.store.mip.1d
+    amdgcn_image_store_mip_1darray,            // llvm.amdgcn.image.store.mip.1darray
+    amdgcn_image_store_mip_2d,                 // llvm.amdgcn.image.store.mip.2d
+    amdgcn_image_store_mip_2darray,            // llvm.amdgcn.image.store.mip.2darray
+    amdgcn_image_store_mip_3d,                 // llvm.amdgcn.image.store.mip.3d
+    amdgcn_image_store_mip_cube,               // llvm.amdgcn.image.store.mip.cube
+    amdgcn_implicit_buffer_ptr,                // llvm.amdgcn.implicit.buffer.ptr
+    amdgcn_implicitarg_ptr,                    // llvm.amdgcn.implicitarg.ptr
+    amdgcn_init_exec,                          // llvm.amdgcn.init.exec
+    amdgcn_init_exec_from_input,               // llvm.amdgcn.init.exec.from.input
+    amdgcn_interp_mov,                         // llvm.amdgcn.interp.mov
+    amdgcn_interp_p1,                          // llvm.amdgcn.interp.p1
+    amdgcn_interp_p1_f16,                      // llvm.amdgcn.interp.p1.f16
+    amdgcn_interp_p2,                          // llvm.amdgcn.interp.p2
+    amdgcn_interp_p2_f16,                      // llvm.amdgcn.interp.p2.f16
+    amdgcn_is_private,                         // llvm.amdgcn.is.private
+    amdgcn_is_shared,                          // llvm.amdgcn.is.shared
+    amdgcn_kernarg_segment_ptr,                // llvm.amdgcn.kernarg.segment.ptr
+    amdgcn_kill,                               // llvm.amdgcn.kill
+    amdgcn_ldexp,                              // llvm.amdgcn.ldexp
+    amdgcn_lerp,                               // llvm.amdgcn.lerp
+    amdgcn_log_clamp,                          // llvm.amdgcn.log.clamp
+    amdgcn_loop,                               // llvm.amdgcn.loop
+    amdgcn_mbcnt_hi,                           // llvm.amdgcn.mbcnt.hi
+    amdgcn_mbcnt_lo,                           // llvm.amdgcn.mbcnt.lo
+    amdgcn_mfma_f32_16x16x16f16,               // llvm.amdgcn.mfma.f32.16x16x16f16
+    amdgcn_mfma_f32_16x16x1f32,                // llvm.amdgcn.mfma.f32.16x16x1f32
+    amdgcn_mfma_f32_16x16x2bf16,               // llvm.amdgcn.mfma.f32.16x16x2bf16
+    amdgcn_mfma_f32_16x16x4f16,                // llvm.amdgcn.mfma.f32.16x16x4f16
+    amdgcn_mfma_f32_16x16x4f32,                // llvm.amdgcn.mfma.f32.16x16x4f32
+    amdgcn_mfma_f32_16x16x8bf16,               // llvm.amdgcn.mfma.f32.16x16x8bf16
+    amdgcn_mfma_f32_32x32x1f32,                // llvm.amdgcn.mfma.f32.32x32x1f32
+    amdgcn_mfma_f32_32x32x2bf16,               // llvm.amdgcn.mfma.f32.32x32x2bf16
+    amdgcn_mfma_f32_32x32x2f32,                // llvm.amdgcn.mfma.f32.32x32x2f32
+    amdgcn_mfma_f32_32x32x4bf16,               // llvm.amdgcn.mfma.f32.32x32x4bf16
+    amdgcn_mfma_f32_32x32x4f16,                // llvm.amdgcn.mfma.f32.32x32x4f16
+    amdgcn_mfma_f32_32x32x8f16,                // llvm.amdgcn.mfma.f32.32x32x8f16
+    amdgcn_mfma_f32_4x4x1f32,                  // llvm.amdgcn.mfma.f32.4x4x1f32
+    amdgcn_mfma_f32_4x4x2bf16,                 // llvm.amdgcn.mfma.f32.4x4x2bf16
+    amdgcn_mfma_f32_4x4x4f16,                  // llvm.amdgcn.mfma.f32.4x4x4f16
+    amdgcn_mfma_i32_16x16x16i8,                // llvm.amdgcn.mfma.i32.16x16x16i8
+    amdgcn_mfma_i32_16x16x4i8,                 // llvm.amdgcn.mfma.i32.16x16x4i8
+    amdgcn_mfma_i32_32x32x4i8,                 // llvm.amdgcn.mfma.i32.32x32x4i8
+    amdgcn_mfma_i32_32x32x8i8,                 // llvm.amdgcn.mfma.i32.32x32x8i8
+    amdgcn_mfma_i32_4x4x4i8,                   // llvm.amdgcn.mfma.i32.4x4x4i8
+    amdgcn_mov_dpp,                            // llvm.amdgcn.mov.dpp
+    amdgcn_mov_dpp8,                           // llvm.amdgcn.mov.dpp8
+    amdgcn_mqsad_pk_u16_u8,                    // llvm.amdgcn.mqsad.pk.u16.u8
+    amdgcn_mqsad_u32_u8,                       // llvm.amdgcn.mqsad.u32.u8
+    amdgcn_msad_u8,                            // llvm.amdgcn.msad.u8
+    amdgcn_mul_i24,                            // llvm.amdgcn.mul.i24
+    amdgcn_mul_u24,                            // llvm.amdgcn.mul.u24
+    amdgcn_permlane16,                         // llvm.amdgcn.permlane16
+    amdgcn_permlanex16,                        // llvm.amdgcn.permlanex16
+    amdgcn_ps_live,                            // llvm.amdgcn.ps.live
+    amdgcn_qsad_pk_u16_u8,                     // llvm.amdgcn.qsad.pk.u16.u8
+    amdgcn_queue_ptr,                          // llvm.amdgcn.queue.ptr
+    amdgcn_raw_buffer_atomic_add,              // llvm.amdgcn.raw.buffer.atomic.add
+    amdgcn_raw_buffer_atomic_and,              // llvm.amdgcn.raw.buffer.atomic.and
+    amdgcn_raw_buffer_atomic_cmpswap,          // llvm.amdgcn.raw.buffer.atomic.cmpswap
+    amdgcn_raw_buffer_atomic_dec,              // llvm.amdgcn.raw.buffer.atomic.dec
+    amdgcn_raw_buffer_atomic_fadd,             // llvm.amdgcn.raw.buffer.atomic.fadd
+    amdgcn_raw_buffer_atomic_inc,              // llvm.amdgcn.raw.buffer.atomic.inc
+    amdgcn_raw_buffer_atomic_or,               // llvm.amdgcn.raw.buffer.atomic.or
+    amdgcn_raw_buffer_atomic_smax,             // llvm.amdgcn.raw.buffer.atomic.smax
+    amdgcn_raw_buffer_atomic_smin,             // llvm.amdgcn.raw.buffer.atomic.smin
+    amdgcn_raw_buffer_atomic_sub,              // llvm.amdgcn.raw.buffer.atomic.sub
+    amdgcn_raw_buffer_atomic_swap,             // llvm.amdgcn.raw.buffer.atomic.swap
+    amdgcn_raw_buffer_atomic_umax,             // llvm.amdgcn.raw.buffer.atomic.umax
+    amdgcn_raw_buffer_atomic_umin,             // llvm.amdgcn.raw.buffer.atomic.umin
+    amdgcn_raw_buffer_atomic_xor,              // llvm.amdgcn.raw.buffer.atomic.xor
+    amdgcn_raw_buffer_load,                    // llvm.amdgcn.raw.buffer.load
+    amdgcn_raw_buffer_load_format,             // llvm.amdgcn.raw.buffer.load.format
+    amdgcn_raw_buffer_store,                   // llvm.amdgcn.raw.buffer.store
+    amdgcn_raw_buffer_store_format,            // llvm.amdgcn.raw.buffer.store.format
+    amdgcn_raw_tbuffer_load,                   // llvm.amdgcn.raw.tbuffer.load
+    amdgcn_raw_tbuffer_store,                  // llvm.amdgcn.raw.tbuffer.store
+    amdgcn_rcp,                                // llvm.amdgcn.rcp
+    amdgcn_rcp_legacy,                         // llvm.amdgcn.rcp.legacy
+    amdgcn_readfirstlane,                      // llvm.amdgcn.readfirstlane
+    amdgcn_readlane,                           // llvm.amdgcn.readlane
+    amdgcn_reloc_constant,                     // llvm.amdgcn.reloc.constant
+    amdgcn_rsq,                                // llvm.amdgcn.rsq
+    amdgcn_rsq_clamp,                          // llvm.amdgcn.rsq.clamp
+    amdgcn_rsq_legacy,                         // llvm.amdgcn.rsq.legacy
+    amdgcn_s_barrier,                          // llvm.amdgcn.s.barrier
+    amdgcn_s_buffer_load,                      // llvm.amdgcn.s.buffer.load
+    amdgcn_s_dcache_inv,                       // llvm.amdgcn.s.dcache.inv
+    amdgcn_s_dcache_inv_vol,                   // llvm.amdgcn.s.dcache.inv.vol
+    amdgcn_s_dcache_wb,                        // llvm.amdgcn.s.dcache.wb
+    amdgcn_s_dcache_wb_vol,                    // llvm.amdgcn.s.dcache.wb.vol
+    amdgcn_s_decperflevel,                     // llvm.amdgcn.s.decperflevel
+    amdgcn_s_get_waveid_in_workgroup,          // llvm.amdgcn.s.get.waveid.in.workgroup
+    amdgcn_s_getpc,                            // llvm.amdgcn.s.getpc
+    amdgcn_s_getreg,                           // llvm.amdgcn.s.getreg
+    amdgcn_s_incperflevel,                     // llvm.amdgcn.s.incperflevel
+    amdgcn_s_memrealtime,                      // llvm.amdgcn.s.memrealtime
+    amdgcn_s_memtime,                          // llvm.amdgcn.s.memtime
+    amdgcn_s_sendmsg,                          // llvm.amdgcn.s.sendmsg
+    amdgcn_s_sendmsghalt,                      // llvm.amdgcn.s.sendmsghalt
+    amdgcn_s_setreg,                           // llvm.amdgcn.s.setreg
+    amdgcn_s_sleep,                            // llvm.amdgcn.s.sleep
+    amdgcn_s_waitcnt,                          // llvm.amdgcn.s.waitcnt
+    amdgcn_sad_hi_u8,                          // llvm.amdgcn.sad.hi.u8
+    amdgcn_sad_u16,                            // llvm.amdgcn.sad.u16
+    amdgcn_sad_u8,                             // llvm.amdgcn.sad.u8
+    amdgcn_sbfe,                               // llvm.amdgcn.sbfe
+    amdgcn_sdot2,                              // llvm.amdgcn.sdot2
+    amdgcn_sdot4,                              // llvm.amdgcn.sdot4
+    amdgcn_sdot8,                              // llvm.amdgcn.sdot8
+    amdgcn_set_inactive,                       // llvm.amdgcn.set.inactive
+    amdgcn_sffbh,                              // llvm.amdgcn.sffbh
+    amdgcn_sin,                                // llvm.amdgcn.sin
+    amdgcn_softwqm,                            // llvm.amdgcn.softwqm
+    amdgcn_sqrt,                               // llvm.amdgcn.sqrt
+    amdgcn_struct_buffer_atomic_add,           // llvm.amdgcn.struct.buffer.atomic.add
+    amdgcn_struct_buffer_atomic_and,           // llvm.amdgcn.struct.buffer.atomic.and
+    amdgcn_struct_buffer_atomic_cmpswap,       // llvm.amdgcn.struct.buffer.atomic.cmpswap
+    amdgcn_struct_buffer_atomic_dec,           // llvm.amdgcn.struct.buffer.atomic.dec
+    amdgcn_struct_buffer_atomic_fadd,          // llvm.amdgcn.struct.buffer.atomic.fadd
+    amdgcn_struct_buffer_atomic_inc,           // llvm.amdgcn.struct.buffer.atomic.inc
+    amdgcn_struct_buffer_atomic_or,            // llvm.amdgcn.struct.buffer.atomic.or
+    amdgcn_struct_buffer_atomic_smax,          // llvm.amdgcn.struct.buffer.atomic.smax
+    amdgcn_struct_buffer_atomic_smin,          // llvm.amdgcn.struct.buffer.atomic.smin
+    amdgcn_struct_buffer_atomic_sub,           // llvm.amdgcn.struct.buffer.atomic.sub
+    amdgcn_struct_buffer_atomic_swap,          // llvm.amdgcn.struct.buffer.atomic.swap
+    amdgcn_struct_buffer_atomic_umax,          // llvm.amdgcn.struct.buffer.atomic.umax
+    amdgcn_struct_buffer_atomic_umin,          // llvm.amdgcn.struct.buffer.atomic.umin
+    amdgcn_struct_buffer_atomic_xor,           // llvm.amdgcn.struct.buffer.atomic.xor
+    amdgcn_struct_buffer_load,                 // llvm.amdgcn.struct.buffer.load
+    amdgcn_struct_buffer_load_format,          // llvm.amdgcn.struct.buffer.load.format
+    amdgcn_struct_buffer_store,                // llvm.amdgcn.struct.buffer.store
+    amdgcn_struct_buffer_store_format,         // llvm.amdgcn.struct.buffer.store.format
+    amdgcn_struct_tbuffer_load,                // llvm.amdgcn.struct.tbuffer.load
+    amdgcn_struct_tbuffer_store,               // llvm.amdgcn.struct.tbuffer.store
+    amdgcn_tbuffer_load,                       // llvm.amdgcn.tbuffer.load
+    amdgcn_tbuffer_store,                      // llvm.amdgcn.tbuffer.store
+    amdgcn_trig_preop,                         // llvm.amdgcn.trig.preop
+    amdgcn_ubfe,                               // llvm.amdgcn.ubfe
+    amdgcn_udot2,                              // llvm.amdgcn.udot2
+    amdgcn_udot4,                              // llvm.amdgcn.udot4
+    amdgcn_udot8,                              // llvm.amdgcn.udot8
+    amdgcn_unreachable,                        // llvm.amdgcn.unreachable
+    amdgcn_update_dpp,                         // llvm.amdgcn.update.dpp
+    amdgcn_wave_barrier,                       // llvm.amdgcn.wave.barrier
+    amdgcn_wavefrontsize,                      // llvm.amdgcn.wavefrontsize
+    amdgcn_workgroup_id_x,                     // llvm.amdgcn.workgroup.id.x
+    amdgcn_workgroup_id_y,                     // llvm.amdgcn.workgroup.id.y
+    amdgcn_workgroup_id_z,                     // llvm.amdgcn.workgroup.id.z
+    amdgcn_workitem_id_x,                      // llvm.amdgcn.workitem.id.x
+    amdgcn_workitem_id_y,                      // llvm.amdgcn.workitem.id.y
+    amdgcn_workitem_id_z,                      // llvm.amdgcn.workitem.id.z
+    amdgcn_wqm,                                // llvm.amdgcn.wqm
+    amdgcn_wqm_vote,                           // llvm.amdgcn.wqm.vote
+    amdgcn_writelane,                          // llvm.amdgcn.writelane
+    amdgcn_wwm,                                // llvm.amdgcn.wwm
+}; // enum
+} // namespace Intrinsic
+} // namespace llvm
+
+#endif
diff --git a/linux-x64/clang/include/llvm/IR/IntrinsicsAMDGPU.td b/linux-x64/clang/include/llvm/IR/IntrinsicsAMDGPU.td
index f546f53..2cab7f3 100644
--- a/linux-x64/clang/include/llvm/IR/IntrinsicsAMDGPU.td
+++ b/linux-x64/clang/include/llvm/IR/IntrinsicsAMDGPU.td
@@ -11,14 +11,14 @@
 //===----------------------------------------------------------------------===//
 
 class AMDGPUReadPreloadRegisterIntrinsic
-  : Intrinsic<[llvm_i32_ty], [], [IntrNoMem, IntrSpeculatable]>;
+  : Intrinsic<[llvm_i32_ty], [], [IntrNoMem, IntrSpeculatable, IntrWillReturn]>;
 
 class AMDGPUReadPreloadRegisterIntrinsicNamed<string name>
-  : Intrinsic<[llvm_i32_ty], [], [IntrNoMem, IntrSpeculatable]>, GCCBuiltin<name>;
+  : Intrinsic<[llvm_i32_ty], [], [IntrNoMem, IntrSpeculatable, IntrWillReturn]>, GCCBuiltin<name>;
 
 // Used to tag image and resource intrinsics with information used to generate
 // mem operands.
-class AMDGPURsrcIntrinsic<int rsrcarg, bit isimage = 0> {
+class AMDGPURsrcIntrinsic<int rsrcarg, bit isimage = false> {
   int RsrcArg = rsrcarg;
   bit IsImage = isimage;
 }
@@ -48,35 +48,35 @@
 defm int_r600_read_tidig : AMDGPUReadPreloadRegisterIntrinsic_xyz;
 
 def int_r600_group_barrier : GCCBuiltin<"__builtin_r600_group_barrier">,
-  Intrinsic<[], [], [IntrConvergent]>;
+  Intrinsic<[], [], [IntrConvergent, IntrWillReturn]>;
 
 // AS 7 is PARAM_I_ADDRESS, used for kernel arguments
 def int_r600_implicitarg_ptr :
   GCCBuiltin<"__builtin_r600_implicitarg_ptr">,
   Intrinsic<[LLVMQualPointerType<llvm_i8_ty, 7>], [],
-  [IntrNoMem, IntrSpeculatable]>;
+  [IntrNoMem, IntrSpeculatable, IntrWillReturn]>;
 
 def int_r600_rat_store_typed :
   // 1st parameter: Data
   // 2nd parameter: Index
   // 3rd parameter: Constant RAT ID
-  Intrinsic<[], [llvm_v4i32_ty, llvm_v4i32_ty, llvm_i32_ty], []>,
+  Intrinsic<[], [llvm_v4i32_ty, llvm_v4i32_ty, llvm_i32_ty], [IntrWillReturn]>,
   GCCBuiltin<"__builtin_r600_rat_store_typed">;
 
 def int_r600_recipsqrt_ieee :  Intrinsic<
-  [llvm_anyfloat_ty], [LLVMMatchType<0>], [IntrNoMem, IntrSpeculatable]
+  [llvm_anyfloat_ty], [LLVMMatchType<0>], [IntrNoMem, IntrSpeculatable, IntrWillReturn]
 >;
 
 def int_r600_recipsqrt_clamped : Intrinsic<
-  [llvm_anyfloat_ty], [LLVMMatchType<0>], [IntrNoMem, IntrSpeculatable]
+  [llvm_anyfloat_ty], [LLVMMatchType<0>], [IntrNoMem, IntrSpeculatable, IntrWillReturn]
 >;
 
 def int_r600_cube : Intrinsic<
-  [llvm_v4f32_ty], [llvm_v4f32_ty], [IntrNoMem, IntrSpeculatable]
+  [llvm_v4f32_ty], [llvm_v4f32_ty], [IntrNoMem, IntrSpeculatable, IntrWillReturn]
 >;
 
 def int_r600_store_stream_output : Intrinsic<
-  [], [llvm_v4f32_ty, llvm_i32_ty, llvm_i32_ty, llvm_i32_ty], []
+  [], [llvm_v4f32_ty, llvm_i32_ty, llvm_i32_ty, llvm_i32_ty], [IntrWillReturn]
 >;
 
 class TextureIntrinsicFloatInput : Intrinsic<[llvm_v4f32_ty], [
@@ -90,7 +90,7 @@
   llvm_i32_ty,   // coord_type_y
   llvm_i32_ty,   // coord_type_z
   llvm_i32_ty],  // coord_type_w
-  [IntrNoMem]
+  [IntrNoMem, IntrWillReturn]
 >;
 
 class TextureIntrinsicInt32Input : Intrinsic<[llvm_v4i32_ty], [
@@ -104,11 +104,11 @@
     llvm_i32_ty,   // coord_type_y
     llvm_i32_ty,   // coord_type_z
     llvm_i32_ty],  // coord_type_w
-    [IntrNoMem]
+    [IntrNoMem, IntrWillReturn]
 >;
 
 def int_r600_store_swizzle :
-  Intrinsic<[], [llvm_v4f32_ty, llvm_i32_ty, llvm_i32_ty], []
+  Intrinsic<[], [llvm_v4f32_ty, llvm_i32_ty, llvm_i32_ty], [IntrWillReturn]
 >;
 
 def int_r600_tex : TextureIntrinsicFloatInput;
@@ -123,10 +123,10 @@
 def int_r600_ddy : TextureIntrinsicFloatInput;
 
 def int_r600_dot4 : Intrinsic<[llvm_float_ty],
-  [llvm_v4f32_ty, llvm_v4f32_ty], [IntrNoMem, IntrSpeculatable]
+  [llvm_v4f32_ty, llvm_v4f32_ty], [IntrNoMem, IntrSpeculatable, IntrWillReturn]
 >;
 
-def int_r600_kill : Intrinsic<[], [llvm_float_ty], []>;
+def int_r600_kill : Intrinsic<[], [llvm_float_ty], [IntrWillReturn]>;
 
 } // End TargetPrefix = "r600"
 
@@ -141,43 +141,43 @@
                                <"__builtin_amdgcn_workgroup_id">;
 
 def int_amdgcn_dispatch_ptr :
-  GCCBuiltin<"__builtin_amdgcn_dispatch_ptr">,
   Intrinsic<[LLVMQualPointerType<llvm_i8_ty, 4>], [],
-  [IntrNoMem, IntrSpeculatable]>;
+  [Align<RetIndex, 4>, IntrNoMem, IntrSpeculatable, IntrWillReturn]>;
 
 def int_amdgcn_queue_ptr :
   GCCBuiltin<"__builtin_amdgcn_queue_ptr">,
   Intrinsic<[LLVMQualPointerType<llvm_i8_ty, 4>], [],
-  [IntrNoMem, IntrSpeculatable]>;
+  [Align<RetIndex, 4>, IntrNoMem, IntrSpeculatable, IntrWillReturn]>;
 
 def int_amdgcn_kernarg_segment_ptr :
   GCCBuiltin<"__builtin_amdgcn_kernarg_segment_ptr">,
   Intrinsic<[LLVMQualPointerType<llvm_i8_ty, 4>], [],
-  [IntrNoMem, IntrSpeculatable]>;
+  [Align<RetIndex, 4>, IntrNoMem, IntrSpeculatable, IntrWillReturn]>;
 
 def int_amdgcn_implicitarg_ptr :
   GCCBuiltin<"__builtin_amdgcn_implicitarg_ptr">,
   Intrinsic<[LLVMQualPointerType<llvm_i8_ty, 4>], [],
-  [IntrNoMem, IntrSpeculatable]>;
+  [Align<RetIndex, 4>, IntrNoMem, IntrSpeculatable, IntrWillReturn]>;
 
 def int_amdgcn_groupstaticsize :
   GCCBuiltin<"__builtin_amdgcn_groupstaticsize">,
-  Intrinsic<[llvm_i32_ty], [], [IntrNoMem, IntrSpeculatable]>;
+  Intrinsic<[llvm_i32_ty], [], [IntrNoMem, IntrSpeculatable, IntrWillReturn]>;
 
 def int_amdgcn_dispatch_id :
   GCCBuiltin<"__builtin_amdgcn_dispatch_id">,
-  Intrinsic<[llvm_i64_ty], [], [IntrNoMem, IntrSpeculatable]>;
+  Intrinsic<[llvm_i64_ty], [], [IntrNoMem, IntrSpeculatable, IntrWillReturn]>;
 
 def int_amdgcn_implicit_buffer_ptr :
   GCCBuiltin<"__builtin_amdgcn_implicit_buffer_ptr">,
   Intrinsic<[LLVMQualPointerType<llvm_i8_ty, 4>], [],
-  [IntrNoMem, IntrSpeculatable]>;
+  [Align<RetIndex, 4>, IntrNoMem, IntrSpeculatable, IntrWillReturn]>;
 
 // Set EXEC to the 64-bit value given.
 // This is always moved to the beginning of the basic block.
+// FIXME: Should be mangled for wave size.
 def int_amdgcn_init_exec : Intrinsic<[],
   [llvm_i64_ty],      // 64-bit literal constant
-  [IntrConvergent, ImmArg<0>]>;
+  [IntrConvergent, ImmArg<ArgIndex<0>>]>;
 
 // Set EXEC according to a thread count packed in an SGPR input:
 //    thread_count = (input >> bitoffset) & 0x7f;
@@ -185,11 +185,11 @@
 def int_amdgcn_init_exec_from_input : Intrinsic<[],
   [llvm_i32_ty,       // 32-bit SGPR input
    llvm_i32_ty],      // bit offset of the thread count
-  [IntrConvergent]>;
+  [IntrConvergent, ImmArg<ArgIndex<1>>]>;
 
 def int_amdgcn_wavefrontsize :
   GCCBuiltin<"__builtin_amdgcn_wavefrontsize">,
-  Intrinsic<[llvm_i32_ty], [], [IntrNoMem, IntrSpeculatable]>;
+  Intrinsic<[llvm_i32_ty], [], [IntrNoMem, IntrSpeculatable, IntrWillReturn]>;
 
 
 //===----------------------------------------------------------------------===//
@@ -199,175 +199,197 @@
 // The first parameter is s_sendmsg immediate (i16),
 // the second one is copied to m0
 def int_amdgcn_s_sendmsg : GCCBuiltin<"__builtin_amdgcn_s_sendmsg">,
-  Intrinsic <[], [llvm_i32_ty, llvm_i32_ty], [ImmArg<0>]>;
+  Intrinsic <[], [llvm_i32_ty, llvm_i32_ty],
+  [ImmArg<ArgIndex<0>>, IntrNoMem, IntrHasSideEffects]>;
 def int_amdgcn_s_sendmsghalt : GCCBuiltin<"__builtin_amdgcn_s_sendmsghalt">,
-  Intrinsic <[], [llvm_i32_ty, llvm_i32_ty], [ImmArg<0>]>;
+  Intrinsic <[], [llvm_i32_ty, llvm_i32_ty],
+  [ImmArg<ArgIndex<0>>, IntrNoMem, IntrHasSideEffects]>;
 
 def int_amdgcn_s_barrier : GCCBuiltin<"__builtin_amdgcn_s_barrier">,
-  Intrinsic<[], [], [IntrConvergent]>;
+  Intrinsic<[], [], [IntrNoMem, IntrHasSideEffects, IntrConvergent, IntrWillReturn]>;
 
 def int_amdgcn_wave_barrier : GCCBuiltin<"__builtin_amdgcn_wave_barrier">,
-  Intrinsic<[], [], [IntrConvergent]>;
+  Intrinsic<[], [], [IntrNoMem, IntrHasSideEffects, IntrConvergent, IntrWillReturn]>;
 
 def int_amdgcn_s_waitcnt : GCCBuiltin<"__builtin_amdgcn_s_waitcnt">,
-  Intrinsic<[], [llvm_i32_ty], [ImmArg<0>]>;
+  Intrinsic<[], [llvm_i32_ty], [ImmArg<ArgIndex<0>>, IntrNoMem, IntrHasSideEffects, IntrWillReturn]>;
 
 def int_amdgcn_div_scale : Intrinsic<
   // 1st parameter: Numerator
   // 2nd parameter: Denominator
-  // 3rd parameter: Constant to select select between first and
-  //                second. (0 = first, 1 = second).
+  // 3rd parameter: Select quotient. Must equal Numerator or Denominator.
+  //                (0 = Denominator, 1 = Numerator).
   [llvm_anyfloat_ty, llvm_i1_ty],
   [LLVMMatchType<0>, LLVMMatchType<0>, llvm_i1_ty],
-  [IntrNoMem, IntrSpeculatable, ImmArg<2>]
+  [IntrNoMem, IntrSpeculatable, ImmArg<ArgIndex<2>>, IntrWillReturn]
 >;
 
 def int_amdgcn_div_fmas : Intrinsic<[llvm_anyfloat_ty],
   [LLVMMatchType<0>, LLVMMatchType<0>, LLVMMatchType<0>, llvm_i1_ty],
-  [IntrNoMem, IntrSpeculatable]
+  [IntrNoMem, IntrSpeculatable, IntrWillReturn]
 >;
 
 def int_amdgcn_div_fixup : Intrinsic<[llvm_anyfloat_ty],
   [LLVMMatchType<0>, LLVMMatchType<0>, LLVMMatchType<0>],
-  [IntrNoMem, IntrSpeculatable]
+  [IntrNoMem, IntrSpeculatable, IntrWillReturn]
 >;
 
+// Look Up 2.0 / pi src0 with segment select src1[4:0]
 def int_amdgcn_trig_preop : Intrinsic<
   [llvm_anyfloat_ty], [LLVMMatchType<0>, llvm_i32_ty],
-  [IntrNoMem, IntrSpeculatable]
+  [IntrNoMem, IntrSpeculatable, IntrWillReturn]
 >;
 
 def int_amdgcn_sin : Intrinsic<
   [llvm_anyfloat_ty], [LLVMMatchType<0>],
-  [IntrNoMem, IntrSpeculatable]
+  [IntrNoMem, IntrSpeculatable, IntrWillReturn]
 >;
 
 def int_amdgcn_cos : Intrinsic<
-  [llvm_anyfloat_ty], [LLVMMatchType<0>], [IntrNoMem, IntrSpeculatable]
+  [llvm_anyfloat_ty], [LLVMMatchType<0>], [IntrNoMem, IntrSpeculatable, IntrWillReturn]
 >;
 
 def int_amdgcn_log_clamp : Intrinsic<
-  [llvm_anyfloat_ty], [LLVMMatchType<0>], [IntrNoMem, IntrSpeculatable]
+  [llvm_anyfloat_ty], [LLVMMatchType<0>], [IntrNoMem, IntrSpeculatable, IntrWillReturn]
 >;
 
 def int_amdgcn_fmul_legacy : GCCBuiltin<"__builtin_amdgcn_fmul_legacy">,
   Intrinsic<[llvm_float_ty], [llvm_float_ty, llvm_float_ty],
-  [IntrNoMem, IntrSpeculatable]
+  [IntrNoMem, IntrSpeculatable, IntrWillReturn, Commutative]
+>;
+
+// Fused single-precision multiply-add with legacy behaviour for the multiply,
+// which is that +/- 0.0 * anything (even NaN or infinity) is +0.0. This is
+// intended for use on subtargets that have the v_fma_legacy_f32 and/or
+// v_fmac_legacy_f32 instructions. (Note that v_fma_legacy_f16 is unrelated and
+// has a completely different kind of legacy behaviour.)
+def int_amdgcn_fma_legacy :
+  Intrinsic<[llvm_float_ty], [llvm_float_ty, llvm_float_ty, llvm_float_ty],
+  [IntrNoMem, IntrSpeculatable, IntrWillReturn, Commutative]
 >;
 
 def int_amdgcn_rcp : Intrinsic<
-  [llvm_anyfloat_ty], [LLVMMatchType<0>], [IntrNoMem, IntrSpeculatable]
+  [llvm_anyfloat_ty], [LLVMMatchType<0>], [IntrNoMem, IntrSpeculatable, IntrWillReturn]
 >;
 
 def int_amdgcn_rcp_legacy : GCCBuiltin<"__builtin_amdgcn_rcp_legacy">,
   Intrinsic<[llvm_float_ty], [llvm_float_ty],
-  [IntrNoMem, IntrSpeculatable]
+  [IntrNoMem, IntrSpeculatable, IntrWillReturn]
+>;
+
+def int_amdgcn_sqrt :  Intrinsic<
+  [llvm_anyfloat_ty], [LLVMMatchType<0>], [IntrNoMem, IntrSpeculatable, IntrWillReturn]
 >;
 
 def int_amdgcn_rsq :  Intrinsic<
-  [llvm_anyfloat_ty], [LLVMMatchType<0>], [IntrNoMem, IntrSpeculatable]
+  [llvm_anyfloat_ty], [LLVMMatchType<0>], [IntrNoMem, IntrSpeculatable, IntrWillReturn]
 >;
 
 def int_amdgcn_rsq_legacy :  GCCBuiltin<"__builtin_amdgcn_rsq_legacy">,
   Intrinsic<
-  [llvm_float_ty], [llvm_float_ty], [IntrNoMem, IntrSpeculatable]
+  [llvm_float_ty], [llvm_float_ty], [IntrNoMem, IntrSpeculatable, IntrWillReturn]
 >;
 
+// out = 1.0 / sqrt(a) result clamped to +/- max_float.
 def int_amdgcn_rsq_clamp : Intrinsic<
-  [llvm_anyfloat_ty], [LLVMMatchType<0>], [IntrNoMem, IntrSpeculatable]>;
+  [llvm_anyfloat_ty], [LLVMMatchType<0>], [IntrNoMem, IntrSpeculatable, IntrWillReturn]>;
 
 def int_amdgcn_ldexp : Intrinsic<
   [llvm_anyfloat_ty], [LLVMMatchType<0>, llvm_i32_ty],
-  [IntrNoMem, IntrSpeculatable]
+  [IntrNoMem, IntrSpeculatable, IntrWillReturn]
 >;
 
 def int_amdgcn_frexp_mant : Intrinsic<
-  [llvm_anyfloat_ty], [LLVMMatchType<0>], [IntrNoMem, IntrSpeculatable]
+  [llvm_anyfloat_ty], [LLVMMatchType<0>], [IntrNoMem, IntrSpeculatable, IntrWillReturn]
 >;
 
 def int_amdgcn_frexp_exp : Intrinsic<
-  [llvm_anyint_ty], [llvm_anyfloat_ty], [IntrNoMem, IntrSpeculatable]
+  [llvm_anyint_ty], [llvm_anyfloat_ty], [IntrNoMem, IntrSpeculatable, IntrWillReturn]
 >;
 
 // v_fract is buggy on SI/CI. It mishandles infinities, may return 1.0
 // and always uses rtz, so is not suitable for implementing the OpenCL
 // fract function. It should be ok on VI.
 def int_amdgcn_fract : Intrinsic<
-  [llvm_anyfloat_ty], [LLVMMatchType<0>], [IntrNoMem, IntrSpeculatable]
+  [llvm_anyfloat_ty], [LLVMMatchType<0>], [IntrNoMem, IntrSpeculatable, IntrWillReturn]
 >;
 
-def int_amdgcn_cvt_pkrtz : Intrinsic<
-  [llvm_v2f16_ty], [llvm_float_ty, llvm_float_ty],
-  [IntrNoMem, IntrSpeculatable]
+def int_amdgcn_cvt_pkrtz : GCCBuiltin<"__builtin_amdgcn_cvt_pkrtz">,
+  Intrinsic<[llvm_v2f16_ty], [llvm_float_ty, llvm_float_ty],
+            [IntrNoMem, IntrSpeculatable, IntrWillReturn]
 >;
 
-def int_amdgcn_cvt_pknorm_i16 : Intrinsic<
-  [llvm_v2i16_ty], [llvm_float_ty, llvm_float_ty],
-  [IntrNoMem, IntrSpeculatable]
+def int_amdgcn_cvt_pknorm_i16 :
+  GCCBuiltin<"__builtin_amdgcn_cvt_pknorm_i16">,
+  Intrinsic<[llvm_v2i16_ty], [llvm_float_ty, llvm_float_ty],
+            [IntrNoMem, IntrSpeculatable, IntrWillReturn]
 >;
 
-def int_amdgcn_cvt_pknorm_u16 : Intrinsic<
-  [llvm_v2i16_ty], [llvm_float_ty, llvm_float_ty],
-  [IntrNoMem, IntrSpeculatable]
+def int_amdgcn_cvt_pknorm_u16 :
+  GCCBuiltin<"__builtin_amdgcn_cvt_pknorm_u16">,
+  Intrinsic<[llvm_v2i16_ty], [llvm_float_ty, llvm_float_ty],
+            [IntrNoMem, IntrSpeculatable, IntrWillReturn]
 >;
 
-def int_amdgcn_cvt_pk_i16 : Intrinsic<
+def int_amdgcn_cvt_pk_i16 :
+    GCCBuiltin<"__builtin_amdgcn_cvt_pk_i16">,
+    Intrinsic<
   [llvm_v2i16_ty], [llvm_i32_ty, llvm_i32_ty],
-  [IntrNoMem, IntrSpeculatable]
+  [IntrNoMem, IntrSpeculatable, IntrWillReturn]
 >;
 
-def int_amdgcn_cvt_pk_u16 : Intrinsic<
-  [llvm_v2i16_ty], [llvm_i32_ty, llvm_i32_ty],
-  [IntrNoMem, IntrSpeculatable]
+def int_amdgcn_cvt_pk_u16 : GCCBuiltin<"__builtin_amdgcn_cvt_pk_u16">,
+  Intrinsic<[llvm_v2i16_ty], [llvm_i32_ty, llvm_i32_ty],
+    [IntrNoMem, IntrSpeculatable, IntrWillReturn]
 >;
 
 def int_amdgcn_class : Intrinsic<
   [llvm_i1_ty], [llvm_anyfloat_ty, llvm_i32_ty],
-  [IntrNoMem, IntrSpeculatable]
+  [IntrNoMem, IntrSpeculatable, IntrWillReturn]
 >;
 
 def int_amdgcn_fmed3 : GCCBuiltin<"__builtin_amdgcn_fmed3">,
   Intrinsic<[llvm_anyfloat_ty],
     [LLVMMatchType<0>, LLVMMatchType<0>, LLVMMatchType<0>],
-    [IntrNoMem, IntrSpeculatable]
+    [IntrNoMem, IntrSpeculatable, IntrWillReturn]
 >;
 
 def int_amdgcn_cubeid : GCCBuiltin<"__builtin_amdgcn_cubeid">,
   Intrinsic<[llvm_float_ty],
     [llvm_float_ty, llvm_float_ty, llvm_float_ty],
-    [IntrNoMem, IntrSpeculatable]
+    [IntrNoMem, IntrSpeculatable, IntrWillReturn]
 >;
 
 def int_amdgcn_cubema : GCCBuiltin<"__builtin_amdgcn_cubema">,
   Intrinsic<[llvm_float_ty],
   [llvm_float_ty, llvm_float_ty, llvm_float_ty],
-  [IntrNoMem, IntrSpeculatable]
+  [IntrNoMem, IntrSpeculatable, IntrWillReturn]
 >;
 
 def int_amdgcn_cubesc : GCCBuiltin<"__builtin_amdgcn_cubesc">,
   Intrinsic<[llvm_float_ty],
     [llvm_float_ty, llvm_float_ty, llvm_float_ty],
-    [IntrNoMem, IntrSpeculatable]
+    [IntrNoMem, IntrSpeculatable, IntrWillReturn]
 >;
 
 def int_amdgcn_cubetc : GCCBuiltin<"__builtin_amdgcn_cubetc">,
   Intrinsic<[llvm_float_ty],
     [llvm_float_ty, llvm_float_ty, llvm_float_ty],
-    [IntrNoMem, IntrSpeculatable]
+    [IntrNoMem, IntrSpeculatable, IntrWillReturn]
 >;
 
 // v_ffbh_i32, as opposed to v_ffbh_u32. For v_ffbh_u32, llvm.ctlz
 // should be used.
 def int_amdgcn_sffbh :
   Intrinsic<[llvm_anyint_ty], [LLVMMatchType<0>],
-  [IntrNoMem, IntrSpeculatable]
+  [IntrNoMem, IntrSpeculatable, IntrWillReturn]
 >;
 
 // v_mad_f32|f16/v_mac_f32|f16, selected regardless of denorm support.
 def int_amdgcn_fmad_ftz :
   Intrinsic<[llvm_anyfloat_ty],
             [LLVMMatchType<0>, LLVMMatchType<0>, LLVMMatchType<0>],
-            [IntrNoMem, IntrSpeculatable]
+            [IntrNoMem, IntrSpeculatable, IntrWillReturn]
 >;
 
 // Fields should mirror atomicrmw
@@ -377,22 +399,23 @@
   llvm_i32_ty, // ordering
   llvm_i32_ty, // scope
   llvm_i1_ty], // isVolatile
-  [IntrArgMemOnly, NoCapture<0>, ImmArg<2>, ImmArg<3>, ImmArg<4>], "",
+  [IntrArgMemOnly, IntrWillReturn, NoCapture<ArgIndex<0>>,
+   ImmArg<ArgIndex<2>>, ImmArg<ArgIndex<3>>, ImmArg<ArgIndex<4>>], "",
   [SDNPMemOperand]
 >;
 
 def int_amdgcn_atomic_inc : AMDGPUAtomicIncIntrin;
 def int_amdgcn_atomic_dec : AMDGPUAtomicIncIntrin;
 
-class AMDGPULDSF32Intrin<string clang_builtin> :
-  GCCBuiltin<clang_builtin>,
-  Intrinsic<[llvm_float_ty],
-    [LLVMQualPointerType<llvm_float_ty, 3>,
-    llvm_float_ty,
+class AMDGPULDSIntrin :
+  Intrinsic<[llvm_any_ty],
+    [LLVMQualPointerType<LLVMMatchType<0>, 3>,
+    LLVMMatchType<0>,
     llvm_i32_ty, // ordering
     llvm_i32_ty, // scope
     llvm_i1_ty], // isVolatile
-    [IntrArgMemOnly, NoCapture<0>, ImmArg<2>, ImmArg<3>, ImmArg<4>]
+    [IntrArgMemOnly, IntrWillReturn, NoCapture<ArgIndex<0>>,
+     ImmArg<ArgIndex<2>>, ImmArg<ArgIndex<3>>, ImmArg<ArgIndex<4>>]
 >;
 
 // FIXME: The m0 argument should be moved after the normal arguments
@@ -409,9 +432,9 @@
                 // gfx10: bits 24-27 indicate the number of active threads/dwords
    llvm_i1_ty,  // wave release, usually set to 1
    llvm_i1_ty], // wave done, set to 1 for the last ordered instruction
-  [NoCapture<0>,
-   ImmArg<2>, ImmArg<3>, ImmArg<4>,
-   ImmArg<5>, ImmArg<6>, ImmArg<7>
+  [IntrWillReturn, NoCapture<ArgIndex<0>>,
+   ImmArg<ArgIndex<2>>, ImmArg<ArgIndex<3>>, ImmArg<ArgIndex<4>>,
+   ImmArg<ArgIndex<5>>, ImmArg<ArgIndex<6>>, ImmArg<ArgIndex<7>>
   ]
 >;
 
@@ -419,7 +442,8 @@
   [llvm_i32_ty],
   [llvm_anyptr_ty, // LDS or GDS ptr
    llvm_i1_ty], // isVolatile
-   [IntrConvergent, IntrArgMemOnly, NoCapture<0>, ImmArg<1>],
+   [IntrConvergent, IntrWillReturn, IntrArgMemOnly,
+    NoCapture<ArgIndex<0>>, ImmArg<ArgIndex<1>>],
    "",
    [SDNPMemOperand]
 >;
@@ -431,9 +455,9 @@
 def int_amdgcn_ds_append : AMDGPUDSAppendConsumedIntrinsic;
 def int_amdgcn_ds_consume : AMDGPUDSAppendConsumedIntrinsic;
 
-def int_amdgcn_ds_fadd : AMDGPULDSF32Intrin<"__builtin_amdgcn_ds_faddf">;
-def int_amdgcn_ds_fmin : AMDGPULDSF32Intrin<"__builtin_amdgcn_ds_fminf">;
-def int_amdgcn_ds_fmax : AMDGPULDSF32Intrin<"__builtin_amdgcn_ds_fmaxf">;
+def int_amdgcn_ds_fadd : AMDGPULDSIntrin;
+def int_amdgcn_ds_fmin : AMDGPULDSIntrin;
+def int_amdgcn_ds_fmax : AMDGPULDSIntrin;
 
 } // TargetPrefix = "amdgcn"
 
@@ -530,7 +554,7 @@
 
   // {offset} {bias} {z-compare}
   list<AMDGPUArg> ExtraAddrArgs = extra_addr;
-  bit Gradients = 0;
+  bit Gradients = false;
 
   // Name of the {lod} or {clamp} argument that is appended to the coordinates,
   // if any.
@@ -570,7 +594,7 @@
     defm AMDGPUSample : AMDGPUSampleHelper_Compare<"_LZ", "_lz", []>;
   }
 
-  let Gradients = 1 in {
+  let Gradients = true in {
     defm AMDGPUSample : AMDGPUSampleHelper_Clamp<"_D", "_d", []>;
     defm AMDGPUSample : AMDGPUSampleHelper_Clamp<"_CD", "_cd", []>;
   }
@@ -584,13 +608,13 @@
   AMDGPUDimProps Dim = dim;
   string OpMod = opmod; // the corresponding instruction is named IMAGE_OpMod
 
-  // These are entended to be overwritten by subclasses
-  bit IsSample = 0;
-  bit IsAtomic = 0;
+  // These are intended to be overwritten by subclasses
+  bit IsSample = false;
+  bit IsAtomic = false;
   list<LLVMType> RetTypes = [];
   list<AMDGPUArg> DataArgs = [];
   list<AMDGPUArg> ExtraAddrArgs = [];
-  bit Gradients = 0;
+  bit Gradients = false;
   string LodClampMip = "";
 
   int NumRetAndDataAnyTypes =
@@ -601,7 +625,7 @@
     arglistconcat<[ExtraAddrArgs,
                    !if(Gradients, dim.GradientArgs, []),
                    !listconcat(!if(IsSample, dim.CoordSliceArgs, dim.CoordSliceIntArgs),
-                               !if(!eq(LodClampMip, ""),
+                               !if(!empty(LodClampMip),
                                    []<AMDGPUArg>,
                                    [AMDGPUArg<LLVMMatchType<0>, LodClampMip>]))],
                   NumRetAndDataAnyTypes>.ret;
@@ -631,7 +655,7 @@
 class AMDGPUDimSampleProfile<string opmod,
                              AMDGPUDimProps dim,
                              AMDGPUSampleVariant sample> : AMDGPUDimProfile<opmod, dim> {
-  let IsSample = 1;
+  let IsSample = true;
   let RetTypes = [llvm_any_ty];
   let ExtraAddrArgs = sample.ExtraAddrArgs;
   let Gradients = sample.Gradients;
@@ -642,7 +666,7 @@
                                AMDGPUDimProps dim,
                                list<LLVMType> retty,
                                list<AMDGPUArg> dataargs,
-                               bit Mip = 0> : AMDGPUDimProfile<opmod, dim> {
+                               bit Mip = false> : AMDGPUDimProfile<opmod, dim> {
   let RetTypes = retty;
   let DataArgs = dataargs;
   let LodClampMip = !if(Mip, "mip", "");
@@ -653,7 +677,7 @@
                              list<AMDGPUArg> dataargs> : AMDGPUDimProfile<opmod, dim> {
   let RetTypes = [llvm_anyint_ty];
   let DataArgs = dataargs;
-  let IsAtomic = 1;
+  let IsAtomic = true;
 }
 
 class AMDGPUDimGetResInfoProfile<AMDGPUDimProps dim> : AMDGPUDimProfile<"GET_RESINFO", dim> {
@@ -666,13 +690,23 @@
 // Helper class for figuring out image intrinsic argument indexes.
 class AMDGPUImageDimIntrinsicEval<AMDGPUDimProfile P_> {
   int NumDataArgs = !size(P_.DataArgs);
-  int NumDmaskArgs = !if(P_.IsAtomic, 0, 1);
+  int NumDmaskArgs = !not(P_.IsAtomic);
+  int NumExtraAddrArgs = !size(P_.ExtraAddrArgs);
   int NumVAddrArgs = !size(P_.AddrArgs);
+  int NumGradientArgs = !if(P_.Gradients, !size(P_.Dim.GradientArgs), 0);
+  int NumCoordArgs = !if(P_.IsSample, !size(P_.Dim.CoordSliceArgs), !size(P_.Dim.CoordSliceIntArgs));
   int NumRSrcArgs = 1;
   int NumSampArgs = !if(P_.IsSample, 2, 0);
   int DmaskArgIndex = NumDataArgs;
-  int UnormArgIndex = !add(NumDataArgs, NumDmaskArgs, NumVAddrArgs, NumRSrcArgs, 1);
-  int TexFailCtrlArgIndex = !add(NumDataArgs, NumDmaskArgs, NumVAddrArgs, NumRSrcArgs, NumSampArgs);
+  int VAddrArgIndex = !add(DmaskArgIndex, NumDmaskArgs);
+  int GradientArgIndex = !add(VAddrArgIndex, NumExtraAddrArgs);
+  int CoordArgIndex = !add(GradientArgIndex, NumGradientArgs);
+  int LodArgIndex = !add(VAddrArgIndex, NumVAddrArgs, -1);
+  int MipArgIndex = LodArgIndex;
+  int RsrcArgIndex = !add(VAddrArgIndex, NumVAddrArgs);
+  int SampArgIndex = !add(RsrcArgIndex, NumRSrcArgs);
+  int UnormArgIndex = !add(SampArgIndex, 1);
+  int TexFailCtrlArgIndex = !add(SampArgIndex, NumSampArgs);
   int CachePolicyArgIndex = !add(TexFailCtrlArgIndex, 1);
 }
 
@@ -690,11 +724,15 @@
                         llvm_i1_ty], []),        // unorm(imm)
       [llvm_i32_ty,                              // texfailctrl(imm; bit 0 = tfe, bit 1 = lwe)
        llvm_i32_ty]),                            // cachepolicy(imm; bit 0 = glc, bit 1 = slc, bit 2 = dlc)
+
      !listconcat(props,
-          !if(P_.IsAtomic, [], [ImmArg<AMDGPUImageDimIntrinsicEval<P_>.DmaskArgIndex>]),
-          !if(P_.IsSample, [ImmArg<AMDGPUImageDimIntrinsicEval<P_>.UnormArgIndex>], []),
-          [ImmArg<AMDGPUImageDimIntrinsicEval<P_>.TexFailCtrlArgIndex>,
-           ImmArg<AMDGPUImageDimIntrinsicEval<P_>.CachePolicyArgIndex>]),
+          !if(P_.IsAtomic, [], [ImmArg<ArgIndex<AMDGPUImageDimIntrinsicEval<P_>.DmaskArgIndex>>]),
+          !if(P_.IsSample, [ImmArg<ArgIndex<AMDGPUImageDimIntrinsicEval<P_>.UnormArgIndex>>], []),
+          [IntrWillReturn],
+          [ImmArg<ArgIndex<AMDGPUImageDimIntrinsicEval<P_>.TexFailCtrlArgIndex>>,
+           ImmArg<ArgIndex<AMDGPUImageDimIntrinsicEval<P_>.CachePolicyArgIndex>>]),
+
+
       "", sdnodeprops>,
   AMDGPURsrcIntrinsic<!add(!size(P_.DataArgs), !size(P_.AddrTypes),
                            !if(P_.IsAtomic, 0, 1)), 1> {
@@ -719,7 +757,7 @@
                                             list<AMDGPUArg> dataargs,
                                             list<IntrinsicProperty> props,
                                             list<SDNodeProperty> sdnodeprops,
-                                            bit Mip = 0> {
+                                            bit Mip = false> {
     foreach dim = AMDGPUDims.NoMsaa in {
       def !strconcat(NAME, "_", dim.Name)
         : AMDGPUImageDimIntrinsic<
@@ -733,7 +771,7 @@
                                          list<AMDGPUArg> dataargs,
                                          list<IntrinsicProperty> props,
                                          list<SDNodeProperty> sdnodeprops,
-                                         bit Mip = 0> {
+                                         bit Mip = false> {
     foreach dim = AMDGPUDims.All in {
       def !strconcat(NAME, "_", dim.Name)
         : AMDGPUImageDimIntrinsic<
@@ -748,22 +786,27 @@
       AMDGPUImageDMaskIntrinsic;
   defm int_amdgcn_image_load_mip
     : AMDGPUImageDimIntrinsicsNoMsaa<"LOAD_MIP", [llvm_any_ty], [],
-                                     [IntrReadMem], [SDNPMemOperand], 1>,
+                                     [IntrReadMem, IntrWillReturn], [SDNPMemOperand], 1>,
       AMDGPUImageDMaskIntrinsic;
 
   defm int_amdgcn_image_store : AMDGPUImageDimIntrinsicsAll<
               "STORE", [], [AMDGPUArg<llvm_anyfloat_ty, "vdata">],
-              [IntrWriteMem], [SDNPMemOperand]>;
+              [IntrWriteMem, IntrWillReturn], [SDNPMemOperand]>;
   defm int_amdgcn_image_store_mip : AMDGPUImageDimIntrinsicsNoMsaa<
               "STORE_MIP", [], [AMDGPUArg<llvm_anyfloat_ty, "vdata">],
-              [IntrWriteMem], [SDNPMemOperand], 1>;
+              [IntrWriteMem, IntrWillReturn], [SDNPMemOperand], 1>;
+
+  defm int_amdgcn_image_msaa_load
+    : AMDGPUImageDimIntrinsicsAll<"MSAA_LOAD", [llvm_any_ty], [], [IntrReadMem],
+                                  [SDNPMemOperand]>,
+      AMDGPUImageDMaskIntrinsic;
 
   //////////////////////////////////////////////////////////////////////////
   // sample and getlod intrinsics
   //////////////////////////////////////////////////////////////////////////
   multiclass AMDGPUImageDimSampleDims<string opmod,
                                       AMDGPUSampleVariant sample,
-                                      bit NoMem = 0> {
+                                      bit NoMem = false> {
     foreach dim = AMDGPUDims.NoMsaa in {
       def !strconcat(NAME, "_", dim.Name) : AMDGPUImageDimIntrinsic<
           AMDGPUDimSampleProfile<opmod, dim, sample>,
@@ -831,9 +874,6 @@
   defm int_amdgcn_image_atomic_and : AMDGPUImageDimAtomic<"ATOMIC_AND">;
   defm int_amdgcn_image_atomic_or : AMDGPUImageDimAtomic<"ATOMIC_OR">;
   defm int_amdgcn_image_atomic_xor : AMDGPUImageDimAtomic<"ATOMIC_XOR">;
-
-  // TODO: INC/DEC are weird: they seem to have a vdata argument in hardware,
-  //       even though it clearly shouldn't be needed
   defm int_amdgcn_image_atomic_inc : AMDGPUImageDimAtomic<"ATOMIC_INC">;
   defm int_amdgcn_image_atomic_dec : AMDGPUImageDimAtomic<"ATOMIC_DEC">;
 
@@ -850,16 +890,17 @@
 
 defset list<AMDGPURsrcIntrinsic> AMDGPUBufferIntrinsics = {
 
-class AMDGPUBufferLoad : Intrinsic <
-  [llvm_any_ty],
+class AMDGPUBufferLoad<LLVMType data_ty = llvm_any_ty> : Intrinsic <
+  [data_ty],
   [llvm_v4i32_ty,     // rsrc(SGPR)
    llvm_i32_ty,       // vindex(VGPR)
    llvm_i32_ty,       // offset(SGPR/VGPR/imm)
    llvm_i1_ty,        // glc(imm)
    llvm_i1_ty],       // slc(imm)
-  [IntrReadMem, ImmArg<3>, ImmArg<4>], "", [SDNPMemOperand]>,
+  [IntrReadMem, IntrWillReturn,
+   ImmArg<ArgIndex<3>>, ImmArg<ArgIndex<4>>], "", [SDNPMemOperand]>,
   AMDGPURsrcIntrinsic<0>;
-def int_amdgcn_buffer_load_format : AMDGPUBufferLoad;
+def int_amdgcn_buffer_load_format : AMDGPUBufferLoad<llvm_anyfloat_ty>;
 def int_amdgcn_buffer_load : AMDGPUBufferLoad;
 
 def int_amdgcn_s_buffer_load : Intrinsic <
@@ -867,20 +908,21 @@
   [llvm_v4i32_ty,     // rsrc(SGPR)
    llvm_i32_ty,       // byte offset(SGPR/imm)
    llvm_i32_ty],      // cachepolicy(imm; bit 0 = glc, bit 2 = dlc)
-  [IntrNoMem, ImmArg<2>]>,
+  [IntrNoMem, IntrWillReturn, ImmArg<ArgIndex<2>>]>,
   AMDGPURsrcIntrinsic<0>;
 
-class AMDGPUBufferStore : Intrinsic <
+class AMDGPUBufferStore<LLVMType data_ty = llvm_any_ty> : Intrinsic <
   [],
-  [llvm_any_ty,       // vdata(VGPR)
+  [data_ty,          // vdata(VGPR)
    llvm_v4i32_ty,     // rsrc(SGPR)
    llvm_i32_ty,       // vindex(VGPR)
    llvm_i32_ty,       // offset(SGPR/VGPR/imm)
    llvm_i1_ty,        // glc(imm)
    llvm_i1_ty],       // slc(imm)
-  [IntrWriteMem, ImmArg<4>, ImmArg<5>], "", [SDNPMemOperand]>,
+  [IntrWriteMem, IntrWillReturn,
+   ImmArg<ArgIndex<4>>, ImmArg<ArgIndex<5>>], "", [SDNPMemOperand]>,
   AMDGPURsrcIntrinsic<1>;
-def int_amdgcn_buffer_store_format : AMDGPUBufferStore;
+def int_amdgcn_buffer_store_format : AMDGPUBufferStore<llvm_anyfloat_ty>;
 def int_amdgcn_buffer_store : AMDGPUBufferStore;
 
 // New buffer intrinsics with separate raw and struct variants.  The raw
@@ -890,62 +932,74 @@
 // and swizzling changes depending on whether idxen is set in the instruction.
 // These new instrinsics also keep the offset and soffset arguments separate as
 // they behave differently in bounds checking and swizzling.
-class AMDGPURawBufferLoad : Intrinsic <
-  [llvm_any_ty],
+class AMDGPURawBufferLoad<LLVMType data_ty = llvm_any_ty> : Intrinsic <
+  [data_ty],
   [llvm_v4i32_ty,     // rsrc(SGPR)
    llvm_i32_ty,       // offset(VGPR/imm, included in bounds checking and swizzling)
    llvm_i32_ty,       // soffset(SGPR/imm, excluded from bounds checking and swizzling)
-   llvm_i32_ty],      // cachepolicy(imm; bit 0 = glc, bit 1 = slc, bit 2 = dlc on gfx10+)
-  [IntrReadMem, ImmArg<3>], "", [SDNPMemOperand]>,
+   llvm_i32_ty],      // auxiliary data (imm, cachepolicy     (bit 0 = glc,
+                      //                                       bit 1 = slc,
+                      //                                       bit 2 = dlc on gfx10+),
+                      //                      swizzled buffer (bit 3 = swz))
+  [IntrReadMem, IntrWillReturn, ImmArg<ArgIndex<3>>], "", [SDNPMemOperand]>,
   AMDGPURsrcIntrinsic<0>;
-def int_amdgcn_raw_buffer_load_format : AMDGPURawBufferLoad;
+def int_amdgcn_raw_buffer_load_format : AMDGPURawBufferLoad<llvm_anyfloat_ty>;
 def int_amdgcn_raw_buffer_load : AMDGPURawBufferLoad;
 
-class AMDGPUStructBufferLoad : Intrinsic <
-  [llvm_any_ty],
+class AMDGPUStructBufferLoad<LLVMType data_ty = llvm_any_ty> : Intrinsic <
+  [data_ty],
   [llvm_v4i32_ty,     // rsrc(SGPR)
    llvm_i32_ty,       // vindex(VGPR)
    llvm_i32_ty,       // offset(VGPR/imm, included in bounds checking and swizzling)
    llvm_i32_ty,       // soffset(SGPR/imm, excluded from bounds checking and swizzling)
-   llvm_i32_ty],      // cachepolicy(imm; bit 0 = glc, bit 1 = slc, bit 2 = dlc on gfx10+)
-  [IntrReadMem, ImmArg<4>], "", [SDNPMemOperand]>,
+   llvm_i32_ty],      // auxiliary data (imm, cachepolicy     (bit 0 = glc,
+                      //                                       bit 1 = slc,
+                      //                                       bit 2 = dlc on gfx10+),
+                      //                      swizzled buffer (bit 3 = swz))
+  [IntrReadMem, IntrWillReturn, ImmArg<ArgIndex<4>>], "", [SDNPMemOperand]>,
   AMDGPURsrcIntrinsic<0>;
 def int_amdgcn_struct_buffer_load_format : AMDGPUStructBufferLoad;
 def int_amdgcn_struct_buffer_load : AMDGPUStructBufferLoad;
 
-class AMDGPURawBufferStore : Intrinsic <
+class AMDGPURawBufferStore<LLVMType data_ty = llvm_any_ty> : Intrinsic <
   [],
-  [llvm_any_ty,       // vdata(VGPR)
+  [data_ty,           // vdata(VGPR)
    llvm_v4i32_ty,     // rsrc(SGPR)
    llvm_i32_ty,       // offset(VGPR/imm, included in bounds checking and swizzling)
    llvm_i32_ty,       // soffset(SGPR/imm, excluded from bounds checking and swizzling)
-   llvm_i32_ty],      // cachepolicy(imm; bit 0 = glc, bit 1 = slc, bit 2 = dlc on gfx10+)
-  [IntrWriteMem, ImmArg<4>], "", [SDNPMemOperand]>,
+   llvm_i32_ty],      // auxiliary data (imm, cachepolicy     (bit 0 = glc,
+                      //                                       bit 1 = slc,
+                      //                                       bit 2 = dlc on gfx10+),
+                      //                      swizzled buffer (bit 3 = swz))
+  [IntrWriteMem, IntrWillReturn, ImmArg<ArgIndex<4>>], "", [SDNPMemOperand]>,
   AMDGPURsrcIntrinsic<1>;
-def int_amdgcn_raw_buffer_store_format : AMDGPURawBufferStore;
+def int_amdgcn_raw_buffer_store_format : AMDGPURawBufferStore<llvm_anyfloat_ty>;
 def int_amdgcn_raw_buffer_store : AMDGPURawBufferStore;
 
-class AMDGPUStructBufferStore : Intrinsic <
+class AMDGPUStructBufferStore<LLVMType data_ty = llvm_any_ty> : Intrinsic <
   [],
-  [llvm_any_ty,       // vdata(VGPR)
+  [data_ty,           // vdata(VGPR)
    llvm_v4i32_ty,     // rsrc(SGPR)
    llvm_i32_ty,       // vindex(VGPR)
    llvm_i32_ty,       // offset(VGPR/imm, included in bounds checking and swizzling)
    llvm_i32_ty,       // soffset(SGPR/imm, excluded from bounds checking and swizzling)
-   llvm_i32_ty],      // cachepolicy(imm; bit 0 = glc, bit 1 = slc, bit 2 = dlc on gfx10+)
-  [IntrWriteMem, ImmArg<5>], "", [SDNPMemOperand]>,
+   llvm_i32_ty],      // auxiliary data (imm, cachepolicy     (bit 0 = glc,
+                      //                                       bit 1 = slc,
+                      //                                       bit 2 = dlc on gfx10+),
+                      //                      swizzled buffer (bit 3 = swz))
+  [IntrWriteMem, IntrWillReturn, ImmArg<ArgIndex<5>>], "", [SDNPMemOperand]>,
   AMDGPURsrcIntrinsic<1>;
 def int_amdgcn_struct_buffer_store_format : AMDGPUStructBufferStore;
 def int_amdgcn_struct_buffer_store : AMDGPUStructBufferStore;
 
-class AMDGPURawBufferAtomic : Intrinsic <
-  [llvm_anyint_ty],
-  [LLVMMatchType<0>,  // vdata(VGPR)
+class AMDGPURawBufferAtomic<LLVMType data_ty = llvm_any_ty, bit NoRtn = false> : Intrinsic <
+  !if(NoRtn, [], [data_ty]),
+  [!if(NoRtn, data_ty, LLVMMatchType<0>),  // vdata(VGPR)
    llvm_v4i32_ty,     // rsrc(SGPR)
    llvm_i32_ty,       // offset(VGPR/imm, included in bounds checking and swizzling)
    llvm_i32_ty,       // soffset(SGPR/imm, excluded from bounds checking and swizzling)
    llvm_i32_ty],      // cachepolicy(imm; bit 1 = slc)
-  [ImmArg<4>], "", [SDNPMemOperand]>,
+  [ImmArg<ArgIndex<4>>, IntrWillReturn], "", [SDNPMemOperand]>,
   AMDGPURsrcIntrinsic<1, 0>;
 def int_amdgcn_raw_buffer_atomic_swap : AMDGPURawBufferAtomic;
 def int_amdgcn_raw_buffer_atomic_add : AMDGPURawBufferAtomic;
@@ -957,6 +1011,8 @@
 def int_amdgcn_raw_buffer_atomic_and : AMDGPURawBufferAtomic;
 def int_amdgcn_raw_buffer_atomic_or : AMDGPURawBufferAtomic;
 def int_amdgcn_raw_buffer_atomic_xor : AMDGPURawBufferAtomic;
+def int_amdgcn_raw_buffer_atomic_inc : AMDGPURawBufferAtomic;
+def int_amdgcn_raw_buffer_atomic_dec : AMDGPURawBufferAtomic;
 def int_amdgcn_raw_buffer_atomic_cmpswap : Intrinsic<
   [llvm_anyint_ty],
   [LLVMMatchType<0>,  // src(VGPR)
@@ -965,18 +1021,21 @@
    llvm_i32_ty,       // offset(VGPR/imm, included in bounds checking and swizzling)
    llvm_i32_ty,       // soffset(SGPR/imm, excluded from bounds checking and swizzling)
    llvm_i32_ty],      // cachepolicy(imm; bit 1 = slc)
-  [ImmArg<5>], "", [SDNPMemOperand]>,
+  [ImmArg<ArgIndex<5>>, IntrWillReturn], "", [SDNPMemOperand]>,
   AMDGPURsrcIntrinsic<2, 0>;
 
-class AMDGPUStructBufferAtomic : Intrinsic <
-  [llvm_anyint_ty],
-  [LLVMMatchType<0>,  // vdata(VGPR)
+// gfx908 intrinsic
+def int_amdgcn_raw_buffer_atomic_fadd : AMDGPURawBufferAtomic<llvm_anyfloat_ty>;
+
+class AMDGPUStructBufferAtomic<LLVMType data_ty = llvm_any_ty, bit NoRtn = false> : Intrinsic <
+  !if(NoRtn, [], [data_ty]),
+  [!if(NoRtn, data_ty, LLVMMatchType<0>),  // vdata(VGPR)
    llvm_v4i32_ty,     // rsrc(SGPR)
    llvm_i32_ty,       // vindex(VGPR)
    llvm_i32_ty,       // offset(VGPR/imm, included in bounds checking and swizzling)
    llvm_i32_ty,       // soffset(SGPR/imm, excluded from bounds checking and swizzling)
    llvm_i32_ty],      // cachepolicy(imm; bit 1 = slc)
-  [ImmArg<5>], "", [SDNPMemOperand]>,
+  [ImmArg<ArgIndex<5>>, IntrWillReturn], "", [SDNPMemOperand]>,
   AMDGPURsrcIntrinsic<1, 0>;
 def int_amdgcn_struct_buffer_atomic_swap : AMDGPUStructBufferAtomic;
 def int_amdgcn_struct_buffer_atomic_add : AMDGPUStructBufferAtomic;
@@ -988,6 +1047,8 @@
 def int_amdgcn_struct_buffer_atomic_and : AMDGPUStructBufferAtomic;
 def int_amdgcn_struct_buffer_atomic_or : AMDGPUStructBufferAtomic;
 def int_amdgcn_struct_buffer_atomic_xor : AMDGPUStructBufferAtomic;
+def int_amdgcn_struct_buffer_atomic_inc : AMDGPUStructBufferAtomic;
+def int_amdgcn_struct_buffer_atomic_dec : AMDGPUStructBufferAtomic;
 def int_amdgcn_struct_buffer_atomic_cmpswap : Intrinsic<
   [llvm_anyint_ty],
   [LLVMMatchType<0>,  // src(VGPR)
@@ -997,9 +1058,13 @@
    llvm_i32_ty,       // offset(VGPR/imm, included in bounds checking and swizzling)
    llvm_i32_ty,       // soffset(SGPR/imm, excluded from bounds checking and swizzling)
    llvm_i32_ty],      // cachepolicy(imm; bit 1 = slc)
-  [ImmArg<6>], "", [SDNPMemOperand]>,
+  [ImmArg<ArgIndex<6>>, IntrWillReturn], "", [SDNPMemOperand]>,
   AMDGPURsrcIntrinsic<2, 0>;
 
+// gfx908 intrinsic
+def int_amdgcn_struct_buffer_atomic_fadd : AMDGPUStructBufferAtomic<llvm_anyfloat_ty>;
+
+
 // Obsolescent tbuffer intrinsics.
 def int_amdgcn_tbuffer_load : Intrinsic <
     [llvm_any_ty],    // overloaded for types f32/i32, v2f32/v2i32, v4f32/v4i32
@@ -1012,8 +1077,9 @@
      llvm_i32_ty,     // nfmt(imm)
      llvm_i1_ty,     // glc(imm)
      llvm_i1_ty],    // slc(imm)
-    [IntrReadMem, ImmArg<4>, ImmArg<5>, ImmArg<6>,
-     ImmArg<7>, ImmArg<8>], "", [SDNPMemOperand]>,
+    [IntrReadMem, IntrWillReturn,
+     ImmArg<ArgIndex<4>>, ImmArg<ArgIndex<5>>, ImmArg<ArgIndex<6>>,
+     ImmArg<ArgIndex<7>>, ImmArg<ArgIndex<8>>], "", [SDNPMemOperand]>,
   AMDGPURsrcIntrinsic<0>;
 
 def int_amdgcn_tbuffer_store : Intrinsic <
@@ -1028,8 +1094,9 @@
      llvm_i32_ty,    // nfmt(imm)
      llvm_i1_ty,     // glc(imm)
      llvm_i1_ty],    // slc(imm)
-    [IntrWriteMem, ImmArg<5>, ImmArg<6>, ImmArg<7>,
-     ImmArg<8>, ImmArg<9>], "", [SDNPMemOperand]>,
+    [IntrWriteMem, IntrWillReturn, ImmArg<ArgIndex<5>>,
+     ImmArg<ArgIndex<6>>, ImmArg<ArgIndex<7>>,
+     ImmArg<ArgIndex<8>>, ImmArg<ArgIndex<9>>], "", [SDNPMemOperand]>,
   AMDGPURsrcIntrinsic<1>;
 
 // New tbuffer intrinsics, with:
@@ -1042,8 +1109,12 @@
      llvm_i32_ty,     // offset(VGPR/imm, included in bounds checking and swizzling)
      llvm_i32_ty,     // soffset(SGPR/imm, excluded from bounds checking and swizzling)
      llvm_i32_ty,     // format(imm; bits 3..0 = dfmt, bits 6..4 = nfmt)
-     llvm_i32_ty],    // cachepolicy(imm; bit 0 = glc, bit 1 = slc, bit 2 = dlc on gfx10+)
-    [IntrReadMem, ImmArg<3>, ImmArg<4>], "", [SDNPMemOperand]>,
+     llvm_i32_ty],    // auxiliary data (imm, cachepolicy     (bit 0 = glc,
+                      //                                       bit 1 = slc,
+                      //                                       bit 2 = dlc on gfx10+),
+                      //                      swizzled buffer (bit 3 = swz))
+    [IntrReadMem, IntrWillReturn,
+     ImmArg<ArgIndex<3>>, ImmArg<ArgIndex<4>>], "", [SDNPMemOperand]>,
   AMDGPURsrcIntrinsic<0>;
 
 def int_amdgcn_raw_tbuffer_store : Intrinsic <
@@ -1053,8 +1124,12 @@
      llvm_i32_ty,    // offset(VGPR/imm, included in bounds checking and swizzling)
      llvm_i32_ty,    // soffset(SGPR/imm, excluded from bounds checking and swizzling)
      llvm_i32_ty,    // format(imm; bits 3..0 = dfmt, bits 6..4 = nfmt)
-     llvm_i32_ty],   // cachepolicy(imm; bit 0 = glc, bit 1 = slc, bit 2 = dlc on gfx10+)
-    [IntrWriteMem, ImmArg<4>, ImmArg<5>], "", [SDNPMemOperand]>,
+     llvm_i32_ty],   // auxiliary data (imm, cachepolicy     (bit 0 = glc,
+                     //                                       bit 1 = slc,
+                     //                                       bit 2 = dlc on gfx10+),
+                     //                      swizzled buffer (bit 3 = swz))
+    [IntrWriteMem, IntrWillReturn,
+     ImmArg<ArgIndex<4>>, ImmArg<ArgIndex<5>>], "", [SDNPMemOperand]>,
   AMDGPURsrcIntrinsic<1>;
 
 def int_amdgcn_struct_tbuffer_load : Intrinsic <
@@ -1064,8 +1139,12 @@
      llvm_i32_ty,     // offset(VGPR/imm, included in bounds checking and swizzling)
      llvm_i32_ty,     // soffset(SGPR/imm, excluded from bounds checking and swizzling)
      llvm_i32_ty,     // format(imm; bits 3..0 = dfmt, bits 6..4 = nfmt)
-     llvm_i32_ty],    // cachepolicy(imm; bit 0 = glc, bit 1 = slc, bit 2 = dlc on gfx10+)
-    [IntrReadMem, ImmArg<4>, ImmArg<5>], "", [SDNPMemOperand]>,
+     llvm_i32_ty],    // auxiliary data (imm, cachepolicy     (bit 0 = glc,
+                      //                                       bit 1 = slc,
+                      //                                       bit 2 = dlc on gfx10+),
+                      //                      swizzled buffer (bit 3 = swz))
+    [IntrReadMem, IntrWillReturn,
+     ImmArg<ArgIndex<4>>, ImmArg<ArgIndex<5>>], "", [SDNPMemOperand]>,
   AMDGPURsrcIntrinsic<0>;
 
 def int_amdgcn_struct_tbuffer_store : Intrinsic <
@@ -1076,8 +1155,12 @@
      llvm_i32_ty,    // offset(VGPR/imm, included in bounds checking and swizzling)
      llvm_i32_ty,    // soffset(SGPR/imm, excluded from bounds checking and swizzling)
      llvm_i32_ty,    // format(imm; bits 3..0 = dfmt, bits 6..4 = nfmt)
-     llvm_i32_ty],   // cachepolicy(imm; bit 0 = glc, bit 1 = slc, bit 2 = dlc on gfx10+)
-    [IntrWriteMem, ImmArg<5>, ImmArg<6>], "", [SDNPMemOperand]>,
+     llvm_i32_ty],   // auxiliary data (imm, cachepolicy     (bit 0 = glc,
+                     //                                       bit 1 = slc,
+                     //                                       bit 2 = dlc on gfx10+),
+                     //                      swizzled buffer (bit 3 = swz))
+    [IntrWriteMem, IntrWillReturn,
+     ImmArg<ArgIndex<5>>, ImmArg<ArgIndex<6>>], "", [SDNPMemOperand]>,
   AMDGPURsrcIntrinsic<1>;
 
 class AMDGPUBufferAtomic : Intrinsic <
@@ -1087,7 +1170,7 @@
    llvm_i32_ty,       // vindex(VGPR)
    llvm_i32_ty,       // offset(SGPR/VGPR/imm)
    llvm_i1_ty],       // slc(imm)
-  [ImmArg<4>], "", [SDNPMemOperand]>,
+  [ImmArg<ArgIndex<4>>, IntrWillReturn], "", [SDNPMemOperand]>,
   AMDGPURsrcIntrinsic<1, 0>;
 def int_amdgcn_buffer_atomic_swap : AMDGPUBufferAtomic;
 def int_amdgcn_buffer_atomic_add : AMDGPUBufferAtomic;
@@ -1107,9 +1190,23 @@
    llvm_i32_ty,       // vindex(VGPR)
    llvm_i32_ty,       // offset(SGPR/VGPR/imm)
    llvm_i1_ty],       // slc(imm)
-  [ImmArg<5>], "", [SDNPMemOperand]>,
+  [ImmArg<ArgIndex<5>>, IntrWillReturn], "", [SDNPMemOperand]>,
   AMDGPURsrcIntrinsic<2, 0>;
 
+def int_amdgcn_buffer_atomic_csub : AMDGPUBufferAtomic;
+
+class AMDGPUBufferAtomicFP : Intrinsic <
+  [llvm_anyfloat_ty],
+  [LLVMMatchType<0>, // vdata(VGPR)
+   llvm_v4i32_ty,    // rsrc(SGPR)
+   llvm_i32_ty,      // vindex(VGPR)
+   llvm_i32_ty,      // offset(SGPR/VGPR/imm)
+   llvm_i1_ty],      // slc(imm)
+  [ImmArg<ArgIndex<4>>], "", [SDNPMemOperand]>,
+  AMDGPURsrcIntrinsic<1, 0>;
+
+// Legacy form of the intrinsic. raw and struct forms should be preferred.
+def int_amdgcn_buffer_atomic_fadd : AMDGPUBufferAtomicFP;
 } // defset AMDGPUBufferIntrinsics
 
 // Uses that do not set the done bit should set IntrWriteMem on the
@@ -1124,7 +1221,9 @@
   llvm_i1_ty,        // done
   llvm_i1_ty         // vm
   ],
-  [ImmArg<0>, ImmArg<1>, ImmArg<6>, ImmArg<7>, IntrInaccessibleMemOnly]
+  [ImmArg<ArgIndex<0>>, ImmArg<ArgIndex<1>>, ImmArg<ArgIndex<6>>,
+   ImmArg<ArgIndex<7>>, IntrWriteMem, IntrInaccessibleMemOnly,
+   IntrWillReturn]
 >;
 
 // exp with compr bit set.
@@ -1135,44 +1234,60 @@
   LLVMMatchType<0>,  // src1
   llvm_i1_ty,        // done
   llvm_i1_ty],       // vm
-  [ImmArg<0>, ImmArg<1>, ImmArg<4>, ImmArg<5>, IntrInaccessibleMemOnly]
+  [ImmArg<ArgIndex<0>>, ImmArg<ArgIndex<1>>, ImmArg<ArgIndex<4>>,
+   ImmArg<ArgIndex<5>>, IntrWriteMem, IntrInaccessibleMemOnly,
+   IntrWillReturn]
 >;
 
 def int_amdgcn_buffer_wbinvl1_sc :
   GCCBuiltin<"__builtin_amdgcn_buffer_wbinvl1_sc">,
-  Intrinsic<[], [], []>;
+  Intrinsic<[], [], [IntrNoMem, IntrHasSideEffects, IntrWillReturn]>;
 
 def int_amdgcn_buffer_wbinvl1 :
   GCCBuiltin<"__builtin_amdgcn_buffer_wbinvl1">,
-  Intrinsic<[], [], []>;
+  Intrinsic<[], [], [IntrNoMem, IntrHasSideEffects, IntrWillReturn]>;
 
 def int_amdgcn_s_dcache_inv :
   GCCBuiltin<"__builtin_amdgcn_s_dcache_inv">,
-  Intrinsic<[], [], []>;
+  Intrinsic<[], [], [IntrNoMem, IntrHasSideEffects, IntrWillReturn]>;
 
 def int_amdgcn_s_memtime :
   GCCBuiltin<"__builtin_amdgcn_s_memtime">,
-  Intrinsic<[llvm_i64_ty], []>;
+  Intrinsic<[llvm_i64_ty], [], [IntrWillReturn]>;
 
 def int_amdgcn_s_sleep :
   GCCBuiltin<"__builtin_amdgcn_s_sleep">,
-  Intrinsic<[], [llvm_i32_ty], [ImmArg<0>]> {
+  Intrinsic<[], [llvm_i32_ty], [ImmArg<ArgIndex<0>>, IntrNoMem,
+                                IntrHasSideEffects, IntrWillReturn]> {
 }
 
 def int_amdgcn_s_incperflevel :
   GCCBuiltin<"__builtin_amdgcn_s_incperflevel">,
-  Intrinsic<[], [llvm_i32_ty], [ImmArg<0>]> {
+  Intrinsic<[], [llvm_i32_ty], [ImmArg<ArgIndex<0>>, IntrNoMem,
+                                IntrHasSideEffects, IntrWillReturn]> {
 }
 
 def int_amdgcn_s_decperflevel :
   GCCBuiltin<"__builtin_amdgcn_s_decperflevel">,
-  Intrinsic<[], [llvm_i32_ty], [ImmArg<0>]> {
+  Intrinsic<[], [llvm_i32_ty], [ImmArg<ArgIndex<0>>, IntrNoMem,
+                                IntrHasSideEffects, IntrWillReturn]> {
 }
 
 def int_amdgcn_s_getreg :
   GCCBuiltin<"__builtin_amdgcn_s_getreg">,
   Intrinsic<[llvm_i32_ty], [llvm_i32_ty],
-  [IntrInaccessibleMemOnly, IntrReadMem, IntrSpeculatable, ImmArg<0>]
+  [IntrInaccessibleMemOnly, IntrReadMem, IntrSpeculatable,
+   IntrWillReturn, ImmArg<ArgIndex<0>>]
+>;
+
+// Note this can be used to set FP environment properties that are
+// unsafe to change in non-strictfp functions. The register properties
+// available (and value required to access them) may differ per
+// subtarget. llvm.amdgcn.s.setreg(hwmode, value)
+def int_amdgcn_s_setreg :
+  GCCBuiltin<"__builtin_amdgcn_s_setreg">,
+  Intrinsic<[], [llvm_i32_ty, llvm_i32_ty],
+  [IntrNoMem, IntrHasSideEffects, ImmArg<ArgIndex<0>>]
 >;
 
 // int_amdgcn_s_getpc is provided to allow a specific style of position
@@ -1183,7 +1298,8 @@
 // especially as we explicitly use IntrNoMem to allow optimizations.
 def int_amdgcn_s_getpc :
   GCCBuiltin<"__builtin_amdgcn_s_getpc">,
-  Intrinsic<[llvm_i64_ty], [], [IntrNoMem, IntrSpeculatable]>;
+  Intrinsic<[llvm_i64_ty], [], [IntrNoMem, IntrSpeculatable,
+                                IntrWillReturn]>;
 
 // __builtin_amdgcn_interp_mov <param>, <attr_chan>, <attr>, <m0>
 // param values: 0 = P10, 1 = P20, 2 = P0
@@ -1191,7 +1307,8 @@
   GCCBuiltin<"__builtin_amdgcn_interp_mov">,
   Intrinsic<[llvm_float_ty],
             [llvm_i32_ty, llvm_i32_ty, llvm_i32_ty, llvm_i32_ty],
-            [IntrNoMem, IntrSpeculatable]>;
+            [IntrNoMem, IntrSpeculatable, IntrWillReturn,
+              ImmArg<ArgIndex<0>>, ImmArg<ArgIndex<1>>, ImmArg<ArgIndex<2>>]>;
 
 // __builtin_amdgcn_interp_p1 <i>, <attr_chan>, <attr>, <m0>
 // This intrinsic reads from lds, but the memory values are constant,
@@ -1200,132 +1317,149 @@
   GCCBuiltin<"__builtin_amdgcn_interp_p1">,
   Intrinsic<[llvm_float_ty],
             [llvm_float_ty, llvm_i32_ty, llvm_i32_ty, llvm_i32_ty],
-            [IntrNoMem, IntrSpeculatable]>;
+            [IntrNoMem, IntrSpeculatable, IntrWillReturn,
+             ImmArg<ArgIndex<1>>, ImmArg<ArgIndex<2>>]>;
 
 // __builtin_amdgcn_interp_p2 <p1>, <j>, <attr_chan>, <attr>, <m0>
 def int_amdgcn_interp_p2 :
   GCCBuiltin<"__builtin_amdgcn_interp_p2">,
   Intrinsic<[llvm_float_ty],
             [llvm_float_ty, llvm_float_ty, llvm_i32_ty, llvm_i32_ty, llvm_i32_ty],
-            [IntrNoMem, IntrSpeculatable]>;
+            [IntrNoMem, IntrSpeculatable, IntrWillReturn,
+             ImmArg<ArgIndex<2>>, ImmArg<ArgIndex<3>>]>;
           // See int_amdgcn_v_interp_p1 for why this is IntrNoMem.
 
 // __builtin_amdgcn_interp_p1_f16 <i>, <attr_chan>, <attr>, <high>, <m0>
+// high selects whether high or low 16-bits are loaded from LDS
 def int_amdgcn_interp_p1_f16 :
   GCCBuiltin<"__builtin_amdgcn_interp_p1_f16">,
   Intrinsic<[llvm_float_ty],
             [llvm_float_ty, llvm_i32_ty, llvm_i32_ty, llvm_i1_ty, llvm_i32_ty],
-            [IntrNoMem, IntrSpeculatable]>;
+            [IntrNoMem, IntrSpeculatable, IntrWillReturn,
+             ImmArg<ArgIndex<1>>, ImmArg<ArgIndex<2>>, ImmArg<ArgIndex<3>>]>;
 
 // __builtin_amdgcn_interp_p2_f16 <p1>, <j>, <attr_chan>, <attr>, <high>, <m0>
+// high selects whether high or low 16-bits are loaded from LDS
 def int_amdgcn_interp_p2_f16 :
   GCCBuiltin<"__builtin_amdgcn_interp_p2_f16">,
   Intrinsic<[llvm_half_ty],
             [llvm_float_ty, llvm_float_ty, llvm_i32_ty, llvm_i32_ty, llvm_i1_ty, llvm_i32_ty],
-            [IntrNoMem, IntrSpeculatable]>;
+            [IntrNoMem, IntrSpeculatable, IntrWillReturn,
+             ImmArg<ArgIndex<2>>, ImmArg<ArgIndex<3>>, ImmArg<ArgIndex<4>>]>;
 
 // Pixel shaders only: whether the current pixel is live (i.e. not a helper
 // invocation for derivative computation).
 def int_amdgcn_ps_live : Intrinsic <
   [llvm_i1_ty],
   [],
-  [IntrNoMem]>;
+  [IntrNoMem, IntrWillReturn]>;
 
 def int_amdgcn_mbcnt_lo :
   GCCBuiltin<"__builtin_amdgcn_mbcnt_lo">,
-  Intrinsic<[llvm_i32_ty], [llvm_i32_ty, llvm_i32_ty], [IntrNoMem]>;
+  Intrinsic<[llvm_i32_ty], [llvm_i32_ty, llvm_i32_ty],
+   [IntrNoMem, IntrWillReturn]>;
 
 def int_amdgcn_mbcnt_hi :
   GCCBuiltin<"__builtin_amdgcn_mbcnt_hi">,
-  Intrinsic<[llvm_i32_ty], [llvm_i32_ty, llvm_i32_ty], [IntrNoMem]>;
+  Intrinsic<[llvm_i32_ty], [llvm_i32_ty, llvm_i32_ty],
+            [IntrNoMem, IntrWillReturn]>;
 
 // llvm.amdgcn.ds.swizzle src offset
 def int_amdgcn_ds_swizzle :
   GCCBuiltin<"__builtin_amdgcn_ds_swizzle">,
   Intrinsic<[llvm_i32_ty], [llvm_i32_ty, llvm_i32_ty],
-            [IntrNoMem, IntrConvergent, ImmArg<1>]>;
+            [IntrNoMem, IntrConvergent, IntrWillReturn,
+             ImmArg<ArgIndex<1>>]>;
 
 def int_amdgcn_ubfe : Intrinsic<[llvm_anyint_ty],
-  [LLVMMatchType<0>, llvm_i32_ty, llvm_i32_ty],
-  [IntrNoMem, IntrSpeculatable]
+    [LLVMMatchType<0>, llvm_i32_ty, llvm_i32_ty],
+    [IntrNoMem, IntrSpeculatable, IntrWillReturn]
 >;
 
 def int_amdgcn_sbfe : Intrinsic<[llvm_anyint_ty],
-  [LLVMMatchType<0>, llvm_i32_ty, llvm_i32_ty],
-  [IntrNoMem, IntrSpeculatable]
+    [LLVMMatchType<0>, llvm_i32_ty, llvm_i32_ty],
+    [IntrNoMem, IntrSpeculatable, IntrWillReturn]
 >;
 
 def int_amdgcn_lerp :
   GCCBuiltin<"__builtin_amdgcn_lerp">,
   Intrinsic<[llvm_i32_ty], [llvm_i32_ty, llvm_i32_ty, llvm_i32_ty],
-  [IntrNoMem, IntrSpeculatable]
+  [IntrNoMem, IntrSpeculatable, IntrWillReturn]
 >;
 
 def int_amdgcn_sad_u8 :
   GCCBuiltin<"__builtin_amdgcn_sad_u8">,
   Intrinsic<[llvm_i32_ty], [llvm_i32_ty, llvm_i32_ty, llvm_i32_ty],
-  [IntrNoMem, IntrSpeculatable]
+  [IntrNoMem, IntrSpeculatable, IntrWillReturn]
 >;
 
 def int_amdgcn_msad_u8 :
   GCCBuiltin<"__builtin_amdgcn_msad_u8">,
   Intrinsic<[llvm_i32_ty], [llvm_i32_ty, llvm_i32_ty, llvm_i32_ty],
-  [IntrNoMem, IntrSpeculatable]
+  [IntrNoMem, IntrSpeculatable, IntrWillReturn]
 >;
 
 def int_amdgcn_sad_hi_u8 :
   GCCBuiltin<"__builtin_amdgcn_sad_hi_u8">,
   Intrinsic<[llvm_i32_ty], [llvm_i32_ty, llvm_i32_ty, llvm_i32_ty],
-  [IntrNoMem, IntrSpeculatable]
+  [IntrNoMem, IntrSpeculatable, IntrWillReturn]
 >;
 
 def int_amdgcn_sad_u16 :
   GCCBuiltin<"__builtin_amdgcn_sad_u16">,
   Intrinsic<[llvm_i32_ty], [llvm_i32_ty, llvm_i32_ty, llvm_i32_ty],
-  [IntrNoMem, IntrSpeculatable]
+  [IntrNoMem, IntrSpeculatable, IntrWillReturn]
 >;
 
 def int_amdgcn_qsad_pk_u16_u8 :
   GCCBuiltin<"__builtin_amdgcn_qsad_pk_u16_u8">,
   Intrinsic<[llvm_i64_ty], [llvm_i64_ty, llvm_i32_ty, llvm_i64_ty],
-  [IntrNoMem, IntrSpeculatable]
+  [IntrNoMem, IntrSpeculatable, IntrWillReturn]
 >;
 
 def int_amdgcn_mqsad_pk_u16_u8 :
   GCCBuiltin<"__builtin_amdgcn_mqsad_pk_u16_u8">,
   Intrinsic<[llvm_i64_ty], [llvm_i64_ty, llvm_i32_ty, llvm_i64_ty],
-  [IntrNoMem, IntrSpeculatable]
+  [IntrNoMem, IntrSpeculatable, IntrWillReturn]
 >;
 
 def int_amdgcn_mqsad_u32_u8 :
   GCCBuiltin<"__builtin_amdgcn_mqsad_u32_u8">,
   Intrinsic<[llvm_v4i32_ty], [llvm_i64_ty, llvm_i32_ty, llvm_v4i32_ty],
-  [IntrNoMem, IntrSpeculatable]
+  [IntrNoMem, IntrSpeculatable, IntrWillReturn]
 >;
 
 def int_amdgcn_cvt_pk_u8_f32 :
   GCCBuiltin<"__builtin_amdgcn_cvt_pk_u8_f32">,
   Intrinsic<[llvm_i32_ty], [llvm_float_ty, llvm_i32_ty, llvm_i32_ty],
-  [IntrNoMem, IntrSpeculatable]
+  [IntrNoMem, IntrSpeculatable, IntrWillReturn]
 >;
 
 def int_amdgcn_icmp :
   Intrinsic<[llvm_anyint_ty], [llvm_anyint_ty, LLVMMatchType<1>, llvm_i32_ty],
-            [IntrNoMem, IntrConvergent, ImmArg<2>]>;
+            [IntrNoMem, IntrConvergent, IntrWillReturn,
+             ImmArg<ArgIndex<2>>]>;
 
 def int_amdgcn_fcmp :
   Intrinsic<[llvm_anyint_ty], [llvm_anyfloat_ty, LLVMMatchType<1>, llvm_i32_ty],
-            [IntrNoMem, IntrConvergent, ImmArg<2>]>;
+            [IntrNoMem, IntrConvergent, IntrWillReturn,
+             ImmArg<ArgIndex<2>>]>;
+
+def int_amdgcn_ballot :
+  Intrinsic<[llvm_anyint_ty], [llvm_i1_ty],
+            [IntrNoMem, IntrConvergent, IntrWillReturn]>;
 
 def int_amdgcn_readfirstlane :
   GCCBuiltin<"__builtin_amdgcn_readfirstlane">,
-  Intrinsic<[llvm_i32_ty], [llvm_i32_ty], [IntrNoMem, IntrConvergent]>;
+  Intrinsic<[llvm_i32_ty], [llvm_i32_ty],
+            [IntrNoMem, IntrConvergent, IntrWillReturn]>;
 
 // The lane argument must be uniform across the currently active threads of the
 // current wave. Otherwise, the result is undefined.
 def int_amdgcn_readlane :
   GCCBuiltin<"__builtin_amdgcn_readlane">,
-  Intrinsic<[llvm_i32_ty], [llvm_i32_ty, llvm_i32_ty], [IntrNoMem, IntrConvergent]>;
+  Intrinsic<[llvm_i32_ty], [llvm_i32_ty, llvm_i32_ty],
+            [IntrNoMem, IntrConvergent, IntrWillReturn]>;
 
 // The value to write and lane select arguments must be uniform across the
 // currently active threads of the current wave. Otherwise, the result is
@@ -1337,17 +1471,28 @@
     llvm_i32_ty,    // uniform lane select
     llvm_i32_ty     // returned by all lanes other than the selected one
   ],
-  [IntrNoMem, IntrConvergent]
+  [IntrNoMem, IntrConvergent, IntrWillReturn]
 >;
 
+// FIXME: Deprecated. This is equivalent to llvm.fshr
 def int_amdgcn_alignbit : Intrinsic<[llvm_i32_ty],
   [llvm_i32_ty, llvm_i32_ty, llvm_i32_ty],
-  [IntrNoMem, IntrSpeculatable]
+  [IntrNoMem, IntrSpeculatable, IntrWillReturn]
 >;
 
-def int_amdgcn_alignbyte : Intrinsic<[llvm_i32_ty],
-  [llvm_i32_ty, llvm_i32_ty, llvm_i32_ty],
-  [IntrNoMem, IntrSpeculatable]
+def int_amdgcn_alignbyte : GCCBuiltin<"__builtin_amdgcn_alignbyte">,
+  Intrinsic<[llvm_i32_ty], [llvm_i32_ty, llvm_i32_ty, llvm_i32_ty],
+  [IntrNoMem, IntrSpeculatable, IntrWillReturn]
+>;
+
+def int_amdgcn_mul_i24 : Intrinsic<[llvm_i32_ty],
+  [llvm_i32_ty, llvm_i32_ty],
+  [IntrNoMem, IntrSpeculatable, IntrWillReturn]
+>;
+
+def int_amdgcn_mul_u24 : Intrinsic<[llvm_i32_ty],
+  [llvm_i32_ty, llvm_i32_ty],
+  [IntrNoMem, IntrSpeculatable, IntrWillReturn]
 >;
 
 // llvm.amdgcn.ds.gws.init(i32 bar_val, i32 resource_id)
@@ -1358,7 +1503,8 @@
   GCCBuiltin<"__builtin_amdgcn_ds_gws_init">,
   Intrinsic<[],
   [llvm_i32_ty, llvm_i32_ty],
-  [IntrConvergent, IntrWriteMem, IntrInaccessibleMemOnly], "",
+  [IntrConvergent, IntrWriteMem,
+   IntrInaccessibleMemOnly, IntrWillReturn], "",
   [SDNPMemOperand]
 >;
 
@@ -1369,7 +1515,7 @@
   GCCBuiltin<"__builtin_amdgcn_ds_gws_barrier">,
   Intrinsic<[],
   [llvm_i32_ty, llvm_i32_ty],
-  [IntrConvergent, IntrInaccessibleMemOnly], "",
+  [IntrConvergent, IntrInaccessibleMemOnly, IntrWillReturn], "",
   [SDNPMemOperand]
 >;
 
@@ -1378,7 +1524,7 @@
   GCCBuiltin<"__builtin_amdgcn_ds_gws_sema_v">,
   Intrinsic<[],
   [llvm_i32_ty],
-  [IntrConvergent, IntrInaccessibleMemOnly], "",
+  [IntrConvergent, IntrInaccessibleMemOnly, IntrWillReturn], "",
   [SDNPMemOperand]
 >;
 
@@ -1387,7 +1533,7 @@
   GCCBuiltin<"__builtin_amdgcn_ds_gws_sema_br">,
   Intrinsic<[],
   [llvm_i32_ty, llvm_i32_ty],
-  [IntrConvergent, IntrInaccessibleMemOnly], "",
+  [IntrConvergent, IntrInaccessibleMemOnly, IntrWillReturn], "",
   [SDNPMemOperand]
 >;
 
@@ -1396,7 +1542,7 @@
   GCCBuiltin<"__builtin_amdgcn_ds_gws_sema_p">,
   Intrinsic<[],
   [llvm_i32_ty],
-  [IntrConvergent, IntrInaccessibleMemOnly], "",
+  [IntrConvergent, IntrInaccessibleMemOnly, IntrWillReturn], "",
   [SDNPMemOperand]
 >;
 
@@ -1405,7 +1551,7 @@
   GCCBuiltin<"__builtin_amdgcn_ds_gws_sema_release_all">,
   Intrinsic<[],
   [llvm_i32_ty],
-  [IntrConvergent, IntrInaccessibleMemOnly], "",
+  [IntrConvergent, IntrInaccessibleMemOnly, IntrWillReturn], "",
   [SDNPMemOperand]
 >;
 
@@ -1413,25 +1559,38 @@
 // Copies the source value to the destination value, with the guarantee that
 // the source value is computed as if the entire program were executed in WQM.
 def int_amdgcn_wqm : Intrinsic<[llvm_any_ty],
-  [LLVMMatchType<0>], [IntrNoMem, IntrSpeculatable]
+  [LLVMMatchType<0>], [IntrNoMem, IntrSpeculatable, IntrWillReturn]
+>;
+
+// Copies the source value to the destination value, such that the source
+// is computed as if the entire program were executed in WQM if any other
+// program code executes in WQM.
+def int_amdgcn_softwqm : Intrinsic<[llvm_any_ty],
+  [LLVMMatchType<0>], [IntrNoMem, IntrSpeculatable, IntrWillReturn]
 >;
 
 // Return true if at least one thread within the pixel quad passes true into
 // the function.
 def int_amdgcn_wqm_vote : Intrinsic<[llvm_i1_ty],
-  [llvm_i1_ty], [IntrNoMem, IntrConvergent]
+  [llvm_i1_ty], [IntrNoMem, IntrConvergent, IntrWillReturn]
 >;
 
 // If false, set EXEC=0 for the current thread until the end of program.
+// FIXME: Should this be IntrNoMem, IntrHasSideEffects, or IntrWillReturn?
 def int_amdgcn_kill : Intrinsic<[], [llvm_i1_ty], []>;
 
+def int_amdgcn_endpgm : GCCBuiltin<"__builtin_amdgcn_endpgm">,
+  Intrinsic<[], [], [IntrNoReturn, IntrCold, IntrNoMem, IntrHasSideEffects]
+>;
+
 // Copies the active channels of the source value to the destination value,
 // with the guarantee that the source value is computed as if the entire
 // program were executed in Whole Wavefront Mode, i.e. with all channels
 // enabled, with a few exceptions: - Phi nodes with require WWM return an
 // undefined value.
 def int_amdgcn_wwm : Intrinsic<[llvm_any_ty],
-  [LLVMMatchType<0>], [IntrNoMem, IntrSpeculatable, IntrConvergent]
+  [LLVMMatchType<0>], [IntrNoMem, IntrSpeculatable,
+                       IntrConvergent, IntrWillReturn]
 >;
 
 // Given a value, copies it while setting all the inactive lanes to a given
@@ -1442,7 +1601,19 @@
   Intrinsic<[llvm_anyint_ty],
             [LLVMMatchType<0>, // value to be copied
              LLVMMatchType<0>], // value for the inactive lanes to take
-            [IntrNoMem, IntrConvergent]>;
+            [IntrNoMem, IntrConvergent, IntrWillReturn]>;
+
+// Return if the given flat pointer points to a local memory address.
+def int_amdgcn_is_shared : GCCBuiltin<"__builtin_amdgcn_is_shared">,
+  Intrinsic<[llvm_i1_ty], [llvm_ptr_ty],
+  [IntrNoMem, IntrSpeculatable, NoCapture<ArgIndex<0>>, IntrWillReturn]
+>;
+
+// Return if the given flat pointer points to a prvate memory address.
+def int_amdgcn_is_private : GCCBuiltin<"__builtin_amdgcn_is_private">,
+  Intrinsic<[llvm_i1_ty], [llvm_ptr_ty],
+  [IntrNoMem, IntrSpeculatable, NoCapture<ArgIndex<0>>, IntrWillReturn]
+>;
 
 //===----------------------------------------------------------------------===//
 // CI+ Intrinsics
@@ -1450,11 +1621,11 @@
 
 def int_amdgcn_s_dcache_inv_vol :
   GCCBuiltin<"__builtin_amdgcn_s_dcache_inv_vol">,
-  Intrinsic<[], [], []>;
+  Intrinsic<[], [], [IntrNoMem, IntrHasSideEffects, IntrWillReturn]>;
 
 def int_amdgcn_buffer_wbinvl1_vol :
   GCCBuiltin<"__builtin_amdgcn_buffer_wbinvl1_vol">,
-  Intrinsic<[], [], []>;
+  Intrinsic<[], [], [IntrNoMem, IntrHasSideEffects, IntrWillReturn]>;
 
 //===----------------------------------------------------------------------===//
 // VI Intrinsics
@@ -1464,8 +1635,10 @@
 def int_amdgcn_mov_dpp :
   Intrinsic<[llvm_anyint_ty],
             [LLVMMatchType<0>, llvm_i32_ty, llvm_i32_ty, llvm_i32_ty,
-             llvm_i1_ty], [IntrNoMem, IntrConvergent, ImmArg<1>,
-                           ImmArg<2>, ImmArg<3>, ImmArg<4>]>;
+             llvm_i1_ty],
+             [IntrNoMem, IntrConvergent, IntrWillReturn,
+             ImmArg<ArgIndex<1>>, ImmArg<ArgIndex<2>>,
+             ImmArg<ArgIndex<3>>, ImmArg<ArgIndex<4>>]>;
 
 // llvm.amdgcn.update.dpp.i32 <old> <src> <dpp_ctrl> <row_mask> <bank_mask> <bound_ctrl>
 // Should be equivalent to:
@@ -1475,46 +1648,51 @@
   Intrinsic<[llvm_anyint_ty],
             [LLVMMatchType<0>, LLVMMatchType<0>, llvm_i32_ty,
             llvm_i32_ty, llvm_i32_ty, llvm_i1_ty],
-             [IntrNoMem, IntrConvergent,
-              ImmArg<2>, ImmArg<3>, ImmArg<4>, ImmArg<5>]>;
+             [IntrNoMem, IntrConvergent, IntrWillReturn,
+              ImmArg<ArgIndex<2>>, ImmArg<ArgIndex<3>>,
+              ImmArg<ArgIndex<4>>, ImmArg<ArgIndex<5>>]>;
 
 def int_amdgcn_s_dcache_wb :
   GCCBuiltin<"__builtin_amdgcn_s_dcache_wb">,
-  Intrinsic<[], [], []>;
+  Intrinsic<[], [], [IntrNoMem, IntrHasSideEffects, IntrWillReturn]>;
 
 def int_amdgcn_s_dcache_wb_vol :
   GCCBuiltin<"__builtin_amdgcn_s_dcache_wb_vol">,
-  Intrinsic<[], [], []>;
+  Intrinsic<[], [], [IntrNoMem, IntrHasSideEffects, IntrWillReturn]>;
 
 def int_amdgcn_s_memrealtime :
   GCCBuiltin<"__builtin_amdgcn_s_memrealtime">,
-  Intrinsic<[llvm_i64_ty]>;
+  Intrinsic<[llvm_i64_ty], [], [IntrWillReturn]>;
 
 // llvm.amdgcn.ds.permute <index> <src>
 def int_amdgcn_ds_permute :
   GCCBuiltin<"__builtin_amdgcn_ds_permute">,
-  Intrinsic<[llvm_i32_ty], [llvm_i32_ty, llvm_i32_ty], [IntrNoMem, IntrConvergent]>;
+  Intrinsic<[llvm_i32_ty], [llvm_i32_ty, llvm_i32_ty],
+    [IntrNoMem, IntrConvergent, IntrWillReturn]>;
 
 // llvm.amdgcn.ds.bpermute <index> <src>
 def int_amdgcn_ds_bpermute :
   GCCBuiltin<"__builtin_amdgcn_ds_bpermute">,
-  Intrinsic<[llvm_i32_ty], [llvm_i32_ty, llvm_i32_ty], [IntrNoMem, IntrConvergent]>;
+  Intrinsic<[llvm_i32_ty], [llvm_i32_ty, llvm_i32_ty],
+     [IntrNoMem, IntrConvergent, IntrWillReturn]>;
 
 //===----------------------------------------------------------------------===//
 // GFX10 Intrinsics
 //===----------------------------------------------------------------------===//
 
 // llvm.amdgcn.permlane16 <old> <src0> <src1> <src2> <fi> <bound_control>
-def int_amdgcn_permlane16 :
+def int_amdgcn_permlane16 : GCCBuiltin<"__builtin_amdgcn_permlane16">,
   Intrinsic<[llvm_i32_ty],
             [llvm_i32_ty, llvm_i32_ty, llvm_i32_ty, llvm_i32_ty, llvm_i1_ty, llvm_i1_ty],
-            [IntrNoMem, IntrConvergent, ImmArg<4>, ImmArg<5>]>;
+            [IntrNoMem, IntrConvergent, IntrWillReturn,
+             ImmArg<ArgIndex<4>>, ImmArg<ArgIndex<5>>]>;
 
 // llvm.amdgcn.permlanex16 <old> <src0> <src1> <src2> <fi> <bound_control>
-def int_amdgcn_permlanex16 :
+def int_amdgcn_permlanex16 : GCCBuiltin<"__builtin_amdgcn_permlanex16">,
   Intrinsic<[llvm_i32_ty],
             [llvm_i32_ty, llvm_i32_ty, llvm_i32_ty, llvm_i32_ty, llvm_i1_ty, llvm_i1_ty],
-            [IntrNoMem, IntrConvergent, ImmArg<4>, ImmArg<5>]>;
+            [IntrNoMem, IntrConvergent, IntrWillReturn,
+             ImmArg<ArgIndex<4>>, ImmArg<ArgIndex<5>>]>;
 
 // llvm.amdgcn.mov.dpp8.i32 <src> <sel>
 // <sel> is a 32-bit constant whose high 8 bits must be zero which selects
@@ -1522,11 +1700,30 @@
 def int_amdgcn_mov_dpp8 :
   Intrinsic<[llvm_anyint_ty],
             [LLVMMatchType<0>, llvm_i32_ty],
-            [IntrNoMem, IntrConvergent, ImmArg<1>]>;
+            [IntrNoMem, IntrConvergent, IntrWillReturn,
+             ImmArg<ArgIndex<1>>]>;
 
 def int_amdgcn_s_get_waveid_in_workgroup :
   GCCBuiltin<"__builtin_amdgcn_s_get_waveid_in_workgroup">,
-  Intrinsic<[llvm_i32_ty], [], [IntrReadMem, IntrInaccessibleMemOnly]>;
+  Intrinsic<[llvm_i32_ty], [],
+    [IntrReadMem, IntrInaccessibleMemOnly, IntrWillReturn]>;
+
+class AMDGPUGlobalAtomicRtn<LLVMType vt> : Intrinsic <
+  [vt],
+  [llvm_anyptr_ty,    // vaddr
+   vt],               // vdata(VGPR)
+  [IntrArgMemOnly, IntrWillReturn, NoCapture<ArgIndex<0>>], "",
+  [SDNPMemOperand]>;
+
+def int_amdgcn_global_atomic_csub : AMDGPUGlobalAtomicRtn<llvm_i32_ty>;
+
+// uint4 llvm.amdgcn.image.bvh.intersect.ray <node_ptr>, <ray_extent>, <ray_origin>,
+//                                           <ray_dir>, <ray_inv_dir>, <texture_descr>
+def int_amdgcn_image_bvh_intersect_ray :
+  Intrinsic<[llvm_v4i32_ty],
+            [llvm_anyint_ty, llvm_float_ty, llvm_v4f32_ty, llvm_anyvector_ty,
+             LLVMMatchType<1>, llvm_v4i32_ty],
+            [IntrReadMem]>;
 
 //===----------------------------------------------------------------------===//
 // Deep learning intrinsics.
@@ -1544,7 +1741,7 @@
       llvm_float_ty, // %c
       llvm_i1_ty     // %clamp
     ],
-    [IntrNoMem, IntrSpeculatable, ImmArg<3>]
+    [IntrNoMem, IntrSpeculatable, IntrWillReturn, ImmArg<ArgIndex<3>>]
   >;
 
 // i32 %r = llvm.amdgcn.sdot2(v2i16 %a, v2i16 %b, i32 %c, i1 %clamp)
@@ -1559,7 +1756,7 @@
       llvm_i32_ty,   // %c
       llvm_i1_ty     // %clamp
     ],
-    [IntrNoMem, IntrSpeculatable, ImmArg<3>]
+    [IntrNoMem, IntrSpeculatable, IntrWillReturn, ImmArg<ArgIndex<3>>]
   >;
 
 // u32 %r = llvm.amdgcn.udot2(v2u16 %a, v2u16 %b, u32 %c, i1 %clamp)
@@ -1574,7 +1771,7 @@
       llvm_i32_ty,   // %c
       llvm_i1_ty     // %clamp
     ],
-    [IntrNoMem, IntrSpeculatable, ImmArg<3>]
+    [IntrNoMem, IntrSpeculatable, IntrWillReturn, ImmArg<ArgIndex<3>>]
   >;
 
 // i32 %r = llvm.amdgcn.sdot4(v4i8 (as i32) %a, v4i8 (as i32) %b, i32 %c, i1 %clamp)
@@ -1589,7 +1786,7 @@
       llvm_i32_ty, // %c
       llvm_i1_ty   // %clamp
     ],
-    [IntrNoMem, IntrSpeculatable, ImmArg<3>]
+    [IntrNoMem, IntrSpeculatable, IntrWillReturn, ImmArg<ArgIndex<3>>]
   >;
 
 // u32 %r = llvm.amdgcn.udot4(v4u8 (as u32) %a, v4u8 (as u32) %b, u32 %c, i1 %clamp)
@@ -1604,7 +1801,7 @@
       llvm_i32_ty, // %c
       llvm_i1_ty   // %clamp
     ],
-    [IntrNoMem, IntrSpeculatable, ImmArg<3>]
+    [IntrNoMem, IntrSpeculatable, IntrWillReturn, ImmArg<ArgIndex<3>>]
   >;
 
 // i32 %r = llvm.amdgcn.sdot8(v8i4 (as i32) %a, v8i4 (as i32) %b, i32 %c, i1 %clamp)
@@ -1620,7 +1817,7 @@
       llvm_i32_ty, // %c
       llvm_i1_ty   // %clamp
     ],
-    [IntrNoMem, IntrSpeculatable, ImmArg<3>]
+    [IntrNoMem, IntrSpeculatable, IntrWillReturn, ImmArg<ArgIndex<3>>]
   >;
 
 // u32 %r = llvm.amdgcn.udot8(v8u4 (as u32) %a, v8u4 (as u32) %b, u32 %c, i1 %clamp)
@@ -1636,114 +1833,179 @@
       llvm_i32_ty, // %c
       llvm_i1_ty   // %clamp
     ],
-    [IntrNoMem, IntrSpeculatable, ImmArg<3>]
+    [IntrNoMem, IntrSpeculatable, IntrWillReturn, ImmArg<ArgIndex<3>>]
   >;
 
 //===----------------------------------------------------------------------===//
-// MI-100 intrinsics
+// gfx908 intrinsics
 // ===----------------------------------------------------------------------===//
+
+def int_amdgcn_global_atomic_fadd : AMDGPUGlobalAtomicRtn<llvm_anyfloat_ty>;
+
 // llvm.amdgcn.mfma.f32.* vdst, srcA, srcB, srcC, cbsz, abid, blgp
-def int_amdgcn_mfma_f32_32x32x1f32 : Intrinsic<[llvm_v32i32_ty],
-  [llvm_float_ty, llvm_float_ty, llvm_v32i32_ty,
-   llvm_i32_ty, llvm_i32_ty, llvm_i32_ty], [IntrConvergent, IntrNoMem]>;
+def int_amdgcn_mfma_f32_32x32x1f32 : GCCBuiltin<"__builtin_amdgcn_mfma_f32_32x32x1f32">,
+  Intrinsic<[llvm_v32f32_ty],
+            [llvm_float_ty, llvm_float_ty, llvm_v32f32_ty,
+            llvm_i32_ty, llvm_i32_ty, llvm_i32_ty],
+            [IntrConvergent, IntrNoMem, IntrWillReturn,
+             ImmArg<ArgIndex<3>>, ImmArg<ArgIndex<4>>, ImmArg<ArgIndex<5>>]>;
 
-def int_amdgcn_mfma_f32_16x16x1f32 : Intrinsic<[llvm_v16f32_ty],
-  [llvm_float_ty, llvm_float_ty, llvm_v16f32_ty,
-   llvm_i32_ty, llvm_i32_ty, llvm_i32_ty], [IntrConvergent, IntrNoMem]>;
+def int_amdgcn_mfma_f32_16x16x1f32 : GCCBuiltin<"__builtin_amdgcn_mfma_f32_16x16x1f32">,
+  Intrinsic<[llvm_v16f32_ty],
+            [llvm_float_ty, llvm_float_ty, llvm_v16f32_ty,
+            llvm_i32_ty, llvm_i32_ty, llvm_i32_ty],
+            [IntrConvergent, IntrNoMem, IntrWillReturn,
+             ImmArg<ArgIndex<3>>, ImmArg<ArgIndex<4>>, ImmArg<ArgIndex<5>>]>;
 
-def int_amdgcn_mfma_f32_4x4x1f32 : Intrinsic<[llvm_v4f32_ty],
-  [llvm_float_ty, llvm_float_ty, llvm_v4f32_ty,
-   llvm_i32_ty, llvm_i32_ty, llvm_i32_ty], [IntrConvergent, IntrNoMem]>;
+def int_amdgcn_mfma_f32_4x4x1f32 : GCCBuiltin<"__builtin_amdgcn_mfma_f32_4x4x1f32">,
+  Intrinsic<[llvm_v4f32_ty],
+            [llvm_float_ty, llvm_float_ty, llvm_v4f32_ty,
+            llvm_i32_ty, llvm_i32_ty, llvm_i32_ty],
+            [IntrConvergent, IntrNoMem, IntrWillReturn,
+             ImmArg<ArgIndex<3>>, ImmArg<ArgIndex<4>>, ImmArg<ArgIndex<5>>]>;
 
-def int_amdgcn_mfma_f32_32x32x2f32 : Intrinsic<[llvm_v16f32_ty],
-  [llvm_float_ty, llvm_float_ty, llvm_v16f32_ty,
-   llvm_i32_ty, llvm_i32_ty, llvm_i32_ty], [IntrConvergent, IntrNoMem]>;
+def int_amdgcn_mfma_f32_32x32x2f32 : GCCBuiltin<"__builtin_amdgcn_mfma_f32_32x32x2f32">,
+  Intrinsic<[llvm_v16f32_ty],
+            [llvm_float_ty, llvm_float_ty, llvm_v16f32_ty,
+            llvm_i32_ty, llvm_i32_ty, llvm_i32_ty],
+            [IntrConvergent, IntrNoMem, IntrWillReturn,
+             ImmArg<ArgIndex<3>>, ImmArg<ArgIndex<4>>, ImmArg<ArgIndex<5>>]>;
 
-def int_amdgcn_mfma_f32_16x16x4f32 : Intrinsic<[llvm_v4f32_ty],
-  [llvm_float_ty, llvm_float_ty, llvm_v4f32_ty,
-   llvm_i32_ty, llvm_i32_ty, llvm_i32_ty], [IntrConvergent, IntrNoMem]>;
+def int_amdgcn_mfma_f32_16x16x4f32 : GCCBuiltin<"__builtin_amdgcn_mfma_f32_16x16x4f32">,
+  Intrinsic<[llvm_v4f32_ty],
+            [llvm_float_ty, llvm_float_ty, llvm_v4f32_ty,
+            llvm_i32_ty, llvm_i32_ty, llvm_i32_ty],
+            [IntrConvergent, IntrNoMem, IntrWillReturn,
+             ImmArg<ArgIndex<3>>, ImmArg<ArgIndex<4>>, ImmArg<ArgIndex<5>>]>;
 
-def int_amdgcn_mfma_f32_32x32x4f16 : Intrinsic<[llvm_v32i32_ty],
-  [llvm_v4f16_ty, llvm_v4f16_ty, llvm_v32i32_ty,
-   llvm_i32_ty, llvm_i32_ty, llvm_i32_ty], [IntrConvergent, IntrNoMem]>;
+def int_amdgcn_mfma_f32_32x32x4f16 : GCCBuiltin<"__builtin_amdgcn_mfma_f32_32x32x4f16">,
+  Intrinsic<[llvm_v32f32_ty],
+            [llvm_v4f16_ty, llvm_v4f16_ty, llvm_v32f32_ty,
+            llvm_i32_ty, llvm_i32_ty, llvm_i32_ty],
+            [IntrConvergent, IntrNoMem, IntrWillReturn,
+             ImmArg<ArgIndex<3>>, ImmArg<ArgIndex<4>>, ImmArg<ArgIndex<5>>]>;
 
-def int_amdgcn_mfma_f32_16x16x4f16 : Intrinsic<[llvm_v16f32_ty],
-  [llvm_v4f16_ty, llvm_v4f16_ty, llvm_v16f32_ty,
-   llvm_i32_ty, llvm_i32_ty, llvm_i32_ty], [IntrConvergent, IntrNoMem]>;
+def int_amdgcn_mfma_f32_16x16x4f16 : GCCBuiltin<"__builtin_amdgcn_mfma_f32_16x16x4f16">,
+  Intrinsic<[llvm_v16f32_ty],
+            [llvm_v4f16_ty, llvm_v4f16_ty, llvm_v16f32_ty,
+            llvm_i32_ty, llvm_i32_ty, llvm_i32_ty],
+            [IntrConvergent, IntrNoMem, IntrWillReturn,
+             ImmArg<ArgIndex<3>>, ImmArg<ArgIndex<4>>, ImmArg<ArgIndex<5>>]>;
 
-def int_amdgcn_mfma_f32_4x4x4f16 : Intrinsic<[llvm_v4f32_ty],
-  [llvm_v4f16_ty, llvm_v4f16_ty, llvm_v4f32_ty,
-   llvm_i32_ty, llvm_i32_ty, llvm_i32_ty], [IntrConvergent, IntrNoMem]>;
+def int_amdgcn_mfma_f32_4x4x4f16 : GCCBuiltin<"__builtin_amdgcn_mfma_f32_4x4x4f16">,
+  Intrinsic<[llvm_v4f32_ty],
+            [llvm_v4f16_ty, llvm_v4f16_ty, llvm_v4f32_ty,
+            llvm_i32_ty, llvm_i32_ty, llvm_i32_ty],
+            [IntrConvergent, IntrNoMem, IntrWillReturn,
+             ImmArg<ArgIndex<3>>, ImmArg<ArgIndex<4>>, ImmArg<ArgIndex<5>>]>;
 
-def int_amdgcn_mfma_f32_32x32x8f16 : Intrinsic<[llvm_v16f32_ty],
-  [llvm_v4f16_ty, llvm_v4f16_ty, llvm_v16f32_ty,
-   llvm_i32_ty, llvm_i32_ty, llvm_i32_ty], [IntrConvergent, IntrNoMem]>;
+def int_amdgcn_mfma_f32_32x32x8f16 : GCCBuiltin<"__builtin_amdgcn_mfma_f32_32x32x8f16">,
+  Intrinsic<[llvm_v16f32_ty],
+            [llvm_v4f16_ty, llvm_v4f16_ty, llvm_v16f32_ty,
+            llvm_i32_ty, llvm_i32_ty, llvm_i32_ty],
+            [IntrConvergent, IntrNoMem, IntrWillReturn,
+             ImmArg<ArgIndex<3>>, ImmArg<ArgIndex<4>>, ImmArg<ArgIndex<5>>]>;
 
-def int_amdgcn_mfma_f32_16x16x16f16 : Intrinsic<[llvm_v4f32_ty],
-  [llvm_v4f16_ty, llvm_v4f16_ty, llvm_v4f32_ty,
-   llvm_i32_ty, llvm_i32_ty, llvm_i32_ty], [IntrConvergent, IntrNoMem]>;
+def int_amdgcn_mfma_f32_16x16x16f16 : GCCBuiltin<"__builtin_amdgcn_mfma_f32_16x16x16f16">,
+  Intrinsic<[llvm_v4f32_ty],
+            [llvm_v4f16_ty, llvm_v4f16_ty, llvm_v4f32_ty,
+            llvm_i32_ty, llvm_i32_ty, llvm_i32_ty],
+            [IntrConvergent, IntrNoMem, IntrWillReturn,
+             ImmArg<ArgIndex<3>>, ImmArg<ArgIndex<4>>, ImmArg<ArgIndex<5>>]>;
 
-def int_amdgcn_mfma_i32_32x32x4i8 : Intrinsic<[llvm_v32i32_ty],
-  [llvm_i32_ty, llvm_i32_ty, llvm_v32i32_ty,
-   llvm_i32_ty, llvm_i32_ty, llvm_i32_ty], [IntrConvergent, IntrNoMem]>;
+def int_amdgcn_mfma_i32_32x32x4i8 : GCCBuiltin<"__builtin_amdgcn_mfma_i32_32x32x4i8">,
+  Intrinsic<[llvm_v32i32_ty],
+            [llvm_i32_ty, llvm_i32_ty, llvm_v32i32_ty,
+            llvm_i32_ty, llvm_i32_ty, llvm_i32_ty],
+            [IntrConvergent, IntrNoMem, IntrWillReturn,
+             ImmArg<ArgIndex<3>>, ImmArg<ArgIndex<4>>, ImmArg<ArgIndex<5>>]>;
 
-def int_amdgcn_mfma_i32_16x16x4i8 : Intrinsic<[llvm_v16i32_ty],
-  [llvm_i32_ty, llvm_i32_ty, llvm_v16i32_ty,
-   llvm_i32_ty, llvm_i32_ty, llvm_i32_ty], [IntrConvergent, IntrNoMem]>;
+def int_amdgcn_mfma_i32_16x16x4i8 : GCCBuiltin<"__builtin_amdgcn_mfma_i32_16x16x4i8">,
+  Intrinsic<[llvm_v16i32_ty],
+            [llvm_i32_ty, llvm_i32_ty, llvm_v16i32_ty,
+            llvm_i32_ty, llvm_i32_ty, llvm_i32_ty],
+            [IntrConvergent, IntrNoMem, IntrWillReturn,
+             ImmArg<ArgIndex<3>>, ImmArg<ArgIndex<4>>, ImmArg<ArgIndex<5>>]>;
 
-def int_amdgcn_mfma_i32_4x4x4i8 : Intrinsic<[llvm_v4i32_ty],
-  [llvm_i32_ty, llvm_i32_ty, llvm_v4i32_ty,
-   llvm_i32_ty, llvm_i32_ty, llvm_i32_ty], [IntrConvergent, IntrNoMem]>;
+def int_amdgcn_mfma_i32_4x4x4i8 : GCCBuiltin<"__builtin_amdgcn_mfma_i32_4x4x4i8">,
+  Intrinsic<[llvm_v4i32_ty],
+            [llvm_i32_ty, llvm_i32_ty, llvm_v4i32_ty,
+            llvm_i32_ty, llvm_i32_ty, llvm_i32_ty],
+            [IntrConvergent, IntrNoMem, IntrWillReturn,
+             ImmArg<ArgIndex<3>>, ImmArg<ArgIndex<4>>, ImmArg<ArgIndex<5>>]>;
 
-def int_amdgcn_mfma_i32_32x32x8i8 : Intrinsic<[llvm_v16i32_ty],
-  [llvm_i32_ty, llvm_i32_ty, llvm_v16i32_ty,
-   llvm_i32_ty, llvm_i32_ty, llvm_i32_ty], [IntrConvergent, IntrNoMem]>;
+def int_amdgcn_mfma_i32_32x32x8i8 : GCCBuiltin<"__builtin_amdgcn_mfma_i32_32x32x8i8">,
+  Intrinsic<[llvm_v16i32_ty],
+            [llvm_i32_ty, llvm_i32_ty, llvm_v16i32_ty,
+            llvm_i32_ty, llvm_i32_ty, llvm_i32_ty],
+            [IntrConvergent, IntrNoMem, IntrWillReturn,
+             ImmArg<ArgIndex<3>>, ImmArg<ArgIndex<4>>, ImmArg<ArgIndex<5>>]>;
 
-def int_amdgcn_mfma_i32_16x16x16i8 : Intrinsic<[llvm_v4i32_ty],
-  [llvm_i32_ty, llvm_i32_ty, llvm_v4i32_ty,
-   llvm_i32_ty, llvm_i32_ty, llvm_i32_ty], [IntrConvergent, IntrNoMem]>;
+def int_amdgcn_mfma_i32_16x16x16i8 : GCCBuiltin<"__builtin_amdgcn_mfma_i32_16x16x16i8">,
+  Intrinsic<[llvm_v4i32_ty],
+            [llvm_i32_ty, llvm_i32_ty, llvm_v4i32_ty,
+            llvm_i32_ty, llvm_i32_ty, llvm_i32_ty],
+            [IntrConvergent, IntrNoMem, IntrWillReturn,
+             ImmArg<ArgIndex<3>>, ImmArg<ArgIndex<4>>, ImmArg<ArgIndex<5>>]>;
 
-def int_amdgcn_mfma_f32_32x32x2bf16 : Intrinsic<[llvm_v32i32_ty],
-  [llvm_v2i16_ty, llvm_v2i16_ty, llvm_v32i32_ty,
-   llvm_i32_ty, llvm_i32_ty, llvm_i32_ty], [IntrConvergent, IntrNoMem]>;
+def int_amdgcn_mfma_f32_32x32x2bf16 : GCCBuiltin<"__builtin_amdgcn_mfma_f32_32x32x2bf16">,
+  Intrinsic<[llvm_v32f32_ty],
+            [llvm_v2i16_ty, llvm_v2i16_ty, llvm_v32f32_ty,
+            llvm_i32_ty, llvm_i32_ty, llvm_i32_ty],
+            [IntrConvergent, IntrNoMem, IntrWillReturn,
+             ImmArg<ArgIndex<3>>, ImmArg<ArgIndex<4>>, ImmArg<ArgIndex<5>>]>;
 
-def int_amdgcn_mfma_f32_16x16x2bf16 : Intrinsic<[llvm_v16f32_ty],
-  [llvm_v2i16_ty, llvm_v2i16_ty, llvm_v16f32_ty,
-   llvm_i32_ty, llvm_i32_ty, llvm_i32_ty], [IntrConvergent, IntrNoMem]>;
+def int_amdgcn_mfma_f32_16x16x2bf16 : GCCBuiltin<"__builtin_amdgcn_mfma_f32_16x16x2bf16">,
+  Intrinsic<[llvm_v16f32_ty],
+            [llvm_v2i16_ty, llvm_v2i16_ty, llvm_v16f32_ty,
+            llvm_i32_ty, llvm_i32_ty, llvm_i32_ty],
+            [IntrConvergent, IntrNoMem, IntrWillReturn,
+             ImmArg<ArgIndex<3>>, ImmArg<ArgIndex<4>>, ImmArg<ArgIndex<5>>]>;
 
-def int_amdgcn_mfma_f32_4x4x2bf16 : Intrinsic<[llvm_v4f32_ty],
-  [llvm_v2i16_ty, llvm_v2i16_ty, llvm_v4f32_ty,
-   llvm_i32_ty, llvm_i32_ty, llvm_i32_ty], [IntrConvergent, IntrNoMem]>;
+def int_amdgcn_mfma_f32_4x4x2bf16 : GCCBuiltin<"__builtin_amdgcn_mfma_f32_4x4x2bf16">,
+  Intrinsic<[llvm_v4f32_ty],
+            [llvm_v2i16_ty, llvm_v2i16_ty, llvm_v4f32_ty,
+            llvm_i32_ty, llvm_i32_ty, llvm_i32_ty],
+            [IntrConvergent, IntrNoMem, IntrWillReturn,
+             ImmArg<ArgIndex<3>>, ImmArg<ArgIndex<4>>, ImmArg<ArgIndex<5>>]>;
 
-def int_amdgcn_mfma_f32_32x32x4bf16 : Intrinsic<[llvm_v16f32_ty],
-  [llvm_v2i16_ty, llvm_v2i16_ty, llvm_v16f32_ty,
-   llvm_i32_ty, llvm_i32_ty, llvm_i32_ty], [IntrConvergent, IntrNoMem]>;
+def int_amdgcn_mfma_f32_32x32x4bf16 : GCCBuiltin<"__builtin_amdgcn_mfma_f32_32x32x4bf16">,
+  Intrinsic<[llvm_v16f32_ty],
+            [llvm_v2i16_ty, llvm_v2i16_ty, llvm_v16f32_ty,
+            llvm_i32_ty, llvm_i32_ty, llvm_i32_ty],
+            [IntrConvergent, IntrNoMem, IntrWillReturn,
+             ImmArg<ArgIndex<3>>, ImmArg<ArgIndex<4>>, ImmArg<ArgIndex<5>>]>;
 
-def int_amdgcn_mfma_f32_16x16x8bf16 : Intrinsic<[llvm_v4f32_ty],
-  [llvm_v2i16_ty, llvm_v2i16_ty, llvm_v4f32_ty,
-   llvm_i32_ty, llvm_i32_ty, llvm_i32_ty], [IntrConvergent, IntrNoMem]>;
+def int_amdgcn_mfma_f32_16x16x8bf16 : GCCBuiltin<"__builtin_amdgcn_mfma_f32_16x16x8bf16">,
+  Intrinsic<[llvm_v4f32_ty],
+            [llvm_v2i16_ty, llvm_v2i16_ty, llvm_v4f32_ty,
+            llvm_i32_ty, llvm_i32_ty, llvm_i32_ty],
+            [IntrConvergent, IntrNoMem, IntrWillReturn,
+             ImmArg<ArgIndex<3>>, ImmArg<ArgIndex<4>>, ImmArg<ArgIndex<5>>]>;
 
 //===----------------------------------------------------------------------===//
 // Special Intrinsics for backend internal use only. No frontend
 // should emit calls to these.
 // ===----------------------------------------------------------------------===//
 def int_amdgcn_if : Intrinsic<[llvm_i1_ty, llvm_anyint_ty],
-  [llvm_i1_ty], [IntrConvergent]
+  [llvm_i1_ty], [IntrConvergent, IntrWillReturn]
 >;
 
 def int_amdgcn_else : Intrinsic<[llvm_i1_ty, llvm_anyint_ty],
-  [llvm_anyint_ty], [IntrConvergent]
+  [llvm_anyint_ty], [IntrConvergent, IntrWillReturn]
 >;
 
 def int_amdgcn_if_break : Intrinsic<[llvm_anyint_ty],
-  [llvm_i1_ty, llvm_anyint_ty], [IntrNoMem, IntrConvergent]
+  [llvm_i1_ty, LLVMMatchType<0>],
+  [IntrNoMem, IntrConvergent, IntrWillReturn]
 >;
 
 def int_amdgcn_loop : Intrinsic<[llvm_i1_ty],
-  [llvm_anyint_ty], [IntrConvergent]
+  [llvm_anyint_ty], [IntrConvergent, IntrWillReturn]
 >;
 
-def int_amdgcn_end_cf : Intrinsic<[], [llvm_anyint_ty], [IntrConvergent]>;
+def int_amdgcn_end_cf : Intrinsic<[], [llvm_anyint_ty],
+  [IntrConvergent, IntrWillReturn]>;
 
 // Represent unreachable in a divergent region.
 def int_amdgcn_unreachable : Intrinsic<[], [], [IntrConvergent]>;
@@ -1752,6 +2014,12 @@
 // pass based on !fpmath metadata.
 def int_amdgcn_fdiv_fast : Intrinsic<
   [llvm_float_ty], [llvm_float_ty, llvm_float_ty],
-  [IntrNoMem, IntrSpeculatable]
+  [IntrNoMem, IntrSpeculatable, IntrWillReturn]
+>;
+
+// Represent a relocation constant.
+def int_amdgcn_reloc_constant : Intrinsic<
+  [llvm_i32_ty], [llvm_metadata_ty],
+  [IntrNoMem, IntrSpeculatable, IntrWillReturn]
 >;
 }
diff --git a/linux-x64/clang/include/llvm/IR/IntrinsicsARM.h b/linux-x64/clang/include/llvm/IR/IntrinsicsARM.h
new file mode 100644
index 0000000..559a8c6
--- /dev/null
+++ b/linux-x64/clang/include/llvm/IR/IntrinsicsARM.h
@@ -0,0 +1,509 @@
+/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
+|*                                                                            *|
+|* Intrinsic Function Source Fragment                                         *|
+|*                                                                            *|
+|* Automatically generated file, do not edit!                                 *|
+|*                                                                            *|
+\*===----------------------------------------------------------------------===*/
+
+#ifndef LLVM_IR_INTRINSIC_ARM_ENUMS_H
+#define LLVM_IR_INTRINSIC_ARM_ENUMS_H
+
+namespace llvm {
+namespace Intrinsic {
+enum ARMIntrinsics : unsigned {
+// Enum values for intrinsics
+    arm_cde_cx1 = 1856,                               // llvm.arm.cde.cx1
+    arm_cde_cx1a,                              // llvm.arm.cde.cx1a
+    arm_cde_cx1d,                              // llvm.arm.cde.cx1d
+    arm_cde_cx1da,                             // llvm.arm.cde.cx1da
+    arm_cde_cx2,                               // llvm.arm.cde.cx2
+    arm_cde_cx2a,                              // llvm.arm.cde.cx2a
+    arm_cde_cx2d,                              // llvm.arm.cde.cx2d
+    arm_cde_cx2da,                             // llvm.arm.cde.cx2da
+    arm_cde_cx3,                               // llvm.arm.cde.cx3
+    arm_cde_cx3a,                              // llvm.arm.cde.cx3a
+    arm_cde_cx3d,                              // llvm.arm.cde.cx3d
+    arm_cde_cx3da,                             // llvm.arm.cde.cx3da
+    arm_cde_vcx1,                              // llvm.arm.cde.vcx1
+    arm_cde_vcx1a,                             // llvm.arm.cde.vcx1a
+    arm_cde_vcx1q,                             // llvm.arm.cde.vcx1q
+    arm_cde_vcx1q_predicated,                  // llvm.arm.cde.vcx1q.predicated
+    arm_cde_vcx1qa,                            // llvm.arm.cde.vcx1qa
+    arm_cde_vcx1qa_predicated,                 // llvm.arm.cde.vcx1qa.predicated
+    arm_cde_vcx2,                              // llvm.arm.cde.vcx2
+    arm_cde_vcx2a,                             // llvm.arm.cde.vcx2a
+    arm_cde_vcx2q,                             // llvm.arm.cde.vcx2q
+    arm_cde_vcx2q_predicated,                  // llvm.arm.cde.vcx2q.predicated
+    arm_cde_vcx2qa,                            // llvm.arm.cde.vcx2qa
+    arm_cde_vcx2qa_predicated,                 // llvm.arm.cde.vcx2qa.predicated
+    arm_cde_vcx3,                              // llvm.arm.cde.vcx3
+    arm_cde_vcx3a,                             // llvm.arm.cde.vcx3a
+    arm_cde_vcx3q,                             // llvm.arm.cde.vcx3q
+    arm_cde_vcx3q_predicated,                  // llvm.arm.cde.vcx3q.predicated
+    arm_cde_vcx3qa,                            // llvm.arm.cde.vcx3qa
+    arm_cde_vcx3qa_predicated,                 // llvm.arm.cde.vcx3qa.predicated
+    arm_cdp,                                   // llvm.arm.cdp
+    arm_cdp2,                                  // llvm.arm.cdp2
+    arm_clrex,                                 // llvm.arm.clrex
+    arm_cls,                                   // llvm.arm.cls
+    arm_cls64,                                 // llvm.arm.cls64
+    arm_cmse_tt,                               // llvm.arm.cmse.tt
+    arm_cmse_tta,                              // llvm.arm.cmse.tta
+    arm_cmse_ttat,                             // llvm.arm.cmse.ttat
+    arm_cmse_ttt,                              // llvm.arm.cmse.ttt
+    arm_crc32b,                                // llvm.arm.crc32b
+    arm_crc32cb,                               // llvm.arm.crc32cb
+    arm_crc32ch,                               // llvm.arm.crc32ch
+    arm_crc32cw,                               // llvm.arm.crc32cw
+    arm_crc32h,                                // llvm.arm.crc32h
+    arm_crc32w,                                // llvm.arm.crc32w
+    arm_dbg,                                   // llvm.arm.dbg
+    arm_dmb,                                   // llvm.arm.dmb
+    arm_dsb,                                   // llvm.arm.dsb
+    arm_get_fpscr,                             // llvm.arm.get.fpscr
+    arm_gnu_eabi_mcount,                       // llvm.arm.gnu.eabi.mcount
+    arm_hint,                                  // llvm.arm.hint
+    arm_isb,                                   // llvm.arm.isb
+    arm_ldaex,                                 // llvm.arm.ldaex
+    arm_ldaexd,                                // llvm.arm.ldaexd
+    arm_ldc,                                   // llvm.arm.ldc
+    arm_ldc2,                                  // llvm.arm.ldc2
+    arm_ldc2l,                                 // llvm.arm.ldc2l
+    arm_ldcl,                                  // llvm.arm.ldcl
+    arm_ldrex,                                 // llvm.arm.ldrex
+    arm_ldrexd,                                // llvm.arm.ldrexd
+    arm_mcr,                                   // llvm.arm.mcr
+    arm_mcr2,                                  // llvm.arm.mcr2
+    arm_mcrr,                                  // llvm.arm.mcrr
+    arm_mcrr2,                                 // llvm.arm.mcrr2
+    arm_mrc,                                   // llvm.arm.mrc
+    arm_mrc2,                                  // llvm.arm.mrc2
+    arm_mrrc,                                  // llvm.arm.mrrc
+    arm_mrrc2,                                 // llvm.arm.mrrc2
+    arm_mve_abd_predicated,                    // llvm.arm.mve.abd.predicated
+    arm_mve_abs_predicated,                    // llvm.arm.mve.abs.predicated
+    arm_mve_add_predicated,                    // llvm.arm.mve.add.predicated
+    arm_mve_addlv,                             // llvm.arm.mve.addlv
+    arm_mve_addlv_predicated,                  // llvm.arm.mve.addlv.predicated
+    arm_mve_addv,                              // llvm.arm.mve.addv
+    arm_mve_addv_predicated,                   // llvm.arm.mve.addv.predicated
+    arm_mve_and_predicated,                    // llvm.arm.mve.and.predicated
+    arm_mve_asrl,                              // llvm.arm.mve.asrl
+    arm_mve_bic_predicated,                    // llvm.arm.mve.bic.predicated
+    arm_mve_cls_predicated,                    // llvm.arm.mve.cls.predicated
+    arm_mve_clz_predicated,                    // llvm.arm.mve.clz.predicated
+    arm_mve_eor_predicated,                    // llvm.arm.mve.eor.predicated
+    arm_mve_fma_predicated,                    // llvm.arm.mve.fma.predicated
+    arm_mve_hadd_predicated,                   // llvm.arm.mve.hadd.predicated
+    arm_mve_hsub_predicated,                   // llvm.arm.mve.hsub.predicated
+    arm_mve_lsll,                              // llvm.arm.mve.lsll
+    arm_mve_max_predicated,                    // llvm.arm.mve.max.predicated
+    arm_mve_maxav,                             // llvm.arm.mve.maxav
+    arm_mve_maxav_predicated,                  // llvm.arm.mve.maxav.predicated
+    arm_mve_maxnmav,                           // llvm.arm.mve.maxnmav
+    arm_mve_maxnmav_predicated,                // llvm.arm.mve.maxnmav.predicated
+    arm_mve_maxnmv,                            // llvm.arm.mve.maxnmv
+    arm_mve_maxnmv_predicated,                 // llvm.arm.mve.maxnmv.predicated
+    arm_mve_maxv,                              // llvm.arm.mve.maxv
+    arm_mve_maxv_predicated,                   // llvm.arm.mve.maxv.predicated
+    arm_mve_min_predicated,                    // llvm.arm.mve.min.predicated
+    arm_mve_minav,                             // llvm.arm.mve.minav
+    arm_mve_minav_predicated,                  // llvm.arm.mve.minav.predicated
+    arm_mve_minnmav,                           // llvm.arm.mve.minnmav
+    arm_mve_minnmav_predicated,                // llvm.arm.mve.minnmav.predicated
+    arm_mve_minnmv,                            // llvm.arm.mve.minnmv
+    arm_mve_minnmv_predicated,                 // llvm.arm.mve.minnmv.predicated
+    arm_mve_minv,                              // llvm.arm.mve.minv
+    arm_mve_minv_predicated,                   // llvm.arm.mve.minv.predicated
+    arm_mve_mul_predicated,                    // llvm.arm.mve.mul.predicated
+    arm_mve_mulh_predicated,                   // llvm.arm.mve.mulh.predicated
+    arm_mve_mull_int_predicated,               // llvm.arm.mve.mull.int.predicated
+    arm_mve_mull_poly_predicated,              // llvm.arm.mve.mull.poly.predicated
+    arm_mve_mvn_predicated,                    // llvm.arm.mve.mvn.predicated
+    arm_mve_neg_predicated,                    // llvm.arm.mve.neg.predicated
+    arm_mve_orn_predicated,                    // llvm.arm.mve.orn.predicated
+    arm_mve_orr_predicated,                    // llvm.arm.mve.orr.predicated
+    arm_mve_pred_i2v,                          // llvm.arm.mve.pred.i2v
+    arm_mve_pred_v2i,                          // llvm.arm.mve.pred.v2i
+    arm_mve_qabs_predicated,                   // llvm.arm.mve.qabs.predicated
+    arm_mve_qadd_predicated,                   // llvm.arm.mve.qadd.predicated
+    arm_mve_qdmulh_predicated,                 // llvm.arm.mve.qdmulh.predicated
+    arm_mve_qneg_predicated,                   // llvm.arm.mve.qneg.predicated
+    arm_mve_qrdmulh_predicated,                // llvm.arm.mve.qrdmulh.predicated
+    arm_mve_qsub_predicated,                   // llvm.arm.mve.qsub.predicated
+    arm_mve_rhadd_predicated,                  // llvm.arm.mve.rhadd.predicated
+    arm_mve_rmulh_predicated,                  // llvm.arm.mve.rmulh.predicated
+    arm_mve_shl_imm_predicated,                // llvm.arm.mve.shl.imm.predicated
+    arm_mve_shr_imm_predicated,                // llvm.arm.mve.shr.imm.predicated
+    arm_mve_sqrshr,                            // llvm.arm.mve.sqrshr
+    arm_mve_sqrshrl,                           // llvm.arm.mve.sqrshrl
+    arm_mve_sqshl,                             // llvm.arm.mve.sqshl
+    arm_mve_sqshll,                            // llvm.arm.mve.sqshll
+    arm_mve_srshr,                             // llvm.arm.mve.srshr
+    arm_mve_srshrl,                            // llvm.arm.mve.srshrl
+    arm_mve_sub_predicated,                    // llvm.arm.mve.sub.predicated
+    arm_mve_uqrshl,                            // llvm.arm.mve.uqrshl
+    arm_mve_uqrshll,                           // llvm.arm.mve.uqrshll
+    arm_mve_uqshl,                             // llvm.arm.mve.uqshl
+    arm_mve_uqshll,                            // llvm.arm.mve.uqshll
+    arm_mve_urshr,                             // llvm.arm.mve.urshr
+    arm_mve_urshrl,                            // llvm.arm.mve.urshrl
+    arm_mve_vabav,                             // llvm.arm.mve.vabav
+    arm_mve_vabav_predicated,                  // llvm.arm.mve.vabav.predicated
+    arm_mve_vabd,                              // llvm.arm.mve.vabd
+    arm_mve_vadc,                              // llvm.arm.mve.vadc
+    arm_mve_vadc_predicated,                   // llvm.arm.mve.vadc.predicated
+    arm_mve_vbrsr,                             // llvm.arm.mve.vbrsr
+    arm_mve_vbrsr_predicated,                  // llvm.arm.mve.vbrsr.predicated
+    arm_mve_vcaddq,                            // llvm.arm.mve.vcaddq
+    arm_mve_vcaddq_predicated,                 // llvm.arm.mve.vcaddq.predicated
+    arm_mve_vcls,                              // llvm.arm.mve.vcls
+    arm_mve_vcmlaq,                            // llvm.arm.mve.vcmlaq
+    arm_mve_vcmlaq_predicated,                 // llvm.arm.mve.vcmlaq.predicated
+    arm_mve_vcmulq,                            // llvm.arm.mve.vcmulq
+    arm_mve_vcmulq_predicated,                 // llvm.arm.mve.vcmulq.predicated
+    arm_mve_vctp16,                            // llvm.arm.mve.vctp16
+    arm_mve_vctp32,                            // llvm.arm.mve.vctp32
+    arm_mve_vctp64,                            // llvm.arm.mve.vctp64
+    arm_mve_vctp8,                             // llvm.arm.mve.vctp8
+    arm_mve_vcvt_fix,                          // llvm.arm.mve.vcvt.fix
+    arm_mve_vcvt_fix_predicated,               // llvm.arm.mve.vcvt.fix.predicated
+    arm_mve_vcvt_fp_int_predicated,            // llvm.arm.mve.vcvt.fp.int.predicated
+    arm_mve_vcvt_narrow,                       // llvm.arm.mve.vcvt.narrow
+    arm_mve_vcvt_narrow_predicated,            // llvm.arm.mve.vcvt.narrow.predicated
+    arm_mve_vcvt_widen,                        // llvm.arm.mve.vcvt.widen
+    arm_mve_vcvt_widen_predicated,             // llvm.arm.mve.vcvt.widen.predicated
+    arm_mve_vcvta,                             // llvm.arm.mve.vcvta
+    arm_mve_vcvta_predicated,                  // llvm.arm.mve.vcvta.predicated
+    arm_mve_vcvtm,                             // llvm.arm.mve.vcvtm
+    arm_mve_vcvtm_predicated,                  // llvm.arm.mve.vcvtm.predicated
+    arm_mve_vcvtn,                             // llvm.arm.mve.vcvtn
+    arm_mve_vcvtn_predicated,                  // llvm.arm.mve.vcvtn.predicated
+    arm_mve_vcvtp,                             // llvm.arm.mve.vcvtp
+    arm_mve_vcvtp_predicated,                  // llvm.arm.mve.vcvtp.predicated
+    arm_mve_vddup,                             // llvm.arm.mve.vddup
+    arm_mve_vddup_predicated,                  // llvm.arm.mve.vddup.predicated
+    arm_mve_vdwdup,                            // llvm.arm.mve.vdwdup
+    arm_mve_vdwdup_predicated,                 // llvm.arm.mve.vdwdup.predicated
+    arm_mve_vhadd,                             // llvm.arm.mve.vhadd
+    arm_mve_vhsub,                             // llvm.arm.mve.vhsub
+    arm_mve_vidup,                             // llvm.arm.mve.vidup
+    arm_mve_vidup_predicated,                  // llvm.arm.mve.vidup.predicated
+    arm_mve_viwdup,                            // llvm.arm.mve.viwdup
+    arm_mve_viwdup_predicated,                 // llvm.arm.mve.viwdup.predicated
+    arm_mve_vld2q,                             // llvm.arm.mve.vld2q
+    arm_mve_vld4q,                             // llvm.arm.mve.vld4q
+    arm_mve_vldr_gather_base,                  // llvm.arm.mve.vldr.gather.base
+    arm_mve_vldr_gather_base_predicated,       // llvm.arm.mve.vldr.gather.base.predicated
+    arm_mve_vldr_gather_base_wb,               // llvm.arm.mve.vldr.gather.base.wb
+    arm_mve_vldr_gather_base_wb_predicated,    // llvm.arm.mve.vldr.gather.base.wb.predicated
+    arm_mve_vldr_gather_offset,                // llvm.arm.mve.vldr.gather.offset
+    arm_mve_vldr_gather_offset_predicated,     // llvm.arm.mve.vldr.gather.offset.predicated
+    arm_mve_vmaxa_predicated,                  // llvm.arm.mve.vmaxa.predicated
+    arm_mve_vmaxnma_predicated,                // llvm.arm.mve.vmaxnma.predicated
+    arm_mve_vmina_predicated,                  // llvm.arm.mve.vmina.predicated
+    arm_mve_vminnma_predicated,                // llvm.arm.mve.vminnma.predicated
+    arm_mve_vmla_n_predicated,                 // llvm.arm.mve.vmla.n.predicated
+    arm_mve_vmlas_n_predicated,                // llvm.arm.mve.vmlas.n.predicated
+    arm_mve_vmldava,                           // llvm.arm.mve.vmldava
+    arm_mve_vmldava_predicated,                // llvm.arm.mve.vmldava.predicated
+    arm_mve_vmlldava,                          // llvm.arm.mve.vmlldava
+    arm_mve_vmlldava_predicated,               // llvm.arm.mve.vmlldava.predicated
+    arm_mve_vmovl_predicated,                  // llvm.arm.mve.vmovl.predicated
+    arm_mve_vmovn_predicated,                  // llvm.arm.mve.vmovn.predicated
+    arm_mve_vmulh,                             // llvm.arm.mve.vmulh
+    arm_mve_vmull,                             // llvm.arm.mve.vmull
+    arm_mve_vmull_poly,                        // llvm.arm.mve.vmull.poly
+    arm_mve_vqdmlad,                           // llvm.arm.mve.vqdmlad
+    arm_mve_vqdmlad_predicated,                // llvm.arm.mve.vqdmlad.predicated
+    arm_mve_vqdmlah,                           // llvm.arm.mve.vqdmlah
+    arm_mve_vqdmlah_predicated,                // llvm.arm.mve.vqdmlah.predicated
+    arm_mve_vqdmlash,                          // llvm.arm.mve.vqdmlash
+    arm_mve_vqdmlash_predicated,               // llvm.arm.mve.vqdmlash.predicated
+    arm_mve_vqdmulh,                           // llvm.arm.mve.vqdmulh
+    arm_mve_vqdmull,                           // llvm.arm.mve.vqdmull
+    arm_mve_vqdmull_predicated,                // llvm.arm.mve.vqdmull.predicated
+    arm_mve_vqmovn,                            // llvm.arm.mve.vqmovn
+    arm_mve_vqmovn_predicated,                 // llvm.arm.mve.vqmovn.predicated
+    arm_mve_vqrdmlah,                          // llvm.arm.mve.vqrdmlah
+    arm_mve_vqrdmlah_predicated,               // llvm.arm.mve.vqrdmlah.predicated
+    arm_mve_vqrdmlash,                         // llvm.arm.mve.vqrdmlash
+    arm_mve_vqrdmlash_predicated,              // llvm.arm.mve.vqrdmlash.predicated
+    arm_mve_vqrdmulh,                          // llvm.arm.mve.vqrdmulh
+    arm_mve_vqshl_imm,                         // llvm.arm.mve.vqshl.imm
+    arm_mve_vqshl_imm_predicated,              // llvm.arm.mve.vqshl.imm.predicated
+    arm_mve_vqshlu_imm,                        // llvm.arm.mve.vqshlu.imm
+    arm_mve_vqshlu_imm_predicated,             // llvm.arm.mve.vqshlu.imm.predicated
+    arm_mve_vreinterpretq,                     // llvm.arm.mve.vreinterpretq
+    arm_mve_vrev_predicated,                   // llvm.arm.mve.vrev.predicated
+    arm_mve_vrhadd,                            // llvm.arm.mve.vrhadd
+    arm_mve_vrinta_predicated,                 // llvm.arm.mve.vrinta.predicated
+    arm_mve_vrintm_predicated,                 // llvm.arm.mve.vrintm.predicated
+    arm_mve_vrintn,                            // llvm.arm.mve.vrintn
+    arm_mve_vrintn_predicated,                 // llvm.arm.mve.vrintn.predicated
+    arm_mve_vrintp_predicated,                 // llvm.arm.mve.vrintp.predicated
+    arm_mve_vrintx_predicated,                 // llvm.arm.mve.vrintx.predicated
+    arm_mve_vrintz_predicated,                 // llvm.arm.mve.vrintz.predicated
+    arm_mve_vrmlldavha,                        // llvm.arm.mve.vrmlldavha
+    arm_mve_vrmlldavha_predicated,             // llvm.arm.mve.vrmlldavha.predicated
+    arm_mve_vrmulh,                            // llvm.arm.mve.vrmulh
+    arm_mve_vrshr_imm,                         // llvm.arm.mve.vrshr.imm
+    arm_mve_vrshr_imm_predicated,              // llvm.arm.mve.vrshr.imm.predicated
+    arm_mve_vsbc,                              // llvm.arm.mve.vsbc
+    arm_mve_vsbc_predicated,                   // llvm.arm.mve.vsbc.predicated
+    arm_mve_vshl_scalar,                       // llvm.arm.mve.vshl.scalar
+    arm_mve_vshl_scalar_predicated,            // llvm.arm.mve.vshl.scalar.predicated
+    arm_mve_vshl_vector,                       // llvm.arm.mve.vshl.vector
+    arm_mve_vshl_vector_predicated,            // llvm.arm.mve.vshl.vector.predicated
+    arm_mve_vshlc,                             // llvm.arm.mve.vshlc
+    arm_mve_vshlc_predicated,                  // llvm.arm.mve.vshlc.predicated
+    arm_mve_vshll_imm,                         // llvm.arm.mve.vshll.imm
+    arm_mve_vshll_imm_predicated,              // llvm.arm.mve.vshll.imm.predicated
+    arm_mve_vshrn,                             // llvm.arm.mve.vshrn
+    arm_mve_vshrn_predicated,                  // llvm.arm.mve.vshrn.predicated
+    arm_mve_vsli,                              // llvm.arm.mve.vsli
+    arm_mve_vsli_predicated,                   // llvm.arm.mve.vsli.predicated
+    arm_mve_vsri,                              // llvm.arm.mve.vsri
+    arm_mve_vsri_predicated,                   // llvm.arm.mve.vsri.predicated
+    arm_mve_vst2q,                             // llvm.arm.mve.vst2q
+    arm_mve_vst4q,                             // llvm.arm.mve.vst4q
+    arm_mve_vstr_scatter_base,                 // llvm.arm.mve.vstr.scatter.base
+    arm_mve_vstr_scatter_base_predicated,      // llvm.arm.mve.vstr.scatter.base.predicated
+    arm_mve_vstr_scatter_base_wb,              // llvm.arm.mve.vstr.scatter.base.wb
+    arm_mve_vstr_scatter_base_wb_predicated,   // llvm.arm.mve.vstr.scatter.base.wb.predicated
+    arm_mve_vstr_scatter_offset,               // llvm.arm.mve.vstr.scatter.offset
+    arm_mve_vstr_scatter_offset_predicated,    // llvm.arm.mve.vstr.scatter.offset.predicated
+    arm_neon_aesd,                             // llvm.arm.neon.aesd
+    arm_neon_aese,                             // llvm.arm.neon.aese
+    arm_neon_aesimc,                           // llvm.arm.neon.aesimc
+    arm_neon_aesmc,                            // llvm.arm.neon.aesmc
+    arm_neon_bfdot,                            // llvm.arm.neon.bfdot
+    arm_neon_bfmlalb,                          // llvm.arm.neon.bfmlalb
+    arm_neon_bfmlalt,                          // llvm.arm.neon.bfmlalt
+    arm_neon_bfmmla,                           // llvm.arm.neon.bfmmla
+    arm_neon_sdot,                             // llvm.arm.neon.sdot
+    arm_neon_sha1c,                            // llvm.arm.neon.sha1c
+    arm_neon_sha1h,                            // llvm.arm.neon.sha1h
+    arm_neon_sha1m,                            // llvm.arm.neon.sha1m
+    arm_neon_sha1p,                            // llvm.arm.neon.sha1p
+    arm_neon_sha1su0,                          // llvm.arm.neon.sha1su0
+    arm_neon_sha1su1,                          // llvm.arm.neon.sha1su1
+    arm_neon_sha256h,                          // llvm.arm.neon.sha256h
+    arm_neon_sha256h2,                         // llvm.arm.neon.sha256h2
+    arm_neon_sha256su0,                        // llvm.arm.neon.sha256su0
+    arm_neon_sha256su1,                        // llvm.arm.neon.sha256su1
+    arm_neon_smmla,                            // llvm.arm.neon.smmla
+    arm_neon_udot,                             // llvm.arm.neon.udot
+    arm_neon_ummla,                            // llvm.arm.neon.ummla
+    arm_neon_usdot,                            // llvm.arm.neon.usdot
+    arm_neon_usmmla,                           // llvm.arm.neon.usmmla
+    arm_neon_vabds,                            // llvm.arm.neon.vabds
+    arm_neon_vabdu,                            // llvm.arm.neon.vabdu
+    arm_neon_vabs,                             // llvm.arm.neon.vabs
+    arm_neon_vacge,                            // llvm.arm.neon.vacge
+    arm_neon_vacgt,                            // llvm.arm.neon.vacgt
+    arm_neon_vbsl,                             // llvm.arm.neon.vbsl
+    arm_neon_vcadd_rot270,                     // llvm.arm.neon.vcadd.rot270
+    arm_neon_vcadd_rot90,                      // llvm.arm.neon.vcadd.rot90
+    arm_neon_vcls,                             // llvm.arm.neon.vcls
+    arm_neon_vcvtas,                           // llvm.arm.neon.vcvtas
+    arm_neon_vcvtau,                           // llvm.arm.neon.vcvtau
+    arm_neon_vcvtbfp2bf,                       // llvm.arm.neon.vcvtbfp2bf
+    arm_neon_vcvtfp2bf,                        // llvm.arm.neon.vcvtfp2bf
+    arm_neon_vcvtfp2fxs,                       // llvm.arm.neon.vcvtfp2fxs
+    arm_neon_vcvtfp2fxu,                       // llvm.arm.neon.vcvtfp2fxu
+    arm_neon_vcvtfp2hf,                        // llvm.arm.neon.vcvtfp2hf
+    arm_neon_vcvtfxs2fp,                       // llvm.arm.neon.vcvtfxs2fp
+    arm_neon_vcvtfxu2fp,                       // llvm.arm.neon.vcvtfxu2fp
+    arm_neon_vcvthf2fp,                        // llvm.arm.neon.vcvthf2fp
+    arm_neon_vcvtms,                           // llvm.arm.neon.vcvtms
+    arm_neon_vcvtmu,                           // llvm.arm.neon.vcvtmu
+    arm_neon_vcvtns,                           // llvm.arm.neon.vcvtns
+    arm_neon_vcvtnu,                           // llvm.arm.neon.vcvtnu
+    arm_neon_vcvtps,                           // llvm.arm.neon.vcvtps
+    arm_neon_vcvtpu,                           // llvm.arm.neon.vcvtpu
+    arm_neon_vhadds,                           // llvm.arm.neon.vhadds
+    arm_neon_vhaddu,                           // llvm.arm.neon.vhaddu
+    arm_neon_vhsubs,                           // llvm.arm.neon.vhsubs
+    arm_neon_vhsubu,                           // llvm.arm.neon.vhsubu
+    arm_neon_vld1,                             // llvm.arm.neon.vld1
+    arm_neon_vld1x2,                           // llvm.arm.neon.vld1x2
+    arm_neon_vld1x3,                           // llvm.arm.neon.vld1x3
+    arm_neon_vld1x4,                           // llvm.arm.neon.vld1x4
+    arm_neon_vld2,                             // llvm.arm.neon.vld2
+    arm_neon_vld2dup,                          // llvm.arm.neon.vld2dup
+    arm_neon_vld2lane,                         // llvm.arm.neon.vld2lane
+    arm_neon_vld3,                             // llvm.arm.neon.vld3
+    arm_neon_vld3dup,                          // llvm.arm.neon.vld3dup
+    arm_neon_vld3lane,                         // llvm.arm.neon.vld3lane
+    arm_neon_vld4,                             // llvm.arm.neon.vld4
+    arm_neon_vld4dup,                          // llvm.arm.neon.vld4dup
+    arm_neon_vld4lane,                         // llvm.arm.neon.vld4lane
+    arm_neon_vmaxnm,                           // llvm.arm.neon.vmaxnm
+    arm_neon_vmaxs,                            // llvm.arm.neon.vmaxs
+    arm_neon_vmaxu,                            // llvm.arm.neon.vmaxu
+    arm_neon_vminnm,                           // llvm.arm.neon.vminnm
+    arm_neon_vmins,                            // llvm.arm.neon.vmins
+    arm_neon_vminu,                            // llvm.arm.neon.vminu
+    arm_neon_vmullp,                           // llvm.arm.neon.vmullp
+    arm_neon_vmulls,                           // llvm.arm.neon.vmulls
+    arm_neon_vmullu,                           // llvm.arm.neon.vmullu
+    arm_neon_vmulp,                            // llvm.arm.neon.vmulp
+    arm_neon_vpadals,                          // llvm.arm.neon.vpadals
+    arm_neon_vpadalu,                          // llvm.arm.neon.vpadalu
+    arm_neon_vpadd,                            // llvm.arm.neon.vpadd
+    arm_neon_vpaddls,                          // llvm.arm.neon.vpaddls
+    arm_neon_vpaddlu,                          // llvm.arm.neon.vpaddlu
+    arm_neon_vpmaxs,                           // llvm.arm.neon.vpmaxs
+    arm_neon_vpmaxu,                           // llvm.arm.neon.vpmaxu
+    arm_neon_vpmins,                           // llvm.arm.neon.vpmins
+    arm_neon_vpminu,                           // llvm.arm.neon.vpminu
+    arm_neon_vqabs,                            // llvm.arm.neon.vqabs
+    arm_neon_vqdmulh,                          // llvm.arm.neon.vqdmulh
+    arm_neon_vqdmull,                          // llvm.arm.neon.vqdmull
+    arm_neon_vqmovns,                          // llvm.arm.neon.vqmovns
+    arm_neon_vqmovnsu,                         // llvm.arm.neon.vqmovnsu
+    arm_neon_vqmovnu,                          // llvm.arm.neon.vqmovnu
+    arm_neon_vqneg,                            // llvm.arm.neon.vqneg
+    arm_neon_vqrdmulh,                         // llvm.arm.neon.vqrdmulh
+    arm_neon_vqrshiftns,                       // llvm.arm.neon.vqrshiftns
+    arm_neon_vqrshiftnsu,                      // llvm.arm.neon.vqrshiftnsu
+    arm_neon_vqrshiftnu,                       // llvm.arm.neon.vqrshiftnu
+    arm_neon_vqrshifts,                        // llvm.arm.neon.vqrshifts
+    arm_neon_vqrshiftu,                        // llvm.arm.neon.vqrshiftu
+    arm_neon_vqshiftns,                        // llvm.arm.neon.vqshiftns
+    arm_neon_vqshiftnsu,                       // llvm.arm.neon.vqshiftnsu
+    arm_neon_vqshiftnu,                        // llvm.arm.neon.vqshiftnu
+    arm_neon_vqshifts,                         // llvm.arm.neon.vqshifts
+    arm_neon_vqshiftsu,                        // llvm.arm.neon.vqshiftsu
+    arm_neon_vqshiftu,                         // llvm.arm.neon.vqshiftu
+    arm_neon_vraddhn,                          // llvm.arm.neon.vraddhn
+    arm_neon_vrecpe,                           // llvm.arm.neon.vrecpe
+    arm_neon_vrecps,                           // llvm.arm.neon.vrecps
+    arm_neon_vrhadds,                          // llvm.arm.neon.vrhadds
+    arm_neon_vrhaddu,                          // llvm.arm.neon.vrhaddu
+    arm_neon_vrinta,                           // llvm.arm.neon.vrinta
+    arm_neon_vrintm,                           // llvm.arm.neon.vrintm
+    arm_neon_vrintn,                           // llvm.arm.neon.vrintn
+    arm_neon_vrintp,                           // llvm.arm.neon.vrintp
+    arm_neon_vrintx,                           // llvm.arm.neon.vrintx
+    arm_neon_vrintz,                           // llvm.arm.neon.vrintz
+    arm_neon_vrshiftn,                         // llvm.arm.neon.vrshiftn
+    arm_neon_vrshifts,                         // llvm.arm.neon.vrshifts
+    arm_neon_vrshiftu,                         // llvm.arm.neon.vrshiftu
+    arm_neon_vrsqrte,                          // llvm.arm.neon.vrsqrte
+    arm_neon_vrsqrts,                          // llvm.arm.neon.vrsqrts
+    arm_neon_vrsubhn,                          // llvm.arm.neon.vrsubhn
+    arm_neon_vshiftins,                        // llvm.arm.neon.vshiftins
+    arm_neon_vshifts,                          // llvm.arm.neon.vshifts
+    arm_neon_vshiftu,                          // llvm.arm.neon.vshiftu
+    arm_neon_vst1,                             // llvm.arm.neon.vst1
+    arm_neon_vst1x2,                           // llvm.arm.neon.vst1x2
+    arm_neon_vst1x3,                           // llvm.arm.neon.vst1x3
+    arm_neon_vst1x4,                           // llvm.arm.neon.vst1x4
+    arm_neon_vst2,                             // llvm.arm.neon.vst2
+    arm_neon_vst2lane,                         // llvm.arm.neon.vst2lane
+    arm_neon_vst3,                             // llvm.arm.neon.vst3
+    arm_neon_vst3lane,                         // llvm.arm.neon.vst3lane
+    arm_neon_vst4,                             // llvm.arm.neon.vst4
+    arm_neon_vst4lane,                         // llvm.arm.neon.vst4lane
+    arm_neon_vtbl1,                            // llvm.arm.neon.vtbl1
+    arm_neon_vtbl2,                            // llvm.arm.neon.vtbl2
+    arm_neon_vtbl3,                            // llvm.arm.neon.vtbl3
+    arm_neon_vtbl4,                            // llvm.arm.neon.vtbl4
+    arm_neon_vtbx1,                            // llvm.arm.neon.vtbx1
+    arm_neon_vtbx2,                            // llvm.arm.neon.vtbx2
+    arm_neon_vtbx3,                            // llvm.arm.neon.vtbx3
+    arm_neon_vtbx4,                            // llvm.arm.neon.vtbx4
+    arm_qadd,                                  // llvm.arm.qadd
+    arm_qadd16,                                // llvm.arm.qadd16
+    arm_qadd8,                                 // llvm.arm.qadd8
+    arm_qasx,                                  // llvm.arm.qasx
+    arm_qsax,                                  // llvm.arm.qsax
+    arm_qsub,                                  // llvm.arm.qsub
+    arm_qsub16,                                // llvm.arm.qsub16
+    arm_qsub8,                                 // llvm.arm.qsub8
+    arm_sadd16,                                // llvm.arm.sadd16
+    arm_sadd8,                                 // llvm.arm.sadd8
+    arm_sasx,                                  // llvm.arm.sasx
+    arm_sel,                                   // llvm.arm.sel
+    arm_set_fpscr,                             // llvm.arm.set.fpscr
+    arm_shadd16,                               // llvm.arm.shadd16
+    arm_shadd8,                                // llvm.arm.shadd8
+    arm_shasx,                                 // llvm.arm.shasx
+    arm_shsax,                                 // llvm.arm.shsax
+    arm_shsub16,                               // llvm.arm.shsub16
+    arm_shsub8,                                // llvm.arm.shsub8
+    arm_smlabb,                                // llvm.arm.smlabb
+    arm_smlabt,                                // llvm.arm.smlabt
+    arm_smlad,                                 // llvm.arm.smlad
+    arm_smladx,                                // llvm.arm.smladx
+    arm_smlald,                                // llvm.arm.smlald
+    arm_smlaldx,                               // llvm.arm.smlaldx
+    arm_smlatb,                                // llvm.arm.smlatb
+    arm_smlatt,                                // llvm.arm.smlatt
+    arm_smlawb,                                // llvm.arm.smlawb
+    arm_smlawt,                                // llvm.arm.smlawt
+    arm_smlsd,                                 // llvm.arm.smlsd
+    arm_smlsdx,                                // llvm.arm.smlsdx
+    arm_smlsld,                                // llvm.arm.smlsld
+    arm_smlsldx,                               // llvm.arm.smlsldx
+    arm_smuad,                                 // llvm.arm.smuad
+    arm_smuadx,                                // llvm.arm.smuadx
+    arm_smulbb,                                // llvm.arm.smulbb
+    arm_smulbt,                                // llvm.arm.smulbt
+    arm_smultb,                                // llvm.arm.smultb
+    arm_smultt,                                // llvm.arm.smultt
+    arm_smulwb,                                // llvm.arm.smulwb
+    arm_smulwt,                                // llvm.arm.smulwt
+    arm_smusd,                                 // llvm.arm.smusd
+    arm_smusdx,                                // llvm.arm.smusdx
+    arm_space,                                 // llvm.arm.space
+    arm_ssat,                                  // llvm.arm.ssat
+    arm_ssat16,                                // llvm.arm.ssat16
+    arm_ssax,                                  // llvm.arm.ssax
+    arm_ssub16,                                // llvm.arm.ssub16
+    arm_ssub8,                                 // llvm.arm.ssub8
+    arm_stc,                                   // llvm.arm.stc
+    arm_stc2,                                  // llvm.arm.stc2
+    arm_stc2l,                                 // llvm.arm.stc2l
+    arm_stcl,                                  // llvm.arm.stcl
+    arm_stlex,                                 // llvm.arm.stlex
+    arm_stlexd,                                // llvm.arm.stlexd
+    arm_strex,                                 // llvm.arm.strex
+    arm_strexd,                                // llvm.arm.strexd
+    arm_sxtab16,                               // llvm.arm.sxtab16
+    arm_sxtb16,                                // llvm.arm.sxtb16
+    arm_uadd16,                                // llvm.arm.uadd16
+    arm_uadd8,                                 // llvm.arm.uadd8
+    arm_uasx,                                  // llvm.arm.uasx
+    arm_uhadd16,                               // llvm.arm.uhadd16
+    arm_uhadd8,                                // llvm.arm.uhadd8
+    arm_uhasx,                                 // llvm.arm.uhasx
+    arm_uhsax,                                 // llvm.arm.uhsax
+    arm_uhsub16,                               // llvm.arm.uhsub16
+    arm_uhsub8,                                // llvm.arm.uhsub8
+    arm_undefined,                             // llvm.arm.undefined
+    arm_uqadd16,                               // llvm.arm.uqadd16
+    arm_uqadd8,                                // llvm.arm.uqadd8
+    arm_uqasx,                                 // llvm.arm.uqasx
+    arm_uqsax,                                 // llvm.arm.uqsax
+    arm_uqsub16,                               // llvm.arm.uqsub16
+    arm_uqsub8,                                // llvm.arm.uqsub8
+    arm_usad8,                                 // llvm.arm.usad8
+    arm_usada8,                                // llvm.arm.usada8
+    arm_usat,                                  // llvm.arm.usat
+    arm_usat16,                                // llvm.arm.usat16
+    arm_usax,                                  // llvm.arm.usax
+    arm_usub16,                                // llvm.arm.usub16
+    arm_usub8,                                 // llvm.arm.usub8
+    arm_uxtab16,                               // llvm.arm.uxtab16
+    arm_uxtb16,                                // llvm.arm.uxtb16
+    arm_vcvtr,                                 // llvm.arm.vcvtr
+    arm_vcvtru,                                // llvm.arm.vcvtru
+}; // enum
+} // namespace Intrinsic
+} // namespace llvm
+
+#endif
diff --git a/linux-x64/clang/include/llvm/IR/IntrinsicsARM.td b/linux-x64/clang/include/llvm/IR/IntrinsicsARM.td
index 3d9a4fa..0eb27cc 100644
--- a/linux-x64/clang/include/llvm/IR/IntrinsicsARM.td
+++ b/linux-x64/clang/include/llvm/IR/IntrinsicsARM.td
@@ -19,7 +19,7 @@
 // A space-consuming intrinsic primarily for testing ARMConstantIslands. The
 // first argument is the number of bytes this "instruction" takes up, the second
 // and return value are essentially chains, used to force ordering during ISel.
-def int_arm_space : Intrinsic<[llvm_i32_ty], [llvm_i32_ty, llvm_i32_ty], []>;
+def int_arm_space : Intrinsic<[llvm_i32_ty], [llvm_i32_ty, llvm_i32_ty], [ImmArg<ArgIndex<0>>]>;
 
 // 16-bit multiplications
 def int_arm_smulbb : GCCBuiltin<"__builtin_arm_smulbb">,
@@ -262,59 +262,59 @@
 // Coprocessor
 
 def int_arm_ldc : GCCBuiltin<"__builtin_arm_ldc">,
-   Intrinsic<[], [llvm_i32_ty, llvm_i32_ty, llvm_ptr_ty], [ImmArg<0>, ImmArg<1>]>;
+   Intrinsic<[], [llvm_i32_ty, llvm_i32_ty, llvm_ptr_ty], [ImmArg<ArgIndex<0>>, ImmArg<ArgIndex<1>>]>;
 def int_arm_ldcl : GCCBuiltin<"__builtin_arm_ldcl">,
-   Intrinsic<[], [llvm_i32_ty, llvm_i32_ty, llvm_ptr_ty], [ImmArg<0>, ImmArg<1>]>;
+   Intrinsic<[], [llvm_i32_ty, llvm_i32_ty, llvm_ptr_ty], [ImmArg<ArgIndex<0>>, ImmArg<ArgIndex<1>>]>;
 def int_arm_ldc2 : GCCBuiltin<"__builtin_arm_ldc2">,
-   Intrinsic<[], [llvm_i32_ty, llvm_i32_ty, llvm_ptr_ty], [ImmArg<0>, ImmArg<1>]>;
+   Intrinsic<[], [llvm_i32_ty, llvm_i32_ty, llvm_ptr_ty], [ImmArg<ArgIndex<0>>, ImmArg<ArgIndex<1>>]>;
 def int_arm_ldc2l : GCCBuiltin<"__builtin_arm_ldc2l">,
-   Intrinsic<[], [llvm_i32_ty, llvm_i32_ty, llvm_ptr_ty], [ImmArg<0>, ImmArg<1>]>;
+   Intrinsic<[], [llvm_i32_ty, llvm_i32_ty, llvm_ptr_ty], [ImmArg<ArgIndex<0>>, ImmArg<ArgIndex<1>>]>;
 
 def int_arm_stc : GCCBuiltin<"__builtin_arm_stc">,
-   Intrinsic<[], [llvm_i32_ty, llvm_i32_ty, llvm_ptr_ty], [ImmArg<0>, ImmArg<1>]>;
+   Intrinsic<[], [llvm_i32_ty, llvm_i32_ty, llvm_ptr_ty], [ImmArg<ArgIndex<0>>, ImmArg<ArgIndex<1>>]>;
 def int_arm_stcl : GCCBuiltin<"__builtin_arm_stcl">,
-   Intrinsic<[], [llvm_i32_ty, llvm_i32_ty, llvm_ptr_ty], [ImmArg<0>, ImmArg<1>]>;
+   Intrinsic<[], [llvm_i32_ty, llvm_i32_ty, llvm_ptr_ty], [ImmArg<ArgIndex<0>>, ImmArg<ArgIndex<1>>]>;
 def int_arm_stc2 : GCCBuiltin<"__builtin_arm_stc2">,
-   Intrinsic<[], [llvm_i32_ty, llvm_i32_ty, llvm_ptr_ty], [ImmArg<0>, ImmArg<1>]>;
+   Intrinsic<[], [llvm_i32_ty, llvm_i32_ty, llvm_ptr_ty], [ImmArg<ArgIndex<0>>, ImmArg<ArgIndex<1>>]>;
 def int_arm_stc2l : GCCBuiltin<"__builtin_arm_stc2l">,
-   Intrinsic<[], [llvm_i32_ty, llvm_i32_ty, llvm_ptr_ty], [ImmArg<0>, ImmArg<1>]>;
+   Intrinsic<[], [llvm_i32_ty, llvm_i32_ty, llvm_ptr_ty], [ImmArg<ArgIndex<0>>, ImmArg<ArgIndex<1>>]>;
 
 // Move to coprocessor
 def int_arm_mcr : GCCBuiltin<"__builtin_arm_mcr">,
    Intrinsic<[], [llvm_i32_ty, llvm_i32_ty, llvm_i32_ty,
-                  llvm_i32_ty, llvm_i32_ty, llvm_i32_ty], [ImmArg<0>, ImmArg<1>, ImmArg<3>, ImmArg<4>, ImmArg<5>]>;
+                  llvm_i32_ty, llvm_i32_ty, llvm_i32_ty], [ImmArg<ArgIndex<0>>, ImmArg<ArgIndex<1>>, ImmArg<ArgIndex<3>>, ImmArg<ArgIndex<4>>, ImmArg<ArgIndex<5>>]>;
 def int_arm_mcr2 : GCCBuiltin<"__builtin_arm_mcr2">,
    Intrinsic<[], [llvm_i32_ty, llvm_i32_ty, llvm_i32_ty,
-                  llvm_i32_ty, llvm_i32_ty, llvm_i32_ty], [ImmArg<0>, ImmArg<1>, ImmArg<3>, ImmArg<4>, ImmArg<5>]>;
+                  llvm_i32_ty, llvm_i32_ty, llvm_i32_ty], [ImmArg<ArgIndex<0>>, ImmArg<ArgIndex<1>>, ImmArg<ArgIndex<3>>, ImmArg<ArgIndex<4>>, ImmArg<ArgIndex<5>>]>;
 
 // Move from coprocessor
 def int_arm_mrc : GCCBuiltin<"__builtin_arm_mrc">,
                   MSBuiltin<"_MoveFromCoprocessor">,
    Intrinsic<[llvm_i32_ty], [llvm_i32_ty, llvm_i32_ty, llvm_i32_ty,
-                             llvm_i32_ty, llvm_i32_ty], [ImmArg<0>, ImmArg<1>, ImmArg<2>, ImmArg<3>, ImmArg<4>]>;
+                             llvm_i32_ty, llvm_i32_ty], [ImmArg<ArgIndex<0>>, ImmArg<ArgIndex<1>>, ImmArg<ArgIndex<2>>, ImmArg<ArgIndex<3>>, ImmArg<ArgIndex<4>>]>;
 def int_arm_mrc2 : GCCBuiltin<"__builtin_arm_mrc2">,
                    MSBuiltin<"_MoveFromCoprocessor2">,
    Intrinsic<[llvm_i32_ty], [llvm_i32_ty, llvm_i32_ty, llvm_i32_ty,
-                             llvm_i32_ty, llvm_i32_ty], [ImmArg<0>, ImmArg<1>, ImmArg<2>, ImmArg<3>, ImmArg<4>]>;
+                             llvm_i32_ty, llvm_i32_ty], [ImmArg<ArgIndex<0>>, ImmArg<ArgIndex<1>>, ImmArg<ArgIndex<2>>, ImmArg<ArgIndex<3>>, ImmArg<ArgIndex<4>>]>;
 
 // Coprocessor data processing
 def int_arm_cdp : GCCBuiltin<"__builtin_arm_cdp">,
    Intrinsic<[], [llvm_i32_ty, llvm_i32_ty, llvm_i32_ty,
-                  llvm_i32_ty, llvm_i32_ty, llvm_i32_ty], [ImmArg<0>, ImmArg<1>, ImmArg<2>, ImmArg<3>, ImmArg<4>, ImmArg<5>]>;
+                  llvm_i32_ty, llvm_i32_ty, llvm_i32_ty], [ImmArg<ArgIndex<0>>, ImmArg<ArgIndex<1>>, ImmArg<ArgIndex<2>>, ImmArg<ArgIndex<3>>, ImmArg<ArgIndex<4>>, ImmArg<ArgIndex<5>>]>;
 def int_arm_cdp2 : GCCBuiltin<"__builtin_arm_cdp2">,
    Intrinsic<[], [llvm_i32_ty, llvm_i32_ty, llvm_i32_ty,
-                  llvm_i32_ty, llvm_i32_ty, llvm_i32_ty], [ImmArg<0>, ImmArg<1>, ImmArg<2>, ImmArg<3>, ImmArg<4>, ImmArg<5>]>;
+                  llvm_i32_ty, llvm_i32_ty, llvm_i32_ty], [ImmArg<ArgIndex<0>>, ImmArg<ArgIndex<1>>, ImmArg<ArgIndex<2>>, ImmArg<ArgIndex<3>>, ImmArg<ArgIndex<4>>, ImmArg<ArgIndex<5>>]>;
 
 // Move from two registers to coprocessor
 def int_arm_mcrr : Intrinsic<[], [llvm_i32_ty, llvm_i32_ty, llvm_i32_ty,
-                                  llvm_i32_ty, llvm_i32_ty], [ImmArg<0>, ImmArg<1>, ImmArg<4>]>;
+                                  llvm_i32_ty, llvm_i32_ty], [ImmArg<ArgIndex<0>>, ImmArg<ArgIndex<1>>, ImmArg<ArgIndex<4>>]>;
 def int_arm_mcrr2 : Intrinsic<[], [llvm_i32_ty, llvm_i32_ty, llvm_i32_ty,
-                                   llvm_i32_ty, llvm_i32_ty], [ImmArg<0>, ImmArg<1>, ImmArg<4>]>;
+                                   llvm_i32_ty, llvm_i32_ty], [ImmArg<ArgIndex<0>>, ImmArg<ArgIndex<1>>, ImmArg<ArgIndex<4>>]>;
 
 def int_arm_mrrc : Intrinsic<[llvm_i32_ty, llvm_i32_ty], [llvm_i32_ty,
-                              llvm_i32_ty, llvm_i32_ty], [ImmArg<0>, ImmArg<1>, ImmArg<2>]>;
+                              llvm_i32_ty, llvm_i32_ty], [ImmArg<ArgIndex<0>>, ImmArg<ArgIndex<1>>, ImmArg<ArgIndex<2>>]>;
 def int_arm_mrrc2 : Intrinsic<[llvm_i32_ty, llvm_i32_ty], [llvm_i32_ty,
-                               llvm_i32_ty, llvm_i32_ty], [ImmArg<0>, ImmArg<1>, ImmArg<2>]>;
+                               llvm_i32_ty, llvm_i32_ty], [ImmArg<ArgIndex<0>>, ImmArg<ArgIndex<1>>, ImmArg<ArgIndex<2>>]>;
 
 //===----------------------------------------------------------------------===//
 // CRC32
@@ -426,8 +426,6 @@
   def int_arm_neon_vhaddu : Neon_2Arg_Intrinsic;
   def int_arm_neon_vrhadds : Neon_2Arg_Intrinsic;
   def int_arm_neon_vrhaddu : Neon_2Arg_Intrinsic;
-  def int_arm_neon_vqadds : Neon_2Arg_Intrinsic;
-  def int_arm_neon_vqaddu : Neon_2Arg_Intrinsic;
   def int_arm_neon_vraddhn : Neon_2Arg_Narrow_Intrinsic;
 
   // Vector Multiply.
@@ -459,8 +457,6 @@
 // Vector Subtract.
 def int_arm_neon_vhsubs : Neon_2Arg_Intrinsic;
 def int_arm_neon_vhsubu : Neon_2Arg_Intrinsic;
-def int_arm_neon_vqsubs : Neon_2Arg_Intrinsic;
-def int_arm_neon_vqsubu : Neon_2Arg_Intrinsic;
 def int_arm_neon_vrsubhn : Neon_2Arg_Narrow_Intrinsic;
 
 // Vector Absolute Compare.
@@ -699,16 +695,16 @@
 def int_arm_neon_vst1x2 : Intrinsic<[],
                                     [llvm_anyptr_ty, llvm_anyvector_ty,
                                      LLVMMatchType<1>],
-                                    [IntrArgMemOnly, NoCapture<0>]>;
+                                    [IntrArgMemOnly, NoCapture<ArgIndex<0>>]>;
 def int_arm_neon_vst1x3 : Intrinsic<[],
                                     [llvm_anyptr_ty, llvm_anyvector_ty,
                                      LLVMMatchType<1>, LLVMMatchType<1>],
-                                    [IntrArgMemOnly, NoCapture<0>]>;
+                                    [IntrArgMemOnly, NoCapture<ArgIndex<0>>]>;
 def int_arm_neon_vst1x4 : Intrinsic<[],
                                     [llvm_anyptr_ty, llvm_anyvector_ty,
                                      LLVMMatchType<1>, LLVMMatchType<1>,
                                      LLVMMatchType<1>],
-                                    [IntrArgMemOnly, NoCapture<0>]>;
+                                    [IntrArgMemOnly, NoCapture<ArgIndex<0>>]>;
 
 // Vector store N-element structure from one lane.
 // Source operands are: the address, the N vectors, the lane number, and
@@ -777,10 +773,608 @@
 def int_arm_neon_udot : Neon_Dot_Intrinsic;
 def int_arm_neon_sdot : Neon_Dot_Intrinsic;
 
+// v8.6-A Matrix Multiply Intrinsics
+class Neon_MatMul_Intrinsic
+  : Intrinsic<[llvm_anyvector_ty],
+              [LLVMMatchType<0>, llvm_anyvector_ty,
+               LLVMMatchType<1>],
+              [IntrNoMem]>;
+def int_arm_neon_ummla  : Neon_MatMul_Intrinsic;
+def int_arm_neon_smmla  : Neon_MatMul_Intrinsic;
+def int_arm_neon_usmmla : Neon_MatMul_Intrinsic;
+def int_arm_neon_usdot  : Neon_Dot_Intrinsic;
+
+// v8.6-A Bfloat Intrinsics
+def int_arm_neon_vcvtfp2bf
+    : Intrinsic<[llvm_anyvector_ty], [llvm_v4f32_ty], [IntrNoMem]>;
+def int_arm_neon_vcvtbfp2bf
+    : Intrinsic<[llvm_bfloat_ty], [llvm_float_ty], [IntrNoMem]>;
+
+def int_arm_neon_bfdot : Neon_Dot_Intrinsic;
+def int_arm_neon_bfmmla
+    : Intrinsic<[llvm_v4f32_ty],
+                [llvm_v4f32_ty, llvm_v8bf16_ty, llvm_v8bf16_ty],
+                [IntrNoMem]>;
+
+class Neon_BF16FML_Intrinsic
+    : Intrinsic<[llvm_v4f32_ty],
+                [llvm_v4f32_ty, llvm_v8bf16_ty, llvm_v8bf16_ty],
+                [IntrNoMem]>;
+def int_arm_neon_bfmlalb : Neon_BF16FML_Intrinsic;
+def int_arm_neon_bfmlalt : Neon_BF16FML_Intrinsic;
+
+def int_arm_cls: Intrinsic<[llvm_i32_ty], [llvm_i32_ty], [IntrNoMem]>;
+def int_arm_cls64: Intrinsic<[llvm_i32_ty], [llvm_i64_ty], [IntrNoMem]>;
+
+def int_arm_mve_vctp8  : Intrinsic<[llvm_v16i1_ty], [llvm_i32_ty], [IntrNoMem]>;
+def int_arm_mve_vctp16 : Intrinsic<[llvm_v8i1_ty], [llvm_i32_ty], [IntrNoMem]>;
+def int_arm_mve_vctp32 : Intrinsic<[llvm_v4i1_ty], [llvm_i32_ty], [IntrNoMem]>;
+// vctp64 takes v4i1, to work around v2i1 not being a legal MVE type
+def int_arm_mve_vctp64 : Intrinsic<[llvm_v4i1_ty], [llvm_i32_ty], [IntrNoMem]>;
+
+// v8.3-A Floating-point complex add
+def int_arm_neon_vcadd_rot90  : Neon_2Arg_Intrinsic;
+def int_arm_neon_vcadd_rot270 : Neon_2Arg_Intrinsic;
 
 // GNU eabi mcount
-def int_arm_gnu_eabi_mcount : Intrinsic<[],
-                                    [],
-                                    [IntrReadMem, IntrWriteMem]>;
+def int_arm_gnu_eabi_mcount : Intrinsic<[], [], []>;
+
+def int_arm_mve_pred_i2v : Intrinsic<
+  [llvm_anyvector_ty], [llvm_i32_ty], [IntrNoMem]>;
+def int_arm_mve_pred_v2i : Intrinsic<
+  [llvm_i32_ty], [llvm_anyvector_ty], [IntrNoMem]>;
+def int_arm_mve_vreinterpretq : Intrinsic<
+  [llvm_anyvector_ty], [llvm_anyvector_ty], [IntrNoMem]>;
+
+def int_arm_mve_min_predicated: Intrinsic<[llvm_anyvector_ty],
+   [LLVMMatchType<0>, LLVMMatchType<0>, llvm_i32_ty /* unsigned */,
+    llvm_anyvector_ty, LLVMMatchType<0>],
+   [IntrNoMem]>;
+def int_arm_mve_max_predicated: Intrinsic<[llvm_anyvector_ty],
+   [LLVMMatchType<0>, LLVMMatchType<0>, llvm_i32_ty /* unsigned */,
+    llvm_anyvector_ty, LLVMMatchType<0>],
+   [IntrNoMem]>;
+def int_arm_mve_abd_predicated: Intrinsic<[llvm_anyvector_ty],
+   [LLVMMatchType<0>, LLVMMatchType<0>, llvm_i32_ty /* unsigned */,
+    llvm_anyvector_ty, LLVMMatchType<0>], [IntrNoMem]>;
+def int_arm_mve_add_predicated: Intrinsic<[llvm_anyvector_ty],
+   [LLVMMatchType<0>, LLVMMatchType<0>, llvm_anyvector_ty, LLVMMatchType<0>],
+   [IntrNoMem]>;
+def int_arm_mve_and_predicated: Intrinsic<[llvm_anyvector_ty],
+   [LLVMMatchType<0>, LLVMMatchType<0>, llvm_anyvector_ty, LLVMMatchType<0>],
+   [IntrNoMem]>;
+def int_arm_mve_bic_predicated: Intrinsic<[llvm_anyvector_ty],
+   [LLVMMatchType<0>, LLVMMatchType<0>, llvm_anyvector_ty, LLVMMatchType<0>],
+   [IntrNoMem]>;
+def int_arm_mve_eor_predicated: Intrinsic<[llvm_anyvector_ty],
+   [LLVMMatchType<0>, LLVMMatchType<0>, llvm_anyvector_ty, LLVMMatchType<0>],
+   [IntrNoMem]>;
+def int_arm_mve_orn_predicated: Intrinsic<[llvm_anyvector_ty],
+   [LLVMMatchType<0>, LLVMMatchType<0>, llvm_anyvector_ty, LLVMMatchType<0>],
+   [IntrNoMem]>;
+def int_arm_mve_orr_predicated: Intrinsic<[llvm_anyvector_ty],
+   [LLVMMatchType<0>, LLVMMatchType<0>, llvm_anyvector_ty, LLVMMatchType<0>],
+   [IntrNoMem]>;
+def int_arm_mve_sub_predicated: Intrinsic<[llvm_anyvector_ty],
+   [LLVMMatchType<0>, LLVMMatchType<0>, llvm_anyvector_ty, LLVMMatchType<0>],
+   [IntrNoMem]>;
+def int_arm_mve_mul_predicated: Intrinsic<[llvm_anyvector_ty],
+   [LLVMMatchType<0>, LLVMMatchType<0>, llvm_anyvector_ty, LLVMMatchType<0>],
+   [IntrNoMem]>;
+def int_arm_mve_mulh_predicated: Intrinsic<[llvm_anyvector_ty],
+   [LLVMMatchType<0>, LLVMMatchType<0>, llvm_i32_ty /* unsigned */,
+    llvm_anyvector_ty, LLVMMatchType<0>],
+   [IntrNoMem]>;
+def int_arm_mve_qdmulh_predicated: Intrinsic<[llvm_anyvector_ty],
+   [LLVMMatchType<0>, LLVMMatchType<0>, llvm_anyvector_ty, LLVMMatchType<0>],
+   [IntrNoMem]>;
+def int_arm_mve_rmulh_predicated: Intrinsic<[llvm_anyvector_ty],
+   [LLVMMatchType<0>, LLVMMatchType<0>, llvm_i32_ty /* unsigned */,
+    llvm_anyvector_ty, LLVMMatchType<0>],
+   [IntrNoMem]>;
+def int_arm_mve_qrdmulh_predicated: Intrinsic<[llvm_anyvector_ty],
+   [LLVMMatchType<0>, LLVMMatchType<0>, llvm_anyvector_ty, LLVMMatchType<0>],
+   [IntrNoMem]>;
+def int_arm_mve_mull_int_predicated: Intrinsic<[llvm_anyvector_ty],
+   [llvm_anyvector_ty, LLVMMatchType<1>, llvm_i32_ty /* unsigned */,
+    llvm_i32_ty /* top */, llvm_anyvector_ty, LLVMMatchType<0>],
+   [IntrNoMem]>;
+def int_arm_mve_mull_poly_predicated: Intrinsic<[llvm_anyvector_ty],
+   [llvm_anyvector_ty, LLVMMatchType<1>, llvm_i32_ty, llvm_anyvector_ty,
+    LLVMMatchType<0>],
+   [IntrNoMem]>;
+def int_arm_mve_qadd_predicated: Intrinsic<[llvm_anyvector_ty],
+   [LLVMMatchType<0>, LLVMMatchType<0>, llvm_i32_ty /* unsigned */,
+    llvm_anyvector_ty, LLVMMatchType<0>], [IntrNoMem]>;
+def int_arm_mve_hadd_predicated: Intrinsic<[llvm_anyvector_ty],
+   [LLVMMatchType<0>, LLVMMatchType<0>, llvm_i32_ty /* unsigned */,
+    llvm_anyvector_ty, LLVMMatchType<0>], [IntrNoMem]>;
+def int_arm_mve_rhadd_predicated: Intrinsic<[llvm_anyvector_ty],
+   [LLVMMatchType<0>, LLVMMatchType<0>, llvm_i32_ty /* unsigned */,
+    llvm_anyvector_ty, LLVMMatchType<0>], [IntrNoMem]>;
+def int_arm_mve_qsub_predicated: Intrinsic<[llvm_anyvector_ty],
+   [LLVMMatchType<0>, LLVMMatchType<0>, llvm_i32_ty /* unsigned */,
+    llvm_anyvector_ty, LLVMMatchType<0>], [IntrNoMem]>;
+def int_arm_mve_hsub_predicated: Intrinsic<[llvm_anyvector_ty],
+   [LLVMMatchType<0>, LLVMMatchType<0>, llvm_i32_ty /* unsigned */,
+    llvm_anyvector_ty, LLVMMatchType<0>], [IntrNoMem]>;
+def int_arm_mve_vmina_predicated: Intrinsic<[llvm_anyvector_ty],
+   [LLVMMatchType<0>, LLVMMatchType<0>, llvm_anyvector_ty],
+    [IntrNoMem]>;
+def int_arm_mve_vmaxa_predicated: Intrinsic<[llvm_anyvector_ty],
+   [LLVMMatchType<0>, LLVMMatchType<0>, llvm_anyvector_ty],
+    [IntrNoMem]>;
+def int_arm_mve_vminnma_predicated: Intrinsic<[llvm_anyvector_ty],
+   [LLVMMatchType<0>, LLVMMatchType<0>, llvm_anyvector_ty],
+    [IntrNoMem]>;
+def int_arm_mve_vmaxnma_predicated: Intrinsic<[llvm_anyvector_ty],
+   [LLVMMatchType<0>, LLVMMatchType<0>, llvm_anyvector_ty],
+    [IntrNoMem]>;
+
+multiclass MVEPredicated<list<LLVMType> rets, list<LLVMType> params,
+                         LLVMType pred = llvm_anyvector_ty,
+                         list<IntrinsicProperty> props = [IntrNoMem]> {
+  def "": Intrinsic<rets, params, props>;
+  def _predicated: Intrinsic<rets, params # [pred], props>;
+}
+multiclass MVEPredicatedM<list<LLVMType> rets, list<LLVMType> params,
+                          LLVMType pred = llvm_anyvector_ty,
+                          list<IntrinsicProperty> props = [IntrNoMem]> {
+  def "": Intrinsic<rets, params, props>;
+  def _predicated: Intrinsic<rets, params # [pred,
+      !if(!eq(rets[0], llvm_anyvector_ty),
+          LLVMMatchType<0>, rets[0])], props>;
+}
+
+multiclass MVE_minmaxv {
+  defm v: MVEPredicated<[llvm_i32_ty],
+     [llvm_i32_ty, llvm_anyvector_ty, llvm_i32_ty /* unsigned */]>;
+  defm av: MVEPredicated<[llvm_i32_ty],
+     [llvm_i32_ty, llvm_anyvector_ty]>;
+  defm nmv: MVEPredicated<[llvm_anyfloat_ty],
+     [LLVMMatchType<0>, llvm_anyvector_ty]>;
+  defm nmav: MVEPredicated<[llvm_anyfloat_ty],
+     [LLVMMatchType<0>, llvm_anyvector_ty]>;
+}
+defm int_arm_mve_min: MVE_minmaxv;
+defm int_arm_mve_max: MVE_minmaxv;
+
+defm int_arm_mve_addv: MVEPredicated<[llvm_i32_ty],
+   [llvm_anyvector_ty, llvm_i32_ty /* unsigned */]>;
+defm int_arm_mve_addlv: MVEPredicated<[llvm_i64_ty],
+   [llvm_anyvector_ty, llvm_i32_ty /* unsigned */]>;
+
+// Intrinsic with a predicated and a non-predicated case. The predicated case
+// has two additional parameters: inactive (the value for inactive lanes, can
+// be undef) and predicate.
+multiclass MVEMXPredicated<list<LLVMType> rets, list<LLVMType> flags,
+                           list<LLVMType> params, LLVMType inactive,
+                           LLVMType predicate,
+                           list<IntrinsicProperty> props = [IntrNoMem]> {
+  def "":          Intrinsic<rets, flags # params, props>;
+  def _predicated: Intrinsic<rets, flags # [inactive] # params # [predicate],
+                             props>;
+}
+
+defm int_arm_mve_vcvt_narrow: MVEPredicated<[llvm_v8f16_ty],
+   [llvm_v8f16_ty, llvm_v4f32_ty, llvm_i32_ty], llvm_v4i1_ty>;
+defm int_arm_mve_vcvt_widen: MVEMXPredicated<[llvm_v4f32_ty], [],
+   [llvm_v8f16_ty, llvm_i32_ty], llvm_v4f32_ty, llvm_v4i1_ty>;
+
+defm int_arm_mve_vldr_gather_base: MVEPredicated<
+   [llvm_anyvector_ty], [llvm_anyvector_ty, llvm_i32_ty],
+   llvm_anyvector_ty, [IntrReadMem]>;
+defm int_arm_mve_vldr_gather_base_wb: MVEPredicated<
+   [llvm_anyvector_ty, llvm_anyvector_ty],
+   [LLVMMatchType<1>, llvm_i32_ty], llvm_anyvector_ty, [IntrReadMem]>;
+defm int_arm_mve_vstr_scatter_base: MVEPredicated<
+   [], [llvm_anyvector_ty, llvm_i32_ty, llvm_anyvector_ty],
+   llvm_anyvector_ty, [IntrWriteMem]>;
+defm int_arm_mve_vstr_scatter_base_wb: MVEPredicated<
+   [llvm_anyvector_ty], [LLVMMatchType<0>, llvm_i32_ty, llvm_anyvector_ty],
+   llvm_anyvector_ty, [IntrWriteMem]>;
+
+// gather_offset takes three i32 parameters. The first is the size of
+// memory element loaded, in bits. The second is a left bit shift to
+// apply to each offset in the vector parameter (must be either 0, or
+// correspond to the element size of the destination vector type). The
+// last is 1 to indicate zero extension (if the load is widening), or
+// 0 for sign extension.
+//
+// scatter_offset has the first two of those parameters, but since it
+// narrows rather than widening, it doesn't have the last one.
+defm int_arm_mve_vldr_gather_offset: MVEPredicated<
+   [llvm_anyvector_ty], [llvm_anyptr_ty, llvm_anyvector_ty,
+   llvm_i32_ty, llvm_i32_ty, llvm_i32_ty], llvm_anyvector_ty, [IntrReadMem]>;
+defm int_arm_mve_vstr_scatter_offset: MVEPredicated<
+   [], [llvm_anyptr_ty, llvm_anyvector_ty, llvm_anyvector_ty,
+   llvm_i32_ty, llvm_i32_ty], llvm_anyvector_ty, [IntrWriteMem]>;
+
+def int_arm_mve_shl_imm_predicated: Intrinsic<[llvm_anyvector_ty],
+   [LLVMMatchType<0>, llvm_i32_ty, llvm_anyvector_ty, LLVMMatchType<0>],
+   [IntrNoMem]>;
+def int_arm_mve_shr_imm_predicated: Intrinsic<[llvm_anyvector_ty],
+   [LLVMMatchType<0>, llvm_i32_ty, llvm_i32_ty, // extra i32 is unsigned flag
+    llvm_anyvector_ty, LLVMMatchType<0>],
+   [IntrNoMem]>;
+
+defm int_arm_mve_vqshl_imm: MVEPredicatedM<[llvm_anyvector_ty],
+   [LLVMMatchType<0>, llvm_i32_ty /*shiftcount*/, llvm_i32_ty /*unsigned*/]>;
+defm int_arm_mve_vrshr_imm: MVEPredicatedM<[llvm_anyvector_ty],
+   [LLVMMatchType<0>, llvm_i32_ty /*shiftcount*/, llvm_i32_ty /*unsigned*/]>;
+defm int_arm_mve_vqshlu_imm: MVEPredicatedM<[llvm_anyvector_ty],
+   [LLVMMatchType<0>, llvm_i32_ty /*shiftcount*/]>;
+defm int_arm_mve_vshll_imm: MVEPredicatedM<[llvm_anyvector_ty],
+   [llvm_anyvector_ty, llvm_i32_ty /*shiftcount*/, llvm_i32_ty /*unsigned*/,
+                       llvm_i32_ty /*top-half*/]>;
+
+defm int_arm_mve_vsli: MVEPredicated<
+   [llvm_anyvector_ty], [LLVMMatchType<0>, LLVMMatchType<0>, llvm_i32_ty]>;
+defm int_arm_mve_vsri: MVEPredicated<
+   [llvm_anyvector_ty], [LLVMMatchType<0>, LLVMMatchType<0>, llvm_i32_ty]>;
+
+defm int_arm_mve_vshrn: MVEPredicated<
+   [llvm_anyvector_ty], [LLVMMatchType<0>, llvm_anyvector_ty,
+    llvm_i32_ty /*shiftcount*/, llvm_i32_ty /*saturate*/, llvm_i32_ty /*round*/,
+    llvm_i32_ty /*unsigned-out*/, llvm_i32_ty /*unsigned-in*/,
+    llvm_i32_ty /*top-half*/]>;
+
+defm int_arm_mve_vshl_scalar: MVEPredicated<
+   [llvm_anyvector_ty], [LLVMMatchType<0>, llvm_i32_ty /*shiftcount*/,
+    llvm_i32_ty /*saturate*/, llvm_i32_ty /*round*/, llvm_i32_ty /*unsigned*/]>;
+defm int_arm_mve_vshl_vector: MVEPredicatedM<
+   [llvm_anyvector_ty], [LLVMMatchType<0>, llvm_anyvector_ty /*shiftcounts*/,
+    llvm_i32_ty /*saturate*/, llvm_i32_ty /*round*/, llvm_i32_ty /*unsigned*/]>;
+
+// MVE scalar shifts.
+class ARM_MVE_qrshift_single<list<LLVMType> value,
+                             list<LLVMType> saturate = []> :
+  Intrinsic<value, value # [llvm_i32_ty] # saturate, [IntrNoMem]>;
+multiclass ARM_MVE_qrshift<list<LLVMType> saturate = []> {
+  // Most of these shifts come in 32- and 64-bit versions. But only
+  // the 64-bit ones have the extra saturation argument (if any).
+  def "": ARM_MVE_qrshift_single<[llvm_i32_ty]>;
+  def l:  ARM_MVE_qrshift_single<[llvm_i32_ty, llvm_i32_ty], saturate>;
+}
+defm int_arm_mve_urshr: ARM_MVE_qrshift;
+defm int_arm_mve_uqshl: ARM_MVE_qrshift;
+defm int_arm_mve_srshr: ARM_MVE_qrshift;
+defm int_arm_mve_sqshl: ARM_MVE_qrshift;
+defm int_arm_mve_uqrshl: ARM_MVE_qrshift<[llvm_i32_ty]>;
+defm int_arm_mve_sqrshr: ARM_MVE_qrshift<[llvm_i32_ty]>;
+// LSLL and ASRL only have 64-bit versions, not 32.
+def int_arm_mve_lsll: ARM_MVE_qrshift_single<[llvm_i32_ty, llvm_i32_ty]>;
+def int_arm_mve_asrl: ARM_MVE_qrshift_single<[llvm_i32_ty, llvm_i32_ty]>;
+
+def int_arm_mve_vabd: Intrinsic<
+   [llvm_anyvector_ty],
+   [LLVMMatchType<0>, LLVMMatchType<0>, llvm_i32_ty /* unsigned */],
+   [IntrNoMem]>;
+def int_arm_mve_vadc: Intrinsic<
+   [llvm_anyvector_ty, llvm_i32_ty],
+   [LLVMMatchType<0>, LLVMMatchType<0>, llvm_i32_ty], [IntrNoMem]>;
+def int_arm_mve_vsbc: Intrinsic<
+   [llvm_anyvector_ty, llvm_i32_ty],
+   [LLVMMatchType<0>, LLVMMatchType<0>, llvm_i32_ty], [IntrNoMem]>;
+def int_arm_mve_vadc_predicated: Intrinsic<
+   [llvm_anyvector_ty, llvm_i32_ty],
+   [LLVMMatchType<0>, LLVMMatchType<0>, LLVMMatchType<0>,
+    llvm_i32_ty, llvm_anyvector_ty], [IntrNoMem]>;
+def int_arm_mve_vsbc_predicated: Intrinsic<
+   [llvm_anyvector_ty, llvm_i32_ty],
+   [LLVMMatchType<0>, LLVMMatchType<0>, LLVMMatchType<0>,
+    llvm_i32_ty, llvm_anyvector_ty], [IntrNoMem]>;
+def int_arm_mve_vshlc: Intrinsic<
+   [llvm_i32_ty /* bits shifted out */, llvm_anyvector_ty],
+   [LLVMMatchType<0>, llvm_i32_ty /* bits shifted in */,
+    llvm_i32_ty /* shift count */], [IntrNoMem]>;
+def int_arm_mve_vshlc_predicated: Intrinsic<
+   [llvm_i32_ty /* bits shifted out */, llvm_anyvector_ty],
+   [LLVMMatchType<0>, llvm_i32_ty /* bits shifted in */,
+    llvm_i32_ty /* shift count */, llvm_anyvector_ty], [IntrNoMem]>;
+def int_arm_mve_vmulh: Intrinsic<
+   [llvm_anyvector_ty],
+   [LLVMMatchType<0>, LLVMMatchType<0>, llvm_i32_ty /* unsigned */],
+   [IntrNoMem]>;
+def int_arm_mve_vqdmulh: Intrinsic<
+   [llvm_anyvector_ty],
+   [LLVMMatchType<0>, LLVMMatchType<0>], [IntrNoMem]>;
+def int_arm_mve_vhadd: Intrinsic<
+   [llvm_anyvector_ty],
+   [LLVMMatchType<0>, LLVMMatchType<0>, llvm_i32_ty /* unsigned */],
+   [IntrNoMem]>;
+def int_arm_mve_vrhadd: Intrinsic<
+   [llvm_anyvector_ty],
+   [LLVMMatchType<0>, LLVMMatchType<0>, llvm_i32_ty /* unsigned */],
+   [IntrNoMem]>;
+def int_arm_mve_vhsub: Intrinsic<
+   [llvm_anyvector_ty],
+   [LLVMMatchType<0>, LLVMMatchType<0>, llvm_i32_ty /* unsigned */],
+   [IntrNoMem]>;
+def int_arm_mve_vrmulh: Intrinsic<
+   [llvm_anyvector_ty],
+   [LLVMMatchType<0>, LLVMMatchType<0>, llvm_i32_ty /* unsigned */],
+   [IntrNoMem]>;
+def int_arm_mve_vqrdmulh: Intrinsic<
+   [llvm_anyvector_ty],
+   [LLVMMatchType<0>, LLVMMatchType<0>], [IntrNoMem]>;
+def int_arm_mve_vmull: Intrinsic<
+   [llvm_anyvector_ty],
+   [llvm_anyvector_ty, LLVMMatchType<1>, llvm_i32_ty /* unsigned */,
+    llvm_i32_ty /* top */], [IntrNoMem]>;
+def int_arm_mve_vmull_poly: Intrinsic<
+   [llvm_anyvector_ty],
+   [llvm_anyvector_ty, LLVMMatchType<1>, llvm_i32_ty], [IntrNoMem]>;
+
+// The first two parameters are compile-time constants:
+// * Halving: 0 means  halving (vhcaddq), 1 means non-halving (vcaddq) 
+//            instruction. Note: the flag is inverted to match the corresponding
+//            bit in the instruction encoding
+// * Rotation angle: 0 mean 90 deg, 1 means 180 deg
+defm int_arm_mve_vcaddq : MVEMXPredicated<
+  [llvm_anyvector_ty],
+  [llvm_i32_ty, llvm_i32_ty], [LLVMMatchType<0>, LLVMMatchType<0>],
+   LLVMMatchType<0>, llvm_anyvector_ty>;
+
+// The first operand of the following two intrinsics is the rotation angle
+// (must be a compile-time constant):
+// 0 - 0 deg
+// 1 - 90 deg
+// 2 - 180 deg
+// 3 - 270 deg
+defm int_arm_mve_vcmulq : MVEMXPredicated<
+  [llvm_anyvector_ty],
+  [llvm_i32_ty], [LLVMMatchType<0>, LLVMMatchType<0>],
+   LLVMMatchType<0>, llvm_anyvector_ty>;
+
+defm int_arm_mve_vcmlaq : MVEPredicated<
+  [llvm_anyvector_ty],
+  [llvm_i32_ty, LLVMMatchType<0>, LLVMMatchType<0>, LLVMMatchType<0>],
+   llvm_anyvector_ty>;
+
+def int_arm_mve_vld2q: Intrinsic<[llvm_anyvector_ty, LLVMMatchType<0>], [llvm_anyptr_ty], [IntrReadMem, IntrArgMemOnly]>;
+def int_arm_mve_vld4q: Intrinsic<[llvm_anyvector_ty, LLVMMatchType<0>, LLVMMatchType<0>, LLVMMatchType<0>], [llvm_anyptr_ty], [IntrReadMem, IntrArgMemOnly]>;
+
+def int_arm_mve_vst2q: Intrinsic<[], [llvm_anyptr_ty, llvm_anyvector_ty, LLVMMatchType<1>, llvm_i32_ty], [IntrWriteMem, IntrArgMemOnly]>;
+def int_arm_mve_vst4q: Intrinsic<[], [llvm_anyptr_ty, llvm_anyvector_ty, LLVMMatchType<1>, LLVMMatchType<1>, LLVMMatchType<1>, llvm_i32_ty], [IntrWriteMem, IntrArgMemOnly]>;
+
+// MVE vector absolute difference and accumulate across vector
+// The first operand is an 'unsigned' flag. The remaining operands are:
+// * accumulator
+// * first vector operand
+// * second vector operand
+// * mask (only in predicated versions)
+defm int_arm_mve_vabav: MVEPredicated<
+  [llvm_i32_ty],
+  [llvm_i32_ty, llvm_i32_ty, llvm_anyvector_ty, LLVMMatchType<0>], llvm_anyvector_ty>;
+
+// The following 3 instrinsics are MVE vector reductions with two vector
+// operands.
+// The first 3 operands are boolean flags (must be compile-time constants):
+// * unsigned - the instruction operates on vectors of unsigned values and
+//              unsigned scalars
+// * subtract - the instruction performs subtraction after multiplication of
+//              lane pairs (e.g., vmlsdav vs vmladav)
+// * exchange - the instruction exchanges successive even and odd lanes of
+//              the first operands before multiplication of lane pairs
+//              (e.g., vmladavx vs vmladav)
+// The remaining operands are:
+// * accumulator
+// * first vector operand
+// * second vector operand
+// * mask (only in predicated versions)
+
+// Version with 32-bit result, vml{a,s}dav[a][x]
+defm int_arm_mve_vmldava: MVEPredicated<
+  [llvm_i32_ty],
+  [llvm_i32_ty, llvm_i32_ty, llvm_i32_ty,
+   llvm_i32_ty, llvm_anyvector_ty, LLVMMatchType<0>],
+  llvm_anyvector_ty>;
+
+// Version with 64-bit result, vml{a,s}ldav[a][x]
+defm int_arm_mve_vmlldava: MVEPredicated<
+  [llvm_i32_ty, llvm_i32_ty],
+  [llvm_i32_ty, llvm_i32_ty, llvm_i32_ty,
+   llvm_i32_ty, llvm_i32_ty, llvm_anyvector_ty, LLVMMatchType<0>],
+  llvm_anyvector_ty>;
+
+// Version with 72-bit rounded result, vrml{a,s}ldavh[a][x]
+defm int_arm_mve_vrmlldavha: MVEPredicated<
+  [llvm_i32_ty, llvm_i32_ty],
+  [llvm_i32_ty, llvm_i32_ty, llvm_i32_ty,
+   llvm_i32_ty, llvm_i32_ty, llvm_anyvector_ty, LLVMMatchType<0>],
+  llvm_anyvector_ty>;
+
+defm int_arm_mve_vidup: MVEMXPredicated<
+   [llvm_anyvector_ty /* output */, llvm_i32_ty /* written-back base */], [],
+   [llvm_i32_ty /* base */, llvm_i32_ty /* step */],
+   LLVMMatchType<0>, llvm_anyvector_ty>;
+defm int_arm_mve_vddup: MVEMXPredicated<
+   [llvm_anyvector_ty /* output */, llvm_i32_ty /* written-back base */], [],
+   [llvm_i32_ty /* base */, llvm_i32_ty /* step */],
+   LLVMMatchType<0>, llvm_anyvector_ty>;
+defm int_arm_mve_viwdup: MVEMXPredicated<
+   [llvm_anyvector_ty /* output */, llvm_i32_ty /* written-back base */], [],
+   [llvm_i32_ty /* base */, llvm_i32_ty /* limit */, llvm_i32_ty /* step */],
+   LLVMMatchType<0>, llvm_anyvector_ty>;
+defm int_arm_mve_vdwdup: MVEMXPredicated<
+   [llvm_anyvector_ty /* output */, llvm_i32_ty /* written-back base */], [],
+   [llvm_i32_ty /* base */, llvm_i32_ty /* limit */, llvm_i32_ty /* step */],
+   LLVMMatchType<0>, llvm_anyvector_ty>;
+
+// Flags:
+// * unsigned
+defm int_arm_mve_vcvt_fix: MVEMXPredicated<
+  [llvm_anyvector_ty /* output */], [llvm_i32_ty],
+  [llvm_anyvector_ty /* input vector */, llvm_i32_ty /* scale */],
+  LLVMMatchType<0>, llvm_anyvector_ty>;
+
+def int_arm_mve_vcvt_fp_int_predicated: Intrinsic<
+  [llvm_anyvector_ty], [llvm_anyvector_ty, llvm_i32_ty /* unsigned */,
+   llvm_anyvector_ty /* predicate */, LLVMMatchType<0> /* inactive */],
+  [IntrNoMem]>;
+
+foreach suffix = ["a","n","p","m"] in {
+  defm "int_arm_mve_vcvt"#suffix: MVEMXPredicated<
+    [llvm_anyvector_ty /* output */], [llvm_i32_ty /* unsigned */],
+    [llvm_anyvector_ty /* input */], LLVMMatchType<0>, llvm_anyvector_ty>;
+}
+
+def int_arm_mve_vrintn: Intrinsic<
+  [llvm_anyvector_ty], [LLVMMatchType<0>], [IntrNoMem]>;
+def int_arm_mve_vcls: Intrinsic<
+  [llvm_anyvector_ty], [LLVMMatchType<0>], [IntrNoMem]>;
+
+defm int_arm_mve_vbrsr: MVEMXPredicated<
+  [llvm_anyvector_ty], [],
+  [LLVMMatchType<0>, llvm_i32_ty], LLVMMatchType<0>, llvm_anyvector_ty>;
+
+def int_arm_mve_vqdmull: Intrinsic<
+  [llvm_anyvector_ty],
+  [llvm_anyvector_ty, LLVMMatchType<1>, llvm_i32_ty],
+  [IntrNoMem]>;
+def int_arm_mve_vqdmull_predicated: Intrinsic<
+  [llvm_anyvector_ty],
+  [llvm_anyvector_ty, LLVMMatchType<1>, llvm_i32_ty, llvm_anyvector_ty,
+   LLVMMatchType<0>],
+  [IntrNoMem]>;
+
+class MVESimpleUnaryPredicated: Intrinsic<[llvm_anyvector_ty],
+   [LLVMMatchType<0>, llvm_anyvector_ty, LLVMMatchType<0>], [IntrNoMem]>;
+
+def int_arm_mve_mvn_predicated: MVESimpleUnaryPredicated;
+def int_arm_mve_abs_predicated: MVESimpleUnaryPredicated;
+def int_arm_mve_neg_predicated: MVESimpleUnaryPredicated;
+def int_arm_mve_qabs_predicated: MVESimpleUnaryPredicated;
+def int_arm_mve_qneg_predicated: MVESimpleUnaryPredicated;
+def int_arm_mve_clz_predicated: MVESimpleUnaryPredicated;
+def int_arm_mve_cls_predicated: MVESimpleUnaryPredicated;
+def int_arm_mve_vrintz_predicated: MVESimpleUnaryPredicated;
+def int_arm_mve_vrintm_predicated: MVESimpleUnaryPredicated;
+def int_arm_mve_vrintp_predicated: MVESimpleUnaryPredicated;
+def int_arm_mve_vrinta_predicated: MVESimpleUnaryPredicated;
+def int_arm_mve_vrintx_predicated: MVESimpleUnaryPredicated;
+def int_arm_mve_vrintn_predicated: MVESimpleUnaryPredicated;
+
+def int_arm_mve_vrev_predicated: Intrinsic<[llvm_anyvector_ty],
+   [LLVMMatchType<0>, llvm_i32_ty /* size to reverse */,
+    llvm_anyvector_ty, LLVMMatchType<0>], [IntrNoMem]>;
+
+def int_arm_mve_vmovl_predicated: Intrinsic<[llvm_anyvector_ty],
+   [llvm_anyvector_ty, llvm_i32_ty /* unsigned */, llvm_i32_ty /* top half */,
+    llvm_anyvector_ty /* predicate */, LLVMMatchType<0>], [IntrNoMem]>;
+def int_arm_mve_vmovn_predicated: Intrinsic<[llvm_anyvector_ty],
+   [LLVMMatchType<0>, llvm_anyvector_ty, llvm_i32_ty /* top half */,
+    llvm_anyvector_ty /* predicate */], [IntrNoMem]>;
+
+def int_arm_mve_vqmovn: Intrinsic<[llvm_anyvector_ty],
+   [LLVMMatchType<0>, llvm_anyvector_ty,
+    llvm_i32_ty /* unsigned output */, llvm_i32_ty /* unsigned input */,
+    llvm_i32_ty /* top half */], [IntrNoMem]>;
+def int_arm_mve_vqmovn_predicated: Intrinsic<[llvm_anyvector_ty],
+   [LLVMMatchType<0>, llvm_anyvector_ty,
+    llvm_i32_ty /* unsigned output */, llvm_i32_ty /* unsigned input */,
+    llvm_i32_ty /* top half */, llvm_anyvector_ty /* pred */], [IntrNoMem]>;
+
+def int_arm_mve_fma_predicated: Intrinsic<[llvm_anyvector_ty],
+   [LLVMMatchType<0> /* mult op #1 */, LLVMMatchType<0> /* mult op #2 */,
+    LLVMMatchType<0> /* addend */, llvm_anyvector_ty /* pred */], [IntrNoMem]>;
+def int_arm_mve_vmla_n_predicated: Intrinsic<[llvm_anyvector_ty],
+   [LLVMMatchType<0> /* mult op #1 */, LLVMMatchType<0> /* addend */,
+    llvm_i32_ty /* mult op #2 (scalar) */, llvm_anyvector_ty /* pred */],
+   [IntrNoMem]>;
+def int_arm_mve_vmlas_n_predicated: Intrinsic<[llvm_anyvector_ty],
+   [LLVMMatchType<0> /* mult op #1 */, LLVMMatchType<0> /* mult op #2 */,
+    llvm_i32_ty /* addend (scalar) */, llvm_anyvector_ty /* pred */],
+   [IntrNoMem]>;
+
+defm int_arm_mve_vqdmlah: MVEPredicated<[llvm_anyvector_ty],
+  [LLVMMatchType<0> /* mult op #1 */, LLVMMatchType<0> /* addend */,
+   llvm_i32_ty /* mult op #2 (scalar) */]>;
+defm int_arm_mve_vqrdmlah: MVEPredicated<[llvm_anyvector_ty],
+  [LLVMMatchType<0> /* mult op #1 */, LLVMMatchType<0> /* addend */,
+   llvm_i32_ty /* mult op #2 (scalar) */]>;
+defm int_arm_mve_vqdmlash: MVEPredicated<[llvm_anyvector_ty],
+  [LLVMMatchType<0> /* mult op #1 */, LLVMMatchType<0> /* mult op #2 */,
+   llvm_i32_ty /* addend (scalar) */]>;
+defm int_arm_mve_vqrdmlash: MVEPredicated<[llvm_anyvector_ty],
+  [LLVMMatchType<0> /* mult op #1 */, LLVMMatchType<0> /* mult op #2 */,
+   llvm_i32_ty /* addend (scalar) */]>;
+
+defm int_arm_mve_vqdmlad: MVEPredicated<[llvm_anyvector_ty],
+  [LLVMMatchType<0>, LLVMMatchType<0>, LLVMMatchType<0>,
+   llvm_i32_ty /* exchange */, llvm_i32_ty /* round */,
+   llvm_i32_ty /* subtract */]>;
+
+// CDE (Custom Datapath Extension)
+
+multiclass CDEGPRIntrinsics<list<LLVMType> args> {
+  def "" : Intrinsic<
+    [llvm_i32_ty],
+    !listconcat([llvm_i32_ty /* coproc */], args, [llvm_i32_ty /* imm */]),
+    [IntrNoMem, ImmArg<ArgIndex<0>>, ImmArg<ArgIndex<!add(!size(args), 1)>>]>;
+  def a : Intrinsic<
+    [llvm_i32_ty],
+    !listconcat([llvm_i32_ty /* coproc */, llvm_i32_ty /* acc */], args,
+                [llvm_i32_ty /* imm */]),
+    [IntrNoMem, ImmArg<ArgIndex<0>>, ImmArg<ArgIndex<!add(!size(args), 2)>>]>;
+
+  def d: Intrinsic<
+    [llvm_i32_ty /* lo */, llvm_i32_ty /* hi */],
+    !listconcat([llvm_i32_ty /* coproc */], args, [llvm_i32_ty /* imm */]),
+    [IntrNoMem, ImmArg<ArgIndex<0>>, ImmArg<ArgIndex<!add(!size(args), 1)>>]>;
+  def da: Intrinsic<
+    [llvm_i32_ty /* lo */, llvm_i32_ty /* hi */],
+    !listconcat([llvm_i32_ty /* coproc */, llvm_i32_ty /* acc_lo */,
+                 llvm_i32_ty /* acc_hi */], args, [llvm_i32_ty /* imm */]),
+    [IntrNoMem, ImmArg<ArgIndex<0>>, ImmArg<ArgIndex<!add(!size(args), 3)>>]>;
+}
+
+defm int_arm_cde_cx1: CDEGPRIntrinsics<[]>;
+defm int_arm_cde_cx2: CDEGPRIntrinsics<[llvm_i32_ty]>;
+defm int_arm_cde_cx3: CDEGPRIntrinsics<[llvm_i32_ty, llvm_i32_ty]>;
+
+multiclass CDEVCXIntrinsics<list<LLVMType> args> {
+  def "" : Intrinsic<
+    [llvm_anyfloat_ty],
+    !listconcat([llvm_i32_ty /* coproc */], args, [llvm_i32_ty /* imm */]),
+    [IntrNoMem, ImmArg<ArgIndex<0>>, ImmArg<ArgIndex<!add(!size(args), 1)>>]>;
+  def a : Intrinsic<
+    [llvm_anyfloat_ty],
+    !listconcat([llvm_i32_ty /* coproc */,  LLVMMatchType<0> /* acc */],
+                args, [llvm_i32_ty /* imm */]),
+    [IntrNoMem, ImmArg<ArgIndex<0>>, ImmArg<ArgIndex<!add(!size(args), 2)>>]>;
+}
+
+defm int_arm_cde_vcx1 : CDEVCXIntrinsics<[]>;
+defm int_arm_cde_vcx2 : CDEVCXIntrinsics<[LLVMMatchType<0>]>;
+defm int_arm_cde_vcx3 : CDEVCXIntrinsics<[LLVMMatchType<0>, LLVMMatchType<0>]>;
+
+multiclass CDEVCXVecIntrinsics<list<LLVMType> args> {
+  def "" : Intrinsic<
+    [llvm_v16i8_ty],
+    !listconcat([llvm_i32_ty /* coproc */], args, [llvm_i32_ty /* imm */]),
+    [IntrNoMem, ImmArg<ArgIndex<0>>, ImmArg<ArgIndex<!add(!size(args), 1)>>]>;
+  def a : Intrinsic<
+    [llvm_v16i8_ty],
+    !listconcat([llvm_i32_ty /* coproc */, llvm_v16i8_ty /* acc */],
+                args, [llvm_i32_ty /* imm */]),
+    [IntrNoMem, ImmArg<ArgIndex<0>>, ImmArg<ArgIndex<!add(!size(args), 2)>>]>;
+
+  def _predicated : Intrinsic<
+    [llvm_anyvector_ty],
+    !listconcat([llvm_i32_ty /* coproc */, LLVMMatchType<0> /* inactive */],
+                args, [llvm_i32_ty /* imm */, llvm_anyvector_ty /* mask */]),
+    [IntrNoMem, ImmArg<ArgIndex<0>>, ImmArg<ArgIndex<!add(!size(args), 2)>>]>;
+  def a_predicated : Intrinsic<
+    [llvm_anyvector_ty],
+    !listconcat([llvm_i32_ty /* coproc */, LLVMMatchType<0> /* acc */],
+                args, [llvm_i32_ty /* imm */, llvm_anyvector_ty /* mask */]),
+    [IntrNoMem, ImmArg<ArgIndex<0>>, ImmArg<ArgIndex<!add(!size(args), 2)>>]>;
+}
+
+defm int_arm_cde_vcx1q : CDEVCXVecIntrinsics<[]>;
+defm int_arm_cde_vcx2q : CDEVCXVecIntrinsics<[llvm_v16i8_ty]>;
+defm int_arm_cde_vcx3q : CDEVCXVecIntrinsics<[llvm_v16i8_ty, llvm_v16i8_ty]>;
 
 } // end TargetPrefix
diff --git a/linux-x64/clang/include/llvm/IR/IntrinsicsBPF.h b/linux-x64/clang/include/llvm/IR/IntrinsicsBPF.h
new file mode 100644
index 0000000..ea50e70
--- /dev/null
+++ b/linux-x64/clang/include/llvm/IR/IntrinsicsBPF.h
@@ -0,0 +1,29 @@
+/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
+|*                                                                            *|
+|* Intrinsic Function Source Fragment                                         *|
+|*                                                                            *|
+|* Automatically generated file, do not edit!                                 *|
+|*                                                                            *|
+\*===----------------------------------------------------------------------===*/
+
+#ifndef LLVM_IR_INTRINSIC_BPF_ENUMS_H
+#define LLVM_IR_INTRINSIC_BPF_ENUMS_H
+
+namespace llvm {
+namespace Intrinsic {
+enum BPFIntrinsics : unsigned {
+// Enum values for intrinsics
+    bpf_btf_type_id = 2345,                           // llvm.bpf.btf.type.id
+    bpf_load_byte,                             // llvm.bpf.load.byte
+    bpf_load_half,                             // llvm.bpf.load.half
+    bpf_load_word,                             // llvm.bpf.load.word
+    bpf_passthrough,                           // llvm.bpf.passthrough
+    bpf_preserve_enum_value,                   // llvm.bpf.preserve.enum.value
+    bpf_preserve_field_info,                   // llvm.bpf.preserve.field.info
+    bpf_preserve_type_info,                    // llvm.bpf.preserve.type.info
+    bpf_pseudo,                                // llvm.bpf.pseudo
+}; // enum
+} // namespace Intrinsic
+} // namespace llvm
+
+#endif
diff --git a/linux-x64/clang/include/llvm/IR/IntrinsicsBPF.td b/linux-x64/clang/include/llvm/IR/IntrinsicsBPF.td
index d7595a2..4b4dd94 100644
--- a/linux-x64/clang/include/llvm/IR/IntrinsicsBPF.td
+++ b/linux-x64/clang/include/llvm/IR/IntrinsicsBPF.td
@@ -20,4 +20,18 @@
               Intrinsic<[llvm_i64_ty], [llvm_ptr_ty, llvm_i64_ty], [IntrReadMem]>;
   def int_bpf_pseudo : GCCBuiltin<"__builtin_bpf_pseudo">,
               Intrinsic<[llvm_i64_ty], [llvm_i64_ty, llvm_i64_ty]>;
+  def int_bpf_preserve_field_info : GCCBuiltin<"__builtin_bpf_preserve_field_info">,
+              Intrinsic<[llvm_i32_ty], [llvm_anyptr_ty, llvm_i64_ty],
+              [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+  def int_bpf_btf_type_id : GCCBuiltin<"__builtin_bpf_btf_type_id">,
+              Intrinsic<[llvm_i64_ty], [llvm_i32_ty, llvm_i64_ty],
+              [IntrNoMem]>;
+  def int_bpf_preserve_type_info : GCCBuiltin<"__builtin_bpf_preserve_type_info">,
+              Intrinsic<[llvm_i32_ty], [llvm_i32_ty, llvm_i64_ty],
+              [IntrNoMem]>;
+  def int_bpf_preserve_enum_value : GCCBuiltin<"__builtin_bpf_preserve_enum_value">,
+              Intrinsic<[llvm_i64_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_i64_ty],
+              [IntrNoMem]>;
+  def int_bpf_passthrough : GCCBuiltin<"__builtin_bpf_passthrough">,
+              Intrinsic<[llvm_any_ty], [llvm_i32_ty, llvm_any_ty], [IntrNoMem]>;
 }
diff --git a/linux-x64/clang/include/llvm/IR/IntrinsicsHexagon.h b/linux-x64/clang/include/llvm/IR/IntrinsicsHexagon.h
new file mode 100644
index 0000000..bb7993f
--- /dev/null
+++ b/linux-x64/clang/include/llvm/IR/IntrinsicsHexagon.h
@@ -0,0 +1,1770 @@
+/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
+|*                                                                            *|
+|* Intrinsic Function Source Fragment                                         *|
+|*                                                                            *|
+|* Automatically generated file, do not edit!                                 *|
+|*                                                                            *|
+\*===----------------------------------------------------------------------===*/
+
+#ifndef LLVM_IR_INTRINSIC_HEXAGON_ENUMS_H
+#define LLVM_IR_INTRINSIC_HEXAGON_ENUMS_H
+
+namespace llvm {
+namespace Intrinsic {
+enum HEXAGONIntrinsics : unsigned {
+// Enum values for intrinsics
+    hexagon_A2_abs = 2354,                            // llvm.hexagon.A2.abs
+    hexagon_A2_absp,                           // llvm.hexagon.A2.absp
+    hexagon_A2_abssat,                         // llvm.hexagon.A2.abssat
+    hexagon_A2_add,                            // llvm.hexagon.A2.add
+    hexagon_A2_addh_h16_hh,                    // llvm.hexagon.A2.addh.h16.hh
+    hexagon_A2_addh_h16_hl,                    // llvm.hexagon.A2.addh.h16.hl
+    hexagon_A2_addh_h16_lh,                    // llvm.hexagon.A2.addh.h16.lh
+    hexagon_A2_addh_h16_ll,                    // llvm.hexagon.A2.addh.h16.ll
+    hexagon_A2_addh_h16_sat_hh,                // llvm.hexagon.A2.addh.h16.sat.hh
+    hexagon_A2_addh_h16_sat_hl,                // llvm.hexagon.A2.addh.h16.sat.hl
+    hexagon_A2_addh_h16_sat_lh,                // llvm.hexagon.A2.addh.h16.sat.lh
+    hexagon_A2_addh_h16_sat_ll,                // llvm.hexagon.A2.addh.h16.sat.ll
+    hexagon_A2_addh_l16_hl,                    // llvm.hexagon.A2.addh.l16.hl
+    hexagon_A2_addh_l16_ll,                    // llvm.hexagon.A2.addh.l16.ll
+    hexagon_A2_addh_l16_sat_hl,                // llvm.hexagon.A2.addh.l16.sat.hl
+    hexagon_A2_addh_l16_sat_ll,                // llvm.hexagon.A2.addh.l16.sat.ll
+    hexagon_A2_addi,                           // llvm.hexagon.A2.addi
+    hexagon_A2_addp,                           // llvm.hexagon.A2.addp
+    hexagon_A2_addpsat,                        // llvm.hexagon.A2.addpsat
+    hexagon_A2_addsat,                         // llvm.hexagon.A2.addsat
+    hexagon_A2_addsp,                          // llvm.hexagon.A2.addsp
+    hexagon_A2_and,                            // llvm.hexagon.A2.and
+    hexagon_A2_andir,                          // llvm.hexagon.A2.andir
+    hexagon_A2_andp,                           // llvm.hexagon.A2.andp
+    hexagon_A2_aslh,                           // llvm.hexagon.A2.aslh
+    hexagon_A2_asrh,                           // llvm.hexagon.A2.asrh
+    hexagon_A2_combine_hh,                     // llvm.hexagon.A2.combine.hh
+    hexagon_A2_combine_hl,                     // llvm.hexagon.A2.combine.hl
+    hexagon_A2_combine_lh,                     // llvm.hexagon.A2.combine.lh
+    hexagon_A2_combine_ll,                     // llvm.hexagon.A2.combine.ll
+    hexagon_A2_combineii,                      // llvm.hexagon.A2.combineii
+    hexagon_A2_combinew,                       // llvm.hexagon.A2.combinew
+    hexagon_A2_max,                            // llvm.hexagon.A2.max
+    hexagon_A2_maxp,                           // llvm.hexagon.A2.maxp
+    hexagon_A2_maxu,                           // llvm.hexagon.A2.maxu
+    hexagon_A2_maxup,                          // llvm.hexagon.A2.maxup
+    hexagon_A2_min,                            // llvm.hexagon.A2.min
+    hexagon_A2_minp,                           // llvm.hexagon.A2.minp
+    hexagon_A2_minu,                           // llvm.hexagon.A2.minu
+    hexagon_A2_minup,                          // llvm.hexagon.A2.minup
+    hexagon_A2_neg,                            // llvm.hexagon.A2.neg
+    hexagon_A2_negp,                           // llvm.hexagon.A2.negp
+    hexagon_A2_negsat,                         // llvm.hexagon.A2.negsat
+    hexagon_A2_not,                            // llvm.hexagon.A2.not
+    hexagon_A2_notp,                           // llvm.hexagon.A2.notp
+    hexagon_A2_or,                             // llvm.hexagon.A2.or
+    hexagon_A2_orir,                           // llvm.hexagon.A2.orir
+    hexagon_A2_orp,                            // llvm.hexagon.A2.orp
+    hexagon_A2_roundsat,                       // llvm.hexagon.A2.roundsat
+    hexagon_A2_sat,                            // llvm.hexagon.A2.sat
+    hexagon_A2_satb,                           // llvm.hexagon.A2.satb
+    hexagon_A2_sath,                           // llvm.hexagon.A2.sath
+    hexagon_A2_satub,                          // llvm.hexagon.A2.satub
+    hexagon_A2_satuh,                          // llvm.hexagon.A2.satuh
+    hexagon_A2_sub,                            // llvm.hexagon.A2.sub
+    hexagon_A2_subh_h16_hh,                    // llvm.hexagon.A2.subh.h16.hh
+    hexagon_A2_subh_h16_hl,                    // llvm.hexagon.A2.subh.h16.hl
+    hexagon_A2_subh_h16_lh,                    // llvm.hexagon.A2.subh.h16.lh
+    hexagon_A2_subh_h16_ll,                    // llvm.hexagon.A2.subh.h16.ll
+    hexagon_A2_subh_h16_sat_hh,                // llvm.hexagon.A2.subh.h16.sat.hh
+    hexagon_A2_subh_h16_sat_hl,                // llvm.hexagon.A2.subh.h16.sat.hl
+    hexagon_A2_subh_h16_sat_lh,                // llvm.hexagon.A2.subh.h16.sat.lh
+    hexagon_A2_subh_h16_sat_ll,                // llvm.hexagon.A2.subh.h16.sat.ll
+    hexagon_A2_subh_l16_hl,                    // llvm.hexagon.A2.subh.l16.hl
+    hexagon_A2_subh_l16_ll,                    // llvm.hexagon.A2.subh.l16.ll
+    hexagon_A2_subh_l16_sat_hl,                // llvm.hexagon.A2.subh.l16.sat.hl
+    hexagon_A2_subh_l16_sat_ll,                // llvm.hexagon.A2.subh.l16.sat.ll
+    hexagon_A2_subp,                           // llvm.hexagon.A2.subp
+    hexagon_A2_subri,                          // llvm.hexagon.A2.subri
+    hexagon_A2_subsat,                         // llvm.hexagon.A2.subsat
+    hexagon_A2_svaddh,                         // llvm.hexagon.A2.svaddh
+    hexagon_A2_svaddhs,                        // llvm.hexagon.A2.svaddhs
+    hexagon_A2_svadduhs,                       // llvm.hexagon.A2.svadduhs
+    hexagon_A2_svavgh,                         // llvm.hexagon.A2.svavgh
+    hexagon_A2_svavghs,                        // llvm.hexagon.A2.svavghs
+    hexagon_A2_svnavgh,                        // llvm.hexagon.A2.svnavgh
+    hexagon_A2_svsubh,                         // llvm.hexagon.A2.svsubh
+    hexagon_A2_svsubhs,                        // llvm.hexagon.A2.svsubhs
+    hexagon_A2_svsubuhs,                       // llvm.hexagon.A2.svsubuhs
+    hexagon_A2_swiz,                           // llvm.hexagon.A2.swiz
+    hexagon_A2_sxtb,                           // llvm.hexagon.A2.sxtb
+    hexagon_A2_sxth,                           // llvm.hexagon.A2.sxth
+    hexagon_A2_sxtw,                           // llvm.hexagon.A2.sxtw
+    hexagon_A2_tfr,                            // llvm.hexagon.A2.tfr
+    hexagon_A2_tfrih,                          // llvm.hexagon.A2.tfrih
+    hexagon_A2_tfril,                          // llvm.hexagon.A2.tfril
+    hexagon_A2_tfrp,                           // llvm.hexagon.A2.tfrp
+    hexagon_A2_tfrpi,                          // llvm.hexagon.A2.tfrpi
+    hexagon_A2_tfrsi,                          // llvm.hexagon.A2.tfrsi
+    hexagon_A2_vabsh,                          // llvm.hexagon.A2.vabsh
+    hexagon_A2_vabshsat,                       // llvm.hexagon.A2.vabshsat
+    hexagon_A2_vabsw,                          // llvm.hexagon.A2.vabsw
+    hexagon_A2_vabswsat,                       // llvm.hexagon.A2.vabswsat
+    hexagon_A2_vaddb_map,                      // llvm.hexagon.A2.vaddb.map
+    hexagon_A2_vaddh,                          // llvm.hexagon.A2.vaddh
+    hexagon_A2_vaddhs,                         // llvm.hexagon.A2.vaddhs
+    hexagon_A2_vaddub,                         // llvm.hexagon.A2.vaddub
+    hexagon_A2_vaddubs,                        // llvm.hexagon.A2.vaddubs
+    hexagon_A2_vadduhs,                        // llvm.hexagon.A2.vadduhs
+    hexagon_A2_vaddw,                          // llvm.hexagon.A2.vaddw
+    hexagon_A2_vaddws,                         // llvm.hexagon.A2.vaddws
+    hexagon_A2_vavgh,                          // llvm.hexagon.A2.vavgh
+    hexagon_A2_vavghcr,                        // llvm.hexagon.A2.vavghcr
+    hexagon_A2_vavghr,                         // llvm.hexagon.A2.vavghr
+    hexagon_A2_vavgub,                         // llvm.hexagon.A2.vavgub
+    hexagon_A2_vavgubr,                        // llvm.hexagon.A2.vavgubr
+    hexagon_A2_vavguh,                         // llvm.hexagon.A2.vavguh
+    hexagon_A2_vavguhr,                        // llvm.hexagon.A2.vavguhr
+    hexagon_A2_vavguw,                         // llvm.hexagon.A2.vavguw
+    hexagon_A2_vavguwr,                        // llvm.hexagon.A2.vavguwr
+    hexagon_A2_vavgw,                          // llvm.hexagon.A2.vavgw
+    hexagon_A2_vavgwcr,                        // llvm.hexagon.A2.vavgwcr
+    hexagon_A2_vavgwr,                         // llvm.hexagon.A2.vavgwr
+    hexagon_A2_vcmpbeq,                        // llvm.hexagon.A2.vcmpbeq
+    hexagon_A2_vcmpbgtu,                       // llvm.hexagon.A2.vcmpbgtu
+    hexagon_A2_vcmpheq,                        // llvm.hexagon.A2.vcmpheq
+    hexagon_A2_vcmphgt,                        // llvm.hexagon.A2.vcmphgt
+    hexagon_A2_vcmphgtu,                       // llvm.hexagon.A2.vcmphgtu
+    hexagon_A2_vcmpweq,                        // llvm.hexagon.A2.vcmpweq
+    hexagon_A2_vcmpwgt,                        // llvm.hexagon.A2.vcmpwgt
+    hexagon_A2_vcmpwgtu,                       // llvm.hexagon.A2.vcmpwgtu
+    hexagon_A2_vconj,                          // llvm.hexagon.A2.vconj
+    hexagon_A2_vmaxb,                          // llvm.hexagon.A2.vmaxb
+    hexagon_A2_vmaxh,                          // llvm.hexagon.A2.vmaxh
+    hexagon_A2_vmaxub,                         // llvm.hexagon.A2.vmaxub
+    hexagon_A2_vmaxuh,                         // llvm.hexagon.A2.vmaxuh
+    hexagon_A2_vmaxuw,                         // llvm.hexagon.A2.vmaxuw
+    hexagon_A2_vmaxw,                          // llvm.hexagon.A2.vmaxw
+    hexagon_A2_vminb,                          // llvm.hexagon.A2.vminb
+    hexagon_A2_vminh,                          // llvm.hexagon.A2.vminh
+    hexagon_A2_vminub,                         // llvm.hexagon.A2.vminub
+    hexagon_A2_vminuh,                         // llvm.hexagon.A2.vminuh
+    hexagon_A2_vminuw,                         // llvm.hexagon.A2.vminuw
+    hexagon_A2_vminw,                          // llvm.hexagon.A2.vminw
+    hexagon_A2_vnavgh,                         // llvm.hexagon.A2.vnavgh
+    hexagon_A2_vnavghcr,                       // llvm.hexagon.A2.vnavghcr
+    hexagon_A2_vnavghr,                        // llvm.hexagon.A2.vnavghr
+    hexagon_A2_vnavgw,                         // llvm.hexagon.A2.vnavgw
+    hexagon_A2_vnavgwcr,                       // llvm.hexagon.A2.vnavgwcr
+    hexagon_A2_vnavgwr,                        // llvm.hexagon.A2.vnavgwr
+    hexagon_A2_vraddub,                        // llvm.hexagon.A2.vraddub
+    hexagon_A2_vraddub_acc,                    // llvm.hexagon.A2.vraddub.acc
+    hexagon_A2_vrsadub,                        // llvm.hexagon.A2.vrsadub
+    hexagon_A2_vrsadub_acc,                    // llvm.hexagon.A2.vrsadub.acc
+    hexagon_A2_vsubb_map,                      // llvm.hexagon.A2.vsubb.map
+    hexagon_A2_vsubh,                          // llvm.hexagon.A2.vsubh
+    hexagon_A2_vsubhs,                         // llvm.hexagon.A2.vsubhs
+    hexagon_A2_vsubub,                         // llvm.hexagon.A2.vsubub
+    hexagon_A2_vsububs,                        // llvm.hexagon.A2.vsububs
+    hexagon_A2_vsubuhs,                        // llvm.hexagon.A2.vsubuhs
+    hexagon_A2_vsubw,                          // llvm.hexagon.A2.vsubw
+    hexagon_A2_vsubws,                         // llvm.hexagon.A2.vsubws
+    hexagon_A2_xor,                            // llvm.hexagon.A2.xor
+    hexagon_A2_xorp,                           // llvm.hexagon.A2.xorp
+    hexagon_A2_zxtb,                           // llvm.hexagon.A2.zxtb
+    hexagon_A2_zxth,                           // llvm.hexagon.A2.zxth
+    hexagon_A4_andn,                           // llvm.hexagon.A4.andn
+    hexagon_A4_andnp,                          // llvm.hexagon.A4.andnp
+    hexagon_A4_bitsplit,                       // llvm.hexagon.A4.bitsplit
+    hexagon_A4_bitspliti,                      // llvm.hexagon.A4.bitspliti
+    hexagon_A4_boundscheck,                    // llvm.hexagon.A4.boundscheck
+    hexagon_A4_cmpbeq,                         // llvm.hexagon.A4.cmpbeq
+    hexagon_A4_cmpbeqi,                        // llvm.hexagon.A4.cmpbeqi
+    hexagon_A4_cmpbgt,                         // llvm.hexagon.A4.cmpbgt
+    hexagon_A4_cmpbgti,                        // llvm.hexagon.A4.cmpbgti
+    hexagon_A4_cmpbgtu,                        // llvm.hexagon.A4.cmpbgtu
+    hexagon_A4_cmpbgtui,                       // llvm.hexagon.A4.cmpbgtui
+    hexagon_A4_cmpheq,                         // llvm.hexagon.A4.cmpheq
+    hexagon_A4_cmpheqi,                        // llvm.hexagon.A4.cmpheqi
+    hexagon_A4_cmphgt,                         // llvm.hexagon.A4.cmphgt
+    hexagon_A4_cmphgti,                        // llvm.hexagon.A4.cmphgti
+    hexagon_A4_cmphgtu,                        // llvm.hexagon.A4.cmphgtu
+    hexagon_A4_cmphgtui,                       // llvm.hexagon.A4.cmphgtui
+    hexagon_A4_combineir,                      // llvm.hexagon.A4.combineir
+    hexagon_A4_combineri,                      // llvm.hexagon.A4.combineri
+    hexagon_A4_cround_ri,                      // llvm.hexagon.A4.cround.ri
+    hexagon_A4_cround_rr,                      // llvm.hexagon.A4.cround.rr
+    hexagon_A4_modwrapu,                       // llvm.hexagon.A4.modwrapu
+    hexagon_A4_orn,                            // llvm.hexagon.A4.orn
+    hexagon_A4_ornp,                           // llvm.hexagon.A4.ornp
+    hexagon_A4_rcmpeq,                         // llvm.hexagon.A4.rcmpeq
+    hexagon_A4_rcmpeqi,                        // llvm.hexagon.A4.rcmpeqi
+    hexagon_A4_rcmpneq,                        // llvm.hexagon.A4.rcmpneq
+    hexagon_A4_rcmpneqi,                       // llvm.hexagon.A4.rcmpneqi
+    hexagon_A4_round_ri,                       // llvm.hexagon.A4.round.ri
+    hexagon_A4_round_ri_sat,                   // llvm.hexagon.A4.round.ri.sat
+    hexagon_A4_round_rr,                       // llvm.hexagon.A4.round.rr
+    hexagon_A4_round_rr_sat,                   // llvm.hexagon.A4.round.rr.sat
+    hexagon_A4_tlbmatch,                       // llvm.hexagon.A4.tlbmatch
+    hexagon_A4_vcmpbeq_any,                    // llvm.hexagon.A4.vcmpbeq.any
+    hexagon_A4_vcmpbeqi,                       // llvm.hexagon.A4.vcmpbeqi
+    hexagon_A4_vcmpbgt,                        // llvm.hexagon.A4.vcmpbgt
+    hexagon_A4_vcmpbgti,                       // llvm.hexagon.A4.vcmpbgti
+    hexagon_A4_vcmpbgtui,                      // llvm.hexagon.A4.vcmpbgtui
+    hexagon_A4_vcmpheqi,                       // llvm.hexagon.A4.vcmpheqi
+    hexagon_A4_vcmphgti,                       // llvm.hexagon.A4.vcmphgti
+    hexagon_A4_vcmphgtui,                      // llvm.hexagon.A4.vcmphgtui
+    hexagon_A4_vcmpweqi,                       // llvm.hexagon.A4.vcmpweqi
+    hexagon_A4_vcmpwgti,                       // llvm.hexagon.A4.vcmpwgti
+    hexagon_A4_vcmpwgtui,                      // llvm.hexagon.A4.vcmpwgtui
+    hexagon_A4_vrmaxh,                         // llvm.hexagon.A4.vrmaxh
+    hexagon_A4_vrmaxuh,                        // llvm.hexagon.A4.vrmaxuh
+    hexagon_A4_vrmaxuw,                        // llvm.hexagon.A4.vrmaxuw
+    hexagon_A4_vrmaxw,                         // llvm.hexagon.A4.vrmaxw
+    hexagon_A4_vrminh,                         // llvm.hexagon.A4.vrminh
+    hexagon_A4_vrminuh,                        // llvm.hexagon.A4.vrminuh
+    hexagon_A4_vrminuw,                        // llvm.hexagon.A4.vrminuw
+    hexagon_A4_vrminw,                         // llvm.hexagon.A4.vrminw
+    hexagon_A5_vaddhubs,                       // llvm.hexagon.A5.vaddhubs
+    hexagon_A6_vcmpbeq_notany,                 // llvm.hexagon.A6.vcmpbeq.notany
+    hexagon_A7_clip,                           // llvm.hexagon.A7.clip
+    hexagon_A7_croundd_ri,                     // llvm.hexagon.A7.croundd.ri
+    hexagon_A7_croundd_rr,                     // llvm.hexagon.A7.croundd.rr
+    hexagon_A7_vclip,                          // llvm.hexagon.A7.vclip
+    hexagon_C2_all8,                           // llvm.hexagon.C2.all8
+    hexagon_C2_and,                            // llvm.hexagon.C2.and
+    hexagon_C2_andn,                           // llvm.hexagon.C2.andn
+    hexagon_C2_any8,                           // llvm.hexagon.C2.any8
+    hexagon_C2_bitsclr,                        // llvm.hexagon.C2.bitsclr
+    hexagon_C2_bitsclri,                       // llvm.hexagon.C2.bitsclri
+    hexagon_C2_bitsset,                        // llvm.hexagon.C2.bitsset
+    hexagon_C2_cmpeq,                          // llvm.hexagon.C2.cmpeq
+    hexagon_C2_cmpeqi,                         // llvm.hexagon.C2.cmpeqi
+    hexagon_C2_cmpeqp,                         // llvm.hexagon.C2.cmpeqp
+    hexagon_C2_cmpgei,                         // llvm.hexagon.C2.cmpgei
+    hexagon_C2_cmpgeui,                        // llvm.hexagon.C2.cmpgeui
+    hexagon_C2_cmpgt,                          // llvm.hexagon.C2.cmpgt
+    hexagon_C2_cmpgti,                         // llvm.hexagon.C2.cmpgti
+    hexagon_C2_cmpgtp,                         // llvm.hexagon.C2.cmpgtp
+    hexagon_C2_cmpgtu,                         // llvm.hexagon.C2.cmpgtu
+    hexagon_C2_cmpgtui,                        // llvm.hexagon.C2.cmpgtui
+    hexagon_C2_cmpgtup,                        // llvm.hexagon.C2.cmpgtup
+    hexagon_C2_cmplt,                          // llvm.hexagon.C2.cmplt
+    hexagon_C2_cmpltu,                         // llvm.hexagon.C2.cmpltu
+    hexagon_C2_mask,                           // llvm.hexagon.C2.mask
+    hexagon_C2_mux,                            // llvm.hexagon.C2.mux
+    hexagon_C2_muxii,                          // llvm.hexagon.C2.muxii
+    hexagon_C2_muxir,                          // llvm.hexagon.C2.muxir
+    hexagon_C2_muxri,                          // llvm.hexagon.C2.muxri
+    hexagon_C2_not,                            // llvm.hexagon.C2.not
+    hexagon_C2_or,                             // llvm.hexagon.C2.or
+    hexagon_C2_orn,                            // llvm.hexagon.C2.orn
+    hexagon_C2_pxfer_map,                      // llvm.hexagon.C2.pxfer.map
+    hexagon_C2_tfrpr,                          // llvm.hexagon.C2.tfrpr
+    hexagon_C2_tfrrp,                          // llvm.hexagon.C2.tfrrp
+    hexagon_C2_vitpack,                        // llvm.hexagon.C2.vitpack
+    hexagon_C2_vmux,                           // llvm.hexagon.C2.vmux
+    hexagon_C2_xor,                            // llvm.hexagon.C2.xor
+    hexagon_C4_and_and,                        // llvm.hexagon.C4.and.and
+    hexagon_C4_and_andn,                       // llvm.hexagon.C4.and.andn
+    hexagon_C4_and_or,                         // llvm.hexagon.C4.and.or
+    hexagon_C4_and_orn,                        // llvm.hexagon.C4.and.orn
+    hexagon_C4_cmplte,                         // llvm.hexagon.C4.cmplte
+    hexagon_C4_cmpltei,                        // llvm.hexagon.C4.cmpltei
+    hexagon_C4_cmplteu,                        // llvm.hexagon.C4.cmplteu
+    hexagon_C4_cmplteui,                       // llvm.hexagon.C4.cmplteui
+    hexagon_C4_cmpneq,                         // llvm.hexagon.C4.cmpneq
+    hexagon_C4_cmpneqi,                        // llvm.hexagon.C4.cmpneqi
+    hexagon_C4_fastcorner9,                    // llvm.hexagon.C4.fastcorner9
+    hexagon_C4_fastcorner9_not,                // llvm.hexagon.C4.fastcorner9.not
+    hexagon_C4_nbitsclr,                       // llvm.hexagon.C4.nbitsclr
+    hexagon_C4_nbitsclri,                      // llvm.hexagon.C4.nbitsclri
+    hexagon_C4_nbitsset,                       // llvm.hexagon.C4.nbitsset
+    hexagon_C4_or_and,                         // llvm.hexagon.C4.or.and
+    hexagon_C4_or_andn,                        // llvm.hexagon.C4.or.andn
+    hexagon_C4_or_or,                          // llvm.hexagon.C4.or.or
+    hexagon_C4_or_orn,                         // llvm.hexagon.C4.or.orn
+    hexagon_F2_conv_d2df,                      // llvm.hexagon.F2.conv.d2df
+    hexagon_F2_conv_d2sf,                      // llvm.hexagon.F2.conv.d2sf
+    hexagon_F2_conv_df2d,                      // llvm.hexagon.F2.conv.df2d
+    hexagon_F2_conv_df2d_chop,                 // llvm.hexagon.F2.conv.df2d.chop
+    hexagon_F2_conv_df2sf,                     // llvm.hexagon.F2.conv.df2sf
+    hexagon_F2_conv_df2ud,                     // llvm.hexagon.F2.conv.df2ud
+    hexagon_F2_conv_df2ud_chop,                // llvm.hexagon.F2.conv.df2ud.chop
+    hexagon_F2_conv_df2uw,                     // llvm.hexagon.F2.conv.df2uw
+    hexagon_F2_conv_df2uw_chop,                // llvm.hexagon.F2.conv.df2uw.chop
+    hexagon_F2_conv_df2w,                      // llvm.hexagon.F2.conv.df2w
+    hexagon_F2_conv_df2w_chop,                 // llvm.hexagon.F2.conv.df2w.chop
+    hexagon_F2_conv_sf2d,                      // llvm.hexagon.F2.conv.sf2d
+    hexagon_F2_conv_sf2d_chop,                 // llvm.hexagon.F2.conv.sf2d.chop
+    hexagon_F2_conv_sf2df,                     // llvm.hexagon.F2.conv.sf2df
+    hexagon_F2_conv_sf2ud,                     // llvm.hexagon.F2.conv.sf2ud
+    hexagon_F2_conv_sf2ud_chop,                // llvm.hexagon.F2.conv.sf2ud.chop
+    hexagon_F2_conv_sf2uw,                     // llvm.hexagon.F2.conv.sf2uw
+    hexagon_F2_conv_sf2uw_chop,                // llvm.hexagon.F2.conv.sf2uw.chop
+    hexagon_F2_conv_sf2w,                      // llvm.hexagon.F2.conv.sf2w
+    hexagon_F2_conv_sf2w_chop,                 // llvm.hexagon.F2.conv.sf2w.chop
+    hexagon_F2_conv_ud2df,                     // llvm.hexagon.F2.conv.ud2df
+    hexagon_F2_conv_ud2sf,                     // llvm.hexagon.F2.conv.ud2sf
+    hexagon_F2_conv_uw2df,                     // llvm.hexagon.F2.conv.uw2df
+    hexagon_F2_conv_uw2sf,                     // llvm.hexagon.F2.conv.uw2sf
+    hexagon_F2_conv_w2df,                      // llvm.hexagon.F2.conv.w2df
+    hexagon_F2_conv_w2sf,                      // llvm.hexagon.F2.conv.w2sf
+    hexagon_F2_dfadd,                          // llvm.hexagon.F2.dfadd
+    hexagon_F2_dfclass,                        // llvm.hexagon.F2.dfclass
+    hexagon_F2_dfcmpeq,                        // llvm.hexagon.F2.dfcmpeq
+    hexagon_F2_dfcmpge,                        // llvm.hexagon.F2.dfcmpge
+    hexagon_F2_dfcmpgt,                        // llvm.hexagon.F2.dfcmpgt
+    hexagon_F2_dfcmpuo,                        // llvm.hexagon.F2.dfcmpuo
+    hexagon_F2_dfimm_n,                        // llvm.hexagon.F2.dfimm.n
+    hexagon_F2_dfimm_p,                        // llvm.hexagon.F2.dfimm.p
+    hexagon_F2_dfmax,                          // llvm.hexagon.F2.dfmax
+    hexagon_F2_dfmin,                          // llvm.hexagon.F2.dfmin
+    hexagon_F2_dfmpyfix,                       // llvm.hexagon.F2.dfmpyfix
+    hexagon_F2_dfmpyhh,                        // llvm.hexagon.F2.dfmpyhh
+    hexagon_F2_dfmpylh,                        // llvm.hexagon.F2.dfmpylh
+    hexagon_F2_dfmpyll,                        // llvm.hexagon.F2.dfmpyll
+    hexagon_F2_dfsub,                          // llvm.hexagon.F2.dfsub
+    hexagon_F2_sfadd,                          // llvm.hexagon.F2.sfadd
+    hexagon_F2_sfclass,                        // llvm.hexagon.F2.sfclass
+    hexagon_F2_sfcmpeq,                        // llvm.hexagon.F2.sfcmpeq
+    hexagon_F2_sfcmpge,                        // llvm.hexagon.F2.sfcmpge
+    hexagon_F2_sfcmpgt,                        // llvm.hexagon.F2.sfcmpgt
+    hexagon_F2_sfcmpuo,                        // llvm.hexagon.F2.sfcmpuo
+    hexagon_F2_sffixupd,                       // llvm.hexagon.F2.sffixupd
+    hexagon_F2_sffixupn,                       // llvm.hexagon.F2.sffixupn
+    hexagon_F2_sffixupr,                       // llvm.hexagon.F2.sffixupr
+    hexagon_F2_sffma,                          // llvm.hexagon.F2.sffma
+    hexagon_F2_sffma_lib,                      // llvm.hexagon.F2.sffma.lib
+    hexagon_F2_sffma_sc,                       // llvm.hexagon.F2.sffma.sc
+    hexagon_F2_sffms,                          // llvm.hexagon.F2.sffms
+    hexagon_F2_sffms_lib,                      // llvm.hexagon.F2.sffms.lib
+    hexagon_F2_sfimm_n,                        // llvm.hexagon.F2.sfimm.n
+    hexagon_F2_sfimm_p,                        // llvm.hexagon.F2.sfimm.p
+    hexagon_F2_sfmax,                          // llvm.hexagon.F2.sfmax
+    hexagon_F2_sfmin,                          // llvm.hexagon.F2.sfmin
+    hexagon_F2_sfmpy,                          // llvm.hexagon.F2.sfmpy
+    hexagon_F2_sfsub,                          // llvm.hexagon.F2.sfsub
+    hexagon_L2_loadrb_pbr,                     // llvm.hexagon.L2.loadrb.pbr
+    hexagon_L2_loadrb_pci,                     // llvm.hexagon.L2.loadrb.pci
+    hexagon_L2_loadrb_pcr,                     // llvm.hexagon.L2.loadrb.pcr
+    hexagon_L2_loadrd_pbr,                     // llvm.hexagon.L2.loadrd.pbr
+    hexagon_L2_loadrd_pci,                     // llvm.hexagon.L2.loadrd.pci
+    hexagon_L2_loadrd_pcr,                     // llvm.hexagon.L2.loadrd.pcr
+    hexagon_L2_loadrh_pbr,                     // llvm.hexagon.L2.loadrh.pbr
+    hexagon_L2_loadrh_pci,                     // llvm.hexagon.L2.loadrh.pci
+    hexagon_L2_loadrh_pcr,                     // llvm.hexagon.L2.loadrh.pcr
+    hexagon_L2_loadri_pbr,                     // llvm.hexagon.L2.loadri.pbr
+    hexagon_L2_loadri_pci,                     // llvm.hexagon.L2.loadri.pci
+    hexagon_L2_loadri_pcr,                     // llvm.hexagon.L2.loadri.pcr
+    hexagon_L2_loadrub_pbr,                    // llvm.hexagon.L2.loadrub.pbr
+    hexagon_L2_loadrub_pci,                    // llvm.hexagon.L2.loadrub.pci
+    hexagon_L2_loadrub_pcr,                    // llvm.hexagon.L2.loadrub.pcr
+    hexagon_L2_loadruh_pbr,                    // llvm.hexagon.L2.loadruh.pbr
+    hexagon_L2_loadruh_pci,                    // llvm.hexagon.L2.loadruh.pci
+    hexagon_L2_loadruh_pcr,                    // llvm.hexagon.L2.loadruh.pcr
+    hexagon_L2_loadw_locked,                   // llvm.hexagon.L2.loadw.locked
+    hexagon_L4_loadd_locked,                   // llvm.hexagon.L4.loadd.locked
+    hexagon_M2_acci,                           // llvm.hexagon.M2.acci
+    hexagon_M2_accii,                          // llvm.hexagon.M2.accii
+    hexagon_M2_cmaci_s0,                       // llvm.hexagon.M2.cmaci.s0
+    hexagon_M2_cmacr_s0,                       // llvm.hexagon.M2.cmacr.s0
+    hexagon_M2_cmacs_s0,                       // llvm.hexagon.M2.cmacs.s0
+    hexagon_M2_cmacs_s1,                       // llvm.hexagon.M2.cmacs.s1
+    hexagon_M2_cmacsc_s0,                      // llvm.hexagon.M2.cmacsc.s0
+    hexagon_M2_cmacsc_s1,                      // llvm.hexagon.M2.cmacsc.s1
+    hexagon_M2_cmpyi_s0,                       // llvm.hexagon.M2.cmpyi.s0
+    hexagon_M2_cmpyr_s0,                       // llvm.hexagon.M2.cmpyr.s0
+    hexagon_M2_cmpyrs_s0,                      // llvm.hexagon.M2.cmpyrs.s0
+    hexagon_M2_cmpyrs_s1,                      // llvm.hexagon.M2.cmpyrs.s1
+    hexagon_M2_cmpyrsc_s0,                     // llvm.hexagon.M2.cmpyrsc.s0
+    hexagon_M2_cmpyrsc_s1,                     // llvm.hexagon.M2.cmpyrsc.s1
+    hexagon_M2_cmpys_s0,                       // llvm.hexagon.M2.cmpys.s0
+    hexagon_M2_cmpys_s1,                       // llvm.hexagon.M2.cmpys.s1
+    hexagon_M2_cmpysc_s0,                      // llvm.hexagon.M2.cmpysc.s0
+    hexagon_M2_cmpysc_s1,                      // llvm.hexagon.M2.cmpysc.s1
+    hexagon_M2_cnacs_s0,                       // llvm.hexagon.M2.cnacs.s0
+    hexagon_M2_cnacs_s1,                       // llvm.hexagon.M2.cnacs.s1
+    hexagon_M2_cnacsc_s0,                      // llvm.hexagon.M2.cnacsc.s0
+    hexagon_M2_cnacsc_s1,                      // llvm.hexagon.M2.cnacsc.s1
+    hexagon_M2_dpmpyss_acc_s0,                 // llvm.hexagon.M2.dpmpyss.acc.s0
+    hexagon_M2_dpmpyss_nac_s0,                 // llvm.hexagon.M2.dpmpyss.nac.s0
+    hexagon_M2_dpmpyss_rnd_s0,                 // llvm.hexagon.M2.dpmpyss.rnd.s0
+    hexagon_M2_dpmpyss_s0,                     // llvm.hexagon.M2.dpmpyss.s0
+    hexagon_M2_dpmpyuu_acc_s0,                 // llvm.hexagon.M2.dpmpyuu.acc.s0
+    hexagon_M2_dpmpyuu_nac_s0,                 // llvm.hexagon.M2.dpmpyuu.nac.s0
+    hexagon_M2_dpmpyuu_s0,                     // llvm.hexagon.M2.dpmpyuu.s0
+    hexagon_M2_hmmpyh_rs1,                     // llvm.hexagon.M2.hmmpyh.rs1
+    hexagon_M2_hmmpyh_s1,                      // llvm.hexagon.M2.hmmpyh.s1
+    hexagon_M2_hmmpyl_rs1,                     // llvm.hexagon.M2.hmmpyl.rs1
+    hexagon_M2_hmmpyl_s1,                      // llvm.hexagon.M2.hmmpyl.s1
+    hexagon_M2_maci,                           // llvm.hexagon.M2.maci
+    hexagon_M2_macsin,                         // llvm.hexagon.M2.macsin
+    hexagon_M2_macsip,                         // llvm.hexagon.M2.macsip
+    hexagon_M2_mmachs_rs0,                     // llvm.hexagon.M2.mmachs.rs0
+    hexagon_M2_mmachs_rs1,                     // llvm.hexagon.M2.mmachs.rs1
+    hexagon_M2_mmachs_s0,                      // llvm.hexagon.M2.mmachs.s0
+    hexagon_M2_mmachs_s1,                      // llvm.hexagon.M2.mmachs.s1
+    hexagon_M2_mmacls_rs0,                     // llvm.hexagon.M2.mmacls.rs0
+    hexagon_M2_mmacls_rs1,                     // llvm.hexagon.M2.mmacls.rs1
+    hexagon_M2_mmacls_s0,                      // llvm.hexagon.M2.mmacls.s0
+    hexagon_M2_mmacls_s1,                      // llvm.hexagon.M2.mmacls.s1
+    hexagon_M2_mmacuhs_rs0,                    // llvm.hexagon.M2.mmacuhs.rs0
+    hexagon_M2_mmacuhs_rs1,                    // llvm.hexagon.M2.mmacuhs.rs1
+    hexagon_M2_mmacuhs_s0,                     // llvm.hexagon.M2.mmacuhs.s0
+    hexagon_M2_mmacuhs_s1,                     // llvm.hexagon.M2.mmacuhs.s1
+    hexagon_M2_mmaculs_rs0,                    // llvm.hexagon.M2.mmaculs.rs0
+    hexagon_M2_mmaculs_rs1,                    // llvm.hexagon.M2.mmaculs.rs1
+    hexagon_M2_mmaculs_s0,                     // llvm.hexagon.M2.mmaculs.s0
+    hexagon_M2_mmaculs_s1,                     // llvm.hexagon.M2.mmaculs.s1
+    hexagon_M2_mmpyh_rs0,                      // llvm.hexagon.M2.mmpyh.rs0
+    hexagon_M2_mmpyh_rs1,                      // llvm.hexagon.M2.mmpyh.rs1
+    hexagon_M2_mmpyh_s0,                       // llvm.hexagon.M2.mmpyh.s0
+    hexagon_M2_mmpyh_s1,                       // llvm.hexagon.M2.mmpyh.s1
+    hexagon_M2_mmpyl_rs0,                      // llvm.hexagon.M2.mmpyl.rs0
+    hexagon_M2_mmpyl_rs1,                      // llvm.hexagon.M2.mmpyl.rs1
+    hexagon_M2_mmpyl_s0,                       // llvm.hexagon.M2.mmpyl.s0
+    hexagon_M2_mmpyl_s1,                       // llvm.hexagon.M2.mmpyl.s1
+    hexagon_M2_mmpyuh_rs0,                     // llvm.hexagon.M2.mmpyuh.rs0
+    hexagon_M2_mmpyuh_rs1,                     // llvm.hexagon.M2.mmpyuh.rs1
+    hexagon_M2_mmpyuh_s0,                      // llvm.hexagon.M2.mmpyuh.s0
+    hexagon_M2_mmpyuh_s1,                      // llvm.hexagon.M2.mmpyuh.s1
+    hexagon_M2_mmpyul_rs0,                     // llvm.hexagon.M2.mmpyul.rs0
+    hexagon_M2_mmpyul_rs1,                     // llvm.hexagon.M2.mmpyul.rs1
+    hexagon_M2_mmpyul_s0,                      // llvm.hexagon.M2.mmpyul.s0
+    hexagon_M2_mmpyul_s1,                      // llvm.hexagon.M2.mmpyul.s1
+    hexagon_M2_mnaci,                          // llvm.hexagon.M2.mnaci
+    hexagon_M2_mpy_acc_hh_s0,                  // llvm.hexagon.M2.mpy.acc.hh.s0
+    hexagon_M2_mpy_acc_hh_s1,                  // llvm.hexagon.M2.mpy.acc.hh.s1
+    hexagon_M2_mpy_acc_hl_s0,                  // llvm.hexagon.M2.mpy.acc.hl.s0
+    hexagon_M2_mpy_acc_hl_s1,                  // llvm.hexagon.M2.mpy.acc.hl.s1
+    hexagon_M2_mpy_acc_lh_s0,                  // llvm.hexagon.M2.mpy.acc.lh.s0
+    hexagon_M2_mpy_acc_lh_s1,                  // llvm.hexagon.M2.mpy.acc.lh.s1
+    hexagon_M2_mpy_acc_ll_s0,                  // llvm.hexagon.M2.mpy.acc.ll.s0
+    hexagon_M2_mpy_acc_ll_s1,                  // llvm.hexagon.M2.mpy.acc.ll.s1
+    hexagon_M2_mpy_acc_sat_hh_s0,              // llvm.hexagon.M2.mpy.acc.sat.hh.s0
+    hexagon_M2_mpy_acc_sat_hh_s1,              // llvm.hexagon.M2.mpy.acc.sat.hh.s1
+    hexagon_M2_mpy_acc_sat_hl_s0,              // llvm.hexagon.M2.mpy.acc.sat.hl.s0
+    hexagon_M2_mpy_acc_sat_hl_s1,              // llvm.hexagon.M2.mpy.acc.sat.hl.s1
+    hexagon_M2_mpy_acc_sat_lh_s0,              // llvm.hexagon.M2.mpy.acc.sat.lh.s0
+    hexagon_M2_mpy_acc_sat_lh_s1,              // llvm.hexagon.M2.mpy.acc.sat.lh.s1
+    hexagon_M2_mpy_acc_sat_ll_s0,              // llvm.hexagon.M2.mpy.acc.sat.ll.s0
+    hexagon_M2_mpy_acc_sat_ll_s1,              // llvm.hexagon.M2.mpy.acc.sat.ll.s1
+    hexagon_M2_mpy_hh_s0,                      // llvm.hexagon.M2.mpy.hh.s0
+    hexagon_M2_mpy_hh_s1,                      // llvm.hexagon.M2.mpy.hh.s1
+    hexagon_M2_mpy_hl_s0,                      // llvm.hexagon.M2.mpy.hl.s0
+    hexagon_M2_mpy_hl_s1,                      // llvm.hexagon.M2.mpy.hl.s1
+    hexagon_M2_mpy_lh_s0,                      // llvm.hexagon.M2.mpy.lh.s0
+    hexagon_M2_mpy_lh_s1,                      // llvm.hexagon.M2.mpy.lh.s1
+    hexagon_M2_mpy_ll_s0,                      // llvm.hexagon.M2.mpy.ll.s0
+    hexagon_M2_mpy_ll_s1,                      // llvm.hexagon.M2.mpy.ll.s1
+    hexagon_M2_mpy_nac_hh_s0,                  // llvm.hexagon.M2.mpy.nac.hh.s0
+    hexagon_M2_mpy_nac_hh_s1,                  // llvm.hexagon.M2.mpy.nac.hh.s1
+    hexagon_M2_mpy_nac_hl_s0,                  // llvm.hexagon.M2.mpy.nac.hl.s0
+    hexagon_M2_mpy_nac_hl_s1,                  // llvm.hexagon.M2.mpy.nac.hl.s1
+    hexagon_M2_mpy_nac_lh_s0,                  // llvm.hexagon.M2.mpy.nac.lh.s0
+    hexagon_M2_mpy_nac_lh_s1,                  // llvm.hexagon.M2.mpy.nac.lh.s1
+    hexagon_M2_mpy_nac_ll_s0,                  // llvm.hexagon.M2.mpy.nac.ll.s0
+    hexagon_M2_mpy_nac_ll_s1,                  // llvm.hexagon.M2.mpy.nac.ll.s1
+    hexagon_M2_mpy_nac_sat_hh_s0,              // llvm.hexagon.M2.mpy.nac.sat.hh.s0
+    hexagon_M2_mpy_nac_sat_hh_s1,              // llvm.hexagon.M2.mpy.nac.sat.hh.s1
+    hexagon_M2_mpy_nac_sat_hl_s0,              // llvm.hexagon.M2.mpy.nac.sat.hl.s0
+    hexagon_M2_mpy_nac_sat_hl_s1,              // llvm.hexagon.M2.mpy.nac.sat.hl.s1
+    hexagon_M2_mpy_nac_sat_lh_s0,              // llvm.hexagon.M2.mpy.nac.sat.lh.s0
+    hexagon_M2_mpy_nac_sat_lh_s1,              // llvm.hexagon.M2.mpy.nac.sat.lh.s1
+    hexagon_M2_mpy_nac_sat_ll_s0,              // llvm.hexagon.M2.mpy.nac.sat.ll.s0
+    hexagon_M2_mpy_nac_sat_ll_s1,              // llvm.hexagon.M2.mpy.nac.sat.ll.s1
+    hexagon_M2_mpy_rnd_hh_s0,                  // llvm.hexagon.M2.mpy.rnd.hh.s0
+    hexagon_M2_mpy_rnd_hh_s1,                  // llvm.hexagon.M2.mpy.rnd.hh.s1
+    hexagon_M2_mpy_rnd_hl_s0,                  // llvm.hexagon.M2.mpy.rnd.hl.s0
+    hexagon_M2_mpy_rnd_hl_s1,                  // llvm.hexagon.M2.mpy.rnd.hl.s1
+    hexagon_M2_mpy_rnd_lh_s0,                  // llvm.hexagon.M2.mpy.rnd.lh.s0
+    hexagon_M2_mpy_rnd_lh_s1,                  // llvm.hexagon.M2.mpy.rnd.lh.s1
+    hexagon_M2_mpy_rnd_ll_s0,                  // llvm.hexagon.M2.mpy.rnd.ll.s0
+    hexagon_M2_mpy_rnd_ll_s1,                  // llvm.hexagon.M2.mpy.rnd.ll.s1
+    hexagon_M2_mpy_sat_hh_s0,                  // llvm.hexagon.M2.mpy.sat.hh.s0
+    hexagon_M2_mpy_sat_hh_s1,                  // llvm.hexagon.M2.mpy.sat.hh.s1
+    hexagon_M2_mpy_sat_hl_s0,                  // llvm.hexagon.M2.mpy.sat.hl.s0
+    hexagon_M2_mpy_sat_hl_s1,                  // llvm.hexagon.M2.mpy.sat.hl.s1
+    hexagon_M2_mpy_sat_lh_s0,                  // llvm.hexagon.M2.mpy.sat.lh.s0
+    hexagon_M2_mpy_sat_lh_s1,                  // llvm.hexagon.M2.mpy.sat.lh.s1
+    hexagon_M2_mpy_sat_ll_s0,                  // llvm.hexagon.M2.mpy.sat.ll.s0
+    hexagon_M2_mpy_sat_ll_s1,                  // llvm.hexagon.M2.mpy.sat.ll.s1
+    hexagon_M2_mpy_sat_rnd_hh_s0,              // llvm.hexagon.M2.mpy.sat.rnd.hh.s0
+    hexagon_M2_mpy_sat_rnd_hh_s1,              // llvm.hexagon.M2.mpy.sat.rnd.hh.s1
+    hexagon_M2_mpy_sat_rnd_hl_s0,              // llvm.hexagon.M2.mpy.sat.rnd.hl.s0
+    hexagon_M2_mpy_sat_rnd_hl_s1,              // llvm.hexagon.M2.mpy.sat.rnd.hl.s1
+    hexagon_M2_mpy_sat_rnd_lh_s0,              // llvm.hexagon.M2.mpy.sat.rnd.lh.s0
+    hexagon_M2_mpy_sat_rnd_lh_s1,              // llvm.hexagon.M2.mpy.sat.rnd.lh.s1
+    hexagon_M2_mpy_sat_rnd_ll_s0,              // llvm.hexagon.M2.mpy.sat.rnd.ll.s0
+    hexagon_M2_mpy_sat_rnd_ll_s1,              // llvm.hexagon.M2.mpy.sat.rnd.ll.s1
+    hexagon_M2_mpy_up,                         // llvm.hexagon.M2.mpy.up
+    hexagon_M2_mpy_up_s1,                      // llvm.hexagon.M2.mpy.up.s1
+    hexagon_M2_mpy_up_s1_sat,                  // llvm.hexagon.M2.mpy.up.s1.sat
+    hexagon_M2_mpyd_acc_hh_s0,                 // llvm.hexagon.M2.mpyd.acc.hh.s0
+    hexagon_M2_mpyd_acc_hh_s1,                 // llvm.hexagon.M2.mpyd.acc.hh.s1
+    hexagon_M2_mpyd_acc_hl_s0,                 // llvm.hexagon.M2.mpyd.acc.hl.s0
+    hexagon_M2_mpyd_acc_hl_s1,                 // llvm.hexagon.M2.mpyd.acc.hl.s1
+    hexagon_M2_mpyd_acc_lh_s0,                 // llvm.hexagon.M2.mpyd.acc.lh.s0
+    hexagon_M2_mpyd_acc_lh_s1,                 // llvm.hexagon.M2.mpyd.acc.lh.s1
+    hexagon_M2_mpyd_acc_ll_s0,                 // llvm.hexagon.M2.mpyd.acc.ll.s0
+    hexagon_M2_mpyd_acc_ll_s1,                 // llvm.hexagon.M2.mpyd.acc.ll.s1
+    hexagon_M2_mpyd_hh_s0,                     // llvm.hexagon.M2.mpyd.hh.s0
+    hexagon_M2_mpyd_hh_s1,                     // llvm.hexagon.M2.mpyd.hh.s1
+    hexagon_M2_mpyd_hl_s0,                     // llvm.hexagon.M2.mpyd.hl.s0
+    hexagon_M2_mpyd_hl_s1,                     // llvm.hexagon.M2.mpyd.hl.s1
+    hexagon_M2_mpyd_lh_s0,                     // llvm.hexagon.M2.mpyd.lh.s0
+    hexagon_M2_mpyd_lh_s1,                     // llvm.hexagon.M2.mpyd.lh.s1
+    hexagon_M2_mpyd_ll_s0,                     // llvm.hexagon.M2.mpyd.ll.s0
+    hexagon_M2_mpyd_ll_s1,                     // llvm.hexagon.M2.mpyd.ll.s1
+    hexagon_M2_mpyd_nac_hh_s0,                 // llvm.hexagon.M2.mpyd.nac.hh.s0
+    hexagon_M2_mpyd_nac_hh_s1,                 // llvm.hexagon.M2.mpyd.nac.hh.s1
+    hexagon_M2_mpyd_nac_hl_s0,                 // llvm.hexagon.M2.mpyd.nac.hl.s0
+    hexagon_M2_mpyd_nac_hl_s1,                 // llvm.hexagon.M2.mpyd.nac.hl.s1
+    hexagon_M2_mpyd_nac_lh_s0,                 // llvm.hexagon.M2.mpyd.nac.lh.s0
+    hexagon_M2_mpyd_nac_lh_s1,                 // llvm.hexagon.M2.mpyd.nac.lh.s1
+    hexagon_M2_mpyd_nac_ll_s0,                 // llvm.hexagon.M2.mpyd.nac.ll.s0
+    hexagon_M2_mpyd_nac_ll_s1,                 // llvm.hexagon.M2.mpyd.nac.ll.s1
+    hexagon_M2_mpyd_rnd_hh_s0,                 // llvm.hexagon.M2.mpyd.rnd.hh.s0
+    hexagon_M2_mpyd_rnd_hh_s1,                 // llvm.hexagon.M2.mpyd.rnd.hh.s1
+    hexagon_M2_mpyd_rnd_hl_s0,                 // llvm.hexagon.M2.mpyd.rnd.hl.s0
+    hexagon_M2_mpyd_rnd_hl_s1,                 // llvm.hexagon.M2.mpyd.rnd.hl.s1
+    hexagon_M2_mpyd_rnd_lh_s0,                 // llvm.hexagon.M2.mpyd.rnd.lh.s0
+    hexagon_M2_mpyd_rnd_lh_s1,                 // llvm.hexagon.M2.mpyd.rnd.lh.s1
+    hexagon_M2_mpyd_rnd_ll_s0,                 // llvm.hexagon.M2.mpyd.rnd.ll.s0
+    hexagon_M2_mpyd_rnd_ll_s1,                 // llvm.hexagon.M2.mpyd.rnd.ll.s1
+    hexagon_M2_mpyi,                           // llvm.hexagon.M2.mpyi
+    hexagon_M2_mpysmi,                         // llvm.hexagon.M2.mpysmi
+    hexagon_M2_mpysu_up,                       // llvm.hexagon.M2.mpysu.up
+    hexagon_M2_mpyu_acc_hh_s0,                 // llvm.hexagon.M2.mpyu.acc.hh.s0
+    hexagon_M2_mpyu_acc_hh_s1,                 // llvm.hexagon.M2.mpyu.acc.hh.s1
+    hexagon_M2_mpyu_acc_hl_s0,                 // llvm.hexagon.M2.mpyu.acc.hl.s0
+    hexagon_M2_mpyu_acc_hl_s1,                 // llvm.hexagon.M2.mpyu.acc.hl.s1
+    hexagon_M2_mpyu_acc_lh_s0,                 // llvm.hexagon.M2.mpyu.acc.lh.s0
+    hexagon_M2_mpyu_acc_lh_s1,                 // llvm.hexagon.M2.mpyu.acc.lh.s1
+    hexagon_M2_mpyu_acc_ll_s0,                 // llvm.hexagon.M2.mpyu.acc.ll.s0
+    hexagon_M2_mpyu_acc_ll_s1,                 // llvm.hexagon.M2.mpyu.acc.ll.s1
+    hexagon_M2_mpyu_hh_s0,                     // llvm.hexagon.M2.mpyu.hh.s0
+    hexagon_M2_mpyu_hh_s1,                     // llvm.hexagon.M2.mpyu.hh.s1
+    hexagon_M2_mpyu_hl_s0,                     // llvm.hexagon.M2.mpyu.hl.s0
+    hexagon_M2_mpyu_hl_s1,                     // llvm.hexagon.M2.mpyu.hl.s1
+    hexagon_M2_mpyu_lh_s0,                     // llvm.hexagon.M2.mpyu.lh.s0
+    hexagon_M2_mpyu_lh_s1,                     // llvm.hexagon.M2.mpyu.lh.s1
+    hexagon_M2_mpyu_ll_s0,                     // llvm.hexagon.M2.mpyu.ll.s0
+    hexagon_M2_mpyu_ll_s1,                     // llvm.hexagon.M2.mpyu.ll.s1
+    hexagon_M2_mpyu_nac_hh_s0,                 // llvm.hexagon.M2.mpyu.nac.hh.s0
+    hexagon_M2_mpyu_nac_hh_s1,                 // llvm.hexagon.M2.mpyu.nac.hh.s1
+    hexagon_M2_mpyu_nac_hl_s0,                 // llvm.hexagon.M2.mpyu.nac.hl.s0
+    hexagon_M2_mpyu_nac_hl_s1,                 // llvm.hexagon.M2.mpyu.nac.hl.s1
+    hexagon_M2_mpyu_nac_lh_s0,                 // llvm.hexagon.M2.mpyu.nac.lh.s0
+    hexagon_M2_mpyu_nac_lh_s1,                 // llvm.hexagon.M2.mpyu.nac.lh.s1
+    hexagon_M2_mpyu_nac_ll_s0,                 // llvm.hexagon.M2.mpyu.nac.ll.s0
+    hexagon_M2_mpyu_nac_ll_s1,                 // llvm.hexagon.M2.mpyu.nac.ll.s1
+    hexagon_M2_mpyu_up,                        // llvm.hexagon.M2.mpyu.up
+    hexagon_M2_mpyud_acc_hh_s0,                // llvm.hexagon.M2.mpyud.acc.hh.s0
+    hexagon_M2_mpyud_acc_hh_s1,                // llvm.hexagon.M2.mpyud.acc.hh.s1
+    hexagon_M2_mpyud_acc_hl_s0,                // llvm.hexagon.M2.mpyud.acc.hl.s0
+    hexagon_M2_mpyud_acc_hl_s1,                // llvm.hexagon.M2.mpyud.acc.hl.s1
+    hexagon_M2_mpyud_acc_lh_s0,                // llvm.hexagon.M2.mpyud.acc.lh.s0
+    hexagon_M2_mpyud_acc_lh_s1,                // llvm.hexagon.M2.mpyud.acc.lh.s1
+    hexagon_M2_mpyud_acc_ll_s0,                // llvm.hexagon.M2.mpyud.acc.ll.s0
+    hexagon_M2_mpyud_acc_ll_s1,                // llvm.hexagon.M2.mpyud.acc.ll.s1
+    hexagon_M2_mpyud_hh_s0,                    // llvm.hexagon.M2.mpyud.hh.s0
+    hexagon_M2_mpyud_hh_s1,                    // llvm.hexagon.M2.mpyud.hh.s1
+    hexagon_M2_mpyud_hl_s0,                    // llvm.hexagon.M2.mpyud.hl.s0
+    hexagon_M2_mpyud_hl_s1,                    // llvm.hexagon.M2.mpyud.hl.s1
+    hexagon_M2_mpyud_lh_s0,                    // llvm.hexagon.M2.mpyud.lh.s0
+    hexagon_M2_mpyud_lh_s1,                    // llvm.hexagon.M2.mpyud.lh.s1
+    hexagon_M2_mpyud_ll_s0,                    // llvm.hexagon.M2.mpyud.ll.s0
+    hexagon_M2_mpyud_ll_s1,                    // llvm.hexagon.M2.mpyud.ll.s1
+    hexagon_M2_mpyud_nac_hh_s0,                // llvm.hexagon.M2.mpyud.nac.hh.s0
+    hexagon_M2_mpyud_nac_hh_s1,                // llvm.hexagon.M2.mpyud.nac.hh.s1
+    hexagon_M2_mpyud_nac_hl_s0,                // llvm.hexagon.M2.mpyud.nac.hl.s0
+    hexagon_M2_mpyud_nac_hl_s1,                // llvm.hexagon.M2.mpyud.nac.hl.s1
+    hexagon_M2_mpyud_nac_lh_s0,                // llvm.hexagon.M2.mpyud.nac.lh.s0
+    hexagon_M2_mpyud_nac_lh_s1,                // llvm.hexagon.M2.mpyud.nac.lh.s1
+    hexagon_M2_mpyud_nac_ll_s0,                // llvm.hexagon.M2.mpyud.nac.ll.s0
+    hexagon_M2_mpyud_nac_ll_s1,                // llvm.hexagon.M2.mpyud.nac.ll.s1
+    hexagon_M2_mpyui,                          // llvm.hexagon.M2.mpyui
+    hexagon_M2_nacci,                          // llvm.hexagon.M2.nacci
+    hexagon_M2_naccii,                         // llvm.hexagon.M2.naccii
+    hexagon_M2_subacc,                         // llvm.hexagon.M2.subacc
+    hexagon_M2_vabsdiffh,                      // llvm.hexagon.M2.vabsdiffh
+    hexagon_M2_vabsdiffw,                      // llvm.hexagon.M2.vabsdiffw
+    hexagon_M2_vcmac_s0_sat_i,                 // llvm.hexagon.M2.vcmac.s0.sat.i
+    hexagon_M2_vcmac_s0_sat_r,                 // llvm.hexagon.M2.vcmac.s0.sat.r
+    hexagon_M2_vcmpy_s0_sat_i,                 // llvm.hexagon.M2.vcmpy.s0.sat.i
+    hexagon_M2_vcmpy_s0_sat_r,                 // llvm.hexagon.M2.vcmpy.s0.sat.r
+    hexagon_M2_vcmpy_s1_sat_i,                 // llvm.hexagon.M2.vcmpy.s1.sat.i
+    hexagon_M2_vcmpy_s1_sat_r,                 // llvm.hexagon.M2.vcmpy.s1.sat.r
+    hexagon_M2_vdmacs_s0,                      // llvm.hexagon.M2.vdmacs.s0
+    hexagon_M2_vdmacs_s1,                      // llvm.hexagon.M2.vdmacs.s1
+    hexagon_M2_vdmpyrs_s0,                     // llvm.hexagon.M2.vdmpyrs.s0
+    hexagon_M2_vdmpyrs_s1,                     // llvm.hexagon.M2.vdmpyrs.s1
+    hexagon_M2_vdmpys_s0,                      // llvm.hexagon.M2.vdmpys.s0
+    hexagon_M2_vdmpys_s1,                      // llvm.hexagon.M2.vdmpys.s1
+    hexagon_M2_vmac2,                          // llvm.hexagon.M2.vmac2
+    hexagon_M2_vmac2es,                        // llvm.hexagon.M2.vmac2es
+    hexagon_M2_vmac2es_s0,                     // llvm.hexagon.M2.vmac2es.s0
+    hexagon_M2_vmac2es_s1,                     // llvm.hexagon.M2.vmac2es.s1
+    hexagon_M2_vmac2s_s0,                      // llvm.hexagon.M2.vmac2s.s0
+    hexagon_M2_vmac2s_s1,                      // llvm.hexagon.M2.vmac2s.s1
+    hexagon_M2_vmac2su_s0,                     // llvm.hexagon.M2.vmac2su.s0
+    hexagon_M2_vmac2su_s1,                     // llvm.hexagon.M2.vmac2su.s1
+    hexagon_M2_vmpy2es_s0,                     // llvm.hexagon.M2.vmpy2es.s0
+    hexagon_M2_vmpy2es_s1,                     // llvm.hexagon.M2.vmpy2es.s1
+    hexagon_M2_vmpy2s_s0,                      // llvm.hexagon.M2.vmpy2s.s0
+    hexagon_M2_vmpy2s_s0pack,                  // llvm.hexagon.M2.vmpy2s.s0pack
+    hexagon_M2_vmpy2s_s1,                      // llvm.hexagon.M2.vmpy2s.s1
+    hexagon_M2_vmpy2s_s1pack,                  // llvm.hexagon.M2.vmpy2s.s1pack
+    hexagon_M2_vmpy2su_s0,                     // llvm.hexagon.M2.vmpy2su.s0
+    hexagon_M2_vmpy2su_s1,                     // llvm.hexagon.M2.vmpy2su.s1
+    hexagon_M2_vraddh,                         // llvm.hexagon.M2.vraddh
+    hexagon_M2_vradduh,                        // llvm.hexagon.M2.vradduh
+    hexagon_M2_vrcmaci_s0,                     // llvm.hexagon.M2.vrcmaci.s0
+    hexagon_M2_vrcmaci_s0c,                    // llvm.hexagon.M2.vrcmaci.s0c
+    hexagon_M2_vrcmacr_s0,                     // llvm.hexagon.M2.vrcmacr.s0
+    hexagon_M2_vrcmacr_s0c,                    // llvm.hexagon.M2.vrcmacr.s0c
+    hexagon_M2_vrcmpyi_s0,                     // llvm.hexagon.M2.vrcmpyi.s0
+    hexagon_M2_vrcmpyi_s0c,                    // llvm.hexagon.M2.vrcmpyi.s0c
+    hexagon_M2_vrcmpyr_s0,                     // llvm.hexagon.M2.vrcmpyr.s0
+    hexagon_M2_vrcmpyr_s0c,                    // llvm.hexagon.M2.vrcmpyr.s0c
+    hexagon_M2_vrcmpys_acc_s1,                 // llvm.hexagon.M2.vrcmpys.acc.s1
+    hexagon_M2_vrcmpys_s1,                     // llvm.hexagon.M2.vrcmpys.s1
+    hexagon_M2_vrcmpys_s1rp,                   // llvm.hexagon.M2.vrcmpys.s1rp
+    hexagon_M2_vrmac_s0,                       // llvm.hexagon.M2.vrmac.s0
+    hexagon_M2_vrmpy_s0,                       // llvm.hexagon.M2.vrmpy.s0
+    hexagon_M2_xor_xacc,                       // llvm.hexagon.M2.xor.xacc
+    hexagon_M4_and_and,                        // llvm.hexagon.M4.and.and
+    hexagon_M4_and_andn,                       // llvm.hexagon.M4.and.andn
+    hexagon_M4_and_or,                         // llvm.hexagon.M4.and.or
+    hexagon_M4_and_xor,                        // llvm.hexagon.M4.and.xor
+    hexagon_M4_cmpyi_wh,                       // llvm.hexagon.M4.cmpyi.wh
+    hexagon_M4_cmpyi_whc,                      // llvm.hexagon.M4.cmpyi.whc
+    hexagon_M4_cmpyr_wh,                       // llvm.hexagon.M4.cmpyr.wh
+    hexagon_M4_cmpyr_whc,                      // llvm.hexagon.M4.cmpyr.whc
+    hexagon_M4_mac_up_s1_sat,                  // llvm.hexagon.M4.mac.up.s1.sat
+    hexagon_M4_mpyri_addi,                     // llvm.hexagon.M4.mpyri.addi
+    hexagon_M4_mpyri_addr,                     // llvm.hexagon.M4.mpyri.addr
+    hexagon_M4_mpyri_addr_u2,                  // llvm.hexagon.M4.mpyri.addr.u2
+    hexagon_M4_mpyrr_addi,                     // llvm.hexagon.M4.mpyrr.addi
+    hexagon_M4_mpyrr_addr,                     // llvm.hexagon.M4.mpyrr.addr
+    hexagon_M4_nac_up_s1_sat,                  // llvm.hexagon.M4.nac.up.s1.sat
+    hexagon_M4_or_and,                         // llvm.hexagon.M4.or.and
+    hexagon_M4_or_andn,                        // llvm.hexagon.M4.or.andn
+    hexagon_M4_or_or,                          // llvm.hexagon.M4.or.or
+    hexagon_M4_or_xor,                         // llvm.hexagon.M4.or.xor
+    hexagon_M4_pmpyw,                          // llvm.hexagon.M4.pmpyw
+    hexagon_M4_pmpyw_acc,                      // llvm.hexagon.M4.pmpyw.acc
+    hexagon_M4_vpmpyh,                         // llvm.hexagon.M4.vpmpyh
+    hexagon_M4_vpmpyh_acc,                     // llvm.hexagon.M4.vpmpyh.acc
+    hexagon_M4_vrmpyeh_acc_s0,                 // llvm.hexagon.M4.vrmpyeh.acc.s0
+    hexagon_M4_vrmpyeh_acc_s1,                 // llvm.hexagon.M4.vrmpyeh.acc.s1
+    hexagon_M4_vrmpyeh_s0,                     // llvm.hexagon.M4.vrmpyeh.s0
+    hexagon_M4_vrmpyeh_s1,                     // llvm.hexagon.M4.vrmpyeh.s1
+    hexagon_M4_vrmpyoh_acc_s0,                 // llvm.hexagon.M4.vrmpyoh.acc.s0
+    hexagon_M4_vrmpyoh_acc_s1,                 // llvm.hexagon.M4.vrmpyoh.acc.s1
+    hexagon_M4_vrmpyoh_s0,                     // llvm.hexagon.M4.vrmpyoh.s0
+    hexagon_M4_vrmpyoh_s1,                     // llvm.hexagon.M4.vrmpyoh.s1
+    hexagon_M4_xor_and,                        // llvm.hexagon.M4.xor.and
+    hexagon_M4_xor_andn,                       // llvm.hexagon.M4.xor.andn
+    hexagon_M4_xor_or,                         // llvm.hexagon.M4.xor.or
+    hexagon_M4_xor_xacc,                       // llvm.hexagon.M4.xor.xacc
+    hexagon_M5_vdmacbsu,                       // llvm.hexagon.M5.vdmacbsu
+    hexagon_M5_vdmpybsu,                       // llvm.hexagon.M5.vdmpybsu
+    hexagon_M5_vmacbsu,                        // llvm.hexagon.M5.vmacbsu
+    hexagon_M5_vmacbuu,                        // llvm.hexagon.M5.vmacbuu
+    hexagon_M5_vmpybsu,                        // llvm.hexagon.M5.vmpybsu
+    hexagon_M5_vmpybuu,                        // llvm.hexagon.M5.vmpybuu
+    hexagon_M5_vrmacbsu,                       // llvm.hexagon.M5.vrmacbsu
+    hexagon_M5_vrmacbuu,                       // llvm.hexagon.M5.vrmacbuu
+    hexagon_M5_vrmpybsu,                       // llvm.hexagon.M5.vrmpybsu
+    hexagon_M5_vrmpybuu,                       // llvm.hexagon.M5.vrmpybuu
+    hexagon_M6_vabsdiffb,                      // llvm.hexagon.M6.vabsdiffb
+    hexagon_M6_vabsdiffub,                     // llvm.hexagon.M6.vabsdiffub
+    hexagon_M7_dcmpyiw,                        // llvm.hexagon.M7.dcmpyiw
+    hexagon_M7_dcmpyiw_acc,                    // llvm.hexagon.M7.dcmpyiw.acc
+    hexagon_M7_dcmpyiwc,                       // llvm.hexagon.M7.dcmpyiwc
+    hexagon_M7_dcmpyiwc_acc,                   // llvm.hexagon.M7.dcmpyiwc.acc
+    hexagon_M7_dcmpyrw,                        // llvm.hexagon.M7.dcmpyrw
+    hexagon_M7_dcmpyrw_acc,                    // llvm.hexagon.M7.dcmpyrw.acc
+    hexagon_M7_dcmpyrwc,                       // llvm.hexagon.M7.dcmpyrwc
+    hexagon_M7_dcmpyrwc_acc,                   // llvm.hexagon.M7.dcmpyrwc.acc
+    hexagon_M7_vdmpy,                          // llvm.hexagon.M7.vdmpy
+    hexagon_M7_vdmpy_acc,                      // llvm.hexagon.M7.vdmpy.acc
+    hexagon_M7_wcmpyiw,                        // llvm.hexagon.M7.wcmpyiw
+    hexagon_M7_wcmpyiw_rnd,                    // llvm.hexagon.M7.wcmpyiw.rnd
+    hexagon_M7_wcmpyiwc,                       // llvm.hexagon.M7.wcmpyiwc
+    hexagon_M7_wcmpyiwc_rnd,                   // llvm.hexagon.M7.wcmpyiwc.rnd
+    hexagon_M7_wcmpyrw,                        // llvm.hexagon.M7.wcmpyrw
+    hexagon_M7_wcmpyrw_rnd,                    // llvm.hexagon.M7.wcmpyrw.rnd
+    hexagon_M7_wcmpyrwc,                       // llvm.hexagon.M7.wcmpyrwc
+    hexagon_M7_wcmpyrwc_rnd,                   // llvm.hexagon.M7.wcmpyrwc.rnd
+    hexagon_S2_addasl_rrri,                    // llvm.hexagon.S2.addasl.rrri
+    hexagon_S2_asl_i_p,                        // llvm.hexagon.S2.asl.i.p
+    hexagon_S2_asl_i_p_acc,                    // llvm.hexagon.S2.asl.i.p.acc
+    hexagon_S2_asl_i_p_and,                    // llvm.hexagon.S2.asl.i.p.and
+    hexagon_S2_asl_i_p_nac,                    // llvm.hexagon.S2.asl.i.p.nac
+    hexagon_S2_asl_i_p_or,                     // llvm.hexagon.S2.asl.i.p.or
+    hexagon_S2_asl_i_p_xacc,                   // llvm.hexagon.S2.asl.i.p.xacc
+    hexagon_S2_asl_i_r,                        // llvm.hexagon.S2.asl.i.r
+    hexagon_S2_asl_i_r_acc,                    // llvm.hexagon.S2.asl.i.r.acc
+    hexagon_S2_asl_i_r_and,                    // llvm.hexagon.S2.asl.i.r.and
+    hexagon_S2_asl_i_r_nac,                    // llvm.hexagon.S2.asl.i.r.nac
+    hexagon_S2_asl_i_r_or,                     // llvm.hexagon.S2.asl.i.r.or
+    hexagon_S2_asl_i_r_sat,                    // llvm.hexagon.S2.asl.i.r.sat
+    hexagon_S2_asl_i_r_xacc,                   // llvm.hexagon.S2.asl.i.r.xacc
+    hexagon_S2_asl_i_vh,                       // llvm.hexagon.S2.asl.i.vh
+    hexagon_S2_asl_i_vw,                       // llvm.hexagon.S2.asl.i.vw
+    hexagon_S2_asl_r_p,                        // llvm.hexagon.S2.asl.r.p
+    hexagon_S2_asl_r_p_acc,                    // llvm.hexagon.S2.asl.r.p.acc
+    hexagon_S2_asl_r_p_and,                    // llvm.hexagon.S2.asl.r.p.and
+    hexagon_S2_asl_r_p_nac,                    // llvm.hexagon.S2.asl.r.p.nac
+    hexagon_S2_asl_r_p_or,                     // llvm.hexagon.S2.asl.r.p.or
+    hexagon_S2_asl_r_p_xor,                    // llvm.hexagon.S2.asl.r.p.xor
+    hexagon_S2_asl_r_r,                        // llvm.hexagon.S2.asl.r.r
+    hexagon_S2_asl_r_r_acc,                    // llvm.hexagon.S2.asl.r.r.acc
+    hexagon_S2_asl_r_r_and,                    // llvm.hexagon.S2.asl.r.r.and
+    hexagon_S2_asl_r_r_nac,                    // llvm.hexagon.S2.asl.r.r.nac
+    hexagon_S2_asl_r_r_or,                     // llvm.hexagon.S2.asl.r.r.or
+    hexagon_S2_asl_r_r_sat,                    // llvm.hexagon.S2.asl.r.r.sat
+    hexagon_S2_asl_r_vh,                       // llvm.hexagon.S2.asl.r.vh
+    hexagon_S2_asl_r_vw,                       // llvm.hexagon.S2.asl.r.vw
+    hexagon_S2_asr_i_p,                        // llvm.hexagon.S2.asr.i.p
+    hexagon_S2_asr_i_p_acc,                    // llvm.hexagon.S2.asr.i.p.acc
+    hexagon_S2_asr_i_p_and,                    // llvm.hexagon.S2.asr.i.p.and
+    hexagon_S2_asr_i_p_nac,                    // llvm.hexagon.S2.asr.i.p.nac
+    hexagon_S2_asr_i_p_or,                     // llvm.hexagon.S2.asr.i.p.or
+    hexagon_S2_asr_i_p_rnd,                    // llvm.hexagon.S2.asr.i.p.rnd
+    hexagon_S2_asr_i_p_rnd_goodsyntax,         // llvm.hexagon.S2.asr.i.p.rnd.goodsyntax
+    hexagon_S2_asr_i_r,                        // llvm.hexagon.S2.asr.i.r
+    hexagon_S2_asr_i_r_acc,                    // llvm.hexagon.S2.asr.i.r.acc
+    hexagon_S2_asr_i_r_and,                    // llvm.hexagon.S2.asr.i.r.and
+    hexagon_S2_asr_i_r_nac,                    // llvm.hexagon.S2.asr.i.r.nac
+    hexagon_S2_asr_i_r_or,                     // llvm.hexagon.S2.asr.i.r.or
+    hexagon_S2_asr_i_r_rnd,                    // llvm.hexagon.S2.asr.i.r.rnd
+    hexagon_S2_asr_i_r_rnd_goodsyntax,         // llvm.hexagon.S2.asr.i.r.rnd.goodsyntax
+    hexagon_S2_asr_i_svw_trun,                 // llvm.hexagon.S2.asr.i.svw.trun
+    hexagon_S2_asr_i_vh,                       // llvm.hexagon.S2.asr.i.vh
+    hexagon_S2_asr_i_vw,                       // llvm.hexagon.S2.asr.i.vw
+    hexagon_S2_asr_r_p,                        // llvm.hexagon.S2.asr.r.p
+    hexagon_S2_asr_r_p_acc,                    // llvm.hexagon.S2.asr.r.p.acc
+    hexagon_S2_asr_r_p_and,                    // llvm.hexagon.S2.asr.r.p.and
+    hexagon_S2_asr_r_p_nac,                    // llvm.hexagon.S2.asr.r.p.nac
+    hexagon_S2_asr_r_p_or,                     // llvm.hexagon.S2.asr.r.p.or
+    hexagon_S2_asr_r_p_xor,                    // llvm.hexagon.S2.asr.r.p.xor
+    hexagon_S2_asr_r_r,                        // llvm.hexagon.S2.asr.r.r
+    hexagon_S2_asr_r_r_acc,                    // llvm.hexagon.S2.asr.r.r.acc
+    hexagon_S2_asr_r_r_and,                    // llvm.hexagon.S2.asr.r.r.and
+    hexagon_S2_asr_r_r_nac,                    // llvm.hexagon.S2.asr.r.r.nac
+    hexagon_S2_asr_r_r_or,                     // llvm.hexagon.S2.asr.r.r.or
+    hexagon_S2_asr_r_r_sat,                    // llvm.hexagon.S2.asr.r.r.sat
+    hexagon_S2_asr_r_svw_trun,                 // llvm.hexagon.S2.asr.r.svw.trun
+    hexagon_S2_asr_r_vh,                       // llvm.hexagon.S2.asr.r.vh
+    hexagon_S2_asr_r_vw,                       // llvm.hexagon.S2.asr.r.vw
+    hexagon_S2_brev,                           // llvm.hexagon.S2.brev
+    hexagon_S2_brevp,                          // llvm.hexagon.S2.brevp
+    hexagon_S2_cl0,                            // llvm.hexagon.S2.cl0
+    hexagon_S2_cl0p,                           // llvm.hexagon.S2.cl0p
+    hexagon_S2_cl1,                            // llvm.hexagon.S2.cl1
+    hexagon_S2_cl1p,                           // llvm.hexagon.S2.cl1p
+    hexagon_S2_clb,                            // llvm.hexagon.S2.clb
+    hexagon_S2_clbnorm,                        // llvm.hexagon.S2.clbnorm
+    hexagon_S2_clbp,                           // llvm.hexagon.S2.clbp
+    hexagon_S2_clrbit_i,                       // llvm.hexagon.S2.clrbit.i
+    hexagon_S2_clrbit_r,                       // llvm.hexagon.S2.clrbit.r
+    hexagon_S2_ct0,                            // llvm.hexagon.S2.ct0
+    hexagon_S2_ct0p,                           // llvm.hexagon.S2.ct0p
+    hexagon_S2_ct1,                            // llvm.hexagon.S2.ct1
+    hexagon_S2_ct1p,                           // llvm.hexagon.S2.ct1p
+    hexagon_S2_deinterleave,                   // llvm.hexagon.S2.deinterleave
+    hexagon_S2_extractu,                       // llvm.hexagon.S2.extractu
+    hexagon_S2_extractu_rp,                    // llvm.hexagon.S2.extractu.rp
+    hexagon_S2_extractup,                      // llvm.hexagon.S2.extractup
+    hexagon_S2_extractup_rp,                   // llvm.hexagon.S2.extractup.rp
+    hexagon_S2_insert,                         // llvm.hexagon.S2.insert
+    hexagon_S2_insert_rp,                      // llvm.hexagon.S2.insert.rp
+    hexagon_S2_insertp,                        // llvm.hexagon.S2.insertp
+    hexagon_S2_insertp_rp,                     // llvm.hexagon.S2.insertp.rp
+    hexagon_S2_interleave,                     // llvm.hexagon.S2.interleave
+    hexagon_S2_lfsp,                           // llvm.hexagon.S2.lfsp
+    hexagon_S2_lsl_r_p,                        // llvm.hexagon.S2.lsl.r.p
+    hexagon_S2_lsl_r_p_acc,                    // llvm.hexagon.S2.lsl.r.p.acc
+    hexagon_S2_lsl_r_p_and,                    // llvm.hexagon.S2.lsl.r.p.and
+    hexagon_S2_lsl_r_p_nac,                    // llvm.hexagon.S2.lsl.r.p.nac
+    hexagon_S2_lsl_r_p_or,                     // llvm.hexagon.S2.lsl.r.p.or
+    hexagon_S2_lsl_r_p_xor,                    // llvm.hexagon.S2.lsl.r.p.xor
+    hexagon_S2_lsl_r_r,                        // llvm.hexagon.S2.lsl.r.r
+    hexagon_S2_lsl_r_r_acc,                    // llvm.hexagon.S2.lsl.r.r.acc
+    hexagon_S2_lsl_r_r_and,                    // llvm.hexagon.S2.lsl.r.r.and
+    hexagon_S2_lsl_r_r_nac,                    // llvm.hexagon.S2.lsl.r.r.nac
+    hexagon_S2_lsl_r_r_or,                     // llvm.hexagon.S2.lsl.r.r.or
+    hexagon_S2_lsl_r_vh,                       // llvm.hexagon.S2.lsl.r.vh
+    hexagon_S2_lsl_r_vw,                       // llvm.hexagon.S2.lsl.r.vw
+    hexagon_S2_lsr_i_p,                        // llvm.hexagon.S2.lsr.i.p
+    hexagon_S2_lsr_i_p_acc,                    // llvm.hexagon.S2.lsr.i.p.acc
+    hexagon_S2_lsr_i_p_and,                    // llvm.hexagon.S2.lsr.i.p.and
+    hexagon_S2_lsr_i_p_nac,                    // llvm.hexagon.S2.lsr.i.p.nac
+    hexagon_S2_lsr_i_p_or,                     // llvm.hexagon.S2.lsr.i.p.or
+    hexagon_S2_lsr_i_p_xacc,                   // llvm.hexagon.S2.lsr.i.p.xacc
+    hexagon_S2_lsr_i_r,                        // llvm.hexagon.S2.lsr.i.r
+    hexagon_S2_lsr_i_r_acc,                    // llvm.hexagon.S2.lsr.i.r.acc
+    hexagon_S2_lsr_i_r_and,                    // llvm.hexagon.S2.lsr.i.r.and
+    hexagon_S2_lsr_i_r_nac,                    // llvm.hexagon.S2.lsr.i.r.nac
+    hexagon_S2_lsr_i_r_or,                     // llvm.hexagon.S2.lsr.i.r.or
+    hexagon_S2_lsr_i_r_xacc,                   // llvm.hexagon.S2.lsr.i.r.xacc
+    hexagon_S2_lsr_i_vh,                       // llvm.hexagon.S2.lsr.i.vh
+    hexagon_S2_lsr_i_vw,                       // llvm.hexagon.S2.lsr.i.vw
+    hexagon_S2_lsr_r_p,                        // llvm.hexagon.S2.lsr.r.p
+    hexagon_S2_lsr_r_p_acc,                    // llvm.hexagon.S2.lsr.r.p.acc
+    hexagon_S2_lsr_r_p_and,                    // llvm.hexagon.S2.lsr.r.p.and
+    hexagon_S2_lsr_r_p_nac,                    // llvm.hexagon.S2.lsr.r.p.nac
+    hexagon_S2_lsr_r_p_or,                     // llvm.hexagon.S2.lsr.r.p.or
+    hexagon_S2_lsr_r_p_xor,                    // llvm.hexagon.S2.lsr.r.p.xor
+    hexagon_S2_lsr_r_r,                        // llvm.hexagon.S2.lsr.r.r
+    hexagon_S2_lsr_r_r_acc,                    // llvm.hexagon.S2.lsr.r.r.acc
+    hexagon_S2_lsr_r_r_and,                    // llvm.hexagon.S2.lsr.r.r.and
+    hexagon_S2_lsr_r_r_nac,                    // llvm.hexagon.S2.lsr.r.r.nac
+    hexagon_S2_lsr_r_r_or,                     // llvm.hexagon.S2.lsr.r.r.or
+    hexagon_S2_lsr_r_vh,                       // llvm.hexagon.S2.lsr.r.vh
+    hexagon_S2_lsr_r_vw,                       // llvm.hexagon.S2.lsr.r.vw
+    hexagon_S2_mask,                           // llvm.hexagon.S2.mask
+    hexagon_S2_packhl,                         // llvm.hexagon.S2.packhl
+    hexagon_S2_parityp,                        // llvm.hexagon.S2.parityp
+    hexagon_S2_setbit_i,                       // llvm.hexagon.S2.setbit.i
+    hexagon_S2_setbit_r,                       // llvm.hexagon.S2.setbit.r
+    hexagon_S2_shuffeb,                        // llvm.hexagon.S2.shuffeb
+    hexagon_S2_shuffeh,                        // llvm.hexagon.S2.shuffeh
+    hexagon_S2_shuffob,                        // llvm.hexagon.S2.shuffob
+    hexagon_S2_shuffoh,                        // llvm.hexagon.S2.shuffoh
+    hexagon_S2_storerb_pbr,                    // llvm.hexagon.S2.storerb.pbr
+    hexagon_S2_storerb_pci,                    // llvm.hexagon.S2.storerb.pci
+    hexagon_S2_storerb_pcr,                    // llvm.hexagon.S2.storerb.pcr
+    hexagon_S2_storerd_pbr,                    // llvm.hexagon.S2.storerd.pbr
+    hexagon_S2_storerd_pci,                    // llvm.hexagon.S2.storerd.pci
+    hexagon_S2_storerd_pcr,                    // llvm.hexagon.S2.storerd.pcr
+    hexagon_S2_storerf_pbr,                    // llvm.hexagon.S2.storerf.pbr
+    hexagon_S2_storerf_pci,                    // llvm.hexagon.S2.storerf.pci
+    hexagon_S2_storerf_pcr,                    // llvm.hexagon.S2.storerf.pcr
+    hexagon_S2_storerh_pbr,                    // llvm.hexagon.S2.storerh.pbr
+    hexagon_S2_storerh_pci,                    // llvm.hexagon.S2.storerh.pci
+    hexagon_S2_storerh_pcr,                    // llvm.hexagon.S2.storerh.pcr
+    hexagon_S2_storeri_pbr,                    // llvm.hexagon.S2.storeri.pbr
+    hexagon_S2_storeri_pci,                    // llvm.hexagon.S2.storeri.pci
+    hexagon_S2_storeri_pcr,                    // llvm.hexagon.S2.storeri.pcr
+    hexagon_S2_storew_locked,                  // llvm.hexagon.S2.storew.locked
+    hexagon_S2_svsathb,                        // llvm.hexagon.S2.svsathb
+    hexagon_S2_svsathub,                       // llvm.hexagon.S2.svsathub
+    hexagon_S2_tableidxb_goodsyntax,           // llvm.hexagon.S2.tableidxb.goodsyntax
+    hexagon_S2_tableidxd_goodsyntax,           // llvm.hexagon.S2.tableidxd.goodsyntax
+    hexagon_S2_tableidxh_goodsyntax,           // llvm.hexagon.S2.tableidxh.goodsyntax
+    hexagon_S2_tableidxw_goodsyntax,           // llvm.hexagon.S2.tableidxw.goodsyntax
+    hexagon_S2_togglebit_i,                    // llvm.hexagon.S2.togglebit.i
+    hexagon_S2_togglebit_r,                    // llvm.hexagon.S2.togglebit.r
+    hexagon_S2_tstbit_i,                       // llvm.hexagon.S2.tstbit.i
+    hexagon_S2_tstbit_r,                       // llvm.hexagon.S2.tstbit.r
+    hexagon_S2_valignib,                       // llvm.hexagon.S2.valignib
+    hexagon_S2_valignrb,                       // llvm.hexagon.S2.valignrb
+    hexagon_S2_vcnegh,                         // llvm.hexagon.S2.vcnegh
+    hexagon_S2_vcrotate,                       // llvm.hexagon.S2.vcrotate
+    hexagon_S2_vrcnegh,                        // llvm.hexagon.S2.vrcnegh
+    hexagon_S2_vrndpackwh,                     // llvm.hexagon.S2.vrndpackwh
+    hexagon_S2_vrndpackwhs,                    // llvm.hexagon.S2.vrndpackwhs
+    hexagon_S2_vsathb,                         // llvm.hexagon.S2.vsathb
+    hexagon_S2_vsathb_nopack,                  // llvm.hexagon.S2.vsathb.nopack
+    hexagon_S2_vsathub,                        // llvm.hexagon.S2.vsathub
+    hexagon_S2_vsathub_nopack,                 // llvm.hexagon.S2.vsathub.nopack
+    hexagon_S2_vsatwh,                         // llvm.hexagon.S2.vsatwh
+    hexagon_S2_vsatwh_nopack,                  // llvm.hexagon.S2.vsatwh.nopack
+    hexagon_S2_vsatwuh,                        // llvm.hexagon.S2.vsatwuh
+    hexagon_S2_vsatwuh_nopack,                 // llvm.hexagon.S2.vsatwuh.nopack
+    hexagon_S2_vsplatrb,                       // llvm.hexagon.S2.vsplatrb
+    hexagon_S2_vsplatrh,                       // llvm.hexagon.S2.vsplatrh
+    hexagon_S2_vspliceib,                      // llvm.hexagon.S2.vspliceib
+    hexagon_S2_vsplicerb,                      // llvm.hexagon.S2.vsplicerb
+    hexagon_S2_vsxtbh,                         // llvm.hexagon.S2.vsxtbh
+    hexagon_S2_vsxthw,                         // llvm.hexagon.S2.vsxthw
+    hexagon_S2_vtrunehb,                       // llvm.hexagon.S2.vtrunehb
+    hexagon_S2_vtrunewh,                       // llvm.hexagon.S2.vtrunewh
+    hexagon_S2_vtrunohb,                       // llvm.hexagon.S2.vtrunohb
+    hexagon_S2_vtrunowh,                       // llvm.hexagon.S2.vtrunowh
+    hexagon_S2_vzxtbh,                         // llvm.hexagon.S2.vzxtbh
+    hexagon_S2_vzxthw,                         // llvm.hexagon.S2.vzxthw
+    hexagon_S4_addaddi,                        // llvm.hexagon.S4.addaddi
+    hexagon_S4_addi_asl_ri,                    // llvm.hexagon.S4.addi.asl.ri
+    hexagon_S4_addi_lsr_ri,                    // llvm.hexagon.S4.addi.lsr.ri
+    hexagon_S4_andi_asl_ri,                    // llvm.hexagon.S4.andi.asl.ri
+    hexagon_S4_andi_lsr_ri,                    // llvm.hexagon.S4.andi.lsr.ri
+    hexagon_S4_clbaddi,                        // llvm.hexagon.S4.clbaddi
+    hexagon_S4_clbpaddi,                       // llvm.hexagon.S4.clbpaddi
+    hexagon_S4_clbpnorm,                       // llvm.hexagon.S4.clbpnorm
+    hexagon_S4_extract,                        // llvm.hexagon.S4.extract
+    hexagon_S4_extract_rp,                     // llvm.hexagon.S4.extract.rp
+    hexagon_S4_extractp,                       // llvm.hexagon.S4.extractp
+    hexagon_S4_extractp_rp,                    // llvm.hexagon.S4.extractp.rp
+    hexagon_S4_lsli,                           // llvm.hexagon.S4.lsli
+    hexagon_S4_ntstbit_i,                      // llvm.hexagon.S4.ntstbit.i
+    hexagon_S4_ntstbit_r,                      // llvm.hexagon.S4.ntstbit.r
+    hexagon_S4_or_andi,                        // llvm.hexagon.S4.or.andi
+    hexagon_S4_or_andix,                       // llvm.hexagon.S4.or.andix
+    hexagon_S4_or_ori,                         // llvm.hexagon.S4.or.ori
+    hexagon_S4_ori_asl_ri,                     // llvm.hexagon.S4.ori.asl.ri
+    hexagon_S4_ori_lsr_ri,                     // llvm.hexagon.S4.ori.lsr.ri
+    hexagon_S4_parity,                         // llvm.hexagon.S4.parity
+    hexagon_S4_stored_locked,                  // llvm.hexagon.S4.stored.locked
+    hexagon_S4_subaddi,                        // llvm.hexagon.S4.subaddi
+    hexagon_S4_subi_asl_ri,                    // llvm.hexagon.S4.subi.asl.ri
+    hexagon_S4_subi_lsr_ri,                    // llvm.hexagon.S4.subi.lsr.ri
+    hexagon_S4_vrcrotate,                      // llvm.hexagon.S4.vrcrotate
+    hexagon_S4_vrcrotate_acc,                  // llvm.hexagon.S4.vrcrotate.acc
+    hexagon_S4_vxaddsubh,                      // llvm.hexagon.S4.vxaddsubh
+    hexagon_S4_vxaddsubhr,                     // llvm.hexagon.S4.vxaddsubhr
+    hexagon_S4_vxaddsubw,                      // llvm.hexagon.S4.vxaddsubw
+    hexagon_S4_vxsubaddh,                      // llvm.hexagon.S4.vxsubaddh
+    hexagon_S4_vxsubaddhr,                     // llvm.hexagon.S4.vxsubaddhr
+    hexagon_S4_vxsubaddw,                      // llvm.hexagon.S4.vxsubaddw
+    hexagon_S5_asrhub_rnd_sat_goodsyntax,      // llvm.hexagon.S5.asrhub.rnd.sat.goodsyntax
+    hexagon_S5_asrhub_sat,                     // llvm.hexagon.S5.asrhub.sat
+    hexagon_S5_popcountp,                      // llvm.hexagon.S5.popcountp
+    hexagon_S5_vasrhrnd_goodsyntax,            // llvm.hexagon.S5.vasrhrnd.goodsyntax
+    hexagon_S6_rol_i_p,                        // llvm.hexagon.S6.rol.i.p
+    hexagon_S6_rol_i_p_acc,                    // llvm.hexagon.S6.rol.i.p.acc
+    hexagon_S6_rol_i_p_and,                    // llvm.hexagon.S6.rol.i.p.and
+    hexagon_S6_rol_i_p_nac,                    // llvm.hexagon.S6.rol.i.p.nac
+    hexagon_S6_rol_i_p_or,                     // llvm.hexagon.S6.rol.i.p.or
+    hexagon_S6_rol_i_p_xacc,                   // llvm.hexagon.S6.rol.i.p.xacc
+    hexagon_S6_rol_i_r,                        // llvm.hexagon.S6.rol.i.r
+    hexagon_S6_rol_i_r_acc,                    // llvm.hexagon.S6.rol.i.r.acc
+    hexagon_S6_rol_i_r_and,                    // llvm.hexagon.S6.rol.i.r.and
+    hexagon_S6_rol_i_r_nac,                    // llvm.hexagon.S6.rol.i.r.nac
+    hexagon_S6_rol_i_r_or,                     // llvm.hexagon.S6.rol.i.r.or
+    hexagon_S6_rol_i_r_xacc,                   // llvm.hexagon.S6.rol.i.r.xacc
+    hexagon_S6_vsplatrbp,                      // llvm.hexagon.S6.vsplatrbp
+    hexagon_S6_vtrunehb_ppp,                   // llvm.hexagon.S6.vtrunehb.ppp
+    hexagon_S6_vtrunohb_ppp,                   // llvm.hexagon.S6.vtrunohb.ppp
+    hexagon_V6_extractw,                       // llvm.hexagon.V6.extractw
+    hexagon_V6_extractw_128B,                  // llvm.hexagon.V6.extractw.128B
+    hexagon_V6_hi,                             // llvm.hexagon.V6.hi
+    hexagon_V6_hi_128B,                        // llvm.hexagon.V6.hi.128B
+    hexagon_V6_lo,                             // llvm.hexagon.V6.lo
+    hexagon_V6_lo_128B,                        // llvm.hexagon.V6.lo.128B
+    hexagon_V6_lvsplatb,                       // llvm.hexagon.V6.lvsplatb
+    hexagon_V6_lvsplatb_128B,                  // llvm.hexagon.V6.lvsplatb.128B
+    hexagon_V6_lvsplath,                       // llvm.hexagon.V6.lvsplath
+    hexagon_V6_lvsplath_128B,                  // llvm.hexagon.V6.lvsplath.128B
+    hexagon_V6_lvsplatw,                       // llvm.hexagon.V6.lvsplatw
+    hexagon_V6_lvsplatw_128B,                  // llvm.hexagon.V6.lvsplatw.128B
+    hexagon_V6_pred_and,                       // llvm.hexagon.V6.pred.and
+    hexagon_V6_pred_and_128B,                  // llvm.hexagon.V6.pred.and.128B
+    hexagon_V6_pred_and_n,                     // llvm.hexagon.V6.pred.and.n
+    hexagon_V6_pred_and_n_128B,                // llvm.hexagon.V6.pred.and.n.128B
+    hexagon_V6_pred_not,                       // llvm.hexagon.V6.pred.not
+    hexagon_V6_pred_not_128B,                  // llvm.hexagon.V6.pred.not.128B
+    hexagon_V6_pred_or,                        // llvm.hexagon.V6.pred.or
+    hexagon_V6_pred_or_128B,                   // llvm.hexagon.V6.pred.or.128B
+    hexagon_V6_pred_or_n,                      // llvm.hexagon.V6.pred.or.n
+    hexagon_V6_pred_or_n_128B,                 // llvm.hexagon.V6.pred.or.n.128B
+    hexagon_V6_pred_scalar2,                   // llvm.hexagon.V6.pred.scalar2
+    hexagon_V6_pred_scalar2_128B,              // llvm.hexagon.V6.pred.scalar2.128B
+    hexagon_V6_pred_scalar2v2,                 // llvm.hexagon.V6.pred.scalar2v2
+    hexagon_V6_pred_scalar2v2_128B,            // llvm.hexagon.V6.pred.scalar2v2.128B
+    hexagon_V6_pred_typecast,                  // llvm.hexagon.V6.pred.typecast
+    hexagon_V6_pred_typecast_128B,             // llvm.hexagon.V6.pred.typecast.128B
+    hexagon_V6_pred_xor,                       // llvm.hexagon.V6.pred.xor
+    hexagon_V6_pred_xor_128B,                  // llvm.hexagon.V6.pred.xor.128B
+    hexagon_V6_shuffeqh,                       // llvm.hexagon.V6.shuffeqh
+    hexagon_V6_shuffeqh_128B,                  // llvm.hexagon.V6.shuffeqh.128B
+    hexagon_V6_shuffeqw,                       // llvm.hexagon.V6.shuffeqw
+    hexagon_V6_shuffeqw_128B,                  // llvm.hexagon.V6.shuffeqw.128B
+    hexagon_V6_vS32b_nqpred_ai,                // llvm.hexagon.V6.vS32b.nqpred.ai
+    hexagon_V6_vS32b_nqpred_ai_128B,           // llvm.hexagon.V6.vS32b.nqpred.ai.128B
+    hexagon_V6_vS32b_nt_nqpred_ai,             // llvm.hexagon.V6.vS32b.nt.nqpred.ai
+    hexagon_V6_vS32b_nt_nqpred_ai_128B,        // llvm.hexagon.V6.vS32b.nt.nqpred.ai.128B
+    hexagon_V6_vS32b_nt_qpred_ai,              // llvm.hexagon.V6.vS32b.nt.qpred.ai
+    hexagon_V6_vS32b_nt_qpred_ai_128B,         // llvm.hexagon.V6.vS32b.nt.qpred.ai.128B
+    hexagon_V6_vS32b_qpred_ai,                 // llvm.hexagon.V6.vS32b.qpred.ai
+    hexagon_V6_vS32b_qpred_ai_128B,            // llvm.hexagon.V6.vS32b.qpred.ai.128B
+    hexagon_V6_vabsb,                          // llvm.hexagon.V6.vabsb
+    hexagon_V6_vabsb_128B,                     // llvm.hexagon.V6.vabsb.128B
+    hexagon_V6_vabsb_sat,                      // llvm.hexagon.V6.vabsb.sat
+    hexagon_V6_vabsb_sat_128B,                 // llvm.hexagon.V6.vabsb.sat.128B
+    hexagon_V6_vabsdiffh,                      // llvm.hexagon.V6.vabsdiffh
+    hexagon_V6_vabsdiffh_128B,                 // llvm.hexagon.V6.vabsdiffh.128B
+    hexagon_V6_vabsdiffub,                     // llvm.hexagon.V6.vabsdiffub
+    hexagon_V6_vabsdiffub_128B,                // llvm.hexagon.V6.vabsdiffub.128B
+    hexagon_V6_vabsdiffuh,                     // llvm.hexagon.V6.vabsdiffuh
+    hexagon_V6_vabsdiffuh_128B,                // llvm.hexagon.V6.vabsdiffuh.128B
+    hexagon_V6_vabsdiffw,                      // llvm.hexagon.V6.vabsdiffw
+    hexagon_V6_vabsdiffw_128B,                 // llvm.hexagon.V6.vabsdiffw.128B
+    hexagon_V6_vabsh,                          // llvm.hexagon.V6.vabsh
+    hexagon_V6_vabsh_128B,                     // llvm.hexagon.V6.vabsh.128B
+    hexagon_V6_vabsh_sat,                      // llvm.hexagon.V6.vabsh.sat
+    hexagon_V6_vabsh_sat_128B,                 // llvm.hexagon.V6.vabsh.sat.128B
+    hexagon_V6_vabsw,                          // llvm.hexagon.V6.vabsw
+    hexagon_V6_vabsw_128B,                     // llvm.hexagon.V6.vabsw.128B
+    hexagon_V6_vabsw_sat,                      // llvm.hexagon.V6.vabsw.sat
+    hexagon_V6_vabsw_sat_128B,                 // llvm.hexagon.V6.vabsw.sat.128B
+    hexagon_V6_vaddb,                          // llvm.hexagon.V6.vaddb
+    hexagon_V6_vaddb_128B,                     // llvm.hexagon.V6.vaddb.128B
+    hexagon_V6_vaddb_dv,                       // llvm.hexagon.V6.vaddb.dv
+    hexagon_V6_vaddb_dv_128B,                  // llvm.hexagon.V6.vaddb.dv.128B
+    hexagon_V6_vaddbnq,                        // llvm.hexagon.V6.vaddbnq
+    hexagon_V6_vaddbnq_128B,                   // llvm.hexagon.V6.vaddbnq.128B
+    hexagon_V6_vaddbq,                         // llvm.hexagon.V6.vaddbq
+    hexagon_V6_vaddbq_128B,                    // llvm.hexagon.V6.vaddbq.128B
+    hexagon_V6_vaddbsat,                       // llvm.hexagon.V6.vaddbsat
+    hexagon_V6_vaddbsat_128B,                  // llvm.hexagon.V6.vaddbsat.128B
+    hexagon_V6_vaddbsat_dv,                    // llvm.hexagon.V6.vaddbsat.dv
+    hexagon_V6_vaddbsat_dv_128B,               // llvm.hexagon.V6.vaddbsat.dv.128B
+    hexagon_V6_vaddcarry,                      // llvm.hexagon.V6.vaddcarry
+    hexagon_V6_vaddcarry_128B,                 // llvm.hexagon.V6.vaddcarry.128B
+    hexagon_V6_vaddcarrysat,                   // llvm.hexagon.V6.vaddcarrysat
+    hexagon_V6_vaddcarrysat_128B,              // llvm.hexagon.V6.vaddcarrysat.128B
+    hexagon_V6_vaddclbh,                       // llvm.hexagon.V6.vaddclbh
+    hexagon_V6_vaddclbh_128B,                  // llvm.hexagon.V6.vaddclbh.128B
+    hexagon_V6_vaddclbw,                       // llvm.hexagon.V6.vaddclbw
+    hexagon_V6_vaddclbw_128B,                  // llvm.hexagon.V6.vaddclbw.128B
+    hexagon_V6_vaddh,                          // llvm.hexagon.V6.vaddh
+    hexagon_V6_vaddh_128B,                     // llvm.hexagon.V6.vaddh.128B
+    hexagon_V6_vaddh_dv,                       // llvm.hexagon.V6.vaddh.dv
+    hexagon_V6_vaddh_dv_128B,                  // llvm.hexagon.V6.vaddh.dv.128B
+    hexagon_V6_vaddhnq,                        // llvm.hexagon.V6.vaddhnq
+    hexagon_V6_vaddhnq_128B,                   // llvm.hexagon.V6.vaddhnq.128B
+    hexagon_V6_vaddhq,                         // llvm.hexagon.V6.vaddhq
+    hexagon_V6_vaddhq_128B,                    // llvm.hexagon.V6.vaddhq.128B
+    hexagon_V6_vaddhsat,                       // llvm.hexagon.V6.vaddhsat
+    hexagon_V6_vaddhsat_128B,                  // llvm.hexagon.V6.vaddhsat.128B
+    hexagon_V6_vaddhsat_dv,                    // llvm.hexagon.V6.vaddhsat.dv
+    hexagon_V6_vaddhsat_dv_128B,               // llvm.hexagon.V6.vaddhsat.dv.128B
+    hexagon_V6_vaddhw,                         // llvm.hexagon.V6.vaddhw
+    hexagon_V6_vaddhw_128B,                    // llvm.hexagon.V6.vaddhw.128B
+    hexagon_V6_vaddhw_acc,                     // llvm.hexagon.V6.vaddhw.acc
+    hexagon_V6_vaddhw_acc_128B,                // llvm.hexagon.V6.vaddhw.acc.128B
+    hexagon_V6_vaddubh,                        // llvm.hexagon.V6.vaddubh
+    hexagon_V6_vaddubh_128B,                   // llvm.hexagon.V6.vaddubh.128B
+    hexagon_V6_vaddubh_acc,                    // llvm.hexagon.V6.vaddubh.acc
+    hexagon_V6_vaddubh_acc_128B,               // llvm.hexagon.V6.vaddubh.acc.128B
+    hexagon_V6_vaddubsat,                      // llvm.hexagon.V6.vaddubsat
+    hexagon_V6_vaddubsat_128B,                 // llvm.hexagon.V6.vaddubsat.128B
+    hexagon_V6_vaddubsat_dv,                   // llvm.hexagon.V6.vaddubsat.dv
+    hexagon_V6_vaddubsat_dv_128B,              // llvm.hexagon.V6.vaddubsat.dv.128B
+    hexagon_V6_vaddububb_sat,                  // llvm.hexagon.V6.vaddububb.sat
+    hexagon_V6_vaddububb_sat_128B,             // llvm.hexagon.V6.vaddububb.sat.128B
+    hexagon_V6_vadduhsat,                      // llvm.hexagon.V6.vadduhsat
+    hexagon_V6_vadduhsat_128B,                 // llvm.hexagon.V6.vadduhsat.128B
+    hexagon_V6_vadduhsat_dv,                   // llvm.hexagon.V6.vadduhsat.dv
+    hexagon_V6_vadduhsat_dv_128B,              // llvm.hexagon.V6.vadduhsat.dv.128B
+    hexagon_V6_vadduhw,                        // llvm.hexagon.V6.vadduhw
+    hexagon_V6_vadduhw_128B,                   // llvm.hexagon.V6.vadduhw.128B
+    hexagon_V6_vadduhw_acc,                    // llvm.hexagon.V6.vadduhw.acc
+    hexagon_V6_vadduhw_acc_128B,               // llvm.hexagon.V6.vadduhw.acc.128B
+    hexagon_V6_vadduwsat,                      // llvm.hexagon.V6.vadduwsat
+    hexagon_V6_vadduwsat_128B,                 // llvm.hexagon.V6.vadduwsat.128B
+    hexagon_V6_vadduwsat_dv,                   // llvm.hexagon.V6.vadduwsat.dv
+    hexagon_V6_vadduwsat_dv_128B,              // llvm.hexagon.V6.vadduwsat.dv.128B
+    hexagon_V6_vaddw,                          // llvm.hexagon.V6.vaddw
+    hexagon_V6_vaddw_128B,                     // llvm.hexagon.V6.vaddw.128B
+    hexagon_V6_vaddw_dv,                       // llvm.hexagon.V6.vaddw.dv
+    hexagon_V6_vaddw_dv_128B,                  // llvm.hexagon.V6.vaddw.dv.128B
+    hexagon_V6_vaddwnq,                        // llvm.hexagon.V6.vaddwnq
+    hexagon_V6_vaddwnq_128B,                   // llvm.hexagon.V6.vaddwnq.128B
+    hexagon_V6_vaddwq,                         // llvm.hexagon.V6.vaddwq
+    hexagon_V6_vaddwq_128B,                    // llvm.hexagon.V6.vaddwq.128B
+    hexagon_V6_vaddwsat,                       // llvm.hexagon.V6.vaddwsat
+    hexagon_V6_vaddwsat_128B,                  // llvm.hexagon.V6.vaddwsat.128B
+    hexagon_V6_vaddwsat_dv,                    // llvm.hexagon.V6.vaddwsat.dv
+    hexagon_V6_vaddwsat_dv_128B,               // llvm.hexagon.V6.vaddwsat.dv.128B
+    hexagon_V6_valignb,                        // llvm.hexagon.V6.valignb
+    hexagon_V6_valignb_128B,                   // llvm.hexagon.V6.valignb.128B
+    hexagon_V6_valignbi,                       // llvm.hexagon.V6.valignbi
+    hexagon_V6_valignbi_128B,                  // llvm.hexagon.V6.valignbi.128B
+    hexagon_V6_vand,                           // llvm.hexagon.V6.vand
+    hexagon_V6_vand_128B,                      // llvm.hexagon.V6.vand.128B
+    hexagon_V6_vandnqrt,                       // llvm.hexagon.V6.vandnqrt
+    hexagon_V6_vandnqrt_128B,                  // llvm.hexagon.V6.vandnqrt.128B
+    hexagon_V6_vandnqrt_acc,                   // llvm.hexagon.V6.vandnqrt.acc
+    hexagon_V6_vandnqrt_acc_128B,              // llvm.hexagon.V6.vandnqrt.acc.128B
+    hexagon_V6_vandqrt,                        // llvm.hexagon.V6.vandqrt
+    hexagon_V6_vandqrt_128B,                   // llvm.hexagon.V6.vandqrt.128B
+    hexagon_V6_vandqrt_acc,                    // llvm.hexagon.V6.vandqrt.acc
+    hexagon_V6_vandqrt_acc_128B,               // llvm.hexagon.V6.vandqrt.acc.128B
+    hexagon_V6_vandvnqv,                       // llvm.hexagon.V6.vandvnqv
+    hexagon_V6_vandvnqv_128B,                  // llvm.hexagon.V6.vandvnqv.128B
+    hexagon_V6_vandvqv,                        // llvm.hexagon.V6.vandvqv
+    hexagon_V6_vandvqv_128B,                   // llvm.hexagon.V6.vandvqv.128B
+    hexagon_V6_vandvrt,                        // llvm.hexagon.V6.vandvrt
+    hexagon_V6_vandvrt_128B,                   // llvm.hexagon.V6.vandvrt.128B
+    hexagon_V6_vandvrt_acc,                    // llvm.hexagon.V6.vandvrt.acc
+    hexagon_V6_vandvrt_acc_128B,               // llvm.hexagon.V6.vandvrt.acc.128B
+    hexagon_V6_vaslh,                          // llvm.hexagon.V6.vaslh
+    hexagon_V6_vaslh_128B,                     // llvm.hexagon.V6.vaslh.128B
+    hexagon_V6_vaslh_acc,                      // llvm.hexagon.V6.vaslh.acc
+    hexagon_V6_vaslh_acc_128B,                 // llvm.hexagon.V6.vaslh.acc.128B
+    hexagon_V6_vaslhv,                         // llvm.hexagon.V6.vaslhv
+    hexagon_V6_vaslhv_128B,                    // llvm.hexagon.V6.vaslhv.128B
+    hexagon_V6_vaslw,                          // llvm.hexagon.V6.vaslw
+    hexagon_V6_vaslw_128B,                     // llvm.hexagon.V6.vaslw.128B
+    hexagon_V6_vaslw_acc,                      // llvm.hexagon.V6.vaslw.acc
+    hexagon_V6_vaslw_acc_128B,                 // llvm.hexagon.V6.vaslw.acc.128B
+    hexagon_V6_vaslwv,                         // llvm.hexagon.V6.vaslwv
+    hexagon_V6_vaslwv_128B,                    // llvm.hexagon.V6.vaslwv.128B
+    hexagon_V6_vasr_into,                      // llvm.hexagon.V6.vasr.into
+    hexagon_V6_vasr_into_128B,                 // llvm.hexagon.V6.vasr.into.128B
+    hexagon_V6_vasrh,                          // llvm.hexagon.V6.vasrh
+    hexagon_V6_vasrh_128B,                     // llvm.hexagon.V6.vasrh.128B
+    hexagon_V6_vasrh_acc,                      // llvm.hexagon.V6.vasrh.acc
+    hexagon_V6_vasrh_acc_128B,                 // llvm.hexagon.V6.vasrh.acc.128B
+    hexagon_V6_vasrhbrndsat,                   // llvm.hexagon.V6.vasrhbrndsat
+    hexagon_V6_vasrhbrndsat_128B,              // llvm.hexagon.V6.vasrhbrndsat.128B
+    hexagon_V6_vasrhbsat,                      // llvm.hexagon.V6.vasrhbsat
+    hexagon_V6_vasrhbsat_128B,                 // llvm.hexagon.V6.vasrhbsat.128B
+    hexagon_V6_vasrhubrndsat,                  // llvm.hexagon.V6.vasrhubrndsat
+    hexagon_V6_vasrhubrndsat_128B,             // llvm.hexagon.V6.vasrhubrndsat.128B
+    hexagon_V6_vasrhubsat,                     // llvm.hexagon.V6.vasrhubsat
+    hexagon_V6_vasrhubsat_128B,                // llvm.hexagon.V6.vasrhubsat.128B
+    hexagon_V6_vasrhv,                         // llvm.hexagon.V6.vasrhv
+    hexagon_V6_vasrhv_128B,                    // llvm.hexagon.V6.vasrhv.128B
+    hexagon_V6_vasruhubrndsat,                 // llvm.hexagon.V6.vasruhubrndsat
+    hexagon_V6_vasruhubrndsat_128B,            // llvm.hexagon.V6.vasruhubrndsat.128B
+    hexagon_V6_vasruhubsat,                    // llvm.hexagon.V6.vasruhubsat
+    hexagon_V6_vasruhubsat_128B,               // llvm.hexagon.V6.vasruhubsat.128B
+    hexagon_V6_vasruwuhrndsat,                 // llvm.hexagon.V6.vasruwuhrndsat
+    hexagon_V6_vasruwuhrndsat_128B,            // llvm.hexagon.V6.vasruwuhrndsat.128B
+    hexagon_V6_vasruwuhsat,                    // llvm.hexagon.V6.vasruwuhsat
+    hexagon_V6_vasruwuhsat_128B,               // llvm.hexagon.V6.vasruwuhsat.128B
+    hexagon_V6_vasrw,                          // llvm.hexagon.V6.vasrw
+    hexagon_V6_vasrw_128B,                     // llvm.hexagon.V6.vasrw.128B
+    hexagon_V6_vasrw_acc,                      // llvm.hexagon.V6.vasrw.acc
+    hexagon_V6_vasrw_acc_128B,                 // llvm.hexagon.V6.vasrw.acc.128B
+    hexagon_V6_vasrwh,                         // llvm.hexagon.V6.vasrwh
+    hexagon_V6_vasrwh_128B,                    // llvm.hexagon.V6.vasrwh.128B
+    hexagon_V6_vasrwhrndsat,                   // llvm.hexagon.V6.vasrwhrndsat
+    hexagon_V6_vasrwhrndsat_128B,              // llvm.hexagon.V6.vasrwhrndsat.128B
+    hexagon_V6_vasrwhsat,                      // llvm.hexagon.V6.vasrwhsat
+    hexagon_V6_vasrwhsat_128B,                 // llvm.hexagon.V6.vasrwhsat.128B
+    hexagon_V6_vasrwuhrndsat,                  // llvm.hexagon.V6.vasrwuhrndsat
+    hexagon_V6_vasrwuhrndsat_128B,             // llvm.hexagon.V6.vasrwuhrndsat.128B
+    hexagon_V6_vasrwuhsat,                     // llvm.hexagon.V6.vasrwuhsat
+    hexagon_V6_vasrwuhsat_128B,                // llvm.hexagon.V6.vasrwuhsat.128B
+    hexagon_V6_vasrwv,                         // llvm.hexagon.V6.vasrwv
+    hexagon_V6_vasrwv_128B,                    // llvm.hexagon.V6.vasrwv.128B
+    hexagon_V6_vassign,                        // llvm.hexagon.V6.vassign
+    hexagon_V6_vassign_128B,                   // llvm.hexagon.V6.vassign.128B
+    hexagon_V6_vassignp,                       // llvm.hexagon.V6.vassignp
+    hexagon_V6_vassignp_128B,                  // llvm.hexagon.V6.vassignp.128B
+    hexagon_V6_vavgb,                          // llvm.hexagon.V6.vavgb
+    hexagon_V6_vavgb_128B,                     // llvm.hexagon.V6.vavgb.128B
+    hexagon_V6_vavgbrnd,                       // llvm.hexagon.V6.vavgbrnd
+    hexagon_V6_vavgbrnd_128B,                  // llvm.hexagon.V6.vavgbrnd.128B
+    hexagon_V6_vavgh,                          // llvm.hexagon.V6.vavgh
+    hexagon_V6_vavgh_128B,                     // llvm.hexagon.V6.vavgh.128B
+    hexagon_V6_vavghrnd,                       // llvm.hexagon.V6.vavghrnd
+    hexagon_V6_vavghrnd_128B,                  // llvm.hexagon.V6.vavghrnd.128B
+    hexagon_V6_vavgub,                         // llvm.hexagon.V6.vavgub
+    hexagon_V6_vavgub_128B,                    // llvm.hexagon.V6.vavgub.128B
+    hexagon_V6_vavgubrnd,                      // llvm.hexagon.V6.vavgubrnd
+    hexagon_V6_vavgubrnd_128B,                 // llvm.hexagon.V6.vavgubrnd.128B
+    hexagon_V6_vavguh,                         // llvm.hexagon.V6.vavguh
+    hexagon_V6_vavguh_128B,                    // llvm.hexagon.V6.vavguh.128B
+    hexagon_V6_vavguhrnd,                      // llvm.hexagon.V6.vavguhrnd
+    hexagon_V6_vavguhrnd_128B,                 // llvm.hexagon.V6.vavguhrnd.128B
+    hexagon_V6_vavguw,                         // llvm.hexagon.V6.vavguw
+    hexagon_V6_vavguw_128B,                    // llvm.hexagon.V6.vavguw.128B
+    hexagon_V6_vavguwrnd,                      // llvm.hexagon.V6.vavguwrnd
+    hexagon_V6_vavguwrnd_128B,                 // llvm.hexagon.V6.vavguwrnd.128B
+    hexagon_V6_vavgw,                          // llvm.hexagon.V6.vavgw
+    hexagon_V6_vavgw_128B,                     // llvm.hexagon.V6.vavgw.128B
+    hexagon_V6_vavgwrnd,                       // llvm.hexagon.V6.vavgwrnd
+    hexagon_V6_vavgwrnd_128B,                  // llvm.hexagon.V6.vavgwrnd.128B
+    hexagon_V6_vcl0h,                          // llvm.hexagon.V6.vcl0h
+    hexagon_V6_vcl0h_128B,                     // llvm.hexagon.V6.vcl0h.128B
+    hexagon_V6_vcl0w,                          // llvm.hexagon.V6.vcl0w
+    hexagon_V6_vcl0w_128B,                     // llvm.hexagon.V6.vcl0w.128B
+    hexagon_V6_vcombine,                       // llvm.hexagon.V6.vcombine
+    hexagon_V6_vcombine_128B,                  // llvm.hexagon.V6.vcombine.128B
+    hexagon_V6_vd0,                            // llvm.hexagon.V6.vd0
+    hexagon_V6_vd0_128B,                       // llvm.hexagon.V6.vd0.128B
+    hexagon_V6_vdd0,                           // llvm.hexagon.V6.vdd0
+    hexagon_V6_vdd0_128B,                      // llvm.hexagon.V6.vdd0.128B
+    hexagon_V6_vdealb,                         // llvm.hexagon.V6.vdealb
+    hexagon_V6_vdealb_128B,                    // llvm.hexagon.V6.vdealb.128B
+    hexagon_V6_vdealb4w,                       // llvm.hexagon.V6.vdealb4w
+    hexagon_V6_vdealb4w_128B,                  // llvm.hexagon.V6.vdealb4w.128B
+    hexagon_V6_vdealh,                         // llvm.hexagon.V6.vdealh
+    hexagon_V6_vdealh_128B,                    // llvm.hexagon.V6.vdealh.128B
+    hexagon_V6_vdealvdd,                       // llvm.hexagon.V6.vdealvdd
+    hexagon_V6_vdealvdd_128B,                  // llvm.hexagon.V6.vdealvdd.128B
+    hexagon_V6_vdelta,                         // llvm.hexagon.V6.vdelta
+    hexagon_V6_vdelta_128B,                    // llvm.hexagon.V6.vdelta.128B
+    hexagon_V6_vdmpybus,                       // llvm.hexagon.V6.vdmpybus
+    hexagon_V6_vdmpybus_128B,                  // llvm.hexagon.V6.vdmpybus.128B
+    hexagon_V6_vdmpybus_acc,                   // llvm.hexagon.V6.vdmpybus.acc
+    hexagon_V6_vdmpybus_acc_128B,              // llvm.hexagon.V6.vdmpybus.acc.128B
+    hexagon_V6_vdmpybus_dv,                    // llvm.hexagon.V6.vdmpybus.dv
+    hexagon_V6_vdmpybus_dv_128B,               // llvm.hexagon.V6.vdmpybus.dv.128B
+    hexagon_V6_vdmpybus_dv_acc,                // llvm.hexagon.V6.vdmpybus.dv.acc
+    hexagon_V6_vdmpybus_dv_acc_128B,           // llvm.hexagon.V6.vdmpybus.dv.acc.128B
+    hexagon_V6_vdmpyhb,                        // llvm.hexagon.V6.vdmpyhb
+    hexagon_V6_vdmpyhb_128B,                   // llvm.hexagon.V6.vdmpyhb.128B
+    hexagon_V6_vdmpyhb_acc,                    // llvm.hexagon.V6.vdmpyhb.acc
+    hexagon_V6_vdmpyhb_acc_128B,               // llvm.hexagon.V6.vdmpyhb.acc.128B
+    hexagon_V6_vdmpyhb_dv,                     // llvm.hexagon.V6.vdmpyhb.dv
+    hexagon_V6_vdmpyhb_dv_128B,                // llvm.hexagon.V6.vdmpyhb.dv.128B
+    hexagon_V6_vdmpyhb_dv_acc,                 // llvm.hexagon.V6.vdmpyhb.dv.acc
+    hexagon_V6_vdmpyhb_dv_acc_128B,            // llvm.hexagon.V6.vdmpyhb.dv.acc.128B
+    hexagon_V6_vdmpyhisat,                     // llvm.hexagon.V6.vdmpyhisat
+    hexagon_V6_vdmpyhisat_128B,                // llvm.hexagon.V6.vdmpyhisat.128B
+    hexagon_V6_vdmpyhisat_acc,                 // llvm.hexagon.V6.vdmpyhisat.acc
+    hexagon_V6_vdmpyhisat_acc_128B,            // llvm.hexagon.V6.vdmpyhisat.acc.128B
+    hexagon_V6_vdmpyhsat,                      // llvm.hexagon.V6.vdmpyhsat
+    hexagon_V6_vdmpyhsat_128B,                 // llvm.hexagon.V6.vdmpyhsat.128B
+    hexagon_V6_vdmpyhsat_acc,                  // llvm.hexagon.V6.vdmpyhsat.acc
+    hexagon_V6_vdmpyhsat_acc_128B,             // llvm.hexagon.V6.vdmpyhsat.acc.128B
+    hexagon_V6_vdmpyhsuisat,                   // llvm.hexagon.V6.vdmpyhsuisat
+    hexagon_V6_vdmpyhsuisat_128B,              // llvm.hexagon.V6.vdmpyhsuisat.128B
+    hexagon_V6_vdmpyhsuisat_acc,               // llvm.hexagon.V6.vdmpyhsuisat.acc
+    hexagon_V6_vdmpyhsuisat_acc_128B,          // llvm.hexagon.V6.vdmpyhsuisat.acc.128B
+    hexagon_V6_vdmpyhsusat,                    // llvm.hexagon.V6.vdmpyhsusat
+    hexagon_V6_vdmpyhsusat_128B,               // llvm.hexagon.V6.vdmpyhsusat.128B
+    hexagon_V6_vdmpyhsusat_acc,                // llvm.hexagon.V6.vdmpyhsusat.acc
+    hexagon_V6_vdmpyhsusat_acc_128B,           // llvm.hexagon.V6.vdmpyhsusat.acc.128B
+    hexagon_V6_vdmpyhvsat,                     // llvm.hexagon.V6.vdmpyhvsat
+    hexagon_V6_vdmpyhvsat_128B,                // llvm.hexagon.V6.vdmpyhvsat.128B
+    hexagon_V6_vdmpyhvsat_acc,                 // llvm.hexagon.V6.vdmpyhvsat.acc
+    hexagon_V6_vdmpyhvsat_acc_128B,            // llvm.hexagon.V6.vdmpyhvsat.acc.128B
+    hexagon_V6_vdsaduh,                        // llvm.hexagon.V6.vdsaduh
+    hexagon_V6_vdsaduh_128B,                   // llvm.hexagon.V6.vdsaduh.128B
+    hexagon_V6_vdsaduh_acc,                    // llvm.hexagon.V6.vdsaduh.acc
+    hexagon_V6_vdsaduh_acc_128B,               // llvm.hexagon.V6.vdsaduh.acc.128B
+    hexagon_V6_veqb,                           // llvm.hexagon.V6.veqb
+    hexagon_V6_veqb_128B,                      // llvm.hexagon.V6.veqb.128B
+    hexagon_V6_veqb_and,                       // llvm.hexagon.V6.veqb.and
+    hexagon_V6_veqb_and_128B,                  // llvm.hexagon.V6.veqb.and.128B
+    hexagon_V6_veqb_or,                        // llvm.hexagon.V6.veqb.or
+    hexagon_V6_veqb_or_128B,                   // llvm.hexagon.V6.veqb.or.128B
+    hexagon_V6_veqb_xor,                       // llvm.hexagon.V6.veqb.xor
+    hexagon_V6_veqb_xor_128B,                  // llvm.hexagon.V6.veqb.xor.128B
+    hexagon_V6_veqh,                           // llvm.hexagon.V6.veqh
+    hexagon_V6_veqh_128B,                      // llvm.hexagon.V6.veqh.128B
+    hexagon_V6_veqh_and,                       // llvm.hexagon.V6.veqh.and
+    hexagon_V6_veqh_and_128B,                  // llvm.hexagon.V6.veqh.and.128B
+    hexagon_V6_veqh_or,                        // llvm.hexagon.V6.veqh.or
+    hexagon_V6_veqh_or_128B,                   // llvm.hexagon.V6.veqh.or.128B
+    hexagon_V6_veqh_xor,                       // llvm.hexagon.V6.veqh.xor
+    hexagon_V6_veqh_xor_128B,                  // llvm.hexagon.V6.veqh.xor.128B
+    hexagon_V6_veqw,                           // llvm.hexagon.V6.veqw
+    hexagon_V6_veqw_128B,                      // llvm.hexagon.V6.veqw.128B
+    hexagon_V6_veqw_and,                       // llvm.hexagon.V6.veqw.and
+    hexagon_V6_veqw_and_128B,                  // llvm.hexagon.V6.veqw.and.128B
+    hexagon_V6_veqw_or,                        // llvm.hexagon.V6.veqw.or
+    hexagon_V6_veqw_or_128B,                   // llvm.hexagon.V6.veqw.or.128B
+    hexagon_V6_veqw_xor,                       // llvm.hexagon.V6.veqw.xor
+    hexagon_V6_veqw_xor_128B,                  // llvm.hexagon.V6.veqw.xor.128B
+    hexagon_V6_vgathermh,                      // llvm.hexagon.V6.vgathermh
+    hexagon_V6_vgathermh_128B,                 // llvm.hexagon.V6.vgathermh.128B
+    hexagon_V6_vgathermhq,                     // llvm.hexagon.V6.vgathermhq
+    hexagon_V6_vgathermhq_128B,                // llvm.hexagon.V6.vgathermhq.128B
+    hexagon_V6_vgathermhw,                     // llvm.hexagon.V6.vgathermhw
+    hexagon_V6_vgathermhw_128B,                // llvm.hexagon.V6.vgathermhw.128B
+    hexagon_V6_vgathermhwq,                    // llvm.hexagon.V6.vgathermhwq
+    hexagon_V6_vgathermhwq_128B,               // llvm.hexagon.V6.vgathermhwq.128B
+    hexagon_V6_vgathermw,                      // llvm.hexagon.V6.vgathermw
+    hexagon_V6_vgathermw_128B,                 // llvm.hexagon.V6.vgathermw.128B
+    hexagon_V6_vgathermwq,                     // llvm.hexagon.V6.vgathermwq
+    hexagon_V6_vgathermwq_128B,                // llvm.hexagon.V6.vgathermwq.128B
+    hexagon_V6_vgtb,                           // llvm.hexagon.V6.vgtb
+    hexagon_V6_vgtb_128B,                      // llvm.hexagon.V6.vgtb.128B
+    hexagon_V6_vgtb_and,                       // llvm.hexagon.V6.vgtb.and
+    hexagon_V6_vgtb_and_128B,                  // llvm.hexagon.V6.vgtb.and.128B
+    hexagon_V6_vgtb_or,                        // llvm.hexagon.V6.vgtb.or
+    hexagon_V6_vgtb_or_128B,                   // llvm.hexagon.V6.vgtb.or.128B
+    hexagon_V6_vgtb_xor,                       // llvm.hexagon.V6.vgtb.xor
+    hexagon_V6_vgtb_xor_128B,                  // llvm.hexagon.V6.vgtb.xor.128B
+    hexagon_V6_vgth,                           // llvm.hexagon.V6.vgth
+    hexagon_V6_vgth_128B,                      // llvm.hexagon.V6.vgth.128B
+    hexagon_V6_vgth_and,                       // llvm.hexagon.V6.vgth.and
+    hexagon_V6_vgth_and_128B,                  // llvm.hexagon.V6.vgth.and.128B
+    hexagon_V6_vgth_or,                        // llvm.hexagon.V6.vgth.or
+    hexagon_V6_vgth_or_128B,                   // llvm.hexagon.V6.vgth.or.128B
+    hexagon_V6_vgth_xor,                       // llvm.hexagon.V6.vgth.xor
+    hexagon_V6_vgth_xor_128B,                  // llvm.hexagon.V6.vgth.xor.128B
+    hexagon_V6_vgtub,                          // llvm.hexagon.V6.vgtub
+    hexagon_V6_vgtub_128B,                     // llvm.hexagon.V6.vgtub.128B
+    hexagon_V6_vgtub_and,                      // llvm.hexagon.V6.vgtub.and
+    hexagon_V6_vgtub_and_128B,                 // llvm.hexagon.V6.vgtub.and.128B
+    hexagon_V6_vgtub_or,                       // llvm.hexagon.V6.vgtub.or
+    hexagon_V6_vgtub_or_128B,                  // llvm.hexagon.V6.vgtub.or.128B
+    hexagon_V6_vgtub_xor,                      // llvm.hexagon.V6.vgtub.xor
+    hexagon_V6_vgtub_xor_128B,                 // llvm.hexagon.V6.vgtub.xor.128B
+    hexagon_V6_vgtuh,                          // llvm.hexagon.V6.vgtuh
+    hexagon_V6_vgtuh_128B,                     // llvm.hexagon.V6.vgtuh.128B
+    hexagon_V6_vgtuh_and,                      // llvm.hexagon.V6.vgtuh.and
+    hexagon_V6_vgtuh_and_128B,                 // llvm.hexagon.V6.vgtuh.and.128B
+    hexagon_V6_vgtuh_or,                       // llvm.hexagon.V6.vgtuh.or
+    hexagon_V6_vgtuh_or_128B,                  // llvm.hexagon.V6.vgtuh.or.128B
+    hexagon_V6_vgtuh_xor,                      // llvm.hexagon.V6.vgtuh.xor
+    hexagon_V6_vgtuh_xor_128B,                 // llvm.hexagon.V6.vgtuh.xor.128B
+    hexagon_V6_vgtuw,                          // llvm.hexagon.V6.vgtuw
+    hexagon_V6_vgtuw_128B,                     // llvm.hexagon.V6.vgtuw.128B
+    hexagon_V6_vgtuw_and,                      // llvm.hexagon.V6.vgtuw.and
+    hexagon_V6_vgtuw_and_128B,                 // llvm.hexagon.V6.vgtuw.and.128B
+    hexagon_V6_vgtuw_or,                       // llvm.hexagon.V6.vgtuw.or
+    hexagon_V6_vgtuw_or_128B,                  // llvm.hexagon.V6.vgtuw.or.128B
+    hexagon_V6_vgtuw_xor,                      // llvm.hexagon.V6.vgtuw.xor
+    hexagon_V6_vgtuw_xor_128B,                 // llvm.hexagon.V6.vgtuw.xor.128B
+    hexagon_V6_vgtw,                           // llvm.hexagon.V6.vgtw
+    hexagon_V6_vgtw_128B,                      // llvm.hexagon.V6.vgtw.128B
+    hexagon_V6_vgtw_and,                       // llvm.hexagon.V6.vgtw.and
+    hexagon_V6_vgtw_and_128B,                  // llvm.hexagon.V6.vgtw.and.128B
+    hexagon_V6_vgtw_or,                        // llvm.hexagon.V6.vgtw.or
+    hexagon_V6_vgtw_or_128B,                   // llvm.hexagon.V6.vgtw.or.128B
+    hexagon_V6_vgtw_xor,                       // llvm.hexagon.V6.vgtw.xor
+    hexagon_V6_vgtw_xor_128B,                  // llvm.hexagon.V6.vgtw.xor.128B
+    hexagon_V6_vinsertwr,                      // llvm.hexagon.V6.vinsertwr
+    hexagon_V6_vinsertwr_128B,                 // llvm.hexagon.V6.vinsertwr.128B
+    hexagon_V6_vlalignb,                       // llvm.hexagon.V6.vlalignb
+    hexagon_V6_vlalignb_128B,                  // llvm.hexagon.V6.vlalignb.128B
+    hexagon_V6_vlalignbi,                      // llvm.hexagon.V6.vlalignbi
+    hexagon_V6_vlalignbi_128B,                 // llvm.hexagon.V6.vlalignbi.128B
+    hexagon_V6_vlsrb,                          // llvm.hexagon.V6.vlsrb
+    hexagon_V6_vlsrb_128B,                     // llvm.hexagon.V6.vlsrb.128B
+    hexagon_V6_vlsrh,                          // llvm.hexagon.V6.vlsrh
+    hexagon_V6_vlsrh_128B,                     // llvm.hexagon.V6.vlsrh.128B
+    hexagon_V6_vlsrhv,                         // llvm.hexagon.V6.vlsrhv
+    hexagon_V6_vlsrhv_128B,                    // llvm.hexagon.V6.vlsrhv.128B
+    hexagon_V6_vlsrw,                          // llvm.hexagon.V6.vlsrw
+    hexagon_V6_vlsrw_128B,                     // llvm.hexagon.V6.vlsrw.128B
+    hexagon_V6_vlsrwv,                         // llvm.hexagon.V6.vlsrwv
+    hexagon_V6_vlsrwv_128B,                    // llvm.hexagon.V6.vlsrwv.128B
+    hexagon_V6_vlut4,                          // llvm.hexagon.V6.vlut4
+    hexagon_V6_vlut4_128B,                     // llvm.hexagon.V6.vlut4.128B
+    hexagon_V6_vlutvvb,                        // llvm.hexagon.V6.vlutvvb
+    hexagon_V6_vlutvvb_128B,                   // llvm.hexagon.V6.vlutvvb.128B
+    hexagon_V6_vlutvvb_nm,                     // llvm.hexagon.V6.vlutvvb.nm
+    hexagon_V6_vlutvvb_nm_128B,                // llvm.hexagon.V6.vlutvvb.nm.128B
+    hexagon_V6_vlutvvb_oracc,                  // llvm.hexagon.V6.vlutvvb.oracc
+    hexagon_V6_vlutvvb_oracc_128B,             // llvm.hexagon.V6.vlutvvb.oracc.128B
+    hexagon_V6_vlutvvb_oracci,                 // llvm.hexagon.V6.vlutvvb.oracci
+    hexagon_V6_vlutvvb_oracci_128B,            // llvm.hexagon.V6.vlutvvb.oracci.128B
+    hexagon_V6_vlutvvbi,                       // llvm.hexagon.V6.vlutvvbi
+    hexagon_V6_vlutvvbi_128B,                  // llvm.hexagon.V6.vlutvvbi.128B
+    hexagon_V6_vlutvwh,                        // llvm.hexagon.V6.vlutvwh
+    hexagon_V6_vlutvwh_128B,                   // llvm.hexagon.V6.vlutvwh.128B
+    hexagon_V6_vlutvwh_nm,                     // llvm.hexagon.V6.vlutvwh.nm
+    hexagon_V6_vlutvwh_nm_128B,                // llvm.hexagon.V6.vlutvwh.nm.128B
+    hexagon_V6_vlutvwh_oracc,                  // llvm.hexagon.V6.vlutvwh.oracc
+    hexagon_V6_vlutvwh_oracc_128B,             // llvm.hexagon.V6.vlutvwh.oracc.128B
+    hexagon_V6_vlutvwh_oracci,                 // llvm.hexagon.V6.vlutvwh.oracci
+    hexagon_V6_vlutvwh_oracci_128B,            // llvm.hexagon.V6.vlutvwh.oracci.128B
+    hexagon_V6_vlutvwhi,                       // llvm.hexagon.V6.vlutvwhi
+    hexagon_V6_vlutvwhi_128B,                  // llvm.hexagon.V6.vlutvwhi.128B
+    hexagon_V6_vmaskedstorenq,                 // llvm.hexagon.V6.vmaskedstorenq
+    hexagon_V6_vmaskedstorenq_128B,            // llvm.hexagon.V6.vmaskedstorenq.128B
+    hexagon_V6_vmaskedstorentnq,               // llvm.hexagon.V6.vmaskedstorentnq
+    hexagon_V6_vmaskedstorentnq_128B,          // llvm.hexagon.V6.vmaskedstorentnq.128B
+    hexagon_V6_vmaskedstorentq,                // llvm.hexagon.V6.vmaskedstorentq
+    hexagon_V6_vmaskedstorentq_128B,           // llvm.hexagon.V6.vmaskedstorentq.128B
+    hexagon_V6_vmaskedstoreq,                  // llvm.hexagon.V6.vmaskedstoreq
+    hexagon_V6_vmaskedstoreq_128B,             // llvm.hexagon.V6.vmaskedstoreq.128B
+    hexagon_V6_vmaxb,                          // llvm.hexagon.V6.vmaxb
+    hexagon_V6_vmaxb_128B,                     // llvm.hexagon.V6.vmaxb.128B
+    hexagon_V6_vmaxh,                          // llvm.hexagon.V6.vmaxh
+    hexagon_V6_vmaxh_128B,                     // llvm.hexagon.V6.vmaxh.128B
+    hexagon_V6_vmaxub,                         // llvm.hexagon.V6.vmaxub
+    hexagon_V6_vmaxub_128B,                    // llvm.hexagon.V6.vmaxub.128B
+    hexagon_V6_vmaxuh,                         // llvm.hexagon.V6.vmaxuh
+    hexagon_V6_vmaxuh_128B,                    // llvm.hexagon.V6.vmaxuh.128B
+    hexagon_V6_vmaxw,                          // llvm.hexagon.V6.vmaxw
+    hexagon_V6_vmaxw_128B,                     // llvm.hexagon.V6.vmaxw.128B
+    hexagon_V6_vminb,                          // llvm.hexagon.V6.vminb
+    hexagon_V6_vminb_128B,                     // llvm.hexagon.V6.vminb.128B
+    hexagon_V6_vminh,                          // llvm.hexagon.V6.vminh
+    hexagon_V6_vminh_128B,                     // llvm.hexagon.V6.vminh.128B
+    hexagon_V6_vminub,                         // llvm.hexagon.V6.vminub
+    hexagon_V6_vminub_128B,                    // llvm.hexagon.V6.vminub.128B
+    hexagon_V6_vminuh,                         // llvm.hexagon.V6.vminuh
+    hexagon_V6_vminuh_128B,                    // llvm.hexagon.V6.vminuh.128B
+    hexagon_V6_vminw,                          // llvm.hexagon.V6.vminw
+    hexagon_V6_vminw_128B,                     // llvm.hexagon.V6.vminw.128B
+    hexagon_V6_vmpabus,                        // llvm.hexagon.V6.vmpabus
+    hexagon_V6_vmpabus_128B,                   // llvm.hexagon.V6.vmpabus.128B
+    hexagon_V6_vmpabus_acc,                    // llvm.hexagon.V6.vmpabus.acc
+    hexagon_V6_vmpabus_acc_128B,               // llvm.hexagon.V6.vmpabus.acc.128B
+    hexagon_V6_vmpabusv,                       // llvm.hexagon.V6.vmpabusv
+    hexagon_V6_vmpabusv_128B,                  // llvm.hexagon.V6.vmpabusv.128B
+    hexagon_V6_vmpabuu,                        // llvm.hexagon.V6.vmpabuu
+    hexagon_V6_vmpabuu_128B,                   // llvm.hexagon.V6.vmpabuu.128B
+    hexagon_V6_vmpabuu_acc,                    // llvm.hexagon.V6.vmpabuu.acc
+    hexagon_V6_vmpabuu_acc_128B,               // llvm.hexagon.V6.vmpabuu.acc.128B
+    hexagon_V6_vmpabuuv,                       // llvm.hexagon.V6.vmpabuuv
+    hexagon_V6_vmpabuuv_128B,                  // llvm.hexagon.V6.vmpabuuv.128B
+    hexagon_V6_vmpahb,                         // llvm.hexagon.V6.vmpahb
+    hexagon_V6_vmpahb_128B,                    // llvm.hexagon.V6.vmpahb.128B
+    hexagon_V6_vmpahb_acc,                     // llvm.hexagon.V6.vmpahb.acc
+    hexagon_V6_vmpahb_acc_128B,                // llvm.hexagon.V6.vmpahb.acc.128B
+    hexagon_V6_vmpahhsat,                      // llvm.hexagon.V6.vmpahhsat
+    hexagon_V6_vmpahhsat_128B,                 // llvm.hexagon.V6.vmpahhsat.128B
+    hexagon_V6_vmpauhb,                        // llvm.hexagon.V6.vmpauhb
+    hexagon_V6_vmpauhb_128B,                   // llvm.hexagon.V6.vmpauhb.128B
+    hexagon_V6_vmpauhb_acc,                    // llvm.hexagon.V6.vmpauhb.acc
+    hexagon_V6_vmpauhb_acc_128B,               // llvm.hexagon.V6.vmpauhb.acc.128B
+    hexagon_V6_vmpauhuhsat,                    // llvm.hexagon.V6.vmpauhuhsat
+    hexagon_V6_vmpauhuhsat_128B,               // llvm.hexagon.V6.vmpauhuhsat.128B
+    hexagon_V6_vmpsuhuhsat,                    // llvm.hexagon.V6.vmpsuhuhsat
+    hexagon_V6_vmpsuhuhsat_128B,               // llvm.hexagon.V6.vmpsuhuhsat.128B
+    hexagon_V6_vmpybus,                        // llvm.hexagon.V6.vmpybus
+    hexagon_V6_vmpybus_128B,                   // llvm.hexagon.V6.vmpybus.128B
+    hexagon_V6_vmpybus_acc,                    // llvm.hexagon.V6.vmpybus.acc
+    hexagon_V6_vmpybus_acc_128B,               // llvm.hexagon.V6.vmpybus.acc.128B
+    hexagon_V6_vmpybusv,                       // llvm.hexagon.V6.vmpybusv
+    hexagon_V6_vmpybusv_128B,                  // llvm.hexagon.V6.vmpybusv.128B
+    hexagon_V6_vmpybusv_acc,                   // llvm.hexagon.V6.vmpybusv.acc
+    hexagon_V6_vmpybusv_acc_128B,              // llvm.hexagon.V6.vmpybusv.acc.128B
+    hexagon_V6_vmpybv,                         // llvm.hexagon.V6.vmpybv
+    hexagon_V6_vmpybv_128B,                    // llvm.hexagon.V6.vmpybv.128B
+    hexagon_V6_vmpybv_acc,                     // llvm.hexagon.V6.vmpybv.acc
+    hexagon_V6_vmpybv_acc_128B,                // llvm.hexagon.V6.vmpybv.acc.128B
+    hexagon_V6_vmpyewuh,                       // llvm.hexagon.V6.vmpyewuh
+    hexagon_V6_vmpyewuh_128B,                  // llvm.hexagon.V6.vmpyewuh.128B
+    hexagon_V6_vmpyewuh_64,                    // llvm.hexagon.V6.vmpyewuh.64
+    hexagon_V6_vmpyewuh_64_128B,               // llvm.hexagon.V6.vmpyewuh.64.128B
+    hexagon_V6_vmpyh,                          // llvm.hexagon.V6.vmpyh
+    hexagon_V6_vmpyh_128B,                     // llvm.hexagon.V6.vmpyh.128B
+    hexagon_V6_vmpyh_acc,                      // llvm.hexagon.V6.vmpyh.acc
+    hexagon_V6_vmpyh_acc_128B,                 // llvm.hexagon.V6.vmpyh.acc.128B
+    hexagon_V6_vmpyhsat_acc,                   // llvm.hexagon.V6.vmpyhsat.acc
+    hexagon_V6_vmpyhsat_acc_128B,              // llvm.hexagon.V6.vmpyhsat.acc.128B
+    hexagon_V6_vmpyhsrs,                       // llvm.hexagon.V6.vmpyhsrs
+    hexagon_V6_vmpyhsrs_128B,                  // llvm.hexagon.V6.vmpyhsrs.128B
+    hexagon_V6_vmpyhss,                        // llvm.hexagon.V6.vmpyhss
+    hexagon_V6_vmpyhss_128B,                   // llvm.hexagon.V6.vmpyhss.128B
+    hexagon_V6_vmpyhus,                        // llvm.hexagon.V6.vmpyhus
+    hexagon_V6_vmpyhus_128B,                   // llvm.hexagon.V6.vmpyhus.128B
+    hexagon_V6_vmpyhus_acc,                    // llvm.hexagon.V6.vmpyhus.acc
+    hexagon_V6_vmpyhus_acc_128B,               // llvm.hexagon.V6.vmpyhus.acc.128B
+    hexagon_V6_vmpyhv,                         // llvm.hexagon.V6.vmpyhv
+    hexagon_V6_vmpyhv_128B,                    // llvm.hexagon.V6.vmpyhv.128B
+    hexagon_V6_vmpyhv_acc,                     // llvm.hexagon.V6.vmpyhv.acc
+    hexagon_V6_vmpyhv_acc_128B,                // llvm.hexagon.V6.vmpyhv.acc.128B
+    hexagon_V6_vmpyhvsrs,                      // llvm.hexagon.V6.vmpyhvsrs
+    hexagon_V6_vmpyhvsrs_128B,                 // llvm.hexagon.V6.vmpyhvsrs.128B
+    hexagon_V6_vmpyieoh,                       // llvm.hexagon.V6.vmpyieoh
+    hexagon_V6_vmpyieoh_128B,                  // llvm.hexagon.V6.vmpyieoh.128B
+    hexagon_V6_vmpyiewh_acc,                   // llvm.hexagon.V6.vmpyiewh.acc
+    hexagon_V6_vmpyiewh_acc_128B,              // llvm.hexagon.V6.vmpyiewh.acc.128B
+    hexagon_V6_vmpyiewuh,                      // llvm.hexagon.V6.vmpyiewuh
+    hexagon_V6_vmpyiewuh_128B,                 // llvm.hexagon.V6.vmpyiewuh.128B
+    hexagon_V6_vmpyiewuh_acc,                  // llvm.hexagon.V6.vmpyiewuh.acc
+    hexagon_V6_vmpyiewuh_acc_128B,             // llvm.hexagon.V6.vmpyiewuh.acc.128B
+    hexagon_V6_vmpyih,                         // llvm.hexagon.V6.vmpyih
+    hexagon_V6_vmpyih_128B,                    // llvm.hexagon.V6.vmpyih.128B
+    hexagon_V6_vmpyih_acc,                     // llvm.hexagon.V6.vmpyih.acc
+    hexagon_V6_vmpyih_acc_128B,                // llvm.hexagon.V6.vmpyih.acc.128B
+    hexagon_V6_vmpyihb,                        // llvm.hexagon.V6.vmpyihb
+    hexagon_V6_vmpyihb_128B,                   // llvm.hexagon.V6.vmpyihb.128B
+    hexagon_V6_vmpyihb_acc,                    // llvm.hexagon.V6.vmpyihb.acc
+    hexagon_V6_vmpyihb_acc_128B,               // llvm.hexagon.V6.vmpyihb.acc.128B
+    hexagon_V6_vmpyiowh,                       // llvm.hexagon.V6.vmpyiowh
+    hexagon_V6_vmpyiowh_128B,                  // llvm.hexagon.V6.vmpyiowh.128B
+    hexagon_V6_vmpyiwb,                        // llvm.hexagon.V6.vmpyiwb
+    hexagon_V6_vmpyiwb_128B,                   // llvm.hexagon.V6.vmpyiwb.128B
+    hexagon_V6_vmpyiwb_acc,                    // llvm.hexagon.V6.vmpyiwb.acc
+    hexagon_V6_vmpyiwb_acc_128B,               // llvm.hexagon.V6.vmpyiwb.acc.128B
+    hexagon_V6_vmpyiwh,                        // llvm.hexagon.V6.vmpyiwh
+    hexagon_V6_vmpyiwh_128B,                   // llvm.hexagon.V6.vmpyiwh.128B
+    hexagon_V6_vmpyiwh_acc,                    // llvm.hexagon.V6.vmpyiwh.acc
+    hexagon_V6_vmpyiwh_acc_128B,               // llvm.hexagon.V6.vmpyiwh.acc.128B
+    hexagon_V6_vmpyiwub,                       // llvm.hexagon.V6.vmpyiwub
+    hexagon_V6_vmpyiwub_128B,                  // llvm.hexagon.V6.vmpyiwub.128B
+    hexagon_V6_vmpyiwub_acc,                   // llvm.hexagon.V6.vmpyiwub.acc
+    hexagon_V6_vmpyiwub_acc_128B,              // llvm.hexagon.V6.vmpyiwub.acc.128B
+    hexagon_V6_vmpyowh,                        // llvm.hexagon.V6.vmpyowh
+    hexagon_V6_vmpyowh_128B,                   // llvm.hexagon.V6.vmpyowh.128B
+    hexagon_V6_vmpyowh_64_acc,                 // llvm.hexagon.V6.vmpyowh.64.acc
+    hexagon_V6_vmpyowh_64_acc_128B,            // llvm.hexagon.V6.vmpyowh.64.acc.128B
+    hexagon_V6_vmpyowh_rnd,                    // llvm.hexagon.V6.vmpyowh.rnd
+    hexagon_V6_vmpyowh_rnd_128B,               // llvm.hexagon.V6.vmpyowh.rnd.128B
+    hexagon_V6_vmpyowh_rnd_sacc,               // llvm.hexagon.V6.vmpyowh.rnd.sacc
+    hexagon_V6_vmpyowh_rnd_sacc_128B,          // llvm.hexagon.V6.vmpyowh.rnd.sacc.128B
+    hexagon_V6_vmpyowh_sacc,                   // llvm.hexagon.V6.vmpyowh.sacc
+    hexagon_V6_vmpyowh_sacc_128B,              // llvm.hexagon.V6.vmpyowh.sacc.128B
+    hexagon_V6_vmpyub,                         // llvm.hexagon.V6.vmpyub
+    hexagon_V6_vmpyub_128B,                    // llvm.hexagon.V6.vmpyub.128B
+    hexagon_V6_vmpyub_acc,                     // llvm.hexagon.V6.vmpyub.acc
+    hexagon_V6_vmpyub_acc_128B,                // llvm.hexagon.V6.vmpyub.acc.128B
+    hexagon_V6_vmpyubv,                        // llvm.hexagon.V6.vmpyubv
+    hexagon_V6_vmpyubv_128B,                   // llvm.hexagon.V6.vmpyubv.128B
+    hexagon_V6_vmpyubv_acc,                    // llvm.hexagon.V6.vmpyubv.acc
+    hexagon_V6_vmpyubv_acc_128B,               // llvm.hexagon.V6.vmpyubv.acc.128B
+    hexagon_V6_vmpyuh,                         // llvm.hexagon.V6.vmpyuh
+    hexagon_V6_vmpyuh_128B,                    // llvm.hexagon.V6.vmpyuh.128B
+    hexagon_V6_vmpyuh_acc,                     // llvm.hexagon.V6.vmpyuh.acc
+    hexagon_V6_vmpyuh_acc_128B,                // llvm.hexagon.V6.vmpyuh.acc.128B
+    hexagon_V6_vmpyuhe,                        // llvm.hexagon.V6.vmpyuhe
+    hexagon_V6_vmpyuhe_128B,                   // llvm.hexagon.V6.vmpyuhe.128B
+    hexagon_V6_vmpyuhe_acc,                    // llvm.hexagon.V6.vmpyuhe.acc
+    hexagon_V6_vmpyuhe_acc_128B,               // llvm.hexagon.V6.vmpyuhe.acc.128B
+    hexagon_V6_vmpyuhv,                        // llvm.hexagon.V6.vmpyuhv
+    hexagon_V6_vmpyuhv_128B,                   // llvm.hexagon.V6.vmpyuhv.128B
+    hexagon_V6_vmpyuhv_acc,                    // llvm.hexagon.V6.vmpyuhv.acc
+    hexagon_V6_vmpyuhv_acc_128B,               // llvm.hexagon.V6.vmpyuhv.acc.128B
+    hexagon_V6_vmux,                           // llvm.hexagon.V6.vmux
+    hexagon_V6_vmux_128B,                      // llvm.hexagon.V6.vmux.128B
+    hexagon_V6_vnavgb,                         // llvm.hexagon.V6.vnavgb
+    hexagon_V6_vnavgb_128B,                    // llvm.hexagon.V6.vnavgb.128B
+    hexagon_V6_vnavgh,                         // llvm.hexagon.V6.vnavgh
+    hexagon_V6_vnavgh_128B,                    // llvm.hexagon.V6.vnavgh.128B
+    hexagon_V6_vnavgub,                        // llvm.hexagon.V6.vnavgub
+    hexagon_V6_vnavgub_128B,                   // llvm.hexagon.V6.vnavgub.128B
+    hexagon_V6_vnavgw,                         // llvm.hexagon.V6.vnavgw
+    hexagon_V6_vnavgw_128B,                    // llvm.hexagon.V6.vnavgw.128B
+    hexagon_V6_vnormamth,                      // llvm.hexagon.V6.vnormamth
+    hexagon_V6_vnormamth_128B,                 // llvm.hexagon.V6.vnormamth.128B
+    hexagon_V6_vnormamtw,                      // llvm.hexagon.V6.vnormamtw
+    hexagon_V6_vnormamtw_128B,                 // llvm.hexagon.V6.vnormamtw.128B
+    hexagon_V6_vnot,                           // llvm.hexagon.V6.vnot
+    hexagon_V6_vnot_128B,                      // llvm.hexagon.V6.vnot.128B
+    hexagon_V6_vor,                            // llvm.hexagon.V6.vor
+    hexagon_V6_vor_128B,                       // llvm.hexagon.V6.vor.128B
+    hexagon_V6_vpackeb,                        // llvm.hexagon.V6.vpackeb
+    hexagon_V6_vpackeb_128B,                   // llvm.hexagon.V6.vpackeb.128B
+    hexagon_V6_vpackeh,                        // llvm.hexagon.V6.vpackeh
+    hexagon_V6_vpackeh_128B,                   // llvm.hexagon.V6.vpackeh.128B
+    hexagon_V6_vpackhb_sat,                    // llvm.hexagon.V6.vpackhb.sat
+    hexagon_V6_vpackhb_sat_128B,               // llvm.hexagon.V6.vpackhb.sat.128B
+    hexagon_V6_vpackhub_sat,                   // llvm.hexagon.V6.vpackhub.sat
+    hexagon_V6_vpackhub_sat_128B,              // llvm.hexagon.V6.vpackhub.sat.128B
+    hexagon_V6_vpackob,                        // llvm.hexagon.V6.vpackob
+    hexagon_V6_vpackob_128B,                   // llvm.hexagon.V6.vpackob.128B
+    hexagon_V6_vpackoh,                        // llvm.hexagon.V6.vpackoh
+    hexagon_V6_vpackoh_128B,                   // llvm.hexagon.V6.vpackoh.128B
+    hexagon_V6_vpackwh_sat,                    // llvm.hexagon.V6.vpackwh.sat
+    hexagon_V6_vpackwh_sat_128B,               // llvm.hexagon.V6.vpackwh.sat.128B
+    hexagon_V6_vpackwuh_sat,                   // llvm.hexagon.V6.vpackwuh.sat
+    hexagon_V6_vpackwuh_sat_128B,              // llvm.hexagon.V6.vpackwuh.sat.128B
+    hexagon_V6_vpopcounth,                     // llvm.hexagon.V6.vpopcounth
+    hexagon_V6_vpopcounth_128B,                // llvm.hexagon.V6.vpopcounth.128B
+    hexagon_V6_vprefixqb,                      // llvm.hexagon.V6.vprefixqb
+    hexagon_V6_vprefixqb_128B,                 // llvm.hexagon.V6.vprefixqb.128B
+    hexagon_V6_vprefixqh,                      // llvm.hexagon.V6.vprefixqh
+    hexagon_V6_vprefixqh_128B,                 // llvm.hexagon.V6.vprefixqh.128B
+    hexagon_V6_vprefixqw,                      // llvm.hexagon.V6.vprefixqw
+    hexagon_V6_vprefixqw_128B,                 // llvm.hexagon.V6.vprefixqw.128B
+    hexagon_V6_vrdelta,                        // llvm.hexagon.V6.vrdelta
+    hexagon_V6_vrdelta_128B,                   // llvm.hexagon.V6.vrdelta.128B
+    hexagon_V6_vrmpybub_rtt,                   // llvm.hexagon.V6.vrmpybub.rtt
+    hexagon_V6_vrmpybub_rtt_128B,              // llvm.hexagon.V6.vrmpybub.rtt.128B
+    hexagon_V6_vrmpybub_rtt_acc,               // llvm.hexagon.V6.vrmpybub.rtt.acc
+    hexagon_V6_vrmpybub_rtt_acc_128B,          // llvm.hexagon.V6.vrmpybub.rtt.acc.128B
+    hexagon_V6_vrmpybus,                       // llvm.hexagon.V6.vrmpybus
+    hexagon_V6_vrmpybus_128B,                  // llvm.hexagon.V6.vrmpybus.128B
+    hexagon_V6_vrmpybus_acc,                   // llvm.hexagon.V6.vrmpybus.acc
+    hexagon_V6_vrmpybus_acc_128B,              // llvm.hexagon.V6.vrmpybus.acc.128B
+    hexagon_V6_vrmpybusi,                      // llvm.hexagon.V6.vrmpybusi
+    hexagon_V6_vrmpybusi_128B,                 // llvm.hexagon.V6.vrmpybusi.128B
+    hexagon_V6_vrmpybusi_acc,                  // llvm.hexagon.V6.vrmpybusi.acc
+    hexagon_V6_vrmpybusi_acc_128B,             // llvm.hexagon.V6.vrmpybusi.acc.128B
+    hexagon_V6_vrmpybusv,                      // llvm.hexagon.V6.vrmpybusv
+    hexagon_V6_vrmpybusv_128B,                 // llvm.hexagon.V6.vrmpybusv.128B
+    hexagon_V6_vrmpybusv_acc,                  // llvm.hexagon.V6.vrmpybusv.acc
+    hexagon_V6_vrmpybusv_acc_128B,             // llvm.hexagon.V6.vrmpybusv.acc.128B
+    hexagon_V6_vrmpybv,                        // llvm.hexagon.V6.vrmpybv
+    hexagon_V6_vrmpybv_128B,                   // llvm.hexagon.V6.vrmpybv.128B
+    hexagon_V6_vrmpybv_acc,                    // llvm.hexagon.V6.vrmpybv.acc
+    hexagon_V6_vrmpybv_acc_128B,               // llvm.hexagon.V6.vrmpybv.acc.128B
+    hexagon_V6_vrmpyub,                        // llvm.hexagon.V6.vrmpyub
+    hexagon_V6_vrmpyub_128B,                   // llvm.hexagon.V6.vrmpyub.128B
+    hexagon_V6_vrmpyub_acc,                    // llvm.hexagon.V6.vrmpyub.acc
+    hexagon_V6_vrmpyub_acc_128B,               // llvm.hexagon.V6.vrmpyub.acc.128B
+    hexagon_V6_vrmpyub_rtt,                    // llvm.hexagon.V6.vrmpyub.rtt
+    hexagon_V6_vrmpyub_rtt_128B,               // llvm.hexagon.V6.vrmpyub.rtt.128B
+    hexagon_V6_vrmpyub_rtt_acc,                // llvm.hexagon.V6.vrmpyub.rtt.acc
+    hexagon_V6_vrmpyub_rtt_acc_128B,           // llvm.hexagon.V6.vrmpyub.rtt.acc.128B
+    hexagon_V6_vrmpyubi,                       // llvm.hexagon.V6.vrmpyubi
+    hexagon_V6_vrmpyubi_128B,                  // llvm.hexagon.V6.vrmpyubi.128B
+    hexagon_V6_vrmpyubi_acc,                   // llvm.hexagon.V6.vrmpyubi.acc
+    hexagon_V6_vrmpyubi_acc_128B,              // llvm.hexagon.V6.vrmpyubi.acc.128B
+    hexagon_V6_vrmpyubv,                       // llvm.hexagon.V6.vrmpyubv
+    hexagon_V6_vrmpyubv_128B,                  // llvm.hexagon.V6.vrmpyubv.128B
+    hexagon_V6_vrmpyubv_acc,                   // llvm.hexagon.V6.vrmpyubv.acc
+    hexagon_V6_vrmpyubv_acc_128B,              // llvm.hexagon.V6.vrmpyubv.acc.128B
+    hexagon_V6_vror,                           // llvm.hexagon.V6.vror
+    hexagon_V6_vror_128B,                      // llvm.hexagon.V6.vror.128B
+    hexagon_V6_vrotr,                          // llvm.hexagon.V6.vrotr
+    hexagon_V6_vrotr_128B,                     // llvm.hexagon.V6.vrotr.128B
+    hexagon_V6_vroundhb,                       // llvm.hexagon.V6.vroundhb
+    hexagon_V6_vroundhb_128B,                  // llvm.hexagon.V6.vroundhb.128B
+    hexagon_V6_vroundhub,                      // llvm.hexagon.V6.vroundhub
+    hexagon_V6_vroundhub_128B,                 // llvm.hexagon.V6.vroundhub.128B
+    hexagon_V6_vrounduhub,                     // llvm.hexagon.V6.vrounduhub
+    hexagon_V6_vrounduhub_128B,                // llvm.hexagon.V6.vrounduhub.128B
+    hexagon_V6_vrounduwuh,                     // llvm.hexagon.V6.vrounduwuh
+    hexagon_V6_vrounduwuh_128B,                // llvm.hexagon.V6.vrounduwuh.128B
+    hexagon_V6_vroundwh,                       // llvm.hexagon.V6.vroundwh
+    hexagon_V6_vroundwh_128B,                  // llvm.hexagon.V6.vroundwh.128B
+    hexagon_V6_vroundwuh,                      // llvm.hexagon.V6.vroundwuh
+    hexagon_V6_vroundwuh_128B,                 // llvm.hexagon.V6.vroundwuh.128B
+    hexagon_V6_vrsadubi,                       // llvm.hexagon.V6.vrsadubi
+    hexagon_V6_vrsadubi_128B,                  // llvm.hexagon.V6.vrsadubi.128B
+    hexagon_V6_vrsadubi_acc,                   // llvm.hexagon.V6.vrsadubi.acc
+    hexagon_V6_vrsadubi_acc_128B,              // llvm.hexagon.V6.vrsadubi.acc.128B
+    hexagon_V6_vsatdw,                         // llvm.hexagon.V6.vsatdw
+    hexagon_V6_vsatdw_128B,                    // llvm.hexagon.V6.vsatdw.128B
+    hexagon_V6_vsathub,                        // llvm.hexagon.V6.vsathub
+    hexagon_V6_vsathub_128B,                   // llvm.hexagon.V6.vsathub.128B
+    hexagon_V6_vsatuwuh,                       // llvm.hexagon.V6.vsatuwuh
+    hexagon_V6_vsatuwuh_128B,                  // llvm.hexagon.V6.vsatuwuh.128B
+    hexagon_V6_vsatwh,                         // llvm.hexagon.V6.vsatwh
+    hexagon_V6_vsatwh_128B,                    // llvm.hexagon.V6.vsatwh.128B
+    hexagon_V6_vsb,                            // llvm.hexagon.V6.vsb
+    hexagon_V6_vsb_128B,                       // llvm.hexagon.V6.vsb.128B
+    hexagon_V6_vscattermh,                     // llvm.hexagon.V6.vscattermh
+    hexagon_V6_vscattermh_128B,                // llvm.hexagon.V6.vscattermh.128B
+    hexagon_V6_vscattermh_add,                 // llvm.hexagon.V6.vscattermh.add
+    hexagon_V6_vscattermh_add_128B,            // llvm.hexagon.V6.vscattermh.add.128B
+    hexagon_V6_vscattermhq,                    // llvm.hexagon.V6.vscattermhq
+    hexagon_V6_vscattermhq_128B,               // llvm.hexagon.V6.vscattermhq.128B
+    hexagon_V6_vscattermhw,                    // llvm.hexagon.V6.vscattermhw
+    hexagon_V6_vscattermhw_128B,               // llvm.hexagon.V6.vscattermhw.128B
+    hexagon_V6_vscattermhw_add,                // llvm.hexagon.V6.vscattermhw.add
+    hexagon_V6_vscattermhw_add_128B,           // llvm.hexagon.V6.vscattermhw.add.128B
+    hexagon_V6_vscattermhwq,                   // llvm.hexagon.V6.vscattermhwq
+    hexagon_V6_vscattermhwq_128B,              // llvm.hexagon.V6.vscattermhwq.128B
+    hexagon_V6_vscattermw,                     // llvm.hexagon.V6.vscattermw
+    hexagon_V6_vscattermw_128B,                // llvm.hexagon.V6.vscattermw.128B
+    hexagon_V6_vscattermw_add,                 // llvm.hexagon.V6.vscattermw.add
+    hexagon_V6_vscattermw_add_128B,            // llvm.hexagon.V6.vscattermw.add.128B
+    hexagon_V6_vscattermwq,                    // llvm.hexagon.V6.vscattermwq
+    hexagon_V6_vscattermwq_128B,               // llvm.hexagon.V6.vscattermwq.128B
+    hexagon_V6_vsh,                            // llvm.hexagon.V6.vsh
+    hexagon_V6_vsh_128B,                       // llvm.hexagon.V6.vsh.128B
+    hexagon_V6_vshufeh,                        // llvm.hexagon.V6.vshufeh
+    hexagon_V6_vshufeh_128B,                   // llvm.hexagon.V6.vshufeh.128B
+    hexagon_V6_vshuffb,                        // llvm.hexagon.V6.vshuffb
+    hexagon_V6_vshuffb_128B,                   // llvm.hexagon.V6.vshuffb.128B
+    hexagon_V6_vshuffeb,                       // llvm.hexagon.V6.vshuffeb
+    hexagon_V6_vshuffeb_128B,                  // llvm.hexagon.V6.vshuffeb.128B
+    hexagon_V6_vshuffh,                        // llvm.hexagon.V6.vshuffh
+    hexagon_V6_vshuffh_128B,                   // llvm.hexagon.V6.vshuffh.128B
+    hexagon_V6_vshuffob,                       // llvm.hexagon.V6.vshuffob
+    hexagon_V6_vshuffob_128B,                  // llvm.hexagon.V6.vshuffob.128B
+    hexagon_V6_vshuffvdd,                      // llvm.hexagon.V6.vshuffvdd
+    hexagon_V6_vshuffvdd_128B,                 // llvm.hexagon.V6.vshuffvdd.128B
+    hexagon_V6_vshufoeb,                       // llvm.hexagon.V6.vshufoeb
+    hexagon_V6_vshufoeb_128B,                  // llvm.hexagon.V6.vshufoeb.128B
+    hexagon_V6_vshufoeh,                       // llvm.hexagon.V6.vshufoeh
+    hexagon_V6_vshufoeh_128B,                  // llvm.hexagon.V6.vshufoeh.128B
+    hexagon_V6_vshufoh,                        // llvm.hexagon.V6.vshufoh
+    hexagon_V6_vshufoh_128B,                   // llvm.hexagon.V6.vshufoh.128B
+    hexagon_V6_vsubb,                          // llvm.hexagon.V6.vsubb
+    hexagon_V6_vsubb_128B,                     // llvm.hexagon.V6.vsubb.128B
+    hexagon_V6_vsubb_dv,                       // llvm.hexagon.V6.vsubb.dv
+    hexagon_V6_vsubb_dv_128B,                  // llvm.hexagon.V6.vsubb.dv.128B
+    hexagon_V6_vsubbnq,                        // llvm.hexagon.V6.vsubbnq
+    hexagon_V6_vsubbnq_128B,                   // llvm.hexagon.V6.vsubbnq.128B
+    hexagon_V6_vsubbq,                         // llvm.hexagon.V6.vsubbq
+    hexagon_V6_vsubbq_128B,                    // llvm.hexagon.V6.vsubbq.128B
+    hexagon_V6_vsubbsat,                       // llvm.hexagon.V6.vsubbsat
+    hexagon_V6_vsubbsat_128B,                  // llvm.hexagon.V6.vsubbsat.128B
+    hexagon_V6_vsubbsat_dv,                    // llvm.hexagon.V6.vsubbsat.dv
+    hexagon_V6_vsubbsat_dv_128B,               // llvm.hexagon.V6.vsubbsat.dv.128B
+    hexagon_V6_vsubcarry,                      // llvm.hexagon.V6.vsubcarry
+    hexagon_V6_vsubcarry_128B,                 // llvm.hexagon.V6.vsubcarry.128B
+    hexagon_V6_vsubh,                          // llvm.hexagon.V6.vsubh
+    hexagon_V6_vsubh_128B,                     // llvm.hexagon.V6.vsubh.128B
+    hexagon_V6_vsubh_dv,                       // llvm.hexagon.V6.vsubh.dv
+    hexagon_V6_vsubh_dv_128B,                  // llvm.hexagon.V6.vsubh.dv.128B
+    hexagon_V6_vsubhnq,                        // llvm.hexagon.V6.vsubhnq
+    hexagon_V6_vsubhnq_128B,                   // llvm.hexagon.V6.vsubhnq.128B
+    hexagon_V6_vsubhq,                         // llvm.hexagon.V6.vsubhq
+    hexagon_V6_vsubhq_128B,                    // llvm.hexagon.V6.vsubhq.128B
+    hexagon_V6_vsubhsat,                       // llvm.hexagon.V6.vsubhsat
+    hexagon_V6_vsubhsat_128B,                  // llvm.hexagon.V6.vsubhsat.128B
+    hexagon_V6_vsubhsat_dv,                    // llvm.hexagon.V6.vsubhsat.dv
+    hexagon_V6_vsubhsat_dv_128B,               // llvm.hexagon.V6.vsubhsat.dv.128B
+    hexagon_V6_vsubhw,                         // llvm.hexagon.V6.vsubhw
+    hexagon_V6_vsubhw_128B,                    // llvm.hexagon.V6.vsubhw.128B
+    hexagon_V6_vsububh,                        // llvm.hexagon.V6.vsububh
+    hexagon_V6_vsububh_128B,                   // llvm.hexagon.V6.vsububh.128B
+    hexagon_V6_vsububsat,                      // llvm.hexagon.V6.vsububsat
+    hexagon_V6_vsububsat_128B,                 // llvm.hexagon.V6.vsububsat.128B
+    hexagon_V6_vsububsat_dv,                   // llvm.hexagon.V6.vsububsat.dv
+    hexagon_V6_vsububsat_dv_128B,              // llvm.hexagon.V6.vsububsat.dv.128B
+    hexagon_V6_vsubububb_sat,                  // llvm.hexagon.V6.vsubububb.sat
+    hexagon_V6_vsubububb_sat_128B,             // llvm.hexagon.V6.vsubububb.sat.128B
+    hexagon_V6_vsubuhsat,                      // llvm.hexagon.V6.vsubuhsat
+    hexagon_V6_vsubuhsat_128B,                 // llvm.hexagon.V6.vsubuhsat.128B
+    hexagon_V6_vsubuhsat_dv,                   // llvm.hexagon.V6.vsubuhsat.dv
+    hexagon_V6_vsubuhsat_dv_128B,              // llvm.hexagon.V6.vsubuhsat.dv.128B
+    hexagon_V6_vsubuhw,                        // llvm.hexagon.V6.vsubuhw
+    hexagon_V6_vsubuhw_128B,                   // llvm.hexagon.V6.vsubuhw.128B
+    hexagon_V6_vsubuwsat,                      // llvm.hexagon.V6.vsubuwsat
+    hexagon_V6_vsubuwsat_128B,                 // llvm.hexagon.V6.vsubuwsat.128B
+    hexagon_V6_vsubuwsat_dv,                   // llvm.hexagon.V6.vsubuwsat.dv
+    hexagon_V6_vsubuwsat_dv_128B,              // llvm.hexagon.V6.vsubuwsat.dv.128B
+    hexagon_V6_vsubw,                          // llvm.hexagon.V6.vsubw
+    hexagon_V6_vsubw_128B,                     // llvm.hexagon.V6.vsubw.128B
+    hexagon_V6_vsubw_dv,                       // llvm.hexagon.V6.vsubw.dv
+    hexagon_V6_vsubw_dv_128B,                  // llvm.hexagon.V6.vsubw.dv.128B
+    hexagon_V6_vsubwnq,                        // llvm.hexagon.V6.vsubwnq
+    hexagon_V6_vsubwnq_128B,                   // llvm.hexagon.V6.vsubwnq.128B
+    hexagon_V6_vsubwq,                         // llvm.hexagon.V6.vsubwq
+    hexagon_V6_vsubwq_128B,                    // llvm.hexagon.V6.vsubwq.128B
+    hexagon_V6_vsubwsat,                       // llvm.hexagon.V6.vsubwsat
+    hexagon_V6_vsubwsat_128B,                  // llvm.hexagon.V6.vsubwsat.128B
+    hexagon_V6_vsubwsat_dv,                    // llvm.hexagon.V6.vsubwsat.dv
+    hexagon_V6_vsubwsat_dv_128B,               // llvm.hexagon.V6.vsubwsat.dv.128B
+    hexagon_V6_vswap,                          // llvm.hexagon.V6.vswap
+    hexagon_V6_vswap_128B,                     // llvm.hexagon.V6.vswap.128B
+    hexagon_V6_vtmpyb,                         // llvm.hexagon.V6.vtmpyb
+    hexagon_V6_vtmpyb_128B,                    // llvm.hexagon.V6.vtmpyb.128B
+    hexagon_V6_vtmpyb_acc,                     // llvm.hexagon.V6.vtmpyb.acc
+    hexagon_V6_vtmpyb_acc_128B,                // llvm.hexagon.V6.vtmpyb.acc.128B
+    hexagon_V6_vtmpybus,                       // llvm.hexagon.V6.vtmpybus
+    hexagon_V6_vtmpybus_128B,                  // llvm.hexagon.V6.vtmpybus.128B
+    hexagon_V6_vtmpybus_acc,                   // llvm.hexagon.V6.vtmpybus.acc
+    hexagon_V6_vtmpybus_acc_128B,              // llvm.hexagon.V6.vtmpybus.acc.128B
+    hexagon_V6_vtmpyhb,                        // llvm.hexagon.V6.vtmpyhb
+    hexagon_V6_vtmpyhb_128B,                   // llvm.hexagon.V6.vtmpyhb.128B
+    hexagon_V6_vtmpyhb_acc,                    // llvm.hexagon.V6.vtmpyhb.acc
+    hexagon_V6_vtmpyhb_acc_128B,               // llvm.hexagon.V6.vtmpyhb.acc.128B
+    hexagon_V6_vunpackb,                       // llvm.hexagon.V6.vunpackb
+    hexagon_V6_vunpackb_128B,                  // llvm.hexagon.V6.vunpackb.128B
+    hexagon_V6_vunpackh,                       // llvm.hexagon.V6.vunpackh
+    hexagon_V6_vunpackh_128B,                  // llvm.hexagon.V6.vunpackh.128B
+    hexagon_V6_vunpackob,                      // llvm.hexagon.V6.vunpackob
+    hexagon_V6_vunpackob_128B,                 // llvm.hexagon.V6.vunpackob.128B
+    hexagon_V6_vunpackoh,                      // llvm.hexagon.V6.vunpackoh
+    hexagon_V6_vunpackoh_128B,                 // llvm.hexagon.V6.vunpackoh.128B
+    hexagon_V6_vunpackub,                      // llvm.hexagon.V6.vunpackub
+    hexagon_V6_vunpackub_128B,                 // llvm.hexagon.V6.vunpackub.128B
+    hexagon_V6_vunpackuh,                      // llvm.hexagon.V6.vunpackuh
+    hexagon_V6_vunpackuh_128B,                 // llvm.hexagon.V6.vunpackuh.128B
+    hexagon_V6_vxor,                           // llvm.hexagon.V6.vxor
+    hexagon_V6_vxor_128B,                      // llvm.hexagon.V6.vxor.128B
+    hexagon_V6_vzb,                            // llvm.hexagon.V6.vzb
+    hexagon_V6_vzb_128B,                       // llvm.hexagon.V6.vzb.128B
+    hexagon_V6_vzh,                            // llvm.hexagon.V6.vzh
+    hexagon_V6_vzh_128B,                       // llvm.hexagon.V6.vzh.128B
+    hexagon_Y2_dccleana,                       // llvm.hexagon.Y2.dccleana
+    hexagon_Y2_dccleaninva,                    // llvm.hexagon.Y2.dccleaninva
+    hexagon_Y2_dcfetch,                        // llvm.hexagon.Y2.dcfetch
+    hexagon_Y2_dcinva,                         // llvm.hexagon.Y2.dcinva
+    hexagon_Y2_dczeroa,                        // llvm.hexagon.Y2.dczeroa
+    hexagon_Y4_l2fetch,                        // llvm.hexagon.Y4.l2fetch
+    hexagon_Y5_l2fetch,                        // llvm.hexagon.Y5.l2fetch
+    hexagon_circ_ldb,                          // llvm.hexagon.circ.ldb
+    hexagon_circ_ldd,                          // llvm.hexagon.circ.ldd
+    hexagon_circ_ldh,                          // llvm.hexagon.circ.ldh
+    hexagon_circ_ldub,                         // llvm.hexagon.circ.ldub
+    hexagon_circ_lduh,                         // llvm.hexagon.circ.lduh
+    hexagon_circ_ldw,                          // llvm.hexagon.circ.ldw
+    hexagon_circ_stb,                          // llvm.hexagon.circ.stb
+    hexagon_circ_std,                          // llvm.hexagon.circ.std
+    hexagon_circ_sth,                          // llvm.hexagon.circ.sth
+    hexagon_circ_sthhi,                        // llvm.hexagon.circ.sthhi
+    hexagon_circ_stw,                          // llvm.hexagon.circ.stw
+    hexagon_prefetch,                          // llvm.hexagon.prefetch
+    hexagon_vmemcpy,                           // llvm.hexagon.vmemcpy
+    hexagon_vmemset,                           // llvm.hexagon.vmemset
+}; // enum
+} // namespace Intrinsic
+} // namespace llvm
+
+#endif
diff --git a/linux-x64/clang/include/llvm/IR/IntrinsicsHexagon.td b/linux-x64/clang/include/llvm/IR/IntrinsicsHexagon.td
index 2abc1dc..fe16a36 100644
--- a/linux-x64/clang/include/llvm/IR/IntrinsicsHexagon.td
+++ b/linux-x64/clang/include/llvm/IR/IntrinsicsHexagon.td
@@ -51,19 +51,19 @@
   : Hexagon_Intrinsic<GCCIntSuffix,
                           [llvm_ptr_ty], [llvm_ptr_ty, llvm_ptr_ty,
                            llvm_i32_ty, llvm_i32_ty],
-                          [IntrArgMemOnly, ImmArg<3>]>;
+                          [IntrArgMemOnly, ImmArg<ArgIndex<3>>]>;
 
 class Hexagon_mem_memsisisi_Intrinsic<string GCCIntSuffix>
   : Hexagon_Intrinsic<GCCIntSuffix,
                           [llvm_ptr_ty], [llvm_ptr_ty, llvm_i32_ty,
                            llvm_i32_ty, llvm_i32_ty],
-                          [IntrWriteMem, ImmArg<3>]>;
+                          [IntrWriteMem, ImmArg<ArgIndex<3>>]>;
 
 class Hexagon_mem_memdisisi_Intrinsic<string GCCIntSuffix>
   : Hexagon_Intrinsic<GCCIntSuffix,
                           [llvm_ptr_ty], [llvm_ptr_ty, llvm_i64_ty,
                            llvm_i32_ty, llvm_i32_ty],
-                          [IntrWriteMem, ImmArg<3>]>;
+                          [IntrWriteMem, ImmArg<ArgIndex<3>>]>;
 
 //
 // BUILTIN_INFO_NONCONST(circ_ldd,PTR_ftype_PTRPTRSISI,4)
@@ -122,24 +122,8 @@
 def int_hexagon_circ_stb :
 Hexagon_mem_memsisisi_Intrinsic<"circ_stb">;
 
-//
-// BUILTIN_INFO(HEXAGON.dcfetch_A,v_ftype_DI*,1)
-//
 def int_hexagon_prefetch :
 Hexagon_Intrinsic<"HEXAGON_prefetch", [], [llvm_ptr_ty], []>;
-def int_hexagon_Y2_dccleana :
-Hexagon_Intrinsic<"HEXAGON_Y2_dccleana", [], [llvm_ptr_ty], []>;
-def int_hexagon_Y2_dccleaninva :
-Hexagon_Intrinsic<"HEXAGON_Y2_dccleaninva", [], [llvm_ptr_ty], []>;
-def int_hexagon_Y2_dcinva :
-Hexagon_Intrinsic<"HEXAGON_Y2_dcinva", [], [llvm_ptr_ty], []>;
-def int_hexagon_Y2_dczeroa :
-Hexagon_Intrinsic<"HEXAGON_Y2_dczeroa", [], [llvm_ptr_ty],
-      [IntrWriteMem, IntrArgMemOnly, IntrHasSideEffects]>;
-def int_hexagon_Y4_l2fetch :
-Hexagon_Intrinsic<"HEXAGON_Y4_l2fetch", [], [llvm_ptr_ty, llvm_i32_ty], []>;
-def int_hexagon_Y5_l2fetch :
-Hexagon_Intrinsic<"HEXAGON_Y5_l2fetch", [], [llvm_ptr_ty, llvm_i64_ty], []>;
 
 def llvm_ptr32_ty : LLVMPointerType<llvm_i32_ty>;
 def llvm_ptr64_ty : LLVMPointerType<llvm_i64_ty>;
@@ -147,34 +131,34 @@
 // Mark locked loads as read/write to prevent any accidental reordering.
 def int_hexagon_L2_loadw_locked :
 Hexagon_Intrinsic<"HEXAGON_L2_loadw_locked", [llvm_i32_ty], [llvm_ptr32_ty],
-      [IntrArgMemOnly, NoCapture<0>]>;
+      [IntrArgMemOnly, NoCapture<ArgIndex<0>>]>;
 def int_hexagon_L4_loadd_locked :
 Hexagon_Intrinsic<"HEXAGON_L4_loadd_locked", [llvm_i64_ty], [llvm_ptr64_ty],
-      [IntrArgMemOnly, NoCapture<0>]>;
+      [IntrArgMemOnly, NoCapture<ArgIndex<0>>]>;
 
 def int_hexagon_S2_storew_locked :
 Hexagon_Intrinsic<"HEXAGON_S2_storew_locked", [llvm_i32_ty],
-      [llvm_ptr32_ty, llvm_i32_ty], [IntrArgMemOnly, NoCapture<0>]>;
+      [llvm_ptr32_ty, llvm_i32_ty], [IntrArgMemOnly, NoCapture<ArgIndex<0>>]>;
 def int_hexagon_S4_stored_locked :
 Hexagon_Intrinsic<"HEXAGON_S4_stored_locked", [llvm_i32_ty],
-      [llvm_ptr64_ty, llvm_i64_ty], [IntrArgMemOnly, NoCapture<0>]>;
+      [llvm_ptr64_ty, llvm_i64_ty], [IntrArgMemOnly, NoCapture<ArgIndex<0>>]>;
 
 def int_hexagon_vmemcpy : Hexagon_Intrinsic<"hexagon_vmemcpy",
     [], [llvm_ptr_ty, llvm_ptr_ty, llvm_i32_ty],
-    [IntrArgMemOnly, NoCapture<0>, NoCapture<1>, WriteOnly<0>, ReadOnly<1>]>;
+    [IntrArgMemOnly, NoCapture<ArgIndex<0>>, NoCapture<ArgIndex<1>>, WriteOnly<ArgIndex<0>>, ReadOnly<ArgIndex<1>>]>;
 
 def int_hexagon_vmemset : Hexagon_Intrinsic<"hexagon_vmemset",
     [], [llvm_ptr_ty, llvm_i32_ty, llvm_i32_ty],
-    [IntrArgMemOnly, NoCapture<0>, WriteOnly<0>]>;
+    [IntrArgMemOnly, NoCapture<ArgIndex<0>>, WriteOnly<ArgIndex<0>>]>;
 
 multiclass Hexagon_custom_circ_ld_Intrinsic<LLVMType ElTy> {
   def NAME#_pci : Hexagon_NonGCC_Intrinsic<
     [ElTy, llvm_ptr_ty],
     [llvm_ptr_ty, llvm_i32_ty, llvm_i32_ty, llvm_ptr_ty],
-    [IntrArgMemOnly, NoCapture<3>]>;
+    [IntrArgMemOnly, NoCapture<ArgIndex<3>>]>;
   def NAME#_pcr : Hexagon_NonGCC_Intrinsic<
     [ElTy, llvm_ptr_ty], [llvm_ptr_ty, llvm_i32_ty, llvm_ptr_ty],
-    [IntrArgMemOnly, NoCapture<2>]>;
+    [IntrArgMemOnly, NoCapture<ArgIndex<2>>]>;
 }
 
 defm int_hexagon_L2_loadrub : Hexagon_custom_circ_ld_Intrinsic<llvm_i32_ty>;
@@ -188,10 +172,10 @@
   def NAME#_pci : Hexagon_NonGCC_Intrinsic<
     [llvm_ptr_ty],
     [llvm_ptr_ty, llvm_i32_ty, llvm_i32_ty, ElTy, llvm_ptr_ty],
-    [IntrArgMemOnly, NoCapture<4>]>;
+    [IntrArgMemOnly, NoCapture<ArgIndex<4>>]>;
   def NAME#_pcr : Hexagon_NonGCC_Intrinsic<
     [llvm_ptr_ty], [llvm_ptr_ty, llvm_i32_ty, ElTy, llvm_ptr_ty],
-    [IntrArgMemOnly, NoCapture<3>]>;
+    [IntrArgMemOnly, NoCapture<ArgIndex<3>>]>;
 }
 
 defm int_hexagon_S2_storerb : Hexagon_custom_circ_st_Intrinsic<llvm_i32_ty>;
@@ -221,6157 +205,83 @@
 def int_hexagon_S2_storeri_pbr : Hexagon_mem_memsisi_Intrinsic<"brev_stw">;
 def int_hexagon_S2_storerd_pbr : Hexagon_mem_memdisi_Intrinsic<"brev_std">;
 
-//
-// Masked vector stores
-//
-
-//
-// Hexagon_vv64ivmemv512_Intrinsic<string GCCIntSuffix>
-// tag: V6_vS32b_qpred_ai
-class Hexagon_vv64ivmemv512_Intrinsic<string GCCIntSuffix>
- : Hexagon_Intrinsic<GCCIntSuffix,
-                          [], [llvm_v512i1_ty,llvm_ptr_ty,llvm_v16i32_ty],
-                          [IntrArgMemOnly]>;
-
-//
-// Hexagon_vv128ivmemv1024_Intrinsic<string GCCIntSuffix>
-// tag: V6_vS32b_qpred_ai_128B
-class Hexagon_vv128ivmemv1024_Intrinsic<string GCCIntSuffix>
- : Hexagon_Intrinsic<GCCIntSuffix,
-                          [], [llvm_v1024i1_ty,llvm_ptr_ty,llvm_v32i32_ty],
-                          [IntrArgMemOnly]>;
-
-def int_hexagon_V6_vS32b_qpred_ai :
-Hexagon_vv64ivmemv512_Intrinsic<"HEXAGON_V6_vS32b_qpred_ai">;
-
-def int_hexagon_V6_vS32b_nqpred_ai :
-Hexagon_vv64ivmemv512_Intrinsic<"HEXAGON_V6_vS32b_nqpred_ai">;
-
-def int_hexagon_V6_vS32b_nt_qpred_ai :
-Hexagon_vv64ivmemv512_Intrinsic<"HEXAGON_V6_vS32b_nt_qpred_ai">;
-
-def int_hexagon_V6_vS32b_nt_nqpred_ai :
-Hexagon_vv64ivmemv512_Intrinsic<"HEXAGON_V6_vS32b_nt_nqpred_ai">;
-
-def int_hexagon_V6_vS32b_qpred_ai_128B :
-Hexagon_vv128ivmemv1024_Intrinsic<"HEXAGON_V6_vS32b_qpred_ai_128B">;
-
-def int_hexagon_V6_vS32b_nqpred_ai_128B :
-Hexagon_vv128ivmemv1024_Intrinsic<"HEXAGON_V6_vS32b_nqpred_ai_128B">;
-
-def int_hexagon_V6_vS32b_nt_qpred_ai_128B :
-Hexagon_vv128ivmemv1024_Intrinsic<"HEXAGON_V6_vS32b_nt_qpred_ai_128B">;
-
-def int_hexagon_V6_vS32b_nt_nqpred_ai_128B :
-Hexagon_vv128ivmemv1024_Intrinsic<"HEXAGON_V6_vS32b_nt_nqpred_ai_128B">;
-
-def int_hexagon_V6_vmaskedstoreq :
-Hexagon_vv64ivmemv512_Intrinsic<"HEXAGON_V6_vmaskedstoreq">;
-
-def int_hexagon_V6_vmaskedstorenq :
-Hexagon_vv64ivmemv512_Intrinsic<"HEXAGON_V6_vmaskedstorenq">;
-
-def int_hexagon_V6_vmaskedstorentq :
-Hexagon_vv64ivmemv512_Intrinsic<"HEXAGON_V6_vmaskedstorentq">;
-
-def int_hexagon_V6_vmaskedstorentnq :
-Hexagon_vv64ivmemv512_Intrinsic<"HEXAGON_V6_vmaskedstorentnq">;
-
-def int_hexagon_V6_vmaskedstoreq_128B :
-Hexagon_vv128ivmemv1024_Intrinsic<"HEXAGON_V6_vmaskedstoreq_128B">;
-
-def int_hexagon_V6_vmaskedstorenq_128B :
-Hexagon_vv128ivmemv1024_Intrinsic<"HEXAGON_V6_vmaskedstorenq_128B">;
-
-def int_hexagon_V6_vmaskedstorentq_128B :
-Hexagon_vv128ivmemv1024_Intrinsic<"HEXAGON_V6_vmaskedstorentq_128B">;
-
-def int_hexagon_V6_vmaskedstorentnq_128B :
-Hexagon_vv128ivmemv1024_Intrinsic<"HEXAGON_V6_vmaskedstorentnq_128B">;
-
-class Hexagon_V65_vvmemiiv512_Intrinsic<string GCCIntSuffix>
- : Hexagon_Intrinsic<GCCIntSuffix,
-                          [], [llvm_ptr_ty,llvm_i32_ty,llvm_i32_ty,
-                               llvm_v16i32_ty],
-                          [IntrArgMemOnly]>;
-
-class Hexagon_V65_vvmemiiv1024_Intrinsic<string GCCIntSuffix>
- : Hexagon_Intrinsic<GCCIntSuffix,
-                          [], [llvm_ptr_ty,llvm_i32_ty,llvm_i32_ty,
-                               llvm_v32i32_ty],
-                          [IntrArgMemOnly]>;
-
-class Hexagon_V65_vvmemiiv2048_Intrinsic<string GCCIntSuffix>
- : Hexagon_Intrinsic<GCCIntSuffix,
-                          [], [llvm_ptr_ty,llvm_i32_ty,llvm_i32_ty,
-                               llvm_v64i32_ty],
-                          [IntrArgMemOnly]>;
-
-class Hexagon_V65_vvmemv64iiiv512_Intrinsic<string GCCIntSuffix>
- : Hexagon_Intrinsic<GCCIntSuffix,
-                          [], [llvm_ptr_ty,llvm_v512i1_ty,llvm_i32_ty,
-                               llvm_i32_ty,llvm_v16i32_ty],
-                          [IntrArgMemOnly]>;
-
-class Hexagon_V65_vvmemv128iiiv1024_Intrinsic<string GCCIntSuffix>
- : Hexagon_Intrinsic<GCCIntSuffix,
-                          [], [llvm_ptr_ty,llvm_v1024i1_ty,llvm_i32_ty,
-                               llvm_i32_ty,llvm_v32i32_ty],
-                          [IntrArgMemOnly]>;
-
-class Hexagon_V65_vvmemv64iiiv1024_Intrinsic<string GCCIntSuffix>
- : Hexagon_Intrinsic<GCCIntSuffix,
-                          [], [llvm_ptr_ty,llvm_v512i1_ty,llvm_i32_ty,
-                               llvm_i32_ty,llvm_v32i32_ty],
-                          [IntrArgMemOnly]>;
-
-class Hexagon_V65_vvmemv128iiiv2048_Intrinsic<string GCCIntSuffix>
- : Hexagon_Intrinsic<GCCIntSuffix,
-                          [], [llvm_ptr_ty,llvm_v1024i1_ty,llvm_i32_ty,
-                               llvm_i32_ty,llvm_v64i32_ty],
-                          [IntrArgMemOnly]>;
-
-def int_hexagon_V6_vgathermw :
-Hexagon_V65_vvmemiiv512_Intrinsic<"HEXAGON_V6_vgathermw">;
-
-def int_hexagon_V6_vgathermw_128B :
-Hexagon_V65_vvmemiiv1024_Intrinsic<"HEXAGON_V6_vgathermw_128B">;
-
-def int_hexagon_V6_vgathermh :
-Hexagon_V65_vvmemiiv512_Intrinsic<"HEXAGON_V6_vgathermh">;
-
-def int_hexagon_V6_vgathermh_128B :
-Hexagon_V65_vvmemiiv1024_Intrinsic<"HEXAGON_V6_vgathermh_128B">;
-
-def int_hexagon_V6_vgathermhw :
-Hexagon_V65_vvmemiiv1024_Intrinsic<"HEXAGON_V6_vgathermhw">;
-
-def int_hexagon_V6_vgathermhw_128B :
-Hexagon_V65_vvmemiiv2048_Intrinsic<"HEXAGON_V6_vgathermhw_128B">;
-
-def int_hexagon_V6_vgathermwq :
-Hexagon_V65_vvmemv64iiiv512_Intrinsic<"HEXAGON_V6_vgathermwq">;
-
-def int_hexagon_V6_vgathermwq_128B :
-Hexagon_V65_vvmemv128iiiv1024_Intrinsic<"HEXAGON_V6_vgathermwq_128B">;
-
-def int_hexagon_V6_vgathermhq :
-Hexagon_V65_vvmemv64iiiv512_Intrinsic<"HEXAGON_V6_vgathermhq">;
-
-def int_hexagon_V6_vgathermhq_128B :
-Hexagon_V65_vvmemv128iiiv1024_Intrinsic<"HEXAGON_V6_vgathermhq_128B">;
-
-def int_hexagon_V6_vgathermhwq :
-Hexagon_V65_vvmemv64iiiv1024_Intrinsic<"HEXAGON_V6_vgathermhwq">;
-
-def int_hexagon_V6_vgathermhwq_128B :
-Hexagon_V65_vvmemv128iiiv2048_Intrinsic<"HEXAGON_V6_vgathermhwq_128B">;
-
-class Hexagon_V65_viiv512v512_Intrinsic<string GCCIntSuffix>
- : Hexagon_Intrinsic<GCCIntSuffix,
-                          [], [llvm_i32_ty,llvm_i32_ty,
-                                           llvm_v16i32_ty,llvm_v16i32_ty],
-                          [IntrWriteMem]>;
-
-class Hexagon_V65_viiv1024v1024_Intrinsic<string GCCIntSuffix>
- : Hexagon_Intrinsic<GCCIntSuffix,
-                          [], [llvm_i32_ty,llvm_i32_ty,
-                                           llvm_v32i32_ty,llvm_v32i32_ty],
-                          [IntrWriteMem]>;
-
-class Hexagon_V65_vv64iiiv512v512_Intrinsic<string GCCIntSuffix>
- : Hexagon_Intrinsic<GCCIntSuffix,
-                          [], [llvm_v512i1_ty,llvm_i32_ty,
-                                           llvm_i32_ty,llvm_v16i32_ty,
-                                           llvm_v16i32_ty],
-                          [IntrWriteMem]>;
-
-class Hexagon_V65_vv128iiiv1024v1024_Intrinsic<string GCCIntSuffix>
- : Hexagon_Intrinsic<GCCIntSuffix,
-                          [], [llvm_v1024i1_ty,llvm_i32_ty,
-                                           llvm_i32_ty,llvm_v32i32_ty,
-                                           llvm_v32i32_ty],
-                          [IntrWriteMem]>;
-
-class Hexagon_V65_viiv1024v512_Intrinsic<string GCCIntSuffix>
- : Hexagon_Intrinsic<GCCIntSuffix,
-                          [], [llvm_i32_ty,llvm_i32_ty,
-                                           llvm_v32i32_ty,llvm_v16i32_ty],
-                          [IntrWriteMem]>;
-
-class Hexagon_V65_viiv2048v1024_Intrinsic<string GCCIntSuffix>
- : Hexagon_Intrinsic<GCCIntSuffix,
-                          [], [llvm_i32_ty,llvm_i32_ty,
-                                           llvm_v64i32_ty,llvm_v32i32_ty],
-                          [IntrWriteMem]>;
-
-class Hexagon_V65_vv64iiiv1024v512_Intrinsic<string GCCIntSuffix>
- : Hexagon_Intrinsic<GCCIntSuffix,
-                          [], [llvm_v512i1_ty,llvm_i32_ty,
-                                           llvm_i32_ty,llvm_v32i32_ty,
-                                           llvm_v16i32_ty],
-                          [IntrWriteMem]>;
-
-class Hexagon_V65_vv128iiiv2048v1024_Intrinsic<string GCCIntSuffix>
- : Hexagon_Intrinsic<GCCIntSuffix,
-                          [], [llvm_v1024i1_ty,llvm_i32_ty,
-                                           llvm_i32_ty,llvm_v64i32_ty,
-                                           llvm_v32i32_ty],
-                          [IntrWriteMem]>;
-
-class Hexagon_V65_v2048_Intrinsic<string GCCIntSuffix>
- : Hexagon_Intrinsic<GCCIntSuffix,
-                          [llvm_v64i32_ty], [],
-                          [IntrNoMem]>;
-
-//
-// BUILTIN_INFO(HEXAGON.V6_vscattermw,v_ftype_SISIVIVI,4)
-// tag : V6_vscattermw
-def int_hexagon_V6_vscattermw :
-Hexagon_V65_viiv512v512_Intrinsic<"HEXAGON_V6_vscattermw">;
-
-//
-// BUILTIN_INFO(HEXAGON.V6_vscattermw_128B,v_ftype_SISIVIVI,4)
-// tag : V6_vscattermw_128B
-def int_hexagon_V6_vscattermw_128B :
-Hexagon_V65_viiv1024v1024_Intrinsic<"HEXAGON_V6_vscattermw_128B">;
-
-//
-// BUILTIN_INFO(HEXAGON.V6_vscattermh,v_ftype_SISIVIVI,4)
-// tag : V6_vscattermh
-def int_hexagon_V6_vscattermh :
-Hexagon_V65_viiv512v512_Intrinsic<"HEXAGON_V6_vscattermh">;
-
-//
-// BUILTIN_INFO(HEXAGON.V6_vscattermh_128B,v_ftype_SISIVIVI,4)
-// tag : V6_vscattermh_128B
-def int_hexagon_V6_vscattermh_128B :
-Hexagon_V65_viiv1024v1024_Intrinsic<"HEXAGON_V6_vscattermh_128B">;
-
-//
-// BUILTIN_INFO(HEXAGON.V6_vscattermw_add,v_ftype_SISIVIVI,4)
-// tag : V6_vscattermw_add
-def int_hexagon_V6_vscattermw_add :
-Hexagon_V65_viiv512v512_Intrinsic<"HEXAGON_V6_vscattermw_add">;
-
-//
-// BUILTIN_INFO(HEXAGON.V6_vscattermw_add_128B,v_ftype_SISIVIVI,4)
-// tag : V6_vscattermw_add_128B
-def int_hexagon_V6_vscattermw_add_128B :
-Hexagon_V65_viiv1024v1024_Intrinsic<"HEXAGON_V6_vscattermw_add_128B">;
-
-//
-// BUILTIN_INFO(HEXAGON.V6_vscattermh_add,v_ftype_SISIVIVI,4)
-// tag : V6_vscattermh_add
-def int_hexagon_V6_vscattermh_add :
-Hexagon_V65_viiv512v512_Intrinsic<"HEXAGON_V6_vscattermh_add">;
-
-//
-// BUILTIN_INFO(HEXAGON.V6_vscattermh_add_128B,v_ftype_SISIVIVI,4)
-// tag : V6_vscattermh_add_128B
-def int_hexagon_V6_vscattermh_add_128B :
-Hexagon_V65_viiv1024v1024_Intrinsic<"HEXAGON_V6_vscattermh_add_128B">;
-
-//
-// BUILTIN_INFO(HEXAGON.V6_vscattermwq,v_ftype_QVSISIVIVI,5)
-// tag : V6_vscattermwq
-def int_hexagon_V6_vscattermwq :
-Hexagon_V65_vv64iiiv512v512_Intrinsic<"HEXAGON_V6_vscattermwq">;
-
-//
-// BUILTIN_INFO(HEXAGON.V6_vscattermwq_128B,v_ftype_QVSISIVIVI,5)
-// tag : V6_vscattermwq_128B
-def int_hexagon_V6_vscattermwq_128B :
-Hexagon_V65_vv128iiiv1024v1024_Intrinsic<"HEXAGON_V6_vscattermwq_128B">;
-
-//
-// BUILTIN_INFO(HEXAGON.V6_vscattermhq,v_ftype_QVSISIVIVI,5)
-// tag : V6_vscattermhq
-def int_hexagon_V6_vscattermhq :
-Hexagon_V65_vv64iiiv512v512_Intrinsic<"HEXAGON_V6_vscattermhq">;
-
-//
-// BUILTIN_INFO(HEXAGON.V6_vscattermhq_128B,v_ftype_QVSISIVIVI,5)
-// tag : V6_vscattermhq_128B
-def int_hexagon_V6_vscattermhq_128B :
-Hexagon_V65_vv128iiiv1024v1024_Intrinsic<"HEXAGON_V6_vscattermhq_128B">;
-
-//
-// BUILTIN_INFO(HEXAGON.V6_vscattermhw,v_ftype_SISIVDVI,4)
-// tag : V6_vscattermhw
-def int_hexagon_V6_vscattermhw :
-Hexagon_V65_viiv1024v512_Intrinsic<"HEXAGON_V6_vscattermhw">;
-
-//
-// BUILTIN_INFO(HEXAGON.V6_vscattermhw_128B,v_ftype_SISIVDVI,4)
-// tag : V6_vscattermhw_128B
-def int_hexagon_V6_vscattermhw_128B :
-Hexagon_V65_viiv2048v1024_Intrinsic<"HEXAGON_V6_vscattermhw_128B">;
-
-//
-// BUILTIN_INFO(HEXAGON.V6_vscattermhwq,v_ftype_QVSISIVDVI,5)
-// tag : V6_vscattermhwq
-def int_hexagon_V6_vscattermhwq :
-Hexagon_V65_vv64iiiv1024v512_Intrinsic<"HEXAGON_V6_vscattermhwq">;
-
-//
-// BUILTIN_INFO(HEXAGON.V6_vscattermhwq_128B,v_ftype_QVSISIVDVI,5)
-// tag : V6_vscattermhwq_128B
-def int_hexagon_V6_vscattermhwq_128B :
-Hexagon_V65_vv128iiiv2048v1024_Intrinsic<"HEXAGON_V6_vscattermhwq_128B">;
-
-//
-// BUILTIN_INFO(HEXAGON.V6_vscattermhw_add,v_ftype_SISIVDVI,4)
-// tag : V6_vscattermhw_add
-def int_hexagon_V6_vscattermhw_add :
-Hexagon_V65_viiv1024v512_Intrinsic<"HEXAGON_V6_vscattermhw_add">;
-
-//
-// BUILTIN_INFO(HEXAGON.V6_vscattermhw_add_128B,v_ftype_SISIVDVI,4)
-// tag : V6_vscattermhw_add_128B
-def int_hexagon_V6_vscattermhw_add_128B :
-Hexagon_V65_viiv2048v1024_Intrinsic<"HEXAGON_V6_vscattermhw_add_128B">;
-
-// Auto-generated intrinsics
-
-// tag : S2_vsatwh
-class Hexagon_i32_i64_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_i32_ty], [llvm_i64_ty],
-       [IntrNoMem]>;
-
-// tag : V6_vrmpybusv
-class Hexagon_v16i32_v16i32v16i32_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v16i32_ty], [llvm_v16i32_ty,llvm_v16i32_ty],
-       [IntrNoMem]>;
-
-// tag : V6_vrmpybusv
-class Hexagon_v32i32_v32i32v32i32_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v32i32_ty], [llvm_v32i32_ty,llvm_v32i32_ty],
-       [IntrNoMem]>;
-
-// tag : V6_vaslw_acc
-class Hexagon_v16i32_v16i32v16i32i32_Intrinsic<string GCCIntSuffix,
-                                               list<IntrinsicProperty> intr_properties = []>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v16i32_ty], [llvm_v16i32_ty,llvm_v16i32_ty,llvm_i32_ty],
-       !listconcat([IntrNoMem], intr_properties)>;
-
-// tag : V6_vaslw_acc
-class Hexagon_v32i32_v32i32v32i32i32_Intrinsic<string GCCIntSuffix,
-                                               list<IntrinsicProperty> intr_properties = []>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v32i32_ty], [llvm_v32i32_ty,llvm_v32i32_ty,llvm_i32_ty],
-       !listconcat([IntrNoMem], intr_properties)>;
-
-// tag : V6_vmux
-class Hexagon_v16i32_v512i1v16i32v16i32_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v16i32_ty], [llvm_v512i1_ty,llvm_v16i32_ty,llvm_v16i32_ty],
-       [IntrNoMem]>;
-
-// tag : V6_vmux
-class Hexagon_v32i32_v1024i1v32i32v32i32_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v32i32_ty], [llvm_v1024i1_ty,llvm_v32i32_ty,llvm_v32i32_ty],
-       [IntrNoMem]>;
-
-// tag : S2_tableidxd_goodsyntax
-class Hexagon_i32_i32i32i32i32_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_i32_ty], [llvm_i32_ty,llvm_i32_ty,llvm_i32_ty,llvm_i32_ty],
-       [IntrNoMem, ImmArg<2>, ImmArg<3>]>;
-
-// tag : V6_vandnqrt_acc
-class Hexagon_v16i32_v16i32v512i1i32_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v16i32_ty], [llvm_v16i32_ty,llvm_v512i1_ty,llvm_i32_ty],
-       [IntrNoMem]>;
-
-// tag : V6_vandnqrt_acc
-class Hexagon_v32i32_v32i32v1024i1i32_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v32i32_ty], [llvm_v32i32_ty,llvm_v1024i1_ty,llvm_i32_ty],
-       [IntrNoMem]>;
-
-// tag : V6_vrmpybusi
-class Hexagon_v32i32_v32i32i32i32_Intrinsic<string GCCIntSuffix,
-      list<IntrinsicProperty> intr_properties = []>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v32i32_ty], [llvm_v32i32_ty,llvm_i32_ty,llvm_i32_ty],
-       !listconcat([IntrNoMem], intr_properties)>;
-
-// tag : V6_vrmpybusi
-class Hexagon_v64i32_v64i32i32i32_Intrinsic<string GCCIntSuffix,
-                                            list<IntrinsicProperty> intr_properties = []>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v64i32_ty], [llvm_v64i32_ty,llvm_i32_ty,llvm_i32_ty],
-       !listconcat([IntrNoMem], intr_properties)>;
-
-// tag : V6_vsubb_dv
-class Hexagon_v64i32_v64i32v64i32_Intrinsic<string GCCIntSuffix, list<IntrinsicProperty> intr_properties = []>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v64i32_ty], [llvm_v64i32_ty,llvm_v64i32_ty],
-       !listconcat([IntrNoMem], intr_properties)>;
-
-// tag : M2_mpysu_up
-class Hexagon_i32_i32i32_Intrinsic<string GCCIntSuffix,
-                                   list<IntrinsicProperty> intr_properties = []>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_i32_ty], [llvm_i32_ty,llvm_i32_ty],
-       !listconcat([IntrNoMem], intr_properties)>;
-
-// tag : M2_mpyud_acc_ll_s0
-class Hexagon_i64_i64i32i32_Intrinsic<string GCCIntSuffix, list<IntrinsicProperty> intr_properties = []>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_i64_ty], [llvm_i64_ty,llvm_i32_ty,llvm_i32_ty],
-       !listconcat([IntrNoMem], intr_properties)>;
-
-// tag : S2_lsr_i_r_nac
-class Hexagon_i32_i32i32i32_Intrinsic<string GCCIntSuffix,
-                                             list<IntrinsicProperty> intr_properties = []>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_i32_ty], [llvm_i32_ty,llvm_i32_ty,llvm_i32_ty],
-       !listconcat([IntrNoMem], intr_properties)>;
-
-// tag : M2_cmpysc_s0
-class Hexagon_i64_i32i32_Intrinsic<string GCCIntSuffix, list<IntrinsicProperty> intr_properties = []>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_i64_ty], [llvm_i32_ty,llvm_i32_ty],
-       !listconcat([IntrNoMem], intr_properties)>;
-
-// tag : V6_lo
-class Hexagon_v16i32_v32i32_Intrinsic<string GCCIntSuffix, list<IntrinsicProperty> intr_properties = []>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v16i32_ty], [llvm_v32i32_ty],
-       !listconcat([IntrNoMem], intr_properties)>;
-
-// tag : V6_lo
-class Hexagon_v32i32_v64i32_Intrinsic<string GCCIntSuffix, list<IntrinsicProperty> intr_properties = []>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v32i32_ty], [llvm_v64i32_ty],
-       !listconcat([IntrNoMem], intr_properties)>;
-
-// tag : S2_shuffoh
-class Hexagon_i64_i64i64_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_i64_ty], [llvm_i64_ty,llvm_i64_ty],
-       [IntrNoMem]>;
-
-// tag : F2_sfmax
-class Hexagon_float_floatfloat_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_float_ty], [llvm_float_ty,llvm_float_ty],
-       [IntrNoMem, Throws]>;
-
-// tag : A2_vabswsat
-class Hexagon_i64_i64_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_i64_ty], [llvm_i64_ty],
-       [IntrNoMem]>;
-
-// tag :
-class Hexagon_v32i32_v32i32_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v32i32_ty], [llvm_v32i32_ty],
-       [IntrNoMem]>;
-
-// tag : V6_ldnp0
-class Hexagon_v16i32_i32i32_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v16i32_ty], [llvm_i32_ty,llvm_i32_ty],
-       [IntrNoMem]>;
-
-// tag : V6_ldnp0
-class Hexagon_v32i32_i32i32_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v32i32_ty], [llvm_i32_ty,llvm_i32_ty],
-       [IntrNoMem]>;
-
-// tag : V6_vdmpyhb
-class Hexagon_v16i32_v16i32i32_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v16i32_ty], [llvm_v16i32_ty,llvm_i32_ty],
-       [IntrNoMem]>;
-
-// tag : V6_vdmpyhb
-class Hexagon_v32i32_v32i32i32_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v32i32_ty], [llvm_v32i32_ty,llvm_i32_ty],
-       [IntrNoMem]>;
-
-// tag : A4_vcmphgti
-class Hexagon_i32_i64i32_Intrinsic<string GCCIntSuffix, list<IntrinsicProperty> intr_properties = []>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_i32_ty], [llvm_i64_ty,llvm_i32_ty],
-       !listconcat([IntrNoMem], intr_properties)>;
-
-// tag :
-class Hexagon_v32i32_v16i32i32_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v32i32_ty], [llvm_v16i32_ty,llvm_i32_ty],
-       [IntrNoMem]>;
-
-// tag : S6_rol_i_p_or
-class Hexagon_i64_i64i64i32_Intrinsic<string GCCIntSuffix,
-                                      list<IntrinsicProperty> intr_properties = []>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_i64_ty], [llvm_i64_ty,llvm_i64_ty,llvm_i32_ty],
-       !listconcat([IntrNoMem], intr_properties)>;
-
-// tag : V6_vgtuh_and
-class Hexagon_v512i1_v512i1v16i32v16i32_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v512i1_ty], [llvm_v512i1_ty,llvm_v16i32_ty,llvm_v16i32_ty],
-       [IntrNoMem]>;
-
-// tag : V6_vgtuh_and
-class Hexagon_v1024i1_v1024i1v32i32v32i32_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v1024i1_ty], [llvm_v1024i1_ty,llvm_v32i32_ty,llvm_v32i32_ty],
-       [IntrNoMem]>;
-
-// tag : A2_abssat
-class Hexagon_i32_i32_Intrinsic<string GCCIntSuffix,
-                                list<IntrinsicProperty> intr_properties = []>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_i32_ty], [llvm_i32_ty],
-       !listconcat([IntrNoMem], intr_properties)>;
-
-// tag : A2_vcmpwgtu
-class Hexagon_i32_i64i64_Intrinsic<string GCCIntSuffix,
-                                  list<IntrinsicProperty> intr_properties = []>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_i32_ty], [llvm_i64_ty,llvm_i64_ty],
-       !listconcat([IntrNoMem], intr_properties)>;
-
-// tag : V6_vtmpybus_acc
-class Hexagon_v64i32_v64i32v64i32i32_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v64i32_ty], [llvm_v64i32_ty,llvm_v64i32_ty,llvm_i32_ty],
-       [IntrNoMem]>;
-
-// tag : F2_conv_df2uw_chop
-class Hexagon_i32_double_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_i32_ty], [llvm_double_ty],
-       [IntrNoMem]>;
-
-// tag : V6_pred_or
-class Hexagon_v512i1_v512i1v512i1_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v512i1_ty], [llvm_v512i1_ty,llvm_v512i1_ty],
-       [IntrNoMem]>;
-
-// tag : V6_pred_or
-class Hexagon_v1024i1_v1024i1v1024i1_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v1024i1_ty], [llvm_v1024i1_ty,llvm_v1024i1_ty],
-       [IntrNoMem]>;
-
-// tag : S2_asr_i_p_rnd_goodsyntax
-class Hexagon_i64_i64i32_Intrinsic<string GCCIntSuffix,
-      list<IntrinsicProperty> intr_properties = []>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_i64_ty], [llvm_i64_ty,llvm_i32_ty],
-       !listconcat([IntrNoMem], intr_properties)>;
-
-// tag : F2_conv_w2df
-class Hexagon_double_i32_Intrinsic<string GCCIntSuffix,
-      list<IntrinsicProperty> intr_properties = []>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_double_ty], [llvm_i32_ty],
-       !listconcat([IntrNoMem], intr_properties)>;
-
-// tag : V6_vunpackuh
-class Hexagon_v32i32_v16i32_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v32i32_ty], [llvm_v16i32_ty],
-       [IntrNoMem]>;
-
-// tag : V6_vunpackuh
-class Hexagon_v64i32_v32i32_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v64i32_ty], [llvm_v32i32_ty],
-       [IntrNoMem]>;
-
-// tag : V6_vadduhw_acc
-class Hexagon_v32i32_v32i32v16i32v16i32_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v32i32_ty], [llvm_v32i32_ty,llvm_v16i32_ty,llvm_v16i32_ty],
-       [IntrNoMem]>;
-
-// tag : V6_vadduhw_acc
-class Hexagon_v64i32_v64i32v32i32v32i32_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v64i32_ty], [llvm_v64i32_ty,llvm_v32i32_ty,llvm_v32i32_ty],
-       [IntrNoMem]>;
-
-// tag : M2_vdmacs_s0
-class Hexagon_i64_i64i64i64_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_i64_ty], [llvm_i64_ty,llvm_i64_ty,llvm_i64_ty],
-       [IntrNoMem]>;
-
-// tag : V6_vrmpybub_rtt_acc
-class Hexagon_v32i32_v32i32v16i32i64_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v32i32_ty], [llvm_v32i32_ty,llvm_v16i32_ty,llvm_i64_ty],
-       [IntrNoMem]>;
-
-// tag : V6_vrmpybub_rtt_acc
-class Hexagon_v64i32_v64i32v32i32i64_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v64i32_ty], [llvm_v64i32_ty,llvm_v32i32_ty,llvm_i64_ty],
-       [IntrNoMem]>;
-
-// tag : V6_ldu0
-class Hexagon_v16i32_i32_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v16i32_ty], [llvm_i32_ty],
-       [IntrNoMem]>;
-
-// tag : V6_ldu0
-class Hexagon_v32i32_i32_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v32i32_ty], [llvm_i32_ty],
-       [IntrNoMem]>;
-
-// tag : S4_extract_rp
-class Hexagon_i32_i32i64_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_i32_ty], [llvm_i32_ty,llvm_i64_ty],
-       [IntrNoMem]>;
-
-// tag : V6_vdmpyhsuisat
-class Hexagon_v16i32_v32i32i32_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v16i32_ty], [llvm_v32i32_ty,llvm_i32_ty],
-       [IntrNoMem]>;
-
-// tag : V6_vdmpyhsuisat
-class Hexagon_v32i32_v64i32i32_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v32i32_ty], [llvm_v64i32_ty,llvm_i32_ty],
-       [IntrNoMem]>;
-
-// tag : A2_addsp
-class Hexagon_i64_i32i64_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_i64_ty], [llvm_i32_ty,llvm_i64_ty],
-       [IntrNoMem]>;
-
-// tag : V6_extractw
-class Hexagon_i32_v16i32i32_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_i32_ty], [llvm_v16i32_ty,llvm_i32_ty],
-       [IntrNoMem]>;
-
-// tag : V6_extractw
-class Hexagon_i32_v32i32i32_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_i32_ty], [llvm_v32i32_ty,llvm_i32_ty],
-       [IntrNoMem]>;
-
-// tag : V6_vlutvwhi
-class Hexagon_v32i32_v16i32v16i32i32_Intrinsic<string GCCIntSuffix,
-      list<IntrinsicProperty> intr_properties = []>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v32i32_ty], [llvm_v16i32_ty,llvm_v16i32_ty,llvm_i32_ty],
-       !listconcat([IntrNoMem], intr_properties)>;
-
-// tag : V6_vlutvwhi
-class Hexagon_v64i32_v32i32v32i32i32_Intrinsic<string GCCIntSuffix,
-      list<IntrinsicProperty> intr_properties = []>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v64i32_ty], [llvm_v32i32_ty,llvm_v32i32_ty,llvm_i32_ty],
-       !listconcat([IntrNoMem], intr_properties)>;
-
-// tag : V6_vgtuh
-class Hexagon_v512i1_v16i32v16i32_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v512i1_ty], [llvm_v16i32_ty,llvm_v16i32_ty],
-       [IntrNoMem]>;
-
-// tag : V6_vgtuh
-class Hexagon_v1024i1_v32i32v32i32_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v1024i1_ty], [llvm_v32i32_ty,llvm_v32i32_ty],
-       [IntrNoMem]>;
-
-// tag : F2_sffma_lib
-class Hexagon_float_floatfloatfloat_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_float_ty], [llvm_float_ty,llvm_float_ty,llvm_float_ty],
-       [IntrNoMem, Throws]>;
-
-// tag : F2_conv_ud2df
-class Hexagon_double_i64_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_double_ty], [llvm_i64_ty],
-       [IntrNoMem]>;
-
-// tag : S2_vzxthw
-class Hexagon_i64_i32_Intrinsic<string GCCIntSuffix,
-      list<IntrinsicProperty> intr_properties = []>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_i64_ty], [llvm_i32_ty],
-       !listconcat([IntrNoMem], intr_properties)>;
-
-// tag : V6_vtmpyhb
-class Hexagon_v64i32_v64i32i32_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v64i32_ty], [llvm_v64i32_ty,llvm_i32_ty],
-       [IntrNoMem]>;
-
-// tag : V6_vshufoeh
-class Hexagon_v32i32_v16i32v16i32_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v32i32_ty], [llvm_v16i32_ty,llvm_v16i32_ty],
-       [IntrNoMem]>;
-
-// tag : V6_vshufoeh
-class Hexagon_v64i32_v32i32v32i32_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v64i32_ty], [llvm_v32i32_ty,llvm_v32i32_ty],
-       [IntrNoMem]>;
-
-// tag : V6_vlut4
-class Hexagon_v16i32_v16i32i64_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v16i32_ty], [llvm_v16i32_ty,llvm_i64_ty],
-       [IntrNoMem]>;
-
-// tag : V6_vlut4
-class Hexagon_v32i32_v32i32i64_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v32i32_ty], [llvm_v32i32_ty,llvm_i64_ty],
-       [IntrNoMem]>;
-
-// tag :
-class Hexagon_v16i32_v16i32_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v16i32_ty], [llvm_v16i32_ty],
-       [IntrNoMem]>;
-
-// tag : F2_conv_uw2sf
-class Hexagon_float_i32_Intrinsic<string GCCIntSuffix,
-      list<IntrinsicProperty> intr_properties = []>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_float_ty], [llvm_i32_ty],
-       !listconcat([IntrNoMem], intr_properties)>;
-
-// tag : V6_vswap
-class Hexagon_v32i32_v512i1v16i32v16i32_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v32i32_ty], [llvm_v512i1_ty,llvm_v16i32_ty,llvm_v16i32_ty],
-       [IntrNoMem]>;
-
-// tag : V6_vswap
-class Hexagon_v64i32_v1024i1v32i32v32i32_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v64i32_ty], [llvm_v1024i1_ty,llvm_v32i32_ty,llvm_v32i32_ty],
-       [IntrNoMem]>;
-
-// tag : V6_vandnqrt
-class Hexagon_v16i32_v512i1i32_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v16i32_ty], [llvm_v512i1_ty,llvm_i32_ty],
-       [IntrNoMem]>;
-
-// tag : V6_vandnqrt
-class Hexagon_v32i32_v1024i1i32_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v32i32_ty], [llvm_v1024i1_ty,llvm_i32_ty],
-       [IntrNoMem]>;
-
-// tag : V6_vmpyub
-class Hexagon_v64i32_v32i32i32_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v64i32_ty], [llvm_v32i32_ty,llvm_i32_ty],
-       [IntrNoMem]>;
-
-// tag : A5_ACS
-class Hexagon_i64i32_i64i64i64_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_i64_ty,llvm_i32_ty], [llvm_i64_ty,llvm_i64_ty,llvm_i64_ty],
-       [IntrNoMem]>;
-
-// tag : V6_vunpackob
-class Hexagon_v32i32_v32i32v16i32_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v32i32_ty], [llvm_v32i32_ty,llvm_v16i32_ty],
-       [IntrNoMem]>;
-
-// tag : V6_vunpackob
-class Hexagon_v64i32_v64i32v32i32_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v64i32_ty], [llvm_v64i32_ty,llvm_v32i32_ty],
-       [IntrNoMem]>;
-
-// tag : V6_vmpyhsat_acc
-class Hexagon_v32i32_v32i32v16i32i32_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v32i32_ty], [llvm_v32i32_ty,llvm_v16i32_ty,llvm_i32_ty],
-       [IntrNoMem]>;
-
-// tag : V6_vmpyhsat_acc
-class Hexagon_v64i32_v64i32v32i32i32_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v64i32_ty], [llvm_v64i32_ty,llvm_v32i32_ty,llvm_i32_ty],
-       [IntrNoMem]>;
-
-// tag : V6_vaddcarrysat
-class Hexagon_v16i32_v16i32v16i32v512i1_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v16i32_ty], [llvm_v16i32_ty,llvm_v16i32_ty,llvm_v512i1_ty],
-       [IntrNoMem]>;
-
-// tag : V6_vaddcarrysat
-class Hexagon_v32i32_v32i32v32i32v1024i1_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v32i32_ty], [llvm_v32i32_ty,llvm_v32i32_ty,llvm_v1024i1_ty],
-       [IntrNoMem]>;
-
-// tag : V6_vlutvvb_oracc
-class Hexagon_v16i32_v16i32v16i32v16i32i32_Intrinsic<string GCCIntSuffix,
-                                                     list<IntrinsicProperty> intr_properties = []>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v16i32_ty], [llvm_v16i32_ty,llvm_v16i32_ty,llvm_v16i32_ty,llvm_i32_ty],
-       !listconcat([IntrNoMem], intr_properties)>;
-
-// tag : V6_vlutvvb_oracc
-class Hexagon_v32i32_v32i32v32i32v32i32i32_Intrinsic<string GCCIntSuffix, list<IntrinsicProperty> intr_properties = []>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v32i32_ty], [llvm_v32i32_ty,llvm_v32i32_ty,llvm_v32i32_ty,llvm_i32_ty],
-       !listconcat([IntrNoMem], intr_properties)>;
-
 // tag : V6_vrmpybub_rtt
-class Hexagon_v32i32_v16i32i64_Intrinsic<string GCCIntSuffix>
+class Hexagon_v32i32_v16i32i64_rtt_Intrinsic<string GCCIntSuffix>
   : Hexagon_Intrinsic<GCCIntSuffix,
        [llvm_v32i32_ty], [llvm_v16i32_ty,llvm_i64_ty],
        [IntrNoMem]>;
 
-// tag : V6_vrmpybub_rtt
-class Hexagon_v64i32_v32i32i64_Intrinsic<string GCCIntSuffix>
+// tag : V6_vrmpybub_rtt_128B
+class Hexagon_v64i32_v32i32i64_rtt_Intrinsic<string GCCIntSuffix>
   : Hexagon_Intrinsic<GCCIntSuffix,
        [llvm_v64i32_ty], [llvm_v32i32_ty,llvm_i64_ty],
        [IntrNoMem]>;
 
-// tag : A4_addp_c
-class Hexagon_i64i32_i64i64i32_Intrinsic<string GCCIntSuffix>
+// tag : V6_vrmpybub_rtt_acc
+class Hexagon_v32i32_v32i32v16i32i64_rtt_Intrinsic<string GCCIntSuffix>
   : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_i64_ty,llvm_i32_ty], [llvm_i64_ty,llvm_i64_ty,llvm_i32_ty],
+       [llvm_v32i32_ty], [llvm_v32i32_ty,llvm_v16i32_ty,llvm_i64_ty],
        [IntrNoMem]>;
 
-// tag : V6_vrsadubi_acc
-class Hexagon_v32i32_v32i32v32i32i32i32_Intrinsic<string GCCIntSuffix,
-                                                  list<IntrinsicProperty> intr_properties = []>
+// tag : V6_vrmpybub_rtt_acc_128B
+class Hexagon_v64i32_v64i32v32i32i64_rtt_Intrinsic<string GCCIntSuffix>
   : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v32i32_ty], [llvm_v32i32_ty,llvm_v32i32_ty,llvm_i32_ty,llvm_i32_ty],
-       !listconcat([IntrNoMem], intr_properties)>;
-
-// tag : V6_vrsadubi_acc
-class Hexagon_v64i32_v64i32v64i32i32i32_Intrinsic<string GCCIntSuffix,
-      list<IntrinsicProperty> intr_properties = []>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v64i32_ty], [llvm_v64i32_ty,llvm_v64i32_ty,llvm_i32_ty,llvm_i32_ty],
-       !listconcat([IntrNoMem], intr_properties)>;
-
-// tag : F2_conv_df2sf
-class Hexagon_float_double_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_float_ty], [llvm_double_ty],
+       [llvm_v64i32_ty], [llvm_v64i32_ty,llvm_v32i32_ty,llvm_i64_ty],
        [IntrNoMem]>;
 
-// tag : V6_vandvqv
-class Hexagon_v16i32_v512i1v16i32_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v16i32_ty], [llvm_v512i1_ty,llvm_v16i32_ty],
-       [IntrNoMem]>;
-
-// tag : V6_vandvqv
-class Hexagon_v32i32_v1024i1v32i32_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v32i32_ty], [llvm_v1024i1_ty,llvm_v32i32_ty],
-       [IntrNoMem]>;
-
-// tag : C2_vmux
-class Hexagon_i64_i32i64i64_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_i64_ty], [llvm_i32_ty,llvm_i64_ty,llvm_i64_ty],
-       [IntrNoMem]>;
-
-// tag : F2_sfcmpeq
-class Hexagon_i32_floatfloat_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_i32_ty], [llvm_float_ty,llvm_float_ty],
-       [IntrNoMem, Throws]>;
-
-// tag : V6_vmpahhsat
-class Hexagon_v16i32_v16i32v16i32i64_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v16i32_ty], [llvm_v16i32_ty,llvm_v16i32_ty,llvm_i64_ty],
-       [IntrNoMem]>;
-
-// tag : V6_vmpahhsat
-class Hexagon_v32i32_v32i32v32i32i64_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v32i32_ty], [llvm_v32i32_ty,llvm_v32i32_ty,llvm_i64_ty],
-       [IntrNoMem]>;
-
-// tag : V6_vandvrt
-class Hexagon_v512i1_v16i32i32_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v512i1_ty], [llvm_v16i32_ty,llvm_i32_ty],
-       [IntrNoMem]>;
-
-// tag : V6_vandvrt
-class Hexagon_v1024i1_v32i32i32_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v1024i1_ty], [llvm_v32i32_ty,llvm_i32_ty],
-       [IntrNoMem]>;
-
-// tag : V6_vsubcarry
-class Hexagon_custom_v16i32v512i1_v16i32v16i32v512i1_Intrinsic
-  : Hexagon_NonGCC_Intrinsic<
-       [llvm_v16i32_ty,llvm_v512i1_ty], [llvm_v16i32_ty,llvm_v16i32_ty,llvm_v512i1_ty],
-       [IntrNoMem]>;
-
-// tag : V6_vsubcarry
-class Hexagon_custom_v32i32v1024i1_v32i32v32i32v1024i1_Intrinsic_128B
-  : Hexagon_NonGCC_Intrinsic<
-       [llvm_v32i32_ty,llvm_v1024i1_ty], [llvm_v32i32_ty,llvm_v32i32_ty,llvm_v1024i1_ty],
-       [IntrNoMem]>;
-
-// tag : F2_sffixupr
-class Hexagon_float_float_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_float_ty], [llvm_float_ty],
-       [IntrNoMem, Throws]>;
-
-// tag : V6_vandvrt_acc
-class Hexagon_v512i1_v512i1v16i32i32_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v512i1_ty], [llvm_v512i1_ty,llvm_v16i32_ty,llvm_i32_ty],
-       [IntrNoMem]>;
-
-// tag : V6_vandvrt_acc
-class Hexagon_v1024i1_v1024i1v32i32i32_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v1024i1_ty], [llvm_v1024i1_ty,llvm_v32i32_ty,llvm_i32_ty],
-       [IntrNoMem]>;
-
-// tag : F2_dfsub
-class Hexagon_double_doubledouble_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_double_ty], [llvm_double_ty,llvm_double_ty],
-       [IntrNoMem, Throws]>;
-
-// tag : V6_vmpyowh_sacc
-class Hexagon_v16i32_v16i32v16i32v16i32_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v16i32_ty], [llvm_v16i32_ty,llvm_v16i32_ty,llvm_v16i32_ty],
-       [IntrNoMem]>;
-
-// tag : V6_vmpyowh_sacc
-class Hexagon_v32i32_v32i32v32i32v32i32_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v32i32_ty], [llvm_v32i32_ty,llvm_v32i32_ty,llvm_v32i32_ty],
-       [IntrNoMem]>;
-
-// tag : S2_insertp
-class Hexagon_i64_i64i64i32i32_Intrinsic<string GCCIntSuffix,
-                                         list<IntrinsicProperty> intr_properties = []>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_i64_ty], [llvm_i64_ty,llvm_i64_ty,llvm_i32_ty,llvm_i32_ty],
-       !listconcat([IntrNoMem], intr_properties)>;
-
-// tag : F2_sfinvsqrta
-class Hexagon_floati32_float_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_float_ty,llvm_i32_ty], [llvm_float_ty],
-       [IntrNoMem, Throws]>;
-
-// tag : V6_vtran2x2_map
-class Hexagon_v16i32v16i32_v16i32v16i32i32_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v16i32_ty,llvm_v16i32_ty], [llvm_v16i32_ty,llvm_v16i32_ty,llvm_i32_ty],
-       [IntrNoMem]>;
-
-// tag : V6_vtran2x2_map
-class Hexagon_v32i32v32i32_v32i32v32i32i32_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v32i32_ty,llvm_v32i32_ty], [llvm_v32i32_ty,llvm_v32i32_ty,llvm_i32_ty],
-       [IntrNoMem]>;
-
-// tag : V6_vlutvwh_oracc
-class Hexagon_v32i32_v32i32v16i32v16i32i32_Intrinsic<string GCCIntSuffix,
-      list<IntrinsicProperty> intr_properties = []>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v32i32_ty], [llvm_v32i32_ty,llvm_v16i32_ty,llvm_v16i32_ty,llvm_i32_ty],
-       !listconcat([IntrNoMem], intr_properties)>;
-
-// tag : V6_vlutvwh_oracc
-class Hexagon_v64i32_v64i32v32i32v32i32i32_Intrinsic<string GCCIntSuffix,
-      list<IntrinsicProperty> intr_properties = []>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v64i32_ty], [llvm_v64i32_ty,llvm_v32i32_ty,llvm_v32i32_ty,llvm_i32_ty],
-       !listconcat([IntrNoMem], intr_properties)>;
-
-// tag : F2_dfcmpge
-class Hexagon_i32_doubledouble_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_i32_ty], [llvm_double_ty,llvm_double_ty],
-       [IntrNoMem, Throws]>;
-
-// tag : F2_conv_df2d_chop
-class Hexagon_i64_double_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_i64_ty], [llvm_double_ty],
-       [IntrNoMem]>;
-
-// tag : F2_conv_sf2w
-class Hexagon_i32_float_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_i32_ty], [llvm_float_ty],
-       [IntrNoMem]>;
-
-// tag : F2_sfclass
-class Hexagon_i32_floati32_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_i32_ty], [llvm_float_ty,llvm_i32_ty],
-       [IntrNoMem, Throws, ImmArg<1>]>;
-
-// tag : F2_conv_sf2ud_chop
-class Hexagon_i64_float_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_i64_ty], [llvm_float_ty],
-       [IntrNoMem]>;
-
-// tag : V6_pred_scalar2v2
-class Hexagon_v512i1_i32_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v512i1_ty], [llvm_i32_ty],
-       [IntrNoMem]>;
-
-// tag : V6_pred_scalar2v2
-class Hexagon_v1024i1_i32_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v1024i1_ty], [llvm_i32_ty],
-       [IntrNoMem]>;
-
-// tag : F2_sfrecipa
-class Hexagon_floati32_floatfloat_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_float_ty,llvm_i32_ty], [llvm_float_ty,llvm_float_ty],
-       [IntrNoMem, Throws]>;
-
-// tag : V6_vprefixqh
-class Hexagon_v16i32_v512i1_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v16i32_ty], [llvm_v512i1_ty],
-       [IntrNoMem]>;
-
-// tag : V6_vprefixqh
-class Hexagon_v32i32_v1024i1_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v32i32_ty], [llvm_v1024i1_ty],
-       [IntrNoMem]>;
-
-// tag : V6_vdmpyhisat_acc
-class Hexagon_v16i32_v16i32v32i32i32_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v16i32_ty], [llvm_v16i32_ty,llvm_v32i32_ty,llvm_i32_ty],
-       [IntrNoMem]>;
-
-// tag : V6_vdmpyhisat_acc
-class Hexagon_v32i32_v32i32v64i32i32_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v32i32_ty], [llvm_v32i32_ty,llvm_v64i32_ty,llvm_i32_ty],
-       [IntrNoMem]>;
-
-// tag : F2_conv_ud2sf
-class Hexagon_float_i64_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_float_ty], [llvm_i64_ty],
-       [IntrNoMem]>;
-
-// tag : F2_conv_sf2df
-class Hexagon_double_float_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_double_ty], [llvm_float_ty],
-       [IntrNoMem]>;
-
-// tag : F2_sffma_sc
-class Hexagon_float_floatfloatfloati32_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_float_ty], [llvm_float_ty,llvm_float_ty,llvm_float_ty,llvm_i32_ty],
-       [IntrNoMem, Throws]>;
-
-// tag : F2_dfclass
-class Hexagon_i32_doublei32_Intrinsic<string GCCIntSuffix,
-                                      list<IntrinsicProperty> intr_properties = []>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_i32_ty], [llvm_double_ty,llvm_i32_ty],
-       !listconcat([IntrNoMem, Throws], intr_properties)>;
-
-// tag : V6_vd0
-class Hexagon_v16i32__Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v16i32_ty], [],
-       [IntrNoMem]>;
-
-// tag : V6_vd0
-class Hexagon_v32i32__Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v32i32_ty], [],
-       [IntrNoMem]>;
-
-// tag : V6_vdd0
-class Hexagon_v64i32__Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v64i32_ty], [],
-       [IntrNoMem]>;
-
-// tag : S2_insert_rp
-class Hexagon_i32_i32i32i64_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_i32_ty], [llvm_i32_ty,llvm_i32_ty,llvm_i64_ty],
-       [IntrNoMem]>;
-
-// tag : V6_vassignp
-class Hexagon_v64i32_v64i32_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v64i32_ty], [llvm_v64i32_ty],
-       [IntrNoMem]>;
-
-// tag : A6_vminub_RdP
-class Hexagon_i64i32_i64i64_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_i64_ty,llvm_i32_ty], [llvm_i64_ty,llvm_i64_ty],
-       [IntrNoMem]>;
-
-// tag : V6_pred_not
-class Hexagon_v512i1_v512i1_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v512i1_ty], [llvm_v512i1_ty],
-       [IntrNoMem]>;
-
-// tag : V6_pred_not
-class Hexagon_v1024i1_v1024i1_Intrinsic<string GCCIntSuffix>
-  : Hexagon_Intrinsic<GCCIntSuffix,
-       [llvm_v1024i1_ty], [llvm_v1024i1_ty],
-       [IntrNoMem]>;
-
-// V5 Scalar Instructions.
-
-def int_hexagon_S2_asr_r_p_or :
-Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_asr_r_p_or">;
-
-def int_hexagon_S2_vsatwh :
-Hexagon_i32_i64_Intrinsic<"HEXAGON_S2_vsatwh">;
-
-def int_hexagon_S2_tableidxd_goodsyntax :
-Hexagon_i32_i32i32i32i32_Intrinsic<"HEXAGON_S2_tableidxd_goodsyntax">;
-
-def int_hexagon_M2_mpysu_up :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpysu_up">;
-
-def int_hexagon_M2_mpyud_acc_ll_s0 :
-Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_mpyud_acc_ll_s0">;
-
-def int_hexagon_M2_mpyud_acc_ll_s1 :
-Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_mpyud_acc_ll_s1">;
-
-def int_hexagon_M2_cmpysc_s1 :
-Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_cmpysc_s1">;
-
-def int_hexagon_M2_cmpysc_s0 :
-Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_cmpysc_s0">;
-
-def int_hexagon_M4_cmpyi_whc :
-Hexagon_i32_i64i32_Intrinsic<"HEXAGON_M4_cmpyi_whc">;
-
-def int_hexagon_M2_mpy_sat_rnd_lh_s1 :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpy_sat_rnd_lh_s1">;
-
-def int_hexagon_M2_mpy_sat_rnd_lh_s0 :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpy_sat_rnd_lh_s0">;
-
-def int_hexagon_S2_tableidxb_goodsyntax :
-Hexagon_i32_i32i32i32i32_Intrinsic<"HEXAGON_S2_tableidxb_goodsyntax">;
-
-def int_hexagon_S2_shuffoh :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_S2_shuffoh">;
-
-def int_hexagon_F2_sfmax :
-Hexagon_float_floatfloat_Intrinsic<"HEXAGON_F2_sfmax">;
-
-def int_hexagon_A2_vabswsat :
-Hexagon_i64_i64_Intrinsic<"HEXAGON_A2_vabswsat">;
-
-def int_hexagon_S2_asr_i_r :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_S2_asr_i_r", [ImmArg<1>]>;
-
-def int_hexagon_S2_asr_i_p :
-Hexagon_i64_i64i32_Intrinsic<"HEXAGON_S2_asr_i_p", [ImmArg<1>]>;
-
-def int_hexagon_A4_combineri :
-Hexagon_i64_i32i32_Intrinsic<"HEXAGON_A4_combineri", [ImmArg<1>]>;
-
-def int_hexagon_M2_mpy_nac_sat_hl_s1 :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpy_nac_sat_hl_s1">;
-
-def int_hexagon_M4_vpmpyh_acc :
-Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M4_vpmpyh_acc">;
-
-def int_hexagon_M2_vcmpy_s0_sat_i :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M2_vcmpy_s0_sat_i">;
-
-def int_hexagon_A2_notp :
-Hexagon_i64_i64_Intrinsic<"HEXAGON_A2_notp">;
-
-def int_hexagon_M2_mpy_hl_s1 :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpy_hl_s1">;
-
-def int_hexagon_M2_mpy_hl_s0 :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpy_hl_s0">;
-
-def int_hexagon_C4_or_and :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_C4_or_and">;
-
-def int_hexagon_M2_vmac2s_s0 :
-Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_vmac2s_s0">;
-
-def int_hexagon_M2_vmac2s_s1 :
-Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_vmac2s_s1">;
-
-def int_hexagon_S2_brevp :
-Hexagon_i64_i64_Intrinsic<"HEXAGON_S2_brevp">;
-
-def int_hexagon_M4_pmpyw_acc :
-Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M4_pmpyw_acc">;
-
-def int_hexagon_S2_cl1 :
-Hexagon_i32_i32_Intrinsic<"HEXAGON_S2_cl1">;
-
-def int_hexagon_C4_cmplte :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_C4_cmplte">;
-
-def int_hexagon_M2_mmpyul_s0 :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M2_mmpyul_s0">;
-
-def int_hexagon_A2_vaddws :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vaddws">;
-
-def int_hexagon_A2_maxup :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_maxup">;
-
-def int_hexagon_A4_vcmphgti :
-Hexagon_i32_i64i32_Intrinsic<"HEXAGON_A4_vcmphgti", [ImmArg<1>]>;
-
-def int_hexagon_S2_interleave :
-Hexagon_i64_i64_Intrinsic<"HEXAGON_S2_interleave">;
-
-def int_hexagon_M2_vrcmpyi_s0 :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M2_vrcmpyi_s0">;
-
-def int_hexagon_A2_abssat :
-Hexagon_i32_i32_Intrinsic<"HEXAGON_A2_abssat">;
-
-def int_hexagon_A2_vcmpwgtu :
-Hexagon_i32_i64i64_Intrinsic<"HEXAGON_A2_vcmpwgtu">;
-
-def int_hexagon_C2_cmpgtu :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_C2_cmpgtu">;
-
-def int_hexagon_C2_cmpgtp :
-Hexagon_i32_i64i64_Intrinsic<"HEXAGON_C2_cmpgtp">;
-
-def int_hexagon_A4_cmphgtui :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A4_cmphgtui", [ImmArg<1>]>;
-
-def int_hexagon_C2_cmpgti :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_C2_cmpgti", [ImmArg<1>]>;
-
-def int_hexagon_M2_mpyi :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpyi">;
-
-def int_hexagon_F2_conv_df2uw_chop :
-Hexagon_i32_double_Intrinsic<"HEXAGON_F2_conv_df2uw_chop">;
-
-def int_hexagon_A4_cmpheq :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A4_cmpheq">;
-
-def int_hexagon_M2_mpy_lh_s1 :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpy_lh_s1">;
-
-def int_hexagon_M2_mpy_lh_s0 :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpy_lh_s0">;
-
-def int_hexagon_S2_lsr_i_r_xacc :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S2_lsr_i_r_xacc", [ImmArg<2>]>;
-
-def int_hexagon_S2_vrcnegh :
-Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_vrcnegh">;
-
-def int_hexagon_S2_extractup :
-Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_S2_extractup", [ImmArg<1>, ImmArg<2>]>;
-
-def int_hexagon_S2_asr_i_p_rnd_goodsyntax :
-Hexagon_i64_i64i32_Intrinsic<"HEXAGON_S2_asr_i_p_rnd_goodsyntax", [ImmArg<1>]>;
-
-def int_hexagon_S4_ntstbit_r :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_S4_ntstbit_r">;
-
-def int_hexagon_F2_conv_w2sf :
-Hexagon_float_i32_Intrinsic<"HEXAGON_F2_conv_w2sf">;
-
-def int_hexagon_C2_not :
-Hexagon_i32_i32_Intrinsic<"HEXAGON_C2_not">;
-
-def int_hexagon_C2_tfrpr :
-Hexagon_i32_i32_Intrinsic<"HEXAGON_C2_tfrpr">;
-
-def int_hexagon_M2_mpy_ll_s1 :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpy_ll_s1">;
-
-def int_hexagon_M2_mpy_ll_s0 :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpy_ll_s0">;
-
-def int_hexagon_A4_cmpbgt :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A4_cmpbgt">;
-
-def int_hexagon_S2_asr_r_r_and :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S2_asr_r_r_and">;
-
-def int_hexagon_A4_rcmpneqi :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A4_rcmpneqi", [ImmArg<1>]>;
-
-def int_hexagon_S2_asl_i_r_nac :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S2_asl_i_r_nac", [ImmArg<2>]>;
-
-def int_hexagon_M2_subacc :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_subacc">;
-
-def int_hexagon_A2_orp :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_orp">;
-
-def int_hexagon_M2_mpyu_up :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpyu_up">;
-
-def int_hexagon_M2_mpy_acc_sat_lh_s1 :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpy_acc_sat_lh_s1">;
-
-def int_hexagon_S2_asr_i_vh :
-Hexagon_i64_i64i32_Intrinsic<"HEXAGON_S2_asr_i_vh", [ImmArg<1>]>;
-
-def int_hexagon_S2_asr_i_vw :
-Hexagon_i64_i64i32_Intrinsic<"HEXAGON_S2_asr_i_vw", [ImmArg<1>]>;
-
-def int_hexagon_A4_cmpbgtu :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A4_cmpbgtu">;
-
-def int_hexagon_A4_vcmpbeq_any :
-Hexagon_i32_i64i64_Intrinsic<"HEXAGON_A4_vcmpbeq_any">;
-
-def int_hexagon_A4_cmpbgti :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A4_cmpbgti", [ImmArg<1>]>;
-
-def int_hexagon_M2_mpyd_lh_s1 :
-Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_mpyd_lh_s1">;
-
-def int_hexagon_S2_asl_r_p_nac :
-Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_asl_r_p_nac">;
-
-def int_hexagon_S2_lsr_i_r_nac :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S2_lsr_i_r_nac", [ImmArg<2>]>;
-
-def int_hexagon_A2_addsp :
-Hexagon_i64_i32i64_Intrinsic<"HEXAGON_A2_addsp">;
-
-def int_hexagon_S4_vxsubaddw :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_S4_vxsubaddw">;
-
-def int_hexagon_A4_vcmpheqi :
-Hexagon_i32_i64i32_Intrinsic<"HEXAGON_A4_vcmpheqi", [ImmArg<1>]>;
-
-def int_hexagon_S4_vxsubaddh :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_S4_vxsubaddh">;
-
-def int_hexagon_M4_pmpyw :
-Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M4_pmpyw">;
-
-def int_hexagon_S2_vsathb :
-Hexagon_i32_i64_Intrinsic<"HEXAGON_S2_vsathb">;
-
-def int_hexagon_S2_asr_r_p_and :
-Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_asr_r_p_and">;
-
-def int_hexagon_M2_mpyu_acc_lh_s1 :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpyu_acc_lh_s1">;
-
-def int_hexagon_M2_mpyu_acc_lh_s0 :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpyu_acc_lh_s0">;
-
-def int_hexagon_S2_lsl_r_p_acc :
-Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_lsl_r_p_acc">;
-
-def int_hexagon_A2_pxorf :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_A2_pxorf">;
-
-def int_hexagon_C2_cmpgei :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_C2_cmpgei", [ImmArg<1>]>;
-
-def int_hexagon_A2_vsubub :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vsubub">;
-
-def int_hexagon_S2_asl_i_p :
-Hexagon_i64_i64i32_Intrinsic<"HEXAGON_S2_asl_i_p", [ImmArg<1>]>;
-
-def int_hexagon_S2_asl_i_r :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_S2_asl_i_r", [ImmArg<1>]>;
-
-def int_hexagon_A4_vrminuw :
-Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_A4_vrminuw">;
-
-def int_hexagon_F2_sffma :
-Hexagon_float_floatfloatfloat_Intrinsic<"HEXAGON_F2_sffma">;
-
-def int_hexagon_A2_absp :
-Hexagon_i64_i64_Intrinsic<"HEXAGON_A2_absp">;
-
-def int_hexagon_C2_all8 :
-Hexagon_i32_i32_Intrinsic<"HEXAGON_C2_all8">;
-
-def int_hexagon_A4_vrminuh :
-Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_A4_vrminuh">;
-
-def int_hexagon_F2_sffma_lib :
-Hexagon_float_floatfloatfloat_Intrinsic<"HEXAGON_F2_sffma_lib">;
-
-def int_hexagon_M4_vrmpyoh_s0 :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M4_vrmpyoh_s0">;
-
-def int_hexagon_M4_vrmpyoh_s1 :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M4_vrmpyoh_s1">;
-
-def int_hexagon_C2_bitsset :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_C2_bitsset">;
-
-def int_hexagon_M2_mpysip :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpysip", [ImmArg<1>]>;
-
-def int_hexagon_M2_mpysin :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpysin", [ImmArg<1>]>;
-
-def int_hexagon_A4_boundscheck :
-Hexagon_i32_i32i64_Intrinsic<"HEXAGON_A4_boundscheck">;
-
-def int_hexagon_M5_vrmpybuu :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M5_vrmpybuu">;
-
-def int_hexagon_C4_fastcorner9 :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_C4_fastcorner9">;
-
-def int_hexagon_M2_vrcmpys_s1rp :
-Hexagon_i32_i64i32_Intrinsic<"HEXAGON_M2_vrcmpys_s1rp">;
-
-def int_hexagon_A2_neg :
-Hexagon_i32_i32_Intrinsic<"HEXAGON_A2_neg">;
-
-def int_hexagon_A2_subsat :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_subsat">;
-
-def int_hexagon_S2_asl_r_r :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_S2_asl_r_r">;
-
-def int_hexagon_S2_asl_r_p :
-Hexagon_i64_i64i32_Intrinsic<"HEXAGON_S2_asl_r_p">;
-
-def int_hexagon_A2_vnavgh :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vnavgh">;
-
-def int_hexagon_M2_mpy_nac_sat_hl_s0 :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpy_nac_sat_hl_s0">;
-
-def int_hexagon_F2_conv_ud2df :
-Hexagon_double_i64_Intrinsic<"HEXAGON_F2_conv_ud2df">;
-
-def int_hexagon_A2_vnavgw :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vnavgw">;
-
-def int_hexagon_S2_asl_i_r_acc :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S2_asl_i_r_acc", [ImmArg<2>]>;
-
-def int_hexagon_S4_subi_lsr_ri :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S4_subi_lsr_ri", [ImmArg<0>, ImmArg<2>]>;
-
-def int_hexagon_S2_vzxthw :
-Hexagon_i64_i32_Intrinsic<"HEXAGON_S2_vzxthw">;
-
-def int_hexagon_F2_sfadd :
-Hexagon_float_floatfloat_Intrinsic<"HEXAGON_F2_sfadd">;
-
-def int_hexagon_A2_sub :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_sub">;
-
-def int_hexagon_M2_vmac2su_s0 :
-Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_vmac2su_s0">;
-
-def int_hexagon_M2_vmac2su_s1 :
-Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_vmac2su_s1">;
-
-def int_hexagon_M2_dpmpyss_s0 :
-Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_dpmpyss_s0">;
-
-def int_hexagon_S2_insert :
-Hexagon_i32_i32i32i32i32_Intrinsic<"HEXAGON_S2_insert">;
-
-def int_hexagon_S2_packhl :
-Hexagon_i64_i32i32_Intrinsic<"HEXAGON_S2_packhl">;
-
-def int_hexagon_A4_vcmpwgti :
-Hexagon_i32_i64i32_Intrinsic<"HEXAGON_A4_vcmpwgti", [ImmArg<1>]>;
-
-def int_hexagon_A2_vavguwr :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vavguwr">;
-
-def int_hexagon_S2_asl_r_r_and :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S2_asl_r_r_and">;
-
-def int_hexagon_A2_svsubhs :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_svsubhs">;
-
-def int_hexagon_A2_addh_l16_hl :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_addh_l16_hl">;
-
-def int_hexagon_M4_and_and :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M4_and_and">;
-
-def int_hexagon_F2_conv_d2df :
-Hexagon_double_i64_Intrinsic<"HEXAGON_F2_conv_d2df">;
-
-def int_hexagon_C2_cmpgtui :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_C2_cmpgtui", [ImmArg<1>]>;
-
-def int_hexagon_A2_vconj :
-Hexagon_i64_i64_Intrinsic<"HEXAGON_A2_vconj">;
-
-def int_hexagon_S2_lsr_r_vw :
-Hexagon_i64_i64i32_Intrinsic<"HEXAGON_S2_lsr_r_vw">;
-
-def int_hexagon_S2_lsr_r_vh :
-Hexagon_i64_i64i32_Intrinsic<"HEXAGON_S2_lsr_r_vh">;
-
-def int_hexagon_A2_subh_l16_hl :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_subh_l16_hl">;
-
-def int_hexagon_S4_vxsubaddhr :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_S4_vxsubaddhr">;
-
-def int_hexagon_S2_clbp :
-Hexagon_i32_i64_Intrinsic<"HEXAGON_S2_clbp">;
-
-def int_hexagon_S2_deinterleave :
-Hexagon_i64_i64_Intrinsic<"HEXAGON_S2_deinterleave">;
-
-def int_hexagon_C2_any8 :
-Hexagon_i32_i32_Intrinsic<"HEXAGON_C2_any8">;
-
-def int_hexagon_S2_togglebit_r :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_S2_togglebit_r">;
-
-def int_hexagon_S2_togglebit_i :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_S2_togglebit_i", [ImmArg<1>]>;
-
-def int_hexagon_F2_conv_uw2sf :
-Hexagon_float_i32_Intrinsic<"HEXAGON_F2_conv_uw2sf">;
-
-def int_hexagon_S2_vsathb_nopack :
-Hexagon_i64_i64_Intrinsic<"HEXAGON_S2_vsathb_nopack">;
-
-def int_hexagon_M2_cmacs_s0 :
-Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_cmacs_s0">;
-
-def int_hexagon_M2_cmacs_s1 :
-Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_cmacs_s1">;
-
-def int_hexagon_M2_mpy_sat_hh_s0 :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpy_sat_hh_s0">;
-
-def int_hexagon_M2_mpy_sat_hh_s1 :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpy_sat_hh_s1">;
-
-def int_hexagon_M2_mmacuhs_s1 :
-Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M2_mmacuhs_s1">;
-
-def int_hexagon_M2_mmacuhs_s0 :
-Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M2_mmacuhs_s0">;
-
-def int_hexagon_S2_clrbit_r :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_S2_clrbit_r">;
-
-def int_hexagon_C4_or_andn :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_C4_or_andn">;
-
-def int_hexagon_S2_asl_r_r_nac :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S2_asl_r_r_nac">;
-
-def int_hexagon_S2_asl_i_p_acc :
-Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_asl_i_p_acc", [ImmArg<2>]>;
-
-def int_hexagon_A4_vcmpwgtui :
-Hexagon_i32_i64i32_Intrinsic<"HEXAGON_A4_vcmpwgtui", [ImmArg<1>]>;
-
-def int_hexagon_M4_vrmpyoh_acc_s0 :
-Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M4_vrmpyoh_acc_s0">;
-
-def int_hexagon_M4_vrmpyoh_acc_s1 :
-Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M4_vrmpyoh_acc_s1">;
-
-def int_hexagon_A4_vrmaxh :
-Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_A4_vrmaxh">;
-
-def int_hexagon_A2_vcmpbeq :
-Hexagon_i32_i64i64_Intrinsic<"HEXAGON_A2_vcmpbeq">;
-
-def int_hexagon_A2_vcmphgt :
-Hexagon_i32_i64i64_Intrinsic<"HEXAGON_A2_vcmphgt">;
-
-def int_hexagon_A2_vnavgwcr :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vnavgwcr">;
-
-def int_hexagon_M2_vrcmacr_s0c :
-Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M2_vrcmacr_s0c">;
-
-def int_hexagon_A2_vavgwcr :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vavgwcr">;
-
-def int_hexagon_S2_asl_i_p_xacc :
-Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_asl_i_p_xacc", [ImmArg<2>]>;
-
-def int_hexagon_A4_vrmaxw :
-Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_A4_vrmaxw">;
-
-def int_hexagon_A2_vnavghr :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vnavghr">;
-
-def int_hexagon_M4_cmpyi_wh :
-Hexagon_i32_i64i32_Intrinsic<"HEXAGON_M4_cmpyi_wh">;
-
-def int_hexagon_A2_tfrsi :
-Hexagon_i32_i32_Intrinsic<"HEXAGON_A2_tfrsi", [ImmArg<0>]>;
-
-def int_hexagon_S2_asr_i_r_acc :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S2_asr_i_r_acc", [ImmArg<2>]>;
-
-def int_hexagon_A2_svnavgh :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_svnavgh">;
-
-def int_hexagon_S2_lsr_i_r :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_S2_lsr_i_r", [ImmArg<1>]>;
-
-def int_hexagon_M2_vmac2 :
-Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_vmac2">;
-
-def int_hexagon_A4_vcmphgtui :
-Hexagon_i32_i64i32_Intrinsic<"HEXAGON_A4_vcmphgtui", [ImmArg<1>]>;
-
-def int_hexagon_A2_svavgh :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_svavgh">;
-
-def int_hexagon_M4_vrmpyeh_acc_s0 :
-Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M4_vrmpyeh_acc_s0">;
-
-def int_hexagon_M4_vrmpyeh_acc_s1 :
-Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M4_vrmpyeh_acc_s1">;
-
-def int_hexagon_S2_lsr_i_p :
-Hexagon_i64_i64i32_Intrinsic<"HEXAGON_S2_lsr_i_p", [ImmArg<1>]>;
-
-def int_hexagon_A2_combine_hl :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_combine_hl">;
-
-def int_hexagon_M2_mpy_up :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpy_up">;
-
-def int_hexagon_A2_combine_hh :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_combine_hh">;
-
-def int_hexagon_A2_negsat :
-Hexagon_i32_i32_Intrinsic<"HEXAGON_A2_negsat">;
-
-def int_hexagon_M2_mpyd_hl_s0 :
-Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_mpyd_hl_s0">;
-
-def int_hexagon_M2_mpyd_hl_s1 :
-Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_mpyd_hl_s1">;
-
-def int_hexagon_A4_bitsplit :
-Hexagon_i64_i32i32_Intrinsic<"HEXAGON_A4_bitsplit">;
-
-def int_hexagon_A2_vabshsat :
-Hexagon_i64_i64_Intrinsic<"HEXAGON_A2_vabshsat">;
-
-def int_hexagon_M2_mpyui :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpyui">;
-
-def int_hexagon_A2_addh_l16_sat_ll :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_addh_l16_sat_ll">;
-
-def int_hexagon_S2_lsl_r_r_and :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S2_lsl_r_r_and">;
-
-def int_hexagon_M2_mmpyul_rs0 :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M2_mmpyul_rs0">;
-
-def int_hexagon_S2_asr_i_r_rnd_goodsyntax :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_S2_asr_i_r_rnd_goodsyntax", [ImmArg<1>]>;
-
-def int_hexagon_S2_lsr_r_p_nac :
-Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_lsr_r_p_nac">;
-
-def int_hexagon_C2_cmplt :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_C2_cmplt">;
-
-def int_hexagon_M2_cmacr_s0 :
-Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_cmacr_s0">;
-
-def int_hexagon_M4_or_and :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M4_or_and">;
-
-def int_hexagon_M4_mpyrr_addi :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M4_mpyrr_addi", [ImmArg<0>]>;
-
-def int_hexagon_S4_or_andi :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S4_or_andi", [ImmArg<2>]>;
-
-def int_hexagon_M2_mpy_sat_hl_s0 :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpy_sat_hl_s0">;
-
-def int_hexagon_M2_mpy_sat_hl_s1 :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpy_sat_hl_s1">;
-
-def int_hexagon_M4_mpyrr_addr :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M4_mpyrr_addr">;
-
-def int_hexagon_M2_mmachs_rs0 :
-Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M2_mmachs_rs0">;
-
-def int_hexagon_M2_mmachs_rs1 :
-Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M2_mmachs_rs1">;
-
-def int_hexagon_M2_vrcmpyr_s0c :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M2_vrcmpyr_s0c">;
-
-def int_hexagon_M2_mpy_acc_sat_hl_s0 :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpy_acc_sat_hl_s0">;
-
-def int_hexagon_M2_mpyd_acc_ll_s1 :
-Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_mpyd_acc_ll_s1">;
-
-def int_hexagon_F2_sffixupn :
-Hexagon_float_floatfloat_Intrinsic<"HEXAGON_F2_sffixupn">;
-
-def int_hexagon_M2_mpyd_acc_lh_s0 :
-Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_mpyd_acc_lh_s0">;
-
-def int_hexagon_M2_mpyd_acc_lh_s1 :
-Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_mpyd_acc_lh_s1">;
-
-def int_hexagon_M2_mpy_rnd_hh_s0 :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpy_rnd_hh_s0">;
-
-def int_hexagon_M2_mpy_rnd_hh_s1 :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpy_rnd_hh_s1">;
-
-def int_hexagon_A2_vadduhs :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vadduhs">;
-
-def int_hexagon_A2_vsubuhs :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vsubuhs">;
-
-def int_hexagon_A2_subh_h16_hl :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_subh_h16_hl">;
-
-def int_hexagon_A2_subh_h16_hh :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_subh_h16_hh">;
-
-def int_hexagon_A2_xorp :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_xorp">;
-
-def int_hexagon_A4_tfrpcp :
-Hexagon_i64_i64_Intrinsic<"HEXAGON_A4_tfrpcp">;
-
-def int_hexagon_A2_addh_h16_lh :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_addh_h16_lh">;
-
-def int_hexagon_A2_addh_h16_sat_hl :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_addh_h16_sat_hl">;
-
-def int_hexagon_A2_addh_h16_ll :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_addh_h16_ll">;
-
-def int_hexagon_A2_addh_h16_sat_hh :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_addh_h16_sat_hh">;
-
-def int_hexagon_A2_zxtb :
-Hexagon_i32_i32_Intrinsic<"HEXAGON_A2_zxtb">;
-
-def int_hexagon_A2_zxth :
-Hexagon_i32_i32_Intrinsic<"HEXAGON_A2_zxth">;
-
-def int_hexagon_A2_vnavgwr :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vnavgwr">;
-
-def int_hexagon_M4_or_xor :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M4_or_xor">;
-
-def int_hexagon_M2_mpyud_acc_hh_s0 :
-Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_mpyud_acc_hh_s0">;
-
-def int_hexagon_M2_mpyud_acc_hh_s1 :
-Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_mpyud_acc_hh_s1">;
-
-def int_hexagon_M5_vmacbsu :
-Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M5_vmacbsu">;
-
-def int_hexagon_M2_dpmpyuu_acc_s0 :
-Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_dpmpyuu_acc_s0">;
-
-def int_hexagon_M2_mpy_rnd_hl_s0 :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpy_rnd_hl_s0">;
-
-def int_hexagon_M2_mpy_rnd_hl_s1 :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpy_rnd_hl_s1">;
-
-def int_hexagon_F2_sffms_lib :
-Hexagon_float_floatfloatfloat_Intrinsic<"HEXAGON_F2_sffms_lib">;
-
-def int_hexagon_C4_cmpneqi :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_C4_cmpneqi", [ImmArg<1>]>;
-
-def int_hexagon_M4_and_xor :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M4_and_xor">;
-
-def int_hexagon_A2_sat :
-Hexagon_i32_i64_Intrinsic<"HEXAGON_A2_sat">;
-
-def int_hexagon_M2_mpyd_nac_lh_s1 :
-Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_mpyd_nac_lh_s1">;
-
-def int_hexagon_M2_mpyd_nac_lh_s0 :
-Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_mpyd_nac_lh_s0">;
-
-def int_hexagon_A2_addsat :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_addsat">;
-
-def int_hexagon_A2_svavghs :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_svavghs">;
-
-def int_hexagon_A2_vrsadub_acc :
-Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_A2_vrsadub_acc">;
-
-def int_hexagon_C2_bitsclri :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_C2_bitsclri", [ImmArg<1>]>;
-
-def int_hexagon_A2_subh_h16_sat_hh :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_subh_h16_sat_hh">;
-
-def int_hexagon_A2_subh_h16_sat_hl :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_subh_h16_sat_hl">;
-
-def int_hexagon_M2_mmaculs_rs0 :
-Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M2_mmaculs_rs0">;
-
-def int_hexagon_M2_mmaculs_rs1 :
-Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M2_mmaculs_rs1">;
-
-def int_hexagon_M2_vradduh :
-Hexagon_i32_i64i64_Intrinsic<"HEXAGON_M2_vradduh">;
-
-def int_hexagon_A4_addp_c :
-Hexagon_i64i32_i64i64i32_Intrinsic<"HEXAGON_A4_addp_c">;
-
-def int_hexagon_C2_xor :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_C2_xor">;
-
-def int_hexagon_S2_lsl_r_r_acc :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S2_lsl_r_r_acc">;
-
-def int_hexagon_M2_mmpyh_rs1 :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M2_mmpyh_rs1">;
-
-def int_hexagon_M2_mmpyh_rs0 :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M2_mmpyh_rs0">;
-
-def int_hexagon_F2_conv_df2ud_chop :
-Hexagon_i64_double_Intrinsic<"HEXAGON_F2_conv_df2ud_chop">;
-
-def int_hexagon_C4_or_or :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_C4_or_or">;
-
-def int_hexagon_S4_vxaddsubhr :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_S4_vxaddsubhr">;
-
-def int_hexagon_S2_vsathub :
-Hexagon_i32_i64_Intrinsic<"HEXAGON_S2_vsathub">;
-
-def int_hexagon_F2_conv_df2sf :
-Hexagon_float_double_Intrinsic<"HEXAGON_F2_conv_df2sf">;
-
-def int_hexagon_M2_hmmpyh_rs1 :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_hmmpyh_rs1">;
-
-def int_hexagon_M2_hmmpyh_s1 :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_hmmpyh_s1">;
-
-def int_hexagon_A2_vavgwr :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vavgwr">;
-
-def int_hexagon_S2_tableidxh_goodsyntax :
-Hexagon_i32_i32i32i32i32_Intrinsic<"HEXAGON_S2_tableidxh_goodsyntax">;
-
-def int_hexagon_A2_sxth :
-Hexagon_i32_i32_Intrinsic<"HEXAGON_A2_sxth">;
-
-def int_hexagon_A2_sxtb :
-Hexagon_i32_i32_Intrinsic<"HEXAGON_A2_sxtb">;
-
-def int_hexagon_C4_or_orn :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_C4_or_orn">;
-
-def int_hexagon_M2_vrcmaci_s0c :
-Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M2_vrcmaci_s0c">;
-
-def int_hexagon_A2_sxtw :
-Hexagon_i64_i32_Intrinsic<"HEXAGON_A2_sxtw">;
-
-def int_hexagon_M2_vabsdiffh :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M2_vabsdiffh">;
-
-def int_hexagon_M2_mpy_acc_lh_s1 :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpy_acc_lh_s1">;
-
-def int_hexagon_M2_mpy_acc_lh_s0 :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpy_acc_lh_s0">;
-
-def int_hexagon_M2_hmmpyl_s1 :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_hmmpyl_s1">;
-
-def int_hexagon_S2_cl1p :
-Hexagon_i32_i64_Intrinsic<"HEXAGON_S2_cl1p">;
-
-def int_hexagon_M2_vabsdiffw :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M2_vabsdiffw">;
-
-def int_hexagon_A4_andnp :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A4_andnp">;
-
-def int_hexagon_C2_vmux :
-Hexagon_i64_i32i64i64_Intrinsic<"HEXAGON_C2_vmux">;
-
-def int_hexagon_S2_parityp :
-Hexagon_i32_i64i64_Intrinsic<"HEXAGON_S2_parityp">;
-
-def int_hexagon_S2_lsr_i_p_and :
-Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_lsr_i_p_and", [ImmArg<2>]>;
-
-def int_hexagon_S2_asr_i_r_or :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S2_asr_i_r_or", [ImmArg<2>]>;
-
-def int_hexagon_M2_mpyu_nac_ll_s0 :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpyu_nac_ll_s0">;
-
-def int_hexagon_M2_mpyu_nac_ll_s1 :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpyu_nac_ll_s1">;
-
-def int_hexagon_F2_sfcmpeq :
-Hexagon_i32_floatfloat_Intrinsic<"HEXAGON_F2_sfcmpeq">;
-
-def int_hexagon_A2_vaddb_map :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vaddb_map">;
-
-def int_hexagon_S2_lsr_r_r_nac :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S2_lsr_r_r_nac">;
-
-def int_hexagon_A2_vcmpheq :
-Hexagon_i32_i64i64_Intrinsic<"HEXAGON_A2_vcmpheq">;
-
-def int_hexagon_S2_clbnorm :
-Hexagon_i32_i32_Intrinsic<"HEXAGON_S2_clbnorm">;
-
-def int_hexagon_M2_cnacsc_s1 :
-Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_cnacsc_s1">;
-
-def int_hexagon_M2_cnacsc_s0 :
-Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_cnacsc_s0">;
-
-def int_hexagon_S4_subaddi :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S4_subaddi", [ImmArg<1>]>;
-
-def int_hexagon_M2_mpyud_nac_hl_s1 :
-Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_mpyud_nac_hl_s1">;
-
-def int_hexagon_M2_mpyud_nac_hl_s0 :
-Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_mpyud_nac_hl_s0">;
-
-def int_hexagon_S5_vasrhrnd_goodsyntax :
-Hexagon_i64_i64i32_Intrinsic<"HEXAGON_S5_vasrhrnd_goodsyntax", [ImmArg<1>]>;
-
-def int_hexagon_S2_tstbit_r :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_S2_tstbit_r">;
-
-def int_hexagon_S4_vrcrotate :
-Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_S4_vrcrotate", [ImmArg<2>]>;
-
-def int_hexagon_M2_mmachs_s1 :
-Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M2_mmachs_s1">;
-
-def int_hexagon_M2_mmachs_s0 :
-Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M2_mmachs_s0">;
-
-def int_hexagon_S2_tstbit_i :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_S2_tstbit_i", [ImmArg<1>]>;
-
-def int_hexagon_M2_mpy_up_s1 :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpy_up_s1">;
-
-def int_hexagon_S2_extractu_rp :
-Hexagon_i32_i32i64_Intrinsic<"HEXAGON_S2_extractu_rp">;
-
-def int_hexagon_M2_mmpyuh_rs0 :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M2_mmpyuh_rs0">;
-
-def int_hexagon_S2_lsr_i_vw :
-Hexagon_i64_i64i32_Intrinsic<"HEXAGON_S2_lsr_i_vw", [ImmArg<1>]>;
-
-def int_hexagon_M2_mpy_rnd_ll_s0 :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpy_rnd_ll_s0">;
-
-def int_hexagon_M2_mpy_rnd_ll_s1 :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpy_rnd_ll_s1">;
-
-def int_hexagon_M4_or_or :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M4_or_or">;
-
-def int_hexagon_M2_mpyu_hh_s1 :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpyu_hh_s1">;
-
-def int_hexagon_M2_mpyu_hh_s0 :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpyu_hh_s0">;
-
-def int_hexagon_S2_asl_r_p_acc :
-Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_asl_r_p_acc">;
-
-def int_hexagon_M2_mpyu_nac_lh_s0 :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpyu_nac_lh_s0">;
-
-def int_hexagon_M2_mpyu_nac_lh_s1 :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpyu_nac_lh_s1">;
-
-def int_hexagon_M2_mpy_sat_ll_s0 :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpy_sat_ll_s0">;
-
-def int_hexagon_M2_mpy_sat_ll_s1 :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpy_sat_ll_s1">;
-
-def int_hexagon_F2_conv_w2df :
-Hexagon_double_i32_Intrinsic<"HEXAGON_F2_conv_w2df">;
-
-def int_hexagon_A2_subh_l16_sat_hl :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_subh_l16_sat_hl">;
-
-def int_hexagon_C2_cmpeqi :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_C2_cmpeqi", [ImmArg<1>]>;
-
-def int_hexagon_S2_asl_i_r_and :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S2_asl_i_r_and", [ImmArg<2>]>;
-
-def int_hexagon_S2_vcnegh :
-Hexagon_i64_i64i32_Intrinsic<"HEXAGON_S2_vcnegh">;
-
-def int_hexagon_A4_vcmpweqi :
-Hexagon_i32_i64i32_Intrinsic<"HEXAGON_A4_vcmpweqi", [ImmArg<1>]>;
-
-def int_hexagon_M2_vdmpyrs_s0 :
-Hexagon_i32_i64i64_Intrinsic<"HEXAGON_M2_vdmpyrs_s0">;
-
-def int_hexagon_M2_vdmpyrs_s1 :
-Hexagon_i32_i64i64_Intrinsic<"HEXAGON_M2_vdmpyrs_s1">;
-
-def int_hexagon_M4_xor_xacc :
-Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M4_xor_xacc">;
-
-def int_hexagon_M2_vdmpys_s1 :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M2_vdmpys_s1">;
-
-def int_hexagon_M2_vdmpys_s0 :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M2_vdmpys_s0">;
-
-def int_hexagon_A2_vavgubr :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vavgubr">;
-
-def int_hexagon_M2_mpyu_hl_s1 :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpyu_hl_s1">;
-
-def int_hexagon_M2_mpyu_hl_s0 :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpyu_hl_s0">;
-
-def int_hexagon_S2_asl_r_r_acc :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S2_asl_r_r_acc">;
-
-def int_hexagon_S2_cl0p :
-Hexagon_i32_i64_Intrinsic<"HEXAGON_S2_cl0p">;
-
-def int_hexagon_S2_valignib :
-Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_valignib", [ImmArg<2>]>;
-
-def int_hexagon_F2_sffixupd :
-Hexagon_float_floatfloat_Intrinsic<"HEXAGON_F2_sffixupd">;
-
-def int_hexagon_M2_mpy_sat_rnd_hl_s1 :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpy_sat_rnd_hl_s1">;
-
-def int_hexagon_M2_mpy_sat_rnd_hl_s0 :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpy_sat_rnd_hl_s0">;
-
-def int_hexagon_M2_cmacsc_s0 :
-Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_cmacsc_s0">;
-
-def int_hexagon_M2_cmacsc_s1 :
-Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_cmacsc_s1">;
-
-def int_hexagon_S2_ct1 :
-Hexagon_i32_i32_Intrinsic<"HEXAGON_S2_ct1">;
-
-def int_hexagon_S2_ct0 :
-Hexagon_i32_i32_Intrinsic<"HEXAGON_S2_ct0">;
-
-def int_hexagon_M2_dpmpyuu_nac_s0 :
-Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_dpmpyuu_nac_s0">;
-
-def int_hexagon_M2_mmpyul_rs1 :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M2_mmpyul_rs1">;
-
-def int_hexagon_S4_ntstbit_i :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_S4_ntstbit_i", [ImmArg<1>]>   ;
-
-def int_hexagon_F2_sffixupr :
-Hexagon_float_float_Intrinsic<"HEXAGON_F2_sffixupr">;
-
-def int_hexagon_S2_asr_r_p_xor :
-Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_asr_r_p_xor">;
-
-def int_hexagon_M2_mpyud_acc_hl_s0 :
-Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_mpyud_acc_hl_s0">;
-
-def int_hexagon_M2_mpyud_acc_hl_s1 :
-Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_mpyud_acc_hl_s1">;
-
-def int_hexagon_A2_vcmphgtu :
-Hexagon_i32_i64i64_Intrinsic<"HEXAGON_A2_vcmphgtu">;
-
-def int_hexagon_C2_andn :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_C2_andn">;
-
-def int_hexagon_M2_vmpy2s_s0pack :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_vmpy2s_s0pack">;
-
-def int_hexagon_S4_addaddi :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S4_addaddi", [ImmArg<2>]>;
-
-def int_hexagon_M2_mpyd_acc_ll_s0 :
-Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_mpyd_acc_ll_s0">;
-
-def int_hexagon_M2_mpy_acc_sat_hl_s1 :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpy_acc_sat_hl_s1">;
-
-def int_hexagon_A4_rcmpeqi :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A4_rcmpeqi", [ImmArg<1>]>;
-
-def int_hexagon_M4_xor_and :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M4_xor_and">;
-
-def int_hexagon_S2_asl_i_p_and :
-Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_asl_i_p_and", [ImmArg<2>]>;
-
-def int_hexagon_M2_mmpyuh_rs1 :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M2_mmpyuh_rs1">;
-
-def int_hexagon_S2_asr_r_r_or :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S2_asr_r_r_or">;
-
-def int_hexagon_A4_round_ri :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A4_round_ri", [ImmArg<1>]>;
-
-def int_hexagon_A2_max :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_max">;
-
-def int_hexagon_A4_round_rr :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A4_round_rr">;
-
-def int_hexagon_A4_combineii :
-Hexagon_i64_i32i32_Intrinsic<"HEXAGON_A4_combineii", [ImmArg<0>, ImmArg<1>]>;
-
-def int_hexagon_A4_combineir :
-Hexagon_i64_i32i32_Intrinsic<"HEXAGON_A4_combineir", [ImmArg<0>]>;
-
-def int_hexagon_C4_and_orn :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_C4_and_orn">;
-
-def int_hexagon_M5_vmacbuu :
-Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M5_vmacbuu">;
-
-def int_hexagon_A4_rcmpeq :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A4_rcmpeq">;
-
-def int_hexagon_M4_cmpyr_whc :
-Hexagon_i32_i64i32_Intrinsic<"HEXAGON_M4_cmpyr_whc">;
-
-def int_hexagon_S2_lsr_i_r_acc :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S2_lsr_i_r_acc", [ImmArg<2>]>;
-
-def int_hexagon_S2_vzxtbh :
-Hexagon_i64_i32_Intrinsic<"HEXAGON_S2_vzxtbh">;
-
-def int_hexagon_M2_mmacuhs_rs1 :
-Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M2_mmacuhs_rs1">;
-
-def int_hexagon_S2_asr_r_r_sat :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_S2_asr_r_r_sat">;
-
-def int_hexagon_A2_combinew :
-Hexagon_i64_i32i32_Intrinsic<"HEXAGON_A2_combinew">;
-
-def int_hexagon_M2_mpy_acc_ll_s1 :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpy_acc_ll_s1">;
-
-def int_hexagon_M2_mpy_acc_ll_s0 :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpy_acc_ll_s0">;
-
-def int_hexagon_M2_cmpyi_s0 :
-Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_cmpyi_s0">;
-
-def int_hexagon_S2_asl_r_p_or :
-Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_asl_r_p_or">;
-
-def int_hexagon_S4_ori_asl_ri :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S4_ori_asl_ri", [ImmArg<0>, ImmArg<2>]>;
-
-def int_hexagon_C4_nbitsset :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_C4_nbitsset">;
-
-def int_hexagon_M2_mpyu_acc_hh_s1 :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpyu_acc_hh_s1">;
-
-def int_hexagon_M2_mpyu_acc_hh_s0 :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpyu_acc_hh_s0">;
-
-def int_hexagon_M2_mpyu_ll_s1 :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpyu_ll_s1">;
-
-def int_hexagon_M2_mpyu_ll_s0 :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpyu_ll_s0">;
-
-def int_hexagon_A2_addh_l16_ll :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_addh_l16_ll">;
-
-def int_hexagon_S2_lsr_r_r_and :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S2_lsr_r_r_and">;
-
-def int_hexagon_A4_modwrapu :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A4_modwrapu">;
-
-def int_hexagon_A4_rcmpneq :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A4_rcmpneq">;
-
-def int_hexagon_M2_mpyd_acc_hh_s0 :
-Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_mpyd_acc_hh_s0">;
-
-def int_hexagon_M2_mpyd_acc_hh_s1 :
-Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_mpyd_acc_hh_s1">;
-
-def int_hexagon_F2_sfimm_p :
-Hexagon_float_i32_Intrinsic<"HEXAGON_F2_sfimm_p", [ImmArg<0>]>;
-
-def int_hexagon_F2_sfimm_n :
-Hexagon_float_i32_Intrinsic<"HEXAGON_F2_sfimm_n", [ImmArg<0>]>;
-
-def int_hexagon_M4_cmpyr_wh :
-Hexagon_i32_i64i32_Intrinsic<"HEXAGON_M4_cmpyr_wh">;
-
-def int_hexagon_S2_lsl_r_p_and :
-Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_lsl_r_p_and">;
-
-def int_hexagon_A2_vavgub :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vavgub">;
-
-def int_hexagon_F2_conv_d2sf :
-Hexagon_float_i64_Intrinsic<"HEXAGON_F2_conv_d2sf">;
-
-def int_hexagon_A2_vavguh :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vavguh">;
-
-def int_hexagon_A4_cmpbeqi :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A4_cmpbeqi", [ImmArg<1>]>;
-
-def int_hexagon_F2_sfcmpuo :
-Hexagon_i32_floatfloat_Intrinsic<"HEXAGON_F2_sfcmpuo">;
-
-def int_hexagon_A2_vavguw :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vavguw">;
-
-def int_hexagon_S2_asr_i_p_nac :
-Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_asr_i_p_nac", [ImmArg<2>]>;
-
-def int_hexagon_S2_vsatwh_nopack :
-Hexagon_i64_i64_Intrinsic<"HEXAGON_S2_vsatwh_nopack">;
-
-def int_hexagon_M2_mpyd_hh_s0 :
-Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_mpyd_hh_s0">;
-
-def int_hexagon_M2_mpyd_hh_s1 :
-Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_mpyd_hh_s1">;
-
-def int_hexagon_S2_lsl_r_p_or :
-Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_lsl_r_p_or">;
-
-def int_hexagon_A2_minu :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_minu">;
-
-def int_hexagon_M2_mpy_sat_lh_s1 :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpy_sat_lh_s1">;
-
-def int_hexagon_M4_or_andn :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M4_or_andn">;
-
-def int_hexagon_A2_minp :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_minp">;
-
-def int_hexagon_S4_or_andix :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S4_or_andix", [ImmArg<2>]>;
-
-def int_hexagon_M2_mpy_rnd_lh_s0 :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpy_rnd_lh_s0">;
-
-def int_hexagon_M2_mpy_rnd_lh_s1 :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpy_rnd_lh_s1">;
-
-def int_hexagon_M2_mmpyuh_s0 :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M2_mmpyuh_s0">;
-
-def int_hexagon_M2_mmpyuh_s1 :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M2_mmpyuh_s1">;
-
-def int_hexagon_M2_mpy_acc_sat_lh_s0 :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpy_acc_sat_lh_s0">;
-
-def int_hexagon_F2_sfcmpge :
-Hexagon_i32_floatfloat_Intrinsic<"HEXAGON_F2_sfcmpge">;
-
-def int_hexagon_F2_sfmin :
-Hexagon_float_floatfloat_Intrinsic<"HEXAGON_F2_sfmin">;
-
-def int_hexagon_F2_sfcmpgt :
-Hexagon_i32_floatfloat_Intrinsic<"HEXAGON_F2_sfcmpgt">;
-
-def int_hexagon_M4_vpmpyh :
-Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M4_vpmpyh">;
-
-def int_hexagon_M2_mmacuhs_rs0 :
-Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M2_mmacuhs_rs0">;
-
-def int_hexagon_M2_mpyd_rnd_lh_s1 :
-Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_mpyd_rnd_lh_s1">;
-
-def int_hexagon_M2_mpyd_rnd_lh_s0 :
-Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_mpyd_rnd_lh_s0">;
-
-def int_hexagon_A2_roundsat :
-Hexagon_i32_i64_Intrinsic<"HEXAGON_A2_roundsat">;
-
-def int_hexagon_S2_ct1p :
-Hexagon_i32_i64_Intrinsic<"HEXAGON_S2_ct1p">;
-
-def int_hexagon_S4_extract_rp :
-Hexagon_i32_i32i64_Intrinsic<"HEXAGON_S4_extract_rp">;
-
-def int_hexagon_S2_lsl_r_r_or :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S2_lsl_r_r_or">;
-
-def int_hexagon_C4_cmplteui :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_C4_cmplteui", [ImmArg<1>]>;
-
-def int_hexagon_S4_addi_lsr_ri :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S4_addi_lsr_ri", [ImmArg<0>, ImmArg<2>]>;
-
-def int_hexagon_A4_tfrcpp :
-Hexagon_i64_i64_Intrinsic<"HEXAGON_A4_tfrcpp">;
-
-def int_hexagon_S2_asr_i_svw_trun :
-Hexagon_i32_i64i32_Intrinsic<"HEXAGON_S2_asr_i_svw_trun", [ImmArg<1>]>;
-
-def int_hexagon_A4_cmphgti :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A4_cmphgti", [ImmArg<1>]>;
-
-def int_hexagon_A4_vrminh :
-Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_A4_vrminh">;
-
-def int_hexagon_A4_vrminw :
-Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_A4_vrminw">;
-
-def int_hexagon_A4_cmphgtu :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A4_cmphgtu">;
-
-def int_hexagon_S2_insertp_rp :
-Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_S2_insertp_rp">;
-
-def int_hexagon_A2_vnavghcr :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vnavghcr">;
-
-def int_hexagon_S4_subi_asl_ri :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S4_subi_asl_ri", [ImmArg<0>, ImmArg<2>]>;
-
-def int_hexagon_S2_lsl_r_vh :
-Hexagon_i64_i64i32_Intrinsic<"HEXAGON_S2_lsl_r_vh">;
-
-def int_hexagon_M2_mpy_hh_s0 :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpy_hh_s0">;
-
-def int_hexagon_A2_vsubws :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vsubws">;
-
-def int_hexagon_A2_sath :
-Hexagon_i32_i32_Intrinsic<"HEXAGON_A2_sath">;
-
-def int_hexagon_S2_asl_r_p_xor :
-Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_asl_r_p_xor">;
-
-def int_hexagon_A2_satb :
-Hexagon_i32_i32_Intrinsic<"HEXAGON_A2_satb">;
-
-def int_hexagon_C2_cmpltu :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_C2_cmpltu">;
-
-def int_hexagon_S2_insertp :
-Hexagon_i64_i64i64i32i32_Intrinsic<"HEXAGON_S2_insertp", [ImmArg<2>, ImmArg<3>]>;
-
-def int_hexagon_M2_mpyd_rnd_ll_s1 :
-Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_mpyd_rnd_ll_s1">;
-
-def int_hexagon_M2_mpyd_rnd_ll_s0 :
-Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_mpyd_rnd_ll_s0">;
-
-def int_hexagon_S2_lsr_i_p_nac :
-Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_lsr_i_p_nac", [ImmArg<2>]>;
-
-def int_hexagon_S2_extractup_rp :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_S2_extractup_rp">;
-
-def int_hexagon_S4_vxaddsubw :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_S4_vxaddsubw">;
-
-def int_hexagon_S4_vxaddsubh :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_S4_vxaddsubh">;
-
-def int_hexagon_A2_asrh :
-Hexagon_i32_i32_Intrinsic<"HEXAGON_A2_asrh">;
-
-def int_hexagon_S4_extractp_rp :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_S4_extractp_rp">;
-
-def int_hexagon_S2_lsr_r_r_acc :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S2_lsr_r_r_acc">;
-
-def int_hexagon_M2_mpyd_nac_ll_s1 :
-Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_mpyd_nac_ll_s1">;
-
-def int_hexagon_M2_mpyd_nac_ll_s0 :
-Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_mpyd_nac_ll_s0">;
-
-def int_hexagon_C2_or :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_C2_or">;
-
-def int_hexagon_M2_mmpyul_s1 :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M2_mmpyul_s1">;
-
-def int_hexagon_M2_vrcmacr_s0 :
-Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M2_vrcmacr_s0">;
-
-def int_hexagon_A2_xor :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_xor">;
-
-def int_hexagon_A2_add :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_add">;
-
-def int_hexagon_A2_vsububs :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vsububs">;
-
-def int_hexagon_M2_vmpy2s_s1 :
-Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_vmpy2s_s1">;
-
-def int_hexagon_M2_vmpy2s_s0 :
-Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_vmpy2s_s0">;
-
-def int_hexagon_A2_vraddub_acc :
-Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_A2_vraddub_acc">;
-
-def int_hexagon_F2_sfinvsqrta :
-Hexagon_floati32_float_Intrinsic<"HEXAGON_F2_sfinvsqrta">;
-
-def int_hexagon_S2_ct0p :
-Hexagon_i32_i64_Intrinsic<"HEXAGON_S2_ct0p">;
-
-def int_hexagon_A2_svaddh :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_svaddh">;
-
-def int_hexagon_S2_vcrotate :
-Hexagon_i64_i64i32_Intrinsic<"HEXAGON_S2_vcrotate">;
-
-def int_hexagon_A2_aslh :
-Hexagon_i32_i32_Intrinsic<"HEXAGON_A2_aslh">;
-
-def int_hexagon_A2_subh_h16_lh :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_subh_h16_lh">;
-
-def int_hexagon_A2_subh_h16_ll :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_subh_h16_ll">;
-
-def int_hexagon_M2_hmmpyl_rs1 :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_hmmpyl_rs1">;
-
-def int_hexagon_S2_asr_r_p :
-Hexagon_i64_i64i32_Intrinsic<"HEXAGON_S2_asr_r_p">;
-
-def int_hexagon_S2_vsplatrh :
-Hexagon_i64_i32_Intrinsic<"HEXAGON_S2_vsplatrh">;
-
-def int_hexagon_S2_asr_r_r :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_S2_asr_r_r">;
-
-def int_hexagon_A2_addh_h16_hl :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_addh_h16_hl">;
-
-def int_hexagon_S2_vsplatrb :
-Hexagon_i32_i32_Intrinsic<"HEXAGON_S2_vsplatrb">;
-
-def int_hexagon_A2_addh_h16_hh :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_addh_h16_hh">;
-
-def int_hexagon_M2_cmpyr_s0 :
-Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_cmpyr_s0">;
-
-def int_hexagon_M2_dpmpyss_rnd_s0 :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_dpmpyss_rnd_s0">;
-
-def int_hexagon_C2_muxri :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_C2_muxri", [ImmArg<1>]>;
-
-def int_hexagon_M2_vmac2es_s0 :
-Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M2_vmac2es_s0">;
-
-def int_hexagon_M2_vmac2es_s1 :
-Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M2_vmac2es_s1">;
-
-def int_hexagon_C2_pxfer_map :
-Hexagon_i32_i32_Intrinsic<"HEXAGON_C2_pxfer_map">;
-
-def int_hexagon_M2_mpyu_lh_s1 :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpyu_lh_s1">;
-
-def int_hexagon_M2_mpyu_lh_s0 :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpyu_lh_s0">;
-
-def int_hexagon_S2_asl_i_r_or :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S2_asl_i_r_or", [ImmArg<2>]>;
-
-def int_hexagon_M2_mpyd_acc_hl_s0 :
-Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_mpyd_acc_hl_s0">;
-
-def int_hexagon_M2_mpyd_acc_hl_s1 :
-Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_mpyd_acc_hl_s1">;
-
-def int_hexagon_S2_asr_r_p_nac :
-Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_asr_r_p_nac">;
-
-def int_hexagon_A2_vaddw :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vaddw">;
-
-def int_hexagon_S2_asr_i_r_and :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S2_asr_i_r_and", [ImmArg<2>]>;
-
-def int_hexagon_A2_vaddh :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vaddh">;
-
-def int_hexagon_M2_mpy_nac_sat_lh_s1 :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpy_nac_sat_lh_s1">;
-
-def int_hexagon_M2_mpy_nac_sat_lh_s0 :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpy_nac_sat_lh_s0">;
-
-def int_hexagon_C2_cmpeqp :
-Hexagon_i32_i64i64_Intrinsic<"HEXAGON_C2_cmpeqp">;
-
-def int_hexagon_M4_mpyri_addi :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M4_mpyri_addi", [ImmArg<0>, ImmArg<2>]>;
-
-def int_hexagon_A2_not :
-Hexagon_i32_i32_Intrinsic<"HEXAGON_A2_not">;
-
-def int_hexagon_S4_andi_lsr_ri :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S4_andi_lsr_ri", [ImmArg<0>, ImmArg<2>]>;
-
-def int_hexagon_M2_macsip :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_macsip", [ImmArg<2>]>;
-
-def int_hexagon_A2_tfrcrr :
-Hexagon_i32_i32_Intrinsic<"HEXAGON_A2_tfrcrr">;
-
-def int_hexagon_M2_macsin :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_macsin", [ImmArg<2>]>;
-
-def int_hexagon_C2_orn :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_C2_orn">;
-
-def int_hexagon_M4_and_andn :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M4_and_andn">;
-
-def int_hexagon_F2_sfmpy :
-Hexagon_float_floatfloat_Intrinsic<"HEXAGON_F2_sfmpy">;
-
-def int_hexagon_M2_mpyud_nac_hh_s1 :
-Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_mpyud_nac_hh_s1">;
-
-def int_hexagon_M2_mpyud_nac_hh_s0 :
-Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_mpyud_nac_hh_s0">;
-
-def int_hexagon_S2_lsr_r_p_acc :
-Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_lsr_r_p_acc">;
-
-def int_hexagon_S2_asr_r_vw :
-Hexagon_i64_i64i32_Intrinsic<"HEXAGON_S2_asr_r_vw">;
-
-def int_hexagon_M4_and_or :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M4_and_or">;
-
-def int_hexagon_S2_asr_r_vh :
-Hexagon_i64_i64i32_Intrinsic<"HEXAGON_S2_asr_r_vh">;
-
-def int_hexagon_C2_mask :
-Hexagon_i64_i32_Intrinsic<"HEXAGON_C2_mask">;
-
-def int_hexagon_M2_mpy_nac_hh_s0 :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpy_nac_hh_s0">;
-
-def int_hexagon_M2_mpy_nac_hh_s1 :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpy_nac_hh_s1">;
-
-def int_hexagon_M2_mpy_up_s1_sat :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpy_up_s1_sat">;
-
-def int_hexagon_A4_vcmpbgt :
-Hexagon_i32_i64i64_Intrinsic<"HEXAGON_A4_vcmpbgt">;
-
-def int_hexagon_M5_vrmacbsu :
-Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M5_vrmacbsu">;
-
-def int_hexagon_S2_tableidxw_goodsyntax :
-Hexagon_i32_i32i32i32i32_Intrinsic<"HEXAGON_S2_tableidxw_goodsyntax">;
-
-def int_hexagon_A2_vrsadub :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vrsadub">;
-
-def int_hexagon_A2_tfrrcr :
-Hexagon_i32_i32_Intrinsic<"HEXAGON_A2_tfrrcr">;
-
-def int_hexagon_M2_vrcmpys_acc_s1 :
-Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_M2_vrcmpys_acc_s1">;
-
-def int_hexagon_F2_dfcmpge :
-Hexagon_i32_doubledouble_Intrinsic<"HEXAGON_F2_dfcmpge">;
-
-def int_hexagon_M2_accii :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_accii", [ImmArg<2>]>;
-
-def int_hexagon_A5_vaddhubs :
-Hexagon_i32_i64i64_Intrinsic<"HEXAGON_A5_vaddhubs">;
-
-def int_hexagon_A2_vmaxw :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vmaxw">;
-
-def int_hexagon_A2_vmaxb :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vmaxb">;
-
-def int_hexagon_A2_vmaxh :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vmaxh">;
-
-def int_hexagon_S2_vsxthw :
-Hexagon_i64_i32_Intrinsic<"HEXAGON_S2_vsxthw">;
-
-def int_hexagon_S4_andi_asl_ri :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S4_andi_asl_ri", [ImmArg<0>, ImmArg<2>]>;
-
-def int_hexagon_S2_asl_i_p_nac :
-Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_asl_i_p_nac", [ImmArg<2>]>;
-
-def int_hexagon_S2_lsl_r_p_xor :
-Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_lsl_r_p_xor">;
-
-def int_hexagon_C2_cmpgt :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_C2_cmpgt">;
-
-def int_hexagon_F2_conv_df2d_chop :
-Hexagon_i64_double_Intrinsic<"HEXAGON_F2_conv_df2d_chop">;
-
-def int_hexagon_M2_mpyu_nac_hl_s0 :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpyu_nac_hl_s0">;
-
-def int_hexagon_M2_mpyu_nac_hl_s1 :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpyu_nac_hl_s1">;
-
-def int_hexagon_F2_conv_sf2w :
-Hexagon_i32_float_Intrinsic<"HEXAGON_F2_conv_sf2w">;
-
-def int_hexagon_S2_lsr_r_p_or :
-Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_lsr_r_p_or">;
-
-def int_hexagon_F2_sfclass :
-Hexagon_i32_floati32_Intrinsic<"HEXAGON_F2_sfclass">;
-
-def int_hexagon_M2_mpyud_acc_lh_s0 :
-Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_mpyud_acc_lh_s0">;
-
-def int_hexagon_M4_xor_andn :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M4_xor_andn">;
-
-def int_hexagon_S2_addasl_rrri :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S2_addasl_rrri", [ImmArg<2>]>;
-
-def int_hexagon_M5_vdmpybsu :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M5_vdmpybsu">;
-
-def int_hexagon_M2_mpyu_nac_hh_s0 :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpyu_nac_hh_s0">;
-
-def int_hexagon_M2_mpyu_nac_hh_s1 :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpyu_nac_hh_s1">;
-
-def int_hexagon_A2_addi :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_addi", [ImmArg<1>]>;
-
-def int_hexagon_A2_addp :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_addp">;
-
-def int_hexagon_M2_vmpy2s_s1pack :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_vmpy2s_s1pack">;
-
-def int_hexagon_S4_clbpnorm :
-Hexagon_i32_i64_Intrinsic<"HEXAGON_S4_clbpnorm">;
-
-def int_hexagon_A4_round_rr_sat :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A4_round_rr_sat">;
-
-def int_hexagon_M2_nacci :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_nacci">;
-
-def int_hexagon_S2_shuffeh :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_S2_shuffeh">;
-
-def int_hexagon_S2_lsr_i_r_and :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S2_lsr_i_r_and", [ImmArg<2>]>;
-
-def int_hexagon_M2_mpy_sat_rnd_hh_s1 :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpy_sat_rnd_hh_s1">;
-
-def int_hexagon_M2_mpy_sat_rnd_hh_s0 :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpy_sat_rnd_hh_s0">;
-
-def int_hexagon_F2_conv_sf2uw :
-Hexagon_i32_float_Intrinsic<"HEXAGON_F2_conv_sf2uw">;
-
-def int_hexagon_A2_vsubh :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vsubh">;
-
-def int_hexagon_F2_conv_sf2ud :
-Hexagon_i64_float_Intrinsic<"HEXAGON_F2_conv_sf2ud">;
-
-def int_hexagon_A2_vsubw :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vsubw">;
-
-def int_hexagon_A2_vcmpwgt :
-Hexagon_i32_i64i64_Intrinsic<"HEXAGON_A2_vcmpwgt">;
-
-def int_hexagon_M4_xor_or :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M4_xor_or">;
-
-def int_hexagon_F2_conv_sf2uw_chop :
-Hexagon_i32_float_Intrinsic<"HEXAGON_F2_conv_sf2uw_chop">;
-
-def int_hexagon_S2_asl_r_vw :
-Hexagon_i64_i64i32_Intrinsic<"HEXAGON_S2_asl_r_vw">;
-
-def int_hexagon_S2_vsatwuh_nopack :
-Hexagon_i64_i64_Intrinsic<"HEXAGON_S2_vsatwuh_nopack">;
-
-def int_hexagon_S2_asl_r_vh :
-Hexagon_i64_i64i32_Intrinsic<"HEXAGON_S2_asl_r_vh">;
-
-def int_hexagon_A2_svsubuhs :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_svsubuhs">;
-
-def int_hexagon_M5_vmpybsu :
-Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M5_vmpybsu">;
-
-def int_hexagon_A2_subh_l16_sat_ll :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_subh_l16_sat_ll">;
-
-def int_hexagon_C4_and_and :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_C4_and_and">;
-
-def int_hexagon_M2_mpyu_acc_hl_s1 :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpyu_acc_hl_s1">;
-
-def int_hexagon_M2_mpyu_acc_hl_s0 :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpyu_acc_hl_s0">;
-
-def int_hexagon_S2_lsr_r_p :
-Hexagon_i64_i64i32_Intrinsic<"HEXAGON_S2_lsr_r_p">;
-
-def int_hexagon_S2_lsr_r_r :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_S2_lsr_r_r">;
-
-def int_hexagon_A4_subp_c :
-Hexagon_i64i32_i64i64i32_Intrinsic<"HEXAGON_A4_subp_c">;
-
-def int_hexagon_A2_vsubhs :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vsubhs">;
-
-def int_hexagon_C2_vitpack :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_C2_vitpack">;
-
-def int_hexagon_A2_vavguhr :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vavguhr">;
-
-def int_hexagon_S2_vsplicerb :
-Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_vsplicerb">;
-
-def int_hexagon_C4_nbitsclr :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_C4_nbitsclr">;
-
-def int_hexagon_A2_vcmpbgtu :
-Hexagon_i32_i64i64_Intrinsic<"HEXAGON_A2_vcmpbgtu">;
-
-def int_hexagon_M2_cmpys_s1 :
-Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_cmpys_s1">;
-
-def int_hexagon_M2_cmpys_s0 :
-Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_cmpys_s0">;
-
-def int_hexagon_F2_dfcmpuo :
-Hexagon_i32_doubledouble_Intrinsic<"HEXAGON_F2_dfcmpuo">;
-
-def int_hexagon_S2_shuffob :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_S2_shuffob">;
-
-def int_hexagon_C2_and :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_C2_and">;
-
-def int_hexagon_S5_popcountp :
-Hexagon_i32_i64_Intrinsic<"HEXAGON_S5_popcountp">;
-
-def int_hexagon_S4_extractp :
-Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_S4_extractp", [ImmArg<1>, ImmArg<2>]>;
-
-def int_hexagon_S2_cl0 :
-Hexagon_i32_i32_Intrinsic<"HEXAGON_S2_cl0">;
-
-def int_hexagon_A4_vcmpbgti :
-Hexagon_i32_i64i32_Intrinsic<"HEXAGON_A4_vcmpbgti", [ImmArg<1>]>;
-
-def int_hexagon_M2_mmacls_s1 :
-Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M2_mmacls_s1">;
-
-def int_hexagon_M2_mmacls_s0 :
-Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M2_mmacls_s0">;
-
-def int_hexagon_C4_cmpneq :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_C4_cmpneq">;
-
-def int_hexagon_M2_vmac2es :
-Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M2_vmac2es">;
-
-def int_hexagon_M2_vdmacs_s0 :
-Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M2_vdmacs_s0">;
-
-def int_hexagon_M2_vdmacs_s1 :
-Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M2_vdmacs_s1">;
-
-def int_hexagon_M2_mpyud_ll_s0 :
-Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_mpyud_ll_s0">;
-
-def int_hexagon_M2_mpyud_ll_s1 :
-Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_mpyud_ll_s1">;
-
-def int_hexagon_S2_clb :
-Hexagon_i32_i32_Intrinsic<"HEXAGON_S2_clb">;
-
-def int_hexagon_M2_mpy_nac_ll_s0 :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpy_nac_ll_s0">;
-
-def int_hexagon_M2_mpy_nac_ll_s1 :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpy_nac_ll_s1">;
-
-def int_hexagon_M2_mpyd_nac_hl_s1 :
-Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_mpyd_nac_hl_s1">;
-
-def int_hexagon_M2_mpyd_nac_hl_s0 :
-Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_mpyd_nac_hl_s0">;
-
-def int_hexagon_M2_maci :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_maci">;
-
-def int_hexagon_A2_vmaxuh :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vmaxuh">;
-
-def int_hexagon_A4_bitspliti :
-Hexagon_i64_i32i32_Intrinsic<"HEXAGON_A4_bitspliti", [ImmArg<1>]>;
-
-def int_hexagon_A2_vmaxub :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vmaxub">;
-
-def int_hexagon_M2_mpyud_hh_s0 :
-Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_mpyud_hh_s0">;
-
-def int_hexagon_M2_mpyud_hh_s1 :
-Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_mpyud_hh_s1">;
-
-def int_hexagon_M2_vrmac_s0 :
-Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M2_vrmac_s0">;
-
-def int_hexagon_M2_mpy_sat_lh_s0 :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpy_sat_lh_s0">;
-
-def int_hexagon_S2_asl_r_r_sat :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_S2_asl_r_r_sat">;
-
-def int_hexagon_F2_conv_sf2d :
-Hexagon_i64_float_Intrinsic<"HEXAGON_F2_conv_sf2d">;
-
-def int_hexagon_S2_asr_r_r_nac :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S2_asr_r_r_nac">;
-
-def int_hexagon_F2_dfimm_n :
-Hexagon_double_i32_Intrinsic<"HEXAGON_F2_dfimm_n", [ImmArg<0>]>;
-
-def int_hexagon_A4_cmphgt :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A4_cmphgt">;
-
-def int_hexagon_F2_dfimm_p :
-Hexagon_double_i32_Intrinsic<"HEXAGON_F2_dfimm_p", [ImmArg<0>]>;
-
-def int_hexagon_M2_mpyud_acc_lh_s1 :
-Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_mpyud_acc_lh_s1">;
-
-def int_hexagon_M2_vcmpy_s1_sat_r :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M2_vcmpy_s1_sat_r">;
-
-def int_hexagon_M4_mpyri_addr_u2 :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M4_mpyri_addr_u2", [ImmArg<1>]>;
-
-def int_hexagon_M2_vcmpy_s1_sat_i :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M2_vcmpy_s1_sat_i">;
-
-def int_hexagon_S2_lsl_r_p_nac :
-Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_lsl_r_p_nac">;
-
-def int_hexagon_M5_vrmacbuu :
-Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M5_vrmacbuu">;
-
-def int_hexagon_S5_asrhub_rnd_sat_goodsyntax :
-Hexagon_i32_i64i32_Intrinsic<"HEXAGON_S5_asrhub_rnd_sat_goodsyntax", [ImmArg<1>]>;
-
-def int_hexagon_S2_vspliceib :
-Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_vspliceib", [ImmArg<2>]>;
-
-def int_hexagon_M2_dpmpyss_acc_s0 :
-Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_dpmpyss_acc_s0">;
-
-def int_hexagon_M2_cnacs_s1 :
-Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_cnacs_s1">;
-
-def int_hexagon_M2_cnacs_s0 :
-Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_cnacs_s0">;
-
-def int_hexagon_A2_maxu :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_maxu">;
-
-def int_hexagon_A2_maxp :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_maxp">;
-
-def int_hexagon_A2_andir :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_andir", [ImmArg<1>]>;
-
-def int_hexagon_F2_sfrecipa :
-Hexagon_floati32_floatfloat_Intrinsic<"HEXAGON_F2_sfrecipa">;
-
-def int_hexagon_A2_combineii :
-Hexagon_i64_i32i32_Intrinsic<"HEXAGON_A2_combineii", [ImmArg<0>, ImmArg<1>]>;
-
-def int_hexagon_A4_orn :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A4_orn">;
-
-def int_hexagon_A4_cmpbgtui :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A4_cmpbgtui", [ImmArg<1>]>;
-
-def int_hexagon_S2_lsr_r_r_or :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S2_lsr_r_r_or">;
-
-def int_hexagon_A4_vcmpbeqi :
-Hexagon_i32_i64i32_Intrinsic<"HEXAGON_A4_vcmpbeqi", [ImmArg<1>]>;
-
-def int_hexagon_S2_lsl_r_r :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_S2_lsl_r_r">;
-
-def int_hexagon_S2_lsl_r_p :
-Hexagon_i64_i64i32_Intrinsic<"HEXAGON_S2_lsl_r_p">;
-
-def int_hexagon_A2_or :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_or">;
-
-def int_hexagon_F2_dfcmpeq :
-Hexagon_i32_doubledouble_Intrinsic<"HEXAGON_F2_dfcmpeq">;
-
-def int_hexagon_C2_cmpeq :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_C2_cmpeq">;
-
-def int_hexagon_A2_tfrp :
-Hexagon_i64_i64_Intrinsic<"HEXAGON_A2_tfrp">;
-
-def int_hexagon_C4_and_andn :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_C4_and_andn">;
-
-def int_hexagon_S2_vsathub_nopack :
-Hexagon_i64_i64_Intrinsic<"HEXAGON_S2_vsathub_nopack">;
-
-def int_hexagon_A2_satuh :
-Hexagon_i32_i32_Intrinsic<"HEXAGON_A2_satuh">;
-
-def int_hexagon_A2_satub :
-Hexagon_i32_i32_Intrinsic<"HEXAGON_A2_satub">;
-
-def int_hexagon_M2_vrcmpys_s1 :
-Hexagon_i64_i64i32_Intrinsic<"HEXAGON_M2_vrcmpys_s1">;
-
-def int_hexagon_S4_or_ori :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S4_or_ori", [ImmArg<2>]>;
-
-def int_hexagon_C4_fastcorner9_not :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_C4_fastcorner9_not">;
-
-def int_hexagon_A2_tfrih :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_tfrih", [ImmArg<1>]>;
-
-def int_hexagon_A2_tfril :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_tfril", [ImmArg<1>]>;
-
-def int_hexagon_M4_mpyri_addr :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M4_mpyri_addr", [ImmArg<2>]>;
-
-def int_hexagon_S2_vtrunehb :
-Hexagon_i32_i64_Intrinsic<"HEXAGON_S2_vtrunehb">;
-
-def int_hexagon_A2_vabsw :
-Hexagon_i64_i64_Intrinsic<"HEXAGON_A2_vabsw">;
-
-def int_hexagon_A2_vabsh :
-Hexagon_i64_i64_Intrinsic<"HEXAGON_A2_vabsh">;
-
-def int_hexagon_F2_sfsub :
-Hexagon_float_floatfloat_Intrinsic<"HEXAGON_F2_sfsub">;
-
-def int_hexagon_C2_muxii :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_C2_muxii", [ImmArg<1>, ImmArg<2>]>;
-
-def int_hexagon_C2_muxir :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_C2_muxir", [ImmArg<2>]>;
-
-def int_hexagon_A2_swiz :
-Hexagon_i32_i32_Intrinsic<"HEXAGON_A2_swiz">;
-
-def int_hexagon_S2_asr_i_p_and :
-Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_asr_i_p_and", [ImmArg<2>]>;
-
-def int_hexagon_M2_cmpyrsc_s0 :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_cmpyrsc_s0">;
-
-def int_hexagon_M2_cmpyrsc_s1 :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_cmpyrsc_s1">;
-
-def int_hexagon_A2_vraddub :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vraddub">;
-
-def int_hexagon_A4_tlbmatch :
-Hexagon_i32_i64i32_Intrinsic<"HEXAGON_A4_tlbmatch">;
-
-def int_hexagon_F2_conv_df2w_chop :
-Hexagon_i32_double_Intrinsic<"HEXAGON_F2_conv_df2w_chop">;
-
-def int_hexagon_A2_and :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_and">;
-
-def int_hexagon_S2_lsr_r_p_and :
-Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_lsr_r_p_and">;
-
-def int_hexagon_M2_mpy_nac_sat_ll_s1 :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpy_nac_sat_ll_s1">;
-
-def int_hexagon_M2_mpy_nac_sat_ll_s0 :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpy_nac_sat_ll_s0">;
-
-def int_hexagon_S4_extract :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S4_extract", [ImmArg<1>, ImmArg<2>]>;
-
-def int_hexagon_A2_vcmpweq :
-Hexagon_i32_i64i64_Intrinsic<"HEXAGON_A2_vcmpweq">;
-
-def int_hexagon_M2_acci :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_acci">;
-
-def int_hexagon_S2_lsr_i_p_acc :
-Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_lsr_i_p_acc", [ImmArg<2>]>;
-
-def int_hexagon_S2_lsr_i_p_or :
-Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_lsr_i_p_or", [ImmArg<2>]>;
-
-def int_hexagon_F2_conv_ud2sf :
-Hexagon_float_i64_Intrinsic<"HEXAGON_F2_conv_ud2sf">;
-
-def int_hexagon_A2_tfr :
-Hexagon_i32_i32_Intrinsic<"HEXAGON_A2_tfr">;
-
-def int_hexagon_S2_asr_i_p_or :
-Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_asr_i_p_or", [ImmArg<2>]>;
-
-def int_hexagon_A2_subri :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_subri", [ImmArg<0>]>;
-
-def int_hexagon_A4_vrmaxuw :
-Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_A4_vrmaxuw">;
-
-def int_hexagon_M5_vmpybuu :
-Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M5_vmpybuu">;
-
-def int_hexagon_A4_vrmaxuh :
-Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_A4_vrmaxuh">;
-
-def int_hexagon_S2_asl_i_vw :
-Hexagon_i64_i64i32_Intrinsic<"HEXAGON_S2_asl_i_vw", [ImmArg<1>]>;
-
-def int_hexagon_A2_vavgw :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vavgw">;
-
-def int_hexagon_S2_brev :
-Hexagon_i32_i32_Intrinsic<"HEXAGON_S2_brev">;
-
-def int_hexagon_A2_vavgh :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vavgh">;
-
-def int_hexagon_S2_clrbit_i :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_S2_clrbit_i", [ImmArg<1>]>;
-
-def int_hexagon_S2_asl_i_vh :
-Hexagon_i64_i64i32_Intrinsic<"HEXAGON_S2_asl_i_vh", [ImmArg<1>]>;
-
-def int_hexagon_S2_lsr_i_r_or :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S2_lsr_i_r_or", [ImmArg<2>]>;
-
-def int_hexagon_S2_lsl_r_r_nac :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S2_lsl_r_r_nac">;
-
-def int_hexagon_M2_mmpyl_rs1 :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M2_mmpyl_rs1">;
-
-def int_hexagon_M2_mpyud_hl_s1 :
-Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_mpyud_hl_s1">;
-
-def int_hexagon_M2_mmpyl_s0 :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M2_mmpyl_s0">;
-
-def int_hexagon_M2_mmpyl_s1 :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M2_mmpyl_s1">;
-
-def int_hexagon_M2_naccii :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_naccii", [ImmArg<2>]>;
-
-def int_hexagon_S2_vrndpackwhs :
-Hexagon_i32_i64_Intrinsic<"HEXAGON_S2_vrndpackwhs">;
-
-def int_hexagon_S2_vtrunewh :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_S2_vtrunewh">;
-
-def int_hexagon_M2_dpmpyss_nac_s0 :
-Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_dpmpyss_nac_s0">;
-
-def int_hexagon_M2_mpyd_ll_s0 :
-Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_mpyd_ll_s0">;
-
-def int_hexagon_M2_mpyd_ll_s1 :
-Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_mpyd_ll_s1">;
-
-def int_hexagon_M4_mac_up_s1_sat :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M4_mac_up_s1_sat">;
-
-def int_hexagon_S4_vrcrotate_acc :
-Hexagon_i64_i64i64i32i32_Intrinsic<"HEXAGON_S4_vrcrotate_acc", [ImmArg<3>]>;
-
-def int_hexagon_F2_conv_uw2df :
-Hexagon_double_i32_Intrinsic<"HEXAGON_F2_conv_uw2df">;
-
-def int_hexagon_A2_vaddubs :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vaddubs">;
-
-def int_hexagon_S2_asr_r_r_acc :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S2_asr_r_r_acc">;
-
-def int_hexagon_A2_orir :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_orir", [ImmArg<1>]>;
-
-def int_hexagon_A2_andp :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_andp">;
-
-def int_hexagon_S2_lfsp :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_S2_lfsp">;
-
-def int_hexagon_A2_min :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_min">;
-
-def int_hexagon_M2_mpysmi :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpysmi", [ImmArg<1>]>;
-
-def int_hexagon_M2_vcmpy_s0_sat_r :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M2_vcmpy_s0_sat_r">;
-
-def int_hexagon_M2_mpyu_acc_ll_s1 :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpyu_acc_ll_s1">;
-
-def int_hexagon_M2_mpyu_acc_ll_s0 :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpyu_acc_ll_s0">;
-
-def int_hexagon_S2_asr_r_svw_trun :
-Hexagon_i32_i64i32_Intrinsic<"HEXAGON_S2_asr_r_svw_trun">;
-
-def int_hexagon_M2_mmpyh_s0 :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M2_mmpyh_s0">;
-
-def int_hexagon_M2_mmpyh_s1 :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M2_mmpyh_s1">;
-
-def int_hexagon_F2_conv_sf2df :
-Hexagon_double_float_Intrinsic<"HEXAGON_F2_conv_sf2df">;
-
-def int_hexagon_S2_vtrunohb :
-Hexagon_i32_i64_Intrinsic<"HEXAGON_S2_vtrunohb">;
-
-def int_hexagon_F2_conv_sf2d_chop :
-Hexagon_i64_float_Intrinsic<"HEXAGON_F2_conv_sf2d_chop">;
-
-def int_hexagon_M2_mpyd_lh_s0 :
-Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_mpyd_lh_s0">;
-
-def int_hexagon_F2_conv_df2w :
-Hexagon_i32_double_Intrinsic<"HEXAGON_F2_conv_df2w">;
-
-def int_hexagon_S5_asrhub_sat :
-Hexagon_i32_i64i32_Intrinsic<"HEXAGON_S5_asrhub_sat", [ImmArg<1>]>;
-
-def int_hexagon_S2_asl_i_r_xacc :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S2_asl_i_r_xacc", [ImmArg<2>]>;
-
-def int_hexagon_F2_conv_df2d :
-Hexagon_i64_double_Intrinsic<"HEXAGON_F2_conv_df2d">;
-
-def int_hexagon_M2_mmaculs_s1 :
-Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M2_mmaculs_s1">;
-
-def int_hexagon_M2_mmaculs_s0 :
-Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M2_mmaculs_s0">;
-
-def int_hexagon_A2_svadduhs :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_svadduhs">;
-
-def int_hexagon_F2_conv_sf2w_chop :
-Hexagon_i32_float_Intrinsic<"HEXAGON_F2_conv_sf2w_chop">;
-
-def int_hexagon_S2_svsathub :
-Hexagon_i32_i32_Intrinsic<"HEXAGON_S2_svsathub">;
-
-def int_hexagon_M2_mpyd_rnd_hl_s1 :
-Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_mpyd_rnd_hl_s1">;
-
-def int_hexagon_M2_mpyd_rnd_hl_s0 :
-Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_mpyd_rnd_hl_s0">;
-
-def int_hexagon_S2_setbit_r :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_S2_setbit_r">;
-
-def int_hexagon_A2_vavghr :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vavghr">;
-
-def int_hexagon_F2_sffma_sc :
-Hexagon_float_floatfloatfloati32_Intrinsic<"HEXAGON_F2_sffma_sc">;
-
-def int_hexagon_F2_dfclass :
-Hexagon_i32_doublei32_Intrinsic<"HEXAGON_F2_dfclass", [ImmArg<1>]>;
-
-def int_hexagon_F2_conv_df2ud :
-Hexagon_i64_double_Intrinsic<"HEXAGON_F2_conv_df2ud">;
-
-def int_hexagon_F2_conv_df2uw :
-Hexagon_i32_double_Intrinsic<"HEXAGON_F2_conv_df2uw">;
-
-def int_hexagon_M2_cmpyrs_s0 :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_cmpyrs_s0">;
-
-def int_hexagon_M2_cmpyrs_s1 :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_cmpyrs_s1">;
-
-def int_hexagon_C4_cmpltei :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_C4_cmpltei", [ImmArg<1>]>;
-
-def int_hexagon_C4_cmplteu :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_C4_cmplteu">;
-
-def int_hexagon_A2_vsubb_map :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vsubb_map">;
-
-def int_hexagon_A2_subh_l16_ll :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_subh_l16_ll">;
-
-def int_hexagon_S2_asr_i_r_rnd :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_S2_asr_i_r_rnd", [ImmArg<1>]>;
-
-def int_hexagon_M2_vrmpy_s0 :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M2_vrmpy_s0">;
-
-def int_hexagon_M2_mpyd_rnd_hh_s1 :
-Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_mpyd_rnd_hh_s1">;
-
-def int_hexagon_M2_mpyd_rnd_hh_s0 :
-Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_mpyd_rnd_hh_s0">;
-
-def int_hexagon_A2_minup :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_minup">;
-
-def int_hexagon_S2_valignrb :
-Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_valignrb">;
-
-def int_hexagon_S2_asr_r_p_acc :
-Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_asr_r_p_acc">;
-
-def int_hexagon_M2_mmpyl_rs0 :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M2_mmpyl_rs0">;
-
-def int_hexagon_M2_vrcmaci_s0 :
-Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M2_vrcmaci_s0">;
-
-def int_hexagon_A2_vaddub :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vaddub">;
-
-def int_hexagon_A2_combine_lh :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_combine_lh">;
-
-def int_hexagon_M5_vdmacbsu :
-Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M5_vdmacbsu">;
-
-def int_hexagon_A2_combine_ll :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_combine_ll">;
-
-def int_hexagon_M2_mpyud_hl_s0 :
-Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_mpyud_hl_s0">;
-
-def int_hexagon_M2_vrcmpyi_s0c :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M2_vrcmpyi_s0c">;
-
-def int_hexagon_S2_asr_i_p_rnd :
-Hexagon_i64_i64i32_Intrinsic<"HEXAGON_S2_asr_i_p_rnd", [ImmArg<1>]>;
-
-def int_hexagon_A2_addpsat :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_addpsat">;
-
-def int_hexagon_A2_svaddhs :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_svaddhs">;
-
-def int_hexagon_S4_ori_lsr_ri :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S4_ori_lsr_ri", [ImmArg<0>, ImmArg<2>]>;
-
-def int_hexagon_M2_mpy_sat_rnd_ll_s1 :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpy_sat_rnd_ll_s1">;
-
-def int_hexagon_M2_mpy_sat_rnd_ll_s0 :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpy_sat_rnd_ll_s0">;
-
-def int_hexagon_A2_vminw :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vminw">;
-
-def int_hexagon_A2_vminh :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vminh">;
-
-def int_hexagon_M2_vrcmpyr_s0 :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M2_vrcmpyr_s0">;
-
-def int_hexagon_A2_vminb :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vminb">;
-
-def int_hexagon_M2_vcmac_s0_sat_i :
-Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M2_vcmac_s0_sat_i">;
-
-def int_hexagon_M2_mpyud_lh_s0 :
-Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_mpyud_lh_s0">;
-
-def int_hexagon_M2_mpyud_lh_s1 :
-Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_mpyud_lh_s1">;
-
-def int_hexagon_S2_asl_r_r_or :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S2_asl_r_r_or">;
-
-def int_hexagon_S4_lsli :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_S4_lsli", [ImmArg<0>]>;
-
-def int_hexagon_S2_lsl_r_vw :
-Hexagon_i64_i64i32_Intrinsic<"HEXAGON_S2_lsl_r_vw">;
-
-def int_hexagon_M2_mpy_hh_s1 :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpy_hh_s1">;
-
-def int_hexagon_M4_vrmpyeh_s0 :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M4_vrmpyeh_s0">;
-
-def int_hexagon_M4_vrmpyeh_s1 :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M4_vrmpyeh_s1">;
-
-def int_hexagon_M2_mpy_nac_lh_s0 :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpy_nac_lh_s0">;
-
-def int_hexagon_M2_mpy_nac_lh_s1 :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpy_nac_lh_s1">;
-
-def int_hexagon_M2_vraddh :
-Hexagon_i32_i64i64_Intrinsic<"HEXAGON_M2_vraddh">;
-
-def int_hexagon_C2_tfrrp :
-Hexagon_i32_i32_Intrinsic<"HEXAGON_C2_tfrrp">;
-
-def int_hexagon_M2_mpy_acc_sat_ll_s0 :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpy_acc_sat_ll_s0">;
-
-def int_hexagon_M2_mpy_acc_sat_ll_s1 :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpy_acc_sat_ll_s1">;
-
-def int_hexagon_S2_vtrunowh :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_S2_vtrunowh">;
-
-def int_hexagon_A2_abs :
-Hexagon_i32_i32_Intrinsic<"HEXAGON_A2_abs">;
-
-def int_hexagon_A4_cmpbeq :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A4_cmpbeq">;
-
-def int_hexagon_A2_negp :
-Hexagon_i64_i64_Intrinsic<"HEXAGON_A2_negp">;
-
-def int_hexagon_S2_asl_i_r_sat :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_S2_asl_i_r_sat", [ImmArg<1>]>;
-
-def int_hexagon_A2_addh_l16_sat_hl :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_addh_l16_sat_hl">;
-
-def int_hexagon_S2_vsatwuh :
-Hexagon_i32_i64_Intrinsic<"HEXAGON_S2_vsatwuh">;
-
-def int_hexagon_F2_dfcmpgt :
-Hexagon_i32_doubledouble_Intrinsic<"HEXAGON_F2_dfcmpgt">;
-
-def int_hexagon_S2_svsathb :
-Hexagon_i32_i32_Intrinsic<"HEXAGON_S2_svsathb">;
-
-def int_hexagon_C2_cmpgtup :
-Hexagon_i32_i64i64_Intrinsic<"HEXAGON_C2_cmpgtup">;
-
-def int_hexagon_A4_cround_ri :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A4_cround_ri", [ImmArg<1>]>;
-
-def int_hexagon_S4_clbpaddi :
-Hexagon_i32_i64i32_Intrinsic<"HEXAGON_S4_clbpaddi", [ImmArg<1>]>;
-
-def int_hexagon_A4_cround_rr :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A4_cround_rr">;
-
-def int_hexagon_C2_mux :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_C2_mux">;
-
-def int_hexagon_M2_dpmpyuu_s0 :
-Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_dpmpyuu_s0">;
-
-def int_hexagon_S2_shuffeb :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_S2_shuffeb">;
-
-def int_hexagon_A2_vminuw :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vminuw">;
-
-def int_hexagon_A2_vaddhs :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vaddhs">;
-
-def int_hexagon_S2_insert_rp :
-Hexagon_i32_i32i32i64_Intrinsic<"HEXAGON_S2_insert_rp">;
-
-def int_hexagon_A2_vminuh :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vminuh">;
-
-def int_hexagon_A2_vminub :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vminub">;
-
-def int_hexagon_S2_extractu :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S2_extractu", [ImmArg<1>, ImmArg<2>]>;
-
-def int_hexagon_A2_svsubh :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_svsubh">;
-
-def int_hexagon_S4_clbaddi :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_S4_clbaddi", [ImmArg<1>]>;
-
-def int_hexagon_F2_sffms :
-Hexagon_float_floatfloatfloat_Intrinsic<"HEXAGON_F2_sffms">;
-
-def int_hexagon_S2_vsxtbh :
-Hexagon_i64_i32_Intrinsic<"HEXAGON_S2_vsxtbh">;
-
-def int_hexagon_M2_mpyud_nac_ll_s1 :
-Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_mpyud_nac_ll_s1">;
-
-def int_hexagon_M2_mpyud_nac_ll_s0 :
-Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_mpyud_nac_ll_s0">;
-
-def int_hexagon_A2_subp :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_subp">;
-
-def int_hexagon_M2_vmpy2es_s1 :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M2_vmpy2es_s1">;
-
-def int_hexagon_M2_vmpy2es_s0 :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M2_vmpy2es_s0">;
-
-def int_hexagon_S4_parity :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_S4_parity">;
-
-def int_hexagon_M2_mpy_acc_hh_s1 :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpy_acc_hh_s1">;
-
-def int_hexagon_M2_mpy_acc_hh_s0 :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpy_acc_hh_s0">;
-
-def int_hexagon_S4_addi_asl_ri :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S4_addi_asl_ri", [ImmArg<0>, ImmArg<2>]>;
-
-def int_hexagon_M2_mpyd_nac_hh_s1 :
-Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_mpyd_nac_hh_s1">;
-
-def int_hexagon_M2_mpyd_nac_hh_s0 :
-Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_mpyd_nac_hh_s0">;
-
-def int_hexagon_S2_asr_i_r_nac :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S2_asr_i_r_nac", [ImmArg<2>]>;
-
-def int_hexagon_A4_cmpheqi :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A4_cmpheqi", [ImmArg<1>]>;
-
-def int_hexagon_S2_lsr_r_p_xor :
-Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_lsr_r_p_xor">;
-
-def int_hexagon_M2_mpy_acc_hl_s1 :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpy_acc_hl_s1">;
-
-def int_hexagon_M2_mpy_acc_hl_s0 :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpy_acc_hl_s0">;
-
-def int_hexagon_F2_conv_sf2ud_chop :
-Hexagon_i64_float_Intrinsic<"HEXAGON_F2_conv_sf2ud_chop">;
-
-def int_hexagon_C2_cmpgeui :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_C2_cmpgeui", [ImmArg<1>]>;
-
-def int_hexagon_M2_mpy_acc_sat_hh_s0 :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpy_acc_sat_hh_s0">;
-
-def int_hexagon_M2_mpy_acc_sat_hh_s1 :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpy_acc_sat_hh_s1">;
-
-def int_hexagon_S2_asl_r_p_and :
-Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_asl_r_p_and">;
-
-def int_hexagon_A2_addh_h16_sat_lh :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_addh_h16_sat_lh">;
-
-def int_hexagon_A2_addh_h16_sat_ll :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_addh_h16_sat_ll">;
-
-def int_hexagon_M4_nac_up_s1_sat :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M4_nac_up_s1_sat">;
-
-def int_hexagon_M2_mpyud_nac_lh_s1 :
-Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_mpyud_nac_lh_s1">;
-
-def int_hexagon_M2_mpyud_nac_lh_s0 :
-Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_mpyud_nac_lh_s0">;
-
-def int_hexagon_A4_round_ri_sat :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A4_round_ri_sat", [ImmArg<1>]>;
-
-def int_hexagon_M2_mpy_nac_hl_s0 :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpy_nac_hl_s0">;
-
-def int_hexagon_M2_mpy_nac_hl_s1 :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpy_nac_hl_s1">;
-
-def int_hexagon_A2_vavghcr :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vavghcr">;
-
-def int_hexagon_M2_mmacls_rs0 :
-Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M2_mmacls_rs0">;
-
-def int_hexagon_M2_mmacls_rs1 :
-Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M2_mmacls_rs1">;
-
-def int_hexagon_M2_cmaci_s0 :
-Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_cmaci_s0">;
-
-def int_hexagon_S2_setbit_i :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_S2_setbit_i", [ImmArg<1>]>;
-
-def int_hexagon_S2_asl_i_p_or :
-Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_asl_i_p_or", [ImmArg<2>]>;
-
-def int_hexagon_A4_andn :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A4_andn">;
-
-def int_hexagon_M5_vrmpybsu :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M5_vrmpybsu">;
-
-def int_hexagon_S2_vrndpackwh :
-Hexagon_i32_i64_Intrinsic<"HEXAGON_S2_vrndpackwh">;
-
-def int_hexagon_M2_vcmac_s0_sat_r :
-Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M2_vcmac_s0_sat_r">;
-
-def int_hexagon_A2_vmaxuw :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vmaxuw">;
-
-def int_hexagon_C2_bitsclr :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_C2_bitsclr">;
-
-def int_hexagon_M2_xor_xacc :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_xor_xacc">;
-
-def int_hexagon_A4_vcmpbgtui :
-Hexagon_i32_i64i32_Intrinsic<"HEXAGON_A4_vcmpbgtui", [ImmArg<1>]>;
-
-def int_hexagon_A4_ornp :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A4_ornp">;
-
-def int_hexagon_A2_tfrpi :
-Hexagon_i64_i32_Intrinsic<"HEXAGON_A2_tfrpi", [ImmArg<0>]>;
-
-def int_hexagon_C4_and_or :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_C4_and_or">;
-
-def int_hexagon_M2_mpy_nac_sat_hh_s1 :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpy_nac_sat_hh_s1">;
-
-def int_hexagon_M2_mpy_nac_sat_hh_s0 :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpy_nac_sat_hh_s0">;
-
-def int_hexagon_A2_subh_h16_sat_ll :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_subh_h16_sat_ll">;
-
-def int_hexagon_A2_subh_h16_sat_lh :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_subh_h16_sat_lh">;
-
-def int_hexagon_M2_vmpy2su_s1 :
-Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_vmpy2su_s1">;
-
-def int_hexagon_M2_vmpy2su_s0 :
-Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_vmpy2su_s0">;
-
-def int_hexagon_S2_asr_i_p_acc :
-Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_asr_i_p_acc", [ImmArg<2>]>;
-
-def int_hexagon_C4_nbitsclri :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_C4_nbitsclri", [ImmArg<1>]>;
-
-def int_hexagon_S2_lsr_i_vh :
-Hexagon_i64_i64i32_Intrinsic<"HEXAGON_S2_lsr_i_vh", [ImmArg<1>]>;
-
-def int_hexagon_S2_lsr_i_p_xacc :
-Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_lsr_i_p_xacc", [ImmArg<2>]>;
-
-// V55 Scalar Instructions.
-
-def int_hexagon_A5_ACS :
-Hexagon_i64i32_i64i64i64_Intrinsic<"HEXAGON_A5_ACS">;
-
-// V60 Scalar Instructions.
-
-def int_hexagon_S6_rol_i_p_and :
-Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S6_rol_i_p_and", [ImmArg<2>]>;
-
-def int_hexagon_S6_rol_i_r_xacc :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S6_rol_i_r_xacc", [ImmArg<2>]>;
-
-def int_hexagon_S6_rol_i_r_and :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S6_rol_i_r_and", [ImmArg<2>]>;
-
-def int_hexagon_S6_rol_i_r_acc :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S6_rol_i_r_acc", [ImmArg<2>]>;
-
-def int_hexagon_S6_rol_i_p_xacc :
-Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S6_rol_i_p_xacc", [ImmArg<2>]>;
-
-def int_hexagon_S6_rol_i_p :
-Hexagon_i64_i64i32_Intrinsic<"HEXAGON_S6_rol_i_p", [ImmArg<1>]>;
-
-def int_hexagon_S6_rol_i_p_nac :
-Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S6_rol_i_p_nac", [ImmArg<2>]>;
-
-def int_hexagon_S6_rol_i_p_acc :
-Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S6_rol_i_p_acc", [ImmArg<2>]>;
-
-def int_hexagon_S6_rol_i_r_or :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S6_rol_i_r_or", [ImmArg<2>]>;
-
-def int_hexagon_S6_rol_i_r :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_S6_rol_i_r", [ImmArg<1>]>;
-
-def int_hexagon_S6_rol_i_r_nac :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S6_rol_i_r_nac", [ImmArg<2>]>;
-
-def int_hexagon_S6_rol_i_p_or :
-Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S6_rol_i_p_or", [ImmArg<2>]>;
-
-// V62 Scalar Instructions.
-
-def int_hexagon_S6_vtrunehb_ppp :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_S6_vtrunehb_ppp">;
-
-def int_hexagon_V6_ldntnt0 :
-Hexagon_v16i32_i32_Intrinsic<"HEXAGON_V6_ldntnt0">;
-
-def int_hexagon_M6_vabsdiffub :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M6_vabsdiffub">;
-
-def int_hexagon_S6_vtrunohb_ppp :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_S6_vtrunohb_ppp">;
-
-def int_hexagon_M6_vabsdiffb :
-Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M6_vabsdiffb">;
-
-def int_hexagon_A6_vminub_RdP :
-Hexagon_i64i32_i64i64_Intrinsic<"HEXAGON_A6_vminub_RdP">;
-
-def int_hexagon_S6_vsplatrbp :
-Hexagon_i64_i32_Intrinsic<"HEXAGON_S6_vsplatrbp">;
-
-// V65 Scalar Instructions.
-
-def int_hexagon_A6_vcmpbeq_notany :
-Hexagon_i32_i64i64_Intrinsic<"HEXAGON_A6_vcmpbeq_notany">;
-
-// V66 Scalar Instructions.
-
-def int_hexagon_F2_dfsub :
-Hexagon_double_doubledouble_Intrinsic<"HEXAGON_F2_dfsub">;
-
-def int_hexagon_F2_dfadd :
-Hexagon_double_doubledouble_Intrinsic<"HEXAGON_F2_dfadd">;
-
-def int_hexagon_M2_mnaci :
-Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mnaci">;
-
-def int_hexagon_S2_mask :
-Hexagon_i32_i32i32_Intrinsic<"HEXAGON_S2_mask", [ImmArg<0>, ImmArg<1>]>;
-
-// V60 HVX Instructions.
-
-def int_hexagon_V6_veqb_or :
-Hexagon_v512i1_v512i1v16i32v16i32_Intrinsic<"HEXAGON_V6_veqb_or">;
-
-def int_hexagon_V6_veqb_or_128B :
-Hexagon_v1024i1_v1024i1v32i32v32i32_Intrinsic<"HEXAGON_V6_veqb_or_128B">;
-
-def int_hexagon_V6_vminub :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vminub">;
-
-def int_hexagon_V6_vminub_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vminub_128B">;
-
-def int_hexagon_V6_vaslw_acc :
-Hexagon_v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vaslw_acc">;
-
-def int_hexagon_V6_vaslw_acc_128B :
-Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vaslw_acc_128B">;
-
-def int_hexagon_V6_vmpyhvsrs :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vmpyhvsrs">;
-
-def int_hexagon_V6_vmpyhvsrs_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vmpyhvsrs_128B">;
-
-def int_hexagon_V6_vsathub :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vsathub">;
-
-def int_hexagon_V6_vsathub_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vsathub_128B">;
-
-def int_hexagon_V6_vaddh_dv :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vaddh_dv">;
-
-def int_hexagon_V6_vaddh_dv_128B :
-Hexagon_v64i32_v64i32v64i32_Intrinsic<"HEXAGON_V6_vaddh_dv_128B">;
-
-def int_hexagon_V6_vrmpybusi :
-Hexagon_v32i32_v32i32i32i32_Intrinsic<"HEXAGON_V6_vrmpybusi", [ImmArg<2>]>;
-
-def int_hexagon_V6_vrmpybusi_128B :
-Hexagon_v64i32_v64i32i32i32_Intrinsic<"HEXAGON_V6_vrmpybusi_128B", [ImmArg<2>]>;
-
-def int_hexagon_V6_vshufoh :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vshufoh">;
-
-def int_hexagon_V6_vshufoh_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vshufoh_128B">;
-
-def int_hexagon_V6_vasrwv :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vasrwv">;
-
-def int_hexagon_V6_vasrwv_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vasrwv_128B">;
-
-def int_hexagon_V6_vdmpyhsuisat :
-Hexagon_v16i32_v32i32i32_Intrinsic<"HEXAGON_V6_vdmpyhsuisat">;
-
-def int_hexagon_V6_vdmpyhsuisat_128B :
-Hexagon_v32i32_v64i32i32_Intrinsic<"HEXAGON_V6_vdmpyhsuisat_128B">;
-
-def int_hexagon_V6_vrsadubi_acc :
-Hexagon_v32i32_v32i32v32i32i32i32_Intrinsic<"HEXAGON_V6_vrsadubi_acc", [ImmArg<3>]>;
-
-def int_hexagon_V6_vrsadubi_acc_128B :
-Hexagon_v64i32_v64i32v64i32i32i32_Intrinsic<"HEXAGON_V6_vrsadubi_acc_128B", [ImmArg<3>]>;
-
-def int_hexagon_V6_vnavgw :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vnavgw">;
-
-def int_hexagon_V6_vnavgw_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vnavgw_128B">;
-
-def int_hexagon_V6_vnavgh :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vnavgh">;
-
-def int_hexagon_V6_vnavgh_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vnavgh_128B">;
-
-def int_hexagon_V6_vavgub :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vavgub">;
-
-def int_hexagon_V6_vavgub_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vavgub_128B">;
-
-def int_hexagon_V6_vsubb :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vsubb">;
-
-def int_hexagon_V6_vsubb_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vsubb_128B">;
-
-def int_hexagon_V6_vgtw_and :
-Hexagon_v512i1_v512i1v16i32v16i32_Intrinsic<"HEXAGON_V6_vgtw_and">;
-
-def int_hexagon_V6_vgtw_and_128B :
-Hexagon_v1024i1_v1024i1v32i32v32i32_Intrinsic<"HEXAGON_V6_vgtw_and_128B">;
-
-def int_hexagon_V6_vavgubrnd :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vavgubrnd">;
-
-def int_hexagon_V6_vavgubrnd_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vavgubrnd_128B">;
-
-def int_hexagon_V6_vrmpybusv :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vrmpybusv">;
-
-def int_hexagon_V6_vrmpybusv_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vrmpybusv_128B">;
-
-def int_hexagon_V6_vsubbnq :
-Hexagon_v16i32_v512i1v16i32v16i32_Intrinsic<"HEXAGON_V6_vsubbnq">;
-
-def int_hexagon_V6_vsubbnq_128B :
-Hexagon_v32i32_v1024i1v32i32v32i32_Intrinsic<"HEXAGON_V6_vsubbnq_128B">;
-
-def int_hexagon_V6_vroundhb :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vroundhb">;
-
-def int_hexagon_V6_vroundhb_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vroundhb_128B">;
-
-def int_hexagon_V6_vadduhsat_dv :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vadduhsat_dv">;
-
-def int_hexagon_V6_vadduhsat_dv_128B :
-Hexagon_v64i32_v64i32v64i32_Intrinsic<"HEXAGON_V6_vadduhsat_dv_128B">;
-
-def int_hexagon_V6_vsububsat :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vsububsat">;
-
-def int_hexagon_V6_vsububsat_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vsububsat_128B">;
-
-def int_hexagon_V6_vmpabus_acc :
-Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vmpabus_acc">;
-
-def int_hexagon_V6_vmpabus_acc_128B :
-Hexagon_v64i32_v64i32v64i32i32_Intrinsic<"HEXAGON_V6_vmpabus_acc_128B">;
-
-def int_hexagon_V6_vmux :
-Hexagon_v16i32_v512i1v16i32v16i32_Intrinsic<"HEXAGON_V6_vmux">;
-
-def int_hexagon_V6_vmux_128B :
-Hexagon_v32i32_v1024i1v32i32v32i32_Intrinsic<"HEXAGON_V6_vmux_128B">;
-
-def int_hexagon_V6_vmpyhus :
-Hexagon_v32i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vmpyhus">;
-
-def int_hexagon_V6_vmpyhus_128B :
-Hexagon_v64i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vmpyhus_128B">;
-
-def int_hexagon_V6_vpackeb :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vpackeb">;
-
-def int_hexagon_V6_vpackeb_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vpackeb_128B">;
-
-def int_hexagon_V6_vsubhnq :
-Hexagon_v16i32_v512i1v16i32v16i32_Intrinsic<"HEXAGON_V6_vsubhnq">;
-
-def int_hexagon_V6_vsubhnq_128B :
-Hexagon_v32i32_v1024i1v32i32v32i32_Intrinsic<"HEXAGON_V6_vsubhnq_128B">;
-
-def int_hexagon_V6_vavghrnd :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vavghrnd">;
-
-def int_hexagon_V6_vavghrnd_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vavghrnd_128B">;
-
-def int_hexagon_V6_vtran2x2_map :
-Hexagon_v16i32v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vtran2x2_map">;
-
-def int_hexagon_V6_vtran2x2_map_128B :
-Hexagon_v32i32v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vtran2x2_map_128B">;
-
-def int_hexagon_V6_vdelta :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vdelta">;
-
-def int_hexagon_V6_vdelta_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vdelta_128B">;
-
-def int_hexagon_V6_vgtuh_and :
-Hexagon_v512i1_v512i1v16i32v16i32_Intrinsic<"HEXAGON_V6_vgtuh_and">;
-
-def int_hexagon_V6_vgtuh_and_128B :
-Hexagon_v1024i1_v1024i1v32i32v32i32_Intrinsic<"HEXAGON_V6_vgtuh_and_128B">;
-
-def int_hexagon_V6_vtmpyhb :
-Hexagon_v32i32_v32i32i32_Intrinsic<"HEXAGON_V6_vtmpyhb">;
-
-def int_hexagon_V6_vtmpyhb_128B :
-Hexagon_v64i32_v64i32i32_Intrinsic<"HEXAGON_V6_vtmpyhb_128B">;
-
-def int_hexagon_V6_vpackob :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vpackob">;
-
-def int_hexagon_V6_vpackob_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vpackob_128B">;
-
-def int_hexagon_V6_vmaxh :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vmaxh">;
-
-def int_hexagon_V6_vmaxh_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vmaxh_128B">;
-
-def int_hexagon_V6_vtmpybus_acc :
-Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vtmpybus_acc">;
-
-def int_hexagon_V6_vtmpybus_acc_128B :
-Hexagon_v64i32_v64i32v64i32i32_Intrinsic<"HEXAGON_V6_vtmpybus_acc_128B">;
-
-def int_hexagon_V6_vsubuhsat :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vsubuhsat">;
-
-def int_hexagon_V6_vsubuhsat_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vsubuhsat_128B">;
-
-def int_hexagon_V6_vasrw_acc :
-Hexagon_v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vasrw_acc">;
-
-def int_hexagon_V6_vasrw_acc_128B :
-Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vasrw_acc_128B">;
-
-def int_hexagon_V6_pred_or :
-Hexagon_v512i1_v512i1v512i1_Intrinsic<"HEXAGON_V6_pred_or">;
-
-def int_hexagon_V6_pred_or_128B :
-Hexagon_v1024i1_v1024i1v1024i1_Intrinsic<"HEXAGON_V6_pred_or_128B">;
-
-def int_hexagon_V6_vrmpyub_acc :
-Hexagon_v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vrmpyub_acc">;
-
-def int_hexagon_V6_vrmpyub_acc_128B :
-Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vrmpyub_acc_128B">;
-
-def int_hexagon_V6_lo :
-Hexagon_v16i32_v32i32_Intrinsic<"HEXAGON_V6_lo">;
-
-def int_hexagon_V6_lo_128B :
-Hexagon_v32i32_v64i32_Intrinsic<"HEXAGON_V6_lo_128B">;
-
-def int_hexagon_V6_vsubb_dv :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vsubb_dv">;
-
-def int_hexagon_V6_vsubb_dv_128B :
-Hexagon_v64i32_v64i32v64i32_Intrinsic<"HEXAGON_V6_vsubb_dv_128B">;
-
-def int_hexagon_V6_vsubhsat_dv :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vsubhsat_dv">;
-
-def int_hexagon_V6_vsubhsat_dv_128B :
-Hexagon_v64i32_v64i32v64i32_Intrinsic<"HEXAGON_V6_vsubhsat_dv_128B">;
-
-def int_hexagon_V6_vmpyiwh :
-Hexagon_v16i32_v16i32i32_Intrinsic<"HEXAGON_V6_vmpyiwh">;
-
-def int_hexagon_V6_vmpyiwh_128B :
-Hexagon_v32i32_v32i32i32_Intrinsic<"HEXAGON_V6_vmpyiwh_128B">;
-
-def int_hexagon_V6_vmpyiwb :
-Hexagon_v16i32_v16i32i32_Intrinsic<"HEXAGON_V6_vmpyiwb">;
-
-def int_hexagon_V6_vmpyiwb_128B :
-Hexagon_v32i32_v32i32i32_Intrinsic<"HEXAGON_V6_vmpyiwb_128B">;
-
-def int_hexagon_V6_ldu0 :
-Hexagon_v16i32_i32_Intrinsic<"HEXAGON_V6_ldu0">;
-
-def int_hexagon_V6_ldu0_128B :
-Hexagon_v32i32_i32_Intrinsic<"HEXAGON_V6_ldu0_128B">;
-
-def int_hexagon_V6_vgtuh_xor :
-Hexagon_v512i1_v512i1v16i32v16i32_Intrinsic<"HEXAGON_V6_vgtuh_xor">;
-
-def int_hexagon_V6_vgtuh_xor_128B :
-Hexagon_v1024i1_v1024i1v32i32v32i32_Intrinsic<"HEXAGON_V6_vgtuh_xor_128B">;
-
-def int_hexagon_V6_vgth_or :
-Hexagon_v512i1_v512i1v16i32v16i32_Intrinsic<"HEXAGON_V6_vgth_or">;
-
-def int_hexagon_V6_vgth_or_128B :
-Hexagon_v1024i1_v1024i1v32i32v32i32_Intrinsic<"HEXAGON_V6_vgth_or_128B">;
-
-def int_hexagon_V6_vavgh :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vavgh">;
-
-def int_hexagon_V6_vavgh_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vavgh_128B">;
-
-def int_hexagon_V6_vlalignb :
-Hexagon_v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vlalignb">;
-
-def int_hexagon_V6_vlalignb_128B :
-Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vlalignb_128B">;
-
-def int_hexagon_V6_vsh :
-Hexagon_v32i32_v16i32_Intrinsic<"HEXAGON_V6_vsh">;
-
-def int_hexagon_V6_vsh_128B :
-Hexagon_v64i32_v32i32_Intrinsic<"HEXAGON_V6_vsh_128B">;
-
-def int_hexagon_V6_pred_and_n :
-Hexagon_v512i1_v512i1v512i1_Intrinsic<"HEXAGON_V6_pred_and_n">;
-
-def int_hexagon_V6_pred_and_n_128B :
-Hexagon_v1024i1_v1024i1v1024i1_Intrinsic<"HEXAGON_V6_pred_and_n_128B">;
-
-def int_hexagon_V6_vsb :
-Hexagon_v32i32_v16i32_Intrinsic<"HEXAGON_V6_vsb">;
-
-def int_hexagon_V6_vsb_128B :
-Hexagon_v64i32_v32i32_Intrinsic<"HEXAGON_V6_vsb_128B">;
-
-def int_hexagon_V6_vroundwuh :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vroundwuh">;
-
-def int_hexagon_V6_vroundwuh_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vroundwuh_128B">;
-
-def int_hexagon_V6_vasrhv :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vasrhv">;
-
-def int_hexagon_V6_vasrhv_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vasrhv_128B">;
-
-def int_hexagon_V6_vshuffh :
-Hexagon_v16i32_v16i32_Intrinsic<"HEXAGON_V6_vshuffh">;
-
-def int_hexagon_V6_vshuffh_128B :
-Hexagon_v32i32_v32i32_Intrinsic<"HEXAGON_V6_vshuffh_128B">;
-
-def int_hexagon_V6_vaddhsat_dv :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vaddhsat_dv">;
-
-def int_hexagon_V6_vaddhsat_dv_128B :
-Hexagon_v64i32_v64i32v64i32_Intrinsic<"HEXAGON_V6_vaddhsat_dv_128B">;
-
-def int_hexagon_V6_vnavgub :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vnavgub">;
-
-def int_hexagon_V6_vnavgub_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vnavgub_128B">;
-
-def int_hexagon_V6_vrmpybv :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vrmpybv">;
-
-def int_hexagon_V6_vrmpybv_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vrmpybv_128B">;
-
-def int_hexagon_V6_vnormamth :
-Hexagon_v16i32_v16i32_Intrinsic<"HEXAGON_V6_vnormamth">;
-
-def int_hexagon_V6_vnormamth_128B :
-Hexagon_v32i32_v32i32_Intrinsic<"HEXAGON_V6_vnormamth_128B">;
-
-def int_hexagon_V6_vdmpyhb :
-Hexagon_v16i32_v16i32i32_Intrinsic<"HEXAGON_V6_vdmpyhb">;
-
-def int_hexagon_V6_vdmpyhb_128B :
-Hexagon_v32i32_v32i32i32_Intrinsic<"HEXAGON_V6_vdmpyhb_128B">;
-
-def int_hexagon_V6_vavguh :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vavguh">;
-
-def int_hexagon_V6_vavguh_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vavguh_128B">;
-
-def int_hexagon_V6_vlsrwv :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vlsrwv">;
-
-def int_hexagon_V6_vlsrwv_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vlsrwv_128B">;
-
-def int_hexagon_V6_vlsrhv :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vlsrhv">;
-
-def int_hexagon_V6_vlsrhv_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vlsrhv_128B">;
-
-def int_hexagon_V6_vdmpyhisat :
-Hexagon_v16i32_v32i32i32_Intrinsic<"HEXAGON_V6_vdmpyhisat">;
-
-def int_hexagon_V6_vdmpyhisat_128B :
-Hexagon_v32i32_v64i32i32_Intrinsic<"HEXAGON_V6_vdmpyhisat_128B">;
-
-def int_hexagon_V6_vdmpyhvsat :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vdmpyhvsat">;
-
-def int_hexagon_V6_vdmpyhvsat_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vdmpyhvsat_128B">;
-
-def int_hexagon_V6_vaddw :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vaddw">;
-
-def int_hexagon_V6_vaddw_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vaddw_128B">;
-
-def int_hexagon_V6_vzh :
-Hexagon_v32i32_v16i32_Intrinsic<"HEXAGON_V6_vzh">;
-
-def int_hexagon_V6_vzh_128B :
-Hexagon_v64i32_v32i32_Intrinsic<"HEXAGON_V6_vzh_128B">;
-
-def int_hexagon_V6_vaddh :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vaddh">;
-
-def int_hexagon_V6_vaddh_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vaddh_128B">;
-
-def int_hexagon_V6_vmaxub :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vmaxub">;
-
-def int_hexagon_V6_vmaxub_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vmaxub_128B">;
-
-def int_hexagon_V6_vmpyhv_acc :
-Hexagon_v32i32_v32i32v16i32v16i32_Intrinsic<"HEXAGON_V6_vmpyhv_acc">;
-
-def int_hexagon_V6_vmpyhv_acc_128B :
-Hexagon_v64i32_v64i32v32i32v32i32_Intrinsic<"HEXAGON_V6_vmpyhv_acc_128B">;
-
-def int_hexagon_V6_vadduhsat :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vadduhsat">;
-
-def int_hexagon_V6_vadduhsat_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vadduhsat_128B">;
-
-def int_hexagon_V6_vshufoeh :
-Hexagon_v32i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vshufoeh">;
-
-def int_hexagon_V6_vshufoeh_128B :
-Hexagon_v64i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vshufoeh_128B">;
-
-def int_hexagon_V6_vmpyuhv_acc :
-Hexagon_v32i32_v32i32v16i32v16i32_Intrinsic<"HEXAGON_V6_vmpyuhv_acc">;
-
-def int_hexagon_V6_vmpyuhv_acc_128B :
-Hexagon_v64i32_v64i32v32i32v32i32_Intrinsic<"HEXAGON_V6_vmpyuhv_acc_128B">;
-
-def int_hexagon_V6_veqh :
-Hexagon_v512i1_v16i32v16i32_Intrinsic<"HEXAGON_V6_veqh">;
-
-def int_hexagon_V6_veqh_128B :
-Hexagon_v1024i1_v32i32v32i32_Intrinsic<"HEXAGON_V6_veqh_128B">;
-
-def int_hexagon_V6_vmpabuuv :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vmpabuuv">;
-
-def int_hexagon_V6_vmpabuuv_128B :
-Hexagon_v64i32_v64i32v64i32_Intrinsic<"HEXAGON_V6_vmpabuuv_128B">;
-
-def int_hexagon_V6_vasrwhsat :
-Hexagon_v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vasrwhsat">;
-
-def int_hexagon_V6_vasrwhsat_128B :
-Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vasrwhsat_128B">;
-
-def int_hexagon_V6_vminuh :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vminuh">;
-
-def int_hexagon_V6_vminuh_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vminuh_128B">;
-
-def int_hexagon_V6_vror :
-Hexagon_v16i32_v16i32i32_Intrinsic<"HEXAGON_V6_vror">;
-
-def int_hexagon_V6_vror_128B :
-Hexagon_v32i32_v32i32i32_Intrinsic<"HEXAGON_V6_vror_128B">;
-
-def int_hexagon_V6_vmpyowh_rnd_sacc :
-Hexagon_v16i32_v16i32v16i32v16i32_Intrinsic<"HEXAGON_V6_vmpyowh_rnd_sacc">;
-
-def int_hexagon_V6_vmpyowh_rnd_sacc_128B :
-Hexagon_v32i32_v32i32v32i32v32i32_Intrinsic<"HEXAGON_V6_vmpyowh_rnd_sacc_128B">;
-
-def int_hexagon_V6_vmaxuh :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vmaxuh">;
-
-def int_hexagon_V6_vmaxuh_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vmaxuh_128B">;
-
-def int_hexagon_V6_vabsh_sat :
-Hexagon_v16i32_v16i32_Intrinsic<"HEXAGON_V6_vabsh_sat">;
-
-def int_hexagon_V6_vabsh_sat_128B :
-Hexagon_v32i32_v32i32_Intrinsic<"HEXAGON_V6_vabsh_sat_128B">;
-
-def int_hexagon_V6_pred_or_n :
-Hexagon_v512i1_v512i1v512i1_Intrinsic<"HEXAGON_V6_pred_or_n">;
-
-def int_hexagon_V6_pred_or_n_128B :
-Hexagon_v1024i1_v1024i1v1024i1_Intrinsic<"HEXAGON_V6_pred_or_n_128B">;
-
-def int_hexagon_V6_vdealb :
-Hexagon_v16i32_v16i32_Intrinsic<"HEXAGON_V6_vdealb">;
-
-def int_hexagon_V6_vdealb_128B :
-Hexagon_v32i32_v32i32_Intrinsic<"HEXAGON_V6_vdealb_128B">;
-
-def int_hexagon_V6_vmpybusv :
-Hexagon_v32i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vmpybusv">;
-
-def int_hexagon_V6_vmpybusv_128B :
-Hexagon_v64i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vmpybusv_128B">;
-
-def int_hexagon_V6_vzb :
-Hexagon_v32i32_v16i32_Intrinsic<"HEXAGON_V6_vzb">;
-
-def int_hexagon_V6_vzb_128B :
-Hexagon_v64i32_v32i32_Intrinsic<"HEXAGON_V6_vzb_128B">;
-
-def int_hexagon_V6_vdmpybus_dv :
-Hexagon_v32i32_v32i32i32_Intrinsic<"HEXAGON_V6_vdmpybus_dv">;
-
-def int_hexagon_V6_vdmpybus_dv_128B :
-Hexagon_v64i32_v64i32i32_Intrinsic<"HEXAGON_V6_vdmpybus_dv_128B">;
-
-def int_hexagon_V6_vaddbq :
-Hexagon_v16i32_v512i1v16i32v16i32_Intrinsic<"HEXAGON_V6_vaddbq">;
-
-def int_hexagon_V6_vaddbq_128B :
-Hexagon_v32i32_v1024i1v32i32v32i32_Intrinsic<"HEXAGON_V6_vaddbq_128B">;
-
-def int_hexagon_V6_vaddb :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vaddb">;
-
-def int_hexagon_V6_vaddb_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vaddb_128B">;
-
-def int_hexagon_V6_vaddwq :
-Hexagon_v16i32_v512i1v16i32v16i32_Intrinsic<"HEXAGON_V6_vaddwq">;
-
-def int_hexagon_V6_vaddwq_128B :
-Hexagon_v32i32_v1024i1v32i32v32i32_Intrinsic<"HEXAGON_V6_vaddwq_128B">;
-
-def int_hexagon_V6_vasrhubrndsat :
-Hexagon_v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vasrhubrndsat">;
-
-def int_hexagon_V6_vasrhubrndsat_128B :
-Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vasrhubrndsat_128B">;
-
-def int_hexagon_V6_vasrhubsat :
-Hexagon_v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vasrhubsat">;
-
-def int_hexagon_V6_vasrhubsat_128B :
-Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vasrhubsat_128B">;
-
-def int_hexagon_V6_vshufoeb :
-Hexagon_v32i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vshufoeb">;
-
-def int_hexagon_V6_vshufoeb_128B :
-Hexagon_v64i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vshufoeb_128B">;
-
-def int_hexagon_V6_vpackhub_sat :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vpackhub_sat">;
-
-def int_hexagon_V6_vpackhub_sat_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vpackhub_sat_128B">;
-
-def int_hexagon_V6_vmpyiwh_acc :
-Hexagon_v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vmpyiwh_acc">;
-
-def int_hexagon_V6_vmpyiwh_acc_128B :
-Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vmpyiwh_acc_128B">;
-
-def int_hexagon_V6_vtmpyb :
-Hexagon_v32i32_v32i32i32_Intrinsic<"HEXAGON_V6_vtmpyb">;
-
-def int_hexagon_V6_vtmpyb_128B :
-Hexagon_v64i32_v64i32i32_Intrinsic<"HEXAGON_V6_vtmpyb_128B">;
-
-def int_hexagon_V6_vmpabusv :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vmpabusv">;
-
-def int_hexagon_V6_vmpabusv_128B :
-Hexagon_v64i32_v64i32v64i32_Intrinsic<"HEXAGON_V6_vmpabusv_128B">;
-
-def int_hexagon_V6_pred_and :
-Hexagon_v512i1_v512i1v512i1_Intrinsic<"HEXAGON_V6_pred_and">;
-
-def int_hexagon_V6_pred_and_128B :
-Hexagon_v1024i1_v1024i1v1024i1_Intrinsic<"HEXAGON_V6_pred_and_128B">;
-
-def int_hexagon_V6_vsubwnq :
-Hexagon_v16i32_v512i1v16i32v16i32_Intrinsic<"HEXAGON_V6_vsubwnq">;
-
-def int_hexagon_V6_vsubwnq_128B :
-Hexagon_v32i32_v1024i1v32i32v32i32_Intrinsic<"HEXAGON_V6_vsubwnq_128B">;
-
-def int_hexagon_V6_vpackwuh_sat :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vpackwuh_sat">;
-
-def int_hexagon_V6_vpackwuh_sat_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vpackwuh_sat_128B">;
-
-def int_hexagon_V6_vswap :
-Hexagon_v32i32_v512i1v16i32v16i32_Intrinsic<"HEXAGON_V6_vswap">;
-
-def int_hexagon_V6_vswap_128B :
-Hexagon_v64i32_v1024i1v32i32v32i32_Intrinsic<"HEXAGON_V6_vswap_128B">;
-
-def int_hexagon_V6_vrmpyubv_acc :
-Hexagon_v16i32_v16i32v16i32v16i32_Intrinsic<"HEXAGON_V6_vrmpyubv_acc">;
-
-def int_hexagon_V6_vrmpyubv_acc_128B :
-Hexagon_v32i32_v32i32v32i32v32i32_Intrinsic<"HEXAGON_V6_vrmpyubv_acc_128B">;
-
-def int_hexagon_V6_vgtb_and :
-Hexagon_v512i1_v512i1v16i32v16i32_Intrinsic<"HEXAGON_V6_vgtb_and">;
-
-def int_hexagon_V6_vgtb_and_128B :
-Hexagon_v1024i1_v1024i1v32i32v32i32_Intrinsic<"HEXAGON_V6_vgtb_and_128B">;
-
-def int_hexagon_V6_vaslw :
-Hexagon_v16i32_v16i32i32_Intrinsic<"HEXAGON_V6_vaslw">;
-
-def int_hexagon_V6_vaslw_128B :
-Hexagon_v32i32_v32i32i32_Intrinsic<"HEXAGON_V6_vaslw_128B">;
-
-def int_hexagon_V6_vpackhb_sat :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vpackhb_sat">;
-
-def int_hexagon_V6_vpackhb_sat_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vpackhb_sat_128B">;
-
-def int_hexagon_V6_vmpyih_acc :
-Hexagon_v16i32_v16i32v16i32v16i32_Intrinsic<"HEXAGON_V6_vmpyih_acc">;
-
-def int_hexagon_V6_vmpyih_acc_128B :
-Hexagon_v32i32_v32i32v32i32v32i32_Intrinsic<"HEXAGON_V6_vmpyih_acc_128B">;
-
-def int_hexagon_V6_vshuffvdd :
-Hexagon_v32i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vshuffvdd">;
-
-def int_hexagon_V6_vshuffvdd_128B :
-Hexagon_v64i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vshuffvdd_128B">;
-
-def int_hexagon_V6_vaddb_dv :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vaddb_dv">;
-
-def int_hexagon_V6_vaddb_dv_128B :
-Hexagon_v64i32_v64i32v64i32_Intrinsic<"HEXAGON_V6_vaddb_dv_128B">;
-
-def int_hexagon_V6_vunpackub :
-Hexagon_v32i32_v16i32_Intrinsic<"HEXAGON_V6_vunpackub">;
-
-def int_hexagon_V6_vunpackub_128B :
-Hexagon_v64i32_v32i32_Intrinsic<"HEXAGON_V6_vunpackub_128B">;
-
-def int_hexagon_V6_vgtuw :
-Hexagon_v512i1_v16i32v16i32_Intrinsic<"HEXAGON_V6_vgtuw">;
-
-def int_hexagon_V6_vgtuw_128B :
-Hexagon_v1024i1_v32i32v32i32_Intrinsic<"HEXAGON_V6_vgtuw_128B">;
-
-def int_hexagon_V6_vlutvwh :
-Hexagon_v32i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vlutvwh">;
-
-def int_hexagon_V6_vlutvwh_128B :
-Hexagon_v64i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vlutvwh_128B">;
-
-def int_hexagon_V6_vgtub :
-Hexagon_v512i1_v16i32v16i32_Intrinsic<"HEXAGON_V6_vgtub">;
-
-def int_hexagon_V6_vgtub_128B :
-Hexagon_v1024i1_v32i32v32i32_Intrinsic<"HEXAGON_V6_vgtub_128B">;
-
-def int_hexagon_V6_vmpyowh :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vmpyowh">;
-
-def int_hexagon_V6_vmpyowh_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vmpyowh_128B">;
-
-def int_hexagon_V6_vmpyieoh :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vmpyieoh">;
-
-def int_hexagon_V6_vmpyieoh_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vmpyieoh_128B">;
-
-def int_hexagon_V6_extractw :
-Hexagon_i32_v16i32i32_Intrinsic<"HEXAGON_V6_extractw">;
-
-def int_hexagon_V6_extractw_128B :
-Hexagon_i32_v32i32i32_Intrinsic<"HEXAGON_V6_extractw_128B">;
-
-def int_hexagon_V6_vavgwrnd :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vavgwrnd">;
-
-def int_hexagon_V6_vavgwrnd_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vavgwrnd_128B">;
-
-def int_hexagon_V6_vdmpyhsat_acc :
-Hexagon_v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vdmpyhsat_acc">;
-
-def int_hexagon_V6_vdmpyhsat_acc_128B :
-Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vdmpyhsat_acc_128B">;
-
-def int_hexagon_V6_vgtub_xor :
-Hexagon_v512i1_v512i1v16i32v16i32_Intrinsic<"HEXAGON_V6_vgtub_xor">;
-
-def int_hexagon_V6_vgtub_xor_128B :
-Hexagon_v1024i1_v1024i1v32i32v32i32_Intrinsic<"HEXAGON_V6_vgtub_xor_128B">;
-
-def int_hexagon_V6_vmpyub :
-Hexagon_v32i32_v16i32i32_Intrinsic<"HEXAGON_V6_vmpyub">;
-
-def int_hexagon_V6_vmpyub_128B :
-Hexagon_v64i32_v32i32i32_Intrinsic<"HEXAGON_V6_vmpyub_128B">;
-
-def int_hexagon_V6_vmpyuh :
-Hexagon_v32i32_v16i32i32_Intrinsic<"HEXAGON_V6_vmpyuh">;
-
-def int_hexagon_V6_vmpyuh_128B :
-Hexagon_v64i32_v32i32i32_Intrinsic<"HEXAGON_V6_vmpyuh_128B">;
-
-def int_hexagon_V6_vunpackob :
-Hexagon_v32i32_v32i32v16i32_Intrinsic<"HEXAGON_V6_vunpackob">;
-
-def int_hexagon_V6_vunpackob_128B :
-Hexagon_v64i32_v64i32v32i32_Intrinsic<"HEXAGON_V6_vunpackob_128B">;
-
-def int_hexagon_V6_vmpahb :
-Hexagon_v32i32_v32i32i32_Intrinsic<"HEXAGON_V6_vmpahb">;
-
-def int_hexagon_V6_vmpahb_128B :
-Hexagon_v64i32_v64i32i32_Intrinsic<"HEXAGON_V6_vmpahb_128B">;
-
-def int_hexagon_V6_veqw_or :
-Hexagon_v512i1_v512i1v16i32v16i32_Intrinsic<"HEXAGON_V6_veqw_or">;
-
-def int_hexagon_V6_veqw_or_128B :
-Hexagon_v1024i1_v1024i1v32i32v32i32_Intrinsic<"HEXAGON_V6_veqw_or_128B">;
-
-def int_hexagon_V6_vandqrt :
-Hexagon_v16i32_v512i1i32_Intrinsic<"HEXAGON_V6_vandqrt">;
-
-def int_hexagon_V6_vandqrt_128B :
-Hexagon_v32i32_v1024i1i32_Intrinsic<"HEXAGON_V6_vandqrt_128B">;
-
-def int_hexagon_V6_vxor :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vxor">;
-
-def int_hexagon_V6_vxor_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vxor_128B">;
-
-def int_hexagon_V6_vasrwhrndsat :
-Hexagon_v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vasrwhrndsat">;
-
-def int_hexagon_V6_vasrwhrndsat_128B :
-Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vasrwhrndsat_128B">;
-
-def int_hexagon_V6_vmpyhsat_acc :
-Hexagon_v32i32_v32i32v16i32i32_Intrinsic<"HEXAGON_V6_vmpyhsat_acc">;
-
-def int_hexagon_V6_vmpyhsat_acc_128B :
-Hexagon_v64i32_v64i32v32i32i32_Intrinsic<"HEXAGON_V6_vmpyhsat_acc_128B">;
-
-def int_hexagon_V6_vrmpybus_acc :
-Hexagon_v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vrmpybus_acc">;
-
-def int_hexagon_V6_vrmpybus_acc_128B :
-Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vrmpybus_acc_128B">;
-
-def int_hexagon_V6_vsubhw :
-Hexagon_v32i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vsubhw">;
-
-def int_hexagon_V6_vsubhw_128B :
-Hexagon_v64i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vsubhw_128B">;
-
-def int_hexagon_V6_vdealb4w :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vdealb4w">;
-
-def int_hexagon_V6_vdealb4w_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vdealb4w_128B">;
-
-def int_hexagon_V6_vmpyowh_sacc :
-Hexagon_v16i32_v16i32v16i32v16i32_Intrinsic<"HEXAGON_V6_vmpyowh_sacc">;
-
-def int_hexagon_V6_vmpyowh_sacc_128B :
-Hexagon_v32i32_v32i32v32i32v32i32_Intrinsic<"HEXAGON_V6_vmpyowh_sacc_128B">;
-
-def int_hexagon_V6_vmpybv :
-Hexagon_v32i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vmpybv">;
-
-def int_hexagon_V6_vmpybv_128B :
-Hexagon_v64i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vmpybv_128B">;
-
-def int_hexagon_V6_vabsdiffh :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vabsdiffh">;
-
-def int_hexagon_V6_vabsdiffh_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vabsdiffh_128B">;
-
-def int_hexagon_V6_vshuffob :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vshuffob">;
-
-def int_hexagon_V6_vshuffob_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vshuffob_128B">;
-
-def int_hexagon_V6_vmpyub_acc :
-Hexagon_v32i32_v32i32v16i32i32_Intrinsic<"HEXAGON_V6_vmpyub_acc">;
-
-def int_hexagon_V6_vmpyub_acc_128B :
-Hexagon_v64i32_v64i32v32i32i32_Intrinsic<"HEXAGON_V6_vmpyub_acc_128B">;
-
-def int_hexagon_V6_vnormamtw :
-Hexagon_v16i32_v16i32_Intrinsic<"HEXAGON_V6_vnormamtw">;
-
-def int_hexagon_V6_vnormamtw_128B :
-Hexagon_v32i32_v32i32_Intrinsic<"HEXAGON_V6_vnormamtw_128B">;
-
-def int_hexagon_V6_vunpackuh :
-Hexagon_v32i32_v16i32_Intrinsic<"HEXAGON_V6_vunpackuh">;
-
-def int_hexagon_V6_vunpackuh_128B :
-Hexagon_v64i32_v32i32_Intrinsic<"HEXAGON_V6_vunpackuh_128B">;
-
-def int_hexagon_V6_vgtuh_or :
-Hexagon_v512i1_v512i1v16i32v16i32_Intrinsic<"HEXAGON_V6_vgtuh_or">;
-
-def int_hexagon_V6_vgtuh_or_128B :
-Hexagon_v1024i1_v1024i1v32i32v32i32_Intrinsic<"HEXAGON_V6_vgtuh_or_128B">;
-
-def int_hexagon_V6_vmpyiewuh_acc :
-Hexagon_v16i32_v16i32v16i32v16i32_Intrinsic<"HEXAGON_V6_vmpyiewuh_acc">;
-
-def int_hexagon_V6_vmpyiewuh_acc_128B :
-Hexagon_v32i32_v32i32v32i32v32i32_Intrinsic<"HEXAGON_V6_vmpyiewuh_acc_128B">;
-
-def int_hexagon_V6_vunpackoh :
-Hexagon_v32i32_v32i32v16i32_Intrinsic<"HEXAGON_V6_vunpackoh">;
-
-def int_hexagon_V6_vunpackoh_128B :
-Hexagon_v64i32_v64i32v32i32_Intrinsic<"HEXAGON_V6_vunpackoh_128B">;
-
-def int_hexagon_V6_vdmpyhsat :
-Hexagon_v16i32_v16i32i32_Intrinsic<"HEXAGON_V6_vdmpyhsat">;
-
-def int_hexagon_V6_vdmpyhsat_128B :
-Hexagon_v32i32_v32i32i32_Intrinsic<"HEXAGON_V6_vdmpyhsat_128B">;
-
-def int_hexagon_V6_vmpyubv :
-Hexagon_v32i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vmpyubv">;
-
-def int_hexagon_V6_vmpyubv_128B :
-Hexagon_v64i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vmpyubv_128B">;
-
-def int_hexagon_V6_vmpyhss :
-Hexagon_v16i32_v16i32i32_Intrinsic<"HEXAGON_V6_vmpyhss">;
-
-def int_hexagon_V6_vmpyhss_128B :
-Hexagon_v32i32_v32i32i32_Intrinsic<"HEXAGON_V6_vmpyhss_128B">;
-
-def int_hexagon_V6_hi :
-Hexagon_v16i32_v32i32_Intrinsic<"HEXAGON_V6_hi">;
-
-def int_hexagon_V6_hi_128B :
-Hexagon_v32i32_v64i32_Intrinsic<"HEXAGON_V6_hi_128B">;
-
-def int_hexagon_V6_vasrwuhsat :
-Hexagon_v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vasrwuhsat">;
-
-def int_hexagon_V6_vasrwuhsat_128B :
-Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vasrwuhsat_128B">;
-
-def int_hexagon_V6_veqw :
-Hexagon_v512i1_v16i32v16i32_Intrinsic<"HEXAGON_V6_veqw">;
-
-def int_hexagon_V6_veqw_128B :
-Hexagon_v1024i1_v32i32v32i32_Intrinsic<"HEXAGON_V6_veqw_128B">;
-
-def int_hexagon_V6_vdsaduh :
-Hexagon_v32i32_v32i32i32_Intrinsic<"HEXAGON_V6_vdsaduh">;
-
-def int_hexagon_V6_vdsaduh_128B :
-Hexagon_v64i32_v64i32i32_Intrinsic<"HEXAGON_V6_vdsaduh_128B">;
-
-def int_hexagon_V6_vsubw :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vsubw">;
-
-def int_hexagon_V6_vsubw_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vsubw_128B">;
-
-def int_hexagon_V6_vsubw_dv :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vsubw_dv">;
-
-def int_hexagon_V6_vsubw_dv_128B :
-Hexagon_v64i32_v64i32v64i32_Intrinsic<"HEXAGON_V6_vsubw_dv_128B">;
-
-def int_hexagon_V6_veqb_and :
-Hexagon_v512i1_v512i1v16i32v16i32_Intrinsic<"HEXAGON_V6_veqb_and">;
-
-def int_hexagon_V6_veqb_and_128B :
-Hexagon_v1024i1_v1024i1v32i32v32i32_Intrinsic<"HEXAGON_V6_veqb_and_128B">;
-
-def int_hexagon_V6_vmpyih :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vmpyih">;
-
-def int_hexagon_V6_vmpyih_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vmpyih_128B">;
-
-def int_hexagon_V6_vtmpyb_acc :
-Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vtmpyb_acc">;
-
-def int_hexagon_V6_vtmpyb_acc_128B :
-Hexagon_v64i32_v64i32v64i32i32_Intrinsic<"HEXAGON_V6_vtmpyb_acc_128B">;
-
-def int_hexagon_V6_vrmpybus :
-Hexagon_v16i32_v16i32i32_Intrinsic<"HEXAGON_V6_vrmpybus">;
-
-def int_hexagon_V6_vrmpybus_128B :
-Hexagon_v32i32_v32i32i32_Intrinsic<"HEXAGON_V6_vrmpybus_128B">;
-
-def int_hexagon_V6_vmpybus_acc :
-Hexagon_v32i32_v32i32v16i32i32_Intrinsic<"HEXAGON_V6_vmpybus_acc">;
-
-def int_hexagon_V6_vmpybus_acc_128B :
-Hexagon_v64i32_v64i32v32i32i32_Intrinsic<"HEXAGON_V6_vmpybus_acc_128B">;
-
-def int_hexagon_V6_vgth_xor :
-Hexagon_v512i1_v512i1v16i32v16i32_Intrinsic<"HEXAGON_V6_vgth_xor">;
-
-def int_hexagon_V6_vgth_xor_128B :
-Hexagon_v1024i1_v1024i1v32i32v32i32_Intrinsic<"HEXAGON_V6_vgth_xor_128B">;
-
-def int_hexagon_V6_vsubhsat :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vsubhsat">;
-
-def int_hexagon_V6_vsubhsat_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vsubhsat_128B">;
-
-def int_hexagon_V6_vrmpyubi_acc :
-Hexagon_v32i32_v32i32v32i32i32i32_Intrinsic<"HEXAGON_V6_vrmpyubi_acc", [ImmArg<3>]>;
-
-def int_hexagon_V6_vrmpyubi_acc_128B :
-Hexagon_v64i32_v64i32v64i32i32i32_Intrinsic<"HEXAGON_V6_vrmpyubi_acc_128B", [ImmArg<3>]>;
-
-def int_hexagon_V6_vabsw :
-Hexagon_v16i32_v16i32_Intrinsic<"HEXAGON_V6_vabsw">;
-
-def int_hexagon_V6_vabsw_128B :
-Hexagon_v32i32_v32i32_Intrinsic<"HEXAGON_V6_vabsw_128B">;
-
-def int_hexagon_V6_vaddwsat_dv :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vaddwsat_dv">;
-
-def int_hexagon_V6_vaddwsat_dv_128B :
-Hexagon_v64i32_v64i32v64i32_Intrinsic<"HEXAGON_V6_vaddwsat_dv_128B">;
-
-def int_hexagon_V6_vlsrw :
-Hexagon_v16i32_v16i32i32_Intrinsic<"HEXAGON_V6_vlsrw">;
-
-def int_hexagon_V6_vlsrw_128B :
-Hexagon_v32i32_v32i32i32_Intrinsic<"HEXAGON_V6_vlsrw_128B">;
-
-def int_hexagon_V6_vabsh :
-Hexagon_v16i32_v16i32_Intrinsic<"HEXAGON_V6_vabsh">;
-
-def int_hexagon_V6_vabsh_128B :
-Hexagon_v32i32_v32i32_Intrinsic<"HEXAGON_V6_vabsh_128B">;
-
-def int_hexagon_V6_vlsrh :
-Hexagon_v16i32_v16i32i32_Intrinsic<"HEXAGON_V6_vlsrh">;
-
-def int_hexagon_V6_vlsrh_128B :
-Hexagon_v32i32_v32i32i32_Intrinsic<"HEXAGON_V6_vlsrh_128B">;
-
-def int_hexagon_V6_valignb :
-Hexagon_v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_valignb">;
-
-def int_hexagon_V6_valignb_128B :
-Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_valignb_128B">;
-
-def int_hexagon_V6_vsubhq :
-Hexagon_v16i32_v512i1v16i32v16i32_Intrinsic<"HEXAGON_V6_vsubhq">;
-
-def int_hexagon_V6_vsubhq_128B :
-Hexagon_v32i32_v1024i1v32i32v32i32_Intrinsic<"HEXAGON_V6_vsubhq_128B">;
-
-def int_hexagon_V6_vpackoh :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vpackoh">;
-
-def int_hexagon_V6_vpackoh_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vpackoh_128B">;
-
-def int_hexagon_V6_vdmpybus_acc :
-Hexagon_v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vdmpybus_acc">;
-
-def int_hexagon_V6_vdmpybus_acc_128B :
-Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vdmpybus_acc_128B">;
-
-def int_hexagon_V6_vdmpyhvsat_acc :
-Hexagon_v16i32_v16i32v16i32v16i32_Intrinsic<"HEXAGON_V6_vdmpyhvsat_acc">;
-
-def int_hexagon_V6_vdmpyhvsat_acc_128B :
-Hexagon_v32i32_v32i32v32i32v32i32_Intrinsic<"HEXAGON_V6_vdmpyhvsat_acc_128B">;
-
-def int_hexagon_V6_vrmpybv_acc :
-Hexagon_v16i32_v16i32v16i32v16i32_Intrinsic<"HEXAGON_V6_vrmpybv_acc">;
-
-def int_hexagon_V6_vrmpybv_acc_128B :
-Hexagon_v32i32_v32i32v32i32v32i32_Intrinsic<"HEXAGON_V6_vrmpybv_acc_128B">;
-
-def int_hexagon_V6_vaddhsat :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vaddhsat">;
-
-def int_hexagon_V6_vaddhsat_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vaddhsat_128B">;
-
-def int_hexagon_V6_vcombine :
-Hexagon_v32i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vcombine">;
-
-def int_hexagon_V6_vcombine_128B :
-Hexagon_v64i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vcombine_128B">;
-
-def int_hexagon_V6_vandqrt_acc :
-Hexagon_v16i32_v16i32v512i1i32_Intrinsic<"HEXAGON_V6_vandqrt_acc">;
-
-def int_hexagon_V6_vandqrt_acc_128B :
-Hexagon_v32i32_v32i32v1024i1i32_Intrinsic<"HEXAGON_V6_vandqrt_acc_128B">;
-
-def int_hexagon_V6_vaslhv :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vaslhv">;
-
-def int_hexagon_V6_vaslhv_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vaslhv_128B">;
-
-def int_hexagon_V6_vinsertwr :
-Hexagon_v16i32_v16i32i32_Intrinsic<"HEXAGON_V6_vinsertwr">;
-
-def int_hexagon_V6_vinsertwr_128B :
-Hexagon_v32i32_v32i32i32_Intrinsic<"HEXAGON_V6_vinsertwr_128B">;
-
-def int_hexagon_V6_vsubh_dv :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vsubh_dv">;
-
-def int_hexagon_V6_vsubh_dv_128B :
-Hexagon_v64i32_v64i32v64i32_Intrinsic<"HEXAGON_V6_vsubh_dv_128B">;
-
-def int_hexagon_V6_vshuffb :
-Hexagon_v16i32_v16i32_Intrinsic<"HEXAGON_V6_vshuffb">;
-
-def int_hexagon_V6_vshuffb_128B :
-Hexagon_v32i32_v32i32_Intrinsic<"HEXAGON_V6_vshuffb_128B">;
-
-def int_hexagon_V6_vand :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vand">;
-
-def int_hexagon_V6_vand_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vand_128B">;
-
-def int_hexagon_V6_vmpyhv :
-Hexagon_v32i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vmpyhv">;
-
-def int_hexagon_V6_vmpyhv_128B :
-Hexagon_v64i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vmpyhv_128B">;
-
-def int_hexagon_V6_vdmpyhsuisat_acc :
-Hexagon_v16i32_v16i32v32i32i32_Intrinsic<"HEXAGON_V6_vdmpyhsuisat_acc">;
-
-def int_hexagon_V6_vdmpyhsuisat_acc_128B :
-Hexagon_v32i32_v32i32v64i32i32_Intrinsic<"HEXAGON_V6_vdmpyhsuisat_acc_128B">;
-
-def int_hexagon_V6_vsububsat_dv :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vsububsat_dv">;
-
-def int_hexagon_V6_vsububsat_dv_128B :
-Hexagon_v64i32_v64i32v64i32_Intrinsic<"HEXAGON_V6_vsububsat_dv_128B">;
-
-def int_hexagon_V6_vgtb_xor :
-Hexagon_v512i1_v512i1v16i32v16i32_Intrinsic<"HEXAGON_V6_vgtb_xor">;
-
-def int_hexagon_V6_vgtb_xor_128B :
-Hexagon_v1024i1_v1024i1v32i32v32i32_Intrinsic<"HEXAGON_V6_vgtb_xor_128B">;
-
-def int_hexagon_V6_vdsaduh_acc :
-Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vdsaduh_acc">;
-
-def int_hexagon_V6_vdsaduh_acc_128B :
-Hexagon_v64i32_v64i32v64i32i32_Intrinsic<"HEXAGON_V6_vdsaduh_acc_128B">;
-
-def int_hexagon_V6_vrmpyub :
-Hexagon_v16i32_v16i32i32_Intrinsic<"HEXAGON_V6_vrmpyub">;
-
-def int_hexagon_V6_vrmpyub_128B :
-Hexagon_v32i32_v32i32i32_Intrinsic<"HEXAGON_V6_vrmpyub_128B">;
-
-def int_hexagon_V6_vmpyuh_acc :
-Hexagon_v32i32_v32i32v16i32i32_Intrinsic<"HEXAGON_V6_vmpyuh_acc">;
-
-def int_hexagon_V6_vmpyuh_acc_128B :
-Hexagon_v64i32_v64i32v32i32i32_Intrinsic<"HEXAGON_V6_vmpyuh_acc_128B">;
-
-def int_hexagon_V6_vcl0h :
-Hexagon_v16i32_v16i32_Intrinsic<"HEXAGON_V6_vcl0h">;
-
-def int_hexagon_V6_vcl0h_128B :
-Hexagon_v32i32_v32i32_Intrinsic<"HEXAGON_V6_vcl0h_128B">;
-
-def int_hexagon_V6_vmpyhus_acc :
-Hexagon_v32i32_v32i32v16i32v16i32_Intrinsic<"HEXAGON_V6_vmpyhus_acc">;
-
-def int_hexagon_V6_vmpyhus_acc_128B :
-Hexagon_v64i32_v64i32v32i32v32i32_Intrinsic<"HEXAGON_V6_vmpyhus_acc_128B">;
-
-def int_hexagon_V6_vmpybv_acc :
-Hexagon_v32i32_v32i32v16i32v16i32_Intrinsic<"HEXAGON_V6_vmpybv_acc">;
-
-def int_hexagon_V6_vmpybv_acc_128B :
-Hexagon_v64i32_v64i32v32i32v32i32_Intrinsic<"HEXAGON_V6_vmpybv_acc_128B">;
-
-def int_hexagon_V6_vrsadubi :
-Hexagon_v32i32_v32i32i32i32_Intrinsic<"HEXAGON_V6_vrsadubi", [ImmArg<2>]>;
-
-def int_hexagon_V6_vrsadubi_128B :
-Hexagon_v64i32_v64i32i32i32_Intrinsic<"HEXAGON_V6_vrsadubi_128B", [ImmArg<2>]>;
-
-def int_hexagon_V6_vdmpyhb_dv_acc :
-Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vdmpyhb_dv_acc">;
-
-def int_hexagon_V6_vdmpyhb_dv_acc_128B :
-Hexagon_v64i32_v64i32v64i32i32_Intrinsic<"HEXAGON_V6_vdmpyhb_dv_acc_128B">;
-
-def int_hexagon_V6_vshufeh :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vshufeh">;
-
-def int_hexagon_V6_vshufeh_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vshufeh_128B">;
-
-def int_hexagon_V6_vmpyewuh :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vmpyewuh">;
-
-def int_hexagon_V6_vmpyewuh_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vmpyewuh_128B">;
-
-def int_hexagon_V6_vmpyhsrs :
-Hexagon_v16i32_v16i32i32_Intrinsic<"HEXAGON_V6_vmpyhsrs">;
-
-def int_hexagon_V6_vmpyhsrs_128B :
-Hexagon_v32i32_v32i32i32_Intrinsic<"HEXAGON_V6_vmpyhsrs_128B">;
-
-def int_hexagon_V6_vdmpybus_dv_acc :
-Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vdmpybus_dv_acc">;
-
-def int_hexagon_V6_vdmpybus_dv_acc_128B :
-Hexagon_v64i32_v64i32v64i32i32_Intrinsic<"HEXAGON_V6_vdmpybus_dv_acc_128B">;
-
-def int_hexagon_V6_vaddubh :
-Hexagon_v32i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vaddubh">;
-
-def int_hexagon_V6_vaddubh_128B :
-Hexagon_v64i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vaddubh_128B">;
-
-def int_hexagon_V6_vasrwh :
-Hexagon_v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vasrwh">;
-
-def int_hexagon_V6_vasrwh_128B :
-Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vasrwh_128B">;
-
-def int_hexagon_V6_ld0 :
-Hexagon_v16i32_i32_Intrinsic<"HEXAGON_V6_ld0">;
-
-def int_hexagon_V6_ld0_128B :
-Hexagon_v32i32_i32_Intrinsic<"HEXAGON_V6_ld0_128B">;
-
-def int_hexagon_V6_vpopcounth :
-Hexagon_v16i32_v16i32_Intrinsic<"HEXAGON_V6_vpopcounth">;
-
-def int_hexagon_V6_vpopcounth_128B :
-Hexagon_v32i32_v32i32_Intrinsic<"HEXAGON_V6_vpopcounth_128B">;
-
-def int_hexagon_V6_ldnt0 :
-Hexagon_v16i32_i32_Intrinsic<"HEXAGON_V6_ldnt0">;
-
-def int_hexagon_V6_ldnt0_128B :
-Hexagon_v32i32_i32_Intrinsic<"HEXAGON_V6_ldnt0_128B">;
-
-def int_hexagon_V6_vgth_and :
-Hexagon_v512i1_v512i1v16i32v16i32_Intrinsic<"HEXAGON_V6_vgth_and">;
-
-def int_hexagon_V6_vgth_and_128B :
-Hexagon_v1024i1_v1024i1v32i32v32i32_Intrinsic<"HEXAGON_V6_vgth_and_128B">;
-
-def int_hexagon_V6_vaddubsat_dv :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vaddubsat_dv">;
-
-def int_hexagon_V6_vaddubsat_dv_128B :
-Hexagon_v64i32_v64i32v64i32_Intrinsic<"HEXAGON_V6_vaddubsat_dv_128B">;
-
-def int_hexagon_V6_vpackeh :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vpackeh">;
-
-def int_hexagon_V6_vpackeh_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vpackeh_128B">;
-
-def int_hexagon_V6_vmpyh :
-Hexagon_v32i32_v16i32i32_Intrinsic<"HEXAGON_V6_vmpyh">;
-
-def int_hexagon_V6_vmpyh_128B :
-Hexagon_v64i32_v32i32i32_Intrinsic<"HEXAGON_V6_vmpyh_128B">;
-
-def int_hexagon_V6_vminh :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vminh">;
-
-def int_hexagon_V6_vminh_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vminh_128B">;
-
-def int_hexagon_V6_pred_scalar2 :
-Hexagon_v512i1_i32_Intrinsic<"HEXAGON_V6_pred_scalar2">;
-
-def int_hexagon_V6_pred_scalar2_128B :
-Hexagon_v1024i1_i32_Intrinsic<"HEXAGON_V6_pred_scalar2_128B">;
-
-def int_hexagon_V6_vdealh :
-Hexagon_v16i32_v16i32_Intrinsic<"HEXAGON_V6_vdealh">;
-
-def int_hexagon_V6_vdealh_128B :
-Hexagon_v32i32_v32i32_Intrinsic<"HEXAGON_V6_vdealh_128B">;
-
-def int_hexagon_V6_vpackwh_sat :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vpackwh_sat">;
-
-def int_hexagon_V6_vpackwh_sat_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vpackwh_sat_128B">;
-
-def int_hexagon_V6_vaslh :
-Hexagon_v16i32_v16i32i32_Intrinsic<"HEXAGON_V6_vaslh">;
-
-def int_hexagon_V6_vaslh_128B :
-Hexagon_v32i32_v32i32i32_Intrinsic<"HEXAGON_V6_vaslh_128B">;
-
-def int_hexagon_V6_vgtuw_and :
-Hexagon_v512i1_v512i1v16i32v16i32_Intrinsic<"HEXAGON_V6_vgtuw_and">;
-
-def int_hexagon_V6_vgtuw_and_128B :
-Hexagon_v1024i1_v1024i1v32i32v32i32_Intrinsic<"HEXAGON_V6_vgtuw_and_128B">;
-
-def int_hexagon_V6_vor :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vor">;
-
-def int_hexagon_V6_vor_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vor_128B">;
-
-def int_hexagon_V6_vlutvvb :
-Hexagon_v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vlutvvb">;
-
-def int_hexagon_V6_vlutvvb_128B :
-Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vlutvvb_128B">;
-
-def int_hexagon_V6_vmpyiowh :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vmpyiowh">;
-
-def int_hexagon_V6_vmpyiowh_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vmpyiowh_128B">;
-
-def int_hexagon_V6_vlutvvb_oracc :
-Hexagon_v16i32_v16i32v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vlutvvb_oracc">;
-
-def int_hexagon_V6_vlutvvb_oracc_128B :
-Hexagon_v32i32_v32i32v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vlutvvb_oracc_128B">;
-
-def int_hexagon_V6_vandvrt :
-Hexagon_v512i1_v16i32i32_Intrinsic<"HEXAGON_V6_vandvrt">;
-
-def int_hexagon_V6_vandvrt_128B :
-Hexagon_v1024i1_v32i32i32_Intrinsic<"HEXAGON_V6_vandvrt_128B">;
-
-def int_hexagon_V6_veqh_xor :
-Hexagon_v512i1_v512i1v16i32v16i32_Intrinsic<"HEXAGON_V6_veqh_xor">;
-
-def int_hexagon_V6_veqh_xor_128B :
-Hexagon_v1024i1_v1024i1v32i32v32i32_Intrinsic<"HEXAGON_V6_veqh_xor_128B">;
-
-def int_hexagon_V6_vadduhw :
-Hexagon_v32i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vadduhw">;
-
-def int_hexagon_V6_vadduhw_128B :
-Hexagon_v64i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vadduhw_128B">;
-
-def int_hexagon_V6_vcl0w :
-Hexagon_v16i32_v16i32_Intrinsic<"HEXAGON_V6_vcl0w">;
-
-def int_hexagon_V6_vcl0w_128B :
-Hexagon_v32i32_v32i32_Intrinsic<"HEXAGON_V6_vcl0w_128B">;
-
-def int_hexagon_V6_vmpyihb :
-Hexagon_v16i32_v16i32i32_Intrinsic<"HEXAGON_V6_vmpyihb">;
-
-def int_hexagon_V6_vmpyihb_128B :
-Hexagon_v32i32_v32i32i32_Intrinsic<"HEXAGON_V6_vmpyihb_128B">;
-
-def int_hexagon_V6_vtmpybus :
-Hexagon_v32i32_v32i32i32_Intrinsic<"HEXAGON_V6_vtmpybus">;
-
-def int_hexagon_V6_vtmpybus_128B :
-Hexagon_v64i32_v64i32i32_Intrinsic<"HEXAGON_V6_vtmpybus_128B">;
-
-def int_hexagon_V6_vd0 :
-Hexagon_v16i32__Intrinsic<"HEXAGON_V6_vd0">;
-
-def int_hexagon_V6_vd0_128B :
-Hexagon_v32i32__Intrinsic<"HEXAGON_V6_vd0_128B">;
-
-def int_hexagon_V6_veqh_or :
-Hexagon_v512i1_v512i1v16i32v16i32_Intrinsic<"HEXAGON_V6_veqh_or">;
-
-def int_hexagon_V6_veqh_or_128B :
-Hexagon_v1024i1_v1024i1v32i32v32i32_Intrinsic<"HEXAGON_V6_veqh_or_128B">;
-
-def int_hexagon_V6_vgtw_or :
-Hexagon_v512i1_v512i1v16i32v16i32_Intrinsic<"HEXAGON_V6_vgtw_or">;
-
-def int_hexagon_V6_vgtw_or_128B :
-Hexagon_v1024i1_v1024i1v32i32v32i32_Intrinsic<"HEXAGON_V6_vgtw_or_128B">;
-
-def int_hexagon_V6_vdmpybus :
-Hexagon_v16i32_v16i32i32_Intrinsic<"HEXAGON_V6_vdmpybus">;
-
-def int_hexagon_V6_vdmpybus_128B :
-Hexagon_v32i32_v32i32i32_Intrinsic<"HEXAGON_V6_vdmpybus_128B">;
-
-def int_hexagon_V6_vgtub_or :
-Hexagon_v512i1_v512i1v16i32v16i32_Intrinsic<"HEXAGON_V6_vgtub_or">;
-
-def int_hexagon_V6_vgtub_or_128B :
-Hexagon_v1024i1_v1024i1v32i32v32i32_Intrinsic<"HEXAGON_V6_vgtub_or_128B">;
-
-def int_hexagon_V6_vmpybus :
-Hexagon_v32i32_v16i32i32_Intrinsic<"HEXAGON_V6_vmpybus">;
-
-def int_hexagon_V6_vmpybus_128B :
-Hexagon_v64i32_v32i32i32_Intrinsic<"HEXAGON_V6_vmpybus_128B">;
-
-def int_hexagon_V6_vdmpyhb_acc :
-Hexagon_v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vdmpyhb_acc">;
-
-def int_hexagon_V6_vdmpyhb_acc_128B :
-Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vdmpyhb_acc_128B">;
-
-def int_hexagon_V6_vandvrt_acc :
-Hexagon_v512i1_v512i1v16i32i32_Intrinsic<"HEXAGON_V6_vandvrt_acc">;
-
-def int_hexagon_V6_vandvrt_acc_128B :
-Hexagon_v1024i1_v1024i1v32i32i32_Intrinsic<"HEXAGON_V6_vandvrt_acc_128B">;
-
-def int_hexagon_V6_vassign :
-Hexagon_v16i32_v16i32_Intrinsic<"HEXAGON_V6_vassign">;
-
-def int_hexagon_V6_vassign_128B :
-Hexagon_v32i32_v32i32_Intrinsic<"HEXAGON_V6_vassign_128B">;
-
-def int_hexagon_V6_vaddwnq :
-Hexagon_v16i32_v512i1v16i32v16i32_Intrinsic<"HEXAGON_V6_vaddwnq">;
-
-def int_hexagon_V6_vaddwnq_128B :
-Hexagon_v32i32_v1024i1v32i32v32i32_Intrinsic<"HEXAGON_V6_vaddwnq_128B">;
-
-def int_hexagon_V6_vgtub_and :
-Hexagon_v512i1_v512i1v16i32v16i32_Intrinsic<"HEXAGON_V6_vgtub_and">;
-
-def int_hexagon_V6_vgtub_and_128B :
-Hexagon_v1024i1_v1024i1v32i32v32i32_Intrinsic<"HEXAGON_V6_vgtub_and_128B">;
-
-def int_hexagon_V6_vdmpyhb_dv :
-Hexagon_v32i32_v32i32i32_Intrinsic<"HEXAGON_V6_vdmpyhb_dv">;
-
-def int_hexagon_V6_vdmpyhb_dv_128B :
-Hexagon_v64i32_v64i32i32_Intrinsic<"HEXAGON_V6_vdmpyhb_dv_128B">;
-
-def int_hexagon_V6_vunpackb :
-Hexagon_v32i32_v16i32_Intrinsic<"HEXAGON_V6_vunpackb">;
-
-def int_hexagon_V6_vunpackb_128B :
-Hexagon_v64i32_v32i32_Intrinsic<"HEXAGON_V6_vunpackb_128B">;
-
-def int_hexagon_V6_vunpackh :
-Hexagon_v32i32_v16i32_Intrinsic<"HEXAGON_V6_vunpackh">;
-
-def int_hexagon_V6_vunpackh_128B :
-Hexagon_v64i32_v32i32_Intrinsic<"HEXAGON_V6_vunpackh_128B">;
-
-def int_hexagon_V6_vmpahb_acc :
-Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vmpahb_acc">;
-
-def int_hexagon_V6_vmpahb_acc_128B :
-Hexagon_v64i32_v64i32v64i32i32_Intrinsic<"HEXAGON_V6_vmpahb_acc_128B">;
-
-def int_hexagon_V6_vaddbnq :
-Hexagon_v16i32_v512i1v16i32v16i32_Intrinsic<"HEXAGON_V6_vaddbnq">;
-
-def int_hexagon_V6_vaddbnq_128B :
-Hexagon_v32i32_v1024i1v32i32v32i32_Intrinsic<"HEXAGON_V6_vaddbnq_128B">;
-
-def int_hexagon_V6_vlalignbi :
-Hexagon_v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vlalignbi", [ImmArg<2>]>;
-
-def int_hexagon_V6_vlalignbi_128B :
-Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vlalignbi_128B", [ImmArg<2>]>;
-
-def int_hexagon_V6_vsatwh :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vsatwh">;
-
-def int_hexagon_V6_vsatwh_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vsatwh_128B">;
-
-def int_hexagon_V6_vgtuh :
-Hexagon_v512i1_v16i32v16i32_Intrinsic<"HEXAGON_V6_vgtuh">;
-
-def int_hexagon_V6_vgtuh_128B :
-Hexagon_v1024i1_v32i32v32i32_Intrinsic<"HEXAGON_V6_vgtuh_128B">;
-
-def int_hexagon_V6_vmpyihb_acc :
-Hexagon_v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vmpyihb_acc">;
-
-def int_hexagon_V6_vmpyihb_acc_128B :
-Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vmpyihb_acc_128B">;
-
-def int_hexagon_V6_vrmpybusv_acc :
-Hexagon_v16i32_v16i32v16i32v16i32_Intrinsic<"HEXAGON_V6_vrmpybusv_acc">;
-
-def int_hexagon_V6_vrmpybusv_acc_128B :
-Hexagon_v32i32_v32i32v32i32v32i32_Intrinsic<"HEXAGON_V6_vrmpybusv_acc_128B">;
-
-def int_hexagon_V6_vrdelta :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vrdelta">;
-
-def int_hexagon_V6_vrdelta_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vrdelta_128B">;
-
-def int_hexagon_V6_vroundwh :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vroundwh">;
-
-def int_hexagon_V6_vroundwh_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vroundwh_128B">;
-
-def int_hexagon_V6_vaddw_dv :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vaddw_dv">;
-
-def int_hexagon_V6_vaddw_dv_128B :
-Hexagon_v64i32_v64i32v64i32_Intrinsic<"HEXAGON_V6_vaddw_dv_128B">;
-
-def int_hexagon_V6_vmpyiwb_acc :
-Hexagon_v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vmpyiwb_acc">;
-
-def int_hexagon_V6_vmpyiwb_acc_128B :
-Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vmpyiwb_acc_128B">;
-
-def int_hexagon_V6_vsubbq :
-Hexagon_v16i32_v512i1v16i32v16i32_Intrinsic<"HEXAGON_V6_vsubbq">;
-
-def int_hexagon_V6_vsubbq_128B :
-Hexagon_v32i32_v1024i1v32i32v32i32_Intrinsic<"HEXAGON_V6_vsubbq_128B">;
-
-def int_hexagon_V6_veqh_and :
-Hexagon_v512i1_v512i1v16i32v16i32_Intrinsic<"HEXAGON_V6_veqh_and">;
-
-def int_hexagon_V6_veqh_and_128B :
-Hexagon_v1024i1_v1024i1v32i32v32i32_Intrinsic<"HEXAGON_V6_veqh_and_128B">;
-
-def int_hexagon_V6_valignbi :
-Hexagon_v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_valignbi", [ImmArg<2>]>;
-
-def int_hexagon_V6_valignbi_128B :
-Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_valignbi_128B", [ImmArg<2>]>;
-
-def int_hexagon_V6_vaddwsat :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vaddwsat">;
-
-def int_hexagon_V6_vaddwsat_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vaddwsat_128B">;
-
-def int_hexagon_V6_veqw_and :
-Hexagon_v512i1_v512i1v16i32v16i32_Intrinsic<"HEXAGON_V6_veqw_and">;
-
-def int_hexagon_V6_veqw_and_128B :
-Hexagon_v1024i1_v1024i1v32i32v32i32_Intrinsic<"HEXAGON_V6_veqw_and_128B">;
-
-def int_hexagon_V6_vabsdiffub :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vabsdiffub">;
-
-def int_hexagon_V6_vabsdiffub_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vabsdiffub_128B">;
-
-def int_hexagon_V6_vshuffeb :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vshuffeb">;
-
-def int_hexagon_V6_vshuffeb_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vshuffeb_128B">;
-
-def int_hexagon_V6_vabsdiffuh :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vabsdiffuh">;
-
-def int_hexagon_V6_vabsdiffuh_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vabsdiffuh_128B">;
-
-def int_hexagon_V6_veqw_xor :
-Hexagon_v512i1_v512i1v16i32v16i32_Intrinsic<"HEXAGON_V6_veqw_xor">;
-
-def int_hexagon_V6_veqw_xor_128B :
-Hexagon_v1024i1_v1024i1v32i32v32i32_Intrinsic<"HEXAGON_V6_veqw_xor_128B">;
-
-def int_hexagon_V6_vgth :
-Hexagon_v512i1_v16i32v16i32_Intrinsic<"HEXAGON_V6_vgth">;
-
-def int_hexagon_V6_vgth_128B :
-Hexagon_v1024i1_v32i32v32i32_Intrinsic<"HEXAGON_V6_vgth_128B">;
-
-def int_hexagon_V6_vgtuw_xor :
-Hexagon_v512i1_v512i1v16i32v16i32_Intrinsic<"HEXAGON_V6_vgtuw_xor">;
-
-def int_hexagon_V6_vgtuw_xor_128B :
-Hexagon_v1024i1_v1024i1v32i32v32i32_Intrinsic<"HEXAGON_V6_vgtuw_xor_128B">;
-
-def int_hexagon_V6_vgtb :
-Hexagon_v512i1_v16i32v16i32_Intrinsic<"HEXAGON_V6_vgtb">;
-
-def int_hexagon_V6_vgtb_128B :
-Hexagon_v1024i1_v32i32v32i32_Intrinsic<"HEXAGON_V6_vgtb_128B">;
-
-def int_hexagon_V6_vgtw :
-Hexagon_v512i1_v16i32v16i32_Intrinsic<"HEXAGON_V6_vgtw">;
-
-def int_hexagon_V6_vgtw_128B :
-Hexagon_v1024i1_v32i32v32i32_Intrinsic<"HEXAGON_V6_vgtw_128B">;
-
-def int_hexagon_V6_vsubwq :
-Hexagon_v16i32_v512i1v16i32v16i32_Intrinsic<"HEXAGON_V6_vsubwq">;
-
-def int_hexagon_V6_vsubwq_128B :
-Hexagon_v32i32_v1024i1v32i32v32i32_Intrinsic<"HEXAGON_V6_vsubwq_128B">;
-
-def int_hexagon_V6_vnot :
-Hexagon_v16i32_v16i32_Intrinsic<"HEXAGON_V6_vnot">;
-
-def int_hexagon_V6_vnot_128B :
-Hexagon_v32i32_v32i32_Intrinsic<"HEXAGON_V6_vnot_128B">;
-
-def int_hexagon_V6_vgtb_or :
-Hexagon_v512i1_v512i1v16i32v16i32_Intrinsic<"HEXAGON_V6_vgtb_or">;
-
-def int_hexagon_V6_vgtb_or_128B :
-Hexagon_v1024i1_v1024i1v32i32v32i32_Intrinsic<"HEXAGON_V6_vgtb_or_128B">;
-
-def int_hexagon_V6_vgtuw_or :
-Hexagon_v512i1_v512i1v16i32v16i32_Intrinsic<"HEXAGON_V6_vgtuw_or">;
-
-def int_hexagon_V6_vgtuw_or_128B :
-Hexagon_v1024i1_v1024i1v32i32v32i32_Intrinsic<"HEXAGON_V6_vgtuw_or_128B">;
-
-def int_hexagon_V6_vaddubsat :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vaddubsat">;
-
-def int_hexagon_V6_vaddubsat_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vaddubsat_128B">;
-
-def int_hexagon_V6_vmaxw :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vmaxw">;
-
-def int_hexagon_V6_vmaxw_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vmaxw_128B">;
-
-def int_hexagon_V6_vaslwv :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vaslwv">;
-
-def int_hexagon_V6_vaslwv_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vaslwv_128B">;
-
-def int_hexagon_V6_vabsw_sat :
-Hexagon_v16i32_v16i32_Intrinsic<"HEXAGON_V6_vabsw_sat">;
-
-def int_hexagon_V6_vabsw_sat_128B :
-Hexagon_v32i32_v32i32_Intrinsic<"HEXAGON_V6_vabsw_sat_128B">;
-
-def int_hexagon_V6_vsubwsat_dv :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vsubwsat_dv">;
-
-def int_hexagon_V6_vsubwsat_dv_128B :
-Hexagon_v64i32_v64i32v64i32_Intrinsic<"HEXAGON_V6_vsubwsat_dv_128B">;
-
-def int_hexagon_V6_vroundhub :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vroundhub">;
-
-def int_hexagon_V6_vroundhub_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vroundhub_128B">;
-
-def int_hexagon_V6_vdmpyhisat_acc :
-Hexagon_v16i32_v16i32v32i32i32_Intrinsic<"HEXAGON_V6_vdmpyhisat_acc">;
-
-def int_hexagon_V6_vdmpyhisat_acc_128B :
-Hexagon_v32i32_v32i32v64i32i32_Intrinsic<"HEXAGON_V6_vdmpyhisat_acc_128B">;
-
-def int_hexagon_V6_vmpabus :
-Hexagon_v32i32_v32i32i32_Intrinsic<"HEXAGON_V6_vmpabus">;
-
-def int_hexagon_V6_vmpabus_128B :
-Hexagon_v64i32_v64i32i32_Intrinsic<"HEXAGON_V6_vmpabus_128B">;
-
-def int_hexagon_V6_vassignp :
-Hexagon_v32i32_v32i32_Intrinsic<"HEXAGON_V6_vassignp">;
-
-def int_hexagon_V6_vassignp_128B :
-Hexagon_v64i32_v64i32_Intrinsic<"HEXAGON_V6_vassignp_128B">;
-
-def int_hexagon_V6_veqb :
-Hexagon_v512i1_v16i32v16i32_Intrinsic<"HEXAGON_V6_veqb">;
-
-def int_hexagon_V6_veqb_128B :
-Hexagon_v1024i1_v32i32v32i32_Intrinsic<"HEXAGON_V6_veqb_128B">;
-
-def int_hexagon_V6_vsububh :
-Hexagon_v32i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vsububh">;
-
-def int_hexagon_V6_vsububh_128B :
-Hexagon_v64i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vsububh_128B">;
-
-def int_hexagon_V6_lvsplatw :
-Hexagon_v16i32_i32_Intrinsic<"HEXAGON_V6_lvsplatw">;
-
-def int_hexagon_V6_lvsplatw_128B :
-Hexagon_v32i32_i32_Intrinsic<"HEXAGON_V6_lvsplatw_128B">;
-
-def int_hexagon_V6_vaddhnq :
-Hexagon_v16i32_v512i1v16i32v16i32_Intrinsic<"HEXAGON_V6_vaddhnq">;
-
-def int_hexagon_V6_vaddhnq_128B :
-Hexagon_v32i32_v1024i1v32i32v32i32_Intrinsic<"HEXAGON_V6_vaddhnq_128B">;
-
-def int_hexagon_V6_vdmpyhsusat :
-Hexagon_v16i32_v16i32i32_Intrinsic<"HEXAGON_V6_vdmpyhsusat">;
-
-def int_hexagon_V6_vdmpyhsusat_128B :
-Hexagon_v32i32_v32i32i32_Intrinsic<"HEXAGON_V6_vdmpyhsusat_128B">;
-
-def int_hexagon_V6_pred_not :
-Hexagon_v512i1_v512i1_Intrinsic<"HEXAGON_V6_pred_not">;
-
-def int_hexagon_V6_pred_not_128B :
-Hexagon_v1024i1_v1024i1_Intrinsic<"HEXAGON_V6_pred_not_128B">;
-
-def int_hexagon_V6_vlutvwh_oracc :
-Hexagon_v32i32_v32i32v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vlutvwh_oracc">;
-
-def int_hexagon_V6_vlutvwh_oracc_128B :
-Hexagon_v64i32_v64i32v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vlutvwh_oracc_128B">;
-
-def int_hexagon_V6_vmpyiewh_acc :
-Hexagon_v16i32_v16i32v16i32v16i32_Intrinsic<"HEXAGON_V6_vmpyiewh_acc">;
-
-def int_hexagon_V6_vmpyiewh_acc_128B :
-Hexagon_v32i32_v32i32v32i32v32i32_Intrinsic<"HEXAGON_V6_vmpyiewh_acc_128B">;
-
-def int_hexagon_V6_vdealvdd :
-Hexagon_v32i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vdealvdd">;
-
-def int_hexagon_V6_vdealvdd_128B :
-Hexagon_v64i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vdealvdd_128B">;
-
-def int_hexagon_V6_vavgw :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vavgw">;
-
-def int_hexagon_V6_vavgw_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vavgw_128B">;
-
-def int_hexagon_V6_vdmpyhsusat_acc :
-Hexagon_v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vdmpyhsusat_acc">;
-
-def int_hexagon_V6_vdmpyhsusat_acc_128B :
-Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vdmpyhsusat_acc_128B">;
-
-def int_hexagon_V6_vgtw_xor :
-Hexagon_v512i1_v512i1v16i32v16i32_Intrinsic<"HEXAGON_V6_vgtw_xor">;
-
-def int_hexagon_V6_vgtw_xor_128B :
-Hexagon_v1024i1_v1024i1v32i32v32i32_Intrinsic<"HEXAGON_V6_vgtw_xor_128B">;
-
-def int_hexagon_V6_vtmpyhb_acc :
-Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vtmpyhb_acc">;
-
-def int_hexagon_V6_vtmpyhb_acc_128B :
-Hexagon_v64i32_v64i32v64i32i32_Intrinsic<"HEXAGON_V6_vtmpyhb_acc_128B">;
-
-def int_hexagon_V6_vaddhw :
-Hexagon_v32i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vaddhw">;
-
-def int_hexagon_V6_vaddhw_128B :
-Hexagon_v64i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vaddhw_128B">;
-
-def int_hexagon_V6_vaddhq :
-Hexagon_v16i32_v512i1v16i32v16i32_Intrinsic<"HEXAGON_V6_vaddhq">;
-
-def int_hexagon_V6_vaddhq_128B :
-Hexagon_v32i32_v1024i1v32i32v32i32_Intrinsic<"HEXAGON_V6_vaddhq_128B">;
-
-def int_hexagon_V6_vrmpyubv :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vrmpyubv">;
-
-def int_hexagon_V6_vrmpyubv_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vrmpyubv_128B">;
-
-def int_hexagon_V6_vsubh :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vsubh">;
-
-def int_hexagon_V6_vsubh_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vsubh_128B">;
-
-def int_hexagon_V6_vrmpyubi :
-Hexagon_v32i32_v32i32i32i32_Intrinsic<"HEXAGON_V6_vrmpyubi", [ImmArg<2>]>;
-
-def int_hexagon_V6_vrmpyubi_128B :
-Hexagon_v64i32_v64i32i32i32_Intrinsic<"HEXAGON_V6_vrmpyubi_128B", [ImmArg<2>]>;
-
-def int_hexagon_V6_vminw :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vminw">;
-
-def int_hexagon_V6_vminw_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vminw_128B">;
-
-def int_hexagon_V6_vmpyubv_acc :
-Hexagon_v32i32_v32i32v16i32v16i32_Intrinsic<"HEXAGON_V6_vmpyubv_acc">;
-
-def int_hexagon_V6_vmpyubv_acc_128B :
-Hexagon_v64i32_v64i32v32i32v32i32_Intrinsic<"HEXAGON_V6_vmpyubv_acc_128B">;
-
-def int_hexagon_V6_pred_xor :
-Hexagon_v512i1_v512i1v512i1_Intrinsic<"HEXAGON_V6_pred_xor">;
-
-def int_hexagon_V6_pred_xor_128B :
-Hexagon_v1024i1_v1024i1v1024i1_Intrinsic<"HEXAGON_V6_pred_xor_128B">;
-
-def int_hexagon_V6_veqb_xor :
-Hexagon_v512i1_v512i1v16i32v16i32_Intrinsic<"HEXAGON_V6_veqb_xor">;
-
-def int_hexagon_V6_veqb_xor_128B :
-Hexagon_v1024i1_v1024i1v32i32v32i32_Intrinsic<"HEXAGON_V6_veqb_xor_128B">;
-
-def int_hexagon_V6_vmpyiewuh :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vmpyiewuh">;
-
-def int_hexagon_V6_vmpyiewuh_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vmpyiewuh_128B">;
-
-def int_hexagon_V6_vmpybusv_acc :
-Hexagon_v32i32_v32i32v16i32v16i32_Intrinsic<"HEXAGON_V6_vmpybusv_acc">;
-
-def int_hexagon_V6_vmpybusv_acc_128B :
-Hexagon_v64i32_v64i32v32i32v32i32_Intrinsic<"HEXAGON_V6_vmpybusv_acc_128B">;
-
-def int_hexagon_V6_vavguhrnd :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vavguhrnd">;
-
-def int_hexagon_V6_vavguhrnd_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vavguhrnd_128B">;
-
-def int_hexagon_V6_vmpyowh_rnd :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vmpyowh_rnd">;
-
-def int_hexagon_V6_vmpyowh_rnd_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vmpyowh_rnd_128B">;
-
-def int_hexagon_V6_vsubwsat :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vsubwsat">;
-
-def int_hexagon_V6_vsubwsat_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vsubwsat_128B">;
-
-def int_hexagon_V6_vsubuhw :
-Hexagon_v32i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vsubuhw">;
-
-def int_hexagon_V6_vsubuhw_128B :
-Hexagon_v64i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vsubuhw_128B">;
-
-def int_hexagon_V6_vrmpybusi_acc :
-Hexagon_v32i32_v32i32v32i32i32i32_Intrinsic<"HEXAGON_V6_vrmpybusi_acc", [ImmArg<3>]>;
-
-def int_hexagon_V6_vrmpybusi_acc_128B :
-Hexagon_v64i32_v64i32v64i32i32i32_Intrinsic<"HEXAGON_V6_vrmpybusi_acc_128B", [ImmArg<3>]>;
-
-def int_hexagon_V6_vasrw :
-Hexagon_v16i32_v16i32i32_Intrinsic<"HEXAGON_V6_vasrw">;
-
-def int_hexagon_V6_vasrw_128B :
-Hexagon_v32i32_v32i32i32_Intrinsic<"HEXAGON_V6_vasrw_128B">;
-
-def int_hexagon_V6_vasrh :
-Hexagon_v16i32_v16i32i32_Intrinsic<"HEXAGON_V6_vasrh">;
-
-def int_hexagon_V6_vasrh_128B :
-Hexagon_v32i32_v32i32i32_Intrinsic<"HEXAGON_V6_vasrh_128B">;
-
-def int_hexagon_V6_vmpyuhv :
-Hexagon_v32i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vmpyuhv">;
-
-def int_hexagon_V6_vmpyuhv_128B :
-Hexagon_v64i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vmpyuhv_128B">;
-
-def int_hexagon_V6_vasrhbrndsat :
-Hexagon_v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vasrhbrndsat">;
-
-def int_hexagon_V6_vasrhbrndsat_128B :
-Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vasrhbrndsat_128B">;
-
-def int_hexagon_V6_vsubuhsat_dv :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vsubuhsat_dv">;
-
-def int_hexagon_V6_vsubuhsat_dv_128B :
-Hexagon_v64i32_v64i32v64i32_Intrinsic<"HEXAGON_V6_vsubuhsat_dv_128B">;
-
-def int_hexagon_V6_vabsdiffw :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vabsdiffw">;
-
-def int_hexagon_V6_vabsdiffw_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vabsdiffw_128B">;
-
-// V62 HVX Instructions.
-
-def int_hexagon_V6_vandnqrt_acc :
-Hexagon_v16i32_v16i32v512i1i32_Intrinsic<"HEXAGON_V6_vandnqrt_acc">;
-
-def int_hexagon_V6_vandnqrt_acc_128B :
-Hexagon_v32i32_v32i32v1024i1i32_Intrinsic<"HEXAGON_V6_vandnqrt_acc_128B">;
-
-def int_hexagon_V6_vaddclbh :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vaddclbh">;
-
-def int_hexagon_V6_vaddclbh_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vaddclbh_128B">;
-
-def int_hexagon_V6_vmpyowh_64_acc :
-Hexagon_v32i32_v32i32v16i32v16i32_Intrinsic<"HEXAGON_V6_vmpyowh_64_acc">;
-
-def int_hexagon_V6_vmpyowh_64_acc_128B :
-Hexagon_v64i32_v64i32v32i32v32i32_Intrinsic<"HEXAGON_V6_vmpyowh_64_acc_128B">;
-
-def int_hexagon_V6_vmpyewuh_64 :
-Hexagon_v32i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vmpyewuh_64">;
-
-def int_hexagon_V6_vmpyewuh_64_128B :
-Hexagon_v64i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vmpyewuh_64_128B">;
-
-def int_hexagon_V6_vsatuwuh :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vsatuwuh">;
-
-def int_hexagon_V6_vsatuwuh_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vsatuwuh_128B">;
-
-def int_hexagon_V6_shuffeqh :
-Hexagon_v512i1_v512i1v512i1_Intrinsic<"HEXAGON_V6_shuffeqh">;
-
-def int_hexagon_V6_shuffeqh_128B :
-Hexagon_v1024i1_v1024i1v1024i1_Intrinsic<"HEXAGON_V6_shuffeqh_128B">;
-
-def int_hexagon_V6_shuffeqw :
-Hexagon_v512i1_v512i1v512i1_Intrinsic<"HEXAGON_V6_shuffeqw">;
-
-def int_hexagon_V6_shuffeqw_128B :
-Hexagon_v1024i1_v1024i1v1024i1_Intrinsic<"HEXAGON_V6_shuffeqw_128B">;
-
-def int_hexagon_V6_ldcnpnt0 :
-Hexagon_v16i32_i32i32_Intrinsic<"HEXAGON_V6_ldcnpnt0">;
-
-def int_hexagon_V6_ldcnpnt0_128B :
-Hexagon_v32i32_i32i32_Intrinsic<"HEXAGON_V6_ldcnpnt0_128B">;
-
-def int_hexagon_V6_vsubcarry :
-Hexagon_custom_v16i32v512i1_v16i32v16i32v512i1_Intrinsic;
-
-def int_hexagon_V6_vsubcarry_128B :
-Hexagon_custom_v32i32v1024i1_v32i32v32i32v1024i1_Intrinsic_128B;
-
-def int_hexagon_V6_vasrhbsat :
-Hexagon_v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vasrhbsat">;
-
-def int_hexagon_V6_vasrhbsat_128B :
-Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vasrhbsat_128B">;
-
-def int_hexagon_V6_vminb :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vminb">;
-
-def int_hexagon_V6_vminb_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vminb_128B">;
-
-def int_hexagon_V6_vmpauhb_acc :
-Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vmpauhb_acc">;
-
-def int_hexagon_V6_vmpauhb_acc_128B :
-Hexagon_v64i32_v64i32v64i32i32_Intrinsic<"HEXAGON_V6_vmpauhb_acc_128B">;
-
-def int_hexagon_V6_vaddhw_acc :
-Hexagon_v32i32_v32i32v16i32v16i32_Intrinsic<"HEXAGON_V6_vaddhw_acc">;
-
-def int_hexagon_V6_vaddhw_acc_128B :
-Hexagon_v64i32_v64i32v32i32v32i32_Intrinsic<"HEXAGON_V6_vaddhw_acc_128B">;
-
-def int_hexagon_V6_vlsrb :
-Hexagon_v16i32_v16i32i32_Intrinsic<"HEXAGON_V6_vlsrb">;
-
-def int_hexagon_V6_vlsrb_128B :
-Hexagon_v32i32_v32i32i32_Intrinsic<"HEXAGON_V6_vlsrb_128B">;
-
-def int_hexagon_V6_vlutvwhi :
-Hexagon_v32i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vlutvwhi", [ImmArg<2>]>;
-
-def int_hexagon_V6_vlutvwhi_128B :
-Hexagon_v64i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vlutvwhi_128B", [ImmArg<2>]>;
-
-def int_hexagon_V6_vaddububb_sat :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vaddububb_sat">;
-
-def int_hexagon_V6_vaddububb_sat_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vaddububb_sat_128B">;
-
-def int_hexagon_V6_vsubbsat_dv :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vsubbsat_dv">;
-
-def int_hexagon_V6_vsubbsat_dv_128B :
-Hexagon_v64i32_v64i32v64i32_Intrinsic<"HEXAGON_V6_vsubbsat_dv_128B">;
-
-def int_hexagon_V6_ldtp0 :
-Hexagon_v16i32_i32i32_Intrinsic<"HEXAGON_V6_ldtp0">;
-
-def int_hexagon_V6_ldtp0_128B :
-Hexagon_v32i32_i32i32_Intrinsic<"HEXAGON_V6_ldtp0_128B">;
-
-def int_hexagon_V6_vlutvvb_oracci :
-Hexagon_v16i32_v16i32v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vlutvvb_oracci", [ImmArg<3>]>;
-
-def int_hexagon_V6_vlutvvb_oracci_128B :
-Hexagon_v32i32_v32i32v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vlutvvb_oracci_128B", [ImmArg<3>]>;
-
-def int_hexagon_V6_vsubuwsat_dv :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vsubuwsat_dv">;
-
-def int_hexagon_V6_vsubuwsat_dv_128B :
-Hexagon_v64i32_v64i32v64i32_Intrinsic<"HEXAGON_V6_vsubuwsat_dv_128B">;
-
-def int_hexagon_V6_ldpnt0 :
-Hexagon_v16i32_i32i32_Intrinsic<"HEXAGON_V6_ldpnt0">;
-
-def int_hexagon_V6_ldpnt0_128B :
-Hexagon_v32i32_i32i32_Intrinsic<"HEXAGON_V6_ldpnt0_128B">;
-
-def int_hexagon_V6_vandvnqv :
-Hexagon_v16i32_v512i1v16i32_Intrinsic<"HEXAGON_V6_vandvnqv">;
-
-def int_hexagon_V6_vandvnqv_128B :
-Hexagon_v32i32_v1024i1v32i32_Intrinsic<"HEXAGON_V6_vandvnqv_128B">;
-
-def int_hexagon_V6_lvsplatb :
-Hexagon_v16i32_i32_Intrinsic<"HEXAGON_V6_lvsplatb">;
-
-def int_hexagon_V6_lvsplatb_128B :
-Hexagon_v32i32_i32_Intrinsic<"HEXAGON_V6_lvsplatb_128B">;
-
-def int_hexagon_V6_lvsplath :
-Hexagon_v16i32_i32_Intrinsic<"HEXAGON_V6_lvsplath">;
-
-def int_hexagon_V6_lvsplath_128B :
-Hexagon_v32i32_i32_Intrinsic<"HEXAGON_V6_lvsplath_128B">;
-
-def int_hexagon_V6_ldtpnt0 :
-Hexagon_v16i32_i32i32_Intrinsic<"HEXAGON_V6_ldtpnt0">;
-
-def int_hexagon_V6_ldtpnt0_128B :
-Hexagon_v32i32_i32i32_Intrinsic<"HEXAGON_V6_ldtpnt0_128B">;
-
-def int_hexagon_V6_vlutvwh_nm :
-Hexagon_v32i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vlutvwh_nm">;
-
-def int_hexagon_V6_vlutvwh_nm_128B :
-Hexagon_v64i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vlutvwh_nm_128B">;
-
-def int_hexagon_V6_ldnpnt0 :
-Hexagon_v16i32_i32i32_Intrinsic<"HEXAGON_V6_ldnpnt0">;
-
-def int_hexagon_V6_ldnpnt0_128B :
-Hexagon_v32i32_i32i32_Intrinsic<"HEXAGON_V6_ldnpnt0_128B">;
-
-def int_hexagon_V6_vmpauhb :
-Hexagon_v32i32_v32i32i32_Intrinsic<"HEXAGON_V6_vmpauhb">;
-
-def int_hexagon_V6_vmpauhb_128B :
-Hexagon_v64i32_v64i32i32_Intrinsic<"HEXAGON_V6_vmpauhb_128B">;
-
-def int_hexagon_V6_ldtnp0 :
-Hexagon_v16i32_i32i32_Intrinsic<"HEXAGON_V6_ldtnp0">;
-
-def int_hexagon_V6_ldtnp0_128B :
-Hexagon_v32i32_i32i32_Intrinsic<"HEXAGON_V6_ldtnp0_128B">;
-
-def int_hexagon_V6_vrounduhub :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vrounduhub">;
-
-def int_hexagon_V6_vrounduhub_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vrounduhub_128B">;
-
-def int_hexagon_V6_vadduhw_acc :
-Hexagon_v32i32_v32i32v16i32v16i32_Intrinsic<"HEXAGON_V6_vadduhw_acc">;
-
-def int_hexagon_V6_vadduhw_acc_128B :
-Hexagon_v64i32_v64i32v32i32v32i32_Intrinsic<"HEXAGON_V6_vadduhw_acc_128B">;
-
-def int_hexagon_V6_ldcp0 :
-Hexagon_v16i32_i32i32_Intrinsic<"HEXAGON_V6_ldcp0">;
-
-def int_hexagon_V6_ldcp0_128B :
-Hexagon_v32i32_i32i32_Intrinsic<"HEXAGON_V6_ldcp0_128B">;
-
-def int_hexagon_V6_vadduwsat :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vadduwsat">;
-
-def int_hexagon_V6_vadduwsat_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vadduwsat_128B">;
-
-def int_hexagon_V6_ldtnpnt0 :
-Hexagon_v16i32_i32i32_Intrinsic<"HEXAGON_V6_ldtnpnt0">;
-
-def int_hexagon_V6_ldtnpnt0_128B :
-Hexagon_v32i32_i32i32_Intrinsic<"HEXAGON_V6_ldtnpnt0_128B">;
-
-def int_hexagon_V6_vaddbsat :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vaddbsat">;
-
-def int_hexagon_V6_vaddbsat_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vaddbsat_128B">;
-
-def int_hexagon_V6_vandnqrt :
-Hexagon_v16i32_v512i1i32_Intrinsic<"HEXAGON_V6_vandnqrt">;
-
-def int_hexagon_V6_vandnqrt_128B :
-Hexagon_v32i32_v1024i1i32_Intrinsic<"HEXAGON_V6_vandnqrt_128B">;
-
-def int_hexagon_V6_vmpyiwub_acc :
-Hexagon_v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vmpyiwub_acc">;
-
-def int_hexagon_V6_vmpyiwub_acc_128B :
-Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vmpyiwub_acc_128B">;
-
-def int_hexagon_V6_vmaxb :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vmaxb">;
-
-def int_hexagon_V6_vmaxb_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vmaxb_128B">;
-
-def int_hexagon_V6_vandvqv :
-Hexagon_v16i32_v512i1v16i32_Intrinsic<"HEXAGON_V6_vandvqv">;
-
-def int_hexagon_V6_vandvqv_128B :
-Hexagon_v32i32_v1024i1v32i32_Intrinsic<"HEXAGON_V6_vandvqv_128B">;
-
-def int_hexagon_V6_vaddcarry :
-Hexagon_custom_v16i32v512i1_v16i32v16i32v512i1_Intrinsic;
-
-def int_hexagon_V6_vaddcarry_128B :
-Hexagon_custom_v32i32v1024i1_v32i32v32i32v1024i1_Intrinsic_128B;
-
-def int_hexagon_V6_vasrwuhrndsat :
-Hexagon_v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vasrwuhrndsat">;
-
-def int_hexagon_V6_vasrwuhrndsat_128B :
-Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vasrwuhrndsat_128B">;
-
-def int_hexagon_V6_vlutvvbi :
-Hexagon_v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vlutvvbi", [ImmArg<2>]>;
-
-def int_hexagon_V6_vlutvvbi_128B :
-Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vlutvvbi_128B", [ImmArg<2>]>;
-
-def int_hexagon_V6_vsubuwsat :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vsubuwsat">;
-
-def int_hexagon_V6_vsubuwsat_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vsubuwsat_128B">;
-
-def int_hexagon_V6_vaddbsat_dv :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vaddbsat_dv">;
-
-def int_hexagon_V6_vaddbsat_dv_128B :
-Hexagon_v64i32_v64i32v64i32_Intrinsic<"HEXAGON_V6_vaddbsat_dv_128B">;
-
-def int_hexagon_V6_ldnp0 :
-Hexagon_v16i32_i32i32_Intrinsic<"HEXAGON_V6_ldnp0">;
-
-def int_hexagon_V6_ldnp0_128B :
-Hexagon_v32i32_i32i32_Intrinsic<"HEXAGON_V6_ldnp0_128B">;
-
-def int_hexagon_V6_vasruwuhrndsat :
-Hexagon_v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vasruwuhrndsat">;
-
-def int_hexagon_V6_vasruwuhrndsat_128B :
-Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vasruwuhrndsat_128B">;
-
-def int_hexagon_V6_vrounduwuh :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vrounduwuh">;
-
-def int_hexagon_V6_vrounduwuh_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vrounduwuh_128B">;
-
-def int_hexagon_V6_vlutvvb_nm :
-Hexagon_v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vlutvvb_nm">;
-
-def int_hexagon_V6_vlutvvb_nm_128B :
-Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vlutvvb_nm_128B">;
-
-def int_hexagon_V6_pred_scalar2v2 :
-Hexagon_v512i1_i32_Intrinsic<"HEXAGON_V6_pred_scalar2v2">;
-
-def int_hexagon_V6_pred_scalar2v2_128B :
-Hexagon_v1024i1_i32_Intrinsic<"HEXAGON_V6_pred_scalar2v2_128B">;
-
-def int_hexagon_V6_ldp0 :
-Hexagon_v16i32_i32i32_Intrinsic<"HEXAGON_V6_ldp0">;
-
-def int_hexagon_V6_ldp0_128B :
-Hexagon_v32i32_i32i32_Intrinsic<"HEXAGON_V6_ldp0_128B">;
-
-def int_hexagon_V6_vaddubh_acc :
-Hexagon_v32i32_v32i32v16i32v16i32_Intrinsic<"HEXAGON_V6_vaddubh_acc">;
-
-def int_hexagon_V6_vaddubh_acc_128B :
-Hexagon_v64i32_v64i32v32i32v32i32_Intrinsic<"HEXAGON_V6_vaddubh_acc_128B">;
-
-def int_hexagon_V6_vaddclbw :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vaddclbw">;
-
-def int_hexagon_V6_vaddclbw_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vaddclbw_128B">;
-
-def int_hexagon_V6_ldcpnt0 :
-Hexagon_v16i32_i32i32_Intrinsic<"HEXAGON_V6_ldcpnt0">;
-
-def int_hexagon_V6_ldcpnt0_128B :
-Hexagon_v32i32_i32i32_Intrinsic<"HEXAGON_V6_ldcpnt0_128B">;
-
-def int_hexagon_V6_vadduwsat_dv :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vadduwsat_dv">;
-
-def int_hexagon_V6_vadduwsat_dv_128B :
-Hexagon_v64i32_v64i32v64i32_Intrinsic<"HEXAGON_V6_vadduwsat_dv_128B">;
-
-def int_hexagon_V6_vmpyiwub :
-Hexagon_v16i32_v16i32i32_Intrinsic<"HEXAGON_V6_vmpyiwub">;
-
-def int_hexagon_V6_vmpyiwub_128B :
-Hexagon_v32i32_v32i32i32_Intrinsic<"HEXAGON_V6_vmpyiwub_128B">;
-
-def int_hexagon_V6_vsubububb_sat :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vsubububb_sat">;
-
-def int_hexagon_V6_vsubububb_sat_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vsubububb_sat_128B">;
-
-def int_hexagon_V6_ldcnp0 :
-Hexagon_v16i32_i32i32_Intrinsic<"HEXAGON_V6_ldcnp0">;
-
-def int_hexagon_V6_ldcnp0_128B :
-Hexagon_v32i32_i32i32_Intrinsic<"HEXAGON_V6_ldcnp0_128B">;
-
-def int_hexagon_V6_vlutvwh_oracci :
-Hexagon_v32i32_v32i32v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vlutvwh_oracci", [ImmArg<3>]>;
-
-def int_hexagon_V6_vlutvwh_oracci_128B :
-Hexagon_v64i32_v64i32v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vlutvwh_oracci_128B", [ImmArg<3>]>;
-
-def int_hexagon_V6_vsubbsat :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vsubbsat">;
-
-def int_hexagon_V6_vsubbsat_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vsubbsat_128B">;
-
-// V65 HVX Instructions.
-
-def int_hexagon_V6_vasruhubrndsat :
-Hexagon_v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vasruhubrndsat">;
-
-def int_hexagon_V6_vasruhubrndsat_128B :
-Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vasruhubrndsat_128B">;
-
 def int_hexagon_V6_vrmpybub_rtt :
-Hexagon_v32i32_v16i32i64_Intrinsic<"HEXAGON_V6_vrmpybub_rtt">;
+Hexagon_v32i32_v16i32i64_rtt_Intrinsic<"HEXAGON_V6_vrmpybub_rtt">;
 
 def int_hexagon_V6_vrmpybub_rtt_128B :
-Hexagon_v64i32_v32i32i64_Intrinsic<"HEXAGON_V6_vrmpybub_rtt_128B">;
-
-def int_hexagon_V6_vmpahhsat :
-Hexagon_v16i32_v16i32v16i32i64_Intrinsic<"HEXAGON_V6_vmpahhsat">;
-
-def int_hexagon_V6_vmpahhsat_128B :
-Hexagon_v32i32_v32i32v32i32i64_Intrinsic<"HEXAGON_V6_vmpahhsat_128B">;
-
-def int_hexagon_V6_vavguwrnd :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vavguwrnd">;
-
-def int_hexagon_V6_vavguwrnd_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vavguwrnd_128B">;
-
-def int_hexagon_V6_vnavgb :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vnavgb">;
-
-def int_hexagon_V6_vnavgb_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vnavgb_128B">;
-
-def int_hexagon_V6_vasrh_acc :
-Hexagon_v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vasrh_acc">;
-
-def int_hexagon_V6_vasrh_acc_128B :
-Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vasrh_acc_128B">;
-
-def int_hexagon_V6_vmpauhuhsat :
-Hexagon_v16i32_v16i32v16i32i64_Intrinsic<"HEXAGON_V6_vmpauhuhsat">;
-
-def int_hexagon_V6_vmpauhuhsat_128B :
-Hexagon_v32i32_v32i32v32i32i64_Intrinsic<"HEXAGON_V6_vmpauhuhsat_128B">;
-
-def int_hexagon_V6_vmpyh_acc :
-Hexagon_v32i32_v32i32v16i32i32_Intrinsic<"HEXAGON_V6_vmpyh_acc">;
-
-def int_hexagon_V6_vmpyh_acc_128B :
-Hexagon_v64i32_v64i32v32i32i32_Intrinsic<"HEXAGON_V6_vmpyh_acc_128B">;
+Hexagon_v64i32_v32i32i64_rtt_Intrinsic<"HEXAGON_V6_vrmpybub_rtt_128B">;
 
 def int_hexagon_V6_vrmpybub_rtt_acc :
-Hexagon_v32i32_v32i32v16i32i64_Intrinsic<"HEXAGON_V6_vrmpybub_rtt_acc">;
+Hexagon_v32i32_v32i32v16i32i64_rtt_Intrinsic<"HEXAGON_V6_vrmpybub_rtt_acc">;
 
 def int_hexagon_V6_vrmpybub_rtt_acc_128B :
-Hexagon_v64i32_v64i32v32i32i64_Intrinsic<"HEXAGON_V6_vrmpybub_rtt_acc_128B">;
-
-def int_hexagon_V6_vavgb :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vavgb">;
-
-def int_hexagon_V6_vavgb_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vavgb_128B">;
-
-def int_hexagon_V6_vaslh_acc :
-Hexagon_v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vaslh_acc">;
-
-def int_hexagon_V6_vaslh_acc_128B :
-Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vaslh_acc_128B">;
-
-def int_hexagon_V6_vavguw :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vavguw">;
-
-def int_hexagon_V6_vavguw_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vavguw_128B">;
-
-def int_hexagon_V6_vlut4 :
-Hexagon_v16i32_v16i32i64_Intrinsic<"HEXAGON_V6_vlut4">;
-
-def int_hexagon_V6_vlut4_128B :
-Hexagon_v32i32_v32i32i64_Intrinsic<"HEXAGON_V6_vlut4_128B">;
-
-def int_hexagon_V6_vmpyuhe_acc :
-Hexagon_v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vmpyuhe_acc">;
-
-def int_hexagon_V6_vmpyuhe_acc_128B :
-Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vmpyuhe_acc_128B">;
+Hexagon_v64i32_v64i32v32i32i64_rtt_Intrinsic<"HEXAGON_V6_vrmpybub_rtt_acc_128B">;
 
 def int_hexagon_V6_vrmpyub_rtt :
-Hexagon_v32i32_v16i32i64_Intrinsic<"HEXAGON_V6_vrmpyub_rtt">;
+Hexagon_v32i32_v16i32i64_rtt_Intrinsic<"HEXAGON_V6_vrmpyub_rtt">;
 
 def int_hexagon_V6_vrmpyub_rtt_128B :
-Hexagon_v64i32_v32i32i64_Intrinsic<"HEXAGON_V6_vrmpyub_rtt_128B">;
-
-def int_hexagon_V6_vmpsuhuhsat :
-Hexagon_v16i32_v16i32v16i32i64_Intrinsic<"HEXAGON_V6_vmpsuhuhsat">;
-
-def int_hexagon_V6_vmpsuhuhsat_128B :
-Hexagon_v32i32_v32i32v32i32i64_Intrinsic<"HEXAGON_V6_vmpsuhuhsat_128B">;
-
-def int_hexagon_V6_vasruhubsat :
-Hexagon_v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vasruhubsat">;
-
-def int_hexagon_V6_vasruhubsat_128B :
-Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vasruhubsat_128B">;
-
-def int_hexagon_V6_vmpyuhe :
-Hexagon_v16i32_v16i32i32_Intrinsic<"HEXAGON_V6_vmpyuhe">;
-
-def int_hexagon_V6_vmpyuhe_128B :
-Hexagon_v32i32_v32i32i32_Intrinsic<"HEXAGON_V6_vmpyuhe_128B">;
+Hexagon_v64i32_v32i32i64_rtt_Intrinsic<"HEXAGON_V6_vrmpyub_rtt_128B">;
 
 def int_hexagon_V6_vrmpyub_rtt_acc :
-Hexagon_v32i32_v32i32v16i32i64_Intrinsic<"HEXAGON_V6_vrmpyub_rtt_acc">;
+Hexagon_v32i32_v32i32v16i32i64_rtt_Intrinsic<"HEXAGON_V6_vrmpyub_rtt_acc">;
 
 def int_hexagon_V6_vrmpyub_rtt_acc_128B :
-Hexagon_v64i32_v64i32v32i32i64_Intrinsic<"HEXAGON_V6_vrmpyub_rtt_acc_128B">;
+Hexagon_v64i32_v64i32v32i32i64_rtt_Intrinsic<"HEXAGON_V6_vrmpyub_rtt_acc_128B">;
 
-def int_hexagon_V6_vasruwuhsat :
-Hexagon_v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vasruwuhsat">;
+// HVX Vector predicate casts.
+// These intrinsics do not emit (nor do they correspond to) any instructions,
+// they are no-ops.
 
-def int_hexagon_V6_vasruwuhsat_128B :
-Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vasruwuhsat_128B">;
+def int_hexagon_V6_pred_typecast :
+Hexagon_NonGCC_Intrinsic<[llvm_anyvector_ty], [llvm_anyvector_ty], [IntrNoMem]>;
 
-def int_hexagon_V6_vmpabuu_acc :
-Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vmpabuu_acc">;
+def int_hexagon_V6_pred_typecast_128B :
+Hexagon_NonGCC_Intrinsic<[llvm_anyvector_ty], [llvm_anyvector_ty], [IntrNoMem]>;
 
-def int_hexagon_V6_vmpabuu_acc_128B :
-Hexagon_v64i32_v64i32v64i32i32_Intrinsic<"HEXAGON_V6_vmpabuu_acc_128B">;
+// Masked vector stores
+//
 
-def int_hexagon_V6_vprefixqw :
-Hexagon_v16i32_v512i1_Intrinsic<"HEXAGON_V6_vprefixqw">;
+class Hexagon_custom_vms_Intrinsic
+  : Hexagon_NonGCC_Intrinsic<
+       [], [llvm_v64i1_ty,llvm_ptr_ty,llvm_v16i32_ty], [IntrWriteMem]>;
 
-def int_hexagon_V6_vprefixqw_128B :
-Hexagon_v32i32_v1024i1_Intrinsic<"HEXAGON_V6_vprefixqw_128B">;
+class Hexagon_custom_vms_Intrinsic_128B
+  : Hexagon_NonGCC_Intrinsic<
+       [], [llvm_v128i1_ty,llvm_ptr_ty,llvm_v32i32_ty], [IntrWriteMem]>;
 
-def int_hexagon_V6_vprefixqh :
-Hexagon_v16i32_v512i1_Intrinsic<"HEXAGON_V6_vprefixqh">;
+def int_hexagon_V6_vmaskedstoreq: Hexagon_custom_vms_Intrinsic;
+def int_hexagon_V6_vmaskedstorenq: Hexagon_custom_vms_Intrinsic;
+def int_hexagon_V6_vmaskedstorentq: Hexagon_custom_vms_Intrinsic;
+def int_hexagon_V6_vmaskedstorentnq: Hexagon_custom_vms_Intrinsic;
 
-def int_hexagon_V6_vprefixqh_128B :
-Hexagon_v32i32_v1024i1_Intrinsic<"HEXAGON_V6_vprefixqh_128B">;
+def int_hexagon_V6_vmaskedstoreq_128B: Hexagon_custom_vms_Intrinsic_128B;
+def int_hexagon_V6_vmaskedstorenq_128B: Hexagon_custom_vms_Intrinsic_128B;
+def int_hexagon_V6_vmaskedstorentq_128B: Hexagon_custom_vms_Intrinsic_128B;
+def int_hexagon_V6_vmaskedstorentnq_128B: Hexagon_custom_vms_Intrinsic_128B;
 
-def int_hexagon_V6_vprefixqb :
-Hexagon_v16i32_v512i1_Intrinsic<"HEXAGON_V6_vprefixqb">;
-
-def int_hexagon_V6_vprefixqb_128B :
-Hexagon_v32i32_v1024i1_Intrinsic<"HEXAGON_V6_vprefixqb_128B">;
-
-def int_hexagon_V6_vabsb :
-Hexagon_v16i32_v16i32_Intrinsic<"HEXAGON_V6_vabsb">;
-
-def int_hexagon_V6_vabsb_128B :
-Hexagon_v32i32_v32i32_Intrinsic<"HEXAGON_V6_vabsb_128B">;
-
-def int_hexagon_V6_vavgbrnd :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vavgbrnd">;
-
-def int_hexagon_V6_vavgbrnd_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vavgbrnd_128B">;
-
-def int_hexagon_V6_vdd0 :
-Hexagon_v32i32__Intrinsic<"HEXAGON_V6_vdd0">;
-
-def int_hexagon_V6_vdd0_128B :
-Hexagon_v64i32__Intrinsic<"HEXAGON_V6_vdd0_128B">;
-
-def int_hexagon_V6_vmpabuu :
-Hexagon_v32i32_v32i32i32_Intrinsic<"HEXAGON_V6_vmpabuu">;
-
-def int_hexagon_V6_vmpabuu_128B :
-Hexagon_v64i32_v64i32i32_Intrinsic<"HEXAGON_V6_vmpabuu_128B">;
-
-def int_hexagon_V6_vabsb_sat :
-Hexagon_v16i32_v16i32_Intrinsic<"HEXAGON_V6_vabsb_sat">;
-
-def int_hexagon_V6_vabsb_sat_128B :
-Hexagon_v32i32_v32i32_Intrinsic<"HEXAGON_V6_vabsb_sat_128B">;
-
-// V66 HVX Instructions.
-
-def int_hexagon_V6_vaddcarrysat :
-Hexagon_v16i32_v16i32v16i32v512i1_Intrinsic<"HEXAGON_V6_vaddcarrysat">;
-
-def int_hexagon_V6_vaddcarrysat_128B :
-Hexagon_v32i32_v32i32v32i32v1024i1_Intrinsic<"HEXAGON_V6_vaddcarrysat_128B">;
-
-def int_hexagon_V6_vasr_into :
-Hexagon_v32i32_v32i32v16i32v16i32_Intrinsic<"HEXAGON_V6_vasr_into">;
-
-def int_hexagon_V6_vasr_into_128B :
-Hexagon_v64i32_v64i32v32i32v32i32_Intrinsic<"HEXAGON_V6_vasr_into_128B">;
-
-def int_hexagon_V6_vsatdw :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vsatdw">;
-
-def int_hexagon_V6_vsatdw_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vsatdw_128B">;
-
-def int_hexagon_V6_vrotr :
-Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vrotr">;
-
-def int_hexagon_V6_vrotr_128B :
-Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vrotr_128B">;
-
+include "llvm/IR/IntrinsicsHexagonDep.td"
diff --git a/linux-x64/clang/include/llvm/IR/IntrinsicsHexagonDep.td b/linux-x64/clang/include/llvm/IR/IntrinsicsHexagonDep.td
new file mode 100644
index 0000000..198b6a7
--- /dev/null
+++ b/linux-x64/clang/include/llvm/IR/IntrinsicsHexagonDep.td
@@ -0,0 +1,6144 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+// Automatically generated file, do not edit!
+//===----------------------------------------------------------------------===//
+
+// tag : C2_cmpeq
+class Hexagon_i32_i32i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_i32_ty], [llvm_i32_ty,llvm_i32_ty],
+       intr_properties>;
+
+// tag : C2_cmpeqp
+class Hexagon_i32_i64i64_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_i32_ty], [llvm_i64_ty,llvm_i64_ty],
+       intr_properties>;
+
+// tag : C2_not
+class Hexagon_i32_i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_i32_ty], [llvm_i32_ty],
+       intr_properties>;
+
+// tag : C4_and_and
+class Hexagon_i32_i32i32i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_i32_ty], [llvm_i32_ty,llvm_i32_ty,llvm_i32_ty],
+       intr_properties>;
+
+// tag : C2_vmux
+class Hexagon_i64_i32i64i64_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_i64_ty], [llvm_i32_ty,llvm_i64_ty,llvm_i64_ty],
+       intr_properties>;
+
+// tag : C2_mask
+class Hexagon_i64_i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_i64_ty], [llvm_i32_ty],
+       intr_properties>;
+
+// tag : A4_vcmpbeqi
+class Hexagon_i32_i64i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_i32_ty], [llvm_i64_ty,llvm_i32_ty],
+       intr_properties>;
+
+// tag : A4_boundscheck
+class Hexagon_i32_i32i64_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_i32_ty], [llvm_i32_ty,llvm_i64_ty],
+       intr_properties>;
+
+// tag : M2_mpyd_acc_hh_s0
+class Hexagon_i64_i64i32i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_i64_ty], [llvm_i64_ty,llvm_i32_ty,llvm_i32_ty],
+       intr_properties>;
+
+// tag : M2_mpyd_hh_s0
+class Hexagon_i64_i32i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_i64_ty], [llvm_i32_ty,llvm_i32_ty],
+       intr_properties>;
+
+// tag : M2_vmpy2es_s0
+class Hexagon_i64_i64i64_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_i64_ty], [llvm_i64_ty,llvm_i64_ty],
+       intr_properties>;
+
+// tag : M2_vmac2es_s0
+class Hexagon_i64_i64i64i64_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_i64_ty], [llvm_i64_ty,llvm_i64_ty,llvm_i64_ty],
+       intr_properties>;
+
+// tag : M2_vrcmpys_s1
+class Hexagon_i64_i64i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_i64_ty], [llvm_i64_ty,llvm_i32_ty],
+       intr_properties>;
+
+// tag : M2_vrcmpys_acc_s1
+class Hexagon_i64_i64i64i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_i64_ty], [llvm_i64_ty,llvm_i64_ty,llvm_i32_ty],
+       intr_properties>;
+
+// tag : S4_vrcrotate_acc
+class Hexagon_i64_i64i64i32i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_i64_ty], [llvm_i64_ty,llvm_i64_ty,llvm_i32_ty,llvm_i32_ty],
+       intr_properties>;
+
+// tag : A2_addsp
+class Hexagon_i64_i32i64_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_i64_ty], [llvm_i32_ty,llvm_i64_ty],
+       intr_properties>;
+
+// tag : A2_vconj
+class Hexagon_i64_i64_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_i64_ty], [llvm_i64_ty],
+       intr_properties>;
+
+// tag : A2_sat
+class Hexagon_i32_i64_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_i32_ty], [llvm_i64_ty],
+       intr_properties>;
+
+// tag : F2_sfadd
+class Hexagon_float_floatfloat_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_float_ty], [llvm_float_ty,llvm_float_ty],
+       intr_properties>;
+
+// tag : F2_sffma
+class Hexagon_float_floatfloatfloat_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_float_ty], [llvm_float_ty,llvm_float_ty,llvm_float_ty],
+       intr_properties>;
+
+// tag : F2_sffma_sc
+class Hexagon_float_floatfloatfloati32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_float_ty], [llvm_float_ty,llvm_float_ty,llvm_float_ty,llvm_i32_ty],
+       intr_properties>;
+
+// tag : F2_sfcmpeq
+class Hexagon_i32_floatfloat_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_i32_ty], [llvm_float_ty,llvm_float_ty],
+       intr_properties>;
+
+// tag : F2_sfclass
+class Hexagon_i32_floati32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_i32_ty], [llvm_float_ty,llvm_i32_ty],
+       intr_properties>;
+
+// tag : F2_sfimm_p
+class Hexagon_float_i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_float_ty], [llvm_i32_ty],
+       intr_properties>;
+
+// tag : F2_sffixupr
+class Hexagon_float_float_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_float_ty], [llvm_float_ty],
+       intr_properties>;
+
+// tag : F2_dfadd
+class Hexagon_double_doubledouble_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_double_ty], [llvm_double_ty,llvm_double_ty],
+       intr_properties>;
+
+// tag : F2_dfmpylh
+class Hexagon_double_doubledoubledouble_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_double_ty], [llvm_double_ty,llvm_double_ty,llvm_double_ty],
+       intr_properties>;
+
+// tag : F2_dfcmpeq
+class Hexagon_i32_doubledouble_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_i32_ty], [llvm_double_ty,llvm_double_ty],
+       intr_properties>;
+
+// tag : F2_dfclass
+class Hexagon_i32_doublei32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_i32_ty], [llvm_double_ty,llvm_i32_ty],
+       intr_properties>;
+
+// tag : F2_dfimm_p
+class Hexagon_double_i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_double_ty], [llvm_i32_ty],
+       intr_properties>;
+
+// tag : F2_conv_sf2df
+class Hexagon_double_float_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_double_ty], [llvm_float_ty],
+       intr_properties>;
+
+// tag : F2_conv_df2sf
+class Hexagon_float_double_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_float_ty], [llvm_double_ty],
+       intr_properties>;
+
+// tag : F2_conv_ud2sf
+class Hexagon_float_i64_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_float_ty], [llvm_i64_ty],
+       intr_properties>;
+
+// tag : F2_conv_ud2df
+class Hexagon_double_i64_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_double_ty], [llvm_i64_ty],
+       intr_properties>;
+
+// tag : F2_conv_sf2uw
+class Hexagon_i32_float_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_i32_ty], [llvm_float_ty],
+       intr_properties>;
+
+// tag : F2_conv_sf2ud
+class Hexagon_i64_float_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_i64_ty], [llvm_float_ty],
+       intr_properties>;
+
+// tag : F2_conv_df2uw
+class Hexagon_i32_double_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_i32_ty], [llvm_double_ty],
+       intr_properties>;
+
+// tag : F2_conv_df2ud
+class Hexagon_i64_double_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_i64_ty], [llvm_double_ty],
+       intr_properties>;
+
+// tag : S2_insert
+class Hexagon_i32_i32i32i32i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_i32_ty], [llvm_i32_ty,llvm_i32_ty,llvm_i32_ty,llvm_i32_ty],
+       intr_properties>;
+
+// tag : S2_insert_rp
+class Hexagon_i32_i32i32i64_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_i32_ty], [llvm_i32_ty,llvm_i32_ty,llvm_i64_ty],
+       intr_properties>;
+
+// tag : Y2_dcfetch
+class Hexagon__ptr_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [], [llvm_ptr_ty],
+       intr_properties>;
+
+// tag : Y4_l2fetch
+class Hexagon__ptri32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [], [llvm_ptr_ty,llvm_i32_ty],
+       intr_properties>;
+
+// tag : Y5_l2fetch
+class Hexagon__ptri64_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [], [llvm_ptr_ty,llvm_i64_ty],
+       intr_properties>;
+
+// tag :
+class Hexagon_v32i32_v32i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_v32i32_ty], [llvm_v32i32_ty],
+       intr_properties>;
+
+// tag :
+class Hexagon_v64i32_v64i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_v64i32_ty], [llvm_v64i32_ty],
+       intr_properties>;
+
+// tag :
+class Hexagon_v32i32__Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_v32i32_ty], [],
+       intr_properties>;
+
+// tag :
+class Hexagon_v64i32__Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_v64i32_ty], [],
+       intr_properties>;
+
+// tag :
+class Hexagon_i32_v32i32i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_i32_ty], [llvm_v32i32_ty,llvm_i32_ty],
+       intr_properties>;
+
+// tag :
+class Hexagon_v32i32_v32i32i64_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_v32i32_ty], [llvm_v32i32_ty,llvm_i64_ty],
+       intr_properties>;
+
+// tag :
+class Hexagon_i64_v32i32i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_i64_ty], [llvm_v32i32_ty,llvm_i32_ty],
+       intr_properties>;
+
+// tag :
+class Hexagon_v64i32_v32i32v32i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_v64i32_ty], [llvm_v32i32_ty,llvm_v32i32_ty],
+       intr_properties>;
+
+// tag :
+class Hexagon_v32i32_i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_v32i32_ty], [llvm_i32_ty],
+       intr_properties>;
+
+// tag :
+class Hexagon_v64i32_i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_v64i32_ty], [llvm_i32_ty],
+       intr_properties>;
+
+// tag :
+class Hexagon_v64i32_i64_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_v64i32_ty], [llvm_i64_ty],
+       intr_properties>;
+
+// tag :
+class Hexagon_v32i32_v32i32v32i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_v32i32_ty], [llvm_v32i32_ty,llvm_v32i32_ty],
+       intr_properties>;
+
+// tag :
+class Hexagon_v32i32_v32i32i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_v32i32_ty], [llvm_v32i32_ty,llvm_i32_ty],
+       intr_properties>;
+
+// tag :
+class Hexagon_v64i32_v64i32i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_v64i32_ty], [llvm_v64i32_ty,llvm_i32_ty],
+       intr_properties>;
+
+// tag :
+class Hexagon_v64i32_v64i32v64i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_v64i32_ty], [llvm_v64i32_ty,llvm_v64i32_ty],
+       intr_properties>;
+
+// tag :
+class Hexagon_v64i32_v32i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_v64i32_ty], [llvm_v32i32_ty],
+       intr_properties>;
+
+// tag :
+class Hexagon_v32i32_v64i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_v32i32_ty], [llvm_v64i32_ty],
+       intr_properties>;
+
+// tag :
+class Hexagon_v4i32_v32i32v32i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_v4i32_ty], [llvm_v32i32_ty,llvm_v32i32_ty],
+       intr_properties>;
+
+// tag :
+class Hexagon_v4i32_v32i32i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_v4i32_ty], [llvm_v32i32_ty,llvm_i32_ty],
+       intr_properties>;
+
+// tag :
+class Hexagon_v32i32_v4i32v32i32v32i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_v32i32_ty], [llvm_v4i32_ty,llvm_v32i32_ty,llvm_v32i32_ty],
+       intr_properties>;
+
+// tag :
+class Hexagon_v64i32_v8i32v64i32v64i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_v64i32_ty], [llvm_v8i32_ty,llvm_v64i32_ty,llvm_v64i32_ty],
+       intr_properties>;
+
+// tag :
+class Hexagon_v32i32_v64i32i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_v32i32_ty], [llvm_v64i32_ty,llvm_i32_ty],
+       intr_properties>;
+
+// tag :
+class Hexagon_v32i32_v64i32v64i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_v32i32_ty], [llvm_v64i32_ty,llvm_v64i32_ty],
+       intr_properties>;
+
+// tag :
+class Hexagon_v32i32_v32i32v32i32i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_v32i32_ty], [llvm_v32i32_ty,llvm_v32i32_ty,llvm_i32_ty],
+       intr_properties>;
+
+// tag :
+class Hexagon_v32i32_v32i32v32i32v32i32i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_v32i32_ty], [llvm_v32i32_ty,llvm_v32i32_ty,llvm_v32i32_ty,llvm_i32_ty],
+       intr_properties>;
+
+// tag :
+class Hexagon_v32i32_v32i32v32i32v32i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_v32i32_ty], [llvm_v32i32_ty,llvm_v32i32_ty,llvm_v32i32_ty],
+       intr_properties>;
+
+// tag :
+class Hexagon_v64i32_v64i32v32i32v32i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_v64i32_ty], [llvm_v64i32_ty,llvm_v32i32_ty,llvm_v32i32_ty],
+       intr_properties>;
+
+// tag :
+class Hexagon_v32i32_v32i32v64i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_v32i32_ty], [llvm_v32i32_ty,llvm_v64i32_ty],
+       intr_properties>;
+
+// tag :
+class Hexagon_v64i32_v64i32v4i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_v64i32_ty], [llvm_v64i32_ty,llvm_v4i32_ty],
+       intr_properties>;
+
+// tag :
+class Hexagon_v64i32_v64i32v64i32i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_v64i32_ty], [llvm_v64i32_ty,llvm_v64i32_ty,llvm_i32_ty],
+       intr_properties>;
+
+// tag :
+class Hexagon_v64i32_v32i32v32i32i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_v64i32_ty], [llvm_v32i32_ty,llvm_v32i32_ty,llvm_i32_ty],
+       intr_properties>;
+
+// tag :
+class Hexagon_v32i32_v32i32v32i32i64_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_v32i32_ty], [llvm_v32i32_ty,llvm_v32i32_ty,llvm_i64_ty],
+       intr_properties>;
+
+// tag :
+class Hexagon_v64i32_v64i32v32i32v32i32i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_v64i32_ty], [llvm_v64i32_ty,llvm_v32i32_ty,llvm_v32i32_ty,llvm_i32_ty],
+       intr_properties>;
+
+// tag :
+class Hexagon_v64i32_v64i32v32i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_v64i32_ty], [llvm_v64i32_ty,llvm_v32i32_ty],
+       intr_properties>;
+
+// tag : V6_vS32b_qpred_ai
+class Hexagon_custom__v64i1ptrv16i32_Intrinsic<
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_NonGCC_Intrinsic<
+       [], [llvm_v64i1_ty,llvm_ptr_ty,llvm_v16i32_ty],
+       intr_properties>;
+
+// tag : V6_vS32b_qpred_ai
+class Hexagon_custom__v128i1ptrv32i32_Intrinsic_128B<
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_NonGCC_Intrinsic<
+       [], [llvm_v128i1_ty,llvm_ptr_ty,llvm_v32i32_ty],
+       intr_properties>;
+
+// tag : V6_valignb
+class Hexagon_v16i32_v16i32v16i32i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_v16i32_ty], [llvm_v16i32_ty,llvm_v16i32_ty,llvm_i32_ty],
+       intr_properties>;
+
+// tag : V6_vror
+class Hexagon_v16i32_v16i32i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_v16i32_ty], [llvm_v16i32_ty,llvm_i32_ty],
+       intr_properties>;
+
+// tag : V6_vunpackub
+class Hexagon_v32i32_v16i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_v32i32_ty], [llvm_v16i32_ty],
+       intr_properties>;
+
+// tag : V6_vunpackob
+class Hexagon_v32i32_v32i32v16i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_v32i32_ty], [llvm_v32i32_ty,llvm_v16i32_ty],
+       intr_properties>;
+
+// tag : V6_vpackeb
+class Hexagon_v16i32_v16i32v16i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_v16i32_ty], [llvm_v16i32_ty,llvm_v16i32_ty],
+       intr_properties>;
+
+// tag : V6_vdmpyhvsat_acc
+class Hexagon_v16i32_v16i32v16i32v16i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_v16i32_ty], [llvm_v16i32_ty,llvm_v16i32_ty,llvm_v16i32_ty],
+       intr_properties>;
+
+// tag : V6_vdmpyhisat
+class Hexagon_v16i32_v32i32i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_v16i32_ty], [llvm_v32i32_ty,llvm_i32_ty],
+       intr_properties>;
+
+// tag : V6_vdmpyhisat_acc
+class Hexagon_v16i32_v16i32v32i32i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_v16i32_ty], [llvm_v16i32_ty,llvm_v32i32_ty,llvm_i32_ty],
+       intr_properties>;
+
+// tag : V6_vdmpyhisat_acc
+class Hexagon_v32i32_v32i32v64i32i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_v32i32_ty], [llvm_v32i32_ty,llvm_v64i32_ty,llvm_i32_ty],
+       intr_properties>;
+
+// tag : V6_vrmpyubi
+class Hexagon_v32i32_v32i32i32i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_v32i32_ty], [llvm_v32i32_ty,llvm_i32_ty,llvm_i32_ty],
+       intr_properties>;
+
+// tag : V6_vrmpyubi
+class Hexagon_v64i32_v64i32i32i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_v64i32_ty], [llvm_v64i32_ty,llvm_i32_ty,llvm_i32_ty],
+       intr_properties>;
+
+// tag : V6_vrmpyubi_acc
+class Hexagon_v32i32_v32i32v32i32i32i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_v32i32_ty], [llvm_v32i32_ty,llvm_v32i32_ty,llvm_i32_ty,llvm_i32_ty],
+       intr_properties>;
+
+// tag : V6_vrmpyubi_acc
+class Hexagon_v64i32_v64i32v64i32i32i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_v64i32_ty], [llvm_v64i32_ty,llvm_v64i32_ty,llvm_i32_ty,llvm_i32_ty],
+       intr_properties>;
+
+// tag : V6_vasr_into
+class Hexagon_v32i32_v32i32v16i32v16i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_v32i32_ty], [llvm_v32i32_ty,llvm_v16i32_ty,llvm_v16i32_ty],
+       intr_properties>;
+
+// tag : V6_vaddcarrysat
+class Hexagon_custom_v16i32_v16i32v16i32v64i1_Intrinsic<
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_NonGCC_Intrinsic<
+       [llvm_v16i32_ty], [llvm_v16i32_ty,llvm_v16i32_ty,llvm_v64i1_ty],
+       intr_properties>;
+
+// tag : V6_vaddcarrysat
+class Hexagon_custom_v32i32_v32i32v32i32v128i1_Intrinsic_128B<
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_NonGCC_Intrinsic<
+       [llvm_v32i32_ty], [llvm_v32i32_ty,llvm_v32i32_ty,llvm_v128i1_ty],
+       intr_properties>;
+
+// tag : V6_vaddcarry
+class Hexagon_custom_v16i32v64i1_v16i32v16i32v64i1_Intrinsic<
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_NonGCC_Intrinsic<
+       [llvm_v16i32_ty,llvm_v64i1_ty], [llvm_v16i32_ty,llvm_v16i32_ty,llvm_v64i1_ty],
+       intr_properties>;
+
+// tag : V6_vaddcarry
+class Hexagon_custom_v32i32v128i1_v32i32v32i32v128i1_Intrinsic_128B<
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_NonGCC_Intrinsic<
+       [llvm_v32i32_ty,llvm_v128i1_ty], [llvm_v32i32_ty,llvm_v32i32_ty,llvm_v128i1_ty],
+       intr_properties>;
+
+// tag : V6_vaddubh
+class Hexagon_v32i32_v16i32v16i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_v32i32_ty], [llvm_v16i32_ty,llvm_v16i32_ty],
+       intr_properties>;
+
+// tag : V6_vd0
+class Hexagon_v16i32__Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_v16i32_ty], [],
+       intr_properties>;
+
+// tag : V6_vaddbq
+class Hexagon_custom_v16i32_v64i1v16i32v16i32_Intrinsic<
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_NonGCC_Intrinsic<
+       [llvm_v16i32_ty], [llvm_v64i1_ty,llvm_v16i32_ty,llvm_v16i32_ty],
+       intr_properties>;
+
+// tag : V6_vaddbq
+class Hexagon_custom_v32i32_v128i1v32i32v32i32_Intrinsic_128B<
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_NonGCC_Intrinsic<
+       [llvm_v32i32_ty], [llvm_v128i1_ty,llvm_v32i32_ty,llvm_v32i32_ty],
+       intr_properties>;
+
+// tag : V6_vabsb
+class Hexagon_v16i32_v16i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_v16i32_ty], [llvm_v16i32_ty],
+       intr_properties>;
+
+// tag : V6_vmpyub
+class Hexagon_v32i32_v16i32i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_v32i32_ty], [llvm_v16i32_ty,llvm_i32_ty],
+       intr_properties>;
+
+// tag : V6_vmpyub
+class Hexagon_v64i32_v32i32i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_v64i32_ty], [llvm_v32i32_ty,llvm_i32_ty],
+       intr_properties>;
+
+// tag : V6_vmpyub_acc
+class Hexagon_v32i32_v32i32v16i32i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_v32i32_ty], [llvm_v32i32_ty,llvm_v16i32_ty,llvm_i32_ty],
+       intr_properties>;
+
+// tag : V6_vmpyub_acc
+class Hexagon_v64i32_v64i32v32i32i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_v64i32_ty], [llvm_v64i32_ty,llvm_v32i32_ty,llvm_i32_ty],
+       intr_properties>;
+
+// tag : V6_vandqrt
+class Hexagon_custom_v16i32_v64i1i32_Intrinsic<
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_NonGCC_Intrinsic<
+       [llvm_v16i32_ty], [llvm_v64i1_ty,llvm_i32_ty],
+       intr_properties>;
+
+// tag : V6_vandqrt
+class Hexagon_custom_v32i32_v128i1i32_Intrinsic_128B<
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_NonGCC_Intrinsic<
+       [llvm_v32i32_ty], [llvm_v128i1_ty,llvm_i32_ty],
+       intr_properties>;
+
+// tag : V6_vandqrt_acc
+class Hexagon_custom_v16i32_v16i32v64i1i32_Intrinsic<
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_NonGCC_Intrinsic<
+       [llvm_v16i32_ty], [llvm_v16i32_ty,llvm_v64i1_ty,llvm_i32_ty],
+       intr_properties>;
+
+// tag : V6_vandqrt_acc
+class Hexagon_custom_v32i32_v32i32v128i1i32_Intrinsic_128B<
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_NonGCC_Intrinsic<
+       [llvm_v32i32_ty], [llvm_v32i32_ty,llvm_v128i1_ty,llvm_i32_ty],
+       intr_properties>;
+
+// tag : V6_vandvrt
+class Hexagon_custom_v64i1_v16i32i32_Intrinsic<
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_NonGCC_Intrinsic<
+       [llvm_v64i1_ty], [llvm_v16i32_ty,llvm_i32_ty],
+       intr_properties>;
+
+// tag : V6_vandvrt
+class Hexagon_custom_v128i1_v32i32i32_Intrinsic_128B<
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_NonGCC_Intrinsic<
+       [llvm_v128i1_ty], [llvm_v32i32_ty,llvm_i32_ty],
+       intr_properties>;
+
+// tag : V6_vandvrt_acc
+class Hexagon_custom_v64i1_v64i1v16i32i32_Intrinsic<
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_NonGCC_Intrinsic<
+       [llvm_v64i1_ty], [llvm_v64i1_ty,llvm_v16i32_ty,llvm_i32_ty],
+       intr_properties>;
+
+// tag : V6_vandvrt_acc
+class Hexagon_custom_v128i1_v128i1v32i32i32_Intrinsic_128B<
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_NonGCC_Intrinsic<
+       [llvm_v128i1_ty], [llvm_v128i1_ty,llvm_v32i32_ty,llvm_i32_ty],
+       intr_properties>;
+
+// tag : V6_vandvqv
+class Hexagon_custom_v16i32_v64i1v16i32_Intrinsic<
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_NonGCC_Intrinsic<
+       [llvm_v16i32_ty], [llvm_v64i1_ty,llvm_v16i32_ty],
+       intr_properties>;
+
+// tag : V6_vandvqv
+class Hexagon_custom_v32i32_v128i1v32i32_Intrinsic_128B<
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_NonGCC_Intrinsic<
+       [llvm_v32i32_ty], [llvm_v128i1_ty,llvm_v32i32_ty],
+       intr_properties>;
+
+// tag : V6_vgtw
+class Hexagon_custom_v64i1_v16i32v16i32_Intrinsic<
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_NonGCC_Intrinsic<
+       [llvm_v64i1_ty], [llvm_v16i32_ty,llvm_v16i32_ty],
+       intr_properties>;
+
+// tag : V6_vgtw
+class Hexagon_custom_v128i1_v32i32v32i32_Intrinsic_128B<
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_NonGCC_Intrinsic<
+       [llvm_v128i1_ty], [llvm_v32i32_ty,llvm_v32i32_ty],
+       intr_properties>;
+
+// tag : V6_vgtw_and
+class Hexagon_custom_v64i1_v64i1v16i32v16i32_Intrinsic<
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_NonGCC_Intrinsic<
+       [llvm_v64i1_ty], [llvm_v64i1_ty,llvm_v16i32_ty,llvm_v16i32_ty],
+       intr_properties>;
+
+// tag : V6_vgtw_and
+class Hexagon_custom_v128i1_v128i1v32i32v32i32_Intrinsic_128B<
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_NonGCC_Intrinsic<
+       [llvm_v128i1_ty], [llvm_v128i1_ty,llvm_v32i32_ty,llvm_v32i32_ty],
+       intr_properties>;
+
+// tag : V6_pred_scalar2
+class Hexagon_custom_v64i1_i32_Intrinsic<
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_NonGCC_Intrinsic<
+       [llvm_v64i1_ty], [llvm_i32_ty],
+       intr_properties>;
+
+// tag : V6_pred_scalar2
+class Hexagon_custom_v128i1_i32_Intrinsic_128B<
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_NonGCC_Intrinsic<
+       [llvm_v128i1_ty], [llvm_i32_ty],
+       intr_properties>;
+
+// tag : V6_shuffeqw
+class Hexagon_custom_v64i1_v64i1v64i1_Intrinsic<
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_NonGCC_Intrinsic<
+       [llvm_v64i1_ty], [llvm_v64i1_ty,llvm_v64i1_ty],
+       intr_properties>;
+
+// tag : V6_shuffeqw
+class Hexagon_custom_v128i1_v128i1v128i1_Intrinsic_128B<
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_NonGCC_Intrinsic<
+       [llvm_v128i1_ty], [llvm_v128i1_ty,llvm_v128i1_ty],
+       intr_properties>;
+
+// tag : V6_pred_not
+class Hexagon_custom_v64i1_v64i1_Intrinsic<
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_NonGCC_Intrinsic<
+       [llvm_v64i1_ty], [llvm_v64i1_ty],
+       intr_properties>;
+
+// tag : V6_pred_not
+class Hexagon_custom_v128i1_v128i1_Intrinsic_128B<
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_NonGCC_Intrinsic<
+       [llvm_v128i1_ty], [llvm_v128i1_ty],
+       intr_properties>;
+
+// tag : V6_vswap
+class Hexagon_custom_v32i32_v64i1v16i32v16i32_Intrinsic<
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_NonGCC_Intrinsic<
+       [llvm_v32i32_ty], [llvm_v64i1_ty,llvm_v16i32_ty,llvm_v16i32_ty],
+       intr_properties>;
+
+// tag : V6_vswap
+class Hexagon_custom_v64i32_v128i1v32i32v32i32_Intrinsic_128B<
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_NonGCC_Intrinsic<
+       [llvm_v64i32_ty], [llvm_v128i1_ty,llvm_v32i32_ty,llvm_v32i32_ty],
+       intr_properties>;
+
+// tag : V6_vshuffvdd
+class Hexagon_v32i32_v16i32v16i32i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_v32i32_ty], [llvm_v16i32_ty,llvm_v16i32_ty,llvm_i32_ty],
+       intr_properties>;
+
+// tag : V6_extractw
+class Hexagon_i32_v16i32i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_i32_ty], [llvm_v16i32_ty,llvm_i32_ty],
+       intr_properties>;
+
+// tag : V6_lvsplatw
+class Hexagon_v16i32_i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_v16i32_ty], [llvm_i32_ty],
+       intr_properties>;
+
+// tag : V6_vlutvvb_oracc
+class Hexagon_v16i32_v16i32v16i32v16i32i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_v16i32_ty], [llvm_v16i32_ty,llvm_v16i32_ty,llvm_v16i32_ty,llvm_i32_ty],
+       intr_properties>;
+
+// tag : V6_vlutvwh_oracc
+class Hexagon_v32i32_v32i32v16i32v16i32i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_v32i32_ty], [llvm_v32i32_ty,llvm_v16i32_ty,llvm_v16i32_ty,llvm_i32_ty],
+       intr_properties>;
+
+// tag : V6_vmpahhsat
+class Hexagon_v16i32_v16i32v16i32i64_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_v16i32_ty], [llvm_v16i32_ty,llvm_v16i32_ty,llvm_i64_ty],
+       intr_properties>;
+
+// tag : V6_vlut4
+class Hexagon_v16i32_v16i32i64_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_v16i32_ty], [llvm_v16i32_ty,llvm_i64_ty],
+       intr_properties>;
+
+// tag : V6_hi
+class Hexagon_v16i32_v32i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [llvm_v16i32_ty], [llvm_v32i32_ty],
+       intr_properties>;
+
+// tag : V6_vgathermw
+class Hexagon__ptri32i32v16i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [], [llvm_ptr_ty,llvm_i32_ty,llvm_i32_ty,llvm_v16i32_ty],
+       intr_properties>;
+
+// tag : V6_vgathermw
+class Hexagon__ptri32i32v32i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [], [llvm_ptr_ty,llvm_i32_ty,llvm_i32_ty,llvm_v32i32_ty],
+       intr_properties>;
+
+// tag : V6_vgathermhw
+class Hexagon__ptri32i32v64i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [], [llvm_ptr_ty,llvm_i32_ty,llvm_i32_ty,llvm_v64i32_ty],
+       intr_properties>;
+
+// tag : V6_vgathermwq
+class Hexagon_custom__ptrv64i1i32i32v16i32_Intrinsic<
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_NonGCC_Intrinsic<
+       [], [llvm_ptr_ty,llvm_v64i1_ty,llvm_i32_ty,llvm_i32_ty,llvm_v16i32_ty],
+       intr_properties>;
+
+// tag : V6_vgathermwq
+class Hexagon_custom__ptrv128i1i32i32v32i32_Intrinsic_128B<
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_NonGCC_Intrinsic<
+       [], [llvm_ptr_ty,llvm_v128i1_ty,llvm_i32_ty,llvm_i32_ty,llvm_v32i32_ty],
+       intr_properties>;
+
+// tag : V6_vgathermhwq
+class Hexagon_custom__ptrv64i1i32i32v32i32_Intrinsic<
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_NonGCC_Intrinsic<
+       [], [llvm_ptr_ty,llvm_v64i1_ty,llvm_i32_ty,llvm_i32_ty,llvm_v32i32_ty],
+       intr_properties>;
+
+// tag : V6_vgathermhwq
+class Hexagon_custom__ptrv128i1i32i32v64i32_Intrinsic_128B<
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_NonGCC_Intrinsic<
+       [], [llvm_ptr_ty,llvm_v128i1_ty,llvm_i32_ty,llvm_i32_ty,llvm_v64i32_ty],
+       intr_properties>;
+
+// tag : V6_vscattermw
+class Hexagon__i32i32v16i32v16i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [], [llvm_i32_ty,llvm_i32_ty,llvm_v16i32_ty,llvm_v16i32_ty],
+       intr_properties>;
+
+// tag : V6_vscattermw
+class Hexagon__i32i32v32i32v32i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [], [llvm_i32_ty,llvm_i32_ty,llvm_v32i32_ty,llvm_v32i32_ty],
+       intr_properties>;
+
+// tag : V6_vscattermwq
+class Hexagon_custom__v64i1i32i32v16i32v16i32_Intrinsic<
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_NonGCC_Intrinsic<
+       [], [llvm_v64i1_ty,llvm_i32_ty,llvm_i32_ty,llvm_v16i32_ty,llvm_v16i32_ty],
+       intr_properties>;
+
+// tag : V6_vscattermwq
+class Hexagon_custom__v128i1i32i32v32i32v32i32_Intrinsic_128B<
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_NonGCC_Intrinsic<
+       [], [llvm_v128i1_ty,llvm_i32_ty,llvm_i32_ty,llvm_v32i32_ty,llvm_v32i32_ty],
+       intr_properties>;
+
+// tag : V6_vscattermhw
+class Hexagon__i32i32v32i32v16i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [], [llvm_i32_ty,llvm_i32_ty,llvm_v32i32_ty,llvm_v16i32_ty],
+       intr_properties>;
+
+// tag : V6_vscattermhw
+class Hexagon__i32i32v64i32v32i32_Intrinsic<string GCCIntSuffix,
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_Intrinsic<GCCIntSuffix,
+       [], [llvm_i32_ty,llvm_i32_ty,llvm_v64i32_ty,llvm_v32i32_ty],
+       intr_properties>;
+
+// tag : V6_vscattermhwq
+class Hexagon_custom__v64i1i32i32v32i32v16i32_Intrinsic<
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_NonGCC_Intrinsic<
+       [], [llvm_v64i1_ty,llvm_i32_ty,llvm_i32_ty,llvm_v32i32_ty,llvm_v16i32_ty],
+       intr_properties>;
+
+// tag : V6_vscattermhwq
+class Hexagon_custom__v128i1i32i32v64i32v32i32_Intrinsic_128B<
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_NonGCC_Intrinsic<
+       [], [llvm_v128i1_ty,llvm_i32_ty,llvm_i32_ty,llvm_v64i32_ty,llvm_v32i32_ty],
+       intr_properties>;
+
+// tag : V6_vprefixqb
+class Hexagon_custom_v16i32_v64i1_Intrinsic<
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_NonGCC_Intrinsic<
+       [llvm_v16i32_ty], [llvm_v64i1_ty],
+       intr_properties>;
+
+// tag : V6_vprefixqb
+class Hexagon_custom_v32i32_v128i1_Intrinsic_128B<
+      list<IntrinsicProperty> intr_properties = [IntrNoMem]>
+  : Hexagon_NonGCC_Intrinsic<
+       [llvm_v32i32_ty], [llvm_v128i1_ty],
+       intr_properties>;
+
+// V5 Scalar Instructions.
+
+def int_hexagon_C2_cmpeq :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_C2_cmpeq">;
+
+def int_hexagon_C2_cmpgt :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_C2_cmpgt">;
+
+def int_hexagon_C2_cmpgtu :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_C2_cmpgtu">;
+
+def int_hexagon_C2_cmpeqp :
+Hexagon_i32_i64i64_Intrinsic<"HEXAGON_C2_cmpeqp">;
+
+def int_hexagon_C2_cmpgtp :
+Hexagon_i32_i64i64_Intrinsic<"HEXAGON_C2_cmpgtp">;
+
+def int_hexagon_C2_cmpgtup :
+Hexagon_i32_i64i64_Intrinsic<"HEXAGON_C2_cmpgtup">;
+
+def int_hexagon_A4_rcmpeqi :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A4_rcmpeqi", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_A4_rcmpneqi :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A4_rcmpneqi", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_A4_rcmpeq :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A4_rcmpeq">;
+
+def int_hexagon_A4_rcmpneq :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A4_rcmpneq">;
+
+def int_hexagon_C2_bitsset :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_C2_bitsset">;
+
+def int_hexagon_C2_bitsclr :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_C2_bitsclr">;
+
+def int_hexagon_C4_nbitsset :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_C4_nbitsset">;
+
+def int_hexagon_C4_nbitsclr :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_C4_nbitsclr">;
+
+def int_hexagon_C2_cmpeqi :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_C2_cmpeqi", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_C2_cmpgti :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_C2_cmpgti", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_C2_cmpgtui :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_C2_cmpgtui", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_C2_cmpgei :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_C2_cmpgei", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_C2_cmpgeui :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_C2_cmpgeui", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_C2_cmplt :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_C2_cmplt">;
+
+def int_hexagon_C2_cmpltu :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_C2_cmpltu">;
+
+def int_hexagon_C2_bitsclri :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_C2_bitsclri", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_C4_nbitsclri :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_C4_nbitsclri", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_C4_cmpneqi :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_C4_cmpneqi", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_C4_cmpltei :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_C4_cmpltei", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_C4_cmplteui :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_C4_cmplteui", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_C4_cmpneq :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_C4_cmpneq">;
+
+def int_hexagon_C4_cmplte :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_C4_cmplte">;
+
+def int_hexagon_C4_cmplteu :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_C4_cmplteu">;
+
+def int_hexagon_C2_and :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_C2_and">;
+
+def int_hexagon_C2_or :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_C2_or">;
+
+def int_hexagon_C2_xor :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_C2_xor">;
+
+def int_hexagon_C2_andn :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_C2_andn">;
+
+def int_hexagon_C2_not :
+Hexagon_i32_i32_Intrinsic<"HEXAGON_C2_not">;
+
+def int_hexagon_C2_orn :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_C2_orn">;
+
+def int_hexagon_C4_and_and :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_C4_and_and">;
+
+def int_hexagon_C4_and_or :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_C4_and_or">;
+
+def int_hexagon_C4_or_and :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_C4_or_and">;
+
+def int_hexagon_C4_or_or :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_C4_or_or">;
+
+def int_hexagon_C4_and_andn :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_C4_and_andn">;
+
+def int_hexagon_C4_and_orn :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_C4_and_orn">;
+
+def int_hexagon_C4_or_andn :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_C4_or_andn">;
+
+def int_hexagon_C4_or_orn :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_C4_or_orn">;
+
+def int_hexagon_C2_pxfer_map :
+Hexagon_i32_i32_Intrinsic<"HEXAGON_C2_pxfer_map">;
+
+def int_hexagon_C2_any8 :
+Hexagon_i32_i32_Intrinsic<"HEXAGON_C2_any8">;
+
+def int_hexagon_C2_all8 :
+Hexagon_i32_i32_Intrinsic<"HEXAGON_C2_all8">;
+
+def int_hexagon_C2_vitpack :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_C2_vitpack">;
+
+def int_hexagon_C2_mux :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_C2_mux">;
+
+def int_hexagon_C2_muxii :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_C2_muxii", [IntrNoMem, ImmArg<ArgIndex<1>>, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_C2_muxir :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_C2_muxir", [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_C2_muxri :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_C2_muxri", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_C2_vmux :
+Hexagon_i64_i32i64i64_Intrinsic<"HEXAGON_C2_vmux">;
+
+def int_hexagon_C2_mask :
+Hexagon_i64_i32_Intrinsic<"HEXAGON_C2_mask">;
+
+def int_hexagon_A2_vcmpbeq :
+Hexagon_i32_i64i64_Intrinsic<"HEXAGON_A2_vcmpbeq">;
+
+def int_hexagon_A4_vcmpbeqi :
+Hexagon_i32_i64i32_Intrinsic<"HEXAGON_A4_vcmpbeqi", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_A4_vcmpbeq_any :
+Hexagon_i32_i64i64_Intrinsic<"HEXAGON_A4_vcmpbeq_any">;
+
+def int_hexagon_A2_vcmpbgtu :
+Hexagon_i32_i64i64_Intrinsic<"HEXAGON_A2_vcmpbgtu">;
+
+def int_hexagon_A4_vcmpbgtui :
+Hexagon_i32_i64i32_Intrinsic<"HEXAGON_A4_vcmpbgtui", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_A4_vcmpbgt :
+Hexagon_i32_i64i64_Intrinsic<"HEXAGON_A4_vcmpbgt">;
+
+def int_hexagon_A4_vcmpbgti :
+Hexagon_i32_i64i32_Intrinsic<"HEXAGON_A4_vcmpbgti", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_A4_cmpbeq :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A4_cmpbeq">;
+
+def int_hexagon_A4_cmpbeqi :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A4_cmpbeqi", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_A4_cmpbgtu :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A4_cmpbgtu">;
+
+def int_hexagon_A4_cmpbgtui :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A4_cmpbgtui", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_A4_cmpbgt :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A4_cmpbgt">;
+
+def int_hexagon_A4_cmpbgti :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A4_cmpbgti", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_A2_vcmpheq :
+Hexagon_i32_i64i64_Intrinsic<"HEXAGON_A2_vcmpheq">;
+
+def int_hexagon_A2_vcmphgt :
+Hexagon_i32_i64i64_Intrinsic<"HEXAGON_A2_vcmphgt">;
+
+def int_hexagon_A2_vcmphgtu :
+Hexagon_i32_i64i64_Intrinsic<"HEXAGON_A2_vcmphgtu">;
+
+def int_hexagon_A4_vcmpheqi :
+Hexagon_i32_i64i32_Intrinsic<"HEXAGON_A4_vcmpheqi", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_A4_vcmphgti :
+Hexagon_i32_i64i32_Intrinsic<"HEXAGON_A4_vcmphgti", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_A4_vcmphgtui :
+Hexagon_i32_i64i32_Intrinsic<"HEXAGON_A4_vcmphgtui", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_A4_cmpheq :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A4_cmpheq">;
+
+def int_hexagon_A4_cmphgt :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A4_cmphgt">;
+
+def int_hexagon_A4_cmphgtu :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A4_cmphgtu">;
+
+def int_hexagon_A4_cmpheqi :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A4_cmpheqi", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_A4_cmphgti :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A4_cmphgti", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_A4_cmphgtui :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A4_cmphgtui", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_A2_vcmpweq :
+Hexagon_i32_i64i64_Intrinsic<"HEXAGON_A2_vcmpweq">;
+
+def int_hexagon_A2_vcmpwgt :
+Hexagon_i32_i64i64_Intrinsic<"HEXAGON_A2_vcmpwgt">;
+
+def int_hexagon_A2_vcmpwgtu :
+Hexagon_i32_i64i64_Intrinsic<"HEXAGON_A2_vcmpwgtu">;
+
+def int_hexagon_A4_vcmpweqi :
+Hexagon_i32_i64i32_Intrinsic<"HEXAGON_A4_vcmpweqi", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_A4_vcmpwgti :
+Hexagon_i32_i64i32_Intrinsic<"HEXAGON_A4_vcmpwgti", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_A4_vcmpwgtui :
+Hexagon_i32_i64i32_Intrinsic<"HEXAGON_A4_vcmpwgtui", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_A4_boundscheck :
+Hexagon_i32_i32i64_Intrinsic<"HEXAGON_A4_boundscheck">;
+
+def int_hexagon_A4_tlbmatch :
+Hexagon_i32_i64i32_Intrinsic<"HEXAGON_A4_tlbmatch">;
+
+def int_hexagon_C2_tfrpr :
+Hexagon_i32_i32_Intrinsic<"HEXAGON_C2_tfrpr">;
+
+def int_hexagon_C2_tfrrp :
+Hexagon_i32_i32_Intrinsic<"HEXAGON_C2_tfrrp">;
+
+def int_hexagon_C4_fastcorner9 :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_C4_fastcorner9">;
+
+def int_hexagon_C4_fastcorner9_not :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_C4_fastcorner9_not">;
+
+def int_hexagon_M2_mpy_acc_hh_s0 :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpy_acc_hh_s0">;
+
+def int_hexagon_M2_mpy_acc_hh_s1 :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpy_acc_hh_s1">;
+
+def int_hexagon_M2_mpy_acc_hl_s0 :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpy_acc_hl_s0">;
+
+def int_hexagon_M2_mpy_acc_hl_s1 :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpy_acc_hl_s1">;
+
+def int_hexagon_M2_mpy_acc_lh_s0 :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpy_acc_lh_s0">;
+
+def int_hexagon_M2_mpy_acc_lh_s1 :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpy_acc_lh_s1">;
+
+def int_hexagon_M2_mpy_acc_ll_s0 :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpy_acc_ll_s0">;
+
+def int_hexagon_M2_mpy_acc_ll_s1 :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpy_acc_ll_s1">;
+
+def int_hexagon_M2_mpy_nac_hh_s0 :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpy_nac_hh_s0">;
+
+def int_hexagon_M2_mpy_nac_hh_s1 :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpy_nac_hh_s1">;
+
+def int_hexagon_M2_mpy_nac_hl_s0 :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpy_nac_hl_s0">;
+
+def int_hexagon_M2_mpy_nac_hl_s1 :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpy_nac_hl_s1">;
+
+def int_hexagon_M2_mpy_nac_lh_s0 :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpy_nac_lh_s0">;
+
+def int_hexagon_M2_mpy_nac_lh_s1 :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpy_nac_lh_s1">;
+
+def int_hexagon_M2_mpy_nac_ll_s0 :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpy_nac_ll_s0">;
+
+def int_hexagon_M2_mpy_nac_ll_s1 :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpy_nac_ll_s1">;
+
+def int_hexagon_M2_mpy_acc_sat_hh_s0 :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpy_acc_sat_hh_s0">;
+
+def int_hexagon_M2_mpy_acc_sat_hh_s1 :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpy_acc_sat_hh_s1">;
+
+def int_hexagon_M2_mpy_acc_sat_hl_s0 :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpy_acc_sat_hl_s0">;
+
+def int_hexagon_M2_mpy_acc_sat_hl_s1 :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpy_acc_sat_hl_s1">;
+
+def int_hexagon_M2_mpy_acc_sat_lh_s0 :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpy_acc_sat_lh_s0">;
+
+def int_hexagon_M2_mpy_acc_sat_lh_s1 :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpy_acc_sat_lh_s1">;
+
+def int_hexagon_M2_mpy_acc_sat_ll_s0 :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpy_acc_sat_ll_s0">;
+
+def int_hexagon_M2_mpy_acc_sat_ll_s1 :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpy_acc_sat_ll_s1">;
+
+def int_hexagon_M2_mpy_nac_sat_hh_s0 :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpy_nac_sat_hh_s0">;
+
+def int_hexagon_M2_mpy_nac_sat_hh_s1 :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpy_nac_sat_hh_s1">;
+
+def int_hexagon_M2_mpy_nac_sat_hl_s0 :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpy_nac_sat_hl_s0">;
+
+def int_hexagon_M2_mpy_nac_sat_hl_s1 :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpy_nac_sat_hl_s1">;
+
+def int_hexagon_M2_mpy_nac_sat_lh_s0 :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpy_nac_sat_lh_s0">;
+
+def int_hexagon_M2_mpy_nac_sat_lh_s1 :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpy_nac_sat_lh_s1">;
+
+def int_hexagon_M2_mpy_nac_sat_ll_s0 :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpy_nac_sat_ll_s0">;
+
+def int_hexagon_M2_mpy_nac_sat_ll_s1 :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpy_nac_sat_ll_s1">;
+
+def int_hexagon_M2_mpy_hh_s0 :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpy_hh_s0">;
+
+def int_hexagon_M2_mpy_hh_s1 :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpy_hh_s1">;
+
+def int_hexagon_M2_mpy_hl_s0 :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpy_hl_s0">;
+
+def int_hexagon_M2_mpy_hl_s1 :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpy_hl_s1">;
+
+def int_hexagon_M2_mpy_lh_s0 :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpy_lh_s0">;
+
+def int_hexagon_M2_mpy_lh_s1 :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpy_lh_s1">;
+
+def int_hexagon_M2_mpy_ll_s0 :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpy_ll_s0">;
+
+def int_hexagon_M2_mpy_ll_s1 :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpy_ll_s1">;
+
+def int_hexagon_M2_mpy_sat_hh_s0 :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpy_sat_hh_s0">;
+
+def int_hexagon_M2_mpy_sat_hh_s1 :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpy_sat_hh_s1">;
+
+def int_hexagon_M2_mpy_sat_hl_s0 :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpy_sat_hl_s0">;
+
+def int_hexagon_M2_mpy_sat_hl_s1 :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpy_sat_hl_s1">;
+
+def int_hexagon_M2_mpy_sat_lh_s0 :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpy_sat_lh_s0">;
+
+def int_hexagon_M2_mpy_sat_lh_s1 :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpy_sat_lh_s1">;
+
+def int_hexagon_M2_mpy_sat_ll_s0 :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpy_sat_ll_s0">;
+
+def int_hexagon_M2_mpy_sat_ll_s1 :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpy_sat_ll_s1">;
+
+def int_hexagon_M2_mpy_rnd_hh_s0 :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpy_rnd_hh_s0">;
+
+def int_hexagon_M2_mpy_rnd_hh_s1 :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpy_rnd_hh_s1">;
+
+def int_hexagon_M2_mpy_rnd_hl_s0 :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpy_rnd_hl_s0">;
+
+def int_hexagon_M2_mpy_rnd_hl_s1 :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpy_rnd_hl_s1">;
+
+def int_hexagon_M2_mpy_rnd_lh_s0 :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpy_rnd_lh_s0">;
+
+def int_hexagon_M2_mpy_rnd_lh_s1 :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpy_rnd_lh_s1">;
+
+def int_hexagon_M2_mpy_rnd_ll_s0 :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpy_rnd_ll_s0">;
+
+def int_hexagon_M2_mpy_rnd_ll_s1 :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpy_rnd_ll_s1">;
+
+def int_hexagon_M2_mpy_sat_rnd_hh_s0 :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpy_sat_rnd_hh_s0">;
+
+def int_hexagon_M2_mpy_sat_rnd_hh_s1 :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpy_sat_rnd_hh_s1">;
+
+def int_hexagon_M2_mpy_sat_rnd_hl_s0 :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpy_sat_rnd_hl_s0">;
+
+def int_hexagon_M2_mpy_sat_rnd_hl_s1 :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpy_sat_rnd_hl_s1">;
+
+def int_hexagon_M2_mpy_sat_rnd_lh_s0 :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpy_sat_rnd_lh_s0">;
+
+def int_hexagon_M2_mpy_sat_rnd_lh_s1 :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpy_sat_rnd_lh_s1">;
+
+def int_hexagon_M2_mpy_sat_rnd_ll_s0 :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpy_sat_rnd_ll_s0">;
+
+def int_hexagon_M2_mpy_sat_rnd_ll_s1 :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpy_sat_rnd_ll_s1">;
+
+def int_hexagon_M2_mpyd_acc_hh_s0 :
+Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_mpyd_acc_hh_s0">;
+
+def int_hexagon_M2_mpyd_acc_hh_s1 :
+Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_mpyd_acc_hh_s1">;
+
+def int_hexagon_M2_mpyd_acc_hl_s0 :
+Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_mpyd_acc_hl_s0">;
+
+def int_hexagon_M2_mpyd_acc_hl_s1 :
+Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_mpyd_acc_hl_s1">;
+
+def int_hexagon_M2_mpyd_acc_lh_s0 :
+Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_mpyd_acc_lh_s0">;
+
+def int_hexagon_M2_mpyd_acc_lh_s1 :
+Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_mpyd_acc_lh_s1">;
+
+def int_hexagon_M2_mpyd_acc_ll_s0 :
+Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_mpyd_acc_ll_s0">;
+
+def int_hexagon_M2_mpyd_acc_ll_s1 :
+Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_mpyd_acc_ll_s1">;
+
+def int_hexagon_M2_mpyd_nac_hh_s0 :
+Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_mpyd_nac_hh_s0">;
+
+def int_hexagon_M2_mpyd_nac_hh_s1 :
+Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_mpyd_nac_hh_s1">;
+
+def int_hexagon_M2_mpyd_nac_hl_s0 :
+Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_mpyd_nac_hl_s0">;
+
+def int_hexagon_M2_mpyd_nac_hl_s1 :
+Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_mpyd_nac_hl_s1">;
+
+def int_hexagon_M2_mpyd_nac_lh_s0 :
+Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_mpyd_nac_lh_s0">;
+
+def int_hexagon_M2_mpyd_nac_lh_s1 :
+Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_mpyd_nac_lh_s1">;
+
+def int_hexagon_M2_mpyd_nac_ll_s0 :
+Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_mpyd_nac_ll_s0">;
+
+def int_hexagon_M2_mpyd_nac_ll_s1 :
+Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_mpyd_nac_ll_s1">;
+
+def int_hexagon_M2_mpyd_hh_s0 :
+Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_mpyd_hh_s0">;
+
+def int_hexagon_M2_mpyd_hh_s1 :
+Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_mpyd_hh_s1">;
+
+def int_hexagon_M2_mpyd_hl_s0 :
+Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_mpyd_hl_s0">;
+
+def int_hexagon_M2_mpyd_hl_s1 :
+Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_mpyd_hl_s1">;
+
+def int_hexagon_M2_mpyd_lh_s0 :
+Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_mpyd_lh_s0">;
+
+def int_hexagon_M2_mpyd_lh_s1 :
+Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_mpyd_lh_s1">;
+
+def int_hexagon_M2_mpyd_ll_s0 :
+Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_mpyd_ll_s0">;
+
+def int_hexagon_M2_mpyd_ll_s1 :
+Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_mpyd_ll_s1">;
+
+def int_hexagon_M2_mpyd_rnd_hh_s0 :
+Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_mpyd_rnd_hh_s0">;
+
+def int_hexagon_M2_mpyd_rnd_hh_s1 :
+Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_mpyd_rnd_hh_s1">;
+
+def int_hexagon_M2_mpyd_rnd_hl_s0 :
+Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_mpyd_rnd_hl_s0">;
+
+def int_hexagon_M2_mpyd_rnd_hl_s1 :
+Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_mpyd_rnd_hl_s1">;
+
+def int_hexagon_M2_mpyd_rnd_lh_s0 :
+Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_mpyd_rnd_lh_s0">;
+
+def int_hexagon_M2_mpyd_rnd_lh_s1 :
+Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_mpyd_rnd_lh_s1">;
+
+def int_hexagon_M2_mpyd_rnd_ll_s0 :
+Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_mpyd_rnd_ll_s0">;
+
+def int_hexagon_M2_mpyd_rnd_ll_s1 :
+Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_mpyd_rnd_ll_s1">;
+
+def int_hexagon_M2_mpyu_acc_hh_s0 :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpyu_acc_hh_s0">;
+
+def int_hexagon_M2_mpyu_acc_hh_s1 :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpyu_acc_hh_s1">;
+
+def int_hexagon_M2_mpyu_acc_hl_s0 :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpyu_acc_hl_s0">;
+
+def int_hexagon_M2_mpyu_acc_hl_s1 :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpyu_acc_hl_s1">;
+
+def int_hexagon_M2_mpyu_acc_lh_s0 :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpyu_acc_lh_s0">;
+
+def int_hexagon_M2_mpyu_acc_lh_s1 :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpyu_acc_lh_s1">;
+
+def int_hexagon_M2_mpyu_acc_ll_s0 :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpyu_acc_ll_s0">;
+
+def int_hexagon_M2_mpyu_acc_ll_s1 :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpyu_acc_ll_s1">;
+
+def int_hexagon_M2_mpyu_nac_hh_s0 :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpyu_nac_hh_s0">;
+
+def int_hexagon_M2_mpyu_nac_hh_s1 :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpyu_nac_hh_s1">;
+
+def int_hexagon_M2_mpyu_nac_hl_s0 :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpyu_nac_hl_s0">;
+
+def int_hexagon_M2_mpyu_nac_hl_s1 :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpyu_nac_hl_s1">;
+
+def int_hexagon_M2_mpyu_nac_lh_s0 :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpyu_nac_lh_s0">;
+
+def int_hexagon_M2_mpyu_nac_lh_s1 :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpyu_nac_lh_s1">;
+
+def int_hexagon_M2_mpyu_nac_ll_s0 :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpyu_nac_ll_s0">;
+
+def int_hexagon_M2_mpyu_nac_ll_s1 :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mpyu_nac_ll_s1">;
+
+def int_hexagon_M2_mpyu_hh_s0 :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpyu_hh_s0">;
+
+def int_hexagon_M2_mpyu_hh_s1 :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpyu_hh_s1">;
+
+def int_hexagon_M2_mpyu_hl_s0 :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpyu_hl_s0">;
+
+def int_hexagon_M2_mpyu_hl_s1 :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpyu_hl_s1">;
+
+def int_hexagon_M2_mpyu_lh_s0 :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpyu_lh_s0">;
+
+def int_hexagon_M2_mpyu_lh_s1 :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpyu_lh_s1">;
+
+def int_hexagon_M2_mpyu_ll_s0 :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpyu_ll_s0">;
+
+def int_hexagon_M2_mpyu_ll_s1 :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpyu_ll_s1">;
+
+def int_hexagon_M2_mpyud_acc_hh_s0 :
+Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_mpyud_acc_hh_s0">;
+
+def int_hexagon_M2_mpyud_acc_hh_s1 :
+Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_mpyud_acc_hh_s1">;
+
+def int_hexagon_M2_mpyud_acc_hl_s0 :
+Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_mpyud_acc_hl_s0">;
+
+def int_hexagon_M2_mpyud_acc_hl_s1 :
+Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_mpyud_acc_hl_s1">;
+
+def int_hexagon_M2_mpyud_acc_lh_s0 :
+Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_mpyud_acc_lh_s0">;
+
+def int_hexagon_M2_mpyud_acc_lh_s1 :
+Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_mpyud_acc_lh_s1">;
+
+def int_hexagon_M2_mpyud_acc_ll_s0 :
+Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_mpyud_acc_ll_s0">;
+
+def int_hexagon_M2_mpyud_acc_ll_s1 :
+Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_mpyud_acc_ll_s1">;
+
+def int_hexagon_M2_mpyud_nac_hh_s0 :
+Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_mpyud_nac_hh_s0">;
+
+def int_hexagon_M2_mpyud_nac_hh_s1 :
+Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_mpyud_nac_hh_s1">;
+
+def int_hexagon_M2_mpyud_nac_hl_s0 :
+Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_mpyud_nac_hl_s0">;
+
+def int_hexagon_M2_mpyud_nac_hl_s1 :
+Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_mpyud_nac_hl_s1">;
+
+def int_hexagon_M2_mpyud_nac_lh_s0 :
+Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_mpyud_nac_lh_s0">;
+
+def int_hexagon_M2_mpyud_nac_lh_s1 :
+Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_mpyud_nac_lh_s1">;
+
+def int_hexagon_M2_mpyud_nac_ll_s0 :
+Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_mpyud_nac_ll_s0">;
+
+def int_hexagon_M2_mpyud_nac_ll_s1 :
+Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_mpyud_nac_ll_s1">;
+
+def int_hexagon_M2_mpyud_hh_s0 :
+Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_mpyud_hh_s0">;
+
+def int_hexagon_M2_mpyud_hh_s1 :
+Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_mpyud_hh_s1">;
+
+def int_hexagon_M2_mpyud_hl_s0 :
+Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_mpyud_hl_s0">;
+
+def int_hexagon_M2_mpyud_hl_s1 :
+Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_mpyud_hl_s1">;
+
+def int_hexagon_M2_mpyud_lh_s0 :
+Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_mpyud_lh_s0">;
+
+def int_hexagon_M2_mpyud_lh_s1 :
+Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_mpyud_lh_s1">;
+
+def int_hexagon_M2_mpyud_ll_s0 :
+Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_mpyud_ll_s0">;
+
+def int_hexagon_M2_mpyud_ll_s1 :
+Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_mpyud_ll_s1">;
+
+def int_hexagon_M2_mpysmi :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpysmi", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_M2_macsip :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_macsip", [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_M2_macsin :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_macsin", [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_M2_dpmpyss_s0 :
+Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_dpmpyss_s0">;
+
+def int_hexagon_M2_dpmpyss_acc_s0 :
+Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_dpmpyss_acc_s0">;
+
+def int_hexagon_M2_dpmpyss_nac_s0 :
+Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_dpmpyss_nac_s0">;
+
+def int_hexagon_M2_dpmpyuu_s0 :
+Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_dpmpyuu_s0">;
+
+def int_hexagon_M2_dpmpyuu_acc_s0 :
+Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_dpmpyuu_acc_s0">;
+
+def int_hexagon_M2_dpmpyuu_nac_s0 :
+Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_dpmpyuu_nac_s0">;
+
+def int_hexagon_M2_mpy_up :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpy_up">;
+
+def int_hexagon_M2_mpy_up_s1 :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpy_up_s1">;
+
+def int_hexagon_M2_mpy_up_s1_sat :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpy_up_s1_sat">;
+
+def int_hexagon_M2_mpyu_up :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpyu_up">;
+
+def int_hexagon_M2_mpysu_up :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpysu_up">;
+
+def int_hexagon_M2_dpmpyss_rnd_s0 :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_dpmpyss_rnd_s0">;
+
+def int_hexagon_M4_mac_up_s1_sat :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M4_mac_up_s1_sat">;
+
+def int_hexagon_M4_nac_up_s1_sat :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M4_nac_up_s1_sat">;
+
+def int_hexagon_M2_mpyi :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpyi">;
+
+def int_hexagon_M2_mpyui :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_mpyui">;
+
+def int_hexagon_M2_maci :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_maci">;
+
+def int_hexagon_M2_acci :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_acci">;
+
+def int_hexagon_M2_accii :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_accii", [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_M2_nacci :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_nacci">;
+
+def int_hexagon_M2_naccii :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_naccii", [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_M2_subacc :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_subacc">;
+
+def int_hexagon_M4_mpyrr_addr :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M4_mpyrr_addr">;
+
+def int_hexagon_M4_mpyri_addr_u2 :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M4_mpyri_addr_u2", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_M4_mpyri_addr :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M4_mpyri_addr", [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_M4_mpyri_addi :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M4_mpyri_addi", [IntrNoMem, ImmArg<ArgIndex<0>>, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_M4_mpyrr_addi :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M4_mpyrr_addi", [IntrNoMem, ImmArg<ArgIndex<0>>]>;
+
+def int_hexagon_M2_vmpy2s_s0 :
+Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_vmpy2s_s0">;
+
+def int_hexagon_M2_vmpy2s_s1 :
+Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_vmpy2s_s1">;
+
+def int_hexagon_M2_vmac2s_s0 :
+Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_vmac2s_s0">;
+
+def int_hexagon_M2_vmac2s_s1 :
+Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_vmac2s_s1">;
+
+def int_hexagon_M2_vmpy2su_s0 :
+Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_vmpy2su_s0">;
+
+def int_hexagon_M2_vmpy2su_s1 :
+Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_vmpy2su_s1">;
+
+def int_hexagon_M2_vmac2su_s0 :
+Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_vmac2su_s0">;
+
+def int_hexagon_M2_vmac2su_s1 :
+Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_vmac2su_s1">;
+
+def int_hexagon_M2_vmpy2s_s0pack :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_vmpy2s_s0pack">;
+
+def int_hexagon_M2_vmpy2s_s1pack :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_vmpy2s_s1pack">;
+
+def int_hexagon_M2_vmac2 :
+Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_vmac2">;
+
+def int_hexagon_M2_vmpy2es_s0 :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M2_vmpy2es_s0">;
+
+def int_hexagon_M2_vmpy2es_s1 :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M2_vmpy2es_s1">;
+
+def int_hexagon_M2_vmac2es_s0 :
+Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M2_vmac2es_s0">;
+
+def int_hexagon_M2_vmac2es_s1 :
+Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M2_vmac2es_s1">;
+
+def int_hexagon_M2_vmac2es :
+Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M2_vmac2es">;
+
+def int_hexagon_M2_vrmac_s0 :
+Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M2_vrmac_s0">;
+
+def int_hexagon_M2_vrmpy_s0 :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M2_vrmpy_s0">;
+
+def int_hexagon_M2_vdmpyrs_s0 :
+Hexagon_i32_i64i64_Intrinsic<"HEXAGON_M2_vdmpyrs_s0">;
+
+def int_hexagon_M2_vdmpyrs_s1 :
+Hexagon_i32_i64i64_Intrinsic<"HEXAGON_M2_vdmpyrs_s1">;
+
+def int_hexagon_M5_vrmpybuu :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M5_vrmpybuu">;
+
+def int_hexagon_M5_vrmacbuu :
+Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M5_vrmacbuu">;
+
+def int_hexagon_M5_vrmpybsu :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M5_vrmpybsu">;
+
+def int_hexagon_M5_vrmacbsu :
+Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M5_vrmacbsu">;
+
+def int_hexagon_M5_vmpybuu :
+Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M5_vmpybuu">;
+
+def int_hexagon_M5_vmpybsu :
+Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M5_vmpybsu">;
+
+def int_hexagon_M5_vmacbuu :
+Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M5_vmacbuu">;
+
+def int_hexagon_M5_vmacbsu :
+Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M5_vmacbsu">;
+
+def int_hexagon_M5_vdmpybsu :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M5_vdmpybsu">;
+
+def int_hexagon_M5_vdmacbsu :
+Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M5_vdmacbsu">;
+
+def int_hexagon_M2_vdmacs_s0 :
+Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M2_vdmacs_s0">;
+
+def int_hexagon_M2_vdmacs_s1 :
+Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M2_vdmacs_s1">;
+
+def int_hexagon_M2_vdmpys_s0 :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M2_vdmpys_s0">;
+
+def int_hexagon_M2_vdmpys_s1 :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M2_vdmpys_s1">;
+
+def int_hexagon_M2_cmpyrs_s0 :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_cmpyrs_s0">;
+
+def int_hexagon_M2_cmpyrs_s1 :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_cmpyrs_s1">;
+
+def int_hexagon_M2_cmpyrsc_s0 :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_cmpyrsc_s0">;
+
+def int_hexagon_M2_cmpyrsc_s1 :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_cmpyrsc_s1">;
+
+def int_hexagon_M2_cmacs_s0 :
+Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_cmacs_s0">;
+
+def int_hexagon_M2_cmacs_s1 :
+Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_cmacs_s1">;
+
+def int_hexagon_M2_cmacsc_s0 :
+Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_cmacsc_s0">;
+
+def int_hexagon_M2_cmacsc_s1 :
+Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_cmacsc_s1">;
+
+def int_hexagon_M2_cmpys_s0 :
+Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_cmpys_s0">;
+
+def int_hexagon_M2_cmpys_s1 :
+Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_cmpys_s1">;
+
+def int_hexagon_M2_cmpysc_s0 :
+Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_cmpysc_s0">;
+
+def int_hexagon_M2_cmpysc_s1 :
+Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_cmpysc_s1">;
+
+def int_hexagon_M2_cnacs_s0 :
+Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_cnacs_s0">;
+
+def int_hexagon_M2_cnacs_s1 :
+Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_cnacs_s1">;
+
+def int_hexagon_M2_cnacsc_s0 :
+Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_cnacsc_s0">;
+
+def int_hexagon_M2_cnacsc_s1 :
+Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_cnacsc_s1">;
+
+def int_hexagon_M2_vrcmpys_s1 :
+Hexagon_i64_i64i32_Intrinsic<"HEXAGON_M2_vrcmpys_s1">;
+
+def int_hexagon_M2_vrcmpys_acc_s1 :
+Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_M2_vrcmpys_acc_s1">;
+
+def int_hexagon_M2_vrcmpys_s1rp :
+Hexagon_i32_i64i32_Intrinsic<"HEXAGON_M2_vrcmpys_s1rp">;
+
+def int_hexagon_M2_mmacls_s0 :
+Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M2_mmacls_s0">;
+
+def int_hexagon_M2_mmacls_s1 :
+Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M2_mmacls_s1">;
+
+def int_hexagon_M2_mmachs_s0 :
+Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M2_mmachs_s0">;
+
+def int_hexagon_M2_mmachs_s1 :
+Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M2_mmachs_s1">;
+
+def int_hexagon_M2_mmpyl_s0 :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M2_mmpyl_s0">;
+
+def int_hexagon_M2_mmpyl_s1 :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M2_mmpyl_s1">;
+
+def int_hexagon_M2_mmpyh_s0 :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M2_mmpyh_s0">;
+
+def int_hexagon_M2_mmpyh_s1 :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M2_mmpyh_s1">;
+
+def int_hexagon_M2_mmacls_rs0 :
+Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M2_mmacls_rs0">;
+
+def int_hexagon_M2_mmacls_rs1 :
+Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M2_mmacls_rs1">;
+
+def int_hexagon_M2_mmachs_rs0 :
+Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M2_mmachs_rs0">;
+
+def int_hexagon_M2_mmachs_rs1 :
+Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M2_mmachs_rs1">;
+
+def int_hexagon_M2_mmpyl_rs0 :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M2_mmpyl_rs0">;
+
+def int_hexagon_M2_mmpyl_rs1 :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M2_mmpyl_rs1">;
+
+def int_hexagon_M2_mmpyh_rs0 :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M2_mmpyh_rs0">;
+
+def int_hexagon_M2_mmpyh_rs1 :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M2_mmpyh_rs1">;
+
+def int_hexagon_M4_vrmpyeh_s0 :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M4_vrmpyeh_s0">;
+
+def int_hexagon_M4_vrmpyeh_s1 :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M4_vrmpyeh_s1">;
+
+def int_hexagon_M4_vrmpyeh_acc_s0 :
+Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M4_vrmpyeh_acc_s0">;
+
+def int_hexagon_M4_vrmpyeh_acc_s1 :
+Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M4_vrmpyeh_acc_s1">;
+
+def int_hexagon_M4_vrmpyoh_s0 :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M4_vrmpyoh_s0">;
+
+def int_hexagon_M4_vrmpyoh_s1 :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M4_vrmpyoh_s1">;
+
+def int_hexagon_M4_vrmpyoh_acc_s0 :
+Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M4_vrmpyoh_acc_s0">;
+
+def int_hexagon_M4_vrmpyoh_acc_s1 :
+Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M4_vrmpyoh_acc_s1">;
+
+def int_hexagon_M2_hmmpyl_rs1 :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_hmmpyl_rs1">;
+
+def int_hexagon_M2_hmmpyh_rs1 :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_hmmpyh_rs1">;
+
+def int_hexagon_M2_hmmpyl_s1 :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_hmmpyl_s1">;
+
+def int_hexagon_M2_hmmpyh_s1 :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_M2_hmmpyh_s1">;
+
+def int_hexagon_M2_mmaculs_s0 :
+Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M2_mmaculs_s0">;
+
+def int_hexagon_M2_mmaculs_s1 :
+Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M2_mmaculs_s1">;
+
+def int_hexagon_M2_mmacuhs_s0 :
+Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M2_mmacuhs_s0">;
+
+def int_hexagon_M2_mmacuhs_s1 :
+Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M2_mmacuhs_s1">;
+
+def int_hexagon_M2_mmpyul_s0 :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M2_mmpyul_s0">;
+
+def int_hexagon_M2_mmpyul_s1 :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M2_mmpyul_s1">;
+
+def int_hexagon_M2_mmpyuh_s0 :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M2_mmpyuh_s0">;
+
+def int_hexagon_M2_mmpyuh_s1 :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M2_mmpyuh_s1">;
+
+def int_hexagon_M2_mmaculs_rs0 :
+Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M2_mmaculs_rs0">;
+
+def int_hexagon_M2_mmaculs_rs1 :
+Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M2_mmaculs_rs1">;
+
+def int_hexagon_M2_mmacuhs_rs0 :
+Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M2_mmacuhs_rs0">;
+
+def int_hexagon_M2_mmacuhs_rs1 :
+Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M2_mmacuhs_rs1">;
+
+def int_hexagon_M2_mmpyul_rs0 :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M2_mmpyul_rs0">;
+
+def int_hexagon_M2_mmpyul_rs1 :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M2_mmpyul_rs1">;
+
+def int_hexagon_M2_mmpyuh_rs0 :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M2_mmpyuh_rs0">;
+
+def int_hexagon_M2_mmpyuh_rs1 :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M2_mmpyuh_rs1">;
+
+def int_hexagon_M2_vrcmaci_s0 :
+Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M2_vrcmaci_s0">;
+
+def int_hexagon_M2_vrcmacr_s0 :
+Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M2_vrcmacr_s0">;
+
+def int_hexagon_M2_vrcmaci_s0c :
+Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M2_vrcmaci_s0c">;
+
+def int_hexagon_M2_vrcmacr_s0c :
+Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M2_vrcmacr_s0c">;
+
+def int_hexagon_M2_cmaci_s0 :
+Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_cmaci_s0">;
+
+def int_hexagon_M2_cmacr_s0 :
+Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M2_cmacr_s0">;
+
+def int_hexagon_M2_vrcmpyi_s0 :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M2_vrcmpyi_s0">;
+
+def int_hexagon_M2_vrcmpyr_s0 :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M2_vrcmpyr_s0">;
+
+def int_hexagon_M2_vrcmpyi_s0c :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M2_vrcmpyi_s0c">;
+
+def int_hexagon_M2_vrcmpyr_s0c :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M2_vrcmpyr_s0c">;
+
+def int_hexagon_M2_cmpyi_s0 :
+Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_cmpyi_s0">;
+
+def int_hexagon_M2_cmpyr_s0 :
+Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M2_cmpyr_s0">;
+
+def int_hexagon_M4_cmpyi_wh :
+Hexagon_i32_i64i32_Intrinsic<"HEXAGON_M4_cmpyi_wh">;
+
+def int_hexagon_M4_cmpyr_wh :
+Hexagon_i32_i64i32_Intrinsic<"HEXAGON_M4_cmpyr_wh">;
+
+def int_hexagon_M4_cmpyi_whc :
+Hexagon_i32_i64i32_Intrinsic<"HEXAGON_M4_cmpyi_whc">;
+
+def int_hexagon_M4_cmpyr_whc :
+Hexagon_i32_i64i32_Intrinsic<"HEXAGON_M4_cmpyr_whc">;
+
+def int_hexagon_M2_vcmpy_s0_sat_i :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M2_vcmpy_s0_sat_i">;
+
+def int_hexagon_M2_vcmpy_s0_sat_r :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M2_vcmpy_s0_sat_r">;
+
+def int_hexagon_M2_vcmpy_s1_sat_i :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M2_vcmpy_s1_sat_i">;
+
+def int_hexagon_M2_vcmpy_s1_sat_r :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M2_vcmpy_s1_sat_r">;
+
+def int_hexagon_M2_vcmac_s0_sat_i :
+Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M2_vcmac_s0_sat_i">;
+
+def int_hexagon_M2_vcmac_s0_sat_r :
+Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M2_vcmac_s0_sat_r">;
+
+def int_hexagon_S2_vcrotate :
+Hexagon_i64_i64i32_Intrinsic<"HEXAGON_S2_vcrotate">;
+
+def int_hexagon_S4_vrcrotate_acc :
+Hexagon_i64_i64i64i32i32_Intrinsic<"HEXAGON_S4_vrcrotate_acc", [IntrNoMem, ImmArg<ArgIndex<3>>]>;
+
+def int_hexagon_S4_vrcrotate :
+Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_S4_vrcrotate", [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_S2_vcnegh :
+Hexagon_i64_i64i32_Intrinsic<"HEXAGON_S2_vcnegh">;
+
+def int_hexagon_S2_vrcnegh :
+Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_vrcnegh">;
+
+def int_hexagon_M4_pmpyw :
+Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M4_pmpyw">;
+
+def int_hexagon_M4_vpmpyh :
+Hexagon_i64_i32i32_Intrinsic<"HEXAGON_M4_vpmpyh">;
+
+def int_hexagon_M4_pmpyw_acc :
+Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M4_pmpyw_acc">;
+
+def int_hexagon_M4_vpmpyh_acc :
+Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_M4_vpmpyh_acc">;
+
+def int_hexagon_A2_add :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_add">;
+
+def int_hexagon_A2_sub :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_sub">;
+
+def int_hexagon_A2_addsat :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_addsat">;
+
+def int_hexagon_A2_subsat :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_subsat">;
+
+def int_hexagon_A2_addi :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_addi", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_A2_addh_l16_ll :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_addh_l16_ll">;
+
+def int_hexagon_A2_addh_l16_hl :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_addh_l16_hl">;
+
+def int_hexagon_A2_addh_l16_sat_ll :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_addh_l16_sat_ll">;
+
+def int_hexagon_A2_addh_l16_sat_hl :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_addh_l16_sat_hl">;
+
+def int_hexagon_A2_subh_l16_ll :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_subh_l16_ll">;
+
+def int_hexagon_A2_subh_l16_hl :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_subh_l16_hl">;
+
+def int_hexagon_A2_subh_l16_sat_ll :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_subh_l16_sat_ll">;
+
+def int_hexagon_A2_subh_l16_sat_hl :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_subh_l16_sat_hl">;
+
+def int_hexagon_A2_addh_h16_ll :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_addh_h16_ll">;
+
+def int_hexagon_A2_addh_h16_lh :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_addh_h16_lh">;
+
+def int_hexagon_A2_addh_h16_hl :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_addh_h16_hl">;
+
+def int_hexagon_A2_addh_h16_hh :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_addh_h16_hh">;
+
+def int_hexagon_A2_addh_h16_sat_ll :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_addh_h16_sat_ll">;
+
+def int_hexagon_A2_addh_h16_sat_lh :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_addh_h16_sat_lh">;
+
+def int_hexagon_A2_addh_h16_sat_hl :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_addh_h16_sat_hl">;
+
+def int_hexagon_A2_addh_h16_sat_hh :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_addh_h16_sat_hh">;
+
+def int_hexagon_A2_subh_h16_ll :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_subh_h16_ll">;
+
+def int_hexagon_A2_subh_h16_lh :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_subh_h16_lh">;
+
+def int_hexagon_A2_subh_h16_hl :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_subh_h16_hl">;
+
+def int_hexagon_A2_subh_h16_hh :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_subh_h16_hh">;
+
+def int_hexagon_A2_subh_h16_sat_ll :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_subh_h16_sat_ll">;
+
+def int_hexagon_A2_subh_h16_sat_lh :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_subh_h16_sat_lh">;
+
+def int_hexagon_A2_subh_h16_sat_hl :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_subh_h16_sat_hl">;
+
+def int_hexagon_A2_subh_h16_sat_hh :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_subh_h16_sat_hh">;
+
+def int_hexagon_A2_aslh :
+Hexagon_i32_i32_Intrinsic<"HEXAGON_A2_aslh">;
+
+def int_hexagon_A2_asrh :
+Hexagon_i32_i32_Intrinsic<"HEXAGON_A2_asrh">;
+
+def int_hexagon_A2_addp :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_addp">;
+
+def int_hexagon_A2_addpsat :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_addpsat">;
+
+def int_hexagon_A2_addsp :
+Hexagon_i64_i32i64_Intrinsic<"HEXAGON_A2_addsp">;
+
+def int_hexagon_A2_subp :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_subp">;
+
+def int_hexagon_A2_neg :
+Hexagon_i32_i32_Intrinsic<"HEXAGON_A2_neg">;
+
+def int_hexagon_A2_negsat :
+Hexagon_i32_i32_Intrinsic<"HEXAGON_A2_negsat">;
+
+def int_hexagon_A2_abs :
+Hexagon_i32_i32_Intrinsic<"HEXAGON_A2_abs">;
+
+def int_hexagon_A2_abssat :
+Hexagon_i32_i32_Intrinsic<"HEXAGON_A2_abssat">;
+
+def int_hexagon_A2_vconj :
+Hexagon_i64_i64_Intrinsic<"HEXAGON_A2_vconj">;
+
+def int_hexagon_A2_negp :
+Hexagon_i64_i64_Intrinsic<"HEXAGON_A2_negp">;
+
+def int_hexagon_A2_absp :
+Hexagon_i64_i64_Intrinsic<"HEXAGON_A2_absp">;
+
+def int_hexagon_A2_max :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_max">;
+
+def int_hexagon_A2_maxu :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_maxu">;
+
+def int_hexagon_A2_min :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_min">;
+
+def int_hexagon_A2_minu :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_minu">;
+
+def int_hexagon_A2_maxp :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_maxp">;
+
+def int_hexagon_A2_maxup :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_maxup">;
+
+def int_hexagon_A2_minp :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_minp">;
+
+def int_hexagon_A2_minup :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_minup">;
+
+def int_hexagon_A2_tfr :
+Hexagon_i32_i32_Intrinsic<"HEXAGON_A2_tfr">;
+
+def int_hexagon_A2_tfrsi :
+Hexagon_i32_i32_Intrinsic<"HEXAGON_A2_tfrsi", [IntrNoMem, ImmArg<ArgIndex<0>>]>;
+
+def int_hexagon_A2_tfrp :
+Hexagon_i64_i64_Intrinsic<"HEXAGON_A2_tfrp">;
+
+def int_hexagon_A2_tfrpi :
+Hexagon_i64_i32_Intrinsic<"HEXAGON_A2_tfrpi", [IntrNoMem, ImmArg<ArgIndex<0>>]>;
+
+def int_hexagon_A2_zxtb :
+Hexagon_i32_i32_Intrinsic<"HEXAGON_A2_zxtb">;
+
+def int_hexagon_A2_sxtb :
+Hexagon_i32_i32_Intrinsic<"HEXAGON_A2_sxtb">;
+
+def int_hexagon_A2_zxth :
+Hexagon_i32_i32_Intrinsic<"HEXAGON_A2_zxth">;
+
+def int_hexagon_A2_sxth :
+Hexagon_i32_i32_Intrinsic<"HEXAGON_A2_sxth">;
+
+def int_hexagon_A2_combinew :
+Hexagon_i64_i32i32_Intrinsic<"HEXAGON_A2_combinew">;
+
+def int_hexagon_A4_combineri :
+Hexagon_i64_i32i32_Intrinsic<"HEXAGON_A4_combineri", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_A4_combineir :
+Hexagon_i64_i32i32_Intrinsic<"HEXAGON_A4_combineir", [IntrNoMem, ImmArg<ArgIndex<0>>]>;
+
+def int_hexagon_A2_combineii :
+Hexagon_i64_i32i32_Intrinsic<"HEXAGON_A2_combineii", [IntrNoMem, ImmArg<ArgIndex<0>>, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_A2_combine_hh :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_combine_hh">;
+
+def int_hexagon_A2_combine_hl :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_combine_hl">;
+
+def int_hexagon_A2_combine_lh :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_combine_lh">;
+
+def int_hexagon_A2_combine_ll :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_combine_ll">;
+
+def int_hexagon_A2_tfril :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_tfril", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_A2_tfrih :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_tfrih", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_A2_and :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_and">;
+
+def int_hexagon_A2_or :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_or">;
+
+def int_hexagon_A2_xor :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_xor">;
+
+def int_hexagon_A2_not :
+Hexagon_i32_i32_Intrinsic<"HEXAGON_A2_not">;
+
+def int_hexagon_M2_xor_xacc :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_xor_xacc">;
+
+def int_hexagon_M4_xor_xacc :
+Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M4_xor_xacc">;
+
+def int_hexagon_A4_andn :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A4_andn">;
+
+def int_hexagon_A4_orn :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A4_orn">;
+
+def int_hexagon_A4_andnp :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A4_andnp">;
+
+def int_hexagon_A4_ornp :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A4_ornp">;
+
+def int_hexagon_S4_addaddi :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S4_addaddi", [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_S4_subaddi :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S4_subaddi", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_M4_and_and :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M4_and_and">;
+
+def int_hexagon_M4_and_andn :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M4_and_andn">;
+
+def int_hexagon_M4_and_or :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M4_and_or">;
+
+def int_hexagon_M4_and_xor :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M4_and_xor">;
+
+def int_hexagon_M4_or_and :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M4_or_and">;
+
+def int_hexagon_M4_or_andn :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M4_or_andn">;
+
+def int_hexagon_M4_or_or :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M4_or_or">;
+
+def int_hexagon_M4_or_xor :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M4_or_xor">;
+
+def int_hexagon_S4_or_andix :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S4_or_andix", [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_S4_or_andi :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S4_or_andi", [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_S4_or_ori :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S4_or_ori", [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_M4_xor_and :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M4_xor_and">;
+
+def int_hexagon_M4_xor_or :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M4_xor_or">;
+
+def int_hexagon_M4_xor_andn :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M4_xor_andn">;
+
+def int_hexagon_A2_subri :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_subri", [IntrNoMem, ImmArg<ArgIndex<0>>]>;
+
+def int_hexagon_A2_andir :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_andir", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_A2_orir :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_orir", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_A2_andp :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_andp">;
+
+def int_hexagon_A2_orp :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_orp">;
+
+def int_hexagon_A2_xorp :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_xorp">;
+
+def int_hexagon_A2_notp :
+Hexagon_i64_i64_Intrinsic<"HEXAGON_A2_notp">;
+
+def int_hexagon_A2_sxtw :
+Hexagon_i64_i32_Intrinsic<"HEXAGON_A2_sxtw">;
+
+def int_hexagon_A2_sat :
+Hexagon_i32_i64_Intrinsic<"HEXAGON_A2_sat">;
+
+def int_hexagon_A2_roundsat :
+Hexagon_i32_i64_Intrinsic<"HEXAGON_A2_roundsat">;
+
+def int_hexagon_A2_sath :
+Hexagon_i32_i32_Intrinsic<"HEXAGON_A2_sath">;
+
+def int_hexagon_A2_satuh :
+Hexagon_i32_i32_Intrinsic<"HEXAGON_A2_satuh">;
+
+def int_hexagon_A2_satub :
+Hexagon_i32_i32_Intrinsic<"HEXAGON_A2_satub">;
+
+def int_hexagon_A2_satb :
+Hexagon_i32_i32_Intrinsic<"HEXAGON_A2_satb">;
+
+def int_hexagon_A2_vaddub :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vaddub">;
+
+def int_hexagon_A2_vaddb_map :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vaddb_map">;
+
+def int_hexagon_A2_vaddubs :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vaddubs">;
+
+def int_hexagon_A2_vaddh :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vaddh">;
+
+def int_hexagon_A2_vaddhs :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vaddhs">;
+
+def int_hexagon_A2_vadduhs :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vadduhs">;
+
+def int_hexagon_A5_vaddhubs :
+Hexagon_i32_i64i64_Intrinsic<"HEXAGON_A5_vaddhubs">;
+
+def int_hexagon_A2_vaddw :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vaddw">;
+
+def int_hexagon_A2_vaddws :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vaddws">;
+
+def int_hexagon_S4_vxaddsubw :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_S4_vxaddsubw">;
+
+def int_hexagon_S4_vxsubaddw :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_S4_vxsubaddw">;
+
+def int_hexagon_S4_vxaddsubh :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_S4_vxaddsubh">;
+
+def int_hexagon_S4_vxsubaddh :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_S4_vxsubaddh">;
+
+def int_hexagon_S4_vxaddsubhr :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_S4_vxaddsubhr">;
+
+def int_hexagon_S4_vxsubaddhr :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_S4_vxsubaddhr">;
+
+def int_hexagon_A2_svavgh :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_svavgh">;
+
+def int_hexagon_A2_svavghs :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_svavghs">;
+
+def int_hexagon_A2_svnavgh :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_svnavgh">;
+
+def int_hexagon_A2_svaddh :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_svaddh">;
+
+def int_hexagon_A2_svaddhs :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_svaddhs">;
+
+def int_hexagon_A2_svadduhs :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_svadduhs">;
+
+def int_hexagon_A2_svsubh :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_svsubh">;
+
+def int_hexagon_A2_svsubhs :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_svsubhs">;
+
+def int_hexagon_A2_svsubuhs :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A2_svsubuhs">;
+
+def int_hexagon_A2_vraddub :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vraddub">;
+
+def int_hexagon_A2_vraddub_acc :
+Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_A2_vraddub_acc">;
+
+def int_hexagon_M2_vraddh :
+Hexagon_i32_i64i64_Intrinsic<"HEXAGON_M2_vraddh">;
+
+def int_hexagon_M2_vradduh :
+Hexagon_i32_i64i64_Intrinsic<"HEXAGON_M2_vradduh">;
+
+def int_hexagon_A2_vsubub :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vsubub">;
+
+def int_hexagon_A2_vsubb_map :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vsubb_map">;
+
+def int_hexagon_A2_vsububs :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vsububs">;
+
+def int_hexagon_A2_vsubh :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vsubh">;
+
+def int_hexagon_A2_vsubhs :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vsubhs">;
+
+def int_hexagon_A2_vsubuhs :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vsubuhs">;
+
+def int_hexagon_A2_vsubw :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vsubw">;
+
+def int_hexagon_A2_vsubws :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vsubws">;
+
+def int_hexagon_A2_vabsh :
+Hexagon_i64_i64_Intrinsic<"HEXAGON_A2_vabsh">;
+
+def int_hexagon_A2_vabshsat :
+Hexagon_i64_i64_Intrinsic<"HEXAGON_A2_vabshsat">;
+
+def int_hexagon_A2_vabsw :
+Hexagon_i64_i64_Intrinsic<"HEXAGON_A2_vabsw">;
+
+def int_hexagon_A2_vabswsat :
+Hexagon_i64_i64_Intrinsic<"HEXAGON_A2_vabswsat">;
+
+def int_hexagon_M2_vabsdiffw :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M2_vabsdiffw">;
+
+def int_hexagon_M2_vabsdiffh :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M2_vabsdiffh">;
+
+def int_hexagon_A2_vrsadub :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vrsadub">;
+
+def int_hexagon_A2_vrsadub_acc :
+Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_A2_vrsadub_acc">;
+
+def int_hexagon_A2_vavgub :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vavgub">;
+
+def int_hexagon_A2_vavguh :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vavguh">;
+
+def int_hexagon_A2_vavgh :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vavgh">;
+
+def int_hexagon_A2_vnavgh :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vnavgh">;
+
+def int_hexagon_A2_vavgw :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vavgw">;
+
+def int_hexagon_A2_vnavgw :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vnavgw">;
+
+def int_hexagon_A2_vavgwr :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vavgwr">;
+
+def int_hexagon_A2_vnavgwr :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vnavgwr">;
+
+def int_hexagon_A2_vavgwcr :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vavgwcr">;
+
+def int_hexagon_A2_vnavgwcr :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vnavgwcr">;
+
+def int_hexagon_A2_vavghcr :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vavghcr">;
+
+def int_hexagon_A2_vnavghcr :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vnavghcr">;
+
+def int_hexagon_A2_vavguw :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vavguw">;
+
+def int_hexagon_A2_vavguwr :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vavguwr">;
+
+def int_hexagon_A2_vavgubr :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vavgubr">;
+
+def int_hexagon_A2_vavguhr :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vavguhr">;
+
+def int_hexagon_A2_vavghr :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vavghr">;
+
+def int_hexagon_A2_vnavghr :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vnavghr">;
+
+def int_hexagon_A4_round_ri :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A4_round_ri", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_A4_round_rr :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A4_round_rr">;
+
+def int_hexagon_A4_round_ri_sat :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A4_round_ri_sat", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_A4_round_rr_sat :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A4_round_rr_sat">;
+
+def int_hexagon_A4_cround_ri :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A4_cround_ri", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_A4_cround_rr :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A4_cround_rr">;
+
+def int_hexagon_A4_vrminh :
+Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_A4_vrminh">;
+
+def int_hexagon_A4_vrmaxh :
+Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_A4_vrmaxh">;
+
+def int_hexagon_A4_vrminuh :
+Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_A4_vrminuh">;
+
+def int_hexagon_A4_vrmaxuh :
+Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_A4_vrmaxuh">;
+
+def int_hexagon_A4_vrminw :
+Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_A4_vrminw">;
+
+def int_hexagon_A4_vrmaxw :
+Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_A4_vrmaxw">;
+
+def int_hexagon_A4_vrminuw :
+Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_A4_vrminuw">;
+
+def int_hexagon_A4_vrmaxuw :
+Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_A4_vrmaxuw">;
+
+def int_hexagon_A2_vminb :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vminb">;
+
+def int_hexagon_A2_vmaxb :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vmaxb">;
+
+def int_hexagon_A2_vminub :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vminub">;
+
+def int_hexagon_A2_vmaxub :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vmaxub">;
+
+def int_hexagon_A2_vminh :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vminh">;
+
+def int_hexagon_A2_vmaxh :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vmaxh">;
+
+def int_hexagon_A2_vminuh :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vminuh">;
+
+def int_hexagon_A2_vmaxuh :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vmaxuh">;
+
+def int_hexagon_A2_vminw :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vminw">;
+
+def int_hexagon_A2_vmaxw :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vmaxw">;
+
+def int_hexagon_A2_vminuw :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vminuw">;
+
+def int_hexagon_A2_vmaxuw :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_A2_vmaxuw">;
+
+def int_hexagon_A4_modwrapu :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A4_modwrapu">;
+
+def int_hexagon_F2_sfadd :
+Hexagon_float_floatfloat_Intrinsic<"HEXAGON_F2_sfadd", [IntrNoMem, Throws]>;
+
+def int_hexagon_F2_sfsub :
+Hexagon_float_floatfloat_Intrinsic<"HEXAGON_F2_sfsub", [IntrNoMem, Throws]>;
+
+def int_hexagon_F2_sfmpy :
+Hexagon_float_floatfloat_Intrinsic<"HEXAGON_F2_sfmpy", [IntrNoMem, Throws]>;
+
+def int_hexagon_F2_sffma :
+Hexagon_float_floatfloatfloat_Intrinsic<"HEXAGON_F2_sffma", [IntrNoMem, Throws]>;
+
+def int_hexagon_F2_sffma_sc :
+Hexagon_float_floatfloatfloati32_Intrinsic<"HEXAGON_F2_sffma_sc", [IntrNoMem, Throws]>;
+
+def int_hexagon_F2_sffms :
+Hexagon_float_floatfloatfloat_Intrinsic<"HEXAGON_F2_sffms", [IntrNoMem, Throws]>;
+
+def int_hexagon_F2_sffma_lib :
+Hexagon_float_floatfloatfloat_Intrinsic<"HEXAGON_F2_sffma_lib", [IntrNoMem, Throws]>;
+
+def int_hexagon_F2_sffms_lib :
+Hexagon_float_floatfloatfloat_Intrinsic<"HEXAGON_F2_sffms_lib", [IntrNoMem, Throws]>;
+
+def int_hexagon_F2_sfcmpeq :
+Hexagon_i32_floatfloat_Intrinsic<"HEXAGON_F2_sfcmpeq", [IntrNoMem, Throws]>;
+
+def int_hexagon_F2_sfcmpgt :
+Hexagon_i32_floatfloat_Intrinsic<"HEXAGON_F2_sfcmpgt", [IntrNoMem, Throws]>;
+
+def int_hexagon_F2_sfcmpge :
+Hexagon_i32_floatfloat_Intrinsic<"HEXAGON_F2_sfcmpge", [IntrNoMem, Throws]>;
+
+def int_hexagon_F2_sfcmpuo :
+Hexagon_i32_floatfloat_Intrinsic<"HEXAGON_F2_sfcmpuo", [IntrNoMem, Throws]>;
+
+def int_hexagon_F2_sfmax :
+Hexagon_float_floatfloat_Intrinsic<"HEXAGON_F2_sfmax", [IntrNoMem, Throws]>;
+
+def int_hexagon_F2_sfmin :
+Hexagon_float_floatfloat_Intrinsic<"HEXAGON_F2_sfmin", [IntrNoMem, Throws]>;
+
+def int_hexagon_F2_sfclass :
+Hexagon_i32_floati32_Intrinsic<"HEXAGON_F2_sfclass", [IntrNoMem, Throws, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_F2_sfimm_p :
+Hexagon_float_i32_Intrinsic<"HEXAGON_F2_sfimm_p", [IntrNoMem, Throws, ImmArg<ArgIndex<0>>]>;
+
+def int_hexagon_F2_sfimm_n :
+Hexagon_float_i32_Intrinsic<"HEXAGON_F2_sfimm_n", [IntrNoMem, Throws, ImmArg<ArgIndex<0>>]>;
+
+def int_hexagon_F2_sffixupn :
+Hexagon_float_floatfloat_Intrinsic<"HEXAGON_F2_sffixupn", [IntrNoMem, Throws]>;
+
+def int_hexagon_F2_sffixupd :
+Hexagon_float_floatfloat_Intrinsic<"HEXAGON_F2_sffixupd", [IntrNoMem, Throws]>;
+
+def int_hexagon_F2_sffixupr :
+Hexagon_float_float_Intrinsic<"HEXAGON_F2_sffixupr", [IntrNoMem, Throws]>;
+
+def int_hexagon_F2_dfcmpeq :
+Hexagon_i32_doubledouble_Intrinsic<"HEXAGON_F2_dfcmpeq", [IntrNoMem, Throws]>;
+
+def int_hexagon_F2_dfcmpgt :
+Hexagon_i32_doubledouble_Intrinsic<"HEXAGON_F2_dfcmpgt", [IntrNoMem, Throws]>;
+
+def int_hexagon_F2_dfcmpge :
+Hexagon_i32_doubledouble_Intrinsic<"HEXAGON_F2_dfcmpge", [IntrNoMem, Throws]>;
+
+def int_hexagon_F2_dfcmpuo :
+Hexagon_i32_doubledouble_Intrinsic<"HEXAGON_F2_dfcmpuo", [IntrNoMem, Throws]>;
+
+def int_hexagon_F2_dfclass :
+Hexagon_i32_doublei32_Intrinsic<"HEXAGON_F2_dfclass", [IntrNoMem, Throws, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_F2_dfimm_p :
+Hexagon_double_i32_Intrinsic<"HEXAGON_F2_dfimm_p", [IntrNoMem, Throws, ImmArg<ArgIndex<0>>]>;
+
+def int_hexagon_F2_dfimm_n :
+Hexagon_double_i32_Intrinsic<"HEXAGON_F2_dfimm_n", [IntrNoMem, Throws, ImmArg<ArgIndex<0>>]>;
+
+def int_hexagon_F2_conv_sf2df :
+Hexagon_double_float_Intrinsic<"HEXAGON_F2_conv_sf2df">;
+
+def int_hexagon_F2_conv_df2sf :
+Hexagon_float_double_Intrinsic<"HEXAGON_F2_conv_df2sf">;
+
+def int_hexagon_F2_conv_uw2sf :
+Hexagon_float_i32_Intrinsic<"HEXAGON_F2_conv_uw2sf">;
+
+def int_hexagon_F2_conv_uw2df :
+Hexagon_double_i32_Intrinsic<"HEXAGON_F2_conv_uw2df">;
+
+def int_hexagon_F2_conv_w2sf :
+Hexagon_float_i32_Intrinsic<"HEXAGON_F2_conv_w2sf">;
+
+def int_hexagon_F2_conv_w2df :
+Hexagon_double_i32_Intrinsic<"HEXAGON_F2_conv_w2df">;
+
+def int_hexagon_F2_conv_ud2sf :
+Hexagon_float_i64_Intrinsic<"HEXAGON_F2_conv_ud2sf">;
+
+def int_hexagon_F2_conv_ud2df :
+Hexagon_double_i64_Intrinsic<"HEXAGON_F2_conv_ud2df">;
+
+def int_hexagon_F2_conv_d2sf :
+Hexagon_float_i64_Intrinsic<"HEXAGON_F2_conv_d2sf">;
+
+def int_hexagon_F2_conv_d2df :
+Hexagon_double_i64_Intrinsic<"HEXAGON_F2_conv_d2df">;
+
+def int_hexagon_F2_conv_sf2uw :
+Hexagon_i32_float_Intrinsic<"HEXAGON_F2_conv_sf2uw">;
+
+def int_hexagon_F2_conv_sf2w :
+Hexagon_i32_float_Intrinsic<"HEXAGON_F2_conv_sf2w">;
+
+def int_hexagon_F2_conv_sf2ud :
+Hexagon_i64_float_Intrinsic<"HEXAGON_F2_conv_sf2ud">;
+
+def int_hexagon_F2_conv_sf2d :
+Hexagon_i64_float_Intrinsic<"HEXAGON_F2_conv_sf2d">;
+
+def int_hexagon_F2_conv_df2uw :
+Hexagon_i32_double_Intrinsic<"HEXAGON_F2_conv_df2uw">;
+
+def int_hexagon_F2_conv_df2w :
+Hexagon_i32_double_Intrinsic<"HEXAGON_F2_conv_df2w">;
+
+def int_hexagon_F2_conv_df2ud :
+Hexagon_i64_double_Intrinsic<"HEXAGON_F2_conv_df2ud">;
+
+def int_hexagon_F2_conv_df2d :
+Hexagon_i64_double_Intrinsic<"HEXAGON_F2_conv_df2d">;
+
+def int_hexagon_F2_conv_sf2uw_chop :
+Hexagon_i32_float_Intrinsic<"HEXAGON_F2_conv_sf2uw_chop">;
+
+def int_hexagon_F2_conv_sf2w_chop :
+Hexagon_i32_float_Intrinsic<"HEXAGON_F2_conv_sf2w_chop">;
+
+def int_hexagon_F2_conv_sf2ud_chop :
+Hexagon_i64_float_Intrinsic<"HEXAGON_F2_conv_sf2ud_chop">;
+
+def int_hexagon_F2_conv_sf2d_chop :
+Hexagon_i64_float_Intrinsic<"HEXAGON_F2_conv_sf2d_chop">;
+
+def int_hexagon_F2_conv_df2uw_chop :
+Hexagon_i32_double_Intrinsic<"HEXAGON_F2_conv_df2uw_chop">;
+
+def int_hexagon_F2_conv_df2w_chop :
+Hexagon_i32_double_Intrinsic<"HEXAGON_F2_conv_df2w_chop">;
+
+def int_hexagon_F2_conv_df2ud_chop :
+Hexagon_i64_double_Intrinsic<"HEXAGON_F2_conv_df2ud_chop">;
+
+def int_hexagon_F2_conv_df2d_chop :
+Hexagon_i64_double_Intrinsic<"HEXAGON_F2_conv_df2d_chop">;
+
+def int_hexagon_S2_asr_r_r :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_S2_asr_r_r">;
+
+def int_hexagon_S2_asl_r_r :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_S2_asl_r_r">;
+
+def int_hexagon_S2_lsr_r_r :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_S2_lsr_r_r">;
+
+def int_hexagon_S2_lsl_r_r :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_S2_lsl_r_r">;
+
+def int_hexagon_S2_asr_r_p :
+Hexagon_i64_i64i32_Intrinsic<"HEXAGON_S2_asr_r_p">;
+
+def int_hexagon_S2_asl_r_p :
+Hexagon_i64_i64i32_Intrinsic<"HEXAGON_S2_asl_r_p">;
+
+def int_hexagon_S2_lsr_r_p :
+Hexagon_i64_i64i32_Intrinsic<"HEXAGON_S2_lsr_r_p">;
+
+def int_hexagon_S2_lsl_r_p :
+Hexagon_i64_i64i32_Intrinsic<"HEXAGON_S2_lsl_r_p">;
+
+def int_hexagon_S2_asr_r_r_acc :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S2_asr_r_r_acc">;
+
+def int_hexagon_S2_asl_r_r_acc :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S2_asl_r_r_acc">;
+
+def int_hexagon_S2_lsr_r_r_acc :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S2_lsr_r_r_acc">;
+
+def int_hexagon_S2_lsl_r_r_acc :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S2_lsl_r_r_acc">;
+
+def int_hexagon_S2_asr_r_p_acc :
+Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_asr_r_p_acc">;
+
+def int_hexagon_S2_asl_r_p_acc :
+Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_asl_r_p_acc">;
+
+def int_hexagon_S2_lsr_r_p_acc :
+Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_lsr_r_p_acc">;
+
+def int_hexagon_S2_lsl_r_p_acc :
+Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_lsl_r_p_acc">;
+
+def int_hexagon_S2_asr_r_r_nac :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S2_asr_r_r_nac">;
+
+def int_hexagon_S2_asl_r_r_nac :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S2_asl_r_r_nac">;
+
+def int_hexagon_S2_lsr_r_r_nac :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S2_lsr_r_r_nac">;
+
+def int_hexagon_S2_lsl_r_r_nac :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S2_lsl_r_r_nac">;
+
+def int_hexagon_S2_asr_r_p_nac :
+Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_asr_r_p_nac">;
+
+def int_hexagon_S2_asl_r_p_nac :
+Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_asl_r_p_nac">;
+
+def int_hexagon_S2_lsr_r_p_nac :
+Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_lsr_r_p_nac">;
+
+def int_hexagon_S2_lsl_r_p_nac :
+Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_lsl_r_p_nac">;
+
+def int_hexagon_S2_asr_r_r_and :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S2_asr_r_r_and">;
+
+def int_hexagon_S2_asl_r_r_and :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S2_asl_r_r_and">;
+
+def int_hexagon_S2_lsr_r_r_and :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S2_lsr_r_r_and">;
+
+def int_hexagon_S2_lsl_r_r_and :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S2_lsl_r_r_and">;
+
+def int_hexagon_S2_asr_r_r_or :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S2_asr_r_r_or">;
+
+def int_hexagon_S2_asl_r_r_or :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S2_asl_r_r_or">;
+
+def int_hexagon_S2_lsr_r_r_or :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S2_lsr_r_r_or">;
+
+def int_hexagon_S2_lsl_r_r_or :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S2_lsl_r_r_or">;
+
+def int_hexagon_S2_asr_r_p_and :
+Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_asr_r_p_and">;
+
+def int_hexagon_S2_asl_r_p_and :
+Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_asl_r_p_and">;
+
+def int_hexagon_S2_lsr_r_p_and :
+Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_lsr_r_p_and">;
+
+def int_hexagon_S2_lsl_r_p_and :
+Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_lsl_r_p_and">;
+
+def int_hexagon_S2_asr_r_p_or :
+Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_asr_r_p_or">;
+
+def int_hexagon_S2_asl_r_p_or :
+Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_asl_r_p_or">;
+
+def int_hexagon_S2_lsr_r_p_or :
+Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_lsr_r_p_or">;
+
+def int_hexagon_S2_lsl_r_p_or :
+Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_lsl_r_p_or">;
+
+def int_hexagon_S2_asr_r_p_xor :
+Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_asr_r_p_xor">;
+
+def int_hexagon_S2_asl_r_p_xor :
+Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_asl_r_p_xor">;
+
+def int_hexagon_S2_lsr_r_p_xor :
+Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_lsr_r_p_xor">;
+
+def int_hexagon_S2_lsl_r_p_xor :
+Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_lsl_r_p_xor">;
+
+def int_hexagon_S2_asr_r_r_sat :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_S2_asr_r_r_sat">;
+
+def int_hexagon_S2_asl_r_r_sat :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_S2_asl_r_r_sat">;
+
+def int_hexagon_S2_asr_i_r :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_S2_asr_i_r", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_S2_lsr_i_r :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_S2_lsr_i_r", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_S2_asl_i_r :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_S2_asl_i_r", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_S2_asr_i_p :
+Hexagon_i64_i64i32_Intrinsic<"HEXAGON_S2_asr_i_p", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_S2_lsr_i_p :
+Hexagon_i64_i64i32_Intrinsic<"HEXAGON_S2_lsr_i_p", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_S2_asl_i_p :
+Hexagon_i64_i64i32_Intrinsic<"HEXAGON_S2_asl_i_p", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_S2_asr_i_r_acc :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S2_asr_i_r_acc", [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_S2_lsr_i_r_acc :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S2_lsr_i_r_acc", [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_S2_asl_i_r_acc :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S2_asl_i_r_acc", [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_S2_asr_i_p_acc :
+Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_asr_i_p_acc", [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_S2_lsr_i_p_acc :
+Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_lsr_i_p_acc", [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_S2_asl_i_p_acc :
+Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_asl_i_p_acc", [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_S2_asr_i_r_nac :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S2_asr_i_r_nac", [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_S2_lsr_i_r_nac :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S2_lsr_i_r_nac", [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_S2_asl_i_r_nac :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S2_asl_i_r_nac", [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_S2_asr_i_p_nac :
+Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_asr_i_p_nac", [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_S2_lsr_i_p_nac :
+Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_lsr_i_p_nac", [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_S2_asl_i_p_nac :
+Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_asl_i_p_nac", [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_S2_lsr_i_r_xacc :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S2_lsr_i_r_xacc", [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_S2_asl_i_r_xacc :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S2_asl_i_r_xacc", [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_S2_lsr_i_p_xacc :
+Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_lsr_i_p_xacc", [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_S2_asl_i_p_xacc :
+Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_asl_i_p_xacc", [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_S2_asr_i_r_and :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S2_asr_i_r_and", [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_S2_lsr_i_r_and :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S2_lsr_i_r_and", [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_S2_asl_i_r_and :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S2_asl_i_r_and", [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_S2_asr_i_r_or :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S2_asr_i_r_or", [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_S2_lsr_i_r_or :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S2_lsr_i_r_or", [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_S2_asl_i_r_or :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S2_asl_i_r_or", [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_S2_asr_i_p_and :
+Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_asr_i_p_and", [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_S2_lsr_i_p_and :
+Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_lsr_i_p_and", [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_S2_asl_i_p_and :
+Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_asl_i_p_and", [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_S2_asr_i_p_or :
+Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_asr_i_p_or", [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_S2_lsr_i_p_or :
+Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_lsr_i_p_or", [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_S2_asl_i_p_or :
+Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_asl_i_p_or", [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_S2_asl_i_r_sat :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_S2_asl_i_r_sat", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_S2_asr_i_r_rnd :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_S2_asr_i_r_rnd", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_S2_asr_i_r_rnd_goodsyntax :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_S2_asr_i_r_rnd_goodsyntax", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_S2_asr_i_p_rnd :
+Hexagon_i64_i64i32_Intrinsic<"HEXAGON_S2_asr_i_p_rnd", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_S2_asr_i_p_rnd_goodsyntax :
+Hexagon_i64_i64i32_Intrinsic<"HEXAGON_S2_asr_i_p_rnd_goodsyntax", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_S4_lsli :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_S4_lsli", [IntrNoMem, ImmArg<ArgIndex<0>>]>;
+
+def int_hexagon_S2_addasl_rrri :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S2_addasl_rrri", [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_S4_andi_asl_ri :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S4_andi_asl_ri", [IntrNoMem, ImmArg<ArgIndex<0>>, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_S4_ori_asl_ri :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S4_ori_asl_ri", [IntrNoMem, ImmArg<ArgIndex<0>>, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_S4_addi_asl_ri :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S4_addi_asl_ri", [IntrNoMem, ImmArg<ArgIndex<0>>, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_S4_subi_asl_ri :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S4_subi_asl_ri", [IntrNoMem, ImmArg<ArgIndex<0>>, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_S4_andi_lsr_ri :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S4_andi_lsr_ri", [IntrNoMem, ImmArg<ArgIndex<0>>, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_S4_ori_lsr_ri :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S4_ori_lsr_ri", [IntrNoMem, ImmArg<ArgIndex<0>>, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_S4_addi_lsr_ri :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S4_addi_lsr_ri", [IntrNoMem, ImmArg<ArgIndex<0>>, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_S4_subi_lsr_ri :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S4_subi_lsr_ri", [IntrNoMem, ImmArg<ArgIndex<0>>, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_S2_valignib :
+Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_valignib", [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_S2_valignrb :
+Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_valignrb">;
+
+def int_hexagon_S2_vspliceib :
+Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_vspliceib", [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_S2_vsplicerb :
+Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S2_vsplicerb">;
+
+def int_hexagon_S2_vsplatrh :
+Hexagon_i64_i32_Intrinsic<"HEXAGON_S2_vsplatrh">;
+
+def int_hexagon_S2_vsplatrb :
+Hexagon_i32_i32_Intrinsic<"HEXAGON_S2_vsplatrb">;
+
+def int_hexagon_S2_insert :
+Hexagon_i32_i32i32i32i32_Intrinsic<"HEXAGON_S2_insert", [IntrNoMem, ImmArg<ArgIndex<2>>, ImmArg<ArgIndex<3>>]>;
+
+def int_hexagon_S2_tableidxb_goodsyntax :
+Hexagon_i32_i32i32i32i32_Intrinsic<"HEXAGON_S2_tableidxb_goodsyntax", [IntrNoMem, ImmArg<ArgIndex<2>>, ImmArg<ArgIndex<3>>]>;
+
+def int_hexagon_S2_tableidxh_goodsyntax :
+Hexagon_i32_i32i32i32i32_Intrinsic<"HEXAGON_S2_tableidxh_goodsyntax", [IntrNoMem, ImmArg<ArgIndex<2>>, ImmArg<ArgIndex<3>>]>;
+
+def int_hexagon_S2_tableidxw_goodsyntax :
+Hexagon_i32_i32i32i32i32_Intrinsic<"HEXAGON_S2_tableidxw_goodsyntax", [IntrNoMem, ImmArg<ArgIndex<2>>, ImmArg<ArgIndex<3>>]>;
+
+def int_hexagon_S2_tableidxd_goodsyntax :
+Hexagon_i32_i32i32i32i32_Intrinsic<"HEXAGON_S2_tableidxd_goodsyntax", [IntrNoMem, ImmArg<ArgIndex<2>>, ImmArg<ArgIndex<3>>]>;
+
+def int_hexagon_A4_bitspliti :
+Hexagon_i64_i32i32_Intrinsic<"HEXAGON_A4_bitspliti", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_A4_bitsplit :
+Hexagon_i64_i32i32_Intrinsic<"HEXAGON_A4_bitsplit">;
+
+def int_hexagon_S4_extract :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S4_extract", [IntrNoMem, ImmArg<ArgIndex<1>>, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_S2_extractu :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S2_extractu", [IntrNoMem, ImmArg<ArgIndex<1>>, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_S2_insertp :
+Hexagon_i64_i64i64i32i32_Intrinsic<"HEXAGON_S2_insertp", [IntrNoMem, ImmArg<ArgIndex<2>>, ImmArg<ArgIndex<3>>]>;
+
+def int_hexagon_S4_extractp :
+Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_S4_extractp", [IntrNoMem, ImmArg<ArgIndex<1>>, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_S2_extractup :
+Hexagon_i64_i64i32i32_Intrinsic<"HEXAGON_S2_extractup", [IntrNoMem, ImmArg<ArgIndex<1>>, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_S2_insert_rp :
+Hexagon_i32_i32i32i64_Intrinsic<"HEXAGON_S2_insert_rp">;
+
+def int_hexagon_S4_extract_rp :
+Hexagon_i32_i32i64_Intrinsic<"HEXAGON_S4_extract_rp">;
+
+def int_hexagon_S2_extractu_rp :
+Hexagon_i32_i32i64_Intrinsic<"HEXAGON_S2_extractu_rp">;
+
+def int_hexagon_S2_insertp_rp :
+Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_S2_insertp_rp">;
+
+def int_hexagon_S4_extractp_rp :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_S4_extractp_rp">;
+
+def int_hexagon_S2_extractup_rp :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_S2_extractup_rp">;
+
+def int_hexagon_S2_tstbit_i :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_S2_tstbit_i", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_S4_ntstbit_i :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_S4_ntstbit_i", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_S2_setbit_i :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_S2_setbit_i", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_S2_togglebit_i :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_S2_togglebit_i", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_S2_clrbit_i :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_S2_clrbit_i", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_S2_tstbit_r :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_S2_tstbit_r">;
+
+def int_hexagon_S4_ntstbit_r :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_S4_ntstbit_r">;
+
+def int_hexagon_S2_setbit_r :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_S2_setbit_r">;
+
+def int_hexagon_S2_togglebit_r :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_S2_togglebit_r">;
+
+def int_hexagon_S2_clrbit_r :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_S2_clrbit_r">;
+
+def int_hexagon_S2_asr_i_vh :
+Hexagon_i64_i64i32_Intrinsic<"HEXAGON_S2_asr_i_vh", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_S2_lsr_i_vh :
+Hexagon_i64_i64i32_Intrinsic<"HEXAGON_S2_lsr_i_vh", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_S2_asl_i_vh :
+Hexagon_i64_i64i32_Intrinsic<"HEXAGON_S2_asl_i_vh", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_S2_asr_r_vh :
+Hexagon_i64_i64i32_Intrinsic<"HEXAGON_S2_asr_r_vh">;
+
+def int_hexagon_S5_asrhub_rnd_sat_goodsyntax :
+Hexagon_i32_i64i32_Intrinsic<"HEXAGON_S5_asrhub_rnd_sat_goodsyntax", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_S5_asrhub_sat :
+Hexagon_i32_i64i32_Intrinsic<"HEXAGON_S5_asrhub_sat", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_S5_vasrhrnd_goodsyntax :
+Hexagon_i64_i64i32_Intrinsic<"HEXAGON_S5_vasrhrnd_goodsyntax", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_S2_asl_r_vh :
+Hexagon_i64_i64i32_Intrinsic<"HEXAGON_S2_asl_r_vh">;
+
+def int_hexagon_S2_lsr_r_vh :
+Hexagon_i64_i64i32_Intrinsic<"HEXAGON_S2_lsr_r_vh">;
+
+def int_hexagon_S2_lsl_r_vh :
+Hexagon_i64_i64i32_Intrinsic<"HEXAGON_S2_lsl_r_vh">;
+
+def int_hexagon_S2_asr_i_vw :
+Hexagon_i64_i64i32_Intrinsic<"HEXAGON_S2_asr_i_vw", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_S2_asr_i_svw_trun :
+Hexagon_i32_i64i32_Intrinsic<"HEXAGON_S2_asr_i_svw_trun", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_S2_asr_r_svw_trun :
+Hexagon_i32_i64i32_Intrinsic<"HEXAGON_S2_asr_r_svw_trun">;
+
+def int_hexagon_S2_lsr_i_vw :
+Hexagon_i64_i64i32_Intrinsic<"HEXAGON_S2_lsr_i_vw", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_S2_asl_i_vw :
+Hexagon_i64_i64i32_Intrinsic<"HEXAGON_S2_asl_i_vw", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_S2_asr_r_vw :
+Hexagon_i64_i64i32_Intrinsic<"HEXAGON_S2_asr_r_vw">;
+
+def int_hexagon_S2_asl_r_vw :
+Hexagon_i64_i64i32_Intrinsic<"HEXAGON_S2_asl_r_vw">;
+
+def int_hexagon_S2_lsr_r_vw :
+Hexagon_i64_i64i32_Intrinsic<"HEXAGON_S2_lsr_r_vw">;
+
+def int_hexagon_S2_lsl_r_vw :
+Hexagon_i64_i64i32_Intrinsic<"HEXAGON_S2_lsl_r_vw">;
+
+def int_hexagon_S2_vrndpackwh :
+Hexagon_i32_i64_Intrinsic<"HEXAGON_S2_vrndpackwh">;
+
+def int_hexagon_S2_vrndpackwhs :
+Hexagon_i32_i64_Intrinsic<"HEXAGON_S2_vrndpackwhs">;
+
+def int_hexagon_S2_vsxtbh :
+Hexagon_i64_i32_Intrinsic<"HEXAGON_S2_vsxtbh">;
+
+def int_hexagon_S2_vzxtbh :
+Hexagon_i64_i32_Intrinsic<"HEXAGON_S2_vzxtbh">;
+
+def int_hexagon_S2_vsathub :
+Hexagon_i32_i64_Intrinsic<"HEXAGON_S2_vsathub">;
+
+def int_hexagon_S2_svsathub :
+Hexagon_i32_i32_Intrinsic<"HEXAGON_S2_svsathub">;
+
+def int_hexagon_S2_svsathb :
+Hexagon_i32_i32_Intrinsic<"HEXAGON_S2_svsathb">;
+
+def int_hexagon_S2_vsathb :
+Hexagon_i32_i64_Intrinsic<"HEXAGON_S2_vsathb">;
+
+def int_hexagon_S2_vtrunohb :
+Hexagon_i32_i64_Intrinsic<"HEXAGON_S2_vtrunohb">;
+
+def int_hexagon_S2_vtrunewh :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_S2_vtrunewh">;
+
+def int_hexagon_S2_vtrunowh :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_S2_vtrunowh">;
+
+def int_hexagon_S2_vtrunehb :
+Hexagon_i32_i64_Intrinsic<"HEXAGON_S2_vtrunehb">;
+
+def int_hexagon_S2_vsxthw :
+Hexagon_i64_i32_Intrinsic<"HEXAGON_S2_vsxthw">;
+
+def int_hexagon_S2_vzxthw :
+Hexagon_i64_i32_Intrinsic<"HEXAGON_S2_vzxthw">;
+
+def int_hexagon_S2_vsatwh :
+Hexagon_i32_i64_Intrinsic<"HEXAGON_S2_vsatwh">;
+
+def int_hexagon_S2_vsatwuh :
+Hexagon_i32_i64_Intrinsic<"HEXAGON_S2_vsatwuh">;
+
+def int_hexagon_S2_packhl :
+Hexagon_i64_i32i32_Intrinsic<"HEXAGON_S2_packhl">;
+
+def int_hexagon_A2_swiz :
+Hexagon_i32_i32_Intrinsic<"HEXAGON_A2_swiz">;
+
+def int_hexagon_S2_vsathub_nopack :
+Hexagon_i64_i64_Intrinsic<"HEXAGON_S2_vsathub_nopack">;
+
+def int_hexagon_S2_vsathb_nopack :
+Hexagon_i64_i64_Intrinsic<"HEXAGON_S2_vsathb_nopack">;
+
+def int_hexagon_S2_vsatwh_nopack :
+Hexagon_i64_i64_Intrinsic<"HEXAGON_S2_vsatwh_nopack">;
+
+def int_hexagon_S2_vsatwuh_nopack :
+Hexagon_i64_i64_Intrinsic<"HEXAGON_S2_vsatwuh_nopack">;
+
+def int_hexagon_S2_shuffob :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_S2_shuffob">;
+
+def int_hexagon_S2_shuffeb :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_S2_shuffeb">;
+
+def int_hexagon_S2_shuffoh :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_S2_shuffoh">;
+
+def int_hexagon_S2_shuffeh :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_S2_shuffeh">;
+
+def int_hexagon_S5_popcountp :
+Hexagon_i32_i64_Intrinsic<"HEXAGON_S5_popcountp">;
+
+def int_hexagon_S4_parity :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_S4_parity">;
+
+def int_hexagon_S2_parityp :
+Hexagon_i32_i64i64_Intrinsic<"HEXAGON_S2_parityp">;
+
+def int_hexagon_S2_lfsp :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_S2_lfsp">;
+
+def int_hexagon_S2_clbnorm :
+Hexagon_i32_i32_Intrinsic<"HEXAGON_S2_clbnorm">;
+
+def int_hexagon_S4_clbaddi :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_S4_clbaddi", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_S4_clbpnorm :
+Hexagon_i32_i64_Intrinsic<"HEXAGON_S4_clbpnorm">;
+
+def int_hexagon_S4_clbpaddi :
+Hexagon_i32_i64i32_Intrinsic<"HEXAGON_S4_clbpaddi", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_S2_clb :
+Hexagon_i32_i32_Intrinsic<"HEXAGON_S2_clb">;
+
+def int_hexagon_S2_cl0 :
+Hexagon_i32_i32_Intrinsic<"HEXAGON_S2_cl0">;
+
+def int_hexagon_S2_cl1 :
+Hexagon_i32_i32_Intrinsic<"HEXAGON_S2_cl1">;
+
+def int_hexagon_S2_clbp :
+Hexagon_i32_i64_Intrinsic<"HEXAGON_S2_clbp">;
+
+def int_hexagon_S2_cl0p :
+Hexagon_i32_i64_Intrinsic<"HEXAGON_S2_cl0p">;
+
+def int_hexagon_S2_cl1p :
+Hexagon_i32_i64_Intrinsic<"HEXAGON_S2_cl1p">;
+
+def int_hexagon_S2_brev :
+Hexagon_i32_i32_Intrinsic<"HEXAGON_S2_brev">;
+
+def int_hexagon_S2_brevp :
+Hexagon_i64_i64_Intrinsic<"HEXAGON_S2_brevp">;
+
+def int_hexagon_S2_ct0 :
+Hexagon_i32_i32_Intrinsic<"HEXAGON_S2_ct0">;
+
+def int_hexagon_S2_ct1 :
+Hexagon_i32_i32_Intrinsic<"HEXAGON_S2_ct1">;
+
+def int_hexagon_S2_ct0p :
+Hexagon_i32_i64_Intrinsic<"HEXAGON_S2_ct0p">;
+
+def int_hexagon_S2_ct1p :
+Hexagon_i32_i64_Intrinsic<"HEXAGON_S2_ct1p">;
+
+def int_hexagon_S2_interleave :
+Hexagon_i64_i64_Intrinsic<"HEXAGON_S2_interleave">;
+
+def int_hexagon_S2_deinterleave :
+Hexagon_i64_i64_Intrinsic<"HEXAGON_S2_deinterleave">;
+
+def int_hexagon_Y2_dcfetch :
+Hexagon__ptr_Intrinsic<"HEXAGON_Y2_dcfetch", []>;
+
+def int_hexagon_Y2_dczeroa :
+Hexagon__ptr_Intrinsic<"HEXAGON_Y2_dczeroa", []>;
+
+def int_hexagon_Y2_dccleana :
+Hexagon__ptr_Intrinsic<"HEXAGON_Y2_dccleana", []>;
+
+def int_hexagon_Y2_dccleaninva :
+Hexagon__ptr_Intrinsic<"HEXAGON_Y2_dccleaninva", []>;
+
+def int_hexagon_Y2_dcinva :
+Hexagon__ptr_Intrinsic<"HEXAGON_Y2_dcinva", []>;
+
+def int_hexagon_Y4_l2fetch :
+Hexagon__ptri32_Intrinsic<"HEXAGON_Y4_l2fetch", []>;
+
+def int_hexagon_Y5_l2fetch :
+Hexagon__ptri64_Intrinsic<"HEXAGON_Y5_l2fetch", []>;
+
+// V60 Scalar Instructions.
+
+def int_hexagon_S6_rol_i_r :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_S6_rol_i_r", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_S6_rol_i_p :
+Hexagon_i64_i64i32_Intrinsic<"HEXAGON_S6_rol_i_p", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_S6_rol_i_r_acc :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S6_rol_i_r_acc", [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_S6_rol_i_p_acc :
+Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S6_rol_i_p_acc", [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_S6_rol_i_r_nac :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S6_rol_i_r_nac", [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_S6_rol_i_p_nac :
+Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S6_rol_i_p_nac", [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_S6_rol_i_r_xacc :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S6_rol_i_r_xacc", [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_S6_rol_i_p_xacc :
+Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S6_rol_i_p_xacc", [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_S6_rol_i_r_and :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S6_rol_i_r_and", [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_S6_rol_i_r_or :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_S6_rol_i_r_or", [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_S6_rol_i_p_and :
+Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S6_rol_i_p_and", [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_S6_rol_i_p_or :
+Hexagon_i64_i64i64i32_Intrinsic<"HEXAGON_S6_rol_i_p_or", [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+// V62 Scalar Instructions.
+
+def int_hexagon_M6_vabsdiffb :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M6_vabsdiffb">;
+
+def int_hexagon_M6_vabsdiffub :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M6_vabsdiffub">;
+
+def int_hexagon_S6_vsplatrbp :
+Hexagon_i64_i32_Intrinsic<"HEXAGON_S6_vsplatrbp">;
+
+def int_hexagon_S6_vtrunehb_ppp :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_S6_vtrunehb_ppp">;
+
+def int_hexagon_S6_vtrunohb_ppp :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_S6_vtrunohb_ppp">;
+
+// V65 Scalar Instructions.
+
+def int_hexagon_A6_vcmpbeq_notany :
+Hexagon_i32_i64i64_Intrinsic<"HEXAGON_A6_vcmpbeq_notany">;
+
+// V66 Scalar Instructions.
+
+def int_hexagon_M2_mnaci :
+Hexagon_i32_i32i32i32_Intrinsic<"HEXAGON_M2_mnaci">;
+
+def int_hexagon_F2_dfadd :
+Hexagon_double_doubledouble_Intrinsic<"HEXAGON_F2_dfadd", [IntrNoMem, Throws]>;
+
+def int_hexagon_F2_dfsub :
+Hexagon_double_doubledouble_Intrinsic<"HEXAGON_F2_dfsub", [IntrNoMem, Throws]>;
+
+def int_hexagon_S2_mask :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_S2_mask", [IntrNoMem, ImmArg<ArgIndex<0>>, ImmArg<ArgIndex<1>>]>;
+
+// V67 Scalar Instructions.
+
+def int_hexagon_M7_dcmpyrw :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M7_dcmpyrw">;
+
+def int_hexagon_M7_dcmpyrw_acc :
+Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M7_dcmpyrw_acc">;
+
+def int_hexagon_M7_dcmpyrwc :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M7_dcmpyrwc">;
+
+def int_hexagon_M7_dcmpyrwc_acc :
+Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M7_dcmpyrwc_acc">;
+
+def int_hexagon_M7_dcmpyiw :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M7_dcmpyiw">;
+
+def int_hexagon_M7_dcmpyiw_acc :
+Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M7_dcmpyiw_acc">;
+
+def int_hexagon_M7_dcmpyiwc :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M7_dcmpyiwc">;
+
+def int_hexagon_M7_dcmpyiwc_acc :
+Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M7_dcmpyiwc_acc">;
+
+def int_hexagon_M7_vdmpy :
+Hexagon_i64_i64i64_Intrinsic<"HEXAGON_M7_vdmpy">;
+
+def int_hexagon_M7_vdmpy_acc :
+Hexagon_i64_i64i64i64_Intrinsic<"HEXAGON_M7_vdmpy_acc">;
+
+def int_hexagon_M7_wcmpyrw :
+Hexagon_i32_i64i64_Intrinsic<"HEXAGON_M7_wcmpyrw">;
+
+def int_hexagon_M7_wcmpyrwc :
+Hexagon_i32_i64i64_Intrinsic<"HEXAGON_M7_wcmpyrwc">;
+
+def int_hexagon_M7_wcmpyiw :
+Hexagon_i32_i64i64_Intrinsic<"HEXAGON_M7_wcmpyiw">;
+
+def int_hexagon_M7_wcmpyiwc :
+Hexagon_i32_i64i64_Intrinsic<"HEXAGON_M7_wcmpyiwc">;
+
+def int_hexagon_M7_wcmpyrw_rnd :
+Hexagon_i32_i64i64_Intrinsic<"HEXAGON_M7_wcmpyrw_rnd">;
+
+def int_hexagon_M7_wcmpyrwc_rnd :
+Hexagon_i32_i64i64_Intrinsic<"HEXAGON_M7_wcmpyrwc_rnd">;
+
+def int_hexagon_M7_wcmpyiw_rnd :
+Hexagon_i32_i64i64_Intrinsic<"HEXAGON_M7_wcmpyiw_rnd">;
+
+def int_hexagon_M7_wcmpyiwc_rnd :
+Hexagon_i32_i64i64_Intrinsic<"HEXAGON_M7_wcmpyiwc_rnd">;
+
+def int_hexagon_A7_croundd_ri :
+Hexagon_i64_i64i32_Intrinsic<"HEXAGON_A7_croundd_ri", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_A7_croundd_rr :
+Hexagon_i64_i64i32_Intrinsic<"HEXAGON_A7_croundd_rr">;
+
+def int_hexagon_A7_clip :
+Hexagon_i32_i32i32_Intrinsic<"HEXAGON_A7_clip", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_A7_vclip :
+Hexagon_i64_i64i32_Intrinsic<"HEXAGON_A7_vclip", [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+def int_hexagon_F2_dfmax :
+Hexagon_double_doubledouble_Intrinsic<"HEXAGON_F2_dfmax", [IntrNoMem, Throws]>;
+
+def int_hexagon_F2_dfmin :
+Hexagon_double_doubledouble_Intrinsic<"HEXAGON_F2_dfmin", [IntrNoMem, Throws]>;
+
+def int_hexagon_F2_dfmpyfix :
+Hexagon_double_doubledouble_Intrinsic<"HEXAGON_F2_dfmpyfix", [IntrNoMem, Throws]>;
+
+def int_hexagon_F2_dfmpyll :
+Hexagon_double_doubledouble_Intrinsic<"HEXAGON_F2_dfmpyll", [IntrNoMem, Throws]>;
+
+def int_hexagon_F2_dfmpylh :
+Hexagon_double_doubledoubledouble_Intrinsic<"HEXAGON_F2_dfmpylh", [IntrNoMem, Throws]>;
+
+def int_hexagon_F2_dfmpyhh :
+Hexagon_double_doubledoubledouble_Intrinsic<"HEXAGON_F2_dfmpyhh", [IntrNoMem, Throws]>;
+
+// V60 HVX Instructions.
+
+def int_hexagon_V6_vS32b_qpred_ai :
+Hexagon_custom__v64i1ptrv16i32_Intrinsic<[IntrWriteMem]>;
+
+def int_hexagon_V6_vS32b_qpred_ai_128B :
+Hexagon_custom__v128i1ptrv32i32_Intrinsic_128B<[IntrWriteMem]>;
+
+def int_hexagon_V6_vS32b_nqpred_ai :
+Hexagon_custom__v64i1ptrv16i32_Intrinsic<[IntrWriteMem]>;
+
+def int_hexagon_V6_vS32b_nqpred_ai_128B :
+Hexagon_custom__v128i1ptrv32i32_Intrinsic_128B<[IntrWriteMem]>;
+
+def int_hexagon_V6_vS32b_nt_qpred_ai :
+Hexagon_custom__v64i1ptrv16i32_Intrinsic<[IntrWriteMem]>;
+
+def int_hexagon_V6_vS32b_nt_qpred_ai_128B :
+Hexagon_custom__v128i1ptrv32i32_Intrinsic_128B<[IntrWriteMem]>;
+
+def int_hexagon_V6_vS32b_nt_nqpred_ai :
+Hexagon_custom__v64i1ptrv16i32_Intrinsic<[IntrWriteMem]>;
+
+def int_hexagon_V6_vS32b_nt_nqpred_ai_128B :
+Hexagon_custom__v128i1ptrv32i32_Intrinsic_128B<[IntrWriteMem]>;
+
+def int_hexagon_V6_valignb :
+Hexagon_v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_valignb">;
+
+def int_hexagon_V6_valignb_128B :
+Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_valignb_128B">;
+
+def int_hexagon_V6_vlalignb :
+Hexagon_v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vlalignb">;
+
+def int_hexagon_V6_vlalignb_128B :
+Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vlalignb_128B">;
+
+def int_hexagon_V6_valignbi :
+Hexagon_v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_valignbi", [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_V6_valignbi_128B :
+Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_valignbi_128B", [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_V6_vlalignbi :
+Hexagon_v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vlalignbi", [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_V6_vlalignbi_128B :
+Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vlalignbi_128B", [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_V6_vror :
+Hexagon_v16i32_v16i32i32_Intrinsic<"HEXAGON_V6_vror">;
+
+def int_hexagon_V6_vror_128B :
+Hexagon_v32i32_v32i32i32_Intrinsic<"HEXAGON_V6_vror_128B">;
+
+def int_hexagon_V6_vunpackub :
+Hexagon_v32i32_v16i32_Intrinsic<"HEXAGON_V6_vunpackub">;
+
+def int_hexagon_V6_vunpackub_128B :
+Hexagon_v64i32_v32i32_Intrinsic<"HEXAGON_V6_vunpackub_128B">;
+
+def int_hexagon_V6_vunpackb :
+Hexagon_v32i32_v16i32_Intrinsic<"HEXAGON_V6_vunpackb">;
+
+def int_hexagon_V6_vunpackb_128B :
+Hexagon_v64i32_v32i32_Intrinsic<"HEXAGON_V6_vunpackb_128B">;
+
+def int_hexagon_V6_vunpackuh :
+Hexagon_v32i32_v16i32_Intrinsic<"HEXAGON_V6_vunpackuh">;
+
+def int_hexagon_V6_vunpackuh_128B :
+Hexagon_v64i32_v32i32_Intrinsic<"HEXAGON_V6_vunpackuh_128B">;
+
+def int_hexagon_V6_vunpackh :
+Hexagon_v32i32_v16i32_Intrinsic<"HEXAGON_V6_vunpackh">;
+
+def int_hexagon_V6_vunpackh_128B :
+Hexagon_v64i32_v32i32_Intrinsic<"HEXAGON_V6_vunpackh_128B">;
+
+def int_hexagon_V6_vunpackob :
+Hexagon_v32i32_v32i32v16i32_Intrinsic<"HEXAGON_V6_vunpackob">;
+
+def int_hexagon_V6_vunpackob_128B :
+Hexagon_v64i32_v64i32v32i32_Intrinsic<"HEXAGON_V6_vunpackob_128B">;
+
+def int_hexagon_V6_vunpackoh :
+Hexagon_v32i32_v32i32v16i32_Intrinsic<"HEXAGON_V6_vunpackoh">;
+
+def int_hexagon_V6_vunpackoh_128B :
+Hexagon_v64i32_v64i32v32i32_Intrinsic<"HEXAGON_V6_vunpackoh_128B">;
+
+def int_hexagon_V6_vpackeb :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vpackeb">;
+
+def int_hexagon_V6_vpackeb_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vpackeb_128B">;
+
+def int_hexagon_V6_vpackeh :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vpackeh">;
+
+def int_hexagon_V6_vpackeh_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vpackeh_128B">;
+
+def int_hexagon_V6_vpackob :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vpackob">;
+
+def int_hexagon_V6_vpackob_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vpackob_128B">;
+
+def int_hexagon_V6_vpackoh :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vpackoh">;
+
+def int_hexagon_V6_vpackoh_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vpackoh_128B">;
+
+def int_hexagon_V6_vpackhub_sat :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vpackhub_sat">;
+
+def int_hexagon_V6_vpackhub_sat_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vpackhub_sat_128B">;
+
+def int_hexagon_V6_vpackhb_sat :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vpackhb_sat">;
+
+def int_hexagon_V6_vpackhb_sat_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vpackhb_sat_128B">;
+
+def int_hexagon_V6_vpackwuh_sat :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vpackwuh_sat">;
+
+def int_hexagon_V6_vpackwuh_sat_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vpackwuh_sat_128B">;
+
+def int_hexagon_V6_vpackwh_sat :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vpackwh_sat">;
+
+def int_hexagon_V6_vpackwh_sat_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vpackwh_sat_128B">;
+
+def int_hexagon_V6_vzb :
+Hexagon_v32i32_v16i32_Intrinsic<"HEXAGON_V6_vzb">;
+
+def int_hexagon_V6_vzb_128B :
+Hexagon_v64i32_v32i32_Intrinsic<"HEXAGON_V6_vzb_128B">;
+
+def int_hexagon_V6_vsb :
+Hexagon_v32i32_v16i32_Intrinsic<"HEXAGON_V6_vsb">;
+
+def int_hexagon_V6_vsb_128B :
+Hexagon_v64i32_v32i32_Intrinsic<"HEXAGON_V6_vsb_128B">;
+
+def int_hexagon_V6_vzh :
+Hexagon_v32i32_v16i32_Intrinsic<"HEXAGON_V6_vzh">;
+
+def int_hexagon_V6_vzh_128B :
+Hexagon_v64i32_v32i32_Intrinsic<"HEXAGON_V6_vzh_128B">;
+
+def int_hexagon_V6_vsh :
+Hexagon_v32i32_v16i32_Intrinsic<"HEXAGON_V6_vsh">;
+
+def int_hexagon_V6_vsh_128B :
+Hexagon_v64i32_v32i32_Intrinsic<"HEXAGON_V6_vsh_128B">;
+
+def int_hexagon_V6_vdmpybus :
+Hexagon_v16i32_v16i32i32_Intrinsic<"HEXAGON_V6_vdmpybus">;
+
+def int_hexagon_V6_vdmpybus_128B :
+Hexagon_v32i32_v32i32i32_Intrinsic<"HEXAGON_V6_vdmpybus_128B">;
+
+def int_hexagon_V6_vdmpybus_acc :
+Hexagon_v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vdmpybus_acc">;
+
+def int_hexagon_V6_vdmpybus_acc_128B :
+Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vdmpybus_acc_128B">;
+
+def int_hexagon_V6_vdmpybus_dv :
+Hexagon_v32i32_v32i32i32_Intrinsic<"HEXAGON_V6_vdmpybus_dv">;
+
+def int_hexagon_V6_vdmpybus_dv_128B :
+Hexagon_v64i32_v64i32i32_Intrinsic<"HEXAGON_V6_vdmpybus_dv_128B">;
+
+def int_hexagon_V6_vdmpybus_dv_acc :
+Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vdmpybus_dv_acc">;
+
+def int_hexagon_V6_vdmpybus_dv_acc_128B :
+Hexagon_v64i32_v64i32v64i32i32_Intrinsic<"HEXAGON_V6_vdmpybus_dv_acc_128B">;
+
+def int_hexagon_V6_vdmpyhb :
+Hexagon_v16i32_v16i32i32_Intrinsic<"HEXAGON_V6_vdmpyhb">;
+
+def int_hexagon_V6_vdmpyhb_128B :
+Hexagon_v32i32_v32i32i32_Intrinsic<"HEXAGON_V6_vdmpyhb_128B">;
+
+def int_hexagon_V6_vdmpyhb_acc :
+Hexagon_v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vdmpyhb_acc">;
+
+def int_hexagon_V6_vdmpyhb_acc_128B :
+Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vdmpyhb_acc_128B">;
+
+def int_hexagon_V6_vdmpyhb_dv :
+Hexagon_v32i32_v32i32i32_Intrinsic<"HEXAGON_V6_vdmpyhb_dv">;
+
+def int_hexagon_V6_vdmpyhb_dv_128B :
+Hexagon_v64i32_v64i32i32_Intrinsic<"HEXAGON_V6_vdmpyhb_dv_128B">;
+
+def int_hexagon_V6_vdmpyhb_dv_acc :
+Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vdmpyhb_dv_acc">;
+
+def int_hexagon_V6_vdmpyhb_dv_acc_128B :
+Hexagon_v64i32_v64i32v64i32i32_Intrinsic<"HEXAGON_V6_vdmpyhb_dv_acc_128B">;
+
+def int_hexagon_V6_vdmpyhvsat :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vdmpyhvsat">;
+
+def int_hexagon_V6_vdmpyhvsat_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vdmpyhvsat_128B">;
+
+def int_hexagon_V6_vdmpyhvsat_acc :
+Hexagon_v16i32_v16i32v16i32v16i32_Intrinsic<"HEXAGON_V6_vdmpyhvsat_acc">;
+
+def int_hexagon_V6_vdmpyhvsat_acc_128B :
+Hexagon_v32i32_v32i32v32i32v32i32_Intrinsic<"HEXAGON_V6_vdmpyhvsat_acc_128B">;
+
+def int_hexagon_V6_vdmpyhsat :
+Hexagon_v16i32_v16i32i32_Intrinsic<"HEXAGON_V6_vdmpyhsat">;
+
+def int_hexagon_V6_vdmpyhsat_128B :
+Hexagon_v32i32_v32i32i32_Intrinsic<"HEXAGON_V6_vdmpyhsat_128B">;
+
+def int_hexagon_V6_vdmpyhsat_acc :
+Hexagon_v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vdmpyhsat_acc">;
+
+def int_hexagon_V6_vdmpyhsat_acc_128B :
+Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vdmpyhsat_acc_128B">;
+
+def int_hexagon_V6_vdmpyhisat :
+Hexagon_v16i32_v32i32i32_Intrinsic<"HEXAGON_V6_vdmpyhisat">;
+
+def int_hexagon_V6_vdmpyhisat_128B :
+Hexagon_v32i32_v64i32i32_Intrinsic<"HEXAGON_V6_vdmpyhisat_128B">;
+
+def int_hexagon_V6_vdmpyhisat_acc :
+Hexagon_v16i32_v16i32v32i32i32_Intrinsic<"HEXAGON_V6_vdmpyhisat_acc">;
+
+def int_hexagon_V6_vdmpyhisat_acc_128B :
+Hexagon_v32i32_v32i32v64i32i32_Intrinsic<"HEXAGON_V6_vdmpyhisat_acc_128B">;
+
+def int_hexagon_V6_vdmpyhsusat :
+Hexagon_v16i32_v16i32i32_Intrinsic<"HEXAGON_V6_vdmpyhsusat">;
+
+def int_hexagon_V6_vdmpyhsusat_128B :
+Hexagon_v32i32_v32i32i32_Intrinsic<"HEXAGON_V6_vdmpyhsusat_128B">;
+
+def int_hexagon_V6_vdmpyhsusat_acc :
+Hexagon_v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vdmpyhsusat_acc">;
+
+def int_hexagon_V6_vdmpyhsusat_acc_128B :
+Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vdmpyhsusat_acc_128B">;
+
+def int_hexagon_V6_vdmpyhsuisat :
+Hexagon_v16i32_v32i32i32_Intrinsic<"HEXAGON_V6_vdmpyhsuisat">;
+
+def int_hexagon_V6_vdmpyhsuisat_128B :
+Hexagon_v32i32_v64i32i32_Intrinsic<"HEXAGON_V6_vdmpyhsuisat_128B">;
+
+def int_hexagon_V6_vdmpyhsuisat_acc :
+Hexagon_v16i32_v16i32v32i32i32_Intrinsic<"HEXAGON_V6_vdmpyhsuisat_acc">;
+
+def int_hexagon_V6_vdmpyhsuisat_acc_128B :
+Hexagon_v32i32_v32i32v64i32i32_Intrinsic<"HEXAGON_V6_vdmpyhsuisat_acc_128B">;
+
+def int_hexagon_V6_vtmpyb :
+Hexagon_v32i32_v32i32i32_Intrinsic<"HEXAGON_V6_vtmpyb">;
+
+def int_hexagon_V6_vtmpyb_128B :
+Hexagon_v64i32_v64i32i32_Intrinsic<"HEXAGON_V6_vtmpyb_128B">;
+
+def int_hexagon_V6_vtmpyb_acc :
+Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vtmpyb_acc">;
+
+def int_hexagon_V6_vtmpyb_acc_128B :
+Hexagon_v64i32_v64i32v64i32i32_Intrinsic<"HEXAGON_V6_vtmpyb_acc_128B">;
+
+def int_hexagon_V6_vtmpybus :
+Hexagon_v32i32_v32i32i32_Intrinsic<"HEXAGON_V6_vtmpybus">;
+
+def int_hexagon_V6_vtmpybus_128B :
+Hexagon_v64i32_v64i32i32_Intrinsic<"HEXAGON_V6_vtmpybus_128B">;
+
+def int_hexagon_V6_vtmpybus_acc :
+Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vtmpybus_acc">;
+
+def int_hexagon_V6_vtmpybus_acc_128B :
+Hexagon_v64i32_v64i32v64i32i32_Intrinsic<"HEXAGON_V6_vtmpybus_acc_128B">;
+
+def int_hexagon_V6_vtmpyhb :
+Hexagon_v32i32_v32i32i32_Intrinsic<"HEXAGON_V6_vtmpyhb">;
+
+def int_hexagon_V6_vtmpyhb_128B :
+Hexagon_v64i32_v64i32i32_Intrinsic<"HEXAGON_V6_vtmpyhb_128B">;
+
+def int_hexagon_V6_vtmpyhb_acc :
+Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vtmpyhb_acc">;
+
+def int_hexagon_V6_vtmpyhb_acc_128B :
+Hexagon_v64i32_v64i32v64i32i32_Intrinsic<"HEXAGON_V6_vtmpyhb_acc_128B">;
+
+def int_hexagon_V6_vrmpyub :
+Hexagon_v16i32_v16i32i32_Intrinsic<"HEXAGON_V6_vrmpyub">;
+
+def int_hexagon_V6_vrmpyub_128B :
+Hexagon_v32i32_v32i32i32_Intrinsic<"HEXAGON_V6_vrmpyub_128B">;
+
+def int_hexagon_V6_vrmpyub_acc :
+Hexagon_v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vrmpyub_acc">;
+
+def int_hexagon_V6_vrmpyub_acc_128B :
+Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vrmpyub_acc_128B">;
+
+def int_hexagon_V6_vrmpyubv :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vrmpyubv">;
+
+def int_hexagon_V6_vrmpyubv_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vrmpyubv_128B">;
+
+def int_hexagon_V6_vrmpyubv_acc :
+Hexagon_v16i32_v16i32v16i32v16i32_Intrinsic<"HEXAGON_V6_vrmpyubv_acc">;
+
+def int_hexagon_V6_vrmpyubv_acc_128B :
+Hexagon_v32i32_v32i32v32i32v32i32_Intrinsic<"HEXAGON_V6_vrmpyubv_acc_128B">;
+
+def int_hexagon_V6_vrmpybv :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vrmpybv">;
+
+def int_hexagon_V6_vrmpybv_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vrmpybv_128B">;
+
+def int_hexagon_V6_vrmpybv_acc :
+Hexagon_v16i32_v16i32v16i32v16i32_Intrinsic<"HEXAGON_V6_vrmpybv_acc">;
+
+def int_hexagon_V6_vrmpybv_acc_128B :
+Hexagon_v32i32_v32i32v32i32v32i32_Intrinsic<"HEXAGON_V6_vrmpybv_acc_128B">;
+
+def int_hexagon_V6_vrmpyubi :
+Hexagon_v32i32_v32i32i32i32_Intrinsic<"HEXAGON_V6_vrmpyubi", [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_V6_vrmpyubi_128B :
+Hexagon_v64i32_v64i32i32i32_Intrinsic<"HEXAGON_V6_vrmpyubi_128B", [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_V6_vrmpyubi_acc :
+Hexagon_v32i32_v32i32v32i32i32i32_Intrinsic<"HEXAGON_V6_vrmpyubi_acc", [IntrNoMem, ImmArg<ArgIndex<3>>]>;
+
+def int_hexagon_V6_vrmpyubi_acc_128B :
+Hexagon_v64i32_v64i32v64i32i32i32_Intrinsic<"HEXAGON_V6_vrmpyubi_acc_128B", [IntrNoMem, ImmArg<ArgIndex<3>>]>;
+
+def int_hexagon_V6_vrmpybus :
+Hexagon_v16i32_v16i32i32_Intrinsic<"HEXAGON_V6_vrmpybus">;
+
+def int_hexagon_V6_vrmpybus_128B :
+Hexagon_v32i32_v32i32i32_Intrinsic<"HEXAGON_V6_vrmpybus_128B">;
+
+def int_hexagon_V6_vrmpybus_acc :
+Hexagon_v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vrmpybus_acc">;
+
+def int_hexagon_V6_vrmpybus_acc_128B :
+Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vrmpybus_acc_128B">;
+
+def int_hexagon_V6_vrmpybusi :
+Hexagon_v32i32_v32i32i32i32_Intrinsic<"HEXAGON_V6_vrmpybusi", [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_V6_vrmpybusi_128B :
+Hexagon_v64i32_v64i32i32i32_Intrinsic<"HEXAGON_V6_vrmpybusi_128B", [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_V6_vrmpybusi_acc :
+Hexagon_v32i32_v32i32v32i32i32i32_Intrinsic<"HEXAGON_V6_vrmpybusi_acc", [IntrNoMem, ImmArg<ArgIndex<3>>]>;
+
+def int_hexagon_V6_vrmpybusi_acc_128B :
+Hexagon_v64i32_v64i32v64i32i32i32_Intrinsic<"HEXAGON_V6_vrmpybusi_acc_128B", [IntrNoMem, ImmArg<ArgIndex<3>>]>;
+
+def int_hexagon_V6_vrmpybusv :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vrmpybusv">;
+
+def int_hexagon_V6_vrmpybusv_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vrmpybusv_128B">;
+
+def int_hexagon_V6_vrmpybusv_acc :
+Hexagon_v16i32_v16i32v16i32v16i32_Intrinsic<"HEXAGON_V6_vrmpybusv_acc">;
+
+def int_hexagon_V6_vrmpybusv_acc_128B :
+Hexagon_v32i32_v32i32v32i32v32i32_Intrinsic<"HEXAGON_V6_vrmpybusv_acc_128B">;
+
+def int_hexagon_V6_vdsaduh :
+Hexagon_v32i32_v32i32i32_Intrinsic<"HEXAGON_V6_vdsaduh">;
+
+def int_hexagon_V6_vdsaduh_128B :
+Hexagon_v64i32_v64i32i32_Intrinsic<"HEXAGON_V6_vdsaduh_128B">;
+
+def int_hexagon_V6_vdsaduh_acc :
+Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vdsaduh_acc">;
+
+def int_hexagon_V6_vdsaduh_acc_128B :
+Hexagon_v64i32_v64i32v64i32i32_Intrinsic<"HEXAGON_V6_vdsaduh_acc_128B">;
+
+def int_hexagon_V6_vrsadubi :
+Hexagon_v32i32_v32i32i32i32_Intrinsic<"HEXAGON_V6_vrsadubi", [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_V6_vrsadubi_128B :
+Hexagon_v64i32_v64i32i32i32_Intrinsic<"HEXAGON_V6_vrsadubi_128B", [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_V6_vrsadubi_acc :
+Hexagon_v32i32_v32i32v32i32i32i32_Intrinsic<"HEXAGON_V6_vrsadubi_acc", [IntrNoMem, ImmArg<ArgIndex<3>>]>;
+
+def int_hexagon_V6_vrsadubi_acc_128B :
+Hexagon_v64i32_v64i32v64i32i32i32_Intrinsic<"HEXAGON_V6_vrsadubi_acc_128B", [IntrNoMem, ImmArg<ArgIndex<3>>]>;
+
+def int_hexagon_V6_vasrw :
+Hexagon_v16i32_v16i32i32_Intrinsic<"HEXAGON_V6_vasrw">;
+
+def int_hexagon_V6_vasrw_128B :
+Hexagon_v32i32_v32i32i32_Intrinsic<"HEXAGON_V6_vasrw_128B">;
+
+def int_hexagon_V6_vaslw :
+Hexagon_v16i32_v16i32i32_Intrinsic<"HEXAGON_V6_vaslw">;
+
+def int_hexagon_V6_vaslw_128B :
+Hexagon_v32i32_v32i32i32_Intrinsic<"HEXAGON_V6_vaslw_128B">;
+
+def int_hexagon_V6_vlsrw :
+Hexagon_v16i32_v16i32i32_Intrinsic<"HEXAGON_V6_vlsrw">;
+
+def int_hexagon_V6_vlsrw_128B :
+Hexagon_v32i32_v32i32i32_Intrinsic<"HEXAGON_V6_vlsrw_128B">;
+
+def int_hexagon_V6_vasrwv :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vasrwv">;
+
+def int_hexagon_V6_vasrwv_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vasrwv_128B">;
+
+def int_hexagon_V6_vaslwv :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vaslwv">;
+
+def int_hexagon_V6_vaslwv_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vaslwv_128B">;
+
+def int_hexagon_V6_vlsrwv :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vlsrwv">;
+
+def int_hexagon_V6_vlsrwv_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vlsrwv_128B">;
+
+def int_hexagon_V6_vasrh :
+Hexagon_v16i32_v16i32i32_Intrinsic<"HEXAGON_V6_vasrh">;
+
+def int_hexagon_V6_vasrh_128B :
+Hexagon_v32i32_v32i32i32_Intrinsic<"HEXAGON_V6_vasrh_128B">;
+
+def int_hexagon_V6_vaslh :
+Hexagon_v16i32_v16i32i32_Intrinsic<"HEXAGON_V6_vaslh">;
+
+def int_hexagon_V6_vaslh_128B :
+Hexagon_v32i32_v32i32i32_Intrinsic<"HEXAGON_V6_vaslh_128B">;
+
+def int_hexagon_V6_vlsrh :
+Hexagon_v16i32_v16i32i32_Intrinsic<"HEXAGON_V6_vlsrh">;
+
+def int_hexagon_V6_vlsrh_128B :
+Hexagon_v32i32_v32i32i32_Intrinsic<"HEXAGON_V6_vlsrh_128B">;
+
+def int_hexagon_V6_vasrhv :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vasrhv">;
+
+def int_hexagon_V6_vasrhv_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vasrhv_128B">;
+
+def int_hexagon_V6_vaslhv :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vaslhv">;
+
+def int_hexagon_V6_vaslhv_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vaslhv_128B">;
+
+def int_hexagon_V6_vlsrhv :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vlsrhv">;
+
+def int_hexagon_V6_vlsrhv_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vlsrhv_128B">;
+
+def int_hexagon_V6_vasrwh :
+Hexagon_v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vasrwh">;
+
+def int_hexagon_V6_vasrwh_128B :
+Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vasrwh_128B">;
+
+def int_hexagon_V6_vasrwhsat :
+Hexagon_v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vasrwhsat">;
+
+def int_hexagon_V6_vasrwhsat_128B :
+Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vasrwhsat_128B">;
+
+def int_hexagon_V6_vasrwhrndsat :
+Hexagon_v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vasrwhrndsat">;
+
+def int_hexagon_V6_vasrwhrndsat_128B :
+Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vasrwhrndsat_128B">;
+
+def int_hexagon_V6_vasrwuhsat :
+Hexagon_v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vasrwuhsat">;
+
+def int_hexagon_V6_vasrwuhsat_128B :
+Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vasrwuhsat_128B">;
+
+def int_hexagon_V6_vroundwh :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vroundwh">;
+
+def int_hexagon_V6_vroundwh_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vroundwh_128B">;
+
+def int_hexagon_V6_vroundwuh :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vroundwuh">;
+
+def int_hexagon_V6_vroundwuh_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vroundwuh_128B">;
+
+def int_hexagon_V6_vasrhubsat :
+Hexagon_v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vasrhubsat">;
+
+def int_hexagon_V6_vasrhubsat_128B :
+Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vasrhubsat_128B">;
+
+def int_hexagon_V6_vasrhubrndsat :
+Hexagon_v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vasrhubrndsat">;
+
+def int_hexagon_V6_vasrhubrndsat_128B :
+Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vasrhubrndsat_128B">;
+
+def int_hexagon_V6_vasrhbrndsat :
+Hexagon_v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vasrhbrndsat">;
+
+def int_hexagon_V6_vasrhbrndsat_128B :
+Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vasrhbrndsat_128B">;
+
+def int_hexagon_V6_vroundhb :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vroundhb">;
+
+def int_hexagon_V6_vroundhb_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vroundhb_128B">;
+
+def int_hexagon_V6_vroundhub :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vroundhub">;
+
+def int_hexagon_V6_vroundhub_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vroundhub_128B">;
+
+def int_hexagon_V6_vaslw_acc :
+Hexagon_v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vaslw_acc">;
+
+def int_hexagon_V6_vaslw_acc_128B :
+Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vaslw_acc_128B">;
+
+def int_hexagon_V6_vasrw_acc :
+Hexagon_v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vasrw_acc">;
+
+def int_hexagon_V6_vasrw_acc_128B :
+Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vasrw_acc_128B">;
+
+def int_hexagon_V6_vaddb :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vaddb">;
+
+def int_hexagon_V6_vaddb_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vaddb_128B">;
+
+def int_hexagon_V6_vsubb :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vsubb">;
+
+def int_hexagon_V6_vsubb_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vsubb_128B">;
+
+def int_hexagon_V6_vaddb_dv :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vaddb_dv">;
+
+def int_hexagon_V6_vaddb_dv_128B :
+Hexagon_v64i32_v64i32v64i32_Intrinsic<"HEXAGON_V6_vaddb_dv_128B">;
+
+def int_hexagon_V6_vsubb_dv :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vsubb_dv">;
+
+def int_hexagon_V6_vsubb_dv_128B :
+Hexagon_v64i32_v64i32v64i32_Intrinsic<"HEXAGON_V6_vsubb_dv_128B">;
+
+def int_hexagon_V6_vaddh :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vaddh">;
+
+def int_hexagon_V6_vaddh_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vaddh_128B">;
+
+def int_hexagon_V6_vsubh :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vsubh">;
+
+def int_hexagon_V6_vsubh_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vsubh_128B">;
+
+def int_hexagon_V6_vaddh_dv :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vaddh_dv">;
+
+def int_hexagon_V6_vaddh_dv_128B :
+Hexagon_v64i32_v64i32v64i32_Intrinsic<"HEXAGON_V6_vaddh_dv_128B">;
+
+def int_hexagon_V6_vsubh_dv :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vsubh_dv">;
+
+def int_hexagon_V6_vsubh_dv_128B :
+Hexagon_v64i32_v64i32v64i32_Intrinsic<"HEXAGON_V6_vsubh_dv_128B">;
+
+def int_hexagon_V6_vaddw :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vaddw">;
+
+def int_hexagon_V6_vaddw_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vaddw_128B">;
+
+def int_hexagon_V6_vsubw :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vsubw">;
+
+def int_hexagon_V6_vsubw_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vsubw_128B">;
+
+def int_hexagon_V6_vaddw_dv :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vaddw_dv">;
+
+def int_hexagon_V6_vaddw_dv_128B :
+Hexagon_v64i32_v64i32v64i32_Intrinsic<"HEXAGON_V6_vaddw_dv_128B">;
+
+def int_hexagon_V6_vsubw_dv :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vsubw_dv">;
+
+def int_hexagon_V6_vsubw_dv_128B :
+Hexagon_v64i32_v64i32v64i32_Intrinsic<"HEXAGON_V6_vsubw_dv_128B">;
+
+def int_hexagon_V6_vaddubsat :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vaddubsat">;
+
+def int_hexagon_V6_vaddubsat_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vaddubsat_128B">;
+
+def int_hexagon_V6_vaddubsat_dv :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vaddubsat_dv">;
+
+def int_hexagon_V6_vaddubsat_dv_128B :
+Hexagon_v64i32_v64i32v64i32_Intrinsic<"HEXAGON_V6_vaddubsat_dv_128B">;
+
+def int_hexagon_V6_vsububsat :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vsububsat">;
+
+def int_hexagon_V6_vsububsat_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vsububsat_128B">;
+
+def int_hexagon_V6_vsububsat_dv :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vsububsat_dv">;
+
+def int_hexagon_V6_vsububsat_dv_128B :
+Hexagon_v64i32_v64i32v64i32_Intrinsic<"HEXAGON_V6_vsububsat_dv_128B">;
+
+def int_hexagon_V6_vadduhsat :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vadduhsat">;
+
+def int_hexagon_V6_vadduhsat_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vadduhsat_128B">;
+
+def int_hexagon_V6_vadduhsat_dv :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vadduhsat_dv">;
+
+def int_hexagon_V6_vadduhsat_dv_128B :
+Hexagon_v64i32_v64i32v64i32_Intrinsic<"HEXAGON_V6_vadduhsat_dv_128B">;
+
+def int_hexagon_V6_vsubuhsat :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vsubuhsat">;
+
+def int_hexagon_V6_vsubuhsat_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vsubuhsat_128B">;
+
+def int_hexagon_V6_vsubuhsat_dv :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vsubuhsat_dv">;
+
+def int_hexagon_V6_vsubuhsat_dv_128B :
+Hexagon_v64i32_v64i32v64i32_Intrinsic<"HEXAGON_V6_vsubuhsat_dv_128B">;
+
+def int_hexagon_V6_vaddhsat :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vaddhsat">;
+
+def int_hexagon_V6_vaddhsat_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vaddhsat_128B">;
+
+def int_hexagon_V6_vaddhsat_dv :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vaddhsat_dv">;
+
+def int_hexagon_V6_vaddhsat_dv_128B :
+Hexagon_v64i32_v64i32v64i32_Intrinsic<"HEXAGON_V6_vaddhsat_dv_128B">;
+
+def int_hexagon_V6_vsubhsat :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vsubhsat">;
+
+def int_hexagon_V6_vsubhsat_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vsubhsat_128B">;
+
+def int_hexagon_V6_vsubhsat_dv :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vsubhsat_dv">;
+
+def int_hexagon_V6_vsubhsat_dv_128B :
+Hexagon_v64i32_v64i32v64i32_Intrinsic<"HEXAGON_V6_vsubhsat_dv_128B">;
+
+def int_hexagon_V6_vaddwsat :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vaddwsat">;
+
+def int_hexagon_V6_vaddwsat_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vaddwsat_128B">;
+
+def int_hexagon_V6_vaddwsat_dv :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vaddwsat_dv">;
+
+def int_hexagon_V6_vaddwsat_dv_128B :
+Hexagon_v64i32_v64i32v64i32_Intrinsic<"HEXAGON_V6_vaddwsat_dv_128B">;
+
+def int_hexagon_V6_vsubwsat :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vsubwsat">;
+
+def int_hexagon_V6_vsubwsat_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vsubwsat_128B">;
+
+def int_hexagon_V6_vsubwsat_dv :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vsubwsat_dv">;
+
+def int_hexagon_V6_vsubwsat_dv_128B :
+Hexagon_v64i32_v64i32v64i32_Intrinsic<"HEXAGON_V6_vsubwsat_dv_128B">;
+
+def int_hexagon_V6_vavgub :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vavgub">;
+
+def int_hexagon_V6_vavgub_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vavgub_128B">;
+
+def int_hexagon_V6_vavgubrnd :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vavgubrnd">;
+
+def int_hexagon_V6_vavgubrnd_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vavgubrnd_128B">;
+
+def int_hexagon_V6_vavguh :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vavguh">;
+
+def int_hexagon_V6_vavguh_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vavguh_128B">;
+
+def int_hexagon_V6_vavguhrnd :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vavguhrnd">;
+
+def int_hexagon_V6_vavguhrnd_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vavguhrnd_128B">;
+
+def int_hexagon_V6_vavgh :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vavgh">;
+
+def int_hexagon_V6_vavgh_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vavgh_128B">;
+
+def int_hexagon_V6_vavghrnd :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vavghrnd">;
+
+def int_hexagon_V6_vavghrnd_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vavghrnd_128B">;
+
+def int_hexagon_V6_vnavgh :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vnavgh">;
+
+def int_hexagon_V6_vnavgh_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vnavgh_128B">;
+
+def int_hexagon_V6_vavgw :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vavgw">;
+
+def int_hexagon_V6_vavgw_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vavgw_128B">;
+
+def int_hexagon_V6_vavgwrnd :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vavgwrnd">;
+
+def int_hexagon_V6_vavgwrnd_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vavgwrnd_128B">;
+
+def int_hexagon_V6_vnavgw :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vnavgw">;
+
+def int_hexagon_V6_vnavgw_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vnavgw_128B">;
+
+def int_hexagon_V6_vabsdiffub :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vabsdiffub">;
+
+def int_hexagon_V6_vabsdiffub_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vabsdiffub_128B">;
+
+def int_hexagon_V6_vabsdiffuh :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vabsdiffuh">;
+
+def int_hexagon_V6_vabsdiffuh_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vabsdiffuh_128B">;
+
+def int_hexagon_V6_vabsdiffh :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vabsdiffh">;
+
+def int_hexagon_V6_vabsdiffh_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vabsdiffh_128B">;
+
+def int_hexagon_V6_vabsdiffw :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vabsdiffw">;
+
+def int_hexagon_V6_vabsdiffw_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vabsdiffw_128B">;
+
+def int_hexagon_V6_vnavgub :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vnavgub">;
+
+def int_hexagon_V6_vnavgub_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vnavgub_128B">;
+
+def int_hexagon_V6_vaddubh :
+Hexagon_v32i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vaddubh">;
+
+def int_hexagon_V6_vaddubh_128B :
+Hexagon_v64i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vaddubh_128B">;
+
+def int_hexagon_V6_vsububh :
+Hexagon_v32i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vsububh">;
+
+def int_hexagon_V6_vsububh_128B :
+Hexagon_v64i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vsububh_128B">;
+
+def int_hexagon_V6_vaddhw :
+Hexagon_v32i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vaddhw">;
+
+def int_hexagon_V6_vaddhw_128B :
+Hexagon_v64i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vaddhw_128B">;
+
+def int_hexagon_V6_vsubhw :
+Hexagon_v32i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vsubhw">;
+
+def int_hexagon_V6_vsubhw_128B :
+Hexagon_v64i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vsubhw_128B">;
+
+def int_hexagon_V6_vadduhw :
+Hexagon_v32i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vadduhw">;
+
+def int_hexagon_V6_vadduhw_128B :
+Hexagon_v64i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vadduhw_128B">;
+
+def int_hexagon_V6_vsubuhw :
+Hexagon_v32i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vsubuhw">;
+
+def int_hexagon_V6_vsubuhw_128B :
+Hexagon_v64i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vsubuhw_128B">;
+
+def int_hexagon_V6_vd0 :
+Hexagon_v16i32__Intrinsic<"HEXAGON_V6_vd0">;
+
+def int_hexagon_V6_vd0_128B :
+Hexagon_v32i32__Intrinsic<"HEXAGON_V6_vd0_128B">;
+
+def int_hexagon_V6_vaddbq :
+Hexagon_custom_v16i32_v64i1v16i32v16i32_Intrinsic;
+
+def int_hexagon_V6_vaddbq_128B :
+Hexagon_custom_v32i32_v128i1v32i32v32i32_Intrinsic_128B;
+
+def int_hexagon_V6_vsubbq :
+Hexagon_custom_v16i32_v64i1v16i32v16i32_Intrinsic;
+
+def int_hexagon_V6_vsubbq_128B :
+Hexagon_custom_v32i32_v128i1v32i32v32i32_Intrinsic_128B;
+
+def int_hexagon_V6_vaddbnq :
+Hexagon_custom_v16i32_v64i1v16i32v16i32_Intrinsic;
+
+def int_hexagon_V6_vaddbnq_128B :
+Hexagon_custom_v32i32_v128i1v32i32v32i32_Intrinsic_128B;
+
+def int_hexagon_V6_vsubbnq :
+Hexagon_custom_v16i32_v64i1v16i32v16i32_Intrinsic;
+
+def int_hexagon_V6_vsubbnq_128B :
+Hexagon_custom_v32i32_v128i1v32i32v32i32_Intrinsic_128B;
+
+def int_hexagon_V6_vaddhq :
+Hexagon_custom_v16i32_v64i1v16i32v16i32_Intrinsic;
+
+def int_hexagon_V6_vaddhq_128B :
+Hexagon_custom_v32i32_v128i1v32i32v32i32_Intrinsic_128B;
+
+def int_hexagon_V6_vsubhq :
+Hexagon_custom_v16i32_v64i1v16i32v16i32_Intrinsic;
+
+def int_hexagon_V6_vsubhq_128B :
+Hexagon_custom_v32i32_v128i1v32i32v32i32_Intrinsic_128B;
+
+def int_hexagon_V6_vaddhnq :
+Hexagon_custom_v16i32_v64i1v16i32v16i32_Intrinsic;
+
+def int_hexagon_V6_vaddhnq_128B :
+Hexagon_custom_v32i32_v128i1v32i32v32i32_Intrinsic_128B;
+
+def int_hexagon_V6_vsubhnq :
+Hexagon_custom_v16i32_v64i1v16i32v16i32_Intrinsic;
+
+def int_hexagon_V6_vsubhnq_128B :
+Hexagon_custom_v32i32_v128i1v32i32v32i32_Intrinsic_128B;
+
+def int_hexagon_V6_vaddwq :
+Hexagon_custom_v16i32_v64i1v16i32v16i32_Intrinsic;
+
+def int_hexagon_V6_vaddwq_128B :
+Hexagon_custom_v32i32_v128i1v32i32v32i32_Intrinsic_128B;
+
+def int_hexagon_V6_vsubwq :
+Hexagon_custom_v16i32_v64i1v16i32v16i32_Intrinsic;
+
+def int_hexagon_V6_vsubwq_128B :
+Hexagon_custom_v32i32_v128i1v32i32v32i32_Intrinsic_128B;
+
+def int_hexagon_V6_vaddwnq :
+Hexagon_custom_v16i32_v64i1v16i32v16i32_Intrinsic;
+
+def int_hexagon_V6_vaddwnq_128B :
+Hexagon_custom_v32i32_v128i1v32i32v32i32_Intrinsic_128B;
+
+def int_hexagon_V6_vsubwnq :
+Hexagon_custom_v16i32_v64i1v16i32v16i32_Intrinsic;
+
+def int_hexagon_V6_vsubwnq_128B :
+Hexagon_custom_v32i32_v128i1v32i32v32i32_Intrinsic_128B;
+
+def int_hexagon_V6_vabsh :
+Hexagon_v16i32_v16i32_Intrinsic<"HEXAGON_V6_vabsh">;
+
+def int_hexagon_V6_vabsh_128B :
+Hexagon_v32i32_v32i32_Intrinsic<"HEXAGON_V6_vabsh_128B">;
+
+def int_hexagon_V6_vabsh_sat :
+Hexagon_v16i32_v16i32_Intrinsic<"HEXAGON_V6_vabsh_sat">;
+
+def int_hexagon_V6_vabsh_sat_128B :
+Hexagon_v32i32_v32i32_Intrinsic<"HEXAGON_V6_vabsh_sat_128B">;
+
+def int_hexagon_V6_vabsw :
+Hexagon_v16i32_v16i32_Intrinsic<"HEXAGON_V6_vabsw">;
+
+def int_hexagon_V6_vabsw_128B :
+Hexagon_v32i32_v32i32_Intrinsic<"HEXAGON_V6_vabsw_128B">;
+
+def int_hexagon_V6_vabsw_sat :
+Hexagon_v16i32_v16i32_Intrinsic<"HEXAGON_V6_vabsw_sat">;
+
+def int_hexagon_V6_vabsw_sat_128B :
+Hexagon_v32i32_v32i32_Intrinsic<"HEXAGON_V6_vabsw_sat_128B">;
+
+def int_hexagon_V6_vmpybv :
+Hexagon_v32i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vmpybv">;
+
+def int_hexagon_V6_vmpybv_128B :
+Hexagon_v64i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vmpybv_128B">;
+
+def int_hexagon_V6_vmpybv_acc :
+Hexagon_v32i32_v32i32v16i32v16i32_Intrinsic<"HEXAGON_V6_vmpybv_acc">;
+
+def int_hexagon_V6_vmpybv_acc_128B :
+Hexagon_v64i32_v64i32v32i32v32i32_Intrinsic<"HEXAGON_V6_vmpybv_acc_128B">;
+
+def int_hexagon_V6_vmpyubv :
+Hexagon_v32i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vmpyubv">;
+
+def int_hexagon_V6_vmpyubv_128B :
+Hexagon_v64i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vmpyubv_128B">;
+
+def int_hexagon_V6_vmpyubv_acc :
+Hexagon_v32i32_v32i32v16i32v16i32_Intrinsic<"HEXAGON_V6_vmpyubv_acc">;
+
+def int_hexagon_V6_vmpyubv_acc_128B :
+Hexagon_v64i32_v64i32v32i32v32i32_Intrinsic<"HEXAGON_V6_vmpyubv_acc_128B">;
+
+def int_hexagon_V6_vmpybusv :
+Hexagon_v32i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vmpybusv">;
+
+def int_hexagon_V6_vmpybusv_128B :
+Hexagon_v64i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vmpybusv_128B">;
+
+def int_hexagon_V6_vmpybusv_acc :
+Hexagon_v32i32_v32i32v16i32v16i32_Intrinsic<"HEXAGON_V6_vmpybusv_acc">;
+
+def int_hexagon_V6_vmpybusv_acc_128B :
+Hexagon_v64i32_v64i32v32i32v32i32_Intrinsic<"HEXAGON_V6_vmpybusv_acc_128B">;
+
+def int_hexagon_V6_vmpabusv :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vmpabusv">;
+
+def int_hexagon_V6_vmpabusv_128B :
+Hexagon_v64i32_v64i32v64i32_Intrinsic<"HEXAGON_V6_vmpabusv_128B">;
+
+def int_hexagon_V6_vmpabuuv :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vmpabuuv">;
+
+def int_hexagon_V6_vmpabuuv_128B :
+Hexagon_v64i32_v64i32v64i32_Intrinsic<"HEXAGON_V6_vmpabuuv_128B">;
+
+def int_hexagon_V6_vmpyhv :
+Hexagon_v32i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vmpyhv">;
+
+def int_hexagon_V6_vmpyhv_128B :
+Hexagon_v64i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vmpyhv_128B">;
+
+def int_hexagon_V6_vmpyhv_acc :
+Hexagon_v32i32_v32i32v16i32v16i32_Intrinsic<"HEXAGON_V6_vmpyhv_acc">;
+
+def int_hexagon_V6_vmpyhv_acc_128B :
+Hexagon_v64i32_v64i32v32i32v32i32_Intrinsic<"HEXAGON_V6_vmpyhv_acc_128B">;
+
+def int_hexagon_V6_vmpyuhv :
+Hexagon_v32i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vmpyuhv">;
+
+def int_hexagon_V6_vmpyuhv_128B :
+Hexagon_v64i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vmpyuhv_128B">;
+
+def int_hexagon_V6_vmpyuhv_acc :
+Hexagon_v32i32_v32i32v16i32v16i32_Intrinsic<"HEXAGON_V6_vmpyuhv_acc">;
+
+def int_hexagon_V6_vmpyuhv_acc_128B :
+Hexagon_v64i32_v64i32v32i32v32i32_Intrinsic<"HEXAGON_V6_vmpyuhv_acc_128B">;
+
+def int_hexagon_V6_vmpyhvsrs :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vmpyhvsrs">;
+
+def int_hexagon_V6_vmpyhvsrs_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vmpyhvsrs_128B">;
+
+def int_hexagon_V6_vmpyhus :
+Hexagon_v32i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vmpyhus">;
+
+def int_hexagon_V6_vmpyhus_128B :
+Hexagon_v64i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vmpyhus_128B">;
+
+def int_hexagon_V6_vmpyhus_acc :
+Hexagon_v32i32_v32i32v16i32v16i32_Intrinsic<"HEXAGON_V6_vmpyhus_acc">;
+
+def int_hexagon_V6_vmpyhus_acc_128B :
+Hexagon_v64i32_v64i32v32i32v32i32_Intrinsic<"HEXAGON_V6_vmpyhus_acc_128B">;
+
+def int_hexagon_V6_vmpyih :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vmpyih">;
+
+def int_hexagon_V6_vmpyih_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vmpyih_128B">;
+
+def int_hexagon_V6_vmpyih_acc :
+Hexagon_v16i32_v16i32v16i32v16i32_Intrinsic<"HEXAGON_V6_vmpyih_acc">;
+
+def int_hexagon_V6_vmpyih_acc_128B :
+Hexagon_v32i32_v32i32v32i32v32i32_Intrinsic<"HEXAGON_V6_vmpyih_acc_128B">;
+
+def int_hexagon_V6_vmpyewuh :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vmpyewuh">;
+
+def int_hexagon_V6_vmpyewuh_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vmpyewuh_128B">;
+
+def int_hexagon_V6_vmpyowh :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vmpyowh">;
+
+def int_hexagon_V6_vmpyowh_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vmpyowh_128B">;
+
+def int_hexagon_V6_vmpyowh_rnd :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vmpyowh_rnd">;
+
+def int_hexagon_V6_vmpyowh_rnd_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vmpyowh_rnd_128B">;
+
+def int_hexagon_V6_vmpyowh_sacc :
+Hexagon_v16i32_v16i32v16i32v16i32_Intrinsic<"HEXAGON_V6_vmpyowh_sacc">;
+
+def int_hexagon_V6_vmpyowh_sacc_128B :
+Hexagon_v32i32_v32i32v32i32v32i32_Intrinsic<"HEXAGON_V6_vmpyowh_sacc_128B">;
+
+def int_hexagon_V6_vmpyowh_rnd_sacc :
+Hexagon_v16i32_v16i32v16i32v16i32_Intrinsic<"HEXAGON_V6_vmpyowh_rnd_sacc">;
+
+def int_hexagon_V6_vmpyowh_rnd_sacc_128B :
+Hexagon_v32i32_v32i32v32i32v32i32_Intrinsic<"HEXAGON_V6_vmpyowh_rnd_sacc_128B">;
+
+def int_hexagon_V6_vmpyieoh :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vmpyieoh">;
+
+def int_hexagon_V6_vmpyieoh_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vmpyieoh_128B">;
+
+def int_hexagon_V6_vmpyiewuh :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vmpyiewuh">;
+
+def int_hexagon_V6_vmpyiewuh_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vmpyiewuh_128B">;
+
+def int_hexagon_V6_vmpyiowh :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vmpyiowh">;
+
+def int_hexagon_V6_vmpyiowh_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vmpyiowh_128B">;
+
+def int_hexagon_V6_vmpyiewh_acc :
+Hexagon_v16i32_v16i32v16i32v16i32_Intrinsic<"HEXAGON_V6_vmpyiewh_acc">;
+
+def int_hexagon_V6_vmpyiewh_acc_128B :
+Hexagon_v32i32_v32i32v32i32v32i32_Intrinsic<"HEXAGON_V6_vmpyiewh_acc_128B">;
+
+def int_hexagon_V6_vmpyiewuh_acc :
+Hexagon_v16i32_v16i32v16i32v16i32_Intrinsic<"HEXAGON_V6_vmpyiewuh_acc">;
+
+def int_hexagon_V6_vmpyiewuh_acc_128B :
+Hexagon_v32i32_v32i32v32i32v32i32_Intrinsic<"HEXAGON_V6_vmpyiewuh_acc_128B">;
+
+def int_hexagon_V6_vmpyub :
+Hexagon_v32i32_v16i32i32_Intrinsic<"HEXAGON_V6_vmpyub">;
+
+def int_hexagon_V6_vmpyub_128B :
+Hexagon_v64i32_v32i32i32_Intrinsic<"HEXAGON_V6_vmpyub_128B">;
+
+def int_hexagon_V6_vmpyub_acc :
+Hexagon_v32i32_v32i32v16i32i32_Intrinsic<"HEXAGON_V6_vmpyub_acc">;
+
+def int_hexagon_V6_vmpyub_acc_128B :
+Hexagon_v64i32_v64i32v32i32i32_Intrinsic<"HEXAGON_V6_vmpyub_acc_128B">;
+
+def int_hexagon_V6_vmpybus :
+Hexagon_v32i32_v16i32i32_Intrinsic<"HEXAGON_V6_vmpybus">;
+
+def int_hexagon_V6_vmpybus_128B :
+Hexagon_v64i32_v32i32i32_Intrinsic<"HEXAGON_V6_vmpybus_128B">;
+
+def int_hexagon_V6_vmpybus_acc :
+Hexagon_v32i32_v32i32v16i32i32_Intrinsic<"HEXAGON_V6_vmpybus_acc">;
+
+def int_hexagon_V6_vmpybus_acc_128B :
+Hexagon_v64i32_v64i32v32i32i32_Intrinsic<"HEXAGON_V6_vmpybus_acc_128B">;
+
+def int_hexagon_V6_vmpabus :
+Hexagon_v32i32_v32i32i32_Intrinsic<"HEXAGON_V6_vmpabus">;
+
+def int_hexagon_V6_vmpabus_128B :
+Hexagon_v64i32_v64i32i32_Intrinsic<"HEXAGON_V6_vmpabus_128B">;
+
+def int_hexagon_V6_vmpabus_acc :
+Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vmpabus_acc">;
+
+def int_hexagon_V6_vmpabus_acc_128B :
+Hexagon_v64i32_v64i32v64i32i32_Intrinsic<"HEXAGON_V6_vmpabus_acc_128B">;
+
+def int_hexagon_V6_vmpahb :
+Hexagon_v32i32_v32i32i32_Intrinsic<"HEXAGON_V6_vmpahb">;
+
+def int_hexagon_V6_vmpahb_128B :
+Hexagon_v64i32_v64i32i32_Intrinsic<"HEXAGON_V6_vmpahb_128B">;
+
+def int_hexagon_V6_vmpahb_acc :
+Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vmpahb_acc">;
+
+def int_hexagon_V6_vmpahb_acc_128B :
+Hexagon_v64i32_v64i32v64i32i32_Intrinsic<"HEXAGON_V6_vmpahb_acc_128B">;
+
+def int_hexagon_V6_vmpyh :
+Hexagon_v32i32_v16i32i32_Intrinsic<"HEXAGON_V6_vmpyh">;
+
+def int_hexagon_V6_vmpyh_128B :
+Hexagon_v64i32_v32i32i32_Intrinsic<"HEXAGON_V6_vmpyh_128B">;
+
+def int_hexagon_V6_vmpyhsat_acc :
+Hexagon_v32i32_v32i32v16i32i32_Intrinsic<"HEXAGON_V6_vmpyhsat_acc">;
+
+def int_hexagon_V6_vmpyhsat_acc_128B :
+Hexagon_v64i32_v64i32v32i32i32_Intrinsic<"HEXAGON_V6_vmpyhsat_acc_128B">;
+
+def int_hexagon_V6_vmpyhss :
+Hexagon_v16i32_v16i32i32_Intrinsic<"HEXAGON_V6_vmpyhss">;
+
+def int_hexagon_V6_vmpyhss_128B :
+Hexagon_v32i32_v32i32i32_Intrinsic<"HEXAGON_V6_vmpyhss_128B">;
+
+def int_hexagon_V6_vmpyhsrs :
+Hexagon_v16i32_v16i32i32_Intrinsic<"HEXAGON_V6_vmpyhsrs">;
+
+def int_hexagon_V6_vmpyhsrs_128B :
+Hexagon_v32i32_v32i32i32_Intrinsic<"HEXAGON_V6_vmpyhsrs_128B">;
+
+def int_hexagon_V6_vmpyuh :
+Hexagon_v32i32_v16i32i32_Intrinsic<"HEXAGON_V6_vmpyuh">;
+
+def int_hexagon_V6_vmpyuh_128B :
+Hexagon_v64i32_v32i32i32_Intrinsic<"HEXAGON_V6_vmpyuh_128B">;
+
+def int_hexagon_V6_vmpyuh_acc :
+Hexagon_v32i32_v32i32v16i32i32_Intrinsic<"HEXAGON_V6_vmpyuh_acc">;
+
+def int_hexagon_V6_vmpyuh_acc_128B :
+Hexagon_v64i32_v64i32v32i32i32_Intrinsic<"HEXAGON_V6_vmpyuh_acc_128B">;
+
+def int_hexagon_V6_vmpyihb :
+Hexagon_v16i32_v16i32i32_Intrinsic<"HEXAGON_V6_vmpyihb">;
+
+def int_hexagon_V6_vmpyihb_128B :
+Hexagon_v32i32_v32i32i32_Intrinsic<"HEXAGON_V6_vmpyihb_128B">;
+
+def int_hexagon_V6_vmpyihb_acc :
+Hexagon_v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vmpyihb_acc">;
+
+def int_hexagon_V6_vmpyihb_acc_128B :
+Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vmpyihb_acc_128B">;
+
+def int_hexagon_V6_vmpyiwb :
+Hexagon_v16i32_v16i32i32_Intrinsic<"HEXAGON_V6_vmpyiwb">;
+
+def int_hexagon_V6_vmpyiwb_128B :
+Hexagon_v32i32_v32i32i32_Intrinsic<"HEXAGON_V6_vmpyiwb_128B">;
+
+def int_hexagon_V6_vmpyiwb_acc :
+Hexagon_v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vmpyiwb_acc">;
+
+def int_hexagon_V6_vmpyiwb_acc_128B :
+Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vmpyiwb_acc_128B">;
+
+def int_hexagon_V6_vmpyiwh :
+Hexagon_v16i32_v16i32i32_Intrinsic<"HEXAGON_V6_vmpyiwh">;
+
+def int_hexagon_V6_vmpyiwh_128B :
+Hexagon_v32i32_v32i32i32_Intrinsic<"HEXAGON_V6_vmpyiwh_128B">;
+
+def int_hexagon_V6_vmpyiwh_acc :
+Hexagon_v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vmpyiwh_acc">;
+
+def int_hexagon_V6_vmpyiwh_acc_128B :
+Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vmpyiwh_acc_128B">;
+
+def int_hexagon_V6_vand :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vand">;
+
+def int_hexagon_V6_vand_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vand_128B">;
+
+def int_hexagon_V6_vor :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vor">;
+
+def int_hexagon_V6_vor_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vor_128B">;
+
+def int_hexagon_V6_vxor :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vxor">;
+
+def int_hexagon_V6_vxor_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vxor_128B">;
+
+def int_hexagon_V6_vnot :
+Hexagon_v16i32_v16i32_Intrinsic<"HEXAGON_V6_vnot">;
+
+def int_hexagon_V6_vnot_128B :
+Hexagon_v32i32_v32i32_Intrinsic<"HEXAGON_V6_vnot_128B">;
+
+def int_hexagon_V6_vandqrt :
+Hexagon_custom_v16i32_v64i1i32_Intrinsic;
+
+def int_hexagon_V6_vandqrt_128B :
+Hexagon_custom_v32i32_v128i1i32_Intrinsic_128B;
+
+def int_hexagon_V6_vandqrt_acc :
+Hexagon_custom_v16i32_v16i32v64i1i32_Intrinsic;
+
+def int_hexagon_V6_vandqrt_acc_128B :
+Hexagon_custom_v32i32_v32i32v128i1i32_Intrinsic_128B;
+
+def int_hexagon_V6_vandvrt :
+Hexagon_custom_v64i1_v16i32i32_Intrinsic;
+
+def int_hexagon_V6_vandvrt_128B :
+Hexagon_custom_v128i1_v32i32i32_Intrinsic_128B;
+
+def int_hexagon_V6_vandvrt_acc :
+Hexagon_custom_v64i1_v64i1v16i32i32_Intrinsic;
+
+def int_hexagon_V6_vandvrt_acc_128B :
+Hexagon_custom_v128i1_v128i1v32i32i32_Intrinsic_128B;
+
+def int_hexagon_V6_vgtw :
+Hexagon_custom_v64i1_v16i32v16i32_Intrinsic;
+
+def int_hexagon_V6_vgtw_128B :
+Hexagon_custom_v128i1_v32i32v32i32_Intrinsic_128B;
+
+def int_hexagon_V6_vgtw_and :
+Hexagon_custom_v64i1_v64i1v16i32v16i32_Intrinsic;
+
+def int_hexagon_V6_vgtw_and_128B :
+Hexagon_custom_v128i1_v128i1v32i32v32i32_Intrinsic_128B;
+
+def int_hexagon_V6_vgtw_or :
+Hexagon_custom_v64i1_v64i1v16i32v16i32_Intrinsic;
+
+def int_hexagon_V6_vgtw_or_128B :
+Hexagon_custom_v128i1_v128i1v32i32v32i32_Intrinsic_128B;
+
+def int_hexagon_V6_vgtw_xor :
+Hexagon_custom_v64i1_v64i1v16i32v16i32_Intrinsic;
+
+def int_hexagon_V6_vgtw_xor_128B :
+Hexagon_custom_v128i1_v128i1v32i32v32i32_Intrinsic_128B;
+
+def int_hexagon_V6_veqw :
+Hexagon_custom_v64i1_v16i32v16i32_Intrinsic;
+
+def int_hexagon_V6_veqw_128B :
+Hexagon_custom_v128i1_v32i32v32i32_Intrinsic_128B;
+
+def int_hexagon_V6_veqw_and :
+Hexagon_custom_v64i1_v64i1v16i32v16i32_Intrinsic;
+
+def int_hexagon_V6_veqw_and_128B :
+Hexagon_custom_v128i1_v128i1v32i32v32i32_Intrinsic_128B;
+
+def int_hexagon_V6_veqw_or :
+Hexagon_custom_v64i1_v64i1v16i32v16i32_Intrinsic;
+
+def int_hexagon_V6_veqw_or_128B :
+Hexagon_custom_v128i1_v128i1v32i32v32i32_Intrinsic_128B;
+
+def int_hexagon_V6_veqw_xor :
+Hexagon_custom_v64i1_v64i1v16i32v16i32_Intrinsic;
+
+def int_hexagon_V6_veqw_xor_128B :
+Hexagon_custom_v128i1_v128i1v32i32v32i32_Intrinsic_128B;
+
+def int_hexagon_V6_vgth :
+Hexagon_custom_v64i1_v16i32v16i32_Intrinsic;
+
+def int_hexagon_V6_vgth_128B :
+Hexagon_custom_v128i1_v32i32v32i32_Intrinsic_128B;
+
+def int_hexagon_V6_vgth_and :
+Hexagon_custom_v64i1_v64i1v16i32v16i32_Intrinsic;
+
+def int_hexagon_V6_vgth_and_128B :
+Hexagon_custom_v128i1_v128i1v32i32v32i32_Intrinsic_128B;
+
+def int_hexagon_V6_vgth_or :
+Hexagon_custom_v64i1_v64i1v16i32v16i32_Intrinsic;
+
+def int_hexagon_V6_vgth_or_128B :
+Hexagon_custom_v128i1_v128i1v32i32v32i32_Intrinsic_128B;
+
+def int_hexagon_V6_vgth_xor :
+Hexagon_custom_v64i1_v64i1v16i32v16i32_Intrinsic;
+
+def int_hexagon_V6_vgth_xor_128B :
+Hexagon_custom_v128i1_v128i1v32i32v32i32_Intrinsic_128B;
+
+def int_hexagon_V6_veqh :
+Hexagon_custom_v64i1_v16i32v16i32_Intrinsic;
+
+def int_hexagon_V6_veqh_128B :
+Hexagon_custom_v128i1_v32i32v32i32_Intrinsic_128B;
+
+def int_hexagon_V6_veqh_and :
+Hexagon_custom_v64i1_v64i1v16i32v16i32_Intrinsic;
+
+def int_hexagon_V6_veqh_and_128B :
+Hexagon_custom_v128i1_v128i1v32i32v32i32_Intrinsic_128B;
+
+def int_hexagon_V6_veqh_or :
+Hexagon_custom_v64i1_v64i1v16i32v16i32_Intrinsic;
+
+def int_hexagon_V6_veqh_or_128B :
+Hexagon_custom_v128i1_v128i1v32i32v32i32_Intrinsic_128B;
+
+def int_hexagon_V6_veqh_xor :
+Hexagon_custom_v64i1_v64i1v16i32v16i32_Intrinsic;
+
+def int_hexagon_V6_veqh_xor_128B :
+Hexagon_custom_v128i1_v128i1v32i32v32i32_Intrinsic_128B;
+
+def int_hexagon_V6_vgtb :
+Hexagon_custom_v64i1_v16i32v16i32_Intrinsic;
+
+def int_hexagon_V6_vgtb_128B :
+Hexagon_custom_v128i1_v32i32v32i32_Intrinsic_128B;
+
+def int_hexagon_V6_vgtb_and :
+Hexagon_custom_v64i1_v64i1v16i32v16i32_Intrinsic;
+
+def int_hexagon_V6_vgtb_and_128B :
+Hexagon_custom_v128i1_v128i1v32i32v32i32_Intrinsic_128B;
+
+def int_hexagon_V6_vgtb_or :
+Hexagon_custom_v64i1_v64i1v16i32v16i32_Intrinsic;
+
+def int_hexagon_V6_vgtb_or_128B :
+Hexagon_custom_v128i1_v128i1v32i32v32i32_Intrinsic_128B;
+
+def int_hexagon_V6_vgtb_xor :
+Hexagon_custom_v64i1_v64i1v16i32v16i32_Intrinsic;
+
+def int_hexagon_V6_vgtb_xor_128B :
+Hexagon_custom_v128i1_v128i1v32i32v32i32_Intrinsic_128B;
+
+def int_hexagon_V6_veqb :
+Hexagon_custom_v64i1_v16i32v16i32_Intrinsic;
+
+def int_hexagon_V6_veqb_128B :
+Hexagon_custom_v128i1_v32i32v32i32_Intrinsic_128B;
+
+def int_hexagon_V6_veqb_and :
+Hexagon_custom_v64i1_v64i1v16i32v16i32_Intrinsic;
+
+def int_hexagon_V6_veqb_and_128B :
+Hexagon_custom_v128i1_v128i1v32i32v32i32_Intrinsic_128B;
+
+def int_hexagon_V6_veqb_or :
+Hexagon_custom_v64i1_v64i1v16i32v16i32_Intrinsic;
+
+def int_hexagon_V6_veqb_or_128B :
+Hexagon_custom_v128i1_v128i1v32i32v32i32_Intrinsic_128B;
+
+def int_hexagon_V6_veqb_xor :
+Hexagon_custom_v64i1_v64i1v16i32v16i32_Intrinsic;
+
+def int_hexagon_V6_veqb_xor_128B :
+Hexagon_custom_v128i1_v128i1v32i32v32i32_Intrinsic_128B;
+
+def int_hexagon_V6_vgtuw :
+Hexagon_custom_v64i1_v16i32v16i32_Intrinsic;
+
+def int_hexagon_V6_vgtuw_128B :
+Hexagon_custom_v128i1_v32i32v32i32_Intrinsic_128B;
+
+def int_hexagon_V6_vgtuw_and :
+Hexagon_custom_v64i1_v64i1v16i32v16i32_Intrinsic;
+
+def int_hexagon_V6_vgtuw_and_128B :
+Hexagon_custom_v128i1_v128i1v32i32v32i32_Intrinsic_128B;
+
+def int_hexagon_V6_vgtuw_or :
+Hexagon_custom_v64i1_v64i1v16i32v16i32_Intrinsic;
+
+def int_hexagon_V6_vgtuw_or_128B :
+Hexagon_custom_v128i1_v128i1v32i32v32i32_Intrinsic_128B;
+
+def int_hexagon_V6_vgtuw_xor :
+Hexagon_custom_v64i1_v64i1v16i32v16i32_Intrinsic;
+
+def int_hexagon_V6_vgtuw_xor_128B :
+Hexagon_custom_v128i1_v128i1v32i32v32i32_Intrinsic_128B;
+
+def int_hexagon_V6_vgtuh :
+Hexagon_custom_v64i1_v16i32v16i32_Intrinsic;
+
+def int_hexagon_V6_vgtuh_128B :
+Hexagon_custom_v128i1_v32i32v32i32_Intrinsic_128B;
+
+def int_hexagon_V6_vgtuh_and :
+Hexagon_custom_v64i1_v64i1v16i32v16i32_Intrinsic;
+
+def int_hexagon_V6_vgtuh_and_128B :
+Hexagon_custom_v128i1_v128i1v32i32v32i32_Intrinsic_128B;
+
+def int_hexagon_V6_vgtuh_or :
+Hexagon_custom_v64i1_v64i1v16i32v16i32_Intrinsic;
+
+def int_hexagon_V6_vgtuh_or_128B :
+Hexagon_custom_v128i1_v128i1v32i32v32i32_Intrinsic_128B;
+
+def int_hexagon_V6_vgtuh_xor :
+Hexagon_custom_v64i1_v64i1v16i32v16i32_Intrinsic;
+
+def int_hexagon_V6_vgtuh_xor_128B :
+Hexagon_custom_v128i1_v128i1v32i32v32i32_Intrinsic_128B;
+
+def int_hexagon_V6_vgtub :
+Hexagon_custom_v64i1_v16i32v16i32_Intrinsic;
+
+def int_hexagon_V6_vgtub_128B :
+Hexagon_custom_v128i1_v32i32v32i32_Intrinsic_128B;
+
+def int_hexagon_V6_vgtub_and :
+Hexagon_custom_v64i1_v64i1v16i32v16i32_Intrinsic;
+
+def int_hexagon_V6_vgtub_and_128B :
+Hexagon_custom_v128i1_v128i1v32i32v32i32_Intrinsic_128B;
+
+def int_hexagon_V6_vgtub_or :
+Hexagon_custom_v64i1_v64i1v16i32v16i32_Intrinsic;
+
+def int_hexagon_V6_vgtub_or_128B :
+Hexagon_custom_v128i1_v128i1v32i32v32i32_Intrinsic_128B;
+
+def int_hexagon_V6_vgtub_xor :
+Hexagon_custom_v64i1_v64i1v16i32v16i32_Intrinsic;
+
+def int_hexagon_V6_vgtub_xor_128B :
+Hexagon_custom_v128i1_v128i1v32i32v32i32_Intrinsic_128B;
+
+def int_hexagon_V6_pred_or :
+Hexagon_custom_v64i1_v64i1v64i1_Intrinsic;
+
+def int_hexagon_V6_pred_or_128B :
+Hexagon_custom_v128i1_v128i1v128i1_Intrinsic_128B;
+
+def int_hexagon_V6_pred_and :
+Hexagon_custom_v64i1_v64i1v64i1_Intrinsic;
+
+def int_hexagon_V6_pred_and_128B :
+Hexagon_custom_v128i1_v128i1v128i1_Intrinsic_128B;
+
+def int_hexagon_V6_pred_not :
+Hexagon_custom_v64i1_v64i1_Intrinsic;
+
+def int_hexagon_V6_pred_not_128B :
+Hexagon_custom_v128i1_v128i1_Intrinsic_128B;
+
+def int_hexagon_V6_pred_xor :
+Hexagon_custom_v64i1_v64i1v64i1_Intrinsic;
+
+def int_hexagon_V6_pred_xor_128B :
+Hexagon_custom_v128i1_v128i1v128i1_Intrinsic_128B;
+
+def int_hexagon_V6_pred_and_n :
+Hexagon_custom_v64i1_v64i1v64i1_Intrinsic;
+
+def int_hexagon_V6_pred_and_n_128B :
+Hexagon_custom_v128i1_v128i1v128i1_Intrinsic_128B;
+
+def int_hexagon_V6_pred_or_n :
+Hexagon_custom_v64i1_v64i1v64i1_Intrinsic;
+
+def int_hexagon_V6_pred_or_n_128B :
+Hexagon_custom_v128i1_v128i1v128i1_Intrinsic_128B;
+
+def int_hexagon_V6_pred_scalar2 :
+Hexagon_custom_v64i1_i32_Intrinsic;
+
+def int_hexagon_V6_pred_scalar2_128B :
+Hexagon_custom_v128i1_i32_Intrinsic_128B;
+
+def int_hexagon_V6_vmux :
+Hexagon_custom_v16i32_v64i1v16i32v16i32_Intrinsic;
+
+def int_hexagon_V6_vmux_128B :
+Hexagon_custom_v32i32_v128i1v32i32v32i32_Intrinsic_128B;
+
+def int_hexagon_V6_vswap :
+Hexagon_custom_v32i32_v64i1v16i32v16i32_Intrinsic;
+
+def int_hexagon_V6_vswap_128B :
+Hexagon_custom_v64i32_v128i1v32i32v32i32_Intrinsic_128B;
+
+def int_hexagon_V6_vmaxub :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vmaxub">;
+
+def int_hexagon_V6_vmaxub_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vmaxub_128B">;
+
+def int_hexagon_V6_vminub :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vminub">;
+
+def int_hexagon_V6_vminub_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vminub_128B">;
+
+def int_hexagon_V6_vmaxuh :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vmaxuh">;
+
+def int_hexagon_V6_vmaxuh_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vmaxuh_128B">;
+
+def int_hexagon_V6_vminuh :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vminuh">;
+
+def int_hexagon_V6_vminuh_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vminuh_128B">;
+
+def int_hexagon_V6_vmaxh :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vmaxh">;
+
+def int_hexagon_V6_vmaxh_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vmaxh_128B">;
+
+def int_hexagon_V6_vminh :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vminh">;
+
+def int_hexagon_V6_vminh_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vminh_128B">;
+
+def int_hexagon_V6_vmaxw :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vmaxw">;
+
+def int_hexagon_V6_vmaxw_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vmaxw_128B">;
+
+def int_hexagon_V6_vminw :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vminw">;
+
+def int_hexagon_V6_vminw_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vminw_128B">;
+
+def int_hexagon_V6_vsathub :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vsathub">;
+
+def int_hexagon_V6_vsathub_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vsathub_128B">;
+
+def int_hexagon_V6_vsatwh :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vsatwh">;
+
+def int_hexagon_V6_vsatwh_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vsatwh_128B">;
+
+def int_hexagon_V6_vshuffeb :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vshuffeb">;
+
+def int_hexagon_V6_vshuffeb_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vshuffeb_128B">;
+
+def int_hexagon_V6_vshuffob :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vshuffob">;
+
+def int_hexagon_V6_vshuffob_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vshuffob_128B">;
+
+def int_hexagon_V6_vshufeh :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vshufeh">;
+
+def int_hexagon_V6_vshufeh_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vshufeh_128B">;
+
+def int_hexagon_V6_vshufoh :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vshufoh">;
+
+def int_hexagon_V6_vshufoh_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vshufoh_128B">;
+
+def int_hexagon_V6_vshuffvdd :
+Hexagon_v32i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vshuffvdd">;
+
+def int_hexagon_V6_vshuffvdd_128B :
+Hexagon_v64i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vshuffvdd_128B">;
+
+def int_hexagon_V6_vdealvdd :
+Hexagon_v32i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vdealvdd">;
+
+def int_hexagon_V6_vdealvdd_128B :
+Hexagon_v64i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vdealvdd_128B">;
+
+def int_hexagon_V6_vshufoeh :
+Hexagon_v32i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vshufoeh">;
+
+def int_hexagon_V6_vshufoeh_128B :
+Hexagon_v64i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vshufoeh_128B">;
+
+def int_hexagon_V6_vshufoeb :
+Hexagon_v32i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vshufoeb">;
+
+def int_hexagon_V6_vshufoeb_128B :
+Hexagon_v64i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vshufoeb_128B">;
+
+def int_hexagon_V6_vdealh :
+Hexagon_v16i32_v16i32_Intrinsic<"HEXAGON_V6_vdealh">;
+
+def int_hexagon_V6_vdealh_128B :
+Hexagon_v32i32_v32i32_Intrinsic<"HEXAGON_V6_vdealh_128B">;
+
+def int_hexagon_V6_vdealb :
+Hexagon_v16i32_v16i32_Intrinsic<"HEXAGON_V6_vdealb">;
+
+def int_hexagon_V6_vdealb_128B :
+Hexagon_v32i32_v32i32_Intrinsic<"HEXAGON_V6_vdealb_128B">;
+
+def int_hexagon_V6_vdealb4w :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vdealb4w">;
+
+def int_hexagon_V6_vdealb4w_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vdealb4w_128B">;
+
+def int_hexagon_V6_vshuffh :
+Hexagon_v16i32_v16i32_Intrinsic<"HEXAGON_V6_vshuffh">;
+
+def int_hexagon_V6_vshuffh_128B :
+Hexagon_v32i32_v32i32_Intrinsic<"HEXAGON_V6_vshuffh_128B">;
+
+def int_hexagon_V6_vshuffb :
+Hexagon_v16i32_v16i32_Intrinsic<"HEXAGON_V6_vshuffb">;
+
+def int_hexagon_V6_vshuffb_128B :
+Hexagon_v32i32_v32i32_Intrinsic<"HEXAGON_V6_vshuffb_128B">;
+
+def int_hexagon_V6_extractw :
+Hexagon_i32_v16i32i32_Intrinsic<"HEXAGON_V6_extractw">;
+
+def int_hexagon_V6_extractw_128B :
+Hexagon_i32_v32i32i32_Intrinsic<"HEXAGON_V6_extractw_128B">;
+
+def int_hexagon_V6_vinsertwr :
+Hexagon_v16i32_v16i32i32_Intrinsic<"HEXAGON_V6_vinsertwr">;
+
+def int_hexagon_V6_vinsertwr_128B :
+Hexagon_v32i32_v32i32i32_Intrinsic<"HEXAGON_V6_vinsertwr_128B">;
+
+def int_hexagon_V6_lvsplatw :
+Hexagon_v16i32_i32_Intrinsic<"HEXAGON_V6_lvsplatw">;
+
+def int_hexagon_V6_lvsplatw_128B :
+Hexagon_v32i32_i32_Intrinsic<"HEXAGON_V6_lvsplatw_128B">;
+
+def int_hexagon_V6_vassignp :
+Hexagon_v32i32_v32i32_Intrinsic<"HEXAGON_V6_vassignp">;
+
+def int_hexagon_V6_vassignp_128B :
+Hexagon_v64i32_v64i32_Intrinsic<"HEXAGON_V6_vassignp_128B">;
+
+def int_hexagon_V6_vassign :
+Hexagon_v16i32_v16i32_Intrinsic<"HEXAGON_V6_vassign">;
+
+def int_hexagon_V6_vassign_128B :
+Hexagon_v32i32_v32i32_Intrinsic<"HEXAGON_V6_vassign_128B">;
+
+def int_hexagon_V6_vcombine :
+Hexagon_v32i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vcombine">;
+
+def int_hexagon_V6_vcombine_128B :
+Hexagon_v64i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vcombine_128B">;
+
+def int_hexagon_V6_vdelta :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vdelta">;
+
+def int_hexagon_V6_vdelta_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vdelta_128B">;
+
+def int_hexagon_V6_vrdelta :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vrdelta">;
+
+def int_hexagon_V6_vrdelta_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vrdelta_128B">;
+
+def int_hexagon_V6_vcl0w :
+Hexagon_v16i32_v16i32_Intrinsic<"HEXAGON_V6_vcl0w">;
+
+def int_hexagon_V6_vcl0w_128B :
+Hexagon_v32i32_v32i32_Intrinsic<"HEXAGON_V6_vcl0w_128B">;
+
+def int_hexagon_V6_vcl0h :
+Hexagon_v16i32_v16i32_Intrinsic<"HEXAGON_V6_vcl0h">;
+
+def int_hexagon_V6_vcl0h_128B :
+Hexagon_v32i32_v32i32_Intrinsic<"HEXAGON_V6_vcl0h_128B">;
+
+def int_hexagon_V6_vnormamtw :
+Hexagon_v16i32_v16i32_Intrinsic<"HEXAGON_V6_vnormamtw">;
+
+def int_hexagon_V6_vnormamtw_128B :
+Hexagon_v32i32_v32i32_Intrinsic<"HEXAGON_V6_vnormamtw_128B">;
+
+def int_hexagon_V6_vnormamth :
+Hexagon_v16i32_v16i32_Intrinsic<"HEXAGON_V6_vnormamth">;
+
+def int_hexagon_V6_vnormamth_128B :
+Hexagon_v32i32_v32i32_Intrinsic<"HEXAGON_V6_vnormamth_128B">;
+
+def int_hexagon_V6_vpopcounth :
+Hexagon_v16i32_v16i32_Intrinsic<"HEXAGON_V6_vpopcounth">;
+
+def int_hexagon_V6_vpopcounth_128B :
+Hexagon_v32i32_v32i32_Intrinsic<"HEXAGON_V6_vpopcounth_128B">;
+
+def int_hexagon_V6_vlutvvb :
+Hexagon_v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vlutvvb">;
+
+def int_hexagon_V6_vlutvvb_128B :
+Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vlutvvb_128B">;
+
+def int_hexagon_V6_vlutvvb_oracc :
+Hexagon_v16i32_v16i32v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vlutvvb_oracc">;
+
+def int_hexagon_V6_vlutvvb_oracc_128B :
+Hexagon_v32i32_v32i32v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vlutvvb_oracc_128B">;
+
+def int_hexagon_V6_vlutvwh :
+Hexagon_v32i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vlutvwh">;
+
+def int_hexagon_V6_vlutvwh_128B :
+Hexagon_v64i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vlutvwh_128B">;
+
+def int_hexagon_V6_vlutvwh_oracc :
+Hexagon_v32i32_v32i32v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vlutvwh_oracc">;
+
+def int_hexagon_V6_vlutvwh_oracc_128B :
+Hexagon_v64i32_v64i32v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vlutvwh_oracc_128B">;
+
+def int_hexagon_V6_hi :
+Hexagon_v16i32_v32i32_Intrinsic<"HEXAGON_V6_hi">;
+
+def int_hexagon_V6_hi_128B :
+Hexagon_v32i32_v64i32_Intrinsic<"HEXAGON_V6_hi_128B">;
+
+def int_hexagon_V6_lo :
+Hexagon_v16i32_v32i32_Intrinsic<"HEXAGON_V6_lo">;
+
+def int_hexagon_V6_lo_128B :
+Hexagon_v32i32_v64i32_Intrinsic<"HEXAGON_V6_lo_128B">;
+
+// V62 HVX Instructions.
+
+def int_hexagon_V6_vlsrb :
+Hexagon_v16i32_v16i32i32_Intrinsic<"HEXAGON_V6_vlsrb">;
+
+def int_hexagon_V6_vlsrb_128B :
+Hexagon_v32i32_v32i32i32_Intrinsic<"HEXAGON_V6_vlsrb_128B">;
+
+def int_hexagon_V6_vasrwuhrndsat :
+Hexagon_v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vasrwuhrndsat">;
+
+def int_hexagon_V6_vasrwuhrndsat_128B :
+Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vasrwuhrndsat_128B">;
+
+def int_hexagon_V6_vasruwuhrndsat :
+Hexagon_v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vasruwuhrndsat">;
+
+def int_hexagon_V6_vasruwuhrndsat_128B :
+Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vasruwuhrndsat_128B">;
+
+def int_hexagon_V6_vasrhbsat :
+Hexagon_v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vasrhbsat">;
+
+def int_hexagon_V6_vasrhbsat_128B :
+Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vasrhbsat_128B">;
+
+def int_hexagon_V6_vrounduwuh :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vrounduwuh">;
+
+def int_hexagon_V6_vrounduwuh_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vrounduwuh_128B">;
+
+def int_hexagon_V6_vrounduhub :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vrounduhub">;
+
+def int_hexagon_V6_vrounduhub_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vrounduhub_128B">;
+
+def int_hexagon_V6_vadduwsat :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vadduwsat">;
+
+def int_hexagon_V6_vadduwsat_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vadduwsat_128B">;
+
+def int_hexagon_V6_vadduwsat_dv :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vadduwsat_dv">;
+
+def int_hexagon_V6_vadduwsat_dv_128B :
+Hexagon_v64i32_v64i32v64i32_Intrinsic<"HEXAGON_V6_vadduwsat_dv_128B">;
+
+def int_hexagon_V6_vsubuwsat :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vsubuwsat">;
+
+def int_hexagon_V6_vsubuwsat_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vsubuwsat_128B">;
+
+def int_hexagon_V6_vsubuwsat_dv :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vsubuwsat_dv">;
+
+def int_hexagon_V6_vsubuwsat_dv_128B :
+Hexagon_v64i32_v64i32v64i32_Intrinsic<"HEXAGON_V6_vsubuwsat_dv_128B">;
+
+def int_hexagon_V6_vaddbsat :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vaddbsat">;
+
+def int_hexagon_V6_vaddbsat_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vaddbsat_128B">;
+
+def int_hexagon_V6_vaddbsat_dv :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vaddbsat_dv">;
+
+def int_hexagon_V6_vaddbsat_dv_128B :
+Hexagon_v64i32_v64i32v64i32_Intrinsic<"HEXAGON_V6_vaddbsat_dv_128B">;
+
+def int_hexagon_V6_vsubbsat :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vsubbsat">;
+
+def int_hexagon_V6_vsubbsat_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vsubbsat_128B">;
+
+def int_hexagon_V6_vsubbsat_dv :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vsubbsat_dv">;
+
+def int_hexagon_V6_vsubbsat_dv_128B :
+Hexagon_v64i32_v64i32v64i32_Intrinsic<"HEXAGON_V6_vsubbsat_dv_128B">;
+
+def int_hexagon_V6_vaddcarry :
+Hexagon_custom_v16i32v64i1_v16i32v16i32v64i1_Intrinsic;
+
+def int_hexagon_V6_vaddcarry_128B :
+Hexagon_custom_v32i32v128i1_v32i32v32i32v128i1_Intrinsic_128B;
+
+def int_hexagon_V6_vsubcarry :
+Hexagon_custom_v16i32v64i1_v16i32v16i32v64i1_Intrinsic;
+
+def int_hexagon_V6_vsubcarry_128B :
+Hexagon_custom_v32i32v128i1_v32i32v32i32v128i1_Intrinsic_128B;
+
+def int_hexagon_V6_vaddububb_sat :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vaddububb_sat">;
+
+def int_hexagon_V6_vaddububb_sat_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vaddububb_sat_128B">;
+
+def int_hexagon_V6_vsubububb_sat :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vsubububb_sat">;
+
+def int_hexagon_V6_vsubububb_sat_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vsubububb_sat_128B">;
+
+def int_hexagon_V6_vaddhw_acc :
+Hexagon_v32i32_v32i32v16i32v16i32_Intrinsic<"HEXAGON_V6_vaddhw_acc">;
+
+def int_hexagon_V6_vaddhw_acc_128B :
+Hexagon_v64i32_v64i32v32i32v32i32_Intrinsic<"HEXAGON_V6_vaddhw_acc_128B">;
+
+def int_hexagon_V6_vadduhw_acc :
+Hexagon_v32i32_v32i32v16i32v16i32_Intrinsic<"HEXAGON_V6_vadduhw_acc">;
+
+def int_hexagon_V6_vadduhw_acc_128B :
+Hexagon_v64i32_v64i32v32i32v32i32_Intrinsic<"HEXAGON_V6_vadduhw_acc_128B">;
+
+def int_hexagon_V6_vaddubh_acc :
+Hexagon_v32i32_v32i32v16i32v16i32_Intrinsic<"HEXAGON_V6_vaddubh_acc">;
+
+def int_hexagon_V6_vaddubh_acc_128B :
+Hexagon_v64i32_v64i32v32i32v32i32_Intrinsic<"HEXAGON_V6_vaddubh_acc_128B">;
+
+def int_hexagon_V6_vmpyewuh_64 :
+Hexagon_v32i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vmpyewuh_64">;
+
+def int_hexagon_V6_vmpyewuh_64_128B :
+Hexagon_v64i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vmpyewuh_64_128B">;
+
+def int_hexagon_V6_vmpyowh_64_acc :
+Hexagon_v32i32_v32i32v16i32v16i32_Intrinsic<"HEXAGON_V6_vmpyowh_64_acc">;
+
+def int_hexagon_V6_vmpyowh_64_acc_128B :
+Hexagon_v64i32_v64i32v32i32v32i32_Intrinsic<"HEXAGON_V6_vmpyowh_64_acc_128B">;
+
+def int_hexagon_V6_vmpauhb :
+Hexagon_v32i32_v32i32i32_Intrinsic<"HEXAGON_V6_vmpauhb">;
+
+def int_hexagon_V6_vmpauhb_128B :
+Hexagon_v64i32_v64i32i32_Intrinsic<"HEXAGON_V6_vmpauhb_128B">;
+
+def int_hexagon_V6_vmpauhb_acc :
+Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vmpauhb_acc">;
+
+def int_hexagon_V6_vmpauhb_acc_128B :
+Hexagon_v64i32_v64i32v64i32i32_Intrinsic<"HEXAGON_V6_vmpauhb_acc_128B">;
+
+def int_hexagon_V6_vmpyiwub :
+Hexagon_v16i32_v16i32i32_Intrinsic<"HEXAGON_V6_vmpyiwub">;
+
+def int_hexagon_V6_vmpyiwub_128B :
+Hexagon_v32i32_v32i32i32_Intrinsic<"HEXAGON_V6_vmpyiwub_128B">;
+
+def int_hexagon_V6_vmpyiwub_acc :
+Hexagon_v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vmpyiwub_acc">;
+
+def int_hexagon_V6_vmpyiwub_acc_128B :
+Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vmpyiwub_acc_128B">;
+
+def int_hexagon_V6_vandnqrt :
+Hexagon_custom_v16i32_v64i1i32_Intrinsic;
+
+def int_hexagon_V6_vandnqrt_128B :
+Hexagon_custom_v32i32_v128i1i32_Intrinsic_128B;
+
+def int_hexagon_V6_vandnqrt_acc :
+Hexagon_custom_v16i32_v16i32v64i1i32_Intrinsic;
+
+def int_hexagon_V6_vandnqrt_acc_128B :
+Hexagon_custom_v32i32_v32i32v128i1i32_Intrinsic_128B;
+
+def int_hexagon_V6_vandvqv :
+Hexagon_custom_v16i32_v64i1v16i32_Intrinsic;
+
+def int_hexagon_V6_vandvqv_128B :
+Hexagon_custom_v32i32_v128i1v32i32_Intrinsic_128B;
+
+def int_hexagon_V6_vandvnqv :
+Hexagon_custom_v16i32_v64i1v16i32_Intrinsic;
+
+def int_hexagon_V6_vandvnqv_128B :
+Hexagon_custom_v32i32_v128i1v32i32_Intrinsic_128B;
+
+def int_hexagon_V6_pred_scalar2v2 :
+Hexagon_custom_v64i1_i32_Intrinsic;
+
+def int_hexagon_V6_pred_scalar2v2_128B :
+Hexagon_custom_v128i1_i32_Intrinsic_128B;
+
+def int_hexagon_V6_shuffeqw :
+Hexagon_custom_v64i1_v64i1v64i1_Intrinsic;
+
+def int_hexagon_V6_shuffeqw_128B :
+Hexagon_custom_v128i1_v128i1v128i1_Intrinsic_128B;
+
+def int_hexagon_V6_shuffeqh :
+Hexagon_custom_v64i1_v64i1v64i1_Intrinsic;
+
+def int_hexagon_V6_shuffeqh_128B :
+Hexagon_custom_v128i1_v128i1v128i1_Intrinsic_128B;
+
+def int_hexagon_V6_vmaxb :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vmaxb">;
+
+def int_hexagon_V6_vmaxb_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vmaxb_128B">;
+
+def int_hexagon_V6_vminb :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vminb">;
+
+def int_hexagon_V6_vminb_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vminb_128B">;
+
+def int_hexagon_V6_vsatuwuh :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vsatuwuh">;
+
+def int_hexagon_V6_vsatuwuh_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vsatuwuh_128B">;
+
+def int_hexagon_V6_lvsplath :
+Hexagon_v16i32_i32_Intrinsic<"HEXAGON_V6_lvsplath">;
+
+def int_hexagon_V6_lvsplath_128B :
+Hexagon_v32i32_i32_Intrinsic<"HEXAGON_V6_lvsplath_128B">;
+
+def int_hexagon_V6_lvsplatb :
+Hexagon_v16i32_i32_Intrinsic<"HEXAGON_V6_lvsplatb">;
+
+def int_hexagon_V6_lvsplatb_128B :
+Hexagon_v32i32_i32_Intrinsic<"HEXAGON_V6_lvsplatb_128B">;
+
+def int_hexagon_V6_vaddclbw :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vaddclbw">;
+
+def int_hexagon_V6_vaddclbw_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vaddclbw_128B">;
+
+def int_hexagon_V6_vaddclbh :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vaddclbh">;
+
+def int_hexagon_V6_vaddclbh_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vaddclbh_128B">;
+
+def int_hexagon_V6_vlutvvbi :
+Hexagon_v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vlutvvbi", [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_V6_vlutvvbi_128B :
+Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vlutvvbi_128B", [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_V6_vlutvvb_oracci :
+Hexagon_v16i32_v16i32v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vlutvvb_oracci", [IntrNoMem, ImmArg<ArgIndex<3>>]>;
+
+def int_hexagon_V6_vlutvvb_oracci_128B :
+Hexagon_v32i32_v32i32v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vlutvvb_oracci_128B", [IntrNoMem, ImmArg<ArgIndex<3>>]>;
+
+def int_hexagon_V6_vlutvwhi :
+Hexagon_v32i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vlutvwhi", [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_V6_vlutvwhi_128B :
+Hexagon_v64i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vlutvwhi_128B", [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+def int_hexagon_V6_vlutvwh_oracci :
+Hexagon_v32i32_v32i32v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vlutvwh_oracci", [IntrNoMem, ImmArg<ArgIndex<3>>]>;
+
+def int_hexagon_V6_vlutvwh_oracci_128B :
+Hexagon_v64i32_v64i32v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vlutvwh_oracci_128B", [IntrNoMem, ImmArg<ArgIndex<3>>]>;
+
+def int_hexagon_V6_vlutvvb_nm :
+Hexagon_v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vlutvvb_nm">;
+
+def int_hexagon_V6_vlutvvb_nm_128B :
+Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vlutvvb_nm_128B">;
+
+def int_hexagon_V6_vlutvwh_nm :
+Hexagon_v32i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vlutvwh_nm">;
+
+def int_hexagon_V6_vlutvwh_nm_128B :
+Hexagon_v64i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vlutvwh_nm_128B">;
+
+// V65 HVX Instructions.
+
+def int_hexagon_V6_vasruwuhsat :
+Hexagon_v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vasruwuhsat">;
+
+def int_hexagon_V6_vasruwuhsat_128B :
+Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vasruwuhsat_128B">;
+
+def int_hexagon_V6_vasruhubsat :
+Hexagon_v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vasruhubsat">;
+
+def int_hexagon_V6_vasruhubsat_128B :
+Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vasruhubsat_128B">;
+
+def int_hexagon_V6_vasruhubrndsat :
+Hexagon_v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vasruhubrndsat">;
+
+def int_hexagon_V6_vasruhubrndsat_128B :
+Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vasruhubrndsat_128B">;
+
+def int_hexagon_V6_vaslh_acc :
+Hexagon_v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vaslh_acc">;
+
+def int_hexagon_V6_vaslh_acc_128B :
+Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vaslh_acc_128B">;
+
+def int_hexagon_V6_vasrh_acc :
+Hexagon_v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vasrh_acc">;
+
+def int_hexagon_V6_vasrh_acc_128B :
+Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vasrh_acc_128B">;
+
+def int_hexagon_V6_vavguw :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vavguw">;
+
+def int_hexagon_V6_vavguw_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vavguw_128B">;
+
+def int_hexagon_V6_vavguwrnd :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vavguwrnd">;
+
+def int_hexagon_V6_vavguwrnd_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vavguwrnd_128B">;
+
+def int_hexagon_V6_vavgb :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vavgb">;
+
+def int_hexagon_V6_vavgb_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vavgb_128B">;
+
+def int_hexagon_V6_vavgbrnd :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vavgbrnd">;
+
+def int_hexagon_V6_vavgbrnd_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vavgbrnd_128B">;
+
+def int_hexagon_V6_vnavgb :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vnavgb">;
+
+def int_hexagon_V6_vnavgb_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vnavgb_128B">;
+
+def int_hexagon_V6_vdd0 :
+Hexagon_v32i32__Intrinsic<"HEXAGON_V6_vdd0">;
+
+def int_hexagon_V6_vdd0_128B :
+Hexagon_v64i32__Intrinsic<"HEXAGON_V6_vdd0_128B">;
+
+def int_hexagon_V6_vabsb :
+Hexagon_v16i32_v16i32_Intrinsic<"HEXAGON_V6_vabsb">;
+
+def int_hexagon_V6_vabsb_128B :
+Hexagon_v32i32_v32i32_Intrinsic<"HEXAGON_V6_vabsb_128B">;
+
+def int_hexagon_V6_vabsb_sat :
+Hexagon_v16i32_v16i32_Intrinsic<"HEXAGON_V6_vabsb_sat">;
+
+def int_hexagon_V6_vabsb_sat_128B :
+Hexagon_v32i32_v32i32_Intrinsic<"HEXAGON_V6_vabsb_sat_128B">;
+
+def int_hexagon_V6_vmpabuu :
+Hexagon_v32i32_v32i32i32_Intrinsic<"HEXAGON_V6_vmpabuu">;
+
+def int_hexagon_V6_vmpabuu_128B :
+Hexagon_v64i32_v64i32i32_Intrinsic<"HEXAGON_V6_vmpabuu_128B">;
+
+def int_hexagon_V6_vmpabuu_acc :
+Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vmpabuu_acc">;
+
+def int_hexagon_V6_vmpabuu_acc_128B :
+Hexagon_v64i32_v64i32v64i32i32_Intrinsic<"HEXAGON_V6_vmpabuu_acc_128B">;
+
+def int_hexagon_V6_vmpyh_acc :
+Hexagon_v32i32_v32i32v16i32i32_Intrinsic<"HEXAGON_V6_vmpyh_acc">;
+
+def int_hexagon_V6_vmpyh_acc_128B :
+Hexagon_v64i32_v64i32v32i32i32_Intrinsic<"HEXAGON_V6_vmpyh_acc_128B">;
+
+def int_hexagon_V6_vmpahhsat :
+Hexagon_v16i32_v16i32v16i32i64_Intrinsic<"HEXAGON_V6_vmpahhsat">;
+
+def int_hexagon_V6_vmpahhsat_128B :
+Hexagon_v32i32_v32i32v32i32i64_Intrinsic<"HEXAGON_V6_vmpahhsat_128B">;
+
+def int_hexagon_V6_vmpauhuhsat :
+Hexagon_v16i32_v16i32v16i32i64_Intrinsic<"HEXAGON_V6_vmpauhuhsat">;
+
+def int_hexagon_V6_vmpauhuhsat_128B :
+Hexagon_v32i32_v32i32v32i32i64_Intrinsic<"HEXAGON_V6_vmpauhuhsat_128B">;
+
+def int_hexagon_V6_vmpsuhuhsat :
+Hexagon_v16i32_v16i32v16i32i64_Intrinsic<"HEXAGON_V6_vmpsuhuhsat">;
+
+def int_hexagon_V6_vmpsuhuhsat_128B :
+Hexagon_v32i32_v32i32v32i32i64_Intrinsic<"HEXAGON_V6_vmpsuhuhsat_128B">;
+
+def int_hexagon_V6_vlut4 :
+Hexagon_v16i32_v16i32i64_Intrinsic<"HEXAGON_V6_vlut4">;
+
+def int_hexagon_V6_vlut4_128B :
+Hexagon_v32i32_v32i32i64_Intrinsic<"HEXAGON_V6_vlut4_128B">;
+
+def int_hexagon_V6_vmpyuhe :
+Hexagon_v16i32_v16i32i32_Intrinsic<"HEXAGON_V6_vmpyuhe">;
+
+def int_hexagon_V6_vmpyuhe_128B :
+Hexagon_v32i32_v32i32i32_Intrinsic<"HEXAGON_V6_vmpyuhe_128B">;
+
+def int_hexagon_V6_vmpyuhe_acc :
+Hexagon_v16i32_v16i32v16i32i32_Intrinsic<"HEXAGON_V6_vmpyuhe_acc">;
+
+def int_hexagon_V6_vmpyuhe_acc_128B :
+Hexagon_v32i32_v32i32v32i32i32_Intrinsic<"HEXAGON_V6_vmpyuhe_acc_128B">;
+
+def int_hexagon_V6_vgathermw :
+Hexagon__ptri32i32v16i32_Intrinsic<"HEXAGON_V6_vgathermw", [IntrArgMemOnly]>;
+
+def int_hexagon_V6_vgathermw_128B :
+Hexagon__ptri32i32v32i32_Intrinsic<"HEXAGON_V6_vgathermw_128B", [IntrArgMemOnly]>;
+
+def int_hexagon_V6_vgathermh :
+Hexagon__ptri32i32v16i32_Intrinsic<"HEXAGON_V6_vgathermh", [IntrArgMemOnly]>;
+
+def int_hexagon_V6_vgathermh_128B :
+Hexagon__ptri32i32v32i32_Intrinsic<"HEXAGON_V6_vgathermh_128B", [IntrArgMemOnly]>;
+
+def int_hexagon_V6_vgathermhw :
+Hexagon__ptri32i32v32i32_Intrinsic<"HEXAGON_V6_vgathermhw", [IntrArgMemOnly]>;
+
+def int_hexagon_V6_vgathermhw_128B :
+Hexagon__ptri32i32v64i32_Intrinsic<"HEXAGON_V6_vgathermhw_128B", [IntrArgMemOnly]>;
+
+def int_hexagon_V6_vgathermwq :
+Hexagon_custom__ptrv64i1i32i32v16i32_Intrinsic<[IntrArgMemOnly]>;
+
+def int_hexagon_V6_vgathermwq_128B :
+Hexagon_custom__ptrv128i1i32i32v32i32_Intrinsic_128B<[IntrArgMemOnly]>;
+
+def int_hexagon_V6_vgathermhq :
+Hexagon_custom__ptrv64i1i32i32v16i32_Intrinsic<[IntrArgMemOnly]>;
+
+def int_hexagon_V6_vgathermhq_128B :
+Hexagon_custom__ptrv128i1i32i32v32i32_Intrinsic_128B<[IntrArgMemOnly]>;
+
+def int_hexagon_V6_vgathermhwq :
+Hexagon_custom__ptrv64i1i32i32v32i32_Intrinsic<[IntrArgMemOnly]>;
+
+def int_hexagon_V6_vgathermhwq_128B :
+Hexagon_custom__ptrv128i1i32i32v64i32_Intrinsic_128B<[IntrArgMemOnly]>;
+
+def int_hexagon_V6_vscattermw :
+Hexagon__i32i32v16i32v16i32_Intrinsic<"HEXAGON_V6_vscattermw", [IntrWriteMem]>;
+
+def int_hexagon_V6_vscattermw_128B :
+Hexagon__i32i32v32i32v32i32_Intrinsic<"HEXAGON_V6_vscattermw_128B", [IntrWriteMem]>;
+
+def int_hexagon_V6_vscattermh :
+Hexagon__i32i32v16i32v16i32_Intrinsic<"HEXAGON_V6_vscattermh", [IntrWriteMem]>;
+
+def int_hexagon_V6_vscattermh_128B :
+Hexagon__i32i32v32i32v32i32_Intrinsic<"HEXAGON_V6_vscattermh_128B", [IntrWriteMem]>;
+
+def int_hexagon_V6_vscattermw_add :
+Hexagon__i32i32v16i32v16i32_Intrinsic<"HEXAGON_V6_vscattermw_add", [IntrWriteMem]>;
+
+def int_hexagon_V6_vscattermw_add_128B :
+Hexagon__i32i32v32i32v32i32_Intrinsic<"HEXAGON_V6_vscattermw_add_128B", [IntrWriteMem]>;
+
+def int_hexagon_V6_vscattermh_add :
+Hexagon__i32i32v16i32v16i32_Intrinsic<"HEXAGON_V6_vscattermh_add", [IntrWriteMem]>;
+
+def int_hexagon_V6_vscattermh_add_128B :
+Hexagon__i32i32v32i32v32i32_Intrinsic<"HEXAGON_V6_vscattermh_add_128B", [IntrWriteMem]>;
+
+def int_hexagon_V6_vscattermwq :
+Hexagon_custom__v64i1i32i32v16i32v16i32_Intrinsic<[IntrWriteMem]>;
+
+def int_hexagon_V6_vscattermwq_128B :
+Hexagon_custom__v128i1i32i32v32i32v32i32_Intrinsic_128B<[IntrWriteMem]>;
+
+def int_hexagon_V6_vscattermhq :
+Hexagon_custom__v64i1i32i32v16i32v16i32_Intrinsic<[IntrWriteMem]>;
+
+def int_hexagon_V6_vscattermhq_128B :
+Hexagon_custom__v128i1i32i32v32i32v32i32_Intrinsic_128B<[IntrWriteMem]>;
+
+def int_hexagon_V6_vscattermhw :
+Hexagon__i32i32v32i32v16i32_Intrinsic<"HEXAGON_V6_vscattermhw", [IntrWriteMem]>;
+
+def int_hexagon_V6_vscattermhw_128B :
+Hexagon__i32i32v64i32v32i32_Intrinsic<"HEXAGON_V6_vscattermhw_128B", [IntrWriteMem]>;
+
+def int_hexagon_V6_vscattermhwq :
+Hexagon_custom__v64i1i32i32v32i32v16i32_Intrinsic<[IntrWriteMem]>;
+
+def int_hexagon_V6_vscattermhwq_128B :
+Hexagon_custom__v128i1i32i32v64i32v32i32_Intrinsic_128B<[IntrWriteMem]>;
+
+def int_hexagon_V6_vscattermhw_add :
+Hexagon__i32i32v32i32v16i32_Intrinsic<"HEXAGON_V6_vscattermhw_add", [IntrWriteMem]>;
+
+def int_hexagon_V6_vscattermhw_add_128B :
+Hexagon__i32i32v64i32v32i32_Intrinsic<"HEXAGON_V6_vscattermhw_add_128B", [IntrWriteMem]>;
+
+def int_hexagon_V6_vprefixqb :
+Hexagon_custom_v16i32_v64i1_Intrinsic;
+
+def int_hexagon_V6_vprefixqb_128B :
+Hexagon_custom_v32i32_v128i1_Intrinsic_128B;
+
+def int_hexagon_V6_vprefixqh :
+Hexagon_custom_v16i32_v64i1_Intrinsic;
+
+def int_hexagon_V6_vprefixqh_128B :
+Hexagon_custom_v32i32_v128i1_Intrinsic_128B;
+
+def int_hexagon_V6_vprefixqw :
+Hexagon_custom_v16i32_v64i1_Intrinsic;
+
+def int_hexagon_V6_vprefixqw_128B :
+Hexagon_custom_v32i32_v128i1_Intrinsic_128B;
+
+// V66 HVX Instructions.
+
+def int_hexagon_V6_vrotr :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vrotr">;
+
+def int_hexagon_V6_vrotr_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vrotr_128B">;
+
+def int_hexagon_V6_vasr_into :
+Hexagon_v32i32_v32i32v16i32v16i32_Intrinsic<"HEXAGON_V6_vasr_into">;
+
+def int_hexagon_V6_vasr_into_128B :
+Hexagon_v64i32_v64i32v32i32v32i32_Intrinsic<"HEXAGON_V6_vasr_into_128B">;
+
+def int_hexagon_V6_vaddcarrysat :
+Hexagon_custom_v16i32_v16i32v16i32v64i1_Intrinsic;
+
+def int_hexagon_V6_vaddcarrysat_128B :
+Hexagon_custom_v32i32_v32i32v32i32v128i1_Intrinsic_128B;
+
+def int_hexagon_V6_vsatdw :
+Hexagon_v16i32_v16i32v16i32_Intrinsic<"HEXAGON_V6_vsatdw">;
+
+def int_hexagon_V6_vsatdw_128B :
+Hexagon_v32i32_v32i32v32i32_Intrinsic<"HEXAGON_V6_vsatdw_128B">;
+
diff --git a/linux-x64/clang/include/llvm/IR/IntrinsicsMips.h b/linux-x64/clang/include/llvm/IR/IntrinsicsMips.h
new file mode 100644
index 0000000..a905338
--- /dev/null
+++ b/linux-x64/clang/include/llvm/IR/IntrinsicsMips.h
@@ -0,0 +1,691 @@
+/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
+|*                                                                            *|
+|* Intrinsic Function Source Fragment                                         *|
+|*                                                                            *|
+|* Automatically generated file, do not edit!                                 *|
+|*                                                                            *|
+\*===----------------------------------------------------------------------===*/
+
+#ifndef LLVM_IR_INTRINSIC_MIPS_ENUMS_H
+#define LLVM_IR_INTRINSIC_MIPS_ENUMS_H
+
+namespace llvm {
+namespace Intrinsic {
+enum MIPSIntrinsics : unsigned {
+// Enum values for intrinsics
+    mips_absq_s_ph = 4104,                            // llvm.mips.absq.s.ph
+    mips_absq_s_qb,                            // llvm.mips.absq.s.qb
+    mips_absq_s_w,                             // llvm.mips.absq.s.w
+    mips_add_a_b,                              // llvm.mips.add.a.b
+    mips_add_a_d,                              // llvm.mips.add.a.d
+    mips_add_a_h,                              // llvm.mips.add.a.h
+    mips_add_a_w,                              // llvm.mips.add.a.w
+    mips_addq_ph,                              // llvm.mips.addq.ph
+    mips_addq_s_ph,                            // llvm.mips.addq.s.ph
+    mips_addq_s_w,                             // llvm.mips.addq.s.w
+    mips_addqh_ph,                             // llvm.mips.addqh.ph
+    mips_addqh_r_ph,                           // llvm.mips.addqh.r.ph
+    mips_addqh_r_w,                            // llvm.mips.addqh.r.w
+    mips_addqh_w,                              // llvm.mips.addqh.w
+    mips_adds_a_b,                             // llvm.mips.adds.a.b
+    mips_adds_a_d,                             // llvm.mips.adds.a.d
+    mips_adds_a_h,                             // llvm.mips.adds.a.h
+    mips_adds_a_w,                             // llvm.mips.adds.a.w
+    mips_adds_s_b,                             // llvm.mips.adds.s.b
+    mips_adds_s_d,                             // llvm.mips.adds.s.d
+    mips_adds_s_h,                             // llvm.mips.adds.s.h
+    mips_adds_s_w,                             // llvm.mips.adds.s.w
+    mips_adds_u_b,                             // llvm.mips.adds.u.b
+    mips_adds_u_d,                             // llvm.mips.adds.u.d
+    mips_adds_u_h,                             // llvm.mips.adds.u.h
+    mips_adds_u_w,                             // llvm.mips.adds.u.w
+    mips_addsc,                                // llvm.mips.addsc
+    mips_addu_ph,                              // llvm.mips.addu.ph
+    mips_addu_qb,                              // llvm.mips.addu.qb
+    mips_addu_s_ph,                            // llvm.mips.addu.s.ph
+    mips_addu_s_qb,                            // llvm.mips.addu.s.qb
+    mips_adduh_qb,                             // llvm.mips.adduh.qb
+    mips_adduh_r_qb,                           // llvm.mips.adduh.r.qb
+    mips_addv_b,                               // llvm.mips.addv.b
+    mips_addv_d,                               // llvm.mips.addv.d
+    mips_addv_h,                               // llvm.mips.addv.h
+    mips_addv_w,                               // llvm.mips.addv.w
+    mips_addvi_b,                              // llvm.mips.addvi.b
+    mips_addvi_d,                              // llvm.mips.addvi.d
+    mips_addvi_h,                              // llvm.mips.addvi.h
+    mips_addvi_w,                              // llvm.mips.addvi.w
+    mips_addwc,                                // llvm.mips.addwc
+    mips_and_v,                                // llvm.mips.and.v
+    mips_andi_b,                               // llvm.mips.andi.b
+    mips_append,                               // llvm.mips.append
+    mips_asub_s_b,                             // llvm.mips.asub.s.b
+    mips_asub_s_d,                             // llvm.mips.asub.s.d
+    mips_asub_s_h,                             // llvm.mips.asub.s.h
+    mips_asub_s_w,                             // llvm.mips.asub.s.w
+    mips_asub_u_b,                             // llvm.mips.asub.u.b
+    mips_asub_u_d,                             // llvm.mips.asub.u.d
+    mips_asub_u_h,                             // llvm.mips.asub.u.h
+    mips_asub_u_w,                             // llvm.mips.asub.u.w
+    mips_ave_s_b,                              // llvm.mips.ave.s.b
+    mips_ave_s_d,                              // llvm.mips.ave.s.d
+    mips_ave_s_h,                              // llvm.mips.ave.s.h
+    mips_ave_s_w,                              // llvm.mips.ave.s.w
+    mips_ave_u_b,                              // llvm.mips.ave.u.b
+    mips_ave_u_d,                              // llvm.mips.ave.u.d
+    mips_ave_u_h,                              // llvm.mips.ave.u.h
+    mips_ave_u_w,                              // llvm.mips.ave.u.w
+    mips_aver_s_b,                             // llvm.mips.aver.s.b
+    mips_aver_s_d,                             // llvm.mips.aver.s.d
+    mips_aver_s_h,                             // llvm.mips.aver.s.h
+    mips_aver_s_w,                             // llvm.mips.aver.s.w
+    mips_aver_u_b,                             // llvm.mips.aver.u.b
+    mips_aver_u_d,                             // llvm.mips.aver.u.d
+    mips_aver_u_h,                             // llvm.mips.aver.u.h
+    mips_aver_u_w,                             // llvm.mips.aver.u.w
+    mips_balign,                               // llvm.mips.balign
+    mips_bclr_b,                               // llvm.mips.bclr.b
+    mips_bclr_d,                               // llvm.mips.bclr.d
+    mips_bclr_h,                               // llvm.mips.bclr.h
+    mips_bclr_w,                               // llvm.mips.bclr.w
+    mips_bclri_b,                              // llvm.mips.bclri.b
+    mips_bclri_d,                              // llvm.mips.bclri.d
+    mips_bclri_h,                              // llvm.mips.bclri.h
+    mips_bclri_w,                              // llvm.mips.bclri.w
+    mips_binsl_b,                              // llvm.mips.binsl.b
+    mips_binsl_d,                              // llvm.mips.binsl.d
+    mips_binsl_h,                              // llvm.mips.binsl.h
+    mips_binsl_w,                              // llvm.mips.binsl.w
+    mips_binsli_b,                             // llvm.mips.binsli.b
+    mips_binsli_d,                             // llvm.mips.binsli.d
+    mips_binsli_h,                             // llvm.mips.binsli.h
+    mips_binsli_w,                             // llvm.mips.binsli.w
+    mips_binsr_b,                              // llvm.mips.binsr.b
+    mips_binsr_d,                              // llvm.mips.binsr.d
+    mips_binsr_h,                              // llvm.mips.binsr.h
+    mips_binsr_w,                              // llvm.mips.binsr.w
+    mips_binsri_b,                             // llvm.mips.binsri.b
+    mips_binsri_d,                             // llvm.mips.binsri.d
+    mips_binsri_h,                             // llvm.mips.binsri.h
+    mips_binsri_w,                             // llvm.mips.binsri.w
+    mips_bitrev,                               // llvm.mips.bitrev
+    mips_bmnz_v,                               // llvm.mips.bmnz.v
+    mips_bmnzi_b,                              // llvm.mips.bmnzi.b
+    mips_bmz_v,                                // llvm.mips.bmz.v
+    mips_bmzi_b,                               // llvm.mips.bmzi.b
+    mips_bneg_b,                               // llvm.mips.bneg.b
+    mips_bneg_d,                               // llvm.mips.bneg.d
+    mips_bneg_h,                               // llvm.mips.bneg.h
+    mips_bneg_w,                               // llvm.mips.bneg.w
+    mips_bnegi_b,                              // llvm.mips.bnegi.b
+    mips_bnegi_d,                              // llvm.mips.bnegi.d
+    mips_bnegi_h,                              // llvm.mips.bnegi.h
+    mips_bnegi_w,                              // llvm.mips.bnegi.w
+    mips_bnz_b,                                // llvm.mips.bnz.b
+    mips_bnz_d,                                // llvm.mips.bnz.d
+    mips_bnz_h,                                // llvm.mips.bnz.h
+    mips_bnz_v,                                // llvm.mips.bnz.v
+    mips_bnz_w,                                // llvm.mips.bnz.w
+    mips_bposge32,                             // llvm.mips.bposge32
+    mips_bsel_v,                               // llvm.mips.bsel.v
+    mips_bseli_b,                              // llvm.mips.bseli.b
+    mips_bset_b,                               // llvm.mips.bset.b
+    mips_bset_d,                               // llvm.mips.bset.d
+    mips_bset_h,                               // llvm.mips.bset.h
+    mips_bset_w,                               // llvm.mips.bset.w
+    mips_bseti_b,                              // llvm.mips.bseti.b
+    mips_bseti_d,                              // llvm.mips.bseti.d
+    mips_bseti_h,                              // llvm.mips.bseti.h
+    mips_bseti_w,                              // llvm.mips.bseti.w
+    mips_bz_b,                                 // llvm.mips.bz.b
+    mips_bz_d,                                 // llvm.mips.bz.d
+    mips_bz_h,                                 // llvm.mips.bz.h
+    mips_bz_v,                                 // llvm.mips.bz.v
+    mips_bz_w,                                 // llvm.mips.bz.w
+    mips_ceq_b,                                // llvm.mips.ceq.b
+    mips_ceq_d,                                // llvm.mips.ceq.d
+    mips_ceq_h,                                // llvm.mips.ceq.h
+    mips_ceq_w,                                // llvm.mips.ceq.w
+    mips_ceqi_b,                               // llvm.mips.ceqi.b
+    mips_ceqi_d,                               // llvm.mips.ceqi.d
+    mips_ceqi_h,                               // llvm.mips.ceqi.h
+    mips_ceqi_w,                               // llvm.mips.ceqi.w
+    mips_cfcmsa,                               // llvm.mips.cfcmsa
+    mips_cle_s_b,                              // llvm.mips.cle.s.b
+    mips_cle_s_d,                              // llvm.mips.cle.s.d
+    mips_cle_s_h,                              // llvm.mips.cle.s.h
+    mips_cle_s_w,                              // llvm.mips.cle.s.w
+    mips_cle_u_b,                              // llvm.mips.cle.u.b
+    mips_cle_u_d,                              // llvm.mips.cle.u.d
+    mips_cle_u_h,                              // llvm.mips.cle.u.h
+    mips_cle_u_w,                              // llvm.mips.cle.u.w
+    mips_clei_s_b,                             // llvm.mips.clei.s.b
+    mips_clei_s_d,                             // llvm.mips.clei.s.d
+    mips_clei_s_h,                             // llvm.mips.clei.s.h
+    mips_clei_s_w,                             // llvm.mips.clei.s.w
+    mips_clei_u_b,                             // llvm.mips.clei.u.b
+    mips_clei_u_d,                             // llvm.mips.clei.u.d
+    mips_clei_u_h,                             // llvm.mips.clei.u.h
+    mips_clei_u_w,                             // llvm.mips.clei.u.w
+    mips_clt_s_b,                              // llvm.mips.clt.s.b
+    mips_clt_s_d,                              // llvm.mips.clt.s.d
+    mips_clt_s_h,                              // llvm.mips.clt.s.h
+    mips_clt_s_w,                              // llvm.mips.clt.s.w
+    mips_clt_u_b,                              // llvm.mips.clt.u.b
+    mips_clt_u_d,                              // llvm.mips.clt.u.d
+    mips_clt_u_h,                              // llvm.mips.clt.u.h
+    mips_clt_u_w,                              // llvm.mips.clt.u.w
+    mips_clti_s_b,                             // llvm.mips.clti.s.b
+    mips_clti_s_d,                             // llvm.mips.clti.s.d
+    mips_clti_s_h,                             // llvm.mips.clti.s.h
+    mips_clti_s_w,                             // llvm.mips.clti.s.w
+    mips_clti_u_b,                             // llvm.mips.clti.u.b
+    mips_clti_u_d,                             // llvm.mips.clti.u.d
+    mips_clti_u_h,                             // llvm.mips.clti.u.h
+    mips_clti_u_w,                             // llvm.mips.clti.u.w
+    mips_cmp_eq_ph,                            // llvm.mips.cmp.eq.ph
+    mips_cmp_le_ph,                            // llvm.mips.cmp.le.ph
+    mips_cmp_lt_ph,                            // llvm.mips.cmp.lt.ph
+    mips_cmpgdu_eq_qb,                         // llvm.mips.cmpgdu.eq.qb
+    mips_cmpgdu_le_qb,                         // llvm.mips.cmpgdu.le.qb
+    mips_cmpgdu_lt_qb,                         // llvm.mips.cmpgdu.lt.qb
+    mips_cmpgu_eq_qb,                          // llvm.mips.cmpgu.eq.qb
+    mips_cmpgu_le_qb,                          // llvm.mips.cmpgu.le.qb
+    mips_cmpgu_lt_qb,                          // llvm.mips.cmpgu.lt.qb
+    mips_cmpu_eq_qb,                           // llvm.mips.cmpu.eq.qb
+    mips_cmpu_le_qb,                           // llvm.mips.cmpu.le.qb
+    mips_cmpu_lt_qb,                           // llvm.mips.cmpu.lt.qb
+    mips_copy_s_b,                             // llvm.mips.copy.s.b
+    mips_copy_s_d,                             // llvm.mips.copy.s.d
+    mips_copy_s_h,                             // llvm.mips.copy.s.h
+    mips_copy_s_w,                             // llvm.mips.copy.s.w
+    mips_copy_u_b,                             // llvm.mips.copy.u.b
+    mips_copy_u_d,                             // llvm.mips.copy.u.d
+    mips_copy_u_h,                             // llvm.mips.copy.u.h
+    mips_copy_u_w,                             // llvm.mips.copy.u.w
+    mips_ctcmsa,                               // llvm.mips.ctcmsa
+    mips_div_s_b,                              // llvm.mips.div.s.b
+    mips_div_s_d,                              // llvm.mips.div.s.d
+    mips_div_s_h,                              // llvm.mips.div.s.h
+    mips_div_s_w,                              // llvm.mips.div.s.w
+    mips_div_u_b,                              // llvm.mips.div.u.b
+    mips_div_u_d,                              // llvm.mips.div.u.d
+    mips_div_u_h,                              // llvm.mips.div.u.h
+    mips_div_u_w,                              // llvm.mips.div.u.w
+    mips_dlsa,                                 // llvm.mips.dlsa
+    mips_dotp_s_d,                             // llvm.mips.dotp.s.d
+    mips_dotp_s_h,                             // llvm.mips.dotp.s.h
+    mips_dotp_s_w,                             // llvm.mips.dotp.s.w
+    mips_dotp_u_d,                             // llvm.mips.dotp.u.d
+    mips_dotp_u_h,                             // llvm.mips.dotp.u.h
+    mips_dotp_u_w,                             // llvm.mips.dotp.u.w
+    mips_dpa_w_ph,                             // llvm.mips.dpa.w.ph
+    mips_dpadd_s_d,                            // llvm.mips.dpadd.s.d
+    mips_dpadd_s_h,                            // llvm.mips.dpadd.s.h
+    mips_dpadd_s_w,                            // llvm.mips.dpadd.s.w
+    mips_dpadd_u_d,                            // llvm.mips.dpadd.u.d
+    mips_dpadd_u_h,                            // llvm.mips.dpadd.u.h
+    mips_dpadd_u_w,                            // llvm.mips.dpadd.u.w
+    mips_dpaq_s_w_ph,                          // llvm.mips.dpaq.s.w.ph
+    mips_dpaq_sa_l_w,                          // llvm.mips.dpaq.sa.l.w
+    mips_dpaqx_s_w_ph,                         // llvm.mips.dpaqx.s.w.ph
+    mips_dpaqx_sa_w_ph,                        // llvm.mips.dpaqx.sa.w.ph
+    mips_dpau_h_qbl,                           // llvm.mips.dpau.h.qbl
+    mips_dpau_h_qbr,                           // llvm.mips.dpau.h.qbr
+    mips_dpax_w_ph,                            // llvm.mips.dpax.w.ph
+    mips_dps_w_ph,                             // llvm.mips.dps.w.ph
+    mips_dpsq_s_w_ph,                          // llvm.mips.dpsq.s.w.ph
+    mips_dpsq_sa_l_w,                          // llvm.mips.dpsq.sa.l.w
+    mips_dpsqx_s_w_ph,                         // llvm.mips.dpsqx.s.w.ph
+    mips_dpsqx_sa_w_ph,                        // llvm.mips.dpsqx.sa.w.ph
+    mips_dpsu_h_qbl,                           // llvm.mips.dpsu.h.qbl
+    mips_dpsu_h_qbr,                           // llvm.mips.dpsu.h.qbr
+    mips_dpsub_s_d,                            // llvm.mips.dpsub.s.d
+    mips_dpsub_s_h,                            // llvm.mips.dpsub.s.h
+    mips_dpsub_s_w,                            // llvm.mips.dpsub.s.w
+    mips_dpsub_u_d,                            // llvm.mips.dpsub.u.d
+    mips_dpsub_u_h,                            // llvm.mips.dpsub.u.h
+    mips_dpsub_u_w,                            // llvm.mips.dpsub.u.w
+    mips_dpsx_w_ph,                            // llvm.mips.dpsx.w.ph
+    mips_extp,                                 // llvm.mips.extp
+    mips_extpdp,                               // llvm.mips.extpdp
+    mips_extr_r_w,                             // llvm.mips.extr.r.w
+    mips_extr_rs_w,                            // llvm.mips.extr.rs.w
+    mips_extr_s_h,                             // llvm.mips.extr.s.h
+    mips_extr_w,                               // llvm.mips.extr.w
+    mips_fadd_d,                               // llvm.mips.fadd.d
+    mips_fadd_w,                               // llvm.mips.fadd.w
+    mips_fcaf_d,                               // llvm.mips.fcaf.d
+    mips_fcaf_w,                               // llvm.mips.fcaf.w
+    mips_fceq_d,                               // llvm.mips.fceq.d
+    mips_fceq_w,                               // llvm.mips.fceq.w
+    mips_fclass_d,                             // llvm.mips.fclass.d
+    mips_fclass_w,                             // llvm.mips.fclass.w
+    mips_fcle_d,                               // llvm.mips.fcle.d
+    mips_fcle_w,                               // llvm.mips.fcle.w
+    mips_fclt_d,                               // llvm.mips.fclt.d
+    mips_fclt_w,                               // llvm.mips.fclt.w
+    mips_fcne_d,                               // llvm.mips.fcne.d
+    mips_fcne_w,                               // llvm.mips.fcne.w
+    mips_fcor_d,                               // llvm.mips.fcor.d
+    mips_fcor_w,                               // llvm.mips.fcor.w
+    mips_fcueq_d,                              // llvm.mips.fcueq.d
+    mips_fcueq_w,                              // llvm.mips.fcueq.w
+    mips_fcule_d,                              // llvm.mips.fcule.d
+    mips_fcule_w,                              // llvm.mips.fcule.w
+    mips_fcult_d,                              // llvm.mips.fcult.d
+    mips_fcult_w,                              // llvm.mips.fcult.w
+    mips_fcun_d,                               // llvm.mips.fcun.d
+    mips_fcun_w,                               // llvm.mips.fcun.w
+    mips_fcune_d,                              // llvm.mips.fcune.d
+    mips_fcune_w,                              // llvm.mips.fcune.w
+    mips_fdiv_d,                               // llvm.mips.fdiv.d
+    mips_fdiv_w,                               // llvm.mips.fdiv.w
+    mips_fexdo_h,                              // llvm.mips.fexdo.h
+    mips_fexdo_w,                              // llvm.mips.fexdo.w
+    mips_fexp2_d,                              // llvm.mips.fexp2.d
+    mips_fexp2_w,                              // llvm.mips.fexp2.w
+    mips_fexupl_d,                             // llvm.mips.fexupl.d
+    mips_fexupl_w,                             // llvm.mips.fexupl.w
+    mips_fexupr_d,                             // llvm.mips.fexupr.d
+    mips_fexupr_w,                             // llvm.mips.fexupr.w
+    mips_ffint_s_d,                            // llvm.mips.ffint.s.d
+    mips_ffint_s_w,                            // llvm.mips.ffint.s.w
+    mips_ffint_u_d,                            // llvm.mips.ffint.u.d
+    mips_ffint_u_w,                            // llvm.mips.ffint.u.w
+    mips_ffql_d,                               // llvm.mips.ffql.d
+    mips_ffql_w,                               // llvm.mips.ffql.w
+    mips_ffqr_d,                               // llvm.mips.ffqr.d
+    mips_ffqr_w,                               // llvm.mips.ffqr.w
+    mips_fill_b,                               // llvm.mips.fill.b
+    mips_fill_d,                               // llvm.mips.fill.d
+    mips_fill_h,                               // llvm.mips.fill.h
+    mips_fill_w,                               // llvm.mips.fill.w
+    mips_flog2_d,                              // llvm.mips.flog2.d
+    mips_flog2_w,                              // llvm.mips.flog2.w
+    mips_fmadd_d,                              // llvm.mips.fmadd.d
+    mips_fmadd_w,                              // llvm.mips.fmadd.w
+    mips_fmax_a_d,                             // llvm.mips.fmax.a.d
+    mips_fmax_a_w,                             // llvm.mips.fmax.a.w
+    mips_fmax_d,                               // llvm.mips.fmax.d
+    mips_fmax_w,                               // llvm.mips.fmax.w
+    mips_fmin_a_d,                             // llvm.mips.fmin.a.d
+    mips_fmin_a_w,                             // llvm.mips.fmin.a.w
+    mips_fmin_d,                               // llvm.mips.fmin.d
+    mips_fmin_w,                               // llvm.mips.fmin.w
+    mips_fmsub_d,                              // llvm.mips.fmsub.d
+    mips_fmsub_w,                              // llvm.mips.fmsub.w
+    mips_fmul_d,                               // llvm.mips.fmul.d
+    mips_fmul_w,                               // llvm.mips.fmul.w
+    mips_frcp_d,                               // llvm.mips.frcp.d
+    mips_frcp_w,                               // llvm.mips.frcp.w
+    mips_frint_d,                              // llvm.mips.frint.d
+    mips_frint_w,                              // llvm.mips.frint.w
+    mips_frsqrt_d,                             // llvm.mips.frsqrt.d
+    mips_frsqrt_w,                             // llvm.mips.frsqrt.w
+    mips_fsaf_d,                               // llvm.mips.fsaf.d
+    mips_fsaf_w,                               // llvm.mips.fsaf.w
+    mips_fseq_d,                               // llvm.mips.fseq.d
+    mips_fseq_w,                               // llvm.mips.fseq.w
+    mips_fsle_d,                               // llvm.mips.fsle.d
+    mips_fsle_w,                               // llvm.mips.fsle.w
+    mips_fslt_d,                               // llvm.mips.fslt.d
+    mips_fslt_w,                               // llvm.mips.fslt.w
+    mips_fsne_d,                               // llvm.mips.fsne.d
+    mips_fsne_w,                               // llvm.mips.fsne.w
+    mips_fsor_d,                               // llvm.mips.fsor.d
+    mips_fsor_w,                               // llvm.mips.fsor.w
+    mips_fsqrt_d,                              // llvm.mips.fsqrt.d
+    mips_fsqrt_w,                              // llvm.mips.fsqrt.w
+    mips_fsub_d,                               // llvm.mips.fsub.d
+    mips_fsub_w,                               // llvm.mips.fsub.w
+    mips_fsueq_d,                              // llvm.mips.fsueq.d
+    mips_fsueq_w,                              // llvm.mips.fsueq.w
+    mips_fsule_d,                              // llvm.mips.fsule.d
+    mips_fsule_w,                              // llvm.mips.fsule.w
+    mips_fsult_d,                              // llvm.mips.fsult.d
+    mips_fsult_w,                              // llvm.mips.fsult.w
+    mips_fsun_d,                               // llvm.mips.fsun.d
+    mips_fsun_w,                               // llvm.mips.fsun.w
+    mips_fsune_d,                              // llvm.mips.fsune.d
+    mips_fsune_w,                              // llvm.mips.fsune.w
+    mips_ftint_s_d,                            // llvm.mips.ftint.s.d
+    mips_ftint_s_w,                            // llvm.mips.ftint.s.w
+    mips_ftint_u_d,                            // llvm.mips.ftint.u.d
+    mips_ftint_u_w,                            // llvm.mips.ftint.u.w
+    mips_ftq_h,                                // llvm.mips.ftq.h
+    mips_ftq_w,                                // llvm.mips.ftq.w
+    mips_ftrunc_s_d,                           // llvm.mips.ftrunc.s.d
+    mips_ftrunc_s_w,                           // llvm.mips.ftrunc.s.w
+    mips_ftrunc_u_d,                           // llvm.mips.ftrunc.u.d
+    mips_ftrunc_u_w,                           // llvm.mips.ftrunc.u.w
+    mips_hadd_s_d,                             // llvm.mips.hadd.s.d
+    mips_hadd_s_h,                             // llvm.mips.hadd.s.h
+    mips_hadd_s_w,                             // llvm.mips.hadd.s.w
+    mips_hadd_u_d,                             // llvm.mips.hadd.u.d
+    mips_hadd_u_h,                             // llvm.mips.hadd.u.h
+    mips_hadd_u_w,                             // llvm.mips.hadd.u.w
+    mips_hsub_s_d,                             // llvm.mips.hsub.s.d
+    mips_hsub_s_h,                             // llvm.mips.hsub.s.h
+    mips_hsub_s_w,                             // llvm.mips.hsub.s.w
+    mips_hsub_u_d,                             // llvm.mips.hsub.u.d
+    mips_hsub_u_h,                             // llvm.mips.hsub.u.h
+    mips_hsub_u_w,                             // llvm.mips.hsub.u.w
+    mips_ilvev_b,                              // llvm.mips.ilvev.b
+    mips_ilvev_d,                              // llvm.mips.ilvev.d
+    mips_ilvev_h,                              // llvm.mips.ilvev.h
+    mips_ilvev_w,                              // llvm.mips.ilvev.w
+    mips_ilvl_b,                               // llvm.mips.ilvl.b
+    mips_ilvl_d,                               // llvm.mips.ilvl.d
+    mips_ilvl_h,                               // llvm.mips.ilvl.h
+    mips_ilvl_w,                               // llvm.mips.ilvl.w
+    mips_ilvod_b,                              // llvm.mips.ilvod.b
+    mips_ilvod_d,                              // llvm.mips.ilvod.d
+    mips_ilvod_h,                              // llvm.mips.ilvod.h
+    mips_ilvod_w,                              // llvm.mips.ilvod.w
+    mips_ilvr_b,                               // llvm.mips.ilvr.b
+    mips_ilvr_d,                               // llvm.mips.ilvr.d
+    mips_ilvr_h,                               // llvm.mips.ilvr.h
+    mips_ilvr_w,                               // llvm.mips.ilvr.w
+    mips_insert_b,                             // llvm.mips.insert.b
+    mips_insert_d,                             // llvm.mips.insert.d
+    mips_insert_h,                             // llvm.mips.insert.h
+    mips_insert_w,                             // llvm.mips.insert.w
+    mips_insv,                                 // llvm.mips.insv
+    mips_insve_b,                              // llvm.mips.insve.b
+    mips_insve_d,                              // llvm.mips.insve.d
+    mips_insve_h,                              // llvm.mips.insve.h
+    mips_insve_w,                              // llvm.mips.insve.w
+    mips_lbux,                                 // llvm.mips.lbux
+    mips_ld_b,                                 // llvm.mips.ld.b
+    mips_ld_d,                                 // llvm.mips.ld.d
+    mips_ld_h,                                 // llvm.mips.ld.h
+    mips_ld_w,                                 // llvm.mips.ld.w
+    mips_ldi_b,                                // llvm.mips.ldi.b
+    mips_ldi_d,                                // llvm.mips.ldi.d
+    mips_ldi_h,                                // llvm.mips.ldi.h
+    mips_ldi_w,                                // llvm.mips.ldi.w
+    mips_ldr_d,                                // llvm.mips.ldr.d
+    mips_ldr_w,                                // llvm.mips.ldr.w
+    mips_lhx,                                  // llvm.mips.lhx
+    mips_lsa,                                  // llvm.mips.lsa
+    mips_lwx,                                  // llvm.mips.lwx
+    mips_madd,                                 // llvm.mips.madd
+    mips_madd_q_h,                             // llvm.mips.madd.q.h
+    mips_madd_q_w,                             // llvm.mips.madd.q.w
+    mips_maddr_q_h,                            // llvm.mips.maddr.q.h
+    mips_maddr_q_w,                            // llvm.mips.maddr.q.w
+    mips_maddu,                                // llvm.mips.maddu
+    mips_maddv_b,                              // llvm.mips.maddv.b
+    mips_maddv_d,                              // llvm.mips.maddv.d
+    mips_maddv_h,                              // llvm.mips.maddv.h
+    mips_maddv_w,                              // llvm.mips.maddv.w
+    mips_maq_s_w_phl,                          // llvm.mips.maq.s.w.phl
+    mips_maq_s_w_phr,                          // llvm.mips.maq.s.w.phr
+    mips_maq_sa_w_phl,                         // llvm.mips.maq.sa.w.phl
+    mips_maq_sa_w_phr,                         // llvm.mips.maq.sa.w.phr
+    mips_max_a_b,                              // llvm.mips.max.a.b
+    mips_max_a_d,                              // llvm.mips.max.a.d
+    mips_max_a_h,                              // llvm.mips.max.a.h
+    mips_max_a_w,                              // llvm.mips.max.a.w
+    mips_max_s_b,                              // llvm.mips.max.s.b
+    mips_max_s_d,                              // llvm.mips.max.s.d
+    mips_max_s_h,                              // llvm.mips.max.s.h
+    mips_max_s_w,                              // llvm.mips.max.s.w
+    mips_max_u_b,                              // llvm.mips.max.u.b
+    mips_max_u_d,                              // llvm.mips.max.u.d
+    mips_max_u_h,                              // llvm.mips.max.u.h
+    mips_max_u_w,                              // llvm.mips.max.u.w
+    mips_maxi_s_b,                             // llvm.mips.maxi.s.b
+    mips_maxi_s_d,                             // llvm.mips.maxi.s.d
+    mips_maxi_s_h,                             // llvm.mips.maxi.s.h
+    mips_maxi_s_w,                             // llvm.mips.maxi.s.w
+    mips_maxi_u_b,                             // llvm.mips.maxi.u.b
+    mips_maxi_u_d,                             // llvm.mips.maxi.u.d
+    mips_maxi_u_h,                             // llvm.mips.maxi.u.h
+    mips_maxi_u_w,                             // llvm.mips.maxi.u.w
+    mips_min_a_b,                              // llvm.mips.min.a.b
+    mips_min_a_d,                              // llvm.mips.min.a.d
+    mips_min_a_h,                              // llvm.mips.min.a.h
+    mips_min_a_w,                              // llvm.mips.min.a.w
+    mips_min_s_b,                              // llvm.mips.min.s.b
+    mips_min_s_d,                              // llvm.mips.min.s.d
+    mips_min_s_h,                              // llvm.mips.min.s.h
+    mips_min_s_w,                              // llvm.mips.min.s.w
+    mips_min_u_b,                              // llvm.mips.min.u.b
+    mips_min_u_d,                              // llvm.mips.min.u.d
+    mips_min_u_h,                              // llvm.mips.min.u.h
+    mips_min_u_w,                              // llvm.mips.min.u.w
+    mips_mini_s_b,                             // llvm.mips.mini.s.b
+    mips_mini_s_d,                             // llvm.mips.mini.s.d
+    mips_mini_s_h,                             // llvm.mips.mini.s.h
+    mips_mini_s_w,                             // llvm.mips.mini.s.w
+    mips_mini_u_b,                             // llvm.mips.mini.u.b
+    mips_mini_u_d,                             // llvm.mips.mini.u.d
+    mips_mini_u_h,                             // llvm.mips.mini.u.h
+    mips_mini_u_w,                             // llvm.mips.mini.u.w
+    mips_mod_s_b,                              // llvm.mips.mod.s.b
+    mips_mod_s_d,                              // llvm.mips.mod.s.d
+    mips_mod_s_h,                              // llvm.mips.mod.s.h
+    mips_mod_s_w,                              // llvm.mips.mod.s.w
+    mips_mod_u_b,                              // llvm.mips.mod.u.b
+    mips_mod_u_d,                              // llvm.mips.mod.u.d
+    mips_mod_u_h,                              // llvm.mips.mod.u.h
+    mips_mod_u_w,                              // llvm.mips.mod.u.w
+    mips_modsub,                               // llvm.mips.modsub
+    mips_move_v,                               // llvm.mips.move.v
+    mips_msub,                                 // llvm.mips.msub
+    mips_msub_q_h,                             // llvm.mips.msub.q.h
+    mips_msub_q_w,                             // llvm.mips.msub.q.w
+    mips_msubr_q_h,                            // llvm.mips.msubr.q.h
+    mips_msubr_q_w,                            // llvm.mips.msubr.q.w
+    mips_msubu,                                // llvm.mips.msubu
+    mips_msubv_b,                              // llvm.mips.msubv.b
+    mips_msubv_d,                              // llvm.mips.msubv.d
+    mips_msubv_h,                              // llvm.mips.msubv.h
+    mips_msubv_w,                              // llvm.mips.msubv.w
+    mips_mthlip,                               // llvm.mips.mthlip
+    mips_mul_ph,                               // llvm.mips.mul.ph
+    mips_mul_q_h,                              // llvm.mips.mul.q.h
+    mips_mul_q_w,                              // llvm.mips.mul.q.w
+    mips_mul_s_ph,                             // llvm.mips.mul.s.ph
+    mips_muleq_s_w_phl,                        // llvm.mips.muleq.s.w.phl
+    mips_muleq_s_w_phr,                        // llvm.mips.muleq.s.w.phr
+    mips_muleu_s_ph_qbl,                       // llvm.mips.muleu.s.ph.qbl
+    mips_muleu_s_ph_qbr,                       // llvm.mips.muleu.s.ph.qbr
+    mips_mulq_rs_ph,                           // llvm.mips.mulq.rs.ph
+    mips_mulq_rs_w,                            // llvm.mips.mulq.rs.w
+    mips_mulq_s_ph,                            // llvm.mips.mulq.s.ph
+    mips_mulq_s_w,                             // llvm.mips.mulq.s.w
+    mips_mulr_q_h,                             // llvm.mips.mulr.q.h
+    mips_mulr_q_w,                             // llvm.mips.mulr.q.w
+    mips_mulsa_w_ph,                           // llvm.mips.mulsa.w.ph
+    mips_mulsaq_s_w_ph,                        // llvm.mips.mulsaq.s.w.ph
+    mips_mult,                                 // llvm.mips.mult
+    mips_multu,                                // llvm.mips.multu
+    mips_mulv_b,                               // llvm.mips.mulv.b
+    mips_mulv_d,                               // llvm.mips.mulv.d
+    mips_mulv_h,                               // llvm.mips.mulv.h
+    mips_mulv_w,                               // llvm.mips.mulv.w
+    mips_nloc_b,                               // llvm.mips.nloc.b
+    mips_nloc_d,                               // llvm.mips.nloc.d
+    mips_nloc_h,                               // llvm.mips.nloc.h
+    mips_nloc_w,                               // llvm.mips.nloc.w
+    mips_nlzc_b,                               // llvm.mips.nlzc.b
+    mips_nlzc_d,                               // llvm.mips.nlzc.d
+    mips_nlzc_h,                               // llvm.mips.nlzc.h
+    mips_nlzc_w,                               // llvm.mips.nlzc.w
+    mips_nor_v,                                // llvm.mips.nor.v
+    mips_nori_b,                               // llvm.mips.nori.b
+    mips_or_v,                                 // llvm.mips.or.v
+    mips_ori_b,                                // llvm.mips.ori.b
+    mips_packrl_ph,                            // llvm.mips.packrl.ph
+    mips_pckev_b,                              // llvm.mips.pckev.b
+    mips_pckev_d,                              // llvm.mips.pckev.d
+    mips_pckev_h,                              // llvm.mips.pckev.h
+    mips_pckev_w,                              // llvm.mips.pckev.w
+    mips_pckod_b,                              // llvm.mips.pckod.b
+    mips_pckod_d,                              // llvm.mips.pckod.d
+    mips_pckod_h,                              // llvm.mips.pckod.h
+    mips_pckod_w,                              // llvm.mips.pckod.w
+    mips_pcnt_b,                               // llvm.mips.pcnt.b
+    mips_pcnt_d,                               // llvm.mips.pcnt.d
+    mips_pcnt_h,                               // llvm.mips.pcnt.h
+    mips_pcnt_w,                               // llvm.mips.pcnt.w
+    mips_pick_ph,                              // llvm.mips.pick.ph
+    mips_pick_qb,                              // llvm.mips.pick.qb
+    mips_preceq_w_phl,                         // llvm.mips.preceq.w.phl
+    mips_preceq_w_phr,                         // llvm.mips.preceq.w.phr
+    mips_precequ_ph_qbl,                       // llvm.mips.precequ.ph.qbl
+    mips_precequ_ph_qbla,                      // llvm.mips.precequ.ph.qbla
+    mips_precequ_ph_qbr,                       // llvm.mips.precequ.ph.qbr
+    mips_precequ_ph_qbra,                      // llvm.mips.precequ.ph.qbra
+    mips_preceu_ph_qbl,                        // llvm.mips.preceu.ph.qbl
+    mips_preceu_ph_qbla,                       // llvm.mips.preceu.ph.qbla
+    mips_preceu_ph_qbr,                        // llvm.mips.preceu.ph.qbr
+    mips_preceu_ph_qbra,                       // llvm.mips.preceu.ph.qbra
+    mips_precr_qb_ph,                          // llvm.mips.precr.qb.ph
+    mips_precr_sra_ph_w,                       // llvm.mips.precr.sra.ph.w
+    mips_precr_sra_r_ph_w,                     // llvm.mips.precr.sra.r.ph.w
+    mips_precrq_ph_w,                          // llvm.mips.precrq.ph.w
+    mips_precrq_qb_ph,                         // llvm.mips.precrq.qb.ph
+    mips_precrq_rs_ph_w,                       // llvm.mips.precrq.rs.ph.w
+    mips_precrqu_s_qb_ph,                      // llvm.mips.precrqu.s.qb.ph
+    mips_prepend,                              // llvm.mips.prepend
+    mips_raddu_w_qb,                           // llvm.mips.raddu.w.qb
+    mips_rddsp,                                // llvm.mips.rddsp
+    mips_repl_ph,                              // llvm.mips.repl.ph
+    mips_repl_qb,                              // llvm.mips.repl.qb
+    mips_sat_s_b,                              // llvm.mips.sat.s.b
+    mips_sat_s_d,                              // llvm.mips.sat.s.d
+    mips_sat_s_h,                              // llvm.mips.sat.s.h
+    mips_sat_s_w,                              // llvm.mips.sat.s.w
+    mips_sat_u_b,                              // llvm.mips.sat.u.b
+    mips_sat_u_d,                              // llvm.mips.sat.u.d
+    mips_sat_u_h,                              // llvm.mips.sat.u.h
+    mips_sat_u_w,                              // llvm.mips.sat.u.w
+    mips_shf_b,                                // llvm.mips.shf.b
+    mips_shf_h,                                // llvm.mips.shf.h
+    mips_shf_w,                                // llvm.mips.shf.w
+    mips_shilo,                                // llvm.mips.shilo
+    mips_shll_ph,                              // llvm.mips.shll.ph
+    mips_shll_qb,                              // llvm.mips.shll.qb
+    mips_shll_s_ph,                            // llvm.mips.shll.s.ph
+    mips_shll_s_w,                             // llvm.mips.shll.s.w
+    mips_shra_ph,                              // llvm.mips.shra.ph
+    mips_shra_qb,                              // llvm.mips.shra.qb
+    mips_shra_r_ph,                            // llvm.mips.shra.r.ph
+    mips_shra_r_qb,                            // llvm.mips.shra.r.qb
+    mips_shra_r_w,                             // llvm.mips.shra.r.w
+    mips_shrl_ph,                              // llvm.mips.shrl.ph
+    mips_shrl_qb,                              // llvm.mips.shrl.qb
+    mips_sld_b,                                // llvm.mips.sld.b
+    mips_sld_d,                                // llvm.mips.sld.d
+    mips_sld_h,                                // llvm.mips.sld.h
+    mips_sld_w,                                // llvm.mips.sld.w
+    mips_sldi_b,                               // llvm.mips.sldi.b
+    mips_sldi_d,                               // llvm.mips.sldi.d
+    mips_sldi_h,                               // llvm.mips.sldi.h
+    mips_sldi_w,                               // llvm.mips.sldi.w
+    mips_sll_b,                                // llvm.mips.sll.b
+    mips_sll_d,                                // llvm.mips.sll.d
+    mips_sll_h,                                // llvm.mips.sll.h
+    mips_sll_w,                                // llvm.mips.sll.w
+    mips_slli_b,                               // llvm.mips.slli.b
+    mips_slli_d,                               // llvm.mips.slli.d
+    mips_slli_h,                               // llvm.mips.slli.h
+    mips_slli_w,                               // llvm.mips.slli.w
+    mips_splat_b,                              // llvm.mips.splat.b
+    mips_splat_d,                              // llvm.mips.splat.d
+    mips_splat_h,                              // llvm.mips.splat.h
+    mips_splat_w,                              // llvm.mips.splat.w
+    mips_splati_b,                             // llvm.mips.splati.b
+    mips_splati_d,                             // llvm.mips.splati.d
+    mips_splati_h,                             // llvm.mips.splati.h
+    mips_splati_w,                             // llvm.mips.splati.w
+    mips_sra_b,                                // llvm.mips.sra.b
+    mips_sra_d,                                // llvm.mips.sra.d
+    mips_sra_h,                                // llvm.mips.sra.h
+    mips_sra_w,                                // llvm.mips.sra.w
+    mips_srai_b,                               // llvm.mips.srai.b
+    mips_srai_d,                               // llvm.mips.srai.d
+    mips_srai_h,                               // llvm.mips.srai.h
+    mips_srai_w,                               // llvm.mips.srai.w
+    mips_srar_b,                               // llvm.mips.srar.b
+    mips_srar_d,                               // llvm.mips.srar.d
+    mips_srar_h,                               // llvm.mips.srar.h
+    mips_srar_w,                               // llvm.mips.srar.w
+    mips_srari_b,                              // llvm.mips.srari.b
+    mips_srari_d,                              // llvm.mips.srari.d
+    mips_srari_h,                              // llvm.mips.srari.h
+    mips_srari_w,                              // llvm.mips.srari.w
+    mips_srl_b,                                // llvm.mips.srl.b
+    mips_srl_d,                                // llvm.mips.srl.d
+    mips_srl_h,                                // llvm.mips.srl.h
+    mips_srl_w,                                // llvm.mips.srl.w
+    mips_srli_b,                               // llvm.mips.srli.b
+    mips_srli_d,                               // llvm.mips.srli.d
+    mips_srli_h,                               // llvm.mips.srli.h
+    mips_srli_w,                               // llvm.mips.srli.w
+    mips_srlr_b,                               // llvm.mips.srlr.b
+    mips_srlr_d,                               // llvm.mips.srlr.d
+    mips_srlr_h,                               // llvm.mips.srlr.h
+    mips_srlr_w,                               // llvm.mips.srlr.w
+    mips_srlri_b,                              // llvm.mips.srlri.b
+    mips_srlri_d,                              // llvm.mips.srlri.d
+    mips_srlri_h,                              // llvm.mips.srlri.h
+    mips_srlri_w,                              // llvm.mips.srlri.w
+    mips_st_b,                                 // llvm.mips.st.b
+    mips_st_d,                                 // llvm.mips.st.d
+    mips_st_h,                                 // llvm.mips.st.h
+    mips_st_w,                                 // llvm.mips.st.w
+    mips_str_d,                                // llvm.mips.str.d
+    mips_str_w,                                // llvm.mips.str.w
+    mips_subq_ph,                              // llvm.mips.subq.ph
+    mips_subq_s_ph,                            // llvm.mips.subq.s.ph
+    mips_subq_s_w,                             // llvm.mips.subq.s.w
+    mips_subqh_ph,                             // llvm.mips.subqh.ph
+    mips_subqh_r_ph,                           // llvm.mips.subqh.r.ph
+    mips_subqh_r_w,                            // llvm.mips.subqh.r.w
+    mips_subqh_w,                              // llvm.mips.subqh.w
+    mips_subs_s_b,                             // llvm.mips.subs.s.b
+    mips_subs_s_d,                             // llvm.mips.subs.s.d
+    mips_subs_s_h,                             // llvm.mips.subs.s.h
+    mips_subs_s_w,                             // llvm.mips.subs.s.w
+    mips_subs_u_b,                             // llvm.mips.subs.u.b
+    mips_subs_u_d,                             // llvm.mips.subs.u.d
+    mips_subs_u_h,                             // llvm.mips.subs.u.h
+    mips_subs_u_w,                             // llvm.mips.subs.u.w
+    mips_subsus_u_b,                           // llvm.mips.subsus.u.b
+    mips_subsus_u_d,                           // llvm.mips.subsus.u.d
+    mips_subsus_u_h,                           // llvm.mips.subsus.u.h
+    mips_subsus_u_w,                           // llvm.mips.subsus.u.w
+    mips_subsuu_s_b,                           // llvm.mips.subsuu.s.b
+    mips_subsuu_s_d,                           // llvm.mips.subsuu.s.d
+    mips_subsuu_s_h,                           // llvm.mips.subsuu.s.h
+    mips_subsuu_s_w,                           // llvm.mips.subsuu.s.w
+    mips_subu_ph,                              // llvm.mips.subu.ph
+    mips_subu_qb,                              // llvm.mips.subu.qb
+    mips_subu_s_ph,                            // llvm.mips.subu.s.ph
+    mips_subu_s_qb,                            // llvm.mips.subu.s.qb
+    mips_subuh_qb,                             // llvm.mips.subuh.qb
+    mips_subuh_r_qb,                           // llvm.mips.subuh.r.qb
+    mips_subv_b,                               // llvm.mips.subv.b
+    mips_subv_d,                               // llvm.mips.subv.d
+    mips_subv_h,                               // llvm.mips.subv.h
+    mips_subv_w,                               // llvm.mips.subv.w
+    mips_subvi_b,                              // llvm.mips.subvi.b
+    mips_subvi_d,                              // llvm.mips.subvi.d
+    mips_subvi_h,                              // llvm.mips.subvi.h
+    mips_subvi_w,                              // llvm.mips.subvi.w
+    mips_vshf_b,                               // llvm.mips.vshf.b
+    mips_vshf_d,                               // llvm.mips.vshf.d
+    mips_vshf_h,                               // llvm.mips.vshf.h
+    mips_vshf_w,                               // llvm.mips.vshf.w
+    mips_wrdsp,                                // llvm.mips.wrdsp
+    mips_xor_v,                                // llvm.mips.xor.v
+    mips_xori_b,                               // llvm.mips.xori.b
+}; // enum
+} // namespace Intrinsic
+} // namespace llvm
+
+#endif
diff --git a/linux-x64/clang/include/llvm/IR/IntrinsicsMips.td b/linux-x64/clang/include/llvm/IR/IntrinsicsMips.td
index 308bec9..271142c 100644
--- a/linux-x64/clang/include/llvm/IR/IntrinsicsMips.td
+++ b/linux-x64/clang/include/llvm/IR/IntrinsicsMips.td
@@ -234,9 +234,9 @@
 // Misc
 
 def int_mips_wrdsp: GCCBuiltin<"__builtin_mips_wrdsp">,
-  Intrinsic<[], [llvm_i32_ty, llvm_i32_ty], [ImmArg<1>]>;
+  Intrinsic<[], [llvm_i32_ty, llvm_i32_ty], [ImmArg<ArgIndex<1>>]>;
 def int_mips_rddsp: GCCBuiltin<"__builtin_mips_rddsp">,
-  Intrinsic<[llvm_i32_ty], [llvm_i32_ty], [IntrReadMem, ImmArg<0>]>;
+  Intrinsic<[llvm_i32_ty], [llvm_i32_ty], [IntrReadMem, ImmArg<ArgIndex<0>>]>;
 
 def int_mips_insv: GCCBuiltin<"__builtin_mips_insv">,
   Intrinsic<[llvm_i32_ty], [llvm_i32_ty, llvm_i32_ty], [IntrReadMem]>;
@@ -302,10 +302,10 @@
 
 def int_mips_append: GCCBuiltin<"__builtin_mips_append">,
   Intrinsic<[llvm_i32_ty], [llvm_i32_ty, llvm_i32_ty, llvm_i32_ty],
-  [IntrNoMem, ImmArg<2>]>;
+  [IntrNoMem, ImmArg<ArgIndex<2>>]>;
 def int_mips_balign: GCCBuiltin<"__builtin_mips_balign">,
   Intrinsic<[llvm_i32_ty], [llvm_i32_ty, llvm_i32_ty, llvm_i32_ty],
-  [IntrNoMem, ImmArg<2>]>;
+  [IntrNoMem, ImmArg<ArgIndex<2>>]>;
 
 def int_mips_cmpgdu_eq_qb: GCCBuiltin<"__builtin_mips_cmpgdu_eq_qb">,
   Intrinsic<[llvm_i32_ty], [llvm_v4i8_ty, llvm_v4i8_ty], [Commutative]>;
@@ -355,14 +355,14 @@
   Intrinsic<[llvm_v4i8_ty], [llvm_v2i16_ty, llvm_v2i16_ty], []>;
 def int_mips_precr_sra_ph_w: GCCBuiltin<"__builtin_mips_precr_sra_ph_w">,
   Intrinsic<[llvm_v2i16_ty], [llvm_i32_ty, llvm_i32_ty, llvm_i32_ty],
-            [IntrNoMem, ImmArg<2>]>;
+            [IntrNoMem, ImmArg<ArgIndex<2>>]>;
 def int_mips_precr_sra_r_ph_w: GCCBuiltin<"__builtin_mips_precr_sra_r_ph_w">,
   Intrinsic<[llvm_v2i16_ty], [llvm_i32_ty, llvm_i32_ty, llvm_i32_ty],
-            [IntrNoMem, ImmArg<2>]>;
+            [IntrNoMem, ImmArg<ArgIndex<2>>]>;
 
 def int_mips_prepend: GCCBuiltin<"__builtin_mips_prepend">,
   Intrinsic<[llvm_i32_ty], [llvm_i32_ty, llvm_i32_ty, llvm_i32_ty],
-  [IntrNoMem, ImmArg<2>]>;
+  [IntrNoMem, ImmArg<ArgIndex<2>>]>;
 
 def int_mips_shra_qb: GCCBuiltin<"__builtin_mips_shra_qb">,
   Intrinsic<[llvm_v4i8_ty], [llvm_v4i8_ty, llvm_i32_ty], [IntrNoMem]>;
@@ -463,22 +463,22 @@
 
 def int_mips_addvi_b : GCCBuiltin<"__builtin_msa_addvi_b">,
   Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_i32_ty],
-  [Commutative, IntrNoMem, ImmArg<1>]>;
+  [Commutative, IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_addvi_h : GCCBuiltin<"__builtin_msa_addvi_h">,
   Intrinsic<[llvm_v8i16_ty], [llvm_v8i16_ty, llvm_i32_ty],
-  [Commutative, IntrNoMem, ImmArg<1>]>;
+  [Commutative, IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_addvi_w : GCCBuiltin<"__builtin_msa_addvi_w">,
   Intrinsic<[llvm_v4i32_ty], [llvm_v4i32_ty, llvm_i32_ty],
-  [Commutative, IntrNoMem, ImmArg<1>]>;
+  [Commutative, IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_addvi_d : GCCBuiltin<"__builtin_msa_addvi_d">,
   Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_i32_ty],
-  [Commutative, IntrNoMem, ImmArg<1>]>;
+  [Commutative, IntrNoMem, ImmArg<ArgIndex<1>>]>;
 
 def int_mips_and_v : GCCBuiltin<"__builtin_msa_and_v">,
   Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_v16i8_ty], [IntrNoMem]>;
 
 def int_mips_andi_b : GCCBuiltin<"__builtin_msa_andi_b">,
-  Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 
 def int_mips_asub_s_b : GCCBuiltin<"__builtin_msa_asub_s_b">,
   Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_v16i8_ty], [IntrNoMem]>;
@@ -560,13 +560,13 @@
   Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_v2i64_ty], [IntrNoMem]>;
 
 def int_mips_bclri_b : GCCBuiltin<"__builtin_msa_bclri_b">,
-  Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_bclri_h : GCCBuiltin<"__builtin_msa_bclri_h">,
-  Intrinsic<[llvm_v8i16_ty], [llvm_v8i16_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v8i16_ty], [llvm_v8i16_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_bclri_w : GCCBuiltin<"__builtin_msa_bclri_w">,
-  Intrinsic<[llvm_v4i32_ty], [llvm_v4i32_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v4i32_ty], [llvm_v4i32_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_bclri_d : GCCBuiltin<"__builtin_msa_bclri_d">,
-  Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 
 def int_mips_binsl_b : GCCBuiltin<"__builtin_msa_binsl_b">,
   Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_v16i8_ty, llvm_v16i8_ty],
@@ -583,16 +583,16 @@
 
 def int_mips_binsli_b : GCCBuiltin<"__builtin_msa_binsli_b">,
   Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_v16i8_ty, llvm_i32_ty],
-            [IntrNoMem, ImmArg<2>]>;
+            [IntrNoMem, ImmArg<ArgIndex<2>>]>;
 def int_mips_binsli_h : GCCBuiltin<"__builtin_msa_binsli_h">,
   Intrinsic<[llvm_v8i16_ty], [llvm_v8i16_ty, llvm_v8i16_ty, llvm_i32_ty],
-            [IntrNoMem, ImmArg<2>]>;
+            [IntrNoMem, ImmArg<ArgIndex<2>>]>;
 def int_mips_binsli_w : GCCBuiltin<"__builtin_msa_binsli_w">,
   Intrinsic<[llvm_v4i32_ty], [llvm_v4i32_ty, llvm_v4i32_ty, llvm_i32_ty],
-            [IntrNoMem, ImmArg<2>]>;
+            [IntrNoMem, ImmArg<ArgIndex<2>>]>;
 def int_mips_binsli_d : GCCBuiltin<"__builtin_msa_binsli_d">,
   Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_v2i64_ty, llvm_i32_ty],
-            [IntrNoMem, ImmArg<2>]>;
+            [IntrNoMem, ImmArg<ArgIndex<2>>]>;
 
 def int_mips_binsr_b : GCCBuiltin<"__builtin_msa_binsr_b">,
   Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_v16i8_ty, llvm_v16i8_ty],
@@ -609,16 +609,16 @@
 
 def int_mips_binsri_b : GCCBuiltin<"__builtin_msa_binsri_b">,
   Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_v16i8_ty, llvm_i32_ty],
-            [IntrNoMem, ImmArg<2>]>;
+            [IntrNoMem, ImmArg<ArgIndex<2>>]>;
 def int_mips_binsri_h : GCCBuiltin<"__builtin_msa_binsri_h">,
   Intrinsic<[llvm_v8i16_ty], [llvm_v8i16_ty, llvm_v8i16_ty, llvm_i32_ty],
-            [IntrNoMem, ImmArg<2>]>;
+            [IntrNoMem, ImmArg<ArgIndex<2>>]>;
 def int_mips_binsri_w : GCCBuiltin<"__builtin_msa_binsri_w">,
   Intrinsic<[llvm_v4i32_ty], [llvm_v4i32_ty, llvm_v4i32_ty, llvm_i32_ty],
-            [IntrNoMem, ImmArg<2>]>;
+            [IntrNoMem, ImmArg<ArgIndex<2>>]>;
 def int_mips_binsri_d : GCCBuiltin<"__builtin_msa_binsri_d">,
   Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_v2i64_ty, llvm_i32_ty],
-            [IntrNoMem, ImmArg<2>]>;
+            [IntrNoMem, ImmArg<ArgIndex<2>>]>;
 
 def int_mips_bmnz_v : GCCBuiltin<"__builtin_msa_bmnz_v">,
   Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_v16i8_ty, llvm_v16i8_ty],
@@ -626,7 +626,7 @@
 
 def int_mips_bmnzi_b : GCCBuiltin<"__builtin_msa_bmnzi_b">,
   Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_v16i8_ty, llvm_i32_ty],
-            [IntrNoMem, ImmArg<2>]>;
+            [IntrNoMem, ImmArg<ArgIndex<2>>]>;
 
 def int_mips_bmz_v : GCCBuiltin<"__builtin_msa_bmz_v">,
   Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_v16i8_ty, llvm_v16i8_ty],
@@ -634,7 +634,7 @@
 
 def int_mips_bmzi_b : GCCBuiltin<"__builtin_msa_bmzi_b">,
   Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_v16i8_ty, llvm_i32_ty],
-            [IntrNoMem, ImmArg<2>]>;
+            [IntrNoMem, ImmArg<ArgIndex<2>>]>;
 
 def int_mips_bneg_b : GCCBuiltin<"__builtin_msa_bneg_b">,
   Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_v16i8_ty], [IntrNoMem]>;
@@ -646,13 +646,13 @@
   Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_v2i64_ty], [IntrNoMem]>;
 
 def int_mips_bnegi_b : GCCBuiltin<"__builtin_msa_bnegi_b">,
-  Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_bnegi_h : GCCBuiltin<"__builtin_msa_bnegi_h">,
-  Intrinsic<[llvm_v8i16_ty], [llvm_v8i16_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v8i16_ty], [llvm_v8i16_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_bnegi_w : GCCBuiltin<"__builtin_msa_bnegi_w">,
-  Intrinsic<[llvm_v4i32_ty], [llvm_v4i32_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v4i32_ty], [llvm_v4i32_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_bnegi_d : GCCBuiltin<"__builtin_msa_bnegi_d">,
-  Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 
 def int_mips_bnz_b : GCCBuiltin<"__builtin_msa_bnz_b">,
   Intrinsic<[llvm_i32_ty], [llvm_v16i8_ty], [IntrNoMem]>;
@@ -672,7 +672,7 @@
 
 def int_mips_bseli_b : GCCBuiltin<"__builtin_msa_bseli_b">,
   Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_v16i8_ty, llvm_i32_ty],
-            [IntrNoMem, ImmArg<2>]>;
+            [IntrNoMem, ImmArg<ArgIndex<2>>]>;
 
 def int_mips_bset_b : GCCBuiltin<"__builtin_msa_bset_b">,
   Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_v16i8_ty], [IntrNoMem]>;
@@ -684,13 +684,13 @@
   Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_v2i64_ty], [IntrNoMem]>;
 
 def int_mips_bseti_b : GCCBuiltin<"__builtin_msa_bseti_b">,
-  Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_bseti_h : GCCBuiltin<"__builtin_msa_bseti_h">,
-  Intrinsic<[llvm_v8i16_ty], [llvm_v8i16_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v8i16_ty], [llvm_v8i16_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_bseti_w : GCCBuiltin<"__builtin_msa_bseti_w">,
-  Intrinsic<[llvm_v4i32_ty], [llvm_v4i32_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v4i32_ty], [llvm_v4i32_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_bseti_d : GCCBuiltin<"__builtin_msa_bseti_d">,
-  Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 
 def int_mips_bz_b : GCCBuiltin<"__builtin_msa_bz_b">,
   Intrinsic<[llvm_i32_ty], [llvm_v16i8_ty], [IntrNoMem]>;
@@ -714,16 +714,16 @@
   Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_v2i64_ty], [IntrNoMem]>;
 
 def int_mips_ceqi_b : GCCBuiltin<"__builtin_msa_ceqi_b">,
-  Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_ceqi_h : GCCBuiltin<"__builtin_msa_ceqi_h">,
-  Intrinsic<[llvm_v8i16_ty], [llvm_v8i16_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v8i16_ty], [llvm_v8i16_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_ceqi_w : GCCBuiltin<"__builtin_msa_ceqi_w">,
-  Intrinsic<[llvm_v4i32_ty], [llvm_v4i32_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v4i32_ty], [llvm_v4i32_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_ceqi_d : GCCBuiltin<"__builtin_msa_ceqi_d">,
-  Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 
 def int_mips_cfcmsa : GCCBuiltin<"__builtin_msa_cfcmsa">,
-  Intrinsic<[llvm_i32_ty], [llvm_i32_ty], [ImmArg<0>]>;
+  Intrinsic<[llvm_i32_ty], [llvm_i32_ty], [ImmArg<ArgIndex<0>>]>;
 
 def int_mips_cle_s_b : GCCBuiltin<"__builtin_msa_cle_s_b">,
   Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_v16i8_ty], [IntrNoMem]>;
@@ -744,22 +744,22 @@
   Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_v2i64_ty], [IntrNoMem]>;
 
 def int_mips_clei_s_b : GCCBuiltin<"__builtin_msa_clei_s_b">,
-  Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_clei_s_h : GCCBuiltin<"__builtin_msa_clei_s_h">,
-  Intrinsic<[llvm_v8i16_ty], [llvm_v8i16_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v8i16_ty], [llvm_v8i16_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_clei_s_w : GCCBuiltin<"__builtin_msa_clei_s_w">,
-  Intrinsic<[llvm_v4i32_ty], [llvm_v4i32_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v4i32_ty], [llvm_v4i32_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_clei_s_d : GCCBuiltin<"__builtin_msa_clei_s_d">,
-  Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 
 def int_mips_clei_u_b : GCCBuiltin<"__builtin_msa_clei_u_b">,
-  Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_clei_u_h : GCCBuiltin<"__builtin_msa_clei_u_h">,
-  Intrinsic<[llvm_v8i16_ty], [llvm_v8i16_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v8i16_ty], [llvm_v8i16_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_clei_u_w : GCCBuiltin<"__builtin_msa_clei_u_w">,
-  Intrinsic<[llvm_v4i32_ty], [llvm_v4i32_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v4i32_ty], [llvm_v4i32_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_clei_u_d : GCCBuiltin<"__builtin_msa_clei_u_d">,
-  Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 
 def int_mips_clt_s_b : GCCBuiltin<"__builtin_msa_clt_s_b">,
   Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_v16i8_ty], [IntrNoMem]>;
@@ -780,43 +780,43 @@
   Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_v2i64_ty], [IntrNoMem]>;
 
 def int_mips_clti_s_b : GCCBuiltin<"__builtin_msa_clti_s_b">,
-  Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_clti_s_h : GCCBuiltin<"__builtin_msa_clti_s_h">,
-  Intrinsic<[llvm_v8i16_ty], [llvm_v8i16_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v8i16_ty], [llvm_v8i16_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_clti_s_w : GCCBuiltin<"__builtin_msa_clti_s_w">,
-  Intrinsic<[llvm_v4i32_ty], [llvm_v4i32_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v4i32_ty], [llvm_v4i32_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_clti_s_d : GCCBuiltin<"__builtin_msa_clti_s_d">,
-  Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 
 def int_mips_clti_u_b : GCCBuiltin<"__builtin_msa_clti_u_b">,
-  Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_clti_u_h : GCCBuiltin<"__builtin_msa_clti_u_h">,
-  Intrinsic<[llvm_v8i16_ty], [llvm_v8i16_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v8i16_ty], [llvm_v8i16_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_clti_u_w : GCCBuiltin<"__builtin_msa_clti_u_w">,
-  Intrinsic<[llvm_v4i32_ty], [llvm_v4i32_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v4i32_ty], [llvm_v4i32_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_clti_u_d : GCCBuiltin<"__builtin_msa_clti_u_d">,
-  Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 
 def int_mips_copy_s_b : GCCBuiltin<"__builtin_msa_copy_s_b">,
-  Intrinsic<[llvm_i32_ty], [llvm_v16i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_i32_ty], [llvm_v16i8_ty, llvm_i32_ty], [IntrNoMem]>;
 def int_mips_copy_s_h : GCCBuiltin<"__builtin_msa_copy_s_h">,
-  Intrinsic<[llvm_i32_ty], [llvm_v8i16_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_i32_ty], [llvm_v8i16_ty, llvm_i32_ty], [IntrNoMem]>;
 def int_mips_copy_s_w : GCCBuiltin<"__builtin_msa_copy_s_w">,
-  Intrinsic<[llvm_i32_ty], [llvm_v4i32_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_i32_ty], [llvm_v4i32_ty, llvm_i32_ty], [IntrNoMem]>;
 def int_mips_copy_s_d : GCCBuiltin<"__builtin_msa_copy_s_d">,
-  Intrinsic<[llvm_i64_ty], [llvm_v2i64_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_i64_ty], [llvm_v2i64_ty, llvm_i32_ty], [IntrNoMem]>;
 
 def int_mips_copy_u_b : GCCBuiltin<"__builtin_msa_copy_u_b">,
-  Intrinsic<[llvm_i32_ty], [llvm_v16i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_i32_ty], [llvm_v16i8_ty, llvm_i32_ty], [IntrNoMem]>;
 def int_mips_copy_u_h : GCCBuiltin<"__builtin_msa_copy_u_h">,
-  Intrinsic<[llvm_i32_ty], [llvm_v8i16_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_i32_ty], [llvm_v8i16_ty, llvm_i32_ty], [IntrNoMem]>;
 def int_mips_copy_u_w : GCCBuiltin<"__builtin_msa_copy_u_w">,
-  Intrinsic<[llvm_i32_ty], [llvm_v4i32_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_i32_ty], [llvm_v4i32_ty, llvm_i32_ty], [IntrNoMem]>;
 def int_mips_copy_u_d : GCCBuiltin<"__builtin_msa_copy_u_d">,
-  Intrinsic<[llvm_i64_ty], [llvm_v2i64_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_i64_ty], [llvm_v2i64_ty, llvm_i32_ty], [IntrNoMem]>;
 
 def int_mips_ctcmsa : GCCBuiltin<"__builtin_msa_ctcmsa">,
-  Intrinsic<[], [llvm_i32_ty, llvm_i32_ty], [ImmArg<0>]>;
+  Intrinsic<[], [llvm_i32_ty, llvm_i32_ty], [ImmArg<ArgIndex<0>>]>;
 
 def int_mips_div_s_b : GCCBuiltin<"__builtin_msa_div_s_b">,
   Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_v16i8_ty], [IntrNoMem]>;
@@ -1230,55 +1230,62 @@
 
 def int_mips_insert_b : GCCBuiltin<"__builtin_msa_insert_b">,
   Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_i32_ty, llvm_i32_ty],
-  [IntrNoMem, ImmArg<1>]>;
+  [IntrNoMem]>;
 def int_mips_insert_h : GCCBuiltin<"__builtin_msa_insert_h">,
   Intrinsic<[llvm_v8i16_ty], [llvm_v8i16_ty, llvm_i32_ty, llvm_i32_ty],
-  [IntrNoMem, ImmArg<1>]>;
+  [IntrNoMem]>;
 def int_mips_insert_w : GCCBuiltin<"__builtin_msa_insert_w">,
   Intrinsic<[llvm_v4i32_ty], [llvm_v4i32_ty, llvm_i32_ty, llvm_i32_ty],
-  [IntrNoMem, ImmArg<1>]>;
+  [IntrNoMem]>;
 def int_mips_insert_d : GCCBuiltin<"__builtin_msa_insert_d">,
   Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_i32_ty, llvm_i64_ty],
-  [IntrNoMem, ImmArg<1>]>;
+  [IntrNoMem]>;
 
 def int_mips_insve_b : GCCBuiltin<"__builtin_msa_insve_b">,
   Intrinsic<[llvm_v16i8_ty],
             [llvm_v16i8_ty, llvm_i32_ty, llvm_v16i8_ty],
-            [IntrNoMem, ImmArg<1>]>;
+            [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_insve_h : GCCBuiltin<"__builtin_msa_insve_h">,
   Intrinsic<[llvm_v8i16_ty],
             [llvm_v8i16_ty, llvm_i32_ty, llvm_v8i16_ty],
-            [IntrNoMem, ImmArg<1>]>;
+            [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_insve_w : GCCBuiltin<"__builtin_msa_insve_w">,
   Intrinsic<[llvm_v4i32_ty],
             [llvm_v4i32_ty, llvm_i32_ty, llvm_v4i32_ty],
-            [IntrNoMem, ImmArg<1>]>;
+            [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_insve_d : GCCBuiltin<"__builtin_msa_insve_d">,
   Intrinsic<[llvm_v2i64_ty],
             [llvm_v2i64_ty, llvm_i32_ty, llvm_v2i64_ty],
-            [IntrNoMem, ImmArg<1>]>;
+            [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 
 def int_mips_ld_b : GCCBuiltin<"__builtin_msa_ld_b">,
   Intrinsic<[llvm_v16i8_ty], [llvm_ptr_ty, llvm_i32_ty],
-  [IntrReadMem, IntrArgMemOnly, ImmArg<1>]>;
+  [IntrReadMem, IntrArgMemOnly]>;
 def int_mips_ld_h : GCCBuiltin<"__builtin_msa_ld_h">,
   Intrinsic<[llvm_v8i16_ty], [llvm_ptr_ty, llvm_i32_ty],
-  [IntrReadMem, IntrArgMemOnly, ImmArg<1>]>;
+  [IntrReadMem, IntrArgMemOnly]>;
 def int_mips_ld_w : GCCBuiltin<"__builtin_msa_ld_w">,
   Intrinsic<[llvm_v4i32_ty], [llvm_ptr_ty, llvm_i32_ty],
-  [IntrReadMem, IntrArgMemOnly, ImmArg<1>]>;
+  [IntrReadMem, IntrArgMemOnly]>;
 def int_mips_ld_d : GCCBuiltin<"__builtin_msa_ld_d">,
   Intrinsic<[llvm_v2i64_ty], [llvm_ptr_ty, llvm_i32_ty],
-  [IntrReadMem, IntrArgMemOnly, ImmArg<1>]>;
+  [IntrReadMem, IntrArgMemOnly]>;
+
+def int_mips_ldr_d : GCCBuiltin<"__builtin_msa_ldr_d">,
+  Intrinsic<[llvm_v2i64_ty], [llvm_ptr_ty, llvm_i32_ty],
+  [IntrReadMem, IntrArgMemOnly]>;
+def int_mips_ldr_w : GCCBuiltin<"__builtin_msa_ldr_w">,
+  Intrinsic<[llvm_v4i32_ty], [llvm_ptr_ty, llvm_i32_ty],
+  [IntrReadMem, IntrArgMemOnly]>;
 
 def int_mips_ldi_b : GCCBuiltin<"__builtin_msa_ldi_b">,
-  Intrinsic<[llvm_v16i8_ty], [llvm_i32_ty], [IntrNoMem, ImmArg<0>]>;
+  Intrinsic<[llvm_v16i8_ty], [llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<0>>]>;
 def int_mips_ldi_h : GCCBuiltin<"__builtin_msa_ldi_h">,
-  Intrinsic<[llvm_v8i16_ty], [llvm_i32_ty], [IntrNoMem, ImmArg<0>]>;
+  Intrinsic<[llvm_v8i16_ty], [llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<0>>]>;
 def int_mips_ldi_w : GCCBuiltin<"__builtin_msa_ldi_w">,
-  Intrinsic<[llvm_v4i32_ty], [llvm_i32_ty], [IntrNoMem, ImmArg<0>]>;
+  Intrinsic<[llvm_v4i32_ty], [llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<0>>]>;
 def int_mips_ldi_d : GCCBuiltin<"__builtin_msa_ldi_d">,
-  Intrinsic<[llvm_v2i64_ty], [llvm_i32_ty], [IntrNoMem, ImmArg<0>]>;
+  Intrinsic<[llvm_v2i64_ty], [llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<0>>]>;
 
 // This instruction is part of the MSA spec but it does not share the
 // __builtin_msa prefix because it operates on the GPR registers.
@@ -1341,22 +1348,22 @@
   Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_v2i64_ty], [IntrNoMem]>;
 
 def int_mips_maxi_s_b : GCCBuiltin<"__builtin_msa_maxi_s_b">,
-  Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_maxi_s_h : GCCBuiltin<"__builtin_msa_maxi_s_h">,
-  Intrinsic<[llvm_v8i16_ty], [llvm_v8i16_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v8i16_ty], [llvm_v8i16_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_maxi_s_w : GCCBuiltin<"__builtin_msa_maxi_s_w">,
-  Intrinsic<[llvm_v4i32_ty], [llvm_v4i32_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v4i32_ty], [llvm_v4i32_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_maxi_s_d : GCCBuiltin<"__builtin_msa_maxi_s_d">,
-  Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 
 def int_mips_maxi_u_b : GCCBuiltin<"__builtin_msa_maxi_u_b">,
-  Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_maxi_u_h : GCCBuiltin<"__builtin_msa_maxi_u_h">,
-  Intrinsic<[llvm_v8i16_ty], [llvm_v8i16_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v8i16_ty], [llvm_v8i16_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_maxi_u_w : GCCBuiltin<"__builtin_msa_maxi_u_w">,
-  Intrinsic<[llvm_v4i32_ty], [llvm_v4i32_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v4i32_ty], [llvm_v4i32_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_maxi_u_d : GCCBuiltin<"__builtin_msa_maxi_u_d">,
-  Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 
 def int_mips_min_a_b : GCCBuiltin<"__builtin_msa_min_a_b">,
   Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_v16i8_ty], [IntrNoMem]>;
@@ -1386,22 +1393,22 @@
   Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_v2i64_ty], [IntrNoMem]>;
 
 def int_mips_mini_s_b : GCCBuiltin<"__builtin_msa_mini_s_b">,
-  Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_mini_s_h : GCCBuiltin<"__builtin_msa_mini_s_h">,
-  Intrinsic<[llvm_v8i16_ty], [llvm_v8i16_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v8i16_ty], [llvm_v8i16_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_mini_s_w : GCCBuiltin<"__builtin_msa_mini_s_w">,
-  Intrinsic<[llvm_v4i32_ty], [llvm_v4i32_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v4i32_ty], [llvm_v4i32_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_mini_s_d : GCCBuiltin<"__builtin_msa_mini_s_d">,
-  Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 
 def int_mips_mini_u_b : GCCBuiltin<"__builtin_msa_mini_u_b">,
-  Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_mini_u_h : GCCBuiltin<"__builtin_msa_mini_u_h">,
-  Intrinsic<[llvm_v8i16_ty], [llvm_v8i16_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v8i16_ty], [llvm_v8i16_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_mini_u_w : GCCBuiltin<"__builtin_msa_mini_u_w">,
-  Intrinsic<[llvm_v4i32_ty], [llvm_v4i32_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v4i32_ty], [llvm_v4i32_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_mini_u_d : GCCBuiltin<"__builtin_msa_mini_u_d">,
-  Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 
 def int_mips_mod_s_b : GCCBuiltin<"__builtin_msa_mod_s_b">,
   Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_v16i8_ty], [IntrNoMem]>;
@@ -1492,13 +1499,13 @@
   Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_v16i8_ty], [IntrNoMem]>;
 
 def int_mips_nori_b : GCCBuiltin<"__builtin_msa_nori_b">,
-  Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 
 def int_mips_or_v : GCCBuiltin<"__builtin_msa_or_v">,
   Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_v16i8_ty], [IntrNoMem]>;
 
 def int_mips_ori_b : GCCBuiltin<"__builtin_msa_ori_b">,
-  Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 
 def int_mips_pckev_b : GCCBuiltin<"__builtin_msa_pckev_b">,
   Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_v16i8_ty], [IntrNoMem]>;
@@ -1528,29 +1535,29 @@
   Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty], [IntrNoMem]>;
 
 def int_mips_sat_s_b : GCCBuiltin<"__builtin_msa_sat_s_b">,
-  Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_sat_s_h : GCCBuiltin<"__builtin_msa_sat_s_h">,
-  Intrinsic<[llvm_v8i16_ty], [llvm_v8i16_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v8i16_ty], [llvm_v8i16_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_sat_s_w : GCCBuiltin<"__builtin_msa_sat_s_w">,
-  Intrinsic<[llvm_v4i32_ty], [llvm_v4i32_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v4i32_ty], [llvm_v4i32_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_sat_s_d : GCCBuiltin<"__builtin_msa_sat_s_d">,
-  Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 
 def int_mips_sat_u_b : GCCBuiltin<"__builtin_msa_sat_u_b">,
-  Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_sat_u_h : GCCBuiltin<"__builtin_msa_sat_u_h">,
-  Intrinsic<[llvm_v8i16_ty], [llvm_v8i16_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v8i16_ty], [llvm_v8i16_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_sat_u_w : GCCBuiltin<"__builtin_msa_sat_u_w">,
-  Intrinsic<[llvm_v4i32_ty], [llvm_v4i32_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v4i32_ty], [llvm_v4i32_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_sat_u_d : GCCBuiltin<"__builtin_msa_sat_u_d">,
-  Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 
 def int_mips_shf_b : GCCBuiltin<"__builtin_msa_shf_b">,
-  Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_shf_h : GCCBuiltin<"__builtin_msa_shf_h">,
-  Intrinsic<[llvm_v8i16_ty], [llvm_v8i16_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v8i16_ty], [llvm_v8i16_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_shf_w : GCCBuiltin<"__builtin_msa_shf_w">,
-  Intrinsic<[llvm_v4i32_ty], [llvm_v4i32_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v4i32_ty], [llvm_v4i32_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 
 def int_mips_sld_b : GCCBuiltin<"__builtin_msa_sld_b">,
   Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_v16i8_ty, llvm_i32_ty], [IntrNoMem]>;
@@ -1563,16 +1570,16 @@
 
 def int_mips_sldi_b : GCCBuiltin<"__builtin_msa_sldi_b">,
   Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_v16i8_ty, llvm_i32_ty],
-            [IntrNoMem, ImmArg<2>]>;
+            [IntrNoMem, ImmArg<ArgIndex<2>>]>;
 def int_mips_sldi_h : GCCBuiltin<"__builtin_msa_sldi_h">,
   Intrinsic<[llvm_v8i16_ty], [llvm_v8i16_ty, llvm_v8i16_ty, llvm_i32_ty],
-            [IntrNoMem, ImmArg<2>]>;
+            [IntrNoMem, ImmArg<ArgIndex<2>>]>;
 def int_mips_sldi_w : GCCBuiltin<"__builtin_msa_sldi_w">,
   Intrinsic<[llvm_v4i32_ty], [llvm_v4i32_ty, llvm_v4i32_ty, llvm_i32_ty],
-            [IntrNoMem, ImmArg<2>]>;
+            [IntrNoMem, ImmArg<ArgIndex<2>>]>;
 def int_mips_sldi_d : GCCBuiltin<"__builtin_msa_sldi_d">,
   Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_v2i64_ty, llvm_i32_ty],
-            [IntrNoMem, ImmArg<2>]>;
+            [IntrNoMem, ImmArg<ArgIndex<2>>]>;
 
 def int_mips_sll_b : GCCBuiltin<"__builtin_msa_sll_b">,
   Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_v16i8_ty], [IntrNoMem]>;
@@ -1584,13 +1591,13 @@
   Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_v2i64_ty], [IntrNoMem]>;
 
 def int_mips_slli_b : GCCBuiltin<"__builtin_msa_slli_b">,
-  Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_slli_h : GCCBuiltin<"__builtin_msa_slli_h">,
-  Intrinsic<[llvm_v8i16_ty], [llvm_v8i16_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v8i16_ty], [llvm_v8i16_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_slli_w : GCCBuiltin<"__builtin_msa_slli_w">,
-  Intrinsic<[llvm_v4i32_ty], [llvm_v4i32_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v4i32_ty], [llvm_v4i32_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_slli_d : GCCBuiltin<"__builtin_msa_slli_d">,
-  Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 
 def int_mips_splat_b : GCCBuiltin<"__builtin_msa_splat_b">,
   Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_i32_ty], [IntrNoMem]>;
@@ -1602,13 +1609,13 @@
   Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_i32_ty], [IntrNoMem]>;
 
 def int_mips_splati_b : GCCBuiltin<"__builtin_msa_splati_b">,
-  Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_splati_h : GCCBuiltin<"__builtin_msa_splati_h">,
-  Intrinsic<[llvm_v8i16_ty], [llvm_v8i16_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v8i16_ty], [llvm_v8i16_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_splati_w : GCCBuiltin<"__builtin_msa_splati_w">,
-  Intrinsic<[llvm_v4i32_ty], [llvm_v4i32_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v4i32_ty], [llvm_v4i32_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_splati_d : GCCBuiltin<"__builtin_msa_splati_d">,
-  Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 
 def int_mips_sra_b : GCCBuiltin<"__builtin_msa_sra_b">,
   Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_v16i8_ty], [IntrNoMem]>;
@@ -1620,13 +1627,13 @@
   Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_v2i64_ty], [IntrNoMem]>;
 
 def int_mips_srai_b : GCCBuiltin<"__builtin_msa_srai_b">,
-  Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_srai_h : GCCBuiltin<"__builtin_msa_srai_h">,
-  Intrinsic<[llvm_v8i16_ty], [llvm_v8i16_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v8i16_ty], [llvm_v8i16_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_srai_w : GCCBuiltin<"__builtin_msa_srai_w">,
-  Intrinsic<[llvm_v4i32_ty], [llvm_v4i32_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v4i32_ty], [llvm_v4i32_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_srai_d : GCCBuiltin<"__builtin_msa_srai_d">,
-  Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 
 def int_mips_srar_b : GCCBuiltin<"__builtin_msa_srar_b">,
   Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_v16i8_ty], [IntrNoMem]>;
@@ -1638,13 +1645,13 @@
   Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_v2i64_ty], [IntrNoMem]>;
 
 def int_mips_srari_b : GCCBuiltin<"__builtin_msa_srari_b">,
-  Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_srari_h : GCCBuiltin<"__builtin_msa_srari_h">,
-  Intrinsic<[llvm_v8i16_ty], [llvm_v8i16_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v8i16_ty], [llvm_v8i16_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_srari_w : GCCBuiltin<"__builtin_msa_srari_w">,
-  Intrinsic<[llvm_v4i32_ty], [llvm_v4i32_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v4i32_ty], [llvm_v4i32_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_srari_d : GCCBuiltin<"__builtin_msa_srari_d">,
-  Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 
 def int_mips_srl_b : GCCBuiltin<"__builtin_msa_srl_b">,
   Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_v16i8_ty], [IntrNoMem]>;
@@ -1656,13 +1663,13 @@
   Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_v2i64_ty], [IntrNoMem]>;
 
 def int_mips_srli_b : GCCBuiltin<"__builtin_msa_srli_b">,
-  Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_srli_h : GCCBuiltin<"__builtin_msa_srli_h">,
-  Intrinsic<[llvm_v8i16_ty], [llvm_v8i16_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v8i16_ty], [llvm_v8i16_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_srli_w : GCCBuiltin<"__builtin_msa_srli_w">,
-  Intrinsic<[llvm_v4i32_ty], [llvm_v4i32_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v4i32_ty], [llvm_v4i32_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_srli_d : GCCBuiltin<"__builtin_msa_srli_d">,
-  Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 
 def int_mips_srlr_b : GCCBuiltin<"__builtin_msa_srlr_b">,
   Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_v16i8_ty], [IntrNoMem]>;
@@ -1674,26 +1681,33 @@
   Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_v2i64_ty], [IntrNoMem]>;
 
 def int_mips_srlri_b : GCCBuiltin<"__builtin_msa_srlri_b">,
-  Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_srlri_h : GCCBuiltin<"__builtin_msa_srlri_h">,
-  Intrinsic<[llvm_v8i16_ty], [llvm_v8i16_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v8i16_ty], [llvm_v8i16_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_srlri_w : GCCBuiltin<"__builtin_msa_srlri_w">,
-  Intrinsic<[llvm_v4i32_ty], [llvm_v4i32_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v4i32_ty], [llvm_v4i32_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_srlri_d : GCCBuiltin<"__builtin_msa_srlri_d">,
-  Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 
 def int_mips_st_b : GCCBuiltin<"__builtin_msa_st_b">,
   Intrinsic<[], [llvm_v16i8_ty, llvm_ptr_ty, llvm_i32_ty],
-  [IntrArgMemOnly, ImmArg<2>]>;
+  [IntrArgMemOnly]>;
 def int_mips_st_h : GCCBuiltin<"__builtin_msa_st_h">,
   Intrinsic<[], [llvm_v8i16_ty, llvm_ptr_ty, llvm_i32_ty],
-  [IntrArgMemOnly, ImmArg<2>]>;
+  [IntrArgMemOnly]>;
 def int_mips_st_w : GCCBuiltin<"__builtin_msa_st_w">,
   Intrinsic<[], [llvm_v4i32_ty, llvm_ptr_ty, llvm_i32_ty],
-  [IntrArgMemOnly, ImmArg<2>]>;
+  [IntrArgMemOnly]>;
 def int_mips_st_d : GCCBuiltin<"__builtin_msa_st_d">,
   Intrinsic<[], [llvm_v2i64_ty, llvm_ptr_ty, llvm_i32_ty],
-  [IntrArgMemOnly, ImmArg<2>]>;
+  [IntrArgMemOnly]>;
+
+def int_mips_str_d : GCCBuiltin<"__builtin_msa_str_d">,
+  Intrinsic<[], [llvm_v2i64_ty, llvm_ptr_ty, llvm_i32_ty],
+  [IntrArgMemOnly]>;
+def int_mips_str_w : GCCBuiltin<"__builtin_msa_str_w">,
+  Intrinsic<[], [llvm_v4i32_ty, llvm_ptr_ty, llvm_i32_ty],
+  [IntrArgMemOnly]>;
 
 def int_mips_subs_s_b : GCCBuiltin<"__builtin_msa_subs_s_b">,
   Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_v16i8_ty], [IntrNoMem]>;
@@ -1741,13 +1755,13 @@
   Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_v2i64_ty], [IntrNoMem]>;
 
 def int_mips_subvi_b : GCCBuiltin<"__builtin_msa_subvi_b">,
-  Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_subvi_h : GCCBuiltin<"__builtin_msa_subvi_h">,
-  Intrinsic<[llvm_v8i16_ty], [llvm_v8i16_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v8i16_ty], [llvm_v8i16_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_subvi_w : GCCBuiltin<"__builtin_msa_subvi_w">,
-  Intrinsic<[llvm_v4i32_ty], [llvm_v4i32_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v4i32_ty], [llvm_v4i32_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_mips_subvi_d : GCCBuiltin<"__builtin_msa_subvi_d">,
-  Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 
 def int_mips_vshf_b : GCCBuiltin<"__builtin_msa_vshf_b">,
   Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_v16i8_ty, llvm_v16i8_ty],
@@ -1766,5 +1780,5 @@
   Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_v16i8_ty], [IntrNoMem]>;
 
 def int_mips_xori_b : GCCBuiltin<"__builtin_msa_xori_b">,
-  Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+  Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 }
diff --git a/linux-x64/clang/include/llvm/IR/IntrinsicsNVPTX.h b/linux-x64/clang/include/llvm/IR/IntrinsicsNVPTX.h
new file mode 100644
index 0000000..2211273
--- /dev/null
+++ b/linux-x64/clang/include/llvm/IR/IntrinsicsNVPTX.h
@@ -0,0 +1,1316 @@
+/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
+|*                                                                            *|
+|* Intrinsic Function Source Fragment                                         *|
+|*                                                                            *|
+|* Automatically generated file, do not edit!                                 *|
+|*                                                                            *|
+\*===----------------------------------------------------------------------===*/
+
+#ifndef LLVM_IR_INTRINSIC_NVVM_ENUMS_H
+#define LLVM_IR_INTRINSIC_NVVM_ENUMS_H
+
+namespace llvm {
+namespace Intrinsic {
+enum NVVMIntrinsics : unsigned {
+// Enum values for intrinsics
+    nvvm_add_rm_d = 4775,                             // llvm.nvvm.add.rm.d
+    nvvm_add_rm_f,                             // llvm.nvvm.add.rm.f
+    nvvm_add_rm_ftz_f,                         // llvm.nvvm.add.rm.ftz.f
+    nvvm_add_rn_d,                             // llvm.nvvm.add.rn.d
+    nvvm_add_rn_f,                             // llvm.nvvm.add.rn.f
+    nvvm_add_rn_ftz_f,                         // llvm.nvvm.add.rn.ftz.f
+    nvvm_add_rp_d,                             // llvm.nvvm.add.rp.d
+    nvvm_add_rp_f,                             // llvm.nvvm.add.rp.f
+    nvvm_add_rp_ftz_f,                         // llvm.nvvm.add.rp.ftz.f
+    nvvm_add_rz_d,                             // llvm.nvvm.add.rz.d
+    nvvm_add_rz_f,                             // llvm.nvvm.add.rz.f
+    nvvm_add_rz_ftz_f,                         // llvm.nvvm.add.rz.ftz.f
+    nvvm_atomic_add_gen_f_cta,                 // llvm.nvvm.atomic.add.gen.f.cta
+    nvvm_atomic_add_gen_f_sys,                 // llvm.nvvm.atomic.add.gen.f.sys
+    nvvm_atomic_add_gen_i_cta,                 // llvm.nvvm.atomic.add.gen.i.cta
+    nvvm_atomic_add_gen_i_sys,                 // llvm.nvvm.atomic.add.gen.i.sys
+    nvvm_atomic_and_gen_i_cta,                 // llvm.nvvm.atomic.and.gen.i.cta
+    nvvm_atomic_and_gen_i_sys,                 // llvm.nvvm.atomic.and.gen.i.sys
+    nvvm_atomic_cas_gen_i_cta,                 // llvm.nvvm.atomic.cas.gen.i.cta
+    nvvm_atomic_cas_gen_i_sys,                 // llvm.nvvm.atomic.cas.gen.i.sys
+    nvvm_atomic_dec_gen_i_cta,                 // llvm.nvvm.atomic.dec.gen.i.cta
+    nvvm_atomic_dec_gen_i_sys,                 // llvm.nvvm.atomic.dec.gen.i.sys
+    nvvm_atomic_exch_gen_i_cta,                // llvm.nvvm.atomic.exch.gen.i.cta
+    nvvm_atomic_exch_gen_i_sys,                // llvm.nvvm.atomic.exch.gen.i.sys
+    nvvm_atomic_inc_gen_i_cta,                 // llvm.nvvm.atomic.inc.gen.i.cta
+    nvvm_atomic_inc_gen_i_sys,                 // llvm.nvvm.atomic.inc.gen.i.sys
+    nvvm_atomic_load_dec_32,                   // llvm.nvvm.atomic.load.dec.32
+    nvvm_atomic_load_inc_32,                   // llvm.nvvm.atomic.load.inc.32
+    nvvm_atomic_max_gen_i_cta,                 // llvm.nvvm.atomic.max.gen.i.cta
+    nvvm_atomic_max_gen_i_sys,                 // llvm.nvvm.atomic.max.gen.i.sys
+    nvvm_atomic_min_gen_i_cta,                 // llvm.nvvm.atomic.min.gen.i.cta
+    nvvm_atomic_min_gen_i_sys,                 // llvm.nvvm.atomic.min.gen.i.sys
+    nvvm_atomic_or_gen_i_cta,                  // llvm.nvvm.atomic.or.gen.i.cta
+    nvvm_atomic_or_gen_i_sys,                  // llvm.nvvm.atomic.or.gen.i.sys
+    nvvm_atomic_xor_gen_i_cta,                 // llvm.nvvm.atomic.xor.gen.i.cta
+    nvvm_atomic_xor_gen_i_sys,                 // llvm.nvvm.atomic.xor.gen.i.sys
+    nvvm_bar_sync,                             // llvm.nvvm.bar.sync
+    nvvm_bar_warp_sync,                        // llvm.nvvm.bar.warp.sync
+    nvvm_barrier,                              // llvm.nvvm.barrier
+    nvvm_barrier_n,                            // llvm.nvvm.barrier.n
+    nvvm_barrier_sync,                         // llvm.nvvm.barrier.sync
+    nvvm_barrier_sync_cnt,                     // llvm.nvvm.barrier.sync.cnt
+    nvvm_barrier0,                             // llvm.nvvm.barrier0
+    nvvm_barrier0_and,                         // llvm.nvvm.barrier0.and
+    nvvm_barrier0_or,                          // llvm.nvvm.barrier0.or
+    nvvm_barrier0_popc,                        // llvm.nvvm.barrier0.popc
+    nvvm_bitcast_d2ll,                         // llvm.nvvm.bitcast.d2ll
+    nvvm_bitcast_f2i,                          // llvm.nvvm.bitcast.f2i
+    nvvm_bitcast_i2f,                          // llvm.nvvm.bitcast.i2f
+    nvvm_bitcast_ll2d,                         // llvm.nvvm.bitcast.ll2d
+    nvvm_ceil_d,                               // llvm.nvvm.ceil.d
+    nvvm_ceil_f,                               // llvm.nvvm.ceil.f
+    nvvm_ceil_ftz_f,                           // llvm.nvvm.ceil.ftz.f
+    nvvm_compiler_error,                       // llvm.nvvm.compiler.error
+    nvvm_compiler_warn,                        // llvm.nvvm.compiler.warn
+    nvvm_cos_approx_f,                         // llvm.nvvm.cos.approx.f
+    nvvm_cos_approx_ftz_f,                     // llvm.nvvm.cos.approx.ftz.f
+    nvvm_d2f_rm,                               // llvm.nvvm.d2f.rm
+    nvvm_d2f_rm_ftz,                           // llvm.nvvm.d2f.rm.ftz
+    nvvm_d2f_rn,                               // llvm.nvvm.d2f.rn
+    nvvm_d2f_rn_ftz,                           // llvm.nvvm.d2f.rn.ftz
+    nvvm_d2f_rp,                               // llvm.nvvm.d2f.rp
+    nvvm_d2f_rp_ftz,                           // llvm.nvvm.d2f.rp.ftz
+    nvvm_d2f_rz,                               // llvm.nvvm.d2f.rz
+    nvvm_d2f_rz_ftz,                           // llvm.nvvm.d2f.rz.ftz
+    nvvm_d2i_hi,                               // llvm.nvvm.d2i.hi
+    nvvm_d2i_lo,                               // llvm.nvvm.d2i.lo
+    nvvm_d2i_rm,                               // llvm.nvvm.d2i.rm
+    nvvm_d2i_rn,                               // llvm.nvvm.d2i.rn
+    nvvm_d2i_rp,                               // llvm.nvvm.d2i.rp
+    nvvm_d2i_rz,                               // llvm.nvvm.d2i.rz
+    nvvm_d2ll_rm,                              // llvm.nvvm.d2ll.rm
+    nvvm_d2ll_rn,                              // llvm.nvvm.d2ll.rn
+    nvvm_d2ll_rp,                              // llvm.nvvm.d2ll.rp
+    nvvm_d2ll_rz,                              // llvm.nvvm.d2ll.rz
+    nvvm_d2ui_rm,                              // llvm.nvvm.d2ui.rm
+    nvvm_d2ui_rn,                              // llvm.nvvm.d2ui.rn
+    nvvm_d2ui_rp,                              // llvm.nvvm.d2ui.rp
+    nvvm_d2ui_rz,                              // llvm.nvvm.d2ui.rz
+    nvvm_d2ull_rm,                             // llvm.nvvm.d2ull.rm
+    nvvm_d2ull_rn,                             // llvm.nvvm.d2ull.rn
+    nvvm_d2ull_rp,                             // llvm.nvvm.d2ull.rp
+    nvvm_d2ull_rz,                             // llvm.nvvm.d2ull.rz
+    nvvm_div_approx_f,                         // llvm.nvvm.div.approx.f
+    nvvm_div_approx_ftz_f,                     // llvm.nvvm.div.approx.ftz.f
+    nvvm_div_rm_d,                             // llvm.nvvm.div.rm.d
+    nvvm_div_rm_f,                             // llvm.nvvm.div.rm.f
+    nvvm_div_rm_ftz_f,                         // llvm.nvvm.div.rm.ftz.f
+    nvvm_div_rn_d,                             // llvm.nvvm.div.rn.d
+    nvvm_div_rn_f,                             // llvm.nvvm.div.rn.f
+    nvvm_div_rn_ftz_f,                         // llvm.nvvm.div.rn.ftz.f
+    nvvm_div_rp_d,                             // llvm.nvvm.div.rp.d
+    nvvm_div_rp_f,                             // llvm.nvvm.div.rp.f
+    nvvm_div_rp_ftz_f,                         // llvm.nvvm.div.rp.ftz.f
+    nvvm_div_rz_d,                             // llvm.nvvm.div.rz.d
+    nvvm_div_rz_f,                             // llvm.nvvm.div.rz.f
+    nvvm_div_rz_ftz_f,                         // llvm.nvvm.div.rz.ftz.f
+    nvvm_ex2_approx_d,                         // llvm.nvvm.ex2.approx.d
+    nvvm_ex2_approx_f,                         // llvm.nvvm.ex2.approx.f
+    nvvm_ex2_approx_ftz_f,                     // llvm.nvvm.ex2.approx.ftz.f
+    nvvm_f2h_rn,                               // llvm.nvvm.f2h.rn
+    nvvm_f2h_rn_ftz,                           // llvm.nvvm.f2h.rn.ftz
+    nvvm_f2i_rm,                               // llvm.nvvm.f2i.rm
+    nvvm_f2i_rm_ftz,                           // llvm.nvvm.f2i.rm.ftz
+    nvvm_f2i_rn,                               // llvm.nvvm.f2i.rn
+    nvvm_f2i_rn_ftz,                           // llvm.nvvm.f2i.rn.ftz
+    nvvm_f2i_rp,                               // llvm.nvvm.f2i.rp
+    nvvm_f2i_rp_ftz,                           // llvm.nvvm.f2i.rp.ftz
+    nvvm_f2i_rz,                               // llvm.nvvm.f2i.rz
+    nvvm_f2i_rz_ftz,                           // llvm.nvvm.f2i.rz.ftz
+    nvvm_f2ll_rm,                              // llvm.nvvm.f2ll.rm
+    nvvm_f2ll_rm_ftz,                          // llvm.nvvm.f2ll.rm.ftz
+    nvvm_f2ll_rn,                              // llvm.nvvm.f2ll.rn
+    nvvm_f2ll_rn_ftz,                          // llvm.nvvm.f2ll.rn.ftz
+    nvvm_f2ll_rp,                              // llvm.nvvm.f2ll.rp
+    nvvm_f2ll_rp_ftz,                          // llvm.nvvm.f2ll.rp.ftz
+    nvvm_f2ll_rz,                              // llvm.nvvm.f2ll.rz
+    nvvm_f2ll_rz_ftz,                          // llvm.nvvm.f2ll.rz.ftz
+    nvvm_f2ui_rm,                              // llvm.nvvm.f2ui.rm
+    nvvm_f2ui_rm_ftz,                          // llvm.nvvm.f2ui.rm.ftz
+    nvvm_f2ui_rn,                              // llvm.nvvm.f2ui.rn
+    nvvm_f2ui_rn_ftz,                          // llvm.nvvm.f2ui.rn.ftz
+    nvvm_f2ui_rp,                              // llvm.nvvm.f2ui.rp
+    nvvm_f2ui_rp_ftz,                          // llvm.nvvm.f2ui.rp.ftz
+    nvvm_f2ui_rz,                              // llvm.nvvm.f2ui.rz
+    nvvm_f2ui_rz_ftz,                          // llvm.nvvm.f2ui.rz.ftz
+    nvvm_f2ull_rm,                             // llvm.nvvm.f2ull.rm
+    nvvm_f2ull_rm_ftz,                         // llvm.nvvm.f2ull.rm.ftz
+    nvvm_f2ull_rn,                             // llvm.nvvm.f2ull.rn
+    nvvm_f2ull_rn_ftz,                         // llvm.nvvm.f2ull.rn.ftz
+    nvvm_f2ull_rp,                             // llvm.nvvm.f2ull.rp
+    nvvm_f2ull_rp_ftz,                         // llvm.nvvm.f2ull.rp.ftz
+    nvvm_f2ull_rz,                             // llvm.nvvm.f2ull.rz
+    nvvm_f2ull_rz_ftz,                         // llvm.nvvm.f2ull.rz.ftz
+    nvvm_fabs_d,                               // llvm.nvvm.fabs.d
+    nvvm_fabs_f,                               // llvm.nvvm.fabs.f
+    nvvm_fabs_ftz_f,                           // llvm.nvvm.fabs.ftz.f
+    nvvm_floor_d,                              // llvm.nvvm.floor.d
+    nvvm_floor_f,                              // llvm.nvvm.floor.f
+    nvvm_floor_ftz_f,                          // llvm.nvvm.floor.ftz.f
+    nvvm_fma_rm_d,                             // llvm.nvvm.fma.rm.d
+    nvvm_fma_rm_f,                             // llvm.nvvm.fma.rm.f
+    nvvm_fma_rm_ftz_f,                         // llvm.nvvm.fma.rm.ftz.f
+    nvvm_fma_rn_d,                             // llvm.nvvm.fma.rn.d
+    nvvm_fma_rn_f,                             // llvm.nvvm.fma.rn.f
+    nvvm_fma_rn_ftz_f,                         // llvm.nvvm.fma.rn.ftz.f
+    nvvm_fma_rp_d,                             // llvm.nvvm.fma.rp.d
+    nvvm_fma_rp_f,                             // llvm.nvvm.fma.rp.f
+    nvvm_fma_rp_ftz_f,                         // llvm.nvvm.fma.rp.ftz.f
+    nvvm_fma_rz_d,                             // llvm.nvvm.fma.rz.d
+    nvvm_fma_rz_f,                             // llvm.nvvm.fma.rz.f
+    nvvm_fma_rz_ftz_f,                         // llvm.nvvm.fma.rz.ftz.f
+    nvvm_fmax_d,                               // llvm.nvvm.fmax.d
+    nvvm_fmax_f,                               // llvm.nvvm.fmax.f
+    nvvm_fmax_ftz_f,                           // llvm.nvvm.fmax.ftz.f
+    nvvm_fmin_d,                               // llvm.nvvm.fmin.d
+    nvvm_fmin_f,                               // llvm.nvvm.fmin.f
+    nvvm_fmin_ftz_f,                           // llvm.nvvm.fmin.ftz.f
+    nvvm_fns,                                  // llvm.nvvm.fns
+    nvvm_i2d_rm,                               // llvm.nvvm.i2d.rm
+    nvvm_i2d_rn,                               // llvm.nvvm.i2d.rn
+    nvvm_i2d_rp,                               // llvm.nvvm.i2d.rp
+    nvvm_i2d_rz,                               // llvm.nvvm.i2d.rz
+    nvvm_i2f_rm,                               // llvm.nvvm.i2f.rm
+    nvvm_i2f_rn,                               // llvm.nvvm.i2f.rn
+    nvvm_i2f_rp,                               // llvm.nvvm.i2f.rp
+    nvvm_i2f_rz,                               // llvm.nvvm.i2f.rz
+    nvvm_isspacep_const,                       // llvm.nvvm.isspacep.const
+    nvvm_isspacep_global,                      // llvm.nvvm.isspacep.global
+    nvvm_isspacep_local,                       // llvm.nvvm.isspacep.local
+    nvvm_isspacep_shared,                      // llvm.nvvm.isspacep.shared
+    nvvm_istypep_sampler,                      // llvm.nvvm.istypep.sampler
+    nvvm_istypep_surface,                      // llvm.nvvm.istypep.surface
+    nvvm_istypep_texture,                      // llvm.nvvm.istypep.texture
+    nvvm_ldg_global_f,                         // llvm.nvvm.ldg.global.f
+    nvvm_ldg_global_i,                         // llvm.nvvm.ldg.global.i
+    nvvm_ldg_global_p,                         // llvm.nvvm.ldg.global.p
+    nvvm_ldu_global_f,                         // llvm.nvvm.ldu.global.f
+    nvvm_ldu_global_i,                         // llvm.nvvm.ldu.global.i
+    nvvm_ldu_global_p,                         // llvm.nvvm.ldu.global.p
+    nvvm_lg2_approx_d,                         // llvm.nvvm.lg2.approx.d
+    nvvm_lg2_approx_f,                         // llvm.nvvm.lg2.approx.f
+    nvvm_lg2_approx_ftz_f,                     // llvm.nvvm.lg2.approx.ftz.f
+    nvvm_ll2d_rm,                              // llvm.nvvm.ll2d.rm
+    nvvm_ll2d_rn,                              // llvm.nvvm.ll2d.rn
+    nvvm_ll2d_rp,                              // llvm.nvvm.ll2d.rp
+    nvvm_ll2d_rz,                              // llvm.nvvm.ll2d.rz
+    nvvm_ll2f_rm,                              // llvm.nvvm.ll2f.rm
+    nvvm_ll2f_rn,                              // llvm.nvvm.ll2f.rn
+    nvvm_ll2f_rp,                              // llvm.nvvm.ll2f.rp
+    nvvm_ll2f_rz,                              // llvm.nvvm.ll2f.rz
+    nvvm_lohi_i2d,                             // llvm.nvvm.lohi.i2d
+    nvvm_match_all_sync_i32p,                  // llvm.nvvm.match.all.sync.i32p
+    nvvm_match_all_sync_i64p,                  // llvm.nvvm.match.all.sync.i64p
+    nvvm_match_any_sync_i32,                   // llvm.nvvm.match.any.sync.i32
+    nvvm_match_any_sync_i64,                   // llvm.nvvm.match.any.sync.i64
+    nvvm_membar_cta,                           // llvm.nvvm.membar.cta
+    nvvm_membar_gl,                            // llvm.nvvm.membar.gl
+    nvvm_membar_sys,                           // llvm.nvvm.membar.sys
+    nvvm_mma_m8n8k4_col_col_f16_f16,           // llvm.nvvm.mma.m8n8k4.col.col.f16.f16
+    nvvm_mma_m8n8k4_col_col_f32_f16,           // llvm.nvvm.mma.m8n8k4.col.col.f32.f16
+    nvvm_mma_m8n8k4_col_col_f32_f32,           // llvm.nvvm.mma.m8n8k4.col.col.f32.f32
+    nvvm_mma_m8n8k4_col_row_f16_f16,           // llvm.nvvm.mma.m8n8k4.col.row.f16.f16
+    nvvm_mma_m8n8k4_col_row_f32_f16,           // llvm.nvvm.mma.m8n8k4.col.row.f32.f16
+    nvvm_mma_m8n8k4_col_row_f32_f32,           // llvm.nvvm.mma.m8n8k4.col.row.f32.f32
+    nvvm_mma_m8n8k4_row_col_f16_f16,           // llvm.nvvm.mma.m8n8k4.row.col.f16.f16
+    nvvm_mma_m8n8k4_row_col_f32_f16,           // llvm.nvvm.mma.m8n8k4.row.col.f32.f16
+    nvvm_mma_m8n8k4_row_col_f32_f32,           // llvm.nvvm.mma.m8n8k4.row.col.f32.f32
+    nvvm_mma_m8n8k4_row_row_f16_f16,           // llvm.nvvm.mma.m8n8k4.row.row.f16.f16
+    nvvm_mma_m8n8k4_row_row_f32_f16,           // llvm.nvvm.mma.m8n8k4.row.row.f32.f16
+    nvvm_mma_m8n8k4_row_row_f32_f32,           // llvm.nvvm.mma.m8n8k4.row.row.f32.f32
+    nvvm_move_double,                          // llvm.nvvm.move.double
+    nvvm_move_float,                           // llvm.nvvm.move.float
+    nvvm_move_i16,                             // llvm.nvvm.move.i16
+    nvvm_move_i32,                             // llvm.nvvm.move.i32
+    nvvm_move_i64,                             // llvm.nvvm.move.i64
+    nvvm_move_ptr,                             // llvm.nvvm.move.ptr
+    nvvm_mul_rm_d,                             // llvm.nvvm.mul.rm.d
+    nvvm_mul_rm_f,                             // llvm.nvvm.mul.rm.f
+    nvvm_mul_rm_ftz_f,                         // llvm.nvvm.mul.rm.ftz.f
+    nvvm_mul_rn_d,                             // llvm.nvvm.mul.rn.d
+    nvvm_mul_rn_f,                             // llvm.nvvm.mul.rn.f
+    nvvm_mul_rn_ftz_f,                         // llvm.nvvm.mul.rn.ftz.f
+    nvvm_mul_rp_d,                             // llvm.nvvm.mul.rp.d
+    nvvm_mul_rp_f,                             // llvm.nvvm.mul.rp.f
+    nvvm_mul_rp_ftz_f,                         // llvm.nvvm.mul.rp.ftz.f
+    nvvm_mul_rz_d,                             // llvm.nvvm.mul.rz.d
+    nvvm_mul_rz_f,                             // llvm.nvvm.mul.rz.f
+    nvvm_mul_rz_ftz_f,                         // llvm.nvvm.mul.rz.ftz.f
+    nvvm_mul24_i,                              // llvm.nvvm.mul24.i
+    nvvm_mul24_ui,                             // llvm.nvvm.mul24.ui
+    nvvm_mulhi_i,                              // llvm.nvvm.mulhi.i
+    nvvm_mulhi_ll,                             // llvm.nvvm.mulhi.ll
+    nvvm_mulhi_ui,                             // llvm.nvvm.mulhi.ui
+    nvvm_mulhi_ull,                            // llvm.nvvm.mulhi.ull
+    nvvm_prmt,                                 // llvm.nvvm.prmt
+    nvvm_ptr_constant_to_gen,                  // llvm.nvvm.ptr.constant.to.gen
+    nvvm_ptr_gen_to_constant,                  // llvm.nvvm.ptr.gen.to.constant
+    nvvm_ptr_gen_to_global,                    // llvm.nvvm.ptr.gen.to.global
+    nvvm_ptr_gen_to_local,                     // llvm.nvvm.ptr.gen.to.local
+    nvvm_ptr_gen_to_param,                     // llvm.nvvm.ptr.gen.to.param
+    nvvm_ptr_gen_to_shared,                    // llvm.nvvm.ptr.gen.to.shared
+    nvvm_ptr_global_to_gen,                    // llvm.nvvm.ptr.global.to.gen
+    nvvm_ptr_local_to_gen,                     // llvm.nvvm.ptr.local.to.gen
+    nvvm_ptr_shared_to_gen,                    // llvm.nvvm.ptr.shared.to.gen
+    nvvm_rcp_approx_ftz_d,                     // llvm.nvvm.rcp.approx.ftz.d
+    nvvm_rcp_rm_d,                             // llvm.nvvm.rcp.rm.d
+    nvvm_rcp_rm_f,                             // llvm.nvvm.rcp.rm.f
+    nvvm_rcp_rm_ftz_f,                         // llvm.nvvm.rcp.rm.ftz.f
+    nvvm_rcp_rn_d,                             // llvm.nvvm.rcp.rn.d
+    nvvm_rcp_rn_f,                             // llvm.nvvm.rcp.rn.f
+    nvvm_rcp_rn_ftz_f,                         // llvm.nvvm.rcp.rn.ftz.f
+    nvvm_rcp_rp_d,                             // llvm.nvvm.rcp.rp.d
+    nvvm_rcp_rp_f,                             // llvm.nvvm.rcp.rp.f
+    nvvm_rcp_rp_ftz_f,                         // llvm.nvvm.rcp.rp.ftz.f
+    nvvm_rcp_rz_d,                             // llvm.nvvm.rcp.rz.d
+    nvvm_rcp_rz_f,                             // llvm.nvvm.rcp.rz.f
+    nvvm_rcp_rz_ftz_f,                         // llvm.nvvm.rcp.rz.ftz.f
+    nvvm_read_ptx_sreg_clock,                  // llvm.nvvm.read.ptx.sreg.clock
+    nvvm_read_ptx_sreg_clock64,                // llvm.nvvm.read.ptx.sreg.clock64
+    nvvm_read_ptx_sreg_ctaid_w,                // llvm.nvvm.read.ptx.sreg.ctaid.w
+    nvvm_read_ptx_sreg_ctaid_x,                // llvm.nvvm.read.ptx.sreg.ctaid.x
+    nvvm_read_ptx_sreg_ctaid_y,                // llvm.nvvm.read.ptx.sreg.ctaid.y
+    nvvm_read_ptx_sreg_ctaid_z,                // llvm.nvvm.read.ptx.sreg.ctaid.z
+    nvvm_read_ptx_sreg_envreg0,                // llvm.nvvm.read.ptx.sreg.envreg0
+    nvvm_read_ptx_sreg_envreg1,                // llvm.nvvm.read.ptx.sreg.envreg1
+    nvvm_read_ptx_sreg_envreg10,               // llvm.nvvm.read.ptx.sreg.envreg10
+    nvvm_read_ptx_sreg_envreg11,               // llvm.nvvm.read.ptx.sreg.envreg11
+    nvvm_read_ptx_sreg_envreg12,               // llvm.nvvm.read.ptx.sreg.envreg12
+    nvvm_read_ptx_sreg_envreg13,               // llvm.nvvm.read.ptx.sreg.envreg13
+    nvvm_read_ptx_sreg_envreg14,               // llvm.nvvm.read.ptx.sreg.envreg14
+    nvvm_read_ptx_sreg_envreg15,               // llvm.nvvm.read.ptx.sreg.envreg15
+    nvvm_read_ptx_sreg_envreg16,               // llvm.nvvm.read.ptx.sreg.envreg16
+    nvvm_read_ptx_sreg_envreg17,               // llvm.nvvm.read.ptx.sreg.envreg17
+    nvvm_read_ptx_sreg_envreg18,               // llvm.nvvm.read.ptx.sreg.envreg18
+    nvvm_read_ptx_sreg_envreg19,               // llvm.nvvm.read.ptx.sreg.envreg19
+    nvvm_read_ptx_sreg_envreg2,                // llvm.nvvm.read.ptx.sreg.envreg2
+    nvvm_read_ptx_sreg_envreg20,               // llvm.nvvm.read.ptx.sreg.envreg20
+    nvvm_read_ptx_sreg_envreg21,               // llvm.nvvm.read.ptx.sreg.envreg21
+    nvvm_read_ptx_sreg_envreg22,               // llvm.nvvm.read.ptx.sreg.envreg22
+    nvvm_read_ptx_sreg_envreg23,               // llvm.nvvm.read.ptx.sreg.envreg23
+    nvvm_read_ptx_sreg_envreg24,               // llvm.nvvm.read.ptx.sreg.envreg24
+    nvvm_read_ptx_sreg_envreg25,               // llvm.nvvm.read.ptx.sreg.envreg25
+    nvvm_read_ptx_sreg_envreg26,               // llvm.nvvm.read.ptx.sreg.envreg26
+    nvvm_read_ptx_sreg_envreg27,               // llvm.nvvm.read.ptx.sreg.envreg27
+    nvvm_read_ptx_sreg_envreg28,               // llvm.nvvm.read.ptx.sreg.envreg28
+    nvvm_read_ptx_sreg_envreg29,               // llvm.nvvm.read.ptx.sreg.envreg29
+    nvvm_read_ptx_sreg_envreg3,                // llvm.nvvm.read.ptx.sreg.envreg3
+    nvvm_read_ptx_sreg_envreg30,               // llvm.nvvm.read.ptx.sreg.envreg30
+    nvvm_read_ptx_sreg_envreg31,               // llvm.nvvm.read.ptx.sreg.envreg31
+    nvvm_read_ptx_sreg_envreg4,                // llvm.nvvm.read.ptx.sreg.envreg4
+    nvvm_read_ptx_sreg_envreg5,                // llvm.nvvm.read.ptx.sreg.envreg5
+    nvvm_read_ptx_sreg_envreg6,                // llvm.nvvm.read.ptx.sreg.envreg6
+    nvvm_read_ptx_sreg_envreg7,                // llvm.nvvm.read.ptx.sreg.envreg7
+    nvvm_read_ptx_sreg_envreg8,                // llvm.nvvm.read.ptx.sreg.envreg8
+    nvvm_read_ptx_sreg_envreg9,                // llvm.nvvm.read.ptx.sreg.envreg9
+    nvvm_read_ptx_sreg_gridid,                 // llvm.nvvm.read.ptx.sreg.gridid
+    nvvm_read_ptx_sreg_laneid,                 // llvm.nvvm.read.ptx.sreg.laneid
+    nvvm_read_ptx_sreg_lanemask_eq,            // llvm.nvvm.read.ptx.sreg.lanemask.eq
+    nvvm_read_ptx_sreg_lanemask_ge,            // llvm.nvvm.read.ptx.sreg.lanemask.ge
+    nvvm_read_ptx_sreg_lanemask_gt,            // llvm.nvvm.read.ptx.sreg.lanemask.gt
+    nvvm_read_ptx_sreg_lanemask_le,            // llvm.nvvm.read.ptx.sreg.lanemask.le
+    nvvm_read_ptx_sreg_lanemask_lt,            // llvm.nvvm.read.ptx.sreg.lanemask.lt
+    nvvm_read_ptx_sreg_nctaid_w,               // llvm.nvvm.read.ptx.sreg.nctaid.w
+    nvvm_read_ptx_sreg_nctaid_x,               // llvm.nvvm.read.ptx.sreg.nctaid.x
+    nvvm_read_ptx_sreg_nctaid_y,               // llvm.nvvm.read.ptx.sreg.nctaid.y
+    nvvm_read_ptx_sreg_nctaid_z,               // llvm.nvvm.read.ptx.sreg.nctaid.z
+    nvvm_read_ptx_sreg_nsmid,                  // llvm.nvvm.read.ptx.sreg.nsmid
+    nvvm_read_ptx_sreg_ntid_w,                 // llvm.nvvm.read.ptx.sreg.ntid.w
+    nvvm_read_ptx_sreg_ntid_x,                 // llvm.nvvm.read.ptx.sreg.ntid.x
+    nvvm_read_ptx_sreg_ntid_y,                 // llvm.nvvm.read.ptx.sreg.ntid.y
+    nvvm_read_ptx_sreg_ntid_z,                 // llvm.nvvm.read.ptx.sreg.ntid.z
+    nvvm_read_ptx_sreg_nwarpid,                // llvm.nvvm.read.ptx.sreg.nwarpid
+    nvvm_read_ptx_sreg_pm0,                    // llvm.nvvm.read.ptx.sreg.pm0
+    nvvm_read_ptx_sreg_pm1,                    // llvm.nvvm.read.ptx.sreg.pm1
+    nvvm_read_ptx_sreg_pm2,                    // llvm.nvvm.read.ptx.sreg.pm2
+    nvvm_read_ptx_sreg_pm3,                    // llvm.nvvm.read.ptx.sreg.pm3
+    nvvm_read_ptx_sreg_smid,                   // llvm.nvvm.read.ptx.sreg.smid
+    nvvm_read_ptx_sreg_tid_w,                  // llvm.nvvm.read.ptx.sreg.tid.w
+    nvvm_read_ptx_sreg_tid_x,                  // llvm.nvvm.read.ptx.sreg.tid.x
+    nvvm_read_ptx_sreg_tid_y,                  // llvm.nvvm.read.ptx.sreg.tid.y
+    nvvm_read_ptx_sreg_tid_z,                  // llvm.nvvm.read.ptx.sreg.tid.z
+    nvvm_read_ptx_sreg_warpid,                 // llvm.nvvm.read.ptx.sreg.warpid
+    nvvm_read_ptx_sreg_warpsize,               // llvm.nvvm.read.ptx.sreg.warpsize
+    nvvm_reflect,                              // llvm.nvvm.reflect
+    nvvm_rotate_b32,                           // llvm.nvvm.rotate.b32
+    nvvm_rotate_b64,                           // llvm.nvvm.rotate.b64
+    nvvm_rotate_right_b64,                     // llvm.nvvm.rotate.right.b64
+    nvvm_round_d,                              // llvm.nvvm.round.d
+    nvvm_round_f,                              // llvm.nvvm.round.f
+    nvvm_round_ftz_f,                          // llvm.nvvm.round.ftz.f
+    nvvm_rsqrt_approx_d,                       // llvm.nvvm.rsqrt.approx.d
+    nvvm_rsqrt_approx_f,                       // llvm.nvvm.rsqrt.approx.f
+    nvvm_rsqrt_approx_ftz_f,                   // llvm.nvvm.rsqrt.approx.ftz.f
+    nvvm_sad_i,                                // llvm.nvvm.sad.i
+    nvvm_sad_ui,                               // llvm.nvvm.sad.ui
+    nvvm_saturate_d,                           // llvm.nvvm.saturate.d
+    nvvm_saturate_f,                           // llvm.nvvm.saturate.f
+    nvvm_saturate_ftz_f,                       // llvm.nvvm.saturate.ftz.f
+    nvvm_shfl_bfly_f32,                        // llvm.nvvm.shfl.bfly.f32
+    nvvm_shfl_bfly_f32p,                       // llvm.nvvm.shfl.bfly.f32p
+    nvvm_shfl_bfly_i32,                        // llvm.nvvm.shfl.bfly.i32
+    nvvm_shfl_bfly_i32p,                       // llvm.nvvm.shfl.bfly.i32p
+    nvvm_shfl_down_f32,                        // llvm.nvvm.shfl.down.f32
+    nvvm_shfl_down_f32p,                       // llvm.nvvm.shfl.down.f32p
+    nvvm_shfl_down_i32,                        // llvm.nvvm.shfl.down.i32
+    nvvm_shfl_down_i32p,                       // llvm.nvvm.shfl.down.i32p
+    nvvm_shfl_idx_f32,                         // llvm.nvvm.shfl.idx.f32
+    nvvm_shfl_idx_f32p,                        // llvm.nvvm.shfl.idx.f32p
+    nvvm_shfl_idx_i32,                         // llvm.nvvm.shfl.idx.i32
+    nvvm_shfl_idx_i32p,                        // llvm.nvvm.shfl.idx.i32p
+    nvvm_shfl_sync_bfly_f32,                   // llvm.nvvm.shfl.sync.bfly.f32
+    nvvm_shfl_sync_bfly_f32p,                  // llvm.nvvm.shfl.sync.bfly.f32p
+    nvvm_shfl_sync_bfly_i32,                   // llvm.nvvm.shfl.sync.bfly.i32
+    nvvm_shfl_sync_bfly_i32p,                  // llvm.nvvm.shfl.sync.bfly.i32p
+    nvvm_shfl_sync_down_f32,                   // llvm.nvvm.shfl.sync.down.f32
+    nvvm_shfl_sync_down_f32p,                  // llvm.nvvm.shfl.sync.down.f32p
+    nvvm_shfl_sync_down_i32,                   // llvm.nvvm.shfl.sync.down.i32
+    nvvm_shfl_sync_down_i32p,                  // llvm.nvvm.shfl.sync.down.i32p
+    nvvm_shfl_sync_idx_f32,                    // llvm.nvvm.shfl.sync.idx.f32
+    nvvm_shfl_sync_idx_f32p,                   // llvm.nvvm.shfl.sync.idx.f32p
+    nvvm_shfl_sync_idx_i32,                    // llvm.nvvm.shfl.sync.idx.i32
+    nvvm_shfl_sync_idx_i32p,                   // llvm.nvvm.shfl.sync.idx.i32p
+    nvvm_shfl_sync_up_f32,                     // llvm.nvvm.shfl.sync.up.f32
+    nvvm_shfl_sync_up_f32p,                    // llvm.nvvm.shfl.sync.up.f32p
+    nvvm_shfl_sync_up_i32,                     // llvm.nvvm.shfl.sync.up.i32
+    nvvm_shfl_sync_up_i32p,                    // llvm.nvvm.shfl.sync.up.i32p
+    nvvm_shfl_up_f32,                          // llvm.nvvm.shfl.up.f32
+    nvvm_shfl_up_f32p,                         // llvm.nvvm.shfl.up.f32p
+    nvvm_shfl_up_i32,                          // llvm.nvvm.shfl.up.i32
+    nvvm_shfl_up_i32p,                         // llvm.nvvm.shfl.up.i32p
+    nvvm_sin_approx_f,                         // llvm.nvvm.sin.approx.f
+    nvvm_sin_approx_ftz_f,                     // llvm.nvvm.sin.approx.ftz.f
+    nvvm_sqrt_approx_f,                        // llvm.nvvm.sqrt.approx.f
+    nvvm_sqrt_approx_ftz_f,                    // llvm.nvvm.sqrt.approx.ftz.f
+    nvvm_sqrt_f,                               // llvm.nvvm.sqrt.f
+    nvvm_sqrt_rm_d,                            // llvm.nvvm.sqrt.rm.d
+    nvvm_sqrt_rm_f,                            // llvm.nvvm.sqrt.rm.f
+    nvvm_sqrt_rm_ftz_f,                        // llvm.nvvm.sqrt.rm.ftz.f
+    nvvm_sqrt_rn_d,                            // llvm.nvvm.sqrt.rn.d
+    nvvm_sqrt_rn_f,                            // llvm.nvvm.sqrt.rn.f
+    nvvm_sqrt_rn_ftz_f,                        // llvm.nvvm.sqrt.rn.ftz.f
+    nvvm_sqrt_rp_d,                            // llvm.nvvm.sqrt.rp.d
+    nvvm_sqrt_rp_f,                            // llvm.nvvm.sqrt.rp.f
+    nvvm_sqrt_rp_ftz_f,                        // llvm.nvvm.sqrt.rp.ftz.f
+    nvvm_sqrt_rz_d,                            // llvm.nvvm.sqrt.rz.d
+    nvvm_sqrt_rz_f,                            // llvm.nvvm.sqrt.rz.f
+    nvvm_sqrt_rz_ftz_f,                        // llvm.nvvm.sqrt.rz.ftz.f
+    nvvm_suld_1d_array_i16_clamp,              // llvm.nvvm.suld.1d.array.i16.clamp
+    nvvm_suld_1d_array_i16_trap,               // llvm.nvvm.suld.1d.array.i16.trap
+    nvvm_suld_1d_array_i16_zero,               // llvm.nvvm.suld.1d.array.i16.zero
+    nvvm_suld_1d_array_i32_clamp,              // llvm.nvvm.suld.1d.array.i32.clamp
+    nvvm_suld_1d_array_i32_trap,               // llvm.nvvm.suld.1d.array.i32.trap
+    nvvm_suld_1d_array_i32_zero,               // llvm.nvvm.suld.1d.array.i32.zero
+    nvvm_suld_1d_array_i64_clamp,              // llvm.nvvm.suld.1d.array.i64.clamp
+    nvvm_suld_1d_array_i64_trap,               // llvm.nvvm.suld.1d.array.i64.trap
+    nvvm_suld_1d_array_i64_zero,               // llvm.nvvm.suld.1d.array.i64.zero
+    nvvm_suld_1d_array_i8_clamp,               // llvm.nvvm.suld.1d.array.i8.clamp
+    nvvm_suld_1d_array_i8_trap,                // llvm.nvvm.suld.1d.array.i8.trap
+    nvvm_suld_1d_array_i8_zero,                // llvm.nvvm.suld.1d.array.i8.zero
+    nvvm_suld_1d_array_v2i16_clamp,            // llvm.nvvm.suld.1d.array.v2i16.clamp
+    nvvm_suld_1d_array_v2i16_trap,             // llvm.nvvm.suld.1d.array.v2i16.trap
+    nvvm_suld_1d_array_v2i16_zero,             // llvm.nvvm.suld.1d.array.v2i16.zero
+    nvvm_suld_1d_array_v2i32_clamp,            // llvm.nvvm.suld.1d.array.v2i32.clamp
+    nvvm_suld_1d_array_v2i32_trap,             // llvm.nvvm.suld.1d.array.v2i32.trap
+    nvvm_suld_1d_array_v2i32_zero,             // llvm.nvvm.suld.1d.array.v2i32.zero
+    nvvm_suld_1d_array_v2i64_clamp,            // llvm.nvvm.suld.1d.array.v2i64.clamp
+    nvvm_suld_1d_array_v2i64_trap,             // llvm.nvvm.suld.1d.array.v2i64.trap
+    nvvm_suld_1d_array_v2i64_zero,             // llvm.nvvm.suld.1d.array.v2i64.zero
+    nvvm_suld_1d_array_v2i8_clamp,             // llvm.nvvm.suld.1d.array.v2i8.clamp
+    nvvm_suld_1d_array_v2i8_trap,              // llvm.nvvm.suld.1d.array.v2i8.trap
+    nvvm_suld_1d_array_v2i8_zero,              // llvm.nvvm.suld.1d.array.v2i8.zero
+    nvvm_suld_1d_array_v4i16_clamp,            // llvm.nvvm.suld.1d.array.v4i16.clamp
+    nvvm_suld_1d_array_v4i16_trap,             // llvm.nvvm.suld.1d.array.v4i16.trap
+    nvvm_suld_1d_array_v4i16_zero,             // llvm.nvvm.suld.1d.array.v4i16.zero
+    nvvm_suld_1d_array_v4i32_clamp,            // llvm.nvvm.suld.1d.array.v4i32.clamp
+    nvvm_suld_1d_array_v4i32_trap,             // llvm.nvvm.suld.1d.array.v4i32.trap
+    nvvm_suld_1d_array_v4i32_zero,             // llvm.nvvm.suld.1d.array.v4i32.zero
+    nvvm_suld_1d_array_v4i8_clamp,             // llvm.nvvm.suld.1d.array.v4i8.clamp
+    nvvm_suld_1d_array_v4i8_trap,              // llvm.nvvm.suld.1d.array.v4i8.trap
+    nvvm_suld_1d_array_v4i8_zero,              // llvm.nvvm.suld.1d.array.v4i8.zero
+    nvvm_suld_1d_i16_clamp,                    // llvm.nvvm.suld.1d.i16.clamp
+    nvvm_suld_1d_i16_trap,                     // llvm.nvvm.suld.1d.i16.trap
+    nvvm_suld_1d_i16_zero,                     // llvm.nvvm.suld.1d.i16.zero
+    nvvm_suld_1d_i32_clamp,                    // llvm.nvvm.suld.1d.i32.clamp
+    nvvm_suld_1d_i32_trap,                     // llvm.nvvm.suld.1d.i32.trap
+    nvvm_suld_1d_i32_zero,                     // llvm.nvvm.suld.1d.i32.zero
+    nvvm_suld_1d_i64_clamp,                    // llvm.nvvm.suld.1d.i64.clamp
+    nvvm_suld_1d_i64_trap,                     // llvm.nvvm.suld.1d.i64.trap
+    nvvm_suld_1d_i64_zero,                     // llvm.nvvm.suld.1d.i64.zero
+    nvvm_suld_1d_i8_clamp,                     // llvm.nvvm.suld.1d.i8.clamp
+    nvvm_suld_1d_i8_trap,                      // llvm.nvvm.suld.1d.i8.trap
+    nvvm_suld_1d_i8_zero,                      // llvm.nvvm.suld.1d.i8.zero
+    nvvm_suld_1d_v2i16_clamp,                  // llvm.nvvm.suld.1d.v2i16.clamp
+    nvvm_suld_1d_v2i16_trap,                   // llvm.nvvm.suld.1d.v2i16.trap
+    nvvm_suld_1d_v2i16_zero,                   // llvm.nvvm.suld.1d.v2i16.zero
+    nvvm_suld_1d_v2i32_clamp,                  // llvm.nvvm.suld.1d.v2i32.clamp
+    nvvm_suld_1d_v2i32_trap,                   // llvm.nvvm.suld.1d.v2i32.trap
+    nvvm_suld_1d_v2i32_zero,                   // llvm.nvvm.suld.1d.v2i32.zero
+    nvvm_suld_1d_v2i64_clamp,                  // llvm.nvvm.suld.1d.v2i64.clamp
+    nvvm_suld_1d_v2i64_trap,                   // llvm.nvvm.suld.1d.v2i64.trap
+    nvvm_suld_1d_v2i64_zero,                   // llvm.nvvm.suld.1d.v2i64.zero
+    nvvm_suld_1d_v2i8_clamp,                   // llvm.nvvm.suld.1d.v2i8.clamp
+    nvvm_suld_1d_v2i8_trap,                    // llvm.nvvm.suld.1d.v2i8.trap
+    nvvm_suld_1d_v2i8_zero,                    // llvm.nvvm.suld.1d.v2i8.zero
+    nvvm_suld_1d_v4i16_clamp,                  // llvm.nvvm.suld.1d.v4i16.clamp
+    nvvm_suld_1d_v4i16_trap,                   // llvm.nvvm.suld.1d.v4i16.trap
+    nvvm_suld_1d_v4i16_zero,                   // llvm.nvvm.suld.1d.v4i16.zero
+    nvvm_suld_1d_v4i32_clamp,                  // llvm.nvvm.suld.1d.v4i32.clamp
+    nvvm_suld_1d_v4i32_trap,                   // llvm.nvvm.suld.1d.v4i32.trap
+    nvvm_suld_1d_v4i32_zero,                   // llvm.nvvm.suld.1d.v4i32.zero
+    nvvm_suld_1d_v4i8_clamp,                   // llvm.nvvm.suld.1d.v4i8.clamp
+    nvvm_suld_1d_v4i8_trap,                    // llvm.nvvm.suld.1d.v4i8.trap
+    nvvm_suld_1d_v4i8_zero,                    // llvm.nvvm.suld.1d.v4i8.zero
+    nvvm_suld_2d_array_i16_clamp,              // llvm.nvvm.suld.2d.array.i16.clamp
+    nvvm_suld_2d_array_i16_trap,               // llvm.nvvm.suld.2d.array.i16.trap
+    nvvm_suld_2d_array_i16_zero,               // llvm.nvvm.suld.2d.array.i16.zero
+    nvvm_suld_2d_array_i32_clamp,              // llvm.nvvm.suld.2d.array.i32.clamp
+    nvvm_suld_2d_array_i32_trap,               // llvm.nvvm.suld.2d.array.i32.trap
+    nvvm_suld_2d_array_i32_zero,               // llvm.nvvm.suld.2d.array.i32.zero
+    nvvm_suld_2d_array_i64_clamp,              // llvm.nvvm.suld.2d.array.i64.clamp
+    nvvm_suld_2d_array_i64_trap,               // llvm.nvvm.suld.2d.array.i64.trap
+    nvvm_suld_2d_array_i64_zero,               // llvm.nvvm.suld.2d.array.i64.zero
+    nvvm_suld_2d_array_i8_clamp,               // llvm.nvvm.suld.2d.array.i8.clamp
+    nvvm_suld_2d_array_i8_trap,                // llvm.nvvm.suld.2d.array.i8.trap
+    nvvm_suld_2d_array_i8_zero,                // llvm.nvvm.suld.2d.array.i8.zero
+    nvvm_suld_2d_array_v2i16_clamp,            // llvm.nvvm.suld.2d.array.v2i16.clamp
+    nvvm_suld_2d_array_v2i16_trap,             // llvm.nvvm.suld.2d.array.v2i16.trap
+    nvvm_suld_2d_array_v2i16_zero,             // llvm.nvvm.suld.2d.array.v2i16.zero
+    nvvm_suld_2d_array_v2i32_clamp,            // llvm.nvvm.suld.2d.array.v2i32.clamp
+    nvvm_suld_2d_array_v2i32_trap,             // llvm.nvvm.suld.2d.array.v2i32.trap
+    nvvm_suld_2d_array_v2i32_zero,             // llvm.nvvm.suld.2d.array.v2i32.zero
+    nvvm_suld_2d_array_v2i64_clamp,            // llvm.nvvm.suld.2d.array.v2i64.clamp
+    nvvm_suld_2d_array_v2i64_trap,             // llvm.nvvm.suld.2d.array.v2i64.trap
+    nvvm_suld_2d_array_v2i64_zero,             // llvm.nvvm.suld.2d.array.v2i64.zero
+    nvvm_suld_2d_array_v2i8_clamp,             // llvm.nvvm.suld.2d.array.v2i8.clamp
+    nvvm_suld_2d_array_v2i8_trap,              // llvm.nvvm.suld.2d.array.v2i8.trap
+    nvvm_suld_2d_array_v2i8_zero,              // llvm.nvvm.suld.2d.array.v2i8.zero
+    nvvm_suld_2d_array_v4i16_clamp,            // llvm.nvvm.suld.2d.array.v4i16.clamp
+    nvvm_suld_2d_array_v4i16_trap,             // llvm.nvvm.suld.2d.array.v4i16.trap
+    nvvm_suld_2d_array_v4i16_zero,             // llvm.nvvm.suld.2d.array.v4i16.zero
+    nvvm_suld_2d_array_v4i32_clamp,            // llvm.nvvm.suld.2d.array.v4i32.clamp
+    nvvm_suld_2d_array_v4i32_trap,             // llvm.nvvm.suld.2d.array.v4i32.trap
+    nvvm_suld_2d_array_v4i32_zero,             // llvm.nvvm.suld.2d.array.v4i32.zero
+    nvvm_suld_2d_array_v4i8_clamp,             // llvm.nvvm.suld.2d.array.v4i8.clamp
+    nvvm_suld_2d_array_v4i8_trap,              // llvm.nvvm.suld.2d.array.v4i8.trap
+    nvvm_suld_2d_array_v4i8_zero,              // llvm.nvvm.suld.2d.array.v4i8.zero
+    nvvm_suld_2d_i16_clamp,                    // llvm.nvvm.suld.2d.i16.clamp
+    nvvm_suld_2d_i16_trap,                     // llvm.nvvm.suld.2d.i16.trap
+    nvvm_suld_2d_i16_zero,                     // llvm.nvvm.suld.2d.i16.zero
+    nvvm_suld_2d_i32_clamp,                    // llvm.nvvm.suld.2d.i32.clamp
+    nvvm_suld_2d_i32_trap,                     // llvm.nvvm.suld.2d.i32.trap
+    nvvm_suld_2d_i32_zero,                     // llvm.nvvm.suld.2d.i32.zero
+    nvvm_suld_2d_i64_clamp,                    // llvm.nvvm.suld.2d.i64.clamp
+    nvvm_suld_2d_i64_trap,                     // llvm.nvvm.suld.2d.i64.trap
+    nvvm_suld_2d_i64_zero,                     // llvm.nvvm.suld.2d.i64.zero
+    nvvm_suld_2d_i8_clamp,                     // llvm.nvvm.suld.2d.i8.clamp
+    nvvm_suld_2d_i8_trap,                      // llvm.nvvm.suld.2d.i8.trap
+    nvvm_suld_2d_i8_zero,                      // llvm.nvvm.suld.2d.i8.zero
+    nvvm_suld_2d_v2i16_clamp,                  // llvm.nvvm.suld.2d.v2i16.clamp
+    nvvm_suld_2d_v2i16_trap,                   // llvm.nvvm.suld.2d.v2i16.trap
+    nvvm_suld_2d_v2i16_zero,                   // llvm.nvvm.suld.2d.v2i16.zero
+    nvvm_suld_2d_v2i32_clamp,                  // llvm.nvvm.suld.2d.v2i32.clamp
+    nvvm_suld_2d_v2i32_trap,                   // llvm.nvvm.suld.2d.v2i32.trap
+    nvvm_suld_2d_v2i32_zero,                   // llvm.nvvm.suld.2d.v2i32.zero
+    nvvm_suld_2d_v2i64_clamp,                  // llvm.nvvm.suld.2d.v2i64.clamp
+    nvvm_suld_2d_v2i64_trap,                   // llvm.nvvm.suld.2d.v2i64.trap
+    nvvm_suld_2d_v2i64_zero,                   // llvm.nvvm.suld.2d.v2i64.zero
+    nvvm_suld_2d_v2i8_clamp,                   // llvm.nvvm.suld.2d.v2i8.clamp
+    nvvm_suld_2d_v2i8_trap,                    // llvm.nvvm.suld.2d.v2i8.trap
+    nvvm_suld_2d_v2i8_zero,                    // llvm.nvvm.suld.2d.v2i8.zero
+    nvvm_suld_2d_v4i16_clamp,                  // llvm.nvvm.suld.2d.v4i16.clamp
+    nvvm_suld_2d_v4i16_trap,                   // llvm.nvvm.suld.2d.v4i16.trap
+    nvvm_suld_2d_v4i16_zero,                   // llvm.nvvm.suld.2d.v4i16.zero
+    nvvm_suld_2d_v4i32_clamp,                  // llvm.nvvm.suld.2d.v4i32.clamp
+    nvvm_suld_2d_v4i32_trap,                   // llvm.nvvm.suld.2d.v4i32.trap
+    nvvm_suld_2d_v4i32_zero,                   // llvm.nvvm.suld.2d.v4i32.zero
+    nvvm_suld_2d_v4i8_clamp,                   // llvm.nvvm.suld.2d.v4i8.clamp
+    nvvm_suld_2d_v4i8_trap,                    // llvm.nvvm.suld.2d.v4i8.trap
+    nvvm_suld_2d_v4i8_zero,                    // llvm.nvvm.suld.2d.v4i8.zero
+    nvvm_suld_3d_i16_clamp,                    // llvm.nvvm.suld.3d.i16.clamp
+    nvvm_suld_3d_i16_trap,                     // llvm.nvvm.suld.3d.i16.trap
+    nvvm_suld_3d_i16_zero,                     // llvm.nvvm.suld.3d.i16.zero
+    nvvm_suld_3d_i32_clamp,                    // llvm.nvvm.suld.3d.i32.clamp
+    nvvm_suld_3d_i32_trap,                     // llvm.nvvm.suld.3d.i32.trap
+    nvvm_suld_3d_i32_zero,                     // llvm.nvvm.suld.3d.i32.zero
+    nvvm_suld_3d_i64_clamp,                    // llvm.nvvm.suld.3d.i64.clamp
+    nvvm_suld_3d_i64_trap,                     // llvm.nvvm.suld.3d.i64.trap
+    nvvm_suld_3d_i64_zero,                     // llvm.nvvm.suld.3d.i64.zero
+    nvvm_suld_3d_i8_clamp,                     // llvm.nvvm.suld.3d.i8.clamp
+    nvvm_suld_3d_i8_trap,                      // llvm.nvvm.suld.3d.i8.trap
+    nvvm_suld_3d_i8_zero,                      // llvm.nvvm.suld.3d.i8.zero
+    nvvm_suld_3d_v2i16_clamp,                  // llvm.nvvm.suld.3d.v2i16.clamp
+    nvvm_suld_3d_v2i16_trap,                   // llvm.nvvm.suld.3d.v2i16.trap
+    nvvm_suld_3d_v2i16_zero,                   // llvm.nvvm.suld.3d.v2i16.zero
+    nvvm_suld_3d_v2i32_clamp,                  // llvm.nvvm.suld.3d.v2i32.clamp
+    nvvm_suld_3d_v2i32_trap,                   // llvm.nvvm.suld.3d.v2i32.trap
+    nvvm_suld_3d_v2i32_zero,                   // llvm.nvvm.suld.3d.v2i32.zero
+    nvvm_suld_3d_v2i64_clamp,                  // llvm.nvvm.suld.3d.v2i64.clamp
+    nvvm_suld_3d_v2i64_trap,                   // llvm.nvvm.suld.3d.v2i64.trap
+    nvvm_suld_3d_v2i64_zero,                   // llvm.nvvm.suld.3d.v2i64.zero
+    nvvm_suld_3d_v2i8_clamp,                   // llvm.nvvm.suld.3d.v2i8.clamp
+    nvvm_suld_3d_v2i8_trap,                    // llvm.nvvm.suld.3d.v2i8.trap
+    nvvm_suld_3d_v2i8_zero,                    // llvm.nvvm.suld.3d.v2i8.zero
+    nvvm_suld_3d_v4i16_clamp,                  // llvm.nvvm.suld.3d.v4i16.clamp
+    nvvm_suld_3d_v4i16_trap,                   // llvm.nvvm.suld.3d.v4i16.trap
+    nvvm_suld_3d_v4i16_zero,                   // llvm.nvvm.suld.3d.v4i16.zero
+    nvvm_suld_3d_v4i32_clamp,                  // llvm.nvvm.suld.3d.v4i32.clamp
+    nvvm_suld_3d_v4i32_trap,                   // llvm.nvvm.suld.3d.v4i32.trap
+    nvvm_suld_3d_v4i32_zero,                   // llvm.nvvm.suld.3d.v4i32.zero
+    nvvm_suld_3d_v4i8_clamp,                   // llvm.nvvm.suld.3d.v4i8.clamp
+    nvvm_suld_3d_v4i8_trap,                    // llvm.nvvm.suld.3d.v4i8.trap
+    nvvm_suld_3d_v4i8_zero,                    // llvm.nvvm.suld.3d.v4i8.zero
+    nvvm_suq_array_size,                       // llvm.nvvm.suq.array.size
+    nvvm_suq_channel_data_type,                // llvm.nvvm.suq.channel.data.type
+    nvvm_suq_channel_order,                    // llvm.nvvm.suq.channel.order
+    nvvm_suq_depth,                            // llvm.nvvm.suq.depth
+    nvvm_suq_height,                           // llvm.nvvm.suq.height
+    nvvm_suq_width,                            // llvm.nvvm.suq.width
+    nvvm_sust_b_1d_array_i16_clamp,            // llvm.nvvm.sust.b.1d.array.i16.clamp
+    nvvm_sust_b_1d_array_i16_trap,             // llvm.nvvm.sust.b.1d.array.i16.trap
+    nvvm_sust_b_1d_array_i16_zero,             // llvm.nvvm.sust.b.1d.array.i16.zero
+    nvvm_sust_b_1d_array_i32_clamp,            // llvm.nvvm.sust.b.1d.array.i32.clamp
+    nvvm_sust_b_1d_array_i32_trap,             // llvm.nvvm.sust.b.1d.array.i32.trap
+    nvvm_sust_b_1d_array_i32_zero,             // llvm.nvvm.sust.b.1d.array.i32.zero
+    nvvm_sust_b_1d_array_i64_clamp,            // llvm.nvvm.sust.b.1d.array.i64.clamp
+    nvvm_sust_b_1d_array_i64_trap,             // llvm.nvvm.sust.b.1d.array.i64.trap
+    nvvm_sust_b_1d_array_i64_zero,             // llvm.nvvm.sust.b.1d.array.i64.zero
+    nvvm_sust_b_1d_array_i8_clamp,             // llvm.nvvm.sust.b.1d.array.i8.clamp
+    nvvm_sust_b_1d_array_i8_trap,              // llvm.nvvm.sust.b.1d.array.i8.trap
+    nvvm_sust_b_1d_array_i8_zero,              // llvm.nvvm.sust.b.1d.array.i8.zero
+    nvvm_sust_b_1d_array_v2i16_clamp,          // llvm.nvvm.sust.b.1d.array.v2i16.clamp
+    nvvm_sust_b_1d_array_v2i16_trap,           // llvm.nvvm.sust.b.1d.array.v2i16.trap
+    nvvm_sust_b_1d_array_v2i16_zero,           // llvm.nvvm.sust.b.1d.array.v2i16.zero
+    nvvm_sust_b_1d_array_v2i32_clamp,          // llvm.nvvm.sust.b.1d.array.v2i32.clamp
+    nvvm_sust_b_1d_array_v2i32_trap,           // llvm.nvvm.sust.b.1d.array.v2i32.trap
+    nvvm_sust_b_1d_array_v2i32_zero,           // llvm.nvvm.sust.b.1d.array.v2i32.zero
+    nvvm_sust_b_1d_array_v2i64_clamp,          // llvm.nvvm.sust.b.1d.array.v2i64.clamp
+    nvvm_sust_b_1d_array_v2i64_trap,           // llvm.nvvm.sust.b.1d.array.v2i64.trap
+    nvvm_sust_b_1d_array_v2i64_zero,           // llvm.nvvm.sust.b.1d.array.v2i64.zero
+    nvvm_sust_b_1d_array_v2i8_clamp,           // llvm.nvvm.sust.b.1d.array.v2i8.clamp
+    nvvm_sust_b_1d_array_v2i8_trap,            // llvm.nvvm.sust.b.1d.array.v2i8.trap
+    nvvm_sust_b_1d_array_v2i8_zero,            // llvm.nvvm.sust.b.1d.array.v2i8.zero
+    nvvm_sust_b_1d_array_v4i16_clamp,          // llvm.nvvm.sust.b.1d.array.v4i16.clamp
+    nvvm_sust_b_1d_array_v4i16_trap,           // llvm.nvvm.sust.b.1d.array.v4i16.trap
+    nvvm_sust_b_1d_array_v4i16_zero,           // llvm.nvvm.sust.b.1d.array.v4i16.zero
+    nvvm_sust_b_1d_array_v4i32_clamp,          // llvm.nvvm.sust.b.1d.array.v4i32.clamp
+    nvvm_sust_b_1d_array_v4i32_trap,           // llvm.nvvm.sust.b.1d.array.v4i32.trap
+    nvvm_sust_b_1d_array_v4i32_zero,           // llvm.nvvm.sust.b.1d.array.v4i32.zero
+    nvvm_sust_b_1d_array_v4i8_clamp,           // llvm.nvvm.sust.b.1d.array.v4i8.clamp
+    nvvm_sust_b_1d_array_v4i8_trap,            // llvm.nvvm.sust.b.1d.array.v4i8.trap
+    nvvm_sust_b_1d_array_v4i8_zero,            // llvm.nvvm.sust.b.1d.array.v4i8.zero
+    nvvm_sust_b_1d_i16_clamp,                  // llvm.nvvm.sust.b.1d.i16.clamp
+    nvvm_sust_b_1d_i16_trap,                   // llvm.nvvm.sust.b.1d.i16.trap
+    nvvm_sust_b_1d_i16_zero,                   // llvm.nvvm.sust.b.1d.i16.zero
+    nvvm_sust_b_1d_i32_clamp,                  // llvm.nvvm.sust.b.1d.i32.clamp
+    nvvm_sust_b_1d_i32_trap,                   // llvm.nvvm.sust.b.1d.i32.trap
+    nvvm_sust_b_1d_i32_zero,                   // llvm.nvvm.sust.b.1d.i32.zero
+    nvvm_sust_b_1d_i64_clamp,                  // llvm.nvvm.sust.b.1d.i64.clamp
+    nvvm_sust_b_1d_i64_trap,                   // llvm.nvvm.sust.b.1d.i64.trap
+    nvvm_sust_b_1d_i64_zero,                   // llvm.nvvm.sust.b.1d.i64.zero
+    nvvm_sust_b_1d_i8_clamp,                   // llvm.nvvm.sust.b.1d.i8.clamp
+    nvvm_sust_b_1d_i8_trap,                    // llvm.nvvm.sust.b.1d.i8.trap
+    nvvm_sust_b_1d_i8_zero,                    // llvm.nvvm.sust.b.1d.i8.zero
+    nvvm_sust_b_1d_v2i16_clamp,                // llvm.nvvm.sust.b.1d.v2i16.clamp
+    nvvm_sust_b_1d_v2i16_trap,                 // llvm.nvvm.sust.b.1d.v2i16.trap
+    nvvm_sust_b_1d_v2i16_zero,                 // llvm.nvvm.sust.b.1d.v2i16.zero
+    nvvm_sust_b_1d_v2i32_clamp,                // llvm.nvvm.sust.b.1d.v2i32.clamp
+    nvvm_sust_b_1d_v2i32_trap,                 // llvm.nvvm.sust.b.1d.v2i32.trap
+    nvvm_sust_b_1d_v2i32_zero,                 // llvm.nvvm.sust.b.1d.v2i32.zero
+    nvvm_sust_b_1d_v2i64_clamp,                // llvm.nvvm.sust.b.1d.v2i64.clamp
+    nvvm_sust_b_1d_v2i64_trap,                 // llvm.nvvm.sust.b.1d.v2i64.trap
+    nvvm_sust_b_1d_v2i64_zero,                 // llvm.nvvm.sust.b.1d.v2i64.zero
+    nvvm_sust_b_1d_v2i8_clamp,                 // llvm.nvvm.sust.b.1d.v2i8.clamp
+    nvvm_sust_b_1d_v2i8_trap,                  // llvm.nvvm.sust.b.1d.v2i8.trap
+    nvvm_sust_b_1d_v2i8_zero,                  // llvm.nvvm.sust.b.1d.v2i8.zero
+    nvvm_sust_b_1d_v4i16_clamp,                // llvm.nvvm.sust.b.1d.v4i16.clamp
+    nvvm_sust_b_1d_v4i16_trap,                 // llvm.nvvm.sust.b.1d.v4i16.trap
+    nvvm_sust_b_1d_v4i16_zero,                 // llvm.nvvm.sust.b.1d.v4i16.zero
+    nvvm_sust_b_1d_v4i32_clamp,                // llvm.nvvm.sust.b.1d.v4i32.clamp
+    nvvm_sust_b_1d_v4i32_trap,                 // llvm.nvvm.sust.b.1d.v4i32.trap
+    nvvm_sust_b_1d_v4i32_zero,                 // llvm.nvvm.sust.b.1d.v4i32.zero
+    nvvm_sust_b_1d_v4i8_clamp,                 // llvm.nvvm.sust.b.1d.v4i8.clamp
+    nvvm_sust_b_1d_v4i8_trap,                  // llvm.nvvm.sust.b.1d.v4i8.trap
+    nvvm_sust_b_1d_v4i8_zero,                  // llvm.nvvm.sust.b.1d.v4i8.zero
+    nvvm_sust_b_2d_array_i16_clamp,            // llvm.nvvm.sust.b.2d.array.i16.clamp
+    nvvm_sust_b_2d_array_i16_trap,             // llvm.nvvm.sust.b.2d.array.i16.trap
+    nvvm_sust_b_2d_array_i16_zero,             // llvm.nvvm.sust.b.2d.array.i16.zero
+    nvvm_sust_b_2d_array_i32_clamp,            // llvm.nvvm.sust.b.2d.array.i32.clamp
+    nvvm_sust_b_2d_array_i32_trap,             // llvm.nvvm.sust.b.2d.array.i32.trap
+    nvvm_sust_b_2d_array_i32_zero,             // llvm.nvvm.sust.b.2d.array.i32.zero
+    nvvm_sust_b_2d_array_i64_clamp,            // llvm.nvvm.sust.b.2d.array.i64.clamp
+    nvvm_sust_b_2d_array_i64_trap,             // llvm.nvvm.sust.b.2d.array.i64.trap
+    nvvm_sust_b_2d_array_i64_zero,             // llvm.nvvm.sust.b.2d.array.i64.zero
+    nvvm_sust_b_2d_array_i8_clamp,             // llvm.nvvm.sust.b.2d.array.i8.clamp
+    nvvm_sust_b_2d_array_i8_trap,              // llvm.nvvm.sust.b.2d.array.i8.trap
+    nvvm_sust_b_2d_array_i8_zero,              // llvm.nvvm.sust.b.2d.array.i8.zero
+    nvvm_sust_b_2d_array_v2i16_clamp,          // llvm.nvvm.sust.b.2d.array.v2i16.clamp
+    nvvm_sust_b_2d_array_v2i16_trap,           // llvm.nvvm.sust.b.2d.array.v2i16.trap
+    nvvm_sust_b_2d_array_v2i16_zero,           // llvm.nvvm.sust.b.2d.array.v2i16.zero
+    nvvm_sust_b_2d_array_v2i32_clamp,          // llvm.nvvm.sust.b.2d.array.v2i32.clamp
+    nvvm_sust_b_2d_array_v2i32_trap,           // llvm.nvvm.sust.b.2d.array.v2i32.trap
+    nvvm_sust_b_2d_array_v2i32_zero,           // llvm.nvvm.sust.b.2d.array.v2i32.zero
+    nvvm_sust_b_2d_array_v2i64_clamp,          // llvm.nvvm.sust.b.2d.array.v2i64.clamp
+    nvvm_sust_b_2d_array_v2i64_trap,           // llvm.nvvm.sust.b.2d.array.v2i64.trap
+    nvvm_sust_b_2d_array_v2i64_zero,           // llvm.nvvm.sust.b.2d.array.v2i64.zero
+    nvvm_sust_b_2d_array_v2i8_clamp,           // llvm.nvvm.sust.b.2d.array.v2i8.clamp
+    nvvm_sust_b_2d_array_v2i8_trap,            // llvm.nvvm.sust.b.2d.array.v2i8.trap
+    nvvm_sust_b_2d_array_v2i8_zero,            // llvm.nvvm.sust.b.2d.array.v2i8.zero
+    nvvm_sust_b_2d_array_v4i16_clamp,          // llvm.nvvm.sust.b.2d.array.v4i16.clamp
+    nvvm_sust_b_2d_array_v4i16_trap,           // llvm.nvvm.sust.b.2d.array.v4i16.trap
+    nvvm_sust_b_2d_array_v4i16_zero,           // llvm.nvvm.sust.b.2d.array.v4i16.zero
+    nvvm_sust_b_2d_array_v4i32_clamp,          // llvm.nvvm.sust.b.2d.array.v4i32.clamp
+    nvvm_sust_b_2d_array_v4i32_trap,           // llvm.nvvm.sust.b.2d.array.v4i32.trap
+    nvvm_sust_b_2d_array_v4i32_zero,           // llvm.nvvm.sust.b.2d.array.v4i32.zero
+    nvvm_sust_b_2d_array_v4i8_clamp,           // llvm.nvvm.sust.b.2d.array.v4i8.clamp
+    nvvm_sust_b_2d_array_v4i8_trap,            // llvm.nvvm.sust.b.2d.array.v4i8.trap
+    nvvm_sust_b_2d_array_v4i8_zero,            // llvm.nvvm.sust.b.2d.array.v4i8.zero
+    nvvm_sust_b_2d_i16_clamp,                  // llvm.nvvm.sust.b.2d.i16.clamp
+    nvvm_sust_b_2d_i16_trap,                   // llvm.nvvm.sust.b.2d.i16.trap
+    nvvm_sust_b_2d_i16_zero,                   // llvm.nvvm.sust.b.2d.i16.zero
+    nvvm_sust_b_2d_i32_clamp,                  // llvm.nvvm.sust.b.2d.i32.clamp
+    nvvm_sust_b_2d_i32_trap,                   // llvm.nvvm.sust.b.2d.i32.trap
+    nvvm_sust_b_2d_i32_zero,                   // llvm.nvvm.sust.b.2d.i32.zero
+    nvvm_sust_b_2d_i64_clamp,                  // llvm.nvvm.sust.b.2d.i64.clamp
+    nvvm_sust_b_2d_i64_trap,                   // llvm.nvvm.sust.b.2d.i64.trap
+    nvvm_sust_b_2d_i64_zero,                   // llvm.nvvm.sust.b.2d.i64.zero
+    nvvm_sust_b_2d_i8_clamp,                   // llvm.nvvm.sust.b.2d.i8.clamp
+    nvvm_sust_b_2d_i8_trap,                    // llvm.nvvm.sust.b.2d.i8.trap
+    nvvm_sust_b_2d_i8_zero,                    // llvm.nvvm.sust.b.2d.i8.zero
+    nvvm_sust_b_2d_v2i16_clamp,                // llvm.nvvm.sust.b.2d.v2i16.clamp
+    nvvm_sust_b_2d_v2i16_trap,                 // llvm.nvvm.sust.b.2d.v2i16.trap
+    nvvm_sust_b_2d_v2i16_zero,                 // llvm.nvvm.sust.b.2d.v2i16.zero
+    nvvm_sust_b_2d_v2i32_clamp,                // llvm.nvvm.sust.b.2d.v2i32.clamp
+    nvvm_sust_b_2d_v2i32_trap,                 // llvm.nvvm.sust.b.2d.v2i32.trap
+    nvvm_sust_b_2d_v2i32_zero,                 // llvm.nvvm.sust.b.2d.v2i32.zero
+    nvvm_sust_b_2d_v2i64_clamp,                // llvm.nvvm.sust.b.2d.v2i64.clamp
+    nvvm_sust_b_2d_v2i64_trap,                 // llvm.nvvm.sust.b.2d.v2i64.trap
+    nvvm_sust_b_2d_v2i64_zero,                 // llvm.nvvm.sust.b.2d.v2i64.zero
+    nvvm_sust_b_2d_v2i8_clamp,                 // llvm.nvvm.sust.b.2d.v2i8.clamp
+    nvvm_sust_b_2d_v2i8_trap,                  // llvm.nvvm.sust.b.2d.v2i8.trap
+    nvvm_sust_b_2d_v2i8_zero,                  // llvm.nvvm.sust.b.2d.v2i8.zero
+    nvvm_sust_b_2d_v4i16_clamp,                // llvm.nvvm.sust.b.2d.v4i16.clamp
+    nvvm_sust_b_2d_v4i16_trap,                 // llvm.nvvm.sust.b.2d.v4i16.trap
+    nvvm_sust_b_2d_v4i16_zero,                 // llvm.nvvm.sust.b.2d.v4i16.zero
+    nvvm_sust_b_2d_v4i32_clamp,                // llvm.nvvm.sust.b.2d.v4i32.clamp
+    nvvm_sust_b_2d_v4i32_trap,                 // llvm.nvvm.sust.b.2d.v4i32.trap
+    nvvm_sust_b_2d_v4i32_zero,                 // llvm.nvvm.sust.b.2d.v4i32.zero
+    nvvm_sust_b_2d_v4i8_clamp,                 // llvm.nvvm.sust.b.2d.v4i8.clamp
+    nvvm_sust_b_2d_v4i8_trap,                  // llvm.nvvm.sust.b.2d.v4i8.trap
+    nvvm_sust_b_2d_v4i8_zero,                  // llvm.nvvm.sust.b.2d.v4i8.zero
+    nvvm_sust_b_3d_i16_clamp,                  // llvm.nvvm.sust.b.3d.i16.clamp
+    nvvm_sust_b_3d_i16_trap,                   // llvm.nvvm.sust.b.3d.i16.trap
+    nvvm_sust_b_3d_i16_zero,                   // llvm.nvvm.sust.b.3d.i16.zero
+    nvvm_sust_b_3d_i32_clamp,                  // llvm.nvvm.sust.b.3d.i32.clamp
+    nvvm_sust_b_3d_i32_trap,                   // llvm.nvvm.sust.b.3d.i32.trap
+    nvvm_sust_b_3d_i32_zero,                   // llvm.nvvm.sust.b.3d.i32.zero
+    nvvm_sust_b_3d_i64_clamp,                  // llvm.nvvm.sust.b.3d.i64.clamp
+    nvvm_sust_b_3d_i64_trap,                   // llvm.nvvm.sust.b.3d.i64.trap
+    nvvm_sust_b_3d_i64_zero,                   // llvm.nvvm.sust.b.3d.i64.zero
+    nvvm_sust_b_3d_i8_clamp,                   // llvm.nvvm.sust.b.3d.i8.clamp
+    nvvm_sust_b_3d_i8_trap,                    // llvm.nvvm.sust.b.3d.i8.trap
+    nvvm_sust_b_3d_i8_zero,                    // llvm.nvvm.sust.b.3d.i8.zero
+    nvvm_sust_b_3d_v2i16_clamp,                // llvm.nvvm.sust.b.3d.v2i16.clamp
+    nvvm_sust_b_3d_v2i16_trap,                 // llvm.nvvm.sust.b.3d.v2i16.trap
+    nvvm_sust_b_3d_v2i16_zero,                 // llvm.nvvm.sust.b.3d.v2i16.zero
+    nvvm_sust_b_3d_v2i32_clamp,                // llvm.nvvm.sust.b.3d.v2i32.clamp
+    nvvm_sust_b_3d_v2i32_trap,                 // llvm.nvvm.sust.b.3d.v2i32.trap
+    nvvm_sust_b_3d_v2i32_zero,                 // llvm.nvvm.sust.b.3d.v2i32.zero
+    nvvm_sust_b_3d_v2i64_clamp,                // llvm.nvvm.sust.b.3d.v2i64.clamp
+    nvvm_sust_b_3d_v2i64_trap,                 // llvm.nvvm.sust.b.3d.v2i64.trap
+    nvvm_sust_b_3d_v2i64_zero,                 // llvm.nvvm.sust.b.3d.v2i64.zero
+    nvvm_sust_b_3d_v2i8_clamp,                 // llvm.nvvm.sust.b.3d.v2i8.clamp
+    nvvm_sust_b_3d_v2i8_trap,                  // llvm.nvvm.sust.b.3d.v2i8.trap
+    nvvm_sust_b_3d_v2i8_zero,                  // llvm.nvvm.sust.b.3d.v2i8.zero
+    nvvm_sust_b_3d_v4i16_clamp,                // llvm.nvvm.sust.b.3d.v4i16.clamp
+    nvvm_sust_b_3d_v4i16_trap,                 // llvm.nvvm.sust.b.3d.v4i16.trap
+    nvvm_sust_b_3d_v4i16_zero,                 // llvm.nvvm.sust.b.3d.v4i16.zero
+    nvvm_sust_b_3d_v4i32_clamp,                // llvm.nvvm.sust.b.3d.v4i32.clamp
+    nvvm_sust_b_3d_v4i32_trap,                 // llvm.nvvm.sust.b.3d.v4i32.trap
+    nvvm_sust_b_3d_v4i32_zero,                 // llvm.nvvm.sust.b.3d.v4i32.zero
+    nvvm_sust_b_3d_v4i8_clamp,                 // llvm.nvvm.sust.b.3d.v4i8.clamp
+    nvvm_sust_b_3d_v4i8_trap,                  // llvm.nvvm.sust.b.3d.v4i8.trap
+    nvvm_sust_b_3d_v4i8_zero,                  // llvm.nvvm.sust.b.3d.v4i8.zero
+    nvvm_sust_p_1d_array_i16_trap,             // llvm.nvvm.sust.p.1d.array.i16.trap
+    nvvm_sust_p_1d_array_i32_trap,             // llvm.nvvm.sust.p.1d.array.i32.trap
+    nvvm_sust_p_1d_array_i8_trap,              // llvm.nvvm.sust.p.1d.array.i8.trap
+    nvvm_sust_p_1d_array_v2i16_trap,           // llvm.nvvm.sust.p.1d.array.v2i16.trap
+    nvvm_sust_p_1d_array_v2i32_trap,           // llvm.nvvm.sust.p.1d.array.v2i32.trap
+    nvvm_sust_p_1d_array_v2i8_trap,            // llvm.nvvm.sust.p.1d.array.v2i8.trap
+    nvvm_sust_p_1d_array_v4i16_trap,           // llvm.nvvm.sust.p.1d.array.v4i16.trap
+    nvvm_sust_p_1d_array_v4i32_trap,           // llvm.nvvm.sust.p.1d.array.v4i32.trap
+    nvvm_sust_p_1d_array_v4i8_trap,            // llvm.nvvm.sust.p.1d.array.v4i8.trap
+    nvvm_sust_p_1d_i16_trap,                   // llvm.nvvm.sust.p.1d.i16.trap
+    nvvm_sust_p_1d_i32_trap,                   // llvm.nvvm.sust.p.1d.i32.trap
+    nvvm_sust_p_1d_i8_trap,                    // llvm.nvvm.sust.p.1d.i8.trap
+    nvvm_sust_p_1d_v2i16_trap,                 // llvm.nvvm.sust.p.1d.v2i16.trap
+    nvvm_sust_p_1d_v2i32_trap,                 // llvm.nvvm.sust.p.1d.v2i32.trap
+    nvvm_sust_p_1d_v2i8_trap,                  // llvm.nvvm.sust.p.1d.v2i8.trap
+    nvvm_sust_p_1d_v4i16_trap,                 // llvm.nvvm.sust.p.1d.v4i16.trap
+    nvvm_sust_p_1d_v4i32_trap,                 // llvm.nvvm.sust.p.1d.v4i32.trap
+    nvvm_sust_p_1d_v4i8_trap,                  // llvm.nvvm.sust.p.1d.v4i8.trap
+    nvvm_sust_p_2d_array_i16_trap,             // llvm.nvvm.sust.p.2d.array.i16.trap
+    nvvm_sust_p_2d_array_i32_trap,             // llvm.nvvm.sust.p.2d.array.i32.trap
+    nvvm_sust_p_2d_array_i8_trap,              // llvm.nvvm.sust.p.2d.array.i8.trap
+    nvvm_sust_p_2d_array_v2i16_trap,           // llvm.nvvm.sust.p.2d.array.v2i16.trap
+    nvvm_sust_p_2d_array_v2i32_trap,           // llvm.nvvm.sust.p.2d.array.v2i32.trap
+    nvvm_sust_p_2d_array_v2i8_trap,            // llvm.nvvm.sust.p.2d.array.v2i8.trap
+    nvvm_sust_p_2d_array_v4i16_trap,           // llvm.nvvm.sust.p.2d.array.v4i16.trap
+    nvvm_sust_p_2d_array_v4i32_trap,           // llvm.nvvm.sust.p.2d.array.v4i32.trap
+    nvvm_sust_p_2d_array_v4i8_trap,            // llvm.nvvm.sust.p.2d.array.v4i8.trap
+    nvvm_sust_p_2d_i16_trap,                   // llvm.nvvm.sust.p.2d.i16.trap
+    nvvm_sust_p_2d_i32_trap,                   // llvm.nvvm.sust.p.2d.i32.trap
+    nvvm_sust_p_2d_i8_trap,                    // llvm.nvvm.sust.p.2d.i8.trap
+    nvvm_sust_p_2d_v2i16_trap,                 // llvm.nvvm.sust.p.2d.v2i16.trap
+    nvvm_sust_p_2d_v2i32_trap,                 // llvm.nvvm.sust.p.2d.v2i32.trap
+    nvvm_sust_p_2d_v2i8_trap,                  // llvm.nvvm.sust.p.2d.v2i8.trap
+    nvvm_sust_p_2d_v4i16_trap,                 // llvm.nvvm.sust.p.2d.v4i16.trap
+    nvvm_sust_p_2d_v4i32_trap,                 // llvm.nvvm.sust.p.2d.v4i32.trap
+    nvvm_sust_p_2d_v4i8_trap,                  // llvm.nvvm.sust.p.2d.v4i8.trap
+    nvvm_sust_p_3d_i16_trap,                   // llvm.nvvm.sust.p.3d.i16.trap
+    nvvm_sust_p_3d_i32_trap,                   // llvm.nvvm.sust.p.3d.i32.trap
+    nvvm_sust_p_3d_i8_trap,                    // llvm.nvvm.sust.p.3d.i8.trap
+    nvvm_sust_p_3d_v2i16_trap,                 // llvm.nvvm.sust.p.3d.v2i16.trap
+    nvvm_sust_p_3d_v2i32_trap,                 // llvm.nvvm.sust.p.3d.v2i32.trap
+    nvvm_sust_p_3d_v2i8_trap,                  // llvm.nvvm.sust.p.3d.v2i8.trap
+    nvvm_sust_p_3d_v4i16_trap,                 // llvm.nvvm.sust.p.3d.v4i16.trap
+    nvvm_sust_p_3d_v4i32_trap,                 // llvm.nvvm.sust.p.3d.v4i32.trap
+    nvvm_sust_p_3d_v4i8_trap,                  // llvm.nvvm.sust.p.3d.v4i8.trap
+    nvvm_swap_lo_hi_b64,                       // llvm.nvvm.swap.lo.hi.b64
+    nvvm_tex_1d_array_grad_v4f32_f32,          // llvm.nvvm.tex.1d.array.grad.v4f32.f32
+    nvvm_tex_1d_array_grad_v4s32_f32,          // llvm.nvvm.tex.1d.array.grad.v4s32.f32
+    nvvm_tex_1d_array_grad_v4u32_f32,          // llvm.nvvm.tex.1d.array.grad.v4u32.f32
+    nvvm_tex_1d_array_level_v4f32_f32,         // llvm.nvvm.tex.1d.array.level.v4f32.f32
+    nvvm_tex_1d_array_level_v4s32_f32,         // llvm.nvvm.tex.1d.array.level.v4s32.f32
+    nvvm_tex_1d_array_level_v4u32_f32,         // llvm.nvvm.tex.1d.array.level.v4u32.f32
+    nvvm_tex_1d_array_v4f32_f32,               // llvm.nvvm.tex.1d.array.v4f32.f32
+    nvvm_tex_1d_array_v4f32_s32,               // llvm.nvvm.tex.1d.array.v4f32.s32
+    nvvm_tex_1d_array_v4s32_f32,               // llvm.nvvm.tex.1d.array.v4s32.f32
+    nvvm_tex_1d_array_v4s32_s32,               // llvm.nvvm.tex.1d.array.v4s32.s32
+    nvvm_tex_1d_array_v4u32_f32,               // llvm.nvvm.tex.1d.array.v4u32.f32
+    nvvm_tex_1d_array_v4u32_s32,               // llvm.nvvm.tex.1d.array.v4u32.s32
+    nvvm_tex_1d_grad_v4f32_f32,                // llvm.nvvm.tex.1d.grad.v4f32.f32
+    nvvm_tex_1d_grad_v4s32_f32,                // llvm.nvvm.tex.1d.grad.v4s32.f32
+    nvvm_tex_1d_grad_v4u32_f32,                // llvm.nvvm.tex.1d.grad.v4u32.f32
+    nvvm_tex_1d_level_v4f32_f32,               // llvm.nvvm.tex.1d.level.v4f32.f32
+    nvvm_tex_1d_level_v4s32_f32,               // llvm.nvvm.tex.1d.level.v4s32.f32
+    nvvm_tex_1d_level_v4u32_f32,               // llvm.nvvm.tex.1d.level.v4u32.f32
+    nvvm_tex_1d_v4f32_f32,                     // llvm.nvvm.tex.1d.v4f32.f32
+    nvvm_tex_1d_v4f32_s32,                     // llvm.nvvm.tex.1d.v4f32.s32
+    nvvm_tex_1d_v4s32_f32,                     // llvm.nvvm.tex.1d.v4s32.f32
+    nvvm_tex_1d_v4s32_s32,                     // llvm.nvvm.tex.1d.v4s32.s32
+    nvvm_tex_1d_v4u32_f32,                     // llvm.nvvm.tex.1d.v4u32.f32
+    nvvm_tex_1d_v4u32_s32,                     // llvm.nvvm.tex.1d.v4u32.s32
+    nvvm_tex_2d_array_grad_v4f32_f32,          // llvm.nvvm.tex.2d.array.grad.v4f32.f32
+    nvvm_tex_2d_array_grad_v4s32_f32,          // llvm.nvvm.tex.2d.array.grad.v4s32.f32
+    nvvm_tex_2d_array_grad_v4u32_f32,          // llvm.nvvm.tex.2d.array.grad.v4u32.f32
+    nvvm_tex_2d_array_level_v4f32_f32,         // llvm.nvvm.tex.2d.array.level.v4f32.f32
+    nvvm_tex_2d_array_level_v4s32_f32,         // llvm.nvvm.tex.2d.array.level.v4s32.f32
+    nvvm_tex_2d_array_level_v4u32_f32,         // llvm.nvvm.tex.2d.array.level.v4u32.f32
+    nvvm_tex_2d_array_v4f32_f32,               // llvm.nvvm.tex.2d.array.v4f32.f32
+    nvvm_tex_2d_array_v4f32_s32,               // llvm.nvvm.tex.2d.array.v4f32.s32
+    nvvm_tex_2d_array_v4s32_f32,               // llvm.nvvm.tex.2d.array.v4s32.f32
+    nvvm_tex_2d_array_v4s32_s32,               // llvm.nvvm.tex.2d.array.v4s32.s32
+    nvvm_tex_2d_array_v4u32_f32,               // llvm.nvvm.tex.2d.array.v4u32.f32
+    nvvm_tex_2d_array_v4u32_s32,               // llvm.nvvm.tex.2d.array.v4u32.s32
+    nvvm_tex_2d_grad_v4f32_f32,                // llvm.nvvm.tex.2d.grad.v4f32.f32
+    nvvm_tex_2d_grad_v4s32_f32,                // llvm.nvvm.tex.2d.grad.v4s32.f32
+    nvvm_tex_2d_grad_v4u32_f32,                // llvm.nvvm.tex.2d.grad.v4u32.f32
+    nvvm_tex_2d_level_v4f32_f32,               // llvm.nvvm.tex.2d.level.v4f32.f32
+    nvvm_tex_2d_level_v4s32_f32,               // llvm.nvvm.tex.2d.level.v4s32.f32
+    nvvm_tex_2d_level_v4u32_f32,               // llvm.nvvm.tex.2d.level.v4u32.f32
+    nvvm_tex_2d_v4f32_f32,                     // llvm.nvvm.tex.2d.v4f32.f32
+    nvvm_tex_2d_v4f32_s32,                     // llvm.nvvm.tex.2d.v4f32.s32
+    nvvm_tex_2d_v4s32_f32,                     // llvm.nvvm.tex.2d.v4s32.f32
+    nvvm_tex_2d_v4s32_s32,                     // llvm.nvvm.tex.2d.v4s32.s32
+    nvvm_tex_2d_v4u32_f32,                     // llvm.nvvm.tex.2d.v4u32.f32
+    nvvm_tex_2d_v4u32_s32,                     // llvm.nvvm.tex.2d.v4u32.s32
+    nvvm_tex_3d_grad_v4f32_f32,                // llvm.nvvm.tex.3d.grad.v4f32.f32
+    nvvm_tex_3d_grad_v4s32_f32,                // llvm.nvvm.tex.3d.grad.v4s32.f32
+    nvvm_tex_3d_grad_v4u32_f32,                // llvm.nvvm.tex.3d.grad.v4u32.f32
+    nvvm_tex_3d_level_v4f32_f32,               // llvm.nvvm.tex.3d.level.v4f32.f32
+    nvvm_tex_3d_level_v4s32_f32,               // llvm.nvvm.tex.3d.level.v4s32.f32
+    nvvm_tex_3d_level_v4u32_f32,               // llvm.nvvm.tex.3d.level.v4u32.f32
+    nvvm_tex_3d_v4f32_f32,                     // llvm.nvvm.tex.3d.v4f32.f32
+    nvvm_tex_3d_v4f32_s32,                     // llvm.nvvm.tex.3d.v4f32.s32
+    nvvm_tex_3d_v4s32_f32,                     // llvm.nvvm.tex.3d.v4s32.f32
+    nvvm_tex_3d_v4s32_s32,                     // llvm.nvvm.tex.3d.v4s32.s32
+    nvvm_tex_3d_v4u32_f32,                     // llvm.nvvm.tex.3d.v4u32.f32
+    nvvm_tex_3d_v4u32_s32,                     // llvm.nvvm.tex.3d.v4u32.s32
+    nvvm_tex_cube_array_level_v4f32_f32,       // llvm.nvvm.tex.cube.array.level.v4f32.f32
+    nvvm_tex_cube_array_level_v4s32_f32,       // llvm.nvvm.tex.cube.array.level.v4s32.f32
+    nvvm_tex_cube_array_level_v4u32_f32,       // llvm.nvvm.tex.cube.array.level.v4u32.f32
+    nvvm_tex_cube_array_v4f32_f32,             // llvm.nvvm.tex.cube.array.v4f32.f32
+    nvvm_tex_cube_array_v4s32_f32,             // llvm.nvvm.tex.cube.array.v4s32.f32
+    nvvm_tex_cube_array_v4u32_f32,             // llvm.nvvm.tex.cube.array.v4u32.f32
+    nvvm_tex_cube_level_v4f32_f32,             // llvm.nvvm.tex.cube.level.v4f32.f32
+    nvvm_tex_cube_level_v4s32_f32,             // llvm.nvvm.tex.cube.level.v4s32.f32
+    nvvm_tex_cube_level_v4u32_f32,             // llvm.nvvm.tex.cube.level.v4u32.f32
+    nvvm_tex_cube_v4f32_f32,                   // llvm.nvvm.tex.cube.v4f32.f32
+    nvvm_tex_cube_v4s32_f32,                   // llvm.nvvm.tex.cube.v4s32.f32
+    nvvm_tex_cube_v4u32_f32,                   // llvm.nvvm.tex.cube.v4u32.f32
+    nvvm_tex_unified_1d_array_grad_v4f32_f32,  // llvm.nvvm.tex.unified.1d.array.grad.v4f32.f32
+    nvvm_tex_unified_1d_array_grad_v4s32_f32,  // llvm.nvvm.tex.unified.1d.array.grad.v4s32.f32
+    nvvm_tex_unified_1d_array_grad_v4u32_f32,  // llvm.nvvm.tex.unified.1d.array.grad.v4u32.f32
+    nvvm_tex_unified_1d_array_level_v4f32_f32,  // llvm.nvvm.tex.unified.1d.array.level.v4f32.f32
+    nvvm_tex_unified_1d_array_level_v4s32_f32,  // llvm.nvvm.tex.unified.1d.array.level.v4s32.f32
+    nvvm_tex_unified_1d_array_level_v4u32_f32,  // llvm.nvvm.tex.unified.1d.array.level.v4u32.f32
+    nvvm_tex_unified_1d_array_v4f32_f32,       // llvm.nvvm.tex.unified.1d.array.v4f32.f32
+    nvvm_tex_unified_1d_array_v4f32_s32,       // llvm.nvvm.tex.unified.1d.array.v4f32.s32
+    nvvm_tex_unified_1d_array_v4s32_f32,       // llvm.nvvm.tex.unified.1d.array.v4s32.f32
+    nvvm_tex_unified_1d_array_v4s32_s32,       // llvm.nvvm.tex.unified.1d.array.v4s32.s32
+    nvvm_tex_unified_1d_array_v4u32_f32,       // llvm.nvvm.tex.unified.1d.array.v4u32.f32
+    nvvm_tex_unified_1d_array_v4u32_s32,       // llvm.nvvm.tex.unified.1d.array.v4u32.s32
+    nvvm_tex_unified_1d_grad_v4f32_f32,        // llvm.nvvm.tex.unified.1d.grad.v4f32.f32
+    nvvm_tex_unified_1d_grad_v4s32_f32,        // llvm.nvvm.tex.unified.1d.grad.v4s32.f32
+    nvvm_tex_unified_1d_grad_v4u32_f32,        // llvm.nvvm.tex.unified.1d.grad.v4u32.f32
+    nvvm_tex_unified_1d_level_v4f32_f32,       // llvm.nvvm.tex.unified.1d.level.v4f32.f32
+    nvvm_tex_unified_1d_level_v4s32_f32,       // llvm.nvvm.tex.unified.1d.level.v4s32.f32
+    nvvm_tex_unified_1d_level_v4u32_f32,       // llvm.nvvm.tex.unified.1d.level.v4u32.f32
+    nvvm_tex_unified_1d_v4f32_f32,             // llvm.nvvm.tex.unified.1d.v4f32.f32
+    nvvm_tex_unified_1d_v4f32_s32,             // llvm.nvvm.tex.unified.1d.v4f32.s32
+    nvvm_tex_unified_1d_v4s32_f32,             // llvm.nvvm.tex.unified.1d.v4s32.f32
+    nvvm_tex_unified_1d_v4s32_s32,             // llvm.nvvm.tex.unified.1d.v4s32.s32
+    nvvm_tex_unified_1d_v4u32_f32,             // llvm.nvvm.tex.unified.1d.v4u32.f32
+    nvvm_tex_unified_1d_v4u32_s32,             // llvm.nvvm.tex.unified.1d.v4u32.s32
+    nvvm_tex_unified_2d_array_grad_v4f32_f32,  // llvm.nvvm.tex.unified.2d.array.grad.v4f32.f32
+    nvvm_tex_unified_2d_array_grad_v4s32_f32,  // llvm.nvvm.tex.unified.2d.array.grad.v4s32.f32
+    nvvm_tex_unified_2d_array_grad_v4u32_f32,  // llvm.nvvm.tex.unified.2d.array.grad.v4u32.f32
+    nvvm_tex_unified_2d_array_level_v4f32_f32,  // llvm.nvvm.tex.unified.2d.array.level.v4f32.f32
+    nvvm_tex_unified_2d_array_level_v4s32_f32,  // llvm.nvvm.tex.unified.2d.array.level.v4s32.f32
+    nvvm_tex_unified_2d_array_level_v4u32_f32,  // llvm.nvvm.tex.unified.2d.array.level.v4u32.f32
+    nvvm_tex_unified_2d_array_v4f32_f32,       // llvm.nvvm.tex.unified.2d.array.v4f32.f32
+    nvvm_tex_unified_2d_array_v4f32_s32,       // llvm.nvvm.tex.unified.2d.array.v4f32.s32
+    nvvm_tex_unified_2d_array_v4s32_f32,       // llvm.nvvm.tex.unified.2d.array.v4s32.f32
+    nvvm_tex_unified_2d_array_v4s32_s32,       // llvm.nvvm.tex.unified.2d.array.v4s32.s32
+    nvvm_tex_unified_2d_array_v4u32_f32,       // llvm.nvvm.tex.unified.2d.array.v4u32.f32
+    nvvm_tex_unified_2d_array_v4u32_s32,       // llvm.nvvm.tex.unified.2d.array.v4u32.s32
+    nvvm_tex_unified_2d_grad_v4f32_f32,        // llvm.nvvm.tex.unified.2d.grad.v4f32.f32
+    nvvm_tex_unified_2d_grad_v4s32_f32,        // llvm.nvvm.tex.unified.2d.grad.v4s32.f32
+    nvvm_tex_unified_2d_grad_v4u32_f32,        // llvm.nvvm.tex.unified.2d.grad.v4u32.f32
+    nvvm_tex_unified_2d_level_v4f32_f32,       // llvm.nvvm.tex.unified.2d.level.v4f32.f32
+    nvvm_tex_unified_2d_level_v4s32_f32,       // llvm.nvvm.tex.unified.2d.level.v4s32.f32
+    nvvm_tex_unified_2d_level_v4u32_f32,       // llvm.nvvm.tex.unified.2d.level.v4u32.f32
+    nvvm_tex_unified_2d_v4f32_f32,             // llvm.nvvm.tex.unified.2d.v4f32.f32
+    nvvm_tex_unified_2d_v4f32_s32,             // llvm.nvvm.tex.unified.2d.v4f32.s32
+    nvvm_tex_unified_2d_v4s32_f32,             // llvm.nvvm.tex.unified.2d.v4s32.f32
+    nvvm_tex_unified_2d_v4s32_s32,             // llvm.nvvm.tex.unified.2d.v4s32.s32
+    nvvm_tex_unified_2d_v4u32_f32,             // llvm.nvvm.tex.unified.2d.v4u32.f32
+    nvvm_tex_unified_2d_v4u32_s32,             // llvm.nvvm.tex.unified.2d.v4u32.s32
+    nvvm_tex_unified_3d_grad_v4f32_f32,        // llvm.nvvm.tex.unified.3d.grad.v4f32.f32
+    nvvm_tex_unified_3d_grad_v4s32_f32,        // llvm.nvvm.tex.unified.3d.grad.v4s32.f32
+    nvvm_tex_unified_3d_grad_v4u32_f32,        // llvm.nvvm.tex.unified.3d.grad.v4u32.f32
+    nvvm_tex_unified_3d_level_v4f32_f32,       // llvm.nvvm.tex.unified.3d.level.v4f32.f32
+    nvvm_tex_unified_3d_level_v4s32_f32,       // llvm.nvvm.tex.unified.3d.level.v4s32.f32
+    nvvm_tex_unified_3d_level_v4u32_f32,       // llvm.nvvm.tex.unified.3d.level.v4u32.f32
+    nvvm_tex_unified_3d_v4f32_f32,             // llvm.nvvm.tex.unified.3d.v4f32.f32
+    nvvm_tex_unified_3d_v4f32_s32,             // llvm.nvvm.tex.unified.3d.v4f32.s32
+    nvvm_tex_unified_3d_v4s32_f32,             // llvm.nvvm.tex.unified.3d.v4s32.f32
+    nvvm_tex_unified_3d_v4s32_s32,             // llvm.nvvm.tex.unified.3d.v4s32.s32
+    nvvm_tex_unified_3d_v4u32_f32,             // llvm.nvvm.tex.unified.3d.v4u32.f32
+    nvvm_tex_unified_3d_v4u32_s32,             // llvm.nvvm.tex.unified.3d.v4u32.s32
+    nvvm_tex_unified_cube_array_level_v4f32_f32,  // llvm.nvvm.tex.unified.cube.array.level.v4f32.f32
+    nvvm_tex_unified_cube_array_level_v4s32_f32,  // llvm.nvvm.tex.unified.cube.array.level.v4s32.f32
+    nvvm_tex_unified_cube_array_level_v4u32_f32,  // llvm.nvvm.tex.unified.cube.array.level.v4u32.f32
+    nvvm_tex_unified_cube_array_v4f32_f32,     // llvm.nvvm.tex.unified.cube.array.v4f32.f32
+    nvvm_tex_unified_cube_array_v4s32_f32,     // llvm.nvvm.tex.unified.cube.array.v4s32.f32
+    nvvm_tex_unified_cube_array_v4u32_f32,     // llvm.nvvm.tex.unified.cube.array.v4u32.f32
+    nvvm_tex_unified_cube_level_v4f32_f32,     // llvm.nvvm.tex.unified.cube.level.v4f32.f32
+    nvvm_tex_unified_cube_level_v4s32_f32,     // llvm.nvvm.tex.unified.cube.level.v4s32.f32
+    nvvm_tex_unified_cube_level_v4u32_f32,     // llvm.nvvm.tex.unified.cube.level.v4u32.f32
+    nvvm_tex_unified_cube_v4f32_f32,           // llvm.nvvm.tex.unified.cube.v4f32.f32
+    nvvm_tex_unified_cube_v4s32_f32,           // llvm.nvvm.tex.unified.cube.v4s32.f32
+    nvvm_tex_unified_cube_v4u32_f32,           // llvm.nvvm.tex.unified.cube.v4u32.f32
+    nvvm_texsurf_handle,                       // llvm.nvvm.texsurf.handle
+    nvvm_texsurf_handle_internal,              // llvm.nvvm.texsurf.handle.internal
+    nvvm_tld4_a_2d_v4f32_f32,                  // llvm.nvvm.tld4.a.2d.v4f32.f32
+    nvvm_tld4_a_2d_v4s32_f32,                  // llvm.nvvm.tld4.a.2d.v4s32.f32
+    nvvm_tld4_a_2d_v4u32_f32,                  // llvm.nvvm.tld4.a.2d.v4u32.f32
+    nvvm_tld4_b_2d_v4f32_f32,                  // llvm.nvvm.tld4.b.2d.v4f32.f32
+    nvvm_tld4_b_2d_v4s32_f32,                  // llvm.nvvm.tld4.b.2d.v4s32.f32
+    nvvm_tld4_b_2d_v4u32_f32,                  // llvm.nvvm.tld4.b.2d.v4u32.f32
+    nvvm_tld4_g_2d_v4f32_f32,                  // llvm.nvvm.tld4.g.2d.v4f32.f32
+    nvvm_tld4_g_2d_v4s32_f32,                  // llvm.nvvm.tld4.g.2d.v4s32.f32
+    nvvm_tld4_g_2d_v4u32_f32,                  // llvm.nvvm.tld4.g.2d.v4u32.f32
+    nvvm_tld4_r_2d_v4f32_f32,                  // llvm.nvvm.tld4.r.2d.v4f32.f32
+    nvvm_tld4_r_2d_v4s32_f32,                  // llvm.nvvm.tld4.r.2d.v4s32.f32
+    nvvm_tld4_r_2d_v4u32_f32,                  // llvm.nvvm.tld4.r.2d.v4u32.f32
+    nvvm_tld4_unified_a_2d_v4f32_f32,          // llvm.nvvm.tld4.unified.a.2d.v4f32.f32
+    nvvm_tld4_unified_a_2d_v4s32_f32,          // llvm.nvvm.tld4.unified.a.2d.v4s32.f32
+    nvvm_tld4_unified_a_2d_v4u32_f32,          // llvm.nvvm.tld4.unified.a.2d.v4u32.f32
+    nvvm_tld4_unified_b_2d_v4f32_f32,          // llvm.nvvm.tld4.unified.b.2d.v4f32.f32
+    nvvm_tld4_unified_b_2d_v4s32_f32,          // llvm.nvvm.tld4.unified.b.2d.v4s32.f32
+    nvvm_tld4_unified_b_2d_v4u32_f32,          // llvm.nvvm.tld4.unified.b.2d.v4u32.f32
+    nvvm_tld4_unified_g_2d_v4f32_f32,          // llvm.nvvm.tld4.unified.g.2d.v4f32.f32
+    nvvm_tld4_unified_g_2d_v4s32_f32,          // llvm.nvvm.tld4.unified.g.2d.v4s32.f32
+    nvvm_tld4_unified_g_2d_v4u32_f32,          // llvm.nvvm.tld4.unified.g.2d.v4u32.f32
+    nvvm_tld4_unified_r_2d_v4f32_f32,          // llvm.nvvm.tld4.unified.r.2d.v4f32.f32
+    nvvm_tld4_unified_r_2d_v4s32_f32,          // llvm.nvvm.tld4.unified.r.2d.v4s32.f32
+    nvvm_tld4_unified_r_2d_v4u32_f32,          // llvm.nvvm.tld4.unified.r.2d.v4u32.f32
+    nvvm_trunc_d,                              // llvm.nvvm.trunc.d
+    nvvm_trunc_f,                              // llvm.nvvm.trunc.f
+    nvvm_trunc_ftz_f,                          // llvm.nvvm.trunc.ftz.f
+    nvvm_txq_array_size,                       // llvm.nvvm.txq.array.size
+    nvvm_txq_channel_data_type,                // llvm.nvvm.txq.channel.data.type
+    nvvm_txq_channel_order,                    // llvm.nvvm.txq.channel.order
+    nvvm_txq_depth,                            // llvm.nvvm.txq.depth
+    nvvm_txq_height,                           // llvm.nvvm.txq.height
+    nvvm_txq_num_mipmap_levels,                // llvm.nvvm.txq.num.mipmap.levels
+    nvvm_txq_num_samples,                      // llvm.nvvm.txq.num.samples
+    nvvm_txq_width,                            // llvm.nvvm.txq.width
+    nvvm_ui2d_rm,                              // llvm.nvvm.ui2d.rm
+    nvvm_ui2d_rn,                              // llvm.nvvm.ui2d.rn
+    nvvm_ui2d_rp,                              // llvm.nvvm.ui2d.rp
+    nvvm_ui2d_rz,                              // llvm.nvvm.ui2d.rz
+    nvvm_ui2f_rm,                              // llvm.nvvm.ui2f.rm
+    nvvm_ui2f_rn,                              // llvm.nvvm.ui2f.rn
+    nvvm_ui2f_rp,                              // llvm.nvvm.ui2f.rp
+    nvvm_ui2f_rz,                              // llvm.nvvm.ui2f.rz
+    nvvm_ull2d_rm,                             // llvm.nvvm.ull2d.rm
+    nvvm_ull2d_rn,                             // llvm.nvvm.ull2d.rn
+    nvvm_ull2d_rp,                             // llvm.nvvm.ull2d.rp
+    nvvm_ull2d_rz,                             // llvm.nvvm.ull2d.rz
+    nvvm_ull2f_rm,                             // llvm.nvvm.ull2f.rm
+    nvvm_ull2f_rn,                             // llvm.nvvm.ull2f.rn
+    nvvm_ull2f_rp,                             // llvm.nvvm.ull2f.rp
+    nvvm_ull2f_rz,                             // llvm.nvvm.ull2f.rz
+    nvvm_vote_all,                             // llvm.nvvm.vote.all
+    nvvm_vote_all_sync,                        // llvm.nvvm.vote.all.sync
+    nvvm_vote_any,                             // llvm.nvvm.vote.any
+    nvvm_vote_any_sync,                        // llvm.nvvm.vote.any.sync
+    nvvm_vote_ballot,                          // llvm.nvvm.vote.ballot
+    nvvm_vote_ballot_sync,                     // llvm.nvvm.vote.ballot.sync
+    nvvm_vote_uni,                             // llvm.nvvm.vote.uni
+    nvvm_vote_uni_sync,                        // llvm.nvvm.vote.uni.sync
+    nvvm_wmma_m16n16k16_load_a_f16_col,        // llvm.nvvm.wmma.m16n16k16.load.a.col.f16
+    nvvm_wmma_m16n16k16_load_a_s8_col,         // llvm.nvvm.wmma.m16n16k16.load.a.col.s8
+    nvvm_wmma_m16n16k16_load_a_f16_col_stride,  // llvm.nvvm.wmma.m16n16k16.load.a.col.stride.f16
+    nvvm_wmma_m16n16k16_load_a_s8_col_stride,  // llvm.nvvm.wmma.m16n16k16.load.a.col.stride.s8
+    nvvm_wmma_m16n16k16_load_a_u8_col_stride,  // llvm.nvvm.wmma.m16n16k16.load.a.col.stride.u8
+    nvvm_wmma_m16n16k16_load_a_u8_col,         // llvm.nvvm.wmma.m16n16k16.load.a.col.u8
+    nvvm_wmma_m16n16k16_load_a_f16_row,        // llvm.nvvm.wmma.m16n16k16.load.a.row.f16
+    nvvm_wmma_m16n16k16_load_a_s8_row,         // llvm.nvvm.wmma.m16n16k16.load.a.row.s8
+    nvvm_wmma_m16n16k16_load_a_f16_row_stride,  // llvm.nvvm.wmma.m16n16k16.load.a.row.stride.f16
+    nvvm_wmma_m16n16k16_load_a_s8_row_stride,  // llvm.nvvm.wmma.m16n16k16.load.a.row.stride.s8
+    nvvm_wmma_m16n16k16_load_a_u8_row_stride,  // llvm.nvvm.wmma.m16n16k16.load.a.row.stride.u8
+    nvvm_wmma_m16n16k16_load_a_u8_row,         // llvm.nvvm.wmma.m16n16k16.load.a.row.u8
+    nvvm_wmma_m16n16k16_load_b_f16_col,        // llvm.nvvm.wmma.m16n16k16.load.b.col.f16
+    nvvm_wmma_m16n16k16_load_b_s8_col,         // llvm.nvvm.wmma.m16n16k16.load.b.col.s8
+    nvvm_wmma_m16n16k16_load_b_f16_col_stride,  // llvm.nvvm.wmma.m16n16k16.load.b.col.stride.f16
+    nvvm_wmma_m16n16k16_load_b_s8_col_stride,  // llvm.nvvm.wmma.m16n16k16.load.b.col.stride.s8
+    nvvm_wmma_m16n16k16_load_b_u8_col_stride,  // llvm.nvvm.wmma.m16n16k16.load.b.col.stride.u8
+    nvvm_wmma_m16n16k16_load_b_u8_col,         // llvm.nvvm.wmma.m16n16k16.load.b.col.u8
+    nvvm_wmma_m16n16k16_load_b_f16_row,        // llvm.nvvm.wmma.m16n16k16.load.b.row.f16
+    nvvm_wmma_m16n16k16_load_b_s8_row,         // llvm.nvvm.wmma.m16n16k16.load.b.row.s8
+    nvvm_wmma_m16n16k16_load_b_f16_row_stride,  // llvm.nvvm.wmma.m16n16k16.load.b.row.stride.f16
+    nvvm_wmma_m16n16k16_load_b_s8_row_stride,  // llvm.nvvm.wmma.m16n16k16.load.b.row.stride.s8
+    nvvm_wmma_m16n16k16_load_b_u8_row_stride,  // llvm.nvvm.wmma.m16n16k16.load.b.row.stride.u8
+    nvvm_wmma_m16n16k16_load_b_u8_row,         // llvm.nvvm.wmma.m16n16k16.load.b.row.u8
+    nvvm_wmma_m16n16k16_load_c_f16_col,        // llvm.nvvm.wmma.m16n16k16.load.c.col.f16
+    nvvm_wmma_m16n16k16_load_c_f32_col,        // llvm.nvvm.wmma.m16n16k16.load.c.col.f32
+    nvvm_wmma_m16n16k16_load_c_s32_col,        // llvm.nvvm.wmma.m16n16k16.load.c.col.s32
+    nvvm_wmma_m16n16k16_load_c_f16_col_stride,  // llvm.nvvm.wmma.m16n16k16.load.c.col.stride.f16
+    nvvm_wmma_m16n16k16_load_c_f32_col_stride,  // llvm.nvvm.wmma.m16n16k16.load.c.col.stride.f32
+    nvvm_wmma_m16n16k16_load_c_s32_col_stride,  // llvm.nvvm.wmma.m16n16k16.load.c.col.stride.s32
+    nvvm_wmma_m16n16k16_load_c_f16_row,        // llvm.nvvm.wmma.m16n16k16.load.c.row.f16
+    nvvm_wmma_m16n16k16_load_c_f32_row,        // llvm.nvvm.wmma.m16n16k16.load.c.row.f32
+    nvvm_wmma_m16n16k16_load_c_s32_row,        // llvm.nvvm.wmma.m16n16k16.load.c.row.s32
+    nvvm_wmma_m16n16k16_load_c_f16_row_stride,  // llvm.nvvm.wmma.m16n16k16.load.c.row.stride.f16
+    nvvm_wmma_m16n16k16_load_c_f32_row_stride,  // llvm.nvvm.wmma.m16n16k16.load.c.row.stride.f32
+    nvvm_wmma_m16n16k16_load_c_s32_row_stride,  // llvm.nvvm.wmma.m16n16k16.load.c.row.stride.s32
+    nvvm_wmma_m16n16k16_mma_col_col_f16_f16,   // llvm.nvvm.wmma.m16n16k16.mma.col.col.f16.f16
+    nvvm_wmma_m16n16k16_mma_col_col_f16_f16_satfinite,  // llvm.nvvm.wmma.m16n16k16.mma.col.col.f16.f16.satfinite
+    nvvm_wmma_m16n16k16_mma_col_col_f16_f32,   // llvm.nvvm.wmma.m16n16k16.mma.col.col.f16.f32
+    nvvm_wmma_m16n16k16_mma_col_col_f16_f32_satfinite,  // llvm.nvvm.wmma.m16n16k16.mma.col.col.f16.f32.satfinite
+    nvvm_wmma_m16n16k16_mma_col_col_f32_f16,   // llvm.nvvm.wmma.m16n16k16.mma.col.col.f32.f16
+    nvvm_wmma_m16n16k16_mma_col_col_f32_f16_satfinite,  // llvm.nvvm.wmma.m16n16k16.mma.col.col.f32.f16.satfinite
+    nvvm_wmma_m16n16k16_mma_col_col_f32_f32,   // llvm.nvvm.wmma.m16n16k16.mma.col.col.f32.f32
+    nvvm_wmma_m16n16k16_mma_col_col_f32_f32_satfinite,  // llvm.nvvm.wmma.m16n16k16.mma.col.col.f32.f32.satfinite
+    nvvm_wmma_m16n16k16_mma_col_col_s8,        // llvm.nvvm.wmma.m16n16k16.mma.col.col.s8
+    nvvm_wmma_m16n16k16_mma_col_col_s8_satfinite,  // llvm.nvvm.wmma.m16n16k16.mma.col.col.s8.satfinite
+    nvvm_wmma_m16n16k16_mma_col_col_u8,        // llvm.nvvm.wmma.m16n16k16.mma.col.col.u8
+    nvvm_wmma_m16n16k16_mma_col_col_u8_satfinite,  // llvm.nvvm.wmma.m16n16k16.mma.col.col.u8.satfinite
+    nvvm_wmma_m16n16k16_mma_col_row_f16_f16,   // llvm.nvvm.wmma.m16n16k16.mma.col.row.f16.f16
+    nvvm_wmma_m16n16k16_mma_col_row_f16_f16_satfinite,  // llvm.nvvm.wmma.m16n16k16.mma.col.row.f16.f16.satfinite
+    nvvm_wmma_m16n16k16_mma_col_row_f16_f32,   // llvm.nvvm.wmma.m16n16k16.mma.col.row.f16.f32
+    nvvm_wmma_m16n16k16_mma_col_row_f16_f32_satfinite,  // llvm.nvvm.wmma.m16n16k16.mma.col.row.f16.f32.satfinite
+    nvvm_wmma_m16n16k16_mma_col_row_f32_f16,   // llvm.nvvm.wmma.m16n16k16.mma.col.row.f32.f16
+    nvvm_wmma_m16n16k16_mma_col_row_f32_f16_satfinite,  // llvm.nvvm.wmma.m16n16k16.mma.col.row.f32.f16.satfinite
+    nvvm_wmma_m16n16k16_mma_col_row_f32_f32,   // llvm.nvvm.wmma.m16n16k16.mma.col.row.f32.f32
+    nvvm_wmma_m16n16k16_mma_col_row_f32_f32_satfinite,  // llvm.nvvm.wmma.m16n16k16.mma.col.row.f32.f32.satfinite
+    nvvm_wmma_m16n16k16_mma_col_row_s8,        // llvm.nvvm.wmma.m16n16k16.mma.col.row.s8
+    nvvm_wmma_m16n16k16_mma_col_row_s8_satfinite,  // llvm.nvvm.wmma.m16n16k16.mma.col.row.s8.satfinite
+    nvvm_wmma_m16n16k16_mma_col_row_u8,        // llvm.nvvm.wmma.m16n16k16.mma.col.row.u8
+    nvvm_wmma_m16n16k16_mma_col_row_u8_satfinite,  // llvm.nvvm.wmma.m16n16k16.mma.col.row.u8.satfinite
+    nvvm_wmma_m16n16k16_mma_row_col_f16_f16,   // llvm.nvvm.wmma.m16n16k16.mma.row.col.f16.f16
+    nvvm_wmma_m16n16k16_mma_row_col_f16_f16_satfinite,  // llvm.nvvm.wmma.m16n16k16.mma.row.col.f16.f16.satfinite
+    nvvm_wmma_m16n16k16_mma_row_col_f16_f32,   // llvm.nvvm.wmma.m16n16k16.mma.row.col.f16.f32
+    nvvm_wmma_m16n16k16_mma_row_col_f16_f32_satfinite,  // llvm.nvvm.wmma.m16n16k16.mma.row.col.f16.f32.satfinite
+    nvvm_wmma_m16n16k16_mma_row_col_f32_f16,   // llvm.nvvm.wmma.m16n16k16.mma.row.col.f32.f16
+    nvvm_wmma_m16n16k16_mma_row_col_f32_f16_satfinite,  // llvm.nvvm.wmma.m16n16k16.mma.row.col.f32.f16.satfinite
+    nvvm_wmma_m16n16k16_mma_row_col_f32_f32,   // llvm.nvvm.wmma.m16n16k16.mma.row.col.f32.f32
+    nvvm_wmma_m16n16k16_mma_row_col_f32_f32_satfinite,  // llvm.nvvm.wmma.m16n16k16.mma.row.col.f32.f32.satfinite
+    nvvm_wmma_m16n16k16_mma_row_col_s8,        // llvm.nvvm.wmma.m16n16k16.mma.row.col.s8
+    nvvm_wmma_m16n16k16_mma_row_col_s8_satfinite,  // llvm.nvvm.wmma.m16n16k16.mma.row.col.s8.satfinite
+    nvvm_wmma_m16n16k16_mma_row_col_u8,        // llvm.nvvm.wmma.m16n16k16.mma.row.col.u8
+    nvvm_wmma_m16n16k16_mma_row_col_u8_satfinite,  // llvm.nvvm.wmma.m16n16k16.mma.row.col.u8.satfinite
+    nvvm_wmma_m16n16k16_mma_row_row_f16_f16,   // llvm.nvvm.wmma.m16n16k16.mma.row.row.f16.f16
+    nvvm_wmma_m16n16k16_mma_row_row_f16_f16_satfinite,  // llvm.nvvm.wmma.m16n16k16.mma.row.row.f16.f16.satfinite
+    nvvm_wmma_m16n16k16_mma_row_row_f16_f32,   // llvm.nvvm.wmma.m16n16k16.mma.row.row.f16.f32
+    nvvm_wmma_m16n16k16_mma_row_row_f16_f32_satfinite,  // llvm.nvvm.wmma.m16n16k16.mma.row.row.f16.f32.satfinite
+    nvvm_wmma_m16n16k16_mma_row_row_f32_f16,   // llvm.nvvm.wmma.m16n16k16.mma.row.row.f32.f16
+    nvvm_wmma_m16n16k16_mma_row_row_f32_f16_satfinite,  // llvm.nvvm.wmma.m16n16k16.mma.row.row.f32.f16.satfinite
+    nvvm_wmma_m16n16k16_mma_row_row_f32_f32,   // llvm.nvvm.wmma.m16n16k16.mma.row.row.f32.f32
+    nvvm_wmma_m16n16k16_mma_row_row_f32_f32_satfinite,  // llvm.nvvm.wmma.m16n16k16.mma.row.row.f32.f32.satfinite
+    nvvm_wmma_m16n16k16_mma_row_row_s8,        // llvm.nvvm.wmma.m16n16k16.mma.row.row.s8
+    nvvm_wmma_m16n16k16_mma_row_row_s8_satfinite,  // llvm.nvvm.wmma.m16n16k16.mma.row.row.s8.satfinite
+    nvvm_wmma_m16n16k16_mma_row_row_u8,        // llvm.nvvm.wmma.m16n16k16.mma.row.row.u8
+    nvvm_wmma_m16n16k16_mma_row_row_u8_satfinite,  // llvm.nvvm.wmma.m16n16k16.mma.row.row.u8.satfinite
+    nvvm_wmma_m16n16k16_store_d_f16_col,       // llvm.nvvm.wmma.m16n16k16.store.d.col.f16
+    nvvm_wmma_m16n16k16_store_d_f32_col,       // llvm.nvvm.wmma.m16n16k16.store.d.col.f32
+    nvvm_wmma_m16n16k16_store_d_s32_col,       // llvm.nvvm.wmma.m16n16k16.store.d.col.s32
+    nvvm_wmma_m16n16k16_store_d_f16_col_stride,  // llvm.nvvm.wmma.m16n16k16.store.d.col.stride.f16
+    nvvm_wmma_m16n16k16_store_d_f32_col_stride,  // llvm.nvvm.wmma.m16n16k16.store.d.col.stride.f32
+    nvvm_wmma_m16n16k16_store_d_s32_col_stride,  // llvm.nvvm.wmma.m16n16k16.store.d.col.stride.s32
+    nvvm_wmma_m16n16k16_store_d_f16_row,       // llvm.nvvm.wmma.m16n16k16.store.d.row.f16
+    nvvm_wmma_m16n16k16_store_d_f32_row,       // llvm.nvvm.wmma.m16n16k16.store.d.row.f32
+    nvvm_wmma_m16n16k16_store_d_s32_row,       // llvm.nvvm.wmma.m16n16k16.store.d.row.s32
+    nvvm_wmma_m16n16k16_store_d_f16_row_stride,  // llvm.nvvm.wmma.m16n16k16.store.d.row.stride.f16
+    nvvm_wmma_m16n16k16_store_d_f32_row_stride,  // llvm.nvvm.wmma.m16n16k16.store.d.row.stride.f32
+    nvvm_wmma_m16n16k16_store_d_s32_row_stride,  // llvm.nvvm.wmma.m16n16k16.store.d.row.stride.s32
+    nvvm_wmma_m32n8k16_load_a_f16_col,         // llvm.nvvm.wmma.m32n8k16.load.a.col.f16
+    nvvm_wmma_m32n8k16_load_a_s8_col,          // llvm.nvvm.wmma.m32n8k16.load.a.col.s8
+    nvvm_wmma_m32n8k16_load_a_f16_col_stride,  // llvm.nvvm.wmma.m32n8k16.load.a.col.stride.f16
+    nvvm_wmma_m32n8k16_load_a_s8_col_stride,   // llvm.nvvm.wmma.m32n8k16.load.a.col.stride.s8
+    nvvm_wmma_m32n8k16_load_a_u8_col_stride,   // llvm.nvvm.wmma.m32n8k16.load.a.col.stride.u8
+    nvvm_wmma_m32n8k16_load_a_u8_col,          // llvm.nvvm.wmma.m32n8k16.load.a.col.u8
+    nvvm_wmma_m32n8k16_load_a_f16_row,         // llvm.nvvm.wmma.m32n8k16.load.a.row.f16
+    nvvm_wmma_m32n8k16_load_a_s8_row,          // llvm.nvvm.wmma.m32n8k16.load.a.row.s8
+    nvvm_wmma_m32n8k16_load_a_f16_row_stride,  // llvm.nvvm.wmma.m32n8k16.load.a.row.stride.f16
+    nvvm_wmma_m32n8k16_load_a_s8_row_stride,   // llvm.nvvm.wmma.m32n8k16.load.a.row.stride.s8
+    nvvm_wmma_m32n8k16_load_a_u8_row_stride,   // llvm.nvvm.wmma.m32n8k16.load.a.row.stride.u8
+    nvvm_wmma_m32n8k16_load_a_u8_row,          // llvm.nvvm.wmma.m32n8k16.load.a.row.u8
+    nvvm_wmma_m32n8k16_load_b_f16_col,         // llvm.nvvm.wmma.m32n8k16.load.b.col.f16
+    nvvm_wmma_m32n8k16_load_b_s8_col,          // llvm.nvvm.wmma.m32n8k16.load.b.col.s8
+    nvvm_wmma_m32n8k16_load_b_f16_col_stride,  // llvm.nvvm.wmma.m32n8k16.load.b.col.stride.f16
+    nvvm_wmma_m32n8k16_load_b_s8_col_stride,   // llvm.nvvm.wmma.m32n8k16.load.b.col.stride.s8
+    nvvm_wmma_m32n8k16_load_b_u8_col_stride,   // llvm.nvvm.wmma.m32n8k16.load.b.col.stride.u8
+    nvvm_wmma_m32n8k16_load_b_u8_col,          // llvm.nvvm.wmma.m32n8k16.load.b.col.u8
+    nvvm_wmma_m32n8k16_load_b_f16_row,         // llvm.nvvm.wmma.m32n8k16.load.b.row.f16
+    nvvm_wmma_m32n8k16_load_b_s8_row,          // llvm.nvvm.wmma.m32n8k16.load.b.row.s8
+    nvvm_wmma_m32n8k16_load_b_f16_row_stride,  // llvm.nvvm.wmma.m32n8k16.load.b.row.stride.f16
+    nvvm_wmma_m32n8k16_load_b_s8_row_stride,   // llvm.nvvm.wmma.m32n8k16.load.b.row.stride.s8
+    nvvm_wmma_m32n8k16_load_b_u8_row_stride,   // llvm.nvvm.wmma.m32n8k16.load.b.row.stride.u8
+    nvvm_wmma_m32n8k16_load_b_u8_row,          // llvm.nvvm.wmma.m32n8k16.load.b.row.u8
+    nvvm_wmma_m32n8k16_load_c_f16_col,         // llvm.nvvm.wmma.m32n8k16.load.c.col.f16
+    nvvm_wmma_m32n8k16_load_c_f32_col,         // llvm.nvvm.wmma.m32n8k16.load.c.col.f32
+    nvvm_wmma_m32n8k16_load_c_s32_col,         // llvm.nvvm.wmma.m32n8k16.load.c.col.s32
+    nvvm_wmma_m32n8k16_load_c_f16_col_stride,  // llvm.nvvm.wmma.m32n8k16.load.c.col.stride.f16
+    nvvm_wmma_m32n8k16_load_c_f32_col_stride,  // llvm.nvvm.wmma.m32n8k16.load.c.col.stride.f32
+    nvvm_wmma_m32n8k16_load_c_s32_col_stride,  // llvm.nvvm.wmma.m32n8k16.load.c.col.stride.s32
+    nvvm_wmma_m32n8k16_load_c_f16_row,         // llvm.nvvm.wmma.m32n8k16.load.c.row.f16
+    nvvm_wmma_m32n8k16_load_c_f32_row,         // llvm.nvvm.wmma.m32n8k16.load.c.row.f32
+    nvvm_wmma_m32n8k16_load_c_s32_row,         // llvm.nvvm.wmma.m32n8k16.load.c.row.s32
+    nvvm_wmma_m32n8k16_load_c_f16_row_stride,  // llvm.nvvm.wmma.m32n8k16.load.c.row.stride.f16
+    nvvm_wmma_m32n8k16_load_c_f32_row_stride,  // llvm.nvvm.wmma.m32n8k16.load.c.row.stride.f32
+    nvvm_wmma_m32n8k16_load_c_s32_row_stride,  // llvm.nvvm.wmma.m32n8k16.load.c.row.stride.s32
+    nvvm_wmma_m32n8k16_mma_col_col_f16_f16,    // llvm.nvvm.wmma.m32n8k16.mma.col.col.f16.f16
+    nvvm_wmma_m32n8k16_mma_col_col_f16_f16_satfinite,  // llvm.nvvm.wmma.m32n8k16.mma.col.col.f16.f16.satfinite
+    nvvm_wmma_m32n8k16_mma_col_col_f16_f32,    // llvm.nvvm.wmma.m32n8k16.mma.col.col.f16.f32
+    nvvm_wmma_m32n8k16_mma_col_col_f16_f32_satfinite,  // llvm.nvvm.wmma.m32n8k16.mma.col.col.f16.f32.satfinite
+    nvvm_wmma_m32n8k16_mma_col_col_f32_f16,    // llvm.nvvm.wmma.m32n8k16.mma.col.col.f32.f16
+    nvvm_wmma_m32n8k16_mma_col_col_f32_f16_satfinite,  // llvm.nvvm.wmma.m32n8k16.mma.col.col.f32.f16.satfinite
+    nvvm_wmma_m32n8k16_mma_col_col_f32_f32,    // llvm.nvvm.wmma.m32n8k16.mma.col.col.f32.f32
+    nvvm_wmma_m32n8k16_mma_col_col_f32_f32_satfinite,  // llvm.nvvm.wmma.m32n8k16.mma.col.col.f32.f32.satfinite
+    nvvm_wmma_m32n8k16_mma_col_col_s8,         // llvm.nvvm.wmma.m32n8k16.mma.col.col.s8
+    nvvm_wmma_m32n8k16_mma_col_col_s8_satfinite,  // llvm.nvvm.wmma.m32n8k16.mma.col.col.s8.satfinite
+    nvvm_wmma_m32n8k16_mma_col_col_u8,         // llvm.nvvm.wmma.m32n8k16.mma.col.col.u8
+    nvvm_wmma_m32n8k16_mma_col_col_u8_satfinite,  // llvm.nvvm.wmma.m32n8k16.mma.col.col.u8.satfinite
+    nvvm_wmma_m32n8k16_mma_col_row_f16_f16,    // llvm.nvvm.wmma.m32n8k16.mma.col.row.f16.f16
+    nvvm_wmma_m32n8k16_mma_col_row_f16_f16_satfinite,  // llvm.nvvm.wmma.m32n8k16.mma.col.row.f16.f16.satfinite
+    nvvm_wmma_m32n8k16_mma_col_row_f16_f32,    // llvm.nvvm.wmma.m32n8k16.mma.col.row.f16.f32
+    nvvm_wmma_m32n8k16_mma_col_row_f16_f32_satfinite,  // llvm.nvvm.wmma.m32n8k16.mma.col.row.f16.f32.satfinite
+    nvvm_wmma_m32n8k16_mma_col_row_f32_f16,    // llvm.nvvm.wmma.m32n8k16.mma.col.row.f32.f16
+    nvvm_wmma_m32n8k16_mma_col_row_f32_f16_satfinite,  // llvm.nvvm.wmma.m32n8k16.mma.col.row.f32.f16.satfinite
+    nvvm_wmma_m32n8k16_mma_col_row_f32_f32,    // llvm.nvvm.wmma.m32n8k16.mma.col.row.f32.f32
+    nvvm_wmma_m32n8k16_mma_col_row_f32_f32_satfinite,  // llvm.nvvm.wmma.m32n8k16.mma.col.row.f32.f32.satfinite
+    nvvm_wmma_m32n8k16_mma_col_row_s8,         // llvm.nvvm.wmma.m32n8k16.mma.col.row.s8
+    nvvm_wmma_m32n8k16_mma_col_row_s8_satfinite,  // llvm.nvvm.wmma.m32n8k16.mma.col.row.s8.satfinite
+    nvvm_wmma_m32n8k16_mma_col_row_u8,         // llvm.nvvm.wmma.m32n8k16.mma.col.row.u8
+    nvvm_wmma_m32n8k16_mma_col_row_u8_satfinite,  // llvm.nvvm.wmma.m32n8k16.mma.col.row.u8.satfinite
+    nvvm_wmma_m32n8k16_mma_row_col_f16_f16,    // llvm.nvvm.wmma.m32n8k16.mma.row.col.f16.f16
+    nvvm_wmma_m32n8k16_mma_row_col_f16_f16_satfinite,  // llvm.nvvm.wmma.m32n8k16.mma.row.col.f16.f16.satfinite
+    nvvm_wmma_m32n8k16_mma_row_col_f16_f32,    // llvm.nvvm.wmma.m32n8k16.mma.row.col.f16.f32
+    nvvm_wmma_m32n8k16_mma_row_col_f16_f32_satfinite,  // llvm.nvvm.wmma.m32n8k16.mma.row.col.f16.f32.satfinite
+    nvvm_wmma_m32n8k16_mma_row_col_f32_f16,    // llvm.nvvm.wmma.m32n8k16.mma.row.col.f32.f16
+    nvvm_wmma_m32n8k16_mma_row_col_f32_f16_satfinite,  // llvm.nvvm.wmma.m32n8k16.mma.row.col.f32.f16.satfinite
+    nvvm_wmma_m32n8k16_mma_row_col_f32_f32,    // llvm.nvvm.wmma.m32n8k16.mma.row.col.f32.f32
+    nvvm_wmma_m32n8k16_mma_row_col_f32_f32_satfinite,  // llvm.nvvm.wmma.m32n8k16.mma.row.col.f32.f32.satfinite
+    nvvm_wmma_m32n8k16_mma_row_col_s8,         // llvm.nvvm.wmma.m32n8k16.mma.row.col.s8
+    nvvm_wmma_m32n8k16_mma_row_col_s8_satfinite,  // llvm.nvvm.wmma.m32n8k16.mma.row.col.s8.satfinite
+    nvvm_wmma_m32n8k16_mma_row_col_u8,         // llvm.nvvm.wmma.m32n8k16.mma.row.col.u8
+    nvvm_wmma_m32n8k16_mma_row_col_u8_satfinite,  // llvm.nvvm.wmma.m32n8k16.mma.row.col.u8.satfinite
+    nvvm_wmma_m32n8k16_mma_row_row_f16_f16,    // llvm.nvvm.wmma.m32n8k16.mma.row.row.f16.f16
+    nvvm_wmma_m32n8k16_mma_row_row_f16_f16_satfinite,  // llvm.nvvm.wmma.m32n8k16.mma.row.row.f16.f16.satfinite
+    nvvm_wmma_m32n8k16_mma_row_row_f16_f32,    // llvm.nvvm.wmma.m32n8k16.mma.row.row.f16.f32
+    nvvm_wmma_m32n8k16_mma_row_row_f16_f32_satfinite,  // llvm.nvvm.wmma.m32n8k16.mma.row.row.f16.f32.satfinite
+    nvvm_wmma_m32n8k16_mma_row_row_f32_f16,    // llvm.nvvm.wmma.m32n8k16.mma.row.row.f32.f16
+    nvvm_wmma_m32n8k16_mma_row_row_f32_f16_satfinite,  // llvm.nvvm.wmma.m32n8k16.mma.row.row.f32.f16.satfinite
+    nvvm_wmma_m32n8k16_mma_row_row_f32_f32,    // llvm.nvvm.wmma.m32n8k16.mma.row.row.f32.f32
+    nvvm_wmma_m32n8k16_mma_row_row_f32_f32_satfinite,  // llvm.nvvm.wmma.m32n8k16.mma.row.row.f32.f32.satfinite
+    nvvm_wmma_m32n8k16_mma_row_row_s8,         // llvm.nvvm.wmma.m32n8k16.mma.row.row.s8
+    nvvm_wmma_m32n8k16_mma_row_row_s8_satfinite,  // llvm.nvvm.wmma.m32n8k16.mma.row.row.s8.satfinite
+    nvvm_wmma_m32n8k16_mma_row_row_u8,         // llvm.nvvm.wmma.m32n8k16.mma.row.row.u8
+    nvvm_wmma_m32n8k16_mma_row_row_u8_satfinite,  // llvm.nvvm.wmma.m32n8k16.mma.row.row.u8.satfinite
+    nvvm_wmma_m32n8k16_store_d_f16_col,        // llvm.nvvm.wmma.m32n8k16.store.d.col.f16
+    nvvm_wmma_m32n8k16_store_d_f32_col,        // llvm.nvvm.wmma.m32n8k16.store.d.col.f32
+    nvvm_wmma_m32n8k16_store_d_s32_col,        // llvm.nvvm.wmma.m32n8k16.store.d.col.s32
+    nvvm_wmma_m32n8k16_store_d_f16_col_stride,  // llvm.nvvm.wmma.m32n8k16.store.d.col.stride.f16
+    nvvm_wmma_m32n8k16_store_d_f32_col_stride,  // llvm.nvvm.wmma.m32n8k16.store.d.col.stride.f32
+    nvvm_wmma_m32n8k16_store_d_s32_col_stride,  // llvm.nvvm.wmma.m32n8k16.store.d.col.stride.s32
+    nvvm_wmma_m32n8k16_store_d_f16_row,        // llvm.nvvm.wmma.m32n8k16.store.d.row.f16
+    nvvm_wmma_m32n8k16_store_d_f32_row,        // llvm.nvvm.wmma.m32n8k16.store.d.row.f32
+    nvvm_wmma_m32n8k16_store_d_s32_row,        // llvm.nvvm.wmma.m32n8k16.store.d.row.s32
+    nvvm_wmma_m32n8k16_store_d_f16_row_stride,  // llvm.nvvm.wmma.m32n8k16.store.d.row.stride.f16
+    nvvm_wmma_m32n8k16_store_d_f32_row_stride,  // llvm.nvvm.wmma.m32n8k16.store.d.row.stride.f32
+    nvvm_wmma_m32n8k16_store_d_s32_row_stride,  // llvm.nvvm.wmma.m32n8k16.store.d.row.stride.s32
+    nvvm_wmma_m8n32k16_load_a_f16_col,         // llvm.nvvm.wmma.m8n32k16.load.a.col.f16
+    nvvm_wmma_m8n32k16_load_a_s8_col,          // llvm.nvvm.wmma.m8n32k16.load.a.col.s8
+    nvvm_wmma_m8n32k16_load_a_f16_col_stride,  // llvm.nvvm.wmma.m8n32k16.load.a.col.stride.f16
+    nvvm_wmma_m8n32k16_load_a_s8_col_stride,   // llvm.nvvm.wmma.m8n32k16.load.a.col.stride.s8
+    nvvm_wmma_m8n32k16_load_a_u8_col_stride,   // llvm.nvvm.wmma.m8n32k16.load.a.col.stride.u8
+    nvvm_wmma_m8n32k16_load_a_u8_col,          // llvm.nvvm.wmma.m8n32k16.load.a.col.u8
+    nvvm_wmma_m8n32k16_load_a_f16_row,         // llvm.nvvm.wmma.m8n32k16.load.a.row.f16
+    nvvm_wmma_m8n32k16_load_a_s8_row,          // llvm.nvvm.wmma.m8n32k16.load.a.row.s8
+    nvvm_wmma_m8n32k16_load_a_f16_row_stride,  // llvm.nvvm.wmma.m8n32k16.load.a.row.stride.f16
+    nvvm_wmma_m8n32k16_load_a_s8_row_stride,   // llvm.nvvm.wmma.m8n32k16.load.a.row.stride.s8
+    nvvm_wmma_m8n32k16_load_a_u8_row_stride,   // llvm.nvvm.wmma.m8n32k16.load.a.row.stride.u8
+    nvvm_wmma_m8n32k16_load_a_u8_row,          // llvm.nvvm.wmma.m8n32k16.load.a.row.u8
+    nvvm_wmma_m8n32k16_load_b_f16_col,         // llvm.nvvm.wmma.m8n32k16.load.b.col.f16
+    nvvm_wmma_m8n32k16_load_b_s8_col,          // llvm.nvvm.wmma.m8n32k16.load.b.col.s8
+    nvvm_wmma_m8n32k16_load_b_f16_col_stride,  // llvm.nvvm.wmma.m8n32k16.load.b.col.stride.f16
+    nvvm_wmma_m8n32k16_load_b_s8_col_stride,   // llvm.nvvm.wmma.m8n32k16.load.b.col.stride.s8
+    nvvm_wmma_m8n32k16_load_b_u8_col_stride,   // llvm.nvvm.wmma.m8n32k16.load.b.col.stride.u8
+    nvvm_wmma_m8n32k16_load_b_u8_col,          // llvm.nvvm.wmma.m8n32k16.load.b.col.u8
+    nvvm_wmma_m8n32k16_load_b_f16_row,         // llvm.nvvm.wmma.m8n32k16.load.b.row.f16
+    nvvm_wmma_m8n32k16_load_b_s8_row,          // llvm.nvvm.wmma.m8n32k16.load.b.row.s8
+    nvvm_wmma_m8n32k16_load_b_f16_row_stride,  // llvm.nvvm.wmma.m8n32k16.load.b.row.stride.f16
+    nvvm_wmma_m8n32k16_load_b_s8_row_stride,   // llvm.nvvm.wmma.m8n32k16.load.b.row.stride.s8
+    nvvm_wmma_m8n32k16_load_b_u8_row_stride,   // llvm.nvvm.wmma.m8n32k16.load.b.row.stride.u8
+    nvvm_wmma_m8n32k16_load_b_u8_row,          // llvm.nvvm.wmma.m8n32k16.load.b.row.u8
+    nvvm_wmma_m8n32k16_load_c_f16_col,         // llvm.nvvm.wmma.m8n32k16.load.c.col.f16
+    nvvm_wmma_m8n32k16_load_c_f32_col,         // llvm.nvvm.wmma.m8n32k16.load.c.col.f32
+    nvvm_wmma_m8n32k16_load_c_s32_col,         // llvm.nvvm.wmma.m8n32k16.load.c.col.s32
+    nvvm_wmma_m8n32k16_load_c_f16_col_stride,  // llvm.nvvm.wmma.m8n32k16.load.c.col.stride.f16
+    nvvm_wmma_m8n32k16_load_c_f32_col_stride,  // llvm.nvvm.wmma.m8n32k16.load.c.col.stride.f32
+    nvvm_wmma_m8n32k16_load_c_s32_col_stride,  // llvm.nvvm.wmma.m8n32k16.load.c.col.stride.s32
+    nvvm_wmma_m8n32k16_load_c_f16_row,         // llvm.nvvm.wmma.m8n32k16.load.c.row.f16
+    nvvm_wmma_m8n32k16_load_c_f32_row,         // llvm.nvvm.wmma.m8n32k16.load.c.row.f32
+    nvvm_wmma_m8n32k16_load_c_s32_row,         // llvm.nvvm.wmma.m8n32k16.load.c.row.s32
+    nvvm_wmma_m8n32k16_load_c_f16_row_stride,  // llvm.nvvm.wmma.m8n32k16.load.c.row.stride.f16
+    nvvm_wmma_m8n32k16_load_c_f32_row_stride,  // llvm.nvvm.wmma.m8n32k16.load.c.row.stride.f32
+    nvvm_wmma_m8n32k16_load_c_s32_row_stride,  // llvm.nvvm.wmma.m8n32k16.load.c.row.stride.s32
+    nvvm_wmma_m8n32k16_mma_col_col_f16_f16,    // llvm.nvvm.wmma.m8n32k16.mma.col.col.f16.f16
+    nvvm_wmma_m8n32k16_mma_col_col_f16_f16_satfinite,  // llvm.nvvm.wmma.m8n32k16.mma.col.col.f16.f16.satfinite
+    nvvm_wmma_m8n32k16_mma_col_col_f16_f32,    // llvm.nvvm.wmma.m8n32k16.mma.col.col.f16.f32
+    nvvm_wmma_m8n32k16_mma_col_col_f16_f32_satfinite,  // llvm.nvvm.wmma.m8n32k16.mma.col.col.f16.f32.satfinite
+    nvvm_wmma_m8n32k16_mma_col_col_f32_f16,    // llvm.nvvm.wmma.m8n32k16.mma.col.col.f32.f16
+    nvvm_wmma_m8n32k16_mma_col_col_f32_f16_satfinite,  // llvm.nvvm.wmma.m8n32k16.mma.col.col.f32.f16.satfinite
+    nvvm_wmma_m8n32k16_mma_col_col_f32_f32,    // llvm.nvvm.wmma.m8n32k16.mma.col.col.f32.f32
+    nvvm_wmma_m8n32k16_mma_col_col_f32_f32_satfinite,  // llvm.nvvm.wmma.m8n32k16.mma.col.col.f32.f32.satfinite
+    nvvm_wmma_m8n32k16_mma_col_col_s8,         // llvm.nvvm.wmma.m8n32k16.mma.col.col.s8
+    nvvm_wmma_m8n32k16_mma_col_col_s8_satfinite,  // llvm.nvvm.wmma.m8n32k16.mma.col.col.s8.satfinite
+    nvvm_wmma_m8n32k16_mma_col_col_u8,         // llvm.nvvm.wmma.m8n32k16.mma.col.col.u8
+    nvvm_wmma_m8n32k16_mma_col_col_u8_satfinite,  // llvm.nvvm.wmma.m8n32k16.mma.col.col.u8.satfinite
+    nvvm_wmma_m8n32k16_mma_col_row_f16_f16,    // llvm.nvvm.wmma.m8n32k16.mma.col.row.f16.f16
+    nvvm_wmma_m8n32k16_mma_col_row_f16_f16_satfinite,  // llvm.nvvm.wmma.m8n32k16.mma.col.row.f16.f16.satfinite
+    nvvm_wmma_m8n32k16_mma_col_row_f16_f32,    // llvm.nvvm.wmma.m8n32k16.mma.col.row.f16.f32
+    nvvm_wmma_m8n32k16_mma_col_row_f16_f32_satfinite,  // llvm.nvvm.wmma.m8n32k16.mma.col.row.f16.f32.satfinite
+    nvvm_wmma_m8n32k16_mma_col_row_f32_f16,    // llvm.nvvm.wmma.m8n32k16.mma.col.row.f32.f16
+    nvvm_wmma_m8n32k16_mma_col_row_f32_f16_satfinite,  // llvm.nvvm.wmma.m8n32k16.mma.col.row.f32.f16.satfinite
+    nvvm_wmma_m8n32k16_mma_col_row_f32_f32,    // llvm.nvvm.wmma.m8n32k16.mma.col.row.f32.f32
+    nvvm_wmma_m8n32k16_mma_col_row_f32_f32_satfinite,  // llvm.nvvm.wmma.m8n32k16.mma.col.row.f32.f32.satfinite
+    nvvm_wmma_m8n32k16_mma_col_row_s8,         // llvm.nvvm.wmma.m8n32k16.mma.col.row.s8
+    nvvm_wmma_m8n32k16_mma_col_row_s8_satfinite,  // llvm.nvvm.wmma.m8n32k16.mma.col.row.s8.satfinite
+    nvvm_wmma_m8n32k16_mma_col_row_u8,         // llvm.nvvm.wmma.m8n32k16.mma.col.row.u8
+    nvvm_wmma_m8n32k16_mma_col_row_u8_satfinite,  // llvm.nvvm.wmma.m8n32k16.mma.col.row.u8.satfinite
+    nvvm_wmma_m8n32k16_mma_row_col_f16_f16,    // llvm.nvvm.wmma.m8n32k16.mma.row.col.f16.f16
+    nvvm_wmma_m8n32k16_mma_row_col_f16_f16_satfinite,  // llvm.nvvm.wmma.m8n32k16.mma.row.col.f16.f16.satfinite
+    nvvm_wmma_m8n32k16_mma_row_col_f16_f32,    // llvm.nvvm.wmma.m8n32k16.mma.row.col.f16.f32
+    nvvm_wmma_m8n32k16_mma_row_col_f16_f32_satfinite,  // llvm.nvvm.wmma.m8n32k16.mma.row.col.f16.f32.satfinite
+    nvvm_wmma_m8n32k16_mma_row_col_f32_f16,    // llvm.nvvm.wmma.m8n32k16.mma.row.col.f32.f16
+    nvvm_wmma_m8n32k16_mma_row_col_f32_f16_satfinite,  // llvm.nvvm.wmma.m8n32k16.mma.row.col.f32.f16.satfinite
+    nvvm_wmma_m8n32k16_mma_row_col_f32_f32,    // llvm.nvvm.wmma.m8n32k16.mma.row.col.f32.f32
+    nvvm_wmma_m8n32k16_mma_row_col_f32_f32_satfinite,  // llvm.nvvm.wmma.m8n32k16.mma.row.col.f32.f32.satfinite
+    nvvm_wmma_m8n32k16_mma_row_col_s8,         // llvm.nvvm.wmma.m8n32k16.mma.row.col.s8
+    nvvm_wmma_m8n32k16_mma_row_col_s8_satfinite,  // llvm.nvvm.wmma.m8n32k16.mma.row.col.s8.satfinite
+    nvvm_wmma_m8n32k16_mma_row_col_u8,         // llvm.nvvm.wmma.m8n32k16.mma.row.col.u8
+    nvvm_wmma_m8n32k16_mma_row_col_u8_satfinite,  // llvm.nvvm.wmma.m8n32k16.mma.row.col.u8.satfinite
+    nvvm_wmma_m8n32k16_mma_row_row_f16_f16,    // llvm.nvvm.wmma.m8n32k16.mma.row.row.f16.f16
+    nvvm_wmma_m8n32k16_mma_row_row_f16_f16_satfinite,  // llvm.nvvm.wmma.m8n32k16.mma.row.row.f16.f16.satfinite
+    nvvm_wmma_m8n32k16_mma_row_row_f16_f32,    // llvm.nvvm.wmma.m8n32k16.mma.row.row.f16.f32
+    nvvm_wmma_m8n32k16_mma_row_row_f16_f32_satfinite,  // llvm.nvvm.wmma.m8n32k16.mma.row.row.f16.f32.satfinite
+    nvvm_wmma_m8n32k16_mma_row_row_f32_f16,    // llvm.nvvm.wmma.m8n32k16.mma.row.row.f32.f16
+    nvvm_wmma_m8n32k16_mma_row_row_f32_f16_satfinite,  // llvm.nvvm.wmma.m8n32k16.mma.row.row.f32.f16.satfinite
+    nvvm_wmma_m8n32k16_mma_row_row_f32_f32,    // llvm.nvvm.wmma.m8n32k16.mma.row.row.f32.f32
+    nvvm_wmma_m8n32k16_mma_row_row_f32_f32_satfinite,  // llvm.nvvm.wmma.m8n32k16.mma.row.row.f32.f32.satfinite
+    nvvm_wmma_m8n32k16_mma_row_row_s8,         // llvm.nvvm.wmma.m8n32k16.mma.row.row.s8
+    nvvm_wmma_m8n32k16_mma_row_row_s8_satfinite,  // llvm.nvvm.wmma.m8n32k16.mma.row.row.s8.satfinite
+    nvvm_wmma_m8n32k16_mma_row_row_u8,         // llvm.nvvm.wmma.m8n32k16.mma.row.row.u8
+    nvvm_wmma_m8n32k16_mma_row_row_u8_satfinite,  // llvm.nvvm.wmma.m8n32k16.mma.row.row.u8.satfinite
+    nvvm_wmma_m8n32k16_store_d_f16_col,        // llvm.nvvm.wmma.m8n32k16.store.d.col.f16
+    nvvm_wmma_m8n32k16_store_d_f32_col,        // llvm.nvvm.wmma.m8n32k16.store.d.col.f32
+    nvvm_wmma_m8n32k16_store_d_s32_col,        // llvm.nvvm.wmma.m8n32k16.store.d.col.s32
+    nvvm_wmma_m8n32k16_store_d_f16_col_stride,  // llvm.nvvm.wmma.m8n32k16.store.d.col.stride.f16
+    nvvm_wmma_m8n32k16_store_d_f32_col_stride,  // llvm.nvvm.wmma.m8n32k16.store.d.col.stride.f32
+    nvvm_wmma_m8n32k16_store_d_s32_col_stride,  // llvm.nvvm.wmma.m8n32k16.store.d.col.stride.s32
+    nvvm_wmma_m8n32k16_store_d_f16_row,        // llvm.nvvm.wmma.m8n32k16.store.d.row.f16
+    nvvm_wmma_m8n32k16_store_d_f32_row,        // llvm.nvvm.wmma.m8n32k16.store.d.row.f32
+    nvvm_wmma_m8n32k16_store_d_s32_row,        // llvm.nvvm.wmma.m8n32k16.store.d.row.s32
+    nvvm_wmma_m8n32k16_store_d_f16_row_stride,  // llvm.nvvm.wmma.m8n32k16.store.d.row.stride.f16
+    nvvm_wmma_m8n32k16_store_d_f32_row_stride,  // llvm.nvvm.wmma.m8n32k16.store.d.row.stride.f32
+    nvvm_wmma_m8n32k16_store_d_s32_row_stride,  // llvm.nvvm.wmma.m8n32k16.store.d.row.stride.s32
+    nvvm_wmma_m8n8k128_load_a_b1_row,          // llvm.nvvm.wmma.m8n8k128.load.a.row.b1
+    nvvm_wmma_m8n8k128_load_a_b1_row_stride,   // llvm.nvvm.wmma.m8n8k128.load.a.row.stride.b1
+    nvvm_wmma_m8n8k128_load_b_b1_col,          // llvm.nvvm.wmma.m8n8k128.load.b.col.b1
+    nvvm_wmma_m8n8k128_load_b_b1_col_stride,   // llvm.nvvm.wmma.m8n8k128.load.b.col.stride.b1
+    nvvm_wmma_m8n8k128_load_c_s32_col,         // llvm.nvvm.wmma.m8n8k128.load.c.col.s32
+    nvvm_wmma_m8n8k128_load_c_s32_col_stride,  // llvm.nvvm.wmma.m8n8k128.load.c.col.stride.s32
+    nvvm_wmma_m8n8k128_load_c_s32_row,         // llvm.nvvm.wmma.m8n8k128.load.c.row.s32
+    nvvm_wmma_m8n8k128_load_c_s32_row_stride,  // llvm.nvvm.wmma.m8n8k128.load.c.row.stride.s32
+    nvvm_wmma_m8n8k128_mma_row_col_b1,         // llvm.nvvm.wmma.m8n8k128.mma.row.col.b1
+    nvvm_wmma_m8n8k128_store_d_s32_col,        // llvm.nvvm.wmma.m8n8k128.store.d.col.s32
+    nvvm_wmma_m8n8k128_store_d_s32_col_stride,  // llvm.nvvm.wmma.m8n8k128.store.d.col.stride.s32
+    nvvm_wmma_m8n8k128_store_d_s32_row,        // llvm.nvvm.wmma.m8n8k128.store.d.row.s32
+    nvvm_wmma_m8n8k128_store_d_s32_row_stride,  // llvm.nvvm.wmma.m8n8k128.store.d.row.stride.s32
+    nvvm_wmma_m8n8k32_load_a_s4_row,           // llvm.nvvm.wmma.m8n8k32.load.a.row.s4
+    nvvm_wmma_m8n8k32_load_a_s4_row_stride,    // llvm.nvvm.wmma.m8n8k32.load.a.row.stride.s4
+    nvvm_wmma_m8n8k32_load_a_u4_row_stride,    // llvm.nvvm.wmma.m8n8k32.load.a.row.stride.u4
+    nvvm_wmma_m8n8k32_load_a_u4_row,           // llvm.nvvm.wmma.m8n8k32.load.a.row.u4
+    nvvm_wmma_m8n8k32_load_b_s4_col,           // llvm.nvvm.wmma.m8n8k32.load.b.col.s4
+    nvvm_wmma_m8n8k32_load_b_s4_col_stride,    // llvm.nvvm.wmma.m8n8k32.load.b.col.stride.s4
+    nvvm_wmma_m8n8k32_load_b_u4_col_stride,    // llvm.nvvm.wmma.m8n8k32.load.b.col.stride.u4
+    nvvm_wmma_m8n8k32_load_b_u4_col,           // llvm.nvvm.wmma.m8n8k32.load.b.col.u4
+    nvvm_wmma_m8n8k32_load_c_s32_col,          // llvm.nvvm.wmma.m8n8k32.load.c.col.s32
+    nvvm_wmma_m8n8k32_load_c_s32_col_stride,   // llvm.nvvm.wmma.m8n8k32.load.c.col.stride.s32
+    nvvm_wmma_m8n8k32_load_c_s32_row,          // llvm.nvvm.wmma.m8n8k32.load.c.row.s32
+    nvvm_wmma_m8n8k32_load_c_s32_row_stride,   // llvm.nvvm.wmma.m8n8k32.load.c.row.stride.s32
+    nvvm_wmma_m8n8k32_mma_row_col_s4,          // llvm.nvvm.wmma.m8n8k32.mma.row.col.s4
+    nvvm_wmma_m8n8k32_mma_row_col_s4_satfinite,  // llvm.nvvm.wmma.m8n8k32.mma.row.col.s4.satfinite
+    nvvm_wmma_m8n8k32_mma_row_col_u4,          // llvm.nvvm.wmma.m8n8k32.mma.row.col.u4
+    nvvm_wmma_m8n8k32_mma_row_col_u4_satfinite,  // llvm.nvvm.wmma.m8n8k32.mma.row.col.u4.satfinite
+    nvvm_wmma_m8n8k32_store_d_s32_col,         // llvm.nvvm.wmma.m8n8k32.store.d.col.s32
+    nvvm_wmma_m8n8k32_store_d_s32_col_stride,  // llvm.nvvm.wmma.m8n8k32.store.d.col.stride.s32
+    nvvm_wmma_m8n8k32_store_d_s32_row,         // llvm.nvvm.wmma.m8n8k32.store.d.row.s32
+    nvvm_wmma_m8n8k32_store_d_s32_row_stride,  // llvm.nvvm.wmma.m8n8k32.store.d.row.stride.s32
+}; // enum
+} // namespace Intrinsic
+} // namespace llvm
+
+#endif
diff --git a/linux-x64/clang/include/llvm/IR/IntrinsicsNVVM.td b/linux-x64/clang/include/llvm/IR/IntrinsicsNVVM.td
index 0301e37..2ab48cf 100644
--- a/linux-x64/clang/include/llvm/IR/IntrinsicsNVVM.td
+++ b/linux-x64/clang/include/llvm/IR/IntrinsicsNVVM.td
@@ -37,11 +37,6 @@
 // MISC
 //
 
-// Helper class for construction of n-element list<LLVMtype> [t,t,...,t]
-class RepLLVMType<int N, LLVMType T> {
-  list<LLVMType> ret = !if(N, !listconcat(RepLLVMType<!add(N,-1), T>.ret, [T]), []);
-}
-
 // Helper class that represents a 'fragment' of an NVPTX *MMA instruction.
 // Geom: m<M>n<N>k<K>. E.g. m8n32k16
 // Frag: [abcd]
@@ -53,37 +48,41 @@
   string gft = Geom#":"#Frag#":"#ptx_elt_type;
   string ft = frag#":"#ptx_elt_type;
   list<LLVMType> regs = !cond(
+    // mma.sync.m8n8k4 uses smaller a/b fragments than wmma fp ops
+    !eq(gft,"m8n8k4:a:f16") : !listsplat(llvm_v2f16_ty, 2),
+    !eq(gft,"m8n8k4:b:f16") : !listsplat(llvm_v2f16_ty, 2),
+
     // fp16 -> fp16/fp32 @  m16n16k16/m8n32k16/m32n8k16
     // All currently supported geometries use the same fragment format,
     // so we only need to consider {fragment, type}.
-    !eq(ft,"a:f16") : RepLLVMType<8, llvm_v2f16_ty>.ret,
-    !eq(ft,"b:f16") : RepLLVMType<8, llvm_v2f16_ty>.ret,
-    !eq(ft,"c:f16") : RepLLVMType<4, llvm_v2f16_ty>.ret,
-    !eq(ft,"d:f16") : RepLLVMType<4, llvm_v2f16_ty>.ret,
-    !eq(ft,"c:f32") : RepLLVMType<8, llvm_float_ty>.ret,
-    !eq(ft,"d:f32") : RepLLVMType<8, llvm_float_ty>.ret,
+    !eq(ft,"a:f16") : !listsplat(llvm_v2f16_ty, 8),
+    !eq(ft,"b:f16") : !listsplat(llvm_v2f16_ty, 8),
+    !eq(ft,"c:f16") : !listsplat(llvm_v2f16_ty, 4),
+    !eq(ft,"d:f16") : !listsplat(llvm_v2f16_ty, 4),
+    !eq(ft,"c:f32") : !listsplat(llvm_float_ty, 8),
+    !eq(ft,"d:f32") : !listsplat(llvm_float_ty, 8),
 
     // u8/s8 -> s32 @ m16n16k16/m8n32k16/m32n8k16
-    !eq(gft,"m16n16k16:a:u8") : RepLLVMType<2, llvm_i32_ty>.ret,
-    !eq(gft,"m16n16k16:a:s8") : RepLLVMType<2, llvm_i32_ty>.ret,
-    !eq(gft,"m16n16k16:b:u8") : RepLLVMType<2, llvm_i32_ty>.ret,
-    !eq(gft,"m16n16k16:b:s8") : RepLLVMType<2, llvm_i32_ty>.ret,
-    !eq(gft,"m16n16k16:c:s32") : RepLLVMType<8, llvm_i32_ty>.ret,
-    !eq(gft,"m16n16k16:d:s32") : RepLLVMType<8, llvm_i32_ty>.ret,
+    !eq(gft,"m16n16k16:a:u8") : !listsplat(llvm_i32_ty, 2),
+    !eq(gft,"m16n16k16:a:s8") : !listsplat(llvm_i32_ty, 2),
+    !eq(gft,"m16n16k16:b:u8") : !listsplat(llvm_i32_ty, 2),
+    !eq(gft,"m16n16k16:b:s8") : !listsplat(llvm_i32_ty, 2),
+    !eq(gft,"m16n16k16:c:s32") : !listsplat(llvm_i32_ty, 8),
+    !eq(gft,"m16n16k16:d:s32") : !listsplat(llvm_i32_ty, 8),
 
     !eq(gft,"m8n32k16:a:u8") : [llvm_i32_ty],
     !eq(gft,"m8n32k16:a:s8") : [llvm_i32_ty],
-    !eq(gft,"m8n32k16:b:u8") : RepLLVMType<4, llvm_i32_ty>.ret,
-    !eq(gft,"m8n32k16:b:s8") : RepLLVMType<4, llvm_i32_ty>.ret,
-    !eq(gft,"m8n32k16:c:s32") : RepLLVMType<8, llvm_i32_ty>.ret,
-    !eq(gft,"m8n32k16:d:s32") : RepLLVMType<8, llvm_i32_ty>.ret,
+    !eq(gft,"m8n32k16:b:u8") : !listsplat(llvm_i32_ty, 4),
+    !eq(gft,"m8n32k16:b:s8") : !listsplat(llvm_i32_ty, 4),
+    !eq(gft,"m8n32k16:c:s32") : !listsplat(llvm_i32_ty, 8),
+    !eq(gft,"m8n32k16:d:s32") : !listsplat(llvm_i32_ty, 8),
 
-    !eq(gft,"m32n8k16:a:u8") : RepLLVMType<4, llvm_i32_ty>.ret,
-    !eq(gft,"m32n8k16:a:s8") : RepLLVMType<4, llvm_i32_ty>.ret,
+    !eq(gft,"m32n8k16:a:u8") : !listsplat(llvm_i32_ty, 4),
+    !eq(gft,"m32n8k16:a:s8") : !listsplat(llvm_i32_ty, 4),
     !eq(gft,"m32n8k16:b:u8") : [llvm_i32_ty],
     !eq(gft,"m32n8k16:b:s8") : [llvm_i32_ty],
-    !eq(gft,"m32n8k16:c:s32") : RepLLVMType<8, llvm_i32_ty>.ret,
-    !eq(gft,"m32n8k16:d:s32") : RepLLVMType<8, llvm_i32_ty>.ret,
+    !eq(gft,"m32n8k16:c:s32") : !listsplat(llvm_i32_ty, 8),
+    !eq(gft,"m32n8k16:d:s32") : !listsplat(llvm_i32_ty, 8),
 
     // u4/s4/b1 -> s32 @ m8n8k32 (u4/s4), m8n8k128(b1)
     !eq(gft,"m8n8k128:a:b1") : [llvm_i32_ty],
@@ -92,10 +91,10 @@
     !eq(gft,"m8n8k128:b:b1") : [llvm_i32_ty],
     !eq(gft,"m8n8k32:b:u4") : [llvm_i32_ty],
     !eq(gft,"m8n8k32:b:s4") : [llvm_i32_ty],
-    !eq(gft,"m8n8k128:c:s32") : RepLLVMType<2, llvm_i32_ty>.ret,
-    !eq(gft,"m8n8k128:d:s32") : RepLLVMType<2, llvm_i32_ty>.ret,
-    !eq(gft,"m8n8k32:c:s32") : RepLLVMType<2, llvm_i32_ty>.ret,
-    !eq(gft,"m8n8k32:d:s32") : RepLLVMType<2, llvm_i32_ty>.ret,
+    !eq(gft,"m8n8k128:c:s32") : !listsplat(llvm_i32_ty, 2),
+    !eq(gft,"m8n8k128:d:s32") : !listsplat(llvm_i32_ty, 2),
+    !eq(gft,"m8n8k32:c:s32") : !listsplat(llvm_i32_ty, 2),
+    !eq(gft,"m8n8k32:d:s32") : !listsplat(llvm_i32_ty, 2),
   );
 }
 
@@ -129,7 +128,7 @@
      !eq(A.ptx_elt_type, "u4") : [A],
      !eq(A.ptx_elt_type, "b1") : [A],
      // the rest are FP ops identified by accumulator & result type.
-     1: [D, C]
+     true: [D, C]
      );
    string ret = !foldl("", id_frags, a, b, !strconcat(a, ".", b.ptx_elt_type));
 }
@@ -137,13 +136,19 @@
 class WMMA_NAME_MMA<string ALayout, string BLayout, int Satfinite,
                     WMMA_REGS A, WMMA_REGS B, WMMA_REGS C, WMMA_REGS D> {
   string signature = MMA_SIGNATURE<A, B, C, D>.ret;
-  string llvm = "llvm.nvvm.wmma."
-                # A.geom
-                # ".mma"
-                # "." # ALayout
-                # "." # BLayout
-                # signature
-                # !if(Satfinite, ".satfinite", "");
+  string llvm = !if(
+    !eq(A.geom, "m8n8k4"),
+        "llvm.nvvm.mma.m8n8k4"
+           # "." # ALayout
+           # "." # BLayout
+           # signature,
+        "llvm.nvvm.wmma."
+           # A.geom
+           # ".mma"
+           # "." # ALayout
+           # "." # BLayout
+           # signature
+           # !if(Satfinite, ".satfinite", ""));
 
   string record = !subst(".", "_",
                   !subst("llvm.", "int_", llvm));
@@ -160,7 +165,7 @@
      !foldl([]<list<WMMA_REGS>>, TypeA, t2, type_a, !listconcat(t2,
      !foldl([]<list<WMMA_REGS>>, !if(!size(TypeB), TypeB, [type_a]), t3, type_b, !listconcat(t3,
      !foldl([]<list<WMMA_REGS>>, TypeC, t4, type_c, !listconcat(t4,
-     !foldl([]<list<WMMA_REGS>>, !if(!size(TypeC), TypeC, [type_c]), t5, type_d, !listconcat(t5,
+     !foldl([]<list<WMMA_REGS>>, !if(!size(TypeD), TypeD, [type_c]), t5, type_d, !listconcat(t5,
             [[WMMA_REGS<geom, "a", type_a>,
               WMMA_REGS<geom, "b", type_b>,
               WMMA_REGS<geom, "c", type_c>,
@@ -185,19 +190,23 @@
 // drives generation of corresponding intrinsics and instructions.
 class NVVM_MMA_OPS<int _ = 0> {
   list<list<WMMA_REGS>> fp_mma_ops = MMA_OPS<
+            ["m8n8k4"],
+            ["f16"], [], ["f16", "f32"], ["f16", "f32"]>.ret;
+  list<list<WMMA_REGS>> fp_wmma_ops = MMA_OPS<
             ["m16n16k16", "m32n8k16", "m8n32k16"],
             ["f16"], [], ["f16", "f32"], ["f16", "f32"]>.ret;
-  list<list<WMMA_REGS>> int_mma_ops = MMA_OPS<
+  list<list<WMMA_REGS>> int_wmma_ops = MMA_OPS<
             ["m16n16k16", "m32n8k16", "m8n32k16"],
             ["s8", "u8"], [], ["s32"], []>.ret;
-  list<list<WMMA_REGS>> subint_mma_ops = MMA_OPS<
+  list<list<WMMA_REGS>> subint_wmma_ops = MMA_OPS<
             ["m8n8k32"],
             ["s4", "u4"], [], ["s32"], []>.ret;
-  list<list<WMMA_REGS>> bit_mma_ops = MMA_OPS<
+  list<list<WMMA_REGS>> bit_wmma_ops = MMA_OPS<
             ["m8n8k128"],
             ["b1"], [], ["s32"], []>.ret;
-  list<list<WMMA_REGS>> all_mma_ops = !listconcat(fp_mma_ops, int_mma_ops,
-                                                  subint_mma_ops, bit_mma_ops);
+  list<list<WMMA_REGS>> all_mma_ops = !listconcat(
+            fp_mma_ops, fp_wmma_ops, int_wmma_ops,
+            subint_wmma_ops, bit_wmma_ops);
 
   list<WMMA_REGS> ldst_ab_ops = MMA_LDST_OPS<
             ["m16n16k16", "m32n8k16", "m8n32k16"],
@@ -216,19 +225,17 @@
                                              ldst_bit_ab_ops,
                                              ldst_subint_cd_ops);
   // Separate A/B/C fragments (loads) from D (stores).
-  list<WMMA_REGS> all_ld_ops = !foldl([]<WMMA_REGS>, all_ldst_ops, a, b,
-                                      !listconcat(a, !if(!eq(b.frag,"d"), [],[b])));
-  list<WMMA_REGS> all_st_ops = !foldl([]<WMMA_REGS>, all_ldst_ops, a, b,
-                                      !listconcat(a, !if(!eq(b.frag,"d"), [b],[])));
+  list<WMMA_REGS> all_ld_ops = !filter(op, all_ldst_ops, !ne(op.frag, "d"));
+  list<WMMA_REGS> all_st_ops = !filter(op, all_ldst_ops, !eq(op.frag, "d"));
 }
 
 def NVVM_MMA_OPS : NVVM_MMA_OPS;
 
-// Returns [1] if this combination of layout/satf is supported, [] otherwise.
+// Returns true if this combination of layout/satf is supported; false otherwise.
 // MMA ops must provide all parameters. Loads and stores -- only frags and layout_a.
 // The class is used to prevent generation of records for the unsupported variants.
 // E.g.
-// foreach _ = NVVM_MMA_SUPPORTED<...>.ret in =
+// if NVVM_MMA_SUPPORTED<...>.ret then
 //   def : FOO<>; // The record will only be defined for supported ops.
 //
 class NVVM_MMA_SUPPORTED<list<WMMA_REGS> frags, string layout_a, string layout_b="-", int satf=-1> {
@@ -245,14 +252,29 @@
                # ":" # frags[0].frag
                ;
   string t = frags[0].ptx_elt_type;
-  list<int> ret = !cond(
+
+  // gcd is a shortcut used to identify instructions that depend on
+  // geom+frag_c+frag_d.  Not all instances of this class have all fragments
+  // specified. If there are not enough fragments, the tail evaluates to '?'.
+  string gcd = frags[0].geom
+               # ":"
+               # !if(!eq(!size(frags), 4),
+                     frags[2].ptx_elt_type # frags[3].ptx_elt_type,
+                     "?");
+  bit ret = !cond(
     // Sub-int MMA only supports fixed A/B layout.
     // b1 does not support .satf.
-    !eq(mma#":"#satf, "b1:row:col:0") : [1],
-    !eq(mma, "s4:row:col") : [1],
-    !eq(mma, "u4:row:col") : [1],
-    !eq(mma, "s4:row:col") : [1],
-    !eq(mma, "u4:row:col") : [1],
+    !eq(mma#":"#satf, "b1:row:col:0") : true,
+    // mma.m8n8k4 has no .satf modifier.
+    !and(!eq(frags[0].geom, "m8n8k4"),
+         !ne(satf, 0)): false,
+
+    // mma.m8n8k4 has no C=f32 D=f16 variant.
+    !eq(gcd, "m8n8k4:f32f16"): false,
+    !eq(mma, "s4:row:col") : true,
+    !eq(mma, "u4:row:col") : true,
+    !eq(mma, "s4:row:col") : true,
+    !eq(mma, "u4:row:col") : true,
     // Sub-int load/stores have fixed layout for A and B.
     !and(!eq(layout_b, "-"), // It's a Load or Store op
          !or(!eq(ld,  "b1:a:row"),
@@ -266,16 +288,36 @@
              !eq(ld, "u4:a:row"),
              !eq(ld, "u4:b:col"),
              !eq(ldf, "u4:c"),
-             !eq(ldf, "u4:d"))) : [1],
+             !eq(ldf, "u4:d"))) : true,
     // All other sub-int ops are not supported.
-    !eq(t, "b1") : [],
-    !eq(t, "s4") : [],
-    !eq(t, "u4") : [],
+    !eq(t, "b1") : false,
+    !eq(t, "s4") : false,
+    !eq(t, "u4") : false,
     // All other (non sub-int) are OK.
-    1: [1]
+    true: true
   );
 }
 
+class SHFL_INFO<bit sync, string mode, string type, bit return_pred> {
+  string Suffix = !if(sync, "sync_", "")
+                  # mode # "_"
+                  # type
+                  # !if(return_pred, "p", "");
+
+  string Name = "int_nvvm_shfl_" # Suffix;
+  string Builtin = "__nvvm_shfl_" # Suffix;
+  string IntrName = "llvm.nvvm.shfl." # !subst("_",".", Suffix);
+  bit withGccBuiltin = !not(return_pred);
+  bit withoutGccBuiltin = return_pred;
+  LLVMType OpType = !cond(
+    !eq(type,"i32"): llvm_i32_ty,
+    !eq(type,"f32"): llvm_float_ty);
+  list<LLVMType> RetTy = !if(return_pred, [OpType, llvm_i1_ty], [OpType]);
+  list<LLVMType> ArgsTy = !if(sync,
+    [llvm_i32_ty, OpType, llvm_i32_ty, llvm_i32_ty],
+    [OpType, llvm_i32_ty, llvm_i32_ty]);
+}
+
 let TargetPrefix = "nvvm" in {
   def int_nvvm_prmt : GCCBuiltin<"__nvvm_prmt">,
       Intrinsic<[llvm_i32_ty], [llvm_i32_ty, llvm_i32_ty, llvm_i32_ty],
@@ -927,30 +969,22 @@
                 [IntrNoMem]>;
 
 // Atomics not available as llvm intrinsics.
-  def int_nvvm_atomic_load_add_f32 : Intrinsic<[llvm_float_ty],
-          [LLVMAnyPointerType<llvm_float_ty>, llvm_float_ty],
-                                      [IntrArgMemOnly, NoCapture<0>]>;
-  // Atomic add of f64 requires sm_60.
-  def int_nvvm_atomic_load_add_f64 : Intrinsic<[llvm_double_ty],
-          [LLVMAnyPointerType<llvm_double_ty>, llvm_double_ty],
-                                      [IntrArgMemOnly, NoCapture<0>]>;
-
   def int_nvvm_atomic_load_inc_32 : Intrinsic<[llvm_i32_ty],
           [LLVMAnyPointerType<llvm_i32_ty>, llvm_i32_ty],
-                                      [IntrArgMemOnly, NoCapture<0>]>;
+                                      [IntrArgMemOnly, NoCapture<ArgIndex<0>>]>;
   def int_nvvm_atomic_load_dec_32 : Intrinsic<[llvm_i32_ty],
           [LLVMAnyPointerType<llvm_i32_ty>, llvm_i32_ty],
-                                      [IntrArgMemOnly, NoCapture<0>]>;
+                                      [IntrArgMemOnly, NoCapture<ArgIndex<0>>]>;
 
   class SCOPED_ATOMIC2_impl<LLVMType elty>
         : Intrinsic<[elty],
           [LLVMAnyPointerType<LLVMMatchType<0>>, LLVMMatchType<0>],
-          [IntrArgMemOnly, NoCapture<0>]>;
+          [IntrArgMemOnly, NoCapture<ArgIndex<0>>]>;
   class SCOPED_ATOMIC3_impl<LLVMType elty>
         : Intrinsic<[elty],
           [LLVMAnyPointerType<LLVMMatchType<0>>, LLVMMatchType<0>,
            LLVMMatchType<0>],
-          [IntrArgMemOnly, NoCapture<0>]>;
+          [IntrArgMemOnly, NoCapture<ArgIndex<0>>]>;
 
   multiclass PTXAtomicWithScope2<LLVMType elty> {
     def _cta : SCOPED_ATOMIC2_impl<elty>;
@@ -1022,30 +1056,30 @@
 // pointer's alignment.
 def int_nvvm_ldu_global_i : Intrinsic<[llvm_anyint_ty],
   [LLVMAnyPointerType<LLVMMatchType<0>>, llvm_i32_ty],
-  [IntrReadMem, IntrArgMemOnly, NoCapture<0>],
+  [IntrReadMem, IntrArgMemOnly, NoCapture<ArgIndex<0>>],
   "llvm.nvvm.ldu.global.i">;
 def int_nvvm_ldu_global_f : Intrinsic<[llvm_anyfloat_ty],
   [LLVMAnyPointerType<LLVMMatchType<0>>, llvm_i32_ty],
-  [IntrReadMem, IntrArgMemOnly, NoCapture<0>],
+  [IntrReadMem, IntrArgMemOnly, NoCapture<ArgIndex<0>>],
   "llvm.nvvm.ldu.global.f">;
 def int_nvvm_ldu_global_p : Intrinsic<[llvm_anyptr_ty],
   [LLVMAnyPointerType<LLVMMatchType<0>>, llvm_i32_ty],
-  [IntrReadMem, IntrArgMemOnly, NoCapture<0>],
+  [IntrReadMem, IntrArgMemOnly, NoCapture<ArgIndex<0>>],
   "llvm.nvvm.ldu.global.p">;
 
 // Generated within nvvm. Use for ldg on sm_35 or later.  Second arg is the
 // pointer's alignment.
 def int_nvvm_ldg_global_i : Intrinsic<[llvm_anyint_ty],
   [LLVMAnyPointerType<LLVMMatchType<0>>, llvm_i32_ty],
-  [IntrReadMem, IntrArgMemOnly, NoCapture<0>],
+  [IntrReadMem, IntrArgMemOnly, NoCapture<ArgIndex<0>>],
   "llvm.nvvm.ldg.global.i">;
 def int_nvvm_ldg_global_f : Intrinsic<[llvm_anyfloat_ty],
   [LLVMAnyPointerType<LLVMMatchType<0>>, llvm_i32_ty],
-  [IntrReadMem, IntrArgMemOnly, NoCapture<0>],
+  [IntrReadMem, IntrArgMemOnly, NoCapture<ArgIndex<0>>],
   "llvm.nvvm.ldg.global.f">;
 def int_nvvm_ldg_global_p : Intrinsic<[llvm_anyptr_ty],
   [LLVMAnyPointerType<LLVMMatchType<0>>, llvm_i32_ty],
-  [IntrReadMem, IntrArgMemOnly, NoCapture<0>],
+  [IntrReadMem, IntrArgMemOnly, NoCapture<ArgIndex<0>>],
   "llvm.nvvm.ldg.global.p">;
 
 // Use for generic pointers
@@ -1102,7 +1136,7 @@
 def int_nvvm_move_double : Intrinsic<[llvm_double_ty], [llvm_double_ty],
   [IntrNoMem], "llvm.nvvm.move.double">;
 def int_nvvm_move_ptr : Intrinsic<[llvm_anyptr_ty], [llvm_anyptr_ty],
-  [IntrNoMem, NoCapture<0>], "llvm.nvvm.move.ptr">;
+  [IntrNoMem, NoCapture<ArgIndex<0>>], "llvm.nvvm.move.ptr">;
 
 
 // For getting the handle from a texture or surface variable
@@ -3963,90 +3997,27 @@
 //
 // SHUFFLE
 //
-
-// shfl.down.b32 dest, val, offset, mask_and_clamp
-def int_nvvm_shfl_down_i32 :
-  Intrinsic<[llvm_i32_ty], [llvm_i32_ty, llvm_i32_ty, llvm_i32_ty],
-            [IntrInaccessibleMemOnly, IntrConvergent], "llvm.nvvm.shfl.down.i32">,
-  GCCBuiltin<"__nvvm_shfl_down_i32">;
-def int_nvvm_shfl_down_f32 :
-  Intrinsic<[llvm_float_ty], [llvm_float_ty, llvm_i32_ty, llvm_i32_ty],
-            [IntrInaccessibleMemOnly, IntrConvergent], "llvm.nvvm.shfl.down.f32">,
-  GCCBuiltin<"__nvvm_shfl_down_f32">;
-
-// shfl.up.b32 dest, val, offset, mask_and_clamp
-def int_nvvm_shfl_up_i32 :
-  Intrinsic<[llvm_i32_ty], [llvm_i32_ty, llvm_i32_ty, llvm_i32_ty],
-            [IntrInaccessibleMemOnly, IntrConvergent], "llvm.nvvm.shfl.up.i32">,
-  GCCBuiltin<"__nvvm_shfl_up_i32">;
-def int_nvvm_shfl_up_f32 :
-  Intrinsic<[llvm_float_ty], [llvm_float_ty, llvm_i32_ty, llvm_i32_ty],
-            [IntrInaccessibleMemOnly, IntrConvergent], "llvm.nvvm.shfl.up.f32">,
-  GCCBuiltin<"__nvvm_shfl_up_f32">;
-
-// shfl.bfly.b32 dest, val, offset, mask_and_clamp
-def int_nvvm_shfl_bfly_i32 :
-  Intrinsic<[llvm_i32_ty], [llvm_i32_ty, llvm_i32_ty, llvm_i32_ty],
-            [IntrInaccessibleMemOnly, IntrConvergent], "llvm.nvvm.shfl.bfly.i32">,
-  GCCBuiltin<"__nvvm_shfl_bfly_i32">;
-def int_nvvm_shfl_bfly_f32 :
-  Intrinsic<[llvm_float_ty], [llvm_float_ty, llvm_i32_ty, llvm_i32_ty],
-            [IntrInaccessibleMemOnly, IntrConvergent], "llvm.nvvm.shfl.bfly.f32">,
-  GCCBuiltin<"__nvvm_shfl_bfly_f32">;
-
-// shfl.idx.b32 dest, val, lane, mask_and_clamp
-def int_nvvm_shfl_idx_i32 :
-  Intrinsic<[llvm_i32_ty], [llvm_i32_ty, llvm_i32_ty, llvm_i32_ty],
-            [IntrInaccessibleMemOnly, IntrConvergent], "llvm.nvvm.shfl.idx.i32">,
-  GCCBuiltin<"__nvvm_shfl_idx_i32">;
-def int_nvvm_shfl_idx_f32 :
-  Intrinsic<[llvm_float_ty], [llvm_float_ty, llvm_i32_ty, llvm_i32_ty],
-            [IntrInaccessibleMemOnly, IntrConvergent], "llvm.nvvm.shfl.idx.f32">,
-  GCCBuiltin<"__nvvm_shfl_idx_f32">;
-
-// Synchronizing shfl variants available in CUDA-9.
-// On sm_70 these don't have to be convergent, so we may eventually want to
-// implement non-convergent variant of this intrinsic.
-
-// shfl.sync.down.b32 dest, threadmask, val, offset , mask_and_clamp
-def int_nvvm_shfl_sync_down_i32 :
-  Intrinsic<[llvm_i32_ty], [llvm_i32_ty, llvm_i32_ty, llvm_i32_ty, llvm_i32_ty],
-            [IntrInaccessibleMemOnly, IntrConvergent], "llvm.nvvm.shfl.sync.down.i32">,
-  GCCBuiltin<"__nvvm_shfl_sync_down_i32">;
-def int_nvvm_shfl_sync_down_f32 :
-  Intrinsic<[llvm_float_ty], [llvm_i32_ty, llvm_float_ty, llvm_i32_ty, llvm_i32_ty],
-            [IntrInaccessibleMemOnly, IntrConvergent], "llvm.nvvm.shfl.sync.down.f32">,
-  GCCBuiltin<"__nvvm_shfl_sync_down_f32">;
-
-// shfl.sync.up.b32 dest, threadmask, val, offset, mask_and_clamp
-def int_nvvm_shfl_sync_up_i32 :
-  Intrinsic<[llvm_i32_ty], [llvm_i32_ty, llvm_i32_ty, llvm_i32_ty, llvm_i32_ty],
-            [IntrInaccessibleMemOnly, IntrConvergent], "llvm.nvvm.shfl.sync.up.i32">,
-  GCCBuiltin<"__nvvm_shfl_sync_up_i32">;
-def int_nvvm_shfl_sync_up_f32 :
-  Intrinsic<[llvm_float_ty], [llvm_i32_ty, llvm_float_ty, llvm_i32_ty, llvm_i32_ty],
-            [IntrInaccessibleMemOnly, IntrConvergent], "llvm.nvvm.shfl.sync.up.f32">,
-  GCCBuiltin<"__nvvm_shfl_sync_up_f32">;
-
-// shfl.sync.bfly.b32 dest, threadmask, val, offset, mask_and_clamp
-def int_nvvm_shfl_sync_bfly_i32 :
-  Intrinsic<[llvm_i32_ty], [llvm_i32_ty, llvm_i32_ty, llvm_i32_ty, llvm_i32_ty],
-            [IntrInaccessibleMemOnly, IntrConvergent], "llvm.nvvm.shfl.sync.bfly.i32">,
-  GCCBuiltin<"__nvvm_shfl_sync_bfly_i32">;
-def int_nvvm_shfl_sync_bfly_f32 :
-  Intrinsic<[llvm_float_ty], [llvm_i32_ty, llvm_float_ty, llvm_i32_ty, llvm_i32_ty],
-            [IntrInaccessibleMemOnly, IntrConvergent], "llvm.nvvm.shfl.sync.bfly.f32">,
-  GCCBuiltin<"__nvvm_shfl_sync_bfly_f32">;
-
-// shfl.sync.idx.b32 dest, threadmask, val, lane, mask_and_clamp
-def int_nvvm_shfl_sync_idx_i32 :
-  Intrinsic<[llvm_i32_ty], [llvm_i32_ty, llvm_i32_ty, llvm_i32_ty, llvm_i32_ty],
-            [IntrInaccessibleMemOnly, IntrConvergent], "llvm.nvvm.shfl.sync.idx.i32">,
-  GCCBuiltin<"__nvvm_shfl_sync_idx_i32">;
-def int_nvvm_shfl_sync_idx_f32 :
-  Intrinsic<[llvm_float_ty], [llvm_i32_ty, llvm_float_ty, llvm_i32_ty, llvm_i32_ty],
-            [IntrInaccessibleMemOnly, IntrConvergent], "llvm.nvvm.shfl.sync.idx.f32">,
-  GCCBuiltin<"__nvvm_shfl_sync_idx_f32">;
+// Generate intrinsics for all variants of shfl instruction.
+foreach sync = [false, true] in {
+  foreach mode = ["up", "down", "bfly", "idx"] in {
+    foreach type = ["i32", "f32"] in {
+      foreach return_pred = [false, true] in {
+        foreach i = [SHFL_INFO<sync, mode, type, return_pred>] in {
+          if i.withGccBuiltin then {
+            def i.Name : GCCBuiltin<i.Builtin>,
+                         Intrinsic<i.RetTy, i.ArgsTy,
+                                   [IntrInaccessibleMemOnly, IntrConvergent],
+                                   i.IntrName>;
+          }
+          if i.withoutGccBuiltin then {
+            def i.Name : Intrinsic<i.RetTy, i.ArgsTy,
+                         [IntrInaccessibleMemOnly, IntrConvergent], i.IntrName>;
+          }
+        }
+      }
+    }
+  }
+}
 
 //
 // VOTE
@@ -4132,7 +4103,7 @@
 class NVVM_WMMA_LD<WMMA_REGS Frag, string Layout, int WithStride>
   : Intrinsic<Frag.regs,
               !if(WithStride, [llvm_anyptr_ty, llvm_i32_ty], [llvm_anyptr_ty]),
-              [IntrReadMem, IntrArgMemOnly, ReadOnly<0>, NoCapture<0>],
+              [IntrReadMem, IntrArgMemOnly, ReadOnly<ArgIndex<0>>, NoCapture<ArgIndex<0>>],
               WMMA_NAME_LDST<"load", Frag, Layout, WithStride>.intr>;
 
 // WMMA.STORE.D
@@ -4142,18 +4113,18 @@
                 [llvm_anyptr_ty],
                 Frag.regs,
                 !if(WithStride, [llvm_i32_ty], [])),
-              [IntrWriteMem, IntrArgMemOnly, WriteOnly<0>, NoCapture<0>],
+              [IntrWriteMem, IntrArgMemOnly, WriteOnly<ArgIndex<0>>, NoCapture<ArgIndex<0>>],
               WMMA_NAME_LDST<"store", Frag, Layout, WithStride>.intr>;
 
-// Create all load/store variants 
+// Create all load/store variants
 foreach layout = ["row", "col"] in {
   foreach stride = [0, 1] in {
     foreach frag = NVVM_MMA_OPS.all_ld_ops in
-      foreach _ = NVVM_MMA_SUPPORTED<[frag], layout>.ret in
+      if NVVM_MMA_SUPPORTED<[frag], layout>.ret then
         def WMMA_NAME_LDST<"load", frag, layout, stride>.record
              : NVVM_WMMA_LD<frag, layout, stride>;
     foreach frag = NVVM_MMA_OPS.all_st_ops in
-      foreach _ = NVVM_MMA_SUPPORTED<[frag], layout>.ret in
+      if NVVM_MMA_SUPPORTED<[frag], layout>.ret then
         def WMMA_NAME_LDST<"store", frag, layout, stride>.record
              : NVVM_WMMA_ST<frag, layout, stride>;
   }
@@ -4172,7 +4143,7 @@
   foreach layout_b = ["row", "col"] in {
     foreach satf = [0, 1] in {
       foreach op = NVVM_MMA_OPS.all_mma_ops in {
-        foreach _ = NVVM_MMA_SUPPORTED<op, layout_a, layout_b, satf>.ret in {
+        if NVVM_MMA_SUPPORTED<op, layout_a, layout_b, satf>.ret then {
           def WMMA_NAME_MMA<layout_a, layout_b, satf,
                             op[0], op[1], op[2], op[3]>.record
             : NVVM_WMMA_MMA<layout_a, layout_b, satf,
diff --git a/linux-x64/clang/include/llvm/IR/IntrinsicsPowerPC.h b/linux-x64/clang/include/llvm/IR/IntrinsicsPowerPC.h
new file mode 100644
index 0000000..c2d9766
--- /dev/null
+++ b/linux-x64/clang/include/llvm/IR/IntrinsicsPowerPC.h
@@ -0,0 +1,535 @@
+/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
+|*                                                                            *|
+|* Intrinsic Function Source Fragment                                         *|
+|*                                                                            *|
+|* Automatically generated file, do not edit!                                 *|
+|*                                                                            *|
+\*===----------------------------------------------------------------------===*/
+
+#ifndef LLVM_IR_INTRINSIC_PPC_ENUMS_H
+#define LLVM_IR_INTRINSIC_PPC_ENUMS_H
+
+namespace llvm {
+namespace Intrinsic {
+enum PPCIntrinsics : unsigned {
+// Enum values for intrinsics
+    ppc_addf128_round_to_odd = 6071,                  // llvm.ppc.addf128.round.to.odd
+    ppc_altivec_crypto_vcipher,                // llvm.ppc.altivec.crypto.vcipher
+    ppc_altivec_crypto_vcipherlast,            // llvm.ppc.altivec.crypto.vcipherlast
+    ppc_altivec_crypto_vncipher,               // llvm.ppc.altivec.crypto.vncipher
+    ppc_altivec_crypto_vncipherlast,           // llvm.ppc.altivec.crypto.vncipherlast
+    ppc_altivec_crypto_vpermxor,               // llvm.ppc.altivec.crypto.vpermxor
+    ppc_altivec_crypto_vpmsumb,                // llvm.ppc.altivec.crypto.vpmsumb
+    ppc_altivec_crypto_vpmsumd,                // llvm.ppc.altivec.crypto.vpmsumd
+    ppc_altivec_crypto_vpmsumh,                // llvm.ppc.altivec.crypto.vpmsumh
+    ppc_altivec_crypto_vpmsumw,                // llvm.ppc.altivec.crypto.vpmsumw
+    ppc_altivec_crypto_vsbox,                  // llvm.ppc.altivec.crypto.vsbox
+    ppc_altivec_crypto_vshasigmad,             // llvm.ppc.altivec.crypto.vshasigmad
+    ppc_altivec_crypto_vshasigmaw,             // llvm.ppc.altivec.crypto.vshasigmaw
+    ppc_altivec_dss,                           // llvm.ppc.altivec.dss
+    ppc_altivec_dssall,                        // llvm.ppc.altivec.dssall
+    ppc_altivec_dst,                           // llvm.ppc.altivec.dst
+    ppc_altivec_dstst,                         // llvm.ppc.altivec.dstst
+    ppc_altivec_dststt,                        // llvm.ppc.altivec.dststt
+    ppc_altivec_dstt,                          // llvm.ppc.altivec.dstt
+    ppc_altivec_lvebx,                         // llvm.ppc.altivec.lvebx
+    ppc_altivec_lvehx,                         // llvm.ppc.altivec.lvehx
+    ppc_altivec_lvewx,                         // llvm.ppc.altivec.lvewx
+    ppc_altivec_lvsl,                          // llvm.ppc.altivec.lvsl
+    ppc_altivec_lvsr,                          // llvm.ppc.altivec.lvsr
+    ppc_altivec_lvx,                           // llvm.ppc.altivec.lvx
+    ppc_altivec_lvxl,                          // llvm.ppc.altivec.lvxl
+    ppc_altivec_mfvscr,                        // llvm.ppc.altivec.mfvscr
+    ppc_altivec_mtvscr,                        // llvm.ppc.altivec.mtvscr
+    ppc_altivec_mtvsrbm,                       // llvm.ppc.altivec.mtvsrbm
+    ppc_altivec_mtvsrdm,                       // llvm.ppc.altivec.mtvsrdm
+    ppc_altivec_mtvsrhm,                       // llvm.ppc.altivec.mtvsrhm
+    ppc_altivec_mtvsrqm,                       // llvm.ppc.altivec.mtvsrqm
+    ppc_altivec_mtvsrwm,                       // llvm.ppc.altivec.mtvsrwm
+    ppc_altivec_stvebx,                        // llvm.ppc.altivec.stvebx
+    ppc_altivec_stvehx,                        // llvm.ppc.altivec.stvehx
+    ppc_altivec_stvewx,                        // llvm.ppc.altivec.stvewx
+    ppc_altivec_stvx,                          // llvm.ppc.altivec.stvx
+    ppc_altivec_stvxl,                         // llvm.ppc.altivec.stvxl
+    ppc_altivec_vabsdub,                       // llvm.ppc.altivec.vabsdub
+    ppc_altivec_vabsduh,                       // llvm.ppc.altivec.vabsduh
+    ppc_altivec_vabsduw,                       // llvm.ppc.altivec.vabsduw
+    ppc_altivec_vaddcuq,                       // llvm.ppc.altivec.vaddcuq
+    ppc_altivec_vaddcuw,                       // llvm.ppc.altivec.vaddcuw
+    ppc_altivec_vaddecuq,                      // llvm.ppc.altivec.vaddecuq
+    ppc_altivec_vaddeuqm,                      // llvm.ppc.altivec.vaddeuqm
+    ppc_altivec_vaddsbs,                       // llvm.ppc.altivec.vaddsbs
+    ppc_altivec_vaddshs,                       // llvm.ppc.altivec.vaddshs
+    ppc_altivec_vaddsws,                       // llvm.ppc.altivec.vaddsws
+    ppc_altivec_vaddubs,                       // llvm.ppc.altivec.vaddubs
+    ppc_altivec_vadduhs,                       // llvm.ppc.altivec.vadduhs
+    ppc_altivec_vadduws,                       // llvm.ppc.altivec.vadduws
+    ppc_altivec_vavgsb,                        // llvm.ppc.altivec.vavgsb
+    ppc_altivec_vavgsh,                        // llvm.ppc.altivec.vavgsh
+    ppc_altivec_vavgsw,                        // llvm.ppc.altivec.vavgsw
+    ppc_altivec_vavgub,                        // llvm.ppc.altivec.vavgub
+    ppc_altivec_vavguh,                        // llvm.ppc.altivec.vavguh
+    ppc_altivec_vavguw,                        // llvm.ppc.altivec.vavguw
+    ppc_altivec_vbpermq,                       // llvm.ppc.altivec.vbpermq
+    ppc_altivec_vcfsx,                         // llvm.ppc.altivec.vcfsx
+    ppc_altivec_vcfuged,                       // llvm.ppc.altivec.vcfuged
+    ppc_altivec_vcfux,                         // llvm.ppc.altivec.vcfux
+    ppc_altivec_vclrlb,                        // llvm.ppc.altivec.vclrlb
+    ppc_altivec_vclrrb,                        // llvm.ppc.altivec.vclrrb
+    ppc_altivec_vclzdm,                        // llvm.ppc.altivec.vclzdm
+    ppc_altivec_vclzlsbb,                      // llvm.ppc.altivec.vclzlsbb
+    ppc_altivec_vcmpbfp,                       // llvm.ppc.altivec.vcmpbfp
+    ppc_altivec_vcmpbfp_p,                     // llvm.ppc.altivec.vcmpbfp.p
+    ppc_altivec_vcmpeqfp,                      // llvm.ppc.altivec.vcmpeqfp
+    ppc_altivec_vcmpeqfp_p,                    // llvm.ppc.altivec.vcmpeqfp.p
+    ppc_altivec_vcmpequb,                      // llvm.ppc.altivec.vcmpequb
+    ppc_altivec_vcmpequb_p,                    // llvm.ppc.altivec.vcmpequb.p
+    ppc_altivec_vcmpequd,                      // llvm.ppc.altivec.vcmpequd
+    ppc_altivec_vcmpequd_p,                    // llvm.ppc.altivec.vcmpequd.p
+    ppc_altivec_vcmpequh,                      // llvm.ppc.altivec.vcmpequh
+    ppc_altivec_vcmpequh_p,                    // llvm.ppc.altivec.vcmpequh.p
+    ppc_altivec_vcmpequq,                      // llvm.ppc.altivec.vcmpequq
+    ppc_altivec_vcmpequq_p,                    // llvm.ppc.altivec.vcmpequq.p
+    ppc_altivec_vcmpequw,                      // llvm.ppc.altivec.vcmpequw
+    ppc_altivec_vcmpequw_p,                    // llvm.ppc.altivec.vcmpequw.p
+    ppc_altivec_vcmpgefp,                      // llvm.ppc.altivec.vcmpgefp
+    ppc_altivec_vcmpgefp_p,                    // llvm.ppc.altivec.vcmpgefp.p
+    ppc_altivec_vcmpgtfp,                      // llvm.ppc.altivec.vcmpgtfp
+    ppc_altivec_vcmpgtfp_p,                    // llvm.ppc.altivec.vcmpgtfp.p
+    ppc_altivec_vcmpgtsb,                      // llvm.ppc.altivec.vcmpgtsb
+    ppc_altivec_vcmpgtsb_p,                    // llvm.ppc.altivec.vcmpgtsb.p
+    ppc_altivec_vcmpgtsd,                      // llvm.ppc.altivec.vcmpgtsd
+    ppc_altivec_vcmpgtsd_p,                    // llvm.ppc.altivec.vcmpgtsd.p
+    ppc_altivec_vcmpgtsh,                      // llvm.ppc.altivec.vcmpgtsh
+    ppc_altivec_vcmpgtsh_p,                    // llvm.ppc.altivec.vcmpgtsh.p
+    ppc_altivec_vcmpgtsq,                      // llvm.ppc.altivec.vcmpgtsq
+    ppc_altivec_vcmpgtsq_p,                    // llvm.ppc.altivec.vcmpgtsq.p
+    ppc_altivec_vcmpgtsw,                      // llvm.ppc.altivec.vcmpgtsw
+    ppc_altivec_vcmpgtsw_p,                    // llvm.ppc.altivec.vcmpgtsw.p
+    ppc_altivec_vcmpgtub,                      // llvm.ppc.altivec.vcmpgtub
+    ppc_altivec_vcmpgtub_p,                    // llvm.ppc.altivec.vcmpgtub.p
+    ppc_altivec_vcmpgtud,                      // llvm.ppc.altivec.vcmpgtud
+    ppc_altivec_vcmpgtud_p,                    // llvm.ppc.altivec.vcmpgtud.p
+    ppc_altivec_vcmpgtuh,                      // llvm.ppc.altivec.vcmpgtuh
+    ppc_altivec_vcmpgtuh_p,                    // llvm.ppc.altivec.vcmpgtuh.p
+    ppc_altivec_vcmpgtuq,                      // llvm.ppc.altivec.vcmpgtuq
+    ppc_altivec_vcmpgtuq_p,                    // llvm.ppc.altivec.vcmpgtuq.p
+    ppc_altivec_vcmpgtuw,                      // llvm.ppc.altivec.vcmpgtuw
+    ppc_altivec_vcmpgtuw_p,                    // llvm.ppc.altivec.vcmpgtuw.p
+    ppc_altivec_vcmpneb,                       // llvm.ppc.altivec.vcmpneb
+    ppc_altivec_vcmpneb_p,                     // llvm.ppc.altivec.vcmpneb.p
+    ppc_altivec_vcmpneh,                       // llvm.ppc.altivec.vcmpneh
+    ppc_altivec_vcmpneh_p,                     // llvm.ppc.altivec.vcmpneh.p
+    ppc_altivec_vcmpnew,                       // llvm.ppc.altivec.vcmpnew
+    ppc_altivec_vcmpnew_p,                     // llvm.ppc.altivec.vcmpnew.p
+    ppc_altivec_vcmpnezb,                      // llvm.ppc.altivec.vcmpnezb
+    ppc_altivec_vcmpnezb_p,                    // llvm.ppc.altivec.vcmpnezb.p
+    ppc_altivec_vcmpnezh,                      // llvm.ppc.altivec.vcmpnezh
+    ppc_altivec_vcmpnezh_p,                    // llvm.ppc.altivec.vcmpnezh.p
+    ppc_altivec_vcmpnezw,                      // llvm.ppc.altivec.vcmpnezw
+    ppc_altivec_vcmpnezw_p,                    // llvm.ppc.altivec.vcmpnezw.p
+    ppc_altivec_vcntmbb,                       // llvm.ppc.altivec.vcntmbb
+    ppc_altivec_vcntmbd,                       // llvm.ppc.altivec.vcntmbd
+    ppc_altivec_vcntmbh,                       // llvm.ppc.altivec.vcntmbh
+    ppc_altivec_vcntmbw,                       // llvm.ppc.altivec.vcntmbw
+    ppc_altivec_vctsxs,                        // llvm.ppc.altivec.vctsxs
+    ppc_altivec_vctuxs,                        // llvm.ppc.altivec.vctuxs
+    ppc_altivec_vctzdm,                        // llvm.ppc.altivec.vctzdm
+    ppc_altivec_vctzlsbb,                      // llvm.ppc.altivec.vctzlsbb
+    ppc_altivec_vdivesd,                       // llvm.ppc.altivec.vdivesd
+    ppc_altivec_vdivesq,                       // llvm.ppc.altivec.vdivesq
+    ppc_altivec_vdivesw,                       // llvm.ppc.altivec.vdivesw
+    ppc_altivec_vdiveud,                       // llvm.ppc.altivec.vdiveud
+    ppc_altivec_vdiveuq,                       // llvm.ppc.altivec.vdiveuq
+    ppc_altivec_vdiveuw,                       // llvm.ppc.altivec.vdiveuw
+    ppc_altivec_vexpandbm,                     // llvm.ppc.altivec.vexpandbm
+    ppc_altivec_vexpanddm,                     // llvm.ppc.altivec.vexpanddm
+    ppc_altivec_vexpandhm,                     // llvm.ppc.altivec.vexpandhm
+    ppc_altivec_vexpandqm,                     // llvm.ppc.altivec.vexpandqm
+    ppc_altivec_vexpandwm,                     // llvm.ppc.altivec.vexpandwm
+    ppc_altivec_vexptefp,                      // llvm.ppc.altivec.vexptefp
+    ppc_altivec_vextddvlx,                     // llvm.ppc.altivec.vextddvlx
+    ppc_altivec_vextddvrx,                     // llvm.ppc.altivec.vextddvrx
+    ppc_altivec_vextdubvlx,                    // llvm.ppc.altivec.vextdubvlx
+    ppc_altivec_vextdubvrx,                    // llvm.ppc.altivec.vextdubvrx
+    ppc_altivec_vextduhvlx,                    // llvm.ppc.altivec.vextduhvlx
+    ppc_altivec_vextduhvrx,                    // llvm.ppc.altivec.vextduhvrx
+    ppc_altivec_vextduwvlx,                    // llvm.ppc.altivec.vextduwvlx
+    ppc_altivec_vextduwvrx,                    // llvm.ppc.altivec.vextduwvrx
+    ppc_altivec_vextractbm,                    // llvm.ppc.altivec.vextractbm
+    ppc_altivec_vextractdm,                    // llvm.ppc.altivec.vextractdm
+    ppc_altivec_vextracthm,                    // llvm.ppc.altivec.vextracthm
+    ppc_altivec_vextractqm,                    // llvm.ppc.altivec.vextractqm
+    ppc_altivec_vextractwm,                    // llvm.ppc.altivec.vextractwm
+    ppc_altivec_vextsb2d,                      // llvm.ppc.altivec.vextsb2d
+    ppc_altivec_vextsb2w,                      // llvm.ppc.altivec.vextsb2w
+    ppc_altivec_vextsd2q,                      // llvm.ppc.altivec.vextsd2q
+    ppc_altivec_vextsh2d,                      // llvm.ppc.altivec.vextsh2d
+    ppc_altivec_vextsh2w,                      // llvm.ppc.altivec.vextsh2w
+    ppc_altivec_vextsw2d,                      // llvm.ppc.altivec.vextsw2d
+    ppc_altivec_vgbbd,                         // llvm.ppc.altivec.vgbbd
+    ppc_altivec_vgnb,                          // llvm.ppc.altivec.vgnb
+    ppc_altivec_vinsblx,                       // llvm.ppc.altivec.vinsblx
+    ppc_altivec_vinsbrx,                       // llvm.ppc.altivec.vinsbrx
+    ppc_altivec_vinsbvlx,                      // llvm.ppc.altivec.vinsbvlx
+    ppc_altivec_vinsbvrx,                      // llvm.ppc.altivec.vinsbvrx
+    ppc_altivec_vinsd,                         // llvm.ppc.altivec.vinsd
+    ppc_altivec_vinsdlx,                       // llvm.ppc.altivec.vinsdlx
+    ppc_altivec_vinsdrx,                       // llvm.ppc.altivec.vinsdrx
+    ppc_altivec_vinshlx,                       // llvm.ppc.altivec.vinshlx
+    ppc_altivec_vinshrx,                       // llvm.ppc.altivec.vinshrx
+    ppc_altivec_vinshvlx,                      // llvm.ppc.altivec.vinshvlx
+    ppc_altivec_vinshvrx,                      // llvm.ppc.altivec.vinshvrx
+    ppc_altivec_vinsw,                         // llvm.ppc.altivec.vinsw
+    ppc_altivec_vinswlx,                       // llvm.ppc.altivec.vinswlx
+    ppc_altivec_vinswrx,                       // llvm.ppc.altivec.vinswrx
+    ppc_altivec_vinswvlx,                      // llvm.ppc.altivec.vinswvlx
+    ppc_altivec_vinswvrx,                      // llvm.ppc.altivec.vinswvrx
+    ppc_altivec_vlogefp,                       // llvm.ppc.altivec.vlogefp
+    ppc_altivec_vmaddfp,                       // llvm.ppc.altivec.vmaddfp
+    ppc_altivec_vmaxfp,                        // llvm.ppc.altivec.vmaxfp
+    ppc_altivec_vmaxsb,                        // llvm.ppc.altivec.vmaxsb
+    ppc_altivec_vmaxsd,                        // llvm.ppc.altivec.vmaxsd
+    ppc_altivec_vmaxsh,                        // llvm.ppc.altivec.vmaxsh
+    ppc_altivec_vmaxsw,                        // llvm.ppc.altivec.vmaxsw
+    ppc_altivec_vmaxub,                        // llvm.ppc.altivec.vmaxub
+    ppc_altivec_vmaxud,                        // llvm.ppc.altivec.vmaxud
+    ppc_altivec_vmaxuh,                        // llvm.ppc.altivec.vmaxuh
+    ppc_altivec_vmaxuw,                        // llvm.ppc.altivec.vmaxuw
+    ppc_altivec_vmhaddshs,                     // llvm.ppc.altivec.vmhaddshs
+    ppc_altivec_vmhraddshs,                    // llvm.ppc.altivec.vmhraddshs
+    ppc_altivec_vminfp,                        // llvm.ppc.altivec.vminfp
+    ppc_altivec_vminsb,                        // llvm.ppc.altivec.vminsb
+    ppc_altivec_vminsd,                        // llvm.ppc.altivec.vminsd
+    ppc_altivec_vminsh,                        // llvm.ppc.altivec.vminsh
+    ppc_altivec_vminsw,                        // llvm.ppc.altivec.vminsw
+    ppc_altivec_vminub,                        // llvm.ppc.altivec.vminub
+    ppc_altivec_vminud,                        // llvm.ppc.altivec.vminud
+    ppc_altivec_vminuh,                        // llvm.ppc.altivec.vminuh
+    ppc_altivec_vminuw,                        // llvm.ppc.altivec.vminuw
+    ppc_altivec_vmladduhm,                     // llvm.ppc.altivec.vmladduhm
+    ppc_altivec_vmsumcud,                      // llvm.ppc.altivec.vmsumcud
+    ppc_altivec_vmsummbm,                      // llvm.ppc.altivec.vmsummbm
+    ppc_altivec_vmsumshm,                      // llvm.ppc.altivec.vmsumshm
+    ppc_altivec_vmsumshs,                      // llvm.ppc.altivec.vmsumshs
+    ppc_altivec_vmsumubm,                      // llvm.ppc.altivec.vmsumubm
+    ppc_altivec_vmsumudm,                      // llvm.ppc.altivec.vmsumudm
+    ppc_altivec_vmsumuhm,                      // llvm.ppc.altivec.vmsumuhm
+    ppc_altivec_vmsumuhs,                      // llvm.ppc.altivec.vmsumuhs
+    ppc_altivec_vmulesb,                       // llvm.ppc.altivec.vmulesb
+    ppc_altivec_vmulesd,                       // llvm.ppc.altivec.vmulesd
+    ppc_altivec_vmulesh,                       // llvm.ppc.altivec.vmulesh
+    ppc_altivec_vmulesw,                       // llvm.ppc.altivec.vmulesw
+    ppc_altivec_vmuleub,                       // llvm.ppc.altivec.vmuleub
+    ppc_altivec_vmuleud,                       // llvm.ppc.altivec.vmuleud
+    ppc_altivec_vmuleuh,                       // llvm.ppc.altivec.vmuleuh
+    ppc_altivec_vmuleuw,                       // llvm.ppc.altivec.vmuleuw
+    ppc_altivec_vmulhsd,                       // llvm.ppc.altivec.vmulhsd
+    ppc_altivec_vmulhsw,                       // llvm.ppc.altivec.vmulhsw
+    ppc_altivec_vmulhud,                       // llvm.ppc.altivec.vmulhud
+    ppc_altivec_vmulhuw,                       // llvm.ppc.altivec.vmulhuw
+    ppc_altivec_vmulosb,                       // llvm.ppc.altivec.vmulosb
+    ppc_altivec_vmulosd,                       // llvm.ppc.altivec.vmulosd
+    ppc_altivec_vmulosh,                       // llvm.ppc.altivec.vmulosh
+    ppc_altivec_vmulosw,                       // llvm.ppc.altivec.vmulosw
+    ppc_altivec_vmuloub,                       // llvm.ppc.altivec.vmuloub
+    ppc_altivec_vmuloud,                       // llvm.ppc.altivec.vmuloud
+    ppc_altivec_vmulouh,                       // llvm.ppc.altivec.vmulouh
+    ppc_altivec_vmulouw,                       // llvm.ppc.altivec.vmulouw
+    ppc_altivec_vnmsubfp,                      // llvm.ppc.altivec.vnmsubfp
+    ppc_altivec_vpdepd,                        // llvm.ppc.altivec.vpdepd
+    ppc_altivec_vperm,                         // llvm.ppc.altivec.vperm
+    ppc_altivec_vpextd,                        // llvm.ppc.altivec.vpextd
+    ppc_altivec_vpkpx,                         // llvm.ppc.altivec.vpkpx
+    ppc_altivec_vpksdss,                       // llvm.ppc.altivec.vpksdss
+    ppc_altivec_vpksdus,                       // llvm.ppc.altivec.vpksdus
+    ppc_altivec_vpkshss,                       // llvm.ppc.altivec.vpkshss
+    ppc_altivec_vpkshus,                       // llvm.ppc.altivec.vpkshus
+    ppc_altivec_vpkswss,                       // llvm.ppc.altivec.vpkswss
+    ppc_altivec_vpkswus,                       // llvm.ppc.altivec.vpkswus
+    ppc_altivec_vpkudus,                       // llvm.ppc.altivec.vpkudus
+    ppc_altivec_vpkuhus,                       // llvm.ppc.altivec.vpkuhus
+    ppc_altivec_vpkuwus,                       // llvm.ppc.altivec.vpkuwus
+    ppc_altivec_vprtybd,                       // llvm.ppc.altivec.vprtybd
+    ppc_altivec_vprtybq,                       // llvm.ppc.altivec.vprtybq
+    ppc_altivec_vprtybw,                       // llvm.ppc.altivec.vprtybw
+    ppc_altivec_vrefp,                         // llvm.ppc.altivec.vrefp
+    ppc_altivec_vrfim,                         // llvm.ppc.altivec.vrfim
+    ppc_altivec_vrfin,                         // llvm.ppc.altivec.vrfin
+    ppc_altivec_vrfip,                         // llvm.ppc.altivec.vrfip
+    ppc_altivec_vrfiz,                         // llvm.ppc.altivec.vrfiz
+    ppc_altivec_vrlb,                          // llvm.ppc.altivec.vrlb
+    ppc_altivec_vrld,                          // llvm.ppc.altivec.vrld
+    ppc_altivec_vrldmi,                        // llvm.ppc.altivec.vrldmi
+    ppc_altivec_vrldnm,                        // llvm.ppc.altivec.vrldnm
+    ppc_altivec_vrlh,                          // llvm.ppc.altivec.vrlh
+    ppc_altivec_vrlqmi,                        // llvm.ppc.altivec.vrlqmi
+    ppc_altivec_vrlqnm,                        // llvm.ppc.altivec.vrlqnm
+    ppc_altivec_vrlw,                          // llvm.ppc.altivec.vrlw
+    ppc_altivec_vrlwmi,                        // llvm.ppc.altivec.vrlwmi
+    ppc_altivec_vrlwnm,                        // llvm.ppc.altivec.vrlwnm
+    ppc_altivec_vrsqrtefp,                     // llvm.ppc.altivec.vrsqrtefp
+    ppc_altivec_vsel,                          // llvm.ppc.altivec.vsel
+    ppc_altivec_vsl,                           // llvm.ppc.altivec.vsl
+    ppc_altivec_vslb,                          // llvm.ppc.altivec.vslb
+    ppc_altivec_vsldbi,                        // llvm.ppc.altivec.vsldbi
+    ppc_altivec_vslh,                          // llvm.ppc.altivec.vslh
+    ppc_altivec_vslo,                          // llvm.ppc.altivec.vslo
+    ppc_altivec_vslv,                          // llvm.ppc.altivec.vslv
+    ppc_altivec_vslw,                          // llvm.ppc.altivec.vslw
+    ppc_altivec_vsr,                           // llvm.ppc.altivec.vsr
+    ppc_altivec_vsrab,                         // llvm.ppc.altivec.vsrab
+    ppc_altivec_vsrah,                         // llvm.ppc.altivec.vsrah
+    ppc_altivec_vsraw,                         // llvm.ppc.altivec.vsraw
+    ppc_altivec_vsrb,                          // llvm.ppc.altivec.vsrb
+    ppc_altivec_vsrdbi,                        // llvm.ppc.altivec.vsrdbi
+    ppc_altivec_vsrh,                          // llvm.ppc.altivec.vsrh
+    ppc_altivec_vsro,                          // llvm.ppc.altivec.vsro
+    ppc_altivec_vsrv,                          // llvm.ppc.altivec.vsrv
+    ppc_altivec_vsrw,                          // llvm.ppc.altivec.vsrw
+    ppc_altivec_vstribl,                       // llvm.ppc.altivec.vstribl
+    ppc_altivec_vstribl_p,                     // llvm.ppc.altivec.vstribl.p
+    ppc_altivec_vstribr,                       // llvm.ppc.altivec.vstribr
+    ppc_altivec_vstribr_p,                     // llvm.ppc.altivec.vstribr.p
+    ppc_altivec_vstrihl,                       // llvm.ppc.altivec.vstrihl
+    ppc_altivec_vstrihl_p,                     // llvm.ppc.altivec.vstrihl.p
+    ppc_altivec_vstrihr,                       // llvm.ppc.altivec.vstrihr
+    ppc_altivec_vstrihr_p,                     // llvm.ppc.altivec.vstrihr.p
+    ppc_altivec_vsubcuq,                       // llvm.ppc.altivec.vsubcuq
+    ppc_altivec_vsubcuw,                       // llvm.ppc.altivec.vsubcuw
+    ppc_altivec_vsubecuq,                      // llvm.ppc.altivec.vsubecuq
+    ppc_altivec_vsubeuqm,                      // llvm.ppc.altivec.vsubeuqm
+    ppc_altivec_vsubsbs,                       // llvm.ppc.altivec.vsubsbs
+    ppc_altivec_vsubshs,                       // llvm.ppc.altivec.vsubshs
+    ppc_altivec_vsubsws,                       // llvm.ppc.altivec.vsubsws
+    ppc_altivec_vsububs,                       // llvm.ppc.altivec.vsububs
+    ppc_altivec_vsubuhs,                       // llvm.ppc.altivec.vsubuhs
+    ppc_altivec_vsubuws,                       // llvm.ppc.altivec.vsubuws
+    ppc_altivec_vsum2sws,                      // llvm.ppc.altivec.vsum2sws
+    ppc_altivec_vsum4sbs,                      // llvm.ppc.altivec.vsum4sbs
+    ppc_altivec_vsum4shs,                      // llvm.ppc.altivec.vsum4shs
+    ppc_altivec_vsum4ubs,                      // llvm.ppc.altivec.vsum4ubs
+    ppc_altivec_vsumsws,                       // llvm.ppc.altivec.vsumsws
+    ppc_altivec_vupkhpx,                       // llvm.ppc.altivec.vupkhpx
+    ppc_altivec_vupkhsb,                       // llvm.ppc.altivec.vupkhsb
+    ppc_altivec_vupkhsh,                       // llvm.ppc.altivec.vupkhsh
+    ppc_altivec_vupkhsw,                       // llvm.ppc.altivec.vupkhsw
+    ppc_altivec_vupklpx,                       // llvm.ppc.altivec.vupklpx
+    ppc_altivec_vupklsb,                       // llvm.ppc.altivec.vupklsb
+    ppc_altivec_vupklsh,                       // llvm.ppc.altivec.vupklsh
+    ppc_altivec_vupklsw,                       // llvm.ppc.altivec.vupklsw
+    ppc_bpermd,                                // llvm.ppc.bpermd
+    ppc_cfence,                                // llvm.ppc.cfence
+    ppc_cfuged,                                // llvm.ppc.cfuged
+    ppc_cntlzdm,                               // llvm.ppc.cntlzdm
+    ppc_cnttzdm,                               // llvm.ppc.cnttzdm
+    ppc_darn,                                  // llvm.ppc.darn
+    ppc_darn32,                                // llvm.ppc.darn32
+    ppc_darnraw,                               // llvm.ppc.darnraw
+    ppc_dcba,                                  // llvm.ppc.dcba
+    ppc_dcbf,                                  // llvm.ppc.dcbf
+    ppc_dcbfl,                                 // llvm.ppc.dcbfl
+    ppc_dcbflp,                                // llvm.ppc.dcbflp
+    ppc_dcbfps,                                // llvm.ppc.dcbfps
+    ppc_dcbi,                                  // llvm.ppc.dcbi
+    ppc_dcbst,                                 // llvm.ppc.dcbst
+    ppc_dcbstps,                               // llvm.ppc.dcbstps
+    ppc_dcbt,                                  // llvm.ppc.dcbt
+    ppc_dcbt_with_hint,                        // llvm.ppc.dcbt.with.hint
+    ppc_dcbtst,                                // llvm.ppc.dcbtst
+    ppc_dcbtst_with_hint,                      // llvm.ppc.dcbtst.with.hint
+    ppc_dcbz,                                  // llvm.ppc.dcbz
+    ppc_dcbzl,                                 // llvm.ppc.dcbzl
+    ppc_divde,                                 // llvm.ppc.divde
+    ppc_divdeu,                                // llvm.ppc.divdeu
+    ppc_divf128_round_to_odd,                  // llvm.ppc.divf128.round.to.odd
+    ppc_divwe,                                 // llvm.ppc.divwe
+    ppc_divweu,                                // llvm.ppc.divweu
+    ppc_eieio,                                 // llvm.ppc.eieio
+    ppc_fmaf128_round_to_odd,                  // llvm.ppc.fmaf128.round.to.odd
+    ppc_get_texasr,                            // llvm.ppc.get.texasr
+    ppc_get_texasru,                           // llvm.ppc.get.texasru
+    ppc_get_tfhar,                             // llvm.ppc.get.tfhar
+    ppc_get_tfiar,                             // llvm.ppc.get.tfiar
+    ppc_isync,                                 // llvm.ppc.isync
+    ppc_lwsync,                                // llvm.ppc.lwsync
+    ppc_mma_assemble_acc,                      // llvm.ppc.mma.assemble.acc
+    ppc_mma_disassemble_acc,                   // llvm.ppc.mma.disassemble.acc
+    ppc_mma_pmxvbf16ger2,                      // llvm.ppc.mma.pmxvbf16ger2
+    ppc_mma_pmxvbf16ger2nn,                    // llvm.ppc.mma.pmxvbf16ger2nn
+    ppc_mma_pmxvbf16ger2np,                    // llvm.ppc.mma.pmxvbf16ger2np
+    ppc_mma_pmxvbf16ger2pn,                    // llvm.ppc.mma.pmxvbf16ger2pn
+    ppc_mma_pmxvbf16ger2pp,                    // llvm.ppc.mma.pmxvbf16ger2pp
+    ppc_mma_pmxvf16ger2,                       // llvm.ppc.mma.pmxvf16ger2
+    ppc_mma_pmxvf16ger2nn,                     // llvm.ppc.mma.pmxvf16ger2nn
+    ppc_mma_pmxvf16ger2np,                     // llvm.ppc.mma.pmxvf16ger2np
+    ppc_mma_pmxvf16ger2pn,                     // llvm.ppc.mma.pmxvf16ger2pn
+    ppc_mma_pmxvf16ger2pp,                     // llvm.ppc.mma.pmxvf16ger2pp
+    ppc_mma_pmxvf32ger,                        // llvm.ppc.mma.pmxvf32ger
+    ppc_mma_pmxvf32gernn,                      // llvm.ppc.mma.pmxvf32gernn
+    ppc_mma_pmxvf32gernp,                      // llvm.ppc.mma.pmxvf32gernp
+    ppc_mma_pmxvf32gerpn,                      // llvm.ppc.mma.pmxvf32gerpn
+    ppc_mma_pmxvf32gerpp,                      // llvm.ppc.mma.pmxvf32gerpp
+    ppc_mma_pmxvf64ger,                        // llvm.ppc.mma.pmxvf64ger
+    ppc_mma_pmxvf64gernn,                      // llvm.ppc.mma.pmxvf64gernn
+    ppc_mma_pmxvf64gernp,                      // llvm.ppc.mma.pmxvf64gernp
+    ppc_mma_pmxvf64gerpn,                      // llvm.ppc.mma.pmxvf64gerpn
+    ppc_mma_pmxvf64gerpp,                      // llvm.ppc.mma.pmxvf64gerpp
+    ppc_mma_pmxvi16ger2,                       // llvm.ppc.mma.pmxvi16ger2
+    ppc_mma_pmxvi16ger2pp,                     // llvm.ppc.mma.pmxvi16ger2pp
+    ppc_mma_pmxvi16ger2s,                      // llvm.ppc.mma.pmxvi16ger2s
+    ppc_mma_pmxvi16ger2spp,                    // llvm.ppc.mma.pmxvi16ger2spp
+    ppc_mma_pmxvi4ger8,                        // llvm.ppc.mma.pmxvi4ger8
+    ppc_mma_pmxvi4ger8pp,                      // llvm.ppc.mma.pmxvi4ger8pp
+    ppc_mma_pmxvi8ger4,                        // llvm.ppc.mma.pmxvi8ger4
+    ppc_mma_pmxvi8ger4pp,                      // llvm.ppc.mma.pmxvi8ger4pp
+    ppc_mma_pmxvi8ger4spp,                     // llvm.ppc.mma.pmxvi8ger4spp
+    ppc_mma_xvbf16ger2,                        // llvm.ppc.mma.xvbf16ger2
+    ppc_mma_xvbf16ger2nn,                      // llvm.ppc.mma.xvbf16ger2nn
+    ppc_mma_xvbf16ger2np,                      // llvm.ppc.mma.xvbf16ger2np
+    ppc_mma_xvbf16ger2pn,                      // llvm.ppc.mma.xvbf16ger2pn
+    ppc_mma_xvbf16ger2pp,                      // llvm.ppc.mma.xvbf16ger2pp
+    ppc_mma_xvf16ger2,                         // llvm.ppc.mma.xvf16ger2
+    ppc_mma_xvf16ger2nn,                       // llvm.ppc.mma.xvf16ger2nn
+    ppc_mma_xvf16ger2np,                       // llvm.ppc.mma.xvf16ger2np
+    ppc_mma_xvf16ger2pn,                       // llvm.ppc.mma.xvf16ger2pn
+    ppc_mma_xvf16ger2pp,                       // llvm.ppc.mma.xvf16ger2pp
+    ppc_mma_xvf32ger,                          // llvm.ppc.mma.xvf32ger
+    ppc_mma_xvf32gernn,                        // llvm.ppc.mma.xvf32gernn
+    ppc_mma_xvf32gernp,                        // llvm.ppc.mma.xvf32gernp
+    ppc_mma_xvf32gerpn,                        // llvm.ppc.mma.xvf32gerpn
+    ppc_mma_xvf32gerpp,                        // llvm.ppc.mma.xvf32gerpp
+    ppc_mma_xvf64ger,                          // llvm.ppc.mma.xvf64ger
+    ppc_mma_xvf64gernn,                        // llvm.ppc.mma.xvf64gernn
+    ppc_mma_xvf64gernp,                        // llvm.ppc.mma.xvf64gernp
+    ppc_mma_xvf64gerpn,                        // llvm.ppc.mma.xvf64gerpn
+    ppc_mma_xvf64gerpp,                        // llvm.ppc.mma.xvf64gerpp
+    ppc_mma_xvi16ger2,                         // llvm.ppc.mma.xvi16ger2
+    ppc_mma_xvi16ger2pp,                       // llvm.ppc.mma.xvi16ger2pp
+    ppc_mma_xvi16ger2s,                        // llvm.ppc.mma.xvi16ger2s
+    ppc_mma_xvi16ger2spp,                      // llvm.ppc.mma.xvi16ger2spp
+    ppc_mma_xvi4ger8,                          // llvm.ppc.mma.xvi4ger8
+    ppc_mma_xvi4ger8pp,                        // llvm.ppc.mma.xvi4ger8pp
+    ppc_mma_xvi8ger4,                          // llvm.ppc.mma.xvi8ger4
+    ppc_mma_xvi8ger4pp,                        // llvm.ppc.mma.xvi8ger4pp
+    ppc_mma_xvi8ger4spp,                       // llvm.ppc.mma.xvi8ger4spp
+    ppc_mma_xxmfacc,                           // llvm.ppc.mma.xxmfacc
+    ppc_mma_xxmtacc,                           // llvm.ppc.mma.xxmtacc
+    ppc_mma_xxsetaccz,                         // llvm.ppc.mma.xxsetaccz
+    ppc_mulf128_round_to_odd,                  // llvm.ppc.mulf128.round.to.odd
+    ppc_pdepd,                                 // llvm.ppc.pdepd
+    ppc_pextd,                                 // llvm.ppc.pextd
+    ppc_popcntb,                               // llvm.ppc.popcntb
+    ppc_readflm,                               // llvm.ppc.readflm
+    ppc_scalar_extract_expq,                   // llvm.ppc.scalar.extract.expq
+    ppc_scalar_insert_exp_qp,                  // llvm.ppc.scalar.insert.exp.qp
+    ppc_set_texasr,                            // llvm.ppc.set.texasr
+    ppc_set_texasru,                           // llvm.ppc.set.texasru
+    ppc_set_tfhar,                             // llvm.ppc.set.tfhar
+    ppc_set_tfiar,                             // llvm.ppc.set.tfiar
+    ppc_setflm,                                // llvm.ppc.setflm
+    ppc_setrnd,                                // llvm.ppc.setrnd
+    ppc_sqrtf128_round_to_odd,                 // llvm.ppc.sqrtf128.round.to.odd
+    ppc_subf128_round_to_odd,                  // llvm.ppc.subf128.round.to.odd
+    ppc_sync,                                  // llvm.ppc.sync
+    ppc_tabort,                                // llvm.ppc.tabort
+    ppc_tabortdc,                              // llvm.ppc.tabortdc
+    ppc_tabortdci,                             // llvm.ppc.tabortdci
+    ppc_tabortwc,                              // llvm.ppc.tabortwc
+    ppc_tabortwci,                             // llvm.ppc.tabortwci
+    ppc_tbegin,                                // llvm.ppc.tbegin
+    ppc_tcheck,                                // llvm.ppc.tcheck
+    ppc_tend,                                  // llvm.ppc.tend
+    ppc_tendall,                               // llvm.ppc.tendall
+    ppc_trechkpt,                              // llvm.ppc.trechkpt
+    ppc_treclaim,                              // llvm.ppc.treclaim
+    ppc_tresume,                               // llvm.ppc.tresume
+    ppc_truncf128_round_to_odd,                // llvm.ppc.truncf128.round.to.odd
+    ppc_tsr,                                   // llvm.ppc.tsr
+    ppc_tsuspend,                              // llvm.ppc.tsuspend
+    ppc_ttest,                                 // llvm.ppc.ttest
+    ppc_vsx_assemble_pair,                     // llvm.ppc.vsx.assemble.pair
+    ppc_vsx_disassemble_pair,                  // llvm.ppc.vsx.disassemble.pair
+    ppc_vsx_lxvd2x,                            // llvm.ppc.vsx.lxvd2x
+    ppc_vsx_lxvd2x_be,                         // llvm.ppc.vsx.lxvd2x.be
+    ppc_vsx_lxvl,                              // llvm.ppc.vsx.lxvl
+    ppc_vsx_lxvll,                             // llvm.ppc.vsx.lxvll
+    ppc_vsx_lxvp,                              // llvm.ppc.vsx.lxvp
+    ppc_vsx_lxvw4x,                            // llvm.ppc.vsx.lxvw4x
+    ppc_vsx_lxvw4x_be,                         // llvm.ppc.vsx.lxvw4x.be
+    ppc_vsx_stxvd2x,                           // llvm.ppc.vsx.stxvd2x
+    ppc_vsx_stxvd2x_be,                        // llvm.ppc.vsx.stxvd2x.be
+    ppc_vsx_stxvl,                             // llvm.ppc.vsx.stxvl
+    ppc_vsx_stxvll,                            // llvm.ppc.vsx.stxvll
+    ppc_vsx_stxvp,                             // llvm.ppc.vsx.stxvp
+    ppc_vsx_stxvw4x,                           // llvm.ppc.vsx.stxvw4x
+    ppc_vsx_stxvw4x_be,                        // llvm.ppc.vsx.stxvw4x.be
+    ppc_vsx_xsmaxdp,                           // llvm.ppc.vsx.xsmaxdp
+    ppc_vsx_xsmindp,                           // llvm.ppc.vsx.xsmindp
+    ppc_vsx_xvcmpeqdp,                         // llvm.ppc.vsx.xvcmpeqdp
+    ppc_vsx_xvcmpeqdp_p,                       // llvm.ppc.vsx.xvcmpeqdp.p
+    ppc_vsx_xvcmpeqsp,                         // llvm.ppc.vsx.xvcmpeqsp
+    ppc_vsx_xvcmpeqsp_p,                       // llvm.ppc.vsx.xvcmpeqsp.p
+    ppc_vsx_xvcmpgedp,                         // llvm.ppc.vsx.xvcmpgedp
+    ppc_vsx_xvcmpgedp_p,                       // llvm.ppc.vsx.xvcmpgedp.p
+    ppc_vsx_xvcmpgesp,                         // llvm.ppc.vsx.xvcmpgesp
+    ppc_vsx_xvcmpgesp_p,                       // llvm.ppc.vsx.xvcmpgesp.p
+    ppc_vsx_xvcmpgtdp,                         // llvm.ppc.vsx.xvcmpgtdp
+    ppc_vsx_xvcmpgtdp_p,                       // llvm.ppc.vsx.xvcmpgtdp.p
+    ppc_vsx_xvcmpgtsp,                         // llvm.ppc.vsx.xvcmpgtsp
+    ppc_vsx_xvcmpgtsp_p,                       // llvm.ppc.vsx.xvcmpgtsp.p
+    ppc_vsx_xvcvbf16spn,                       // llvm.ppc.vsx.xvcvbf16spn
+    ppc_vsx_xvcvdpsp,                          // llvm.ppc.vsx.xvcvdpsp
+    ppc_vsx_xvcvdpsxws,                        // llvm.ppc.vsx.xvcvdpsxws
+    ppc_vsx_xvcvdpuxws,                        // llvm.ppc.vsx.xvcvdpuxws
+    ppc_vsx_xvcvhpsp,                          // llvm.ppc.vsx.xvcvhpsp
+    ppc_vsx_xvcvspbf16,                        // llvm.ppc.vsx.xvcvspbf16
+    ppc_vsx_xvcvspdp,                          // llvm.ppc.vsx.xvcvspdp
+    ppc_vsx_xvcvsphp,                          // llvm.ppc.vsx.xvcvsphp
+    ppc_vsx_xvcvsxdsp,                         // llvm.ppc.vsx.xvcvsxdsp
+    ppc_vsx_xvcvsxwdp,                         // llvm.ppc.vsx.xvcvsxwdp
+    ppc_vsx_xvcvuxdsp,                         // llvm.ppc.vsx.xvcvuxdsp
+    ppc_vsx_xvcvuxwdp,                         // llvm.ppc.vsx.xvcvuxwdp
+    ppc_vsx_xvdivdp,                           // llvm.ppc.vsx.xvdivdp
+    ppc_vsx_xvdivsp,                           // llvm.ppc.vsx.xvdivsp
+    ppc_vsx_xviexpdp,                          // llvm.ppc.vsx.xviexpdp
+    ppc_vsx_xviexpsp,                          // llvm.ppc.vsx.xviexpsp
+    ppc_vsx_xvmaxdp,                           // llvm.ppc.vsx.xvmaxdp
+    ppc_vsx_xvmaxsp,                           // llvm.ppc.vsx.xvmaxsp
+    ppc_vsx_xvmindp,                           // llvm.ppc.vsx.xvmindp
+    ppc_vsx_xvminsp,                           // llvm.ppc.vsx.xvminsp
+    ppc_vsx_xvrdpip,                           // llvm.ppc.vsx.xvrdpip
+    ppc_vsx_xvredp,                            // llvm.ppc.vsx.xvredp
+    ppc_vsx_xvresp,                            // llvm.ppc.vsx.xvresp
+    ppc_vsx_xvrspip,                           // llvm.ppc.vsx.xvrspip
+    ppc_vsx_xvrsqrtedp,                        // llvm.ppc.vsx.xvrsqrtedp
+    ppc_vsx_xvrsqrtesp,                        // llvm.ppc.vsx.xvrsqrtesp
+    ppc_vsx_xvtdivdp,                          // llvm.ppc.vsx.xvtdivdp
+    ppc_vsx_xvtdivsp,                          // llvm.ppc.vsx.xvtdivsp
+    ppc_vsx_xvtlsbb,                           // llvm.ppc.vsx.xvtlsbb
+    ppc_vsx_xvtsqrtdp,                         // llvm.ppc.vsx.xvtsqrtdp
+    ppc_vsx_xvtsqrtsp,                         // llvm.ppc.vsx.xvtsqrtsp
+    ppc_vsx_xvtstdcdp,                         // llvm.ppc.vsx.xvtstdcdp
+    ppc_vsx_xvtstdcsp,                         // llvm.ppc.vsx.xvtstdcsp
+    ppc_vsx_xvxexpdp,                          // llvm.ppc.vsx.xvxexpdp
+    ppc_vsx_xvxexpsp,                          // llvm.ppc.vsx.xvxexpsp
+    ppc_vsx_xvxsigdp,                          // llvm.ppc.vsx.xvxsigdp
+    ppc_vsx_xvxsigsp,                          // llvm.ppc.vsx.xvxsigsp
+    ppc_vsx_xxblendvb,                         // llvm.ppc.vsx.xxblendvb
+    ppc_vsx_xxblendvd,                         // llvm.ppc.vsx.xxblendvd
+    ppc_vsx_xxblendvh,                         // llvm.ppc.vsx.xxblendvh
+    ppc_vsx_xxblendvw,                         // llvm.ppc.vsx.xxblendvw
+    ppc_vsx_xxeval,                            // llvm.ppc.vsx.xxeval
+    ppc_vsx_xxextractuw,                       // llvm.ppc.vsx.xxextractuw
+    ppc_vsx_xxgenpcvbm,                        // llvm.ppc.vsx.xxgenpcvbm
+    ppc_vsx_xxgenpcvdm,                        // llvm.ppc.vsx.xxgenpcvdm
+    ppc_vsx_xxgenpcvhm,                        // llvm.ppc.vsx.xxgenpcvhm
+    ppc_vsx_xxgenpcvwm,                        // llvm.ppc.vsx.xxgenpcvwm
+    ppc_vsx_xxinsertw,                         // llvm.ppc.vsx.xxinsertw
+    ppc_vsx_xxleqv,                            // llvm.ppc.vsx.xxleqv
+    ppc_vsx_xxpermx,                           // llvm.ppc.vsx.xxpermx
+}; // enum
+} // namespace Intrinsic
+} // namespace llvm
+
+#endif
diff --git a/linux-x64/clang/include/llvm/IR/IntrinsicsPowerPC.td b/linux-x64/clang/include/llvm/IR/IntrinsicsPowerPC.td
index f873174..075b625 100644
--- a/linux-x64/clang/include/llvm/IR/IntrinsicsPowerPC.td
+++ b/linux-x64/clang/include/llvm/IR/IntrinsicsPowerPC.td
@@ -18,30 +18,43 @@
 let TargetPrefix = "ppc" in {  // All intrinsics start with "llvm.ppc.".
   // dcba/dcbf/dcbi/dcbst/dcbt/dcbz/dcbzl(PPC970) instructions.
   def int_ppc_dcba  : Intrinsic<[], [llvm_ptr_ty], []>;
-  def int_ppc_dcbf  : GCCBuiltin<"__builtin_dcbf">,
-                      Intrinsic<[], [llvm_ptr_ty], []>;
+  def int_ppc_dcbf : GCCBuiltin<"__builtin_dcbf">,
+                      Intrinsic<[], [llvm_ptr_ty], [IntrArgMemOnly]>;
+  def int_ppc_dcbfl : Intrinsic<[], [llvm_ptr_ty], [IntrArgMemOnly]>;
+  def int_ppc_dcbflp : Intrinsic<[], [llvm_ptr_ty], [IntrArgMemOnly]>;
+  def int_ppc_dcbfps : Intrinsic<[], [llvm_ptr_ty], [IntrArgMemOnly]>;
+  def int_ppc_dcbstps : Intrinsic<[], [llvm_ptr_ty], [IntrArgMemOnly]>;
   def int_ppc_dcbi  : Intrinsic<[], [llvm_ptr_ty], []>;
   def int_ppc_dcbst : Intrinsic<[], [llvm_ptr_ty], []>;
   def int_ppc_dcbt  : Intrinsic<[], [llvm_ptr_ty],
-    [IntrArgMemOnly, NoCapture<0>]>;
+    [IntrArgMemOnly, NoCapture<ArgIndex<0>>]>;
   def int_ppc_dcbtst: Intrinsic<[], [llvm_ptr_ty],
-    [IntrArgMemOnly, NoCapture<0>]>;
+    [IntrArgMemOnly, NoCapture<ArgIndex<0>>]>;
+  def int_ppc_dcbt_with_hint: Intrinsic<[], [llvm_ptr_ty, llvm_i32_ty],
+    [IntrArgMemOnly, NoCapture<ArgIndex<0>>, ImmArg<ArgIndex<1>>]>;
+  def int_ppc_dcbtst_with_hint: Intrinsic<[], [llvm_ptr_ty, llvm_i32_ty],
+    [IntrArgMemOnly, NoCapture<ArgIndex<0>>, ImmArg<ArgIndex<1>>]>;
   def int_ppc_dcbz  : Intrinsic<[], [llvm_ptr_ty], []>;
   def int_ppc_dcbzl : Intrinsic<[], [llvm_ptr_ty], []>;
 
+  // Population Count in each Byte.
+  def int_ppc_popcntb : Intrinsic<[llvm_i64_ty], [llvm_i64_ty], [IntrNoMem]>;
+
   // sync instruction (i.e. sync 0, a.k.a hwsync)
   def int_ppc_sync : Intrinsic<[], [], []>;
+  // isync instruction
+  def int_ppc_isync : Intrinsic<[], [], []>;
   // lwsync is sync 1
   def int_ppc_lwsync : Intrinsic<[], [], []>;
+  // eieio instruction
+  def int_ppc_eieio : Intrinsic<[],[],[]>;
 
-  // Intrinsics used to generate ctr-based loops. These should only be
-  // generated by the PowerPC backend!
-  // The branch intrinsic is marked as NoDuplicate because loop rotation will
-  // attempt to duplicate it forming loops where a block reachable from one
-  // instance of it can contain another.
-  def int_ppc_mtctr : Intrinsic<[], [llvm_anyint_ty], []>;
-  def int_ppc_is_decremented_ctr_nonzero :
-    Intrinsic<[llvm_i1_ty], [], [IntrNoDuplicate]>;
+  // Get content from current FPSCR register
+  def int_ppc_readflm : GCCBuiltin<"__builtin_readflm">,
+                        Intrinsic<[llvm_double_ty], [], [IntrNoMem]>;
+  // Set FPSCR register, and return previous content
+  def int_ppc_setflm : GCCBuiltin<"__builtin_setflm">,
+                       Intrinsic<[llvm_double_ty], [llvm_double_ty], []>;
 
   // Intrinsics for [double]word extended forms of divide instructions
   def int_ppc_divwe : GCCBuiltin<"__builtin_divwe">,
@@ -57,11 +70,40 @@
                        Intrinsic<[llvm_i64_ty], [llvm_i64_ty, llvm_i64_ty],
                                  [IntrNoMem]>;
 
+  // Generate a random number
+  def int_ppc_darn : GCCBuiltin<"__builtin_darn">,
+                     Intrinsic<[llvm_i64_ty], [], [IntrNoMem]>;
+  def int_ppc_darnraw : GCCBuiltin<"__builtin_darn_raw">,
+                     Intrinsic<[llvm_i64_ty], [], [IntrNoMem]>;
+  def int_ppc_darn32 : GCCBuiltin<"__builtin_darn_32">,
+                     Intrinsic<[llvm_i32_ty], [], [IntrNoMem]>;
+
   // Bit permute doubleword
   def int_ppc_bpermd : GCCBuiltin<"__builtin_bpermd">,
                        Intrinsic<[llvm_i64_ty], [llvm_i64_ty, llvm_i64_ty],
                                  [IntrNoMem]>;
 
+  // Parallel Bits Deposit/Extract Doubleword Builtins.
+  def int_ppc_pdepd
+      : GCCBuiltin<"__builtin_pdepd">,
+        Intrinsic <[llvm_i64_ty], [llvm_i64_ty, llvm_i64_ty], [IntrNoMem]>;
+  def int_ppc_pextd
+      : GCCBuiltin<"__builtin_pextd">,
+        Intrinsic <[llvm_i64_ty], [llvm_i64_ty, llvm_i64_ty], [IntrNoMem]>;
+
+  // Centrifuge Doubleword Builtin.
+  def int_ppc_cfuged
+      : GCCBuiltin<"__builtin_cfuged">,
+        Intrinsic <[llvm_i64_ty], [llvm_i64_ty, llvm_i64_ty], [IntrNoMem]>;
+
+  // Count Leading / Trailing Zeroes under bit Mask Builtins.
+  def int_ppc_cntlzdm
+      : GCCBuiltin<"__builtin_cntlzdm">,
+        Intrinsic <[llvm_i64_ty], [llvm_i64_ty, llvm_i64_ty], [IntrNoMem]>;
+  def int_ppc_cnttzdm
+      : GCCBuiltin<"__builtin_cnttzdm">,
+        Intrinsic <[llvm_i64_ty], [llvm_i64_ty, llvm_i64_ty], [IntrNoMem]>;
+
   def int_ppc_truncf128_round_to_odd
       : GCCBuiltin<"__builtin_truncf128_round_to_odd">,
         Intrinsic <[llvm_double_ty], [llvm_f128_ty], [IntrNoMem]>;
@@ -110,6 +152,28 @@
 }
 
 //===----------------------------------------------------------------------===//
+// PowerPC MMA Intrinsic Multi Class Definitions.
+//
+
+multiclass PowerPC_MMA_ACC_Intrinsic<list<LLVMType> args> {
+  def NAME: Intrinsic<[llvm_v512i1_ty], args, [IntrNoMem]>;
+  def pp : Intrinsic<[llvm_v512i1_ty], !listconcat([llvm_v512i1_ty], args),
+                     [IntrNoMem]>;
+  def pn : Intrinsic<[llvm_v512i1_ty], !listconcat([llvm_v512i1_ty], args),
+                     [IntrNoMem]>;
+  def np : Intrinsic<[llvm_v512i1_ty], !listconcat([llvm_v512i1_ty], args),
+                     [IntrNoMem]>;
+  def nn : Intrinsic<[llvm_v512i1_ty], !listconcat([llvm_v512i1_ty], args),
+                     [IntrNoMem]>;
+}
+
+multiclass PowerPC_MMA_ACC_PP_Intrinsic<list<LLVMType> args> {
+  def NAME: Intrinsic<[llvm_v512i1_ty], args, [IntrNoMem]>;
+  def pp : Intrinsic<[llvm_v512i1_ty], !listconcat([llvm_v512i1_ty], args),
+                     [IntrNoMem]>;
+}
+
+//===----------------------------------------------------------------------===//
 // PowerPC Altivec Intrinsic Class Definitions.
 //
 
@@ -161,6 +225,13 @@
                          [llvm_v1i128_ty], [llvm_v1i128_ty, llvm_v1i128_ty],
                          [IntrNoMem]>;
 
+/// PowerPC_Vec_QDD_Intrinsic - A PowerPC intrinsic that takes two v2i64
+/// vectors and returns one v1i128. These intrinsics have no side effects.
+class PowerPC_Vec_QDD_Intrinsic<string GCCIntSuffix>
+  : PowerPC_Vec_Intrinsic<GCCIntSuffix,
+                          [llvm_v1i128_ty], [llvm_v2i64_ty, llvm_v2i64_ty],
+                          [IntrNoMem]>;
+
 //===----------------------------------------------------------------------===//
 // PowerPC VSX Intrinsic Class Definitions.
 //
@@ -214,9 +285,9 @@
 
   // VSCR access.
   def int_ppc_altivec_mfvscr : GCCBuiltin<"__builtin_altivec_mfvscr">,
-              Intrinsic<[llvm_v8i16_ty], [], [IntrReadMem]>;
+              Intrinsic<[llvm_v8i16_ty], [], [IntrNoMem, IntrHasSideEffects]>;
   def int_ppc_altivec_mtvscr : GCCBuiltin<"__builtin_altivec_mtvscr">,
-              Intrinsic<[], [llvm_v4i32_ty], []>;
+              Intrinsic<[], [llvm_v4i32_ty], [IntrNoMem, IntrHasSideEffects]>;
 
 
   // Loads.  These don't map directly to GCC builtins because they represent the
@@ -322,6 +393,28 @@
               Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_v16i8_ty],
                         [IntrNoMem]>;
 
+  def int_ppc_altivec_vcmpequq : GCCBuiltin<"__builtin_altivec_vcmpequq">,
+              Intrinsic<[llvm_v1i128_ty], [llvm_v1i128_ty, llvm_v1i128_ty],
+                        [IntrNoMem]>;
+  def int_ppc_altivec_vcmpgtsq : GCCBuiltin<"__builtin_altivec_vcmpgtsq">,
+              Intrinsic<[llvm_v1i128_ty], [llvm_v1i128_ty, llvm_v1i128_ty],
+                        [IntrNoMem]>;
+  def int_ppc_altivec_vcmpgtuq : GCCBuiltin<"__builtin_altivec_vcmpgtuq">,
+              Intrinsic<[llvm_v1i128_ty], [llvm_v1i128_ty, llvm_v1i128_ty],
+                        [IntrNoMem]>;
+  def int_ppc_altivec_vcmpequq_p : GCCBuiltin<"__builtin_altivec_vcmpequq_p">,
+              Intrinsic<[llvm_i32_ty],
+                        [llvm_i32_ty,llvm_v1i128_ty,llvm_v1i128_ty],
+                        [IntrNoMem]>;
+  def int_ppc_altivec_vcmpgtsq_p : GCCBuiltin<"__builtin_altivec_vcmpgtsq_p">,
+              Intrinsic<[llvm_i32_ty],
+                        [llvm_i32_ty,llvm_v1i128_ty,llvm_v1i128_ty],
+                        [IntrNoMem]>;
+  def int_ppc_altivec_vcmpgtuq_p : GCCBuiltin<"__builtin_altivec_vcmpgtuq_p">,
+              Intrinsic<[llvm_i32_ty],
+                        [llvm_i32_ty,llvm_v1i128_ty,llvm_v1i128_ty],
+                        [IntrNoMem]>;
+
   // Predicate Comparisons.  The first operand specifies interpretation of CR6.
   def int_ppc_altivec_vcmpbfp_p : GCCBuiltin<"__builtin_altivec_vcmpbfp_p">,
               Intrinsic<[llvm_i32_ty],[llvm_i32_ty,llvm_v4f32_ty,llvm_v4f32_ty],
@@ -404,6 +497,210 @@
   def int_ppc_altivec_vprtybq : GCCBuiltin<"__builtin_altivec_vprtybq">,
               Intrinsic<[llvm_v1i128_ty],[llvm_v1i128_ty],[IntrNoMem]>;
 
+  // P10 Vector Extract with Mask
+  def int_ppc_altivec_vextractbm : GCCBuiltin<"__builtin_altivec_vextractbm">,
+              Intrinsic<[llvm_i32_ty], [llvm_v16i8_ty], [IntrNoMem]>;
+  def int_ppc_altivec_vextracthm : GCCBuiltin<"__builtin_altivec_vextracthm">,
+              Intrinsic<[llvm_i32_ty], [llvm_v8i16_ty], [IntrNoMem]>;
+  def int_ppc_altivec_vextractwm : GCCBuiltin<"__builtin_altivec_vextractwm">,
+              Intrinsic<[llvm_i32_ty], [llvm_v4i32_ty], [IntrNoMem]>;
+  def int_ppc_altivec_vextractdm : GCCBuiltin<"__builtin_altivec_vextractdm">,
+              Intrinsic<[llvm_i32_ty], [llvm_v2i64_ty], [IntrNoMem]>;
+  def int_ppc_altivec_vextractqm : GCCBuiltin<"__builtin_altivec_vextractqm">,
+              Intrinsic<[llvm_i32_ty], [llvm_v1i128_ty], [IntrNoMem]>;
+
+  // P10 Vector Expand with Mask
+  def int_ppc_altivec_vexpandbm : GCCBuiltin<"__builtin_altivec_vexpandbm">,
+              Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty], [IntrNoMem]>;
+  def int_ppc_altivec_vexpandhm : GCCBuiltin<"__builtin_altivec_vexpandhm">,
+              Intrinsic<[llvm_v8i16_ty], [llvm_v8i16_ty], [IntrNoMem]>;
+  def int_ppc_altivec_vexpandwm : GCCBuiltin<"__builtin_altivec_vexpandwm">,
+              Intrinsic<[llvm_v4i32_ty], [llvm_v4i32_ty], [IntrNoMem]>;
+  def int_ppc_altivec_vexpanddm : GCCBuiltin<"__builtin_altivec_vexpanddm">,
+              Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty], [IntrNoMem]>;
+  def int_ppc_altivec_vexpandqm : GCCBuiltin<"__builtin_altivec_vexpandqm">,
+              Intrinsic<[llvm_v1i128_ty], [llvm_v1i128_ty], [IntrNoMem]>;
+
+  // P10 Vector Count with Mask intrinsics.
+  def int_ppc_altivec_vcntmbb : GCCBuiltin<"__builtin_altivec_vcntmbb">,
+              Intrinsic<[llvm_i64_ty], [llvm_v16i8_ty, llvm_i32_ty],
+                        [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+  def int_ppc_altivec_vcntmbh : GCCBuiltin<"__builtin_altivec_vcntmbh">,
+              Intrinsic<[llvm_i64_ty], [llvm_v8i16_ty, llvm_i32_ty],
+                        [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+  def int_ppc_altivec_vcntmbw : GCCBuiltin<"__builtin_altivec_vcntmbw">,
+              Intrinsic<[llvm_i64_ty], [llvm_v4i32_ty, llvm_i32_ty],
+                        [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+  def int_ppc_altivec_vcntmbd : GCCBuiltin<"__builtin_altivec_vcntmbd">,
+              Intrinsic<[llvm_i64_ty], [llvm_v2i64_ty, llvm_i32_ty],
+                        [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+  // P10 Move to VSR with Mask Intrinsics.
+  def int_ppc_altivec_mtvsrbm : GCCBuiltin<"__builtin_altivec_mtvsrbm">,
+              Intrinsic<[llvm_v16i8_ty], [llvm_i64_ty], [IntrNoMem]>;
+  def int_ppc_altivec_mtvsrhm : GCCBuiltin<"__builtin_altivec_mtvsrhm">,
+              Intrinsic<[llvm_v8i16_ty], [llvm_i64_ty], [IntrNoMem]>;
+  def int_ppc_altivec_mtvsrwm : GCCBuiltin<"__builtin_altivec_mtvsrwm">,
+              Intrinsic<[llvm_v4i32_ty], [llvm_i64_ty], [IntrNoMem]>;
+  def int_ppc_altivec_mtvsrdm : GCCBuiltin<"__builtin_altivec_mtvsrdm">,
+              Intrinsic<[llvm_v2i64_ty], [llvm_i64_ty], [IntrNoMem]>;
+  def int_ppc_altivec_mtvsrqm : GCCBuiltin<"__builtin_altivec_mtvsrqm">,
+              Intrinsic<[llvm_v1i128_ty], [llvm_i64_ty], [IntrNoMem]>;
+
+  // P10 Vector Parallel Bits Deposit/Extract Doubleword Builtins.
+  def int_ppc_altivec_vpdepd : GCCBuiltin<"__builtin_altivec_vpdepd">,
+              Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_v2i64_ty],
+                        [IntrNoMem]>;
+  def int_ppc_altivec_vpextd : GCCBuiltin<"__builtin_altivec_vpextd">,
+              Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_v2i64_ty],
+                        [IntrNoMem]>;
+
+  // P10 Vector String Isolate Intrinsics.
+  def int_ppc_altivec_vstribr : GCCBuiltin<"__builtin_altivec_vstribr">,
+              Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty], [IntrNoMem]>;
+  def int_ppc_altivec_vstribl : GCCBuiltin<"__builtin_altivec_vstribl">,
+              Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty], [IntrNoMem]>;
+  def int_ppc_altivec_vstrihr : GCCBuiltin<"__builtin_altivec_vstrihr">,
+              Intrinsic<[llvm_v8i16_ty], [llvm_v8i16_ty], [IntrNoMem]>;
+  def int_ppc_altivec_vstrihl : GCCBuiltin<"__builtin_altivec_vstrihl">,
+              Intrinsic<[llvm_v8i16_ty], [llvm_v8i16_ty], [IntrNoMem]>;
+  // Predicate Intrinsics: The first operand specifies interpretation of CR6.
+  def int_ppc_altivec_vstribr_p : GCCBuiltin<"__builtin_altivec_vstribr_p">,
+              Intrinsic<[llvm_i32_ty], [llvm_i32_ty, llvm_v16i8_ty], [IntrNoMem]>;
+  def int_ppc_altivec_vstribl_p : GCCBuiltin<"__builtin_altivec_vstribl_p">,
+              Intrinsic<[llvm_i32_ty], [llvm_i32_ty, llvm_v16i8_ty], [IntrNoMem]>;
+  def int_ppc_altivec_vstrihr_p : GCCBuiltin<"__builtin_altivec_vstrihr_p">,
+              Intrinsic<[llvm_i32_ty], [llvm_i32_ty, llvm_v8i16_ty], [IntrNoMem]>;
+  def int_ppc_altivec_vstrihl_p : GCCBuiltin<"__builtin_altivec_vstrihl_p">,
+              Intrinsic<[llvm_i32_ty], [llvm_i32_ty, llvm_v8i16_ty], [IntrNoMem]>;
+
+  // P10 Vector Centrifuge Builtin.
+  def int_ppc_altivec_vcfuged : GCCBuiltin<"__builtin_altivec_vcfuged">,
+              Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_v2i64_ty],
+                        [IntrNoMem]>;
+
+  // P10 Vector Gather Every Nth Bit Builtin.
+  def int_ppc_altivec_vgnb : GCCBuiltin<"__builtin_altivec_vgnb">,
+              Intrinsic<[llvm_i64_ty], [llvm_v1i128_ty, llvm_i32_ty],
+                        [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+
+   // P10 Vector Clear Bytes
+   def int_ppc_altivec_vclrlb :  GCCBuiltin<"__builtin_altivec_vclrlb">,
+               Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_i32_ty],
+                         [IntrNoMem]>;
+   def int_ppc_altivec_vclrrb :  GCCBuiltin<"__builtin_altivec_vclrrb">,
+               Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_i32_ty],
+                         [IntrNoMem]>;
+
+  // P10 Vector Shift Double Bit Immediate.
+  def int_ppc_altivec_vsldbi : GCCBuiltin<"__builtin_altivec_vsldbi">,
+              Intrinsic<[llvm_v16i8_ty],
+                        [llvm_v16i8_ty, llvm_v16i8_ty, llvm_i32_ty],
+                        [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+  def int_ppc_altivec_vsrdbi : GCCBuiltin<"__builtin_altivec_vsrdbi">,
+              Intrinsic<[llvm_v16i8_ty],
+                        [llvm_v16i8_ty, llvm_v16i8_ty, llvm_i32_ty],
+                        [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+  // P10 Vector Insert.
+  def int_ppc_altivec_vinsblx : GCCBuiltin<"__builtin_altivec_vinsblx">,
+              Intrinsic<[llvm_v16i8_ty],
+                        [llvm_v16i8_ty, llvm_i32_ty, llvm_i32_ty],
+                        [IntrNoMem]>;
+  def int_ppc_altivec_vinsbrx : GCCBuiltin<"__builtin_altivec_vinsbrx">,
+              Intrinsic<[llvm_v16i8_ty],
+                        [llvm_v16i8_ty, llvm_i32_ty, llvm_i32_ty],
+                        [IntrNoMem]>;
+  def int_ppc_altivec_vinshlx : GCCBuiltin<"__builtin_altivec_vinshlx">,
+              Intrinsic<[llvm_v8i16_ty],
+                        [llvm_v8i16_ty, llvm_i32_ty, llvm_i32_ty],
+                        [IntrNoMem]>;
+  def int_ppc_altivec_vinshrx : GCCBuiltin<"__builtin_altivec_vinshrx">,
+              Intrinsic<[llvm_v8i16_ty],
+                        [llvm_v8i16_ty, llvm_i32_ty, llvm_i32_ty],
+                        [IntrNoMem]>;
+  def int_ppc_altivec_vinswlx : GCCBuiltin<"__builtin_altivec_vinswlx">,
+              Intrinsic<[llvm_v4i32_ty],
+                        [llvm_v4i32_ty, llvm_i32_ty, llvm_i32_ty],
+                        [IntrNoMem]>;
+  def int_ppc_altivec_vinswrx : GCCBuiltin<"__builtin_altivec_vinswrx">,
+              Intrinsic<[llvm_v4i32_ty],
+                        [llvm_v4i32_ty, llvm_i32_ty, llvm_i32_ty],
+                        [IntrNoMem]>;
+  def int_ppc_altivec_vinsdlx : GCCBuiltin<"__builtin_altivec_vinsdlx">,
+              Intrinsic<[llvm_v2i64_ty],
+                        [llvm_v2i64_ty, llvm_i64_ty, llvm_i64_ty],
+                        [IntrNoMem]>;
+  def int_ppc_altivec_vinsdrx : GCCBuiltin<"__builtin_altivec_vinsdrx">,
+              Intrinsic<[llvm_v2i64_ty],
+                        [llvm_v2i64_ty, llvm_i64_ty, llvm_i64_ty],
+                        [IntrNoMem]>;
+  def int_ppc_altivec_vinsbvlx : GCCBuiltin<"__builtin_altivec_vinsbvlx">,
+              Intrinsic<[llvm_v16i8_ty],
+                        [llvm_v16i8_ty, llvm_i32_ty, llvm_v16i8_ty],
+                        [IntrNoMem]>;
+  def int_ppc_altivec_vinsbvrx : GCCBuiltin<"__builtin_altivec_vinsbvrx">,
+              Intrinsic<[llvm_v16i8_ty],
+                        [llvm_v16i8_ty, llvm_i32_ty, llvm_v16i8_ty],
+                        [IntrNoMem]>;
+  def int_ppc_altivec_vinshvlx : GCCBuiltin<"__builtin_altivec_vinshvlx">,
+              Intrinsic<[llvm_v8i16_ty],
+                        [llvm_v8i16_ty, llvm_i32_ty, llvm_v8i16_ty],
+                        [IntrNoMem]>;
+ def int_ppc_altivec_vinshvrx : GCCBuiltin<"__builtin_altivec_vinshvrx">,
+              Intrinsic<[llvm_v8i16_ty],
+                        [llvm_v8i16_ty, llvm_i32_ty, llvm_v8i16_ty],
+                        [IntrNoMem]>;
+  def int_ppc_altivec_vinswvlx : GCCBuiltin<"__builtin_altivec_vinswvlx">,
+              Intrinsic<[llvm_v4i32_ty],
+                        [llvm_v4i32_ty, llvm_i32_ty, llvm_v4i32_ty],
+                        [IntrNoMem]>;
+  def int_ppc_altivec_vinswvrx : GCCBuiltin<"__builtin_altivec_vinswvrx">,
+              Intrinsic<[llvm_v4i32_ty],
+                        [llvm_v4i32_ty, llvm_i32_ty, llvm_v4i32_ty],
+                        [IntrNoMem]>;
+  // P10 Vector Insert with immediate.
+  def int_ppc_altivec_vinsw :
+              Intrinsic<[llvm_v4i32_ty],
+                        [llvm_v4i32_ty, llvm_i32_ty, llvm_i32_ty],
+                        [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+  def int_ppc_altivec_vinsd :
+              Intrinsic<[llvm_v2i64_ty],
+                        [llvm_v2i64_ty, llvm_i64_ty, llvm_i32_ty],
+                        [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+  // P10 Vector Extract.
+  def int_ppc_altivec_vextdubvlx : GCCBuiltin<"__builtin_altivec_vextdubvlx">,
+              Intrinsic<[llvm_v2i64_ty],
+                        [llvm_v16i8_ty, llvm_v16i8_ty, llvm_i32_ty],
+                        [IntrNoMem]>;
+  def int_ppc_altivec_vextdubvrx : GCCBuiltin<"__builtin_altivec_vextdubvrx">,
+              Intrinsic<[llvm_v2i64_ty],
+                        [llvm_v16i8_ty, llvm_v16i8_ty, llvm_i32_ty],
+                        [IntrNoMem]>;
+  def int_ppc_altivec_vextduhvlx : GCCBuiltin<"__builtin_altivec_vextduhvlx">,
+              Intrinsic<[llvm_v2i64_ty],
+                        [llvm_v8i16_ty, llvm_v8i16_ty, llvm_i32_ty],
+                        [IntrNoMem]>;
+  def int_ppc_altivec_vextduhvrx : GCCBuiltin<"__builtin_altivec_vextduhvrx">,
+              Intrinsic<[llvm_v2i64_ty],
+                        [llvm_v8i16_ty, llvm_v8i16_ty, llvm_i32_ty],
+                        [IntrNoMem]>;
+  def int_ppc_altivec_vextduwvlx : GCCBuiltin<"__builtin_altivec_vextduwvlx">,
+              Intrinsic<[llvm_v2i64_ty],
+                        [llvm_v4i32_ty, llvm_v4i32_ty, llvm_i32_ty],
+                        [IntrNoMem]>;
+  def int_ppc_altivec_vextduwvrx : GCCBuiltin<"__builtin_altivec_vextduwvrx">,
+              Intrinsic<[llvm_v2i64_ty],
+                        [llvm_v4i32_ty, llvm_v4i32_ty, llvm_i32_ty],
+                        [IntrNoMem]>;
+  def int_ppc_altivec_vextddvlx : GCCBuiltin<"__builtin_altivec_vextddvlx">,
+              Intrinsic<[llvm_v2i64_ty],
+                        [llvm_v2i64_ty, llvm_v2i64_ty, llvm_i32_ty],
+                        [IntrNoMem]>;
+  def int_ppc_altivec_vextddvrx : GCCBuiltin<"__builtin_altivec_vextddvrx">,
+              Intrinsic<[llvm_v2i64_ty],
+                        [llvm_v2i64_ty, llvm_v2i64_ty, llvm_i32_ty],
+                        [IntrNoMem]>;
 }
 
 // Vector average.
@@ -460,10 +757,12 @@
   // Saturating multiply-adds.
   def int_ppc_altivec_vmhaddshs : GCCBuiltin<"__builtin_altivec_vmhaddshs">,
               Intrinsic<[llvm_v8i16_ty], [llvm_v8i16_ty,
-                         llvm_v8i16_ty, llvm_v8i16_ty], [IntrNoMem]>;
+                         llvm_v8i16_ty, llvm_v8i16_ty],
+                         [IntrNoMem, IntrHasSideEffects]>;
   def int_ppc_altivec_vmhraddshs : GCCBuiltin<"__builtin_altivec_vmhraddshs">,
               Intrinsic<[llvm_v8i16_ty], [llvm_v8i16_ty,
-                         llvm_v8i16_ty, llvm_v8i16_ty], [IntrNoMem]>;
+                         llvm_v8i16_ty, llvm_v8i16_ty],
+                         [IntrNoMem, IntrHasSideEffects]>;
 
   def int_ppc_altivec_vmaddfp : GCCBuiltin<"__builtin_altivec_vmaddfp">,
               Intrinsic<[llvm_v4f32_ty], [llvm_v4f32_ty,
@@ -472,7 +771,7 @@
               Intrinsic<[llvm_v4f32_ty], [llvm_v4f32_ty,
                          llvm_v4f32_ty, llvm_v4f32_ty], [IntrNoMem]>;
 
-  // Vector Multiply Sum Intructions.
+  // Vector Multiply Sum Instructions.
   def int_ppc_altivec_vmsummbm : GCCBuiltin<"__builtin_altivec_vmsummbm">,
             Intrinsic<[llvm_v4i32_ty], [llvm_v16i8_ty, llvm_v16i8_ty,
                        llvm_v4i32_ty], [IntrNoMem]>;
@@ -481,18 +780,24 @@
                        llvm_v4i32_ty], [IntrNoMem]>;
   def int_ppc_altivec_vmsumshs : GCCBuiltin<"__builtin_altivec_vmsumshs">,
             Intrinsic<[llvm_v4i32_ty], [llvm_v8i16_ty, llvm_v8i16_ty,
-                       llvm_v4i32_ty], [IntrNoMem]>;
+                       llvm_v4i32_ty], [IntrNoMem, IntrHasSideEffects]>;
   def int_ppc_altivec_vmsumubm : GCCBuiltin<"__builtin_altivec_vmsumubm">,
             Intrinsic<[llvm_v4i32_ty], [llvm_v16i8_ty, llvm_v16i8_ty,
                        llvm_v4i32_ty], [IntrNoMem]>;
   def int_ppc_altivec_vmsumuhm : GCCBuiltin<"__builtin_altivec_vmsumuhm">,
             Intrinsic<[llvm_v4i32_ty], [llvm_v8i16_ty, llvm_v8i16_ty,
                        llvm_v4i32_ty], [IntrNoMem]>;
+  def int_ppc_altivec_vmsumudm : GCCBuiltin<"__builtin_altivec_vmsumudm">,
+            Intrinsic<[llvm_v1i128_ty], [llvm_v2i64_ty, llvm_v2i64_ty,
+                       llvm_v1i128_ty], [IntrNoMem]>;
   def int_ppc_altivec_vmsumuhs : GCCBuiltin<"__builtin_altivec_vmsumuhs">,
             Intrinsic<[llvm_v4i32_ty], [llvm_v8i16_ty, llvm_v8i16_ty,
-                       llvm_v4i32_ty], [IntrNoMem]>;
+                       llvm_v4i32_ty], [IntrNoMem, IntrHasSideEffects]>;
+  def int_ppc_altivec_vmsumcud : GCCBuiltin<"__builtin_altivec_vmsumcud">,
+            Intrinsic<[llvm_v1i128_ty],
+                      [llvm_v2i64_ty, llvm_v2i64_ty, llvm_v1i128_ty], [IntrNoMem]>;
 
-  // Vector Multiply Intructions.
+  // Vector Multiply Instructions.
   def int_ppc_altivec_vmulesb : GCCBuiltin<"__builtin_altivec_vmulesb">,
           Intrinsic<[llvm_v8i16_ty], [llvm_v16i8_ty, llvm_v16i8_ty],
                     [IntrNoMem]>;
@@ -502,6 +807,7 @@
   def int_ppc_altivec_vmulesw : GCCBuiltin<"__builtin_altivec_vmulesw">,
           Intrinsic<[llvm_v2i64_ty], [llvm_v4i32_ty, llvm_v4i32_ty],
                     [IntrNoMem]>;
+  def int_ppc_altivec_vmulesd : PowerPC_Vec_QDD_Intrinsic<"vmulesd">;
   def int_ppc_altivec_vmuleub : GCCBuiltin<"__builtin_altivec_vmuleub">,
           Intrinsic<[llvm_v8i16_ty], [llvm_v16i8_ty, llvm_v16i8_ty],
                     [IntrNoMem]>;
@@ -511,6 +817,7 @@
   def int_ppc_altivec_vmuleuw : GCCBuiltin<"__builtin_altivec_vmuleuw">,
           Intrinsic<[llvm_v2i64_ty], [llvm_v4i32_ty, llvm_v4i32_ty],
                     [IntrNoMem]>;
+  def int_ppc_altivec_vmuleud : PowerPC_Vec_QDD_Intrinsic<"vmuleud">;
 
   def int_ppc_altivec_vmulosb : GCCBuiltin<"__builtin_altivec_vmulosb">,
           Intrinsic<[llvm_v8i16_ty], [llvm_v16i8_ty, llvm_v16i8_ty],
@@ -521,6 +828,7 @@
   def int_ppc_altivec_vmulosw : GCCBuiltin<"__builtin_altivec_vmulosw">,
           Intrinsic<[llvm_v2i64_ty], [llvm_v4i32_ty, llvm_v4i32_ty],
                     [IntrNoMem]>;
+  def int_ppc_altivec_vmulosd : PowerPC_Vec_QDD_Intrinsic<"vmulosd">;
   def int_ppc_altivec_vmuloub : GCCBuiltin<"__builtin_altivec_vmuloub">,
           Intrinsic<[llvm_v8i16_ty], [llvm_v16i8_ty, llvm_v16i8_ty],
                     [IntrNoMem]>;
@@ -530,23 +838,38 @@
   def int_ppc_altivec_vmulouw : GCCBuiltin<"__builtin_altivec_vmulouw">,
           Intrinsic<[llvm_v2i64_ty], [llvm_v4i32_ty, llvm_v4i32_ty],
                     [IntrNoMem]>;
+  def int_ppc_altivec_vmuloud : PowerPC_Vec_QDD_Intrinsic<"vmuloud">;
 
-  // Vector Sum Intructions.
+  // Vector Sum Instructions.
   def int_ppc_altivec_vsumsws : GCCBuiltin<"__builtin_altivec_vsumsws">,
             Intrinsic<[llvm_v4i32_ty], [llvm_v4i32_ty, llvm_v4i32_ty],
-                      [IntrNoMem]>;
+                      [IntrNoMem, IntrHasSideEffects]>;
   def int_ppc_altivec_vsum2sws : GCCBuiltin<"__builtin_altivec_vsum2sws">,
             Intrinsic<[llvm_v4i32_ty], [llvm_v4i32_ty, llvm_v4i32_ty],
-                      [IntrNoMem]>;
+                      [IntrNoMem, IntrHasSideEffects]>;
   def int_ppc_altivec_vsum4sbs : GCCBuiltin<"__builtin_altivec_vsum4sbs">,
             Intrinsic<[llvm_v4i32_ty], [llvm_v16i8_ty, llvm_v4i32_ty],
-                      [IntrNoMem]>;
+                      [IntrNoMem, IntrHasSideEffects]>;
   def int_ppc_altivec_vsum4shs : GCCBuiltin<"__builtin_altivec_vsum4shs">,
             Intrinsic<[llvm_v4i32_ty], [llvm_v8i16_ty, llvm_v4i32_ty],
-                      [IntrNoMem]>;
+                      [IntrNoMem, IntrHasSideEffects]>;
   def int_ppc_altivec_vsum4ubs : GCCBuiltin<"__builtin_altivec_vsum4ubs">,
             Intrinsic<[llvm_v4i32_ty], [llvm_v16i8_ty, llvm_v4i32_ty],
-                      [IntrNoMem]>;
+                      [IntrNoMem, IntrHasSideEffects]>;
+
+  // Vector Sign Extension Instructions
+  def int_ppc_altivec_vextsb2w : GCCBuiltin<"__builtin_altivec_vextsb2w">,
+            Intrinsic<[llvm_v4i32_ty], [llvm_v16i8_ty], [IntrNoMem]>;
+  def int_ppc_altivec_vextsb2d : GCCBuiltin<"__builtin_altivec_vextsb2d">,
+            Intrinsic<[llvm_v2i64_ty], [llvm_v16i8_ty], [IntrNoMem]>;
+  def int_ppc_altivec_vextsh2w : GCCBuiltin<"__builtin_altivec_vextsh2w">,
+            Intrinsic<[llvm_v4i32_ty], [llvm_v8i16_ty], [IntrNoMem]>;
+  def int_ppc_altivec_vextsh2d : GCCBuiltin<"__builtin_altivec_vextsh2d">,
+            Intrinsic<[llvm_v2i64_ty], [llvm_v8i16_ty], [IntrNoMem]>;
+  def int_ppc_altivec_vextsw2d : GCCBuiltin<"__builtin_altivec_vextsw2d">,
+            Intrinsic<[llvm_v2i64_ty], [llvm_v4i32_ty], [IntrNoMem]>;
+  def int_ppc_altivec_vextsd2q : GCCBuiltin<"__builtin_altivec_vextsd2q">,
+            Intrinsic<[llvm_v1i128_ty], [llvm_v2i64_ty], [IntrNoMem]>;
 
   // Other multiplies.
   def int_ppc_altivec_vmladduhm : GCCBuiltin<"__builtin_altivec_vmladduhm">,
@@ -559,34 +882,34 @@
                       [IntrNoMem]>;
   def int_ppc_altivec_vpkshss : GCCBuiltin<"__builtin_altivec_vpkshss">,
             Intrinsic<[llvm_v16i8_ty], [llvm_v8i16_ty, llvm_v8i16_ty],
-                      [IntrNoMem]>;
+                      [IntrNoMem, IntrHasSideEffects]>;
   def int_ppc_altivec_vpkshus : GCCBuiltin<"__builtin_altivec_vpkshus">,
             Intrinsic<[llvm_v16i8_ty], [llvm_v8i16_ty, llvm_v8i16_ty],
-                      [IntrNoMem]>;
+                      [IntrNoMem, IntrHasSideEffects]>;
   def int_ppc_altivec_vpkswss : GCCBuiltin<"__builtin_altivec_vpkswss">,
             Intrinsic<[llvm_v8i16_ty], [llvm_v4i32_ty, llvm_v4i32_ty],
-                      [IntrNoMem]>;
+                      [IntrNoMem, IntrHasSideEffects]>;
   def int_ppc_altivec_vpkswus : GCCBuiltin<"__builtin_altivec_vpkswus">,
             Intrinsic<[llvm_v8i16_ty], [llvm_v4i32_ty, llvm_v4i32_ty],
-                      [IntrNoMem]>;
+                      [IntrNoMem, IntrHasSideEffects]>;
   def int_ppc_altivec_vpksdss : GCCBuiltin<"__builtin_altivec_vpksdss">,
             Intrinsic<[llvm_v4i32_ty], [llvm_v2i64_ty, llvm_v2i64_ty],
-                      [IntrNoMem]>;
+                      [IntrNoMem, IntrHasSideEffects]>;
   def int_ppc_altivec_vpksdus : GCCBuiltin<"__builtin_altivec_vpksdus">,
             Intrinsic<[llvm_v4i32_ty], [llvm_v2i64_ty, llvm_v2i64_ty],
-                      [IntrNoMem]>;
+                      [IntrNoMem, IntrHasSideEffects]>;
   // vpkuhum is lowered to a shuffle.
   def int_ppc_altivec_vpkuhus : GCCBuiltin<"__builtin_altivec_vpkuhus">,
             Intrinsic<[llvm_v16i8_ty], [llvm_v8i16_ty, llvm_v8i16_ty],
-                      [IntrNoMem]>;
+                      [IntrNoMem, IntrHasSideEffects]>;
   // vpkuwum is lowered to a shuffle.
   def int_ppc_altivec_vpkuwus : GCCBuiltin<"__builtin_altivec_vpkuwus">,
             Intrinsic<[llvm_v8i16_ty], [llvm_v4i32_ty, llvm_v4i32_ty],
-                      [IntrNoMem]>;
+                      [IntrNoMem, IntrHasSideEffects]>;
   // vpkudum is lowered to a shuffle.
   def int_ppc_altivec_vpkudus : GCCBuiltin<"__builtin_altivec_vpkudus">,
             Intrinsic<[llvm_v4i32_ty], [llvm_v2i64_ty, llvm_v2i64_ty],
-                      [IntrNoMem]>;
+                      [IntrNoMem, IntrHasSideEffects]>;
 
   // Unpacks.
   def int_ppc_altivec_vupkhpx : GCCBuiltin<"__builtin_altivec_vupkhpx">,
@@ -610,16 +933,16 @@
   // FP <-> integer conversion.
   def int_ppc_altivec_vcfsx : GCCBuiltin<"__builtin_altivec_vcfsx">,
               Intrinsic<[llvm_v4f32_ty], [llvm_v4i32_ty, llvm_i32_ty],
-                        [IntrNoMem, ImmArg<1>]>;
+                        [IntrNoMem, ImmArg<ArgIndex<1>>]>;
   def int_ppc_altivec_vcfux : GCCBuiltin<"__builtin_altivec_vcfux">,
               Intrinsic<[llvm_v4f32_ty], [llvm_v4i32_ty, llvm_i32_ty],
-                        [IntrNoMem, ImmArg<1>]>;
+                        [IntrNoMem, ImmArg<ArgIndex<1>>]>;
   def int_ppc_altivec_vctsxs : GCCBuiltin<"__builtin_altivec_vctsxs">,
               Intrinsic<[llvm_v4i32_ty], [llvm_v4f32_ty, llvm_i32_ty],
-                        [IntrNoMem, ImmArg<1>]>;
+                        [IntrNoMem, ImmArg<ArgIndex<1>>]>;
   def int_ppc_altivec_vctuxs : GCCBuiltin<"__builtin_altivec_vctuxs">,
               Intrinsic<[llvm_v4i32_ty], [llvm_v4f32_ty, llvm_i32_ty],
-                        [IntrNoMem, ImmArg<1>]>;
+                        [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 
   def int_ppc_altivec_vrfim : GCCBuiltin<"__builtin_altivec_vrfim">,
               Intrinsic<[llvm_v4f32_ty], [llvm_v4f32_ty], [IntrNoMem]>;
@@ -649,6 +972,14 @@
               Intrinsic<[llvm_v1i128_ty],
                         [llvm_v1i128_ty, llvm_v1i128_ty, llvm_v1i128_ty],
                         [IntrNoMem]>;
+
+  // P10 Vector Count Leading / Trailing Zeroes under bit Mask Builtins.
+  def int_ppc_altivec_vclzdm : GCCBuiltin<"__builtin_altivec_vclzdm">,
+              Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_v2i64_ty],
+                        [IntrNoMem]>;
+  def int_ppc_altivec_vctzdm : GCCBuiltin<"__builtin_altivec_vctzdm">,
+              Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_v2i64_ty],
+                        [IntrNoMem]>;
 }
 
 def int_ppc_altivec_vsl   : PowerPC_Vec_WWW_Intrinsic<"vsl">;
@@ -716,11 +1047,11 @@
 def int_ppc_altivec_crypto_vshasigmad :
             GCCBuiltin<"__builtin_altivec_crypto_vshasigmad">,
             Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty,
-                       llvm_i32_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>, ImmArg<2>]>;
+                       llvm_i32_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>, ImmArg<ArgIndex<2>>]>;
 def int_ppc_altivec_crypto_vshasigmaw :
             GCCBuiltin<"__builtin_altivec_crypto_vshasigmaw">,
             Intrinsic<[llvm_v4i32_ty], [llvm_v4i32_ty,
-                       llvm_i32_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>, ImmArg<2>]>;
+                       llvm_i32_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>, ImmArg<ArgIndex<2>>]>;
 }
 def int_ppc_altivec_crypto_vcipher :
             PowerPC_Vec_DDD_Intrinsic<"crypto_vcipher">;
@@ -760,6 +1091,29 @@
                             [llvm_v2i64_ty, llvm_v2i64_ty, llvm_v2i64_ty],
                             [IntrNoMem]>;
 
+def int_ppc_altivec_vrlqnm :
+      PowerPC_Vec_Intrinsic<"vrlqnm", [llvm_v1i128_ty],
+                           [llvm_v1i128_ty, llvm_v1i128_ty],
+                            [IntrNoMem]>;
+def int_ppc_altivec_vrlqmi :
+      PowerPC_Vec_Intrinsic<"vrlqmi", [llvm_v1i128_ty],
+                            [llvm_v1i128_ty, llvm_v1i128_ty, llvm_v1i128_ty],
+                            [IntrNoMem]>;
+
+// Vector Divide Extended Intrinsics.
+def int_ppc_altivec_vdivesw : PowerPC_Vec_WWW_Intrinsic<"vdivesw">;
+def int_ppc_altivec_vdiveuw : PowerPC_Vec_WWW_Intrinsic<"vdiveuw">;
+def int_ppc_altivec_vdivesd : PowerPC_Vec_DDD_Intrinsic<"vdivesd">;
+def int_ppc_altivec_vdiveud : PowerPC_Vec_DDD_Intrinsic<"vdiveud">;
+def int_ppc_altivec_vdivesq : PowerPC_Vec_QQQ_Intrinsic<"vdivesq">;
+def int_ppc_altivec_vdiveuq : PowerPC_Vec_QQQ_Intrinsic<"vdiveuq">;
+
+// Vector Multiply High Intrinsics.
+def int_ppc_altivec_vmulhsw : PowerPC_Vec_WWW_Intrinsic<"vmulhsw">;
+def int_ppc_altivec_vmulhuw : PowerPC_Vec_WWW_Intrinsic<"vmulhuw">;
+def int_ppc_altivec_vmulhsd : PowerPC_Vec_DDD_Intrinsic<"vmulhsd">;
+def int_ppc_altivec_vmulhud : PowerPC_Vec_DDD_Intrinsic<"vmulhud">;
+
 //===----------------------------------------------------------------------===//
 // PowerPC VSX Intrinsic Definitions.
 
@@ -780,12 +1134,8 @@
 def int_ppc_vsx_lxvll :
       Intrinsic<[llvm_v4i32_ty], [llvm_ptr_ty, llvm_i64_ty], [IntrReadMem,
       IntrArgMemOnly]>;
-def int_ppc_vsx_stxvl :
-      Intrinsic<[], [llvm_v4i32_ty, llvm_ptr_ty, llvm_i64_ty],
-      [IntrWriteMem, IntrArgMemOnly]>;
-def int_ppc_vsx_stxvll :
-      Intrinsic<[], [llvm_v4i32_ty, llvm_ptr_ty, llvm_i64_ty],
-      [IntrWriteMem, IntrArgMemOnly]>;
+def int_ppc_vsx_lxvp :
+      Intrinsic<[llvm_v256i1_ty], [llvm_ptr_ty], [IntrReadMem, IntrArgMemOnly]>;
 
 // Vector store.
 def int_ppc_vsx_stxvw4x : Intrinsic<[], [llvm_v4i32_ty, llvm_ptr_ty],
@@ -796,6 +1146,15 @@
                                        [IntrWriteMem, IntrArgMemOnly]>;
 def int_ppc_vsx_stxvd2x_be : Intrinsic<[], [llvm_v2f64_ty, llvm_ptr_ty],
                                        [IntrWriteMem, IntrArgMemOnly]>;
+def int_ppc_vsx_stxvl :
+      Intrinsic<[], [llvm_v4i32_ty, llvm_ptr_ty, llvm_i64_ty],
+      [IntrWriteMem, IntrArgMemOnly]>;
+def int_ppc_vsx_stxvll :
+      Intrinsic<[], [llvm_v4i32_ty, llvm_ptr_ty, llvm_i64_ty],
+      [IntrWriteMem, IntrArgMemOnly]>;
+def int_ppc_vsx_stxvp :
+      Intrinsic<[], [llvm_v256i1_ty, llvm_ptr_ty], [IntrWriteMem,
+      IntrArgMemOnly]>;
 // Vector and scalar maximum.
 def int_ppc_vsx_xvmaxdp : PowerPC_VSX_Vec_DDD_Intrinsic<"xvmaxdp">;
 def int_ppc_vsx_xvmaxsp : PowerPC_VSX_Vec_FFF_Intrinsic<"xvmaxsp">;
@@ -915,13 +1274,19 @@
                             [llvm_v4f32_ty], [IntrNoMem]>;
 def int_ppc_vsx_xvtstdcdp :
       PowerPC_VSX_Intrinsic<"xvtstdcdp", [llvm_v2i64_ty],
-                            [llvm_v2f64_ty, llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+                            [llvm_v2f64_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_ppc_vsx_xvtstdcsp :
       PowerPC_VSX_Intrinsic<"xvtstdcsp", [llvm_v4i32_ty],
-                            [llvm_v4f32_ty,llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+                            [llvm_v4f32_ty,llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 def int_ppc_vsx_xvcvhpsp :
       PowerPC_VSX_Intrinsic<"xvcvhpsp", [llvm_v4f32_ty],
                             [llvm_v8i16_ty],[IntrNoMem]>;
+def int_ppc_vsx_xvcvspbf16 :
+      PowerPC_VSX_Intrinsic<"xvcvspbf16", [llvm_v16i8_ty],
+                            [llvm_v16i8_ty], [IntrNoMem]>;
+def int_ppc_vsx_xvcvbf16spn :
+      PowerPC_VSX_Intrinsic<"xvcvbf16spn", [llvm_v16i8_ty],
+                            [llvm_v16i8_ty], [IntrNoMem]>;
 def int_ppc_vsx_xxextractuw :
       PowerPC_VSX_Intrinsic<"xxextractuw",[llvm_v2i64_ty],
                             [llvm_v2i64_ty,llvm_i32_ty], [IntrNoMem]>;
@@ -929,182 +1294,56 @@
       PowerPC_VSX_Intrinsic<"xxinsertw",[llvm_v4i32_ty],
                             [llvm_v4i32_ty,llvm_v2i64_ty,llvm_i32_ty],
                             [IntrNoMem]>;
-}
+def int_ppc_vsx_xvtlsbb :
+      PowerPC_VSX_Intrinsic<"xvtlsbb", [llvm_i32_ty],
+                            [llvm_v16i8_ty, llvm_i32_ty], [IntrNoMem]>;
+def int_ppc_vsx_xvtdivdp :
+      PowerPC_VSX_Intrinsic<"xvtdivdp", [llvm_i32_ty],
+                            [llvm_v2f64_ty, llvm_v2f64_ty], [IntrNoMem]>;
+def int_ppc_vsx_xvtdivsp :
+      PowerPC_VSX_Intrinsic<"xvtdivsp", [llvm_i32_ty],
+                            [llvm_v4f32_ty, llvm_v4f32_ty], [IntrNoMem]>;
+def int_ppc_vsx_xvtsqrtdp :
+      PowerPC_VSX_Intrinsic<"xvtsqrtdp", [llvm_i32_ty], [llvm_v2f64_ty], [IntrNoMem]>;
+def int_ppc_vsx_xvtsqrtsp :
+      PowerPC_VSX_Intrinsic<"xvtsqrtsp", [llvm_i32_ty], [llvm_v4f32_ty], [IntrNoMem]>;
+def int_ppc_vsx_xxeval :
+      PowerPC_VSX_Intrinsic<"xxeval", [llvm_v2i64_ty],
+                           [llvm_v2i64_ty, llvm_v2i64_ty,
+                            llvm_v2i64_ty, llvm_i32_ty],
+                           [IntrNoMem, ImmArg<ArgIndex<3>>]>;
+def int_ppc_vsx_xxgenpcvbm :
+      PowerPC_VSX_Intrinsic<"xxgenpcvbm", [llvm_v16i8_ty],
+                            [llvm_v16i8_ty, llvm_i32_ty], [IntrNoMem]>;
+def int_ppc_vsx_xxgenpcvhm :
+      PowerPC_VSX_Intrinsic<"xxgenpcvhm", [llvm_v8i16_ty],
+                            [llvm_v8i16_ty, llvm_i32_ty], [IntrNoMem]>;
+def int_ppc_vsx_xxgenpcvwm :
+      PowerPC_VSX_Intrinsic<"xxgenpcvwm", [llvm_v4i32_ty],
+                            [llvm_v4i32_ty, llvm_i32_ty], [IntrNoMem]>;
+def int_ppc_vsx_xxgenpcvdm :
+      PowerPC_VSX_Intrinsic<"xxgenpcvdm", [llvm_v2i64_ty],
+                            [llvm_v2i64_ty, llvm_i32_ty], [IntrNoMem]>;
 
-//===----------------------------------------------------------------------===//
-// PowerPC QPX Intrinsics.
-//
-
-let TargetPrefix = "ppc" in {  // All PPC intrinsics start with "llvm.ppc.".
-  /// PowerPC_QPX_Intrinsic - Base class for all QPX intrinsics.
-  class PowerPC_QPX_Intrinsic<string GCCIntSuffix, list<LLVMType> ret_types,
-                              list<LLVMType> param_types,
-                              list<IntrinsicProperty> properties>
-    : GCCBuiltin<!strconcat("__builtin_qpx_", GCCIntSuffix)>,
-      Intrinsic<ret_types, param_types, properties>;
-}
-
-//===----------------------------------------------------------------------===//
-// PowerPC QPX Intrinsic Class Definitions.
-//
-
-/// PowerPC_QPX_FF_Intrinsic - A PowerPC intrinsic that takes one v4f64
-/// vector and returns one.  These intrinsics have no side effects.
-class PowerPC_QPX_FF_Intrinsic<string GCCIntSuffix>
-  : PowerPC_QPX_Intrinsic<GCCIntSuffix,
-                          [llvm_v4f64_ty], [llvm_v4f64_ty], [IntrNoMem]>;
-
-/// PowerPC_QPX_FFF_Intrinsic - A PowerPC intrinsic that takes two v4f64
-/// vectors and returns one.  These intrinsics have no side effects.
-class PowerPC_QPX_FFF_Intrinsic<string GCCIntSuffix>
-  : PowerPC_QPX_Intrinsic<GCCIntSuffix,
-                          [llvm_v4f64_ty], [llvm_v4f64_ty, llvm_v4f64_ty],
-                          [IntrNoMem]>;
-
-/// PowerPC_QPX_FFFF_Intrinsic - A PowerPC intrinsic that takes three v4f64
-/// vectors and returns one.  These intrinsics have no side effects.
-class PowerPC_QPX_FFFF_Intrinsic<string GCCIntSuffix>
-  : PowerPC_QPX_Intrinsic<GCCIntSuffix,
-                          [llvm_v4f64_ty],
-                          [llvm_v4f64_ty, llvm_v4f64_ty, llvm_v4f64_ty],
-                          [IntrNoMem]>;
-
-/// PowerPC_QPX_Load_Intrinsic - A PowerPC intrinsic that takes a pointer
-/// and returns a v4f64.
-class PowerPC_QPX_Load_Intrinsic<string GCCIntSuffix>
-  : PowerPC_QPX_Intrinsic<GCCIntSuffix,
-                          [llvm_v4f64_ty], [llvm_ptr_ty], [IntrReadMem, IntrArgMemOnly]>;
-
-/// PowerPC_QPX_LoadPerm_Intrinsic - A PowerPC intrinsic that takes a pointer
-/// and returns a v4f64 permutation.
-class PowerPC_QPX_LoadPerm_Intrinsic<string GCCIntSuffix>
-  : PowerPC_QPX_Intrinsic<GCCIntSuffix,
-                          [llvm_v4f64_ty], [llvm_ptr_ty], [IntrNoMem]>;
-
-/// PowerPC_QPX_Store_Intrinsic - A PowerPC intrinsic that takes a pointer
-/// and stores a v4f64.
-class PowerPC_QPX_Store_Intrinsic<string GCCIntSuffix>
-  : PowerPC_QPX_Intrinsic<GCCIntSuffix,
-                          [], [llvm_v4f64_ty, llvm_ptr_ty],
-                          [IntrWriteMem, IntrArgMemOnly]>;
-
-//===----------------------------------------------------------------------===//
-// PowerPC QPX Intrinsic Definitions.
-
-let TargetPrefix = "ppc" in {  // All intrinsics start with "llvm.ppc.".
-  // Add Instructions
-  def int_ppc_qpx_qvfadd : PowerPC_QPX_FFF_Intrinsic<"qvfadd">;
-  def int_ppc_qpx_qvfadds : PowerPC_QPX_FFF_Intrinsic<"qvfadds">;
-  def int_ppc_qpx_qvfsub : PowerPC_QPX_FFF_Intrinsic<"qvfsub">;
-  def int_ppc_qpx_qvfsubs : PowerPC_QPX_FFF_Intrinsic<"qvfsubs">;
-
-  // Estimate Instructions
-  def int_ppc_qpx_qvfre : PowerPC_QPX_FF_Intrinsic<"qvfre">;
-  def int_ppc_qpx_qvfres : PowerPC_QPX_FF_Intrinsic<"qvfres">;
-  def int_ppc_qpx_qvfrsqrte : PowerPC_QPX_FF_Intrinsic<"qvfrsqrte">;
-  def int_ppc_qpx_qvfrsqrtes : PowerPC_QPX_FF_Intrinsic<"qvfrsqrtes">;
-
-  // Multiply Instructions
-  def int_ppc_qpx_qvfmul : PowerPC_QPX_FFF_Intrinsic<"qvfmul">;
-  def int_ppc_qpx_qvfmuls : PowerPC_QPX_FFF_Intrinsic<"qvfmuls">;
-  def int_ppc_qpx_qvfxmul : PowerPC_QPX_FFF_Intrinsic<"qvfxmul">;
-  def int_ppc_qpx_qvfxmuls : PowerPC_QPX_FFF_Intrinsic<"qvfxmuls">;
-
-  // Multiply-add instructions
-  def int_ppc_qpx_qvfmadd : PowerPC_QPX_FFFF_Intrinsic<"qvfmadd">;
-  def int_ppc_qpx_qvfmadds : PowerPC_QPX_FFFF_Intrinsic<"qvfmadds">;
-  def int_ppc_qpx_qvfnmadd : PowerPC_QPX_FFFF_Intrinsic<"qvfnmadd">;
-  def int_ppc_qpx_qvfnmadds : PowerPC_QPX_FFFF_Intrinsic<"qvfnmadds">;
-  def int_ppc_qpx_qvfmsub : PowerPC_QPX_FFFF_Intrinsic<"qvfmsub">;
-  def int_ppc_qpx_qvfmsubs : PowerPC_QPX_FFFF_Intrinsic<"qvfmsubs">;
-  def int_ppc_qpx_qvfnmsub : PowerPC_QPX_FFFF_Intrinsic<"qvfnmsub">;
-  def int_ppc_qpx_qvfnmsubs : PowerPC_QPX_FFFF_Intrinsic<"qvfnmsubs">;
-  def int_ppc_qpx_qvfxmadd : PowerPC_QPX_FFFF_Intrinsic<"qvfxmadd">;
-  def int_ppc_qpx_qvfxmadds : PowerPC_QPX_FFFF_Intrinsic<"qvfxmadds">;
-  def int_ppc_qpx_qvfxxnpmadd : PowerPC_QPX_FFFF_Intrinsic<"qvfxxnpmadd">;
-  def int_ppc_qpx_qvfxxnpmadds : PowerPC_QPX_FFFF_Intrinsic<"qvfxxnpmadds">;
-  def int_ppc_qpx_qvfxxcpnmadd : PowerPC_QPX_FFFF_Intrinsic<"qvfxxcpnmadd">;
-  def int_ppc_qpx_qvfxxcpnmadds : PowerPC_QPX_FFFF_Intrinsic<"qvfxxcpnmadds">;
-  def int_ppc_qpx_qvfxxmadd : PowerPC_QPX_FFFF_Intrinsic<"qvfxxmadd">;
-  def int_ppc_qpx_qvfxxmadds : PowerPC_QPX_FFFF_Intrinsic<"qvfxxmadds">;
-
-  // Select Instruction
-  def int_ppc_qpx_qvfsel : PowerPC_QPX_FFFF_Intrinsic<"qvfsel">;
-
-  // Permute Instruction
-  def int_ppc_qpx_qvfperm : PowerPC_QPX_FFFF_Intrinsic<"qvfperm">;
-
-  // Convert and Round Instructions
-  def int_ppc_qpx_qvfctid : PowerPC_QPX_FF_Intrinsic<"qvfctid">;
-  def int_ppc_qpx_qvfctidu : PowerPC_QPX_FF_Intrinsic<"qvfctidu">;
-  def int_ppc_qpx_qvfctidz : PowerPC_QPX_FF_Intrinsic<"qvfctidz">;
-  def int_ppc_qpx_qvfctiduz : PowerPC_QPX_FF_Intrinsic<"qvfctiduz">;
-  def int_ppc_qpx_qvfctiw : PowerPC_QPX_FF_Intrinsic<"qvfctiw">;
-  def int_ppc_qpx_qvfctiwu : PowerPC_QPX_FF_Intrinsic<"qvfctiwu">;
-  def int_ppc_qpx_qvfctiwz : PowerPC_QPX_FF_Intrinsic<"qvfctiwz">;
-  def int_ppc_qpx_qvfctiwuz : PowerPC_QPX_FF_Intrinsic<"qvfctiwuz">;
-  def int_ppc_qpx_qvfcfid : PowerPC_QPX_FF_Intrinsic<"qvfcfid">;
-  def int_ppc_qpx_qvfcfidu : PowerPC_QPX_FF_Intrinsic<"qvfcfidu">;
-  def int_ppc_qpx_qvfcfids : PowerPC_QPX_FF_Intrinsic<"qvfcfids">;
-  def int_ppc_qpx_qvfcfidus : PowerPC_QPX_FF_Intrinsic<"qvfcfidus">;
-  def int_ppc_qpx_qvfrsp : PowerPC_QPX_FF_Intrinsic<"qvfrsp">;
-  def int_ppc_qpx_qvfriz : PowerPC_QPX_FF_Intrinsic<"qvfriz">;
-  def int_ppc_qpx_qvfrin : PowerPC_QPX_FF_Intrinsic<"qvfrin">;
-  def int_ppc_qpx_qvfrip : PowerPC_QPX_FF_Intrinsic<"qvfrip">;
-  def int_ppc_qpx_qvfrim : PowerPC_QPX_FF_Intrinsic<"qvfrim">;
-
-  // Move Instructions
-  def int_ppc_qpx_qvfneg : PowerPC_QPX_FF_Intrinsic<"qvfneg">;
-  def int_ppc_qpx_qvfabs : PowerPC_QPX_FF_Intrinsic<"qvfabs">;
-  def int_ppc_qpx_qvfnabs : PowerPC_QPX_FF_Intrinsic<"qvfnabs">;
-  def int_ppc_qpx_qvfcpsgn : PowerPC_QPX_FFF_Intrinsic<"qvfcpsgn">;
-
-  // Compare Instructions
-  def int_ppc_qpx_qvftstnan : PowerPC_QPX_FFF_Intrinsic<"qvftstnan">;
-  def int_ppc_qpx_qvfcmplt : PowerPC_QPX_FFF_Intrinsic<"qvfcmplt">;
-  def int_ppc_qpx_qvfcmpgt : PowerPC_QPX_FFF_Intrinsic<"qvfcmpgt">;
-  def int_ppc_qpx_qvfcmpeq : PowerPC_QPX_FFF_Intrinsic<"qvfcmpeq">;
-
-  // Load instructions
-  def int_ppc_qpx_qvlfd : PowerPC_QPX_Load_Intrinsic<"qvlfd">;
-  def int_ppc_qpx_qvlfda : PowerPC_QPX_Load_Intrinsic<"qvlfda">;
-  def int_ppc_qpx_qvlfs : PowerPC_QPX_Load_Intrinsic<"qvlfs">;
-  def int_ppc_qpx_qvlfsa : PowerPC_QPX_Load_Intrinsic<"qvlfsa">;
-
-  def int_ppc_qpx_qvlfcda : PowerPC_QPX_Load_Intrinsic<"qvlfcda">;
-  def int_ppc_qpx_qvlfcd : PowerPC_QPX_Load_Intrinsic<"qvlfcd">;
-  def int_ppc_qpx_qvlfcsa : PowerPC_QPX_Load_Intrinsic<"qvlfcsa">;
-  def int_ppc_qpx_qvlfcs : PowerPC_QPX_Load_Intrinsic<"qvlfcs">;
-  def int_ppc_qpx_qvlfiwaa : PowerPC_QPX_Load_Intrinsic<"qvlfiwaa">;
-  def int_ppc_qpx_qvlfiwa : PowerPC_QPX_Load_Intrinsic<"qvlfiwa">;
-  def int_ppc_qpx_qvlfiwza : PowerPC_QPX_Load_Intrinsic<"qvlfiwza">;
-  def int_ppc_qpx_qvlfiwz : PowerPC_QPX_Load_Intrinsic<"qvlfiwz">;
-
-  def int_ppc_qpx_qvlpcld : PowerPC_QPX_LoadPerm_Intrinsic<"qvlpcld">;
-  def int_ppc_qpx_qvlpcls : PowerPC_QPX_LoadPerm_Intrinsic<"qvlpcls">;
-  def int_ppc_qpx_qvlpcrd : PowerPC_QPX_LoadPerm_Intrinsic<"qvlpcrd">;
-  def int_ppc_qpx_qvlpcrs : PowerPC_QPX_LoadPerm_Intrinsic<"qvlpcrs">;
-
-  // Store instructions
-  def int_ppc_qpx_qvstfd : PowerPC_QPX_Store_Intrinsic<"qvstfd">;
-  def int_ppc_qpx_qvstfda : PowerPC_QPX_Store_Intrinsic<"qvstfda">;
-  def int_ppc_qpx_qvstfs : PowerPC_QPX_Store_Intrinsic<"qvstfs">;
-  def int_ppc_qpx_qvstfsa : PowerPC_QPX_Store_Intrinsic<"qvstfsa">;
-
-  def int_ppc_qpx_qvstfcda : PowerPC_QPX_Store_Intrinsic<"qvstfcda">;
-  def int_ppc_qpx_qvstfcd : PowerPC_QPX_Store_Intrinsic<"qvstfcd">;
-  def int_ppc_qpx_qvstfcsa : PowerPC_QPX_Store_Intrinsic<"qvstfcsa">;
-  def int_ppc_qpx_qvstfcs : PowerPC_QPX_Store_Intrinsic<"qvstfcs">;
-  def int_ppc_qpx_qvstfiwa : PowerPC_QPX_Store_Intrinsic<"qvstfiwa">;
-  def int_ppc_qpx_qvstfiw : PowerPC_QPX_Store_Intrinsic<"qvstfiw">;
-
-  // Logical and permutation formation
-  def int_ppc_qpx_qvflogical : PowerPC_QPX_Intrinsic<"qvflogical",
-                          [llvm_v4f64_ty],
-                          [llvm_v4f64_ty, llvm_v4f64_ty, llvm_i32_ty],
-                          [IntrNoMem]>;
-  def int_ppc_qpx_qvgpci : PowerPC_QPX_Intrinsic<"qvgpci",
-                          [llvm_v4f64_ty], [llvm_i32_ty], [IntrNoMem]>;
+// P10 VSX Vector permute extended.
+def int_ppc_vsx_xxpermx : 
+      GCCBuiltin<"__builtin_vsx_xxpermx">,
+      Intrinsic<[llvm_v16i8_ty],
+                [llvm_v16i8_ty,llvm_v16i8_ty,llvm_v16i8_ty,llvm_i32_ty],
+                [IntrNoMem, ImmArg<ArgIndex<3>>]>;
+// P10 VSX Vector Blend Variable.
+def  int_ppc_vsx_xxblendvb: GCCBuiltin<"__builtin_vsx_xxblendvb">,
+       Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty, llvm_v16i8_ty, llvm_v16i8_ty],
+                 [IntrNoMem]>;
+def  int_ppc_vsx_xxblendvh: GCCBuiltin<"__builtin_vsx_xxblendvh">,
+       Intrinsic<[llvm_v8i16_ty], [llvm_v8i16_ty, llvm_v8i16_ty,llvm_v8i16_ty],
+                 [IntrNoMem]>;
+def  int_ppc_vsx_xxblendvw: GCCBuiltin<"__builtin_vsx_xxblendvw">,
+       Intrinsic<[llvm_v4i32_ty], [llvm_v4i32_ty, llvm_v4i32_ty, llvm_v4i32_ty],
+                 [IntrNoMem]>;
+def  int_ppc_vsx_xxblendvd: GCCBuiltin<"__builtin_vsx_xxblendvd">,
+       Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_v2i64_ty, llvm_v2i64_ty],
+                 [IntrNoMem]>;
 }
 
 //===----------------------------------------------------------------------===//
@@ -1113,9 +1352,9 @@
 let TargetPrefix = "ppc" in {  // All intrinsics start with "llvm.ppc.".
 
 def int_ppc_tbegin : GCCBuiltin<"__builtin_tbegin">,
-      Intrinsic<[llvm_i32_ty], [llvm_i32_ty], [ImmArg<0>]>;
+      Intrinsic<[llvm_i32_ty], [llvm_i32_ty], [ImmArg<ArgIndex<0>>]>;
 def int_ppc_tend : GCCBuiltin<"__builtin_tend">,
-      Intrinsic<[llvm_i32_ty], [llvm_i32_ty], [ImmArg<0>]>;
+      Intrinsic<[llvm_i32_ty], [llvm_i32_ty], [ImmArg<ArgIndex<0>>]>;
 
 def int_ppc_tabort : GCCBuiltin<"__builtin_tabort">,
       Intrinsic<[llvm_i32_ty], [llvm_i32_ty], []>;
@@ -1171,5 +1410,88 @@
 // PowerPC set FPSCR Intrinsic Definitions.
 def int_ppc_setrnd : GCCBuiltin<"__builtin_setrnd">,
       Intrinsic<[llvm_double_ty], [llvm_i32_ty], []>;
+}
 
+let TargetPrefix = "ppc" in {
+  def int_ppc_vsx_assemble_pair :
+        Intrinsic<[llvm_v256i1_ty],
+                  [llvm_v16i8_ty, llvm_v16i8_ty], [IntrNoMem]>;
+
+  def int_ppc_vsx_disassemble_pair :
+        Intrinsic<[llvm_v16i8_ty, llvm_v16i8_ty],
+                  [llvm_v256i1_ty], [IntrNoMem]>;
+
+  def int_ppc_mma_assemble_acc :
+        Intrinsic<[llvm_v512i1_ty],
+                  [llvm_v16i8_ty, llvm_v16i8_ty, llvm_v16i8_ty, llvm_v16i8_ty],
+                  [IntrNoMem]>;
+
+  def int_ppc_mma_disassemble_acc :
+        Intrinsic<[llvm_v16i8_ty, llvm_v16i8_ty, llvm_v16i8_ty, llvm_v16i8_ty],
+                  [llvm_v512i1_ty], [IntrNoMem]>;
+
+  def int_ppc_mma_xxmtacc :
+        Intrinsic<[llvm_v512i1_ty], [llvm_v512i1_ty], [IntrNoMem]>;
+
+  def int_ppc_mma_xxmfacc :
+        Intrinsic<[llvm_v512i1_ty], [llvm_v512i1_ty], [IntrNoMem]>;
+
+  def int_ppc_mma_xxsetaccz :
+        Intrinsic<[llvm_v512i1_ty], [], [IntrNoMem]>;
+
+  // MMA Reduced-Precision: Outer Product Intrinsic Definitions.
+  defm int_ppc_mma_xvi4ger8 :
+        PowerPC_MMA_ACC_PP_Intrinsic<[llvm_v16i8_ty, llvm_v16i8_ty]>;
+  defm int_ppc_mma_pmxvi4ger8 :
+        PowerPC_MMA_ACC_PP_Intrinsic<[llvm_v16i8_ty, llvm_v16i8_ty, llvm_i32_ty,
+                                      llvm_i32_ty, llvm_i32_ty]>;
+
+  defm int_ppc_mma_xvi8ger4 :
+       PowerPC_MMA_ACC_PP_Intrinsic<[llvm_v16i8_ty, llvm_v16i8_ty]>;
+  defm int_ppc_mma_pmxvi8ger4 :
+       PowerPC_MMA_ACC_PP_Intrinsic<[llvm_v16i8_ty, llvm_v16i8_ty, llvm_i32_ty,
+                                     llvm_i32_ty, llvm_i32_ty]>;
+
+  defm int_ppc_mma_xvi16ger2s :
+       PowerPC_MMA_ACC_PP_Intrinsic<[llvm_v16i8_ty, llvm_v16i8_ty]>;
+  defm int_ppc_mma_pmxvi16ger2s :
+       PowerPC_MMA_ACC_PP_Intrinsic<[llvm_v16i8_ty, llvm_v16i8_ty, llvm_i32_ty,
+                                     llvm_i32_ty, llvm_i32_ty]>;
+
+  defm int_ppc_mma_xvf16ger2 :
+       PowerPC_MMA_ACC_Intrinsic<[llvm_v16i8_ty, llvm_v16i8_ty]>;
+  defm int_ppc_mma_pmxvf16ger2 :
+       PowerPC_MMA_ACC_Intrinsic<[llvm_v16i8_ty, llvm_v16i8_ty, llvm_i32_ty,
+                                  llvm_i32_ty, llvm_i32_ty]>;
+  defm int_ppc_mma_xvf32ger :
+       PowerPC_MMA_ACC_Intrinsic<[llvm_v16i8_ty, llvm_v16i8_ty]>;
+  defm int_ppc_mma_pmxvf32ger :
+       PowerPC_MMA_ACC_Intrinsic<[llvm_v16i8_ty, llvm_v16i8_ty, llvm_i32_ty,
+                                  llvm_i32_ty]>;
+  defm int_ppc_mma_xvf64ger :
+       PowerPC_MMA_ACC_Intrinsic<[llvm_v256i1_ty, llvm_v16i8_ty]>;
+  defm int_ppc_mma_pmxvf64ger :
+       PowerPC_MMA_ACC_Intrinsic<[llvm_v256i1_ty, llvm_v16i8_ty, llvm_i32_ty,
+                                  llvm_i32_ty]>;
+
+  // MMA Reduced-Precision: bfloat16 Outer Product Intrinsic Definitions.
+  defm int_ppc_mma_xvbf16ger2 :
+         PowerPC_MMA_ACC_Intrinsic<[llvm_v16i8_ty, llvm_v16i8_ty]>;
+  defm int_ppc_mma_pmxvbf16ger2 :
+         PowerPC_MMA_ACC_Intrinsic<
+           [llvm_v16i8_ty, llvm_v16i8_ty, llvm_i32_ty, llvm_i32_ty, llvm_i32_ty]>;
+
+  // MMA Reduced-Precision: Missing Integer-based Outer Product Operations.
+  defm int_ppc_mma_xvi16ger2 :
+         PowerPC_MMA_ACC_PP_Intrinsic<[llvm_v16i8_ty, llvm_v16i8_ty]>;
+  defm int_ppc_mma_pmxvi16ger2 :
+         PowerPC_MMA_ACC_PP_Intrinsic<[llvm_v16i8_ty, llvm_v16i8_ty, llvm_i32_ty,
+                                       llvm_i32_ty, llvm_i32_ty]>;
+  def int_ppc_mma_xvi8ger4spp :
+        Intrinsic<[llvm_v512i1_ty],
+                  [llvm_v512i1_ty, llvm_v16i8_ty, llvm_v16i8_ty], [IntrNoMem]>;
+  def int_ppc_mma_pmxvi8ger4spp :
+        Intrinsic<[llvm_v512i1_ty],
+                  [llvm_v512i1_ty, llvm_v16i8_ty, llvm_v16i8_ty, llvm_i32_ty,
+                   llvm_i32_ty, llvm_i32_ty], [IntrNoMem]>;
 }
diff --git a/linux-x64/clang/include/llvm/IR/IntrinsicsR600.h b/linux-x64/clang/include/llvm/IR/IntrinsicsR600.h
new file mode 100644
index 0000000..89b0195
--- /dev/null
+++ b/linux-x64/clang/include/llvm/IR/IntrinsicsR600.h
@@ -0,0 +1,55 @@
+/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
+|*                                                                            *|
+|* Intrinsic Function Source Fragment                                         *|
+|*                                                                            *|
+|* Automatically generated file, do not edit!                                 *|
+|*                                                                            *|
+\*===----------------------------------------------------------------------===*/
+
+#ifndef LLVM_IR_INTRINSIC_R600_ENUMS_H
+#define LLVM_IR_INTRINSIC_R600_ENUMS_H
+
+namespace llvm {
+namespace Intrinsic {
+enum R600Intrinsics : unsigned {
+// Enum values for intrinsics
+    r600_cube = 6586,                                 // llvm.r600.cube
+    r600_ddx,                                  // llvm.r600.ddx
+    r600_ddy,                                  // llvm.r600.ddy
+    r600_dot4,                                 // llvm.r600.dot4
+    r600_group_barrier,                        // llvm.r600.group.barrier
+    r600_implicitarg_ptr,                      // llvm.r600.implicitarg.ptr
+    r600_kill,                                 // llvm.r600.kill
+    r600_rat_store_typed,                      // llvm.r600.rat.store.typed
+    r600_read_global_size_x,                   // llvm.r600.read.global.size.x
+    r600_read_global_size_y,                   // llvm.r600.read.global.size.y
+    r600_read_global_size_z,                   // llvm.r600.read.global.size.z
+    r600_read_local_size_x,                    // llvm.r600.read.local.size.x
+    r600_read_local_size_y,                    // llvm.r600.read.local.size.y
+    r600_read_local_size_z,                    // llvm.r600.read.local.size.z
+    r600_read_ngroups_x,                       // llvm.r600.read.ngroups.x
+    r600_read_ngroups_y,                       // llvm.r600.read.ngroups.y
+    r600_read_ngroups_z,                       // llvm.r600.read.ngroups.z
+    r600_read_tgid_x,                          // llvm.r600.read.tgid.x
+    r600_read_tgid_y,                          // llvm.r600.read.tgid.y
+    r600_read_tgid_z,                          // llvm.r600.read.tgid.z
+    r600_read_tidig_x,                         // llvm.r600.read.tidig.x
+    r600_read_tidig_y,                         // llvm.r600.read.tidig.y
+    r600_read_tidig_z,                         // llvm.r600.read.tidig.z
+    r600_recipsqrt_clamped,                    // llvm.r600.recipsqrt.clamped
+    r600_recipsqrt_ieee,                       // llvm.r600.recipsqrt.ieee
+    r600_store_stream_output,                  // llvm.r600.store.stream.output
+    r600_store_swizzle,                        // llvm.r600.store.swizzle
+    r600_tex,                                  // llvm.r600.tex
+    r600_texc,                                 // llvm.r600.texc
+    r600_txb,                                  // llvm.r600.txb
+    r600_txbc,                                 // llvm.r600.txbc
+    r600_txf,                                  // llvm.r600.txf
+    r600_txl,                                  // llvm.r600.txl
+    r600_txlc,                                 // llvm.r600.txlc
+    r600_txq,                                  // llvm.r600.txq
+}; // enum
+} // namespace Intrinsic
+} // namespace llvm
+
+#endif
diff --git a/linux-x64/clang/include/llvm/IR/IntrinsicsRISCV.h b/linux-x64/clang/include/llvm/IR/IntrinsicsRISCV.h
new file mode 100644
index 0000000..eecdee0
--- /dev/null
+++ b/linux-x64/clang/include/llvm/IR/IntrinsicsRISCV.h
@@ -0,0 +1,386 @@
+/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
+|*                                                                            *|
+|* Intrinsic Function Source Fragment                                         *|
+|*                                                                            *|
+|* Automatically generated file, do not edit!                                 *|
+|*                                                                            *|
+\*===----------------------------------------------------------------------===*/
+
+#ifndef LLVM_IR_INTRINSIC_RISCV_ENUMS_H
+#define LLVM_IR_INTRINSIC_RISCV_ENUMS_H
+
+namespace llvm {
+namespace Intrinsic {
+enum RISCVIntrinsics : unsigned {
+// Enum values for intrinsics
+    riscv_masked_atomicrmw_add_i32 = 6621,            // llvm.riscv.masked.atomicrmw.add.i32
+    riscv_masked_atomicrmw_add_i64,            // llvm.riscv.masked.atomicrmw.add.i64
+    riscv_masked_atomicrmw_max_i32,            // llvm.riscv.masked.atomicrmw.max.i32
+    riscv_masked_atomicrmw_max_i64,            // llvm.riscv.masked.atomicrmw.max.i64
+    riscv_masked_atomicrmw_min_i32,            // llvm.riscv.masked.atomicrmw.min.i32
+    riscv_masked_atomicrmw_min_i64,            // llvm.riscv.masked.atomicrmw.min.i64
+    riscv_masked_atomicrmw_nand_i32,           // llvm.riscv.masked.atomicrmw.nand.i32
+    riscv_masked_atomicrmw_nand_i64,           // llvm.riscv.masked.atomicrmw.nand.i64
+    riscv_masked_atomicrmw_sub_i32,            // llvm.riscv.masked.atomicrmw.sub.i32
+    riscv_masked_atomicrmw_sub_i64,            // llvm.riscv.masked.atomicrmw.sub.i64
+    riscv_masked_atomicrmw_umax_i32,           // llvm.riscv.masked.atomicrmw.umax.i32
+    riscv_masked_atomicrmw_umax_i64,           // llvm.riscv.masked.atomicrmw.umax.i64
+    riscv_masked_atomicrmw_umin_i32,           // llvm.riscv.masked.atomicrmw.umin.i32
+    riscv_masked_atomicrmw_umin_i64,           // llvm.riscv.masked.atomicrmw.umin.i64
+    riscv_masked_atomicrmw_xchg_i32,           // llvm.riscv.masked.atomicrmw.xchg.i32
+    riscv_masked_atomicrmw_xchg_i64,           // llvm.riscv.masked.atomicrmw.xchg.i64
+    riscv_masked_cmpxchg_i32,                  // llvm.riscv.masked.cmpxchg.i32
+    riscv_masked_cmpxchg_i64,                  // llvm.riscv.masked.cmpxchg.i64
+    riscv_vaadd,                               // llvm.riscv.vaadd
+    riscv_vaadd_mask,                          // llvm.riscv.vaadd.mask
+    riscv_vaaddu,                              // llvm.riscv.vaaddu
+    riscv_vaaddu_mask,                         // llvm.riscv.vaaddu.mask
+    riscv_vadc,                                // llvm.riscv.vadc
+    riscv_vadd,                                // llvm.riscv.vadd
+    riscv_vadd_mask,                           // llvm.riscv.vadd.mask
+    riscv_vand,                                // llvm.riscv.vand
+    riscv_vand_mask,                           // llvm.riscv.vand.mask
+    riscv_vasub,                               // llvm.riscv.vasub
+    riscv_vasub_mask,                          // llvm.riscv.vasub.mask
+    riscv_vasubu,                              // llvm.riscv.vasubu
+    riscv_vasubu_mask,                         // llvm.riscv.vasubu.mask
+    riscv_vcompress,                           // llvm.riscv.vcompress
+    riscv_vdiv,                                // llvm.riscv.vdiv
+    riscv_vdiv_mask,                           // llvm.riscv.vdiv.mask
+    riscv_vdivu,                               // llvm.riscv.vdivu
+    riscv_vdivu_mask,                          // llvm.riscv.vdivu.mask
+    riscv_vfadd,                               // llvm.riscv.vfadd
+    riscv_vfadd_mask,                          // llvm.riscv.vfadd.mask
+    riscv_vfclass,                             // llvm.riscv.vfclass
+    riscv_vfclass_mask,                        // llvm.riscv.vfclass.mask
+    riscv_vfcvt_f_x_v,                         // llvm.riscv.vfcvt.f.x.v
+    riscv_vfcvt_f_x_v_mask,                    // llvm.riscv.vfcvt.f.x.v.mask
+    riscv_vfcvt_f_xu_v,                        // llvm.riscv.vfcvt.f.xu.v
+    riscv_vfcvt_f_xu_v_mask,                   // llvm.riscv.vfcvt.f.xu.v.mask
+    riscv_vfcvt_rtz_x_f_v,                     // llvm.riscv.vfcvt.rtz.x.f.v
+    riscv_vfcvt_rtz_x_f_v_mask,                // llvm.riscv.vfcvt.rtz.x.f.v.mask
+    riscv_vfcvt_rtz_xu_f_v,                    // llvm.riscv.vfcvt.rtz.xu.f.v
+    riscv_vfcvt_rtz_xu_f_v_mask,               // llvm.riscv.vfcvt.rtz.xu.f.v.mask
+    riscv_vfcvt_x_f_v,                         // llvm.riscv.vfcvt.x.f.v
+    riscv_vfcvt_x_f_v_mask,                    // llvm.riscv.vfcvt.x.f.v.mask
+    riscv_vfcvt_xu_f_v,                        // llvm.riscv.vfcvt.xu.f.v
+    riscv_vfcvt_xu_f_v_mask,                   // llvm.riscv.vfcvt.xu.f.v.mask
+    riscv_vfdiv,                               // llvm.riscv.vfdiv
+    riscv_vfdiv_mask,                          // llvm.riscv.vfdiv.mask
+    riscv_vfirst,                              // llvm.riscv.vfirst
+    riscv_vfirst_mask,                         // llvm.riscv.vfirst.mask
+    riscv_vfmacc,                              // llvm.riscv.vfmacc
+    riscv_vfmacc_mask,                         // llvm.riscv.vfmacc.mask
+    riscv_vfmadd,                              // llvm.riscv.vfmadd
+    riscv_vfmadd_mask,                         // llvm.riscv.vfmadd.mask
+    riscv_vfmax,                               // llvm.riscv.vfmax
+    riscv_vfmax_mask,                          // llvm.riscv.vfmax.mask
+    riscv_vfmerge,                             // llvm.riscv.vfmerge
+    riscv_vfmin,                               // llvm.riscv.vfmin
+    riscv_vfmin_mask,                          // llvm.riscv.vfmin.mask
+    riscv_vfmsac,                              // llvm.riscv.vfmsac
+    riscv_vfmsac_mask,                         // llvm.riscv.vfmsac.mask
+    riscv_vfmsub,                              // llvm.riscv.vfmsub
+    riscv_vfmsub_mask,                         // llvm.riscv.vfmsub.mask
+    riscv_vfmul,                               // llvm.riscv.vfmul
+    riscv_vfmul_mask,                          // llvm.riscv.vfmul.mask
+    riscv_vfmv_f_s,                            // llvm.riscv.vfmv.f.s
+    riscv_vfmv_s_f,                            // llvm.riscv.vfmv.s.f
+    riscv_vfmv_v_f,                            // llvm.riscv.vfmv.v.f
+    riscv_vfncvt_f_f_w,                        // llvm.riscv.vfncvt.f.f.w
+    riscv_vfncvt_f_f_w_mask,                   // llvm.riscv.vfncvt.f.f.w.mask
+    riscv_vfncvt_f_x_w,                        // llvm.riscv.vfncvt.f.x.w
+    riscv_vfncvt_f_x_w_mask,                   // llvm.riscv.vfncvt.f.x.w.mask
+    riscv_vfncvt_f_xu_w,                       // llvm.riscv.vfncvt.f.xu.w
+    riscv_vfncvt_f_xu_w_mask,                  // llvm.riscv.vfncvt.f.xu.w.mask
+    riscv_vfncvt_rod_f_f_w,                    // llvm.riscv.vfncvt.rod.f.f.w
+    riscv_vfncvt_rod_f_f_w_mask,               // llvm.riscv.vfncvt.rod.f.f.w.mask
+    riscv_vfncvt_rtz_x_f_w,                    // llvm.riscv.vfncvt.rtz.x.f.w
+    riscv_vfncvt_rtz_x_f_w_mask,               // llvm.riscv.vfncvt.rtz.x.f.w.mask
+    riscv_vfncvt_rtz_xu_f_w,                   // llvm.riscv.vfncvt.rtz.xu.f.w
+    riscv_vfncvt_rtz_xu_f_w_mask,              // llvm.riscv.vfncvt.rtz.xu.f.w.mask
+    riscv_vfncvt_x_f_w,                        // llvm.riscv.vfncvt.x.f.w
+    riscv_vfncvt_x_f_w_mask,                   // llvm.riscv.vfncvt.x.f.w.mask
+    riscv_vfncvt_xu_f_w,                       // llvm.riscv.vfncvt.xu.f.w
+    riscv_vfncvt_xu_f_w_mask,                  // llvm.riscv.vfncvt.xu.f.w.mask
+    riscv_vfnmacc,                             // llvm.riscv.vfnmacc
+    riscv_vfnmacc_mask,                        // llvm.riscv.vfnmacc.mask
+    riscv_vfnmadd,                             // llvm.riscv.vfnmadd
+    riscv_vfnmadd_mask,                        // llvm.riscv.vfnmadd.mask
+    riscv_vfnmsac,                             // llvm.riscv.vfnmsac
+    riscv_vfnmsac_mask,                        // llvm.riscv.vfnmsac.mask
+    riscv_vfnmsub,                             // llvm.riscv.vfnmsub
+    riscv_vfnmsub_mask,                        // llvm.riscv.vfnmsub.mask
+    riscv_vfrdiv,                              // llvm.riscv.vfrdiv
+    riscv_vfrdiv_mask,                         // llvm.riscv.vfrdiv.mask
+    riscv_vfredmax,                            // llvm.riscv.vfredmax
+    riscv_vfredmax_mask,                       // llvm.riscv.vfredmax.mask
+    riscv_vfredmin,                            // llvm.riscv.vfredmin
+    riscv_vfredmin_mask,                       // llvm.riscv.vfredmin.mask
+    riscv_vfredosum,                           // llvm.riscv.vfredosum
+    riscv_vfredosum_mask,                      // llvm.riscv.vfredosum.mask
+    riscv_vfredsum,                            // llvm.riscv.vfredsum
+    riscv_vfredsum_mask,                       // llvm.riscv.vfredsum.mask
+    riscv_vfrsub,                              // llvm.riscv.vfrsub
+    riscv_vfrsub_mask,                         // llvm.riscv.vfrsub.mask
+    riscv_vfsgnj,                              // llvm.riscv.vfsgnj
+    riscv_vfsgnj_mask,                         // llvm.riscv.vfsgnj.mask
+    riscv_vfsgnjn,                             // llvm.riscv.vfsgnjn
+    riscv_vfsgnjn_mask,                        // llvm.riscv.vfsgnjn.mask
+    riscv_vfsgnjx,                             // llvm.riscv.vfsgnjx
+    riscv_vfsgnjx_mask,                        // llvm.riscv.vfsgnjx.mask
+    riscv_vfslide1down,                        // llvm.riscv.vfslide1down
+    riscv_vfslide1down_mask,                   // llvm.riscv.vfslide1down.mask
+    riscv_vfslide1up,                          // llvm.riscv.vfslide1up
+    riscv_vfslide1up_mask,                     // llvm.riscv.vfslide1up.mask
+    riscv_vfsqrt,                              // llvm.riscv.vfsqrt
+    riscv_vfsqrt_mask,                         // llvm.riscv.vfsqrt.mask
+    riscv_vfsub,                               // llvm.riscv.vfsub
+    riscv_vfsub_mask,                          // llvm.riscv.vfsub.mask
+    riscv_vfwadd,                              // llvm.riscv.vfwadd
+    riscv_vfwadd_mask,                         // llvm.riscv.vfwadd.mask
+    riscv_vfwadd_w,                            // llvm.riscv.vfwadd.w
+    riscv_vfwadd_w_mask,                       // llvm.riscv.vfwadd.w.mask
+    riscv_vfwcvt_f_f_v,                        // llvm.riscv.vfwcvt.f.f.v
+    riscv_vfwcvt_f_f_v_mask,                   // llvm.riscv.vfwcvt.f.f.v.mask
+    riscv_vfwcvt_f_x_v,                        // llvm.riscv.vfwcvt.f.x.v
+    riscv_vfwcvt_f_x_v_mask,                   // llvm.riscv.vfwcvt.f.x.v.mask
+    riscv_vfwcvt_f_xu_v,                       // llvm.riscv.vfwcvt.f.xu.v
+    riscv_vfwcvt_f_xu_v_mask,                  // llvm.riscv.vfwcvt.f.xu.v.mask
+    riscv_vfwcvt_rtz_x_f_v,                    // llvm.riscv.vfwcvt.rtz.x.f.v
+    riscv_vfwcvt_rtz_x_f_v_mask,               // llvm.riscv.vfwcvt.rtz.x.f.v.mask
+    riscv_vfwcvt_rtz_xu_f_v,                   // llvm.riscv.vfwcvt.rtz.xu.f.v
+    riscv_vfwcvt_rtz_xu_f_v_mask,              // llvm.riscv.vfwcvt.rtz.xu.f.v.mask
+    riscv_vfwcvt_x_f_v,                        // llvm.riscv.vfwcvt.x.f.v
+    riscv_vfwcvt_x_f_v_mask,                   // llvm.riscv.vfwcvt.x.f.v.mask
+    riscv_vfwcvt_xu_f_v,                       // llvm.riscv.vfwcvt.xu.f.v
+    riscv_vfwcvt_xu_f_v_mask,                  // llvm.riscv.vfwcvt.xu.f.v.mask
+    riscv_vfwmacc,                             // llvm.riscv.vfwmacc
+    riscv_vfwmacc_mask,                        // llvm.riscv.vfwmacc.mask
+    riscv_vfwmsac,                             // llvm.riscv.vfwmsac
+    riscv_vfwmsac_mask,                        // llvm.riscv.vfwmsac.mask
+    riscv_vfwmul,                              // llvm.riscv.vfwmul
+    riscv_vfwmul_mask,                         // llvm.riscv.vfwmul.mask
+    riscv_vfwnmacc,                            // llvm.riscv.vfwnmacc
+    riscv_vfwnmacc_mask,                       // llvm.riscv.vfwnmacc.mask
+    riscv_vfwnmsac,                            // llvm.riscv.vfwnmsac
+    riscv_vfwnmsac_mask,                       // llvm.riscv.vfwnmsac.mask
+    riscv_vfwredosum,                          // llvm.riscv.vfwredosum
+    riscv_vfwredosum_mask,                     // llvm.riscv.vfwredosum.mask
+    riscv_vfwredsum,                           // llvm.riscv.vfwredsum
+    riscv_vfwredsum_mask,                      // llvm.riscv.vfwredsum.mask
+    riscv_vfwsub,                              // llvm.riscv.vfwsub
+    riscv_vfwsub_mask,                         // llvm.riscv.vfwsub.mask
+    riscv_vfwsub_w,                            // llvm.riscv.vfwsub.w
+    riscv_vfwsub_w_mask,                       // llvm.riscv.vfwsub.w.mask
+    riscv_vid,                                 // llvm.riscv.vid
+    riscv_vid_mask,                            // llvm.riscv.vid.mask
+    riscv_viota,                               // llvm.riscv.viota
+    riscv_viota_mask,                          // llvm.riscv.viota.mask
+    riscv_vle,                                 // llvm.riscv.vle
+    riscv_vle_mask,                            // llvm.riscv.vle.mask
+    riscv_vleff,                               // llvm.riscv.vleff
+    riscv_vleff_mask,                          // llvm.riscv.vleff.mask
+    riscv_vlse,                                // llvm.riscv.vlse
+    riscv_vlse_mask,                           // llvm.riscv.vlse.mask
+    riscv_vlxe,                                // llvm.riscv.vlxe
+    riscv_vlxe_mask,                           // llvm.riscv.vlxe.mask
+    riscv_vmacc,                               // llvm.riscv.vmacc
+    riscv_vmacc_mask,                          // llvm.riscv.vmacc.mask
+    riscv_vmadc,                               // llvm.riscv.vmadc
+    riscv_vmadc_carry_in,                      // llvm.riscv.vmadc.carry.in
+    riscv_vmadd,                               // llvm.riscv.vmadd
+    riscv_vmadd_mask,                          // llvm.riscv.vmadd.mask
+    riscv_vmand,                               // llvm.riscv.vmand
+    riscv_vmandnot,                            // llvm.riscv.vmandnot
+    riscv_vmax,                                // llvm.riscv.vmax
+    riscv_vmax_mask,                           // llvm.riscv.vmax.mask
+    riscv_vmaxu,                               // llvm.riscv.vmaxu
+    riscv_vmaxu_mask,                          // llvm.riscv.vmaxu.mask
+    riscv_vmclr,                               // llvm.riscv.vmclr
+    riscv_vmerge,                              // llvm.riscv.vmerge
+    riscv_vmfeq,                               // llvm.riscv.vmfeq
+    riscv_vmfeq_mask,                          // llvm.riscv.vmfeq.mask
+    riscv_vmfge,                               // llvm.riscv.vmfge
+    riscv_vmfge_mask,                          // llvm.riscv.vmfge.mask
+    riscv_vmfgt,                               // llvm.riscv.vmfgt
+    riscv_vmfgt_mask,                          // llvm.riscv.vmfgt.mask
+    riscv_vmfle,                               // llvm.riscv.vmfle
+    riscv_vmfle_mask,                          // llvm.riscv.vmfle.mask
+    riscv_vmflt,                               // llvm.riscv.vmflt
+    riscv_vmflt_mask,                          // llvm.riscv.vmflt.mask
+    riscv_vmfne,                               // llvm.riscv.vmfne
+    riscv_vmfne_mask,                          // llvm.riscv.vmfne.mask
+    riscv_vmin,                                // llvm.riscv.vmin
+    riscv_vmin_mask,                           // llvm.riscv.vmin.mask
+    riscv_vminu,                               // llvm.riscv.vminu
+    riscv_vminu_mask,                          // llvm.riscv.vminu.mask
+    riscv_vmnand,                              // llvm.riscv.vmnand
+    riscv_vmnor,                               // llvm.riscv.vmnor
+    riscv_vmor,                                // llvm.riscv.vmor
+    riscv_vmornot,                             // llvm.riscv.vmornot
+    riscv_vmsbc,                               // llvm.riscv.vmsbc
+    riscv_vmsbc_borrow_in,                     // llvm.riscv.vmsbc.borrow.in
+    riscv_vmsbf,                               // llvm.riscv.vmsbf
+    riscv_vmsbf_mask,                          // llvm.riscv.vmsbf.mask
+    riscv_vmseq,                               // llvm.riscv.vmseq
+    riscv_vmseq_mask,                          // llvm.riscv.vmseq.mask
+    riscv_vmset,                               // llvm.riscv.vmset
+    riscv_vmsgt,                               // llvm.riscv.vmsgt
+    riscv_vmsgt_mask,                          // llvm.riscv.vmsgt.mask
+    riscv_vmsgtu,                              // llvm.riscv.vmsgtu
+    riscv_vmsgtu_mask,                         // llvm.riscv.vmsgtu.mask
+    riscv_vmsif,                               // llvm.riscv.vmsif
+    riscv_vmsif_mask,                          // llvm.riscv.vmsif.mask
+    riscv_vmsle,                               // llvm.riscv.vmsle
+    riscv_vmsle_mask,                          // llvm.riscv.vmsle.mask
+    riscv_vmsleu,                              // llvm.riscv.vmsleu
+    riscv_vmsleu_mask,                         // llvm.riscv.vmsleu.mask
+    riscv_vmslt,                               // llvm.riscv.vmslt
+    riscv_vmslt_mask,                          // llvm.riscv.vmslt.mask
+    riscv_vmsltu,                              // llvm.riscv.vmsltu
+    riscv_vmsltu_mask,                         // llvm.riscv.vmsltu.mask
+    riscv_vmsne,                               // llvm.riscv.vmsne
+    riscv_vmsne_mask,                          // llvm.riscv.vmsne.mask
+    riscv_vmsof,                               // llvm.riscv.vmsof
+    riscv_vmsof_mask,                          // llvm.riscv.vmsof.mask
+    riscv_vmul,                                // llvm.riscv.vmul
+    riscv_vmul_mask,                           // llvm.riscv.vmul.mask
+    riscv_vmulh,                               // llvm.riscv.vmulh
+    riscv_vmulh_mask,                          // llvm.riscv.vmulh.mask
+    riscv_vmulhsu,                             // llvm.riscv.vmulhsu
+    riscv_vmulhsu_mask,                        // llvm.riscv.vmulhsu.mask
+    riscv_vmulhu,                              // llvm.riscv.vmulhu
+    riscv_vmulhu_mask,                         // llvm.riscv.vmulhu.mask
+    riscv_vmv_s_x,                             // llvm.riscv.vmv.s.x
+    riscv_vmv_v_v,                             // llvm.riscv.vmv.v.v
+    riscv_vmv_v_x,                             // llvm.riscv.vmv.v.x
+    riscv_vmv_x_s,                             // llvm.riscv.vmv.x.s
+    riscv_vmxnor,                              // llvm.riscv.vmxnor
+    riscv_vmxor,                               // llvm.riscv.vmxor
+    riscv_vnclip,                              // llvm.riscv.vnclip
+    riscv_vnclip_mask,                         // llvm.riscv.vnclip.mask
+    riscv_vnclipu,                             // llvm.riscv.vnclipu
+    riscv_vnclipu_mask,                        // llvm.riscv.vnclipu.mask
+    riscv_vnmsac,                              // llvm.riscv.vnmsac
+    riscv_vnmsac_mask,                         // llvm.riscv.vnmsac.mask
+    riscv_vnmsub,                              // llvm.riscv.vnmsub
+    riscv_vnmsub_mask,                         // llvm.riscv.vnmsub.mask
+    riscv_vnsra,                               // llvm.riscv.vnsra
+    riscv_vnsra_mask,                          // llvm.riscv.vnsra.mask
+    riscv_vnsrl,                               // llvm.riscv.vnsrl
+    riscv_vnsrl_mask,                          // llvm.riscv.vnsrl.mask
+    riscv_vor,                                 // llvm.riscv.vor
+    riscv_vor_mask,                            // llvm.riscv.vor.mask
+    riscv_vpopc,                               // llvm.riscv.vpopc
+    riscv_vpopc_mask,                          // llvm.riscv.vpopc.mask
+    riscv_vredand,                             // llvm.riscv.vredand
+    riscv_vredand_mask,                        // llvm.riscv.vredand.mask
+    riscv_vredmax,                             // llvm.riscv.vredmax
+    riscv_vredmax_mask,                        // llvm.riscv.vredmax.mask
+    riscv_vredmaxu,                            // llvm.riscv.vredmaxu
+    riscv_vredmaxu_mask,                       // llvm.riscv.vredmaxu.mask
+    riscv_vredmin,                             // llvm.riscv.vredmin
+    riscv_vredmin_mask,                        // llvm.riscv.vredmin.mask
+    riscv_vredminu,                            // llvm.riscv.vredminu
+    riscv_vredminu_mask,                       // llvm.riscv.vredminu.mask
+    riscv_vredor,                              // llvm.riscv.vredor
+    riscv_vredor_mask,                         // llvm.riscv.vredor.mask
+    riscv_vredsum,                             // llvm.riscv.vredsum
+    riscv_vredsum_mask,                        // llvm.riscv.vredsum.mask
+    riscv_vredxor,                             // llvm.riscv.vredxor
+    riscv_vredxor_mask,                        // llvm.riscv.vredxor.mask
+    riscv_vrem,                                // llvm.riscv.vrem
+    riscv_vrem_mask,                           // llvm.riscv.vrem.mask
+    riscv_vremu,                               // llvm.riscv.vremu
+    riscv_vremu_mask,                          // llvm.riscv.vremu.mask
+    riscv_vrgather,                            // llvm.riscv.vrgather
+    riscv_vrgather_mask,                       // llvm.riscv.vrgather.mask
+    riscv_vrsub,                               // llvm.riscv.vrsub
+    riscv_vrsub_mask,                          // llvm.riscv.vrsub.mask
+    riscv_vsadd,                               // llvm.riscv.vsadd
+    riscv_vsadd_mask,                          // llvm.riscv.vsadd.mask
+    riscv_vsaddu,                              // llvm.riscv.vsaddu
+    riscv_vsaddu_mask,                         // llvm.riscv.vsaddu.mask
+    riscv_vsbc,                                // llvm.riscv.vsbc
+    riscv_vse,                                 // llvm.riscv.vse
+    riscv_vse_mask,                            // llvm.riscv.vse.mask
+    riscv_vsetvli,                             // llvm.riscv.vsetvli
+    riscv_vsetvlimax,                          // llvm.riscv.vsetvlimax
+    riscv_vsext,                               // llvm.riscv.vsext
+    riscv_vsext_mask,                          // llvm.riscv.vsext.mask
+    riscv_vslide1down,                         // llvm.riscv.vslide1down
+    riscv_vslide1down_mask,                    // llvm.riscv.vslide1down.mask
+    riscv_vslide1up,                           // llvm.riscv.vslide1up
+    riscv_vslide1up_mask,                      // llvm.riscv.vslide1up.mask
+    riscv_vslidedown,                          // llvm.riscv.vslidedown
+    riscv_vslidedown_mask,                     // llvm.riscv.vslidedown.mask
+    riscv_vslideup,                            // llvm.riscv.vslideup
+    riscv_vslideup_mask,                       // llvm.riscv.vslideup.mask
+    riscv_vsll,                                // llvm.riscv.vsll
+    riscv_vsll_mask,                           // llvm.riscv.vsll.mask
+    riscv_vsmul,                               // llvm.riscv.vsmul
+    riscv_vsmul_mask,                          // llvm.riscv.vsmul.mask
+    riscv_vsra,                                // llvm.riscv.vsra
+    riscv_vsra_mask,                           // llvm.riscv.vsra.mask
+    riscv_vsrl,                                // llvm.riscv.vsrl
+    riscv_vsrl_mask,                           // llvm.riscv.vsrl.mask
+    riscv_vsse,                                // llvm.riscv.vsse
+    riscv_vsse_mask,                           // llvm.riscv.vsse.mask
+    riscv_vssra,                               // llvm.riscv.vssra
+    riscv_vssra_mask,                          // llvm.riscv.vssra.mask
+    riscv_vssrl,                               // llvm.riscv.vssrl
+    riscv_vssrl_mask,                          // llvm.riscv.vssrl.mask
+    riscv_vssub,                               // llvm.riscv.vssub
+    riscv_vssub_mask,                          // llvm.riscv.vssub.mask
+    riscv_vssubu,                              // llvm.riscv.vssubu
+    riscv_vssubu_mask,                         // llvm.riscv.vssubu.mask
+    riscv_vsub,                                // llvm.riscv.vsub
+    riscv_vsub_mask,                           // llvm.riscv.vsub.mask
+    riscv_vsuxe,                               // llvm.riscv.vsuxe
+    riscv_vsuxe_mask,                          // llvm.riscv.vsuxe.mask
+    riscv_vsxe,                                // llvm.riscv.vsxe
+    riscv_vsxe_mask,                           // llvm.riscv.vsxe.mask
+    riscv_vwadd,                               // llvm.riscv.vwadd
+    riscv_vwadd_mask,                          // llvm.riscv.vwadd.mask
+    riscv_vwadd_w,                             // llvm.riscv.vwadd.w
+    riscv_vwadd_w_mask,                        // llvm.riscv.vwadd.w.mask
+    riscv_vwaddu,                              // llvm.riscv.vwaddu
+    riscv_vwaddu_mask,                         // llvm.riscv.vwaddu.mask
+    riscv_vwaddu_w,                            // llvm.riscv.vwaddu.w
+    riscv_vwaddu_w_mask,                       // llvm.riscv.vwaddu.w.mask
+    riscv_vwmacc,                              // llvm.riscv.vwmacc
+    riscv_vwmacc_mask,                         // llvm.riscv.vwmacc.mask
+    riscv_vwmaccsu,                            // llvm.riscv.vwmaccsu
+    riscv_vwmaccsu_mask,                       // llvm.riscv.vwmaccsu.mask
+    riscv_vwmaccu,                             // llvm.riscv.vwmaccu
+    riscv_vwmaccu_mask,                        // llvm.riscv.vwmaccu.mask
+    riscv_vwmaccus,                            // llvm.riscv.vwmaccus
+    riscv_vwmaccus_mask,                       // llvm.riscv.vwmaccus.mask
+    riscv_vwmul,                               // llvm.riscv.vwmul
+    riscv_vwmul_mask,                          // llvm.riscv.vwmul.mask
+    riscv_vwmulsu,                             // llvm.riscv.vwmulsu
+    riscv_vwmulsu_mask,                        // llvm.riscv.vwmulsu.mask
+    riscv_vwmulu,                              // llvm.riscv.vwmulu
+    riscv_vwmulu_mask,                         // llvm.riscv.vwmulu.mask
+    riscv_vwredsum,                            // llvm.riscv.vwredsum
+    riscv_vwredsum_mask,                       // llvm.riscv.vwredsum.mask
+    riscv_vwredsumu,                           // llvm.riscv.vwredsumu
+    riscv_vwredsumu_mask,                      // llvm.riscv.vwredsumu.mask
+    riscv_vwsub,                               // llvm.riscv.vwsub
+    riscv_vwsub_mask,                          // llvm.riscv.vwsub.mask
+    riscv_vwsub_w,                             // llvm.riscv.vwsub.w
+    riscv_vwsub_w_mask,                        // llvm.riscv.vwsub.w.mask
+    riscv_vwsubu,                              // llvm.riscv.vwsubu
+    riscv_vwsubu_mask,                         // llvm.riscv.vwsubu.mask
+    riscv_vwsubu_w,                            // llvm.riscv.vwsubu.w
+    riscv_vwsubu_w_mask,                       // llvm.riscv.vwsubu.w.mask
+    riscv_vxor,                                // llvm.riscv.vxor
+    riscv_vxor_mask,                           // llvm.riscv.vxor.mask
+    riscv_vzext,                               // llvm.riscv.vzext
+    riscv_vzext_mask,                          // llvm.riscv.vzext.mask
+}; // enum
+} // namespace Intrinsic
+} // namespace llvm
+
+#endif
diff --git a/linux-x64/clang/include/llvm/IR/IntrinsicsRISCV.td b/linux-x64/clang/include/llvm/IR/IntrinsicsRISCV.td
index 6039318..e45be2b 100644
--- a/linux-x64/clang/include/llvm/IR/IntrinsicsRISCV.td
+++ b/linux-x64/clang/include/llvm/IR/IntrinsicsRISCV.td
@@ -10,59 +10,843 @@
 //
 //===----------------------------------------------------------------------===//
 
-let TargetPrefix = "riscv" in {
-
 //===----------------------------------------------------------------------===//
 // Atomics
 
-class MaskedAtomicRMW32Intrinsic
-    : Intrinsic<[llvm_i32_ty],
-                [llvm_anyptr_ty, llvm_i32_ty, llvm_i32_ty, llvm_i32_ty],
-                [IntrArgMemOnly, NoCapture<0>, ImmArg<3>]>;
+// Atomic Intrinsics have multiple versions for different access widths, which
+// all follow one of the following signatures (depending on how many arguments
+// they require). We carefully instantiate only specific versions of these for
+// specific integer widths, rather than using `llvm_anyint_ty`.
+//
+// In fact, as these intrinsics take `llvm_anyptr_ty`, the given names are the
+// canonical names, and the intrinsics used in the code will have a name
+// suffixed with the pointer type they are specialised for (denoted `<p>` in the
+// names below), in order to avoid type conflicts.
 
-class MaskedAtomicRMW32WithSextIntrinsic
-    : Intrinsic<[llvm_i32_ty],
-                [llvm_anyptr_ty, llvm_i32_ty, llvm_i32_ty, llvm_i32_ty,
-                 llvm_i32_ty],
-                [IntrArgMemOnly, NoCapture<0>, ImmArg<4>]>;
+let TargetPrefix = "riscv" in {
 
-def int_riscv_masked_atomicrmw_xchg_i32 : MaskedAtomicRMW32Intrinsic;
-def int_riscv_masked_atomicrmw_add_i32  : MaskedAtomicRMW32Intrinsic;
-def int_riscv_masked_atomicrmw_sub_i32  : MaskedAtomicRMW32Intrinsic;
-def int_riscv_masked_atomicrmw_nand_i32 : MaskedAtomicRMW32Intrinsic;
-def int_riscv_masked_atomicrmw_max_i32  : MaskedAtomicRMW32WithSextIntrinsic;
-def int_riscv_masked_atomicrmw_min_i32  : MaskedAtomicRMW32WithSextIntrinsic;
-def int_riscv_masked_atomicrmw_umax_i32 : MaskedAtomicRMW32Intrinsic;
-def int_riscv_masked_atomicrmw_umin_i32 : MaskedAtomicRMW32Intrinsic;
+  // T @llvm.<name>.T.<p>(any*, T, T, T imm);
+  class MaskedAtomicRMWFourArg<LLVMType itype>
+      : Intrinsic<[itype], [llvm_anyptr_ty, itype, itype, itype],
+                  [IntrArgMemOnly, NoCapture<ArgIndex<0>>, ImmArg<ArgIndex<3>>]>;
+  // T @llvm.<name>.T.<p>(any*, T, T, T, T imm);
+  class MaskedAtomicRMWFiveArg<LLVMType itype>
+      : Intrinsic<[itype], [llvm_anyptr_ty, itype, itype, itype, itype],
+                  [IntrArgMemOnly, NoCapture<ArgIndex<0>>, ImmArg<ArgIndex<4>>]>;
 
-def int_riscv_masked_cmpxchg_i32
-    : Intrinsic<[llvm_i32_ty], [llvm_anyptr_ty, llvm_i32_ty, llvm_i32_ty,
-                                llvm_i32_ty, llvm_i32_ty],
-                [IntrArgMemOnly, NoCapture<0>, ImmArg<4>]>;
+  // We define 32-bit and 64-bit variants of the above, where T stands for i32
+  // or i64 respectively:
+  multiclass MaskedAtomicRMWFourArgIntrinsics {
+    // i32 @llvm.<name>.i32.<p>(any*, i32, i32, i32 imm);
+    def _i32 : MaskedAtomicRMWFourArg<llvm_i32_ty>;
+    // i64 @llvm.<name>.i32.<p>(any*, i64, i64, i64 imm);
+    def _i64 : MaskedAtomicRMWFourArg<llvm_i64_ty>;
+  }
 
-class MaskedAtomicRMW64Intrinsic
-    : Intrinsic<[llvm_i64_ty],
-                [llvm_anyptr_ty, llvm_i64_ty, llvm_i64_ty, llvm_i64_ty],
-                [IntrArgMemOnly, NoCapture<0>, ImmArg<3>]>;
+  multiclass MaskedAtomicRMWFiveArgIntrinsics {
+    // i32 @llvm.<name>.i32.<p>(any*, i32, i32, i32, i32 imm);
+    def _i32 : MaskedAtomicRMWFiveArg<llvm_i32_ty>;
+    // i64 @llvm.<name>.i64.<p>(any*, i64, i64, i64, i64 imm);
+    def _i64 : MaskedAtomicRMWFiveArg<llvm_i64_ty>;
+  }
 
-class MaskedAtomicRMW64WithSextIntrinsic
-    : Intrinsic<[llvm_i64_ty],
-                [llvm_anyptr_ty, llvm_i64_ty, llvm_i64_ty, llvm_i64_ty,
-                 llvm_i64_ty],
-                [IntrArgMemOnly, NoCapture<0>, ImmArg<4>]>;
+  // @llvm.riscv.masked.atomicrmw.*.{i32,i64}.<p>(...)
+  defm int_riscv_masked_atomicrmw_xchg : MaskedAtomicRMWFourArgIntrinsics;
+  defm int_riscv_masked_atomicrmw_add : MaskedAtomicRMWFourArgIntrinsics;
+  defm int_riscv_masked_atomicrmw_sub : MaskedAtomicRMWFourArgIntrinsics;
+  defm int_riscv_masked_atomicrmw_nand : MaskedAtomicRMWFourArgIntrinsics;
+  // Signed min and max need an extra operand to do sign extension with.
+  defm int_riscv_masked_atomicrmw_max : MaskedAtomicRMWFiveArgIntrinsics;
+  defm int_riscv_masked_atomicrmw_min : MaskedAtomicRMWFiveArgIntrinsics;
+  // Unsigned min and max don't need the extra operand.
+  defm int_riscv_masked_atomicrmw_umax : MaskedAtomicRMWFourArgIntrinsics;
+  defm int_riscv_masked_atomicrmw_umin : MaskedAtomicRMWFourArgIntrinsics;
 
-def int_riscv_masked_atomicrmw_xchg_i64 : MaskedAtomicRMW64Intrinsic;
-def int_riscv_masked_atomicrmw_add_i64  : MaskedAtomicRMW64Intrinsic;
-def int_riscv_masked_atomicrmw_sub_i64  : MaskedAtomicRMW64Intrinsic;
-def int_riscv_masked_atomicrmw_nand_i64 : MaskedAtomicRMW64Intrinsic;
-def int_riscv_masked_atomicrmw_max_i64  : MaskedAtomicRMW64WithSextIntrinsic;
-def int_riscv_masked_atomicrmw_min_i64  : MaskedAtomicRMW64WithSextIntrinsic;
-def int_riscv_masked_atomicrmw_umax_i64 : MaskedAtomicRMW64Intrinsic;
-def int_riscv_masked_atomicrmw_umin_i64 : MaskedAtomicRMW64Intrinsic;
+  // @llvm.riscv.masked.cmpxchg.{i32,i64}.<p>(...)
+  defm int_riscv_masked_cmpxchg : MaskedAtomicRMWFiveArgIntrinsics;
 
-def int_riscv_masked_cmpxchg_i64
-    : Intrinsic<[llvm_i64_ty], [llvm_anyptr_ty, llvm_i64_ty, llvm_i64_ty,
-                                llvm_i64_ty, llvm_i64_ty],
-                [IntrArgMemOnly, NoCapture<0>, ImmArg<4>]>;
+} // TargetPrefix = "riscv"
+
+//===----------------------------------------------------------------------===//
+// Vectors
+
+class RISCVVIntrinsic {
+  // These intrinsics may accept illegal integer values in their llvm_any_ty
+  // operand, so they have to be extended. If set to zero then the intrinsic
+  // does not have any operand that must be extended.
+  Intrinsic IntrinsicID = !cast<Intrinsic>(NAME);
+  bits<4> ExtendOperand = 0;
+}
+
+let TargetPrefix = "riscv" in {
+  // We use anyint here but we only support XLen.
+  def int_riscv_vsetvli   : Intrinsic<[llvm_anyint_ty],
+                           /* AVL */  [LLVMMatchType<0>,
+                           /* VSEW */  LLVMMatchType<0>,
+                           /* VLMUL */ LLVMMatchType<0>],
+                                      [IntrNoMem, IntrHasSideEffects,
+                                       ImmArg<ArgIndex<1>>,
+                                       ImmArg<ArgIndex<2>>]>;
+  def int_riscv_vsetvlimax : Intrinsic<[llvm_anyint_ty],
+                            /* VSEW */ [LLVMMatchType<0>,
+                            /* VLMUL */ LLVMMatchType<0>],
+                                      [IntrNoMem, IntrHasSideEffects,
+                                       ImmArg<ArgIndex<0>>,
+                                       ImmArg<ArgIndex<1>>]>;
+
+  // For unit stride load
+  // Input: (pointer, vl)
+  class RISCVUSLoad
+        : Intrinsic<[llvm_anyvector_ty],
+                    [LLVMPointerType<LLVMMatchType<0>>,
+                     llvm_anyint_ty],
+                    [NoCapture<ArgIndex<0>>, IntrReadMem]>, RISCVVIntrinsic;
+  // For unit stride load with mask
+  // Input: (maskedoff, pointer, mask, vl)
+  class RISCVUSLoadMask
+        : Intrinsic<[llvm_anyvector_ty ],
+                    [LLVMMatchType<0>,
+                     LLVMPointerType<LLVMMatchType<0>>,
+                     LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>,
+                     llvm_anyint_ty],
+                    [NoCapture<ArgIndex<1>>, IntrReadMem]>, RISCVVIntrinsic;
+  // For strided load
+  // Input: (pointer, stride, vl)
+  class RISCVSLoad
+        : Intrinsic<[llvm_anyvector_ty],
+                    [LLVMPointerType<LLVMMatchType<0>>,
+                     llvm_anyint_ty, LLVMMatchType<1>],
+                    [NoCapture<ArgIndex<0>>, IntrReadMem]>, RISCVVIntrinsic;
+  // For strided load with mask
+  // Input: (maskedoff, pointer, stride, mask, vl)
+  class RISCVSLoadMask
+        : Intrinsic<[llvm_anyvector_ty ],
+                    [LLVMMatchType<0>,
+                     LLVMPointerType<LLVMMatchType<0>>, llvm_anyint_ty,
+                     LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>, LLVMMatchType<1>],
+                    [NoCapture<ArgIndex<1>>, IntrReadMem]>, RISCVVIntrinsic;
+  // For indexed load
+  // Input: (pointer, index, vl)
+  class RISCVILoad
+        : Intrinsic<[llvm_anyvector_ty],
+                    [LLVMPointerType<LLVMMatchType<0>>,
+                     llvm_anyvector_ty, llvm_anyint_ty],
+                    [NoCapture<ArgIndex<0>>, IntrReadMem]>, RISCVVIntrinsic;
+  // For indexed load with mask
+  // Input: (maskedoff, pointer, index, mask, vl)
+  class RISCVILoadMask
+        : Intrinsic<[llvm_anyvector_ty ],
+                    [LLVMMatchType<0>,
+                     LLVMPointerType<LLVMMatchType<0>>, llvm_anyvector_ty,
+                     LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>, llvm_anyint_ty],
+                    [NoCapture<ArgIndex<1>>, IntrReadMem]>, RISCVVIntrinsic;
+  // For unit stride store
+  // Input: (vector_in, pointer, vl)
+  class RISCVUSStore
+        : Intrinsic<[],
+                    [llvm_anyvector_ty,
+                     LLVMPointerType<LLVMMatchType<0>>,
+                     llvm_anyint_ty],
+                    [NoCapture<ArgIndex<1>>, IntrWriteMem]>, RISCVVIntrinsic;
+  // For unit stride store with mask
+  // Input: (vector_in, pointer, mask, vl)
+  class RISCVUSStoreMask
+        : Intrinsic<[],
+                    [llvm_anyvector_ty,
+                     LLVMPointerType<LLVMMatchType<0>>,
+                     LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>,
+                     llvm_anyint_ty],
+                    [NoCapture<ArgIndex<1>>, IntrWriteMem]>, RISCVVIntrinsic;
+  // For strided store
+  // Input: (vector_in, pointer, stride, vl)
+  class RISCVSStore
+        : Intrinsic<[],
+                    [llvm_anyvector_ty,
+                     LLVMPointerType<LLVMMatchType<0>>,
+                     llvm_anyint_ty, LLVMMatchType<1>],
+                    [NoCapture<ArgIndex<1>>, IntrWriteMem]>, RISCVVIntrinsic;
+  // For stride store with mask
+  // Input: (vector_in, pointer, stirde, mask, vl)
+  class RISCVSStoreMask
+        : Intrinsic<[],
+                    [llvm_anyvector_ty,
+                     LLVMPointerType<LLVMMatchType<0>>, llvm_anyint_ty,
+                     LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>, LLVMMatchType<1>],
+                    [NoCapture<ArgIndex<1>>, IntrWriteMem]>, RISCVVIntrinsic;
+  // For indexed store
+  // Input: (vector_in, pointer, index, vl)
+  class RISCVIStore
+        : Intrinsic<[],
+                    [llvm_anyvector_ty,
+                     LLVMPointerType<LLVMMatchType<0>>,
+                     llvm_anyint_ty, llvm_anyint_ty],
+                    [NoCapture<ArgIndex<1>>, IntrWriteMem]>, RISCVVIntrinsic;
+  // For indexed store with mask
+  // Input: (vector_in, pointer, index, mask, vl)
+  class RISCVIStoreMask
+        : Intrinsic<[],
+                    [llvm_anyvector_ty,
+                     LLVMPointerType<LLVMMatchType<0>>, llvm_anyvector_ty,
+                     LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>, llvm_anyint_ty],
+                    [NoCapture<ArgIndex<1>>, IntrWriteMem]>, RISCVVIntrinsic;
+  // For destination vector type is the same as source vector.
+  // Input: (vector_in, vl)
+  class RISCVUnaryAANoMask
+        : Intrinsic<[llvm_anyvector_ty],
+                    [LLVMMatchType<0>, llvm_anyint_ty],
+                    [IntrNoMem]>, RISCVVIntrinsic;
+  // For destination vector type is the same as first source vector (with mask).
+  // Input: (vector_in, mask, vl)
+  class RISCVUnaryAAMask
+        : Intrinsic<[llvm_anyvector_ty],
+                    [LLVMMatchType<0>, LLVMMatchType<0>,
+                     LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>, llvm_anyint_ty],
+                    [IntrNoMem]>, RISCVVIntrinsic;
+  // For destination vector type is the same as first and second source vector.
+  // Input: (vector_in, vector_in, vl)
+  class RISCVBinaryAAANoMask
+        : Intrinsic<[llvm_anyvector_ty],
+                    [LLVMMatchType<0>, LLVMMatchType<0>, llvm_anyint_ty],
+                    [IntrNoMem]>, RISCVVIntrinsic;
+  // For destination vector type is the same as first and second source vector.
+  // Input: (vector_in, vector_in, vl)
+  class RISCVBinaryAAAMask
+        : Intrinsic<[llvm_anyvector_ty],
+                    [LLVMMatchType<0>, LLVMMatchType<0>,
+                     LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>, llvm_anyint_ty],
+                    [IntrNoMem]>, RISCVVIntrinsic;
+  // For destination vector type is the same as first source vector.
+  // Input: (vector_in, vector_in/scalar_in, vl)
+  class RISCVBinaryAAXNoMask
+        : Intrinsic<[llvm_anyvector_ty],
+                    [LLVMMatchType<0>, llvm_any_ty, llvm_anyint_ty],
+                    [IntrNoMem]>, RISCVVIntrinsic {
+    let ExtendOperand = 2;
+  }
+  // For destination vector type is the same as first source vector (with mask).
+  // Input: (maskedoff, vector_in, vector_in/scalar_in, mask, vl)
+  class RISCVBinaryAAXMask
+       : Intrinsic<[llvm_anyvector_ty],
+                   [LLVMMatchType<0>, LLVMMatchType<0>, llvm_any_ty,
+                    LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>, llvm_anyint_ty],
+                   [IntrNoMem]>, RISCVVIntrinsic {
+    let ExtendOperand = 3;
+  }
+  // For destination vector type is NOT the same as first source vector.
+  // Input: (vector_in, vector_in/scalar_in, vl)
+  class RISCVBinaryABXNoMask
+        : Intrinsic<[llvm_anyvector_ty],
+                    [llvm_anyvector_ty, llvm_any_ty, llvm_anyint_ty],
+                    [IntrNoMem]>, RISCVVIntrinsic {
+    let ExtendOperand = 2;
+  }
+  // For destination vector type is NOT the same as first source vector (with mask).
+  // Input: (maskedoff, vector_in, vector_in/scalar_in, mask, vl)
+  class RISCVBinaryABXMask
+        : Intrinsic<[llvm_anyvector_ty],
+                    [LLVMMatchType<0>, llvm_anyvector_ty, llvm_any_ty,
+                     LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>, llvm_anyint_ty],
+                    [IntrNoMem]>, RISCVVIntrinsic {
+    let ExtendOperand = 3;
+  }
+  // For binary operations with V0 as input.
+  // Input: (vector_in, vector_in/scalar_in, V0, vl)
+  class RISCVBinaryWithV0
+        : Intrinsic<[llvm_anyvector_ty],
+                    [LLVMMatchType<0>, llvm_any_ty,
+                     LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>,
+                     llvm_anyint_ty],
+                    [IntrNoMem]>, RISCVVIntrinsic {
+    let ExtendOperand = 2;
+  }
+  // For binary operations with mask type output and V0 as input.
+  // Output: (mask type output)
+  // Input: (vector_in, vector_in/scalar_in, V0, vl)
+  class RISCVBinaryMOutWithV0
+        :Intrinsic<[LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>],
+                   [llvm_anyvector_ty, llvm_any_ty,
+                    LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>,
+                    llvm_anyint_ty],
+                   [IntrNoMem]>, RISCVVIntrinsic {
+    let ExtendOperand = 2;
+  }
+  // For binary operations with mask type output.
+  // Output: (mask type output)
+  // Input: (vector_in, vector_in/scalar_in, vl)
+  class RISCVBinaryMOut
+        : Intrinsic<[LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>],
+                    [llvm_anyvector_ty, llvm_any_ty, llvm_anyint_ty],
+                    [IntrNoMem]>, RISCVVIntrinsic {
+    let ExtendOperand = 2;
+  }
+  // For binary operations with mask type output without mask.
+  // Output: (mask type output)
+  // Input: (vector_in, vector_in/scalar_in, vl)
+  class RISCVCompareNoMask
+        : Intrinsic<[LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>],
+                    [llvm_anyvector_ty, llvm_any_ty, llvm_anyint_ty],
+                    [IntrNoMem]>, RISCVVIntrinsic {
+    let ExtendOperand = 2;
+  }
+  // For binary operations with mask type output with mask.
+  // Output: (mask type output)
+  // Input: (maskedoff, vector_in, vector_in/scalar_in, mask, vl)
+  class RISCVCompareMask
+        : Intrinsic<[LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>],
+                    [LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>,
+                     llvm_anyvector_ty, llvm_any_ty,
+                     LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>, llvm_anyint_ty],
+                    [IntrNoMem]>, RISCVVIntrinsic {
+    let ExtendOperand = 3;
+  }
+  // For FP classify operations.
+  // Output: (bit mask type output)
+  // Input: (vector_in, vl)
+  class RISCVClassifyNoMask
+        : Intrinsic<[LLVMVectorOfBitcastsToInt<0>],
+                    [llvm_anyvector_ty, llvm_anyint_ty],
+                    [IntrNoMem]>, RISCVVIntrinsic;
+  // For FP classify operations with mask.
+  // Output: (bit mask type output)
+  // Input: (maskedoff, vector_in, mask, vl)
+  class RISCVClassifyMask
+        : Intrinsic<[LLVMVectorOfBitcastsToInt<0>],
+                    [LLVMVectorOfBitcastsToInt<0>, llvm_anyvector_ty,
+                     LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>, llvm_anyint_ty],
+                    [IntrNoMem]>, RISCVVIntrinsic;
+  // For Saturating binary operations.
+  // The destination vector type is the same as first source vector.
+  // Input: (vector_in, vector_in/scalar_in, vl)
+  class RISCVSaturatingBinaryAAXNoMask
+        : Intrinsic<[llvm_anyvector_ty],
+                    [LLVMMatchType<0>, llvm_any_ty, llvm_anyint_ty],
+                    [IntrNoMem, IntrHasSideEffects]>, RISCVVIntrinsic {
+    let ExtendOperand = 2;
+  }
+  // For Saturating binary operations with mask.
+  // The destination vector type is the same as first source vector.
+  // Input: (maskedoff, vector_in, vector_in/scalar_in, mask, vl)
+  class RISCVSaturatingBinaryAAXMask
+        : Intrinsic<[llvm_anyvector_ty],
+                    [LLVMMatchType<0>, LLVMMatchType<0>, llvm_any_ty,
+                     LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>, llvm_anyint_ty],
+                    [IntrNoMem, IntrHasSideEffects]>, RISCVVIntrinsic {
+    let ExtendOperand = 3;
+  }
+  // For Saturating binary operations.
+  // The destination vector type is NOT the same as first source vector.
+  // Input: (vector_in, vector_in/scalar_in, vl)
+  class RISCVSaturatingBinaryABXNoMask
+        : Intrinsic<[llvm_anyvector_ty],
+                    [llvm_anyvector_ty, llvm_any_ty, llvm_anyint_ty],
+                    [IntrNoMem, IntrHasSideEffects]>, RISCVVIntrinsic {
+    let ExtendOperand = 2;
+  }
+  // For Saturating binary operations with mask.
+  // The destination vector type is NOT the same as first source vector (with mask).
+  // Input: (maskedoff, vector_in, vector_in/scalar_in, mask, vl)
+  class RISCVSaturatingBinaryABXMask
+        : Intrinsic<[llvm_anyvector_ty],
+                    [LLVMMatchType<0>, llvm_anyvector_ty, llvm_any_ty,
+                     LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>, llvm_anyint_ty],
+                    [IntrNoMem, IntrHasSideEffects]>, RISCVVIntrinsic {
+    let ExtendOperand = 3;
+  }
+  class RISCVTernaryAAAXNoMask
+        : Intrinsic<[llvm_anyvector_ty],
+                    [LLVMMatchType<0>, LLVMMatchType<0>, llvm_anyint_ty,
+                     LLVMMatchType<1>],
+                    [IntrNoMem]>, RISCVVIntrinsic;
+  class RISCVTernaryAAAXMask
+        : Intrinsic<[llvm_anyvector_ty],
+                    [LLVMMatchType<0>, LLVMMatchType<0>, llvm_anyint_ty,
+                     LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>, LLVMMatchType<1>],
+                    [IntrNoMem]>, RISCVVIntrinsic;
+  class RISCVTernaryAAXANoMask
+        : Intrinsic<[llvm_anyvector_ty],
+                    [LLVMMatchType<0>, llvm_any_ty, LLVMMatchType<0>,
+                     llvm_anyint_ty],
+                    [IntrNoMem]>, RISCVVIntrinsic {
+    let ExtendOperand = 2;
+  }
+  class RISCVTernaryAAXAMask
+        : Intrinsic<[llvm_anyvector_ty],
+                    [LLVMMatchType<0>, llvm_any_ty, LLVMMatchType<0>,
+                     LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>, llvm_anyint_ty],
+                    [IntrNoMem]>, RISCVVIntrinsic {
+    let ExtendOperand = 2;
+  }
+  class RISCVTernaryWideNoMask
+        : Intrinsic< [llvm_anyvector_ty],
+                     [LLVMMatchType<0>, llvm_any_ty, llvm_anyvector_ty,
+                      llvm_anyint_ty],
+                     [IntrNoMem] >, RISCVVIntrinsic {
+    let ExtendOperand = 2;
+  }
+  class RISCVTernaryWideMask
+        : Intrinsic< [llvm_anyvector_ty],
+                     [LLVMMatchType<0>, llvm_any_ty, llvm_anyvector_ty,
+                      LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>, llvm_anyint_ty],
+                     [IntrNoMem]>, RISCVVIntrinsic {
+    let ExtendOperand = 2;
+  }
+  // For Reduction ternary operations.
+  // For destination vector type is the same as first and third source vector.
+  // Input: (vector_in, vector_in, vector_in, vl)
+  class RISCVReductionNoMask
+        : Intrinsic<[llvm_anyvector_ty],
+                    [LLVMMatchType<0>, llvm_anyvector_ty, LLVMMatchType<0>,
+                     llvm_anyint_ty],
+                    [IntrNoMem]>, RISCVVIntrinsic;
+  // For Reduction ternary operations with mask.
+  // For destination vector type is the same as first and third source vector.
+  // The mask type come from second source vector.
+  // Input: (maskedoff, vector_in, vector_in, vector_in, mask, vl)
+  class RISCVReductionMask
+        : Intrinsic<[llvm_anyvector_ty],
+                    [LLVMMatchType<0>, llvm_anyvector_ty, LLVMMatchType<0>,
+                     LLVMScalarOrSameVectorWidth<1, llvm_i1_ty>, llvm_anyint_ty],
+                    [IntrNoMem]>, RISCVVIntrinsic;
+  // For unary operations with scalar type output without mask
+  // Output: (scalar type)
+  // Input: (vector_in, vl)
+  class RISCVMaskUnarySOutNoMask
+        : Intrinsic<[llvm_anyint_ty],
+                    [llvm_anyvector_ty, LLVMMatchType<0>],
+                    [IntrNoMem]>, RISCVVIntrinsic;
+  // For unary operations with scalar type output with mask
+  // Output: (scalar type)
+  // Input: (vector_in, mask, vl)
+  class RISCVMaskUnarySOutMask
+        : Intrinsic<[llvm_anyint_ty],
+                    [llvm_anyvector_ty, LLVMMatchType<1>, LLVMMatchType<0>],
+                    [IntrNoMem]>, RISCVVIntrinsic;
+  // For destination vector type is NOT the same as source vector.
+  // Input: (vector_in, vl)
+  class RISCVUnaryABNoMask
+        : Intrinsic<[llvm_anyvector_ty],
+                    [llvm_anyvector_ty, llvm_anyint_ty],
+                    [IntrNoMem]>, RISCVVIntrinsic;
+  // For destination vector type is NOT the same as source vector (with mask).
+  // Input: (maskedoff, vector_in, mask, vl)
+  class RISCVUnaryABMask
+        : Intrinsic<[llvm_anyvector_ty],
+                    [LLVMMatchType<0>, llvm_anyvector_ty,
+                     LLVMScalarOrSameVectorWidth<1, llvm_i1_ty>,
+                     llvm_anyint_ty],
+                    [IntrNoMem]>, RISCVVIntrinsic;
+  // For unary operations with the same vector type in/out without mask
+  // Output: (vector)
+  // Input: (vector_in, vl)
+  class RISCVUnaryNoMask
+        : Intrinsic<[llvm_anyvector_ty],
+                    [LLVMMatchType<0>, llvm_anyint_ty],
+                    [IntrNoMem]>, RISCVVIntrinsic;
+  // For mask unary operations with mask type in/out with mask
+  // Output: (mask type output)
+  // Input: (mask type maskedoff, mask type vector_in, mask, vl)
+  class RISCVMaskUnaryMOutMask
+        : Intrinsic<[llvm_anyint_ty],
+                    [LLVMMatchType<0>, LLVMMatchType<0>,
+                     LLVMMatchType<0>, llvm_anyint_ty],
+                    [IntrNoMem]>, RISCVVIntrinsic;
+  // Output: (vector)
+  // Input: (vl)
+  class RISCVNullaryIntrinsic
+        : Intrinsic<[llvm_anyvector_ty],
+                    [llvm_anyint_ty],
+                    [IntrNoMem]>, RISCVVIntrinsic;
+  // For Conversion unary operations.
+  // Input: (vector_in, vl)
+  class RISCVConversionNoMask
+        : Intrinsic<[llvm_anyvector_ty],
+                    [llvm_anyvector_ty, llvm_anyint_ty],
+                    [IntrNoMem]>, RISCVVIntrinsic;
+  // For Conversion unary operations with mask.
+  // Input: (maskedoff, vector_in, mask, vl)
+  class RISCVConversionMask
+        : Intrinsic<[llvm_anyvector_ty],
+                    [LLVMMatchType<0>, llvm_anyvector_ty,
+                     LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>, llvm_anyint_ty],
+                    [IntrNoMem]>, RISCVVIntrinsic;
+
+  multiclass RISCVUSLoad {
+    def "int_riscv_" # NAME : RISCVUSLoad;
+    def "int_riscv_" # NAME # "_mask" : RISCVUSLoadMask;
+  }
+  multiclass RISCVSLoad {
+    def "int_riscv_" # NAME : RISCVSLoad;
+    def "int_riscv_" # NAME # "_mask" : RISCVSLoadMask;
+  }
+  multiclass RISCVILoad {
+    def "int_riscv_" # NAME : RISCVILoad;
+    def "int_riscv_" # NAME # "_mask" : RISCVILoadMask;
+  }
+  multiclass RISCVUSStore {
+    def "int_riscv_" # NAME : RISCVUSStore;
+    def "int_riscv_" # NAME # "_mask" : RISCVUSStoreMask;
+  }
+  multiclass RISCVSStore {
+    def "int_riscv_" # NAME : RISCVSStore;
+    def "int_riscv_" # NAME # "_mask" : RISCVSStoreMask;
+  }
+
+  multiclass RISCVIStore {
+    def "int_riscv_" # NAME : RISCVIStore;
+    def "int_riscv_" # NAME # "_mask" : RISCVIStoreMask;
+  }
+  multiclass RISCVUnaryAA {
+    def "int_riscv_" # NAME : RISCVUnaryAANoMask;
+    def "int_riscv_" # NAME # "_mask" : RISCVUnaryAAMask;
+  }
+  multiclass RISCVUnaryAB {
+    def "int_riscv_" # NAME : RISCVUnaryABNoMask;
+    def "int_riscv_" # NAME # "_mask" : RISCVUnaryABMask;
+  }
+  // AAX means the destination type(A) is the same as the first source
+  // type(A). X means any type for the second source operand.
+  multiclass RISCVBinaryAAX {
+    def "int_riscv_" # NAME : RISCVBinaryAAXNoMask;
+    def "int_riscv_" # NAME # "_mask" : RISCVBinaryAAXMask;
+  }
+  // ABX means the destination type(A) is different from the first source
+  // type(B). X means any type for the second source operand.
+  multiclass RISCVBinaryABX {
+    def "int_riscv_" # NAME : RISCVBinaryABXNoMask;
+    def "int_riscv_" # NAME # "_mask" : RISCVBinaryABXMask;
+  }
+  multiclass RISCVBinaryWithV0 {
+    def "int_riscv_" # NAME : RISCVBinaryWithV0;
+  }
+  multiclass RISCVBinaryMaskOutWithV0 {
+    def "int_riscv_" # NAME : RISCVBinaryMOutWithV0;
+  }
+  multiclass RISCVBinaryMaskOut {
+    def "int_riscv_" # NAME : RISCVBinaryMOut;
+  }
+  multiclass RISCVSaturatingBinaryAAX {
+    def "int_riscv_" # NAME : RISCVSaturatingBinaryAAXNoMask;
+    def "int_riscv_" # NAME # "_mask" : RISCVSaturatingBinaryAAXMask;
+  }
+  multiclass RISCVSaturatingBinaryABX {
+    def "int_riscv_" # NAME : RISCVSaturatingBinaryABXNoMask;
+    def "int_riscv_" # NAME # "_mask" : RISCVSaturatingBinaryABXMask;
+  }
+  multiclass RISCVTernaryAAAX {
+    def "int_riscv_" # NAME : RISCVTernaryAAAXNoMask;
+    def "int_riscv_" # NAME # "_mask" : RISCVTernaryAAAXMask;
+  }
+  multiclass RISCVTernaryAAXA {
+    def "int_riscv_" # NAME : RISCVTernaryAAXANoMask;
+    def "int_riscv_" # NAME # "_mask" : RISCVTernaryAAXAMask;
+  }
+  multiclass RISCVCompare {
+    def "int_riscv_" # NAME : RISCVCompareNoMask;
+    def "int_riscv_" # NAME # "_mask" : RISCVCompareMask;
+  }
+  multiclass RISCVClassify {
+    def "int_riscv_" # NAME : RISCVClassifyNoMask;
+    def "int_riscv_" # NAME # "_mask" : RISCVClassifyMask;
+  }
+  multiclass RISCVTernaryWide {
+    def "int_riscv_" # NAME : RISCVTernaryWideNoMask;
+    def "int_riscv_" # NAME # "_mask" : RISCVTernaryWideMask;
+  }
+  multiclass RISCVReduction {
+    def "int_riscv_" # NAME : RISCVReductionNoMask;
+    def "int_riscv_" # NAME # "_mask" : RISCVReductionMask;
+  }
+  multiclass RISCVMaskUnarySOut {
+    def "int_riscv_" # NAME : RISCVMaskUnarySOutNoMask;
+    def "int_riscv_" # NAME # "_mask" : RISCVMaskUnarySOutMask;
+  }
+  multiclass RISCVMaskUnaryMOut {
+    def "int_riscv_" # NAME : RISCVUnaryNoMask;
+    def "int_riscv_" # NAME # "_mask" : RISCVMaskUnaryMOutMask;
+  }
+  multiclass RISCVConversion {
+    def "int_riscv_" #NAME :RISCVConversionNoMask;
+    def "int_riscv_" # NAME # "_mask" : RISCVConversionMask;
+  }
+
+  defm vle : RISCVUSLoad;
+  defm vleff : RISCVUSLoad;
+  defm vse : RISCVUSStore;
+  defm vlse: RISCVSLoad;
+  defm vsse: RISCVSStore;
+  defm vlxe: RISCVILoad;
+  defm vsxe: RISCVIStore;
+  defm vsuxe: RISCVIStore;
+
+  defm vadd : RISCVBinaryAAX;
+  defm vsub : RISCVBinaryAAX;
+  defm vrsub : RISCVBinaryAAX;
+
+  defm vwaddu : RISCVBinaryABX;
+  defm vwadd : RISCVBinaryABX;
+  defm vwaddu_w : RISCVBinaryAAX;
+  defm vwadd_w : RISCVBinaryAAX;
+  defm vwsubu : RISCVBinaryABX;
+  defm vwsub : RISCVBinaryABX;
+  defm vwsubu_w : RISCVBinaryAAX;
+  defm vwsub_w : RISCVBinaryAAX;
+
+  defm vzext : RISCVUnaryAB;
+  defm vsext : RISCVUnaryAB;
+
+  defm vadc : RISCVBinaryWithV0;
+  defm vmadc_carry_in : RISCVBinaryMaskOutWithV0;
+  defm vmadc : RISCVBinaryMaskOut;
+
+  defm vsbc : RISCVBinaryWithV0;
+  defm vmsbc_borrow_in : RISCVBinaryMaskOutWithV0;
+  defm vmsbc : RISCVBinaryMaskOut;
+
+  defm vand : RISCVBinaryAAX;
+  defm vor : RISCVBinaryAAX;
+  defm vxor : RISCVBinaryAAX;
+
+  defm vsll : RISCVBinaryAAX;
+  defm vsrl : RISCVBinaryAAX;
+  defm vsra : RISCVBinaryAAX;
+
+  defm vnsrl : RISCVBinaryABX;
+  defm vnsra : RISCVBinaryABX;
+
+  defm vmseq : RISCVCompare;
+  defm vmsne : RISCVCompare;
+  defm vmsltu : RISCVCompare;
+  defm vmslt : RISCVCompare;
+  defm vmsleu : RISCVCompare;
+  defm vmsle : RISCVCompare;
+  defm vmsgtu : RISCVCompare;
+  defm vmsgt : RISCVCompare;
+
+  defm vminu : RISCVBinaryAAX;
+  defm vmin : RISCVBinaryAAX;
+  defm vmaxu : RISCVBinaryAAX;
+  defm vmax : RISCVBinaryAAX;
+
+  defm vmul : RISCVBinaryAAX;
+  defm vmulh : RISCVBinaryAAX;
+  defm vmulhu : RISCVBinaryAAX;
+  defm vmulhsu : RISCVBinaryAAX;
+
+  defm vdivu : RISCVBinaryAAX;
+  defm vdiv : RISCVBinaryAAX;
+  defm vremu : RISCVBinaryAAX;
+  defm vrem : RISCVBinaryAAX;
+
+  defm vwmul : RISCVBinaryABX;
+  defm vwmulu : RISCVBinaryABX;
+  defm vwmulsu : RISCVBinaryABX;
+
+  defm vmacc : RISCVTernaryAAXA;
+  defm vnmsac : RISCVTernaryAAXA;
+  defm vmadd : RISCVTernaryAAXA;
+  defm vnmsub : RISCVTernaryAAXA;
+
+  defm vwmaccu  : RISCVTernaryWide;
+  defm vwmacc   : RISCVTernaryWide;
+  defm vwmaccus : RISCVTernaryWide;
+  defm vwmaccsu : RISCVTernaryWide;
+
+  defm vfadd : RISCVBinaryAAX;
+  defm vfsub : RISCVBinaryAAX;
+  defm vfrsub : RISCVBinaryAAX;
+
+  defm vfwadd : RISCVBinaryABX;
+  defm vfwsub : RISCVBinaryABX;
+  defm vfwadd_w : RISCVBinaryAAX;
+  defm vfwsub_w : RISCVBinaryAAX;
+
+  defm vsaddu : RISCVSaturatingBinaryAAX;
+  defm vsadd : RISCVSaturatingBinaryAAX;
+  defm vssubu : RISCVSaturatingBinaryAAX;
+  defm vssub : RISCVSaturatingBinaryAAX;
+
+  def int_riscv_vmerge : RISCVBinaryWithV0;
+
+  def int_riscv_vmv_v_v : Intrinsic<[llvm_anyvector_ty],
+                                    [LLVMMatchType<0>, llvm_anyint_ty],
+                                    [IntrNoMem]>, RISCVVIntrinsic;
+  def int_riscv_vmv_v_x : Intrinsic<[llvm_anyint_ty],
+                                    [LLVMVectorElementType<0>, llvm_anyint_ty],
+                                    [IntrNoMem]>, RISCVVIntrinsic {
+    let ExtendOperand = 1;
+  }
+  def int_riscv_vfmv_v_f : Intrinsic<[llvm_anyfloat_ty],
+                                     [LLVMVectorElementType<0>, llvm_anyint_ty],
+                                     [IntrNoMem]>, RISCVVIntrinsic;
+
+  def int_riscv_vmv_x_s : Intrinsic<[LLVMVectorElementType<0>],
+                                    [llvm_anyint_ty],
+                                    [IntrNoMem]>, RISCVVIntrinsic;
+  def int_riscv_vmv_s_x : Intrinsic<[llvm_anyint_ty],
+                                    [LLVMMatchType<0>, LLVMVectorElementType<0>,
+                                     llvm_anyint_ty],
+                                    [IntrNoMem]>, RISCVVIntrinsic {
+    let ExtendOperand = 2;
+  }
+
+  def int_riscv_vfmv_f_s : Intrinsic<[LLVMVectorElementType<0>],
+                                     [llvm_anyfloat_ty],
+                                     [IntrNoMem]>, RISCVVIntrinsic;
+  def int_riscv_vfmv_s_f : Intrinsic<[llvm_anyfloat_ty],
+                                     [LLVMMatchType<0>, LLVMVectorElementType<0>,
+                                      llvm_anyint_ty],
+                                     [IntrNoMem]>, RISCVVIntrinsic;
+
+  defm vfmul : RISCVBinaryAAX;
+  defm vfdiv : RISCVBinaryAAX;
+  defm vfrdiv : RISCVBinaryAAX;
+
+  defm vfwmul : RISCVBinaryABX;
+
+  defm vfmacc : RISCVTernaryAAXA;
+  defm vfnmacc : RISCVTernaryAAXA;
+  defm vfmsac : RISCVTernaryAAXA;
+  defm vfnmsac : RISCVTernaryAAXA;
+  defm vfmadd : RISCVTernaryAAXA;
+  defm vfnmadd : RISCVTernaryAAXA;
+  defm vfmsub : RISCVTernaryAAXA;
+  defm vfnmsub : RISCVTernaryAAXA;
+
+  defm vfwmacc : RISCVTernaryWide;
+  defm vfwnmacc : RISCVTernaryWide;
+  defm vfwmsac : RISCVTernaryWide;
+  defm vfwnmsac : RISCVTernaryWide;
+
+  defm vfsqrt : RISCVUnaryAA;
+
+  defm vfmin : RISCVBinaryAAX;
+  defm vfmax : RISCVBinaryAAX;
+
+  defm vfsgnj : RISCVBinaryAAX;
+  defm vfsgnjn : RISCVBinaryAAX;
+  defm vfsgnjx : RISCVBinaryAAX;
+
+  defm vfclass : RISCVClassify;
+
+  defm vfmerge : RISCVBinaryWithV0;
+
+  defm vslideup : RISCVTernaryAAAX;
+  defm vslidedown : RISCVTernaryAAAX;
+
+  defm vslide1up : RISCVBinaryAAX;
+  defm vslide1down : RISCVBinaryAAX;
+  defm vfslide1up : RISCVBinaryAAX;
+  defm vfslide1down : RISCVBinaryAAX;
+
+  defm vrgather : RISCVBinaryAAX;
+
+  def "int_riscv_vcompress" : RISCVBinaryAAAMask;
+
+  defm vaaddu : RISCVSaturatingBinaryAAX;
+  defm vaadd : RISCVSaturatingBinaryAAX;
+  defm vasubu : RISCVSaturatingBinaryAAX;
+  defm vasub : RISCVSaturatingBinaryAAX;
+
+  defm vsmul : RISCVSaturatingBinaryAAX;
+
+  defm vssrl : RISCVSaturatingBinaryAAX;
+  defm vssra : RISCVSaturatingBinaryAAX;
+
+  defm vnclipu : RISCVSaturatingBinaryABX;
+  defm vnclip : RISCVSaturatingBinaryABX;
+
+  defm vmfeq : RISCVCompare;
+  defm vmfne : RISCVCompare;
+  defm vmflt : RISCVCompare;
+  defm vmfle : RISCVCompare;
+  defm vmfgt : RISCVCompare;
+  defm vmfge : RISCVCompare;
+
+  defm vredsum : RISCVReduction;
+  defm vredand : RISCVReduction;
+  defm vredor : RISCVReduction;
+  defm vredxor : RISCVReduction;
+  defm vredminu : RISCVReduction;
+  defm vredmin : RISCVReduction;
+  defm vredmaxu : RISCVReduction;
+  defm vredmax : RISCVReduction;
+
+  defm vwredsumu : RISCVReduction;
+  defm vwredsum : RISCVReduction;
+
+  defm vfredosum : RISCVReduction;
+  defm vfredsum : RISCVReduction;
+  defm vfredmin : RISCVReduction;
+  defm vfredmax : RISCVReduction;
+
+  defm vfwredsum : RISCVReduction;
+  defm vfwredosum : RISCVReduction;
+
+  def int_riscv_vmand: RISCVBinaryAAANoMask;
+  def int_riscv_vmnand: RISCVBinaryAAANoMask;
+  def int_riscv_vmandnot: RISCVBinaryAAANoMask;
+  def int_riscv_vmxor: RISCVBinaryAAANoMask;
+  def int_riscv_vmor: RISCVBinaryAAANoMask;
+  def int_riscv_vmnor: RISCVBinaryAAANoMask;
+  def int_riscv_vmornot: RISCVBinaryAAANoMask;
+  def int_riscv_vmxnor: RISCVBinaryAAANoMask;
+  def int_riscv_vmclr : RISCVNullaryIntrinsic;
+  def int_riscv_vmset : RISCVNullaryIntrinsic;
+
+  defm vpopc : RISCVMaskUnarySOut;
+  defm vfirst : RISCVMaskUnarySOut;
+  defm vmsbf : RISCVMaskUnaryMOut;
+  defm vmsof : RISCVMaskUnaryMOut;
+  defm vmsif : RISCVMaskUnaryMOut;
+
+  defm vfcvt_xu_f_v : RISCVConversion;
+  defm vfcvt_x_f_v : RISCVConversion;
+  defm vfcvt_rtz_xu_f_v : RISCVConversion;
+  defm vfcvt_rtz_x_f_v : RISCVConversion;
+  defm vfcvt_f_xu_v : RISCVConversion;
+  defm vfcvt_f_x_v : RISCVConversion;
+
+  defm vfwcvt_f_xu_v : RISCVConversion;
+  defm vfwcvt_f_x_v : RISCVConversion;
+  defm vfwcvt_xu_f_v : RISCVConversion;
+  defm vfwcvt_x_f_v : RISCVConversion;
+  defm vfwcvt_rtz_xu_f_v : RISCVConversion;
+  defm vfwcvt_rtz_x_f_v : RISCVConversion;
+  defm vfwcvt_f_f_v : RISCVConversion;
+
+  defm vfncvt_f_xu_w : RISCVConversion;
+  defm vfncvt_f_x_w : RISCVConversion;
+  defm vfncvt_xu_f_w : RISCVConversion;
+  defm vfncvt_x_f_w : RISCVConversion;
+  defm vfncvt_rtz_xu_f_w : RISCVConversion;
+  defm vfncvt_rtz_x_f_w : RISCVConversion;
+  defm vfncvt_f_f_w : RISCVConversion;
+  defm vfncvt_rod_f_f_w : RISCVConversion;
+
+  // Output: (vector)
+  // Input: (mask type input, vl)
+  def int_riscv_viota : Intrinsic<[llvm_anyvector_ty],
+                                  [LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>,
+                                   llvm_anyint_ty],
+                                  [IntrNoMem]>, RISCVVIntrinsic;
+  // Output: (vector)
+  // Input: (maskedoff, mask type vector_in, mask, vl)
+  def int_riscv_viota_mask : Intrinsic<[llvm_anyvector_ty],
+                                       [LLVMMatchType<0>,
+                                        LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>,
+                                        LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>,
+                                        llvm_anyint_ty],
+                                       [IntrNoMem]>, RISCVVIntrinsic;
+  // Output: (vector)
+  // Input: (vl)
+  def int_riscv_vid : RISCVNullaryIntrinsic;
+
+  // Output: (vector)
+  // Input: (maskedoff, mask, vl)
+  def int_riscv_vid_mask : Intrinsic<[llvm_anyvector_ty],
+                                     [LLVMMatchType<0>,
+                                      LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>,
+                                      llvm_anyint_ty],
+                                     [IntrNoMem]>, RISCVVIntrinsic;
 
 } // TargetPrefix = "riscv"
diff --git a/linux-x64/clang/include/llvm/IR/IntrinsicsS390.h b/linux-x64/clang/include/llvm/IR/IntrinsicsS390.h
new file mode 100644
index 0000000..ae62baa
--- /dev/null
+++ b/linux-x64/clang/include/llvm/IR/IntrinsicsS390.h
@@ -0,0 +1,248 @@
+/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
+|*                                                                            *|
+|* Intrinsic Function Source Fragment                                         *|
+|*                                                                            *|
+|* Automatically generated file, do not edit!                                 *|
+|*                                                                            *|
+\*===----------------------------------------------------------------------===*/
+
+#ifndef LLVM_IR_INTRINSIC_S390_ENUMS_H
+#define LLVM_IR_INTRINSIC_S390_ENUMS_H
+
+namespace llvm {
+namespace Intrinsic {
+enum S390Intrinsics : unsigned {
+// Enum values for intrinsics
+    s390_efpc = 6987,                                 // llvm.s390.efpc
+    s390_etnd,                                 // llvm.s390.etnd
+    s390_lcbb,                                 // llvm.s390.lcbb
+    s390_ntstg,                                // llvm.s390.ntstg
+    s390_ppa_txassist,                         // llvm.s390.ppa.txassist
+    s390_sfpc,                                 // llvm.s390.sfpc
+    s390_tabort,                               // llvm.s390.tabort
+    s390_tbegin,                               // llvm.s390.tbegin
+    s390_tbegin_nofloat,                       // llvm.s390.tbegin.nofloat
+    s390_tbeginc,                              // llvm.s390.tbeginc
+    s390_tdc,                                  // llvm.s390.tdc
+    s390_tend,                                 // llvm.s390.tend
+    s390_vaccb,                                // llvm.s390.vaccb
+    s390_vacccq,                               // llvm.s390.vacccq
+    s390_vaccf,                                // llvm.s390.vaccf
+    s390_vaccg,                                // llvm.s390.vaccg
+    s390_vacch,                                // llvm.s390.vacch
+    s390_vaccq,                                // llvm.s390.vaccq
+    s390_vacq,                                 // llvm.s390.vacq
+    s390_vaq,                                  // llvm.s390.vaq
+    s390_vavgb,                                // llvm.s390.vavgb
+    s390_vavgf,                                // llvm.s390.vavgf
+    s390_vavgg,                                // llvm.s390.vavgg
+    s390_vavgh,                                // llvm.s390.vavgh
+    s390_vavglb,                               // llvm.s390.vavglb
+    s390_vavglf,                               // llvm.s390.vavglf
+    s390_vavglg,                               // llvm.s390.vavglg
+    s390_vavglh,                               // llvm.s390.vavglh
+    s390_vbperm,                               // llvm.s390.vbperm
+    s390_vceqbs,                               // llvm.s390.vceqbs
+    s390_vceqfs,                               // llvm.s390.vceqfs
+    s390_vceqgs,                               // llvm.s390.vceqgs
+    s390_vceqhs,                               // llvm.s390.vceqhs
+    s390_vchbs,                                // llvm.s390.vchbs
+    s390_vchfs,                                // llvm.s390.vchfs
+    s390_vchgs,                                // llvm.s390.vchgs
+    s390_vchhs,                                // llvm.s390.vchhs
+    s390_vchlbs,                               // llvm.s390.vchlbs
+    s390_vchlfs,                               // llvm.s390.vchlfs
+    s390_vchlgs,                               // llvm.s390.vchlgs
+    s390_vchlhs,                               // llvm.s390.vchlhs
+    s390_vcksm,                                // llvm.s390.vcksm
+    s390_verimb,                               // llvm.s390.verimb
+    s390_verimf,                               // llvm.s390.verimf
+    s390_verimg,                               // llvm.s390.verimg
+    s390_verimh,                               // llvm.s390.verimh
+    s390_verllb,                               // llvm.s390.verllb
+    s390_verllf,                               // llvm.s390.verllf
+    s390_verllg,                               // llvm.s390.verllg
+    s390_verllh,                               // llvm.s390.verllh
+    s390_verllvb,                              // llvm.s390.verllvb
+    s390_verllvf,                              // llvm.s390.verllvf
+    s390_verllvg,                              // llvm.s390.verllvg
+    s390_verllvh,                              // llvm.s390.verllvh
+    s390_vfaeb,                                // llvm.s390.vfaeb
+    s390_vfaebs,                               // llvm.s390.vfaebs
+    s390_vfaef,                                // llvm.s390.vfaef
+    s390_vfaefs,                               // llvm.s390.vfaefs
+    s390_vfaeh,                                // llvm.s390.vfaeh
+    s390_vfaehs,                               // llvm.s390.vfaehs
+    s390_vfaezb,                               // llvm.s390.vfaezb
+    s390_vfaezbs,                              // llvm.s390.vfaezbs
+    s390_vfaezf,                               // llvm.s390.vfaezf
+    s390_vfaezfs,                              // llvm.s390.vfaezfs
+    s390_vfaezh,                               // llvm.s390.vfaezh
+    s390_vfaezhs,                              // llvm.s390.vfaezhs
+    s390_vfcedbs,                              // llvm.s390.vfcedbs
+    s390_vfcesbs,                              // llvm.s390.vfcesbs
+    s390_vfchdbs,                              // llvm.s390.vfchdbs
+    s390_vfchedbs,                             // llvm.s390.vfchedbs
+    s390_vfchesbs,                             // llvm.s390.vfchesbs
+    s390_vfchsbs,                              // llvm.s390.vfchsbs
+    s390_vfeeb,                                // llvm.s390.vfeeb
+    s390_vfeebs,                               // llvm.s390.vfeebs
+    s390_vfeef,                                // llvm.s390.vfeef
+    s390_vfeefs,                               // llvm.s390.vfeefs
+    s390_vfeeh,                                // llvm.s390.vfeeh
+    s390_vfeehs,                               // llvm.s390.vfeehs
+    s390_vfeezb,                               // llvm.s390.vfeezb
+    s390_vfeezbs,                              // llvm.s390.vfeezbs
+    s390_vfeezf,                               // llvm.s390.vfeezf
+    s390_vfeezfs,                              // llvm.s390.vfeezfs
+    s390_vfeezh,                               // llvm.s390.vfeezh
+    s390_vfeezhs,                              // llvm.s390.vfeezhs
+    s390_vfeneb,                               // llvm.s390.vfeneb
+    s390_vfenebs,                              // llvm.s390.vfenebs
+    s390_vfenef,                               // llvm.s390.vfenef
+    s390_vfenefs,                              // llvm.s390.vfenefs
+    s390_vfeneh,                               // llvm.s390.vfeneh
+    s390_vfenehs,                              // llvm.s390.vfenehs
+    s390_vfenezb,                              // llvm.s390.vfenezb
+    s390_vfenezbs,                             // llvm.s390.vfenezbs
+    s390_vfenezf,                              // llvm.s390.vfenezf
+    s390_vfenezfs,                             // llvm.s390.vfenezfs
+    s390_vfenezh,                              // llvm.s390.vfenezh
+    s390_vfenezhs,                             // llvm.s390.vfenezhs
+    s390_vfidb,                                // llvm.s390.vfidb
+    s390_vfisb,                                // llvm.s390.vfisb
+    s390_vfmaxdb,                              // llvm.s390.vfmaxdb
+    s390_vfmaxsb,                              // llvm.s390.vfmaxsb
+    s390_vfmindb,                              // llvm.s390.vfmindb
+    s390_vfminsb,                              // llvm.s390.vfminsb
+    s390_vftcidb,                              // llvm.s390.vftcidb
+    s390_vftcisb,                              // llvm.s390.vftcisb
+    s390_vgfmab,                               // llvm.s390.vgfmab
+    s390_vgfmaf,                               // llvm.s390.vgfmaf
+    s390_vgfmag,                               // llvm.s390.vgfmag
+    s390_vgfmah,                               // llvm.s390.vgfmah
+    s390_vgfmb,                                // llvm.s390.vgfmb
+    s390_vgfmf,                                // llvm.s390.vgfmf
+    s390_vgfmg,                                // llvm.s390.vgfmg
+    s390_vgfmh,                                // llvm.s390.vgfmh
+    s390_vistrb,                               // llvm.s390.vistrb
+    s390_vistrbs,                              // llvm.s390.vistrbs
+    s390_vistrf,                               // llvm.s390.vistrf
+    s390_vistrfs,                              // llvm.s390.vistrfs
+    s390_vistrh,                               // llvm.s390.vistrh
+    s390_vistrhs,                              // llvm.s390.vistrhs
+    s390_vlbb,                                 // llvm.s390.vlbb
+    s390_vll,                                  // llvm.s390.vll
+    s390_vlrl,                                 // llvm.s390.vlrl
+    s390_vmaeb,                                // llvm.s390.vmaeb
+    s390_vmaef,                                // llvm.s390.vmaef
+    s390_vmaeh,                                // llvm.s390.vmaeh
+    s390_vmahb,                                // llvm.s390.vmahb
+    s390_vmahf,                                // llvm.s390.vmahf
+    s390_vmahh,                                // llvm.s390.vmahh
+    s390_vmaleb,                               // llvm.s390.vmaleb
+    s390_vmalef,                               // llvm.s390.vmalef
+    s390_vmaleh,                               // llvm.s390.vmaleh
+    s390_vmalhb,                               // llvm.s390.vmalhb
+    s390_vmalhf,                               // llvm.s390.vmalhf
+    s390_vmalhh,                               // llvm.s390.vmalhh
+    s390_vmalob,                               // llvm.s390.vmalob
+    s390_vmalof,                               // llvm.s390.vmalof
+    s390_vmaloh,                               // llvm.s390.vmaloh
+    s390_vmaob,                                // llvm.s390.vmaob
+    s390_vmaof,                                // llvm.s390.vmaof
+    s390_vmaoh,                                // llvm.s390.vmaoh
+    s390_vmeb,                                 // llvm.s390.vmeb
+    s390_vmef,                                 // llvm.s390.vmef
+    s390_vmeh,                                 // llvm.s390.vmeh
+    s390_vmhb,                                 // llvm.s390.vmhb
+    s390_vmhf,                                 // llvm.s390.vmhf
+    s390_vmhh,                                 // llvm.s390.vmhh
+    s390_vmleb,                                // llvm.s390.vmleb
+    s390_vmlef,                                // llvm.s390.vmlef
+    s390_vmleh,                                // llvm.s390.vmleh
+    s390_vmlhb,                                // llvm.s390.vmlhb
+    s390_vmlhf,                                // llvm.s390.vmlhf
+    s390_vmlhh,                                // llvm.s390.vmlhh
+    s390_vmlob,                                // llvm.s390.vmlob
+    s390_vmlof,                                // llvm.s390.vmlof
+    s390_vmloh,                                // llvm.s390.vmloh
+    s390_vmob,                                 // llvm.s390.vmob
+    s390_vmof,                                 // llvm.s390.vmof
+    s390_vmoh,                                 // llvm.s390.vmoh
+    s390_vmslg,                                // llvm.s390.vmslg
+    s390_vpdi,                                 // llvm.s390.vpdi
+    s390_vperm,                                // llvm.s390.vperm
+    s390_vpklsf,                               // llvm.s390.vpklsf
+    s390_vpklsfs,                              // llvm.s390.vpklsfs
+    s390_vpklsg,                               // llvm.s390.vpklsg
+    s390_vpklsgs,                              // llvm.s390.vpklsgs
+    s390_vpklsh,                               // llvm.s390.vpklsh
+    s390_vpklshs,                              // llvm.s390.vpklshs
+    s390_vpksf,                                // llvm.s390.vpksf
+    s390_vpksfs,                               // llvm.s390.vpksfs
+    s390_vpksg,                                // llvm.s390.vpksg
+    s390_vpksgs,                               // llvm.s390.vpksgs
+    s390_vpksh,                                // llvm.s390.vpksh
+    s390_vpkshs,                               // llvm.s390.vpkshs
+    s390_vsbcbiq,                              // llvm.s390.vsbcbiq
+    s390_vsbiq,                                // llvm.s390.vsbiq
+    s390_vscbib,                               // llvm.s390.vscbib
+    s390_vscbif,                               // llvm.s390.vscbif
+    s390_vscbig,                               // llvm.s390.vscbig
+    s390_vscbih,                               // llvm.s390.vscbih
+    s390_vscbiq,                               // llvm.s390.vscbiq
+    s390_vsl,                                  // llvm.s390.vsl
+    s390_vslb,                                 // llvm.s390.vslb
+    s390_vsld,                                 // llvm.s390.vsld
+    s390_vsldb,                                // llvm.s390.vsldb
+    s390_vsq,                                  // llvm.s390.vsq
+    s390_vsra,                                 // llvm.s390.vsra
+    s390_vsrab,                                // llvm.s390.vsrab
+    s390_vsrd,                                 // llvm.s390.vsrd
+    s390_vsrl,                                 // llvm.s390.vsrl
+    s390_vsrlb,                                // llvm.s390.vsrlb
+    s390_vstl,                                 // llvm.s390.vstl
+    s390_vstrcb,                               // llvm.s390.vstrcb
+    s390_vstrcbs,                              // llvm.s390.vstrcbs
+    s390_vstrcf,                               // llvm.s390.vstrcf
+    s390_vstrcfs,                              // llvm.s390.vstrcfs
+    s390_vstrch,                               // llvm.s390.vstrch
+    s390_vstrchs,                              // llvm.s390.vstrchs
+    s390_vstrczb,                              // llvm.s390.vstrczb
+    s390_vstrczbs,                             // llvm.s390.vstrczbs
+    s390_vstrczf,                              // llvm.s390.vstrczf
+    s390_vstrczfs,                             // llvm.s390.vstrczfs
+    s390_vstrczh,                              // llvm.s390.vstrczh
+    s390_vstrczhs,                             // llvm.s390.vstrczhs
+    s390_vstrl,                                // llvm.s390.vstrl
+    s390_vstrsb,                               // llvm.s390.vstrsb
+    s390_vstrsf,                               // llvm.s390.vstrsf
+    s390_vstrsh,                               // llvm.s390.vstrsh
+    s390_vstrszb,                              // llvm.s390.vstrszb
+    s390_vstrszf,                              // llvm.s390.vstrszf
+    s390_vstrszh,                              // llvm.s390.vstrszh
+    s390_vsumb,                                // llvm.s390.vsumb
+    s390_vsumgf,                               // llvm.s390.vsumgf
+    s390_vsumgh,                               // llvm.s390.vsumgh
+    s390_vsumh,                                // llvm.s390.vsumh
+    s390_vsumqf,                               // llvm.s390.vsumqf
+    s390_vsumqg,                               // llvm.s390.vsumqg
+    s390_vtm,                                  // llvm.s390.vtm
+    s390_vuphb,                                // llvm.s390.vuphb
+    s390_vuphf,                                // llvm.s390.vuphf
+    s390_vuphh,                                // llvm.s390.vuphh
+    s390_vuplb,                                // llvm.s390.vuplb
+    s390_vuplf,                                // llvm.s390.vuplf
+    s390_vuplhb,                               // llvm.s390.vuplhb
+    s390_vuplhf,                               // llvm.s390.vuplhf
+    s390_vuplhh,                               // llvm.s390.vuplhh
+    s390_vuplhw,                               // llvm.s390.vuplhw
+    s390_vupllb,                               // llvm.s390.vupllb
+    s390_vupllf,                               // llvm.s390.vupllf
+    s390_vupllh,                               // llvm.s390.vupllh
+}; // enum
+} // namespace Intrinsic
+} // namespace llvm
+
+#endif
diff --git a/linux-x64/clang/include/llvm/IR/IntrinsicsSystemZ.td b/linux-x64/clang/include/llvm/IR/IntrinsicsSystemZ.td
index 68ac285..b0c5cf0 100644
--- a/linux-x64/clang/include/llvm/IR/IntrinsicsSystemZ.td
+++ b/linux-x64/clang/include/llvm/IR/IntrinsicsSystemZ.td
@@ -11,7 +11,7 @@
 //===----------------------------------------------------------------------===//
 
 class SystemZUnaryConv<string name, LLVMType result, LLVMType arg>
-  : GCCBuiltin<"__builtin_s390_" ## name>,
+  : GCCBuiltin<"__builtin_s390_" # name>,
     Intrinsic<[result], [arg], [IntrNoMem]>;
 
 class SystemZUnary<string name, LLVMType type>
@@ -24,14 +24,14 @@
   : SystemZUnaryConvCC<type, type>;
 
 class SystemZBinaryConv<string name, LLVMType result, LLVMType arg>
-  : GCCBuiltin<"__builtin_s390_" ## name>,
+  : GCCBuiltin<"__builtin_s390_" # name>,
     Intrinsic<[result], [arg, arg], [IntrNoMem]>;
 
 class SystemZBinary<string name, LLVMType type>
   : SystemZBinaryConv<name, type, type>;
 
 class SystemZBinaryInt<string name, LLVMType type>
-  : GCCBuiltin<"__builtin_s390_" ## name>,
+  : GCCBuiltin<"__builtin_s390_" # name>,
     Intrinsic<[type], [type, llvm_i32_ty], [IntrNoMem]>;
 
 class SystemZBinaryConvCC<LLVMType result, LLVMType arg>
@@ -39,55 +39,58 @@
 
 class SystemZBinaryConvIntCC<LLVMType result, LLVMType arg>
   : Intrinsic<[result, llvm_i32_ty], [arg, llvm_i32_ty],
-              [IntrNoMem, ImmArg<1>]>;
+              [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 
 class SystemZBinaryCC<LLVMType type>
   : SystemZBinaryConvCC<type, type>;
 
 class SystemZTernaryConv<string name, LLVMType result, LLVMType arg>
-  : GCCBuiltin<"__builtin_s390_" ## name>,
+  : GCCBuiltin<"__builtin_s390_" # name>,
     Intrinsic<[result], [arg, arg, result], [IntrNoMem]>;
 
+class SystemZTernaryConvCC<LLVMType result, LLVMType arg>
+  : Intrinsic<[result, llvm_i32_ty], [arg, arg, result], [IntrNoMem]>;
+
 class SystemZTernary<string name, LLVMType type>
   : SystemZTernaryConv<name, type, type>;
 
 class SystemZTernaryInt<string name, LLVMType type>
-  : GCCBuiltin<"__builtin_s390_" ## name>,
-    Intrinsic<[type], [type, type, llvm_i32_ty], [IntrNoMem, ImmArg<2>]>;
+  : GCCBuiltin<"__builtin_s390_" # name>,
+    Intrinsic<[type], [type, type, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<2>>]>;
 
 class SystemZTernaryIntCC<LLVMType type>
   : Intrinsic<[type, llvm_i32_ty], [type, type, llvm_i32_ty],
-              [IntrNoMem, ImmArg<2>]>;
+              [IntrNoMem, ImmArg<ArgIndex<2>>]>;
 
 class SystemZQuaternaryInt<string name, LLVMType type>
-  : GCCBuiltin<"__builtin_s390_" ## name>,
+  : GCCBuiltin<"__builtin_s390_" # name>,
     Intrinsic<[type], [type, type, type, llvm_i32_ty],
-    [IntrNoMem, ImmArg<3>]>;
+    [IntrNoMem, ImmArg<ArgIndex<3>>]>;
 
 class SystemZQuaternaryIntCC<LLVMType type>
   : Intrinsic<[type, llvm_i32_ty], [type, type, type, llvm_i32_ty],
-              [IntrNoMem, ImmArg<3>]>;
+              [IntrNoMem, ImmArg<ArgIndex<3>>]>;
 
 multiclass SystemZUnaryExtBHF<string name> {
-  def b : SystemZUnaryConv<name##"b", llvm_v8i16_ty, llvm_v16i8_ty>;
-  def h : SystemZUnaryConv<name##"h", llvm_v4i32_ty, llvm_v8i16_ty>;
-  def f : SystemZUnaryConv<name##"f", llvm_v2i64_ty, llvm_v4i32_ty>;
+  def b : SystemZUnaryConv<name#"b", llvm_v8i16_ty, llvm_v16i8_ty>;
+  def h : SystemZUnaryConv<name#"h", llvm_v4i32_ty, llvm_v8i16_ty>;
+  def f : SystemZUnaryConv<name#"f", llvm_v2i64_ty, llvm_v4i32_ty>;
 }
 
 multiclass SystemZUnaryExtBHWF<string name> {
-  def b  : SystemZUnaryConv<name##"b",  llvm_v8i16_ty, llvm_v16i8_ty>;
-  def hw : SystemZUnaryConv<name##"hw", llvm_v4i32_ty, llvm_v8i16_ty>;
-  def f  : SystemZUnaryConv<name##"f",  llvm_v2i64_ty, llvm_v4i32_ty>;
+  def b  : SystemZUnaryConv<name#"b",  llvm_v8i16_ty, llvm_v16i8_ty>;
+  def hw : SystemZUnaryConv<name#"hw", llvm_v4i32_ty, llvm_v8i16_ty>;
+  def f  : SystemZUnaryConv<name#"f",  llvm_v2i64_ty, llvm_v4i32_ty>;
 }
 
 multiclass SystemZUnaryBHF<string name> {
-  def b : SystemZUnary<name##"b", llvm_v16i8_ty>;
-  def h : SystemZUnary<name##"h", llvm_v8i16_ty>;
-  def f : SystemZUnary<name##"f", llvm_v4i32_ty>;
+  def b : SystemZUnary<name#"b", llvm_v16i8_ty>;
+  def h : SystemZUnary<name#"h", llvm_v8i16_ty>;
+  def f : SystemZUnary<name#"f", llvm_v4i32_ty>;
 }
 
 multiclass SystemZUnaryBHFG<string name> : SystemZUnaryBHF<name> {
-  def g : SystemZUnary<name##"g", llvm_v2i64_ty>;
+  def g : SystemZUnary<name#"g", llvm_v2i64_ty>;
 }
 
 multiclass SystemZUnaryCCBHF {
@@ -97,9 +100,9 @@
 }
 
 multiclass SystemZBinaryTruncHFG<string name> {
-  def h : SystemZBinaryConv<name##"h", llvm_v16i8_ty, llvm_v8i16_ty>;
-  def f : SystemZBinaryConv<name##"f", llvm_v8i16_ty, llvm_v4i32_ty>;
-  def g : SystemZBinaryConv<name##"g", llvm_v4i32_ty, llvm_v2i64_ty>;
+  def h : SystemZBinaryConv<name#"h", llvm_v16i8_ty, llvm_v8i16_ty>;
+  def f : SystemZBinaryConv<name#"f", llvm_v8i16_ty, llvm_v4i32_ty>;
+  def g : SystemZBinaryConv<name#"g", llvm_v4i32_ty, llvm_v2i64_ty>;
 }
 
 multiclass SystemZBinaryTruncCCHFG {
@@ -109,30 +112,30 @@
 }
 
 multiclass SystemZBinaryExtBHF<string name> {
-  def b : SystemZBinaryConv<name##"b", llvm_v8i16_ty, llvm_v16i8_ty>;
-  def h : SystemZBinaryConv<name##"h", llvm_v4i32_ty, llvm_v8i16_ty>;
-  def f : SystemZBinaryConv<name##"f", llvm_v2i64_ty, llvm_v4i32_ty>;
+  def b : SystemZBinaryConv<name#"b", llvm_v8i16_ty, llvm_v16i8_ty>;
+  def h : SystemZBinaryConv<name#"h", llvm_v4i32_ty, llvm_v8i16_ty>;
+  def f : SystemZBinaryConv<name#"f", llvm_v2i64_ty, llvm_v4i32_ty>;
 }
 
 multiclass SystemZBinaryExtBHFG<string name> : SystemZBinaryExtBHF<name> {
-  def g : SystemZBinaryConv<name##"g", llvm_v16i8_ty, llvm_v2i64_ty>;
+  def g : SystemZBinaryConv<name#"g", llvm_v16i8_ty, llvm_v2i64_ty>;
 }
 
 multiclass SystemZBinaryBHF<string name> {
-  def b : SystemZBinary<name##"b", llvm_v16i8_ty>;
-  def h : SystemZBinary<name##"h", llvm_v8i16_ty>;
-  def f : SystemZBinary<name##"f", llvm_v4i32_ty>;
+  def b : SystemZBinary<name#"b", llvm_v16i8_ty>;
+  def h : SystemZBinary<name#"h", llvm_v8i16_ty>;
+  def f : SystemZBinary<name#"f", llvm_v4i32_ty>;
 }
 
 multiclass SystemZBinaryBHFG<string name> : SystemZBinaryBHF<name> {
-  def g : SystemZBinary<name##"g", llvm_v2i64_ty>;
+  def g : SystemZBinary<name#"g", llvm_v2i64_ty>;
 }
 
 multiclass SystemZBinaryIntBHFG<string name> {
-  def b : SystemZBinaryInt<name##"b", llvm_v16i8_ty>;
-  def h : SystemZBinaryInt<name##"h", llvm_v8i16_ty>;
-  def f : SystemZBinaryInt<name##"f", llvm_v4i32_ty>;
-  def g : SystemZBinaryInt<name##"g", llvm_v2i64_ty>;
+  def b : SystemZBinaryInt<name#"b", llvm_v16i8_ty>;
+  def h : SystemZBinaryInt<name#"h", llvm_v8i16_ty>;
+  def f : SystemZBinaryInt<name#"f", llvm_v4i32_ty>;
+  def g : SystemZBinaryInt<name#"g", llvm_v2i64_ty>;
 }
 
 multiclass SystemZBinaryCCBHF {
@@ -149,25 +152,25 @@
 }
 
 multiclass SystemZTernaryExtBHF<string name> {
-  def b : SystemZTernaryConv<name##"b", llvm_v8i16_ty, llvm_v16i8_ty>;
-  def h : SystemZTernaryConv<name##"h", llvm_v4i32_ty, llvm_v8i16_ty>;
-  def f : SystemZTernaryConv<name##"f", llvm_v2i64_ty, llvm_v4i32_ty>;
+  def b : SystemZTernaryConv<name#"b", llvm_v8i16_ty, llvm_v16i8_ty>;
+  def h : SystemZTernaryConv<name#"h", llvm_v4i32_ty, llvm_v8i16_ty>;
+  def f : SystemZTernaryConv<name#"f", llvm_v2i64_ty, llvm_v4i32_ty>;
 }
 
 multiclass SystemZTernaryExtBHFG<string name> : SystemZTernaryExtBHF<name> {
-  def g : SystemZTernaryConv<name##"g", llvm_v16i8_ty, llvm_v2i64_ty>;
+  def g : SystemZTernaryConv<name#"g", llvm_v16i8_ty, llvm_v2i64_ty>;
 }
 
 multiclass SystemZTernaryBHF<string name> {
-  def b : SystemZTernary<name##"b", llvm_v16i8_ty>;
-  def h : SystemZTernary<name##"h", llvm_v8i16_ty>;
-  def f : SystemZTernary<name##"f", llvm_v4i32_ty>;
+  def b : SystemZTernary<name#"b", llvm_v16i8_ty>;
+  def h : SystemZTernary<name#"h", llvm_v8i16_ty>;
+  def f : SystemZTernary<name#"f", llvm_v4i32_ty>;
 }
 
 multiclass SystemZTernaryIntBHF<string name> {
-  def b : SystemZTernaryInt<name##"b", llvm_v16i8_ty>;
-  def h : SystemZTernaryInt<name##"h", llvm_v8i16_ty>;
-  def f : SystemZTernaryInt<name##"f", llvm_v4i32_ty>;
+  def b : SystemZTernaryInt<name#"b", llvm_v16i8_ty>;
+  def h : SystemZTernaryInt<name#"h", llvm_v8i16_ty>;
+  def f : SystemZTernaryInt<name#"f", llvm_v4i32_ty>;
 }
 
 multiclass SystemZTernaryIntCCBHF {
@@ -177,14 +180,14 @@
 }
 
 multiclass SystemZQuaternaryIntBHF<string name> {
-  def b : SystemZQuaternaryInt<name##"b", llvm_v16i8_ty>;
-  def h : SystemZQuaternaryInt<name##"h", llvm_v8i16_ty>;
-  def f : SystemZQuaternaryInt<name##"f", llvm_v4i32_ty>;
+  def b : SystemZQuaternaryInt<name#"b", llvm_v16i8_ty>;
+  def h : SystemZQuaternaryInt<name#"h", llvm_v8i16_ty>;
+  def f : SystemZQuaternaryInt<name#"f", llvm_v4i32_ty>;
 }
 
 multiclass SystemZQuaternaryIntBHFG<string name> :
   SystemZQuaternaryIntBHF<name> {
-  def g : SystemZQuaternaryInt<name##"g", llvm_v2i64_ty>;
+  def g : SystemZQuaternaryInt<name#"g", llvm_v2i64_ty>;
 }
 
 multiclass SystemZQuaternaryIntCCBHF {
@@ -235,11 +238,11 @@
 let TargetPrefix = "s390" in {
   def int_s390_lcbb : GCCBuiltin<"__builtin_s390_lcbb">,
                       Intrinsic<[llvm_i32_ty], [llvm_ptr_ty, llvm_i32_ty],
-                                [IntrNoMem, ImmArg<1>]>;
+                                [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 
   def int_s390_vlbb : GCCBuiltin<"__builtin_s390_vlbb">,
                       Intrinsic<[llvm_v16i8_ty], [llvm_ptr_ty, llvm_i32_ty],
-                                [IntrReadMem, IntrArgMemOnly, ImmArg<1>]>;
+                                [IntrReadMem, IntrArgMemOnly, ImmArg<ArgIndex<1>>]>;
 
   def int_s390_vll : GCCBuiltin<"__builtin_s390_vll">,
                      Intrinsic<[llvm_v16i8_ty], [llvm_i32_ty, llvm_ptr_ty],
@@ -248,7 +251,7 @@
   def int_s390_vpdi : GCCBuiltin<"__builtin_s390_vpdi">,
                       Intrinsic<[llvm_v2i64_ty],
                                 [llvm_v2i64_ty, llvm_v2i64_ty, llvm_i32_ty],
-                                [IntrNoMem, ImmArg<2>]>;
+                                [IntrNoMem, ImmArg<ArgIndex<2>>]>;
 
   def int_s390_vperm : GCCBuiltin<"__builtin_s390_vperm">,
                        Intrinsic<[llvm_v16i8_ty],
@@ -314,7 +317,7 @@
   def int_s390_vsldb : GCCBuiltin<"__builtin_s390_vsldb">,
                        Intrinsic<[llvm_v16i8_ty],
                                  [llvm_v16i8_ty, llvm_v16i8_ty, llvm_i32_ty],
-                                 [IntrNoMem, ImmArg<2>]>;
+                                 [IntrNoMem, ImmArg<ArgIndex<2>>]>;
 
   defm int_s390_vscbi : SystemZBinaryBHFG<"vscbi">;
 
@@ -373,7 +376,7 @@
 
   def int_s390_vfidb : Intrinsic<[llvm_v2f64_ty],
                                  [llvm_v2f64_ty, llvm_i32_ty, llvm_i32_ty],
-                                 [IntrNoMem, ImmArg<1>, ImmArg<2>]>;
+                                 [IntrNoMem, ImmArg<ArgIndex<1>>, ImmArg<ArgIndex<2>>]>;
 
   // Instructions from the Vector Enhancements Facility 1
   def int_s390_vbperm : SystemZBinaryConv<"vbperm", llvm_v2i64_ty,
@@ -382,20 +385,20 @@
   def int_s390_vmslg  : GCCBuiltin<"__builtin_s390_vmslg">,
                         Intrinsic<[llvm_v16i8_ty],
                                   [llvm_v2i64_ty, llvm_v2i64_ty, llvm_v16i8_ty,
-                                   llvm_i32_ty], [IntrNoMem, ImmArg<3>]>;
+                                   llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<3>>]>;
 
   def int_s390_vfmaxdb : Intrinsic<[llvm_v2f64_ty],
                                    [llvm_v2f64_ty, llvm_v2f64_ty, llvm_i32_ty],
-                                   [IntrNoMem, ImmArg<2>]>;
+                                   [IntrNoMem, ImmArg<ArgIndex<2>>]>;
   def int_s390_vfmindb : Intrinsic<[llvm_v2f64_ty],
                                    [llvm_v2f64_ty, llvm_v2f64_ty, llvm_i32_ty],
-                                   [IntrNoMem, ImmArg<2>]>;
+                                   [IntrNoMem, ImmArg<ArgIndex<2>>]>;
   def int_s390_vfmaxsb : Intrinsic<[llvm_v4f32_ty],
                                    [llvm_v4f32_ty, llvm_v4f32_ty, llvm_i32_ty],
-                                   [IntrNoMem, ImmArg<2>]>;
+                                   [IntrNoMem, ImmArg<ArgIndex<2>>]>;
   def int_s390_vfminsb : Intrinsic<[llvm_v4f32_ty],
                                    [llvm_v4f32_ty, llvm_v4f32_ty, llvm_i32_ty],
-                                   [IntrNoMem, ImmArg<2>]>;
+                                   [IntrNoMem, ImmArg<ArgIndex<2>>]>;
 
   def int_s390_vfcesbs  : SystemZBinaryConvCC<llvm_v4i32_ty, llvm_v4f32_ty>;
   def int_s390_vfchsbs  : SystemZBinaryConvCC<llvm_v4i32_ty, llvm_v4f32_ty>;
@@ -405,7 +408,7 @@
 
   def int_s390_vfisb : Intrinsic<[llvm_v4f32_ty],
                                  [llvm_v4f32_ty, llvm_i32_ty, llvm_i32_ty],
-                                 [IntrNoMem, ImmArg<1>, ImmArg<2>]>;
+                                 [IntrNoMem, ImmArg<ArgIndex<1>>, ImmArg<ArgIndex<2>>]>;
 
   // Instructions from the Vector Packed Decimal Facility
   def int_s390_vlrl : GCCBuiltin<"__builtin_s390_vlrl">,
@@ -415,6 +418,24 @@
   def int_s390_vstrl : GCCBuiltin<"__builtin_s390_vstrl">,
                        Intrinsic<[], [llvm_v16i8_ty, llvm_i32_ty, llvm_ptr_ty],
                                  [IntrArgMemOnly, IntrWriteMem]>;
+
+  // Instructions from the Vector Enhancements Facility 2
+  def int_s390_vsld : GCCBuiltin<"__builtin_s390_vsld">,
+                      Intrinsic<[llvm_v16i8_ty],
+                                [llvm_v16i8_ty, llvm_v16i8_ty, llvm_i32_ty],
+                                [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+  def int_s390_vsrd : GCCBuiltin<"__builtin_s390_vsrd">,
+                      Intrinsic<[llvm_v16i8_ty],
+                                [llvm_v16i8_ty, llvm_v16i8_ty, llvm_i32_ty],
+                                [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+
+  def int_s390_vstrsb : SystemZTernaryConvCC<llvm_v16i8_ty, llvm_v16i8_ty>;
+  def int_s390_vstrsh : SystemZTernaryConvCC<llvm_v16i8_ty, llvm_v8i16_ty>;
+  def int_s390_vstrsf : SystemZTernaryConvCC<llvm_v16i8_ty, llvm_v4i32_ty>;
+  def int_s390_vstrszb : SystemZTernaryConvCC<llvm_v16i8_ty, llvm_v16i8_ty>;
+  def int_s390_vstrszh : SystemZTernaryConvCC<llvm_v16i8_ty, llvm_v8i16_ty>;
+  def int_s390_vstrszf : SystemZTernaryConvCC<llvm_v16i8_ty, llvm_v4i32_ty>;
 }
 
 //===----------------------------------------------------------------------===//
diff --git a/linux-x64/clang/include/llvm/IR/IntrinsicsVE.h b/linux-x64/clang/include/llvm/IR/IntrinsicsVE.h
new file mode 100644
index 0000000..19ed527
--- /dev/null
+++ b/linux-x64/clang/include/llvm/IR/IntrinsicsVE.h
@@ -0,0 +1,1240 @@
+/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
+|*                                                                            *|
+|* Intrinsic Function Source Fragment                                         *|
+|*                                                                            *|
+|* Automatically generated file, do not edit!                                 *|
+|*                                                                            *|
+\*===----------------------------------------------------------------------===*/
+
+#ifndef LLVM_IR_INTRINSIC_VE_ENUMS_H
+#define LLVM_IR_INTRINSIC_VE_ENUMS_H
+
+namespace llvm {
+namespace Intrinsic {
+enum VEIntrinsics : unsigned {
+// Enum values for intrinsics
+    ve_vl_andm_MMM = 7215,                            // llvm.ve.vl.andm.MMM
+    ve_vl_andm_mmm,                            // llvm.ve.vl.andm.mmm
+    ve_vl_eqvm_MMM,                            // llvm.ve.vl.eqvm.MMM
+    ve_vl_eqvm_mmm,                            // llvm.ve.vl.eqvm.mmm
+    ve_vl_extract_vm512l,                      // llvm.ve.vl.extract.vm512l
+    ve_vl_extract_vm512u,                      // llvm.ve.vl.extract.vm512u
+    ve_vl_insert_vm512l,                       // llvm.ve.vl.insert.vm512l
+    ve_vl_insert_vm512u,                       // llvm.ve.vl.insert.vm512u
+    ve_vl_lsv_vvss,                            // llvm.ve.vl.lsv.vvss
+    ve_vl_lvm_MMss,                            // llvm.ve.vl.lvm.MMss
+    ve_vl_lvm_mmss,                            // llvm.ve.vl.lvm.mmss
+    ve_vl_lvsd_svs,                            // llvm.ve.vl.lvsd.svs
+    ve_vl_lvsl_svs,                            // llvm.ve.vl.lvsl.svs
+    ve_vl_lvss_svs,                            // llvm.ve.vl.lvss.svs
+    ve_vl_lzvm_sml,                            // llvm.ve.vl.lzvm.sml
+    ve_vl_negm_MM,                             // llvm.ve.vl.negm.MM
+    ve_vl_negm_mm,                             // llvm.ve.vl.negm.mm
+    ve_vl_nndm_MMM,                            // llvm.ve.vl.nndm.MMM
+    ve_vl_nndm_mmm,                            // llvm.ve.vl.nndm.mmm
+    ve_vl_orm_MMM,                             // llvm.ve.vl.orm.MMM
+    ve_vl_orm_mmm,                             // llvm.ve.vl.orm.mmm
+    ve_vl_pack_f32a,                           // llvm.ve.vl.pack.f32a
+    ve_vl_pack_f32p,                           // llvm.ve.vl.pack.f32p
+    ve_vl_pcvm_sml,                            // llvm.ve.vl.pcvm.sml
+    ve_vl_pfchv_ssl,                           // llvm.ve.vl.pfchv.ssl
+    ve_vl_pfchvnc_ssl,                         // llvm.ve.vl.pfchvnc.ssl
+    ve_vl_pvadds_vsvMvl,                       // llvm.ve.vl.pvadds.vsvMvl
+    ve_vl_pvadds_vsvl,                         // llvm.ve.vl.pvadds.vsvl
+    ve_vl_pvadds_vsvvl,                        // llvm.ve.vl.pvadds.vsvvl
+    ve_vl_pvadds_vvvMvl,                       // llvm.ve.vl.pvadds.vvvMvl
+    ve_vl_pvadds_vvvl,                         // llvm.ve.vl.pvadds.vvvl
+    ve_vl_pvadds_vvvvl,                        // llvm.ve.vl.pvadds.vvvvl
+    ve_vl_pvaddu_vsvMvl,                       // llvm.ve.vl.pvaddu.vsvMvl
+    ve_vl_pvaddu_vsvl,                         // llvm.ve.vl.pvaddu.vsvl
+    ve_vl_pvaddu_vsvvl,                        // llvm.ve.vl.pvaddu.vsvvl
+    ve_vl_pvaddu_vvvMvl,                       // llvm.ve.vl.pvaddu.vvvMvl
+    ve_vl_pvaddu_vvvl,                         // llvm.ve.vl.pvaddu.vvvl
+    ve_vl_pvaddu_vvvvl,                        // llvm.ve.vl.pvaddu.vvvvl
+    ve_vl_pvand_vsvMvl,                        // llvm.ve.vl.pvand.vsvMvl
+    ve_vl_pvand_vsvl,                          // llvm.ve.vl.pvand.vsvl
+    ve_vl_pvand_vsvvl,                         // llvm.ve.vl.pvand.vsvvl
+    ve_vl_pvand_vvvMvl,                        // llvm.ve.vl.pvand.vvvMvl
+    ve_vl_pvand_vvvl,                          // llvm.ve.vl.pvand.vvvl
+    ve_vl_pvand_vvvvl,                         // llvm.ve.vl.pvand.vvvvl
+    ve_vl_pvbrd_vsMvl,                         // llvm.ve.vl.pvbrd.vsMvl
+    ve_vl_pvbrd_vsl,                           // llvm.ve.vl.pvbrd.vsl
+    ve_vl_pvbrd_vsvl,                          // llvm.ve.vl.pvbrd.vsvl
+    ve_vl_pvcmps_vsvMvl,                       // llvm.ve.vl.pvcmps.vsvMvl
+    ve_vl_pvcmps_vsvl,                         // llvm.ve.vl.pvcmps.vsvl
+    ve_vl_pvcmps_vsvvl,                        // llvm.ve.vl.pvcmps.vsvvl
+    ve_vl_pvcmps_vvvMvl,                       // llvm.ve.vl.pvcmps.vvvMvl
+    ve_vl_pvcmps_vvvl,                         // llvm.ve.vl.pvcmps.vvvl
+    ve_vl_pvcmps_vvvvl,                        // llvm.ve.vl.pvcmps.vvvvl
+    ve_vl_pvcmpu_vsvMvl,                       // llvm.ve.vl.pvcmpu.vsvMvl
+    ve_vl_pvcmpu_vsvl,                         // llvm.ve.vl.pvcmpu.vsvl
+    ve_vl_pvcmpu_vsvvl,                        // llvm.ve.vl.pvcmpu.vsvvl
+    ve_vl_pvcmpu_vvvMvl,                       // llvm.ve.vl.pvcmpu.vvvMvl
+    ve_vl_pvcmpu_vvvl,                         // llvm.ve.vl.pvcmpu.vvvl
+    ve_vl_pvcmpu_vvvvl,                        // llvm.ve.vl.pvcmpu.vvvvl
+    ve_vl_pvcvtsw_vvl,                         // llvm.ve.vl.pvcvtsw.vvl
+    ve_vl_pvcvtsw_vvvl,                        // llvm.ve.vl.pvcvtsw.vvvl
+    ve_vl_pvcvtws_vvMvl,                       // llvm.ve.vl.pvcvtws.vvMvl
+    ve_vl_pvcvtws_vvl,                         // llvm.ve.vl.pvcvtws.vvl
+    ve_vl_pvcvtws_vvvl,                        // llvm.ve.vl.pvcvtws.vvvl
+    ve_vl_pvcvtwsrz_vvMvl,                     // llvm.ve.vl.pvcvtwsrz.vvMvl
+    ve_vl_pvcvtwsrz_vvl,                       // llvm.ve.vl.pvcvtwsrz.vvl
+    ve_vl_pvcvtwsrz_vvvl,                      // llvm.ve.vl.pvcvtwsrz.vvvl
+    ve_vl_pveqv_vsvMvl,                        // llvm.ve.vl.pveqv.vsvMvl
+    ve_vl_pveqv_vsvl,                          // llvm.ve.vl.pveqv.vsvl
+    ve_vl_pveqv_vsvvl,                         // llvm.ve.vl.pveqv.vsvvl
+    ve_vl_pveqv_vvvMvl,                        // llvm.ve.vl.pveqv.vvvMvl
+    ve_vl_pveqv_vvvl,                          // llvm.ve.vl.pveqv.vvvl
+    ve_vl_pveqv_vvvvl,                         // llvm.ve.vl.pveqv.vvvvl
+    ve_vl_pvfadd_vsvMvl,                       // llvm.ve.vl.pvfadd.vsvMvl
+    ve_vl_pvfadd_vsvl,                         // llvm.ve.vl.pvfadd.vsvl
+    ve_vl_pvfadd_vsvvl,                        // llvm.ve.vl.pvfadd.vsvvl
+    ve_vl_pvfadd_vvvMvl,                       // llvm.ve.vl.pvfadd.vvvMvl
+    ve_vl_pvfadd_vvvl,                         // llvm.ve.vl.pvfadd.vvvl
+    ve_vl_pvfadd_vvvvl,                        // llvm.ve.vl.pvfadd.vvvvl
+    ve_vl_pvfcmp_vsvMvl,                       // llvm.ve.vl.pvfcmp.vsvMvl
+    ve_vl_pvfcmp_vsvl,                         // llvm.ve.vl.pvfcmp.vsvl
+    ve_vl_pvfcmp_vsvvl,                        // llvm.ve.vl.pvfcmp.vsvvl
+    ve_vl_pvfcmp_vvvMvl,                       // llvm.ve.vl.pvfcmp.vvvMvl
+    ve_vl_pvfcmp_vvvl,                         // llvm.ve.vl.pvfcmp.vvvl
+    ve_vl_pvfcmp_vvvvl,                        // llvm.ve.vl.pvfcmp.vvvvl
+    ve_vl_pvfmad_vsvvMvl,                      // llvm.ve.vl.pvfmad.vsvvMvl
+    ve_vl_pvfmad_vsvvl,                        // llvm.ve.vl.pvfmad.vsvvl
+    ve_vl_pvfmad_vsvvvl,                       // llvm.ve.vl.pvfmad.vsvvvl
+    ve_vl_pvfmad_vvsvMvl,                      // llvm.ve.vl.pvfmad.vvsvMvl
+    ve_vl_pvfmad_vvsvl,                        // llvm.ve.vl.pvfmad.vvsvl
+    ve_vl_pvfmad_vvsvvl,                       // llvm.ve.vl.pvfmad.vvsvvl
+    ve_vl_pvfmad_vvvvMvl,                      // llvm.ve.vl.pvfmad.vvvvMvl
+    ve_vl_pvfmad_vvvvl,                        // llvm.ve.vl.pvfmad.vvvvl
+    ve_vl_pvfmad_vvvvvl,                       // llvm.ve.vl.pvfmad.vvvvvl
+    ve_vl_pvfmax_vsvMvl,                       // llvm.ve.vl.pvfmax.vsvMvl
+    ve_vl_pvfmax_vsvl,                         // llvm.ve.vl.pvfmax.vsvl
+    ve_vl_pvfmax_vsvvl,                        // llvm.ve.vl.pvfmax.vsvvl
+    ve_vl_pvfmax_vvvMvl,                       // llvm.ve.vl.pvfmax.vvvMvl
+    ve_vl_pvfmax_vvvl,                         // llvm.ve.vl.pvfmax.vvvl
+    ve_vl_pvfmax_vvvvl,                        // llvm.ve.vl.pvfmax.vvvvl
+    ve_vl_pvfmin_vsvMvl,                       // llvm.ve.vl.pvfmin.vsvMvl
+    ve_vl_pvfmin_vsvl,                         // llvm.ve.vl.pvfmin.vsvl
+    ve_vl_pvfmin_vsvvl,                        // llvm.ve.vl.pvfmin.vsvvl
+    ve_vl_pvfmin_vvvMvl,                       // llvm.ve.vl.pvfmin.vvvMvl
+    ve_vl_pvfmin_vvvl,                         // llvm.ve.vl.pvfmin.vvvl
+    ve_vl_pvfmin_vvvvl,                        // llvm.ve.vl.pvfmin.vvvvl
+    ve_vl_pvfmkaf_Ml,                          // llvm.ve.vl.pvfmkaf.Ml
+    ve_vl_pvfmkat_Ml,                          // llvm.ve.vl.pvfmkat.Ml
+    ve_vl_pvfmkseq_MvMl,                       // llvm.ve.vl.pvfmkseq.MvMl
+    ve_vl_pvfmkseq_Mvl,                        // llvm.ve.vl.pvfmkseq.Mvl
+    ve_vl_pvfmkseqnan_MvMl,                    // llvm.ve.vl.pvfmkseqnan.MvMl
+    ve_vl_pvfmkseqnan_Mvl,                     // llvm.ve.vl.pvfmkseqnan.Mvl
+    ve_vl_pvfmksge_MvMl,                       // llvm.ve.vl.pvfmksge.MvMl
+    ve_vl_pvfmksge_Mvl,                        // llvm.ve.vl.pvfmksge.Mvl
+    ve_vl_pvfmksgenan_MvMl,                    // llvm.ve.vl.pvfmksgenan.MvMl
+    ve_vl_pvfmksgenan_Mvl,                     // llvm.ve.vl.pvfmksgenan.Mvl
+    ve_vl_pvfmksgt_MvMl,                       // llvm.ve.vl.pvfmksgt.MvMl
+    ve_vl_pvfmksgt_Mvl,                        // llvm.ve.vl.pvfmksgt.Mvl
+    ve_vl_pvfmksgtnan_MvMl,                    // llvm.ve.vl.pvfmksgtnan.MvMl
+    ve_vl_pvfmksgtnan_Mvl,                     // llvm.ve.vl.pvfmksgtnan.Mvl
+    ve_vl_pvfmksle_MvMl,                       // llvm.ve.vl.pvfmksle.MvMl
+    ve_vl_pvfmksle_Mvl,                        // llvm.ve.vl.pvfmksle.Mvl
+    ve_vl_pvfmkslenan_MvMl,                    // llvm.ve.vl.pvfmkslenan.MvMl
+    ve_vl_pvfmkslenan_Mvl,                     // llvm.ve.vl.pvfmkslenan.Mvl
+    ve_vl_pvfmksloeq_mvl,                      // llvm.ve.vl.pvfmksloeq.mvl
+    ve_vl_pvfmksloeq_mvml,                     // llvm.ve.vl.pvfmksloeq.mvml
+    ve_vl_pvfmksloeqnan_mvl,                   // llvm.ve.vl.pvfmksloeqnan.mvl
+    ve_vl_pvfmksloeqnan_mvml,                  // llvm.ve.vl.pvfmksloeqnan.mvml
+    ve_vl_pvfmksloge_mvl,                      // llvm.ve.vl.pvfmksloge.mvl
+    ve_vl_pvfmksloge_mvml,                     // llvm.ve.vl.pvfmksloge.mvml
+    ve_vl_pvfmkslogenan_mvl,                   // llvm.ve.vl.pvfmkslogenan.mvl
+    ve_vl_pvfmkslogenan_mvml,                  // llvm.ve.vl.pvfmkslogenan.mvml
+    ve_vl_pvfmkslogt_mvl,                      // llvm.ve.vl.pvfmkslogt.mvl
+    ve_vl_pvfmkslogt_mvml,                     // llvm.ve.vl.pvfmkslogt.mvml
+    ve_vl_pvfmkslogtnan_mvl,                   // llvm.ve.vl.pvfmkslogtnan.mvl
+    ve_vl_pvfmkslogtnan_mvml,                  // llvm.ve.vl.pvfmkslogtnan.mvml
+    ve_vl_pvfmkslole_mvl,                      // llvm.ve.vl.pvfmkslole.mvl
+    ve_vl_pvfmkslole_mvml,                     // llvm.ve.vl.pvfmkslole.mvml
+    ve_vl_pvfmkslolenan_mvl,                   // llvm.ve.vl.pvfmkslolenan.mvl
+    ve_vl_pvfmkslolenan_mvml,                  // llvm.ve.vl.pvfmkslolenan.mvml
+    ve_vl_pvfmkslolt_mvl,                      // llvm.ve.vl.pvfmkslolt.mvl
+    ve_vl_pvfmkslolt_mvml,                     // llvm.ve.vl.pvfmkslolt.mvml
+    ve_vl_pvfmksloltnan_mvl,                   // llvm.ve.vl.pvfmksloltnan.mvl
+    ve_vl_pvfmksloltnan_mvml,                  // llvm.ve.vl.pvfmksloltnan.mvml
+    ve_vl_pvfmkslonan_mvl,                     // llvm.ve.vl.pvfmkslonan.mvl
+    ve_vl_pvfmkslonan_mvml,                    // llvm.ve.vl.pvfmkslonan.mvml
+    ve_vl_pvfmkslone_mvl,                      // llvm.ve.vl.pvfmkslone.mvl
+    ve_vl_pvfmkslone_mvml,                     // llvm.ve.vl.pvfmkslone.mvml
+    ve_vl_pvfmkslonenan_mvl,                   // llvm.ve.vl.pvfmkslonenan.mvl
+    ve_vl_pvfmkslonenan_mvml,                  // llvm.ve.vl.pvfmkslonenan.mvml
+    ve_vl_pvfmkslonum_mvl,                     // llvm.ve.vl.pvfmkslonum.mvl
+    ve_vl_pvfmkslonum_mvml,                    // llvm.ve.vl.pvfmkslonum.mvml
+    ve_vl_pvfmkslt_MvMl,                       // llvm.ve.vl.pvfmkslt.MvMl
+    ve_vl_pvfmkslt_Mvl,                        // llvm.ve.vl.pvfmkslt.Mvl
+    ve_vl_pvfmksltnan_MvMl,                    // llvm.ve.vl.pvfmksltnan.MvMl
+    ve_vl_pvfmksltnan_Mvl,                     // llvm.ve.vl.pvfmksltnan.Mvl
+    ve_vl_pvfmksnan_MvMl,                      // llvm.ve.vl.pvfmksnan.MvMl
+    ve_vl_pvfmksnan_Mvl,                       // llvm.ve.vl.pvfmksnan.Mvl
+    ve_vl_pvfmksne_MvMl,                       // llvm.ve.vl.pvfmksne.MvMl
+    ve_vl_pvfmksne_Mvl,                        // llvm.ve.vl.pvfmksne.Mvl
+    ve_vl_pvfmksnenan_MvMl,                    // llvm.ve.vl.pvfmksnenan.MvMl
+    ve_vl_pvfmksnenan_Mvl,                     // llvm.ve.vl.pvfmksnenan.Mvl
+    ve_vl_pvfmksnum_MvMl,                      // llvm.ve.vl.pvfmksnum.MvMl
+    ve_vl_pvfmksnum_Mvl,                       // llvm.ve.vl.pvfmksnum.Mvl
+    ve_vl_pvfmksupeq_mvl,                      // llvm.ve.vl.pvfmksupeq.mvl
+    ve_vl_pvfmksupeq_mvml,                     // llvm.ve.vl.pvfmksupeq.mvml
+    ve_vl_pvfmksupeqnan_mvl,                   // llvm.ve.vl.pvfmksupeqnan.mvl
+    ve_vl_pvfmksupeqnan_mvml,                  // llvm.ve.vl.pvfmksupeqnan.mvml
+    ve_vl_pvfmksupge_mvl,                      // llvm.ve.vl.pvfmksupge.mvl
+    ve_vl_pvfmksupge_mvml,                     // llvm.ve.vl.pvfmksupge.mvml
+    ve_vl_pvfmksupgenan_mvl,                   // llvm.ve.vl.pvfmksupgenan.mvl
+    ve_vl_pvfmksupgenan_mvml,                  // llvm.ve.vl.pvfmksupgenan.mvml
+    ve_vl_pvfmksupgt_mvl,                      // llvm.ve.vl.pvfmksupgt.mvl
+    ve_vl_pvfmksupgt_mvml,                     // llvm.ve.vl.pvfmksupgt.mvml
+    ve_vl_pvfmksupgtnan_mvl,                   // llvm.ve.vl.pvfmksupgtnan.mvl
+    ve_vl_pvfmksupgtnan_mvml,                  // llvm.ve.vl.pvfmksupgtnan.mvml
+    ve_vl_pvfmksuple_mvl,                      // llvm.ve.vl.pvfmksuple.mvl
+    ve_vl_pvfmksuple_mvml,                     // llvm.ve.vl.pvfmksuple.mvml
+    ve_vl_pvfmksuplenan_mvl,                   // llvm.ve.vl.pvfmksuplenan.mvl
+    ve_vl_pvfmksuplenan_mvml,                  // llvm.ve.vl.pvfmksuplenan.mvml
+    ve_vl_pvfmksuplt_mvl,                      // llvm.ve.vl.pvfmksuplt.mvl
+    ve_vl_pvfmksuplt_mvml,                     // llvm.ve.vl.pvfmksuplt.mvml
+    ve_vl_pvfmksupltnan_mvl,                   // llvm.ve.vl.pvfmksupltnan.mvl
+    ve_vl_pvfmksupltnan_mvml,                  // llvm.ve.vl.pvfmksupltnan.mvml
+    ve_vl_pvfmksupnan_mvl,                     // llvm.ve.vl.pvfmksupnan.mvl
+    ve_vl_pvfmksupnan_mvml,                    // llvm.ve.vl.pvfmksupnan.mvml
+    ve_vl_pvfmksupne_mvl,                      // llvm.ve.vl.pvfmksupne.mvl
+    ve_vl_pvfmksupne_mvml,                     // llvm.ve.vl.pvfmksupne.mvml
+    ve_vl_pvfmksupnenan_mvl,                   // llvm.ve.vl.pvfmksupnenan.mvl
+    ve_vl_pvfmksupnenan_mvml,                  // llvm.ve.vl.pvfmksupnenan.mvml
+    ve_vl_pvfmksupnum_mvl,                     // llvm.ve.vl.pvfmksupnum.mvl
+    ve_vl_pvfmksupnum_mvml,                    // llvm.ve.vl.pvfmksupnum.mvml
+    ve_vl_pvfmkweq_MvMl,                       // llvm.ve.vl.pvfmkweq.MvMl
+    ve_vl_pvfmkweq_Mvl,                        // llvm.ve.vl.pvfmkweq.Mvl
+    ve_vl_pvfmkweqnan_MvMl,                    // llvm.ve.vl.pvfmkweqnan.MvMl
+    ve_vl_pvfmkweqnan_Mvl,                     // llvm.ve.vl.pvfmkweqnan.Mvl
+    ve_vl_pvfmkwge_MvMl,                       // llvm.ve.vl.pvfmkwge.MvMl
+    ve_vl_pvfmkwge_Mvl,                        // llvm.ve.vl.pvfmkwge.Mvl
+    ve_vl_pvfmkwgenan_MvMl,                    // llvm.ve.vl.pvfmkwgenan.MvMl
+    ve_vl_pvfmkwgenan_Mvl,                     // llvm.ve.vl.pvfmkwgenan.Mvl
+    ve_vl_pvfmkwgt_MvMl,                       // llvm.ve.vl.pvfmkwgt.MvMl
+    ve_vl_pvfmkwgt_Mvl,                        // llvm.ve.vl.pvfmkwgt.Mvl
+    ve_vl_pvfmkwgtnan_MvMl,                    // llvm.ve.vl.pvfmkwgtnan.MvMl
+    ve_vl_pvfmkwgtnan_Mvl,                     // llvm.ve.vl.pvfmkwgtnan.Mvl
+    ve_vl_pvfmkwle_MvMl,                       // llvm.ve.vl.pvfmkwle.MvMl
+    ve_vl_pvfmkwle_Mvl,                        // llvm.ve.vl.pvfmkwle.Mvl
+    ve_vl_pvfmkwlenan_MvMl,                    // llvm.ve.vl.pvfmkwlenan.MvMl
+    ve_vl_pvfmkwlenan_Mvl,                     // llvm.ve.vl.pvfmkwlenan.Mvl
+    ve_vl_pvfmkwloeq_mvl,                      // llvm.ve.vl.pvfmkwloeq.mvl
+    ve_vl_pvfmkwloeq_mvml,                     // llvm.ve.vl.pvfmkwloeq.mvml
+    ve_vl_pvfmkwloeqnan_mvl,                   // llvm.ve.vl.pvfmkwloeqnan.mvl
+    ve_vl_pvfmkwloeqnan_mvml,                  // llvm.ve.vl.pvfmkwloeqnan.mvml
+    ve_vl_pvfmkwloge_mvl,                      // llvm.ve.vl.pvfmkwloge.mvl
+    ve_vl_pvfmkwloge_mvml,                     // llvm.ve.vl.pvfmkwloge.mvml
+    ve_vl_pvfmkwlogenan_mvl,                   // llvm.ve.vl.pvfmkwlogenan.mvl
+    ve_vl_pvfmkwlogenan_mvml,                  // llvm.ve.vl.pvfmkwlogenan.mvml
+    ve_vl_pvfmkwlogt_mvl,                      // llvm.ve.vl.pvfmkwlogt.mvl
+    ve_vl_pvfmkwlogt_mvml,                     // llvm.ve.vl.pvfmkwlogt.mvml
+    ve_vl_pvfmkwlogtnan_mvl,                   // llvm.ve.vl.pvfmkwlogtnan.mvl
+    ve_vl_pvfmkwlogtnan_mvml,                  // llvm.ve.vl.pvfmkwlogtnan.mvml
+    ve_vl_pvfmkwlole_mvl,                      // llvm.ve.vl.pvfmkwlole.mvl
+    ve_vl_pvfmkwlole_mvml,                     // llvm.ve.vl.pvfmkwlole.mvml
+    ve_vl_pvfmkwlolenan_mvl,                   // llvm.ve.vl.pvfmkwlolenan.mvl
+    ve_vl_pvfmkwlolenan_mvml,                  // llvm.ve.vl.pvfmkwlolenan.mvml
+    ve_vl_pvfmkwlolt_mvl,                      // llvm.ve.vl.pvfmkwlolt.mvl
+    ve_vl_pvfmkwlolt_mvml,                     // llvm.ve.vl.pvfmkwlolt.mvml
+    ve_vl_pvfmkwloltnan_mvl,                   // llvm.ve.vl.pvfmkwloltnan.mvl
+    ve_vl_pvfmkwloltnan_mvml,                  // llvm.ve.vl.pvfmkwloltnan.mvml
+    ve_vl_pvfmkwlonan_mvl,                     // llvm.ve.vl.pvfmkwlonan.mvl
+    ve_vl_pvfmkwlonan_mvml,                    // llvm.ve.vl.pvfmkwlonan.mvml
+    ve_vl_pvfmkwlone_mvl,                      // llvm.ve.vl.pvfmkwlone.mvl
+    ve_vl_pvfmkwlone_mvml,                     // llvm.ve.vl.pvfmkwlone.mvml
+    ve_vl_pvfmkwlonenan_mvl,                   // llvm.ve.vl.pvfmkwlonenan.mvl
+    ve_vl_pvfmkwlonenan_mvml,                  // llvm.ve.vl.pvfmkwlonenan.mvml
+    ve_vl_pvfmkwlonum_mvl,                     // llvm.ve.vl.pvfmkwlonum.mvl
+    ve_vl_pvfmkwlonum_mvml,                    // llvm.ve.vl.pvfmkwlonum.mvml
+    ve_vl_pvfmkwlt_MvMl,                       // llvm.ve.vl.pvfmkwlt.MvMl
+    ve_vl_pvfmkwlt_Mvl,                        // llvm.ve.vl.pvfmkwlt.Mvl
+    ve_vl_pvfmkwltnan_MvMl,                    // llvm.ve.vl.pvfmkwltnan.MvMl
+    ve_vl_pvfmkwltnan_Mvl,                     // llvm.ve.vl.pvfmkwltnan.Mvl
+    ve_vl_pvfmkwnan_MvMl,                      // llvm.ve.vl.pvfmkwnan.MvMl
+    ve_vl_pvfmkwnan_Mvl,                       // llvm.ve.vl.pvfmkwnan.Mvl
+    ve_vl_pvfmkwne_MvMl,                       // llvm.ve.vl.pvfmkwne.MvMl
+    ve_vl_pvfmkwne_Mvl,                        // llvm.ve.vl.pvfmkwne.Mvl
+    ve_vl_pvfmkwnenan_MvMl,                    // llvm.ve.vl.pvfmkwnenan.MvMl
+    ve_vl_pvfmkwnenan_Mvl,                     // llvm.ve.vl.pvfmkwnenan.Mvl
+    ve_vl_pvfmkwnum_MvMl,                      // llvm.ve.vl.pvfmkwnum.MvMl
+    ve_vl_pvfmkwnum_Mvl,                       // llvm.ve.vl.pvfmkwnum.Mvl
+    ve_vl_pvfmkwupeq_mvl,                      // llvm.ve.vl.pvfmkwupeq.mvl
+    ve_vl_pvfmkwupeq_mvml,                     // llvm.ve.vl.pvfmkwupeq.mvml
+    ve_vl_pvfmkwupeqnan_mvl,                   // llvm.ve.vl.pvfmkwupeqnan.mvl
+    ve_vl_pvfmkwupeqnan_mvml,                  // llvm.ve.vl.pvfmkwupeqnan.mvml
+    ve_vl_pvfmkwupge_mvl,                      // llvm.ve.vl.pvfmkwupge.mvl
+    ve_vl_pvfmkwupge_mvml,                     // llvm.ve.vl.pvfmkwupge.mvml
+    ve_vl_pvfmkwupgenan_mvl,                   // llvm.ve.vl.pvfmkwupgenan.mvl
+    ve_vl_pvfmkwupgenan_mvml,                  // llvm.ve.vl.pvfmkwupgenan.mvml
+    ve_vl_pvfmkwupgt_mvl,                      // llvm.ve.vl.pvfmkwupgt.mvl
+    ve_vl_pvfmkwupgt_mvml,                     // llvm.ve.vl.pvfmkwupgt.mvml
+    ve_vl_pvfmkwupgtnan_mvl,                   // llvm.ve.vl.pvfmkwupgtnan.mvl
+    ve_vl_pvfmkwupgtnan_mvml,                  // llvm.ve.vl.pvfmkwupgtnan.mvml
+    ve_vl_pvfmkwuple_mvl,                      // llvm.ve.vl.pvfmkwuple.mvl
+    ve_vl_pvfmkwuple_mvml,                     // llvm.ve.vl.pvfmkwuple.mvml
+    ve_vl_pvfmkwuplenan_mvl,                   // llvm.ve.vl.pvfmkwuplenan.mvl
+    ve_vl_pvfmkwuplenan_mvml,                  // llvm.ve.vl.pvfmkwuplenan.mvml
+    ve_vl_pvfmkwuplt_mvl,                      // llvm.ve.vl.pvfmkwuplt.mvl
+    ve_vl_pvfmkwuplt_mvml,                     // llvm.ve.vl.pvfmkwuplt.mvml
+    ve_vl_pvfmkwupltnan_mvl,                   // llvm.ve.vl.pvfmkwupltnan.mvl
+    ve_vl_pvfmkwupltnan_mvml,                  // llvm.ve.vl.pvfmkwupltnan.mvml
+    ve_vl_pvfmkwupnan_mvl,                     // llvm.ve.vl.pvfmkwupnan.mvl
+    ve_vl_pvfmkwupnan_mvml,                    // llvm.ve.vl.pvfmkwupnan.mvml
+    ve_vl_pvfmkwupne_mvl,                      // llvm.ve.vl.pvfmkwupne.mvl
+    ve_vl_pvfmkwupne_mvml,                     // llvm.ve.vl.pvfmkwupne.mvml
+    ve_vl_pvfmkwupnenan_mvl,                   // llvm.ve.vl.pvfmkwupnenan.mvl
+    ve_vl_pvfmkwupnenan_mvml,                  // llvm.ve.vl.pvfmkwupnenan.mvml
+    ve_vl_pvfmkwupnum_mvl,                     // llvm.ve.vl.pvfmkwupnum.mvl
+    ve_vl_pvfmkwupnum_mvml,                    // llvm.ve.vl.pvfmkwupnum.mvml
+    ve_vl_pvfmsb_vsvvMvl,                      // llvm.ve.vl.pvfmsb.vsvvMvl
+    ve_vl_pvfmsb_vsvvl,                        // llvm.ve.vl.pvfmsb.vsvvl
+    ve_vl_pvfmsb_vsvvvl,                       // llvm.ve.vl.pvfmsb.vsvvvl
+    ve_vl_pvfmsb_vvsvMvl,                      // llvm.ve.vl.pvfmsb.vvsvMvl
+    ve_vl_pvfmsb_vvsvl,                        // llvm.ve.vl.pvfmsb.vvsvl
+    ve_vl_pvfmsb_vvsvvl,                       // llvm.ve.vl.pvfmsb.vvsvvl
+    ve_vl_pvfmsb_vvvvMvl,                      // llvm.ve.vl.pvfmsb.vvvvMvl
+    ve_vl_pvfmsb_vvvvl,                        // llvm.ve.vl.pvfmsb.vvvvl
+    ve_vl_pvfmsb_vvvvvl,                       // llvm.ve.vl.pvfmsb.vvvvvl
+    ve_vl_pvfmul_vsvMvl,                       // llvm.ve.vl.pvfmul.vsvMvl
+    ve_vl_pvfmul_vsvl,                         // llvm.ve.vl.pvfmul.vsvl
+    ve_vl_pvfmul_vsvvl,                        // llvm.ve.vl.pvfmul.vsvvl
+    ve_vl_pvfmul_vvvMvl,                       // llvm.ve.vl.pvfmul.vvvMvl
+    ve_vl_pvfmul_vvvl,                         // llvm.ve.vl.pvfmul.vvvl
+    ve_vl_pvfmul_vvvvl,                        // llvm.ve.vl.pvfmul.vvvvl
+    ve_vl_pvfnmad_vsvvMvl,                     // llvm.ve.vl.pvfnmad.vsvvMvl
+    ve_vl_pvfnmad_vsvvl,                       // llvm.ve.vl.pvfnmad.vsvvl
+    ve_vl_pvfnmad_vsvvvl,                      // llvm.ve.vl.pvfnmad.vsvvvl
+    ve_vl_pvfnmad_vvsvMvl,                     // llvm.ve.vl.pvfnmad.vvsvMvl
+    ve_vl_pvfnmad_vvsvl,                       // llvm.ve.vl.pvfnmad.vvsvl
+    ve_vl_pvfnmad_vvsvvl,                      // llvm.ve.vl.pvfnmad.vvsvvl
+    ve_vl_pvfnmad_vvvvMvl,                     // llvm.ve.vl.pvfnmad.vvvvMvl
+    ve_vl_pvfnmad_vvvvl,                       // llvm.ve.vl.pvfnmad.vvvvl
+    ve_vl_pvfnmad_vvvvvl,                      // llvm.ve.vl.pvfnmad.vvvvvl
+    ve_vl_pvfnmsb_vsvvMvl,                     // llvm.ve.vl.pvfnmsb.vsvvMvl
+    ve_vl_pvfnmsb_vsvvl,                       // llvm.ve.vl.pvfnmsb.vsvvl
+    ve_vl_pvfnmsb_vsvvvl,                      // llvm.ve.vl.pvfnmsb.vsvvvl
+    ve_vl_pvfnmsb_vvsvMvl,                     // llvm.ve.vl.pvfnmsb.vvsvMvl
+    ve_vl_pvfnmsb_vvsvl,                       // llvm.ve.vl.pvfnmsb.vvsvl
+    ve_vl_pvfnmsb_vvsvvl,                      // llvm.ve.vl.pvfnmsb.vvsvvl
+    ve_vl_pvfnmsb_vvvvMvl,                     // llvm.ve.vl.pvfnmsb.vvvvMvl
+    ve_vl_pvfnmsb_vvvvl,                       // llvm.ve.vl.pvfnmsb.vvvvl
+    ve_vl_pvfnmsb_vvvvvl,                      // llvm.ve.vl.pvfnmsb.vvvvvl
+    ve_vl_pvfsub_vsvMvl,                       // llvm.ve.vl.pvfsub.vsvMvl
+    ve_vl_pvfsub_vsvl,                         // llvm.ve.vl.pvfsub.vsvl
+    ve_vl_pvfsub_vsvvl,                        // llvm.ve.vl.pvfsub.vsvvl
+    ve_vl_pvfsub_vvvMvl,                       // llvm.ve.vl.pvfsub.vvvMvl
+    ve_vl_pvfsub_vvvl,                         // llvm.ve.vl.pvfsub.vvvl
+    ve_vl_pvfsub_vvvvl,                        // llvm.ve.vl.pvfsub.vvvvl
+    ve_vl_pvmaxs_vsvMvl,                       // llvm.ve.vl.pvmaxs.vsvMvl
+    ve_vl_pvmaxs_vsvl,                         // llvm.ve.vl.pvmaxs.vsvl
+    ve_vl_pvmaxs_vsvvl,                        // llvm.ve.vl.pvmaxs.vsvvl
+    ve_vl_pvmaxs_vvvMvl,                       // llvm.ve.vl.pvmaxs.vvvMvl
+    ve_vl_pvmaxs_vvvl,                         // llvm.ve.vl.pvmaxs.vvvl
+    ve_vl_pvmaxs_vvvvl,                        // llvm.ve.vl.pvmaxs.vvvvl
+    ve_vl_pvmins_vsvMvl,                       // llvm.ve.vl.pvmins.vsvMvl
+    ve_vl_pvmins_vsvl,                         // llvm.ve.vl.pvmins.vsvl
+    ve_vl_pvmins_vsvvl,                        // llvm.ve.vl.pvmins.vsvvl
+    ve_vl_pvmins_vvvMvl,                       // llvm.ve.vl.pvmins.vvvMvl
+    ve_vl_pvmins_vvvl,                         // llvm.ve.vl.pvmins.vvvl
+    ve_vl_pvmins_vvvvl,                        // llvm.ve.vl.pvmins.vvvvl
+    ve_vl_pvor_vsvMvl,                         // llvm.ve.vl.pvor.vsvMvl
+    ve_vl_pvor_vsvl,                           // llvm.ve.vl.pvor.vsvl
+    ve_vl_pvor_vsvvl,                          // llvm.ve.vl.pvor.vsvvl
+    ve_vl_pvor_vvvMvl,                         // llvm.ve.vl.pvor.vvvMvl
+    ve_vl_pvor_vvvl,                           // llvm.ve.vl.pvor.vvvl
+    ve_vl_pvor_vvvvl,                          // llvm.ve.vl.pvor.vvvvl
+    ve_vl_pvrcp_vvl,                           // llvm.ve.vl.pvrcp.vvl
+    ve_vl_pvrcp_vvvl,                          // llvm.ve.vl.pvrcp.vvvl
+    ve_vl_pvrsqrt_vvl,                         // llvm.ve.vl.pvrsqrt.vvl
+    ve_vl_pvrsqrt_vvvl,                        // llvm.ve.vl.pvrsqrt.vvvl
+    ve_vl_pvrsqrtnex_vvl,                      // llvm.ve.vl.pvrsqrtnex.vvl
+    ve_vl_pvrsqrtnex_vvvl,                     // llvm.ve.vl.pvrsqrtnex.vvvl
+    ve_vl_pvseq_vl,                            // llvm.ve.vl.pvseq.vl
+    ve_vl_pvseq_vvl,                           // llvm.ve.vl.pvseq.vvl
+    ve_vl_pvseqlo_vl,                          // llvm.ve.vl.pvseqlo.vl
+    ve_vl_pvseqlo_vvl,                         // llvm.ve.vl.pvseqlo.vvl
+    ve_vl_pvsequp_vl,                          // llvm.ve.vl.pvsequp.vl
+    ve_vl_pvsequp_vvl,                         // llvm.ve.vl.pvsequp.vvl
+    ve_vl_pvsla_vvsMvl,                        // llvm.ve.vl.pvsla.vvsMvl
+    ve_vl_pvsla_vvsl,                          // llvm.ve.vl.pvsla.vvsl
+    ve_vl_pvsla_vvsvl,                         // llvm.ve.vl.pvsla.vvsvl
+    ve_vl_pvsla_vvvMvl,                        // llvm.ve.vl.pvsla.vvvMvl
+    ve_vl_pvsla_vvvl,                          // llvm.ve.vl.pvsla.vvvl
+    ve_vl_pvsla_vvvvl,                         // llvm.ve.vl.pvsla.vvvvl
+    ve_vl_pvsll_vvsMvl,                        // llvm.ve.vl.pvsll.vvsMvl
+    ve_vl_pvsll_vvsl,                          // llvm.ve.vl.pvsll.vvsl
+    ve_vl_pvsll_vvsvl,                         // llvm.ve.vl.pvsll.vvsvl
+    ve_vl_pvsll_vvvMvl,                        // llvm.ve.vl.pvsll.vvvMvl
+    ve_vl_pvsll_vvvl,                          // llvm.ve.vl.pvsll.vvvl
+    ve_vl_pvsll_vvvvl,                         // llvm.ve.vl.pvsll.vvvvl
+    ve_vl_pvsra_vvsMvl,                        // llvm.ve.vl.pvsra.vvsMvl
+    ve_vl_pvsra_vvsl,                          // llvm.ve.vl.pvsra.vvsl
+    ve_vl_pvsra_vvsvl,                         // llvm.ve.vl.pvsra.vvsvl
+    ve_vl_pvsra_vvvMvl,                        // llvm.ve.vl.pvsra.vvvMvl
+    ve_vl_pvsra_vvvl,                          // llvm.ve.vl.pvsra.vvvl
+    ve_vl_pvsra_vvvvl,                         // llvm.ve.vl.pvsra.vvvvl
+    ve_vl_pvsrl_vvsMvl,                        // llvm.ve.vl.pvsrl.vvsMvl
+    ve_vl_pvsrl_vvsl,                          // llvm.ve.vl.pvsrl.vvsl
+    ve_vl_pvsrl_vvsvl,                         // llvm.ve.vl.pvsrl.vvsvl
+    ve_vl_pvsrl_vvvMvl,                        // llvm.ve.vl.pvsrl.vvvMvl
+    ve_vl_pvsrl_vvvl,                          // llvm.ve.vl.pvsrl.vvvl
+    ve_vl_pvsrl_vvvvl,                         // llvm.ve.vl.pvsrl.vvvvl
+    ve_vl_pvsubs_vsvMvl,                       // llvm.ve.vl.pvsubs.vsvMvl
+    ve_vl_pvsubs_vsvl,                         // llvm.ve.vl.pvsubs.vsvl
+    ve_vl_pvsubs_vsvvl,                        // llvm.ve.vl.pvsubs.vsvvl
+    ve_vl_pvsubs_vvvMvl,                       // llvm.ve.vl.pvsubs.vvvMvl
+    ve_vl_pvsubs_vvvl,                         // llvm.ve.vl.pvsubs.vvvl
+    ve_vl_pvsubs_vvvvl,                        // llvm.ve.vl.pvsubs.vvvvl
+    ve_vl_pvsubu_vsvMvl,                       // llvm.ve.vl.pvsubu.vsvMvl
+    ve_vl_pvsubu_vsvl,                         // llvm.ve.vl.pvsubu.vsvl
+    ve_vl_pvsubu_vsvvl,                        // llvm.ve.vl.pvsubu.vsvvl
+    ve_vl_pvsubu_vvvMvl,                       // llvm.ve.vl.pvsubu.vvvMvl
+    ve_vl_pvsubu_vvvl,                         // llvm.ve.vl.pvsubu.vvvl
+    ve_vl_pvsubu_vvvvl,                        // llvm.ve.vl.pvsubu.vvvvl
+    ve_vl_pvxor_vsvMvl,                        // llvm.ve.vl.pvxor.vsvMvl
+    ve_vl_pvxor_vsvl,                          // llvm.ve.vl.pvxor.vsvl
+    ve_vl_pvxor_vsvvl,                         // llvm.ve.vl.pvxor.vsvvl
+    ve_vl_pvxor_vvvMvl,                        // llvm.ve.vl.pvxor.vvvMvl
+    ve_vl_pvxor_vvvl,                          // llvm.ve.vl.pvxor.vvvl
+    ve_vl_pvxor_vvvvl,                         // llvm.ve.vl.pvxor.vvvvl
+    ve_vl_svm_sMs,                             // llvm.ve.vl.svm.sMs
+    ve_vl_svm_sms,                             // llvm.ve.vl.svm.sms
+    ve_vl_svob,                                // llvm.ve.vl.svob
+    ve_vl_tovm_sml,                            // llvm.ve.vl.tovm.sml
+    ve_vl_vaddsl_vsvl,                         // llvm.ve.vl.vaddsl.vsvl
+    ve_vl_vaddsl_vsvmvl,                       // llvm.ve.vl.vaddsl.vsvmvl
+    ve_vl_vaddsl_vsvvl,                        // llvm.ve.vl.vaddsl.vsvvl
+    ve_vl_vaddsl_vvvl,                         // llvm.ve.vl.vaddsl.vvvl
+    ve_vl_vaddsl_vvvmvl,                       // llvm.ve.vl.vaddsl.vvvmvl
+    ve_vl_vaddsl_vvvvl,                        // llvm.ve.vl.vaddsl.vvvvl
+    ve_vl_vaddswsx_vsvl,                       // llvm.ve.vl.vaddswsx.vsvl
+    ve_vl_vaddswsx_vsvmvl,                     // llvm.ve.vl.vaddswsx.vsvmvl
+    ve_vl_vaddswsx_vsvvl,                      // llvm.ve.vl.vaddswsx.vsvvl
+    ve_vl_vaddswsx_vvvl,                       // llvm.ve.vl.vaddswsx.vvvl
+    ve_vl_vaddswsx_vvvmvl,                     // llvm.ve.vl.vaddswsx.vvvmvl
+    ve_vl_vaddswsx_vvvvl,                      // llvm.ve.vl.vaddswsx.vvvvl
+    ve_vl_vaddswzx_vsvl,                       // llvm.ve.vl.vaddswzx.vsvl
+    ve_vl_vaddswzx_vsvmvl,                     // llvm.ve.vl.vaddswzx.vsvmvl
+    ve_vl_vaddswzx_vsvvl,                      // llvm.ve.vl.vaddswzx.vsvvl
+    ve_vl_vaddswzx_vvvl,                       // llvm.ve.vl.vaddswzx.vvvl
+    ve_vl_vaddswzx_vvvmvl,                     // llvm.ve.vl.vaddswzx.vvvmvl
+    ve_vl_vaddswzx_vvvvl,                      // llvm.ve.vl.vaddswzx.vvvvl
+    ve_vl_vaddul_vsvl,                         // llvm.ve.vl.vaddul.vsvl
+    ve_vl_vaddul_vsvmvl,                       // llvm.ve.vl.vaddul.vsvmvl
+    ve_vl_vaddul_vsvvl,                        // llvm.ve.vl.vaddul.vsvvl
+    ve_vl_vaddul_vvvl,                         // llvm.ve.vl.vaddul.vvvl
+    ve_vl_vaddul_vvvmvl,                       // llvm.ve.vl.vaddul.vvvmvl
+    ve_vl_vaddul_vvvvl,                        // llvm.ve.vl.vaddul.vvvvl
+    ve_vl_vadduw_vsvl,                         // llvm.ve.vl.vadduw.vsvl
+    ve_vl_vadduw_vsvmvl,                       // llvm.ve.vl.vadduw.vsvmvl
+    ve_vl_vadduw_vsvvl,                        // llvm.ve.vl.vadduw.vsvvl
+    ve_vl_vadduw_vvvl,                         // llvm.ve.vl.vadduw.vvvl
+    ve_vl_vadduw_vvvmvl,                       // llvm.ve.vl.vadduw.vvvmvl
+    ve_vl_vadduw_vvvvl,                        // llvm.ve.vl.vadduw.vvvvl
+    ve_vl_vand_vsvl,                           // llvm.ve.vl.vand.vsvl
+    ve_vl_vand_vsvmvl,                         // llvm.ve.vl.vand.vsvmvl
+    ve_vl_vand_vsvvl,                          // llvm.ve.vl.vand.vsvvl
+    ve_vl_vand_vvvl,                           // llvm.ve.vl.vand.vvvl
+    ve_vl_vand_vvvmvl,                         // llvm.ve.vl.vand.vvvmvl
+    ve_vl_vand_vvvvl,                          // llvm.ve.vl.vand.vvvvl
+    ve_vl_vbrdd_vsl,                           // llvm.ve.vl.vbrdd.vsl
+    ve_vl_vbrdd_vsmvl,                         // llvm.ve.vl.vbrdd.vsmvl
+    ve_vl_vbrdd_vsvl,                          // llvm.ve.vl.vbrdd.vsvl
+    ve_vl_vbrdl_vsl,                           // llvm.ve.vl.vbrdl.vsl
+    ve_vl_vbrdl_vsmvl,                         // llvm.ve.vl.vbrdl.vsmvl
+    ve_vl_vbrdl_vsvl,                          // llvm.ve.vl.vbrdl.vsvl
+    ve_vl_vbrds_vsl,                           // llvm.ve.vl.vbrds.vsl
+    ve_vl_vbrds_vsmvl,                         // llvm.ve.vl.vbrds.vsmvl
+    ve_vl_vbrds_vsvl,                          // llvm.ve.vl.vbrds.vsvl
+    ve_vl_vbrdw_vsl,                           // llvm.ve.vl.vbrdw.vsl
+    ve_vl_vbrdw_vsmvl,                         // llvm.ve.vl.vbrdw.vsmvl
+    ve_vl_vbrdw_vsvl,                          // llvm.ve.vl.vbrdw.vsvl
+    ve_vl_vcmpsl_vsvl,                         // llvm.ve.vl.vcmpsl.vsvl
+    ve_vl_vcmpsl_vsvmvl,                       // llvm.ve.vl.vcmpsl.vsvmvl
+    ve_vl_vcmpsl_vsvvl,                        // llvm.ve.vl.vcmpsl.vsvvl
+    ve_vl_vcmpsl_vvvl,                         // llvm.ve.vl.vcmpsl.vvvl
+    ve_vl_vcmpsl_vvvmvl,                       // llvm.ve.vl.vcmpsl.vvvmvl
+    ve_vl_vcmpsl_vvvvl,                        // llvm.ve.vl.vcmpsl.vvvvl
+    ve_vl_vcmpswsx_vsvl,                       // llvm.ve.vl.vcmpswsx.vsvl
+    ve_vl_vcmpswsx_vsvmvl,                     // llvm.ve.vl.vcmpswsx.vsvmvl
+    ve_vl_vcmpswsx_vsvvl,                      // llvm.ve.vl.vcmpswsx.vsvvl
+    ve_vl_vcmpswsx_vvvl,                       // llvm.ve.vl.vcmpswsx.vvvl
+    ve_vl_vcmpswsx_vvvmvl,                     // llvm.ve.vl.vcmpswsx.vvvmvl
+    ve_vl_vcmpswsx_vvvvl,                      // llvm.ve.vl.vcmpswsx.vvvvl
+    ve_vl_vcmpswzx_vsvl,                       // llvm.ve.vl.vcmpswzx.vsvl
+    ve_vl_vcmpswzx_vsvmvl,                     // llvm.ve.vl.vcmpswzx.vsvmvl
+    ve_vl_vcmpswzx_vsvvl,                      // llvm.ve.vl.vcmpswzx.vsvvl
+    ve_vl_vcmpswzx_vvvl,                       // llvm.ve.vl.vcmpswzx.vvvl
+    ve_vl_vcmpswzx_vvvmvl,                     // llvm.ve.vl.vcmpswzx.vvvmvl
+    ve_vl_vcmpswzx_vvvvl,                      // llvm.ve.vl.vcmpswzx.vvvvl
+    ve_vl_vcmpul_vsvl,                         // llvm.ve.vl.vcmpul.vsvl
+    ve_vl_vcmpul_vsvmvl,                       // llvm.ve.vl.vcmpul.vsvmvl
+    ve_vl_vcmpul_vsvvl,                        // llvm.ve.vl.vcmpul.vsvvl
+    ve_vl_vcmpul_vvvl,                         // llvm.ve.vl.vcmpul.vvvl
+    ve_vl_vcmpul_vvvmvl,                       // llvm.ve.vl.vcmpul.vvvmvl
+    ve_vl_vcmpul_vvvvl,                        // llvm.ve.vl.vcmpul.vvvvl
+    ve_vl_vcmpuw_vsvl,                         // llvm.ve.vl.vcmpuw.vsvl
+    ve_vl_vcmpuw_vsvmvl,                       // llvm.ve.vl.vcmpuw.vsvmvl
+    ve_vl_vcmpuw_vsvvl,                        // llvm.ve.vl.vcmpuw.vsvvl
+    ve_vl_vcmpuw_vvvl,                         // llvm.ve.vl.vcmpuw.vvvl
+    ve_vl_vcmpuw_vvvmvl,                       // llvm.ve.vl.vcmpuw.vvvmvl
+    ve_vl_vcmpuw_vvvvl,                        // llvm.ve.vl.vcmpuw.vvvvl
+    ve_vl_vcp_vvmvl,                           // llvm.ve.vl.vcp.vvmvl
+    ve_vl_vcvtdl_vvl,                          // llvm.ve.vl.vcvtdl.vvl
+    ve_vl_vcvtdl_vvvl,                         // llvm.ve.vl.vcvtdl.vvvl
+    ve_vl_vcvtds_vvl,                          // llvm.ve.vl.vcvtds.vvl
+    ve_vl_vcvtds_vvvl,                         // llvm.ve.vl.vcvtds.vvvl
+    ve_vl_vcvtdw_vvl,                          // llvm.ve.vl.vcvtdw.vvl
+    ve_vl_vcvtdw_vvvl,                         // llvm.ve.vl.vcvtdw.vvvl
+    ve_vl_vcvtld_vvl,                          // llvm.ve.vl.vcvtld.vvl
+    ve_vl_vcvtld_vvmvl,                        // llvm.ve.vl.vcvtld.vvmvl
+    ve_vl_vcvtld_vvvl,                         // llvm.ve.vl.vcvtld.vvvl
+    ve_vl_vcvtldrz_vvl,                        // llvm.ve.vl.vcvtldrz.vvl
+    ve_vl_vcvtldrz_vvmvl,                      // llvm.ve.vl.vcvtldrz.vvmvl
+    ve_vl_vcvtldrz_vvvl,                       // llvm.ve.vl.vcvtldrz.vvvl
+    ve_vl_vcvtsd_vvl,                          // llvm.ve.vl.vcvtsd.vvl
+    ve_vl_vcvtsd_vvvl,                         // llvm.ve.vl.vcvtsd.vvvl
+    ve_vl_vcvtsw_vvl,                          // llvm.ve.vl.vcvtsw.vvl
+    ve_vl_vcvtsw_vvvl,                         // llvm.ve.vl.vcvtsw.vvvl
+    ve_vl_vcvtwdsx_vvl,                        // llvm.ve.vl.vcvtwdsx.vvl
+    ve_vl_vcvtwdsx_vvmvl,                      // llvm.ve.vl.vcvtwdsx.vvmvl
+    ve_vl_vcvtwdsx_vvvl,                       // llvm.ve.vl.vcvtwdsx.vvvl
+    ve_vl_vcvtwdsxrz_vvl,                      // llvm.ve.vl.vcvtwdsxrz.vvl
+    ve_vl_vcvtwdsxrz_vvmvl,                    // llvm.ve.vl.vcvtwdsxrz.vvmvl
+    ve_vl_vcvtwdsxrz_vvvl,                     // llvm.ve.vl.vcvtwdsxrz.vvvl
+    ve_vl_vcvtwdzx_vvl,                        // llvm.ve.vl.vcvtwdzx.vvl
+    ve_vl_vcvtwdzx_vvmvl,                      // llvm.ve.vl.vcvtwdzx.vvmvl
+    ve_vl_vcvtwdzx_vvvl,                       // llvm.ve.vl.vcvtwdzx.vvvl
+    ve_vl_vcvtwdzxrz_vvl,                      // llvm.ve.vl.vcvtwdzxrz.vvl
+    ve_vl_vcvtwdzxrz_vvmvl,                    // llvm.ve.vl.vcvtwdzxrz.vvmvl
+    ve_vl_vcvtwdzxrz_vvvl,                     // llvm.ve.vl.vcvtwdzxrz.vvvl
+    ve_vl_vcvtwssx_vvl,                        // llvm.ve.vl.vcvtwssx.vvl
+    ve_vl_vcvtwssx_vvmvl,                      // llvm.ve.vl.vcvtwssx.vvmvl
+    ve_vl_vcvtwssx_vvvl,                       // llvm.ve.vl.vcvtwssx.vvvl
+    ve_vl_vcvtwssxrz_vvl,                      // llvm.ve.vl.vcvtwssxrz.vvl
+    ve_vl_vcvtwssxrz_vvmvl,                    // llvm.ve.vl.vcvtwssxrz.vvmvl
+    ve_vl_vcvtwssxrz_vvvl,                     // llvm.ve.vl.vcvtwssxrz.vvvl
+    ve_vl_vcvtwszx_vvl,                        // llvm.ve.vl.vcvtwszx.vvl
+    ve_vl_vcvtwszx_vvmvl,                      // llvm.ve.vl.vcvtwszx.vvmvl
+    ve_vl_vcvtwszx_vvvl,                       // llvm.ve.vl.vcvtwszx.vvvl
+    ve_vl_vcvtwszxrz_vvl,                      // llvm.ve.vl.vcvtwszxrz.vvl
+    ve_vl_vcvtwszxrz_vvmvl,                    // llvm.ve.vl.vcvtwszxrz.vvmvl
+    ve_vl_vcvtwszxrz_vvvl,                     // llvm.ve.vl.vcvtwszxrz.vvvl
+    ve_vl_vdivsl_vsvl,                         // llvm.ve.vl.vdivsl.vsvl
+    ve_vl_vdivsl_vsvmvl,                       // llvm.ve.vl.vdivsl.vsvmvl
+    ve_vl_vdivsl_vsvvl,                        // llvm.ve.vl.vdivsl.vsvvl
+    ve_vl_vdivsl_vvsl,                         // llvm.ve.vl.vdivsl.vvsl
+    ve_vl_vdivsl_vvsmvl,                       // llvm.ve.vl.vdivsl.vvsmvl
+    ve_vl_vdivsl_vvsvl,                        // llvm.ve.vl.vdivsl.vvsvl
+    ve_vl_vdivsl_vvvl,                         // llvm.ve.vl.vdivsl.vvvl
+    ve_vl_vdivsl_vvvmvl,                       // llvm.ve.vl.vdivsl.vvvmvl
+    ve_vl_vdivsl_vvvvl,                        // llvm.ve.vl.vdivsl.vvvvl
+    ve_vl_vdivswsx_vsvl,                       // llvm.ve.vl.vdivswsx.vsvl
+    ve_vl_vdivswsx_vsvmvl,                     // llvm.ve.vl.vdivswsx.vsvmvl
+    ve_vl_vdivswsx_vsvvl,                      // llvm.ve.vl.vdivswsx.vsvvl
+    ve_vl_vdivswsx_vvsl,                       // llvm.ve.vl.vdivswsx.vvsl
+    ve_vl_vdivswsx_vvsmvl,                     // llvm.ve.vl.vdivswsx.vvsmvl
+    ve_vl_vdivswsx_vvsvl,                      // llvm.ve.vl.vdivswsx.vvsvl
+    ve_vl_vdivswsx_vvvl,                       // llvm.ve.vl.vdivswsx.vvvl
+    ve_vl_vdivswsx_vvvmvl,                     // llvm.ve.vl.vdivswsx.vvvmvl
+    ve_vl_vdivswsx_vvvvl,                      // llvm.ve.vl.vdivswsx.vvvvl
+    ve_vl_vdivswzx_vsvl,                       // llvm.ve.vl.vdivswzx.vsvl
+    ve_vl_vdivswzx_vsvmvl,                     // llvm.ve.vl.vdivswzx.vsvmvl
+    ve_vl_vdivswzx_vsvvl,                      // llvm.ve.vl.vdivswzx.vsvvl
+    ve_vl_vdivswzx_vvsl,                       // llvm.ve.vl.vdivswzx.vvsl
+    ve_vl_vdivswzx_vvsmvl,                     // llvm.ve.vl.vdivswzx.vvsmvl
+    ve_vl_vdivswzx_vvsvl,                      // llvm.ve.vl.vdivswzx.vvsvl
+    ve_vl_vdivswzx_vvvl,                       // llvm.ve.vl.vdivswzx.vvvl
+    ve_vl_vdivswzx_vvvmvl,                     // llvm.ve.vl.vdivswzx.vvvmvl
+    ve_vl_vdivswzx_vvvvl,                      // llvm.ve.vl.vdivswzx.vvvvl
+    ve_vl_vdivul_vsvl,                         // llvm.ve.vl.vdivul.vsvl
+    ve_vl_vdivul_vsvmvl,                       // llvm.ve.vl.vdivul.vsvmvl
+    ve_vl_vdivul_vsvvl,                        // llvm.ve.vl.vdivul.vsvvl
+    ve_vl_vdivul_vvsl,                         // llvm.ve.vl.vdivul.vvsl
+    ve_vl_vdivul_vvsmvl,                       // llvm.ve.vl.vdivul.vvsmvl
+    ve_vl_vdivul_vvsvl,                        // llvm.ve.vl.vdivul.vvsvl
+    ve_vl_vdivul_vvvl,                         // llvm.ve.vl.vdivul.vvvl
+    ve_vl_vdivul_vvvmvl,                       // llvm.ve.vl.vdivul.vvvmvl
+    ve_vl_vdivul_vvvvl,                        // llvm.ve.vl.vdivul.vvvvl
+    ve_vl_vdivuw_vsvl,                         // llvm.ve.vl.vdivuw.vsvl
+    ve_vl_vdivuw_vsvmvl,                       // llvm.ve.vl.vdivuw.vsvmvl
+    ve_vl_vdivuw_vsvvl,                        // llvm.ve.vl.vdivuw.vsvvl
+    ve_vl_vdivuw_vvsl,                         // llvm.ve.vl.vdivuw.vvsl
+    ve_vl_vdivuw_vvsmvl,                       // llvm.ve.vl.vdivuw.vvsmvl
+    ve_vl_vdivuw_vvsvl,                        // llvm.ve.vl.vdivuw.vvsvl
+    ve_vl_vdivuw_vvvl,                         // llvm.ve.vl.vdivuw.vvvl
+    ve_vl_vdivuw_vvvmvl,                       // llvm.ve.vl.vdivuw.vvvmvl
+    ve_vl_vdivuw_vvvvl,                        // llvm.ve.vl.vdivuw.vvvvl
+    ve_vl_veqv_vsvl,                           // llvm.ve.vl.veqv.vsvl
+    ve_vl_veqv_vsvmvl,                         // llvm.ve.vl.veqv.vsvmvl
+    ve_vl_veqv_vsvvl,                          // llvm.ve.vl.veqv.vsvvl
+    ve_vl_veqv_vvvl,                           // llvm.ve.vl.veqv.vvvl
+    ve_vl_veqv_vvvmvl,                         // llvm.ve.vl.veqv.vvvmvl
+    ve_vl_veqv_vvvvl,                          // llvm.ve.vl.veqv.vvvvl
+    ve_vl_vex_vvmvl,                           // llvm.ve.vl.vex.vvmvl
+    ve_vl_vfaddd_vsvl,                         // llvm.ve.vl.vfaddd.vsvl
+    ve_vl_vfaddd_vsvmvl,                       // llvm.ve.vl.vfaddd.vsvmvl
+    ve_vl_vfaddd_vsvvl,                        // llvm.ve.vl.vfaddd.vsvvl
+    ve_vl_vfaddd_vvvl,                         // llvm.ve.vl.vfaddd.vvvl
+    ve_vl_vfaddd_vvvmvl,                       // llvm.ve.vl.vfaddd.vvvmvl
+    ve_vl_vfaddd_vvvvl,                        // llvm.ve.vl.vfaddd.vvvvl
+    ve_vl_vfadds_vsvl,                         // llvm.ve.vl.vfadds.vsvl
+    ve_vl_vfadds_vsvmvl,                       // llvm.ve.vl.vfadds.vsvmvl
+    ve_vl_vfadds_vsvvl,                        // llvm.ve.vl.vfadds.vsvvl
+    ve_vl_vfadds_vvvl,                         // llvm.ve.vl.vfadds.vvvl
+    ve_vl_vfadds_vvvmvl,                       // llvm.ve.vl.vfadds.vvvmvl
+    ve_vl_vfadds_vvvvl,                        // llvm.ve.vl.vfadds.vvvvl
+    ve_vl_vfcmpd_vsvl,                         // llvm.ve.vl.vfcmpd.vsvl
+    ve_vl_vfcmpd_vsvmvl,                       // llvm.ve.vl.vfcmpd.vsvmvl
+    ve_vl_vfcmpd_vsvvl,                        // llvm.ve.vl.vfcmpd.vsvvl
+    ve_vl_vfcmpd_vvvl,                         // llvm.ve.vl.vfcmpd.vvvl
+    ve_vl_vfcmpd_vvvmvl,                       // llvm.ve.vl.vfcmpd.vvvmvl
+    ve_vl_vfcmpd_vvvvl,                        // llvm.ve.vl.vfcmpd.vvvvl
+    ve_vl_vfcmps_vsvl,                         // llvm.ve.vl.vfcmps.vsvl
+    ve_vl_vfcmps_vsvmvl,                       // llvm.ve.vl.vfcmps.vsvmvl
+    ve_vl_vfcmps_vsvvl,                        // llvm.ve.vl.vfcmps.vsvvl
+    ve_vl_vfcmps_vvvl,                         // llvm.ve.vl.vfcmps.vvvl
+    ve_vl_vfcmps_vvvmvl,                       // llvm.ve.vl.vfcmps.vvvmvl
+    ve_vl_vfcmps_vvvvl,                        // llvm.ve.vl.vfcmps.vvvvl
+    ve_vl_vfdivd_vsvl,                         // llvm.ve.vl.vfdivd.vsvl
+    ve_vl_vfdivd_vsvmvl,                       // llvm.ve.vl.vfdivd.vsvmvl
+    ve_vl_vfdivd_vsvvl,                        // llvm.ve.vl.vfdivd.vsvvl
+    ve_vl_vfdivd_vvvl,                         // llvm.ve.vl.vfdivd.vvvl
+    ve_vl_vfdivd_vvvmvl,                       // llvm.ve.vl.vfdivd.vvvmvl
+    ve_vl_vfdivd_vvvvl,                        // llvm.ve.vl.vfdivd.vvvvl
+    ve_vl_vfdivs_vsvl,                         // llvm.ve.vl.vfdivs.vsvl
+    ve_vl_vfdivs_vsvmvl,                       // llvm.ve.vl.vfdivs.vsvmvl
+    ve_vl_vfdivs_vsvvl,                        // llvm.ve.vl.vfdivs.vsvvl
+    ve_vl_vfdivs_vvvl,                         // llvm.ve.vl.vfdivs.vvvl
+    ve_vl_vfdivs_vvvmvl,                       // llvm.ve.vl.vfdivs.vvvmvl
+    ve_vl_vfdivs_vvvvl,                        // llvm.ve.vl.vfdivs.vvvvl
+    ve_vl_vfmadd_vsvvl,                        // llvm.ve.vl.vfmadd.vsvvl
+    ve_vl_vfmadd_vsvvmvl,                      // llvm.ve.vl.vfmadd.vsvvmvl
+    ve_vl_vfmadd_vsvvvl,                       // llvm.ve.vl.vfmadd.vsvvvl
+    ve_vl_vfmadd_vvsvl,                        // llvm.ve.vl.vfmadd.vvsvl
+    ve_vl_vfmadd_vvsvmvl,                      // llvm.ve.vl.vfmadd.vvsvmvl
+    ve_vl_vfmadd_vvsvvl,                       // llvm.ve.vl.vfmadd.vvsvvl
+    ve_vl_vfmadd_vvvvl,                        // llvm.ve.vl.vfmadd.vvvvl
+    ve_vl_vfmadd_vvvvmvl,                      // llvm.ve.vl.vfmadd.vvvvmvl
+    ve_vl_vfmadd_vvvvvl,                       // llvm.ve.vl.vfmadd.vvvvvl
+    ve_vl_vfmads_vsvvl,                        // llvm.ve.vl.vfmads.vsvvl
+    ve_vl_vfmads_vsvvmvl,                      // llvm.ve.vl.vfmads.vsvvmvl
+    ve_vl_vfmads_vsvvvl,                       // llvm.ve.vl.vfmads.vsvvvl
+    ve_vl_vfmads_vvsvl,                        // llvm.ve.vl.vfmads.vvsvl
+    ve_vl_vfmads_vvsvmvl,                      // llvm.ve.vl.vfmads.vvsvmvl
+    ve_vl_vfmads_vvsvvl,                       // llvm.ve.vl.vfmads.vvsvvl
+    ve_vl_vfmads_vvvvl,                        // llvm.ve.vl.vfmads.vvvvl
+    ve_vl_vfmads_vvvvmvl,                      // llvm.ve.vl.vfmads.vvvvmvl
+    ve_vl_vfmads_vvvvvl,                       // llvm.ve.vl.vfmads.vvvvvl
+    ve_vl_vfmaxd_vsvl,                         // llvm.ve.vl.vfmaxd.vsvl
+    ve_vl_vfmaxd_vsvmvl,                       // llvm.ve.vl.vfmaxd.vsvmvl
+    ve_vl_vfmaxd_vsvvl,                        // llvm.ve.vl.vfmaxd.vsvvl
+    ve_vl_vfmaxd_vvvl,                         // llvm.ve.vl.vfmaxd.vvvl
+    ve_vl_vfmaxd_vvvmvl,                       // llvm.ve.vl.vfmaxd.vvvmvl
+    ve_vl_vfmaxd_vvvvl,                        // llvm.ve.vl.vfmaxd.vvvvl
+    ve_vl_vfmaxs_vsvl,                         // llvm.ve.vl.vfmaxs.vsvl
+    ve_vl_vfmaxs_vsvmvl,                       // llvm.ve.vl.vfmaxs.vsvmvl
+    ve_vl_vfmaxs_vsvvl,                        // llvm.ve.vl.vfmaxs.vsvvl
+    ve_vl_vfmaxs_vvvl,                         // llvm.ve.vl.vfmaxs.vvvl
+    ve_vl_vfmaxs_vvvmvl,                       // llvm.ve.vl.vfmaxs.vvvmvl
+    ve_vl_vfmaxs_vvvvl,                        // llvm.ve.vl.vfmaxs.vvvvl
+    ve_vl_vfmind_vsvl,                         // llvm.ve.vl.vfmind.vsvl
+    ve_vl_vfmind_vsvmvl,                       // llvm.ve.vl.vfmind.vsvmvl
+    ve_vl_vfmind_vsvvl,                        // llvm.ve.vl.vfmind.vsvvl
+    ve_vl_vfmind_vvvl,                         // llvm.ve.vl.vfmind.vvvl
+    ve_vl_vfmind_vvvmvl,                       // llvm.ve.vl.vfmind.vvvmvl
+    ve_vl_vfmind_vvvvl,                        // llvm.ve.vl.vfmind.vvvvl
+    ve_vl_vfmins_vsvl,                         // llvm.ve.vl.vfmins.vsvl
+    ve_vl_vfmins_vsvmvl,                       // llvm.ve.vl.vfmins.vsvmvl
+    ve_vl_vfmins_vsvvl,                        // llvm.ve.vl.vfmins.vsvvl
+    ve_vl_vfmins_vvvl,                         // llvm.ve.vl.vfmins.vvvl
+    ve_vl_vfmins_vvvmvl,                       // llvm.ve.vl.vfmins.vvvmvl
+    ve_vl_vfmins_vvvvl,                        // llvm.ve.vl.vfmins.vvvvl
+    ve_vl_vfmkdeq_mvl,                         // llvm.ve.vl.vfmkdeq.mvl
+    ve_vl_vfmkdeq_mvml,                        // llvm.ve.vl.vfmkdeq.mvml
+    ve_vl_vfmkdeqnan_mvl,                      // llvm.ve.vl.vfmkdeqnan.mvl
+    ve_vl_vfmkdeqnan_mvml,                     // llvm.ve.vl.vfmkdeqnan.mvml
+    ve_vl_vfmkdge_mvl,                         // llvm.ve.vl.vfmkdge.mvl
+    ve_vl_vfmkdge_mvml,                        // llvm.ve.vl.vfmkdge.mvml
+    ve_vl_vfmkdgenan_mvl,                      // llvm.ve.vl.vfmkdgenan.mvl
+    ve_vl_vfmkdgenan_mvml,                     // llvm.ve.vl.vfmkdgenan.mvml
+    ve_vl_vfmkdgt_mvl,                         // llvm.ve.vl.vfmkdgt.mvl
+    ve_vl_vfmkdgt_mvml,                        // llvm.ve.vl.vfmkdgt.mvml
+    ve_vl_vfmkdgtnan_mvl,                      // llvm.ve.vl.vfmkdgtnan.mvl
+    ve_vl_vfmkdgtnan_mvml,                     // llvm.ve.vl.vfmkdgtnan.mvml
+    ve_vl_vfmkdle_mvl,                         // llvm.ve.vl.vfmkdle.mvl
+    ve_vl_vfmkdle_mvml,                        // llvm.ve.vl.vfmkdle.mvml
+    ve_vl_vfmkdlenan_mvl,                      // llvm.ve.vl.vfmkdlenan.mvl
+    ve_vl_vfmkdlenan_mvml,                     // llvm.ve.vl.vfmkdlenan.mvml
+    ve_vl_vfmkdlt_mvl,                         // llvm.ve.vl.vfmkdlt.mvl
+    ve_vl_vfmkdlt_mvml,                        // llvm.ve.vl.vfmkdlt.mvml
+    ve_vl_vfmkdltnan_mvl,                      // llvm.ve.vl.vfmkdltnan.mvl
+    ve_vl_vfmkdltnan_mvml,                     // llvm.ve.vl.vfmkdltnan.mvml
+    ve_vl_vfmkdnan_mvl,                        // llvm.ve.vl.vfmkdnan.mvl
+    ve_vl_vfmkdnan_mvml,                       // llvm.ve.vl.vfmkdnan.mvml
+    ve_vl_vfmkdne_mvl,                         // llvm.ve.vl.vfmkdne.mvl
+    ve_vl_vfmkdne_mvml,                        // llvm.ve.vl.vfmkdne.mvml
+    ve_vl_vfmkdnenan_mvl,                      // llvm.ve.vl.vfmkdnenan.mvl
+    ve_vl_vfmkdnenan_mvml,                     // llvm.ve.vl.vfmkdnenan.mvml
+    ve_vl_vfmkdnum_mvl,                        // llvm.ve.vl.vfmkdnum.mvl
+    ve_vl_vfmkdnum_mvml,                       // llvm.ve.vl.vfmkdnum.mvml
+    ve_vl_vfmklaf_ml,                          // llvm.ve.vl.vfmklaf.ml
+    ve_vl_vfmklat_ml,                          // llvm.ve.vl.vfmklat.ml
+    ve_vl_vfmkleq_mvl,                         // llvm.ve.vl.vfmkleq.mvl
+    ve_vl_vfmkleq_mvml,                        // llvm.ve.vl.vfmkleq.mvml
+    ve_vl_vfmkleqnan_mvl,                      // llvm.ve.vl.vfmkleqnan.mvl
+    ve_vl_vfmkleqnan_mvml,                     // llvm.ve.vl.vfmkleqnan.mvml
+    ve_vl_vfmklge_mvl,                         // llvm.ve.vl.vfmklge.mvl
+    ve_vl_vfmklge_mvml,                        // llvm.ve.vl.vfmklge.mvml
+    ve_vl_vfmklgenan_mvl,                      // llvm.ve.vl.vfmklgenan.mvl
+    ve_vl_vfmklgenan_mvml,                     // llvm.ve.vl.vfmklgenan.mvml
+    ve_vl_vfmklgt_mvl,                         // llvm.ve.vl.vfmklgt.mvl
+    ve_vl_vfmklgt_mvml,                        // llvm.ve.vl.vfmklgt.mvml
+    ve_vl_vfmklgtnan_mvl,                      // llvm.ve.vl.vfmklgtnan.mvl
+    ve_vl_vfmklgtnan_mvml,                     // llvm.ve.vl.vfmklgtnan.mvml
+    ve_vl_vfmklle_mvl,                         // llvm.ve.vl.vfmklle.mvl
+    ve_vl_vfmklle_mvml,                        // llvm.ve.vl.vfmklle.mvml
+    ve_vl_vfmkllenan_mvl,                      // llvm.ve.vl.vfmkllenan.mvl
+    ve_vl_vfmkllenan_mvml,                     // llvm.ve.vl.vfmkllenan.mvml
+    ve_vl_vfmkllt_mvl,                         // llvm.ve.vl.vfmkllt.mvl
+    ve_vl_vfmkllt_mvml,                        // llvm.ve.vl.vfmkllt.mvml
+    ve_vl_vfmklltnan_mvl,                      // llvm.ve.vl.vfmklltnan.mvl
+    ve_vl_vfmklltnan_mvml,                     // llvm.ve.vl.vfmklltnan.mvml
+    ve_vl_vfmklnan_mvl,                        // llvm.ve.vl.vfmklnan.mvl
+    ve_vl_vfmklnan_mvml,                       // llvm.ve.vl.vfmklnan.mvml
+    ve_vl_vfmklne_mvl,                         // llvm.ve.vl.vfmklne.mvl
+    ve_vl_vfmklne_mvml,                        // llvm.ve.vl.vfmklne.mvml
+    ve_vl_vfmklnenan_mvl,                      // llvm.ve.vl.vfmklnenan.mvl
+    ve_vl_vfmklnenan_mvml,                     // llvm.ve.vl.vfmklnenan.mvml
+    ve_vl_vfmklnum_mvl,                        // llvm.ve.vl.vfmklnum.mvl
+    ve_vl_vfmklnum_mvml,                       // llvm.ve.vl.vfmklnum.mvml
+    ve_vl_vfmkseq_mvl,                         // llvm.ve.vl.vfmkseq.mvl
+    ve_vl_vfmkseq_mvml,                        // llvm.ve.vl.vfmkseq.mvml
+    ve_vl_vfmkseqnan_mvl,                      // llvm.ve.vl.vfmkseqnan.mvl
+    ve_vl_vfmkseqnan_mvml,                     // llvm.ve.vl.vfmkseqnan.mvml
+    ve_vl_vfmksge_mvl,                         // llvm.ve.vl.vfmksge.mvl
+    ve_vl_vfmksge_mvml,                        // llvm.ve.vl.vfmksge.mvml
+    ve_vl_vfmksgenan_mvl,                      // llvm.ve.vl.vfmksgenan.mvl
+    ve_vl_vfmksgenan_mvml,                     // llvm.ve.vl.vfmksgenan.mvml
+    ve_vl_vfmksgt_mvl,                         // llvm.ve.vl.vfmksgt.mvl
+    ve_vl_vfmksgt_mvml,                        // llvm.ve.vl.vfmksgt.mvml
+    ve_vl_vfmksgtnan_mvl,                      // llvm.ve.vl.vfmksgtnan.mvl
+    ve_vl_vfmksgtnan_mvml,                     // llvm.ve.vl.vfmksgtnan.mvml
+    ve_vl_vfmksle_mvl,                         // llvm.ve.vl.vfmksle.mvl
+    ve_vl_vfmksle_mvml,                        // llvm.ve.vl.vfmksle.mvml
+    ve_vl_vfmkslenan_mvl,                      // llvm.ve.vl.vfmkslenan.mvl
+    ve_vl_vfmkslenan_mvml,                     // llvm.ve.vl.vfmkslenan.mvml
+    ve_vl_vfmkslt_mvl,                         // llvm.ve.vl.vfmkslt.mvl
+    ve_vl_vfmkslt_mvml,                        // llvm.ve.vl.vfmkslt.mvml
+    ve_vl_vfmksltnan_mvl,                      // llvm.ve.vl.vfmksltnan.mvl
+    ve_vl_vfmksltnan_mvml,                     // llvm.ve.vl.vfmksltnan.mvml
+    ve_vl_vfmksnan_mvl,                        // llvm.ve.vl.vfmksnan.mvl
+    ve_vl_vfmksnan_mvml,                       // llvm.ve.vl.vfmksnan.mvml
+    ve_vl_vfmksne_mvl,                         // llvm.ve.vl.vfmksne.mvl
+    ve_vl_vfmksne_mvml,                        // llvm.ve.vl.vfmksne.mvml
+    ve_vl_vfmksnenan_mvl,                      // llvm.ve.vl.vfmksnenan.mvl
+    ve_vl_vfmksnenan_mvml,                     // llvm.ve.vl.vfmksnenan.mvml
+    ve_vl_vfmksnum_mvl,                        // llvm.ve.vl.vfmksnum.mvl
+    ve_vl_vfmksnum_mvml,                       // llvm.ve.vl.vfmksnum.mvml
+    ve_vl_vfmkweq_mvl,                         // llvm.ve.vl.vfmkweq.mvl
+    ve_vl_vfmkweq_mvml,                        // llvm.ve.vl.vfmkweq.mvml
+    ve_vl_vfmkweqnan_mvl,                      // llvm.ve.vl.vfmkweqnan.mvl
+    ve_vl_vfmkweqnan_mvml,                     // llvm.ve.vl.vfmkweqnan.mvml
+    ve_vl_vfmkwge_mvl,                         // llvm.ve.vl.vfmkwge.mvl
+    ve_vl_vfmkwge_mvml,                        // llvm.ve.vl.vfmkwge.mvml
+    ve_vl_vfmkwgenan_mvl,                      // llvm.ve.vl.vfmkwgenan.mvl
+    ve_vl_vfmkwgenan_mvml,                     // llvm.ve.vl.vfmkwgenan.mvml
+    ve_vl_vfmkwgt_mvl,                         // llvm.ve.vl.vfmkwgt.mvl
+    ve_vl_vfmkwgt_mvml,                        // llvm.ve.vl.vfmkwgt.mvml
+    ve_vl_vfmkwgtnan_mvl,                      // llvm.ve.vl.vfmkwgtnan.mvl
+    ve_vl_vfmkwgtnan_mvml,                     // llvm.ve.vl.vfmkwgtnan.mvml
+    ve_vl_vfmkwle_mvl,                         // llvm.ve.vl.vfmkwle.mvl
+    ve_vl_vfmkwle_mvml,                        // llvm.ve.vl.vfmkwle.mvml
+    ve_vl_vfmkwlenan_mvl,                      // llvm.ve.vl.vfmkwlenan.mvl
+    ve_vl_vfmkwlenan_mvml,                     // llvm.ve.vl.vfmkwlenan.mvml
+    ve_vl_vfmkwlt_mvl,                         // llvm.ve.vl.vfmkwlt.mvl
+    ve_vl_vfmkwlt_mvml,                        // llvm.ve.vl.vfmkwlt.mvml
+    ve_vl_vfmkwltnan_mvl,                      // llvm.ve.vl.vfmkwltnan.mvl
+    ve_vl_vfmkwltnan_mvml,                     // llvm.ve.vl.vfmkwltnan.mvml
+    ve_vl_vfmkwnan_mvl,                        // llvm.ve.vl.vfmkwnan.mvl
+    ve_vl_vfmkwnan_mvml,                       // llvm.ve.vl.vfmkwnan.mvml
+    ve_vl_vfmkwne_mvl,                         // llvm.ve.vl.vfmkwne.mvl
+    ve_vl_vfmkwne_mvml,                        // llvm.ve.vl.vfmkwne.mvml
+    ve_vl_vfmkwnenan_mvl,                      // llvm.ve.vl.vfmkwnenan.mvl
+    ve_vl_vfmkwnenan_mvml,                     // llvm.ve.vl.vfmkwnenan.mvml
+    ve_vl_vfmkwnum_mvl,                        // llvm.ve.vl.vfmkwnum.mvl
+    ve_vl_vfmkwnum_mvml,                       // llvm.ve.vl.vfmkwnum.mvml
+    ve_vl_vfmsbd_vsvvl,                        // llvm.ve.vl.vfmsbd.vsvvl
+    ve_vl_vfmsbd_vsvvmvl,                      // llvm.ve.vl.vfmsbd.vsvvmvl
+    ve_vl_vfmsbd_vsvvvl,                       // llvm.ve.vl.vfmsbd.vsvvvl
+    ve_vl_vfmsbd_vvsvl,                        // llvm.ve.vl.vfmsbd.vvsvl
+    ve_vl_vfmsbd_vvsvmvl,                      // llvm.ve.vl.vfmsbd.vvsvmvl
+    ve_vl_vfmsbd_vvsvvl,                       // llvm.ve.vl.vfmsbd.vvsvvl
+    ve_vl_vfmsbd_vvvvl,                        // llvm.ve.vl.vfmsbd.vvvvl
+    ve_vl_vfmsbd_vvvvmvl,                      // llvm.ve.vl.vfmsbd.vvvvmvl
+    ve_vl_vfmsbd_vvvvvl,                       // llvm.ve.vl.vfmsbd.vvvvvl
+    ve_vl_vfmsbs_vsvvl,                        // llvm.ve.vl.vfmsbs.vsvvl
+    ve_vl_vfmsbs_vsvvmvl,                      // llvm.ve.vl.vfmsbs.vsvvmvl
+    ve_vl_vfmsbs_vsvvvl,                       // llvm.ve.vl.vfmsbs.vsvvvl
+    ve_vl_vfmsbs_vvsvl,                        // llvm.ve.vl.vfmsbs.vvsvl
+    ve_vl_vfmsbs_vvsvmvl,                      // llvm.ve.vl.vfmsbs.vvsvmvl
+    ve_vl_vfmsbs_vvsvvl,                       // llvm.ve.vl.vfmsbs.vvsvvl
+    ve_vl_vfmsbs_vvvvl,                        // llvm.ve.vl.vfmsbs.vvvvl
+    ve_vl_vfmsbs_vvvvmvl,                      // llvm.ve.vl.vfmsbs.vvvvmvl
+    ve_vl_vfmsbs_vvvvvl,                       // llvm.ve.vl.vfmsbs.vvvvvl
+    ve_vl_vfmuld_vsvl,                         // llvm.ve.vl.vfmuld.vsvl
+    ve_vl_vfmuld_vsvmvl,                       // llvm.ve.vl.vfmuld.vsvmvl
+    ve_vl_vfmuld_vsvvl,                        // llvm.ve.vl.vfmuld.vsvvl
+    ve_vl_vfmuld_vvvl,                         // llvm.ve.vl.vfmuld.vvvl
+    ve_vl_vfmuld_vvvmvl,                       // llvm.ve.vl.vfmuld.vvvmvl
+    ve_vl_vfmuld_vvvvl,                        // llvm.ve.vl.vfmuld.vvvvl
+    ve_vl_vfmuls_vsvl,                         // llvm.ve.vl.vfmuls.vsvl
+    ve_vl_vfmuls_vsvmvl,                       // llvm.ve.vl.vfmuls.vsvmvl
+    ve_vl_vfmuls_vsvvl,                        // llvm.ve.vl.vfmuls.vsvvl
+    ve_vl_vfmuls_vvvl,                         // llvm.ve.vl.vfmuls.vvvl
+    ve_vl_vfmuls_vvvmvl,                       // llvm.ve.vl.vfmuls.vvvmvl
+    ve_vl_vfmuls_vvvvl,                        // llvm.ve.vl.vfmuls.vvvvl
+    ve_vl_vfnmadd_vsvvl,                       // llvm.ve.vl.vfnmadd.vsvvl
+    ve_vl_vfnmadd_vsvvmvl,                     // llvm.ve.vl.vfnmadd.vsvvmvl
+    ve_vl_vfnmadd_vsvvvl,                      // llvm.ve.vl.vfnmadd.vsvvvl
+    ve_vl_vfnmadd_vvsvl,                       // llvm.ve.vl.vfnmadd.vvsvl
+    ve_vl_vfnmadd_vvsvmvl,                     // llvm.ve.vl.vfnmadd.vvsvmvl
+    ve_vl_vfnmadd_vvsvvl,                      // llvm.ve.vl.vfnmadd.vvsvvl
+    ve_vl_vfnmadd_vvvvl,                       // llvm.ve.vl.vfnmadd.vvvvl
+    ve_vl_vfnmadd_vvvvmvl,                     // llvm.ve.vl.vfnmadd.vvvvmvl
+    ve_vl_vfnmadd_vvvvvl,                      // llvm.ve.vl.vfnmadd.vvvvvl
+    ve_vl_vfnmads_vsvvl,                       // llvm.ve.vl.vfnmads.vsvvl
+    ve_vl_vfnmads_vsvvmvl,                     // llvm.ve.vl.vfnmads.vsvvmvl
+    ve_vl_vfnmads_vsvvvl,                      // llvm.ve.vl.vfnmads.vsvvvl
+    ve_vl_vfnmads_vvsvl,                       // llvm.ve.vl.vfnmads.vvsvl
+    ve_vl_vfnmads_vvsvmvl,                     // llvm.ve.vl.vfnmads.vvsvmvl
+    ve_vl_vfnmads_vvsvvl,                      // llvm.ve.vl.vfnmads.vvsvvl
+    ve_vl_vfnmads_vvvvl,                       // llvm.ve.vl.vfnmads.vvvvl
+    ve_vl_vfnmads_vvvvmvl,                     // llvm.ve.vl.vfnmads.vvvvmvl
+    ve_vl_vfnmads_vvvvvl,                      // llvm.ve.vl.vfnmads.vvvvvl
+    ve_vl_vfnmsbd_vsvvl,                       // llvm.ve.vl.vfnmsbd.vsvvl
+    ve_vl_vfnmsbd_vsvvmvl,                     // llvm.ve.vl.vfnmsbd.vsvvmvl
+    ve_vl_vfnmsbd_vsvvvl,                      // llvm.ve.vl.vfnmsbd.vsvvvl
+    ve_vl_vfnmsbd_vvsvl,                       // llvm.ve.vl.vfnmsbd.vvsvl
+    ve_vl_vfnmsbd_vvsvmvl,                     // llvm.ve.vl.vfnmsbd.vvsvmvl
+    ve_vl_vfnmsbd_vvsvvl,                      // llvm.ve.vl.vfnmsbd.vvsvvl
+    ve_vl_vfnmsbd_vvvvl,                       // llvm.ve.vl.vfnmsbd.vvvvl
+    ve_vl_vfnmsbd_vvvvmvl,                     // llvm.ve.vl.vfnmsbd.vvvvmvl
+    ve_vl_vfnmsbd_vvvvvl,                      // llvm.ve.vl.vfnmsbd.vvvvvl
+    ve_vl_vfnmsbs_vsvvl,                       // llvm.ve.vl.vfnmsbs.vsvvl
+    ve_vl_vfnmsbs_vsvvmvl,                     // llvm.ve.vl.vfnmsbs.vsvvmvl
+    ve_vl_vfnmsbs_vsvvvl,                      // llvm.ve.vl.vfnmsbs.vsvvvl
+    ve_vl_vfnmsbs_vvsvl,                       // llvm.ve.vl.vfnmsbs.vvsvl
+    ve_vl_vfnmsbs_vvsvmvl,                     // llvm.ve.vl.vfnmsbs.vvsvmvl
+    ve_vl_vfnmsbs_vvsvvl,                      // llvm.ve.vl.vfnmsbs.vvsvvl
+    ve_vl_vfnmsbs_vvvvl,                       // llvm.ve.vl.vfnmsbs.vvvvl
+    ve_vl_vfnmsbs_vvvvmvl,                     // llvm.ve.vl.vfnmsbs.vvvvmvl
+    ve_vl_vfnmsbs_vvvvvl,                      // llvm.ve.vl.vfnmsbs.vvvvvl
+    ve_vl_vfrmaxdfst_vvl,                      // llvm.ve.vl.vfrmaxdfst.vvl
+    ve_vl_vfrmaxdfst_vvvl,                     // llvm.ve.vl.vfrmaxdfst.vvvl
+    ve_vl_vfrmaxdlst_vvl,                      // llvm.ve.vl.vfrmaxdlst.vvl
+    ve_vl_vfrmaxdlst_vvvl,                     // llvm.ve.vl.vfrmaxdlst.vvvl
+    ve_vl_vfrmaxsfst_vvl,                      // llvm.ve.vl.vfrmaxsfst.vvl
+    ve_vl_vfrmaxsfst_vvvl,                     // llvm.ve.vl.vfrmaxsfst.vvvl
+    ve_vl_vfrmaxslst_vvl,                      // llvm.ve.vl.vfrmaxslst.vvl
+    ve_vl_vfrmaxslst_vvvl,                     // llvm.ve.vl.vfrmaxslst.vvvl
+    ve_vl_vfrmindfst_vvl,                      // llvm.ve.vl.vfrmindfst.vvl
+    ve_vl_vfrmindfst_vvvl,                     // llvm.ve.vl.vfrmindfst.vvvl
+    ve_vl_vfrmindlst_vvl,                      // llvm.ve.vl.vfrmindlst.vvl
+    ve_vl_vfrmindlst_vvvl,                     // llvm.ve.vl.vfrmindlst.vvvl
+    ve_vl_vfrminsfst_vvl,                      // llvm.ve.vl.vfrminsfst.vvl
+    ve_vl_vfrminsfst_vvvl,                     // llvm.ve.vl.vfrminsfst.vvvl
+    ve_vl_vfrminslst_vvl,                      // llvm.ve.vl.vfrminslst.vvl
+    ve_vl_vfrminslst_vvvl,                     // llvm.ve.vl.vfrminslst.vvvl
+    ve_vl_vfsqrtd_vvl,                         // llvm.ve.vl.vfsqrtd.vvl
+    ve_vl_vfsqrtd_vvvl,                        // llvm.ve.vl.vfsqrtd.vvvl
+    ve_vl_vfsqrts_vvl,                         // llvm.ve.vl.vfsqrts.vvl
+    ve_vl_vfsqrts_vvvl,                        // llvm.ve.vl.vfsqrts.vvvl
+    ve_vl_vfsubd_vsvl,                         // llvm.ve.vl.vfsubd.vsvl
+    ve_vl_vfsubd_vsvmvl,                       // llvm.ve.vl.vfsubd.vsvmvl
+    ve_vl_vfsubd_vsvvl,                        // llvm.ve.vl.vfsubd.vsvvl
+    ve_vl_vfsubd_vvvl,                         // llvm.ve.vl.vfsubd.vvvl
+    ve_vl_vfsubd_vvvmvl,                       // llvm.ve.vl.vfsubd.vvvmvl
+    ve_vl_vfsubd_vvvvl,                        // llvm.ve.vl.vfsubd.vvvvl
+    ve_vl_vfsubs_vsvl,                         // llvm.ve.vl.vfsubs.vsvl
+    ve_vl_vfsubs_vsvmvl,                       // llvm.ve.vl.vfsubs.vsvmvl
+    ve_vl_vfsubs_vsvvl,                        // llvm.ve.vl.vfsubs.vsvvl
+    ve_vl_vfsubs_vvvl,                         // llvm.ve.vl.vfsubs.vvvl
+    ve_vl_vfsubs_vvvmvl,                       // llvm.ve.vl.vfsubs.vvvmvl
+    ve_vl_vfsubs_vvvvl,                        // llvm.ve.vl.vfsubs.vvvvl
+    ve_vl_vfsumd_vvl,                          // llvm.ve.vl.vfsumd.vvl
+    ve_vl_vfsumd_vvml,                         // llvm.ve.vl.vfsumd.vvml
+    ve_vl_vfsums_vvl,                          // llvm.ve.vl.vfsums.vvl
+    ve_vl_vfsums_vvml,                         // llvm.ve.vl.vfsums.vvml
+    ve_vl_vgt_vvssl,                           // llvm.ve.vl.vgt.vvssl
+    ve_vl_vgt_vvssml,                          // llvm.ve.vl.vgt.vvssml
+    ve_vl_vgt_vvssmvl,                         // llvm.ve.vl.vgt.vvssmvl
+    ve_vl_vgt_vvssvl,                          // llvm.ve.vl.vgt.vvssvl
+    ve_vl_vgtlsx_vvssl,                        // llvm.ve.vl.vgtlsx.vvssl
+    ve_vl_vgtlsx_vvssml,                       // llvm.ve.vl.vgtlsx.vvssml
+    ve_vl_vgtlsx_vvssmvl,                      // llvm.ve.vl.vgtlsx.vvssmvl
+    ve_vl_vgtlsx_vvssvl,                       // llvm.ve.vl.vgtlsx.vvssvl
+    ve_vl_vgtlsxnc_vvssl,                      // llvm.ve.vl.vgtlsxnc.vvssl
+    ve_vl_vgtlsxnc_vvssml,                     // llvm.ve.vl.vgtlsxnc.vvssml
+    ve_vl_vgtlsxnc_vvssmvl,                    // llvm.ve.vl.vgtlsxnc.vvssmvl
+    ve_vl_vgtlsxnc_vvssvl,                     // llvm.ve.vl.vgtlsxnc.vvssvl
+    ve_vl_vgtlzx_vvssl,                        // llvm.ve.vl.vgtlzx.vvssl
+    ve_vl_vgtlzx_vvssml,                       // llvm.ve.vl.vgtlzx.vvssml
+    ve_vl_vgtlzx_vvssmvl,                      // llvm.ve.vl.vgtlzx.vvssmvl
+    ve_vl_vgtlzx_vvssvl,                       // llvm.ve.vl.vgtlzx.vvssvl
+    ve_vl_vgtlzxnc_vvssl,                      // llvm.ve.vl.vgtlzxnc.vvssl
+    ve_vl_vgtlzxnc_vvssml,                     // llvm.ve.vl.vgtlzxnc.vvssml
+    ve_vl_vgtlzxnc_vvssmvl,                    // llvm.ve.vl.vgtlzxnc.vvssmvl
+    ve_vl_vgtlzxnc_vvssvl,                     // llvm.ve.vl.vgtlzxnc.vvssvl
+    ve_vl_vgtnc_vvssl,                         // llvm.ve.vl.vgtnc.vvssl
+    ve_vl_vgtnc_vvssml,                        // llvm.ve.vl.vgtnc.vvssml
+    ve_vl_vgtnc_vvssmvl,                       // llvm.ve.vl.vgtnc.vvssmvl
+    ve_vl_vgtnc_vvssvl,                        // llvm.ve.vl.vgtnc.vvssvl
+    ve_vl_vgtu_vvssl,                          // llvm.ve.vl.vgtu.vvssl
+    ve_vl_vgtu_vvssml,                         // llvm.ve.vl.vgtu.vvssml
+    ve_vl_vgtu_vvssmvl,                        // llvm.ve.vl.vgtu.vvssmvl
+    ve_vl_vgtu_vvssvl,                         // llvm.ve.vl.vgtu.vvssvl
+    ve_vl_vgtunc_vvssl,                        // llvm.ve.vl.vgtunc.vvssl
+    ve_vl_vgtunc_vvssml,                       // llvm.ve.vl.vgtunc.vvssml
+    ve_vl_vgtunc_vvssmvl,                      // llvm.ve.vl.vgtunc.vvssmvl
+    ve_vl_vgtunc_vvssvl,                       // llvm.ve.vl.vgtunc.vvssvl
+    ve_vl_vld_vssl,                            // llvm.ve.vl.vld.vssl
+    ve_vl_vld_vssvl,                           // llvm.ve.vl.vld.vssvl
+    ve_vl_vld2d_vssl,                          // llvm.ve.vl.vld2d.vssl
+    ve_vl_vld2d_vssvl,                         // llvm.ve.vl.vld2d.vssvl
+    ve_vl_vld2dnc_vssl,                        // llvm.ve.vl.vld2dnc.vssl
+    ve_vl_vld2dnc_vssvl,                       // llvm.ve.vl.vld2dnc.vssvl
+    ve_vl_vldl2dsx_vssl,                       // llvm.ve.vl.vldl2dsx.vssl
+    ve_vl_vldl2dsx_vssvl,                      // llvm.ve.vl.vldl2dsx.vssvl
+    ve_vl_vldl2dsxnc_vssl,                     // llvm.ve.vl.vldl2dsxnc.vssl
+    ve_vl_vldl2dsxnc_vssvl,                    // llvm.ve.vl.vldl2dsxnc.vssvl
+    ve_vl_vldl2dzx_vssl,                       // llvm.ve.vl.vldl2dzx.vssl
+    ve_vl_vldl2dzx_vssvl,                      // llvm.ve.vl.vldl2dzx.vssvl
+    ve_vl_vldl2dzxnc_vssl,                     // llvm.ve.vl.vldl2dzxnc.vssl
+    ve_vl_vldl2dzxnc_vssvl,                    // llvm.ve.vl.vldl2dzxnc.vssvl
+    ve_vl_vldlsx_vssl,                         // llvm.ve.vl.vldlsx.vssl
+    ve_vl_vldlsx_vssvl,                        // llvm.ve.vl.vldlsx.vssvl
+    ve_vl_vldlsxnc_vssl,                       // llvm.ve.vl.vldlsxnc.vssl
+    ve_vl_vldlsxnc_vssvl,                      // llvm.ve.vl.vldlsxnc.vssvl
+    ve_vl_vldlzx_vssl,                         // llvm.ve.vl.vldlzx.vssl
+    ve_vl_vldlzx_vssvl,                        // llvm.ve.vl.vldlzx.vssvl
+    ve_vl_vldlzxnc_vssl,                       // llvm.ve.vl.vldlzxnc.vssl
+    ve_vl_vldlzxnc_vssvl,                      // llvm.ve.vl.vldlzxnc.vssvl
+    ve_vl_vldnc_vssl,                          // llvm.ve.vl.vldnc.vssl
+    ve_vl_vldnc_vssvl,                         // llvm.ve.vl.vldnc.vssvl
+    ve_vl_vldu_vssl,                           // llvm.ve.vl.vldu.vssl
+    ve_vl_vldu_vssvl,                          // llvm.ve.vl.vldu.vssvl
+    ve_vl_vldu2d_vssl,                         // llvm.ve.vl.vldu2d.vssl
+    ve_vl_vldu2d_vssvl,                        // llvm.ve.vl.vldu2d.vssvl
+    ve_vl_vldu2dnc_vssl,                       // llvm.ve.vl.vldu2dnc.vssl
+    ve_vl_vldu2dnc_vssvl,                      // llvm.ve.vl.vldu2dnc.vssvl
+    ve_vl_vldunc_vssl,                         // llvm.ve.vl.vldunc.vssl
+    ve_vl_vldunc_vssvl,                        // llvm.ve.vl.vldunc.vssvl
+    ve_vl_vmaxsl_vsvl,                         // llvm.ve.vl.vmaxsl.vsvl
+    ve_vl_vmaxsl_vsvmvl,                       // llvm.ve.vl.vmaxsl.vsvmvl
+    ve_vl_vmaxsl_vsvvl,                        // llvm.ve.vl.vmaxsl.vsvvl
+    ve_vl_vmaxsl_vvvl,                         // llvm.ve.vl.vmaxsl.vvvl
+    ve_vl_vmaxsl_vvvmvl,                       // llvm.ve.vl.vmaxsl.vvvmvl
+    ve_vl_vmaxsl_vvvvl,                        // llvm.ve.vl.vmaxsl.vvvvl
+    ve_vl_vmaxswsx_vsvl,                       // llvm.ve.vl.vmaxswsx.vsvl
+    ve_vl_vmaxswsx_vsvmvl,                     // llvm.ve.vl.vmaxswsx.vsvmvl
+    ve_vl_vmaxswsx_vsvvl,                      // llvm.ve.vl.vmaxswsx.vsvvl
+    ve_vl_vmaxswsx_vvvl,                       // llvm.ve.vl.vmaxswsx.vvvl
+    ve_vl_vmaxswsx_vvvmvl,                     // llvm.ve.vl.vmaxswsx.vvvmvl
+    ve_vl_vmaxswsx_vvvvl,                      // llvm.ve.vl.vmaxswsx.vvvvl
+    ve_vl_vmaxswzx_vsvl,                       // llvm.ve.vl.vmaxswzx.vsvl
+    ve_vl_vmaxswzx_vsvmvl,                     // llvm.ve.vl.vmaxswzx.vsvmvl
+    ve_vl_vmaxswzx_vsvvl,                      // llvm.ve.vl.vmaxswzx.vsvvl
+    ve_vl_vmaxswzx_vvvl,                       // llvm.ve.vl.vmaxswzx.vvvl
+    ve_vl_vmaxswzx_vvvmvl,                     // llvm.ve.vl.vmaxswzx.vvvmvl
+    ve_vl_vmaxswzx_vvvvl,                      // llvm.ve.vl.vmaxswzx.vvvvl
+    ve_vl_vminsl_vsvl,                         // llvm.ve.vl.vminsl.vsvl
+    ve_vl_vminsl_vsvmvl,                       // llvm.ve.vl.vminsl.vsvmvl
+    ve_vl_vminsl_vsvvl,                        // llvm.ve.vl.vminsl.vsvvl
+    ve_vl_vminsl_vvvl,                         // llvm.ve.vl.vminsl.vvvl
+    ve_vl_vminsl_vvvmvl,                       // llvm.ve.vl.vminsl.vvvmvl
+    ve_vl_vminsl_vvvvl,                        // llvm.ve.vl.vminsl.vvvvl
+    ve_vl_vminswsx_vsvl,                       // llvm.ve.vl.vminswsx.vsvl
+    ve_vl_vminswsx_vsvmvl,                     // llvm.ve.vl.vminswsx.vsvmvl
+    ve_vl_vminswsx_vsvvl,                      // llvm.ve.vl.vminswsx.vsvvl
+    ve_vl_vminswsx_vvvl,                       // llvm.ve.vl.vminswsx.vvvl
+    ve_vl_vminswsx_vvvmvl,                     // llvm.ve.vl.vminswsx.vvvmvl
+    ve_vl_vminswsx_vvvvl,                      // llvm.ve.vl.vminswsx.vvvvl
+    ve_vl_vminswzx_vsvl,                       // llvm.ve.vl.vminswzx.vsvl
+    ve_vl_vminswzx_vsvmvl,                     // llvm.ve.vl.vminswzx.vsvmvl
+    ve_vl_vminswzx_vsvvl,                      // llvm.ve.vl.vminswzx.vsvvl
+    ve_vl_vminswzx_vvvl,                       // llvm.ve.vl.vminswzx.vvvl
+    ve_vl_vminswzx_vvvmvl,                     // llvm.ve.vl.vminswzx.vvvmvl
+    ve_vl_vminswzx_vvvvl,                      // llvm.ve.vl.vminswzx.vvvvl
+    ve_vl_vmrg_vsvml,                          // llvm.ve.vl.vmrg.vsvml
+    ve_vl_vmrg_vsvmvl,                         // llvm.ve.vl.vmrg.vsvmvl
+    ve_vl_vmrg_vvvml,                          // llvm.ve.vl.vmrg.vvvml
+    ve_vl_vmrg_vvvmvl,                         // llvm.ve.vl.vmrg.vvvmvl
+    ve_vl_vmrgw_vsvMl,                         // llvm.ve.vl.vmrgw.vsvMl
+    ve_vl_vmrgw_vsvMvl,                        // llvm.ve.vl.vmrgw.vsvMvl
+    ve_vl_vmrgw_vvvMl,                         // llvm.ve.vl.vmrgw.vvvMl
+    ve_vl_vmrgw_vvvMvl,                        // llvm.ve.vl.vmrgw.vvvMvl
+    ve_vl_vmulsl_vsvl,                         // llvm.ve.vl.vmulsl.vsvl
+    ve_vl_vmulsl_vsvmvl,                       // llvm.ve.vl.vmulsl.vsvmvl
+    ve_vl_vmulsl_vsvvl,                        // llvm.ve.vl.vmulsl.vsvvl
+    ve_vl_vmulsl_vvvl,                         // llvm.ve.vl.vmulsl.vvvl
+    ve_vl_vmulsl_vvvmvl,                       // llvm.ve.vl.vmulsl.vvvmvl
+    ve_vl_vmulsl_vvvvl,                        // llvm.ve.vl.vmulsl.vvvvl
+    ve_vl_vmulslw_vsvl,                        // llvm.ve.vl.vmulslw.vsvl
+    ve_vl_vmulslw_vsvvl,                       // llvm.ve.vl.vmulslw.vsvvl
+    ve_vl_vmulslw_vvvl,                        // llvm.ve.vl.vmulslw.vvvl
+    ve_vl_vmulslw_vvvvl,                       // llvm.ve.vl.vmulslw.vvvvl
+    ve_vl_vmulswsx_vsvl,                       // llvm.ve.vl.vmulswsx.vsvl
+    ve_vl_vmulswsx_vsvmvl,                     // llvm.ve.vl.vmulswsx.vsvmvl
+    ve_vl_vmulswsx_vsvvl,                      // llvm.ve.vl.vmulswsx.vsvvl
+    ve_vl_vmulswsx_vvvl,                       // llvm.ve.vl.vmulswsx.vvvl
+    ve_vl_vmulswsx_vvvmvl,                     // llvm.ve.vl.vmulswsx.vvvmvl
+    ve_vl_vmulswsx_vvvvl,                      // llvm.ve.vl.vmulswsx.vvvvl
+    ve_vl_vmulswzx_vsvl,                       // llvm.ve.vl.vmulswzx.vsvl
+    ve_vl_vmulswzx_vsvmvl,                     // llvm.ve.vl.vmulswzx.vsvmvl
+    ve_vl_vmulswzx_vsvvl,                      // llvm.ve.vl.vmulswzx.vsvvl
+    ve_vl_vmulswzx_vvvl,                       // llvm.ve.vl.vmulswzx.vvvl
+    ve_vl_vmulswzx_vvvmvl,                     // llvm.ve.vl.vmulswzx.vvvmvl
+    ve_vl_vmulswzx_vvvvl,                      // llvm.ve.vl.vmulswzx.vvvvl
+    ve_vl_vmulul_vsvl,                         // llvm.ve.vl.vmulul.vsvl
+    ve_vl_vmulul_vsvmvl,                       // llvm.ve.vl.vmulul.vsvmvl
+    ve_vl_vmulul_vsvvl,                        // llvm.ve.vl.vmulul.vsvvl
+    ve_vl_vmulul_vvvl,                         // llvm.ve.vl.vmulul.vvvl
+    ve_vl_vmulul_vvvmvl,                       // llvm.ve.vl.vmulul.vvvmvl
+    ve_vl_vmulul_vvvvl,                        // llvm.ve.vl.vmulul.vvvvl
+    ve_vl_vmuluw_vsvl,                         // llvm.ve.vl.vmuluw.vsvl
+    ve_vl_vmuluw_vsvmvl,                       // llvm.ve.vl.vmuluw.vsvmvl
+    ve_vl_vmuluw_vsvvl,                        // llvm.ve.vl.vmuluw.vsvvl
+    ve_vl_vmuluw_vvvl,                         // llvm.ve.vl.vmuluw.vvvl
+    ve_vl_vmuluw_vvvmvl,                       // llvm.ve.vl.vmuluw.vvvmvl
+    ve_vl_vmuluw_vvvvl,                        // llvm.ve.vl.vmuluw.vvvvl
+    ve_vl_vmv_vsvl,                            // llvm.ve.vl.vmv.vsvl
+    ve_vl_vmv_vsvmvl,                          // llvm.ve.vl.vmv.vsvmvl
+    ve_vl_vmv_vsvvl,                           // llvm.ve.vl.vmv.vsvvl
+    ve_vl_vor_vsvl,                            // llvm.ve.vl.vor.vsvl
+    ve_vl_vor_vsvmvl,                          // llvm.ve.vl.vor.vsvmvl
+    ve_vl_vor_vsvvl,                           // llvm.ve.vl.vor.vsvvl
+    ve_vl_vor_vvvl,                            // llvm.ve.vl.vor.vvvl
+    ve_vl_vor_vvvmvl,                          // llvm.ve.vl.vor.vvvmvl
+    ve_vl_vor_vvvvl,                           // llvm.ve.vl.vor.vvvvl
+    ve_vl_vrand_vvl,                           // llvm.ve.vl.vrand.vvl
+    ve_vl_vrand_vvml,                          // llvm.ve.vl.vrand.vvml
+    ve_vl_vrcpd_vvl,                           // llvm.ve.vl.vrcpd.vvl
+    ve_vl_vrcpd_vvvl,                          // llvm.ve.vl.vrcpd.vvvl
+    ve_vl_vrcps_vvl,                           // llvm.ve.vl.vrcps.vvl
+    ve_vl_vrcps_vvvl,                          // llvm.ve.vl.vrcps.vvvl
+    ve_vl_vrmaxslfst_vvl,                      // llvm.ve.vl.vrmaxslfst.vvl
+    ve_vl_vrmaxslfst_vvvl,                     // llvm.ve.vl.vrmaxslfst.vvvl
+    ve_vl_vrmaxsllst_vvl,                      // llvm.ve.vl.vrmaxsllst.vvl
+    ve_vl_vrmaxsllst_vvvl,                     // llvm.ve.vl.vrmaxsllst.vvvl
+    ve_vl_vrmaxswfstsx_vvl,                    // llvm.ve.vl.vrmaxswfstsx.vvl
+    ve_vl_vrmaxswfstsx_vvvl,                   // llvm.ve.vl.vrmaxswfstsx.vvvl
+    ve_vl_vrmaxswfstzx_vvl,                    // llvm.ve.vl.vrmaxswfstzx.vvl
+    ve_vl_vrmaxswfstzx_vvvl,                   // llvm.ve.vl.vrmaxswfstzx.vvvl
+    ve_vl_vrmaxswlstsx_vvl,                    // llvm.ve.vl.vrmaxswlstsx.vvl
+    ve_vl_vrmaxswlstsx_vvvl,                   // llvm.ve.vl.vrmaxswlstsx.vvvl
+    ve_vl_vrmaxswlstzx_vvl,                    // llvm.ve.vl.vrmaxswlstzx.vvl
+    ve_vl_vrmaxswlstzx_vvvl,                   // llvm.ve.vl.vrmaxswlstzx.vvvl
+    ve_vl_vrminslfst_vvl,                      // llvm.ve.vl.vrminslfst.vvl
+    ve_vl_vrminslfst_vvvl,                     // llvm.ve.vl.vrminslfst.vvvl
+    ve_vl_vrminsllst_vvl,                      // llvm.ve.vl.vrminsllst.vvl
+    ve_vl_vrminsllst_vvvl,                     // llvm.ve.vl.vrminsllst.vvvl
+    ve_vl_vrminswfstsx_vvl,                    // llvm.ve.vl.vrminswfstsx.vvl
+    ve_vl_vrminswfstsx_vvvl,                   // llvm.ve.vl.vrminswfstsx.vvvl
+    ve_vl_vrminswfstzx_vvl,                    // llvm.ve.vl.vrminswfstzx.vvl
+    ve_vl_vrminswfstzx_vvvl,                   // llvm.ve.vl.vrminswfstzx.vvvl
+    ve_vl_vrminswlstsx_vvl,                    // llvm.ve.vl.vrminswlstsx.vvl
+    ve_vl_vrminswlstsx_vvvl,                   // llvm.ve.vl.vrminswlstsx.vvvl
+    ve_vl_vrminswlstzx_vvl,                    // llvm.ve.vl.vrminswlstzx.vvl
+    ve_vl_vrminswlstzx_vvvl,                   // llvm.ve.vl.vrminswlstzx.vvvl
+    ve_vl_vror_vvl,                            // llvm.ve.vl.vror.vvl
+    ve_vl_vror_vvml,                           // llvm.ve.vl.vror.vvml
+    ve_vl_vrsqrtd_vvl,                         // llvm.ve.vl.vrsqrtd.vvl
+    ve_vl_vrsqrtd_vvvl,                        // llvm.ve.vl.vrsqrtd.vvvl
+    ve_vl_vrsqrtdnex_vvl,                      // llvm.ve.vl.vrsqrtdnex.vvl
+    ve_vl_vrsqrtdnex_vvvl,                     // llvm.ve.vl.vrsqrtdnex.vvvl
+    ve_vl_vrsqrts_vvl,                         // llvm.ve.vl.vrsqrts.vvl
+    ve_vl_vrsqrts_vvvl,                        // llvm.ve.vl.vrsqrts.vvvl
+    ve_vl_vrsqrtsnex_vvl,                      // llvm.ve.vl.vrsqrtsnex.vvl
+    ve_vl_vrsqrtsnex_vvvl,                     // llvm.ve.vl.vrsqrtsnex.vvvl
+    ve_vl_vrxor_vvl,                           // llvm.ve.vl.vrxor.vvl
+    ve_vl_vrxor_vvml,                          // llvm.ve.vl.vrxor.vvml
+    ve_vl_vsc_vvssl,                           // llvm.ve.vl.vsc.vvssl
+    ve_vl_vsc_vvssml,                          // llvm.ve.vl.vsc.vvssml
+    ve_vl_vscl_vvssl,                          // llvm.ve.vl.vscl.vvssl
+    ve_vl_vscl_vvssml,                         // llvm.ve.vl.vscl.vvssml
+    ve_vl_vsclnc_vvssl,                        // llvm.ve.vl.vsclnc.vvssl
+    ve_vl_vsclnc_vvssml,                       // llvm.ve.vl.vsclnc.vvssml
+    ve_vl_vsclncot_vvssl,                      // llvm.ve.vl.vsclncot.vvssl
+    ve_vl_vsclncot_vvssml,                     // llvm.ve.vl.vsclncot.vvssml
+    ve_vl_vsclot_vvssl,                        // llvm.ve.vl.vsclot.vvssl
+    ve_vl_vsclot_vvssml,                       // llvm.ve.vl.vsclot.vvssml
+    ve_vl_vscnc_vvssl,                         // llvm.ve.vl.vscnc.vvssl
+    ve_vl_vscnc_vvssml,                        // llvm.ve.vl.vscnc.vvssml
+    ve_vl_vscncot_vvssl,                       // llvm.ve.vl.vscncot.vvssl
+    ve_vl_vscncot_vvssml,                      // llvm.ve.vl.vscncot.vvssml
+    ve_vl_vscot_vvssl,                         // llvm.ve.vl.vscot.vvssl
+    ve_vl_vscot_vvssml,                        // llvm.ve.vl.vscot.vvssml
+    ve_vl_vscu_vvssl,                          // llvm.ve.vl.vscu.vvssl
+    ve_vl_vscu_vvssml,                         // llvm.ve.vl.vscu.vvssml
+    ve_vl_vscunc_vvssl,                        // llvm.ve.vl.vscunc.vvssl
+    ve_vl_vscunc_vvssml,                       // llvm.ve.vl.vscunc.vvssml
+    ve_vl_vscuncot_vvssl,                      // llvm.ve.vl.vscuncot.vvssl
+    ve_vl_vscuncot_vvssml,                     // llvm.ve.vl.vscuncot.vvssml
+    ve_vl_vscuot_vvssl,                        // llvm.ve.vl.vscuot.vvssl
+    ve_vl_vscuot_vvssml,                       // llvm.ve.vl.vscuot.vvssml
+    ve_vl_vseq_vl,                             // llvm.ve.vl.vseq.vl
+    ve_vl_vseq_vvl,                            // llvm.ve.vl.vseq.vvl
+    ve_vl_vsfa_vvssl,                          // llvm.ve.vl.vsfa.vvssl
+    ve_vl_vsfa_vvssmvl,                        // llvm.ve.vl.vsfa.vvssmvl
+    ve_vl_vsfa_vvssvl,                         // llvm.ve.vl.vsfa.vvssvl
+    ve_vl_vshf_vvvsl,                          // llvm.ve.vl.vshf.vvvsl
+    ve_vl_vshf_vvvsvl,                         // llvm.ve.vl.vshf.vvvsvl
+    ve_vl_vslal_vvsl,                          // llvm.ve.vl.vslal.vvsl
+    ve_vl_vslal_vvsmvl,                        // llvm.ve.vl.vslal.vvsmvl
+    ve_vl_vslal_vvsvl,                         // llvm.ve.vl.vslal.vvsvl
+    ve_vl_vslal_vvvl,                          // llvm.ve.vl.vslal.vvvl
+    ve_vl_vslal_vvvmvl,                        // llvm.ve.vl.vslal.vvvmvl
+    ve_vl_vslal_vvvvl,                         // llvm.ve.vl.vslal.vvvvl
+    ve_vl_vslawsx_vvsl,                        // llvm.ve.vl.vslawsx.vvsl
+    ve_vl_vslawsx_vvsmvl,                      // llvm.ve.vl.vslawsx.vvsmvl
+    ve_vl_vslawsx_vvsvl,                       // llvm.ve.vl.vslawsx.vvsvl
+    ve_vl_vslawsx_vvvl,                        // llvm.ve.vl.vslawsx.vvvl
+    ve_vl_vslawsx_vvvmvl,                      // llvm.ve.vl.vslawsx.vvvmvl
+    ve_vl_vslawsx_vvvvl,                       // llvm.ve.vl.vslawsx.vvvvl
+    ve_vl_vslawzx_vvsl,                        // llvm.ve.vl.vslawzx.vvsl
+    ve_vl_vslawzx_vvsmvl,                      // llvm.ve.vl.vslawzx.vvsmvl
+    ve_vl_vslawzx_vvsvl,                       // llvm.ve.vl.vslawzx.vvsvl
+    ve_vl_vslawzx_vvvl,                        // llvm.ve.vl.vslawzx.vvvl
+    ve_vl_vslawzx_vvvmvl,                      // llvm.ve.vl.vslawzx.vvvmvl
+    ve_vl_vslawzx_vvvvl,                       // llvm.ve.vl.vslawzx.vvvvl
+    ve_vl_vsll_vvsl,                           // llvm.ve.vl.vsll.vvsl
+    ve_vl_vsll_vvsmvl,                         // llvm.ve.vl.vsll.vvsmvl
+    ve_vl_vsll_vvsvl,                          // llvm.ve.vl.vsll.vvsvl
+    ve_vl_vsll_vvvl,                           // llvm.ve.vl.vsll.vvvl
+    ve_vl_vsll_vvvmvl,                         // llvm.ve.vl.vsll.vvvmvl
+    ve_vl_vsll_vvvvl,                          // llvm.ve.vl.vsll.vvvvl
+    ve_vl_vsral_vvsl,                          // llvm.ve.vl.vsral.vvsl
+    ve_vl_vsral_vvsmvl,                        // llvm.ve.vl.vsral.vvsmvl
+    ve_vl_vsral_vvsvl,                         // llvm.ve.vl.vsral.vvsvl
+    ve_vl_vsral_vvvl,                          // llvm.ve.vl.vsral.vvvl
+    ve_vl_vsral_vvvmvl,                        // llvm.ve.vl.vsral.vvvmvl
+    ve_vl_vsral_vvvvl,                         // llvm.ve.vl.vsral.vvvvl
+    ve_vl_vsrawsx_vvsl,                        // llvm.ve.vl.vsrawsx.vvsl
+    ve_vl_vsrawsx_vvsmvl,                      // llvm.ve.vl.vsrawsx.vvsmvl
+    ve_vl_vsrawsx_vvsvl,                       // llvm.ve.vl.vsrawsx.vvsvl
+    ve_vl_vsrawsx_vvvl,                        // llvm.ve.vl.vsrawsx.vvvl
+    ve_vl_vsrawsx_vvvmvl,                      // llvm.ve.vl.vsrawsx.vvvmvl
+    ve_vl_vsrawsx_vvvvl,                       // llvm.ve.vl.vsrawsx.vvvvl
+    ve_vl_vsrawzx_vvsl,                        // llvm.ve.vl.vsrawzx.vvsl
+    ve_vl_vsrawzx_vvsmvl,                      // llvm.ve.vl.vsrawzx.vvsmvl
+    ve_vl_vsrawzx_vvsvl,                       // llvm.ve.vl.vsrawzx.vvsvl
+    ve_vl_vsrawzx_vvvl,                        // llvm.ve.vl.vsrawzx.vvvl
+    ve_vl_vsrawzx_vvvmvl,                      // llvm.ve.vl.vsrawzx.vvvmvl
+    ve_vl_vsrawzx_vvvvl,                       // llvm.ve.vl.vsrawzx.vvvvl
+    ve_vl_vsrl_vvsl,                           // llvm.ve.vl.vsrl.vvsl
+    ve_vl_vsrl_vvsmvl,                         // llvm.ve.vl.vsrl.vvsmvl
+    ve_vl_vsrl_vvsvl,                          // llvm.ve.vl.vsrl.vvsvl
+    ve_vl_vsrl_vvvl,                           // llvm.ve.vl.vsrl.vvvl
+    ve_vl_vsrl_vvvmvl,                         // llvm.ve.vl.vsrl.vvvmvl
+    ve_vl_vsrl_vvvvl,                          // llvm.ve.vl.vsrl.vvvvl
+    ve_vl_vst_vssl,                            // llvm.ve.vl.vst.vssl
+    ve_vl_vst_vssml,                           // llvm.ve.vl.vst.vssml
+    ve_vl_vst2d_vssl,                          // llvm.ve.vl.vst2d.vssl
+    ve_vl_vst2d_vssml,                         // llvm.ve.vl.vst2d.vssml
+    ve_vl_vst2dnc_vssl,                        // llvm.ve.vl.vst2dnc.vssl
+    ve_vl_vst2dnc_vssml,                       // llvm.ve.vl.vst2dnc.vssml
+    ve_vl_vst2dncot_vssl,                      // llvm.ve.vl.vst2dncot.vssl
+    ve_vl_vst2dncot_vssml,                     // llvm.ve.vl.vst2dncot.vssml
+    ve_vl_vst2dot_vssl,                        // llvm.ve.vl.vst2dot.vssl
+    ve_vl_vst2dot_vssml,                       // llvm.ve.vl.vst2dot.vssml
+    ve_vl_vstl_vssl,                           // llvm.ve.vl.vstl.vssl
+    ve_vl_vstl_vssml,                          // llvm.ve.vl.vstl.vssml
+    ve_vl_vstl2d_vssl,                         // llvm.ve.vl.vstl2d.vssl
+    ve_vl_vstl2d_vssml,                        // llvm.ve.vl.vstl2d.vssml
+    ve_vl_vstl2dnc_vssl,                       // llvm.ve.vl.vstl2dnc.vssl
+    ve_vl_vstl2dnc_vssml,                      // llvm.ve.vl.vstl2dnc.vssml
+    ve_vl_vstl2dncot_vssl,                     // llvm.ve.vl.vstl2dncot.vssl
+    ve_vl_vstl2dncot_vssml,                    // llvm.ve.vl.vstl2dncot.vssml
+    ve_vl_vstl2dot_vssl,                       // llvm.ve.vl.vstl2dot.vssl
+    ve_vl_vstl2dot_vssml,                      // llvm.ve.vl.vstl2dot.vssml
+    ve_vl_vstlnc_vssl,                         // llvm.ve.vl.vstlnc.vssl
+    ve_vl_vstlnc_vssml,                        // llvm.ve.vl.vstlnc.vssml
+    ve_vl_vstlncot_vssl,                       // llvm.ve.vl.vstlncot.vssl
+    ve_vl_vstlncot_vssml,                      // llvm.ve.vl.vstlncot.vssml
+    ve_vl_vstlot_vssl,                         // llvm.ve.vl.vstlot.vssl
+    ve_vl_vstlot_vssml,                        // llvm.ve.vl.vstlot.vssml
+    ve_vl_vstnc_vssl,                          // llvm.ve.vl.vstnc.vssl
+    ve_vl_vstnc_vssml,                         // llvm.ve.vl.vstnc.vssml
+    ve_vl_vstncot_vssl,                        // llvm.ve.vl.vstncot.vssl
+    ve_vl_vstncot_vssml,                       // llvm.ve.vl.vstncot.vssml
+    ve_vl_vstot_vssl,                          // llvm.ve.vl.vstot.vssl
+    ve_vl_vstot_vssml,                         // llvm.ve.vl.vstot.vssml
+    ve_vl_vstu_vssl,                           // llvm.ve.vl.vstu.vssl
+    ve_vl_vstu_vssml,                          // llvm.ve.vl.vstu.vssml
+    ve_vl_vstu2d_vssl,                         // llvm.ve.vl.vstu2d.vssl
+    ve_vl_vstu2d_vssml,                        // llvm.ve.vl.vstu2d.vssml
+    ve_vl_vstu2dnc_vssl,                       // llvm.ve.vl.vstu2dnc.vssl
+    ve_vl_vstu2dnc_vssml,                      // llvm.ve.vl.vstu2dnc.vssml
+    ve_vl_vstu2dncot_vssl,                     // llvm.ve.vl.vstu2dncot.vssl
+    ve_vl_vstu2dncot_vssml,                    // llvm.ve.vl.vstu2dncot.vssml
+    ve_vl_vstu2dot_vssl,                       // llvm.ve.vl.vstu2dot.vssl
+    ve_vl_vstu2dot_vssml,                      // llvm.ve.vl.vstu2dot.vssml
+    ve_vl_vstunc_vssl,                         // llvm.ve.vl.vstunc.vssl
+    ve_vl_vstunc_vssml,                        // llvm.ve.vl.vstunc.vssml
+    ve_vl_vstuncot_vssl,                       // llvm.ve.vl.vstuncot.vssl
+    ve_vl_vstuncot_vssml,                      // llvm.ve.vl.vstuncot.vssml
+    ve_vl_vstuot_vssl,                         // llvm.ve.vl.vstuot.vssl
+    ve_vl_vstuot_vssml,                        // llvm.ve.vl.vstuot.vssml
+    ve_vl_vsubsl_vsvl,                         // llvm.ve.vl.vsubsl.vsvl
+    ve_vl_vsubsl_vsvmvl,                       // llvm.ve.vl.vsubsl.vsvmvl
+    ve_vl_vsubsl_vsvvl,                        // llvm.ve.vl.vsubsl.vsvvl
+    ve_vl_vsubsl_vvvl,                         // llvm.ve.vl.vsubsl.vvvl
+    ve_vl_vsubsl_vvvmvl,                       // llvm.ve.vl.vsubsl.vvvmvl
+    ve_vl_vsubsl_vvvvl,                        // llvm.ve.vl.vsubsl.vvvvl
+    ve_vl_vsubswsx_vsvl,                       // llvm.ve.vl.vsubswsx.vsvl
+    ve_vl_vsubswsx_vsvmvl,                     // llvm.ve.vl.vsubswsx.vsvmvl
+    ve_vl_vsubswsx_vsvvl,                      // llvm.ve.vl.vsubswsx.vsvvl
+    ve_vl_vsubswsx_vvvl,                       // llvm.ve.vl.vsubswsx.vvvl
+    ve_vl_vsubswsx_vvvmvl,                     // llvm.ve.vl.vsubswsx.vvvmvl
+    ve_vl_vsubswsx_vvvvl,                      // llvm.ve.vl.vsubswsx.vvvvl
+    ve_vl_vsubswzx_vsvl,                       // llvm.ve.vl.vsubswzx.vsvl
+    ve_vl_vsubswzx_vsvmvl,                     // llvm.ve.vl.vsubswzx.vsvmvl
+    ve_vl_vsubswzx_vsvvl,                      // llvm.ve.vl.vsubswzx.vsvvl
+    ve_vl_vsubswzx_vvvl,                       // llvm.ve.vl.vsubswzx.vvvl
+    ve_vl_vsubswzx_vvvmvl,                     // llvm.ve.vl.vsubswzx.vvvmvl
+    ve_vl_vsubswzx_vvvvl,                      // llvm.ve.vl.vsubswzx.vvvvl
+    ve_vl_vsubul_vsvl,                         // llvm.ve.vl.vsubul.vsvl
+    ve_vl_vsubul_vsvmvl,                       // llvm.ve.vl.vsubul.vsvmvl
+    ve_vl_vsubul_vsvvl,                        // llvm.ve.vl.vsubul.vsvvl
+    ve_vl_vsubul_vvvl,                         // llvm.ve.vl.vsubul.vvvl
+    ve_vl_vsubul_vvvmvl,                       // llvm.ve.vl.vsubul.vvvmvl
+    ve_vl_vsubul_vvvvl,                        // llvm.ve.vl.vsubul.vvvvl
+    ve_vl_vsubuw_vsvl,                         // llvm.ve.vl.vsubuw.vsvl
+    ve_vl_vsubuw_vsvmvl,                       // llvm.ve.vl.vsubuw.vsvmvl
+    ve_vl_vsubuw_vsvvl,                        // llvm.ve.vl.vsubuw.vsvvl
+    ve_vl_vsubuw_vvvl,                         // llvm.ve.vl.vsubuw.vvvl
+    ve_vl_vsubuw_vvvmvl,                       // llvm.ve.vl.vsubuw.vvvmvl
+    ve_vl_vsubuw_vvvvl,                        // llvm.ve.vl.vsubuw.vvvvl
+    ve_vl_vsuml_vvl,                           // llvm.ve.vl.vsuml.vvl
+    ve_vl_vsuml_vvml,                          // llvm.ve.vl.vsuml.vvml
+    ve_vl_vsumwsx_vvl,                         // llvm.ve.vl.vsumwsx.vvl
+    ve_vl_vsumwsx_vvml,                        // llvm.ve.vl.vsumwsx.vvml
+    ve_vl_vsumwzx_vvl,                         // llvm.ve.vl.vsumwzx.vvl
+    ve_vl_vsumwzx_vvml,                        // llvm.ve.vl.vsumwzx.vvml
+    ve_vl_vxor_vsvl,                           // llvm.ve.vl.vxor.vsvl
+    ve_vl_vxor_vsvmvl,                         // llvm.ve.vl.vxor.vsvmvl
+    ve_vl_vxor_vsvvl,                          // llvm.ve.vl.vxor.vsvvl
+    ve_vl_vxor_vvvl,                           // llvm.ve.vl.vxor.vvvl
+    ve_vl_vxor_vvvmvl,                         // llvm.ve.vl.vxor.vvvmvl
+    ve_vl_vxor_vvvvl,                          // llvm.ve.vl.vxor.vvvvl
+    ve_vl_xorm_MMM,                            // llvm.ve.vl.xorm.MMM
+    ve_vl_xorm_mmm,                            // llvm.ve.vl.xorm.mmm
+}; // enum
+} // namespace Intrinsic
+} // namespace llvm
+
+#endif
diff --git a/linux-x64/clang/include/llvm/IR/IntrinsicsVE.td b/linux-x64/clang/include/llvm/IR/IntrinsicsVE.td
new file mode 100644
index 0000000..be4bcce
--- /dev/null
+++ b/linux-x64/clang/include/llvm/IR/IntrinsicsVE.td
@@ -0,0 +1,35 @@
+// Define intrinsics written by hand
+
+// VEL Intrinsic instructions.
+let TargetPrefix = "ve" in {
+  def int_ve_vl_svob : GCCBuiltin<"__builtin_ve_vl_svob">,
+                       Intrinsic<[], [], [IntrHasSideEffects]>;
+
+  def int_ve_vl_pack_f32p : GCCBuiltin<"__builtin_ve_vl_pack_f32p">,
+                            Intrinsic<[llvm_i64_ty], [llvm_ptr_ty, llvm_ptr_ty],
+                                      [IntrReadMem]>;
+  def int_ve_vl_pack_f32a : GCCBuiltin<"__builtin_ve_vl_pack_f32a">,
+                            Intrinsic<[llvm_i64_ty], [llvm_ptr_ty],
+                                      [IntrReadMem]>;
+
+  def int_ve_vl_extract_vm512u :
+      GCCBuiltin<"__builtin_ve_vl_extract_vm512u">,
+      Intrinsic<[LLVMType<v256i1>], [LLVMType<v512i1>], [IntrNoMem]>;
+
+  def int_ve_vl_extract_vm512l :
+      GCCBuiltin<"__builtin_ve_vl_extract_vm512l">,
+      Intrinsic<[LLVMType<v256i1>], [LLVMType<v512i1>], [IntrNoMem]>;
+
+  def int_ve_vl_insert_vm512u :
+      GCCBuiltin<"__builtin_ve_vl_insert_vm512u">,
+      Intrinsic<[LLVMType<v512i1>], [LLVMType<v512i1>, LLVMType<v256i1>],
+                [IntrNoMem]>;
+
+  def int_ve_vl_insert_vm512l :
+      GCCBuiltin<"__builtin_ve_vl_insert_vm512l">,
+      Intrinsic<[LLVMType<v512i1>], [LLVMType<v512i1>, LLVMType<v256i1>],
+                [IntrNoMem]>;
+}
+
+// Define intrinsics automatically generated
+include "llvm/IR/IntrinsicsVEVL.gen.td"
diff --git a/linux-x64/clang/include/llvm/IR/IntrinsicsVEVL.gen.td b/linux-x64/clang/include/llvm/IR/IntrinsicsVEVL.gen.td
new file mode 100644
index 0000000..67cbd30
--- /dev/null
+++ b/linux-x64/clang/include/llvm/IR/IntrinsicsVEVL.gen.td
@@ -0,0 +1,1213 @@
+let TargetPrefix = "ve" in def int_ve_vl_vld_vssl : GCCBuiltin<"__builtin_ve_vl_vld_vssl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, llvm_ptr_ty, LLVMType<i32>], [IntrReadMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vld_vssvl : GCCBuiltin<"__builtin_ve_vl_vld_vssvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, llvm_ptr_ty, LLVMType<v256f64>, LLVMType<i32>], [IntrReadMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vldnc_vssl : GCCBuiltin<"__builtin_ve_vl_vldnc_vssl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, llvm_ptr_ty, LLVMType<i32>], [IntrReadMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vldnc_vssvl : GCCBuiltin<"__builtin_ve_vl_vldnc_vssvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, llvm_ptr_ty, LLVMType<v256f64>, LLVMType<i32>], [IntrReadMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vldu_vssl : GCCBuiltin<"__builtin_ve_vl_vldu_vssl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, llvm_ptr_ty, LLVMType<i32>], [IntrReadMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vldu_vssvl : GCCBuiltin<"__builtin_ve_vl_vldu_vssvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, llvm_ptr_ty, LLVMType<v256f64>, LLVMType<i32>], [IntrReadMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vldunc_vssl : GCCBuiltin<"__builtin_ve_vl_vldunc_vssl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, llvm_ptr_ty, LLVMType<i32>], [IntrReadMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vldunc_vssvl : GCCBuiltin<"__builtin_ve_vl_vldunc_vssvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, llvm_ptr_ty, LLVMType<v256f64>, LLVMType<i32>], [IntrReadMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vldlsx_vssl : GCCBuiltin<"__builtin_ve_vl_vldlsx_vssl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, llvm_ptr_ty, LLVMType<i32>], [IntrReadMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vldlsx_vssvl : GCCBuiltin<"__builtin_ve_vl_vldlsx_vssvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, llvm_ptr_ty, LLVMType<v256f64>, LLVMType<i32>], [IntrReadMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vldlsxnc_vssl : GCCBuiltin<"__builtin_ve_vl_vldlsxnc_vssl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, llvm_ptr_ty, LLVMType<i32>], [IntrReadMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vldlsxnc_vssvl : GCCBuiltin<"__builtin_ve_vl_vldlsxnc_vssvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, llvm_ptr_ty, LLVMType<v256f64>, LLVMType<i32>], [IntrReadMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vldlzx_vssl : GCCBuiltin<"__builtin_ve_vl_vldlzx_vssl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, llvm_ptr_ty, LLVMType<i32>], [IntrReadMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vldlzx_vssvl : GCCBuiltin<"__builtin_ve_vl_vldlzx_vssvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, llvm_ptr_ty, LLVMType<v256f64>, LLVMType<i32>], [IntrReadMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vldlzxnc_vssl : GCCBuiltin<"__builtin_ve_vl_vldlzxnc_vssl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, llvm_ptr_ty, LLVMType<i32>], [IntrReadMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vldlzxnc_vssvl : GCCBuiltin<"__builtin_ve_vl_vldlzxnc_vssvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, llvm_ptr_ty, LLVMType<v256f64>, LLVMType<i32>], [IntrReadMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vld2d_vssl : GCCBuiltin<"__builtin_ve_vl_vld2d_vssl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, llvm_ptr_ty, LLVMType<i32>], [IntrReadMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vld2d_vssvl : GCCBuiltin<"__builtin_ve_vl_vld2d_vssvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, llvm_ptr_ty, LLVMType<v256f64>, LLVMType<i32>], [IntrReadMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vld2dnc_vssl : GCCBuiltin<"__builtin_ve_vl_vld2dnc_vssl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, llvm_ptr_ty, LLVMType<i32>], [IntrReadMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vld2dnc_vssvl : GCCBuiltin<"__builtin_ve_vl_vld2dnc_vssvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, llvm_ptr_ty, LLVMType<v256f64>, LLVMType<i32>], [IntrReadMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vldu2d_vssl : GCCBuiltin<"__builtin_ve_vl_vldu2d_vssl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, llvm_ptr_ty, LLVMType<i32>], [IntrReadMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vldu2d_vssvl : GCCBuiltin<"__builtin_ve_vl_vldu2d_vssvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, llvm_ptr_ty, LLVMType<v256f64>, LLVMType<i32>], [IntrReadMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vldu2dnc_vssl : GCCBuiltin<"__builtin_ve_vl_vldu2dnc_vssl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, llvm_ptr_ty, LLVMType<i32>], [IntrReadMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vldu2dnc_vssvl : GCCBuiltin<"__builtin_ve_vl_vldu2dnc_vssvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, llvm_ptr_ty, LLVMType<v256f64>, LLVMType<i32>], [IntrReadMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vldl2dsx_vssl : GCCBuiltin<"__builtin_ve_vl_vldl2dsx_vssl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, llvm_ptr_ty, LLVMType<i32>], [IntrReadMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vldl2dsx_vssvl : GCCBuiltin<"__builtin_ve_vl_vldl2dsx_vssvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, llvm_ptr_ty, LLVMType<v256f64>, LLVMType<i32>], [IntrReadMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vldl2dsxnc_vssl : GCCBuiltin<"__builtin_ve_vl_vldl2dsxnc_vssl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, llvm_ptr_ty, LLVMType<i32>], [IntrReadMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vldl2dsxnc_vssvl : GCCBuiltin<"__builtin_ve_vl_vldl2dsxnc_vssvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, llvm_ptr_ty, LLVMType<v256f64>, LLVMType<i32>], [IntrReadMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vldl2dzx_vssl : GCCBuiltin<"__builtin_ve_vl_vldl2dzx_vssl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, llvm_ptr_ty, LLVMType<i32>], [IntrReadMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vldl2dzx_vssvl : GCCBuiltin<"__builtin_ve_vl_vldl2dzx_vssvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, llvm_ptr_ty, LLVMType<v256f64>, LLVMType<i32>], [IntrReadMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vldl2dzxnc_vssl : GCCBuiltin<"__builtin_ve_vl_vldl2dzxnc_vssl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, llvm_ptr_ty, LLVMType<i32>], [IntrReadMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vldl2dzxnc_vssvl : GCCBuiltin<"__builtin_ve_vl_vldl2dzxnc_vssvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, llvm_ptr_ty, LLVMType<v256f64>, LLVMType<i32>], [IntrReadMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vst_vssl : GCCBuiltin<"__builtin_ve_vl_vst_vssl">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<i64>, llvm_ptr_ty, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vst_vssml : GCCBuiltin<"__builtin_ve_vl_vst_vssml">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<i64>, llvm_ptr_ty, LLVMType<v256i1>, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vstnc_vssl : GCCBuiltin<"__builtin_ve_vl_vstnc_vssl">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<i64>, llvm_ptr_ty, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vstnc_vssml : GCCBuiltin<"__builtin_ve_vl_vstnc_vssml">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<i64>, llvm_ptr_ty, LLVMType<v256i1>, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vstot_vssl : GCCBuiltin<"__builtin_ve_vl_vstot_vssl">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<i64>, llvm_ptr_ty, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vstot_vssml : GCCBuiltin<"__builtin_ve_vl_vstot_vssml">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<i64>, llvm_ptr_ty, LLVMType<v256i1>, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vstncot_vssl : GCCBuiltin<"__builtin_ve_vl_vstncot_vssl">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<i64>, llvm_ptr_ty, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vstncot_vssml : GCCBuiltin<"__builtin_ve_vl_vstncot_vssml">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<i64>, llvm_ptr_ty, LLVMType<v256i1>, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vstu_vssl : GCCBuiltin<"__builtin_ve_vl_vstu_vssl">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<i64>, llvm_ptr_ty, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vstu_vssml : GCCBuiltin<"__builtin_ve_vl_vstu_vssml">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<i64>, llvm_ptr_ty, LLVMType<v256i1>, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vstunc_vssl : GCCBuiltin<"__builtin_ve_vl_vstunc_vssl">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<i64>, llvm_ptr_ty, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vstunc_vssml : GCCBuiltin<"__builtin_ve_vl_vstunc_vssml">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<i64>, llvm_ptr_ty, LLVMType<v256i1>, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vstuot_vssl : GCCBuiltin<"__builtin_ve_vl_vstuot_vssl">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<i64>, llvm_ptr_ty, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vstuot_vssml : GCCBuiltin<"__builtin_ve_vl_vstuot_vssml">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<i64>, llvm_ptr_ty, LLVMType<v256i1>, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vstuncot_vssl : GCCBuiltin<"__builtin_ve_vl_vstuncot_vssl">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<i64>, llvm_ptr_ty, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vstuncot_vssml : GCCBuiltin<"__builtin_ve_vl_vstuncot_vssml">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<i64>, llvm_ptr_ty, LLVMType<v256i1>, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vstl_vssl : GCCBuiltin<"__builtin_ve_vl_vstl_vssl">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<i64>, llvm_ptr_ty, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vstl_vssml : GCCBuiltin<"__builtin_ve_vl_vstl_vssml">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<i64>, llvm_ptr_ty, LLVMType<v256i1>, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vstlnc_vssl : GCCBuiltin<"__builtin_ve_vl_vstlnc_vssl">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<i64>, llvm_ptr_ty, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vstlnc_vssml : GCCBuiltin<"__builtin_ve_vl_vstlnc_vssml">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<i64>, llvm_ptr_ty, LLVMType<v256i1>, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vstlot_vssl : GCCBuiltin<"__builtin_ve_vl_vstlot_vssl">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<i64>, llvm_ptr_ty, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vstlot_vssml : GCCBuiltin<"__builtin_ve_vl_vstlot_vssml">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<i64>, llvm_ptr_ty, LLVMType<v256i1>, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vstlncot_vssl : GCCBuiltin<"__builtin_ve_vl_vstlncot_vssl">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<i64>, llvm_ptr_ty, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vstlncot_vssml : GCCBuiltin<"__builtin_ve_vl_vstlncot_vssml">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<i64>, llvm_ptr_ty, LLVMType<v256i1>, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vst2d_vssl : GCCBuiltin<"__builtin_ve_vl_vst2d_vssl">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<i64>, llvm_ptr_ty, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vst2d_vssml : GCCBuiltin<"__builtin_ve_vl_vst2d_vssml">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<i64>, llvm_ptr_ty, LLVMType<v256i1>, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vst2dnc_vssl : GCCBuiltin<"__builtin_ve_vl_vst2dnc_vssl">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<i64>, llvm_ptr_ty, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vst2dnc_vssml : GCCBuiltin<"__builtin_ve_vl_vst2dnc_vssml">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<i64>, llvm_ptr_ty, LLVMType<v256i1>, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vst2dot_vssl : GCCBuiltin<"__builtin_ve_vl_vst2dot_vssl">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<i64>, llvm_ptr_ty, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vst2dot_vssml : GCCBuiltin<"__builtin_ve_vl_vst2dot_vssml">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<i64>, llvm_ptr_ty, LLVMType<v256i1>, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vst2dncot_vssl : GCCBuiltin<"__builtin_ve_vl_vst2dncot_vssl">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<i64>, llvm_ptr_ty, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vst2dncot_vssml : GCCBuiltin<"__builtin_ve_vl_vst2dncot_vssml">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<i64>, llvm_ptr_ty, LLVMType<v256i1>, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vstu2d_vssl : GCCBuiltin<"__builtin_ve_vl_vstu2d_vssl">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<i64>, llvm_ptr_ty, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vstu2d_vssml : GCCBuiltin<"__builtin_ve_vl_vstu2d_vssml">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<i64>, llvm_ptr_ty, LLVMType<v256i1>, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vstu2dnc_vssl : GCCBuiltin<"__builtin_ve_vl_vstu2dnc_vssl">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<i64>, llvm_ptr_ty, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vstu2dnc_vssml : GCCBuiltin<"__builtin_ve_vl_vstu2dnc_vssml">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<i64>, llvm_ptr_ty, LLVMType<v256i1>, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vstu2dot_vssl : GCCBuiltin<"__builtin_ve_vl_vstu2dot_vssl">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<i64>, llvm_ptr_ty, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vstu2dot_vssml : GCCBuiltin<"__builtin_ve_vl_vstu2dot_vssml">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<i64>, llvm_ptr_ty, LLVMType<v256i1>, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vstu2dncot_vssl : GCCBuiltin<"__builtin_ve_vl_vstu2dncot_vssl">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<i64>, llvm_ptr_ty, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vstu2dncot_vssml : GCCBuiltin<"__builtin_ve_vl_vstu2dncot_vssml">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<i64>, llvm_ptr_ty, LLVMType<v256i1>, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vstl2d_vssl : GCCBuiltin<"__builtin_ve_vl_vstl2d_vssl">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<i64>, llvm_ptr_ty, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vstl2d_vssml : GCCBuiltin<"__builtin_ve_vl_vstl2d_vssml">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<i64>, llvm_ptr_ty, LLVMType<v256i1>, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vstl2dnc_vssl : GCCBuiltin<"__builtin_ve_vl_vstl2dnc_vssl">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<i64>, llvm_ptr_ty, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vstl2dnc_vssml : GCCBuiltin<"__builtin_ve_vl_vstl2dnc_vssml">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<i64>, llvm_ptr_ty, LLVMType<v256i1>, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vstl2dot_vssl : GCCBuiltin<"__builtin_ve_vl_vstl2dot_vssl">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<i64>, llvm_ptr_ty, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vstl2dot_vssml : GCCBuiltin<"__builtin_ve_vl_vstl2dot_vssml">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<i64>, llvm_ptr_ty, LLVMType<v256i1>, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vstl2dncot_vssl : GCCBuiltin<"__builtin_ve_vl_vstl2dncot_vssl">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<i64>, llvm_ptr_ty, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vstl2dncot_vssml : GCCBuiltin<"__builtin_ve_vl_vstl2dncot_vssml">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<i64>, llvm_ptr_ty, LLVMType<v256i1>, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pfchv_ssl : GCCBuiltin<"__builtin_ve_vl_pfchv_ssl">, Intrinsic<[], [LLVMType<i64>, llvm_ptr_ty, LLVMType<i32>], [IntrInaccessibleMemOrArgMemOnly]>;
+let TargetPrefix = "ve" in def int_ve_vl_pfchvnc_ssl : GCCBuiltin<"__builtin_ve_vl_pfchvnc_ssl">, Intrinsic<[], [LLVMType<i64>, llvm_ptr_ty, LLVMType<i32>], [IntrInaccessibleMemOrArgMemOnly]>;
+let TargetPrefix = "ve" in def int_ve_vl_lsv_vvss : GCCBuiltin<"__builtin_ve_vl_lsv_vvss">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>, LLVMType<i64>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_lvsl_svs : GCCBuiltin<"__builtin_ve_vl_lvsl_svs">, Intrinsic<[LLVMType<i64>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_lvsd_svs : GCCBuiltin<"__builtin_ve_vl_lvsd_svs">, Intrinsic<[LLVMType<f64>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_lvss_svs : GCCBuiltin<"__builtin_ve_vl_lvss_svs">, Intrinsic<[LLVMType<f32>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_lvm_mmss : GCCBuiltin<"__builtin_ve_vl_lvm_mmss">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256i1>, LLVMType<i64>, LLVMType<i64>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_lvm_MMss : GCCBuiltin<"__builtin_ve_vl_lvm_MMss">, Intrinsic<[LLVMType<v512i1>], [LLVMType<v512i1>, LLVMType<i64>, LLVMType<i64>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_svm_sms : GCCBuiltin<"__builtin_ve_vl_svm_sms">, Intrinsic<[LLVMType<i64>], [LLVMType<v256i1>, LLVMType<i64>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_svm_sMs : GCCBuiltin<"__builtin_ve_vl_svm_sMs">, Intrinsic<[LLVMType<i64>], [LLVMType<v512i1>, LLVMType<i64>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vbrdd_vsl : GCCBuiltin<"__builtin_ve_vl_vbrdd_vsl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vbrdd_vsvl : GCCBuiltin<"__builtin_ve_vl_vbrdd_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vbrdd_vsmvl : GCCBuiltin<"__builtin_ve_vl_vbrdd_vsmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vbrdl_vsl : GCCBuiltin<"__builtin_ve_vl_vbrdl_vsl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vbrdl_vsvl : GCCBuiltin<"__builtin_ve_vl_vbrdl_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vbrdl_vsmvl : GCCBuiltin<"__builtin_ve_vl_vbrdl_vsmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vbrds_vsl : GCCBuiltin<"__builtin_ve_vl_vbrds_vsl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f32>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vbrds_vsvl : GCCBuiltin<"__builtin_ve_vl_vbrds_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f32>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vbrds_vsmvl : GCCBuiltin<"__builtin_ve_vl_vbrds_vsmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f32>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vbrdw_vsl : GCCBuiltin<"__builtin_ve_vl_vbrdw_vsl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vbrdw_vsvl : GCCBuiltin<"__builtin_ve_vl_vbrdw_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vbrdw_vsmvl : GCCBuiltin<"__builtin_ve_vl_vbrdw_vsmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvbrd_vsl : GCCBuiltin<"__builtin_ve_vl_pvbrd_vsl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvbrd_vsvl : GCCBuiltin<"__builtin_ve_vl_pvbrd_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvbrd_vsMvl : GCCBuiltin<"__builtin_ve_vl_pvbrd_vsMvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v512i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vmv_vsvl : GCCBuiltin<"__builtin_ve_vl_vmv_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vmv_vsvvl : GCCBuiltin<"__builtin_ve_vl_vmv_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vmv_vsvmvl : GCCBuiltin<"__builtin_ve_vl_vmv_vsvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vaddul_vvvl : GCCBuiltin<"__builtin_ve_vl_vaddul_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vaddul_vvvvl : GCCBuiltin<"__builtin_ve_vl_vaddul_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vaddul_vsvl : GCCBuiltin<"__builtin_ve_vl_vaddul_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vaddul_vsvvl : GCCBuiltin<"__builtin_ve_vl_vaddul_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vaddul_vvvmvl : GCCBuiltin<"__builtin_ve_vl_vaddul_vvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vaddul_vsvmvl : GCCBuiltin<"__builtin_ve_vl_vaddul_vsvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vadduw_vvvl : GCCBuiltin<"__builtin_ve_vl_vadduw_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vadduw_vvvvl : GCCBuiltin<"__builtin_ve_vl_vadduw_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vadduw_vsvl : GCCBuiltin<"__builtin_ve_vl_vadduw_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vadduw_vsvvl : GCCBuiltin<"__builtin_ve_vl_vadduw_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vadduw_vvvmvl : GCCBuiltin<"__builtin_ve_vl_vadduw_vvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vadduw_vsvmvl : GCCBuiltin<"__builtin_ve_vl_vadduw_vsvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvaddu_vvvl : GCCBuiltin<"__builtin_ve_vl_pvaddu_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvaddu_vvvvl : GCCBuiltin<"__builtin_ve_vl_pvaddu_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvaddu_vsvl : GCCBuiltin<"__builtin_ve_vl_pvaddu_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvaddu_vsvvl : GCCBuiltin<"__builtin_ve_vl_pvaddu_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvaddu_vvvMvl : GCCBuiltin<"__builtin_ve_vl_pvaddu_vvvMvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvaddu_vsvMvl : GCCBuiltin<"__builtin_ve_vl_pvaddu_vsvMvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vaddswsx_vvvl : GCCBuiltin<"__builtin_ve_vl_vaddswsx_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vaddswsx_vvvvl : GCCBuiltin<"__builtin_ve_vl_vaddswsx_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vaddswsx_vsvl : GCCBuiltin<"__builtin_ve_vl_vaddswsx_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vaddswsx_vsvvl : GCCBuiltin<"__builtin_ve_vl_vaddswsx_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vaddswsx_vvvmvl : GCCBuiltin<"__builtin_ve_vl_vaddswsx_vvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vaddswsx_vsvmvl : GCCBuiltin<"__builtin_ve_vl_vaddswsx_vsvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vaddswzx_vvvl : GCCBuiltin<"__builtin_ve_vl_vaddswzx_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vaddswzx_vvvvl : GCCBuiltin<"__builtin_ve_vl_vaddswzx_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vaddswzx_vsvl : GCCBuiltin<"__builtin_ve_vl_vaddswzx_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vaddswzx_vsvvl : GCCBuiltin<"__builtin_ve_vl_vaddswzx_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vaddswzx_vvvmvl : GCCBuiltin<"__builtin_ve_vl_vaddswzx_vvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vaddswzx_vsvmvl : GCCBuiltin<"__builtin_ve_vl_vaddswzx_vsvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvadds_vvvl : GCCBuiltin<"__builtin_ve_vl_pvadds_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvadds_vvvvl : GCCBuiltin<"__builtin_ve_vl_pvadds_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvadds_vsvl : GCCBuiltin<"__builtin_ve_vl_pvadds_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvadds_vsvvl : GCCBuiltin<"__builtin_ve_vl_pvadds_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvadds_vvvMvl : GCCBuiltin<"__builtin_ve_vl_pvadds_vvvMvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvadds_vsvMvl : GCCBuiltin<"__builtin_ve_vl_pvadds_vsvMvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vaddsl_vvvl : GCCBuiltin<"__builtin_ve_vl_vaddsl_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vaddsl_vvvvl : GCCBuiltin<"__builtin_ve_vl_vaddsl_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vaddsl_vsvl : GCCBuiltin<"__builtin_ve_vl_vaddsl_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vaddsl_vsvvl : GCCBuiltin<"__builtin_ve_vl_vaddsl_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vaddsl_vvvmvl : GCCBuiltin<"__builtin_ve_vl_vaddsl_vvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vaddsl_vsvmvl : GCCBuiltin<"__builtin_ve_vl_vaddsl_vsvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsubul_vvvl : GCCBuiltin<"__builtin_ve_vl_vsubul_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsubul_vvvvl : GCCBuiltin<"__builtin_ve_vl_vsubul_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsubul_vsvl : GCCBuiltin<"__builtin_ve_vl_vsubul_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsubul_vsvvl : GCCBuiltin<"__builtin_ve_vl_vsubul_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsubul_vvvmvl : GCCBuiltin<"__builtin_ve_vl_vsubul_vvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsubul_vsvmvl : GCCBuiltin<"__builtin_ve_vl_vsubul_vsvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsubuw_vvvl : GCCBuiltin<"__builtin_ve_vl_vsubuw_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsubuw_vvvvl : GCCBuiltin<"__builtin_ve_vl_vsubuw_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsubuw_vsvl : GCCBuiltin<"__builtin_ve_vl_vsubuw_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsubuw_vsvvl : GCCBuiltin<"__builtin_ve_vl_vsubuw_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsubuw_vvvmvl : GCCBuiltin<"__builtin_ve_vl_vsubuw_vvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsubuw_vsvmvl : GCCBuiltin<"__builtin_ve_vl_vsubuw_vsvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvsubu_vvvl : GCCBuiltin<"__builtin_ve_vl_pvsubu_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvsubu_vvvvl : GCCBuiltin<"__builtin_ve_vl_pvsubu_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvsubu_vsvl : GCCBuiltin<"__builtin_ve_vl_pvsubu_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvsubu_vsvvl : GCCBuiltin<"__builtin_ve_vl_pvsubu_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvsubu_vvvMvl : GCCBuiltin<"__builtin_ve_vl_pvsubu_vvvMvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvsubu_vsvMvl : GCCBuiltin<"__builtin_ve_vl_pvsubu_vsvMvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsubswsx_vvvl : GCCBuiltin<"__builtin_ve_vl_vsubswsx_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsubswsx_vvvvl : GCCBuiltin<"__builtin_ve_vl_vsubswsx_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsubswsx_vsvl : GCCBuiltin<"__builtin_ve_vl_vsubswsx_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsubswsx_vsvvl : GCCBuiltin<"__builtin_ve_vl_vsubswsx_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsubswsx_vvvmvl : GCCBuiltin<"__builtin_ve_vl_vsubswsx_vvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsubswsx_vsvmvl : GCCBuiltin<"__builtin_ve_vl_vsubswsx_vsvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsubswzx_vvvl : GCCBuiltin<"__builtin_ve_vl_vsubswzx_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsubswzx_vvvvl : GCCBuiltin<"__builtin_ve_vl_vsubswzx_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsubswzx_vsvl : GCCBuiltin<"__builtin_ve_vl_vsubswzx_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsubswzx_vsvvl : GCCBuiltin<"__builtin_ve_vl_vsubswzx_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsubswzx_vvvmvl : GCCBuiltin<"__builtin_ve_vl_vsubswzx_vvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsubswzx_vsvmvl : GCCBuiltin<"__builtin_ve_vl_vsubswzx_vsvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvsubs_vvvl : GCCBuiltin<"__builtin_ve_vl_pvsubs_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvsubs_vvvvl : GCCBuiltin<"__builtin_ve_vl_pvsubs_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvsubs_vsvl : GCCBuiltin<"__builtin_ve_vl_pvsubs_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvsubs_vsvvl : GCCBuiltin<"__builtin_ve_vl_pvsubs_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvsubs_vvvMvl : GCCBuiltin<"__builtin_ve_vl_pvsubs_vvvMvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvsubs_vsvMvl : GCCBuiltin<"__builtin_ve_vl_pvsubs_vsvMvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsubsl_vvvl : GCCBuiltin<"__builtin_ve_vl_vsubsl_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsubsl_vvvvl : GCCBuiltin<"__builtin_ve_vl_vsubsl_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsubsl_vsvl : GCCBuiltin<"__builtin_ve_vl_vsubsl_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsubsl_vsvvl : GCCBuiltin<"__builtin_ve_vl_vsubsl_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsubsl_vvvmvl : GCCBuiltin<"__builtin_ve_vl_vsubsl_vvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsubsl_vsvmvl : GCCBuiltin<"__builtin_ve_vl_vsubsl_vsvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vmulul_vvvl : GCCBuiltin<"__builtin_ve_vl_vmulul_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vmulul_vvvvl : GCCBuiltin<"__builtin_ve_vl_vmulul_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vmulul_vsvl : GCCBuiltin<"__builtin_ve_vl_vmulul_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vmulul_vsvvl : GCCBuiltin<"__builtin_ve_vl_vmulul_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vmulul_vvvmvl : GCCBuiltin<"__builtin_ve_vl_vmulul_vvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vmulul_vsvmvl : GCCBuiltin<"__builtin_ve_vl_vmulul_vsvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vmuluw_vvvl : GCCBuiltin<"__builtin_ve_vl_vmuluw_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vmuluw_vvvvl : GCCBuiltin<"__builtin_ve_vl_vmuluw_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vmuluw_vsvl : GCCBuiltin<"__builtin_ve_vl_vmuluw_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vmuluw_vsvvl : GCCBuiltin<"__builtin_ve_vl_vmuluw_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vmuluw_vvvmvl : GCCBuiltin<"__builtin_ve_vl_vmuluw_vvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vmuluw_vsvmvl : GCCBuiltin<"__builtin_ve_vl_vmuluw_vsvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vmulswsx_vvvl : GCCBuiltin<"__builtin_ve_vl_vmulswsx_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vmulswsx_vvvvl : GCCBuiltin<"__builtin_ve_vl_vmulswsx_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vmulswsx_vsvl : GCCBuiltin<"__builtin_ve_vl_vmulswsx_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vmulswsx_vsvvl : GCCBuiltin<"__builtin_ve_vl_vmulswsx_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vmulswsx_vvvmvl : GCCBuiltin<"__builtin_ve_vl_vmulswsx_vvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vmulswsx_vsvmvl : GCCBuiltin<"__builtin_ve_vl_vmulswsx_vsvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vmulswzx_vvvl : GCCBuiltin<"__builtin_ve_vl_vmulswzx_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vmulswzx_vvvvl : GCCBuiltin<"__builtin_ve_vl_vmulswzx_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vmulswzx_vsvl : GCCBuiltin<"__builtin_ve_vl_vmulswzx_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vmulswzx_vsvvl : GCCBuiltin<"__builtin_ve_vl_vmulswzx_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vmulswzx_vvvmvl : GCCBuiltin<"__builtin_ve_vl_vmulswzx_vvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vmulswzx_vsvmvl : GCCBuiltin<"__builtin_ve_vl_vmulswzx_vsvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vmulsl_vvvl : GCCBuiltin<"__builtin_ve_vl_vmulsl_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vmulsl_vvvvl : GCCBuiltin<"__builtin_ve_vl_vmulsl_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vmulsl_vsvl : GCCBuiltin<"__builtin_ve_vl_vmulsl_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vmulsl_vsvvl : GCCBuiltin<"__builtin_ve_vl_vmulsl_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vmulsl_vvvmvl : GCCBuiltin<"__builtin_ve_vl_vmulsl_vvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vmulsl_vsvmvl : GCCBuiltin<"__builtin_ve_vl_vmulsl_vsvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vmulslw_vvvl : GCCBuiltin<"__builtin_ve_vl_vmulslw_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vmulslw_vvvvl : GCCBuiltin<"__builtin_ve_vl_vmulslw_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vmulslw_vsvl : GCCBuiltin<"__builtin_ve_vl_vmulslw_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vmulslw_vsvvl : GCCBuiltin<"__builtin_ve_vl_vmulslw_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vdivul_vvvl : GCCBuiltin<"__builtin_ve_vl_vdivul_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vdivul_vvvvl : GCCBuiltin<"__builtin_ve_vl_vdivul_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vdivul_vsvl : GCCBuiltin<"__builtin_ve_vl_vdivul_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vdivul_vsvvl : GCCBuiltin<"__builtin_ve_vl_vdivul_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vdivul_vvvmvl : GCCBuiltin<"__builtin_ve_vl_vdivul_vvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vdivul_vsvmvl : GCCBuiltin<"__builtin_ve_vl_vdivul_vsvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vdivuw_vvvl : GCCBuiltin<"__builtin_ve_vl_vdivuw_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vdivuw_vvvvl : GCCBuiltin<"__builtin_ve_vl_vdivuw_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vdivuw_vsvl : GCCBuiltin<"__builtin_ve_vl_vdivuw_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vdivuw_vsvvl : GCCBuiltin<"__builtin_ve_vl_vdivuw_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vdivuw_vvvmvl : GCCBuiltin<"__builtin_ve_vl_vdivuw_vvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vdivuw_vsvmvl : GCCBuiltin<"__builtin_ve_vl_vdivuw_vsvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vdivul_vvsl : GCCBuiltin<"__builtin_ve_vl_vdivul_vvsl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vdivul_vvsvl : GCCBuiltin<"__builtin_ve_vl_vdivul_vvsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vdivul_vvsmvl : GCCBuiltin<"__builtin_ve_vl_vdivul_vvsmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vdivuw_vvsl : GCCBuiltin<"__builtin_ve_vl_vdivuw_vvsl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vdivuw_vvsvl : GCCBuiltin<"__builtin_ve_vl_vdivuw_vvsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vdivuw_vvsmvl : GCCBuiltin<"__builtin_ve_vl_vdivuw_vvsmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vdivswsx_vvvl : GCCBuiltin<"__builtin_ve_vl_vdivswsx_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vdivswsx_vvvvl : GCCBuiltin<"__builtin_ve_vl_vdivswsx_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vdivswsx_vsvl : GCCBuiltin<"__builtin_ve_vl_vdivswsx_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vdivswsx_vsvvl : GCCBuiltin<"__builtin_ve_vl_vdivswsx_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vdivswsx_vvvmvl : GCCBuiltin<"__builtin_ve_vl_vdivswsx_vvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vdivswsx_vsvmvl : GCCBuiltin<"__builtin_ve_vl_vdivswsx_vsvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vdivswzx_vvvl : GCCBuiltin<"__builtin_ve_vl_vdivswzx_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vdivswzx_vvvvl : GCCBuiltin<"__builtin_ve_vl_vdivswzx_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vdivswzx_vsvl : GCCBuiltin<"__builtin_ve_vl_vdivswzx_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vdivswzx_vsvvl : GCCBuiltin<"__builtin_ve_vl_vdivswzx_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vdivswzx_vvvmvl : GCCBuiltin<"__builtin_ve_vl_vdivswzx_vvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vdivswzx_vsvmvl : GCCBuiltin<"__builtin_ve_vl_vdivswzx_vsvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vdivswsx_vvsl : GCCBuiltin<"__builtin_ve_vl_vdivswsx_vvsl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vdivswsx_vvsvl : GCCBuiltin<"__builtin_ve_vl_vdivswsx_vvsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vdivswsx_vvsmvl : GCCBuiltin<"__builtin_ve_vl_vdivswsx_vvsmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vdivswzx_vvsl : GCCBuiltin<"__builtin_ve_vl_vdivswzx_vvsl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vdivswzx_vvsvl : GCCBuiltin<"__builtin_ve_vl_vdivswzx_vvsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vdivswzx_vvsmvl : GCCBuiltin<"__builtin_ve_vl_vdivswzx_vvsmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vdivsl_vvvl : GCCBuiltin<"__builtin_ve_vl_vdivsl_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vdivsl_vvvvl : GCCBuiltin<"__builtin_ve_vl_vdivsl_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vdivsl_vsvl : GCCBuiltin<"__builtin_ve_vl_vdivsl_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vdivsl_vsvvl : GCCBuiltin<"__builtin_ve_vl_vdivsl_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vdivsl_vvvmvl : GCCBuiltin<"__builtin_ve_vl_vdivsl_vvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vdivsl_vsvmvl : GCCBuiltin<"__builtin_ve_vl_vdivsl_vsvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vdivsl_vvsl : GCCBuiltin<"__builtin_ve_vl_vdivsl_vvsl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vdivsl_vvsvl : GCCBuiltin<"__builtin_ve_vl_vdivsl_vvsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vdivsl_vvsmvl : GCCBuiltin<"__builtin_ve_vl_vdivsl_vvsmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcmpul_vvvl : GCCBuiltin<"__builtin_ve_vl_vcmpul_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcmpul_vvvvl : GCCBuiltin<"__builtin_ve_vl_vcmpul_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcmpul_vsvl : GCCBuiltin<"__builtin_ve_vl_vcmpul_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcmpul_vsvvl : GCCBuiltin<"__builtin_ve_vl_vcmpul_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcmpul_vvvmvl : GCCBuiltin<"__builtin_ve_vl_vcmpul_vvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcmpul_vsvmvl : GCCBuiltin<"__builtin_ve_vl_vcmpul_vsvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcmpuw_vvvl : GCCBuiltin<"__builtin_ve_vl_vcmpuw_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcmpuw_vvvvl : GCCBuiltin<"__builtin_ve_vl_vcmpuw_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcmpuw_vsvl : GCCBuiltin<"__builtin_ve_vl_vcmpuw_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcmpuw_vsvvl : GCCBuiltin<"__builtin_ve_vl_vcmpuw_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcmpuw_vvvmvl : GCCBuiltin<"__builtin_ve_vl_vcmpuw_vvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcmpuw_vsvmvl : GCCBuiltin<"__builtin_ve_vl_vcmpuw_vsvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvcmpu_vvvl : GCCBuiltin<"__builtin_ve_vl_pvcmpu_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvcmpu_vvvvl : GCCBuiltin<"__builtin_ve_vl_pvcmpu_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvcmpu_vsvl : GCCBuiltin<"__builtin_ve_vl_pvcmpu_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvcmpu_vsvvl : GCCBuiltin<"__builtin_ve_vl_pvcmpu_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvcmpu_vvvMvl : GCCBuiltin<"__builtin_ve_vl_pvcmpu_vvvMvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvcmpu_vsvMvl : GCCBuiltin<"__builtin_ve_vl_pvcmpu_vsvMvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcmpswsx_vvvl : GCCBuiltin<"__builtin_ve_vl_vcmpswsx_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcmpswsx_vvvvl : GCCBuiltin<"__builtin_ve_vl_vcmpswsx_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcmpswsx_vsvl : GCCBuiltin<"__builtin_ve_vl_vcmpswsx_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcmpswsx_vsvvl : GCCBuiltin<"__builtin_ve_vl_vcmpswsx_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcmpswsx_vvvmvl : GCCBuiltin<"__builtin_ve_vl_vcmpswsx_vvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcmpswsx_vsvmvl : GCCBuiltin<"__builtin_ve_vl_vcmpswsx_vsvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcmpswzx_vvvl : GCCBuiltin<"__builtin_ve_vl_vcmpswzx_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcmpswzx_vvvvl : GCCBuiltin<"__builtin_ve_vl_vcmpswzx_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcmpswzx_vsvl : GCCBuiltin<"__builtin_ve_vl_vcmpswzx_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcmpswzx_vsvvl : GCCBuiltin<"__builtin_ve_vl_vcmpswzx_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcmpswzx_vvvmvl : GCCBuiltin<"__builtin_ve_vl_vcmpswzx_vvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcmpswzx_vsvmvl : GCCBuiltin<"__builtin_ve_vl_vcmpswzx_vsvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvcmps_vvvl : GCCBuiltin<"__builtin_ve_vl_pvcmps_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvcmps_vvvvl : GCCBuiltin<"__builtin_ve_vl_pvcmps_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvcmps_vsvl : GCCBuiltin<"__builtin_ve_vl_pvcmps_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvcmps_vsvvl : GCCBuiltin<"__builtin_ve_vl_pvcmps_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvcmps_vvvMvl : GCCBuiltin<"__builtin_ve_vl_pvcmps_vvvMvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvcmps_vsvMvl : GCCBuiltin<"__builtin_ve_vl_pvcmps_vsvMvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcmpsl_vvvl : GCCBuiltin<"__builtin_ve_vl_vcmpsl_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcmpsl_vvvvl : GCCBuiltin<"__builtin_ve_vl_vcmpsl_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcmpsl_vsvl : GCCBuiltin<"__builtin_ve_vl_vcmpsl_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcmpsl_vsvvl : GCCBuiltin<"__builtin_ve_vl_vcmpsl_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcmpsl_vvvmvl : GCCBuiltin<"__builtin_ve_vl_vcmpsl_vvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcmpsl_vsvmvl : GCCBuiltin<"__builtin_ve_vl_vcmpsl_vsvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vmaxswsx_vvvl : GCCBuiltin<"__builtin_ve_vl_vmaxswsx_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vmaxswsx_vvvvl : GCCBuiltin<"__builtin_ve_vl_vmaxswsx_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vmaxswsx_vsvl : GCCBuiltin<"__builtin_ve_vl_vmaxswsx_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vmaxswsx_vsvvl : GCCBuiltin<"__builtin_ve_vl_vmaxswsx_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vmaxswsx_vvvmvl : GCCBuiltin<"__builtin_ve_vl_vmaxswsx_vvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vmaxswsx_vsvmvl : GCCBuiltin<"__builtin_ve_vl_vmaxswsx_vsvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vmaxswzx_vvvl : GCCBuiltin<"__builtin_ve_vl_vmaxswzx_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vmaxswzx_vvvvl : GCCBuiltin<"__builtin_ve_vl_vmaxswzx_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vmaxswzx_vsvl : GCCBuiltin<"__builtin_ve_vl_vmaxswzx_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vmaxswzx_vsvvl : GCCBuiltin<"__builtin_ve_vl_vmaxswzx_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vmaxswzx_vvvmvl : GCCBuiltin<"__builtin_ve_vl_vmaxswzx_vvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vmaxswzx_vsvmvl : GCCBuiltin<"__builtin_ve_vl_vmaxswzx_vsvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvmaxs_vvvl : GCCBuiltin<"__builtin_ve_vl_pvmaxs_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvmaxs_vvvvl : GCCBuiltin<"__builtin_ve_vl_pvmaxs_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvmaxs_vsvl : GCCBuiltin<"__builtin_ve_vl_pvmaxs_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvmaxs_vsvvl : GCCBuiltin<"__builtin_ve_vl_pvmaxs_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvmaxs_vvvMvl : GCCBuiltin<"__builtin_ve_vl_pvmaxs_vvvMvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvmaxs_vsvMvl : GCCBuiltin<"__builtin_ve_vl_pvmaxs_vsvMvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vminswsx_vvvl : GCCBuiltin<"__builtin_ve_vl_vminswsx_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vminswsx_vvvvl : GCCBuiltin<"__builtin_ve_vl_vminswsx_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vminswsx_vsvl : GCCBuiltin<"__builtin_ve_vl_vminswsx_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vminswsx_vsvvl : GCCBuiltin<"__builtin_ve_vl_vminswsx_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vminswsx_vvvmvl : GCCBuiltin<"__builtin_ve_vl_vminswsx_vvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vminswsx_vsvmvl : GCCBuiltin<"__builtin_ve_vl_vminswsx_vsvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vminswzx_vvvl : GCCBuiltin<"__builtin_ve_vl_vminswzx_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vminswzx_vvvvl : GCCBuiltin<"__builtin_ve_vl_vminswzx_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vminswzx_vsvl : GCCBuiltin<"__builtin_ve_vl_vminswzx_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vminswzx_vsvvl : GCCBuiltin<"__builtin_ve_vl_vminswzx_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vminswzx_vvvmvl : GCCBuiltin<"__builtin_ve_vl_vminswzx_vvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vminswzx_vsvmvl : GCCBuiltin<"__builtin_ve_vl_vminswzx_vsvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvmins_vvvl : GCCBuiltin<"__builtin_ve_vl_pvmins_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvmins_vvvvl : GCCBuiltin<"__builtin_ve_vl_pvmins_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvmins_vsvl : GCCBuiltin<"__builtin_ve_vl_pvmins_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvmins_vsvvl : GCCBuiltin<"__builtin_ve_vl_pvmins_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvmins_vvvMvl : GCCBuiltin<"__builtin_ve_vl_pvmins_vvvMvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvmins_vsvMvl : GCCBuiltin<"__builtin_ve_vl_pvmins_vsvMvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vmaxsl_vvvl : GCCBuiltin<"__builtin_ve_vl_vmaxsl_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vmaxsl_vvvvl : GCCBuiltin<"__builtin_ve_vl_vmaxsl_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vmaxsl_vsvl : GCCBuiltin<"__builtin_ve_vl_vmaxsl_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vmaxsl_vsvvl : GCCBuiltin<"__builtin_ve_vl_vmaxsl_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vmaxsl_vvvmvl : GCCBuiltin<"__builtin_ve_vl_vmaxsl_vvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vmaxsl_vsvmvl : GCCBuiltin<"__builtin_ve_vl_vmaxsl_vsvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vminsl_vvvl : GCCBuiltin<"__builtin_ve_vl_vminsl_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vminsl_vvvvl : GCCBuiltin<"__builtin_ve_vl_vminsl_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vminsl_vsvl : GCCBuiltin<"__builtin_ve_vl_vminsl_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vminsl_vsvvl : GCCBuiltin<"__builtin_ve_vl_vminsl_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vminsl_vvvmvl : GCCBuiltin<"__builtin_ve_vl_vminsl_vvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vminsl_vsvmvl : GCCBuiltin<"__builtin_ve_vl_vminsl_vsvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vand_vvvl : GCCBuiltin<"__builtin_ve_vl_vand_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vand_vvvvl : GCCBuiltin<"__builtin_ve_vl_vand_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vand_vsvl : GCCBuiltin<"__builtin_ve_vl_vand_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vand_vsvvl : GCCBuiltin<"__builtin_ve_vl_vand_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vand_vvvmvl : GCCBuiltin<"__builtin_ve_vl_vand_vvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vand_vsvmvl : GCCBuiltin<"__builtin_ve_vl_vand_vsvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvand_vvvl : GCCBuiltin<"__builtin_ve_vl_pvand_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvand_vvvvl : GCCBuiltin<"__builtin_ve_vl_pvand_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvand_vsvl : GCCBuiltin<"__builtin_ve_vl_pvand_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvand_vsvvl : GCCBuiltin<"__builtin_ve_vl_pvand_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvand_vvvMvl : GCCBuiltin<"__builtin_ve_vl_pvand_vvvMvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvand_vsvMvl : GCCBuiltin<"__builtin_ve_vl_pvand_vsvMvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vor_vvvl : GCCBuiltin<"__builtin_ve_vl_vor_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vor_vvvvl : GCCBuiltin<"__builtin_ve_vl_vor_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vor_vsvl : GCCBuiltin<"__builtin_ve_vl_vor_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vor_vsvvl : GCCBuiltin<"__builtin_ve_vl_vor_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vor_vvvmvl : GCCBuiltin<"__builtin_ve_vl_vor_vvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vor_vsvmvl : GCCBuiltin<"__builtin_ve_vl_vor_vsvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvor_vvvl : GCCBuiltin<"__builtin_ve_vl_pvor_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvor_vvvvl : GCCBuiltin<"__builtin_ve_vl_pvor_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvor_vsvl : GCCBuiltin<"__builtin_ve_vl_pvor_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvor_vsvvl : GCCBuiltin<"__builtin_ve_vl_pvor_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvor_vvvMvl : GCCBuiltin<"__builtin_ve_vl_pvor_vvvMvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvor_vsvMvl : GCCBuiltin<"__builtin_ve_vl_pvor_vsvMvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vxor_vvvl : GCCBuiltin<"__builtin_ve_vl_vxor_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vxor_vvvvl : GCCBuiltin<"__builtin_ve_vl_vxor_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vxor_vsvl : GCCBuiltin<"__builtin_ve_vl_vxor_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vxor_vsvvl : GCCBuiltin<"__builtin_ve_vl_vxor_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vxor_vvvmvl : GCCBuiltin<"__builtin_ve_vl_vxor_vvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vxor_vsvmvl : GCCBuiltin<"__builtin_ve_vl_vxor_vsvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvxor_vvvl : GCCBuiltin<"__builtin_ve_vl_pvxor_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvxor_vvvvl : GCCBuiltin<"__builtin_ve_vl_pvxor_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvxor_vsvl : GCCBuiltin<"__builtin_ve_vl_pvxor_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvxor_vsvvl : GCCBuiltin<"__builtin_ve_vl_pvxor_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvxor_vvvMvl : GCCBuiltin<"__builtin_ve_vl_pvxor_vvvMvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvxor_vsvMvl : GCCBuiltin<"__builtin_ve_vl_pvxor_vsvMvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_veqv_vvvl : GCCBuiltin<"__builtin_ve_vl_veqv_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_veqv_vvvvl : GCCBuiltin<"__builtin_ve_vl_veqv_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_veqv_vsvl : GCCBuiltin<"__builtin_ve_vl_veqv_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_veqv_vsvvl : GCCBuiltin<"__builtin_ve_vl_veqv_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_veqv_vvvmvl : GCCBuiltin<"__builtin_ve_vl_veqv_vvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_veqv_vsvmvl : GCCBuiltin<"__builtin_ve_vl_veqv_vsvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pveqv_vvvl : GCCBuiltin<"__builtin_ve_vl_pveqv_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pveqv_vvvvl : GCCBuiltin<"__builtin_ve_vl_pveqv_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pveqv_vsvl : GCCBuiltin<"__builtin_ve_vl_pveqv_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pveqv_vsvvl : GCCBuiltin<"__builtin_ve_vl_pveqv_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pveqv_vvvMvl : GCCBuiltin<"__builtin_ve_vl_pveqv_vvvMvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pveqv_vsvMvl : GCCBuiltin<"__builtin_ve_vl_pveqv_vsvMvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vseq_vl : GCCBuiltin<"__builtin_ve_vl_vseq_vl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vseq_vvl : GCCBuiltin<"__builtin_ve_vl_vseq_vvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvseqlo_vl : GCCBuiltin<"__builtin_ve_vl_pvseqlo_vl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvseqlo_vvl : GCCBuiltin<"__builtin_ve_vl_pvseqlo_vvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvsequp_vl : GCCBuiltin<"__builtin_ve_vl_pvsequp_vl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvsequp_vvl : GCCBuiltin<"__builtin_ve_vl_pvsequp_vvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvseq_vl : GCCBuiltin<"__builtin_ve_vl_pvseq_vl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvseq_vvl : GCCBuiltin<"__builtin_ve_vl_pvseq_vvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsll_vvvl : GCCBuiltin<"__builtin_ve_vl_vsll_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsll_vvvvl : GCCBuiltin<"__builtin_ve_vl_vsll_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsll_vvsl : GCCBuiltin<"__builtin_ve_vl_vsll_vvsl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsll_vvsvl : GCCBuiltin<"__builtin_ve_vl_vsll_vvsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsll_vvvmvl : GCCBuiltin<"__builtin_ve_vl_vsll_vvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsll_vvsmvl : GCCBuiltin<"__builtin_ve_vl_vsll_vvsmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvsll_vvvl : GCCBuiltin<"__builtin_ve_vl_pvsll_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvsll_vvvvl : GCCBuiltin<"__builtin_ve_vl_pvsll_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvsll_vvsl : GCCBuiltin<"__builtin_ve_vl_pvsll_vvsl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvsll_vvsvl : GCCBuiltin<"__builtin_ve_vl_pvsll_vvsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvsll_vvvMvl : GCCBuiltin<"__builtin_ve_vl_pvsll_vvvMvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvsll_vvsMvl : GCCBuiltin<"__builtin_ve_vl_pvsll_vvsMvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<v512i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsrl_vvvl : GCCBuiltin<"__builtin_ve_vl_vsrl_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsrl_vvvvl : GCCBuiltin<"__builtin_ve_vl_vsrl_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsrl_vvsl : GCCBuiltin<"__builtin_ve_vl_vsrl_vvsl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsrl_vvsvl : GCCBuiltin<"__builtin_ve_vl_vsrl_vvsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsrl_vvvmvl : GCCBuiltin<"__builtin_ve_vl_vsrl_vvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsrl_vvsmvl : GCCBuiltin<"__builtin_ve_vl_vsrl_vvsmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvsrl_vvvl : GCCBuiltin<"__builtin_ve_vl_pvsrl_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvsrl_vvvvl : GCCBuiltin<"__builtin_ve_vl_pvsrl_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvsrl_vvsl : GCCBuiltin<"__builtin_ve_vl_pvsrl_vvsl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvsrl_vvsvl : GCCBuiltin<"__builtin_ve_vl_pvsrl_vvsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvsrl_vvvMvl : GCCBuiltin<"__builtin_ve_vl_pvsrl_vvvMvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvsrl_vvsMvl : GCCBuiltin<"__builtin_ve_vl_pvsrl_vvsMvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<v512i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vslawsx_vvvl : GCCBuiltin<"__builtin_ve_vl_vslawsx_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vslawsx_vvvvl : GCCBuiltin<"__builtin_ve_vl_vslawsx_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vslawsx_vvsl : GCCBuiltin<"__builtin_ve_vl_vslawsx_vvsl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vslawsx_vvsvl : GCCBuiltin<"__builtin_ve_vl_vslawsx_vvsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vslawsx_vvvmvl : GCCBuiltin<"__builtin_ve_vl_vslawsx_vvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vslawsx_vvsmvl : GCCBuiltin<"__builtin_ve_vl_vslawsx_vvsmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vslawzx_vvvl : GCCBuiltin<"__builtin_ve_vl_vslawzx_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vslawzx_vvvvl : GCCBuiltin<"__builtin_ve_vl_vslawzx_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vslawzx_vvsl : GCCBuiltin<"__builtin_ve_vl_vslawzx_vvsl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vslawzx_vvsvl : GCCBuiltin<"__builtin_ve_vl_vslawzx_vvsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vslawzx_vvvmvl : GCCBuiltin<"__builtin_ve_vl_vslawzx_vvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vslawzx_vvsmvl : GCCBuiltin<"__builtin_ve_vl_vslawzx_vvsmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvsla_vvvl : GCCBuiltin<"__builtin_ve_vl_pvsla_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvsla_vvvvl : GCCBuiltin<"__builtin_ve_vl_pvsla_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvsla_vvsl : GCCBuiltin<"__builtin_ve_vl_pvsla_vvsl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvsla_vvsvl : GCCBuiltin<"__builtin_ve_vl_pvsla_vvsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvsla_vvvMvl : GCCBuiltin<"__builtin_ve_vl_pvsla_vvvMvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvsla_vvsMvl : GCCBuiltin<"__builtin_ve_vl_pvsla_vvsMvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<v512i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vslal_vvvl : GCCBuiltin<"__builtin_ve_vl_vslal_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vslal_vvvvl : GCCBuiltin<"__builtin_ve_vl_vslal_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vslal_vvsl : GCCBuiltin<"__builtin_ve_vl_vslal_vvsl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vslal_vvsvl : GCCBuiltin<"__builtin_ve_vl_vslal_vvsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vslal_vvvmvl : GCCBuiltin<"__builtin_ve_vl_vslal_vvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vslal_vvsmvl : GCCBuiltin<"__builtin_ve_vl_vslal_vvsmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsrawsx_vvvl : GCCBuiltin<"__builtin_ve_vl_vsrawsx_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsrawsx_vvvvl : GCCBuiltin<"__builtin_ve_vl_vsrawsx_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsrawsx_vvsl : GCCBuiltin<"__builtin_ve_vl_vsrawsx_vvsl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsrawsx_vvsvl : GCCBuiltin<"__builtin_ve_vl_vsrawsx_vvsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsrawsx_vvvmvl : GCCBuiltin<"__builtin_ve_vl_vsrawsx_vvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsrawsx_vvsmvl : GCCBuiltin<"__builtin_ve_vl_vsrawsx_vvsmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsrawzx_vvvl : GCCBuiltin<"__builtin_ve_vl_vsrawzx_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsrawzx_vvvvl : GCCBuiltin<"__builtin_ve_vl_vsrawzx_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsrawzx_vvsl : GCCBuiltin<"__builtin_ve_vl_vsrawzx_vvsl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsrawzx_vvsvl : GCCBuiltin<"__builtin_ve_vl_vsrawzx_vvsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsrawzx_vvvmvl : GCCBuiltin<"__builtin_ve_vl_vsrawzx_vvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsrawzx_vvsmvl : GCCBuiltin<"__builtin_ve_vl_vsrawzx_vvsmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvsra_vvvl : GCCBuiltin<"__builtin_ve_vl_pvsra_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvsra_vvvvl : GCCBuiltin<"__builtin_ve_vl_pvsra_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvsra_vvsl : GCCBuiltin<"__builtin_ve_vl_pvsra_vvsl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvsra_vvsvl : GCCBuiltin<"__builtin_ve_vl_pvsra_vvsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvsra_vvvMvl : GCCBuiltin<"__builtin_ve_vl_pvsra_vvvMvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvsra_vvsMvl : GCCBuiltin<"__builtin_ve_vl_pvsra_vvsMvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<v512i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsral_vvvl : GCCBuiltin<"__builtin_ve_vl_vsral_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsral_vvvvl : GCCBuiltin<"__builtin_ve_vl_vsral_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsral_vvsl : GCCBuiltin<"__builtin_ve_vl_vsral_vvsl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsral_vvsvl : GCCBuiltin<"__builtin_ve_vl_vsral_vvsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsral_vvvmvl : GCCBuiltin<"__builtin_ve_vl_vsral_vvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsral_vvsmvl : GCCBuiltin<"__builtin_ve_vl_vsral_vvsmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsfa_vvssl : GCCBuiltin<"__builtin_ve_vl_vsfa_vvssl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<i64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsfa_vvssvl : GCCBuiltin<"__builtin_ve_vl_vsfa_vvssvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<i64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsfa_vvssmvl : GCCBuiltin<"__builtin_ve_vl_vsfa_vvssmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<i64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfaddd_vvvl : GCCBuiltin<"__builtin_ve_vl_vfaddd_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfaddd_vvvvl : GCCBuiltin<"__builtin_ve_vl_vfaddd_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfaddd_vsvl : GCCBuiltin<"__builtin_ve_vl_vfaddd_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfaddd_vsvvl : GCCBuiltin<"__builtin_ve_vl_vfaddd_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfaddd_vvvmvl : GCCBuiltin<"__builtin_ve_vl_vfaddd_vvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfaddd_vsvmvl : GCCBuiltin<"__builtin_ve_vl_vfaddd_vsvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfadds_vvvl : GCCBuiltin<"__builtin_ve_vl_vfadds_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfadds_vvvvl : GCCBuiltin<"__builtin_ve_vl_vfadds_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfadds_vsvl : GCCBuiltin<"__builtin_ve_vl_vfadds_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f32>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfadds_vsvvl : GCCBuiltin<"__builtin_ve_vl_vfadds_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f32>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfadds_vvvmvl : GCCBuiltin<"__builtin_ve_vl_vfadds_vvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfadds_vsvmvl : GCCBuiltin<"__builtin_ve_vl_vfadds_vsvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f32>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfadd_vvvl : GCCBuiltin<"__builtin_ve_vl_pvfadd_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfadd_vvvvl : GCCBuiltin<"__builtin_ve_vl_pvfadd_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfadd_vsvl : GCCBuiltin<"__builtin_ve_vl_pvfadd_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfadd_vsvvl : GCCBuiltin<"__builtin_ve_vl_pvfadd_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfadd_vvvMvl : GCCBuiltin<"__builtin_ve_vl_pvfadd_vvvMvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfadd_vsvMvl : GCCBuiltin<"__builtin_ve_vl_pvfadd_vsvMvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfsubd_vvvl : GCCBuiltin<"__builtin_ve_vl_vfsubd_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfsubd_vvvvl : GCCBuiltin<"__builtin_ve_vl_vfsubd_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfsubd_vsvl : GCCBuiltin<"__builtin_ve_vl_vfsubd_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfsubd_vsvvl : GCCBuiltin<"__builtin_ve_vl_vfsubd_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfsubd_vvvmvl : GCCBuiltin<"__builtin_ve_vl_vfsubd_vvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfsubd_vsvmvl : GCCBuiltin<"__builtin_ve_vl_vfsubd_vsvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfsubs_vvvl : GCCBuiltin<"__builtin_ve_vl_vfsubs_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfsubs_vvvvl : GCCBuiltin<"__builtin_ve_vl_vfsubs_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfsubs_vsvl : GCCBuiltin<"__builtin_ve_vl_vfsubs_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f32>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfsubs_vsvvl : GCCBuiltin<"__builtin_ve_vl_vfsubs_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f32>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfsubs_vvvmvl : GCCBuiltin<"__builtin_ve_vl_vfsubs_vvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfsubs_vsvmvl : GCCBuiltin<"__builtin_ve_vl_vfsubs_vsvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f32>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfsub_vvvl : GCCBuiltin<"__builtin_ve_vl_pvfsub_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfsub_vvvvl : GCCBuiltin<"__builtin_ve_vl_pvfsub_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfsub_vsvl : GCCBuiltin<"__builtin_ve_vl_pvfsub_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfsub_vsvvl : GCCBuiltin<"__builtin_ve_vl_pvfsub_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfsub_vvvMvl : GCCBuiltin<"__builtin_ve_vl_pvfsub_vvvMvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfsub_vsvMvl : GCCBuiltin<"__builtin_ve_vl_pvfsub_vsvMvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmuld_vvvl : GCCBuiltin<"__builtin_ve_vl_vfmuld_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmuld_vvvvl : GCCBuiltin<"__builtin_ve_vl_vfmuld_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmuld_vsvl : GCCBuiltin<"__builtin_ve_vl_vfmuld_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmuld_vsvvl : GCCBuiltin<"__builtin_ve_vl_vfmuld_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmuld_vvvmvl : GCCBuiltin<"__builtin_ve_vl_vfmuld_vvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmuld_vsvmvl : GCCBuiltin<"__builtin_ve_vl_vfmuld_vsvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmuls_vvvl : GCCBuiltin<"__builtin_ve_vl_vfmuls_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmuls_vvvvl : GCCBuiltin<"__builtin_ve_vl_vfmuls_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmuls_vsvl : GCCBuiltin<"__builtin_ve_vl_vfmuls_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f32>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmuls_vsvvl : GCCBuiltin<"__builtin_ve_vl_vfmuls_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f32>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmuls_vvvmvl : GCCBuiltin<"__builtin_ve_vl_vfmuls_vvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmuls_vsvmvl : GCCBuiltin<"__builtin_ve_vl_vfmuls_vsvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f32>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmul_vvvl : GCCBuiltin<"__builtin_ve_vl_pvfmul_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmul_vvvvl : GCCBuiltin<"__builtin_ve_vl_pvfmul_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmul_vsvl : GCCBuiltin<"__builtin_ve_vl_pvfmul_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmul_vsvvl : GCCBuiltin<"__builtin_ve_vl_pvfmul_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmul_vvvMvl : GCCBuiltin<"__builtin_ve_vl_pvfmul_vvvMvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmul_vsvMvl : GCCBuiltin<"__builtin_ve_vl_pvfmul_vsvMvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfdivd_vvvl : GCCBuiltin<"__builtin_ve_vl_vfdivd_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfdivd_vvvvl : GCCBuiltin<"__builtin_ve_vl_vfdivd_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfdivd_vsvl : GCCBuiltin<"__builtin_ve_vl_vfdivd_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfdivd_vsvvl : GCCBuiltin<"__builtin_ve_vl_vfdivd_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfdivd_vvvmvl : GCCBuiltin<"__builtin_ve_vl_vfdivd_vvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfdivd_vsvmvl : GCCBuiltin<"__builtin_ve_vl_vfdivd_vsvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfdivs_vvvl : GCCBuiltin<"__builtin_ve_vl_vfdivs_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfdivs_vvvvl : GCCBuiltin<"__builtin_ve_vl_vfdivs_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfdivs_vsvl : GCCBuiltin<"__builtin_ve_vl_vfdivs_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f32>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfdivs_vsvvl : GCCBuiltin<"__builtin_ve_vl_vfdivs_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f32>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfdivs_vvvmvl : GCCBuiltin<"__builtin_ve_vl_vfdivs_vvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfdivs_vsvmvl : GCCBuiltin<"__builtin_ve_vl_vfdivs_vsvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f32>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfsqrtd_vvl : GCCBuiltin<"__builtin_ve_vl_vfsqrtd_vvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfsqrtd_vvvl : GCCBuiltin<"__builtin_ve_vl_vfsqrtd_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfsqrts_vvl : GCCBuiltin<"__builtin_ve_vl_vfsqrts_vvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfsqrts_vvvl : GCCBuiltin<"__builtin_ve_vl_vfsqrts_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfcmpd_vvvl : GCCBuiltin<"__builtin_ve_vl_vfcmpd_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfcmpd_vvvvl : GCCBuiltin<"__builtin_ve_vl_vfcmpd_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfcmpd_vsvl : GCCBuiltin<"__builtin_ve_vl_vfcmpd_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfcmpd_vsvvl : GCCBuiltin<"__builtin_ve_vl_vfcmpd_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfcmpd_vvvmvl : GCCBuiltin<"__builtin_ve_vl_vfcmpd_vvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfcmpd_vsvmvl : GCCBuiltin<"__builtin_ve_vl_vfcmpd_vsvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfcmps_vvvl : GCCBuiltin<"__builtin_ve_vl_vfcmps_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfcmps_vvvvl : GCCBuiltin<"__builtin_ve_vl_vfcmps_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfcmps_vsvl : GCCBuiltin<"__builtin_ve_vl_vfcmps_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f32>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfcmps_vsvvl : GCCBuiltin<"__builtin_ve_vl_vfcmps_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f32>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfcmps_vvvmvl : GCCBuiltin<"__builtin_ve_vl_vfcmps_vvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfcmps_vsvmvl : GCCBuiltin<"__builtin_ve_vl_vfcmps_vsvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f32>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfcmp_vvvl : GCCBuiltin<"__builtin_ve_vl_pvfcmp_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfcmp_vvvvl : GCCBuiltin<"__builtin_ve_vl_pvfcmp_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfcmp_vsvl : GCCBuiltin<"__builtin_ve_vl_pvfcmp_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfcmp_vsvvl : GCCBuiltin<"__builtin_ve_vl_pvfcmp_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfcmp_vvvMvl : GCCBuiltin<"__builtin_ve_vl_pvfcmp_vvvMvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfcmp_vsvMvl : GCCBuiltin<"__builtin_ve_vl_pvfcmp_vsvMvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmaxd_vvvl : GCCBuiltin<"__builtin_ve_vl_vfmaxd_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmaxd_vvvvl : GCCBuiltin<"__builtin_ve_vl_vfmaxd_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmaxd_vsvl : GCCBuiltin<"__builtin_ve_vl_vfmaxd_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmaxd_vsvvl : GCCBuiltin<"__builtin_ve_vl_vfmaxd_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmaxd_vvvmvl : GCCBuiltin<"__builtin_ve_vl_vfmaxd_vvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmaxd_vsvmvl : GCCBuiltin<"__builtin_ve_vl_vfmaxd_vsvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmaxs_vvvl : GCCBuiltin<"__builtin_ve_vl_vfmaxs_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmaxs_vvvvl : GCCBuiltin<"__builtin_ve_vl_vfmaxs_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmaxs_vsvl : GCCBuiltin<"__builtin_ve_vl_vfmaxs_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f32>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmaxs_vsvvl : GCCBuiltin<"__builtin_ve_vl_vfmaxs_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f32>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmaxs_vvvmvl : GCCBuiltin<"__builtin_ve_vl_vfmaxs_vvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmaxs_vsvmvl : GCCBuiltin<"__builtin_ve_vl_vfmaxs_vsvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f32>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmax_vvvl : GCCBuiltin<"__builtin_ve_vl_pvfmax_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmax_vvvvl : GCCBuiltin<"__builtin_ve_vl_pvfmax_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmax_vsvl : GCCBuiltin<"__builtin_ve_vl_pvfmax_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmax_vsvvl : GCCBuiltin<"__builtin_ve_vl_pvfmax_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmax_vvvMvl : GCCBuiltin<"__builtin_ve_vl_pvfmax_vvvMvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmax_vsvMvl : GCCBuiltin<"__builtin_ve_vl_pvfmax_vsvMvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmind_vvvl : GCCBuiltin<"__builtin_ve_vl_vfmind_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmind_vvvvl : GCCBuiltin<"__builtin_ve_vl_vfmind_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmind_vsvl : GCCBuiltin<"__builtin_ve_vl_vfmind_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmind_vsvvl : GCCBuiltin<"__builtin_ve_vl_vfmind_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmind_vvvmvl : GCCBuiltin<"__builtin_ve_vl_vfmind_vvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmind_vsvmvl : GCCBuiltin<"__builtin_ve_vl_vfmind_vsvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmins_vvvl : GCCBuiltin<"__builtin_ve_vl_vfmins_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmins_vvvvl : GCCBuiltin<"__builtin_ve_vl_vfmins_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmins_vsvl : GCCBuiltin<"__builtin_ve_vl_vfmins_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f32>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmins_vsvvl : GCCBuiltin<"__builtin_ve_vl_vfmins_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f32>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmins_vvvmvl : GCCBuiltin<"__builtin_ve_vl_vfmins_vvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmins_vsvmvl : GCCBuiltin<"__builtin_ve_vl_vfmins_vsvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f32>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmin_vvvl : GCCBuiltin<"__builtin_ve_vl_pvfmin_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmin_vvvvl : GCCBuiltin<"__builtin_ve_vl_pvfmin_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmin_vsvl : GCCBuiltin<"__builtin_ve_vl_pvfmin_vsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmin_vsvvl : GCCBuiltin<"__builtin_ve_vl_pvfmin_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmin_vvvMvl : GCCBuiltin<"__builtin_ve_vl_pvfmin_vvvMvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmin_vsvMvl : GCCBuiltin<"__builtin_ve_vl_pvfmin_vsvMvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmadd_vvvvl : GCCBuiltin<"__builtin_ve_vl_vfmadd_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmadd_vvvvvl : GCCBuiltin<"__builtin_ve_vl_vfmadd_vvvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmadd_vsvvl : GCCBuiltin<"__builtin_ve_vl_vfmadd_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmadd_vsvvvl : GCCBuiltin<"__builtin_ve_vl_vfmadd_vsvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmadd_vvsvl : GCCBuiltin<"__builtin_ve_vl_vfmadd_vvsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmadd_vvsvvl : GCCBuiltin<"__builtin_ve_vl_vfmadd_vvsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmadd_vvvvmvl : GCCBuiltin<"__builtin_ve_vl_vfmadd_vvvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmadd_vsvvmvl : GCCBuiltin<"__builtin_ve_vl_vfmadd_vsvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmadd_vvsvmvl : GCCBuiltin<"__builtin_ve_vl_vfmadd_vvsvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmads_vvvvl : GCCBuiltin<"__builtin_ve_vl_vfmads_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmads_vvvvvl : GCCBuiltin<"__builtin_ve_vl_vfmads_vvvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmads_vsvvl : GCCBuiltin<"__builtin_ve_vl_vfmads_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f32>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmads_vsvvvl : GCCBuiltin<"__builtin_ve_vl_vfmads_vsvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f32>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmads_vvsvl : GCCBuiltin<"__builtin_ve_vl_vfmads_vvsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<f32>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmads_vvsvvl : GCCBuiltin<"__builtin_ve_vl_vfmads_vvsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<f32>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmads_vvvvmvl : GCCBuiltin<"__builtin_ve_vl_vfmads_vvvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmads_vsvvmvl : GCCBuiltin<"__builtin_ve_vl_vfmads_vsvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f32>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmads_vvsvmvl : GCCBuiltin<"__builtin_ve_vl_vfmads_vvsvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<f32>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmad_vvvvl : GCCBuiltin<"__builtin_ve_vl_pvfmad_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmad_vvvvvl : GCCBuiltin<"__builtin_ve_vl_pvfmad_vvvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmad_vsvvl : GCCBuiltin<"__builtin_ve_vl_pvfmad_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmad_vsvvvl : GCCBuiltin<"__builtin_ve_vl_pvfmad_vsvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmad_vvsvl : GCCBuiltin<"__builtin_ve_vl_pvfmad_vvsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmad_vvsvvl : GCCBuiltin<"__builtin_ve_vl_pvfmad_vvsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmad_vvvvMvl : GCCBuiltin<"__builtin_ve_vl_pvfmad_vvvvMvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmad_vsvvMvl : GCCBuiltin<"__builtin_ve_vl_pvfmad_vsvvMvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmad_vvsvMvl : GCCBuiltin<"__builtin_ve_vl_pvfmad_vvsvMvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmsbd_vvvvl : GCCBuiltin<"__builtin_ve_vl_vfmsbd_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmsbd_vvvvvl : GCCBuiltin<"__builtin_ve_vl_vfmsbd_vvvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmsbd_vsvvl : GCCBuiltin<"__builtin_ve_vl_vfmsbd_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmsbd_vsvvvl : GCCBuiltin<"__builtin_ve_vl_vfmsbd_vsvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmsbd_vvsvl : GCCBuiltin<"__builtin_ve_vl_vfmsbd_vvsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmsbd_vvsvvl : GCCBuiltin<"__builtin_ve_vl_vfmsbd_vvsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmsbd_vvvvmvl : GCCBuiltin<"__builtin_ve_vl_vfmsbd_vvvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmsbd_vsvvmvl : GCCBuiltin<"__builtin_ve_vl_vfmsbd_vsvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmsbd_vvsvmvl : GCCBuiltin<"__builtin_ve_vl_vfmsbd_vvsvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmsbs_vvvvl : GCCBuiltin<"__builtin_ve_vl_vfmsbs_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmsbs_vvvvvl : GCCBuiltin<"__builtin_ve_vl_vfmsbs_vvvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmsbs_vsvvl : GCCBuiltin<"__builtin_ve_vl_vfmsbs_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f32>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmsbs_vsvvvl : GCCBuiltin<"__builtin_ve_vl_vfmsbs_vsvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f32>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmsbs_vvsvl : GCCBuiltin<"__builtin_ve_vl_vfmsbs_vvsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<f32>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmsbs_vvsvvl : GCCBuiltin<"__builtin_ve_vl_vfmsbs_vvsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<f32>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmsbs_vvvvmvl : GCCBuiltin<"__builtin_ve_vl_vfmsbs_vvvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmsbs_vsvvmvl : GCCBuiltin<"__builtin_ve_vl_vfmsbs_vsvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f32>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmsbs_vvsvmvl : GCCBuiltin<"__builtin_ve_vl_vfmsbs_vvsvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<f32>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmsb_vvvvl : GCCBuiltin<"__builtin_ve_vl_pvfmsb_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmsb_vvvvvl : GCCBuiltin<"__builtin_ve_vl_pvfmsb_vvvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmsb_vsvvl : GCCBuiltin<"__builtin_ve_vl_pvfmsb_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmsb_vsvvvl : GCCBuiltin<"__builtin_ve_vl_pvfmsb_vsvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmsb_vvsvl : GCCBuiltin<"__builtin_ve_vl_pvfmsb_vvsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmsb_vvsvvl : GCCBuiltin<"__builtin_ve_vl_pvfmsb_vvsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmsb_vvvvMvl : GCCBuiltin<"__builtin_ve_vl_pvfmsb_vvvvMvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmsb_vsvvMvl : GCCBuiltin<"__builtin_ve_vl_pvfmsb_vsvvMvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmsb_vvsvMvl : GCCBuiltin<"__builtin_ve_vl_pvfmsb_vvsvMvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfnmadd_vvvvl : GCCBuiltin<"__builtin_ve_vl_vfnmadd_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfnmadd_vvvvvl : GCCBuiltin<"__builtin_ve_vl_vfnmadd_vvvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfnmadd_vsvvl : GCCBuiltin<"__builtin_ve_vl_vfnmadd_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfnmadd_vsvvvl : GCCBuiltin<"__builtin_ve_vl_vfnmadd_vsvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfnmadd_vvsvl : GCCBuiltin<"__builtin_ve_vl_vfnmadd_vvsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfnmadd_vvsvvl : GCCBuiltin<"__builtin_ve_vl_vfnmadd_vvsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfnmadd_vvvvmvl : GCCBuiltin<"__builtin_ve_vl_vfnmadd_vvvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfnmadd_vsvvmvl : GCCBuiltin<"__builtin_ve_vl_vfnmadd_vsvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfnmadd_vvsvmvl : GCCBuiltin<"__builtin_ve_vl_vfnmadd_vvsvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfnmads_vvvvl : GCCBuiltin<"__builtin_ve_vl_vfnmads_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfnmads_vvvvvl : GCCBuiltin<"__builtin_ve_vl_vfnmads_vvvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfnmads_vsvvl : GCCBuiltin<"__builtin_ve_vl_vfnmads_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f32>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfnmads_vsvvvl : GCCBuiltin<"__builtin_ve_vl_vfnmads_vsvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f32>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfnmads_vvsvl : GCCBuiltin<"__builtin_ve_vl_vfnmads_vvsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<f32>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfnmads_vvsvvl : GCCBuiltin<"__builtin_ve_vl_vfnmads_vvsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<f32>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfnmads_vvvvmvl : GCCBuiltin<"__builtin_ve_vl_vfnmads_vvvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfnmads_vsvvmvl : GCCBuiltin<"__builtin_ve_vl_vfnmads_vsvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f32>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfnmads_vvsvmvl : GCCBuiltin<"__builtin_ve_vl_vfnmads_vvsvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<f32>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfnmad_vvvvl : GCCBuiltin<"__builtin_ve_vl_pvfnmad_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfnmad_vvvvvl : GCCBuiltin<"__builtin_ve_vl_pvfnmad_vvvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfnmad_vsvvl : GCCBuiltin<"__builtin_ve_vl_pvfnmad_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfnmad_vsvvvl : GCCBuiltin<"__builtin_ve_vl_pvfnmad_vsvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfnmad_vvsvl : GCCBuiltin<"__builtin_ve_vl_pvfnmad_vvsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfnmad_vvsvvl : GCCBuiltin<"__builtin_ve_vl_pvfnmad_vvsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfnmad_vvvvMvl : GCCBuiltin<"__builtin_ve_vl_pvfnmad_vvvvMvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfnmad_vsvvMvl : GCCBuiltin<"__builtin_ve_vl_pvfnmad_vsvvMvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfnmad_vvsvMvl : GCCBuiltin<"__builtin_ve_vl_pvfnmad_vvsvMvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfnmsbd_vvvvl : GCCBuiltin<"__builtin_ve_vl_vfnmsbd_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfnmsbd_vvvvvl : GCCBuiltin<"__builtin_ve_vl_vfnmsbd_vvvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfnmsbd_vsvvl : GCCBuiltin<"__builtin_ve_vl_vfnmsbd_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfnmsbd_vsvvvl : GCCBuiltin<"__builtin_ve_vl_vfnmsbd_vsvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfnmsbd_vvsvl : GCCBuiltin<"__builtin_ve_vl_vfnmsbd_vvsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfnmsbd_vvsvvl : GCCBuiltin<"__builtin_ve_vl_vfnmsbd_vvsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfnmsbd_vvvvmvl : GCCBuiltin<"__builtin_ve_vl_vfnmsbd_vvvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfnmsbd_vsvvmvl : GCCBuiltin<"__builtin_ve_vl_vfnmsbd_vsvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfnmsbd_vvsvmvl : GCCBuiltin<"__builtin_ve_vl_vfnmsbd_vvsvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfnmsbs_vvvvl : GCCBuiltin<"__builtin_ve_vl_vfnmsbs_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfnmsbs_vvvvvl : GCCBuiltin<"__builtin_ve_vl_vfnmsbs_vvvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfnmsbs_vsvvl : GCCBuiltin<"__builtin_ve_vl_vfnmsbs_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f32>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfnmsbs_vsvvvl : GCCBuiltin<"__builtin_ve_vl_vfnmsbs_vsvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f32>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfnmsbs_vvsvl : GCCBuiltin<"__builtin_ve_vl_vfnmsbs_vvsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<f32>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfnmsbs_vvsvvl : GCCBuiltin<"__builtin_ve_vl_vfnmsbs_vvsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<f32>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfnmsbs_vvvvmvl : GCCBuiltin<"__builtin_ve_vl_vfnmsbs_vvvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfnmsbs_vsvvmvl : GCCBuiltin<"__builtin_ve_vl_vfnmsbs_vsvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<f32>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfnmsbs_vvsvmvl : GCCBuiltin<"__builtin_ve_vl_vfnmsbs_vvsvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<f32>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfnmsb_vvvvl : GCCBuiltin<"__builtin_ve_vl_pvfnmsb_vvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfnmsb_vvvvvl : GCCBuiltin<"__builtin_ve_vl_pvfnmsb_vvvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfnmsb_vsvvl : GCCBuiltin<"__builtin_ve_vl_pvfnmsb_vsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfnmsb_vsvvvl : GCCBuiltin<"__builtin_ve_vl_pvfnmsb_vsvvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfnmsb_vvsvl : GCCBuiltin<"__builtin_ve_vl_pvfnmsb_vvsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfnmsb_vvsvvl : GCCBuiltin<"__builtin_ve_vl_pvfnmsb_vvsvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfnmsb_vvvvMvl : GCCBuiltin<"__builtin_ve_vl_pvfnmsb_vvvvMvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfnmsb_vsvvMvl : GCCBuiltin<"__builtin_ve_vl_pvfnmsb_vsvvMvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfnmsb_vvsvMvl : GCCBuiltin<"__builtin_ve_vl_pvfnmsb_vvsvMvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vrcpd_vvl : GCCBuiltin<"__builtin_ve_vl_vrcpd_vvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vrcpd_vvvl : GCCBuiltin<"__builtin_ve_vl_vrcpd_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vrcps_vvl : GCCBuiltin<"__builtin_ve_vl_vrcps_vvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vrcps_vvvl : GCCBuiltin<"__builtin_ve_vl_vrcps_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvrcp_vvl : GCCBuiltin<"__builtin_ve_vl_pvrcp_vvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvrcp_vvvl : GCCBuiltin<"__builtin_ve_vl_pvrcp_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vrsqrtd_vvl : GCCBuiltin<"__builtin_ve_vl_vrsqrtd_vvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vrsqrtd_vvvl : GCCBuiltin<"__builtin_ve_vl_vrsqrtd_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vrsqrts_vvl : GCCBuiltin<"__builtin_ve_vl_vrsqrts_vvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vrsqrts_vvvl : GCCBuiltin<"__builtin_ve_vl_vrsqrts_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvrsqrt_vvl : GCCBuiltin<"__builtin_ve_vl_pvrsqrt_vvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvrsqrt_vvvl : GCCBuiltin<"__builtin_ve_vl_pvrsqrt_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vrsqrtdnex_vvl : GCCBuiltin<"__builtin_ve_vl_vrsqrtdnex_vvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vrsqrtdnex_vvvl : GCCBuiltin<"__builtin_ve_vl_vrsqrtdnex_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vrsqrtsnex_vvl : GCCBuiltin<"__builtin_ve_vl_vrsqrtsnex_vvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vrsqrtsnex_vvvl : GCCBuiltin<"__builtin_ve_vl_vrsqrtsnex_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvrsqrtnex_vvl : GCCBuiltin<"__builtin_ve_vl_pvrsqrtnex_vvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvrsqrtnex_vvvl : GCCBuiltin<"__builtin_ve_vl_pvrsqrtnex_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcvtwdsx_vvl : GCCBuiltin<"__builtin_ve_vl_vcvtwdsx_vvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcvtwdsx_vvvl : GCCBuiltin<"__builtin_ve_vl_vcvtwdsx_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcvtwdsx_vvmvl : GCCBuiltin<"__builtin_ve_vl_vcvtwdsx_vvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcvtwdsxrz_vvl : GCCBuiltin<"__builtin_ve_vl_vcvtwdsxrz_vvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcvtwdsxrz_vvvl : GCCBuiltin<"__builtin_ve_vl_vcvtwdsxrz_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcvtwdsxrz_vvmvl : GCCBuiltin<"__builtin_ve_vl_vcvtwdsxrz_vvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcvtwdzx_vvl : GCCBuiltin<"__builtin_ve_vl_vcvtwdzx_vvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcvtwdzx_vvvl : GCCBuiltin<"__builtin_ve_vl_vcvtwdzx_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcvtwdzx_vvmvl : GCCBuiltin<"__builtin_ve_vl_vcvtwdzx_vvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcvtwdzxrz_vvl : GCCBuiltin<"__builtin_ve_vl_vcvtwdzxrz_vvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcvtwdzxrz_vvvl : GCCBuiltin<"__builtin_ve_vl_vcvtwdzxrz_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcvtwdzxrz_vvmvl : GCCBuiltin<"__builtin_ve_vl_vcvtwdzxrz_vvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcvtwssx_vvl : GCCBuiltin<"__builtin_ve_vl_vcvtwssx_vvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcvtwssx_vvvl : GCCBuiltin<"__builtin_ve_vl_vcvtwssx_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcvtwssx_vvmvl : GCCBuiltin<"__builtin_ve_vl_vcvtwssx_vvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcvtwssxrz_vvl : GCCBuiltin<"__builtin_ve_vl_vcvtwssxrz_vvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcvtwssxrz_vvvl : GCCBuiltin<"__builtin_ve_vl_vcvtwssxrz_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcvtwssxrz_vvmvl : GCCBuiltin<"__builtin_ve_vl_vcvtwssxrz_vvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcvtwszx_vvl : GCCBuiltin<"__builtin_ve_vl_vcvtwszx_vvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcvtwszx_vvvl : GCCBuiltin<"__builtin_ve_vl_vcvtwszx_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcvtwszx_vvmvl : GCCBuiltin<"__builtin_ve_vl_vcvtwszx_vvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcvtwszxrz_vvl : GCCBuiltin<"__builtin_ve_vl_vcvtwszxrz_vvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcvtwszxrz_vvvl : GCCBuiltin<"__builtin_ve_vl_vcvtwszxrz_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcvtwszxrz_vvmvl : GCCBuiltin<"__builtin_ve_vl_vcvtwszxrz_vvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvcvtws_vvl : GCCBuiltin<"__builtin_ve_vl_pvcvtws_vvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvcvtws_vvvl : GCCBuiltin<"__builtin_ve_vl_pvcvtws_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvcvtws_vvMvl : GCCBuiltin<"__builtin_ve_vl_pvcvtws_vvMvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvcvtwsrz_vvl : GCCBuiltin<"__builtin_ve_vl_pvcvtwsrz_vvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvcvtwsrz_vvvl : GCCBuiltin<"__builtin_ve_vl_pvcvtwsrz_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvcvtwsrz_vvMvl : GCCBuiltin<"__builtin_ve_vl_pvcvtwsrz_vvMvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcvtld_vvl : GCCBuiltin<"__builtin_ve_vl_vcvtld_vvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcvtld_vvvl : GCCBuiltin<"__builtin_ve_vl_vcvtld_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcvtld_vvmvl : GCCBuiltin<"__builtin_ve_vl_vcvtld_vvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcvtldrz_vvl : GCCBuiltin<"__builtin_ve_vl_vcvtldrz_vvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcvtldrz_vvvl : GCCBuiltin<"__builtin_ve_vl_vcvtldrz_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcvtldrz_vvmvl : GCCBuiltin<"__builtin_ve_vl_vcvtldrz_vvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcvtdw_vvl : GCCBuiltin<"__builtin_ve_vl_vcvtdw_vvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcvtdw_vvvl : GCCBuiltin<"__builtin_ve_vl_vcvtdw_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcvtsw_vvl : GCCBuiltin<"__builtin_ve_vl_vcvtsw_vvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcvtsw_vvvl : GCCBuiltin<"__builtin_ve_vl_vcvtsw_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvcvtsw_vvl : GCCBuiltin<"__builtin_ve_vl_pvcvtsw_vvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvcvtsw_vvvl : GCCBuiltin<"__builtin_ve_vl_pvcvtsw_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcvtdl_vvl : GCCBuiltin<"__builtin_ve_vl_vcvtdl_vvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcvtdl_vvvl : GCCBuiltin<"__builtin_ve_vl_vcvtdl_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcvtds_vvl : GCCBuiltin<"__builtin_ve_vl_vcvtds_vvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcvtds_vvvl : GCCBuiltin<"__builtin_ve_vl_vcvtds_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcvtsd_vvl : GCCBuiltin<"__builtin_ve_vl_vcvtsd_vvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcvtsd_vvvl : GCCBuiltin<"__builtin_ve_vl_vcvtsd_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vmrg_vvvml : GCCBuiltin<"__builtin_ve_vl_vmrg_vvvml">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vmrg_vvvmvl : GCCBuiltin<"__builtin_ve_vl_vmrg_vvvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vmrg_vsvml : GCCBuiltin<"__builtin_ve_vl_vmrg_vsvml">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vmrg_vsvmvl : GCCBuiltin<"__builtin_ve_vl_vmrg_vsvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i64>, LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vmrgw_vvvMl : GCCBuiltin<"__builtin_ve_vl_vmrgw_vvvMl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vmrgw_vvvMvl : GCCBuiltin<"__builtin_ve_vl_vmrgw_vvvMvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vmrgw_vsvMl : GCCBuiltin<"__builtin_ve_vl_vmrgw_vsvMl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>, LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vmrgw_vsvMvl : GCCBuiltin<"__builtin_ve_vl_vmrgw_vsvMvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<i32>, LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vshf_vvvsl : GCCBuiltin<"__builtin_ve_vl_vshf_vvvsl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vshf_vvvsvl : GCCBuiltin<"__builtin_ve_vl_vshf_vvvsvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vcp_vvmvl : GCCBuiltin<"__builtin_ve_vl_vcp_vvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vex_vvmvl : GCCBuiltin<"__builtin_ve_vl_vex_vvmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmklat_ml : GCCBuiltin<"__builtin_ve_vl_vfmklat_ml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmklaf_ml : GCCBuiltin<"__builtin_ve_vl_vfmklaf_ml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkat_Ml : GCCBuiltin<"__builtin_ve_vl_pvfmkat_Ml">, Intrinsic<[LLVMType<v512i1>], [LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkaf_Ml : GCCBuiltin<"__builtin_ve_vl_pvfmkaf_Ml">, Intrinsic<[LLVMType<v512i1>], [LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmklgt_mvl : GCCBuiltin<"__builtin_ve_vl_vfmklgt_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmklgt_mvml : GCCBuiltin<"__builtin_ve_vl_vfmklgt_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkllt_mvl : GCCBuiltin<"__builtin_ve_vl_vfmkllt_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkllt_mvml : GCCBuiltin<"__builtin_ve_vl_vfmkllt_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmklne_mvl : GCCBuiltin<"__builtin_ve_vl_vfmklne_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmklne_mvml : GCCBuiltin<"__builtin_ve_vl_vfmklne_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkleq_mvl : GCCBuiltin<"__builtin_ve_vl_vfmkleq_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkleq_mvml : GCCBuiltin<"__builtin_ve_vl_vfmkleq_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmklge_mvl : GCCBuiltin<"__builtin_ve_vl_vfmklge_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmklge_mvml : GCCBuiltin<"__builtin_ve_vl_vfmklge_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmklle_mvl : GCCBuiltin<"__builtin_ve_vl_vfmklle_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmklle_mvml : GCCBuiltin<"__builtin_ve_vl_vfmklle_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmklnum_mvl : GCCBuiltin<"__builtin_ve_vl_vfmklnum_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmklnum_mvml : GCCBuiltin<"__builtin_ve_vl_vfmklnum_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmklnan_mvl : GCCBuiltin<"__builtin_ve_vl_vfmklnan_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmklnan_mvml : GCCBuiltin<"__builtin_ve_vl_vfmklnan_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmklgtnan_mvl : GCCBuiltin<"__builtin_ve_vl_vfmklgtnan_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmklgtnan_mvml : GCCBuiltin<"__builtin_ve_vl_vfmklgtnan_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmklltnan_mvl : GCCBuiltin<"__builtin_ve_vl_vfmklltnan_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmklltnan_mvml : GCCBuiltin<"__builtin_ve_vl_vfmklltnan_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmklnenan_mvl : GCCBuiltin<"__builtin_ve_vl_vfmklnenan_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmklnenan_mvml : GCCBuiltin<"__builtin_ve_vl_vfmklnenan_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkleqnan_mvl : GCCBuiltin<"__builtin_ve_vl_vfmkleqnan_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkleqnan_mvml : GCCBuiltin<"__builtin_ve_vl_vfmkleqnan_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmklgenan_mvl : GCCBuiltin<"__builtin_ve_vl_vfmklgenan_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmklgenan_mvml : GCCBuiltin<"__builtin_ve_vl_vfmklgenan_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkllenan_mvl : GCCBuiltin<"__builtin_ve_vl_vfmkllenan_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkllenan_mvml : GCCBuiltin<"__builtin_ve_vl_vfmkllenan_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkwgt_mvl : GCCBuiltin<"__builtin_ve_vl_vfmkwgt_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkwgt_mvml : GCCBuiltin<"__builtin_ve_vl_vfmkwgt_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkwlt_mvl : GCCBuiltin<"__builtin_ve_vl_vfmkwlt_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkwlt_mvml : GCCBuiltin<"__builtin_ve_vl_vfmkwlt_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkwne_mvl : GCCBuiltin<"__builtin_ve_vl_vfmkwne_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkwne_mvml : GCCBuiltin<"__builtin_ve_vl_vfmkwne_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkweq_mvl : GCCBuiltin<"__builtin_ve_vl_vfmkweq_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkweq_mvml : GCCBuiltin<"__builtin_ve_vl_vfmkweq_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkwge_mvl : GCCBuiltin<"__builtin_ve_vl_vfmkwge_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkwge_mvml : GCCBuiltin<"__builtin_ve_vl_vfmkwge_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkwle_mvl : GCCBuiltin<"__builtin_ve_vl_vfmkwle_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkwle_mvml : GCCBuiltin<"__builtin_ve_vl_vfmkwle_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkwnum_mvl : GCCBuiltin<"__builtin_ve_vl_vfmkwnum_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkwnum_mvml : GCCBuiltin<"__builtin_ve_vl_vfmkwnum_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkwnan_mvl : GCCBuiltin<"__builtin_ve_vl_vfmkwnan_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkwnan_mvml : GCCBuiltin<"__builtin_ve_vl_vfmkwnan_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkwgtnan_mvl : GCCBuiltin<"__builtin_ve_vl_vfmkwgtnan_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkwgtnan_mvml : GCCBuiltin<"__builtin_ve_vl_vfmkwgtnan_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkwltnan_mvl : GCCBuiltin<"__builtin_ve_vl_vfmkwltnan_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkwltnan_mvml : GCCBuiltin<"__builtin_ve_vl_vfmkwltnan_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkwnenan_mvl : GCCBuiltin<"__builtin_ve_vl_vfmkwnenan_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkwnenan_mvml : GCCBuiltin<"__builtin_ve_vl_vfmkwnenan_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkweqnan_mvl : GCCBuiltin<"__builtin_ve_vl_vfmkweqnan_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkweqnan_mvml : GCCBuiltin<"__builtin_ve_vl_vfmkweqnan_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkwgenan_mvl : GCCBuiltin<"__builtin_ve_vl_vfmkwgenan_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkwgenan_mvml : GCCBuiltin<"__builtin_ve_vl_vfmkwgenan_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkwlenan_mvl : GCCBuiltin<"__builtin_ve_vl_vfmkwlenan_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkwlenan_mvml : GCCBuiltin<"__builtin_ve_vl_vfmkwlenan_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwlogt_mvl : GCCBuiltin<"__builtin_ve_vl_pvfmkwlogt_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwupgt_mvl : GCCBuiltin<"__builtin_ve_vl_pvfmkwupgt_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwlogt_mvml : GCCBuiltin<"__builtin_ve_vl_pvfmkwlogt_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwupgt_mvml : GCCBuiltin<"__builtin_ve_vl_pvfmkwupgt_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwlolt_mvl : GCCBuiltin<"__builtin_ve_vl_pvfmkwlolt_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwuplt_mvl : GCCBuiltin<"__builtin_ve_vl_pvfmkwuplt_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwlolt_mvml : GCCBuiltin<"__builtin_ve_vl_pvfmkwlolt_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwuplt_mvml : GCCBuiltin<"__builtin_ve_vl_pvfmkwuplt_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwlone_mvl : GCCBuiltin<"__builtin_ve_vl_pvfmkwlone_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwupne_mvl : GCCBuiltin<"__builtin_ve_vl_pvfmkwupne_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwlone_mvml : GCCBuiltin<"__builtin_ve_vl_pvfmkwlone_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwupne_mvml : GCCBuiltin<"__builtin_ve_vl_pvfmkwupne_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwloeq_mvl : GCCBuiltin<"__builtin_ve_vl_pvfmkwloeq_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwupeq_mvl : GCCBuiltin<"__builtin_ve_vl_pvfmkwupeq_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwloeq_mvml : GCCBuiltin<"__builtin_ve_vl_pvfmkwloeq_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwupeq_mvml : GCCBuiltin<"__builtin_ve_vl_pvfmkwupeq_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwloge_mvl : GCCBuiltin<"__builtin_ve_vl_pvfmkwloge_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwupge_mvl : GCCBuiltin<"__builtin_ve_vl_pvfmkwupge_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwloge_mvml : GCCBuiltin<"__builtin_ve_vl_pvfmkwloge_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwupge_mvml : GCCBuiltin<"__builtin_ve_vl_pvfmkwupge_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwlole_mvl : GCCBuiltin<"__builtin_ve_vl_pvfmkwlole_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwuple_mvl : GCCBuiltin<"__builtin_ve_vl_pvfmkwuple_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwlole_mvml : GCCBuiltin<"__builtin_ve_vl_pvfmkwlole_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwuple_mvml : GCCBuiltin<"__builtin_ve_vl_pvfmkwuple_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwlonum_mvl : GCCBuiltin<"__builtin_ve_vl_pvfmkwlonum_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwupnum_mvl : GCCBuiltin<"__builtin_ve_vl_pvfmkwupnum_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwlonum_mvml : GCCBuiltin<"__builtin_ve_vl_pvfmkwlonum_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwupnum_mvml : GCCBuiltin<"__builtin_ve_vl_pvfmkwupnum_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwlonan_mvl : GCCBuiltin<"__builtin_ve_vl_pvfmkwlonan_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwupnan_mvl : GCCBuiltin<"__builtin_ve_vl_pvfmkwupnan_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwlonan_mvml : GCCBuiltin<"__builtin_ve_vl_pvfmkwlonan_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwupnan_mvml : GCCBuiltin<"__builtin_ve_vl_pvfmkwupnan_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwlogtnan_mvl : GCCBuiltin<"__builtin_ve_vl_pvfmkwlogtnan_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwupgtnan_mvl : GCCBuiltin<"__builtin_ve_vl_pvfmkwupgtnan_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwlogtnan_mvml : GCCBuiltin<"__builtin_ve_vl_pvfmkwlogtnan_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwupgtnan_mvml : GCCBuiltin<"__builtin_ve_vl_pvfmkwupgtnan_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwloltnan_mvl : GCCBuiltin<"__builtin_ve_vl_pvfmkwloltnan_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwupltnan_mvl : GCCBuiltin<"__builtin_ve_vl_pvfmkwupltnan_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwloltnan_mvml : GCCBuiltin<"__builtin_ve_vl_pvfmkwloltnan_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwupltnan_mvml : GCCBuiltin<"__builtin_ve_vl_pvfmkwupltnan_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwlonenan_mvl : GCCBuiltin<"__builtin_ve_vl_pvfmkwlonenan_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwupnenan_mvl : GCCBuiltin<"__builtin_ve_vl_pvfmkwupnenan_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwlonenan_mvml : GCCBuiltin<"__builtin_ve_vl_pvfmkwlonenan_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwupnenan_mvml : GCCBuiltin<"__builtin_ve_vl_pvfmkwupnenan_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwloeqnan_mvl : GCCBuiltin<"__builtin_ve_vl_pvfmkwloeqnan_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwupeqnan_mvl : GCCBuiltin<"__builtin_ve_vl_pvfmkwupeqnan_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwloeqnan_mvml : GCCBuiltin<"__builtin_ve_vl_pvfmkwloeqnan_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwupeqnan_mvml : GCCBuiltin<"__builtin_ve_vl_pvfmkwupeqnan_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwlogenan_mvl : GCCBuiltin<"__builtin_ve_vl_pvfmkwlogenan_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwupgenan_mvl : GCCBuiltin<"__builtin_ve_vl_pvfmkwupgenan_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwlogenan_mvml : GCCBuiltin<"__builtin_ve_vl_pvfmkwlogenan_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwupgenan_mvml : GCCBuiltin<"__builtin_ve_vl_pvfmkwupgenan_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwlolenan_mvl : GCCBuiltin<"__builtin_ve_vl_pvfmkwlolenan_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwuplenan_mvl : GCCBuiltin<"__builtin_ve_vl_pvfmkwuplenan_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwlolenan_mvml : GCCBuiltin<"__builtin_ve_vl_pvfmkwlolenan_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwuplenan_mvml : GCCBuiltin<"__builtin_ve_vl_pvfmkwuplenan_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwgt_Mvl : GCCBuiltin<"__builtin_ve_vl_pvfmkwgt_Mvl">, Intrinsic<[LLVMType<v512i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwgt_MvMl : GCCBuiltin<"__builtin_ve_vl_pvfmkwgt_MvMl">, Intrinsic<[LLVMType<v512i1>], [LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwlt_Mvl : GCCBuiltin<"__builtin_ve_vl_pvfmkwlt_Mvl">, Intrinsic<[LLVMType<v512i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwlt_MvMl : GCCBuiltin<"__builtin_ve_vl_pvfmkwlt_MvMl">, Intrinsic<[LLVMType<v512i1>], [LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwne_Mvl : GCCBuiltin<"__builtin_ve_vl_pvfmkwne_Mvl">, Intrinsic<[LLVMType<v512i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwne_MvMl : GCCBuiltin<"__builtin_ve_vl_pvfmkwne_MvMl">, Intrinsic<[LLVMType<v512i1>], [LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkweq_Mvl : GCCBuiltin<"__builtin_ve_vl_pvfmkweq_Mvl">, Intrinsic<[LLVMType<v512i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkweq_MvMl : GCCBuiltin<"__builtin_ve_vl_pvfmkweq_MvMl">, Intrinsic<[LLVMType<v512i1>], [LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwge_Mvl : GCCBuiltin<"__builtin_ve_vl_pvfmkwge_Mvl">, Intrinsic<[LLVMType<v512i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwge_MvMl : GCCBuiltin<"__builtin_ve_vl_pvfmkwge_MvMl">, Intrinsic<[LLVMType<v512i1>], [LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwle_Mvl : GCCBuiltin<"__builtin_ve_vl_pvfmkwle_Mvl">, Intrinsic<[LLVMType<v512i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwle_MvMl : GCCBuiltin<"__builtin_ve_vl_pvfmkwle_MvMl">, Intrinsic<[LLVMType<v512i1>], [LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwnum_Mvl : GCCBuiltin<"__builtin_ve_vl_pvfmkwnum_Mvl">, Intrinsic<[LLVMType<v512i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwnum_MvMl : GCCBuiltin<"__builtin_ve_vl_pvfmkwnum_MvMl">, Intrinsic<[LLVMType<v512i1>], [LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwnan_Mvl : GCCBuiltin<"__builtin_ve_vl_pvfmkwnan_Mvl">, Intrinsic<[LLVMType<v512i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwnan_MvMl : GCCBuiltin<"__builtin_ve_vl_pvfmkwnan_MvMl">, Intrinsic<[LLVMType<v512i1>], [LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwgtnan_Mvl : GCCBuiltin<"__builtin_ve_vl_pvfmkwgtnan_Mvl">, Intrinsic<[LLVMType<v512i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwgtnan_MvMl : GCCBuiltin<"__builtin_ve_vl_pvfmkwgtnan_MvMl">, Intrinsic<[LLVMType<v512i1>], [LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwltnan_Mvl : GCCBuiltin<"__builtin_ve_vl_pvfmkwltnan_Mvl">, Intrinsic<[LLVMType<v512i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwltnan_MvMl : GCCBuiltin<"__builtin_ve_vl_pvfmkwltnan_MvMl">, Intrinsic<[LLVMType<v512i1>], [LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwnenan_Mvl : GCCBuiltin<"__builtin_ve_vl_pvfmkwnenan_Mvl">, Intrinsic<[LLVMType<v512i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwnenan_MvMl : GCCBuiltin<"__builtin_ve_vl_pvfmkwnenan_MvMl">, Intrinsic<[LLVMType<v512i1>], [LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkweqnan_Mvl : GCCBuiltin<"__builtin_ve_vl_pvfmkweqnan_Mvl">, Intrinsic<[LLVMType<v512i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkweqnan_MvMl : GCCBuiltin<"__builtin_ve_vl_pvfmkweqnan_MvMl">, Intrinsic<[LLVMType<v512i1>], [LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwgenan_Mvl : GCCBuiltin<"__builtin_ve_vl_pvfmkwgenan_Mvl">, Intrinsic<[LLVMType<v512i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwgenan_MvMl : GCCBuiltin<"__builtin_ve_vl_pvfmkwgenan_MvMl">, Intrinsic<[LLVMType<v512i1>], [LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwlenan_Mvl : GCCBuiltin<"__builtin_ve_vl_pvfmkwlenan_Mvl">, Intrinsic<[LLVMType<v512i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkwlenan_MvMl : GCCBuiltin<"__builtin_ve_vl_pvfmkwlenan_MvMl">, Intrinsic<[LLVMType<v512i1>], [LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkdgt_mvl : GCCBuiltin<"__builtin_ve_vl_vfmkdgt_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkdgt_mvml : GCCBuiltin<"__builtin_ve_vl_vfmkdgt_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkdlt_mvl : GCCBuiltin<"__builtin_ve_vl_vfmkdlt_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkdlt_mvml : GCCBuiltin<"__builtin_ve_vl_vfmkdlt_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkdne_mvl : GCCBuiltin<"__builtin_ve_vl_vfmkdne_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkdne_mvml : GCCBuiltin<"__builtin_ve_vl_vfmkdne_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkdeq_mvl : GCCBuiltin<"__builtin_ve_vl_vfmkdeq_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkdeq_mvml : GCCBuiltin<"__builtin_ve_vl_vfmkdeq_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkdge_mvl : GCCBuiltin<"__builtin_ve_vl_vfmkdge_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkdge_mvml : GCCBuiltin<"__builtin_ve_vl_vfmkdge_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkdle_mvl : GCCBuiltin<"__builtin_ve_vl_vfmkdle_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkdle_mvml : GCCBuiltin<"__builtin_ve_vl_vfmkdle_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkdnum_mvl : GCCBuiltin<"__builtin_ve_vl_vfmkdnum_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkdnum_mvml : GCCBuiltin<"__builtin_ve_vl_vfmkdnum_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkdnan_mvl : GCCBuiltin<"__builtin_ve_vl_vfmkdnan_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkdnan_mvml : GCCBuiltin<"__builtin_ve_vl_vfmkdnan_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkdgtnan_mvl : GCCBuiltin<"__builtin_ve_vl_vfmkdgtnan_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkdgtnan_mvml : GCCBuiltin<"__builtin_ve_vl_vfmkdgtnan_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkdltnan_mvl : GCCBuiltin<"__builtin_ve_vl_vfmkdltnan_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkdltnan_mvml : GCCBuiltin<"__builtin_ve_vl_vfmkdltnan_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkdnenan_mvl : GCCBuiltin<"__builtin_ve_vl_vfmkdnenan_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkdnenan_mvml : GCCBuiltin<"__builtin_ve_vl_vfmkdnenan_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkdeqnan_mvl : GCCBuiltin<"__builtin_ve_vl_vfmkdeqnan_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkdeqnan_mvml : GCCBuiltin<"__builtin_ve_vl_vfmkdeqnan_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkdgenan_mvl : GCCBuiltin<"__builtin_ve_vl_vfmkdgenan_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkdgenan_mvml : GCCBuiltin<"__builtin_ve_vl_vfmkdgenan_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkdlenan_mvl : GCCBuiltin<"__builtin_ve_vl_vfmkdlenan_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkdlenan_mvml : GCCBuiltin<"__builtin_ve_vl_vfmkdlenan_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmksgt_mvl : GCCBuiltin<"__builtin_ve_vl_vfmksgt_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmksgt_mvml : GCCBuiltin<"__builtin_ve_vl_vfmksgt_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkslt_mvl : GCCBuiltin<"__builtin_ve_vl_vfmkslt_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkslt_mvml : GCCBuiltin<"__builtin_ve_vl_vfmkslt_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmksne_mvl : GCCBuiltin<"__builtin_ve_vl_vfmksne_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmksne_mvml : GCCBuiltin<"__builtin_ve_vl_vfmksne_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkseq_mvl : GCCBuiltin<"__builtin_ve_vl_vfmkseq_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkseq_mvml : GCCBuiltin<"__builtin_ve_vl_vfmkseq_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmksge_mvl : GCCBuiltin<"__builtin_ve_vl_vfmksge_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmksge_mvml : GCCBuiltin<"__builtin_ve_vl_vfmksge_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmksle_mvl : GCCBuiltin<"__builtin_ve_vl_vfmksle_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmksle_mvml : GCCBuiltin<"__builtin_ve_vl_vfmksle_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmksnum_mvl : GCCBuiltin<"__builtin_ve_vl_vfmksnum_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmksnum_mvml : GCCBuiltin<"__builtin_ve_vl_vfmksnum_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmksnan_mvl : GCCBuiltin<"__builtin_ve_vl_vfmksnan_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmksnan_mvml : GCCBuiltin<"__builtin_ve_vl_vfmksnan_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmksgtnan_mvl : GCCBuiltin<"__builtin_ve_vl_vfmksgtnan_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmksgtnan_mvml : GCCBuiltin<"__builtin_ve_vl_vfmksgtnan_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmksltnan_mvl : GCCBuiltin<"__builtin_ve_vl_vfmksltnan_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmksltnan_mvml : GCCBuiltin<"__builtin_ve_vl_vfmksltnan_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmksnenan_mvl : GCCBuiltin<"__builtin_ve_vl_vfmksnenan_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmksnenan_mvml : GCCBuiltin<"__builtin_ve_vl_vfmksnenan_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkseqnan_mvl : GCCBuiltin<"__builtin_ve_vl_vfmkseqnan_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkseqnan_mvml : GCCBuiltin<"__builtin_ve_vl_vfmkseqnan_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmksgenan_mvl : GCCBuiltin<"__builtin_ve_vl_vfmksgenan_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmksgenan_mvml : GCCBuiltin<"__builtin_ve_vl_vfmksgenan_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkslenan_mvl : GCCBuiltin<"__builtin_ve_vl_vfmkslenan_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfmkslenan_mvml : GCCBuiltin<"__builtin_ve_vl_vfmkslenan_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkslogt_mvl : GCCBuiltin<"__builtin_ve_vl_pvfmkslogt_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmksupgt_mvl : GCCBuiltin<"__builtin_ve_vl_pvfmksupgt_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkslogt_mvml : GCCBuiltin<"__builtin_ve_vl_pvfmkslogt_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmksupgt_mvml : GCCBuiltin<"__builtin_ve_vl_pvfmksupgt_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkslolt_mvl : GCCBuiltin<"__builtin_ve_vl_pvfmkslolt_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmksuplt_mvl : GCCBuiltin<"__builtin_ve_vl_pvfmksuplt_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkslolt_mvml : GCCBuiltin<"__builtin_ve_vl_pvfmkslolt_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmksuplt_mvml : GCCBuiltin<"__builtin_ve_vl_pvfmksuplt_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkslone_mvl : GCCBuiltin<"__builtin_ve_vl_pvfmkslone_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmksupne_mvl : GCCBuiltin<"__builtin_ve_vl_pvfmksupne_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkslone_mvml : GCCBuiltin<"__builtin_ve_vl_pvfmkslone_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmksupne_mvml : GCCBuiltin<"__builtin_ve_vl_pvfmksupne_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmksloeq_mvl : GCCBuiltin<"__builtin_ve_vl_pvfmksloeq_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmksupeq_mvl : GCCBuiltin<"__builtin_ve_vl_pvfmksupeq_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmksloeq_mvml : GCCBuiltin<"__builtin_ve_vl_pvfmksloeq_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmksupeq_mvml : GCCBuiltin<"__builtin_ve_vl_pvfmksupeq_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmksloge_mvl : GCCBuiltin<"__builtin_ve_vl_pvfmksloge_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmksupge_mvl : GCCBuiltin<"__builtin_ve_vl_pvfmksupge_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmksloge_mvml : GCCBuiltin<"__builtin_ve_vl_pvfmksloge_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmksupge_mvml : GCCBuiltin<"__builtin_ve_vl_pvfmksupge_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkslole_mvl : GCCBuiltin<"__builtin_ve_vl_pvfmkslole_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmksuple_mvl : GCCBuiltin<"__builtin_ve_vl_pvfmksuple_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkslole_mvml : GCCBuiltin<"__builtin_ve_vl_pvfmkslole_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmksuple_mvml : GCCBuiltin<"__builtin_ve_vl_pvfmksuple_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkslonum_mvl : GCCBuiltin<"__builtin_ve_vl_pvfmkslonum_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmksupnum_mvl : GCCBuiltin<"__builtin_ve_vl_pvfmksupnum_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkslonum_mvml : GCCBuiltin<"__builtin_ve_vl_pvfmkslonum_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmksupnum_mvml : GCCBuiltin<"__builtin_ve_vl_pvfmksupnum_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkslonan_mvl : GCCBuiltin<"__builtin_ve_vl_pvfmkslonan_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmksupnan_mvl : GCCBuiltin<"__builtin_ve_vl_pvfmksupnan_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkslonan_mvml : GCCBuiltin<"__builtin_ve_vl_pvfmkslonan_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmksupnan_mvml : GCCBuiltin<"__builtin_ve_vl_pvfmksupnan_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkslogtnan_mvl : GCCBuiltin<"__builtin_ve_vl_pvfmkslogtnan_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmksupgtnan_mvl : GCCBuiltin<"__builtin_ve_vl_pvfmksupgtnan_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkslogtnan_mvml : GCCBuiltin<"__builtin_ve_vl_pvfmkslogtnan_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmksupgtnan_mvml : GCCBuiltin<"__builtin_ve_vl_pvfmksupgtnan_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmksloltnan_mvl : GCCBuiltin<"__builtin_ve_vl_pvfmksloltnan_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmksupltnan_mvl : GCCBuiltin<"__builtin_ve_vl_pvfmksupltnan_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmksloltnan_mvml : GCCBuiltin<"__builtin_ve_vl_pvfmksloltnan_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmksupltnan_mvml : GCCBuiltin<"__builtin_ve_vl_pvfmksupltnan_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkslonenan_mvl : GCCBuiltin<"__builtin_ve_vl_pvfmkslonenan_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmksupnenan_mvl : GCCBuiltin<"__builtin_ve_vl_pvfmksupnenan_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkslonenan_mvml : GCCBuiltin<"__builtin_ve_vl_pvfmkslonenan_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmksupnenan_mvml : GCCBuiltin<"__builtin_ve_vl_pvfmksupnenan_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmksloeqnan_mvl : GCCBuiltin<"__builtin_ve_vl_pvfmksloeqnan_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmksupeqnan_mvl : GCCBuiltin<"__builtin_ve_vl_pvfmksupeqnan_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmksloeqnan_mvml : GCCBuiltin<"__builtin_ve_vl_pvfmksloeqnan_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmksupeqnan_mvml : GCCBuiltin<"__builtin_ve_vl_pvfmksupeqnan_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkslogenan_mvl : GCCBuiltin<"__builtin_ve_vl_pvfmkslogenan_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmksupgenan_mvl : GCCBuiltin<"__builtin_ve_vl_pvfmksupgenan_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkslogenan_mvml : GCCBuiltin<"__builtin_ve_vl_pvfmkslogenan_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmksupgenan_mvml : GCCBuiltin<"__builtin_ve_vl_pvfmksupgenan_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkslolenan_mvl : GCCBuiltin<"__builtin_ve_vl_pvfmkslolenan_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmksuplenan_mvl : GCCBuiltin<"__builtin_ve_vl_pvfmksuplenan_mvl">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkslolenan_mvml : GCCBuiltin<"__builtin_ve_vl_pvfmkslolenan_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmksuplenan_mvml : GCCBuiltin<"__builtin_ve_vl_pvfmksuplenan_mvml">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmksgt_Mvl : GCCBuiltin<"__builtin_ve_vl_pvfmksgt_Mvl">, Intrinsic<[LLVMType<v512i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmksgt_MvMl : GCCBuiltin<"__builtin_ve_vl_pvfmksgt_MvMl">, Intrinsic<[LLVMType<v512i1>], [LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkslt_Mvl : GCCBuiltin<"__builtin_ve_vl_pvfmkslt_Mvl">, Intrinsic<[LLVMType<v512i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkslt_MvMl : GCCBuiltin<"__builtin_ve_vl_pvfmkslt_MvMl">, Intrinsic<[LLVMType<v512i1>], [LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmksne_Mvl : GCCBuiltin<"__builtin_ve_vl_pvfmksne_Mvl">, Intrinsic<[LLVMType<v512i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmksne_MvMl : GCCBuiltin<"__builtin_ve_vl_pvfmksne_MvMl">, Intrinsic<[LLVMType<v512i1>], [LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkseq_Mvl : GCCBuiltin<"__builtin_ve_vl_pvfmkseq_Mvl">, Intrinsic<[LLVMType<v512i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkseq_MvMl : GCCBuiltin<"__builtin_ve_vl_pvfmkseq_MvMl">, Intrinsic<[LLVMType<v512i1>], [LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmksge_Mvl : GCCBuiltin<"__builtin_ve_vl_pvfmksge_Mvl">, Intrinsic<[LLVMType<v512i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmksge_MvMl : GCCBuiltin<"__builtin_ve_vl_pvfmksge_MvMl">, Intrinsic<[LLVMType<v512i1>], [LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmksle_Mvl : GCCBuiltin<"__builtin_ve_vl_pvfmksle_Mvl">, Intrinsic<[LLVMType<v512i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmksle_MvMl : GCCBuiltin<"__builtin_ve_vl_pvfmksle_MvMl">, Intrinsic<[LLVMType<v512i1>], [LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmksnum_Mvl : GCCBuiltin<"__builtin_ve_vl_pvfmksnum_Mvl">, Intrinsic<[LLVMType<v512i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmksnum_MvMl : GCCBuiltin<"__builtin_ve_vl_pvfmksnum_MvMl">, Intrinsic<[LLVMType<v512i1>], [LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmksnan_Mvl : GCCBuiltin<"__builtin_ve_vl_pvfmksnan_Mvl">, Intrinsic<[LLVMType<v512i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmksnan_MvMl : GCCBuiltin<"__builtin_ve_vl_pvfmksnan_MvMl">, Intrinsic<[LLVMType<v512i1>], [LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmksgtnan_Mvl : GCCBuiltin<"__builtin_ve_vl_pvfmksgtnan_Mvl">, Intrinsic<[LLVMType<v512i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmksgtnan_MvMl : GCCBuiltin<"__builtin_ve_vl_pvfmksgtnan_MvMl">, Intrinsic<[LLVMType<v512i1>], [LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmksltnan_Mvl : GCCBuiltin<"__builtin_ve_vl_pvfmksltnan_Mvl">, Intrinsic<[LLVMType<v512i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmksltnan_MvMl : GCCBuiltin<"__builtin_ve_vl_pvfmksltnan_MvMl">, Intrinsic<[LLVMType<v512i1>], [LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmksnenan_Mvl : GCCBuiltin<"__builtin_ve_vl_pvfmksnenan_Mvl">, Intrinsic<[LLVMType<v512i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmksnenan_MvMl : GCCBuiltin<"__builtin_ve_vl_pvfmksnenan_MvMl">, Intrinsic<[LLVMType<v512i1>], [LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkseqnan_Mvl : GCCBuiltin<"__builtin_ve_vl_pvfmkseqnan_Mvl">, Intrinsic<[LLVMType<v512i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkseqnan_MvMl : GCCBuiltin<"__builtin_ve_vl_pvfmkseqnan_MvMl">, Intrinsic<[LLVMType<v512i1>], [LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmksgenan_Mvl : GCCBuiltin<"__builtin_ve_vl_pvfmksgenan_Mvl">, Intrinsic<[LLVMType<v512i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmksgenan_MvMl : GCCBuiltin<"__builtin_ve_vl_pvfmksgenan_MvMl">, Intrinsic<[LLVMType<v512i1>], [LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkslenan_Mvl : GCCBuiltin<"__builtin_ve_vl_pvfmkslenan_Mvl">, Intrinsic<[LLVMType<v512i1>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pvfmkslenan_MvMl : GCCBuiltin<"__builtin_ve_vl_pvfmkslenan_MvMl">, Intrinsic<[LLVMType<v512i1>], [LLVMType<v256f64>, LLVMType<v512i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsumwsx_vvl : GCCBuiltin<"__builtin_ve_vl_vsumwsx_vvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsumwsx_vvml : GCCBuiltin<"__builtin_ve_vl_vsumwsx_vvml">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsumwzx_vvl : GCCBuiltin<"__builtin_ve_vl_vsumwzx_vvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsumwzx_vvml : GCCBuiltin<"__builtin_ve_vl_vsumwzx_vvml">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsuml_vvl : GCCBuiltin<"__builtin_ve_vl_vsuml_vvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsuml_vvml : GCCBuiltin<"__builtin_ve_vl_vsuml_vvml">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfsumd_vvl : GCCBuiltin<"__builtin_ve_vl_vfsumd_vvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfsumd_vvml : GCCBuiltin<"__builtin_ve_vl_vfsumd_vvml">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfsums_vvl : GCCBuiltin<"__builtin_ve_vl_vfsums_vvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfsums_vvml : GCCBuiltin<"__builtin_ve_vl_vfsums_vvml">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vrmaxswfstsx_vvl : GCCBuiltin<"__builtin_ve_vl_vrmaxswfstsx_vvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vrmaxswfstsx_vvvl : GCCBuiltin<"__builtin_ve_vl_vrmaxswfstsx_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vrmaxswlstsx_vvl : GCCBuiltin<"__builtin_ve_vl_vrmaxswlstsx_vvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vrmaxswlstsx_vvvl : GCCBuiltin<"__builtin_ve_vl_vrmaxswlstsx_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vrmaxswfstzx_vvl : GCCBuiltin<"__builtin_ve_vl_vrmaxswfstzx_vvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vrmaxswfstzx_vvvl : GCCBuiltin<"__builtin_ve_vl_vrmaxswfstzx_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vrmaxswlstzx_vvl : GCCBuiltin<"__builtin_ve_vl_vrmaxswlstzx_vvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vrmaxswlstzx_vvvl : GCCBuiltin<"__builtin_ve_vl_vrmaxswlstzx_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vrminswfstsx_vvl : GCCBuiltin<"__builtin_ve_vl_vrminswfstsx_vvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vrminswfstsx_vvvl : GCCBuiltin<"__builtin_ve_vl_vrminswfstsx_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vrminswlstsx_vvl : GCCBuiltin<"__builtin_ve_vl_vrminswlstsx_vvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vrminswlstsx_vvvl : GCCBuiltin<"__builtin_ve_vl_vrminswlstsx_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vrminswfstzx_vvl : GCCBuiltin<"__builtin_ve_vl_vrminswfstzx_vvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vrminswfstzx_vvvl : GCCBuiltin<"__builtin_ve_vl_vrminswfstzx_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vrminswlstzx_vvl : GCCBuiltin<"__builtin_ve_vl_vrminswlstzx_vvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vrminswlstzx_vvvl : GCCBuiltin<"__builtin_ve_vl_vrminswlstzx_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vrmaxslfst_vvl : GCCBuiltin<"__builtin_ve_vl_vrmaxslfst_vvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vrmaxslfst_vvvl : GCCBuiltin<"__builtin_ve_vl_vrmaxslfst_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vrmaxsllst_vvl : GCCBuiltin<"__builtin_ve_vl_vrmaxsllst_vvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vrmaxsllst_vvvl : GCCBuiltin<"__builtin_ve_vl_vrmaxsllst_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vrminslfst_vvl : GCCBuiltin<"__builtin_ve_vl_vrminslfst_vvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vrminslfst_vvvl : GCCBuiltin<"__builtin_ve_vl_vrminslfst_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vrminsllst_vvl : GCCBuiltin<"__builtin_ve_vl_vrminsllst_vvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vrminsllst_vvvl : GCCBuiltin<"__builtin_ve_vl_vrminsllst_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfrmaxdfst_vvl : GCCBuiltin<"__builtin_ve_vl_vfrmaxdfst_vvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfrmaxdfst_vvvl : GCCBuiltin<"__builtin_ve_vl_vfrmaxdfst_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfrmaxdlst_vvl : GCCBuiltin<"__builtin_ve_vl_vfrmaxdlst_vvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfrmaxdlst_vvvl : GCCBuiltin<"__builtin_ve_vl_vfrmaxdlst_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfrmaxsfst_vvl : GCCBuiltin<"__builtin_ve_vl_vfrmaxsfst_vvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfrmaxsfst_vvvl : GCCBuiltin<"__builtin_ve_vl_vfrmaxsfst_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfrmaxslst_vvl : GCCBuiltin<"__builtin_ve_vl_vfrmaxslst_vvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfrmaxslst_vvvl : GCCBuiltin<"__builtin_ve_vl_vfrmaxslst_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfrmindfst_vvl : GCCBuiltin<"__builtin_ve_vl_vfrmindfst_vvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfrmindfst_vvvl : GCCBuiltin<"__builtin_ve_vl_vfrmindfst_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfrmindlst_vvl : GCCBuiltin<"__builtin_ve_vl_vfrmindlst_vvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfrmindlst_vvvl : GCCBuiltin<"__builtin_ve_vl_vfrmindlst_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfrminsfst_vvl : GCCBuiltin<"__builtin_ve_vl_vfrminsfst_vvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfrminsfst_vvvl : GCCBuiltin<"__builtin_ve_vl_vfrminsfst_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfrminslst_vvl : GCCBuiltin<"__builtin_ve_vl_vfrminslst_vvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vfrminslst_vvvl : GCCBuiltin<"__builtin_ve_vl_vfrminslst_vvvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vrand_vvl : GCCBuiltin<"__builtin_ve_vl_vrand_vvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vrand_vvml : GCCBuiltin<"__builtin_ve_vl_vrand_vvml">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vror_vvl : GCCBuiltin<"__builtin_ve_vl_vror_vvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vror_vvml : GCCBuiltin<"__builtin_ve_vl_vror_vvml">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vrxor_vvl : GCCBuiltin<"__builtin_ve_vl_vrxor_vvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vrxor_vvml : GCCBuiltin<"__builtin_ve_vl_vrxor_vvml">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vgt_vvssl : GCCBuiltin<"__builtin_ve_vl_vgt_vvssl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<i64>, LLVMType<i32>], [IntrReadMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vgt_vvssvl : GCCBuiltin<"__builtin_ve_vl_vgt_vvssvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<i64>, LLVMType<v256f64>, LLVMType<i32>], [IntrReadMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vgt_vvssml : GCCBuiltin<"__builtin_ve_vl_vgt_vvssml">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<i64>, LLVMType<v256i1>, LLVMType<i32>], [IntrReadMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vgt_vvssmvl : GCCBuiltin<"__builtin_ve_vl_vgt_vvssmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<i64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrReadMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vgtnc_vvssl : GCCBuiltin<"__builtin_ve_vl_vgtnc_vvssl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<i64>, LLVMType<i32>], [IntrReadMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vgtnc_vvssvl : GCCBuiltin<"__builtin_ve_vl_vgtnc_vvssvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<i64>, LLVMType<v256f64>, LLVMType<i32>], [IntrReadMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vgtnc_vvssml : GCCBuiltin<"__builtin_ve_vl_vgtnc_vvssml">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<i64>, LLVMType<v256i1>, LLVMType<i32>], [IntrReadMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vgtnc_vvssmvl : GCCBuiltin<"__builtin_ve_vl_vgtnc_vvssmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<i64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrReadMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vgtu_vvssl : GCCBuiltin<"__builtin_ve_vl_vgtu_vvssl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<i64>, LLVMType<i32>], [IntrReadMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vgtu_vvssvl : GCCBuiltin<"__builtin_ve_vl_vgtu_vvssvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<i64>, LLVMType<v256f64>, LLVMType<i32>], [IntrReadMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vgtu_vvssml : GCCBuiltin<"__builtin_ve_vl_vgtu_vvssml">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<i64>, LLVMType<v256i1>, LLVMType<i32>], [IntrReadMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vgtu_vvssmvl : GCCBuiltin<"__builtin_ve_vl_vgtu_vvssmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<i64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrReadMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vgtunc_vvssl : GCCBuiltin<"__builtin_ve_vl_vgtunc_vvssl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<i64>, LLVMType<i32>], [IntrReadMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vgtunc_vvssvl : GCCBuiltin<"__builtin_ve_vl_vgtunc_vvssvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<i64>, LLVMType<v256f64>, LLVMType<i32>], [IntrReadMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vgtunc_vvssml : GCCBuiltin<"__builtin_ve_vl_vgtunc_vvssml">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<i64>, LLVMType<v256i1>, LLVMType<i32>], [IntrReadMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vgtunc_vvssmvl : GCCBuiltin<"__builtin_ve_vl_vgtunc_vvssmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<i64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrReadMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vgtlsx_vvssl : GCCBuiltin<"__builtin_ve_vl_vgtlsx_vvssl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<i64>, LLVMType<i32>], [IntrReadMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vgtlsx_vvssvl : GCCBuiltin<"__builtin_ve_vl_vgtlsx_vvssvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<i64>, LLVMType<v256f64>, LLVMType<i32>], [IntrReadMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vgtlsx_vvssml : GCCBuiltin<"__builtin_ve_vl_vgtlsx_vvssml">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<i64>, LLVMType<v256i1>, LLVMType<i32>], [IntrReadMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vgtlsx_vvssmvl : GCCBuiltin<"__builtin_ve_vl_vgtlsx_vvssmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<i64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrReadMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vgtlsxnc_vvssl : GCCBuiltin<"__builtin_ve_vl_vgtlsxnc_vvssl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<i64>, LLVMType<i32>], [IntrReadMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vgtlsxnc_vvssvl : GCCBuiltin<"__builtin_ve_vl_vgtlsxnc_vvssvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<i64>, LLVMType<v256f64>, LLVMType<i32>], [IntrReadMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vgtlsxnc_vvssml : GCCBuiltin<"__builtin_ve_vl_vgtlsxnc_vvssml">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<i64>, LLVMType<v256i1>, LLVMType<i32>], [IntrReadMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vgtlsxnc_vvssmvl : GCCBuiltin<"__builtin_ve_vl_vgtlsxnc_vvssmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<i64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrReadMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vgtlzx_vvssl : GCCBuiltin<"__builtin_ve_vl_vgtlzx_vvssl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<i64>, LLVMType<i32>], [IntrReadMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vgtlzx_vvssvl : GCCBuiltin<"__builtin_ve_vl_vgtlzx_vvssvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<i64>, LLVMType<v256f64>, LLVMType<i32>], [IntrReadMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vgtlzx_vvssml : GCCBuiltin<"__builtin_ve_vl_vgtlzx_vvssml">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<i64>, LLVMType<v256i1>, LLVMType<i32>], [IntrReadMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vgtlzx_vvssmvl : GCCBuiltin<"__builtin_ve_vl_vgtlzx_vvssmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<i64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrReadMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vgtlzxnc_vvssl : GCCBuiltin<"__builtin_ve_vl_vgtlzxnc_vvssl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<i64>, LLVMType<i32>], [IntrReadMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vgtlzxnc_vvssvl : GCCBuiltin<"__builtin_ve_vl_vgtlzxnc_vvssvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<i64>, LLVMType<v256f64>, LLVMType<i32>], [IntrReadMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vgtlzxnc_vvssml : GCCBuiltin<"__builtin_ve_vl_vgtlzxnc_vvssml">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<i64>, LLVMType<v256i1>, LLVMType<i32>], [IntrReadMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vgtlzxnc_vvssmvl : GCCBuiltin<"__builtin_ve_vl_vgtlzxnc_vvssmvl">, Intrinsic<[LLVMType<v256f64>], [LLVMType<v256f64>, LLVMType<i64>, LLVMType<i64>, LLVMType<v256i1>, LLVMType<v256f64>, LLVMType<i32>], [IntrReadMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsc_vvssl : GCCBuiltin<"__builtin_ve_vl_vsc_vvssl">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i64>, LLVMType<i64>, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsc_vvssml : GCCBuiltin<"__builtin_ve_vl_vsc_vvssml">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i64>, LLVMType<i64>, LLVMType<v256i1>, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vscnc_vvssl : GCCBuiltin<"__builtin_ve_vl_vscnc_vvssl">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i64>, LLVMType<i64>, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vscnc_vvssml : GCCBuiltin<"__builtin_ve_vl_vscnc_vvssml">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i64>, LLVMType<i64>, LLVMType<v256i1>, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vscot_vvssl : GCCBuiltin<"__builtin_ve_vl_vscot_vvssl">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i64>, LLVMType<i64>, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vscot_vvssml : GCCBuiltin<"__builtin_ve_vl_vscot_vvssml">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i64>, LLVMType<i64>, LLVMType<v256i1>, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vscncot_vvssl : GCCBuiltin<"__builtin_ve_vl_vscncot_vvssl">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i64>, LLVMType<i64>, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vscncot_vvssml : GCCBuiltin<"__builtin_ve_vl_vscncot_vvssml">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i64>, LLVMType<i64>, LLVMType<v256i1>, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vscu_vvssl : GCCBuiltin<"__builtin_ve_vl_vscu_vvssl">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i64>, LLVMType<i64>, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vscu_vvssml : GCCBuiltin<"__builtin_ve_vl_vscu_vvssml">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i64>, LLVMType<i64>, LLVMType<v256i1>, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vscunc_vvssl : GCCBuiltin<"__builtin_ve_vl_vscunc_vvssl">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i64>, LLVMType<i64>, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vscunc_vvssml : GCCBuiltin<"__builtin_ve_vl_vscunc_vvssml">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i64>, LLVMType<i64>, LLVMType<v256i1>, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vscuot_vvssl : GCCBuiltin<"__builtin_ve_vl_vscuot_vvssl">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i64>, LLVMType<i64>, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vscuot_vvssml : GCCBuiltin<"__builtin_ve_vl_vscuot_vvssml">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i64>, LLVMType<i64>, LLVMType<v256i1>, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vscuncot_vvssl : GCCBuiltin<"__builtin_ve_vl_vscuncot_vvssl">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i64>, LLVMType<i64>, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vscuncot_vvssml : GCCBuiltin<"__builtin_ve_vl_vscuncot_vvssml">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i64>, LLVMType<i64>, LLVMType<v256i1>, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vscl_vvssl : GCCBuiltin<"__builtin_ve_vl_vscl_vvssl">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i64>, LLVMType<i64>, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vscl_vvssml : GCCBuiltin<"__builtin_ve_vl_vscl_vvssml">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i64>, LLVMType<i64>, LLVMType<v256i1>, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsclnc_vvssl : GCCBuiltin<"__builtin_ve_vl_vsclnc_vvssl">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i64>, LLVMType<i64>, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsclnc_vvssml : GCCBuiltin<"__builtin_ve_vl_vsclnc_vvssml">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i64>, LLVMType<i64>, LLVMType<v256i1>, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsclot_vvssl : GCCBuiltin<"__builtin_ve_vl_vsclot_vvssl">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i64>, LLVMType<i64>, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsclot_vvssml : GCCBuiltin<"__builtin_ve_vl_vsclot_vvssml">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i64>, LLVMType<i64>, LLVMType<v256i1>, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsclncot_vvssl : GCCBuiltin<"__builtin_ve_vl_vsclncot_vvssl">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i64>, LLVMType<i64>, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_vsclncot_vvssml : GCCBuiltin<"__builtin_ve_vl_vsclncot_vvssml">, Intrinsic<[], [LLVMType<v256f64>, LLVMType<v256f64>, LLVMType<i64>, LLVMType<i64>, LLVMType<v256i1>, LLVMType<i32>], [IntrWriteMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_andm_mmm : GCCBuiltin<"__builtin_ve_vl_andm_mmm">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256i1>, LLVMType<v256i1>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_andm_MMM : GCCBuiltin<"__builtin_ve_vl_andm_MMM">, Intrinsic<[LLVMType<v512i1>], [LLVMType<v512i1>, LLVMType<v512i1>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_orm_mmm : GCCBuiltin<"__builtin_ve_vl_orm_mmm">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256i1>, LLVMType<v256i1>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_orm_MMM : GCCBuiltin<"__builtin_ve_vl_orm_MMM">, Intrinsic<[LLVMType<v512i1>], [LLVMType<v512i1>, LLVMType<v512i1>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_xorm_mmm : GCCBuiltin<"__builtin_ve_vl_xorm_mmm">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256i1>, LLVMType<v256i1>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_xorm_MMM : GCCBuiltin<"__builtin_ve_vl_xorm_MMM">, Intrinsic<[LLVMType<v512i1>], [LLVMType<v512i1>, LLVMType<v512i1>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_eqvm_mmm : GCCBuiltin<"__builtin_ve_vl_eqvm_mmm">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256i1>, LLVMType<v256i1>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_eqvm_MMM : GCCBuiltin<"__builtin_ve_vl_eqvm_MMM">, Intrinsic<[LLVMType<v512i1>], [LLVMType<v512i1>, LLVMType<v512i1>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_nndm_mmm : GCCBuiltin<"__builtin_ve_vl_nndm_mmm">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256i1>, LLVMType<v256i1>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_nndm_MMM : GCCBuiltin<"__builtin_ve_vl_nndm_MMM">, Intrinsic<[LLVMType<v512i1>], [LLVMType<v512i1>, LLVMType<v512i1>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_negm_mm : GCCBuiltin<"__builtin_ve_vl_negm_mm">, Intrinsic<[LLVMType<v256i1>], [LLVMType<v256i1>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_negm_MM : GCCBuiltin<"__builtin_ve_vl_negm_MM">, Intrinsic<[LLVMType<v512i1>], [LLVMType<v512i1>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_pcvm_sml : GCCBuiltin<"__builtin_ve_vl_pcvm_sml">, Intrinsic<[LLVMType<i64>], [LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_lzvm_sml : GCCBuiltin<"__builtin_ve_vl_lzvm_sml">, Intrinsic<[LLVMType<i64>], [LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
+let TargetPrefix = "ve" in def int_ve_vl_tovm_sml : GCCBuiltin<"__builtin_ve_vl_tovm_sml">, Intrinsic<[LLVMType<i64>], [LLVMType<v256i1>, LLVMType<i32>], [IntrNoMem]>;
diff --git a/linux-x64/clang/include/llvm/IR/IntrinsicsWebAssembly.h b/linux-x64/clang/include/llvm/IR/IntrinsicsWebAssembly.h
new file mode 100644
index 0000000..90fbd36
--- /dev/null
+++ b/linux-x64/clang/include/llvm/IR/IntrinsicsWebAssembly.h
@@ -0,0 +1,85 @@
+/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
+|*                                                                            *|
+|* Intrinsic Function Source Fragment                                         *|
+|*                                                                            *|
+|* Automatically generated file, do not edit!                                 *|
+|*                                                                            *|
+\*===----------------------------------------------------------------------===*/
+
+#ifndef LLVM_IR_INTRINSIC_WASM_ENUMS_H
+#define LLVM_IR_INTRINSIC_WASM_ENUMS_H
+
+namespace llvm {
+namespace Intrinsic {
+enum WASMIntrinsics : unsigned {
+// Enum values for intrinsics
+    wasm_alltrue = 8435,                              // llvm.wasm.alltrue
+    wasm_anytrue,                              // llvm.wasm.anytrue
+    wasm_avgr_unsigned,                        // llvm.wasm.avgr.unsigned
+    wasm_bitmask,                              // llvm.wasm.bitmask
+    wasm_bitselect,                            // llvm.wasm.bitselect
+    wasm_catch,                                // llvm.wasm.catch
+    wasm_ceil,                                 // llvm.wasm.ceil
+    wasm_dot,                                  // llvm.wasm.dot
+    wasm_eq,                                   // llvm.wasm.eq
+    wasm_extadd_pairwise_signed,               // llvm.wasm.extadd.pairwise.signed
+    wasm_extadd_pairwise_unsigned,             // llvm.wasm.extadd.pairwise.unsigned
+    wasm_extmul_high_signed,                   // llvm.wasm.extmul.high.signed
+    wasm_extmul_high_unsigned,                 // llvm.wasm.extmul.high.unsigned
+    wasm_extmul_low_signed,                    // llvm.wasm.extmul.low.signed
+    wasm_extmul_low_unsigned,                  // llvm.wasm.extmul.low.unsigned
+    wasm_floor,                                // llvm.wasm.floor
+    wasm_get_ehselector,                       // llvm.wasm.get.ehselector
+    wasm_get_exception,                        // llvm.wasm.get.exception
+    wasm_landingpad_index,                     // llvm.wasm.landingpad.index
+    wasm_load16_lane,                          // llvm.wasm.load16.lane
+    wasm_load32_lane,                          // llvm.wasm.load32.lane
+    wasm_load32_zero,                          // llvm.wasm.load32.zero
+    wasm_load64_lane,                          // llvm.wasm.load64.lane
+    wasm_load64_zero,                          // llvm.wasm.load64.zero
+    wasm_load8_lane,                           // llvm.wasm.load8.lane
+    wasm_lsda,                                 // llvm.wasm.lsda
+    wasm_memory_atomic_notify,                 // llvm.wasm.memory.atomic.notify
+    wasm_memory_atomic_wait32,                 // llvm.wasm.memory.atomic.wait32
+    wasm_memory_atomic_wait64,                 // llvm.wasm.memory.atomic.wait64
+    wasm_memory_grow,                          // llvm.wasm.memory.grow
+    wasm_memory_size,                          // llvm.wasm.memory.size
+    wasm_narrow_signed,                        // llvm.wasm.narrow.signed
+    wasm_narrow_unsigned,                      // llvm.wasm.narrow.unsigned
+    wasm_nearest,                              // llvm.wasm.nearest
+    wasm_pmax,                                 // llvm.wasm.pmax
+    wasm_pmin,                                 // llvm.wasm.pmin
+    wasm_popcnt,                               // llvm.wasm.popcnt
+    wasm_prefetch_nt,                          // llvm.wasm.prefetch.nt
+    wasm_prefetch_t,                           // llvm.wasm.prefetch.t
+    wasm_q15mulr_saturate_signed,              // llvm.wasm.q15mulr.saturate.signed
+    wasm_qfma,                                 // llvm.wasm.qfma
+    wasm_qfms,                                 // llvm.wasm.qfms
+    wasm_rethrow,                              // llvm.wasm.rethrow
+    wasm_shuffle,                              // llvm.wasm.shuffle
+    wasm_signselect,                           // llvm.wasm.signselect
+    wasm_store16_lane,                         // llvm.wasm.store16.lane
+    wasm_store32_lane,                         // llvm.wasm.store32.lane
+    wasm_store64_lane,                         // llvm.wasm.store64.lane
+    wasm_store8_lane,                          // llvm.wasm.store8.lane
+    wasm_sub_saturate_signed,                  // llvm.wasm.sub.saturate.signed
+    wasm_sub_saturate_unsigned,                // llvm.wasm.sub.saturate.unsigned
+    wasm_swizzle,                              // llvm.wasm.swizzle
+    wasm_throw,                                // llvm.wasm.throw
+    wasm_tls_align,                            // llvm.wasm.tls.align
+    wasm_tls_base,                             // llvm.wasm.tls.base
+    wasm_tls_size,                             // llvm.wasm.tls.size
+    wasm_trunc,                                // llvm.wasm.trunc
+    wasm_trunc_saturate_signed,                // llvm.wasm.trunc.saturate.signed
+    wasm_trunc_saturate_unsigned,              // llvm.wasm.trunc.saturate.unsigned
+    wasm_trunc_signed,                         // llvm.wasm.trunc.signed
+    wasm_trunc_unsigned,                       // llvm.wasm.trunc.unsigned
+    wasm_widen_high_signed,                    // llvm.wasm.widen.high.signed
+    wasm_widen_high_unsigned,                  // llvm.wasm.widen.high.unsigned
+    wasm_widen_low_signed,                     // llvm.wasm.widen.low.signed
+    wasm_widen_low_unsigned,                   // llvm.wasm.widen.low.unsigned
+}; // enum
+} // namespace Intrinsic
+} // namespace llvm
+
+#endif
diff --git a/linux-x64/clang/include/llvm/IR/IntrinsicsWebAssembly.td b/linux-x64/clang/include/llvm/IR/IntrinsicsWebAssembly.td
index 1731995..c0892ee 100644
--- a/linux-x64/clang/include/llvm/IR/IntrinsicsWebAssembly.td
+++ b/linux-x64/clang/include/llvm/IR/IntrinsicsWebAssembly.td
@@ -24,6 +24,17 @@
                                      []>;
 
 //===----------------------------------------------------------------------===//
+// Trapping float-to-int conversions
+//===----------------------------------------------------------------------===//
+
+def int_wasm_trunc_signed : Intrinsic<[llvm_anyint_ty],
+                                      [llvm_anyfloat_ty],
+                                      [IntrNoMem]>;
+def int_wasm_trunc_unsigned : Intrinsic<[llvm_anyint_ty],
+                                        [llvm_anyfloat_ty],
+                                        [IntrNoMem]>;
+
+//===----------------------------------------------------------------------===//
 // Saturating float-to-int conversions
 //===----------------------------------------------------------------------===//
 
@@ -39,9 +50,10 @@
 //===----------------------------------------------------------------------===//
 
 // throw / rethrow
+// The immediate argument is an index to a tag, which is 0 for C++.
 def int_wasm_throw : Intrinsic<[], [llvm_i32_ty, llvm_ptr_ty],
-                               [Throws, IntrNoReturn, ImmArg<0>]>;
-def int_wasm_rethrow_in_catch : Intrinsic<[], [], [Throws, IntrNoReturn]>;
+                               [Throws, IntrNoReturn, ImmArg<ArgIndex<0>>]>;
+def int_wasm_rethrow : Intrinsic<[], [], [Throws, IntrNoReturn]>;
 
 // Since wasm does not use landingpad instructions, these instructions return
 // exception pointer and selector values until we lower them in WasmEHPrepare.
@@ -49,16 +61,18 @@
                                        [IntrHasSideEffects]>;
 def int_wasm_get_ehselector : Intrinsic<[llvm_i32_ty], [llvm_token_ty],
                                         [IntrHasSideEffects]>;
-// This is the same as llvm.wasm.get.exception except that it does not take a
-// token operand. This is only for instruction selection purpose.
-def int_wasm_extract_exception : Intrinsic<[llvm_ptr_ty], [],
-                                           [IntrHasSideEffects]>;
+
+// wasm.catch returns the pointer to the exception object caught by wasm 'catch'
+// instruction. This returns a single pointer, which is sufficient for C++
+// support. The immediate argument is an index to for a tag, which is 0 for C++.
+def int_wasm_catch : Intrinsic<[llvm_ptr_ty], [llvm_i32_ty],
+                               [IntrHasSideEffects, ImmArg<ArgIndex<0>>]>;
 
 // WebAssembly EH must maintain the landingpads in the order assigned to them
 // by WasmEHPrepare pass to generate landingpad table in EHStreamer. This is
 // used in order to give them the indices in WasmEHPrepare.
 def int_wasm_landingpad_index: Intrinsic<[], [llvm_token_ty, llvm_i32_ty],
-                                         [IntrNoMem, ImmArg<1>]>;
+                                         [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 
 // Returns LSDA address of the current function.
 def int_wasm_lsda : Intrinsic<[llvm_ptr_ty], [], [IntrNoMem]>;
@@ -68,27 +82,39 @@
 //===----------------------------------------------------------------------===//
 
 // wait / notify
-def int_wasm_atomic_wait_i32 :
+def int_wasm_memory_atomic_wait32 :
   Intrinsic<[llvm_i32_ty],
             [LLVMPointerType<llvm_i32_ty>, llvm_i32_ty, llvm_i64_ty],
-            [IntrInaccessibleMemOrArgMemOnly, ReadOnly<0>, NoCapture<0>,
-             IntrHasSideEffects],
-             "", [SDNPMemOperand]>;
-def int_wasm_atomic_wait_i64 :
+            [IntrInaccessibleMemOrArgMemOnly, ReadOnly<ArgIndex<0>>,
+             NoCapture<ArgIndex<0>>, IntrHasSideEffects],
+            "", [SDNPMemOperand]>;
+def int_wasm_memory_atomic_wait64 :
   Intrinsic<[llvm_i32_ty],
             [LLVMPointerType<llvm_i64_ty>, llvm_i64_ty, llvm_i64_ty],
-            [IntrInaccessibleMemOrArgMemOnly, ReadOnly<0>, NoCapture<0>,
-             IntrHasSideEffects],
-             "", [SDNPMemOperand]>;
-def int_wasm_atomic_notify:
+            [IntrInaccessibleMemOrArgMemOnly, ReadOnly<ArgIndex<0>>,
+             NoCapture<ArgIndex<0>>, IntrHasSideEffects],
+            "", [SDNPMemOperand]>;
+def int_wasm_memory_atomic_notify:
   Intrinsic<[llvm_i32_ty], [LLVMPointerType<llvm_i32_ty>, llvm_i32_ty],
-            [IntrInaccessibleMemOnly, NoCapture<0>, IntrHasSideEffects], "",
-            [SDNPMemOperand]>;
+            [IntrInaccessibleMemOnly, NoCapture<ArgIndex<0>>,
+             IntrHasSideEffects],
+            "", [SDNPMemOperand]>;
 
 //===----------------------------------------------------------------------===//
 // SIMD intrinsics
 //===----------------------------------------------------------------------===//
 
+def int_wasm_swizzle :
+  Intrinsic<[llvm_v16i8_ty],
+            [llvm_v16i8_ty, llvm_v16i8_ty],
+            [IntrNoMem, IntrSpeculatable]>;
+def int_wasm_shuffle :
+  Intrinsic<[llvm_v16i8_ty],
+            [llvm_v16i8_ty, llvm_v16i8_ty, llvm_i32_ty, llvm_i32_ty,
+             llvm_i32_ty, llvm_i32_ty, llvm_i32_ty, llvm_i32_ty, llvm_i32_ty,
+             llvm_i32_ty, llvm_i32_ty, llvm_i32_ty, llvm_i32_ty, llvm_i32_ty,
+             llvm_i32_ty, llvm_i32_ty, llvm_i32_ty, llvm_i32_ty],
+            [IntrNoMem, IntrSpeculatable]>;
 def int_wasm_sub_saturate_signed :
   Intrinsic<[llvm_anyvector_ty],
             [LLVMMatchType<0>, LLVMMatchType<0>],
@@ -97,6 +123,10 @@
   Intrinsic<[llvm_anyvector_ty],
             [LLVMMatchType<0>, LLVMMatchType<0>],
             [IntrNoMem, IntrSpeculatable]>;
+def int_wasm_avgr_unsigned :
+  Intrinsic<[llvm_anyvector_ty],
+            [LLVMMatchType<0>, LLVMMatchType<0>],
+            [IntrNoMem, IntrSpeculatable]>;
 def int_wasm_bitselect :
   Intrinsic<[llvm_anyvector_ty],
             [LLVMMatchType<0>, LLVMMatchType<0>, LLVMMatchType<0>],
@@ -109,19 +139,212 @@
   Intrinsic<[llvm_i32_ty],
             [llvm_anyvector_ty],
             [IntrNoMem, IntrSpeculatable]>;
+def int_wasm_bitmask :
+  Intrinsic<[llvm_i32_ty],
+            [llvm_anyvector_ty],
+            [IntrNoMem, IntrSpeculatable]>;
+def int_wasm_qfma :
+  Intrinsic<[llvm_anyvector_ty],
+            [LLVMMatchType<0>, LLVMMatchType<0>, LLVMMatchType<0>],
+            [IntrNoMem, IntrSpeculatable]>;
+def int_wasm_qfms :
+  Intrinsic<[llvm_anyvector_ty],
+            [LLVMMatchType<0>, LLVMMatchType<0>, LLVMMatchType<0>],
+            [IntrNoMem, IntrSpeculatable]>;
+def int_wasm_dot :
+  Intrinsic<[llvm_v4i32_ty],
+            [llvm_v8i16_ty, llvm_v8i16_ty],
+            [IntrNoMem, IntrSpeculatable]>;
+
+def int_wasm_narrow_signed :
+  Intrinsic<[llvm_anyvector_ty],
+            [llvm_anyvector_ty, LLVMMatchType<1>],
+            [IntrNoMem, IntrSpeculatable]>;
+def int_wasm_narrow_unsigned :
+  Intrinsic<[llvm_anyvector_ty],
+            [llvm_anyvector_ty, LLVMMatchType<1>],
+            [IntrNoMem, IntrSpeculatable]>;
+
+// TODO: Replace these intrinsics with normal ISel patterns once i32x4 to i64x2
+// widening is merged to the proposal.
+def int_wasm_widen_low_signed :
+  Intrinsic<[llvm_v2i64_ty], [llvm_v4i32_ty], [IntrNoMem, IntrSpeculatable]>;
+def int_wasm_widen_high_signed :
+  Intrinsic<[llvm_v2i64_ty], [llvm_v4i32_ty], [IntrNoMem, IntrSpeculatable]>;
+def int_wasm_widen_low_unsigned :
+  Intrinsic<[llvm_v2i64_ty], [llvm_v4i32_ty], [IntrNoMem, IntrSpeculatable]>;
+def int_wasm_widen_high_unsigned :
+  Intrinsic<[llvm_v2i64_ty], [llvm_v4i32_ty], [IntrNoMem, IntrSpeculatable]>;
+
+def int_wasm_q15mulr_saturate_signed :
+  Intrinsic<[llvm_v8i16_ty],
+            [llvm_v8i16_ty, llvm_v8i16_ty],
+            [IntrNoMem, IntrSpeculatable]>;
+
+// TODO: Replace these intrinsics with normal ISel patterns
+def int_wasm_pmin :
+  Intrinsic<[llvm_anyvector_ty],
+            [LLVMMatchType<0>, LLVMMatchType<0>],
+            [IntrNoMem, IntrSpeculatable]>;
+def int_wasm_pmax :
+  Intrinsic<[llvm_anyvector_ty],
+            [LLVMMatchType<0>, LLVMMatchType<0>],
+            [IntrNoMem, IntrSpeculatable]>;
+
+// TODO: Replace these instrinsics with normal ISel patterns once the
+// rounding instructions are merged to the proposal
+// (https://github.com/WebAssembly/simd/pull/232).
+def int_wasm_ceil :
+  Intrinsic<[llvm_anyvector_ty],
+            [LLVMMatchType<0>],
+            [IntrNoMem, IntrSpeculatable]>;
+def int_wasm_floor :
+  Intrinsic<[llvm_anyvector_ty],
+            [LLVMMatchType<0>],
+            [IntrNoMem, IntrSpeculatable]>;
+def int_wasm_trunc :
+  Intrinsic<[llvm_anyvector_ty],
+            [LLVMMatchType<0>],
+            [IntrNoMem, IntrSpeculatable]>;
+def int_wasm_nearest :
+  Intrinsic<[llvm_anyvector_ty],
+            [LLVMMatchType<0>],
+            [IntrNoMem, IntrSpeculatable]>;
+
+// TODO: Replace these intrinsic with normal ISel patterns once the
+// load_zero instructions are merged to the proposal.
+def int_wasm_load32_zero :
+  Intrinsic<[llvm_v4i32_ty],
+            [LLVMPointerType<llvm_i32_ty>],
+            [IntrReadMem, IntrArgMemOnly],
+             "", [SDNPMemOperand]>;
+
+def int_wasm_load64_zero :
+  Intrinsic<[llvm_v2i64_ty],
+            [LLVMPointerType<llvm_i64_ty>],
+            [IntrReadMem, IntrArgMemOnly],
+             "", [SDNPMemOperand]>;
+
+// These intrinsics do not mark their lane index arguments as immediate because
+// that changes the corresponding SDNode from ISD::Constant to
+// ISD::TargetConstant, which would require extra complications in the ISel
+// tablegen patterns. TODO: Replace these intrinsic with normal ISel patterns
+// once the load_lane instructions are merged to the proposal.
+def int_wasm_load8_lane :
+  Intrinsic<[llvm_v16i8_ty],
+            [LLVMPointerType<llvm_i8_ty>, llvm_v16i8_ty, llvm_i32_ty],
+            [IntrReadMem, IntrArgMemOnly],
+            "", [SDNPMemOperand]>;
+def int_wasm_load16_lane :
+  Intrinsic<[llvm_v8i16_ty],
+            [LLVMPointerType<llvm_i16_ty>, llvm_v8i16_ty, llvm_i32_ty],
+            [IntrReadMem, IntrArgMemOnly],
+            "", [SDNPMemOperand]>;
+def int_wasm_load32_lane :
+  Intrinsic<[llvm_v4i32_ty],
+            [LLVMPointerType<llvm_i32_ty>, llvm_v4i32_ty, llvm_i32_ty],
+            [IntrReadMem, IntrArgMemOnly],
+            "", [SDNPMemOperand]>;
+def int_wasm_load64_lane :
+  Intrinsic<[llvm_v2i64_ty],
+            [LLVMPointerType<llvm_i64_ty>, llvm_v2i64_ty, llvm_i32_ty],
+            [IntrReadMem, IntrArgMemOnly],
+            "", [SDNPMemOperand]>;
+def int_wasm_store8_lane :
+  Intrinsic<[],
+            [LLVMPointerType<llvm_i8_ty>, llvm_v16i8_ty, llvm_i32_ty],
+            [IntrWriteMem, IntrArgMemOnly],
+            "", [SDNPMemOperand]>;
+def int_wasm_store16_lane :
+  Intrinsic<[],
+            [LLVMPointerType<llvm_i16_ty>, llvm_v8i16_ty, llvm_i32_ty],
+            [IntrWriteMem, IntrArgMemOnly],
+            "", [SDNPMemOperand]>;
+def int_wasm_store32_lane :
+  Intrinsic<[],
+            [LLVMPointerType<llvm_i32_ty>, llvm_v4i32_ty, llvm_i32_ty],
+            [IntrWriteMem, IntrArgMemOnly],
+            "", [SDNPMemOperand]>;
+def int_wasm_store64_lane :
+  Intrinsic<[],
+            [LLVMPointerType<llvm_i64_ty>, llvm_v2i64_ty, llvm_i32_ty],
+            [IntrWriteMem, IntrArgMemOnly],
+            "", [SDNPMemOperand]>;
+
+// TODO: Replace this intrinsic with normal ISel patterns once popcnt is merged
+// to the proposal.
+def int_wasm_popcnt :
+  Intrinsic<[llvm_v16i8_ty], [llvm_v16i8_ty], [IntrNoMem, IntrSpeculatable]>;
+
+def int_wasm_extmul_low_signed :
+  Intrinsic<[llvm_anyvector_ty],
+            [LLVMSubdivide2VectorType<0>, LLVMSubdivide2VectorType<0>],
+            [IntrNoMem, IntrSpeculatable]>;
+def int_wasm_extmul_high_signed :
+  Intrinsic<[llvm_anyvector_ty],
+            [LLVMSubdivide2VectorType<0>, LLVMSubdivide2VectorType<0>],
+            [IntrNoMem, IntrSpeculatable]>;
+def int_wasm_extmul_low_unsigned :
+  Intrinsic<[llvm_anyvector_ty],
+            [LLVMSubdivide2VectorType<0>, LLVMSubdivide2VectorType<0>],
+            [IntrNoMem, IntrSpeculatable]>;
+def int_wasm_extmul_high_unsigned :
+  Intrinsic<[llvm_anyvector_ty],
+            [LLVMSubdivide2VectorType<0>, LLVMSubdivide2VectorType<0>],
+            [IntrNoMem, IntrSpeculatable]>;
+
+def int_wasm_extadd_pairwise_signed :
+  Intrinsic<[llvm_anyvector_ty],
+            [LLVMSubdivide2VectorType<0>],
+            [IntrNoMem, IntrSpeculatable]>;
+def int_wasm_extadd_pairwise_unsigned :
+  Intrinsic<[llvm_anyvector_ty],
+            [LLVMSubdivide2VectorType<0>],
+            [IntrNoMem, IntrSpeculatable]>;
+
+def int_wasm_signselect :
+  Intrinsic<[llvm_anyvector_ty],
+            [LLVMMatchType<0>, LLVMMatchType<0>, LLVMMatchType<0>],
+            [IntrNoMem, IntrSpeculatable]>;
+
+// TODO: Remove this intrinsic and the associated builtin if i64x2.eq gets
+// merged to the proposal.
+def int_wasm_eq :
+  Intrinsic<[llvm_v2i64_ty],
+            [llvm_v2i64_ty, llvm_v2i64_ty],
+            [IntrNoMem, IntrSpeculatable]>;
+
+// TODO: Remove this after experiments have been run. Use the target-agnostic
+// int_prefetch if this becomes specified at some point.
+def int_wasm_prefetch_t :
+  Intrinsic<[], [llvm_ptr_ty],
+            [IntrInaccessibleMemOrArgMemOnly, IntrWillReturn,
+             ReadOnly<ArgIndex<0>>, NoCapture<ArgIndex<0>>],
+            "", [SDNPMemOperand]>;
+
+def int_wasm_prefetch_nt :
+  Intrinsic<[], [llvm_ptr_ty],
+            [IntrInaccessibleMemOrArgMemOnly, IntrWillReturn,
+             ReadOnly<ArgIndex<0>>, NoCapture<ArgIndex<0>>],
+            "", [SDNPMemOperand]>;
 
 //===----------------------------------------------------------------------===//
-// Bulk memory intrinsics
+// Thread-local storage intrinsics
 //===----------------------------------------------------------------------===//
 
-def int_wasm_memory_init :
-  Intrinsic<[],
-            [llvm_i32_ty, llvm_i32_ty, llvm_ptr_ty, llvm_i32_ty, llvm_i32_ty],
-            [IntrWriteMem, IntrInaccessibleMemOrArgMemOnly, WriteOnly<2>,
-             IntrHasSideEffects, ImmArg<0>, ImmArg<1>]>;
-def int_wasm_data_drop :
-  Intrinsic<[],
-            [llvm_i32_ty],
-            [IntrNoDuplicate, IntrHasSideEffects, ImmArg<0>]>;
+def int_wasm_tls_size :
+  Intrinsic<[llvm_anyint_ty],
+            [],
+            [IntrNoMem, IntrSpeculatable]>;
+
+def int_wasm_tls_align :
+  Intrinsic<[llvm_anyint_ty],
+            [],
+            [IntrNoMem, IntrSpeculatable]>;
+
+def int_wasm_tls_base :
+  Intrinsic<[llvm_ptr_ty],
+            [],
+            [IntrReadMem]>;
 
 } // TargetPrefix = "wasm"
diff --git a/linux-x64/clang/include/llvm/IR/IntrinsicsX86.h b/linux-x64/clang/include/llvm/IR/IntrinsicsX86.h
new file mode 100644
index 0000000..c2e4cba
--- /dev/null
+++ b/linux-x64/clang/include/llvm/IR/IntrinsicsX86.h
@@ -0,0 +1,1226 @@
+/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
+|*                                                                            *|
+|* Intrinsic Function Source Fragment                                         *|
+|*                                                                            *|
+|* Automatically generated file, do not edit!                                 *|
+|*                                                                            *|
+\*===----------------------------------------------------------------------===*/
+
+#ifndef LLVM_IR_INTRINSIC_X86_ENUMS_H
+#define LLVM_IR_INTRINSIC_X86_ENUMS_H
+
+namespace llvm {
+namespace Intrinsic {
+enum X86Intrinsics : unsigned {
+// Enum values for intrinsics
+    x86_3dnow_pavgusb = 8500,                         // llvm.x86.3dnow.pavgusb
+    x86_3dnow_pf2id,                           // llvm.x86.3dnow.pf2id
+    x86_3dnow_pfacc,                           // llvm.x86.3dnow.pfacc
+    x86_3dnow_pfadd,                           // llvm.x86.3dnow.pfadd
+    x86_3dnow_pfcmpeq,                         // llvm.x86.3dnow.pfcmpeq
+    x86_3dnow_pfcmpge,                         // llvm.x86.3dnow.pfcmpge
+    x86_3dnow_pfcmpgt,                         // llvm.x86.3dnow.pfcmpgt
+    x86_3dnow_pfmax,                           // llvm.x86.3dnow.pfmax
+    x86_3dnow_pfmin,                           // llvm.x86.3dnow.pfmin
+    x86_3dnow_pfmul,                           // llvm.x86.3dnow.pfmul
+    x86_3dnow_pfrcp,                           // llvm.x86.3dnow.pfrcp
+    x86_3dnow_pfrcpit1,                        // llvm.x86.3dnow.pfrcpit1
+    x86_3dnow_pfrcpit2,                        // llvm.x86.3dnow.pfrcpit2
+    x86_3dnow_pfrsqit1,                        // llvm.x86.3dnow.pfrsqit1
+    x86_3dnow_pfrsqrt,                         // llvm.x86.3dnow.pfrsqrt
+    x86_3dnow_pfsub,                           // llvm.x86.3dnow.pfsub
+    x86_3dnow_pfsubr,                          // llvm.x86.3dnow.pfsubr
+    x86_3dnow_pi2fd,                           // llvm.x86.3dnow.pi2fd
+    x86_3dnow_pmulhrw,                         // llvm.x86.3dnow.pmulhrw
+    x86_3dnowa_pf2iw,                          // llvm.x86.3dnowa.pf2iw
+    x86_3dnowa_pfnacc,                         // llvm.x86.3dnowa.pfnacc
+    x86_3dnowa_pfpnacc,                        // llvm.x86.3dnowa.pfpnacc
+    x86_3dnowa_pi2fw,                          // llvm.x86.3dnowa.pi2fw
+    x86_3dnowa_pswapd,                         // llvm.x86.3dnowa.pswapd
+    x86_addcarry_32,                           // llvm.x86.addcarry.32
+    x86_addcarry_64,                           // llvm.x86.addcarry.64
+    x86_aesdec128kl,                           // llvm.x86.aesdec128kl
+    x86_aesdec256kl,                           // llvm.x86.aesdec256kl
+    x86_aesdecwide128kl,                       // llvm.x86.aesdecwide128kl
+    x86_aesdecwide256kl,                       // llvm.x86.aesdecwide256kl
+    x86_aesenc128kl,                           // llvm.x86.aesenc128kl
+    x86_aesenc256kl,                           // llvm.x86.aesenc256kl
+    x86_aesencwide128kl,                       // llvm.x86.aesencwide128kl
+    x86_aesencwide256kl,                       // llvm.x86.aesencwide256kl
+    x86_aesni_aesdec,                          // llvm.x86.aesni.aesdec
+    x86_aesni_aesdec_256,                      // llvm.x86.aesni.aesdec.256
+    x86_aesni_aesdec_512,                      // llvm.x86.aesni.aesdec.512
+    x86_aesni_aesdeclast,                      // llvm.x86.aesni.aesdeclast
+    x86_aesni_aesdeclast_256,                  // llvm.x86.aesni.aesdeclast.256
+    x86_aesni_aesdeclast_512,                  // llvm.x86.aesni.aesdeclast.512
+    x86_aesni_aesenc,                          // llvm.x86.aesni.aesenc
+    x86_aesni_aesenc_256,                      // llvm.x86.aesni.aesenc.256
+    x86_aesni_aesenc_512,                      // llvm.x86.aesni.aesenc.512
+    x86_aesni_aesenclast,                      // llvm.x86.aesni.aesenclast
+    x86_aesni_aesenclast_256,                  // llvm.x86.aesni.aesenclast.256
+    x86_aesni_aesenclast_512,                  // llvm.x86.aesni.aesenclast.512
+    x86_aesni_aesimc,                          // llvm.x86.aesni.aesimc
+    x86_aesni_aeskeygenassist,                 // llvm.x86.aesni.aeskeygenassist
+    x86_avx_addsub_pd_256,                     // llvm.x86.avx.addsub.pd.256
+    x86_avx_addsub_ps_256,                     // llvm.x86.avx.addsub.ps.256
+    x86_avx_blendv_pd_256,                     // llvm.x86.avx.blendv.pd.256
+    x86_avx_blendv_ps_256,                     // llvm.x86.avx.blendv.ps.256
+    x86_avx_cmp_pd_256,                        // llvm.x86.avx.cmp.pd.256
+    x86_avx_cmp_ps_256,                        // llvm.x86.avx.cmp.ps.256
+    x86_avx_cvt_pd2_ps_256,                    // llvm.x86.avx.cvt.pd2.ps.256
+    x86_avx_cvt_pd2dq_256,                     // llvm.x86.avx.cvt.pd2dq.256
+    x86_avx_cvt_ps2dq_256,                     // llvm.x86.avx.cvt.ps2dq.256
+    x86_avx_cvtt_pd2dq_256,                    // llvm.x86.avx.cvtt.pd2dq.256
+    x86_avx_cvtt_ps2dq_256,                    // llvm.x86.avx.cvtt.ps2dq.256
+    x86_avx_dp_ps_256,                         // llvm.x86.avx.dp.ps.256
+    x86_avx_hadd_pd_256,                       // llvm.x86.avx.hadd.pd.256
+    x86_avx_hadd_ps_256,                       // llvm.x86.avx.hadd.ps.256
+    x86_avx_hsub_pd_256,                       // llvm.x86.avx.hsub.pd.256
+    x86_avx_hsub_ps_256,                       // llvm.x86.avx.hsub.ps.256
+    x86_avx_ldu_dq_256,                        // llvm.x86.avx.ldu.dq.256
+    x86_avx_maskload_pd,                       // llvm.x86.avx.maskload.pd
+    x86_avx_maskload_pd_256,                   // llvm.x86.avx.maskload.pd.256
+    x86_avx_maskload_ps,                       // llvm.x86.avx.maskload.ps
+    x86_avx_maskload_ps_256,                   // llvm.x86.avx.maskload.ps.256
+    x86_avx_maskstore_pd,                      // llvm.x86.avx.maskstore.pd
+    x86_avx_maskstore_pd_256,                  // llvm.x86.avx.maskstore.pd.256
+    x86_avx_maskstore_ps,                      // llvm.x86.avx.maskstore.ps
+    x86_avx_maskstore_ps_256,                  // llvm.x86.avx.maskstore.ps.256
+    x86_avx_max_pd_256,                        // llvm.x86.avx.max.pd.256
+    x86_avx_max_ps_256,                        // llvm.x86.avx.max.ps.256
+    x86_avx_min_pd_256,                        // llvm.x86.avx.min.pd.256
+    x86_avx_min_ps_256,                        // llvm.x86.avx.min.ps.256
+    x86_avx_movmsk_pd_256,                     // llvm.x86.avx.movmsk.pd.256
+    x86_avx_movmsk_ps_256,                     // llvm.x86.avx.movmsk.ps.256
+    x86_avx_ptestc_256,                        // llvm.x86.avx.ptestc.256
+    x86_avx_ptestnzc_256,                      // llvm.x86.avx.ptestnzc.256
+    x86_avx_ptestz_256,                        // llvm.x86.avx.ptestz.256
+    x86_avx_rcp_ps_256,                        // llvm.x86.avx.rcp.ps.256
+    x86_avx_round_pd_256,                      // llvm.x86.avx.round.pd.256
+    x86_avx_round_ps_256,                      // llvm.x86.avx.round.ps.256
+    x86_avx_rsqrt_ps_256,                      // llvm.x86.avx.rsqrt.ps.256
+    x86_avx_vpermilvar_pd,                     // llvm.x86.avx.vpermilvar.pd
+    x86_avx_vpermilvar_pd_256,                 // llvm.x86.avx.vpermilvar.pd.256
+    x86_avx_vpermilvar_ps,                     // llvm.x86.avx.vpermilvar.ps
+    x86_avx_vpermilvar_ps_256,                 // llvm.x86.avx.vpermilvar.ps.256
+    x86_avx_vtestc_pd,                         // llvm.x86.avx.vtestc.pd
+    x86_avx_vtestc_pd_256,                     // llvm.x86.avx.vtestc.pd.256
+    x86_avx_vtestc_ps,                         // llvm.x86.avx.vtestc.ps
+    x86_avx_vtestc_ps_256,                     // llvm.x86.avx.vtestc.ps.256
+    x86_avx_vtestnzc_pd,                       // llvm.x86.avx.vtestnzc.pd
+    x86_avx_vtestnzc_pd_256,                   // llvm.x86.avx.vtestnzc.pd.256
+    x86_avx_vtestnzc_ps,                       // llvm.x86.avx.vtestnzc.ps
+    x86_avx_vtestnzc_ps_256,                   // llvm.x86.avx.vtestnzc.ps.256
+    x86_avx_vtestz_pd,                         // llvm.x86.avx.vtestz.pd
+    x86_avx_vtestz_pd_256,                     // llvm.x86.avx.vtestz.pd.256
+    x86_avx_vtestz_ps,                         // llvm.x86.avx.vtestz.ps
+    x86_avx_vtestz_ps_256,                     // llvm.x86.avx.vtestz.ps.256
+    x86_avx_vzeroall,                          // llvm.x86.avx.vzeroall
+    x86_avx_vzeroupper,                        // llvm.x86.avx.vzeroupper
+    x86_avx2_gather_d_d,                       // llvm.x86.avx2.gather.d.d
+    x86_avx2_gather_d_d_256,                   // llvm.x86.avx2.gather.d.d.256
+    x86_avx2_gather_d_pd,                      // llvm.x86.avx2.gather.d.pd
+    x86_avx2_gather_d_pd_256,                  // llvm.x86.avx2.gather.d.pd.256
+    x86_avx2_gather_d_ps,                      // llvm.x86.avx2.gather.d.ps
+    x86_avx2_gather_d_ps_256,                  // llvm.x86.avx2.gather.d.ps.256
+    x86_avx2_gather_d_q,                       // llvm.x86.avx2.gather.d.q
+    x86_avx2_gather_d_q_256,                   // llvm.x86.avx2.gather.d.q.256
+    x86_avx2_gather_q_d,                       // llvm.x86.avx2.gather.q.d
+    x86_avx2_gather_q_d_256,                   // llvm.x86.avx2.gather.q.d.256
+    x86_avx2_gather_q_pd,                      // llvm.x86.avx2.gather.q.pd
+    x86_avx2_gather_q_pd_256,                  // llvm.x86.avx2.gather.q.pd.256
+    x86_avx2_gather_q_ps,                      // llvm.x86.avx2.gather.q.ps
+    x86_avx2_gather_q_ps_256,                  // llvm.x86.avx2.gather.q.ps.256
+    x86_avx2_gather_q_q,                       // llvm.x86.avx2.gather.q.q
+    x86_avx2_gather_q_q_256,                   // llvm.x86.avx2.gather.q.q.256
+    x86_avx2_maskload_d,                       // llvm.x86.avx2.maskload.d
+    x86_avx2_maskload_d_256,                   // llvm.x86.avx2.maskload.d.256
+    x86_avx2_maskload_q,                       // llvm.x86.avx2.maskload.q
+    x86_avx2_maskload_q_256,                   // llvm.x86.avx2.maskload.q.256
+    x86_avx2_maskstore_d,                      // llvm.x86.avx2.maskstore.d
+    x86_avx2_maskstore_d_256,                  // llvm.x86.avx2.maskstore.d.256
+    x86_avx2_maskstore_q,                      // llvm.x86.avx2.maskstore.q
+    x86_avx2_maskstore_q_256,                  // llvm.x86.avx2.maskstore.q.256
+    x86_avx2_mpsadbw,                          // llvm.x86.avx2.mpsadbw
+    x86_avx2_packssdw,                         // llvm.x86.avx2.packssdw
+    x86_avx2_packsswb,                         // llvm.x86.avx2.packsswb
+    x86_avx2_packusdw,                         // llvm.x86.avx2.packusdw
+    x86_avx2_packuswb,                         // llvm.x86.avx2.packuswb
+    x86_avx2_pavg_b,                           // llvm.x86.avx2.pavg.b
+    x86_avx2_pavg_w,                           // llvm.x86.avx2.pavg.w
+    x86_avx2_pblendvb,                         // llvm.x86.avx2.pblendvb
+    x86_avx2_permd,                            // llvm.x86.avx2.permd
+    x86_avx2_permps,                           // llvm.x86.avx2.permps
+    x86_avx2_phadd_d,                          // llvm.x86.avx2.phadd.d
+    x86_avx2_phadd_sw,                         // llvm.x86.avx2.phadd.sw
+    x86_avx2_phadd_w,                          // llvm.x86.avx2.phadd.w
+    x86_avx2_phsub_d,                          // llvm.x86.avx2.phsub.d
+    x86_avx2_phsub_sw,                         // llvm.x86.avx2.phsub.sw
+    x86_avx2_phsub_w,                          // llvm.x86.avx2.phsub.w
+    x86_avx2_pmadd_ub_sw,                      // llvm.x86.avx2.pmadd.ub.sw
+    x86_avx2_pmadd_wd,                         // llvm.x86.avx2.pmadd.wd
+    x86_avx2_pmovmskb,                         // llvm.x86.avx2.pmovmskb
+    x86_avx2_pmul_hr_sw,                       // llvm.x86.avx2.pmul.hr.sw
+    x86_avx2_pmulh_w,                          // llvm.x86.avx2.pmulh.w
+    x86_avx2_pmulhu_w,                         // llvm.x86.avx2.pmulhu.w
+    x86_avx2_psad_bw,                          // llvm.x86.avx2.psad.bw
+    x86_avx2_pshuf_b,                          // llvm.x86.avx2.pshuf.b
+    x86_avx2_psign_b,                          // llvm.x86.avx2.psign.b
+    x86_avx2_psign_d,                          // llvm.x86.avx2.psign.d
+    x86_avx2_psign_w,                          // llvm.x86.avx2.psign.w
+    x86_avx2_psll_d,                           // llvm.x86.avx2.psll.d
+    x86_avx2_psll_q,                           // llvm.x86.avx2.psll.q
+    x86_avx2_psll_w,                           // llvm.x86.avx2.psll.w
+    x86_avx2_pslli_d,                          // llvm.x86.avx2.pslli.d
+    x86_avx2_pslli_q,                          // llvm.x86.avx2.pslli.q
+    x86_avx2_pslli_w,                          // llvm.x86.avx2.pslli.w
+    x86_avx2_psllv_d,                          // llvm.x86.avx2.psllv.d
+    x86_avx2_psllv_d_256,                      // llvm.x86.avx2.psllv.d.256
+    x86_avx2_psllv_q,                          // llvm.x86.avx2.psllv.q
+    x86_avx2_psllv_q_256,                      // llvm.x86.avx2.psllv.q.256
+    x86_avx2_psra_d,                           // llvm.x86.avx2.psra.d
+    x86_avx2_psra_w,                           // llvm.x86.avx2.psra.w
+    x86_avx2_psrai_d,                          // llvm.x86.avx2.psrai.d
+    x86_avx2_psrai_w,                          // llvm.x86.avx2.psrai.w
+    x86_avx2_psrav_d,                          // llvm.x86.avx2.psrav.d
+    x86_avx2_psrav_d_256,                      // llvm.x86.avx2.psrav.d.256
+    x86_avx2_psrl_d,                           // llvm.x86.avx2.psrl.d
+    x86_avx2_psrl_q,                           // llvm.x86.avx2.psrl.q
+    x86_avx2_psrl_w,                           // llvm.x86.avx2.psrl.w
+    x86_avx2_psrli_d,                          // llvm.x86.avx2.psrli.d
+    x86_avx2_psrli_q,                          // llvm.x86.avx2.psrli.q
+    x86_avx2_psrli_w,                          // llvm.x86.avx2.psrli.w
+    x86_avx2_psrlv_d,                          // llvm.x86.avx2.psrlv.d
+    x86_avx2_psrlv_d_256,                      // llvm.x86.avx2.psrlv.d.256
+    x86_avx2_psrlv_q,                          // llvm.x86.avx2.psrlv.q
+    x86_avx2_psrlv_q_256,                      // llvm.x86.avx2.psrlv.q.256
+    x86_avx512_add_pd_512,                     // llvm.x86.avx512.add.pd.512
+    x86_avx512_add_ps_512,                     // llvm.x86.avx512.add.ps.512
+    x86_avx512_broadcastmb_128,                // llvm.x86.avx512.broadcastmb.128
+    x86_avx512_broadcastmb_256,                // llvm.x86.avx512.broadcastmb.256
+    x86_avx512_broadcastmb_512,                // llvm.x86.avx512.broadcastmb.512
+    x86_avx512_broadcastmw_128,                // llvm.x86.avx512.broadcastmw.128
+    x86_avx512_broadcastmw_256,                // llvm.x86.avx512.broadcastmw.256
+    x86_avx512_broadcastmw_512,                // llvm.x86.avx512.broadcastmw.512
+    x86_avx512_conflict_d_128,                 // llvm.x86.avx512.conflict.d.128
+    x86_avx512_conflict_d_256,                 // llvm.x86.avx512.conflict.d.256
+    x86_avx512_conflict_d_512,                 // llvm.x86.avx512.conflict.d.512
+    x86_avx512_conflict_q_128,                 // llvm.x86.avx512.conflict.q.128
+    x86_avx512_conflict_q_256,                 // llvm.x86.avx512.conflict.q.256
+    x86_avx512_conflict_q_512,                 // llvm.x86.avx512.conflict.q.512
+    x86_avx512_cvtsi2sd64,                     // llvm.x86.avx512.cvtsi2sd64
+    x86_avx512_cvtsi2ss32,                     // llvm.x86.avx512.cvtsi2ss32
+    x86_avx512_cvtsi2ss64,                     // llvm.x86.avx512.cvtsi2ss64
+    x86_avx512_cvttsd2si,                      // llvm.x86.avx512.cvttsd2si
+    x86_avx512_cvttsd2si64,                    // llvm.x86.avx512.cvttsd2si64
+    x86_avx512_cvttsd2usi,                     // llvm.x86.avx512.cvttsd2usi
+    x86_avx512_cvttsd2usi64,                   // llvm.x86.avx512.cvttsd2usi64
+    x86_avx512_cvttss2si,                      // llvm.x86.avx512.cvttss2si
+    x86_avx512_cvttss2si64,                    // llvm.x86.avx512.cvttss2si64
+    x86_avx512_cvttss2usi,                     // llvm.x86.avx512.cvttss2usi
+    x86_avx512_cvttss2usi64,                   // llvm.x86.avx512.cvttss2usi64
+    x86_avx512_cvtusi2ss,                      // llvm.x86.avx512.cvtusi2ss
+    x86_avx512_cvtusi642sd,                    // llvm.x86.avx512.cvtusi642sd
+    x86_avx512_cvtusi642ss,                    // llvm.x86.avx512.cvtusi642ss
+    x86_avx512_dbpsadbw_128,                   // llvm.x86.avx512.dbpsadbw.128
+    x86_avx512_dbpsadbw_256,                   // llvm.x86.avx512.dbpsadbw.256
+    x86_avx512_dbpsadbw_512,                   // llvm.x86.avx512.dbpsadbw.512
+    x86_avx512_div_pd_512,                     // llvm.x86.avx512.div.pd.512
+    x86_avx512_div_ps_512,                     // llvm.x86.avx512.div.ps.512
+    x86_avx512_exp2_pd,                        // llvm.x86.avx512.exp2.pd
+    x86_avx512_exp2_ps,                        // llvm.x86.avx512.exp2.ps
+    x86_avx512_fpclass_pd_128,                 // llvm.x86.avx512.fpclass.pd.128
+    x86_avx512_fpclass_pd_256,                 // llvm.x86.avx512.fpclass.pd.256
+    x86_avx512_fpclass_pd_512,                 // llvm.x86.avx512.fpclass.pd.512
+    x86_avx512_fpclass_ps_128,                 // llvm.x86.avx512.fpclass.ps.128
+    x86_avx512_fpclass_ps_256,                 // llvm.x86.avx512.fpclass.ps.256
+    x86_avx512_fpclass_ps_512,                 // llvm.x86.avx512.fpclass.ps.512
+    x86_avx512_gather_dpd_512,                 // llvm.x86.avx512.gather.dpd.512
+    x86_avx512_gather_dpi_512,                 // llvm.x86.avx512.gather.dpi.512
+    x86_avx512_gather_dpq_512,                 // llvm.x86.avx512.gather.dpq.512
+    x86_avx512_gather_dps_512,                 // llvm.x86.avx512.gather.dps.512
+    x86_avx512_gather_qpd_512,                 // llvm.x86.avx512.gather.qpd.512
+    x86_avx512_gather_qpi_512,                 // llvm.x86.avx512.gather.qpi.512
+    x86_avx512_gather_qpq_512,                 // llvm.x86.avx512.gather.qpq.512
+    x86_avx512_gather_qps_512,                 // llvm.x86.avx512.gather.qps.512
+    x86_avx512_gather3div2_df,                 // llvm.x86.avx512.gather3div2.df
+    x86_avx512_gather3div2_di,                 // llvm.x86.avx512.gather3div2.di
+    x86_avx512_gather3div4_df,                 // llvm.x86.avx512.gather3div4.df
+    x86_avx512_gather3div4_di,                 // llvm.x86.avx512.gather3div4.di
+    x86_avx512_gather3div4_sf,                 // llvm.x86.avx512.gather3div4.sf
+    x86_avx512_gather3div4_si,                 // llvm.x86.avx512.gather3div4.si
+    x86_avx512_gather3div8_sf,                 // llvm.x86.avx512.gather3div8.sf
+    x86_avx512_gather3div8_si,                 // llvm.x86.avx512.gather3div8.si
+    x86_avx512_gather3siv2_df,                 // llvm.x86.avx512.gather3siv2.df
+    x86_avx512_gather3siv2_di,                 // llvm.x86.avx512.gather3siv2.di
+    x86_avx512_gather3siv4_df,                 // llvm.x86.avx512.gather3siv4.df
+    x86_avx512_gather3siv4_di,                 // llvm.x86.avx512.gather3siv4.di
+    x86_avx512_gather3siv4_sf,                 // llvm.x86.avx512.gather3siv4.sf
+    x86_avx512_gather3siv4_si,                 // llvm.x86.avx512.gather3siv4.si
+    x86_avx512_gather3siv8_sf,                 // llvm.x86.avx512.gather3siv8.sf
+    x86_avx512_gather3siv8_si,                 // llvm.x86.avx512.gather3siv8.si
+    x86_avx512_gatherpf_dpd_512,               // llvm.x86.avx512.gatherpf.dpd.512
+    x86_avx512_gatherpf_dps_512,               // llvm.x86.avx512.gatherpf.dps.512
+    x86_avx512_gatherpf_qpd_512,               // llvm.x86.avx512.gatherpf.qpd.512
+    x86_avx512_gatherpf_qps_512,               // llvm.x86.avx512.gatherpf.qps.512
+    x86_avx512_kadd_b,                         // llvm.x86.avx512.kadd.b
+    x86_avx512_kadd_d,                         // llvm.x86.avx512.kadd.d
+    x86_avx512_kadd_q,                         // llvm.x86.avx512.kadd.q
+    x86_avx512_kadd_w,                         // llvm.x86.avx512.kadd.w
+    x86_avx512_ktestc_b,                       // llvm.x86.avx512.ktestc.b
+    x86_avx512_ktestc_d,                       // llvm.x86.avx512.ktestc.d
+    x86_avx512_ktestc_q,                       // llvm.x86.avx512.ktestc.q
+    x86_avx512_ktestc_w,                       // llvm.x86.avx512.ktestc.w
+    x86_avx512_ktestz_b,                       // llvm.x86.avx512.ktestz.b
+    x86_avx512_ktestz_d,                       // llvm.x86.avx512.ktestz.d
+    x86_avx512_ktestz_q,                       // llvm.x86.avx512.ktestz.q
+    x86_avx512_ktestz_w,                       // llvm.x86.avx512.ktestz.w
+    x86_avx512_mask_add_sd_round,              // llvm.x86.avx512.mask.add.sd.round
+    x86_avx512_mask_add_ss_round,              // llvm.x86.avx512.mask.add.ss.round
+    x86_avx512_mask_cmp_pd_128,                // llvm.x86.avx512.mask.cmp.pd.128
+    x86_avx512_mask_cmp_pd_256,                // llvm.x86.avx512.mask.cmp.pd.256
+    x86_avx512_mask_cmp_pd_512,                // llvm.x86.avx512.mask.cmp.pd.512
+    x86_avx512_mask_cmp_ps_128,                // llvm.x86.avx512.mask.cmp.ps.128
+    x86_avx512_mask_cmp_ps_256,                // llvm.x86.avx512.mask.cmp.ps.256
+    x86_avx512_mask_cmp_ps_512,                // llvm.x86.avx512.mask.cmp.ps.512
+    x86_avx512_mask_cmp_sd,                    // llvm.x86.avx512.mask.cmp.sd
+    x86_avx512_mask_cmp_ss,                    // llvm.x86.avx512.mask.cmp.ss
+    x86_avx512_mask_compress,                  // llvm.x86.avx512.mask.compress
+    x86_avx512_mask_cvtpd2dq_128,              // llvm.x86.avx512.mask.cvtpd2dq.128
+    x86_avx512_mask_cvtpd2dq_512,              // llvm.x86.avx512.mask.cvtpd2dq.512
+    x86_avx512_mask_cvtpd2ps,                  // llvm.x86.avx512.mask.cvtpd2ps
+    x86_avx512_mask_cvtpd2ps_512,              // llvm.x86.avx512.mask.cvtpd2ps.512
+    x86_avx512_mask_cvtpd2qq_128,              // llvm.x86.avx512.mask.cvtpd2qq.128
+    x86_avx512_mask_cvtpd2qq_256,              // llvm.x86.avx512.mask.cvtpd2qq.256
+    x86_avx512_mask_cvtpd2qq_512,              // llvm.x86.avx512.mask.cvtpd2qq.512
+    x86_avx512_mask_cvtpd2udq_128,             // llvm.x86.avx512.mask.cvtpd2udq.128
+    x86_avx512_mask_cvtpd2udq_256,             // llvm.x86.avx512.mask.cvtpd2udq.256
+    x86_avx512_mask_cvtpd2udq_512,             // llvm.x86.avx512.mask.cvtpd2udq.512
+    x86_avx512_mask_cvtpd2uqq_128,             // llvm.x86.avx512.mask.cvtpd2uqq.128
+    x86_avx512_mask_cvtpd2uqq_256,             // llvm.x86.avx512.mask.cvtpd2uqq.256
+    x86_avx512_mask_cvtpd2uqq_512,             // llvm.x86.avx512.mask.cvtpd2uqq.512
+    x86_avx512_mask_cvtps2dq_128,              // llvm.x86.avx512.mask.cvtps2dq.128
+    x86_avx512_mask_cvtps2dq_256,              // llvm.x86.avx512.mask.cvtps2dq.256
+    x86_avx512_mask_cvtps2dq_512,              // llvm.x86.avx512.mask.cvtps2dq.512
+    x86_avx512_mask_cvtps2pd_512,              // llvm.x86.avx512.mask.cvtps2pd.512
+    x86_avx512_mask_cvtps2qq_128,              // llvm.x86.avx512.mask.cvtps2qq.128
+    x86_avx512_mask_cvtps2qq_256,              // llvm.x86.avx512.mask.cvtps2qq.256
+    x86_avx512_mask_cvtps2qq_512,              // llvm.x86.avx512.mask.cvtps2qq.512
+    x86_avx512_mask_cvtps2udq_128,             // llvm.x86.avx512.mask.cvtps2udq.128
+    x86_avx512_mask_cvtps2udq_256,             // llvm.x86.avx512.mask.cvtps2udq.256
+    x86_avx512_mask_cvtps2udq_512,             // llvm.x86.avx512.mask.cvtps2udq.512
+    x86_avx512_mask_cvtps2uqq_128,             // llvm.x86.avx512.mask.cvtps2uqq.128
+    x86_avx512_mask_cvtps2uqq_256,             // llvm.x86.avx512.mask.cvtps2uqq.256
+    x86_avx512_mask_cvtps2uqq_512,             // llvm.x86.avx512.mask.cvtps2uqq.512
+    x86_avx512_mask_cvtqq2ps_128,              // llvm.x86.avx512.mask.cvtqq2ps.128
+    x86_avx512_mask_cvtsd2ss_round,            // llvm.x86.avx512.mask.cvtsd2ss.round
+    x86_avx512_mask_cvtss2sd_round,            // llvm.x86.avx512.mask.cvtss2sd.round
+    x86_avx512_mask_cvttpd2dq_128,             // llvm.x86.avx512.mask.cvttpd2dq.128
+    x86_avx512_mask_cvttpd2dq_512,             // llvm.x86.avx512.mask.cvttpd2dq.512
+    x86_avx512_mask_cvttpd2qq_128,             // llvm.x86.avx512.mask.cvttpd2qq.128
+    x86_avx512_mask_cvttpd2qq_256,             // llvm.x86.avx512.mask.cvttpd2qq.256
+    x86_avx512_mask_cvttpd2qq_512,             // llvm.x86.avx512.mask.cvttpd2qq.512
+    x86_avx512_mask_cvttpd2udq_128,            // llvm.x86.avx512.mask.cvttpd2udq.128
+    x86_avx512_mask_cvttpd2udq_256,            // llvm.x86.avx512.mask.cvttpd2udq.256
+    x86_avx512_mask_cvttpd2udq_512,            // llvm.x86.avx512.mask.cvttpd2udq.512
+    x86_avx512_mask_cvttpd2uqq_128,            // llvm.x86.avx512.mask.cvttpd2uqq.128
+    x86_avx512_mask_cvttpd2uqq_256,            // llvm.x86.avx512.mask.cvttpd2uqq.256
+    x86_avx512_mask_cvttpd2uqq_512,            // llvm.x86.avx512.mask.cvttpd2uqq.512
+    x86_avx512_mask_cvttps2dq_512,             // llvm.x86.avx512.mask.cvttps2dq.512
+    x86_avx512_mask_cvttps2qq_128,             // llvm.x86.avx512.mask.cvttps2qq.128
+    x86_avx512_mask_cvttps2qq_256,             // llvm.x86.avx512.mask.cvttps2qq.256
+    x86_avx512_mask_cvttps2qq_512,             // llvm.x86.avx512.mask.cvttps2qq.512
+    x86_avx512_mask_cvttps2udq_128,            // llvm.x86.avx512.mask.cvttps2udq.128
+    x86_avx512_mask_cvttps2udq_256,            // llvm.x86.avx512.mask.cvttps2udq.256
+    x86_avx512_mask_cvttps2udq_512,            // llvm.x86.avx512.mask.cvttps2udq.512
+    x86_avx512_mask_cvttps2uqq_128,            // llvm.x86.avx512.mask.cvttps2uqq.128
+    x86_avx512_mask_cvttps2uqq_256,            // llvm.x86.avx512.mask.cvttps2uqq.256
+    x86_avx512_mask_cvttps2uqq_512,            // llvm.x86.avx512.mask.cvttps2uqq.512
+    x86_avx512_mask_cvtuqq2ps_128,             // llvm.x86.avx512.mask.cvtuqq2ps.128
+    x86_avx512_mask_div_sd_round,              // llvm.x86.avx512.mask.div.sd.round
+    x86_avx512_mask_div_ss_round,              // llvm.x86.avx512.mask.div.ss.round
+    x86_avx512_mask_expand,                    // llvm.x86.avx512.mask.expand
+    x86_avx512_mask_fixupimm_pd_128,           // llvm.x86.avx512.mask.fixupimm.pd.128
+    x86_avx512_mask_fixupimm_pd_256,           // llvm.x86.avx512.mask.fixupimm.pd.256
+    x86_avx512_mask_fixupimm_pd_512,           // llvm.x86.avx512.mask.fixupimm.pd.512
+    x86_avx512_mask_fixupimm_ps_128,           // llvm.x86.avx512.mask.fixupimm.ps.128
+    x86_avx512_mask_fixupimm_ps_256,           // llvm.x86.avx512.mask.fixupimm.ps.256
+    x86_avx512_mask_fixupimm_ps_512,           // llvm.x86.avx512.mask.fixupimm.ps.512
+    x86_avx512_mask_fixupimm_sd,               // llvm.x86.avx512.mask.fixupimm.sd
+    x86_avx512_mask_fixupimm_ss,               // llvm.x86.avx512.mask.fixupimm.ss
+    x86_avx512_mask_fpclass_sd,                // llvm.x86.avx512.mask.fpclass.sd
+    x86_avx512_mask_fpclass_ss,                // llvm.x86.avx512.mask.fpclass.ss
+    x86_avx512_mask_gather_dpd_512,            // llvm.x86.avx512.mask.gather.dpd.512
+    x86_avx512_mask_gather_dpi_512,            // llvm.x86.avx512.mask.gather.dpi.512
+    x86_avx512_mask_gather_dpq_512,            // llvm.x86.avx512.mask.gather.dpq.512
+    x86_avx512_mask_gather_dps_512,            // llvm.x86.avx512.mask.gather.dps.512
+    x86_avx512_mask_gather_qpd_512,            // llvm.x86.avx512.mask.gather.qpd.512
+    x86_avx512_mask_gather_qpi_512,            // llvm.x86.avx512.mask.gather.qpi.512
+    x86_avx512_mask_gather_qpq_512,            // llvm.x86.avx512.mask.gather.qpq.512
+    x86_avx512_mask_gather_qps_512,            // llvm.x86.avx512.mask.gather.qps.512
+    x86_avx512_mask_gather3div2_df,            // llvm.x86.avx512.mask.gather3div2.df
+    x86_avx512_mask_gather3div2_di,            // llvm.x86.avx512.mask.gather3div2.di
+    x86_avx512_mask_gather3div4_df,            // llvm.x86.avx512.mask.gather3div4.df
+    x86_avx512_mask_gather3div4_di,            // llvm.x86.avx512.mask.gather3div4.di
+    x86_avx512_mask_gather3div4_sf,            // llvm.x86.avx512.mask.gather3div4.sf
+    x86_avx512_mask_gather3div4_si,            // llvm.x86.avx512.mask.gather3div4.si
+    x86_avx512_mask_gather3div8_sf,            // llvm.x86.avx512.mask.gather3div8.sf
+    x86_avx512_mask_gather3div8_si,            // llvm.x86.avx512.mask.gather3div8.si
+    x86_avx512_mask_gather3siv2_df,            // llvm.x86.avx512.mask.gather3siv2.df
+    x86_avx512_mask_gather3siv2_di,            // llvm.x86.avx512.mask.gather3siv2.di
+    x86_avx512_mask_gather3siv4_df,            // llvm.x86.avx512.mask.gather3siv4.df
+    x86_avx512_mask_gather3siv4_di,            // llvm.x86.avx512.mask.gather3siv4.di
+    x86_avx512_mask_gather3siv4_sf,            // llvm.x86.avx512.mask.gather3siv4.sf
+    x86_avx512_mask_gather3siv4_si,            // llvm.x86.avx512.mask.gather3siv4.si
+    x86_avx512_mask_gather3siv8_sf,            // llvm.x86.avx512.mask.gather3siv8.sf
+    x86_avx512_mask_gather3siv8_si,            // llvm.x86.avx512.mask.gather3siv8.si
+    x86_avx512_mask_getexp_pd_128,             // llvm.x86.avx512.mask.getexp.pd.128
+    x86_avx512_mask_getexp_pd_256,             // llvm.x86.avx512.mask.getexp.pd.256
+    x86_avx512_mask_getexp_pd_512,             // llvm.x86.avx512.mask.getexp.pd.512
+    x86_avx512_mask_getexp_ps_128,             // llvm.x86.avx512.mask.getexp.ps.128
+    x86_avx512_mask_getexp_ps_256,             // llvm.x86.avx512.mask.getexp.ps.256
+    x86_avx512_mask_getexp_ps_512,             // llvm.x86.avx512.mask.getexp.ps.512
+    x86_avx512_mask_getexp_sd,                 // llvm.x86.avx512.mask.getexp.sd
+    x86_avx512_mask_getexp_ss,                 // llvm.x86.avx512.mask.getexp.ss
+    x86_avx512_mask_getmant_pd_128,            // llvm.x86.avx512.mask.getmant.pd.128
+    x86_avx512_mask_getmant_pd_256,            // llvm.x86.avx512.mask.getmant.pd.256
+    x86_avx512_mask_getmant_pd_512,            // llvm.x86.avx512.mask.getmant.pd.512
+    x86_avx512_mask_getmant_ps_128,            // llvm.x86.avx512.mask.getmant.ps.128
+    x86_avx512_mask_getmant_ps_256,            // llvm.x86.avx512.mask.getmant.ps.256
+    x86_avx512_mask_getmant_ps_512,            // llvm.x86.avx512.mask.getmant.ps.512
+    x86_avx512_mask_getmant_sd,                // llvm.x86.avx512.mask.getmant.sd
+    x86_avx512_mask_getmant_ss,                // llvm.x86.avx512.mask.getmant.ss
+    x86_avx512_mask_max_sd_round,              // llvm.x86.avx512.mask.max.sd.round
+    x86_avx512_mask_max_ss_round,              // llvm.x86.avx512.mask.max.ss.round
+    x86_avx512_mask_min_sd_round,              // llvm.x86.avx512.mask.min.sd.round
+    x86_avx512_mask_min_ss_round,              // llvm.x86.avx512.mask.min.ss.round
+    x86_avx512_mask_mul_sd_round,              // llvm.x86.avx512.mask.mul.sd.round
+    x86_avx512_mask_mul_ss_round,              // llvm.x86.avx512.mask.mul.ss.round
+    x86_avx512_mask_pmov_db_128,               // llvm.x86.avx512.mask.pmov.db.128
+    x86_avx512_mask_pmov_db_256,               // llvm.x86.avx512.mask.pmov.db.256
+    x86_avx512_mask_pmov_db_512,               // llvm.x86.avx512.mask.pmov.db.512
+    x86_avx512_mask_pmov_db_mem_128,           // llvm.x86.avx512.mask.pmov.db.mem.128
+    x86_avx512_mask_pmov_db_mem_256,           // llvm.x86.avx512.mask.pmov.db.mem.256
+    x86_avx512_mask_pmov_db_mem_512,           // llvm.x86.avx512.mask.pmov.db.mem.512
+    x86_avx512_mask_pmov_dw_128,               // llvm.x86.avx512.mask.pmov.dw.128
+    x86_avx512_mask_pmov_dw_256,               // llvm.x86.avx512.mask.pmov.dw.256
+    x86_avx512_mask_pmov_dw_512,               // llvm.x86.avx512.mask.pmov.dw.512
+    x86_avx512_mask_pmov_dw_mem_128,           // llvm.x86.avx512.mask.pmov.dw.mem.128
+    x86_avx512_mask_pmov_dw_mem_256,           // llvm.x86.avx512.mask.pmov.dw.mem.256
+    x86_avx512_mask_pmov_dw_mem_512,           // llvm.x86.avx512.mask.pmov.dw.mem.512
+    x86_avx512_mask_pmov_qb_128,               // llvm.x86.avx512.mask.pmov.qb.128
+    x86_avx512_mask_pmov_qb_256,               // llvm.x86.avx512.mask.pmov.qb.256
+    x86_avx512_mask_pmov_qb_512,               // llvm.x86.avx512.mask.pmov.qb.512
+    x86_avx512_mask_pmov_qb_mem_128,           // llvm.x86.avx512.mask.pmov.qb.mem.128
+    x86_avx512_mask_pmov_qb_mem_256,           // llvm.x86.avx512.mask.pmov.qb.mem.256
+    x86_avx512_mask_pmov_qb_mem_512,           // llvm.x86.avx512.mask.pmov.qb.mem.512
+    x86_avx512_mask_pmov_qd_128,               // llvm.x86.avx512.mask.pmov.qd.128
+    x86_avx512_mask_pmov_qd_mem_128,           // llvm.x86.avx512.mask.pmov.qd.mem.128
+    x86_avx512_mask_pmov_qd_mem_256,           // llvm.x86.avx512.mask.pmov.qd.mem.256
+    x86_avx512_mask_pmov_qd_mem_512,           // llvm.x86.avx512.mask.pmov.qd.mem.512
+    x86_avx512_mask_pmov_qw_128,               // llvm.x86.avx512.mask.pmov.qw.128
+    x86_avx512_mask_pmov_qw_256,               // llvm.x86.avx512.mask.pmov.qw.256
+    x86_avx512_mask_pmov_qw_512,               // llvm.x86.avx512.mask.pmov.qw.512
+    x86_avx512_mask_pmov_qw_mem_128,           // llvm.x86.avx512.mask.pmov.qw.mem.128
+    x86_avx512_mask_pmov_qw_mem_256,           // llvm.x86.avx512.mask.pmov.qw.mem.256
+    x86_avx512_mask_pmov_qw_mem_512,           // llvm.x86.avx512.mask.pmov.qw.mem.512
+    x86_avx512_mask_pmov_wb_128,               // llvm.x86.avx512.mask.pmov.wb.128
+    x86_avx512_mask_pmov_wb_mem_128,           // llvm.x86.avx512.mask.pmov.wb.mem.128
+    x86_avx512_mask_pmov_wb_mem_256,           // llvm.x86.avx512.mask.pmov.wb.mem.256
+    x86_avx512_mask_pmov_wb_mem_512,           // llvm.x86.avx512.mask.pmov.wb.mem.512
+    x86_avx512_mask_pmovs_db_128,              // llvm.x86.avx512.mask.pmovs.db.128
+    x86_avx512_mask_pmovs_db_256,              // llvm.x86.avx512.mask.pmovs.db.256
+    x86_avx512_mask_pmovs_db_512,              // llvm.x86.avx512.mask.pmovs.db.512
+    x86_avx512_mask_pmovs_db_mem_128,          // llvm.x86.avx512.mask.pmovs.db.mem.128
+    x86_avx512_mask_pmovs_db_mem_256,          // llvm.x86.avx512.mask.pmovs.db.mem.256
+    x86_avx512_mask_pmovs_db_mem_512,          // llvm.x86.avx512.mask.pmovs.db.mem.512
+    x86_avx512_mask_pmovs_dw_128,              // llvm.x86.avx512.mask.pmovs.dw.128
+    x86_avx512_mask_pmovs_dw_256,              // llvm.x86.avx512.mask.pmovs.dw.256
+    x86_avx512_mask_pmovs_dw_512,              // llvm.x86.avx512.mask.pmovs.dw.512
+    x86_avx512_mask_pmovs_dw_mem_128,          // llvm.x86.avx512.mask.pmovs.dw.mem.128
+    x86_avx512_mask_pmovs_dw_mem_256,          // llvm.x86.avx512.mask.pmovs.dw.mem.256
+    x86_avx512_mask_pmovs_dw_mem_512,          // llvm.x86.avx512.mask.pmovs.dw.mem.512
+    x86_avx512_mask_pmovs_qb_128,              // llvm.x86.avx512.mask.pmovs.qb.128
+    x86_avx512_mask_pmovs_qb_256,              // llvm.x86.avx512.mask.pmovs.qb.256
+    x86_avx512_mask_pmovs_qb_512,              // llvm.x86.avx512.mask.pmovs.qb.512
+    x86_avx512_mask_pmovs_qb_mem_128,          // llvm.x86.avx512.mask.pmovs.qb.mem.128
+    x86_avx512_mask_pmovs_qb_mem_256,          // llvm.x86.avx512.mask.pmovs.qb.mem.256
+    x86_avx512_mask_pmovs_qb_mem_512,          // llvm.x86.avx512.mask.pmovs.qb.mem.512
+    x86_avx512_mask_pmovs_qd_128,              // llvm.x86.avx512.mask.pmovs.qd.128
+    x86_avx512_mask_pmovs_qd_256,              // llvm.x86.avx512.mask.pmovs.qd.256
+    x86_avx512_mask_pmovs_qd_512,              // llvm.x86.avx512.mask.pmovs.qd.512
+    x86_avx512_mask_pmovs_qd_mem_128,          // llvm.x86.avx512.mask.pmovs.qd.mem.128
+    x86_avx512_mask_pmovs_qd_mem_256,          // llvm.x86.avx512.mask.pmovs.qd.mem.256
+    x86_avx512_mask_pmovs_qd_mem_512,          // llvm.x86.avx512.mask.pmovs.qd.mem.512
+    x86_avx512_mask_pmovs_qw_128,              // llvm.x86.avx512.mask.pmovs.qw.128
+    x86_avx512_mask_pmovs_qw_256,              // llvm.x86.avx512.mask.pmovs.qw.256
+    x86_avx512_mask_pmovs_qw_512,              // llvm.x86.avx512.mask.pmovs.qw.512
+    x86_avx512_mask_pmovs_qw_mem_128,          // llvm.x86.avx512.mask.pmovs.qw.mem.128
+    x86_avx512_mask_pmovs_qw_mem_256,          // llvm.x86.avx512.mask.pmovs.qw.mem.256
+    x86_avx512_mask_pmovs_qw_mem_512,          // llvm.x86.avx512.mask.pmovs.qw.mem.512
+    x86_avx512_mask_pmovs_wb_128,              // llvm.x86.avx512.mask.pmovs.wb.128
+    x86_avx512_mask_pmovs_wb_256,              // llvm.x86.avx512.mask.pmovs.wb.256
+    x86_avx512_mask_pmovs_wb_512,              // llvm.x86.avx512.mask.pmovs.wb.512
+    x86_avx512_mask_pmovs_wb_mem_128,          // llvm.x86.avx512.mask.pmovs.wb.mem.128
+    x86_avx512_mask_pmovs_wb_mem_256,          // llvm.x86.avx512.mask.pmovs.wb.mem.256
+    x86_avx512_mask_pmovs_wb_mem_512,          // llvm.x86.avx512.mask.pmovs.wb.mem.512
+    x86_avx512_mask_pmovus_db_128,             // llvm.x86.avx512.mask.pmovus.db.128
+    x86_avx512_mask_pmovus_db_256,             // llvm.x86.avx512.mask.pmovus.db.256
+    x86_avx512_mask_pmovus_db_512,             // llvm.x86.avx512.mask.pmovus.db.512
+    x86_avx512_mask_pmovus_db_mem_128,         // llvm.x86.avx512.mask.pmovus.db.mem.128
+    x86_avx512_mask_pmovus_db_mem_256,         // llvm.x86.avx512.mask.pmovus.db.mem.256
+    x86_avx512_mask_pmovus_db_mem_512,         // llvm.x86.avx512.mask.pmovus.db.mem.512
+    x86_avx512_mask_pmovus_dw_128,             // llvm.x86.avx512.mask.pmovus.dw.128
+    x86_avx512_mask_pmovus_dw_256,             // llvm.x86.avx512.mask.pmovus.dw.256
+    x86_avx512_mask_pmovus_dw_512,             // llvm.x86.avx512.mask.pmovus.dw.512
+    x86_avx512_mask_pmovus_dw_mem_128,         // llvm.x86.avx512.mask.pmovus.dw.mem.128
+    x86_avx512_mask_pmovus_dw_mem_256,         // llvm.x86.avx512.mask.pmovus.dw.mem.256
+    x86_avx512_mask_pmovus_dw_mem_512,         // llvm.x86.avx512.mask.pmovus.dw.mem.512
+    x86_avx512_mask_pmovus_qb_128,             // llvm.x86.avx512.mask.pmovus.qb.128
+    x86_avx512_mask_pmovus_qb_256,             // llvm.x86.avx512.mask.pmovus.qb.256
+    x86_avx512_mask_pmovus_qb_512,             // llvm.x86.avx512.mask.pmovus.qb.512
+    x86_avx512_mask_pmovus_qb_mem_128,         // llvm.x86.avx512.mask.pmovus.qb.mem.128
+    x86_avx512_mask_pmovus_qb_mem_256,         // llvm.x86.avx512.mask.pmovus.qb.mem.256
+    x86_avx512_mask_pmovus_qb_mem_512,         // llvm.x86.avx512.mask.pmovus.qb.mem.512
+    x86_avx512_mask_pmovus_qd_128,             // llvm.x86.avx512.mask.pmovus.qd.128
+    x86_avx512_mask_pmovus_qd_256,             // llvm.x86.avx512.mask.pmovus.qd.256
+    x86_avx512_mask_pmovus_qd_512,             // llvm.x86.avx512.mask.pmovus.qd.512
+    x86_avx512_mask_pmovus_qd_mem_128,         // llvm.x86.avx512.mask.pmovus.qd.mem.128
+    x86_avx512_mask_pmovus_qd_mem_256,         // llvm.x86.avx512.mask.pmovus.qd.mem.256
+    x86_avx512_mask_pmovus_qd_mem_512,         // llvm.x86.avx512.mask.pmovus.qd.mem.512
+    x86_avx512_mask_pmovus_qw_128,             // llvm.x86.avx512.mask.pmovus.qw.128
+    x86_avx512_mask_pmovus_qw_256,             // llvm.x86.avx512.mask.pmovus.qw.256
+    x86_avx512_mask_pmovus_qw_512,             // llvm.x86.avx512.mask.pmovus.qw.512
+    x86_avx512_mask_pmovus_qw_mem_128,         // llvm.x86.avx512.mask.pmovus.qw.mem.128
+    x86_avx512_mask_pmovus_qw_mem_256,         // llvm.x86.avx512.mask.pmovus.qw.mem.256
+    x86_avx512_mask_pmovus_qw_mem_512,         // llvm.x86.avx512.mask.pmovus.qw.mem.512
+    x86_avx512_mask_pmovus_wb_128,             // llvm.x86.avx512.mask.pmovus.wb.128
+    x86_avx512_mask_pmovus_wb_256,             // llvm.x86.avx512.mask.pmovus.wb.256
+    x86_avx512_mask_pmovus_wb_512,             // llvm.x86.avx512.mask.pmovus.wb.512
+    x86_avx512_mask_pmovus_wb_mem_128,         // llvm.x86.avx512.mask.pmovus.wb.mem.128
+    x86_avx512_mask_pmovus_wb_mem_256,         // llvm.x86.avx512.mask.pmovus.wb.mem.256
+    x86_avx512_mask_pmovus_wb_mem_512,         // llvm.x86.avx512.mask.pmovus.wb.mem.512
+    x86_avx512_mask_range_pd_128,              // llvm.x86.avx512.mask.range.pd.128
+    x86_avx512_mask_range_pd_256,              // llvm.x86.avx512.mask.range.pd.256
+    x86_avx512_mask_range_pd_512,              // llvm.x86.avx512.mask.range.pd.512
+    x86_avx512_mask_range_ps_128,              // llvm.x86.avx512.mask.range.ps.128
+    x86_avx512_mask_range_ps_256,              // llvm.x86.avx512.mask.range.ps.256
+    x86_avx512_mask_range_ps_512,              // llvm.x86.avx512.mask.range.ps.512
+    x86_avx512_mask_range_sd,                  // llvm.x86.avx512.mask.range.sd
+    x86_avx512_mask_range_ss,                  // llvm.x86.avx512.mask.range.ss
+    x86_avx512_mask_reduce_pd_128,             // llvm.x86.avx512.mask.reduce.pd.128
+    x86_avx512_mask_reduce_pd_256,             // llvm.x86.avx512.mask.reduce.pd.256
+    x86_avx512_mask_reduce_pd_512,             // llvm.x86.avx512.mask.reduce.pd.512
+    x86_avx512_mask_reduce_ps_128,             // llvm.x86.avx512.mask.reduce.ps.128
+    x86_avx512_mask_reduce_ps_256,             // llvm.x86.avx512.mask.reduce.ps.256
+    x86_avx512_mask_reduce_ps_512,             // llvm.x86.avx512.mask.reduce.ps.512
+    x86_avx512_mask_reduce_sd,                 // llvm.x86.avx512.mask.reduce.sd
+    x86_avx512_mask_reduce_ss,                 // llvm.x86.avx512.mask.reduce.ss
+    x86_avx512_mask_rndscale_pd_128,           // llvm.x86.avx512.mask.rndscale.pd.128
+    x86_avx512_mask_rndscale_pd_256,           // llvm.x86.avx512.mask.rndscale.pd.256
+    x86_avx512_mask_rndscale_pd_512,           // llvm.x86.avx512.mask.rndscale.pd.512
+    x86_avx512_mask_rndscale_ps_128,           // llvm.x86.avx512.mask.rndscale.ps.128
+    x86_avx512_mask_rndscale_ps_256,           // llvm.x86.avx512.mask.rndscale.ps.256
+    x86_avx512_mask_rndscale_ps_512,           // llvm.x86.avx512.mask.rndscale.ps.512
+    x86_avx512_mask_rndscale_sd,               // llvm.x86.avx512.mask.rndscale.sd
+    x86_avx512_mask_rndscale_ss,               // llvm.x86.avx512.mask.rndscale.ss
+    x86_avx512_mask_scalef_pd_128,             // llvm.x86.avx512.mask.scalef.pd.128
+    x86_avx512_mask_scalef_pd_256,             // llvm.x86.avx512.mask.scalef.pd.256
+    x86_avx512_mask_scalef_pd_512,             // llvm.x86.avx512.mask.scalef.pd.512
+    x86_avx512_mask_scalef_ps_128,             // llvm.x86.avx512.mask.scalef.ps.128
+    x86_avx512_mask_scalef_ps_256,             // llvm.x86.avx512.mask.scalef.ps.256
+    x86_avx512_mask_scalef_ps_512,             // llvm.x86.avx512.mask.scalef.ps.512
+    x86_avx512_mask_scalef_sd,                 // llvm.x86.avx512.mask.scalef.sd
+    x86_avx512_mask_scalef_ss,                 // llvm.x86.avx512.mask.scalef.ss
+    x86_avx512_mask_scatter_dpd_512,           // llvm.x86.avx512.mask.scatter.dpd.512
+    x86_avx512_mask_scatter_dpi_512,           // llvm.x86.avx512.mask.scatter.dpi.512
+    x86_avx512_mask_scatter_dpq_512,           // llvm.x86.avx512.mask.scatter.dpq.512
+    x86_avx512_mask_scatter_dps_512,           // llvm.x86.avx512.mask.scatter.dps.512
+    x86_avx512_mask_scatter_qpd_512,           // llvm.x86.avx512.mask.scatter.qpd.512
+    x86_avx512_mask_scatter_qpi_512,           // llvm.x86.avx512.mask.scatter.qpi.512
+    x86_avx512_mask_scatter_qpq_512,           // llvm.x86.avx512.mask.scatter.qpq.512
+    x86_avx512_mask_scatter_qps_512,           // llvm.x86.avx512.mask.scatter.qps.512
+    x86_avx512_mask_scatterdiv2_df,            // llvm.x86.avx512.mask.scatterdiv2.df
+    x86_avx512_mask_scatterdiv2_di,            // llvm.x86.avx512.mask.scatterdiv2.di
+    x86_avx512_mask_scatterdiv4_df,            // llvm.x86.avx512.mask.scatterdiv4.df
+    x86_avx512_mask_scatterdiv4_di,            // llvm.x86.avx512.mask.scatterdiv4.di
+    x86_avx512_mask_scatterdiv4_sf,            // llvm.x86.avx512.mask.scatterdiv4.sf
+    x86_avx512_mask_scatterdiv4_si,            // llvm.x86.avx512.mask.scatterdiv4.si
+    x86_avx512_mask_scatterdiv8_sf,            // llvm.x86.avx512.mask.scatterdiv8.sf
+    x86_avx512_mask_scatterdiv8_si,            // llvm.x86.avx512.mask.scatterdiv8.si
+    x86_avx512_mask_scattersiv2_df,            // llvm.x86.avx512.mask.scattersiv2.df
+    x86_avx512_mask_scattersiv2_di,            // llvm.x86.avx512.mask.scattersiv2.di
+    x86_avx512_mask_scattersiv4_df,            // llvm.x86.avx512.mask.scattersiv4.df
+    x86_avx512_mask_scattersiv4_di,            // llvm.x86.avx512.mask.scattersiv4.di
+    x86_avx512_mask_scattersiv4_sf,            // llvm.x86.avx512.mask.scattersiv4.sf
+    x86_avx512_mask_scattersiv4_si,            // llvm.x86.avx512.mask.scattersiv4.si
+    x86_avx512_mask_scattersiv8_sf,            // llvm.x86.avx512.mask.scattersiv8.sf
+    x86_avx512_mask_scattersiv8_si,            // llvm.x86.avx512.mask.scattersiv8.si
+    x86_avx512_mask_sqrt_sd,                   // llvm.x86.avx512.mask.sqrt.sd
+    x86_avx512_mask_sqrt_ss,                   // llvm.x86.avx512.mask.sqrt.ss
+    x86_avx512_mask_sub_sd_round,              // llvm.x86.avx512.mask.sub.sd.round
+    x86_avx512_mask_sub_ss_round,              // llvm.x86.avx512.mask.sub.ss.round
+    x86_avx512_mask_vcvtph2ps_512,             // llvm.x86.avx512.mask.vcvtph2ps.512
+    x86_avx512_mask_vcvtps2ph_128,             // llvm.x86.avx512.mask.vcvtps2ph.128
+    x86_avx512_mask_vcvtps2ph_256,             // llvm.x86.avx512.mask.vcvtps2ph.256
+    x86_avx512_mask_vcvtps2ph_512,             // llvm.x86.avx512.mask.vcvtps2ph.512
+    x86_avx512_maskz_fixupimm_pd_128,          // llvm.x86.avx512.maskz.fixupimm.pd.128
+    x86_avx512_maskz_fixupimm_pd_256,          // llvm.x86.avx512.maskz.fixupimm.pd.256
+    x86_avx512_maskz_fixupimm_pd_512,          // llvm.x86.avx512.maskz.fixupimm.pd.512
+    x86_avx512_maskz_fixupimm_ps_128,          // llvm.x86.avx512.maskz.fixupimm.ps.128
+    x86_avx512_maskz_fixupimm_ps_256,          // llvm.x86.avx512.maskz.fixupimm.ps.256
+    x86_avx512_maskz_fixupimm_ps_512,          // llvm.x86.avx512.maskz.fixupimm.ps.512
+    x86_avx512_maskz_fixupimm_sd,              // llvm.x86.avx512.maskz.fixupimm.sd
+    x86_avx512_maskz_fixupimm_ss,              // llvm.x86.avx512.maskz.fixupimm.ss
+    x86_avx512_max_pd_512,                     // llvm.x86.avx512.max.pd.512
+    x86_avx512_max_ps_512,                     // llvm.x86.avx512.max.ps.512
+    x86_avx512_min_pd_512,                     // llvm.x86.avx512.min.pd.512
+    x86_avx512_min_ps_512,                     // llvm.x86.avx512.min.ps.512
+    x86_avx512_mul_pd_512,                     // llvm.x86.avx512.mul.pd.512
+    x86_avx512_mul_ps_512,                     // llvm.x86.avx512.mul.ps.512
+    x86_avx512_packssdw_512,                   // llvm.x86.avx512.packssdw.512
+    x86_avx512_packsswb_512,                   // llvm.x86.avx512.packsswb.512
+    x86_avx512_packusdw_512,                   // llvm.x86.avx512.packusdw.512
+    x86_avx512_packuswb_512,                   // llvm.x86.avx512.packuswb.512
+    x86_avx512_pavg_b_512,                     // llvm.x86.avx512.pavg.b.512
+    x86_avx512_pavg_w_512,                     // llvm.x86.avx512.pavg.w.512
+    x86_avx512_permvar_df_256,                 // llvm.x86.avx512.permvar.df.256
+    x86_avx512_permvar_df_512,                 // llvm.x86.avx512.permvar.df.512
+    x86_avx512_permvar_di_256,                 // llvm.x86.avx512.permvar.di.256
+    x86_avx512_permvar_di_512,                 // llvm.x86.avx512.permvar.di.512
+    x86_avx512_permvar_hi_128,                 // llvm.x86.avx512.permvar.hi.128
+    x86_avx512_permvar_hi_256,                 // llvm.x86.avx512.permvar.hi.256
+    x86_avx512_permvar_hi_512,                 // llvm.x86.avx512.permvar.hi.512
+    x86_avx512_permvar_qi_128,                 // llvm.x86.avx512.permvar.qi.128
+    x86_avx512_permvar_qi_256,                 // llvm.x86.avx512.permvar.qi.256
+    x86_avx512_permvar_qi_512,                 // llvm.x86.avx512.permvar.qi.512
+    x86_avx512_permvar_sf_512,                 // llvm.x86.avx512.permvar.sf.512
+    x86_avx512_permvar_si_512,                 // llvm.x86.avx512.permvar.si.512
+    x86_avx512_pmaddubs_w_512,                 // llvm.x86.avx512.pmaddubs.w.512
+    x86_avx512_pmaddw_d_512,                   // llvm.x86.avx512.pmaddw.d.512
+    x86_avx512_pmul_hr_sw_512,                 // llvm.x86.avx512.pmul.hr.sw.512
+    x86_avx512_pmulh_w_512,                    // llvm.x86.avx512.pmulh.w.512
+    x86_avx512_pmulhu_w_512,                   // llvm.x86.avx512.pmulhu.w.512
+    x86_avx512_pmultishift_qb_128,             // llvm.x86.avx512.pmultishift.qb.128
+    x86_avx512_pmultishift_qb_256,             // llvm.x86.avx512.pmultishift.qb.256
+    x86_avx512_pmultishift_qb_512,             // llvm.x86.avx512.pmultishift.qb.512
+    x86_avx512_psad_bw_512,                    // llvm.x86.avx512.psad.bw.512
+    x86_avx512_pshuf_b_512,                    // llvm.x86.avx512.pshuf.b.512
+    x86_avx512_psll_d_512,                     // llvm.x86.avx512.psll.d.512
+    x86_avx512_psll_q_512,                     // llvm.x86.avx512.psll.q.512
+    x86_avx512_psll_w_512,                     // llvm.x86.avx512.psll.w.512
+    x86_avx512_pslli_d_512,                    // llvm.x86.avx512.pslli.d.512
+    x86_avx512_pslli_q_512,                    // llvm.x86.avx512.pslli.q.512
+    x86_avx512_pslli_w_512,                    // llvm.x86.avx512.pslli.w.512
+    x86_avx512_psllv_d_512,                    // llvm.x86.avx512.psllv.d.512
+    x86_avx512_psllv_q_512,                    // llvm.x86.avx512.psllv.q.512
+    x86_avx512_psllv_w_128,                    // llvm.x86.avx512.psllv.w.128
+    x86_avx512_psllv_w_256,                    // llvm.x86.avx512.psllv.w.256
+    x86_avx512_psllv_w_512,                    // llvm.x86.avx512.psllv.w.512
+    x86_avx512_psra_d_512,                     // llvm.x86.avx512.psra.d.512
+    x86_avx512_psra_q_128,                     // llvm.x86.avx512.psra.q.128
+    x86_avx512_psra_q_256,                     // llvm.x86.avx512.psra.q.256
+    x86_avx512_psra_q_512,                     // llvm.x86.avx512.psra.q.512
+    x86_avx512_psra_w_512,                     // llvm.x86.avx512.psra.w.512
+    x86_avx512_psrai_d_512,                    // llvm.x86.avx512.psrai.d.512
+    x86_avx512_psrai_q_128,                    // llvm.x86.avx512.psrai.q.128
+    x86_avx512_psrai_q_256,                    // llvm.x86.avx512.psrai.q.256
+    x86_avx512_psrai_q_512,                    // llvm.x86.avx512.psrai.q.512
+    x86_avx512_psrai_w_512,                    // llvm.x86.avx512.psrai.w.512
+    x86_avx512_psrav_d_512,                    // llvm.x86.avx512.psrav.d.512
+    x86_avx512_psrav_q_128,                    // llvm.x86.avx512.psrav.q.128
+    x86_avx512_psrav_q_256,                    // llvm.x86.avx512.psrav.q.256
+    x86_avx512_psrav_q_512,                    // llvm.x86.avx512.psrav.q.512
+    x86_avx512_psrav_w_128,                    // llvm.x86.avx512.psrav.w.128
+    x86_avx512_psrav_w_256,                    // llvm.x86.avx512.psrav.w.256
+    x86_avx512_psrav_w_512,                    // llvm.x86.avx512.psrav.w.512
+    x86_avx512_psrl_d_512,                     // llvm.x86.avx512.psrl.d.512
+    x86_avx512_psrl_q_512,                     // llvm.x86.avx512.psrl.q.512
+    x86_avx512_psrl_w_512,                     // llvm.x86.avx512.psrl.w.512
+    x86_avx512_psrli_d_512,                    // llvm.x86.avx512.psrli.d.512
+    x86_avx512_psrli_q_512,                    // llvm.x86.avx512.psrli.q.512
+    x86_avx512_psrli_w_512,                    // llvm.x86.avx512.psrli.w.512
+    x86_avx512_psrlv_d_512,                    // llvm.x86.avx512.psrlv.d.512
+    x86_avx512_psrlv_q_512,                    // llvm.x86.avx512.psrlv.q.512
+    x86_avx512_psrlv_w_128,                    // llvm.x86.avx512.psrlv.w.128
+    x86_avx512_psrlv_w_256,                    // llvm.x86.avx512.psrlv.w.256
+    x86_avx512_psrlv_w_512,                    // llvm.x86.avx512.psrlv.w.512
+    x86_avx512_pternlog_d_128,                 // llvm.x86.avx512.pternlog.d.128
+    x86_avx512_pternlog_d_256,                 // llvm.x86.avx512.pternlog.d.256
+    x86_avx512_pternlog_d_512,                 // llvm.x86.avx512.pternlog.d.512
+    x86_avx512_pternlog_q_128,                 // llvm.x86.avx512.pternlog.q.128
+    x86_avx512_pternlog_q_256,                 // llvm.x86.avx512.pternlog.q.256
+    x86_avx512_pternlog_q_512,                 // llvm.x86.avx512.pternlog.q.512
+    x86_avx512_rcp14_pd_128,                   // llvm.x86.avx512.rcp14.pd.128
+    x86_avx512_rcp14_pd_256,                   // llvm.x86.avx512.rcp14.pd.256
+    x86_avx512_rcp14_pd_512,                   // llvm.x86.avx512.rcp14.pd.512
+    x86_avx512_rcp14_ps_128,                   // llvm.x86.avx512.rcp14.ps.128
+    x86_avx512_rcp14_ps_256,                   // llvm.x86.avx512.rcp14.ps.256
+    x86_avx512_rcp14_ps_512,                   // llvm.x86.avx512.rcp14.ps.512
+    x86_avx512_rcp14_sd,                       // llvm.x86.avx512.rcp14.sd
+    x86_avx512_rcp14_ss,                       // llvm.x86.avx512.rcp14.ss
+    x86_avx512_rcp28_pd,                       // llvm.x86.avx512.rcp28.pd
+    x86_avx512_rcp28_ps,                       // llvm.x86.avx512.rcp28.ps
+    x86_avx512_rcp28_sd,                       // llvm.x86.avx512.rcp28.sd
+    x86_avx512_rcp28_ss,                       // llvm.x86.avx512.rcp28.ss
+    x86_avx512_rsqrt14_pd_128,                 // llvm.x86.avx512.rsqrt14.pd.128
+    x86_avx512_rsqrt14_pd_256,                 // llvm.x86.avx512.rsqrt14.pd.256
+    x86_avx512_rsqrt14_pd_512,                 // llvm.x86.avx512.rsqrt14.pd.512
+    x86_avx512_rsqrt14_ps_128,                 // llvm.x86.avx512.rsqrt14.ps.128
+    x86_avx512_rsqrt14_ps_256,                 // llvm.x86.avx512.rsqrt14.ps.256
+    x86_avx512_rsqrt14_ps_512,                 // llvm.x86.avx512.rsqrt14.ps.512
+    x86_avx512_rsqrt14_sd,                     // llvm.x86.avx512.rsqrt14.sd
+    x86_avx512_rsqrt14_ss,                     // llvm.x86.avx512.rsqrt14.ss
+    x86_avx512_rsqrt28_pd,                     // llvm.x86.avx512.rsqrt28.pd
+    x86_avx512_rsqrt28_ps,                     // llvm.x86.avx512.rsqrt28.ps
+    x86_avx512_rsqrt28_sd,                     // llvm.x86.avx512.rsqrt28.sd
+    x86_avx512_rsqrt28_ss,                     // llvm.x86.avx512.rsqrt28.ss
+    x86_avx512_scatter_dpd_512,                // llvm.x86.avx512.scatter.dpd.512
+    x86_avx512_scatter_dpi_512,                // llvm.x86.avx512.scatter.dpi.512
+    x86_avx512_scatter_dpq_512,                // llvm.x86.avx512.scatter.dpq.512
+    x86_avx512_scatter_dps_512,                // llvm.x86.avx512.scatter.dps.512
+    x86_avx512_scatter_qpd_512,                // llvm.x86.avx512.scatter.qpd.512
+    x86_avx512_scatter_qpi_512,                // llvm.x86.avx512.scatter.qpi.512
+    x86_avx512_scatter_qpq_512,                // llvm.x86.avx512.scatter.qpq.512
+    x86_avx512_scatter_qps_512,                // llvm.x86.avx512.scatter.qps.512
+    x86_avx512_scatterdiv2_df,                 // llvm.x86.avx512.scatterdiv2.df
+    x86_avx512_scatterdiv2_di,                 // llvm.x86.avx512.scatterdiv2.di
+    x86_avx512_scatterdiv4_df,                 // llvm.x86.avx512.scatterdiv4.df
+    x86_avx512_scatterdiv4_di,                 // llvm.x86.avx512.scatterdiv4.di
+    x86_avx512_scatterdiv4_sf,                 // llvm.x86.avx512.scatterdiv4.sf
+    x86_avx512_scatterdiv4_si,                 // llvm.x86.avx512.scatterdiv4.si
+    x86_avx512_scatterdiv8_sf,                 // llvm.x86.avx512.scatterdiv8.sf
+    x86_avx512_scatterdiv8_si,                 // llvm.x86.avx512.scatterdiv8.si
+    x86_avx512_scatterpf_dpd_512,              // llvm.x86.avx512.scatterpf.dpd.512
+    x86_avx512_scatterpf_dps_512,              // llvm.x86.avx512.scatterpf.dps.512
+    x86_avx512_scatterpf_qpd_512,              // llvm.x86.avx512.scatterpf.qpd.512
+    x86_avx512_scatterpf_qps_512,              // llvm.x86.avx512.scatterpf.qps.512
+    x86_avx512_scattersiv2_df,                 // llvm.x86.avx512.scattersiv2.df
+    x86_avx512_scattersiv2_di,                 // llvm.x86.avx512.scattersiv2.di
+    x86_avx512_scattersiv4_df,                 // llvm.x86.avx512.scattersiv4.df
+    x86_avx512_scattersiv4_di,                 // llvm.x86.avx512.scattersiv4.di
+    x86_avx512_scattersiv4_sf,                 // llvm.x86.avx512.scattersiv4.sf
+    x86_avx512_scattersiv4_si,                 // llvm.x86.avx512.scattersiv4.si
+    x86_avx512_scattersiv8_sf,                 // llvm.x86.avx512.scattersiv8.sf
+    x86_avx512_scattersiv8_si,                 // llvm.x86.avx512.scattersiv8.si
+    x86_avx512_sitofp_round,                   // llvm.x86.avx512.sitofp.round
+    x86_avx512_sqrt_pd_512,                    // llvm.x86.avx512.sqrt.pd.512
+    x86_avx512_sqrt_ps_512,                    // llvm.x86.avx512.sqrt.ps.512
+    x86_avx512_sub_pd_512,                     // llvm.x86.avx512.sub.pd.512
+    x86_avx512_sub_ps_512,                     // llvm.x86.avx512.sub.ps.512
+    x86_avx512_uitofp_round,                   // llvm.x86.avx512.uitofp.round
+    x86_avx512_vcomi_sd,                       // llvm.x86.avx512.vcomi.sd
+    x86_avx512_vcomi_ss,                       // llvm.x86.avx512.vcomi.ss
+    x86_avx512_vcvtsd2si32,                    // llvm.x86.avx512.vcvtsd2si32
+    x86_avx512_vcvtsd2si64,                    // llvm.x86.avx512.vcvtsd2si64
+    x86_avx512_vcvtsd2usi32,                   // llvm.x86.avx512.vcvtsd2usi32
+    x86_avx512_vcvtsd2usi64,                   // llvm.x86.avx512.vcvtsd2usi64
+    x86_avx512_vcvtss2si32,                    // llvm.x86.avx512.vcvtss2si32
+    x86_avx512_vcvtss2si64,                    // llvm.x86.avx512.vcvtss2si64
+    x86_avx512_vcvtss2usi32,                   // llvm.x86.avx512.vcvtss2usi32
+    x86_avx512_vcvtss2usi64,                   // llvm.x86.avx512.vcvtss2usi64
+    x86_avx512_vfmadd_f32,                     // llvm.x86.avx512.vfmadd.f32
+    x86_avx512_vfmadd_f64,                     // llvm.x86.avx512.vfmadd.f64
+    x86_avx512_vfmadd_pd_512,                  // llvm.x86.avx512.vfmadd.pd.512
+    x86_avx512_vfmadd_ps_512,                  // llvm.x86.avx512.vfmadd.ps.512
+    x86_avx512_vfmaddsub_pd_512,               // llvm.x86.avx512.vfmaddsub.pd.512
+    x86_avx512_vfmaddsub_ps_512,               // llvm.x86.avx512.vfmaddsub.ps.512
+    x86_avx512_vp2intersect_d_128,             // llvm.x86.avx512.vp2intersect.d.128
+    x86_avx512_vp2intersect_d_256,             // llvm.x86.avx512.vp2intersect.d.256
+    x86_avx512_vp2intersect_d_512,             // llvm.x86.avx512.vp2intersect.d.512
+    x86_avx512_vp2intersect_q_128,             // llvm.x86.avx512.vp2intersect.q.128
+    x86_avx512_vp2intersect_q_256,             // llvm.x86.avx512.vp2intersect.q.256
+    x86_avx512_vp2intersect_q_512,             // llvm.x86.avx512.vp2intersect.q.512
+    x86_avx512_vpdpbusd_128,                   // llvm.x86.avx512.vpdpbusd.128
+    x86_avx512_vpdpbusd_256,                   // llvm.x86.avx512.vpdpbusd.256
+    x86_avx512_vpdpbusd_512,                   // llvm.x86.avx512.vpdpbusd.512
+    x86_avx512_vpdpbusds_128,                  // llvm.x86.avx512.vpdpbusds.128
+    x86_avx512_vpdpbusds_256,                  // llvm.x86.avx512.vpdpbusds.256
+    x86_avx512_vpdpbusds_512,                  // llvm.x86.avx512.vpdpbusds.512
+    x86_avx512_vpdpwssd_128,                   // llvm.x86.avx512.vpdpwssd.128
+    x86_avx512_vpdpwssd_256,                   // llvm.x86.avx512.vpdpwssd.256
+    x86_avx512_vpdpwssd_512,                   // llvm.x86.avx512.vpdpwssd.512
+    x86_avx512_vpdpwssds_128,                  // llvm.x86.avx512.vpdpwssds.128
+    x86_avx512_vpdpwssds_256,                  // llvm.x86.avx512.vpdpwssds.256
+    x86_avx512_vpdpwssds_512,                  // llvm.x86.avx512.vpdpwssds.512
+    x86_avx512_vpermi2var_d_128,               // llvm.x86.avx512.vpermi2var.d.128
+    x86_avx512_vpermi2var_d_256,               // llvm.x86.avx512.vpermi2var.d.256
+    x86_avx512_vpermi2var_d_512,               // llvm.x86.avx512.vpermi2var.d.512
+    x86_avx512_vpermi2var_hi_128,              // llvm.x86.avx512.vpermi2var.hi.128
+    x86_avx512_vpermi2var_hi_256,              // llvm.x86.avx512.vpermi2var.hi.256
+    x86_avx512_vpermi2var_hi_512,              // llvm.x86.avx512.vpermi2var.hi.512
+    x86_avx512_vpermi2var_pd_128,              // llvm.x86.avx512.vpermi2var.pd.128
+    x86_avx512_vpermi2var_pd_256,              // llvm.x86.avx512.vpermi2var.pd.256
+    x86_avx512_vpermi2var_pd_512,              // llvm.x86.avx512.vpermi2var.pd.512
+    x86_avx512_vpermi2var_ps_128,              // llvm.x86.avx512.vpermi2var.ps.128
+    x86_avx512_vpermi2var_ps_256,              // llvm.x86.avx512.vpermi2var.ps.256
+    x86_avx512_vpermi2var_ps_512,              // llvm.x86.avx512.vpermi2var.ps.512
+    x86_avx512_vpermi2var_q_128,               // llvm.x86.avx512.vpermi2var.q.128
+    x86_avx512_vpermi2var_q_256,               // llvm.x86.avx512.vpermi2var.q.256
+    x86_avx512_vpermi2var_q_512,               // llvm.x86.avx512.vpermi2var.q.512
+    x86_avx512_vpermi2var_qi_128,              // llvm.x86.avx512.vpermi2var.qi.128
+    x86_avx512_vpermi2var_qi_256,              // llvm.x86.avx512.vpermi2var.qi.256
+    x86_avx512_vpermi2var_qi_512,              // llvm.x86.avx512.vpermi2var.qi.512
+    x86_avx512_vpermilvar_pd_512,              // llvm.x86.avx512.vpermilvar.pd.512
+    x86_avx512_vpermilvar_ps_512,              // llvm.x86.avx512.vpermilvar.ps.512
+    x86_avx512_vpmadd52h_uq_128,               // llvm.x86.avx512.vpmadd52h.uq.128
+    x86_avx512_vpmadd52h_uq_256,               // llvm.x86.avx512.vpmadd52h.uq.256
+    x86_avx512_vpmadd52h_uq_512,               // llvm.x86.avx512.vpmadd52h.uq.512
+    x86_avx512_vpmadd52l_uq_128,               // llvm.x86.avx512.vpmadd52l.uq.128
+    x86_avx512_vpmadd52l_uq_256,               // llvm.x86.avx512.vpmadd52l.uq.256
+    x86_avx512_vpmadd52l_uq_512,               // llvm.x86.avx512.vpmadd52l.uq.512
+    x86_avx512_vpshufbitqmb_128,               // llvm.x86.avx512.vpshufbitqmb.128
+    x86_avx512_vpshufbitqmb_256,               // llvm.x86.avx512.vpshufbitqmb.256
+    x86_avx512_vpshufbitqmb_512,               // llvm.x86.avx512.vpshufbitqmb.512
+    x86_avx512bf16_cvtne2ps2bf16_128,          // llvm.x86.avx512bf16.cvtne2ps2bf16.128
+    x86_avx512bf16_cvtne2ps2bf16_256,          // llvm.x86.avx512bf16.cvtne2ps2bf16.256
+    x86_avx512bf16_cvtne2ps2bf16_512,          // llvm.x86.avx512bf16.cvtne2ps2bf16.512
+    x86_avx512bf16_cvtneps2bf16_256,           // llvm.x86.avx512bf16.cvtneps2bf16.256
+    x86_avx512bf16_cvtneps2bf16_512,           // llvm.x86.avx512bf16.cvtneps2bf16.512
+    x86_avx512bf16_dpbf16ps_128,               // llvm.x86.avx512bf16.dpbf16ps.128
+    x86_avx512bf16_dpbf16ps_256,               // llvm.x86.avx512bf16.dpbf16ps.256
+    x86_avx512bf16_dpbf16ps_512,               // llvm.x86.avx512bf16.dpbf16ps.512
+    x86_avx512bf16_mask_cvtneps2bf16_128,      // llvm.x86.avx512bf16.mask.cvtneps2bf16.128
+    x86_bmi_bextr_32,                          // llvm.x86.bmi.bextr.32
+    x86_bmi_bextr_64,                          // llvm.x86.bmi.bextr.64
+    x86_bmi_bzhi_32,                           // llvm.x86.bmi.bzhi.32
+    x86_bmi_bzhi_64,                           // llvm.x86.bmi.bzhi.64
+    x86_bmi_pdep_32,                           // llvm.x86.bmi.pdep.32
+    x86_bmi_pdep_64,                           // llvm.x86.bmi.pdep.64
+    x86_bmi_pext_32,                           // llvm.x86.bmi.pext.32
+    x86_bmi_pext_64,                           // llvm.x86.bmi.pext.64
+    x86_cldemote,                              // llvm.x86.cldemote
+    x86_clflushopt,                            // llvm.x86.clflushopt
+    x86_clrssbsy,                              // llvm.x86.clrssbsy
+    x86_clui,                                  // llvm.x86.clui
+    x86_clwb,                                  // llvm.x86.clwb
+    x86_clzero,                                // llvm.x86.clzero
+    x86_directstore32,                         // llvm.x86.directstore32
+    x86_directstore64,                         // llvm.x86.directstore64
+    x86_encodekey128,                          // llvm.x86.encodekey128
+    x86_encodekey256,                          // llvm.x86.encodekey256
+    x86_enqcmd,                                // llvm.x86.enqcmd
+    x86_enqcmds,                               // llvm.x86.enqcmds
+    x86_flags_read_u32,                        // llvm.x86.flags.read.u32
+    x86_flags_read_u64,                        // llvm.x86.flags.read.u64
+    x86_flags_write_u32,                       // llvm.x86.flags.write.u32
+    x86_flags_write_u64,                       // llvm.x86.flags.write.u64
+    x86_fma_vfmaddsub_pd,                      // llvm.x86.fma.vfmaddsub.pd
+    x86_fma_vfmaddsub_pd_256,                  // llvm.x86.fma.vfmaddsub.pd.256
+    x86_fma_vfmaddsub_ps,                      // llvm.x86.fma.vfmaddsub.ps
+    x86_fma_vfmaddsub_ps_256,                  // llvm.x86.fma.vfmaddsub.ps.256
+    x86_fxrstor,                               // llvm.x86.fxrstor
+    x86_fxrstor64,                             // llvm.x86.fxrstor64
+    x86_fxsave,                                // llvm.x86.fxsave
+    x86_fxsave64,                              // llvm.x86.fxsave64
+    x86_incsspd,                               // llvm.x86.incsspd
+    x86_incsspq,                               // llvm.x86.incsspq
+    x86_int,                                   // llvm.x86.int
+    x86_invpcid,                               // llvm.x86.invpcid
+    x86_ldtilecfg,                             // llvm.x86.ldtilecfg
+    x86_llwpcb,                                // llvm.x86.llwpcb
+    x86_loadiwkey,                             // llvm.x86.loadiwkey
+    x86_lwpins32,                              // llvm.x86.lwpins32
+    x86_lwpins64,                              // llvm.x86.lwpins64
+    x86_lwpval32,                              // llvm.x86.lwpval32
+    x86_lwpval64,                              // llvm.x86.lwpval64
+    x86_mmx_emms,                              // llvm.x86.mmx.emms
+    x86_mmx_femms,                             // llvm.x86.mmx.femms
+    x86_mmx_maskmovq,                          // llvm.x86.mmx.maskmovq
+    x86_mmx_movnt_dq,                          // llvm.x86.mmx.movnt.dq
+    x86_mmx_packssdw,                          // llvm.x86.mmx.packssdw
+    x86_mmx_packsswb,                          // llvm.x86.mmx.packsswb
+    x86_mmx_packuswb,                          // llvm.x86.mmx.packuswb
+    x86_mmx_padd_b,                            // llvm.x86.mmx.padd.b
+    x86_mmx_padd_d,                            // llvm.x86.mmx.padd.d
+    x86_mmx_padd_q,                            // llvm.x86.mmx.padd.q
+    x86_mmx_padd_w,                            // llvm.x86.mmx.padd.w
+    x86_mmx_padds_b,                           // llvm.x86.mmx.padds.b
+    x86_mmx_padds_w,                           // llvm.x86.mmx.padds.w
+    x86_mmx_paddus_b,                          // llvm.x86.mmx.paddus.b
+    x86_mmx_paddus_w,                          // llvm.x86.mmx.paddus.w
+    x86_mmx_palignr_b,                         // llvm.x86.mmx.palignr.b
+    x86_mmx_pand,                              // llvm.x86.mmx.pand
+    x86_mmx_pandn,                             // llvm.x86.mmx.pandn
+    x86_mmx_pavg_b,                            // llvm.x86.mmx.pavg.b
+    x86_mmx_pavg_w,                            // llvm.x86.mmx.pavg.w
+    x86_mmx_pcmpeq_b,                          // llvm.x86.mmx.pcmpeq.b
+    x86_mmx_pcmpeq_d,                          // llvm.x86.mmx.pcmpeq.d
+    x86_mmx_pcmpeq_w,                          // llvm.x86.mmx.pcmpeq.w
+    x86_mmx_pcmpgt_b,                          // llvm.x86.mmx.pcmpgt.b
+    x86_mmx_pcmpgt_d,                          // llvm.x86.mmx.pcmpgt.d
+    x86_mmx_pcmpgt_w,                          // llvm.x86.mmx.pcmpgt.w
+    x86_mmx_pextr_w,                           // llvm.x86.mmx.pextr.w
+    x86_mmx_pinsr_w,                           // llvm.x86.mmx.pinsr.w
+    x86_mmx_pmadd_wd,                          // llvm.x86.mmx.pmadd.wd
+    x86_mmx_pmaxs_w,                           // llvm.x86.mmx.pmaxs.w
+    x86_mmx_pmaxu_b,                           // llvm.x86.mmx.pmaxu.b
+    x86_mmx_pmins_w,                           // llvm.x86.mmx.pmins.w
+    x86_mmx_pminu_b,                           // llvm.x86.mmx.pminu.b
+    x86_mmx_pmovmskb,                          // llvm.x86.mmx.pmovmskb
+    x86_mmx_pmulh_w,                           // llvm.x86.mmx.pmulh.w
+    x86_mmx_pmulhu_w,                          // llvm.x86.mmx.pmulhu.w
+    x86_mmx_pmull_w,                           // llvm.x86.mmx.pmull.w
+    x86_mmx_pmulu_dq,                          // llvm.x86.mmx.pmulu.dq
+    x86_mmx_por,                               // llvm.x86.mmx.por
+    x86_mmx_psad_bw,                           // llvm.x86.mmx.psad.bw
+    x86_mmx_psll_d,                            // llvm.x86.mmx.psll.d
+    x86_mmx_psll_q,                            // llvm.x86.mmx.psll.q
+    x86_mmx_psll_w,                            // llvm.x86.mmx.psll.w
+    x86_mmx_pslli_d,                           // llvm.x86.mmx.pslli.d
+    x86_mmx_pslli_q,                           // llvm.x86.mmx.pslli.q
+    x86_mmx_pslli_w,                           // llvm.x86.mmx.pslli.w
+    x86_mmx_psra_d,                            // llvm.x86.mmx.psra.d
+    x86_mmx_psra_w,                            // llvm.x86.mmx.psra.w
+    x86_mmx_psrai_d,                           // llvm.x86.mmx.psrai.d
+    x86_mmx_psrai_w,                           // llvm.x86.mmx.psrai.w
+    x86_mmx_psrl_d,                            // llvm.x86.mmx.psrl.d
+    x86_mmx_psrl_q,                            // llvm.x86.mmx.psrl.q
+    x86_mmx_psrl_w,                            // llvm.x86.mmx.psrl.w
+    x86_mmx_psrli_d,                           // llvm.x86.mmx.psrli.d
+    x86_mmx_psrli_q,                           // llvm.x86.mmx.psrli.q
+    x86_mmx_psrli_w,                           // llvm.x86.mmx.psrli.w
+    x86_mmx_psub_b,                            // llvm.x86.mmx.psub.b
+    x86_mmx_psub_d,                            // llvm.x86.mmx.psub.d
+    x86_mmx_psub_q,                            // llvm.x86.mmx.psub.q
+    x86_mmx_psub_w,                            // llvm.x86.mmx.psub.w
+    x86_mmx_psubs_b,                           // llvm.x86.mmx.psubs.b
+    x86_mmx_psubs_w,                           // llvm.x86.mmx.psubs.w
+    x86_mmx_psubus_b,                          // llvm.x86.mmx.psubus.b
+    x86_mmx_psubus_w,                          // llvm.x86.mmx.psubus.w
+    x86_mmx_punpckhbw,                         // llvm.x86.mmx.punpckhbw
+    x86_mmx_punpckhdq,                         // llvm.x86.mmx.punpckhdq
+    x86_mmx_punpckhwd,                         // llvm.x86.mmx.punpckhwd
+    x86_mmx_punpcklbw,                         // llvm.x86.mmx.punpcklbw
+    x86_mmx_punpckldq,                         // llvm.x86.mmx.punpckldq
+    x86_mmx_punpcklwd,                         // llvm.x86.mmx.punpcklwd
+    x86_mmx_pxor,                              // llvm.x86.mmx.pxor
+    x86_monitorx,                              // llvm.x86.monitorx
+    x86_movdir64b,                             // llvm.x86.movdir64b
+    x86_mwaitx,                                // llvm.x86.mwaitx
+    x86_pclmulqdq,                             // llvm.x86.pclmulqdq
+    x86_pclmulqdq_256,                         // llvm.x86.pclmulqdq.256
+    x86_pclmulqdq_512,                         // llvm.x86.pclmulqdq.512
+    x86_ptwrite32,                             // llvm.x86.ptwrite32
+    x86_ptwrite64,                             // llvm.x86.ptwrite64
+    x86_rdfsbase_32,                           // llvm.x86.rdfsbase.32
+    x86_rdfsbase_64,                           // llvm.x86.rdfsbase.64
+    x86_rdgsbase_32,                           // llvm.x86.rdgsbase.32
+    x86_rdgsbase_64,                           // llvm.x86.rdgsbase.64
+    x86_rdpid,                                 // llvm.x86.rdpid
+    x86_rdpkru,                                // llvm.x86.rdpkru
+    x86_rdpmc,                                 // llvm.x86.rdpmc
+    x86_rdrand_16,                             // llvm.x86.rdrand.16
+    x86_rdrand_32,                             // llvm.x86.rdrand.32
+    x86_rdrand_64,                             // llvm.x86.rdrand.64
+    x86_rdseed_16,                             // llvm.x86.rdseed.16
+    x86_rdseed_32,                             // llvm.x86.rdseed.32
+    x86_rdseed_64,                             // llvm.x86.rdseed.64
+    x86_rdsspd,                                // llvm.x86.rdsspd
+    x86_rdsspq,                                // llvm.x86.rdsspq
+    x86_rdtsc,                                 // llvm.x86.rdtsc
+    x86_rdtscp,                                // llvm.x86.rdtscp
+    x86_rstorssp,                              // llvm.x86.rstorssp
+    x86_saveprevssp,                           // llvm.x86.saveprevssp
+    x86_seh_ehguard,                           // llvm.x86.seh.ehguard
+    x86_seh_ehregnode,                         // llvm.x86.seh.ehregnode
+    x86_seh_lsda,                              // llvm.x86.seh.lsda
+    x86_senduipi,                              // llvm.x86.senduipi
+    x86_serialize,                             // llvm.x86.serialize
+    x86_setssbsy,                              // llvm.x86.setssbsy
+    x86_sha1msg1,                              // llvm.x86.sha1msg1
+    x86_sha1msg2,                              // llvm.x86.sha1msg2
+    x86_sha1nexte,                             // llvm.x86.sha1nexte
+    x86_sha1rnds4,                             // llvm.x86.sha1rnds4
+    x86_sha256msg1,                            // llvm.x86.sha256msg1
+    x86_sha256msg2,                            // llvm.x86.sha256msg2
+    x86_sha256rnds2,                           // llvm.x86.sha256rnds2
+    x86_slwpcb,                                // llvm.x86.slwpcb
+    x86_sse_cmp_ps,                            // llvm.x86.sse.cmp.ps
+    x86_sse_cmp_ss,                            // llvm.x86.sse.cmp.ss
+    x86_sse_comieq_ss,                         // llvm.x86.sse.comieq.ss
+    x86_sse_comige_ss,                         // llvm.x86.sse.comige.ss
+    x86_sse_comigt_ss,                         // llvm.x86.sse.comigt.ss
+    x86_sse_comile_ss,                         // llvm.x86.sse.comile.ss
+    x86_sse_comilt_ss,                         // llvm.x86.sse.comilt.ss
+    x86_sse_comineq_ss,                        // llvm.x86.sse.comineq.ss
+    x86_sse_cvtpd2pi,                          // llvm.x86.sse.cvtpd2pi
+    x86_sse_cvtpi2pd,                          // llvm.x86.sse.cvtpi2pd
+    x86_sse_cvtpi2ps,                          // llvm.x86.sse.cvtpi2ps
+    x86_sse_cvtps2pi,                          // llvm.x86.sse.cvtps2pi
+    x86_sse_cvtss2si,                          // llvm.x86.sse.cvtss2si
+    x86_sse_cvtss2si64,                        // llvm.x86.sse.cvtss2si64
+    x86_sse_cvttpd2pi,                         // llvm.x86.sse.cvttpd2pi
+    x86_sse_cvttps2pi,                         // llvm.x86.sse.cvttps2pi
+    x86_sse_cvttss2si,                         // llvm.x86.sse.cvttss2si
+    x86_sse_cvttss2si64,                       // llvm.x86.sse.cvttss2si64
+    x86_sse_ldmxcsr,                           // llvm.x86.sse.ldmxcsr
+    x86_sse_max_ps,                            // llvm.x86.sse.max.ps
+    x86_sse_max_ss,                            // llvm.x86.sse.max.ss
+    x86_sse_min_ps,                            // llvm.x86.sse.min.ps
+    x86_sse_min_ss,                            // llvm.x86.sse.min.ss
+    x86_sse_movmsk_ps,                         // llvm.x86.sse.movmsk.ps
+    x86_sse_pshuf_w,                           // llvm.x86.sse.pshuf.w
+    x86_sse_rcp_ps,                            // llvm.x86.sse.rcp.ps
+    x86_sse_rcp_ss,                            // llvm.x86.sse.rcp.ss
+    x86_sse_rsqrt_ps,                          // llvm.x86.sse.rsqrt.ps
+    x86_sse_rsqrt_ss,                          // llvm.x86.sse.rsqrt.ss
+    x86_sse_sfence,                            // llvm.x86.sse.sfence
+    x86_sse_stmxcsr,                           // llvm.x86.sse.stmxcsr
+    x86_sse_ucomieq_ss,                        // llvm.x86.sse.ucomieq.ss
+    x86_sse_ucomige_ss,                        // llvm.x86.sse.ucomige.ss
+    x86_sse_ucomigt_ss,                        // llvm.x86.sse.ucomigt.ss
+    x86_sse_ucomile_ss,                        // llvm.x86.sse.ucomile.ss
+    x86_sse_ucomilt_ss,                        // llvm.x86.sse.ucomilt.ss
+    x86_sse_ucomineq_ss,                       // llvm.x86.sse.ucomineq.ss
+    x86_sse2_clflush,                          // llvm.x86.sse2.clflush
+    x86_sse2_cmp_pd,                           // llvm.x86.sse2.cmp.pd
+    x86_sse2_cmp_sd,                           // llvm.x86.sse2.cmp.sd
+    x86_sse2_comieq_sd,                        // llvm.x86.sse2.comieq.sd
+    x86_sse2_comige_sd,                        // llvm.x86.sse2.comige.sd
+    x86_sse2_comigt_sd,                        // llvm.x86.sse2.comigt.sd
+    x86_sse2_comile_sd,                        // llvm.x86.sse2.comile.sd
+    x86_sse2_comilt_sd,                        // llvm.x86.sse2.comilt.sd
+    x86_sse2_comineq_sd,                       // llvm.x86.sse2.comineq.sd
+    x86_sse2_cvtpd2dq,                         // llvm.x86.sse2.cvtpd2dq
+    x86_sse2_cvtpd2ps,                         // llvm.x86.sse2.cvtpd2ps
+    x86_sse2_cvtps2dq,                         // llvm.x86.sse2.cvtps2dq
+    x86_sse2_cvtsd2si,                         // llvm.x86.sse2.cvtsd2si
+    x86_sse2_cvtsd2si64,                       // llvm.x86.sse2.cvtsd2si64
+    x86_sse2_cvtsd2ss,                         // llvm.x86.sse2.cvtsd2ss
+    x86_sse2_cvttpd2dq,                        // llvm.x86.sse2.cvttpd2dq
+    x86_sse2_cvttps2dq,                        // llvm.x86.sse2.cvttps2dq
+    x86_sse2_cvttsd2si,                        // llvm.x86.sse2.cvttsd2si
+    x86_sse2_cvttsd2si64,                      // llvm.x86.sse2.cvttsd2si64
+    x86_sse2_lfence,                           // llvm.x86.sse2.lfence
+    x86_sse2_maskmov_dqu,                      // llvm.x86.sse2.maskmov.dqu
+    x86_sse2_max_pd,                           // llvm.x86.sse2.max.pd
+    x86_sse2_max_sd,                           // llvm.x86.sse2.max.sd
+    x86_sse2_mfence,                           // llvm.x86.sse2.mfence
+    x86_sse2_min_pd,                           // llvm.x86.sse2.min.pd
+    x86_sse2_min_sd,                           // llvm.x86.sse2.min.sd
+    x86_sse2_movmsk_pd,                        // llvm.x86.sse2.movmsk.pd
+    x86_sse2_packssdw_128,                     // llvm.x86.sse2.packssdw.128
+    x86_sse2_packsswb_128,                     // llvm.x86.sse2.packsswb.128
+    x86_sse2_packuswb_128,                     // llvm.x86.sse2.packuswb.128
+    x86_sse2_pause,                            // llvm.x86.sse2.pause
+    x86_sse2_pavg_b,                           // llvm.x86.sse2.pavg.b
+    x86_sse2_pavg_w,                           // llvm.x86.sse2.pavg.w
+    x86_sse2_pmadd_wd,                         // llvm.x86.sse2.pmadd.wd
+    x86_sse2_pmovmskb_128,                     // llvm.x86.sse2.pmovmskb.128
+    x86_sse2_pmulh_w,                          // llvm.x86.sse2.pmulh.w
+    x86_sse2_pmulhu_w,                         // llvm.x86.sse2.pmulhu.w
+    x86_sse2_psad_bw,                          // llvm.x86.sse2.psad.bw
+    x86_sse2_psll_d,                           // llvm.x86.sse2.psll.d
+    x86_sse2_psll_q,                           // llvm.x86.sse2.psll.q
+    x86_sse2_psll_w,                           // llvm.x86.sse2.psll.w
+    x86_sse2_pslli_d,                          // llvm.x86.sse2.pslli.d
+    x86_sse2_pslli_q,                          // llvm.x86.sse2.pslli.q
+    x86_sse2_pslli_w,                          // llvm.x86.sse2.pslli.w
+    x86_sse2_psra_d,                           // llvm.x86.sse2.psra.d
+    x86_sse2_psra_w,                           // llvm.x86.sse2.psra.w
+    x86_sse2_psrai_d,                          // llvm.x86.sse2.psrai.d
+    x86_sse2_psrai_w,                          // llvm.x86.sse2.psrai.w
+    x86_sse2_psrl_d,                           // llvm.x86.sse2.psrl.d
+    x86_sse2_psrl_q,                           // llvm.x86.sse2.psrl.q
+    x86_sse2_psrl_w,                           // llvm.x86.sse2.psrl.w
+    x86_sse2_psrli_d,                          // llvm.x86.sse2.psrli.d
+    x86_sse2_psrli_q,                          // llvm.x86.sse2.psrli.q
+    x86_sse2_psrli_w,                          // llvm.x86.sse2.psrli.w
+    x86_sse2_ucomieq_sd,                       // llvm.x86.sse2.ucomieq.sd
+    x86_sse2_ucomige_sd,                       // llvm.x86.sse2.ucomige.sd
+    x86_sse2_ucomigt_sd,                       // llvm.x86.sse2.ucomigt.sd
+    x86_sse2_ucomile_sd,                       // llvm.x86.sse2.ucomile.sd
+    x86_sse2_ucomilt_sd,                       // llvm.x86.sse2.ucomilt.sd
+    x86_sse2_ucomineq_sd,                      // llvm.x86.sse2.ucomineq.sd
+    x86_sse3_addsub_pd,                        // llvm.x86.sse3.addsub.pd
+    x86_sse3_addsub_ps,                        // llvm.x86.sse3.addsub.ps
+    x86_sse3_hadd_pd,                          // llvm.x86.sse3.hadd.pd
+    x86_sse3_hadd_ps,                          // llvm.x86.sse3.hadd.ps
+    x86_sse3_hsub_pd,                          // llvm.x86.sse3.hsub.pd
+    x86_sse3_hsub_ps,                          // llvm.x86.sse3.hsub.ps
+    x86_sse3_ldu_dq,                           // llvm.x86.sse3.ldu.dq
+    x86_sse3_monitor,                          // llvm.x86.sse3.monitor
+    x86_sse3_mwait,                            // llvm.x86.sse3.mwait
+    x86_sse41_blendvpd,                        // llvm.x86.sse41.blendvpd
+    x86_sse41_blendvps,                        // llvm.x86.sse41.blendvps
+    x86_sse41_dppd,                            // llvm.x86.sse41.dppd
+    x86_sse41_dpps,                            // llvm.x86.sse41.dpps
+    x86_sse41_insertps,                        // llvm.x86.sse41.insertps
+    x86_sse41_mpsadbw,                         // llvm.x86.sse41.mpsadbw
+    x86_sse41_packusdw,                        // llvm.x86.sse41.packusdw
+    x86_sse41_pblendvb,                        // llvm.x86.sse41.pblendvb
+    x86_sse41_phminposuw,                      // llvm.x86.sse41.phminposuw
+    x86_sse41_ptestc,                          // llvm.x86.sse41.ptestc
+    x86_sse41_ptestnzc,                        // llvm.x86.sse41.ptestnzc
+    x86_sse41_ptestz,                          // llvm.x86.sse41.ptestz
+    x86_sse41_round_pd,                        // llvm.x86.sse41.round.pd
+    x86_sse41_round_ps,                        // llvm.x86.sse41.round.ps
+    x86_sse41_round_sd,                        // llvm.x86.sse41.round.sd
+    x86_sse41_round_ss,                        // llvm.x86.sse41.round.ss
+    x86_sse42_crc32_32_16,                     // llvm.x86.sse42.crc32.32.16
+    x86_sse42_crc32_32_32,                     // llvm.x86.sse42.crc32.32.32
+    x86_sse42_crc32_32_8,                      // llvm.x86.sse42.crc32.32.8
+    x86_sse42_crc32_64_64,                     // llvm.x86.sse42.crc32.64.64
+    x86_sse42_pcmpestri128,                    // llvm.x86.sse42.pcmpestri128
+    x86_sse42_pcmpestria128,                   // llvm.x86.sse42.pcmpestria128
+    x86_sse42_pcmpestric128,                   // llvm.x86.sse42.pcmpestric128
+    x86_sse42_pcmpestrio128,                   // llvm.x86.sse42.pcmpestrio128
+    x86_sse42_pcmpestris128,                   // llvm.x86.sse42.pcmpestris128
+    x86_sse42_pcmpestriz128,                   // llvm.x86.sse42.pcmpestriz128
+    x86_sse42_pcmpestrm128,                    // llvm.x86.sse42.pcmpestrm128
+    x86_sse42_pcmpistri128,                    // llvm.x86.sse42.pcmpistri128
+    x86_sse42_pcmpistria128,                   // llvm.x86.sse42.pcmpistria128
+    x86_sse42_pcmpistric128,                   // llvm.x86.sse42.pcmpistric128
+    x86_sse42_pcmpistrio128,                   // llvm.x86.sse42.pcmpistrio128
+    x86_sse42_pcmpistris128,                   // llvm.x86.sse42.pcmpistris128
+    x86_sse42_pcmpistriz128,                   // llvm.x86.sse42.pcmpistriz128
+    x86_sse42_pcmpistrm128,                    // llvm.x86.sse42.pcmpistrm128
+    x86_sse4a_extrq,                           // llvm.x86.sse4a.extrq
+    x86_sse4a_extrqi,                          // llvm.x86.sse4a.extrqi
+    x86_sse4a_insertq,                         // llvm.x86.sse4a.insertq
+    x86_sse4a_insertqi,                        // llvm.x86.sse4a.insertqi
+    x86_ssse3_pabs_b,                          // llvm.x86.ssse3.pabs.b
+    x86_ssse3_pabs_d,                          // llvm.x86.ssse3.pabs.d
+    x86_ssse3_pabs_w,                          // llvm.x86.ssse3.pabs.w
+    x86_ssse3_phadd_d,                         // llvm.x86.ssse3.phadd.d
+    x86_ssse3_phadd_d_128,                     // llvm.x86.ssse3.phadd.d.128
+    x86_ssse3_phadd_sw,                        // llvm.x86.ssse3.phadd.sw
+    x86_ssse3_phadd_sw_128,                    // llvm.x86.ssse3.phadd.sw.128
+    x86_ssse3_phadd_w,                         // llvm.x86.ssse3.phadd.w
+    x86_ssse3_phadd_w_128,                     // llvm.x86.ssse3.phadd.w.128
+    x86_ssse3_phsub_d,                         // llvm.x86.ssse3.phsub.d
+    x86_ssse3_phsub_d_128,                     // llvm.x86.ssse3.phsub.d.128
+    x86_ssse3_phsub_sw,                        // llvm.x86.ssse3.phsub.sw
+    x86_ssse3_phsub_sw_128,                    // llvm.x86.ssse3.phsub.sw.128
+    x86_ssse3_phsub_w,                         // llvm.x86.ssse3.phsub.w
+    x86_ssse3_phsub_w_128,                     // llvm.x86.ssse3.phsub.w.128
+    x86_ssse3_pmadd_ub_sw,                     // llvm.x86.ssse3.pmadd.ub.sw
+    x86_ssse3_pmadd_ub_sw_128,                 // llvm.x86.ssse3.pmadd.ub.sw.128
+    x86_ssse3_pmul_hr_sw,                      // llvm.x86.ssse3.pmul.hr.sw
+    x86_ssse3_pmul_hr_sw_128,                  // llvm.x86.ssse3.pmul.hr.sw.128
+    x86_ssse3_pshuf_b,                         // llvm.x86.ssse3.pshuf.b
+    x86_ssse3_pshuf_b_128,                     // llvm.x86.ssse3.pshuf.b.128
+    x86_ssse3_psign_b,                         // llvm.x86.ssse3.psign.b
+    x86_ssse3_psign_b_128,                     // llvm.x86.ssse3.psign.b.128
+    x86_ssse3_psign_d,                         // llvm.x86.ssse3.psign.d
+    x86_ssse3_psign_d_128,                     // llvm.x86.ssse3.psign.d.128
+    x86_ssse3_psign_w,                         // llvm.x86.ssse3.psign.w
+    x86_ssse3_psign_w_128,                     // llvm.x86.ssse3.psign.w.128
+    x86_sttilecfg,                             // llvm.x86.sttilecfg
+    x86_stui,                                  // llvm.x86.stui
+    x86_subborrow_32,                          // llvm.x86.subborrow.32
+    x86_subborrow_64,                          // llvm.x86.subborrow.64
+    x86_tbm_bextri_u32,                        // llvm.x86.tbm.bextri.u32
+    x86_tbm_bextri_u64,                        // llvm.x86.tbm.bextri.u64
+    x86_tdpbf16ps,                             // llvm.x86.tdpbf16ps
+    x86_tdpbssd,                               // llvm.x86.tdpbssd
+    x86_tdpbssd_internal,                      // llvm.x86.tdpbssd.internal
+    x86_tdpbsud,                               // llvm.x86.tdpbsud
+    x86_tdpbusd,                               // llvm.x86.tdpbusd
+    x86_tdpbuud,                               // llvm.x86.tdpbuud
+    x86_testui,                                // llvm.x86.testui
+    x86_tileloadd64,                           // llvm.x86.tileloadd64
+    x86_tileloadd64_internal,                  // llvm.x86.tileloadd64.internal
+    x86_tileloaddt164,                         // llvm.x86.tileloaddt164
+    x86_tilerelease,                           // llvm.x86.tilerelease
+    x86_tilestored64,                          // llvm.x86.tilestored64
+    x86_tilestored64_internal,                 // llvm.x86.tilestored64.internal
+    x86_tilezero,                              // llvm.x86.tilezero
+    x86_tilezero_internal,                     // llvm.x86.tilezero.internal
+    x86_tpause,                                // llvm.x86.tpause
+    x86_umonitor,                              // llvm.x86.umonitor
+    x86_umwait,                                // llvm.x86.umwait
+    x86_vcvtps2ph_128,                         // llvm.x86.vcvtps2ph.128
+    x86_vcvtps2ph_256,                         // llvm.x86.vcvtps2ph.256
+    x86_vgf2p8affineinvqb_128,                 // llvm.x86.vgf2p8affineinvqb.128
+    x86_vgf2p8affineinvqb_256,                 // llvm.x86.vgf2p8affineinvqb.256
+    x86_vgf2p8affineinvqb_512,                 // llvm.x86.vgf2p8affineinvqb.512
+    x86_vgf2p8affineqb_128,                    // llvm.x86.vgf2p8affineqb.128
+    x86_vgf2p8affineqb_256,                    // llvm.x86.vgf2p8affineqb.256
+    x86_vgf2p8affineqb_512,                    // llvm.x86.vgf2p8affineqb.512
+    x86_vgf2p8mulb_128,                        // llvm.x86.vgf2p8mulb.128
+    x86_vgf2p8mulb_256,                        // llvm.x86.vgf2p8mulb.256
+    x86_vgf2p8mulb_512,                        // llvm.x86.vgf2p8mulb.512
+    x86_wbinvd,                                // llvm.x86.wbinvd
+    x86_wbnoinvd,                              // llvm.x86.wbnoinvd
+    x86_wrfsbase_32,                           // llvm.x86.wrfsbase.32
+    x86_wrfsbase_64,                           // llvm.x86.wrfsbase.64
+    x86_wrgsbase_32,                           // llvm.x86.wrgsbase.32
+    x86_wrgsbase_64,                           // llvm.x86.wrgsbase.64
+    x86_wrpkru,                                // llvm.x86.wrpkru
+    x86_wrssd,                                 // llvm.x86.wrssd
+    x86_wrssq,                                 // llvm.x86.wrssq
+    x86_wrussd,                                // llvm.x86.wrussd
+    x86_wrussq,                                // llvm.x86.wrussq
+    x86_xabort,                                // llvm.x86.xabort
+    x86_xbegin,                                // llvm.x86.xbegin
+    x86_xend,                                  // llvm.x86.xend
+    x86_xgetbv,                                // llvm.x86.xgetbv
+    x86_xop_vfrcz_pd,                          // llvm.x86.xop.vfrcz.pd
+    x86_xop_vfrcz_pd_256,                      // llvm.x86.xop.vfrcz.pd.256
+    x86_xop_vfrcz_ps,                          // llvm.x86.xop.vfrcz.ps
+    x86_xop_vfrcz_ps_256,                      // llvm.x86.xop.vfrcz.ps.256
+    x86_xop_vfrcz_sd,                          // llvm.x86.xop.vfrcz.sd
+    x86_xop_vfrcz_ss,                          // llvm.x86.xop.vfrcz.ss
+    x86_xop_vpermil2pd,                        // llvm.x86.xop.vpermil2pd
+    x86_xop_vpermil2pd_256,                    // llvm.x86.xop.vpermil2pd.256
+    x86_xop_vpermil2ps,                        // llvm.x86.xop.vpermil2ps
+    x86_xop_vpermil2ps_256,                    // llvm.x86.xop.vpermil2ps.256
+    x86_xop_vphaddbd,                          // llvm.x86.xop.vphaddbd
+    x86_xop_vphaddbq,                          // llvm.x86.xop.vphaddbq
+    x86_xop_vphaddbw,                          // llvm.x86.xop.vphaddbw
+    x86_xop_vphadddq,                          // llvm.x86.xop.vphadddq
+    x86_xop_vphaddubd,                         // llvm.x86.xop.vphaddubd
+    x86_xop_vphaddubq,                         // llvm.x86.xop.vphaddubq
+    x86_xop_vphaddubw,                         // llvm.x86.xop.vphaddubw
+    x86_xop_vphaddudq,                         // llvm.x86.xop.vphaddudq
+    x86_xop_vphadduwd,                         // llvm.x86.xop.vphadduwd
+    x86_xop_vphadduwq,                         // llvm.x86.xop.vphadduwq
+    x86_xop_vphaddwd,                          // llvm.x86.xop.vphaddwd
+    x86_xop_vphaddwq,                          // llvm.x86.xop.vphaddwq
+    x86_xop_vphsubbw,                          // llvm.x86.xop.vphsubbw
+    x86_xop_vphsubdq,                          // llvm.x86.xop.vphsubdq
+    x86_xop_vphsubwd,                          // llvm.x86.xop.vphsubwd
+    x86_xop_vpmacsdd,                          // llvm.x86.xop.vpmacsdd
+    x86_xop_vpmacsdqh,                         // llvm.x86.xop.vpmacsdqh
+    x86_xop_vpmacsdql,                         // llvm.x86.xop.vpmacsdql
+    x86_xop_vpmacssdd,                         // llvm.x86.xop.vpmacssdd
+    x86_xop_vpmacssdqh,                        // llvm.x86.xop.vpmacssdqh
+    x86_xop_vpmacssdql,                        // llvm.x86.xop.vpmacssdql
+    x86_xop_vpmacsswd,                         // llvm.x86.xop.vpmacsswd
+    x86_xop_vpmacssww,                         // llvm.x86.xop.vpmacssww
+    x86_xop_vpmacswd,                          // llvm.x86.xop.vpmacswd
+    x86_xop_vpmacsww,                          // llvm.x86.xop.vpmacsww
+    x86_xop_vpmadcsswd,                        // llvm.x86.xop.vpmadcsswd
+    x86_xop_vpmadcswd,                         // llvm.x86.xop.vpmadcswd
+    x86_xop_vpperm,                            // llvm.x86.xop.vpperm
+    x86_xop_vpshab,                            // llvm.x86.xop.vpshab
+    x86_xop_vpshad,                            // llvm.x86.xop.vpshad
+    x86_xop_vpshaq,                            // llvm.x86.xop.vpshaq
+    x86_xop_vpshaw,                            // llvm.x86.xop.vpshaw
+    x86_xop_vpshlb,                            // llvm.x86.xop.vpshlb
+    x86_xop_vpshld,                            // llvm.x86.xop.vpshld
+    x86_xop_vpshlq,                            // llvm.x86.xop.vpshlq
+    x86_xop_vpshlw,                            // llvm.x86.xop.vpshlw
+    x86_xresldtrk,                             // llvm.x86.xresldtrk
+    x86_xrstor,                                // llvm.x86.xrstor
+    x86_xrstor64,                              // llvm.x86.xrstor64
+    x86_xrstors,                               // llvm.x86.xrstors
+    x86_xrstors64,                             // llvm.x86.xrstors64
+    x86_xsave,                                 // llvm.x86.xsave
+    x86_xsave64,                               // llvm.x86.xsave64
+    x86_xsavec,                                // llvm.x86.xsavec
+    x86_xsavec64,                              // llvm.x86.xsavec64
+    x86_xsaveopt,                              // llvm.x86.xsaveopt
+    x86_xsaveopt64,                            // llvm.x86.xsaveopt64
+    x86_xsaves,                                // llvm.x86.xsaves
+    x86_xsaves64,                              // llvm.x86.xsaves64
+    x86_xsetbv,                                // llvm.x86.xsetbv
+    x86_xsusldtrk,                             // llvm.x86.xsusldtrk
+    x86_xtest,                                 // llvm.x86.xtest
+}; // enum
+} // namespace Intrinsic
+} // namespace llvm
+
+#endif
diff --git a/linux-x64/clang/include/llvm/IR/IntrinsicsX86.td b/linux-x64/clang/include/llvm/IR/IntrinsicsX86.td
index 236d312..bba1213 100644
--- a/linux-x64/clang/include/llvm/IR/IntrinsicsX86.td
+++ b/linux-x64/clang/include/llvm/IR/IntrinsicsX86.td
@@ -13,7 +13,7 @@
 //===----------------------------------------------------------------------===//
 // Interrupt traps
 let TargetPrefix = "x86" in {  // All intrinsics start with "llvm.x86.".
-  def int_x86_int : Intrinsic<[], [llvm_i8_ty], [ImmArg<0>]>;
+  def int_x86_int : Intrinsic<[], [llvm_i8_ty], [ImmArg<ArgIndex<0>>]>;
 }
 
 //===----------------------------------------------------------------------===//
@@ -203,12 +203,12 @@
 let TargetPrefix = "x86" in {  // All intrinsics start with "llvm.x86.".
   def int_x86_sse_cmp_ss : GCCBuiltin<"__builtin_ia32_cmpss">,
               Intrinsic<[llvm_v4f32_ty], [llvm_v4f32_ty,
-                         llvm_v4f32_ty, llvm_i8_ty], [IntrNoMem, ImmArg<2>]>;
+                         llvm_v4f32_ty, llvm_i8_ty], [IntrNoMem, ImmArg<ArgIndex<2>>]>;
   // NOTE: This comparison intrinsic is not used by clang as long as the
   //       distinction in signaling behaviour is not implemented.
   def int_x86_sse_cmp_ps :
               Intrinsic<[llvm_v4f32_ty], [llvm_v4f32_ty,
-                         llvm_v4f32_ty, llvm_i8_ty], [IntrNoMem, ImmArg<2>]>;
+                         llvm_v4f32_ty, llvm_i8_ty], [IntrNoMem, ImmArg<ArgIndex<2>>]>;
   def int_x86_sse_comieq_ss : GCCBuiltin<"__builtin_ia32_comieq">,
               Intrinsic<[llvm_i32_ty], [llvm_v4f32_ty,
                          llvm_v4f32_ty], [IntrNoMem]>;
@@ -283,11 +283,10 @@
                          IntrHasSideEffects]>;
   def int_x86_sse_ldmxcsr :
               Intrinsic<[], [llvm_ptr_ty],
-                        [IntrReadMem, IntrArgMemOnly, IntrHasSideEffects,
-                         // FIXME: LDMXCSR does not actualy write to memory,
-                         // but Fast and DAG Isel both use writing to memory
-                         // as a proxy for having side effects.
-                         IntrWriteMem]>;
+                         // FIXME: LDMXCSR does not actually write to memory,
+                         // but intrinsic properties are generated incorrectly
+                         // for IntrReadMem+IntrHasSideEffects.
+                        [/*IntrReadMem, IntrArgMemOnly,*/ IntrHasSideEffects]>;
 }
 
 // Misc.
@@ -319,12 +318,12 @@
 let TargetPrefix = "x86" in {  // All intrinsics start with "llvm.x86.".
   def int_x86_sse2_cmp_sd : GCCBuiltin<"__builtin_ia32_cmpsd">,
               Intrinsic<[llvm_v2f64_ty], [llvm_v2f64_ty,
-                         llvm_v2f64_ty, llvm_i8_ty], [IntrNoMem, ImmArg<2>]>;
+                         llvm_v2f64_ty, llvm_i8_ty], [IntrNoMem, ImmArg<ArgIndex<2>>]>;
   // NOTE: This comparison intrinsic is not used by clang as long as the
   //       distinction in signaling behaviour is not implemented.
   def int_x86_sse2_cmp_pd :
               Intrinsic<[llvm_v2f64_ty], [llvm_v2f64_ty,
-                         llvm_v2f64_ty, llvm_i8_ty], [IntrNoMem, ImmArg<2>]>;
+                         llvm_v2f64_ty, llvm_i8_ty], [IntrNoMem, ImmArg<ArgIndex<2>>]>;
   def int_x86_sse2_comieq_sd : GCCBuiltin<"__builtin_ia32_comisdeq">,
               Intrinsic<[llvm_i32_ty], [llvm_v2f64_ty,
                          llvm_v2f64_ty], [IntrNoMem]>;
@@ -618,7 +617,7 @@
                          llvm_v16i8_ty], [IntrNoMem]>;
   def int_x86_sse_pshuf_w           : GCCBuiltin<"__builtin_ia32_pshufw">,
               Intrinsic<[llvm_x86mmx_ty], [llvm_x86mmx_ty, llvm_i8_ty],
-                         [IntrNoMem, ImmArg<1>]>;
+                         [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 }
 
 // Sign ops
@@ -664,16 +663,16 @@
 let TargetPrefix = "x86" in {  // All intrinsics start with "llvm.x86.".
   def int_x86_sse41_round_ss        : GCCBuiltin<"__builtin_ia32_roundss">,
               Intrinsic<[llvm_v4f32_ty], [llvm_v4f32_ty, llvm_v4f32_ty,
-                         llvm_i32_ty], [IntrNoMem, ImmArg<2>]>;
+                         llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<2>>]>;
   def int_x86_sse41_round_ps        : GCCBuiltin<"__builtin_ia32_roundps">,
               Intrinsic<[llvm_v4f32_ty], [llvm_v4f32_ty,
-                         llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+                         llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
   def int_x86_sse41_round_sd        : GCCBuiltin<"__builtin_ia32_roundsd">,
               Intrinsic<[llvm_v2f64_ty], [llvm_v2f64_ty, llvm_v2f64_ty,
-                         llvm_i32_ty], [IntrNoMem, ImmArg<2>]>;
+                         llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<2>>]>;
   def int_x86_sse41_round_pd        : GCCBuiltin<"__builtin_ia32_roundpd">,
               Intrinsic<[llvm_v2f64_ty], [llvm_v2f64_ty,
-                         llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+                         llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 }
 
 // Vector min element
@@ -736,20 +735,20 @@
   def int_x86_aesni_aeskeygenassist :
               GCCBuiltin<"__builtin_ia32_aeskeygenassist128">,
               Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_i8_ty],
-                        [IntrNoMem, ImmArg<1>]>;
+                        [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 }
 
 // PCLMUL instructions
 let TargetPrefix = "x86" in { // All intrinsics start with "llvm.x86.".
   def int_x86_pclmulqdq : GCCBuiltin<"__builtin_ia32_pclmulqdq128">,
           Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_v2i64_ty, llvm_i8_ty],
-                    [IntrNoMem, ImmArg<2>]>;
+                    [IntrNoMem, ImmArg<ArgIndex<2>>]>;
   def int_x86_pclmulqdq_256 : GCCBuiltin<"__builtin_ia32_pclmulqdq256">,
           Intrinsic<[llvm_v4i64_ty], [llvm_v4i64_ty, llvm_v4i64_ty, llvm_i8_ty],
-                    [IntrNoMem, ImmArg<2>]>;
+                    [IntrNoMem, ImmArg<ArgIndex<2>>]>;
   def int_x86_pclmulqdq_512 : GCCBuiltin<"__builtin_ia32_pclmulqdq512">,
           Intrinsic<[llvm_v8i64_ty], [llvm_v8i64_ty, llvm_v8i64_ty, llvm_i8_ty],
-                    [IntrNoMem, ImmArg<2>]>;
+                    [IntrNoMem, ImmArg<ArgIndex<2>>]>;
 }
 
 // Vector pack
@@ -763,7 +762,7 @@
 let TargetPrefix = "x86" in {  // All intrinsics start with "llvm.x86.".
   def int_x86_sse41_insertps       : GCCBuiltin<"__builtin_ia32_insertps128">,
           Intrinsic<[llvm_v4f32_ty], [llvm_v4f32_ty, llvm_v4f32_ty, llvm_i8_ty],
-                    [IntrNoMem, ImmArg<2>]>;
+                    [IntrNoMem, ImmArg<ArgIndex<2>>]>;
 }
 
 // Vector blend
@@ -783,17 +782,17 @@
 let TargetPrefix = "x86" in {  // All intrinsics start with "llvm.x86.".
   def int_x86_sse41_dppd            : GCCBuiltin<"__builtin_ia32_dppd">,
           Intrinsic<[llvm_v2f64_ty], [llvm_v2f64_ty, llvm_v2f64_ty, llvm_i8_ty],
-                    [IntrNoMem, Commutative, ImmArg<2>]>;
+                    [IntrNoMem, Commutative, ImmArg<ArgIndex<2>>]>;
   def int_x86_sse41_dpps            : GCCBuiltin<"__builtin_ia32_dpps">,
           Intrinsic<[llvm_v4f32_ty], [llvm_v4f32_ty, llvm_v4f32_ty, llvm_i8_ty],
-                    [IntrNoMem, Commutative, ImmArg<2>]>;
+                    [IntrNoMem, Commutative, ImmArg<ArgIndex<2>>]>;
 }
 
 // Vector sum of absolute differences
 let TargetPrefix = "x86" in {  // All intrinsics start with "llvm.x86.".
   def int_x86_sse41_mpsadbw         : GCCBuiltin<"__builtin_ia32_mpsadbw128">,
           Intrinsic<[llvm_v8i16_ty], [llvm_v16i8_ty, llvm_v16i8_ty,llvm_i8_ty],
-                    [IntrNoMem, Commutative, ImmArg<2>]>;
+                    [IntrNoMem, Commutative, ImmArg<ArgIndex<2>>]>;
 }
 
 // Test instruction with bitwise comparison.
@@ -834,66 +833,66 @@
   def int_x86_sse42_pcmpistrm128  : GCCBuiltin<"__builtin_ia32_pcmpistrm128">,
     Intrinsic<[llvm_v16i8_ty],
         [llvm_v16i8_ty, llvm_v16i8_ty, llvm_i8_ty],
-        [IntrNoMem, ImmArg<2>]>;
+        [IntrNoMem, ImmArg<ArgIndex<2>>]>;
   def int_x86_sse42_pcmpistri128  : GCCBuiltin<"__builtin_ia32_pcmpistri128">,
     Intrinsic<[llvm_i32_ty],
         [llvm_v16i8_ty, llvm_v16i8_ty, llvm_i8_ty],
-        [IntrNoMem, ImmArg<2>]>;
+        [IntrNoMem, ImmArg<ArgIndex<2>>]>;
   def int_x86_sse42_pcmpistria128 : GCCBuiltin<"__builtin_ia32_pcmpistria128">,
     Intrinsic<[llvm_i32_ty],
         [llvm_v16i8_ty, llvm_v16i8_ty, llvm_i8_ty],
-        [IntrNoMem, ImmArg<2>]>;
+        [IntrNoMem, ImmArg<ArgIndex<2>>]>;
   def int_x86_sse42_pcmpistric128 : GCCBuiltin<"__builtin_ia32_pcmpistric128">,
     Intrinsic<[llvm_i32_ty],
         [llvm_v16i8_ty, llvm_v16i8_ty, llvm_i8_ty],
-        [IntrNoMem, ImmArg<2>]>;
+        [IntrNoMem, ImmArg<ArgIndex<2>>]>;
   def int_x86_sse42_pcmpistrio128 : GCCBuiltin<"__builtin_ia32_pcmpistrio128">,
     Intrinsic<[llvm_i32_ty],
         [llvm_v16i8_ty, llvm_v16i8_ty, llvm_i8_ty],
-        [IntrNoMem, ImmArg<2>]>;
+        [IntrNoMem, ImmArg<ArgIndex<2>>]>;
   def int_x86_sse42_pcmpistris128 : GCCBuiltin<"__builtin_ia32_pcmpistris128">,
     Intrinsic<[llvm_i32_ty],
         [llvm_v16i8_ty, llvm_v16i8_ty, llvm_i8_ty],
-        [IntrNoMem, ImmArg<2>]>;
+        [IntrNoMem, ImmArg<ArgIndex<2>>]>;
   def int_x86_sse42_pcmpistriz128 : GCCBuiltin<"__builtin_ia32_pcmpistriz128">,
     Intrinsic<[llvm_i32_ty],
         [llvm_v16i8_ty, llvm_v16i8_ty, llvm_i8_ty],
-        [IntrNoMem, ImmArg<2>]>;
+        [IntrNoMem, ImmArg<ArgIndex<2>>]>;
   def int_x86_sse42_pcmpestrm128  : GCCBuiltin<"__builtin_ia32_pcmpestrm128">,
     Intrinsic<[llvm_v16i8_ty],
         [llvm_v16i8_ty, llvm_i32_ty, llvm_v16i8_ty, llvm_i32_ty,
          llvm_i8_ty],
-        [IntrNoMem, ImmArg<4>]>;
+        [IntrNoMem, ImmArg<ArgIndex<4>>]>;
   def int_x86_sse42_pcmpestri128  : GCCBuiltin<"__builtin_ia32_pcmpestri128">,
     Intrinsic<[llvm_i32_ty],
         [llvm_v16i8_ty, llvm_i32_ty, llvm_v16i8_ty, llvm_i32_ty,
          llvm_i8_ty],
-        [IntrNoMem, ImmArg<4>]>;
+        [IntrNoMem, ImmArg<ArgIndex<4>>]>;
   def int_x86_sse42_pcmpestria128 : GCCBuiltin<"__builtin_ia32_pcmpestria128">,
     Intrinsic<[llvm_i32_ty],
         [llvm_v16i8_ty, llvm_i32_ty, llvm_v16i8_ty, llvm_i32_ty,
          llvm_i8_ty],
-        [IntrNoMem, ImmArg<4>]>;
+        [IntrNoMem, ImmArg<ArgIndex<4>>]>;
   def int_x86_sse42_pcmpestric128 : GCCBuiltin<"__builtin_ia32_pcmpestric128">,
     Intrinsic<[llvm_i32_ty],
         [llvm_v16i8_ty, llvm_i32_ty, llvm_v16i8_ty, llvm_i32_ty,
          llvm_i8_ty],
-        [IntrNoMem, ImmArg<4>]>;
+        [IntrNoMem, ImmArg<ArgIndex<4>>]>;
   def int_x86_sse42_pcmpestrio128 : GCCBuiltin<"__builtin_ia32_pcmpestrio128">,
     Intrinsic<[llvm_i32_ty],
         [llvm_v16i8_ty, llvm_i32_ty, llvm_v16i8_ty, llvm_i32_ty,
          llvm_i8_ty],
-        [IntrNoMem, ImmArg<4>]>;
+        [IntrNoMem, ImmArg<ArgIndex<4>>]>;
   def int_x86_sse42_pcmpestris128 : GCCBuiltin<"__builtin_ia32_pcmpestris128">,
     Intrinsic<[llvm_i32_ty],
         [llvm_v16i8_ty, llvm_i32_ty, llvm_v16i8_ty, llvm_i32_ty,
          llvm_i8_ty],
-        [IntrNoMem, ImmArg<4>]>;
+        [IntrNoMem, ImmArg<ArgIndex<4>>]>;
   def int_x86_sse42_pcmpestriz128 : GCCBuiltin<"__builtin_ia32_pcmpestriz128">,
     Intrinsic<[llvm_i32_ty],
         [llvm_v16i8_ty, llvm_i32_ty, llvm_v16i8_ty, llvm_i32_ty,
          llvm_i8_ty],
-        [IntrNoMem, ImmArg<4>]>;
+        [IntrNoMem, ImmArg<ArgIndex<4>>]>;
 }
 
 //===----------------------------------------------------------------------===//
@@ -902,14 +901,14 @@
 let TargetPrefix = "x86" in {  // All intrinsics start with "llvm.x86.".
   def int_x86_sse4a_extrqi : GCCBuiltin<"__builtin_ia32_extrqi">,
     Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_i8_ty, llvm_i8_ty],
-              [IntrNoMem, ImmArg<1>, ImmArg<2>]>;
+              [IntrNoMem, ImmArg<ArgIndex<1>>, ImmArg<ArgIndex<2>>]>;
   def int_x86_sse4a_extrq  : GCCBuiltin<"__builtin_ia32_extrq">,
     Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_v16i8_ty], [IntrNoMem]>;
 
   def int_x86_sse4a_insertqi : GCCBuiltin<"__builtin_ia32_insertqi">,
     Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_v2i64_ty,
                                 llvm_i8_ty, llvm_i8_ty],
-              [IntrNoMem, ImmArg<2>, ImmArg<3>]>;
+              [IntrNoMem, ImmArg<ArgIndex<2>>, ImmArg<ArgIndex<3>>]>;
   def int_x86_sse4a_insertq  : GCCBuiltin<"__builtin_ia32_insertq">,
     Intrinsic<[llvm_v2i64_ty], [llvm_v2i64_ty, llvm_v2i64_ty], [IntrNoMem]>;
 }
@@ -946,10 +945,10 @@
 
   def int_x86_avx_round_pd_256 : GCCBuiltin<"__builtin_ia32_roundpd256">,
         Intrinsic<[llvm_v4f64_ty], [llvm_v4f64_ty,
-                  llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+                  llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
   def int_x86_avx_round_ps_256 : GCCBuiltin<"__builtin_ia32_roundps256">,
         Intrinsic<[llvm_v8f32_ty], [llvm_v8f32_ty,
-                  llvm_i32_ty], [IntrNoMem, ImmArg<1>]>;
+                  llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 }
 
 // Horizontal ops
@@ -1101,33 +1100,33 @@
          GCCBuiltin<"__builtin_ia32_vgf2p8affineinvqb_v16qi">,
           Intrinsic<[llvm_v16i8_ty],
           [llvm_v16i8_ty, llvm_v16i8_ty, llvm_i8_ty],
-          [IntrNoMem, ImmArg<2>]>;
+          [IntrNoMem, ImmArg<ArgIndex<2>>]>;
   def int_x86_vgf2p8affineinvqb_256 :
          GCCBuiltin<"__builtin_ia32_vgf2p8affineinvqb_v32qi">,
           Intrinsic<[llvm_v32i8_ty],
           [llvm_v32i8_ty, llvm_v32i8_ty, llvm_i8_ty],
-          [IntrNoMem, ImmArg<2>]>;
+          [IntrNoMem, ImmArg<ArgIndex<2>>]>;
   def int_x86_vgf2p8affineinvqb_512 :
          GCCBuiltin<"__builtin_ia32_vgf2p8affineinvqb_v64qi">,
           Intrinsic<[llvm_v64i8_ty],
           [llvm_v64i8_ty, llvm_v64i8_ty, llvm_i8_ty],
-          [IntrNoMem, ImmArg<2>]>;
+          [IntrNoMem, ImmArg<ArgIndex<2>>]>;
 
   def int_x86_vgf2p8affineqb_128 :
          GCCBuiltin<"__builtin_ia32_vgf2p8affineqb_v16qi">,
           Intrinsic<[llvm_v16i8_ty],
           [llvm_v16i8_ty, llvm_v16i8_ty, llvm_i8_ty],
-          [IntrNoMem, ImmArg<2>]>;
+          [IntrNoMem, ImmArg<ArgIndex<2>>]>;
   def int_x86_vgf2p8affineqb_256 :
          GCCBuiltin<"__builtin_ia32_vgf2p8affineqb_v32qi">,
           Intrinsic<[llvm_v32i8_ty],
           [llvm_v32i8_ty, llvm_v32i8_ty, llvm_i8_ty],
-          [IntrNoMem, ImmArg<2>]>;
+          [IntrNoMem, ImmArg<ArgIndex<2>>]>;
   def int_x86_vgf2p8affineqb_512 :
          GCCBuiltin<"__builtin_ia32_vgf2p8affineqb_v64qi">,
           Intrinsic<[llvm_v64i8_ty],
           [llvm_v64i8_ty, llvm_v64i8_ty, llvm_i8_ty],
-          [IntrNoMem, ImmArg<2>]>;
+          [IntrNoMem, ImmArg<ArgIndex<2>>]>;
 
   def int_x86_vgf2p8mulb_128     :
          GCCBuiltin<"__builtin_ia32_vgf2p8mulb_v16qi">,
@@ -1161,17 +1160,17 @@
   def int_x86_avx_dp_ps_256 : GCCBuiltin<"__builtin_ia32_dpps256">,
         Intrinsic<[llvm_v8f32_ty], [llvm_v8f32_ty,
                   llvm_v8f32_ty, llvm_i8_ty],
-                  [IntrNoMem, Commutative, ImmArg<2>]>;
+                  [IntrNoMem, Commutative, ImmArg<ArgIndex<2>>]>;
 }
 
 // Vector compare
 let TargetPrefix = "x86" in {  // All intrinsics start with "llvm.x86.".
   def int_x86_avx_cmp_pd_256 :
         Intrinsic<[llvm_v4f64_ty], [llvm_v4f64_ty,
-                  llvm_v4f64_ty, llvm_i8_ty], [IntrNoMem, ImmArg<2>]>;
+                  llvm_v4f64_ty, llvm_i8_ty], [IntrNoMem, ImmArg<ArgIndex<2>>]>;
   def int_x86_avx_cmp_ps_256 :
         Intrinsic<[llvm_v8f32_ty], [llvm_v8f32_ty,
-                  llvm_v8f32_ty, llvm_i8_ty], [IntrNoMem, ImmArg<2>]>;
+                  llvm_v8f32_ty, llvm_i8_ty], [IntrNoMem, ImmArg<ArgIndex<2>>]>;
 }
 
 // Vector convert
@@ -1238,30 +1237,30 @@
 
   def int_x86_avx512_fpclass_pd_128 :
           Intrinsic<[llvm_v2i1_ty], [llvm_v2f64_ty, llvm_i32_ty],
-          [IntrNoMem, ImmArg<1>]>;
+          [IntrNoMem, ImmArg<ArgIndex<1>>]>;
   def int_x86_avx512_fpclass_pd_256 :
           Intrinsic<[llvm_v4i1_ty], [llvm_v4f64_ty, llvm_i32_ty],
-          [IntrNoMem, ImmArg<1>]>;
+          [IntrNoMem, ImmArg<ArgIndex<1>>]>;
   def int_x86_avx512_fpclass_pd_512 :
           Intrinsic<[llvm_v8i1_ty], [llvm_v8f64_ty, llvm_i32_ty],
-          [IntrNoMem, ImmArg<1>]>;
+          [IntrNoMem, ImmArg<ArgIndex<1>>]>;
   def int_x86_avx512_fpclass_ps_128 :
           Intrinsic<[llvm_v4i1_ty], [llvm_v4f32_ty, llvm_i32_ty],
-          [IntrNoMem, ImmArg<1>]>;
+          [IntrNoMem, ImmArg<ArgIndex<1>>]>;
   def int_x86_avx512_fpclass_ps_256 :
           Intrinsic<[llvm_v8i1_ty], [llvm_v8f32_ty, llvm_i32_ty],
-          [IntrNoMem, ImmArg<1>]>;
+          [IntrNoMem, ImmArg<ArgIndex<1>>]>;
   def int_x86_avx512_fpclass_ps_512 :
           Intrinsic<[llvm_v16i1_ty], [llvm_v16f32_ty, llvm_i32_ty],
-          [IntrNoMem, ImmArg<1>]>;
+          [IntrNoMem, ImmArg<ArgIndex<1>>]>;
   def int_x86_avx512_mask_fpclass_sd :
          GCCBuiltin<"__builtin_ia32_fpclasssd_mask">,
           Intrinsic<[llvm_i8_ty], [llvm_v2f64_ty, llvm_i32_ty, llvm_i8_ty],
-          [IntrNoMem, ImmArg<1>]>;
+          [IntrNoMem, ImmArg<ArgIndex<1>>]>;
   def int_x86_avx512_mask_fpclass_ss :
          GCCBuiltin<"__builtin_ia32_fpclassss_mask">,
           Intrinsic<[llvm_i8_ty], [llvm_v4f32_ty, llvm_i32_ty, llvm_i8_ty],
-          [IntrNoMem, ImmArg<1>]>;
+          [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 }
 
 // Vector extract sign mask
@@ -1275,9 +1274,9 @@
 // Vector zero
 let TargetPrefix = "x86" in {  // All intrinsics start with "llvm.x86.".
   def int_x86_avx_vzeroall : GCCBuiltin<"__builtin_ia32_vzeroall">,
-        Intrinsic<[], [], []>;
+        Intrinsic<[], [], [IntrNoMem, IntrHasSideEffects]>;
   def int_x86_avx_vzeroupper : GCCBuiltin<"__builtin_ia32_vzeroupper">,
-        Intrinsic<[], [], []>;
+        Intrinsic<[], [], [IntrNoMem, IntrHasSideEffects]>;
 }
 
 // SIMD load ops
@@ -1707,68 +1706,68 @@
   def int_x86_avx2_gather_d_pd : GCCBuiltin<"__builtin_ia32_gatherd_pd">,
       Intrinsic<[llvm_v2f64_ty],
         [llvm_v2f64_ty, llvm_ptr_ty, llvm_v4i32_ty, llvm_v2f64_ty, llvm_i8_ty],
-        [IntrReadMem, ImmArg<4>]>;
+        [IntrReadMem, ImmArg<ArgIndex<4>>]>;
   def int_x86_avx2_gather_d_pd_256 : GCCBuiltin<"__builtin_ia32_gatherd_pd256">,
       Intrinsic<[llvm_v4f64_ty],
         [llvm_v4f64_ty, llvm_ptr_ty, llvm_v4i32_ty, llvm_v4f64_ty, llvm_i8_ty],
-        [IntrReadMem, ImmArg<4>]>;
+        [IntrReadMem, ImmArg<ArgIndex<4>>]>;
   def int_x86_avx2_gather_q_pd : GCCBuiltin<"__builtin_ia32_gatherq_pd">,
       Intrinsic<[llvm_v2f64_ty],
         [llvm_v2f64_ty, llvm_ptr_ty, llvm_v2i64_ty, llvm_v2f64_ty, llvm_i8_ty],
-        [IntrReadMem, ImmArg<4>]>;
+        [IntrReadMem, ImmArg<ArgIndex<4>>]>;
   def int_x86_avx2_gather_q_pd_256 : GCCBuiltin<"__builtin_ia32_gatherq_pd256">,
       Intrinsic<[llvm_v4f64_ty],
         [llvm_v4f64_ty, llvm_ptr_ty, llvm_v4i64_ty, llvm_v4f64_ty, llvm_i8_ty],
-        [IntrReadMem, ImmArg<4>]>;
+        [IntrReadMem, ImmArg<ArgIndex<4>>]>;
   def int_x86_avx2_gather_d_ps : GCCBuiltin<"__builtin_ia32_gatherd_ps">,
       Intrinsic<[llvm_v4f32_ty],
         [llvm_v4f32_ty, llvm_ptr_ty, llvm_v4i32_ty, llvm_v4f32_ty, llvm_i8_ty],
-        [IntrReadMem, ImmArg<4>]>;
+        [IntrReadMem, ImmArg<ArgIndex<4>>]>;
   def int_x86_avx2_gather_d_ps_256 : GCCBuiltin<"__builtin_ia32_gatherd_ps256">,
       Intrinsic<[llvm_v8f32_ty],
         [llvm_v8f32_ty, llvm_ptr_ty, llvm_v8i32_ty, llvm_v8f32_ty, llvm_i8_ty],
-        [IntrReadMem, ImmArg<4>]>;
+        [IntrReadMem, ImmArg<ArgIndex<4>>]>;
   def int_x86_avx2_gather_q_ps : GCCBuiltin<"__builtin_ia32_gatherq_ps">,
       Intrinsic<[llvm_v4f32_ty],
         [llvm_v4f32_ty, llvm_ptr_ty, llvm_v2i64_ty, llvm_v4f32_ty, llvm_i8_ty],
-        [IntrReadMem, ImmArg<4>]>;
+        [IntrReadMem, ImmArg<ArgIndex<4>>]>;
   def int_x86_avx2_gather_q_ps_256 : GCCBuiltin<"__builtin_ia32_gatherq_ps256">,
       Intrinsic<[llvm_v4f32_ty],
         [llvm_v4f32_ty, llvm_ptr_ty, llvm_v4i64_ty, llvm_v4f32_ty, llvm_i8_ty],
-        [IntrReadMem, ImmArg<4>]>;
+        [IntrReadMem, ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx2_gather_d_q : GCCBuiltin<"__builtin_ia32_gatherd_q">,
       Intrinsic<[llvm_v2i64_ty],
         [llvm_v2i64_ty, llvm_ptr_ty, llvm_v4i32_ty, llvm_v2i64_ty, llvm_i8_ty],
-        [IntrReadMem, ImmArg<4>]>;
+        [IntrReadMem, ImmArg<ArgIndex<4>>]>;
   def int_x86_avx2_gather_d_q_256 : GCCBuiltin<"__builtin_ia32_gatherd_q256">,
       Intrinsic<[llvm_v4i64_ty],
         [llvm_v4i64_ty, llvm_ptr_ty, llvm_v4i32_ty, llvm_v4i64_ty, llvm_i8_ty],
-        [IntrReadMem, ImmArg<4>]>;
+        [IntrReadMem, ImmArg<ArgIndex<4>>]>;
   def int_x86_avx2_gather_q_q : GCCBuiltin<"__builtin_ia32_gatherq_q">,
       Intrinsic<[llvm_v2i64_ty],
         [llvm_v2i64_ty, llvm_ptr_ty, llvm_v2i64_ty, llvm_v2i64_ty, llvm_i8_ty],
-        [IntrReadMem, ImmArg<4>]>;
+        [IntrReadMem, ImmArg<ArgIndex<4>>]>;
   def int_x86_avx2_gather_q_q_256 : GCCBuiltin<"__builtin_ia32_gatherq_q256">,
       Intrinsic<[llvm_v4i64_ty],
         [llvm_v4i64_ty, llvm_ptr_ty, llvm_v4i64_ty, llvm_v4i64_ty, llvm_i8_ty],
-        [IntrReadMem, ImmArg<4>]>;
+        [IntrReadMem, ImmArg<ArgIndex<4>>]>;
   def int_x86_avx2_gather_d_d : GCCBuiltin<"__builtin_ia32_gatherd_d">,
       Intrinsic<[llvm_v4i32_ty],
         [llvm_v4i32_ty, llvm_ptr_ty, llvm_v4i32_ty, llvm_v4i32_ty, llvm_i8_ty],
-        [IntrReadMem, ImmArg<4>]>;
+        [IntrReadMem, ImmArg<ArgIndex<4>>]>;
   def int_x86_avx2_gather_d_d_256 : GCCBuiltin<"__builtin_ia32_gatherd_d256">,
       Intrinsic<[llvm_v8i32_ty],
         [llvm_v8i32_ty, llvm_ptr_ty, llvm_v8i32_ty, llvm_v8i32_ty, llvm_i8_ty],
-        [IntrReadMem, ImmArg<4>]>;
+        [IntrReadMem, ImmArg<ArgIndex<4>>]>;
   def int_x86_avx2_gather_q_d : GCCBuiltin<"__builtin_ia32_gatherq_d">,
       Intrinsic<[llvm_v4i32_ty],
         [llvm_v4i32_ty, llvm_ptr_ty, llvm_v2i64_ty, llvm_v4i32_ty, llvm_i8_ty],
-        [IntrReadMem, ImmArg<4>]>;
+        [IntrReadMem, ImmArg<ArgIndex<4>>]>;
   def int_x86_avx2_gather_q_d_256 : GCCBuiltin<"__builtin_ia32_gatherq_d256">,
       Intrinsic<[llvm_v4i32_ty],
         [llvm_v4i32_ty, llvm_ptr_ty, llvm_v4i64_ty, llvm_v4i32_ty, llvm_i8_ty],
-        [IntrReadMem, ImmArg<4>]>;
+        [IntrReadMem, ImmArg<ArgIndex<4>>]>;
 }
 
 // Misc.
@@ -1780,42 +1779,60 @@
                          llvm_v32i8_ty], [IntrNoMem]>;
   def int_x86_avx2_mpsadbw : GCCBuiltin<"__builtin_ia32_mpsadbw256">,
               Intrinsic<[llvm_v16i16_ty], [llvm_v32i8_ty, llvm_v32i8_ty,
-                         llvm_i8_ty], [IntrNoMem, Commutative, ImmArg<2>]>;
+                         llvm_i8_ty], [IntrNoMem, Commutative, ImmArg<ArgIndex<2>>]>;
 }
 
 //===----------------------------------------------------------------------===//
 // FMA3 and FMA4
 
 let TargetPrefix = "x86" in {  // All intrinsics start with "llvm.x86.".
+  def int_x86_fma_vfmaddsub_ps : GCCBuiltin<"__builtin_ia32_vfmaddsubps">,
+              Intrinsic<[llvm_v4f32_ty],
+                        [llvm_v4f32_ty, llvm_v4f32_ty, llvm_v4f32_ty],
+                        [IntrNoMem]>;
+  def int_x86_fma_vfmaddsub_pd : GCCBuiltin<"__builtin_ia32_vfmaddsubpd">,
+              Intrinsic<[llvm_v2f64_ty],
+                        [llvm_v2f64_ty, llvm_v2f64_ty, llvm_v2f64_ty],
+                        [IntrNoMem]>;
+  def int_x86_fma_vfmaddsub_ps_256 :
+               GCCBuiltin<"__builtin_ia32_vfmaddsubps256">,
+              Intrinsic<[llvm_v8f32_ty],
+                        [llvm_v8f32_ty, llvm_v8f32_ty, llvm_v8f32_ty],
+                        [IntrNoMem]>;
+  def int_x86_fma_vfmaddsub_pd_256 :
+              GCCBuiltin<"__builtin_ia32_vfmaddsubpd256">,
+              Intrinsic<[llvm_v4f64_ty],
+                        [llvm_v4f64_ty, llvm_v4f64_ty, llvm_v4f64_ty],
+                        [IntrNoMem]>;
+
   def int_x86_avx512_vfmadd_pd_512 :
           Intrinsic<[llvm_v8f64_ty],
           [llvm_v8f64_ty, llvm_v8f64_ty, llvm_v8f64_ty, llvm_i32_ty],
-          [IntrNoMem, ImmArg<3>]>;
+          [IntrNoMem, ImmArg<ArgIndex<3>>]>;
 
   def int_x86_avx512_vfmadd_ps_512 :
           Intrinsic<[llvm_v16f32_ty],
           [llvm_v16f32_ty, llvm_v16f32_ty, llvm_v16f32_ty, llvm_i32_ty],
-          [IntrNoMem, ImmArg<3>]>;
+          [IntrNoMem, ImmArg<ArgIndex<3>>]>;
 
-  // TODO: Can we use 2 vfmadds+shufflevector?
   def int_x86_avx512_vfmaddsub_pd_512 :
           Intrinsic<[llvm_v8f64_ty],
           [llvm_v8f64_ty, llvm_v8f64_ty, llvm_v8f64_ty, llvm_i32_ty],
-          [IntrNoMem, ImmArg<3>]>;
+          [IntrNoMem, ImmArg<ArgIndex<3>>]>;
 
   def int_x86_avx512_vfmaddsub_ps_512 :
           Intrinsic<[llvm_v16f32_ty],
           [llvm_v16f32_ty, llvm_v16f32_ty, llvm_v16f32_ty, llvm_i32_ty],
-          [IntrNoMem, ImmArg<3>]>;
+          [IntrNoMem, ImmArg<ArgIndex<3>>]>;
 
   def int_x86_avx512_vfmadd_f64 :
           Intrinsic<[llvm_double_ty],
                     [llvm_double_ty, llvm_double_ty, llvm_double_ty, llvm_i32_ty],
-                    [IntrNoMem, ImmArg<3>]>;
+                    [IntrNoMem, ImmArg<ArgIndex<3>>]>;
   def int_x86_avx512_vfmadd_f32 :
           Intrinsic<[llvm_float_ty],
                     [llvm_float_ty, llvm_float_ty, llvm_float_ty, llvm_i32_ty],
-                    [IntrNoMem, ImmArg<3>]>;
+                    [IntrNoMem, ImmArg<ArgIndex<3>>]>;
 
   def int_x86_avx512_vpmadd52h_uq_128 :
               GCCBuiltin<"__builtin_ia32_vpmadd52huq128">,
@@ -1905,23 +1922,23 @@
   def int_x86_xop_vpermil2pd : GCCBuiltin<"__builtin_ia32_vpermil2pd">,
               Intrinsic<[llvm_v2f64_ty], [llvm_v2f64_ty, llvm_v2f64_ty,
                                           llvm_v2i64_ty, llvm_i8_ty],
-                        [IntrNoMem, ImmArg<3>]>;
+                        [IntrNoMem, ImmArg<ArgIndex<3>>]>;
 
   def int_x86_xop_vpermil2pd_256 :
               GCCBuiltin<"__builtin_ia32_vpermil2pd256">,
               Intrinsic<[llvm_v4f64_ty], [llvm_v4f64_ty, llvm_v4f64_ty,
                                           llvm_v4i64_ty, llvm_i8_ty],
-                        [IntrNoMem, ImmArg<3>]>;
+                        [IntrNoMem, ImmArg<ArgIndex<3>>]>;
 
   def int_x86_xop_vpermil2ps : GCCBuiltin<"__builtin_ia32_vpermil2ps">,
               Intrinsic<[llvm_v4f32_ty], [llvm_v4f32_ty, llvm_v4f32_ty,
                                           llvm_v4i32_ty, llvm_i8_ty],
-                        [IntrNoMem, ImmArg<3>]>;
+                        [IntrNoMem, ImmArg<ArgIndex<3>>]>;
   def int_x86_xop_vpermil2ps_256 :
               GCCBuiltin<"__builtin_ia32_vpermil2ps256">,
               Intrinsic<[llvm_v8f32_ty], [llvm_v8f32_ty, llvm_v8f32_ty,
                                           llvm_v8i32_ty, llvm_i8_ty],
-                        [IntrNoMem, ImmArg<3>]>;
+                        [IntrNoMem, ImmArg<ArgIndex<3>>]>;
 
   def int_x86_xop_vfrcz_pd : GCCBuiltin<"__builtin_ia32_vfrczpd">,
               Intrinsic<[llvm_v2f64_ty], [llvm_v2f64_ty], [IntrNoMem]>;
@@ -2091,16 +2108,20 @@
               Intrinsic<[llvm_ptr_ty], [], []>;
   def int_x86_lwpins32 :
               GCCBuiltin<"__builtin_ia32_lwpins32">,
-              Intrinsic<[llvm_i8_ty], [llvm_i32_ty, llvm_i32_ty, llvm_i32_ty], []>;
+              Intrinsic<[llvm_i8_ty], [llvm_i32_ty, llvm_i32_ty, llvm_i32_ty],
+                        [ImmArg<ArgIndex<2>>]>;
   def int_x86_lwpins64 :
               GCCBuiltin<"__builtin_ia32_lwpins64">,
-              Intrinsic<[llvm_i8_ty], [llvm_i64_ty, llvm_i32_ty, llvm_i32_ty], []>;
+              Intrinsic<[llvm_i8_ty], [llvm_i64_ty, llvm_i32_ty, llvm_i32_ty],
+                        [ImmArg<ArgIndex<2>>]>;
   def int_x86_lwpval32 :
               GCCBuiltin<"__builtin_ia32_lwpval32">,
-              Intrinsic<[], [llvm_i32_ty, llvm_i32_ty, llvm_i32_ty], []>;
+              Intrinsic<[], [llvm_i32_ty, llvm_i32_ty, llvm_i32_ty],
+                        [ImmArg<ArgIndex<2>>]>;
   def int_x86_lwpval64 :
               GCCBuiltin<"__builtin_ia32_lwpval64">,
-              Intrinsic<[], [llvm_i64_ty, llvm_i32_ty, llvm_i32_ty], []>;
+              Intrinsic<[], [llvm_i64_ty, llvm_i32_ty, llvm_i32_ty],
+                        [ImmArg<ArgIndex<2>>]>;
 }
 
 //===----------------------------------------------------------------------===//
@@ -2401,15 +2422,15 @@
 
   def int_x86_mmx_palignr_b : GCCBuiltin<"__builtin_ia32_palignr">,
               Intrinsic<[llvm_x86mmx_ty], [llvm_x86mmx_ty,
-                        llvm_x86mmx_ty, llvm_i8_ty], [IntrNoMem, ImmArg<2>]>;
+                        llvm_x86mmx_ty, llvm_i8_ty], [IntrNoMem, ImmArg<ArgIndex<2>>]>;
 
   def int_x86_mmx_pextr_w : GCCBuiltin<"__builtin_ia32_vec_ext_v4hi">,
               Intrinsic<[llvm_i32_ty], [llvm_x86mmx_ty, llvm_i32_ty],
-                        [IntrNoMem, ImmArg<1>]>;
+                        [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 
   def int_x86_mmx_pinsr_w : GCCBuiltin<"__builtin_ia32_vec_set_v4hi">,
               Intrinsic<[llvm_x86mmx_ty], [llvm_x86mmx_ty,
-                        llvm_i32_ty, llvm_i32_ty], [IntrNoMem, ImmArg<2>]>;
+                        llvm_i32_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<2>>]>;
 }
 
 //===----------------------------------------------------------------------===//
@@ -2524,38 +2545,28 @@
 // Half float conversion
 
 let TargetPrefix = "x86" in {  // All intrinsics start with "llvm.x86.".
-  def int_x86_vcvtph2ps_128 : GCCBuiltin<"__builtin_ia32_vcvtph2ps">,
-              Intrinsic<[llvm_v4f32_ty], [llvm_v8i16_ty], [IntrNoMem]>;
-  def int_x86_vcvtph2ps_256 : GCCBuiltin<"__builtin_ia32_vcvtph2ps256">,
-              Intrinsic<[llvm_v8f32_ty], [llvm_v8i16_ty], [IntrNoMem]>;
   def int_x86_vcvtps2ph_128 : GCCBuiltin<"__builtin_ia32_vcvtps2ph">,
               Intrinsic<[llvm_v8i16_ty], [llvm_v4f32_ty, llvm_i32_ty],
-                        [IntrNoMem, ImmArg<1>]>;
+                        [IntrNoMem, ImmArg<ArgIndex<1>>]>;
   def int_x86_vcvtps2ph_256 : GCCBuiltin<"__builtin_ia32_vcvtps2ph256">,
               Intrinsic<[llvm_v8i16_ty], [llvm_v8f32_ty, llvm_i32_ty],
-                        [IntrNoMem, ImmArg<1>]>;
-  def int_x86_avx512_mask_vcvtph2ps_512 : GCCBuiltin<"__builtin_ia32_vcvtph2ps512_mask">,
+                        [IntrNoMem, ImmArg<ArgIndex<1>>]>;
+  def int_x86_avx512_mask_vcvtph2ps_512 :
               Intrinsic<[llvm_v16f32_ty], [llvm_v16i16_ty, llvm_v16f32_ty,
                                            llvm_i16_ty, llvm_i32_ty],
-                        [IntrNoMem, ImmArg<3>]>;
-  def int_x86_avx512_mask_vcvtph2ps_256 : GCCBuiltin<"__builtin_ia32_vcvtph2ps256_mask">,
-              Intrinsic<[llvm_v8f32_ty], [llvm_v8i16_ty, llvm_v8f32_ty,
-                                           llvm_i8_ty], [IntrNoMem]>;
-  def int_x86_avx512_mask_vcvtph2ps_128 : GCCBuiltin<"__builtin_ia32_vcvtph2ps_mask">,
-              Intrinsic<[llvm_v4f32_ty], [llvm_v8i16_ty, llvm_v4f32_ty,
-                                           llvm_i8_ty], [IntrNoMem]>;
+                        [IntrNoMem, ImmArg<ArgIndex<3>>]>;
   def int_x86_avx512_mask_vcvtps2ph_512 : GCCBuiltin<"__builtin_ia32_vcvtps2ph512_mask">,
               Intrinsic<[llvm_v16i16_ty], [llvm_v16f32_ty, llvm_i32_ty,
                                            llvm_v16i16_ty, llvm_i16_ty],
-                        [IntrNoMem, ImmArg<1>]>;
+                        [IntrNoMem, ImmArg<ArgIndex<1>>]>;
   def int_x86_avx512_mask_vcvtps2ph_256 : GCCBuiltin<"__builtin_ia32_vcvtps2ph256_mask">,
               Intrinsic<[llvm_v8i16_ty], [llvm_v8f32_ty, llvm_i32_ty,
                                            llvm_v8i16_ty, llvm_i8_ty],
-                        [IntrNoMem, ImmArg<1>]>;
+                        [IntrNoMem, ImmArg<ArgIndex<1>>]>;
   def int_x86_avx512_mask_vcvtps2ph_128 : GCCBuiltin<"__builtin_ia32_vcvtps2ph_mask">,
               Intrinsic<[llvm_v8i16_ty], [llvm_v4f32_ty, llvm_i32_ty,
                                            llvm_v8i16_ty, llvm_i8_ty],
-                        [IntrNoMem, ImmArg<1>]>;
+                        [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 }
 
 //===----------------------------------------------------------------------===//
@@ -2564,10 +2575,10 @@
 let TargetPrefix = "x86" in {  // All intrinsics start with "llvm.x86.".
   def int_x86_tbm_bextri_u32 : GCCBuiltin<"__builtin_ia32_bextri_u32">,
         Intrinsic<[llvm_i32_ty], [llvm_i32_ty, llvm_i32_ty],
-                  [IntrNoMem, ImmArg<1>]>;
+                  [IntrNoMem, ImmArg<ArgIndex<1>>]>;
   def int_x86_tbm_bextri_u64 : GCCBuiltin<"__builtin_ia32_bextri_u64">,
         Intrinsic<[llvm_i64_ty], [llvm_i64_ty, llvm_i64_ty],
-                  [IntrNoMem, ImmArg<1>]>;
+                  [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 }
 
 //===----------------------------------------------------------------------===//
@@ -2613,7 +2624,7 @@
   def int_x86_xend : GCCBuiltin<"__builtin_ia32_xend">,
               Intrinsic<[], [], []>;
   def int_x86_xabort : GCCBuiltin<"__builtin_ia32_xabort">,
-              Intrinsic<[], [llvm_i8_ty], [ImmArg<0>]>;
+              Intrinsic<[], [llvm_i8_ty], [ImmArg<ArgIndex<0>>]>;
   def int_x86_xtest : GCCBuiltin<"__builtin_ia32_xtest">,
               Intrinsic<[llvm_i32_ty], [], []>;
 }
@@ -2655,70 +2666,70 @@
 let TargetPrefix = "x86" in {  // All intrinsics start with "llvm.x86.".
   def int_x86_avx512_cvttss2si : GCCBuiltin<"__builtin_ia32_vcvttss2si32">,
               Intrinsic<[llvm_i32_ty], [llvm_v4f32_ty, llvm_i32_ty],
-                        [IntrNoMem, ImmArg<1>]>;
+                        [IntrNoMem, ImmArg<ArgIndex<1>>]>;
   def int_x86_avx512_cvttss2si64 : GCCBuiltin<"__builtin_ia32_vcvttss2si64">,
               Intrinsic<[llvm_i64_ty], [llvm_v4f32_ty, llvm_i32_ty],
-                        [IntrNoMem, ImmArg<1>]>;
+                        [IntrNoMem, ImmArg<ArgIndex<1>>]>;
   def int_x86_avx512_cvttss2usi : GCCBuiltin<"__builtin_ia32_vcvttss2usi32">,
               Intrinsic<[llvm_i32_ty], [llvm_v4f32_ty, llvm_i32_ty],
-                        [IntrNoMem, ImmArg<1>]>;
+                        [IntrNoMem, ImmArg<ArgIndex<1>>]>;
   def int_x86_avx512_cvttss2usi64 : GCCBuiltin<"__builtin_ia32_vcvttss2usi64">,
               Intrinsic<[llvm_i64_ty], [llvm_v4f32_ty, llvm_i32_ty],
-                        [IntrNoMem, ImmArg<1>]>;
+                        [IntrNoMem, ImmArg<ArgIndex<1>>]>;
   def int_x86_avx512_cvtusi2ss : GCCBuiltin<"__builtin_ia32_cvtusi2ss32">,
               Intrinsic<[llvm_v4f32_ty], [llvm_v4f32_ty,
-                         llvm_i32_ty, llvm_i32_ty], [IntrNoMem, ImmArg<2>]>;
+                         llvm_i32_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<2>>]>;
   def int_x86_avx512_cvtusi642ss : GCCBuiltin<"__builtin_ia32_cvtusi2ss64">,
               Intrinsic<[llvm_v4f32_ty], [llvm_v4f32_ty,
-                         llvm_i64_ty, llvm_i32_ty], [IntrNoMem, ImmArg<2>]>;
+                         llvm_i64_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<2>>]>;
   def int_x86_avx512_cvttsd2si : GCCBuiltin<"__builtin_ia32_vcvttsd2si32">,
               Intrinsic<[llvm_i32_ty], [llvm_v2f64_ty, llvm_i32_ty],
-                        [IntrNoMem, ImmArg<1>]>;
+                        [IntrNoMem, ImmArg<ArgIndex<1>>]>;
   def int_x86_avx512_cvttsd2si64 : GCCBuiltin<"__builtin_ia32_vcvttsd2si64">,
               Intrinsic<[llvm_i64_ty], [llvm_v2f64_ty, llvm_i32_ty],
-                        [IntrNoMem, ImmArg<1>]>;
+                        [IntrNoMem, ImmArg<ArgIndex<1>>]>;
   def int_x86_avx512_cvttsd2usi : GCCBuiltin<"__builtin_ia32_vcvttsd2usi32">,
               Intrinsic<[llvm_i32_ty], [llvm_v2f64_ty, llvm_i32_ty],
-                        [IntrNoMem, ImmArg<1>]>;
+                        [IntrNoMem, ImmArg<ArgIndex<1>>]>;
   def int_x86_avx512_cvttsd2usi64 : GCCBuiltin<"__builtin_ia32_vcvttsd2usi64">,
               Intrinsic<[llvm_i64_ty], [llvm_v2f64_ty, llvm_i32_ty],
-                        [IntrNoMem, ImmArg<1>]>;
+                        [IntrNoMem, ImmArg<ArgIndex<1>>]>;
   def int_x86_avx512_cvtusi642sd : GCCBuiltin<"__builtin_ia32_cvtusi2sd64">,
               Intrinsic<[llvm_v2f64_ty], [llvm_v2f64_ty,
-                         llvm_i64_ty, llvm_i32_ty], [IntrNoMem, ImmArg<2>]>;
+                         llvm_i64_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<2>>]>;
   def int_x86_avx512_vcvtss2usi32 : GCCBuiltin<"__builtin_ia32_vcvtss2usi32">,
               Intrinsic<[llvm_i32_ty], [llvm_v4f32_ty, llvm_i32_ty],
-                        [IntrNoMem, ImmArg<1>]>;
+                        [IntrNoMem, ImmArg<ArgIndex<1>>]>;
   def int_x86_avx512_vcvtss2usi64 : GCCBuiltin<"__builtin_ia32_vcvtss2usi64">,
               Intrinsic<[llvm_i64_ty], [llvm_v4f32_ty, llvm_i32_ty],
-                        [IntrNoMem, ImmArg<1>]>;
+                        [IntrNoMem, ImmArg<ArgIndex<1>>]>;
   def int_x86_avx512_vcvtss2si32 : GCCBuiltin<"__builtin_ia32_vcvtss2si32">,
               Intrinsic<[llvm_i32_ty], [llvm_v4f32_ty, llvm_i32_ty],
-                        [IntrNoMem, ImmArg<1>]>;
+                        [IntrNoMem, ImmArg<ArgIndex<1>>]>;
   def int_x86_avx512_vcvtss2si64 : GCCBuiltin<"__builtin_ia32_vcvtss2si64">,
               Intrinsic<[llvm_i64_ty], [llvm_v4f32_ty, llvm_i32_ty],
-                        [IntrNoMem, ImmArg<1>]>;
+                        [IntrNoMem, ImmArg<ArgIndex<1>>]>;
   def int_x86_avx512_vcvtsd2usi32 : GCCBuiltin<"__builtin_ia32_vcvtsd2usi32">,
               Intrinsic<[llvm_i32_ty], [llvm_v2f64_ty, llvm_i32_ty],
-                        [IntrNoMem, ImmArg<1>]>;
+                        [IntrNoMem, ImmArg<ArgIndex<1>>]>;
   def int_x86_avx512_vcvtsd2usi64 : GCCBuiltin<"__builtin_ia32_vcvtsd2usi64">,
               Intrinsic<[llvm_i64_ty], [llvm_v2f64_ty, llvm_i32_ty],
-                        [IntrNoMem, ImmArg<1>]>;
+                        [IntrNoMem, ImmArg<ArgIndex<1>>]>;
   def int_x86_avx512_vcvtsd2si32 : GCCBuiltin<"__builtin_ia32_vcvtsd2si32">,
               Intrinsic<[llvm_i32_ty], [llvm_v2f64_ty, llvm_i32_ty],
-                        [IntrNoMem, ImmArg<1>]>;
+                        [IntrNoMem, ImmArg<ArgIndex<1>>]>;
   def int_x86_avx512_vcvtsd2si64 : GCCBuiltin<"__builtin_ia32_vcvtsd2si64">,
               Intrinsic<[llvm_i64_ty], [llvm_v2f64_ty, llvm_i32_ty],
-                        [IntrNoMem, ImmArg<1>]>;
+                        [IntrNoMem, ImmArg<ArgIndex<1>>]>;
   def int_x86_avx512_cvtsi2ss32 : GCCBuiltin<"__builtin_ia32_cvtsi2ss32">,
               Intrinsic<[llvm_v4f32_ty], [llvm_v4f32_ty,
-                         llvm_i32_ty, llvm_i32_ty], [IntrNoMem, ImmArg<2>]>;
+                         llvm_i32_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<2>>]>;
   def int_x86_avx512_cvtsi2ss64 : GCCBuiltin<"__builtin_ia32_cvtsi2ss64">,
               Intrinsic<[llvm_v4f32_ty], [llvm_v4f32_ty,
-                         llvm_i64_ty, llvm_i32_ty], [IntrNoMem, ImmArg<2>]>;
+                         llvm_i64_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<2>>]>;
   def int_x86_avx512_cvtsi2sd64 : GCCBuiltin<"__builtin_ia32_cvtsi2sd64">,
               Intrinsic<[llvm_v2f64_ty], [llvm_v2f64_ty,
-                         llvm_i64_ty, llvm_i32_ty], [IntrNoMem, ImmArg<2>]>;
+                         llvm_i64_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<2>>]>;
 }
 
 // Pack ops.
@@ -2741,11 +2752,11 @@
 let TargetPrefix = "x86" in {  // All intrinsics start with "llvm.x86.".
   def int_x86_avx512_sitofp_round :
           Intrinsic<[llvm_anyfloat_ty], [llvm_anyint_ty, llvm_i32_ty],
-                    [IntrNoMem, ImmArg<1>]>;
+                    [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 
   def int_x86_avx512_uitofp_round :
           Intrinsic<[llvm_anyfloat_ty], [llvm_anyint_ty, llvm_i32_ty],
-                    [IntrNoMem, ImmArg<1>]>;
+                    [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 
   def int_x86_avx512_mask_cvtpd2dq_128 :
         GCCBuiltin<"__builtin_ia32_cvtpd2dq128_mask">,
@@ -2757,25 +2768,25 @@
         GCCBuiltin<"__builtin_ia32_cvtpd2dq512_mask">,
           Intrinsic<[llvm_v8i32_ty],
           [llvm_v8f64_ty, llvm_v8i32_ty,  llvm_i8_ty,  llvm_i32_ty],
-          [IntrNoMem, ImmArg<3>]>;
+          [IntrNoMem, ImmArg<ArgIndex<3>>]>;
 
   def int_x86_avx512_mask_cvtpd2ps_512 :
         GCCBuiltin<"__builtin_ia32_cvtpd2ps512_mask">,
           Intrinsic<[llvm_v8f32_ty],
           [llvm_v8f64_ty, llvm_v8f32_ty,  llvm_i8_ty,  llvm_i32_ty],
-          [IntrNoMem, ImmArg<3>]>;
+          [IntrNoMem, ImmArg<ArgIndex<3>>]>;
 
   def int_x86_avx512_mask_cvtsd2ss_round :
         GCCBuiltin<"__builtin_ia32_cvtsd2ss_round_mask">,
           Intrinsic<[llvm_v4f32_ty],
           [llvm_v4f32_ty, llvm_v2f64_ty, llvm_v4f32_ty, llvm_i8_ty, llvm_i32_ty],
-          [IntrNoMem, ImmArg<4>]>;
+          [IntrNoMem, ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_mask_cvtss2sd_round :
         GCCBuiltin<"__builtin_ia32_cvtss2sd_round_mask">,
           Intrinsic<[llvm_v2f64_ty],
           [llvm_v2f64_ty, llvm_v4f32_ty, llvm_v2f64_ty, llvm_i8_ty, llvm_i32_ty],
-          [IntrNoMem, ImmArg<4>]>;
+          [IntrNoMem, ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_mask_cvtpd2ps :
         GCCBuiltin<"__builtin_ia32_cvtpd2ps_mask">,
@@ -2799,7 +2810,7 @@
         GCCBuiltin<"__builtin_ia32_cvtpd2qq512_mask">,
           Intrinsic<[llvm_v8i64_ty],
           [llvm_v8f64_ty, llvm_v8i64_ty,  llvm_i8_ty,  llvm_i32_ty],
-          [IntrNoMem, ImmArg<3>]>;
+          [IntrNoMem, ImmArg<ArgIndex<3>>]>;
 
   def int_x86_avx512_mask_cvtpd2udq_128 :
         GCCBuiltin<"__builtin_ia32_cvtpd2udq128_mask">,
@@ -2817,7 +2828,7 @@
         GCCBuiltin<"__builtin_ia32_cvtpd2udq512_mask">,
           Intrinsic<[llvm_v8i32_ty],
           [llvm_v8f64_ty, llvm_v8i32_ty,  llvm_i8_ty,  llvm_i32_ty],
-          [IntrNoMem, ImmArg<3>]>;
+          [IntrNoMem, ImmArg<ArgIndex<3>>]>;
 
   def int_x86_avx512_mask_cvtpd2uqq_128 :
         GCCBuiltin<"__builtin_ia32_cvtpd2uqq128_mask">,
@@ -2835,7 +2846,7 @@
         GCCBuiltin<"__builtin_ia32_cvtpd2uqq512_mask">,
           Intrinsic<[llvm_v8i64_ty],
           [llvm_v8f64_ty, llvm_v8i64_ty,  llvm_i8_ty,  llvm_i32_ty],
-          [IntrNoMem, ImmArg<3>]>;
+          [IntrNoMem, ImmArg<ArgIndex<3>>]>;
 
   def int_x86_avx512_mask_cvtps2dq_128 :
         GCCBuiltin<"__builtin_ia32_cvtps2dq128_mask">,
@@ -2853,13 +2864,13 @@
         GCCBuiltin<"__builtin_ia32_cvtps2dq512_mask">,
           Intrinsic<[llvm_v16i32_ty],
           [llvm_v16f32_ty, llvm_v16i32_ty,  llvm_i16_ty,  llvm_i32_ty],
-          [IntrNoMem, ImmArg<3>]>;
+          [IntrNoMem, ImmArg<ArgIndex<3>>]>;
 
   def int_x86_avx512_mask_cvtps2pd_512 :
         GCCBuiltin<"__builtin_ia32_cvtps2pd512_mask">,
           Intrinsic<[llvm_v8f64_ty],
           [llvm_v8f32_ty, llvm_v8f64_ty,  llvm_i8_ty,  llvm_i32_ty],
-          [IntrNoMem, ImmArg<3>]>;
+          [IntrNoMem, ImmArg<ArgIndex<3>>]>;
 
   def int_x86_avx512_mask_cvtps2qq_128 :
         GCCBuiltin<"__builtin_ia32_cvtps2qq128_mask">,
@@ -2877,7 +2888,7 @@
         GCCBuiltin<"__builtin_ia32_cvtps2qq512_mask">,
           Intrinsic<[llvm_v8i64_ty],
           [llvm_v8f32_ty, llvm_v8i64_ty,  llvm_i8_ty,  llvm_i32_ty],
-          [IntrNoMem, ImmArg<3>]>;
+          [IntrNoMem, ImmArg<ArgIndex<3>>]>;
 
   def int_x86_avx512_mask_cvtps2udq_128 :
         GCCBuiltin<"__builtin_ia32_cvtps2udq128_mask">,
@@ -2895,7 +2906,7 @@
         GCCBuiltin<"__builtin_ia32_cvtps2udq512_mask">,
           Intrinsic<[llvm_v16i32_ty],
           [llvm_v16f32_ty, llvm_v16i32_ty,  llvm_i16_ty,  llvm_i32_ty],
-          [IntrNoMem, ImmArg<3>]>;
+          [IntrNoMem, ImmArg<ArgIndex<3>>]>;
 
   def int_x86_avx512_mask_cvtps2uqq_128 :
         GCCBuiltin<"__builtin_ia32_cvtps2uqq128_mask">,
@@ -2913,7 +2924,7 @@
         GCCBuiltin<"__builtin_ia32_cvtps2uqq512_mask">,
           Intrinsic<[llvm_v8i64_ty],
           [llvm_v8f32_ty, llvm_v8i64_ty,  llvm_i8_ty,  llvm_i32_ty],
-          [IntrNoMem, ImmArg<3>]>;
+          [IntrNoMem, ImmArg<ArgIndex<3>>]>;
 
   def int_x86_avx512_mask_cvtqq2ps_128 :
         GCCBuiltin<"__builtin_ia32_cvtqq2ps128_mask">,
@@ -2931,7 +2942,7 @@
         GCCBuiltin<"__builtin_ia32_cvttpd2dq512_mask">,
           Intrinsic<[llvm_v8i32_ty],
           [llvm_v8f64_ty, llvm_v8i32_ty,  llvm_i8_ty,  llvm_i32_ty],
-          [IntrNoMem, ImmArg<3>]>;
+          [IntrNoMem, ImmArg<ArgIndex<3>>]>;
 
   def int_x86_avx512_mask_cvttpd2qq_128 :
         GCCBuiltin<"__builtin_ia32_cvttpd2qq128_mask">,
@@ -2949,7 +2960,7 @@
         GCCBuiltin<"__builtin_ia32_cvttpd2qq512_mask">,
           Intrinsic<[llvm_v8i64_ty],
           [llvm_v8f64_ty, llvm_v8i64_ty,  llvm_i8_ty,  llvm_i32_ty],
-          [IntrNoMem, ImmArg<3>]>;
+          [IntrNoMem, ImmArg<ArgIndex<3>>]>;
 
   def int_x86_avx512_mask_cvttpd2udq_128 :
         GCCBuiltin<"__builtin_ia32_cvttpd2udq128_mask">,
@@ -2967,7 +2978,7 @@
         GCCBuiltin<"__builtin_ia32_cvttpd2udq512_mask">,
           Intrinsic<[llvm_v8i32_ty],
           [llvm_v8f64_ty, llvm_v8i32_ty,  llvm_i8_ty,  llvm_i32_ty],
-          [IntrNoMem, ImmArg<3>]>;
+          [IntrNoMem, ImmArg<ArgIndex<3>>]>;
 
   def int_x86_avx512_mask_cvttpd2uqq_128 :
         GCCBuiltin<"__builtin_ia32_cvttpd2uqq128_mask">,
@@ -2985,13 +2996,13 @@
         GCCBuiltin<"__builtin_ia32_cvttpd2uqq512_mask">,
           Intrinsic<[llvm_v8i64_ty],
           [llvm_v8f64_ty, llvm_v8i64_ty,  llvm_i8_ty,  llvm_i32_ty],
-          [IntrNoMem, ImmArg<3>]>;
+          [IntrNoMem, ImmArg<ArgIndex<3>>]>;
 
   def int_x86_avx512_mask_cvttps2dq_512 :
         GCCBuiltin<"__builtin_ia32_cvttps2dq512_mask">,
           Intrinsic<[llvm_v16i32_ty],
           [llvm_v16f32_ty, llvm_v16i32_ty,  llvm_i16_ty,  llvm_i32_ty],
-          [IntrNoMem, ImmArg<3>]>;
+          [IntrNoMem, ImmArg<ArgIndex<3>>]>;
 
   def int_x86_avx512_mask_cvttps2qq_128 :
         GCCBuiltin<"__builtin_ia32_cvttps2qq128_mask">,
@@ -3009,7 +3020,7 @@
         GCCBuiltin<"__builtin_ia32_cvttps2qq512_mask">,
           Intrinsic<[llvm_v8i64_ty],
           [llvm_v8f32_ty, llvm_v8i64_ty,  llvm_i8_ty,  llvm_i32_ty],
-          [IntrNoMem, ImmArg<3>]>;
+          [IntrNoMem, ImmArg<ArgIndex<3>>]>;
 
   def int_x86_avx512_mask_cvttps2udq_128 :
         GCCBuiltin<"__builtin_ia32_cvttps2udq128_mask">,
@@ -3027,7 +3038,7 @@
         GCCBuiltin<"__builtin_ia32_cvttps2udq512_mask">,
           Intrinsic<[llvm_v16i32_ty],
           [llvm_v16f32_ty, llvm_v16i32_ty,  llvm_i16_ty,  llvm_i32_ty],
-          [IntrNoMem, ImmArg<3>]>;
+          [IntrNoMem, ImmArg<ArgIndex<3>>]>;
 
   def int_x86_avx512_mask_cvttps2uqq_128 :
         GCCBuiltin<"__builtin_ia32_cvttps2uqq128_mask">,
@@ -3045,7 +3056,7 @@
         GCCBuiltin<"__builtin_ia32_cvttps2uqq512_mask">,
           Intrinsic<[llvm_v8i64_ty],
           [llvm_v8f32_ty, llvm_v8i64_ty,  llvm_i8_ty,  llvm_i32_ty],
-          [IntrNoMem, ImmArg<3>]>;
+          [IntrNoMem, ImmArg<ArgIndex<3>>]>;
 
   def int_x86_avx512_mask_cvtuqq2ps_128 :
         GCCBuiltin<"__builtin_ia32_cvtuqq2ps128_mask">,
@@ -3056,75 +3067,75 @@
   def int_x86_avx512_mask_rndscale_pd_128 : GCCBuiltin<"__builtin_ia32_rndscalepd_128_mask">,
         Intrinsic<[llvm_v2f64_ty], [llvm_v2f64_ty, llvm_i32_ty,
                                      llvm_v2f64_ty,  llvm_i8_ty],
-                  [IntrNoMem, ImmArg<1>]>;
+                  [IntrNoMem, ImmArg<ArgIndex<1>>]>;
   def int_x86_avx512_mask_rndscale_pd_256 : GCCBuiltin<"__builtin_ia32_rndscalepd_256_mask">,
         Intrinsic<[llvm_v4f64_ty], [llvm_v4f64_ty, llvm_i32_ty,
                                      llvm_v4f64_ty,  llvm_i8_ty],
-                  [IntrNoMem, ImmArg<1>]>;
+                  [IntrNoMem, ImmArg<ArgIndex<1>>]>;
   def int_x86_avx512_mask_rndscale_pd_512 : GCCBuiltin<"__builtin_ia32_rndscalepd_mask">,
         Intrinsic<[llvm_v8f64_ty], [llvm_v8f64_ty, llvm_i32_ty, llvm_v8f64_ty,
                                      llvm_i8_ty, llvm_i32_ty],
-                  [IntrNoMem, ImmArg<1>, ImmArg<4>]>;
+                  [IntrNoMem, ImmArg<ArgIndex<1>>, ImmArg<ArgIndex<4>>]>;
   def int_x86_avx512_mask_rndscale_ps_128 : GCCBuiltin<"__builtin_ia32_rndscaleps_128_mask">,
         Intrinsic<[llvm_v4f32_ty], [llvm_v4f32_ty, llvm_i32_ty,
                                      llvm_v4f32_ty,  llvm_i8_ty],
-                  [IntrNoMem, ImmArg<1>]>;
+                  [IntrNoMem, ImmArg<ArgIndex<1>>]>;
   def int_x86_avx512_mask_rndscale_ps_256 : GCCBuiltin<"__builtin_ia32_rndscaleps_256_mask">,
         Intrinsic<[llvm_v8f32_ty], [llvm_v8f32_ty, llvm_i32_ty,
                                      llvm_v8f32_ty,  llvm_i8_ty],
-                  [IntrNoMem, ImmArg<1>]>;
+                  [IntrNoMem, ImmArg<ArgIndex<1>>]>;
   def int_x86_avx512_mask_rndscale_ps_512 : GCCBuiltin<"__builtin_ia32_rndscaleps_mask">,
         Intrinsic<[llvm_v16f32_ty], [llvm_v16f32_ty, llvm_i32_ty, llvm_v16f32_ty,
                                      llvm_i16_ty, llvm_i32_ty],
-                  [IntrNoMem, ImmArg<1>, ImmArg<4>]>;
+                  [IntrNoMem, ImmArg<ArgIndex<1>>, ImmArg<ArgIndex<4>>]>;
   def int_x86_avx512_mask_reduce_pd_128 : GCCBuiltin<"__builtin_ia32_reducepd128_mask">,
         Intrinsic<[llvm_v2f64_ty], [llvm_v2f64_ty, llvm_i32_ty,
                                      llvm_v2f64_ty,  llvm_i8_ty],
-                  [IntrNoMem, ImmArg<1>]>;
+                  [IntrNoMem, ImmArg<ArgIndex<1>>]>;
   def int_x86_avx512_mask_reduce_pd_256 : GCCBuiltin<"__builtin_ia32_reducepd256_mask">,
         Intrinsic<[llvm_v4f64_ty], [llvm_v4f64_ty, llvm_i32_ty,
                                      llvm_v4f64_ty,  llvm_i8_ty],
-                  [IntrNoMem, ImmArg<1>]>;
+                  [IntrNoMem, ImmArg<ArgIndex<1>>]>;
   def int_x86_avx512_mask_reduce_pd_512 : GCCBuiltin<"__builtin_ia32_reducepd512_mask">,
         Intrinsic<[llvm_v8f64_ty], [llvm_v8f64_ty, llvm_i32_ty, llvm_v8f64_ty,
                                      llvm_i8_ty, llvm_i32_ty],
-                  [IntrNoMem, ImmArg<1>, ImmArg<4>]>;
+                  [IntrNoMem, ImmArg<ArgIndex<1>>, ImmArg<ArgIndex<4>>]>;
   def int_x86_avx512_mask_reduce_ps_128 : GCCBuiltin<"__builtin_ia32_reduceps128_mask">,
         Intrinsic<[llvm_v4f32_ty], [llvm_v4f32_ty, llvm_i32_ty,
                                      llvm_v4f32_ty,  llvm_i8_ty],
-                  [IntrNoMem, ImmArg<1>]>;
+                  [IntrNoMem, ImmArg<ArgIndex<1>>]>;
   def int_x86_avx512_mask_reduce_ps_256 : GCCBuiltin<"__builtin_ia32_reduceps256_mask">,
         Intrinsic<[llvm_v8f32_ty], [llvm_v8f32_ty, llvm_i32_ty,
                                      llvm_v8f32_ty,  llvm_i8_ty],
-                  [IntrNoMem, ImmArg<1>]>;
+                  [IntrNoMem, ImmArg<ArgIndex<1>>]>;
   def int_x86_avx512_mask_reduce_ps_512 : GCCBuiltin<"__builtin_ia32_reduceps512_mask">,
         Intrinsic<[llvm_v16f32_ty], [llvm_v16f32_ty, llvm_i32_ty, llvm_v16f32_ty,
                                      llvm_i16_ty, llvm_i32_ty],
-                  [IntrNoMem, ImmArg<1>, ImmArg<4>]>;
+                  [IntrNoMem, ImmArg<ArgIndex<1>>, ImmArg<ArgIndex<4>>]>;
 def int_x86_avx512_mask_range_pd_128 : GCCBuiltin<"__builtin_ia32_rangepd128_mask">,
         Intrinsic<[llvm_v2f64_ty], [llvm_v2f64_ty, llvm_v2f64_ty, llvm_i32_ty,
                                     llvm_v2f64_ty,  llvm_i8_ty],
-                  [IntrNoMem, ImmArg<2>]>;
+                  [IntrNoMem, ImmArg<ArgIndex<2>>]>;
 def int_x86_avx512_mask_range_pd_256 : GCCBuiltin<"__builtin_ia32_rangepd256_mask">,
         Intrinsic<[llvm_v4f64_ty], [llvm_v4f64_ty, llvm_v4f64_ty, llvm_i32_ty,
                                     llvm_v4f64_ty,  llvm_i8_ty],
-                  [IntrNoMem, ImmArg<2>]>;
+                  [IntrNoMem, ImmArg<ArgIndex<2>>]>;
 def int_x86_avx512_mask_range_pd_512 : GCCBuiltin<"__builtin_ia32_rangepd512_mask">,
         Intrinsic<[llvm_v8f64_ty], [llvm_v8f64_ty, llvm_v8f64_ty, llvm_i32_ty,
                                     llvm_v8f64_ty,  llvm_i8_ty,  llvm_i32_ty],
-                  [IntrNoMem, ImmArg<2>, ImmArg<5>]>;
+                  [IntrNoMem, ImmArg<ArgIndex<2>>, ImmArg<ArgIndex<5>>]>;
 def int_x86_avx512_mask_range_ps_128 : GCCBuiltin<"__builtin_ia32_rangeps128_mask">,
         Intrinsic<[llvm_v4f32_ty], [llvm_v4f32_ty, llvm_v4f32_ty, llvm_i32_ty,
                                     llvm_v4f32_ty,  llvm_i8_ty],
-                  [IntrNoMem, ImmArg<2>]>;
+                  [IntrNoMem, ImmArg<ArgIndex<2>>]>;
 def int_x86_avx512_mask_range_ps_256 : GCCBuiltin<"__builtin_ia32_rangeps256_mask">,
         Intrinsic<[llvm_v8f32_ty], [llvm_v8f32_ty, llvm_v8f32_ty, llvm_i32_ty,
                                     llvm_v8f32_ty,  llvm_i8_ty],
-                  [IntrNoMem, ImmArg<2>]>;
+                  [IntrNoMem, ImmArg<ArgIndex<2>>]>;
 def int_x86_avx512_mask_range_ps_512 : GCCBuiltin<"__builtin_ia32_rangeps512_mask">,
         Intrinsic<[llvm_v16f32_ty], [llvm_v16f32_ty, llvm_v16f32_ty, llvm_i32_ty,
                                      llvm_v16f32_ty,  llvm_i16_ty,  llvm_i32_ty],
-                  [IntrNoMem, ImmArg<2>, ImmArg<5>]>;
+                  [IntrNoMem, ImmArg<ArgIndex<2>>, ImmArg<ArgIndex<5>>]>;
 }
 
 // Vector load with broadcast
@@ -3154,111 +3165,111 @@
 
   def int_x86_avx512_add_ps_512 : GCCBuiltin<"__builtin_ia32_addps512">,
           Intrinsic<[llvm_v16f32_ty], [llvm_v16f32_ty, llvm_v16f32_ty,
-                     llvm_i32_ty], [IntrNoMem, ImmArg<2>]>;
+                     llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<2>>]>;
   def int_x86_avx512_add_pd_512 : GCCBuiltin<"__builtin_ia32_addpd512">,
           Intrinsic<[llvm_v8f64_ty], [llvm_v8f64_ty, llvm_v8f64_ty,
-                     llvm_i32_ty], [IntrNoMem, ImmArg<2>]>;
+                     llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<2>>]>;
   def int_x86_avx512_sub_ps_512 : GCCBuiltin<"__builtin_ia32_subps512">,
           Intrinsic<[llvm_v16f32_ty], [llvm_v16f32_ty, llvm_v16f32_ty,
-                     llvm_i32_ty], [IntrNoMem, ImmArg<2>]>;
+                     llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<2>>]>;
   def int_x86_avx512_sub_pd_512 : GCCBuiltin<"__builtin_ia32_subpd512">,
           Intrinsic<[llvm_v8f64_ty], [llvm_v8f64_ty, llvm_v8f64_ty,
-                     llvm_i32_ty], [IntrNoMem, ImmArg<2>]>;
+                     llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<2>>]>;
   def int_x86_avx512_mul_ps_512 : GCCBuiltin<"__builtin_ia32_mulps512">,
           Intrinsic<[llvm_v16f32_ty], [llvm_v16f32_ty, llvm_v16f32_ty,
-                     llvm_i32_ty], [IntrNoMem, ImmArg<2>]>;
+                     llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<2>>]>;
   def int_x86_avx512_mul_pd_512 : GCCBuiltin<"__builtin_ia32_mulpd512">,
           Intrinsic<[llvm_v8f64_ty], [llvm_v8f64_ty, llvm_v8f64_ty,
-                     llvm_i32_ty], [IntrNoMem, ImmArg<2>]>;
+                     llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<2>>]>;
   def int_x86_avx512_div_ps_512 : GCCBuiltin<"__builtin_ia32_divps512">,
           Intrinsic<[llvm_v16f32_ty], [llvm_v16f32_ty, llvm_v16f32_ty,
-                     llvm_i32_ty], [IntrNoMem, ImmArg<2>]>;
+                     llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<2>>]>;
   def int_x86_avx512_div_pd_512 : GCCBuiltin<"__builtin_ia32_divpd512">,
           Intrinsic<[llvm_v8f64_ty], [llvm_v8f64_ty, llvm_v8f64_ty,
-                     llvm_i32_ty], [IntrNoMem, ImmArg<2>]>;
+                     llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<2>>]>;
 
   def int_x86_avx512_max_ps_512 : GCCBuiltin<"__builtin_ia32_maxps512">,
           Intrinsic<[llvm_v16f32_ty], [llvm_v16f32_ty, llvm_v16f32_ty,
-                     llvm_i32_ty], [IntrNoMem, ImmArg<2>]>;
+                     llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<2>>]>;
   def int_x86_avx512_max_pd_512 : GCCBuiltin<"__builtin_ia32_maxpd512">,
           Intrinsic<[llvm_v8f64_ty], [llvm_v8f64_ty, llvm_v8f64_ty,
-                     llvm_i32_ty], [IntrNoMem, ImmArg<2>]>;
+                     llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<2>>]>;
   def int_x86_avx512_min_ps_512 : GCCBuiltin<"__builtin_ia32_minps512">,
           Intrinsic<[llvm_v16f32_ty], [llvm_v16f32_ty, llvm_v16f32_ty,
-                     llvm_i32_ty], [IntrNoMem, ImmArg<2>]>;
+                     llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<2>>]>;
   def int_x86_avx512_min_pd_512 : GCCBuiltin<"__builtin_ia32_minpd512">,
           Intrinsic<[llvm_v8f64_ty], [llvm_v8f64_ty, llvm_v8f64_ty,
-                     llvm_i32_ty], [IntrNoMem, ImmArg<2>]>;
+                     llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<2>>]>;
 
   def int_x86_avx512_mask_add_ss_round : GCCBuiltin<"__builtin_ia32_addss_round_mask">,
           Intrinsic<[llvm_v4f32_ty], [llvm_v4f32_ty, llvm_v4f32_ty,
-                     llvm_v4f32_ty, llvm_i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<4>]>;
+                     llvm_v4f32_ty, llvm_i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<4>>]>;
   def int_x86_avx512_mask_div_ss_round : GCCBuiltin<"__builtin_ia32_divss_round_mask">,
           Intrinsic<[llvm_v4f32_ty], [llvm_v4f32_ty, llvm_v4f32_ty,
-                     llvm_v4f32_ty, llvm_i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<4>]>;
+                     llvm_v4f32_ty, llvm_i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<4>>]>;
   def int_x86_avx512_mask_mul_ss_round : GCCBuiltin<"__builtin_ia32_mulss_round_mask">,
           Intrinsic<[llvm_v4f32_ty], [llvm_v4f32_ty, llvm_v4f32_ty,
-                     llvm_v4f32_ty, llvm_i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<4>]>;
+                     llvm_v4f32_ty, llvm_i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<4>>]>;
   def int_x86_avx512_mask_sub_ss_round : GCCBuiltin<"__builtin_ia32_subss_round_mask">,
           Intrinsic<[llvm_v4f32_ty], [llvm_v4f32_ty, llvm_v4f32_ty,
-                     llvm_v4f32_ty, llvm_i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<4>]>;
+                     llvm_v4f32_ty, llvm_i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<4>>]>;
   def int_x86_avx512_mask_max_ss_round : GCCBuiltin<"__builtin_ia32_maxss_round_mask">,
           Intrinsic<[llvm_v4f32_ty], [llvm_v4f32_ty, llvm_v4f32_ty,
-                     llvm_v4f32_ty, llvm_i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<4>]>;
+                     llvm_v4f32_ty, llvm_i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<4>>]>;
   def int_x86_avx512_mask_min_ss_round : GCCBuiltin<"__builtin_ia32_minss_round_mask">,
           Intrinsic<[llvm_v4f32_ty], [llvm_v4f32_ty, llvm_v4f32_ty,
-                     llvm_v4f32_ty, llvm_i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<4>]>;
+                     llvm_v4f32_ty, llvm_i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<4>>]>;
   def int_x86_avx512_mask_add_sd_round : GCCBuiltin<"__builtin_ia32_addsd_round_mask">,
           Intrinsic<[llvm_v2f64_ty], [llvm_v2f64_ty, llvm_v2f64_ty,
-                     llvm_v2f64_ty, llvm_i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<4>]>;
+                     llvm_v2f64_ty, llvm_i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<4>>]>;
   def int_x86_avx512_mask_div_sd_round : GCCBuiltin<"__builtin_ia32_divsd_round_mask">,
           Intrinsic<[llvm_v2f64_ty], [llvm_v2f64_ty, llvm_v2f64_ty,
-                     llvm_v2f64_ty, llvm_i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<4>]>;
+                     llvm_v2f64_ty, llvm_i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<4>>]>;
   def int_x86_avx512_mask_mul_sd_round : GCCBuiltin<"__builtin_ia32_mulsd_round_mask">,
           Intrinsic<[llvm_v2f64_ty], [llvm_v2f64_ty, llvm_v2f64_ty,
-                     llvm_v2f64_ty, llvm_i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<4>]>;
+                     llvm_v2f64_ty, llvm_i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<4>>]>;
   def int_x86_avx512_mask_sub_sd_round : GCCBuiltin<"__builtin_ia32_subsd_round_mask">,
           Intrinsic<[llvm_v2f64_ty], [llvm_v2f64_ty, llvm_v2f64_ty,
-                     llvm_v2f64_ty, llvm_i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<4>]>;
+                     llvm_v2f64_ty, llvm_i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<4>>]>;
   def int_x86_avx512_mask_max_sd_round : GCCBuiltin<"__builtin_ia32_maxsd_round_mask">,
           Intrinsic<[llvm_v2f64_ty], [llvm_v2f64_ty, llvm_v2f64_ty,
-                     llvm_v2f64_ty, llvm_i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<4>]>;
+                     llvm_v2f64_ty, llvm_i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<4>>]>;
   def int_x86_avx512_mask_min_sd_round : GCCBuiltin<"__builtin_ia32_minsd_round_mask">,
           Intrinsic<[llvm_v2f64_ty], [llvm_v2f64_ty, llvm_v2f64_ty,
-                     llvm_v2f64_ty, llvm_i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<4>]>;
+                     llvm_v2f64_ty, llvm_i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_mask_rndscale_ss : GCCBuiltin<"__builtin_ia32_rndscaless_round_mask">,
           Intrinsic<[llvm_v4f32_ty], [llvm_v4f32_ty, llvm_v4f32_ty, llvm_v4f32_ty,
                                      llvm_i8_ty, llvm_i32_ty, llvm_i32_ty],
-                                     [IntrNoMem, ImmArg<4>, ImmArg<5>]>;
+                                     [IntrNoMem, ImmArg<ArgIndex<4>>, ImmArg<ArgIndex<5>>]>;
   def int_x86_avx512_mask_rndscale_sd : GCCBuiltin<"__builtin_ia32_rndscalesd_round_mask">,
           Intrinsic<[llvm_v2f64_ty], [llvm_v2f64_ty, llvm_v2f64_ty, llvm_v2f64_ty,
                                       llvm_i8_ty, llvm_i32_ty, llvm_i32_ty],
-                                     [IntrNoMem, ImmArg<4>, ImmArg<5>]>;
+                                     [IntrNoMem, ImmArg<ArgIndex<4>>, ImmArg<ArgIndex<5>>]>;
   def int_x86_avx512_mask_range_ss : GCCBuiltin<"__builtin_ia32_rangess128_round_mask">,
           Intrinsic<[llvm_v4f32_ty], [llvm_v4f32_ty, llvm_v4f32_ty, llvm_v4f32_ty,
                                      llvm_i8_ty, llvm_i32_ty, llvm_i32_ty],
-                                     [IntrNoMem, ImmArg<4>, ImmArg<5>]>;
+                                     [IntrNoMem, ImmArg<ArgIndex<4>>, ImmArg<ArgIndex<5>>]>;
   def int_x86_avx512_mask_range_sd : GCCBuiltin<"__builtin_ia32_rangesd128_round_mask">,
           Intrinsic<[llvm_v2f64_ty], [llvm_v2f64_ty, llvm_v2f64_ty, llvm_v2f64_ty,
                                       llvm_i8_ty, llvm_i32_ty, llvm_i32_ty],
-                                     [IntrNoMem, ImmArg<4>, ImmArg<5>]>;
+                                     [IntrNoMem, ImmArg<ArgIndex<4>>, ImmArg<ArgIndex<5>>]>;
   def int_x86_avx512_mask_reduce_ss : GCCBuiltin<"__builtin_ia32_reducess_mask">,
           Intrinsic<[llvm_v4f32_ty], [llvm_v4f32_ty, llvm_v4f32_ty, llvm_v4f32_ty,
                                      llvm_i8_ty, llvm_i32_ty, llvm_i32_ty],
-                                     [IntrNoMem, ImmArg<4>, ImmArg<5>]>;
+                                     [IntrNoMem, ImmArg<ArgIndex<4>>, ImmArg<ArgIndex<5>>]>;
   def int_x86_avx512_mask_reduce_sd : GCCBuiltin<"__builtin_ia32_reducesd_mask">,
           Intrinsic<[llvm_v2f64_ty], [llvm_v2f64_ty, llvm_v2f64_ty, llvm_v2f64_ty,
                                       llvm_i8_ty, llvm_i32_ty, llvm_i32_ty],
-                                     [IntrNoMem, ImmArg<4>, ImmArg<5>]>;
+                                     [IntrNoMem, ImmArg<ArgIndex<4>>, ImmArg<ArgIndex<5>>]>;
   def int_x86_avx512_mask_scalef_sd : GCCBuiltin<"__builtin_ia32_scalefsd_round_mask">,
           Intrinsic<[llvm_v2f64_ty], [llvm_v2f64_ty, llvm_v2f64_ty,
                                       llvm_v2f64_ty, llvm_i8_ty, llvm_i32_ty],
-                                     [IntrNoMem, ImmArg<4>]>;
+                                     [IntrNoMem, ImmArg<ArgIndex<4>>]>;
   def int_x86_avx512_mask_scalef_ss : GCCBuiltin<"__builtin_ia32_scalefss_round_mask">,
           Intrinsic<[llvm_v4f32_ty], [llvm_v4f32_ty, llvm_v4f32_ty,
                                       llvm_v4f32_ty, llvm_i8_ty, llvm_i32_ty],
-                                     [IntrNoMem, ImmArg<4>]>;
+                                     [IntrNoMem, ImmArg<ArgIndex<4>>]>;
   def int_x86_avx512_mask_scalef_pd_128 : GCCBuiltin<"__builtin_ia32_scalefpd128_mask">,
           Intrinsic<[llvm_v2f64_ty], [llvm_v2f64_ty, llvm_v2f64_ty,
                     llvm_v2f64_ty, llvm_i8_ty], [IntrNoMem]>;
@@ -3268,7 +3279,7 @@
   def int_x86_avx512_mask_scalef_pd_512 : GCCBuiltin<"__builtin_ia32_scalefpd512_mask">,
           Intrinsic<[llvm_v8f64_ty], [llvm_v8f64_ty, llvm_v8f64_ty,
                                       llvm_v8f64_ty, llvm_i8_ty, llvm_i32_ty],
-                    [IntrNoMem, ImmArg<4>]>;
+                    [IntrNoMem, ImmArg<ArgIndex<4>>]>;
   def int_x86_avx512_mask_scalef_ps_128 : GCCBuiltin<"__builtin_ia32_scalefps128_mask">,
           Intrinsic<[llvm_v4f32_ty], [llvm_v4f32_ty, llvm_v4f32_ty,
                     llvm_v4f32_ty, llvm_i8_ty], [IntrNoMem]>;
@@ -3278,103 +3289,103 @@
   def int_x86_avx512_mask_scalef_ps_512 : GCCBuiltin<"__builtin_ia32_scalefps512_mask">,
           Intrinsic<[llvm_v16f32_ty], [llvm_v16f32_ty, llvm_v16f32_ty,
                                        llvm_v16f32_ty, llvm_i16_ty, llvm_i32_ty],
-                    [IntrNoMem, ImmArg<4>]>;
+                    [IntrNoMem, ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_mask_sqrt_ss :
         Intrinsic<[llvm_v4f32_ty], [llvm_v4f32_ty, llvm_v4f32_ty, llvm_v4f32_ty,
                                     llvm_i8_ty, llvm_i32_ty],
-                  [IntrNoMem, ImmArg<4>]>;
+                  [IntrNoMem, ImmArg<ArgIndex<4>>]>;
   def int_x86_avx512_mask_sqrt_sd :
         Intrinsic<[llvm_v2f64_ty], [llvm_v2f64_ty, llvm_v2f64_ty, llvm_v2f64_ty,
                                     llvm_i8_ty, llvm_i32_ty],
-                  [IntrNoMem, ImmArg<4>]>;
+                  [IntrNoMem, ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_sqrt_pd_512 :
         Intrinsic<[llvm_v8f64_ty], [llvm_v8f64_ty, llvm_i32_ty],
-                  [IntrNoMem, ImmArg<1>]>;
+                  [IntrNoMem, ImmArg<ArgIndex<1>>]>;
   def int_x86_avx512_sqrt_ps_512 :
         Intrinsic<[llvm_v16f32_ty], [llvm_v16f32_ty, llvm_i32_ty],
-                  [IntrNoMem, ImmArg<1>]>;
+                  [IntrNoMem, ImmArg<ArgIndex<1>>]>;
   def int_x86_avx512_mask_fixupimm_pd_128 :
          GCCBuiltin<"__builtin_ia32_fixupimmpd128_mask">,
           Intrinsic<[llvm_v2f64_ty],
           [llvm_v2f64_ty, llvm_v2f64_ty, llvm_v2i64_ty, llvm_i32_ty, llvm_i8_ty],
-          [IntrNoMem, ImmArg<3>]>;
+          [IntrNoMem, ImmArg<ArgIndex<3>>]>;
   def int_x86_avx512_maskz_fixupimm_pd_128 :
          GCCBuiltin<"__builtin_ia32_fixupimmpd128_maskz">,
           Intrinsic<[llvm_v2f64_ty],
           [llvm_v2f64_ty, llvm_v2f64_ty, llvm_v2i64_ty, llvm_i32_ty, llvm_i8_ty],
-          [IntrNoMem, ImmArg<3>]>;
+          [IntrNoMem, ImmArg<ArgIndex<3>>]>;
   def int_x86_avx512_mask_fixupimm_pd_256 :
          GCCBuiltin<"__builtin_ia32_fixupimmpd256_mask">,
           Intrinsic<[llvm_v4f64_ty],
           [llvm_v4f64_ty, llvm_v4f64_ty, llvm_v4i64_ty, llvm_i32_ty, llvm_i8_ty],
-          [IntrNoMem, ImmArg<3>]>;
+          [IntrNoMem, ImmArg<ArgIndex<3>>]>;
   def int_x86_avx512_maskz_fixupimm_pd_256 :
          GCCBuiltin<"__builtin_ia32_fixupimmpd256_maskz">,
           Intrinsic<[llvm_v4f64_ty],
           [llvm_v4f64_ty, llvm_v4f64_ty, llvm_v4i64_ty, llvm_i32_ty, llvm_i8_ty],
-          [IntrNoMem, ImmArg<3>]>;
+          [IntrNoMem, ImmArg<ArgIndex<3>>]>;
   def int_x86_avx512_mask_fixupimm_pd_512 :
          GCCBuiltin<"__builtin_ia32_fixupimmpd512_mask">,
           Intrinsic<[llvm_v8f64_ty],
           [llvm_v8f64_ty, llvm_v8f64_ty, llvm_v8i64_ty, llvm_i32_ty, llvm_i8_ty,
-          llvm_i32_ty], [IntrNoMem, ImmArg<3>, ImmArg<5>]>;
+          llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<3>>, ImmArg<ArgIndex<5>>]>;
   def int_x86_avx512_maskz_fixupimm_pd_512 :
          GCCBuiltin<"__builtin_ia32_fixupimmpd512_maskz">,
           Intrinsic<[llvm_v8f64_ty],
           [llvm_v8f64_ty, llvm_v8f64_ty, llvm_v8i64_ty, llvm_i32_ty, llvm_i8_ty,
-          llvm_i32_ty], [IntrNoMem, ImmArg<3>, ImmArg<5>]>;
+          llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<3>>, ImmArg<ArgIndex<5>>]>;
   def int_x86_avx512_mask_fixupimm_ps_128 :
          GCCBuiltin<"__builtin_ia32_fixupimmps128_mask">,
           Intrinsic<[llvm_v4f32_ty],
           [llvm_v4f32_ty, llvm_v4f32_ty, llvm_v4i32_ty, llvm_i32_ty, llvm_i8_ty],
-          [IntrNoMem, ImmArg<3>]>;
+          [IntrNoMem, ImmArg<ArgIndex<3>>]>;
   def int_x86_avx512_maskz_fixupimm_ps_128 :
          GCCBuiltin<"__builtin_ia32_fixupimmps128_maskz">,
           Intrinsic<[llvm_v4f32_ty],
           [llvm_v4f32_ty, llvm_v4f32_ty, llvm_v4i32_ty, llvm_i32_ty, llvm_i8_ty],
-          [IntrNoMem, ImmArg<3>]>;
+          [IntrNoMem, ImmArg<ArgIndex<3>>]>;
   def int_x86_avx512_mask_fixupimm_ps_256 :
          GCCBuiltin<"__builtin_ia32_fixupimmps256_mask">,
           Intrinsic<[llvm_v8f32_ty],
           [llvm_v8f32_ty, llvm_v8f32_ty, llvm_v8i32_ty, llvm_i32_ty, llvm_i8_ty],
-          [IntrNoMem, ImmArg<3>]>;
+          [IntrNoMem, ImmArg<ArgIndex<3>>]>;
   def int_x86_avx512_maskz_fixupimm_ps_256 :
          GCCBuiltin<"__builtin_ia32_fixupimmps256_maskz">,
           Intrinsic<[llvm_v8f32_ty],
           [llvm_v8f32_ty, llvm_v8f32_ty, llvm_v8i32_ty, llvm_i32_ty, llvm_i8_ty],
-          [IntrNoMem, ImmArg<3>]>;
+          [IntrNoMem, ImmArg<ArgIndex<3>>]>;
   def int_x86_avx512_mask_fixupimm_ps_512 :
          GCCBuiltin<"__builtin_ia32_fixupimmps512_mask">,
           Intrinsic<[llvm_v16f32_ty],
           [llvm_v16f32_ty, llvm_v16f32_ty, llvm_v16i32_ty, llvm_i32_ty,
-          llvm_i16_ty, llvm_i32_ty], [IntrNoMem, ImmArg<3>, ImmArg<5>]>;
+          llvm_i16_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<3>>, ImmArg<ArgIndex<5>>]>;
   def int_x86_avx512_maskz_fixupimm_ps_512 :
          GCCBuiltin<"__builtin_ia32_fixupimmps512_maskz">,
           Intrinsic<[llvm_v16f32_ty],
           [llvm_v16f32_ty, llvm_v16f32_ty, llvm_v16i32_ty, llvm_i32_ty,
-          llvm_i16_ty, llvm_i32_ty], [IntrNoMem, ImmArg<3>, ImmArg<5>]>;
+          llvm_i16_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<3>>, ImmArg<ArgIndex<5>>]>;
   def int_x86_avx512_mask_fixupimm_sd :
          GCCBuiltin<"__builtin_ia32_fixupimmsd_mask">,
           Intrinsic<[llvm_v2f64_ty],
           [llvm_v2f64_ty, llvm_v2f64_ty, llvm_v2i64_ty, llvm_i32_ty, llvm_i8_ty,
-          llvm_i32_ty], [IntrNoMem, ImmArg<3>, ImmArg<5>]>;
+          llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<3>>, ImmArg<ArgIndex<5>>]>;
   def int_x86_avx512_maskz_fixupimm_sd :
          GCCBuiltin<"__builtin_ia32_fixupimmsd_maskz">,
           Intrinsic<[llvm_v2f64_ty],
           [llvm_v2f64_ty, llvm_v2f64_ty, llvm_v2i64_ty, llvm_i32_ty, llvm_i8_ty,
-          llvm_i32_ty], [IntrNoMem, ImmArg<3>, ImmArg<5>]>;
+          llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<3>>, ImmArg<ArgIndex<5>>]>;
   def int_x86_avx512_mask_fixupimm_ss :
          GCCBuiltin<"__builtin_ia32_fixupimmss_mask">,
           Intrinsic<[llvm_v4f32_ty],
           [llvm_v4f32_ty, llvm_v4f32_ty, llvm_v4i32_ty, llvm_i32_ty, llvm_i8_ty,
-          llvm_i32_ty], [IntrNoMem, ImmArg<3>, ImmArg<5>]>;
+          llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<3>>, ImmArg<ArgIndex<5>>]>;
   def int_x86_avx512_maskz_fixupimm_ss :
          GCCBuiltin<"__builtin_ia32_fixupimmss_maskz">,
           Intrinsic<[llvm_v4f32_ty],
           [llvm_v4f32_ty, llvm_v4f32_ty, llvm_v4i32_ty, llvm_i32_ty, llvm_i8_ty,
-          llvm_i32_ty], [IntrNoMem, ImmArg<3>, ImmArg<5>]>;
+          llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<3>>, ImmArg<ArgIndex<5>>]>;
   def int_x86_avx512_mask_getexp_pd_128 : GCCBuiltin<"__builtin_ia32_getexppd128_mask">,
         Intrinsic<[llvm_v2f64_ty], [llvm_v2f64_ty, llvm_v2f64_ty,
                                     llvm_i8_ty], [IntrNoMem]>;
@@ -3384,7 +3395,7 @@
   def int_x86_avx512_mask_getexp_pd_512 : GCCBuiltin<"__builtin_ia32_getexppd512_mask">,
         Intrinsic<[llvm_v8f64_ty], [llvm_v8f64_ty, llvm_v8f64_ty,
                                     llvm_i8_ty, llvm_i32_ty],
-                  [IntrNoMem, ImmArg<3>]>;
+                  [IntrNoMem, ImmArg<ArgIndex<3>>]>;
   def int_x86_avx512_mask_getexp_ps_128 : GCCBuiltin<"__builtin_ia32_getexpps128_mask">,
         Intrinsic<[llvm_v4f32_ty], [llvm_v4f32_ty, llvm_v4f32_ty,
                                      llvm_i8_ty], [IntrNoMem]>;
@@ -3394,64 +3405,64 @@
   def int_x86_avx512_mask_getexp_ps_512 : GCCBuiltin<"__builtin_ia32_getexpps512_mask">,
         Intrinsic<[llvm_v16f32_ty], [llvm_v16f32_ty, llvm_v16f32_ty,
                                      llvm_i16_ty, llvm_i32_ty],
-                  [IntrNoMem, ImmArg<3>]>;
+                  [IntrNoMem, ImmArg<ArgIndex<3>>]>;
 
   def int_x86_avx512_mask_getexp_ss : GCCBuiltin<"__builtin_ia32_getexpss128_round_mask">,
         Intrinsic<[llvm_v4f32_ty], [llvm_v4f32_ty, llvm_v4f32_ty, llvm_v4f32_ty,
                                     llvm_i8_ty, llvm_i32_ty],
-                  [IntrNoMem, ImmArg<4>]>;
+                  [IntrNoMem, ImmArg<ArgIndex<4>>]>;
   def int_x86_avx512_mask_getexp_sd : GCCBuiltin<"__builtin_ia32_getexpsd128_round_mask">,
         Intrinsic<[llvm_v2f64_ty], [llvm_v2f64_ty, llvm_v2f64_ty, llvm_v2f64_ty,
                                     llvm_i8_ty, llvm_i32_ty],
-                  [IntrNoMem, ImmArg<4>]>;
+                  [IntrNoMem, ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_mask_getmant_pd_128 :
          GCCBuiltin<"__builtin_ia32_getmantpd128_mask">,
           Intrinsic<[llvm_v2f64_ty],
           [llvm_v2f64_ty,llvm_i32_ty, llvm_v2f64_ty,  llvm_i8_ty],
-          [IntrNoMem, ImmArg<1>]>;
+          [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 
   def int_x86_avx512_mask_getmant_pd_256 :
          GCCBuiltin<"__builtin_ia32_getmantpd256_mask">,
           Intrinsic<[llvm_v4f64_ty],
           [llvm_v4f64_ty,llvm_i32_ty, llvm_v4f64_ty,  llvm_i8_ty],
-          [IntrNoMem, ImmArg<1>]>;
+          [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 
   def int_x86_avx512_mask_getmant_pd_512 :
          GCCBuiltin<"__builtin_ia32_getmantpd512_mask">,
           Intrinsic<[llvm_v8f64_ty],
           [llvm_v8f64_ty,llvm_i32_ty, llvm_v8f64_ty,  llvm_i8_ty,llvm_i32_ty ],
-          [IntrNoMem, ImmArg<1>, ImmArg<4>]>;
+          [IntrNoMem, ImmArg<ArgIndex<1>>, ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_mask_getmant_ps_128 :
          GCCBuiltin<"__builtin_ia32_getmantps128_mask">,
           Intrinsic<[llvm_v4f32_ty],
           [llvm_v4f32_ty, llvm_i32_ty, llvm_v4f32_ty,  llvm_i8_ty],
-          [IntrNoMem, ImmArg<1>]>;
+          [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 
   def int_x86_avx512_mask_getmant_ps_256 :
          GCCBuiltin<"__builtin_ia32_getmantps256_mask">,
           Intrinsic<[llvm_v8f32_ty],
           [llvm_v8f32_ty, llvm_i32_ty, llvm_v8f32_ty,  llvm_i8_ty],
-          [IntrNoMem, ImmArg<1>]>;
+          [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 
   def int_x86_avx512_mask_getmant_ps_512 :
          GCCBuiltin<"__builtin_ia32_getmantps512_mask">,
           Intrinsic<[llvm_v16f32_ty],
           [llvm_v16f32_ty,llvm_i32_ty, llvm_v16f32_ty,llvm_i16_ty,llvm_i32_ty],
-          [IntrNoMem, ImmArg<1>, ImmArg<4>]>;
+          [IntrNoMem, ImmArg<ArgIndex<1>>, ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_mask_getmant_ss :
          GCCBuiltin<"__builtin_ia32_getmantss_round_mask">,
           Intrinsic<[llvm_v4f32_ty],
           [llvm_v4f32_ty, llvm_v4f32_ty, llvm_i32_ty, llvm_v4f32_ty,
-           llvm_i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<2>, ImmArg<5>]>;
+           llvm_i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<2>>, ImmArg<ArgIndex<5>>]>;
 
   def int_x86_avx512_mask_getmant_sd :
          GCCBuiltin<"__builtin_ia32_getmantsd_round_mask">,
           Intrinsic<[llvm_v2f64_ty],
           [llvm_v2f64_ty, llvm_v2f64_ty, llvm_i32_ty, llvm_v2f64_ty,
-           llvm_i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<2>, ImmArg<5>]>;
+           llvm_i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<2>>, ImmArg<ArgIndex<5>>]>;
 
   def int_x86_avx512_rsqrt14_ss : GCCBuiltin<"__builtin_ia32_rsqrt14ss_mask">,
         Intrinsic<[llvm_v4f32_ty], [llvm_v4f32_ty, llvm_v4f32_ty, llvm_v4f32_ty,
@@ -3506,41 +3517,41 @@
 
   def int_x86_avx512_rcp28_ps : GCCBuiltin<"__builtin_ia32_rcp28ps_mask">,
             Intrinsic<[llvm_v16f32_ty], [llvm_v16f32_ty, llvm_v16f32_ty,
-                                         llvm_i16_ty, llvm_i32_ty], [IntrNoMem, ImmArg<3>]>;
+                                         llvm_i16_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<3>>]>;
   def int_x86_avx512_rcp28_pd : GCCBuiltin<"__builtin_ia32_rcp28pd_mask">,
             Intrinsic<[llvm_v8f64_ty], [llvm_v8f64_ty, llvm_v8f64_ty,
-                                        llvm_i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<3>]>;
+                                        llvm_i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<3>>]>;
   def int_x86_avx512_exp2_ps : GCCBuiltin<"__builtin_ia32_exp2ps_mask">,
             Intrinsic<[llvm_v16f32_ty], [llvm_v16f32_ty, llvm_v16f32_ty,
-                                         llvm_i16_ty, llvm_i32_ty], [IntrNoMem, ImmArg<3>]>;
+                                         llvm_i16_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<3>>]>;
   def int_x86_avx512_exp2_pd : GCCBuiltin<"__builtin_ia32_exp2pd_mask">,
             Intrinsic<[llvm_v8f64_ty], [llvm_v8f64_ty, llvm_v8f64_ty,
-                                        llvm_i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<3>]>;
+                                        llvm_i8_ty, llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<3>>]>;
 
   def int_x86_avx512_rcp28_ss : GCCBuiltin<"__builtin_ia32_rcp28ss_round_mask">,
             Intrinsic<[llvm_v4f32_ty], [llvm_v4f32_ty, llvm_v4f32_ty,
                                         llvm_v4f32_ty, llvm_i8_ty, llvm_i32_ty],
-                      [IntrNoMem, ImmArg<4>]>;
+                      [IntrNoMem, ImmArg<ArgIndex<4>>]>;
   def int_x86_avx512_rcp28_sd : GCCBuiltin<"__builtin_ia32_rcp28sd_round_mask">,
             Intrinsic<[llvm_v2f64_ty], [llvm_v2f64_ty, llvm_v2f64_ty,
                                         llvm_v2f64_ty, llvm_i8_ty, llvm_i32_ty],
-                      [IntrNoMem, ImmArg<4>]>;
+                      [IntrNoMem, ImmArg<ArgIndex<4>>]>;
   def int_x86_avx512_rsqrt28_ps : GCCBuiltin<"__builtin_ia32_rsqrt28ps_mask">,
             Intrinsic<[llvm_v16f32_ty], [llvm_v16f32_ty, llvm_v16f32_ty,
                                          llvm_i16_ty, llvm_i32_ty],
-                      [IntrNoMem, ImmArg<3>]>;
+                      [IntrNoMem, ImmArg<ArgIndex<3>>]>;
   def int_x86_avx512_rsqrt28_pd : GCCBuiltin<"__builtin_ia32_rsqrt28pd_mask">,
             Intrinsic<[llvm_v8f64_ty], [llvm_v8f64_ty, llvm_v8f64_ty,
                                         llvm_i8_ty, llvm_i32_ty],
-                      [IntrNoMem, ImmArg<3>]>;
+                      [IntrNoMem, ImmArg<ArgIndex<3>>]>;
   def int_x86_avx512_rsqrt28_ss : GCCBuiltin<"__builtin_ia32_rsqrt28ss_round_mask">,
             Intrinsic<[llvm_v4f32_ty], [llvm_v4f32_ty, llvm_v4f32_ty,
                                         llvm_v4f32_ty, llvm_i8_ty, llvm_i32_ty],
-                      [IntrNoMem, ImmArg<4>]>;
+                      [IntrNoMem, ImmArg<ArgIndex<4>>]>;
   def int_x86_avx512_rsqrt28_sd : GCCBuiltin<"__builtin_ia32_rsqrt28sd_round_mask">,
             Intrinsic<[llvm_v2f64_ty], [llvm_v2f64_ty, llvm_v2f64_ty,
                                         llvm_v2f64_ty, llvm_i8_ty, llvm_i32_ty],
-                      [IntrNoMem, ImmArg<4>]>;
+                      [IntrNoMem, ImmArg<ArgIndex<4>>]>;
   def int_x86_avx512_psad_bw_512 : GCCBuiltin<"__builtin_ia32_psadbw512">,
               Intrinsic<[llvm_v8i64_ty], [llvm_v64i8_ty, llvm_v64i8_ty],
                         [IntrNoMem, Commutative]>;
@@ -3570,19 +3581,19 @@
          GCCBuiltin<"__builtin_ia32_dbpsadbw128">,
           Intrinsic<[llvm_v8i16_ty],
                     [llvm_v16i8_ty, llvm_v16i8_ty, llvm_i32_ty],
-                    [IntrNoMem, ImmArg<2>]>;
+                    [IntrNoMem, ImmArg<ArgIndex<2>>]>;
 
   def int_x86_avx512_dbpsadbw_256 :
          GCCBuiltin<"__builtin_ia32_dbpsadbw256">,
           Intrinsic<[llvm_v16i16_ty],
                     [llvm_v32i8_ty, llvm_v32i8_ty, llvm_i32_ty],
-                    [IntrNoMem, ImmArg<2>]>;
+                    [IntrNoMem, ImmArg<ArgIndex<2>>]>;
 
   def int_x86_avx512_dbpsadbw_512 :
          GCCBuiltin<"__builtin_ia32_dbpsadbw512">,
           Intrinsic<[llvm_v32i16_ty],
                     [llvm_v64i8_ty, llvm_v64i8_ty, llvm_i32_ty],
-                    [IntrNoMem, ImmArg<2>]>;
+                    [IntrNoMem, ImmArg<ArgIndex<2>>]>;
 }
 
 // Gather and Scatter ops
@@ -3593,117 +3604,117 @@
   def int_x86_avx512_gather_dpd_512  :
           Intrinsic<[llvm_v8f64_ty], [llvm_v8f64_ty, llvm_ptr_ty,
                      llvm_v8i32_ty, llvm_i8_ty, llvm_i32_ty],
-                    [IntrReadMem, ImmArg<4>]>;
+                    [IntrReadMem, ImmArg<ArgIndex<4>>]>;
   def int_x86_avx512_gather_dps_512  :
           Intrinsic<[llvm_v16f32_ty], [llvm_v16f32_ty, llvm_ptr_ty,
                      llvm_v16i32_ty, llvm_i16_ty, llvm_i32_ty],
-                    [IntrReadMem, ImmArg<4>]>;
+                    [IntrReadMem, ImmArg<ArgIndex<4>>]>;
   def int_x86_avx512_gather_qpd_512  :
           Intrinsic<[llvm_v8f64_ty], [llvm_v8f64_ty, llvm_ptr_ty,
                      llvm_v8i64_ty, llvm_i8_ty, llvm_i32_ty],
-                    [IntrReadMem, ImmArg<4>]>;
+                    [IntrReadMem, ImmArg<ArgIndex<4>>]>;
   def int_x86_avx512_gather_qps_512  :
           Intrinsic<[llvm_v8f32_ty], [llvm_v8f32_ty, llvm_ptr_ty,
                      llvm_v8i64_ty, llvm_i8_ty, llvm_i32_ty],
-                    [IntrReadMem, ImmArg<4>]>;
+                    [IntrReadMem, ImmArg<ArgIndex<4>>]>;
 
 
   def int_x86_avx512_gather_dpq_512  :
           Intrinsic<[llvm_v8i64_ty], [llvm_v8i64_ty, llvm_ptr_ty,
                      llvm_v8i32_ty, llvm_i8_ty, llvm_i32_ty],
-                    [IntrReadMem, ImmArg<4>]>;
+                    [IntrReadMem, ImmArg<ArgIndex<4>>]>;
   def int_x86_avx512_gather_dpi_512  :
           Intrinsic<[llvm_v16i32_ty], [llvm_v16i32_ty, llvm_ptr_ty,
                      llvm_v16i32_ty, llvm_i16_ty, llvm_i32_ty],
-                    [IntrReadMem, ImmArg<4>]>;
+                    [IntrReadMem, ImmArg<ArgIndex<4>>]>;
   def int_x86_avx512_gather_qpq_512  :
           Intrinsic<[llvm_v8i64_ty], [llvm_v8i64_ty, llvm_ptr_ty,
                      llvm_v8i64_ty, llvm_i8_ty, llvm_i32_ty],
-                    [IntrReadMem, ImmArg<4>]>;
+                    [IntrReadMem, ImmArg<ArgIndex<4>>]>;
   def int_x86_avx512_gather_qpi_512  :
           Intrinsic<[llvm_v8i32_ty], [llvm_v8i32_ty, llvm_ptr_ty,
                      llvm_v8i64_ty, llvm_i8_ty, llvm_i32_ty],
-                    [IntrReadMem, ImmArg<4>]>;
+                    [IntrReadMem, ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_gather3div2_df :
           Intrinsic<[llvm_v2f64_ty],
           [llvm_v2f64_ty, llvm_ptr_ty, llvm_v2i64_ty, llvm_i8_ty, llvm_i32_ty],
-          [IntrReadMem, ImmArg<4>]>;
+          [IntrReadMem, ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_gather3div2_di :
           Intrinsic<[llvm_v2i64_ty],
           [llvm_v2i64_ty, llvm_ptr_ty, llvm_v2i64_ty, llvm_i8_ty, llvm_i32_ty],
-          [IntrReadMem, ImmArg<4>]>;
+          [IntrReadMem, ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_gather3div4_df :
           Intrinsic<[llvm_v4f64_ty],
           [llvm_v4f64_ty, llvm_ptr_ty, llvm_v4i64_ty, llvm_i8_ty, llvm_i32_ty],
-          [IntrReadMem, ImmArg<4>]>;
+          [IntrReadMem, ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_gather3div4_di :
           Intrinsic<[llvm_v4i64_ty],
           [llvm_v4i64_ty, llvm_ptr_ty, llvm_v4i64_ty, llvm_i8_ty, llvm_i32_ty],
-          [IntrReadMem, ImmArg<4>]>;
+          [IntrReadMem, ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_gather3div4_sf :
           Intrinsic<[llvm_v4f32_ty],
           [llvm_v4f32_ty, llvm_ptr_ty, llvm_v2i64_ty, llvm_i8_ty, llvm_i32_ty],
-          [IntrReadMem, ImmArg<4>]>;
+          [IntrReadMem, ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_gather3div4_si :
           Intrinsic<[llvm_v4i32_ty],
           [llvm_v4i32_ty, llvm_ptr_ty, llvm_v2i64_ty, llvm_i8_ty, llvm_i32_ty],
-          [IntrReadMem, ImmArg<4>]>;
+          [IntrReadMem, ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_gather3div8_sf :
           Intrinsic<[llvm_v4f32_ty],
           [llvm_v4f32_ty, llvm_ptr_ty, llvm_v4i64_ty, llvm_i8_ty, llvm_i32_ty],
-          [IntrReadMem, ImmArg<4>]>;
+          [IntrReadMem, ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_gather3div8_si :
           Intrinsic<[llvm_v4i32_ty],
           [llvm_v4i32_ty, llvm_ptr_ty, llvm_v4i64_ty, llvm_i8_ty, llvm_i32_ty],
-          [IntrReadMem, ImmArg<4>]>;
+          [IntrReadMem, ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_gather3siv2_df :
           Intrinsic<[llvm_v2f64_ty],
           [llvm_v2f64_ty, llvm_ptr_ty, llvm_v4i32_ty, llvm_i8_ty, llvm_i32_ty],
-          [IntrReadMem, ImmArg<4>]>;
+          [IntrReadMem, ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_gather3siv2_di :
           Intrinsic<[llvm_v2i64_ty],
           [llvm_v2i64_ty, llvm_ptr_ty, llvm_v4i32_ty, llvm_i8_ty, llvm_i32_ty],
-          [IntrReadMem, ImmArg<4>]>;
+          [IntrReadMem, ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_gather3siv4_df :
           Intrinsic<[llvm_v4f64_ty],
           [llvm_v4f64_ty, llvm_ptr_ty, llvm_v4i32_ty, llvm_i8_ty, llvm_i32_ty],
-          [IntrReadMem, ImmArg<4>]>;
+          [IntrReadMem, ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_gather3siv4_di :
           Intrinsic<[llvm_v4i64_ty],
           [llvm_v4i64_ty, llvm_ptr_ty, llvm_v4i32_ty, llvm_i8_ty, llvm_i32_ty],
-          [IntrReadMem, ImmArg<4>]>;
+          [IntrReadMem, ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_gather3siv4_sf :
           Intrinsic<[llvm_v4f32_ty],
           [llvm_v4f32_ty, llvm_ptr_ty, llvm_v4i32_ty, llvm_i8_ty, llvm_i32_ty],
-          [IntrReadMem, ImmArg<4>]>;
+          [IntrReadMem, ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_gather3siv4_si :
           Intrinsic<[llvm_v4i32_ty],
           [llvm_v4i32_ty, llvm_ptr_ty, llvm_v4i32_ty, llvm_i8_ty, llvm_i32_ty],
-          [IntrReadMem, ImmArg<4>]>;
+          [IntrReadMem, ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_gather3siv8_sf :
           Intrinsic<[llvm_v8f32_ty],
           [llvm_v8f32_ty, llvm_ptr_ty, llvm_v8i32_ty, llvm_i8_ty, llvm_i32_ty],
-          [IntrReadMem, ImmArg<4>]>;
+          [IntrReadMem, ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_gather3siv8_si :
           Intrinsic<[llvm_v8i32_ty],
           [llvm_v8i32_ty, llvm_ptr_ty, llvm_v8i32_ty, llvm_i8_ty, llvm_i32_ty],
-          [IntrReadMem, ImmArg<4>]>;
+          [IntrReadMem, ImmArg<ArgIndex<4>>]>;
 
 // scatter
   // NOTE: These are deprecated in favor of the versions that take a vXi1 mask.
@@ -3712,149 +3723,149 @@
   def int_x86_avx512_scatter_dpd_512  :
           Intrinsic<[], [llvm_ptr_ty, llvm_i8_ty,
                         llvm_v8i32_ty, llvm_v8f64_ty, llvm_i32_ty],
-                    [ImmArg<4>]>;
+                    [ImmArg<ArgIndex<4>>]>;
   def int_x86_avx512_scatter_dps_512  :
           Intrinsic<[], [llvm_ptr_ty, llvm_i16_ty,
                        llvm_v16i32_ty, llvm_v16f32_ty, llvm_i32_ty],
-                    [ImmArg<4>]>;
+                    [ImmArg<ArgIndex<4>>]>;
   def int_x86_avx512_scatter_qpd_512  :
           Intrinsic<[], [llvm_ptr_ty, llvm_i8_ty,
                      llvm_v8i64_ty, llvm_v8f64_ty, llvm_i32_ty],
-                    [ImmArg<4>]>;
+                    [ImmArg<ArgIndex<4>>]>;
   def int_x86_avx512_scatter_qps_512  :
           Intrinsic<[], [llvm_ptr_ty, llvm_i8_ty,
                      llvm_v8i64_ty, llvm_v8f32_ty, llvm_i32_ty],
-                    [ImmArg<4>]>;
+                    [ImmArg<ArgIndex<4>>]>;
 
 
   def int_x86_avx512_scatter_dpq_512  :
           Intrinsic<[], [llvm_ptr_ty, llvm_i8_ty,
                          llvm_v8i32_ty, llvm_v8i64_ty, llvm_i32_ty],
-                    [ImmArg<4>]>;
+                    [ImmArg<ArgIndex<4>>]>;
   def int_x86_avx512_scatter_dpi_512  :
           Intrinsic<[], [llvm_ptr_ty, llvm_i16_ty,
                      llvm_v16i32_ty, llvm_v16i32_ty, llvm_i32_ty],
-                    [ImmArg<4>]>;
+                    [ImmArg<ArgIndex<4>>]>;
   def int_x86_avx512_scatter_qpq_512  :
           Intrinsic<[], [llvm_ptr_ty, llvm_i8_ty,llvm_v8i64_ty, llvm_v8i64_ty,
                          llvm_i32_ty],
-                    [ImmArg<4>]>;
+                    [ImmArg<ArgIndex<4>>]>;
   def int_x86_avx512_scatter_qpi_512  :
           Intrinsic<[], [llvm_ptr_ty, llvm_i8_ty, llvm_v8i64_ty, llvm_v8i32_ty,
                          llvm_i32_ty],
-                    [ImmArg<4>]>;
+                    [ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_scatterdiv2_df :
         Intrinsic<[],
         [llvm_ptr_ty, llvm_i8_ty, llvm_v2i64_ty, llvm_v2f64_ty, llvm_i32_ty],
-        [ImmArg<4>]>;
+        [ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_scatterdiv2_di :
           Intrinsic<[],
           [llvm_ptr_ty, llvm_i8_ty, llvm_v2i64_ty, llvm_v2i64_ty, llvm_i32_ty],
-          [ImmArg<4>]>;
+          [ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_scatterdiv4_df :
           Intrinsic<[],
           [llvm_ptr_ty, llvm_i8_ty, llvm_v4i64_ty, llvm_v4f64_ty, llvm_i32_ty],
-          [ImmArg<4>]>;
+          [ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_scatterdiv4_di :
           Intrinsic<[],
           [llvm_ptr_ty, llvm_i8_ty, llvm_v4i64_ty, llvm_v4i64_ty, llvm_i32_ty],
-          [ImmArg<4>]>;
+          [ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_scatterdiv4_sf :
           Intrinsic<[],
           [llvm_ptr_ty, llvm_i8_ty, llvm_v2i64_ty, llvm_v4f32_ty, llvm_i32_ty],
-          [ImmArg<4>]>;
+          [ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_scatterdiv4_si :
           Intrinsic<[],
           [llvm_ptr_ty, llvm_i8_ty, llvm_v2i64_ty, llvm_v4i32_ty, llvm_i32_ty],
-          [ImmArg<4>]>;
+          [ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_scatterdiv8_sf :
           Intrinsic<[],
           [llvm_ptr_ty, llvm_i8_ty, llvm_v4i64_ty, llvm_v4f32_ty, llvm_i32_ty],
-          [ImmArg<4>]>;
+          [ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_scatterdiv8_si :
           Intrinsic<[],
           [llvm_ptr_ty, llvm_i8_ty, llvm_v4i64_ty, llvm_v4i32_ty, llvm_i32_ty],
-          [ImmArg<4>]>;
+          [ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_scattersiv2_df :
           Intrinsic<[],
           [llvm_ptr_ty, llvm_i8_ty, llvm_v4i32_ty, llvm_v2f64_ty, llvm_i32_ty],
-          [ImmArg<4>]>;
+          [ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_scattersiv2_di :
           Intrinsic<[],
           [llvm_ptr_ty, llvm_i8_ty, llvm_v4i32_ty, llvm_v2i64_ty, llvm_i32_ty],
-          [ImmArg<4>]>;
+          [ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_scattersiv4_df :
           Intrinsic<[],
           [llvm_ptr_ty, llvm_i8_ty, llvm_v4i32_ty, llvm_v4f64_ty, llvm_i32_ty],
-          [ImmArg<4>]>;
+          [ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_scattersiv4_di :
           Intrinsic<[],
           [llvm_ptr_ty, llvm_i8_ty, llvm_v4i32_ty, llvm_v4i64_ty, llvm_i32_ty],
-          [ImmArg<4>]>;
+          [ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_scattersiv4_sf :
           Intrinsic<[],
           [llvm_ptr_ty, llvm_i8_ty, llvm_v4i32_ty, llvm_v4f32_ty, llvm_i32_ty],
-          [ImmArg<4>]>;
+          [ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_scattersiv4_si :
           Intrinsic<[],
           [llvm_ptr_ty, llvm_i8_ty, llvm_v4i32_ty, llvm_v4i32_ty, llvm_i32_ty],
-          [ImmArg<4>]>;
+          [ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_scattersiv8_sf :
           Intrinsic<[],
           [llvm_ptr_ty, llvm_i8_ty, llvm_v8i32_ty, llvm_v8f32_ty, llvm_i32_ty],
-          [ImmArg<4>]>;
+          [ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_scattersiv8_si :
           Intrinsic<[],
           [llvm_ptr_ty, llvm_i8_ty, llvm_v8i32_ty, llvm_v8i32_ty, llvm_i32_ty],
-          [ImmArg<4>]>;
+          [ImmArg<ArgIndex<4>>]>;
 
   // gather prefetch
   // NOTE: These can't be ArgMemOnly because you can put the address completely
   // in the index register.
   def int_x86_avx512_gatherpf_dpd_512  : GCCBuiltin<"__builtin_ia32_gatherpfdpd">,
           Intrinsic<[], [llvm_i8_ty, llvm_v8i32_ty, llvm_ptr_ty,
-                     llvm_i32_ty, llvm_i32_ty], [ImmArg<3>, ImmArg<4>]>;
+                     llvm_i32_ty, llvm_i32_ty], [ImmArg<ArgIndex<3>>, ImmArg<ArgIndex<4>>]>;
   def int_x86_avx512_gatherpf_dps_512  : GCCBuiltin<"__builtin_ia32_gatherpfdps">,
           Intrinsic<[], [llvm_i16_ty, llvm_v16i32_ty, llvm_ptr_ty,
-                     llvm_i32_ty, llvm_i32_ty], [ImmArg<3>, ImmArg<4>]>;
+                     llvm_i32_ty, llvm_i32_ty], [ImmArg<ArgIndex<3>>, ImmArg<ArgIndex<4>>]>;
   def int_x86_avx512_gatherpf_qpd_512  : GCCBuiltin<"__builtin_ia32_gatherpfqpd">,
           Intrinsic<[], [llvm_i8_ty, llvm_v8i64_ty, llvm_ptr_ty,
-                     llvm_i32_ty, llvm_i32_ty], [ImmArg<3>, ImmArg<4>]>;
+                     llvm_i32_ty, llvm_i32_ty], [ImmArg<ArgIndex<3>>, ImmArg<ArgIndex<4>>]>;
   def int_x86_avx512_gatherpf_qps_512  : GCCBuiltin<"__builtin_ia32_gatherpfqps">,
           Intrinsic<[], [llvm_i8_ty, llvm_v8i64_ty, llvm_ptr_ty,
-                     llvm_i32_ty, llvm_i32_ty], [ImmArg<3>, ImmArg<4>]>;
+                     llvm_i32_ty, llvm_i32_ty], [ImmArg<ArgIndex<3>>, ImmArg<ArgIndex<4>>]>;
 
   // scatter prefetch
   // NOTE: These can't be ArgMemOnly because you can put the address completely
   // in the index register.
   def int_x86_avx512_scatterpf_dpd_512  : GCCBuiltin<"__builtin_ia32_scatterpfdpd">,
           Intrinsic<[], [llvm_i8_ty, llvm_v8i32_ty, llvm_ptr_ty,
-                     llvm_i32_ty, llvm_i32_ty], [ImmArg<3>, ImmArg<4>]>;
+                     llvm_i32_ty, llvm_i32_ty], [ImmArg<ArgIndex<3>>, ImmArg<ArgIndex<4>>]>;
   def int_x86_avx512_scatterpf_dps_512  : GCCBuiltin<"__builtin_ia32_scatterpfdps">,
           Intrinsic<[], [llvm_i16_ty, llvm_v16i32_ty, llvm_ptr_ty,
-                     llvm_i32_ty, llvm_i32_ty], [ImmArg<3>, ImmArg<4>]>;
+                     llvm_i32_ty, llvm_i32_ty], [ImmArg<ArgIndex<3>>, ImmArg<ArgIndex<4>>]>;
   def int_x86_avx512_scatterpf_qpd_512  : GCCBuiltin<"__builtin_ia32_scatterpfqpd">,
           Intrinsic<[], [llvm_i8_ty, llvm_v8i64_ty, llvm_ptr_ty,
-                     llvm_i32_ty, llvm_i32_ty], [ImmArg<3>, ImmArg<4>]>;
+                     llvm_i32_ty, llvm_i32_ty], [ImmArg<ArgIndex<3>>, ImmArg<ArgIndex<4>>]>;
   def int_x86_avx512_scatterpf_qps_512  : GCCBuiltin<"__builtin_ia32_scatterpfqps">,
           Intrinsic<[], [llvm_i8_ty, llvm_v8i64_ty, llvm_ptr_ty,
-                     llvm_i32_ty, llvm_i32_ty], [ImmArg<3>, ImmArg<4>]>;
+                     llvm_i32_ty, llvm_i32_ty], [ImmArg<ArgIndex<3>>, ImmArg<ArgIndex<4>>]>;
 }
 
 // AVX512 gather/scatter intrinsics that use vXi1 masks.
@@ -3864,134 +3875,134 @@
   def int_x86_avx512_mask_gather_dpd_512  :
           Intrinsic<[llvm_v8f64_ty], [llvm_v8f64_ty, llvm_ptr_ty,
                      llvm_v8i32_ty, llvm_v8i1_ty, llvm_i32_ty],
-                    [IntrReadMem, ImmArg<4>]>;
+                    [IntrReadMem, ImmArg<ArgIndex<4>>]>;
   def int_x86_avx512_mask_gather_dps_512  :
           Intrinsic<[llvm_v16f32_ty], [llvm_v16f32_ty, llvm_ptr_ty,
                      llvm_v16i32_ty, llvm_v16i1_ty, llvm_i32_ty],
-                    [IntrReadMem, ImmArg<4>]>;
+                    [IntrReadMem, ImmArg<ArgIndex<4>>]>;
   def int_x86_avx512_mask_gather_qpd_512  :
           Intrinsic<[llvm_v8f64_ty], [llvm_v8f64_ty, llvm_ptr_ty,
                      llvm_v8i64_ty, llvm_v8i1_ty, llvm_i32_ty],
-                    [IntrReadMem, ImmArg<4>]>;
+                    [IntrReadMem, ImmArg<ArgIndex<4>>]>;
   def int_x86_avx512_mask_gather_qps_512  :
           Intrinsic<[llvm_v8f32_ty], [llvm_v8f32_ty, llvm_ptr_ty,
                      llvm_v8i64_ty, llvm_v8i1_ty, llvm_i32_ty],
-                    [IntrReadMem, ImmArg<4>]>;
+                    [IntrReadMem, ImmArg<ArgIndex<4>>]>;
 
 
   def int_x86_avx512_mask_gather_dpq_512  :
           Intrinsic<[llvm_v8i64_ty], [llvm_v8i64_ty, llvm_ptr_ty,
                      llvm_v8i32_ty, llvm_v8i1_ty, llvm_i32_ty],
-                    [IntrReadMem, ImmArg<4>]>;
+                    [IntrReadMem, ImmArg<ArgIndex<4>>]>;
   def int_x86_avx512_mask_gather_dpi_512  :
           Intrinsic<[llvm_v16i32_ty], [llvm_v16i32_ty, llvm_ptr_ty,
                      llvm_v16i32_ty, llvm_v16i1_ty, llvm_i32_ty],
-                    [IntrReadMem, ImmArg<4>]>;
+                    [IntrReadMem, ImmArg<ArgIndex<4>>]>;
   def int_x86_avx512_mask_gather_qpq_512  :
           Intrinsic<[llvm_v8i64_ty], [llvm_v8i64_ty, llvm_ptr_ty,
                      llvm_v8i64_ty, llvm_v8i1_ty, llvm_i32_ty],
-                    [IntrReadMem, ImmArg<4>]>;
+                    [IntrReadMem, ImmArg<ArgIndex<4>>]>;
   def int_x86_avx512_mask_gather_qpi_512  :
           Intrinsic<[llvm_v8i32_ty], [llvm_v8i32_ty, llvm_ptr_ty,
                      llvm_v8i64_ty, llvm_v8i1_ty, llvm_i32_ty],
-                    [IntrReadMem, ImmArg<4>]>;
+                    [IntrReadMem, ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_mask_gather3div2_df :
           Intrinsic<[llvm_v2f64_ty],
           [llvm_v2f64_ty, llvm_ptr_ty, llvm_v2i64_ty, llvm_v2i1_ty, llvm_i32_ty],
-          [IntrReadMem, ImmArg<4>]>;
+          [IntrReadMem, ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_mask_gather3div2_di :
           Intrinsic<[llvm_v2i64_ty],
           [llvm_v2i64_ty, llvm_ptr_ty, llvm_v2i64_ty, llvm_v2i1_ty, llvm_i32_ty],
-          [IntrReadMem, ImmArg<4>]>;
+          [IntrReadMem, ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_mask_gather3div4_df :
           Intrinsic<[llvm_v4f64_ty],
           [llvm_v4f64_ty, llvm_ptr_ty, llvm_v4i64_ty, llvm_v4i1_ty, llvm_i32_ty],
-          [IntrReadMem, ImmArg<4>]>;
+          [IntrReadMem, ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_mask_gather3div4_di :
           Intrinsic<[llvm_v4i64_ty],
           [llvm_v4i64_ty, llvm_ptr_ty, llvm_v4i64_ty, llvm_v4i1_ty, llvm_i32_ty],
-          [IntrReadMem, ImmArg<4>]>;
+          [IntrReadMem, ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_mask_gather3div4_sf :
           Intrinsic<[llvm_v4f32_ty],
           [llvm_v4f32_ty, llvm_ptr_ty, llvm_v2i64_ty, llvm_v2i1_ty, llvm_i32_ty],
-          [IntrReadMem, ImmArg<4>]>;
+          [IntrReadMem, ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_mask_gather3div4_si :
           Intrinsic<[llvm_v4i32_ty],
           [llvm_v4i32_ty, llvm_ptr_ty, llvm_v2i64_ty, llvm_v2i1_ty, llvm_i32_ty],
-          [IntrReadMem, ImmArg<4>]>;
+          [IntrReadMem, ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_mask_gather3div8_sf :
           Intrinsic<[llvm_v4f32_ty],
           [llvm_v4f32_ty, llvm_ptr_ty, llvm_v4i64_ty, llvm_v4i1_ty, llvm_i32_ty],
-          [IntrReadMem, ImmArg<4>]>;
+          [IntrReadMem, ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_mask_gather3div8_si :
           Intrinsic<[llvm_v4i32_ty],
           [llvm_v4i32_ty, llvm_ptr_ty, llvm_v4i64_ty, llvm_v4i1_ty, llvm_i32_ty],
-          [IntrReadMem, ImmArg<4>]>;
+          [IntrReadMem, ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_mask_gather3siv2_df :
           Intrinsic<[llvm_v2f64_ty],
           [llvm_v2f64_ty, llvm_ptr_ty, llvm_v4i32_ty, llvm_v2i1_ty, llvm_i32_ty],
-          [IntrReadMem, ImmArg<4>]>;
+          [IntrReadMem, ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_mask_gather3siv2_di :
           Intrinsic<[llvm_v2i64_ty],
           [llvm_v2i64_ty, llvm_ptr_ty, llvm_v4i32_ty, llvm_v2i1_ty, llvm_i32_ty],
-          [IntrReadMem, ImmArg<4>]>;
+          [IntrReadMem, ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_mask_gather3siv4_df :
           Intrinsic<[llvm_v4f64_ty],
           [llvm_v4f64_ty, llvm_ptr_ty, llvm_v4i32_ty, llvm_v4i1_ty, llvm_i32_ty],
-          [IntrReadMem, ImmArg<4>]>;
+          [IntrReadMem, ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_mask_gather3siv4_di :
           Intrinsic<[llvm_v4i64_ty],
           [llvm_v4i64_ty, llvm_ptr_ty, llvm_v4i32_ty, llvm_v4i1_ty, llvm_i32_ty],
-          [IntrReadMem, ImmArg<4>]>;
+          [IntrReadMem, ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_mask_gather3siv4_sf :
           Intrinsic<[llvm_v4f32_ty],
           [llvm_v4f32_ty, llvm_ptr_ty, llvm_v4i32_ty, llvm_v4i1_ty, llvm_i32_ty],
-          [IntrReadMem, ImmArg<4>]>;
+          [IntrReadMem, ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_mask_gather3siv4_si :
           Intrinsic<[llvm_v4i32_ty],
           [llvm_v4i32_ty, llvm_ptr_ty, llvm_v4i32_ty, llvm_v4i1_ty, llvm_i32_ty],
-          [IntrReadMem, ImmArg<4>]>;
+          [IntrReadMem, ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_mask_gather3siv8_sf :
           Intrinsic<[llvm_v8f32_ty],
           [llvm_v8f32_ty, llvm_ptr_ty, llvm_v8i32_ty, llvm_v8i1_ty, llvm_i32_ty],
-          [IntrReadMem, ImmArg<4>]>;
+          [IntrReadMem, ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_mask_gather3siv8_si :
           Intrinsic<[llvm_v8i32_ty],
           [llvm_v8i32_ty, llvm_ptr_ty, llvm_v8i32_ty, llvm_v8i1_ty, llvm_i32_ty],
-          [IntrReadMem, ImmArg<4>]>;
+          [IntrReadMem, ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_mask_scatter_dpd_512  :
           Intrinsic<[], [llvm_ptr_ty, llvm_v8i1_ty,
                         llvm_v8i32_ty, llvm_v8f64_ty, llvm_i32_ty],
-                    [ImmArg<4>]>;
+                    [ImmArg<ArgIndex<4>>]>;
   def int_x86_avx512_mask_scatter_dps_512  :
           Intrinsic<[], [llvm_ptr_ty, llvm_v16i1_ty,
                        llvm_v16i32_ty, llvm_v16f32_ty, llvm_i32_ty],
-                    [ImmArg<4>]>;
+                    [ImmArg<ArgIndex<4>>]>;
   def int_x86_avx512_mask_scatter_qpd_512  :
           Intrinsic<[], [llvm_ptr_ty, llvm_v8i1_ty,
                      llvm_v8i64_ty, llvm_v8f64_ty, llvm_i32_ty],
-                    [ImmArg<4>]>;
+                    [ImmArg<ArgIndex<4>>]>;
   def int_x86_avx512_mask_scatter_qps_512  :
           Intrinsic<[], [llvm_ptr_ty, llvm_v8i1_ty,
                      llvm_v8i64_ty, llvm_v8f32_ty, llvm_i32_ty],
-                    [ImmArg<4>]>;
+                    [ImmArg<ArgIndex<4>>]>;
 
 
   // NOTE: These can't be ArgMemOnly because you can put the address completely
@@ -3999,99 +4010,99 @@
   def int_x86_avx512_mask_scatter_dpq_512  :
           Intrinsic<[], [llvm_ptr_ty, llvm_v8i1_ty,
                          llvm_v8i32_ty, llvm_v8i64_ty, llvm_i32_ty],
-                    [ImmArg<4>]>;
+                    [ImmArg<ArgIndex<4>>]>;
   def int_x86_avx512_mask_scatter_dpi_512  :
           Intrinsic<[], [llvm_ptr_ty, llvm_v16i1_ty,
                      llvm_v16i32_ty, llvm_v16i32_ty, llvm_i32_ty],
-                    [ImmArg<4>]>;
+                    [ImmArg<ArgIndex<4>>]>;
   def int_x86_avx512_mask_scatter_qpq_512  :
           Intrinsic<[], [llvm_ptr_ty, llvm_v8i1_ty,llvm_v8i64_ty, llvm_v8i64_ty,
                          llvm_i32_ty],
-                    [ImmArg<4>]>;
+                    [ImmArg<ArgIndex<4>>]>;
   def int_x86_avx512_mask_scatter_qpi_512  :
           Intrinsic<[], [llvm_ptr_ty, llvm_v8i1_ty, llvm_v8i64_ty, llvm_v8i32_ty,
                          llvm_i32_ty],
-                    [ImmArg<4>]>;
+                    [ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_mask_scatterdiv2_df :
         Intrinsic<[],
         [llvm_ptr_ty, llvm_v2i1_ty, llvm_v2i64_ty, llvm_v2f64_ty, llvm_i32_ty],
-        [ImmArg<4>]>;
+        [ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_mask_scatterdiv2_di :
           Intrinsic<[],
           [llvm_ptr_ty, llvm_v2i1_ty, llvm_v2i64_ty, llvm_v2i64_ty, llvm_i32_ty],
-          [ImmArg<4>]>;
+          [ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_mask_scatterdiv4_df :
           Intrinsic<[],
           [llvm_ptr_ty, llvm_v4i1_ty, llvm_v4i64_ty, llvm_v4f64_ty, llvm_i32_ty],
-          [ImmArg<4>]>;
+          [ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_mask_scatterdiv4_di :
           Intrinsic<[],
           [llvm_ptr_ty, llvm_v4i1_ty, llvm_v4i64_ty, llvm_v4i64_ty, llvm_i32_ty],
-          [ImmArg<4>]>;
+          [ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_mask_scatterdiv4_sf :
           Intrinsic<[],
           [llvm_ptr_ty, llvm_v2i1_ty, llvm_v2i64_ty, llvm_v4f32_ty, llvm_i32_ty],
-          [ImmArg<4>]>;
+          [ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_mask_scatterdiv4_si :
           Intrinsic<[],
           [llvm_ptr_ty, llvm_v2i1_ty, llvm_v2i64_ty, llvm_v4i32_ty, llvm_i32_ty],
-          [ImmArg<4>]>;
+          [ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_mask_scatterdiv8_sf :
           Intrinsic<[],
           [llvm_ptr_ty, llvm_v4i1_ty, llvm_v4i64_ty, llvm_v4f32_ty, llvm_i32_ty],
-          [ImmArg<4>]>;
+          [ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_mask_scatterdiv8_si :
           Intrinsic<[],
           [llvm_ptr_ty, llvm_v4i1_ty, llvm_v4i64_ty, llvm_v4i32_ty, llvm_i32_ty],
-          [ImmArg<4>]>;
+          [ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_mask_scattersiv2_df :
           Intrinsic<[],
           [llvm_ptr_ty, llvm_v2i1_ty, llvm_v4i32_ty, llvm_v2f64_ty, llvm_i32_ty],
-          [ImmArg<4>]>;
+          [ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_mask_scattersiv2_di :
           Intrinsic<[],
           [llvm_ptr_ty, llvm_v2i1_ty, llvm_v4i32_ty, llvm_v2i64_ty, llvm_i32_ty],
-          [ImmArg<4>]>;
+          [ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_mask_scattersiv4_df :
           Intrinsic<[],
           [llvm_ptr_ty, llvm_v4i1_ty, llvm_v4i32_ty, llvm_v4f64_ty, llvm_i32_ty],
-          [ImmArg<4>]>;
+          [ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_mask_scattersiv4_di :
           Intrinsic<[],
           [llvm_ptr_ty, llvm_v4i1_ty, llvm_v4i32_ty, llvm_v4i64_ty, llvm_i32_ty],
-          [ImmArg<4>]>;
+          [ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_mask_scattersiv4_sf :
           Intrinsic<[],
           [llvm_ptr_ty, llvm_v4i1_ty, llvm_v4i32_ty, llvm_v4f32_ty, llvm_i32_ty],
-          [ImmArg<4>]>;
+          [ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_mask_scattersiv4_si :
           Intrinsic<[],
           [llvm_ptr_ty, llvm_v4i1_ty, llvm_v4i32_ty, llvm_v4i32_ty, llvm_i32_ty],
-          [ImmArg<4>]>;
+          [ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_mask_scattersiv8_sf :
           Intrinsic<[],
           [llvm_ptr_ty, llvm_v8i1_ty, llvm_v8i32_ty, llvm_v8f32_ty, llvm_i32_ty],
-          [ImmArg<4>]>;
+          [ImmArg<ArgIndex<4>>]>;
 
   def int_x86_avx512_mask_scattersiv8_si :
           Intrinsic<[],
           [llvm_ptr_ty, llvm_v8i1_ty, llvm_v8i32_ty, llvm_v8i32_ty, llvm_i32_ty],
-          [ImmArg<4>]>;
+          [ImmArg<ArgIndex<4>>]>;
 }
 
 // AVX-512 conflict detection instruction
@@ -4124,11 +4135,11 @@
   def int_x86_avx512_vcomi_sd : GCCBuiltin<"__builtin_ia32_vcomisd">,
               Intrinsic<[llvm_i32_ty], [llvm_v2f64_ty,
                          llvm_v2f64_ty, llvm_i32_ty, llvm_i32_ty],
-                        [IntrNoMem, ImmArg<2>, ImmArg<3>]>;
+                        [IntrNoMem, ImmArg<ArgIndex<2>>, ImmArg<ArgIndex<3>>]>;
   def int_x86_avx512_vcomi_ss : GCCBuiltin<"__builtin_ia32_vcomiss">,
               Intrinsic<[llvm_i32_ty], [llvm_v4f32_ty,
                          llvm_v4f32_ty, llvm_i32_ty, llvm_i32_ty],
-                        [IntrNoMem, ImmArg<2>, ImmArg<3>]>;
+                        [IntrNoMem, ImmArg<ArgIndex<2>>, ImmArg<ArgIndex<3>>]>;
 }
 
 // Compress, Expand
@@ -4672,37 +4683,37 @@
           GCCBuiltin<"__builtin_ia32_pternlogd128">,
           Intrinsic<[llvm_v4i32_ty],
                     [llvm_v4i32_ty, llvm_v4i32_ty, llvm_v4i32_ty, llvm_i32_ty],
-                    [IntrNoMem, ImmArg<3>]>;
+                    [IntrNoMem, ImmArg<ArgIndex<3>>]>;
 
   def int_x86_avx512_pternlog_d_256 :
           GCCBuiltin<"__builtin_ia32_pternlogd256">,
           Intrinsic<[llvm_v8i32_ty],
                     [llvm_v8i32_ty, llvm_v8i32_ty, llvm_v8i32_ty, llvm_i32_ty],
-                    [IntrNoMem, ImmArg<3>]>;
+                    [IntrNoMem, ImmArg<ArgIndex<3>>]>;
 
   def int_x86_avx512_pternlog_d_512 :
           GCCBuiltin<"__builtin_ia32_pternlogd512">,
           Intrinsic<[llvm_v16i32_ty],
                     [llvm_v16i32_ty, llvm_v16i32_ty, llvm_v16i32_ty,
-                     llvm_i32_ty], [IntrNoMem, ImmArg<3>]>;
+                     llvm_i32_ty], [IntrNoMem, ImmArg<ArgIndex<3>>]>;
 
   def int_x86_avx512_pternlog_q_128 :
           GCCBuiltin<"__builtin_ia32_pternlogq128">,
           Intrinsic<[llvm_v2i64_ty],
                     [llvm_v2i64_ty, llvm_v2i64_ty, llvm_v2i64_ty, llvm_i32_ty],
-                    [IntrNoMem, ImmArg<3>]>;
+                    [IntrNoMem, ImmArg<ArgIndex<3>>]>;
 
   def int_x86_avx512_pternlog_q_256 :
           GCCBuiltin<"__builtin_ia32_pternlogq256">,
           Intrinsic<[llvm_v4i64_ty],
                     [llvm_v4i64_ty, llvm_v4i64_ty, llvm_v4i64_ty, llvm_i32_ty],
-                    [IntrNoMem, ImmArg<3>]>;
+                    [IntrNoMem, ImmArg<ArgIndex<3>>]>;
 
   def int_x86_avx512_pternlog_q_512 :
           GCCBuiltin<"__builtin_ia32_pternlogq512">,
           Intrinsic<[llvm_v8i64_ty],
                     [llvm_v8i64_ty, llvm_v8i64_ty, llvm_v8i64_ty, llvm_i32_ty],
-                    [IntrNoMem, ImmArg<3>]>;
+                    [IntrNoMem, ImmArg<ArgIndex<3>>]>;
 }
 
 // vp2intersect
@@ -4737,37 +4748,37 @@
 let TargetPrefix = "x86" in {
   // NOTE: These comparison intrinsics are not used by clang as long as the
   //       distinction in signaling behaviour is not implemented.
-  def int_x86_avx512_cmp_ps_512 :
+  def int_x86_avx512_mask_cmp_ps_512 :
               Intrinsic<[llvm_v16i1_ty], [llvm_v16f32_ty, llvm_v16f32_ty,
-                         llvm_i32_ty, llvm_i32_ty],
-                        [IntrNoMem, ImmArg<2>, ImmArg<3>]>;
-  def int_x86_avx512_cmp_pd_512 :
+                         llvm_i32_ty, llvm_v16i1_ty, llvm_i32_ty],
+                        [IntrNoMem, ImmArg<ArgIndex<2>>, ImmArg<ArgIndex<4>>]>;
+  def int_x86_avx512_mask_cmp_pd_512 :
               Intrinsic<[llvm_v8i1_ty], [llvm_v8f64_ty, llvm_v8f64_ty,
-                         llvm_i32_ty, llvm_i32_ty],
-                        [IntrNoMem, ImmArg<2>, ImmArg<3>]>;
-  def int_x86_avx512_cmp_ps_256 :
+                         llvm_i32_ty, llvm_v8i1_ty, llvm_i32_ty],
+                        [IntrNoMem, ImmArg<ArgIndex<2>>, ImmArg<ArgIndex<4>>]>;
+  def int_x86_avx512_mask_cmp_ps_256 :
               Intrinsic<[llvm_v8i1_ty], [llvm_v8f32_ty, llvm_v8f32_ty,
-                         llvm_i32_ty], [IntrNoMem, ImmArg<2>]>;
-  def int_x86_avx512_cmp_pd_256 :
+                         llvm_i32_ty, llvm_v8i1_ty], [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+  def int_x86_avx512_mask_cmp_pd_256 :
               Intrinsic<[llvm_v4i1_ty], [llvm_v4f64_ty, llvm_v4f64_ty,
-                         llvm_i32_ty], [IntrNoMem, ImmArg<2>]>;
-  def int_x86_avx512_cmp_ps_128 :
+                         llvm_i32_ty, llvm_v4i1_ty], [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+  def int_x86_avx512_mask_cmp_ps_128 :
             Intrinsic<[llvm_v4i1_ty], [llvm_v4f32_ty, llvm_v4f32_ty,
-                       llvm_i32_ty], [IntrNoMem, ImmArg<2>]>;
-  def int_x86_avx512_cmp_pd_128 :
+                       llvm_i32_ty, llvm_v4i1_ty], [IntrNoMem, ImmArg<ArgIndex<2>>]>;
+  def int_x86_avx512_mask_cmp_pd_128 :
             Intrinsic<[llvm_v2i1_ty], [llvm_v2f64_ty, llvm_v2f64_ty,
-                       llvm_i32_ty], [IntrNoMem, ImmArg<2>]>;
+                       llvm_i32_ty, llvm_v2i1_ty], [IntrNoMem, ImmArg<ArgIndex<2>>]>;
 
   def int_x86_avx512_mask_cmp_ss :
         GCCBuiltin<"__builtin_ia32_cmpss_mask">,
               Intrinsic<[llvm_i8_ty], [llvm_v4f32_ty, llvm_v4f32_ty,
                          llvm_i32_ty, llvm_i8_ty, llvm_i32_ty],
-                        [IntrNoMem, ImmArg<2>, ImmArg<4>]>;
+                        [IntrNoMem, ImmArg<ArgIndex<2>>, ImmArg<ArgIndex<4>>]>;
   def int_x86_avx512_mask_cmp_sd :
         GCCBuiltin<"__builtin_ia32_cmpsd_mask">,
               Intrinsic<[llvm_i8_ty], [llvm_v2f64_ty, llvm_v2f64_ty,
                          llvm_i32_ty, llvm_i8_ty, llvm_i32_ty],
-                        [IntrNoMem, ImmArg<2>, ImmArg<4>]>;
+                        [IntrNoMem, ImmArg<ArgIndex<2>>, ImmArg<ArgIndex<4>>]>;
 }
 
 //===----------------------------------------------------------------------===//
@@ -4775,7 +4786,7 @@
 let TargetPrefix = "x86" in {
   def int_x86_sha1rnds4 : GCCBuiltin<"__builtin_ia32_sha1rnds4">,
         Intrinsic<[llvm_v4i32_ty], [llvm_v4i32_ty, llvm_v4i32_ty, llvm_i8_ty],
-                  [IntrNoMem, ImmArg<2>]>;
+                  [IntrNoMem, ImmArg<ArgIndex<2>>]>;
   def int_x86_sha1nexte : GCCBuiltin<"__builtin_ia32_sha1nexte">,
       Intrinsic<[llvm_v4i32_ty], [llvm_v4i32_ty, llvm_v4i32_ty], [IntrNoMem]>;
   def int_x86_sha1msg1 : GCCBuiltin<"__builtin_ia32_sha1msg1">,
@@ -4918,3 +4929,150 @@
   def int_x86_enqcmds : GCCBuiltin<"__builtin_ia32_enqcmds">,
               Intrinsic<[llvm_i8_ty], [llvm_ptr_ty, llvm_ptr_ty], []>;
 }
+
+//===----------------------------------------------------------------------===//
+// SERIALIZE - Serialize instruction fetch and execution
+
+let TargetPrefix = "x86" in {
+  def int_x86_serialize : GCCBuiltin<"__builtin_ia32_serialize">,
+              Intrinsic<[], [], []>;
+}
+
+//===----------------------------------------------------------------------===//
+// TSXLDTRK - TSX Suspend Load Address Tracking
+
+let TargetPrefix = "x86" in {
+  def int_x86_xsusldtrk : GCCBuiltin<"__builtin_ia32_xsusldtrk">,
+              Intrinsic<[], [], []>;
+  def int_x86_xresldtrk : GCCBuiltin<"__builtin_ia32_xresldtrk">,
+              Intrinsic<[], [], []>;
+}
+
+//===----------------------------------------------------------------------===//
+// Key Locker
+let TargetPrefix = "x86" in {
+  def int_x86_loadiwkey : GCCBuiltin<"__builtin_ia32_loadiwkey">,
+      Intrinsic<[], [llvm_v2i64_ty, llvm_v2i64_ty, llvm_v2i64_ty, llvm_i32_ty],
+                []>;
+  def int_x86_encodekey128 :
+      Intrinsic<[llvm_i32_ty, llvm_v2i64_ty, llvm_v2i64_ty,
+                 llvm_v2i64_ty, llvm_v2i64_ty, llvm_v2i64_ty, llvm_v2i64_ty],
+                [llvm_i32_ty, llvm_v2i64_ty], []>;
+  def int_x86_encodekey256 :
+      Intrinsic<[llvm_i32_ty, llvm_v2i64_ty, llvm_v2i64_ty, llvm_v2i64_ty,
+                 llvm_v2i64_ty, llvm_v2i64_ty, llvm_v2i64_ty, llvm_v2i64_ty],
+                [llvm_i32_ty, llvm_v2i64_ty, llvm_v2i64_ty], []>;
+  def int_x86_aesenc128kl :
+      Intrinsic<[llvm_i8_ty, llvm_v2i64_ty], [llvm_v2i64_ty, llvm_ptr_ty], []>;
+  def int_x86_aesdec128kl :
+      Intrinsic<[llvm_i8_ty, llvm_v2i64_ty], [llvm_v2i64_ty, llvm_ptr_ty], []>;
+  def int_x86_aesenc256kl :
+      Intrinsic<[llvm_i8_ty, llvm_v2i64_ty], [llvm_v2i64_ty, llvm_ptr_ty], []>;
+  def int_x86_aesdec256kl :
+      Intrinsic<[llvm_i8_ty, llvm_v2i64_ty], [llvm_v2i64_ty, llvm_ptr_ty], []>;
+  def int_x86_aesencwide128kl :
+      Intrinsic<[llvm_i8_ty, llvm_v2i64_ty, llvm_v2i64_ty,
+                 llvm_v2i64_ty, llvm_v2i64_ty, llvm_v2i64_ty,
+                 llvm_v2i64_ty, llvm_v2i64_ty, llvm_v2i64_ty],
+                [llvm_ptr_ty, llvm_v2i64_ty, llvm_v2i64_ty,
+                 llvm_v2i64_ty, llvm_v2i64_ty, llvm_v2i64_ty,
+                 llvm_v2i64_ty, llvm_v2i64_ty, llvm_v2i64_ty], []>;
+  def int_x86_aesdecwide128kl :
+      Intrinsic<[llvm_i8_ty, llvm_v2i64_ty, llvm_v2i64_ty,
+                 llvm_v2i64_ty, llvm_v2i64_ty, llvm_v2i64_ty,
+                 llvm_v2i64_ty, llvm_v2i64_ty, llvm_v2i64_ty],
+                [llvm_ptr_ty, llvm_v2i64_ty, llvm_v2i64_ty,
+                 llvm_v2i64_ty, llvm_v2i64_ty, llvm_v2i64_ty,
+                 llvm_v2i64_ty, llvm_v2i64_ty, llvm_v2i64_ty], []>;
+  def int_x86_aesencwide256kl :
+      Intrinsic<[llvm_i8_ty, llvm_v2i64_ty, llvm_v2i64_ty,
+                 llvm_v2i64_ty, llvm_v2i64_ty, llvm_v2i64_ty,
+                 llvm_v2i64_ty, llvm_v2i64_ty, llvm_v2i64_ty],
+                [llvm_ptr_ty, llvm_v2i64_ty, llvm_v2i64_ty,
+                 llvm_v2i64_ty, llvm_v2i64_ty, llvm_v2i64_ty,
+                 llvm_v2i64_ty, llvm_v2i64_ty, llvm_v2i64_ty], []>;
+  def int_x86_aesdecwide256kl :
+      Intrinsic<[llvm_i8_ty, llvm_v2i64_ty, llvm_v2i64_ty,
+                 llvm_v2i64_ty, llvm_v2i64_ty, llvm_v2i64_ty,
+                 llvm_v2i64_ty, llvm_v2i64_ty, llvm_v2i64_ty],
+                [llvm_ptr_ty, llvm_v2i64_ty, llvm_v2i64_ty,
+                 llvm_v2i64_ty, llvm_v2i64_ty, llvm_v2i64_ty,
+                 llvm_v2i64_ty, llvm_v2i64_ty, llvm_v2i64_ty], []>;
+}
+
+//===----------------------------------------------------------------------===//
+// AMX - Intel AMX extensions
+
+let TargetPrefix = "x86" in {
+  def int_x86_ldtilecfg : GCCBuiltin<"__builtin_ia32_tile_loadconfig">,
+              Intrinsic<[], [llvm_ptr_ty], []>;
+  def int_x86_sttilecfg : GCCBuiltin<"__builtin_ia32_tile_storeconfig">,
+              Intrinsic<[], [llvm_ptr_ty], []>;
+  def int_x86_tilerelease : GCCBuiltin<"__builtin_ia32_tilerelease">,
+              Intrinsic<[], [], []>;
+  def int_x86_tilezero : GCCBuiltin<"__builtin_ia32_tilezero">,
+              Intrinsic<[], [llvm_i8_ty], [ImmArg<ArgIndex<0>>]>;
+  def int_x86_tileloadd64 : GCCBuiltin<"__builtin_ia32_tileloadd64">,
+              Intrinsic<[], [llvm_i8_ty, llvm_ptr_ty, llvm_i64_ty],
+                        [ImmArg<ArgIndex<0>>]>;
+  def int_x86_tileloaddt164 : GCCBuiltin<"__builtin_ia32_tileloaddt164">,
+              Intrinsic<[], [llvm_i8_ty, llvm_ptr_ty, llvm_i64_ty],
+                        [ImmArg<ArgIndex<0>>]>;
+  def int_x86_tilestored64 : GCCBuiltin<"__builtin_ia32_tilestored64">,
+              Intrinsic<[], [llvm_i8_ty, llvm_ptr_ty, llvm_i64_ty],
+                        [ImmArg<ArgIndex<0>>]>;
+  def int_x86_tdpbssd : GCCBuiltin<"__builtin_ia32_tdpbssd">,
+              Intrinsic<[], [llvm_i8_ty, llvm_i8_ty, llvm_i8_ty],
+                        [ImmArg<ArgIndex<0>>, ImmArg<ArgIndex<1>>,
+                         ImmArg<ArgIndex<2>>]>;
+  def int_x86_tdpbsud : GCCBuiltin<"__builtin_ia32_tdpbsud">,
+              Intrinsic<[], [llvm_i8_ty, llvm_i8_ty, llvm_i8_ty],
+                        [ImmArg<ArgIndex<0>>, ImmArg<ArgIndex<1>>,
+                         ImmArg<ArgIndex<2>>]>;
+  def int_x86_tdpbusd : GCCBuiltin<"__builtin_ia32_tdpbusd">,
+              Intrinsic<[], [llvm_i8_ty, llvm_i8_ty, llvm_i8_ty],
+                        [ImmArg<ArgIndex<0>>, ImmArg<ArgIndex<1>>,
+                         ImmArg<ArgIndex<2>>]>;
+  def int_x86_tdpbuud : GCCBuiltin<"__builtin_ia32_tdpbuud">,
+              Intrinsic<[], [llvm_i8_ty, llvm_i8_ty, llvm_i8_ty],
+                        [ImmArg<ArgIndex<0>>, ImmArg<ArgIndex<1>>,
+                         ImmArg<ArgIndex<2>>]>;
+  def int_x86_tdpbf16ps : GCCBuiltin<"__builtin_ia32_tdpbf16ps">,
+              Intrinsic<[], [llvm_i8_ty, llvm_i8_ty, llvm_i8_ty],
+                        [ImmArg<ArgIndex<0>>, ImmArg<ArgIndex<1>>,
+                         ImmArg<ArgIndex<2>>]>;
+  // AMX - internal intrinsics
+  def int_x86_tileloadd64_internal :
+              GCCBuiltin<"__builtin_ia32_tileloadd64_internal">,
+              Intrinsic<[llvm_x86amx_ty],
+                        [llvm_i16_ty, llvm_i16_ty, llvm_ptr_ty, llvm_i64_ty],
+                        []>;
+  def int_x86_tdpbssd_internal :
+              GCCBuiltin<"__builtin_ia32_tdpbssd_internal">,
+              Intrinsic<[llvm_x86amx_ty],
+                        [llvm_i16_ty, llvm_i16_ty, llvm_i16_ty,
+                         llvm_x86amx_ty, llvm_x86amx_ty,
+                         llvm_x86amx_ty], []>;
+  def int_x86_tilestored64_internal :
+              GCCBuiltin<"__builtin_ia32_tilestored64_internal">,
+              Intrinsic<[], [llvm_i16_ty, llvm_i16_ty, llvm_ptr_ty,
+                             llvm_i64_ty, llvm_x86amx_ty], []>;
+  def int_x86_tilezero_internal :
+              GCCBuiltin<"__builtin_ia32_tilezero_internal">,
+              Intrinsic<[llvm_x86amx_ty], [llvm_i16_ty, llvm_i16_ty],
+                        []>;
+}
+
+//===----------------------------------------------------------------------===//
+// UINTR - User Level Interrupt
+
+let TargetPrefix = "x86" in {
+  def int_x86_clui : GCCBuiltin<"__builtin_ia32_clui">,
+              Intrinsic<[], [], []>;
+  def int_x86_stui : GCCBuiltin<"__builtin_ia32_stui">,
+              Intrinsic<[], [], []>;
+  def int_x86_testui : GCCBuiltin<"__builtin_ia32_testui">,
+              Intrinsic<[llvm_i8_ty], [], []>;
+  def int_x86_senduipi : GCCBuiltin<"__builtin_ia32_senduipi">,
+              Intrinsic<[], [llvm_i64_ty], []>;
+}
diff --git a/linux-x64/clang/include/llvm/IR/IntrinsicsXCore.h b/linux-x64/clang/include/llvm/IR/IntrinsicsXCore.h
new file mode 100644
index 0000000..a0de124
--- /dev/null
+++ b/linux-x64/clang/include/llvm/IR/IntrinsicsXCore.h
@@ -0,0 +1,73 @@
+/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
+|*                                                                            *|
+|* Intrinsic Function Source Fragment                                         *|
+|*                                                                            *|
+|* Automatically generated file, do not edit!                                 *|
+|*                                                                            *|
+\*===----------------------------------------------------------------------===*/
+
+#ifndef LLVM_IR_INTRINSIC_XCORE_ENUMS_H
+#define LLVM_IR_INTRINSIC_XCORE_ENUMS_H
+
+namespace llvm {
+namespace Intrinsic {
+enum XCOREIntrinsics : unsigned {
+// Enum values for intrinsics
+    xcore_bitrev = 9706,                              // llvm.xcore.bitrev
+    xcore_checkevent,                          // llvm.xcore.checkevent
+    xcore_chkct,                               // llvm.xcore.chkct
+    xcore_clre,                                // llvm.xcore.clre
+    xcore_clrpt,                               // llvm.xcore.clrpt
+    xcore_clrsr,                               // llvm.xcore.clrsr
+    xcore_crc32,                               // llvm.xcore.crc32
+    xcore_crc8,                                // llvm.xcore.crc8
+    xcore_edu,                                 // llvm.xcore.edu
+    xcore_eeu,                                 // llvm.xcore.eeu
+    xcore_endin,                               // llvm.xcore.endin
+    xcore_freer,                               // llvm.xcore.freer
+    xcore_geted,                               // llvm.xcore.geted
+    xcore_getet,                               // llvm.xcore.getet
+    xcore_getid,                               // llvm.xcore.getid
+    xcore_getps,                               // llvm.xcore.getps
+    xcore_getr,                                // llvm.xcore.getr
+    xcore_getst,                               // llvm.xcore.getst
+    xcore_getts,                               // llvm.xcore.getts
+    xcore_in,                                  // llvm.xcore.in
+    xcore_inct,                                // llvm.xcore.inct
+    xcore_initcp,                              // llvm.xcore.initcp
+    xcore_initdp,                              // llvm.xcore.initdp
+    xcore_initlr,                              // llvm.xcore.initlr
+    xcore_initpc,                              // llvm.xcore.initpc
+    xcore_initsp,                              // llvm.xcore.initsp
+    xcore_inshr,                               // llvm.xcore.inshr
+    xcore_int,                                 // llvm.xcore.int
+    xcore_mjoin,                               // llvm.xcore.mjoin
+    xcore_msync,                               // llvm.xcore.msync
+    xcore_out,                                 // llvm.xcore.out
+    xcore_outct,                               // llvm.xcore.outct
+    xcore_outshr,                              // llvm.xcore.outshr
+    xcore_outt,                                // llvm.xcore.outt
+    xcore_peek,                                // llvm.xcore.peek
+    xcore_setc,                                // llvm.xcore.setc
+    xcore_setclk,                              // llvm.xcore.setclk
+    xcore_setd,                                // llvm.xcore.setd
+    xcore_setev,                               // llvm.xcore.setev
+    xcore_setps,                               // llvm.xcore.setps
+    xcore_setpsc,                              // llvm.xcore.setpsc
+    xcore_setpt,                               // llvm.xcore.setpt
+    xcore_setrdy,                              // llvm.xcore.setrdy
+    xcore_setsr,                               // llvm.xcore.setsr
+    xcore_settw,                               // llvm.xcore.settw
+    xcore_setv,                                // llvm.xcore.setv
+    xcore_sext,                                // llvm.xcore.sext
+    xcore_ssync,                               // llvm.xcore.ssync
+    xcore_syncr,                               // llvm.xcore.syncr
+    xcore_testct,                              // llvm.xcore.testct
+    xcore_testwct,                             // llvm.xcore.testwct
+    xcore_waitevent,                           // llvm.xcore.waitevent
+    xcore_zext,                                // llvm.xcore.zext
+}; // enum
+} // namespace Intrinsic
+} // namespace llvm
+
+#endif
diff --git a/linux-x64/clang/include/llvm/IR/IntrinsicsXCore.td b/linux-x64/clang/include/llvm/IR/IntrinsicsXCore.td
index 7fe8bdf..89dbc65 100644
--- a/linux-x64/clang/include/llvm/IR/IntrinsicsXCore.td
+++ b/linux-x64/clang/include/llvm/IR/IntrinsicsXCore.td
@@ -38,58 +38,58 @@
   // Resource instructions.
   def int_xcore_getr : Intrinsic<[llvm_anyptr_ty],[llvm_i32_ty]>;
   def int_xcore_freer : Intrinsic<[],[llvm_anyptr_ty],
-                                   [NoCapture<0>]>;
-  def int_xcore_in : Intrinsic<[llvm_i32_ty],[llvm_anyptr_ty],[NoCapture<0>]>;
+                                   [NoCapture<ArgIndex<0>>]>;
+  def int_xcore_in : Intrinsic<[llvm_i32_ty],[llvm_anyptr_ty],[NoCapture<ArgIndex<0>>]>;
   def int_xcore_int : Intrinsic<[llvm_i32_ty],[llvm_anyptr_ty],
-                                [NoCapture<0>]>;
+                                [NoCapture<ArgIndex<0>>]>;
   def int_xcore_inct : Intrinsic<[llvm_i32_ty],[llvm_anyptr_ty],
-                                 [NoCapture<0>]>;
+                                 [NoCapture<ArgIndex<0>>]>;
   def int_xcore_out : Intrinsic<[],[llvm_anyptr_ty, llvm_i32_ty],
-                                [NoCapture<0>]>;
+                                [NoCapture<ArgIndex<0>>]>;
   def int_xcore_outt : Intrinsic<[],[llvm_anyptr_ty, llvm_i32_ty],
-                                 [NoCapture<0>]>;
+                                 [NoCapture<ArgIndex<0>>]>;
   def int_xcore_outct : Intrinsic<[],[llvm_anyptr_ty, llvm_i32_ty],
-                                  [NoCapture<0>]>;
+                                  [NoCapture<ArgIndex<0>>]>;
   def int_xcore_chkct : Intrinsic<[],[llvm_anyptr_ty, llvm_i32_ty],
-                                  [NoCapture<0>]>;
+                                  [NoCapture<ArgIndex<0>>]>;
   def int_xcore_testct : Intrinsic<[llvm_i32_ty],[llvm_anyptr_ty],
-                                   [NoCapture<0>]>;
+                                   [NoCapture<ArgIndex<0>>]>;
   def int_xcore_testwct : Intrinsic<[llvm_i32_ty],[llvm_anyptr_ty],
-                                    [NoCapture<0>]>;
+                                    [NoCapture<ArgIndex<0>>]>;
   def int_xcore_setd : Intrinsic<[],[llvm_anyptr_ty, llvm_i32_ty],
-                                  [NoCapture<0>]>;
+                                  [NoCapture<ArgIndex<0>>]>;
   def int_xcore_setc : Intrinsic<[],[llvm_anyptr_ty, llvm_i32_ty],
-                                  [NoCapture<0>]>;
+                                  [NoCapture<ArgIndex<0>>]>;
   def int_xcore_inshr : Intrinsic<[llvm_i32_ty],[llvm_anyptr_ty, llvm_i32_ty],
-                                  [NoCapture<0>]>;
+                                  [NoCapture<ArgIndex<0>>]>;
   def int_xcore_outshr : Intrinsic<[llvm_i32_ty],[llvm_anyptr_ty, llvm_i32_ty],
-                                  [NoCapture<0>]>;
+                                  [NoCapture<ArgIndex<0>>]>;
   def int_xcore_setpt : Intrinsic<[],[llvm_anyptr_ty, llvm_i32_ty],
-                                  [NoCapture<0>]>;
+                                  [NoCapture<ArgIndex<0>>]>;
   def int_xcore_clrpt : Intrinsic<[],[llvm_anyptr_ty],
-                                  [NoCapture<0>]>;
+                                  [NoCapture<ArgIndex<0>>]>;
   def int_xcore_getts : Intrinsic<[llvm_i32_ty],[llvm_anyptr_ty],
-                                  [NoCapture<0>]>;
+                                  [NoCapture<ArgIndex<0>>]>;
   def int_xcore_syncr : Intrinsic<[],[llvm_anyptr_ty],
-                                  [NoCapture<0>]>;
+                                  [NoCapture<ArgIndex<0>>]>;
   def int_xcore_settw : Intrinsic<[],[llvm_anyptr_ty, llvm_i32_ty],
-                                  [NoCapture<0>]>;
+                                  [NoCapture<ArgIndex<0>>]>;
   def int_xcore_setv : Intrinsic<[],[llvm_anyptr_ty, llvm_ptr_ty],
-                                 [NoCapture<0>]>;
+                                 [NoCapture<ArgIndex<0>>]>;
   def int_xcore_setev : Intrinsic<[],[llvm_anyptr_ty, llvm_ptr_ty],
-                                  [NoCapture<0>]>;
-  def int_xcore_eeu : Intrinsic<[],[llvm_anyptr_ty], [NoCapture<0>]>;
-  def int_xcore_edu : Intrinsic<[],[llvm_anyptr_ty], [NoCapture<0>]>;
+                                  [NoCapture<ArgIndex<0>>]>;
+  def int_xcore_eeu : Intrinsic<[],[llvm_anyptr_ty], [NoCapture<ArgIndex<0>>]>;
+  def int_xcore_edu : Intrinsic<[],[llvm_anyptr_ty], [NoCapture<ArgIndex<0>>]>;
   def int_xcore_setclk : Intrinsic<[],[llvm_anyptr_ty, llvm_anyptr_ty],
-                                   [NoCapture<0>, NoCapture<1>]>;
+                                   [NoCapture<ArgIndex<0>>, NoCapture<ArgIndex<1>>]>;
   def int_xcore_setrdy : Intrinsic<[],[llvm_anyptr_ty, llvm_anyptr_ty],
-                                   [NoCapture<0>, NoCapture<1>]>;
+                                   [NoCapture<ArgIndex<0>>, NoCapture<ArgIndex<1>>]>;
   def int_xcore_setpsc : Intrinsic<[],[llvm_anyptr_ty, llvm_i32_ty],
-                                   [NoCapture<0>]>;
+                                   [NoCapture<ArgIndex<0>>]>;
   def int_xcore_peek : Intrinsic<[llvm_i32_ty],[llvm_anyptr_ty],
-                                 [NoCapture<0>]>;
+                                 [NoCapture<ArgIndex<0>>]>;
   def int_xcore_endin : Intrinsic<[llvm_i32_ty],[llvm_anyptr_ty],
-                                 [NoCapture<0>]>;
+                                 [NoCapture<ArgIndex<0>>]>;
 
   // Intrinsics for events.
   def int_xcore_waitevent : Intrinsic<[llvm_ptr_ty],[], [IntrReadMem]>;
@@ -103,18 +103,18 @@
 
   // Intrinsics for threads.
   def int_xcore_getst : Intrinsic <[llvm_anyptr_ty],[llvm_anyptr_ty],
-                                   [NoCapture<0>]>;
-  def int_xcore_msync : Intrinsic <[],[llvm_anyptr_ty], [NoCapture<0>]>;
+                                   [NoCapture<ArgIndex<0>>]>;
+  def int_xcore_msync : Intrinsic <[],[llvm_anyptr_ty], [NoCapture<ArgIndex<0>>]>;
   def int_xcore_ssync : Intrinsic <[],[]>;
-  def int_xcore_mjoin : Intrinsic <[],[llvm_anyptr_ty], [NoCapture<0>]>;
+  def int_xcore_mjoin : Intrinsic <[],[llvm_anyptr_ty], [NoCapture<ArgIndex<0>>]>;
   def int_xcore_initsp : Intrinsic <[],[llvm_anyptr_ty, llvm_ptr_ty],
-                                    [NoCapture<0>]>;
+                                    [NoCapture<ArgIndex<0>>]>;
   def int_xcore_initpc : Intrinsic <[],[llvm_anyptr_ty, llvm_ptr_ty],
-                                    [NoCapture<0>]>;
+                                    [NoCapture<ArgIndex<0>>]>;
   def int_xcore_initlr : Intrinsic <[],[llvm_anyptr_ty, llvm_ptr_ty],
-                                    [NoCapture<0>]>;
+                                    [NoCapture<ArgIndex<0>>]>;
   def int_xcore_initcp : Intrinsic <[],[llvm_anyptr_ty, llvm_ptr_ty],
-                                    [NoCapture<0>]>;
+                                    [NoCapture<ArgIndex<0>>]>;
   def int_xcore_initdp : Intrinsic <[],[llvm_anyptr_ty, llvm_ptr_ty],
-                                    [NoCapture<0>]>;
+                                    [NoCapture<ArgIndex<0>>]>;
 }
diff --git a/linux-x64/clang/include/llvm/IR/LLVMContext.h b/linux-x64/clang/include/llvm/IR/LLVMContext.h
index c805045..8f8a35d 100644
--- a/linux-x64/clang/include/llvm/IR/LLVMContext.h
+++ b/linux-x64/clang/include/llvm/IR/LLVMContext.h
@@ -17,7 +17,6 @@
 #include "llvm-c/Types.h"
 #include "llvm/IR/DiagnosticHandler.h"
 #include "llvm/Support/CBindingWrapping.h"
-#include "llvm/Support/Options.h"
 #include <cstdint>
 #include <memory>
 #include <string>
@@ -32,12 +31,17 @@
 class Module;
 class OptPassGate;
 template <typename T> class SmallVectorImpl;
+template <typename T> class StringMapEntry;
 class SMDiagnostic;
 class StringRef;
 class Twine;
-class RemarkStreamer;
+class LLVMRemarkStreamer;
 class raw_ostream;
 
+namespace remarks {
+class RemarkStreamer;
+}
+
 namespace SyncScope {
 
 typedef uint8_t ID;
@@ -72,44 +76,23 @@
   // Pinned metadata names, which always have the same value.  This is a
   // compile-time performance optimization, not a correctness optimization.
   enum : unsigned {
-    MD_dbg = 0,                       // "dbg"
-    MD_tbaa = 1,                      // "tbaa"
-    MD_prof = 2,                      // "prof"
-    MD_fpmath = 3,                    // "fpmath"
-    MD_range = 4,                     // "range"
-    MD_tbaa_struct = 5,               // "tbaa.struct"
-    MD_invariant_load = 6,            // "invariant.load"
-    MD_alias_scope = 7,               // "alias.scope"
-    MD_noalias = 8,                   // "noalias",
-    MD_nontemporal = 9,               // "nontemporal"
-    MD_mem_parallel_loop_access = 10, // "llvm.mem.parallel_loop_access"
-    MD_nonnull = 11,                  // "nonnull"
-    MD_dereferenceable = 12,          // "dereferenceable"
-    MD_dereferenceable_or_null = 13,  // "dereferenceable_or_null"
-    MD_make_implicit = 14,            // "make.implicit"
-    MD_unpredictable = 15,            // "unpredictable"
-    MD_invariant_group = 16,          // "invariant.group"
-    MD_align = 17,                    // "align"
-    MD_loop = 18,                     // "llvm.loop"
-    MD_type = 19,                     // "type"
-    MD_section_prefix = 20,           // "section_prefix"
-    MD_absolute_symbol = 21,          // "absolute_symbol"
-    MD_associated = 22,               // "associated"
-    MD_callees = 23,                  // "callees"
-    MD_irr_loop = 24,                 // "irr_loop"
-    MD_access_group = 25,             // "llvm.access.group"
-    MD_callback = 26,                 // "callback"
-    MD_preserve_access_index = 27,    // "llvm.preserve.*.access.index"
+#define LLVM_FIXED_MD_KIND(EnumID, Name, Value) EnumID = Value,
+#include "llvm/IR/FixedMetadataKinds.def"
+#undef LLVM_FIXED_MD_KIND
   };
 
   /// Known operand bundle tag IDs, which always have the same value.  All
   /// operand bundle tags that LLVM has special knowledge of are listed here.
   /// Additionally, this scheme allows LLVM to efficiently check for specific
-  /// operand bundle tags without comparing strings.
+  /// operand bundle tags without comparing strings. Keep this in sync with
+  /// LLVMContext::LLVMContext().
   enum : unsigned {
     OB_deopt = 0,         // "deopt"
     OB_funclet = 1,       // "funclet"
     OB_gc_transition = 2, // "gc-transition"
+    OB_cfguardtarget = 3, // "cfguardtarget"
+    OB_preallocated = 4,  // "preallocated"
+    OB_gc_live = 5,       // "gc-live"
   };
 
   /// getMDKindID - Return a unique non-zero ID for the specified metadata kind.
@@ -126,6 +109,10 @@
   /// \see LLVMContext::getOperandBundleTagID
   void getOperandBundleTags(SmallVectorImpl<StringRef> &Result) const;
 
+  /// getOrInsertBundleTag - Returns the Tag to use for an operand bundle of
+  /// name TagName.
+  StringMapEntry<uint32_t> *getOrInsertBundleTag(StringRef TagName) const;
+
   /// getOperandBundleTagID - Maps a bundle tag to an integer ID.  Every bundle
   /// tag registered with an LLVMContext has an unique ID.
   uint32_t getOperandBundleTagID(StringRef Tag) const;
@@ -235,31 +222,45 @@
   void setDiagnosticsHotnessRequested(bool Requested);
 
   /// Return the minimum hotness value a diagnostic would need in order
-  /// to be included in optimization diagnostics. If there is no minimum, this
-  /// returns None.
+  /// to be included in optimization diagnostics.
+  ///
+  /// Three possible return values:
+  /// 0            - threshold is disabled. Everything will be printed out.
+  /// positive int - threshold is set.
+  /// UINT64_MAX   - threshold is not yet set, and needs to be synced from
+  ///                profile summary. Note that in case of missing profile
+  ///                summary, threshold will be kept at "MAX", effectively
+  ///                suppresses all remarks output.
   uint64_t getDiagnosticsHotnessThreshold() const;
 
   /// Set the minimum hotness value a diagnostic needs in order to be
   /// included in optimization diagnostics.
-  void setDiagnosticsHotnessThreshold(uint64_t Threshold);
+  void setDiagnosticsHotnessThreshold(Optional<uint64_t> Threshold);
 
-  /// Return the streamer used by the backend to save remark diagnostics. If it
-  /// does not exist, diagnostics are not saved in a file but only emitted via
-  /// the diagnostic handler.
-  RemarkStreamer *getRemarkStreamer();
-  const RemarkStreamer *getRemarkStreamer() const;
+  /// Return if hotness threshold is requested from PSI.
+  bool isDiagnosticsHotnessThresholdSetFromPSI() const;
 
-  /// Set the diagnostics output used for optimization diagnostics.
-  /// This filename may be embedded in a section for tools to find the
-  /// diagnostics whenever they're needed.
+  /// The "main remark streamer" used by all the specialized remark streamers.
+  /// This streamer keeps generic remark metadata in memory throughout the life
+  /// of the LLVMContext. This metadata may be emitted in a section in object
+  /// files depending on the format requirements.
   ///
-  /// If a remark streamer is already set, it will be replaced with
-  /// \p RemarkStreamer.
+  /// All specialized remark streamers should convert remarks to
+  /// llvm::remarks::Remark and emit them through this streamer.
+  remarks::RemarkStreamer *getMainRemarkStreamer();
+  const remarks::RemarkStreamer *getMainRemarkStreamer() const;
+  void setMainRemarkStreamer(
+      std::unique_ptr<remarks::RemarkStreamer> MainRemarkStreamer);
+
+  /// The "LLVM remark streamer" used by LLVM to serialize remark diagnostics
+  /// comming from IR and MIR passes.
   ///
-  /// By default, diagnostics are not saved in a file but only emitted via the
-  /// diagnostic handler.  Even if an output file is set, the handler is invoked
-  /// for each diagnostic message.
-  void setRemarkStreamer(std::unique_ptr<RemarkStreamer> RemarkStreamer);
+  /// If it does not exist, diagnostics are not saved in a file but only emitted
+  /// via the diagnostic handler.
+  LLVMRemarkStreamer *getLLVMRemarkStreamer();
+  const LLVMRemarkStreamer *getLLVMRemarkStreamer() const;
+  void
+  setLLVMRemarkStreamer(std::unique_ptr<LLVMRemarkStreamer> RemarkStreamer);
 
   /// Get the prefix that should be printed in front of a diagnostic of
   ///        the given \p Severity
@@ -312,14 +313,6 @@
   void emitError(const Instruction *I, const Twine &ErrorStr);
   void emitError(const Twine &ErrorStr);
 
-  /// Query for a debug option's value.
-  ///
-  /// This function returns typed data populated from command line parsing.
-  template <typename ValT, typename Base, ValT(Base::*Mem)>
-  ValT getOption() const {
-    return OptionRegistry::instance().template get<ValT, Base, Mem>();
-  }
-
   /// Access the object which can disable optional passes and individual
   /// optimizations at compile time.
   OptPassGate &getOptPassGate() const;
diff --git a/linux-x64/clang/include/llvm/IR/LLVMRemarkStreamer.h b/linux-x64/clang/include/llvm/IR/LLVMRemarkStreamer.h
new file mode 100644
index 0000000..e7627e9
--- /dev/null
+++ b/linux-x64/clang/include/llvm/IR/LLVMRemarkStreamer.h
@@ -0,0 +1,94 @@
+//===- llvm/IR/LLVMRemarkStreamer.h - Streamer for LLVM remarks--*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements the conversion between IR Diagnostics and
+// serializable remarks::Remark objects.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_IR_LLVMREMARKSTREAMER_H
+#define LLVM_IR_LLVMREMARKSTREAMER_H
+
+#include "llvm/IR/DiagnosticInfo.h"
+#include "llvm/Remarks/RemarkStreamer.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/ToolOutputFile.h"
+#include <memory>
+#include <string>
+
+namespace llvm {
+/// Streamer for LLVM remarks which has logic for dealing with DiagnosticInfo
+/// objects.
+class LLVMRemarkStreamer {
+  remarks::RemarkStreamer &RS;
+  /// Convert diagnostics into remark objects.
+  /// The lifetime of the members of the result is bound to the lifetime of
+  /// the LLVM diagnostics.
+  remarks::Remark toRemark(const DiagnosticInfoOptimizationBase &Diag) const;
+
+public:
+  LLVMRemarkStreamer(remarks::RemarkStreamer &RS) : RS(RS) {}
+  /// Emit a diagnostic through the streamer.
+  void emit(const DiagnosticInfoOptimizationBase &Diag);
+};
+
+template <typename ThisError>
+struct LLVMRemarkSetupErrorInfo : public ErrorInfo<ThisError> {
+  std::string Msg;
+  std::error_code EC;
+
+  LLVMRemarkSetupErrorInfo(Error E) {
+    handleAllErrors(std::move(E), [&](const ErrorInfoBase &EIB) {
+      Msg = EIB.message();
+      EC = EIB.convertToErrorCode();
+    });
+  }
+
+  void log(raw_ostream &OS) const override { OS << Msg; }
+  std::error_code convertToErrorCode() const override { return EC; }
+};
+
+struct LLVMRemarkSetupFileError
+    : LLVMRemarkSetupErrorInfo<LLVMRemarkSetupFileError> {
+  static char ID;
+  using LLVMRemarkSetupErrorInfo<
+      LLVMRemarkSetupFileError>::LLVMRemarkSetupErrorInfo;
+};
+
+struct LLVMRemarkSetupPatternError
+    : LLVMRemarkSetupErrorInfo<LLVMRemarkSetupPatternError> {
+  static char ID;
+  using LLVMRemarkSetupErrorInfo<
+      LLVMRemarkSetupPatternError>::LLVMRemarkSetupErrorInfo;
+};
+
+struct LLVMRemarkSetupFormatError
+    : LLVMRemarkSetupErrorInfo<LLVMRemarkSetupFormatError> {
+  static char ID;
+  using LLVMRemarkSetupErrorInfo<
+      LLVMRemarkSetupFormatError>::LLVMRemarkSetupErrorInfo;
+};
+
+/// Setup optimization remarks that output to a file.
+Expected<std::unique_ptr<ToolOutputFile>>
+setupLLVMOptimizationRemarks(LLVMContext &Context, StringRef RemarksFilename,
+                             StringRef RemarksPasses, StringRef RemarksFormat,
+                             bool RemarksWithHotness,
+                             Optional<uint64_t> RemarksHotnessThreshold = 0);
+
+/// Setup optimization remarks that output directly to a raw_ostream.
+/// \p OS is managed by the caller and should be open for writing as long as \p
+/// Context is streaming remarks to it.
+Error setupLLVMOptimizationRemarks(
+    LLVMContext &Context, raw_ostream &OS, StringRef RemarksPasses,
+    StringRef RemarksFormat, bool RemarksWithHotness,
+    Optional<uint64_t> RemarksHotnessThreshold = 0);
+
+} // end namespace llvm
+
+#endif // LLVM_IR_LLVMREMARKSTREAMER_H
diff --git a/linux-x64/clang/include/llvm/IR/LegacyPassManager.h b/linux-x64/clang/include/llvm/IR/LegacyPassManager.h
index d6bb79a..2b87143 100644
--- a/linux-x64/clang/include/llvm/IR/LegacyPassManager.h
+++ b/linux-x64/clang/include/llvm/IR/LegacyPassManager.h
@@ -63,7 +63,7 @@
   PassManagerImpl *PM;
 };
 
-/// FunctionPassManager manages FunctionPasses and BasicBlockPassManagers.
+/// FunctionPassManager manages FunctionPasses.
 class FunctionPassManager : public PassManagerBase {
 public:
   /// FunctionPassManager ctor - This initializes the pass manager.  It needs,
diff --git a/linux-x64/clang/include/llvm/IR/LegacyPassManagers.h b/linux-x64/clang/include/llvm/IR/LegacyPassManagers.h
index 72bc80f..498e736 100644
--- a/linux-x64/clang/include/llvm/IR/LegacyPassManagers.h
+++ b/linux-x64/clang/include/llvm/IR/LegacyPassManagers.h
@@ -53,10 +53,6 @@
 // a place to implement common pass manager APIs. All pass managers derive from
 // PMDataManager.
 //
-// [o] class BBPassManager : public FunctionPass, public PMDataManager;
-//
-// BBPassManager manages BasicBlockPasses.
-//
 // [o] class FunctionPassManager;
 //
 // This is a external interface used to manage FunctionPasses. This
@@ -92,7 +88,6 @@
 namespace llvm {
 template <typename T> class ArrayRef;
 class Module;
-class Pass;
 class StringRef;
 class Value;
 class Timer;
@@ -103,7 +98,6 @@
   EXECUTION_MSG, // "Executing Pass '" + PassName
   MODIFICATION_MSG, // "Made Modification '" + PassName
   FREEING_MSG, // " Freeing Pass '" + PassName
-  ON_BASICBLOCK_MSG, // "' on BasicBlock '" + InstructionName + "'...\n"
   ON_FUNCTION_MSG, // "' on Function '" + FunctionName + "'...\n"
   ON_MODULE_MSG, // "' on Module '" + ModuleName + "'...\n"
   ON_REGION_MSG, // "' on Region '" + Msg + "'...\n'"
@@ -335,7 +329,8 @@
   /// through getAnalysis interface.
   virtual void addLowerLevelRequiredPass(Pass *P, Pass *RequiredPass);
 
-  virtual Pass *getOnTheFlyPass(Pass *P, AnalysisID PI, Function &F);
+  virtual std::tuple<Pass *, bool> getOnTheFlyPass(Pass *P, AnalysisID PI,
+                                                   Function &F);
 
   /// Initialize available analysis information.
   void initializeAnalysisInfo() {
diff --git a/linux-x64/clang/include/llvm/IR/LegacyPassNameParser.h b/linux-x64/clang/include/llvm/IR/LegacyPassNameParser.h
index 30820e7..c33b9fc 100644
--- a/linux-x64/clang/include/llvm/IR/LegacyPassNameParser.h
+++ b/linux-x64/clang/include/llvm/IR/LegacyPassNameParser.h
@@ -92,47 +92,6 @@
   }
 };
 
-///===----------------------------------------------------------------------===//
-/// FilteredPassNameParser class - Make use of the pass registration
-/// mechanism to automatically add a command line argument to opt for
-/// each pass that satisfies a filter criteria.  Filter should return
-/// true for passes to be registered as command-line options.
-///
-template<typename Filter>
-class FilteredPassNameParser : public PassNameParser {
-private:
-  Filter filter;
-
-public:
-  bool ignorablePassImpl(const PassInfo *P) const override {
-    return !filter(*P);
-  }
-};
-
-///===----------------------------------------------------------------------===//
-/// PassArgFilter - A filter for use with PassNameFilterParser that only
-/// accepts a Pass whose Arg matches certain strings.
-///
-/// Use like this:
-///
-/// extern const char AllowedPassArgs[] = "-anders_aa -dse";
-///
-/// static cl::list<
-///   const PassInfo*,
-///   bool,
-///   FilteredPassNameParser<PassArgFilter<AllowedPassArgs> > >
-/// PassList(cl::desc("Passes available:"));
-///
-/// Only the -anders_aa and -dse options will be available to the user.
-///
-template<const char *Args>
-class PassArgFilter {
-public:
-  bool operator()(const PassInfo &P) const {
-    return StringRef(Args).contains(P.getPassArgument());
-  }
-};
-
 } // End llvm namespace
 
 #endif
diff --git a/linux-x64/clang/include/llvm/IR/MDBuilder.h b/linux-x64/clang/include/llvm/IR/MDBuilder.h
index 3a2b1bd..51be866 100644
--- a/linux-x64/clang/include/llvm/IR/MDBuilder.h
+++ b/linux-x64/clang/include/llvm/IR/MDBuilder.h
@@ -16,6 +16,7 @@
 
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/IR/Constants.h"
 #include "llvm/IR/GlobalValue.h"
 #include "llvm/Support/DataTypes.h"
 #include <utility>
@@ -75,6 +76,9 @@
   /// Return metadata containing the section prefix for a function.
   MDNode *createFunctionSectionPrefix(StringRef Prefix);
 
+  /// Return metadata containing the pseudo probe descriptor for a function.
+  MDNode *createPseudoProbeDesc(uint64_t GUID, uint64_t Hash, Function *F);
+
   //===------------------------------------------------------------------===//
   // Range metadata.
   //===------------------------------------------------------------------===//
diff --git a/linux-x64/clang/include/llvm/IR/Mangler.h b/linux-x64/clang/include/llvm/IR/Mangler.h
index e4a05ab..747a408 100644
--- a/linux-x64/clang/include/llvm/IR/Mangler.h
+++ b/linux-x64/clang/include/llvm/IR/Mangler.h
@@ -14,11 +14,11 @@
 #define LLVM_IR_MANGLER_H
 
 #include "llvm/ADT/DenseMap.h"
-#include "llvm/IR/GlobalValue.h"
 
 namespace llvm {
 
 class DataLayout;
+class GlobalValue;
 template <typename T> class SmallVectorImpl;
 class Triple;
 class Twine;
diff --git a/linux-x64/clang/include/llvm/IR/MatrixBuilder.h b/linux-x64/clang/include/llvm/IR/MatrixBuilder.h
new file mode 100644
index 0000000..084b1d4
--- /dev/null
+++ b/linux-x64/clang/include/llvm/IR/MatrixBuilder.h
@@ -0,0 +1,236 @@
+//===- llvm/MatrixBuilder.h - Builder to lower matrix ops -------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the MatrixBuilder class, which is used as a convenient way
+// to lower matrix operations to LLVM IR.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_IR_MATRIXBUILDER_H
+#define LLVM_IR_MATRIXBUILDER_H
+
+#include "llvm/IR/Constant.h"
+#include "llvm/IR/Constants.h"
+#include "llvm/IR/IRBuilder.h"
+#include "llvm/IR/InstrTypes.h"
+#include "llvm/IR/Instruction.h"
+#include "llvm/IR/IntrinsicInst.h"
+#include "llvm/IR/Type.h"
+#include "llvm/IR/Value.h"
+#include "llvm/Support/Alignment.h"
+
+namespace llvm {
+
+class Function;
+class Twine;
+class Module;
+
+template <class IRBuilderTy> class MatrixBuilder {
+  IRBuilderTy &B;
+  Module *getModule() { return B.GetInsertBlock()->getParent()->getParent(); }
+
+  std::pair<Value *, Value *> splatScalarOperandIfNeeded(Value *LHS,
+                                                         Value *RHS) {
+    assert((LHS->getType()->isVectorTy() || RHS->getType()->isVectorTy()) &&
+           "One of the operands must be a matrix (embedded in a vector)");
+    if (LHS->getType()->isVectorTy() && !RHS->getType()->isVectorTy()) {
+      assert(!isa<ScalableVectorType>(LHS->getType()) &&
+             "LHS Assumed to be fixed width");
+      RHS = B.CreateVectorSplat(
+          cast<VectorType>(LHS->getType())->getElementCount(), RHS,
+          "scalar.splat");
+    } else if (!LHS->getType()->isVectorTy() && RHS->getType()->isVectorTy()) {
+      assert(!isa<ScalableVectorType>(RHS->getType()) &&
+             "RHS Assumed to be fixed width");
+      LHS = B.CreateVectorSplat(
+          cast<VectorType>(RHS->getType())->getElementCount(), LHS,
+          "scalar.splat");
+    }
+    return {LHS, RHS};
+  }
+
+public:
+  MatrixBuilder(IRBuilderTy &Builder) : B(Builder) {}
+
+  /// Create a column major, strided matrix load.
+  /// \p DataPtr - Start address of the matrix read
+  /// \p Rows    - Number of rows in matrix (must be a constant)
+  /// \p Columns - Number of columns in matrix (must be a constant)
+  /// \p Stride  - Space between columns
+  CallInst *CreateColumnMajorLoad(Value *DataPtr, Align Alignment,
+                                  Value *Stride, bool IsVolatile, unsigned Rows,
+                                  unsigned Columns, const Twine &Name = "") {
+
+    // Deal with the pointer
+    PointerType *PtrTy = cast<PointerType>(DataPtr->getType());
+    Type *EltTy = PtrTy->getElementType();
+
+    auto *RetType = FixedVectorType::get(EltTy, Rows * Columns);
+
+    Value *Ops[] = {DataPtr, Stride, B.getInt1(IsVolatile), B.getInt32(Rows),
+                    B.getInt32(Columns)};
+    Type *OverloadedTypes[] = {RetType};
+
+    Function *TheFn = Intrinsic::getDeclaration(
+        getModule(), Intrinsic::matrix_column_major_load, OverloadedTypes);
+
+    CallInst *Call = B.CreateCall(TheFn->getFunctionType(), TheFn, Ops, Name);
+    Attribute AlignAttr =
+        Attribute::getWithAlignment(Call->getContext(), Alignment);
+    Call->addAttribute(1, AlignAttr);
+    return Call;
+  }
+
+  /// Create a column major, strided matrix store.
+  /// \p Matrix  - Matrix to store
+  /// \p Ptr     - Pointer to write back to
+  /// \p Stride  - Space between columns
+  CallInst *CreateColumnMajorStore(Value *Matrix, Value *Ptr, Align Alignment,
+                                   Value *Stride, bool IsVolatile,
+                                   unsigned Rows, unsigned Columns,
+                                   const Twine &Name = "") {
+    Value *Ops[] = {Matrix,           Ptr,
+                    Stride,           B.getInt1(IsVolatile),
+                    B.getInt32(Rows), B.getInt32(Columns)};
+    Type *OverloadedTypes[] = {Matrix->getType()};
+
+    Function *TheFn = Intrinsic::getDeclaration(
+        getModule(), Intrinsic::matrix_column_major_store, OverloadedTypes);
+
+    CallInst *Call = B.CreateCall(TheFn->getFunctionType(), TheFn, Ops, Name);
+    Attribute AlignAttr =
+        Attribute::getWithAlignment(Call->getContext(), Alignment);
+    Call->addAttribute(2, AlignAttr);
+    return Call;
+  }
+
+  /// Create a llvm.matrix.transpose call, transposing \p Matrix with \p Rows
+  /// rows and \p Columns columns.
+  CallInst *CreateMatrixTranspose(Value *Matrix, unsigned Rows,
+                                  unsigned Columns, const Twine &Name = "") {
+    auto *OpType = cast<VectorType>(Matrix->getType());
+    auto *ReturnType =
+        FixedVectorType::get(OpType->getElementType(), Rows * Columns);
+
+    Type *OverloadedTypes[] = {ReturnType};
+    Value *Ops[] = {Matrix, B.getInt32(Rows), B.getInt32(Columns)};
+    Function *TheFn = Intrinsic::getDeclaration(
+        getModule(), Intrinsic::matrix_transpose, OverloadedTypes);
+
+    return B.CreateCall(TheFn->getFunctionType(), TheFn, Ops, Name);
+  }
+
+  /// Create a llvm.matrix.multiply call, multiplying matrixes \p LHS and \p
+  /// RHS.
+  CallInst *CreateMatrixMultiply(Value *LHS, Value *RHS, unsigned LHSRows,
+                                 unsigned LHSColumns, unsigned RHSColumns,
+                                 const Twine &Name = "") {
+    auto *LHSType = cast<VectorType>(LHS->getType());
+    auto *RHSType = cast<VectorType>(RHS->getType());
+
+    auto *ReturnType =
+        FixedVectorType::get(LHSType->getElementType(), LHSRows * RHSColumns);
+
+    Value *Ops[] = {LHS, RHS, B.getInt32(LHSRows), B.getInt32(LHSColumns),
+                    B.getInt32(RHSColumns)};
+    Type *OverloadedTypes[] = {ReturnType, LHSType, RHSType};
+
+    Function *TheFn = Intrinsic::getDeclaration(
+        getModule(), Intrinsic::matrix_multiply, OverloadedTypes);
+    return B.CreateCall(TheFn->getFunctionType(), TheFn, Ops, Name);
+  }
+
+  /// Insert a single element \p NewVal into \p Matrix at indices (\p RowIdx, \p
+  /// ColumnIdx).
+  Value *CreateMatrixInsert(Value *Matrix, Value *NewVal, Value *RowIdx,
+                            Value *ColumnIdx, unsigned NumRows) {
+    return B.CreateInsertElement(
+        Matrix, NewVal,
+        B.CreateAdd(B.CreateMul(ColumnIdx, ConstantInt::get(
+                                               ColumnIdx->getType(), NumRows)),
+                    RowIdx));
+  }
+
+  /// Add matrixes \p LHS and \p RHS. Support both integer and floating point
+  /// matrixes.
+  Value *CreateAdd(Value *LHS, Value *RHS) {
+    assert(LHS->getType()->isVectorTy() || RHS->getType()->isVectorTy());
+    if (LHS->getType()->isVectorTy() && !RHS->getType()->isVectorTy()) {
+      assert(!isa<ScalableVectorType>(LHS->getType()) &&
+             "LHS Assumed to be fixed width");
+      RHS = B.CreateVectorSplat(
+          cast<VectorType>(LHS->getType())->getElementCount(), RHS,
+          "scalar.splat");
+    } else if (!LHS->getType()->isVectorTy() && RHS->getType()->isVectorTy()) {
+      assert(!isa<ScalableVectorType>(RHS->getType()) &&
+             "RHS Assumed to be fixed width");
+      LHS = B.CreateVectorSplat(
+          cast<VectorType>(RHS->getType())->getElementCount(), LHS,
+          "scalar.splat");
+    }
+
+    return cast<VectorType>(LHS->getType())
+                   ->getElementType()
+                   ->isFloatingPointTy()
+               ? B.CreateFAdd(LHS, RHS)
+               : B.CreateAdd(LHS, RHS);
+  }
+
+  /// Subtract matrixes \p LHS and \p RHS. Support both integer and floating
+  /// point matrixes.
+  Value *CreateSub(Value *LHS, Value *RHS) {
+    assert(LHS->getType()->isVectorTy() || RHS->getType()->isVectorTy());
+    if (LHS->getType()->isVectorTy() && !RHS->getType()->isVectorTy()) {
+      assert(!isa<ScalableVectorType>(LHS->getType()) &&
+             "LHS Assumed to be fixed width");
+      RHS = B.CreateVectorSplat(
+          cast<VectorType>(LHS->getType())->getElementCount(), RHS,
+          "scalar.splat");
+    } else if (!LHS->getType()->isVectorTy() && RHS->getType()->isVectorTy()) {
+      assert(!isa<ScalableVectorType>(RHS->getType()) &&
+             "RHS Assumed to be fixed width");
+      LHS = B.CreateVectorSplat(
+          cast<VectorType>(RHS->getType())->getElementCount(), LHS,
+          "scalar.splat");
+    }
+
+    return cast<VectorType>(LHS->getType())
+                   ->getElementType()
+                   ->isFloatingPointTy()
+               ? B.CreateFSub(LHS, RHS)
+               : B.CreateSub(LHS, RHS);
+  }
+
+  /// Multiply matrix \p LHS with scalar \p RHS or scalar \p LHS with matrix \p
+  /// RHS.
+  Value *CreateScalarMultiply(Value *LHS, Value *RHS) {
+    std::tie(LHS, RHS) = splatScalarOperandIfNeeded(LHS, RHS);
+    if (LHS->getType()->getScalarType()->isFloatingPointTy())
+      return B.CreateFMul(LHS, RHS);
+    return B.CreateMul(LHS, RHS);
+  }
+
+  /// Extracts the element at (\p RowIdx, \p ColumnIdx) from \p Matrix.
+  Value *CreateExtractElement(Value *Matrix, Value *RowIdx, Value *ColumnIdx,
+                              unsigned NumRows, Twine const &Name = "") {
+
+    unsigned MaxWidth = std::max(RowIdx->getType()->getScalarSizeInBits(),
+                                 ColumnIdx->getType()->getScalarSizeInBits());
+    Type *IntTy = IntegerType::get(RowIdx->getType()->getContext(), MaxWidth);
+    RowIdx = B.CreateZExt(RowIdx, IntTy);
+    ColumnIdx = B.CreateZExt(ColumnIdx, IntTy);
+    Value *NumRowsV = B.getIntN(MaxWidth, NumRows);
+    return B.CreateExtractElement(
+        Matrix, B.CreateAdd(B.CreateMul(ColumnIdx, NumRowsV), RowIdx),
+        "matext");
+  }
+};
+
+} // end namespace llvm
+
+#endif // LLVM_IR_MATRIXBUILDER_H
diff --git a/linux-x64/clang/include/llvm/IR/Metadata.def b/linux-x64/clang/include/llvm/IR/Metadata.def
index 1df60ca..f31be8d 100644
--- a/linux-x64/clang/include/llvm/IR/Metadata.def
+++ b/linux-x64/clang/include/llvm/IR/Metadata.def
@@ -114,6 +114,8 @@
 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIMacro)
 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIMacroFile)
 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DICommonBlock)
+HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIStringType)
+HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIGenericSubrange)
 
 #undef HANDLE_METADATA
 #undef HANDLE_METADATA_LEAF
diff --git a/linux-x64/clang/include/llvm/IR/Metadata.h b/linux-x64/clang/include/llvm/IR/Metadata.h
index 7ca2540..33b92c3 100644
--- a/linux-x64/clang/include/llvm/IR/Metadata.h
+++ b/linux-x64/clang/include/llvm/IR/Metadata.h
@@ -22,6 +22,7 @@
 #include "llvm/ADT/PointerUnion.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/ilist_node.h"
 #include "llvm/ADT/iterator_range.h"
@@ -526,7 +527,7 @@
 /// As an analogue to \a isa(), check whether \c MD has an \a Value inside of
 /// type \c X.
 template <class X, class Y>
-inline typename std::enable_if<detail::IsValidPointer<X, Y>::value, bool>::type
+inline std::enable_if_t<detail::IsValidPointer<X, Y>::value, bool>
 hasa(Y &&MD) {
   assert(MD && "Null pointer sent into hasa");
   if (auto *V = dyn_cast<ConstantAsMetadata>(MD))
@@ -534,9 +535,8 @@
   return false;
 }
 template <class X, class Y>
-inline
-    typename std::enable_if<detail::IsValidReference<X, Y &>::value, bool>::type
-    hasa(Y &MD) {
+inline std::enable_if_t<detail::IsValidReference<X, Y &>::value, bool>
+hasa(Y &MD) {
   return hasa(&MD);
 }
 
@@ -544,14 +544,13 @@
 ///
 /// As an analogue to \a cast(), extract the \a Value subclass \c X from \c MD.
 template <class X, class Y>
-inline typename std::enable_if<detail::IsValidPointer<X, Y>::value, X *>::type
+inline std::enable_if_t<detail::IsValidPointer<X, Y>::value, X *>
 extract(Y &&MD) {
   return cast<X>(cast<ConstantAsMetadata>(MD)->getValue());
 }
 template <class X, class Y>
-inline
-    typename std::enable_if<detail::IsValidReference<X, Y &>::value, X *>::type
-    extract(Y &MD) {
+inline std::enable_if_t<detail::IsValidReference<X, Y &>::value, X *>
+extract(Y &MD) {
   return extract(&MD);
 }
 
@@ -560,7 +559,7 @@
 /// As an analogue to \a cast_or_null(), extract the \a Value subclass \c X
 /// from \c MD, allowing \c MD to be null.
 template <class X, class Y>
-inline typename std::enable_if<detail::IsValidPointer<X, Y>::value, X *>::type
+inline std::enable_if_t<detail::IsValidPointer<X, Y>::value, X *>
 extract_or_null(Y &&MD) {
   if (auto *V = cast_or_null<ConstantAsMetadata>(MD))
     return cast<X>(V->getValue());
@@ -573,7 +572,7 @@
 /// from \c MD, return null if \c MD doesn't contain a \a Value or if the \a
 /// Value it does contain is of the wrong subclass.
 template <class X, class Y>
-inline typename std::enable_if<detail::IsValidPointer<X, Y>::value, X *>::type
+inline std::enable_if_t<detail::IsValidPointer<X, Y>::value, X *>
 dyn_extract(Y &&MD) {
   if (auto *V = dyn_cast<ConstantAsMetadata>(MD))
     return dyn_cast<X>(V->getValue());
@@ -586,7 +585,7 @@
 /// from \c MD, return null if \c MD doesn't contain a \a Value or if the \a
 /// Value it does contain is of the wrong subclass, allowing \c MD to be null.
 template <class X, class Y>
-inline typename std::enable_if<detail::IsValidPointer<X, Y>::value, X *>::type
+inline std::enable_if_t<detail::IsValidPointer<X, Y>::value, X *>
 dyn_extract_or_null(Y &&MD) {
   if (auto *V = dyn_cast_or_null<ConstantAsMetadata>(MD))
     return dyn_cast<X>(V->getValue());
@@ -601,7 +600,7 @@
 /// These are used to efficiently contain a byte sequence for metadata.
 /// MDString is always unnamed.
 class MDString : public Metadata {
-  friend class StringMapEntry<MDString>;
+  friend class StringMapEntryStorage<MDString>;
 
   StringMapEntry<MDString> *Entry = nullptr;
 
@@ -641,26 +640,32 @@
 /// A collection of metadata nodes that might be associated with a
 /// memory access used by the alias-analysis infrastructure.
 struct AAMDNodes {
-  explicit AAMDNodes(MDNode *T = nullptr, MDNode *S = nullptr,
-                     MDNode *N = nullptr)
-      : TBAA(T), Scope(S), NoAlias(N) {}
+  explicit AAMDNodes() = default;
+  explicit AAMDNodes(MDNode *T, MDNode *TS, MDNode *S, MDNode *N)
+      : TBAA(T), TBAAStruct(TS), Scope(S), NoAlias(N) {}
 
   bool operator==(const AAMDNodes &A) const {
-    return TBAA == A.TBAA && Scope == A.Scope && NoAlias == A.NoAlias;
+    return TBAA == A.TBAA && TBAAStruct == A.TBAAStruct && Scope == A.Scope &&
+           NoAlias == A.NoAlias;
   }
 
   bool operator!=(const AAMDNodes &A) const { return !(*this == A); }
 
-  explicit operator bool() const { return TBAA || Scope || NoAlias; }
+  explicit operator bool() const {
+    return TBAA || TBAAStruct || Scope || NoAlias;
+  }
 
   /// The tag for type-based alias analysis.
-  MDNode *TBAA;
+  MDNode *TBAA = nullptr;
+
+  /// The tag for type-based alias analysis (tbaa struct).
+  MDNode *TBAAStruct = nullptr;
 
   /// The tag for alias scope specification (used with noalias).
-  MDNode *Scope;
+  MDNode *Scope = nullptr;
 
   /// The tag specifying the noalias scope.
-  MDNode *NoAlias;
+  MDNode *NoAlias = nullptr;
 
   /// Given two sets of AAMDNodes that apply to the same pointer,
   /// give the best AAMDNodes that are compatible with both (i.e. a set of
@@ -670,6 +675,7 @@
   AAMDNodes intersect(const AAMDNodes &Other) {
     AAMDNodes Result;
     Result.TBAA = Other.TBAA == TBAA ? TBAA : nullptr;
+    Result.TBAAStruct = Other.TBAAStruct == TBAAStruct ? TBAAStruct : nullptr;
     Result.Scope = Other.Scope == Scope ? Scope : nullptr;
     Result.NoAlias = Other.NoAlias == NoAlias ? NoAlias : nullptr;
     return Result;
@@ -681,16 +687,17 @@
 struct DenseMapInfo<AAMDNodes> {
   static inline AAMDNodes getEmptyKey() {
     return AAMDNodes(DenseMapInfo<MDNode *>::getEmptyKey(),
-                     nullptr, nullptr);
+                     nullptr, nullptr, nullptr);
   }
 
   static inline AAMDNodes getTombstoneKey() {
     return AAMDNodes(DenseMapInfo<MDNode *>::getTombstoneKey(),
-                     nullptr, nullptr);
+                     nullptr, nullptr, nullptr);
   }
 
   static unsigned getHashValue(const AAMDNodes &Val) {
     return DenseMapInfo<MDNode *>::getHashValue(Val.TBAA) ^
+           DenseMapInfo<MDNode *>::getHashValue(Val.TBAAStruct) ^
            DenseMapInfo<MDNode *>::getHashValue(Val.Scope) ^
            DenseMapInfo<MDNode *>::getHashValue(Val.NoAlias);
   }
@@ -806,7 +813,7 @@
   /// Ensure that this has RAUW support, and then return it.
   ReplaceableMetadataImpl *getOrCreateReplaceableUses() {
     if (!hasReplaceableUses())
-      makeReplaceable(llvm::make_unique<ReplaceableMetadataImpl>(getContext()));
+      makeReplaceable(std::make_unique<ReplaceableMetadataImpl>(getContext()));
     return getReplaceableUses();
   }
 
@@ -967,7 +974,7 @@
   /// Try to create a uniqued version of \c N -- in place, if possible -- and
   /// return it.  If \c N cannot be uniqued, return a distinct node instead.
   template <class T>
-  static typename std::enable_if<std::is_base_of<MDNode, T>::value, T *>::type
+  static std::enable_if_t<std::is_base_of<MDNode, T>::value, T *>
   replaceWithPermanent(std::unique_ptr<T, TempMDNodeDeleter> N) {
     return cast<T>(N.release()->replaceWithPermanentImpl());
   }
@@ -979,7 +986,7 @@
   ///
   /// \pre N does not self-reference.
   template <class T>
-  static typename std::enable_if<std::is_base_of<MDNode, T>::value, T *>::type
+  static std::enable_if_t<std::is_base_of<MDNode, T>::value, T *>
   replaceWithUniqued(std::unique_ptr<T, TempMDNodeDeleter> N) {
     return cast<T>(N.release()->replaceWithUniquedImpl());
   }
@@ -989,7 +996,7 @@
   /// Create a distinct version of \c N -- in place, if possible -- and return
   /// it.  Takes ownership of the temporary node.
   template <class T>
-  static typename std::enable_if<std::is_base_of<MDNode, T>::value, T *>::type
+  static std::enable_if_t<std::is_base_of<MDNode, T>::value, T *>
   replaceWithDistinct(std::unique_ptr<T, TempMDNodeDeleter> N) {
     return cast<T>(N.release()->replaceWithDistinctImpl());
   }
@@ -1121,8 +1128,7 @@
                           StorageType Storage, bool ShouldCreate = true);
 
   TempMDTuple cloneImpl() const {
-    return getTemporary(getContext(),
-                        SmallVector<Metadata *, 4>(op_begin(), op_end()));
+    return getTemporary(getContext(), SmallVector<Metadata *, 4>(operands()));
   }
 
 public:
@@ -1183,6 +1189,27 @@
   MDNode::deleteTemporary(Node);
 }
 
+/// This is a simple wrapper around an MDNode which provides a higher-level
+/// interface by hiding the details of how alias analysis information is encoded
+/// in its operands.
+class AliasScopeNode {
+  const MDNode *Node = nullptr;
+
+public:
+  AliasScopeNode() = default;
+  explicit AliasScopeNode(const MDNode *N) : Node(N) {}
+
+  /// Get the MDNode for this AliasScopeNode.
+  const MDNode *getNode() const { return Node; }
+
+  /// Get the MDNode for this AliasScopeNode's domain.
+  const MDNode *getDomain() const {
+    if (Node->getNumOperands() < 2)
+      return nullptr;
+    return dyn_cast_or_null<MDNode>(Node->getOperand(1));
+  }
+};
+
 /// Typed iterator through MDNode operands.
 ///
 /// An iterator that transforms an \a MDNode::iterator into an iterator over a
@@ -1228,15 +1255,13 @@
   template <class U>
   MDTupleTypedArrayWrapper(
       const MDTupleTypedArrayWrapper<U> &Other,
-      typename std::enable_if<std::is_convertible<U *, T *>::value>::type * =
-          nullptr)
+      std::enable_if_t<std::is_convertible<U *, T *>::value> * = nullptr)
       : N(Other.get()) {}
 
   template <class U>
   explicit MDTupleTypedArrayWrapper(
       const MDTupleTypedArrayWrapper<U> &Other,
-      typename std::enable_if<!std::is_convertible<U *, T *>::value>::type * =
-          nullptr)
+      std::enable_if_t<!std::is_convertible<U *, T *>::value> * = nullptr)
       : N(Other.get()) {}
 
   explicit operator bool() const { return get(); }
diff --git a/linux-x64/clang/include/llvm/IR/Module.h b/linux-x64/clang/include/llvm/IR/Module.h
index f458680..3664b27 100644
--- a/linux-x64/clang/include/llvm/IR/Module.h
+++ b/linux-x64/clang/include/llvm/IR/Module.h
@@ -46,6 +46,8 @@
 class GVMaterializer;
 class LLVMContext;
 class MemoryBuffer;
+class ModuleSummaryIndex;
+class Pass;
 class RandomNumberGenerator;
 template <class PtrType> class SmallPtrSetImpl;
 class StructType;
@@ -78,6 +80,8 @@
   using NamedMDListType = ilist<NamedMDNode>;
   /// The type of the comdat "symbol" table.
   using ComdatSymTabType = StringMap<Comdat>;
+  /// The type for mapping names to named metadata.
+  using NamedMDSymTabType = StringMap<NamedMDNode *>;
 
   /// The Global Variable iterator.
   using global_iterator = GlobalListType::iterator;
@@ -153,6 +157,11 @@
   /// converted result in MFB.
   static bool isValidModFlagBehavior(Metadata *MD, ModFlagBehavior &MFB);
 
+  /// Check if the given module flag metadata represents a valid module flag,
+  /// and store the flag behavior, the key string and the value metadata.
+  static bool isValidModuleFlag(const MDNode &ModFlag, ModFlagBehavior &MFB,
+                                MDString *&Key, Metadata *&Val);
+
   struct ModuleFlagEntry {
     ModFlagBehavior Behavior;
     MDString *Key;
@@ -174,7 +183,7 @@
   IFuncListType IFuncList;        ///< The IFuncs in the module
   NamedMDListType NamedMDList;    ///< The named metadata in the module
   std::string GlobalScopeAsm;     ///< Inline Asm at global scope.
-  ValueSymbolTable *ValSymTab;    ///< Symbol table for values
+  std::unique_ptr<ValueSymbolTable> ValSymTab; ///< Symbol table for values
   ComdatSymTabType ComdatSymTab;  ///< Symbol table for COMDATs
   std::unique_ptr<MemoryBuffer>
   OwnedMemoryBuffer;              ///< Memory buffer directly owned by this
@@ -186,7 +195,7 @@
                                   ///< recorded in bitcode.
   std::string TargetTriple;       ///< Platform target triple Module compiled on
                                   ///< Format: (arch)(sub)-(vendor)-(sys0-(abi)
-  void *NamedMDSymTab;            ///< NamedMDNode names.
+  NamedMDSymTabType NamedMDSymTab;  ///< NamedMDNode names.
   DataLayout DL;                  ///< DataLayout associated with the module
 
   friend class Constant;
@@ -256,7 +265,7 @@
   /// when other randomness consuming passes are added or removed. In
   /// addition, the random stream will be reproducible across LLVM
   /// versions when the pass does not change.
-  std::unique_ptr<RandomNumberGenerator> createRNG(const Pass* P) const;
+  std::unique_ptr<RandomNumberGenerator> createRNG(const StringRef Name) const;
 
   /// Return true if size-info optimization remark is enabled, false
   /// otherwise.
@@ -270,22 +279,22 @@
   /// @{
 
   /// Set the module identifier.
-  void setModuleIdentifier(StringRef ID) { ModuleID = ID; }
+  void setModuleIdentifier(StringRef ID) { ModuleID = std::string(ID); }
 
   /// Set the module's original source file name.
-  void setSourceFileName(StringRef Name) { SourceFileName = Name; }
+  void setSourceFileName(StringRef Name) { SourceFileName = std::string(Name); }
 
   /// Set the data layout
   void setDataLayout(StringRef Desc);
   void setDataLayout(const DataLayout &Other);
 
   /// Set the target triple.
-  void setTargetTriple(StringRef T) { TargetTriple = T; }
+  void setTargetTriple(StringRef T) { TargetTriple = std::string(T); }
 
   /// Set the module-scope inline assembly blocks.
   /// A trailing newline is added if the input doesn't have one.
   void setModuleInlineAsm(StringRef Asm) {
-    GlobalScopeAsm = Asm;
+    GlobalScopeAsm = std::string(Asm);
     if (!GlobalScopeAsm.empty() && GlobalScopeAsm.back() != '\n')
       GlobalScopeAsm += '\n';
   }
@@ -320,10 +329,6 @@
   /// \see LLVMContext::getOperandBundleTagID
   void getOperandBundleTags(SmallVectorImpl<StringRef> &Result) const;
 
-  /// Return the type with the specified name, or null if there is none by that
-  /// name.
-  StructType *getTypeByName(StringRef Name) const;
-
   std::vector<StructType *> getIdentifiedStructTypes() const;
 
 /// @}
@@ -490,10 +495,12 @@
   void addModuleFlag(ModFlagBehavior Behavior, StringRef Key, Constant *Val);
   void addModuleFlag(ModFlagBehavior Behavior, StringRef Key, uint32_t Val);
   void addModuleFlag(MDNode *Node);
+  /// Like addModuleFlag but replaces the old module flag if it already exists.
+  void setModuleFlag(ModFlagBehavior Behavior, StringRef Key, Metadata *Val);
 
-/// @}
-/// @name Materialization
-/// @{
+  /// @}
+  /// @name Materialization
+  /// @{
 
   /// Sets the GVMaterializer to GVM. This module must not yet have a
   /// Materializer. To reset the materializer for a module that already has one,
@@ -582,6 +589,7 @@
   const_global_iterator global_begin() const { return GlobalList.begin(); }
   global_iterator       global_end  ()       { return GlobalList.end(); }
   const_global_iterator global_end  () const { return GlobalList.end(); }
+  size_t                global_size () const { return GlobalList.size(); }
   bool                  global_empty() const { return GlobalList.empty(); }
 
   iterator_range<global_iterator> globals() {
@@ -659,24 +667,8 @@
       concat_iterator<const GlobalObject, const_iterator,
                       const_global_iterator>;
 
-  iterator_range<global_object_iterator> global_objects() {
-    return concat<GlobalObject>(functions(), globals());
-  }
-  iterator_range<const_global_object_iterator> global_objects() const {
-    return concat<const GlobalObject>(functions(), globals());
-  }
-
-  global_object_iterator global_object_begin() {
-    return global_objects().begin();
-  }
-  global_object_iterator global_object_end() { return global_objects().end(); }
-
-  const_global_object_iterator global_object_begin() const {
-    return global_objects().begin();
-  }
-  const_global_object_iterator global_object_end() const {
-    return global_objects().end();
-  }
+  iterator_range<global_object_iterator> global_objects();
+  iterator_range<const_global_object_iterator> global_objects() const;
 
   using global_value_iterator =
       concat_iterator<GlobalValue, iterator, global_iterator, alias_iterator,
@@ -685,23 +677,8 @@
       concat_iterator<const GlobalValue, const_iterator, const_global_iterator,
                       const_alias_iterator, const_ifunc_iterator>;
 
-  iterator_range<global_value_iterator> global_values() {
-    return concat<GlobalValue>(functions(), globals(), aliases(), ifuncs());
-  }
-  iterator_range<const_global_value_iterator> global_values() const {
-    return concat<const GlobalValue>(functions(), globals(), aliases(),
-                                     ifuncs());
-  }
-
-  global_value_iterator global_value_begin() { return global_values().begin(); }
-  global_value_iterator global_value_end() { return global_values().end(); }
-
-  const_global_value_iterator global_value_begin() const {
-    return global_values().begin();
-  }
-  const_global_value_iterator global_value_end() const {
-    return global_values().end();
-  }
+  iterator_range<global_value_iterator> global_values();
+  iterator_range<const_global_value_iterator> global_values() const;
 
   /// @}
   /// @name Named Metadata Iteration
@@ -873,9 +850,15 @@
 
   /// Returns profile summary metadata. When IsCS is true, use the context
   /// sensitive profile summary.
-  Metadata *getProfileSummary(bool IsCS);
+  Metadata *getProfileSummary(bool IsCS) const;
   /// @}
 
+  /// Returns whether semantic interposition is to be respected.
+  bool getSemanticInterposition() const;
+
+  /// Set whether semantic interposition is to be respected.
+  void setSemanticInterposition(bool);
+
   /// Returns true if PLT should be avoided for RTLib calls.
   bool getRtLibUseGOT() const;
 
@@ -896,6 +879,10 @@
 
   /// Take ownership of the given memory buffer.
   void setOwnedMemoryBuffer(std::unique_ptr<MemoryBuffer> MB);
+
+  /// Set the partial sample profile ratio in the profile summary module flag,
+  /// if applicable.
+  void setPartialSampleProfileRatio(const ModuleSummaryIndex &Index);
 };
 
 /// Given "llvm.used" or "llvm.compiler.used" as a global name, collect
diff --git a/linux-x64/clang/include/llvm/IR/ModuleSummaryIndex.h b/linux-x64/clang/include/llvm/IR/ModuleSummaryIndex.h
index aacf8cf..d5a7ad6 100644
--- a/linux-x64/clang/include/llvm/IR/ModuleSummaryIndex.h
+++ b/linux-x64/clang/include/llvm/IR/ModuleSummaryIndex.h
@@ -23,12 +23,14 @@
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/TinyPtrVector.h"
+#include "llvm/IR/ConstantRange.h"
 #include "llvm/IR/GlobalValue.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/ScaledNumber.h"
 #include "llvm/Support/StringSaver.h"
+#include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <array>
 #include <cassert>
@@ -119,7 +121,7 @@
 
 using GlobalValueSummaryList = std::vector<std::unique_ptr<GlobalValueSummary>>;
 
-struct LLVM_ALIGNAS(8) GlobalValueSummaryInfo {
+struct alignas(8) GlobalValueSummaryInfo {
   union NameOrGV {
     NameOrGV(bool HaveGVs) {
       if (HaveGVs)
@@ -172,7 +174,7 @@
     RefAndFlags.setInt(HaveGVs);
   }
 
-  operator bool() const { return getRef(); }
+  explicit operator bool() const { return getRef(); }
 
   GlobalValue::GUID getGUID() const { return getRef()->first; }
   const GlobalValue *getValue() const {
@@ -547,6 +549,42 @@
 
     // Indicate if the global value cannot be inlined.
     unsigned NoInline : 1;
+    // Indicate if function should be always inlined.
+    unsigned AlwaysInline : 1;
+  };
+
+  /// Describes the uses of a parameter by the function.
+  struct ParamAccess {
+    static constexpr uint32_t RangeWidth = 64;
+
+    /// Describes the use of a value in a call instruction, specifying the
+    /// call's target, the value's parameter number, and the possible range of
+    /// offsets from the beginning of the value that are passed.
+    struct Call {
+      uint64_t ParamNo = 0;
+      ValueInfo Callee;
+      ConstantRange Offsets{/*BitWidth=*/RangeWidth, /*isFullSet=*/true};
+
+      Call() = default;
+      Call(uint64_t ParamNo, ValueInfo Callee, const ConstantRange &Offsets)
+          : ParamNo(ParamNo), Callee(Callee), Offsets(Offsets) {}
+    };
+
+    uint64_t ParamNo = 0;
+    /// The range contains byte offsets from the parameter pointer which
+    /// accessed by the function. In the per-module summary, it only includes
+    /// accesses made by the function instructions. In the combined summary, it
+    /// also includes accesses by nested function calls.
+    ConstantRange Use{/*BitWidth=*/RangeWidth, /*isFullSet=*/true};
+    /// In the per-module summary, it summarizes the byte offset applied to each
+    /// pointer parameter before passing to each corresponding callee.
+    /// In the combined summary, it's empty and information is propagated by
+    /// inter-procedural analysis and applied to the Use field.
+    std::vector<Call> Calls;
+
+    ParamAccess() = default;
+    ParamAccess(uint64_t ParamNo, const ConstantRange &Use)
+        : ParamNo(ParamNo), Use(Use) {}
   };
 
   /// Create an empty FunctionSummary (with specified call edges).
@@ -558,13 +596,14 @@
             GlobalValue::LinkageTypes::AvailableExternallyLinkage,
             /*NotEligibleToImport=*/true, /*Live=*/true, /*IsLocal=*/false,
             /*CanAutoHide=*/false),
-        /*InsCount=*/0, FunctionSummary::FFlags{}, /*EntryCount=*/0,
+        /*NumInsts=*/0, FunctionSummary::FFlags{}, /*EntryCount=*/0,
         std::vector<ValueInfo>(), std::move(Edges),
         std::vector<GlobalValue::GUID>(),
         std::vector<FunctionSummary::VFuncId>(),
         std::vector<FunctionSummary::VFuncId>(),
         std::vector<FunctionSummary::ConstVCall>(),
-        std::vector<FunctionSummary::ConstVCall>());
+        std::vector<FunctionSummary::ConstVCall>(),
+        std::vector<FunctionSummary::ParamAccess>());
   }
 
   /// A dummy node to reference external functions that aren't in the index
@@ -588,6 +627,10 @@
 
   std::unique_ptr<TypeIdInfo> TIdInfo;
 
+  /// Uses for every parameter to this function.
+  using ParamAccessesTy = std::vector<ParamAccess>;
+  std::unique_ptr<ParamAccessesTy> ParamAccesses;
+
 public:
   FunctionSummary(GVFlags Flags, unsigned NumInsts, FFlags FunFlags,
                   uint64_t EntryCount, std::vector<ValueInfo> Refs,
@@ -596,18 +639,21 @@
                   std::vector<VFuncId> TypeTestAssumeVCalls,
                   std::vector<VFuncId> TypeCheckedLoadVCalls,
                   std::vector<ConstVCall> TypeTestAssumeConstVCalls,
-                  std::vector<ConstVCall> TypeCheckedLoadConstVCalls)
+                  std::vector<ConstVCall> TypeCheckedLoadConstVCalls,
+                  std::vector<ParamAccess> Params)
       : GlobalValueSummary(FunctionKind, Flags, std::move(Refs)),
         InstCount(NumInsts), FunFlags(FunFlags), EntryCount(EntryCount),
         CallGraphEdgeList(std::move(CGEdges)) {
     if (!TypeTests.empty() || !TypeTestAssumeVCalls.empty() ||
         !TypeCheckedLoadVCalls.empty() || !TypeTestAssumeConstVCalls.empty() ||
         !TypeCheckedLoadConstVCalls.empty())
-      TIdInfo = llvm::make_unique<TypeIdInfo>(TypeIdInfo{
-          std::move(TypeTests), std::move(TypeTestAssumeVCalls),
-          std::move(TypeCheckedLoadVCalls),
-          std::move(TypeTestAssumeConstVCalls),
-          std::move(TypeCheckedLoadConstVCalls)});
+      TIdInfo = std::make_unique<TypeIdInfo>(
+          TypeIdInfo{std::move(TypeTests), std::move(TypeTestAssumeVCalls),
+                     std::move(TypeCheckedLoadVCalls),
+                     std::move(TypeTestAssumeConstVCalls),
+                     std::move(TypeCheckedLoadConstVCalls)});
+    if (!Params.empty())
+      ParamAccesses = std::make_unique<ParamAccessesTy>(std::move(Params));
   }
   // Gets the number of readonly and writeonly refs in RefEdgeList
   std::pair<unsigned, unsigned> specialRefCounts() const;
@@ -632,6 +678,8 @@
   /// Return the list of <CalleeValueInfo, CalleeInfo> pairs.
   ArrayRef<EdgeTy> calls() const { return CallGraphEdgeList; }
 
+  void addCall(EdgeTy E) { CallGraphEdgeList.push_back(E); }
+
   /// Returns the list of type identifiers used by this function in
   /// llvm.type.test intrinsics other than by an llvm.assume intrinsic,
   /// represented as GUIDs.
@@ -676,11 +724,28 @@
     return {};
   }
 
+  /// Returns the list of known uses of pointer parameters.
+  ArrayRef<ParamAccess> paramAccesses() const {
+    if (ParamAccesses)
+      return *ParamAccesses;
+    return {};
+  }
+
+  /// Sets the list of known uses of pointer parameters.
+  void setParamAccesses(std::vector<ParamAccess> NewParams) {
+    if (NewParams.empty())
+      ParamAccesses.reset();
+    else if (ParamAccesses)
+      *ParamAccesses = std::move(NewParams);
+    else
+      ParamAccesses = std::make_unique<ParamAccessesTy>(std::move(NewParams));
+  }
+
   /// Add a type test to the summary. This is used by WholeProgramDevirt if we
   /// were unable to devirtualize a checked call.
   void addTypeTest(GlobalValue::GUID Guid) {
     if (!TIdInfo)
-      TIdInfo = llvm::make_unique<TypeIdInfo>();
+      TIdInfo = std::make_unique<TypeIdInfo>();
     TIdInfo->TypeTests.push_back(Guid);
   }
 
@@ -752,14 +817,33 @@
 
 public:
   struct GVarFlags {
-    GVarFlags(bool ReadOnly, bool WriteOnly)
-        : MaybeReadOnly(ReadOnly), MaybeWriteOnly(WriteOnly) {}
+    GVarFlags(bool ReadOnly, bool WriteOnly, bool Constant,
+              GlobalObject::VCallVisibility Vis)
+        : MaybeReadOnly(ReadOnly), MaybeWriteOnly(WriteOnly),
+          Constant(Constant), VCallVisibility(Vis) {}
 
-    // In permodule summaries both MaybeReadOnly and MaybeWriteOnly
-    // bits are set, because attribute propagation occurs later on
-    // thin link phase.
+    // If true indicates that this global variable might be accessed
+    // purely by non-volatile load instructions. This in turn means
+    // it can be internalized in source and destination modules during
+    // thin LTO import because it neither modified nor its address
+    // is taken.
     unsigned MaybeReadOnly : 1;
+    // If true indicates that variable is possibly only written to, so
+    // its value isn't loaded and its address isn't taken anywhere.
+    // False, when 'Constant' attribute is set.
     unsigned MaybeWriteOnly : 1;
+    // Indicates that value is a compile-time constant. Global variable
+    // can be 'Constant' while not being 'ReadOnly' on several occasions:
+    // - it is volatile, (e.g mapped device address)
+    // - its address is taken, meaning that unlike 'ReadOnly' vars we can't
+    //   internalize it.
+    // Constant variables are always imported thus giving compiler an
+    // opportunity to make some extra optimizations. Readonly constants
+    // are also internalized.
+    unsigned Constant : 1;
+    // Set from metadata on vtable definitions during the module summary
+    // analysis.
+    unsigned VCallVisibility : 2;
   } VarFlags;
 
   GlobalVarSummary(GVFlags Flags, GVarFlags VarFlags,
@@ -777,10 +861,17 @@
   void setWriteOnly(bool WO) { VarFlags.MaybeWriteOnly = WO; }
   bool maybeReadOnly() const { return VarFlags.MaybeReadOnly; }
   bool maybeWriteOnly() const { return VarFlags.MaybeWriteOnly; }
+  bool isConstant() const { return VarFlags.Constant; }
+  void setVCallVisibility(GlobalObject::VCallVisibility Vis) {
+    VarFlags.VCallVisibility = Vis;
+  }
+  GlobalObject::VCallVisibility getVCallVisibility() const {
+    return (GlobalObject::VCallVisibility)VarFlags.VCallVisibility;
+  }
 
   void setVTableFuncs(VTableFuncList Funcs) {
     assert(!VTableFuncs);
-    VTableFuncs = llvm::make_unique<VTableFuncList>(std::move(Funcs));
+    VTableFuncs = std::make_unique<VTableFuncList>(std::move(Funcs));
   }
 
   ArrayRef<VirtFuncOffset> vTableFuncs() const {
@@ -802,7 +893,8 @@
     Single,    ///< Single element (last example in "Short Inline Bit Vectors")
     AllOnes,   ///< All-ones bit vector ("Eliminating Bit Vector Checks for
                ///  All-Ones Bit Vectors")
-  } TheKind = Unsat;
+    Unknown,   ///< Unknown (analysis not performed, don't lower)
+  } TheKind = Unknown;
 
   /// Range of size-1 expressed as a bit width. For example, if the size is in
   /// range [1,256], this number will be 8. This helps generate the most compact
@@ -928,7 +1020,8 @@
   /// with that type identifier's metadata. Produced by per module summary
   /// analysis and consumed by thin link. For more information, see description
   /// above where TypeIdCompatibleVtableInfo is defined.
-  std::map<std::string, TypeIdCompatibleVtableInfo> TypeIdCompatibleVtableMap;
+  std::map<std::string, TypeIdCompatibleVtableInfo, std::less<>>
+      TypeIdCompatibleVtableMap;
 
   /// Mapping from original ID to GUID. If original ID can map to multiple
   /// GUIDs, it will be mapped to 0.
@@ -939,6 +1032,11 @@
   /// considered live.
   bool WithGlobalValueDeadStripping = false;
 
+  /// Indicates that summary-based attribute propagation has run and
+  /// GVarFlags::MaybeReadonly / GVarFlags::MaybeWriteonly are really
+  /// read/write only.
+  bool WithAttributePropagation = false;
+
   /// Indicates that summary-based synthetic entry count propagation has run
   bool HasSyntheticEntryCounts = false;
 
@@ -962,6 +1060,9 @@
   // some were not. Set when the combined index is created during the thin link.
   bool PartiallySplitLTOUnits = false;
 
+  /// True if some of the FunctionSummary contains a ParamAccess.
+  bool HasParamAccess = false;
+
   std::set<std::string> CfiFunctionDefs;
   std::set<std::string> CfiFunctionDecls;
 
@@ -970,6 +1071,10 @@
   StringSaver Saver;
   BumpPtrAllocator Alloc;
 
+  // The total number of basic blocks in the module in the per-module summary or
+  // the total number of basic blocks in the LTO unit in the combined index.
+  uint64_t BlockCount;
+
   // YAML I/O support.
   friend yaml::MappingTraits<ModuleSummaryIndex>;
 
@@ -982,11 +1087,30 @@
 public:
   // See HaveGVs variable comment.
   ModuleSummaryIndex(bool HaveGVs, bool EnableSplitLTOUnit = false)
-      : HaveGVs(HaveGVs), EnableSplitLTOUnit(EnableSplitLTOUnit), Saver(Alloc) {
+      : HaveGVs(HaveGVs), EnableSplitLTOUnit(EnableSplitLTOUnit), Saver(Alloc),
+        BlockCount(0) {}
+
+  // Current version for the module summary in bitcode files.
+  // The BitcodeSummaryVersion should be bumped whenever we introduce changes
+  // in the way some record are interpreted, like flags for instance.
+  // Note that incrementing this may require changes in both BitcodeReader.cpp
+  // and BitcodeWriter.cpp.
+  static constexpr uint64_t BitcodeSummaryVersion = 9;
+
+  // Regular LTO module name for ASM writer
+  static constexpr const char *getRegularLTOModuleName() {
+    return "[Regular LTO]";
   }
 
   bool haveGVs() const { return HaveGVs; }
 
+  uint64_t getFlags() const;
+  void setFlags(uint64_t Flags);
+
+  uint64_t getBlockCount() const { return BlockCount; }
+  void addBlockCount(uint64_t C) { BlockCount += C; }
+  void setBlockCount(uint64_t C) { BlockCount = C; }
+
   gvsummary_iterator begin() { return GlobalValueMap.begin(); }
   const_gvsummary_iterator begin() const { return GlobalValueMap.begin(); }
   gvsummary_iterator end() { return GlobalValueMap.end(); }
@@ -1063,6 +1187,18 @@
     WithGlobalValueDeadStripping = true;
   }
 
+  bool withAttributePropagation() const { return WithAttributePropagation; }
+  void setWithAttributePropagation() {
+    WithAttributePropagation = true;
+  }
+
+  bool isReadOnly(const GlobalVarSummary *GVS) const {
+    return WithAttributePropagation && GVS->maybeReadOnly();
+  }
+  bool isWriteOnly(const GlobalVarSummary *GVS) const {
+    return WithAttributePropagation && GVS->maybeWriteOnly();
+  }
+
   bool hasSyntheticEntryCounts() const { return HasSyntheticEntryCounts; }
   void setHasSyntheticEntryCounts() { HasSyntheticEntryCounts = true; }
 
@@ -1079,6 +1215,8 @@
   bool partiallySplitLTOUnits() const { return PartiallySplitLTOUnits; }
   void setPartiallySplitLTOUnits() { PartiallySplitLTOUnits = true; }
 
+  bool hasParamAccess() const { return HasParamAccess; }
+
   bool isGlobalValueLive(const GlobalValueSummary *GVS) const {
     return !WithGlobalValueDeadStripping || GVS->isLive();
   }
@@ -1150,6 +1288,8 @@
   /// Add a global value summary for the given ValueInfo.
   void addGlobalValueSummary(ValueInfo VI,
                              std::unique_ptr<GlobalValueSummary> Summary) {
+    if (const FunctionSummary *FS = dyn_cast<FunctionSummary>(Summary.get()))
+      HasParamAccess |= !FS->paramAccesses().empty();
     addOriginalName(VI.getGUID(), Summary->getOriginalName());
     // Here we have a notionally const VI, but the value it points to is owned
     // by the non-const *this.
@@ -1235,13 +1375,15 @@
     NewName += ".llvm.";
     NewName += utostr((uint64_t(ModHash[0]) << 32) |
                       ModHash[1]); // Take the first 64 bits
-    return NewName.str();
+    return std::string(NewName.str());
   }
 
   /// Helper to obtain the unpromoted name for a global value (or the original
-  /// name if not promoted).
+  /// name if not promoted). Split off the rightmost ".llvm.${hash}" suffix,
+  /// because it is possible in certain clients (not clang at the moment) for
+  /// two rounds of ThinLTO optimization and therefore promotion to occur.
   static StringRef getOriginalNameBeforePromote(StringRef Name) {
-    std::pair<StringRef, StringRef> Pair = Name.split(".llvm.");
+    std::pair<StringRef, StringRef> Pair = Name.rsplit(".llvm.");
     return Pair.first;
   }
 
@@ -1279,7 +1421,7 @@
       if (It->second.first == TypeId)
         return It->second.second;
     auto It = TypeIdMap.insert(
-        {GlobalValue::getGUID(TypeId), {TypeId, TypeIdSummary()}});
+        {GlobalValue::getGUID(TypeId), {std::string(TypeId), TypeIdSummary()}});
     return It->second.second;
   }
 
@@ -1293,8 +1435,13 @@
     return nullptr;
   }
 
-  const std::map<std::string, TypeIdCompatibleVtableInfo> &
-  typeIdCompatibleVtableMap() const {
+  TypeIdSummary *getTypeIdSummary(StringRef TypeId) {
+    return const_cast<TypeIdSummary *>(
+        static_cast<const ModuleSummaryIndex *>(this)->getTypeIdSummary(
+            TypeId));
+  }
+
+  const auto &typeIdCompatibleVtableMap() const {
     return TypeIdCompatibleVtableMap;
   }
 
@@ -1303,7 +1450,7 @@
   /// the ThinLTO backends.
   TypeIdCompatibleVtableInfo &
   getOrInsertTypeIdCompatibleVtableSummary(StringRef TypeId) {
-    return TypeIdCompatibleVtableMap[TypeId];
+    return TypeIdCompatibleVtableMap[std::string(TypeId)];
   }
 
   /// For the given \p TypeId, this returns the TypeIdCompatibleVtableMap
@@ -1341,13 +1488,18 @@
   void dump() const;
 
   /// Export summary to dot file for GraphViz.
-  void exportToDot(raw_ostream& OS) const;
+  void
+  exportToDot(raw_ostream &OS,
+              const DenseSet<GlobalValue::GUID> &GUIDPreservedSymbols) const;
 
   /// Print out strongly connected components for debugging.
   void dumpSCCs(raw_ostream &OS);
 
   /// Analyze index and detect unmodified globals
   void propagateAttributes(const DenseSet<GlobalValue::GUID> &PreservedSymbols);
+
+  /// Checks if we can import global variable from another module.
+  bool canImportGlobalVar(GlobalValueSummary *S, bool AnalyzeRefs) const;
 };
 
 /// GraphTraits definition to build SCC for the index
@@ -1411,7 +1563,7 @@
 struct GraphTraits<ModuleSummaryIndex *> : public GraphTraits<ValueInfo> {
   static NodeRef getEntryNode(ModuleSummaryIndex *I) {
     std::unique_ptr<GlobalValueSummary> Root =
-        make_unique<FunctionSummary>(I->calculateCallGraphRoot());
+        std::make_unique<FunctionSummary>(I->calculateCallGraphRoot());
     GlobalValueSummaryInfo G(I->haveGVs());
     G.SummaryList.push_back(std::move(Root));
     static auto P =
@@ -1419,15 +1571,6 @@
     return ValueInfo(I->haveGVs(), &P);
   }
 };
-
-static inline bool canImportGlobalVar(GlobalValueSummary *S) {
-  assert(isa<GlobalVarSummary>(S->getBaseObject()));
-
-  // We don't import GV with references, because it can result
-  // in promotion of local variables in the source module.
-  return !GlobalValue::isInterposableLinkage(S->linkage()) &&
-         !S->notEligibleToImport() && S->refs().empty();
-}
 } // end namespace llvm
 
 #endif // LLVM_IR_MODULESUMMARYINDEX_H
diff --git a/linux-x64/clang/include/llvm/IR/ModuleSummaryIndexYAML.h b/linux-x64/clang/include/llvm/IR/ModuleSummaryIndexYAML.h
index 26d9c43..f7fa16d 100644
--- a/linux-x64/clang/include/llvm/IR/ModuleSummaryIndexYAML.h
+++ b/linux-x64/clang/include/llvm/IR/ModuleSummaryIndexYAML.h
@@ -17,6 +17,7 @@
 
 template <> struct ScalarEnumerationTraits<TypeTestResolution::Kind> {
   static void enumeration(IO &io, TypeTestResolution::Kind &value) {
+    io.enumCase(value, "Unknown", TypeTestResolution::Unknown);
     io.enumCase(value, "Unsat", TypeTestResolution::Unsat);
     io.enumCase(value, "ByteArray", TypeTestResolution::ByteArray);
     io.enumCase(value, "Inline", TypeTestResolution::Inline);
@@ -220,16 +221,18 @@
           V.emplace(RefGUID, /*IsAnalysis=*/false);
         Refs.push_back(ValueInfo(/*IsAnalysis=*/false, &*V.find(RefGUID)));
       }
-      Elem.SummaryList.push_back(llvm::make_unique<FunctionSummary>(
+      Elem.SummaryList.push_back(std::make_unique<FunctionSummary>(
           GlobalValueSummary::GVFlags(
               static_cast<GlobalValue::LinkageTypes>(FSum.Linkage),
-              FSum.NotEligibleToImport, FSum.Live, FSum.IsLocal, FSum.CanAutoHide),
+              FSum.NotEligibleToImport, FSum.Live, FSum.IsLocal,
+              FSum.CanAutoHide),
           /*NumInsts=*/0, FunctionSummary::FFlags{}, /*EntryCount=*/0, Refs,
           ArrayRef<FunctionSummary::EdgeTy>{}, std::move(FSum.TypeTests),
           std::move(FSum.TypeTestAssumeVCalls),
           std::move(FSum.TypeCheckedLoadVCalls),
           std::move(FSum.TypeTestAssumeConstVCalls),
-          std::move(FSum.TypeCheckedLoadConstVCalls)));
+          std::move(FSum.TypeCheckedLoadConstVCalls),
+          ArrayRef<FunctionSummary::ParamAccess>{}));
     }
   }
   static void output(IO &io, GlobalValueSummaryMapTy &V) {
@@ -262,7 +265,7 @@
   static void inputOne(IO &io, StringRef Key, TypeIdSummaryMapTy &V) {
     TypeIdSummary TId;
     io.mapRequired(Key.str().c_str(), TId);
-    V.insert({GlobalValue::getGUID(Key), {Key, TId}});
+    V.insert({GlobalValue::getGUID(Key), {std::string(Key), TId}});
   }
   static void output(IO &io, TypeIdSummaryMapTy &V) {
     for (auto TidIter = V.begin(); TidIter != V.end(); TidIter++)
diff --git a/linux-x64/clang/include/llvm/IR/NoFolder.h b/linux-x64/clang/include/llvm/IR/NoFolder.h
index 0e3c19f..dcffa6b 100644
--- a/linux-x64/clang/include/llvm/IR/NoFolder.h
+++ b/linux-x64/clang/include/llvm/IR/NoFolder.h
@@ -26,11 +26,14 @@
 #include "llvm/IR/InstrTypes.h"
 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/Instructions.h"
+#include "llvm/IR/IRBuilderFolder.h"
 
 namespace llvm {
 
 /// NoFolder - Create "constants" (actually, instructions) with no folding.
-class NoFolder {
+class NoFolder final : public IRBuilderFolder {
+  virtual void anchor();
+
 public:
   explicit NoFolder() = default;
 
@@ -39,105 +42,76 @@
   //===--------------------------------------------------------------------===//
 
   Instruction *CreateAdd(Constant *LHS, Constant *RHS,
-                         bool HasNUW = false, bool HasNSW = false) const {
+                         bool HasNUW = false,
+                         bool HasNSW = false) const override {
     BinaryOperator *BO = BinaryOperator::CreateAdd(LHS, RHS);
     if (HasNUW) BO->setHasNoUnsignedWrap();
     if (HasNSW) BO->setHasNoSignedWrap();
     return BO;
   }
 
-  Instruction *CreateNSWAdd(Constant *LHS, Constant *RHS) const {
-    return BinaryOperator::CreateNSWAdd(LHS, RHS);
-  }
-
-  Instruction *CreateNUWAdd(Constant *LHS, Constant *RHS) const {
-    return BinaryOperator::CreateNUWAdd(LHS, RHS);
-  }
-
-  Instruction *CreateFAdd(Constant *LHS, Constant *RHS) const {
+  Instruction *CreateFAdd(Constant *LHS, Constant *RHS) const override {
     return BinaryOperator::CreateFAdd(LHS, RHS);
   }
 
   Instruction *CreateSub(Constant *LHS, Constant *RHS,
-                         bool HasNUW = false, bool HasNSW = false) const {
+                         bool HasNUW = false,
+                         bool HasNSW = false) const override {
     BinaryOperator *BO = BinaryOperator::CreateSub(LHS, RHS);
     if (HasNUW) BO->setHasNoUnsignedWrap();
     if (HasNSW) BO->setHasNoSignedWrap();
     return BO;
   }
 
-  Instruction *CreateNSWSub(Constant *LHS, Constant *RHS) const {
-    return BinaryOperator::CreateNSWSub(LHS, RHS);
-  }
-
-  Instruction *CreateNUWSub(Constant *LHS, Constant *RHS) const {
-    return BinaryOperator::CreateNUWSub(LHS, RHS);
-  }
-
-  Instruction *CreateFSub(Constant *LHS, Constant *RHS) const {
+  Instruction *CreateFSub(Constant *LHS, Constant *RHS) const override {
     return BinaryOperator::CreateFSub(LHS, RHS);
   }
 
   Instruction *CreateMul(Constant *LHS, Constant *RHS,
-                         bool HasNUW = false, bool HasNSW = false) const {
+                         bool HasNUW = false,
+                         bool HasNSW = false) const override {
     BinaryOperator *BO = BinaryOperator::CreateMul(LHS, RHS);
     if (HasNUW) BO->setHasNoUnsignedWrap();
     if (HasNSW) BO->setHasNoSignedWrap();
     return BO;
   }
 
-  Instruction *CreateNSWMul(Constant *LHS, Constant *RHS) const {
-    return BinaryOperator::CreateNSWMul(LHS, RHS);
-  }
-
-  Instruction *CreateNUWMul(Constant *LHS, Constant *RHS) const {
-    return BinaryOperator::CreateNUWMul(LHS, RHS);
-  }
-
-  Instruction *CreateFMul(Constant *LHS, Constant *RHS) const {
+  Instruction *CreateFMul(Constant *LHS, Constant *RHS) const override {
     return BinaryOperator::CreateFMul(LHS, RHS);
   }
 
   Instruction *CreateUDiv(Constant *LHS, Constant *RHS,
-                          bool isExact = false) const {
+                          bool isExact = false) const override {
     if (!isExact)
       return BinaryOperator::CreateUDiv(LHS, RHS);
     return BinaryOperator::CreateExactUDiv(LHS, RHS);
   }
 
-  Instruction *CreateExactUDiv(Constant *LHS, Constant *RHS) const {
-    return BinaryOperator::CreateExactUDiv(LHS, RHS);
-  }
-
   Instruction *CreateSDiv(Constant *LHS, Constant *RHS,
-                          bool isExact = false) const {
+                          bool isExact = false) const override {
     if (!isExact)
       return BinaryOperator::CreateSDiv(LHS, RHS);
     return BinaryOperator::CreateExactSDiv(LHS, RHS);
   }
 
-  Instruction *CreateExactSDiv(Constant *LHS, Constant *RHS) const {
-    return BinaryOperator::CreateExactSDiv(LHS, RHS);
-  }
-
-  Instruction *CreateFDiv(Constant *LHS, Constant *RHS) const {
+  Instruction *CreateFDiv(Constant *LHS, Constant *RHS) const override {
     return BinaryOperator::CreateFDiv(LHS, RHS);
   }
 
-  Instruction *CreateURem(Constant *LHS, Constant *RHS) const {
+  Instruction *CreateURem(Constant *LHS, Constant *RHS) const override {
     return BinaryOperator::CreateURem(LHS, RHS);
   }
 
-  Instruction *CreateSRem(Constant *LHS, Constant *RHS) const {
+  Instruction *CreateSRem(Constant *LHS, Constant *RHS) const override {
     return BinaryOperator::CreateSRem(LHS, RHS);
   }
 
-  Instruction *CreateFRem(Constant *LHS, Constant *RHS) const {
+  Instruction *CreateFRem(Constant *LHS, Constant *RHS) const override {
     return BinaryOperator::CreateFRem(LHS, RHS);
   }
 
   Instruction *CreateShl(Constant *LHS, Constant *RHS, bool HasNUW = false,
-                         bool HasNSW = false) const {
+                         bool HasNSW = false) const override {
     BinaryOperator *BO = BinaryOperator::CreateShl(LHS, RHS);
     if (HasNUW) BO->setHasNoUnsignedWrap();
     if (HasNSW) BO->setHasNoSignedWrap();
@@ -145,33 +119,33 @@
   }
 
   Instruction *CreateLShr(Constant *LHS, Constant *RHS,
-                          bool isExact = false) const {
+                          bool isExact = false) const override {
     if (!isExact)
       return BinaryOperator::CreateLShr(LHS, RHS);
     return BinaryOperator::CreateExactLShr(LHS, RHS);
   }
 
   Instruction *CreateAShr(Constant *LHS, Constant *RHS,
-                          bool isExact = false) const {
+                          bool isExact = false) const override {
     if (!isExact)
       return BinaryOperator::CreateAShr(LHS, RHS);
     return BinaryOperator::CreateExactAShr(LHS, RHS);
   }
 
-  Instruction *CreateAnd(Constant *LHS, Constant *RHS) const {
+  Instruction *CreateAnd(Constant *LHS, Constant *RHS) const override {
     return BinaryOperator::CreateAnd(LHS, RHS);
   }
 
-  Instruction *CreateOr(Constant *LHS, Constant *RHS) const {
+  Instruction *CreateOr(Constant *LHS, Constant *RHS) const override {
     return BinaryOperator::CreateOr(LHS, RHS);
   }
 
-  Instruction *CreateXor(Constant *LHS, Constant *RHS) const {
+  Instruction *CreateXor(Constant *LHS, Constant *RHS) const override {
     return BinaryOperator::CreateXor(LHS, RHS);
   }
 
   Instruction *CreateBinOp(Instruction::BinaryOps Opc,
-                           Constant *LHS, Constant *RHS) const {
+                           Constant *LHS, Constant *RHS) const override {
     return BinaryOperator::Create(Opc, LHS, RHS);
   }
 
@@ -180,30 +154,24 @@
   //===--------------------------------------------------------------------===//
 
   Instruction *CreateNeg(Constant *C,
-                         bool HasNUW = false, bool HasNSW = false) const {
+                         bool HasNUW = false,
+                         bool HasNSW = false) const override {
     BinaryOperator *BO = BinaryOperator::CreateNeg(C);
     if (HasNUW) BO->setHasNoUnsignedWrap();
     if (HasNSW) BO->setHasNoSignedWrap();
     return BO;
   }
 
-  Instruction *CreateNSWNeg(Constant *C) const {
-    return BinaryOperator::CreateNSWNeg(C);
+  Instruction *CreateFNeg(Constant *C) const override {
+    return UnaryOperator::CreateFNeg(C);
   }
 
-  Instruction *CreateNUWNeg(Constant *C) const {
-    return BinaryOperator::CreateNUWNeg(C);
-  }
-
-  Instruction *CreateFNeg(Constant *C) const {
-    return BinaryOperator::CreateFNeg(C);
-  }
-
-  Instruction *CreateNot(Constant *C) const {
+  Instruction *CreateNot(Constant *C) const override {
     return BinaryOperator::CreateNot(C);
   }
 
-  Instruction *CreateUnOp(Instruction::UnaryOps Opc, Constant *C) const {
+  Instruction *CreateUnOp(Instruction::UnaryOps Opc,
+                          Constant *C) const override {
     return UnaryOperator::Create(Opc, C);
   }
 
@@ -212,11 +180,12 @@
   //===--------------------------------------------------------------------===//
 
   Constant *CreateGetElementPtr(Type *Ty, Constant *C,
-                                ArrayRef<Constant *> IdxList) const {
+                                ArrayRef<Constant *> IdxList) const override {
     return ConstantExpr::getGetElementPtr(Ty, C, IdxList);
   }
 
-  Constant *CreateGetElementPtr(Type *Ty, Constant *C, Constant *Idx) const {
+  Constant *CreateGetElementPtr(Type *Ty, Constant *C,
+                                Constant *Idx) const override {
     // This form of the function only exists to avoid ambiguous overload
     // warnings about whether to convert Idx to ArrayRef<Constant *> or
     // ArrayRef<Value *>.
@@ -224,25 +193,25 @@
   }
 
   Instruction *CreateGetElementPtr(Type *Ty, Constant *C,
-                                   ArrayRef<Value *> IdxList) const {
+                                   ArrayRef<Value *> IdxList) const override {
     return GetElementPtrInst::Create(Ty, C, IdxList);
   }
 
-  Constant *CreateInBoundsGetElementPtr(Type *Ty, Constant *C,
-                                        ArrayRef<Constant *> IdxList) const {
+  Constant *CreateInBoundsGetElementPtr(
+      Type *Ty, Constant *C, ArrayRef<Constant *> IdxList) const override {
     return ConstantExpr::getInBoundsGetElementPtr(Ty, C, IdxList);
   }
 
   Constant *CreateInBoundsGetElementPtr(Type *Ty, Constant *C,
-                                        Constant *Idx) const {
+                                        Constant *Idx) const override {
     // This form of the function only exists to avoid ambiguous overload
     // warnings about whether to convert Idx to ArrayRef<Constant *> or
     // ArrayRef<Value *>.
     return ConstantExpr::getInBoundsGetElementPtr(Ty, C, Idx);
   }
 
-  Instruction *CreateInBoundsGetElementPtr(Type *Ty, Constant *C,
-                                           ArrayRef<Value *> IdxList) const {
+  Instruction *CreateInBoundsGetElementPtr(
+      Type *Ty, Constant *C, ArrayRef<Value *> IdxList) const override {
     return GetElementPtrInst::CreateInBounds(Ty, C, IdxList);
   }
 
@@ -251,44 +220,49 @@
   //===--------------------------------------------------------------------===//
 
   Instruction *CreateCast(Instruction::CastOps Op, Constant *C,
-                    Type *DestTy) const {
+                          Type *DestTy) const override {
     return CastInst::Create(Op, C, DestTy);
   }
 
-  Instruction *CreatePointerCast(Constant *C, Type *DestTy) const {
+  Instruction *CreatePointerCast(Constant *C, Type *DestTy) const override {
     return CastInst::CreatePointerCast(C, DestTy);
   }
 
+  Instruction *CreatePointerBitCastOrAddrSpaceCast(
+      Constant *C, Type *DestTy) const override {
+    return CastInst::CreatePointerBitCastOrAddrSpaceCast(C, DestTy);
+  }
+
   Instruction *CreateIntCast(Constant *C, Type *DestTy,
-                       bool isSigned) const {
+                             bool isSigned) const override {
     return CastInst::CreateIntegerCast(C, DestTy, isSigned);
   }
 
-  Instruction *CreateFPCast(Constant *C, Type *DestTy) const {
+  Instruction *CreateFPCast(Constant *C, Type *DestTy) const override {
     return CastInst::CreateFPCast(C, DestTy);
   }
 
-  Instruction *CreateBitCast(Constant *C, Type *DestTy) const {
+  Instruction *CreateBitCast(Constant *C, Type *DestTy) const override {
     return CreateCast(Instruction::BitCast, C, DestTy);
   }
 
-  Instruction *CreateIntToPtr(Constant *C, Type *DestTy) const {
+  Instruction *CreateIntToPtr(Constant *C, Type *DestTy) const override {
     return CreateCast(Instruction::IntToPtr, C, DestTy);
   }
 
-  Instruction *CreatePtrToInt(Constant *C, Type *DestTy) const {
+  Instruction *CreatePtrToInt(Constant *C, Type *DestTy) const override {
     return CreateCast(Instruction::PtrToInt, C, DestTy);
   }
 
-  Instruction *CreateZExtOrBitCast(Constant *C, Type *DestTy) const {
+  Instruction *CreateZExtOrBitCast(Constant *C, Type *DestTy) const override {
     return CastInst::CreateZExtOrBitCast(C, DestTy);
   }
 
-  Instruction *CreateSExtOrBitCast(Constant *C, Type *DestTy) const {
+  Instruction *CreateSExtOrBitCast(Constant *C, Type *DestTy) const override {
     return CastInst::CreateSExtOrBitCast(C, DestTy);
   }
 
-  Instruction *CreateTruncOrBitCast(Constant *C, Type *DestTy) const {
+  Instruction *CreateTruncOrBitCast(Constant *C, Type *DestTy) const override {
     return CastInst::CreateTruncOrBitCast(C, DestTy);
   }
 
@@ -297,12 +271,12 @@
   //===--------------------------------------------------------------------===//
 
   Instruction *CreateICmp(CmpInst::Predicate P,
-                          Constant *LHS, Constant *RHS) const {
+                          Constant *LHS, Constant *RHS) const override {
     return new ICmpInst(P, LHS, RHS);
   }
 
   Instruction *CreateFCmp(CmpInst::Predicate P,
-                          Constant *LHS, Constant *RHS) const {
+                          Constant *LHS, Constant *RHS) const override {
     return new FCmpInst(P, LHS, RHS);
   }
 
@@ -311,31 +285,32 @@
   //===--------------------------------------------------------------------===//
 
   Instruction *CreateSelect(Constant *C,
-                            Constant *True, Constant *False) const {
+                            Constant *True, Constant *False) const override {
     return SelectInst::Create(C, True, False);
   }
 
-  Instruction *CreateExtractElement(Constant *Vec, Constant *Idx) const {
+  Instruction *CreateExtractElement(Constant *Vec,
+                                    Constant *Idx) const override {
     return ExtractElementInst::Create(Vec, Idx);
   }
 
   Instruction *CreateInsertElement(Constant *Vec, Constant *NewElt,
-                                   Constant *Idx) const {
+                                   Constant *Idx) const override {
     return InsertElementInst::Create(Vec, NewElt, Idx);
   }
 
   Instruction *CreateShuffleVector(Constant *V1, Constant *V2,
-                                   Constant *Mask) const {
+                                   ArrayRef<int> Mask) const override {
     return new ShuffleVectorInst(V1, V2, Mask);
   }
 
   Instruction *CreateExtractValue(Constant *Agg,
-                                  ArrayRef<unsigned> IdxList) const {
+                                  ArrayRef<unsigned> IdxList) const override {
     return ExtractValueInst::Create(Agg, IdxList);
   }
 
   Instruction *CreateInsertValue(Constant *Agg, Constant *Val,
-                                 ArrayRef<unsigned> IdxList) const {
+                                 ArrayRef<unsigned> IdxList) const override {
     return InsertValueInst::Create(Agg, Val, IdxList);
   }
 };
diff --git a/linux-x64/clang/include/llvm/IR/Operator.h b/linux-x64/clang/include/llvm/IR/Operator.h
index 8199c65..acfacbd 100644
--- a/linux-x64/clang/include/llvm/IR/Operator.h
+++ b/linux-x64/clang/include/llvm/IR/Operator.h
@@ -66,6 +66,7 @@
 class OverflowingBinaryOperator : public Operator {
 public:
   enum {
+    AnyWrap        = 0,
     NoUnsignedWrap = (1 << 0),
     NoSignedWrap   = (1 << 1)
   };
@@ -379,16 +380,29 @@
       return false;
 
     switch (Opcode) {
+    case Instruction::FNeg:
+    case Instruction::FAdd:
+    case Instruction::FSub:
+    case Instruction::FMul:
+    case Instruction::FDiv:
+    case Instruction::FRem:
+    // FIXME: To clean up and correct the semantics of fast-math-flags, FCmp
+    //        should not be treated as a math op, but the other opcodes should.
+    //        This would make things consistent with Select/PHI (FP value type
+    //        determines whether they are math ops and, therefore, capable of
+    //        having fast-math-flags).
     case Instruction::FCmp:
       return true;
-    // non math FP Operators (no FMF)
-    case Instruction::ExtractElement:
-    case Instruction::ShuffleVector:
-    case Instruction::InsertElement:
     case Instruction::PHI:
-      return false;
+    case Instruction::Select:
+    case Instruction::Call: {
+      Type *Ty = V->getType();
+      while (ArrayType *ArrTy = dyn_cast<ArrayType>(Ty))
+        Ty = ArrTy->getElementType();
+      return Ty->isFPOrFPVectorTy();
+    }
     default:
-      return V->getType()->isFPOrFPVectorTy();
+      return false;
     }
   }
 };
@@ -531,15 +545,29 @@
       });
   }
 
+  /// Compute the maximum alignment that this GEP is garranteed to preserve.
+  Align getMaxPreservedAlignment(const DataLayout &DL) const;
+
   /// Accumulate the constant address offset of this GEP if possible.
   ///
-  /// This routine accepts an APInt into which it will accumulate the constant
-  /// offset of this GEP if the GEP is in fact constant. If the GEP is not
-  /// all-constant, it returns false and the value of the offset APInt is
-  /// undefined (it is *not* preserved!). The APInt passed into this routine
-  /// must be at exactly as wide as the IntPtr type for the address space of the
-  /// base GEP pointer.
-  bool accumulateConstantOffset(const DataLayout &DL, APInt &Offset) const;
+  /// This routine accepts an APInt into which it will try to accumulate the
+  /// constant offset of this GEP.
+  ///
+  /// If \p ExternalAnalysis is provided it will be used to calculate a offset
+  /// when a operand of GEP is not constant.
+  /// For example, for a value \p ExternalAnalysis might try to calculate a
+  /// lower bound. If \p ExternalAnalysis is successful, it should return true.
+  ///
+  /// If the \p ExternalAnalysis returns false or the value returned by \p
+  /// ExternalAnalysis results in a overflow/underflow, this routine returns
+  /// false and the value of the offset APInt is undefined (it is *not*
+  /// preserved!).
+  ///
+  /// The APInt passed into this routine must be at exactly as wide as the
+  /// IntPtr type for the address space of the base GEP pointer.
+  bool accumulateConstantOffset(
+      const DataLayout &DL, APInt &Offset,
+      function_ref<bool(Value &, APInt &)> ExternalAnalysis = nullptr) const;
 };
 
 class PtrToIntOperator
@@ -585,6 +613,25 @@
   }
 };
 
+class AddrSpaceCastOperator
+    : public ConcreteOperator<Operator, Instruction::AddrSpaceCast> {
+  friend class AddrSpaceCastInst;
+  friend class ConstantExpr;
+
+public:
+  Value *getPointerOperand() { return getOperand(0); }
+
+  const Value *getPointerOperand() const { return getOperand(0); }
+
+  unsigned getSrcAddressSpace() const {
+    return getPointerOperand()->getType()->getPointerAddressSpace();
+  }
+
+  unsigned getDestAddressSpace() const {
+    return getType()->getPointerAddressSpace();
+  }
+};
+
 } // end namespace llvm
 
 #endif // LLVM_IR_OPERATOR_H
diff --git a/linux-x64/clang/include/llvm/IR/OptBisect.h b/linux-x64/clang/include/llvm/IR/OptBisect.h
index 1b2b0bd..6c2a1b0 100644
--- a/linux-x64/clang/include/llvm/IR/OptBisect.h
+++ b/linux-x64/clang/include/llvm/IR/OptBisect.h
@@ -15,6 +15,7 @@
 #define LLVM_IR_OPTBISECT_H
 
 #include "llvm/ADT/StringRef.h"
+#include "llvm/Support/ManagedStatic.h"
 
 namespace llvm {
 
@@ -32,7 +33,7 @@
     return true;
   }
 
-  /// isEnabled should return true before calling shouldRunPass
+  /// isEnabled() should return true before calling shouldRunPass().
   virtual bool isEnabled() const { return false; }
 };
 
@@ -55,6 +56,14 @@
 
   /// Checks the bisect limit to determine if the specified pass should run.
   ///
+  /// This forwards to checkPass().
+  bool shouldRunPass(const Pass *P, StringRef IRDescription) override;
+
+  /// isEnabled() should return true before calling shouldRunPass().
+  bool isEnabled() const override { return BisectEnabled; }
+
+  /// Checks the bisect limit to determine if the specified pass should run.
+  ///
   /// If the bisect limit is set to -1, the function prints a message describing
   /// the pass and the bisect number assigned to it and return true.  Otherwise,
   /// the function prints a message with the bisect number assigned to the
@@ -64,17 +73,16 @@
   /// Most passes should not call this routine directly. Instead, they are
   /// called through helper routines provided by the pass base classes.  For
   /// instance, function passes should call FunctionPass::skipFunction().
-  bool shouldRunPass(const Pass *P, StringRef IRDescription) override;
-
-  /// isEnabled should return true before calling shouldRunPass
-  bool isEnabled() const override { return BisectEnabled; }
-private:
   bool checkPass(const StringRef PassName, const StringRef TargetDesc);
 
+private:
   bool BisectEnabled = false;
   unsigned LastBisectNum = 0;
 };
 
+/// Singleton instance of the OptBisect class, so multiple pass managers don't
+/// need to coordinate their uses of OptBisect.
+extern ManagedStatic<OptBisect> OptBisector;
 } // end namespace llvm
 
 #endif // LLVM_IR_OPTBISECT_H
diff --git a/linux-x64/clang/include/llvm/IR/PassInstrumentation.h b/linux-x64/clang/include/llvm/IR/PassInstrumentation.h
index f8a1196..291f324 100644
--- a/linux-x64/clang/include/llvm/IR/PassInstrumentation.h
+++ b/linux-x64/clang/include/llvm/IR/PassInstrumentation.h
@@ -44,10 +44,6 @@
 ///      of a pass. For those callbacks returning false means pass will not be
 ///      executed.
 ///
-/// TODO: currently there is no way for a pass to opt-out of execution control
-/// (e.g. become unskippable). PassManager is the only entity that determines
-/// how pass instrumentation affects pass execution.
-///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_IR_PASSINSTRUMENTATION_H
@@ -56,12 +52,13 @@
 #include "llvm/ADT/Any.h"
 #include "llvm/ADT/FunctionExtras.h"
 #include "llvm/ADT/SmallVector.h"
-#include "llvm/Support/TypeName.h"
+#include "llvm/ADT/StringMap.h"
 #include <type_traits>
 
 namespace llvm {
 
 class PreservedAnalyses;
+class StringRef;
 
 /// This class manages callbacks registration, as well as provides a way for
 /// PassInstrumentation to pass control to the registered callbacks.
@@ -71,13 +68,17 @@
   // to take them as constant pointers, wrapped with llvm::Any.
   // For the case when IRUnit has been invalidated there is a different
   // callback to use - AfterPassInvalidated.
+  // We call all BeforePassFuncs to determine if a pass should run or not.
+  // BeforeNonSkippedPassFuncs are called only if the pass should run.
   // TODO: currently AfterPassInvalidated does not accept IRUnit, since passing
-  // already invalidated IRUnit is unsafe. There are ways to handle invalidated IRUnits
-  // in a safe way, and we might pursue that as soon as there is a useful instrumentation
-  // that needs it.
+  // already invalidated IRUnit is unsafe. There are ways to handle invalidated
+  // IRUnits in a safe way, and we might pursue that as soon as there is a
+  // useful instrumentation that needs it.
   using BeforePassFunc = bool(StringRef, Any);
-  using AfterPassFunc = void(StringRef, Any);
-  using AfterPassInvalidatedFunc = void(StringRef);
+  using BeforeSkippedPassFunc = void(StringRef, Any);
+  using BeforeNonSkippedPassFunc = void(StringRef, Any);
+  using AfterPassFunc = void(StringRef, Any, const PreservedAnalyses &);
+  using AfterPassInvalidatedFunc = void(StringRef, const PreservedAnalyses &);
   using BeforeAnalysisFunc = void(StringRef, Any);
   using AfterAnalysisFunc = void(StringRef, Any);
 
@@ -88,8 +89,19 @@
   PassInstrumentationCallbacks(const PassInstrumentationCallbacks &) = delete;
   void operator=(const PassInstrumentationCallbacks &) = delete;
 
-  template <typename CallableT> void registerBeforePassCallback(CallableT C) {
-    BeforePassCallbacks.emplace_back(std::move(C));
+  template <typename CallableT>
+  void registerShouldRunOptionalPassCallback(CallableT C) {
+    ShouldRunOptionalPassCallbacks.emplace_back(std::move(C));
+  }
+
+  template <typename CallableT>
+  void registerBeforeSkippedPassCallback(CallableT C) {
+    BeforeSkippedPassCallbacks.emplace_back(std::move(C));
+  }
+
+  template <typename CallableT>
+  void registerBeforeNonSkippedPassCallback(CallableT C) {
+    BeforeNonSkippedPassCallbacks.emplace_back(std::move(C));
   }
 
   template <typename CallableT> void registerAfterPassCallback(CallableT C) {
@@ -111,17 +123,37 @@
     AfterAnalysisCallbacks.emplace_back(std::move(C));
   }
 
+  /// Add a class name to pass name mapping for use by pass instrumentation.
+  void addClassToPassName(StringRef ClassName, StringRef PassName);
+  /// Get the pass name for a given pass class name.
+  StringRef getPassNameForClassName(StringRef ClassName);
+
 private:
   friend class PassInstrumentation;
 
-  SmallVector<llvm::unique_function<BeforePassFunc>, 4> BeforePassCallbacks;
+  /// These are only run on passes that are not required. They return false when
+  /// an optional pass should be skipped.
+  SmallVector<llvm::unique_function<BeforePassFunc>, 4>
+      ShouldRunOptionalPassCallbacks;
+  /// These are run on passes that are skipped.
+  SmallVector<llvm::unique_function<BeforeSkippedPassFunc>, 4>
+      BeforeSkippedPassCallbacks;
+  /// These are run on passes that are about to be run.
+  SmallVector<llvm::unique_function<BeforeNonSkippedPassFunc>, 4>
+      BeforeNonSkippedPassCallbacks;
+  /// These are run on passes that have just run.
   SmallVector<llvm::unique_function<AfterPassFunc>, 4> AfterPassCallbacks;
+  /// These are run passes that have just run on invalidated IR.
   SmallVector<llvm::unique_function<AfterPassInvalidatedFunc>, 4>
       AfterPassInvalidatedCallbacks;
+  /// These are run on analyses that are about to be run.
   SmallVector<llvm::unique_function<BeforeAnalysisFunc>, 4>
       BeforeAnalysisCallbacks;
+  /// These are run on analyses that have been run.
   SmallVector<llvm::unique_function<AfterAnalysisFunc>, 4>
       AfterAnalysisCallbacks;
+
+  StringMap<std::string> ClassToPassName;
 };
 
 /// This class provides instrumentation entry points for the Pass Manager,
@@ -129,6 +161,26 @@
 class PassInstrumentation {
   PassInstrumentationCallbacks *Callbacks;
 
+  // Template argument PassT of PassInstrumentation::runBeforePass could be two
+  // kinds: (1) a regular pass inherited from PassInfoMixin (happen when
+  // creating a adaptor pass for a regular pass); (2) a type-erased PassConcept
+  // created from (1). Here we want to make case (1) skippable unconditionally
+  // since they are regular passes. We call PassConcept::isRequired to decide
+  // for case (2).
+  template <typename PassT>
+  using has_required_t = decltype(std::declval<PassT &>().isRequired());
+
+  template <typename PassT>
+  static std::enable_if_t<is_detected<has_required_t, PassT>::value, bool>
+  isRequired(const PassT &Pass) {
+    return Pass.isRequired();
+  }
+  template <typename PassT>
+  static std::enable_if_t<!is_detected<has_required_t, PassT>::value, bool>
+  isRequired(const PassT &Pass) {
+    return false;
+  }
+
 public:
   /// Callbacks object is not owned by PassInstrumentation, its life-time
   /// should at least match the life-time of corresponding
@@ -139,15 +191,28 @@
 
   /// BeforePass instrumentation point - takes \p Pass instance to be executed
   /// and constant reference to IR it operates on. \Returns true if pass is
-  /// allowed to be executed.
+  /// allowed to be executed. These are only run on optional pass since required
+  /// passes must always be run. This allows these callbacks to print info when
+  /// they want to skip a pass.
   template <typename IRUnitT, typename PassT>
   bool runBeforePass(const PassT &Pass, const IRUnitT &IR) const {
     if (!Callbacks)
       return true;
 
     bool ShouldRun = true;
-    for (auto &C : Callbacks->BeforePassCallbacks)
-      ShouldRun &= C(Pass.name(), llvm::Any(&IR));
+    if (!isRequired(Pass)) {
+      for (auto &C : Callbacks->ShouldRunOptionalPassCallbacks)
+        ShouldRun &= C(Pass.name(), llvm::Any(&IR));
+    }
+
+    if (ShouldRun) {
+      for (auto &C : Callbacks->BeforeNonSkippedPassCallbacks)
+        C(Pass.name(), llvm::Any(&IR));
+    } else {
+      for (auto &C : Callbacks->BeforeSkippedPassCallbacks)
+        C(Pass.name(), llvm::Any(&IR));
+    }
+
     return ShouldRun;
   }
 
@@ -155,20 +220,22 @@
   /// just been executed and constant reference to \p IR it operates on.
   /// \p IR is guaranteed to be valid at this point.
   template <typename IRUnitT, typename PassT>
-  void runAfterPass(const PassT &Pass, const IRUnitT &IR) const {
+  void runAfterPass(const PassT &Pass, const IRUnitT &IR,
+                    const PreservedAnalyses &PA) const {
     if (Callbacks)
       for (auto &C : Callbacks->AfterPassCallbacks)
-        C(Pass.name(), llvm::Any(&IR));
+        C(Pass.name(), llvm::Any(&IR), PA);
   }
 
   /// AfterPassInvalidated instrumentation point - takes \p Pass instance
   /// that has just been executed. For use when IR has been invalidated
   /// by \p Pass execution.
   template <typename IRUnitT, typename PassT>
-  void runAfterPassInvalidated(const PassT &Pass) const {
+  void runAfterPassInvalidated(const PassT &Pass,
+                               const PreservedAnalyses &PA) const {
     if (Callbacks)
       for (auto &C : Callbacks->AfterPassInvalidatedCallbacks)
-        C(Pass.name());
+        C(Pass.name(), PA);
   }
 
   /// BeforeAnalysis instrumentation point - takes \p Analysis instance
@@ -199,8 +266,20 @@
                   ExtraArgsT...) {
     return false;
   }
+
+  template <typename CallableT>
+  void pushBeforeNonSkippedPassCallback(CallableT C) {
+    if (Callbacks)
+      Callbacks->BeforeNonSkippedPassCallbacks.emplace_back(std::move(C));
+  }
+  void popBeforeNonSkippedPassCallback() {
+    if (Callbacks)
+      Callbacks->BeforeNonSkippedPassCallbacks.pop_back();
+  }
 };
 
+bool isSpecialPass(StringRef PassID, const std::vector<StringRef> &Specials);
+
 } // namespace llvm
 
 #endif
diff --git a/linux-x64/clang/include/llvm/IR/PassManager.h b/linux-x64/clang/include/llvm/IR/PassManager.h
index 37fe2a5..c669565 100644
--- a/linux-x64/clang/include/llvm/IR/PassManager.h
+++ b/linux-x64/clang/include/llvm/IR/PassManager.h
@@ -38,6 +38,7 @@
 #define LLVM_IR_PASSMANAGER_H
 
 #include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/TinyPtrVector.h"
@@ -45,9 +46,10 @@
 #include "llvm/IR/Module.h"
 #include "llvm/IR/PassInstrumentation.h"
 #include "llvm/IR/PassManagerInternal.h"
+#include "llvm/Pass.h"
 #include "llvm/Support/Debug.h"
+#include "llvm/Support/TimeProfiler.h"
 #include "llvm/Support/TypeName.h"
-#include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cassert>
 #include <cstring>
@@ -418,7 +420,7 @@
 typename PassT::Result
 getAnalysisResultUnpackTuple(AnalysisManagerT &AM, IRUnitT &IR,
                              std::tuple<ArgTs...> Args,
-                             llvm::index_sequence<Ns...>) {
+                             std::index_sequence<Ns...>) {
   (void)Args;
   return AM.template getResult<PassT>(IR, std::get<Ns>(Args)...);
 }
@@ -435,7 +437,7 @@
                   std::tuple<MainArgTs...> Args) {
   return (getAnalysisResultUnpackTuple<
           PassT, IRUnitT>)(AM, IR, Args,
-                           llvm::index_sequence_for<AnalysisArgTs...>{});
+                           std::index_sequence_for<AnalysisArgTs...>{});
 }
 
 } // namespace detail
@@ -502,9 +504,6 @@
 
     for (unsigned Idx = 0, Size = Passes.size(); Idx != Size; ++Idx) {
       auto *P = Passes[Idx].get();
-      if (DebugLogging)
-        dbgs() << "Running pass: " << P->name() << " on " << IR.getName()
-               << "\n";
 
       // Check the PassInstrumentation's BeforePass callbacks before running the
       // pass, skip its execution completely if asked to (callback returns
@@ -512,11 +511,15 @@
       if (!PI.runBeforePass<IRUnitT>(*P, IR))
         continue;
 
-      PreservedAnalyses PassPA = P->run(IR, AM, ExtraArgs...);
+      PreservedAnalyses PassPA;
+      {
+        TimeTraceScope TimeScope(P->name(), IR.getName());
+        PassPA = P->run(IR, AM, ExtraArgs...);
+      }
 
       // Call onto PassInstrumentation's AfterPass callbacks immediately after
       // running the pass.
-      PI.runAfterPass<IRUnitT>(*P, IR);
+      PI.runAfterPass<IRUnitT>(*P, IR, PassPA);
 
       // Update the analysis manager as each pass runs and potentially
       // invalidates analyses.
@@ -545,7 +548,9 @@
     return PA;
   }
 
-  template <typename PassT> void addPass(PassT Pass) {
+  template <typename PassT>
+  std::enable_if_t<!std::is_same<PassT, PassManager>::value>
+  addPass(PassT Pass) {
     using PassModelT =
         detail::PassModel<IRUnitT, PassT, PreservedAnalyses, AnalysisManagerT,
                           ExtraArgTs...>;
@@ -553,7 +558,24 @@
     Passes.emplace_back(new PassModelT(std::move(Pass)));
   }
 
-private:
+  /// When adding a pass manager pass that has the same type as this pass
+  /// manager, simply move the passes over. This is because we don't have use
+  /// cases rely on executing nested pass managers. Doing this could reduce
+  /// implementation complexity and avoid potential invalidation issues that may
+  /// happen with nested pass managers of the same type.
+  template <typename PassT>
+  std::enable_if_t<std::is_same<PassT, PassManager>::value>
+  addPass(PassT &&Pass) {
+    for (auto &P : Pass.Passes)
+      Passes.emplace_back(std::move(P));
+  }
+
+  /// Returns if the pass manager contains any passes.
+  bool isEmpty() const { return Passes.empty(); }
+
+  static bool isRequired() { return true; }
+
+protected:
   using PassConceptT =
       detail::PassConcept<IRUnitT, AnalysisManagerT, ExtraArgTs...>;
 
@@ -643,7 +665,7 @@
   /// when any of its embedded analysis results end up invalidated. We pass an
   /// \c Invalidator object as an argument to \c invalidate() in order to let
   /// the analysis results themselves define the dependency graph on the fly.
-  /// This lets us avoid building building an explicit representation of the
+  /// This lets us avoid building an explicit representation of the
   /// dependencies between analysis results.
   class Invalidator {
   public:
@@ -726,9 +748,9 @@
   /// Construct an empty analysis manager.
   ///
   /// If \p DebugLogging is true, we'll log our progress to llvm::dbgs().
-  AnalysisManager(bool DebugLogging = false) : DebugLogging(DebugLogging) {}
-  AnalysisManager(AnalysisManager &&) = default;
-  AnalysisManager &operator=(AnalysisManager &&) = default;
+  AnalysisManager(bool DebugLogging = false);
+  AnalysisManager(AnalysisManager &&);
+  AnalysisManager &operator=(AnalysisManager &&);
 
   /// Returns true if the analysis manager has an empty results cache.
   bool empty() const {
@@ -743,20 +765,7 @@
   /// This doesn't invalidate, but instead simply deletes, the relevant results.
   /// It is useful when the IR is being removed and we want to clear out all the
   /// memory pinned for it.
-  void clear(IRUnitT &IR, llvm::StringRef Name) {
-    if (DebugLogging)
-      dbgs() << "Clearing all analysis results for: " << Name << "\n";
-
-    auto ResultsListI = AnalysisResultLists.find(&IR);
-    if (ResultsListI == AnalysisResultLists.end())
-      return;
-    // Delete the map entries that point into the results list.
-    for (auto &IDAndResult : ResultsListI->second)
-      AnalysisResults.erase({IDAndResult.first, &IR});
-
-    // And actually destroy and erase the results associated with this IR.
-    AnalysisResultLists.erase(ResultsListI);
-  }
+  void clear(IRUnitT &IR, llvm::StringRef Name);
 
   /// Clear all analysis results cached by this AnalysisManager.
   ///
@@ -807,6 +816,16 @@
     return &static_cast<ResultModelT *>(ResultConcept)->Result;
   }
 
+  /// Verify that the given Result cannot be invalidated, assert otherwise.
+  template <typename PassT>
+  void verifyNotInvalidated(IRUnitT &IR, typename PassT::Result *Result) const {
+    PreservedAnalyses PA = PreservedAnalyses::none();
+    SmallDenseMap<AnalysisKey *, bool, 8> IsResultInvalidated;
+    Invalidator Inv(IsResultInvalidated, AnalysisResults);
+    assert(!Result->invalidate(IR, PA, Inv) &&
+           "Cached result cannot be invalidated");
+  }
+
   /// Register an analysis pass with the manager.
   ///
   /// The parameter is a callable whose result is an analysis pass. This allows
@@ -841,7 +860,7 @@
     return true;
   }
 
-  /// Invalidate a specific analysis pass for an IR module.
+  /// Invalidate a specific analysis pass for an IR unit.
   ///
   /// Note that the analysis result can disregard invalidation, if it determines
   /// it is in fact still valid.
@@ -855,67 +874,7 @@
   ///
   /// Walk through all of the analyses pertaining to this unit of IR and
   /// invalidate them, unless they are preserved by the PreservedAnalyses set.
-  void invalidate(IRUnitT &IR, const PreservedAnalyses &PA) {
-    // We're done if all analyses on this IR unit are preserved.
-    if (PA.allAnalysesInSetPreserved<AllAnalysesOn<IRUnitT>>())
-      return;
-
-    if (DebugLogging)
-      dbgs() << "Invalidating all non-preserved analyses for: " << IR.getName()
-             << "\n";
-
-    // Track whether each analysis's result is invalidated in
-    // IsResultInvalidated.
-    SmallDenseMap<AnalysisKey *, bool, 8> IsResultInvalidated;
-    Invalidator Inv(IsResultInvalidated, AnalysisResults);
-    AnalysisResultListT &ResultsList = AnalysisResultLists[&IR];
-    for (auto &AnalysisResultPair : ResultsList) {
-      // This is basically the same thing as Invalidator::invalidate, but we
-      // can't call it here because we're operating on the type-erased result.
-      // Moreover if we instead called invalidate() directly, it would do an
-      // unnecessary look up in ResultsList.
-      AnalysisKey *ID = AnalysisResultPair.first;
-      auto &Result = *AnalysisResultPair.second;
-
-      auto IMapI = IsResultInvalidated.find(ID);
-      if (IMapI != IsResultInvalidated.end())
-        // This result was already handled via the Invalidator.
-        continue;
-
-      // Try to invalidate the result, giving it the Invalidator so it can
-      // recursively query for any dependencies it has and record the result.
-      // Note that we cannot reuse 'IMapI' here or pre-insert the ID, as
-      // Result.invalidate may insert things into the map, invalidating our
-      // iterator.
-      bool Inserted =
-          IsResultInvalidated.insert({ID, Result.invalidate(IR, PA, Inv)})
-              .second;
-      (void)Inserted;
-      assert(Inserted && "Should never have already inserted this ID, likely "
-                         "indicates a cycle!");
-    }
-
-    // Now erase the results that were marked above as invalidated.
-    if (!IsResultInvalidated.empty()) {
-      for (auto I = ResultsList.begin(), E = ResultsList.end(); I != E;) {
-        AnalysisKey *ID = I->first;
-        if (!IsResultInvalidated.lookup(ID)) {
-          ++I;
-          continue;
-        }
-
-        if (DebugLogging)
-          dbgs() << "Invalidating analysis: " << this->lookUpPass(ID).name()
-                 << " on " << IR.getName() << "\n";
-
-        I = ResultsList.erase(I);
-        AnalysisResults.erase({ID, &IR});
-      }
-    }
-
-    if (ResultsList.empty())
-      AnalysisResultLists.erase(&IR);
-  }
+  void invalidate(IRUnitT &IR, const PreservedAnalyses &PA);
 
 private:
   /// Look up a registered analysis pass.
@@ -936,41 +895,7 @@
 
   /// Get an analysis result, running the pass if necessary.
   ResultConceptT &getResultImpl(AnalysisKey *ID, IRUnitT &IR,
-                                ExtraArgTs... ExtraArgs) {
-    typename AnalysisResultMapT::iterator RI;
-    bool Inserted;
-    std::tie(RI, Inserted) = AnalysisResults.insert(std::make_pair(
-        std::make_pair(ID, &IR), typename AnalysisResultListT::iterator()));
-
-    // If we don't have a cached result for this function, look up the pass and
-    // run it to produce a result, which we then add to the cache.
-    if (Inserted) {
-      auto &P = this->lookUpPass(ID);
-      if (DebugLogging)
-        dbgs() << "Running analysis: " << P.name() << " on " << IR.getName()
-               << "\n";
-
-      PassInstrumentation PI;
-      if (ID != PassInstrumentationAnalysis::ID()) {
-        PI = getResult<PassInstrumentationAnalysis>(IR, ExtraArgs...);
-        PI.runBeforeAnalysis(P, IR);
-      }
-
-      AnalysisResultListT &ResultList = AnalysisResultLists[&IR];
-      ResultList.emplace_back(ID, P.run(IR, *this, ExtraArgs...));
-
-      PI.runAfterAnalysis(P, IR);
-
-      // P.run may have inserted elements into AnalysisResults and invalidated
-      // RI.
-      RI = AnalysisResults.find({ID, &IR});
-      assert(RI != AnalysisResults.end() && "we just inserted it!");
-
-      RI->second = std::prev(ResultList.end());
-    }
-
-    return *RI->second->second;
-  }
+                                ExtraArgTs... ExtraArgs);
 
   /// Get a cached analysis result or return null.
   ResultConceptT *getCachedResultImpl(AnalysisKey *ID, IRUnitT &IR) const {
@@ -979,7 +904,7 @@
     return RI == AnalysisResults.end() ? nullptr : &*RI->second->second;
   }
 
-  /// Invalidate a function pass result.
+  /// Invalidate a pass result for a IR unit.
   void invalidateImpl(AnalysisKey *ID, IRUnitT &IR) {
     typename AnalysisResultMapT::iterator RI =
         AnalysisResults.find({ID, &IR});
@@ -993,20 +918,20 @@
     AnalysisResults.erase(RI);
   }
 
-  /// Map type from module analysis pass ID to pass concept pointer.
+  /// Map type from analysis pass ID to pass concept pointer.
   using AnalysisPassMapT =
       DenseMap<AnalysisKey *, std::unique_ptr<PassConceptT>>;
 
-  /// Collection of module analysis passes, indexed by ID.
+  /// Collection of analysis passes, indexed by ID.
   AnalysisPassMapT AnalysisPasses;
 
-  /// Map from function to a list of function analysis results.
+  /// Map from IR unit to a list of analysis results.
   ///
-  /// Provides linear time removal of all analysis results for a function and
+  /// Provides linear time removal of all analysis results for a IR unit and
   /// the ultimate storage for a particular cached analysis result.
   AnalysisResultListMapT AnalysisResultLists;
 
-  /// Map from an analysis ID and function to a particular cached
+  /// Map from an analysis ID and IR unit to a particular cached
   /// analysis result.
   AnalysisResultMapT AnalysisResults;
 
@@ -1150,7 +1075,16 @@
 ///
 /// This proxy only exposes the const interface of the outer analysis manager,
 /// to indicate that you cannot cause an outer analysis to run from within an
-/// inner pass.  Instead, you must rely on the \c getCachedResult API.
+/// inner pass.  Instead, you must rely on the \c getCachedResult API.  This is
+/// due to keeping potential future concurrency in mind. To give an example,
+/// running a module analysis before any function passes may give a different
+/// result than running it in a function pass. Both may be valid, but it would
+/// produce non-deterministic results. GlobalsAA is a good analysis example,
+/// because the cached information has the mod/ref info for all memory for each
+/// function at the time the analysis was computed. The information is still
+/// valid after a function transformation, but it may be *different* if
+/// recomputed after that transform. GlobalsAA is never invalidated.
+
 ///
 /// This proxy doesn't manage invalidation in any way -- that is handled by the
 /// recursive return path of each layer of the pass manager.  A consequence of
@@ -1164,9 +1098,26 @@
   /// Result proxy object for \c OuterAnalysisManagerProxy.
   class Result {
   public:
-    explicit Result(const AnalysisManagerT &AM) : AM(&AM) {}
+    explicit Result(const AnalysisManagerT &OuterAM) : OuterAM(&OuterAM) {}
 
-    const AnalysisManagerT &getManager() const { return *AM; }
+    /// Get a cached analysis. If the analysis can be invalidated, this will
+    /// assert.
+    template <typename PassT, typename IRUnitTParam>
+    typename PassT::Result *getCachedResult(IRUnitTParam &IR) const {
+      typename PassT::Result *Res =
+          OuterAM->template getCachedResult<PassT>(IR);
+      if (Res)
+        OuterAM->template verifyNotInvalidated<PassT>(IR, Res);
+      return Res;
+    }
+
+    /// Method provided for unit testing, not intended for general use.
+    template <typename PassT, typename IRUnitTParam>
+    bool cachedResultExists(IRUnitTParam &IR) const {
+      typename PassT::Result *Res =
+          OuterAM->template getCachedResult<PassT>(IR);
+      return Res != nullptr;
+    }
 
     /// When invalidation occurs, remove any registered invalidation events.
     bool invalidate(
@@ -1178,9 +1129,9 @@
       for (auto &KeyValuePair : OuterAnalysisInvalidationMap) {
         AnalysisKey *OuterID = KeyValuePair.first;
         auto &InnerIDs = KeyValuePair.second;
-        InnerIDs.erase(llvm::remove_if(InnerIDs, [&](AnalysisKey *InnerID) {
-          return Inv.invalidate(InnerID, IRUnit, PA); }),
-                       InnerIDs.end());
+        llvm::erase_if(InnerIDs, [&](AnalysisKey *InnerID) {
+          return Inv.invalidate(InnerID, IRUnit, PA);
+        });
         if (InnerIDs.empty())
           DeadKeys.push_back(OuterID);
       }
@@ -1204,9 +1155,7 @@
       // analyses that all trigger invalidation on the same outer analysis,
       // this entire system should be changed to some other deterministic
       // data structure such as a `SetVector` of a pair of pointers.
-      auto InvalidatedIt = std::find(InvalidatedIDList.begin(),
-                                     InvalidatedIDList.end(), InvalidatedID);
-      if (InvalidatedIt == InvalidatedIDList.end())
+      if (!llvm::is_contained(InvalidatedIDList, InvalidatedID))
         InvalidatedIDList.push_back(InvalidatedID);
     }
 
@@ -1218,7 +1167,7 @@
     }
 
   private:
-    const AnalysisManagerT *AM;
+    const AnalysisManagerT *OuterAM;
 
     /// A map from an outer analysis ID to the set of this IR-unit's analyses
     /// which need to be invalidated.
@@ -1226,14 +1175,15 @@
         OuterAnalysisInvalidationMap;
   };
 
-  OuterAnalysisManagerProxy(const AnalysisManagerT &AM) : AM(&AM) {}
+  OuterAnalysisManagerProxy(const AnalysisManagerT &OuterAM)
+      : OuterAM(&OuterAM) {}
 
   /// Run the analysis pass and create our proxy result object.
-  /// Nothing to see here, it just forwards the \c AM reference into the
+  /// Nothing to see here, it just forwards the \c OuterAM reference into the
   /// result.
   Result run(IRUnitT &, AnalysisManager<IRUnitT, ExtraArgTs...> &,
              ExtraArgTs...) {
-    return Result(*AM);
+    return Result(*OuterAM);
   }
 
 private:
@@ -1242,7 +1192,7 @@
 
   static AnalysisKey Key;
 
-  const AnalysisManagerT *AM;
+  const AnalysisManagerT *OuterAM;
 };
 
 template <typename AnalysisManagerT, typename IRUnitT, typename... ExtraArgTs>
@@ -1278,66 +1228,34 @@
 /// Note that although function passes can access module analyses, module
 /// analyses are not invalidated while the function passes are running, so they
 /// may be stale.  Function analyses will not be stale.
-template <typename FunctionPassT>
 class ModuleToFunctionPassAdaptor
-    : public PassInfoMixin<ModuleToFunctionPassAdaptor<FunctionPassT>> {
+    : public PassInfoMixin<ModuleToFunctionPassAdaptor> {
 public:
-  explicit ModuleToFunctionPassAdaptor(FunctionPassT Pass)
+  using PassConceptT = detail::PassConcept<Function, FunctionAnalysisManager>;
+
+  explicit ModuleToFunctionPassAdaptor(std::unique_ptr<PassConceptT> Pass)
       : Pass(std::move(Pass)) {}
 
   /// Runs the function pass across every function in the module.
-  PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM) {
-    FunctionAnalysisManager &FAM =
-        AM.getResult<FunctionAnalysisManagerModuleProxy>(M).getManager();
+  PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
 
-    // Request PassInstrumentation from analysis manager, will use it to run
-    // instrumenting callbacks for the passes later.
-    PassInstrumentation PI = AM.getResult<PassInstrumentationAnalysis>(M);
-
-    PreservedAnalyses PA = PreservedAnalyses::all();
-    for (Function &F : M) {
-      if (F.isDeclaration())
-        continue;
-
-      // Check the PassInstrumentation's BeforePass callbacks before running the
-      // pass, skip its execution completely if asked to (callback returns
-      // false).
-      if (!PI.runBeforePass<Function>(Pass, F))
-        continue;
-      PreservedAnalyses PassPA = Pass.run(F, FAM);
-
-      PI.runAfterPass(Pass, F);
-
-      // We know that the function pass couldn't have invalidated any other
-      // function's analyses (that's the contract of a function pass), so
-      // directly handle the function analysis manager's invalidation here.
-      FAM.invalidate(F, PassPA);
-
-      // Then intersect the preserved set so that invalidation of module
-      // analyses will eventually occur when the module pass completes.
-      PA.intersect(std::move(PassPA));
-    }
-
-    // The FunctionAnalysisManagerModuleProxy is preserved because (we assume)
-    // the function passes we ran didn't add or remove any functions.
-    //
-    // We also preserve all analyses on Functions, because we did all the
-    // invalidation we needed to do above.
-    PA.preserveSet<AllAnalysesOn<Function>>();
-    PA.preserve<FunctionAnalysisManagerModuleProxy>();
-    return PA;
-  }
+  static bool isRequired() { return true; }
 
 private:
-  FunctionPassT Pass;
+  std::unique_ptr<PassConceptT> Pass;
 };
 
 /// A function to deduce a function pass type and wrap it in the
 /// templated adaptor.
 template <typename FunctionPassT>
-ModuleToFunctionPassAdaptor<FunctionPassT>
+ModuleToFunctionPassAdaptor
 createModuleToFunctionPassAdaptor(FunctionPassT Pass) {
-  return ModuleToFunctionPassAdaptor<FunctionPassT>(std::move(Pass));
+  using PassModelT =
+      detail::PassModel<Function, FunctionPassT, PreservedAnalyses,
+                        FunctionAnalysisManager>;
+
+  return ModuleToFunctionPassAdaptor(
+      std::make_unique<PassModelT>(std::move(Pass)));
 }
 
 /// A utility pass template to force an analysis result to be available.
@@ -1368,6 +1286,7 @@
 
     return PreservedAnalyses::all();
   }
+  static bool isRequired() { return true; }
 };
 
 /// A no-op pass template which simply forces a specific analysis result
@@ -1428,8 +1347,9 @@
       // false).
       if (!PI.runBeforePass<IRUnitT>(P, IR))
         continue;
-      PA.intersect(P.run(IR, AM, std::forward<Ts>(Args)...));
-      PI.runAfterPass(P, IR);
+      PreservedAnalyses IterPA = P.run(IR, AM, std::forward<Ts>(Args)...);
+      PA.intersect(IterPA);
+      PI.runAfterPass(P, IR, IterPA);
     }
     return PA;
   }
diff --git a/linux-x64/clang/include/llvm/IR/PassManagerImpl.h b/linux-x64/clang/include/llvm/IR/PassManagerImpl.h
new file mode 100644
index 0000000..71a86d1
--- /dev/null
+++ b/linux-x64/clang/include/llvm/IR/PassManagerImpl.h
@@ -0,0 +1,150 @@
+//===- PassManagerImpl.h - Pass management infrastructure -------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+///
+/// Provides implementations for PassManager and AnalysisManager template
+/// methods. These classes should be explicitly instantiated for any IR unit,
+/// and files doing the explicit instantiation should include this header.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_IR_PASSMANAGERIMPL_H
+#define LLVM_IR_PASSMANAGERIMPL_H
+
+#include "llvm/IR/PassManager.h"
+
+namespace llvm {
+
+template <typename IRUnitT, typename... ExtraArgTs>
+inline AnalysisManager<IRUnitT, ExtraArgTs...>::AnalysisManager(
+    bool DebugLogging)
+    : DebugLogging(DebugLogging) {}
+
+template <typename IRUnitT, typename... ExtraArgTs>
+inline AnalysisManager<IRUnitT, ExtraArgTs...>::AnalysisManager(
+    AnalysisManager &&) = default;
+
+template <typename IRUnitT, typename... ExtraArgTs>
+inline AnalysisManager<IRUnitT, ExtraArgTs...> &
+AnalysisManager<IRUnitT, ExtraArgTs...>::operator=(AnalysisManager &&) =
+    default;
+
+template <typename IRUnitT, typename... ExtraArgTs>
+inline void
+AnalysisManager<IRUnitT, ExtraArgTs...>::clear(IRUnitT &IR,
+                                               llvm::StringRef Name) {
+  if (DebugLogging)
+    dbgs() << "Clearing all analysis results for: " << Name << "\n";
+
+  auto ResultsListI = AnalysisResultLists.find(&IR);
+  if (ResultsListI == AnalysisResultLists.end())
+    return;
+  // Delete the map entries that point into the results list.
+  for (auto &IDAndResult : ResultsListI->second)
+    AnalysisResults.erase({IDAndResult.first, &IR});
+
+  // And actually destroy and erase the results associated with this IR.
+  AnalysisResultLists.erase(ResultsListI);
+}
+
+template <typename IRUnitT, typename... ExtraArgTs>
+inline typename AnalysisManager<IRUnitT, ExtraArgTs...>::ResultConceptT &
+AnalysisManager<IRUnitT, ExtraArgTs...>::getResultImpl(
+    AnalysisKey *ID, IRUnitT &IR, ExtraArgTs... ExtraArgs) {
+  typename AnalysisResultMapT::iterator RI;
+  bool Inserted;
+  std::tie(RI, Inserted) = AnalysisResults.insert(std::make_pair(
+      std::make_pair(ID, &IR), typename AnalysisResultListT::iterator()));
+
+  // If we don't have a cached result for this function, look up the pass and
+  // run it to produce a result, which we then add to the cache.
+  if (Inserted) {
+    auto &P = this->lookUpPass(ID);
+
+    PassInstrumentation PI;
+    if (ID != PassInstrumentationAnalysis::ID()) {
+      PI = getResult<PassInstrumentationAnalysis>(IR, ExtraArgs...);
+      PI.runBeforeAnalysis(P, IR);
+    }
+
+    AnalysisResultListT &ResultList = AnalysisResultLists[&IR];
+    ResultList.emplace_back(ID, P.run(IR, *this, ExtraArgs...));
+
+    PI.runAfterAnalysis(P, IR);
+
+    // P.run may have inserted elements into AnalysisResults and invalidated
+    // RI.
+    RI = AnalysisResults.find({ID, &IR});
+    assert(RI != AnalysisResults.end() && "we just inserted it!");
+
+    RI->second = std::prev(ResultList.end());
+  }
+
+  return *RI->second->second;
+}
+
+template <typename IRUnitT, typename... ExtraArgTs>
+inline void AnalysisManager<IRUnitT, ExtraArgTs...>::invalidate(
+    IRUnitT &IR, const PreservedAnalyses &PA) {
+  // We're done if all analyses on this IR unit are preserved.
+  if (PA.allAnalysesInSetPreserved<AllAnalysesOn<IRUnitT>>())
+    return;
+
+  // Track whether each analysis's result is invalidated in
+  // IsResultInvalidated.
+  SmallDenseMap<AnalysisKey *, bool, 8> IsResultInvalidated;
+  Invalidator Inv(IsResultInvalidated, AnalysisResults);
+  AnalysisResultListT &ResultsList = AnalysisResultLists[&IR];
+  for (auto &AnalysisResultPair : ResultsList) {
+    // This is basically the same thing as Invalidator::invalidate, but we
+    // can't call it here because we're operating on the type-erased result.
+    // Moreover if we instead called invalidate() directly, it would do an
+    // unnecessary look up in ResultsList.
+    AnalysisKey *ID = AnalysisResultPair.first;
+    auto &Result = *AnalysisResultPair.second;
+
+    auto IMapI = IsResultInvalidated.find(ID);
+    if (IMapI != IsResultInvalidated.end())
+      // This result was already handled via the Invalidator.
+      continue;
+
+    // Try to invalidate the result, giving it the Invalidator so it can
+    // recursively query for any dependencies it has and record the result.
+    // Note that we cannot reuse 'IMapI' here or pre-insert the ID, as
+    // Result.invalidate may insert things into the map, invalidating our
+    // iterator.
+    bool Inserted =
+        IsResultInvalidated.insert({ID, Result.invalidate(IR, PA, Inv)}).second;
+    (void)Inserted;
+    assert(Inserted && "Should never have already inserted this ID, likely "
+                       "indicates a cycle!");
+  }
+
+  // Now erase the results that were marked above as invalidated.
+  if (!IsResultInvalidated.empty()) {
+    for (auto I = ResultsList.begin(), E = ResultsList.end(); I != E;) {
+      AnalysisKey *ID = I->first;
+      if (!IsResultInvalidated.lookup(ID)) {
+        ++I;
+        continue;
+      }
+
+      if (DebugLogging)
+        dbgs() << "Invalidating analysis: " << this->lookUpPass(ID).name()
+               << " on " << IR.getName() << "\n";
+
+      I = ResultsList.erase(I);
+      AnalysisResults.erase({ID, &IR});
+    }
+  }
+
+  if (ResultsList.empty())
+    AnalysisResultLists.erase(&IR);
+}
+} // end namespace llvm
+
+#endif // LLVM_IR_PASSMANAGERIMPL_H
diff --git a/linux-x64/clang/include/llvm/IR/PassManagerInternal.h b/linux-x64/clang/include/llvm/IR/PassManagerInternal.h
index 58198bf..986ed0b 100644
--- a/linux-x64/clang/include/llvm/IR/PassManagerInternal.h
+++ b/linux-x64/clang/include/llvm/IR/PassManagerInternal.h
@@ -48,6 +48,12 @@
 
   /// Polymorphic method to access the name of a pass.
   virtual StringRef name() const = 0;
+
+  /// Polymorphic method to to let a pass optionally exempted from skipping by
+  /// PassInstrumentation.
+  /// To opt-in, pass should implement `static bool isRequired()`. It's no-op
+  /// to have `isRequired` always return false since that is the default.
+  virtual bool isRequired() const = 0;
 };
 
 /// A template wrapper used to implement the polymorphic API.
@@ -81,6 +87,22 @@
 
   StringRef name() const override { return PassT::name(); }
 
+  template <typename T>
+  using has_required_t = decltype(std::declval<T &>().isRequired());
+
+  template <typename T>
+  static std::enable_if_t<is_detected<has_required_t, T>::value, bool>
+  passIsRequiredImpl() {
+    return T::isRequired();
+  }
+  template <typename T>
+  static std::enable_if_t<!is_detected<has_required_t, T>::value, bool>
+  passIsRequiredImpl() {
+    return false;
+  }
+
+  bool isRequired() const override { return passIsRequiredImpl<PassT>(); }
+
   PassT Pass;
 };
 
@@ -289,7 +311,7 @@
       AnalysisResultConcept<IRUnitT, PreservedAnalysesT, InvalidatorT>>
   run(IRUnitT &IR, AnalysisManager<IRUnitT, ExtraArgTs...> &AM,
       ExtraArgTs... ExtraArgs) override {
-    return llvm::make_unique<ResultModelT>(
+    return std::make_unique<ResultModelT>(
         Pass.run(IR, AM, std::forward<ExtraArgTs>(ExtraArgs)...));
   }
 
diff --git a/linux-x64/clang/include/llvm/IR/PassTimingInfo.h b/linux-x64/clang/include/llvm/IR/PassTimingInfo.h
index b8d8f11..e44321b 100644
--- a/linux-x64/clang/include/llvm/IR/PassTimingInfo.h
+++ b/linux-x64/clang/include/llvm/IR/PassTimingInfo.h
@@ -17,11 +17,13 @@
 
 #include "llvm/ADT/Any.h"
 #include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Timer.h"
-#include "llvm/Support/TypeName.h"
 #include <memory>
+#include <utility>
+
 namespace llvm {
 
 class Pass;
@@ -36,11 +38,6 @@
 /// Request the timer for this legacy-pass-manager's pass instance.
 Timer *getPassTimer(Pass *);
 
-/// If the user specifies the -time-passes argument on an LLVM tool command line
-/// then the value of this boolean will be true, otherwise false.
-/// This is the storage for the -time-passes option.
-extern bool TimePassesIsEnabled;
-
 /// This class implements -time-passes functionality for new pass manager.
 /// It provides the pass-instrumentation callbacks that measure the pass
 /// execution time. They collect timing info into individual timers as
@@ -55,11 +52,9 @@
   /// A group of all pass-timing timers.
   TimerGroup TG;
 
+  using TimerVector = llvm::SmallVector<std::unique_ptr<Timer>, 4>;
   /// Map of timers for pass invocations
-  DenseMap<PassInvocationID, std::unique_ptr<Timer>> TimingData;
-
-  /// Map that counts invocations of passes, for use in UniqPassID construction.
-  StringMap<unsigned> PassIDCountMap;
+  StringMap<TimerVector> TimingData;
 
   /// Stack of currently active timers.
   SmallVector<Timer *, 8> TimerStack;
@@ -70,9 +65,11 @@
   raw_ostream *OutStream = nullptr;
 
   bool Enabled;
+  bool PerRun;
 
 public:
-  TimePassesHandler(bool Enabled = TimePassesIsEnabled);
+  TimePassesHandler();
+  TimePassesHandler(bool Enabled, bool PerRun = false);
 
   /// Destructor handles the print action if it has not been handled before.
   ~TimePassesHandler() { print(); }
@@ -96,14 +93,11 @@
   /// Returns the new timer for each new run of the pass.
   Timer &getPassTimer(StringRef PassID);
 
-  /// Returns the incremented counter for the next invocation of \p PassID.
-  unsigned nextPassID(StringRef PassID) { return ++PassIDCountMap[PassID]; }
-
   void startTimer(StringRef PassID);
   void stopTimer(StringRef PassID);
 
   // Implementation of pass instrumentation callbacks.
-  bool runBeforePass(StringRef PassID);
+  void runBeforePass(StringRef PassID);
   void runAfterPass(StringRef PassID);
 };
 
diff --git a/linux-x64/clang/include/llvm/IR/PatternMatch.h b/linux-x64/clang/include/llvm/IR/PatternMatch.h
index 1a11af2..166ad23 100644
--- a/linux-x64/clang/include/llvm/IR/PatternMatch.h
+++ b/linux-x64/clang/include/llvm/IR/PatternMatch.h
@@ -32,9 +32,11 @@
 #include "llvm/ADT/APInt.h"
 #include "llvm/IR/Constant.h"
 #include "llvm/IR/Constants.h"
+#include "llvm/IR/DataLayout.h"
 #include "llvm/IR/InstrTypes.h"
 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/Instructions.h"
+#include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/Operator.h"
 #include "llvm/IR/Value.h"
@@ -48,6 +50,10 @@
   return const_cast<Pattern &>(P).match(V);
 }
 
+template <typename Pattern> bool match(ArrayRef<int> Mask, const Pattern &P) {
+  return const_cast<Pattern &>(P).match(Mask);
+}
+
 template <typename SubPattern_t> struct OneUse_match {
   SubPattern_t SubPattern;
 
@@ -69,6 +75,11 @@
 /// Match an arbitrary value and ignore it.
 inline class_match<Value> m_Value() { return class_match<Value>(); }
 
+/// Match an arbitrary unary operation and ignore it.
+inline class_match<UnaryOperator> m_UnOp() {
+  return class_match<UnaryOperator>();
+}
+
 /// Match an arbitrary binary operation and ignore it.
 inline class_match<BinaryOperator> m_BinOp() {
   return class_match<BinaryOperator>();
@@ -77,16 +88,48 @@
 /// Matches any compare instruction and ignore it.
 inline class_match<CmpInst> m_Cmp() { return class_match<CmpInst>(); }
 
+/// Match an arbitrary undef constant.
+inline class_match<UndefValue> m_Undef() { return class_match<UndefValue>(); }
+
+/// Match an arbitrary poison constant.
+inline class_match<PoisonValue> m_Poison() { return class_match<PoisonValue>(); }
+
+/// Match an arbitrary Constant and ignore it.
+inline class_match<Constant> m_Constant() { return class_match<Constant>(); }
+
 /// Match an arbitrary ConstantInt and ignore it.
 inline class_match<ConstantInt> m_ConstantInt() {
   return class_match<ConstantInt>();
 }
 
-/// Match an arbitrary undef constant.
-inline class_match<UndefValue> m_Undef() { return class_match<UndefValue>(); }
+/// Match an arbitrary ConstantFP and ignore it.
+inline class_match<ConstantFP> m_ConstantFP() {
+  return class_match<ConstantFP>();
+}
 
-/// Match an arbitrary Constant and ignore it.
-inline class_match<Constant> m_Constant() { return class_match<Constant>(); }
+/// Match an arbitrary ConstantExpr and ignore it.
+inline class_match<ConstantExpr> m_ConstantExpr() {
+  return class_match<ConstantExpr>();
+}
+
+/// Match an arbitrary basic block value and ignore it.
+inline class_match<BasicBlock> m_BasicBlock() {
+  return class_match<BasicBlock>();
+}
+
+/// Inverting matcher
+template <typename Ty> struct match_unless {
+  Ty M;
+
+  match_unless(const Ty &Matcher) : M(Matcher) {}
+
+  template <typename ITy> bool match(ITy *V) { return !M.match(V); }
+};
+
+/// Match if the inner matcher does *NOT* match.
+template <typename Ty> inline match_unless<Ty> m_Unless(const Ty &M) {
+  return match_unless<Ty>(M);
+}
 
 /// Matching combinators
 template <typename LTy, typename RTy> struct match_combine_or {
@@ -132,8 +175,10 @@
 
 struct apint_match {
   const APInt *&Res;
+  bool AllowUndef;
 
-  apint_match(const APInt *&R) : Res(R) {}
+  apint_match(const APInt *&Res, bool AllowUndef)
+    : Res(Res), AllowUndef(AllowUndef) {}
 
   template <typename ITy> bool match(ITy *V) {
     if (auto *CI = dyn_cast<ConstantInt>(V)) {
@@ -142,7 +187,8 @@
     }
     if (V->getType()->isVectorTy())
       if (const auto *C = dyn_cast<Constant>(V))
-        if (auto *CI = dyn_cast_or_null<ConstantInt>(C->getSplatValue())) {
+        if (auto *CI = dyn_cast_or_null<ConstantInt>(
+                C->getSplatValue(AllowUndef))) {
           Res = &CI->getValue();
           return true;
         }
@@ -154,7 +200,11 @@
 // function for both apint/apfloat.
 struct apfloat_match {
   const APFloat *&Res;
-  apfloat_match(const APFloat *&R) : Res(R) {}
+  bool AllowUndef;
+
+  apfloat_match(const APFloat *&Res, bool AllowUndef)
+      : Res(Res), AllowUndef(AllowUndef) {}
+
   template <typename ITy> bool match(ITy *V) {
     if (auto *CI = dyn_cast<ConstantFP>(V)) {
       Res = &CI->getValueAPF();
@@ -162,7 +212,8 @@
     }
     if (V->getType()->isVectorTy())
       if (const auto *C = dyn_cast<Constant>(V))
-        if (auto *CI = dyn_cast_or_null<ConstantFP>(C->getSplatValue())) {
+        if (auto *CI = dyn_cast_or_null<ConstantFP>(
+                C->getSplatValue(AllowUndef))) {
           Res = &CI->getValueAPF();
           return true;
         }
@@ -172,11 +223,37 @@
 
 /// Match a ConstantInt or splatted ConstantVector, binding the
 /// specified pointer to the contained APInt.
-inline apint_match m_APInt(const APInt *&Res) { return Res; }
+inline apint_match m_APInt(const APInt *&Res) {
+  // Forbid undefs by default to maintain previous behavior.
+  return apint_match(Res, /* AllowUndef */ false);
+}
+
+/// Match APInt while allowing undefs in splat vector constants.
+inline apint_match m_APIntAllowUndef(const APInt *&Res) {
+  return apint_match(Res, /* AllowUndef */ true);
+}
+
+/// Match APInt while forbidding undefs in splat vector constants.
+inline apint_match m_APIntForbidUndef(const APInt *&Res) {
+  return apint_match(Res, /* AllowUndef */ false);
+}
 
 /// Match a ConstantFP or splatted ConstantVector, binding the
 /// specified pointer to the contained APFloat.
-inline apfloat_match m_APFloat(const APFloat *&Res) { return Res; }
+inline apfloat_match m_APFloat(const APFloat *&Res) {
+  // Forbid undefs by default to maintain previous behavior.
+  return apfloat_match(Res, /* AllowUndef */ false);
+}
+
+/// Match APFloat while allowing undefs in splat vector constants.
+inline apfloat_match m_APFloatAllowUndef(const APFloat *&Res) {
+  return apfloat_match(Res, /* AllowUndef */ true);
+}
+
+/// Match APFloat while forbidding undefs in splat vector constants.
+inline apfloat_match m_APFloatForbidUndef(const APFloat *&Res) {
+  return apfloat_match(Res, /* AllowUndef */ false);
+}
 
 template <int64_t Val> struct constantint_match {
   template <typename ITy> bool match(ITy *V) {
@@ -198,20 +275,26 @@
   return constantint_match<Val>();
 }
 
-/// This helper class is used to match scalar and vector integer constants that
-/// satisfy a specified predicate.
-/// For vector constants, undefined elements are ignored.
-template <typename Predicate> struct cst_pred_ty : public Predicate {
+/// This helper class is used to match constant scalars, vector splats,
+/// and fixed width vectors that satisfy a specified predicate.
+/// For fixed width vector constants, undefined elements are ignored.
+template <typename Predicate, typename ConstantVal>
+struct cstval_pred_ty : public Predicate {
   template <typename ITy> bool match(ITy *V) {
-    if (const auto *CI = dyn_cast<ConstantInt>(V))
-      return this->isValue(CI->getValue());
-    if (V->getType()->isVectorTy()) {
+    if (const auto *CV = dyn_cast<ConstantVal>(V))
+      return this->isValue(CV->getValue());
+    if (const auto *VTy = dyn_cast<VectorType>(V->getType())) {
       if (const auto *C = dyn_cast<Constant>(V)) {
-        if (const auto *CI = dyn_cast_or_null<ConstantInt>(C->getSplatValue()))
-          return this->isValue(CI->getValue());
+        if (const auto *CV = dyn_cast_or_null<ConstantVal>(C->getSplatValue()))
+          return this->isValue(CV->getValue());
+
+        // Number of elements of a scalable vector unknown at compile time
+        auto *FVTy = dyn_cast<FixedVectorType>(VTy);
+        if (!FVTy)
+          return false;
 
         // Non-splat vector constant: check each element for a match.
-        unsigned NumElts = V->getType()->getVectorNumElements();
+        unsigned NumElts = FVTy->getNumElements();
         assert(NumElts != 0 && "Constant vector with no elements?");
         bool HasNonUndefElements = false;
         for (unsigned i = 0; i != NumElts; ++i) {
@@ -220,8 +303,8 @@
             return false;
           if (isa<UndefValue>(Elt))
             continue;
-          auto *CI = dyn_cast<ConstantInt>(Elt);
-          if (!CI || !this->isValue(CI->getValue()))
+          auto *CV = dyn_cast<ConstantVal>(Elt);
+          if (!CV || !this->isValue(CV->getValue()))
             return false;
           HasNonUndefElements = true;
         }
@@ -232,6 +315,14 @@
   }
 };
 
+/// specialization of cstval_pred_ty for ConstantInt
+template <typename Predicate>
+using cst_pred_ty = cstval_pred_ty<Predicate, ConstantInt>;
+
+/// specialization of cstval_pred_ty for ConstantFP
+template <typename Predicate>
+using cstfp_pred_ty = cstval_pred_ty<Predicate, ConstantFP>;
+
 /// This helper class is used to match scalar and vector constants that
 /// satisfy a specified predicate, and bind them to an APInt.
 template <typename Predicate> struct api_pred_ty : public Predicate {
@@ -257,36 +348,29 @@
   }
 };
 
-/// This helper class is used to match scalar and vector floating-point
-/// constants that satisfy a specified predicate.
-/// For vector constants, undefined elements are ignored.
-template <typename Predicate> struct cstfp_pred_ty : public Predicate {
-  template <typename ITy> bool match(ITy *V) {
-    if (const auto *CF = dyn_cast<ConstantFP>(V))
-      return this->isValue(CF->getValueAPF());
-    if (V->getType()->isVectorTy()) {
-      if (const auto *C = dyn_cast<Constant>(V)) {
-        if (const auto *CF = dyn_cast_or_null<ConstantFP>(C->getSplatValue()))
-          return this->isValue(CF->getValueAPF());
+/// This helper class is used to match scalar and vector constants that
+/// satisfy a specified predicate, and bind them to an APFloat.
+/// Undefs are allowed in splat vector constants.
+template <typename Predicate> struct apf_pred_ty : public Predicate {
+  const APFloat *&Res;
 
-        // Non-splat vector constant: check each element for a match.
-        unsigned NumElts = V->getType()->getVectorNumElements();
-        assert(NumElts != 0 && "Constant vector with no elements?");
-        bool HasNonUndefElements = false;
-        for (unsigned i = 0; i != NumElts; ++i) {
-          Constant *Elt = C->getAggregateElement(i);
-          if (!Elt)
-            return false;
-          if (isa<UndefValue>(Elt))
-            continue;
-          auto *CF = dyn_cast<ConstantFP>(Elt);
-          if (!CF || !this->isValue(CF->getValueAPF()))
-            return false;
-          HasNonUndefElements = true;
-        }
-        return HasNonUndefElements;
+  apf_pred_ty(const APFloat *&R) : Res(R) {}
+
+  template <typename ITy> bool match(ITy *V) {
+    if (const auto *CI = dyn_cast<ConstantFP>(V))
+      if (this->isValue(CI->getValue())) {
+        Res = &CI->getValue();
+        return true;
       }
-    }
+    if (V->getType()->isVectorTy())
+      if (const auto *C = dyn_cast<Constant>(V))
+        if (auto *CI = dyn_cast_or_null<ConstantFP>(
+                C->getSplatValue(/* AllowUndef */ true)))
+          if (this->isValue(CI->getValue())) {
+            Res = &CI->getValue();
+            return true;
+          }
+
     return false;
   }
 };
@@ -300,6 +384,15 @@
 //
 ///////////////////////////////////////////////////////////////////////////////
 
+struct is_any_apint {
+  bool isValue(const APInt &C) { return true; }
+};
+/// Match an integer or vector with any integral constant.
+/// For vectors, this includes constants with undefined elements.
+inline cst_pred_ty<is_any_apint> m_AnyIntegralConstant() {
+  return cst_pred_ty<is_any_apint>();
+}
+
 struct is_all_ones {
   bool isValue(const APInt &C) { return C.isAllOnesValue(); }
 };
@@ -337,7 +430,7 @@
 struct is_nonnegative {
   bool isValue(const APInt &C) { return C.isNonNegative(); }
 };
-/// Match an integer or vector of nonnegative values.
+/// Match an integer or vector of non-negative values.
 /// For vectors, this includes constants with undefined elements.
 inline cst_pred_ty<is_nonnegative> m_NonNegative() {
   return cst_pred_ty<is_nonnegative>();
@@ -346,6 +439,28 @@
   return V;
 }
 
+struct is_strictlypositive {
+  bool isValue(const APInt &C) { return C.isStrictlyPositive(); }
+};
+/// Match an integer or vector of strictly positive values.
+/// For vectors, this includes constants with undefined elements.
+inline cst_pred_ty<is_strictlypositive> m_StrictlyPositive() {
+  return cst_pred_ty<is_strictlypositive>();
+}
+inline api_pred_ty<is_strictlypositive> m_StrictlyPositive(const APInt *&V) {
+  return V;
+}
+
+struct is_nonpositive {
+  bool isValue(const APInt &C) { return C.isNonPositive(); }
+};
+/// Match an integer or vector of non-positive values.
+/// For vectors, this includes constants with undefined elements.
+inline cst_pred_ty<is_nonpositive> m_NonPositive() {
+  return cst_pred_ty<is_nonpositive>();
+}
+inline api_pred_ty<is_nonpositive> m_NonPositive(const APInt *&V) { return V; }
+
 struct is_one {
   bool isValue(const APInt &C) { return C.isOneValue(); }
 };
@@ -367,6 +482,7 @@
 struct is_zero {
   template <typename ITy> bool match(ITy *V) {
     auto *C = dyn_cast<Constant>(V);
+    // FIXME: this should be able to do something for scalable vectors
     return C && (C->isNullValue() || cst_pred_ty<is_zero_int>().match(C));
   }
 };
@@ -388,6 +504,18 @@
   return V;
 }
 
+struct is_negated_power2 {
+  bool isValue(const APInt &C) { return (-C).isPowerOf2(); }
+};
+/// Match a integer or vector negated power-of-2.
+/// For vectors, this includes constants with undefined elements.
+inline cst_pred_ty<is_negated_power2> m_NegatedPower2() {
+  return cst_pred_ty<is_negated_power2>();
+}
+inline api_pred_ty<is_negated_power2> m_NegatedPower2(const APInt *&V) {
+  return V;
+}
+
 struct is_power2_or_zero {
   bool isValue(const APInt &C) { return !C || C.isPowerOf2(); }
 };
@@ -418,16 +546,42 @@
   return cst_pred_ty<is_lowbit_mask>();
 }
 
-struct is_unsigned_less_than {
+struct icmp_pred_with_threshold {
+  ICmpInst::Predicate Pred;
   const APInt *Thr;
-  bool isValue(const APInt &C) { return C.ult(*Thr); }
+  bool isValue(const APInt &C) {
+    switch (Pred) {
+    case ICmpInst::Predicate::ICMP_EQ:
+      return C.eq(*Thr);
+    case ICmpInst::Predicate::ICMP_NE:
+      return C.ne(*Thr);
+    case ICmpInst::Predicate::ICMP_UGT:
+      return C.ugt(*Thr);
+    case ICmpInst::Predicate::ICMP_UGE:
+      return C.uge(*Thr);
+    case ICmpInst::Predicate::ICMP_ULT:
+      return C.ult(*Thr);
+    case ICmpInst::Predicate::ICMP_ULE:
+      return C.ule(*Thr);
+    case ICmpInst::Predicate::ICMP_SGT:
+      return C.sgt(*Thr);
+    case ICmpInst::Predicate::ICMP_SGE:
+      return C.sge(*Thr);
+    case ICmpInst::Predicate::ICMP_SLT:
+      return C.slt(*Thr);
+    case ICmpInst::Predicate::ICMP_SLE:
+      return C.sle(*Thr);
+    default:
+      llvm_unreachable("Unhandled ICmp predicate");
+    }
+  }
 };
-/// Match an integer or vector with every element unsigned less than the
-/// Threshold. For vectors, this includes constants with undefined elements.
-/// FIXME: is it worth generalizing this to simply take ICmpInst::Predicate?
-inline cst_pred_ty<is_unsigned_less_than>
-m_SpecificInt_ULT(const APInt &Threshold) {
-  cst_pred_ty<is_unsigned_less_than> P;
+/// Match an integer or vector with every element comparing 'pred' (eg/ne/...)
+/// to Threshold. For vectors, this includes constants with undefined elements.
+inline cst_pred_ty<icmp_pred_with_threshold>
+m_SpecificInt_ICMP(ICmpInst::Predicate Predicate, const APInt &Threshold) {
+  cst_pred_ty<icmp_pred_with_threshold> P;
+  P.Pred = Predicate;
   P.Thr = &Threshold;
   return P;
 }
@@ -441,6 +595,55 @@
   return cstfp_pred_ty<is_nan>();
 }
 
+struct is_nonnan {
+  bool isValue(const APFloat &C) { return !C.isNaN(); }
+};
+/// Match a non-NaN FP constant.
+/// For vectors, this includes constants with undefined elements.
+inline cstfp_pred_ty<is_nonnan> m_NonNaN() {
+  return cstfp_pred_ty<is_nonnan>();
+}
+
+struct is_inf {
+  bool isValue(const APFloat &C) { return C.isInfinity(); }
+};
+/// Match a positive or negative infinity FP constant.
+/// For vectors, this includes constants with undefined elements.
+inline cstfp_pred_ty<is_inf> m_Inf() {
+  return cstfp_pred_ty<is_inf>();
+}
+
+struct is_noninf {
+  bool isValue(const APFloat &C) { return !C.isInfinity(); }
+};
+/// Match a non-infinity FP constant, i.e. finite or NaN.
+/// For vectors, this includes constants with undefined elements.
+inline cstfp_pred_ty<is_noninf> m_NonInf() {
+  return cstfp_pred_ty<is_noninf>();
+}
+
+struct is_finite {
+  bool isValue(const APFloat &C) { return C.isFinite(); }
+};
+/// Match a finite FP constant, i.e. not infinity or NaN.
+/// For vectors, this includes constants with undefined elements.
+inline cstfp_pred_ty<is_finite> m_Finite() {
+  return cstfp_pred_ty<is_finite>();
+}
+inline apf_pred_ty<is_finite> m_Finite(const APFloat *&V) { return V; }
+
+struct is_finitenonzero {
+  bool isValue(const APFloat &C) { return C.isFiniteNonZero(); }
+};
+/// Match a finite non-zero FP constant.
+/// For vectors, this includes constants with undefined elements.
+inline cstfp_pred_ty<is_finitenonzero> m_FiniteNonZero() {
+  return cstfp_pred_ty<is_finitenonzero>();
+}
+inline apf_pred_ty<is_finitenonzero> m_FiniteNonZero(const APFloat *&V) {
+  return V;
+}
+
 struct is_any_zero_fp {
   bool isValue(const APFloat &C) { return C.isZero(); }
 };
@@ -468,6 +671,15 @@
   return cstfp_pred_ty<is_neg_zero_fp>();
 }
 
+struct is_non_zero_fp {
+  bool isValue(const APFloat &C) { return C.isNonZero(); }
+};
+/// Match a floating-point non-zero.
+/// For vectors, this includes constants with undefined elements.
+inline cstfp_pred_ty<is_non_zero_fp> m_NonZeroFP() {
+  return cstfp_pred_ty<is_non_zero_fp>();
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 
 template <typename Class> struct bind_ty {
@@ -490,18 +702,45 @@
 
 /// Match an instruction, capturing it if we match.
 inline bind_ty<Instruction> m_Instruction(Instruction *&I) { return I; }
+/// Match a unary operator, capturing it if we match.
+inline bind_ty<UnaryOperator> m_UnOp(UnaryOperator *&I) { return I; }
 /// Match a binary operator, capturing it if we match.
 inline bind_ty<BinaryOperator> m_BinOp(BinaryOperator *&I) { return I; }
-
-/// Match a ConstantInt, capturing the value if we match.
-inline bind_ty<ConstantInt> m_ConstantInt(ConstantInt *&CI) { return CI; }
+/// Match a with overflow intrinsic, capturing it if we match.
+inline bind_ty<WithOverflowInst> m_WithOverflowInst(WithOverflowInst *&I) { return I; }
 
 /// Match a Constant, capturing the value if we match.
 inline bind_ty<Constant> m_Constant(Constant *&C) { return C; }
 
+/// Match a ConstantInt, capturing the value if we match.
+inline bind_ty<ConstantInt> m_ConstantInt(ConstantInt *&CI) { return CI; }
+
 /// Match a ConstantFP, capturing the value if we match.
 inline bind_ty<ConstantFP> m_ConstantFP(ConstantFP *&C) { return C; }
 
+/// Match a ConstantExpr, capturing the value if we match.
+inline bind_ty<ConstantExpr> m_ConstantExpr(ConstantExpr *&C) { return C; }
+
+/// Match a basic block value, capturing it if we match.
+inline bind_ty<BasicBlock> m_BasicBlock(BasicBlock *&V) { return V; }
+inline bind_ty<const BasicBlock> m_BasicBlock(const BasicBlock *&V) {
+  return V;
+}
+
+/// Match an arbitrary immediate Constant and ignore it.
+inline match_combine_and<class_match<Constant>,
+                         match_unless<class_match<ConstantExpr>>>
+m_ImmConstant() {
+  return m_CombineAnd(m_Constant(), m_Unless(m_ConstantExpr()));
+}
+
+/// Match an immediate Constant, capturing the value if we match.
+inline match_combine_and<bind_ty<Constant>,
+                         match_unless<class_match<ConstantExpr>>>
+m_ImmConstant(Constant *&C) {
+  return m_CombineAnd(m_Constant(C), m_Unless(m_ConstantExpr()));
+}
+
 /// Match a specified Value*.
 struct specificval_ty {
   const Value *Val;
@@ -571,30 +810,71 @@
 };
 
 /// Match a specified integer value or vector of all elements of that
-// value.
+/// value.
+template <bool AllowUndefs>
 struct specific_intval {
-  uint64_t Val;
+  APInt Val;
 
-  specific_intval(uint64_t V) : Val(V) {}
+  specific_intval(APInt V) : Val(std::move(V)) {}
 
   template <typename ITy> bool match(ITy *V) {
     const auto *CI = dyn_cast<ConstantInt>(V);
     if (!CI && V->getType()->isVectorTy())
       if (const auto *C = dyn_cast<Constant>(V))
-        CI = dyn_cast_or_null<ConstantInt>(C->getSplatValue());
+        CI = dyn_cast_or_null<ConstantInt>(C->getSplatValue(AllowUndefs));
 
-    return CI && CI->getValue() == Val;
+    return CI && APInt::isSameValue(CI->getValue(), Val);
   }
 };
 
 /// Match a specific integer value or vector with all elements equal to
 /// the value.
-inline specific_intval m_SpecificInt(uint64_t V) { return specific_intval(V); }
+inline specific_intval<false> m_SpecificInt(APInt V) {
+  return specific_intval<false>(std::move(V));
+}
+
+inline specific_intval<false> m_SpecificInt(uint64_t V) {
+  return m_SpecificInt(APInt(64, V));
+}
+
+inline specific_intval<true> m_SpecificIntAllowUndef(APInt V) {
+  return specific_intval<true>(std::move(V));
+}
+
+inline specific_intval<true> m_SpecificIntAllowUndef(uint64_t V) {
+  return m_SpecificIntAllowUndef(APInt(64, V));
+}
 
 /// Match a ConstantInt and bind to its value.  This does not match
 /// ConstantInts wider than 64-bits.
 inline bind_const_intval_ty m_ConstantInt(uint64_t &V) { return V; }
 
+/// Match a specified basic block value.
+struct specific_bbval {
+  BasicBlock *Val;
+
+  specific_bbval(BasicBlock *Val) : Val(Val) {}
+
+  template <typename ITy> bool match(ITy *V) {
+    const auto *BB = dyn_cast<BasicBlock>(V);
+    return BB && BB == Val;
+  }
+};
+
+/// Match a specific basic block value.
+inline specific_bbval m_SpecificBB(BasicBlock *BB) {
+  return specific_bbval(BB);
+}
+
+/// A commutative-friendly version of m_Specific().
+inline deferredval_ty<BasicBlock> m_Deferred(BasicBlock *const &BB) {
+  return BB;
+}
+inline deferredval_ty<const BasicBlock>
+m_Deferred(const BasicBlock *const &BB) {
+  return BB;
+}
+
 //===----------------------------------------------------------------------===//
 // Matcher for any binary operator.
 //
@@ -622,6 +902,26 @@
 }
 
 //===----------------------------------------------------------------------===//
+// Matcher for any unary operator.
+// TODO fuse unary, binary matcher into n-ary matcher
+//
+template <typename OP_t> struct AnyUnaryOp_match {
+  OP_t X;
+
+  AnyUnaryOp_match(const OP_t &X) : X(X) {}
+
+  template <typename OpTy> bool match(OpTy *V) {
+    if (auto *I = dyn_cast<UnaryOperator>(V))
+      return X.match(I->getOperand(0));
+    return false;
+  }
+};
+
+template <typename OP_t> inline AnyUnaryOp_match<OP_t> m_UnOp(const OP_t &X) {
+  return AnyUnaryOp_match<OP_t>(X);
+}
+
+//===----------------------------------------------------------------------===//
 // Matchers for specific binary operators.
 //
 
@@ -942,6 +1242,12 @@
   }
 };
 
+struct is_irem_op {
+  bool isOpType(unsigned Opcode) {
+    return Opcode == Instruction::SRem || Opcode == Instruction::URem;
+  }
+};
+
 /// Matches shift operations.
 template <typename LHS, typename RHS>
 inline BinOpPred_match<LHS, RHS, is_shift_op> m_Shift(const LHS &L,
@@ -977,6 +1283,13 @@
   return BinOpPred_match<LHS, RHS, is_idiv_op>(L, R);
 }
 
+/// Matches integer remainder operations.
+template <typename LHS, typename RHS>
+inline BinOpPred_match<LHS, RHS, is_irem_op> m_IRem(const LHS &L,
+                                                    const RHS &R) {
+  return BinOpPred_match<LHS, RHS, is_irem_op>(L, R);
+}
+
 //===----------------------------------------------------------------------===//
 // Class that matches exact binary ops.
 //
@@ -1013,13 +1326,16 @@
       : Predicate(Pred), L(LHS), R(RHS) {}
 
   template <typename OpTy> bool match(OpTy *V) {
-    if (auto *I = dyn_cast<Class>(V))
-      if ((L.match(I->getOperand(0)) && R.match(I->getOperand(1))) ||
-          (Commutable && L.match(I->getOperand(1)) &&
-           R.match(I->getOperand(0)))) {
+    if (auto *I = dyn_cast<Class>(V)) {
+      if (L.match(I->getOperand(0)) && R.match(I->getOperand(1))) {
         Predicate = I->getPredicate();
         return true;
+      } else if (Commutable && L.match(I->getOperand(1)) &&
+           R.match(I->getOperand(0))) {
+        Predicate = I->getSwappedPredicate();
+        return true;
       }
+    }
     return false;
   }
 };
@@ -1113,10 +1429,16 @@
   return m_Select(C, m_ConstantInt<L>(), m_ConstantInt<R>());
 }
 
+/// Matches FreezeInst.
+template <typename OpTy>
+inline OneOps_match<OpTy, Instruction::Freeze> m_Freeze(const OpTy &Op) {
+  return OneOps_match<OpTy, Instruction::Freeze>(Op);
+}
+
 /// Matches InsertElementInst.
 template <typename Val_t, typename Elt_t, typename Idx_t>
 inline ThreeOps_match<Val_t, Elt_t, Idx_t, Instruction::InsertElement>
-m_InsertElement(const Val_t &Val, const Elt_t &Elt, const Idx_t &Idx) {
+m_InsertElt(const Val_t &Val, const Elt_t &Elt, const Idx_t &Idx) {
   return ThreeOps_match<Val_t, Elt_t, Idx_t, Instruction::InsertElement>(
       Val, Elt, Idx);
 }
@@ -1124,16 +1446,73 @@
 /// Matches ExtractElementInst.
 template <typename Val_t, typename Idx_t>
 inline TwoOps_match<Val_t, Idx_t, Instruction::ExtractElement>
-m_ExtractElement(const Val_t &Val, const Idx_t &Idx) {
+m_ExtractElt(const Val_t &Val, const Idx_t &Idx) {
   return TwoOps_match<Val_t, Idx_t, Instruction::ExtractElement>(Val, Idx);
 }
 
-/// Matches ShuffleVectorInst.
+/// Matches shuffle.
+template <typename T0, typename T1, typename T2> struct Shuffle_match {
+  T0 Op1;
+  T1 Op2;
+  T2 Mask;
+
+  Shuffle_match(const T0 &Op1, const T1 &Op2, const T2 &Mask)
+      : Op1(Op1), Op2(Op2), Mask(Mask) {}
+
+  template <typename OpTy> bool match(OpTy *V) {
+    if (auto *I = dyn_cast<ShuffleVectorInst>(V)) {
+      return Op1.match(I->getOperand(0)) && Op2.match(I->getOperand(1)) &&
+             Mask.match(I->getShuffleMask());
+    }
+    return false;
+  }
+};
+
+struct m_Mask {
+  ArrayRef<int> &MaskRef;
+  m_Mask(ArrayRef<int> &MaskRef) : MaskRef(MaskRef) {}
+  bool match(ArrayRef<int> Mask) {
+    MaskRef = Mask;
+    return true;
+  }
+};
+
+struct m_ZeroMask {
+  bool match(ArrayRef<int> Mask) {
+    return all_of(Mask, [](int Elem) { return Elem == 0 || Elem == -1; });
+  }
+};
+
+struct m_SpecificMask {
+  ArrayRef<int> &MaskRef;
+  m_SpecificMask(ArrayRef<int> &MaskRef) : MaskRef(MaskRef) {}
+  bool match(ArrayRef<int> Mask) { return MaskRef == Mask; }
+};
+
+struct m_SplatOrUndefMask {
+  int &SplatIndex;
+  m_SplatOrUndefMask(int &SplatIndex) : SplatIndex(SplatIndex) {}
+  bool match(ArrayRef<int> Mask) {
+    auto First = find_if(Mask, [](int Elem) { return Elem != -1; });
+    if (First == Mask.end())
+      return false;
+    SplatIndex = *First;
+    return all_of(Mask,
+                  [First](int Elem) { return Elem == *First || Elem == -1; });
+  }
+};
+
+/// Matches ShuffleVectorInst independently of mask value.
+template <typename V1_t, typename V2_t>
+inline TwoOps_match<V1_t, V2_t, Instruction::ShuffleVector>
+m_Shuffle(const V1_t &v1, const V2_t &v2) {
+  return TwoOps_match<V1_t, V2_t, Instruction::ShuffleVector>(v1, v2);
+}
+
 template <typename V1_t, typename V2_t, typename Mask_t>
-inline ThreeOps_match<V1_t, V2_t, Mask_t, Instruction::ShuffleVector>
-m_ShuffleVector(const V1_t &v1, const V2_t &v2, const Mask_t &m) {
-  return ThreeOps_match<V1_t, V2_t, Mask_t, Instruction::ShuffleVector>(v1, v2,
-                                                                        m);
+inline Shuffle_match<V1_t, V2_t, Mask_t>
+m_Shuffle(const V1_t &v1, const V2_t &v2, const Mask_t &mask) {
+  return Shuffle_match<V1_t, V2_t, Mask_t>(v1, v2, mask);
 }
 
 /// Matches LoadInst.
@@ -1178,12 +1557,24 @@
   return CastClass_match<OpTy, Instruction::PtrToInt>(Op);
 }
 
+/// Matches IntToPtr.
+template <typename OpTy>
+inline CastClass_match<OpTy, Instruction::IntToPtr> m_IntToPtr(const OpTy &Op) {
+  return CastClass_match<OpTy, Instruction::IntToPtr>(Op);
+}
+
 /// Matches Trunc.
 template <typename OpTy>
 inline CastClass_match<OpTy, Instruction::Trunc> m_Trunc(const OpTy &Op) {
   return CastClass_match<OpTy, Instruction::Trunc>(Op);
 }
 
+template <typename OpTy>
+inline match_combine_or<CastClass_match<OpTy, Instruction::Trunc>, OpTy>
+m_TruncOrSelf(const OpTy &Op) {
+  return m_CombineOr(m_Trunc(Op), Op);
+}
+
 /// Matches SExt.
 template <typename OpTy>
 inline CastClass_match<OpTy, Instruction::SExt> m_SExt(const OpTy &Op) {
@@ -1197,31 +1588,58 @@
 }
 
 template <typename OpTy>
+inline match_combine_or<CastClass_match<OpTy, Instruction::ZExt>, OpTy>
+m_ZExtOrSelf(const OpTy &Op) {
+  return m_CombineOr(m_ZExt(Op), Op);
+}
+
+template <typename OpTy>
+inline match_combine_or<CastClass_match<OpTy, Instruction::SExt>, OpTy>
+m_SExtOrSelf(const OpTy &Op) {
+  return m_CombineOr(m_SExt(Op), Op);
+}
+
+template <typename OpTy>
 inline match_combine_or<CastClass_match<OpTy, Instruction::ZExt>,
                         CastClass_match<OpTy, Instruction::SExt>>
 m_ZExtOrSExt(const OpTy &Op) {
   return m_CombineOr(m_ZExt(Op), m_SExt(Op));
 }
 
-/// Matches UIToFP.
+template <typename OpTy>
+inline match_combine_or<
+    match_combine_or<CastClass_match<OpTy, Instruction::ZExt>,
+                     CastClass_match<OpTy, Instruction::SExt>>,
+    OpTy>
+m_ZExtOrSExtOrSelf(const OpTy &Op) {
+  return m_CombineOr(m_ZExtOrSExt(Op), Op);
+}
+
 template <typename OpTy>
 inline CastClass_match<OpTy, Instruction::UIToFP> m_UIToFP(const OpTy &Op) {
   return CastClass_match<OpTy, Instruction::UIToFP>(Op);
 }
 
-/// Matches SIToFP.
 template <typename OpTy>
 inline CastClass_match<OpTy, Instruction::SIToFP> m_SIToFP(const OpTy &Op) {
   return CastClass_match<OpTy, Instruction::SIToFP>(Op);
 }
 
-/// Matches FPTrunc
+template <typename OpTy>
+inline CastClass_match<OpTy, Instruction::FPToUI> m_FPToUI(const OpTy &Op) {
+  return CastClass_match<OpTy, Instruction::FPToUI>(Op);
+}
+
+template <typename OpTy>
+inline CastClass_match<OpTy, Instruction::FPToSI> m_FPToSI(const OpTy &Op) {
+  return CastClass_match<OpTy, Instruction::FPToSI>(Op);
+}
+
 template <typename OpTy>
 inline CastClass_match<OpTy, Instruction::FPTrunc> m_FPTrunc(const OpTy &Op) {
   return CastClass_match<OpTy, Instruction::FPTrunc>(Op);
 }
 
-/// Matches FPExt
 template <typename OpTy>
 inline CastClass_match<OpTy, Instruction::FPExt> m_FPExt(const OpTy &Op) {
   return CastClass_match<OpTy, Instruction::FPExt>(Op);
@@ -1248,27 +1666,34 @@
 
 inline br_match m_UnconditionalBr(BasicBlock *&Succ) { return br_match(Succ); }
 
-template <typename Cond_t> struct brc_match {
+template <typename Cond_t, typename TrueBlock_t, typename FalseBlock_t>
+struct brc_match {
   Cond_t Cond;
-  BasicBlock *&T, *&F;
+  TrueBlock_t T;
+  FalseBlock_t F;
 
-  brc_match(const Cond_t &C, BasicBlock *&t, BasicBlock *&f)
+  brc_match(const Cond_t &C, const TrueBlock_t &t, const FalseBlock_t &f)
       : Cond(C), T(t), F(f) {}
 
   template <typename OpTy> bool match(OpTy *V) {
     if (auto *BI = dyn_cast<BranchInst>(V))
-      if (BI->isConditional() && Cond.match(BI->getCondition())) {
-        T = BI->getSuccessor(0);
-        F = BI->getSuccessor(1);
-        return true;
-      }
+      if (BI->isConditional() && Cond.match(BI->getCondition()))
+        return T.match(BI->getSuccessor(0)) && F.match(BI->getSuccessor(1));
     return false;
   }
 };
 
 template <typename Cond_t>
-inline brc_match<Cond_t> m_Br(const Cond_t &C, BasicBlock *&T, BasicBlock *&F) {
-  return brc_match<Cond_t>(C, T, F);
+inline brc_match<Cond_t, bind_ty<BasicBlock>, bind_ty<BasicBlock>>
+m_Br(const Cond_t &C, BasicBlock *&T, BasicBlock *&F) {
+  return brc_match<Cond_t, bind_ty<BasicBlock>, bind_ty<BasicBlock>>(
+      C, m_BasicBlock(T), m_BasicBlock(F));
+}
+
+template <typename Cond_t, typename TrueBlock_t, typename FalseBlock_t>
+inline brc_match<Cond_t, TrueBlock_t, FalseBlock_t>
+m_Br(const Cond_t &C, const TrueBlock_t &T, const FalseBlock_t &F) {
+  return brc_match<Cond_t, TrueBlock_t, FalseBlock_t>(C, T, F);
 }
 
 //===----------------------------------------------------------------------===//
@@ -1286,6 +1711,17 @@
   MaxMin_match(const LHS_t &LHS, const RHS_t &RHS) : L(LHS), R(RHS) {}
 
   template <typename OpTy> bool match(OpTy *V) {
+    if (auto *II = dyn_cast<IntrinsicInst>(V)) {
+      Intrinsic::ID IID = II->getIntrinsicID();
+      if ((IID == Intrinsic::smax && Pred_t::match(ICmpInst::ICMP_SGT)) ||
+          (IID == Intrinsic::smin && Pred_t::match(ICmpInst::ICMP_SLT)) ||
+          (IID == Intrinsic::umax && Pred_t::match(ICmpInst::ICMP_UGT)) ||
+          (IID == Intrinsic::umin && Pred_t::match(ICmpInst::ICMP_ULT))) {
+        Value *LHS = II->getOperand(0), *RHS = II->getOperand(1);
+        return (L.match(LHS) && R.match(RHS)) ||
+               (Commutable && L.match(RHS) && R.match(LHS));
+      }
+    }
     // Look for "(x pred y) ? x : y" or "(x pred y) ? y : x".
     auto *SI = dyn_cast<SelectInst>(V);
     if (!SI)
@@ -1393,6 +1829,17 @@
   return MaxMin_match<ICmpInst, LHS, RHS, umin_pred_ty>(L, R);
 }
 
+template <typename LHS, typename RHS>
+inline match_combine_or<
+    match_combine_or<MaxMin_match<ICmpInst, LHS, RHS, smax_pred_ty>,
+                     MaxMin_match<ICmpInst, LHS, RHS, smin_pred_ty>>,
+    match_combine_or<MaxMin_match<ICmpInst, LHS, RHS, umax_pred_ty>,
+                     MaxMin_match<ICmpInst, LHS, RHS, umin_pred_ty>>>
+m_MaxOrMin(const LHS &L, const RHS &R) {
+  return m_CombineOr(m_CombineOr(m_SMax(L, R), m_SMin(L, R)),
+                     m_CombineOr(m_UMax(L, R), m_UMin(L, R)));
+}
+
 /// Match an 'ordered' floating point maximum function.
 /// Floating point has one special value 'NaN'. Therefore, there is no total
 /// order. However, if we can ignore the 'NaN' value (for example, because of a
@@ -1454,7 +1901,8 @@
 }
 
 //===----------------------------------------------------------------------===//
-// Matchers for overflow check patterns: e.g. (a + b) u< a
+// Matchers for overflow check patterns: e.g. (a + b) u< a, (a ^ -1) <u b
+// Note that S might be matched to other instructions than AddInst.
 //
 
 template <typename LHS_t, typename RHS_t, typename Sum_t>
@@ -1485,6 +1933,19 @@
       if (AddExpr.match(ICmpRHS) && (ICmpLHS == AddLHS || ICmpLHS == AddRHS))
         return L.match(AddLHS) && R.match(AddRHS) && S.match(ICmpRHS);
 
+    Value *Op1;
+    auto XorExpr = m_OneUse(m_Xor(m_Value(Op1), m_AllOnes()));
+    // (a ^ -1) <u b
+    if (Pred == ICmpInst::ICMP_ULT) {
+      if (XorExpr.match(ICmpLHS))
+        return L.match(Op1) && R.match(ICmpRHS) && S.match(ICmpLHS);
+    }
+    //  b > u (a ^ -1)
+    if (Pred == ICmpInst::ICMP_UGT) {
+      if (XorExpr.match(ICmpRHS))
+        return L.match(Op1) && R.match(ICmpLHS) && S.match(ICmpRHS);
+    }
+
     // Match special-case for increment-by-1.
     if (Pred == ICmpInst::ICMP_EQ) {
       // (a + 1) == 0
@@ -1576,6 +2037,18 @@
                         Argument_match<T3>>;
 };
 
+template <typename T0, typename T1, typename T2, typename T3, typename T4>
+struct m_Intrinsic_Ty<T0, T1, T2, T3, T4> {
+  using Ty = match_combine_and<typename m_Intrinsic_Ty<T0, T1, T2, T3>::Ty,
+                               Argument_match<T4>>;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5>
+struct m_Intrinsic_Ty<T0, T1, T2, T3, T4, T5> {
+  using Ty = match_combine_and<typename m_Intrinsic_Ty<T0, T1, T2, T3, T4>::Ty,
+                               Argument_match<T5>>;
+};
+
 /// Match intrinsic calls like this:
 /// m_Intrinsic<Intrinsic::fabs>(m_Value(X))
 template <Intrinsic::ID IntrID> inline IntrinsicID_match m_Intrinsic() {
@@ -1606,6 +2079,24 @@
   return m_CombineAnd(m_Intrinsic<IntrID>(Op0, Op1, Op2), m_Argument<3>(Op3));
 }
 
+template <Intrinsic::ID IntrID, typename T0, typename T1, typename T2,
+          typename T3, typename T4>
+inline typename m_Intrinsic_Ty<T0, T1, T2, T3, T4>::Ty
+m_Intrinsic(const T0 &Op0, const T1 &Op1, const T2 &Op2, const T3 &Op3,
+            const T4 &Op4) {
+  return m_CombineAnd(m_Intrinsic<IntrID>(Op0, Op1, Op2, Op3),
+                      m_Argument<4>(Op4));
+}
+
+template <Intrinsic::ID IntrID, typename T0, typename T1, typename T2,
+          typename T3, typename T4, typename T5>
+inline typename m_Intrinsic_Ty<T0, T1, T2, T3, T4, T5>::Ty
+m_Intrinsic(const T0 &Op0, const T1 &Op1, const T2 &Op2, const T3 &Op3,
+            const T4 &Op4, const T5 &Op5) {
+  return m_CombineAnd(m_Intrinsic<IntrID>(Op0, Op1, Op2, Op3, Op4),
+                      m_Argument<5>(Op5));
+}
+
 // Helper intrinsic matching specializations.
 template <typename Opnd0>
 inline typename m_Intrinsic_Ty<Opnd0>::Ty m_BitReverse(const Opnd0 &Op0) {
@@ -1639,6 +2130,18 @@
   return m_Intrinsic<Intrinsic::maxnum>(Op0, Op1);
 }
 
+template <typename Opnd0, typename Opnd1, typename Opnd2>
+inline typename m_Intrinsic_Ty<Opnd0, Opnd1, Opnd2>::Ty
+m_FShl(const Opnd0 &Op0, const Opnd1 &Op1, const Opnd2 &Op2) {
+  return m_Intrinsic<Intrinsic::fshl>(Op0, Op1, Op2);
+}
+
+template <typename Opnd0, typename Opnd1, typename Opnd2>
+inline typename m_Intrinsic_Ty<Opnd0, Opnd1, Opnd2>::Ty
+m_FShr(const Opnd0 &Op0, const Opnd1 &Op1, const Opnd2 &Op2) {
+  return m_Intrinsic<Intrinsic::fshr>(Op0, Op1, Op2);
+}
+
 //===----------------------------------------------------------------------===//
 // Matchers for two-operands operators with the operators in either order
 //
@@ -1650,7 +2153,7 @@
 }
 
 /// Matches an ICmp with a predicate over LHS and RHS in either order.
-/// Does not swap the predicate.
+/// Swaps the predicate if operands are commuted.
 template <typename LHS, typename RHS>
 inline CmpClass_match<LHS, RHS, ICmpInst, ICmpInst::Predicate, true>
 m_c_ICmp(ICmpInst::Predicate &Pred, const LHS &L, const RHS &R) {
@@ -1700,6 +2203,15 @@
   return m_Sub(m_ZeroInt(), V);
 }
 
+/// Matches a 'Neg' as 'sub nsw 0, V'.
+template <typename ValTy>
+inline OverflowingBinaryOp_match<cst_pred_ty<is_zero_int>, ValTy,
+                                 Instruction::Sub,
+                                 OverflowingBinaryOperator::NoSignedWrap>
+m_NSWNeg(const ValTy &V) {
+  return m_NSWSub(m_ZeroInt(), V);
+}
+
 /// Matches a 'Not' as 'xor V, -1' or 'xor -1, V'.
 template <typename ValTy>
 inline BinaryOp_match<ValTy, cst_pred_ty<is_all_ones>, Instruction::Xor, true>
@@ -1732,6 +2244,17 @@
   return MaxMin_match<ICmpInst, LHS, RHS, umax_pred_ty, true>(L, R);
 }
 
+template <typename LHS, typename RHS>
+inline match_combine_or<
+    match_combine_or<MaxMin_match<ICmpInst, LHS, RHS, smax_pred_ty, true>,
+                     MaxMin_match<ICmpInst, LHS, RHS, smin_pred_ty, true>>,
+    match_combine_or<MaxMin_match<ICmpInst, LHS, RHS, umax_pred_ty, true>,
+                     MaxMin_match<ICmpInst, LHS, RHS, umin_pred_ty, true>>>
+m_c_MaxOrMin(const LHS &L, const RHS &R) {
+  return m_CombineOr(m_CombineOr(m_c_SMax(L, R), m_c_SMin(L, R)),
+                     m_CombineOr(m_c_UMax(L, R), m_c_UMin(L, R)));
+}
+
 /// Matches FAdd with LHS and RHS in either order.
 template <typename LHS, typename RHS>
 inline BinaryOp_match<LHS, RHS, Instruction::FAdd, true>
@@ -1786,6 +2309,136 @@
   return Signum_match<Val_t>(V);
 }
 
+template <int Ind, typename Opnd_t> struct ExtractValue_match {
+  Opnd_t Val;
+  ExtractValue_match(const Opnd_t &V) : Val(V) {}
+
+  template <typename OpTy> bool match(OpTy *V) {
+    if (auto *I = dyn_cast<ExtractValueInst>(V))
+      return I->getNumIndices() == 1 && I->getIndices()[0] == Ind &&
+             Val.match(I->getAggregateOperand());
+    return false;
+  }
+};
+
+/// Match a single index ExtractValue instruction.
+/// For example m_ExtractValue<1>(...)
+template <int Ind, typename Val_t>
+inline ExtractValue_match<Ind, Val_t> m_ExtractValue(const Val_t &V) {
+  return ExtractValue_match<Ind, Val_t>(V);
+}
+
+/// Matcher for a single index InsertValue instruction.
+template <int Ind, typename T0, typename T1> struct InsertValue_match {
+  T0 Op0;
+  T1 Op1;
+
+  InsertValue_match(const T0 &Op0, const T1 &Op1) : Op0(Op0), Op1(Op1) {}
+
+  template <typename OpTy> bool match(OpTy *V) {
+    if (auto *I = dyn_cast<InsertValueInst>(V)) {
+      return Op0.match(I->getOperand(0)) && Op1.match(I->getOperand(1)) &&
+             I->getNumIndices() == 1 && Ind == I->getIndices()[0];
+    }
+    return false;
+  }
+};
+
+/// Matches a single index InsertValue instruction.
+template <int Ind, typename Val_t, typename Elt_t>
+inline InsertValue_match<Ind, Val_t, Elt_t> m_InsertValue(const Val_t &Val,
+                                                          const Elt_t &Elt) {
+  return InsertValue_match<Ind, Val_t, Elt_t>(Val, Elt);
+}
+
+/// Matches patterns for `vscale`. This can either be a call to `llvm.vscale` or
+/// the constant expression
+///  `ptrtoint(gep <vscale x 1 x i8>, <vscale x 1 x i8>* null, i32 1>`
+/// under the right conditions determined by DataLayout.
+struct VScaleVal_match {
+private:
+  template <typename Base, typename Offset>
+  inline BinaryOp_match<Base, Offset, Instruction::GetElementPtr>
+  m_OffsetGep(const Base &B, const Offset &O) {
+    return BinaryOp_match<Base, Offset, Instruction::GetElementPtr>(B, O);
+  }
+
+public:
+  const DataLayout &DL;
+  VScaleVal_match(const DataLayout &DL) : DL(DL) {}
+
+  template <typename ITy> bool match(ITy *V) {
+    if (m_Intrinsic<Intrinsic::vscale>().match(V))
+      return true;
+
+    if (m_PtrToInt(m_OffsetGep(m_Zero(), m_SpecificInt(1))).match(V)) {
+      Type *PtrTy = cast<Operator>(V)->getOperand(0)->getType();
+      auto *DerefTy = PtrTy->getPointerElementType();
+      if (isa<ScalableVectorType>(DerefTy) &&
+          DL.getTypeAllocSizeInBits(DerefTy).getKnownMinSize() == 8)
+        return true;
+    }
+
+    return false;
+  }
+};
+
+inline VScaleVal_match m_VScale(const DataLayout &DL) {
+  return VScaleVal_match(DL);
+}
+
+template <typename LHS, typename RHS, unsigned Opcode>
+struct LogicalOp_match {
+  LHS L;
+  RHS R;
+
+  LogicalOp_match(const LHS &L, const RHS &R) : L(L), R(R) {}
+
+  template <typename T> bool match(T *V) {
+    if (auto *I = dyn_cast<Instruction>(V)) {
+      if (!I->getType()->isIntOrIntVectorTy(1))
+        return false;
+
+      if (I->getOpcode() == Opcode && L.match(I->getOperand(0)) &&
+          R.match(I->getOperand(1)))
+        return true;
+
+      if (auto *SI = dyn_cast<SelectInst>(I)) {
+        if (Opcode == Instruction::And) {
+          if (const auto *C = dyn_cast<Constant>(SI->getFalseValue()))
+            if (C->isNullValue() && L.match(SI->getCondition()) &&
+                R.match(SI->getTrueValue()))
+              return true;
+        } else {
+          assert(Opcode == Instruction::Or);
+          if (const auto *C = dyn_cast<Constant>(SI->getTrueValue()))
+            if (C->isOneValue() && L.match(SI->getCondition()) &&
+                R.match(SI->getFalseValue()))
+              return true;
+        }
+      }
+    }
+
+    return false;
+  }
+};
+
+/// Matches L && R either in the form of L & R or L ? R : false.
+/// Note that the latter form is poison-blocking.
+template <typename LHS, typename RHS>
+inline LogicalOp_match<LHS, RHS, Instruction::And>
+m_LogicalAnd(const LHS &L, const RHS &R) {
+  return LogicalOp_match<LHS, RHS, Instruction::And>(L, R);
+}
+
+/// Matches L || R either in the form of L | R or L ? true : R.
+/// Note that the latter form is poison-blocking.
+template <typename LHS, typename RHS>
+inline LogicalOp_match<LHS, RHS, Instruction::Or>
+m_LogicalOr(const LHS &L, const RHS &R) {
+  return LogicalOp_match<LHS, RHS, Instruction::Or>(L, R);
+}
+
 } // end namespace PatternMatch
 } // end namespace llvm
 
diff --git a/linux-x64/clang/include/llvm/IR/PredIteratorCache.h b/linux-x64/clang/include/llvm/IR/PredIteratorCache.h
index cc83527..6bbd7e5 100644
--- a/linux-x64/clang/include/llvm/IR/PredIteratorCache.h
+++ b/linux-x64/clang/include/llvm/IR/PredIteratorCache.h
@@ -44,7 +44,7 @@
     if (Entry)
       return Entry;
 
-    SmallVector<BasicBlock *, 32> PredCache(pred_begin(BB), pred_end(BB));
+    SmallVector<BasicBlock *, 32> PredCache(predecessors(BB));
     PredCache.push_back(nullptr); // null terminator.
 
     BlockToPredCountMap[BB] = PredCache.size() - 1;
@@ -58,7 +58,7 @@
     auto Result = BlockToPredCountMap.find(BB);
     if (Result != BlockToPredCountMap.end())
       return Result->second;
-    return BlockToPredCountMap[BB] = std::distance(pred_begin(BB), pred_end(BB));
+    return BlockToPredCountMap[BB] = pred_size(BB);
   }
 
 public:
diff --git a/linux-x64/clang/include/llvm/IR/PrintPasses.h b/linux-x64/clang/include/llvm/IR/PrintPasses.h
new file mode 100644
index 0000000..1fa7c18
--- /dev/null
+++ b/linux-x64/clang/include/llvm/IR/PrintPasses.h
@@ -0,0 +1,44 @@
+//===- PrintPasses.h - Determining whether/when to print IR ---------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_IR_PRINTPASSES_H
+#define LLVM_IR_PRINTPASSES_H
+
+#include "llvm/ADT/StringRef.h"
+#include <vector>
+
+namespace llvm {
+
+// Returns true if printing before/after some pass is enabled, whether all
+// passes or a specific pass.
+bool shouldPrintBeforeSomePass();
+bool shouldPrintAfterSomePass();
+
+// Returns true if we should print before/after a specific pass. The argument
+// should be the pass ID, e.g. "instcombine".
+bool shouldPrintBeforePass(StringRef PassID);
+bool shouldPrintAfterPass(StringRef PassID);
+
+// Returns true if we should print before/after all passes.
+bool shouldPrintBeforeAll();
+bool shouldPrintAfterAll();
+
+// The list of passes to print before/after, if we only want to print
+// before/after specific passes.
+std::vector<std::string> printBeforePasses();
+std::vector<std::string> printAfterPasses();
+
+// Returns true if we should always print the entire module.
+bool forcePrintModuleIR();
+
+// Returns true if we should print the function.
+bool isFunctionInPrintList(StringRef FunctionName);
+
+} // namespace llvm
+
+#endif // LLVM_IR_PRINTPASSES_H
diff --git a/linux-x64/clang/include/llvm/IR/ProfileSummary.h b/linux-x64/clang/include/llvm/IR/ProfileSummary.h
index 78635ec..889568e 100644
--- a/linux-x64/clang/include/llvm/IR/ProfileSummary.h
+++ b/linux-x64/clang/include/llvm/IR/ProfileSummary.h
@@ -14,6 +14,7 @@
 #define LLVM_IR_PROFILESUMMARY_H
 
 #include <algorithm>
+#include <cassert>
 #include <cstdint>
 #include <vector>
 
@@ -21,6 +22,7 @@
 
 class LLVMContext;
 class Metadata;
+class raw_ostream;
 
 // The profile summary is one or more (Cutoff, MinCount, NumCounts) triplets.
 // The semantics of counts depend on the type of profile. For instrumentation
@@ -49,6 +51,17 @@
   SummaryEntryVector DetailedSummary;
   uint64_t TotalCount, MaxCount, MaxInternalCount, MaxFunctionCount;
   uint32_t NumCounts, NumFunctions;
+  /// If 'Partial' is false, it means the profile being used to optimize
+  /// a target is collected from the same target.
+  /// If 'Partial' is true, it means the profile is for common/shared
+  /// code. The common profile is usually merged from profiles collected
+  /// from running other targets.
+  bool Partial = false;
+  /// This approximately represents the ratio of the number of profile counters
+  /// of the program being built to the number of profile counters in the
+  /// partial sample profile. When 'Partial' is false, it is undefined. This is
+  /// currently only available under thin LTO mode.
+  double PartialProfileRatio = 0;
   /// Return detailed summary as metadata.
   Metadata *getDetailedSummaryMD(LLVMContext &Context);
 
@@ -58,15 +71,18 @@
   ProfileSummary(Kind K, SummaryEntryVector DetailedSummary,
                  uint64_t TotalCount, uint64_t MaxCount,
                  uint64_t MaxInternalCount, uint64_t MaxFunctionCount,
-                 uint32_t NumCounts, uint32_t NumFunctions)
+                 uint32_t NumCounts, uint32_t NumFunctions,
+                 bool Partial = false, double PartialProfileRatio = 0)
       : PSK(K), DetailedSummary(std::move(DetailedSummary)),
         TotalCount(TotalCount), MaxCount(MaxCount),
         MaxInternalCount(MaxInternalCount), MaxFunctionCount(MaxFunctionCount),
-        NumCounts(NumCounts), NumFunctions(NumFunctions) {}
+        NumCounts(NumCounts), NumFunctions(NumFunctions), Partial(Partial),
+        PartialProfileRatio(PartialProfileRatio) {}
 
   Kind getKind() const { return PSK; }
   /// Return summary information as metadata.
-  Metadata *getMD(LLVMContext &Context);
+  Metadata *getMD(LLVMContext &Context, bool AddPartialField = true,
+                  bool AddPartialProfileRatioField = true);
   /// Construct profile summary from metdata.
   static ProfileSummary *getFromMD(Metadata *MD);
   SummaryEntryVector &getDetailedSummary() { return DetailedSummary; }
@@ -76,6 +92,15 @@
   uint64_t getTotalCount() { return TotalCount; }
   uint64_t getMaxCount() { return MaxCount; }
   uint64_t getMaxInternalCount() { return MaxInternalCount; }
+  void setPartialProfile(bool PP) { Partial = PP; }
+  bool isPartialProfile() { return Partial; }
+  double getPartialProfileRatio() { return PartialProfileRatio; }
+  void setPartialProfileRatio(double R) {
+    assert(isPartialProfile() && "Unexpected when not partial profile");
+    PartialProfileRatio = R;
+  }
+  void printSummary(raw_ostream &OS);
+  void printDetailedSummary(raw_ostream &OS);
 };
 
 } // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/IR/PseudoProbe.h b/linux-x64/clang/include/llvm/IR/PseudoProbe.h
new file mode 100644
index 0000000..e0370c2
--- /dev/null
+++ b/linux-x64/clang/include/llvm/IR/PseudoProbe.h
@@ -0,0 +1,66 @@
+//===- PseudoProbe.h - Pseudo Probe IR Helpers ------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Pseudo probe IR intrinsic and dwarf discriminator manipulation routines.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_IR_PSEUDOPROBE_H
+#define LLVM_IR_PSEUDOPROBE_H
+
+#include "llvm/ADT/Optional.h"
+#include <cassert>
+#include <cstdint>
+
+namespace llvm {
+
+class Instruction;
+
+constexpr const char *PseudoProbeDescMetadataName = "llvm.pseudo_probe_desc";
+
+enum class PseudoProbeType { Block = 0, IndirectCall, DirectCall };
+
+struct PseudoProbeDwarfDiscriminator {
+  // The following APIs encodes/decodes per-probe information to/from a
+  // 32-bit integer which is organized as:
+  //  [2:0] - 0x7, this is reserved for regular discriminator,
+  //          see DWARF discriminator encoding rule
+  //  [18:3] - probe id
+  //  [25:19] - reserved
+  //  [28:26] - probe type, see PseudoProbeType
+  //  [31:29] - reserved for probe attributes
+  static uint32_t packProbeData(uint32_t Index, uint32_t Type) {
+    assert(Index <= 0xFFFF && "Probe index too big to encode, exceeding 2^16");
+    assert(Type <= 0x7 && "Probe type too big to encode, exceeding 7");
+    return (Index << 3) | (Type << 26) | 0x7;
+  }
+
+  static uint32_t extractProbeIndex(uint32_t Value) {
+    return (Value >> 3) & 0xFFFF;
+  }
+
+  static uint32_t extractProbeType(uint32_t Value) {
+    return (Value >> 26) & 0x7;
+  }
+
+  static uint32_t extractProbeAttributes(uint32_t Value) {
+    return (Value >> 29) & 0x7;
+  }
+};
+
+struct PseudoProbe {
+  uint32_t Id;
+  uint32_t Type;
+  uint32_t Attr;
+};
+
+Optional<PseudoProbe> extractProbe(const Instruction &Inst);
+
+} // end namespace llvm
+
+#endif // LLVM_IR_PSEUDOPROBE_H
diff --git a/linux-x64/clang/include/llvm/IR/RemarkStreamer.h b/linux-x64/clang/include/llvm/IR/RemarkStreamer.h
deleted file mode 100644
index 9b6d82e..0000000
--- a/linux-x64/clang/include/llvm/IR/RemarkStreamer.h
+++ /dev/null
@@ -1,106 +0,0 @@
-//===- llvm/IR/RemarkStreamer.h - Remark Streamer ---------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// This file declares the main interface for outputting remarks.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_IR_REMARKSTREAMER_H
-#define LLVM_IR_REMARKSTREAMER_H
-
-#include "llvm/IR/DiagnosticInfo.h"
-#include "llvm/Remarks/RemarkSerializer.h"
-#include "llvm/Support/Error.h"
-#include "llvm/Support/Regex.h"
-#include "llvm/Support/ToolOutputFile.h"
-#include "llvm/Support/raw_ostream.h"
-#include <string>
-#include <vector>
-
-namespace llvm {
-/// Streamer for remarks.
-class RemarkStreamer {
-  /// The filename that the remark diagnostics are emitted to.
-  const std::string Filename;
-  /// The regex used to filter remarks based on the passes that emit them.
-  Optional<Regex> PassFilter;
-  /// The object used to serialize the remarks to a specific format.
-  std::unique_ptr<remarks::Serializer> Serializer;
-
-  /// Temporary buffer for converting diagnostics into remark objects. This is
-  /// used for the remark arguments that are converted from a vector of
-  /// diagnostic arguments to a vector of remark arguments.
-  SmallVector<remarks::Argument, 8> TmpArgs;
-  /// Convert diagnostics into remark objects. The result uses \p TmpArgs as a
-  /// temporary buffer for the remark arguments, and relies on all the strings
-  /// to be kept in memory until the next call to `toRemark`.
-  /// The lifetime of the members of the result is bound to the lifetime of both
-  /// the remark streamer and the LLVM diagnostics.
-  remarks::Remark toRemark(const DiagnosticInfoOptimizationBase &Diag);
-
-public:
-  RemarkStreamer(StringRef Filename,
-                 std::unique_ptr<remarks::Serializer> Serializer);
-  /// Return the filename that the remark diagnostics are emitted to.
-  StringRef getFilename() const { return Filename; }
-  /// Return stream that the remark diagnostics are emitted to.
-  raw_ostream &getStream() { return Serializer->OS; }
-  /// Return the serializer used for this stream.
-  remarks::Serializer &getSerializer() { return *Serializer; }
-  /// Set a pass filter based on a regex \p Filter.
-  /// Returns an error if the regex is invalid.
-  Error setFilter(StringRef Filter);
-  /// Emit a diagnostic through the streamer.
-  void emit(const DiagnosticInfoOptimizationBase &Diag);
-};
-
-template <typename ThisError>
-struct RemarkSetupErrorInfo : public ErrorInfo<ThisError> {
-  std::string Msg;
-  std::error_code EC;
-
-  RemarkSetupErrorInfo(Error E) {
-    handleAllErrors(std::move(E), [&](const ErrorInfoBase &EIB) {
-      Msg = EIB.message();
-      EC = EIB.convertToErrorCode();
-    });
-  }
-
-  void log(raw_ostream &OS) const override { OS << Msg; }
-  std::error_code convertToErrorCode() const override { return EC; }
-};
-
-struct RemarkSetupFileError : RemarkSetupErrorInfo<RemarkSetupFileError> {
-  static char ID;
-  using RemarkSetupErrorInfo<RemarkSetupFileError>::RemarkSetupErrorInfo;
-};
-
-struct RemarkSetupPatternError : RemarkSetupErrorInfo<RemarkSetupPatternError> {
-  static char ID;
-  using RemarkSetupErrorInfo<RemarkSetupPatternError>::RemarkSetupErrorInfo;
-};
-
-struct RemarkSetupFormatError : RemarkSetupErrorInfo<RemarkSetupFormatError> {
-  static char ID;
-  using RemarkSetupErrorInfo<RemarkSetupFormatError>::RemarkSetupErrorInfo;
-};
-
-enum class RemarksSerializerFormat { Unknown, YAML };
-
-Expected<RemarksSerializerFormat> parseSerializerFormat(StringRef Format);
-
-/// Setup optimization remarks.
-Expected<std::unique_ptr<ToolOutputFile>>
-setupOptimizationRemarks(LLVMContext &Context, StringRef RemarksFilename,
-                         StringRef RemarksPasses, StringRef RemarksFormat,
-                         bool RemarksWithHotness,
-                         unsigned RemarksHotnessThreshold = 0);
-
-} // end namespace llvm
-
-#endif // LLVM_IR_REMARKSTREAMER_H
diff --git a/linux-x64/clang/include/llvm/IR/RuntimeLibcalls.def b/linux-x64/clang/include/llvm/IR/RuntimeLibcalls.def
index f6c74d4..c731726 100644
--- a/linux-x64/clang/include/llvm/IR/RuntimeLibcalls.def
+++ b/linux-x64/clang/include/llvm/IR/RuntimeLibcalls.def
@@ -23,7 +23,7 @@
 
 // Declare the enumerator for each libcall, along with its default name. Some
 // libcalls have different names on particular OSes or architectures. These
-// are set in InitLibcallNames() in TargetLoweringBase.cpp and/or by targets
+// are set in InitLibcalls() in TargetLoweringBase.cpp and/or by targets
 // using TargetLoweringBase::setLibcallName()
 #ifndef HANDLE_LIBCALL
 #error "HANDLE_LIBCALL must be defined"
@@ -234,6 +234,11 @@
 HANDLE_LIBCALL(ROUND_F80, "roundl")
 HANDLE_LIBCALL(ROUND_F128, "roundl")
 HANDLE_LIBCALL(ROUND_PPCF128, "roundl")
+HANDLE_LIBCALL(ROUNDEVEN_F32, "roundevenf")
+HANDLE_LIBCALL(ROUNDEVEN_F64, "roundeven")
+HANDLE_LIBCALL(ROUNDEVEN_F80, "roundevenl")
+HANDLE_LIBCALL(ROUNDEVEN_F128, "roundevenl")
+HANDLE_LIBCALL(ROUNDEVEN_PPCF128, "roundevenl")
 HANDLE_LIBCALL(FLOOR_F32, "floorf")
 HANDLE_LIBCALL(FLOOR_F64, "floor")
 HANDLE_LIBCALL(FLOOR_F80, "floorl")
@@ -281,7 +286,9 @@
 HANDLE_LIBCALL(FPEXT_F80_F128, "__extendxftf2")
 HANDLE_LIBCALL(FPEXT_F64_F128, "__extenddftf2")
 HANDLE_LIBCALL(FPEXT_F32_F128, "__extendsftf2")
+HANDLE_LIBCALL(FPEXT_F16_F128, "__extendhftf2")
 HANDLE_LIBCALL(FPEXT_F32_F64, "__extendsfdf2")
+HANDLE_LIBCALL(FPEXT_F16_F64, "__extendhfdf2")
 HANDLE_LIBCALL(FPEXT_F16_F32, "__gnu_h2f_ieee")
 HANDLE_LIBCALL(FPROUND_F32_F16, "__gnu_f2h_ieee")
 HANDLE_LIBCALL(FPROUND_F64_F16, "__truncdfhf2")
@@ -296,6 +303,9 @@
 HANDLE_LIBCALL(FPROUND_F128_F64, "__trunctfdf2")
 HANDLE_LIBCALL(FPROUND_PPCF128_F64, "__gcc_qtod")
 HANDLE_LIBCALL(FPROUND_F128_F80, "__trunctfxf2")
+HANDLE_LIBCALL(FPTOSINT_F16_I32, "__fixhfsi")
+HANDLE_LIBCALL(FPTOSINT_F16_I64, "__fixhfdi")
+HANDLE_LIBCALL(FPTOSINT_F16_I128, "__fixhfti")
 HANDLE_LIBCALL(FPTOSINT_F32_I32, "__fixsfsi")
 HANDLE_LIBCALL(FPTOSINT_F32_I64, "__fixsfdi")
 HANDLE_LIBCALL(FPTOSINT_F32_I128, "__fixsfti")
@@ -311,6 +321,9 @@
 HANDLE_LIBCALL(FPTOSINT_PPCF128_I32, "__gcc_qtou")
 HANDLE_LIBCALL(FPTOSINT_PPCF128_I64, "__fixtfdi")
 HANDLE_LIBCALL(FPTOSINT_PPCF128_I128, "__fixtfti")
+HANDLE_LIBCALL(FPTOUINT_F16_I32, "__fixunshfsi")
+HANDLE_LIBCALL(FPTOUINT_F16_I64, "__fixunshfdi")
+HANDLE_LIBCALL(FPTOUINT_F16_I128, "__fixunshfti")
 HANDLE_LIBCALL(FPTOUINT_F32_I32, "__fixunssfsi")
 HANDLE_LIBCALL(FPTOUINT_F32_I64, "__fixunssfdi")
 HANDLE_LIBCALL(FPTOUINT_F32_I128, "__fixunssfti")
@@ -326,31 +339,37 @@
 HANDLE_LIBCALL(FPTOUINT_PPCF128_I32, "__fixunstfsi")
 HANDLE_LIBCALL(FPTOUINT_PPCF128_I64, "__fixunstfdi")
 HANDLE_LIBCALL(FPTOUINT_PPCF128_I128, "__fixunstfti")
+HANDLE_LIBCALL(SINTTOFP_I32_F16, "__floatsihf")
 HANDLE_LIBCALL(SINTTOFP_I32_F32, "__floatsisf")
 HANDLE_LIBCALL(SINTTOFP_I32_F64, "__floatsidf")
 HANDLE_LIBCALL(SINTTOFP_I32_F80, "__floatsixf")
 HANDLE_LIBCALL(SINTTOFP_I32_F128, "__floatsitf")
 HANDLE_LIBCALL(SINTTOFP_I32_PPCF128, "__gcc_itoq")
+HANDLE_LIBCALL(SINTTOFP_I64_F16, "__floatdihf")
 HANDLE_LIBCALL(SINTTOFP_I64_F32, "__floatdisf")
 HANDLE_LIBCALL(SINTTOFP_I64_F64, "__floatdidf")
 HANDLE_LIBCALL(SINTTOFP_I64_F80, "__floatdixf")
 HANDLE_LIBCALL(SINTTOFP_I64_F128, "__floatditf")
 HANDLE_LIBCALL(SINTTOFP_I64_PPCF128, "__floatditf")
+HANDLE_LIBCALL(SINTTOFP_I128_F16, "__floattihf")
 HANDLE_LIBCALL(SINTTOFP_I128_F32, "__floattisf")
 HANDLE_LIBCALL(SINTTOFP_I128_F64, "__floattidf")
 HANDLE_LIBCALL(SINTTOFP_I128_F80, "__floattixf")
 HANDLE_LIBCALL(SINTTOFP_I128_F128, "__floattitf")
 HANDLE_LIBCALL(SINTTOFP_I128_PPCF128, "__floattitf")
+HANDLE_LIBCALL(UINTTOFP_I32_F16, "__floatunsihf")
 HANDLE_LIBCALL(UINTTOFP_I32_F32, "__floatunsisf")
 HANDLE_LIBCALL(UINTTOFP_I32_F64, "__floatunsidf")
 HANDLE_LIBCALL(UINTTOFP_I32_F80, "__floatunsixf")
 HANDLE_LIBCALL(UINTTOFP_I32_F128, "__floatunsitf")
 HANDLE_LIBCALL(UINTTOFP_I32_PPCF128, "__gcc_utoq")
+HANDLE_LIBCALL(UINTTOFP_I64_F16, "__floatundihf")
 HANDLE_LIBCALL(UINTTOFP_I64_F32, "__floatundisf")
 HANDLE_LIBCALL(UINTTOFP_I64_F64, "__floatundidf")
 HANDLE_LIBCALL(UINTTOFP_I64_F80, "__floatundixf")
 HANDLE_LIBCALL(UINTTOFP_I64_F128, "__floatunditf")
 HANDLE_LIBCALL(UINTTOFP_I64_PPCF128, "__floatunditf")
+HANDLE_LIBCALL(UINTTOFP_I128_F16, "__floatuntihf")
 HANDLE_LIBCALL(UINTTOFP_I128_F32, "__floatuntisf")
 HANDLE_LIBCALL(UINTTOFP_I128_F64, "__floatuntidf")
 HANDLE_LIBCALL(UINTTOFP_I128_F80, "__floatuntixf")
@@ -386,10 +405,6 @@
 HANDLE_LIBCALL(UO_F64, "__unorddf2")
 HANDLE_LIBCALL(UO_F128, "__unordtf2")
 HANDLE_LIBCALL(UO_PPCF128, "__gcc_qunord")
-HANDLE_LIBCALL(O_F32, "__unordsf2")
-HANDLE_LIBCALL(O_F64, "__unorddf2")
-HANDLE_LIBCALL(O_F128, "__unordtf2")
-HANDLE_LIBCALL(O_PPCF128, "__gcc_qunord")
 
 // Memory
 HANDLE_LIBCALL(MEMCPY, "memcpy")
@@ -543,6 +558,23 @@
 HANDLE_LIBCALL(ATOMIC_FETCH_NAND_8, "__atomic_fetch_nand_8")
 HANDLE_LIBCALL(ATOMIC_FETCH_NAND_16, "__atomic_fetch_nand_16")
 
+// Out-of-line atomics libcalls
+#define HLCALLS(A, N)                                                          \
+  HANDLE_LIBCALL(A##N##_RELAX, nullptr)                                        \
+  HANDLE_LIBCALL(A##N##_ACQ, nullptr)                                          \
+  HANDLE_LIBCALL(A##N##_REL, nullptr)                                          \
+  HANDLE_LIBCALL(A##N##_ACQ_REL, nullptr)
+#define HLCALL5(A)                                                             \
+  HLCALLS(A, 1) HLCALLS(A, 2) HLCALLS(A, 4) HLCALLS(A, 8) HLCALLS(A, 16)
+HLCALL5(OUTLINE_ATOMIC_CAS)
+HLCALL5(OUTLINE_ATOMIC_SWP)
+HLCALL5(OUTLINE_ATOMIC_LDADD)
+HLCALL5(OUTLINE_ATOMIC_LDSET)
+HLCALL5(OUTLINE_ATOMIC_LDCLR)
+HLCALL5(OUTLINE_ATOMIC_LDEOR)
+#undef HLCALLS
+#undef HLCALL5
+
 // Stack Protector Fail
 HANDLE_LIBCALL(STACKPROTECTOR_CHECK_FAIL, "__stack_chk_fail")
 
@@ -554,4 +586,3 @@
 
 HANDLE_LIBCALL(UNKNOWN_LIBCALL, nullptr)
 
-#undef HANDLE_LIBCALL
diff --git a/linux-x64/clang/include/llvm/IR/Statepoint.h b/linux-x64/clang/include/llvm/IR/Statepoint.h
index 89f130b..6ce1583 100644
--- a/linux-x64/clang/include/llvm/IR/Statepoint.h
+++ b/linux-x64/clang/include/llvm/IR/Statepoint.h
@@ -55,36 +55,24 @@
 class GCRelocateInst;
 class GCResultInst;
 
-bool isStatepoint(const CallBase *Call);
-bool isStatepoint(const Value *V);
-bool isStatepoint(const Value &V);
-
-bool isGCRelocate(const CallBase *Call);
-bool isGCRelocate(const Value *V);
-
-bool isGCResult(const CallBase *Call);
-bool isGCResult(const Value *V);
-
-/// A wrapper around a GC intrinsic call, this provides most of the actual
-/// functionality for Statepoint and ImmutableStatepoint.  It is
-/// templatized to allow easily specializing of const and non-const
-/// concrete subtypes.
-template <typename FunTy, typename InstructionTy, typename ValueTy,
-          typename CallBaseTy>
-class StatepointBase {
-  CallBaseTy *StatepointCall;
-
-protected:
-  explicit StatepointBase(InstructionTy *I) {
-    StatepointCall = isStatepoint(I) ? cast<CallBaseTy>(I) : nullptr;
-  }
-
-  explicit StatepointBase(CallBaseTy *Call) {
-    StatepointCall = isStatepoint(Call) ? Call : nullptr;
-  }
-
+/// Represents a gc.statepoint intrinsic call.  This extends directly from
+/// CallBase as the IntrinsicInst only supports calls and gc.statepoint is
+/// invokable.
+class GCStatepointInst : public CallBase {
 public:
-  using arg_iterator = typename CallBaseTy::const_op_iterator;
+  GCStatepointInst() = delete;
+  GCStatepointInst(const GCStatepointInst &) = delete;
+  GCStatepointInst &operator=(const GCStatepointInst &) = delete;
+
+  static bool classof(const CallBase *I) {
+    if (const Function *CF = I->getCalledFunction())
+      return CF->getIntrinsicID() == Intrinsic::experimental_gc_statepoint;
+    return false;
+  }
+
+  static bool classof(const Value *V) {
+    return isa<CallBase>(V) && classof(cast<CallBase>(V));
+  }
 
   enum {
     IDPos = 0,
@@ -95,220 +83,134 @@
     CallArgsBeginPos = 5,
   };
 
-  void *operator new(size_t, unsigned) = delete;
-  void *operator new(size_t s) = delete;
-
-  explicit operator bool() const {
-    // We do not assign non-statepoint call instructions to StatepointCall.
-    return (bool)StatepointCall;
-  }
-
-  /// Return the underlying call instruction.
-  CallBaseTy *getCall() const {
-    assert(*this && "check validity first!");
-    return StatepointCall;
-  }
-
-  uint64_t getFlags() const {
-    return cast<ConstantInt>(getCall()->getArgOperand(FlagsPos))
-        ->getZExtValue();
-  }
-
   /// Return the ID associated with this statepoint.
   uint64_t getID() const {
-    const Value *IDVal = getCall()->getArgOperand(IDPos);
-    return cast<ConstantInt>(IDVal)->getZExtValue();
+    return cast<ConstantInt>(getArgOperand(IDPos))->getZExtValue();
   }
 
   /// Return the number of patchable bytes associated with this statepoint.
   uint32_t getNumPatchBytes() const {
-    const Value *NumPatchBytesVal = getCall()->getArgOperand(NumPatchBytesPos);
+    const Value *NumPatchBytesVal = getArgOperand(NumPatchBytesPos);
     uint64_t NumPatchBytes =
       cast<ConstantInt>(NumPatchBytesVal)->getZExtValue();
     assert(isInt<32>(NumPatchBytes) && "should fit in 32 bits!");
     return NumPatchBytes;
   }
 
+  /// Number of arguments to be passed to the actual callee.
+  int getNumCallArgs() const {
+    return cast<ConstantInt>(getArgOperand(NumCallArgsPos))->getZExtValue();
+  }
+
+  uint64_t getFlags() const {
+    return cast<ConstantInt>(getArgOperand(FlagsPos))->getZExtValue();
+  }
+
   /// Return the value actually being called or invoked.
-  ValueTy *getCalledValue() const {
-    return getCall()->getArgOperand(CalledFunctionPos);
+  Value *getActualCalledOperand() const {
+    return getArgOperand(CalledFunctionPos);
   }
 
-  // FIXME: Migrate users of this to `getCall` and remove it.
-  InstructionTy *getInstruction() const { return getCall(); }
-
-  /// Return the function being called if this is a direct call, otherwise
-  /// return null (if it's an indirect call).
-  FunTy *getCalledFunction() const {
-    return dyn_cast<Function>(getCalledValue());
-  }
-
-  /// Return the caller function for this statepoint.
-  FunTy *getCaller() const { return getCall()->getCaller(); }
-
-  /// Determine if the statepoint cannot unwind.
-  bool doesNotThrow() const {
-    Function *F = getCalledFunction();
-    return getCall()->doesNotThrow() || (F ? F->doesNotThrow() : false);
+  /// Returns the function called if this is a wrapping a direct call, and null
+  /// otherwise.
+  Function *getActualCalledFunction() const {
+    return dyn_cast_or_null<Function>(getActualCalledOperand());
   }
 
   /// Return the type of the value returned by the call underlying the
   /// statepoint.
   Type *getActualReturnType() const {
-    auto *FTy = cast<FunctionType>(
-        cast<PointerType>(getCalledValue()->getType())->getElementType());
-    return FTy->getReturnType();
+    auto *CalleeTy =
+      cast<PointerType>(getActualCalledOperand()->getType())->getElementType();
+    return cast<FunctionType>(CalleeTy)->getReturnType();
   }
 
-  /// Number of arguments to be passed to the actual callee.
-  int getNumCallArgs() const {
-    const Value *NumCallArgsVal = getCall()->getArgOperand(NumCallArgsPos);
-    return cast<ConstantInt>(NumCallArgsVal)->getZExtValue();
-  }
 
-  size_t arg_size() const { return getNumCallArgs(); }
-  arg_iterator arg_begin() const {
-    assert(CallArgsBeginPos <= (int)getCall()->arg_size());
-    return getCall()->arg_begin() + CallArgsBeginPos;
+  /// Return the number of arguments to the underlying call.
+  size_t actual_arg_size() const { return getNumCallArgs(); }
+  /// Return an iterator to the begining of the arguments to the underlying call
+  const_op_iterator actual_arg_begin() const {
+    assert(CallArgsBeginPos <= (int)arg_size());
+    return arg_begin() + CallArgsBeginPos;
   }
-  arg_iterator arg_end() const {
-    auto I = arg_begin() + arg_size();
-    assert((getCall()->arg_end() - I) >= 0);
+  /// Return an end iterator of the arguments to the underlying call
+  const_op_iterator actual_arg_end() const {
+    auto I = actual_arg_begin() + actual_arg_size();
+    assert((arg_end() - I) == 2);
     return I;
   }
-
-  ValueTy *getArgument(unsigned Index) {
-    assert(Index < arg_size() && "out of bounds!");
-    return *(arg_begin() + Index);
+  /// range adapter for actual call arguments
+  iterator_range<const_op_iterator> actual_args() const {
+    return make_range(actual_arg_begin(), actual_arg_end());
   }
 
-  /// range adapter for call arguments
-  iterator_range<arg_iterator> call_args() const {
-    return make_range(arg_begin(), arg_end());
+  const_op_iterator gc_transition_args_begin() const {
+    if (auto Opt = getOperandBundle(LLVMContext::OB_gc_transition))
+      return Opt->Inputs.begin();
+    return arg_end();
   }
-
-  /// Return true if the call or the callee has the given attribute.
-  bool paramHasAttr(unsigned i, Attribute::AttrKind A) const {
-    Function *F = getCalledFunction();
-    return getCall()->paramHasAttr(i + CallArgsBeginPos, A) ||
-           (F ? F->getAttributes().hasAttribute(i, A) : false);
-  }
-
-  /// Number of GC transition args.
-  int getNumTotalGCTransitionArgs() const {
-    const Value *NumGCTransitionArgs = *arg_end();
-    return cast<ConstantInt>(NumGCTransitionArgs)->getZExtValue();
-  }
-  arg_iterator gc_transition_args_begin() const {
-    auto I = arg_end() + 1;
-    assert((getCall()->arg_end() - I) >= 0);
-    return I;
-  }
-  arg_iterator gc_transition_args_end() const {
-    auto I = gc_transition_args_begin() + getNumTotalGCTransitionArgs();
-    assert((getCall()->arg_end() - I) >= 0);
-    return I;
+  const_op_iterator gc_transition_args_end() const {
+    if (auto Opt = getOperandBundle(LLVMContext::OB_gc_transition))
+      return Opt->Inputs.end();
+    return arg_end();
   }
 
   /// range adapter for GC transition arguments
-  iterator_range<arg_iterator> gc_transition_args() const {
+  iterator_range<const_op_iterator> gc_transition_args() const {
     return make_range(gc_transition_args_begin(), gc_transition_args_end());
   }
 
-  /// Number of additional arguments excluding those intended
-  /// for garbage collection.
-  int getNumTotalVMSArgs() const {
-    const Value *NumVMSArgs = *gc_transition_args_end();
-    return cast<ConstantInt>(NumVMSArgs)->getZExtValue();
+  const_op_iterator deopt_begin() const {
+    if (auto Opt = getOperandBundle(LLVMContext::OB_deopt))
+      return Opt->Inputs.begin();
+    return arg_end();
   }
-
-  arg_iterator deopt_begin() const {
-    auto I = gc_transition_args_end() + 1;
-    assert((getCall()->arg_end() - I) >= 0);
-    return I;
-  }
-  arg_iterator deopt_end() const {
-    auto I = deopt_begin() + getNumTotalVMSArgs();
-    assert((getCall()->arg_end() - I) >= 0);
-    return I;
+  const_op_iterator deopt_end() const {
+    if (auto Opt = getOperandBundle(LLVMContext::OB_deopt))
+      return Opt->Inputs.end();
+    return arg_end();
   }
 
   /// range adapter for vm state arguments
-  iterator_range<arg_iterator> deopt_operands() const {
+  iterator_range<const_op_iterator> deopt_operands() const {
     return make_range(deopt_begin(), deopt_end());
   }
 
-  arg_iterator gc_args_begin() const { return deopt_end(); }
-  arg_iterator gc_args_end() const { return getCall()->arg_end(); }
+  /// Returns an iterator to the begining of the argument range describing gc
+  /// values for the statepoint.
+  const_op_iterator gc_args_begin() const {
+    if (auto Opt = getOperandBundle(LLVMContext::OB_gc_live))
+      return Opt->Inputs.begin();
+    return arg_end();
+  }
 
-  unsigned gcArgsStartIdx() const {
-    return gc_args_begin() - getCall()->op_begin();
+  /// Return an end iterator for the gc argument range
+  const_op_iterator gc_args_end() const {
+    if (auto Opt = getOperandBundle(LLVMContext::OB_gc_live))
+      return Opt->Inputs.end();
+    return arg_end();
   }
 
   /// range adapter for gc arguments
-  iterator_range<arg_iterator> gc_args() const {
+  iterator_range<const_op_iterator> gc_args() const {
     return make_range(gc_args_begin(), gc_args_end());
   }
 
+
   /// Get list of all gc reloactes linked to this statepoint
   /// May contain several relocations for the same base/derived pair.
   /// For example this could happen due to relocations on unwinding
   /// path of invoke.
-  std::vector<const GCRelocateInst *> getRelocates() const;
+  inline std::vector<const GCRelocateInst *> getGCRelocates() const;
 
-  /// Get the experimental_gc_result call tied to this statepoint.  Can be
-  /// nullptr if there isn't a gc_result tied to this statepoint.  Guaranteed to
-  /// be a CallInst if non-null.
+  /// Get the experimental_gc_result call tied to this statepoint if there is
+  /// one, otherwise return nullptr.
   const GCResultInst *getGCResult() const {
-    for (auto *U : getInstruction()->users())
+    for (auto *U : users())
       if (auto *GRI = dyn_cast<GCResultInst>(U))
         return GRI;
     return nullptr;
   }
-
-#ifndef NDEBUG
-  /// Asserts if this statepoint is malformed.  Common cases for failure
-  /// include incorrect length prefixes for variable length sections or
-  /// illegal values for parameters.
-  void verify() {
-    assert(getNumCallArgs() >= 0 &&
-           "number of arguments to actually callee can't be negative");
-
-    // The internal asserts in the iterator accessors do the rest.
-    (void)arg_begin();
-    (void)arg_end();
-    (void)gc_transition_args_begin();
-    (void)gc_transition_args_end();
-    (void)deopt_begin();
-    (void)deopt_end();
-    (void)gc_args_begin();
-    (void)gc_args_end();
-  }
-#endif
-};
-
-/// A specialization of it's base class for read only access
-/// to a gc.statepoint.
-class ImmutableStatepoint
-    : public StatepointBase<const Function, const Instruction, const Value,
-                            const CallBase> {
-  using Base = StatepointBase<const Function, const Instruction, const Value,
-                              const CallBase>;
-
-public:
-  explicit ImmutableStatepoint(const Instruction *I) : Base(I) {}
-  explicit ImmutableStatepoint(const CallBase *Call) : Base(Call) {}
-};
-
-/// A specialization of it's base class for read-write access
-/// to a gc.statepoint.
-class Statepoint
-    : public StatepointBase<Function, Instruction, Value, CallBase> {
-  using Base = StatepointBase<Function, Instruction, Value, CallBase>;
-
-public:
-  explicit Statepoint(Instruction *I) : Base(I) {}
-  explicit Statepoint(CallBase *Call) : Base(Call) {}
 };
 
 /// Common base class for representing values projected from a statepoint.
@@ -333,15 +235,13 @@
   }
 
   /// The statepoint with which this gc.relocate is associated.
-  const CallBase *getStatepoint() const {
+  const GCStatepointInst *getStatepoint() const {
     const Value *Token = getArgOperand(0);
 
     // This takes care both of relocates for call statepoints and relocates
     // on normal path of invoke statepoint.
-    if (!isa<LandingPadInst>(Token)) {
-      assert(isStatepoint(Token));
-      return cast<CallBase>(Token);
-    }
+    if (!isa<LandingPadInst>(Token))
+      return cast<GCStatepointInst>(Token);
 
     // This relocate is on exceptional path of an invoke statepoint
     const BasicBlock *InvokeBB =
@@ -350,9 +250,8 @@
     assert(InvokeBB && "safepoints should have unique landingpads");
     assert(InvokeBB->getTerminator() &&
            "safepoint block should be well formed");
-    assert(isStatepoint(InvokeBB->getTerminator()));
 
-    return cast<CallBase>(InvokeBB->getTerminator());
+    return cast<GCStatepointInst>(InvokeBB->getTerminator());
   }
 };
 
@@ -381,10 +280,14 @@
   }
 
   Value *getBasePtr() const {
+    if (auto Opt = getStatepoint()->getOperandBundle(LLVMContext::OB_gc_live))
+      return *(Opt->Inputs.begin() + getBasePtrIndex());
     return *(getStatepoint()->arg_begin() + getBasePtrIndex());
   }
 
   Value *getDerivedPtr() const {
+    if (auto Opt = getStatepoint()->getOperandBundle(LLVMContext::OB_gc_live))
+      return *(Opt->Inputs.begin() + getDerivedPtrIndex());
     return *(getStatepoint()->arg_begin() + getDerivedPtrIndex());
   }
 };
@@ -401,21 +304,17 @@
   }
 };
 
-template <typename FunTy, typename InstructionTy, typename ValueTy,
-          typename CallBaseTy>
-std::vector<const GCRelocateInst *>
-StatepointBase<FunTy, InstructionTy, ValueTy, CallBaseTy>::getRelocates()
-    const {
+std::vector<const GCRelocateInst *> GCStatepointInst::getGCRelocates() const {
   std::vector<const GCRelocateInst *> Result;
 
   // Search for relocated pointers.  Note that working backwards from the
   // gc_relocates ensures that we only get pairs which are actually relocated
   // and used after the statepoint.
-  for (const User *U : StatepointCall->users())
+  for (const User *U : users())
     if (auto *Relocate = dyn_cast<GCRelocateInst>(U))
       Result.push_back(Relocate);
 
-  auto *StatepointInvoke = dyn_cast<InvokeInst>(StatepointCall);
+  auto *StatepointInvoke = dyn_cast<InvokeInst>(this);
   if (!StatepointInvoke)
     return Result;
 
diff --git a/linux-x64/clang/include/llvm/IR/StructuralHash.h b/linux-x64/clang/include/llvm/IR/StructuralHash.h
new file mode 100644
index 0000000..eb63a21
--- /dev/null
+++ b/linux-x64/clang/include/llvm/IR/StructuralHash.h
@@ -0,0 +1,34 @@
+//===- llvm/IR/StructuralHash.h - IR Hash for expensive checks --*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file provides hashing of the LLVM IR structure to be used to check
+// Passes modification status.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_IR_STRUCTURALHASH_H
+#define LLVM_IR_STRUCTURALHASH_H
+
+#ifdef EXPENSIVE_CHECKS
+
+#include <cstdint>
+
+// This header is only meant to be used when -DEXPENSIVE_CHECKS is set
+namespace llvm {
+
+class Function;
+class Module;
+
+uint64_t StructuralHash(const Function &F);
+uint64_t StructuralHash(const Module &M);
+
+} // end namespace llvm
+
+#endif
+
+#endif // LLVM_IR_STRUCTURALHASH_H
diff --git a/linux-x64/clang/include/llvm/IR/SymbolTableListTraits.h b/linux-x64/clang/include/llvm/IR/SymbolTableListTraits.h
index 5b793e5..8af7123 100644
--- a/linux-x64/clang/include/llvm/IR/SymbolTableListTraits.h
+++ b/linux-x64/clang/include/llvm/IR/SymbolTableListTraits.h
@@ -76,9 +76,11 @@
   /// getListOwner - Return the object that owns this list.  If this is a list
   /// of instructions, it returns the BasicBlock that owns them.
   ItemParentClass *getListOwner() {
-    size_t Offset(size_t(&((ItemParentClass*)nullptr->*ItemParentClass::
-                           getSublistAccess(static_cast<ValueSubClass*>(nullptr)))));
-    ListTy *Anchor(static_cast<ListTy *>(this));
+    size_t Offset = reinterpret_cast<size_t>(
+        &((ItemParentClass *)nullptr->*ItemParentClass::getSublistAccess(
+                                           static_cast<ValueSubClass *>(
+                                               nullptr))));
+    ListTy *Anchor = static_cast<ListTy *>(this);
     return reinterpret_cast<ItemParentClass*>(reinterpret_cast<char*>(Anchor)-
                                               Offset);
   }
diff --git a/linux-x64/clang/include/llvm/IR/Type.h b/linux-x64/clang/include/llvm/IR/Type.h
index f2aa490..756c69d 100644
--- a/linux-x64/clang/include/llvm/IR/Type.h
+++ b/linux-x64/clang/include/llvm/IR/Type.h
@@ -21,6 +21,7 @@
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/TypeSize.h"
 #include <cassert>
 #include <cstdint>
 #include <iterator>
@@ -52,27 +53,29 @@
   /// Also update LLVMTypeKind and LLVMGetTypeKind () in the C binding.
   ///
   enum TypeID {
-    // PrimitiveTypes - make sure LastPrimitiveTyID stays up to date.
-    VoidTyID = 0,    ///<  0: type with no size
-    HalfTyID,        ///<  1: 16-bit floating point type
-    FloatTyID,       ///<  2: 32-bit floating point type
-    DoubleTyID,      ///<  3: 64-bit floating point type
-    X86_FP80TyID,    ///<  4: 80-bit floating point type (X87)
-    FP128TyID,       ///<  5: 128-bit floating point type (112-bit mantissa)
-    PPC_FP128TyID,   ///<  6: 128-bit floating point type (two 64-bits, PowerPC)
-    LabelTyID,       ///<  7: Labels
-    MetadataTyID,    ///<  8: Metadata
-    X86_MMXTyID,     ///<  9: MMX vectors (64 bits, X86 specific)
-    TokenTyID,       ///< 10: Tokens
+    // PrimitiveTypes
+    HalfTyID = 0,  ///< 16-bit floating point type
+    BFloatTyID,    ///< 16-bit floating point type (7-bit significand)
+    FloatTyID,     ///< 32-bit floating point type
+    DoubleTyID,    ///< 64-bit floating point type
+    X86_FP80TyID,  ///< 80-bit floating point type (X87)
+    FP128TyID,     ///< 128-bit floating point type (112-bit significand)
+    PPC_FP128TyID, ///< 128-bit floating point type (two 64-bits, PowerPC)
+    VoidTyID,      ///< type with no size
+    LabelTyID,     ///< Labels
+    MetadataTyID,  ///< Metadata
+    X86_MMXTyID,   ///< MMX vectors (64 bits, X86 specific)
+    X86_AMXTyID,   ///< AMX vectors (8192 bits, X86 specific)
+    TokenTyID,     ///< Tokens
 
     // Derived types... see DerivedTypes.h file.
-    // Make sure FirstDerivedTyID stays up to date!
-    IntegerTyID,     ///< 11: Arbitrary bit width integers
-    FunctionTyID,    ///< 12: Functions
-    StructTyID,      ///< 13: Structures
-    ArrayTyID,       ///< 14: Arrays
-    PointerTyID,     ///< 15: Pointers
-    VectorTyID       ///< 16: SIMD 'packed' format, or other vector type
+    IntegerTyID,       ///< Arbitrary bit width integers
+    FunctionTyID,      ///< Functions
+    PointerTyID,       ///< Pointers
+    StructTyID,        ///< Structures
+    ArrayTyID,         ///< Arrays
+    FixedVectorTyID,   ///< Fixed width SIMD vector type
+    ScalableVectorTyID ///< Scalable SIMD vector type
   };
 
 private:
@@ -109,10 +112,6 @@
   /// Float).
   Type * const *ContainedTys = nullptr;
 
-  static bool isSequentialType(TypeID TyID) {
-    return TyID == ArrayTyID || TyID == VectorTyID;
-  }
-
 public:
   /// Print the current type.
   /// Omit the type details if \p NoDetails == true.
@@ -142,6 +141,9 @@
   /// Return true if this is 'half', a 16-bit IEEE fp type.
   bool isHalfTy() const { return getTypeID() == HalfTyID; }
 
+  /// Return true if this is 'bfloat', a 16-bit bfloat type.
+  bool isBFloatTy() const { return getTypeID() == BFloatTyID; }
+
   /// Return true if this is 'float', a 32-bit IEEE fp type.
   bool isFloatTy() const { return getTypeID() == FloatTyID; }
 
@@ -159,8 +161,8 @@
 
   /// Return true if this is one of the six floating-point types
   bool isFloatingPointTy() const {
-    return getTypeID() == HalfTyID || getTypeID() == FloatTyID ||
-           getTypeID() == DoubleTyID ||
+    return getTypeID() == HalfTyID || getTypeID() == BFloatTyID ||
+           getTypeID() == FloatTyID || getTypeID() == DoubleTyID ||
            getTypeID() == X86_FP80TyID || getTypeID() == FP128TyID ||
            getTypeID() == PPC_FP128TyID;
   }
@@ -168,6 +170,7 @@
   const fltSemantics &getFltSemantics() const {
     switch (getTypeID()) {
     case HalfTyID: return APFloat::IEEEhalf();
+    case BFloatTyID: return APFloat::BFloat();
     case FloatTyID: return APFloat::IEEEsingle();
     case DoubleTyID: return APFloat::IEEEdouble();
     case X86_FP80TyID: return APFloat::x87DoubleExtended();
@@ -180,6 +183,9 @@
   /// Return true if this is X86 MMX.
   bool isX86_MMXTy() const { return getTypeID() == X86_MMXTyID; }
 
+  /// Return true if this is X86 AMX.
+  bool isX86_AMXTy() const { return getTypeID() == X86_AMXTyID; }
+
   /// Return true if this is a FP type or a vector of FP.
   bool isFPOrFPVectorTy() const { return getScalarType()->isFloatingPointTy(); }
 
@@ -226,7 +232,9 @@
   bool isPtrOrPtrVectorTy() const { return getScalarType()->isPointerTy(); }
 
   /// True if this is an instance of VectorType.
-  bool isVectorTy() const { return getTypeID() == VectorTyID; }
+  inline bool isVectorTy() const {
+    return getTypeID() == ScalableVectorTyID || getTypeID() == FixedVectorTyID;
+  }
 
   /// Return true if this type could be converted with a lossless BitCast to
   /// type 'Ty'. For example, i8* to i32*. BitCasts are valid for types of the
@@ -248,7 +256,7 @@
   /// includes all first-class types except struct and array types.
   bool isSingleValueType() const {
     return isFloatingPointTy() || isX86_MMXTy() || isIntegerTy() ||
-           isPointerTy() || isVectorTy();
+           isPointerTy() || isVectorTy() || isX86_AMXTy();
   }
 
   /// Return true if the type is an aggregate type. This means it is valid as
@@ -264,13 +272,12 @@
   bool isSized(SmallPtrSetImpl<Type*> *Visited = nullptr) const {
     // If it's a primitive, it is always sized.
     if (getTypeID() == IntegerTyID || isFloatingPointTy() ||
-        getTypeID() == PointerTyID ||
-        getTypeID() == X86_MMXTyID)
+        getTypeID() == PointerTyID || getTypeID() == X86_MMXTyID ||
+        getTypeID() == X86_AMXTyID)
       return true;
     // If it is not something that can have a size (e.g. a function or label),
     // it doesn't have a size.
-    if (getTypeID() != StructTyID && getTypeID() != ArrayTyID &&
-        getTypeID() != VectorTyID)
+    if (getTypeID() != StructTyID && getTypeID() != ArrayTyID && !isVectorTy())
       return false;
     // Otherwise we have to try harder to decide.
     return isSizedDerivedType(Visited);
@@ -281,12 +288,15 @@
   /// This will return zero if the type does not have a size or is not a
   /// primitive type.
   ///
+  /// If this is a scalable vector type, the scalable property will be set and
+  /// the runtime size will be a positive integer multiple of the base size.
+  ///
   /// Note that this may not reflect the size of memory allocated for an
   /// instance of the type or the number of bytes that are written when an
   /// instance of the type is stored to memory. The DataLayout class provides
   /// additional query functions to provide this information.
   ///
-  unsigned getPrimitiveSizeInBits() const LLVM_READONLY;
+  TypeSize getPrimitiveSizeInBits() const LLVM_READONLY;
 
   /// If this is a vector type, return the getPrimitiveSizeInBits value for the
   /// element type. Otherwise return the getPrimitiveSizeInBits value for this
@@ -300,10 +310,10 @@
 
   /// If this is a vector type, return the element type, otherwise return
   /// 'this'.
-  Type *getScalarType() const {
+  inline Type *getScalarType() const {
     if (isVectorTy())
-      return getVectorElementType();
-    return const_cast<Type*>(this);
+      return getContainedType(0);
+    return const_cast<Type *>(this);
   }
 
   //===--------------------------------------------------------------------===//
@@ -339,8 +349,8 @@
 
   //===--------------------------------------------------------------------===//
   // Helper methods corresponding to subclass methods.  This forces a cast to
-  // the specified subclass and calls its accessor.  "getVectorNumElements" (for
-  // example) is shorthand for cast<VectorType>(Ty)->getNumElements().  This is
+  // the specified subclass and calls its accessor.  "getArrayNumElements" (for
+  // example) is shorthand for cast<ArrayType>(Ty)->getNumElements().  This is
   // only intended to cover the core methods that are frequently used, helper
   // methods should not be added here.
 
@@ -354,11 +364,6 @@
   inline unsigned getStructNumElements() const;
   inline Type *getStructElementType(unsigned N) const;
 
-  inline Type *getSequentialElementType() const {
-    assert(isSequentialType(getTypeID()) && "Not a sequential type!");
-    return ContainedTys[0];
-  }
-
   inline uint64_t getArrayNumElements() const;
 
   Type *getArrayElementType() const {
@@ -366,18 +371,19 @@
     return ContainedTys[0];
   }
 
-  inline bool getVectorIsScalable() const;
-  inline unsigned getVectorNumElements() const;
-  Type *getVectorElementType() const {
-    assert(getTypeID() == VectorTyID);
-    return ContainedTys[0];
-  }
-
   Type *getPointerElementType() const {
     assert(getTypeID() == PointerTyID);
     return ContainedTys[0];
   }
 
+  /// Given an integer or vector type, change the lane bitwidth to NewBitwidth,
+  /// whilst keeping the old number of lanes.
+  inline Type *getWithNewBitWidth(unsigned NewBitWidth) const;
+
+  /// Given scalar/vector integer type, returns a type with elements twice as
+  /// wide as in the original type. For vectors, preserves element count.
+  inline Type *getExtendedType() const;
+
   /// Get the address space of this pointer or pointer vector type.
   inline unsigned getPointerAddressSpace() const;
 
@@ -395,6 +401,7 @@
   static Type *getVoidTy(LLVMContext &C);
   static Type *getLabelTy(LLVMContext &C);
   static Type *getHalfTy(LLVMContext &C);
+  static Type *getBFloatTy(LLVMContext &C);
   static Type *getFloatTy(LLVMContext &C);
   static Type *getDoubleTy(LLVMContext &C);
   static Type *getMetadataTy(LLVMContext &C);
@@ -402,6 +409,7 @@
   static Type *getFP128Ty(LLVMContext &C);
   static Type *getPPC_FP128Ty(LLVMContext &C);
   static Type *getX86_MMXTy(LLVMContext &C);
+  static Type *getX86_AMXTy(LLVMContext &C);
   static Type *getTokenTy(LLVMContext &C);
   static IntegerType *getIntNTy(LLVMContext &C, unsigned N);
   static IntegerType *getInt1Ty(LLVMContext &C);
@@ -424,18 +432,40 @@
     }
     llvm_unreachable("Unsupported type in Type::getScalarTy");
   }
+  static Type *getFloatingPointTy(LLVMContext &C, const fltSemantics &S) {
+    Type *Ty;
+    if (&S == &APFloat::IEEEhalf())
+      Ty = Type::getHalfTy(C);
+    else if (&S == &APFloat::BFloat())
+      Ty = Type::getBFloatTy(C);
+    else if (&S == &APFloat::IEEEsingle())
+      Ty = Type::getFloatTy(C);
+    else if (&S == &APFloat::IEEEdouble())
+      Ty = Type::getDoubleTy(C);
+    else if (&S == &APFloat::x87DoubleExtended())
+      Ty = Type::getX86_FP80Ty(C);
+    else if (&S == &APFloat::IEEEquad())
+      Ty = Type::getFP128Ty(C);
+    else {
+      assert(&S == &APFloat::PPCDoubleDouble() && "Unknown FP format");
+      Ty = Type::getPPC_FP128Ty(C);
+    }
+    return Ty;
+  }
 
   //===--------------------------------------------------------------------===//
   // Convenience methods for getting pointer types with one of the above builtin
   // types as pointee.
   //
   static PointerType *getHalfPtrTy(LLVMContext &C, unsigned AS = 0);
+  static PointerType *getBFloatPtrTy(LLVMContext &C, unsigned AS = 0);
   static PointerType *getFloatPtrTy(LLVMContext &C, unsigned AS = 0);
   static PointerType *getDoublePtrTy(LLVMContext &C, unsigned AS = 0);
   static PointerType *getX86_FP80PtrTy(LLVMContext &C, unsigned AS = 0);
   static PointerType *getFP128PtrTy(LLVMContext &C, unsigned AS = 0);
   static PointerType *getPPC_FP128PtrTy(LLVMContext &C, unsigned AS = 0);
   static PointerType *getX86_MMXPtrTy(LLVMContext &C, unsigned AS = 0);
+  static PointerType *getX86_AMXPtrTy(LLVMContext &C, unsigned AS = 0);
   static PointerType *getIntNPtrTy(LLVMContext &C, unsigned N, unsigned AS = 0);
   static PointerType *getInt1PtrTy(LLVMContext &C, unsigned AS = 0);
   static PointerType *getInt8PtrTy(LLVMContext &C, unsigned AS = 0);
diff --git a/linux-x64/clang/include/llvm/IR/Use.h b/linux-x64/clang/include/llvm/IR/Use.h
index 034ca2c..917db26 100644
--- a/linux-x64/clang/include/llvm/IR/Use.h
+++ b/linux-x64/clang/include/llvm/IR/Use.h
@@ -41,17 +41,6 @@
 /// all of the uses for a particular value definition. It also supports jumping
 /// directly to the used value when we arrive from the User's operands, and
 /// jumping directly to the User when we arrive from the Value's uses.
-///
-/// The pointer to the used Value is explicit, and the pointer to the User is
-/// implicit. The implicit pointer is found via a waymarking algorithm
-/// described in the programmer's manual:
-///
-///   http://www.llvm.org/docs/ProgrammersManual.html#the-waymarking-algorithm
-///
-/// This is essentially the single most memory intensive object in LLVM because
-/// of the number of uses in the system. At the same time, the constant time
-/// operations it allows are essential to many optimizations having reasonable
-/// time complexity.
 class Use {
 public:
   Use(const Use &U) = delete;
@@ -60,34 +49,6 @@
   /// that also works with less standard-compliant compilers
   void swap(Use &RHS);
 
-  /// Pointer traits for the UserRef PointerIntPair. This ensures we always
-  /// use the LSB regardless of pointer alignment on different targets.
-  struct UserRefPointerTraits {
-    static inline void *getAsVoidPointer(User *P) { return P; }
-
-    static inline User *getFromVoidPointer(void *P) {
-      return (User *)P;
-    }
-
-    enum { NumLowBitsAvailable = 1 };
-  };
-
-  // A type for the word following an array of hung-off Uses in memory, which is
-  // a pointer back to their User with the bottom bit set.
-  using UserRef = PointerIntPair<User *, 1, unsigned, UserRefPointerTraits>;
-
-  /// Pointer traits for the Prev PointerIntPair. This ensures we always use
-  /// the two LSBs regardless of pointer alignment on different targets.
-  struct PrevPointerTraits {
-    static inline void *getAsVoidPointer(Use **P) { return P; }
-
-    static inline Use **getFromVoidPointer(void *P) {
-      return (Use **)P;
-    }
-
-    enum { NumLowBitsAvailable = 2 };
-  };
-
 private:
   /// Destructor - Only for zap()
   ~Use() {
@@ -95,13 +56,12 @@
       removeFromList();
   }
 
-  enum PrevPtrTag { zeroDigitTag, oneDigitTag, stopTag, fullStopTag };
-
   /// Constructor
-  Use(PrevPtrTag tag) { Prev.setInt(tag); }
+  Use(User *Parent) : Parent(Parent) {}
 
 public:
   friend class Value;
+  friend class User;
 
   operator Value *() const { return Val; }
   Value *get() const { return Val; }
@@ -110,7 +70,7 @@
   ///
   /// For an instruction operand, for example, this will return the
   /// instruction.
-  User *getUser() const LLVM_READONLY;
+  User *getUser() const { return Parent; };
 
   inline void set(Value *Val);
 
@@ -125,38 +85,29 @@
   /// Return the operand # of this use in its User.
   unsigned getOperandNo() const;
 
-  /// Initializes the waymarking tags on an array of Uses.
-  ///
-  /// This sets up the array of Uses such that getUser() can find the User from
-  /// any of those Uses.
-  static Use *initTags(Use *Start, Use *Stop);
-
   /// Destroys Use operands when the number of operands of
   /// a User changes.
   static void zap(Use *Start, const Use *Stop, bool del = false);
 
 private:
-  const Use *getImpliedUser() const LLVM_READONLY;
 
   Value *Val = nullptr;
   Use *Next = nullptr;
-  PointerIntPair<Use **, 2, PrevPtrTag, PrevPointerTraits> Prev;
-
-  void setPrev(Use **NewPrev) { Prev.setPointer(NewPrev); }
+  Use **Prev = nullptr;
+  User *Parent = nullptr;
 
   void addToList(Use **List) {
     Next = *List;
     if (Next)
-      Next->setPrev(&Next);
-    setPrev(List);
-    *List = this;
+      Next->Prev = &Next;
+    Prev = List;
+    *Prev = this;
   }
 
   void removeFromList() {
-    Use **StrippedPrev = Prev.getPointer();
-    *StrippedPrev = Next;
+    *Prev = Next;
     if (Next)
-      Next->setPrev(StrippedPrev);
+      Next->Prev = Prev;
   }
 };
 
diff --git a/linux-x64/clang/include/llvm/IR/User.h b/linux-x64/clang/include/llvm/IR/User.h
index 19d87c5..221bb5b 100644
--- a/linux-x64/clang/include/llvm/IR/User.h
+++ b/linux-x64/clang/include/llvm/IR/User.h
@@ -45,7 +45,7 @@
   template <unsigned>
   friend struct HungoffOperandTraits;
 
-  LLVM_ATTRIBUTE_ALWAYS_INLINE inline static void *
+  LLVM_ATTRIBUTE_ALWAYS_INLINE static void *
   allocateFixedOperandUser(size_t, unsigned, unsigned);
 
 protected:
@@ -111,7 +111,7 @@
 #endif
   }
   /// Placement delete - required by std, called if the ctor throws.
-  void operator delete(void *Usr, unsigned, bool) {
+  void operator delete(void *Usr, unsigned, unsigned) {
     // Note: If a subclass manipulates the information which is required to calculate the
     // Usr memory pointer, e.g. NumUserOperands, the operator delete of that subclass has
     // to restore the changed information to the original value, since the dtor of that class
@@ -218,6 +218,11 @@
     NumUserOperands = NumOps;
   }
 
+  /// A droppable user is a user for which uses can be dropped without affecting
+  /// correctness and should be dropped rather than preventing a transformation
+  /// from happening.
+  bool isDroppable() const;
+
   // ---------------------------------------------------------------------------
   // Operand Iterator interface...
   //
diff --git a/linux-x64/clang/include/llvm/IR/VPIntrinsics.def b/linux-x64/clang/include/llvm/IR/VPIntrinsics.def
new file mode 100644
index 0000000..981548c
--- /dev/null
+++ b/linux-x64/clang/include/llvm/IR/VPIntrinsics.def
@@ -0,0 +1,156 @@
+//===-- IR/VPIntrinsics.def - Describes llvm.vp.* Intrinsics -*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains descriptions of the various Vector Predication intrinsics.
+// This is used as a central place for enumerating the different instructions
+// and should eventually be the place to put comments about the instructions.
+//
+//===----------------------------------------------------------------------===//
+
+// NOTE: NO INCLUDE GUARD DESIRED!
+
+// Provide definitions of macros so that users of this file do not have to
+// define everything to use it...
+//
+// Register a VP intrinsic and begin its property scope.
+// All VP intrinsic scopes are top level, ie it is illegal to place a
+// BEGIN_REGISTER_VP_INTRINSIC within a VP intrinsic scope.
+// \p VPID     The VP intrinsic id.
+// \p MASKPOS  The mask operand position.
+// \p EVLPOS   The explicit vector length operand position.
+#ifndef BEGIN_REGISTER_VP_INTRINSIC
+#define BEGIN_REGISTER_VP_INTRINSIC(VPID, MASKPOS, EVLPOS)
+#endif
+
+// End the property scope of a VP intrinsic.
+#ifndef END_REGISTER_VP_INTRINSIC
+#define END_REGISTER_VP_INTRINSIC(VPID)
+#endif
+
+// Register a new VP SDNode and begin its property scope.
+// When the SDNode scope is nested within a VP intrinsic scope, it is implicitly registered as the canonical SDNode for this VP intrinsic.
+// There is one VP intrinsic that maps directly to one SDNode that goes by the
+// same name.  Since the operands are also the same, we open the property
+// scopes for both the VPIntrinsic and the SDNode at once.
+// \p SDOPC     The SelectionDAG Node id (eg VP_ADD).
+// \p LEGALPOS The operand position of the SDNode that is used for legalizing
+//             this SDNode. This can be `-1`, in which case the return type of
+//             the SDNode is used.
+// \p TDNAME   The name of the TableGen definition of this SDNode.
+// \p MASKPOS  The mask operand position.
+// \p EVLPOS   The explicit vector length operand position.
+#ifndef BEGIN_REGISTER_VP_SDNODE
+#define BEGIN_REGISTER_VP_SDNODE(SDOPC, LEGALPOS, TDNAME, MASKPOS, EVLPOS)
+#endif
+
+// End the property scope of a new VP SDNode.
+#ifndef END_REGISTER_VP_SDNODE
+#define END_REGISTER_VP_SDNODE(SDOPC)
+#endif
+
+// Helper macros for the common "1:1 - Intrinsic : SDNode" case.
+//
+// There is one VP intrinsic that maps directly to one SDNode that goes by the
+// same name.  Since the operands are also the same, we open the property
+// scopes for both the VPIntrinsic and the SDNode at once.
+//
+// \p INTRIN   The canonical name (eg `vp_add`, which at the same time is the
+//             name of the intrinsic and the TableGen def of the SDNode).
+// \p MASKPOS  The mask operand position.
+// \p EVLPOS   The explicit vector length operand position.
+// \p SDOPC    The SelectionDAG Node id (eg VP_ADD).
+// \p LEGALPOS The operand position of the SDNode that is used for legalizing
+//             this SDNode. This can be `-1`, in which case the return type of
+//             the SDNode is used.
+#define BEGIN_REGISTER_VP(INTRIN, MASKPOS, EVLPOS, SDOPC, LEGALPOS) \
+BEGIN_REGISTER_VP_INTRINSIC(INTRIN, MASKPOS, EVLPOS) \
+BEGIN_REGISTER_VP_SDNODE(SDOPC, LEGALPOS, INTRIN, MASKPOS, EVLPOS)
+
+#define END_REGISTER_VP(INTRIN, SDOPC) \
+END_REGISTER_VP_INTRINSIC(INTRIN) \
+END_REGISTER_VP_SDNODE(SDOPC)
+
+
+// The following macros attach properties to the scope they are placed in. This
+// assigns the property to the VP Intrinsic and/or SDNode that belongs to the
+// scope.
+//
+// Property Macros {
+
+// The intrinsic and/or SDNode has the same function as this LLVM IR Opcode.
+// \p OPC  The standard IR opcode.
+#ifndef HANDLE_VP_TO_OPC
+#define HANDLE_VP_TO_OPC(OPC)
+#endif
+
+/// } Property Macros
+
+///// Integer Arithmetic {
+
+// Specialized helper macro for integer binary operators (%x, %y, %mask, %evl).
+#ifdef HELPER_REGISTER_BINARY_INT_VP
+#error "The internal helper macro HELPER_REGISTER_BINARY_INT_VP is already defined!"
+#endif
+#define HELPER_REGISTER_BINARY_INT_VP(INTRIN, SDOPC, OPC) \
+BEGIN_REGISTER_VP(INTRIN, 2, 3, SDOPC, -1) \
+HANDLE_VP_TO_OPC(OPC) \
+END_REGISTER_VP(INTRIN, SDOPC)
+
+
+
+// llvm.vp.add(x,y,mask,vlen)
+HELPER_REGISTER_BINARY_INT_VP(vp_add, VP_ADD, Add)
+
+// llvm.vp.and(x,y,mask,vlen)
+HELPER_REGISTER_BINARY_INT_VP(vp_and, VP_AND, And)
+
+// llvm.vp.ashr(x,y,mask,vlen)
+HELPER_REGISTER_BINARY_INT_VP(vp_ashr, VP_ASHR, AShr)
+
+// llvm.vp.lshr(x,y,mask,vlen)
+HELPER_REGISTER_BINARY_INT_VP(vp_lshr, VP_LSHR, LShr)
+
+// llvm.vp.mul(x,y,mask,vlen)
+HELPER_REGISTER_BINARY_INT_VP(vp_mul, VP_MUL, Mul)
+
+// llvm.vp.or(x,y,mask,vlen)
+HELPER_REGISTER_BINARY_INT_VP(vp_or, VP_OR, Or)
+
+// llvm.vp.sdiv(x,y,mask,vlen)
+HELPER_REGISTER_BINARY_INT_VP(vp_sdiv, VP_SDIV, SDiv)
+
+// llvm.vp.shl(x,y,mask,vlen)
+HELPER_REGISTER_BINARY_INT_VP(vp_shl, VP_SHL, Shl)
+
+// llvm.vp.srem(x,y,mask,vlen)
+HELPER_REGISTER_BINARY_INT_VP(vp_srem, VP_SREM, SRem)
+
+// llvm.vp.sub(x,y,mask,vlen)
+HELPER_REGISTER_BINARY_INT_VP(vp_sub, VP_SUB, Sub)
+
+// llvm.vp.udiv(x,y,mask,vlen)
+HELPER_REGISTER_BINARY_INT_VP(vp_udiv, VP_UDIV, UDiv)
+
+// llvm.vp.urem(x,y,mask,vlen)
+HELPER_REGISTER_BINARY_INT_VP(vp_urem, VP_UREM, URem)
+
+// llvm.vp.xor(x,y,mask,vlen)
+HELPER_REGISTER_BINARY_INT_VP(vp_xor, VP_XOR, Xor)
+
+#undef HELPER_REGISTER_BINARY_INT_VP
+
+///// } Integer Arithmetic
+
+
+#undef BEGIN_REGISTER_VP
+#undef BEGIN_REGISTER_VP_INTRINSIC
+#undef BEGIN_REGISTER_VP_SDNODE
+#undef END_REGISTER_VP
+#undef END_REGISTER_VP_INTRINSIC
+#undef END_REGISTER_VP_SDNODE
+#undef HANDLE_VP_TO_OPC
diff --git a/linux-x64/clang/include/llvm/IR/Value.def b/linux-x64/clang/include/llvm/IR/Value.def
index aaf1651..0a0125d 100644
--- a/linux-x64/clang/include/llvm/IR/Value.def
+++ b/linux-x64/clang/include/llvm/IR/Value.def
@@ -23,6 +23,11 @@
 #error "Missing macro definition of HANDLE_VALUE*"
 #endif
 
+// If the LLVM_C_API macro is set, then values handled via HANDLE_*_EXCLUDE_LLVM_C_API will not be expanded in areas the HANDLE_* macro is used. If it is not set, then HANDLE_*_EXCLUDE_LLVM_C_API values are handled normally as their HANDLE_* counterparts.
+#ifndef LLVM_C_API
+#define LLVM_C_API 0
+#endif
+
 #ifndef HANDLE_MEMORY_VALUE
 #define HANDLE_MEMORY_VALUE(ValueName) HANDLE_VALUE(ValueName)
 #endif
@@ -55,6 +60,15 @@
 #define HANDLE_CONSTANT_MARKER(MarkerName, ValueName)
 #endif
 
+#ifndef HANDLE_CONSTANT_EXCLUDE_LLVM_C_API
+#define HANDLE_CONSTANT_EXCLUDE_LLVM_C_API(ValueName) HANDLE_CONSTANT(ValueName)
+#endif
+
+#if LLVM_C_API
+#undef HANDLE_CONSTANT_EXCLUDE_LLVM_C_API
+#define HANDLE_CONSTANT_EXCLUDE_LLVM_C_API(ValueName)
+#endif
+
 // Having constant first makes the range check for isa<Constant> faster
 // and smaller by one operation.
 
@@ -65,6 +79,7 @@
 HANDLE_GLOBAL_VALUE(GlobalVariable)
 HANDLE_CONSTANT(BlockAddress)
 HANDLE_CONSTANT(ConstantExpr)
+HANDLE_CONSTANT_EXCLUDE_LLVM_C_API(DSOLocalEquivalent)
 
 // ConstantAggregate.
 HANDLE_CONSTANT(ConstantArray)
@@ -73,6 +88,7 @@
 
 // ConstantData.
 HANDLE_CONSTANT(UndefValue)
+HANDLE_CONSTANT(PoisonValue)
 HANDLE_CONSTANT(ConstantAggregateZero)
 HANDLE_CONSTANT(ConstantDataArray)
 HANDLE_CONSTANT(ConstantDataVector)
@@ -114,3 +130,5 @@
 #undef HANDLE_INLINE_ASM_VALUE
 #undef HANDLE_VALUE
 #undef HANDLE_CONSTANT_MARKER
+#undef HANDLE_CONSTANT_EXCLUDE_LLVM_C_API
+#undef LLVM_C_API
diff --git a/linux-x64/clang/include/llvm/IR/Value.h b/linux-x64/clang/include/llvm/IR/Value.h
index 3f8caa6..e84840a 100644
--- a/linux-x64/clang/include/llvm/IR/Value.h
+++ b/linux-x64/clang/include/llvm/IR/Value.h
@@ -14,8 +14,11 @@
 #define LLVM_IR_VALUE_H
 
 #include "llvm-c/Types.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/IR/Use.h"
+#include "llvm/Support/Alignment.h"
 #include "llvm/Support/CBindingWrapping.h"
 #include "llvm/Support/Casting.h"
 #include <cassert>
@@ -41,11 +44,11 @@
 class InlineAsm;
 class Instruction;
 class LLVMContext;
+class MDNode;
 class Module;
 class ModuleSlotTracker;
 class raw_ostream;
 template<typename ValueTy> class StringMapEntry;
-class StringRef;
 class Twine;
 class Type;
 class User;
@@ -70,8 +73,6 @@
 /// objects that watch it and listen to RAUW and Destroy events.  See
 /// llvm/IR/ValueHandle.h for details.
 class Value {
-  // The least-significant bit of the first word of Value *must* be zero:
-  //   http://www.llvm.org/docs/ProgrammersManual.html#the-waymarking-algorithm
   Type *VTy;
   Use *UseList;
 
@@ -110,12 +111,13 @@
   ///
   /// Note, this should *NOT* be used directly by any class other than User.
   /// User uses this value to find the Use list.
-  enum : unsigned { NumUserOperandsBits = 28 };
+  enum : unsigned { NumUserOperandsBits = 27 };
   unsigned NumUserOperands : NumUserOperandsBits;
 
   // Use the same type as the bitfield above so that MSVC will pack them.
   unsigned IsUsedByMD : 1;
   unsigned HasName : 1;
+  unsigned HasMetadata : 1; // Has metadata attached to this?
   unsigned HasHungOffUses : 1;
   unsigned HasDescriptor : 1;
 
@@ -279,6 +281,10 @@
   /// \note It is an error to call V->takeName(V).
   void takeName(Value *V);
 
+#ifndef NDEBUG
+  std::string getNameOrAsOperand() const;
+#endif
+
   /// Change all uses of this to point to a new Value.
   ///
   /// Go through the uses list for this definition and make each use point to
@@ -292,10 +298,29 @@
   /// "V" instead of "this". This function skips metadata entries in the list.
   void replaceNonMetadataUsesWith(Value *V);
 
+  /// Go through the uses list for this definition and make each use point
+  /// to "V" if the callback ShouldReplace returns true for the given Use.
+  /// Unlike replaceAllUsesWith() this function does not support basic block
+  /// values or constant users.
+  void replaceUsesWithIf(Value *New,
+                         llvm::function_ref<bool(Use &U)> ShouldReplace) {
+    assert(New && "Value::replaceUsesWithIf(<null>) is invalid!");
+    assert(New->getType() == getType() &&
+           "replaceUses of value with new value of different type!");
+
+    for (use_iterator UI = use_begin(), E = use_end(); UI != E;) {
+      Use &U = *UI;
+      ++UI;
+      if (!ShouldReplace(U))
+        continue;
+      U.set(New);
+    }
+  }
+
   /// replaceUsesOutsideBlock - Go through the uses list for this definition and
   /// make each use point to "V" instead of "this" when the use is outside the
   /// block. 'This's use list is expected to have at least one element.
-  /// Unlike replaceAllUsesWith this function does not support basic block
+  /// Unlike replaceAllUsesWith() this function does not support basic block
   /// values or constant users.
   void replaceUsesOutsideBlock(Value *V, BasicBlock *BB);
 
@@ -405,7 +430,7 @@
     return materialized_users();
   }
 
-  /// Return true if there is exactly one user of this value.
+  /// Return true if there is exactly one use of this value.
   ///
   /// This is specialized because it is a common request and does not require
   /// traversing the whole use list.
@@ -415,14 +440,58 @@
     return ++I == E;
   }
 
-  /// Return true if this Value has exactly N users.
+  /// Return true if this Value has exactly N uses.
   bool hasNUses(unsigned N) const;
 
-  /// Return true if this value has N users or more.
+  /// Return true if this value has N uses or more.
   ///
   /// This is logically equivalent to getNumUses() >= N.
   bool hasNUsesOrMore(unsigned N) const;
 
+  /// Return true if there is exactly one user of this value.
+  ///
+  /// Note that this is not the same as "has one use". If a value has one use,
+  /// then there certainly is a single user. But if value has several uses,
+  /// it is possible that all uses are in a single user, or not.
+  ///
+  /// This check is potentially costly, since it requires traversing,
+  /// in the worst case, the whole use list of a value.
+  bool hasOneUser() const;
+
+  /// Return true if there is exactly one use of this value that cannot be
+  /// dropped.
+  ///
+  /// This is specialized because it is a common request and does not require
+  /// traversing the whole use list.
+  Use *getSingleUndroppableUse();
+
+  /// Return true if there this value.
+  ///
+  /// This is specialized because it is a common request and does not require
+  /// traversing the whole use list.
+  bool hasNUndroppableUses(unsigned N) const;
+
+  /// Return true if this value has N uses or more.
+  ///
+  /// This is logically equivalent to getNumUses() >= N.
+  bool hasNUndroppableUsesOrMore(unsigned N) const;
+
+  /// Remove every uses that can safely be removed.
+  ///
+  /// This will remove for example uses in llvm.assume.
+  /// This should be used when performing want to perform a tranformation but
+  /// some Droppable uses pervent it.
+  /// This function optionally takes a filter to only remove some droppable
+  /// uses.
+  void dropDroppableUses(llvm::function_ref<bool(const Use *)> ShouldDrop =
+                             [](const Use *) { return true; });
+
+  /// Remove every use of this value in \p User that can safely be removed.
+  void dropDroppableUsesIn(User &Usr);
+
+  /// Remove the droppable use \p U.
+  static void dropDroppableUse(Use &U);
+
   /// Check if this value is used in the specified basic block.
   bool isUsedInBasicBlock(const BasicBlock *BB) const;
 
@@ -487,23 +556,95 @@
   /// Return true if there is metadata referencing this value.
   bool isUsedByMetadata() const { return IsUsedByMD; }
 
+protected:
+  /// Get the current metadata attachments for the given kind, if any.
+  ///
+  /// These functions require that the value have at most a single attachment
+  /// of the given kind, and return \c nullptr if such an attachment is missing.
+  /// @{
+  MDNode *getMetadata(unsigned KindID) const;
+  MDNode *getMetadata(StringRef Kind) const;
+  /// @}
+
+  /// Appends all attachments with the given ID to \c MDs in insertion order.
+  /// If the Value has no attachments with the given ID, or if ID is invalid,
+  /// leaves MDs unchanged.
+  /// @{
+  void getMetadata(unsigned KindID, SmallVectorImpl<MDNode *> &MDs) const;
+  void getMetadata(StringRef Kind, SmallVectorImpl<MDNode *> &MDs) const;
+  /// @}
+
+  /// Appends all metadata attached to this value to \c MDs, sorting by
+  /// KindID. The first element of each pair returned is the KindID, the second
+  /// element is the metadata value. Attachments with the same ID appear in
+  /// insertion order.
+  void
+  getAllMetadata(SmallVectorImpl<std::pair<unsigned, MDNode *>> &MDs) const;
+
+  /// Return true if this value has any metadata attached to it.
+  bool hasMetadata() const { return (bool)HasMetadata; }
+
+  /// Return true if this value has the given type of metadata attached.
+  /// @{
+  bool hasMetadata(unsigned KindID) const {
+    return getMetadata(KindID) != nullptr;
+  }
+  bool hasMetadata(StringRef Kind) const {
+    return getMetadata(Kind) != nullptr;
+  }
+  /// @}
+
+  /// Set a particular kind of metadata attachment.
+  ///
+  /// Sets the given attachment to \c MD, erasing it if \c MD is \c nullptr or
+  /// replacing it if it already exists.
+  /// @{
+  void setMetadata(unsigned KindID, MDNode *Node);
+  void setMetadata(StringRef Kind, MDNode *Node);
+  /// @}
+
+  /// Add a metadata attachment.
+  /// @{
+  void addMetadata(unsigned KindID, MDNode &MD);
+  void addMetadata(StringRef Kind, MDNode &MD);
+  /// @}
+
+  /// Erase all metadata attachments with the given kind.
+  ///
+  /// \returns true if any metadata was removed.
+  bool eraseMetadata(unsigned KindID);
+
+  /// Erase all metadata attached to this Value.
+  void clearMetadata();
+
+public:
   /// Return true if this value is a swifterror value.
   ///
   /// swifterror values can be either a function argument or an alloca with a
   /// swifterror attribute.
   bool isSwiftError() const;
 
-  /// Strip off pointer casts, all-zero GEPs, address space casts, and aliases.
+  /// Strip off pointer casts, all-zero GEPs and address space casts.
   ///
   /// Returns the original uncasted value.  If this is called on a non-pointer
   /// value, it returns 'this'.
   const Value *stripPointerCasts() const;
   Value *stripPointerCasts() {
     return const_cast<Value *>(
-                         static_cast<const Value *>(this)->stripPointerCasts());
+        static_cast<const Value *>(this)->stripPointerCasts());
   }
 
-  /// Strip off pointer casts, all-zero GEPs, address space casts, and aliases
+  /// Strip off pointer casts, all-zero GEPs, address space casts, and aliases.
+  ///
+  /// Returns the original uncasted value.  If this is called on a non-pointer
+  /// value, it returns 'this'.
+  const Value *stripPointerCastsAndAliases() const;
+  Value *stripPointerCastsAndAliases() {
+    return const_cast<Value *>(
+        static_cast<const Value *>(this)->stripPointerCastsAndAliases());
+  }
+
+  /// Strip off pointer casts, all-zero GEPs and address space casts
   /// but ensures the representation of the result stays the same.
   ///
   /// Returns the original uncasted value with the same representation. If this
@@ -514,26 +655,15 @@
                                    ->stripPointerCastsSameRepresentation());
   }
 
-  /// Strip off pointer casts, all-zero GEPs, aliases and invariant group
-  /// info.
+  /// Strip off pointer casts, all-zero GEPs and invariant group info.
   ///
   /// Returns the original uncasted value.  If this is called on a non-pointer
   /// value, it returns 'this'. This function should be used only in
   /// Alias analysis.
   const Value *stripPointerCastsAndInvariantGroups() const;
   Value *stripPointerCastsAndInvariantGroups() {
-    return const_cast<Value *>(
-        static_cast<const Value *>(this)->stripPointerCastsAndInvariantGroups());
-  }
-
-  /// Strip off pointer casts and all-zero GEPs.
-  ///
-  /// Returns the original uncasted value.  If this is called on a non-pointer
-  /// value, it returns 'this'.
-  const Value *stripPointerCastsNoFollowAliases() const;
-  Value *stripPointerCastsNoFollowAliases() {
-    return const_cast<Value *>(
-          static_cast<const Value *>(this)->stripPointerCastsNoFollowAliases());
+    return const_cast<Value *>(static_cast<const Value *>(this)
+                                   ->stripPointerCastsAndInvariantGroups());
   }
 
   /// Strip off pointer casts and all-constant inbounds GEPs.
@@ -546,29 +676,66 @@
               static_cast<const Value *>(this)->stripInBoundsConstantOffsets());
   }
 
-  /// Accumulate offsets from \a stripInBoundsConstantOffsets().
+  /// Accumulate the constant offset this value has compared to a base pointer.
+  /// Only 'getelementptr' instructions (GEPs) are accumulated but other
+  /// instructions, e.g., casts, are stripped away as well.
+  /// The accumulated constant offset is added to \p Offset and the base
+  /// pointer is returned.
   ///
-  /// Stores the resulting constant offset stripped into the APInt provided.
-  /// The provided APInt will be extended or truncated as needed to be the
-  /// correct bitwidth for an offset of this pointer type.
+  /// The APInt \p Offset has to have a bit-width equal to the IntPtr type for
+  /// the address space of 'this' pointer value, e.g., use
+  /// DataLayout::getIndexTypeSizeInBits(Ty).
   ///
-  /// If this is called on a non-pointer value, it returns 'this'.
+  /// If \p AllowNonInbounds is true, offsets in GEPs are stripped and
+  /// accumulated even if the GEP is not "inbounds".
+  ///
+  /// If \p ExternalAnalysis is provided it will be used to calculate a offset
+  /// when a operand of GEP is not constant.
+  /// For example, for a value \p ExternalAnalysis might try to calculate a
+  /// lower bound. If \p ExternalAnalysis is successful, it should return true.
+  ///
+  /// If this is called on a non-pointer value, it returns 'this' and the
+  /// \p Offset is not modified.
+  ///
+  /// Note that this function will never return a nullptr. It will also never
+  /// manipulate the \p Offset in a way that would not match the difference
+  /// between the underlying value and the returned one. Thus, if no constant
+  /// offset was found, the returned value is the underlying one and \p Offset
+  /// is unchanged.
+  const Value *stripAndAccumulateConstantOffsets(
+      const DataLayout &DL, APInt &Offset, bool AllowNonInbounds,
+      function_ref<bool(Value &Value, APInt &Offset)> ExternalAnalysis =
+          nullptr) const;
+  Value *stripAndAccumulateConstantOffsets(const DataLayout &DL, APInt &Offset,
+                                           bool AllowNonInbounds) {
+    return const_cast<Value *>(
+        static_cast<const Value *>(this)->stripAndAccumulateConstantOffsets(
+            DL, Offset, AllowNonInbounds));
+  }
+
+  /// This is a wrapper around stripAndAccumulateConstantOffsets with the
+  /// in-bounds requirement set to false.
   const Value *stripAndAccumulateInBoundsConstantOffsets(const DataLayout &DL,
-                                                         APInt &Offset) const;
+                                                         APInt &Offset) const {
+    return stripAndAccumulateConstantOffsets(DL, Offset,
+                                             /* AllowNonInbounds */ false);
+  }
   Value *stripAndAccumulateInBoundsConstantOffsets(const DataLayout &DL,
                                                    APInt &Offset) {
-    return const_cast<Value *>(static_cast<const Value *>(this)
-        ->stripAndAccumulateInBoundsConstantOffsets(DL, Offset));
+    return stripAndAccumulateConstantOffsets(DL, Offset,
+                                             /* AllowNonInbounds */ false);
   }
 
   /// Strip off pointer casts and inbounds GEPs.
   ///
   /// Returns the original pointer value.  If this is called on a non-pointer
   /// value, it returns 'this'.
-  const Value *stripInBoundsOffsets() const;
-  Value *stripInBoundsOffsets() {
+  const Value *stripInBoundsOffsets(function_ref<void(const Value *)> Func =
+                                        [](const Value *) {}) const;
+  inline Value *stripInBoundsOffsets(function_ref<void(const Value *)> Func =
+                                  [](const Value *) {}) {
     return const_cast<Value *>(
-                      static_cast<const Value *>(this)->stripInBoundsOffsets());
+        static_cast<const Value *>(this)->stripInBoundsOffsets(Func));
   }
 
   /// Returns the number of bytes known to be dereferenceable for the
@@ -583,7 +750,7 @@
   ///
   /// Returns an alignment which is either specified explicitly, e.g. via
   /// align attribute of a function argument, or guaranteed by DataLayout.
-  unsigned getPointerAlignment(const DataLayout &DL) const;
+  Align getPointerAlignment(const DataLayout &DL) const;
 
   /// Translate PHI node to its predecessor from the given basic block.
   ///
@@ -756,7 +923,7 @@
 
   // Fix the Prev pointers.
   for (Use *I = UseList, **Prev = &UseList; I; I = I->Next) {
-    I->setPrev(Prev);
+    I->Prev = Prev;
     Prev = &I->Next;
   }
 }
diff --git a/linux-x64/clang/include/llvm/IR/ValueHandle.h b/linux-x64/clang/include/llvm/IR/ValueHandle.h
index 1135d79..a88b28a 100644
--- a/linux-x64/clang/include/llvm/IR/ValueHandle.h
+++ b/linux-x64/clang/include/llvm/IR/ValueHandle.h
@@ -89,7 +89,11 @@
   }
 
   Value *operator->() const { return getValPtr(); }
-  Value &operator*() const { return *getValPtr(); }
+  Value &operator*() const {
+    Value *V = getValPtr();
+    assert(V && "Dereferencing deleted ValueHandle");
+    return *V;
+  }
 
 protected:
   Value *getValPtr() const { return Val; }
@@ -171,6 +175,25 @@
   static SimpleType getSimplifiedValue(const WeakVH &WVH) { return WVH; }
 };
 
+// Specialize DenseMapInfo to allow WeakVH to participate in DenseMap.
+template <> struct DenseMapInfo<WeakVH> {
+  static inline WeakVH getEmptyKey() {
+    return WeakVH(DenseMapInfo<Value *>::getEmptyKey());
+  }
+
+  static inline WeakVH getTombstoneKey() {
+    return WeakVH(DenseMapInfo<Value *>::getTombstoneKey());
+  }
+
+  static unsigned getHashValue(const WeakVH &Val) {
+    return DenseMapInfo<Value *>::getHashValue(Val);
+  }
+
+  static bool isEqual(const WeakVH &LHS, const WeakVH &RHS) {
+    return DenseMapInfo<Value *>::isEqual(LHS, RHS);
+  }
+};
+
 /// Value handle that is nullable, but tries to track the Value.
 ///
 /// This is a value handle that tries hard to point to a Value, even across
@@ -235,13 +258,13 @@
 /// class turns into a trivial wrapper around a pointer.
 template <typename ValueTy>
 class AssertingVH
-#ifndef NDEBUG
-  : public ValueHandleBase
+#if LLVM_ENABLE_ABI_BREAKING_CHECKS
+    : public ValueHandleBase
 #endif
-  {
+{
   friend struct DenseMapInfo<AssertingVH<ValueTy>>;
 
-#ifndef NDEBUG
+#if LLVM_ENABLE_ABI_BREAKING_CHECKS
   Value *getRawValPtr() const { return ValueHandleBase::getValPtr(); }
   void setRawValPtr(Value *P) { ValueHandleBase::operator=(P); }
 #else
@@ -257,13 +280,14 @@
   void setValPtr(ValueTy *P) { setRawValPtr(GetAsValue(P)); }
 
 public:
-#ifndef NDEBUG
+#if LLVM_ENABLE_ABI_BREAKING_CHECKS
   AssertingVH() : ValueHandleBase(Assert) {}
   AssertingVH(ValueTy *P) : ValueHandleBase(Assert, GetAsValue(P)) {}
   AssertingVH(const AssertingVH &RHS) : ValueHandleBase(Assert, RHS) {}
 #else
   AssertingVH() : ThePtr(nullptr) {}
   AssertingVH(ValueTy *P) : ThePtr(GetAsValue(P)) {}
+  AssertingVH(const AssertingVH<ValueTy> &) = default;
 #endif
 
   operator ValueTy*() const {
@@ -283,30 +307,10 @@
   ValueTy &operator*() const { return *getValPtr(); }
 };
 
-// Specialize DenseMapInfo to allow AssertingVH to participate in DenseMap.
+// Treat AssertingVH<T> like T* inside maps. This also allows using find_as()
+// to look up a value without constructing a value handle.
 template<typename T>
-struct DenseMapInfo<AssertingVH<T>> {
-  static inline AssertingVH<T> getEmptyKey() {
-    AssertingVH<T> Res;
-    Res.setRawValPtr(DenseMapInfo<Value *>::getEmptyKey());
-    return Res;
-  }
-
-  static inline AssertingVH<T> getTombstoneKey() {
-    AssertingVH<T> Res;
-    Res.setRawValPtr(DenseMapInfo<Value *>::getTombstoneKey());
-    return Res;
-  }
-
-  static unsigned getHashValue(const AssertingVH<T> &Val) {
-    return DenseMapInfo<Value *>::getHashValue(Val.getRawValPtr());
-  }
-
-  static bool isEqual(const AssertingVH<T> &LHS, const AssertingVH<T> &RHS) {
-    return DenseMapInfo<Value *>::isEqual(LHS.getRawValPtr(),
-                                          RHS.getRawValPtr());
-  }
-};
+struct DenseMapInfo<AssertingVH<T>> : DenseMapInfo<T *> {};
 
 /// Value handle that tracks a Value across RAUW.
 ///
@@ -390,6 +394,7 @@
 public:
   CallbackVH() : ValueHandleBase(Callback) {}
   CallbackVH(Value *P) : ValueHandleBase(Callback, P) {}
+  CallbackVH(const Value *P) : CallbackVH(const_cast<Value *>(P)) {}
 
   operator Value*() const {
     return getValPtr();
@@ -438,7 +443,7 @@
 /// class turns into a trivial wrapper around a pointer.
 template <typename ValueTy>
 class PoisoningVH
-#ifndef NDEBUG
+#if LLVM_ENABLE_ABI_BREAKING_CHECKS
     final : public CallbackVH
 #endif
 {
@@ -448,7 +453,7 @@
   static Value *GetAsValue(Value *V) { return V; }
   static Value *GetAsValue(const Value *V) { return const_cast<Value *>(V); }
 
-#ifndef NDEBUG
+#if LLVM_ENABLE_ABI_BREAKING_CHECKS
   /// A flag tracking whether this value has been poisoned.
   ///
   /// On delete and RAUW, we leave the value pointer alone so that as a raw
@@ -473,7 +478,7 @@
     Poisoned = true;
     RemoveFromUseList();
   }
-#else // NDEBUG
+#else // LLVM_ENABLE_ABI_BREAKING_CHECKS
   Value *ThePtr = nullptr;
 
   Value *getRawValPtr() const { return ThePtr; }
@@ -481,14 +486,16 @@
 #endif
 
   ValueTy *getValPtr() const {
+#if LLVM_ENABLE_ABI_BREAKING_CHECKS
     assert(!Poisoned && "Accessed a poisoned value handle!");
+#endif
     return static_cast<ValueTy *>(getRawValPtr());
   }
   void setValPtr(ValueTy *P) { setRawValPtr(GetAsValue(P)); }
 
 public:
   PoisoningVH() = default;
-#ifndef NDEBUG
+#if LLVM_ENABLE_ABI_BREAKING_CHECKS
   PoisoningVH(ValueTy *P) : CallbackVH(GetAsValue(P)) {}
   PoisoningVH(const PoisoningVH &RHS)
       : CallbackVH(RHS), Poisoned(RHS.Poisoned) {}
@@ -537,6 +544,17 @@
     return DenseMapInfo<Value *>::isEqual(LHS.getRawValPtr(),
                                           RHS.getRawValPtr());
   }
+
+  // Allow lookup by T* via find_as(), without constructing a temporary
+  // value handle.
+
+  static unsigned getHashValue(const T *Val) {
+    return DenseMapInfo<Value *>::getHashValue(Val);
+  }
+
+  static bool isEqual(const T *LHS, const PoisoningVH<T> &RHS) {
+    return DenseMapInfo<Value *>::isEqual(LHS, RHS.getRawValPtr());
+  }
 };
 
 } // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/IR/ValueMap.h b/linux-x64/clang/include/llvm/IR/ValueMap.h
index 6a79b1d..a5a06b7 100644
--- a/linux-x64/clang/include/llvm/IR/ValueMap.h
+++ b/linux-x64/clang/include/llvm/IR/ValueMap.h
@@ -33,11 +33,11 @@
 #include "llvm/IR/ValueHandle.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Mutex.h"
-#include "llvm/Support/UniqueLock.h"
 #include <algorithm>
 #include <cassert>
 #include <cstddef>
 #include <iterator>
+#include <mutex>
 #include <type_traits>
 #include <utility>
 
@@ -93,7 +93,6 @@
   MapT Map;
   Optional<MDMapT> MDMap;
   ExtraData Data;
-  bool MayMapMetadata = true;
 
 public:
   using key_type = KeyT;
@@ -120,10 +119,6 @@
   }
   Optional<MDMapT> &getMDMap() { return MDMap; }
 
-  bool mayMapMetadata() const { return MayMapMetadata; }
-  void enableMapMetadata() { MayMapMetadata = true; }
-  void disableMapMetadata() { MayMapMetadata = false; }
-
   /// Get the mapped metadata, if it's in the map.
   Optional<Metadata *> getMappedMD(const Metadata *MD) const {
     if (!MDMap)
@@ -248,7 +243,7 @@
   friend struct DenseMapInfo<ValueMapCallbackVH>;
 
   using ValueMapT = ValueMap<KeyT, ValueT, Config>;
-  using KeySansPointerT = typename std::remove_pointer<KeyT>::type;
+  using KeySansPointerT = std::remove_pointer_t<KeyT>;
 
   ValueMapT *Map;
 
@@ -266,9 +261,9 @@
     // Make a copy that won't get changed even when *this is destroyed.
     ValueMapCallbackVH Copy(*this);
     typename Config::mutex_type *M = Config::getMutex(Copy.Map->Data);
-    unique_lock<typename Config::mutex_type> Guard;
+    std::unique_lock<typename Config::mutex_type> Guard;
     if (M)
-      Guard = unique_lock<typename Config::mutex_type>(*M);
+      Guard = std::unique_lock<typename Config::mutex_type>(*M);
     Config::onDelete(Copy.Map->Data, Copy.Unwrap());  // May destroy *this.
     Copy.Map->Map.erase(Copy);  // Definitely destroys *this.
   }
@@ -279,9 +274,9 @@
     // Make a copy that won't get changed even when *this is destroyed.
     ValueMapCallbackVH Copy(*this);
     typename Config::mutex_type *M = Config::getMutex(Copy.Map->Data);
-    unique_lock<typename Config::mutex_type> Guard;
+    std::unique_lock<typename Config::mutex_type> Guard;
     if (M)
-      Guard = unique_lock<typename Config::mutex_type>(*M);
+      Guard = std::unique_lock<typename Config::mutex_type>(*M);
 
     KeyT typed_new_key = cast<KeySansPointerT>(new_key);
     // Can destroy *this:
diff --git a/linux-x64/clang/include/llvm/IR/Verifier.h b/linux-x64/clang/include/llvm/IR/Verifier.h
index 62c33c8..f4381d2 100644
--- a/linux-x64/clang/include/llvm/IR/Verifier.h
+++ b/linux-x64/clang/include/llvm/IR/Verifier.h
@@ -116,6 +116,7 @@
 
   Result run(Module &M, ModuleAnalysisManager &);
   Result run(Function &F, FunctionAnalysisManager &);
+  static bool isRequired() { return true; }
 };
 
 /// Check a module for errors, but report debug info errors separately.
@@ -141,6 +142,7 @@
 
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static bool isRequired() { return true; }
 };
 
 } // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/IRReader/IRReader.h b/linux-x64/clang/include/llvm/IRReader/IRReader.h
index 0517130..a14e46e 100644
--- a/linux-x64/clang/include/llvm/IRReader/IRReader.h
+++ b/linux-x64/clang/include/llvm/IRReader/IRReader.h
@@ -14,18 +14,21 @@
 #ifndef LLVM_IRREADER_IRREADER_H
 #define LLVM_IRREADER_IRREADER_H
 
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include <memory>
 
 namespace llvm {
 
-class StringRef;
 class MemoryBuffer;
 class MemoryBufferRef;
 class Module;
 class SMDiagnostic;
 class LLVMContext;
 
+typedef llvm::function_ref<Optional<std::string>(StringRef)>
+    DataLayoutCallbackTy;
+
 /// If the given MemoryBuffer holds a bitcode image, return a Module
 /// for it which does lazy deserialization of function bodies.  Otherwise,
 /// attempt to parse it as LLVM Assembly and return a fully populated
@@ -48,26 +51,18 @@
 /// If the given MemoryBuffer holds a bitcode image, return a Module
 /// for it.  Otherwise, attempt to parse it as LLVM Assembly and return
 /// a Module for it.
-/// \param UpgradeDebugInfo Run UpgradeDebugInfo, which runs the Verifier.
-///                         This option should only be set to false by llvm-as
-///                         for use inside the LLVM testuite!
-/// \param DataLayoutString Override datalayout in the llvm assembly.
-std::unique_ptr<Module> parseIR(MemoryBufferRef Buffer, SMDiagnostic &Err,
-                                LLVMContext &Context,
-                                bool UpgradeDebugInfo = true,
-                                StringRef DataLayoutString = "");
+/// \param DataLayoutCallback Override datalayout in the llvm assembly.
+std::unique_ptr<Module> parseIR(
+    MemoryBufferRef Buffer, SMDiagnostic &Err, LLVMContext &Context,
+    DataLayoutCallbackTy DataLayoutCallback = [](StringRef) { return None; });
 
 /// If the given file holds a bitcode image, return a Module for it.
 /// Otherwise, attempt to parse it as LLVM Assembly and return a Module
 /// for it.
-/// \param UpgradeDebugInfo Run UpgradeDebugInfo, which runs the Verifier.
-///                         This option should only be set to false by llvm-as
-///                         for use inside the LLVM testuite!
-/// \param DataLayoutString Override datalayout in the llvm assembly.
-std::unique_ptr<Module> parseIRFile(StringRef Filename, SMDiagnostic &Err,
-                                    LLVMContext &Context,
-                                    bool UpgradeDebugInfo = true,
-                                    StringRef DataLayoutString = "");
+/// \param DataLayoutCallback Override datalayout in the llvm assembly.
+std::unique_ptr<Module> parseIRFile(
+    StringRef Filename, SMDiagnostic &Err, LLVMContext &Context,
+    DataLayoutCallbackTy DataLayoutCallback = [](StringRef) { return None; });
 }
 
 #endif
diff --git a/linux-x64/clang/include/llvm/InitializePasses.h b/linux-x64/clang/include/llvm/InitializePasses.h
index 164d0be..4f89179 100644
--- a/linux-x64/clang/include/llvm/InitializePasses.h
+++ b/linux-x64/clang/include/llvm/InitializePasses.h
@@ -71,14 +71,21 @@
 void initializeAliasSetPrinterPass(PassRegistry&);
 void initializeAlignmentFromAssumptionsPass(PassRegistry&);
 void initializeAlwaysInlinerLegacyPassPass(PassRegistry&);
+void initializeAssumeSimplifyPassLegacyPassPass(PassRegistry &);
+void initializeAssumeBuilderPassLegacyPassPass(PassRegistry &);
+void initializeAnnotation2MetadataLegacyPass(PassRegistry &);
+void initializeAnnotationRemarksLegacyPass(PassRegistry &);
+void initializeOpenMPOptLegacyPassPass(PassRegistry &);
 void initializeArgPromotionPass(PassRegistry&);
 void initializeAssumptionCacheTrackerPass(PassRegistry&);
 void initializeAtomicExpandPass(PassRegistry&);
 void initializeAttributorLegacyPassPass(PassRegistry&);
+void initializeAttributorCGSCCLegacyPassPass(PassRegistry &);
+void initializeBasicBlockSectionsPass(PassRegistry &);
 void initializeBDCELegacyPassPass(PassRegistry&);
 void initializeBarrierNoopPass(PassRegistry&);
 void initializeBasicAAWrapperPassPass(PassRegistry&);
-void initializeBlockExtractorPass(PassRegistry &);
+void initializeBlockExtractorLegacyPassPass(PassRegistry &);
 void initializeBlockFrequencyInfoWrapperPassPass(PassRegistry&);
 void initializeBoundsCheckingLegacyPassPass(PassRegistry&);
 void initializeBranchFolderPassPass(PassRegistry&);
@@ -87,24 +94,29 @@
 void initializeBreakCriticalEdgesPass(PassRegistry&);
 void initializeBreakFalseDepsPass(PassRegistry&);
 void initializeCanonicalizeAliasesLegacyPassPass(PassRegistry &);
+void initializeCanonicalizeFreezeInLoopsPass(PassRegistry &);
 void initializeCFGOnlyPrinterLegacyPassPass(PassRegistry&);
 void initializeCFGOnlyViewerLegacyPassPass(PassRegistry&);
 void initializeCFGPrinterLegacyPassPass(PassRegistry&);
 void initializeCFGSimplifyPassPass(PassRegistry&);
+void initializeCFGuardPass(PassRegistry&);
+void initializeCFGuardLongjmpPass(PassRegistry&);
 void initializeCFGViewerLegacyPassPass(PassRegistry&);
 void initializeCFIInstrInserterPass(PassRegistry&);
 void initializeCFLAndersAAWrapperPassPass(PassRegistry&);
 void initializeCFLSteensAAWrapperPassPass(PassRegistry&);
+void initializeCGProfileLegacyPassPass(PassRegistry &);
 void initializeCallGraphDOTPrinterPass(PassRegistry&);
 void initializeCallGraphPrinterLegacyPassPass(PassRegistry&);
 void initializeCallGraphViewerPass(PassRegistry&);
 void initializeCallGraphWrapperPassPass(PassRegistry&);
 void initializeCallSiteSplittingLegacyPassPass(PassRegistry&);
 void initializeCalledValuePropagationLegacyPassPass(PassRegistry &);
+void initializeCheckDebugMachineModulePass(PassRegistry &);
 void initializeCodeGenPreparePass(PassRegistry&);
 void initializeConstantHoistingLegacyPassPass(PassRegistry&);
 void initializeConstantMergeLegacyPassPass(PassRegistry&);
-void initializeConstantPropagationPass(PassRegistry&);
+void initializeConstraintEliminationPass(PassRegistry &);
 void initializeControlHeightReductionLegacyPassPass(PassRegistry&);
 void initializeCorrelatedValuePropagationPass(PassRegistry&);
 void initializeCostModelAnalysisPass(PassRegistry&);
@@ -113,9 +125,9 @@
 void initializeDAHPass(PassRegistry&);
 void initializeDCELegacyPassPass(PassRegistry&);
 void initializeDSELegacyPassPass(PassRegistry&);
-void initializeDataFlowSanitizerPass(PassRegistry&);
-void initializeDeadInstEliminationPass(PassRegistry&);
+void initializeDataFlowSanitizerLegacyPassPass(PassRegistry &);
 void initializeDeadMachineInstructionElimPass(PassRegistry&);
+void initializeDebugifyMachineModulePass(PassRegistry &);
 void initializeDelinearizationPass(PassRegistry&);
 void initializeDemandedBitsWrapperPassPass(PassRegistry&);
 void initializeDependenceAnalysisPass(PassRegistry&);
@@ -128,10 +140,11 @@
 void initializeDomViewerPass(PassRegistry&);
 void initializeDominanceFrontierWrapperPassPass(PassRegistry&);
 void initializeDominatorTreeWrapperPassPass(PassRegistry&);
-void initializeDwarfEHPreparePass(PassRegistry&);
+void initializeDwarfEHPrepareLegacyPassPass(PassRegistry &);
 void initializeEarlyCSELegacyPassPass(PassRegistry&);
 void initializeEarlyCSEMemSSALegacyPassPass(PassRegistry&);
 void initializeEarlyIfConverterPass(PassRegistry&);
+void initializeEarlyIfPredicatorPass(PassRegistry &);
 void initializeEarlyMachineLICMPass(PassRegistry&);
 void initializeEarlyTailDuplicatePass(PassRegistry&);
 void initializeEdgeBundlesPass(PassRegistry&);
@@ -145,6 +158,8 @@
 void initializeFEntryInserterPass(PassRegistry&);
 void initializeFinalizeISelPass(PassRegistry&);
 void initializeFinalizeMachineBundlesPass(PassRegistry&);
+void initializeFixIrreduciblePass(PassRegistry &);
+void initializeFixupStatepointCallerSavedPass(PassRegistry&);
 void initializeFlattenCFGPassPass(PassRegistry&);
 void initializeFloat2IntLegacyPassPass(PassRegistry&);
 void initializeForceFunctionAttrsLegacyPassPass(PassRegistry&);
@@ -164,21 +179,25 @@
 void initializeGlobalsAAWrapperPassPass(PassRegistry&);
 void initializeGuardWideningLegacyPassPass(PassRegistry&);
 void initializeHardwareLoopsPass(PassRegistry&);
+void initializeMemProfilerLegacyPassPass(PassRegistry &);
 void initializeHotColdSplittingLegacyPassPass(PassRegistry&);
 void initializeHWAddressSanitizerLegacyPassPass(PassRegistry &);
-void initializeIPCPPass(PassRegistry&);
 void initializeIPSCCPLegacyPassPass(PassRegistry&);
 void initializeIRCELegacyPassPass(PassRegistry&);
+void initializeIROutlinerLegacyPassPass(PassRegistry&);
+void initializeIRSimilarityIdentifierWrapperPassPass(PassRegistry&);
 void initializeIRTranslatorPass(PassRegistry&);
 void initializeIVUsersWrapperPassPass(PassRegistry&);
 void initializeIfConverterPass(PassRegistry&);
+void initializeImmutableModuleSummaryIndexWrapperPassPass(PassRegistry&);
 void initializeImplicitNullChecksPass(PassRegistry&);
 void initializeIndVarSimplifyLegacyPassPass(PassRegistry&);
 void initializeIndirectBrExpandPassPass(PassRegistry&);
 void initializeInferAddressSpacesPass(PassRegistry&);
 void initializeInferFunctionAttrsLegacyPassPass(PassRegistry&);
+void initializeInjectTLIMappingsLegacyPass(PassRegistry &);
 void initializeInlineCostAnalysisPass(PassRegistry&);
-void initializeInstCountPass(PassRegistry&);
+void initializeInstCountLegacyPassPass(PassRegistry &);
 void initializeInstNamerPass(PassRegistry&);
 void initializeInstSimplifyLegacyPassPass(PassRegistry &);
 void initializeInstrProfilingLegacyPassPass(PassRegistry&);
@@ -202,8 +221,9 @@
 void initializeLegacyLoopSinkPassPass(PassRegistry&);
 void initializeLegalizerPass(PassRegistry&);
 void initializeGISelCSEAnalysisWrapperPassPass(PassRegistry &);
+void initializeGISelKnownBitsAnalysisPass(PassRegistry &);
 void initializeLibCallsShrinkWrapLegacyPassPass(PassRegistry&);
-void initializeLintPass(PassRegistry&);
+void initializeLintLegacyPassPass(PassRegistry &);
 void initializeLiveDebugValuesPass(PassRegistry&);
 void initializeLiveDebugVariablesPass(PassRegistry&);
 void initializeLiveIntervalsPass(PassRegistry&);
@@ -219,17 +239,18 @@
 void initializeLoopDataPrefetchLegacyPassPass(PassRegistry&);
 void initializeLoopDeletionLegacyPassPass(PassRegistry&);
 void initializeLoopDistributeLegacyPass(PassRegistry&);
-void initializeLoopExtractorPass(PassRegistry&);
+void initializeLoopExtractorLegacyPassPass(PassRegistry &);
 void initializeLoopGuardWideningLegacyPassPass(PassRegistry&);
 void initializeLoopFuseLegacyPass(PassRegistry&);
 void initializeLoopIdiomRecognizeLegacyPassPass(PassRegistry&);
 void initializeLoopInfoWrapperPassPass(PassRegistry&);
 void initializeLoopInstSimplifyLegacyPassPass(PassRegistry&);
-void initializeLoopInterchangePass(PassRegistry&);
+void initializeLoopInterchangeLegacyPassPass(PassRegistry &);
+void initializeLoopFlattenLegacyPassPass(PassRegistry&);
 void initializeLoopLoadEliminationPass(PassRegistry&);
 void initializeLoopPassPass(PassRegistry&);
 void initializeLoopPredicationLegacyPassPass(PassRegistry&);
-void initializeLoopRerollPass(PassRegistry&);
+void initializeLoopRerollLegacyPassPass(PassRegistry &);
 void initializeLoopRotateLegacyPassPass(PassRegistry&);
 void initializeLoopSimplifyCFGLegacyPassPass(PassRegistry&);
 void initializeLoopSimplifyPass(PassRegistry&);
@@ -238,18 +259,22 @@
 void initializeLoopUnrollPass(PassRegistry&);
 void initializeLoopUnswitchPass(PassRegistry&);
 void initializeLoopVectorizePass(PassRegistry&);
-void initializeLoopVersioningLICMPass(PassRegistry&);
-void initializeLoopVersioningPassPass(PassRegistry&);
+void initializeLoopVersioningLICMLegacyPassPass(PassRegistry &);
+void initializeLoopVersioningLegacyPassPass(PassRegistry &);
 void initializeLowerAtomicLegacyPassPass(PassRegistry&);
+void initializeLowerConstantIntrinsicsPass(PassRegistry&);
 void initializeLowerEmuTLSPass(PassRegistry&);
 void initializeLowerExpectIntrinsicPass(PassRegistry&);
 void initializeLowerGuardIntrinsicLegacyPassPass(PassRegistry&);
 void initializeLowerWidenableConditionLegacyPassPass(PassRegistry&);
 void initializeLowerIntrinsicsPass(PassRegistry&);
 void initializeLowerInvokeLegacyPassPass(PassRegistry&);
-void initializeLowerSwitchPass(PassRegistry&);
+void initializeLowerSwitchLegacyPassPass(PassRegistry &);
 void initializeLowerTypeTestsPass(PassRegistry&);
+void initializeLowerMatrixIntrinsicsLegacyPassPass(PassRegistry &);
+void initializeLowerMatrixIntrinsicsMinimalLegacyPassPass(PassRegistry &);
 void initializeMIRCanonicalizerPass(PassRegistry &);
+void initializeMIRNamerPass(PassRegistry &);
 void initializeMIRPrintingPassPass(PassRegistry&);
 void initializeMachineBlockFrequencyInfoPass(PassRegistry&);
 void initializeMachineBlockPlacementPass(PassRegistry&);
@@ -261,9 +286,10 @@
 void initializeMachineDominanceFrontierPass(PassRegistry&);
 void initializeMachineDominatorTreePass(PassRegistry&);
 void initializeMachineFunctionPrinterPassPass(PassRegistry&);
+void initializeMachineFunctionSplitterPass(PassRegistry &);
 void initializeMachineLICMPass(PassRegistry&);
 void initializeMachineLoopInfoPass(PassRegistry&);
-void initializeMachineModuleInfoPass(PassRegistry&);
+void initializeMachineModuleInfoWrapperPassPass(PassRegistry &);
 void initializeMachineOptimizationRemarkEmitterPassPass(PassRegistry&);
 void initializeMachineOutlinerPass(PassRegistry&);
 void initializeMachinePipelinerPass(PassRegistry&);
@@ -280,21 +306,25 @@
 void initializeMemorySSAPrinterLegacyPassPass(PassRegistry&);
 void initializeMemorySSAWrapperPassPass(PassRegistry&);
 void initializeMemorySanitizerLegacyPassPass(PassRegistry&);
-void initializeMergeFunctionsPass(PassRegistry&);
+void initializeMergeFunctionsLegacyPassPass(PassRegistry&);
 void initializeMergeICmpsLegacyPassPass(PassRegistry &);
 void initializeMergedLoadStoreMotionLegacyPassPass(PassRegistry&);
 void initializeMetaRenamerPass(PassRegistry&);
-void initializeModuleDebugInfoPrinterPass(PassRegistry&);
+void initializeModuleDebugInfoLegacyPrinterPass(PassRegistry &);
+void initializeModuleMemProfilerLegacyPassPass(PassRegistry &);
 void initializeModuleSummaryIndexWrapperPassPass(PassRegistry&);
+void initializeModuloScheduleTestPass(PassRegistry&);
 void initializeMustExecutePrinterPass(PassRegistry&);
+void initializeMustBeExecutedContextPrinterPass(PassRegistry&);
 void initializeNameAnonGlobalLegacyPassPass(PassRegistry&);
+void initializeUniqueInternalLinkageNamesLegacyPassPass(PassRegistry &);
 void initializeNaryReassociateLegacyPassPass(PassRegistry&);
 void initializeNewGVNLegacyPassPass(PassRegistry&);
 void initializeObjCARCAAWrapperPassPass(PassRegistry&);
 void initializeObjCARCAPElimPass(PassRegistry&);
-void initializeObjCARCContractPass(PassRegistry&);
+void initializeObjCARCContractLegacyPassPass(PassRegistry &);
 void initializeObjCARCExpandPass(PassRegistry&);
-void initializeObjCARCOptPass(PassRegistry&);
+void initializeObjCARCOptLegacyPassPass(PassRegistry &);
 void initializeOptimizationRemarkEmitterWrapperPassPass(PassRegistry&);
 void initializeOptimizePHIsPass(PassRegistry&);
 void initializePAEvalPass(PassRegistry&);
@@ -326,7 +356,6 @@
 void initializePostRASchedulerPass(PassRegistry&);
 void initializePreISelIntrinsicLoweringLegacyPassPass(PassRegistry&);
 void initializePredicateInfoPrinterLegacyPassPass(PassRegistry&);
-void initializePrintBasicBlockPassPass(PassRegistry&);
 void initializePrintFunctionPassWrapperPass(PassRegistry&);
 void initializePrintModulePassWrapperPass(PassRegistry&);
 void initializeProcessImplicitDefsPass(PassRegistry&);
@@ -334,12 +363,14 @@
 void initializePromoteLegacyPassPass(PassRegistry&);
 void initializePruneEHPass(PassRegistry&);
 void initializeRABasicPass(PassRegistry&);
+void initializePseudoProbeInserterPass(PassRegistry &);
 void initializeRAGreedyPass(PassRegistry&);
 void initializeReachingDefAnalysisPass(PassRegistry&);
 void initializeReassociateLegacyPassPass(PassRegistry&);
+void initializeRedundantDbgInstEliminationPass(PassRegistry&);
 void initializeRegAllocFastPass(PassRegistry&);
 void initializeRegBankSelectPass(PassRegistry&);
-void initializeRegToMemPass(PassRegistry&);
+void initializeRegToMemLegacyPass(PassRegistry&);
 void initializeRegUsageInfoCollectorPass(PassRegistry&);
 void initializeRegUsageInfoPropagationPass(PassRegistry&);
 void initializeRegionInfoPassPass(PassRegistry&);
@@ -360,13 +391,13 @@
 void initializeSafeStackLegacyPassPass(PassRegistry&);
 void initializeSafepointIRVerifierPass(PassRegistry&);
 void initializeSampleProfileLoaderLegacyPassPass(PassRegistry&);
-void initializeSanitizerCoverageModulePass(PassRegistry&);
+void initializeModuleSanitizerCoverageLegacyPassPass(PassRegistry &);
 void initializeScalarEvolutionWrapperPassPass(PassRegistry&);
-void initializeScalarizeMaskedMemIntrinPass(PassRegistry&);
+void initializeScalarizeMaskedMemIntrinLegacyPassPass(PassRegistry &);
 void initializeScalarizerLegacyPassPass(PassRegistry&);
 void initializeScavengerTestPass(PassRegistry&);
 void initializeScopedNoAliasAAWrapperPassPass(PassRegistry&);
-void initializeSeparateConstOffsetFromGEPPass(PassRegistry&);
+void initializeSeparateConstOffsetFromGEPLegacyPassPass(PassRegistry &);
 void initializeShadowStackGCLoweringPass(PassRegistry&);
 void initializeShrinkWrapPass(PassRegistry&);
 void initializeSimpleInlinerPass(PassRegistry&);
@@ -383,15 +414,16 @@
 void initializeStackSafetyGlobalInfoWrapperPassPass(PassRegistry &);
 void initializeStackSafetyInfoWrapperPassPass(PassRegistry &);
 void initializeStackSlotColoringPass(PassRegistry&);
-void initializeStraightLineStrengthReducePass(PassRegistry&);
+void initializeStraightLineStrengthReduceLegacyPassPass(PassRegistry &);
 void initializeStripDeadDebugInfoPass(PassRegistry&);
 void initializeStripDeadPrototypesLegacyPassPass(PassRegistry&);
 void initializeStripDebugDeclarePass(PassRegistry&);
-void initializeStripGCRelocatesPass(PassRegistry&);
+void initializeStripDebugMachineModulePass(PassRegistry &);
+void initializeStripGCRelocatesLegacyPass(PassRegistry &);
 void initializeStripNonDebugSymbolsPass(PassRegistry&);
-void initializeStripNonLineTableDebugInfoPass(PassRegistry&);
+void initializeStripNonLineTableDebugLegacyPassPass(PassRegistry &);
 void initializeStripSymbolsPass(PassRegistry&);
-void initializeStructurizeCFGPass(PassRegistry&);
+void initializeStructurizeCFGLegacyPassPass(PassRegistry &);
 void initializeTailCallElimPass(PassRegistry&);
 void initializeTailDuplicatePass(PassRegistry&);
 void initializeTargetLibraryInfoWrapperPassPass(PassRegistry&);
@@ -400,10 +432,13 @@
 void initializeThreadSanitizerLegacyPassPass(PassRegistry&);
 void initializeTwoAddressInstructionPassPass(PassRegistry&);
 void initializeTypeBasedAAWrapperPassPass(PassRegistry&);
-void initializeUnifyFunctionExitNodesPass(PassRegistry&);
+void initializeTypePromotionPass(PassRegistry&);
+void initializeUnifyFunctionExitNodesLegacyPassPass(PassRegistry &);
+void initializeUnifyLoopExitsLegacyPassPass(PassRegistry &);
 void initializeUnpackMachineBundlesPass(PassRegistry&);
 void initializeUnreachableBlockElimLegacyPassPass(PassRegistry&);
 void initializeUnreachableMachineBlockElimPass(PassRegistry&);
+void initializeVectorCombineLegacyPassPass(PassRegistry&);
 void initializeVerifierLegacyPassPass(PassRegistry&);
 void initializeVirtRegMapPass(PassRegistry&);
 void initializeVirtRegRewriterPass(PassRegistry&);
diff --git a/linux-x64/clang/include/llvm/InterfaceStub/ELFObjHandler.h b/linux-x64/clang/include/llvm/InterfaceStub/ELFObjHandler.h
new file mode 100644
index 0000000..4ec158c
--- /dev/null
+++ b/linux-x64/clang/include/llvm/InterfaceStub/ELFObjHandler.h
@@ -0,0 +1,47 @@
+//===- ELFObjHandler.h ------------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===-----------------------------------------------------------------------===/
+///
+/// This supports reading and writing of elf dynamic shared objects.
+///
+//===-----------------------------------------------------------------------===/
+
+#ifndef LLVM_TOOLS_ELFABI_ELFOBJHANDLER_H
+#define LLVM_TOOLS_ELFABI_ELFOBJHANDLER_H
+
+#include "llvm/InterfaceStub/ELFStub.h"
+#include "llvm/Object/ELFObjectFile.h"
+#include "llvm/Object/ELFTypes.h"
+#include "llvm/Support/FileSystem.h"
+
+namespace llvm {
+
+class MemoryBuffer;
+
+namespace elfabi {
+
+enum class ELFTarget { ELF32LE, ELF32BE, ELF64LE, ELF64BE };
+
+/// Attempt to read a binary ELF file from a MemoryBuffer.
+Expected<std::unique_ptr<ELFStub>> readELFFile(MemoryBufferRef Buf);
+
+/// Attempt to write a binary ELF stub.
+/// This function determines appropriate ELFType using the passed ELFTarget and
+/// then writes a binary ELF stub to a specified file path.
+///
+/// @param FilePath File path for writing the ELF binary.
+/// @param Stub Source ELFStub to generate a binary ELF stub from.
+/// @param OutputFormat Target ELFType to write binary as.
+/// @param WriteIfChanged Whether or not to preserve timestamp if
+///        the output stays the same.
+Error writeBinaryStub(StringRef FilePath, const ELFStub &Stub,
+                      ELFTarget OutputFormat, bool WriteIfChanged = false);
+
+} // end namespace elfabi
+} // end namespace llvm
+
+#endif // LLVM_TOOLS_ELFABI_ELFOBJHANDLER_H
diff --git a/linux-x64/clang/include/llvm/TextAPI/ELF/ELFStub.h b/linux-x64/clang/include/llvm/InterfaceStub/ELFStub.h
similarity index 92%
rename from linux-x64/clang/include/llvm/TextAPI/ELF/ELFStub.h
rename to linux-x64/clang/include/llvm/InterfaceStub/ELFStub.h
index 76b2af1..7832c1c 100644
--- a/linux-x64/clang/include/llvm/TextAPI/ELF/ELFStub.h
+++ b/linux-x64/clang/include/llvm/InterfaceStub/ELFStub.h
@@ -16,8 +16,8 @@
 
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/Support/VersionTuple.h"
-#include <vector>
 #include <set>
+#include <vector>
 
 namespace llvm {
 namespace elfabi {
@@ -42,15 +42,13 @@
   bool Undefined;
   bool Weak;
   Optional<std::string> Warning;
-  bool operator<(const ELFSymbol &RHS) const {
-    return Name < RHS.Name;
-  }
+  bool operator<(const ELFSymbol &RHS) const { return Name < RHS.Name; }
 };
 
 // A cumulative representation of ELF stubs.
 // Both textual and binary stubs will read into and write from this object.
 class ELFStub {
-// TODO: Add support for symbol versioning.
+  // TODO: Add support for symbol versioning.
 public:
   VersionTuple TbeVersion;
   Optional<std::string> SoName;
diff --git a/linux-x64/clang/include/llvm/TextAPI/ELF/TBEHandler.h b/linux-x64/clang/include/llvm/InterfaceStub/TBEHandler.h
similarity index 98%
rename from linux-x64/clang/include/llvm/TextAPI/ELF/TBEHandler.h
rename to linux-x64/clang/include/llvm/InterfaceStub/TBEHandler.h
index 1748fd1..5c523eb 100644
--- a/linux-x64/clang/include/llvm/TextAPI/ELF/TBEHandler.h
+++ b/linux-x64/clang/include/llvm/InterfaceStub/TBEHandler.h
@@ -15,8 +15,8 @@
 #ifndef LLVM_TEXTAPI_ELF_TBEHANDLER_H
 #define LLVM_TEXTAPI_ELF_TBEHANDLER_H
 
-#include "llvm/Support/VersionTuple.h"
 #include "llvm/Support/Error.h"
+#include "llvm/Support/VersionTuple.h"
 #include <memory>
 
 namespace llvm {
@@ -24,7 +24,6 @@
 class raw_ostream;
 class Error;
 class StringRef;
-class VersionTuple;
 
 namespace elfabi {
 
diff --git a/linux-x64/clang/include/llvm/LTO/Config.h b/linux-x64/clang/include/llvm/LTO/Config.h
index fb107e3..1a7595d 100644
--- a/linux-x64/clang/include/llvm/LTO/Config.h
+++ b/linux-x64/clang/include/llvm/LTO/Config.h
@@ -1,4 +1,4 @@
-//===-Config.h - LLVM Link Time Optimizer Configuration -------------------===//
+//===-Config.h - LLVM Link Time Optimizer Configuration ---------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -14,9 +14,13 @@
 #ifndef LLVM_LTO_CONFIG_H
 #define LLVM_LTO_CONFIG_H
 
+#include "llvm/ADT/DenseSet.h"
+#include "llvm/Config/llvm-config.h"
 #include "llvm/IR/DiagnosticInfo.h"
+#include "llvm/IR/GlobalValue.h"
+#include "llvm/IR/LLVMContext.h"
+#include "llvm/Passes/PassBuilder.h"
 #include "llvm/Support/CodeGen.h"
-#include "llvm/Target/TargetMachine.h"
 #include "llvm/Target/TargetOptions.h"
 
 #include <functional>
@@ -38,15 +42,16 @@
   std::string CPU;
   TargetOptions Options;
   std::vector<std::string> MAttrs;
+  std::vector<std::string> PassPlugins;
   Optional<Reloc::Model> RelocModel = Reloc::PIC_;
   Optional<CodeModel::Model> CodeModel = None;
   CodeGenOpt::Level CGOptLevel = CodeGenOpt::Default;
-  TargetMachine::CodeGenFileType CGFileType = TargetMachine::CGFT_ObjectFile;
+  CodeGenFileType CGFileType = CGFT_ObjectFile;
   unsigned OptLevel = 2;
   bool DisableVerify = false;
 
   /// Use the new pass manager
-  bool UseNewPM = false;
+  bool UseNewPM = LLVM_ENABLE_NEW_PASS_MANAGER;
 
   /// Flag to indicate that the optimizer should not assume builtins are present
   /// on the target.
@@ -58,6 +63,15 @@
   /// Run PGO context sensitive IR instrumentation.
   bool RunCSIRInstr = false;
 
+  /// Asserts whether we can assume whole program visibility during the LTO
+  /// link.
+  bool HasWholeProgramVisibility = false;
+
+  /// Always emit a Regular LTO object even when it is empty because no Regular
+  /// LTO modules were linked. This option is useful for some build system which
+  /// want to know a priori all possible output files.
+  bool AlwaysEmitRegularLTOObj = false;
+
   /// If this field is set, the set of passes run in the middle-end optimizer
   /// will be the one specified by the string. Only works with the new pass
   /// manager as the old one doesn't have this ability.
@@ -100,16 +114,31 @@
   std::string SplitDwarfOutput;
 
   /// Optimization remarks file path.
-  std::string RemarksFilename = "";
+  std::string RemarksFilename;
 
   /// Optimization remarks pass filter.
-  std::string RemarksPasses = "";
+  std::string RemarksPasses;
 
   /// Whether to emit optimization remarks with hotness informations.
   bool RemarksWithHotness = false;
 
+  /// The minimum hotness value a diagnostic needs in order to be included in
+  /// optimization diagnostics.
+  ///
+  /// The threshold is an Optional value, which maps to one of the 3 states:
+  /// 1. 0            => threshold disabled. All emarks will be printed.
+  /// 2. positive int => manual threshold by user. Remarks with hotness exceed
+  ///                    threshold will be printed.
+  /// 3. None         => 'auto' threshold by user. The actual value is not
+  ///                    available at command line, but will be synced with
+  ///                    hotness threhold from profile summary during
+  ///                    compilation.
+  ///
+  /// If threshold option is not specified, it is disabled by default.
+  llvm::Optional<uint64_t> RemarksHotnessThreshold = 0;
+
   /// The format used for serializing remarks (default: YAML).
-  std::string RemarksFormat = "";
+  std::string RemarksFormat;
 
   /// Whether to emit the pass manager debuggging informations.
   bool DebugPassManager = false;
@@ -117,6 +146,15 @@
   /// Statistics output file path.
   std::string StatsFile;
 
+  /// Specific thinLTO modules to compile.
+  std::vector<std::string> ThinLTOModulesToCompile;
+
+  /// Time trace enabled.
+  bool TimeTraceEnabled = false;
+
+  /// Time trace granularity.
+  unsigned TimeTraceGranularity = 500;
+
   bool ShouldDiscardValueNames = true;
   DiagnosticHandlerFunction DiagHandler;
 
@@ -126,6 +164,9 @@
   /// with llvm-lto2.
   std::unique_ptr<raw_ostream> ResolutionFile;
 
+  /// Tunable parameters for passes in the default pipelines.
+  PipelineTuningOptions PTO;
+
   /// The following callbacks deal with tasks, which normally represent the
   /// entire optimization and code generation pipeline for what will become a
   /// single native object file. Each task has a unique identifier between 0 and
@@ -183,8 +224,9 @@
   ///
   /// It is called regardless of whether the backend is in-process, although it
   /// is not called from individual backend processes.
-  using CombinedIndexHookFn =
-      std::function<bool(const ModuleSummaryIndex &Index)>;
+  using CombinedIndexHookFn = std::function<bool(
+      const ModuleSummaryIndex &Index,
+      const DenseSet<GlobalValue::GUID> &GUIDPreservedSymbols)>;
   CombinedIndexHookFn CombinedIndexHook;
 
   /// This is a convenience function that configures this Config object to write
@@ -226,7 +268,7 @@
     setDiscardValueNames(C.ShouldDiscardValueNames);
     enableDebugTypeODRUniquing();
     setDiagnosticHandler(
-        llvm::make_unique<LTOLLVMDiagnosticHandler>(&DiagHandler), true);
+        std::make_unique<LTOLLVMDiagnosticHandler>(&DiagHandler), true);
   }
   DiagnosticHandlerFunction DiagHandler;
 };
diff --git a/linux-x64/clang/include/llvm/LTO/LTO.h b/linux-x64/clang/include/llvm/LTO/LTO.h
index ca0a8b6..4f16913 100644
--- a/linux-x64/clang/include/llvm/LTO/LTO.h
+++ b/linux-x64/clang/include/llvm/LTO/LTO.h
@@ -17,28 +17,24 @@
 
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/StringMap.h"
-#include "llvm/ADT/StringSet.h"
-#include "llvm/IR/DiagnosticInfo.h"
+#include "llvm/Bitcode/BitcodeReader.h"
 #include "llvm/IR/ModuleSummaryIndex.h"
-#include "llvm/IR/RemarkStreamer.h"
 #include "llvm/LTO/Config.h"
-#include "llvm/Linker/IRMover.h"
 #include "llvm/Object/IRSymtab.h"
 #include "llvm/Support/Error.h"
-#include "llvm/Support/ToolOutputFile.h"
 #include "llvm/Support/thread.h"
-#include "llvm/Target/TargetOptions.h"
 #include "llvm/Transforms/IPO/FunctionImport.h"
 
 namespace llvm {
 
-class BitcodeModule;
 class Error;
+class IRMover;
 class LLVMContext;
 class MemoryBufferRef;
 class Module;
-class Target;
 class raw_pwrite_stream;
+class Target;
+class ToolOutputFile;
 
 /// Resolve linkage for prevailing symbols in the \p Index. Linkage changes
 /// recorded in the index and the ThinLTO backends must apply the changes to
@@ -59,7 +55,9 @@
 /// must apply the changes to the Module via thinLTOInternalizeModule.
 void thinLTOInternalizeAndPromoteInIndex(
     ModuleSummaryIndex &Index,
-    function_ref<bool(StringRef, GlobalValue::GUID)> isExported);
+    function_ref<bool(StringRef, ValueInfo)> isExported,
+    function_ref<bool(GlobalValue::GUID, const GlobalValueSummary *)>
+        isPrevailing);
 
 /// Computes a unique hash for the Module considering the current list of
 /// export/import and other global analysis results.
@@ -84,15 +82,19 @@
                                  const std::string &NewPrefix);
 
 /// Setup optimization remarks.
-Expected<std::unique_ptr<ToolOutputFile>>
-setupOptimizationRemarks(LLVMContext &Context, StringRef RemarksFilename,
-                         StringRef RemarksPasses, StringRef RemarksFormat,
-                         bool RemarksWithHotness, int Count = -1);
+Expected<std::unique_ptr<ToolOutputFile>> setupLLVMOptimizationRemarks(
+    LLVMContext &Context, StringRef RemarksFilename, StringRef RemarksPasses,
+    StringRef RemarksFormat, bool RemarksWithHotness,
+    Optional<uint64_t> RemarksHotnessThreshold = 0, int Count = -1);
 
 /// Setups the output file for saving statistics.
 Expected<std::unique_ptr<ToolOutputFile>>
 setupStatsFile(StringRef StatsFilename);
 
+/// Produces a container ordering for optimal multi-threaded processing. Returns
+/// ordered indices to elements in the input array.
+std::vector<int> generateModulesOrdering(ArrayRef<BitcodeModule *> R);
+
 class LTO;
 struct SymbolResolution;
 class ThinBackendProc;
@@ -220,12 +222,13 @@
 /// The details of this type definition aren't important; clients can only
 /// create a ThinBackend using one of the create*ThinBackend() functions below.
 using ThinBackend = std::function<std::unique_ptr<ThinBackendProc>(
-    Config &C, ModuleSummaryIndex &CombinedIndex,
+    const Config &C, ModuleSummaryIndex &CombinedIndex,
     StringMap<GVSummaryMapTy> &ModuleToDefinedGVSummaries,
     AddStreamFn AddStream, NativeObjectCache Cache)>;
 
 /// This ThinBackend runs the individual backend jobs in-process.
-ThinBackend createInProcessThinBackend(unsigned ParallelismLevel);
+/// The default value means to use one job per hardware core (not hyper-thread).
+ThinBackend createInProcessThinBackend(ThreadPoolStrategy Parallelism);
 
 /// This ThinBackend writes individual module indexes to files, instead of
 /// running the individual backend jobs. This backend is for distributed builds
@@ -296,14 +299,19 @@
   /// Cache) for each task identifier.
   Error run(AddStreamFn AddStream, NativeObjectCache Cache = nullptr);
 
+  /// Static method that returns a list of libcall symbols that can be generated
+  /// by LTO but might not be visible from bitcode symbol table.
+  static ArrayRef<const char*> getRuntimeLibcallSymbols();
+
 private:
   Config Conf;
 
   struct RegularLTOState {
-    RegularLTOState(unsigned ParallelCodeGenParallelismLevel, Config &Conf);
+    RegularLTOState(unsigned ParallelCodeGenParallelismLevel,
+                    const Config &Conf);
     struct CommonResolution {
       uint64_t Size = 0;
-      unsigned Align = 0;
+      MaybeAlign Align;
       /// Record if at least one instance of the common was marked as prevailing
       bool Prevailing = false;
     };
@@ -323,14 +331,20 @@
       std::vector<GlobalValue *> Keep;
     };
     std::vector<AddedModule> ModsWithSummaries;
+    bool EmptyCombinedModule = true;
   } RegularLTO;
 
+  using ModuleMapType = MapVector<StringRef, BitcodeModule>;
+
   struct ThinLTOState {
     ThinLTOState(ThinBackend Backend);
 
     ThinBackend Backend;
     ModuleSummaryIndex CombinedIndex;
-    MapVector<StringRef, BitcodeModule> ModuleMap;
+    // The full set of bitcode modules in input order.
+    ModuleMapType ModuleMap;
+    // The bitcode modules to compile, if specified by the LTO Config.
+    Optional<ModuleMapType> ModulesToCompile;
     DenseMap<GlobalValue::GUID, StringRef> PrevailingModuleForGUID;
   } ThinLTO;
 
diff --git a/linux-x64/clang/include/llvm/LTO/LTOBackend.h b/linux-x64/clang/include/llvm/LTO/LTOBackend.h
index 4ff8a19..824c7d1 100644
--- a/linux-x64/clang/include/llvm/LTO/LTOBackend.h
+++ b/linux-x64/clang/include/llvm/LTO/LTOBackend.h
@@ -33,18 +33,44 @@
 
 namespace lto {
 
+/// Runs middle-end LTO optimizations on \p Mod.
+bool opt(const Config &Conf, TargetMachine *TM, unsigned Task, Module &Mod,
+         bool IsThinLTO, ModuleSummaryIndex *ExportSummary,
+         const ModuleSummaryIndex *ImportSummary,
+         const std::vector<uint8_t> &CmdArgs);
+
 /// Runs a regular LTO backend. The regular LTO backend can also act as the
 /// regular LTO phase of ThinLTO, which may need to access the combined index.
-Error backend(Config &C, AddStreamFn AddStream,
+Error backend(const Config &C, AddStreamFn AddStream,
               unsigned ParallelCodeGenParallelismLevel,
               std::unique_ptr<Module> M, ModuleSummaryIndex &CombinedIndex);
 
 /// Runs a ThinLTO backend.
-Error thinBackend(Config &C, unsigned Task, AddStreamFn AddStream, Module &M,
-                  const ModuleSummaryIndex &CombinedIndex,
+Error thinBackend(const Config &C, unsigned Task, AddStreamFn AddStream,
+                  Module &M, const ModuleSummaryIndex &CombinedIndex,
                   const FunctionImporter::ImportMapTy &ImportList,
                   const GVSummaryMapTy &DefinedGlobals,
-                  MapVector<StringRef, BitcodeModule> &ModuleMap);
+                  MapVector<StringRef, BitcodeModule> &ModuleMap,
+                  const std::vector<uint8_t> &CmdArgs = std::vector<uint8_t>());
+
+Error finalizeOptimizationRemarks(
+    std::unique_ptr<ToolOutputFile> DiagOutputFile);
+
+/// Returns the BitcodeModule that is ThinLTO.
+BitcodeModule *findThinLTOModule(MutableArrayRef<BitcodeModule> BMs);
+
+/// Variant of the above.
+Expected<BitcodeModule> findThinLTOModule(MemoryBufferRef MBRef);
+
+/// Distributed ThinLTO: load the referenced modules, keeping their buffers
+/// alive in the provided OwnedImportLifetimeManager. Returns false if the
+/// operation failed.
+bool loadReferencedModules(
+    const Module &M, const ModuleSummaryIndex &CombinedIndex,
+    FunctionImporter::ImportMapTy &ImportList,
+    MapVector<llvm::StringRef, llvm::BitcodeModule> &ModuleMap,
+    std::vector<std::unique_ptr<llvm::MemoryBuffer>>
+        &OwnedImportsLifetimeManager);
 }
 }
 
diff --git a/linux-x64/clang/include/llvm/LTO/legacy/LTOCodeGenerator.h b/linux-x64/clang/include/llvm/LTO/legacy/LTOCodeGenerator.h
index d3cb4c8..d7ccc0d 100644
--- a/linux-x64/clang/include/llvm/LTO/legacy/LTOCodeGenerator.h
+++ b/linux-x64/clang/include/llvm/LTO/legacy/LTOCodeGenerator.h
@@ -35,11 +35,13 @@
 #define LLVM_LTO_LTOCODEGENERATOR_H
 
 #include "llvm-c/lto.h"
+#include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/IR/GlobalValue.h"
 #include "llvm/IR/Module.h"
+#include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/ToolOutputFile.h"
 #include "llvm/Target/TargetMachine.h"
@@ -87,11 +89,11 @@
   void setCodePICModel(Optional<Reloc::Model> Model) { RelocModel = Model; }
 
   /// Set the file type to be emitted (assembly or object code).
-  /// The default is TargetMachine::CGFT_ObjectFile.
-  void setFileType(TargetMachine::CodeGenFileType FT) { FileType = FT; }
+  /// The default is CGFT_ObjectFile.
+  void setFileType(CodeGenFileType FT) { FileType = FT; }
 
-  void setCpu(StringRef MCpu) { this->MCpu = MCpu; }
-  void setAttr(StringRef MAttr) { this->MAttr = MAttr; }
+  void setCpu(StringRef MCpu) { this->MCpu = std::string(MCpu); }
+  void setAttr(StringRef MAttr) { this->MAttr = std::string(MAttr); }
   void setOptLevel(unsigned OptLevel);
 
   void setShouldInternalize(bool Value) { ShouldInternalize = Value; }
@@ -113,7 +115,7 @@
     ShouldRestoreGlobalsLinkage = Value;
   }
 
-  void addMustPreserveSymbol(StringRef Sym) { MustPreserveSymbols[Sym] = 1; }
+  void addMustPreserveSymbol(StringRef Sym) { MustPreserveSymbols.insert(Sym); }
 
   /// Pass options to the driver and optimization passes.
   ///
@@ -121,7 +123,7 @@
   /// name is misleading).  This function should be called before
   /// LTOCodeGenerator::compilexxx(), and
   /// LTOCodeGenerator::writeMergedModules().
-  void setCodeGenDebugOptions(StringRef Opts);
+  void setCodeGenDebugOptions(ArrayRef<StringRef> Opts);
 
   /// Parse the options set in setCodeGenDebugOptions.
   ///
@@ -238,7 +240,7 @@
   bool ShouldInternalize = EnableLTOInternalization;
   bool ShouldEmbedUselists = false;
   bool ShouldRestoreGlobalsLinkage = false;
-  TargetMachine::CodeGenFileType FileType = TargetMachine::CGFT_ObjectFile;
+  CodeGenFileType FileType = CGFT_ObjectFile;
   std::unique_ptr<ToolOutputFile> DiagnosticOutputFile;
   bool Freestanding = false;
   std::unique_ptr<ToolOutputFile> StatsFile = nullptr;
diff --git a/linux-x64/clang/include/llvm/LTO/legacy/LTOModule.h b/linux-x64/clang/include/llvm/LTO/legacy/LTOModule.h
index 84b9b8c..310447d 100644
--- a/linux-x64/clang/include/llvm/LTO/legacy/LTOModule.h
+++ b/linux-x64/clang/include/llvm/LTO/legacy/LTOModule.h
@@ -48,8 +48,6 @@
 
   std::string LinkerOpts;
 
-  std::string DependentLibraries;
-
   std::unique_ptr<Module> Mod;
   MemoryBufferRef MBRef;
   ModuleSymbolTable SymTab;
@@ -165,6 +163,10 @@
 
   static const char *getDependentLibrary(lto::InputFile *input, size_t index, size_t *size);
 
+  Expected<uint32_t> getMachOCPUType() const;
+
+  Expected<uint32_t> getMachOCPUSubType() const;
+
 private:
   /// Parse metadata from the module
   // FIXME: it only parses "llvm.linker.options" metadata at the moment
diff --git a/linux-x64/clang/include/llvm/LinkAllPasses.h b/linux-x64/clang/include/llvm/LinkAllPasses.h
index 675d179..891d534 100644
--- a/linux-x64/clang/include/llvm/LinkAllPasses.h
+++ b/linux-x64/clang/include/llvm/LinkAllPasses.h
@@ -71,6 +71,7 @@
       (void) llvm::createAggressiveDCEPass();
       (void) llvm::createAggressiveInstCombinerPass();
       (void) llvm::createBitTrackingDCEPass();
+      (void) llvm::createOpenMPOptLegacyPass();
       (void) llvm::createArgumentPromotionPass();
       (void) llvm::createAlignmentFromAssumptionsPass();
       (void) llvm::createBasicAAWrapperPass();
@@ -88,12 +89,10 @@
       (void) llvm::createLibCallsShrinkWrapPass();
       (void) llvm::createCalledValuePropagationPass();
       (void) llvm::createConstantMergePass();
-      (void) llvm::createConstantPropagationPass();
       (void) llvm::createControlHeightReductionLegacyPass();
       (void) llvm::createCostModelAnalysisPass();
       (void) llvm::createDeadArgEliminationPass();
       (void) llvm::createDeadCodeEliminationPass();
-      (void) llvm::createDeadInstEliminationPass();
       (void) llvm::createDeadStoreEliminationPass();
       (void) llvm::createDependenceAnalysisWrapperPass();
       (void) llvm::createDomOnlyPrinterPass();
@@ -115,7 +114,6 @@
       (void) llvm::createGlobalsAAWrapperPass();
       (void) llvm::createGuardWideningPass();
       (void) llvm::createLoopGuardWideningPass();
-      (void) llvm::createIPConstantPropagationPass();
       (void) llvm::createIPSCCPPass();
       (void) llvm::createInductiveRangeCheckEliminationPass();
       (void) llvm::createIndVarSimplifyPass();
@@ -129,6 +127,7 @@
       (void) llvm::createLazyValueInfoPass();
       (void) llvm::createLoopExtractorPass();
       (void) llvm::createLoopInterchangePass();
+      (void) llvm::createLoopFlattenPass();
       (void) llvm::createLoopPredicationPass();
       (void) llvm::createLoopSimplifyPass();
       (void) llvm::createLoopSimplifyCFGPass();
@@ -140,6 +139,7 @@
       (void) llvm::createLoopVersioningLICMPass();
       (void) llvm::createLoopIdiomPass();
       (void) llvm::createLoopRotatePass();
+      (void) llvm::createLowerConstantIntrinsicsPass();
       (void) llvm::createLowerExpectIntrinsicPass();
       (void) llvm::createLowerInvokePass();
       (void) llvm::createLowerSwitchPass();
@@ -158,6 +158,7 @@
       (void) llvm::createPostDomOnlyViewerPass();
       (void) llvm::createPostDomViewerPass();
       (void) llvm::createReassociatePass();
+      (void) llvm::createRedundantDbgInstEliminationPass();
       (void) llvm::createRegionInfoPass();
       (void) llvm::createRegionOnlyPrinterPass();
       (void) llvm::createRegionOnlyViewerPass();
@@ -190,6 +191,7 @@
       (void) llvm::createInstructionNamerPass();
       (void) llvm::createMetaRenamerPass();
       (void) llvm::createAttributorLegacyPass();
+      (void) llvm::createAttributorCGSCCLegacyPass();
       (void) llvm::createPostOrderFunctionAttrsLegacyPass();
       (void) llvm::createReversePostOrderFunctionAttrsPass();
       (void) llvm::createMergeFunctionsPass();
@@ -199,10 +201,9 @@
       llvm::raw_string_ostream os(buf);
       (void) llvm::createPrintModulePass(os);
       (void) llvm::createPrintFunctionPass(os);
-      (void) llvm::createPrintBasicBlockPass(os);
       (void) llvm::createModuleDebugInfoPrinterPass();
       (void) llvm::createPartialInliningPass();
-      (void) llvm::createLintPass();
+      (void) llvm::createLintLegacyPassPass();
       (void) llvm::createSinkingPass();
       (void) llvm::createLowerAtomicPass();
       (void) llvm::createCorrelatedValuePropagationPass();
@@ -210,6 +211,7 @@
       (void) llvm::createLoopVectorizePass();
       (void) llvm::createSLPVectorizerPass();
       (void) llvm::createLoadStoreVectorizerPass();
+      (void) llvm::createVectorCombinePass();
       (void) llvm::createPartiallyInlineLibCallsPass();
       (void) llvm::createScalarizerPass();
       (void) llvm::createSeparateConstOffsetFromGEPPass();
@@ -219,11 +221,15 @@
       (void) llvm::createStraightLineStrengthReducePass();
       (void) llvm::createMemDerefPrinter();
       (void) llvm::createMustExecutePrinter();
+      (void) llvm::createMustBeExecutedContextPrinter();
       (void) llvm::createFloat2IntPass();
       (void) llvm::createEliminateAvailableExternallyPass();
-      (void) llvm::createScalarizeMaskedMemIntrinPass();
+      (void)llvm::createScalarizeMaskedMemIntrinLegacyPass();
       (void) llvm::createWarnMissedTransformationsPass();
       (void) llvm::createHardwareLoopsPass();
+      (void) llvm::createInjectTLIMappingsLegacyPass();
+      (void) llvm::createUnifyLoopExitsPass();
+      (void) llvm::createFixIrreduciblePass();
 
       (void)new llvm::IntervalPartition();
       (void)new llvm::ScalarEvolutionWrapperPass();
@@ -233,7 +239,7 @@
       llvm::TargetLibraryInfo TLI(TLII);
       llvm::AliasAnalysis AA(TLI);
       llvm::AliasSetTracker X(AA);
-      X.add(nullptr, llvm::LocationSize::unknown(),
+      X.add(nullptr, llvm::LocationSize::beforeOrAfterPointer(),
             llvm::AAMDNodes()); // for -print-alias-sets
       (void) llvm::AreStatisticsEnabled();
       (void) llvm::sys::RunningOnValgrind();
diff --git a/linux-x64/clang/include/llvm/MC/ConstantPools.h b/linux-x64/clang/include/llvm/MC/ConstantPools.h
index 2fe5ce2..9fe0cce 100644
--- a/linux-x64/clang/include/llvm/MC/ConstantPools.h
+++ b/linux-x64/clang/include/llvm/MC/ConstantPools.h
@@ -13,7 +13,6 @@
 #ifndef LLVM_MC_CONSTANTPOOLS_H
 #define LLVM_MC_CONSTANTPOOLS_H
 
-#include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/SMLoc.h"
diff --git a/linux-x64/clang/include/llvm/MC/LaneBitmask.h b/linux-x64/clang/include/llvm/MC/LaneBitmask.h
index d5f6928..a467407 100644
--- a/linux-x64/clang/include/llvm/MC/LaneBitmask.h
+++ b/linux-x64/clang/include/llvm/MC/LaneBitmask.h
@@ -38,9 +38,9 @@
 
   struct LaneBitmask {
     // When changing the underlying type, change the format string as well.
-    using Type = unsigned;
+    using Type = uint64_t;
     enum : unsigned { BitWidth = 8*sizeof(Type) };
-    constexpr static const char *const FormatStr = "%08X";
+    constexpr static const char *const FormatStr = "%016llX";
 
     constexpr LaneBitmask() = default;
     explicit constexpr LaneBitmask(Type V) : Mask(V) {}
@@ -76,7 +76,7 @@
       return countPopulation(Mask);
     }
     unsigned getHighestLane() const {
-      return Log2_32(Mask);
+      return Log2_64(Mask);
     }
 
     static constexpr LaneBitmask getNone() { return LaneBitmask(0); }
diff --git a/linux-x64/clang/include/llvm/MC/MCAsmBackend.h b/linux-x64/clang/include/llvm/MC/MCAsmBackend.h
index 1f3ad6c..94ed3d2 100644
--- a/linux-x64/clang/include/llvm/MC/MCAsmBackend.h
+++ b/linux-x64/clang/include/llvm/MC/MCAsmBackend.h
@@ -11,36 +11,29 @@
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Optional.h"
-#include "llvm/ADT/StringRef.h"
 #include "llvm/MC/MCDirectives.h"
 #include "llvm/MC/MCFixup.h"
 #include "llvm/MC/MCFragment.h"
 #include "llvm/Support/Endian.h"
 #include <cstdint>
-#include <memory>
 
 namespace llvm {
 
 class MCAsmLayout;
 class MCAssembler;
 class MCCFIInstruction;
-class MCCodePadder;
 struct MCFixupKindInfo;
-class MCFragment;
 class MCInst;
 class MCObjectStreamer;
 class MCObjectTargetWriter;
 class MCObjectWriter;
-struct MCCodePaddingContext;
-class MCRelaxableFragment;
 class MCSubtargetInfo;
 class MCValue;
 class raw_pwrite_stream;
+class StringRef;
 
 /// Generic interface to target specific assembler backends.
 class MCAsmBackend {
-  std::unique_ptr<MCCodePadder> CodePadder;
-
 protected: // Can only create subclasses.
   MCAsmBackend(support::endianness Endian);
 
@@ -51,6 +44,20 @@
 
   const support::endianness Endian;
 
+  /// Return true if this target might automatically pad instructions and thus
+  /// need to emit padding enable/disable directives around sensative code.
+  virtual bool allowAutoPadding() const { return false; }
+  /// Return true if this target allows an unrelaxable instruction to be
+  /// emitted into RelaxableFragment and then we can increase its size in a
+  /// tricky way for optimization.
+  virtual bool allowEnhancedRelaxation() const { return false; }
+
+  /// Give the target a chance to manipulate state related to instruction
+  /// alignment (e.g. padding for optimization), instruction relaxablility, etc.
+  /// before and after actually emitting the instruction.
+  virtual void emitInstructionBegin(MCObjectStreamer &OS, const MCInst &Inst) {}
+  virtual void emitInstructionEnd(MCObjectStreamer &OS, const MCInst &Inst) {}
+
   /// lifetime management
   virtual void reset() {}
 
@@ -103,6 +110,14 @@
     return false;
   }
 
+  virtual bool evaluateTargetFixup(const MCAssembler &Asm,
+                                   const MCAsmLayout &Layout,
+                                   const MCFixup &Fixup, const MCFragment *DF,
+                                   const MCValue &Target, uint64_t &Value,
+                                   bool &WasForced) {
+    llvm_unreachable("Need to implement hook if target has custom fixups");
+  }
+
   /// Apply the \p Value for given \p Fixup into the provided data fragment, at
   /// the offset specified by the fixup and following the fixup kind as
   /// appropriate. Errors (such as an out of range fixup value) should be
@@ -129,7 +144,9 @@
   /// \param STI - The MCSubtargetInfo in effect when the instruction was
   /// encoded.
   virtual bool mayNeedRelaxation(const MCInst &Inst,
-                                 const MCSubtargetInfo &STI) const = 0;
+                                 const MCSubtargetInfo &STI) const {
+    return false;
+  }
 
   /// Target specific predicate for whether a given fixup requires the
   /// associated instruction to be relaxed.
@@ -146,12 +163,11 @@
 
   /// Relax the instruction in the given fragment to the next wider instruction.
   ///
-  /// \param Inst The instruction to relax, which may be the same as the
-  /// output.
+  /// \param [out] Inst The instruction to relax, which is also the relaxed
+  /// instruction.
   /// \param STI the subtarget information for the associated instruction.
-  /// \param [out] Res On return, the relaxed instruction.
-  virtual void relaxInstruction(const MCInst &Inst, const MCSubtargetInfo &STI,
-                                MCInst &Res) const = 0;
+  virtual void relaxInstruction(MCInst &Inst,
+                                const MCSubtargetInfo &STI) const {};
 
   /// @}
 
@@ -161,6 +177,10 @@
   ///
   virtual unsigned getMinimumNopSize() const { return 1; }
 
+  /// Returns the maximum size of a nop in bytes on this target.
+  ///
+  virtual unsigned getMaximumNopSize() const { return 0; }
+
   /// Write an (optimal) nop sequence of Count bytes to the given output. If the
   /// target cannot generate such a sequence, it should return an error.
   ///
@@ -184,40 +204,6 @@
   virtual bool isMicroMips(const MCSymbol *Sym) const {
     return false;
   }
-
-  /// Handles all target related code padding when starting to write a new
-  /// basic block to an object file.
-  ///
-  /// \param OS The streamer used for writing the padding data and function.
-  /// \param Context the context of the padding, Embeds the basic block's
-  /// parameters.
-  void handleCodePaddingBasicBlockStart(MCObjectStreamer *OS,
-                                        const MCCodePaddingContext &Context);
-  /// Handles all target related code padding after writing a block to an object
-  /// file.
-  ///
-  /// \param Context the context of the padding, Embeds the basic block's
-  /// parameters.
-  void handleCodePaddingBasicBlockEnd(const MCCodePaddingContext &Context);
-  /// Handles all target related code padding before writing a new instruction
-  /// to an object file.
-  ///
-  /// \param Inst the instruction.
-  void handleCodePaddingInstructionBegin(const MCInst &Inst);
-  /// Handles all target related code padding after writing an instruction to an
-  /// object file.
-  ///
-  /// \param Inst the instruction.
-  void handleCodePaddingInstructionEnd(const MCInst &Inst);
-
-  /// Relaxes a fragment (changes the size of the padding) according to target
-  /// requirements. The new size computation is done w.r.t a layout.
-  ///
-  /// \param PF The fragment to relax.
-  /// \param Layout Code layout information.
-  ///
-  /// \returns true iff any relaxation occurred.
-  bool relaxFragment(MCPaddingFragment *PF, MCAsmLayout &Layout);
 };
 
 } // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/MC/MCAsmInfo.h b/linux-x64/clang/include/llvm/MC/MCAsmInfo.h
index 971e935..98e9c2f 100644
--- a/linux-x64/clang/include/llvm/MC/MCAsmInfo.h
+++ b/linux-x64/clang/include/llvm/MC/MCAsmInfo.h
@@ -54,6 +54,15 @@
 /// This class is intended to be used as a base class for asm
 /// properties and features specific to the target.
 class MCAsmInfo {
+public:
+  /// Assembly character literal syntax types.
+  enum AsmCharLiteralSyntax {
+    ACLS_Unknown, /// Unknown; character literals not used by LLVM for this
+                  /// target.
+    ACLS_SingleQuotePrefix, /// The desired character is prefixed by a single
+                            /// quote, e.g., `'A`.
+  };
+
 protected:
   //===------------------------------------------------------------------===//
   // Properties to be set by the target writer, used to configure asm printer.
@@ -93,6 +102,10 @@
   /// constants into comdat sections.
   bool HasCOFFComdatConstants = false;
 
+  /// True if this is an XCOFF target that supports visibility attributes as
+  /// part of .global, .weak, .extern, and .comm. Default is false.
+  bool HasVisibilityOnlyWithLinkage = false;
+
   /// This is the maximum possible length of an instruction, which is needed to
   /// compute the size of an inline asm.  Defaults to 4.
   unsigned MaxInstLength = 4;
@@ -156,6 +169,10 @@
   /// Defaults to false.
   bool AllowAtInName = false;
 
+  /// This is true if the assembler allows $ @ ? characters at the start of
+  /// symbol names. Defaults to false.
+  bool AllowSymbolAtNameStart = false;
+
   /// If this is true, symbol names with invalid characters will be printed in
   /// quotes.
   bool SupportsQuotedNames = true;
@@ -165,14 +182,26 @@
   /// instead.
   bool UseDataRegionDirectives = false;
 
+  /// True if .align is to be used for alignment. Only power-of-two
+  /// alignment is supported.
+  bool UseDotAlignForAlignment = false;
+
+  /// True if the target supports LEB128 directives.
+  bool HasLEB128Directives = true;
+
   //===--- Data Emission Directives -------------------------------------===//
 
-  /// This should be set to the directive used to get some number of zero bytes
-  /// emitted to the current section.  Common cases are "\t.zero\t" and
-  /// "\t.space\t".  If this is set to null, the Data*bitsDirective's will be
-  /// used to emit zero bytes.  Defaults to "\t.zero\t"
+  /// This should be set to the directive used to get some number of zero (and
+  /// non-zero if supported by the directive) bytes emitted to the current
+  /// section. Common cases are "\t.zero\t" and "\t.space\t". Defaults to
+  /// "\t.zero\t"
   const char *ZeroDirective;
 
+  /// This should be set to true if the zero directive supports a value to emit
+  /// other than zero. If this is set to false, the Data*bitsDirective's will be
+  /// used to emit these bytes. Defaults to true.
+  bool ZeroDirectiveSupportsNonZeroValue = true;
+
   /// This directive allows emission of an ascii string with the standard C
   /// escape characters embedded into it.  If a target doesn't support this, it
   /// can be set to null. Defaults to "\t.ascii\t"
@@ -183,6 +212,16 @@
   /// doesn't support this, it can be set to null.  Defaults to "\t.asciz\t"
   const char *AscizDirective;
 
+  /// This directive accepts a comma-separated list of bytes for emission as a
+  /// string of bytes.  For targets that do not support this, it shall be set to
+  /// null.  Defaults to null.
+  const char *ByteListDirective = nullptr;
+
+  /// Form used for character literals in the assembly syntax.  Useful for
+  /// producing strings as byte lists.  If a target does not use or support
+  /// this, it shall be set to ACLS_Unknown.  Defaults to ACLS_Unknown.
+  AsmCharLiteralSyntax CharacterLiteralSyntax = ACLS_Unknown;
+
   /// These directives are used to output some unit of integer data to the
   /// current section.  If a data directive is set to null, smaller data
   /// directives will be used to emit the large sizes.  Defaults to "\t.byte\t",
@@ -192,6 +231,9 @@
   const char *Data32bitsDirective;
   const char *Data64bitsDirective;
 
+  /// True if data directives support signed values
+  bool SupportsSignedData = true;
+
   /// If non-null, a directive that is used to emit a word which should be
   /// relocated as a 64-bit GP-relative offset, e.g. .gpdword on Mips.  Defaults
   /// to nullptr.
@@ -309,9 +351,10 @@
   /// symbol that can be hidden (unexported).  Defaults to false.
   bool HasWeakDefCanBeHiddenDirective = false;
 
-  /// True if we have a .linkonce directive.  This is used on cygwin/mingw.
+  /// True if we should mark symbols as global instead of weak, for
+  /// weak*/linkonce*, if the symbol has a comdat.
   /// Defaults to false.
-  bool HasLinkOnceDirective = false;
+  bool AvoidWeakIfComdat = false;
 
   /// This attribute, if not MCSA_Invalid, is used to declare a symbol as having
   /// hidden visibility.  Defaults to MCSA_Hidden.
@@ -388,6 +431,9 @@
   // %hi(), and similar unary operators.
   bool HasMipsExpressions = false;
 
+  // If true, emit function descriptor symbol on AIX.
+  bool NeedsFunctionDescriptors = false;
+
 public:
   explicit MCAsmInfo();
   virtual ~MCAsmInfo();
@@ -415,6 +461,7 @@
   const char *getData16bitsDirective() const { return Data16bitsDirective; }
   const char *getData32bitsDirective() const { return Data32bitsDirective; }
   const char *getData64bitsDirective() const { return Data64bitsDirective; }
+  bool supportsSignedData() const { return SupportsSignedData; }
   const char *getGPRel64Directive() const { return GPRel64Directive; }
   const char *getGPRel32Directive() const { return GPRel32Directive; }
   const char *getDTPRel64Directive() const { return DTPRel64Directive; }
@@ -443,6 +490,9 @@
                                             unsigned Encoding,
                                             MCStreamer &Streamer) const;
 
+  /// Return true if C is an acceptable character inside a symbol name.
+  virtual bool isAcceptableChar(char C) const;
+
   /// Return true if the identifier \p Name does not need quotes to be
   /// syntactically correct.
   virtual bool isValidUnquotedName(StringRef Name) const;
@@ -474,6 +524,9 @@
   bool hasMachoTBSSDirective() const { return HasMachoTBSSDirective; }
   bool hasCOFFAssociativeComdats() const { return HasCOFFAssociativeComdats; }
   bool hasCOFFComdatConstants() const { return HasCOFFComdatConstants; }
+  bool hasVisibilityOnlyWithLinkage() const {
+    return HasVisibilityOnlyWithLinkage;
+  }
 
   /// Returns the maximum possible encoded instruction size in bytes. If \p STI
   /// is null, this should be the maximum size for any subtarget.
@@ -514,15 +567,29 @@
   const char *getCode64Directive() const { return Code64Directive; }
   unsigned getAssemblerDialect() const { return AssemblerDialect; }
   bool doesAllowAtInName() const { return AllowAtInName; }
+  bool doesAllowSymbolAtNameStart() const { return AllowSymbolAtNameStart; }
   bool supportsNameQuoting() const { return SupportsQuotedNames; }
 
   bool doesSupportDataRegionDirectives() const {
     return UseDataRegionDirectives;
   }
 
+  bool useDotAlignForAlignment() const {
+    return UseDotAlignForAlignment;
+  }
+
+  bool hasLEB128Directives() const { return HasLEB128Directives; }
+
   const char *getZeroDirective() const { return ZeroDirective; }
+  bool doesZeroDirectiveSupportNonZeroValue() const {
+    return ZeroDirectiveSupportsNonZeroValue;
+  }
   const char *getAsciiDirective() const { return AsciiDirective; }
   const char *getAscizDirective() const { return AscizDirective; }
+  const char *getByteListDirective() const { return ByteListDirective; }
+  AsmCharLiteralSyntax characterLiteralSyntax() const {
+    return CharacterLiteralSyntax;
+  }
   bool getAlignmentIsInBytes() const { return AlignmentIsInBytes; }
   unsigned getTextAlignFillValue() const { return TextAlignFillValue; }
   const char *getGlobalDirective() const { return GlobalDirective; }
@@ -555,7 +622,7 @@
     return HasWeakDefCanBeHiddenDirective;
   }
 
-  bool hasLinkOnceDirective() const { return HasLinkOnceDirective; }
+  bool avoidWeakIfComdat() const { return AvoidWeakIfComdat; }
 
   MCSymbolAttr getHiddenVisibilityAttr() const { return HiddenVisibilityAttr; }
 
@@ -569,10 +636,6 @@
 
   bool doesSupportDebugInformation() const { return SupportsDebugInformation; }
 
-  bool doesSupportExceptionHandling() const {
-    return ExceptionsType != ExceptionHandling::None;
-  }
-
   ExceptionHandling getExceptionHandlingType() const { return ExceptionsType; }
   WinEH::EncodingType getWinEHEncodingType() const { return WinEHEncodingType; }
 
@@ -639,6 +702,7 @@
   bool canRelaxRelocations() const { return RelaxELFRelocations; }
   void setRelaxELFRelocations(bool V) { RelaxELFRelocations = V; }
   bool hasMipsExpressions() const { return HasMipsExpressions; }
+  bool needsFunctionDescriptors() const { return NeedsFunctionDescriptors; }
 };
 
 } // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/MC/MCAsmInfoELF.h b/linux-x64/clang/include/llvm/MC/MCAsmInfoELF.h
index aa2e587..408d4df 100644
--- a/linux-x64/clang/include/llvm/MC/MCAsmInfoELF.h
+++ b/linux-x64/clang/include/llvm/MC/MCAsmInfoELF.h
@@ -18,10 +18,6 @@
   MCSection *getNonexecutableStackSection(MCContext &Ctx) const final;
 
 protected:
-  /// Targets which have non-executable stacks by default can set this to false
-  /// to disable the special section which requests a non-executable stack.
-  bool UsesNonexecutableStackSection = true;
-
   MCAsmInfoELF();
 };
 
diff --git a/linux-x64/clang/include/llvm/MC/MCAsmInfoXCOFF.h b/linux-x64/clang/include/llvm/MC/MCAsmInfoXCOFF.h
index 2a72ba7..5483899 100644
--- a/linux-x64/clang/include/llvm/MC/MCAsmInfoXCOFF.h
+++ b/linux-x64/clang/include/llvm/MC/MCAsmInfoXCOFF.h
@@ -18,6 +18,11 @@
 
 protected:
   MCAsmInfoXCOFF();
+
+public:
+  // Return true only when C is an acceptable character inside a
+  // MCSymbolXCOFF.
+  bool isAcceptableChar(char C) const override;
 };
 
 } // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/MC/MCAsmLayout.h b/linux-x64/clang/include/llvm/MC/MCAsmLayout.h
index 45ac96f..f95af21 100644
--- a/linux-x64/clang/include/llvm/MC/MCAsmLayout.h
+++ b/linux-x64/clang/include/llvm/MC/MCAsmLayout.h
@@ -49,6 +49,10 @@
   /// Get the assembler object this is a layout for.
   MCAssembler &getAssembler() const { return Assembler; }
 
+  /// \returns whether the offset of fragment \p F can be obtained via
+  /// getFragmentOffset.
+  bool canGetFragmentOffset(const MCFragment *F) const;
+
   /// Invalidate the fragments starting with F because it has been
   /// resized. The fragment's size should have already been updated, but
   /// its bundle padding will be recomputed.
diff --git a/linux-x64/clang/include/llvm/MC/MCAsmMacro.h b/linux-x64/clang/include/llvm/MC/MCAsmMacro.h
index 364d3b5..e3d6a85 100644
--- a/linux-x64/clang/include/llvm/MC/MCAsmMacro.h
+++ b/linux-x64/clang/include/llvm/MC/MCAsmMacro.h
@@ -124,7 +124,6 @@
   }
 
   void dump(raw_ostream &OS) const;
-  void dump() const { dump(dbgs()); }
 };
 
 struct MCAsmMacroParameter {
@@ -133,10 +132,10 @@
   bool Required = false;
   bool Vararg = false;
 
-  MCAsmMacroParameter() = default;
-
+#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
   void dump() const { dump(dbgs()); }
-  void dump(raw_ostream &OS) const;
+  LLVM_DUMP_METHOD void dump(raw_ostream &OS) const;
+#endif
 };
 
 typedef std::vector<MCAsmMacroParameter> MCAsmMacroParameters;
@@ -144,13 +143,21 @@
   StringRef Name;
   StringRef Body;
   MCAsmMacroParameters Parameters;
+  std::vector<std::string> Locals;
+  bool IsFunction = false;
 
 public:
   MCAsmMacro(StringRef N, StringRef B, MCAsmMacroParameters P)
       : Name(N), Body(B), Parameters(std::move(P)) {}
+  MCAsmMacro(StringRef N, StringRef B, MCAsmMacroParameters P,
+             std::vector<std::string> L, bool F)
+      : Name(N), Body(B), Parameters(std::move(P)), Locals(std::move(L)),
+        IsFunction(F) {}
 
+#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
   void dump() const { dump(dbgs()); }
-  void dump(raw_ostream &OS) const;
+  LLVM_DUMP_METHOD void dump(raw_ostream &OS) const;
+#endif
 };
 } // namespace llvm
 
diff --git a/linux-x64/clang/include/llvm/MC/MCAssembler.h b/linux-x64/clang/include/llvm/MC/MCAssembler.h
index 4543018..1b76559 100644
--- a/linux-x64/clang/include/llvm/MC/MCAssembler.h
+++ b/linux-x64/clang/include/llvm/MC/MCAssembler.h
@@ -190,18 +190,19 @@
   /// if any offsets were adjusted.
   bool layoutSectionOnce(MCAsmLayout &Layout, MCSection &Sec);
 
+  /// Perform relaxation on a single fragment - returns true if the fragment
+  /// changes as a result of relaxation.
+  bool relaxFragment(MCAsmLayout &Layout, MCFragment &F);
   bool relaxInstruction(MCAsmLayout &Layout, MCRelaxableFragment &IF);
-
-  bool relaxPaddingFragment(MCAsmLayout &Layout, MCPaddingFragment &PF);
-
   bool relaxLEB(MCAsmLayout &Layout, MCLEBFragment &IF);
-
+  bool relaxBoundaryAlign(MCAsmLayout &Layout, MCBoundaryAlignFragment &BF);
   bool relaxDwarfLineAddr(MCAsmLayout &Layout, MCDwarfLineAddrFragment &DF);
   bool relaxDwarfCallFrameFragment(MCAsmLayout &Layout,
                                    MCDwarfCallFrameFragment &DF);
   bool relaxCVInlineLineTable(MCAsmLayout &Layout,
                               MCCVInlineLineTableFragment &DF);
   bool relaxCVDefRange(MCAsmLayout &Layout, MCCVDefRangeFragment &DF);
+  bool relaxPseudoProbeAddr(MCAsmLayout &Layout, MCPseudoProbeAddrFragment &DF);
 
   /// finishLayout - Finalize a layout, including fragment lowering.
   void finishLayout(MCAsmLayout &Layout);
@@ -210,7 +211,12 @@
   handleFixup(const MCAsmLayout &Layout, MCFragment &F, const MCFixup &Fixup);
 
 public:
-  std::vector<std::pair<StringRef, const MCSymbol *>> Symvers;
+  struct Symver {
+    StringRef Name;
+    const MCSymbol *Sym;
+    SMLoc Loc;
+  };
+  std::vector<Symver> Symvers;
 
   /// Construct a new assembler instance.
   //
@@ -443,7 +449,7 @@
 
   void addFileName(StringRef FileName) {
     if (!is_contained(FileNames, FileName))
-      FileNames.push_back(FileName);
+      FileNames.push_back(std::string(FileName));
   }
 
   /// Write the necessary bundle padding to \p OS.
diff --git a/linux-x64/clang/include/llvm/MC/MCCodeEmitter.h b/linux-x64/clang/include/llvm/MC/MCCodeEmitter.h
index 04b4367..2794acc 100644
--- a/linux-x64/clang/include/llvm/MC/MCCodeEmitter.h
+++ b/linux-x64/clang/include/llvm/MC/MCCodeEmitter.h
@@ -30,6 +30,12 @@
   /// Lifetime management
   virtual void reset() {}
 
+  /// Emit the prefixes of given instruction on the output stream.
+  ///
+  /// \param Inst a single low-level machine instruction.
+  /// \param OS output stream.
+  virtual void emitPrefix(const MCInst &Inst, raw_ostream &OS,
+                          const MCSubtargetInfo &STI) const {}
   /// EncodeInstruction - Encode the given \p Inst to bytes on the output
   /// stream \p OS.
   virtual void encodeInstruction(const MCInst &Inst, raw_ostream &OS,
diff --git a/linux-x64/clang/include/llvm/MC/MCCodePadder.h b/linux-x64/clang/include/llvm/MC/MCCodePadder.h
deleted file mode 100644
index f7b1a21..0000000
--- a/linux-x64/clang/include/llvm/MC/MCCodePadder.h
+++ /dev/null
@@ -1,241 +0,0 @@
-//===- llvm/MC/MCCodePadder.h - MC Code Padder ------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_MC_MCCODEPADDER_H
-#define LLVM_MC_MCCODEPADDER_H
-
-#include "MCFragment.h"
-#include "llvm/ADT/DenseMap.h"
-#include "llvm/ADT/SmallPtrSet.h"
-#include "llvm/ADT/SmallVector.h"
-
-namespace llvm {
-
-class MCAsmLayout;
-class MCCodePaddingPolicy;
-class MCFragment;
-class MCInst;
-class MCObjectStreamer;
-class MCSection;
-
-typedef SmallVector<const MCPaddingFragment *, 8> MCPFRange;
-
-struct MCCodePaddingContext {
-  bool IsPaddingActive;
-  bool IsBasicBlockReachableViaFallthrough;
-  bool IsBasicBlockReachableViaBranch;
-};
-
-/// Target-independent base class incharge of all code padding decisions for a
-/// target. During encoding it determines if and where MCPaddingFragments will
-/// be located, as later on, when layout information is available, it determines
-/// their sizes.
-class MCCodePadder {
-  MCCodePadder(const MCCodePadder &) = delete;
-  void operator=(const MCCodePadder &) = delete;
-
-  /// Determines if the MCCodePaddingPolicies are active.
-  bool ArePoliciesActive;
-
-  /// All the supported MCCodePaddingPolicies.
-  SmallPtrSet<MCCodePaddingPolicy *, 4> CodePaddingPolicies;
-
-  /// A pointer to the fragment of the instruction whose padding is currently
-  /// done for.
-  MCPaddingFragment *CurrHandledInstFragment;
-
-  /// A map holding the jurisdiction for each padding fragment. Key: padding
-  /// fragment. Value: The fragment's jurisdiction. A jurisdiction is a vector
-  /// of padding fragments whose conditions are being controlled by another
-  /// fragment, the key fragment.
-  DenseMap<MCPaddingFragment *, MCPFRange> FragmentToJurisdiction;
-  MCPFRange &getJurisdiction(MCPaddingFragment *Fragment, MCAsmLayout &Layout);
-
-  /// A map holding the maximal instruction window size relevant for a padding
-  /// fragment.
-  DenseMap<MCPaddingFragment *, uint64_t> FragmentToMaxWindowSize;
-  uint64_t getMaxWindowSize(MCPaddingFragment *Fragment, MCAsmLayout &Layout);
-
-protected:
-  /// The current streamer, used to stream code padding.
-  MCObjectStreamer *OS;
-
-  bool addPolicy(MCCodePaddingPolicy *Policy);
-
-  virtual bool
-  basicBlockRequiresInsertionPoint(const MCCodePaddingContext &Context) {
-    return false;
-  }
-
-  virtual bool instructionRequiresInsertionPoint(const MCInst &Inst) {
-    return false;
-  }
-
-  virtual bool usePoliciesForBasicBlock(const MCCodePaddingContext &Context) {
-    return Context.IsPaddingActive;
-  }
-
-public:
-  MCCodePadder()
-      : ArePoliciesActive(false), CurrHandledInstFragment(nullptr),
-        OS(nullptr) {}
-  virtual ~MCCodePadder();
-
-  /// Handles all target related code padding when starting to write a new
-  /// basic block to an object file.
-  ///
-  /// \param OS The streamer used for writing the padding data and function.
-  /// \param Context the context of the padding, Embeds the basic block's
-  /// parameters.
-  void handleBasicBlockStart(MCObjectStreamer *OS,
-                             const MCCodePaddingContext &Context);
-  /// Handles all target related code padding when done writing a block to an
-  /// object file.
-  ///
-  /// \param Context the context of the padding, Embeds the basic block's
-  /// parameters.
-  void handleBasicBlockEnd(const MCCodePaddingContext &Context);
-  /// Handles all target related code padding before writing a new instruction
-  /// to an object file.
-  ///
-  /// \param Inst the instruction.
-  void handleInstructionBegin(const MCInst &Inst);
-  /// Handles all target related code padding after writing an instruction to an
-  /// object file.
-  ///
-  /// \param Inst the instruction.
-  void handleInstructionEnd(const MCInst &Inst);
-
-  /// Relaxes a fragment (changes the size of the padding) according to target
-  /// requirements. The new size computation is done w.r.t a layout.
-  ///
-  /// \param Fragment The fragment to relax.
-  /// \param Layout Code layout information.
-  ///
-  /// \returns true iff any relaxation occurred.
-  bool relaxFragment(MCPaddingFragment *Fragment, MCAsmLayout &Layout);
-};
-
-/// The base class for all padding policies, i.e. a rule or set of rules to pad
-/// the generated code.
-class MCCodePaddingPolicy {
-  MCCodePaddingPolicy() = delete;
-  MCCodePaddingPolicy(const MCCodePaddingPolicy &) = delete;
-  void operator=(const MCCodePaddingPolicy &) = delete;
-
-protected:
-  /// A mask holding the kind of this policy, i.e. only the i'th bit will be set
-  /// where i is the kind number.
-  const uint64_t KindMask;
-  /// Instruction window size relevant to this policy.
-  const uint64_t WindowSize;
-  /// A boolean indicating which byte of the instruction determies its
-  /// instruction window. If true - the last byte of the instructions, o.w. -
-  /// the first byte of the instruction.
-  const bool InstByteIsLastByte;
-
-  MCCodePaddingPolicy(uint64_t Kind, uint64_t WindowSize,
-                      bool InstByteIsLastByte)
-      : KindMask(UINT64_C(1) << Kind), WindowSize(WindowSize),
-        InstByteIsLastByte(InstByteIsLastByte) {}
-
-  /// Computes and returns the offset of the consecutive fragment of a given
-  /// fragment.
-  ///
-  /// \param Fragment The fragment whose consecutive offset will be computed.
-  /// \param Layout Code layout information.
-  ///
-  /// \returns the offset of the consecutive fragment of \p Fragment.
-  static uint64_t getNextFragmentOffset(const MCFragment *Fragment,
-                                        const MCAsmLayout &Layout);
-  /// Returns the instruction byte of an instruction pointed by a given
-  /// MCPaddingFragment. An instruction byte is the address of the byte of an
-  /// instruction which determines its instruction window.
-  ///
-  /// \param Fragment The fragment pointing to the instruction.
-  /// \param Layout Code layout information.
-  ///
-  /// \returns the instruction byte of an instruction pointed by \p Fragment.
-  uint64_t getFragmentInstByte(const MCPaddingFragment *Fragment,
-                               MCAsmLayout &Layout) const;
-  uint64_t computeWindowEndAddress(const MCPaddingFragment *Fragment,
-                                   uint64_t Offset, MCAsmLayout &Layout) const;
-
-  /// Computes and returns the penalty weight of a first instruction window in a
-  /// range. This requires a special function since the first window does not
-  /// contain all the padding fragments in that window. It only contains all the
-  /// padding fragments starting from the relevant insertion point.
-  ///
-  /// \param Window The first window.
-  /// \param Offset The offset of the parent section relative to the beginning
-  /// of the file, mod the window size.
-  /// \param Layout Code layout information.
-  ///
-  /// \returns the penalty weight of a first instruction window in a range, \p
-  /// Window.
-  double computeFirstWindowPenaltyWeight(const MCPFRange &Window,
-                                         uint64_t Offset,
-                                         MCAsmLayout &Layout) const;
-  /// Computes and returns the penalty caused by an instruction window.
-  ///
-  /// \param Window The instruction window.
-  /// \param Offset The offset of the parent section relative to the beginning
-  /// of the file, mod the window size.
-  /// \param Layout Code layout information.
-  ///
-  /// \returns the penalty caused by \p Window.
-  virtual double computeWindowPenaltyWeight(const MCPFRange &Window,
-                                            uint64_t Offset,
-                                            MCAsmLayout &Layout) const = 0;
-
-public:
-  virtual ~MCCodePaddingPolicy() {}
-
-  /// Returns the kind mask of this policy -  A mask holding the kind of this
-  /// policy, i.e. only the i'th bit will be set where i is the kind number.
-  uint64_t getKindMask() const { return KindMask; }
-  /// Returns the instruction window size relevant to this policy.
-  uint64_t getWindowSize() const { return WindowSize; }
-  /// Returns true if the last byte of an instruction determines its instruction
-  /// window, or false if the first of an instruction determines it.
-  bool isInstByteLastByte() const { return InstByteIsLastByte; }
-
-  /// Returns true iff this policy needs padding for a given basic block.
-  ///
-  /// \param Context the context of the padding, Embeds the basic block's
-  /// parameters.
-  ///
-  /// \returns true iff this policy needs padding for the basic block.
-  virtual bool
-  basicBlockRequiresPaddingFragment(const MCCodePaddingContext &Context) const {
-    return false;
-  }
-  /// Returns true iff this policy needs padding for a given instruction.
-  ///
-  /// \param Inst The given instruction.
-  ///
-  /// \returns true iff this policy needs padding for \p Inst.
-  virtual bool instructionRequiresPaddingFragment(const MCInst &Inst) const {
-    return false;
-  }
-  /// Computes and returns the penalty caused by a range of instruction windows.
-  /// The weight is computed for each window separelty and then accumulated.
-  ///
-  /// \param Range The range.
-  /// \param Offset The offset of the parent section relative to the beginning
-  /// of the file, mod the window size.
-  /// \param Layout Code layout information.
-  ///
-  /// \returns the penalty caused by \p Range.
-  double computeRangePenaltyWeight(const MCPFRange &Range, uint64_t Offset,
-                                   MCAsmLayout &Layout) const;
-};
-
-} // namespace llvm
-
-#endif // LLVM_MC_MCCODEPADDER_H
diff --git a/linux-x64/clang/include/llvm/MC/MCCodeView.h b/linux-x64/clang/include/llvm/MC/MCCodeView.h
index 2126354..5770f37 100644
--- a/linux-x64/clang/include/llvm/MC/MCCodeView.h
+++ b/linux-x64/clang/include/llvm/MC/MCCodeView.h
@@ -166,8 +166,6 @@
                    unsigned FileNo, unsigned Line, unsigned Column,
                    bool PrologueEnd, bool IsStmt);
 
-  bool isValidCVFileNumber(unsigned FileNumber);
-
   /// Add a line entry.
   void addLineEntry(const MCCVLoc &LineEntry);
 
diff --git a/linux-x64/clang/include/llvm/MC/MCContext.h b/linux-x64/clang/include/llvm/MC/MCContext.h
index c40cd7c..49ab0ce 100644
--- a/linux-x64/clang/include/llvm/MC/MCContext.h
+++ b/linux-x64/clang/include/llvm/MC/MCContext.h
@@ -18,10 +18,13 @@
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/BinaryFormat/Dwarf.h"
+#include "llvm/BinaryFormat/ELF.h"
 #include "llvm/BinaryFormat/XCOFF.h"
 #include "llvm/MC/MCAsmMacro.h"
 #include "llvm/MC/MCDwarf.h"
+#include "llvm/MC/MCPseudoProbe.h"
 #include "llvm/MC/MCSubtargetInfo.h"
+#include "llvm/MC/MCTargetOptions.h"
 #include "llvm/MC/SectionKind.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/Compiler.h"
@@ -55,6 +58,7 @@
   class MCSymbol;
   class MCSymbolELF;
   class MCSymbolWasm;
+  class MCSymbolXCOFF;
   class SMLoc;
   class SourceMgr;
 
@@ -94,6 +98,7 @@
     SpecificBumpPtrAllocator<MCSectionMachO> MachOAllocator;
     SpecificBumpPtrAllocator<MCSectionWasm> WasmAllocator;
     SpecificBumpPtrAllocator<MCSectionXCOFF> XCOFFAllocator;
+    SpecificBumpPtrAllocator<MCInst> MCInstAllocator;
 
     /// Bindings of names to symbols.
     SymbolTable Symbols;
@@ -183,30 +188,42 @@
     /// The maximum version of dwarf that we should emit.
     uint16_t DwarfVersion = 4;
 
+    /// The format of dwarf that we emit.
+    dwarf::DwarfFormat DwarfFormat = dwarf::DWARF32;
+
     /// Honor temporary labels, this is useful for debugging semantic
     /// differences between temporary and non-temporary labels (primarily on
     /// Darwin).
     bool AllowTemporaryLabels = true;
-    bool UseNamesOnTempLabels = true;
+    bool UseNamesOnTempLabels = false;
 
     /// The Compile Unit ID that we are currently processing.
     unsigned DwarfCompileUnitID = 0;
 
+    /// A collection of MCPseudoProbe in the current module
+    MCPseudoProbeTable PseudoProbeTable;
+
+    // Sections are differentiated by the quadruple (section_name, group_name,
+    // unique_id, link_to_symbol_name). Sections sharing the same quadruple are
+    // combined into one section.
     struct ELFSectionKey {
       std::string SectionName;
       StringRef GroupName;
+      StringRef LinkedToName;
       unsigned UniqueID;
 
       ELFSectionKey(StringRef SectionName, StringRef GroupName,
-                    unsigned UniqueID)
-          : SectionName(SectionName), GroupName(GroupName), UniqueID(UniqueID) {
-      }
+                    StringRef LinkedToName, unsigned UniqueID)
+          : SectionName(SectionName), GroupName(GroupName),
+            LinkedToName(LinkedToName), UniqueID(UniqueID) {}
 
       bool operator<(const ELFSectionKey &Other) const {
         if (SectionName != Other.SectionName)
           return SectionName < Other.SectionName;
         if (GroupName != Other.GroupName)
           return GroupName < Other.GroupName;
+        if (int O = LinkedToName.compare(Other.LinkedToName))
+          return O < 0;
         return UniqueID < Other.UniqueID;
       }
     };
@@ -278,6 +295,8 @@
     /// Do automatic reset in destructor
     bool AutoReset;
 
+    MCTargetOptions const *TargetOptions;
+
     bool HadError = false;
 
     MCSymbol *createSymbolImpl(const StringMapEntry<bool> *Name,
@@ -293,15 +312,51 @@
                                        unsigned EntrySize,
                                        const MCSymbolELF *Group,
                                        unsigned UniqueID,
-                                       const MCSymbolELF *Associated);
+                                       const MCSymbolELF *LinkedToSym);
+
+    MCSymbolXCOFF *createXCOFFSymbolImpl(const StringMapEntry<bool> *Name,
+                                         bool IsTemporary);
 
     /// Map of currently defined macros.
     StringMap<MCAsmMacro> MacroMap;
 
+    struct ELFEntrySizeKey {
+      std::string SectionName;
+      unsigned Flags;
+      unsigned EntrySize;
+
+      ELFEntrySizeKey(StringRef SectionName, unsigned Flags, unsigned EntrySize)
+          : SectionName(SectionName), Flags(Flags), EntrySize(EntrySize) {}
+
+      bool operator<(const ELFEntrySizeKey &Other) const {
+        if (SectionName != Other.SectionName)
+          return SectionName < Other.SectionName;
+        if ((Flags & ELF::SHF_STRINGS) != (Other.Flags & ELF::SHF_STRINGS))
+          return Other.Flags & ELF::SHF_STRINGS;
+        return EntrySize < Other.EntrySize;
+      }
+    };
+
+    // Symbols must be assigned to a section with a compatible entry
+    // size. This map is used to assign unique IDs to sections to
+    // distinguish between sections with identical names but incompatible entry
+    // sizes. This can occur when a symbol is explicitly assigned to a
+    // section, e.g. via __attribute__((section("myname"))).
+    std::map<ELFEntrySizeKey, unsigned> ELFEntrySizeMap;
+
+    // This set is used to record the generic mergeable section names seen.
+    // These are sections that are created as mergeable e.g. .debug_str. We need
+    // to avoid assigning non-mergeable symbols to these sections. It is used
+    // to prevent non-mergeable symbols being explicitly assigned  to mergeable
+    // sections (e.g. via _attribute_((section("myname")))).
+    DenseSet<StringRef> ELFSeenGenericMergeableSections;
+
   public:
     explicit MCContext(const MCAsmInfo *MAI, const MCRegisterInfo *MRI,
                        const MCObjectFileInfo *MOFI,
-                       const SourceMgr *Mgr = nullptr, bool DoAutoReset = true);
+                       const SourceMgr *Mgr = nullptr,
+                       MCTargetOptions const *TargetOpts = nullptr,
+                       bool DoAutoReset = true);
     MCContext(const MCContext &) = delete;
     MCContext &operator=(const MCContext &) = delete;
     ~MCContext();
@@ -330,6 +385,11 @@
 
     /// @}
 
+    /// \name McInst Management
+
+    /// Create and return a new MC instruction.
+    MCInst *createMCInst();
+
     /// \name Symbol Management
     /// @{
 
@@ -337,12 +397,16 @@
     /// unspecified name.
     MCSymbol *createLinkerPrivateTempSymbol();
 
-    /// Create and return a new assembler temporary symbol with a unique but
-    /// unspecified name.
-    MCSymbol *createTempSymbol(bool CanBeUnnamed = true);
+    /// Create a temporary symbol with a unique name. The name will be omitted
+    /// in the symbol table if UseNamesOnTempLabels is false (default except
+    /// MCAsmStreamer). The overload without Name uses an unspecified name.
+    MCSymbol *createTempSymbol();
+    MCSymbol *createTempSymbol(const Twine &Name, bool AlwaysAddSuffix = true);
 
-    MCSymbol *createTempSymbol(const Twine &Name, bool AlwaysAddSuffix,
-                               bool CanBeUnnamed = true);
+    /// Create a temporary symbol with a unique name whose name cannot be
+    /// omitted in the symbol table. This is rarely used.
+    MCSymbol *createNamedTempSymbol();
+    MCSymbol *createNamedTempSymbol(const Twine &Name);
 
     /// Create the definition of a directional local symbol for numbered label
     /// (used for "1:" definitions).
@@ -424,25 +488,19 @@
     MCSectionELF *getELFSection(const Twine &Section, unsigned Type,
                                 unsigned Flags, unsigned EntrySize,
                                 const Twine &Group) {
-      return getELFSection(Section, Type, Flags, EntrySize, Group, ~0);
-    }
-
-    MCSectionELF *getELFSection(const Twine &Section, unsigned Type,
-                                unsigned Flags, unsigned EntrySize,
-                                const Twine &Group, unsigned UniqueID) {
-      return getELFSection(Section, Type, Flags, EntrySize, Group, UniqueID,
-                           nullptr);
+      return getELFSection(Section, Type, Flags, EntrySize, Group,
+                           MCSection::NonUniqueID, nullptr);
     }
 
     MCSectionELF *getELFSection(const Twine &Section, unsigned Type,
                                 unsigned Flags, unsigned EntrySize,
                                 const Twine &Group, unsigned UniqueID,
-                                const MCSymbolELF *Associated);
+                                const MCSymbolELF *LinkedToSym);
 
     MCSectionELF *getELFSection(const Twine &Section, unsigned Type,
                                 unsigned Flags, unsigned EntrySize,
                                 const MCSymbolELF *Group, unsigned UniqueID,
-                                const MCSymbolELF *Associated);
+                                const MCSymbolELF *LinkedToSym);
 
     /// Get a section with the provided group identifier. This section is
     /// named by concatenating \p Prefix with '.' then \p Suffix. The \p Type
@@ -461,6 +519,17 @@
 
     MCSectionELF *createELFGroupSection(const MCSymbolELF *Group);
 
+    void recordELFMergeableSectionInfo(StringRef SectionName, unsigned Flags,
+                                       unsigned UniqueID, unsigned EntrySize);
+
+    bool isELFImplicitMergeableSectionNamePrefix(StringRef Name);
+
+    bool isELFGenericMergeableSection(StringRef Name);
+
+    Optional<unsigned> getELFUniqueIDForEntsize(StringRef SectionName,
+                                                unsigned Flags,
+                                                unsigned EntrySize);
+
     MCSectionCOFF *getCOFFSection(StringRef Section, unsigned Characteristics,
                                   SectionKind Kind, StringRef COMDATSymName,
                                   int Selection,
@@ -503,7 +572,8 @@
 
     MCSectionXCOFF *getXCOFFSection(StringRef Section,
                                     XCOFF::StorageMappingClass MappingClass,
-                                    SectionKind K,
+                                    XCOFF::SymbolType CSectType, SectionKind K,
+                                    bool MultiSymbolsAllowed = false,
                                     const char *BeginSymName = nullptr);
 
     // Create and save a copy of STI and return a reference to the copy.
@@ -534,7 +604,7 @@
     const std::string &getMainFileName() const { return MainFileName; }
 
     /// Set the main file name and override the default.
-    void setMainFileName(StringRef S) { MainFileName = S; }
+    void setMainFileName(StringRef S) { MainFileName = std::string(S); }
 
     /// Creates an entry in the dwarf file and directory tables.
     Expected<unsigned> getDwarfFile(StringRef Directory, StringRef FileName,
@@ -644,10 +714,8 @@
     void setDwarfDebugProducer(StringRef S) { DwarfDebugProducer = S; }
     StringRef getDwarfDebugProducer() { return DwarfDebugProducer; }
 
-    dwarf::DwarfFormat getDwarfFormat() const {
-      // TODO: Support DWARF64
-      return dwarf::DWARF32;
-    }
+    void setDwarfFormat(dwarf::DwarfFormat f) { DwarfFormat = f; }
+    dwarf::DwarfFormat getDwarfFormat() const { return DwarfFormat; }
 
     void setDwarfVersion(uint16_t v) { DwarfVersion = v; }
     uint16_t getDwarfVersion() const { return DwarfVersion; }
@@ -672,6 +740,7 @@
 
     bool hadError() { return HadError; }
     void reportError(SMLoc L, const Twine &Msg);
+    void reportWarning(SMLoc L, const Twine &Msg);
     // Unrecoverable error has occurred. Display the best diagnostic we can
     // and bail via exit(1). For now, most MC backend errors are unrecoverable.
     // FIXME: We should really do something about that.
@@ -688,6 +757,8 @@
     }
 
     void undefineMacro(StringRef Name) { MacroMap.erase(Name); }
+
+    MCPseudoProbeTable &getMCPseudoProbeTable() { return PseudoProbeTable; }
   };
 
 } // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/MC/MCDirectives.h b/linux-x64/clang/include/llvm/MC/MCDirectives.h
index 4029264..51e57ad 100644
--- a/linux-x64/clang/include/llvm/MC/MCDirectives.h
+++ b/linux-x64/clang/include/llvm/MC/MCDirectives.h
@@ -16,33 +16,35 @@
 namespace llvm {
 
 enum MCSymbolAttr {
-  MCSA_Invalid = 0,    ///< Not a valid directive.
+  MCSA_Invalid = 0, ///< Not a valid directive.
 
   // Various directives in alphabetical order.
-  MCSA_Cold,                ///< .cold (MachO)
-  MCSA_ELF_TypeFunction,    ///< .type _foo, STT_FUNC  # aka @function
-  MCSA_ELF_TypeIndFunction, ///< .type _foo, STT_GNU_IFUNC
-  MCSA_ELF_TypeObject,      ///< .type _foo, STT_OBJECT  # aka @object
-  MCSA_ELF_TypeTLS,         ///< .type _foo, STT_TLS     # aka @tls_object
-  MCSA_ELF_TypeCommon,      ///< .type _foo, STT_COMMON  # aka @common
-  MCSA_ELF_TypeNoType,      ///< .type _foo, STT_NOTYPE  # aka @notype
+  MCSA_Cold,                    ///< .cold (MachO)
+  MCSA_ELF_TypeFunction,        ///< .type _foo, STT_FUNC  # aka @function
+  MCSA_ELF_TypeIndFunction,     ///< .type _foo, STT_GNU_IFUNC
+  MCSA_ELF_TypeObject,          ///< .type _foo, STT_OBJECT  # aka @object
+  MCSA_ELF_TypeTLS,             ///< .type _foo, STT_TLS     # aka @tls_object
+  MCSA_ELF_TypeCommon,          ///< .type _foo, STT_COMMON  # aka @common
+  MCSA_ELF_TypeNoType,          ///< .type _foo, STT_NOTYPE  # aka @notype
   MCSA_ELF_TypeGnuUniqueObject, /// .type _foo, @gnu_unique_object
-  MCSA_Global,              ///< .globl
-  MCSA_Hidden,              ///< .hidden (ELF)
-  MCSA_IndirectSymbol,      ///< .indirect_symbol (MachO)
-  MCSA_Internal,            ///< .internal (ELF)
-  MCSA_LazyReference,       ///< .lazy_reference (MachO)
-  MCSA_Local,               ///< .local (ELF)
-  MCSA_NoDeadStrip,         ///< .no_dead_strip (MachO)
-  MCSA_SymbolResolver,      ///< .symbol_resolver (MachO)
-  MCSA_AltEntry,            ///< .alt_entry (MachO)
-  MCSA_PrivateExtern,       ///< .private_extern (MachO)
-  MCSA_Protected,           ///< .protected (ELF)
-  MCSA_Reference,           ///< .reference (MachO)
-  MCSA_Weak,                ///< .weak
-  MCSA_WeakDefinition,      ///< .weak_definition (MachO)
-  MCSA_WeakReference,       ///< .weak_reference (MachO)
-  MCSA_WeakDefAutoPrivate   ///< .weak_def_can_be_hidden (MachO)
+  MCSA_Global,                  ///< .globl
+  MCSA_LGlobal,                 ///< .lglobl (XCOFF)
+  MCSA_Extern,                  ///< .extern (XCOFF)
+  MCSA_Hidden,                  ///< .hidden (ELF)
+  MCSA_IndirectSymbol,          ///< .indirect_symbol (MachO)
+  MCSA_Internal,                ///< .internal (ELF)
+  MCSA_LazyReference,           ///< .lazy_reference (MachO)
+  MCSA_Local,                   ///< .local (ELF)
+  MCSA_NoDeadStrip,             ///< .no_dead_strip (MachO)
+  MCSA_SymbolResolver,          ///< .symbol_resolver (MachO)
+  MCSA_AltEntry,                ///< .alt_entry (MachO)
+  MCSA_PrivateExtern,           ///< .private_extern (MachO)
+  MCSA_Protected,               ///< .protected (ELF)
+  MCSA_Reference,               ///< .reference (MachO)
+  MCSA_Weak,                    ///< .weak
+  MCSA_WeakDefinition,          ///< .weak_definition (MachO)
+  MCSA_WeakReference,           ///< .weak_reference (MachO)
+  MCSA_WeakDefAutoPrivate       ///< .weak_def_can_be_hidden (MachO)
 };
 
 enum MCAssemblerFlag {
diff --git a/linux-x64/clang/include/llvm/MC/MCDisassembler/MCDisassembler.h b/linux-x64/clang/include/llvm/MC/MCDisassembler/MCDisassembler.h
index 268f3cc..10037cd 100644
--- a/linux-x64/clang/include/llvm/MC/MCDisassembler/MCDisassembler.h
+++ b/linux-x64/clang/include/llvm/MC/MCDisassembler/MCDisassembler.h
@@ -9,14 +9,63 @@
 #ifndef LLVM_MC_MCDISASSEMBLER_MCDISASSEMBLER_H
 #define LLVM_MC_MCDISASSEMBLER_MCDISASSEMBLER_H
 
+#include "llvm/ADT/Optional.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/BinaryFormat/XCOFF.h"
 #include "llvm/MC/MCDisassembler/MCSymbolizer.h"
 #include <cstdint>
 #include <memory>
+#include <vector>
 
 namespace llvm {
 
+struct XCOFFSymbolInfo {
+  Optional<XCOFF::StorageMappingClass> StorageMappingClass;
+  Optional<uint32_t> Index;
+  bool IsLabel;
+  XCOFFSymbolInfo(Optional<XCOFF::StorageMappingClass> Smc,
+                  Optional<uint32_t> Idx, bool Label)
+      : StorageMappingClass(Smc), Index(Idx), IsLabel(Label) {}
+
+  bool operator<(const XCOFFSymbolInfo &SymInfo) const;
+};
+
+struct SymbolInfoTy {
+  uint64_t Addr;
+  StringRef Name;
+  union {
+    uint8_t Type;
+    XCOFFSymbolInfo XCOFFSymInfo;
+  };
+
+private:
+  bool IsXCOFF;
+
+public:
+  SymbolInfoTy(uint64_t Addr, StringRef Name,
+               Optional<XCOFF::StorageMappingClass> Smc, Optional<uint32_t> Idx,
+               bool Label)
+      : Addr(Addr), Name(Name), XCOFFSymInfo(Smc, Idx, Label), IsXCOFF(true) {}
+  SymbolInfoTy(uint64_t Addr, StringRef Name, uint8_t Type)
+      : Addr(Addr), Name(Name), Type(Type), IsXCOFF(false) {}
+  bool isXCOFF() const { return IsXCOFF; }
+
+private:
+  friend bool operator<(const SymbolInfoTy &P1, const SymbolInfoTy &P2) {
+    assert(P1.IsXCOFF == P2.IsXCOFF &&
+           "P1.IsXCOFF should be equal to P2.IsXCOFF.");
+    if (P1.IsXCOFF)
+      return std::tie(P1.Addr, P1.XCOFFSymInfo, P1.Name) <
+             std::tie(P2.Addr, P2.XCOFFSymInfo, P2.Name);
+
+    return std::tie(P1.Addr, P1.Name, P1.Type) <
+             std::tie(P2.Addr, P2.Name, P2.Type);
+  }
+};
+
+using SectionSymbolsTy = std::vector<SymbolInfoTy>;
+
 template <typename T> class ArrayRef;
-class StringRef;
 class MCContext;
 class MCInst;
 class MCSubtargetInfo;
@@ -69,7 +118,6 @@
   /// \param Address  - The address, in the memory space of region, of the first
   ///                   byte of the instruction.
   /// \param Bytes    - A reference to the actual bytes of the instruction.
-  /// \param VStream  - The stream to print warnings and diagnostic messages on.
   /// \param CStream  - The stream to print comments and annotations on.
   /// \return         - MCDisassembler::Success if the instruction is valid,
   ///                   MCDisassembler::SoftFail if the instruction was
@@ -77,25 +125,42 @@
   ///                   MCDisassembler::Fail if the instruction was invalid.
   virtual DecodeStatus getInstruction(MCInst &Instr, uint64_t &Size,
                                       ArrayRef<uint8_t> Bytes, uint64_t Address,
-                                      raw_ostream &VStream,
                                       raw_ostream &CStream) const = 0;
 
-  /// May parse any prelude that precedes instructions after the start of a
-  /// symbol. Needed for some targets, e.g. WebAssembly.
+  /// Used to perform separate target specific disassembly for a particular
+  /// symbol. May parse any prelude that precedes instructions after the
+  /// start of a symbol, or the entire symbol.
+  /// This is used for example by WebAssembly to decode preludes.
   ///
-  /// \param Name     - The name of the symbol.
+  /// Base implementation returns None. So all targets by default ignore to
+  /// treat symbols separately.
+  ///
+  /// \param Symbol   - The symbol.
   /// \param Size     - The number of bytes consumed.
   /// \param Address  - The address, in the memory space of region, of the first
   ///                   byte of the symbol.
   /// \param Bytes    - A reference to the actual bytes at the symbol location.
-  /// \param VStream  - The stream to print warnings and diagnostic messages on.
   /// \param CStream  - The stream to print comments and annotations on.
-  /// \return         - MCDisassembler::Success if the bytes are valid,
-  ///                   MCDisassembler::Fail if the bytes were invalid.
-  virtual DecodeStatus onSymbolStart(StringRef Name, uint64_t &Size,
-                                     ArrayRef<uint8_t> Bytes, uint64_t Address,
-                                     raw_ostream &VStream,
-                                     raw_ostream &CStream) const;
+  /// \return         - MCDisassembler::Success if bytes are decoded
+  ///                   successfully. Size must hold the number of bytes that
+  ///                   were decoded.
+  ///                 - MCDisassembler::Fail if the bytes are invalid. Size
+  ///                   must hold the number of bytes that were decoded before
+  ///                   failing. The target must print nothing. This can be
+  ///                   done by buffering the output if needed.
+  ///                 - None if the target doesn't want to handle the symbol
+  ///                   separately. Value of Size is ignored in this case.
+  virtual Optional<DecodeStatus>
+  onSymbolStart(SymbolInfoTy &Symbol, uint64_t &Size, ArrayRef<uint8_t> Bytes,
+                uint64_t Address, raw_ostream &CStream) const;
+  // TODO:
+  // Implement similar hooks that can be used at other points during
+  // disassembly. Something along the following lines:
+  // - onBeforeInstructionDecode()
+  // - onAfterInstructionDecode()
+  // - onSymbolEnd()
+  // It should help move much of the target specific code from llvm-objdump to
+  // respective target disassemblers.
 
 private:
   MCContext &Ctx;
diff --git a/linux-x64/clang/include/llvm/MC/MCDwarf.h b/linux-x64/clang/include/llvm/MC/MCDwarf.h
index 1a37aaf..70da5f7 100644
--- a/linux-x64/clang/include/llvm/MC/MCDwarf.h
+++ b/linux-x64/clang/include/llvm/MC/MCDwarf.h
@@ -41,6 +41,11 @@
 class SMLoc;
 class SourceMgr;
 
+namespace mcdwarf {
+// Emit the common part of the DWARF 5 range/locations list tables header.
+MCSymbol *emitListsTableHeaderStart(MCStreamer &S);
+} // namespace mcdwarf
+
 /// Instances of this class represent the name of the dwarf .file directive and
 /// its associated dwarf file number in the MC file. MCDwarfFile's are created
 /// and uniqued by the MCContext class. In Dwarf 4 file numbers start from 1;
@@ -54,7 +59,7 @@
   std::string Name;
 
   // The index into the list of directory names for this file name.
-  unsigned DirIndex;
+  unsigned DirIndex = 0;
 
   /// The MD5 checksum, if there is one. Non-owning pointer to data allocated
   /// in MCContext.
@@ -252,8 +257,8 @@
   void setRootFile(StringRef Directory, StringRef FileName,
                    Optional<MD5::MD5Result> Checksum,
                    Optional<StringRef> Source) {
-    CompilationDir = Directory;
-    RootFile.Name = FileName;
+    CompilationDir = std::string(Directory);
+    RootFile.Name = std::string(FileName);
     RootFile.DirIndex = 0;
     RootFile.Checksum = Checksum;
     RootFile.Source = Source;
@@ -325,8 +330,8 @@
 
   void setRootFile(StringRef Directory, StringRef FileName,
                    Optional<MD5::MD5Result> Checksum, Optional<StringRef> Source) {
-    Header.CompilationDir = Directory;
-    Header.RootFile.Name = FileName;
+    Header.CompilationDir = std::string(Directory);
+    Header.RootFile.Name = std::string(FileName);
     Header.RootFile.DirIndex = 0;
     Header.RootFile.Checksum = Checksum;
     Header.RootFile.Source = Source;
@@ -462,10 +467,12 @@
     unsigned Register2;
   };
   std::vector<char> Values;
+  std::string Comment;
 
-  MCCFIInstruction(OpType Op, MCSymbol *L, unsigned R, int O, StringRef V)
+  MCCFIInstruction(OpType Op, MCSymbol *L, unsigned R, int O, StringRef V,
+                   StringRef Comment = "")
       : Operation(Op), Label(L), Register(R), Offset(O),
-        Values(V.begin(), V.end()) {
+        Values(V.begin(), V.end()), Comment(Comment) {
     assert(Op != OpRegister);
   }
 
@@ -477,9 +484,9 @@
 public:
   /// .cfi_def_cfa defines a rule for computing CFA as: take address from
   /// Register and add Offset to it.
-  static MCCFIInstruction createDefCfa(MCSymbol *L, unsigned Register,
-                                       int Offset) {
-    return MCCFIInstruction(OpDefCfa, L, Register, -Offset, "");
+  static MCCFIInstruction cfiDefCfa(MCSymbol *L, unsigned Register,
+                                    int Offset) {
+    return MCCFIInstruction(OpDefCfa, L, Register, Offset, "");
   }
 
   /// .cfi_def_cfa_register modifies a rule for computing CFA. From now
@@ -491,8 +498,8 @@
   /// .cfi_def_cfa_offset modifies a rule for computing CFA. Register
   /// remains the same, but offset is new. Note that it is the absolute offset
   /// that will be added to a defined register to the compute CFA address.
-  static MCCFIInstruction createDefCfaOffset(MCSymbol *L, int Offset) {
-    return MCCFIInstruction(OpDefCfaOffset, L, 0, -Offset, "");
+  static MCCFIInstruction cfiDefCfaOffset(MCSymbol *L, int Offset) {
+    return MCCFIInstruction(OpDefCfaOffset, L, 0, Offset, "");
   }
 
   /// .cfi_adjust_cfa_offset Same as .cfi_def_cfa_offset, but
@@ -565,8 +572,9 @@
 
   /// .cfi_escape Allows the user to add arbitrary bytes to the unwind
   /// info.
-  static MCCFIInstruction createEscape(MCSymbol *L, StringRef Vals) {
-    return MCCFIInstruction(OpEscape, L, 0, 0, Vals);
+  static MCCFIInstruction createEscape(MCSymbol *L, StringRef Vals,
+                                       StringRef Comment = "") {
+    return MCCFIInstruction(OpEscape, L, 0, 0, Vals, Comment);
   }
 
   /// A special wrapper for .cfi_escape that indicates GNU_ARGS_SIZE
@@ -601,6 +609,10 @@
     assert(Operation == OpEscape);
     return StringRef(&Values[0], Values.size());
   }
+
+  StringRef getComment() const {
+    return Comment;
+  }
 };
 
 struct MCDwarfFrameInfo {
@@ -629,7 +641,8 @@
   static void Emit(MCObjectStreamer &streamer, MCAsmBackend *MAB, bool isEH);
   static void EmitAdvanceLoc(MCObjectStreamer &Streamer, uint64_t AddrDelta);
   static void EncodeAdvanceLoc(MCContext &Context, uint64_t AddrDelta,
-                               raw_ostream &OS);
+                               raw_ostream &OS, uint32_t *Offset = nullptr,
+                               uint32_t *Size = nullptr);
 };
 
 } // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/MC/MCELFObjectWriter.h b/linux-x64/clang/include/llvm/MC/MCELFObjectWriter.h
index 2d441fd..5d99c49 100644
--- a/linux-x64/clang/include/llvm/MC/MCELFObjectWriter.h
+++ b/linux-x64/clang/include/llvm/MC/MCELFObjectWriter.h
@@ -23,7 +23,6 @@
 class MCAssembler;
 class MCContext;
 class MCFixup;
-class MCObjectWriter;
 class MCSymbol;
 class MCSymbolELF;
 class MCValue;
@@ -65,7 +64,7 @@
 public:
   virtual ~MCELFObjectTargetWriter() = default;
 
-  virtual Triple::ObjectFormatType getFormat() const { return Triple::ELF; }
+  Triple::ObjectFormatType getFormat() const override { return Triple::ELF; }
   static bool classof(const MCObjectTargetWriter *W) {
     return W->getFormat() == Triple::ELF;
   }
@@ -130,14 +129,10 @@
   }
 
   // N64 relocation type setting
-  unsigned setRType(unsigned Value, unsigned Type) const {
-    return ((Type & R_TYPE_MASK) | ((Value & 0xff) << R_TYPE_SHIFT));
-  }
-  unsigned setRType2(unsigned Value, unsigned Type) const {
-    return (Type & R_TYPE2_MASK) | ((Value & 0xff) << R_TYPE2_SHIFT);
-  }
-  unsigned setRType3(unsigned Value, unsigned Type) const {
-    return (Type & R_TYPE3_MASK) | ((Value & 0xff) << R_TYPE3_SHIFT);
+  static unsigned setRTypes(unsigned Value1, unsigned Value2, unsigned Value3) {
+    return ((Value1 & 0xff) << R_TYPE_SHIFT) |
+           ((Value2 & 0xff) << R_TYPE2_SHIFT) |
+           ((Value3 & 0xff) << R_TYPE3_SHIFT);
   }
   unsigned setRSsym(unsigned Value, unsigned Type) const {
     return (Type & R_SSYM_MASK) | ((Value & 0xff) << R_SSYM_SHIFT);
diff --git a/linux-x64/clang/include/llvm/MC/MCELFStreamer.h b/linux-x64/clang/include/llvm/MC/MCELFStreamer.h
index 8838d53..f11629d 100644
--- a/linux-x64/clang/include/llvm/MC/MCELFStreamer.h
+++ b/linux-x64/clang/include/llvm/MC/MCELFStreamer.h
@@ -39,49 +39,50 @@
   /// @{
 
   void InitSections(bool NoExecStack) override;
-  void ChangeSection(MCSection *Section, const MCExpr *Subsection) override;
-  void EmitLabel(MCSymbol *Symbol, SMLoc Loc = SMLoc()) override;
-  void EmitLabel(MCSymbol *Symbol, SMLoc Loc, MCFragment *F) override;
-  void EmitAssemblerFlag(MCAssemblerFlag Flag) override;
-  void EmitThumbFunc(MCSymbol *Func) override;
-  void EmitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) override;
-  bool EmitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute) override;
-  void EmitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) override;
-  void EmitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
+  void changeSection(MCSection *Section, const MCExpr *Subsection) override;
+  void emitLabel(MCSymbol *Symbol, SMLoc Loc = SMLoc()) override;
+  void emitLabelAtPos(MCSymbol *Symbol, SMLoc Loc, MCFragment *F,
+                      uint64_t Offset) override;
+  void emitAssemblerFlag(MCAssemblerFlag Flag) override;
+  void emitThumbFunc(MCSymbol *Func) override;
+  void emitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) override;
+  bool emitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute) override;
+  void emitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) override;
+  void emitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
                         unsigned ByteAlignment) override;
 
   void emitELFSize(MCSymbol *Symbol, const MCExpr *Value) override;
   void emitELFSymverDirective(StringRef AliasName,
                               const MCSymbol *Aliasee) override;
 
-  void EmitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size,
+  void emitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size,
                              unsigned ByteAlignment) override;
 
-  void EmitZerofill(MCSection *Section, MCSymbol *Symbol = nullptr,
+  void emitZerofill(MCSection *Section, MCSymbol *Symbol = nullptr,
                     uint64_t Size = 0, unsigned ByteAlignment = 0,
                     SMLoc L = SMLoc()) override;
-  void EmitTBSSSymbol(MCSection *Section, MCSymbol *Symbol, uint64_t Size,
+  void emitTBSSSymbol(MCSection *Section, MCSymbol *Symbol, uint64_t Size,
                       unsigned ByteAlignment = 0) override;
-  void EmitValueImpl(const MCExpr *Value, unsigned Size,
+  void emitValueImpl(const MCExpr *Value, unsigned Size,
                      SMLoc Loc = SMLoc()) override;
 
-  void EmitIdent(StringRef IdentString) override;
+  void emitIdent(StringRef IdentString) override;
 
-  void EmitValueToAlignment(unsigned, int64_t, unsigned, unsigned) override;
+  void emitValueToAlignment(unsigned, int64_t, unsigned, unsigned) override;
 
   void emitCGProfileEntry(const MCSymbolRefExpr *From,
                           const MCSymbolRefExpr *To, uint64_t Count) override;
 
-  void FinishImpl() override;
+  void finishImpl() override;
 
-  void EmitBundleAlignMode(unsigned AlignPow2) override;
-  void EmitBundleLock(bool AlignToEnd) override;
-  void EmitBundleUnlock() override;
+  void emitBundleAlignMode(unsigned AlignPow2) override;
+  void emitBundleLock(bool AlignToEnd) override;
+  void emitBundleUnlock() override;
 
 private:
   bool isBundleLocked() const;
-  void EmitInstToFragment(const MCInst &Inst, const MCSubtargetInfo &) override;
-  void EmitInstToData(const MCInst &Inst, const MCSubtargetInfo &) override;
+  void emitInstToFragment(const MCInst &Inst, const MCSubtargetInfo &) override;
+  void emitInstToData(const MCInst &Inst, const MCSubtargetInfo &) override;
 
   void fixSymbolsInTLSFixups(const MCExpr *expr);
   void finalizeCGProfileEntry(const MCSymbolRefExpr *&S);
@@ -101,7 +102,7 @@
                                     std::unique_ptr<MCAsmBackend> TAB,
                                     std::unique_ptr<MCObjectWriter> OW,
                                     std::unique_ptr<MCCodeEmitter> Emitter,
-                                    bool RelaxAll, bool IsThumb);
+                                    bool RelaxAll, bool IsThumb, bool IsAndroid);
 
 } // end namespace llvm
 
diff --git a/linux-x64/clang/include/llvm/MC/MCExpr.h b/linux-x64/clang/include/llvm/MC/MCExpr.h
index 7d9b265..3ffc845 100644
--- a/linux-x64/clang/include/llvm/MC/MCExpr.h
+++ b/linux-x64/clang/include/llvm/MC/MCExpr.h
@@ -34,7 +34,7 @@
 /// needed for parsing.
 class MCExpr {
 public:
-  enum ExprKind {
+  enum ExprKind : uint8_t {
     Binary,    ///< Binary expressions.
     Constant,  ///< Constant expressions.
     SymbolRef, ///< References to labels and assigned expressions.
@@ -43,25 +43,34 @@
   };
 
 private:
-  ExprKind Kind;
-  SMLoc Loc;
+  static const unsigned NumSubclassDataBits = 24;
+  static_assert(
+      NumSubclassDataBits == CHAR_BIT * (sizeof(unsigned) - sizeof(ExprKind)),
+      "ExprKind and SubclassData together should take up one word");
 
-  bool evaluateAsAbsolute(int64_t &Res, const MCAssembler *Asm,
-                          const MCAsmLayout *Layout,
-                          const SectionAddrMap *Addrs) const;
+  ExprKind Kind;
+  /// Field reserved for use by MCExpr subclasses.
+  unsigned SubclassData : NumSubclassDataBits;
+  SMLoc Loc;
 
   bool evaluateAsAbsolute(int64_t &Res, const MCAssembler *Asm,
                           const MCAsmLayout *Layout,
                           const SectionAddrMap *Addrs, bool InSet) const;
 
 protected:
-  explicit MCExpr(ExprKind Kind, SMLoc Loc) : Kind(Kind), Loc(Loc) {}
+  explicit MCExpr(ExprKind Kind, SMLoc Loc, unsigned SubclassData = 0)
+      : Kind(Kind), SubclassData(SubclassData), Loc(Loc) {
+    assert(SubclassData < (1 << NumSubclassDataBits) &&
+           "Subclass data too large");
+  }
 
   bool evaluateAsRelocatableImpl(MCValue &Res, const MCAssembler *Asm,
                                  const MCAsmLayout *Layout,
                                  const MCFixup *Fixup,
                                  const SectionAddrMap *Addrs, bool InSet) const;
 
+  unsigned getSubclassData() const { return SubclassData; }
+
 public:
   MCExpr(const MCExpr &) = delete;
   MCExpr &operator=(const MCExpr &) = delete;
@@ -135,20 +144,38 @@
 class MCConstantExpr : public MCExpr {
   int64_t Value;
 
-  explicit MCConstantExpr(int64_t Value)
-      : MCExpr(MCExpr::Constant, SMLoc()), Value(Value) {}
+  // Subclass data stores SizeInBytes in bits 0..7 and PrintInHex in bit 8.
+  static const unsigned SizeInBytesBits = 8;
+  static const unsigned SizeInBytesMask = (1 << SizeInBytesBits) - 1;
+  static const unsigned PrintInHexBit = 1 << SizeInBytesBits;
+
+  static unsigned encodeSubclassData(bool PrintInHex, unsigned SizeInBytes) {
+    assert(SizeInBytes <= sizeof(int64_t) && "Excessive size");
+    return SizeInBytes | (PrintInHex ? PrintInHexBit : 0);
+  }
+
+  MCConstantExpr(int64_t Value, bool PrintInHex, unsigned SizeInBytes)
+      : MCExpr(MCExpr::Constant, SMLoc(),
+               encodeSubclassData(PrintInHex, SizeInBytes)), Value(Value) {}
 
 public:
   /// \name Construction
   /// @{
 
-  static const MCConstantExpr *create(int64_t Value, MCContext &Ctx);
+  static const MCConstantExpr *create(int64_t Value, MCContext &Ctx,
+                                      bool PrintInHex = false,
+                                      unsigned SizeInBytes = 0);
 
   /// @}
   /// \name Accessors
   /// @{
 
   int64_t getValue() const { return Value; }
+  unsigned getSizeInBytes() const {
+    return getSubclassData() & SizeInBytesMask;
+  }
+
+  bool useHexFormat() const { return (getSubclassData() & PrintInHexBit) != 0; }
 
   /// @}
 
@@ -171,6 +198,7 @@
     VK_GOT,
     VK_GOTOFF,
     VK_GOTREL,
+    VK_PCREL,
     VK_GOTPCREL,
     VK_GOTTPOFF,
     VK_INDNTPOFF,
@@ -182,9 +210,9 @@
     VK_TLSLDM,
     VK_TPOFF,
     VK_DTPOFF,
-    VK_TLSCALL,   // symbol(tlscall)
-    VK_TLSDESC,   // symbol(tlsdesc)
-    VK_TLVP,      // Mach-O thread local variable relocations
+    VK_TLSCALL, // symbol(tlscall)
+    VK_TLSDESC, // symbol(tlsdesc)
+    VK_TLVP,    // Mach-O thread local variable relocations
     VK_TLVPPAGE,
     VK_TLVPPAGEOFF,
     VK_PAGE,
@@ -192,18 +220,19 @@
     VK_GOTPAGE,
     VK_GOTPAGEOFF,
     VK_SECREL,
-    VK_SIZE,      // symbol@SIZE
-    VK_WEAKREF,   // The link between the symbols in .weakref foo, bar
+    VK_SIZE,    // symbol@SIZE
+    VK_WEAKREF, // The link between the symbols in .weakref foo, bar
 
     VK_X86_ABS8,
+    VK_X86_PLTOFF,
 
     VK_ARM_NONE,
     VK_ARM_GOT_PREL,
     VK_ARM_TARGET1,
     VK_ARM_TARGET2,
     VK_ARM_PREL31,
-    VK_ARM_SBREL,          // symbol(sbrel)
-    VK_ARM_TLSLDO,         // symbol(tlsldo)
+    VK_ARM_SBREL,  // symbol(sbrel)
+    VK_ARM_TLSLDO, // symbol(tlsldo)
     VK_ARM_TLSDESCSEQ,
 
     VK_AVR_NONE,
@@ -214,66 +243,74 @@
     VK_AVR_DIFF16,
     VK_AVR_DIFF32,
 
-    VK_PPC_LO,             // symbol@l
-    VK_PPC_HI,             // symbol@h
-    VK_PPC_HA,             // symbol@ha
-    VK_PPC_HIGH,           // symbol@high
-    VK_PPC_HIGHA,          // symbol@higha
-    VK_PPC_HIGHER,         // symbol@higher
-    VK_PPC_HIGHERA,        // symbol@highera
-    VK_PPC_HIGHEST,        // symbol@highest
-    VK_PPC_HIGHESTA,       // symbol@highesta
-    VK_PPC_GOT_LO,         // symbol@got@l
-    VK_PPC_GOT_HI,         // symbol@got@h
-    VK_PPC_GOT_HA,         // symbol@got@ha
-    VK_PPC_TOCBASE,        // symbol@tocbase
-    VK_PPC_TOC,            // symbol@toc
-    VK_PPC_TOC_LO,         // symbol@toc@l
-    VK_PPC_TOC_HI,         // symbol@toc@h
-    VK_PPC_TOC_HA,         // symbol@toc@ha
-    VK_PPC_DTPMOD,         // symbol@dtpmod
-    VK_PPC_TPREL_LO,       // symbol@tprel@l
-    VK_PPC_TPREL_HI,       // symbol@tprel@h
-    VK_PPC_TPREL_HA,       // symbol@tprel@ha
-    VK_PPC_TPREL_HIGH,     // symbol@tprel@high
-    VK_PPC_TPREL_HIGHA,    // symbol@tprel@higha
-    VK_PPC_TPREL_HIGHER,   // symbol@tprel@higher
-    VK_PPC_TPREL_HIGHERA,  // symbol@tprel@highera
-    VK_PPC_TPREL_HIGHEST,  // symbol@tprel@highest
-    VK_PPC_TPREL_HIGHESTA, // symbol@tprel@highesta
-    VK_PPC_DTPREL_LO,      // symbol@dtprel@l
-    VK_PPC_DTPREL_HI,      // symbol@dtprel@h
-    VK_PPC_DTPREL_HA,      // symbol@dtprel@ha
-    VK_PPC_DTPREL_HIGH,    // symbol@dtprel@high
-    VK_PPC_DTPREL_HIGHA,   // symbol@dtprel@higha
-    VK_PPC_DTPREL_HIGHER,  // symbol@dtprel@higher
-    VK_PPC_DTPREL_HIGHERA, // symbol@dtprel@highera
-    VK_PPC_DTPREL_HIGHEST, // symbol@dtprel@highest
-    VK_PPC_DTPREL_HIGHESTA,// symbol@dtprel@highesta
-    VK_PPC_GOT_TPREL,      // symbol@got@tprel
-    VK_PPC_GOT_TPREL_LO,   // symbol@got@tprel@l
-    VK_PPC_GOT_TPREL_HI,   // symbol@got@tprel@h
-    VK_PPC_GOT_TPREL_HA,   // symbol@got@tprel@ha
-    VK_PPC_GOT_DTPREL,     // symbol@got@dtprel
-    VK_PPC_GOT_DTPREL_LO,  // symbol@got@dtprel@l
-    VK_PPC_GOT_DTPREL_HI,  // symbol@got@dtprel@h
-    VK_PPC_GOT_DTPREL_HA,  // symbol@got@dtprel@ha
-    VK_PPC_TLS,            // symbol@tls
-    VK_PPC_GOT_TLSGD,      // symbol@got@tlsgd
-    VK_PPC_GOT_TLSGD_LO,   // symbol@got@tlsgd@l
-    VK_PPC_GOT_TLSGD_HI,   // symbol@got@tlsgd@h
-    VK_PPC_GOT_TLSGD_HA,   // symbol@got@tlsgd@ha
-    VK_PPC_TLSGD,          // symbol@tlsgd
-    VK_PPC_GOT_TLSLD,      // symbol@got@tlsld
-    VK_PPC_GOT_TLSLD_LO,   // symbol@got@tlsld@l
-    VK_PPC_GOT_TLSLD_HI,   // symbol@got@tlsld@h
-    VK_PPC_GOT_TLSLD_HA,   // symbol@got@tlsld@ha
-    VK_PPC_TLSLD,          // symbol@tlsld
-    VK_PPC_LOCAL,          // symbol@local
+    VK_PPC_LO,              // symbol@l
+    VK_PPC_HI,              // symbol@h
+    VK_PPC_HA,              // symbol@ha
+    VK_PPC_HIGH,            // symbol@high
+    VK_PPC_HIGHA,           // symbol@higha
+    VK_PPC_HIGHER,          // symbol@higher
+    VK_PPC_HIGHERA,         // symbol@highera
+    VK_PPC_HIGHEST,         // symbol@highest
+    VK_PPC_HIGHESTA,        // symbol@highesta
+    VK_PPC_GOT_LO,          // symbol@got@l
+    VK_PPC_GOT_HI,          // symbol@got@h
+    VK_PPC_GOT_HA,          // symbol@got@ha
+    VK_PPC_TOCBASE,         // symbol@tocbase
+    VK_PPC_TOC,             // symbol@toc
+    VK_PPC_TOC_LO,          // symbol@toc@l
+    VK_PPC_TOC_HI,          // symbol@toc@h
+    VK_PPC_TOC_HA,          // symbol@toc@ha
+    VK_PPC_U,               // symbol@u
+    VK_PPC_L,               // symbol@l
+    VK_PPC_DTPMOD,          // symbol@dtpmod
+    VK_PPC_TPREL_LO,        // symbol@tprel@l
+    VK_PPC_TPREL_HI,        // symbol@tprel@h
+    VK_PPC_TPREL_HA,        // symbol@tprel@ha
+    VK_PPC_TPREL_HIGH,      // symbol@tprel@high
+    VK_PPC_TPREL_HIGHA,     // symbol@tprel@higha
+    VK_PPC_TPREL_HIGHER,    // symbol@tprel@higher
+    VK_PPC_TPREL_HIGHERA,   // symbol@tprel@highera
+    VK_PPC_TPREL_HIGHEST,   // symbol@tprel@highest
+    VK_PPC_TPREL_HIGHESTA,  // symbol@tprel@highesta
+    VK_PPC_DTPREL_LO,       // symbol@dtprel@l
+    VK_PPC_DTPREL_HI,       // symbol@dtprel@h
+    VK_PPC_DTPREL_HA,       // symbol@dtprel@ha
+    VK_PPC_DTPREL_HIGH,     // symbol@dtprel@high
+    VK_PPC_DTPREL_HIGHA,    // symbol@dtprel@higha
+    VK_PPC_DTPREL_HIGHER,   // symbol@dtprel@higher
+    VK_PPC_DTPREL_HIGHERA,  // symbol@dtprel@highera
+    VK_PPC_DTPREL_HIGHEST,  // symbol@dtprel@highest
+    VK_PPC_DTPREL_HIGHESTA, // symbol@dtprel@highesta
+    VK_PPC_GOT_TPREL,       // symbol@got@tprel
+    VK_PPC_GOT_TPREL_LO,    // symbol@got@tprel@l
+    VK_PPC_GOT_TPREL_HI,    // symbol@got@tprel@h
+    VK_PPC_GOT_TPREL_HA,    // symbol@got@tprel@ha
+    VK_PPC_GOT_DTPREL,      // symbol@got@dtprel
+    VK_PPC_GOT_DTPREL_LO,   // symbol@got@dtprel@l
+    VK_PPC_GOT_DTPREL_HI,   // symbol@got@dtprel@h
+    VK_PPC_GOT_DTPREL_HA,   // symbol@got@dtprel@ha
+    VK_PPC_TLS,             // symbol@tls
+    VK_PPC_GOT_TLSGD,       // symbol@got@tlsgd
+    VK_PPC_GOT_TLSGD_LO,    // symbol@got@tlsgd@l
+    VK_PPC_GOT_TLSGD_HI,    // symbol@got@tlsgd@h
+    VK_PPC_GOT_TLSGD_HA,    // symbol@got@tlsgd@ha
+    VK_PPC_TLSGD,           // symbol@tlsgd
+    VK_PPC_GOT_TLSLD,       // symbol@got@tlsld
+    VK_PPC_GOT_TLSLD_LO,    // symbol@got@tlsld@l
+    VK_PPC_GOT_TLSLD_HI,    // symbol@got@tlsld@h
+    VK_PPC_GOT_TLSLD_HA,    // symbol@got@tlsld@ha
+    VK_PPC_GOT_PCREL,       // symbol@got@pcrel
+    VK_PPC_GOT_TLSGD_PCREL, // symbol@got@tlsgd@pcrel
+    VK_PPC_GOT_TLSLD_PCREL, // symbol@got@tlsld@pcrel
+    VK_PPC_GOT_TPREL_PCREL, // symbol@got@tprel@pcrel
+    VK_PPC_TLS_PCREL,       // symbol@tls@pcrel
+    VK_PPC_TLSLD,           // symbol@tlsld
+    VK_PPC_LOCAL,           // symbol@local
+    VK_PPC_NOTOC,           // symbol@notoc
+    VK_PPC_PCREL_OPT,       // .reloc expr, R_PPC64_PCREL_OPT, expr
 
     VK_COFF_IMGREL32, // symbol@imgrel (image-relative)
 
-    VK_Hexagon_PCREL,
     VK_Hexagon_LO16,
     VK_Hexagon_HI16,
     VK_Hexagon_GPREL,
@@ -285,8 +322,9 @@
     VK_Hexagon_IE_GOT,
 
     VK_WASM_TYPEINDEX, // Reference to a symbol's type (signature)
-    VK_WASM_MBREL,     // Memory address relative to memory base
-    VK_WASM_TBREL,     // Table index relative to table bare
+    VK_WASM_TLSREL,    // Memory address relative to __tls_base
+    VK_WASM_MBREL,     // Memory address relative to __memory_base
+    VK_WASM_TBREL,     // Table index relative to __table_base
 
     VK_AMDGPU_GOTPCREL32_LO, // symbol@gotpcrel32@lo
     VK_AMDGPU_GOTPCREL32_HI, // symbol@gotpcrel32@hi
@@ -296,23 +334,43 @@
     VK_AMDGPU_ABS32_LO,      // symbol@abs32@lo
     VK_AMDGPU_ABS32_HI,      // symbol@abs32@hi
 
+    VK_VE_HI32,        // symbol@hi
+    VK_VE_LO32,        // symbol@lo
+    VK_VE_PC_HI32,     // symbol@pc_hi
+    VK_VE_PC_LO32,     // symbol@pc_lo
+    VK_VE_GOT_HI32,    // symbol@got_hi
+    VK_VE_GOT_LO32,    // symbol@got_lo
+    VK_VE_GOTOFF_HI32, // symbol@gotoff_hi
+    VK_VE_GOTOFF_LO32, // symbol@gotoff_lo
+    VK_VE_PLT_HI32,    // symbol@plt_hi
+    VK_VE_PLT_LO32,    // symbol@plt_lo
+    VK_VE_TLS_GD_HI32, // symbol@tls_gd_hi
+    VK_VE_TLS_GD_LO32, // symbol@tls_gd_lo
+    VK_VE_TPOFF_HI32,  // symbol@tpoff_hi
+    VK_VE_TPOFF_LO32,  // symbol@tpoff_lo
+
     VK_TPREL,
     VK_DTPREL
   };
 
 private:
-  /// The symbol reference modifier.
-  const VariantKind Kind;
-
-  /// Specifies how the variant kind should be printed.
-  const unsigned UseParensForSymbolVariant : 1;
-
-  // FIXME: Remove this bit.
-  const unsigned HasSubsectionsViaSymbols : 1;
-
   /// The symbol being referenced.
   const MCSymbol *Symbol;
 
+  // Subclass data stores VariantKind in bits 0..15 and HasSubsectionsViaSymbols
+  // in bit 16.
+  static const unsigned VariantKindBits = 16;
+  static const unsigned VariantKindMask = (1 << VariantKindBits) - 1;
+
+  // FIXME: Remove this bit.
+  static const unsigned HasSubsectionsViaSymbolsBit = 1 << VariantKindBits;
+
+  static unsigned encodeSubclassData(VariantKind Kind,
+                                     bool HasSubsectionsViaSymbols) {
+    return (unsigned)Kind |
+           (HasSubsectionsViaSymbols ? HasSubsectionsViaSymbolsBit : 0);
+  }
+
   explicit MCSymbolRefExpr(const MCSymbol *Symbol, VariantKind Kind,
                            const MCAsmInfo *MAI, SMLoc Loc = SMLoc());
 
@@ -335,11 +393,13 @@
 
   const MCSymbol &getSymbol() const { return *Symbol; }
 
-  VariantKind getKind() const { return Kind; }
+  VariantKind getKind() const {
+    return (VariantKind)(getSubclassData() & VariantKindMask);
+  }
 
-  void printVariantKind(raw_ostream &OS) const;
-
-  bool hasSubsectionsViaSymbols() const { return HasSubsectionsViaSymbols; }
+  bool hasSubsectionsViaSymbols() const {
+    return (getSubclassData() & HasSubsectionsViaSymbolsBit) != 0;
+  }
 
   /// @}
   /// \name Static Utility Functions
@@ -367,11 +427,10 @@
   };
 
 private:
-  Opcode Op;
   const MCExpr *Expr;
 
   MCUnaryExpr(Opcode Op, const MCExpr *Expr, SMLoc Loc)
-      : MCExpr(MCExpr::Unary, Loc), Op(Op), Expr(Expr) {}
+      : MCExpr(MCExpr::Unary, Loc, Op), Expr(Expr) {}
 
 public:
   /// \name Construction
@@ -401,7 +460,7 @@
   /// @{
 
   /// Get the kind of this unary expression.
-  Opcode getOpcode() const { return Op; }
+  Opcode getOpcode() const { return (Opcode)getSubclassData(); }
 
   /// Get the child of this unary expression.
   const MCExpr *getSubExpr() const { return Expr; }
@@ -435,6 +494,7 @@
     Mul,  ///< Multiplication.
     NE,   ///< Inequality comparison.
     Or,   ///< Bitwise or.
+    OrNot, ///< Bitwise or not.
     Shl,  ///< Shift left.
     AShr, ///< Arithmetic shift right.
     LShr, ///< Logical shift right.
@@ -443,12 +503,11 @@
   };
 
 private:
-  Opcode Op;
   const MCExpr *LHS, *RHS;
 
   MCBinaryExpr(Opcode Op, const MCExpr *LHS, const MCExpr *RHS,
                SMLoc Loc = SMLoc())
-      : MCExpr(MCExpr::Binary, Loc), Op(Op), LHS(LHS), RHS(RHS) {}
+      : MCExpr(MCExpr::Binary, Loc, Op), LHS(LHS), RHS(RHS) {}
 
 public:
   /// \name Construction
@@ -558,7 +617,7 @@
   /// @{
 
   /// Get the kind of this binary expression.
-  Opcode getOpcode() const { return Op; }
+  Opcode getOpcode() const { return (Opcode)getSubclassData(); }
 
   /// Get the left-hand side expression of the binary operator.
   const MCExpr *getLHS() const { return LHS; }
diff --git a/linux-x64/clang/include/llvm/MC/MCFixup.h b/linux-x64/clang/include/llvm/MC/MCFixup.h
index accffb7..b3a2391 100644
--- a/linux-x64/clang/include/llvm/MC/MCFixup.h
+++ b/linux-x64/clang/include/llvm/MC/MCFixup.h
@@ -9,7 +9,6 @@
 #ifndef LLVM_MC_MCFIXUP_H
 #define LLVM_MC_MCFIXUP_H
 
-#include "llvm/MC/MCExpr.h"
 #include "llvm/Support/DataTypes.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/SMLoc.h"
@@ -20,41 +19,49 @@
 
 /// Extensible enumeration to represent the type of a fixup.
 enum MCFixupKind {
-  FK_NONE = 0,   ///< A no-op fixup.
-  FK_Data_1,     ///< A one-byte fixup.
-  FK_Data_2,     ///< A two-byte fixup.
-  FK_Data_4,     ///< A four-byte fixup.
-  FK_Data_8,     ///< A eight-byte fixup.
-  FK_PCRel_1,    ///< A one-byte pc relative fixup.
-  FK_PCRel_2,    ///< A two-byte pc relative fixup.
-  FK_PCRel_4,    ///< A four-byte pc relative fixup.
-  FK_PCRel_8,    ///< A eight-byte pc relative fixup.
-  FK_GPRel_1,    ///< A one-byte gp relative fixup.
-  FK_GPRel_2,    ///< A two-byte gp relative fixup.
-  FK_GPRel_4,    ///< A four-byte gp relative fixup.
-  FK_GPRel_8,    ///< A eight-byte gp relative fixup.
-  FK_DTPRel_4,   ///< A four-byte dtp relative fixup.
-  FK_DTPRel_8,   ///< A eight-byte dtp relative fixup.
-  FK_TPRel_4,    ///< A four-byte tp relative fixup.
-  FK_TPRel_8,    ///< A eight-byte tp relative fixup.
-  FK_SecRel_1,   ///< A one-byte section relative fixup.
-  FK_SecRel_2,   ///< A two-byte section relative fixup.
-  FK_SecRel_4,   ///< A four-byte section relative fixup.
-  FK_SecRel_8,   ///< A eight-byte section relative fixup.
-  FK_Data_Add_1, ///< A one-byte add fixup.
-  FK_Data_Add_2, ///< A two-byte add fixup.
-  FK_Data_Add_4, ///< A four-byte add fixup.
-  FK_Data_Add_8, ///< A eight-byte add fixup.
-  FK_Data_Sub_1, ///< A one-byte sub fixup.
-  FK_Data_Sub_2, ///< A two-byte sub fixup.
-  FK_Data_Sub_4, ///< A four-byte sub fixup.
-  FK_Data_Sub_8, ///< A eight-byte sub fixup.
+  FK_NONE = 0,    ///< A no-op fixup.
+  FK_Data_1,      ///< A one-byte fixup.
+  FK_Data_2,      ///< A two-byte fixup.
+  FK_Data_4,      ///< A four-byte fixup.
+  FK_Data_8,      ///< A eight-byte fixup.
+  FK_Data_6b,     ///< A six-bits fixup.
+  FK_PCRel_1,     ///< A one-byte pc relative fixup.
+  FK_PCRel_2,     ///< A two-byte pc relative fixup.
+  FK_PCRel_4,     ///< A four-byte pc relative fixup.
+  FK_PCRel_8,     ///< A eight-byte pc relative fixup.
+  FK_GPRel_1,     ///< A one-byte gp relative fixup.
+  FK_GPRel_2,     ///< A two-byte gp relative fixup.
+  FK_GPRel_4,     ///< A four-byte gp relative fixup.
+  FK_GPRel_8,     ///< A eight-byte gp relative fixup.
+  FK_DTPRel_4,    ///< A four-byte dtp relative fixup.
+  FK_DTPRel_8,    ///< A eight-byte dtp relative fixup.
+  FK_TPRel_4,     ///< A four-byte tp relative fixup.
+  FK_TPRel_8,     ///< A eight-byte tp relative fixup.
+  FK_SecRel_1,    ///< A one-byte section relative fixup.
+  FK_SecRel_2,    ///< A two-byte section relative fixup.
+  FK_SecRel_4,    ///< A four-byte section relative fixup.
+  FK_SecRel_8,    ///< A eight-byte section relative fixup.
+  FK_Data_Add_1,  ///< A one-byte add fixup.
+  FK_Data_Add_2,  ///< A two-byte add fixup.
+  FK_Data_Add_4,  ///< A four-byte add fixup.
+  FK_Data_Add_8,  ///< A eight-byte add fixup.
+  FK_Data_Add_6b, ///< A six-bits add fixup.
+  FK_Data_Sub_1,  ///< A one-byte sub fixup.
+  FK_Data_Sub_2,  ///< A two-byte sub fixup.
+  FK_Data_Sub_4,  ///< A four-byte sub fixup.
+  FK_Data_Sub_8,  ///< A eight-byte sub fixup.
+  FK_Data_Sub_6b, ///< A six-bits sub fixup.
 
   FirstTargetFixupKind = 128,
 
-  // Limit range of target fixups, in case we want to pack more efficiently
-  // later.
-  MaxTargetFixupKind = (1 << 8)
+  /// The range [FirstLiteralRelocationKind, MaxTargetFixupKind) is used for
+  /// relocations coming from .reloc directive. Fixup kind
+  /// FirstLiteralRelocationKind+V represents the relocation type with number V.
+  FirstLiteralRelocationKind = 256,
+
+  /// Set limit to accommodate the highest reloc type in use for all Targets,
+  /// currently R_AARCH64_IRELATIVE at 1032, including room for expansion.
+  MaxFixupKind = FirstLiteralRelocationKind + 1032 + 32,
 };
 
 /// Encode information on a single operation to perform on a byte
@@ -75,25 +82,25 @@
   /// The value to put into the fixup location. The exact interpretation of the
   /// expression is target dependent, usually it will be one of the operands to
   /// an instruction or an assembler directive.
-  const MCExpr *Value;
+  const MCExpr *Value = nullptr;
 
   /// The byte index of start of the relocation inside the MCFragment.
-  uint32_t Offset;
+  uint32_t Offset = 0;
 
   /// The target dependent kind of fixup item this is. The kind is used to
   /// determine how the operand value should be encoded into the instruction.
-  unsigned Kind;
+  MCFixupKind Kind = FK_NONE;
 
   /// The source location which gave rise to the fixup, if any.
   SMLoc Loc;
 public:
   static MCFixup create(uint32_t Offset, const MCExpr *Value,
                         MCFixupKind Kind, SMLoc Loc = SMLoc()) {
-    assert(unsigned(Kind) < MaxTargetFixupKind && "Kind out of range!");
+    assert(Kind <= MaxFixupKind && "Kind out of range!");
     MCFixup FI;
     FI.Value = Value;
     FI.Offset = Offset;
-    FI.Kind = unsigned(Kind);
+    FI.Kind = Kind;
     FI.Loc = Loc;
     return FI;
   }
@@ -104,7 +111,7 @@
     MCFixup FI;
     FI.Value = Fixup.getValue();
     FI.Offset = Fixup.getOffset();
-    FI.Kind = (unsigned)getAddKindForKind(Fixup.getKind());
+    FI.Kind = getAddKindForKind(Fixup.getKind());
     FI.Loc = Fixup.getLoc();
     return FI;
   }
@@ -115,12 +122,14 @@
     MCFixup FI;
     FI.Value = Fixup.getValue();
     FI.Offset = Fixup.getOffset();
-    FI.Kind = (unsigned)getSubKindForKind(Fixup.getKind());
+    FI.Kind = getSubKindForKind(Fixup.getKind());
     FI.Loc = Fixup.getLoc();
     return FI;
   }
 
-  MCFixupKind getKind() const { return MCFixupKind(Kind); }
+  MCFixupKind getKind() const { return Kind; }
+
+  unsigned getTargetKind() const { return Kind; }
 
   uint32_t getOffset() const { return Offset; }
   void setOffset(uint32_t Value) { Offset = Value; }
@@ -129,37 +138,63 @@
 
   /// Return the generic fixup kind for a value with the given size. It
   /// is an error to pass an unsupported size.
-  static MCFixupKind getKindForSize(unsigned Size, bool isPCRel) {
+  static MCFixupKind getKindForSize(unsigned Size, bool IsPCRel) {
     switch (Size) {
     default: llvm_unreachable("Invalid generic fixup size!");
-    case 1: return isPCRel ? FK_PCRel_1 : FK_Data_1;
-    case 2: return isPCRel ? FK_PCRel_2 : FK_Data_2;
-    case 4: return isPCRel ? FK_PCRel_4 : FK_Data_4;
-    case 8: return isPCRel ? FK_PCRel_8 : FK_Data_8;
+    case 1:
+      return IsPCRel ? FK_PCRel_1 : FK_Data_1;
+    case 2:
+      return IsPCRel ? FK_PCRel_2 : FK_Data_2;
+    case 4:
+      return IsPCRel ? FK_PCRel_4 : FK_Data_4;
+    case 8:
+      return IsPCRel ? FK_PCRel_8 : FK_Data_8;
+    }
+  }
+
+  /// Return the generic fixup kind for a value with the given size in bits.
+  /// It is an error to pass an unsupported size.
+  static MCFixupKind getKindForSizeInBits(unsigned Size, bool IsPCRel) {
+    switch (Size) {
+    default:
+      llvm_unreachable("Invalid generic fixup size!");
+    case 6:
+      assert(!IsPCRel && "Invalid pc-relative fixup size!");
+      return FK_Data_6b;
+    case 8:
+      return IsPCRel ? FK_PCRel_1 : FK_Data_1;
+    case 16:
+      return IsPCRel ? FK_PCRel_2 : FK_Data_2;
+    case 32:
+      return IsPCRel ? FK_PCRel_4 : FK_Data_4;
+    case 64:
+      return IsPCRel ? FK_PCRel_8 : FK_Data_8;
     }
   }
 
   /// Return the generic fixup kind for an addition with a given size. It
   /// is an error to pass an unsupported size.
-  static MCFixupKind getAddKindForKind(unsigned Kind) {
+  static MCFixupKind getAddKindForKind(MCFixupKind Kind) {
     switch (Kind) {
     default: llvm_unreachable("Unknown type to convert!");
     case FK_Data_1: return FK_Data_Add_1;
     case FK_Data_2: return FK_Data_Add_2;
     case FK_Data_4: return FK_Data_Add_4;
     case FK_Data_8: return FK_Data_Add_8;
+    case FK_Data_6b: return FK_Data_Add_6b;
     }
   }
 
   /// Return the generic fixup kind for an subtraction with a given size. It
   /// is an error to pass an unsupported size.
-  static MCFixupKind getSubKindForKind(unsigned Kind) {
+  static MCFixupKind getSubKindForKind(MCFixupKind Kind) {
     switch (Kind) {
     default: llvm_unreachable("Unknown type to convert!");
     case FK_Data_1: return FK_Data_Sub_1;
     case FK_Data_2: return FK_Data_Sub_2;
     case FK_Data_4: return FK_Data_Sub_4;
     case FK_Data_8: return FK_Data_Sub_8;
+    case FK_Data_6b: return FK_Data_Sub_6b;
     }
   }
 
diff --git a/linux-x64/clang/include/llvm/MC/MCFixupKindInfo.h b/linux-x64/clang/include/llvm/MC/MCFixupKindInfo.h
index 0ea3486..ecf85fa 100644
--- a/linux-x64/clang/include/llvm/MC/MCFixupKindInfo.h
+++ b/linux-x64/clang/include/llvm/MC/MCFixupKindInfo.h
@@ -19,7 +19,15 @@
     FKF_IsPCRel = (1 << 0),
 
     /// Should this fixup kind force a 4-byte aligned effective PC value?
-    FKF_IsAlignedDownTo32Bits = (1 << 1)
+    FKF_IsAlignedDownTo32Bits = (1 << 1),
+
+    /// Should this fixup be evaluated in a target dependent manner?
+    FKF_IsTarget = (1 << 2),
+
+    /// This fixup kind should be resolved if defined.
+    /// FIXME This is a workaround because we don't support certain ARM
+    /// relocation types. This flag should eventually be removed.
+    FKF_Constant = 1 << 3,
   };
 
   /// A target specific name for the fixup kind. The names will be unique for
diff --git a/linux-x64/clang/include/llvm/MC/MCFragment.h b/linux-x64/clang/include/llvm/MC/MCFragment.h
index aadf2ce..000b0e3 100644
--- a/linux-x64/clang/include/llvm/MC/MCFragment.h
+++ b/linux-x64/clang/include/llvm/MC/MCFragment.h
@@ -16,6 +16,7 @@
 #include "llvm/ADT/ilist_node.h"
 #include "llvm/MC/MCFixup.h"
 #include "llvm/MC/MCInst.h"
+#include "llvm/Support/Alignment.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/SMLoc.h"
 #include <cstdint>
@@ -36,52 +37,49 @@
     FT_Data,
     FT_CompactEncodedInst,
     FT_Fill,
+    FT_Nops,
     FT_Relaxable,
     FT_Org,
     FT_Dwarf,
     FT_DwarfFrame,
     FT_LEB,
-    FT_Padding,
+    FT_BoundaryAlign,
     FT_SymbolId,
     FT_CVInlineLines,
     FT_CVDefRange,
+    FT_PseudoProbe,
     FT_Dummy
   };
 
 private:
+  /// The data for the section this fragment is in.
+  MCSection *Parent;
+
+  /// The atom this fragment is in, as represented by its defining symbol.
+  const MCSymbol *Atom;
+
+  /// The offset of this fragment in its section. This is ~0 until
+  /// initialized.
+  uint64_t Offset;
+
+  /// The layout order of this fragment.
+  unsigned LayoutOrder;
+
+  /// The subsection this fragment belongs to. This is 0 if the fragment is not
+  // in any subsection.
+  unsigned SubsectionNumber = 0;
+
   FragmentType Kind;
 
+  /// Whether fragment is being laid out.
+  bool IsBeingLaidOut;
+
 protected:
   bool HasInstructions;
 
-private:
-  /// LayoutOrder - The layout order of this fragment.
-  unsigned LayoutOrder;
-
-  /// The data for the section this fragment is in.
-  MCSection *Parent;
-
-  /// Atom - The atom this fragment is in, as represented by its defining
-  /// symbol.
-  const MCSymbol *Atom;
-
-  /// \name Assembler Backend Data
-  /// @{
-  //
-  // FIXME: This could all be kept private to the assembler implementation.
-
-  /// Offset - The offset of this fragment in its section. This is ~0 until
-  /// initialized.
-  uint64_t Offset;
-
-  /// @}
-
-protected:
   MCFragment(FragmentType Kind, bool HasInstructions,
              MCSection *Parent = nullptr);
 
-  ~MCFragment();
-
 public:
   MCFragment() = delete;
   MCFragment(const MCFragment &) = delete;
@@ -108,10 +106,10 @@
   /// this is false, but specific fragment types may set it to true.
   bool hasInstructions() const { return HasInstructions; }
 
-  /// Return true if given frgment has FT_Dummy type.
-  bool isDummy() const { return Kind == FT_Dummy; }
-
   void dump() const;
+
+  void setSubsectionNumber(unsigned Value) { SubsectionNumber = Value; }
+  unsigned getSubsectionNumber() const { return SubsectionNumber; }
 };
 
 class MCDummyFragment : public MCFragment {
@@ -135,8 +133,8 @@
                     MCSection *Sec)
       : MCFragment(FType, HasInstructions, Sec) {}
 
-  /// STI - The MCSubtargetInfo in effect when the instruction was encoded.
-  /// must be non-null for instructions.
+  /// The MCSubtargetInfo in effect when the instruction was encoded.
+  /// It must be non-null for instructions.
   const MCSubtargetInfo *STI = nullptr;
 
 public:
@@ -149,6 +147,8 @@
     case MCFragment::FT_CompactEncodedInst:
     case MCFragment::FT_Data:
     case MCFragment::FT_Dwarf:
+    case MCFragment::FT_DwarfFrame:
+    case MCFragment::FT_PseudoProbe:
       return true;
     }
   }
@@ -205,7 +205,7 @@
 class MCEncodedFragmentWithFixups :
   public MCEncodedFragmentWithContents<ContentsSize> {
 
-  /// Fixups - The list of fixups in this fragment.
+  /// The list of fixups in this fragment.
   SmallVector<MCFixup, FixupsSize> Fixups;
 
 protected:
@@ -232,7 +232,8 @@
   static bool classof(const MCFragment *F) {
     MCFragment::FragmentType Kind = F->getKind();
     return Kind == MCFragment::FT_Relaxable || Kind == MCFragment::FT_Data ||
-           Kind == MCFragment::FT_CVDefRange || Kind == MCFragment::FT_Dwarf;;
+           Kind == MCFragment::FT_CVDefRange || Kind == MCFragment::FT_Dwarf ||
+           Kind == MCFragment::FT_DwarfFrame;
   }
 };
 
@@ -269,8 +270,10 @@
 ///
 class MCRelaxableFragment : public MCEncodedFragmentWithFixups<8, 1> {
 
-  /// Inst - The instruction this is a fragment for.
+  /// The instruction this is a fragment for.
   MCInst Inst;
+  /// Can we auto pad the instruction?
+  bool AllowAutoPadding = false;
 
 public:
   MCRelaxableFragment(const MCInst &Inst, const MCSubtargetInfo &STI,
@@ -281,27 +284,30 @@
   const MCInst &getInst() const { return Inst; }
   void setInst(const MCInst &Value) { Inst = Value; }
 
+  bool getAllowAutoPadding() const { return AllowAutoPadding; }
+  void setAllowAutoPadding(bool V) { AllowAutoPadding = V; }
+
   static bool classof(const MCFragment *F) {
     return F->getKind() == MCFragment::FT_Relaxable;
   }
 };
 
 class MCAlignFragment : public MCFragment {
-  /// Alignment - The alignment to ensure, in bytes.
+  /// The alignment to ensure, in bytes.
   unsigned Alignment;
 
-  /// EmitNops - Flag to indicate that (optimal) NOPs should be emitted instead
+  /// Flag to indicate that (optimal) NOPs should be emitted instead
   /// of using the provided value. The exact interpretation of this flag is
   /// target dependent.
   bool EmitNops : 1;
 
-  /// Value - Value to use for filling padding bytes.
+  /// Value to use for filling padding bytes.
   int64_t Value;
 
-  /// ValueSize - The size of the integer (in bytes) of \p Value.
+  /// The size of the integer (in bytes) of \p Value.
   unsigned ValueSize;
 
-  /// MaxBytesToEmit - The maximum number of bytes to emit; if the alignment
+  /// The maximum number of bytes to emit; if the alignment
   /// cannot be satisfied in this width then this fragment is ignored.
   unsigned MaxBytesToEmit;
 
@@ -311,9 +317,6 @@
       : MCFragment(FT_Align, false, Sec), Alignment(Alignment), EmitNops(false),
         Value(Value), ValueSize(ValueSize), MaxBytesToEmit(MaxBytesToEmit) {}
 
-  /// \name Accessors
-  /// @{
-
   unsigned getAlignment() const { return Alignment; }
 
   int64_t getValue() const { return Value; }
@@ -325,109 +328,15 @@
   bool hasEmitNops() const { return EmitNops; }
   void setEmitNops(bool Value) { EmitNops = Value; }
 
-  /// @}
-
   static bool classof(const MCFragment *F) {
     return F->getKind() == MCFragment::FT_Align;
   }
 };
 
-/// Fragment for adding required padding.
-/// This fragment is always inserted before an instruction, and holds that
-/// instruction as context information (as well as a mask of kinds) for
-/// determining the padding size.
-///
-class MCPaddingFragment : public MCFragment {
-  /// A mask containing all the kinds relevant to this fragment. i.e. the i'th
-  /// bit will be set iff kind i is relevant to this fragment.
-  uint64_t PaddingPoliciesMask;
-  /// A boolean indicating if this fragment will actually hold padding. If its
-  /// value is false, then this fragment serves only as a placeholder,
-  /// containing data to assist other insertion point in their decision making.
-  bool IsInsertionPoint;
-
-  uint64_t Size;
-
-  struct MCInstInfo {
-    bool IsInitialized;
-    MCInst Inst;
-    /// A boolean indicating whether the instruction pointed by this fragment is
-    /// a fixed size instruction or a relaxable instruction held by a
-    /// MCRelaxableFragment.
-    bool IsImmutableSizedInst;
-    union {
-      /// If the instruction is a fixed size instruction, hold its size.
-      size_t InstSize;
-      /// Otherwise, hold a pointer to the MCRelaxableFragment holding it.
-      MCRelaxableFragment *InstFragment;
-    };
-  };
-  MCInstInfo InstInfo;
-
-public:
-  static const uint64_t PFK_None = UINT64_C(0);
-
-  enum MCPaddingFragmentKind {
-    // values 0-7 are reserved for future target independet values.
-
-    FirstTargetPerfNopFragmentKind = 8,
-
-    /// Limit range of target MCPerfNopFragment kinds to fit in uint64_t
-    MaxTargetPerfNopFragmentKind = 63
-  };
-
-  MCPaddingFragment(MCSection *Sec = nullptr)
-      : MCFragment(FT_Padding, false, Sec), PaddingPoliciesMask(PFK_None),
-        IsInsertionPoint(false), Size(UINT64_C(0)),
-        InstInfo({false, MCInst(), false, {0}}) {}
-
-  bool isInsertionPoint() const { return IsInsertionPoint; }
-  void setAsInsertionPoint() { IsInsertionPoint = true; }
-  uint64_t getPaddingPoliciesMask() const { return PaddingPoliciesMask; }
-  void setPaddingPoliciesMask(uint64_t Value) { PaddingPoliciesMask = Value; }
-  bool hasPaddingPolicy(uint64_t PolicyMask) const {
-    assert(isPowerOf2_64(PolicyMask) &&
-           "Policy mask must contain exactly one policy");
-    return (getPaddingPoliciesMask() & PolicyMask) != PFK_None;
-  }
-  const MCInst &getInst() const {
-    assert(isInstructionInitialized() && "Fragment has no instruction!");
-    return InstInfo.Inst;
-  }
-  size_t getInstSize() const {
-    assert(isInstructionInitialized() && "Fragment has no instruction!");
-    if (InstInfo.IsImmutableSizedInst)
-      return InstInfo.InstSize;
-    assert(InstInfo.InstFragment != nullptr &&
-           "Must have a valid InstFragment to retrieve InstSize from");
-    return InstInfo.InstFragment->getContents().size();
-  }
-  void setInstAndInstSize(const MCInst &Inst, size_t InstSize) {
-	InstInfo.IsInitialized = true;
-    InstInfo.IsImmutableSizedInst = true;
-    InstInfo.Inst = Inst;
-    InstInfo.InstSize = InstSize;
-  }
-  void setInstAndInstFragment(const MCInst &Inst,
-                              MCRelaxableFragment *InstFragment) {
-    InstInfo.IsInitialized = true;
-    InstInfo.IsImmutableSizedInst = false;
-    InstInfo.Inst = Inst;
-    InstInfo.InstFragment = InstFragment;
-  }
-  uint64_t getSize() const { return Size; }
-  void setSize(uint64_t Value) { Size = Value; }
-  bool isInstructionInitialized() const { return InstInfo.IsInitialized; }
-
-  static bool classof(const MCFragment *F) {
-    return F->getKind() == MCFragment::FT_Padding;
-  }
-};
-
 class MCFillFragment : public MCFragment {
+  uint8_t ValueSize;
   /// Value to use for filling bytes.
   uint64_t Value;
-  uint8_t ValueSize;
   /// The number of bytes to insert.
   const MCExpr &NumValues;
 
@@ -437,7 +346,7 @@
 public:
   MCFillFragment(uint64_t Value, uint8_t VSize, const MCExpr &NumValues,
                  SMLoc Loc, MCSection *Sec = nullptr)
-      : MCFragment(FT_Fill, false, Sec), Value(Value), ValueSize(VSize),
+      : MCFragment(FT_Fill, false, Sec), ValueSize(VSize), Value(Value),
         NumValues(NumValues), Loc(Loc) {}
 
   uint64_t getValue() const { return Value; }
@@ -451,23 +360,46 @@
   }
 };
 
-class MCOrgFragment : public MCFragment {
-  /// The offset this fragment should start at.
-  const MCExpr *Offset;
+class MCNopsFragment : public MCFragment {
+  /// The number of bytes to insert.
+  int64_t Size;
+  /// Maximum number of bytes allowed in each NOP instruction.
+  int64_t ControlledNopLength;
 
+  /// Source location of the directive that this fragment was created for.
+  SMLoc Loc;
+
+public:
+  MCNopsFragment(int64_t NumBytes, int64_t ControlledNopLength, SMLoc L,
+                 MCSection *Sec = nullptr)
+      : MCFragment(FT_Nops, false, Sec), Size(NumBytes),
+        ControlledNopLength(ControlledNopLength), Loc(L) {}
+
+  int64_t getNumBytes() const { return Size; }
+  int64_t getControlledNopLength() const { return ControlledNopLength; }
+
+  SMLoc getLoc() const { return Loc; }
+
+  static bool classof(const MCFragment *F) {
+    return F->getKind() == MCFragment::FT_Nops;
+  }
+};
+
+class MCOrgFragment : public MCFragment {
   /// Value to use for filling bytes.
   int8_t Value;
 
+  /// The offset this fragment should start at.
+  const MCExpr *Offset;
+
   /// Source location of the directive that this fragment was created for.
   SMLoc Loc;
 
 public:
   MCOrgFragment(const MCExpr &Offset, int8_t Value, SMLoc Loc,
                 MCSection *Sec = nullptr)
-      : MCFragment(FT_Org, false, Sec), Offset(&Offset), Value(Value), Loc(Loc) {}
-
-  /// \name Accessors
-  /// @{
+      : MCFragment(FT_Org, false, Sec), Value(Value), Offset(&Offset),
+        Loc(Loc) {}
 
   const MCExpr &getOffset() const { return *Offset; }
 
@@ -475,31 +407,26 @@
 
   SMLoc getLoc() const { return Loc; }
 
-  /// @}
-
   static bool classof(const MCFragment *F) {
     return F->getKind() == MCFragment::FT_Org;
   }
 };
 
 class MCLEBFragment : public MCFragment {
-  /// Value - The value this fragment should contain.
-  const MCExpr *Value;
-
-  /// IsSigned - True if this is a sleb128, false if uleb128.
+  /// True if this is a sleb128, false if uleb128.
   bool IsSigned;
 
+  /// The value this fragment should contain.
+  const MCExpr *Value;
+
   SmallString<8> Contents;
 
 public:
   MCLEBFragment(const MCExpr &Value_, bool IsSigned_, MCSection *Sec = nullptr)
-      : MCFragment(FT_LEB, false, Sec), Value(&Value_), IsSigned(IsSigned_) {
+      : MCFragment(FT_LEB, false, Sec), IsSigned(IsSigned_), Value(&Value_) {
     Contents.push_back(0);
   }
 
-  /// \name Accessors
-  /// @{
-
   const MCExpr &getValue() const { return *Value; }
 
   bool isSigned() const { return IsSigned; }
@@ -515,11 +442,11 @@
 };
 
 class MCDwarfLineAddrFragment : public MCEncodedFragmentWithFixups<8, 1> {
-  /// LineDelta - the value of the difference between the two line numbers
+  /// The value of the difference between the two line numbers
   /// between two .loc dwarf directives.
   int64_t LineDelta;
 
-  /// AddrDelta - The expression for the difference of the two symbols that
+  /// The expression for the difference of the two symbols that
   /// make up the address delta between two .loc dwarf directives.
   const MCExpr *AddrDelta;
 
@@ -529,43 +456,27 @@
       : MCEncodedFragmentWithFixups<8, 1>(FT_Dwarf, false, Sec),
         LineDelta(LineDelta), AddrDelta(&AddrDelta) {}
 
-  /// \name Accessors
-  /// @{
-
   int64_t getLineDelta() const { return LineDelta; }
 
   const MCExpr &getAddrDelta() const { return *AddrDelta; }
 
-  /// @}
-
   static bool classof(const MCFragment *F) {
     return F->getKind() == MCFragment::FT_Dwarf;
   }
 };
 
-class MCDwarfCallFrameFragment : public MCFragment {
-  /// AddrDelta - The expression for the difference of the two symbols that
+class MCDwarfCallFrameFragment : public MCEncodedFragmentWithFixups<8, 1> {
+  /// The expression for the difference of the two symbols that
   /// make up the address delta between two .cfi_* dwarf directives.
   const MCExpr *AddrDelta;
 
-  SmallString<8> Contents;
-
 public:
   MCDwarfCallFrameFragment(const MCExpr &AddrDelta, MCSection *Sec = nullptr)
-      : MCFragment(FT_DwarfFrame, false, Sec), AddrDelta(&AddrDelta) {
-    Contents.push_back(0);
-  }
-
-  /// \name Accessors
-  /// @{
+      : MCEncodedFragmentWithFixups<8, 1>(FT_DwarfFrame, false, Sec),
+        AddrDelta(&AddrDelta) {}
 
   const MCExpr &getAddrDelta() const { return *AddrDelta; }
 
-  SmallString<8> &getContents() { return Contents; }
-  const SmallString<8> &getContents() const { return Contents; }
-
-  /// @}
-
   static bool classof(const MCFragment *F) {
     return F->getKind() == MCFragment::FT_DwarfFrame;
   }
@@ -579,14 +490,9 @@
   MCSymbolIdFragment(const MCSymbol *Sym, MCSection *Sec = nullptr)
       : MCFragment(FT_SymbolId, false, Sec), Sym(Sym) {}
 
-  /// \name Accessors
-  /// @{
-
   const MCSymbol *getSymbol() { return Sym; }
   const MCSymbol *getSymbol() const { return Sym; }
 
-  /// @}
-
   static bool classof(const MCFragment *F) {
     return F->getKind() == MCFragment::FT_SymbolId;
   }
@@ -615,17 +521,12 @@
         StartFileId(StartFileId), StartLineNum(StartLineNum),
         FnStartSym(FnStartSym), FnEndSym(FnEndSym) {}
 
-  /// \name Accessors
-  /// @{
-
   const MCSymbol *getFnStartSym() const { return FnStartSym; }
   const MCSymbol *getFnEndSym() const { return FnEndSym; }
 
   SmallString<8> &getContents() { return Contents; }
   const SmallString<8> &getContents() const { return Contents; }
 
-  /// @}
-
   static bool classof(const MCFragment *F) {
     return F->getKind() == MCFragment::FT_CVInlineLines;
   }
@@ -648,20 +549,67 @@
         Ranges(Ranges.begin(), Ranges.end()),
         FixedSizePortion(FixedSizePortion) {}
 
-  /// \name Accessors
-  /// @{
   ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> getRanges() const {
     return Ranges;
   }
 
   StringRef getFixedSizePortion() const { return FixedSizePortion; }
-  /// @}
 
   static bool classof(const MCFragment *F) {
     return F->getKind() == MCFragment::FT_CVDefRange;
   }
 };
 
+/// Represents required padding such that a particular other set of fragments
+/// does not cross a particular power-of-two boundary. The other fragments must
+/// follow this one within the same section.
+class MCBoundaryAlignFragment : public MCFragment {
+  /// The alignment requirement of the branch to be aligned.
+  Align AlignBoundary;
+  /// The last fragment in the set of fragments to be aligned.
+  const MCFragment *LastFragment = nullptr;
+  /// The size of the fragment.  The size is lazily set during relaxation, and
+  /// is not meaningful before that.
+  uint64_t Size = 0;
+
+public:
+  MCBoundaryAlignFragment(Align AlignBoundary, MCSection *Sec = nullptr)
+      : MCFragment(FT_BoundaryAlign, false, Sec), AlignBoundary(AlignBoundary) {
+  }
+
+  uint64_t getSize() const { return Size; }
+  void setSize(uint64_t Value) { Size = Value; }
+
+  Align getAlignment() const { return AlignBoundary; }
+  void setAlignment(Align Value) { AlignBoundary = Value; }
+
+  const MCFragment *getLastFragment() const { return LastFragment; }
+  void setLastFragment(const MCFragment *F) {
+    assert(!F || getParent() == F->getParent());
+    LastFragment = F;
+  }
+
+  static bool classof(const MCFragment *F) {
+    return F->getKind() == MCFragment::FT_BoundaryAlign;
+  }
+};
+
+class MCPseudoProbeAddrFragment : public MCEncodedFragmentWithFixups<8, 1> {
+  /// The expression for the difference of the two symbols that
+  /// make up the address delta between two .pseudoprobe directives.
+  const MCExpr *AddrDelta;
+
+public:
+  MCPseudoProbeAddrFragment(const MCExpr *AddrDelta, MCSection *Sec = nullptr)
+      : MCEncodedFragmentWithFixups<8, 1>(FT_PseudoProbe, false, Sec),
+        AddrDelta(AddrDelta) {}
+
+  const MCExpr &getAddrDelta() const { return *AddrDelta; }
+
+  static bool classof(const MCFragment *F) {
+    return F->getKind() == MCFragment::FT_PseudoProbe;
+  }
+};
 } // end namespace llvm
 
 #endif // LLVM_MC_MCFRAGMENT_H
diff --git a/linux-x64/clang/include/llvm/MC/MCInst.h b/linux-x64/clang/include/llvm/MC/MCInst.h
index 8df8096..2ce2ee0 100644
--- a/linux-x64/clang/include/llvm/MC/MCInst.h
+++ b/linux-x64/clang/include/llvm/MC/MCInst.h
@@ -157,13 +157,14 @@
 /// instruction.
 class MCInst {
   unsigned Opcode = 0;
-  SMLoc Loc;
-  SmallVector<MCOperand, 8> Operands;
   // These flags could be used to pass some info from one target subcomponent
   // to another, for example, from disassembler to asm printer. The values of
   // the flags have any sense on target level only (e.g. prefixes on x86).
   unsigned Flags = 0;
 
+  SMLoc Loc;
+  SmallVector<MCOperand, 8> Operands;
+
 public:
   MCInst() = default;
 
@@ -180,7 +181,7 @@
   MCOperand &getOperand(unsigned i) { return Operands[i]; }
   unsigned getNumOperands() const { return Operands.size(); }
 
-  void addOperand(const MCOperand &Op) { Operands.push_back(Op); }
+  void addOperand(const MCOperand Op) { Operands.push_back(Op); }
 
   using iterator = SmallVectorImpl<MCOperand>::iterator;
   using const_iterator = SmallVectorImpl<MCOperand>::const_iterator;
diff --git a/linux-x64/clang/include/llvm/MC/MCInstPrinter.h b/linux-x64/clang/include/llvm/MC/MCInstPrinter.h
index 6bbc4bc..8b9ef17 100644
--- a/linux-x64/clang/include/llvm/MC/MCInstPrinter.h
+++ b/linux-x64/clang/include/llvm/MC/MCInstPrinter.h
@@ -16,7 +16,9 @@
 
 class MCAsmInfo;
 class MCInst;
+class MCOperand;
 class MCInstrInfo;
+class MCInstrAnalysis;
 class MCRegisterInfo;
 class MCSubtargetInfo;
 class raw_ostream;
@@ -34,6 +36,8 @@
 
 } // end namespace HexStyle
 
+struct AliasMatchingData;
+
 /// This is an instance of a target assembly language printer that
 /// converts an MCInst to valid target assembly syntax.
 class MCInstPrinter {
@@ -45,6 +49,7 @@
   const MCAsmInfo &MAI;
   const MCInstrInfo &MII;
   const MCRegisterInfo &MRI;
+  const MCInstrAnalysis *MIA = nullptr;
 
   /// True if we are printing marked up assembly.
   bool UseMarkup = false;
@@ -55,9 +60,21 @@
   /// Which style to use for printing hexadecimal values.
   HexStyle::Style PrintHexStyle = HexStyle::C;
 
+  /// If true, a branch immediate (e.g. bl 4) will be printed as a hexadecimal
+  /// address (e.g. bl 0x20004). This is useful for a stream disassembler
+  /// (llvm-objdump -d).
+  bool PrintBranchImmAsAddress = false;
+
+  /// If true, symbolize branch target and memory reference operands.
+  bool SymbolizeOperands = false;
+
   /// Utility function for printing annotations.
   void printAnnotation(raw_ostream &OS, StringRef Annot);
 
+  /// Helper for matching MCInsts to alias patterns when printing instructions.
+  const char *matchAliasPatterns(const MCInst *MI, const MCSubtargetInfo *STI,
+                                 const AliasMatchingData &M);
+
 public:
   MCInstPrinter(const MCAsmInfo &mai, const MCInstrInfo &mii,
                 const MCRegisterInfo &mri) : MAI(mai), MII(mii), MRI(mri) {}
@@ -71,9 +88,19 @@
   /// Specify a stream to emit comments to.
   void setCommentStream(raw_ostream &OS) { CommentStream = &OS; }
 
+  /// Returns a pair containing the mnemonic for \p MI and the number of bits
+  /// left for further processing by printInstruction (generated by tablegen).
+  virtual std::pair<const char *, uint64_t> getMnemonic(const MCInst *MI) = 0;
+
   /// Print the specified MCInst to the specified raw_ostream.
-  virtual void printInst(const MCInst *MI, raw_ostream &OS, StringRef Annot,
-                         const MCSubtargetInfo &STI) = 0;
+  ///
+  /// \p Address the address of current instruction on most targets, used to
+  /// print a PC relative immediate as the target address. On targets where a PC
+  /// relative immediate is relative to the next instruction and the length of a
+  /// MCInst is difficult to measure (e.g. x86), this is the address of the next
+  /// instruction. If Address is 0, the immediate will be printed.
+  virtual void printInst(const MCInst *MI, uint64_t Address, StringRef Annot,
+                         const MCSubtargetInfo &STI, raw_ostream &OS) = 0;
 
   /// Return the name of the specified opcode enum (e.g. "MOV32ri") or
   /// empty if we can't resolve it.
@@ -87,14 +114,19 @@
 
   /// Utility functions to make adding mark ups simpler.
   StringRef markup(StringRef s) const;
-  StringRef markup(StringRef a, StringRef b) const;
 
   bool getPrintImmHex() const { return PrintImmHex; }
   void setPrintImmHex(bool Value) { PrintImmHex = Value; }
 
-  HexStyle::Style getPrintHexStyle() const { return PrintHexStyle; }
   void setPrintHexStyle(HexStyle::Style Value) { PrintHexStyle = Value; }
 
+  void setPrintBranchImmAsAddress(bool Value) {
+    PrintBranchImmAsAddress = Value;
+  }
+
+  void setSymbolizeOperands(bool Value) { SymbolizeOperands = Value; }
+  void setMCInstrAnalysis(const MCInstrAnalysis *Value) { MIA = Value; }
+
   /// Utility function to print immediates in decimal or hex.
   format_object<int64_t> formatImm(int64_t Value) const {
     return PrintImmHex ? formatHex(Value) : formatDec(Value);
@@ -106,6 +138,51 @@
   format_object<uint64_t> formatHex(uint64_t Value) const;
 };
 
+/// Map from opcode to pattern list by binary search.
+struct PatternsForOpcode {
+  uint32_t Opcode;
+  uint16_t PatternStart;
+  uint16_t NumPatterns;
+};
+
+/// Data for each alias pattern. Includes feature bits, string, number of
+/// operands, and a variadic list of conditions to check.
+struct AliasPattern {
+  uint32_t AsmStrOffset;
+  uint32_t AliasCondStart;
+  uint8_t NumOperands;
+  uint8_t NumConds;
+};
+
+struct AliasPatternCond {
+  enum CondKind : uint8_t {
+    K_Feature,       // Match only if a feature is enabled.
+    K_NegFeature,    // Match only if a feature is disabled.
+    K_OrFeature,     // Match only if one of a set of features is enabled.
+    K_OrNegFeature,  // Match only if one of a set of features is disabled.
+    K_EndOrFeatures, // Note end of list of K_Or(Neg)?Features.
+    K_Ignore,        // Match any operand.
+    K_Reg,           // Match a specific register.
+    K_TiedReg,       // Match another already matched register.
+    K_Imm,           // Match a specific immediate.
+    K_RegClass,      // Match registers in a class.
+    K_Custom,        // Call custom matcher by index.
+  };
+
+  CondKind Kind;
+  uint32_t Value;
+};
+
+/// Tablegenerated data structures needed to match alias patterns.
+struct AliasMatchingData {
+  ArrayRef<PatternsForOpcode> OpToPatterns;
+  ArrayRef<AliasPattern> Patterns;
+  ArrayRef<AliasPatternCond> PatternConds;
+  StringRef AsmStrings;
+  bool (*ValidateMCOperand)(const MCOperand &MCOp, const MCSubtargetInfo &STI,
+                            unsigned PredicateIndex);
+};
+
 } // end namespace llvm
 
 #endif // LLVM_MC_MCINSTPRINTER_H
diff --git a/linux-x64/clang/include/llvm/MC/MCInstrAnalysis.h b/linux-x64/clang/include/llvm/MC/MCInstrAnalysis.h
index dfefd7e..898ca47 100644
--- a/linux-x64/clang/include/llvm/MC/MCInstrAnalysis.h
+++ b/linux-x64/clang/include/llvm/MC/MCInstrAnalysis.h
@@ -152,6 +152,12 @@
   evaluateBranch(const MCInst &Inst, uint64_t Addr, uint64_t Size,
                  uint64_t &Target) const;
 
+  /// Given an instruction tries to get the address of a memory operand. Returns
+  /// the address on success.
+  virtual Optional<uint64_t> evaluateMemoryOperandAddress(const MCInst &Inst,
+                                                          uint64_t Addr,
+                                                          uint64_t Size) const;
+
   /// Returns (PLT virtual address, GOT virtual address) pairs for PLT entries.
   virtual std::vector<std::pair<uint64_t, uint64_t>>
   findPltEntries(uint64_t PltSectionVA, ArrayRef<uint8_t> PltContents,
diff --git a/linux-x64/clang/include/llvm/MC/MCInstrDesc.h b/linux-x64/clang/include/llvm/MC/MCInstrDesc.h
index 0aa586d..cbb061f 100644
--- a/linux-x64/clang/include/llvm/MC/MCInstrDesc.h
+++ b/linux-x64/clang/include/llvm/MC/MCInstrDesc.h
@@ -19,25 +19,39 @@
 #include <string>
 
 namespace llvm {
-  class MCInst;
-  class MCSubtargetInfo;
-  class FeatureBitset;
+
+class MCInst;
 
 //===----------------------------------------------------------------------===//
 // Machine Operand Flags and Description
 //===----------------------------------------------------------------------===//
 
 namespace MCOI {
-// Operand constraints
+/// Operand constraints. These are encoded in 16 bits with one of the
+/// low-order 3 bits specifying that a constraint is present and the
+/// corresponding high-order hex digit specifying the constraint value.
+/// This allows for a maximum of 3 constraints.
 enum OperandConstraint {
-  TIED_TO = 0,  // Must be allocated the same register as.
-  EARLY_CLOBBER // Operand is an early clobber register operand
+  TIED_TO = 0,  // Must be allocated the same register as specified value.
+  EARLY_CLOBBER // If present, operand is an early clobber register.
 };
 
+// Define a macro to produce each constraint value.
+#define MCOI_TIED_TO(op) \
+  ((1 << MCOI::TIED_TO) | ((op) << (4 + MCOI::TIED_TO * 4)))
+
+#define MCOI_EARLY_CLOBBER \
+  (1 << MCOI::EARLY_CLOBBER)
+
 /// These are flags set on operands, but should be considered
 /// private, all access should go through the MCOperandInfo accessors.
 /// See the accessors for a description of what these are.
-enum OperandFlags { LookupPtrRegClass = 0, Predicate, OptionalDef };
+enum OperandFlags {
+  LookupPtrRegClass = 0,
+  Predicate,
+  OptionalDef,
+  BranchTarget
+};
 
 /// Operands are tagged with one of the values of this enum.
 enum OperandType {
@@ -56,7 +70,11 @@
   OPERAND_GENERIC_5 = 11,
   OPERAND_LAST_GENERIC = 11,
 
-  OPERAND_FIRST_TARGET = 12,
+  OPERAND_FIRST_GENERIC_IMM = 12,
+  OPERAND_GENERIC_IMM_0 = 12,
+  OPERAND_LAST_GENERIC_IMM = 12,
+
+  OPERAND_FIRST_TARGET = 13,
 };
 
 }
@@ -76,10 +94,9 @@
 
   /// Information about the type of the operand.
   uint8_t OperandType;
-  /// The lower 16 bits are used to specify which constraints are set.
-  /// The higher 16 bits are used to specify the value of constraints (4 bits
-  /// each).
-  uint32_t Constraints;
+
+  /// Operand constraints (see OperandConstraint enum).
+  uint16_t Constraints;
 
   /// Set if this operand is a pointer value and it requires a callback
   /// to look up its register class.
@@ -94,6 +111,9 @@
   /// Set if this operand is a optional def.
   bool isOptionalDef() const { return Flags & (1 << MCOI::OptionalDef); }
 
+  /// Set if this operand is a branch target.
+  bool isBranchTarget() const { return Flags & (1 << MCOI::BranchTarget); }
+
   bool isGenericType() const {
     return OperandType >= MCOI::OPERAND_FIRST_GENERIC &&
            OperandType <= MCOI::OPERAND_LAST_GENERIC;
@@ -103,6 +123,16 @@
     assert(isGenericType() && "non-generic types don't have an index");
     return OperandType - MCOI::OPERAND_FIRST_GENERIC;
   }
+
+  bool isGenericImm() const {
+    return OperandType >= MCOI::OPERAND_FIRST_GENERIC_IMM &&
+           OperandType <= MCOI::OPERAND_LAST_GENERIC_IMM;
+  }
+
+  unsigned getGenericImmIndex() const {
+    assert(isGenericImm() && "non-generic immediates don't have an index");
+    return OperandType - MCOI::OPERAND_FIRST_GENERIC_IMM;
+  }
 };
 
 //===----------------------------------------------------------------------===//
@@ -115,7 +145,8 @@
 /// not use these directly.  These all correspond to bitfields in the
 /// MCInstrDesc::Flags field.
 enum Flag {
-  Variadic = 0,
+  PreISelOpcode = 0,
+  Variadic,
   HasOptionalDef,
   Pseudo,
   Return,
@@ -153,6 +184,7 @@
   Add,
   Trap,
   VariadicOpsAreDefs,
+  Authenticated,
 };
 }
 
@@ -173,33 +205,19 @@
   const MCPhysReg *ImplicitUses; // Registers implicitly read by this instr
   const MCPhysReg *ImplicitDefs; // Registers implicitly defined by this instr
   const MCOperandInfo *OpInfo;   // 'NumOperands' entries about operands
-  // Subtarget feature that this is deprecated on, if any
-  // -1 implies this is not deprecated by any single feature. It may still be
-  // deprecated due to a "complex" reason, below.
-  int64_t DeprecatedFeature;
 
-  // A complex method to determine if a certain instruction is deprecated or
-  // not, and return the reason for deprecation.
-  bool (*ComplexDeprecationInfo)(MCInst &, const MCSubtargetInfo &,
-                                 std::string &);
-
-  /// Returns the value of the specific constraint if
-  /// it is set. Returns -1 if it is not set.
+  /// Returns the value of the specified operand constraint if
+  /// it is present. Returns -1 if it is not present.
   int getOperandConstraint(unsigned OpNum,
                            MCOI::OperandConstraint Constraint) const {
     if (OpNum < NumOperands &&
         (OpInfo[OpNum].Constraints & (1 << Constraint))) {
-      unsigned Pos = 16 + Constraint * 4;
-      return (int)(OpInfo[OpNum].Constraints >> Pos) & 0xf;
+      unsigned ValuePos = 4 + Constraint * 4;
+      return (int)(OpInfo[OpNum].Constraints >> ValuePos) & 0x0f;
     }
     return -1;
   }
 
-  /// Returns true if a certain instruction is deprecated and if so
-  /// returns the reason in \p Info.
-  bool getDeprecatedInfo(MCInst &MI, const MCSubtargetInfo &STI,
-                         std::string &Info) const;
-
   /// Return the opcode number for this descriptor.
   unsigned getOpcode() const { return Opcode; }
 
@@ -228,6 +246,10 @@
   /// Return flags of this instruction.
   uint64_t getFlags() const { return Flags; }
 
+  /// \returns true if this instruction is emitted before instruction selection
+  /// and should be legalized/regbankselected/selected.
+  bool isPreISelOpcode() const { return Flags & (1ULL << MCID::PreISelOpcode); }
+
   /// Return true if this instruction can have a variable number of
   /// operands.  In this case, the variable operands will be after the normal
   /// operands but before the implicit definitions and uses (if any are
@@ -272,7 +294,7 @@
 
   /// Returns true if this is a conditional, unconditional, or
   /// indirect branch.  Predicates below can be used to discriminate between
-  /// these cases, and the TargetInstrInfo::AnalyzeBranch method can be used to
+  /// these cases, and the TargetInstrInfo::analyzeBranch method can be used to
   /// get more information.
   bool isBranch() const { return Flags & (1ULL << MCID::Branch); }
 
@@ -282,18 +304,18 @@
 
   /// Return true if this is a branch which may fall
   /// through to the next instruction or may transfer control flow to some other
-  /// block.  The TargetInstrInfo::AnalyzeBranch method can be used to get more
+  /// block.  The TargetInstrInfo::analyzeBranch method can be used to get more
   /// information about this branch.
   bool isConditionalBranch() const {
-    return isBranch() & !isBarrier() & !isIndirectBranch();
+    return isBranch() && !isBarrier() && !isIndirectBranch();
   }
 
   /// Return true if this is a branch which always
   /// transfers control flow to some other block.  The
-  /// TargetInstrInfo::AnalyzeBranch method can be used to get more information
+  /// TargetInstrInfo::analyzeBranch method can be used to get more information
   /// about this branch.
   bool isUnconditionalBranch() const {
-    return isBranch() & isBarrier() & !isIndirectBranch();
+    return isBranch() && isBarrier() && !isIndirectBranch();
   }
 
   /// Return true if this is a branch or an instruction which directly
@@ -389,6 +411,15 @@
     return Flags & (1ULL << MCID::VariadicOpsAreDefs);
   }
 
+  /// Return true if this instruction authenticates a pointer (e.g. LDRAx/BRAx
+  /// from ARMv8.3, which perform loads/branches with authentication).
+  ///
+  /// An authenticated instruction may fail in an ABI-defined manner when
+  /// operating on an invalid signed pointer.
+  bool isAuthenticated() const {
+    return Flags & (1ULL << MCID::Authenticated);
+  }
+
   //===--------------------------------------------------------------------===//
   // Side Effect Analysis
   //===--------------------------------------------------------------------===//
diff --git a/linux-x64/clang/include/llvm/MC/MCInstrInfo.h b/linux-x64/clang/include/llvm/MC/MCInstrInfo.h
index 874b1e4..598e242 100644
--- a/linux-x64/clang/include/llvm/MC/MCInstrInfo.h
+++ b/linux-x64/clang/include/llvm/MC/MCInstrInfo.h
@@ -18,22 +18,40 @@
 
 namespace llvm {
 
+class MCSubtargetInfo;
+
 //---------------------------------------------------------------------------
 /// Interface to description of machine instruction set.
 class MCInstrInfo {
+public:
+  using ComplexDeprecationPredicate = bool (*)(MCInst &,
+                                               const MCSubtargetInfo &,
+                                               std::string &);
+
+private:
   const MCInstrDesc *Desc;          // Raw array to allow static init'n
   const unsigned *InstrNameIndices; // Array for name indices in InstrNameData
   const char *InstrNameData;        // Instruction name string pool
+  // Subtarget feature that an instruction is deprecated on, if any
+  // -1 implies this is not deprecated by any single feature. It may still be
+  // deprecated due to a "complex" reason, below.
+  const uint8_t *DeprecatedFeatures;
+  // A complex method to determine if a certain instruction is deprecated or
+  // not, and return the reason for deprecation.
+  const ComplexDeprecationPredicate *ComplexDeprecationInfos;
   unsigned NumOpcodes;              // Number of entries in the desc array
 
 public:
   /// Initialize MCInstrInfo, called by TableGen auto-generated routines.
   /// *DO NOT USE*.
   void InitMCInstrInfo(const MCInstrDesc *D, const unsigned *NI, const char *ND,
-                       unsigned NO) {
+                       const uint8_t *DF,
+                       const ComplexDeprecationPredicate *CDI, unsigned NO) {
     Desc = D;
     InstrNameIndices = NI;
     InstrNameData = ND;
+    DeprecatedFeatures = DF;
+    ComplexDeprecationInfos = CDI;
     NumOpcodes = NO;
   }
 
@@ -51,6 +69,11 @@
     assert(Opcode < NumOpcodes && "Invalid opcode!");
     return StringRef(&InstrNameData[InstrNameIndices[Opcode]]);
   }
+
+  /// Returns true if a certain instruction is deprecated and if so
+  /// returns the reason in \p Info.
+  bool getDeprecatedInfo(MCInst &MI, const MCSubtargetInfo &STI,
+                         std::string &Info) const;
 };
 
 } // End llvm namespace
diff --git a/linux-x64/clang/include/llvm/MC/MCInstrItineraries.h b/linux-x64/clang/include/llvm/MC/MCInstrItineraries.h
index 485aa66..652922f 100644
--- a/linux-x64/clang/include/llvm/MC/MCInstrItineraries.h
+++ b/linux-x64/clang/include/llvm/MC/MCInstrItineraries.h
@@ -61,8 +61,11 @@
     Reserved = 1
   };
 
+  /// Bitmask representing a set of functional units.
+  typedef uint64_t FuncUnits;
+
   unsigned Cycles_;  ///< Length of stage in machine cycles
-  unsigned Units_;   ///< Choice of functional units
+  FuncUnits Units_;  ///< Choice of functional units
   int NextCycles_;   ///< Number of machine cycles to next stage
   ReservationKinds Kind_; ///< Kind of the FU reservation
 
@@ -72,7 +75,7 @@
   }
 
   /// Returns the choice of FUs.
-  unsigned getUnits() const {
+  FuncUnits getUnits() const {
     return Units_;
   }
 
diff --git a/linux-x64/clang/include/llvm/MC/MCLinkerOptimizationHint.h b/linux-x64/clang/include/llvm/MC/MCLinkerOptimizationHint.h
index f2a1364..003491f 100644
--- a/linux-x64/clang/include/llvm/MC/MCLinkerOptimizationHint.h
+++ b/linux-x64/clang/include/llvm/MC/MCLinkerOptimizationHint.h
@@ -61,6 +61,7 @@
     MCLOHCaseNameToId(AdrpAdd)
     MCLOHCaseNameToId(AdrpLdrGot)
     .Default(-1);
+#undef MCLOHCaseNameToId
 }
 
 static inline StringRef MCLOHIdToName(MCLOHType Kind) {
@@ -76,6 +77,7 @@
     MCLOHCaseIdToName(AdrpLdrGot);
   }
   return StringRef();
+#undef MCLOHCaseIdToName
 }
 
 static inline int MCLOHIdToNbArgs(MCLOHType Kind) {
diff --git a/linux-x64/clang/include/llvm/MC/MCMachObjectWriter.h b/linux-x64/clang/include/llvm/MC/MCMachObjectWriter.h
index 278aebe..f4f9c47 100644
--- a/linux-x64/clang/include/llvm/MC/MCMachObjectWriter.h
+++ b/linux-x64/clang/include/llvm/MC/MCMachObjectWriter.h
@@ -16,6 +16,7 @@
 #include "llvm/MC/MCObjectWriter.h"
 #include "llvm/MC/MCSection.h"
 #include "llvm/MC/StringTableBuilder.h"
+#include "llvm/Support/EndianStream.h"
 #include <cstdint>
 #include <memory>
 #include <string>
@@ -28,7 +29,9 @@
 class MCMachObjectTargetWriter : public MCObjectTargetWriter {
   const unsigned Is64Bit : 1;
   const uint32_t CPUType;
-  const uint32_t CPUSubtype;
+protected:
+  uint32_t CPUSubtype;
+public:
   unsigned LocalDifference_RIT;
 
 protected:
@@ -42,7 +45,7 @@
 public:
   virtual ~MCMachObjectTargetWriter();
 
-  virtual Triple::ObjectFormatType getFormat() const { return Triple::MachO; }
+  Triple::ObjectFormatType getFormat() const override { return Triple::MachO; }
   static bool classof(const MCObjectTargetWriter *W) {
     return W->getFormat() == Triple::MachO;
   }
@@ -111,7 +114,7 @@
   /// \name Symbol Table Data
   /// @{
 
-  StringTableBuilder StringTable{StringTableBuilder::MachO};
+  StringTableBuilder StringTable;
   std::vector<MachSymbolData> LocalSymbolData;
   std::vector<MachSymbolData> ExternalSymbolData;
   std::vector<MachSymbolData> UndefinedSymbolData;
@@ -126,6 +129,8 @@
   MachObjectWriter(std::unique_ptr<MCMachObjectTargetWriter> MOTW,
                    raw_pwrite_stream &OS, bool IsLittleEndian)
       : TargetObjectWriter(std::move(MOTW)),
+        StringTable(TargetObjectWriter->is64Bit() ? StringTableBuilder::MachO64
+                                                  : StringTableBuilder::MachO),
         W(OS, IsLittleEndian ? support::little : support::big) {}
 
   support::endian::Writer W;
@@ -230,16 +235,6 @@
     Relocations[Sec].push_back(P);
   }
 
-  void recordScatteredRelocation(const MCAssembler &Asm,
-                                 const MCAsmLayout &Layout,
-                                 const MCFragment *Fragment,
-                                 const MCFixup &Fixup, MCValue Target,
-                                 unsigned Log2Size, uint64_t &FixedValue);
-
-  void recordTLVPRelocation(const MCAssembler &Asm, const MCAsmLayout &Layout,
-                            const MCFragment *Fragment, const MCFixup &Fixup,
-                            MCValue Target, uint64_t &FixedValue);
-
   void recordRelocation(MCAssembler &Asm, const MCAsmLayout &Layout,
                         const MCFragment *Fragment, const MCFixup &Fixup,
                         MCValue Target, uint64_t &FixedValue) override;
diff --git a/linux-x64/clang/include/llvm/MC/MCObjectFileInfo.h b/linux-x64/clang/include/llvm/MC/MCObjectFileInfo.h
index abc87bf..2e6a84b 100644
--- a/linux-x64/clang/include/llvm/MC/MCObjectFileInfo.h
+++ b/linux-x64/clang/include/llvm/MC/MCObjectFileInfo.h
@@ -27,20 +27,20 @@
 protected:
   /// True if .comm supports alignment.  This is a hack for as long as we
   /// support 10.4 Tiger, whose assembler doesn't support alignment on comm.
-  bool CommDirectiveSupportsAlignment;
+  bool CommDirectiveSupportsAlignment = false;
 
   /// True if target object file supports a weak_definition of constant 0 for an
   /// omitted EH frame.
-  bool SupportsWeakOmittedEHFrame;
+  bool SupportsWeakOmittedEHFrame = false;
 
   /// True if the target object file supports emitting a compact unwind section
   /// without an associated EH frame section.
-  bool SupportsCompactUnwindWithoutEHFrame;
+  bool SupportsCompactUnwindWithoutEHFrame = false;
 
   /// OmitDwarfIfHaveCompactUnwind - True if the target object file
   /// supports having some functions with compact unwind and other with
   /// dwarf unwind.
-  bool OmitDwarfIfHaveCompactUnwind;
+  bool OmitDwarfIfHaveCompactUnwind = false;
 
   /// FDE CFI encoding. Controls the encoding of the begin label in the
   /// .eh_frame section. Unlike the LSDA encoding, personality encoding, and
@@ -49,134 +49,141 @@
   unsigned FDECFIEncoding = 0;
 
   /// Compact unwind encoding indicating that we should emit only an EH frame.
-  unsigned CompactUnwindDwarfEHFrameOnly;
+  unsigned CompactUnwindDwarfEHFrameOnly = 0;
 
   /// Section directive for standard text.
-  MCSection *TextSection;
+  MCSection *TextSection = nullptr;
 
   /// Section directive for standard data.
-  MCSection *DataSection;
+  MCSection *DataSection = nullptr;
 
   /// Section that is default initialized to zero.
-  MCSection *BSSSection;
+  MCSection *BSSSection = nullptr;
 
   /// Section that is readonly and can contain arbitrary initialized data.
   /// Targets are not required to have a readonly section. If they don't,
   /// various bits of code will fall back to using the data section for
   /// constants.
-  MCSection *ReadOnlySection;
+  MCSection *ReadOnlySection = nullptr;
 
   /// If exception handling is supported by the target, this is the section the
   /// Language Specific Data Area information is emitted to.
-  MCSection *LSDASection;
+  MCSection *LSDASection = nullptr;
 
   /// If exception handling is supported by the target and the target can
   /// support a compact representation of the CIE and FDE, this is the section
   /// to emit them into.
-  MCSection *CompactUnwindSection;
+  MCSection *CompactUnwindSection = nullptr;
 
   // Dwarf sections for debug info.  If a target supports debug info, these must
   // be set.
-  MCSection *DwarfAbbrevSection;
-  MCSection *DwarfInfoSection;
-  MCSection *DwarfLineSection;
-  MCSection *DwarfLineStrSection;
-  MCSection *DwarfFrameSection;
-  MCSection *DwarfPubTypesSection;
-  const MCSection *DwarfDebugInlineSection;
-  MCSection *DwarfStrSection;
-  MCSection *DwarfLocSection;
-  MCSection *DwarfARangesSection;
-  MCSection *DwarfRangesSection;
-  MCSection *DwarfMacinfoSection;
+  MCSection *DwarfAbbrevSection = nullptr;
+  MCSection *DwarfInfoSection = nullptr;
+  MCSection *DwarfLineSection = nullptr;
+  MCSection *DwarfLineStrSection = nullptr;
+  MCSection *DwarfFrameSection = nullptr;
+  MCSection *DwarfPubTypesSection = nullptr;
+  const MCSection *DwarfDebugInlineSection = nullptr;
+  MCSection *DwarfStrSection = nullptr;
+  MCSection *DwarfLocSection = nullptr;
+  MCSection *DwarfARangesSection = nullptr;
+  MCSection *DwarfRangesSection = nullptr;
+  MCSection *DwarfMacinfoSection = nullptr;
+  MCSection *DwarfMacroSection = nullptr;
   // The pubnames section is no longer generated by default.  The generation
   // can be enabled by a compiler flag.
-  MCSection *DwarfPubNamesSection;
+  MCSection *DwarfPubNamesSection = nullptr;
 
   /// Accelerator table sections. DwarfDebugNamesSection is the DWARF v5
   /// accelerator table, while DwarfAccelNamesSection, DwarfAccelObjCSection,
   /// DwarfAccelNamespaceSection, DwarfAccelTypesSection are pre-DWARF v5
   /// extensions.
-  MCSection *DwarfDebugNamesSection;
-  MCSection *DwarfAccelNamesSection;
-  MCSection *DwarfAccelObjCSection;
-  MCSection *DwarfAccelNamespaceSection;
-  MCSection *DwarfAccelTypesSection;
+  MCSection *DwarfDebugNamesSection = nullptr;
+  MCSection *DwarfAccelNamesSection = nullptr;
+  MCSection *DwarfAccelObjCSection = nullptr;
+  MCSection *DwarfAccelNamespaceSection = nullptr;
+  MCSection *DwarfAccelTypesSection = nullptr;
 
   // These are used for the Fission separate debug information files.
-  MCSection *DwarfInfoDWOSection;
-  MCSection *DwarfTypesDWOSection;
-  MCSection *DwarfAbbrevDWOSection;
-  MCSection *DwarfStrDWOSection;
-  MCSection *DwarfLineDWOSection;
-  MCSection *DwarfLocDWOSection;
-  MCSection *DwarfStrOffDWOSection;
+  MCSection *DwarfInfoDWOSection = nullptr;
+  MCSection *DwarfTypesDWOSection = nullptr;
+  MCSection *DwarfAbbrevDWOSection = nullptr;
+  MCSection *DwarfStrDWOSection = nullptr;
+  MCSection *DwarfLineDWOSection = nullptr;
+  MCSection *DwarfLocDWOSection = nullptr;
+  MCSection *DwarfStrOffDWOSection = nullptr;
+  MCSection *DwarfMacinfoDWOSection = nullptr;
+  MCSection *DwarfMacroDWOSection = nullptr;
 
   /// The DWARF v5 string offset and address table sections.
-  MCSection *DwarfStrOffSection;
-  MCSection *DwarfAddrSection;
+  MCSection *DwarfStrOffSection = nullptr;
+  MCSection *DwarfAddrSection = nullptr;
   /// The DWARF v5 range list section.
-  MCSection *DwarfRnglistsSection;
+  MCSection *DwarfRnglistsSection = nullptr;
   /// The DWARF v5 locations list section.
-  MCSection *DwarfLoclistsSection;
+  MCSection *DwarfLoclistsSection = nullptr;
 
-  /// The DWARF v5 range list section for fission.
-  MCSection *DwarfRnglistsDWOSection;
+  /// The DWARF v5 range and location list sections for fission.
+  MCSection *DwarfRnglistsDWOSection = nullptr;
+  MCSection *DwarfLoclistsDWOSection = nullptr;
 
   // These are for Fission DWP files.
-  MCSection *DwarfCUIndexSection;
-  MCSection *DwarfTUIndexSection;
+  MCSection *DwarfCUIndexSection = nullptr;
+  MCSection *DwarfTUIndexSection = nullptr;
 
   /// Section for newer gnu pubnames.
-  MCSection *DwarfGnuPubNamesSection;
+  MCSection *DwarfGnuPubNamesSection = nullptr;
   /// Section for newer gnu pubtypes.
-  MCSection *DwarfGnuPubTypesSection;
+  MCSection *DwarfGnuPubTypesSection = nullptr;
 
   // Section for Swift AST
-  MCSection *DwarfSwiftASTSection;
+  MCSection *DwarfSwiftASTSection = nullptr;
 
-  MCSection *COFFDebugSymbolsSection;
-  MCSection *COFFDebugTypesSection;
-  MCSection *COFFGlobalTypeHashesSection;
+  MCSection *COFFDebugSymbolsSection = nullptr;
+  MCSection *COFFDebugTypesSection = nullptr;
+  MCSection *COFFGlobalTypeHashesSection = nullptr;
 
   /// Extra TLS Variable Data section.
   ///
   /// If the target needs to put additional information for a TLS variable,
   /// it'll go here.
-  MCSection *TLSExtraDataSection;
+  MCSection *TLSExtraDataSection = nullptr;
 
   /// Section directive for Thread Local data. ELF, MachO, COFF, and Wasm.
-  MCSection *TLSDataSection; // Defaults to ".tdata".
+  MCSection *TLSDataSection = nullptr; // Defaults to ".tdata".
 
   /// Section directive for Thread Local uninitialized data.
   ///
   /// Null if this target doesn't support a BSS section. ELF and MachO only.
-  MCSection *TLSBSSSection; // Defaults to ".tbss".
+  MCSection *TLSBSSSection = nullptr; // Defaults to ".tbss".
 
   /// StackMap section.
-  MCSection *StackMapSection;
+  MCSection *StackMapSection = nullptr;
 
   /// FaultMap section.
-  MCSection *FaultMapSection;
+  MCSection *FaultMapSection = nullptr;
 
   /// Remarks section.
-  MCSection *RemarksSection;
+  MCSection *RemarksSection = nullptr;
 
   /// EH frame section.
   ///
   /// It is initialized on demand so it can be overwritten (with uniquing).
-  MCSection *EHFrameSection;
+  MCSection *EHFrameSection = nullptr;
 
   /// Section containing metadata on function stack sizes.
-  MCSection *StackSizesSection;
-  mutable DenseMap<const MCSymbol *, unsigned> StackSizesUniquing;
+  MCSection *StackSizesSection = nullptr;
+
+  /// Section for pseudo probe information used by AutoFDO
+  MCSection *PseudoProbeSection = nullptr;
+  MCSection *PseudoProbeDescSection = nullptr;
 
   // ELF specific sections.
-  MCSection *DataRelROSection;
-  MCSection *MergeableConst4Section;
-  MCSection *MergeableConst8Section;
-  MCSection *MergeableConst16Section;
-  MCSection *MergeableConst32Section;
+  MCSection *DataRelROSection = nullptr;
+  MCSection *MergeableConst4Section = nullptr;
+  MCSection *MergeableConst8Section = nullptr;
+  MCSection *MergeableConst16Section = nullptr;
+  MCSection *MergeableConst32Section = nullptr;
 
   // MachO specific sections.
 
@@ -184,37 +191,44 @@
   ///
   /// Contains the source code name of the variable, visibility and a pointer to
   /// the initial value (.tdata or .tbss).
-  MCSection *TLSTLVSection; // Defaults to ".tlv".
+  MCSection *TLSTLVSection = nullptr; // Defaults to ".tlv".
 
   /// Section for thread local data initialization functions.
-  const MCSection *TLSThreadInitSection; // Defaults to ".thread_init_func".
+   // Defaults to ".thread_init_func".
+  const MCSection *TLSThreadInitSection = nullptr;
 
-  MCSection *CStringSection;
-  MCSection *UStringSection;
-  MCSection *TextCoalSection;
-  MCSection *ConstTextCoalSection;
-  MCSection *ConstDataSection;
-  MCSection *DataCoalSection;
-  MCSection *ConstDataCoalSection;
-  MCSection *DataCommonSection;
-  MCSection *DataBSSSection;
-  MCSection *FourByteConstantSection;
-  MCSection *EightByteConstantSection;
-  MCSection *SixteenByteConstantSection;
-  MCSection *LazySymbolPointerSection;
-  MCSection *NonLazySymbolPointerSection;
-  MCSection *ThreadLocalPointerSection;
+  MCSection *CStringSection = nullptr;
+  MCSection *UStringSection = nullptr;
+  MCSection *TextCoalSection = nullptr;
+  MCSection *ConstTextCoalSection = nullptr;
+  MCSection *ConstDataSection = nullptr;
+  MCSection *DataCoalSection = nullptr;
+  MCSection *ConstDataCoalSection = nullptr;
+  MCSection *DataCommonSection = nullptr;
+  MCSection *DataBSSSection = nullptr;
+  MCSection *FourByteConstantSection = nullptr;
+  MCSection *EightByteConstantSection = nullptr;
+  MCSection *SixteenByteConstantSection = nullptr;
+  MCSection *LazySymbolPointerSection = nullptr;
+  MCSection *NonLazySymbolPointerSection = nullptr;
+  MCSection *ThreadLocalPointerSection = nullptr;
 
   /// COFF specific sections.
-  MCSection *DrectveSection;
-  MCSection *PDataSection;
-  MCSection *XDataSection;
-  MCSection *SXDataSection;
-  MCSection *GFIDsSection;
+  MCSection *DrectveSection = nullptr;
+  MCSection *PDataSection = nullptr;
+  MCSection *XDataSection = nullptr;
+  MCSection *SXDataSection = nullptr;
+  MCSection *GFIDsSection = nullptr;
+  MCSection *GIATsSection = nullptr;
+  MCSection *GLJMPSection = nullptr;
+
+  // XCOFF specific sections
+  MCSection *TOCBaseSection = nullptr;
 
 public:
   void InitMCObjectFileInfo(const Triple &TT, bool PIC, MCContext &ctx,
                             bool LargeCodeModel = false);
+  MCContext &getContext() const { return *Ctx; }
 
   bool getSupportsWeakOmittedEHFrame() const {
     return SupportsWeakOmittedEHFrame;
@@ -240,7 +254,6 @@
   MCSection *getDataSection() const { return DataSection; }
   MCSection *getBSSSection() const { return BSSSection; }
   MCSection *getReadOnlySection() const { return ReadOnlySection; }
-  MCSection *getLSDASection() const { return LSDASection; }
   MCSection *getCompactUnwindSection() const { return CompactUnwindSection; }
   MCSection *getDwarfAbbrevSection() const { return DwarfAbbrevSection; }
   MCSection *getDwarfInfoSection() const { return DwarfInfoSection; }
@@ -268,6 +281,7 @@
   MCSection *getDwarfRnglistsSection() const { return DwarfRnglistsSection; }
   MCSection *getDwarfLoclistsSection() const { return DwarfLoclistsSection; }
   MCSection *getDwarfMacinfoSection() const { return DwarfMacinfoSection; }
+  MCSection *getDwarfMacroSection() const { return DwarfMacroSection; }
 
   MCSection *getDwarfDebugNamesSection() const {
     return DwarfDebugNamesSection;
@@ -297,6 +311,13 @@
   MCSection *getDwarfRnglistsDWOSection() const {
     return DwarfRnglistsDWOSection;
   }
+  MCSection *getDwarfLoclistsDWOSection() const {
+    return DwarfLoclistsDWOSection;
+  }
+  MCSection *getDwarfMacroDWOSection() const { return DwarfMacroDWOSection; }
+  MCSection *getDwarfMacinfoDWOSection() const {
+    return DwarfMacinfoDWOSection;
+  }
   MCSection *getDwarfCUIndexSection() const { return DwarfCUIndexSection; }
   MCSection *getDwarfTUIndexSection() const { return DwarfTUIndexSection; }
   MCSection *getDwarfSwiftASTSection() const { return DwarfSwiftASTSection; }
@@ -321,6 +342,12 @@
 
   MCSection *getStackSizesSection(const MCSection &TextSec) const;
 
+  MCSection *getBBAddrMapSection(const MCSection &TextSec) const;
+
+  MCSection *getPseudoProbeSection(const MCSection *TextSec) const;
+
+  MCSection *getPseudoProbeDescSection(StringRef FuncName) const;
+
   // ELF specific sections.
   MCSection *getDataRelROSection() const { return DataRelROSection; }
   const MCSection *getMergeableConst4Section() const {
@@ -379,10 +406,13 @@
   MCSection *getXDataSection() const { return XDataSection; }
   MCSection *getSXDataSection() const { return SXDataSection; }
   MCSection *getGFIDsSection() const { return GFIDsSection; }
+  MCSection *getGIATsSection() const { return GIATsSection; }
+  MCSection *getGLJMPSection() const { return GLJMPSection; }
 
-  MCSection *getEHFrameSection() {
-    return EHFrameSection;
-  }
+  // XCOFF specific sections
+  MCSection *getTOCBaseSection() const { return TOCBaseSection; }
+
+  MCSection *getEHFrameSection() const { return EHFrameSection; }
 
   enum Environment { IsMachO, IsELF, IsCOFF, IsWasm, IsXCOFF };
   Environment getObjectFileType() const { return Env; }
@@ -391,8 +421,8 @@
 
 private:
   Environment Env;
-  bool PositionIndependent;
-  MCContext *Ctx;
+  bool PositionIndependent = false;
+  MCContext *Ctx = nullptr;
   Triple TT;
   VersionTuple SDKVersion;
 
diff --git a/linux-x64/clang/include/llvm/MC/MCObjectStreamer.h b/linux-x64/clang/include/llvm/MC/MCObjectStreamer.h
index 8affca4..a00000b 100644
--- a/linux-x64/clang/include/llvm/MC/MCObjectStreamer.h
+++ b/linux-x64/clang/include/llvm/MC/MCObjectStreamer.h
@@ -9,6 +9,7 @@
 #ifndef LLVM_MC_MCOBJECTSTREAMER_H
 #define LLVM_MC_MCOBJECTSTREAMER_H
 
+#include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/MC/MCAssembler.h"
 #include "llvm/MC/MCSection.h"
@@ -38,6 +39,8 @@
   bool EmitEHFrame;
   bool EmitDebugFrame;
   SmallVector<MCSymbol *, 2> PendingLabels;
+  SmallSetVector<MCSection *, 4> PendingLabelSections;
+  unsigned CurSubsectionIdx;
   struct PendingMCFixup {
     const MCSymbol *Sym;
     MCFixup Fixup;
@@ -47,11 +50,11 @@
   };
   SmallVector<PendingMCFixup, 2> PendingFixups;
 
-  virtual void EmitInstToData(const MCInst &Inst, const MCSubtargetInfo&) = 0;
-  void EmitCFIStartProcImpl(MCDwarfFrameInfo &Frame) override;
-  void EmitCFIEndProcImpl(MCDwarfFrameInfo &Frame) override;
-  MCSymbol *EmitCFILabel() override;
-  void EmitInstructionImpl(const MCInst &Inst, const MCSubtargetInfo &STI);
+  virtual void emitInstToData(const MCInst &Inst, const MCSubtargetInfo&) = 0;
+  void emitCFIStartProcImpl(MCDwarfFrameInfo &Frame) override;
+  void emitCFIEndProcImpl(MCDwarfFrameInfo &Frame) override;
+  MCSymbol *emitCFILabel() override;
+  void emitInstructionImpl(const MCInst &Inst, const MCSubtargetInfo &STI);
   void resolvePendingFixups();
 
 protected:
@@ -67,8 +70,8 @@
   /// Object streamers require the integrated assembler.
   bool isIntegratedAssemblerRequired() const override { return true; }
 
-  void EmitFrames(MCAsmBackend *MAB);
-  void EmitCFISections(bool EH, bool Debug) override;
+  void emitFrames(MCAsmBackend *MAB);
+  void emitCFISections(bool EH, bool Debug) override;
 
   MCFragment *getCurrentFragment() const;
 
@@ -84,103 +87,106 @@
   /// Optionally a \p STI can be passed in so that a new fragment is created
   /// if the Subtarget differs from the current fragment.
   MCDataFragment *getOrCreateDataFragment(const MCSubtargetInfo* STI = nullptr);
-  MCPaddingFragment *getOrCreatePaddingFragment();
 
 protected:
   bool changeSectionImpl(MCSection *Section, const MCExpr *Subsection);
 
-  /// If any labels have been emitted but not assigned fragments, ensure that
-  /// they get assigned, either to F if possible or to a new data fragment.
-  /// Optionally, it is also possible to provide an offset \p FOffset, which
-  /// will be used as a symbol offset within the fragment.
+  /// Assign a label to the current Section and Subsection even though a
+  /// fragment is not yet present. Use flushPendingLabels(F) to associate
+  /// a fragment with this label.
+  void addPendingLabel(MCSymbol* label);
+
+  /// If any labels have been emitted but not assigned fragments in the current
+  /// Section and Subsection, ensure that they get assigned, either to fragment
+  /// F if possible or to a new data fragment. Optionally, one can provide an
+  /// offset \p FOffset as a symbol offset within the fragment.
   void flushPendingLabels(MCFragment *F, uint64_t FOffset = 0);
 
 public:
   void visitUsedSymbol(const MCSymbol &Sym) override;
 
-  /// Create a dummy fragment to assign any pending labels.
-  void flushPendingLabels() { flushPendingLabels(nullptr); }
+  /// Create a data fragment for any pending labels across all Sections
+  /// and Subsections.
+  void flushPendingLabels();
 
   MCAssembler &getAssembler() { return *Assembler; }
   MCAssembler *getAssemblerPtr() override;
   /// \name MCStreamer Interface
   /// @{
 
-  void EmitLabel(MCSymbol *Symbol, SMLoc Loc = SMLoc()) override;
-  virtual void EmitLabel(MCSymbol *Symbol, SMLoc Loc, MCFragment *F);
-  void EmitAssignment(MCSymbol *Symbol, const MCExpr *Value) override;
-  void EmitValueImpl(const MCExpr *Value, unsigned Size,
+  void emitLabel(MCSymbol *Symbol, SMLoc Loc = SMLoc()) override;
+  virtual void emitLabelAtPos(MCSymbol *Symbol, SMLoc Loc, MCFragment *F,
+                              uint64_t Offset);
+  void emitAssignment(MCSymbol *Symbol, const MCExpr *Value) override;
+  void emitValueImpl(const MCExpr *Value, unsigned Size,
                      SMLoc Loc = SMLoc()) override;
-  void EmitULEB128Value(const MCExpr *Value) override;
-  void EmitSLEB128Value(const MCExpr *Value) override;
-  void EmitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) override;
-  void ChangeSection(MCSection *Section, const MCExpr *Subsection) override;
-  void EmitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI) override;
+  void emitULEB128Value(const MCExpr *Value) override;
+  void emitSLEB128Value(const MCExpr *Value) override;
+  void emitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) override;
+  void changeSection(MCSection *Section, const MCExpr *Subsection) override;
+  void emitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI) override;
 
   /// Emit an instruction to a special fragment, because this instruction
   /// can change its size during relaxation.
-  virtual void EmitInstToFragment(const MCInst &Inst, const MCSubtargetInfo &);
+  virtual void emitInstToFragment(const MCInst &Inst, const MCSubtargetInfo &);
 
-  void EmitBundleAlignMode(unsigned AlignPow2) override;
-  void EmitBundleLock(bool AlignToEnd) override;
-  void EmitBundleUnlock() override;
-  void EmitBytes(StringRef Data) override;
-  void EmitValueToAlignment(unsigned ByteAlignment, int64_t Value = 0,
+  void emitBundleAlignMode(unsigned AlignPow2) override;
+  void emitBundleLock(bool AlignToEnd) override;
+  void emitBundleUnlock() override;
+  void emitBytes(StringRef Data) override;
+  void emitValueToAlignment(unsigned ByteAlignment, int64_t Value = 0,
                             unsigned ValueSize = 1,
                             unsigned MaxBytesToEmit = 0) override;
-  void EmitCodeAlignment(unsigned ByteAlignment,
+  void emitCodeAlignment(unsigned ByteAlignment,
                          unsigned MaxBytesToEmit = 0) override;
   void emitValueToOffset(const MCExpr *Offset, unsigned char Value,
                          SMLoc Loc) override;
-  void
-  EmitCodePaddingBasicBlockStart(const MCCodePaddingContext &Context) override;
-  void
-  EmitCodePaddingBasicBlockEnd(const MCCodePaddingContext &Context) override;
-  void EmitDwarfLocDirective(unsigned FileNo, unsigned Line,
-                             unsigned Column, unsigned Flags,
-                             unsigned Isa, unsigned Discriminator,
+  void emitDwarfLocDirective(unsigned FileNo, unsigned Line, unsigned Column,
+                             unsigned Flags, unsigned Isa,
+                             unsigned Discriminator,
                              StringRef FileName) override;
-  void EmitDwarfAdvanceLineAddr(int64_t LineDelta, const MCSymbol *LastLabel,
-                                const MCSymbol *Label,
-                                unsigned PointerSize);
-  void EmitDwarfAdvanceFrameAddr(const MCSymbol *LastLabel,
+  void emitDwarfAdvanceLineAddr(int64_t LineDelta, const MCSymbol *LastLabel,
+                                const MCSymbol *Label, unsigned PointerSize);
+  void emitDwarfAdvanceFrameAddr(const MCSymbol *LastLabel,
                                  const MCSymbol *Label);
-  void EmitCVLocDirective(unsigned FunctionId, unsigned FileNo, unsigned Line,
+  void emitCVLocDirective(unsigned FunctionId, unsigned FileNo, unsigned Line,
                           unsigned Column, bool PrologueEnd, bool IsStmt,
                           StringRef FileName, SMLoc Loc) override;
-  void EmitCVLinetableDirective(unsigned FunctionId, const MCSymbol *Begin,
+  void emitCVLinetableDirective(unsigned FunctionId, const MCSymbol *Begin,
                                 const MCSymbol *End) override;
-  void EmitCVInlineLinetableDirective(unsigned PrimaryFunctionId,
+  void emitCVInlineLinetableDirective(unsigned PrimaryFunctionId,
                                       unsigned SourceFileId,
                                       unsigned SourceLineNum,
                                       const MCSymbol *FnStartSym,
                                       const MCSymbol *FnEndSym) override;
-  void EmitCVDefRangeDirective(
+  void emitCVDefRangeDirective(
       ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges,
       StringRef FixedSizePortion) override;
-  void EmitCVStringTableDirective() override;
-  void EmitCVFileChecksumsDirective() override;
-  void EmitCVFileChecksumOffsetDirective(unsigned FileNo) override;
-  void EmitDTPRel32Value(const MCExpr *Value) override;
-  void EmitDTPRel64Value(const MCExpr *Value) override;
-  void EmitTPRel32Value(const MCExpr *Value) override;
-  void EmitTPRel64Value(const MCExpr *Value) override;
-  void EmitGPRel32Value(const MCExpr *Value) override;
-  void EmitGPRel64Value(const MCExpr *Value) override;
-  bool EmitRelocDirective(const MCExpr &Offset, StringRef Name,
-                          const MCExpr *Expr, SMLoc Loc,
-                          const MCSubtargetInfo &STI) override;
+  void emitCVStringTableDirective() override;
+  void emitCVFileChecksumsDirective() override;
+  void emitCVFileChecksumOffsetDirective(unsigned FileNo) override;
+  void emitDTPRel32Value(const MCExpr *Value) override;
+  void emitDTPRel64Value(const MCExpr *Value) override;
+  void emitTPRel32Value(const MCExpr *Value) override;
+  void emitTPRel64Value(const MCExpr *Value) override;
+  void emitGPRel32Value(const MCExpr *Value) override;
+  void emitGPRel64Value(const MCExpr *Value) override;
+  Optional<std::pair<bool, std::string>>
+  emitRelocDirective(const MCExpr &Offset, StringRef Name, const MCExpr *Expr,
+                     SMLoc Loc, const MCSubtargetInfo &STI) override;
   using MCStreamer::emitFill;
   void emitFill(const MCExpr &NumBytes, uint64_t FillValue,
                 SMLoc Loc = SMLoc()) override;
   void emitFill(const MCExpr &NumValues, int64_t Size, int64_t Expr,
                 SMLoc Loc = SMLoc()) override;
-  void EmitFileDirective(StringRef Filename) override;
+  void emitNops(int64_t NumBytes, int64_t ControlledNopLength,
+                SMLoc Loc) override;
+  void emitFileDirective(StringRef Filename) override;
 
-  void EmitAddrsig() override;
-  void EmitAddrsigSym(const MCSymbol *Sym) override;
+  void emitAddrsig() override;
+  void emitAddrsigSym(const MCSymbol *Sym) override;
 
-  void FinishImpl() override;
+  void finishImpl() override;
 
   /// Emit the absolute difference between two symbols if possible.
   ///
diff --git a/linux-x64/clang/include/llvm/MC/MCObjectWriter.h b/linux-x64/clang/include/llvm/MC/MCObjectWriter.h
index 2547b2b..ddc2301 100644
--- a/linux-x64/clang/include/llvm/MC/MCObjectWriter.h
+++ b/linux-x64/clang/include/llvm/MC/MCObjectWriter.h
@@ -9,13 +9,7 @@
 #ifndef LLVM_MC_MCOBJECTWRITER_H
 #define LLVM_MC_MCOBJECTWRITER_H
 
-#include "llvm/ADT/SmallVector.h"
-#include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Triple.h"
-#include "llvm/Support/Endian.h"
-#include "llvm/Support/EndianStream.h"
-#include "llvm/Support/raw_ostream.h"
-#include <cassert>
 #include <cstdint>
 
 namespace llvm {
diff --git a/linux-x64/clang/include/llvm/MC/MCParser/AsmCond.h b/linux-x64/clang/include/llvm/MC/MCParser/AsmCond.h
index ea21550..44edd2b 100644
--- a/linux-x64/clang/include/llvm/MC/MCParser/AsmCond.h
+++ b/linux-x64/clang/include/llvm/MC/MCParser/AsmCond.h
@@ -30,8 +30,6 @@
   ConditionalAssemblyType TheCond = NoCond;
   bool CondMet = false;
   bool Ignore = false;
-
-  AsmCond() = default;
 };
 
 } // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/MC/MCParser/AsmLexer.h b/linux-x64/clang/include/llvm/MC/MCParser/AsmLexer.h
index b729449..e187a28 100644
--- a/linux-x64/clang/include/llvm/MC/MCParser/AsmLexer.h
+++ b/linux-x64/clang/include/llvm/MC/MCParser/AsmLexer.h
@@ -30,6 +30,7 @@
   bool IsAtStartOfLine = true;
   bool IsAtStartOfStatement = true;
   bool IsPeeking = false;
+  bool EndStatementAtEOF = true;
 
 protected:
   /// LexToken - Read the next token and return its code.
@@ -41,7 +42,8 @@
   AsmLexer &operator=(const AsmLexer &) = delete;
   ~AsmLexer() override;
 
-  void setBuffer(StringRef Buf, const char *ptr = nullptr);
+  void setBuffer(StringRef Buf, const char *ptr = nullptr,
+                 bool EndStatementAtEOF = true);
 
   StringRef LexUntilEndOfStatement() override;
 
@@ -54,6 +56,7 @@
   bool isAtStartOfComment(const char *Ptr);
   bool isAtStatementSeparator(const char *Ptr);
   int getNextChar();
+  int peekNextChar();
   AsmToken ReturnError(const char *Loc, const std::string &Msg);
 
   AsmToken LexIdentifier();
diff --git a/linux-x64/clang/include/llvm/MC/MCParser/MCAsmLexer.h b/linux-x64/clang/include/llvm/MC/MCParser/MCAsmLexer.h
index e89abea..21966d1 100644
--- a/linux-x64/clang/include/llvm/MC/MCParser/MCAsmLexer.h
+++ b/linux-x64/clang/include/llvm/MC/MCParser/MCAsmLexer.h
@@ -49,7 +49,11 @@
   bool SkipSpace = true;
   bool AllowAtInIdentifier;
   bool IsAtStartOfStatement = true;
+  bool LexMasmHexFloats = false;
   bool LexMasmIntegers = false;
+  bool LexMasmStrings = false;
+  bool UseMasmDefaultRadix = false;
+  unsigned DefaultRadix = 10;
   AsmCommentConsumer *CommentConsumer = nullptr;
 
   MCAsmLexer();
@@ -147,9 +151,23 @@
     this->CommentConsumer = CommentConsumer;
   }
 
-  /// Set whether to lex masm-style binary and hex literals. They look like
-  /// 0b1101 and 0ABCh respectively.
+  /// Set whether to lex masm-style binary (e.g., 0b1101) and radix-specified
+  /// literals (e.g., 0ABCh [hex], 576t [decimal], 77o [octal], 1101y [binary]).
   void setLexMasmIntegers(bool V) { LexMasmIntegers = V; }
+
+  /// Set whether to use masm-style default-radix integer literals. If disabled,
+  /// assume decimal unless prefixed (e.g., 0x2c [hex], 077 [octal]).
+  void useMasmDefaultRadix(bool V) { UseMasmDefaultRadix = V; }
+
+  unsigned getMasmDefaultRadix() const { return DefaultRadix; }
+  void setMasmDefaultRadix(unsigned Radix) { DefaultRadix = Radix; }
+
+  /// Set whether to lex masm-style hex float literals, such as 3f800000r.
+  void setLexMasmHexFloats(bool V) { LexMasmHexFloats = V; }
+
+  /// Set whether to lex masm-style string literals, such as 'Can''t find file'
+  /// and "This ""value"" not found".
+  void setLexMasmStrings(bool V) { LexMasmStrings = V; }
 };
 
 } // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/MC/MCParser/MCAsmParser.h b/linux-x64/clang/include/llvm/MC/MCParser/MCAsmParser.h
index da5653e..391a6b0 100644
--- a/linux-x64/clang/include/llvm/MC/MCParser/MCAsmParser.h
+++ b/linux-x64/clang/include/llvm/MC/MCParser/MCAsmParser.h
@@ -90,6 +90,20 @@
   IdKind Kind;
 };
 
+// Generic type information for an assembly object.
+// All sizes measured in bytes.
+struct AsmTypeInfo {
+  StringRef Name;
+  unsigned Size = 0;
+  unsigned ElementSize = 0;
+  unsigned Length = 0;
+};
+
+struct AsmFieldInfo {
+  AsmTypeInfo Type;
+  unsigned Offset = 0;
+};
+
 /// Generic Sema callback for assembly parser.
 class MCAsmParserSemaCallback {
 public:
@@ -165,8 +179,24 @@
   /// Run the parser on the input source buffer.
   virtual bool Run(bool NoInitialTextSection, bool NoFinalize = false) = 0;
 
-  virtual void setParsingInlineAsm(bool V) = 0;
-  virtual bool isParsingInlineAsm() = 0;
+  virtual void setParsingMSInlineAsm(bool V) = 0;
+  virtual bool isParsingMSInlineAsm() = 0;
+
+  virtual bool isParsingMasm() const { return false; }
+
+  virtual bool defineMacro(StringRef Name, StringRef Value) { return true; }
+
+  virtual bool lookUpField(StringRef Name, AsmFieldInfo &Info) const {
+    return true;
+  }
+  virtual bool lookUpField(StringRef Base, StringRef Member,
+                           AsmFieldInfo &Info) const {
+    return true;
+  }
+
+  virtual bool lookUpType(StringRef Name, AsmTypeInfo &Info) const {
+    return true;
+  }
 
   /// Parse MS-style inline assembly.
   virtual bool parseMSInlineAsm(
@@ -250,6 +280,10 @@
   /// characters and return the string contents.
   virtual bool parseEscapedString(std::string &Data) = 0;
 
+  /// Parse an angle-bracket delimited string at the current position if one is
+  /// present, returning the string contents.
+  virtual bool parseAngleBracketString(std::string &Data) = 0;
+
   /// Skip to the end of the current statement, for error recovery.
   virtual void eatToEndOfStatement() = 0;
 
@@ -266,7 +300,8 @@
   /// \param Res - The value of the expression. The result is undefined
   /// on error.
   /// \return - False on success.
-  virtual bool parsePrimaryExpr(const MCExpr *&Res, SMLoc &EndLoc) = 0;
+  virtual bool parsePrimaryExpr(const MCExpr *&Res, SMLoc &EndLoc,
+                                AsmTypeInfo *TypeInfo) = 0;
 
   /// Parse an arbitrary expression, assuming that an initial '(' has
   /// already been consumed.
@@ -300,10 +335,14 @@
                                      SMLoc &EndLoc) = 0;
 };
 
-/// Create an MCAsmParser instance.
+/// Create an MCAsmParser instance for parsing assembly similar to gas syntax
 MCAsmParser *createMCAsmParser(SourceMgr &, MCContext &, MCStreamer &,
                                const MCAsmInfo &, unsigned CB = 0);
 
+/// Create an MCAsmParser instance for parsing Microsoft MASM-style assembly
+MCAsmParser *createMCMasmParser(SourceMgr &, MCContext &, MCStreamer &,
+                                const MCAsmInfo &, unsigned CB = 0);
+
 } // end namespace llvm
 
 #endif // LLVM_MC_MCPARSER_MCASMPARSER_H
diff --git a/linux-x64/clang/include/llvm/MC/MCParser/MCAsmParserExtension.h b/linux-x64/clang/include/llvm/MC/MCParser/MCAsmParserExtension.h
index 5d2afe8..c37889c 100644
--- a/linux-x64/clang/include/llvm/MC/MCParser/MCAsmParserExtension.h
+++ b/linux-x64/clang/include/llvm/MC/MCParser/MCAsmParserExtension.h
@@ -98,6 +98,8 @@
     return getParser().parseOptionalToken(T);
   }
 
+  bool ParseDirectiveCGProfile(StringRef, SMLoc);
+
   bool check(bool P, const Twine &Msg) {
     return getParser().check(P, Msg);
   }
diff --git a/linux-x64/clang/include/llvm/MC/MCParser/MCParsedAsmOperand.h b/linux-x64/clang/include/llvm/MC/MCParser/MCParsedAsmOperand.h
index 2b6e2aa..abb9562 100644
--- a/linux-x64/clang/include/llvm/MC/MCParser/MCParsedAsmOperand.h
+++ b/linux-x64/clang/include/llvm/MC/MCParser/MCParsedAsmOperand.h
@@ -71,10 +71,10 @@
   /// variable/label?   Only valid when parsing MS-style inline assembly.
   virtual bool needAddressOf() const { return false; }
 
-  /// isOffsetOf - Do we need to emit code to get the offset of the variable,
-  /// rather then the value of the variable?   Only valid when parsing MS-style
-  /// inline assembly.
-  virtual bool isOffsetOf() const { return false; }
+  /// isOffsetOfLocal - Do we need to emit code to get the offset of the local
+  /// variable, rather than its value?   Only valid when parsing MS-style inline
+  /// assembly.
+  virtual bool isOffsetOfLocal() const { return false; }
 
   /// getOffsetOfLoc - Get the location of the offset operator.
   virtual SMLoc getOffsetOfLoc() const { return SMLoc(); }
diff --git a/linux-x64/clang/include/llvm/MC/MCParser/MCTargetAsmParser.h b/linux-x64/clang/include/llvm/MC/MCParser/MCTargetAsmParser.h
index 849dbd5..0a1e50d 100644
--- a/linux-x64/clang/include/llvm/MC/MCParser/MCTargetAsmParser.h
+++ b/linux-x64/clang/include/llvm/MC/MCParser/MCTargetAsmParser.h
@@ -24,7 +24,6 @@
 namespace llvm {
 
 class MCInst;
-class MCParsedAsmOperand;
 class MCStreamer;
 class MCSubtargetInfo;
 template <typename T> class SmallVectorImpl;
@@ -35,6 +34,7 @@
   AOK_Align,          // Rewrite align as .align.
   AOK_EVEN,           // Rewrite even as .even.
   AOK_Emit,           // Rewrite _emit as .byte.
+  AOK_CallInput,      // Rewrite in terms of ${N:P}.
   AOK_Input,          // Rewrite in terms of $N.
   AOK_Output,         // Rewrite in terms of $N.
   AOK_SizeDirective,  // Add a sizing directive (e.g., dword ptr).
@@ -49,6 +49,7 @@
   2, // AOK_EVEN
   2, // AOK_Emit
   3, // AOK_Input
+  3, // AOK_CallInput
   3, // AOK_Output
   5, // AOK_SizeDirective
   1, // AOK_Label
@@ -64,39 +65,27 @@
   int64_t Imm;
   StringRef BaseReg;
   StringRef IndexReg;
+  StringRef OffsetName;
   unsigned Scale;
 
-  IntelExpr(bool needBracs = false) : NeedBracs(needBracs), Imm(0),
-    BaseReg(StringRef()), IndexReg(StringRef()),
-    Scale(1) {}
-  // Compund immediate expression
-  IntelExpr(int64_t imm, bool needBracs) : IntelExpr(needBracs) {
-    Imm = imm;
-  }
-  // [Reg + ImmediateExpression]
-  // We don't bother to emit an immediate expression evaluated to zero
-  IntelExpr(StringRef reg, int64_t imm = 0, unsigned scale = 0,
-    bool needBracs = true) :
-    IntelExpr(imm, needBracs) {
-    IndexReg = reg;
+  IntelExpr()
+      : NeedBracs(false), Imm(0), BaseReg(StringRef()), IndexReg(StringRef()),
+        OffsetName(StringRef()), Scale(1) {}
+  // [BaseReg + IndexReg * ScaleExpression + OFFSET name + ImmediateExpression]
+  IntelExpr(StringRef baseReg, StringRef indexReg, unsigned scale,
+            StringRef offsetName, int64_t imm, bool needBracs)
+      : NeedBracs(needBracs), Imm(imm), BaseReg(baseReg), IndexReg(indexReg),
+        OffsetName(offsetName), Scale(1) {
     if (scale)
       Scale = scale;
   }
-  // [BaseReg + IndexReg * ScaleExpression + ImmediateExpression]
-  IntelExpr(StringRef baseReg, StringRef indexReg, unsigned scale = 0,
-    int64_t imm = 0, bool needBracs = true) :
-    IntelExpr(indexReg, imm, scale, needBracs) {
-    BaseReg = baseReg;
-  }
-  bool hasBaseReg() const {
-    return BaseReg.size();
-  }
-  bool hasIndexReg() const {
-    return IndexReg.size();
-  }
-  bool hasRegs() const {
-    return hasBaseReg() || hasIndexReg();
-  }
+  bool hasBaseReg() const { return !BaseReg.empty(); }
+  bool hasIndexReg() const { return !IndexReg.empty(); }
+  bool hasRegs() const { return hasBaseReg() || hasIndexReg(); }
+  bool hasOffset() const { return !OffsetName.empty(); }
+  // Normally we won't emit immediates unconditionally,
+  // unless we've got no other components
+  bool emitImm() const { return !(hasRegs() || hasOffset()); }
   bool isValid() const {
     return (Scale == 1) ||
            (hasIndexReg() && (Scale == 2 || Scale == 4 || Scale == 8));
@@ -107,13 +96,14 @@
   AsmRewriteKind Kind;
   SMLoc Loc;
   unsigned Len;
+  bool Done;
   int64_t Val;
   StringRef Label;
   IntelExpr IntelExp;
 
 public:
   AsmRewrite(AsmRewriteKind kind, SMLoc loc, unsigned len = 0, int64_t val = 0)
-    : Kind(kind), Loc(loc), Len(len), Val(val) {}
+    : Kind(kind), Loc(loc), Len(len), Done(false), Val(val) {}
   AsmRewrite(AsmRewriteKind kind, SMLoc loc, unsigned len, StringRef label)
     : AsmRewrite(kind, loc, len) { Label = label; }
   AsmRewrite(SMLoc loc, unsigned len, IntelExpr exp)
@@ -174,6 +164,7 @@
                    : DiagnosticPredicateTy::NearMatch) {}
   DiagnosticPredicate(DiagnosticPredicateTy T) : Type(T) {}
   DiagnosticPredicate(const DiagnosticPredicate &) = default;
+  DiagnosticPredicate& operator=(const DiagnosticPredicate &) = default;
 
   operator bool() const { return Type == DiagnosticPredicateTy::Match; }
   bool isMatch() const { return Type == DiagnosticPredicateTy::Match; }
@@ -337,12 +328,12 @@
   /// AvailableFeatures - The current set of available features.
   FeatureBitset AvailableFeatures;
 
-  /// ParsingInlineAsm - Are we parsing ms-style inline assembly?
-  bool ParsingInlineAsm = false;
+  /// ParsingMSInlineAsm - Are we parsing ms-style inline assembly?
+  bool ParsingMSInlineAsm = false;
 
   /// SemaCallback - The Sema callback implementation.  Must be set when parsing
   /// ms-style inline assembly.
-  MCAsmParserSemaCallback *SemaCallback;
+  MCAsmParserSemaCallback *SemaCallback = nullptr;
 
   /// Set of options which affects instrumentation of inline assembly.
   MCTargetOptions MCOptions;
@@ -367,8 +358,8 @@
     AvailableFeatures = Value;
   }
 
-  bool isParsingInlineAsm () { return ParsingInlineAsm; }
-  void setParsingInlineAsm (bool Value) { ParsingInlineAsm = Value; }
+  bool isParsingMSInlineAsm () { return ParsingMSInlineAsm; }
+  void setParsingMSInlineAsm (bool Value) { ParsingMSInlineAsm = Value; }
 
   MCTargetOptions getTargetOptions() const { return MCOptions; }
 
@@ -378,12 +369,20 @@
 
   // Target-specific parsing of expression.
   virtual bool parsePrimaryExpr(const MCExpr *&Res, SMLoc &EndLoc) {
-    return getParser().parsePrimaryExpr(Res, EndLoc);
+    return getParser().parsePrimaryExpr(Res, EndLoc, nullptr);
   }
 
   virtual bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc,
                              SMLoc &EndLoc) = 0;
 
+  /// tryParseRegister - parse one register if possible
+  ///
+  /// Check whether a register specification can be parsed at the current
+  /// location, without failing the entire parse if it can't. Must not consume
+  /// tokens if the parse fails.
+  virtual OperandMatchResultTy
+  tryParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc) = 0;
+
   /// ParseInstruction - Parse one assembly instruction.
   ///
   /// The parser is positioned following the instruction name. The target
diff --git a/linux-x64/clang/include/llvm/MC/MCPseudoProbe.h b/linux-x64/clang/include/llvm/MC/MCPseudoProbe.h
new file mode 100644
index 0000000..b9a6196
--- /dev/null
+++ b/linux-x64/clang/include/llvm/MC/MCPseudoProbe.h
@@ -0,0 +1,178 @@
+//===- MCPseudoProbe.h - Pseudo probe encoding support ---------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains the declaration of the MCPseudoProbe to support the pseudo
+// probe encoding for AutoFDO. Pseudo probes together with their inline context
+// are encoded in a DFS recursive way in the .pseudoprobe sections. For each
+// .pseudoprobe section, the encoded binary data consist of a single or mutiple
+// function records each for one outlined function. A function record has the
+// following format :
+//
+// FUNCTION BODY (one for each outlined function present in the text section)
+//    GUID (uint64)
+//        GUID of the function
+//    NPROBES (ULEB128)
+//        Number of probes originating from this function.
+//    NUM_INLINED_FUNCTIONS (ULEB128)
+//        Number of callees inlined into this function, aka number of
+//        first-level inlinees
+//    PROBE RECORDS
+//        A list of NPROBES entries. Each entry contains:
+//          INDEX (ULEB128)
+//          TYPE (uint4)
+//            0 - block probe, 1 - indirect call, 2 - direct call
+//          ATTRIBUTE (uint3)
+//            reserved
+//          ADDRESS_TYPE (uint1)
+//            0 - code address, 1 - address delta
+//          CODE_ADDRESS (uint64 or ULEB128)
+//            code address or address delta, depending on ADDRESS_TYPE
+//    INLINED FUNCTION RECORDS
+//        A list of NUM_INLINED_FUNCTIONS entries describing each of the inlined
+//        callees.  Each record contains:
+//          INLINE SITE
+//            GUID of the inlinee (uint64)
+//            ID of the callsite probe (ULEB128)
+//          FUNCTION BODY
+//            A FUNCTION BODY entry describing the inlined function.
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_MC_MCPSEUDOPROBE_H
+#define LLVM_MC_MCPSEUDOPROBE_H
+
+#include "llvm/ADT/MapVector.h"
+#include "llvm/MC/MCSection.h"
+#include <functional>
+#include <map>
+#include <vector>
+
+namespace llvm {
+
+class MCStreamer;
+class MCSymbol;
+class MCObjectStreamer;
+
+enum class MCPseudoProbeFlag {
+  // If set, indicates that the probe is encoded as an address delta
+  // instead of a real code address.
+  AddressDelta = 0x1,
+};
+
+/// Instances of this class represent a pseudo probe instance for a pseudo probe
+/// table entry, which is created during a machine instruction is assembled and
+/// uses an address from a temporary label created at the current address in the
+/// current section.
+class MCPseudoProbe {
+  MCSymbol *Label;
+  uint64_t Guid;
+  uint64_t Index;
+  uint8_t Type;
+  uint8_t Attributes;
+
+public:
+  MCPseudoProbe(MCSymbol *Label, uint64_t Guid, uint64_t Index, uint64_t Type,
+                uint64_t Attributes)
+      : Label(Label), Guid(Guid), Index(Index), Type(Type),
+        Attributes(Attributes) {
+    assert(Type <= 0xFF && "Probe type too big to encode, exceeding 2^8");
+    assert(Attributes <= 0xFF &&
+           "Probe attributes too big to encode, exceeding 2^16");
+  }
+
+  MCSymbol *getLabel() const { return Label; }
+
+  uint64_t getGuid() const { return Guid; }
+
+  uint64_t getIndex() const { return Index; }
+
+  uint8_t getType() const { return Type; }
+
+  uint8_t getAttributes() const { return Attributes; }
+
+  void emit(MCObjectStreamer *MCOS, const MCPseudoProbe *LastProbe) const;
+};
+
+// An inline frame has the form <Guid, ProbeID>
+using InlineSite = std::tuple<uint64_t, uint32_t>;
+using MCPseudoProbeInlineStack = SmallVector<InlineSite, 8>;
+
+// A Tri-tree based data structure to group probes by inline stack.
+// A tree is allocated for a standalone .text section. A fake
+// instance is created as the root of a tree.
+// A real instance of this class is created for each function, either an
+// unlined function that has code in .text section or an inlined function.
+class MCPseudoProbeInlineTree {
+  uint64_t Guid;
+  // Set of probes that come with the function.
+  std::vector<MCPseudoProbe> Probes;
+  // Use std::map for a deterministic output.
+  std::map<InlineSite, MCPseudoProbeInlineTree *> Inlinees;
+
+  // Root node has a GUID 0.
+  bool isRoot() { return Guid == 0; }
+  MCPseudoProbeInlineTree *getOrAddNode(InlineSite Site);
+
+public:
+  MCPseudoProbeInlineTree() = default;
+  MCPseudoProbeInlineTree(uint64_t Guid) : Guid(Guid) {}
+  ~MCPseudoProbeInlineTree();
+  void addPseudoProbe(const MCPseudoProbe &Probe,
+                      const MCPseudoProbeInlineStack &InlineStack);
+  void emit(MCObjectStreamer *MCOS, const MCPseudoProbe *&LastProbe);
+};
+
+/// Instances of this class represent the pseudo probes inserted into a compile
+/// unit.
+class MCPseudoProbeSection {
+public:
+  void addPseudoProbe(MCSection *Sec, const MCPseudoProbe &Probe,
+                      const MCPseudoProbeInlineStack &InlineStack) {
+    MCProbeDivisions[Sec].addPseudoProbe(Probe, InlineStack);
+  }
+
+  // TODO: Sort by getOrdinal to ensure a determinstic section order
+  using MCProbeDivisionMap = std::map<MCSection *, MCPseudoProbeInlineTree>;
+
+private:
+  // A collection of MCPseudoProbe for each text section. The MCPseudoProbes
+  // are grouped by GUID of the functions where they are from and will be
+  // encoded by groups. In the comdat scenario where a text section really only
+  // contains the code of a function solely, the probes associated with a comdat
+  // function are still grouped by GUIDs due to inlining that can bring probes
+  // from different functions into one function.
+  MCProbeDivisionMap MCProbeDivisions;
+
+public:
+  const MCProbeDivisionMap &getMCProbes() const { return MCProbeDivisions; }
+
+  bool empty() const { return MCProbeDivisions.empty(); }
+
+  void emit(MCObjectStreamer *MCOS);
+};
+
+class MCPseudoProbeTable {
+  // A collection of MCPseudoProbe in the current module grouped by text
+  // sections. MCPseudoProbes will be encoded into a corresponding
+  // .pseudoprobe section. With functions emitted as separate comdats,
+  // a text section really only contains the code of a function solely, and the
+  // probes associated with the text section will be emitted into a standalone
+  // .pseudoprobe section that shares the same comdat group with the function.
+  MCPseudoProbeSection MCProbeSections;
+
+public:
+  static void emit(MCObjectStreamer *MCOS);
+
+  MCPseudoProbeSection &getProbeSections() { return MCProbeSections; }
+
+#ifndef NDEBUG
+  static int DdgPrintIndent;
+#endif
+};
+} // end namespace llvm
+
+#endif // LLVM_MC_MCPSEUDOPROBE_H
diff --git a/linux-x64/clang/include/llvm/MC/MCRegister.h b/linux-x64/clang/include/llvm/MC/MCRegister.h
new file mode 100644
index 0000000..8bbeab5
--- /dev/null
+++ b/linux-x64/clang/include/llvm/MC/MCRegister.h
@@ -0,0 +1,114 @@
+//===-- llvm/MC/Register.h --------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_MC_REGISTER_H
+#define LLVM_MC_REGISTER_H
+
+#include "llvm/ADT/DenseMapInfo.h"
+#include <cassert>
+
+namespace llvm {
+
+/// An unsigned integer type large enough to represent all physical registers,
+/// but not necessarily virtual registers.
+using MCPhysReg = uint16_t;
+
+/// Wrapper class representing physical registers. Should be passed by value.
+class MCRegister {
+  friend hash_code hash_value(const MCRegister &);
+  unsigned Reg;
+
+public:
+  constexpr MCRegister(unsigned Val = 0): Reg(Val) {}
+
+  // Register numbers can represent physical registers, virtual registers, and
+  // sometimes stack slots. The unsigned values are divided into these ranges:
+  //
+  //   0           Not a register, can be used as a sentinel.
+  //   [1;2^30)    Physical registers assigned by TableGen.
+  //   [2^30;2^31) Stack slots. (Rarely used.)
+  //   [2^31;2^32) Virtual registers assigned by MachineRegisterInfo.
+  //
+  // Further sentinels can be allocated from the small negative integers.
+  // DenseMapInfo<unsigned> uses -1u and -2u.
+  static_assert(std::numeric_limits<decltype(Reg)>::max() >= 0xFFFFFFFF,
+                "Reg isn't large enough to hold full range.");
+  static constexpr unsigned NoRegister = 0u;
+  static constexpr unsigned FirstPhysicalReg = 1u;
+  static constexpr unsigned FirstStackSlot = 1u << 30;
+  static constexpr unsigned VirtualRegFlag = 1u << 31;
+
+  /// This is the portion of the positive number space that is not a physical
+  /// register. StackSlot values do not exist in the MC layer, see
+  /// Register::isStackSlot() for the more information on them.
+  ///
+  static bool isStackSlot(unsigned Reg) {
+    return FirstStackSlot <= Reg && Reg < VirtualRegFlag;
+  }
+
+  /// Return true if the specified register number is in
+  /// the physical register namespace.
+  static bool isPhysicalRegister(unsigned Reg) {
+    return FirstPhysicalReg <= Reg && Reg < FirstStackSlot;
+  }
+
+  constexpr operator unsigned() const {
+    return Reg;
+  }
+
+  /// Check the provided unsigned value is a valid MCRegister.
+  static MCRegister from(unsigned Val) {
+    assert(Val == NoRegister || isPhysicalRegister(Val));
+    return MCRegister(Val);
+  }
+
+  unsigned id() const {
+    return Reg;
+  }
+
+  bool isValid() const { return Reg != NoRegister; }
+
+  /// Comparisons between register objects
+  bool operator==(const MCRegister &Other) const { return Reg == Other.Reg; }
+  bool operator!=(const MCRegister &Other) const { return Reg != Other.Reg; }
+
+  /// Comparisons against register constants. E.g.
+  /// * R == AArch64::WZR
+  /// * R == 0
+  /// * R == VirtRegMap::NO_PHYS_REG
+  bool operator==(unsigned Other) const { return Reg == Other; }
+  bool operator!=(unsigned Other) const { return Reg != Other; }
+  bool operator==(int Other) const { return Reg == unsigned(Other); }
+  bool operator!=(int Other) const { return Reg != unsigned(Other); }
+  // MSVC requires that we explicitly declare these two as well.
+  bool operator==(MCPhysReg Other) const { return Reg == unsigned(Other); }
+  bool operator!=(MCPhysReg Other) const { return Reg != unsigned(Other); }
+};
+
+// Provide DenseMapInfo for MCRegister
+template<> struct DenseMapInfo<MCRegister> {
+  static inline unsigned getEmptyKey() {
+    return DenseMapInfo<unsigned>::getEmptyKey();
+  }
+  static inline unsigned getTombstoneKey() {
+    return DenseMapInfo<unsigned>::getTombstoneKey();
+  }
+  static unsigned getHashValue(const MCRegister &Val) {
+    return DenseMapInfo<unsigned>::getHashValue(Val.id());
+  }
+  static bool isEqual(const MCRegister &LHS, const MCRegister &RHS) {
+    return DenseMapInfo<unsigned>::isEqual(LHS.id(), RHS.id());
+  }
+};
+
+inline hash_code hash_value(const MCRegister &Reg) {
+  return hash_value(Reg.id());
+}
+}
+
+#endif // ifndef LLVM_MC_REGISTER_H
diff --git a/linux-x64/clang/include/llvm/MC/MCRegisterInfo.h b/linux-x64/clang/include/llvm/MC/MCRegisterInfo.h
index 92d39c3..0c1ac62 100644
--- a/linux-x64/clang/include/llvm/MC/MCRegisterInfo.h
+++ b/linux-x64/clang/include/llvm/MC/MCRegisterInfo.h
@@ -16,18 +16,17 @@
 #define LLVM_MC_MCREGISTERINFO_H
 
 #include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/iterator.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/MC/LaneBitmask.h"
+#include "llvm/MC/MCRegister.h"
 #include <cassert>
 #include <cstdint>
+#include <iterator>
 #include <utility>
 
 namespace llvm {
 
-/// An unsigned integer type large enough to represent all physical registers,
-/// but not necessarily virtual registers.
-using MCPhysReg = uint16_t;
-
 /// MCRegisterClass - Base class of TargetRegisterClass.
 class MCRegisterClass {
 public:
@@ -65,16 +64,17 @@
 
   /// contains - Return true if the specified register is included in this
   /// register class.  This does not include virtual registers.
-  bool contains(unsigned Reg) const {
-    unsigned InByte = Reg % 8;
-    unsigned Byte = Reg / 8;
+  bool contains(MCRegister Reg) const {
+    unsigned RegNo = unsigned(Reg);
+    unsigned InByte = RegNo % 8;
+    unsigned Byte = RegNo / 8;
     if (Byte >= RegSetSize)
       return false;
     return (RegSet[Byte] & (1 << InByte)) != 0;
   }
 
   /// contains - Return true if both registers are in this class.
-  bool contains(unsigned Reg1, unsigned Reg2) const {
+  bool contains(MCRegister Reg1, MCRegister Reg2) const {
     return contains(Reg1) && contains(Reg2);
   }
 
@@ -148,8 +148,8 @@
 private:
   const MCRegisterDesc *Desc;                 // Pointer to the descriptor array
   unsigned NumRegs;                           // Number of entries in the array
-  unsigned RAReg;                             // Return address register
-  unsigned PCReg;                             // Program counter register
+  MCRegister RAReg;                           // Return address register
+  MCRegister PCReg;                           // Program counter register
   const MCRegisterClass *Classes;             // Pointer to the regclass array
   unsigned NumClasses;                        // Number of entries in the array
   unsigned NumRegUnits;                       // Number of regunits.
@@ -175,10 +175,13 @@
   const DwarfLLVMRegPair *EHL2DwarfRegs;      // LLVM to Dwarf regs mapping EH
   const DwarfLLVMRegPair *Dwarf2LRegs;        // Dwarf to LLVM regs mapping
   const DwarfLLVMRegPair *EHDwarf2LRegs;      // Dwarf to LLVM regs mapping EH
-  DenseMap<unsigned, int> L2SEHRegs;          // LLVM to SEH regs mapping
-  DenseMap<unsigned, int> L2CVRegs;           // LLVM to CV regs mapping
+  DenseMap<MCRegister, int> L2SEHRegs;        // LLVM to SEH regs mapping
+  DenseMap<MCRegister, int> L2CVRegs;         // LLVM to CV regs mapping
 
 public:
+  // Forward declaration to become a friend class of DiffListIterator.
+  template <class SubT> class mc_difflist_iterator;
+
   /// DiffListIterator - Base iterator class that can traverse the
   /// differentially encoded register and regunit lists in DiffLists.
   /// Don't use this class directly, use one of the specialized sub-classes
@@ -202,7 +205,7 @@
     /// advance - Move to the next list position, return the applied
     /// differential. This function does not detect the end of the list, that
     /// is the caller's responsibility (by checking for a 0 return value).
-    unsigned advance() {
+    MCRegister advance() {
       assert(isValid() && "Cannot move off the end of the list.");
       MCPhysReg D = *List++;
       Val += D;
@@ -214,7 +217,7 @@
     bool isValid() const { return List; }
 
     /// Dereference the iterator to get the value at the current position.
-    unsigned operator*() const { return Val; }
+    MCRegister operator*() const { return Val; }
 
     /// Pre-increment to move to the next position.
     void operator++() {
@@ -222,8 +225,113 @@
       if (!advance())
         List = nullptr;
     }
+
+    template <class SubT> friend class MCRegisterInfo::mc_difflist_iterator;
   };
 
+  /// Forward iterator using DiffListIterator.
+  template <class SubT>
+  class mc_difflist_iterator
+      : public iterator_facade_base<mc_difflist_iterator<SubT>,
+                                    std::forward_iterator_tag, MCPhysReg> {
+    MCRegisterInfo::DiffListIterator Iter;
+    /// Current value as MCPhysReg, so we can return a reference to it.
+    MCPhysReg Val;
+
+  protected:
+    mc_difflist_iterator(MCRegisterInfo::DiffListIterator Iter) : Iter(Iter) {}
+
+    // Allow conversion between instantiations where valid.
+    mc_difflist_iterator(MCRegister Reg, const MCPhysReg *DiffList) {
+      Iter.init(Reg, DiffList);
+      Val = *Iter;
+    }
+
+  public:
+    // Allow default construction to build variables, but this doesn't build
+    // a useful iterator.
+    mc_difflist_iterator() = default;
+
+    /// Return an iterator past the last element.
+    static SubT end() {
+      SubT End;
+      End.Iter.List = nullptr;
+      return End;
+    }
+
+    bool operator==(const mc_difflist_iterator &Arg) const {
+      return Iter.List == Arg.Iter.List;
+    }
+
+    const MCPhysReg &operator*() const { return Val; }
+
+    using mc_difflist_iterator::iterator_facade_base::operator++;
+    void operator++() {
+      assert(Iter.List && "Cannot increment the end iterator!");
+      ++Iter;
+      Val = *Iter;
+    }
+  };
+
+  /// Forward iterator over all sub-registers.
+  /// TODO: Replace remaining uses of MCSubRegIterator.
+  class mc_subreg_iterator : public mc_difflist_iterator<mc_subreg_iterator> {
+  public:
+    mc_subreg_iterator(MCRegisterInfo::DiffListIterator Iter)
+        : mc_difflist_iterator(Iter) {}
+    mc_subreg_iterator() = default;
+    mc_subreg_iterator(MCRegister Reg, const MCRegisterInfo *MCRI)
+        : mc_difflist_iterator(Reg, MCRI->DiffLists + MCRI->get(Reg).SubRegs) {}
+  };
+
+  /// Forward iterator over all super-registers.
+  /// TODO: Replace remaining uses of MCSuperRegIterator.
+  class mc_superreg_iterator
+      : public mc_difflist_iterator<mc_superreg_iterator> {
+  public:
+    mc_superreg_iterator(MCRegisterInfo::DiffListIterator Iter)
+        : mc_difflist_iterator(Iter) {}
+    mc_superreg_iterator() = default;
+    mc_superreg_iterator(MCRegister Reg, const MCRegisterInfo *MCRI)
+        : mc_difflist_iterator(Reg,
+                               MCRI->DiffLists + MCRI->get(Reg).SuperRegs) {}
+  };
+
+  /// Return an iterator range over all sub-registers of \p Reg, excluding \p
+  /// Reg.
+  iterator_range<mc_subreg_iterator> subregs(MCRegister Reg) const {
+    return make_range(std::next(mc_subreg_iterator(Reg, this)),
+                      mc_subreg_iterator::end());
+  }
+
+  /// Return an iterator range over all sub-registers of \p Reg, including \p
+  /// Reg.
+  iterator_range<mc_subreg_iterator> subregs_inclusive(MCRegister Reg) const {
+    return make_range({Reg, this}, mc_subreg_iterator::end());
+  }
+
+  /// Return an iterator range over all super-registers of \p Reg, excluding \p
+  /// Reg.
+  iterator_range<mc_superreg_iterator> superregs(MCRegister Reg) const {
+    return make_range(std::next(mc_superreg_iterator(Reg, this)),
+                      mc_superreg_iterator::end());
+  }
+
+  /// Return an iterator range over all super-registers of \p Reg, including \p
+  /// Reg.
+  iterator_range<mc_superreg_iterator>
+  superregs_inclusive(MCRegister Reg) const {
+    return make_range({Reg, this}, mc_superreg_iterator::end());
+  }
+
+  /// Return an iterator range over all sub- and super-registers of \p Reg,
+  /// including \p Reg.
+  detail::concat_range<const MCPhysReg, iterator_range<mc_subreg_iterator>,
+                       iterator_range<mc_superreg_iterator>>
+  sub_and_superregs_inclusive(MCRegister Reg) const {
+    return concat<const MCPhysReg>(subregs_inclusive(Reg), superregs(Reg));
+  }
+
   // These iterators are allowed to sub-class DiffListIterator and access
   // internal list pointers.
   friend class MCSubRegIterator;
@@ -309,26 +417,26 @@
   /// as the LLVM register number.
   /// FIXME: TableGen these numbers. Currently this requires target specific
   /// initialization code.
-  void mapLLVMRegToSEHReg(unsigned LLVMReg, int SEHReg) {
+  void mapLLVMRegToSEHReg(MCRegister LLVMReg, int SEHReg) {
     L2SEHRegs[LLVMReg] = SEHReg;
   }
 
-  void mapLLVMRegToCVReg(unsigned LLVMReg, int CVReg) {
+  void mapLLVMRegToCVReg(MCRegister LLVMReg, int CVReg) {
     L2CVRegs[LLVMReg] = CVReg;
   }
 
   /// This method should return the register where the return
   /// address can be found.
-  unsigned getRARegister() const {
+  MCRegister getRARegister() const {
     return RAReg;
   }
 
   /// Return the register which is the program counter.
-  unsigned getProgramCounter() const {
+  MCRegister getProgramCounter() const {
     return PCReg;
   }
 
-  const MCRegisterDesc &operator[](unsigned RegNo) const {
+  const MCRegisterDesc &operator[](MCRegister RegNo) const {
     assert(RegNo < NumRegs &&
            "Attempting to access record for invalid register number!");
     return Desc[RegNo];
@@ -336,24 +444,24 @@
 
   /// Provide a get method, equivalent to [], but more useful with a
   /// pointer to this object.
-  const MCRegisterDesc &get(unsigned RegNo) const {
+  const MCRegisterDesc &get(MCRegister RegNo) const {
     return operator[](RegNo);
   }
 
   /// Returns the physical register number of sub-register "Index"
   /// for physical register RegNo. Return zero if the sub-register does not
   /// exist.
-  unsigned getSubReg(unsigned Reg, unsigned Idx) const;
+  MCRegister getSubReg(MCRegister Reg, unsigned Idx) const;
 
   /// Return a super-register of the specified register
   /// Reg so its sub-register of index SubIdx is Reg.
-  unsigned getMatchingSuperReg(unsigned Reg, unsigned SubIdx,
-                               const MCRegisterClass *RC) const;
+  MCRegister getMatchingSuperReg(MCRegister Reg, unsigned SubIdx,
+                                 const MCRegisterClass *RC) const;
 
   /// For a given register pair, return the sub-register index
   /// if the second register is a sub-register of the first. Return zero
   /// otherwise.
-  unsigned getSubRegIndex(unsigned RegNo, unsigned SubRegNo) const;
+  unsigned getSubRegIndex(MCRegister RegNo, MCRegister SubRegNo) const;
 
   /// Get the size of the bit range covered by a sub-register index.
   /// If the index isn't continuous, return the sum of the sizes of its parts.
@@ -367,7 +475,7 @@
 
   /// Return the human-readable symbolic target-specific name for the
   /// specified physical register.
-  const char *getName(unsigned RegNo) const {
+  const char *getName(MCRegister RegNo) const {
     return RegStrings + get(RegNo).Name;
   }
 
@@ -395,15 +503,11 @@
   /// number.  Returns -1 if there is no equivalent value.  The second
   /// parameter allows targets to use different numberings for EH info and
   /// debugging info.
-  int getDwarfRegNum(unsigned RegNum, bool isEH) const;
+  int getDwarfRegNum(MCRegister RegNum, bool isEH) const;
 
-  /// Map a dwarf register back to a target register.
-  int getLLVMRegNum(unsigned RegNum, bool isEH) const;
-
-  /// Map a DWARF EH register back to a target register (same as
-  /// getLLVMRegNum(RegNum, true)) but return -1 if there is no mapping,
-  /// rather than asserting that there must be one.
-  int getLLVMRegNumFromEH(unsigned RegNum) const;
+  /// Map a dwarf register back to a target register. Returns None is there is
+  /// no mapping.
+  Optional<unsigned> getLLVMRegNum(unsigned RegNum, bool isEH) const;
 
   /// Map a target EH register number to an equivalent DWARF register
   /// number.
@@ -411,11 +515,11 @@
 
   /// Map a target register to an equivalent SEH register
   /// number.  Returns LLVM register number if there is no equivalent value.
-  int getSEHRegNum(unsigned RegNum) const;
+  int getSEHRegNum(MCRegister RegNum) const;
 
   /// Map a target register to an equivalent CodeView register
   /// number.
-  int getCodeViewRegNum(unsigned RegNum) const;
+  int getCodeViewRegNum(MCRegister RegNum) const;
 
   regclass_iterator regclass_begin() const { return Classes; }
   regclass_iterator regclass_end() const { return Classes+NumClasses; }
@@ -439,34 +543,34 @@
   }
 
    /// Returns the encoding for RegNo
-  uint16_t getEncodingValue(unsigned RegNo) const {
+  uint16_t getEncodingValue(MCRegister RegNo) const {
     assert(RegNo < NumRegs &&
            "Attempting to get encoding for invalid register number!");
     return RegEncodingTable[RegNo];
   }
 
   /// Returns true if RegB is a sub-register of RegA.
-  bool isSubRegister(unsigned RegA, unsigned RegB) const {
+  bool isSubRegister(MCRegister RegA, MCRegister RegB) const {
     return isSuperRegister(RegB, RegA);
   }
 
   /// Returns true if RegB is a super-register of RegA.
-  bool isSuperRegister(unsigned RegA, unsigned RegB) const;
+  bool isSuperRegister(MCRegister RegA, MCRegister RegB) const;
 
   /// Returns true if RegB is a sub-register of RegA or if RegB == RegA.
-  bool isSubRegisterEq(unsigned RegA, unsigned RegB) const {
+  bool isSubRegisterEq(MCRegister RegA, MCRegister RegB) const {
     return isSuperRegisterEq(RegB, RegA);
   }
 
   /// Returns true if RegB is a super-register of RegA or if
   /// RegB == RegA.
-  bool isSuperRegisterEq(unsigned RegA, unsigned RegB) const {
+  bool isSuperRegisterEq(MCRegister RegA, MCRegister RegB) const {
     return RegA == RegB || isSuperRegister(RegA, RegB);
   }
 
   /// Returns true if RegB is a super-register or sub-register of RegA
   /// or if RegB == RegA.
-  bool isSuperOrSubRegisterEq(unsigned RegA, unsigned RegB) const {
+  bool isSuperOrSubRegisterEq(MCRegister RegA, MCRegister RegB) const {
     return isSubRegisterEq(RegA, RegB) || isSuperRegister(RegA, RegB);
   }
 };
@@ -482,8 +586,8 @@
 /// If IncludeSelf is set, Reg itself is included in the list.
 class MCSubRegIterator : public MCRegisterInfo::DiffListIterator {
 public:
-  MCSubRegIterator(unsigned Reg, const MCRegisterInfo *MCRI,
-                     bool IncludeSelf = false) {
+  MCSubRegIterator(MCRegister Reg, const MCRegisterInfo *MCRI,
+                   bool IncludeSelf = false) {
     init(Reg, MCRI->DiffLists + MCRI->get(Reg).SubRegs);
     // Initially, the iterator points to Reg itself.
     if (!IncludeSelf)
@@ -500,13 +604,13 @@
 public:
   /// Constructs an iterator that traverses subregisters and their
   /// associated subregister indices.
-  MCSubRegIndexIterator(unsigned Reg, const MCRegisterInfo *MCRI)
+  MCSubRegIndexIterator(MCRegister Reg, const MCRegisterInfo *MCRI)
     : SRIter(Reg, MCRI) {
     SRIndex = MCRI->SubRegIndices + MCRI->get(Reg).SubRegIndices;
   }
 
   /// Returns current sub-register.
-  unsigned getSubReg() const {
+  MCRegister getSubReg() const {
     return *SRIter;
   }
 
@@ -531,7 +635,7 @@
 public:
   MCSuperRegIterator() = default;
 
-  MCSuperRegIterator(unsigned Reg, const MCRegisterInfo *MCRI,
+  MCSuperRegIterator(MCRegister Reg, const MCRegisterInfo *MCRI,
                      bool IncludeSelf = false) {
     init(Reg, MCRI->DiffLists + MCRI->get(Reg).SuperRegs);
     // Initially, the iterator points to Reg itself.
@@ -542,7 +646,7 @@
 
 // Definition for isSuperRegister. Put it down here since it needs the
 // iterator defined above in addition to the MCRegisterInfo class itself.
-inline bool MCRegisterInfo::isSuperRegister(unsigned RegA, unsigned RegB) const{
+inline bool MCRegisterInfo::isSuperRegister(MCRegister RegA, MCRegister RegB) const{
   for (MCSuperRegIterator I(RegA, this); I.isValid(); ++I)
     if (*I == RegB)
       return true;
@@ -569,8 +673,9 @@
   /// in Reg.
   MCRegUnitIterator() = default;
 
-  MCRegUnitIterator(unsigned Reg, const MCRegisterInfo *MCRI) {
+  MCRegUnitIterator(MCRegister Reg, const MCRegisterInfo *MCRI) {
     assert(Reg && "Null register has no regunits");
+    assert(MCRegister::isPhysicalRegister(Reg.id()));
     // Decode the RegUnits MCRegisterDesc field.
     unsigned RU = MCRI->get(Reg).RegUnits;
     unsigned Scale = RU & 15;
@@ -600,7 +705,7 @@
 
   /// Constructs an iterator that traverses the register units and their
   /// associated LaneMasks in Reg.
-  MCRegUnitMaskIterator(unsigned Reg, const MCRegisterInfo *MCRI)
+  MCRegUnitMaskIterator(MCRegister Reg, const MCRegisterInfo *MCRI)
     : RUIter(Reg, MCRI) {
       uint16_t Idx = MCRI->get(Reg).RegUnitLaneMasks;
       MaskListIter = &MCRI->RegUnitMaskSequences[Idx];
@@ -667,7 +772,7 @@
 /// any ordering or that entries are unique.
 class MCRegAliasIterator {
 private:
-  unsigned Reg;
+  MCRegister Reg;
   const MCRegisterInfo *MCRI;
   bool IncludeSelf;
 
@@ -676,7 +781,7 @@
   MCSuperRegIterator SI;
 
 public:
-  MCRegAliasIterator(unsigned Reg, const MCRegisterInfo *MCRI,
+  MCRegAliasIterator(MCRegister Reg, const MCRegisterInfo *MCRI,
                      bool IncludeSelf)
     : Reg(Reg), MCRI(MCRI), IncludeSelf(IncludeSelf) {
     // Initialize the iterators.
@@ -692,7 +797,7 @@
 
   bool isValid() const { return RI.isValid(); }
 
-  unsigned operator*() const {
+  MCRegister operator*() const {
     assert(SI.isValid() && "Cannot dereference an invalid iterator.");
     return *SI;
   }
diff --git a/linux-x64/clang/include/llvm/MC/MCSchedule.h b/linux-x64/clang/include/llvm/MC/MCSchedule.h
index df3248e..ee0e5b4 100644
--- a/linux-x64/clang/include/llvm/MC/MCSchedule.h
+++ b/linux-x64/clang/include/llvm/MC/MCSchedule.h
@@ -14,7 +14,6 @@
 #ifndef LLVM_MC_MCSCHEDULE_H
 #define LLVM_MC_MCSCHEDULE_H
 
-#include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/Config/llvm-config.h"
 #include "llvm/Support/DataTypes.h"
@@ -22,6 +21,7 @@
 
 namespace llvm {
 
+template <typename T> class ArrayRef;
 struct InstrItinerary;
 class MCSubtargetInfo;
 class MCInstrInfo;
@@ -205,7 +205,7 @@
 /// subtargets can't be done. Nonetheless, the abstract model is
 /// useful. Futhermore, subtargets typically extend this model with processor
 /// specific resources to model any hardware features that can be exploited by
-/// sceduling heuristics and aren't sufficiently represented in the abstract.
+/// scheduling heuristics and aren't sufficiently represented in the abstract.
 ///
 /// The abstract pipeline is built around the notion of an "issue point". This
 /// is merely a reference point for counting machine cycles. The physical
diff --git a/linux-x64/clang/include/llvm/MC/MCSection.h b/linux-x64/clang/include/llvm/MC/MCSection.h
index 6fad1ec..a68e06e 100644
--- a/linux-x64/clang/include/llvm/MC/MCSection.h
+++ b/linux-x64/clang/include/llvm/MC/MCSection.h
@@ -17,6 +17,7 @@
 #include "llvm/ADT/ilist.h"
 #include "llvm/MC/MCFragment.h"
 #include "llvm/MC/SectionKind.h"
+#include "llvm/Support/Alignment.h"
 #include <cassert>
 #include <utility>
 
@@ -37,6 +38,8 @@
 /// current translation unit.  The MCContext class uniques and creates these.
 class MCSection {
 public:
+  static constexpr unsigned NonUniqueID = ~0U;
+
   enum SectionVariant { SV_COFF = 0, SV_ELF, SV_MachO, SV_Wasm, SV_XCOFF };
 
   /// Express the state of bundle locked groups while emitting code.
@@ -58,7 +61,7 @@
   MCSymbol *Begin;
   MCSymbol *End = nullptr;
   /// The alignment requirement of this section.
-  unsigned Alignment = 1;
+  Align Alignment;
   /// The section index in the assemblers section list.
   unsigned Ordinal = 0;
   /// The index of this section in the layout order.
@@ -77,10 +80,6 @@
   /// Whether this section has had instructions emitted into it.
   bool HasInstructions : 1;
 
-  /// Whether this section has had data emitted into it.
-  /// Right now this is only used by the ARM backend.
-  bool HasData : 1;
-
   bool IsRegistered : 1;
 
   MCDummyFragment DummyFragment;
@@ -91,17 +90,29 @@
   /// below that number.
   SmallVector<std::pair<unsigned, MCFragment *>, 1> SubsectionFragmentMap;
 
+  /// State for tracking labels that don't yet have Fragments
+  struct PendingLabel {
+    MCSymbol* Sym;
+    unsigned Subsection;
+    PendingLabel(MCSymbol* Sym, unsigned Subsection = 0)
+      : Sym(Sym), Subsection(Subsection) {}
+  };
+  SmallVector<PendingLabel, 2> PendingLabels;
+
 protected:
+  // TODO Make Name private when possible.
+  StringRef Name;
   SectionVariant Variant;
   SectionKind Kind;
 
-  MCSection(SectionVariant V, SectionKind K, MCSymbol *Begin);
+  MCSection(SectionVariant V, StringRef Name, SectionKind K, MCSymbol *Begin);
   ~MCSection();
 
 public:
   MCSection(const MCSection &) = delete;
   MCSection &operator=(const MCSection &) = delete;
 
+  StringRef getName() const { return Name; }
   SectionKind getKind() const { return Kind; }
 
   SectionVariant getVariant() const { return Variant; }
@@ -117,8 +128,8 @@
   MCSymbol *getEndSymbol(MCContext &Ctx);
   bool hasEnded() const;
 
-  unsigned getAlignment() const { return Alignment; }
-  void setAlignment(unsigned Value) { Alignment = Value; }
+  unsigned getAlignment() const { return Alignment.value(); }
+  void setAlignment(Align Value) { Alignment = Value; }
 
   unsigned getOrdinal() const { return Ordinal; }
   void setOrdinal(unsigned Value) { Ordinal = Value; }
@@ -140,9 +151,6 @@
   bool hasInstructions() const { return HasInstructions; }
   void setHasInstructions(bool Value) { HasInstructions = Value; }
 
-  bool hasData() const { return HasData; }
-  void setHasData(bool Value) { HasData = Value; }
-
   bool isRegistered() const { return IsRegistered; }
   void setIsRegistered(bool Value) { IsRegistered = Value; }
 
@@ -165,12 +173,6 @@
   iterator end() { return Fragments.end(); }
   const_iterator end() const { return Fragments.end(); }
 
-  reverse_iterator rbegin() { return Fragments.rbegin(); }
-  const_reverse_iterator rbegin() const { return Fragments.rbegin(); }
-
-  reverse_iterator rend() { return Fragments.rend(); }
-  const_reverse_iterator rend() const  { return Fragments.rend(); }
-
   MCSection::iterator getSubsectionInsertionPoint(unsigned Subsection);
 
   void dump() const;
@@ -186,6 +188,20 @@
   /// Check whether this section is "virtual", that is has no actual object
   /// file contents.
   virtual bool isVirtualSection() const = 0;
+
+  virtual StringRef getVirtualSectionKind() const;
+
+  /// Add a pending label for the requested subsection. This label will be
+  /// associated with a fragment in flushPendingLabels()
+  void addPendingLabel(MCSymbol* label, unsigned Subsection = 0);
+
+  /// Associate all pending labels in a subsection with a fragment.
+  void flushPendingLabels(MCFragment *F, uint64_t FOffset = 0,
+			  unsigned Subsection = 0);
+
+  /// Associate all pending labels with empty data fragments. One fragment
+  /// will be created for each subsection as necessary.
+  void flushPendingLabels();
 };
 
 } // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/MC/MCSectionCOFF.h b/linux-x64/clang/include/llvm/MC/MCSectionCOFF.h
index 8be95e0..3ece6eb 100644
--- a/linux-x64/clang/include/llvm/MC/MCSectionCOFF.h
+++ b/linux-x64/clang/include/llvm/MC/MCSectionCOFF.h
@@ -24,9 +24,6 @@
 
 /// This represents a section on Windows
 class MCSectionCOFF final : public MCSection {
-  // The memory for this string is stored in the same MCContext as *this.
-  StringRef SectionName;
-
   // FIXME: The following fields should not be mutable, but are for now so the
   // asm parser can honor the .linkonce directive.
 
@@ -51,12 +48,12 @@
 
 private:
   friend class MCContext;
-  MCSectionCOFF(StringRef Section, unsigned Characteristics,
+  // The storage of Name is owned by MCContext's COFFUniquingMap.
+  MCSectionCOFF(StringRef Name, unsigned Characteristics,
                 MCSymbol *COMDATSymbol, int Selection, SectionKind K,
                 MCSymbol *Begin)
-      : MCSection(SV_COFF, K, Begin), SectionName(Section),
-        Characteristics(Characteristics), COMDATSymbol(COMDATSymbol),
-        Selection(Selection) {
+      : MCSection(SV_COFF, Name, K, Begin), Characteristics(Characteristics),
+        COMDATSymbol(COMDATSymbol), Selection(Selection) {
     assert((Characteristics & 0x00F00000) == 0 &&
            "alignment must not be set upon section creation");
   }
@@ -66,7 +63,6 @@
   /// section name
   bool ShouldOmitSectionDirective(StringRef Name, const MCAsmInfo &MAI) const;
 
-  StringRef getSectionName() const { return SectionName; }
   unsigned getCharacteristics() const { return Characteristics; }
   MCSymbol *getCOMDATSymbol() const { return COMDATSymbol; }
   int getSelection() const { return Selection; }
@@ -78,6 +74,7 @@
                             const MCExpr *Subsection) const override;
   bool UseCodeAlign() const override;
   bool isVirtualSection() const override;
+  StringRef getVirtualSectionKind() const override;
 
   unsigned getOrAssignWinCFISectionID(unsigned *NextID) const {
     if (WinCFISectionID == ~0U)
diff --git a/linux-x64/clang/include/llvm/MC/MCSectionELF.h b/linux-x64/clang/include/llvm/MC/MCSectionELF.h
index fe6b2d7..4136ea7 100644
--- a/linux-x64/clang/include/llvm/MC/MCSectionELF.h
+++ b/linux-x64/clang/include/llvm/MC/MCSectionELF.h
@@ -25,10 +25,6 @@
 /// This represents a section on linux, lots of unix variants and some bare
 /// metal systems.
 class MCSectionELF final : public MCSection {
-  /// This is the name of the section.  The referenced memory is owned by
-  /// TargetLoweringObjectFileELF's ELFUniqueMap.
-  StringRef SectionName;
-
   /// This is the sh_type field of a section, drawn from the enums below.
   unsigned Type;
 
@@ -44,30 +40,33 @@
 
   const MCSymbolELF *Group;
 
-  /// sh_info for SHF_LINK_ORDER (can be null).
-  const MCSymbol *AssociatedSymbol;
+  /// Used by SHF_LINK_ORDER. If non-null, the sh_link field will be set to the
+  /// section header index of the section where LinkedToSym is defined.
+  const MCSymbol *LinkedToSym;
 
 private:
   friend class MCContext;
 
-  MCSectionELF(StringRef Section, unsigned type, unsigned flags, SectionKind K,
+  // The storage of Name is owned by MCContext's ELFUniquingMap.
+  MCSectionELF(StringRef Name, unsigned type, unsigned flags, SectionKind K,
                unsigned entrySize, const MCSymbolELF *group, unsigned UniqueID,
-               MCSymbol *Begin, const MCSymbolELF *AssociatedSymbol)
-      : MCSection(SV_ELF, K, Begin), SectionName(Section), Type(type),
-        Flags(flags), UniqueID(UniqueID), EntrySize(entrySize), Group(group),
-        AssociatedSymbol(AssociatedSymbol) {
+               MCSymbol *Begin, const MCSymbolELF *LinkedToSym)
+      : MCSection(SV_ELF, Name, K, Begin), Type(type), Flags(flags),
+        UniqueID(UniqueID), EntrySize(entrySize), Group(group),
+        LinkedToSym(LinkedToSym) {
     if (Group)
       Group->setIsSignature();
   }
 
-  void setSectionName(StringRef Name) { SectionName = Name; }
+  // TODO Delete after we stop supporting generation of GNU-style .zdebug_*
+  // sections.
+  void setSectionName(StringRef Name) { this->Name = Name; }
 
 public:
   /// Decides whether a '.section' directive should be printed before the
   /// section name
   bool ShouldOmitSectionDirective(StringRef Name, const MCAsmInfo &MAI) const;
 
-  StringRef getSectionName() const { return SectionName; }
   unsigned getType() const { return Type; }
   unsigned getFlags() const { return Flags; }
   unsigned getEntrySize() const { return EntrySize; }
@@ -79,12 +78,15 @@
                             const MCExpr *Subsection) const override;
   bool UseCodeAlign() const override;
   bool isVirtualSection() const override;
+  StringRef getVirtualSectionKind() const override;
 
-  bool isUnique() const { return UniqueID != ~0U; }
+  bool isUnique() const { return UniqueID != NonUniqueID; }
   unsigned getUniqueID() const { return UniqueID; }
 
-  const MCSection *getAssociatedSection() const { return &AssociatedSymbol->getSection(); }
-  const MCSymbol *getAssociatedSymbol() const { return AssociatedSymbol; }
+  const MCSection *getLinkedToSection() const {
+    return &LinkedToSym->getSection();
+  }
+  const MCSymbol *getLinkedToSymbol() const { return LinkedToSym; }
 
   static bool classof(const MCSection *S) {
     return S->getVariant() == SV_ELF;
diff --git a/linux-x64/clang/include/llvm/MC/MCSectionMachO.h b/linux-x64/clang/include/llvm/MC/MCSectionMachO.h
index 2c73661..b675585 100644
--- a/linux-x64/clang/include/llvm/MC/MCSectionMachO.h
+++ b/linux-x64/clang/include/llvm/MC/MCSectionMachO.h
@@ -23,7 +23,6 @@
 /// system, these are also described in /usr/include/mach-o/loader.h.
 class MCSectionMachO final : public MCSection {
   char SegmentName[16];  // Not necessarily null terminated!
-  char SectionName[16];  // Not necessarily null terminated!
 
   /// This is the SECTION_TYPE and SECTION_ATTRIBUTES field of a section, drawn
   /// from the enums below.
@@ -44,12 +43,6 @@
       return StringRef(SegmentName, 16);
     return StringRef(SegmentName);
   }
-  StringRef getSectionName() const {
-    // SectionName is not necessarily null terminated!
-    if (SectionName[15])
-      return StringRef(SectionName, 16);
-    return StringRef(SectionName);
-  }
 
   unsigned getTypeAndAttributes() const { return TypeAndAttributes; }
   unsigned getStubSize() const { return Reserved2; }
diff --git a/linux-x64/clang/include/llvm/MC/MCSectionWasm.h b/linux-x64/clang/include/llvm/MC/MCSectionWasm.h
index 1adc812..6211afe 100644
--- a/linux-x64/clang/include/llvm/MC/MCSectionWasm.h
+++ b/linux-x64/clang/include/llvm/MC/MCSectionWasm.h
@@ -13,22 +13,17 @@
 #ifndef LLVM_MC_MCSECTIONWASM_H
 #define LLVM_MC_MCSECTIONWASM_H
 
-#include "llvm/ADT/Twine.h"
 #include "llvm/MC/MCSection.h"
-#include "llvm/MC/MCSymbolWasm.h"
-#include "llvm/Support/Debug.h"
-#include "llvm/Support/raw_ostream.h"
 
 namespace llvm {
 
 class MCSymbol;
+class MCSymbolWasm;
+class StringRef;
+class raw_ostream;
 
 /// This represents a section on wasm.
 class MCSectionWasm final : public MCSection {
-  /// This is the name of the section.  The referenced memory is owned by
-  /// TargetLoweringObjectFileWasm's WasmUniqueMap.
-  StringRef SectionName;
-
   unsigned UniqueID;
 
   const MCSymbolWasm *Group;
@@ -45,18 +40,17 @@
   // Whether this data segment is passive
   bool IsPassive = false;
 
+  // The storage of Name is owned by MCContext's WasmUniquingMap.
   friend class MCContext;
-  MCSectionWasm(StringRef Section, SectionKind K, const MCSymbolWasm *group,
+  MCSectionWasm(StringRef Name, SectionKind K, const MCSymbolWasm *group,
                 unsigned UniqueID, MCSymbol *Begin)
-      : MCSection(SV_Wasm, K, Begin), SectionName(Section), UniqueID(UniqueID),
-        Group(group) {}
+      : MCSection(SV_Wasm, Name, K, Begin), UniqueID(UniqueID), Group(group) {}
 
 public:
   /// Decides whether a '.section' directive should be printed before the
   /// section name
   bool shouldOmitSectionDirective(StringRef Name, const MCAsmInfo &MAI) const;
 
-  StringRef getSectionName() const { return SectionName; }
   const MCSymbolWasm *getGroup() const { return Group; }
 
   void PrintSwitchToSection(const MCAsmInfo &MAI, const Triple &T,
@@ -66,7 +60,8 @@
   bool isVirtualSection() const override;
 
   bool isWasmData() const {
-    return Kind.isGlobalWriteableData() || Kind.isReadOnly();
+    return Kind.isGlobalWriteableData() || Kind.isReadOnly() ||
+           Kind.isThreadLocal();
   }
 
   bool isUnique() const { return UniqueID != ~0U; }
diff --git a/linux-x64/clang/include/llvm/MC/MCSectionXCOFF.h b/linux-x64/clang/include/llvm/MC/MCSectionXCOFF.h
index 2a3f391..aa39dff 100644
--- a/linux-x64/clang/include/llvm/MC/MCSectionXCOFF.h
+++ b/linux-x64/clang/include/llvm/MC/MCSectionXCOFF.h
@@ -13,26 +13,50 @@
 #ifndef LLVM_MC_MCSECTIONXCOFF_H
 #define LLVM_MC_MCSECTIONXCOFF_H
 
-#include "llvm/ADT/Twine.h"
 #include "llvm/BinaryFormat/XCOFF.h"
 #include "llvm/MC/MCSection.h"
+#include "llvm/MC/MCSymbolXCOFF.h"
 
 namespace llvm {
 
-class MCSymbol;
-
 // This class represents an XCOFF `Control Section`, more commonly referred to
 // as a csect. A csect represents the smallest possible unit of data/code which
-// will be relocated as a single block.
+// will be relocated as a single block. A csect can either be:
+// 1) Initialized: The Type will be XTY_SD, and the symbols inside the csect
+//    will have a label definition representing their offset within the csect.
+// 2) Uninitialized: The Type will be XTY_CM, it will contain a single symbol,
+//    and may not contain label definitions.
+// 3) An external reference providing a symbol table entry for a symbol
+//    contained in another XCOFF object file. External reference csects are not
+//    implemented yet.
 class MCSectionXCOFF final : public MCSection {
   friend class MCContext;
 
-  StringRef Name;
   XCOFF::StorageMappingClass MappingClass;
+  XCOFF::SymbolType Type;
+  MCSymbolXCOFF *const QualName;
+  StringRef SymbolTableName;
+  bool MultiSymbolsAllowed;
+  static constexpr unsigned DefaultAlignVal = 4;
 
-  MCSectionXCOFF(StringRef Section, XCOFF::StorageMappingClass SMC,
-                 SectionKind K, MCSymbol *Begin)
-      : MCSection(SV_XCOFF, K, Begin), Name(Section), MappingClass(SMC) {}
+  MCSectionXCOFF(StringRef Name, XCOFF::StorageMappingClass SMC,
+                 XCOFF::SymbolType ST, SectionKind K, MCSymbolXCOFF *QualName,
+                 MCSymbol *Begin, StringRef SymbolTableName,
+                 bool MultiSymbolsAllowed)
+      : MCSection(SV_XCOFF, Name, K, Begin), MappingClass(SMC), Type(ST),
+        QualName(QualName), SymbolTableName(SymbolTableName),
+        MultiSymbolsAllowed(MultiSymbolsAllowed) {
+    assert((ST == XCOFF::XTY_SD || ST == XCOFF::XTY_CM || ST == XCOFF::XTY_ER) &&
+           "Invalid or unhandled type for csect.");
+    assert(QualName != nullptr && "QualName is needed.");
+    QualName->setRepresentedCsect(this);
+    QualName->setStorageClass(XCOFF::C_HIDEXT);
+    // A csect is 4 byte aligned by default, except for undefined symbol csects.
+    if (Type != XCOFF::XTY_ER)
+      setAlignment(Align(DefaultAlignVal));
+  }
+
+  void printCsectDirective(raw_ostream &OS) const;
 
 public:
   ~MCSectionXCOFF();
@@ -41,14 +65,20 @@
     return S->getVariant() == SV_XCOFF;
   }
 
-  StringRef getSectionName() const { return Name; }
   XCOFF::StorageMappingClass getMappingClass() const { return MappingClass; }
+  XCOFF::StorageClass getStorageClass() const {
+    return QualName->getStorageClass();
+  }
+  XCOFF::SymbolType getCSectType() const { return Type; }
+  MCSymbolXCOFF *getQualNameSymbol() const { return QualName; }
 
   void PrintSwitchToSection(const MCAsmInfo &MAI, const Triple &T,
                             raw_ostream &OS,
                             const MCExpr *Subsection) const override;
   bool UseCodeAlign() const override;
   bool isVirtualSection() const override;
+  StringRef getSymbolTableName() const { return SymbolTableName; }
+  bool isMultiSymbolsAllowed() const { return MultiSymbolsAllowed; }
 };
 
 } // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/MC/MCStreamer.h b/linux-x64/clang/include/llvm/MC/MCStreamer.h
index 67284fb..cdc728f 100644
--- a/linux-x64/clang/include/llvm/MC/MCStreamer.h
+++ b/linux-x64/clang/include/llvm/MC/MCStreamer.h
@@ -13,6 +13,7 @@
 #ifndef LLVM_MC_MCSTREAMER_H
 #define LLVM_MC_MCSTREAMER_H
 
+#include "llvm/ADT/APInt.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/Optional.h"
@@ -20,6 +21,7 @@
 #include "llvm/ADT/StringRef.h"
 #include "llvm/MC/MCDirectives.h"
 #include "llvm/MC/MCLinkerOptimizationHint.h"
+#include "llvm/MC/MCPseudoProbe.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/MC/MCWinEH.h"
 #include "llvm/Support/Error.h"
@@ -40,12 +42,12 @@
 class formatted_raw_ostream;
 class MCAsmBackend;
 class MCCodeEmitter;
-struct MCCodePaddingContext;
 class MCContext;
 struct MCDwarfFrameInfo;
 class MCExpr;
 class MCInst;
 class MCInstPrinter;
+class MCRegister;
 class MCSection;
 class MCStreamer;
 class MCSymbolRefExpr;
@@ -53,6 +55,13 @@
 class raw_ostream;
 class Twine;
 
+namespace codeview {
+struct DefRangeRegisterRelHeader;
+struct DefRangeSubfieldRegisterHeader;
+struct DefRangeRegisterHeader;
+struct DefRangeFramePointerRelHeader;
+}
+
 using MCSectionSubPair = std::pair<MCSection *, const MCExpr *>;
 
 /// Target specific streamer interface. This is used so that targets can
@@ -95,8 +104,9 @@
   // Allow a target to add behavior to the emitAssignment of MCStreamer.
   virtual void emitAssignment(MCSymbol *Symbol, const MCExpr *Value);
 
-  virtual void prettyPrintAsm(MCInstPrinter &InstPrinter, raw_ostream &OS,
-                              const MCInst &Inst, const MCSubtargetInfo &STI);
+  virtual void prettyPrintAsm(MCInstPrinter &InstPrinter, uint64_t Address,
+                              const MCInst &Inst, const MCSubtargetInfo &STI,
+                              raw_ostream &OS);
 
   virtual void emitDwarfFileDirective(StringRef Directive);
 
@@ -146,7 +156,7 @@
                                     StringRef StringValue = "");
   virtual void emitFPU(unsigned FPU);
   virtual void emitArch(ARM::ArchKind Arch);
-  virtual void emitArchExtension(unsigned ArchExt);
+  virtual void emitArchExtension(uint64_t ArchExt);
   virtual void emitObjectArch(ARM::ArchKind Arch);
   void emitTargetAttributes(const MCSubtargetInfo &STI);
   virtual void finishAttributeSection();
@@ -197,6 +207,7 @@
   std::vector<std::unique_ptr<WinEH::FrameInfo>> WinFrameInfos;
 
   WinEH::FrameInfo *CurrentWinFrameInfo;
+  size_t CurrentProcWinFrameInfoStartIndex;
 
   /// Tracks an index to represent the order a symbol was emitted in.
   /// Zero means we did not emit that symbol.
@@ -206,6 +217,10 @@
   /// PushSection.
   SmallVector<std::pair<MCSectionSubPair, MCSectionSubPair>, 4> SectionStack;
 
+  /// Pointer to the parser's SMLoc if available. This is used to provide
+  /// locations for diagnostics.
+  const SMLoc *StartTokLocPtr = nullptr;
+
   /// The next unique ID to use when creating a WinCFI-related section (.pdata
   /// or .xdata). This ID ensures that we have a one-to-one mapping from
   /// code section to unwind info section, which MSVC's incremental linker
@@ -214,19 +229,28 @@
 
   bool UseAssemblerInfoForParsing;
 
+  /// Is the assembler allowed to insert padding automatically?  For
+  /// correctness reasons, we sometimes need to ensure instructions aren't
+  /// seperated in unexpected ways.  At the moment, this feature is only
+  /// useable from an integrated assembler, but assembly syntax is under
+  /// discussion for future inclusion.
+  bool AllowAutoPadding = false;
+
 protected:
   MCStreamer(MCContext &Ctx);
 
-  virtual void EmitCFIStartProcImpl(MCDwarfFrameInfo &Frame);
-  virtual void EmitCFIEndProcImpl(MCDwarfFrameInfo &CurFrame);
+  virtual void emitCFIStartProcImpl(MCDwarfFrameInfo &Frame);
+  virtual void emitCFIEndProcImpl(MCDwarfFrameInfo &CurFrame);
 
   WinEH::FrameInfo *getCurrentWinFrameInfo() {
     return CurrentWinFrameInfo;
   }
 
+  virtual void EmitWindowsUnwindTables(WinEH::FrameInfo *Frame);
+
   virtual void EmitWindowsUnwindTables();
 
-  virtual void EmitRawTextImpl(StringRef String);
+  virtual void emitRawTextImpl(StringRef String);
 
   /// Returns true if the the .cv_loc directive is in the right section.
   bool checkCVLocSection(unsigned FuncId, unsigned FileNo, SMLoc Loc);
@@ -243,6 +267,11 @@
     TargetStreamer.reset(TS);
   }
 
+  void setStartTokLocPtr(const SMLoc *Loc) { StartTokLocPtr = Loc; }
+  SMLoc getStartTokLoc() const {
+    return StartTokLocPtr ? *StartTokLocPtr : SMLoc();
+  }
+
   /// State management
   ///
   virtual void reset();
@@ -258,9 +287,12 @@
     return TargetStreamer.get();
   }
 
+  void setAllowAutoPadding(bool v) { AllowAutoPadding = v; }
+  bool getAllowAutoPadding() const { return AllowAutoPadding; }
+
   /// When emitting an object file, create and emit a real label. When emitting
   /// textual assembly, this should do nothing to avoid polluting our output.
-  virtual MCSymbol *EmitCFILabel();
+  virtual MCSymbol *emitCFILabel();
 
   /// Retreive the current frame info if one is available and it is not yet
   /// closed. Otherwise, issue an error and return null.
@@ -359,7 +391,7 @@
   ///
   /// This is called by PopSection and SwitchSection, if the current
   /// section changes.
-  virtual void ChangeSection(MCSection *, const MCExpr *);
+  virtual void changeSection(MCSection *, const MCExpr *);
 
   /// Save the current and previous section on the section stack.
   void PushSection() {
@@ -368,7 +400,7 @@
   }
 
   /// Restore the current and previous section from the section stack.
-  /// Calls ChangeSection as needed.
+  /// Calls changeSection as needed.
   ///
   /// Returns false if the stack was empty.
   bool PopSection() {
@@ -380,8 +412,8 @@
     --I;
     MCSectionSubPair NewSection = I->first;
 
-    if (OldSection != NewSection)
-      ChangeSection(NewSection.first, NewSection.second);
+    if (NewSection.first && OldSection != NewSection)
+      changeSection(NewSection.first, NewSection.second);
     SectionStack.pop_back();
     return true;
   }
@@ -403,7 +435,7 @@
 
   /// Set the current section where code is being emitted to \p Section.
   /// This is required to update CurSection. This version does not call
-  /// ChangeSection.
+  /// changeSection.
   void SwitchSectionNoChange(MCSection *Section,
                              const MCExpr *Subsection = nullptr) {
     assert(Section && "Cannot switch to a null section!");
@@ -424,6 +456,10 @@
   /// so we can sort on them later.
   void AssignFragment(MCSymbol *Symbol, MCFragment *Fragment);
 
+  /// Returns the mnemonic for \p MI, if the streamer has access to a
+  /// instruction printer and returns an empty string otherwise.
+  virtual StringRef getMnemonic(MCInst &MI) { return ""; }
+
   /// Emit a label for \p Symbol into the current section.
   ///
   /// This corresponds to an assembler statement such as:
@@ -434,37 +470,37 @@
   /// used in an assignment.
   // FIXME: These emission are non-const because we mutate the symbol to
   // add the section we're emitting it to later.
-  virtual void EmitLabel(MCSymbol *Symbol, SMLoc Loc = SMLoc());
+  virtual void emitLabel(MCSymbol *Symbol, SMLoc Loc = SMLoc());
 
-  virtual void EmitEHSymAttributes(const MCSymbol *Symbol, MCSymbol *EHSymbol);
+  virtual void emitEHSymAttributes(const MCSymbol *Symbol, MCSymbol *EHSymbol);
 
   /// Note in the output the specified \p Flag.
-  virtual void EmitAssemblerFlag(MCAssemblerFlag Flag);
+  virtual void emitAssemblerFlag(MCAssemblerFlag Flag);
 
   /// Emit the given list \p Options of strings as linker
   /// options into the output.
-  virtual void EmitLinkerOptions(ArrayRef<std::string> Kind) {}
+  virtual void emitLinkerOptions(ArrayRef<std::string> Kind) {}
 
   /// Note in the output the specified region \p Kind.
-  virtual void EmitDataRegion(MCDataRegionType Kind) {}
+  virtual void emitDataRegion(MCDataRegionType Kind) {}
 
   /// Specify the Mach-O minimum deployment target version.
-  virtual void EmitVersionMin(MCVersionMinType Type, unsigned Major,
+  virtual void emitVersionMin(MCVersionMinType Type, unsigned Major,
                               unsigned Minor, unsigned Update,
                               VersionTuple SDKVersion) {}
 
   /// Emit/Specify Mach-O build version command.
   /// \p Platform should be one of MachO::PlatformType.
-  virtual void EmitBuildVersion(unsigned Platform, unsigned Major,
+  virtual void emitBuildVersion(unsigned Platform, unsigned Major,
                                 unsigned Minor, unsigned Update,
                                 VersionTuple SDKVersion) {}
 
-  void EmitVersionForTarget(const Triple &Target,
+  void emitVersionForTarget(const Triple &Target,
                             const VersionTuple &SDKVersion);
 
   /// Note in the output that the specified \p Func is a Thumb mode
   /// function (ARM target only).
-  virtual void EmitThumbFunc(MCSymbol *Func);
+  virtual void emitThumbFunc(MCSymbol *Func);
 
   /// Emit an assignment of \p Value to \p Symbol.
   ///
@@ -477,7 +513,7 @@
   ///
   /// \param Symbol - The symbol being assigned to.
   /// \param Value - The value for the symbol.
-  virtual void EmitAssignment(MCSymbol *Symbol, const MCExpr *Value);
+  virtual void emitAssignment(MCSymbol *Symbol, const MCExpr *Value);
 
   /// Emit an weak reference from \p Alias to \p Symbol.
   ///
@@ -486,17 +522,17 @@
   ///
   /// \param Alias - The alias that is being created.
   /// \param Symbol - The symbol being aliased.
-  virtual void EmitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol);
+  virtual void emitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol);
 
   /// Add the given \p Attribute to \p Symbol.
-  virtual bool EmitSymbolAttribute(MCSymbol *Symbol,
+  virtual bool emitSymbolAttribute(MCSymbol *Symbol,
                                    MCSymbolAttr Attribute) = 0;
 
   /// Set the \p DescValue for the \p Symbol.
   ///
   /// \param Symbol - The symbol to have its n_desc field set.
   /// \param DescValue - The value to set into the n_desc field.
-  virtual void EmitSymbolDesc(MCSymbol *Symbol, unsigned DescValue);
+  virtual void emitSymbolDesc(MCSymbol *Symbol, unsigned DescValue);
 
   /// Start emitting COFF symbol definition
   ///
@@ -536,6 +572,36 @@
   /// \param Symbol - Symbol the image relative relocation should point to.
   virtual void EmitCOFFImgRel32(MCSymbol const *Symbol, int64_t Offset);
 
+  /// Emits an lcomm directive with XCOFF csect information.
+  ///
+  /// \param LabelSym - Label on the block of storage.
+  /// \param Size - The size of the block of storage.
+  /// \param CsectSym - Csect name for the block of storage.
+  /// \param ByteAlignment - The alignment of the symbol in bytes. Must be a
+  /// power of 2.
+  virtual void emitXCOFFLocalCommonSymbol(MCSymbol *LabelSym, uint64_t Size,
+                                          MCSymbol *CsectSym,
+                                          unsigned ByteAlignment);
+
+  /// Emit a symbol's linkage and visibilty with a linkage directive for XCOFF.
+  ///
+  /// \param Symbol - The symbol to emit.
+  /// \param Linkage - The linkage of the symbol to emit.
+  /// \param Visibility - The visibility of the symbol to emit or MCSA_Invalid
+  /// if the symbol does not have an explicit visibility.
+  virtual void emitXCOFFSymbolLinkageWithVisibility(MCSymbol *Symbol,
+                                                    MCSymbolAttr Linkage,
+                                                    MCSymbolAttr Visibility);
+
+  /// Emit a XCOFF .rename directive which creates a synonym for an illegal or
+  /// undesirable name.
+  ///
+  /// \param Name - The name used internally in the assembly for references to
+  /// the symbol.
+  /// \param Rename - The value to which the Name parameter is
+  /// changed at the end of assembly.
+  virtual void emitXCOFFRenameDirective(const MCSymbol *Name, StringRef Rename);
+
   /// Emit an ELF .size directive.
   ///
   /// This corresponds to an assembler statement such as:
@@ -553,7 +619,7 @@
 
   /// Emit a Linker Optimization Hint (LOH) directive.
   /// \param Args - Arguments of the LOH.
-  virtual void EmitLOHDirective(MCLOHType Kind, const MCLOHArgs &Args) {}
+  virtual void emitLOHDirective(MCLOHType Kind, const MCLOHArgs &Args) {}
 
   /// Emit a common symbol.
   ///
@@ -561,7 +627,7 @@
   /// \param Size - The size of the common symbol.
   /// \param ByteAlignment - The alignment of the symbol if
   /// non-zero. This must be a power of 2.
-  virtual void EmitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
+  virtual void emitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
                                 unsigned ByteAlignment) = 0;
 
   /// Emit a local common (.lcomm) symbol.
@@ -569,7 +635,7 @@
   /// \param Symbol - The common symbol to emit.
   /// \param Size - The size of the common symbol.
   /// \param ByteAlignment - The alignment of the common symbol in bytes.
-  virtual void EmitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size,
+  virtual void emitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size,
                                      unsigned ByteAlignment);
 
   /// Emit the zerofill section and an optional symbol.
@@ -579,7 +645,7 @@
   /// \param Size - The size of the zerofill symbol.
   /// \param ByteAlignment - The alignment of the zerofill symbol if
   /// non-zero. This must be a power of 2 on some targets.
-  virtual void EmitZerofill(MCSection *Section, MCSymbol *Symbol = nullptr,
+  virtual void emitZerofill(MCSection *Section, MCSymbol *Symbol = nullptr,
                             uint64_t Size = 0, unsigned ByteAlignment = 0,
                             SMLoc Loc = SMLoc()) = 0;
 
@@ -590,7 +656,7 @@
   /// \param Size - The size of the symbol.
   /// \param ByteAlignment - The alignment of the thread local common symbol
   /// if non-zero.  This must be a power of 2 on some targets.
-  virtual void EmitTBSSSymbol(MCSection *Section, MCSymbol *Symbol,
+  virtual void emitTBSSSymbol(MCSection *Section, MCSymbol *Symbol,
                               uint64_t Size, unsigned ByteAlignment = 0);
 
   /// @}
@@ -601,11 +667,11 @@
   ///
   /// This is used to implement assembler directives such as .byte, .ascii,
   /// etc.
-  virtual void EmitBytes(StringRef Data);
+  virtual void emitBytes(StringRef Data);
 
   /// Functionally identical to EmitBytes. When emitting textual assembly, this
   /// method uses .byte directives instead of .ascii or .asciz for readability.
-  virtual void EmitBinaryData(StringRef Data);
+  virtual void emitBinaryData(StringRef Data);
 
   /// Emit the expression \p Value into the output as a native
   /// integer of the given \p Size bytes.
@@ -617,30 +683,50 @@
   /// \param Size - The size of the integer (in bytes) to emit. This must
   /// match a native machine width.
   /// \param Loc - The location of the expression for error reporting.
-  virtual void EmitValueImpl(const MCExpr *Value, unsigned Size,
+  virtual void emitValueImpl(const MCExpr *Value, unsigned Size,
                              SMLoc Loc = SMLoc());
 
-  void EmitValue(const MCExpr *Value, unsigned Size, SMLoc Loc = SMLoc());
+  void emitValue(const MCExpr *Value, unsigned Size, SMLoc Loc = SMLoc());
 
   /// Special case of EmitValue that avoids the client having
   /// to pass in a MCExpr for constant integers.
-  virtual void EmitIntValue(uint64_t Value, unsigned Size);
+  virtual void emitIntValue(uint64_t Value, unsigned Size);
+  virtual void emitIntValue(APInt Value);
 
-  virtual void EmitULEB128Value(const MCExpr *Value);
+  /// Special case of EmitValue that avoids the client having to pass
+  /// in a MCExpr for constant integers & prints in Hex format for certain
+  /// modes.
+  virtual void emitIntValueInHex(uint64_t Value, unsigned Size) {
+    emitIntValue(Value, Size);
+  }
 
-  virtual void EmitSLEB128Value(const MCExpr *Value);
+  void emitInt8(uint64_t Value) { emitIntValue(Value, 1); }
+  void emitInt16(uint64_t Value) { emitIntValue(Value, 2); }
+  void emitInt32(uint64_t Value) { emitIntValue(Value, 4); }
+  void emitInt64(uint64_t Value) { emitIntValue(Value, 8); }
+
+  /// Special case of EmitValue that avoids the client having to pass
+  /// in a MCExpr for constant integers & prints in Hex format for certain
+  /// modes, pads the field with leading zeros to Size width
+  virtual void emitIntValueInHexWithPadding(uint64_t Value, unsigned Size) {
+    emitIntValue(Value, Size);
+  }
+
+  virtual void emitULEB128Value(const MCExpr *Value);
+
+  virtual void emitSLEB128Value(const MCExpr *Value);
 
   /// Special case of EmitULEB128Value that avoids the client having to
   /// pass in a MCExpr for constant integers.
-  void EmitULEB128IntValue(uint64_t Value, unsigned PadTo = 0);
+  void emitULEB128IntValue(uint64_t Value, unsigned PadTo = 0);
 
   /// Special case of EmitSLEB128Value that avoids the client having to
   /// pass in a MCExpr for constant integers.
-  void EmitSLEB128IntValue(int64_t Value);
+  void emitSLEB128IntValue(int64_t Value);
 
   /// Special case of EmitValue that avoids the client having to pass in
   /// a MCExpr for MCSymbols.
-  void EmitSymbolValue(const MCSymbol *Sym, unsigned Size,
+  void emitSymbolValue(const MCSymbol *Sym, unsigned Size,
                        bool IsSectionRelative = false);
 
   /// Emit the expression \p Value into the output as a dtprel
@@ -648,42 +734,42 @@
   ///
   /// This is used to implement assembler directives such as .dtpreldword on
   /// targets that support them.
-  virtual void EmitDTPRel64Value(const MCExpr *Value);
+  virtual void emitDTPRel64Value(const MCExpr *Value);
 
   /// Emit the expression \p Value into the output as a dtprel
   /// (32-bit DTP relative) value.
   ///
   /// This is used to implement assembler directives such as .dtprelword on
   /// targets that support them.
-  virtual void EmitDTPRel32Value(const MCExpr *Value);
+  virtual void emitDTPRel32Value(const MCExpr *Value);
 
   /// Emit the expression \p Value into the output as a tprel
   /// (64-bit TP relative) value.
   ///
   /// This is used to implement assembler directives such as .tpreldword on
   /// targets that support them.
-  virtual void EmitTPRel64Value(const MCExpr *Value);
+  virtual void emitTPRel64Value(const MCExpr *Value);
 
   /// Emit the expression \p Value into the output as a tprel
   /// (32-bit TP relative) value.
   ///
   /// This is used to implement assembler directives such as .tprelword on
   /// targets that support them.
-  virtual void EmitTPRel32Value(const MCExpr *Value);
+  virtual void emitTPRel32Value(const MCExpr *Value);
 
   /// Emit the expression \p Value into the output as a gprel64 (64-bit
   /// GP relative) value.
   ///
   /// This is used to implement assembler directives such as .gpdword on
   /// targets that support them.
-  virtual void EmitGPRel64Value(const MCExpr *Value);
+  virtual void emitGPRel64Value(const MCExpr *Value);
 
   /// Emit the expression \p Value into the output as a gprel32 (32-bit
   /// GP relative) value.
   ///
   /// This is used to implement assembler directives such as .gprel32 on
   /// targets that support them.
-  virtual void EmitGPRel32Value(const MCExpr *Value);
+  virtual void emitGPRel32Value(const MCExpr *Value);
 
   /// Emit NumBytes bytes worth of the value specified by FillValue.
   /// This implements directives such as '.space'.
@@ -710,9 +796,12 @@
   virtual void emitFill(const MCExpr &NumValues, int64_t Size, int64_t Expr,
                         SMLoc Loc = SMLoc());
 
+  virtual void emitNops(int64_t NumBytes, int64_t ControlledNopLength,
+                        SMLoc Loc);
+
   /// Emit NumBytes worth of zeros.
   /// This function properly handles data in virtual sections.
-  void EmitZeros(uint64_t NumBytes);
+  void emitZeros(uint64_t NumBytes);
 
   /// Emit some number of copies of \p Value until the byte alignment \p
   /// ByteAlignment is reached.
@@ -731,7 +820,7 @@
   /// \param MaxBytesToEmit - The maximum numbers of bytes to emit, or 0. If
   /// the alignment cannot be reached in this many bytes, no bytes are
   /// emitted.
-  virtual void EmitValueToAlignment(unsigned ByteAlignment, int64_t Value = 0,
+  virtual void emitValueToAlignment(unsigned ByteAlignment, int64_t Value = 0,
                                     unsigned ValueSize = 1,
                                     unsigned MaxBytesToEmit = 0);
 
@@ -745,7 +834,7 @@
   /// \param MaxBytesToEmit - The maximum numbers of bytes to emit, or 0. If
   /// the alignment cannot be reached in this many bytes, no bytes are
   /// emitted.
-  virtual void EmitCodeAlignment(unsigned ByteAlignment,
+  virtual void emitCodeAlignment(unsigned ByteAlignment,
                                  unsigned MaxBytesToEmit = 0);
 
   /// Emit some number of copies of \p Value until the byte offset \p
@@ -759,25 +848,19 @@
   virtual void emitValueToOffset(const MCExpr *Offset, unsigned char Value,
                                  SMLoc Loc);
 
-  virtual void
-  EmitCodePaddingBasicBlockStart(const MCCodePaddingContext &Context) {}
-
-  virtual void
-  EmitCodePaddingBasicBlockEnd(const MCCodePaddingContext &Context) {}
-
   /// @}
 
   /// Switch to a new logical file.  This is used to implement the '.file
   /// "foo.c"' assembler directive.
-  virtual void EmitFileDirective(StringRef Filename);
+  virtual void emitFileDirective(StringRef Filename);
 
   /// Emit the "identifiers" directive.  This implements the
   /// '.ident "version foo"' assembler directive.
-  virtual void EmitIdent(StringRef IdentString) {}
+  virtual void emitIdent(StringRef IdentString) {}
 
   /// Associate a filename with a specified logical file number.  This
   /// implements the DWARF2 '.file 4 "foo.c"' assembler directive.
-  unsigned EmitDwarfFileDirective(unsigned FileNo, StringRef Directory,
+  unsigned emitDwarfFileDirective(unsigned FileNo, StringRef Directory,
                                   StringRef Filename,
                                   Optional<MD5::MD5Result> Checksum = None,
                                   Optional<StringRef> Source = None,
@@ -803,11 +886,11 @@
                                        Optional<StringRef> Source,
                                        unsigned CUID = 0);
 
-  virtual void EmitCFIBKeyFrame();
+  virtual void emitCFIBKeyFrame();
 
   /// This implements the DWARF2 '.loc fileno lineno ...' assembler
   /// directive.
-  virtual void EmitDwarfLocDirective(unsigned FileNo, unsigned Line,
+  virtual void emitDwarfLocDirective(unsigned FileNo, unsigned Line,
                                      unsigned Column, unsigned Flags,
                                      unsigned Isa, unsigned Discriminator,
                                      StringRef FileName);
@@ -829,19 +912,19 @@
                                            unsigned IACol, SMLoc Loc);
 
   /// This implements the CodeView '.cv_loc' assembler directive.
-  virtual void EmitCVLocDirective(unsigned FunctionId, unsigned FileNo,
+  virtual void emitCVLocDirective(unsigned FunctionId, unsigned FileNo,
                                   unsigned Line, unsigned Column,
                                   bool PrologueEnd, bool IsStmt,
                                   StringRef FileName, SMLoc Loc);
 
   /// This implements the CodeView '.cv_linetable' assembler directive.
-  virtual void EmitCVLinetableDirective(unsigned FunctionId,
+  virtual void emitCVLinetableDirective(unsigned FunctionId,
                                         const MCSymbol *FnStart,
                                         const MCSymbol *FnEnd);
 
   /// This implements the CodeView '.cv_inline_linetable' assembler
   /// directive.
-  virtual void EmitCVInlineLinetableDirective(unsigned PrimaryFunctionId,
+  virtual void emitCVInlineLinetableDirective(unsigned PrimaryFunctionId,
                                               unsigned SourceFileId,
                                               unsigned SourceLineNum,
                                               const MCSymbol *FnStartSym,
@@ -849,19 +932,35 @@
 
   /// This implements the CodeView '.cv_def_range' assembler
   /// directive.
-  virtual void EmitCVDefRangeDirective(
+  virtual void emitCVDefRangeDirective(
       ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges,
       StringRef FixedSizePortion);
 
+  virtual void emitCVDefRangeDirective(
+      ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges,
+      codeview::DefRangeRegisterRelHeader DRHdr);
+
+  virtual void emitCVDefRangeDirective(
+      ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges,
+      codeview::DefRangeSubfieldRegisterHeader DRHdr);
+
+  virtual void emitCVDefRangeDirective(
+      ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges,
+      codeview::DefRangeRegisterHeader DRHdr);
+
+  virtual void emitCVDefRangeDirective(
+      ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges,
+      codeview::DefRangeFramePointerRelHeader DRHdr);
+
   /// This implements the CodeView '.cv_stringtable' assembler directive.
-  virtual void EmitCVStringTableDirective() {}
+  virtual void emitCVStringTableDirective() {}
 
   /// This implements the CodeView '.cv_filechecksums' assembler directive.
-  virtual void EmitCVFileChecksumsDirective() {}
+  virtual void emitCVFileChecksumsDirective() {}
 
   /// This implements the CodeView '.cv_filechecksumoffset' assembler
   /// directive.
-  virtual void EmitCVFileChecksumOffsetDirective(unsigned FileNo) {}
+  virtual void emitCVFileChecksumOffsetDirective(unsigned FileNo) {}
 
   /// This implements the CodeView '.cv_fpo_data' assembler directive.
   virtual void EmitCVFPOData(const MCSymbol *ProcSym, SMLoc Loc = {}) {}
@@ -877,29 +976,29 @@
                                                const MCSymbol *Lo);
 
   virtual MCSymbol *getDwarfLineTableSymbol(unsigned CUID);
-  virtual void EmitCFISections(bool EH, bool Debug);
-  void EmitCFIStartProc(bool IsSimple, SMLoc Loc = SMLoc());
-  void EmitCFIEndProc();
-  virtual void EmitCFIDefCfa(int64_t Register, int64_t Offset);
-  virtual void EmitCFIDefCfaOffset(int64_t Offset);
-  virtual void EmitCFIDefCfaRegister(int64_t Register);
-  virtual void EmitCFIOffset(int64_t Register, int64_t Offset);
-  virtual void EmitCFIPersonality(const MCSymbol *Sym, unsigned Encoding);
-  virtual void EmitCFILsda(const MCSymbol *Sym, unsigned Encoding);
-  virtual void EmitCFIRememberState();
-  virtual void EmitCFIRestoreState();
-  virtual void EmitCFISameValue(int64_t Register);
-  virtual void EmitCFIRestore(int64_t Register);
-  virtual void EmitCFIRelOffset(int64_t Register, int64_t Offset);
-  virtual void EmitCFIAdjustCfaOffset(int64_t Adjustment);
-  virtual void EmitCFIEscape(StringRef Values);
-  virtual void EmitCFIReturnColumn(int64_t Register);
-  virtual void EmitCFIGnuArgsSize(int64_t Size);
-  virtual void EmitCFISignalFrame();
-  virtual void EmitCFIUndefined(int64_t Register);
-  virtual void EmitCFIRegister(int64_t Register1, int64_t Register2);
-  virtual void EmitCFIWindowSave();
-  virtual void EmitCFINegateRAState();
+  virtual void emitCFISections(bool EH, bool Debug);
+  void emitCFIStartProc(bool IsSimple, SMLoc Loc = SMLoc());
+  void emitCFIEndProc();
+  virtual void emitCFIDefCfa(int64_t Register, int64_t Offset);
+  virtual void emitCFIDefCfaOffset(int64_t Offset);
+  virtual void emitCFIDefCfaRegister(int64_t Register);
+  virtual void emitCFIOffset(int64_t Register, int64_t Offset);
+  virtual void emitCFIPersonality(const MCSymbol *Sym, unsigned Encoding);
+  virtual void emitCFILsda(const MCSymbol *Sym, unsigned Encoding);
+  virtual void emitCFIRememberState();
+  virtual void emitCFIRestoreState();
+  virtual void emitCFISameValue(int64_t Register);
+  virtual void emitCFIRestore(int64_t Register);
+  virtual void emitCFIRelOffset(int64_t Register, int64_t Offset);
+  virtual void emitCFIAdjustCfaOffset(int64_t Adjustment);
+  virtual void emitCFIEscape(StringRef Values);
+  virtual void emitCFIReturnColumn(int64_t Register);
+  virtual void emitCFIGnuArgsSize(int64_t Size);
+  virtual void emitCFISignalFrame();
+  virtual void emitCFIUndefined(int64_t Register);
+  virtual void emitCFIRegister(int64_t Register1, int64_t Register2);
+  virtual void emitCFIWindowSave();
+  virtual void emitCFINegateRAState();
 
   virtual void EmitWinCFIStartProc(const MCSymbol *Symbol, SMLoc Loc = SMLoc());
   virtual void EmitWinCFIEndProc(SMLoc Loc = SMLoc());
@@ -910,13 +1009,13 @@
   virtual void EmitWinCFIFuncletOrFuncEnd(SMLoc Loc = SMLoc());
   virtual void EmitWinCFIStartChained(SMLoc Loc = SMLoc());
   virtual void EmitWinCFIEndChained(SMLoc Loc = SMLoc());
-  virtual void EmitWinCFIPushReg(unsigned Register, SMLoc Loc = SMLoc());
-  virtual void EmitWinCFISetFrame(unsigned Register, unsigned Offset,
+  virtual void EmitWinCFIPushReg(MCRegister Register, SMLoc Loc = SMLoc());
+  virtual void EmitWinCFISetFrame(MCRegister Register, unsigned Offset,
                                   SMLoc Loc = SMLoc());
   virtual void EmitWinCFIAllocStack(unsigned Size, SMLoc Loc = SMLoc());
-  virtual void EmitWinCFISaveReg(unsigned Register, unsigned Offset,
+  virtual void EmitWinCFISaveReg(MCRegister Register, unsigned Offset,
                                  SMLoc Loc = SMLoc());
-  virtual void EmitWinCFISaveXMM(unsigned Register, unsigned Offset,
+  virtual void EmitWinCFISaveXMM(MCRegister Register, unsigned Offset,
                                  SMLoc Loc = SMLoc());
   virtual void EmitWinCFIPushFrame(bool Code, SMLoc Loc = SMLoc());
   virtual void EmitWinCFIEndProlog(SMLoc Loc = SMLoc());
@@ -935,46 +1034,50 @@
   /// Get the .xdata section used for the given section.
   MCSection *getAssociatedXDataSection(const MCSection *TextSec);
 
-  virtual void EmitSyntaxDirective();
+  virtual void emitSyntaxDirective();
 
-  /// Emit a .reloc directive.
-  /// Returns true if the relocation could not be emitted because Name is not
-  /// known.
-  virtual bool EmitRelocDirective(const MCExpr &Offset, StringRef Name,
-                                  const MCExpr *Expr, SMLoc Loc,
-                                  const MCSubtargetInfo &STI) {
-    return true;
+  /// Record a relocation described by the .reloc directive. Return None if
+  /// succeeded. Otherwise, return a pair (Name is invalid, error message).
+  virtual Optional<std::pair<bool, std::string>>
+  emitRelocDirective(const MCExpr &Offset, StringRef Name, const MCExpr *Expr,
+                     SMLoc Loc, const MCSubtargetInfo &STI) {
+    return None;
   }
 
-  virtual void EmitAddrsig() {}
-  virtual void EmitAddrsigSym(const MCSymbol *Sym) {}
+  virtual void emitAddrsig() {}
+  virtual void emitAddrsigSym(const MCSymbol *Sym) {}
 
   /// Emit the given \p Instruction into the current section.
-  virtual void EmitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI);
+  virtual void emitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI);
+
+  /// Emit the a pseudo probe into the current section.
+  virtual void emitPseudoProbe(uint64_t Guid, uint64_t Index, uint64_t Type,
+                               uint64_t Attr,
+                               const MCPseudoProbeInlineStack &InlineStack);
 
   /// Set the bundle alignment mode from now on in the section.
   /// The argument is the power of 2 to which the alignment is set. The
   /// value 0 means turn the bundle alignment off.
-  virtual void EmitBundleAlignMode(unsigned AlignPow2);
+  virtual void emitBundleAlignMode(unsigned AlignPow2);
 
   /// The following instructions are a bundle-locked group.
   ///
   /// \param AlignToEnd - If true, the bundle-locked group will be aligned to
   ///                     the end of a bundle.
-  virtual void EmitBundleLock(bool AlignToEnd);
+  virtual void emitBundleLock(bool AlignToEnd);
 
   /// Ends a bundle-locked group.
-  virtual void EmitBundleUnlock();
+  virtual void emitBundleUnlock();
 
   /// If this file is backed by a assembly streamer, this dumps the
   /// specified string in the output .s file.  This capability is indicated by
   /// the hasRawTextSupport() predicate.  By default this aborts.
-  void EmitRawText(const Twine &String);
+  void emitRawText(const Twine &String);
 
   /// Streamer specific finalization.
-  virtual void FinishImpl();
+  virtual void finishImpl();
   /// Finish emission of machine code.
-  void Finish();
+  void Finish(SMLoc EndLoc = SMLoc());
 
   virtual bool mayHaveInstructions(MCSection &Sec) const { return true; }
 };
@@ -983,28 +1086,6 @@
 /// timing the assembler front end.
 MCStreamer *createNullStreamer(MCContext &Ctx);
 
-/// Create a machine code streamer which will print out assembly for the native
-/// target, suitable for compiling with a native assembler.
-///
-/// \param InstPrint - If given, the instruction printer to use. If not given
-/// the MCInst representation will be printed.  This method takes ownership of
-/// InstPrint.
-///
-/// \param CE - If given, a code emitter to use to show the instruction
-/// encoding inline with the assembly. This method takes ownership of \p CE.
-///
-/// \param TAB - If given, a target asm backend to use to show the fixup
-/// information in conjunction with encoding information. This method takes
-/// ownership of \p TAB.
-///
-/// \param ShowInst - Whether to show the MCInst representation inline with
-/// the assembly.
-MCStreamer *createAsmStreamer(MCContext &Ctx,
-                              std::unique_ptr<formatted_raw_ostream> OS,
-                              bool isVerboseAsm, bool useDwarfDirectory,
-                              MCInstPrinter *InstPrint, MCCodeEmitter *CE,
-                              MCAsmBackend *TAB, bool ShowInst);
-
 } // end namespace llvm
 
 #endif // LLVM_MC_MCSTREAMER_H
diff --git a/linux-x64/clang/include/llvm/MC/MCSubtargetInfo.h b/linux-x64/clang/include/llvm/MC/MCSubtargetInfo.h
index 9490a6e..2c1072d 100644
--- a/linux-x64/clang/include/llvm/MC/MCSubtargetInfo.h
+++ b/linux-x64/clang/include/llvm/MC/MCSubtargetInfo.h
@@ -54,6 +54,7 @@
 struct SubtargetSubTypeKV {
   const char *Key;                      ///< K-V key string
   FeatureBitArray Implies;              ///< K-V bit mask
+  FeatureBitArray TuneImplies;          ///< K-V bit mask
   const MCSchedModel *SchedModel;
 
   /// Compare routine for std::lower_bound
@@ -74,6 +75,7 @@
 class MCSubtargetInfo {
   Triple TargetTriple;
   std::string CPU; // CPU being targeted.
+  std::string TuneCPU; // CPU being tuned for.
   ArrayRef<SubtargetFeatureKV> ProcFeatures;  // Processor feature list
   ArrayRef<SubtargetSubTypeKV> ProcDesc;  // Processor descriptions
 
@@ -90,8 +92,8 @@
 
 public:
   MCSubtargetInfo(const MCSubtargetInfo &) = default;
-  MCSubtargetInfo(const Triple &TT, StringRef CPU, StringRef FS,
-                  ArrayRef<SubtargetFeatureKV> PF,
+  MCSubtargetInfo(const Triple &TT, StringRef CPU, StringRef TuneCPU,
+                  StringRef FS, ArrayRef<SubtargetFeatureKV> PF,
                   ArrayRef<SubtargetSubTypeKV> PD,
                   const MCWriteProcResEntry *WPR, const MCWriteLatencyEntry *WL,
                   const MCReadAdvanceEntry *RA, const InstrStage *IS,
@@ -103,6 +105,7 @@
 
   const Triple &getTargetTriple() const { return TargetTriple; }
   StringRef getCPU() const { return CPU; }
+  StringRef getTuneCPU() const { return TuneCPU; }
 
   const FeatureBitset& getFeatureBits() const { return FeatureBits; }
   void setFeatureBits(const FeatureBitset &FeatureBits_) {
@@ -118,12 +121,12 @@
   ///
   /// FIXME: Find a way to stick this in the constructor, since it should only
   /// be called during initialization.
-  void InitMCProcessorInfo(StringRef CPU, StringRef FS);
+  void InitMCProcessorInfo(StringRef CPU, StringRef TuneCPU, StringRef FS);
 
 public:
-  /// Set the features to the default for the given CPU with an appended feature
-  /// string.
-  void setDefaultFeatures(StringRef CPU, StringRef FS);
+  /// Set the features to the default for the given CPU and TuneCPU, with ano
+  /// appended feature string.
+  void setDefaultFeatures(StringRef CPU, StringRef TuneCPU, StringRef FS);
 
   /// Toggle a feature and return the re-computed feature bits.
   /// This version does not change the implied bits.
@@ -210,17 +213,71 @@
   void initInstrItins(InstrItineraryData &InstrItins) const;
 
   /// Resolve a variant scheduling class for the given MCInst and CPU.
-  virtual unsigned
-  resolveVariantSchedClass(unsigned SchedClass, const MCInst *MI,
-                           unsigned CPUID) const {
+  virtual unsigned resolveVariantSchedClass(unsigned SchedClass,
+                                            const MCInst *MI,
+                                            const MCInstrInfo *MCII,
+                                            unsigned CPUID) const {
     return 0;
   }
 
   /// Check whether the CPU string is valid.
   bool isCPUStringValid(StringRef CPU) const {
-    auto Found = std::lower_bound(ProcDesc.begin(), ProcDesc.end(), CPU);
+    auto Found = llvm::lower_bound(ProcDesc, CPU);
     return Found != ProcDesc.end() && StringRef(Found->Key) == CPU;
   }
+
+  virtual unsigned getHwMode() const { return 0; }
+
+  /// Return the cache size in bytes for the given level of cache.
+  /// Level is zero-based, so a value of zero means the first level of
+  /// cache.
+  ///
+  virtual Optional<unsigned> getCacheSize(unsigned Level) const;
+
+  /// Return the cache associatvity for the given level of cache.
+  /// Level is zero-based, so a value of zero means the first level of
+  /// cache.
+  ///
+  virtual Optional<unsigned> getCacheAssociativity(unsigned Level) const;
+
+  /// Return the target cache line size in bytes at a given level.
+  ///
+  virtual Optional<unsigned> getCacheLineSize(unsigned Level) const;
+
+  /// Return the target cache line size in bytes.  By default, return
+  /// the line size for the bottom-most level of cache.  This provides
+  /// a more convenient interface for the common case where all cache
+  /// levels have the same line size.  Return zero if there is no
+  /// cache model.
+  ///
+  virtual unsigned getCacheLineSize() const {
+    Optional<unsigned> Size = getCacheLineSize(0);
+    if (Size)
+      return *Size;
+
+    return 0;
+  }
+
+  /// Return the preferred prefetch distance in terms of instructions.
+  ///
+  virtual unsigned getPrefetchDistance() const;
+
+  /// Return the maximum prefetch distance in terms of loop
+  /// iterations.
+  ///
+  virtual unsigned getMaxPrefetchIterationsAhead() const;
+
+  /// \return True if prefetching should also be done for writes.
+  ///
+  virtual bool enableWritePrefetching() const;
+
+  /// Return the minimum stride necessary to trigger software
+  /// prefetching.
+  ///
+  virtual unsigned getMinPrefetchStride(unsigned NumMemAccesses,
+                                        unsigned NumStridedMemAccesses,
+                                        unsigned NumPrefetches,
+                                        bool HasCall) const;
 };
 
 } // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/MC/MCSymbol.h b/linux-x64/clang/include/llvm/MC/MCSymbol.h
index 189484d..a83781f 100644
--- a/linux-x64/clang/include/llvm/MC/MCSymbol.h
+++ b/linux-x64/clang/include/llvm/MC/MCSymbol.h
@@ -16,6 +16,7 @@
 #include "llvm/ADT/PointerIntPair.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCFragment.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MathExtras.h"
@@ -27,7 +28,6 @@
 
 class MCAsmInfo;
 class MCContext;
-class MCExpr;
 class MCSection;
 class raw_ostream;
 
@@ -94,7 +94,8 @@
 
   mutable unsigned IsRegistered : 1;
 
-  /// This symbol is visible outside this translation unit.
+  /// True if this symbol is visible outside this translation unit. Note: ELF
+  /// uses binding instead of this bit.
   mutable unsigned IsExternal : 1;
 
   /// This symbol is private extern.
@@ -178,14 +179,6 @@
     llvm_unreachable("Constructor throws?");
   }
 
-  MCSection *getSectionPtr() const {
-    if (MCFragment *F = getFragment()) {
-      assert(F != AbsolutePseudoFragment);
-      return F->getParent();
-    }
-    return nullptr;
-  }
-
   /// Get a reference to the name field.  Requires that we have a name
   const StringMapEntry<bool> *&getNameEntryPtr() {
     assert(FragmentAndHasName.getInt() && "Name is required");
@@ -267,7 +260,7 @@
   /// Get the section associated with a defined, non-absolute symbol.
   MCSection &getSection() const {
     assert(isInSection() && "Invalid accessor!");
-    return *getSectionPtr();
+    return *getFragment()->getParent();
   }
 
   /// Mark the symbol as defined in the fragment \p F.
diff --git a/linux-x64/clang/include/llvm/MC/MCSymbolWasm.h b/linux-x64/clang/include/llvm/MC/MCSymbolWasm.h
index c50cd0e..ae512fd 100644
--- a/linux-x64/clang/include/llvm/MC/MCSymbolWasm.h
+++ b/linux-x64/clang/include/llvm/MC/MCSymbolWasm.h
@@ -18,11 +18,14 @@
   bool IsWeak = false;
   bool IsHidden = false;
   bool IsComdat = false;
+  mutable bool IsUsedInInitArray = false;
   mutable bool IsUsedInGOT = false;
-  Optional<std::string> ImportModule;
-  Optional<std::string> ImportName;
+  Optional<StringRef> ImportModule;
+  Optional<StringRef> ImportName;
+  Optional<StringRef> ExportName;
   wasm::WasmSignature *Signature = nullptr;
   Optional<wasm::WasmGlobalType> GlobalType;
+  Optional<wasm::ValType> TableType;
   Optional<wasm::WasmEventType> EventType;
 
   /// An expression describing how to calculate the size of a symbol. If a
@@ -30,8 +33,6 @@
   const MCExpr *SymbolSize = nullptr;
 
 public:
-  // Use a module name of "env" for now, for compatibility with existing tools.
-  // This is temporary, and may change, as the ABI is not yet stable.
   MCSymbolWasm(const StringMapEntry<bool> *Name, bool isTemporary)
       : MCSymbol(SymbolKindWasm, Name, isTemporary) {}
   static bool classof(const MCSymbol *S) { return S->isWasm(); }
@@ -42,6 +43,7 @@
   bool isFunction() const { return Type == wasm::WASM_SYMBOL_TYPE_FUNCTION; }
   bool isData() const { return Type == wasm::WASM_SYMBOL_TYPE_DATA; }
   bool isGlobal() const { return Type == wasm::WASM_SYMBOL_TYPE_GLOBAL; }
+  bool isTable() const { return Type == wasm::WASM_SYMBOL_TYPE_TABLE; }
   bool isSection() const { return Type == wasm::WASM_SYMBOL_TYPE_SECTION; }
   bool isEvent() const { return Type == wasm::WASM_SYMBOL_TYPE_EVENT; }
   wasm::WasmSymbolType getType() const { return Type; }
@@ -54,6 +56,13 @@
     modifyFlags(wasm::WASM_SYMBOL_EXPORTED, wasm::WASM_SYMBOL_EXPORTED);
   }
 
+  bool isNoStrip() const {
+    return getFlags() & wasm::WASM_SYMBOL_NO_STRIP;
+  }
+  void setNoStrip() const {
+    modifyFlags(wasm::WASM_SYMBOL_NO_STRIP, wasm::WASM_SYMBOL_NO_STRIP);
+  }
+
   bool isWeak() const { return IsWeak; }
   void setWeak(bool isWeak) { IsWeak = isWeak; }
 
@@ -63,25 +72,45 @@
   bool isComdat() const { return IsComdat; }
   void setComdat(bool isComdat) { IsComdat = isComdat; }
 
-  const StringRef getImportModule() const {
-      if (ImportModule.hasValue()) {
-          return ImportModule.getValue();
-      }
-      return "env";
+  bool hasImportModule() const { return ImportModule.hasValue(); }
+  StringRef getImportModule() const {
+    if (ImportModule.hasValue())
+      return ImportModule.getValue();
+    // Use a default module name of "env" for now, for compatibility with
+    // existing tools.
+    // TODO(sbc): Find a way to specify a default value in the object format
+    // without picking a hardcoded value like this.
+    return "env";
   }
   void setImportModule(StringRef Name) { ImportModule = Name; }
 
-  const StringRef getImportName() const {
-      if (ImportName.hasValue()) {
-          return ImportName.getValue();
-      }
-      return getName();
+  bool hasImportName() const { return ImportName.hasValue(); }
+  StringRef getImportName() const {
+    if (ImportName.hasValue())
+      return ImportName.getValue();
+    return getName();
   }
   void setImportName(StringRef Name) { ImportName = Name; }
 
+  bool hasExportName() const { return ExportName.hasValue(); }
+  StringRef getExportName() const { return ExportName.getValue(); }
+  void setExportName(StringRef Name) { ExportName = Name; }
+
+  bool isFunctionTable() const {
+    return isTable() && hasTableType() &&
+           getTableType() == wasm::ValType::FUNCREF;
+  }
+  void setFunctionTable() {
+    setType(wasm::WASM_SYMBOL_TYPE_TABLE);
+    setTableType(wasm::ValType::FUNCREF);
+  }
+
   void setUsedInGOT() const { IsUsedInGOT = true; }
   bool isUsedInGOT() const { return IsUsedInGOT; }
 
+  void setUsedInInitArray() const { IsUsedInInitArray = true; }
+  bool isUsedInInitArray() const { return IsUsedInInitArray; }
+
   const wasm::WasmSignature *getSignature() const { return Signature; }
   void setSignature(wasm::WasmSignature *Sig) { Signature = Sig; }
 
@@ -91,6 +120,13 @@
   }
   void setGlobalType(wasm::WasmGlobalType GT) { GlobalType = GT; }
 
+  bool hasTableType() const { return TableType.hasValue(); }
+  wasm::ValType getTableType() const {
+    assert(hasTableType());
+    return TableType.getValue();
+  }
+  void setTableType(wasm::ValType TT) { TableType = TT; }
+
   const wasm::WasmEventType &getEventType() const {
     assert(EventType.hasValue());
     return EventType.getValue();
diff --git a/linux-x64/clang/include/llvm/MC/MCSymbolXCOFF.h b/linux-x64/clang/include/llvm/MC/MCSymbolXCOFF.h
index 30cbf0b..752e1e7 100644
--- a/linux-x64/clang/include/llvm/MC/MCSymbolXCOFF.h
+++ b/linux-x64/clang/include/llvm/MC/MCSymbolXCOFF.h
@@ -8,27 +8,67 @@
 #ifndef LLVM_MC_MCSYMBOLXCOFF_H
 #define LLVM_MC_MCSYMBOLXCOFF_H
 
+#include "llvm/ADT/Optional.h"
+#include "llvm/ADT/StringRef.h"
 #include "llvm/BinaryFormat/XCOFF.h"
 #include "llvm/MC/MCSymbol.h"
 
 namespace llvm {
 
-class GlobalValue;
+class MCSectionXCOFF;
 
 class MCSymbolXCOFF : public MCSymbol {
-  // The IR symbol this MCSymbolXCOFF is based on. It is set on function
-  // entry point symbols when they are the callee operand of a direct call
-  // SDNode.
-  const GlobalValue *GV = nullptr;
-
 public:
   MCSymbolXCOFF(const StringMapEntry<bool> *Name, bool isTemporary)
       : MCSymbol(SymbolKindXCOFF, Name, isTemporary) {}
 
-  void setGlobalValue(const GlobalValue *G) { GV = G; }
-  const GlobalValue *getGlobalValue() const { return GV; }
-
   static bool classof(const MCSymbol *S) { return S->isXCOFF(); }
+
+  static StringRef getUnqualifiedName(StringRef Name) {
+    if (Name.back() == ']') {
+      StringRef Lhs, Rhs;
+      std::tie(Lhs, Rhs) = Name.rsplit('[');
+      assert(!Rhs.empty() && "Invalid SMC format in XCOFF symbol.");
+      return Lhs;
+    }
+    return Name;
+  }
+
+  void setStorageClass(XCOFF::StorageClass SC) {
+    StorageClass = SC;
+  };
+
+  XCOFF::StorageClass getStorageClass() const {
+    assert(StorageClass.hasValue() &&
+           "StorageClass not set on XCOFF MCSymbol.");
+    return StorageClass.getValue();
+  }
+
+  StringRef getUnqualifiedName() const { return getUnqualifiedName(getName()); }
+
+  MCSectionXCOFF *getRepresentedCsect() const;
+
+  void setRepresentedCsect(MCSectionXCOFF *C);
+
+  void setVisibilityType(XCOFF::VisibilityType SVT) { VisibilityType = SVT; };
+
+  XCOFF::VisibilityType getVisibilityType() const { return VisibilityType; }
+
+  bool hasRename() const { return !SymbolTableName.empty(); }
+
+  void setSymbolTableName(StringRef STN) { SymbolTableName = STN; }
+
+  StringRef getSymbolTableName() const {
+    if (hasRename())
+      return SymbolTableName;
+    return getUnqualifiedName();
+  }
+
+private:
+  Optional<XCOFF::StorageClass> StorageClass;
+  MCSectionXCOFF *RepresentedCsect = nullptr;
+  XCOFF::VisibilityType VisibilityType = XCOFF::SYM_V_UNSPECIFIED;
+  StringRef SymbolTableName;
 };
 
 } // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/MC/MCTargetOptions.h b/linux-x64/clang/include/llvm/MC/MCTargetOptions.h
index f184620..d29a749 100644
--- a/linux-x64/clang/include/llvm/MC/MCTargetOptions.h
+++ b/linux-x64/clang/include/llvm/MC/MCTargetOptions.h
@@ -9,6 +9,7 @@
 #ifndef LLVM_MC_MCTARGETOPTIONS_H
 #define LLVM_MC_MCTARGETOPTIONS_H
 
+#include "llvm/ADT/ArrayRef.h"
 #include <string>
 #include <vector>
 
@@ -21,6 +22,7 @@
   ARM,      ///< ARM EHABI
   WinEH,    ///< Windows Exception Handling
   Wasm,     ///< WebAssembly Exception Handling
+  AIX,      ///< AIX Exception Handling
 };
 
 enum class DebugCompressionType {
@@ -46,7 +48,6 @@
   bool MCSaveTempLabels : 1;
   bool MCUseDwarfDirectory : 1;
   bool MCIncrementalLinkerCompatible : 1;
-  bool MCPIECopyRelocations : 1;
   bool ShowMCEncoding : 1;
   bool ShowMCInst : 1;
   bool AsmVerbose : 1;
@@ -54,11 +55,16 @@
   /// Preserve Comments in Assembly.
   bool PreserveAsmComments : 1;
 
+  bool Dwarf64 : 1;
   int DwarfVersion = 0;
 
   std::string ABIName;
+  std::string AssemblyLanguage;
   std::string SplitDwarfFile;
 
+  const char *Argv0 = nullptr;
+  ArrayRef<const char *> CommandLineArgs;
+
   /// Additional paths to search for `.include` directives when using the
   /// integrated assembler.
   std::vector<std::string> IASSearchPaths;
@@ -69,6 +75,11 @@
   /// textual name of the ABI that we want the backend to use, e.g. o32, or
   /// aapcs-linux.
   StringRef getABIName() const;
+
+  /// getAssemblyLanguage - If this returns a non-empty string this represents
+  /// the textual name of the assembly language that we will use for this
+  /// target, e.g. masm.
+  StringRef getAssemblyLanguage() const;
 };
 
 } // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/MC/MCTargetOptionsCommandFlags.h b/linux-x64/clang/include/llvm/MC/MCTargetOptionsCommandFlags.h
new file mode 100644
index 0000000..6d3c477
--- /dev/null
+++ b/linux-x64/clang/include/llvm/MC/MCTargetOptionsCommandFlags.h
@@ -0,0 +1,57 @@
+//===-- MCTargetOptionsCommandFlags.h --------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains machine code-specific flags that are shared between
+// different command line tools.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_MC_MCTARGETOPTIONSCOMMANDFLAGS_H
+#define LLVM_MC_MCTARGETOPTIONSCOMMANDFLAGS_H
+
+#include "llvm/ADT/Optional.h"
+#include <string>
+
+namespace llvm {
+
+class MCTargetOptions;
+
+namespace mc {
+
+bool getRelaxAll();
+Optional<bool> getExplicitRelaxAll();
+
+bool getIncrementalLinkerCompatible();
+
+int getDwarfVersion();
+
+bool getDwarf64();
+
+bool getShowMCInst();
+
+bool getFatalWarnings();
+
+bool getNoWarn();
+
+bool getNoDeprecatedWarn();
+
+std::string getABIName();
+
+/// Create this object with static storage to register mc-related command
+/// line options.
+struct RegisterMCTargetOptionsFlags {
+  RegisterMCTargetOptionsFlags();
+};
+
+MCTargetOptions InitMCTargetOptionsFromFlags();
+
+} // namespace mc
+
+} // namespace llvm
+
+#endif
diff --git a/linux-x64/clang/include/llvm/MC/MCTargetOptionsCommandFlags.inc b/linux-x64/clang/include/llvm/MC/MCTargetOptionsCommandFlags.inc
deleted file mode 100644
index 9f1177f..0000000
--- a/linux-x64/clang/include/llvm/MC/MCTargetOptionsCommandFlags.inc
+++ /dev/null
@@ -1,68 +0,0 @@
-//===-- MCTargetOptionsCommandFlags.h --------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// This file contains machine code-specific flags that are shared between
-// different command line tools.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_MC_MCTARGETOPTIONSCOMMANDFLAGS_H
-#define LLVM_MC_MCTARGETOPTIONSCOMMANDFLAGS_H
-
-#include "llvm/MC/MCTargetOptions.h"
-#include "llvm/Support/CommandLine.h"
-using namespace llvm;
-
-static cl::opt<bool> RelaxAll("mc-relax-all",
-                       cl::desc("When used with filetype=obj, "
-                                "relax all fixups in the emitted object file"));
-
-static cl::opt<bool> IncrementalLinkerCompatible(
-    "incremental-linker-compatible",
-    cl::desc(
-        "When used with filetype=obj, "
-        "emit an object file which can be used with an incremental linker"));
-
-static cl::opt<bool> PIECopyRelocations("pie-copy-relocations", cl::desc("PIE Copy Relocations"));
-
-static cl::opt<int> DwarfVersion("dwarf-version", cl::desc("Dwarf version"),
-                          cl::init(0));
-
-static cl::opt<bool> ShowMCInst("asm-show-inst",
-                         cl::desc("Emit internal instruction representation to "
-                                  "assembly file"));
-
-static cl::opt<bool> FatalWarnings("fatal-warnings",
-                            cl::desc("Treat warnings as errors"));
-
-static cl::opt<bool> NoWarn("no-warn", cl::desc("Suppress all warnings"));
-static cl::alias NoWarnW("W", cl::desc("Alias for --no-warn"), cl::aliasopt(NoWarn));
-
-static cl::opt<bool> NoDeprecatedWarn("no-deprecated-warn",
-                               cl::desc("Suppress all deprecated warnings"));
-
-static cl::opt<std::string>
-ABIName("target-abi", cl::Hidden,
-        cl::desc("The name of the ABI to be targeted from the backend."),
-        cl::init(""));
-
-static MCTargetOptions InitMCTargetOptionsFromFlags() {
-  MCTargetOptions Options;
-  Options.MCRelaxAll = RelaxAll;
-  Options.MCIncrementalLinkerCompatible = IncrementalLinkerCompatible;
-  Options.MCPIECopyRelocations = PIECopyRelocations;
-  Options.DwarfVersion = DwarfVersion;
-  Options.ShowMCInst = ShowMCInst;
-  Options.ABIName = ABIName;
-  Options.MCFatalWarnings = FatalWarnings;
-  Options.MCNoWarn = NoWarn;
-  Options.MCNoDeprecatedWarn = NoDeprecatedWarn;
-  return Options;
-}
-
-#endif
diff --git a/linux-x64/clang/include/llvm/MC/MCValue.h b/linux-x64/clang/include/llvm/MC/MCValue.h
index 0be7ce7..37feee4 100644
--- a/linux-x64/clang/include/llvm/MC/MCValue.h
+++ b/linux-x64/clang/include/llvm/MC/MCValue.h
@@ -14,12 +14,10 @@
 #define LLVM_MC_MCVALUE_H
 
 #include "llvm/MC/MCExpr.h"
-#include "llvm/MC/MCSymbol.h"
 #include "llvm/Support/DataTypes.h"
 #include <cassert>
 
 namespace llvm {
-class MCAsmInfo;
 class raw_ostream;
 
 /// This represents an "assembler immediate".
diff --git a/linux-x64/clang/include/llvm/MC/MCWasmObjectWriter.h b/linux-x64/clang/include/llvm/MC/MCWasmObjectWriter.h
index 4adbca2..00da632 100644
--- a/linux-x64/clang/include/llvm/MC/MCWasmObjectWriter.h
+++ b/linux-x64/clang/include/llvm/MC/MCWasmObjectWriter.h
@@ -20,14 +20,15 @@
 
 class MCWasmObjectTargetWriter : public MCObjectTargetWriter {
   const unsigned Is64Bit : 1;
+  const unsigned IsEmscripten : 1;
 
 protected:
-  explicit MCWasmObjectTargetWriter(bool Is64Bit_);
+  explicit MCWasmObjectTargetWriter(bool Is64Bit_, bool IsEmscripten);
 
 public:
   virtual ~MCWasmObjectTargetWriter();
 
-  virtual Triple::ObjectFormatType getFormat() const { return Triple::Wasm; }
+  Triple::ObjectFormatType getFormat() const override { return Triple::Wasm; }
   static bool classof(const MCObjectTargetWriter *W) {
     return W->getFormat() == Triple::Wasm;
   }
@@ -38,6 +39,7 @@
   /// \name Accessors
   /// @{
   bool is64Bit() const { return Is64Bit; }
+  bool isEmscripten() const { return IsEmscripten; }
   /// @}
 };
 
@@ -50,6 +52,10 @@
 createWasmObjectWriter(std::unique_ptr<MCWasmObjectTargetWriter> MOTW,
                        raw_pwrite_stream &OS);
 
+std::unique_ptr<MCObjectWriter>
+createWasmDwoObjectWriter(std::unique_ptr<MCWasmObjectTargetWriter> MOTW,
+                          raw_pwrite_stream &OS, raw_pwrite_stream &DwoOS);
+
 } // namespace llvm
 
 #endif
diff --git a/linux-x64/clang/include/llvm/MC/MCWasmStreamer.h b/linux-x64/clang/include/llvm/MC/MCWasmStreamer.h
index 2d7f2b9..6651f07 100644
--- a/linux-x64/clang/include/llvm/MC/MCWasmStreamer.h
+++ b/linux-x64/clang/include/llvm/MC/MCWasmStreamer.h
@@ -11,18 +11,14 @@
 
 #include "MCAsmBackend.h"
 #include "MCCodeEmitter.h"
-#include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/MC/MCDirectives.h"
 #include "llvm/MC/MCObjectStreamer.h"
 #include "llvm/MC/MCObjectWriter.h"
-#include "llvm/MC/SectionKind.h"
 #include "llvm/Support/DataTypes.h"
 
 namespace llvm {
-class MCAssembler;
 class MCExpr;
 class MCInst;
-class raw_ostream;
 
 class MCWasmStreamer : public MCObjectStreamer {
 public:
@@ -44,37 +40,33 @@
   /// \name MCStreamer Interface
   /// @{
 
-  void ChangeSection(MCSection *Section, const MCExpr *Subsection) override;
-  void EmitAssemblerFlag(MCAssemblerFlag Flag) override;
-  void EmitThumbFunc(MCSymbol *Func) override;
-  void EmitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) override;
-  bool EmitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute) override;
-  void EmitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) override;
-  void EmitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
+  void changeSection(MCSection *Section, const MCExpr *Subsection) override;
+  void emitAssemblerFlag(MCAssemblerFlag Flag) override;
+  void emitThumbFunc(MCSymbol *Func) override;
+  void emitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) override;
+  bool emitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute) override;
+  void emitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) override;
+  void emitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
                         unsigned ByteAlignment) override;
 
   void emitELFSize(MCSymbol *Symbol, const MCExpr *Value) override;
 
-  void EmitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size,
+  void emitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size,
                              unsigned ByteAlignment) override;
 
-  void EmitZerofill(MCSection *Section, MCSymbol *Symbol = nullptr,
+  void emitZerofill(MCSection *Section, MCSymbol *Symbol = nullptr,
                     uint64_t Size = 0, unsigned ByteAlignment = 0,
                     SMLoc Loc = SMLoc()) override;
-  void EmitTBSSSymbol(MCSection *Section, MCSymbol *Symbol, uint64_t Size,
+  void emitTBSSSymbol(MCSection *Section, MCSymbol *Symbol, uint64_t Size,
                       unsigned ByteAlignment = 0) override;
-  void EmitValueImpl(const MCExpr *Value, unsigned Size,
-                     SMLoc Loc = SMLoc()) override;
 
-  void EmitIdent(StringRef IdentString) override;
+  void emitIdent(StringRef IdentString) override;
 
-  void EmitValueToAlignment(unsigned, int64_t, unsigned, unsigned) override;
-
-  void FinishImpl() override;
+  void finishImpl() override;
 
 private:
-  void EmitInstToFragment(const MCInst &Inst, const MCSubtargetInfo &) override;
-  void EmitInstToData(const MCInst &Inst, const MCSubtargetInfo &) override;
+  void emitInstToFragment(const MCInst &Inst, const MCSubtargetInfo &) override;
+  void emitInstToData(const MCInst &Inst, const MCSubtargetInfo &) override;
 
   /// Merge the content of the fragment \p EF into the fragment \p DF.
   void mergeFragment(MCDataFragment *, MCDataFragment *);
diff --git a/linux-x64/clang/include/llvm/MC/MCWin64EH.h b/linux-x64/clang/include/llvm/MC/MCWin64EH.h
index 60ec06e..065161d 100644
--- a/linux-x64/clang/include/llvm/MC/MCWin64EH.h
+++ b/linux-x64/clang/include/llvm/MC/MCWin64EH.h
@@ -53,14 +53,15 @@
 class UnwindEmitter : public WinEH::UnwindEmitter {
 public:
   void Emit(MCStreamer &Streamer) const override;
-  void EmitUnwindInfo(MCStreamer &Streamer, WinEH::FrameInfo *FI) const override;
+  void EmitUnwindInfo(MCStreamer &Streamer, WinEH::FrameInfo *FI,
+                      bool HandlerData) const override;
 };
 
 class ARM64UnwindEmitter : public WinEH::UnwindEmitter {
 public:
   void Emit(MCStreamer &Streamer) const override;
-  void EmitUnwindInfo(MCStreamer &Streamer,
-                      WinEH::FrameInfo *FI) const override;
+  void EmitUnwindInfo(MCStreamer &Streamer, WinEH::FrameInfo *FI,
+                      bool HandlerData) const override;
 };
 
 }
diff --git a/linux-x64/clang/include/llvm/MC/MCWinCOFFObjectWriter.h b/linux-x64/clang/include/llvm/MC/MCWinCOFFObjectWriter.h
index 3fe124f..3015efe 100644
--- a/linux-x64/clang/include/llvm/MC/MCWinCOFFObjectWriter.h
+++ b/linux-x64/clang/include/llvm/MC/MCWinCOFFObjectWriter.h
@@ -31,7 +31,7 @@
   public:
     virtual ~MCWinCOFFObjectTargetWriter() = default;
 
-    virtual Triple::ObjectFormatType getFormat() const { return Triple::COFF; }
+    Triple::ObjectFormatType getFormat() const override { return Triple::COFF; }
     static bool classof(const MCObjectTargetWriter *W) {
       return W->getFormat() == Triple::COFF;
     }
diff --git a/linux-x64/clang/include/llvm/MC/MCWinCOFFStreamer.h b/linux-x64/clang/include/llvm/MC/MCWinCOFFStreamer.h
index c1c1ec5..53b2ef0 100644
--- a/linux-x64/clang/include/llvm/MC/MCWinCOFFStreamer.h
+++ b/linux-x64/clang/include/llvm/MC/MCWinCOFFStreamer.h
@@ -40,11 +40,11 @@
   /// \{
 
   void InitSections(bool NoExecStack) override;
-  void EmitLabel(MCSymbol *Symbol, SMLoc Loc = SMLoc()) override;
-  void EmitAssemblerFlag(MCAssemblerFlag Flag) override;
-  void EmitThumbFunc(MCSymbol *Func) override;
-  bool EmitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute) override;
-  void EmitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) override;
+  void emitLabel(MCSymbol *Symbol, SMLoc Loc = SMLoc()) override;
+  void emitAssemblerFlag(MCAssemblerFlag Flag) override;
+  void emitThumbFunc(MCSymbol *Func) override;
+  bool emitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute) override;
+  void emitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) override;
   void BeginCOFFSymbolDef(MCSymbol const *Symbol) override;
   void EmitCOFFSymbolStorageClass(int StorageClass) override;
   void EmitCOFFSymbolType(int Type) override;
@@ -54,24 +54,30 @@
   void EmitCOFFSectionIndex(MCSymbol const *Symbol) override;
   void EmitCOFFSecRel32(MCSymbol const *Symbol, uint64_t Offset) override;
   void EmitCOFFImgRel32(MCSymbol const *Symbol, int64_t Offset) override;
-  void EmitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
+  void emitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
                         unsigned ByteAlignment) override;
-  void EmitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size,
+  void emitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size,
                              unsigned ByteAlignment) override;
-  void EmitZerofill(MCSection *Section, MCSymbol *Symbol, uint64_t Size,
+  void emitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) override;
+  void emitZerofill(MCSection *Section, MCSymbol *Symbol, uint64_t Size,
                     unsigned ByteAlignment, SMLoc Loc = SMLoc()) override;
-  void EmitTBSSSymbol(MCSection *Section, MCSymbol *Symbol, uint64_t Size,
+  void emitTBSSSymbol(MCSection *Section, MCSymbol *Symbol, uint64_t Size,
                       unsigned ByteAlignment) override;
-  void EmitIdent(StringRef IdentString) override;
+  void emitIdent(StringRef IdentString) override;
   void EmitWinEHHandlerData(SMLoc Loc) override;
-  void FinishImpl() override;
+  void emitCGProfileEntry(const MCSymbolRefExpr *From,
+                          const MCSymbolRefExpr *To, uint64_t Count) override;
+  void finishImpl() override;
 
   /// \}
 
 protected:
   const MCSymbol *CurSymbol;
 
-  void EmitInstToData(const MCInst &Inst, const MCSubtargetInfo &STI) override;
+  void emitInstToData(const MCInst &Inst, const MCSubtargetInfo &STI) override;
+
+  void finalizeCGProfileEntry(const MCSymbolRefExpr *&S);
+  void finalizeCGProfile();
 
 private:
   void Error(const Twine &Msg) const;
diff --git a/linux-x64/clang/include/llvm/MC/MCWinEH.h b/linux-x64/clang/include/llvm/MC/MCWinEH.h
index b1c28c0..5688255 100644
--- a/linux-x64/clang/include/llvm/MC/MCWinEH.h
+++ b/linux-x64/clang/include/llvm/MC/MCWinEH.h
@@ -26,6 +26,14 @@
 
   Instruction(unsigned Op, MCSymbol *L, unsigned Reg, unsigned Off)
     : Label(L), Offset(Off), Register(Reg), Operation(Op) {}
+
+  bool operator==(const Instruction &I) const {
+    // Check whether two instructions refer to the same operation
+    // applied at a different spot (i.e. pointing at a different label).
+    return Offset == I.Offset && Register == I.Register &&
+           Operation == I.Operation;
+  }
+  bool operator!=(const Instruction &I) const { return !(*this == I); }
 };
 
 struct FrameInfo {
@@ -36,10 +44,12 @@
   const MCSymbol *Function = nullptr;
   const MCSymbol *PrologEnd = nullptr;
   const MCSymbol *Symbol = nullptr;
-  const MCSection *TextSection = nullptr;
+  MCSection *TextSection = nullptr;
+  uint32_t PackedInfo = 0;
 
   bool HandlesUnwind = false;
   bool HandlesExceptions = false;
+  bool EmitAttempted = false;
 
   int LastFrameInst = -1;
   const FrameInfo *ChainedParent = nullptr;
@@ -53,6 +63,15 @@
             const FrameInfo *ChainedParent)
       : Begin(BeginFuncEHLabel), Function(Function),
         ChainedParent(ChainedParent) {}
+
+  bool empty() const {
+    if (!Instructions.empty())
+      return false;
+    for (const auto &E : EpilogMap)
+      if (!E.second.empty())
+        return false;
+    return true;
+  }
 };
 
 class UnwindEmitter {
@@ -61,7 +80,8 @@
 
   /// This emits the unwind info sections (.pdata and .xdata in PE/COFF).
   virtual void Emit(MCStreamer &Streamer) const = 0;
-  virtual void EmitUnwindInfo(MCStreamer &Streamer, FrameInfo *FI) const = 0;
+  virtual void EmitUnwindInfo(MCStreamer &Streamer, FrameInfo *FI,
+                              bool HandlerData) const = 0;
 };
 }
 }
diff --git a/linux-x64/clang/include/llvm/MC/MCXCOFFObjectWriter.h b/linux-x64/clang/include/llvm/MC/MCXCOFFObjectWriter.h
index fe4087f..faad2ce 100644
--- a/linux-x64/clang/include/llvm/MC/MCXCOFFObjectWriter.h
+++ b/linux-x64/clang/include/llvm/MC/MCXCOFFObjectWriter.h
@@ -28,6 +28,13 @@
   }
   bool is64Bit() const { return Is64Bit; }
 
+  // Returns relocation info such as type, sign and size.
+  // First element of the pair contains type,
+  // second element contains sign and size.
+  virtual std::pair<uint8_t, uint8_t>
+  getRelocTypeAndSignSize(const MCValue &Target, const MCFixup &Fixup,
+                          bool IsPCRel) const = 0;
+
 private:
   bool Is64Bit;
 };
diff --git a/linux-x64/clang/include/llvm/MC/MCXCOFFStreamer.h b/linux-x64/clang/include/llvm/MC/MCXCOFFStreamer.h
index 159ae48..5fc2efb 100644
--- a/linux-x64/clang/include/llvm/MC/MCXCOFFStreamer.h
+++ b/linux-x64/clang/include/llvm/MC/MCXCOFFStreamer.h
@@ -19,13 +19,24 @@
                   std::unique_ptr<MCObjectWriter> OW,
                   std::unique_ptr<MCCodeEmitter> Emitter);
 
-  bool EmitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute) override;
-  void EmitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
+  bool emitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute) override;
+  void emitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
                         unsigned ByteAlignment) override;
-  void EmitZerofill(MCSection *Section, MCSymbol *Symbol = nullptr,
+  void emitZerofill(MCSection *Section, MCSymbol *Symbol = nullptr,
                     uint64_t Size = 0, unsigned ByteAlignment = 0,
                     SMLoc Loc = SMLoc()) override;
-  void EmitInstToData(const MCInst &Inst, const MCSubtargetInfo &) override;
+  void emitInstToData(const MCInst &Inst, const MCSubtargetInfo &) override;
+  void emitXCOFFLocalCommonSymbol(MCSymbol *LabelSym, uint64_t Size,
+                                  MCSymbol *CsectSym,
+                                  unsigned ByteAlign) override;
+  void emitXCOFFSymbolLinkageWithVisibility(MCSymbol *Symbol,
+                                            MCSymbolAttr Linkage,
+                                            MCSymbolAttr Visibility) override;
+  void emitXCOFFRenameDirective(const MCSymbol *Name,
+                                StringRef Rename) override {
+    report_fatal_error("emitXCOFFRenameDirective is not implemented yet on "
+                       "object generation path");
+  }
 };
 
 } // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/MC/StringTableBuilder.h b/linux-x64/clang/include/llvm/MC/StringTableBuilder.h
index c83eca4..3f9c91b 100644
--- a/linux-x64/clang/include/llvm/MC/StringTableBuilder.h
+++ b/linux-x64/clang/include/llvm/MC/StringTableBuilder.h
@@ -22,7 +22,17 @@
 /// Utility for building string tables with deduplicated suffixes.
 class StringTableBuilder {
 public:
-  enum Kind { ELF, WinCOFF, MachO, RAW, DWARF };
+  enum Kind {
+    ELF,
+    WinCOFF,
+    MachO,
+    MachO64,
+    MachOLinked,
+    MachO64Linked,
+    RAW,
+    DWARF,
+    XCOFF
+  };
 
 private:
   DenseMap<CachedHashStringRef, size_t> StringIndexMap;
@@ -59,6 +69,16 @@
     return getOffset(CachedHashStringRef(S));
   }
 
+  /// Check if a string is contained in the string table. Since this class
+  /// doesn't store the string values, this function can be used to check if
+  /// storage needs to be done prior to adding the string.
+  bool contains(StringRef S) const {
+    return contains(CachedHashStringRef(S));
+  }
+  bool contains(CachedHashStringRef S) const {
+    return StringIndexMap.count(S);
+  }
+
   size_t getSize() const { return Size; }
   void clear();
 
diff --git a/linux-x64/clang/include/llvm/MC/SubtargetFeature.h b/linux-x64/clang/include/llvm/MC/SubtargetFeature.h
index fc9565c..cc36b25 100644
--- a/linux-x64/clang/include/llvm/MC/SubtargetFeature.h
+++ b/linux-x64/clang/include/llvm/MC/SubtargetFeature.h
@@ -18,6 +18,7 @@
 #define LLVM_MC_SUBTARGETFEATURE_H
 
 #include "llvm/ADT/StringRef.h"
+#include "llvm/Support/MathExtras.h"
 #include <array>
 #include <bitset>
 #include <initializer_list>
@@ -29,24 +30,127 @@
 class raw_ostream;
 class Triple;
 
-const unsigned MAX_SUBTARGET_WORDS = 3;
+const unsigned MAX_SUBTARGET_WORDS = 4;
 const unsigned MAX_SUBTARGET_FEATURES = MAX_SUBTARGET_WORDS * 64;
 
 /// Container class for subtarget features.
-/// This is convenient because std::bitset does not have a constructor
-/// with an initializer list of set bits.
-class FeatureBitset : public std::bitset<MAX_SUBTARGET_FEATURES> {
+/// This is a constexpr reimplementation of a subset of std::bitset. It would be
+/// nice to use std::bitset directly, but it doesn't support constant
+/// initialization.
+class FeatureBitset {
+  static_assert((MAX_SUBTARGET_FEATURES % 64) == 0,
+                "Should be a multiple of 64!");
+  // This cannot be a std::array, operator[] is not constexpr until C++17.
+  uint64_t Bits[MAX_SUBTARGET_WORDS] = {};
+
+protected:
+  constexpr FeatureBitset(const std::array<uint64_t, MAX_SUBTARGET_WORDS> &B) {
+    for (unsigned I = 0; I != B.size(); ++I)
+      Bits[I] = B[I];
+  }
+
 public:
-  // Cannot inherit constructors because it's not supported by VC++..
-  FeatureBitset() = default;
-
-  FeatureBitset(const bitset<MAX_SUBTARGET_FEATURES>& B) : bitset(B) {}
-
-  FeatureBitset(std::initializer_list<unsigned> Init) {
+  constexpr FeatureBitset() = default;
+  constexpr FeatureBitset(std::initializer_list<unsigned> Init) {
     for (auto I : Init)
       set(I);
   }
 
+  FeatureBitset &set() {
+    std::fill(std::begin(Bits), std::end(Bits), -1ULL);
+    return *this;
+  }
+
+  constexpr FeatureBitset &set(unsigned I) {
+    // GCC <6.2 crashes if this is written in a single statement.
+    uint64_t NewBits = Bits[I / 64] | (uint64_t(1) << (I % 64));
+    Bits[I / 64] = NewBits;
+    return *this;
+  }
+
+  constexpr FeatureBitset &reset(unsigned I) {
+    // GCC <6.2 crashes if this is written in a single statement.
+    uint64_t NewBits = Bits[I / 64] & ~(uint64_t(1) << (I % 64));
+    Bits[I / 64] = NewBits;
+    return *this;
+  }
+
+  constexpr FeatureBitset &flip(unsigned I) {
+    // GCC <6.2 crashes if this is written in a single statement.
+    uint64_t NewBits = Bits[I / 64] ^ (uint64_t(1) << (I % 64));
+    Bits[I / 64] = NewBits;
+    return *this;
+  }
+
+  constexpr bool operator[](unsigned I) const {
+    uint64_t Mask = uint64_t(1) << (I % 64);
+    return (Bits[I / 64] & Mask) != 0;
+  }
+
+  constexpr bool test(unsigned I) const { return (*this)[I]; }
+
+  constexpr size_t size() const { return MAX_SUBTARGET_FEATURES; }
+
+  bool any() const {
+    return llvm::any_of(Bits, [](uint64_t I) { return I != 0; });
+  }
+  bool none() const { return !any(); }
+  size_t count() const {
+    size_t Count = 0;
+    for (auto B : Bits)
+      Count += countPopulation(B);
+    return Count;
+  }
+
+  constexpr FeatureBitset &operator^=(const FeatureBitset &RHS) {
+    for (unsigned I = 0, E = array_lengthof(Bits); I != E; ++I) {
+      Bits[I] ^= RHS.Bits[I];
+    }
+    return *this;
+  }
+  constexpr FeatureBitset operator^(const FeatureBitset &RHS) const {
+    FeatureBitset Result = *this;
+    Result ^= RHS;
+    return Result;
+  }
+
+  constexpr FeatureBitset &operator&=(const FeatureBitset &RHS) {
+    for (unsigned I = 0, E = array_lengthof(Bits); I != E; ++I) {
+      Bits[I] &= RHS.Bits[I];
+    }
+    return *this;
+  }
+  constexpr FeatureBitset operator&(const FeatureBitset &RHS) const {
+    FeatureBitset Result = *this;
+    Result &= RHS;
+    return Result;
+  }
+
+  constexpr FeatureBitset &operator|=(const FeatureBitset &RHS) {
+    for (unsigned I = 0, E = array_lengthof(Bits); I != E; ++I) {
+      Bits[I] |= RHS.Bits[I];
+    }
+    return *this;
+  }
+  constexpr FeatureBitset operator|(const FeatureBitset &RHS) const {
+    FeatureBitset Result = *this;
+    Result |= RHS;
+    return Result;
+  }
+
+  constexpr FeatureBitset operator~() const {
+    FeatureBitset Result = *this;
+    for (auto &B : Result.Bits)
+      B = ~B;
+    return Result;
+  }
+
+  bool operator==(const FeatureBitset &RHS) const {
+    return std::equal(std::begin(Bits), std::end(Bits), std::begin(RHS.Bits));
+  }
+
+  bool operator!=(const FeatureBitset &RHS) const { return !(*this == RHS); }
+
   bool operator < (const FeatureBitset &Other) const {
     for (unsigned I = 0, E = size(); I != E; ++I) {
       bool LHS = test(I), RHS = Other.test(I);
@@ -58,23 +162,12 @@
 };
 
 /// Class used to store the subtarget bits in the tables created by tablegen.
-/// The std::initializer_list constructor of FeatureBitset can't be done at
-/// compile time and requires a static constructor to run at startup.
-class FeatureBitArray {
-  std::array<uint64_t, MAX_SUBTARGET_WORDS> Bits;
-
+class FeatureBitArray : public FeatureBitset {
 public:
   constexpr FeatureBitArray(const std::array<uint64_t, MAX_SUBTARGET_WORDS> &B)
-      : Bits(B) {}
+      : FeatureBitset(B) {}
 
-  FeatureBitset getAsBitset() const {
-    FeatureBitset Result;
-
-    for (unsigned i = 0, e = Bits.size(); i != e; ++i)
-      Result |= FeatureBitset(Bits[i]) << (64 * i);
-
-    return Result;
-  }
+  const FeatureBitset &getAsBitset() const { return *this; }
 };
 
 //===----------------------------------------------------------------------===//
@@ -121,7 +214,7 @@
   }
 
   /// Return string stripped of flag.
-  static std::string StripFlag(StringRef Feature) {
+  static StringRef StripFlag(StringRef Feature) {
     return hasFlag(Feature) ? Feature.substr(1) : Feature;
   }
 
diff --git a/linux-x64/clang/include/llvm/MCA/CodeEmitter.h b/linux-x64/clang/include/llvm/MCA/CodeEmitter.h
new file mode 100644
index 0000000..edbadcc
--- /dev/null
+++ b/linux-x64/clang/include/llvm/MCA/CodeEmitter.h
@@ -0,0 +1,69 @@
+//===--------------------- CodeEmitter.h ------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+/// \file
+///
+/// A utility class used to compute instruction encodings. It buffers encodings
+/// for later usage. It exposes a simple API to compute and get the encodings as
+/// StringRef.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_MCA_CODEEMITTER_H
+#define LLVM_MCA_CODEEMITTER_H
+
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/MC/MCAsmBackend.h"
+#include "llvm/MC/MCCodeEmitter.h"
+#include "llvm/MC/MCInst.h"
+#include "llvm/MC/MCSubtargetInfo.h"
+#include "llvm/Support/raw_ostream.h"
+
+#include <string>
+
+namespace llvm {
+namespace mca {
+
+/// A utility class used to compute instruction encodings for a code region.
+///
+/// It provides a simple API to compute and return instruction encodings as
+/// strings. Encodings are cached internally for later usage.
+class CodeEmitter {
+  const MCSubtargetInfo &STI;
+  const MCAsmBackend &MAB;
+  const MCCodeEmitter &MCE;
+
+  SmallString<256> Code;
+  raw_svector_ostream VecOS;
+  ArrayRef<MCInst> Sequence;
+
+  // An EncodingInfo pair stores <base, length> information.  Base (i.e. first)
+  // is an index to the `Code`. Length (i.e. second) is the encoding size.
+  using EncodingInfo = std::pair<unsigned, unsigned>;
+
+  // A cache of encodings.
+  SmallVector<EncodingInfo, 16> Encodings;
+
+  EncodingInfo getOrCreateEncodingInfo(unsigned MCID);
+
+public:
+  CodeEmitter(const MCSubtargetInfo &ST, const MCAsmBackend &AB,
+              const MCCodeEmitter &CE, ArrayRef<MCInst> S)
+      : STI(ST), MAB(AB), MCE(CE), VecOS(Code), Sequence(S),
+        Encodings(S.size()) {}
+
+  StringRef getEncoding(unsigned MCID) {
+    EncodingInfo EI = getOrCreateEncodingInfo(MCID);
+    return StringRef(&Code[EI.first], EI.second);
+  }
+};
+
+} // namespace mca
+} // namespace llvm
+
+#endif // LLVM_MCA_CODEEMITTER_H
diff --git a/linux-x64/clang/include/llvm/MCA/Context.h b/linux-x64/clang/include/llvm/MCA/Context.h
index 503d780..af3cb8e 100644
--- a/linux-x64/clang/include/llvm/MCA/Context.h
+++ b/linux-x64/clang/include/llvm/MCA/Context.h
@@ -20,7 +20,6 @@
 #include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/MCA/HardwareUnits/HardwareUnit.h"
-#include "llvm/MCA/InstrBuilder.h"
 #include "llvm/MCA/Pipeline.h"
 #include "llvm/MCA/SourceMgr.h"
 #include <memory>
@@ -58,6 +57,9 @@
   Context(const Context &C) = delete;
   Context &operator=(const Context &C) = delete;
 
+  const MCRegisterInfo &getMCRegisterInfo() const { return MRI; }
+  const MCSubtargetInfo &getMCSubtargetInfo() const { return STI; }
+
   void addHardwareUnit(std::unique_ptr<HardwareUnit> H) {
     Hardware.push_back(std::move(H));
   }
@@ -65,7 +67,6 @@
   /// Construct a basic pipeline for simulating an out-of-order pipeline.
   /// This pipeline consists of Fetch, Dispatch, Execute, and Retire stages.
   std::unique_ptr<Pipeline> createDefaultPipeline(const PipelineOptions &Opts,
-                                                  InstrBuilder &IB,
                                                   SourceMgr &SrcMgr);
 };
 
diff --git a/linux-x64/clang/include/llvm/MCA/HardwareUnits/LSUnit.h b/linux-x64/clang/include/llvm/MCA/HardwareUnits/LSUnit.h
index ae9a49c..2f9b4ba 100644
--- a/linux-x64/clang/include/llvm/MCA/HardwareUnits/LSUnit.h
+++ b/linux-x64/clang/include/llvm/MCA/HardwareUnits/LSUnit.h
@@ -24,8 +24,6 @@
 namespace llvm {
 namespace mca {
 
-class Scheduler;
-
 /// A node of a memory dependency graph. A MemoryGroup describes a set of
 /// instructions with same memory dependencies.
 ///
@@ -42,7 +40,10 @@
   unsigned NumInstructions;
   unsigned NumExecuting;
   unsigned NumExecuted;
-  SmallVector<MemoryGroup *, 4> Succ;
+  // Successors that are in a order dependency with this group.
+  SmallVector<MemoryGroup *, 4> OrderSucc;
+  // Successors that are in a data dependency with this group.
+  SmallVector<MemoryGroup *, 4> DataSucc;
 
   CriticalDependency CriticalPredecessor;
   InstRef CriticalMemoryInstruction;
@@ -57,8 +58,9 @@
         NumExecuted(0), CriticalPredecessor(), CriticalMemoryInstruction() {}
   MemoryGroup(MemoryGroup &&) = default;
 
-  ArrayRef<MemoryGroup *> getSuccessors() const { return Succ; }
-  unsigned getNumSuccessors() const { return Succ.size(); }
+  size_t getNumSuccessors() const {
+    return OrderSucc.size() + DataSucc.size();
+  }
   unsigned getNumPredecessors() const { return NumPredecessors; }
   unsigned getNumExecutingPredecessors() const {
     return NumExecutingPredecessors;
@@ -77,12 +79,22 @@
     return CriticalPredecessor;
   }
 
-  void addSuccessor(MemoryGroup *Group) {
+  void addSuccessor(MemoryGroup *Group, bool IsDataDependent) {
+    // Do not need to add a dependency if there is no data
+    // dependency and all instructions from this group have been
+    // issued already.
+    if (!IsDataDependent && isExecuting())
+      return;
+
     Group->NumPredecessors++;
     assert(!isExecuted() && "Should have been removed!");
     if (isExecuting())
-      Group->onGroupIssued(CriticalMemoryInstruction);
-    Succ.emplace_back(Group);
+      Group->onGroupIssued(CriticalMemoryInstruction, IsDataDependent);
+
+    if (IsDataDependent)
+      DataSucc.emplace_back(Group);
+    else
+      OrderSucc.emplace_back(Group);
   }
 
   bool isWaiting() const {
@@ -100,10 +112,13 @@
   }
   bool isExecuted() const { return NumInstructions == NumExecuted; }
 
-  void onGroupIssued(const InstRef &IR) {
+  void onGroupIssued(const InstRef &IR, bool ShouldUpdateCriticalDep) {
     assert(!isReady() && "Unexpected group-start event!");
     NumExecutingPredecessors++;
 
+    if (!ShouldUpdateCriticalDep)
+      return;
+
     unsigned Cycles = IR.getInstruction()->getCyclesLeft();
     if (CriticalPredecessor.Cycles < Cycles) {
       CriticalPredecessor.IID = IR.getSourceIndex();
@@ -135,8 +150,14 @@
       return;
 
     // Notify successors that this group started execution.
-    for (MemoryGroup *MG : Succ)
-      MG->onGroupIssued(CriticalMemoryInstruction);
+    for (MemoryGroup *MG : OrderSucc) {
+      MG->onGroupIssued(CriticalMemoryInstruction, false);
+      // Release the order dependency with this group.
+      MG->onGroupExecuted();
+    }
+
+    for (MemoryGroup *MG : DataSucc)
+      MG->onGroupIssued(CriticalMemoryInstruction, true);
   }
 
   void onInstructionExecuted() {
@@ -147,8 +168,8 @@
     if (!isExecuted())
       return;
 
-    // Notify successors that this group has finished execution.
-    for (MemoryGroup *MG : Succ)
+    // Notify data dependent successors that this group has finished execution.
+    for (MemoryGroup *MG : DataSucc)
       MG->onGroupExecuted();
   }
 
@@ -209,8 +230,10 @@
 
   unsigned getUsedLQEntries() const { return UsedLQEntries; }
   unsigned getUsedSQEntries() const { return UsedSQEntries; }
-  unsigned assignLQSlot() { return UsedLQEntries++; }
-  unsigned assignSQSlot() { return UsedSQEntries++; }
+  void acquireLQSlot() { ++UsedLQEntries; }
+  void acquireSQSlot() { ++UsedSQEntries; }
+  void releaseLQSlot() { --UsedLQEntries; }
+  void releaseSQSlot() { --UsedSQEntries; }
 
   bool assumeNoAlias() const { return NoAlias; }
 
@@ -285,13 +308,18 @@
 
   unsigned createMemoryGroup() {
     Groups.insert(
-        std::make_pair(NextGroupID, llvm::make_unique<MemoryGroup>()));
+        std::make_pair(NextGroupID, std::make_unique<MemoryGroup>()));
     return NextGroupID++;
   }
 
-  // Instruction executed event handlers.
   virtual void onInstructionExecuted(const InstRef &IR);
 
+  // Loads are tracked by the LDQ (load queue) from dispatch until completion.
+  // Stores are tracked by the STQ (store queue) from dispatch until commitment.
+  // By default we conservatively assume that the LDQ receives a load at
+  // dispatch. Loads leave the LDQ at retirement stage.
+  virtual void onInstructionRetired(const InstRef &IR);
+
   virtual void onInstructionIssued(const InstRef &IR) {
     unsigned GroupID = IR.getInstruction()->getLSUTokenID();
     Groups[GroupID]->onInstructionIssued(IR);
@@ -407,6 +435,7 @@
   unsigned CurrentLoadGroupID;
   unsigned CurrentLoadBarrierGroupID;
   unsigned CurrentStoreGroupID;
+  unsigned CurrentStoreBarrierGroupID;
 
 public:
   LSUnit(const MCSchedModel &SM)
@@ -415,7 +444,8 @@
       : LSUnit(SM, LQ, SQ, /* NoAlias */ false) {}
   LSUnit(const MCSchedModel &SM, unsigned LQ, unsigned SQ, bool AssumeNoAlias)
       : LSUnitBase(SM, LQ, SQ, AssumeNoAlias), CurrentLoadGroupID(0),
-        CurrentLoadBarrierGroupID(0), CurrentStoreGroupID(0) {}
+        CurrentLoadBarrierGroupID(0), CurrentStoreGroupID(0),
+        CurrentStoreBarrierGroupID(0) {}
 
   /// Returns LSU_AVAILABLE if there are enough load/store queue entries to
   /// accomodate instruction IR.
@@ -436,9 +466,6 @@
   /// 6. A store has to wait until an older store barrier is fully executed.
   unsigned dispatch(const InstRef &IR) override;
 
-  // FIXME: For simplicity, we optimistically assume a similar behavior for
-  // store instructions. In practice, store operations don't tend to leave the
-  // store queue until they reach the 'Retired' stage (See PR39830).
   void onInstructionExecuted(const InstRef &IR) override;
 };
 
diff --git a/linux-x64/clang/include/llvm/MCA/HardwareUnits/RegisterFile.h b/linux-x64/clang/include/llvm/MCA/HardwareUnits/RegisterFile.h
index 3650632..e8ca348 100644
--- a/linux-x64/clang/include/llvm/MCA/HardwareUnits/RegisterFile.h
+++ b/linux-x64/clang/include/llvm/MCA/HardwareUnits/RegisterFile.h
@@ -22,7 +22,6 @@
 #include "llvm/MC/MCSchedule.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/MCA/HardwareUnits/HardwareUnit.h"
-#include "llvm/Support/Error.h"
 
 namespace llvm {
 namespace mca {
@@ -84,7 +83,7 @@
   // the target name).
   //
   // Users can limit the number of physical registers that are available in
-  // regsiter file #0 specifying command line flag `-register-file-size=<uint>`.
+  // register file #0 specifying command line flag `-register-file-size=<uint>`.
   SmallVector<RegisterMappingTracker, 4> RegisterFiles;
 
   // This type is used to propagate information about the owner of a register,
@@ -220,7 +219,7 @@
   //
   // Current implementation can simulate up to 32 register files (including the
   // special register file at index #0).
-  unsigned isAvailable(ArrayRef<unsigned> Regs) const;
+  unsigned isAvailable(ArrayRef<MCPhysReg> Regs) const;
 
   // Returns the number of PRFs implemented by this processor.
   unsigned getNumRegisterFiles() const { return RegisterFiles.size(); }
diff --git a/linux-x64/clang/include/llvm/MCA/HardwareUnits/ResourceManager.h b/linux-x64/clang/include/llvm/MCA/HardwareUnits/ResourceManager.h
index 2f91185..b6d4e34 100644
--- a/linux-x64/clang/include/llvm/MCA/HardwareUnits/ResourceManager.h
+++ b/linux-x64/clang/include/llvm/MCA/HardwareUnits/ResourceManager.h
@@ -15,7 +15,6 @@
 #ifndef LLVM_MCA_RESOURCE_MANAGER_H
 #define LLVM_MCA_RESOURCE_MANAGER_H
 
-#include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/MC/MCSchedule.h"
@@ -33,8 +32,7 @@
 /// with a buffer size of -1 is always available if it is not reserved.
 ///
 /// Values of type ResourceStateEvent are returned by method
-/// ResourceState::isBufferAvailable(), which is used to query the internal
-/// state of a resource.
+/// ResourceManager::canBeDispatched()
 ///
 /// The naming convention for resource state events is:
 ///  * Event names start with prefix RS_
@@ -263,16 +261,26 @@
   /// Returns RS_BUFFER_UNAVAILABLE if there are no available slots.
   ResourceStateEvent isBufferAvailable() const;
 
-  /// Reserve a slot in the buffer.
-  void reserveBuffer() {
-    if (AvailableSlots)
-      AvailableSlots--;
+  /// Reserve a buffer slot.
+  ///
+  /// Returns true if the buffer is not full.
+  /// It always returns true if BufferSize is set to zero.
+  bool reserveBuffer() {
+    if (BufferSize <= 0)
+      return true;
+
+    --AvailableSlots;
+    assert(AvailableSlots <= static_cast<unsigned>(BufferSize));
+    return AvailableSlots;
   }
 
-  /// Release a slot in the buffer.
+  /// Releases a slot in the buffer.
   void releaseBuffer() {
-    if (BufferSize > 0)
-      AvailableSlots++;
+    // Ignore dispatch hazards or invalid buffer sizes.
+    if (BufferSize <= 0)
+      return;
+
+    ++AvailableSlots;
     assert(AvailableSlots <= static_cast<unsigned>(BufferSize));
   }
 
@@ -351,9 +359,16 @@
   // Set of processor resource units that are available during this cycle.
   uint64_t AvailableProcResUnits;
 
-  // Set of processor resource groups that are currently reserved.
+  // Set of processor resources that are currently reserved.
   uint64_t ReservedResourceGroups;
 
+  // Set of unavailable scheduler buffer resources. This is used internally to
+  // speedup `canBeDispatched()` queries.
+  uint64_t AvailableBuffers;
+
+  // Set of dispatch hazard buffer resources that are currently unavailable.
+  uint64_t ReservedBuffers;
+
   // Returns the actual resource unit that will be used.
   ResourceRef selectPipe(uint64_t ResourceID);
 
@@ -382,17 +397,20 @@
 
   // Returns RS_BUFFER_AVAILABLE if buffered resources are not reserved, and if
   // there are enough available slots in the buffers.
-  ResourceStateEvent canBeDispatched(ArrayRef<uint64_t> Buffers) const;
+  ResourceStateEvent canBeDispatched(uint64_t ConsumedBuffers) const;
 
   // Return the processor resource identifier associated to this Mask.
   unsigned resolveResourceMask(uint64_t Mask) const;
 
-  // Consume a slot in every buffered resource from array 'Buffers'. Resource
-  // units that are dispatch hazards (i.e. BufferSize=0) are marked as reserved.
-  void reserveBuffers(ArrayRef<uint64_t> Buffers);
+  // Acquires a slot from every buffered resource in mask `ConsumedBuffers`.
+  // Units that are dispatch hazards (i.e. BufferSize=0) are marked as reserved.
+  void reserveBuffers(uint64_t ConsumedBuffers);
 
-  // Release buffer entries previously allocated by method reserveBuffers.
-  void releaseBuffers(ArrayRef<uint64_t> Buffers);
+  // Releases a slot from every buffered resource in mask `ConsumedBuffers`.
+  // ConsumedBuffers is a bitmask of previously acquired buffers (using method
+  // `reserveBuffers`). Units that are dispatch hazards (i.e. BufferSize=0) are
+  // not automatically unreserved by this method.
+  void releaseBuffers(uint64_t ConsumedBuffers);
 
   // Reserve a processor resource. A reserved resource is not available for
   // instruction issue until it is released.
diff --git a/linux-x64/clang/include/llvm/MCA/HardwareUnits/RetireControlUnit.h b/linux-x64/clang/include/llvm/MCA/HardwareUnits/RetireControlUnit.h
index 0629014..acbd454 100644
--- a/linux-x64/clang/include/llvm/MCA/HardwareUnits/RetireControlUnit.h
+++ b/linux-x64/clang/include/llvm/MCA/HardwareUnits/RetireControlUnit.h
@@ -57,34 +57,43 @@
 private:
   unsigned NextAvailableSlotIdx;
   unsigned CurrentInstructionSlotIdx;
-  unsigned AvailableSlots;
+  unsigned NumROBEntries;
+  unsigned AvailableEntries;
   unsigned MaxRetirePerCycle; // 0 means no limit.
   std::vector<RUToken> Queue;
 
-public:
-  RetireControlUnit(const MCSchedModel &SM);
-
-  bool isEmpty() const { return AvailableSlots == Queue.size(); }
-  bool isAvailable(unsigned Quantity = 1) const {
+  unsigned normalizeQuantity(unsigned Quantity) const {
     // Some instructions may declare a number of uOps which exceeds the size
     // of the reorder buffer. To avoid problems, cap the amount of slots to
     // the size of the reorder buffer.
-    Quantity = std::min(Quantity, static_cast<unsigned>(Queue.size()));
+    Quantity = std::min(Quantity, NumROBEntries);
 
     // Further normalize the number of micro opcodes for instructions that
     // declare zero opcodes. This should match the behavior of method
     // reserveSlot().
-    Quantity = std::max(Quantity, 1U);
-    return AvailableSlots >= Quantity;
+    return std::max(Quantity, 1U);
+  }
+
+  unsigned computeNextSlotIdx() const;
+
+public:
+  RetireControlUnit(const MCSchedModel &SM);
+
+  bool isEmpty() const { return AvailableEntries == NumROBEntries; }
+
+  bool isAvailable(unsigned Quantity = 1) const {
+    return AvailableEntries >= normalizeQuantity(Quantity);
   }
 
   unsigned getMaxRetirePerCycle() const { return MaxRetirePerCycle; }
 
-  // Reserves a number of slots, and returns a new token.
-  unsigned reserveSlot(const InstRef &IS, unsigned NumMicroOps);
+  // Reserves a number of slots, and returns a new token reference.
+  unsigned dispatch(const InstRef &IS);
 
   // Return the current token from the RCU's circular token queue.
-  const RUToken &peekCurrentToken() const;
+  const RUToken &getCurrentToken() const;
+
+  const RUToken &peekNextToken() const;
 
   // Advance the pointer to the next token in the circular token queue.
   void consumeCurrentToken();
diff --git a/linux-x64/clang/include/llvm/MCA/HardwareUnits/Scheduler.h b/linux-x64/clang/include/llvm/MCA/HardwareUnits/Scheduler.h
index 27beb84..0293364 100644
--- a/linux-x64/clang/include/llvm/MCA/HardwareUnits/Scheduler.h
+++ b/linux-x64/clang/include/llvm/MCA/HardwareUnits/Scheduler.h
@@ -68,7 +68,7 @@
 /// instructions from the dispatch stage, until the write-back stage.
 ///
 class Scheduler : public HardwareUnit {
-  LSUnit &LSU;
+  LSUnitBase &LSU;
 
   // Instruction selection strategy for this Scheduler.
   std::unique_ptr<SchedulerStrategy> Strategy;
@@ -154,15 +154,15 @@
   bool promoteToPendingSet(SmallVectorImpl<InstRef> &Pending);
 
 public:
-  Scheduler(const MCSchedModel &Model, LSUnit &Lsu)
+  Scheduler(const MCSchedModel &Model, LSUnitBase &Lsu)
       : Scheduler(Model, Lsu, nullptr) {}
 
-  Scheduler(const MCSchedModel &Model, LSUnit &Lsu,
+  Scheduler(const MCSchedModel &Model, LSUnitBase &Lsu,
             std::unique_ptr<SchedulerStrategy> SelectStrategy)
-      : Scheduler(make_unique<ResourceManager>(Model), Lsu,
+      : Scheduler(std::make_unique<ResourceManager>(Model), Lsu,
                   std::move(SelectStrategy)) {}
 
-  Scheduler(std::unique_ptr<ResourceManager> RM, LSUnit &Lsu,
+  Scheduler(std::unique_ptr<ResourceManager> RM, LSUnitBase &Lsu,
             std::unique_ptr<SchedulerStrategy> SelectStrategy)
       : LSU(Lsu), Resources(std::move(RM)), BusyResourceUnits(0),
         NumDispatchedToThePendingSet(0), HadTokenStall(false) {
@@ -228,6 +228,9 @@
                   SmallVectorImpl<InstRef> &Ready);
 
   /// Convert a resource mask into a valid llvm processor resource identifier.
+  ///
+  /// Only the most significant bit of the Mask is used by this method to
+  /// identify the processor resource.
   unsigned getResourceID(uint64_t Mask) const {
     return Resources->resolveResourceMask(Mask);
   }
@@ -264,9 +267,9 @@
   // This routine performs a sanity check.  This routine should only be called
   // when we know that 'IR' is not in the scheduler's instruction queues.
   void sanityCheck(const InstRef &IR) const {
-    assert(find(WaitSet, IR) == WaitSet.end() && "Already in the wait set!");
-    assert(find(ReadySet, IR) == ReadySet.end() && "Already in the ready set!");
-    assert(find(IssuedSet, IR) == IssuedSet.end() && "Already executing!");
+    assert(!is_contained(WaitSet, IR) && "Already in the wait set!");
+    assert(!is_contained(ReadySet, IR) && "Already in the ready set!");
+    assert(!is_contained(IssuedSet, IR) && "Already executing!");
   }
 #endif // !NDEBUG
 };
diff --git a/linux-x64/clang/include/llvm/MCA/Instruction.h b/linux-x64/clang/include/llvm/MCA/Instruction.h
index d4d3f22..c97cb46 100644
--- a/linux-x64/clang/include/llvm/MCA/Instruction.h
+++ b/linux-x64/clang/include/llvm/MCA/Instruction.h
@@ -18,6 +18,7 @@
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallVector.h"
+#include "llvm/MC/MCRegister.h" // definition of MCPhysReg.
 #include "llvm/Support/MathExtras.h"
 
 #ifndef NDEBUG
@@ -42,7 +43,7 @@
   unsigned Latency;
   // This field is set to a value different than zero only if this
   // is an implicit definition.
-  unsigned RegisterID;
+  MCPhysReg RegisterID;
   // Instruction itineraries would set this field to the SchedClass ID.
   // Otherwise, it defaults to the WriteResourceID from the MCWriteLatencyEntry
   // element associated to this write.
@@ -70,7 +71,7 @@
   // uses always come first in the sequence of uses.
   unsigned UseIndex;
   // This field is only set if this is an implicit read.
-  unsigned RegisterID;
+  MCPhysReg RegisterID;
   // Scheduling Class Index. It is used to query the scheduling model for the
   // MCSchedClassDesc object.
   unsigned SchedClassID;
@@ -85,7 +86,7 @@
 /// Field RegID is set to the invalid register for memory dependencies.
 struct CriticalDependency {
   unsigned IID;
-  unsigned RegID;
+  MCPhysReg RegID;
   unsigned Cycles;
 };
 
@@ -106,7 +107,7 @@
   // to speedup queries on the register file.
   // For implicit writes, this field always matches the value of
   // field RegisterID from WD.
-  unsigned RegisterID;
+  MCPhysReg RegisterID;
 
   // Physical register file that serves register RegisterID.
   unsigned PRFID;
@@ -146,7 +147,7 @@
   SmallVector<std::pair<ReadState *, int>, 4> Users;
 
 public:
-  WriteState(const WriteDescriptor &Desc, unsigned RegID,
+  WriteState(const WriteDescriptor &Desc, MCPhysReg RegID,
              bool clearsSuperRegs = false, bool writesZero = false)
       : WD(&Desc), CyclesLeft(UNKNOWN_CYCLES), RegisterID(RegID), PRFID(0),
         ClearsSuperRegs(clearsSuperRegs), WritesZero(writesZero),
@@ -158,7 +159,7 @@
 
   int getCyclesLeft() const { return CyclesLeft; }
   unsigned getWriteResourceID() const { return WD->SClassOrWriteResourceID; }
-  unsigned getRegisterID() const { return RegisterID; }
+  MCPhysReg getRegisterID() const { return RegisterID; }
   unsigned getRegisterFileID() const { return PRFID; }
   unsigned getLatency() const { return WD->Latency; }
   unsigned getDependentWriteCyclesLeft() const {
@@ -200,7 +201,7 @@
   }
 
   void setDependentWrite(const WriteState *Other) { DependentWrite = Other; }
-  void writeStartEvent(unsigned IID, unsigned RegID, unsigned Cycles);
+  void writeStartEvent(unsigned IID, MCPhysReg RegID, unsigned Cycles);
   void setWriteZero() { WritesZero = true; }
   void setEliminated() {
     assert(Users.empty() && "Write is in an inconsistent state.");
@@ -226,7 +227,7 @@
 class ReadState {
   const ReadDescriptor *RD;
   // Physical register identified associated to this read.
-  unsigned RegisterID;
+  MCPhysReg RegisterID;
   // Physical register file that serves register RegisterID.
   unsigned PRFID;
   // Number of writes that contribute to the definition of RegisterID.
@@ -253,14 +254,14 @@
   bool IndependentFromDef;
 
 public:
-  ReadState(const ReadDescriptor &Desc, unsigned RegID)
+  ReadState(const ReadDescriptor &Desc, MCPhysReg RegID)
       : RD(&Desc), RegisterID(RegID), PRFID(0), DependentWrites(0),
         CyclesLeft(UNKNOWN_CYCLES), TotalCycles(0), CRD(), IsReady(true),
         IsZero(false), IndependentFromDef(false) {}
 
   const ReadDescriptor &getDescriptor() const { return *RD; }
   unsigned getSchedClass() const { return RD->SchedClassID; }
-  unsigned getRegisterID() const { return RegisterID; }
+  MCPhysReg getRegisterID() const { return RegisterID; }
   unsigned getRegisterFileID() const { return PRFID; }
   const CriticalDependency &getCriticalRegDep() const { return CRD; }
 
@@ -272,7 +273,7 @@
   void setIndependentFromDef() { IndependentFromDef = true; }
 
   void cycleEvent();
-  void writeStartEvent(unsigned IID, unsigned RegID, unsigned Cycles);
+  void writeStartEvent(unsigned IID, MCPhysReg RegID, unsigned Cycles);
   void setDependentWrites(unsigned Writes) {
     DependentWrites = Writes;
     IsReady = !Writes;
@@ -352,11 +353,14 @@
   // reports the number of "consumed cycles".
   SmallVector<std::pair<uint64_t, ResourceUsage>, 4> Resources;
 
-  // A list of buffered resources consumed by this instruction.
-  SmallVector<uint64_t, 4> Buffers;
+  // A bitmask of used hardware buffers.
+  uint64_t UsedBuffers;
 
-  unsigned UsedProcResUnits;
-  unsigned UsedProcResGroups;
+  // A bitmask of used processor resource units.
+  uint64_t UsedProcResUnits;
+
+  // A bitmask of used processor resource groups.
+  uint64_t UsedProcResGroups;
 
   unsigned MaxLatency;
   // Number of MicroOps for this instruction.
@@ -414,6 +418,7 @@
   const InstrDesc &getDesc() const { return Desc; }
 
   unsigned getLatency() const { return Desc.MaxLatency; }
+  unsigned getNumMicroOps() const { return Desc.NumMicroOps; }
 
   bool hasDependentUsers() const {
     return any_of(Defs,
@@ -463,6 +468,12 @@
   // operation.
   unsigned LSUTokenID;
 
+  // A resource mask which identifies buffered resources consumed by this
+  // instruction at dispatch stage. In the absence of macro-fusion, this value
+  // should always match the value of field `UsedBuffers` from the instruction
+  // descriptor (see field InstrBase::Desc).
+  uint64_t UsedBuffers;
+
   // Critical register dependency.
   CriticalDependency CriticalRegDep;
 
@@ -480,12 +491,18 @@
 public:
   Instruction(const InstrDesc &D)
       : InstructionBase(D), Stage(IS_INVALID), CyclesLeft(UNKNOWN_CYCLES),
-        RCUTokenID(0), LSUTokenID(0), CriticalRegDep(), CriticalMemDep(),
-        CriticalResourceMask(0), IsEliminated(false) {}
+        RCUTokenID(0), LSUTokenID(0), UsedBuffers(D.UsedBuffers),
+        CriticalRegDep(), CriticalMemDep(), CriticalResourceMask(0),
+        IsEliminated(false) {}
 
   unsigned getRCUTokenID() const { return RCUTokenID; }
   unsigned getLSUTokenID() const { return LSUTokenID; }
   void setLSUTokenID(unsigned LSUTok) { LSUTokenID = LSUTok; }
+
+  uint64_t getUsedBuffers() const { return UsedBuffers; }
+  void setUsedBuffers(uint64_t Mask) { UsedBuffers = Mask; }
+  void clearUsedBuffers() { UsedBuffers = 0ULL; }
+
   int getCyclesLeft() const { return CyclesLeft; }
 
   // Transition to the dispatch stage, and assign a RCUToken to this
diff --git a/linux-x64/clang/include/llvm/MCA/Pipeline.h b/linux-x64/clang/include/llvm/MCA/Pipeline.h
index 935033f..0ac988c 100644
--- a/linux-x64/clang/include/llvm/MCA/Pipeline.h
+++ b/linux-x64/clang/include/llvm/MCA/Pipeline.h
@@ -15,8 +15,6 @@
 #ifndef LLVM_MCA_PIPELINE_H
 #define LLVM_MCA_PIPELINE_H
 
-#include "llvm/ADT/SmallVector.h"
-#include "llvm/MCA/HardwareUnits/Scheduler.h"
 #include "llvm/MCA/Stages/Stage.h"
 #include "llvm/Support/Error.h"
 
diff --git a/linux-x64/clang/include/llvm/MCA/SourceMgr.h b/linux-x64/clang/include/llvm/MCA/SourceMgr.h
index dbe31db..e844171 100644
--- a/linux-x64/clang/include/llvm/MCA/SourceMgr.h
+++ b/linux-x64/clang/include/llvm/MCA/SourceMgr.h
@@ -16,12 +16,13 @@
 #define LLVM_MCA_SOURCEMGR_H
 
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/MCA/Instruction.h"
 
 namespace llvm {
 namespace mca {
 
-class Instruction;
-
+// MSVC >= 19.15, < 19.20 need to see the definition of class Instruction to
+// prevent compiler error C2139 about intrinsic type trait '__is_assignable'.
 typedef std::pair<unsigned, const Instruction &> SourceRef;
 
 class SourceMgr {
diff --git a/linux-x64/clang/include/llvm/MCA/Stages/DispatchStage.h b/linux-x64/clang/include/llvm/MCA/Stages/DispatchStage.h
index d80eded..597f731 100644
--- a/linux-x64/clang/include/llvm/MCA/Stages/DispatchStage.h
+++ b/linux-x64/clang/include/llvm/MCA/Stages/DispatchStage.h
@@ -20,7 +20,6 @@
 
 #include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/MCSubtargetInfo.h"
-#include "llvm/MCA/HWEventListener.h"
 #include "llvm/MCA/HardwareUnits/RegisterFile.h"
 #include "llvm/MCA/HardwareUnits/RetireControlUnit.h"
 #include "llvm/MCA/Instruction.h"
diff --git a/linux-x64/clang/include/llvm/MCA/Stages/RetireStage.h b/linux-x64/clang/include/llvm/MCA/Stages/RetireStage.h
index 08c216a..f471368 100644
--- a/linux-x64/clang/include/llvm/MCA/Stages/RetireStage.h
+++ b/linux-x64/clang/include/llvm/MCA/Stages/RetireStage.h
@@ -16,6 +16,7 @@
 #ifndef LLVM_MCA_RETIRE_STAGE_H
 #define LLVM_MCA_RETIRE_STAGE_H
 
+#include "llvm/MCA/HardwareUnits/LSUnit.h"
 #include "llvm/MCA/HardwareUnits/RegisterFile.h"
 #include "llvm/MCA/HardwareUnits/RetireControlUnit.h"
 #include "llvm/MCA/Stages/Stage.h"
@@ -27,13 +28,14 @@
   // Owner will go away when we move listeners/eventing to the stages.
   RetireControlUnit &RCU;
   RegisterFile &PRF;
+  LSUnitBase &LSU;
 
   RetireStage(const RetireStage &Other) = delete;
   RetireStage &operator=(const RetireStage &Other) = delete;
 
 public:
-  RetireStage(RetireControlUnit &R, RegisterFile &F)
-      : Stage(), RCU(R), PRF(F) {}
+  RetireStage(RetireControlUnit &R, RegisterFile &F, LSUnitBase &LS)
+      : Stage(), RCU(R), PRF(F), LSU(LS) {}
 
   bool hasWorkToComplete() const override { return !RCU.isEmpty(); }
   Error cycleStart() override;
diff --git a/linux-x64/clang/include/llvm/Object/Archive.h b/linux-x64/clang/include/llvm/Object/Archive.h
index c40278a..c3f36bd 100644
--- a/linux-x64/clang/include/llvm/Object/Archive.h
+++ b/linux-x64/clang/include/llvm/Object/Archive.h
@@ -48,8 +48,7 @@
   /// Get the name looking up long names.
   Expected<StringRef> getName(uint64_t Size) const;
 
-  /// Members are not larger than 4GB.
-  Expected<uint32_t> getSize() const;
+  Expected<uint64_t> getSize() const;
 
   Expected<sys::fs::perms> getAccessMode() const;
   Expected<sys::TimePoint<std::chrono::seconds>> getLastModified() const;
@@ -136,6 +135,7 @@
 
     Expected<StringRef> getBuffer() const;
     uint64_t getChildOffset() const;
+    uint64_t getDataOffset() const { return getChildOffset() + StartOfFile; }
 
     Expected<MemoryBufferRef> getMemoryBufferRef() const;
 
@@ -221,6 +221,9 @@
   Archive(MemoryBufferRef Source, Error &Err);
   static Expected<std::unique_ptr<Archive>> create(MemoryBufferRef Source);
 
+  /// Size field is 10 decimal digits long
+  static const uint64_t MaxMemberSize = 9999999999;
+
   enum Kind {
     K_GNU,
     K_GNU64,
diff --git a/linux-x64/clang/include/llvm/Object/ArchiveWriter.h b/linux-x64/clang/include/llvm/Object/ArchiveWriter.h
index 9e6daf2..7eaf13e 100644
--- a/linux-x64/clang/include/llvm/Object/ArchiveWriter.h
+++ b/linux-x64/clang/include/llvm/Object/ArchiveWriter.h
@@ -13,10 +13,7 @@
 #ifndef LLVM_OBJECT_ARCHIVEWRITER_H
 #define LLVM_OBJECT_ARCHIVEWRITER_H
 
-#include "llvm/ADT/StringRef.h"
 #include "llvm/Object/Archive.h"
-#include "llvm/Support/Error.h"
-#include "llvm/Support/FileSystem.h"
 
 namespace llvm {
 
@@ -42,6 +39,12 @@
                    bool WriteSymtab, object::Archive::Kind Kind,
                    bool Deterministic, bool Thin,
                    std::unique_ptr<MemoryBuffer> OldArchiveBuf = nullptr);
+
+// writeArchiveToBuffer is similar to writeArchive but returns the Archive in a
+// buffer instead of writing it out to a file.
+Expected<std::unique_ptr<MemoryBuffer>>
+writeArchiveToBuffer(ArrayRef<NewArchiveMember> NewMembers, bool WriteSymtab,
+                     object::Archive::Kind Kind, bool Deterministic, bool Thin);
 }
 
 #endif
diff --git a/linux-x64/clang/include/llvm/Object/Binary.h b/linux-x64/clang/include/llvm/Object/Binary.h
index 3c3e977..dd98e11 100644
--- a/linux-x64/clang/include/llvm/Object/Binary.h
+++ b/linux-x64/clang/include/llvm/Object/Binary.h
@@ -42,7 +42,9 @@
     ID_Archive,
     ID_MachOUniversalBinary,
     ID_COFFImportFile,
-    ID_IR, // LLVM IR
+    ID_IR,            // LLVM IR
+    ID_TapiUniversal, // Text-based Dynamic Library Stub file.
+    ID_TapiFile,      // Text-based Dynamic Library Stub file.
 
     ID_Minidump,
 
@@ -89,6 +91,8 @@
   Binary(const Binary &other) = delete;
   virtual ~Binary();
 
+  virtual Error initContent() { return Error::success(); };
+
   StringRef getData() const;
   StringRef getFileName() const;
   MemoryBufferRef getMemoryBufferRef() const;
@@ -101,16 +105,18 @@
     return TypeID > ID_StartObjects && TypeID < ID_EndObjects;
   }
 
-  bool isSymbolic() const { return isIR() || isObject() || isCOFFImportFile(); }
-
-  bool isArchive() const {
-    return TypeID == ID_Archive;
+  bool isSymbolic() const {
+    return isIR() || isObject() || isCOFFImportFile() || isTapiFile();
   }
 
+  bool isArchive() const { return TypeID == ID_Archive; }
+
   bool isMachOUniversalBinary() const {
     return TypeID == ID_MachOUniversalBinary;
   }
 
+  bool isTapiUniversal() const { return TypeID == ID_TapiUniversal; }
+
   bool isELF() const {
     return TypeID >= ID_ELF32L && TypeID <= ID_ELF64B;
   }
@@ -137,6 +143,8 @@
 
   bool isMinidump() const { return TypeID == ID_Minidump; }
 
+  bool isTapiFile() const { return TypeID == ID_TapiFile; }
+
   bool isLittleEndian() const {
     return !(TypeID == ID_ELF32B || TypeID == ID_ELF64B ||
              TypeID == ID_MachO32B || TypeID == ID_MachO64B);
@@ -154,14 +162,14 @@
     return Triple::UnknownObjectFormat;
   }
 
-  static std::error_code checkOffset(MemoryBufferRef M, uintptr_t Addr,
-                                     const uint64_t Size) {
+  static Error checkOffset(MemoryBufferRef M, uintptr_t Addr,
+                           const uint64_t Size) {
     if (Addr + Size < Addr || Addr + Size < Size ||
-        Addr + Size > uintptr_t(M.getBufferEnd()) ||
-        Addr < uintptr_t(M.getBufferStart())) {
-      return object_error::unexpected_eof;
+        Addr + Size > reinterpret_cast<uintptr_t>(M.getBufferEnd()) ||
+        Addr < reinterpret_cast<uintptr_t>(M.getBufferStart())) {
+      return errorCodeToError(object_error::unexpected_eof);
     }
-    return std::error_code();
+    return Error::success();
   }
 };
 
@@ -172,7 +180,8 @@
 ///
 /// @param Source The data to create the Binary from.
 Expected<std::unique_ptr<Binary>> createBinary(MemoryBufferRef Source,
-                                               LLVMContext *Context = nullptr);
+                                               LLVMContext *Context = nullptr,
+                                               bool InitContent = true);
 
 template <typename T> class OwningBinary {
   std::unique_ptr<T> Bin;
@@ -222,7 +231,9 @@
   return Bin.get();
 }
 
-Expected<OwningBinary<Binary>> createBinary(StringRef Path);
+Expected<OwningBinary<Binary>> createBinary(StringRef Path,
+                                            LLVMContext *Context = nullptr,
+                                            bool InitContent = true);
 
 } // end namespace object
 
diff --git a/linux-x64/clang/include/llvm/Object/COFF.h b/linux-x64/clang/include/llvm/Object/COFF.h
index c53cbc4..e7cf1b5 100644
--- a/linux-x64/clang/include/llvm/Object/COFF.h
+++ b/linux-x64/clang/include/llvm/Object/COFF.h
@@ -314,7 +314,10 @@
     return CS16 ? CS16->Name.Offset : CS32->Name.Offset;
   }
 
-  uint32_t getValue() const { return CS16 ? CS16->Value : CS32->Value; }
+  uint32_t getValue() const {
+    assert(isSet() && "COFFSymbolRef points to nothing!");
+    return CS16 ? CS16->Value : CS32->Value;
+  }
 
   int32_t getSectionNumber() const {
     assert(isSet() && "COFFSymbolRef points to nothing!");
@@ -573,11 +576,22 @@
 
   uint32_t getAlignment() const {
     // Bit [20:24] contains section alignment.
-    uint32_t Shift = (Characteristics & 0x00F00000) >> 20;
+    uint32_t Shift = (Characteristics & COFF::IMAGE_SCN_ALIGN_MASK) >> 20;
     if (Shift > 0)
       return 1U << (Shift - 1);
     return 0;
   }
+
+  void setAlignment(uint32_t Align) {
+    uint32_t AlignBits = 0;
+    if (Align) {
+      assert(llvm::isPowerOf2_32(Align) && "alignment is not a power of 2");
+      assert(llvm::Log2_32(Align) <= 13 && "alignment requested is too large");
+      AlignBits = (llvm::Log2_32(Align) + 1) << 20;
+    }
+    Characteristics =
+        (Characteristics & ~COFF::IMAGE_SCN_ALIGN_MASK) | AlignBits;
+  }
 };
 
 using coff_tls_directory32 = coff_tls_directory<support::little32_t>;
@@ -761,6 +775,8 @@
 
 class COFFObjectFile : public ObjectFile {
 private:
+  COFFObjectFile(MemoryBufferRef Object);
+
   friend class ImportDirectoryEntryRef;
   friend class ExportDirectoryEntryRef;
   const coff_file_header *COFFHeader;
@@ -781,25 +797,34 @@
   const coff_base_reloc_block_header *BaseRelocEnd;
   const debug_directory *DebugDirectoryBegin;
   const debug_directory *DebugDirectoryEnd;
+  const coff_tls_directory32 *TLSDirectory32;
+  const coff_tls_directory64 *TLSDirectory64;
   // Either coff_load_configuration32 or coff_load_configuration64.
   const void *LoadConfig = nullptr;
 
-  std::error_code getString(uint32_t offset, StringRef &Res) const;
+  Expected<StringRef> getString(uint32_t offset) const;
 
   template <typename coff_symbol_type>
   const coff_symbol_type *toSymb(DataRefImpl Symb) const;
   const coff_section *toSec(DataRefImpl Sec) const;
   const coff_relocation *toRel(DataRefImpl Rel) const;
 
-  std::error_code initSymbolTablePtr();
-  std::error_code initImportTablePtr();
-  std::error_code initDelayImportTablePtr();
-  std::error_code initExportTablePtr();
-  std::error_code initBaseRelocPtr();
-  std::error_code initDebugDirectoryPtr();
-  std::error_code initLoadConfigPtr();
+  // Finish initializing the object and return success or an error.
+  Error initialize();
+
+  Error initSymbolTablePtr();
+  Error initImportTablePtr();
+  Error initDelayImportTablePtr();
+  Error initExportTablePtr();
+  Error initBaseRelocPtr();
+  Error initDebugDirectoryPtr();
+  Error initTLSDirectoryPtr();
+  Error initLoadConfigPtr();
 
 public:
+  static Expected<std::unique_ptr<COFFObjectFile>>
+  create(MemoryBufferRef Object);
+
   uintptr_t getSymbolTable() const {
     if (SymbolTable16)
       return reinterpret_cast<uintptr_t>(SymbolTable16);
@@ -875,6 +900,8 @@
     return getRawNumberOfSymbols();
   }
 
+  uint32_t getStringTableSize() const { return StringTableSize; }
+
   const coff_load_configuration32 *getLoadConfig32() const {
     assert(!is64());
     return reinterpret_cast<const coff_load_configuration32 *>(LoadConfig);
@@ -893,7 +920,7 @@
   uint32_t getSymbolAlignment(DataRefImpl Symb) const override;
   uint64_t getSymbolValueImpl(DataRefImpl Symb) const override;
   uint64_t getCommonSymbolSizeImpl(DataRefImpl Symb) const override;
-  uint32_t getSymbolFlags(DataRefImpl Symb) const override;
+  Expected<uint32_t> getSymbolFlags(DataRefImpl Symb) const override;
   Expected<SymbolRef::Type> getSymbolType(DataRefImpl Symb) const override;
   Expected<section_iterator> getSymbolSection(DataRefImpl Symb) const override;
   void moveSectionNext(DataRefImpl &Sec) const override;
@@ -909,6 +936,7 @@
   bool isSectionData(DataRefImpl Sec) const override;
   bool isSectionBSS(DataRefImpl Sec) const override;
   bool isSectionVirtual(DataRefImpl Sec) const override;
+  bool isDebugSection(StringRef SectionName) const override;
   relocation_iterator section_rel_begin(DataRefImpl Sec) const override;
   relocation_iterator section_rel_end(DataRefImpl Sec) const override;
 
@@ -920,8 +948,6 @@
                              SmallVectorImpl<char> &Result) const override;
 
 public:
-  COFFObjectFile(MemoryBufferRef Object, std::error_code &EC);
-
   basic_symbol_iterator symbol_begin() const override;
   basic_symbol_iterator symbol_end() const override;
   section_iterator section_begin() const override;
@@ -964,59 +990,50 @@
     return make_range(debug_directory_begin(), debug_directory_end());
   }
 
+  const coff_tls_directory32 *getTLSDirectory32() const {
+    return TLSDirectory32;
+  }
+  const coff_tls_directory64 *getTLSDirectory64() const {
+    return TLSDirectory64;
+  }
+
   const dos_header *getDOSHeader() const {
     if (!PE32Header && !PE32PlusHeader)
       return nullptr;
     return reinterpret_cast<const dos_header *>(base());
   }
-  std::error_code getCOFFHeader(const coff_file_header *&Res) const;
-  std::error_code
-  getCOFFBigObjHeader(const coff_bigobj_file_header *&Res) const;
-  std::error_code getPE32Header(const pe32_header *&Res) const;
-  std::error_code getPE32PlusHeader(const pe32plus_header *&Res) const;
-  std::error_code getDataDirectory(uint32_t index,
-                                   const data_directory *&Res) const;
-  std::error_code getSection(int32_t index, const coff_section *&Res) const;
-  std::error_code getSection(StringRef SectionName,
-                             const coff_section *&Res) const;
 
-  template <typename coff_symbol_type>
-  std::error_code getSymbol(uint32_t Index,
-                            const coff_symbol_type *&Res) const {
-    if (Index >= getNumberOfSymbols())
-      return object_error::parse_failed;
-
-    Res = reinterpret_cast<coff_symbol_type *>(getSymbolTable()) + Index;
-    return std::error_code();
+  const coff_file_header *getCOFFHeader() const { return COFFHeader; }
+  const coff_bigobj_file_header *getCOFFBigObjHeader() const {
+    return COFFBigObjHeader;
   }
+  const pe32_header *getPE32Header() const { return PE32Header; }
+  const pe32plus_header *getPE32PlusHeader() const { return PE32PlusHeader; }
+
+  const data_directory *getDataDirectory(uint32_t index) const;
+  Expected<const coff_section *> getSection(int32_t index) const;
+
   Expected<COFFSymbolRef> getSymbol(uint32_t index) const {
-    if (SymbolTable16) {
-      const coff_symbol16 *Symb = nullptr;
-      if (std::error_code EC = getSymbol(index, Symb))
-        return errorCodeToError(EC);
-      return COFFSymbolRef(Symb);
-    }
-    if (SymbolTable32) {
-      const coff_symbol32 *Symb = nullptr;
-      if (std::error_code EC = getSymbol(index, Symb))
-        return errorCodeToError(EC);
-      return COFFSymbolRef(Symb);
-    }
+    if (index >= getNumberOfSymbols())
+      return errorCodeToError(object_error::parse_failed);
+    if (SymbolTable16)
+      return COFFSymbolRef(SymbolTable16 + index);
+    if (SymbolTable32)
+      return COFFSymbolRef(SymbolTable32 + index);
     return errorCodeToError(object_error::parse_failed);
   }
 
   template <typename T>
-  std::error_code getAuxSymbol(uint32_t index, const T *&Res) const {
+  Error getAuxSymbol(uint32_t index, const T *&Res) const {
     Expected<COFFSymbolRef> S = getSymbol(index);
     if (Error E = S.takeError())
-      return errorToErrorCode(std::move(E));
+      return E;
     Res = reinterpret_cast<const T *>(S->getRawPtr());
-    return std::error_code();
+    return Error::success();
   }
 
-  std::error_code getSymbolName(COFFSymbolRef Symbol, StringRef &Res) const;
-  std::error_code getSymbolName(const coff_symbol_generic *Symbol,
-                                StringRef &Res) const;
+  Expected<StringRef> getSymbolName(COFFSymbolRef Symbol) const;
+  Expected<StringRef> getSymbolName(const coff_symbol_generic *Symbol) const;
 
   ArrayRef<uint8_t> getSymbolAuxData(COFFSymbolRef Symbol) const;
 
@@ -1038,29 +1055,29 @@
                            ArrayRef<uint8_t> &Res) const;
 
   uint64_t getImageBase() const;
-  std::error_code getVaPtr(uint64_t VA, uintptr_t &Res) const;
-  std::error_code getRvaPtr(uint32_t Rva, uintptr_t &Res) const;
+  Error getVaPtr(uint64_t VA, uintptr_t &Res) const;
+  Error getRvaPtr(uint32_t Rva, uintptr_t &Res) const;
 
   /// Given an RVA base and size, returns a valid array of bytes or an error
   /// code if the RVA and size is not contained completely within a valid
   /// section.
-  std::error_code getRvaAndSizeAsBytes(uint32_t RVA, uint32_t Size,
-                                       ArrayRef<uint8_t> &Contents) const;
+  Error getRvaAndSizeAsBytes(uint32_t RVA, uint32_t Size,
+                             ArrayRef<uint8_t> &Contents) const;
 
-  std::error_code getHintName(uint32_t Rva, uint16_t &Hint,
+  Error getHintName(uint32_t Rva, uint16_t &Hint,
                               StringRef &Name) const;
 
   /// Get PDB information out of a codeview debug directory entry.
-  std::error_code getDebugPDBInfo(const debug_directory *DebugDir,
-                                  const codeview::DebugInfo *&Info,
-                                  StringRef &PDBFileName) const;
+  Error getDebugPDBInfo(const debug_directory *DebugDir,
+                        const codeview::DebugInfo *&Info,
+                        StringRef &PDBFileName) const;
 
   /// Get PDB information from an executable. If the information is not present,
   /// Info will be set to nullptr and PDBFileName will be empty. An error is
   /// returned only on corrupt object files. Convenience accessor that can be
   /// used if the debug directory is not already handy.
-  std::error_code getDebugPDBInfo(const codeview::DebugInfo *&Info,
-                                  StringRef &PDBFileName) const;
+  Error getDebugPDBInfo(const codeview::DebugInfo *&Info,
+                        StringRef &PDBFileName) const;
 
   bool isRelocatableObject() const override;
   bool is64() const { return PE32PlusHeader; }
@@ -1089,11 +1106,11 @@
   imported_symbol_iterator lookup_table_end() const;
   iterator_range<imported_symbol_iterator> lookup_table_symbols() const;
 
-  std::error_code getName(StringRef &Result) const;
-  std::error_code getImportLookupTableRVA(uint32_t &Result) const;
-  std::error_code getImportAddressTableRVA(uint32_t &Result) const;
+  Error getName(StringRef &Result) const;
+  Error getImportLookupTableRVA(uint32_t &Result) const;
+  Error getImportAddressTableRVA(uint32_t &Result) const;
 
-  std::error_code
+  Error
   getImportTableEntry(const coff_import_directory_table_entry *&Result) const;
 
 private:
@@ -1116,10 +1133,10 @@
   imported_symbol_iterator imported_symbol_end() const;
   iterator_range<imported_symbol_iterator> imported_symbols() const;
 
-  std::error_code getName(StringRef &Result) const;
-  std::error_code getDelayImportTable(
+  Error getName(StringRef &Result) const;
+  Error getDelayImportTable(
       const delay_import_directory_table_entry *&Result) const;
-  std::error_code getImportAddress(int AddrIndex, uint64_t &Result) const;
+  Error getImportAddress(int AddrIndex, uint64_t &Result) const;
 
 private:
   const delay_import_directory_table_entry *Table;
@@ -1138,14 +1155,14 @@
   bool operator==(const ExportDirectoryEntryRef &Other) const;
   void moveNext();
 
-  std::error_code getDllName(StringRef &Result) const;
-  std::error_code getOrdinalBase(uint32_t &Result) const;
-  std::error_code getOrdinal(uint32_t &Result) const;
-  std::error_code getExportRVA(uint32_t &Result) const;
-  std::error_code getSymbolName(StringRef &Result) const;
+  Error getDllName(StringRef &Result) const;
+  Error getOrdinalBase(uint32_t &Result) const;
+  Error getOrdinal(uint32_t &Result) const;
+  Error getExportRVA(uint32_t &Result) const;
+  Error getSymbolName(StringRef &Result) const;
 
-  std::error_code isForwarder(bool &Result) const;
-  std::error_code getForwardTo(StringRef &Result) const;
+  Error isForwarder(bool &Result) const;
+  Error getForwardTo(StringRef &Result) const;
 
 private:
   const export_directory_table_entry *ExportTable;
@@ -1166,10 +1183,10 @@
   bool operator==(const ImportedSymbolRef &Other) const;
   void moveNext();
 
-  std::error_code getSymbolName(StringRef &Result) const;
-  std::error_code isOrdinal(bool &Result) const;
-  std::error_code getOrdinal(uint16_t &Result) const;
-  std::error_code getHintNameRVA(uint32_t &Result) const;
+  Error getSymbolName(StringRef &Result) const;
+  Error isOrdinal(bool &Result) const;
+  Error getOrdinal(uint16_t &Result) const;
+  Error getHintNameRVA(uint32_t &Result) const;
 
 private:
   const import_lookup_table_entry32 *Entry32;
@@ -1188,8 +1205,8 @@
   bool operator==(const BaseRelocRef &Other) const;
   void moveNext();
 
-  std::error_code getType(uint8_t &Type) const;
-  std::error_code getRVA(uint32_t &Result) const;
+  Error getType(uint8_t &Type) const;
+  Error getRVA(uint32_t &Result) const;
 
 private:
   const coff_base_reloc_block_header *Header;
@@ -1201,16 +1218,34 @@
   ResourceSectionRef() = default;
   explicit ResourceSectionRef(StringRef Ref) : BBS(Ref, support::little) {}
 
+  Error load(const COFFObjectFile *O);
+  Error load(const COFFObjectFile *O, const SectionRef &S);
+
   Expected<ArrayRef<UTF16>>
   getEntryNameString(const coff_resource_dir_entry &Entry);
   Expected<const coff_resource_dir_table &>
   getEntrySubDir(const coff_resource_dir_entry &Entry);
+  Expected<const coff_resource_data_entry &>
+  getEntryData(const coff_resource_dir_entry &Entry);
   Expected<const coff_resource_dir_table &> getBaseTable();
+  Expected<const coff_resource_dir_entry &>
+  getTableEntry(const coff_resource_dir_table &Table, uint32_t Index);
+
+  Expected<StringRef> getContents(const coff_resource_data_entry &Entry);
 
 private:
   BinaryByteStream BBS;
 
+  SectionRef Section;
+  const COFFObjectFile *Obj;
+
+  std::vector<const coff_relocation *> Relocs;
+
   Expected<const coff_resource_dir_table &> getTableAtOffset(uint32_t Offset);
+  Expected<const coff_resource_dir_entry &>
+  getTableEntryAtOffset(uint32_t Offset);
+  Expected<const coff_resource_data_entry &>
+  getDataEntryAtOffset(uint32_t Offset);
   Expected<ArrayRef<UTF16>> getDirStringAtOffset(uint32_t Offset);
 };
 
diff --git a/linux-x64/clang/include/llvm/Object/COFFImportFile.h b/linux-x64/clang/include/llvm/Object/COFFImportFile.h
index 5aa8364..f38bd89 100644
--- a/linux-x64/clang/include/llvm/Object/COFFImportFile.h
+++ b/linux-x64/clang/include/llvm/Object/COFFImportFile.h
@@ -43,7 +43,7 @@
     return Error::success();
   }
 
-  uint32_t getSymbolFlags(DataRefImpl Symb) const override {
+  Expected<uint32_t> getSymbolFlags(DataRefImpl Symb) const override {
     return SymbolRef::SF_Global;
   }
 
diff --git a/linux-x64/clang/include/llvm/Object/ELF.h b/linux-x64/clang/include/llvm/Object/ELF.h
index cab2974..86359ff 100644
--- a/linux-x64/clang/include/llvm/Object/ELF.h
+++ b/linux-x64/clang/include/llvm/Object/ELF.h
@@ -48,14 +48,51 @@
   return make_error<StringError>(Err, object_error::parse_failed);
 }
 
+enum PPCInstrMasks : uint64_t {
+  PADDI_R12_NO_DISP = 0x0610000039800000,
+  PLD_R12_NO_DISP = 0x04100000E5800000,
+  MTCTR_R12 = 0x7D8903A6,
+  BCTR = 0x4E800420,
+};
+
 template <class ELFT> class ELFFile;
 
+template <class T> struct DataRegion {
+  // This constructor is used when we know the start and the size of a data
+  // region. We assume that Arr does not go past the end of the file.
+  DataRegion(ArrayRef<T> Arr) : First(Arr.data()), Size(Arr.size()) {}
+
+  // Sometimes we only know the start of a data region. We still don't want to
+  // read past the end of the file, so we provide the end of a buffer.
+  DataRegion(const T *Data, const uint8_t *BufferEnd)
+      : First(Data), BufEnd(BufferEnd) {}
+
+  Expected<T> operator[](uint64_t N) {
+    assert(Size || BufEnd);
+    if (Size) {
+      if (N >= *Size)
+        return createError(
+            "the index is greater than or equal to the number of entries (" +
+            Twine(*Size) + ")");
+    } else {
+      const uint8_t *EntryStart = (const uint8_t *)First + N * sizeof(T);
+      if (EntryStart + sizeof(T) > BufEnd)
+        return createError("can't read past the end of the file");
+    }
+    return *(First + N);
+  }
+
+  const T *First;
+  Optional<uint64_t> Size = None;
+  const uint8_t *BufEnd = nullptr;
+};
+
 template <class ELFT>
-std::string getSecIndexForError(const ELFFile<ELFT> *Obj,
-                                const typename ELFT::Shdr *Sec) {
-  auto TableOrErr = Obj->sections();
+std::string getSecIndexForError(const ELFFile<ELFT> &Obj,
+                                const typename ELFT::Shdr &Sec) {
+  auto TableOrErr = Obj.sections();
   if (TableOrErr)
-    return "[index " + std::to_string(Sec - &TableOrErr->front()) + "]";
+    return "[index " + std::to_string(&Sec - &TableOrErr->front()) + "]";
   // To make this helper be more convenient for error reporting purposes we
   // drop the error. But really it should never be triggered. Before this point,
   // our code should have called 'sections()' and reported a proper error on
@@ -65,37 +102,34 @@
 }
 
 template <class ELFT>
+std::string getPhdrIndexForError(const ELFFile<ELFT> &Obj,
+                                 const typename ELFT::Phdr &Phdr) {
+  auto Headers = Obj.program_headers();
+  if (Headers)
+    return ("[index " + Twine(&Phdr - &Headers->front()) + "]").str();
+  // See comment in the getSecIndexForError() above.
+  llvm::consumeError(Headers.takeError());
+  return "[unknown index]";
+}
+
+static inline Error defaultWarningHandler(const Twine &Msg) {
+  return createError(Msg);
+}
+
+template <class ELFT>
 class ELFFile {
 public:
   LLVM_ELF_IMPORT_TYPES_ELFT(ELFT)
-  using uintX_t = typename ELFT::uint;
-  using Elf_Ehdr = typename ELFT::Ehdr;
-  using Elf_Shdr = typename ELFT::Shdr;
-  using Elf_Sym = typename ELFT::Sym;
-  using Elf_Dyn = typename ELFT::Dyn;
-  using Elf_Phdr = typename ELFT::Phdr;
-  using Elf_Rel = typename ELFT::Rel;
-  using Elf_Rela = typename ELFT::Rela;
-  using Elf_Relr = typename ELFT::Relr;
-  using Elf_Verdef = typename ELFT::Verdef;
-  using Elf_Verdaux = typename ELFT::Verdaux;
-  using Elf_Verneed = typename ELFT::Verneed;
-  using Elf_Vernaux = typename ELFT::Vernaux;
-  using Elf_Versym = typename ELFT::Versym;
-  using Elf_Hash = typename ELFT::Hash;
-  using Elf_GnuHash = typename ELFT::GnuHash;
-  using Elf_Nhdr = typename ELFT::Nhdr;
-  using Elf_Note = typename ELFT::Note;
-  using Elf_Note_Iterator = typename ELFT::NoteIterator;
-  using Elf_Dyn_Range = typename ELFT::DynRange;
-  using Elf_Shdr_Range = typename ELFT::ShdrRange;
-  using Elf_Sym_Range = typename ELFT::SymRange;
-  using Elf_Rel_Range = typename ELFT::RelRange;
-  using Elf_Rela_Range = typename ELFT::RelaRange;
-  using Elf_Relr_Range = typename ELFT::RelrRange;
-  using Elf_Phdr_Range = typename ELFT::PhdrRange;
+
+  // This is a callback that can be passed to a number of functions.
+  // It can be used to ignore non-critical errors (warnings), which is
+  // useful for dumpers, like llvm-readobj.
+  // It accepts a warning message string and returns a success
+  // when the warning should be ignored or an error otherwise.
+  using WarningHandler = llvm::function_ref<Error(const Twine &Msg)>;
 
   const uint8_t *base() const { return Buf.bytes_begin(); }
+  const uint8_t *end() const { return base() + getBufSize(); }
 
   size_t getBufSize() const { return Buf.size(); }
 
@@ -105,16 +139,18 @@
   ELFFile(StringRef Object);
 
 public:
-  const Elf_Ehdr *getHeader() const {
-    return reinterpret_cast<const Elf_Ehdr *>(base());
+  const Elf_Ehdr &getHeader() const {
+    return *reinterpret_cast<const Elf_Ehdr *>(base());
   }
 
   template <typename T>
   Expected<const T *> getEntry(uint32_t Section, uint32_t Entry) const;
   template <typename T>
-  Expected<const T *> getEntry(const Elf_Shdr *Section, uint32_t Entry) const;
+  Expected<const T *> getEntry(const Elf_Shdr &Section, uint32_t Entry) const;
 
-  Expected<StringRef> getStringTable(const Elf_Shdr *Section) const;
+  Expected<StringRef>
+  getStringTable(const Elf_Shdr &Section,
+                 WarningHandler WarnHandler = &defaultWarningHandler) const;
   Expected<StringRef> getStringTableForSymtab(const Elf_Shdr &Section) const;
   Expected<StringRef> getStringTableForSymtab(const Elf_Shdr &Section,
                                               Elf_Shdr_Range Sections) const;
@@ -132,65 +168,70 @@
   std::string getDynamicTagAsString(uint64_t Type) const;
 
   /// Get the symbol for a given relocation.
-  Expected<const Elf_Sym *> getRelocationSymbol(const Elf_Rel *Rel,
+  Expected<const Elf_Sym *> getRelocationSymbol(const Elf_Rel &Rel,
                                                 const Elf_Shdr *SymTab) const;
 
   static Expected<ELFFile> create(StringRef Object);
 
-  bool isMipsELF64() const {
-    return getHeader()->e_machine == ELF::EM_MIPS &&
-           getHeader()->getFileClass() == ELF::ELFCLASS64;
+  bool isLE() const {
+    return getHeader().getDataEncoding() == ELF::ELFDATA2LSB;
   }
 
-  bool isMips64EL() const {
-    return isMipsELF64() &&
-           getHeader()->getDataEncoding() == ELF::ELFDATA2LSB;
+  bool isMipsELF64() const {
+    return getHeader().e_machine == ELF::EM_MIPS &&
+           getHeader().getFileClass() == ELF::ELFCLASS64;
   }
 
+  bool isMips64EL() const { return isMipsELF64() && isLE(); }
+
   Expected<Elf_Shdr_Range> sections() const;
 
   Expected<Elf_Dyn_Range> dynamicEntries() const;
 
-  Expected<const uint8_t *> toMappedAddr(uint64_t VAddr) const;
+  Expected<const uint8_t *>
+  toMappedAddr(uint64_t VAddr,
+               WarningHandler WarnHandler = &defaultWarningHandler) const;
 
   Expected<Elf_Sym_Range> symbols(const Elf_Shdr *Sec) const {
     if (!Sec)
       return makeArrayRef<Elf_Sym>(nullptr, nullptr);
-    return getSectionContentsAsArray<Elf_Sym>(Sec);
+    return getSectionContentsAsArray<Elf_Sym>(*Sec);
   }
 
-  Expected<Elf_Rela_Range> relas(const Elf_Shdr *Sec) const {
+  Expected<Elf_Rela_Range> relas(const Elf_Shdr &Sec) const {
     return getSectionContentsAsArray<Elf_Rela>(Sec);
   }
 
-  Expected<Elf_Rel_Range> rels(const Elf_Shdr *Sec) const {
+  Expected<Elf_Rel_Range> rels(const Elf_Shdr &Sec) const {
     return getSectionContentsAsArray<Elf_Rel>(Sec);
   }
 
-  Expected<Elf_Relr_Range> relrs(const Elf_Shdr *Sec) const {
+  Expected<Elf_Relr_Range> relrs(const Elf_Shdr &Sec) const {
     return getSectionContentsAsArray<Elf_Relr>(Sec);
   }
 
-  Expected<std::vector<Elf_Rela>> decode_relrs(Elf_Relr_Range relrs) const;
+  std::vector<Elf_Rel> decode_relrs(Elf_Relr_Range relrs) const;
 
-  Expected<std::vector<Elf_Rela>> android_relas(const Elf_Shdr *Sec) const;
+  Expected<std::vector<Elf_Rela>> android_relas(const Elf_Shdr &Sec) const;
 
   /// Iterate over program header table.
   Expected<Elf_Phdr_Range> program_headers() const {
-    if (getHeader()->e_phnum && getHeader()->e_phentsize != sizeof(Elf_Phdr))
+    if (getHeader().e_phnum && getHeader().e_phentsize != sizeof(Elf_Phdr))
       return createError("invalid e_phentsize: " +
-                         Twine(getHeader()->e_phentsize));
-    if (getHeader()->e_phoff +
-            (getHeader()->e_phnum * getHeader()->e_phentsize) >
-        getBufSize())
+                         Twine(getHeader().e_phentsize));
+
+    uint64_t HeadersSize =
+        (uint64_t)getHeader().e_phnum * getHeader().e_phentsize;
+    uint64_t PhOff = getHeader().e_phoff;
+    if (PhOff + HeadersSize < PhOff || PhOff + HeadersSize > getBufSize())
       return createError("program headers are longer than binary of size " +
                          Twine(getBufSize()) + ": e_phoff = 0x" +
-                         Twine::utohexstr(getHeader()->e_phoff) +
-                         ", e_phnum = " + Twine(getHeader()->e_phnum) +
-                         ", e_phentsize = " + Twine(getHeader()->e_phentsize));
-    auto *Begin =
-        reinterpret_cast<const Elf_Phdr *>(base() + getHeader()->e_phoff);
-    return makeArrayRef(Begin, Begin + getHeader()->e_phnum);
+                         Twine::utohexstr(getHeader().e_phoff) +
+                         ", e_phnum = " + Twine(getHeader().e_phnum) +
+                         ", e_phentsize = " + Twine(getHeader().e_phentsize));
+
+    auto *Begin = reinterpret_cast<const Elf_Phdr *>(base() + PhOff);
+    return makeArrayRef(Begin, Begin + getHeader().e_phnum);
   }
 
   /// Get an iterator over notes in a program header.
@@ -201,14 +242,12 @@
   /// \param Err [out] an error to support fallible iteration, which should
   ///  be checked after iteration ends.
   Elf_Note_Iterator notes_begin(const Elf_Phdr &Phdr, Error &Err) const {
-    if (Phdr.p_type != ELF::PT_NOTE) {
-      // TODO: this error is untested.
-      Err = createError("attempt to iterate notes of non-note program header");
-      return Elf_Note_Iterator(Err);
-    }
+    assert(Phdr.p_type == ELF::PT_NOTE && "Phdr is not of type PT_NOTE");
+    ErrorAsOutParameter ErrAsOutParam(&Err);
     if (Phdr.p_offset + Phdr.p_filesz > getBufSize()) {
-      // TODO: this error is untested.
-      Err = createError("invalid program header offset/size");
+      Err =
+          createError("invalid offset (0x" + Twine::utohexstr(Phdr.p_offset) +
+                      ") or size (0x" + Twine::utohexstr(Phdr.p_filesz) + ")");
       return Elf_Note_Iterator(Err);
     }
     return Elf_Note_Iterator(base() + Phdr.p_offset, Phdr.p_filesz, Err);
@@ -222,14 +261,12 @@
   /// \param Err [out] an error to support fallible iteration, which should
   ///  be checked after iteration ends.
   Elf_Note_Iterator notes_begin(const Elf_Shdr &Shdr, Error &Err) const {
-    if (Shdr.sh_type != ELF::SHT_NOTE) {
-      // TODO: this error is untested.
-      Err = createError("attempt to iterate notes of non-note section");
-      return Elf_Note_Iterator(Err);
-    }
+    assert(Shdr.sh_type == ELF::SHT_NOTE && "Shdr is not of type SHT_NOTE");
+    ErrorAsOutParameter ErrAsOutParam(&Err);
     if (Shdr.sh_offset + Shdr.sh_size > getBufSize()) {
-      // TODO: this error is untested.
-      Err = createError("invalid section offset/size");
+      Err =
+          createError("invalid offset (0x" + Twine::utohexstr(Shdr.sh_offset) +
+                      ") or size (0x" + Twine::utohexstr(Shdr.sh_size) + ")");
       return Elf_Note_Iterator(Err);
     }
     return Elf_Note_Iterator(base() + Shdr.sh_offset, Shdr.sh_size, Err);
@@ -264,27 +301,31 @@
     return make_range(notes_begin(Shdr, Err), notes_end());
   }
 
-  Expected<StringRef> getSectionStringTable(Elf_Shdr_Range Sections) const;
-  Expected<uint32_t> getSectionIndex(const Elf_Sym *Sym, Elf_Sym_Range Syms,
-                                     ArrayRef<Elf_Word> ShndxTable) const;
-  Expected<const Elf_Shdr *> getSection(const Elf_Sym *Sym,
+  Expected<StringRef> getSectionStringTable(
+      Elf_Shdr_Range Sections,
+      WarningHandler WarnHandler = &defaultWarningHandler) const;
+  Expected<uint32_t> getSectionIndex(const Elf_Sym &Sym, Elf_Sym_Range Syms,
+                                     DataRegion<Elf_Word> ShndxTable) const;
+  Expected<const Elf_Shdr *> getSection(const Elf_Sym &Sym,
                                         const Elf_Shdr *SymTab,
-                                        ArrayRef<Elf_Word> ShndxTable) const;
-  Expected<const Elf_Shdr *> getSection(const Elf_Sym *Sym,
+                                        DataRegion<Elf_Word> ShndxTable) const;
+  Expected<const Elf_Shdr *> getSection(const Elf_Sym &Sym,
                                         Elf_Sym_Range Symtab,
-                                        ArrayRef<Elf_Word> ShndxTable) const;
+                                        DataRegion<Elf_Word> ShndxTable) const;
   Expected<const Elf_Shdr *> getSection(uint32_t Index) const;
-  Expected<const Elf_Shdr *> getSection(const StringRef SectionName) const;
 
   Expected<const Elf_Sym *> getSymbol(const Elf_Shdr *Sec,
                                       uint32_t Index) const;
 
-  Expected<StringRef> getSectionName(const Elf_Shdr *Section) const;
-  Expected<StringRef> getSectionName(const Elf_Shdr *Section,
+  Expected<StringRef>
+  getSectionName(const Elf_Shdr &Section,
+                 WarningHandler WarnHandler = &defaultWarningHandler) const;
+  Expected<StringRef> getSectionName(const Elf_Shdr &Section,
                                      StringRef DotShstrtab) const;
   template <typename T>
-  Expected<ArrayRef<T>> getSectionContentsAsArray(const Elf_Shdr *Sec) const;
-  Expected<ArrayRef<uint8_t>> getSectionContents(const Elf_Shdr *Sec) const;
+  Expected<ArrayRef<T>> getSectionContentsAsArray(const Elf_Shdr &Sec) const;
+  Expected<ArrayRef<uint8_t>> getSectionContents(const Elf_Shdr &Sec) const;
+  Expected<ArrayRef<uint8_t>> getSegmentContents(const Elf_Phdr &Phdr) const;
 };
 
 using ELF32LEFile = ELFFile<ELF32LE>;
@@ -302,29 +343,30 @@
 
 template <class ELFT>
 inline Expected<uint32_t>
-getExtendedSymbolTableIndex(const typename ELFT::Sym *Sym,
-                            const typename ELFT::Sym *FirstSym,
-                            ArrayRef<typename ELFT::Word> ShndxTable) {
-  assert(Sym->st_shndx == ELF::SHN_XINDEX);
-  unsigned Index = Sym - FirstSym;
-  if (Index >= ShndxTable.size())
+getExtendedSymbolTableIndex(const typename ELFT::Sym &Sym, unsigned SymIndex,
+                            DataRegion<typename ELFT::Word> ShndxTable) {
+  assert(Sym.st_shndx == ELF::SHN_XINDEX);
+  if (!ShndxTable.First)
     return createError(
-        "extended symbol index (" + Twine(Index) +
-        ") is past the end of the SHT_SYMTAB_SHNDX section of size " +
-        Twine(ShndxTable.size()));
+        "found an extended symbol index (" + Twine(SymIndex) +
+        "), but unable to locate the extended symbol index table");
 
-  // The size of the table was checked in getSHNDXTable.
-  return ShndxTable[Index];
+  Expected<typename ELFT::Word> TableOrErr = ShndxTable[SymIndex];
+  if (!TableOrErr)
+    return createError("unable to read an extended symbol table at index " +
+                       Twine(SymIndex) + ": " +
+                       toString(TableOrErr.takeError()));
+  return *TableOrErr;
 }
 
 template <class ELFT>
 Expected<uint32_t>
-ELFFile<ELFT>::getSectionIndex(const Elf_Sym *Sym, Elf_Sym_Range Syms,
-                               ArrayRef<Elf_Word> ShndxTable) const {
-  uint32_t Index = Sym->st_shndx;
+ELFFile<ELFT>::getSectionIndex(const Elf_Sym &Sym, Elf_Sym_Range Syms,
+                               DataRegion<Elf_Word> ShndxTable) const {
+  uint32_t Index = Sym.st_shndx;
   if (Index == ELF::SHN_XINDEX) {
-    auto ErrorOrIndex = getExtendedSymbolTableIndex<ELFT>(
-        Sym, Syms.begin(), ShndxTable);
+    Expected<uint32_t> ErrorOrIndex =
+        getExtendedSymbolTableIndex<ELFT>(Sym, &Sym - Syms.begin(), ShndxTable);
     if (!ErrorOrIndex)
       return ErrorOrIndex.takeError();
     return *ErrorOrIndex;
@@ -336,8 +378,8 @@
 
 template <class ELFT>
 Expected<const typename ELFT::Shdr *>
-ELFFile<ELFT>::getSection(const Elf_Sym *Sym, const Elf_Shdr *SymTab,
-                          ArrayRef<Elf_Word> ShndxTable) const {
+ELFFile<ELFT>::getSection(const Elf_Sym &Sym, const Elf_Shdr *SymTab,
+                          DataRegion<Elf_Word> ShndxTable) const {
   auto SymsOrErr = symbols(SymTab);
   if (!SymsOrErr)
     return SymsOrErr.takeError();
@@ -346,8 +388,8 @@
 
 template <class ELFT>
 Expected<const typename ELFT::Shdr *>
-ELFFile<ELFT>::getSection(const Elf_Sym *Sym, Elf_Sym_Range Symbols,
-                          ArrayRef<Elf_Word> ShndxTable) const {
+ELFFile<ELFT>::getSection(const Elf_Sym &Sym, Elf_Sym_Range Symbols,
+                          DataRegion<Elf_Word> ShndxTable) const {
   auto IndexOrErr = getSectionIndex(Sym, Symbols, ShndxTable);
   if (!IndexOrErr)
     return IndexOrErr.takeError();
@@ -358,45 +400,48 @@
 }
 
 template <class ELFT>
-inline Expected<const typename ELFT::Sym *>
-getSymbol(typename ELFT::SymRange Symbols, uint32_t Index) {
-  if (Index >= Symbols.size())
-    // TODO: this error is untested.
-    return createError("invalid symbol index");
-  return &Symbols[Index];
-}
-
-template <class ELFT>
 Expected<const typename ELFT::Sym *>
 ELFFile<ELFT>::getSymbol(const Elf_Shdr *Sec, uint32_t Index) const {
-  auto SymtabOrErr = symbols(Sec);
-  if (!SymtabOrErr)
-    return SymtabOrErr.takeError();
-  return object::getSymbol<ELFT>(*SymtabOrErr, Index);
+  auto SymsOrErr = symbols(Sec);
+  if (!SymsOrErr)
+    return SymsOrErr.takeError();
+
+  Elf_Sym_Range Symbols = *SymsOrErr;
+  if (Index >= Symbols.size())
+    return createError("unable to get symbol from section " +
+                       getSecIndexForError(*this, *Sec) +
+                       ": invalid symbol index (" + Twine(Index) + ")");
+  return &Symbols[Index];
 }
 
 template <class ELFT>
 template <typename T>
 Expected<ArrayRef<T>>
-ELFFile<ELFT>::getSectionContentsAsArray(const Elf_Shdr *Sec) const {
-  if (Sec->sh_entsize != sizeof(T) && sizeof(T) != 1)
-    return createError("section " + getSecIndexForError(this, Sec) +
-                       " has an invalid sh_entsize: " + Twine(Sec->sh_entsize));
+ELFFile<ELFT>::getSectionContentsAsArray(const Elf_Shdr &Sec) const {
+  if (Sec.sh_entsize != sizeof(T) && sizeof(T) != 1)
+    return createError("section " + getSecIndexForError(*this, Sec) +
+                       " has invalid sh_entsize: expected " + Twine(sizeof(T)) +
+                       ", but got " + Twine(Sec.sh_entsize));
 
-  uintX_t Offset = Sec->sh_offset;
-  uintX_t Size = Sec->sh_size;
+  uintX_t Offset = Sec.sh_offset;
+  uintX_t Size = Sec.sh_size;
 
   if (Size % sizeof(T))
-    return createError("section " + getSecIndexForError(this, Sec) +
+    return createError("section " + getSecIndexForError(*this, Sec) +
                        " has an invalid sh_size (" + Twine(Size) +
                        ") which is not a multiple of its sh_entsize (" +
-                       Twine(Sec->sh_entsize) + ")");
-  if ((std::numeric_limits<uintX_t>::max() - Offset < Size) ||
-      Offset + Size > Buf.size())
-    return createError("section " + getSecIndexForError(this, Sec) +
+                       Twine(Sec.sh_entsize) + ")");
+  if (std::numeric_limits<uintX_t>::max() - Offset < Size)
+    return createError("section " + getSecIndexForError(*this, Sec) +
                        " has a sh_offset (0x" + Twine::utohexstr(Offset) +
-                       ") + sh_size (0x" + Twine(Size) +
+                       ") + sh_size (0x" + Twine::utohexstr(Size) +
                        ") that cannot be represented");
+  if (Offset + Size > Buf.size())
+    return createError("section " + getSecIndexForError(*this, Sec) +
+                       " has a sh_offset (0x" + Twine::utohexstr(Offset) +
+                       ") + sh_size (0x" + Twine::utohexstr(Size) +
+                       ") that is greater than the file size (0x" +
+                       Twine::utohexstr(Buf.size()) + ")");
 
   if (Offset % alignof(T))
     // TODO: this error is untested.
@@ -408,13 +453,33 @@
 
 template <class ELFT>
 Expected<ArrayRef<uint8_t>>
-ELFFile<ELFT>::getSectionContents(const Elf_Shdr *Sec) const {
+ELFFile<ELFT>::getSegmentContents(const Elf_Phdr &Phdr) const {
+  uintX_t Offset = Phdr.p_offset;
+  uintX_t Size = Phdr.p_filesz;
+
+  if (std::numeric_limits<uintX_t>::max() - Offset < Size)
+    return createError("program header " + getPhdrIndexForError(*this, Phdr) +
+                       " has a p_offset (0x" + Twine::utohexstr(Offset) +
+                       ") + p_filesz (0x" + Twine::utohexstr(Size) +
+                       ") that cannot be represented");
+  if (Offset + Size > Buf.size())
+    return createError("program header  " + getPhdrIndexForError(*this, Phdr) +
+                       " has a p_offset (0x" + Twine::utohexstr(Offset) +
+                       ") + p_filesz (0x" + Twine::utohexstr(Size) +
+                       ") that is greater than the file size (0x" +
+                       Twine::utohexstr(Buf.size()) + ")");
+  return makeArrayRef(base() + Offset, Size);
+}
+
+template <class ELFT>
+Expected<ArrayRef<uint8_t>>
+ELFFile<ELFT>::getSectionContents(const Elf_Shdr &Sec) const {
   return getSectionContentsAsArray<uint8_t>(Sec);
 }
 
 template <class ELFT>
 StringRef ELFFile<ELFT>::getRelocationTypeName(uint32_t Type) const {
-  return getELFRelocationTypeName(getHeader()->e_machine, Type);
+  return getELFRelocationTypeName(getHeader().e_machine, Type);
 }
 
 template <class ELFT>
@@ -450,32 +515,42 @@
 
 template <class ELFT>
 uint32_t ELFFile<ELFT>::getRelativeRelocationType() const {
-  return getELFRelativeRelocationType(getHeader()->e_machine);
+  return getELFRelativeRelocationType(getHeader().e_machine);
 }
 
 template <class ELFT>
 Expected<const typename ELFT::Sym *>
-ELFFile<ELFT>::getRelocationSymbol(const Elf_Rel *Rel,
+ELFFile<ELFT>::getRelocationSymbol(const Elf_Rel &Rel,
                                    const Elf_Shdr *SymTab) const {
-  uint32_t Index = Rel->getSymbol(isMips64EL());
+  uint32_t Index = Rel.getSymbol(isMips64EL());
   if (Index == 0)
     return nullptr;
-  return getEntry<Elf_Sym>(SymTab, Index);
+  return getEntry<Elf_Sym>(*SymTab, Index);
 }
 
 template <class ELFT>
 Expected<StringRef>
-ELFFile<ELFT>::getSectionStringTable(Elf_Shdr_Range Sections) const {
-  uint32_t Index = getHeader()->e_shstrndx;
-  if (Index == ELF::SHN_XINDEX)
+ELFFile<ELFT>::getSectionStringTable(Elf_Shdr_Range Sections,
+                                     WarningHandler WarnHandler) const {
+  uint32_t Index = getHeader().e_shstrndx;
+  if (Index == ELF::SHN_XINDEX) {
+    // If the section name string table section index is greater than
+    // or equal to SHN_LORESERVE, then the actual index of the section name
+    // string table section is contained in the sh_link field of the section
+    // header at index 0.
+    if (Sections.empty())
+      return createError(
+          "e_shstrndx == SHN_XINDEX, but the section header table is empty");
+
     Index = Sections[0].sh_link;
+  }
 
   if (!Index) // no section string table.
     return "";
   if (Index >= Sections.size())
-    // TODO: this error is untested.
-    return createError("invalid section index");
-  return getStringTable(&Sections[Index]);
+    return createError("section header string table index " + Twine(Index) +
+                       " does not exist");
+  return getStringTable(Sections[Index], WarnHandler);
 }
 
 template <class ELFT> ELFFile<ELFT>::ELFFile(StringRef Object) : Buf(Object) {}
@@ -491,16 +566,17 @@
 
 template <class ELFT>
 Expected<typename ELFT::ShdrRange> ELFFile<ELFT>::sections() const {
-  const uintX_t SectionTableOffset = getHeader()->e_shoff;
+  const uintX_t SectionTableOffset = getHeader().e_shoff;
   if (SectionTableOffset == 0)
     return ArrayRef<Elf_Shdr>();
 
-  if (getHeader()->e_shentsize != sizeof(Elf_Shdr))
+  if (getHeader().e_shentsize != sizeof(Elf_Shdr))
     return createError("invalid e_shentsize in ELF header: " +
-                       Twine(getHeader()->e_shentsize));
+                       Twine(getHeader().e_shentsize));
 
   const uint64_t FileSize = Buf.size();
-  if (SectionTableOffset + sizeof(Elf_Shdr) > FileSize)
+  if (SectionTableOffset + sizeof(Elf_Shdr) > FileSize ||
+      SectionTableOffset + (uintX_t)sizeof(Elf_Shdr) < SectionTableOffset)
     return createError(
         "section header table goes past the end of the file: e_shoff = 0x" +
         Twine::utohexstr(SectionTableOffset));
@@ -513,20 +589,27 @@
   const Elf_Shdr *First =
       reinterpret_cast<const Elf_Shdr *>(base() + SectionTableOffset);
 
-  uintX_t NumSections = getHeader()->e_shnum;
+  uintX_t NumSections = getHeader().e_shnum;
   if (NumSections == 0)
     NumSections = First->sh_size;
 
   if (NumSections > UINT64_MAX / sizeof(Elf_Shdr))
-    // TODO: this error is untested.
-    return createError("section table goes past the end of file");
+    return createError("invalid number of sections specified in the NULL "
+                       "section's sh_size field (" +
+                       Twine(NumSections) + ")");
 
   const uint64_t SectionTableSize = NumSections * sizeof(Elf_Shdr);
+  if (SectionTableOffset + SectionTableSize < SectionTableOffset)
+    return createError(
+        "invalid section header table offset (e_shoff = 0x" +
+        Twine::utohexstr(SectionTableOffset) +
+        ") or invalid number of sections specified in the first section "
+        "header's sh_size field (0x" +
+        Twine::utohexstr(NumSections) + ")");
 
   // Section table goes past end of file!
   if (SectionTableOffset + SectionTableSize > FileSize)
     return createError("section table goes past the end of file");
-
   return makeArrayRef(First, NumSections);
 }
 
@@ -537,23 +620,25 @@
   auto SecOrErr = getSection(Section);
   if (!SecOrErr)
     return SecOrErr.takeError();
-  return getEntry<T>(*SecOrErr, Entry);
+  return getEntry<T>(**SecOrErr, Entry);
 }
 
 template <class ELFT>
 template <typename T>
-Expected<const T *> ELFFile<ELFT>::getEntry(const Elf_Shdr *Section,
+Expected<const T *> ELFFile<ELFT>::getEntry(const Elf_Shdr &Section,
                                             uint32_t Entry) const {
-  if (sizeof(T) != Section->sh_entsize)
-    // TODO: this error is untested.
-    return createError("invalid sh_entsize");
-  size_t Pos = Section->sh_offset + Entry * sizeof(T);
-  if (Pos + sizeof(T) > Buf.size())
-    return createError("unable to access section " +
-                       getSecIndexForError(this, Section) + " data at 0x" +
-                       Twine::utohexstr(Pos) +
-                       ": offset goes past the end of file");
-  return reinterpret_cast<const T *>(base() + Pos);
+  Expected<ArrayRef<T>> EntriesOrErr = getSectionContentsAsArray<T>(Section);
+  if (!EntriesOrErr)
+    return EntriesOrErr.takeError();
+
+  ArrayRef<T> Arr = *EntriesOrErr;
+  if (Entry >= Arr.size())
+    return createError(
+        "can't read an entry at 0x" +
+        Twine::utohexstr(Entry * static_cast<uint64_t>(sizeof(T))) +
+        ": it goes past the end of the section (0x" +
+        Twine::utohexstr(Section.sh_size) + ")");
+  return &Arr[Entry];
 }
 
 template <class ELFT>
@@ -566,43 +651,27 @@
 }
 
 template <class ELFT>
-Expected<const typename ELFT::Shdr *>
-ELFFile<ELFT>::getSection(const StringRef SectionName) const {
-  auto TableOrErr = sections();
-  if (!TableOrErr)
-    return TableOrErr.takeError();
-  for (auto &Sec : *TableOrErr) {
-    auto SecNameOrErr = getSectionName(&Sec);
-    if (!SecNameOrErr)
-      return SecNameOrErr.takeError();
-    if (*SecNameOrErr == SectionName)
-      return &Sec;
-  }
-  // TODO: this error is untested.
-  return createError("invalid section name");
-}
-
-template <class ELFT>
 Expected<StringRef>
-ELFFile<ELFT>::getStringTable(const Elf_Shdr *Section) const {
-  if (Section->sh_type != ELF::SHT_STRTAB)
-    return createError("invalid sh_type for string table section " +
-                       getSecIndexForError(this, Section) +
-                       ": expected SHT_STRTAB, but got " +
-                       object::getELFSectionTypeName(getHeader()->e_machine,
-                                                     Section->sh_type));
+ELFFile<ELFT>::getStringTable(const Elf_Shdr &Section,
+                              WarningHandler WarnHandler) const {
+  if (Section.sh_type != ELF::SHT_STRTAB)
+    if (Error E = WarnHandler("invalid sh_type for string table section " +
+                              getSecIndexForError(*this, Section) +
+                              ": expected SHT_STRTAB, but got " +
+                              object::getELFSectionTypeName(
+                                  getHeader().e_machine, Section.sh_type)))
+      return std::move(E);
+
   auto V = getSectionContentsAsArray<char>(Section);
   if (!V)
     return V.takeError();
   ArrayRef<char> Data = *V;
   if (Data.empty())
-    // TODO: this error is untested.
-    return createError("empty string table");
+    return createError("SHT_STRTAB string table section " +
+                       getSecIndexForError(*this, Section) + " is empty");
   if (Data.back() != '\0')
-    return createError(object::getELFSectionTypeName(getHeader()->e_machine,
-                                                     Section->sh_type) +
-                       " string table section " +
-                       getSecIndexForError(this, Section) +
+    return createError("SHT_STRTAB string table section " +
+                       getSecIndexForError(*this, Section) +
                        " is non-null terminated");
   return StringRef(Data.begin(), Data.size());
 }
@@ -621,7 +690,7 @@
 ELFFile<ELFT>::getSHNDXTable(const Elf_Shdr &Section,
                              Elf_Shdr_Range Sections) const {
   assert(Section.sh_type == ELF::SHT_SYMTAB_SHNDX);
-  auto VOrErr = getSectionContentsAsArray<Elf_Word>(&Section);
+  auto VOrErr = getSectionContentsAsArray<Elf_Word>(Section);
   if (!VOrErr)
     return VOrErr.takeError();
   ArrayRef<Elf_Word> V = *VOrErr;
@@ -631,13 +700,17 @@
   const Elf_Shdr &SymTable = **SymTableOrErr;
   if (SymTable.sh_type != ELF::SHT_SYMTAB &&
       SymTable.sh_type != ELF::SHT_DYNSYM)
-    // TODO: this error is untested.
-    return createError("invalid sh_type");
-  if (V.size() != (SymTable.sh_size / sizeof(Elf_Sym)))
-    return createError("SHT_SYMTAB_SHNDX section has sh_size (" +
-                       Twine(SymTable.sh_size) +
-                       ") which is not equal to the number of symbols (" +
-                       Twine(V.size()) + ")");
+    return createError(
+        "SHT_SYMTAB_SHNDX section is linked with " +
+        object::getELFSectionTypeName(getHeader().e_machine, SymTable.sh_type) +
+        " section (expected SHT_SYMTAB/SHT_DYNSYM)");
+
+  uint64_t Syms = SymTable.sh_size / sizeof(Elf_Sym);
+  if (V.size() != Syms)
+    return createError("SHT_SYMTAB_SHNDX has " + Twine(V.size()) +
+                       " entries, but the symbol table associated has " +
+                       Twine(Syms));
+
   return V;
 }
 
@@ -656,35 +729,36 @@
                                        Elf_Shdr_Range Sections) const {
 
   if (Sec.sh_type != ELF::SHT_SYMTAB && Sec.sh_type != ELF::SHT_DYNSYM)
-    // TODO: this error is untested.
     return createError(
         "invalid sh_type for symbol table, expected SHT_SYMTAB or SHT_DYNSYM");
-  auto SectionOrErr = object::getSection<ELFT>(Sections, Sec.sh_link);
+  Expected<const Elf_Shdr *> SectionOrErr =
+      object::getSection<ELFT>(Sections, Sec.sh_link);
   if (!SectionOrErr)
     return SectionOrErr.takeError();
-  return getStringTable(*SectionOrErr);
+  return getStringTable(**SectionOrErr);
 }
 
 template <class ELFT>
 Expected<StringRef>
-ELFFile<ELFT>::getSectionName(const Elf_Shdr *Section) const {
+ELFFile<ELFT>::getSectionName(const Elf_Shdr &Section,
+                              WarningHandler WarnHandler) const {
   auto SectionsOrErr = sections();
   if (!SectionsOrErr)
     return SectionsOrErr.takeError();
-  auto Table = getSectionStringTable(*SectionsOrErr);
+  auto Table = getSectionStringTable(*SectionsOrErr, WarnHandler);
   if (!Table)
     return Table.takeError();
   return getSectionName(Section, *Table);
 }
 
 template <class ELFT>
-Expected<StringRef> ELFFile<ELFT>::getSectionName(const Elf_Shdr *Section,
+Expected<StringRef> ELFFile<ELFT>::getSectionName(const Elf_Shdr &Section,
                                                   StringRef DotShstrtab) const {
-  uint32_t Offset = Section->sh_name;
+  uint32_t Offset = Section.sh_name;
   if (Offset == 0)
     return StringRef();
   if (Offset >= DotShstrtab.size())
-    return createError("a section " + getSecIndexForError(this, Section) +
+    return createError("a section " + getSecIndexForError(*this, Section) +
                        " has an invalid sh_name (0x" +
                        Twine::utohexstr(Offset) +
                        ") offset which goes past the end of the "
diff --git a/linux-x64/clang/include/llvm/Object/ELFObjectFile.h b/linux-x64/clang/include/llvm/Object/ELFObjectFile.h
index 86c015e..fed53ee 100644
--- a/linux-x64/clang/include/llvm/Object/ELFObjectFile.h
+++ b/linux-x64/clang/include/llvm/Object/ELFObjectFile.h
@@ -28,8 +28,8 @@
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Object/SymbolicFile.h"
 #include "llvm/Support/ARMAttributeParser.h"
-#include "llvm/Support/ARMBuildAttributes.h"
 #include "llvm/Support/Casting.h"
+#include "llvm/Support/ELFAttributes.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/ErrorHandling.h"
@@ -41,7 +41,7 @@
 namespace llvm {
 namespace object {
 
-constexpr int NumElfSymbolTypes = 8;
+constexpr int NumElfSymbolTypes = 16;
 extern const llvm::EnumEntry<unsigned> ElfSymbolTypes[NumElfSymbolTypes];
 
 class elf_symbol_iterator;
@@ -51,6 +51,12 @@
   friend class ELFSectionRef;
   friend class ELFSymbolRef;
 
+  SubtargetFeatures getMIPSFeatures() const;
+  SubtargetFeatures getARMFeatures() const;
+  SubtargetFeatures getRISCVFeatures() const;
+
+  StringRef getAMDGPUCPUName() const;
+
 protected:
   ELFObjectFileBase(unsigned int Type, MemoryBufferRef Source);
 
@@ -64,7 +70,7 @@
   virtual uint64_t getSectionOffset(DataRefImpl Sec) const = 0;
 
   virtual Expected<int64_t> getRelocationAddend(DataRefImpl Rel) const = 0;
-  virtual Error getBuildAttributes(ARMAttributeParser &Attributes) const = 0;
+  virtual Error getBuildAttributes(ELFAttributeParser &Attributes) const = 0;
 
 public:
   using elf_symbol_iterator_range = iterator_range<elf_symbol_iterator>;
@@ -80,11 +86,7 @@
 
   SubtargetFeatures getFeatures() const override;
 
-  SubtargetFeatures getMIPSFeatures() const;
-
-  SubtargetFeatures getARMFeatures() const;
-
-  SubtargetFeatures getRISCVFeatures() const;
+  Optional<StringRef> tryGetCPUName() const override;
 
   void setARMSubArch(Triple &TheTriple) const override;
 
@@ -92,7 +94,8 @@
 
   virtual uint16_t getEMachine() const = 0;
 
-  std::vector<std::pair<DataRefImpl, uint64_t>> getPltAddresses() const;
+  std::vector<std::pair<Optional<DataRefImpl>, uint64_t>>
+  getPltAddresses() const;
 };
 
 class ELFSectionRef : public SectionRef {
@@ -230,26 +233,31 @@
 public:
   LLVM_ELF_IMPORT_TYPES_ELFT(ELFT)
 
-  using uintX_t = typename ELFT::uint;
+  SectionRef toSectionRef(const Elf_Shdr *Sec) const {
+    return SectionRef(toDRI(Sec), this);
+  }
 
-  using Elf_Sym = typename ELFT::Sym;
-  using Elf_Shdr = typename ELFT::Shdr;
-  using Elf_Ehdr = typename ELFT::Ehdr;
-  using Elf_Rel = typename ELFT::Rel;
-  using Elf_Rela = typename ELFT::Rela;
-  using Elf_Dyn = typename ELFT::Dyn;
+  ELFSymbolRef toSymbolRef(const Elf_Shdr *SymTable, unsigned SymbolNum) const {
+    return ELFSymbolRef({toDRI(SymTable, SymbolNum), this});
+  }
+
+  bool IsContentValid() const { return ContentValid; }
 
 private:
   ELFObjectFile(MemoryBufferRef Object, ELFFile<ELFT> EF,
                 const Elf_Shdr *DotDynSymSec, const Elf_Shdr *DotSymtabSec,
-                ArrayRef<Elf_Word> ShndxTable);
+                const Elf_Shdr *DotSymtabShndxSec);
+
+  bool ContentValid = false;
 
 protected:
   ELFFile<ELFT> EF;
 
   const Elf_Shdr *DotDynSymSec = nullptr; // Dynamic symbol table section.
   const Elf_Shdr *DotSymtabSec = nullptr; // Symbol table section.
-  ArrayRef<Elf_Word> ShndxTable;
+  const Elf_Shdr *DotSymtabShndxSec = nullptr; // SHT_SYMTAB_SHNDX section.
+
+  Error initContent() override;
 
   void moveSymbolNext(DataRefImpl &Symb) const override;
   Expected<StringRef> getSymbolName(DataRefImpl Symb) const override;
@@ -257,7 +265,7 @@
   uint64_t getSymbolValueImpl(DataRefImpl Symb) const override;
   uint32_t getSymbolAlignment(DataRefImpl Symb) const override;
   uint64_t getCommonSymbolSizeImpl(DataRefImpl Symb) const override;
-  uint32_t getSymbolFlags(DataRefImpl Symb) const override;
+  Expected<uint32_t> getSymbolFlags(DataRefImpl Symb) const override;
   uint8_t getSymbolBinding(DataRefImpl Symb) const override;
   uint8_t getSymbolOther(DataRefImpl Symb) const override;
   uint8_t getSymbolELFType(DataRefImpl Symb) const override;
@@ -281,10 +289,12 @@
   bool isSectionVirtual(DataRefImpl Sec) const override;
   bool isBerkeleyText(DataRefImpl Sec) const override;
   bool isBerkeleyData(DataRefImpl Sec) const override;
+  bool isDebugSection(StringRef SectionName) const override;
   relocation_iterator section_rel_begin(DataRefImpl Sec) const override;
   relocation_iterator section_rel_end(DataRefImpl Sec) const override;
   std::vector<SectionRef> dynamic_relocation_sections() const override;
-  section_iterator getRelocatedSection(DataRefImpl Sec) const override;
+  Expected<section_iterator>
+  getRelocatedSection(DataRefImpl Sec) const override;
 
   void moveRelocationNext(DataRefImpl &Rel) const override;
   uint64_t getRelocationOffset(DataRefImpl Rel) const override;
@@ -298,14 +308,6 @@
   uint64_t getSectionOffset(DataRefImpl Sec) const override;
   StringRef getRelocationTypeName(uint32_t Type) const;
 
-  /// Get the relocation section that contains \a Rel.
-  const Elf_Shdr *getRelSection(DataRefImpl Rel) const {
-    auto RelSecOrErr = EF.getSection(Rel.d.a);
-    if (!RelSecOrErr)
-      report_fatal_error(errorToErrorCode(RelSecOrErr.takeError()).message());
-    return *RelSecOrErr;
-  }
-
   DataRefImpl toDRI(const Elf_Shdr *SymTable, unsigned SymbolNum) const {
     DataRefImpl DRI;
     if (!SymTable) {
@@ -360,22 +362,24 @@
         (Visibility == ELF::STV_DEFAULT || Visibility == ELF::STV_PROTECTED));
   }
 
-  Error getBuildAttributes(ARMAttributeParser &Attributes) const override {
+  Error getBuildAttributes(ELFAttributeParser &Attributes) const override {
     auto SectionsOrErr = EF.sections();
     if (!SectionsOrErr)
       return SectionsOrErr.takeError();
 
     for (const Elf_Shdr &Sec : *SectionsOrErr) {
-      if (Sec.sh_type == ELF::SHT_ARM_ATTRIBUTES) {
-        auto ErrorOrContents = EF.getSectionContents(&Sec);
+      if (Sec.sh_type == ELF::SHT_ARM_ATTRIBUTES ||
+          Sec.sh_type == ELF::SHT_RISCV_ATTRIBUTES) {
+        auto ErrorOrContents = EF.getSectionContents(Sec);
         if (!ErrorOrContents)
           return ErrorOrContents.takeError();
 
         auto Contents = ErrorOrContents.get();
-        if (Contents[0] != ARMBuildAttrs::Format_Version || Contents.size() == 1)
+        if (Contents[0] != ELFAttrs::Format_Version || Contents.size() == 1)
           return Error::success();
 
-        Attributes.Parse(Contents, ELFT::TargetEndianness == support::little);
+        if (Error E = Attributes.parse(Contents, ELFT::TargetEndianness))
+          return E;
         break;
       }
     }
@@ -389,16 +393,22 @@
 
 public:
   ELFObjectFile(ELFObjectFile<ELFT> &&Other);
-  static Expected<ELFObjectFile<ELFT>> create(MemoryBufferRef Object);
+  static Expected<ELFObjectFile<ELFT>> create(MemoryBufferRef Object,
+                                              bool InitContent = true);
 
   const Elf_Rel *getRel(DataRefImpl Rel) const;
   const Elf_Rela *getRela(DataRefImpl Rela) const;
 
-  const Elf_Sym *getSymbol(DataRefImpl Sym) const {
-    auto Ret = EF.template getEntry<Elf_Sym>(Sym.d.a, Sym.d.b);
-    if (!Ret)
-      report_fatal_error(errorToErrorCode(Ret.takeError()).message());
-    return *Ret;
+  Expected<const Elf_Sym *> getSymbol(DataRefImpl Sym) const {
+    return EF.template getEntry<Elf_Sym>(Sym.d.a, Sym.d.b);
+  }
+
+  /// Get the relocation section that contains \a Rel.
+  const Elf_Shdr *getRelSection(DataRefImpl Rel) const {
+    auto RelSecOrErr = EF.getSection(Rel.d.a);
+    if (!RelSecOrErr)
+      report_fatal_error(errorToErrorCode(RelSecOrErr.takeError()).message());
+    return *RelSecOrErr;
   }
 
   const Elf_Shdr *getSection(DataRefImpl Sec) const {
@@ -421,9 +431,9 @@
   Triple::ArchType getArch() const override;
   Expected<uint64_t> getStartAddress() const override;
 
-  unsigned getPlatformFlags() const override { return EF.getHeader()->e_flags; }
+  unsigned getPlatformFlags() const override { return EF.getHeader().e_flags; }
 
-  const ELFFile<ELFT> *getELFFile() const { return &EF; }
+  const ELFFile<ELFT> &getELFFile() const { return EF; }
 
   bool isDyldType() const { return isDyldELFObject; }
   static bool classof(const Binary *v) {
@@ -446,9 +456,40 @@
   ++Sym.d.b;
 }
 
+template <class ELFT> Error ELFObjectFile<ELFT>::initContent() {
+  auto SectionsOrErr = EF.sections();
+  if (!SectionsOrErr)
+    return SectionsOrErr.takeError();
+
+  for (const Elf_Shdr &Sec : *SectionsOrErr) {
+    switch (Sec.sh_type) {
+    case ELF::SHT_DYNSYM: {
+      if (!DotDynSymSec)
+        DotDynSymSec = &Sec;
+      break;
+    }
+    case ELF::SHT_SYMTAB: {
+      if (!DotSymtabSec)
+        DotSymtabSec = &Sec;
+      break;
+    }
+    case ELF::SHT_SYMTAB_SHNDX: {
+      if (!DotSymtabShndxSec)
+        DotSymtabShndxSec = &Sec;
+      break;
+    }
+    }
+  }
+
+  ContentValid = true;
+  return Error::success();
+}
+
 template <class ELFT>
 Expected<StringRef> ELFObjectFile<ELFT>::getSymbolName(DataRefImpl Sym) const {
-  const Elf_Sym *ESym = getSymbol(Sym);
+  Expected<const Elf_Sym *> SymOrErr = getSymbol(Sym);
+  if (!SymOrErr)
+    return SymOrErr.takeError();
   auto SymTabOrErr = EF.getSection(Sym.d.a);
   if (!SymTabOrErr)
     return SymTabOrErr.takeError();
@@ -457,17 +498,19 @@
   if (!StrTabOrErr)
     return StrTabOrErr.takeError();
   const Elf_Shdr *StringTableSec = *StrTabOrErr;
-  auto SymStrTabOrErr = EF.getStringTable(StringTableSec);
+  auto SymStrTabOrErr = EF.getStringTable(*StringTableSec);
   if (!SymStrTabOrErr)
     return SymStrTabOrErr.takeError();
-  Expected<StringRef> Name = ESym->getName(*SymStrTabOrErr);
+  Expected<StringRef> Name = (*SymOrErr)->getName(*SymStrTabOrErr);
+  if (Name && !Name->empty())
+    return Name;
 
   // If the symbol name is empty use the section name.
-  if ((!Name || Name->empty()) && ESym->getType() == ELF::STT_SECTION) {
-    StringRef SecName;
-    Expected<section_iterator> Sec = getSymbolSection(Sym);
-    if (Sec && !(*Sec)->getName(SecName))
-      return SecName;
+  if ((*SymOrErr)->getType() == ELF::STT_SECTION) {
+    if (Expected<section_iterator> SecOrErr = getSymbolSection(Sym)) {
+      consumeError(Name.takeError());
+      return (*SecOrErr)->getName();
+    }
   }
   return Name;
 }
@@ -489,15 +532,18 @@
 
 template <class ELFT>
 uint64_t ELFObjectFile<ELFT>::getSymbolValueImpl(DataRefImpl Symb) const {
-  const Elf_Sym *ESym = getSymbol(Symb);
-  uint64_t Ret = ESym->st_value;
-  if (ESym->st_shndx == ELF::SHN_ABS)
+  Expected<const Elf_Sym *> SymOrErr = getSymbol(Symb);
+  if (!SymOrErr)
+    report_fatal_error(SymOrErr.takeError());
+
+  uint64_t Ret = (*SymOrErr)->st_value;
+  if ((*SymOrErr)->st_shndx == ELF::SHN_ABS)
     return Ret;
 
-  const Elf_Ehdr *Header = EF.getHeader();
+  const Elf_Ehdr &Header = EF.getHeader();
   // Clear the ARM/Thumb or microMIPS indicator flag.
-  if ((Header->e_machine == ELF::EM_ARM || Header->e_machine == ELF::EM_MIPS) &&
-      ESym->getType() == ELF::STT_FUNC)
+  if ((Header.e_machine == ELF::EM_ARM || Header.e_machine == ELF::EM_MIPS) &&
+      (*SymOrErr)->getType() == ELF::STT_FUNC)
     Ret &= ~1;
 
   return Ret;
@@ -506,23 +552,40 @@
 template <class ELFT>
 Expected<uint64_t>
 ELFObjectFile<ELFT>::getSymbolAddress(DataRefImpl Symb) const {
-  uint64_t Result = getSymbolValue(Symb);
-  const Elf_Sym *ESym = getSymbol(Symb);
-  switch (ESym->st_shndx) {
+  Expected<uint64_t> SymbolValueOrErr = getSymbolValue(Symb);
+  if (!SymbolValueOrErr)
+    // TODO: Test this error.
+    return SymbolValueOrErr.takeError();
+
+  uint64_t Result = *SymbolValueOrErr;
+  Expected<const Elf_Sym *> SymOrErr = getSymbol(Symb);
+  if (!SymOrErr)
+    return SymOrErr.takeError();
+
+  switch ((*SymOrErr)->st_shndx) {
   case ELF::SHN_COMMON:
   case ELF::SHN_UNDEF:
   case ELF::SHN_ABS:
     return Result;
   }
 
-  const Elf_Ehdr *Header = EF.getHeader();
   auto SymTabOrErr = EF.getSection(Symb.d.a);
   if (!SymTabOrErr)
     return SymTabOrErr.takeError();
-  const Elf_Shdr *SymTab = *SymTabOrErr;
 
-  if (Header->e_type == ELF::ET_REL) {
-    auto SectionOrErr = EF.getSection(ESym, SymTab, ShndxTable);
+  if (EF.getHeader().e_type == ELF::ET_REL) {
+    ArrayRef<Elf_Word> ShndxTable;
+    if (DotSymtabShndxSec) {
+      // TODO: Test this error.
+      if (Expected<ArrayRef<Elf_Word>> ShndxTableOrErr =
+              EF.getSHNDXTable(*DotSymtabShndxSec))
+        ShndxTable = *ShndxTableOrErr;
+      else
+        return ShndxTableOrErr.takeError();
+    }
+
+    Expected<const Elf_Shdr *> SectionOrErr =
+        EF.getSection(**SymOrErr, *SymTabOrErr, ShndxTable);
     if (!SectionOrErr)
       return SectionOrErr.takeError();
     const Elf_Shdr *Section = *SectionOrErr;
@@ -535,52 +598,68 @@
 
 template <class ELFT>
 uint32_t ELFObjectFile<ELFT>::getSymbolAlignment(DataRefImpl Symb) const {
-  const Elf_Sym *Sym = getSymbol(Symb);
-  if (Sym->st_shndx == ELF::SHN_COMMON)
-    return Sym->st_value;
+  Expected<const Elf_Sym *> SymOrErr = getSymbol(Symb);
+  if (!SymOrErr)
+    report_fatal_error(SymOrErr.takeError());
+  if ((*SymOrErr)->st_shndx == ELF::SHN_COMMON)
+    return (*SymOrErr)->st_value;
   return 0;
 }
 
 template <class ELFT>
 uint16_t ELFObjectFile<ELFT>::getEMachine() const {
-  return EF.getHeader()->e_machine;
+  return EF.getHeader().e_machine;
 }
 
 template <class ELFT> uint16_t ELFObjectFile<ELFT>::getEType() const {
-  return EF.getHeader()->e_type;
+  return EF.getHeader().e_type;
 }
 
 template <class ELFT>
 uint64_t ELFObjectFile<ELFT>::getSymbolSize(DataRefImpl Sym) const {
-  return getSymbol(Sym)->st_size;
+  Expected<const Elf_Sym *> SymOrErr = getSymbol(Sym);
+  if (!SymOrErr)
+    report_fatal_error(SymOrErr.takeError());
+  return (*SymOrErr)->st_size;
 }
 
 template <class ELFT>
 uint64_t ELFObjectFile<ELFT>::getCommonSymbolSizeImpl(DataRefImpl Symb) const {
-  return getSymbol(Symb)->st_size;
+  return getSymbolSize(Symb);
 }
 
 template <class ELFT>
 uint8_t ELFObjectFile<ELFT>::getSymbolBinding(DataRefImpl Symb) const {
-  return getSymbol(Symb)->getBinding();
+  Expected<const Elf_Sym *> SymOrErr = getSymbol(Symb);
+  if (!SymOrErr)
+    report_fatal_error(SymOrErr.takeError());
+  return (*SymOrErr)->getBinding();
 }
 
 template <class ELFT>
 uint8_t ELFObjectFile<ELFT>::getSymbolOther(DataRefImpl Symb) const {
-  return getSymbol(Symb)->st_other;
+  Expected<const Elf_Sym *> SymOrErr = getSymbol(Symb);
+  if (!SymOrErr)
+    report_fatal_error(SymOrErr.takeError());
+  return (*SymOrErr)->st_other;
 }
 
 template <class ELFT>
 uint8_t ELFObjectFile<ELFT>::getSymbolELFType(DataRefImpl Symb) const {
-  return getSymbol(Symb)->getType();
+  Expected<const Elf_Sym *> SymOrErr = getSymbol(Symb);
+  if (!SymOrErr)
+    report_fatal_error(SymOrErr.takeError());
+  return (*SymOrErr)->getType();
 }
 
 template <class ELFT>
 Expected<SymbolRef::Type>
 ELFObjectFile<ELFT>::getSymbolType(DataRefImpl Symb) const {
-  const Elf_Sym *ESym = getSymbol(Symb);
+  Expected<const Elf_Sym *> SymOrErr = getSymbol(Symb);
+  if (!SymOrErr)
+    return SymOrErr.takeError();
 
-  switch (ESym->getType()) {
+  switch ((*SymOrErr)->getType()) {
   case ELF::STT_NOTYPE:
     return SymbolRef::ST_Unknown;
   case ELF::STT_SECTION:
@@ -599,9 +678,12 @@
 }
 
 template <class ELFT>
-uint32_t ELFObjectFile<ELFT>::getSymbolFlags(DataRefImpl Sym) const {
-  const Elf_Sym *ESym = getSymbol(Sym);
+Expected<uint32_t> ELFObjectFile<ELFT>::getSymbolFlags(DataRefImpl Sym) const {
+  Expected<const Elf_Sym *> SymOrErr = getSymbol(Sym);
+  if (!SymOrErr)
+    return SymOrErr.takeError();
 
+  const Elf_Sym *ESym = *SymOrErr;
   uint32_t Result = SymbolRef::SF_None;
 
   if (ESym->getBinding() != ELF::STB_LOCAL)
@@ -616,14 +698,25 @@
   if (ESym->getType() == ELF::STT_FILE || ESym->getType() == ELF::STT_SECTION)
     Result |= SymbolRef::SF_FormatSpecific;
 
-  auto DotSymtabSecSyms = EF.symbols(DotSymtabSec);
-  if (DotSymtabSecSyms && ESym == (*DotSymtabSecSyms).begin())
-    Result |= SymbolRef::SF_FormatSpecific;
-  auto DotDynSymSecSyms = EF.symbols(DotDynSymSec);
-  if (DotDynSymSecSyms && ESym == (*DotDynSymSecSyms).begin())
-    Result |= SymbolRef::SF_FormatSpecific;
+  if (Expected<typename ELFT::SymRange> SymbolsOrErr =
+          EF.symbols(DotSymtabSec)) {
+    // Set the SF_FormatSpecific flag for the 0-index null symbol.
+    if (ESym == SymbolsOrErr->begin())
+      Result |= SymbolRef::SF_FormatSpecific;
+  } else
+    // TODO: Test this error.
+    return SymbolsOrErr.takeError();
 
-  if (EF.getHeader()->e_machine == ELF::EM_ARM) {
+  if (Expected<typename ELFT::SymRange> SymbolsOrErr =
+          EF.symbols(DotDynSymSec)) {
+    // Set the SF_FormatSpecific flag for the 0-index null symbol.
+    if (ESym == SymbolsOrErr->begin())
+      Result |= SymbolRef::SF_FormatSpecific;
+  } else
+    // TODO: Test this error.
+    return SymbolsOrErr.takeError();
+
+  if (EF.getHeader().e_machine == ELF::EM_ARM) {
     if (Expected<StringRef> NameOrErr = getSymbolName(Sym)) {
       StringRef Name = *NameOrErr;
       if (Name.startswith("$d") || Name.startswith("$t") ||
@@ -656,7 +749,17 @@
 Expected<section_iterator>
 ELFObjectFile<ELFT>::getSymbolSection(const Elf_Sym *ESym,
                                       const Elf_Shdr *SymTab) const {
-  auto ESecOrErr = EF.getSection(ESym, SymTab, ShndxTable);
+  ArrayRef<Elf_Word> ShndxTable;
+  if (DotSymtabShndxSec) {
+    // TODO: Test this error.
+    Expected<ArrayRef<Elf_Word>> ShndxTableOrErr =
+        EF.getSHNDXTable(*DotSymtabShndxSec);
+    if (!ShndxTableOrErr)
+      return ShndxTableOrErr.takeError();
+    ShndxTable = *ShndxTableOrErr;
+  }
+
+  auto ESecOrErr = EF.getSection(*ESym, SymTab, ShndxTable);
   if (!ESecOrErr)
     return ESecOrErr.takeError();
 
@@ -672,12 +775,14 @@
 template <class ELFT>
 Expected<section_iterator>
 ELFObjectFile<ELFT>::getSymbolSection(DataRefImpl Symb) const {
-  const Elf_Sym *Sym = getSymbol(Symb);
+  Expected<const Elf_Sym *> SymOrErr = getSymbol(Symb);
+  if (!SymOrErr)
+    return SymOrErr.takeError();
+
   auto SymTabOrErr = EF.getSection(Symb.d.a);
   if (!SymTabOrErr)
     return SymTabOrErr.takeError();
-  const Elf_Shdr *SymTab = *SymTabOrErr;
-  return getSymbolSection(Sym, SymTab);
+  return getSymbolSection(*SymOrErr, *SymTabOrErr);
 }
 
 template <class ELFT>
@@ -688,7 +793,7 @@
 
 template <class ELFT>
 Expected<StringRef> ELFObjectFile<ELFT>::getSectionName(DataRefImpl Sec) const {
-  return EF.getSectionName(&*getSection(Sec));
+  return EF.getSectionName(*getSection(Sec));
 }
 
 template <class ELFT>
@@ -716,10 +821,12 @@
 Expected<ArrayRef<uint8_t>>
 ELFObjectFile<ELFT>::getSectionContents(DataRefImpl Sec) const {
   const Elf_Shdr *EShdr = getSection(Sec);
-  if (std::error_code EC =
+  if (EShdr->sh_type == ELF::SHT_NOBITS)
+    return makeArrayRef((const uint8_t *)base(), 0);
+  if (Error E =
           checkOffset(getMemoryBufferRef(),
                       (uintptr_t)base() + EShdr->sh_offset, EShdr->sh_size))
-    return errorCodeToError(EC);
+    return std::move(E);
   return makeArrayRef((const uint8_t *)base() + EShdr->sh_offset,
                       EShdr->sh_size);
 }
@@ -803,6 +910,12 @@
 }
 
 template <class ELFT>
+bool ELFObjectFile<ELFT>::isDebugSection(StringRef SectionName) const {
+  return SectionName.startswith(".debug") ||
+         SectionName.startswith(".zdebug") || SectionName == ".gdb_index";
+}
+
+template <class ELFT>
 relocation_iterator
 ELFObjectFile<ELFT>::section_rel_begin(DataRefImpl Sec) const {
   DataRefImpl RelData;
@@ -810,7 +923,7 @@
   if (!SectionsOrErr)
     return relocation_iterator(RelocationRef());
   uintptr_t SHT = reinterpret_cast<uintptr_t>((*SectionsOrErr).begin());
-  RelData.d.a = (Sec.p - SHT) / EF.getHeader()->e_shentsize;
+  RelData.d.a = (Sec.p - SHT) / EF.getHeader().e_shentsize;
   RelData.d.b = 0;
   return relocation_iterator(RelocationRef(RelData, this));
 }
@@ -835,9 +948,9 @@
 }
 
 template <class ELFT>
-section_iterator
+Expected<section_iterator>
 ELFObjectFile<ELFT>::getRelocatedSection(DataRefImpl Sec) const {
-  if (EF.getHeader()->e_type != ELF::ET_REL)
+  if (EF.getHeader().e_type != ELF::ET_REL)
     return section_end();
 
   const Elf_Shdr *EShdr = getSection(Sec);
@@ -845,10 +958,10 @@
   if (Type != ELF::SHT_REL && Type != ELF::SHT_RELA)
     return section_end();
 
-  auto R = EF.getSection(EShdr->sh_info);
-  if (!R)
-    report_fatal_error(errorToErrorCode(R.takeError()).message());
-  return section_iterator(SectionRef(toDRI(*R), this));
+  Expected<const Elf_Shdr *> SecOrErr = EF.getSection(EShdr->sh_info);
+  if (!SecOrErr)
+    return SecOrErr.takeError();
+  return section_iterator(SectionRef(toDRI(*SecOrErr), this));
 }
 
 // Relocations
@@ -896,7 +1009,7 @@
 
 template <class ELFT>
 StringRef ELFObjectFile<ELFT>::getRelocationTypeName(uint32_t Type) const {
-  return getELFRelocationTypeName(EF.getHeader()->e_machine, Type);
+  return getELFRelocationTypeName(EF.getHeader().e_machine, Type);
 }
 
 template <class ELFT>
@@ -936,59 +1049,34 @@
 
 template <class ELFT>
 Expected<ELFObjectFile<ELFT>>
-ELFObjectFile<ELFT>::create(MemoryBufferRef Object) {
+ELFObjectFile<ELFT>::create(MemoryBufferRef Object, bool InitContent) {
   auto EFOrErr = ELFFile<ELFT>::create(Object.getBuffer());
   if (Error E = EFOrErr.takeError())
     return std::move(E);
-  auto EF = std::move(*EFOrErr);
 
-  auto SectionsOrErr = EF.sections();
-  if (!SectionsOrErr)
-    return SectionsOrErr.takeError();
-
-  const Elf_Shdr *DotDynSymSec = nullptr;
-  const Elf_Shdr *DotSymtabSec = nullptr;
-  ArrayRef<Elf_Word> ShndxTable;
-  for (const Elf_Shdr &Sec : *SectionsOrErr) {
-    switch (Sec.sh_type) {
-    case ELF::SHT_DYNSYM: {
-      if (!DotDynSymSec)
-        DotDynSymSec = &Sec;
-      break;
-    }
-    case ELF::SHT_SYMTAB: {
-      if (!DotSymtabSec)
-        DotSymtabSec = &Sec;
-      break;
-    }
-    case ELF::SHT_SYMTAB_SHNDX: {
-      auto TableOrErr = EF.getSHNDXTable(Sec);
-      if (!TableOrErr)
-        return TableOrErr.takeError();
-      ShndxTable = *TableOrErr;
-      break;
-    }
-    }
-  }
-  return ELFObjectFile<ELFT>(Object, EF, DotDynSymSec, DotSymtabSec,
-                             ShndxTable);
+  ELFObjectFile<ELFT> Obj = {Object, std::move(*EFOrErr), nullptr, nullptr,
+                             nullptr};
+  if (InitContent)
+    if (Error E = Obj.initContent())
+      return std::move(E);
+  return std::move(Obj);
 }
 
 template <class ELFT>
 ELFObjectFile<ELFT>::ELFObjectFile(MemoryBufferRef Object, ELFFile<ELFT> EF,
                                    const Elf_Shdr *DotDynSymSec,
                                    const Elf_Shdr *DotSymtabSec,
-                                   ArrayRef<Elf_Word> ShndxTable)
+                                   const Elf_Shdr *DotSymtabShndx)
     : ELFObjectFileBase(
           getELFType(ELFT::TargetEndianness == support::little, ELFT::Is64Bits),
           Object),
       EF(EF), DotDynSymSec(DotDynSymSec), DotSymtabSec(DotSymtabSec),
-      ShndxTable(ShndxTable) {}
+      DotSymtabShndxSec(DotSymtabShndx) {}
 
 template <class ELFT>
 ELFObjectFile<ELFT>::ELFObjectFile(ELFObjectFile<ELFT> &&Other)
     : ELFObjectFile(Other.Data, Other.EF, Other.DotDynSymSec,
-                    Other.DotSymtabSec, Other.ShndxTable) {}
+                    Other.DotSymtabSec, Other.DotSymtabShndxSec) {}
 
 template <class ELFT>
 basic_symbol_iterator ELFObjectFile<ELFT>::symbol_begin() const {
@@ -1009,8 +1097,12 @@
 
 template <class ELFT>
 elf_symbol_iterator ELFObjectFile<ELFT>::dynamic_symbol_begin() const {
-  DataRefImpl Sym = toDRI(DotDynSymSec, 0);
-  return symbol_iterator(SymbolRef(Sym, this));
+  if (!DotDynSymSec || DotDynSymSec->sh_size < sizeof(Elf_Sym))
+    // Ignore errors here where the dynsym is empty or sh_size less than the
+    // size of one symbol. These should be handled elsewhere.
+    return symbol_iterator(SymbolRef(toDRI(DotDynSymSec, 0), this));
+  // Skip 0-index NULL symbol.
+  return symbol_iterator(SymbolRef(toDRI(DotDynSymSec, 1), this));
 }
 
 template <class ELFT>
@@ -1046,63 +1138,67 @@
 template <class ELFT>
 StringRef ELFObjectFile<ELFT>::getFileFormatName() const {
   bool IsLittleEndian = ELFT::TargetEndianness == support::little;
-  switch (EF.getHeader()->e_ident[ELF::EI_CLASS]) {
+  switch (EF.getHeader().e_ident[ELF::EI_CLASS]) {
   case ELF::ELFCLASS32:
-    switch (EF.getHeader()->e_machine) {
+    switch (EF.getHeader().e_machine) {
     case ELF::EM_386:
-      return "ELF32-i386";
+      return "elf32-i386";
     case ELF::EM_IAMCU:
-      return "ELF32-iamcu";
+      return "elf32-iamcu";
     case ELF::EM_X86_64:
-      return "ELF32-x86-64";
+      return "elf32-x86-64";
     case ELF::EM_ARM:
-      return (IsLittleEndian ? "ELF32-arm-little" : "ELF32-arm-big");
+      return (IsLittleEndian ? "elf32-littlearm" : "elf32-bigarm");
     case ELF::EM_AVR:
-      return "ELF32-avr";
+      return "elf32-avr";
     case ELF::EM_HEXAGON:
-      return "ELF32-hexagon";
+      return "elf32-hexagon";
     case ELF::EM_LANAI:
-      return "ELF32-lanai";
+      return "elf32-lanai";
     case ELF::EM_MIPS:
-      return "ELF32-mips";
+      return "elf32-mips";
     case ELF::EM_MSP430:
-      return "ELF32-msp430";
+      return "elf32-msp430";
     case ELF::EM_PPC:
-      return "ELF32-ppc";
+      return (IsLittleEndian ? "elf32-powerpcle" : "elf32-powerpc");
     case ELF::EM_RISCV:
-      return "ELF32-riscv";
+      return "elf32-littleriscv";
+    case ELF::EM_CSKY:
+      return "elf32-csky";
     case ELF::EM_SPARC:
     case ELF::EM_SPARC32PLUS:
-      return "ELF32-sparc";
+      return "elf32-sparc";
     case ELF::EM_AMDGPU:
-      return "ELF32-amdgpu";
+      return "elf32-amdgpu";
     default:
-      return "ELF32-unknown";
+      return "elf32-unknown";
     }
   case ELF::ELFCLASS64:
-    switch (EF.getHeader()->e_machine) {
+    switch (EF.getHeader().e_machine) {
     case ELF::EM_386:
-      return "ELF64-i386";
+      return "elf64-i386";
     case ELF::EM_X86_64:
-      return "ELF64-x86-64";
+      return "elf64-x86-64";
     case ELF::EM_AARCH64:
-      return (IsLittleEndian ? "ELF64-aarch64-little" : "ELF64-aarch64-big");
+      return (IsLittleEndian ? "elf64-littleaarch64" : "elf64-bigaarch64");
     case ELF::EM_PPC64:
-      return "ELF64-ppc64";
+      return (IsLittleEndian ? "elf64-powerpcle" : "elf64-powerpc");
     case ELF::EM_RISCV:
-      return "ELF64-riscv";
+      return "elf64-littleriscv";
     case ELF::EM_S390:
-      return "ELF64-s390";
+      return "elf64-s390";
     case ELF::EM_SPARCV9:
-      return "ELF64-sparc";
+      return "elf64-sparc";
     case ELF::EM_MIPS:
-      return "ELF64-mips";
+      return "elf64-mips";
     case ELF::EM_AMDGPU:
-      return "ELF64-amdgpu";
+      return "elf64-amdgpu";
     case ELF::EM_BPF:
-      return "ELF64-BPF";
+      return "elf64-bpf";
+    case ELF::EM_VE:
+      return "elf64-ve";
     default:
-      return "ELF64-unknown";
+      return "elf64-unknown";
     }
   default:
     // FIXME: Proper error handling.
@@ -1112,7 +1208,7 @@
 
 template <class ELFT> Triple::ArchType ELFObjectFile<ELFT>::getArch() const {
   bool IsLittleEndian = ELFT::TargetEndianness == support::little;
-  switch (EF.getHeader()->e_machine) {
+  switch (EF.getHeader().e_machine) {
   case ELF::EM_386:
   case ELF::EM_IAMCU:
     return Triple::x86;
@@ -1129,7 +1225,7 @@
   case ELF::EM_LANAI:
     return Triple::lanai;
   case ELF::EM_MIPS:
-    switch (EF.getHeader()->e_ident[ELF::EI_CLASS]) {
+    switch (EF.getHeader().e_ident[ELF::EI_CLASS]) {
     case ELF::ELFCLASS32:
       return IsLittleEndian ? Triple::mipsel : Triple::mips;
     case ELF::ELFCLASS64:
@@ -1140,11 +1236,11 @@
   case ELF::EM_MSP430:
     return Triple::msp430;
   case ELF::EM_PPC:
-    return Triple::ppc;
+    return IsLittleEndian ? Triple::ppcle : Triple::ppc;
   case ELF::EM_PPC64:
     return IsLittleEndian ? Triple::ppc64le : Triple::ppc64;
   case ELF::EM_RISCV:
-    switch (EF.getHeader()->e_ident[ELF::EI_CLASS]) {
+    switch (EF.getHeader().e_ident[ELF::EI_CLASS]) {
     case ELF::ELFCLASS32:
       return Triple::riscv32;
     case ELF::ELFCLASS64:
@@ -1165,7 +1261,7 @@
     if (!IsLittleEndian)
       return Triple::UnknownArch;
 
-    unsigned MACH = EF.getHeader()->e_flags & ELF::EF_AMDGPU_MACH;
+    unsigned MACH = EF.getHeader().e_flags & ELF::EF_AMDGPU_MACH;
     if (MACH >= ELF::EF_AMDGPU_MACH_R600_FIRST &&
         MACH <= ELF::EF_AMDGPU_MACH_R600_LAST)
       return Triple::r600;
@@ -1179,6 +1275,10 @@
   case ELF::EM_BPF:
     return IsLittleEndian ? Triple::bpfel : Triple::bpfeb;
 
+  case ELF::EM_VE:
+    return Triple::ve;
+  case ELF::EM_CSKY:
+    return Triple::csky;
   default:
     return Triple::UnknownArch;
   }
@@ -1186,7 +1286,7 @@
 
 template <class ELFT>
 Expected<uint64_t> ELFObjectFile<ELFT>::getStartAddress() const {
-  return EF.getHeader()->e_entry;
+  return EF.getHeader().e_entry;
 }
 
 template <class ELFT>
@@ -1196,7 +1296,7 @@
 }
 
 template <class ELFT> bool ELFObjectFile<ELFT>::isRelocatableObject() const {
-  return EF.getHeader()->e_type == ELF::ET_REL;
+  return EF.getHeader().e_type == ELF::ET_REL;
 }
 
 } // end namespace object
diff --git a/linux-x64/clang/include/llvm/Object/ELFTypes.h b/linux-x64/clang/include/llvm/Object/ELFTypes.h
index 5552208..f64e7c0 100644
--- a/linux-x64/clang/include/llvm/Object/ELFTypes.h
+++ b/linux-x64/clang/include/llvm/Object/ELFTypes.h
@@ -53,7 +53,7 @@
   static const endianness TargetEndianness = E;
   static const bool Is64Bits = Is64;
 
-  using uint = typename std::conditional<Is64, uint64_t, uint32_t>::type;
+  using uint = std::conditional_t<Is64, uint64_t, uint32_t>;
   using Ehdr = Elf_Ehdr_Impl<ELFType<E, Is64>>;
   using Shdr = Elf_Shdr_Impl<ELFType<E, Is64>>;
   using Sym = Elf_Sym_Impl<ELFType<E, Is64>>;
@@ -107,7 +107,34 @@
   using Elf_Word = typename ELFT::Word;                                        \
   using Elf_Sword = typename ELFT::Sword;                                      \
   using Elf_Xword = typename ELFT::Xword;                                      \
-  using Elf_Sxword = typename ELFT::Sxword;
+  using Elf_Sxword = typename ELFT::Sxword;                                    \
+  using uintX_t = typename ELFT::uint;                                         \
+  using Elf_Ehdr = typename ELFT::Ehdr;                                        \
+  using Elf_Shdr = typename ELFT::Shdr;                                        \
+  using Elf_Sym = typename ELFT::Sym;                                          \
+  using Elf_Dyn = typename ELFT::Dyn;                                          \
+  using Elf_Phdr = typename ELFT::Phdr;                                        \
+  using Elf_Rel = typename ELFT::Rel;                                          \
+  using Elf_Rela = typename ELFT::Rela;                                        \
+  using Elf_Relr = typename ELFT::Relr;                                        \
+  using Elf_Verdef = typename ELFT::Verdef;                                    \
+  using Elf_Verdaux = typename ELFT::Verdaux;                                  \
+  using Elf_Verneed = typename ELFT::Verneed;                                  \
+  using Elf_Vernaux = typename ELFT::Vernaux;                                  \
+  using Elf_Versym = typename ELFT::Versym;                                    \
+  using Elf_Hash = typename ELFT::Hash;                                        \
+  using Elf_GnuHash = typename ELFT::GnuHash;                                  \
+  using Elf_Nhdr = typename ELFT::Nhdr;                                        \
+  using Elf_Note = typename ELFT::Note;                                        \
+  using Elf_Note_Iterator = typename ELFT::NoteIterator;                       \
+  using Elf_CGProfile = typename ELFT::CGProfile;                              \
+  using Elf_Dyn_Range = typename ELFT::DynRange;                               \
+  using Elf_Shdr_Range = typename ELFT::ShdrRange;                             \
+  using Elf_Sym_Range = typename ELFT::SymRange;                               \
+  using Elf_Rel_Range = typename ELFT::RelRange;                               \
+  using Elf_Rela_Range = typename ELFT::RelaRange;                             \
+  using Elf_Relr_Range = typename ELFT::RelrRange;                             \
+  using Elf_Phdr_Range = typename ELFT::PhdrRange;                             \
 
 #define LLVM_ELF_COMMA ,
 #define LLVM_ELF_IMPORT_TYPES(E, W)                                            \
@@ -248,7 +275,11 @@
 Expected<StringRef> Elf_Sym_Impl<ELFT>::getName(StringRef StrTab) const {
   uint32_t Offset = this->st_name;
   if (Offset >= StrTab.size())
-    return errorCodeToError(object_error::parse_failed);
+    return createStringError(object_error::parse_failed,
+                             "st_name (0x%" PRIx32
+                             ") is past the end of the string table"
+                             " of size 0x%zx",
+                             Offset, StrTab.size());
   return StringRef(StrTab.data() + Offset);
 }
 
@@ -265,7 +296,6 @@
 template <class ELFT>
 struct Elf_Verdef_Impl {
   LLVM_ELF_IMPORT_TYPES_ELFT(ELFT)
-  using Elf_Verdaux = Elf_Verdaux_Impl<ELFT>;
   Elf_Half vd_version; // Version of this structure (e.g. VER_DEF_CURRENT)
   Elf_Half vd_flags;   // Bitwise flags (VER_DEF_*)
   Elf_Half vd_ndx;     // Version index, used in .gnu.version entries
@@ -342,10 +372,8 @@
 struct Elf_Dyn_Impl : Elf_Dyn_Base<ELFT> {
   using Elf_Dyn_Base<ELFT>::d_tag;
   using Elf_Dyn_Base<ELFT>::d_un;
-  using intX_t = typename std::conditional<ELFT::Is64Bits,
-                                           int64_t, int32_t>::type;
-  using uintX_t = typename std::conditional<ELFT::Is64Bits,
-                                            uint64_t, uint32_t>::type;
+  using intX_t = std::conditional_t<ELFT::Is64Bits, int64_t, int32_t>;
+  using uintX_t = std::conditional_t<ELFT::Is64Bits, uint64_t, uint32_t>;
   intX_t getTag() const { return d_tag; }
   uintX_t getVal() const { return d_un.d_val; }
   uintX_t getPtr() const { return d_un.d_ptr; }
@@ -537,6 +565,7 @@
   }
 
   ArrayRef<Elf_Word> values(unsigned DynamicSymCount) const {
+    assert(DynamicSymCount >= symndx);
     return ArrayRef<Elf_Word>(buckets().end(), DynamicSymCount - symndx);
   }
 };
@@ -613,6 +642,12 @@
         Nhdr.n_descsz);
   }
 
+  /// Get the note's descriptor as StringRef
+  StringRef getDescAsStringRef() const {
+    ArrayRef<uint8_t> Desc = getDesc();
+    return StringRef(reinterpret_cast<const char *>(Desc.data()), Desc.size());
+  }
+
   /// Get the note's type.
   Elf_Word getType() const { return Nhdr.n_type; }
 };
diff --git a/linux-x64/clang/include/llvm/Object/Error.h b/linux-x64/clang/include/llvm/Object/Error.h
index b7bbf06..0774418 100644
--- a/linux-x64/clang/include/llvm/Object/Error.h
+++ b/linux-x64/clang/include/llvm/Object/Error.h
@@ -13,11 +13,13 @@
 #ifndef LLVM_OBJECT_ERROR_H
 #define LLVM_OBJECT_ERROR_H
 
-#include "llvm/ADT/Twine.h"
 #include "llvm/Support/Error.h"
 #include <system_error>
 
 namespace llvm {
+
+class Twine;
+
 namespace object {
 
 class Binary;
@@ -49,7 +51,7 @@
 /// Currently inherits from ECError for easy interoperability with
 /// std::error_code, but this will be removed in the future.
 class BinaryError : public ErrorInfo<BinaryError, ECError> {
-  virtual void anchor();
+  void anchor() override;
 public:
   static char ID;
   BinaryError() {
@@ -65,8 +67,8 @@
 class GenericBinaryError : public ErrorInfo<GenericBinaryError, BinaryError> {
 public:
   static char ID;
-  GenericBinaryError(Twine Msg);
-  GenericBinaryError(Twine Msg, object_error ECOverride);
+  GenericBinaryError(const Twine &Msg);
+  GenericBinaryError(const Twine &Msg, object_error ECOverride);
   const std::string &getMessage() const { return Msg; }
   void log(raw_ostream &OS) const override;
 private:
diff --git a/linux-x64/clang/include/llvm/Object/IRObjectFile.h b/linux-x64/clang/include/llvm/Object/IRObjectFile.h
index 08b92f1..338b194 100644
--- a/linux-x64/clang/include/llvm/Object/IRObjectFile.h
+++ b/linux-x64/clang/include/llvm/Object/IRObjectFile.h
@@ -38,7 +38,7 @@
   ~IRObjectFile() override;
   void moveSymbolNext(DataRefImpl &Symb) const override;
   Error printSymbolName(raw_ostream &OS, DataRefImpl Symb) const override;
-  uint32_t getSymbolFlags(DataRefImpl Symb) const override;
+  Expected<uint32_t> getSymbolFlags(DataRefImpl Symb) const override;
   basic_symbol_iterator symbol_begin() const override;
   basic_symbol_iterator symbol_end() const override;
 
diff --git a/linux-x64/clang/include/llvm/Object/IRSymtab.h b/linux-x64/clang/include/llvm/Object/IRSymtab.h
index 0bbfc93..4ee32fc 100644
--- a/linux-x64/clang/include/llvm/Object/IRSymtab.h
+++ b/linux-x64/clang/include/llvm/Object/IRSymtab.h
@@ -28,6 +28,7 @@
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/IR/GlobalValue.h"
 #include "llvm/Object/SymbolicFile.h"
+#include "llvm/Support/Allocator.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/Error.h"
 #include <cassert>
diff --git a/linux-x64/clang/include/llvm/Object/MachO.h b/linux-x64/clang/include/llvm/Object/MachO.h
index ca9512f..7eb0173 100644
--- a/linux-x64/clang/include/llvm/Object/MachO.h
+++ b/linux-x64/clang/include/llvm/Object/MachO.h
@@ -65,7 +65,7 @@
 /// ExportEntry encapsulates the current-state-of-the-walk used when doing a
 /// non-recursive walk of the trie data structure.  This allows you to iterate
 /// across all exported symbols using:
-///      Error Err;
+///      Error Err = Error::success();
 ///      for (const llvm::object::ExportEntry &AnExport : Obj->exports(&Err)) {
 ///      }
 ///      if (Err) { report error ...
@@ -160,7 +160,7 @@
 /// MachORebaseEntry encapsulates the current state in the decompression of
 /// rebasing opcodes. This allows you to iterate through the compressed table of
 /// rebasing using:
-///    Error Err;
+///    Error Err = Error::success();
 ///    for (const llvm::object::MachORebaseEntry &Entry : Obj->rebaseTable(&Err)) {
 ///    }
 ///    if (Err) { report error ...
@@ -204,7 +204,7 @@
 /// MachOBindEntry encapsulates the current state in the decompression of
 /// binding opcodes. This allows you to iterate through the compressed table of
 /// bindings using:
-///    Error Err;
+///    Error Err = Error::success();
 ///    for (const llvm::object::MachOBindEntry &Entry : Obj->bindTable(&Err)) {
 ///    }
 ///    if (Err) { report error ...
@@ -287,7 +287,7 @@
   uint32_t getSymbolAlignment(DataRefImpl Symb) const override;
   uint64_t getCommonSymbolSizeImpl(DataRefImpl Symb) const override;
   Expected<SymbolRef::Type> getSymbolType(DataRefImpl Symb) const override;
-  uint32_t getSymbolFlags(DataRefImpl Symb) const override;
+  Expected<uint32_t> getSymbolFlags(DataRefImpl Symb) const override;
   Expected<section_iterator> getSymbolSection(DataRefImpl Symb) const override;
   unsigned getSymbolSectionID(SymbolRef Symb) const;
   unsigned getSectionID(SectionRef Sec) const;
@@ -297,6 +297,7 @@
   uint64_t getSectionAddress(DataRefImpl Sec) const override;
   uint64_t getSectionIndex(DataRefImpl Sec) const override;
   uint64_t getSectionSize(DataRefImpl Sec) const override;
+  ArrayRef<uint8_t> getSectionContents(uint32_t Offset, uint64_t Size) const;
   Expected<ArrayRef<uint8_t>>
   getSectionContents(DataRefImpl Sec) const override;
   uint64_t getSectionAlignment(DataRefImpl Sec) const override;
@@ -308,6 +309,7 @@
   bool isSectionBSS(DataRefImpl Sec) const override;
   bool isSectionVirtual(DataRefImpl Sec) const override;
   bool isSectionBitcode(DataRefImpl Sec) const override;
+  bool isDebugSection(StringRef SectionName) const override;
 
   /// When dsymutil generates the companion file, it strips all unnecessary
   /// sections (e.g. everything in the _TEXT segment) by omitting their body
@@ -566,7 +568,7 @@
   static StringRef guessLibraryShortName(StringRef Name, bool &isFramework,
                                          StringRef &Suffix);
 
-  static Triple::ArchType getArch(uint32_t CPUType);
+  static Triple::ArchType getArch(uint32_t CPUType, uint32_t CPUSubType);
   static Triple getArchTriple(uint32_t CPUType, uint32_t CPUSubType,
                               const char **McpuDefault = nullptr,
                               const char **ArchFlag = nullptr);
@@ -613,6 +615,7 @@
     case MachO::PLATFORM_IOSSIMULATOR: return "iossimulator";
     case MachO::PLATFORM_TVOSSIMULATOR: return "tvossimulator";
     case MachO::PLATFORM_WATCHOSSIMULATOR: return "watchossimulator";
+    case MachO::PLATFORM_DRIVERKIT: return "driverkit";
     default:
       std::string ret;
       raw_string_ostream ss(ret);
@@ -643,7 +646,7 @@
     Version = utostr(major) + "." + utostr(minor);
     if (update != 0)
       Version += "." + utostr(update);
-    return Version.str();
+    return std::string(std::string(Version.str()));
   }
 
 private:
diff --git a/linux-x64/clang/include/llvm/Object/MachOUniversal.h b/linux-x64/clang/include/llvm/Object/MachOUniversal.h
index 5bf724f..9bcacb5 100644
--- a/linux-x64/clang/include/llvm/Object/MachOUniversal.h
+++ b/linux-x64/clang/include/llvm/Object/MachOUniversal.h
@@ -22,8 +22,11 @@
 
 namespace llvm {
 class StringRef;
+class Module;
+class LLVMContext;
 
 namespace object {
+class IRObjectFile;
 
 class MachOUniversalBinary : public Binary {
   virtual void anchor();
@@ -31,6 +34,8 @@
   uint32_t Magic;
   uint32_t NumberOfObjects;
 public:
+  static constexpr uint32_t MaxSectionAlignment = 15; /* 2**15 or 0x8000 */
+
   class ObjectForArch {
     const MachOUniversalBinary *Parent;
     /// Index of object in the universal binary.
@@ -64,13 +69,13 @@
       else // Parent->getMagic() == MachO::FAT_MAGIC_64
         return Header64.cpusubtype;
     }
-    uint32_t getOffset() const {
+    uint64_t getOffset() const {
       if (Parent->getMagic() == MachO::FAT_MAGIC)
         return Header.offset;
       else // Parent->getMagic() == MachO::FAT_MAGIC_64
         return Header64.offset;
     }
-    uint32_t getSize() const {
+    uint64_t getSize() const {
       if (Parent->getMagic() == MachO::FAT_MAGIC)
         return Header.size;
       else // Parent->getMagic() == MachO::FAT_MAGIC_64
@@ -88,28 +93,19 @@
       else // Parent->getMagic() == MachO::FAT_MAGIC_64
         return Header64.reserved;
     }
+    Triple getTriple() const {
+      return MachOObjectFile::getArchTriple(getCPUType(), getCPUSubType());
+    }
     std::string getArchFlagName() const {
       const char *McpuDefault, *ArchFlag;
-      if (Parent->getMagic() == MachO::FAT_MAGIC) {
-        Triple T =
-            MachOObjectFile::getArchTriple(Header.cputype, Header.cpusubtype,
-                                           &McpuDefault, &ArchFlag);
-      } else { // Parent->getMagic() == MachO::FAT_MAGIC_64
-        Triple T =
-            MachOObjectFile::getArchTriple(Header64.cputype,
-                                           Header64.cpusubtype,
-                                           &McpuDefault, &ArchFlag);
-      }
-      if (ArchFlag) {
-        std::string ArchFlagName(ArchFlag);
-        return ArchFlagName;
-      } else {
-        std::string ArchFlagName("");
-        return ArchFlagName;
-      }
+      MachOObjectFile::getArchTriple(getCPUType(), getCPUSubType(),
+                                     &McpuDefault, &ArchFlag);
+      return ArchFlag ? ArchFlag : std::string();
     }
 
     Expected<std::unique_ptr<MachOObjectFile>> getAsObjectFile() const;
+    Expected<std::unique_ptr<IRObjectFile>>
+    getAsIRObject(LLVMContext &Ctx) const;
 
     Expected<std::unique_ptr<Archive>> getAsArchive() const;
   };
@@ -157,8 +153,17 @@
     return V->isMachOUniversalBinary();
   }
 
-  Expected<std::unique_ptr<MachOObjectFile>>
+  Expected<ObjectForArch>
   getObjectForArch(StringRef ArchName) const;
+
+  Expected<std::unique_ptr<MachOObjectFile>>
+  getMachOObjectForArch(StringRef ArchName) const;
+
+  Expected<std::unique_ptr<IRObjectFile>>
+  getIRObjectForArch(StringRef ArchName, LLVMContext &Ctx) const;
+
+  Expected<std::unique_ptr<Archive>>
+  getArchiveForArch(StringRef ArchName) const;
 };
 
 }
diff --git a/linux-x64/clang/include/llvm/Object/MachOUniversalWriter.h b/linux-x64/clang/include/llvm/Object/MachOUniversalWriter.h
new file mode 100644
index 0000000..cdfedcf
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Object/MachOUniversalWriter.h
@@ -0,0 +1,102 @@
+//===- MachOUniversalWriter.h - MachO universal binary writer----*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Declares the Slice class and writeUniversalBinary function for writing a
+// MachO universal binary file.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_OBJECT_MACHOUNIVERSALWRITER_H
+#define LLVM_OBJECT_MACHOUNIVERSALWRITER_H
+
+#include "llvm/Object/Archive.h"
+#include "llvm/Object/Binary.h"
+#include "llvm/Object/MachO.h"
+
+namespace llvm {
+class LLVMContext;
+
+namespace object {
+class IRObjectFile;
+
+class Slice {
+  const Binary *B;
+  uint32_t CPUType;
+  uint32_t CPUSubType;
+  std::string ArchName;
+
+  // P2Alignment field stores slice alignment values from universal
+  // binaries. This is also needed to order the slices so the total
+  // file size can be calculated before creating the output buffer.
+  uint32_t P2Alignment;
+
+  Slice(const IRObjectFile &IRO, uint32_t CPUType, uint32_t CPUSubType,
+        std::string ArchName, uint32_t Align);
+
+public:
+  explicit Slice(const MachOObjectFile &O);
+
+  Slice(const MachOObjectFile &O, uint32_t Align);
+
+  /// This constructor takes pre-specified \param CPUType , \param CPUSubType ,
+  /// \param ArchName , \param Align instead of inferring them from the archive
+  /// members.
+  Slice(const Archive &A, uint32_t CPUType, uint32_t CPUSubType,
+        std::string ArchName, uint32_t Align);
+
+  static Expected<Slice> create(const Archive &A,
+                                LLVMContext *LLVMCtx = nullptr);
+
+  static Expected<Slice> create(const IRObjectFile &IRO, uint32_t Align);
+
+  void setP2Alignment(uint32_t Align) { P2Alignment = Align; }
+
+  const Binary *getBinary() const { return B; }
+
+  uint32_t getCPUType() const { return CPUType; }
+
+  uint32_t getCPUSubType() const { return CPUSubType; }
+
+  uint32_t getP2Alignment() const { return P2Alignment; }
+
+  uint64_t getCPUID() const {
+    return static_cast<uint64_t>(CPUType) << 32 | CPUSubType;
+  }
+
+  std::string getArchString() const {
+    if (!ArchName.empty())
+      return ArchName;
+    return ("unknown(" + Twine(CPUType) + "," +
+            Twine(CPUSubType & ~MachO::CPU_SUBTYPE_MASK) + ")")
+        .str();
+  }
+
+  friend bool operator<(const Slice &Lhs, const Slice &Rhs) {
+    if (Lhs.CPUType == Rhs.CPUType)
+      return Lhs.CPUSubType < Rhs.CPUSubType;
+    // force arm64-family to follow after all other slices for
+    // compatibility with cctools lipo
+    if (Lhs.CPUType == MachO::CPU_TYPE_ARM64)
+      return false;
+    if (Rhs.CPUType == MachO::CPU_TYPE_ARM64)
+      return true;
+    // Sort by alignment to minimize file size
+    return Lhs.P2Alignment < Rhs.P2Alignment;
+  }
+};
+
+Error writeUniversalBinary(ArrayRef<Slice> Slices, StringRef OutputFileName);
+
+Expected<std::unique_ptr<MemoryBuffer>>
+writeUniversalBinaryToBuffer(ArrayRef<Slice> Slices);
+
+} // end namespace object
+
+} // end namespace llvm
+
+#endif // LLVM_OBJECT_MACHOUNIVERSALWRITER_H
diff --git a/linux-x64/clang/include/llvm/Object/Minidump.h b/linux-x64/clang/include/llvm/Object/Minidump.h
index 470008d..4429493 100644
--- a/linux-x64/clang/include/llvm/Object/Minidump.h
+++ b/linux-x64/clang/include/llvm/Object/Minidump.h
@@ -11,6 +11,7 @@
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/StringExtras.h"
+#include "llvm/ADT/iterator.h"
 #include "llvm/BinaryFormat/Minidump.h"
 #include "llvm/Object/Binary.h"
 #include "llvm/Support/Error.h"
@@ -80,16 +81,65 @@
     return getListStream<minidump::Thread>(minidump::StreamType::ThreadList);
   }
 
-  /// Returns the list of memory ranges embedded in the MemoryList stream. An
-  /// error is returned if the file does not contain this stream, or if the
-  /// stream is not large enough to contain the number of memory descriptors
-  /// declared in the stream header. The consistency of the MemoryDescriptor
-  /// entries themselves is not checked in any way.
+  /// Returns the contents of the Exception stream.  An error is returned if the
+  /// file does not contain this stream, or the stream is smaller than the size
+  /// of the ExceptionStream structure.  The internal consistency of the stream
+  /// is not checked in any way.
+  Expected<const minidump::ExceptionStream &> getExceptionStream() const {
+    return getStream<minidump::ExceptionStream>(
+        minidump::StreamType::Exception);
+  }
+
+  /// Returns the list of descriptors embedded in the MemoryList stream. The
+  /// descriptors provide the content of interesting regions of memory at the
+  /// time the minidump was taken. An error is returned if the file does not
+  /// contain this stream, or if the stream is not large enough to contain the
+  /// number of memory descriptors declared in the stream header. The
+  /// consistency of the MemoryDescriptor entries themselves is not checked in
+  /// any way.
   Expected<ArrayRef<minidump::MemoryDescriptor>> getMemoryList() const {
     return getListStream<minidump::MemoryDescriptor>(
         minidump::StreamType::MemoryList);
   }
 
+  class MemoryInfoIterator
+      : public iterator_facade_base<MemoryInfoIterator,
+                                    std::forward_iterator_tag,
+                                    minidump::MemoryInfo> {
+  public:
+    MemoryInfoIterator(ArrayRef<uint8_t> Storage, size_t Stride)
+        : Storage(Storage), Stride(Stride) {
+      assert(Storage.size() % Stride == 0);
+    }
+
+    bool operator==(const MemoryInfoIterator &R) const {
+      return Storage.size() == R.Storage.size();
+    }
+
+    const minidump::MemoryInfo &operator*() const {
+      assert(Storage.size() >= sizeof(minidump::MemoryInfo));
+      return *reinterpret_cast<const minidump::MemoryInfo *>(Storage.data());
+    }
+
+    MemoryInfoIterator &operator++() {
+      Storage = Storage.drop_front(Stride);
+      return *this;
+    }
+
+  private:
+    ArrayRef<uint8_t> Storage;
+    size_t Stride;
+  };
+
+  /// Returns the list of descriptors embedded in the MemoryInfoList stream. The
+  /// descriptors provide properties (e.g. permissions) of interesting regions
+  /// of memory at the time the minidump was taken. An error is returned if the
+  /// file does not contain this stream, or if the stream is not large enough to
+  /// contain the number of memory descriptors declared in the stream header.
+  /// The consistency of the MemoryInfoList entries themselves is not checked
+  /// in any way.
+  Expected<iterator_range<MemoryInfoIterator>> getMemoryInfoList() const;
+
 private:
   static Error createError(StringRef Str) {
     return make_error<GenericBinaryError>(Str, object_error::parse_failed);
@@ -137,10 +187,10 @@
 };
 
 template <typename T>
-Expected<const T &> MinidumpFile::getStream(minidump::StreamType Stream) const {
-  if (auto OptionalStream = getRawStream(Stream)) {
-    if (OptionalStream->size() >= sizeof(T))
-      return *reinterpret_cast<const T *>(OptionalStream->data());
+Expected<const T &> MinidumpFile::getStream(minidump::StreamType Type) const {
+  if (Optional<ArrayRef<uint8_t>> Stream = getRawStream(Type)) {
+    if (Stream->size() >= sizeof(T))
+      return *reinterpret_cast<const T *>(Stream->data());
     return createEOFError();
   }
   return createError("No such stream");
@@ -153,10 +203,11 @@
   // Check for overflow.
   if (Count > std::numeric_limits<size_t>::max() / sizeof(T))
     return createEOFError();
-  auto ExpectedArray = getDataSlice(Data, Offset, sizeof(T) * Count);
-  if (!ExpectedArray)
-    return ExpectedArray.takeError();
-  return ArrayRef<T>(reinterpret_cast<const T *>(ExpectedArray->data()), Count);
+  Expected<ArrayRef<uint8_t>> Slice =
+      getDataSlice(Data, Offset, sizeof(T) * Count);
+  if (!Slice)
+    return Slice.takeError();
+  return ArrayRef<T>(reinterpret_cast<const T *>(Slice->data()), Count);
 }
 
 } // end namespace object
diff --git a/linux-x64/clang/include/llvm/Object/ModuleSymbolTable.h b/linux-x64/clang/include/llvm/Object/ModuleSymbolTable.h
index 4c582fb..1134b98 100644
--- a/linux-x64/clang/include/llvm/Object/ModuleSymbolTable.h
+++ b/linux-x64/clang/include/llvm/Object/ModuleSymbolTable.h
@@ -28,6 +28,7 @@
 namespace llvm {
 
 class GlobalValue;
+class Module;
 
 class ModuleSymbolTable {
 public:
diff --git a/linux-x64/clang/include/llvm/Object/ObjectFile.h b/linux-x64/clang/include/llvm/Object/ObjectFile.h
index 483a348..27e40cb 100644
--- a/linux-x64/clang/include/llvm/Object/ObjectFile.h
+++ b/linux-x64/clang/include/llvm/Object/ObjectFile.h
@@ -18,13 +18,11 @@
 #include "llvm/ADT/Triple.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/BinaryFormat/Magic.h"
-#include "llvm/MC/SubtargetFeature.h"
 #include "llvm/Object/Binary.h"
 #include "llvm/Object/Error.h"
 #include "llvm/Object/SymbolicFile.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Error.h"
-#include "llvm/Support/FileSystem.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include <cassert>
 #include <cstdint>
@@ -34,6 +32,7 @@
 namespace llvm {
 
 class ARMAttributeParser;
+class SubtargetFeatures;
 
 namespace object {
 
@@ -94,7 +93,7 @@
 
   void moveNext();
 
-  std::error_code getName(StringRef &Result) const;
+  Expected<StringRef> getName() const;
   uint64_t getAddress() const;
   uint64_t getIndex() const;
   uint64_t getSize() const;
@@ -123,6 +122,9 @@
   /// contains data (e.g. PROGBITS), but is not text.
   bool isBerkeleyData() const;
 
+  /// Whether this section is a debug section.
+  bool isDebugSection(StringRef SectionName) const;
+
   bool containsSymbol(SymbolRef S) const;
 
   relocation_iterator relocation_begin() const;
@@ -130,18 +132,13 @@
   iterator_range<relocation_iterator> relocations() const {
     return make_range(relocation_begin(), relocation_end());
   }
-  section_iterator getRelocatedSection() const;
+  Expected<section_iterator> getRelocatedSection() const;
 
   DataRefImpl getRawDataRefImpl() const;
   const ObjectFile *getObject() const;
 };
 
 struct SectionedAddress {
-  // TODO: constructors could be removed when C++14 would be adopted.
-  SectionedAddress() {}
-  SectionedAddress(uint64_t Addr, uint64_t SectIdx)
-      : Address(Addr), SectionIndex(SectIdx) {}
-
   const static uint64_t UndefSection = UINT64_MAX;
 
   uint64_t Address = 0;
@@ -160,6 +157,8 @@
          std::tie(RHS.SectionIndex, RHS.Address);
 }
 
+raw_ostream &operator<<(raw_ostream &OS, const SectionedAddress &Addr);
+
 /// This is a value type class that represents a single symbol in the list of
 /// symbols in the object file.
 class SymbolRef : public BasicSymbolRef {
@@ -188,7 +187,7 @@
 
   /// Return the value of the symbol depending on the object this can be an
   /// offset or a virtual address.
-  uint64_t getValue() const;
+  Expected<uint64_t> getValue() const;
 
   /// Get the alignment of this symbol as the actual value (not log 2).
   uint32_t getAlignment() const;
@@ -275,9 +274,10 @@
   virtual bool isSectionStripped(DataRefImpl Sec) const;
   virtual bool isBerkeleyText(DataRefImpl Sec) const;
   virtual bool isBerkeleyData(DataRefImpl Sec) const;
+  virtual bool isDebugSection(StringRef SectionName) const;
   virtual relocation_iterator section_rel_begin(DataRefImpl Sec) const = 0;
   virtual relocation_iterator section_rel_end(DataRefImpl Sec) const = 0;
-  virtual section_iterator getRelocatedSection(DataRefImpl Sec) const;
+  virtual Expected<section_iterator> getRelocatedSection(DataRefImpl Sec) const;
 
   // Same as above for RelocationRef.
   friend class RelocationRef;
@@ -288,14 +288,18 @@
   virtual void getRelocationTypeName(DataRefImpl Rel,
                                      SmallVectorImpl<char> &Result) const = 0;
 
-  uint64_t getSymbolValue(DataRefImpl Symb) const;
+  Expected<uint64_t> getSymbolValue(DataRefImpl Symb) const;
 
 public:
   ObjectFile() = delete;
   ObjectFile(const ObjectFile &other) = delete;
 
   uint64_t getCommonSymbolSize(DataRefImpl Symb) const {
-    assert(getSymbolFlags(Symb) & SymbolRef::SF_Common);
+    Expected<uint32_t> SymbolFlagsOrErr = getSymbolFlags(Symb);
+    if (!SymbolFlagsOrErr)
+      // TODO: Actually report errors helpfully.
+      report_fatal_error(SymbolFlagsOrErr.takeError());
+    assert(*SymbolFlagsOrErr & SymbolRef::SF_Common);
     return getCommonSymbolSizeImpl(Symb);
   }
 
@@ -323,6 +327,7 @@
   virtual StringRef getFileFormatName() const = 0;
   virtual Triple::ArchType getArch() const = 0;
   virtual SubtargetFeatures getFeatures() const = 0;
+  virtual Optional<StringRef> tryGetCPUName() const { return None; };
   virtual void setARMSubArch(Triple &TheTriple) const { }
   virtual Expected<uint64_t> getStartAddress() const {
     return errorCodeToError(object_error::parse_failed);
@@ -345,7 +350,8 @@
   createObjectFile(StringRef ObjectPath);
 
   static Expected<std::unique_ptr<ObjectFile>>
-  createObjectFile(MemoryBufferRef Object, llvm::file_magic Type);
+  createObjectFile(MemoryBufferRef Object, llvm::file_magic Type,
+                   bool InitContent = true);
   static Expected<std::unique_ptr<ObjectFile>>
   createObjectFile(MemoryBufferRef Object) {
     return createObjectFile(Object, llvm::file_magic::unknown);
@@ -362,7 +368,7 @@
   createXCOFFObjectFile(MemoryBufferRef Object, unsigned FileType);
 
   static Expected<std::unique_ptr<ObjectFile>>
-  createELFObjectFile(MemoryBufferRef Object);
+  createELFObjectFile(MemoryBufferRef Object, bool InitContent = true);
 
   static Expected<std::unique_ptr<MachOObjectFile>>
   createMachOObjectFile(MemoryBufferRef Object,
@@ -385,7 +391,7 @@
   return getObject()->getSymbolAddress(getRawDataRefImpl());
 }
 
-inline uint64_t SymbolRef::getValue() const {
+inline Expected<uint64_t> SymbolRef::getValue() const {
   return getObject()->getSymbolValue(getRawDataRefImpl());
 }
 
@@ -434,12 +440,8 @@
   return OwningObject->moveSectionNext(SectionPimpl);
 }
 
-inline std::error_code SectionRef::getName(StringRef &Result) const {
-  Expected<StringRef> NameOrErr = OwningObject->getSectionName(SectionPimpl);
-  if (!NameOrErr)
-    return errorToErrorCode(NameOrErr.takeError());
-  Result = *NameOrErr;
-  return std::error_code();
+inline Expected<StringRef> SectionRef::getName() const {
+  return OwningObject->getSectionName(SectionPimpl);
 }
 
 inline uint64_t SectionRef::getAddress() const {
@@ -502,6 +504,10 @@
   return OwningObject->isBerkeleyData(SectionPimpl);
 }
 
+inline bool SectionRef::isDebugSection(StringRef SectionName) const {
+  return OwningObject->isDebugSection(SectionName);
+}
+
 inline relocation_iterator SectionRef::relocation_begin() const {
   return OwningObject->section_rel_begin(SectionPimpl);
 }
@@ -510,7 +516,7 @@
   return OwningObject->section_rel_end(SectionPimpl);
 }
 
-inline section_iterator SectionRef::getRelocatedSection() const {
+inline Expected<section_iterator> SectionRef::getRelocatedSection() const {
   return OwningObject->getRelocatedSection(SectionPimpl);
 }
 
diff --git a/linux-x64/clang/include/llvm/Object/RelocationResolver.h b/linux-x64/clang/include/llvm/Object/RelocationResolver.h
index 1246dcc..46f74e9 100644
--- a/linux-x64/clang/include/llvm/Object/RelocationResolver.h
+++ b/linux-x64/clang/include/llvm/Object/RelocationResolver.h
@@ -31,11 +31,17 @@
 namespace llvm {
 namespace object {
 
-using RelocationResolver = uint64_t (*)(RelocationRef R, uint64_t S, uint64_t A);
+using SupportsRelocation = bool (*)(uint64_t);
+using RelocationResolver = uint64_t (*)(uint64_t Type, uint64_t Offset,
+                                        uint64_t S, uint64_t LocData,
+                                        int64_t Addend);
 
-std::pair<bool (*)(uint64_t), RelocationResolver>
+std::pair<SupportsRelocation, RelocationResolver>
 getRelocationResolver(const ObjectFile &Obj);
 
+uint64_t resolveRelocation(RelocationResolver Resolver, const RelocationRef &R,
+                           uint64_t S, uint64_t LocData);
+
 } // end namespace object
 } // end namespace llvm
 
diff --git a/linux-x64/clang/include/llvm/Object/StackMapParser.h b/linux-x64/clang/include/llvm/Object/StackMapParser.h
index ed44efb..4ee6711 100644
--- a/linux-x64/clang/include/llvm/Object/StackMapParser.h
+++ b/linux-x64/clang/include/llvm/Object/StackMapParser.h
@@ -11,6 +11,7 @@
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/iterator_range.h"
+#include "llvm/Object/ELF.h"
 #include "llvm/Support/Endian.h"
 #include <cassert>
 #include <cstddef>
@@ -19,7 +20,7 @@
 
 namespace llvm {
 
-/// A parser for the latest stackmap format.  At the moment, latest=V2.
+/// A parser for the latest stackmap format.  At the moment, latest=V3.
 template <support::endianness Endianness>
 class StackMapParser {
 public:
@@ -35,11 +36,13 @@
       return tmp;
     }
 
-    bool operator==(const AccessorIterator &Other) {
+    bool operator==(const AccessorIterator &Other) const {
       return A.P == Other.A.P;
     }
 
-    bool operator!=(const AccessorIterator &Other) { return !(*this == Other); }
+    bool operator!=(const AccessorIterator &Other) const {
+      return !(*this == Other);
+    }
 
     AccessorT& operator*() { return A; }
     AccessorT* operator->() { return &A; }
@@ -299,7 +302,7 @@
     const uint8_t *P;
   };
 
-  /// Construct a parser for a version-2 stackmap. StackMap data will be read
+  /// Construct a parser for a version-3 stackmap. StackMap data will be read
   /// from the given array.
   StackMapParser(ArrayRef<uint8_t> StackMapSection)
       : StackMapSection(StackMapSection) {
@@ -318,6 +321,23 @@
     }
   }
 
+  /// Validates the header of the specified stack map section.
+  static Error validateHeader(ArrayRef<uint8_t> StackMapSection) {
+    // See the comment for StackMaps::emitStackmapHeader().
+    if (StackMapSection.size() < 16)
+      return object::createError(
+          "the stack map section size (" + Twine(StackMapSection.size()) +
+          ") is less than the minimum possible size of its header (16)");
+
+    unsigned Version = StackMapSection[0];
+    if (Version != 3)
+      return object::createError(
+          "the version (" + Twine(Version) +
+          ") of the stack map section is unsupported, the "
+          "supported version is 3");
+    return Error::success();
+  }
+
   using function_iterator = AccessorIterator<FunctionAccessor>;
   using constant_iterator = AccessorIterator<ConstantAccessor>;
   using record_iterator = AccessorIterator<RecordAccessor>;
diff --git a/linux-x64/clang/include/llvm/Object/SymbolicFile.h b/linux-x64/clang/include/llvm/Object/SymbolicFile.h
index 1398fa1..012f9f7 100644
--- a/linux-x64/clang/include/llvm/Object/SymbolicFile.h
+++ b/linux-x64/clang/include/llvm/Object/SymbolicFile.h
@@ -18,7 +18,6 @@
 #include "llvm/BinaryFormat/Magic.h"
 #include "llvm/Object/Binary.h"
 #include "llvm/Support/Error.h"
-#include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include <cinttypes>
@@ -129,7 +128,7 @@
   Error printName(raw_ostream &OS) const;
 
   /// Get symbol flags (bitwise OR of SymbolRef::Flags)
-  uint32_t getFlags() const;
+  Expected<uint32_t> getFlags() const;
 
   DataRefImpl getRawDataRefImpl() const;
   const SymbolicFile *getObject() const;
@@ -147,7 +146,7 @@
 
   virtual Error printSymbolName(raw_ostream &OS, DataRefImpl Symb) const = 0;
 
-  virtual uint32_t getSymbolFlags(DataRefImpl Symb) const = 0;
+  virtual Expected<uint32_t> getSymbolFlags(DataRefImpl Symb) const = 0;
 
   virtual basic_symbol_iterator symbol_begin() const = 0;
 
@@ -162,18 +161,18 @@
   // construction aux.
   static Expected<std::unique_ptr<SymbolicFile>>
   createSymbolicFile(MemoryBufferRef Object, llvm::file_magic Type,
-                     LLVMContext *Context);
+                     LLVMContext *Context, bool InitContent = true);
 
   static Expected<std::unique_ptr<SymbolicFile>>
   createSymbolicFile(MemoryBufferRef Object) {
     return createSymbolicFile(Object, llvm::file_magic::unknown, nullptr);
   }
-  static Expected<OwningBinary<SymbolicFile>>
-  createSymbolicFile(StringRef ObjectPath);
 
   static bool classof(const Binary *v) {
     return v->isSymbolic();
   }
+
+  static bool isSymbolicFile(file_magic Type, const LLVMContext *Context);
 };
 
 inline BasicSymbolRef::BasicSymbolRef(DataRefImpl SymbolP,
@@ -196,7 +195,7 @@
   return OwningObject->printSymbolName(OS, SymbolPimpl);
 }
 
-inline uint32_t BasicSymbolRef::getFlags() const {
+inline Expected<uint32_t> BasicSymbolRef::getFlags() const {
   return OwningObject->getSymbolFlags(SymbolPimpl);
 }
 
diff --git a/linux-x64/clang/include/llvm/Object/TapiFile.h b/linux-x64/clang/include/llvm/Object/TapiFile.h
new file mode 100644
index 0000000..ab99690
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Object/TapiFile.h
@@ -0,0 +1,63 @@
+//===- TapiFile.h - Text-based Dynamic Library Stub -------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file declares the TapiFile interface.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_OBJECT_TAPI_FILE_H
+#define LLVM_OBJECT_TAPI_FILE_H
+
+#include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/iterator_range.h"
+#include "llvm/Object/SymbolicFile.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/MemoryBuffer.h"
+#include "llvm/TextAPI/MachO/InterfaceFile.h"
+
+namespace llvm {
+namespace object {
+
+class TapiFile : public SymbolicFile {
+public:
+  TapiFile(MemoryBufferRef Source, const MachO::InterfaceFile &interface,
+           MachO::Architecture Arch);
+  ~TapiFile() override;
+
+  void moveSymbolNext(DataRefImpl &DRI) const override;
+
+  Error printSymbolName(raw_ostream &OS, DataRefImpl DRI) const override;
+
+  Expected<uint32_t> getSymbolFlags(DataRefImpl DRI) const override;
+
+  basic_symbol_iterator symbol_begin() const override;
+
+  basic_symbol_iterator symbol_end() const override;
+
+  static bool classof(const Binary *v) { return v->isTapiFile(); }
+
+  bool is64Bit() { return MachO::is64Bit(Arch); }
+
+private:
+  struct Symbol {
+    StringRef Prefix;
+    StringRef Name;
+    uint32_t Flags;
+
+    constexpr Symbol(StringRef Prefix, StringRef Name, uint32_t Flags)
+        : Prefix(Prefix), Name(Name), Flags(Flags) {}
+  };
+
+  std::vector<Symbol> Symbols;
+  MachO::Architecture Arch;
+};
+
+} // end namespace object.
+} // end namespace llvm.
+
+#endif // LLVM_OBJECT_TAPI_FILE_H
diff --git a/linux-x64/clang/include/llvm/Object/TapiUniversal.h b/linux-x64/clang/include/llvm/Object/TapiUniversal.h
new file mode 100644
index 0000000..0f494fc
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Object/TapiUniversal.h
@@ -0,0 +1,121 @@
+//===-- TapiUniversal.h - Text-based Dynamic Library Stub -------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file declares the TapiUniversal interface.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_OBJECT_TAPI_UNIVERSAL_H
+#define LLVM_OBJECT_TAPI_UNIVERSAL_H
+
+#include "llvm/Object/Binary.h"
+#include "llvm/Object/TapiFile.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/MemoryBuffer.h"
+#include "llvm/TextAPI/MachO/Architecture.h"
+#include "llvm/TextAPI/MachO/InterfaceFile.h"
+
+namespace llvm {
+namespace object {
+
+class TapiUniversal : public Binary {
+public:
+  class ObjectForArch {
+    const TapiUniversal *Parent;
+    int Index;
+
+  public:
+    ObjectForArch(const TapiUniversal *Parent, int Index)
+        : Parent(Parent), Index(Index) {}
+
+    ObjectForArch getNext() const { return ObjectForArch(Parent, Index + 1); }
+
+    bool operator==(const ObjectForArch &Other) const {
+      return (Parent == Other.Parent) && (Index == Other.Index);
+    }
+
+    uint32_t getCPUType() const {
+      auto Result =
+          MachO::getCPUTypeFromArchitecture(Parent->Libraries[Index].Arch);
+      return Result.first;
+    }
+
+    uint32_t getCPUSubType() const {
+      auto Result =
+          MachO::getCPUTypeFromArchitecture(Parent->Libraries[Index].Arch);
+      return Result.second;
+    }
+
+    StringRef getArchFlagName() const {
+      return MachO::getArchitectureName(Parent->Libraries[Index].Arch);
+    }
+
+    std::string getInstallName() const {
+      return std::string(Parent->Libraries[Index].InstallName);
+    }
+
+    bool isTopLevelLib() const {
+      return Parent->ParsedFile->getInstallName() == getInstallName();
+    }
+
+    Expected<std::unique_ptr<TapiFile>> getAsObjectFile() const;
+  };
+
+  class object_iterator {
+    ObjectForArch Obj;
+
+  public:
+    object_iterator(const ObjectForArch &Obj) : Obj(Obj) {}
+    const ObjectForArch *operator->() const { return &Obj; }
+    const ObjectForArch &operator*() const { return Obj; }
+
+    bool operator==(const object_iterator &Other) const {
+      return Obj == Other.Obj;
+    }
+    bool operator!=(const object_iterator &Other) const {
+      return !(*this == Other);
+    }
+
+    object_iterator &operator++() { // Preincrement
+      Obj = Obj.getNext();
+      return *this;
+    }
+  };
+
+  TapiUniversal(MemoryBufferRef Source, Error &Err);
+  static Expected<std::unique_ptr<TapiUniversal>>
+  create(MemoryBufferRef Source);
+  ~TapiUniversal() override;
+
+  object_iterator begin_objects() const { return ObjectForArch(this, 0); }
+  object_iterator end_objects() const {
+    return ObjectForArch(this, Libraries.size());
+  }
+
+  iterator_range<object_iterator> objects() const {
+    return make_range(begin_objects(), end_objects());
+  }
+
+  uint32_t getNumberOfObjects() const { return Libraries.size(); }
+
+  static bool classof(const Binary *v) { return v->isTapiUniversal(); }
+
+private:
+  struct Library {
+    StringRef InstallName;
+    MachO::Architecture Arch;
+  };
+
+  std::unique_ptr<MachO::InterfaceFile> ParsedFile;
+  std::vector<Library> Libraries;
+};
+
+} // end namespace object.
+} // end namespace llvm.
+
+#endif // LLVM_OBJECT_TAPI_UNIVERSAL_H
diff --git a/linux-x64/clang/include/llvm/Object/Wasm.h b/linux-x64/clang/include/llvm/Object/Wasm.h
index e130ea3..f7cd2e6 100644
--- a/linux-x64/clang/include/llvm/Object/Wasm.h
+++ b/linux-x64/clang/include/llvm/Object/Wasm.h
@@ -17,7 +17,6 @@
 #define LLVM_OBJECT_WASM_H
 
 #include "llvm/ADT/ArrayRef.h"
-#include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/BinaryFormat/Wasm.h"
 #include "llvm/Config/llvm-config.h"
@@ -37,13 +36,15 @@
 public:
   WasmSymbol(const wasm::WasmSymbolInfo &Info,
              const wasm::WasmGlobalType *GlobalType,
+             const wasm::WasmTableType *TableType,
              const wasm::WasmEventType *EventType,
              const wasm::WasmSignature *Signature)
-      : Info(Info), GlobalType(GlobalType), EventType(EventType),
-        Signature(Signature) {}
+      : Info(Info), GlobalType(GlobalType), TableType(TableType),
+        EventType(EventType), Signature(Signature) {}
 
   const wasm::WasmSymbolInfo &Info;
   const wasm::WasmGlobalType *GlobalType;
+  const wasm::WasmTableType *TableType;
   const wasm::WasmEventType *EventType;
   const wasm::WasmSignature *Signature;
 
@@ -51,6 +52,8 @@
     return Info.Kind == wasm::WASM_SYMBOL_TYPE_FUNCTION;
   }
 
+  bool isTypeTable() const { return Info.Kind == wasm::WASM_SYMBOL_TYPE_TABLE; }
+
   bool isTypeData() const { return Info.Kind == wasm::WASM_SYMBOL_TYPE_DATA; }
 
   bool isTypeGlobal() const {
@@ -106,6 +109,7 @@
   uint32_t Type = 0;         // Section type (See below)
   uint32_t Offset = 0;       // Offset with in the file
   StringRef Name;            // Section name (User-defined sections only)
+  uint32_t Comdat = UINT32_MAX; // From the "comdat info" section
   ArrayRef<uint8_t> Content; // Section content
   std::vector<wasm::WasmRelocation> Relocations; // Relocations for this section
 };
@@ -147,14 +151,16 @@
   ArrayRef<wasm::WasmElemSegment> elements() const { return ElemSegments; }
   ArrayRef<WasmSegment> dataSegments() const { return DataSegments; }
   ArrayRef<wasm::WasmFunction> functions() const { return Functions; }
-  ArrayRef<wasm::WasmFunctionName> debugNames() const { return DebugNames; }
+  ArrayRef<wasm::WasmDebugName> debugNames() const { return DebugNames; }
   uint32_t startFunction() const { return StartFunction; }
   uint32_t getNumImportedGlobals() const { return NumImportedGlobals; }
+  uint32_t getNumImportedTables() const { return NumImportedTables; }
   uint32_t getNumImportedFunctions() const { return NumImportedFunctions; }
   uint32_t getNumImportedEvents() const { return NumImportedEvents; }
+  uint32_t getNumSections() const { return Sections.size(); }
   void moveSymbolNext(DataRefImpl &Symb) const override;
 
-  uint32_t getSymbolFlags(DataRefImpl Symb) const override;
+  Expected<uint32_t> getSymbolFlags(DataRefImpl Symb) const override;
 
   basic_symbol_iterator symbol_begin() const override;
 
@@ -168,6 +174,7 @@
   uint64_t getCommonSymbolSizeImpl(DataRefImpl Symb) const override;
   Expected<SymbolRef::Type> getSymbolType(DataRefImpl Symb) const override;
   Expected<section_iterator> getSymbolSection(DataRefImpl Symb) const override;
+  uint32_t getSymbolSectionId(SymbolRef Sym) const;
 
   // Overrides from SectionRef.
   void moveSectionNext(DataRefImpl &Sec) const override;
@@ -183,7 +190,6 @@
   bool isSectionData(DataRefImpl Sec) const override;
   bool isSectionBSS(DataRefImpl Sec) const override;
   bool isSectionVirtual(DataRefImpl Sec) const override;
-  bool isSectionBitcode(DataRefImpl Sec) const override;
   relocation_iterator section_rel_begin(DataRefImpl Sec) const override;
   relocation_iterator section_rel_end(DataRefImpl Sec) const override;
 
@@ -214,10 +220,13 @@
   bool isValidFunctionIndex(uint32_t Index) const;
   bool isDefinedFunctionIndex(uint32_t Index) const;
   bool isValidGlobalIndex(uint32_t Index) const;
+  bool isValidTableIndex(uint32_t Index) const;
   bool isDefinedGlobalIndex(uint32_t Index) const;
+  bool isDefinedTableIndex(uint32_t Index) const;
   bool isValidEventIndex(uint32_t Index) const;
   bool isDefinedEventIndex(uint32_t Index) const;
   bool isValidFunctionSymbol(uint32_t Index) const;
+  bool isValidTableSymbol(uint32_t Index) const;
   bool isValidGlobalSymbol(uint32_t Index) const;
   bool isValidEventSymbol(uint32_t Index) const;
   bool isValidDataSymbol(uint32_t Index) const;
@@ -229,6 +238,7 @@
 
   const WasmSection &getWasmSection(DataRefImpl Ref) const;
   const wasm::WasmRelocation &getWasmRelocation(DataRefImpl Ref) const;
+  uint32_t getSymbolSectionIdImpl(const WasmSymbol &Symb) const;
 
   Error parseSection(WasmSection &Sec);
   Error parseCustomSection(WasmSection &Sec, ReadContext &Ctx);
@@ -239,8 +249,8 @@
   Error parseFunctionSection(ReadContext &Ctx);
   Error parseTableSection(ReadContext &Ctx);
   Error parseMemorySection(ReadContext &Ctx);
-  Error parseGlobalSection(ReadContext &Ctx);
   Error parseEventSection(ReadContext &Ctx);
+  Error parseGlobalSection(ReadContext &Ctx);
   Error parseExportSection(ReadContext &Ctx);
   Error parseStartSection(ReadContext &Ctx);
   Error parseElemSection(ReadContext &Ctx);
@@ -276,18 +286,22 @@
   llvm::Optional<size_t> DataCount;
   std::vector<wasm::WasmFunction> Functions;
   std::vector<WasmSymbol> Symbols;
-  std::vector<wasm::WasmFunctionName> DebugNames;
+  std::vector<wasm::WasmDebugName> DebugNames;
   uint32_t StartFunction = -1;
   bool HasLinkingSection = false;
   bool HasDylinkSection = false;
+  bool SeenCodeSection = false;
+  bool HasMemory64 = false;
   wasm::WasmLinkingData LinkingData;
   uint32_t NumImportedGlobals = 0;
+  uint32_t NumImportedTables = 0;
   uint32_t NumImportedFunctions = 0;
   uint32_t NumImportedEvents = 0;
   uint32_t CodeSection = 0;
   uint32_t DataSection = 0;
-  uint32_t GlobalSection = 0;
   uint32_t EventSection = 0;
+  uint32_t GlobalSection = 0;
+  uint32_t TableSection = 0;
 };
 
 class WasmSectionOrderChecker {
@@ -303,8 +317,8 @@
     WASM_SEC_ORDER_FUNCTION,
     WASM_SEC_ORDER_TABLE,
     WASM_SEC_ORDER_MEMORY,
-    WASM_SEC_ORDER_GLOBAL,
     WASM_SEC_ORDER_EVENT,
+    WASM_SEC_ORDER_GLOBAL,
     WASM_SEC_ORDER_EXPORT,
     WASM_SEC_ORDER_START,
     WASM_SEC_ORDER_ELEM,
diff --git a/linux-x64/clang/include/llvm/Object/WindowsResource.h b/linux-x64/clang/include/llvm/Object/WindowsResource.h
index 356dcb0..a0d6584 100644
--- a/linux-x64/clang/include/llvm/Object/WindowsResource.h
+++ b/linux-x64/clang/include/llvm/Object/WindowsResource.h
@@ -31,6 +31,7 @@
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/BinaryFormat/COFF.h"
 #include "llvm/Object/Binary.h"
+#include "llvm/Object/COFF.h"
 #include "llvm/Object/Error.h"
 #include "llvm/Support/BinaryByteStream.h"
 #include "llvm/Support/BinaryStreamReader.h"
@@ -48,6 +49,7 @@
 namespace object {
 
 class WindowsResource;
+class ResourceSectionRef;
 
 const size_t WIN_RES_MAGIC_SIZE = 16;
 const size_t WIN_RES_NULL_ENTRY_SIZE = 16;
@@ -151,8 +153,11 @@
 class WindowsResourceParser {
 public:
   class TreeNode;
-  WindowsResourceParser();
+  WindowsResourceParser(bool MinGW = false);
   Error parse(WindowsResource *WR, std::vector<std::string> &Duplicates);
+  Error parse(ResourceSectionRef &RSR, StringRef Filename,
+              std::vector<std::string> &Duplicates);
+  void cleanUpManifests(std::vector<std::string> &Duplicates);
   void printTree(raw_ostream &OS) const;
   const TreeNode &getTree() const { return Root; }
   const ArrayRef<std::vector<uint8_t>> getData() const { return Data; }
@@ -181,32 +186,38 @@
   private:
     friend class WindowsResourceParser;
 
-    static uint32_t StringCount;
-    static uint32_t DataCount;
-
-    static std::unique_ptr<TreeNode> createStringNode();
+    // Index is the StringTable vector index for this node's name.
+    static std::unique_ptr<TreeNode> createStringNode(uint32_t Index);
     static std::unique_ptr<TreeNode> createIDNode();
+    // DataIndex is the Data vector index that the data node points at.
     static std::unique_ptr<TreeNode> createDataNode(uint16_t MajorVersion,
                                                     uint16_t MinorVersion,
                                                     uint32_t Characteristics,
-                                                    uint32_t Origin);
+                                                    uint32_t Origin,
+                                                    uint32_t DataIndex);
 
-    explicit TreeNode(bool IsStringNode);
+    explicit TreeNode(uint32_t StringIndex);
     TreeNode(uint16_t MajorVersion, uint16_t MinorVersion,
-             uint32_t Characteristics, uint32_t Origin);
+             uint32_t Characteristics, uint32_t Origin, uint32_t DataIndex);
 
     bool addEntry(const ResourceEntryRef &Entry, uint32_t Origin,
-                  bool &IsNewTypeString, bool &IsNewNameString,
+                  std::vector<std::vector<uint8_t>> &Data,
+                  std::vector<std::vector<UTF16>> &StringTable,
                   TreeNode *&Result);
-    TreeNode &addTypeNode(const ResourceEntryRef &Entry, bool &IsNewTypeString);
-    TreeNode &addNameNode(const ResourceEntryRef &Entry, bool &IsNewNameString);
+    TreeNode &addTypeNode(const ResourceEntryRef &Entry,
+                          std::vector<std::vector<UTF16>> &StringTable);
+    TreeNode &addNameNode(const ResourceEntryRef &Entry,
+                          std::vector<std::vector<UTF16>> &StringTable);
     bool addLanguageNode(const ResourceEntryRef &Entry, uint32_t Origin,
+                         std::vector<std::vector<uint8_t>> &Data,
                          TreeNode *&Result);
     bool addDataChild(uint32_t ID, uint16_t MajorVersion, uint16_t MinorVersion,
                       uint32_t Characteristics, uint32_t Origin,
-                      TreeNode *&Result);
+                      uint32_t DataIndex, TreeNode *&Result);
     TreeNode &addIDChild(uint32_t ID);
-    TreeNode &addNameChild(ArrayRef<UTF16> NameRef, bool &IsNewString);
+    TreeNode &addNameChild(ArrayRef<UTF16> NameRef,
+                           std::vector<std::vector<UTF16>> &StringTable);
+    void shiftDataIndexDown(uint32_t Index);
 
     bool IsDataNode = false;
     uint32_t StringIndex;
@@ -222,12 +233,30 @@
     uint32_t Origin;
   };
 
+  struct StringOrID {
+    bool IsString;
+    ArrayRef<UTF16> String;
+    uint32_t ID;
+
+    StringOrID(uint32_t ID) : IsString(false), ID(ID) {}
+    StringOrID(ArrayRef<UTF16> String) : IsString(true), String(String) {}
+  };
+
 private:
+  Error addChildren(TreeNode &Node, ResourceSectionRef &RSR,
+                    const coff_resource_dir_table &Table, uint32_t Origin,
+                    std::vector<StringOrID> &Context,
+                    std::vector<std::string> &Duplicates);
+  bool shouldIgnoreDuplicate(const ResourceEntryRef &Entry) const;
+  bool shouldIgnoreDuplicate(const std::vector<StringOrID> &Context) const;
+
   TreeNode Root;
   std::vector<std::vector<uint8_t>> Data;
   std::vector<std::vector<UTF16>> StringTable;
 
   std::vector<std::string> InputFilenames;
+
+  bool MinGW;
 };
 
 Expected<std::unique_ptr<MemoryBuffer>>
diff --git a/linux-x64/clang/include/llvm/Object/XCOFFObjectFile.h b/linux-x64/clang/include/llvm/Object/XCOFFObjectFile.h
index cdee712..1ac00ed 100644
--- a/linux-x64/clang/include/llvm/Object/XCOFFObjectFile.h
+++ b/linux-x64/clang/include/llvm/Object/XCOFFObjectFile.h
@@ -13,23 +13,12 @@
 #ifndef LLVM_OBJECT_XCOFFOBJECTFILE_H
 #define LLVM_OBJECT_XCOFFOBJECTFILE_H
 
-#include "llvm/ADT/StringRef.h"
-#include "llvm/ADT/iterator_range.h"
-#include "llvm/BinaryFormat/Magic.h"
+#include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/SmallVector.h"
 #include "llvm/BinaryFormat/XCOFF.h"
-#include "llvm/MC/SubtargetFeature.h"
-#include "llvm/Object/Binary.h"
-#include "llvm/Object/Error.h"
 #include "llvm/Object/ObjectFile.h"
-#include "llvm/Object/SymbolicFile.h"
-#include "llvm/Support/Casting.h"
-#include "llvm/Support/Error.h"
-#include "llvm/Support/FileSystem.h"
-#include "llvm/Support/MemoryBuffer.h"
-#include <cassert>
-#include <cstdint>
-#include <memory>
-#include <system_error>
+#include "llvm/Support/Endian.h"
+#include <limits>
 
 namespace llvm {
 namespace object {
@@ -62,8 +51,27 @@
   support::ubig32_t NumberOfSymTableEntries;
 };
 
-struct XCOFFSectionHeader32 {
-  char Name[XCOFF::SectionNameSize];
+template <typename T> struct XCOFFSectionHeader {
+  // Least significant 3 bits are reserved.
+  static constexpr unsigned SectionFlagsReservedMask = 0x7;
+
+  // The low order 16 bits of section flags denotes the section type.
+  static constexpr unsigned SectionFlagsTypeMask = 0xffffu;
+
+public:
+  StringRef getName() const;
+  uint16_t getSectionType() const;
+  bool isReservedSectionType() const;
+};
+
+// Explicit extern template declarations.
+struct XCOFFSectionHeader32;
+struct XCOFFSectionHeader64;
+extern template struct XCOFFSectionHeader<XCOFFSectionHeader32>;
+extern template struct XCOFFSectionHeader<XCOFFSectionHeader64>;
+
+struct XCOFFSectionHeader32 : XCOFFSectionHeader<XCOFFSectionHeader32> {
+  char Name[XCOFF::NameSize];
   support::ubig32_t PhysicalAddress;
   support::ubig32_t VirtualAddress;
   support::ubig32_t SectionSize;
@@ -73,12 +81,10 @@
   support::ubig16_t NumberOfRelocations;
   support::ubig16_t NumberOfLineNumbers;
   support::big32_t Flags;
-
-  StringRef getName() const;
 };
 
-struct XCOFFSectionHeader64 {
-  char Name[XCOFF::SectionNameSize];
+struct XCOFFSectionHeader64 : XCOFFSectionHeader<XCOFFSectionHeader64> {
+  char Name[XCOFF::NameSize];
   support::ubig64_t PhysicalAddress;
   support::ubig64_t VirtualAddress;
   support::ubig64_t SectionSize;
@@ -89,8 +95,6 @@
   support::ubig32_t NumberOfLineNumbers;
   support::big32_t Flags;
   char Padding[4];
-
-  StringRef getName() const;
 };
 
 struct XCOFFSymbolEntry {
@@ -106,7 +110,7 @@
   } CFileLanguageIdAndTypeIdType;
 
   union {
-    char SymbolName[XCOFF::SymbolNameSize];
+    char SymbolName[XCOFF::NameSize];
     NameInStrTblType NameInStrTbl;
   };
 
@@ -127,6 +131,90 @@
   const char *Data;
 };
 
+struct XCOFFCsectAuxEnt32 {
+  static constexpr uint8_t SymbolTypeMask = 0x07;
+  static constexpr uint8_t SymbolAlignmentMask = 0xF8;
+  static constexpr size_t SymbolAlignmentBitOffset = 3;
+
+  support::ubig32_t
+      SectionOrLength; // If the symbol type is XTY_SD or XTY_CM, the csect
+                       // length.
+                       // If the symbol type is XTY_LD, the symbol table
+                       // index of the containing csect.
+                       // If the symbol type is XTY_ER, 0.
+  support::ubig32_t ParameterHashIndex;
+  support::ubig16_t TypeChkSectNum;
+  uint8_t SymbolAlignmentAndType;
+  XCOFF::StorageMappingClass StorageMappingClass;
+  support::ubig32_t StabInfoIndex;
+  support::ubig16_t StabSectNum;
+
+  uint16_t getAlignmentLog2() const {
+    return (SymbolAlignmentAndType & SymbolAlignmentMask) >>
+           SymbolAlignmentBitOffset;
+  }
+
+  uint8_t getSymbolType() const {
+    return SymbolAlignmentAndType & SymbolTypeMask;
+  }
+
+  bool isLabel() const { return getSymbolType() == XCOFF::XTY_LD; }
+};
+
+struct XCOFFFileAuxEnt {
+  typedef struct {
+    support::big32_t Magic; // Zero indicates name in string table.
+    support::ubig32_t Offset;
+    char NamePad[XCOFF::FileNamePadSize];
+  } NameInStrTblType;
+  union {
+    char Name[XCOFF::NameSize + XCOFF::FileNamePadSize];
+    NameInStrTblType NameInStrTbl;
+  };
+  XCOFF::CFileStringType Type;
+  uint8_t ReservedZeros[2];
+  uint8_t AuxType; // 64-bit XCOFF file only.
+};
+
+struct XCOFFSectAuxEntForStat {
+  support::ubig32_t SectionLength;
+  support::ubig16_t NumberOfRelocEnt;
+  support::ubig16_t NumberOfLineNum;
+  uint8_t Pad[10];
+};
+
+struct XCOFFRelocation32 {
+  // Masks for packing/unpacking the r_rsize field of relocations.
+
+  // The msb is used to indicate if the bits being relocated are signed or
+  // unsigned.
+  static constexpr uint8_t XR_SIGN_INDICATOR_MASK = 0x80;
+
+  // The 2nd msb is used to indicate that the binder has replaced/modified the
+  // original instruction.
+  static constexpr uint8_t XR_FIXUP_INDICATOR_MASK = 0x40;
+
+  // The remaining bits specify the bit length of the relocatable reference
+  // minus one.
+  static constexpr uint8_t XR_BIASED_LENGTH_MASK = 0x3f;
+
+public:
+  support::ubig32_t VirtualAddress;
+  support::ubig32_t SymbolIndex;
+
+  // Packed field, see XR_* masks for details of packing.
+  uint8_t Info;
+
+  XCOFF::RelocationType Type;
+
+public:
+  bool isRelocationSigned() const;
+  bool isFixupIndicated() const;
+
+  // Returns the number of bits being relocated.
+  uint8_t getRelocatedLength() const;
+};
+
 class XCOFFObjectFile : public ObjectFile {
 private:
   const void *FileHeader = nullptr;
@@ -146,18 +234,18 @@
 
   const XCOFFSectionHeader32 *toSection32(DataRefImpl Ref) const;
   const XCOFFSectionHeader64 *toSection64(DataRefImpl Ref) const;
-  void checkSectionAddress(uintptr_t Addr, uintptr_t TableAddr) const;
   uintptr_t getSectionHeaderTableAddress() const;
+  uintptr_t getEndOfSymbolTableAddress() const;
 
   // This returns a pointer to the start of the storage for the name field of
   // the 32-bit or 64-bit SectionHeader struct. This string is *not* necessarily
   // null-terminated.
   const char *getSectionNameInternal(DataRefImpl Sec) const;
 
-  int32_t getSectionFlags(DataRefImpl Sec) const;
+  // This function returns string table entry.
+  Expected<StringRef> getStringTableEntry(uint32_t Offset) const;
 
   static bool isReservedSectionNumber(int16_t SectionNumber);
-  Expected<DataRefImpl> getSectionByNum(int16_t Num) const;
 
   // Constructor and "create" factory function. The constructor is only a thin
   // wrapper around the base constructor. The "create" function fills out the
@@ -175,10 +263,15 @@
   friend Expected<std::unique_ptr<ObjectFile>>
   ObjectFile::createXCOFFObjectFile(MemoryBufferRef Object, unsigned FileType);
 
+  void checkSectionAddress(uintptr_t Addr, uintptr_t TableAddr) const;
+
 public:
+  static constexpr uint64_t InvalidRelocOffset =
+      std::numeric_limits<uint64_t>::max();
+
   // Interface inherited from base classes.
   void moveSymbolNext(DataRefImpl &Symb) const override;
-  uint32_t getSymbolFlags(DataRefImpl Symb) const override;
+  Expected<uint32_t> getSymbolFlags(DataRefImpl Symb) const override;
   basic_symbol_iterator symbol_begin() const override;
   basic_symbol_iterator symbol_end() const override;
 
@@ -207,6 +300,10 @@
   relocation_iterator section_rel_end(DataRefImpl Sec) const override;
 
   void moveRelocationNext(DataRefImpl &Rel) const override;
+
+  /// \returns the relocation offset with the base address of the containing
+  /// section as zero, or InvalidRelocOffset on errors (such as a relocation
+  /// that does not refer to an address in any section).
   uint64_t getRelocationOffset(DataRefImpl Rel) const override;
   symbol_iterator getRelocationSymbol(DataRefImpl Rel) const override;
   uint64_t getRelocationType(DataRefImpl Rel) const override;
@@ -253,15 +350,148 @@
   uint32_t getLogicalNumberOfSymbolTableEntries32() const;
 
   uint32_t getNumberOfSymbolTableEntries64() const;
+  uint32_t getSymbolIndex(uintptr_t SymEntPtr) const;
+  Expected<StringRef> getSymbolNameByIndex(uint32_t SymbolTableIndex) const;
 
+  Expected<StringRef> getCFileName(const XCOFFFileAuxEnt *CFileEntPtr) const;
   uint16_t getOptionalHeaderSize() const;
   uint16_t getFlags() const;
 
   // Section header table related interfaces.
   ArrayRef<XCOFFSectionHeader32> sections32() const;
   ArrayRef<XCOFFSectionHeader64> sections64() const;
+
+  int32_t getSectionFlags(DataRefImpl Sec) const;
+  Expected<DataRefImpl> getSectionByNum(int16_t Num) const;
+
+  void checkSymbolEntryPointer(uintptr_t SymbolEntPtr) const;
+
+  // Relocation-related interfaces.
+  Expected<uint32_t>
+  getLogicalNumberOfRelocationEntries(const XCOFFSectionHeader32 &Sec) const;
+
+  Expected<ArrayRef<XCOFFRelocation32>>
+  relocations(const XCOFFSectionHeader32 &) const;
+
+  static bool classof(const Binary *B) { return B->isXCOFF(); }
 }; // XCOFFObjectFile
 
+class XCOFFSymbolRef {
+  const DataRefImpl SymEntDataRef;
+  const XCOFFObjectFile *const OwningObjectPtr;
+
+public:
+  XCOFFSymbolRef(DataRefImpl SymEntDataRef,
+                 const XCOFFObjectFile *OwningObjectPtr)
+      : SymEntDataRef(SymEntDataRef), OwningObjectPtr(OwningObjectPtr){};
+
+  XCOFF::StorageClass getStorageClass() const;
+  uint8_t getNumberOfAuxEntries() const;
+  const XCOFFCsectAuxEnt32 *getXCOFFCsectAuxEnt32() const;
+  uint16_t getType() const;
+  int16_t getSectionNumber() const;
+
+  bool hasCsectAuxEnt() const;
+  bool isFunction() const;
+};
+
+class TBVectorExt {
+  friend class XCOFFTracebackTable;
+
+  uint16_t Data;
+  uint32_t VecParmsInfo;
+
+  TBVectorExt(StringRef TBvectorStrRef);
+
+public:
+  uint8_t getNumberOfVRSaved() const;
+  bool isVRSavedOnStack() const;
+  bool hasVarArgs() const;
+  uint8_t getNumberOfVectorParms() const;
+  bool hasVMXInstruction() const;
+  SmallString<32> getVectorParmsInfoString() const;
+};
+
+/// This class provides methods to extract traceback table data from a buffer.
+/// The various accessors may reference the buffer provided via the constructor.
+
+class XCOFFTracebackTable {
+  const uint8_t *const TBPtr;
+  Optional<SmallString<32>> ParmsType;
+  Optional<uint32_t> TraceBackTableOffset;
+  Optional<uint32_t> HandlerMask;
+  Optional<uint32_t> NumOfCtlAnchors;
+  Optional<SmallVector<uint32_t, 8>> ControlledStorageInfoDisp;
+  Optional<StringRef> FunctionName;
+  Optional<uint8_t> AllocaRegister;
+  Optional<TBVectorExt> VecExt;
+  Optional<uint8_t> ExtensionTable;
+
+  XCOFFTracebackTable(const uint8_t *Ptr, uint64_t &Size, Error &Err);
+public:
+  /// Parse an XCOFF Traceback Table from \a Ptr with \a Size bytes.
+  /// Returns an XCOFFTracebackTable upon successful parsing, otherwise an
+  /// Error is returned.
+  ///
+  /// \param[in] Ptr
+  ///   A pointer that points just past the initial 4 bytes of zeros at the
+  ///   beginning of an XCOFF Traceback Table.
+  ///
+  /// \param[in, out] Size
+  ///    A pointer that points to the length of the XCOFF Traceback Table.
+  ///    If the XCOFF Traceback Table is not parsed successfully or there are
+  ///    extra bytes that are not recognized, \a Size will be updated to be the
+  ///    size up to the end of the last successfully parsed field of the table.
+  static Expected<XCOFFTracebackTable> create(const uint8_t *Ptr,
+                                              uint64_t &Size);
+  uint8_t getVersion() const;
+  uint8_t getLanguageID() const;
+
+  bool isGlobalLinkage() const;
+  bool isOutOfLineEpilogOrPrologue() const;
+  bool hasTraceBackTableOffset() const;
+  bool isInternalProcedure() const;
+  bool hasControlledStorage() const;
+  bool isTOCless() const;
+  bool isFloatingPointPresent() const;
+  bool isFloatingPointOperationLogOrAbortEnabled() const;
+
+  bool isInterruptHandler() const;
+  bool isFuncNamePresent() const;
+  bool isAllocaUsed() const;
+  uint8_t getOnConditionDirective() const;
+  bool isCRSaved() const;
+  bool isLRSaved() const;
+
+  bool isBackChainStored() const;
+  bool isFixup() const;
+  uint8_t getNumOfFPRsSaved() const;
+
+  bool hasVectorInfo() const;
+  bool hasExtensionTable() const;
+  uint8_t getNumOfGPRsSaved() const;
+
+  uint8_t getNumberOfFixedParms() const;
+
+  uint8_t getNumberOfFPParms() const;
+  bool hasParmsOnStack() const;
+
+  const Optional<SmallString<32>> &getParmsType() const { return ParmsType; }
+  const Optional<uint32_t> &getTraceBackTableOffset() const {
+    return TraceBackTableOffset;
+  }
+  const Optional<uint32_t> &getHandlerMask() const { return HandlerMask; }
+  const Optional<uint32_t> &getNumOfCtlAnchors() { return NumOfCtlAnchors; }
+  const Optional<SmallVector<uint32_t, 8>> &getControlledStorageInfoDisp() {
+    return ControlledStorageInfoDisp;
+  }
+  const Optional<StringRef> &getFunctionName() const { return FunctionName; }
+  const Optional<uint8_t> &getAllocaRegister() const { return AllocaRegister; }
+  const Optional<TBVectorExt> &getVectorExt() const { return VecExt; }
+  const Optional<uint8_t> &getExtensionTable() const { return ExtensionTable; }
+};
+
+bool doesXCOFFTracebackTableBegin(ArrayRef<uint8_t> Bytes);
 } // namespace object
 } // namespace llvm
 
diff --git a/linux-x64/clang/include/llvm/ObjectYAML/ArchiveYAML.h b/linux-x64/clang/include/llvm/ObjectYAML/ArchiveYAML.h
new file mode 100644
index 0000000..8d05fee
--- /dev/null
+++ b/linux-x64/clang/include/llvm/ObjectYAML/ArchiveYAML.h
@@ -0,0 +1,77 @@
+//===- ArchiveYAML.h - Archive YAMLIO implementation ------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file declares classes for handling the YAML representation of archives.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_OBJECTYAML_ARCHIVEYAML_H
+#define LLVM_OBJECTYAML_ARCHIVEYAML_H
+
+#include "llvm/Support/YAMLTraits.h"
+#include "llvm/ObjectYAML/YAML.h"
+#include "llvm/ADT/MapVector.h"
+
+namespace llvm {
+namespace ArchYAML {
+
+struct Archive {
+  struct Child {
+    struct Field {
+      Field() = default;
+      Field(StringRef Default, unsigned Length)
+          : DefaultValue(Default), MaxLength(Length) {}
+      StringRef Value;
+      StringRef DefaultValue;
+      unsigned MaxLength;
+    };
+
+    Child() {
+      Fields["Name"] = {"", 16};
+      Fields["LastModified"] = {"0", 12};
+      Fields["UID"] = {"0", 6};
+      Fields["GID"] = {"0", 6};
+      Fields["AccessMode"] = {"0", 8};
+      Fields["Size"] = {"0", 10};
+      Fields["Terminator"] = {"`\n", 2};
+    }
+
+    MapVector<StringRef, Field> Fields;
+
+    Optional<yaml::BinaryRef> Content;
+    Optional<llvm::yaml::Hex8> PaddingByte;
+  };
+
+  StringRef Magic;
+  Optional<std::vector<Child>> Members;
+  Optional<yaml::BinaryRef> Content;
+};
+
+} // end namespace ArchYAML
+} // end namespace llvm
+
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ArchYAML::Archive::Child)
+
+namespace llvm {
+namespace yaml {
+
+template <> struct MappingTraits<ArchYAML::Archive> {
+  static void mapping(IO &IO, ArchYAML::Archive &A);
+  static std::string validate(IO &, ArchYAML::Archive &A);
+};
+
+template <> struct MappingTraits<ArchYAML::Archive::Child> {
+  static void mapping(IO &IO, ArchYAML::Archive::Child &C);
+  static std::string validate(IO &, ArchYAML::Archive::Child &C);
+};
+
+} // end namespace yaml
+} // end namespace llvm
+
+#endif // LLVM_OBJECTYAML_ARCHIVEYAML_H
diff --git a/linux-x64/clang/include/llvm/ObjectYAML/DWARFEmitter.h b/linux-x64/clang/include/llvm/ObjectYAML/DWARFEmitter.h
index 2ccc876..eb56d1e 100644
--- a/linux-x64/clang/include/llvm/ObjectYAML/DWARFEmitter.h
+++ b/linux-x64/clang/include/llvm/ObjectYAML/DWARFEmitter.h
@@ -28,21 +28,28 @@
 struct Data;
 struct PubSection;
 
-void EmitDebugAbbrev(raw_ostream &OS, const Data &DI);
-void EmitDebugStr(raw_ostream &OS, const Data &DI);
+Error emitDebugAbbrev(raw_ostream &OS, const Data &DI);
+Error emitDebugStr(raw_ostream &OS, const Data &DI);
 
-void EmitDebugAranges(raw_ostream &OS, const Data &DI);
-void EmitPubSection(raw_ostream &OS, const PubSection &Sect,
-                    bool IsLittleEndian);
-void EmitDebugInfo(raw_ostream &OS, const Data &DI);
-void EmitDebugLine(raw_ostream &OS, const Data &DI);
+Error emitDebugAranges(raw_ostream &OS, const Data &DI);
+Error emitDebugRanges(raw_ostream &OS, const Data &DI);
+Error emitDebugPubnames(raw_ostream &OS, const Data &DI);
+Error emitDebugPubtypes(raw_ostream &OS, const Data &DI);
+Error emitDebugGNUPubnames(raw_ostream &OS, const Data &DI);
+Error emitDebugGNUPubtypes(raw_ostream &OS, const Data &DI);
+Error emitDebugInfo(raw_ostream &OS, const Data &DI);
+Error emitDebugLine(raw_ostream &OS, const Data &DI);
+Error emitDebugAddr(raw_ostream &OS, const Data &DI);
+Error emitDebugStrOffsets(raw_ostream &OS, const Data &DI);
+Error emitDebugRnglists(raw_ostream &OS, const Data &DI);
+Error emitDebugLoclists(raw_ostream &OS, const Data &DI);
 
+std::function<Error(raw_ostream &, const Data &)>
+getDWARFEmitterByName(StringRef SecName);
 Expected<StringMap<std::unique_ptr<MemoryBuffer>>>
-EmitDebugSections(StringRef YAMLString, bool ApplyFixups = false,
-                  bool IsLittleEndian = sys::IsLittleEndianHost);
-StringMap<std::unique_ptr<MemoryBuffer>>
-EmitDebugSections(llvm::DWARFYAML::Data &DI, bool ApplyFixups);
-
+emitDebugSections(StringRef YAMLString,
+                  bool IsLittleEndian = sys::IsLittleEndianHost,
+                  bool Is64BitAddrSize = true);
 } // end namespace DWARFYAML
 } // end namespace llvm
 
diff --git a/linux-x64/clang/include/llvm/ObjectYAML/DWARFYAML.h b/linux-x64/clang/include/llvm/ObjectYAML/DWARFYAML.h
index 78d736c..856cea9 100644
--- a/linux-x64/clang/include/llvm/ObjectYAML/DWARFYAML.h
+++ b/linux-x64/clang/include/llvm/ObjectYAML/DWARFYAML.h
@@ -15,35 +15,18 @@
 #ifndef LLVM_OBJECTYAML_DWARFYAML_H
 #define LLVM_OBJECTYAML_DWARFYAML_H
 
+#include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/BinaryFormat/Dwarf.h"
+#include "llvm/ObjectYAML/YAML.h"
 #include "llvm/Support/YAMLTraits.h"
 #include <cstdint>
+#include <unordered_map>
 #include <vector>
 
 namespace llvm {
 namespace DWARFYAML {
 
-struct InitialLength {
-  uint32_t TotalLength;
-  uint64_t TotalLength64;
-
-  bool isDWARF64() const { return TotalLength == UINT32_MAX; }
-
-  uint64_t getLength() const {
-    return isDWARF64() ? TotalLength64 : TotalLength;
-  }
-
-  void setLength(uint64_t Len) {
-    if (Len >= (uint64_t)UINT32_MAX) {
-      TotalLength64 = Len;
-      TotalLength = UINT32_MAX;
-    } else {
-      TotalLength = Len;
-    }
-  }
-};
-
 struct AttributeAbbrev {
   llvm::dwarf::Attribute Attribute;
   llvm::dwarf::Form Form;
@@ -51,26 +34,46 @@
 };
 
 struct Abbrev {
-  llvm::yaml::Hex32 Code;
+  Optional<yaml::Hex64> Code;
   llvm::dwarf::Tag Tag;
   llvm::dwarf::Constants Children;
   std::vector<AttributeAbbrev> Attributes;
 };
 
+struct AbbrevTable {
+  Optional<uint64_t> ID;
+  std::vector<Abbrev> Table;
+};
+
 struct ARangeDescriptor {
   llvm::yaml::Hex64 Address;
-  uint64_t Length;
+  yaml::Hex64 Length;
 };
 
 struct ARange {
-  InitialLength Length;
+  dwarf::DwarfFormat Format;
+  Optional<yaml::Hex64> Length;
   uint16_t Version;
-  uint32_t CuOffset;
-  uint8_t AddrSize;
-  uint8_t SegSize;
+  yaml::Hex64 CuOffset;
+  Optional<yaml::Hex8> AddrSize;
+  yaml::Hex8 SegSize;
   std::vector<ARangeDescriptor> Descriptors;
 };
 
+/// Class that describes a range list entry, or a base address selection entry
+/// within a range list in the .debug_ranges section.
+struct RangeEntry {
+  llvm::yaml::Hex64 LowOffset;
+  llvm::yaml::Hex64 HighOffset;
+};
+
+/// Class that describes a single range list inside the .debug_ranges section.
+struct Ranges {
+  Optional<llvm::yaml::Hex64> Offset;
+  Optional<llvm::yaml::Hex8> AddrSize;
+  std::vector<RangeEntry> Entries;
+};
+
 struct PubEntry {
   llvm::yaml::Hex32 DieOffset;
   llvm::yaml::Hex8 Descriptor;
@@ -78,11 +81,11 @@
 };
 
 struct PubSection {
-  InitialLength Length;
+  dwarf::DwarfFormat Format;
+  yaml::Hex64 Length;
   uint16_t Version;
   uint32_t UnitOffset;
   uint32_t UnitSize;
-  bool IsGNUStyle = false;
   std::vector<PubEntry> Entries;
 };
 
@@ -97,12 +100,20 @@
   std::vector<FormValue> Values;
 };
 
+/// Class that contains helpful context information when mapping YAML into DWARF
+/// data structures.
+struct DWARFContext {
+  bool IsGNUPubSec = false;
+};
+
 struct Unit {
-  InitialLength Length;
+  dwarf::DwarfFormat Format;
+  Optional<yaml::Hex64> Length;
   uint16_t Version;
+  Optional<uint8_t> AddrSize;
   llvm::dwarf::UnitType Type; // Added in DWARF 5
-  uint32_t AbbrOffset;
-  uint8_t AddrSize;
+  Optional<uint64_t> AbbrevTableID;
+  Optional<yaml::Hex64> AbbrOffset;
   std::vector<Entry> Entries;
 };
 
@@ -115,7 +126,7 @@
 
 struct LineTableOpcode {
   dwarf::LineNumberOps Opcode;
-  uint64_t ExtLen;
+  Optional<uint64_t> ExtLen;
   dwarf::LineNumberExtendedOps SubOpcode;
   uint64_t Data;
   int64_t SData;
@@ -125,48 +136,124 @@
 };
 
 struct LineTable {
-  InitialLength Length;
+  dwarf::DwarfFormat Format;
+  Optional<uint64_t> Length;
   uint16_t Version;
-  uint64_t PrologueLength;
+  Optional<uint64_t> PrologueLength;
   uint8_t MinInstLength;
   uint8_t MaxOpsPerInst;
   uint8_t DefaultIsStmt;
   uint8_t LineBase;
   uint8_t LineRange;
-  uint8_t OpcodeBase;
-  std::vector<uint8_t> StandardOpcodeLengths;
+  Optional<uint8_t> OpcodeBase;
+  Optional<std::vector<uint8_t>> StandardOpcodeLengths;
   std::vector<StringRef> IncludeDirs;
   std::vector<File> Files;
   std::vector<LineTableOpcode> Opcodes;
 };
 
+struct SegAddrPair {
+  yaml::Hex64 Segment;
+  yaml::Hex64 Address;
+};
+
+struct AddrTableEntry {
+  dwarf::DwarfFormat Format;
+  Optional<yaml::Hex64> Length;
+  yaml::Hex16 Version;
+  Optional<yaml::Hex8> AddrSize;
+  yaml::Hex8 SegSelectorSize;
+  std::vector<SegAddrPair> SegAddrPairs;
+};
+
+struct StringOffsetsTable {
+  dwarf::DwarfFormat Format;
+  Optional<yaml::Hex64> Length;
+  yaml::Hex16 Version;
+  yaml::Hex16 Padding;
+  std::vector<yaml::Hex64> Offsets;
+};
+
+struct DWARFOperation {
+  dwarf::LocationAtom Operator;
+  std::vector<yaml::Hex64> Values;
+};
+
+struct RnglistEntry {
+  dwarf::RnglistEntries Operator;
+  std::vector<yaml::Hex64> Values;
+};
+
+struct LoclistEntry {
+  dwarf::LoclistEntries Operator;
+  std::vector<yaml::Hex64> Values;
+  Optional<yaml::Hex64> DescriptionsLength;
+  std::vector<DWARFOperation> Descriptions;
+};
+
+template <typename EntryType> struct ListEntries {
+  Optional<std::vector<EntryType>> Entries;
+  Optional<yaml::BinaryRef> Content;
+};
+
+template <typename EntryType> struct ListTable {
+  dwarf::DwarfFormat Format;
+  Optional<yaml::Hex64> Length;
+  yaml::Hex16 Version;
+  Optional<yaml::Hex8> AddrSize;
+  yaml::Hex8 SegSelectorSize;
+  Optional<uint32_t> OffsetEntryCount;
+  Optional<std::vector<yaml::Hex64>> Offsets;
+  std::vector<ListEntries<EntryType>> Lists;
+};
+
 struct Data {
   bool IsLittleEndian;
-  std::vector<Abbrev> AbbrevDecls;
-  std::vector<StringRef> DebugStrings;
-  std::vector<ARange> ARanges;
-  PubSection PubNames;
-  PubSection PubTypes;
+  bool Is64BitAddrSize;
+  std::vector<AbbrevTable> DebugAbbrev;
+  Optional<std::vector<StringRef>> DebugStrings;
+  Optional<std::vector<StringOffsetsTable>> DebugStrOffsets;
+  Optional<std::vector<ARange>> DebugAranges;
+  Optional<std::vector<Ranges>> DebugRanges;
+  Optional<std::vector<AddrTableEntry>> DebugAddr;
+  Optional<PubSection> PubNames;
+  Optional<PubSection> PubTypes;
 
-  PubSection GNUPubNames;
-  PubSection GNUPubTypes;
+  Optional<PubSection> GNUPubNames;
+  Optional<PubSection> GNUPubTypes;
 
   std::vector<Unit> CompileUnits;
 
   std::vector<LineTable> DebugLines;
+  Optional<std::vector<ListTable<RnglistEntry>>> DebugRnglists;
+  Optional<std::vector<ListTable<LoclistEntry>>> DebugLoclists;
 
   bool isEmpty() const;
+
+  SetVector<StringRef> getNonEmptySectionNames() const;
+
+  struct AbbrevTableInfo {
+    uint64_t Index;
+    uint64_t Offset;
+  };
+  Expected<AbbrevTableInfo> getAbbrevTableInfoByID(uint64_t ID) const;
+  StringRef getAbbrevTableContentByIndex(uint64_t Index) const;
+
+private:
+  mutable std::unordered_map<uint64_t, AbbrevTableInfo> AbbrevTableInfoMap;
+  mutable std::unordered_map<uint64_t, std::string> AbbrevTableContents;
 };
 
 } // end namespace DWARFYAML
 } // end namespace llvm
 
-LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::yaml::Hex64)
-LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::yaml::Hex8)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::AttributeAbbrev)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::Abbrev)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::AbbrevTable)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::ARangeDescriptor)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::ARange)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::RangeEntry)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::Ranges)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::PubEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::Unit)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::FormValue)
@@ -174,6 +261,20 @@
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::File)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::LineTable)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::LineTableOpcode)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::SegAddrPair)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::AddrTableEntry)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::StringOffsetsTable)
+LLVM_YAML_IS_SEQUENCE_VECTOR(
+    llvm::DWARFYAML::ListTable<DWARFYAML::RnglistEntry>)
+LLVM_YAML_IS_SEQUENCE_VECTOR(
+    llvm::DWARFYAML::ListEntries<DWARFYAML::RnglistEntry>)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::RnglistEntry)
+LLVM_YAML_IS_SEQUENCE_VECTOR(
+    llvm::DWARFYAML::ListTable<DWARFYAML::LoclistEntry>)
+LLVM_YAML_IS_SEQUENCE_VECTOR(
+    llvm::DWARFYAML::ListEntries<DWARFYAML::LoclistEntry>)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::LoclistEntry)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::DWARFOperation)
 
 namespace llvm {
 namespace yaml {
@@ -182,6 +283,10 @@
   static void mapping(IO &IO, DWARFYAML::Data &DWARF);
 };
 
+template <> struct MappingTraits<DWARFYAML::AbbrevTable> {
+  static void mapping(IO &IO, DWARFYAML::AbbrevTable &AbbrevTable);
+};
+
 template <> struct MappingTraits<DWARFYAML::Abbrev> {
   static void mapping(IO &IO, DWARFYAML::Abbrev &Abbrev);
 };
@@ -195,7 +300,15 @@
 };
 
 template <> struct MappingTraits<DWARFYAML::ARange> {
-  static void mapping(IO &IO, DWARFYAML::ARange &Range);
+  static void mapping(IO &IO, DWARFYAML::ARange &ARange);
+};
+
+template <> struct MappingTraits<DWARFYAML::RangeEntry> {
+  static void mapping(IO &IO, DWARFYAML::RangeEntry &Entry);
+};
+
+template <> struct MappingTraits<DWARFYAML::Ranges> {
+  static void mapping(IO &IO, DWARFYAML::Ranges &Ranges);
 };
 
 template <> struct MappingTraits<DWARFYAML::PubEntry> {
@@ -230,11 +343,50 @@
   static void mapping(IO &IO, DWARFYAML::LineTable &LineTable);
 };
 
-template <> struct MappingTraits<DWARFYAML::InitialLength> {
-  static void mapping(IO &IO, DWARFYAML::InitialLength &DWARF);
+template <> struct MappingTraits<DWARFYAML::SegAddrPair> {
+  static void mapping(IO &IO, DWARFYAML::SegAddrPair &SegAddrPair);
 };
 
-#define HANDLE_DW_TAG(unused, name, unused2, unused3)                          \
+template <> struct MappingTraits<DWARFYAML::DWARFOperation> {
+  static void mapping(IO &IO, DWARFYAML::DWARFOperation &DWARFOperation);
+};
+
+template <typename EntryType>
+struct MappingTraits<DWARFYAML::ListTable<EntryType>> {
+  static void mapping(IO &IO, DWARFYAML::ListTable<EntryType> &ListTable);
+};
+
+template <typename EntryType>
+struct MappingTraits<DWARFYAML::ListEntries<EntryType>> {
+  static void mapping(IO &IO, DWARFYAML::ListEntries<EntryType> &ListEntries);
+  static std::string validate(IO &IO,
+                              DWARFYAML::ListEntries<EntryType> &ListEntries);
+};
+
+template <> struct MappingTraits<DWARFYAML::RnglistEntry> {
+  static void mapping(IO &IO, DWARFYAML::RnglistEntry &RnglistEntry);
+};
+
+template <> struct MappingTraits<DWARFYAML::LoclistEntry> {
+  static void mapping(IO &IO, DWARFYAML::LoclistEntry &LoclistEntry);
+};
+
+template <> struct MappingTraits<DWARFYAML::AddrTableEntry> {
+  static void mapping(IO &IO, DWARFYAML::AddrTableEntry &AddrTable);
+};
+
+template <> struct MappingTraits<DWARFYAML::StringOffsetsTable> {
+  static void mapping(IO &IO, DWARFYAML::StringOffsetsTable &StrOffsetsTable);
+};
+
+template <> struct ScalarEnumerationTraits<dwarf::DwarfFormat> {
+  static void enumeration(IO &IO, dwarf::DwarfFormat &Format) {
+    IO.enumCase(Format, "DWARF32", dwarf::DWARF32);
+    IO.enumCase(Format, "DWARF64", dwarf::DWARF64);
+  }
+};
+
+#define HANDLE_DW_TAG(unused, name, unused2, unused3, unused4)                 \
   io.enumCase(value, "DW_TAG_" #name, dwarf::DW_TAG_##name);
 
 template <> struct ScalarEnumerationTraits<dwarf::Tag> {
@@ -302,6 +454,34 @@
   }
 };
 
+#define HANDLE_DW_RLE(unused, name)                                            \
+  io.enumCase(value, "DW_RLE_" #name, dwarf::DW_RLE_##name);
+
+template <> struct ScalarEnumerationTraits<dwarf::RnglistEntries> {
+  static void enumeration(IO &io, dwarf::RnglistEntries &value) {
+#include "llvm/BinaryFormat/Dwarf.def"
+  }
+};
+
+#define HANDLE_DW_LLE(unused, name)                                            \
+  io.enumCase(value, "DW_LLE_" #name, dwarf::DW_LLE_##name);
+
+template <> struct ScalarEnumerationTraits<dwarf::LoclistEntries> {
+  static void enumeration(IO &io, dwarf::LoclistEntries &value) {
+#include "llvm/BinaryFormat/Dwarf.def"
+  }
+};
+
+#define HANDLE_DW_OP(id, name, version, vendor)                                \
+  io.enumCase(value, "DW_OP_" #name, dwarf::DW_OP_##name);
+
+template <> struct ScalarEnumerationTraits<dwarf::LocationAtom> {
+  static void enumeration(IO &io, dwarf::LocationAtom &value) {
+#include "llvm/BinaryFormat/Dwarf.def"
+    io.enumFallback<yaml::Hex8>(value);
+  }
+};
+
 } // end namespace yaml
 } // end namespace llvm
 
diff --git a/linux-x64/clang/include/llvm/ObjectYAML/ELFYAML.h b/linux-x64/clang/include/llvm/ObjectYAML/ELFYAML.h
index 68a0fc3..c9e9052 100644
--- a/linux-x64/clang/include/llvm/ObjectYAML/ELFYAML.h
+++ b/linux-x64/clang/include/llvm/ObjectYAML/ELFYAML.h
@@ -16,6 +16,9 @@
 #define LLVM_OBJECTYAML_ELFYAML_H
 
 #include "llvm/ADT/StringRef.h"
+#include "llvm/BinaryFormat/ELF.h"
+#include "llvm/Object/ELFTypes.h"
+#include "llvm/ObjectYAML/DWARFYAML.h"
 #include "llvm/ObjectYAML/YAML.h"
 #include "llvm/Support/YAMLTraits.h"
 #include <cstdint>
@@ -25,6 +28,9 @@
 namespace llvm {
 namespace ELFYAML {
 
+StringRef dropUniqueSuffix(StringRef S);
+std::string appendUniqueSuffix(StringRef Name, const Twine& Msg);
+
 // These types are invariant across 32/64-bit ELF, so for simplicity just
 // directly give them their exact sizes. We don't need to worry about
 // endianness because these are just the types in the YAMLIO structures,
@@ -54,8 +60,6 @@
 LLVM_YAML_STRONG_TYPEDEF(uint16_t, ELF_SHN)
 LLVM_YAML_STRONG_TYPEDEF(uint8_t, ELF_STB)
 LLVM_YAML_STRONG_TYPEDEF(uint8_t, ELF_STT)
-LLVM_YAML_STRONG_TYPEDEF(uint8_t, ELF_STV)
-LLVM_YAML_STRONG_TYPEDEF(uint8_t, ELF_STO)
 
 LLVM_YAML_STRONG_TYPEDEF(uint8_t, MIPS_AFL_REG)
 LLVM_YAML_STRONG_TYPEDEF(uint8_t, MIPS_ABI_FP)
@@ -64,6 +68,41 @@
 LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_AFL_FLAGS1)
 LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_ISA)
 
+LLVM_YAML_STRONG_TYPEDEF(StringRef, YAMLFlowString)
+LLVM_YAML_STRONG_TYPEDEF(int64_t, YAMLIntUInt)
+
+template <class ELFT>
+unsigned getDefaultShEntSize(unsigned EMachine, ELF_SHT SecType,
+                             StringRef SecName) {
+  if (EMachine == ELF::EM_MIPS && SecType == ELF::SHT_MIPS_ABIFLAGS)
+    return sizeof(object::Elf_Mips_ABIFlags<ELFT>);
+
+  switch (SecType) {
+  case ELF::SHT_GROUP:
+    return sizeof(typename ELFT::Word);
+  case ELF::SHT_REL:
+    return sizeof(typename ELFT::Rel);
+  case ELF::SHT_RELA:
+    return sizeof(typename ELFT::Rela);
+  case ELF::SHT_RELR:
+    return sizeof(typename ELFT::Relr);
+  case ELF::SHT_DYNAMIC:
+    return sizeof(typename ELFT::Dyn);
+  case ELF::SHT_HASH:
+    return sizeof(typename ELFT::Word);
+  case ELF::SHT_SYMTAB_SHNDX:
+    return sizeof(typename ELFT::Word);
+  case ELF::SHT_GNU_versym:
+    return sizeof(typename ELFT::Half);
+  case ELF::SHT_LLVM_CALL_GRAPH_PROFILE:
+    return sizeof(object::Elf_CGProfile_Impl<ELFT>);
+  default:
+    if (SecName == ".debug_str")
+      return 1;
+    return 0;
+  }
+}
+
 // For now, hardcode 64 bits everywhere that 32 or 64 would be needed
 // since 64-bit can hold 32-bit values too.
 struct FileHeader {
@@ -72,42 +111,40 @@
   ELF_ELFOSABI OSABI;
   llvm::yaml::Hex8 ABIVersion;
   ELF_ET Type;
-  ELF_EM Machine;
+  Optional<ELF_EM> Machine;
   ELF_EF Flags;
   llvm::yaml::Hex64 Entry;
 
-  Optional<llvm::yaml::Hex16> SHEntSize;
-  Optional<llvm::yaml::Hex16> SHOffset;
-  Optional<llvm::yaml::Hex16> SHNum;
-  Optional<llvm::yaml::Hex16> SHStrNdx;
+  Optional<llvm::yaml::Hex64> EPhOff;
+  Optional<llvm::yaml::Hex16> EPhEntSize;
+  Optional<llvm::yaml::Hex16> EPhNum;
+  Optional<llvm::yaml::Hex16> EShEntSize;
+  Optional<llvm::yaml::Hex64> EShOff;
+  Optional<llvm::yaml::Hex16> EShNum;
+  Optional<llvm::yaml::Hex16> EShStrNdx;
 };
 
-struct SectionName {
-  StringRef Section;
+struct SectionHeader {
+  StringRef Name;
 };
 
-struct ProgramHeader {
-  ELF_PT Type;
-  ELF_PF Flags;
-  llvm::yaml::Hex64 VAddr;
-  llvm::yaml::Hex64 PAddr;
-  Optional<llvm::yaml::Hex64> Align;
-  Optional<llvm::yaml::Hex64> FileSize;
-  Optional<llvm::yaml::Hex64> MemSize;
-  Optional<llvm::yaml::Hex64> Offset;
-  std::vector<SectionName> Sections;
+struct SectionHeaderTable {
+  Optional<std::vector<SectionHeader>> Sections;
+  Optional<std::vector<SectionHeader>> Excluded;
+  Optional<bool> NoHeaders;
 };
 
 struct Symbol {
   StringRef Name;
-  Optional<uint32_t> NameIndex;
   ELF_STT Type;
-  StringRef Section;
+  Optional<StringRef> Section;
   Optional<ELF_SHN> Index;
   ELF_STB Binding;
-  llvm::yaml::Hex64 Value;
-  llvm::yaml::Hex64 Size;
-  uint8_t Other;
+  Optional<llvm::yaml::Hex64> Value;
+  Optional<llvm::yaml::Hex64> Size;
+  Optional<uint8_t> Other;
+
+  Optional<uint32_t> StName;
 };
 
 struct SectionOrType {
@@ -119,66 +156,260 @@
   llvm::yaml::Hex64 Val;
 };
 
-struct Section {
-  enum class SectionKind {
+struct BBAddrMapEntry {
+  struct BBEntry {
+    llvm::yaml::Hex32 AddressOffset;
+    llvm::yaml::Hex32 Size;
+    llvm::yaml::Hex32 Metadata;
+  };
+  llvm::yaml::Hex64 Address;
+  Optional<std::vector<BBEntry>> BBEntries;
+};
+
+struct StackSizeEntry {
+  llvm::yaml::Hex64 Address;
+  llvm::yaml::Hex64 Size;
+};
+
+struct NoteEntry {
+  StringRef Name;
+  yaml::BinaryRef Desc;
+  llvm::yaml::Hex32 Type;
+};
+
+struct Chunk {
+  enum class ChunkKind {
     Dynamic,
     Group,
     RawContent,
     Relocation,
+    Relr,
     NoBits,
+    Note,
+    Hash,
+    GnuHash,
     Verdef,
     Verneed,
+    StackSizes,
+    SymtabShndxSection,
     Symver,
-    MipsABIFlags
+    ARMIndexTable,
+    MipsABIFlags,
+    Addrsig,
+    Fill,
+    LinkerOptions,
+    DependentLibraries,
+    CallGraphProfile,
+    BBAddrMap
   };
-  SectionKind Kind;
+
+  ChunkKind Kind;
   StringRef Name;
+  Optional<llvm::yaml::Hex64> Offset;
+
+  Chunk(ChunkKind K) : Kind(K) {}
+  virtual ~Chunk();
+};
+
+struct Section : public Chunk {
   ELF_SHT Type;
   Optional<ELF_SHF> Flags;
-  llvm::yaml::Hex64 Address;
-  StringRef Link;
+  Optional<llvm::yaml::Hex64> Address;
+  Optional<StringRef> Link;
   llvm::yaml::Hex64 AddressAlign;
   Optional<llvm::yaml::Hex64> EntSize;
 
+  Optional<yaml::BinaryRef> Content;
+  Optional<llvm::yaml::Hex64> Size;
+
+  // Usually sections are not created implicitly, but loaded from YAML.
+  // When they are, this flag is used to signal about that.
+  bool IsImplicit;
+
+  // Holds the original section index.
+  unsigned OriginalSecNdx;
+
+  Section(ChunkKind Kind, bool IsImplicit = false)
+      : Chunk(Kind), IsImplicit(IsImplicit) {}
+
+  static bool classof(const Chunk *S) { return S->Kind != ChunkKind::Fill; }
+
+  // Some derived sections might have their own special entries. This method
+  // returns a vector of <entry name, is used> pairs. It is used for section
+  // validation.
+  virtual std::vector<std::pair<StringRef, bool>> getEntries() const {
+    return {};
+  };
+
+  // The following members are used to override section fields which is
+  // useful for creating invalid objects.
+
+  // This can be used to override the sh_addralign field.
+  Optional<llvm::yaml::Hex64> ShAddrAlign;
+
+  // This can be used to override the offset stored in the sh_name field.
+  // It does not affect the name stored in the string table.
+  Optional<llvm::yaml::Hex64> ShName;
+
   // This can be used to override the sh_offset field. It does not place the
-  // section data at the offset specified. Useful for creating invalid objects.
+  // section data at the offset specified.
   Optional<llvm::yaml::Hex64> ShOffset;
 
-  Section(SectionKind Kind) : Kind(Kind) {}
-  virtual ~Section();
+  // This can be used to override the sh_size field. It does not affect the
+  // content written.
+  Optional<llvm::yaml::Hex64> ShSize;
+
+  // This can be used to override the sh_flags field.
+  Optional<llvm::yaml::Hex64> ShFlags;
+
+  // This can be used to override the sh_type field. It is useful when we
+  // want to use specific YAML keys for a section of a particular type to
+  // describe the content, but still want to have a different final type
+  // for the section.
+  Optional<ELF_SHT> ShType;
+};
+
+// Fill is a block of data which is placed outside of sections. It is
+// not present in the sections header table, but it might affect the output file
+// size and program headers produced.
+struct Fill : Chunk {
+  Optional<yaml::BinaryRef> Pattern;
+  llvm::yaml::Hex64 Size;
+
+  Fill() : Chunk(ChunkKind::Fill) {}
+
+  static bool classof(const Chunk *S) { return S->Kind == ChunkKind::Fill; }
+};
+
+struct BBAddrMapSection : Section {
+  Optional<std::vector<BBAddrMapEntry>> Entries;
+
+  BBAddrMapSection() : Section(ChunkKind::BBAddrMap) {}
+
+  std::vector<std::pair<StringRef, bool>> getEntries() const override {
+    return {{"Entries", Entries.hasValue()}};
+  };
+
+  static bool classof(const Chunk *S) {
+    return S->Kind == ChunkKind::BBAddrMap;
+  }
+};
+
+struct StackSizesSection : Section {
+  Optional<std::vector<StackSizeEntry>> Entries;
+
+  StackSizesSection() : Section(ChunkKind::StackSizes) {}
+
+  std::vector<std::pair<StringRef, bool>> getEntries() const override {
+    return {{"Entries", Entries.hasValue()}};
+  };
+
+  static bool classof(const Chunk *S) {
+    return S->Kind == ChunkKind::StackSizes;
+  }
+
+  static bool nameMatches(StringRef Name) {
+    return Name == ".stack_sizes";
+  }
 };
 
 struct DynamicSection : Section {
-  std::vector<DynamicEntry> Entries;
-  Optional<yaml::BinaryRef> Content;
+  Optional<std::vector<DynamicEntry>> Entries;
 
-  DynamicSection() : Section(SectionKind::Dynamic) {}
+  DynamicSection() : Section(ChunkKind::Dynamic) {}
 
-  static bool classof(const Section *S) {
-    return S->Kind == SectionKind::Dynamic;
-  }
+  std::vector<std::pair<StringRef, bool>> getEntries() const override {
+    return {{"Entries", Entries.hasValue()}};
+  };
+
+  static bool classof(const Chunk *S) { return S->Kind == ChunkKind::Dynamic; }
 };
 
 struct RawContentSection : Section {
-  Optional<yaml::BinaryRef> Content;
-  Optional<llvm::yaml::Hex64> Size;
   Optional<llvm::yaml::Hex64> Info;
 
-  RawContentSection() : Section(SectionKind::RawContent) {}
+  RawContentSection() : Section(ChunkKind::RawContent) {}
 
-  static bool classof(const Section *S) {
-    return S->Kind == SectionKind::RawContent;
+  static bool classof(const Chunk *S) {
+    return S->Kind == ChunkKind::RawContent;
   }
+
+  // Is used when a content is read as an array of bytes.
+  Optional<std::vector<uint8_t>> ContentBuf;
 };
 
 struct NoBitsSection : Section {
-  llvm::yaml::Hex64 Size;
+  NoBitsSection() : Section(ChunkKind::NoBits) {}
 
-  NoBitsSection() : Section(SectionKind::NoBits) {}
+  static bool classof(const Chunk *S) { return S->Kind == ChunkKind::NoBits; }
+};
 
-  static bool classof(const Section *S) {
-    return S->Kind == SectionKind::NoBits;
-  }
+struct NoteSection : Section {
+  Optional<std::vector<ELFYAML::NoteEntry>> Notes;
+
+  NoteSection() : Section(ChunkKind::Note) {}
+
+  std::vector<std::pair<StringRef, bool>> getEntries() const override {
+    return {{"Notes", Notes.hasValue()}};
+  };
+
+  static bool classof(const Chunk *S) { return S->Kind == ChunkKind::Note; }
+};
+
+struct HashSection : Section {
+  Optional<std::vector<uint32_t>> Bucket;
+  Optional<std::vector<uint32_t>> Chain;
+
+  std::vector<std::pair<StringRef, bool>> getEntries() const override {
+    return {{"Bucket", Bucket.hasValue()}, {"Chain", Chain.hasValue()}};
+  };
+
+  // The following members are used to override section fields.
+  // This is useful for creating invalid objects.
+  Optional<llvm::yaml::Hex64> NBucket;
+  Optional<llvm::yaml::Hex64> NChain;
+
+  HashSection() : Section(ChunkKind::Hash) {}
+
+  static bool classof(const Chunk *S) { return S->Kind == ChunkKind::Hash; }
+};
+
+struct GnuHashHeader {
+  // The number of hash buckets.
+  // Not used when dumping the object, but can be used to override
+  // the real number of buckets when emiting an object from a YAML document.
+  Optional<llvm::yaml::Hex32> NBuckets;
+
+  // Index of the first symbol in the dynamic symbol table
+  // included in the hash table.
+  llvm::yaml::Hex32 SymNdx;
+
+  // The number of words in the Bloom filter.
+  // Not used when dumping the object, but can be used to override the real
+  // number of words in the Bloom filter when emiting an object from a YAML
+  // document.
+  Optional<llvm::yaml::Hex32> MaskWords;
+
+  // A shift constant used by the Bloom filter.
+  llvm::yaml::Hex32 Shift2;
+};
+
+struct GnuHashSection : Section {
+  Optional<GnuHashHeader> Header;
+  Optional<std::vector<llvm::yaml::Hex64>> BloomFilter;
+  Optional<std::vector<llvm::yaml::Hex32>> HashBuckets;
+  Optional<std::vector<llvm::yaml::Hex32>> HashValues;
+
+  GnuHashSection() : Section(ChunkKind::GnuHash) {}
+
+  std::vector<std::pair<StringRef, bool>> getEntries() const override {
+    return {{"Header", Header.hasValue()},
+            {"BloomFilter", BloomFilter.hasValue()},
+            {"HashBuckets", HashBuckets.hasValue()},
+            {"HashValues", HashValues.hasValue()}};
+  };
+
+  static bool classof(const Chunk *S) { return S->Kind == ChunkKind::GnuHash; }
 };
 
 struct VernauxEntry {
@@ -195,73 +426,204 @@
 };
 
 struct VerneedSection : Section {
-  std::vector<VerneedEntry> VerneedV;
+  Optional<std::vector<VerneedEntry>> VerneedV;
   llvm::yaml::Hex64 Info;
 
-  VerneedSection() : Section(SectionKind::Verneed) {}
+  VerneedSection() : Section(ChunkKind::Verneed) {}
 
-  static bool classof(const Section *S) {
-    return S->Kind == SectionKind::Verneed;
+  std::vector<std::pair<StringRef, bool>> getEntries() const override {
+    return {{"Dependencies", VerneedV.hasValue()}};
+  };
+
+  static bool classof(const Chunk *S) {
+    return S->Kind == ChunkKind::Verneed;
+  }
+};
+
+struct AddrsigSection : Section {
+  Optional<std::vector<YAMLFlowString>> Symbols;
+
+  AddrsigSection() : Section(ChunkKind::Addrsig) {}
+
+  std::vector<std::pair<StringRef, bool>> getEntries() const override {
+    return {{"Symbols", Symbols.hasValue()}};
+  };
+
+  static bool classof(const Chunk *S) { return S->Kind == ChunkKind::Addrsig; }
+};
+
+struct LinkerOption {
+  StringRef Key;
+  StringRef Value;
+};
+
+struct LinkerOptionsSection : Section {
+  Optional<std::vector<LinkerOption>> Options;
+
+  LinkerOptionsSection() : Section(ChunkKind::LinkerOptions) {}
+
+  std::vector<std::pair<StringRef, bool>> getEntries() const override {
+    return {{"Options", Options.hasValue()}};
+  };
+
+  static bool classof(const Chunk *S) {
+    return S->Kind == ChunkKind::LinkerOptions;
+  }
+};
+
+struct DependentLibrariesSection : Section {
+  Optional<std::vector<YAMLFlowString>> Libs;
+
+  DependentLibrariesSection() : Section(ChunkKind::DependentLibraries) {}
+
+  std::vector<std::pair<StringRef, bool>> getEntries() const override {
+    return {{"Libraries", Libs.hasValue()}};
+  };
+
+  static bool classof(const Chunk *S) {
+    return S->Kind == ChunkKind::DependentLibraries;
+  }
+};
+
+// Represents the call graph profile section entry.
+struct CallGraphEntry {
+  // The symbol of the source of the edge.
+  StringRef From;
+  // The symbol index of the destination of the edge.
+  StringRef To;
+  // The weight of the edge.
+  uint64_t Weight;
+};
+
+struct CallGraphProfileSection : Section {
+  Optional<std::vector<CallGraphEntry>> Entries;
+
+  CallGraphProfileSection() : Section(ChunkKind::CallGraphProfile) {}
+
+  std::vector<std::pair<StringRef, bool>> getEntries() const override {
+    return {{"Entries", Entries.hasValue()}};
+  };
+
+  static bool classof(const Chunk *S) {
+    return S->Kind == ChunkKind::CallGraphProfile;
   }
 };
 
 struct SymverSection : Section {
-  std::vector<uint16_t> Entries;
+  Optional<std::vector<uint16_t>> Entries;
 
-  SymverSection() : Section(SectionKind::Symver) {}
+  SymverSection() : Section(ChunkKind::Symver) {}
 
-  static bool classof(const Section *S) {
-    return S->Kind == SectionKind::Symver;
-  }
+  std::vector<std::pair<StringRef, bool>> getEntries() const override {
+    return {{"Entries", Entries.hasValue()}};
+  };
+
+  static bool classof(const Chunk *S) { return S->Kind == ChunkKind::Symver; }
 };
 
 struct VerdefEntry {
-  uint16_t Version;
-  uint16_t Flags;
-  uint16_t VersionNdx;
-  uint32_t Hash;
+  Optional<uint16_t> Version;
+  Optional<uint16_t> Flags;
+  Optional<uint16_t> VersionNdx;
+  Optional<uint32_t> Hash;
   std::vector<StringRef> VerNames;
 };
 
 struct VerdefSection : Section {
-  std::vector<VerdefEntry> Entries;
+  Optional<std::vector<VerdefEntry>> Entries;
+
   llvm::yaml::Hex64 Info;
 
-  VerdefSection() : Section(SectionKind::Verdef) {}
+  VerdefSection() : Section(ChunkKind::Verdef) {}
 
-  static bool classof(const Section *S) {
-    return S->Kind == SectionKind::Verdef;
-  }
+  std::vector<std::pair<StringRef, bool>> getEntries() const override {
+    return {{"Entries", Entries.hasValue()}};
+  };
+
+  static bool classof(const Chunk *S) { return S->Kind == ChunkKind::Verdef; }
 };
 
-struct Group : Section {
+struct GroupSection : Section {
   // Members of a group contain a flag and a list of section indices
   // that are part of the group.
-  std::vector<SectionOrType> Members;
-  StringRef Signature; /* Info */
+  Optional<std::vector<SectionOrType>> Members;
+  Optional<StringRef> Signature; /* Info */
 
-  Group() : Section(SectionKind::Group) {}
+  GroupSection() : Section(ChunkKind::Group) {}
 
-  static bool classof(const Section *S) {
-    return S->Kind == SectionKind::Group;
-  }
+  std::vector<std::pair<StringRef, bool>> getEntries() const override {
+    return {{"Members", Members.hasValue()}};
+  };
+
+  static bool classof(const Chunk *S) { return S->Kind == ChunkKind::Group; }
 };
 
 struct Relocation {
   llvm::yaml::Hex64 Offset;
-  int64_t Addend;
+  YAMLIntUInt Addend;
   ELF_REL Type;
   Optional<StringRef> Symbol;
 };
 
 struct RelocationSection : Section {
-  std::vector<Relocation> Relocations;
+  Optional<std::vector<Relocation>> Relocations;
   StringRef RelocatableSec; /* Info */
 
-  RelocationSection() : Section(SectionKind::Relocation) {}
+  RelocationSection() : Section(ChunkKind::Relocation) {}
 
-  static bool classof(const Section *S) {
-    return S->Kind == SectionKind::Relocation;
+  std::vector<std::pair<StringRef, bool>> getEntries() const override {
+    return {{"Relocations", Relocations.hasValue()}};
+  };
+
+  static bool classof(const Chunk *S) {
+    return S->Kind == ChunkKind::Relocation;
+  }
+};
+
+struct RelrSection : Section {
+  Optional<std::vector<llvm::yaml::Hex64>> Entries;
+
+  RelrSection() : Section(ChunkKind::Relr) {}
+
+  std::vector<std::pair<StringRef, bool>> getEntries() const override {
+    return {{"Entries", Entries.hasValue()}};
+  };
+
+  static bool classof(const Chunk *S) {
+    return S->Kind == ChunkKind::Relr;
+  }
+};
+
+struct SymtabShndxSection : Section {
+  Optional<std::vector<uint32_t>> Entries;
+
+  SymtabShndxSection() : Section(ChunkKind::SymtabShndxSection) {}
+
+  std::vector<std::pair<StringRef, bool>> getEntries() const override {
+    return {{"Entries", Entries.hasValue()}};
+  };
+
+  static bool classof(const Chunk *S) {
+    return S->Kind == ChunkKind::SymtabShndxSection;
+  }
+};
+
+struct ARMIndexTableEntry {
+  llvm::yaml::Hex32 Offset;
+  llvm::yaml::Hex32 Value;
+};
+
+struct ARMIndexTableSection : Section {
+  Optional<std::vector<ARMIndexTableEntry>> Entries;
+
+  ARMIndexTableSection() : Section(ChunkKind::ARMIndexTable) {}
+
+  std::vector<std::pair<StringRef, bool>> getEntries() const override {
+    return {{"Entries", Entries.hasValue()}};
+  };
+
+  static bool classof(const Chunk *S) {
+    return S->Kind == ChunkKind::ARMIndexTable;
   }
 };
 
@@ -279,42 +641,92 @@
   MIPS_AFL_FLAGS1 Flags1;
   llvm::yaml::Hex32 Flags2;
 
-  MipsABIFlags() : Section(SectionKind::MipsABIFlags) {}
+  MipsABIFlags() : Section(ChunkKind::MipsABIFlags) {}
 
-  static bool classof(const Section *S) {
-    return S->Kind == SectionKind::MipsABIFlags;
+  static bool classof(const Chunk *S) {
+    return S->Kind == ChunkKind::MipsABIFlags;
   }
 };
 
+struct ProgramHeader {
+  ELF_PT Type;
+  ELF_PF Flags;
+  llvm::yaml::Hex64 VAddr;
+  llvm::yaml::Hex64 PAddr;
+  Optional<llvm::yaml::Hex64> Align;
+  Optional<llvm::yaml::Hex64> FileSize;
+  Optional<llvm::yaml::Hex64> MemSize;
+  Optional<llvm::yaml::Hex64> Offset;
+  Optional<StringRef> FirstSec;
+  Optional<StringRef> LastSec;
+
+  // This vector contains all chunks from [FirstSec, LastSec].
+  std::vector<Chunk *> Chunks;
+};
+
 struct Object {
   FileHeader Header;
+  Optional<SectionHeaderTable> SectionHeaders;
   std::vector<ProgramHeader> ProgramHeaders;
-  std::vector<std::unique_ptr<Section>> Sections;
+
+  // An object might contain output section descriptions as well as
+  // custom data that does not belong to any section.
+  std::vector<std::unique_ptr<Chunk>> Chunks;
+
   // Although in reality the symbols reside in a section, it is a lot
   // cleaner and nicer if we read them from the YAML as a separate
   // top-level key, which automatically ensures that invariants like there
   // being a single SHT_SYMTAB section are upheld.
-  std::vector<Symbol> Symbols;
-  std::vector<Symbol> DynamicSymbols;
+  Optional<std::vector<Symbol>> Symbols;
+  Optional<std::vector<Symbol>> DynamicSymbols;
+  Optional<DWARFYAML::Data> DWARF;
+
+  std::vector<Section *> getSections() {
+    std::vector<Section *> Ret;
+    for (const std::unique_ptr<Chunk> &Sec : Chunks)
+      if (auto S = dyn_cast<ELFYAML::Section>(Sec.get()))
+        Ret.push_back(S);
+    return Ret;
+  }
+
+  unsigned getMachine() const;
 };
 
+bool shouldAllocateFileSpace(ArrayRef<ProgramHeader> Phdrs,
+                             const NoBitsSection &S);
+
 } // end namespace ELFYAML
 } // end namespace llvm
 
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::StackSizeEntry)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::BBAddrMapEntry)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::BBAddrMapEntry::BBEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::DynamicEntry)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::LinkerOption)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::CallGraphEntry)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::NoteEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::ProgramHeader)
-LLVM_YAML_IS_SEQUENCE_VECTOR(std::unique_ptr<llvm::ELFYAML::Section>)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::SectionHeader)
+LLVM_YAML_IS_SEQUENCE_VECTOR(std::unique_ptr<llvm::ELFYAML::Chunk>)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::Symbol)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::VerdefEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::VernauxEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::VerneedEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::Relocation)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::SectionOrType)
-LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::SectionName)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::ARMIndexTableEntry)
 
 namespace llvm {
 namespace yaml {
 
+template <> struct ScalarTraits<ELFYAML::YAMLIntUInt> {
+  static void output(const ELFYAML::YAMLIntUInt &Val, void *Ctx,
+                     raw_ostream &Out);
+  static StringRef input(StringRef Scalar, void *Ctx,
+                         ELFYAML::YAMLIntUInt &Val);
+  static QuotingType mustQuote(StringRef) { return QuotingType::None; }
+};
+
 template <>
 struct ScalarEnumerationTraits<ELFYAML::ELF_ET> {
   static void enumeration(IO &IO, ELFYAML::ELF_ET &Value);
@@ -377,16 +789,6 @@
 };
 
 template <>
-struct ScalarEnumerationTraits<ELFYAML::ELF_STV> {
-  static void enumeration(IO &IO, ELFYAML::ELF_STV &Value);
-};
-
-template <>
-struct ScalarBitSetTraits<ELFYAML::ELF_STO> {
-  static void bitset(IO &IO, ELFYAML::ELF_STO &Value);
-};
-
-template <>
 struct ScalarEnumerationTraits<ELFYAML::ELF_REL> {
   static void enumeration(IO &IO, ELFYAML::ELF_REL &Value);
 };
@@ -436,20 +838,50 @@
   static void mapping(IO &IO, ELFYAML::FileHeader &FileHdr);
 };
 
+template <> struct MappingTraits<ELFYAML::SectionHeaderTable> {
+  static void mapping(IO &IO, ELFYAML::SectionHeaderTable &SecHdrTable);
+  static std::string validate(IO &IO, ELFYAML::SectionHeaderTable &SecHdrTable);
+};
+
+template <> struct MappingTraits<ELFYAML::SectionHeader> {
+  static void mapping(IO &IO, ELFYAML::SectionHeader &SHdr);
+};
+
 template <> struct MappingTraits<ELFYAML::ProgramHeader> {
   static void mapping(IO &IO, ELFYAML::ProgramHeader &FileHdr);
+  static std::string validate(IO &IO, ELFYAML::ProgramHeader &FileHdr);
 };
 
 template <>
 struct MappingTraits<ELFYAML::Symbol> {
   static void mapping(IO &IO, ELFYAML::Symbol &Symbol);
-  static StringRef validate(IO &IO, ELFYAML::Symbol &Symbol);
+  static std::string validate(IO &IO, ELFYAML::Symbol &Symbol);
+};
+
+template <> struct MappingTraits<ELFYAML::StackSizeEntry> {
+  static void mapping(IO &IO, ELFYAML::StackSizeEntry &Rel);
+};
+
+template <> struct MappingTraits<ELFYAML::BBAddrMapEntry> {
+  static void mapping(IO &IO, ELFYAML::BBAddrMapEntry &Rel);
+};
+
+template <> struct MappingTraits<ELFYAML::BBAddrMapEntry::BBEntry> {
+  static void mapping(IO &IO, ELFYAML::BBAddrMapEntry::BBEntry &Rel);
+};
+
+template <> struct MappingTraits<ELFYAML::GnuHashHeader> {
+  static void mapping(IO &IO, ELFYAML::GnuHashHeader &Rel);
 };
 
 template <> struct MappingTraits<ELFYAML::DynamicEntry> {
   static void mapping(IO &IO, ELFYAML::DynamicEntry &Rel);
 };
 
+template <> struct MappingTraits<ELFYAML::NoteEntry> {
+  static void mapping(IO &IO, ELFYAML::NoteEntry &N);
+};
+
 template <> struct MappingTraits<ELFYAML::VerdefEntry> {
   static void mapping(IO &IO, ELFYAML::VerdefEntry &E);
 };
@@ -462,14 +894,25 @@
   static void mapping(IO &IO, ELFYAML::VernauxEntry &E);
 };
 
+template <> struct MappingTraits<ELFYAML::LinkerOption> {
+  static void mapping(IO &IO, ELFYAML::LinkerOption &Sym);
+};
+
+template <> struct MappingTraits<ELFYAML::CallGraphEntry> {
+  static void mapping(IO &IO, ELFYAML::CallGraphEntry &E);
+};
+
 template <> struct MappingTraits<ELFYAML::Relocation> {
   static void mapping(IO &IO, ELFYAML::Relocation &Rel);
 };
 
-template <>
-struct MappingTraits<std::unique_ptr<ELFYAML::Section>> {
-  static void mapping(IO &IO, std::unique_ptr<ELFYAML::Section> &Section);
-  static StringRef validate(IO &io, std::unique_ptr<ELFYAML::Section> &Section);
+template <> struct MappingTraits<ELFYAML::ARMIndexTableEntry> {
+  static void mapping(IO &IO, ELFYAML::ARMIndexTableEntry &E);
+};
+
+template <> struct MappingTraits<std::unique_ptr<ELFYAML::Chunk>> {
+  static void mapping(IO &IO, std::unique_ptr<ELFYAML::Chunk> &C);
+  static std::string validate(IO &io, std::unique_ptr<ELFYAML::Chunk> &C);
 };
 
 template <>
@@ -481,10 +924,6 @@
   static void mapping(IO &IO, ELFYAML::SectionOrType &sectionOrType);
 };
 
-template <> struct MappingTraits<ELFYAML::SectionName> {
-  static void mapping(IO &IO, ELFYAML::SectionName &sectionName);
-};
-
 } // end namespace yaml
 } // end namespace llvm
 
diff --git a/linux-x64/clang/include/llvm/ObjectYAML/MachOYAML.h b/linux-x64/clang/include/llvm/ObjectYAML/MachOYAML.h
index d7e1c03..94e66c5 100644
--- a/linux-x64/clang/include/llvm/ObjectYAML/MachOYAML.h
+++ b/linux-x64/clang/include/llvm/ObjectYAML/MachOYAML.h
@@ -18,6 +18,7 @@
 #include "llvm/ADT/StringRef.h"
 #include "llvm/BinaryFormat/MachO.h"
 #include "llvm/ObjectYAML/DWARFYAML.h"
+#include "llvm/ObjectYAML/YAML.h"
 #include "llvm/Support/YAMLTraits.h"
 #include <cstdint>
 #include <string>
@@ -26,6 +27,20 @@
 namespace llvm {
 namespace MachOYAML {
 
+struct Relocation {
+  // Offset in the section to what is being relocated.
+  llvm::yaml::Hex32 address;
+  // Symbol index if r_extern == 1 else section index.
+  uint32_t symbolnum;
+  bool is_pcrel;
+  // Real length = 2 ^ length.
+  uint8_t length;
+  bool is_extern;
+  uint8_t type;
+  bool is_scattered;
+  int32_t value;
+};
+
 struct Section {
   char sectname[16];
   char segname[16];
@@ -39,6 +54,8 @@
   llvm::yaml::Hex32 reserved1;
   llvm::yaml::Hex32 reserved2;
   llvm::yaml::Hex32 reserved3;
+  Optional<llvm::yaml::BinaryRef> content;
+  std::vector<Relocation> relocations;
 };
 
 struct FileHeader {
@@ -141,6 +158,7 @@
 } // end namespace llvm
 
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::MachOYAML::LoadCommand)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::MachOYAML::Relocation)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::MachOYAML::Section)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::MachOYAML::RebaseOpcode)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::MachOYAML::BindOpcode)
@@ -196,8 +214,13 @@
   static void mapping(IO &IO, MachOYAML::ExportEntry &ExportEntry);
 };
 
+template <> struct MappingTraits<MachOYAML::Relocation> {
+  static void mapping(IO &IO, MachOYAML::Relocation &R);
+};
+
 template <> struct MappingTraits<MachOYAML::Section> {
   static void mapping(IO &IO, MachOYAML::Section &Section);
+  static std::string validate(IO &io, MachOYAML::Section &Section);
 };
 
 template <> struct MappingTraits<MachOYAML::NListEntry> {
diff --git a/linux-x64/clang/include/llvm/ObjectYAML/MinidumpYAML.h b/linux-x64/clang/include/llvm/ObjectYAML/MinidumpYAML.h
index 39fdd62..b0cee54 100644
--- a/linux-x64/clang/include/llvm/ObjectYAML/MinidumpYAML.h
+++ b/linux-x64/clang/include/llvm/ObjectYAML/MinidumpYAML.h
@@ -26,6 +26,8 @@
 /// from Types to Kinds is fixed and given by the static getKind function.
 struct Stream {
   enum class StreamKind {
+    Exception,
+    MemoryInfoList,
     MemoryList,
     ModuleList,
     RawContent,
@@ -102,6 +104,45 @@
 using ThreadListStream = detail::ListStream<detail::ParsedThread>;
 using MemoryListStream = detail::ListStream<detail::ParsedMemoryDescriptor>;
 
+/// ExceptionStream minidump stream.
+struct ExceptionStream : public Stream {
+  minidump::ExceptionStream MDExceptionStream;
+  yaml::BinaryRef ThreadContext;
+
+  ExceptionStream()
+      : Stream(StreamKind::Exception, minidump::StreamType::Exception),
+        MDExceptionStream({}) {}
+
+  explicit ExceptionStream(const minidump::ExceptionStream &MDExceptionStream,
+                           ArrayRef<uint8_t> ThreadContext)
+      : Stream(StreamKind::Exception, minidump::StreamType::Exception),
+        MDExceptionStream(MDExceptionStream), ThreadContext(ThreadContext) {}
+
+  static bool classof(const Stream *S) {
+    return S->Kind == StreamKind::Exception;
+  }
+};
+
+/// A structure containing the list of MemoryInfo entries comprising a
+/// MemoryInfoList stream.
+struct MemoryInfoListStream : public Stream {
+  std::vector<minidump::MemoryInfo> Infos;
+
+  MemoryInfoListStream()
+      : Stream(StreamKind::MemoryInfoList,
+               minidump::StreamType::MemoryInfoList) {}
+
+  explicit MemoryInfoListStream(
+      iterator_range<object::MinidumpFile::MemoryInfoIterator> Range)
+      : Stream(StreamKind::MemoryInfoList,
+               minidump::StreamType::MemoryInfoList),
+        Infos(Range.begin(), Range.end()) {}
+
+  static bool classof(const Stream *S) {
+    return S->Kind == StreamKind::MemoryInfoList;
+  }
+};
+
 /// A minidump stream represented as a sequence of hex bytes. This is used as a
 /// fallback when no other stream kind is suitable.
 struct RawContentStream : public Stream {
@@ -122,16 +163,16 @@
   minidump::SystemInfo Info;
   std::string CSDVersion;
 
-  explicit SystemInfoStream(const minidump::SystemInfo &Info,
-                            std::string CSDVersion)
-      : Stream(StreamKind::SystemInfo, minidump::StreamType::SystemInfo),
-        Info(Info), CSDVersion(std::move(CSDVersion)) {}
-
   SystemInfoStream()
       : Stream(StreamKind::SystemInfo, minidump::StreamType::SystemInfo) {
     memset(&Info, 0, sizeof(Info));
   }
 
+  explicit SystemInfoStream(const minidump::SystemInfo &Info,
+                            std::string CSDVersion)
+      : Stream(StreamKind::SystemInfo, minidump::StreamType::SystemInfo),
+        Info(Info), CSDVersion(std::move(CSDVersion)) {}
+
   static bool classof(const Stream *S) {
     return S->Kind == StreamKind::SystemInfo;
   }
@@ -177,12 +218,6 @@
   static Expected<Object> create(const object::MinidumpFile &File);
 };
 
-/// Serialize the minidump file represented by Obj to OS in binary form.
-void writeAsBinary(Object &Obj, raw_ostream &OS);
-
-/// Serialize the yaml string as a minidump file to OS in binary form.
-Error writeAsBinary(StringRef Yaml, raw_ostream &OS);
-
 } // namespace MinidumpYAML
 
 namespace yaml {
@@ -201,7 +236,7 @@
 
 template <> struct MappingTraits<std::unique_ptr<MinidumpYAML::Stream>> {
   static void mapping(IO &IO, std::unique_ptr<MinidumpYAML::Stream> &S);
-  static StringRef validate(IO &IO, std::unique_ptr<MinidumpYAML::Stream> &S);
+  static std::string validate(IO &IO, std::unique_ptr<MinidumpYAML::Stream> &S);
 };
 
 template <> struct MappingContextTraits<minidump::MemoryDescriptor, BinaryRef> {
@@ -213,6 +248,10 @@
 
 } // namespace llvm
 
+LLVM_YAML_DECLARE_BITSET_TRAITS(llvm::minidump::MemoryProtection)
+LLVM_YAML_DECLARE_BITSET_TRAITS(llvm::minidump::MemoryState)
+LLVM_YAML_DECLARE_BITSET_TRAITS(llvm::minidump::MemoryType)
+
 LLVM_YAML_DECLARE_ENUM_TRAITS(llvm::minidump::ProcessorArchitecture)
 LLVM_YAML_DECLARE_ENUM_TRAITS(llvm::minidump::OSPlatform)
 LLVM_YAML_DECLARE_ENUM_TRAITS(llvm::minidump::StreamType)
@@ -220,6 +259,8 @@
 LLVM_YAML_DECLARE_MAPPING_TRAITS(llvm::minidump::CPUInfo::ArmInfo)
 LLVM_YAML_DECLARE_MAPPING_TRAITS(llvm::minidump::CPUInfo::OtherInfo)
 LLVM_YAML_DECLARE_MAPPING_TRAITS(llvm::minidump::CPUInfo::X86Info)
+LLVM_YAML_DECLARE_MAPPING_TRAITS(llvm::minidump::Exception)
+LLVM_YAML_DECLARE_MAPPING_TRAITS(llvm::minidump::MemoryInfo)
 LLVM_YAML_DECLARE_MAPPING_TRAITS(llvm::minidump::VSFixedFileInfo)
 
 LLVM_YAML_DECLARE_MAPPING_TRAITS(
@@ -233,6 +274,7 @@
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::MinidumpYAML::MemoryListStream::entry_type)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::MinidumpYAML::ModuleListStream::entry_type)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::MinidumpYAML::ThreadListStream::entry_type)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::minidump::MemoryInfo)
 
 LLVM_YAML_DECLARE_MAPPING_TRAITS(llvm::MinidumpYAML::Object)
 
diff --git a/linux-x64/clang/include/llvm/ObjectYAML/ObjectYAML.h b/linux-x64/clang/include/llvm/ObjectYAML/ObjectYAML.h
index 0015fd3..dd26ce3 100644
--- a/linux-x64/clang/include/llvm/ObjectYAML/ObjectYAML.h
+++ b/linux-x64/clang/include/llvm/ObjectYAML/ObjectYAML.h
@@ -9,6 +9,7 @@
 #ifndef LLVM_OBJECTYAML_OBJECTYAML_H
 #define LLVM_OBJECTYAML_OBJECTYAML_H
 
+#include "llvm/ObjectYAML/ArchiveYAML.h"
 #include "llvm/ObjectYAML/COFFYAML.h"
 #include "llvm/ObjectYAML/ELFYAML.h"
 #include "llvm/ObjectYAML/MachOYAML.h"
@@ -23,6 +24,7 @@
 class IO;
 
 struct YamlObjectFile {
+  std::unique_ptr<ArchYAML::Archive> Arch;
   std::unique_ptr<ELFYAML::Object> Elf;
   std::unique_ptr<COFFYAML::Object> Coff;
   std::unique_ptr<MachOYAML::Object> MachO;
diff --git a/linux-x64/clang/include/llvm/ObjectYAML/WasmYAML.h b/linux-x64/clang/include/llvm/ObjectYAML/WasmYAML.h
index 2411dc7..80f1b40 100644
--- a/linux-x64/clang/include/llvm/ObjectYAML/WasmYAML.h
+++ b/linux-x64/clang/include/llvm/ObjectYAML/WasmYAML.h
@@ -53,6 +53,7 @@
 struct Table {
   TableType ElemType;
   Limits TableLimits;
+  uint32_t Index;
 };
 
 struct Export {
@@ -107,8 +108,10 @@
 struct Relocation {
   RelocType Type;
   uint32_t Index;
+  // TODO(wvo): this would strictly be better as Hex64, but that will change
+  // all existing obj2yaml output.
   yaml::Hex32 Offset;
-  int32_t Addend;
+  int64_t Addend;
 };
 
 struct DataSegment {
@@ -145,7 +148,7 @@
   uint32_t Index;
   SignatureForm Form = wasm::WASM_TYPE_FUNC;
   std::vector<ValueType> ParamTypes;
-  ValueType ReturnType;
+  std::vector<ValueType> ReturnTypes;
 };
 
 struct SymbolInfo {
@@ -218,6 +221,8 @@
   }
 
   std::vector<NameEntry> FunctionNames;
+  std::vector<NameEntry> GlobalNames;
+  std::vector<NameEntry> DataSegmentNames;
 };
 
 struct LinkingSection : CustomSection {
@@ -309,16 +314,6 @@
   std::vector<Limits> Memories;
 };
 
-struct GlobalSection : Section {
-  GlobalSection() : Section(wasm::WASM_SEC_GLOBAL) {}
-
-  static bool classof(const Section *S) {
-    return S->Type == wasm::WASM_SEC_GLOBAL;
-  }
-
-  std::vector<Global> Globals;
-};
-
 struct EventSection : Section {
   EventSection() : Section(wasm::WASM_SEC_EVENT) {}
 
@@ -329,6 +324,16 @@
   std::vector<Event> Events;
 };
 
+struct GlobalSection : Section {
+  GlobalSection() : Section(wasm::WASM_SEC_GLOBAL) {}
+
+  static bool classof(const Section *S) {
+    return S->Type == wasm::WASM_SEC_GLOBAL;
+  }
+
+  std::vector<Global> Globals;
+};
+
 struct ExportSection : Section {
   ExportSection() : Section(wasm::WASM_SEC_EXPORT) {}
 
diff --git a/linux-x64/clang/include/llvm/ObjectYAML/YAML.h b/linux-x64/clang/include/llvm/ObjectYAML/YAML.h
index 3701410..3bf6527 100644
--- a/linux-x64/clang/include/llvm/ObjectYAML/YAML.h
+++ b/linux-x64/clang/include/llvm/ObjectYAML/YAML.h
@@ -85,7 +85,8 @@
 
   /// Write the contents (regardless of whether it is binary or a
   /// hex string) as binary to the given raw_ostream.
-  void writeAsBinary(raw_ostream &OS) const;
+  /// N can be used to specify the maximum number of bytes.
+  void writeAsBinary(raw_ostream &OS, uint64_t N = UINT64_MAX) const;
 
   /// Write the contents (regardless of whether it is binary or a
   /// hex string) as hex to the given raw_ostream.
diff --git a/linux-x64/clang/include/llvm/ObjectYAML/yaml2obj.h b/linux-x64/clang/include/llvm/ObjectYAML/yaml2obj.h
new file mode 100644
index 0000000..1f69347
--- /dev/null
+++ b/linux-x64/clang/include/llvm/ObjectYAML/yaml2obj.h
@@ -0,0 +1,73 @@
+//===--- yaml2obj.h - -------------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+/// \file
+/// Common declarations for yaml2obj
+//===----------------------------------------------------------------------===//
+#ifndef LLVM_TOOLS_YAML2OBJ_YAML2OBJ_H
+#define LLVM_TOOLS_YAML2OBJ_YAML2OBJ_H
+
+#include "llvm/ADT/STLExtras.h"
+#include <memory>
+
+namespace llvm {
+class raw_ostream;
+template <typename T> class SmallVectorImpl;
+class StringRef;
+class Twine;
+
+namespace object {
+class ObjectFile;
+}
+
+namespace COFFYAML {
+struct Object;
+}
+
+namespace ELFYAML {
+struct Object;
+}
+
+namespace MinidumpYAML {
+struct Object;
+}
+
+namespace WasmYAML {
+struct Object;
+}
+
+namespace ArchYAML {
+struct Archive;
+}
+
+namespace yaml {
+class Input;
+struct YamlObjectFile;
+
+using ErrorHandler = llvm::function_ref<void(const Twine &Msg)>;
+
+bool yaml2archive(ArchYAML::Archive &Doc, raw_ostream &Out, ErrorHandler EH);
+bool yaml2coff(COFFYAML::Object &Doc, raw_ostream &Out, ErrorHandler EH);
+bool yaml2elf(ELFYAML::Object &Doc, raw_ostream &Out, ErrorHandler EH,
+              uint64_t MaxSize);
+bool yaml2macho(YamlObjectFile &Doc, raw_ostream &Out, ErrorHandler EH);
+bool yaml2minidump(MinidumpYAML::Object &Doc, raw_ostream &Out,
+                   ErrorHandler EH);
+bool yaml2wasm(WasmYAML::Object &Doc, raw_ostream &Out, ErrorHandler EH);
+
+bool convertYAML(Input &YIn, raw_ostream &Out, ErrorHandler ErrHandler,
+                 unsigned DocNum = 1, uint64_t MaxSize = UINT64_MAX);
+
+/// Convenience function for tests.
+std::unique_ptr<object::ObjectFile>
+yaml2ObjectFile(SmallVectorImpl<char> &Storage, StringRef Yaml,
+                ErrorHandler ErrHandler);
+
+} // namespace yaml
+} // namespace llvm
+
+#endif
diff --git a/linux-x64/clang/include/llvm/Option/ArgList.h b/linux-x64/clang/include/llvm/Option/ArgList.h
index 74bfadc..9ce7839 100644
--- a/linux-x64/clang/include/llvm/Option/ArgList.h
+++ b/linux-x64/clang/include/llvm/Option/ArgList.h
@@ -412,6 +412,10 @@
     return ArgStrings[Index];
   }
 
+  void replaceArgString(unsigned Index, const Twine &S) {
+    ArgStrings[Index] = MakeArgString(S);
+  }
+
   unsigned getNumInputArgStrings() const override {
     return NumInputArgStrings;
   }
diff --git a/linux-x64/clang/include/llvm/Option/OptParser.td b/linux-x64/clang/include/llvm/Option/OptParser.td
index a68f17a..94437ef 100644
--- a/linux-x64/clang/include/llvm/Option/OptParser.td
+++ b/linux-x64/clang/include/llvm/Option/OptParser.td
@@ -13,7 +13,7 @@
 
 // Define the kinds of options.
 
-class OptionKind<string name, int precedence = 0, bit sentinel = 0> {
+class OptionKind<string name, int precedence = 0, bit sentinel = false> {
   string Name = name;
   // The kind precedence, kinds with lower precedence are matched first.
   int Precedence = precedence;
@@ -24,9 +24,9 @@
 // An option group.
 def KIND_GROUP : OptionKind<"Group">;
 // The input option kind.
-def KIND_INPUT : OptionKind<"Input", 1, 1>;
+def KIND_INPUT : OptionKind<"Input", 1, true>;
 // The unknown option kind.
-def KIND_UNKNOWN : OptionKind<"Unknown", 2, 1>;
+def KIND_UNKNOWN : OptionKind<"Unknown", 2, true>;
 // A flag with no values.
 def KIND_FLAG : OptionKind<"Flag">;
 // An option which prefixes its (single) value.
@@ -97,6 +97,20 @@
   OptionGroup Group = ?;
   Option Alias = ?;
   list<string> AliasArgs = [];
+  code MacroPrefix = "";
+  code KeyPath = ?;
+  code DefaultValue = ?;
+  code ImpliedValue = ?;
+  code ImpliedCheck = "false";
+  code ShouldParse = "true";
+  bit ShouldAlwaysEmit = false;
+  code NormalizerRetTy = ?;
+  code NormalizedValuesScope = "";
+  code Normalizer = "";
+  code Denormalizer = "";
+  code ValueMerger = "mergeForwardValue";
+  code ValueExtractor = "extractForwardValue";
+  list<code> NormalizedValues = ?;
 }
 
 // Helpers for defining options.
@@ -130,6 +144,88 @@
 class Values<string value> { string Values = value; }
 class ValuesCode<code valuecode> { code ValuesCode = valuecode; }
 
+// Helpers for defining marshalling information.
+
+class KeyPathAndMacro<string key_path_prefix, string key_path_base,
+                      string macro_prefix = ""> {
+  code KeyPath = !strconcat(key_path_prefix, key_path_base);
+  code MacroPrefix = macro_prefix;
+}
+
+def EmptyKPM : KeyPathAndMacro<"", "">;
+
+class ImpliedByAnyOf<list<Option> options, code value = "true"> {
+  code ImpliedCheck = !foldl("false", options, accumulator, option,
+                             !strconcat(accumulator, " || ", option.KeyPath));
+  code ImpliedValue = value;
+}
+
+class MarshallingInfo<KeyPathAndMacro kpm, code defaultvalue> {
+  code KeyPath = kpm.KeyPath;
+  code MacroPrefix = kpm.MacroPrefix;
+  code DefaultValue = defaultvalue;
+}
+
+class MarshallingInfoString<KeyPathAndMacro kpm, code defaultvalue="std::string()">
+  : MarshallingInfo<kpm, defaultvalue> {
+  code Normalizer = "normalizeString";
+  code Denormalizer = "denormalizeString";
+}
+
+class MarshallingInfoStringInt<KeyPathAndMacro kpm, code defaultvalue="0", code type="unsigned">
+  : MarshallingInfo<kpm, defaultvalue> {
+  code Normalizer = "normalizeStringIntegral<"#type#">";
+  code Denormalizer = "denormalizeString";
+}
+
+class MarshallingInfoStringVector<KeyPathAndMacro kpm>
+  : MarshallingInfo<kpm, "std::vector<std::string>({})"> {
+  code Normalizer = "normalizeStringVector";
+  code Denormalizer = "denormalizeStringVector";
+}
+
+class MarshallingInfoFlag<KeyPathAndMacro kpm, code defaultvalue = "false">
+  : MarshallingInfo<kpm, defaultvalue> {
+  code Normalizer = "normalizeSimpleFlag";
+  code Denormalizer = "denormalizeSimpleFlag";
+}
+
+class MarshallingInfoNegativeFlag<KeyPathAndMacro kpm, code defaultvalue = "true">
+  : MarshallingInfo<kpm, defaultvalue> {
+  code Normalizer = "normalizeSimpleNegativeFlag";
+  code Denormalizer = "denormalizeSimpleFlag";
+}
+
+class MarshallingInfoBitfieldFlag<KeyPathAndMacro kpm, code value>
+  : MarshallingInfoFlag<kpm, "0u"> {
+  code Normalizer = "makeFlagToValueNormalizer("#value#")";
+  code ValueMerger = "mergeMaskValue";
+  code ValueExtractor = "(extractMaskValue<unsigned, decltype("#value#"), "#value#">)";
+}
+
+// Marshalling info for booleans. Applied to the flag setting keypath to false.
+class MarshallingInfoBooleanFlag<KeyPathAndMacro kpm, code defaultvalue, code value, code name,
+                                 code other_value, code other_name>
+  : MarshallingInfoFlag<kpm, defaultvalue> {
+  code Normalizer = "makeBooleanOptionNormalizer("#value#", "#other_value#", OPT_"#other_name#")";
+  code Denormalizer = "makeBooleanOptionDenormalizer("#value#")";
+}
+
+// Mixins for additional marshalling attributes.
+
+class ShouldParseIf<code condition> { code ShouldParse = condition; }
+class AlwaysEmit { bit ShouldAlwaysEmit = true; }
+class Normalizer<code normalizer> { code Normalizer = normalizer; }
+class Denormalizer<code denormalizer> { code Denormalizer = denormalizer; }
+class NormalizedValuesScope<code scope> { code NormalizedValuesScope = scope; }
+class NormalizedValues<list<code> definitions> { list<code> NormalizedValues = definitions; } 
+class AutoNormalizeEnum {
+  code Normalizer = "normalizeSimpleEnum";
+  code Denormalizer = "denormalizeSimpleEnum";
+}
+class ValueMerger<code merger> { code ValueMerger = merger; }
+class ValueExtractor<code extractor> { code ValueExtractor = extractor; }
+
 // Predefined options.
 
 // FIXME: Have generator validate that these appear in correct position (and
diff --git a/linux-x64/clang/include/llvm/Option/OptTable.h b/linux-x64/clang/include/llvm/Option/OptTable.h
index 5db3043..58c09b2 100644
--- a/linux-x64/clang/include/llvm/Option/OptTable.h
+++ b/linux-x64/clang/include/llvm/Option/OptTable.h
@@ -13,6 +13,7 @@
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/Option/OptSpecifier.h"
+#include "llvm/Support/StringSaver.h"
 #include <cassert>
 #include <string>
 #include <vector>
@@ -20,6 +21,7 @@
 namespace llvm {
 
 class raw_ostream;
+template <typename Fn> class function_ref;
 
 namespace opt {
 
@@ -48,7 +50,7 @@
     unsigned ID;
     unsigned char Kind;
     unsigned char Param;
-    unsigned short Flags;
+    unsigned int Flags;
     unsigned short GroupID;
     unsigned short AliasID;
     const char *AliasArgs;
@@ -59,6 +61,8 @@
   /// The option information table.
   std::vector<Info> OptionInfos;
   bool IgnoreCase;
+  bool GroupedShortOptions = false;
+  const char *EnvVar = nullptr;
 
   unsigned TheInputOptionID = 0;
   unsigned TheUnknownOptionID = 0;
@@ -79,6 +83,8 @@
     return OptionInfos[id - 1];
   }
 
+  Arg *parseOneArgGrouped(InputArgList &Args, unsigned &Index) const;
+
 protected:
   OptTable(ArrayRef<Info> OptionInfos, bool IgnoreCase = false);
 
@@ -120,6 +126,12 @@
     return getInfo(id).MetaVar;
   }
 
+  /// Specify the environment variable where initial options should be read.
+  void setInitialOptionsFromEnvironment(const char *E) { EnvVar = E; }
+
+  /// Support grouped short options. e.g. -ab represents -a -b.
+  void setGroupedShortOptions(bool Value) { GroupedShortOptions = Value; }
+
   /// Find possible value for given flags. This is used for shell
   /// autocompletion.
   ///
@@ -140,7 +152,7 @@
   ///
   /// \return The vector of flags which start with Cur.
   std::vector<std::string> findByPrefix(StringRef Cur,
-                                        unsigned short DisableFlags) const;
+                                        unsigned int DisableFlags) const;
 
   /// Find the OptTable option that most closely matches the given string.
   ///
@@ -213,6 +225,18 @@
                          unsigned &MissingArgCount, unsigned FlagsToInclude = 0,
                          unsigned FlagsToExclude = 0) const;
 
+  /// A convenience helper which handles optional initial options populated from
+  /// an environment variable, expands response files recursively and parses
+  /// options.
+  ///
+  /// \param ErrorFn - Called on a formatted error message for missing arguments
+  /// or unknown options.
+  /// \return An InputArgList; on error this will contain all the options which
+  /// could be parsed.
+  InputArgList parseArgs(int Argc, char *const *Argv, OptSpecifier Unknown,
+                         StringSaver &Saver,
+                         function_ref<void(StringRef)> ErrorFn) const;
+
   /// Render the help text for an option table.
   ///
   /// \param OS - The stream to write the help text to.
diff --git a/linux-x64/clang/include/llvm/Option/Option.h b/linux-x64/clang/include/llvm/Option/Option.h
index 33813d2..196cf65 100644
--- a/linux-x64/clang/include/llvm/Option/Option.h
+++ b/linux-x64/clang/include/llvm/Option/Option.h
@@ -130,11 +130,23 @@
 
   /// Get the name of this option with the default prefix.
   std::string getPrefixedName() const {
-    std::string Ret = getPrefix();
+    std::string Ret(getPrefix());
     Ret += getName();
     return Ret;
   }
 
+  /// Get the help text for this option.
+  StringRef getHelpText() const {
+    assert(Info && "Must have a valid info!");
+    return Info->HelpText;
+  }
+
+  /// Get the meta-variable list for this option.
+  StringRef getMetaVar() const {
+    assert(Info && "Must have a valid info!");
+    return Info->MetaVar;
+  }
+
   unsigned getNumArgs() const { return Info->Param; }
 
   bool hasNoOptAsInput() const { return Info->Flags & RenderAsInput;}
@@ -201,14 +213,16 @@
   /// Index to the position where argument parsing should resume
   /// (even if the argument is missing values).
   ///
-  /// \param ArgSize The number of bytes taken up by the matched Option prefix
-  ///                and name. This is used to determine where joined values
-  ///                start.
-  Arg *accept(const ArgList &Args, unsigned &Index, unsigned ArgSize) const;
+  /// \p CurArg The argument to be matched. It may be shorter than the
+  /// underlying storage to represent a Joined argument.
+  /// \p GroupedShortOption If true, we are handling the fallback case of
+  /// parsing a prefix of the current argument as a short option.
+  Arg *accept(const ArgList &Args, StringRef CurArg, bool GroupedShortOption,
+              unsigned &Index) const;
 
 private:
-  Arg *acceptInternal(const ArgList &Args, unsigned &Index,
-                      unsigned ArgSize) const;
+  Arg *acceptInternal(const ArgList &Args, StringRef CurArg,
+                      unsigned &Index) const;
 
 public:
   void print(raw_ostream &O) const;
diff --git a/linux-x64/clang/include/llvm/Pass.h b/linux-x64/clang/include/llvm/Pass.h
index 329f7ea..8aa9ba9 100644
--- a/linux-x64/clang/include/llvm/Pass.h
+++ b/linux-x64/clang/include/llvm/Pass.h
@@ -28,14 +28,12 @@
 #ifndef LLVM_PASS_H
 #define LLVM_PASS_H
 
-#include "llvm/ADT/StringRef.h"
 #include <string>
 
 namespace llvm {
 
 class AnalysisResolver;
 class AnalysisUsage;
-class BasicBlock;
 class Function;
 class ImmutablePass;
 class Module;
@@ -43,6 +41,7 @@
 class PMDataManager;
 class PMStack;
 class raw_ostream;
+class StringRef;
 
 // AnalysisID - Use the PassInfo to identify a pass...
 using AnalysisID = const void *;
@@ -57,13 +56,11 @@
   PMT_FunctionPassManager,   ///< FPPassManager
   PMT_LoopPassManager,       ///< LPPassManager
   PMT_RegionPassManager,     ///< RGPassManager
-  PMT_BasicBlockPassManager, ///< BBPassManager
   PMT_Last
 };
 
 // Different types of passes.
 enum PassKind {
-  PT_BasicBlock,
   PT_Region,
   PT_Loop,
   PT_Function,
@@ -72,6 +69,20 @@
   PT_PassManager
 };
 
+/// This enumerates the LLVM full LTO or ThinLTO optimization phases.
+enum class ThinOrFullLTOPhase {
+  /// No LTO/ThinLTO behavior needed.
+  None,
+  /// ThinLTO prelink (summary) phase.
+  ThinLTOPreLink,
+  /// ThinLTO postlink (backend compile) phase.
+  ThinLTOPostLink,
+  /// Full LTO prelink phase.
+  FullLTOPreLink,
+  /// Full LTO postlink (backend compile) phase.
+  FullLTOPostLink
+};
+
 //===----------------------------------------------------------------------===//
 /// Pass interface - Implemented by all 'passes'.  Subclass this if you are an
 /// interprocedural optimization or you do not fit into any of the more
@@ -206,14 +217,17 @@
   template<typename AnalysisType>
   AnalysisType &getAnalysis() const; // Defined in PassAnalysisSupport.h
 
-  template<typename AnalysisType>
-  AnalysisType &getAnalysis(Function &F); // Defined in PassAnalysisSupport.h
+  template <typename AnalysisType>
+  AnalysisType &
+  getAnalysis(Function &F,
+              bool *Changed = nullptr); // Defined in PassAnalysisSupport.h
 
   template<typename AnalysisType>
   AnalysisType &getAnalysisID(AnalysisID PI) const;
 
-  template<typename AnalysisType>
-  AnalysisType &getAnalysisID(AnalysisID PI, Function &F);
+  template <typename AnalysisType>
+  AnalysisType &getAnalysisID(AnalysisID PI, Function &F,
+                              bool *Changed = nullptr);
 };
 
 //===----------------------------------------------------------------------===//
@@ -305,61 +319,21 @@
   bool skipFunction(const Function &F) const;
 };
 
-//===----------------------------------------------------------------------===//
-/// BasicBlockPass class - This class is used to implement most local
-/// optimizations.  Optimizations should subclass this class if they
-/// meet the following constraints:
-///   1. Optimizations are local, operating on either a basic block or
-///      instruction at a time.
-///   2. Optimizations do not modify the CFG of the contained function, or any
-///      other basic block in the function.
-///   3. Optimizations conform to all of the constraints of FunctionPasses.
-///
-class BasicBlockPass : public Pass {
-public:
-  explicit BasicBlockPass(char &pid) : Pass(PT_BasicBlock, pid) {}
-
-  /// createPrinterPass - Get a basic block printer pass.
-  Pass *createPrinterPass(raw_ostream &OS,
-                          const std::string &Banner) const override;
-
-  using llvm::Pass::doInitialization;
-  using llvm::Pass::doFinalization;
-
-  /// doInitialization - Virtual method overridden by BasicBlockPass subclasses
-  /// to do any necessary per-function initialization.
-  virtual bool doInitialization(Function &);
-
-  /// runOnBasicBlock - Virtual method overriden by subclasses to do the
-  /// per-basicblock processing of the pass.
-  virtual bool runOnBasicBlock(BasicBlock &BB) = 0;
-
-  /// doFinalization - Virtual method overriden by BasicBlockPass subclasses to
-  /// do any post processing needed after all passes have run.
-  virtual bool doFinalization(Function &);
-
-  void assignPassManager(PMStack &PMS, PassManagerType T) override;
-
-  ///  Return what kind of Pass Manager can manage this pass.
-  PassManagerType getPotentialPassManagerType() const override;
-
-protected:
-  /// Optional passes call this function to check whether the pass should be
-  /// skipped. This is the case when Attribute::OptimizeNone is set or when
-  /// optimization bisect is over the limit.
-  bool skipBasicBlock(const BasicBlock &BB) const;
-};
-
 /// If the user specifies the -time-passes argument on an LLVM tool command line
 /// then the value of this boolean will be true, otherwise false.
 /// This is the storage for the -time-passes option.
 extern bool TimePassesIsEnabled;
+/// If TimePassesPerRun is true, there would be one line of report for
+/// each pass invocation.
+/// If TimePassesPerRun is false, there would be only one line of
+/// report for each pass (even there are more than one pass objects).
+/// (For new pass manager only)
+extern bool TimePassesPerRun;
 
 } // end namespace llvm
 
 // Include support files that contain important APIs commonly used by Passes,
 // but that we want to separate out to make it easier to read the header files.
-#include "llvm/InitializePasses.h"
 #include "llvm/PassAnalysisSupport.h"
 #include "llvm/PassSupport.h"
 
diff --git a/linux-x64/clang/include/llvm/PassAnalysisSupport.h b/linux-x64/clang/include/llvm/PassAnalysisSupport.h
index 1228534..4e28466 100644
--- a/linux-x64/clang/include/llvm/PassAnalysisSupport.h
+++ b/linux-x64/clang/include/llvm/PassAnalysisSupport.h
@@ -15,13 +15,16 @@
 //
 //===----------------------------------------------------------------------===//
 
+#if !defined(LLVM_PASS_H) || defined(LLVM_PASSANALYSISSUPPORT_H)
+#error "Do not include <PassAnalysisSupport.h>; include <Pass.h> instead"
+#endif 
+
 #ifndef LLVM_PASSANALYSISSUPPORT_H
 #define LLVM_PASSANALYSISSUPPORT_H
 
-#include "Pass.h"
 #include "llvm/ADT/SmallVector.h"
-#include "llvm/ADT/StringRef.h"
 #include <cassert>
+#include <tuple>
 #include <utility>
 #include <vector>
 
@@ -30,6 +33,7 @@
 class Function;
 class Pass;
 class PMDataManager;
+class StringRef;
 
 //===----------------------------------------------------------------------===//
 /// Represent the analysis usage information of a pass.  This tracks analyses
@@ -164,7 +168,7 @@
   }
 
   /// Find pass that is implementing PI. Initialize pass for Function F.
-  Pass *findImplPass(Pass *P, AnalysisID PI, Function &F);
+  std::tuple<Pass *, bool> findImplPass(Pass *P, AnalysisID PI, Function &F);
 
   void addAnalysisImplsPair(AnalysisID PI, Pass *P) {
     if (findImplPass(PI) == P)
@@ -179,7 +183,7 @@
   }
 
   /// Return analysis result or null if it doesn't exist.
-  Pass *getAnalysisIfAvailable(AnalysisID ID, bool Direction) const;
+  Pass *getAnalysisIfAvailable(AnalysisID ID) const;
 
 private:
   /// This keeps track of which passes implements the interfaces that are
@@ -203,7 +207,7 @@
 
   const void *PI = &AnalysisType::ID;
 
-  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
+  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI);
   if (!ResultPass) return nullptr;
 
   // Because the AnalysisType may not be a subclass of pass (for
@@ -243,23 +247,33 @@
 
 /// getAnalysis<AnalysisType>() - This function is used by subclasses to get
 /// to the analysis information that they claim to use by overriding the
-/// getAnalysisUsage function.
-template<typename AnalysisType>
-AnalysisType &Pass::getAnalysis(Function &F) {
+/// getAnalysisUsage function. If as part of the dependencies, an IR
+/// transformation is triggered (e.g. because the analysis requires
+/// BreakCriticalEdges), and Changed is non null, *Changed is updated.
+template <typename AnalysisType>
+AnalysisType &Pass::getAnalysis(Function &F, bool *Changed) {
   assert(Resolver &&"Pass has not been inserted into a PassManager object!");
 
-  return getAnalysisID<AnalysisType>(&AnalysisType::ID, F);
+  return getAnalysisID<AnalysisType>(&AnalysisType::ID, F, Changed);
 }
 
-template<typename AnalysisType>
-AnalysisType &Pass::getAnalysisID(AnalysisID PI, Function &F) {
+template <typename AnalysisType>
+AnalysisType &Pass::getAnalysisID(AnalysisID PI, Function &F, bool *Changed) {
   assert(PI && "getAnalysis for unregistered pass!");
   assert(Resolver && "Pass has not been inserted into a PassManager object!");
   // PI *must* appear in AnalysisImpls.  Because the number of passes used
   // should be a small number, we just do a linear search over a (dense)
   // vector.
-  Pass *ResultPass = Resolver->findImplPass(this, PI, F);
+  Pass *ResultPass;
+  bool LocalChanged;
+  std::tie(ResultPass, LocalChanged) = Resolver->findImplPass(this, PI, F);
+
   assert(ResultPass && "Unable to find requested analysis info");
+  if (Changed)
+    *Changed |= LocalChanged;
+  else
+    assert(!LocalChanged &&
+           "A pass trigged a code update but the update status is lost");
 
   // Because the AnalysisType may not be a subclass of pass (for
   // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
diff --git a/linux-x64/clang/include/llvm/PassSupport.h b/linux-x64/clang/include/llvm/PassSupport.h
index ab90217..e95ed7a 100644
--- a/linux-x64/clang/include/llvm/PassSupport.h
+++ b/linux-x64/clang/include/llvm/PassSupport.h
@@ -17,6 +17,10 @@
 //
 //===----------------------------------------------------------------------===//
 
+#if !defined(LLVM_PASS_H) || defined(LLVM_PASSSUPPORT_H)
+#error "Do not include <PassSupport.h>; include <Pass.h> instead"
+#endif
+
 #ifndef LLVM_PASSSUPPORT_H
 #define LLVM_PASSSUPPORT_H
 
diff --git a/linux-x64/clang/include/llvm/Passes/PassBuilder.h b/linux-x64/clang/include/llvm/Passes/PassBuilder.h
index 5e66605..28f9e83 100644
--- a/linux-x64/clang/include/llvm/Passes/PassBuilder.h
+++ b/linux-x64/clang/include/llvm/Passes/PassBuilder.h
@@ -19,6 +19,7 @@
 #include "llvm/Analysis/CGSCCPassManager.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/Support/Error.h"
+#include "llvm/Transforms/IPO/Inliner.h"
 #include "llvm/Transforms/Instrumentation.h"
 #include "llvm/Transforms/Scalar/LoopPassManager.h"
 #include <vector>
@@ -35,11 +36,15 @@
   enum CSPGOAction { NoCSAction, CSIRInstr, CSIRUse };
   PGOOptions(std::string ProfileFile = "", std::string CSProfileGenFile = "",
              std::string ProfileRemappingFile = "", PGOAction Action = NoAction,
-             CSPGOAction CSAction = NoCSAction, bool SamplePGOSupport = false)
+             CSPGOAction CSAction = NoCSAction,
+             bool DebugInfoForProfiling = false,
+             bool PseudoProbeForProfiling = false)
       : ProfileFile(ProfileFile), CSProfileGenFile(CSProfileGenFile),
         ProfileRemappingFile(ProfileRemappingFile), Action(Action),
-        CSAction(CSAction),
-        SamplePGOSupport(SamplePGOSupport || Action == SampleUse) {
+        CSAction(CSAction), DebugInfoForProfiling(DebugInfoForProfiling ||
+                                                  (Action == SampleUse &&
+                                                   !PseudoProbeForProfiling)),
+        PseudoProbeForProfiling(PseudoProbeForProfiling) {
     // Note, we do allow ProfileFile.empty() for Action=IRUse LTO can
     // callback with IRUse action without ProfileFile.
 
@@ -54,16 +59,26 @@
     // a profile.
     assert(this->CSAction != CSIRUse || this->Action == IRUse);
 
-    // If neither Action nor CSAction, SamplePGOSupport needs to be true.
+    // If neither Action nor CSAction, DebugInfoForProfiling or
+    // PseudoProbeForProfiling needs to be true.
     assert(this->Action != NoAction || this->CSAction != NoCSAction ||
-           this->SamplePGOSupport);
+           this->DebugInfoForProfiling || this->PseudoProbeForProfiling);
+
+    // Pseudo probe emission does not work with -fdebug-info-for-profiling since
+    // they both use the discriminator field of debug lines but for different
+    // purposes.
+    if (this->DebugInfoForProfiling && this->PseudoProbeForProfiling) {
+      report_fatal_error(
+          "Pseudo probes cannot be used with -debug-info-for-profiling", false);
+    }
   }
   std::string ProfileFile;
   std::string CSProfileGenFile;
   std::string ProfileRemappingFile;
   PGOAction Action;
   CSPGOAction CSAction;
-  bool SamplePGOSupport;
+  bool DebugInfoForProfiling;
+  bool PseudoProbeForProfiling;
 };
 
 /// Tunable parameters for passes in the default pipelines.
@@ -73,16 +88,15 @@
   /// can be set in the PassBuilder when using a LLVM as a library.
   PipelineTuningOptions();
 
-  /// Tuning option to set loop interleaving on/off. Its default value is that
-  /// of the flag: `-interleave-loops`.
+  /// Tuning option to set loop interleaving on/off, set based on opt level.
   bool LoopInterleaving;
 
-  /// Tuning option to enable/disable loop vectorization. Its default value is
-  /// that of the flag: `-vectorize-loops`.
+  /// Tuning option to enable/disable loop vectorization, set based on opt
+  /// level.
   bool LoopVectorization;
 
-  /// Tuning option to enable/disable slp loop vectorization. Its default value
-  /// is that of the flag: `vectorize-slp`.
+  /// Tuning option to enable/disable slp loop vectorization, set based on opt
+  /// level.
   bool SLPVectorization;
 
   /// Tuning option to enable/disable loop unrolling. Its default value is true.
@@ -92,6 +106,12 @@
   /// is that of the flag: `-forget-scev-loop-unroll`.
   bool ForgetAllSCEVInLoopUnroll;
 
+  /// Tuning option to enable/disable coroutine intrinsic lowering. Its default
+  /// value is false. Frontends such as Clang may enable this conditionally. For
+  /// example, Clang enables this option if the flags `-std=c++2a` or above, or
+  /// `-fcoroutines-ts`, have been specified.
+  bool Coroutines;
+
   /// Tuning option to cap the number of calls to retrive clobbering accesses in
   /// MemorySSA, in LICM.
   unsigned LicmMssaOptCap;
@@ -99,6 +119,17 @@
   /// Tuning option to disable promotion to scalars in LICM with MemorySSA, if
   /// the number of access is too large.
   unsigned LicmMssaNoAccForPromotionCap;
+
+  /// Tuning option to enable/disable call graph profile. Its default value is
+  /// that of the flag: `-enable-npm-call-graph-profile`.
+  bool CallGraphProfile;
+
+  /// Tuning option to enable/disable function merging. Its default value is
+  /// false.
+  bool MergeFunctions;
+
+  /// Uniquefy function linkage name. Its default value is false.
+  bool UniqueLinkageNames;
 };
 
 /// This class provides access to building LLVM's passes.
@@ -108,6 +139,7 @@
 /// of the built-in passes, and those may reference these members during
 /// construction.
 class PassBuilder {
+  bool DebugLogging;
   TargetMachine *TM;
   PipelineTuningOptions PTO;
   Optional<PGOOptions> PGOOpt;
@@ -127,34 +159,33 @@
     std::vector<PipelineElement> InnerPipeline;
   };
 
-  /// ThinLTO phase.
-  ///
-  /// This enumerates the LLVM ThinLTO optimization phases.
-  enum class ThinLTOPhase {
-    /// No ThinLTO behavior needed.
-    None,
-    /// ThinLTO prelink (summary) phase.
-    PreLink,
-    /// ThinLTO postlink (backend compile) phase.
-    PostLink
-  };
-
   /// LLVM-provided high-level optimization levels.
   ///
   /// This enumerates the LLVM-provided high-level optimization levels. Each
   /// level has a specific goal and rationale.
-  enum OptimizationLevel {
+  class OptimizationLevel final {
+    unsigned SpeedLevel = 2;
+    unsigned SizeLevel = 0;
+    OptimizationLevel(unsigned SpeedLevel, unsigned SizeLevel)
+        : SpeedLevel(SpeedLevel), SizeLevel(SizeLevel) {
+      // Check that only valid combinations are passed.
+      assert(SpeedLevel <= 3 &&
+             "Optimization level for speed should be 0, 1, 2, or 3");
+      assert(SizeLevel <= 2 &&
+             "Optimization level for size should be 0, 1, or 2");
+      assert((SizeLevel == 0 || SpeedLevel == 2) &&
+             "Optimize for size should be encoded with speedup level == 2");
+    }
+
+  public:
+    OptimizationLevel() = default;
     /// Disable as many optimizations as possible. This doesn't completely
     /// disable the optimizer in all cases, for example always_inline functions
     /// can be required to be inlined for correctness.
-    O0,
+    static const OptimizationLevel O0;
 
     /// Optimize quickly without destroying debuggability.
     ///
-    /// FIXME: The current and historical behavior of this level does *not*
-    /// agree with this goal, but we would like to move toward this goal in the
-    /// future.
-    ///
     /// This level is tuned to produce a result from the optimizer as quickly
     /// as possible and to avoid destroying debuggability. This tends to result
     /// in a very good development mode where the compiled code will be
@@ -164,11 +195,10 @@
     /// debugging of the resulting binary.
     ///
     /// As an example, complex loop transformations such as versioning,
-    /// vectorization, or fusion might not make sense here due to the degree to
-    /// which the executed code would differ from the source code, and the
-    /// potential compile time cost.
-    O1,
-
+    /// vectorization, or fusion don't make sense here due to the degree to
+    /// which the executed code differs from the source code, and the compile
+    /// time cost.
+    static const OptimizationLevel O1;
     /// Optimize for fast execution as much as possible without triggering
     /// significant incremental compile time or code size growth.
     ///
@@ -185,8 +215,7 @@
     ///
     /// This is expected to be a good default optimization level for the vast
     /// majority of users.
-    O2,
-
+    static const OptimizationLevel O2;
     /// Optimize for fast execution as much as possible.
     ///
     /// This mode is significantly more aggressive in trading off compile time
@@ -201,8 +230,7 @@
     /// order to make even significantly slower compile times at least scale
     /// reasonably. This does not preclude very substantial constant factor
     /// costs though.
-    O3,
-
+    static const OptimizationLevel O3;
     /// Similar to \c O2 but tries to optimize for small code size instead of
     /// fast execution without triggering significant incremental execution
     /// time slowdowns.
@@ -213,8 +241,7 @@
     /// A consequence of the different core goal is that this should in general
     /// produce substantially smaller executables that still run in
     /// a reasonable amount of time.
-    Os,
-
+    static const OptimizationLevel Os;
     /// A very specialized mode that will optimize for code size at any and all
     /// costs.
     ///
@@ -222,14 +249,30 @@
     /// any effort taken to reduce the size is worth it regardless of the
     /// execution time impact. You should expect this level to produce rather
     /// slow, but very small, code.
-    Oz
+    static const OptimizationLevel Oz;
+
+    bool isOptimizingForSpeed() const {
+      return SizeLevel == 0 && SpeedLevel > 0;
+    }
+
+    bool isOptimizingForSize() const { return SizeLevel > 0; }
+
+    bool operator==(const OptimizationLevel &Other) const {
+      return SizeLevel == Other.SizeLevel && SpeedLevel == Other.SpeedLevel;
+    }
+    bool operator!=(const OptimizationLevel &Other) const {
+      return SizeLevel != Other.SizeLevel || SpeedLevel != Other.SpeedLevel;
+    }
+
+    unsigned getSpeedupLevel() const { return SpeedLevel; }
+
+    unsigned getSizeLevel() const { return SizeLevel; }
   };
 
-  explicit PassBuilder(TargetMachine *TM = nullptr,
+  explicit PassBuilder(bool DebugLogging = false, TargetMachine *TM = nullptr,
                        PipelineTuningOptions PTO = PipelineTuningOptions(),
                        Optional<PGOOptions> PGOOpt = None,
-                       PassInstrumentationCallbacks *PIC = nullptr)
-      : TM(TM), PTO(PTO), PGOOpt(PGOOpt), PIC(PIC) {}
+                       PassInstrumentationCallbacks *PIC = nullptr);
 
   /// Cross register the analysis managers through their proxies.
   ///
@@ -287,8 +330,7 @@
   /// \p Phase indicates the current ThinLTO phase.
   FunctionPassManager
   buildFunctionSimplificationPipeline(OptimizationLevel Level,
-                                      ThinLTOPhase Phase,
-                                      bool DebugLogging = false);
+                                      ThinOrFullLTOPhase Phase);
 
   /// Construct the core LLVM module canonicalization and simplification
   /// pipeline.
@@ -305,10 +347,13 @@
   /// build them.
   ///
   /// \p Phase indicates the current ThinLTO phase.
-  ModulePassManager
-  buildModuleSimplificationPipeline(OptimizationLevel Level,
-                                    ThinLTOPhase Phase,
-                                    bool DebugLogging = false);
+  ModulePassManager buildModuleSimplificationPipeline(OptimizationLevel Level,
+                                                      ThinOrFullLTOPhase Phase);
+
+  /// Construct the module pipeline that performs inlining as well as
+  /// the inlining-driven cleanups.
+  ModuleInlinerWrapperPass buildInlinerPipeline(OptimizationLevel Level,
+                                                ThinOrFullLTOPhase Phase);
 
   /// Construct the core LLVM module optimization pipeline.
   ///
@@ -324,7 +369,6 @@
   /// require some transformations for semantic reasons, they should explicitly
   /// build them.
   ModulePassManager buildModuleOptimizationPipeline(OptimizationLevel Level,
-                                                    bool DebugLogging = false,
                                                     bool LTOPreLink = false);
 
   /// Build a per-module default optimization pipeline.
@@ -339,7 +383,6 @@
   /// require some transformations for semantic reasons, they should explicitly
   /// build them.
   ModulePassManager buildPerModuleDefaultPipeline(OptimizationLevel Level,
-                                                  bool DebugLogging = false,
                                                   bool LTOPreLink = false);
 
   /// Build a pre-link, ThinLTO-targeting default optimization pipeline to
@@ -354,9 +397,7 @@
   /// only intended for use when attempting to optimize code. If frontends
   /// require some transformations for semantic reasons, they should explicitly
   /// build them.
-  ModulePassManager
-  buildThinLTOPreLinkDefaultPipeline(OptimizationLevel Level,
-                                     bool DebugLogging = false);
+  ModulePassManager buildThinLTOPreLinkDefaultPipeline(OptimizationLevel Level);
 
   /// Build an ThinLTO default optimization pipeline to a pass manager.
   ///
@@ -370,7 +411,7 @@
   /// require some transformations for semantic reasons, they should explicitly
   /// build them.
   ModulePassManager
-  buildThinLTODefaultPipeline(OptimizationLevel Level, bool DebugLogging,
+  buildThinLTODefaultPipeline(OptimizationLevel Level,
                               const ModuleSummaryIndex *ImportSummary);
 
   /// Build a pre-link, LTO-targeting default optimization pipeline to a pass
@@ -385,8 +426,7 @@
   /// only intended for use when attempting to optimize code. If frontends
   /// require some transformations for semantic reasons, they should explicitly
   /// build them.
-  ModulePassManager buildLTOPreLinkDefaultPipeline(OptimizationLevel Level,
-                                                   bool DebugLogging = false);
+  ModulePassManager buildLTOPreLinkDefaultPipeline(OptimizationLevel Level);
 
   /// Build an LTO default optimization pipeline to a pass manager.
   ///
@@ -400,11 +440,19 @@
   /// require some transformations for semantic reasons, they should explicitly
   /// build them.
   ModulePassManager buildLTODefaultPipeline(OptimizationLevel Level,
-                                            bool DebugLogging,
                                             ModuleSummaryIndex *ExportSummary);
 
+  /// Build an O0 pipeline with the minimal semantically required passes.
+  ///
+  /// This should only be used for non-LTO and LTO pre-link pipelines.
+  ModulePassManager buildO0DefaultPipeline(OptimizationLevel Level,
+                                           bool LTOPreLink = false);
+
   /// Build the default `AAManager` with the default alias analysis pipeline
   /// registered.
+  ///
+  /// This also adds target-specific alias analyses registered via
+  /// TargetMachine::registerDefaultAliasAnalyses().
   AAManager buildDefaultAAPipeline();
 
   /// Parse a textual pass pipeline description into a \c
@@ -432,13 +480,22 @@
   ///   module(function(loop(lpass1,lpass2,lpass3)))
   ///
   /// This shortcut is especially useful for debugging and testing small pass
-  /// combinations. Note that these shortcuts don't introduce any other magic.
-  /// If the sequence of passes aren't all the exact same kind of pass, it will
-  /// be an error. You cannot mix different levels implicitly, you must
-  /// explicitly form a pass manager in which to nest passes.
-  Error parsePassPipeline(ModulePassManager &MPM, StringRef PipelineText,
-                          bool VerifyEachPass = true,
-                          bool DebugLogging = false);
+  /// combinations.
+  ///
+  /// The sequence of passes aren't necessarily the exact same kind of pass.
+  /// You can mix different levels implicitly if adaptor passes are defined to
+  /// make them work. For example,
+  ///
+  ///   mpass1,fpass1,fpass2,mpass2,lpass1
+  ///
+  /// This pipeline uses only one pass manager: the top-level module manager.
+  /// fpass1,fpass2 and lpass1 are added into the the top-level module manager
+  /// using only adaptor passes. No nested function/loop pass managers are
+  /// added. The purpose is to allow easy pass testing when the user
+  /// specifically want the pass to run under a adaptor directly. This is
+  /// preferred when a pipeline is largely of one type, but one or just a few
+  /// passes are of different types(See PassBuilder.cpp for examples).
+  Error parsePassPipeline(ModulePassManager &MPM, StringRef PipelineText);
 
   /// {{@ Parse a textual pass pipeline description into a specific PassManager
   ///
@@ -447,15 +504,9 @@
   /// this is the valid pipeline text:
   ///
   ///   function(lpass)
-  Error parsePassPipeline(CGSCCPassManager &CGPM, StringRef PipelineText,
-                          bool VerifyEachPass = true,
-                          bool DebugLogging = false);
-  Error parsePassPipeline(FunctionPassManager &FPM, StringRef PipelineText,
-                          bool VerifyEachPass = true,
-                          bool DebugLogging = false);
-  Error parsePassPipeline(LoopPassManager &LPM, StringRef PipelineText,
-                          bool VerifyEachPass = true,
-                          bool DebugLogging = false);
+  Error parsePassPipeline(CGSCCPassManager &CGPM, StringRef PipelineText);
+  Error parsePassPipeline(FunctionPassManager &FPM, StringRef PipelineText);
+  Error parsePassPipeline(LoopPassManager &LPM, StringRef PipelineText);
   /// @}}
 
   /// Parse a textual alias analysis pipeline into the provided AA manager.
@@ -475,6 +526,12 @@
   /// returns false.
   Error parseAAPipeline(AAManager &AA, StringRef PipelineText);
 
+  /// Returns true if the pass name is the name of an alias analysis pass.
+  bool isAAPassName(StringRef PassName);
+
+  /// Returns true if the pass name is the name of a (non-alias) analysis pass.
+  bool isAnalysisPassName(StringRef PassName);
+
   /// Register a callback for a default optimizer pipeline extension
   /// point
   ///
@@ -548,19 +605,25 @@
   /// pipeline. This does not apply to 'backend' compiles (LTO and ThinLTO
   /// link-time pipelines).
   void registerPipelineStartEPCallback(
-      const std::function<void(ModulePassManager &)> &C) {
+      const std::function<void(ModulePassManager &, OptimizationLevel)> &C) {
     PipelineStartEPCallbacks.push_back(C);
   }
 
+  /// Register a callback for a default optimizer pipeline extension point.
+  ///
+  /// This extension point allows adding optimization right after passes that do
+  /// basic simplification of the input IR.
+  void registerPipelineEarlySimplificationEPCallback(
+      const std::function<void(ModulePassManager &, OptimizationLevel)> &C) {
+    PipelineEarlySimplificationEPCallbacks.push_back(C);
+  }
+
   /// Register a callback for a default optimizer pipeline extension point
   ///
   /// This extension point allows adding optimizations at the very end of the
-  /// function optimization pipeline. A key difference between this and the
-  /// legacy PassManager's OptimizerLast callback is that this extension point
-  /// is not triggered at O0. Extensions to the O0 pipeline should append their
-  /// passes to the end of the overall pipeline.
+  /// function optimization pipeline.
   void registerOptimizerLastEPCallback(
-      const std::function<void(FunctionPassManager &, OptimizationLevel)> &C) {
+      const std::function<void(ModulePassManager &, OptimizationLevel)> &C) {
     OptimizerLastEPCallbacks.push_back(C);
   }
 
@@ -625,42 +688,48 @@
   /// PassManagers and populate the passed ModulePassManager.
   void registerParseTopLevelPipelineCallback(
       const std::function<bool(ModulePassManager &, ArrayRef<PipelineElement>,
-                               bool VerifyEachPass, bool DebugLogging)> &C) {
-    TopLevelPipelineParsingCallbacks.push_back(C);
+                               bool DebugLogging)> &C);
+
+  /// Add PGOInstrumenation passes for O0 only.
+  void addPGOInstrPassesForO0(ModulePassManager &MPM, bool RunProfileGen,
+                              bool IsCS, std::string ProfileFile,
+                              std::string ProfileRemappingFile);
+
+  /// Returns PIC. External libraries can use this to register pass
+  /// instrumentation callbacks.
+  PassInstrumentationCallbacks *getPassInstrumentationCallbacks() const {
+    return PIC;
   }
 
 private:
+  // O1 pass pipeline
+  FunctionPassManager
+  buildO1FunctionSimplificationPipeline(OptimizationLevel Level,
+                                        ThinOrFullLTOPhase Phase);
+
+  void addRequiredLTOPreLinkPasses(ModulePassManager &MPM);
+
   static Optional<std::vector<PipelineElement>>
   parsePipelineText(StringRef Text);
 
-  Error parseModulePass(ModulePassManager &MPM, const PipelineElement &E,
-                        bool VerifyEachPass, bool DebugLogging);
-  Error parseCGSCCPass(CGSCCPassManager &CGPM, const PipelineElement &E,
-                       bool VerifyEachPass, bool DebugLogging);
-  Error parseFunctionPass(FunctionPassManager &FPM, const PipelineElement &E,
-                          bool VerifyEachPass, bool DebugLogging);
-  Error parseLoopPass(LoopPassManager &LPM, const PipelineElement &E,
-                      bool VerifyEachPass, bool DebugLogging);
+  Error parseModulePass(ModulePassManager &MPM, const PipelineElement &E);
+  Error parseCGSCCPass(CGSCCPassManager &CGPM, const PipelineElement &E);
+  Error parseFunctionPass(FunctionPassManager &FPM, const PipelineElement &E);
+  Error parseLoopPass(LoopPassManager &LPM, const PipelineElement &E);
   bool parseAAPassName(AAManager &AA, StringRef Name);
 
   Error parseLoopPassPipeline(LoopPassManager &LPM,
-                              ArrayRef<PipelineElement> Pipeline,
-                              bool VerifyEachPass, bool DebugLogging);
+                              ArrayRef<PipelineElement> Pipeline);
   Error parseFunctionPassPipeline(FunctionPassManager &FPM,
-                                  ArrayRef<PipelineElement> Pipeline,
-                                  bool VerifyEachPass, bool DebugLogging);
+                                  ArrayRef<PipelineElement> Pipeline);
   Error parseCGSCCPassPipeline(CGSCCPassManager &CGPM,
-                               ArrayRef<PipelineElement> Pipeline,
-                               bool VerifyEachPass, bool DebugLogging);
+                               ArrayRef<PipelineElement> Pipeline);
   Error parseModulePassPipeline(ModulePassManager &MPM,
-                                ArrayRef<PipelineElement> Pipeline,
-                                bool VerifyEachPass, bool DebugLogging);
+                                ArrayRef<PipelineElement> Pipeline);
 
-  void addPGOInstrPasses(ModulePassManager &MPM, bool DebugLogging,
-                         OptimizationLevel Level, bool RunProfileGen, bool IsCS,
-                         std::string ProfileFile,
+  void addPGOInstrPasses(ModulePassManager &MPM, OptimizationLevel Level,
+                         bool RunProfileGen, bool IsCS, std::string ProfileFile,
                          std::string ProfileRemappingFile);
-
   void invokePeepholeEPCallbacks(FunctionPassManager &, OptimizationLevel);
 
   // Extension Point callbacks
@@ -676,11 +745,14 @@
       CGSCCOptimizerLateEPCallbacks;
   SmallVector<std::function<void(FunctionPassManager &, OptimizationLevel)>, 2>
       VectorizerStartEPCallbacks;
-  SmallVector<std::function<void(FunctionPassManager &, OptimizationLevel)>, 2>
+  SmallVector<std::function<void(ModulePassManager &, OptimizationLevel)>, 2>
       OptimizerLastEPCallbacks;
   // Module callbacks
-  SmallVector<std::function<void(ModulePassManager &)>, 2>
+  SmallVector<std::function<void(ModulePassManager &, OptimizationLevel)>, 2>
       PipelineStartEPCallbacks;
+  SmallVector<std::function<void(ModulePassManager &, OptimizationLevel)>, 2>
+      PipelineEarlySimplificationEPCallbacks;
+
   SmallVector<std::function<void(ModuleAnalysisManager &)>, 2>
       ModuleAnalysisRegistrationCallbacks;
   SmallVector<std::function<bool(StringRef, ModulePassManager &,
@@ -688,7 +760,7 @@
               2>
       ModulePipelineParsingCallbacks;
   SmallVector<std::function<bool(ModulePassManager &, ArrayRef<PipelineElement>,
-                                 bool VerifyEachPass, bool DebugLogging)>,
+                                 bool DebugLogging)>,
               2>
       TopLevelPipelineParsingCallbacks;
   // CGSCC callbacks
diff --git a/linux-x64/clang/include/llvm/Passes/StandardInstrumentations.h b/linux-x64/clang/include/llvm/Passes/StandardInstrumentations.h
index 3d3002e..795a980 100644
--- a/linux-x64/clang/include/llvm/Passes/StandardInstrumentations.h
+++ b/linux-x64/clang/include/llvm/Passes/StandardInstrumentations.h
@@ -16,8 +16,12 @@
 #define LLVM_PASSES_STANDARDINSTRUMENTATIONS_H
 
 #include "llvm/ADT/SmallVector.h"
-#include "llvm/IR/PassInstrumentation.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/IR/BasicBlock.h"
+#include "llvm/IR/OptBisect.h"
 #include "llvm/IR/PassTimingInfo.h"
+#include "llvm/IR/ValueHandle.h"
+#include "llvm/Support/CommandLine.h"
 
 #include <string>
 #include <utility>
@@ -25,6 +29,8 @@
 namespace llvm {
 
 class Module;
+class Function;
+class PassInstrumentationCallbacks;
 
 /// Instrumentation to print IR before/after passes.
 ///
@@ -32,40 +38,256 @@
 /// (typically Loop or SCC).
 class PrintIRInstrumentation {
 public:
-  PrintIRInstrumentation() = default;
   ~PrintIRInstrumentation();
 
   void registerCallbacks(PassInstrumentationCallbacks &PIC);
 
 private:
-  bool printBeforePass(StringRef PassID, Any IR);
+  void printBeforePass(StringRef PassID, Any IR);
   void printAfterPass(StringRef PassID, Any IR);
   void printAfterPassInvalidated(StringRef PassID);
 
+  bool shouldPrintBeforePass(StringRef PassID);
+  bool shouldPrintAfterPass(StringRef PassID);
+
   using PrintModuleDesc = std::tuple<const Module *, std::string, StringRef>;
 
   void pushModuleDesc(StringRef PassID, Any IR);
   PrintModuleDesc popModuleDesc(StringRef PassID);
 
+  PassInstrumentationCallbacks *PIC;
   /// Stack of Module description, enough to print the module after a given
   /// pass.
   SmallVector<PrintModuleDesc, 2> ModuleDescStack;
   bool StoreModuleDesc = false;
 };
 
+class OptNoneInstrumentation {
+public:
+  OptNoneInstrumentation(bool DebugLogging) : DebugLogging(DebugLogging) {}
+  void registerCallbacks(PassInstrumentationCallbacks &PIC);
+
+private:
+  bool DebugLogging;
+  bool shouldRun(StringRef PassID, Any IR);
+};
+
+class OptBisectInstrumentation {
+public:
+  OptBisectInstrumentation() {}
+  void registerCallbacks(PassInstrumentationCallbacks &PIC);
+};
+
+// Debug logging for transformation and analysis passes.
+class PrintPassInstrumentation {
+public:
+  PrintPassInstrumentation(bool DebugLogging) : DebugLogging(DebugLogging) {}
+  void registerCallbacks(PassInstrumentationCallbacks &PIC);
+
+private:
+  bool DebugLogging;
+};
+
+class PreservedCFGCheckerInstrumentation {
+private:
+  // CFG is a map BB -> {(Succ, Multiplicity)}, where BB is a non-leaf basic
+  // block, {(Succ, Multiplicity)} set of all pairs of the block's successors
+  // and the multiplicity of the edge (BB->Succ). As the mapped sets are
+  // unordered the order of successors is not tracked by the CFG. In other words
+  // this allows basic block successors to be swapped by a pass without
+  // reporting a CFG change. CFG can be guarded by basic block tracking pointers
+  // in the Graph (BBGuard). That is if any of the block is deleted or RAUWed
+  // then the CFG is treated poisoned and no block pointer of the Graph is used.
+  struct CFG {
+    struct BBGuard final : public CallbackVH {
+      BBGuard(const BasicBlock *BB) : CallbackVH(BB) {}
+      void deleted() override { CallbackVH::deleted(); }
+      void allUsesReplacedWith(Value *) override { CallbackVH::deleted(); }
+      bool isPoisoned() const { return !getValPtr(); }
+    };
+
+    Optional<DenseMap<intptr_t, BBGuard>> BBGuards;
+    DenseMap<const BasicBlock *, DenseMap<const BasicBlock *, unsigned>> Graph;
+
+    CFG(const Function *F, bool TrackBBLifetime = false);
+
+    bool operator==(const CFG &G) const {
+      return !isPoisoned() && !G.isPoisoned() && Graph == G.Graph;
+    }
+
+    bool isPoisoned() const {
+      if (BBGuards)
+        for (auto &BB : *BBGuards) {
+          if (BB.second.isPoisoned())
+            return true;
+        }
+      return false;
+    }
+
+    static void printDiff(raw_ostream &out, const CFG &Before,
+                          const CFG &After);
+  };
+
+  SmallVector<std::pair<StringRef, Optional<CFG>>, 8> GraphStackBefore;
+
+public:
+  static cl::opt<bool> VerifyPreservedCFG;
+  void registerCallbacks(PassInstrumentationCallbacks &PIC);
+};
+
+// Base class for classes that report changes to the IR.
+// It presents an interface for such classes and provides calls
+// on various events as the new pass manager transforms the IR.
+// It also provides filtering of information based on hidden options
+// specifying which functions are interesting.
+// Calls are made for the following events/queries:
+// 1.  The initial IR processed.
+// 2.  To get the representation of the IR (of type \p T).
+// 3.  When a pass does not change the IR.
+// 4.  When a pass changes the IR (given both before and after representations
+//         of type \p T).
+// 5.  When an IR is invalidated.
+// 6.  When a pass is run on an IR that is not interesting (based on options).
+// 7.  When a pass is ignored (pass manager or adapter pass).
+// 8.  To compare two IR representations (of type \p T).
+template <typename IRUnitT> class ChangeReporter {
+protected:
+  ChangeReporter(bool RunInVerboseMode) : VerboseMode(RunInVerboseMode) {}
+
+public:
+  virtual ~ChangeReporter();
+
+  // Determine if this pass/IR is interesting and if so, save the IR
+  // otherwise it is left on the stack without data.
+  void saveIRBeforePass(Any IR, StringRef PassID);
+  // Compare the IR from before the pass after the pass.
+  void handleIRAfterPass(Any IR, StringRef PassID);
+  // Handle the situation where a pass is invalidated.
+  void handleInvalidatedPass(StringRef PassID);
+
+protected:
+  // Register required callbacks.
+  void registerRequiredCallbacks(PassInstrumentationCallbacks &PIC);
+
+  // Return true when this is a defined function for which printing
+  // of changes is desired.
+  bool isInterestingFunction(const Function &F);
+
+  // Return true when this is a pass for which printing of changes is desired.
+  bool isInterestingPass(StringRef PassID);
+
+  // Return true when this is a pass on IR for which printing
+  // of changes is desired.
+  bool isInteresting(Any IR, StringRef PassID);
+
+  // Called on the first IR processed.
+  virtual void handleInitialIR(Any IR) = 0;
+  // Called before and after a pass to get the representation of the IR.
+  virtual void generateIRRepresentation(Any IR, StringRef PassID,
+                                        IRUnitT &Output) = 0;
+  // Called when the pass is not iteresting.
+  virtual void omitAfter(StringRef PassID, std::string &Name) = 0;
+  // Called when an interesting IR has changed.
+  virtual void handleAfter(StringRef PassID, std::string &Name,
+                           const IRUnitT &Before, const IRUnitT &After,
+                           Any) = 0;
+  // Called when an interesting pass is invalidated.
+  virtual void handleInvalidated(StringRef PassID) = 0;
+  // Called when the IR or pass is not interesting.
+  virtual void handleFiltered(StringRef PassID, std::string &Name) = 0;
+  // Called when an ignored pass is encountered.
+  virtual void handleIgnored(StringRef PassID, std::string &Name) = 0;
+  // Called to compare the before and after representations of the IR.
+  virtual bool same(const IRUnitT &Before, const IRUnitT &After) = 0;
+
+  // Stack of IRs before passes.
+  std::vector<IRUnitT> BeforeStack;
+  // Is this the first IR seen?
+  bool InitialIR = true;
+
+  // Run in verbose mode, printing everything?
+  const bool VerboseMode;
+};
+
+// An abstract template base class that handles printing banners and
+// reporting when things have not changed or are filtered out.
+template <typename IRUnitT>
+class TextChangeReporter : public ChangeReporter<IRUnitT> {
+protected:
+  TextChangeReporter(bool Verbose);
+
+  // Print a module dump of the first IR that is changed.
+  void handleInitialIR(Any IR) override;
+  // Report that the IR was omitted because it did not change.
+  void omitAfter(StringRef PassID, std::string &Name) override;
+  // Report that the pass was invalidated.
+  void handleInvalidated(StringRef PassID) override;
+  // Report that the IR was filtered out.
+  void handleFiltered(StringRef PassID, std::string &Name) override;
+  // Report that the pass was ignored.
+  void handleIgnored(StringRef PassID, std::string &Name) override;
+  // Make substitutions in \p S suitable for reporting changes
+  // after the pass and then print it.
+
+  raw_ostream &Out;
+};
+
+// A change printer based on the string representation of the IR as created
+// by unwrapAndPrint.  The string representation is stored in a std::string
+// to preserve it as the IR changes in each pass.  Note that the banner is
+// included in this representation but it is massaged before reporting.
+class IRChangedPrinter : public TextChangeReporter<std::string> {
+public:
+  IRChangedPrinter(bool VerboseMode)
+      : TextChangeReporter<std::string>(VerboseMode) {}
+  ~IRChangedPrinter() override;
+  void registerCallbacks(PassInstrumentationCallbacks &PIC);
+
+protected:
+  // Called before and after a pass to get the representation of the IR.
+  void generateIRRepresentation(Any IR, StringRef PassID,
+                                std::string &Output) override;
+  // Called when an interesting IR has changed.
+  void handleAfter(StringRef PassID, std::string &Name,
+                   const std::string &Before, const std::string &After,
+                   Any) override;
+  // Called to compare the before and after representations of the IR.
+  bool same(const std::string &Before, const std::string &After) override;
+};
+
+class VerifyInstrumentation {
+  bool DebugLogging;
+
+public:
+  VerifyInstrumentation(bool DebugLogging) : DebugLogging(DebugLogging) {}
+  void registerCallbacks(PassInstrumentationCallbacks &PIC);
+};
+
 /// This class provides an interface to register all the standard pass
 /// instrumentations and manages their state (if any).
 class StandardInstrumentations {
   PrintIRInstrumentation PrintIR;
+  PrintPassInstrumentation PrintPass;
   TimePassesHandler TimePasses;
+  OptNoneInstrumentation OptNone;
+  OptBisectInstrumentation OptBisect;
+  PreservedCFGCheckerInstrumentation PreservedCFGChecker;
+  IRChangedPrinter PrintChangedIR;
+  VerifyInstrumentation Verify;
+
+  bool VerifyEach;
 
 public:
-  StandardInstrumentations() = default;
+  StandardInstrumentations(bool DebugLogging, bool VerifyEach = false);
 
   void registerCallbacks(PassInstrumentationCallbacks &PIC);
 
   TimePassesHandler &getTimePasses() { return TimePasses; }
 };
+
+extern template class ChangeReporter<std::string>;
+extern template class TextChangeReporter<std::string>;
+
 } // namespace llvm
 
 #endif
diff --git a/linux-x64/clang/include/llvm/ProfileData/Coverage/CoverageMapping.h b/linux-x64/clang/include/llvm/ProfileData/Coverage/CoverageMapping.h
index 11758ac..09f2167 100644
--- a/linux-x64/clang/include/llvm/ProfileData/Coverage/CoverageMapping.h
+++ b/linux-x64/clang/include/llvm/ProfileData/Coverage/CoverageMapping.h
@@ -20,10 +20,10 @@
 #include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/None.h"
 #include "llvm/ADT/StringRef.h"
-#include "llvm/ADT/StringSet.h"
 #include "llvm/ADT/iterator.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/ProfileData/InstrProf.h"
+#include "llvm/Support/Alignment.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Endian.h"
@@ -54,7 +54,9 @@
   no_data_found,
   unsupported_version,
   truncated,
-  malformed
+  malformed,
+  decompression_failed,
+  invalid_or_missing_arch_specifier
 };
 
 const std::error_category &coveragemap_category();
@@ -88,6 +90,8 @@
 /// A Counter is an abstract value that describes how to compute the
 /// execution count for a region of code using the collected profile count data.
 struct Counter {
+  /// The CounterExpression kind (Add or Subtract) is encoded in bit 0 next to
+  /// the CounterKind. This means CounterKind has to leave bit 0 free.
   enum CounterKind { Zero, CounterValueReference, Expression };
   static const unsigned EncodingTagBits = 2;
   static const unsigned EncodingTagMask = 0x3;
@@ -217,10 +221,20 @@
 
     /// A GapRegion is like a CodeRegion, but its count is only set as the
     /// line execution count when its the only region in the line.
-    GapRegion
+    GapRegion,
+
+    /// A BranchRegion represents leaf-level boolean expressions and is
+    /// associated with two counters, each representing the number of times the
+    /// expression evaluates to true or false.
+    BranchRegion
   };
 
+  /// Primary Counter that is also used for Branch Regions (TrueCount).
   Counter Count;
+
+  /// Secondary Counter used for Branch Regions (FalseCount).
+  Counter FalseCount;
+
   unsigned FileID, ExpandedFileID;
   unsigned LineStart, ColumnStart, LineEnd, ColumnEnd;
   RegionKind Kind;
@@ -232,6 +246,15 @@
         LineStart(LineStart), ColumnStart(ColumnStart), LineEnd(LineEnd),
         ColumnEnd(ColumnEnd), Kind(Kind) {}
 
+  CounterMappingRegion(Counter Count, Counter FalseCount, unsigned FileID,
+                       unsigned ExpandedFileID, unsigned LineStart,
+                       unsigned ColumnStart, unsigned LineEnd,
+                       unsigned ColumnEnd, RegionKind Kind)
+      : Count(Count), FalseCount(FalseCount), FileID(FileID),
+        ExpandedFileID(ExpandedFileID), LineStart(LineStart),
+        ColumnStart(ColumnStart), LineEnd(LineEnd), ColumnEnd(ColumnEnd),
+        Kind(Kind) {}
+
   static CounterMappingRegion
   makeRegion(Counter Count, unsigned FileID, unsigned LineStart,
              unsigned ColumnStart, unsigned LineEnd, unsigned ColumnEnd) {
@@ -261,6 +284,14 @@
                                 LineEnd, (1U << 31) | ColumnEnd, GapRegion);
   }
 
+  static CounterMappingRegion
+  makeBranchRegion(Counter Count, Counter FalseCount, unsigned FileID,
+                   unsigned LineStart, unsigned ColumnStart, unsigned LineEnd,
+                   unsigned ColumnEnd) {
+    return CounterMappingRegion(Count, FalseCount, FileID, 0, LineStart,
+                                ColumnStart, LineEnd, ColumnEnd, BranchRegion);
+  }
+
   inline LineColPair startLoc() const {
     return LineColPair(LineStart, ColumnStart);
   }
@@ -271,9 +302,17 @@
 /// Associates a source range with an execution count.
 struct CountedRegion : public CounterMappingRegion {
   uint64_t ExecutionCount;
+  uint64_t FalseExecutionCount;
+  bool Folded;
 
   CountedRegion(const CounterMappingRegion &R, uint64_t ExecutionCount)
-      : CounterMappingRegion(R), ExecutionCount(ExecutionCount) {}
+      : CounterMappingRegion(R), ExecutionCount(ExecutionCount),
+        FalseExecutionCount(0), Folded(false) {}
+
+  CountedRegion(const CounterMappingRegion &R, uint64_t ExecutionCount,
+                uint64_t FalseExecutionCount)
+      : CounterMappingRegion(R), ExecutionCount(ExecutionCount),
+        FalseExecutionCount(FalseExecutionCount), Folded(false) {}
 };
 
 /// A Counter mapping context is used to connect the counters, expressions
@@ -301,12 +340,19 @@
 struct FunctionRecord {
   /// Raw function name.
   std::string Name;
-  /// Associated files.
+  /// Mapping from FileID (i.e. vector index) to filename. Used to support
+  /// macro expansions within a function in which the macro and function are
+  /// defined in separate files.
+  ///
+  /// TODO: Uniquing filenames across all function records may be a performance
+  /// optimization.
   std::vector<std::string> Filenames;
   /// Regions in the function along with their counts.
   std::vector<CountedRegion> CountedRegions;
+  /// Branch Regions in the function along with their counts.
+  std::vector<CountedRegion> CountedBranchRegions;
   /// The number of times this function was executed.
-  uint64_t ExecutionCount;
+  uint64_t ExecutionCount = 0;
 
   FunctionRecord(StringRef Name, ArrayRef<StringRef> Filenames)
       : Name(Name), Filenames(Filenames.begin(), Filenames.end()) {}
@@ -314,10 +360,19 @@
   FunctionRecord(FunctionRecord &&FR) = default;
   FunctionRecord &operator=(FunctionRecord &&) = default;
 
-  void pushRegion(CounterMappingRegion Region, uint64_t Count) {
+  void pushRegion(CounterMappingRegion Region, uint64_t Count,
+                  uint64_t FalseCount) {
+    if (Region.Kind == CounterMappingRegion::BranchRegion) {
+      CountedBranchRegions.emplace_back(Region, Count, FalseCount);
+      // If both counters are hard-coded to zero, then this region represents a
+      // constant-folded branch.
+      if (Region.Count.isZero() && Region.FalseCount.isZero())
+        CountedBranchRegions.back().Folded = true;
+      return;
+    }
     if (CountedRegions.empty())
       ExecutionCount = Count;
-    CountedRegions.emplace_back(Region, Count);
+    CountedRegions.emplace_back(Region, Count, FalseCount);
   }
 };
 
@@ -396,7 +451,8 @@
         IsRegionEntry(IsRegionEntry), IsGapRegion(false) {}
 
   CoverageSegment(unsigned Line, unsigned Col, uint64_t Count,
-                  bool IsRegionEntry, bool IsGapRegion = false)
+                  bool IsRegionEntry, bool IsGapRegion = false,
+                  bool IsBranchRegion = false)
       : Line(Line), Col(Col), Count(Count), HasCount(true),
         IsRegionEntry(IsRegionEntry), IsGapRegion(IsGapRegion) {}
 
@@ -476,6 +532,7 @@
   std::string Filename;
   std::vector<CoverageSegment> Segments;
   std::vector<ExpansionRecord> Expansions;
+  std::vector<CountedRegion> BranchRegions;
 
 public:
   CoverageData() = default;
@@ -499,6 +556,9 @@
 
   /// Expansions that can be further processed.
   ArrayRef<ExpansionRecord> getExpansions() const { return Expansions; }
+
+  /// Branches that can be further processed.
+  ArrayRef<CountedRegion> getBranches() const { return BranchRegions; }
 };
 
 /// The mapping of profile information to coverage data.
@@ -508,6 +568,7 @@
 class CoverageMapping {
   DenseMap<size_t, DenseSet<size_t>> RecordProvenance;
   std::vector<FunctionRecord> Functions;
+  DenseMap<size_t, SmallVector<unsigned, 0>> FilenameHash2RecordIndices;
   std::vector<std::pair<std::string, uint64_t>> FuncHashMismatches;
 
   CoverageMapping() = default;
@@ -516,6 +577,13 @@
   Error loadFunctionRecord(const CoverageMappingRecord &Record,
                            IndexedInstrProfReader &ProfileReader);
 
+  /// Look up the indices for function records which are at least partially
+  /// defined in the specified file. This is guaranteed to return a superset of
+  /// such records: extra records not in the file may be included if there is
+  /// a hash collision on the filename. Clients must be robust to collisions.
+  ArrayRef<unsigned>
+  getImpreciseRecordIndicesForFilename(StringRef Filename) const;
+
 public:
   CoverageMapping(const CoverageMapping &) = delete;
   CoverageMapping &operator=(const CoverageMapping &) = delete;
@@ -527,6 +595,7 @@
 
   /// Load the coverage mapping from the given object files and profile. If
   /// \p Arches is non-empty, it must specify an architecture for each object.
+  /// Ignores non-instrumented object files unless all are not instrumented.
   static Expected<std::unique_ptr<CoverageMapping>>
   load(ArrayRef<StringRef> ObjectFilenames, StringRef ProfileFilename,
        ArrayRef<StringRef> Arches = None);
@@ -664,37 +733,107 @@
   return make_range(Begin, End);
 }
 
-// Profile coverage map has the following layout:
-// [CoverageMapFileHeader]
-// [ArrayStart]
-//  [CovMapFunctionRecord]
-//  [CovMapFunctionRecord]
-//  ...
-// [ArrayEnd]
-// [Encoded Region Mapping Data]
+// Coverage mappping data (V2) has the following layout:
+// IPSK_covmap:
+//   [CoverageMapFileHeader]
+//   [ArrayStart]
+//    [CovMapFunctionRecordV2]
+//    [CovMapFunctionRecordV2]
+//    ...
+//   [ArrayEnd]
+//   [Encoded Filenames and Region Mapping Data]
+//
+// Coverage mappping data (V3) has the following layout:
+// IPSK_covmap:
+//   [CoverageMapFileHeader]
+//   [Encoded Filenames]
+// IPSK_covfun:
+//   [ArrayStart]
+//     odr_name_1: [CovMapFunctionRecordV3]
+//     odr_name_2: [CovMapFunctionRecordV3]
+//     ...
+//   [ArrayEnd]
+//
+// Both versions of the coverage mapping format encode the same information,
+// but the V3 format does so more compactly by taking advantage of linkonce_odr
+// semantics (it allows exactly 1 function record per name reference).
+
+/// This namespace defines accessors shared by different versions of coverage
+/// mapping records.
+namespace accessors {
+
+/// Return the structural hash associated with the function.
+template <class FuncRecordTy, support::endianness Endian>
+uint64_t getFuncHash(const FuncRecordTy *Record) {
+  return support::endian::byte_swap<uint64_t, Endian>(Record->FuncHash);
+}
+
+/// Return the coverage map data size for the function.
+template <class FuncRecordTy, support::endianness Endian>
+uint64_t getDataSize(const FuncRecordTy *Record) {
+  return support::endian::byte_swap<uint32_t, Endian>(Record->DataSize);
+}
+
+/// Return the function lookup key. The value is considered opaque.
+template <class FuncRecordTy, support::endianness Endian>
+uint64_t getFuncNameRef(const FuncRecordTy *Record) {
+  return support::endian::byte_swap<uint64_t, Endian>(Record->NameRef);
+}
+
+/// Return the PGO name of the function. Used for formats in which the name is
+/// a hash.
+template <class FuncRecordTy, support::endianness Endian>
+Error getFuncNameViaRef(const FuncRecordTy *Record,
+                        InstrProfSymtab &ProfileNames, StringRef &FuncName) {
+  uint64_t NameRef = getFuncNameRef<FuncRecordTy, Endian>(Record);
+  FuncName = ProfileNames.getFuncName(NameRef);
+  return Error::success();
+}
+
+/// Read coverage mapping out-of-line, from \p MappingBuf. This is used when the
+/// coverage mapping is attached to the file header, instead of to the function
+/// record.
+template <class FuncRecordTy, support::endianness Endian>
+StringRef getCoverageMappingOutOfLine(const FuncRecordTy *Record,
+                                      const char *MappingBuf) {
+  return {MappingBuf, size_t(getDataSize<FuncRecordTy, Endian>(Record))};
+}
+
+/// Advance to the next out-of-line coverage mapping and its associated
+/// function record.
+template <class FuncRecordTy, support::endianness Endian>
+std::pair<const char *, const FuncRecordTy *>
+advanceByOneOutOfLine(const FuncRecordTy *Record, const char *MappingBuf) {
+  return {MappingBuf + getDataSize<FuncRecordTy, Endian>(Record), Record + 1};
+}
+
+} // end namespace accessors
+
 LLVM_PACKED_START
-template <class IntPtrT> struct CovMapFunctionRecordV1 {
+template <class IntPtrT>
+struct CovMapFunctionRecordV1 {
+  using ThisT = CovMapFunctionRecordV1<IntPtrT>;
+
 #define COVMAP_V1
 #define COVMAP_FUNC_RECORD(Type, LLVMType, Name, Init) Type Name;
 #include "llvm/ProfileData/InstrProfData.inc"
 #undef COVMAP_V1
+  CovMapFunctionRecordV1() = delete;
 
-  // Return the structural hash associated with the function.
   template <support::endianness Endian> uint64_t getFuncHash() const {
-    return support::endian::byte_swap<uint64_t, Endian>(FuncHash);
+    return accessors::getFuncHash<ThisT, Endian>(this);
   }
 
-  // Return the coverage map data size for the funciton.
-  template <support::endianness Endian> uint32_t getDataSize() const {
-    return support::endian::byte_swap<uint32_t, Endian>(DataSize);
+  template <support::endianness Endian> uint64_t getDataSize() const {
+    return accessors::getDataSize<ThisT, Endian>(this);
   }
 
-  // Return function lookup key. The value is consider opaque.
+  /// Return function lookup key. The value is consider opaque.
   template <support::endianness Endian> IntPtrT getFuncNameRef() const {
     return support::endian::byte_swap<IntPtrT, Endian>(NamePtr);
   }
 
-  // Return the PGO name of the function */
+  /// Return the PGO name of the function.
   template <support::endianness Endian>
   Error getFuncName(InstrProfSymtab &ProfileNames, StringRef &FuncName) const {
     IntPtrT NameRef = getFuncNameRef<Endian>();
@@ -704,33 +843,119 @@
       return make_error<CoverageMapError>(coveragemap_error::malformed);
     return Error::success();
   }
+
+  template <support::endianness Endian>
+  std::pair<const char *, const ThisT *>
+  advanceByOne(const char *MappingBuf) const {
+    return accessors::advanceByOneOutOfLine<ThisT, Endian>(this, MappingBuf);
+  }
+
+  template <support::endianness Endian> uint64_t getFilenamesRef() const {
+    llvm_unreachable("V1 function format does not contain a filenames ref");
+  }
+
+  template <support::endianness Endian>
+  StringRef getCoverageMapping(const char *MappingBuf) const {
+    return accessors::getCoverageMappingOutOfLine<ThisT, Endian>(this,
+                                                                 MappingBuf);
+  }
 };
 
-struct CovMapFunctionRecord {
+struct CovMapFunctionRecordV2 {
+  using ThisT = CovMapFunctionRecordV2;
+
+#define COVMAP_V2
 #define COVMAP_FUNC_RECORD(Type, LLVMType, Name, Init) Type Name;
 #include "llvm/ProfileData/InstrProfData.inc"
+#undef COVMAP_V2
+  CovMapFunctionRecordV2() = delete;
 
-  // Return the structural hash associated with the function.
   template <support::endianness Endian> uint64_t getFuncHash() const {
-    return support::endian::byte_swap<uint64_t, Endian>(FuncHash);
+    return accessors::getFuncHash<ThisT, Endian>(this);
   }
 
-  // Return the coverage map data size for the funciton.
-  template <support::endianness Endian> uint32_t getDataSize() const {
-    return support::endian::byte_swap<uint32_t, Endian>(DataSize);
+  template <support::endianness Endian> uint64_t getDataSize() const {
+    return accessors::getDataSize<ThisT, Endian>(this);
   }
 
-  // Return function lookup key. The value is consider opaque.
   template <support::endianness Endian> uint64_t getFuncNameRef() const {
-    return support::endian::byte_swap<uint64_t, Endian>(NameRef);
+    return accessors::getFuncNameRef<ThisT, Endian>(this);
   }
 
-  // Return the PGO name of the function */
   template <support::endianness Endian>
   Error getFuncName(InstrProfSymtab &ProfileNames, StringRef &FuncName) const {
-    uint64_t NameRef = getFuncNameRef<Endian>();
-    FuncName = ProfileNames.getFuncName(NameRef);
-    return Error::success();
+    return accessors::getFuncNameViaRef<ThisT, Endian>(this, ProfileNames,
+                                                       FuncName);
+  }
+
+  template <support::endianness Endian>
+  std::pair<const char *, const ThisT *>
+  advanceByOne(const char *MappingBuf) const {
+    return accessors::advanceByOneOutOfLine<ThisT, Endian>(this, MappingBuf);
+  }
+
+  template <support::endianness Endian> uint64_t getFilenamesRef() const {
+    llvm_unreachable("V2 function format does not contain a filenames ref");
+  }
+
+  template <support::endianness Endian>
+  StringRef getCoverageMapping(const char *MappingBuf) const {
+    return accessors::getCoverageMappingOutOfLine<ThisT, Endian>(this,
+                                                                 MappingBuf);
+  }
+};
+
+struct CovMapFunctionRecordV3 {
+  using ThisT = CovMapFunctionRecordV3;
+
+#define COVMAP_V3
+#define COVMAP_FUNC_RECORD(Type, LLVMType, Name, Init) Type Name;
+#include "llvm/ProfileData/InstrProfData.inc"
+#undef COVMAP_V3
+  CovMapFunctionRecordV3() = delete;
+
+  template <support::endianness Endian> uint64_t getFuncHash() const {
+    return accessors::getFuncHash<ThisT, Endian>(this);
+  }
+
+  template <support::endianness Endian> uint64_t getDataSize() const {
+    return accessors::getDataSize<ThisT, Endian>(this);
+  }
+
+  template <support::endianness Endian> uint64_t getFuncNameRef() const {
+    return accessors::getFuncNameRef<ThisT, Endian>(this);
+  }
+
+  template <support::endianness Endian>
+  Error getFuncName(InstrProfSymtab &ProfileNames, StringRef &FuncName) const {
+    return accessors::getFuncNameViaRef<ThisT, Endian>(this, ProfileNames,
+                                                       FuncName);
+  }
+
+  /// Get the filename set reference.
+  template <support::endianness Endian> uint64_t getFilenamesRef() const {
+    return support::endian::byte_swap<uint64_t, Endian>(FilenamesRef);
+  }
+
+  /// Read the inline coverage mapping. Ignore the buffer parameter, it is for
+  /// out-of-line coverage mapping data only.
+  template <support::endianness Endian>
+  StringRef getCoverageMapping(const char *) const {
+    return StringRef(&CoverageMapping, getDataSize<Endian>());
+  }
+
+  // Advance to the next inline coverage mapping and its associated function
+  // record. Ignore the out-of-line coverage mapping buffer.
+  template <support::endianness Endian>
+  std::pair<const char *, const CovMapFunctionRecordV3 *>
+  advanceByOne(const char *) const {
+    assert(isAddrAligned(Align(8), this) && "Function record not aligned");
+    const char *Next = ((const char *)this) + sizeof(CovMapFunctionRecordV3) -
+                       sizeof(char) + getDataSize<Endian>();
+    // Each function record has an alignment of 8, so we need to adjust
+    // alignment before reading the next record.
+    Next += offsetToAlignedAddr(Next, Align(8));
+    return {nullptr, reinterpret_cast<const CovMapFunctionRecordV3 *>(Next)};
   }
 };
 
@@ -767,12 +992,26 @@
   // A new interpretation of the columnEnd field is added in order to mark
   // regions as gap areas.
   Version3 = 2,
-  // The current version is Version3
+  // Function records are named, uniqued, and moved to a dedicated section.
+  Version4 = 3,
+  // Branch regions referring to two counters are added
+  Version5 = 4,
+  // The current version is Version5.
   CurrentVersion = INSTR_PROF_COVMAP_VERSION
 };
 
 template <int CovMapVersion, class IntPtrT> struct CovMapTraits {
-  using CovMapFuncRecordType = CovMapFunctionRecord;
+  using CovMapFuncRecordType = CovMapFunctionRecordV3;
+  using NameRefType = uint64_t;
+};
+
+template <class IntPtrT> struct CovMapTraits<CovMapVersion::Version3, IntPtrT> {
+  using CovMapFuncRecordType = CovMapFunctionRecordV2;
+  using NameRefType = uint64_t;
+};
+
+template <class IntPtrT> struct CovMapTraits<CovMapVersion::Version2, IntPtrT> {
+  using CovMapFuncRecordType = CovMapFunctionRecordV2;
   using NameRefType = uint64_t;
 };
 
diff --git a/linux-x64/clang/include/llvm/ProfileData/Coverage/CoverageMappingReader.h b/linux-x64/clang/include/llvm/ProfileData/Coverage/CoverageMappingReader.h
index 57a2aae..3a611bc 100644
--- a/linux-x64/clang/include/llvm/ProfileData/Coverage/CoverageMappingReader.h
+++ b/linux-x64/clang/include/llvm/ProfileData/Coverage/CoverageMappingReader.h
@@ -67,10 +67,10 @@
     increment();
     return *this;
   }
-  bool operator==(const CoverageMappingIterator &RHS) {
+  bool operator==(const CoverageMappingIterator &RHS) const {
     return Reader == RHS.Reader;
   }
-  bool operator!=(const CoverageMappingIterator &RHS) {
+  bool operator!=(const CoverageMappingIterator &RHS) const {
     return Reader != RHS.Reader;
   }
   Expected<CoverageMappingRecord &> operator*() {
@@ -113,20 +113,6 @@
   Error readString(StringRef &Result);
 };
 
-/// Reader for the raw coverage filenames.
-class RawCoverageFilenamesReader : public RawCoverageReader {
-  std::vector<StringRef> &Filenames;
-
-public:
-  RawCoverageFilenamesReader(StringRef Data, std::vector<StringRef> &Filenames)
-      : RawCoverageReader(Data), Filenames(Filenames) {}
-  RawCoverageFilenamesReader(const RawCoverageFilenamesReader &) = delete;
-  RawCoverageFilenamesReader &
-  operator=(const RawCoverageFilenamesReader &) = delete;
-
-  Error read();
-};
-
 /// Checks if the given coverage mapping data is exported for
 /// an unused function.
 class RawCoverageMappingDummyChecker : public RawCoverageReader {
@@ -188,6 +174,8 @@
           FilenamesBegin(FilenamesBegin), FilenamesSize(FilenamesSize) {}
   };
 
+  using DecompressedData = std::vector<std::unique_ptr<SmallVector<char, 0>>>;
+
 private:
   std::vector<StringRef> Filenames;
   std::vector<ProfileMappingRecord> MappingRecords;
@@ -197,7 +185,17 @@
   std::vector<CounterExpression> Expressions;
   std::vector<CounterMappingRegion> MappingRegions;
 
-  BinaryCoverageReader() = default;
+  // Used to tie the lifetimes of coverage function records to the lifetime of
+  // this BinaryCoverageReader instance. Needed to support the format change in
+  // D69471, which can split up function records into multiple sections on ELF.
+  std::string FuncRecords;
+
+  // Used to tie the lifetimes of decompressed strings to the lifetime of this
+  // BinaryCoverageReader instance.
+  DecompressedData Decompressed;
+
+  BinaryCoverageReader(std::string &&FuncRecords)
+      : FuncRecords(std::move(FuncRecords)) {}
 
 public:
   BinaryCoverageReader(const BinaryCoverageReader &) = delete;
@@ -208,7 +206,7 @@
          SmallVectorImpl<std::unique_ptr<MemoryBuffer>> &ObjectFileBuffers);
 
   static Expected<std::unique_ptr<BinaryCoverageReader>>
-  createCoverageReaderFromBuffer(StringRef Coverage,
+  createCoverageReaderFromBuffer(StringRef Coverage, std::string &&FuncRecords,
                                  InstrProfSymtab &&ProfileNames,
                                  uint8_t BytesInAddress,
                                  support::endianness Endian);
@@ -216,6 +214,24 @@
   Error readNextRecord(CoverageMappingRecord &Record) override;
 };
 
+/// Reader for the raw coverage filenames.
+class RawCoverageFilenamesReader : public RawCoverageReader {
+  std::vector<StringRef> &Filenames;
+
+  // Read an uncompressed sequence of filenames.
+  Error readUncompressed(uint64_t NumFilenames);
+
+public:
+  RawCoverageFilenamesReader(StringRef Data, std::vector<StringRef> &Filenames)
+      : RawCoverageReader(Data), Filenames(Filenames) {}
+  RawCoverageFilenamesReader(const RawCoverageFilenamesReader &) = delete;
+  RawCoverageFilenamesReader &
+  operator=(const RawCoverageFilenamesReader &) = delete;
+
+  Error read(CovMapVersion Version,
+             BinaryCoverageReader::DecompressedData &Decompressed);
+};
+
 } // end namespace coverage
 } // end namespace llvm
 
diff --git a/linux-x64/clang/include/llvm/ProfileData/Coverage/CoverageMappingWriter.h b/linux-x64/clang/include/llvm/ProfileData/Coverage/CoverageMappingWriter.h
index 5f88cac..303e518 100644
--- a/linux-x64/clang/include/llvm/ProfileData/Coverage/CoverageMappingWriter.h
+++ b/linux-x64/clang/include/llvm/ProfileData/Coverage/CoverageMappingWriter.h
@@ -30,11 +30,11 @@
   ArrayRef<StringRef> Filenames;
 
 public:
-  CoverageFilenamesSectionWriter(ArrayRef<StringRef> Filenames)
-      : Filenames(Filenames) {}
+  CoverageFilenamesSectionWriter(ArrayRef<StringRef> Filenames);
 
-  /// Write encoded filenames to the given output stream.
-  void write(raw_ostream &OS);
+  /// Write encoded filenames to the given output stream. If \p Compress is
+  /// true, attempt to compress the filenames.
+  void write(raw_ostream &OS, bool Compress = true);
 };
 
 /// Writer for instrumentation based coverage mapping data.
diff --git a/linux-x64/clang/include/llvm/ProfileData/GCOV.h b/linux-x64/clang/include/llvm/ProfileData/GCOV.h
index 004ff3f..d4f0b91 100644
--- a/linux-x64/clang/include/llvm/ProfileData/GCOV.h
+++ b/linux-x64/clang/include/llvm/ProfileData/GCOV.h
@@ -15,12 +15,14 @@
 #define LLVM_PROFILEDATA_GCOV_H
 
 #include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/iterator.h"
 #include "llvm/ADT/iterator_range.h"
+#include "llvm/Support/DataExtractor.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
@@ -28,6 +30,7 @@
 #include <cstddef>
 #include <cstdint>
 #include <limits>
+#include <map>
 #include <memory>
 #include <string>
 #include <utility>
@@ -36,18 +39,19 @@
 
 class GCOVFunction;
 class GCOVBlock;
-class FileInfo;
 
 namespace GCOV {
 
-enum GCOVVersion { V402, V404, V704 };
+enum GCOVVersion { V304, V407, V408, V800, V900 };
 
 /// A struct for passing gcov options between functions.
 struct Options {
-  Options(bool A, bool B, bool C, bool F, bool P, bool U, bool L, bool N, bool X)
+  Options(bool A, bool B, bool C, bool F, bool P, bool U, bool I, bool L,
+          bool M, bool N, bool R, bool T, bool X, std::string SourcePrefix)
       : AllBlocks(A), BranchInfo(B), BranchCount(C), FuncCoverage(F),
-        PreservePaths(P), UncondBranch(U), LongFileNames(L), NoOutput(N),
-        HashFilenames(X) {}
+        PreservePaths(P), UncondBranch(U), Intermediate(I), LongFileNames(L),
+        Demangle(M), NoOutput(N), RelativeOnly(R), UseStdout(T),
+        HashFilenames(X), SourcePrefix(std::move(SourcePrefix)) {}
 
   bool AllBlocks;
   bool BranchInfo;
@@ -55,9 +59,14 @@
   bool FuncCoverage;
   bool PreservePaths;
   bool UncondBranch;
+  bool Intermediate;
   bool LongFileNames;
+  bool Demangle;
   bool NoOutput;
+  bool RelativeOnly;
+  bool UseStdout;
   bool HashFilenames;
+  std::string SourcePrefix;
 };
 
 } // end namespace GCOV
@@ -67,143 +76,86 @@
 class GCOVBuffer {
 public:
   GCOVBuffer(MemoryBuffer *B) : Buffer(B) {}
+  ~GCOVBuffer() { consumeError(cursor.takeError()); }
 
   /// readGCNOFormat - Check GCNO signature is valid at the beginning of buffer.
   bool readGCNOFormat() {
-    StringRef File = Buffer->getBuffer().slice(0, 4);
-    if (File != "oncg") {
-      errs() << "Unexpected file type: " << File << ".\n";
+    StringRef buf = Buffer->getBuffer();
+    StringRef magic = buf.substr(0, 4);
+    if (magic == "gcno") {
+      de = DataExtractor(buf.substr(4), false, 0);
+    } else if (magic == "oncg") {
+      de = DataExtractor(buf.substr(4), true, 0);
+    } else {
+      errs() << "unexpected magic: " << magic << "\n";
       return false;
     }
-    Cursor = 4;
     return true;
   }
 
   /// readGCDAFormat - Check GCDA signature is valid at the beginning of buffer.
   bool readGCDAFormat() {
-    StringRef File = Buffer->getBuffer().slice(0, 4);
-    if (File != "adcg") {
-      errs() << "Unexpected file type: " << File << ".\n";
+    StringRef buf = Buffer->getBuffer();
+    StringRef magic = buf.substr(0, 4);
+    if (magic == "gcda") {
+      de = DataExtractor(buf.substr(4), false, 0);
+    } else if (magic == "adcg") {
+      de = DataExtractor(buf.substr(4), true, 0);
+    } else {
       return false;
     }
-    Cursor = 4;
     return true;
   }
 
   /// readGCOVVersion - Read GCOV version.
   bool readGCOVVersion(GCOV::GCOVVersion &Version) {
-    StringRef VersionStr = Buffer->getBuffer().slice(Cursor, Cursor + 4);
-    if (VersionStr == "*204") {
-      Cursor += 4;
-      Version = GCOV::V402;
+    std::string str(de.getBytes(cursor, 4));
+    if (str.size() != 4)
+      return false;
+    if (de.isLittleEndian())
+      std::reverse(str.begin(), str.end());
+    int ver = str[0] >= 'A'
+                  ? (str[0] - 'A') * 100 + (str[1] - '0') * 10 + str[2] - '0'
+                  : (str[0] - '0') * 10 + str[2] - '0';
+    if (ver >= 90) {
+      // PR gcov-profile/84846, r269678
+      Version = GCOV::V900;
+      return true;
+    } else if (ver >= 80) {
+      // PR gcov-profile/48463
+      Version = GCOV::V800;
+      return true;
+    } else if (ver >= 48) {
+      // r189778: the exit block moved from the last to the second.
+      Version = GCOV::V408;
+      return true;
+    } else if (ver >= 47) {
+      // r173147: split checksum into cfg checksum and line checksum.
+      Version = GCOV::V407;
+      return true;
+    } else if (ver >= 34) {
+      Version = GCOV::V304;
       return true;
     }
-    if (VersionStr == "*404") {
-      Cursor += 4;
-      Version = GCOV::V404;
-      return true;
-    }
-    if (VersionStr == "*704") {
-      Cursor += 4;
-      Version = GCOV::V704;
-      return true;
-    }
-    errs() << "Unexpected version: " << VersionStr << ".\n";
+    errs() << "unexpected version: " << str << "\n";
     return false;
   }
 
-  /// readFunctionTag - If cursor points to a function tag then increment the
-  /// cursor and return true otherwise return false.
-  bool readFunctionTag() {
-    StringRef Tag = Buffer->getBuffer().slice(Cursor, Cursor + 4);
-    if (Tag.empty() || Tag[0] != '\0' || Tag[1] != '\0' || Tag[2] != '\0' ||
-        Tag[3] != '\1') {
-      return false;
-    }
-    Cursor += 4;
-    return true;
-  }
-
-  /// readBlockTag - If cursor points to a block tag then increment the
-  /// cursor and return true otherwise return false.
-  bool readBlockTag() {
-    StringRef Tag = Buffer->getBuffer().slice(Cursor, Cursor + 4);
-    if (Tag.empty() || Tag[0] != '\0' || Tag[1] != '\0' || Tag[2] != '\x41' ||
-        Tag[3] != '\x01') {
-      return false;
-    }
-    Cursor += 4;
-    return true;
-  }
-
-  /// readEdgeTag - If cursor points to an edge tag then increment the
-  /// cursor and return true otherwise return false.
-  bool readEdgeTag() {
-    StringRef Tag = Buffer->getBuffer().slice(Cursor, Cursor + 4);
-    if (Tag.empty() || Tag[0] != '\0' || Tag[1] != '\0' || Tag[2] != '\x43' ||
-        Tag[3] != '\x01') {
-      return false;
-    }
-    Cursor += 4;
-    return true;
-  }
-
-  /// readLineTag - If cursor points to a line tag then increment the
-  /// cursor and return true otherwise return false.
-  bool readLineTag() {
-    StringRef Tag = Buffer->getBuffer().slice(Cursor, Cursor + 4);
-    if (Tag.empty() || Tag[0] != '\0' || Tag[1] != '\0' || Tag[2] != '\x45' ||
-        Tag[3] != '\x01') {
-      return false;
-    }
-    Cursor += 4;
-    return true;
-  }
-
-  /// readArcTag - If cursor points to an gcda arc tag then increment the
-  /// cursor and return true otherwise return false.
-  bool readArcTag() {
-    StringRef Tag = Buffer->getBuffer().slice(Cursor, Cursor + 4);
-    if (Tag.empty() || Tag[0] != '\0' || Tag[1] != '\0' || Tag[2] != '\xa1' ||
-        Tag[3] != '\1') {
-      return false;
-    }
-    Cursor += 4;
-    return true;
-  }
-
-  /// readObjectTag - If cursor points to an object summary tag then increment
-  /// the cursor and return true otherwise return false.
-  bool readObjectTag() {
-    StringRef Tag = Buffer->getBuffer().slice(Cursor, Cursor + 4);
-    if (Tag.empty() || Tag[0] != '\0' || Tag[1] != '\0' || Tag[2] != '\0' ||
-        Tag[3] != '\xa1') {
-      return false;
-    }
-    Cursor += 4;
-    return true;
-  }
-
-  /// readProgramTag - If cursor points to a program summary tag then increment
-  /// the cursor and return true otherwise return false.
-  bool readProgramTag() {
-    StringRef Tag = Buffer->getBuffer().slice(Cursor, Cursor + 4);
-    if (Tag.empty() || Tag[0] != '\0' || Tag[1] != '\0' || Tag[2] != '\0' ||
-        Tag[3] != '\xa3') {
-      return false;
-    }
-    Cursor += 4;
-    return true;
+  uint32_t getWord() { return de.getU32(cursor); }
+  StringRef getString() {
+    uint32_t len;
+    if (!readInt(len) || len == 0)
+      return {};
+    return de.getBytes(cursor, len * 4).split('\0').first;
   }
 
   bool readInt(uint32_t &Val) {
-    if (Buffer->getBuffer().size() < Cursor + 4) {
-      errs() << "Unexpected end of memory buffer: " << Cursor + 4 << ".\n";
+    if (cursor.tell() + 4 > de.size()) {
+      Val = 0;
+      errs() << "unexpected end of memory buffer: " << cursor.tell() << "\n";
       return false;
     }
-    StringRef Str = Buffer->getBuffer().slice(Cursor, Cursor + 4);
-    Cursor += 4;
-    Val = *(const uint32_t *)(Str.data());
+    Val = de.getU32(cursor);
     return true;
   }
 
@@ -216,28 +168,18 @@
   }
 
   bool readString(StringRef &Str) {
-    uint32_t Len = 0;
-    // Keep reading until we find a non-zero length. This emulates gcov's
-    // behaviour, which appears to do the same.
-    while (Len == 0)
-      if (!readInt(Len))
-        return false;
-    Len *= 4;
-    if (Buffer->getBuffer().size() < Cursor + Len) {
-      errs() << "Unexpected end of memory buffer: " << Cursor + Len << ".\n";
+    uint32_t len;
+    if (!readInt(len) || len == 0)
       return false;
-    }
-    Str = Buffer->getBuffer().slice(Cursor, Cursor + Len).split('\0').first;
-    Cursor += Len;
-    return true;
+    Str = de.getBytes(cursor, len * 4).split('\0').first;
+    return bool(cursor);
   }
 
-  uint64_t getCursor() const { return Cursor; }
-  void advanceCursor(uint32_t n) { Cursor += n * 4; }
+  DataExtractor de{ArrayRef<uint8_t>{}, false, 0};
+  DataExtractor::Cursor cursor{0};
 
 private:
   MemoryBuffer *Buffer;
-  uint64_t Cursor = 0;
 };
 
 /// GCOVFile - Collects coverage information for one pair of coverage file
@@ -248,28 +190,39 @@
 
   bool readGCNO(GCOVBuffer &Buffer);
   bool readGCDA(GCOVBuffer &Buffer);
-  uint32_t getChecksum() const { return Checksum; }
+  GCOV::GCOVVersion getVersion() const { return Version; }
   void print(raw_ostream &OS) const;
   void dump() const;
-  void collectLineCounts(FileInfo &FI);
 
-private:
+  std::vector<std::string> filenames;
+  StringMap<unsigned> filenameToIdx;
+
+public:
   bool GCNOInitialized = false;
   GCOV::GCOVVersion Version;
   uint32_t Checksum = 0;
-  SmallVector<std::unique_ptr<GCOVFunction>, 16> Functions;
+  StringRef cwd;
+  SmallVector<std::unique_ptr<GCOVFunction>, 16> functions;
+  std::map<uint32_t, GCOVFunction *> IdentToFunction;
   uint32_t RunCount = 0;
   uint32_t ProgramCount = 0;
+
+  using iterator = pointee_iterator<
+      SmallVectorImpl<std::unique_ptr<GCOVFunction>>::const_iterator>;
+  iterator begin() const { return iterator(functions.begin()); }
+  iterator end() const { return iterator(functions.end()); }
 };
 
-/// GCOVEdge - Collects edge information.
-struct GCOVEdge {
-  GCOVEdge(GCOVBlock &S, GCOVBlock &D) : Src(S), Dst(D) {}
+struct GCOVArc {
+  GCOVArc(GCOVBlock &src, GCOVBlock &dst, uint32_t flags)
+      : src(src), dst(dst), flags(flags) {}
+  bool onTree() const;
 
-  GCOVBlock &Src;
-  GCOVBlock &Dst;
-  uint64_t Count = 0;
-  uint64_t CyclesCount = 0;
+  GCOVBlock &src;
+  GCOVBlock &dst;
+  uint32_t flags;
+  uint64_t count = 0;
+  uint64_t cycleCount = 0;
 };
 
 /// GCOVFunction - Collects function information.
@@ -278,195 +231,86 @@
   using BlockIterator = pointee_iterator<
       SmallVectorImpl<std::unique_ptr<GCOVBlock>>::const_iterator>;
 
-  GCOVFunction(GCOVFile &P) : Parent(P) {}
+  GCOVFunction(GCOVFile &file) : file(file) {}
 
-  bool readGCNO(GCOVBuffer &Buffer, GCOV::GCOVVersion Version);
-  bool readGCDA(GCOVBuffer &Buffer, GCOV::GCOVVersion Version);
-  StringRef getName() const { return Name; }
-  StringRef getFilename() const { return Filename; }
-  size_t getNumBlocks() const { return Blocks.size(); }
+  StringRef getName(bool demangle) const;
+  StringRef getFilename() const;
   uint64_t getEntryCount() const;
-  uint64_t getExitCount() const;
+  GCOVBlock &getExitBlock() const;
 
-  BlockIterator block_begin() const { return Blocks.begin(); }
-  BlockIterator block_end() const { return Blocks.end(); }
-  iterator_range<BlockIterator> blocks() const {
-    return make_range(block_begin(), block_end());
+  iterator_range<BlockIterator> blocksRange() const {
+    return make_range(blocks.begin(), blocks.end());
   }
 
+  uint64_t propagateCounts(const GCOVBlock &v, GCOVArc *pred);
   void print(raw_ostream &OS) const;
   void dump() const;
-  void collectLineCounts(FileInfo &FI);
 
-private:
-  GCOVFile &Parent;
-  uint32_t Ident = 0;
-  uint32_t Checksum;
-  uint32_t LineNumber = 0;
+  GCOVFile &file;
+  uint32_t ident = 0;
+  uint32_t linenoChecksum;
+  uint32_t cfgChecksum = 0;
+  uint32_t startLine = 0;
+  uint32_t startColumn = 0;
+  uint32_t endLine = 0;
+  uint32_t endColumn = 0;
+  uint8_t artificial = 0;
   StringRef Name;
-  StringRef Filename;
-  SmallVector<std::unique_ptr<GCOVBlock>, 16> Blocks;
-  SmallVector<std::unique_ptr<GCOVEdge>, 16> Edges;
+  mutable SmallString<0> demangled;
+  unsigned srcIdx;
+  SmallVector<std::unique_ptr<GCOVBlock>, 0> blocks;
+  SmallVector<std::unique_ptr<GCOVArc>, 0> arcs, treeArcs;
+  DenseSet<const GCOVBlock *> visited;
 };
 
 /// GCOVBlock - Collects block information.
 class GCOVBlock {
-  struct EdgeWeight {
-    EdgeWeight(GCOVBlock *D) : Dst(D) {}
-
-    GCOVBlock *Dst;
-    uint64_t Count = 0;
-  };
-
 public:
-  using EdgeIterator = SmallVectorImpl<GCOVEdge *>::const_iterator;
-  using BlockVector = SmallVector<const GCOVBlock *, 4>;
+  using EdgeIterator = SmallVectorImpl<GCOVArc *>::const_iterator;
+  using BlockVector = SmallVector<const GCOVBlock *, 1>;
   using BlockVectorLists = SmallVector<BlockVector, 4>;
-  using Edges = SmallVector<GCOVEdge *, 4>;
+  using Edges = SmallVector<GCOVArc *, 4>;
 
-  GCOVBlock(GCOVFunction &P, uint32_t N) : Parent(P), Number(N) {}
-  ~GCOVBlock();
+  GCOVBlock(uint32_t N) : number(N) {}
 
-  const GCOVFunction &getParent() const { return Parent; }
-  void addLine(uint32_t N) { Lines.push_back(N); }
-  uint32_t getLastLine() const { return Lines.back(); }
-  void addCount(size_t DstEdgeNo, uint64_t N);
-  uint64_t getCount() const { return Counter; }
+  void addLine(uint32_t N) { lines.push_back(N); }
+  uint32_t getLastLine() const { return lines.back(); }
+  uint64_t getCount() const { return count; }
 
-  void addSrcEdge(GCOVEdge *Edge) {
-    assert(&Edge->Dst == this); // up to caller to ensure edge is valid
-    SrcEdges.push_back(Edge);
-  }
+  void addSrcEdge(GCOVArc *Edge) { pred.push_back(Edge); }
 
-  void addDstEdge(GCOVEdge *Edge) {
-    assert(&Edge->Src == this); // up to caller to ensure edge is valid
-    // Check if adding this edge causes list to become unsorted.
-    if (DstEdges.size() && DstEdges.back()->Dst.Number > Edge->Dst.Number)
-      DstEdgesAreSorted = false;
-    DstEdges.push_back(Edge);
-  }
+  void addDstEdge(GCOVArc *Edge) { succ.push_back(Edge); }
 
-  size_t getNumSrcEdges() const { return SrcEdges.size(); }
-  size_t getNumDstEdges() const { return DstEdges.size(); }
-  void sortDstEdges();
-
-  EdgeIterator src_begin() const { return SrcEdges.begin(); }
-  EdgeIterator src_end() const { return SrcEdges.end(); }
   iterator_range<EdgeIterator> srcs() const {
-    return make_range(src_begin(), src_end());
+    return make_range(pred.begin(), pred.end());
   }
 
-  EdgeIterator dst_begin() const { return DstEdges.begin(); }
-  EdgeIterator dst_end() const { return DstEdges.end(); }
   iterator_range<EdgeIterator> dsts() const {
-    return make_range(dst_begin(), dst_end());
+    return make_range(succ.begin(), succ.end());
   }
 
   void print(raw_ostream &OS) const;
   void dump() const;
-  void collectLineCounts(FileInfo &FI);
 
-  static uint64_t getCycleCount(const Edges &Path);
-  static void unblock(const GCOVBlock *U, BlockVector &Blocked,
-                      BlockVectorLists &BlockLists);
-  static bool lookForCircuit(const GCOVBlock *V, const GCOVBlock *Start,
-                             Edges &Path, BlockVector &Blocked,
-                             BlockVectorLists &BlockLists,
-                             const BlockVector &Blocks, uint64_t &Count);
-  static void getCyclesCount(const BlockVector &Blocks, uint64_t &Count);
+  static uint64_t
+  augmentOneCycle(GCOVBlock *src,
+                  std::vector<std::pair<GCOVBlock *, size_t>> &stack);
+  static uint64_t getCyclesCount(const BlockVector &blocks);
   static uint64_t getLineCount(const BlockVector &Blocks);
 
-private:
-  GCOVFunction &Parent;
-  uint32_t Number;
-  uint64_t Counter = 0;
-  bool DstEdgesAreSorted = true;
-  SmallVector<GCOVEdge *, 16> SrcEdges;
-  SmallVector<GCOVEdge *, 16> DstEdges;
-  SmallVector<uint32_t, 16> Lines;
-};
-
-class FileInfo {
-protected:
-  // It is unlikely--but possible--for multiple functions to be on the same
-  // line.
-  // Therefore this typedef allows LineData.Functions to store multiple
-  // functions
-  // per instance. This is rare, however, so optimize for the common case.
-  using FunctionVector = SmallVector<const GCOVFunction *, 1>;
-  using FunctionLines = DenseMap<uint32_t, FunctionVector>;
-  using BlockVector = SmallVector<const GCOVBlock *, 4>;
-  using BlockLines = DenseMap<uint32_t, BlockVector>;
-
-  struct LineData {
-    LineData() = default;
-
-    BlockLines Blocks;
-    FunctionLines Functions;
-    uint32_t LastLine = 0;
-  };
-
-  struct GCOVCoverage {
-    GCOVCoverage(StringRef Name) : Name(Name) {}
-
-    StringRef Name;
-
-    uint32_t LogicalLines = 0;
-    uint32_t LinesExec = 0;
-
-    uint32_t Branches = 0;
-    uint32_t BranchesExec = 0;
-    uint32_t BranchesTaken = 0;
-  };
-
 public:
-  FileInfo(const GCOV::Options &Options) : Options(Options) {}
-
-  void addBlockLine(StringRef Filename, uint32_t Line, const GCOVBlock *Block) {
-    if (Line > LineInfo[Filename].LastLine)
-      LineInfo[Filename].LastLine = Line;
-    LineInfo[Filename].Blocks[Line - 1].push_back(Block);
-  }
-
-  void addFunctionLine(StringRef Filename, uint32_t Line,
-                       const GCOVFunction *Function) {
-    if (Line > LineInfo[Filename].LastLine)
-      LineInfo[Filename].LastLine = Line;
-    LineInfo[Filename].Functions[Line - 1].push_back(Function);
-  }
-
-  void setRunCount(uint32_t Runs) { RunCount = Runs; }
-  void setProgramCount(uint32_t Programs) { ProgramCount = Programs; }
-  void print(raw_ostream &OS, StringRef MainFilename, StringRef GCNOFile,
-             StringRef GCDAFile);
-
-protected:
-  std::string getCoveragePath(StringRef Filename, StringRef MainFilename);
-  std::unique_ptr<raw_ostream> openCoveragePath(StringRef CoveragePath);
-  void printFunctionSummary(raw_ostream &OS, const FunctionVector &Funcs) const;
-  void printBlockInfo(raw_ostream &OS, const GCOVBlock &Block,
-                      uint32_t LineIndex, uint32_t &BlockNo) const;
-  void printBranchInfo(raw_ostream &OS, const GCOVBlock &Block,
-                       GCOVCoverage &Coverage, uint32_t &EdgeNo);
-  void printUncondBranchInfo(raw_ostream &OS, uint32_t &EdgeNo,
-                             uint64_t Count) const;
-
-  void printCoverage(raw_ostream &OS, const GCOVCoverage &Coverage) const;
-  void printFuncCoverage(raw_ostream &OS) const;
-  void printFileCoverage(raw_ostream &OS) const;
-
-  const GCOV::Options &Options;
-  StringMap<LineData> LineInfo;
-  uint32_t RunCount = 0;
-  uint32_t ProgramCount = 0;
-
-  using FileCoverageList = SmallVector<std::pair<std::string, GCOVCoverage>, 4>;
-  using FuncCoverageMap = MapVector<const GCOVFunction *, GCOVCoverage>;
-
-  FileCoverageList FileCoverages;
-  FuncCoverageMap FuncCoverages;
+  uint32_t number;
+  uint64_t count = 0;
+  SmallVector<GCOVArc *, 2> pred;
+  SmallVector<GCOVArc *, 2> succ;
+  SmallVector<uint32_t, 4> lines;
+  bool traversable = false;
+  GCOVArc *incoming = nullptr;
 };
 
+void gcovOneInput(const GCOV::Options &options, StringRef filename,
+                  StringRef gcno, StringRef gcda, GCOVFile &file);
+
 } // end namespace llvm
 
 #endif // LLVM_SUPPORT_GCOV_H
diff --git a/linux-x64/clang/include/llvm/ProfileData/InstrProf.h b/linux-x64/clang/include/llvm/ProfileData/InstrProf.h
index c7d764a..9c16c35 100644
--- a/linux-x64/clang/include/llvm/ProfileData/InstrProf.h
+++ b/linux-x64/clang/include/llvm/ProfileData/InstrProf.h
@@ -23,6 +23,7 @@
 #include "llvm/IR/GlobalValue.h"
 #include "llvm/IR/ProfileSummary.h"
 #include "llvm/ProfileData/InstrProfData.inc"
+#include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/Error.h"
@@ -73,9 +74,10 @@
   return INSTR_PROF_VALUE_PROF_FUNC_STR;
 }
 
-/// Return the name profile runtime entry point to do value range profiling.
-inline StringRef getInstrProfValueRangeProfFuncName() {
-  return INSTR_PROF_VALUE_RANGE_PROF_FUNC_STR;
+/// Return the name profile runtime entry point to do memop size value
+/// profiling.
+inline StringRef getInstrProfValueProfMemOpFuncName() {
+  return INSTR_PROF_VALUE_PROF_MEMOP_FUNC_STR;
 }
 
 /// Return the name prefix of variables containing instrumented function names.
@@ -93,10 +95,6 @@
 /// Return the name of value profile node array variables:
 inline StringRef getInstrProfVNodesVarName() { return "__llvm_prf_vnodes"; }
 
-/// Return the name prefix of the COMDAT group for instrumentation variables
-/// associated with a COMDAT function.
-inline StringRef getInstrProfComdatPrefix() { return "__profv_"; }
-
 /// Return the name of the variable holding the strings (possibly compressed)
 /// of all function's PGO names.
 inline StringRef getInstrProfNamesVarName() {
@@ -157,6 +155,10 @@
   return "__llvm_profile_runtime_user";
 }
 
+inline StringRef getInstrProfCounterBiasVarName() {
+  return "__llvm_profile_counter_bias";
+}
+
 /// Return the marker used to separate PGO names during serialization.
 inline StringRef getInstrProfNameSeparator() { return "\01"; }
 
@@ -560,10 +562,9 @@
 
 StringRef InstrProfSymtab::getFuncName(uint64_t FuncMD5Hash) {
   finalizeSymtab();
-  auto Result =
-      std::lower_bound(MD5NameMap.begin(), MD5NameMap.end(), FuncMD5Hash,
-                       [](const std::pair<uint64_t, std::string> &LHS,
-                          uint64_t RHS) { return LHS.first < RHS; });
+  auto Result = llvm::lower_bound(MD5NameMap, FuncMD5Hash,
+                                  [](const std::pair<uint64_t, StringRef> &LHS,
+                                     uint64_t RHS) { return LHS.first < RHS; });
   if (Result != MD5NameMap.end() && Result->first == FuncMD5Hash)
     return Result->second;
   return StringRef();
@@ -571,10 +572,9 @@
 
 Function* InstrProfSymtab::getFunction(uint64_t FuncMD5Hash) {
   finalizeSymtab();
-  auto Result =
-      std::lower_bound(MD5FuncMap.begin(), MD5FuncMap.end(), FuncMD5Hash,
-                       [](const std::pair<uint64_t, Function*> &LHS,
-                          uint64_t RHS) { return LHS.first < RHS; });
+  auto Result = llvm::lower_bound(MD5FuncMap, FuncMD5Hash,
+                                  [](const std::pair<uint64_t, Function *> &LHS,
+                                     uint64_t RHS) { return LHS.first < RHS; });
   if (Result != MD5FuncMap.end() && Result->first == FuncMD5Hash)
     return Result->second;
   return nullptr;
@@ -634,8 +634,8 @@
     FuncHash = Hash;
   }
 
-  Error accumuateCounts(const std::string &BaseFilename,
-                        const std::string &TestFilename, bool IsCS);
+  Error accumulateCounts(const std::string &BaseFilename,
+                         const std::string &TestFilename, bool IsCS);
   void addOneMismatch(const CountSumOrPercent &MismatchFunc);
   void addOneUnique(const CountSumOrPercent &UniqueFunc);
 
@@ -677,8 +677,8 @@
   /// Optionally scale merged counts by \p Weight.
   void merge(InstrProfValueSiteRecord &Input, uint64_t Weight,
              function_ref<void(instrprof_error)> Warn);
-  /// Scale up value profile data counts.
-  void scale(uint64_t Weight, function_ref<void(instrprof_error)> Warn);
+  /// Scale up value profile data counts by N (Numerator) / D (Denominator).
+  void scale(uint64_t N, uint64_t D, function_ref<void(instrprof_error)> Warn);
 
   /// Compute the overlap b/w this record and Input record.
   void overlap(InstrProfValueSiteRecord &Input, uint32_t ValueKind,
@@ -695,7 +695,7 @@
   InstrProfRecord(const InstrProfRecord &RHS)
       : Counts(RHS.Counts),
         ValueData(RHS.ValueData
-                      ? llvm::make_unique<ValueProfData>(*RHS.ValueData)
+                      ? std::make_unique<ValueProfData>(*RHS.ValueData)
                       : nullptr) {}
   InstrProfRecord &operator=(InstrProfRecord &&) = default;
   InstrProfRecord &operator=(const InstrProfRecord &RHS) {
@@ -705,7 +705,7 @@
       return *this;
     }
     if (!ValueData)
-      ValueData = llvm::make_unique<ValueProfData>(*RHS.ValueData);
+      ValueData = std::make_unique<ValueProfData>(*RHS.ValueData);
     else
       *ValueData = *RHS.ValueData;
     return *this;
@@ -752,8 +752,8 @@
              function_ref<void(instrprof_error)> Warn);
 
   /// Scale up profile counts (including value profile data) by
-  /// \p Weight.
-  void scale(uint64_t Weight, function_ref<void(instrprof_error)> Warn);
+  /// a factor of (N / D).
+  void scale(uint64_t N, uint64_t D, function_ref<void(instrprof_error)> Warn);
 
   /// Sort value profile data (per site) by count.
   void sortValueData() {
@@ -772,7 +772,7 @@
   void clearValueData() { ValueData = nullptr; }
 
   /// Compute the sums of all counts and store in Sum.
-  void accumuateCounts(CountSumOrPercent &Sum) const;
+  void accumulateCounts(CountSumOrPercent &Sum) const;
 
   /// Compute the overlap b/w this IntrprofRecord and Other.
   void overlap(InstrProfRecord &Other, OverlapStats &Overlap,
@@ -817,7 +817,7 @@
   std::vector<InstrProfValueSiteRecord> &
   getOrCreateValueSitesForKind(uint32_t ValueKind) {
     if (!ValueData)
-      ValueData = llvm::make_unique<ValueProfData>();
+      ValueData = std::make_unique<ValueProfData>();
     switch (ValueKind) {
     case IPVK_IndirectCallTarget:
       return ValueData->IndirectCallSites;
@@ -838,8 +838,8 @@
                           uint64_t Weight,
                           function_ref<void(instrprof_error)> Warn);
 
-  // Scale up value profile data count.
-  void scaleValueProfData(uint32_t ValueKind, uint64_t Weight,
+  // Scale up value profile data count by N (Numerator) / D (Denominator).
+  void scaleValueProfData(uint32_t ValueKind, uint64_t N, uint64_t D,
                           function_ref<void(instrprof_error)> Warn);
 };
 
@@ -889,7 +889,7 @@
 std::unique_ptr<InstrProfValueData[]>
 InstrProfRecord::getValueForSite(uint32_t ValueKind, uint32_t Site,
                                  uint64_t *TotalC) const {
-  uint64_t Dummy;
+  uint64_t Dummy = 0;
   uint64_t &TotalCount = (TotalC == nullptr ? Dummy : *TotalC);
   uint32_t N = getNumValueDataForSite(ValueKind, Site);
   if (N == 0) {
@@ -897,7 +897,7 @@
     return std::unique_ptr<InstrProfValueData[]>(nullptr);
   }
 
-  auto VD = llvm::make_unique<InstrProfValueData[]>(N);
+  auto VD = std::make_unique<InstrProfValueData[]>(N);
   TotalCount = getValueForSite(VD.get(), ValueKind, Site);
 
   return VD;
@@ -978,7 +978,12 @@
   Version4 = 4,
   // In this version, the frontend PGO stable hash algorithm defaults to V2.
   Version5 = 5,
-  // The current version is 5.
+  // In this version, the frontend PGO stable hash algorithm got fixed and
+  // may produce hashes different from Version5.
+  Version6 = 6,
+  // An additional counter is added around logical operators.
+  Version7 = 7,
+  // The current version is 7.
   CurrentVersion = INSTR_PROF_INDEX_VERSION
 };
 const uint64_t Version = ProfVersion::CurrentVersion;
@@ -1134,10 +1139,15 @@
 
 // Create a COMDAT variable INSTR_PROF_RAW_VERSION_VAR to make the runtime
 // aware this is an ir_level profile so it can set the version flag.
-void createIRLevelProfileFlagVar(Module &M, bool IsCS);
+void createIRLevelProfileFlagVar(Module &M, bool IsCS,
+                                 bool InstrEntryBBEnabled);
 
 // Create the variable for the profile file name.
 void createProfileFileNameVar(Module &M, StringRef InstrProfileOutput);
 
+// Whether to compress function names in profile records, and filenames in
+// code coverage mappings. Used by the Instrumentation library and unit tests.
+extern cl::opt<bool> DoInstrProfNameCompression;
+
 } // end namespace llvm
 #endif // LLVM_PROFILEDATA_INSTRPROF_H
diff --git a/linux-x64/clang/include/llvm/ProfileData/InstrProfData.inc b/linux-x64/clang/include/llvm/ProfileData/InstrProfData.inc
index 749781b..f715505 100644
--- a/linux-x64/clang/include/llvm/ProfileData/InstrProfData.inc
+++ b/linux-x64/clang/include/llvm/ProfileData/InstrProfData.inc
@@ -130,7 +130,9 @@
 INSTR_PROF_RAW_HEADER(uint64_t, Magic, __llvm_profile_get_magic())
 INSTR_PROF_RAW_HEADER(uint64_t, Version, __llvm_profile_get_version())
 INSTR_PROF_RAW_HEADER(uint64_t, DataSize, DataSize)
+INSTR_PROF_RAW_HEADER(uint64_t, PaddingBytesBeforeCounters, PaddingBytesBeforeCounters)
 INSTR_PROF_RAW_HEADER(uint64_t, CountersSize, CountersSize)
+INSTR_PROF_RAW_HEADER(uint64_t, PaddingBytesAfterCounters, PaddingBytesAfterCounters)
 INSTR_PROF_RAW_HEADER(uint64_t, NamesSize,  NamesSize)
 INSTR_PROF_RAW_HEADER(uint64_t, CountersDelta, (uintptr_t)CountersBegin)
 INSTR_PROF_RAW_HEADER(uint64_t, NamesDelta, (uintptr_t)NamesBegin)
@@ -152,17 +154,7 @@
 VALUE_PROF_FUNC_PARAM(uint64_t, TargetValue, Type::getInt64Ty(Ctx)) \
                       INSTR_PROF_COMMA
 VALUE_PROF_FUNC_PARAM(void *, Data, Type::getInt8PtrTy(Ctx)) INSTR_PROF_COMMA
-#ifndef VALUE_RANGE_PROF
 VALUE_PROF_FUNC_PARAM(uint32_t, CounterIndex, Type::getInt32Ty(Ctx))
-#else /* VALUE_RANGE_PROF */
-VALUE_PROF_FUNC_PARAM(uint32_t, CounterIndex, Type::getInt32Ty(Ctx)) \
-                      INSTR_PROF_COMMA
-VALUE_PROF_FUNC_PARAM(uint64_t, PreciseRangeStart, Type::getInt64Ty(Ctx)) \
-                      INSTR_PROF_COMMA
-VALUE_PROF_FUNC_PARAM(uint64_t, PreciseRangeLast, Type::getInt64Ty(Ctx)) \
-                      INSTR_PROF_COMMA
-VALUE_PROF_FUNC_PARAM(uint64_t, LargeValue, Type::getInt64Ty(Ctx))
-#endif /*VALUE_RANGE_PROF */
 #undef VALUE_PROF_FUNC_PARAM
 #undef INSTR_PROF_COMMA
 /* VALUE_PROF_FUNC_PARAM end */
@@ -196,6 +188,14 @@
 #undef VALUE_PROF_KIND
 /* VALUE_PROF_KIND end */
 
+#undef COVMAP_V2_OR_V3
+#ifdef COVMAP_V2
+#define COVMAP_V2_OR_V3
+#endif
+#ifdef COVMAP_V3
+#define COVMAP_V2_OR_V3
+#endif
+
 /* COVMAP_FUNC_RECORD start */
 /* Definition of member fields of the function record structure in coverage
  * map.
@@ -212,16 +212,30 @@
 COVMAP_FUNC_RECORD(const uint32_t, llvm::Type::getInt32Ty(Ctx), NameSize, \
                    llvm::ConstantInt::get(llvm::Type::getInt32Ty(Ctx), \
                    NameValue.size()))
-#else
+#endif
+#ifdef COVMAP_V2_OR_V3
 COVMAP_FUNC_RECORD(const int64_t, llvm::Type::getInt64Ty(Ctx), NameRef, \
-                   llvm::ConstantInt::get(llvm::Type::getInt64Ty(Ctx), \
-                   llvm::IndexedInstrProf::ComputeHash(NameValue)))
+                   llvm::ConstantInt::get( \
+                     llvm::Type::getInt64Ty(Ctx), NameHash))
 #endif
 COVMAP_FUNC_RECORD(const uint32_t, llvm::Type::getInt32Ty(Ctx), DataSize, \
-                   llvm::ConstantInt::get(llvm::Type::getInt32Ty(Ctx),\
-                   CoverageMapping.size()))
+                   llvm::ConstantInt::get( \
+                     llvm::Type::getInt32Ty(Ctx), CoverageMapping.size()))
 COVMAP_FUNC_RECORD(const uint64_t, llvm::Type::getInt64Ty(Ctx), FuncHash, \
-                   llvm::ConstantInt::get(llvm::Type::getInt64Ty(Ctx), FuncHash))
+                   llvm::ConstantInt::get( \
+                     llvm::Type::getInt64Ty(Ctx), FuncHash))
+#ifdef COVMAP_V3
+COVMAP_FUNC_RECORD(const uint64_t, llvm::Type::getInt64Ty(Ctx), FilenamesRef, \
+                   llvm::ConstantInt::get( \
+                     llvm::Type::getInt64Ty(Ctx), FilenamesRef))
+COVMAP_FUNC_RECORD(const char, \
+                   llvm::ArrayType::get(llvm::Type::getInt8Ty(Ctx), \
+                                        CoverageMapping.size()), \
+                   CoverageMapping,
+                   llvm::ConstantDataArray::getRaw( \
+                     CoverageMapping, CoverageMapping.size(), \
+                     llvm::Type::getInt8Ty(Ctx)))
+#endif
 #undef COVMAP_FUNC_RECORD
 /* COVMAP_FUNC_RECORD end.  */
 
@@ -234,7 +248,7 @@
 #define INSTR_PROF_DATA_DEFINED
 #endif
 COVMAP_HEADER(uint32_t, Int32Ty, NRecords, \
-              llvm::ConstantInt::get(Int32Ty,  FunctionRecords.size()))
+              llvm::ConstantInt::get(Int32Ty, NRecords))
 COVMAP_HEADER(uint32_t, Int32Ty, FilenamesSize, \
               llvm::ConstantInt::get(Int32Ty, FilenamesSize))
 COVMAP_HEADER(uint32_t, Int32Ty, CoverageSize, \
@@ -265,6 +279,9 @@
 INSTR_PROF_SECT_ENTRY(IPSK_covmap, \
                       INSTR_PROF_QUOTE(INSTR_PROF_COVMAP_COMMON), \
                       INSTR_PROF_COVMAP_COFF, "__LLVM_COV,")
+INSTR_PROF_SECT_ENTRY(IPSK_covfun, \
+                      INSTR_PROF_QUOTE(INSTR_PROF_COVFUN_COMMON), \
+                      INSTR_PROF_COVFUN_COFF, "__LLVM_COV,")
 INSTR_PROF_SECT_ENTRY(IPSK_orderfile, \
                       INSTR_PROF_QUOTE(INSTR_PROF_ORDERFILE_COMMON), \
                       INSTR_PROF_QUOTE(INSTR_PROF_ORDERFILE_COFF), "__DATA,")
@@ -628,11 +645,11 @@
         (uint64_t)'f' << 16 | (uint64_t)'R' << 8 | (uint64_t)129
 
 /* Raw profile format version (start from 1). */
-#define INSTR_PROF_RAW_VERSION 4
+#define INSTR_PROF_RAW_VERSION 5
 /* Indexed profile format version (start from 1). */
-#define INSTR_PROF_INDEX_VERSION 5
-/* Coverage mapping format vresion (start from 0). */
-#define INSTR_PROF_COVMAP_VERSION 2
+#define INSTR_PROF_INDEX_VERSION 7
+/* Coverage mapping format version (start from 0). */
+#define INSTR_PROF_COVMAP_VERSION 4
 
 /* Profile version is always of type uint64_t. Reserve the upper 8 bits in the
  * version for other variants of profile. We set the lowest bit of the upper 8
@@ -644,6 +661,7 @@
 #define GET_VERSION(V) ((V) & ~VARIANT_MASKS_ALL)
 #define VARIANT_MASK_IR_PROF (0x1ULL << 56)
 #define VARIANT_MASK_CSIR_PROF (0x1ULL << 57)
+#define VARIANT_MASK_INSTR_ENTRY (0x1ULL << 58)
 #define INSTR_PROF_RAW_VERSION_VAR __llvm_profile_raw_version
 #define INSTR_PROF_PROFILE_RUNTIME_VAR __llvm_profile_runtime
 
@@ -659,6 +677,7 @@
 #define INSTR_PROF_VALS_COMMON __llvm_prf_vals
 #define INSTR_PROF_VNODES_COMMON __llvm_prf_vnds
 #define INSTR_PROF_COVMAP_COMMON __llvm_covmap
+#define INSTR_PROF_COVFUN_COMMON __llvm_covfun
 #define INSTR_PROF_ORDERFILE_COMMON __llvm_orderfile
 /* Windows section names. Because these section names contain dollar characters,
  * they must be quoted.
@@ -669,6 +688,7 @@
 #define INSTR_PROF_VALS_COFF ".lprfv$M"
 #define INSTR_PROF_VNODES_COFF ".lprfnd$M"
 #define INSTR_PROF_COVMAP_COFF ".lcovmap$M"
+#define INSTR_PROF_COVFUN_COFF ".lcovfun$M"
 #define INSTR_PROF_ORDERFILE_COFF ".lorderfile$M"
 
 #ifdef _WIN32
@@ -683,6 +703,7 @@
 /* Value profile nodes section. */
 #define INSTR_PROF_VNODES_SECT_NAME INSTR_PROF_VNODES_COFF
 #define INSTR_PROF_COVMAP_SECT_NAME INSTR_PROF_COVMAP_COFF
+#define INSTR_PROF_COVFUN_SECT_NAME INSTR_PROF_COVFUN_COFF
 #define INSTR_PROF_ORDERFILE_SECT_NAME INSTR_PROF_ORDERFILE_COFF
 #else
 /* Runtime section names and name strings.  */
@@ -696,6 +717,7 @@
 /* Value profile nodes section. */
 #define INSTR_PROF_VNODES_SECT_NAME INSTR_PROF_QUOTE(INSTR_PROF_VNODES_COMMON)
 #define INSTR_PROF_COVMAP_SECT_NAME INSTR_PROF_QUOTE(INSTR_PROF_COVMAP_COMMON)
+#define INSTR_PROF_COVFUN_SECT_NAME INSTR_PROF_QUOTE(INSTR_PROF_COVFUN_COMMON)
 /* Order file instrumentation. */
 #define INSTR_PROF_ORDERFILE_SECT_NAME                                         \
   INSTR_PROF_QUOTE(INSTR_PROF_ORDERFILE_COMMON)
@@ -722,9 +744,9 @@
 #define INSTR_PROF_VALUE_PROF_FUNC __llvm_profile_instrument_target
 #define INSTR_PROF_VALUE_PROF_FUNC_STR \
         INSTR_PROF_QUOTE(INSTR_PROF_VALUE_PROF_FUNC)
-#define INSTR_PROF_VALUE_RANGE_PROF_FUNC __llvm_profile_instrument_range
-#define INSTR_PROF_VALUE_RANGE_PROF_FUNC_STR \
-        INSTR_PROF_QUOTE(INSTR_PROF_VALUE_RANGE_PROF_FUNC)
+#define INSTR_PROF_VALUE_PROF_MEMOP_FUNC __llvm_profile_instrument_memop
+#define INSTR_PROF_VALUE_PROF_MEMOP_FUNC_STR                                   \
+  INSTR_PROF_QUOTE(INSTR_PROF_VALUE_PROF_MEMOP_FUNC)
 
 /* InstrProfile per-function control data alignment.  */
 #define INSTR_PROF_DATA_ALIGNMENT 8
@@ -742,7 +764,7 @@
 #endif /* INSTR_PROF_DATA_INC */
 
 #ifndef INSTR_ORDER_FILE_INC
-// The maximal # of functions: 128*1024 (the buffer size will be 128*4 KB).
+/* The maximal # of functions: 128*1024 (the buffer size will be 128*4 KB). */
 #define INSTR_ORDER_FILE_BUFFER_SIZE 131072
 #define INSTR_ORDER_FILE_BUFFER_BITS 17
 #define INSTR_ORDER_FILE_BUFFER_MASK 0x1ffff
@@ -750,3 +772,123 @@
 #else
 #undef INSTR_PROF_DATA_DEFINED
 #endif
+
+#undef COVMAP_V2_OR_V3
+
+#ifdef INSTR_PROF_VALUE_PROF_MEMOP_API
+
+#ifdef __cplusplus
+#define INSTR_PROF_INLINE inline
+#else
+#define INSTR_PROF_INLINE
+#endif
+
+/* The value range buckets (22 buckets) for the memop size value profiling looks
+ * like:
+ *
+ *   [0, 0]
+ *   [1, 1]
+ *   [2, 2]
+ *   [3, 3]
+ *   [4, 4]
+ *   [5, 5]
+ *   [6, 6]
+ *   [7, 7]
+ *   [8, 8]
+ *   [9, 15]
+ *   [16, 16]
+ *   [17, 31]
+ *   [32, 32]
+ *   [33, 63]
+ *   [64, 64]
+ *   [65, 127]
+ *   [128, 128]
+ *   [129, 255]
+ *   [256, 256]
+ *   [257, 511]
+ *   [512, 512]
+ *   [513, UINT64_MAX]
+ *
+ * Each range has a 'representative value' which is the lower end value of the
+ * range and used to store in the runtime profile data records and the VP
+ * metadata. For example, it's 2 for [2, 2] and 64 for [65, 127].
+ */
+
+/*
+ * Clz and Popcount. This code was copied from
+ * compiler-rt/lib/fuzzer/{FuzzerBuiltins.h,FuzzerBuiltinsMsvc.h} and
+ * llvm/include/llvm/Support/MathExtras.h.
+ */
+#if defined(_MSC_VER) && !defined(__clang__)
+
+#include <intrin.h>
+INSTR_PROF_VISIBILITY INSTR_PROF_INLINE
+int InstProfClzll(unsigned long long X) {
+  unsigned long LeadZeroIdx = 0;
+#if !defined(_M_ARM64) && !defined(_M_X64)
+  // Scan the high 32 bits.
+  if (_BitScanReverse(&LeadZeroIdx, (unsigned long)(X >> 32)))
+    return (int)(63 - (LeadZeroIdx + 32)); // Create a bit offset
+                                                      // from the MSB.
+  // Scan the low 32 bits.
+  if (_BitScanReverse(&LeadZeroIdx, (unsigned long)(X)))
+    return (int)(63 - LeadZeroIdx);
+#else
+  if (_BitScanReverse64(&LeadZeroIdx, X)) return 63 - LeadZeroIdx;
+#endif
+  return 64;
+}
+INSTR_PROF_VISIBILITY INSTR_PROF_INLINE
+int InstProfPopcountll(unsigned long long X) {
+  // This code originates from https://reviews.llvm.org/rG30626254510f.
+  unsigned long long v = X;
+  v = v - ((v >> 1) & 0x5555555555555555ULL);
+  v = (v & 0x3333333333333333ULL) + ((v >> 2) & 0x3333333333333333ULL);
+  v = (v + (v >> 4)) & 0x0F0F0F0F0F0F0F0FULL;
+  return (int)((unsigned long long)(v * 0x0101010101010101ULL) >> 56);
+}
+
+#else
+
+INSTR_PROF_VISIBILITY INSTR_PROF_INLINE
+int InstProfClzll(unsigned long long X) { return __builtin_clzll(X); }
+INSTR_PROF_VISIBILITY INSTR_PROF_INLINE
+int InstProfPopcountll(unsigned long long X) { return __builtin_popcountll(X); }
+
+#endif  /* defined(_MSC_VER) && !defined(__clang__) */
+
+/* Map an (observed) memop size value to the representative value of its range.
+ * For example, 5 -> 5, 22 -> 17, 99 -> 65, 256 -> 256, 1001 -> 513. */
+INSTR_PROF_VISIBILITY INSTR_PROF_INLINE uint64_t
+InstrProfGetRangeRepValue(uint64_t Value) {
+  if (Value <= 8)
+    // The first ranges are individually tracked. Use the value as is.
+    return Value;
+  else if (Value >= 513)
+    // The last range is mapped to its lowest value.
+    return 513;
+  else if (InstProfPopcountll(Value) == 1)
+    // If it's a power of two, use it as is.
+    return Value;
+  else
+    // Otherwise, take to the previous power of two + 1.
+    return (1 << (64 - InstProfClzll(Value) - 1)) + 1;
+}
+
+/* Return true if the range that an (observed) memop size value belongs to has
+ * only a single value in the range.  For example, 0 -> true, 8 -> true, 10 ->
+ * false, 64 -> true, 100 -> false, 513 -> false. */
+INSTR_PROF_VISIBILITY INSTR_PROF_INLINE unsigned
+InstrProfIsSingleValRange(uint64_t Value) {
+  if (Value <= 8)
+    // The first ranges are individually tracked.
+    return 1;
+  else if (InstProfPopcountll(Value) == 1)
+    // If it's a power of two, there's only one value.
+    return 1;
+  else
+    // Otherwise, there's more than one value in the range.
+    return 0;
+}
+
+#endif /* INSTR_PROF_VALUE_PROF_MEMOP_API */
diff --git a/linux-x64/clang/include/llvm/ProfileData/InstrProfReader.h b/linux-x64/clang/include/llvm/ProfileData/InstrProfReader.h
index 73751fa..2c2cfb9 100644
--- a/linux-x64/clang/include/llvm/ProfileData/InstrProfReader.h
+++ b/linux-x64/clang/include/llvm/ProfileData/InstrProfReader.h
@@ -50,8 +50,12 @@
   InstrProfIterator(InstrProfReader *Reader) : Reader(Reader) { Increment(); }
 
   InstrProfIterator &operator++() { Increment(); return *this; }
-  bool operator==(const InstrProfIterator &RHS) { return Reader == RHS.Reader; }
-  bool operator!=(const InstrProfIterator &RHS) { return Reader != RHS.Reader; }
+  bool operator==(const InstrProfIterator &RHS) const {
+    return Reader == RHS.Reader;
+  }
+  bool operator!=(const InstrProfIterator &RHS) const {
+    return Reader != RHS.Reader;
+  }
   value_type &operator*() { return Record; }
   value_type *operator->() { return &Record; }
 };
@@ -79,6 +83,8 @@
 
   virtual bool hasCSIRLevelProfile() const = 0;
 
+  virtual bool instrEntryBBEnabled() const = 0;
+
   /// Return the PGO symtab. There are three different readers:
   /// Raw, Text, and Indexed profile readers. The first two types
   /// of readers are used only by llvm-profdata tool, while the indexed
@@ -92,7 +98,7 @@
   virtual InstrProfSymtab &getSymtab() = 0;
 
   /// Compute the sum of counts and return in Sum.
-  void accumuateCounts(CountSumOrPercent &Sum, bool IsCS);
+  void accumulateCounts(CountSumOrPercent &Sum, bool IsCS);
 
 protected:
   std::unique_ptr<InstrProfSymtab> Symtab;
@@ -148,6 +154,7 @@
   line_iterator Line;
   bool IsIRLevelProfile = false;
   bool HasCSIRLevelProfile = false;
+  bool InstrEntryBBEnabled = false;
 
   Error readValueProfileData(InstrProfRecord &Record);
 
@@ -164,6 +171,8 @@
 
   bool hasCSIRLevelProfile() const override { return HasCSIRLevelProfile; }
 
+  bool instrEntryBBEnabled() const override { return InstrEntryBBEnabled; }
+
   /// Read the header.
   Error readHeader() override;
 
@@ -224,6 +233,10 @@
     return (Version & VARIANT_MASK_CSIR_PROF) != 0;
   }
 
+  bool instrEntryBBEnabled() const override {
+    return (Version & VARIANT_MASK_INSTR_ENTRY) != 0;
+  }
+
   InstrProfSymtab &getSymtab() override {
     assert(Symtab.get());
     return *Symtab.get();
@@ -268,8 +281,14 @@
       return (const char *)ValueDataStart;
   }
 
-  const uint64_t *getCounter(IntPtrT CounterPtr) const {
-    ptrdiff_t Offset = (swap(CounterPtr) - CountersDelta) / sizeof(uint64_t);
+  /// Get the offset of \p CounterPtr from the start of the counters section of
+  /// the profile. The offset has units of "number of counters", i.e. increasing
+  /// the offset by 1 corresponds to an increase in the *byte offset* by 8.
+  ptrdiff_t getCounterOffset(IntPtrT CounterPtr) const {
+    return (swap(CounterPtr) - CountersDelta) / sizeof(uint64_t);
+  }
+
+  const uint64_t *getCounter(ptrdiff_t Offset) const {
     return CountersStart + Offset;
   }
 
@@ -354,6 +373,7 @@
   virtual uint64_t getVersion() const = 0;
   virtual bool isIRLevelProfile() const = 0;
   virtual bool hasCSIRLevelProfile() const = 0;
+  virtual bool instrEntryBBEnabled() const = 0;
   virtual Error populateSymtab(InstrProfSymtab &) = 0;
 };
 
@@ -402,6 +422,10 @@
     return (FormatVersion & VARIANT_MASK_CSIR_PROF) != 0;
   }
 
+  bool instrEntryBBEnabled() const override {
+    return (FormatVersion & VARIANT_MASK_INSTR_ENTRY) != 0;
+  }
+
   Error populateSymtab(InstrProfSymtab &Symtab) override {
     return Symtab.create(HashTable->keys());
   }
@@ -456,6 +480,10 @@
     return Index->hasCSIRLevelProfile();
   }
 
+  bool instrEntryBBEnabled() const override {
+    return Index->instrEntryBBEnabled();
+  }
+
   /// Return true if the given buffer is in an indexed instrprof format.
   static bool hasFormat(const MemoryBuffer &DataBuffer);
 
diff --git a/linux-x64/clang/include/llvm/ProfileData/InstrProfWriter.h b/linux-x64/clang/include/llvm/ProfileData/InstrProfWriter.h
index 5882fa2..35c2669 100644
--- a/linux-x64/clang/include/llvm/ProfileData/InstrProfWriter.h
+++ b/linux-x64/clang/include/llvm/ProfileData/InstrProfWriter.h
@@ -40,13 +40,16 @@
   bool Sparse;
   StringMap<ProfilingData> FunctionData;
   ProfKind ProfileKind = PF_Unknown;
+  bool InstrEntryBBEnabled;
   // Use raw pointer here for the incomplete type object.
   InstrProfRecordWriterTrait *InfoObj;
 
 public:
-  InstrProfWriter(bool Sparse = false);
+  InstrProfWriter(bool Sparse = false, bool InstrEntryBBEnabled = false);
   ~InstrProfWriter();
 
+  StringMap<ProfilingData> &getProfileData() { return FunctionData; }
+
   /// Add function counts for the given function. If there are already counts
   /// for this function and the hash and number of counts match, each counter is
   /// summed. Optionally scale counts by \p Weight.
@@ -97,6 +100,7 @@
     return Error::success();
   }
 
+  void setInstrEntryBBEnabled(bool Enabled) { InstrEntryBBEnabled = Enabled; }
   // Internal interface for testing purpose only.
   void setValueProfDataEndianness(support::endianness Endianness);
   void setOutputSparse(bool Sparse);
diff --git a/linux-x64/clang/include/llvm/ProfileData/ProfileCommon.h b/linux-x64/clang/include/llvm/ProfileData/ProfileCommon.h
index f98a343..6bb5825 100644
--- a/linux-x64/clang/include/llvm/ProfileData/ProfileCommon.h
+++ b/linux-x64/clang/include/llvm/ProfileData/ProfileCommon.h
@@ -33,8 +33,8 @@
 
 } // end namespace sampleprof
 
-inline const char *getHotSectionPrefix() { return ".hot"; }
-inline const char *getUnlikelySectionPrefix() { return ".unlikely"; }
+inline const char *getHotSectionPrefix() { return "hot"; }
+inline const char *getUnlikelySectionPrefix() { return "unlikely"; }
 
 class ProfileSummaryBuilder {
 private:
@@ -62,6 +62,10 @@
 public:
   /// A vector of useful cutoff values for detailed summary.
   static const ArrayRef<uint32_t> DefaultCutoffs;
+
+  /// Find the summary entry for a desired percentile of counts.
+  static const ProfileSummaryEntry &
+  getEntryForPercentile(SummaryEntryVector &DS, uint64_t Percentile);
 };
 
 class InstrProfSummaryBuilder final : public ProfileSummaryBuilder {
diff --git a/linux-x64/clang/include/llvm/ProfileData/SampleProf.h b/linux-x64/clang/include/llvm/ProfileData/SampleProf.h
index 7fbc857..c423466 100644
--- a/linux-x64/clang/include/llvm/ProfileData/SampleProf.h
+++ b/linux-x64/clang/include/llvm/ProfileData/SampleProf.h
@@ -18,23 +18,25 @@
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/StringSet.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/GlobalValue.h"
 #include "llvm/IR/Module.h"
+#include "llvm/Support/Allocator.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/MathExtras.h"
+#include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cstdint>
 #include <map>
+#include <set>
 #include <string>
 #include <system_error>
 #include <utility>
 
 namespace llvm {
 
-class raw_ostream;
-
 const std::error_category &sampleprof_category();
 
 enum class sampleprof_error {
@@ -49,7 +51,11 @@
   truncated_name_table,
   not_implemented,
   counter_overflow,
-  ostream_seek_unsupported
+  ostream_seek_unsupported,
+  compress_failed,
+  uncompress_failed,
+  zlib_unavailable,
+  hash_mismatch
 };
 
 inline std::error_code make_error_code(sampleprof_error E) {
@@ -83,6 +89,7 @@
   SPF_Text = 0x1,
   SPF_Compact_Binary = 0x2,
   SPF_GCC = 0x3,
+  SPF_Ext_Binary = 0x4,
   SPF_Binary = 0xff
 };
 
@@ -93,18 +100,146 @@
          uint64_t('2') << (64 - 56) | uint64_t(Format);
 }
 
-// Get the proper representation of a string in the input Format.
-static inline StringRef getRepInFormat(StringRef Name,
-                                       SampleProfileFormat Format,
+/// Get the proper representation of a string according to whether the
+/// current Format uses MD5 to represent the string.
+static inline StringRef getRepInFormat(StringRef Name, bool UseMD5,
                                        std::string &GUIDBuf) {
   if (Name.empty())
     return Name;
   GUIDBuf = std::to_string(Function::getGUID(Name));
-  return (Format == SPF_Compact_Binary) ? StringRef(GUIDBuf) : Name;
+  return UseMD5 ? StringRef(GUIDBuf) : Name;
 }
 
 static inline uint64_t SPVersion() { return 103; }
 
+// Section Type used by SampleProfileExtBinaryBaseReader and
+// SampleProfileExtBinaryBaseWriter. Never change the existing
+// value of enum. Only append new ones.
+enum SecType {
+  SecInValid = 0,
+  SecProfSummary = 1,
+  SecNameTable = 2,
+  SecProfileSymbolList = 3,
+  SecFuncOffsetTable = 4,
+  SecFuncMetadata = 5,
+  // marker for the first type of profile.
+  SecFuncProfileFirst = 32,
+  SecLBRProfile = SecFuncProfileFirst
+};
+
+static inline std::string getSecName(SecType Type) {
+  switch (Type) {
+  case SecInValid:
+    return "InvalidSection";
+  case SecProfSummary:
+    return "ProfileSummarySection";
+  case SecNameTable:
+    return "NameTableSection";
+  case SecProfileSymbolList:
+    return "ProfileSymbolListSection";
+  case SecFuncOffsetTable:
+    return "FuncOffsetTableSection";
+  case SecFuncMetadata:
+    return "FunctionMetadata";
+  case SecLBRProfile:
+    return "LBRProfileSection";
+  }
+  llvm_unreachable("A SecType has no name for output");
+}
+
+// Entry type of section header table used by SampleProfileExtBinaryBaseReader
+// and SampleProfileExtBinaryBaseWriter.
+struct SecHdrTableEntry {
+  SecType Type;
+  uint64_t Flags;
+  uint64_t Offset;
+  uint64_t Size;
+  // The index indicating the location of the current entry in
+  // SectionHdrLayout table.
+  uint32_t LayoutIndex;
+};
+
+// Flags common for all sections are defined here. In SecHdrTableEntry::Flags,
+// common flags will be saved in the lower 32bits and section specific flags
+// will be saved in the higher 32 bits.
+enum class SecCommonFlags : uint32_t {
+  SecFlagInValid = 0,
+  SecFlagCompress = (1 << 0)
+};
+
+// Section specific flags are defined here.
+// !!!Note: Everytime a new enum class is created here, please add
+// a new check in verifySecFlag.
+enum class SecNameTableFlags : uint32_t {
+  SecFlagInValid = 0,
+  SecFlagMD5Name = (1 << 0),
+  // Store MD5 in fixed length instead of ULEB128 so NameTable can be
+  // accessed like an array.
+  SecFlagFixedLengthMD5 = (1 << 1)
+};
+enum class SecProfSummaryFlags : uint32_t {
+  SecFlagInValid = 0,
+  /// SecFlagPartial means the profile is for common/shared code.
+  /// The common profile is usually merged from profiles collected
+  /// from running other targets.
+  SecFlagPartial = (1 << 0)
+};
+
+enum class SecFuncMetadataFlags : uint32_t {
+  SecFlagInvalid = 0,
+  SecFlagIsProbeBased = (1 << 0),
+};
+
+// Verify section specific flag is used for the correct section.
+template <class SecFlagType>
+static inline void verifySecFlag(SecType Type, SecFlagType Flag) {
+  // No verification is needed for common flags.
+  if (std::is_same<SecCommonFlags, SecFlagType>())
+    return;
+
+  // Verification starts here for section specific flag.
+  bool IsFlagLegal = false;
+  switch (Type) {
+  case SecNameTable:
+    IsFlagLegal = std::is_same<SecNameTableFlags, SecFlagType>();
+    break;
+  case SecProfSummary:
+    IsFlagLegal = std::is_same<SecProfSummaryFlags, SecFlagType>();
+    break;
+  case SecFuncMetadata:
+    IsFlagLegal = std::is_same<SecFuncMetadataFlags, SecFlagType>();
+    break;
+  default:
+    break;
+  }
+  if (!IsFlagLegal)
+    llvm_unreachable("Misuse of a flag in an incompatible section");
+}
+
+template <class SecFlagType>
+static inline void addSecFlag(SecHdrTableEntry &Entry, SecFlagType Flag) {
+  verifySecFlag(Entry.Type, Flag);
+  auto FVal = static_cast<uint64_t>(Flag);
+  bool IsCommon = std::is_same<SecCommonFlags, SecFlagType>();
+  Entry.Flags |= IsCommon ? FVal : (FVal << 32);
+}
+
+template <class SecFlagType>
+static inline void removeSecFlag(SecHdrTableEntry &Entry, SecFlagType Flag) {
+  verifySecFlag(Entry.Type, Flag);
+  auto FVal = static_cast<uint64_t>(Flag);
+  bool IsCommon = std::is_same<SecCommonFlags, SecFlagType>();
+  Entry.Flags &= ~(IsCommon ? FVal : (FVal << 32));
+}
+
+template <class SecFlagType>
+static inline bool hasSecFlag(const SecHdrTableEntry &Entry, SecFlagType Flag) {
+  verifySecFlag(Entry.Type, Flag);
+  auto FVal = static_cast<uint64_t>(Flag);
+  bool IsCommon = std::is_same<SecCommonFlags, SecFlagType>();
+  return Entry.Flags & (IsCommon ? FVal : (FVal << 32));
+}
+
 /// Represents the relative location of an instruction.
 ///
 /// Instruction locations are specified by the line offset from the
@@ -125,6 +260,14 @@
            (LineOffset == O.LineOffset && Discriminator < O.Discriminator);
   }
 
+  bool operator==(const LineLocation &O) const {
+    return LineOffset == O.LineOffset && Discriminator == O.Discriminator;
+  }
+
+  bool operator!=(const LineLocation &O) const {
+    return LineOffset != O.LineOffset || Discriminator != O.Discriminator;
+  }
+
   uint32_t LineOffset;
   uint32_t Discriminator;
 };
@@ -143,8 +286,18 @@
 /// will be a list of one or more functions.
 class SampleRecord {
 public:
-  using CallTargetMap = StringMap<uint64_t>;
+  using CallTarget = std::pair<StringRef, uint64_t>;
+  struct CallTargetComparator {
+    bool operator()(const CallTarget &LHS, const CallTarget &RHS) const {
+      if (LHS.second != RHS.second)
+        return LHS.second > RHS.second;
 
+      return LHS.first < RHS.first;
+    }
+  };
+
+  using SortedCallTargetSet = std::set<CallTarget, CallTargetComparator>;
+  using CallTargetMap = StringMap<uint64_t>;
   SampleRecord() = default;
 
   /// Increment the number of samples for this record by \p S.
@@ -179,6 +332,18 @@
 
   uint64_t getSamples() const { return NumSamples; }
   const CallTargetMap &getCallTargets() const { return CallTargets; }
+  const SortedCallTargetSet getSortedCallTargets() const {
+    return SortCallTargets(CallTargets);
+  }
+
+  /// Sort call targets in descending order of call frequency.
+  static const SortedCallTargetSet SortCallTargets(const CallTargetMap &Targets) {
+    SortedCallTargetSet SortedTargets;
+    for (const auto &I : Targets) {
+      SortedTargets.emplace(I.first(), I.second);
+    }
+    return SortedTargets;
+  }
 
   /// Merge the samples in \p Other into this record.
   /// Optionally scale sample counts by \p Weight.
@@ -200,12 +365,136 @@
 
 raw_ostream &operator<<(raw_ostream &OS, const SampleRecord &Sample);
 
+// State of context associated with FunctionSamples
+enum ContextStateMask {
+  UnknownContext = 0x0,   // Profile without context
+  RawContext = 0x1,       // Full context profile from input profile
+  SyntheticContext = 0x2, // Synthetic context created for context promotion
+  InlinedContext = 0x4,   // Profile for context that is inlined into caller
+  MergedContext = 0x8     // Profile for context merged into base profile
+};
+
+// Sample context for FunctionSamples. It consists of the calling context,
+// the function name and context state. Internally sample context is represented
+// using StringRef, which is also the input for constructing a `SampleContext`.
+// It can accept and represent both full context string as well as context-less
+// function name.
+// Example of full context string (note the wrapping `[]`):
+//    `[main:3 @ _Z5funcAi:1 @ _Z8funcLeafi]`
+// Example of context-less function name (same as AutoFDO):
+//    `_Z8funcLeafi`
+class SampleContext {
+public:
+  SampleContext() : State(UnknownContext) {}
+  SampleContext(StringRef ContextStr,
+                ContextStateMask CState = UnknownContext) {
+    setContext(ContextStr, CState);
+  }
+
+  // Promote context by removing top frames (represented by `ContextStrToRemove`).
+  // Note that with string representation of context, the promotion is effectively
+  // a substr operation with `ContextStrToRemove` removed from left.
+  void promoteOnPath(StringRef ContextStrToRemove) {
+    assert(FullContext.startswith(ContextStrToRemove));
+
+    // Remove leading context and frame separator " @ ".
+    FullContext = FullContext.substr(ContextStrToRemove.size() + 3);
+    CallingContext = CallingContext.substr(ContextStrToRemove.size() + 3);
+  }
+
+  // Split the top context frame (left-most substr) from context.
+  static std::pair<StringRef, StringRef>
+  splitContextString(StringRef ContextStr) {
+    return ContextStr.split(" @ ");
+  }
+
+  // Decode context string for a frame to get function name and location.
+  // `ContextStr` is in the form of `FuncName:StartLine.Discriminator`.
+  static void decodeContextString(StringRef ContextStr, StringRef &FName,
+                                  LineLocation &LineLoc) {
+    // Get function name
+    auto EntrySplit = ContextStr.split(':');
+    FName = EntrySplit.first;
+
+    LineLoc = {0, 0};
+    if (!EntrySplit.second.empty()) {
+      // Get line offset, use signed int for getAsInteger so string will
+      // be parsed as signed.
+      int LineOffset = 0;
+      auto LocSplit = EntrySplit.second.split('.');
+      LocSplit.first.getAsInteger(10, LineOffset);
+      LineLoc.LineOffset = LineOffset;
+
+      // Get discriminator
+      if (!LocSplit.second.empty())
+        LocSplit.second.getAsInteger(10, LineLoc.Discriminator);
+    }
+  }
+
+  operator StringRef() const { return FullContext; }
+  bool hasState(ContextStateMask S) { return State & (uint32_t)S; }
+  void setState(ContextStateMask S) { State |= (uint32_t)S; }
+  void clearState(ContextStateMask S) { State &= (uint32_t)~S; }
+  bool hasContext() const { return State != UnknownContext; }
+  bool isBaseContext() const { return CallingContext.empty(); }
+  StringRef getName() const { return Name; }
+  StringRef getCallingContext() const { return CallingContext; }
+  StringRef getNameWithContext() const { return FullContext; }
+
+private:
+  // Give a context string, decode and populate internal states like
+  // Function name, Calling context and context state. Example of input
+  // `ContextStr`: `[main:3 @ _Z5funcAi:1 @ _Z8funcLeafi]`
+  void setContext(StringRef ContextStr, ContextStateMask CState) {
+    assert(!ContextStr.empty());
+    // Note that `[]` wrapped input indicates a full context string, otherwise
+    // it's treated as context-less function name only.
+    bool HasContext = ContextStr.startswith("[");
+    if (!HasContext && CState == UnknownContext) {
+      State = UnknownContext;
+      Name = FullContext = ContextStr;
+    } else {
+      // Assume raw context profile if unspecified
+      if (CState == UnknownContext)
+        State = RawContext;
+      else
+        State = CState;
+
+      // Remove encapsulating '[' and ']' if any
+      if (HasContext)
+        FullContext = ContextStr.substr(1, ContextStr.size() - 2);
+      else
+        FullContext = ContextStr;
+
+      // Caller is to the left of callee in context string
+      auto NameContext = FullContext.rsplit(" @ ");
+      if (NameContext.second.empty()) {
+        Name = NameContext.first;
+        CallingContext = NameContext.second;
+      } else {
+        Name = NameContext.second;
+        CallingContext = NameContext.first;
+      }
+    }
+  }
+
+  // Full context string including calling context and leaf function name
+  StringRef FullContext;
+  // Function name for the associated sample profile
+  StringRef Name;
+  // Calling context (leaf function excluded) for the associated sample profile
+  StringRef CallingContext;
+  // State of the associated sample profile
+  uint32_t State;
+};
+
 class FunctionSamples;
+class SampleProfileReaderItaniumRemapper;
 
 using BodySampleMap = std::map<LineLocation, SampleRecord>;
 // NOTE: Using a StringMap here makes parsed profiles consume around 17% more
 // memory, which is *very* significant for large profiles.
-using FunctionSamplesMap = std::map<std::string, FunctionSamples>;
+using FunctionSamplesMap = std::map<std::string, FunctionSamples, std::less<>>;
 using CallsiteSampleMap = std::map<LineLocation, FunctionSamplesMap>;
 
 /// Representation of the samples collected for a function.
@@ -228,6 +517,8 @@
                       : sampleprof_error::success;
   }
 
+  void setTotalSamples(uint64_t Num) { TotalSamples = Num; }
+
   sampleprof_error addHeadSamples(uint64_t Num, uint64_t Weight = 1) {
     bool Overflowed;
     TotalHeadSamples =
@@ -256,10 +547,22 @@
   ErrorOr<uint64_t> findSamplesAt(uint32_t LineOffset,
                                   uint32_t Discriminator) const {
     const auto &ret = BodySamples.find(LineLocation(LineOffset, Discriminator));
-    if (ret == BodySamples.end())
+    if (ret == BodySamples.end()) {
+      // For CSSPGO, in order to conserve profile size, we no longer write out
+      // locations profile for those not hit during training, so we need to
+      // treat them as zero instead of error here.
+      if (ProfileIsCS)
+        return 0;
       return std::error_code();
-    else
+      // A missing counter for a probe likely means the probe was not executed.
+      // Treat it as a zero count instead of an unknown count to help edge
+      // weight inference.
+      if (FunctionSamples::ProfileIsProbeBased)
+        return 0;
+      return std::error_code();
+    } else {
       return ret->second.getSamples();
+    }
   }
 
   /// Returns the call target map collected at a given location.
@@ -273,6 +576,16 @@
     return ret->second.getCallTargets();
   }
 
+  /// Returns the call target map collected at a given location specified by \p
+  /// CallSite. If the location is not found in profile, return error.
+  ErrorOr<SampleRecord::CallTargetMap>
+  findCallTargetMapAt(const LineLocation &CallSite) const {
+    const auto &Ret = BodySamples.find(CallSite);
+    if (Ret == BodySamples.end())
+      return std::error_code();
+    return Ret->second.getCallTargets();
+  }
+
   /// Return the function samples at the given callsite location.
   FunctionSamplesMap &functionSamplesAt(const LineLocation &Loc) {
     return CallsiteSamples[Loc];
@@ -287,32 +600,15 @@
     return &iter->second;
   }
 
-  /// Returns a pointer to FunctionSamples at the given callsite location \p Loc
-  /// with callee \p CalleeName. If no callsite can be found, relax the
-  /// restriction to return the FunctionSamples at callsite location \p Loc
-  /// with the maximum total sample count.
-  const FunctionSamples *findFunctionSamplesAt(const LineLocation &Loc,
-                                               StringRef CalleeName) const {
-    std::string CalleeGUID;
-    CalleeName = getRepInFormat(CalleeName, Format, CalleeGUID);
-
-    auto iter = CallsiteSamples.find(Loc);
-    if (iter == CallsiteSamples.end())
-      return nullptr;
-    auto FS = iter->second.find(CalleeName);
-    if (FS != iter->second.end())
-      return &FS->second;
-    // If we cannot find exact match of the callee name, return the FS with
-    // the max total count.
-    uint64_t MaxTotalSamples = 0;
-    const FunctionSamples *R = nullptr;
-    for (const auto &NameFS : iter->second)
-      if (NameFS.second.getTotalSamples() >= MaxTotalSamples) {
-        MaxTotalSamples = NameFS.second.getTotalSamples();
-        R = &NameFS.second;
-      }
-    return R;
-  }
+  /// Returns a pointer to FunctionSamples at the given callsite location
+  /// \p Loc with callee \p CalleeName. If no callsite can be found, relax
+  /// the restriction to return the FunctionSamples at callsite location
+  /// \p Loc with the maximum total sample count. If \p Remapper is not
+  /// nullptr, use \p Remapper to find FunctionSamples with equivalent name
+  /// as \p CalleeName.
+  const FunctionSamples *
+  findFunctionSamplesAt(const LineLocation &Loc, StringRef CalleeName,
+                        SampleProfileReaderItaniumRemapper *Remapper) const;
 
   bool empty() const { return TotalSamples == 0; }
 
@@ -329,21 +625,26 @@
   /// Return the sample count of the first instruction of the function.
   /// The function can be either a standalone symbol or an inlined function.
   uint64_t getEntrySamples() const {
+    if (FunctionSamples::ProfileIsCS && getHeadSamples()) {
+      // For CS profile, if we already have more accurate head samples
+      // counted by branch sample from caller, use them as entry samples.
+      return getHeadSamples();
+    }
+    uint64_t Count = 0;
     // Use either BodySamples or CallsiteSamples which ever has the smaller
     // lineno.
     if (!BodySamples.empty() &&
         (CallsiteSamples.empty() ||
          BodySamples.begin()->first < CallsiteSamples.begin()->first))
-      return BodySamples.begin()->second.getSamples();
-    if (!CallsiteSamples.empty()) {
-      uint64_t T = 0;
+      Count = BodySamples.begin()->second.getSamples();
+    else if (!CallsiteSamples.empty()) {
       // An indirect callsite may be promoted to several inlined direct calls.
       // We need to get the sum of them.
       for (const auto &N_FS : CallsiteSamples.begin()->second)
-        T += N_FS.second.getEntrySamples();
-      return T;
+        Count += N_FS.second.getEntrySamples();
     }
-    return 0;
+    // Return at least 1 if total sample is not 0.
+    return Count ? Count : TotalSamples > 0;
   }
 
   /// Return all the samples collected in the body of the function.
@@ -354,11 +655,40 @@
     return CallsiteSamples;
   }
 
+  /// Return the maximum of sample counts in a function body including functions
+  /// inlined in it.
+  uint64_t getMaxCountInside() const {
+    uint64_t MaxCount = 0;
+    for (const auto &L : getBodySamples())
+      MaxCount = std::max(MaxCount, L.second.getSamples());
+    for (const auto &C : getCallsiteSamples())
+      for (const FunctionSamplesMap::value_type &F : C.second)
+        MaxCount = std::max(MaxCount, F.second.getMaxCountInside());
+    return MaxCount;
+  }
+
   /// Merge the samples in \p Other into this one.
   /// Optionally scale samples by \p Weight.
   sampleprof_error merge(const FunctionSamples &Other, uint64_t Weight = 1) {
     sampleprof_error Result = sampleprof_error::success;
     Name = Other.getName();
+    if (!GUIDToFuncNameMap)
+      GUIDToFuncNameMap = Other.GUIDToFuncNameMap;
+
+    if (FunctionHash == 0) {
+      // Set the function hash code for the target profile.
+      FunctionHash = Other.getFunctionHash();
+    } else if (FunctionHash != Other.getFunctionHash()) {
+      // The two profiles coming with different valid hash codes indicates
+      // either:
+      // 1. They are same-named static functions from different compilation
+      // units (without using -unique-internal-linkage-names), or
+      // 2. They are really the same function but from different compilations.
+      // Let's bail out in either case for now, which means one profile is
+      // dropped.
+      return sampleprof_error::hash_mismatch;
+    }
+
     MergeResult(Result, addTotalSamples(Other.getTotalSamples(), Weight));
     MergeResult(Result, addHeadSamples(Other.getHeadSamples(), Weight));
     for (const auto &I : Other.getBodySamples()) {
@@ -383,15 +713,20 @@
                             uint64_t Threshold) const {
     if (TotalSamples <= Threshold)
       return;
-    S.insert(getGUID(Name));
+    auto isDeclaration = [](const Function *F) {
+      return !F || F->isDeclaration();
+    };
+    if (isDeclaration(M->getFunction(getFuncName()))) {
+      // Add to the import list only when it's defined out of module.
+      S.insert(getGUID(Name));
+    }
     // Import hot CallTargets, which may not be available in IR because full
     // profile annotation cannot be done until backend compilation in ThinLTO.
     for (const auto &BS : BodySamples)
       for (const auto &TS : BS.second.getCallTargets())
         if (TS.getValue() > Threshold) {
-          const Function *Callee =
-              M->getFunction(getNameInModule(TS.getKey(), M));
-          if (!Callee || !Callee->getSubprogram())
+          const Function *Callee = M->getFunction(getFuncName(TS.getKey()));
+          if (isDeclaration(Callee))
             S.insert(getGUID(TS.getKey()));
         }
     for (const auto &CS : CallsiteSamples)
@@ -405,21 +740,32 @@
   /// Return the function name.
   StringRef getName() const { return Name; }
 
-  /// Return the original function name if it exists in Module \p M.
-  StringRef getFuncNameInModule(const Module *M) const {
-    return getNameInModule(Name, M);
+  /// Return function name with context.
+  StringRef getNameWithContext() const {
+    return FunctionSamples::ProfileIsCS ? Context.getNameWithContext() : Name;
   }
 
+  /// Return the original function name.
+  StringRef getFuncName() const { return getFuncName(Name); }
+
+  void setFunctionHash(uint64_t Hash) { FunctionHash = Hash; }
+
+  uint64_t getFunctionHash() const { return FunctionHash; }
+
   /// Return the canonical name for a function, taking into account
   /// suffix elision policy attributes.
   static StringRef getCanonicalFnName(const Function &F) {
-    static const char *knownSuffixes[] = { ".llvm.", ".part." };
     auto AttrName = "sample-profile-suffix-elision-policy";
     auto Attr = F.getFnAttribute(AttrName).getValueAsString();
+    return getCanonicalFnName(F.getName(), Attr);
+  }
+
+  static StringRef getCanonicalFnName(StringRef FnName, StringRef Attr = "") {
+    static const char *knownSuffixes[] = { ".llvm.", ".part." };
     if (Attr == "" || Attr == "all") {
-      return F.getName().split('.').first;
+      return FnName.split('.').first;
     } else if (Attr == "selected") {
-      StringRef Cand(F.getName());
+      StringRef Cand(FnName);
       for (const auto &Suf : knownSuffixes) {
         StringRef Suffix(Suf);
         auto It = Cand.rfind(Suffix);
@@ -431,35 +777,38 @@
       }
       return Cand;
     } else if (Attr == "none") {
-      return F.getName();
+      return FnName;
     } else {
       assert(false && "internal error: unknown suffix elision policy");
     }
-    return F.getName();
+    return FnName;
   }
 
-  /// Translate \p Name into its original name in Module.
-  /// When the Format is not SPF_Compact_Binary, \p Name needs no translation.
-  /// When the Format is SPF_Compact_Binary, \p Name in current FunctionSamples
-  /// is actually GUID of the original function name. getNameInModule will
-  /// translate \p Name in current FunctionSamples into its original name.
-  /// If the original name doesn't exist in \p M, return empty StringRef.
-  StringRef getNameInModule(StringRef Name, const Module *M) const {
-    if (Format != SPF_Compact_Binary)
+  /// Translate \p Name into its original name.
+  /// When profile doesn't use MD5, \p Name needs no translation.
+  /// When profile uses MD5, \p Name in current FunctionSamples
+  /// is actually GUID of the original function name. getFuncName will
+  /// translate \p Name in current FunctionSamples into its original name
+  /// by looking up in the function map GUIDToFuncNameMap.
+  /// If the original name doesn't exist in the map, return empty StringRef.
+  StringRef getFuncName(StringRef Name) const {
+    if (!UseMD5)
       return Name;
-    // Expect CurrentModule to be initialized by GUIDToFuncNameMapper.
-    if (M != CurrentModule)
-      llvm_unreachable("Input Module should be the same as CurrentModule");
-    auto iter = GUIDToFuncNameMap.find(std::stoull(Name.data()));
-    if (iter == GUIDToFuncNameMap.end())
-      return StringRef();
-    return iter->second;
+
+    assert(GUIDToFuncNameMap && "GUIDToFuncNameMap needs to be popluated first");
+    return GUIDToFuncNameMap->lookup(std::stoull(Name.data()));
   }
 
   /// Returns the line offset to the start line of the subprogram.
   /// We assume that a single function will not exceed 65535 LOC.
   static unsigned getOffset(const DILocation *DIL);
 
+  /// Returns a unique call site identifier for a given debug location of a call
+  /// instruction. This is wrapper of two scenarios, the probe-based profile and
+  /// regular profile, to hide implementation details from the sample loader and
+  /// the context tracker.
+  static LineLocation getCallSiteIdentifier(const DILocation *DIL);
+
   /// Get the FunctionSamples of the inline instance where DIL originates
   /// from.
   ///
@@ -469,58 +818,50 @@
   /// tree nodes in the profile.
   ///
   /// \returns the FunctionSamples pointer to the inlined instance.
-  const FunctionSamples *findFunctionSamples(const DILocation *DIL) const;
+  /// If \p Remapper is not nullptr, it will be used to find matching
+  /// FunctionSamples with not exactly the same but equivalent name.
+  const FunctionSamples *findFunctionSamples(
+      const DILocation *DIL,
+      SampleProfileReaderItaniumRemapper *Remapper = nullptr) const;
+
+  static bool ProfileIsProbeBased;
+
+  static bool ProfileIsCS;
+
+  SampleContext &getContext() const { return Context; }
+
+  void setContext(const SampleContext &FContext) { Context = FContext; }
 
   static SampleProfileFormat Format;
+
+  /// Whether the profile uses MD5 to represent string.
+  static bool UseMD5;
+
   /// GUIDToFuncNameMap saves the mapping from GUID to the symbol name, for
-  /// all the function symbols defined or declared in CurrentModule.
-  static DenseMap<uint64_t, StringRef> GUIDToFuncNameMap;
-  static Module *CurrentModule;
-
-  class GUIDToFuncNameMapper {
-  public:
-    GUIDToFuncNameMapper(Module &M) {
-      if (Format != SPF_Compact_Binary)
-        return;
-
-      for (const auto &F : M) {
-        StringRef OrigName = F.getName();
-        GUIDToFuncNameMap.insert({Function::getGUID(OrigName), OrigName});
-        /// Local to global var promotion used by optimization like thinlto
-        /// will rename the var and add suffix like ".llvm.xxx" to the
-        /// original local name. In sample profile, the suffixes of function
-        /// names are all stripped. Since it is possible that the mapper is
-        /// built in post-thin-link phase and var promotion has been done,
-        /// we need to add the substring of function name without the suffix
-        /// into the GUIDToFuncNameMap.
-        StringRef CanonName = getCanonicalFnName(F);
-        if (CanonName != OrigName)
-          GUIDToFuncNameMap.insert({Function::getGUID(CanonName), CanonName});
-      }
-      CurrentModule = &M;
-    }
-
-    ~GUIDToFuncNameMapper() {
-      if (Format != SPF_Compact_Binary)
-        return;
-
-      GUIDToFuncNameMap.clear();
-      CurrentModule = nullptr;
-    }
-  };
+  /// all the function symbols defined or declared in current module.
+  DenseMap<uint64_t, StringRef> *GUIDToFuncNameMap = nullptr;
 
   // Assume the input \p Name is a name coming from FunctionSamples itself.
-  // If the format is SPF_Compact_Binary, the name is already a GUID and we
+  // If UseMD5 is true, the name is already a GUID and we
   // don't want to return the GUID of GUID.
   static uint64_t getGUID(StringRef Name) {
-    return (Format == SPF_Compact_Binary) ? std::stoull(Name.data())
-                                          : Function::getGUID(Name);
+    return UseMD5 ? std::stoull(Name.data()) : Function::getGUID(Name);
   }
 
+  // Find all the names in the current FunctionSamples including names in
+  // all the inline instances and names of call targets.
+  void findAllNames(DenseSet<StringRef> &NameSet) const;
+
 private:
   /// Mangled name of the function.
   StringRef Name;
 
+  /// CFG hash value for the function.
+  uint64_t FunctionHash = 0;
+
+  /// Calling context for function profile
+  mutable SampleContext Context;
+
   /// Total number of samples collected inside this function.
   ///
   /// Samples are cumulative, they include all the samples collected
@@ -583,6 +924,47 @@
   SamplesWithLocList V;
 };
 
+/// ProfileSymbolList records the list of function symbols shown up
+/// in the binary used to generate the profile. It is useful to
+/// to discriminate a function being so cold as not to shown up
+/// in the profile and a function newly added.
+class ProfileSymbolList {
+public:
+  /// copy indicates whether we need to copy the underlying memory
+  /// for the input Name.
+  void add(StringRef Name, bool copy = false) {
+    if (!copy) {
+      Syms.insert(Name);
+      return;
+    }
+    Syms.insert(Name.copy(Allocator));
+  }
+
+  bool contains(StringRef Name) { return Syms.count(Name); }
+
+  void merge(const ProfileSymbolList &List) {
+    for (auto Sym : List.Syms)
+      add(Sym, true);
+  }
+
+  unsigned size() { return Syms.size(); }
+
+  void setToCompress(bool TC) { ToCompress = TC; }
+  bool toCompress() { return ToCompress; }
+
+  std::error_code read(const uint8_t *Data, uint64_t ListSize);
+  std::error_code write(raw_ostream &OS);
+  void dump(raw_ostream &OS = dbgs()) const;
+
+private:
+  // Determine whether or not to compress the symbol list when
+  // writing it into profile. The variable is unused when the symbol
+  // list is read from an existing profile.
+  bool ToCompress = false;
+  DenseSet<StringRef> Syms;
+  BumpPtrAllocator Allocator;
+};
+
 } // end namespace sampleprof
 } // end namespace llvm
 
diff --git a/linux-x64/clang/include/llvm/ProfileData/SampleProfReader.h b/linux-x64/clang/include/llvm/ProfileData/SampleProfReader.h
index 969cdea..92fe825 100644
--- a/linux-x64/clang/include/llvm/ProfileData/SampleProfReader.h
+++ b/linux-x64/clang/include/llvm/ProfileData/SampleProfReader.h
@@ -27,8 +27,9 @@
 //      offsetA[.discriminator]: fnA:num_of_total_samples
 //       offsetA1[.discriminator]: number_of_samples [fn7:num fn8:num ... ]
 //       ...
+//      !CFGChecksum: num
 //
-// This is a nested tree in which the identation represents the nesting level
+// This is a nested tree in which the indentation represents the nesting level
 // of the inline stack. There are no blank lines in the file. And the spacing
 // within a single line is fixed. Additional spaces will result in an error
 // while reading the file.
@@ -47,10 +48,11 @@
 // in the prologue of the function (second number). This head sample
 // count provides an indicator of how frequently the function is invoked.
 //
-// There are two types of lines in the function body.
+// There are three types of lines in the function body.
 //
 // * Sampled line represents the profile information of a source location.
 // * Callsite line represents the profile information of a callsite.
+// * Metadata line represents extra metadata of the function.
 //
 // Each sampled line may contain several items. Some are optional (marked
 // below):
@@ -114,6 +116,18 @@
 //    total number of samples collected for the inlined instance at this
 //    callsite
 //
+// Metadata line can occur in lines with one indent only, containing extra
+// information for the top-level function. Furthermore, metadata can only
+// occur after all the body samples and callsite samples.
+// Each metadata line may contain a particular type of metadata, marked by
+// the starting characters annotated with !. We process each metadata line
+// independently, hence each metadata line has to form an independent piece
+// of information that does not require cross-line reference.
+// We support the following types of metadata:
+//
+// a. CFG Checksum (a.k.a. function hash):
+//   !CFGChecksum: 12345
+//
 //
 // Binary format
 // -------------
@@ -208,10 +222,10 @@
 #ifndef LLVM_PROFILEDATA_SAMPLEPROFREADER_H
 #define LLVM_PROFILEDATA_SAMPLEPROFREADER_H
 
+#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
-#include "llvm/ADT/Twine.h"
 #include "llvm/IR/DiagnosticInfo.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/LLVMContext.h"
@@ -232,9 +246,69 @@
 namespace llvm {
 
 class raw_ostream;
+class Twine;
 
 namespace sampleprof {
 
+class SampleProfileReader;
+
+/// SampleProfileReaderItaniumRemapper remaps the profile data from a
+/// sample profile data reader, by applying a provided set of equivalences
+/// between components of the symbol names in the profile.
+class SampleProfileReaderItaniumRemapper {
+public:
+  SampleProfileReaderItaniumRemapper(std::unique_ptr<MemoryBuffer> B,
+                                     std::unique_ptr<SymbolRemappingReader> SRR,
+                                     SampleProfileReader &R)
+      : Buffer(std::move(B)), Remappings(std::move(SRR)), Reader(R) {
+    assert(Remappings && "Remappings cannot be nullptr");
+  }
+
+  /// Create a remapper from the given remapping file. The remapper will
+  /// be used for profile read in by Reader.
+  static ErrorOr<std::unique_ptr<SampleProfileReaderItaniumRemapper>>
+  create(const std::string Filename, SampleProfileReader &Reader,
+         LLVMContext &C);
+
+  /// Create a remapper from the given Buffer. The remapper will
+  /// be used for profile read in by Reader.
+  static ErrorOr<std::unique_ptr<SampleProfileReaderItaniumRemapper>>
+  create(std::unique_ptr<MemoryBuffer> &B, SampleProfileReader &Reader,
+         LLVMContext &C);
+
+  /// Apply remappings to the profile read by Reader.
+  void applyRemapping(LLVMContext &Ctx);
+
+  bool hasApplied() { return RemappingApplied; }
+
+  /// Insert function name into remapper.
+  void insert(StringRef FunctionName) { Remappings->insert(FunctionName); }
+
+  /// Query whether there is equivalent in the remapper which has been
+  /// inserted.
+  bool exist(StringRef FunctionName) {
+    return Remappings->lookup(FunctionName);
+  }
+
+  /// Return the equivalent name in the profile for \p FunctionName if
+  /// it exists.
+  Optional<StringRef> lookUpNameInProfile(StringRef FunctionName);
+
+private:
+  // The buffer holding the content read from remapping file.
+  std::unique_ptr<MemoryBuffer> Buffer;
+  std::unique_ptr<SymbolRemappingReader> Remappings;
+  // Map remapping key to the name in the profile. By looking up the
+  // key in the remapper, a given new name can be mapped to the
+  // cannonical name using the NameMap.
+  DenseMap<SymbolRemappingReader::Key, StringRef> NameMap;
+  // The Reader the remapper is servicing.
+  SampleProfileReader &Reader;
+  // Indicate whether remapping has been applied to the profile read
+  // by Reader -- by calling applyRemapping.
+  bool RemappingApplied = false;
+};
+
 /// Sample-based profile reader.
 ///
 /// Each profile contains sample counts for all the functions
@@ -273,13 +347,23 @@
   /// Read and validate the file header.
   virtual std::error_code readHeader() = 0;
 
-  /// Read sample profiles from the associated file.
-  virtual std::error_code read() = 0;
+  /// The interface to read sample profiles from the associated file.
+  std::error_code read() {
+    if (std::error_code EC = readImpl())
+      return EC;
+    if (Remapper)
+      Remapper->applyRemapping(Ctx);
+    FunctionSamples::UseMD5 = useMD5();
+    return sampleprof_error::success;
+  }
+
+  /// The implementaion to read sample profiles from the associated file.
+  virtual std::error_code readImpl() = 0;
 
   /// Print the profile for \p FName on stream \p OS.
   void dumpFunctionProfile(StringRef FName, raw_ostream &OS = dbgs());
 
-  virtual void collectFuncsToUse(const Module &M) {}
+  virtual void collectFuncsFrom(const Module &M) {}
 
   /// Print all the profiles on stream \p OS.
   void dump(raw_ostream &OS = dbgs());
@@ -293,13 +377,30 @@
     return getSamplesFor(CanonName);
   }
 
+  /// Return the samples collected for function \p F, create empty
+  /// FunctionSamples if it doesn't exist.
+  FunctionSamples *getOrCreateSamplesFor(const Function &F) {
+    std::string FGUID;
+    StringRef CanonName = FunctionSamples::getCanonicalFnName(F);
+    CanonName = getRepInFormat(CanonName, useMD5(), FGUID);
+    return &Profiles[CanonName];
+  }
+
   /// Return the samples collected for function \p F.
   virtual FunctionSamples *getSamplesFor(StringRef Fname) {
     std::string FGUID;
-    Fname = getRepInFormat(Fname, getFormat(), FGUID);
+    Fname = getRepInFormat(Fname, useMD5(), FGUID);
     auto It = Profiles.find(Fname);
     if (It != Profiles.end())
       return &It->second;
+
+    if (Remapper) {
+      if (auto NameInProfile = Remapper->lookUpNameInProfile(Fname)) {
+        auto It = Profiles.find(*NameInProfile);
+        if (It != Profiles.end())
+          return &It->second;
+      }
+    }
     return nullptr;
   }
 
@@ -307,24 +408,50 @@
   StringMap<FunctionSamples> &getProfiles() { return Profiles; }
 
   /// Report a parse error message.
-  void reportError(int64_t LineNumber, Twine Msg) const {
+  void reportError(int64_t LineNumber, const Twine &Msg) const {
     Ctx.diagnose(DiagnosticInfoSampleProfile(Buffer->getBufferIdentifier(),
                                              LineNumber, Msg));
   }
 
   /// Create a sample profile reader appropriate to the file format.
+  /// Create a remapper underlying if RemapFilename is not empty.
   static ErrorOr<std::unique_ptr<SampleProfileReader>>
-  create(const Twine &Filename, LLVMContext &C);
+  create(const std::string Filename, LLVMContext &C,
+         const std::string RemapFilename = "");
 
   /// Create a sample profile reader from the supplied memory buffer.
+  /// Create a remapper underlying if RemapFilename is not empty.
   static ErrorOr<std::unique_ptr<SampleProfileReader>>
-  create(std::unique_ptr<MemoryBuffer> &B, LLVMContext &C);
+  create(std::unique_ptr<MemoryBuffer> &B, LLVMContext &C,
+         const std::string RemapFilename = "");
 
   /// Return the profile summary.
-  ProfileSummary &getSummary() { return *(Summary.get()); }
+  ProfileSummary &getSummary() const { return *(Summary.get()); }
+
+  MemoryBuffer *getBuffer() const { return Buffer.get(); }
 
   /// \brief Return the profile format.
-  SampleProfileFormat getFormat() { return Format; }
+  SampleProfileFormat getFormat() const { return Format; }
+
+  /// Whether input profile is based on pseudo probes.
+  bool profileIsProbeBased() const { return ProfileIsProbeBased; }
+
+  /// Whether input profile is fully context-sensitive
+  bool profileIsCS() const { return ProfileIsCS; }
+
+  virtual std::unique_ptr<ProfileSymbolList> getProfileSymbolList() {
+    return nullptr;
+  };
+
+  /// It includes all the names that have samples either in outline instance
+  /// or inline instance.
+  virtual std::vector<StringRef> *getNameTable() { return nullptr; }
+  virtual bool dumpSectionInfo(raw_ostream &OS = dbgs()) { return false; };
+
+  /// Return whether names in the profile are all MD5 numbers.
+  virtual bool useMD5() { return false; }
+
+  SampleProfileReaderItaniumRemapper *getRemapper() { return Remapper.get(); }
 
 protected:
   /// Map every function to its associated profile.
@@ -352,6 +479,13 @@
   /// Compute summary for this profile.
   void computeSummary();
 
+  std::unique_ptr<SampleProfileReaderItaniumRemapper> Remapper;
+
+  /// \brief Whether samples are collected based on pseudo probes.
+  bool ProfileIsProbeBased = false;
+
+  bool ProfileIsCS = false;
+
   /// \brief The format of sample.
   SampleProfileFormat Format = SPF_None;
 };
@@ -365,7 +499,7 @@
   std::error_code readHeader() override { return sampleprof_error::success; }
 
   /// Read sample profiles from the associated file.
-  std::error_code read() override;
+  std::error_code readImpl() override;
 
   /// Return true if \p Buffer is in the format supported by this class.
   static bool hasFormat(const MemoryBuffer &Buffer);
@@ -381,7 +515,11 @@
   virtual std::error_code readHeader() override;
 
   /// Read sample profiles from the associated file.
-  std::error_code read() override;
+  std::error_code readImpl() override;
+
+  /// It includes all the names that have samples either in outline instance
+  /// or inline instance.
+  virtual std::vector<StringRef> *getNameTable() override { return &NameTable; }
 
 protected:
   /// Read a numeric value of type T from the profile.
@@ -411,43 +549,160 @@
   bool at_eof() const { return Data >= End; }
 
   /// Read the next function profile instance.
-  std::error_code readFuncProfile();
+  std::error_code readFuncProfile(const uint8_t *Start);
 
   /// Read the contents of the given profile instance.
   std::error_code readProfile(FunctionSamples &FProfile);
 
+  /// Read the contents of Magic number and Version number.
+  std::error_code readMagicIdent();
+
+  /// Read profile summary.
+  std::error_code readSummary();
+
+  /// Read the whole name table.
+  virtual std::error_code readNameTable();
+
   /// Points to the current location in the buffer.
   const uint8_t *Data = nullptr;
 
   /// Points to the end of the buffer.
   const uint8_t *End = nullptr;
 
+  /// Function name table.
+  std::vector<StringRef> NameTable;
+
+  /// Read a string indirectly via the name table.
+  virtual ErrorOr<StringRef> readStringFromTable();
+
 private:
   std::error_code readSummaryEntry(std::vector<ProfileSummaryEntry> &Entries);
   virtual std::error_code verifySPMagic(uint64_t Magic) = 0;
-
-  /// Read profile summary.
-  std::error_code readSummary();
-
-  /// Read the whole name table.
-  virtual std::error_code readNameTable() = 0;
-
-  /// Read a string indirectly via the name table.
-  virtual ErrorOr<StringRef> readStringFromTable() = 0;
 };
 
 class SampleProfileReaderRawBinary : public SampleProfileReaderBinary {
 private:
-  /// Function name table.
-  std::vector<StringRef> NameTable;
   virtual std::error_code verifySPMagic(uint64_t Magic) override;
-  virtual std::error_code readNameTable() override;
-  /// Read a string indirectly via the name table.
-  virtual ErrorOr<StringRef> readStringFromTable() override;
 
 public:
-  SampleProfileReaderRawBinary(std::unique_ptr<MemoryBuffer> B, LLVMContext &C)
-      : SampleProfileReaderBinary(std::move(B), C, SPF_Binary) {}
+  SampleProfileReaderRawBinary(std::unique_ptr<MemoryBuffer> B, LLVMContext &C,
+                               SampleProfileFormat Format = SPF_Binary)
+      : SampleProfileReaderBinary(std::move(B), C, Format) {}
+
+  /// \brief Return true if \p Buffer is in the format supported by this class.
+  static bool hasFormat(const MemoryBuffer &Buffer);
+};
+
+/// SampleProfileReaderExtBinaryBase/SampleProfileWriterExtBinaryBase defines
+/// the basic structure of the extensible binary format.
+/// The format is organized in sections except the magic and version number
+/// at the beginning. There is a section table before all the sections, and
+/// each entry in the table describes the entry type, start, size and
+/// attributes. The format in each section is defined by the section itself.
+///
+/// It is easy to add a new section while maintaining the backward
+/// compatibility of the profile. Nothing extra needs to be done. If we want
+/// to extend an existing section, like add cache misses information in
+/// addition to the sample count in the profile body, we can add a new section
+/// with the extension and retire the existing section, and we could choose
+/// to keep the parser of the old section if we want the reader to be able
+/// to read both new and old format profile.
+///
+/// SampleProfileReaderExtBinary/SampleProfileWriterExtBinary define the
+/// commonly used sections of a profile in extensible binary format. It is
+/// possible to define other types of profile inherited from
+/// SampleProfileReaderExtBinaryBase/SampleProfileWriterExtBinaryBase.
+class SampleProfileReaderExtBinaryBase : public SampleProfileReaderBinary {
+private:
+  std::error_code decompressSection(const uint8_t *SecStart,
+                                    const uint64_t SecSize,
+                                    const uint8_t *&DecompressBuf,
+                                    uint64_t &DecompressBufSize);
+
+  BumpPtrAllocator Allocator;
+
+protected:
+  std::vector<SecHdrTableEntry> SecHdrTable;
+  std::error_code readSecHdrTableEntry(uint32_t Idx);
+  std::error_code readSecHdrTable();
+
+  std::error_code readFuncMetadata();
+  std::error_code readFuncOffsetTable();
+  std::error_code readFuncProfiles();
+  std::error_code readMD5NameTable();
+  std::error_code readNameTableSec(bool IsMD5);
+  std::error_code readProfileSymbolList();
+
+  virtual std::error_code readHeader() override;
+  virtual std::error_code verifySPMagic(uint64_t Magic) override = 0;
+  virtual std::error_code readOneSection(const uint8_t *Start, uint64_t Size,
+                                         const SecHdrTableEntry &Entry);
+  // placeholder for subclasses to dispatch their own section readers.
+  virtual std::error_code readCustomSection(const SecHdrTableEntry &Entry) = 0;
+  virtual ErrorOr<StringRef> readStringFromTable() override;
+
+  std::unique_ptr<ProfileSymbolList> ProfSymList;
+
+  /// The table mapping from function name to the offset of its FunctionSample
+  /// towards file start.
+  DenseMap<StringRef, uint64_t> FuncOffsetTable;
+  /// The set containing the functions to use when compiling a module.
+  DenseSet<StringRef> FuncsToUse;
+  /// Use all functions from the input profile.
+  bool UseAllFuncs = true;
+
+  /// Use fixed length MD5 instead of ULEB128 encoding so NameTable doesn't
+  /// need to be read in up front and can be directly accessed using index.
+  bool FixedLengthMD5 = false;
+  /// The starting address of NameTable containing fixed length MD5.
+  const uint8_t *MD5NameMemStart = nullptr;
+
+  /// If MD5 is used in NameTable section, the section saves uint64_t data.
+  /// The uint64_t data has to be converted to a string and then the string
+  /// will be used to initialize StringRef in NameTable.
+  /// Note NameTable contains StringRef so it needs another buffer to own
+  /// the string data. MD5StringBuf serves as the string buffer that is
+  /// referenced by NameTable (vector of StringRef). We make sure
+  /// the lifetime of MD5StringBuf is not shorter than that of NameTable.
+  std::unique_ptr<std::vector<std::string>> MD5StringBuf;
+
+public:
+  SampleProfileReaderExtBinaryBase(std::unique_ptr<MemoryBuffer> B,
+                                   LLVMContext &C, SampleProfileFormat Format)
+      : SampleProfileReaderBinary(std::move(B), C, Format) {}
+
+  /// Read sample profiles in extensible format from the associated file.
+  std::error_code readImpl() override;
+
+  /// Get the total size of all \p Type sections.
+  uint64_t getSectionSize(SecType Type);
+  /// Get the total size of header and all sections.
+  uint64_t getFileSize();
+  virtual bool dumpSectionInfo(raw_ostream &OS = dbgs()) override;
+
+  /// Collect functions with definitions in Module \p M.
+  void collectFuncsFrom(const Module &M) override;
+
+  /// Return whether names in the profile are all MD5 numbers.
+  virtual bool useMD5() override { return MD5StringBuf.get(); }
+
+  virtual std::unique_ptr<ProfileSymbolList> getProfileSymbolList() override {
+    return std::move(ProfSymList);
+  };
+};
+
+class SampleProfileReaderExtBinary : public SampleProfileReaderExtBinaryBase {
+private:
+  virtual std::error_code verifySPMagic(uint64_t Magic) override;
+  virtual std::error_code
+  readCustomSection(const SecHdrTableEntry &Entry) override {
+    return sampleprof_error::success;
+  };
+
+public:
+  SampleProfileReaderExtBinary(std::unique_ptr<MemoryBuffer> B, LLVMContext &C,
+                               SampleProfileFormat Format = SPF_Ext_Binary)
+      : SampleProfileReaderExtBinaryBase(std::move(B), C, Format) {}
 
   /// \brief Return true if \p Buffer is in the format supported by this class.
   static bool hasFormat(const MemoryBuffer &Buffer);
@@ -462,6 +717,8 @@
   DenseMap<StringRef, uint64_t> FuncOffsetTable;
   /// The set containing the functions to use when compiling a module.
   DenseSet<StringRef> FuncsToUse;
+  /// Use all functions from the input profile.
+  bool UseAllFuncs = true;
   virtual std::error_code verifySPMagic(uint64_t Magic) override;
   virtual std::error_code readNameTable() override;
   /// Read a string indirectly via the name table.
@@ -478,10 +735,13 @@
   static bool hasFormat(const MemoryBuffer &Buffer);
 
   /// Read samples only for functions to use.
-  std::error_code read() override;
+  std::error_code readImpl() override;
 
   /// Collect functions to be used when compiling Module \p M.
-  void collectFuncsToUse(const Module &M) override;
+  void collectFuncsFrom(const Module &M) override;
+
+  /// Return whether names in the profile are all MD5 numbers.
+  virtual bool useMD5() override { return true; }
 };
 
 using InlineCallStack = SmallVector<FunctionSamples *, 10>;
@@ -509,7 +769,7 @@
   std::error_code readHeader() override;
 
   /// Read sample profiles from the associated file.
-  std::error_code read() override;
+  std::error_code readImpl() override;
 
   /// Return true if \p Buffer is in the format supported by this class.
   static bool hasFormat(const MemoryBuffer &Buffer);
@@ -537,44 +797,6 @@
   static const uint32_t GCOVTagAFDOFunction = 0xac000000;
 };
 
-/// A profile data reader proxy that remaps the profile data from another
-/// sample profile data reader, by applying a provided set of equivalences
-/// between components of the symbol names in the profile.
-class SampleProfileReaderItaniumRemapper : public SampleProfileReader {
-public:
-  SampleProfileReaderItaniumRemapper(
-      std::unique_ptr<MemoryBuffer> B, LLVMContext &C,
-      std::unique_ptr<SampleProfileReader> Underlying)
-      : SampleProfileReader(std::move(B), C, Underlying->getFormat()) {
-    Profiles = std::move(Underlying->getProfiles());
-    Summary = takeSummary(*Underlying);
-    // Keep the underlying reader alive; the profile data may contain
-    // StringRefs referencing names in its name table.
-    UnderlyingReader = std::move(Underlying);
-  }
-
-  /// Create a remapped sample profile from the given remapping file and
-  /// underlying samples.
-  static ErrorOr<std::unique_ptr<SampleProfileReader>>
-  create(const Twine &Filename, LLVMContext &C,
-         std::unique_ptr<SampleProfileReader> Underlying);
-
-  /// Read and validate the file header.
-  std::error_code readHeader() override { return sampleprof_error::success; }
-
-  /// Read remapping file and apply it to the sample profile.
-  std::error_code read() override;
-
-  /// Return the samples collected for function \p F.
-  FunctionSamples *getSamplesFor(StringRef FunctionName) override;
-  using SampleProfileReader::getSamplesFor;
-
-private:
-  SymbolRemappingReader Remappings;
-  DenseMap<SymbolRemappingReader::Key, FunctionSamples*> SampleMap;
-  std::unique_ptr<SampleProfileReader> UnderlyingReader;
-};
-
 } // end namespace sampleprof
 
 } // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/ProfileData/SampleProfWriter.h b/linux-x64/clang/include/llvm/ProfileData/SampleProfWriter.h
index 81e6e3a..fc568f0 100644
--- a/linux-x64/clang/include/llvm/ProfileData/SampleProfWriter.h
+++ b/linux-x64/clang/include/llvm/ProfileData/SampleProfWriter.h
@@ -36,7 +36,7 @@
   /// Write sample profiles in \p S.
   ///
   /// \returns status code of the file update operation.
-  virtual std::error_code write(const FunctionSamples &S) = 0;
+  virtual std::error_code writeSample(const FunctionSamples &S) = 0;
 
   /// Write all the sample profiles in the given map of samples.
   ///
@@ -56,6 +56,11 @@
   static ErrorOr<std::unique_ptr<SampleProfileWriter>>
   create(std::unique_ptr<raw_ostream> &OS, SampleProfileFormat Format);
 
+  virtual void setProfileSymbolList(ProfileSymbolList *PSL) {}
+  virtual void setToCompressAllSections() {}
+  virtual void setUseMD5() {}
+  virtual void setPartialProfile() {}
+
 protected:
   SampleProfileWriter(std::unique_ptr<raw_ostream> &OS)
       : OutputStream(std::move(OS)) {}
@@ -64,6 +69,10 @@
   virtual std::error_code
   writeHeader(const StringMap<FunctionSamples> &ProfileMap) = 0;
 
+  // Write function profiles to the profile file.
+  virtual std::error_code
+  writeFuncProfiles(const StringMap<FunctionSamples> &ProfileMap);
+
   /// Output stream where to emit the profile to.
   std::unique_ptr<raw_ostream> OutputStream;
 
@@ -72,12 +81,15 @@
 
   /// Compute summary for this profile.
   void computeSummary(const StringMap<FunctionSamples> &ProfileMap);
+
+  /// Profile format.
+  SampleProfileFormat Format = SPF_None;
 };
 
 /// Sample-based profile writer (text format).
 class SampleProfileWriterText : public SampleProfileWriter {
 public:
-  std::error_code write(const FunctionSamples &S) override;
+  std::error_code writeSample(const FunctionSamples &S) override;
 
 protected:
   SampleProfileWriterText(std::unique_ptr<raw_ostream> &OS)
@@ -102,13 +114,14 @@
 /// Sample-based profile writer (binary format).
 class SampleProfileWriterBinary : public SampleProfileWriter {
 public:
-  virtual std::error_code write(const FunctionSamples &S) override;
   SampleProfileWriterBinary(std::unique_ptr<raw_ostream> &OS)
       : SampleProfileWriter(OS) {}
 
+  virtual std::error_code writeSample(const FunctionSamples &S) override;
+
 protected:
-  virtual std::error_code writeNameTable() = 0;
-  virtual std::error_code writeMagicIdent() = 0;
+  virtual std::error_code writeMagicIdent(SampleProfileFormat Format);
+  virtual std::error_code writeNameTable();
   virtual std::error_code
   writeHeader(const StringMap<FunctionSamples> &ProfileMap) override;
   std::error_code writeSummary();
@@ -118,10 +131,10 @@
 
   MapVector<StringRef, uint32_t> NameTable;
 
-private:
   void addName(StringRef FName);
   void addNames(const FunctionSamples &S);
 
+private:
   friend ErrorOr<std::unique_ptr<SampleProfileWriter>>
   SampleProfileWriter::create(std::unique_ptr<raw_ostream> &OS,
                               SampleProfileFormat Format);
@@ -129,10 +142,152 @@
 
 class SampleProfileWriterRawBinary : public SampleProfileWriterBinary {
   using SampleProfileWriterBinary::SampleProfileWriterBinary;
+};
+
+class SampleProfileWriterExtBinaryBase : public SampleProfileWriterBinary {
+  using SampleProfileWriterBinary::SampleProfileWriterBinary;
+public:
+  virtual std::error_code
+  write(const StringMap<FunctionSamples> &ProfileMap) override;
+
+  virtual void setToCompressAllSections() override;
+  void setToCompressSection(SecType Type);
+  virtual std::error_code writeSample(const FunctionSamples &S) override;
+
+  // Set to use MD5 to represent string in NameTable.
+  virtual void setUseMD5() override {
+    UseMD5 = true;
+    addSectionFlag(SecNameTable, SecNameTableFlags::SecFlagMD5Name);
+    // MD5 will be stored as plain uint64_t instead of variable-length
+    // quantity format in NameTable section.
+    addSectionFlag(SecNameTable, SecNameTableFlags::SecFlagFixedLengthMD5);
+  }
+
+  // Set the profile to be partial. It means the profile is for
+  // common/shared code. The common profile is usually merged from
+  // profiles collected from running other targets.
+  virtual void setPartialProfile() override {
+    addSectionFlag(SecProfSummary, SecProfSummaryFlags::SecFlagPartial);
+  }
+
+  virtual void setProfileSymbolList(ProfileSymbolList *PSL) override {
+    ProfSymList = PSL;
+  };
 
 protected:
+  uint64_t markSectionStart(SecType Type, uint32_t LayoutIdx);
+  std::error_code addNewSection(SecType Sec, uint32_t LayoutIdx,
+                                uint64_t SectionStart);
+  template <class SecFlagType>
+  void addSectionFlag(SecType Type, SecFlagType Flag) {
+    for (auto &Entry : SectionHdrLayout) {
+      if (Entry.Type == Type)
+        addSecFlag(Entry, Flag);
+    }
+  }
+
+  // placeholder for subclasses to dispatch their own section writers.
+  virtual std::error_code writeCustomSection(SecType Type) = 0;
+
+  virtual void initSectionHdrLayout() = 0;
+  // specify the order to write sections.
+  virtual std::error_code
+  writeSections(const StringMap<FunctionSamples> &ProfileMap) = 0;
+
+  // Dispatch section writer for each section. \p LayoutIdx is the sequence
+  // number indicating where the section is located in SectionHdrLayout.
+  virtual std::error_code
+  writeOneSection(SecType Type, uint32_t LayoutIdx,
+                  const StringMap<FunctionSamples> &ProfileMap);
+
+  // Helper function to write name table.
   virtual std::error_code writeNameTable() override;
-  virtual std::error_code writeMagicIdent() override;
+
+  std::error_code writeFuncMetadata(const StringMap<FunctionSamples> &Profiles);
+
+  // Functions to write various kinds of sections.
+  std::error_code
+  writeNameTableSection(const StringMap<FunctionSamples> &ProfileMap);
+  std::error_code writeFuncOffsetTable();
+  std::error_code writeProfileSymbolListSection();
+
+  // Specifiy the order of sections in section header table. Note
+  // the order of sections in SecHdrTable may be different that the
+  // order in SectionHdrLayout. sample Reader will follow the order
+  // in SectionHdrLayout to read each section.
+  SmallVector<SecHdrTableEntry, 8> SectionHdrLayout;
+
+  // Save the start of SecLBRProfile so we can compute the offset to the
+  // start of SecLBRProfile for each Function's Profile and will keep it
+  // in FuncOffsetTable.
+  uint64_t SecLBRProfileStart = 0;
+
+private:
+  void allocSecHdrTable();
+  std::error_code writeSecHdrTable();
+  virtual std::error_code
+  writeHeader(const StringMap<FunctionSamples> &ProfileMap) override;
+  std::error_code compressAndOutput();
+
+  // We will swap the raw_ostream held by LocalBufStream and that
+  // held by OutputStream if we try to add a section which needs
+  // compression. After the swap, all the data written to output
+  // will be temporarily buffered into the underlying raw_string_ostream
+  // originally held by LocalBufStream. After the data writing for the
+  // section is completed, compress the data in the local buffer,
+  // swap the raw_ostream back and write the compressed data to the
+  // real output.
+  std::unique_ptr<raw_ostream> LocalBufStream;
+  // The location where the output stream starts.
+  uint64_t FileStart;
+  // The location in the output stream where the SecHdrTable should be
+  // written to.
+  uint64_t SecHdrTableOffset;
+  // The table contains SecHdrTableEntry entries in order of how they are
+  // populated in the writer. It may be different from the order in
+  // SectionHdrLayout which specifies the sequence in which sections will
+  // be read.
+  std::vector<SecHdrTableEntry> SecHdrTable;
+
+  // FuncOffsetTable maps function name to its profile offset in SecLBRProfile
+  // section. It is used to load function profile on demand.
+  MapVector<StringRef, uint64_t> FuncOffsetTable;
+  // Whether to use MD5 to represent string.
+  bool UseMD5 = false;
+
+  ProfileSymbolList *ProfSymList = nullptr;
+};
+
+class SampleProfileWriterExtBinary : public SampleProfileWriterExtBinaryBase {
+public:
+  SampleProfileWriterExtBinary(std::unique_ptr<raw_ostream> &OS)
+      : SampleProfileWriterExtBinaryBase(OS) {
+    initSectionHdrLayout();
+  }
+
+private:
+  virtual void initSectionHdrLayout() override {
+    // Note that SecFuncOffsetTable section is written after SecLBRProfile
+    // in the profile, but is put before SecLBRProfile in SectionHdrLayout.
+    //
+    // This is because sample reader follows the order of SectionHdrLayout to
+    // read each section, to read function profiles on demand sample reader
+    // need to get the offset of each function profile first.
+    //
+    // SecFuncOffsetTable section is written after SecLBRProfile in the
+    // profile because FuncOffsetTable needs to be populated while section
+    // SecLBRProfile is written.
+    SectionHdrLayout = {
+        {SecProfSummary, 0, 0, 0, 0},       {SecNameTable, 0, 0, 0, 0},
+        {SecFuncOffsetTable, 0, 0, 0, 0},   {SecLBRProfile, 0, 0, 0, 0},
+        {SecProfileSymbolList, 0, 0, 0, 0}, {SecFuncMetadata, 0, 0, 0, 0}};
+  };
+  virtual std::error_code
+  writeSections(const StringMap<FunctionSamples> &ProfileMap) override;
+
+  virtual std::error_code writeCustomSection(SecType Type) override {
+    return sampleprof_error::success;
+  };
 };
 
 // CompactBinary is a compact format of binary profile which both reduces
@@ -169,7 +324,7 @@
   using SampleProfileWriterBinary::SampleProfileWriterBinary;
 
 public:
-  virtual std::error_code write(const FunctionSamples &S) override;
+  virtual std::error_code writeSample(const FunctionSamples &S) override;
   virtual std::error_code
   write(const StringMap<FunctionSamples> &ProfileMap) override;
 
@@ -181,7 +336,6 @@
   /// towards profile start.
   uint64_t TableOffset;
   virtual std::error_code writeNameTable() override;
-  virtual std::error_code writeMagicIdent() override;
   virtual std::error_code
   writeHeader(const StringMap<FunctionSamples> &ProfileMap) override;
   std::error_code writeFuncOffsetTable();
diff --git a/linux-x64/clang/include/llvm/Remarks/BitstreamRemarkContainer.h b/linux-x64/clang/include/llvm/Remarks/BitstreamRemarkContainer.h
new file mode 100644
index 0000000..a2282fc
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Remarks/BitstreamRemarkContainer.h
@@ -0,0 +1,106 @@
+//===-- BitstreamRemarkContainer.h - Container for remarks --------------*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file provides declarations for things used in the various types of
+// remark containers.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_REMARKS_REMARK_CONTAINER_H
+#define LLVM_REMARKS_REMARK_CONTAINER_H
+
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Bitstream/BitCodes.h"
+#include <cstdint>
+
+namespace llvm {
+namespace remarks {
+
+/// The current version of the remark container.
+/// Note: this is different from the version of the remark entry.
+constexpr uint64_t CurrentContainerVersion = 0;
+/// The magic number used for identifying remark blocks.
+constexpr StringLiteral ContainerMagic("RMRK");
+
+/// Type of the remark container.
+/// The remark container has two modes:
+/// * separate: the metadata is separate from the remarks and points to the
+///             auxiliary file that contains the remarks.
+/// * standalone: the metadata and the remarks are emitted together.
+enum class BitstreamRemarkContainerType {
+  /// The metadata emitted separately.
+  /// This will contain the following:
+  /// * Container version and type
+  /// * String table
+  /// * External file
+  SeparateRemarksMeta,
+  /// The remarks emitted separately.
+  /// This will contain the following:
+  /// * Container version and type
+  /// * Remark version
+  SeparateRemarksFile,
+  /// Everything is emitted together.
+  /// This will contain the following:
+  /// * Container version and type
+  /// * Remark version
+  /// * String table
+  Standalone,
+  First = SeparateRemarksMeta,
+  Last = Standalone,
+};
+
+/// The possible blocks that will be encountered in a bitstream remark
+/// container.
+enum BlockIDs {
+  /// The metadata block is mandatory. It should always come after the
+  /// BLOCKINFO_BLOCK, and contains metadata that should be used when parsing
+  /// REMARK_BLOCKs.
+  /// There should always be only one META_BLOCK.
+  META_BLOCK_ID = bitc::FIRST_APPLICATION_BLOCKID,
+  /// One remark entry is represented using a REMARK_BLOCK. There can be
+  /// multiple REMARK_BLOCKs in the same file.
+  REMARK_BLOCK_ID
+};
+
+constexpr StringRef MetaBlockName = StringRef("Meta", 4);
+constexpr StringRef RemarkBlockName = StringRef("Remark", 6);
+
+/// The possible records that can be encountered in the previously described
+/// blocks.
+enum RecordIDs {
+  // Meta block records.
+  RECORD_META_CONTAINER_INFO = 1,
+  RECORD_META_REMARK_VERSION,
+  RECORD_META_STRTAB,
+  RECORD_META_EXTERNAL_FILE,
+  // Remark block records.
+  RECORD_REMARK_HEADER,
+  RECORD_REMARK_DEBUG_LOC,
+  RECORD_REMARK_HOTNESS,
+  RECORD_REMARK_ARG_WITH_DEBUGLOC,
+  RECORD_REMARK_ARG_WITHOUT_DEBUGLOC,
+  // Helpers.
+  RECORD_FIRST = RECORD_META_CONTAINER_INFO,
+  RECORD_LAST = RECORD_REMARK_ARG_WITHOUT_DEBUGLOC
+};
+
+constexpr StringRef MetaContainerInfoName = StringRef("Container info", 14);
+constexpr StringRef MetaRemarkVersionName = StringRef("Remark version", 14);
+constexpr StringRef MetaStrTabName = StringRef("String table", 12);
+constexpr StringRef MetaExternalFileName = StringRef("External File", 13);
+constexpr StringRef RemarkHeaderName = StringRef("Remark header", 13);
+constexpr StringRef RemarkDebugLocName = StringRef("Remark debug location", 21);
+constexpr StringRef RemarkHotnessName = StringRef("Remark hotness", 14);
+constexpr StringRef RemarkArgWithDebugLocName =
+    StringRef("Argument with debug location", 28);
+constexpr StringRef RemarkArgWithoutDebugLocName = StringRef("Argument", 8);
+
+} // end namespace remarks
+} // end namespace llvm
+
+#endif /* LLVM_REMARKS_REMARK_CONTAINER_H */
diff --git a/linux-x64/clang/include/llvm/Remarks/BitstreamRemarkParser.h b/linux-x64/clang/include/llvm/Remarks/BitstreamRemarkParser.h
new file mode 100644
index 0000000..f7553ba
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Remarks/BitstreamRemarkParser.h
@@ -0,0 +1,116 @@
+//===-- BitstreamRemarkParser.h - Bitstream parser --------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file provides an implementation of the remark parser using the LLVM
+// Bitstream format.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_REMARKS_BITSTREAM_REMARK_PARSER_H
+#define LLVM_REMARKS_BITSTREAM_REMARK_PARSER_H
+
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/Optional.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Bitstream/BitstreamReader.h"
+#include "llvm/Support/Error.h"
+#include <array>
+#include <cstdint>
+
+namespace llvm {
+namespace remarks {
+
+/// Helper to parse a META_BLOCK for a bitstream remark container.
+struct BitstreamMetaParserHelper {
+  /// The Bitstream reader.
+  BitstreamCursor &Stream;
+  /// Reference to the storage for the block info.
+  BitstreamBlockInfo &BlockInfo;
+  /// The parsed content: depending on the container type, some fields might be
+  /// empty.
+  Optional<uint64_t> ContainerVersion;
+  Optional<uint8_t> ContainerType;
+  Optional<StringRef> StrTabBuf;
+  Optional<StringRef> ExternalFilePath;
+  Optional<uint64_t> RemarkVersion;
+
+  /// Continue parsing with \p Stream. \p Stream is expected to contain a
+  /// ENTER_SUBBLOCK to the META_BLOCK at the current position.
+  /// \p Stream is expected to have a BLOCKINFO_BLOCK set.
+  BitstreamMetaParserHelper(BitstreamCursor &Stream,
+                            BitstreamBlockInfo &BlockInfo);
+
+  /// Parse the META_BLOCK and fill the available entries.
+  /// This helper does not check for the validity of the fields.
+  Error parse();
+};
+
+/// Helper to parse a REMARK_BLOCK for a bitstream remark container.
+struct BitstreamRemarkParserHelper {
+  /// The Bitstream reader.
+  BitstreamCursor &Stream;
+  /// The parsed content: depending on the remark, some fields might be empty.
+  Optional<uint8_t> Type;
+  Optional<uint64_t> RemarkNameIdx;
+  Optional<uint64_t> PassNameIdx;
+  Optional<uint64_t> FunctionNameIdx;
+  Optional<uint64_t> SourceFileNameIdx;
+  Optional<uint32_t> SourceLine;
+  Optional<uint32_t> SourceColumn;
+  Optional<uint64_t> Hotness;
+  struct Argument {
+    Optional<uint64_t> KeyIdx;
+    Optional<uint64_t> ValueIdx;
+    Optional<uint64_t> SourceFileNameIdx;
+    Optional<uint32_t> SourceLine;
+    Optional<uint32_t> SourceColumn;
+  };
+  Optional<ArrayRef<Argument>> Args;
+  /// Avoid re-allocating a vector every time.
+  SmallVector<Argument, 8> TmpArgs;
+
+  /// Continue parsing with \p Stream. \p Stream is expected to contain a
+  /// ENTER_SUBBLOCK to the REMARK_BLOCK at the current position.
+  /// \p Stream is expected to have a BLOCKINFO_BLOCK set and to have already
+  /// parsed the META_BLOCK.
+  BitstreamRemarkParserHelper(BitstreamCursor &Stream);
+
+  /// Parse the REMARK_BLOCK and fill the available entries.
+  /// This helper does not check for the validity of the fields.
+  Error parse();
+};
+
+/// Helper to parse any bitstream remark container.
+struct BitstreamParserHelper {
+  /// The Bitstream reader.
+  BitstreamCursor Stream;
+  /// The block info block.
+  BitstreamBlockInfo BlockInfo;
+  /// Start parsing at \p Buffer.
+  BitstreamParserHelper(StringRef Buffer);
+  /// Parse the magic number.
+  Expected<std::array<char, 4>> parseMagic();
+  /// Parse the block info block containing all the abbrevs.
+  /// This needs to be called before calling any other parsing function.
+  Error parseBlockInfoBlock();
+  /// Return true if the next block is a META_BLOCK. This function does not move
+  /// the cursor.
+  Expected<bool> isMetaBlock();
+  /// Return true if the next block is a REMARK_BLOCK. This function does not
+  /// move the cursor.
+  Expected<bool> isRemarkBlock();
+  /// Return true if the parser reached the end of the stream.
+  bool atEndOfStream() { return Stream.AtEndOfStream(); }
+  /// Jump to the end of the stream, skipping everything.
+  void skipToEnd() { return Stream.skipToEnd(); }
+};
+
+} // end namespace remarks
+} // end namespace llvm
+
+#endif /* LLVM_REMARKS_BITSTREAM_REMARK_PARSER_H */
diff --git a/linux-x64/clang/include/llvm/Remarks/BitstreamRemarkSerializer.h b/linux-x64/clang/include/llvm/Remarks/BitstreamRemarkSerializer.h
new file mode 100644
index 0000000..62a175a
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Remarks/BitstreamRemarkSerializer.h
@@ -0,0 +1,196 @@
+//===-- BitstreamRemarkSerializer.h - Bitstream serializer ------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file provides an implementation of the serializer using the LLVM
+// Bitstream format.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_REMARKS_BITSTREAM_REMARK_SERIALIZER_H
+#define LLVM_REMARKS_BITSTREAM_REMARK_SERIALIZER_H
+
+#include "llvm/Bitstream/BitstreamWriter.h"
+#include "llvm/Remarks/BitstreamRemarkContainer.h"
+#include "llvm/Remarks/RemarkSerializer.h"
+#include "llvm/Support/raw_ostream.h"
+
+namespace llvm {
+namespace remarks {
+
+/// Serialize the remarks to LLVM bitstream.
+/// This class provides ways to emit remarks in the LLVM bitstream format and
+/// its associated metadata.
+///
+/// * The separate model:
+///   Separate meta:        | Container info
+///                         | String table
+///                         | External file
+///
+///   Separate remarks:     | Container info
+///                         | Remark version
+///                         | Remark0
+///                         | Remark1
+///                         | Remark2
+///                         | ...
+///
+/// * The standalone model: | Container info
+///                         | String table
+///                         | Remark version
+///                         | Remark0
+///                         | Remark1
+///                         | Remark2
+///                         | ...
+///
+struct BitstreamRemarkSerializerHelper {
+  /// Buffer used for encoding the bitstream before writing it to the final
+  /// stream.
+  SmallVector<char, 1024> Encoded;
+  /// Buffer used to construct records and pass to the bitstream writer.
+  SmallVector<uint64_t, 64> R;
+  /// The Bitstream writer.
+  BitstreamWriter Bitstream;
+  /// The type of the container we are serializing.
+  BitstreamRemarkContainerType ContainerType;
+
+  /// Abbrev IDs initialized in the block info block.
+  /// Note: depending on the container type, some IDs might be uninitialized.
+  /// Warning: When adding more abbrev IDs, make sure to update the
+  /// BlockCodeSize (in the call to EnterSubblock).
+  uint64_t RecordMetaContainerInfoAbbrevID = 0;
+  uint64_t RecordMetaRemarkVersionAbbrevID = 0;
+  uint64_t RecordMetaStrTabAbbrevID = 0;
+  uint64_t RecordMetaExternalFileAbbrevID = 0;
+  uint64_t RecordRemarkHeaderAbbrevID = 0;
+  uint64_t RecordRemarkDebugLocAbbrevID = 0;
+  uint64_t RecordRemarkHotnessAbbrevID = 0;
+  uint64_t RecordRemarkArgWithDebugLocAbbrevID = 0;
+  uint64_t RecordRemarkArgWithoutDebugLocAbbrevID = 0;
+
+  BitstreamRemarkSerializerHelper(BitstreamRemarkContainerType ContainerType);
+
+  // Disable copy and move: Bitstream points to Encoded, which needs special
+  // handling during copy/move, but moving the vectors is probably useless
+  // anyway.
+  BitstreamRemarkSerializerHelper(const BitstreamRemarkSerializerHelper &) =
+      delete;
+  BitstreamRemarkSerializerHelper &
+  operator=(const BitstreamRemarkSerializerHelper &) = delete;
+  BitstreamRemarkSerializerHelper(BitstreamRemarkSerializerHelper &&) = delete;
+  BitstreamRemarkSerializerHelper &
+  operator=(BitstreamRemarkSerializerHelper &&) = delete;
+
+  /// Set up the necessary block info entries according to the container type.
+  void setupBlockInfo();
+
+  /// Set up the block info for the metadata block.
+  void setupMetaBlockInfo();
+  /// The remark version in the metadata block.
+  void setupMetaRemarkVersion();
+  void emitMetaRemarkVersion(uint64_t RemarkVersion);
+  /// The strtab in the metadata block.
+  void setupMetaStrTab();
+  void emitMetaStrTab(const StringTable &StrTab);
+  /// The external file in the metadata block.
+  void setupMetaExternalFile();
+  void emitMetaExternalFile(StringRef Filename);
+
+  /// The block info for the remarks block.
+  void setupRemarkBlockInfo();
+
+  /// Emit the metadata for the remarks.
+  void emitMetaBlock(uint64_t ContainerVersion,
+                     Optional<uint64_t> RemarkVersion,
+                     Optional<const StringTable *> StrTab = None,
+                     Optional<StringRef> Filename = None);
+
+  /// Emit a remark block. The string table is required.
+  void emitRemarkBlock(const Remark &Remark, StringTable &StrTab);
+  /// Finalize the writing to \p OS.
+  void flushToStream(raw_ostream &OS);
+  /// Finalize the writing to a buffer.
+  /// The contents of the buffer remain valid for the lifetime of the object.
+  /// Any call to any other function in this class will invalidate the buffer.
+  StringRef getBuffer();
+};
+
+/// Implementation of the remark serializer using LLVM bitstream.
+struct BitstreamRemarkSerializer : public RemarkSerializer {
+  /// The file should contain:
+  /// 1) The block info block that describes how to read the blocks.
+  /// 2) The metadata block that contains various information about the remarks
+  ///    in the file.
+  /// 3) A number of remark blocks.
+
+  /// We need to set up 1) and 2) first, so that we can emit 3) after. This flag
+  /// is used to emit the first two blocks only once.
+  bool DidSetUp = false;
+  /// The helper to emit bitstream.
+  BitstreamRemarkSerializerHelper Helper;
+
+  /// Construct a serializer that will create its own string table.
+  BitstreamRemarkSerializer(raw_ostream &OS, SerializerMode Mode);
+  /// Construct a serializer with a pre-filled string table.
+  BitstreamRemarkSerializer(raw_ostream &OS, SerializerMode Mode,
+                            StringTable StrTab);
+
+  /// Emit a remark to the stream. This also emits the metadata associated to
+  /// the remarks based on the SerializerMode specified at construction.
+  /// This writes the serialized output to the provided stream.
+  void emit(const Remark &Remark) override;
+  /// The metadata serializer associated to this remark serializer. Based on the
+  /// container type of the current serializer, the container type of the
+  /// metadata serializer will change.
+  std::unique_ptr<MetaSerializer>
+  metaSerializer(raw_ostream &OS,
+                 Optional<StringRef> ExternalFilename = None) override;
+
+  static bool classof(const RemarkSerializer *S) {
+    return S->SerializerFormat == Format::Bitstream;
+  }
+};
+
+/// Serializer of metadata for bitstream remarks.
+struct BitstreamMetaSerializer : public MetaSerializer {
+  /// This class can be used with [1] a pre-constructed
+  /// BitstreamRemarkSerializerHelper, or with [2] one that is owned by the meta
+  /// serializer. In case of [1], we need to be able to store a reference to the
+  /// object, while in case of [2] we need to store the whole object.
+  Optional<BitstreamRemarkSerializerHelper> TmpHelper;
+  /// The actual helper, that can point to \p TmpHelper or to an external helper
+  /// object.
+  BitstreamRemarkSerializerHelper *Helper = nullptr;
+
+  Optional<const StringTable *> StrTab;
+  Optional<StringRef> ExternalFilename;
+
+  /// Create a new meta serializer based on \p ContainerType.
+  BitstreamMetaSerializer(raw_ostream &OS,
+                          BitstreamRemarkContainerType ContainerType,
+                          Optional<const StringTable *> StrTab = None,
+                          Optional<StringRef> ExternalFilename = None)
+      : MetaSerializer(OS), TmpHelper(None), Helper(nullptr), StrTab(StrTab),
+        ExternalFilename(ExternalFilename) {
+    TmpHelper.emplace(ContainerType);
+    Helper = &*TmpHelper;
+  }
+
+  /// Create a new meta serializer based on a previously built \p Helper.
+  BitstreamMetaSerializer(raw_ostream &OS,
+                          BitstreamRemarkSerializerHelper &Helper,
+                          Optional<const StringTable *> StrTab = None,
+                          Optional<StringRef> ExternalFilename = None)
+      : MetaSerializer(OS), TmpHelper(None), Helper(&Helper), StrTab(StrTab),
+        ExternalFilename(ExternalFilename) {}
+
+  void emit() override;
+};
+
+} // end namespace remarks
+} // end namespace llvm
+
+#endif /* LLVM_REMARKS_BITSTREAM_REMARK_SERIALIZER_H */
diff --git a/linux-x64/clang/include/llvm/Remarks/HotnessThresholdParser.h b/linux-x64/clang/include/llvm/Remarks/HotnessThresholdParser.h
new file mode 100644
index 0000000..08bbf5f
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Remarks/HotnessThresholdParser.h
@@ -0,0 +1,63 @@
+//===- HotnessThresholdParser.h - Parser for hotness threshold --*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file implements a simple parser to decode commandline option for
+/// remarks hotness threshold that supports both int and a special 'auto' value.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_REMARKS_HOTNESSTHRESHOLDPARSER_H
+#define LLVM_REMARKS_HOTNESSTHRESHOLDPARSER_H
+
+#include "llvm/ADT/Optional.h"
+#include "llvm/Support/CommandLine.h"
+
+namespace llvm {
+namespace remarks {
+
+// Parse remarks hotness threshold argument value.
+// Valid option values are
+// 1. integer: manually specified threshold; or
+// 2. string 'auto': automatically get threshold from profile summary.
+//
+// Return None Optional if 'auto' is specified, indicating the value will
+// be filled later during PSI.
+inline Expected<Optional<uint64_t>> parseHotnessThresholdOption(StringRef Arg) {
+  if (Arg == "auto")
+    return None;
+
+  int64_t Val;
+  if (Arg.getAsInteger(10, Val))
+    return createStringError(llvm::inconvertibleErrorCode(),
+                             "Not an integer: %s", Arg.data());
+
+  // Negative integer effectively means no threshold
+  return Val < 0 ? 0 : Val;
+}
+
+// A simple CL parser for '*-remarks-hotness-threshold='
+class HotnessThresholdParser : public cl::parser<Optional<uint64_t>> {
+public:
+  HotnessThresholdParser(cl::Option &O) : cl::parser<Optional<uint64_t>>(O) {}
+
+  bool parse(cl::Option &O, StringRef ArgName, StringRef Arg,
+             Optional<uint64_t> &V) {
+    auto ResultOrErr = parseHotnessThresholdOption(Arg);
+    if (!ResultOrErr)
+      return O.error("Invalid argument '" + Arg +
+                     "', only integer or 'auto' is supported.");
+
+    V = *ResultOrErr;
+    return false;
+  }
+};
+
+} // namespace remarks
+} // namespace llvm
+#endif // LLVM_REMARKS_HOTNESSTHRESHOLDPARSER_H
diff --git a/linux-x64/clang/include/llvm/Remarks/Remark.h b/linux-x64/clang/include/llvm/Remarks/Remark.h
index d916728..160e8dc 100644
--- a/linux-x64/clang/include/llvm/Remarks/Remark.h
+++ b/linux-x64/clang/include/llvm/Remarks/Remark.h
@@ -14,8 +14,8 @@
 #define LLVM_REMARKS_REMARK_H
 
 #include "llvm-c/Remarks.h"
-#include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Optional.h"
+#include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/CBindingWrapping.h"
 #include <string>
@@ -23,15 +23,15 @@
 namespace llvm {
 namespace remarks {
 
-constexpr uint64_t Version = 0;
-constexpr StringRef Magic("REMARKS", 7);
+/// The current version of the remark entry.
+constexpr uint64_t CurrentRemarkVersion = 0;
 
 /// The debug location used to track a remark back to the source file.
 struct RemarkLocation {
   /// Absolute path of the source file corresponding to this remark.
   StringRef SourceFilePath;
-  unsigned SourceLine;
-  unsigned SourceColumn;
+  unsigned SourceLine = 0;
+  unsigned SourceColumn = 0;
 };
 
 // Create wrappers for C Binding types (see CBindingWrapping.h).
@@ -59,7 +59,8 @@
   AnalysisFPCommute,
   AnalysisAliasing,
   Failure,
-  LastTypeValue = Failure
+  First = Unknown,
+  Last = Failure
 };
 
 /// A remark type used for both emission and parsing.
@@ -86,15 +87,90 @@
   Optional<uint64_t> Hotness;
 
   /// Arguments collected via the streaming interface.
-  ArrayRef<Argument> Args;
+  SmallVector<Argument, 5> Args;
+
+  Remark() = default;
+  Remark(Remark &&) = default;
+  Remark &operator=(Remark &&) = default;
 
   /// Return a message composed from the arguments as a string.
   std::string getArgsAsMsg() const;
+
+  /// Clone this remark to explicitly ask for a copy.
+  Remark clone() const { return *this; }
+
+private:
+  /// In order to avoid unwanted copies, "delete" the copy constructor.
+  /// If a copy is needed, it should be done through `Remark::clone()`.
+  Remark(const Remark &) = default;
+  Remark& operator=(const Remark &) = default;
 };
 
 // Create wrappers for C Binding types (see CBindingWrapping.h).
 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Remark, LLVMRemarkEntryRef)
 
+/// Comparison operators for Remark objects and dependent objects.
+
+template <typename T>
+bool operator<(const Optional<T> &LHS, const Optional<T> &RHS) {
+  // Sorting based on optionals should result in all `None` entries to appear
+  // before the valid entries. For example, remarks with no debug location will
+  // appear first.
+  if (!LHS && !RHS)
+    return false;
+  if (!LHS && RHS)
+    return true;
+  if (LHS && !RHS)
+    return false;
+  return *LHS < *RHS;
+}
+
+inline bool operator==(const RemarkLocation &LHS, const RemarkLocation &RHS) {
+  return LHS.SourceFilePath == RHS.SourceFilePath &&
+         LHS.SourceLine == RHS.SourceLine &&
+         LHS.SourceColumn == RHS.SourceColumn;
+}
+
+inline bool operator!=(const RemarkLocation &LHS, const RemarkLocation &RHS) {
+  return !(LHS == RHS);
+}
+
+inline bool operator<(const RemarkLocation &LHS, const RemarkLocation &RHS) {
+  return std::make_tuple(LHS.SourceFilePath, LHS.SourceLine, LHS.SourceColumn) <
+         std::make_tuple(RHS.SourceFilePath, RHS.SourceLine, RHS.SourceColumn);
+}
+
+inline bool operator==(const Argument &LHS, const Argument &RHS) {
+  return LHS.Key == RHS.Key && LHS.Val == RHS.Val && LHS.Loc == RHS.Loc;
+}
+
+inline bool operator!=(const Argument &LHS, const Argument &RHS) {
+  return !(LHS == RHS);
+}
+
+inline bool operator<(const Argument &LHS, const Argument &RHS) {
+  return std::make_tuple(LHS.Key, LHS.Val, LHS.Loc) <
+         std::make_tuple(RHS.Key, RHS.Val, RHS.Loc);
+}
+
+inline bool operator==(const Remark &LHS, const Remark &RHS) {
+  return LHS.RemarkType == RHS.RemarkType && LHS.PassName == RHS.PassName &&
+         LHS.RemarkName == RHS.RemarkName &&
+         LHS.FunctionName == RHS.FunctionName && LHS.Loc == RHS.Loc &&
+         LHS.Hotness == RHS.Hotness && LHS.Args == RHS.Args;
+}
+
+inline bool operator!=(const Remark &LHS, const Remark &RHS) {
+  return !(LHS == RHS);
+}
+
+inline bool operator<(const Remark &LHS, const Remark &RHS) {
+  return std::make_tuple(LHS.RemarkType, LHS.PassName, LHS.RemarkName,
+                         LHS.FunctionName, LHS.Loc, LHS.Hotness, LHS.Args) <
+         std::make_tuple(RHS.RemarkType, RHS.PassName, RHS.RemarkName,
+                         RHS.FunctionName, RHS.Loc, RHS.Hotness, RHS.Args);
+}
+
 } // end namespace remarks
 } // end namespace llvm
 
diff --git a/linux-x64/clang/include/llvm/Remarks/RemarkFormat.h b/linux-x64/clang/include/llvm/Remarks/RemarkFormat.h
new file mode 100644
index 0000000..a432c5a
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Remarks/RemarkFormat.h
@@ -0,0 +1,36 @@
+//===-- llvm/Remarks/RemarkFormat.h - The format of remarks -----*- C++/-*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines utilities to deal with the format of remarks.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_REMARKS_REMARK_FORMAT_H
+#define LLVM_REMARKS_REMARK_FORMAT_H
+
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/Error.h"
+
+namespace llvm {
+namespace remarks {
+
+constexpr StringLiteral Magic("REMARKS");
+
+/// The format used for serializing/deserializing remarks.
+enum class Format { Unknown, YAML, YAMLStrTab, Bitstream };
+
+/// Parse and validate a string for the remark format.
+Expected<Format> parseFormat(StringRef FormatStr);
+
+/// Parse and validate a magic number to a remark format.
+Expected<Format> magicToFormat(StringRef Magic);
+
+} // end namespace remarks
+} // end namespace llvm
+
+#endif /* LLVM_REMARKS_REMARK_FORMAT_H */
diff --git a/linux-x64/clang/include/llvm/Remarks/RemarkLinker.h b/linux-x64/clang/include/llvm/Remarks/RemarkLinker.h
new file mode 100644
index 0000000..7a53c30
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Remarks/RemarkLinker.h
@@ -0,0 +1,99 @@
+//===-- llvm/Remarks/RemarkLinker.h -----------------------------*- C++/-*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file provides an interface to link together multiple remark files.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_REMARKS_REMARK_LINKER_H
+#define LLVM_REMARKS_REMARK_LINKER_H
+
+#include "llvm/Object/ObjectFile.h"
+#include "llvm/Remarks/Remark.h"
+#include "llvm/Remarks/RemarkFormat.h"
+#include "llvm/Remarks/RemarkStringTable.h"
+#include "llvm/Support/Error.h"
+#include <memory>
+#include <set>
+
+namespace llvm {
+namespace remarks {
+
+struct RemarkLinker {
+private:
+  /// Compare through the pointers.
+  struct RemarkPtrCompare {
+    bool operator()(const std::unique_ptr<Remark> &LHS,
+                    const std::unique_ptr<Remark> &RHS) const {
+      assert(LHS && RHS && "Invalid pointers to compare.");
+      return *LHS < *RHS;
+    };
+  };
+
+  /// The main string table for the remarks.
+  /// Note: all remarks should use the strings from this string table to avoid
+  /// dangling references.
+  StringTable StrTab;
+
+  /// A set holding unique remarks.
+  /// FIXME: std::set is probably not the most appropriate data structure here.
+  /// Due to the limitation of having a move-only key, there isn't another
+  /// obvious choice for now.
+  std::set<std::unique_ptr<Remark>, RemarkPtrCompare> Remarks;
+
+  /// A path to append before the external file path found in remark metadata.
+  Optional<std::string> PrependPath;
+
+  /// Keep this remark. If it's already in the set, discard it.
+  Remark &keep(std::unique_ptr<Remark> Remark);
+
+public:
+  /// Set a path to prepend to the external file path.
+  void setExternalFilePrependPath(StringRef PrependPath);
+
+  /// Link the remarks found in \p Buffer.
+  /// If \p RemarkFormat is not provided, try to deduce it from the metadata in
+  /// \p Buffer.
+  /// \p Buffer can be either a standalone remark container or just
+  /// metadata. This takes care of uniquing and merging the remarks.
+  Error link(StringRef Buffer, Optional<Format> RemarkFormat = None);
+
+  /// Link the remarks found in \p Obj by looking for the right section and
+  /// calling the method above.
+  Error link(const object::ObjectFile &Obj,
+             Optional<Format> RemarkFormat = None);
+
+  /// Serialize the linked remarks to the stream \p OS, using the format \p
+  /// RemarkFormat.
+  /// This clears internal state such as the string table.
+  /// Note: this implies that the serialization mode is standalone.
+  Error serialize(raw_ostream &OS, Format RemarksFormat) const;
+
+  /// Check whether there are any remarks linked.
+  bool empty() const { return Remarks.empty(); }
+
+  /// Return a collection of the linked unique remarks to iterate on.
+  /// Ex:
+  /// for (const Remark &R : RL.remarks() { [...] }
+  using iterator = pointee_iterator<decltype(Remarks)::const_iterator>;
+
+  iterator_range<iterator> remarks() const {
+    return {Remarks.begin(), Remarks.end()};
+  }
+};
+
+/// Returns a buffer with the contents of the remarks section depending on the
+/// format of the file. If the section doesn't exist, this returns an empty
+/// optional.
+Expected<Optional<StringRef>>
+getRemarksSectionContents(const object::ObjectFile &Obj);
+
+} // end namespace remarks
+} // end namespace llvm
+
+#endif /* LLVM_REMARKS_REMARK_LINKER_H */
diff --git a/linux-x64/clang/include/llvm/Remarks/RemarkParser.h b/linux-x64/clang/include/llvm/Remarks/RemarkParser.h
index 457b2fb..d6b1fdd 100644
--- a/linux-x64/clang/include/llvm/Remarks/RemarkParser.h
+++ b/linux-x64/clang/include/llvm/Remarks/RemarkParser.h
@@ -16,38 +16,42 @@
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Remarks/Remark.h"
+#include "llvm/Remarks/RemarkFormat.h"
 #include "llvm/Support/Error.h"
 #include <memory>
 
 namespace llvm {
 namespace remarks {
 
-struct ParserImpl;
-struct ParsedStringTable;
+class EndOfFileError : public ErrorInfo<EndOfFileError> {
+public:
+  static char ID;
 
-enum class ParserFormat { YAML };
+  EndOfFileError() {}
+
+  void log(raw_ostream &OS) const override { OS << "End of file reached."; }
+  std::error_code convertToErrorCode() const override {
+    return inconvertibleErrorCode();
+  }
+};
 
 /// Parser used to parse a raw buffer to remarks::Remark objects.
-struct Parser {
-  /// The hidden implementation of the parser.
-  std::unique_ptr<ParserImpl> Impl;
+struct RemarkParser {
+  /// The format of the parser.
+  Format ParserFormat;
+  /// Path to prepend when opening an external remark file.
+  std::string ExternalFilePrependPath;
 
-  /// Create a parser parsing \p Buffer to Remark objects.
-  /// This constructor should be only used for parsing remarks without a string
-  /// table.
-  Parser(ParserFormat Format, StringRef Buffer);
+  RemarkParser(Format ParserFormat) : ParserFormat(ParserFormat) {}
 
-  /// Create a parser parsing \p Buffer to Remark objects, using \p StrTab as a
-  /// string table.
-  Parser(ParserFormat Format, StringRef Buffer,
-         const ParsedStringTable &StrTab);
+  /// If no error occurs, this returns a valid Remark object.
+  /// If an error of type EndOfFileError occurs, it is safe to recover from it
+  /// by stopping the parsing.
+  /// If any other error occurs, it should be propagated to the user.
+  /// The pointer should never be null.
+  virtual Expected<std::unique_ptr<Remark>> next() = 0;
 
-  // Needed because ParserImpl is an incomplete type.
-  ~Parser();
-
-  /// Returns an empty Optional if it reached the end.
-  /// Returns a valid remark otherwise.
-  Expected<const Remark *> getNext() const;
+  virtual ~RemarkParser() = default;
 };
 
 /// In-memory representation of the string table parsed from a buffer (e.g. the
@@ -55,13 +59,34 @@
 struct ParsedStringTable {
   /// The buffer mapped from the section contents.
   StringRef Buffer;
-  /// Collection of offsets in the buffer for each string entry.
-  SmallVector<size_t, 8> Offsets;
+  /// This object has high changes to be std::move'd around, so don't use a
+  /// SmallVector for once.
+  std::vector<size_t> Offsets;
 
-  Expected<StringRef> operator[](size_t Index) const;
   ParsedStringTable(StringRef Buffer);
+  /// Disable copy.
+  ParsedStringTable(const ParsedStringTable &) = delete;
+  ParsedStringTable &operator=(const ParsedStringTable &) = delete;
+  /// Should be movable.
+  ParsedStringTable(ParsedStringTable &&) = default;
+  ParsedStringTable &operator=(ParsedStringTable &&) = default;
+
+  size_t size() const { return Offsets.size(); }
+  Expected<StringRef> operator[](size_t Index) const;
 };
 
+Expected<std::unique_ptr<RemarkParser>> createRemarkParser(Format ParserFormat,
+                                                           StringRef Buf);
+
+Expected<std::unique_ptr<RemarkParser>>
+createRemarkParser(Format ParserFormat, StringRef Buf,
+                   ParsedStringTable StrTab);
+
+Expected<std::unique_ptr<RemarkParser>>
+createRemarkParserFromMeta(Format ParserFormat, StringRef Buf,
+                           Optional<ParsedStringTable> StrTab = None,
+                           Optional<StringRef> ExternalFilePrependPath = None);
+
 } // end namespace remarks
 } // end namespace llvm
 
diff --git a/linux-x64/clang/include/llvm/Remarks/RemarkSerializer.h b/linux-x64/clang/include/llvm/Remarks/RemarkSerializer.h
index def5c2e..35752cd 100644
--- a/linux-x64/clang/include/llvm/Remarks/RemarkSerializer.h
+++ b/linux-x64/clang/include/llvm/Remarks/RemarkSerializer.h
@@ -14,54 +14,74 @@
 #define LLVM_REMARKS_REMARK_SERIALIZER_H
 
 #include "llvm/Remarks/Remark.h"
+#include "llvm/Remarks/RemarkFormat.h"
 #include "llvm/Remarks/RemarkStringTable.h"
-#include "llvm/Support/YAMLTraits.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace llvm {
 namespace remarks {
 
+enum class SerializerMode {
+  Separate,  // A mode where the metadata is serialized separately from the
+             // remarks. Typically, this is used when the remarks need to be
+             // streamed to a side file and the metadata is embedded into the
+             // final result of the compilation.
+  Standalone // A mode where everything can be retrieved in the same
+             // file/buffer. Typically, this is used for storing remarks for
+             // later use.
+};
+
+struct MetaSerializer;
+
 /// This is the base class for a remark serializer.
 /// It includes support for using a string table while emitting.
-struct Serializer {
+struct RemarkSerializer {
+  /// The format of the serializer.
+  Format SerializerFormat;
   /// The open raw_ostream that the remark diagnostics are emitted to.
   raw_ostream &OS;
+  /// The serialization mode.
+  SerializerMode Mode;
   /// The string table containing all the unique strings used in the output.
   /// The table can be serialized to be consumed after the compilation.
   Optional<StringTable> StrTab;
 
-  Serializer(raw_ostream &OS) : OS(OS), StrTab() {}
+  RemarkSerializer(Format SerializerFormat, raw_ostream &OS,
+                   SerializerMode Mode)
+      : SerializerFormat(SerializerFormat), OS(OS), Mode(Mode), StrTab() {}
 
   /// This is just an interface.
-  virtual ~Serializer() = default;
-  virtual void emit(const Remark &Remark) = 0;
-};
-
-/// Wether the serializer should use a string table while emitting.
-enum class UseStringTable { No, Yes };
-
-/// Serialize the remarks to YAML. One remark entry looks like this:
-/// --- !<TYPE>
-/// Pass:            <PASSNAME>
-/// Name:            <REMARKNAME>
-/// DebugLoc:        { File: <SOURCEFILENAME>, Line: <SOURCELINE>,
-///                    Column: <SOURCECOLUMN> }
-/// Function:        <FUNCTIONNAME>
-/// Args:
-///   - <KEY>: <VALUE>
-///     DebugLoc:        { File: <FILE>, Line: <LINE>, Column: <COL> }
-/// ...
-struct YAMLSerializer : public Serializer {
-  /// The YAML streamer.
-  yaml::Output YAMLOutput;
-
-  YAMLSerializer(raw_ostream &OS,
-                 UseStringTable UseStringTable = remarks::UseStringTable::No);
-
+  virtual ~RemarkSerializer() = default;
   /// Emit a remark to the stream.
-  void emit(const Remark &Remark) override;
+  virtual void emit(const Remark &Remark) = 0;
+  /// Return the corresponding metadata serializer.
+  virtual std::unique_ptr<MetaSerializer>
+  metaSerializer(raw_ostream &OS,
+                 Optional<StringRef> ExternalFilename = None) = 0;
 };
 
+/// This is the base class for a remark metadata serializer.
+struct MetaSerializer {
+  /// The open raw_ostream that the metadata is emitted to.
+  raw_ostream &OS;
+
+  MetaSerializer(raw_ostream &OS) : OS(OS) {}
+
+  /// This is just an interface.
+  virtual ~MetaSerializer() = default;
+  virtual void emit() = 0;
+};
+
+/// Create a remark serializer.
+Expected<std::unique_ptr<RemarkSerializer>>
+createRemarkSerializer(Format RemarksFormat, SerializerMode Mode,
+                       raw_ostream &OS);
+
+/// Create a remark serializer that uses a pre-filled string table.
+Expected<std::unique_ptr<RemarkSerializer>>
+createRemarkSerializer(Format RemarksFormat, SerializerMode Mode,
+                       raw_ostream &OS, remarks::StringTable StrTab);
+
 } // end namespace remarks
 } // end namespace llvm
 
diff --git a/linux-x64/clang/include/llvm/Remarks/RemarkStreamer.h b/linux-x64/clang/include/llvm/Remarks/RemarkStreamer.h
new file mode 100644
index 0000000..7741cb4
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Remarks/RemarkStreamer.h
@@ -0,0 +1,73 @@
+//===- llvm/Remarks/RemarkStreamer.h ----------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file declares the main interface for streaming remarks.
+//
+// This is used to stream any llvm::remarks::Remark to an open file taking
+// advantage of all the serialization capabilities developed for remarks (e.g.
+// metadata in a section, bitstream format, etc.).
+//
+// Typically, a specialized remark emitter should hold a reference to the main
+// remark streamer set up in the LLVMContext, and should convert specialized
+// diagnostics to llvm::remarks::Remark objects as they get emitted.
+//
+// Specialized remark emitters can be components like:
+// * Remarks from LLVM (M)IR passes
+// * Remarks from the frontend
+// * Remarks from an intermediate IR
+//
+// This allows for composition between specialized remark emitters throughout
+// the compilation pipeline, that end up in the same file, using the same format
+// and serialization techniques.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_REMARKS_REMARKSTREAMER_H
+#define LLVM_REMARKS_REMARKSTREAMER_H
+
+#include "llvm/ADT/Optional.h"
+#include "llvm/Remarks/RemarkSerializer.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/Regex.h"
+#include "llvm/Support/raw_ostream.h"
+#include <memory>
+
+namespace llvm {
+namespace remarks {
+class RemarkStreamer final {
+  /// The regex used to filter remarks based on the passes that emit them.
+  Optional<Regex> PassFilter;
+  /// The object used to serialize the remarks to a specific format.
+  std::unique_ptr<remarks::RemarkSerializer> RemarkSerializer;
+  /// The filename that the remark diagnostics are emitted to.
+  const Optional<std::string> Filename;
+
+public:
+  RemarkStreamer(std::unique_ptr<remarks::RemarkSerializer> RemarkSerializer,
+                 Optional<StringRef> Filename = None);
+
+  /// Return the filename that the remark diagnostics are emitted to.
+  Optional<StringRef> getFilename() const {
+    return Filename ? Optional<StringRef>(*Filename) : None;
+  }
+  /// Return stream that the remark diagnostics are emitted to.
+  raw_ostream &getStream() { return RemarkSerializer->OS; }
+  /// Return the serializer used for this stream.
+  remarks::RemarkSerializer &getSerializer() { return *RemarkSerializer; }
+  /// Set a pass filter based on a regex \p Filter.
+  /// Returns an error if the regex is invalid.
+  Error setFilter(StringRef Filter);
+  /// Check wether the string matches the filter.
+  bool matchesFilter(StringRef Str);
+  /// Check if the remarks also need to have associated metadata in a section.
+  bool needsSection() const;
+};
+} // end namespace remarks
+} // end namespace llvm
+
+#endif // LLVM_REMARKS_REMARKSTREAMER_H
diff --git a/linux-x64/clang/include/llvm/Remarks/RemarkStringTable.h b/linux-x64/clang/include/llvm/Remarks/RemarkStringTable.h
index f9b4fdb..60cf601 100644
--- a/linux-x64/clang/include/llvm/Remarks/RemarkStringTable.h
+++ b/linux-x64/clang/include/llvm/Remarks/RemarkStringTable.h
@@ -17,31 +17,46 @@
 #define LLVM_REMARKS_REMARK_STRING_TABLE_H
 
 #include "llvm/ADT/StringMap.h"
-#include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Allocator.h"
 #include <vector>
 
 namespace llvm {
 
 class raw_ostream;
+class StringRef;
 
 namespace remarks {
 
+struct ParsedStringTable;
+struct Remark;
+
 /// The string table used for serializing remarks.
 /// This table can be for example serialized in a section to be consumed after
 /// the compilation.
 struct StringTable {
-  /// Allocator holding all the memory used by the map.
-  BumpPtrAllocator Allocator;
   /// The string table containing all the unique strings used in the output.
   /// It maps a string to an unique ID.
-  StringMap<unsigned, BumpPtrAllocator &> StrTab;
+  StringMap<unsigned, BumpPtrAllocator> StrTab;
   /// Total size of the string table when serialized.
   size_t SerializedSize = 0;
 
-  StringTable() : Allocator(), StrTab(Allocator) {}
+  StringTable() = default;
+
+  /// Disable copy.
+  StringTable(const StringTable &) = delete;
+  StringTable &operator=(const StringTable &) = delete;
+  /// Should be movable.
+  StringTable(StringTable &&) = default;
+  StringTable &operator=(StringTable &&) = default;
+
+  /// Construct a string table from a ParsedStringTable.
+  StringTable(const ParsedStringTable &Other);
+
   /// Add a string to the table. It returns an unique ID of the string.
   std::pair<unsigned, StringRef> add(StringRef Str);
+  /// Modify \p R to use strings from this string table. If the string table
+  /// does not contain the strings, it adds them.
+  void internalize(Remark &R);
   /// Serialize the string table to a stream. It is serialized as a little
   /// endian uint64 (the size of the table in bytes) followed by a sequence of
   /// NULL-terminated strings, where the N-th string is the string with the ID N
diff --git a/linux-x64/clang/include/llvm/Remarks/YAMLRemarkSerializer.h b/linux-x64/clang/include/llvm/Remarks/YAMLRemarkSerializer.h
new file mode 100644
index 0000000..f1213be
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Remarks/YAMLRemarkSerializer.h
@@ -0,0 +1,108 @@
+//===-- YAMLRemarkSerializer.h - YAML Remark serialization ---*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file provides an interface for serializing remarks to YAML.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_REMARKS_YAML_REMARK_SERIALIZER_H
+#define LLVM_REMARKS_YAML_REMARK_SERIALIZER_H
+
+#include "llvm/Remarks/RemarkSerializer.h"
+#include "llvm/Support/YAMLTraits.h"
+
+namespace llvm {
+namespace remarks {
+
+/// Serialize the remarks to YAML. One remark entry looks like this:
+/// --- !<TYPE>
+/// Pass:            <PASSNAME>
+/// Name:            <REMARKNAME>
+/// DebugLoc:        { File: <SOURCEFILENAME>, Line: <SOURCELINE>,
+///                    Column: <SOURCECOLUMN> }
+/// Function:        <FUNCTIONNAME>
+/// Args:
+///   - <KEY>: <VALUE>
+///     DebugLoc:        { File: <FILE>, Line: <LINE>, Column: <COL> }
+/// ...
+struct YAMLRemarkSerializer : public RemarkSerializer {
+  /// The YAML streamer.
+  yaml::Output YAMLOutput;
+
+  YAMLRemarkSerializer(raw_ostream &OS, SerializerMode Mode,
+                       Optional<StringTable> StrTab = None);
+
+  void emit(const Remark &Remark) override;
+  std::unique_ptr<MetaSerializer>
+  metaSerializer(raw_ostream &OS,
+                 Optional<StringRef> ExternalFilename = None) override;
+
+  static bool classof(const RemarkSerializer *S) {
+    return S->SerializerFormat == Format::YAML;
+  }
+
+protected:
+  YAMLRemarkSerializer(Format SerializerFormat, raw_ostream &OS,
+                       SerializerMode Mode,
+                       Optional<StringTable> StrTab = None);
+};
+
+struct YAMLMetaSerializer : public MetaSerializer {
+  Optional<StringRef> ExternalFilename;
+
+  YAMLMetaSerializer(raw_ostream &OS, Optional<StringRef> ExternalFilename)
+      : MetaSerializer(OS), ExternalFilename(ExternalFilename) {}
+
+  void emit() override;
+};
+
+/// Serialize the remarks to YAML using a string table. An remark entry looks
+/// like the regular YAML remark but instead of string entries it's using
+/// numbers that map to an index in the string table.
+struct YAMLStrTabRemarkSerializer : public YAMLRemarkSerializer {
+  /// Wether we already emitted the metadata in standalone mode.
+  /// This should be set to true after the first invocation of `emit`.
+  bool DidEmitMeta = false;
+
+  YAMLStrTabRemarkSerializer(raw_ostream &OS, SerializerMode Mode)
+      : YAMLRemarkSerializer(Format::YAMLStrTab, OS, Mode) {
+    // We always need a string table for this type of serializer.
+    StrTab.emplace();
+  }
+  YAMLStrTabRemarkSerializer(raw_ostream &OS, SerializerMode Mode,
+                             StringTable StrTab)
+      : YAMLRemarkSerializer(Format::YAMLStrTab, OS, Mode, std::move(StrTab)) {}
+
+  /// Override to emit the metadata if necessary.
+  void emit(const Remark &Remark) override;
+
+  std::unique_ptr<MetaSerializer>
+  metaSerializer(raw_ostream &OS,
+                 Optional<StringRef> ExternalFilename = None) override;
+
+  static bool classof(const RemarkSerializer *S) {
+    return S->SerializerFormat == Format::YAMLStrTab;
+  }
+};
+
+struct YAMLStrTabMetaSerializer : public YAMLMetaSerializer {
+  /// The string table is part of the metadata.
+  const StringTable &StrTab;
+
+  YAMLStrTabMetaSerializer(raw_ostream &OS,
+                           Optional<StringRef> ExternalFilename,
+                           const StringTable &StrTab)
+      : YAMLMetaSerializer(OS, ExternalFilename), StrTab(StrTab) {}
+
+  void emit() override;
+};
+
+} // end namespace remarks
+} // end namespace llvm
+
+#endif /* LLVM_REMARKS_REMARK_SERIALIZER_H */
diff --git a/linux-x64/clang/include/llvm/Support/AArch64TargetParser.def b/linux-x64/clang/include/llvm/Support/AArch64TargetParser.def
index e152f38..5f36b0e 100644
--- a/linux-x64/clang/include/llvm/Support/AArch64TargetParser.def
+++ b/linux-x64/clang/include/llvm/Support/AArch64TargetParser.def
@@ -44,46 +44,79 @@
              (AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_FP |
               AArch64::AEK_SIMD | AArch64::AEK_RAS | AArch64::AEK_LSE |
               AArch64::AEK_RDM | AArch64::AEK_RCPC | AArch64::AEK_DOTPROD))
+AARCH64_ARCH("armv8.6-a", ARMV8_6A, "8.6-A", "v8.6a",
+             ARMBuildAttrs::CPUArch::v8_A, FK_CRYPTO_NEON_FP_ARMV8,
+             (AArch64::AEK_CRC  | AArch64::AEK_FP   |
+              AArch64::AEK_SIMD | AArch64::AEK_RAS  | AArch64::AEK_LSE     |
+              AArch64::AEK_RDM  | AArch64::AEK_RCPC | AArch64::AEK_DOTPROD |
+              AArch64::AEK_SM4  | AArch64::AEK_SHA3 | AArch64::AEK_BF16    |
+              AArch64::AEK_SHA2 | AArch64::AEK_AES  | AArch64::AEK_I8MM))
+AARCH64_ARCH("armv8.7-a", ARMV8_7A, "8.7-A", "v8.7a",
+             ARMBuildAttrs::CPUArch::v8_A, FK_CRYPTO_NEON_FP_ARMV8,
+             (AArch64::AEK_CRC | AArch64::AEK_FP |
+              AArch64::AEK_SIMD | AArch64::AEK_RAS | AArch64::AEK_LSE |
+              AArch64::AEK_RDM | AArch64::AEK_RCPC | AArch64::AEK_DOTPROD |
+              AArch64::AEK_SM4 | AArch64::AEK_SHA3 | AArch64::AEK_BF16 |
+              AArch64::AEK_SHA2 | AArch64::AEK_AES | AArch64::AEK_I8MM))
+// For v8-R, we do not enable crypto and align with GCC that enables a more
+// minimal set of optional architecture extensions.
+AARCH64_ARCH("armv8-r", ARMV8R, "8-R", "v8r",
+             ARMBuildAttrs::CPUArch::v8_R, FK_CRYPTO_NEON_FP_ARMV8,
+             (AArch64::AEK_CRC     | AArch64::AEK_RDM  | AArch64::AEK_SSBS |
+              AArch64::AEK_DOTPROD | AArch64::AEK_FP   | AArch64::AEK_SIMD |
+              AArch64::AEK_FP16    | AArch64::AEK_FP16FML | AArch64::AEK_RAS |
+              AArch64::AEK_RCPC    | AArch64::AEK_SB))
 #undef AARCH64_ARCH
 
 #ifndef AARCH64_ARCH_EXT_NAME
 #define AARCH64_ARCH_EXT_NAME(NAME, ID, FEATURE, NEGFEATURE)
 #endif
 // FIXME: This would be nicer were it tablegen
-AARCH64_ARCH_EXT_NAME("invalid",   AArch64::AEK_INVALID,  nullptr,  nullptr)
-AARCH64_ARCH_EXT_NAME("none",      AArch64::AEK_NONE,     nullptr,  nullptr)
-AARCH64_ARCH_EXT_NAME("crc",       AArch64::AEK_CRC,      "+crc",   "-crc")
-AARCH64_ARCH_EXT_NAME("lse",       AArch64::AEK_LSE,      "+lse",   "-lse")
-AARCH64_ARCH_EXT_NAME("rdm",       AArch64::AEK_RDM,      "+rdm",   "-rdm")
-AARCH64_ARCH_EXT_NAME("crypto",    AArch64::AEK_CRYPTO,   "+crypto","-crypto")
-AARCH64_ARCH_EXT_NAME("sm4",       AArch64::AEK_SM4,      "+sm4",   "-sm4")
-AARCH64_ARCH_EXT_NAME("sha3",      AArch64::AEK_SHA3,     "+sha3",  "-sha3")
-AARCH64_ARCH_EXT_NAME("sha2",      AArch64::AEK_SHA2,     "+sha2",  "-sha2")
-AARCH64_ARCH_EXT_NAME("aes",       AArch64::AEK_AES,      "+aes",   "-aes")
-AARCH64_ARCH_EXT_NAME("dotprod",   AArch64::AEK_DOTPROD,  "+dotprod","-dotprod")
-AARCH64_ARCH_EXT_NAME("fp",        AArch64::AEK_FP,       "+fp-armv8",  "-fp-armv8")
-AARCH64_ARCH_EXT_NAME("simd",      AArch64::AEK_SIMD,     "+neon",  "-neon")
-AARCH64_ARCH_EXT_NAME("fp16",      AArch64::AEK_FP16,     "+fullfp16",  "-fullfp16")
-AARCH64_ARCH_EXT_NAME("fp16fml",   AArch64::AEK_FP16FML,  "+fp16fml", "-fp16fml")
-AARCH64_ARCH_EXT_NAME("profile",   AArch64::AEK_PROFILE,  "+spe",  "-spe")
-AARCH64_ARCH_EXT_NAME("ras",       AArch64::AEK_RAS,      "+ras",  "-ras")
-AARCH64_ARCH_EXT_NAME("sve",       AArch64::AEK_SVE,      "+sve",  "-sve")
-AARCH64_ARCH_EXT_NAME("sve2",      AArch64::AEK_SVE2,     "+sve2", "-sve2")
-AARCH64_ARCH_EXT_NAME("sve2-aes",  AArch64::AEK_SVE2AES,  "+sve2-aes", "-sve2-aes")
-AARCH64_ARCH_EXT_NAME("sve2-sm4",  AArch64::AEK_SVE2SM4,  "+sve2-sm4", "-sve2-sm4")
-AARCH64_ARCH_EXT_NAME("sve2-sha3", AArch64::AEK_SVE2SHA3, "+sve2-sha3", "-sve2-sha3")
-AARCH64_ARCH_EXT_NAME("bitperm",   AArch64::AEK_BITPERM,  "+bitperm", "-bitperm")
-AARCH64_ARCH_EXT_NAME("rcpc",      AArch64::AEK_RCPC,     "+rcpc", "-rcpc")
-AARCH64_ARCH_EXT_NAME("rng",       AArch64::AEK_RAND,     "+rand",  "-rand")
-AARCH64_ARCH_EXT_NAME("memtag",    AArch64::AEK_MTE,      "+mte",   "-mte")
-AARCH64_ARCH_EXT_NAME("ssbs",      AArch64::AEK_SSBS,     "+ssbs",  "-ssbs")
-AARCH64_ARCH_EXT_NAME("sb",        AArch64::AEK_SB,       "+sb",    "-sb")
-AARCH64_ARCH_EXT_NAME("predres",   AArch64::AEK_PREDRES,  "+predres", "-predres")
+AARCH64_ARCH_EXT_NAME("invalid",      AArch64::AEK_INVALID,     nullptr,  nullptr)
+AARCH64_ARCH_EXT_NAME("none",         AArch64::AEK_NONE,        nullptr,  nullptr)
+AARCH64_ARCH_EXT_NAME("crc",          AArch64::AEK_CRC,         "+crc",   "-crc")
+AARCH64_ARCH_EXT_NAME("lse",          AArch64::AEK_LSE,         "+lse",   "-lse")
+AARCH64_ARCH_EXT_NAME("rdm",          AArch64::AEK_RDM,         "+rdm",   "-rdm")
+AARCH64_ARCH_EXT_NAME("crypto",       AArch64::AEK_CRYPTO,      "+crypto","-crypto")
+AARCH64_ARCH_EXT_NAME("sm4",          AArch64::AEK_SM4,         "+sm4",   "-sm4")
+AARCH64_ARCH_EXT_NAME("sha3",         AArch64::AEK_SHA3,        "+sha3",  "-sha3")
+AARCH64_ARCH_EXT_NAME("sha2",         AArch64::AEK_SHA2,        "+sha2",  "-sha2")
+AARCH64_ARCH_EXT_NAME("aes",          AArch64::AEK_AES,         "+aes",   "-aes")
+AARCH64_ARCH_EXT_NAME("dotprod",      AArch64::AEK_DOTPROD,     "+dotprod","-dotprod")
+AARCH64_ARCH_EXT_NAME("fp",           AArch64::AEK_FP,          "+fp-armv8",  "-fp-armv8")
+AARCH64_ARCH_EXT_NAME("simd",         AArch64::AEK_SIMD,        "+neon",  "-neon")
+AARCH64_ARCH_EXT_NAME("fp16",         AArch64::AEK_FP16,        "+fullfp16",  "-fullfp16")
+AARCH64_ARCH_EXT_NAME("fp16fml",      AArch64::AEK_FP16FML,     "+fp16fml", "-fp16fml")
+AARCH64_ARCH_EXT_NAME("profile",      AArch64::AEK_PROFILE,     "+spe",  "-spe")
+AARCH64_ARCH_EXT_NAME("ras",          AArch64::AEK_RAS,         "+ras",  "-ras")
+AARCH64_ARCH_EXT_NAME("sve",          AArch64::AEK_SVE,         "+sve",  "-sve")
+AARCH64_ARCH_EXT_NAME("sve2",         AArch64::AEK_SVE2,        "+sve2", "-sve2")
+AARCH64_ARCH_EXT_NAME("sve2-aes",     AArch64::AEK_SVE2AES,     "+sve2-aes", "-sve2-aes")
+AARCH64_ARCH_EXT_NAME("sve2-sm4",     AArch64::AEK_SVE2SM4,     "+sve2-sm4", "-sve2-sm4")
+AARCH64_ARCH_EXT_NAME("sve2-sha3",    AArch64::AEK_SVE2SHA3,    "+sve2-sha3", "-sve2-sha3")
+AARCH64_ARCH_EXT_NAME("sve2-bitperm", AArch64::AEK_SVE2BITPERM, "+sve2-bitperm", "-sve2-bitperm")
+AARCH64_ARCH_EXT_NAME("rcpc",         AArch64::AEK_RCPC,        "+rcpc", "-rcpc")
+AARCH64_ARCH_EXT_NAME("rng",          AArch64::AEK_RAND,        "+rand",  "-rand")
+AARCH64_ARCH_EXT_NAME("memtag",       AArch64::AEK_MTE,         "+mte",   "-mte")
+AARCH64_ARCH_EXT_NAME("ssbs",         AArch64::AEK_SSBS,        "+ssbs",  "-ssbs")
+AARCH64_ARCH_EXT_NAME("sb",           AArch64::AEK_SB,          "+sb",    "-sb")
+AARCH64_ARCH_EXT_NAME("predres",      AArch64::AEK_PREDRES,     "+predres", "-predres")
+AARCH64_ARCH_EXT_NAME("bf16",         AArch64::AEK_BF16,        "+bf16",  "-bf16")
+AARCH64_ARCH_EXT_NAME("i8mm",         AArch64::AEK_I8MM,        "+i8mm",  "-i8mm")
+AARCH64_ARCH_EXT_NAME("f32mm",        AArch64::AEK_F32MM,       "+f32mm", "-f32mm")
+AARCH64_ARCH_EXT_NAME("f64mm",        AArch64::AEK_F64MM,       "+f64mm", "-f64mm")
+AARCH64_ARCH_EXT_NAME("tme",          AArch64::AEK_TME,         "+tme",   "-tme")
+AARCH64_ARCH_EXT_NAME("ls64",         AArch64::AEK_LS64,        "+ls64",  "-ls64")
+AARCH64_ARCH_EXT_NAME("brbe",         AArch64::AEK_BRBE,        "+brbe",  "-brbe")
+AARCH64_ARCH_EXT_NAME("pauth",        AArch64::AEK_PAUTH,       "+pauth", "-pauth")
+AARCH64_ARCH_EXT_NAME("flagm",        AArch64::AEK_FLAGM,       "+flagm", "-flagm")
 #undef AARCH64_ARCH_EXT_NAME
 
 #ifndef AARCH64_CPU_NAME
 #define AARCH64_CPU_NAME(NAME, ID, DEFAULT_FPU, IS_DEFAULT, DEFAULT_EXT)
 #endif
+AARCH64_CPU_NAME("cortex-a34", ARMV8A, FK_CRYPTO_NEON_FP_ARMV8, false,
+                 (AArch64::AEK_CRC))
 AARCH64_CPU_NAME("cortex-a35", ARMV8A, FK_CRYPTO_NEON_FP_ARMV8, false,
                  (AArch64::AEK_CRC))
 AARCH64_CPU_NAME("cortex-a53", ARMV8A, FK_CRYPTO_NEON_FP_ARMV8, true,
@@ -92,6 +125,12 @@
                  (AArch64::AEK_FP16 | AArch64::AEK_DOTPROD | AArch64::AEK_RCPC))
 AARCH64_CPU_NAME("cortex-a57", ARMV8A, FK_CRYPTO_NEON_FP_ARMV8, false,
                  (AArch64::AEK_CRC))
+AARCH64_CPU_NAME("cortex-a65", ARMV8_2A, FK_CRYPTO_NEON_FP_ARMV8, false,
+                 (AArch64::AEK_DOTPROD | AArch64::AEK_FP16 | AArch64::AEK_RAS |
+                  AArch64::AEK_RCPC | AArch64::AEK_SSBS))
+AARCH64_CPU_NAME("cortex-a65ae", ARMV8_2A, FK_CRYPTO_NEON_FP_ARMV8, false,
+                 (AArch64::AEK_DOTPROD | AArch64::AEK_FP16 | AArch64::AEK_RAS |
+                  AArch64::AEK_RCPC | AArch64::AEK_SSBS))
 AARCH64_CPU_NAME("cortex-a72", ARMV8A, FK_CRYPTO_NEON_FP_ARMV8, false,
                  (AArch64::AEK_CRC))
 AARCH64_CPU_NAME("cortex-a73", ARMV8A, FK_CRYPTO_NEON_FP_ARMV8, false,
@@ -104,12 +143,56 @@
 AARCH64_CPU_NAME("cortex-a76ae", ARMV8_2A, FK_CRYPTO_NEON_FP_ARMV8, false,
                  (AArch64::AEK_FP16 | AArch64::AEK_DOTPROD | AArch64::AEK_RCPC |
                   AArch64::AEK_SSBS))
+AARCH64_CPU_NAME("cortex-a77", ARMV8_2A, FK_CRYPTO_NEON_FP_ARMV8, false,
+                 (AArch64::AEK_FP16 | AArch64::AEK_RCPC | AArch64::AEK_DOTPROD |
+                  AArch64::AEK_SSBS))
+AARCH64_CPU_NAME("cortex-a78", ARMV8_2A, FK_CRYPTO_NEON_FP_ARMV8, false,
+                 (AArch64::AEK_FP16 | AArch64::AEK_DOTPROD | AArch64::AEK_RCPC |
+                  AArch64::AEK_SSBS))
+AARCH64_CPU_NAME("cortex-a78c", ARMV8_2A, FK_CRYPTO_NEON_FP_ARMV8, false,
+                 (AArch64::AEK_FP16 | AArch64::AEK_DOTPROD | AArch64::AEK_RCPC |
+                  AArch64::AEK_SSBS))
+AARCH64_CPU_NAME("cortex-r82", ARMV8R, FK_CRYPTO_NEON_FP_ARMV8, false,
+                 (AArch64::AEK_LSE))
+AARCH64_CPU_NAME("cortex-x1", ARMV8_2A, FK_CRYPTO_NEON_FP_ARMV8, false,
+                 (AArch64::AEK_FP16 | AArch64::AEK_DOTPROD | AArch64::AEK_RCPC |
+                  AArch64::AEK_SSBS))
+AARCH64_CPU_NAME("neoverse-e1", ARMV8_2A, FK_CRYPTO_NEON_FP_ARMV8, false,
+                 (AArch64::AEK_DOTPROD | AArch64::AEK_FP16 | AArch64::AEK_RAS |
+                  AArch64::AEK_RCPC | AArch64::AEK_SSBS))
+AARCH64_CPU_NAME("neoverse-n1", ARMV8_2A, FK_CRYPTO_NEON_FP_ARMV8, false,
+                 (AArch64::AEK_DOTPROD | AArch64::AEK_FP16 |
+                  AArch64::AEK_PROFILE | AArch64::AEK_RAS | AArch64::AEK_RCPC |
+                  AArch64::AEK_SSBS))
+AARCH64_CPU_NAME("neoverse-n2", ARMV8_5A, FK_CRYPTO_NEON_FP_ARMV8, false,
+                 (AArch64::AEK_BF16 | AArch64::AEK_DOTPROD | AArch64::AEK_FP16 |
+                  AArch64::AEK_I8MM | AArch64::AEK_MTE | AArch64::AEK_RAS |
+                  AArch64::AEK_RCPC | AArch64::AEK_SB | AArch64::AEK_SSBS |
+                  AArch64::AEK_SVE | AArch64::AEK_SVE2 | AArch64::AEK_SVE2BITPERM))
+AARCH64_CPU_NAME("neoverse-v1", ARMV8_4A, FK_CRYPTO_NEON_FP_ARMV8, false,
+                 (AArch64::AEK_RAS | AArch64::AEK_SVE | AArch64::AEK_SSBS |
+                  AArch64::AEK_RCPC | AArch64::AEK_FP16 | AArch64::AEK_BF16 |
+                  AArch64::AEK_DOTPROD ))
 AARCH64_CPU_NAME("cyclone", ARMV8A, FK_CRYPTO_NEON_FP_ARMV8, false,
                  (AArch64::AEK_NONE))
-AARCH64_CPU_NAME("exynos-m1", ARMV8A, FK_CRYPTO_NEON_FP_ARMV8, false,
-                 (AArch64::AEK_CRC))
-AARCH64_CPU_NAME("exynos-m2", ARMV8A, FK_CRYPTO_NEON_FP_ARMV8, false,
-                 (AArch64::AEK_CRC))
+AARCH64_CPU_NAME("apple-a7", ARMV8A, FK_CRYPTO_NEON_FP_ARMV8, false,
+                 (AArch64::AEK_NONE))
+AARCH64_CPU_NAME("apple-a8", ARMV8A, FK_CRYPTO_NEON_FP_ARMV8, false,
+                 (AArch64::AEK_NONE))
+AARCH64_CPU_NAME("apple-a9", ARMV8A, FK_CRYPTO_NEON_FP_ARMV8, false,
+                 (AArch64::AEK_NONE))
+AARCH64_CPU_NAME("apple-a10", ARMV8A, FK_CRYPTO_NEON_FP_ARMV8, false,
+                 (AArch64::AEK_CRC | AArch64::AEK_RDM))
+AARCH64_CPU_NAME("apple-a11", ARMV8_2A, FK_CRYPTO_NEON_FP_ARMV8, false,
+                 (AArch64::AEK_NONE))
+AARCH64_CPU_NAME("apple-a12", ARMV8_3A, FK_CRYPTO_NEON_FP_ARMV8, false,
+                 (AArch64::AEK_FP16))
+AARCH64_CPU_NAME("apple-a13", ARMV8_4A, FK_CRYPTO_NEON_FP_ARMV8, false,
+                 (AArch64::AEK_FP16 | AArch64::AEK_FP16FML))
+AARCH64_CPU_NAME("apple-s4", ARMV8_3A, FK_CRYPTO_NEON_FP_ARMV8, false,
+                 (AArch64::AEK_FP16))
+AARCH64_CPU_NAME("apple-s5", ARMV8_3A, FK_CRYPTO_NEON_FP_ARMV8, false,
+                 (AArch64::AEK_FP16))
 AARCH64_CPU_NAME("exynos-m3", ARMV8A, FK_CRYPTO_NEON_FP_ARMV8, false,
                  (AArch64::AEK_CRC))
 AARCH64_CPU_NAME("exynos-m4", ARMV8_2A, FK_CRYPTO_NEON_FP_ARMV8, false,
@@ -124,6 +207,10 @@
                  (AArch64::AEK_CRC))
 AARCH64_CPU_NAME("thunderx2t99", ARMV8_1A, FK_CRYPTO_NEON_FP_ARMV8, false,
                  (AArch64::AEK_NONE))
+AARCH64_CPU_NAME("thunderx3t110", ARMV8_3A, FK_CRYPTO_NEON_FP_ARMV8, false,
+                 (AArch64::AEK_CRC | AEK_CRYPTO | AEK_FP | AEK_SIMD |
+                  AEK_LSE | AEK_RAND | AArch64::AEK_PROFILE |
+                  AArch64::AEK_RAS))
 AARCH64_CPU_NAME("thunderx", ARMV8A, FK_CRYPTO_NEON_FP_ARMV8, false,
                  (AArch64::AEK_CRC | AArch64::AEK_PROFILE))
 AARCH64_CPU_NAME("thunderxt88", ARMV8A, FK_CRYPTO_NEON_FP_ARMV8, false,
@@ -136,6 +223,10 @@
                  (AArch64::AEK_DOTPROD |
                   AArch64::AEK_FP16 | AArch64::AEK_FP16FML |
                   AArch64::AEK_PROFILE))
+AARCH64_CPU_NAME("a64fx", ARMV8_2A, FK_CRYPTO_NEON_FP_ARMV8, false,
+                 (AArch64::AEK_FP16 | AArch64::AEK_SVE))
+AARCH64_CPU_NAME("carmel", ARMV8_2A, FK_CRYPTO_NEON_FP_ARMV8, false,
+                 AArch64::AEK_FP16)
 // Invalid CPU
 AARCH64_CPU_NAME("invalid", INVALID, FK_INVALID, true, AArch64::AEK_INVALID)
 #undef AARCH64_CPU_NAME
diff --git a/linux-x64/clang/include/llvm/Support/AArch64TargetParser.h b/linux-x64/clang/include/llvm/Support/AArch64TargetParser.h
index 965d385..7c9e245 100644
--- a/linux-x64/clang/include/llvm/Support/AArch64TargetParser.h
+++ b/linux-x64/clang/include/llvm/Support/AArch64TargetParser.h
@@ -14,17 +14,20 @@
 #ifndef LLVM_SUPPORT_AARCH64TARGETPARSERCOMMON_H
 #define LLVM_SUPPORT_AARCH64TARGETPARSERCOMMON_H
 
+#include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
-#include "llvm/ADT/Triple.h"
 #include "llvm/Support/ARMTargetParser.h"
 #include <vector>
 
 // FIXME:This should be made into class design,to avoid dupplication.
 namespace llvm {
+
+class Triple;
+
 namespace AArch64 {
 
 // Arch extension modifiers for CPUs.
-enum ArchExtKind : unsigned {
+enum ArchExtKind : uint64_t {
   AEK_INVALID =     0,
   AEK_NONE =        1,
   AEK_CRC =         1 << 1,
@@ -53,7 +56,16 @@
   AEK_SVE2AES =     1 << 24,
   AEK_SVE2SM4 =     1 << 25,
   AEK_SVE2SHA3 =    1 << 26,
-  AEK_BITPERM =     1 << 27,
+  AEK_SVE2BITPERM = 1 << 27,
+  AEK_TME =         1 << 28,
+  AEK_BF16 =        1 << 29,
+  AEK_I8MM =        1 << 30,
+  AEK_F32MM =       1ULL << 31,
+  AEK_F64MM =       1ULL << 32,
+  AEK_LS64 =        1ULL << 33,
+  AEK_BRBE =        1ULL << 34,
+  AEK_PAUTH =       1ULL << 35,
+  AEK_FLAGM =       1ULL << 36,
 };
 
 enum class ArchKind {
@@ -96,7 +108,7 @@
 };
 
 // FIXME: These should be moved to TargetTuple once it exists
-bool getExtensionFeatures(unsigned Extensions,
+bool getExtensionFeatures(uint64_t Extensions,
                           std::vector<StringRef> &Features);
 bool getArchFeatures(ArchKind AK, std::vector<StringRef> &Features);
 
@@ -109,7 +121,7 @@
 
 // Information by Name
 unsigned getDefaultFPU(StringRef CPU, ArchKind AK);
-unsigned getDefaultExtensions(StringRef CPU, ArchKind AK);
+uint64_t getDefaultExtensions(StringRef CPU, ArchKind AK);
 StringRef getDefaultCPU(StringRef Arch);
 ArchKind getCPUArchKind(StringRef CPU);
 
@@ -122,6 +134,15 @@
 
 bool isX18ReservedByDefault(const Triple &TT);
 
+struct ParsedBranchProtection {
+  StringRef Scope;
+  StringRef Key;
+  bool BranchTargetEnforcement;
+};
+
+bool parseBranchProtection(StringRef Spec, ParsedBranchProtection &PBP,
+                           StringRef &Err);
+
 } // namespace AArch64
 } // namespace llvm
 
diff --git a/linux-x64/clang/include/llvm/Support/AMDGPUMetadata.h b/linux-x64/clang/include/llvm/Support/AMDGPUMetadata.h
index f7f1ec4..920c97f 100644
--- a/linux-x64/clang/include/llvm/Support/AMDGPUMetadata.h
+++ b/linux-x64/clang/include/llvm/Support/AMDGPUMetadata.h
@@ -75,10 +75,12 @@
   HiddenDefaultQueue     = 12,
   HiddenCompletionAction = 13,
   HiddenMultiGridSyncArg = 14,
+  HiddenHostcallBuffer   = 15,
   Unknown                = 0xff
 };
 
-/// Value types.
+/// Value types. This is deprecated and only remains for compatibility parsing
+/// of old metadata.
 enum class ValueType : uint8_t {
   Struct  = 0,
   I8      = 1,
@@ -163,7 +165,7 @@
 constexpr char Align[] = "Align";
 /// Key for Kernel::Arg::Metadata::mValueKind.
 constexpr char ValueKind[] = "ValueKind";
-/// Key for Kernel::Arg::Metadata::mValueType.
+/// Key for Kernel::Arg::Metadata::mValueType. (deprecated)
 constexpr char ValueType[] = "ValueType";
 /// Key for Kernel::Arg::Metadata::mPointeeAlign.
 constexpr char PointeeAlign[] = "PointeeAlign";
@@ -197,8 +199,6 @@
   uint32_t mAlign = 0;
   /// Value kind. Required.
   ValueKind mValueKind = ValueKind::Unknown;
-  /// Value type. Required.
-  ValueType mValueType = ValueType::Unknown;
   /// Pointee alignment in bytes. Optional.
   uint32_t mPointeeAlign = 0;
   /// Address space qualifier. Optional.
diff --git a/linux-x64/clang/include/llvm/Support/AMDHSAKernelDescriptor.h b/linux-x64/clang/include/llvm/Support/AMDHSAKernelDescriptor.h
index d1c2147..bd84da4 100644
--- a/linux-x64/clang/include/llvm/Support/AMDHSAKernelDescriptor.h
+++ b/linux-x64/clang/include/llvm/Support/AMDHSAKernelDescriptor.h
@@ -100,7 +100,7 @@
 #define COMPUTE_PGM_RSRC2(NAME, SHIFT, WIDTH) \
   AMDHSA_BITS_ENUM_ENTRY(COMPUTE_PGM_RSRC2_ ## NAME, SHIFT, WIDTH)
 enum : int32_t {
-  COMPUTE_PGM_RSRC2(ENABLE_SGPR_PRIVATE_SEGMENT_WAVEFRONT_OFFSET, 0, 1),
+  COMPUTE_PGM_RSRC2(ENABLE_PRIVATE_SEGMENT, 0, 1),
   COMPUTE_PGM_RSRC2(USER_SGPR_COUNT, 1, 5),
   COMPUTE_PGM_RSRC2(ENABLE_TRAP_HANDLER, 6, 1),
   COMPUTE_PGM_RSRC2(ENABLE_SGPR_WORKGROUP_ID_X, 7, 1),
@@ -162,39 +162,49 @@
   uint8_t reserved2[6];
 };
 
+enum : uint32_t {
+  GROUP_SEGMENT_FIXED_SIZE_OFFSET = 0,
+  PRIVATE_SEGMENT_FIXED_SIZE_OFFSET = 4,
+  RESERVED0_OFFSET = 8,
+  KERNEL_CODE_ENTRY_BYTE_OFFSET_OFFSET = 16,
+  RESERVED1_OFFSET = 24,
+  COMPUTE_PGM_RSRC3_OFFSET = 44,
+  COMPUTE_PGM_RSRC1_OFFSET = 48,
+  COMPUTE_PGM_RSRC2_OFFSET = 52,
+  KERNEL_CODE_PROPERTIES_OFFSET = 56,
+  RESERVED2_OFFSET = 58,
+};
+
 static_assert(
     sizeof(kernel_descriptor_t) == 64,
     "invalid size for kernel_descriptor_t");
-static_assert(
-    offsetof(kernel_descriptor_t, group_segment_fixed_size) == 0,
-    "invalid offset for group_segment_fixed_size");
-static_assert(
-    offsetof(kernel_descriptor_t, private_segment_fixed_size) == 4,
-    "invalid offset for private_segment_fixed_size");
-static_assert(
-    offsetof(kernel_descriptor_t, reserved0) == 8,
-    "invalid offset for reserved0");
-static_assert(
-    offsetof(kernel_descriptor_t, kernel_code_entry_byte_offset) == 16,
-    "invalid offset for kernel_code_entry_byte_offset");
-static_assert(
-    offsetof(kernel_descriptor_t, reserved1) == 24,
-    "invalid offset for reserved1");
-static_assert(
-    offsetof(kernel_descriptor_t, compute_pgm_rsrc3) == 44,
-    "invalid offset for compute_pgm_rsrc3");
-static_assert(
-    offsetof(kernel_descriptor_t, compute_pgm_rsrc1) == 48,
-    "invalid offset for compute_pgm_rsrc1");
-static_assert(
-    offsetof(kernel_descriptor_t, compute_pgm_rsrc2) == 52,
-    "invalid offset for compute_pgm_rsrc2");
-static_assert(
-    offsetof(kernel_descriptor_t, kernel_code_properties) == 56,
-    "invalid offset for kernel_code_properties");
-static_assert(
-    offsetof(kernel_descriptor_t, reserved2) == 58,
-    "invalid offset for reserved2");
+static_assert(offsetof(kernel_descriptor_t, group_segment_fixed_size) ==
+                  GROUP_SEGMENT_FIXED_SIZE_OFFSET,
+              "invalid offset for group_segment_fixed_size");
+static_assert(offsetof(kernel_descriptor_t, private_segment_fixed_size) ==
+                  PRIVATE_SEGMENT_FIXED_SIZE_OFFSET,
+              "invalid offset for private_segment_fixed_size");
+static_assert(offsetof(kernel_descriptor_t, reserved0) == RESERVED0_OFFSET,
+              "invalid offset for reserved0");
+static_assert(offsetof(kernel_descriptor_t, kernel_code_entry_byte_offset) ==
+                  KERNEL_CODE_ENTRY_BYTE_OFFSET_OFFSET,
+              "invalid offset for kernel_code_entry_byte_offset");
+static_assert(offsetof(kernel_descriptor_t, reserved1) == RESERVED1_OFFSET,
+              "invalid offset for reserved1");
+static_assert(offsetof(kernel_descriptor_t, compute_pgm_rsrc3) ==
+                  COMPUTE_PGM_RSRC3_OFFSET,
+              "invalid offset for compute_pgm_rsrc3");
+static_assert(offsetof(kernel_descriptor_t, compute_pgm_rsrc1) ==
+                  COMPUTE_PGM_RSRC1_OFFSET,
+              "invalid offset for compute_pgm_rsrc1");
+static_assert(offsetof(kernel_descriptor_t, compute_pgm_rsrc2) ==
+                  COMPUTE_PGM_RSRC2_OFFSET,
+              "invalid offset for compute_pgm_rsrc2");
+static_assert(offsetof(kernel_descriptor_t, kernel_code_properties) ==
+                  KERNEL_CODE_PROPERTIES_OFFSET,
+              "invalid offset for kernel_code_properties");
+static_assert(offsetof(kernel_descriptor_t, reserved2) == RESERVED2_OFFSET,
+              "invalid offset for reserved2");
 
 } // end namespace amdhsa
 } // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/Support/ARMAttributeParser.h b/linux-x64/clang/include/llvm/Support/ARMAttributeParser.h
index f6c39ab..bf85ea1 100644
--- a/linux-x64/clang/include/llvm/Support/ARMAttributeParser.h
+++ b/linux-x64/clang/include/llvm/Support/ARMAttributeParser.h
@@ -1,4 +1,4 @@
-//===--- ARMAttributeParser.h - ARM Attribute Information Printer ---------===//
+//===- ARMAttributeParser.h - ARM Attribute Information Printer -*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -10,132 +10,71 @@
 #define LLVM_SUPPORT_ARMATTRIBUTEPARSER_H
 
 #include "ARMBuildAttributes.h"
+#include "ELFAttributeParser.h"
 #include "ScopedPrinter.h"
-
-#include <map>
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/Support/DataExtractor.h"
+#include "llvm/Support/Endian.h"
+#include "llvm/Support/Error.h"
 
 namespace llvm {
 class StringRef;
 
-class ARMAttributeParser {
-  ScopedPrinter *SW;
-
-  std::map<unsigned, unsigned> Attributes;
-
+class ARMAttributeParser : public ELFAttributeParser {
   struct DisplayHandler {
-    ARMBuildAttrs::AttrType Attribute;
-    void (ARMAttributeParser::*Routine)(ARMBuildAttrs::AttrType,
-                                        const uint8_t *, uint32_t &);
+    ARMBuildAttrs::AttrType attribute;
+    Error (ARMAttributeParser::*routine)(ARMBuildAttrs::AttrType);
   };
-  static const DisplayHandler DisplayRoutines[];
+  static const DisplayHandler displayRoutines[];
 
-  uint64_t ParseInteger(const uint8_t *Data, uint32_t &Offset);
-  StringRef ParseString(const uint8_t *Data, uint32_t &Offset);
+  Error handler(uint64_t tag, bool &handled) override;
 
-  void IntegerAttribute(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-                        uint32_t &Offset);
-  void StringAttribute(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-                       uint32_t &Offset);
+  Error stringAttribute(ARMBuildAttrs::AttrType tag);
 
-  void PrintAttribute(unsigned Tag, unsigned Value, StringRef ValueDesc);
+  Error CPU_arch(ARMBuildAttrs::AttrType tag);
+  Error CPU_arch_profile(ARMBuildAttrs::AttrType tag);
+  Error ARM_ISA_use(ARMBuildAttrs::AttrType tag);
+  Error THUMB_ISA_use(ARMBuildAttrs::AttrType tag);
+  Error FP_arch(ARMBuildAttrs::AttrType tag);
+  Error WMMX_arch(ARMBuildAttrs::AttrType tag);
+  Error Advanced_SIMD_arch(ARMBuildAttrs::AttrType tag);
+  Error MVE_arch(ARMBuildAttrs::AttrType tag);
+  Error PCS_config(ARMBuildAttrs::AttrType tag);
+  Error ABI_PCS_R9_use(ARMBuildAttrs::AttrType tag);
+  Error ABI_PCS_RW_data(ARMBuildAttrs::AttrType tag);
+  Error ABI_PCS_RO_data(ARMBuildAttrs::AttrType tag);
+  Error ABI_PCS_GOT_use(ARMBuildAttrs::AttrType tag);
+  Error ABI_PCS_wchar_t(ARMBuildAttrs::AttrType tag);
+  Error ABI_FP_rounding(ARMBuildAttrs::AttrType tag);
+  Error ABI_FP_denormal(ARMBuildAttrs::AttrType tag);
+  Error ABI_FP_exceptions(ARMBuildAttrs::AttrType tag);
+  Error ABI_FP_user_exceptions(ARMBuildAttrs::AttrType tag);
+  Error ABI_FP_number_model(ARMBuildAttrs::AttrType tag);
+  Error ABI_align_needed(ARMBuildAttrs::AttrType tag);
+  Error ABI_align_preserved(ARMBuildAttrs::AttrType tag);
+  Error ABI_enum_size(ARMBuildAttrs::AttrType tag);
+  Error ABI_HardFP_use(ARMBuildAttrs::AttrType tag);
+  Error ABI_VFP_args(ARMBuildAttrs::AttrType tag);
+  Error ABI_WMMX_args(ARMBuildAttrs::AttrType tag);
+  Error ABI_optimization_goals(ARMBuildAttrs::AttrType tag);
+  Error ABI_FP_optimization_goals(ARMBuildAttrs::AttrType tag);
+  Error compatibility(ARMBuildAttrs::AttrType tag);
+  Error CPU_unaligned_access(ARMBuildAttrs::AttrType tag);
+  Error FP_HP_extension(ARMBuildAttrs::AttrType tag);
+  Error ABI_FP_16bit_format(ARMBuildAttrs::AttrType tag);
+  Error MPextension_use(ARMBuildAttrs::AttrType tag);
+  Error DIV_use(ARMBuildAttrs::AttrType tag);
+  Error DSP_extension(ARMBuildAttrs::AttrType tag);
+  Error T2EE_use(ARMBuildAttrs::AttrType tag);
+  Error Virtualization_use(ARMBuildAttrs::AttrType tag);
+  Error nodefaults(ARMBuildAttrs::AttrType tag);
 
-  void CPU_arch(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-                uint32_t &Offset);
-  void CPU_arch_profile(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-                        uint32_t &Offset);
-  void ARM_ISA_use(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-                   uint32_t &Offset);
-  void THUMB_ISA_use(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-                     uint32_t &Offset);
-  void FP_arch(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-               uint32_t &Offset);
-  void WMMX_arch(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-                 uint32_t &Offset);
-  void Advanced_SIMD_arch(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-                          uint32_t &Offset);
-  void MVE_arch(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-                uint32_t &Offset);
-  void PCS_config(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-                  uint32_t &Offset);
-  void ABI_PCS_R9_use(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-                      uint32_t &Offset);
-  void ABI_PCS_RW_data(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-                       uint32_t &Offset);
-  void ABI_PCS_RO_data(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-                       uint32_t &Offset);
-  void ABI_PCS_GOT_use(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-                       uint32_t &Offset);
-  void ABI_PCS_wchar_t(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-                       uint32_t &Offset);
-  void ABI_FP_rounding(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-                       uint32_t &Offset);
-  void ABI_FP_denormal(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-                       uint32_t &Offset);
-  void ABI_FP_exceptions(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-                         uint32_t &Offset);
-  void ABI_FP_user_exceptions(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-                              uint32_t &Offset);
-  void ABI_FP_number_model(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-                           uint32_t &Offset);
-  void ABI_align_needed(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-                        uint32_t &Offset);
-  void ABI_align_preserved(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-                           uint32_t &Offset);
-  void ABI_enum_size(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-                     uint32_t &Offset);
-  void ABI_HardFP_use(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-                      uint32_t &Offset);
-  void ABI_VFP_args(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-                    uint32_t &Offset);
-  void ABI_WMMX_args(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-                     uint32_t &Offset);
-  void ABI_optimization_goals(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-                              uint32_t &Offset);
-  void ABI_FP_optimization_goals(ARMBuildAttrs::AttrType Tag,
-                                 const uint8_t *Data, uint32_t &Offset);
-  void compatibility(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-                     uint32_t &Offset);
-  void CPU_unaligned_access(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-                            uint32_t &Offset);
-  void FP_HP_extension(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-                       uint32_t &Offset);
-  void ABI_FP_16bit_format(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-                           uint32_t &Offset);
-  void MPextension_use(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-                       uint32_t &Offset);
-  void DIV_use(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-               uint32_t &Offset);
-  void DSP_extension(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-                     uint32_t &Offset);
-  void T2EE_use(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-                uint32_t &Offset);
-  void Virtualization_use(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-                          uint32_t &Offset);
-  void nodefaults(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
-                  uint32_t &Offset);
-
-  void ParseAttributeList(const uint8_t *Data, uint32_t &Offset,
-                          uint32_t Length);
-  void ParseIndexList(const uint8_t *Data, uint32_t &Offset,
-                      SmallVectorImpl<uint8_t> &IndexList);
-  void ParseSubsection(const uint8_t *Data, uint32_t Length);
 public:
-  ARMAttributeParser(ScopedPrinter *SW) : SW(SW) {}
-
-  ARMAttributeParser() : SW(nullptr) { }
-
-  void Parse(ArrayRef<uint8_t> Section, bool isLittle);
-
-  bool hasAttribute(unsigned Tag) const {
-    return Attributes.count(Tag);
-  }
-
-  unsigned getAttributeValue(unsigned Tag) const {
-    return Attributes.find(Tag)->second;
-  }
+  ARMAttributeParser(ScopedPrinter *sw)
+      : ELFAttributeParser(sw, ARMBuildAttrs::ARMAttributeTags, "aeabi") {}
+  ARMAttributeParser()
+      : ELFAttributeParser(ARMBuildAttrs::ARMAttributeTags, "aeabi") {}
 };
-
 }
 
 #endif
-
diff --git a/linux-x64/clang/include/llvm/Support/ARMBuildAttributes.h b/linux-x64/clang/include/llvm/Support/ARMBuildAttributes.h
index 90481ea..5a06fd6 100644
--- a/linux-x64/clang/include/llvm/Support/ARMBuildAttributes.h
+++ b/linux-x64/clang/include/llvm/Support/ARMBuildAttributes.h
@@ -18,77 +18,70 @@
 #ifndef LLVM_SUPPORT_ARMBUILDATTRIBUTES_H
 #define LLVM_SUPPORT_ARMBUILDATTRIBUTES_H
 
-namespace llvm {
-class StringRef;
+#include "llvm/Support/ELFAttributes.h"
 
+namespace llvm {
 namespace ARMBuildAttrs {
 
+extern const TagNameMap ARMAttributeTags;
+
 enum SpecialAttr {
   // This is for the .cpu asm attr. It translates into one or more
   // AttrType (below) entries in the .ARM.attributes section in the ELF.
   SEL_CPU
 };
 
-enum AttrType {
+enum AttrType : unsigned {
   // Rest correspond to ELF/.ARM.attributes
-  File                      = 1,
-  CPU_raw_name              = 4,
-  CPU_name                  = 5,
-  CPU_arch                  = 6,
-  CPU_arch_profile          = 7,
-  ARM_ISA_use               = 8,
-  THUMB_ISA_use             = 9,
-  FP_arch                   = 10,
-  WMMX_arch                 = 11,
-  Advanced_SIMD_arch        = 12,
-  PCS_config                = 13,
-  ABI_PCS_R9_use            = 14,
-  ABI_PCS_RW_data           = 15,
-  ABI_PCS_RO_data           = 16,
-  ABI_PCS_GOT_use           = 17,
-  ABI_PCS_wchar_t           = 18,
-  ABI_FP_rounding           = 19,
-  ABI_FP_denormal           = 20,
-  ABI_FP_exceptions         = 21,
-  ABI_FP_user_exceptions    = 22,
-  ABI_FP_number_model       = 23,
-  ABI_align_needed          = 24,
-  ABI_align_preserved       = 25,
-  ABI_enum_size             = 26,
-  ABI_HardFP_use            = 27,
-  ABI_VFP_args              = 28,
-  ABI_WMMX_args             = 29,
-  ABI_optimization_goals    = 30,
+  File = 1,
+  CPU_raw_name = 4,
+  CPU_name = 5,
+  CPU_arch = 6,
+  CPU_arch_profile = 7,
+  ARM_ISA_use = 8,
+  THUMB_ISA_use = 9,
+  FP_arch = 10,
+  WMMX_arch = 11,
+  Advanced_SIMD_arch = 12,
+  PCS_config = 13,
+  ABI_PCS_R9_use = 14,
+  ABI_PCS_RW_data = 15,
+  ABI_PCS_RO_data = 16,
+  ABI_PCS_GOT_use = 17,
+  ABI_PCS_wchar_t = 18,
+  ABI_FP_rounding = 19,
+  ABI_FP_denormal = 20,
+  ABI_FP_exceptions = 21,
+  ABI_FP_user_exceptions = 22,
+  ABI_FP_number_model = 23,
+  ABI_align_needed = 24,
+  ABI_align_preserved = 25,
+  ABI_enum_size = 26,
+  ABI_HardFP_use = 27,
+  ABI_VFP_args = 28,
+  ABI_WMMX_args = 29,
+  ABI_optimization_goals = 30,
   ABI_FP_optimization_goals = 31,
-  compatibility             = 32,
-  CPU_unaligned_access      = 34,
-  FP_HP_extension           = 36,
-  ABI_FP_16bit_format       = 38,
-  MPextension_use           = 42, // recoded from 70 (ABI r2.08)
-  DIV_use                   = 44,
-  DSP_extension             = 46,
-  MVE_arch                  = 48,
-  also_compatible_with      = 65,
-  conformance               = 67,
-  Virtualization_use        = 68,
+  compatibility = 32,
+  CPU_unaligned_access = 34,
+  FP_HP_extension = 36,
+  ABI_FP_16bit_format = 38,
+  MPextension_use = 42, // recoded from 70 (ABI r2.08)
+  DIV_use = 44,
+  DSP_extension = 46,
+  MVE_arch = 48,
+  also_compatible_with = 65,
+  conformance = 67,
+  Virtualization_use = 68,
 
   /// Legacy Tags
-  Section                   = 2,  // deprecated (ABI r2.09)
-  Symbol                    = 3,  // deprecated (ABI r2.09)
-  ABI_align8_needed         = 24, // renamed to ABI_align_needed (ABI r2.09)
-  ABI_align8_preserved      = 25, // renamed to ABI_align_preserved (ABI r2.09)
-  nodefaults                = 64, // deprecated (ABI r2.09)
-  T2EE_use                  = 66, // deprecated (ABI r2.09)
-  MPextension_use_old       = 70  // recoded to MPextension_use (ABI r2.08)
-};
-
-StringRef AttrTypeAsString(unsigned Attr, bool HasTagPrefix = true);
-StringRef AttrTypeAsString(AttrType Attr, bool HasTagPrefix = true);
-int AttrTypeFromString(StringRef Tag);
-
-// Magic numbers for .ARM.attributes
-enum AttrMagic {
-  Format_Version  = 0x41
+  Section = 2,               // deprecated (ABI r2.09)
+  Symbol = 3,                // deprecated (ABI r2.09)
+  ABI_align8_needed = 24,    // renamed to ABI_align_needed (ABI r2.09)
+  ABI_align8_preserved = 25, // renamed to ABI_align_preserved (ABI r2.09)
+  nodefaults = 64,           // deprecated (ABI r2.09)
+  T2EE_use = 66,             // deprecated (ABI r2.09)
+  MPextension_use_old = 70   // recoded to MPextension_use (ABI r2.08)
 };
 
 // Legal Values for CPU_arch, (=6), uleb128
diff --git a/linux-x64/clang/include/llvm/Support/ARMTargetParser.def b/linux-x64/clang/include/llvm/Support/ARMTargetParser.def
index 593480f..37cf0a9 100644
--- a/linux-x64/clang/include/llvm/Support/ARMTargetParser.def
+++ b/linux-x64/clang/include/llvm/Support/ARMTargetParser.def
@@ -112,6 +112,18 @@
          (ARM::AEK_SEC | ARM::AEK_MP | ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
           ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP | ARM::AEK_CRC | ARM::AEK_RAS |
           ARM::AEK_DOTPROD))
+ARM_ARCH("armv8.6-a", ARMV8_6A, "8.6-A", "v8.6a",
+         ARMBuildAttrs::CPUArch::v8_A, FK_CRYPTO_NEON_FP_ARMV8,
+         (ARM::AEK_SEC        | ARM::AEK_MP   | ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
+          ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP  | ARM::AEK_CRC  | ARM::AEK_RAS |
+          ARM::AEK_DOTPROD    | ARM::AEK_BF16 | ARM::AEK_SHA2 | ARM::AEK_AES |
+          ARM::AEK_I8MM))
+ARM_ARCH("armv8.7-a", ARMV8_7A, "8.7-A", "v8.7a",
+         ARMBuildAttrs::CPUArch::v8_A, FK_CRYPTO_NEON_FP_ARMV8,
+         (ARM::AEK_SEC        | ARM::AEK_MP   | ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
+          ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP  | ARM::AEK_CRC  | ARM::AEK_RAS |
+          ARM::AEK_DOTPROD    | ARM::AEK_BF16 | ARM::AEK_SHA2 | ARM::AEK_AES |
+          ARM::AEK_I8MM))
 ARM_ARCH("armv8-r", ARMV8R, "8-R", "v8r", ARMBuildAttrs::CPUArch::v8_R,
           FK_NEON_FP_ARMV8,
           (ARM::AEK_MP | ARM::AEK_VIRT | ARM::AEK_HWDIVARM | ARM::AEK_HWDIVTHUMB |
@@ -148,8 +160,9 @@
 ARM_ARCH_EXT_NAME("dotprod",  ARM::AEK_DOTPROD,  "+dotprod","-dotprod")
 ARM_ARCH_EXT_NAME("dsp",      ARM::AEK_DSP,      "+dsp",   "-dsp")
 ARM_ARCH_EXT_NAME("fp",       ARM::AEK_FP,       nullptr,  nullptr)
-ARM_ARCH_EXT_NAME("mve",      ARM::AEK_SIMD,     "+mve",   "-mve")
-ARM_ARCH_EXT_NAME("mve.fp",   (ARM::AEK_SIMD | ARM::AEK_FP), "+mve.fp", "-mve.fp")
+ARM_ARCH_EXT_NAME("fp.dp",    ARM::AEK_FP_DP,    nullptr,  nullptr)
+ARM_ARCH_EXT_NAME("mve",     (ARM::AEK_DSP | ARM::AEK_SIMD), "+mve", "-mve")
+ARM_ARCH_EXT_NAME("mve.fp",  (ARM::AEK_DSP | ARM::AEK_SIMD | ARM::AEK_FP), "+mve.fp", "-mve.fp")
 ARM_ARCH_EXT_NAME("idiv",     (ARM::AEK_HWDIVARM | ARM::AEK_HWDIVTHUMB), nullptr, nullptr)
 ARM_ARCH_EXT_NAME("mp",       ARM::AEK_MP,       nullptr,  nullptr)
 ARM_ARCH_EXT_NAME("simd",     ARM::AEK_SIMD,     nullptr,  nullptr)
@@ -163,8 +176,18 @@
 ARM_ARCH_EXT_NAME("maverick", ARM::AEK_MAVERICK, nullptr,  nullptr)
 ARM_ARCH_EXT_NAME("xscale",   ARM::AEK_XSCALE,   nullptr,  nullptr)
 ARM_ARCH_EXT_NAME("fp16fml",  ARM::AEK_FP16FML,  "+fp16fml", "-fp16fml")
+ARM_ARCH_EXT_NAME("bf16",     ARM::AEK_BF16,     "+bf16",    "-bf16")
 ARM_ARCH_EXT_NAME("sb",       ARM::AEK_SB,       "+sb",      "-sb")
+ARM_ARCH_EXT_NAME("i8mm",     ARM::AEK_I8MM,     "+i8mm",    "-i8mm")
 ARM_ARCH_EXT_NAME("lob",      ARM::AEK_LOB,      "+lob",   "-lob")
+ARM_ARCH_EXT_NAME("cdecp0",   ARM::AEK_CDECP0,   "+cdecp0",  "-cdecp0")
+ARM_ARCH_EXT_NAME("cdecp1",   ARM::AEK_CDECP1,   "+cdecp1",  "-cdecp1")
+ARM_ARCH_EXT_NAME("cdecp2",   ARM::AEK_CDECP2,   "+cdecp2",  "-cdecp2")
+ARM_ARCH_EXT_NAME("cdecp3",   ARM::AEK_CDECP3,   "+cdecp3",  "-cdecp3")
+ARM_ARCH_EXT_NAME("cdecp4",   ARM::AEK_CDECP4,   "+cdecp4",  "-cdecp4")
+ARM_ARCH_EXT_NAME("cdecp5",   ARM::AEK_CDECP5,   "+cdecp5",  "-cdecp5")
+ARM_ARCH_EXT_NAME("cdecp6",   ARM::AEK_CDECP6,   "+cdecp6",  "-cdecp6")
+ARM_ARCH_EXT_NAME("cdecp7",   ARM::AEK_CDECP7,   "+cdecp7",  "-cdecp7")
 #undef ARM_ARCH_EXT_NAME
 
 #ifndef ARM_HW_DIV_NAME
@@ -259,6 +282,8 @@
 ARM_CPU_NAME("cortex-m23", ARMV8MBaseline, FK_NONE, false, ARM::AEK_NONE)
 ARM_CPU_NAME("cortex-m33", ARMV8MMainline, FK_FPV5_SP_D16, false, ARM::AEK_DSP)
 ARM_CPU_NAME("cortex-m35p", ARMV8MMainline, FK_FPV5_SP_D16, false, ARM::AEK_DSP)
+ARM_CPU_NAME("cortex-m55", ARMV8_1MMainline, FK_FP_ARMV8_FULLFP16_D16, false,
+             (ARM::AEK_DSP | ARM::AEK_SIMD | ARM::AEK_FP | ARM::AEK_FP16))
 ARM_CPU_NAME("cortex-a32", ARMV8A, FK_CRYPTO_NEON_FP_ARMV8, false, ARM::AEK_CRC)
 ARM_CPU_NAME("cortex-a35", ARMV8A, FK_CRYPTO_NEON_FP_ARMV8, false, ARM::AEK_CRC)
 ARM_CPU_NAME("cortex-a53", ARMV8A, FK_CRYPTO_NEON_FP_ARMV8, false, ARM::AEK_CRC)
@@ -273,9 +298,22 @@
             (ARM::AEK_FP16 | ARM::AEK_DOTPROD))
 ARM_CPU_NAME("cortex-a76ae", ARMV8_2A, FK_CRYPTO_NEON_FP_ARMV8, false,
             (ARM::AEK_FP16 | ARM::AEK_DOTPROD))
+ARM_CPU_NAME("cortex-a77", ARMV8_2A, FK_CRYPTO_NEON_FP_ARMV8, false,
+            (ARM::AEK_FP16 | ARM::AEK_DOTPROD))
+ARM_CPU_NAME("cortex-a78", ARMV8_2A, FK_CRYPTO_NEON_FP_ARMV8, false,
+             (ARM::AEK_FP16 | ARM::AEK_DOTPROD))
+ARM_CPU_NAME("cortex-a78c", ARMV8_2A, FK_CRYPTO_NEON_FP_ARMV8, false,
+             ARM::AEK_FP16 | ARM::AEK_DOTPROD)
+ARM_CPU_NAME("cortex-x1", ARMV8_2A, FK_CRYPTO_NEON_FP_ARMV8, false,
+             (ARM::AEK_FP16 | ARM::AEK_DOTPROD))
+ARM_CPU_NAME("neoverse-n1", ARMV8_2A, FK_CRYPTO_NEON_FP_ARMV8, false,
+             (ARM::AEK_FP16 | ARM::AEK_DOTPROD))
+ARM_CPU_NAME("neoverse-n2", ARMV8_5A, FK_CRYPTO_NEON_FP_ARMV8, false,
+             (ARM::AEK_BF16 | ARM::AEK_DOTPROD | ARM::AEK_I8MM | ARM::AEK_RAS |
+              ARM::AEK_SB))
+ARM_CPU_NAME("neoverse-v1", ARMV8_4A, FK_CRYPTO_NEON_FP_ARMV8, false,
+             (ARM::AEK_RAS | ARM::AEK_FP16 | ARM::AEK_BF16 | ARM::AEK_DOTPROD))
 ARM_CPU_NAME("cyclone", ARMV8A, FK_CRYPTO_NEON_FP_ARMV8, false, ARM::AEK_CRC)
-ARM_CPU_NAME("exynos-m1", ARMV8A, FK_CRYPTO_NEON_FP_ARMV8, false, ARM::AEK_CRC)
-ARM_CPU_NAME("exynos-m2", ARMV8A, FK_CRYPTO_NEON_FP_ARMV8, false, ARM::AEK_CRC)
 ARM_CPU_NAME("exynos-m3", ARMV8A, FK_CRYPTO_NEON_FP_ARMV8, false, ARM::AEK_CRC)
 ARM_CPU_NAME("exynos-m4", ARMV8_2A, FK_CRYPTO_NEON_FP_ARMV8, false,
              (ARM::AEK_FP16 | ARM::AEK_DOTPROD))
diff --git a/linux-x64/clang/include/llvm/Support/ARMTargetParser.h b/linux-x64/clang/include/llvm/Support/ARMTargetParser.h
index 4b9070d..7dd2abd 100644
--- a/linux-x64/clang/include/llvm/Support/ARMTargetParser.h
+++ b/linux-x64/clang/include/llvm/Support/ARMTargetParser.h
@@ -14,17 +14,20 @@
 #ifndef LLVM_SUPPORT_ARMTARGETPARSER_H
 #define LLVM_SUPPORT_ARMTARGETPARSER_H
 
+#include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
-#include "llvm/ADT/Triple.h"
 #include "llvm/Support/ARMBuildAttributes.h"
 #include <vector>
 
 namespace llvm {
+
+class Triple;
+
 namespace ARM {
 
 // Arch extension modifiers for CPUs.
 // Note that this is not the same as the AArch64 list
-enum ArchExtKind : unsigned {
+enum ArchExtKind : uint64_t {
   AEK_INVALID =     0,
   AEK_NONE =        1,
   AEK_CRC =         1 << 1,
@@ -39,25 +42,30 @@
   AEK_DSP =         1 << 10,
   AEK_FP16 =        1 << 11,
   AEK_RAS =         1 << 12,
-  AEK_SVE =         1 << 13,
-  AEK_DOTPROD =     1 << 14,
-  AEK_SHA2    =     1 << 15,
-  AEK_AES     =     1 << 16,
-  AEK_FP16FML =     1 << 17,
-  AEK_SB      =     1 << 18,
-  AEK_SVE2 =        1 << 19,
-  AEK_SVE2AES =     1 << 20,
-  AEK_SVE2SM4 =     1 << 21,
-  AEK_SVE2SHA3 =    1 << 22,
-  AEK_BITPERM =     1 << 23,
-  AEK_FP_DP   =     1 << 24,
-  AEK_LOB     =     1 << 25,
+  AEK_DOTPROD =     1 << 13,
+  AEK_SHA2    =     1 << 14,
+  AEK_AES     =     1 << 15,
+  AEK_FP16FML =     1 << 16,
+  AEK_SB      =     1 << 17,
+  AEK_FP_DP   =     1 << 18,
+  AEK_LOB     =     1 << 19,
+  AEK_BF16    =     1 << 20,
+  AEK_I8MM    =     1 << 21,
+  AEK_CDECP0 =      1 << 22,
+  AEK_CDECP1 =      1 << 23,
+  AEK_CDECP2 =      1 << 24,
+  AEK_CDECP3 =      1 << 25,
+  AEK_CDECP4 =      1 << 26,
+  AEK_CDECP5 =      1 << 27,
+  AEK_CDECP6 =      1 << 28,
+  AEK_CDECP7 =      1 << 29,
+
   // Unsupported extensions.
-  AEK_OS = 0x8000000,
-  AEK_IWMMXT = 0x10000000,
-  AEK_IWMMXT2 = 0x20000000,
-  AEK_MAVERICK = 0x40000000,
-  AEK_XSCALE = 0x80000000,
+  AEK_OS       =    1ULL << 59,
+  AEK_IWMMXT   =    1ULL << 60,
+  AEK_IWMMXT2  =    1ULL << 61,
+  AEK_MAVERICK =    1ULL << 62,
+  AEK_XSCALE   =    1ULL << 63,
 };
 
 // List of Arch Extension names.
@@ -65,7 +73,7 @@
 struct ExtName {
   const char *NameCStr;
   size_t NameLength;
-  unsigned ID;
+  uint64_t ID;
   const char *Feature;
   const char *NegFeature;
 
@@ -84,7 +92,7 @@
 const struct {
   const char *NameCStr;
   size_t NameLength;
-  unsigned ID;
+  uint64_t ID;
 
   StringRef getName() const { return StringRef(NameCStr, NameLength); }
 } HWDivNames[] = {
@@ -108,7 +116,7 @@
   size_t NameLength;
   T ArchID;
   bool Default; // is $Name the default CPU for $ArchID ?
-  unsigned DefaultExtensions;
+  uint64_t DefaultExtensions;
 
   StringRef getName() const { return StringRef(NameCStr, NameLength); }
 };
@@ -199,7 +207,7 @@
   const char *SubArchCStr;
   size_t SubArchLength;
   unsigned DefaultFPU;
-  unsigned ArchBaseExtensions;
+  uint64_t ArchBaseExtensions;
   T ID;
   ARMBuildAttrs::CPUArch ArchAttr; // Arch ID in build attributes.
 
@@ -231,33 +239,34 @@
 
 // FIXME: These should be moved to TargetTuple once it exists
 bool getFPUFeatures(unsigned FPUKind, std::vector<StringRef> &Features);
-bool getHWDivFeatures(unsigned HWDivKind, std::vector<StringRef> &Features);
-bool getExtensionFeatures(unsigned Extensions,
+bool getHWDivFeatures(uint64_t HWDivKind, std::vector<StringRef> &Features);
+bool getExtensionFeatures(uint64_t Extensions,
                           std::vector<StringRef> &Features);
 
 StringRef getArchName(ArchKind AK);
 unsigned getArchAttr(ArchKind AK);
 StringRef getCPUAttr(ArchKind AK);
 StringRef getSubArch(ArchKind AK);
-StringRef getArchExtName(unsigned ArchExtKind);
+StringRef getArchExtName(uint64_t ArchExtKind);
 StringRef getArchExtFeature(StringRef ArchExt);
 bool appendArchExtFeatures(StringRef CPU, ARM::ArchKind AK, StringRef ArchExt,
-                           std::vector<StringRef> &Features);
-StringRef getHWDivName(unsigned HWDivKind);
+                           std::vector<StringRef> &Features,
+                           unsigned &ArgFPUKind);
+StringRef getHWDivName(uint64_t HWDivKind);
 
 // Information by Name
 unsigned getDefaultFPU(StringRef CPU, ArchKind AK);
-unsigned getDefaultExtensions(StringRef CPU, ArchKind AK);
+uint64_t getDefaultExtensions(StringRef CPU, ArchKind AK);
 StringRef getDefaultCPU(StringRef Arch);
 StringRef getCanonicalArchName(StringRef Arch);
 StringRef getFPUSynonym(StringRef FPU);
 StringRef getArchSynonym(StringRef Arch);
 
 // Parser
-unsigned parseHWDiv(StringRef HWDiv);
+uint64_t parseHWDiv(StringRef HWDiv);
 unsigned parseFPU(StringRef FPU);
 ArchKind parseArch(StringRef Arch);
-unsigned parseArchExt(StringRef ArchExt);
+uint64_t parseArchExt(StringRef ArchExt);
 ArchKind parseCPUArch(StringRef CPU);
 ISAKind parseArchISA(StringRef Arch);
 EndianKind parseArchEndian(StringRef Arch);
diff --git a/linux-x64/clang/include/llvm/Support/ARMWinEH.h b/linux-x64/clang/include/llvm/Support/ARMWinEH.h
index 857a0d3..327aa98 100644
--- a/linux-x64/clang/include/llvm/Support/ARMWinEH.h
+++ b/linux-x64/clang/include/llvm/Support/ARMWinEH.h
@@ -31,6 +31,9 @@
 
 /// RuntimeFunction - An entry in the table of procedure data (.pdata)
 ///
+/// This is ARM specific, but the Function Start RVA, Flag and
+/// ExceptionInformationRVA fields work identically for ARM64.
+///
 ///  3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0
 ///  1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
 /// +---------------------------------------------------------------+
@@ -204,6 +207,85 @@
 /// purpose (r0-r15) and VFP (d0-d31) registers.
 std::pair<uint16_t, uint32_t> SavedRegisterMask(const RuntimeFunction &RF);
 
+/// RuntimeFunctionARM64 - An entry in the table of procedure data (.pdata)
+///
+///  3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0
+///  1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
+/// +---------------------------------------------------------------+
+/// |                     Function Start RVA                        |
+/// +-----------------+---+-+-------+-----+---------------------+---+
+/// |    Frame Size   |CR |H| RegI  |RegF |   Function Length   |Flg|
+/// +-----------------+---+-+-------+-----+---------------------+---+
+///
+/// See https://docs.microsoft.com/en-us/cpp/build/arm64-exception-handling
+/// for the full reference for this struct.
+
+class RuntimeFunctionARM64 {
+public:
+  const support::ulittle32_t BeginAddress;
+  const support::ulittle32_t UnwindData;
+
+  RuntimeFunctionARM64(const support::ulittle32_t *Data)
+      : BeginAddress(Data[0]), UnwindData(Data[1]) {}
+
+  RuntimeFunctionARM64(const support::ulittle32_t BeginAddress,
+                       const support::ulittle32_t UnwindData)
+      : BeginAddress(BeginAddress), UnwindData(UnwindData) {}
+
+  RuntimeFunctionFlag Flag() const {
+    return RuntimeFunctionFlag(UnwindData & 0x3);
+  }
+
+  uint32_t ExceptionInformationRVA() const {
+    assert(Flag() == RuntimeFunctionFlag::RFF_Unpacked &&
+           "unpacked form required for this operation");
+    return (UnwindData & ~0x3);
+  }
+
+  uint32_t PackedUnwindData() const {
+    assert((Flag() == RuntimeFunctionFlag::RFF_Packed ||
+            Flag() == RuntimeFunctionFlag::RFF_PackedFragment) &&
+           "packed form required for this operation");
+    return (UnwindData & ~0x3);
+  }
+  uint32_t FunctionLength() const {
+    assert((Flag() == RuntimeFunctionFlag::RFF_Packed ||
+            Flag() == RuntimeFunctionFlag::RFF_PackedFragment) &&
+           "packed form required for this operation");
+    return (((UnwindData & 0x00001ffc) >> 2) << 2);
+  }
+  uint8_t RegF() const {
+    assert((Flag() == RuntimeFunctionFlag::RFF_Packed ||
+            Flag() == RuntimeFunctionFlag::RFF_PackedFragment) &&
+           "packed form required for this operation");
+    return ((UnwindData & 0x0000e000) >> 13);
+  }
+  uint8_t RegI() const {
+    assert((Flag() == RuntimeFunctionFlag::RFF_Packed ||
+            Flag() == RuntimeFunctionFlag::RFF_PackedFragment) &&
+           "packed form required for this operation");
+    return ((UnwindData & 0x000f0000) >> 16);
+  }
+  bool H() const {
+    assert((Flag() == RuntimeFunctionFlag::RFF_Packed ||
+            Flag() == RuntimeFunctionFlag::RFF_PackedFragment) &&
+           "packed form required for this operation");
+    return ((UnwindData & 0x00100000) >> 20);
+  }
+  uint8_t CR() const {
+    assert((Flag() == RuntimeFunctionFlag::RFF_Packed ||
+            Flag() == RuntimeFunctionFlag::RFF_PackedFragment) &&
+           "packed form required for this operation");
+    return ((UnwindData & 0x600000) >> 21);
+  }
+  uint16_t FrameSize() const {
+    assert((Flag() == RuntimeFunctionFlag::RFF_Packed ||
+            Flag() == RuntimeFunctionFlag::RFF_PackedFragment) &&
+           "packed form required for this operation");
+    return ((UnwindData & 0xff800000) >> 23);
+  }
+};
+
 /// ExceptionDataRecord - An entry in the table of exception data (.xdata)
 ///
 /// The format on ARM is:
@@ -416,12 +498,13 @@
 
   uint32_t ExceptionHandlerRVA() const {
     assert(X() && "Exception Handler RVA is only valid if the X bit is set");
-    return Data[HeaderWords(*this) + EpilogueCount() + CodeWords()];
+    return Data[HeaderWords(*this) + (E() ? 0 : EpilogueCount()) + CodeWords()];
   }
 
   uint32_t ExceptionHandlerParameter() const {
     assert(X() && "Exception Handler RVA is only valid if the X bit is set");
-    return Data[HeaderWords(*this) + EpilogueCount() + CodeWords() + 1];
+    return Data[HeaderWords(*this) + (E() ? 0 : EpilogueCount()) + CodeWords() +
+                1];
   }
 };
 
diff --git a/linux-x64/clang/include/llvm/Support/AlignOf.h b/linux-x64/clang/include/llvm/Support/AlignOf.h
index d12401f..f586d7f 100644
--- a/linux-x64/clang/include/llvm/Support/AlignOf.h
+++ b/linux-x64/clang/include/llvm/Support/AlignOf.h
@@ -6,140 +6,29 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// This file defines the AlignedCharArray and AlignedCharArrayUnion classes.
+// This file defines the AlignedCharArrayUnion class.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_ALIGNOF_H
 #define LLVM_SUPPORT_ALIGNOF_H
 
-#include "llvm/Support/Compiler.h"
-#include <cstddef>
+#include <type_traits>
 
 namespace llvm {
 
-/// \struct AlignedCharArray
-/// Helper for building an aligned character array type.
+/// A suitably aligned and sized character array member which can hold elements
+/// of any type.
 ///
-/// This template is used to explicitly build up a collection of aligned
-/// character array types. We have to build these up using a macro and explicit
-/// specialization to cope with MSVC (at least till 2015) where only an
-/// integer literal can be used to specify an alignment constraint. Once built
-/// up here, we can then begin to indirect between these using normal C++
-/// template parameters.
-
-// MSVC requires special handling here.
-#ifndef _MSC_VER
-
-template<std::size_t Alignment, std::size_t Size>
-struct AlignedCharArray {
-  alignas(Alignment) char buffer[Size];
+/// This template is equivalent to std::aligned_union_t<1, ...>, but we cannot
+/// use it due to a bug in the MSVC x86 compiler:
+/// https://github.com/microsoft/STL/issues/1533
+/// Using `alignas` here works around the bug.
+template <typename T, typename... Ts> struct AlignedCharArrayUnion {
+  using AlignedUnion = std::aligned_union_t<1, T, Ts...>;
+  alignas(alignof(AlignedUnion)) char buffer[sizeof(AlignedUnion)];
 };
 
-#else // _MSC_VER
-
-/// Create a type with an aligned char buffer.
-template<std::size_t Alignment, std::size_t Size>
-struct AlignedCharArray;
-
-// We provide special variations of this template for the most common
-// alignments because __declspec(align(...)) doesn't actually work when it is
-// a member of a by-value function argument in MSVC, even if the alignment
-// request is something reasonably like 8-byte or 16-byte. Note that we can't
-// even include the declspec with the union that forces the alignment because
-// MSVC warns on the existence of the declspec despite the union member forcing
-// proper alignment.
-
-template<std::size_t Size>
-struct AlignedCharArray<1, Size> {
-  union {
-    char aligned;
-    char buffer[Size];
-  };
-};
-
-template<std::size_t Size>
-struct AlignedCharArray<2, Size> {
-  union {
-    short aligned;
-    char buffer[Size];
-  };
-};
-
-template<std::size_t Size>
-struct AlignedCharArray<4, Size> {
-  union {
-    int aligned;
-    char buffer[Size];
-  };
-};
-
-template<std::size_t Size>
-struct AlignedCharArray<8, Size> {
-  union {
-    double aligned;
-    char buffer[Size];
-  };
-};
-
-
-// The rest of these are provided with a __declspec(align(...)) and we simply
-// can't pass them by-value as function arguments on MSVC.
-
-#define LLVM_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT(x) \
-  template<std::size_t Size> \
-  struct AlignedCharArray<x, Size> { \
-    __declspec(align(x)) char buffer[Size]; \
-  };
-
-LLVM_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT(16)
-LLVM_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT(32)
-LLVM_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT(64)
-LLVM_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT(128)
-
-#undef LLVM_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT
-
-#endif // _MSC_VER
-
-namespace detail {
-template <typename T1,
-          typename T2 = char, typename T3 = char, typename T4 = char,
-          typename T5 = char, typename T6 = char, typename T7 = char,
-          typename T8 = char, typename T9 = char, typename T10 = char>
-class AlignerImpl {
-  T1 t1; T2 t2; T3 t3; T4 t4; T5 t5; T6 t6; T7 t7; T8 t8; T9 t9; T10 t10;
-
-  AlignerImpl() = delete;
-};
-
-template <typename T1,
-          typename T2 = char, typename T3 = char, typename T4 = char,
-          typename T5 = char, typename T6 = char, typename T7 = char,
-          typename T8 = char, typename T9 = char, typename T10 = char>
-union SizerImpl {
-  char arr1[sizeof(T1)], arr2[sizeof(T2)], arr3[sizeof(T3)], arr4[sizeof(T4)],
-       arr5[sizeof(T5)], arr6[sizeof(T6)], arr7[sizeof(T7)], arr8[sizeof(T8)],
-       arr9[sizeof(T9)], arr10[sizeof(T10)];
-};
-} // end namespace detail
-
-/// This union template exposes a suitably aligned and sized character
-/// array member which can hold elements of any of up to ten types.
-///
-/// These types may be arrays, structs, or any other types. The goal is to
-/// expose a char array buffer member which can be used as suitable storage for
-/// a placement new of any of these types. Support for more than ten types can
-/// be added at the cost of more boilerplate.
-template <typename T1,
-          typename T2 = char, typename T3 = char, typename T4 = char,
-          typename T5 = char, typename T6 = char, typename T7 = char,
-          typename T8 = char, typename T9 = char, typename T10 = char>
-struct AlignedCharArrayUnion : llvm::AlignedCharArray<
-    alignof(llvm::detail::AlignerImpl<T1, T2, T3, T4, T5,
-                                      T6, T7, T8, T9, T10>),
-    sizeof(::llvm::detail::SizerImpl<T1, T2, T3, T4, T5,
-                                     T6, T7, T8, T9, T10>)> {
-};
 } // end namespace llvm
 
 #endif // LLVM_SUPPORT_ALIGNOF_H
diff --git a/linux-x64/clang/include/llvm/Support/Alignment.h b/linux-x64/clang/include/llvm/Support/Alignment.h
new file mode 100644
index 0000000..667434e
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Support/Alignment.h
@@ -0,0 +1,375 @@
+//===-- llvm/Support/Alignment.h - Useful alignment functions ---*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains types to represent alignments.
+// They are instrumented to guarantee some invariants are preserved and prevent
+// invalid manipulations.
+//
+// - Align represents an alignment in bytes, it is always set and always a valid
+// power of two, its minimum value is 1 which means no alignment requirements.
+//
+// - MaybeAlign is an optional type, it may be undefined or set. When it's set
+// you can get the underlying Align type by using the getValue() method.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_SUPPORT_ALIGNMENT_H_
+#define LLVM_SUPPORT_ALIGNMENT_H_
+
+#include "llvm/ADT/Optional.h"
+#include "llvm/Support/MathExtras.h"
+#include <cassert>
+#ifndef NDEBUG
+#include <string>
+#endif // NDEBUG
+
+namespace llvm {
+
+#define ALIGN_CHECK_ISPOSITIVE(decl)                                           \
+  assert(decl > 0 && (#decl " should be defined"))
+
+/// This struct is a compact representation of a valid (non-zero power of two)
+/// alignment.
+/// It is suitable for use as static global constants.
+struct Align {
+private:
+  uint8_t ShiftValue = 0; /// The log2 of the required alignment.
+                          /// ShiftValue is less than 64 by construction.
+
+  friend struct MaybeAlign;
+  friend unsigned Log2(Align);
+  friend bool operator==(Align Lhs, Align Rhs);
+  friend bool operator!=(Align Lhs, Align Rhs);
+  friend bool operator<=(Align Lhs, Align Rhs);
+  friend bool operator>=(Align Lhs, Align Rhs);
+  friend bool operator<(Align Lhs, Align Rhs);
+  friend bool operator>(Align Lhs, Align Rhs);
+  friend unsigned encode(struct MaybeAlign A);
+  friend struct MaybeAlign decodeMaybeAlign(unsigned Value);
+
+  /// A trivial type to allow construction of constexpr Align.
+  /// This is currently needed to workaround a bug in GCC 5.3 which prevents
+  /// definition of constexpr assign operators.
+  /// https://stackoverflow.com/questions/46756288/explicitly-defaulted-function-cannot-be-declared-as-constexpr-because-the-implic
+  /// FIXME: Remove this, make all assign operators constexpr and introduce user
+  /// defined literals when we don't have to support GCC 5.3 anymore.
+  /// https://llvm.org/docs/GettingStarted.html#getting-a-modern-host-c-toolchain
+  struct LogValue {
+    uint8_t Log;
+  };
+
+public:
+  /// Default is byte-aligned.
+  constexpr Align() = default;
+  /// Do not perform checks in case of copy/move construct/assign, because the
+  /// checks have been performed when building `Other`.
+  constexpr Align(const Align &Other) = default;
+  constexpr Align(Align &&Other) = default;
+  Align &operator=(const Align &Other) = default;
+  Align &operator=(Align &&Other) = default;
+
+  explicit Align(uint64_t Value) {
+    assert(Value > 0 && "Value must not be 0");
+    assert(llvm::isPowerOf2_64(Value) && "Alignment is not a power of 2");
+    ShiftValue = Log2_64(Value);
+    assert(ShiftValue < 64 && "Broken invariant");
+  }
+
+  /// This is a hole in the type system and should not be abused.
+  /// Needed to interact with C for instance.
+  uint64_t value() const { return uint64_t(1) << ShiftValue; }
+
+  /// Returns a default constructed Align which corresponds to no alignment.
+  /// It was decided to deprecate Align::None because it's too close to
+  /// llvm::None which can be used to initialize `MaybeAlign`.
+  /// MaybeAlign = llvm::None means unspecified alignment,
+  /// Align = Align::None() means alignment of one byte.
+  LLVM_ATTRIBUTE_DEPRECATED(constexpr static const Align None(),
+                            "Use Align() or Align(1) instead") {
+    return Align();
+  }
+
+  /// Allow constructions of constexpr Align.
+  template <size_t kValue> constexpr static LogValue Constant() {
+    return LogValue{static_cast<uint8_t>(CTLog2<kValue>())};
+  }
+
+  /// Allow constructions of constexpr Align from types.
+  /// Compile time equivalent to Align(alignof(T)).
+  template <typename T> constexpr static LogValue Of() {
+    return Constant<std::alignment_of<T>::value>();
+  }
+
+  /// Constexpr constructor from LogValue type.
+  constexpr Align(LogValue CA) : ShiftValue(CA.Log) {}
+};
+
+/// Treats the value 0 as a 1, so Align is always at least 1.
+inline Align assumeAligned(uint64_t Value) {
+  return Value ? Align(Value) : Align();
+}
+
+/// This struct is a compact representation of a valid (power of two) or
+/// undefined (0) alignment.
+struct MaybeAlign : public llvm::Optional<Align> {
+private:
+  using UP = llvm::Optional<Align>;
+
+public:
+  /// Default is undefined.
+  MaybeAlign() = default;
+  /// Do not perform checks in case of copy/move construct/assign, because the
+  /// checks have been performed when building `Other`.
+  MaybeAlign(const MaybeAlign &Other) = default;
+  MaybeAlign &operator=(const MaybeAlign &Other) = default;
+  MaybeAlign(MaybeAlign &&Other) = default;
+  MaybeAlign &operator=(MaybeAlign &&Other) = default;
+
+  /// Use llvm::Optional<Align> constructor.
+  using UP::UP;
+
+  explicit MaybeAlign(uint64_t Value) {
+    assert((Value == 0 || llvm::isPowerOf2_64(Value)) &&
+           "Alignment is neither 0 nor a power of 2");
+    if (Value)
+      emplace(Value);
+  }
+
+  /// For convenience, returns a valid alignment or 1 if undefined.
+  Align valueOrOne() const { return hasValue() ? getValue() : Align(); }
+};
+
+/// Checks that SizeInBytes is a multiple of the alignment.
+inline bool isAligned(Align Lhs, uint64_t SizeInBytes) {
+  return SizeInBytes % Lhs.value() == 0;
+}
+
+/// Checks that Addr is a multiple of the alignment.
+inline bool isAddrAligned(Align Lhs, const void *Addr) {
+  return isAligned(Lhs, reinterpret_cast<uintptr_t>(Addr));
+}
+
+/// Returns a multiple of A needed to store `Size` bytes.
+inline uint64_t alignTo(uint64_t Size, Align A) {
+  const uint64_t Value = A.value();
+  // The following line is equivalent to `(Size + Value - 1) / Value * Value`.
+
+  // The division followed by a multiplication can be thought of as a right
+  // shift followed by a left shift which zeros out the extra bits produced in
+  // the bump; `~(Value - 1)` is a mask where all those bits being zeroed out
+  // are just zero.
+
+  // Most compilers can generate this code but the pattern may be missed when
+  // multiple functions gets inlined.
+  return (Size + Value - 1) & ~(Value - 1U);
+}
+
+/// If non-zero \p Skew is specified, the return value will be a minimal integer
+/// that is greater than or equal to \p Size and equal to \p A * N + \p Skew for
+/// some integer N. If \p Skew is larger than \p A, its value is adjusted to '\p
+/// Skew mod \p A'.
+///
+/// Examples:
+/// \code
+///   alignTo(5, Align(8), 7) = 7
+///   alignTo(17, Align(8), 1) = 17
+///   alignTo(~0LL, Align(8), 3) = 3
+/// \endcode
+inline uint64_t alignTo(uint64_t Size, Align A, uint64_t Skew) {
+  const uint64_t Value = A.value();
+  Skew %= Value;
+  return ((Size + Value - 1 - Skew) & ~(Value - 1U)) + Skew;
+}
+
+/// Returns a multiple of A needed to store `Size` bytes.
+/// Returns `Size` if current alignment is undefined.
+inline uint64_t alignTo(uint64_t Size, MaybeAlign A) {
+  return A ? alignTo(Size, A.getValue()) : Size;
+}
+
+/// Aligns `Addr` to `Alignment` bytes, rounding up.
+inline uintptr_t alignAddr(const void *Addr, Align Alignment) {
+  uintptr_t ArithAddr = reinterpret_cast<uintptr_t>(Addr);
+  assert(static_cast<uintptr_t>(ArithAddr + Alignment.value() - 1) >=
+             ArithAddr &&
+         "Overflow");
+  return alignTo(ArithAddr, Alignment);
+}
+
+/// Returns the offset to the next integer (mod 2**64) that is greater than
+/// or equal to \p Value and is a multiple of \p Align.
+inline uint64_t offsetToAlignment(uint64_t Value, Align Alignment) {
+  return alignTo(Value, Alignment) - Value;
+}
+
+/// Returns the necessary adjustment for aligning `Addr` to `Alignment`
+/// bytes, rounding up.
+inline uint64_t offsetToAlignedAddr(const void *Addr, Align Alignment) {
+  return offsetToAlignment(reinterpret_cast<uintptr_t>(Addr), Alignment);
+}
+
+/// Returns the log2 of the alignment.
+inline unsigned Log2(Align A) { return A.ShiftValue; }
+
+/// Returns the alignment that satisfies both alignments.
+/// Same semantic as MinAlign.
+inline Align commonAlignment(Align A, Align B) { return std::min(A, B); }
+
+/// Returns the alignment that satisfies both alignments.
+/// Same semantic as MinAlign.
+inline Align commonAlignment(Align A, uint64_t Offset) {
+  return Align(MinAlign(A.value(), Offset));
+}
+
+/// Returns the alignment that satisfies both alignments.
+/// Same semantic as MinAlign.
+inline MaybeAlign commonAlignment(MaybeAlign A, MaybeAlign B) {
+  return A && B ? commonAlignment(*A, *B) : A ? A : B;
+}
+
+/// Returns the alignment that satisfies both alignments.
+/// Same semantic as MinAlign.
+inline MaybeAlign commonAlignment(MaybeAlign A, uint64_t Offset) {
+  return MaybeAlign(MinAlign((*A).value(), Offset));
+}
+
+/// Returns a representation of the alignment that encodes undefined as 0.
+inline unsigned encode(MaybeAlign A) { return A ? A->ShiftValue + 1 : 0; }
+
+/// Dual operation of the encode function above.
+inline MaybeAlign decodeMaybeAlign(unsigned Value) {
+  if (Value == 0)
+    return MaybeAlign();
+  Align Out;
+  Out.ShiftValue = Value - 1;
+  return Out;
+}
+
+/// Returns a representation of the alignment, the encoded value is positive by
+/// definition.
+inline unsigned encode(Align A) { return encode(MaybeAlign(A)); }
+
+/// Comparisons between Align and scalars. Rhs must be positive.
+inline bool operator==(Align Lhs, uint64_t Rhs) {
+  ALIGN_CHECK_ISPOSITIVE(Rhs);
+  return Lhs.value() == Rhs;
+}
+inline bool operator!=(Align Lhs, uint64_t Rhs) {
+  ALIGN_CHECK_ISPOSITIVE(Rhs);
+  return Lhs.value() != Rhs;
+}
+inline bool operator<=(Align Lhs, uint64_t Rhs) {
+  ALIGN_CHECK_ISPOSITIVE(Rhs);
+  return Lhs.value() <= Rhs;
+}
+inline bool operator>=(Align Lhs, uint64_t Rhs) {
+  ALIGN_CHECK_ISPOSITIVE(Rhs);
+  return Lhs.value() >= Rhs;
+}
+inline bool operator<(Align Lhs, uint64_t Rhs) {
+  ALIGN_CHECK_ISPOSITIVE(Rhs);
+  return Lhs.value() < Rhs;
+}
+inline bool operator>(Align Lhs, uint64_t Rhs) {
+  ALIGN_CHECK_ISPOSITIVE(Rhs);
+  return Lhs.value() > Rhs;
+}
+
+/// Comparisons between MaybeAlign and scalars.
+inline bool operator==(MaybeAlign Lhs, uint64_t Rhs) {
+  return Lhs ? (*Lhs).value() == Rhs : Rhs == 0;
+}
+inline bool operator!=(MaybeAlign Lhs, uint64_t Rhs) {
+  return Lhs ? (*Lhs).value() != Rhs : Rhs != 0;
+}
+
+/// Comparisons operators between Align.
+inline bool operator==(Align Lhs, Align Rhs) {
+  return Lhs.ShiftValue == Rhs.ShiftValue;
+}
+inline bool operator!=(Align Lhs, Align Rhs) {
+  return Lhs.ShiftValue != Rhs.ShiftValue;
+}
+inline bool operator<=(Align Lhs, Align Rhs) {
+  return Lhs.ShiftValue <= Rhs.ShiftValue;
+}
+inline bool operator>=(Align Lhs, Align Rhs) {
+  return Lhs.ShiftValue >= Rhs.ShiftValue;
+}
+inline bool operator<(Align Lhs, Align Rhs) {
+  return Lhs.ShiftValue < Rhs.ShiftValue;
+}
+inline bool operator>(Align Lhs, Align Rhs) {
+  return Lhs.ShiftValue > Rhs.ShiftValue;
+}
+
+// Don't allow relational comparisons with MaybeAlign.
+bool operator<=(Align Lhs, MaybeAlign Rhs) = delete;
+bool operator>=(Align Lhs, MaybeAlign Rhs) = delete;
+bool operator<(Align Lhs, MaybeAlign Rhs) = delete;
+bool operator>(Align Lhs, MaybeAlign Rhs) = delete;
+
+bool operator<=(MaybeAlign Lhs, Align Rhs) = delete;
+bool operator>=(MaybeAlign Lhs, Align Rhs) = delete;
+bool operator<(MaybeAlign Lhs, Align Rhs) = delete;
+bool operator>(MaybeAlign Lhs, Align Rhs) = delete;
+
+bool operator<=(MaybeAlign Lhs, MaybeAlign Rhs) = delete;
+bool operator>=(MaybeAlign Lhs, MaybeAlign Rhs) = delete;
+bool operator<(MaybeAlign Lhs, MaybeAlign Rhs) = delete;
+bool operator>(MaybeAlign Lhs, MaybeAlign Rhs) = delete;
+
+inline Align operator*(Align Lhs, uint64_t Rhs) {
+  assert(Rhs > 0 && "Rhs must be positive");
+  return Align(Lhs.value() * Rhs);
+}
+
+inline MaybeAlign operator*(MaybeAlign Lhs, uint64_t Rhs) {
+  assert(Rhs > 0 && "Rhs must be positive");
+  return Lhs ? Lhs.getValue() * Rhs : MaybeAlign();
+}
+
+inline Align operator/(Align Lhs, uint64_t Divisor) {
+  assert(llvm::isPowerOf2_64(Divisor) &&
+         "Divisor must be positive and a power of 2");
+  assert(Lhs != 1 && "Can't halve byte alignment");
+  return Align(Lhs.value() / Divisor);
+}
+
+inline MaybeAlign operator/(MaybeAlign Lhs, uint64_t Divisor) {
+  assert(llvm::isPowerOf2_64(Divisor) &&
+         "Divisor must be positive and a power of 2");
+  return Lhs ? Lhs.getValue() / Divisor : MaybeAlign();
+}
+
+inline Align max(MaybeAlign Lhs, Align Rhs) {
+  return Lhs && *Lhs > Rhs ? *Lhs : Rhs;
+}
+
+inline Align max(Align Lhs, MaybeAlign Rhs) {
+  return Rhs && *Rhs > Lhs ? *Rhs : Lhs;
+}
+
+#ifndef NDEBUG
+// For usage in LLVM_DEBUG macros.
+inline std::string DebugStr(const Align &A) {
+  return std::to_string(A.value());
+}
+// For usage in LLVM_DEBUG macros.
+inline std::string DebugStr(const MaybeAlign &MA) {
+  if (MA)
+    return std::to_string(MA->value());
+  return "None";
+}
+#endif // NDEBUG
+
+#undef ALIGN_CHECK_ISPOSITIVE
+
+} // namespace llvm
+
+#endif // LLVM_SUPPORT_ALIGNMENT_H_
diff --git a/linux-x64/clang/include/llvm/Support/Allocator.h b/linux-x64/clang/include/llvm/Support/Allocator.h
index 09e967b..245432d 100644
--- a/linux-x64/clang/include/llvm/Support/Allocator.h
+++ b/linux-x64/clang/include/llvm/Support/Allocator.h
@@ -7,13 +7,10 @@
 //===----------------------------------------------------------------------===//
 /// \file
 ///
-/// This file defines the MallocAllocator and BumpPtrAllocator interfaces. Both
-/// of these conform to an LLVM "Allocator" concept which consists of an
-/// Allocate method accepting a size and alignment, and a Deallocate accepting
-/// a pointer and size. Further, the LLVM "Allocator" concept has overloads of
-/// Allocate and Deallocate for setting size and alignment based on the final
-/// type. These overloads are typically provided by a base class template \c
-/// AllocatorBase.
+/// This file defines the BumpPtrAllocator interface. BumpPtrAllocator conforms
+/// to the LLVM "Allocator" concept and is similar to MallocAllocator, but
+/// objects cannot be deallocated. Their lifetime is tied to the lifetime of the
+/// allocator.
 ///
 //===----------------------------------------------------------------------===//
 
@@ -22,6 +19,8 @@
 
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallVector.h"
+#include "llvm/Support/Alignment.h"
+#include "llvm/Support/AllocatorBase.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MathExtras.h"
@@ -37,81 +36,6 @@
 
 namespace llvm {
 
-/// CRTP base class providing obvious overloads for the core \c
-/// Allocate() methods of LLVM-style allocators.
-///
-/// This base class both documents the full public interface exposed by all
-/// LLVM-style allocators, and redirects all of the overloads to a single core
-/// set of methods which the derived class must define.
-template <typename DerivedT> class AllocatorBase {
-public:
-  /// Allocate \a Size bytes of \a Alignment aligned memory. This method
-  /// must be implemented by \c DerivedT.
-  void *Allocate(size_t Size, size_t Alignment) {
-#ifdef __clang__
-    static_assert(static_cast<void *(AllocatorBase::*)(size_t, size_t)>(
-                      &AllocatorBase::Allocate) !=
-                      static_cast<void *(DerivedT::*)(size_t, size_t)>(
-                          &DerivedT::Allocate),
-                  "Class derives from AllocatorBase without implementing the "
-                  "core Allocate(size_t, size_t) overload!");
-#endif
-    return static_cast<DerivedT *>(this)->Allocate(Size, Alignment);
-  }
-
-  /// Deallocate \a Ptr to \a Size bytes of memory allocated by this
-  /// allocator.
-  void Deallocate(const void *Ptr, size_t Size) {
-#ifdef __clang__
-    static_assert(static_cast<void (AllocatorBase::*)(const void *, size_t)>(
-                      &AllocatorBase::Deallocate) !=
-                      static_cast<void (DerivedT::*)(const void *, size_t)>(
-                          &DerivedT::Deallocate),
-                  "Class derives from AllocatorBase without implementing the "
-                  "core Deallocate(void *) overload!");
-#endif
-    return static_cast<DerivedT *>(this)->Deallocate(Ptr, Size);
-  }
-
-  // The rest of these methods are helpers that redirect to one of the above
-  // core methods.
-
-  /// Allocate space for a sequence of objects without constructing them.
-  template <typename T> T *Allocate(size_t Num = 1) {
-    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
-  }
-
-  /// Deallocate space for a sequence of objects without constructing them.
-  template <typename T>
-  typename std::enable_if<
-      !std::is_same<typename std::remove_cv<T>::type, void>::value, void>::type
-  Deallocate(T *Ptr, size_t Num = 1) {
-    Deallocate(static_cast<const void *>(Ptr), Num * sizeof(T));
-  }
-};
-
-class MallocAllocator : public AllocatorBase<MallocAllocator> {
-public:
-  void Reset() {}
-
-  LLVM_ATTRIBUTE_RETURNS_NONNULL void *Allocate(size_t Size,
-                                                size_t /*Alignment*/) {
-    return safe_malloc(Size);
-  }
-
-  // Pull in base class overloads.
-  using AllocatorBase<MallocAllocator>::Allocate;
-
-  void Deallocate(const void *Ptr, size_t /*Size*/) {
-    free(const_cast<void *>(Ptr));
-  }
-
-  // Pull in base class overloads.
-  using AllocatorBase<MallocAllocator>::Deallocate;
-
-  void PrintStats() const {}
-};
-
 namespace detail {
 
 // We call out to an external function to actually print the message as the
@@ -135,30 +59,37 @@
 /// The BumpPtrAllocatorImpl template defaults to using a MallocAllocator
 /// object, which wraps malloc, to allocate memory, but it can be changed to
 /// use a custom allocator.
+///
+/// The GrowthDelay specifies after how many allocated slabs the allocator
+/// increases the size of the slabs.
 template <typename AllocatorT = MallocAllocator, size_t SlabSize = 4096,
-          size_t SizeThreshold = SlabSize>
+          size_t SizeThreshold = SlabSize, size_t GrowthDelay = 128>
 class BumpPtrAllocatorImpl
-    : public AllocatorBase<
-          BumpPtrAllocatorImpl<AllocatorT, SlabSize, SizeThreshold>> {
+    : public AllocatorBase<BumpPtrAllocatorImpl<AllocatorT, SlabSize,
+                                                SizeThreshold, GrowthDelay>>,
+      private AllocatorT {
 public:
   static_assert(SizeThreshold <= SlabSize,
                 "The SizeThreshold must be at most the SlabSize to ensure "
                 "that objects larger than a slab go into their own memory "
                 "allocation.");
+  static_assert(GrowthDelay > 0,
+                "GrowthDelay must be at least 1 which already increases the"
+                "slab size after each allocated slab.");
 
   BumpPtrAllocatorImpl() = default;
 
   template <typename T>
   BumpPtrAllocatorImpl(T &&Allocator)
-      : Allocator(std::forward<T &&>(Allocator)) {}
+      : AllocatorT(std::forward<T &&>(Allocator)) {}
 
   // Manually implement a move constructor as we must clear the old allocator's
   // slabs as a matter of correctness.
   BumpPtrAllocatorImpl(BumpPtrAllocatorImpl &&Old)
-      : CurPtr(Old.CurPtr), End(Old.End), Slabs(std::move(Old.Slabs)),
+      : AllocatorT(static_cast<AllocatorT &&>(Old)), CurPtr(Old.CurPtr),
+        End(Old.End), Slabs(std::move(Old.Slabs)),
         CustomSizedSlabs(std::move(Old.CustomSizedSlabs)),
-        BytesAllocated(Old.BytesAllocated), RedZoneSize(Old.RedZoneSize),
-        Allocator(std::move(Old.Allocator)) {
+        BytesAllocated(Old.BytesAllocated), RedZoneSize(Old.RedZoneSize) {
     Old.CurPtr = Old.End = nullptr;
     Old.BytesAllocated = 0;
     Old.Slabs.clear();
@@ -180,7 +111,7 @@
     RedZoneSize = RHS.RedZoneSize;
     Slabs = std::move(RHS.Slabs);
     CustomSizedSlabs = std::move(RHS.CustomSizedSlabs);
-    Allocator = std::move(RHS.Allocator);
+    AllocatorT::operator=(static_cast<AllocatorT &&>(RHS));
 
     RHS.CurPtr = RHS.End = nullptr;
     RHS.BytesAllocated = 0;
@@ -211,13 +142,11 @@
 
   /// Allocate space at the specified alignment.
   LLVM_ATTRIBUTE_RETURNS_NONNULL LLVM_ATTRIBUTE_RETURNS_NOALIAS void *
-  Allocate(size_t Size, size_t Alignment) {
-    assert(Alignment > 0 && "0-byte alignnment is not allowed. Use 1 instead.");
-
+  Allocate(size_t Size, Align Alignment) {
     // Keep track of how many bytes we've allocated.
     BytesAllocated += Size;
 
-    size_t Adjustment = alignmentAdjustment(CurPtr, Alignment);
+    size_t Adjustment = offsetToAlignedAddr(CurPtr, Alignment);
     assert(Adjustment + Size >= Size && "Adjustment + Size must not overflow");
 
     size_t SizeToAllocate = Size;
@@ -240,9 +169,10 @@
     }
 
     // If Size is really big, allocate a separate slab for it.
-    size_t PaddedSize = SizeToAllocate + Alignment - 1;
+    size_t PaddedSize = SizeToAllocate + Alignment.value() - 1;
     if (PaddedSize > SizeThreshold) {
-      void *NewSlab = Allocator.Allocate(PaddedSize, 0);
+      void *NewSlab =
+          AllocatorT::Allocate(PaddedSize, alignof(std::max_align_t));
       // We own the new slab and don't want anyone reading anyting other than
       // pieces returned from this method.  So poison the whole slab.
       __asan_poison_memory_region(NewSlab, PaddedSize);
@@ -268,13 +198,19 @@
     return AlignedPtr;
   }
 
+  inline LLVM_ATTRIBUTE_RETURNS_NONNULL LLVM_ATTRIBUTE_RETURNS_NOALIAS void *
+  Allocate(size_t Size, size_t Alignment) {
+    assert(Alignment > 0 && "0-byte alignment is not allowed. Use 1 instead.");
+    return Allocate(Size, Align(Alignment));
+  }
+
   // Pull in base class overloads.
   using AllocatorBase<BumpPtrAllocatorImpl>::Allocate;
 
   // Bump pointer allocators are expected to never free their storage; and
   // clients expect pointers to remain valid for non-dereferencing uses even
   // after deallocation.
-  void Deallocate(const void *Ptr, size_t Size) {
+  void Deallocate(const void *Ptr, size_t Size, size_t /*Alignment*/) {
     __asan_poison_memory_region(Ptr, Size);
   }
 
@@ -381,15 +317,13 @@
   /// a sanitizer.
   size_t RedZoneSize = 1;
 
-  /// The allocator instance we use to get slabs of memory.
-  AllocatorT Allocator;
-
   static size_t computeSlabSize(unsigned SlabIdx) {
     // Scale the actual allocated slab size based on the number of slabs
-    // allocated. Every 128 slabs allocated, we double the allocated size to
-    // reduce allocation frequency, but saturate at multiplying the slab size by
-    // 2^30.
-    return SlabSize * ((size_t)1 << std::min<size_t>(30, SlabIdx / 128));
+    // allocated. Every GrowthDelay slabs allocated, we double
+    // the allocated size to reduce allocation frequency, but saturate at
+    // multiplying the slab size by 2^30.
+    return SlabSize *
+           ((size_t)1 << std::min<size_t>(30, SlabIdx / GrowthDelay));
   }
 
   /// Allocate a new slab and move the bump pointers over into the new
@@ -397,7 +331,8 @@
   void StartNewSlab() {
     size_t AllocatedSlabSize = computeSlabSize(Slabs.size());
 
-    void *NewSlab = Allocator.Allocate(AllocatedSlabSize, 0);
+    void *NewSlab =
+        AllocatorT::Allocate(AllocatedSlabSize, alignof(std::max_align_t));
     // We own the new slab and don't want anyone reading anything other than
     // pieces returned from this method.  So poison the whole slab.
     __asan_poison_memory_region(NewSlab, AllocatedSlabSize);
@@ -413,7 +348,7 @@
     for (; I != E; ++I) {
       size_t AllocatedSlabSize =
           computeSlabSize(std::distance(Slabs.begin(), I));
-      Allocator.Deallocate(*I, AllocatedSlabSize);
+      AllocatorT::Deallocate(*I, AllocatedSlabSize, alignof(std::max_align_t));
     }
   }
 
@@ -422,7 +357,7 @@
     for (auto &PtrAndSize : CustomSizedSlabs) {
       void *Ptr = PtrAndSize.first;
       size_t Size = PtrAndSize.second;
-      Allocator.Deallocate(Ptr, Size);
+      AllocatorT::Deallocate(Ptr, Size, alignof(std::max_align_t));
     }
   }
 
@@ -461,7 +396,7 @@
   /// all memory allocated so far.
   void DestroyAll() {
     auto DestroyElements = [](char *Begin, char *End) {
-      assert(Begin == (char *)alignAddr(Begin, alignof(T)));
+      assert(Begin == (char *)alignAddr(Begin, Align::Of<T>()));
       for (char *Ptr = Begin; Ptr + sizeof(T) <= End; Ptr += sizeof(T))
         reinterpret_cast<T *>(Ptr)->~T();
     };
@@ -470,7 +405,7 @@
          ++I) {
       size_t AllocatedSlabSize = BumpPtrAllocator::computeSlabSize(
           std::distance(Allocator.Slabs.begin(), I));
-      char *Begin = (char *)alignAddr(*I, alignof(T));
+      char *Begin = (char *)alignAddr(*I, Align::Of<T>());
       char *End = *I == Allocator.Slabs.back() ? Allocator.CurPtr
                                                : (char *)*I + AllocatedSlabSize;
 
@@ -480,7 +415,8 @@
     for (auto &PtrAndSize : Allocator.CustomSizedSlabs) {
       void *Ptr = PtrAndSize.first;
       size_t Size = PtrAndSize.second;
-      DestroyElements((char *)alignAddr(Ptr, alignof(T)), (char *)Ptr + Size);
+      DestroyElements((char *)alignAddr(Ptr, Align::Of<T>()),
+                      (char *)Ptr + Size);
     }
 
     Allocator.Reset();
@@ -492,26 +428,21 @@
 
 } // end namespace llvm
 
-template <typename AllocatorT, size_t SlabSize, size_t SizeThreshold>
-void *operator new(size_t Size,
-                   llvm::BumpPtrAllocatorImpl<AllocatorT, SlabSize,
-                                              SizeThreshold> &Allocator) {
-  struct S {
-    char c;
-    union {
-      double D;
-      long double LD;
-      long long L;
-      void *P;
-    } x;
-  };
-  return Allocator.Allocate(
-      Size, std::min((size_t)llvm::NextPowerOf2(Size), offsetof(S, x)));
+template <typename AllocatorT, size_t SlabSize, size_t SizeThreshold,
+          size_t GrowthDelay>
+void *
+operator new(size_t Size,
+             llvm::BumpPtrAllocatorImpl<AllocatorT, SlabSize, SizeThreshold,
+                                        GrowthDelay> &Allocator) {
+  return Allocator.Allocate(Size, std::min((size_t)llvm::NextPowerOf2(Size),
+                                           alignof(std::max_align_t)));
 }
 
-template <typename AllocatorT, size_t SlabSize, size_t SizeThreshold>
-void operator delete(
-    void *, llvm::BumpPtrAllocatorImpl<AllocatorT, SlabSize, SizeThreshold> &) {
+template <typename AllocatorT, size_t SlabSize, size_t SizeThreshold,
+          size_t GrowthDelay>
+void operator delete(void *,
+                     llvm::BumpPtrAllocatorImpl<AllocatorT, SlabSize,
+                                                SizeThreshold, GrowthDelay> &) {
 }
 
 #endif // LLVM_SUPPORT_ALLOCATOR_H
diff --git a/linux-x64/clang/include/llvm/Support/AllocatorBase.h b/linux-x64/clang/include/llvm/Support/AllocatorBase.h
new file mode 100644
index 0000000..e5549d1
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Support/AllocatorBase.h
@@ -0,0 +1,103 @@
+//===- AllocatorBase.h - Simple memory allocation abstraction ---*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+/// \file
+///
+/// This file defines MallocAllocator. MallocAllocator conforms to the LLVM
+/// "Allocator" concept which consists of an Allocate method accepting a size
+/// and alignment, and a Deallocate accepting a pointer and size. Further, the
+/// LLVM "Allocator" concept has overloads of Allocate and Deallocate for
+/// setting size and alignment based on the final type. These overloads are
+/// typically provided by a base class template \c AllocatorBase.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_SUPPORT_ALLOCATORBASE_H
+#define LLVM_SUPPORT_ALLOCATORBASE_H
+
+#include "llvm/Support/Compiler.h"
+#include "llvm/Support/MemAlloc.h"
+
+namespace llvm {
+
+/// CRTP base class providing obvious overloads for the core \c
+/// Allocate() methods of LLVM-style allocators.
+///
+/// This base class both documents the full public interface exposed by all
+/// LLVM-style allocators, and redirects all of the overloads to a single core
+/// set of methods which the derived class must define.
+template <typename DerivedT> class AllocatorBase {
+public:
+  /// Allocate \a Size bytes of \a Alignment aligned memory. This method
+  /// must be implemented by \c DerivedT.
+  void *Allocate(size_t Size, size_t Alignment) {
+#ifdef __clang__
+    static_assert(static_cast<void *(AllocatorBase::*)(size_t, size_t)>(
+                      &AllocatorBase::Allocate) !=
+                      static_cast<void *(DerivedT::*)(size_t, size_t)>(
+                          &DerivedT::Allocate),
+                  "Class derives from AllocatorBase without implementing the "
+                  "core Allocate(size_t, size_t) overload!");
+#endif
+    return static_cast<DerivedT *>(this)->Allocate(Size, Alignment);
+  }
+
+  /// Deallocate \a Ptr to \a Size bytes of memory allocated by this
+  /// allocator.
+  void Deallocate(const void *Ptr, size_t Size, size_t Alignment) {
+#ifdef __clang__
+    static_assert(
+        static_cast<void (AllocatorBase::*)(const void *, size_t, size_t)>(
+            &AllocatorBase::Deallocate) !=
+            static_cast<void (DerivedT::*)(const void *, size_t, size_t)>(
+                &DerivedT::Deallocate),
+        "Class derives from AllocatorBase without implementing the "
+        "core Deallocate(void *) overload!");
+#endif
+    return static_cast<DerivedT *>(this)->Deallocate(Ptr, Size, Alignment);
+  }
+
+  // The rest of these methods are helpers that redirect to one of the above
+  // core methods.
+
+  /// Allocate space for a sequence of objects without constructing them.
+  template <typename T> T *Allocate(size_t Num = 1) {
+    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
+  }
+
+  /// Deallocate space for a sequence of objects without constructing them.
+  template <typename T>
+  std::enable_if_t<!std::is_same<std::remove_cv_t<T>, void>::value, void>
+  Deallocate(T *Ptr, size_t Num = 1) {
+    Deallocate(static_cast<const void *>(Ptr), Num * sizeof(T), alignof(T));
+  }
+};
+
+class MallocAllocator : public AllocatorBase<MallocAllocator> {
+public:
+  void Reset() {}
+
+  LLVM_ATTRIBUTE_RETURNS_NONNULL void *Allocate(size_t Size, size_t Alignment) {
+    return allocate_buffer(Size, Alignment);
+  }
+
+  // Pull in base class overloads.
+  using AllocatorBase<MallocAllocator>::Allocate;
+
+  void Deallocate(const void *Ptr, size_t Size, size_t Alignment) {
+    deallocate_buffer(const_cast<void *>(Ptr), Size, Alignment);
+  }
+
+  // Pull in base class overloads.
+  using AllocatorBase<MallocAllocator>::Deallocate;
+
+  void PrintStats() const {}
+};
+
+} // namespace llvm
+
+#endif // LLVM_SUPPORT_ALLOCATORBASE_H
diff --git a/linux-x64/clang/include/llvm/Support/AtomicOrdering.h b/linux-x64/clang/include/llvm/Support/AtomicOrdering.h
index 763bc3e..27ca825 100644
--- a/linux-x64/clang/include/llvm/Support/AtomicOrdering.h
+++ b/linux-x64/clang/include/llvm/Support/AtomicOrdering.h
@@ -21,7 +21,7 @@
 
 namespace llvm {
 
-/// Atomic ordering for C11 / C++11's memody models.
+/// Atomic ordering for C11 / C++11's memory models.
 ///
 /// These values cannot change because they are shared with standard library
 /// implementations as well as with other compilers.
@@ -53,7 +53,7 @@
 ///
 /// not_atomic-->unordered-->relaxed-->release--------------->acq_rel-->seq_cst
 ///                                   \-->consume-->acquire--/
-enum class AtomicOrdering {
+enum class AtomicOrdering : unsigned {
   NotAtomic = 0,
   Unordered = 1,
   Monotonic = 2, // Equivalent to C++'s relaxed.
@@ -61,7 +61,8 @@
   Acquire = 4,
   Release = 5,
   AcquireRelease = 6,
-  SequentiallyConsistent = 7
+  SequentiallyConsistent = 7,
+  LAST = SequentiallyConsistent
 };
 
 bool operator<(AtomicOrdering, AtomicOrdering) = delete;
@@ -86,7 +87,7 @@
 
 /// Returns true if ao is stronger than other as defined by the AtomicOrdering
 /// lattice, which is based on C++'s definition.
-inline bool isStrongerThan(AtomicOrdering ao, AtomicOrdering other) {
+inline bool isStrongerThan(AtomicOrdering AO, AtomicOrdering Other) {
   static const bool lookup[8][8] = {
       //               NA     UN     RX     CO     AC     RE     AR     SC
       /* NotAtomic */ {false, false, false, false, false, false, false, false},
@@ -98,10 +99,10 @@
       /* acq_rel   */ { true,  true,  true,  true,  true,  true, false, false},
       /* seq_cst   */ { true,  true,  true,  true,  true,  true,  true, false},
   };
-  return lookup[static_cast<size_t>(ao)][static_cast<size_t>(other)];
+  return lookup[static_cast<size_t>(AO)][static_cast<size_t>(Other)];
 }
 
-inline bool isAtLeastOrStrongerThan(AtomicOrdering ao, AtomicOrdering other) {
+inline bool isAtLeastOrStrongerThan(AtomicOrdering AO, AtomicOrdering Other) {
   static const bool lookup[8][8] = {
       //               NA     UN     RX     CO     AC     RE     AR     SC
       /* NotAtomic */ { true, false, false, false, false, false, false, false},
@@ -113,26 +114,26 @@
       /* acq_rel   */ { true,  true,  true,  true,  true,  true,  true, false},
       /* seq_cst   */ { true,  true,  true,  true,  true,  true,  true,  true},
   };
-  return lookup[static_cast<size_t>(ao)][static_cast<size_t>(other)];
+  return lookup[static_cast<size_t>(AO)][static_cast<size_t>(Other)];
 }
 
-inline bool isStrongerThanUnordered(AtomicOrdering ao) {
-  return isStrongerThan(ao, AtomicOrdering::Unordered);
+inline bool isStrongerThanUnordered(AtomicOrdering AO) {
+  return isStrongerThan(AO, AtomicOrdering::Unordered);
 }
 
-inline bool isStrongerThanMonotonic(AtomicOrdering ao) {
-  return isStrongerThan(ao, AtomicOrdering::Monotonic);
+inline bool isStrongerThanMonotonic(AtomicOrdering AO) {
+  return isStrongerThan(AO, AtomicOrdering::Monotonic);
 }
 
-inline bool isAcquireOrStronger(AtomicOrdering ao) {
-  return isAtLeastOrStrongerThan(ao, AtomicOrdering::Acquire);
+inline bool isAcquireOrStronger(AtomicOrdering AO) {
+  return isAtLeastOrStrongerThan(AO, AtomicOrdering::Acquire);
 }
 
-inline bool isReleaseOrStronger(AtomicOrdering ao) {
-  return isAtLeastOrStrongerThan(ao, AtomicOrdering::Release);
+inline bool isReleaseOrStronger(AtomicOrdering AO) {
+  return isAtLeastOrStrongerThan(AO, AtomicOrdering::Release);
 }
 
-inline AtomicOrderingCABI toCABI(AtomicOrdering ao) {
+inline AtomicOrderingCABI toCABI(AtomicOrdering AO) {
   static const AtomicOrderingCABI lookup[8] = {
       /* NotAtomic */ AtomicOrderingCABI::relaxed,
       /* Unordered */ AtomicOrderingCABI::relaxed,
@@ -143,7 +144,7 @@
       /* acq_rel   */ AtomicOrderingCABI::acq_rel,
       /* seq_cst   */ AtomicOrderingCABI::seq_cst,
   };
-  return lookup[static_cast<size_t>(ao)];
+  return lookup[static_cast<size_t>(AO)];
 }
 
 } // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/Support/Automaton.h b/linux-x64/clang/include/llvm/Support/Automaton.h
new file mode 100644
index 0000000..c2b9213
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Support/Automaton.h
@@ -0,0 +1,263 @@
+//===-- Automaton.h - Support for driving TableGen-produced DFAs ----------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements class that drive and introspect deterministic finite-
+// state automata (DFAs) as generated by TableGen's -gen-automata backend.
+//
+// For a description of how to define an automaton, see
+// include/llvm/TableGen/Automaton.td.
+//
+// One important detail is that these deterministic automata are created from
+// (potentially) nondeterministic definitions. Therefore a unique sequence of
+// input symbols will produce one path through the DFA but multiple paths
+// through the original NFA. An automaton by default only returns "accepted" or
+// "not accepted", but frequently we want to analyze what NFA path was taken.
+// Finding a path through the NFA states that results in a DFA state can help
+// answer *what* the solution to a problem was, not just that there exists a
+// solution.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_SUPPORT_AUTOMATON_H
+#define LLVM_SUPPORT_AUTOMATON_H
+
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/Support/Allocator.h"
+#include <deque>
+#include <map>
+#include <memory>
+#include <unordered_map>
+#include <vector>
+
+namespace llvm {
+
+using NfaPath = SmallVector<uint64_t, 4>;
+
+/// Forward define the pair type used by the automata transition info tables.
+///
+/// Experimental results with large tables have shown a significant (multiple
+/// orders of magnitude) parsing speedup by using a custom struct here with a
+/// trivial constructor rather than std::pair<uint64_t, uint64_t>.
+struct NfaStatePair {
+  uint64_t FromDfaState, ToDfaState;
+
+  bool operator<(const NfaStatePair &Other) const {
+    return std::make_tuple(FromDfaState, ToDfaState) <
+           std::make_tuple(Other.FromDfaState, Other.ToDfaState);
+  }
+};
+
+namespace internal {
+/// The internal class that maintains all possible paths through an NFA based
+/// on a path through the DFA.
+class NfaTranscriber {
+private:
+  /// Cached transition table. This is a table of NfaStatePairs that contains
+  /// zero-terminated sequences pointed to by DFA transitions.
+  ArrayRef<NfaStatePair> TransitionInfo;
+
+  /// A simple linked-list of traversed states that can have a shared tail. The
+  /// traversed path is stored in reverse order with the latest state as the
+  /// head.
+  struct PathSegment {
+    uint64_t State;
+    PathSegment *Tail;
+  };
+
+  /// We allocate segment objects frequently. Allocate them upfront and dispose
+  /// at the end of a traversal rather than hammering the system allocator.
+  SpecificBumpPtrAllocator<PathSegment> Allocator;
+
+  /// Heads of each tracked path. These are not ordered.
+  std::deque<PathSegment *> Heads;
+
+  /// The returned paths. This is populated during getPaths.
+  SmallVector<NfaPath, 4> Paths;
+
+  /// Create a new segment and return it.
+  PathSegment *makePathSegment(uint64_t State, PathSegment *Tail) {
+    PathSegment *P = Allocator.Allocate();
+    *P = {State, Tail};
+    return P;
+  }
+
+  /// Pairs defines a sequence of possible NFA transitions for a single DFA
+  /// transition.
+  void transition(ArrayRef<NfaStatePair> Pairs) {
+    // Iterate over all existing heads. We will mutate the Heads deque during
+    // iteration.
+    unsigned NumHeads = Heads.size();
+    for (unsigned I = 0; I < NumHeads; ++I) {
+      PathSegment *Head = Heads[I];
+      // The sequence of pairs is sorted. Select the set of pairs that
+      // transition from the current head state.
+      auto PI = lower_bound(Pairs, NfaStatePair{Head->State, 0ULL});
+      auto PE = upper_bound(Pairs, NfaStatePair{Head->State, INT64_MAX});
+      // For every transition from the current head state, add a new path
+      // segment.
+      for (; PI != PE; ++PI)
+        if (PI->FromDfaState == Head->State)
+          Heads.push_back(makePathSegment(PI->ToDfaState, Head));
+    }
+    // Now we've iterated over all the initial heads and added new ones,
+    // dispose of the original heads.
+    Heads.erase(Heads.begin(), std::next(Heads.begin(), NumHeads));
+  }
+
+public:
+  NfaTranscriber(ArrayRef<NfaStatePair> TransitionInfo)
+      : TransitionInfo(TransitionInfo) {
+    reset();
+  }
+
+  ArrayRef<NfaStatePair> getTransitionInfo() const {
+    return TransitionInfo;
+  }
+
+  void reset() {
+    Paths.clear();
+    Heads.clear();
+    Allocator.DestroyAll();
+    // The initial NFA state is 0.
+    Heads.push_back(makePathSegment(0ULL, nullptr));
+  }
+
+  void transition(unsigned TransitionInfoIdx) {
+    unsigned EndIdx = TransitionInfoIdx;
+    while (TransitionInfo[EndIdx].ToDfaState != 0)
+      ++EndIdx;
+    ArrayRef<NfaStatePair> Pairs(&TransitionInfo[TransitionInfoIdx],
+                                 EndIdx - TransitionInfoIdx);
+    transition(Pairs);
+  }
+
+  ArrayRef<NfaPath> getPaths() {
+    Paths.clear();
+    for (auto *Head : Heads) {
+      NfaPath P;
+      while (Head->State != 0) {
+        P.push_back(Head->State);
+        Head = Head->Tail;
+      }
+      std::reverse(P.begin(), P.end());
+      Paths.push_back(std::move(P));
+    }
+    return Paths;
+  }
+};
+} // namespace internal
+
+/// A deterministic finite-state automaton. The automaton is defined in
+/// TableGen; this object drives an automaton defined by tblgen-emitted tables.
+///
+/// An automaton accepts a sequence of input tokens ("actions"). This class is
+/// templated on the type of these actions.
+template <typename ActionT> class Automaton {
+  /// Map from {State, Action} to {NewState, TransitionInfoIdx}.
+  /// TransitionInfoIdx is used by the DfaTranscriber to analyze the transition.
+  /// FIXME: This uses a std::map because ActionT can be a pair type including
+  /// an enum. In particular DenseMapInfo<ActionT> must be defined to use
+  /// DenseMap here.
+  /// This is a shared_ptr to allow very quick copy-construction of Automata; this
+  /// state is immutable after construction so this is safe.
+  using MapTy = std::map<std::pair<uint64_t, ActionT>, std::pair<uint64_t, unsigned>>;
+  std::shared_ptr<MapTy> M;
+  /// An optional transcription object. This uses much more state than simply
+  /// traversing the DFA for acceptance, so is heap allocated.
+  std::shared_ptr<internal::NfaTranscriber> Transcriber;
+  /// The initial DFA state is 1.
+  uint64_t State = 1;
+  /// True if we should transcribe and false if not (even if Transcriber is defined).
+  bool Transcribe;
+
+public:
+  /// Create an automaton.
+  /// \param Transitions The Transitions table as created by TableGen. Note that
+  ///                    because the action type differs per automaton, the
+  ///                    table type is templated as ArrayRef<InfoT>.
+  /// \param TranscriptionTable The TransitionInfo table as created by TableGen.
+  ///
+  /// Providing the TranscriptionTable argument as non-empty will enable the
+  /// use of transcription, which analyzes the possible paths in the original
+  /// NFA taken by the DFA. NOTE: This is substantially more work than simply
+  /// driving the DFA, so unless you require the getPaths() method leave this
+  /// empty.
+  template <typename InfoT>
+  Automaton(ArrayRef<InfoT> Transitions,
+            ArrayRef<NfaStatePair> TranscriptionTable = {}) {
+    if (!TranscriptionTable.empty())
+      Transcriber =
+          std::make_shared<internal::NfaTranscriber>(TranscriptionTable);
+    Transcribe = Transcriber != nullptr;
+    M = std::make_shared<MapTy>();
+    for (const auto &I : Transitions)
+      // Greedily read and cache the transition table.
+      M->emplace(std::make_pair(I.FromDfaState, I.Action),
+                 std::make_pair(I.ToDfaState, I.InfoIdx));
+  }
+  Automaton(const Automaton &Other)
+      : M(Other.M), State(Other.State), Transcribe(Other.Transcribe) {
+    // Transcriber is not thread-safe, so create a new instance on copy.
+    if (Other.Transcriber)
+      Transcriber = std::make_shared<internal::NfaTranscriber>(
+          Other.Transcriber->getTransitionInfo());
+  }
+
+  /// Reset the automaton to its initial state.
+  void reset() {
+    State = 1;
+    if (Transcriber)
+      Transcriber->reset();
+  }
+
+  /// Enable or disable transcription. Transcription is only available if
+  /// TranscriptionTable was provided to the constructor.
+  void enableTranscription(bool Enable = true) {
+    assert(Transcriber &&
+           "Transcription is only available if TranscriptionTable was provided "
+           "to the Automaton constructor");
+    Transcribe = Enable;
+  }
+
+  /// Transition the automaton based on input symbol A. Return true if the
+  /// automaton transitioned to a valid state, false if the automaton
+  /// transitioned to an invalid state.
+  ///
+  /// If this function returns false, all methods are undefined until reset() is
+  /// called.
+  bool add(const ActionT &A) {
+    auto I = M->find({State, A});
+    if (I == M->end())
+      return false;
+    if (Transcriber && Transcribe)
+      Transcriber->transition(I->second.second);
+    State = I->second.first;
+    return true;
+  }
+
+  /// Return true if the automaton can be transitioned based on input symbol A.
+  bool canAdd(const ActionT &A) {
+    auto I = M->find({State, A});
+    return I != M->end();
+  }
+
+  /// Obtain a set of possible paths through the input nondeterministic
+  /// automaton that could be obtained from the sequence of input actions
+  /// presented to this deterministic automaton.
+  ArrayRef<NfaPath> getNfaPaths() {
+    assert(Transcriber && Transcribe &&
+           "Can only obtain NFA paths if transcribing!");
+    return Transcriber->getPaths();
+  }
+};
+
+} // namespace llvm
+
+#endif // LLVM_SUPPORT_AUTOMATON_H
diff --git a/linux-x64/clang/include/llvm/Support/Base64.h b/linux-x64/clang/include/llvm/Support/Base64.h
new file mode 100644
index 0000000..62064a3
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Support/Base64.h
@@ -0,0 +1,56 @@
+//===--- Base64.h - Base64 Encoder/Decoder ----------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file provides generic base64 encoder/decoder.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_SUPPORT_BASE64_H
+#define LLVM_SUPPORT_BASE64_H
+
+#include <string>
+
+namespace llvm {
+
+template <class InputBytes> std::string encodeBase64(InputBytes const &Bytes) {
+  static const char Table[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+                              "abcdefghijklmnopqrstuvwxyz"
+                              "0123456789+/";
+  std::string Buffer;
+  Buffer.resize(((Bytes.size() + 2) / 3) * 4);
+
+  size_t i = 0, j = 0;
+  for (size_t n = Bytes.size() / 3 * 3; i < n; i += 3, j += 4) {
+    uint32_t x = ((unsigned char)Bytes[i] << 16) |
+                 ((unsigned char)Bytes[i + 1] << 8) |
+                 (unsigned char)Bytes[i + 2];
+    Buffer[j + 0] = Table[(x >> 18) & 63];
+    Buffer[j + 1] = Table[(x >> 12) & 63];
+    Buffer[j + 2] = Table[(x >> 6) & 63];
+    Buffer[j + 3] = Table[x & 63];
+  }
+  if (i + 1 == Bytes.size()) {
+    uint32_t x = ((unsigned char)Bytes[i] << 16);
+    Buffer[j + 0] = Table[(x >> 18) & 63];
+    Buffer[j + 1] = Table[(x >> 12) & 63];
+    Buffer[j + 2] = '=';
+    Buffer[j + 3] = '=';
+  } else if (i + 2 == Bytes.size()) {
+    uint32_t x =
+        ((unsigned char)Bytes[i] << 16) | ((unsigned char)Bytes[i + 1] << 8);
+    Buffer[j + 0] = Table[(x >> 18) & 63];
+    Buffer[j + 1] = Table[(x >> 12) & 63];
+    Buffer[j + 2] = Table[(x >> 6) & 63];
+    Buffer[j + 3] = '=';
+  }
+  return Buffer;
+}
+
+} // end namespace llvm
+
+#endif
diff --git a/linux-x64/clang/include/llvm/Support/BinaryItemStream.h b/linux-x64/clang/include/llvm/Support/BinaryItemStream.h
index 4cd66ad..4d27013 100644
--- a/linux-x64/clang/include/llvm/Support/BinaryItemStream.h
+++ b/linux-x64/clang/include/llvm/Support/BinaryItemStream.h
@@ -88,8 +88,7 @@
     if (Offset >= getLength())
       return make_error<BinaryStreamError>(stream_error_code::stream_too_short);
     ++Offset;
-    auto Iter =
-        std::lower_bound(ItemEndOffsets.begin(), ItemEndOffsets.end(), Offset);
+    auto Iter = llvm::lower_bound(ItemEndOffsets, Offset);
     size_t Idx = std::distance(ItemEndOffsets.begin(), Iter);
     assert(Idx < Items.size() && "binary search for offset failed");
     return Idx;
diff --git a/linux-x64/clang/include/llvm/Support/BinaryStreamArray.h b/linux-x64/clang/include/llvm/Support/BinaryStreamArray.h
index 96d09db..3ba65c0 100644
--- a/linux-x64/clang/include/llvm/Support/BinaryStreamArray.h
+++ b/linux-x64/clang/include/llvm/Support/BinaryStreamArray.h
@@ -11,6 +11,7 @@
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/iterator.h"
+#include "llvm/Support/Alignment.h"
 #include "llvm/Support/BinaryStreamRef.h"
 #include "llvm/Support/Error.h"
 #include <cassert>
@@ -133,9 +134,9 @@
   Extractor &getExtractor() { return E; }
 
   BinaryStreamRef getUnderlyingStream() const { return Stream; }
-  void setUnderlyingStream(BinaryStreamRef S, uint32_t Skew = 0) {
-    Stream = S;
-    this->Skew = Skew;
+  void setUnderlyingStream(BinaryStreamRef NewStream, uint32_t NewSkew = 0) {
+    Stream = NewStream;
+    Skew = NewSkew;
   }
 
   void drop_front() { Skew += begin()->length(); }
@@ -143,7 +144,7 @@
 private:
   BinaryStreamRef Stream;
   Extractor E;
-  uint32_t Skew;
+  uint32_t Skew = 0;
 };
 
 template <typename ValueType, typename Extractor>
@@ -274,6 +275,7 @@
     return !(*this == Other);
   }
 
+  FixedStreamArray(const FixedStreamArray &) = default;
   FixedStreamArray &operator=(const FixedStreamArray &) = default;
 
   const T &operator[](uint32_t Index) const {
@@ -286,7 +288,7 @@
       // an exact multiple of the element size.
       consumeError(std::move(EC));
     }
-    assert(llvm::alignmentAdjustment(Data.data(), alignof(T)) == 0);
+    assert(isAddrAligned(Align::Of<T>(), Data.data()));
     return *reinterpret_cast<const T *>(Data.data());
   }
 
@@ -323,6 +325,8 @@
   FixedStreamArrayIterator(const FixedStreamArray<T> &Array, uint32_t Index)
       : Array(Array), Index(Index) {}
 
+  FixedStreamArrayIterator<T>(const FixedStreamArrayIterator<T> &Other)
+      : Array(Other.Array), Index(Other.Index) {}
   FixedStreamArrayIterator<T> &
   operator=(const FixedStreamArrayIterator<T> &Other) {
     Array = Other.Array;
diff --git a/linux-x64/clang/include/llvm/Support/BinaryStreamReader.h b/linux-x64/clang/include/llvm/Support/BinaryStreamReader.h
index d8fddde..b611707 100644
--- a/linux-x64/clang/include/llvm/Support/BinaryStreamReader.h
+++ b/linux-x64/clang/include/llvm/Support/BinaryStreamReader.h
@@ -11,6 +11,7 @@
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/STLExtras.h"
+#include "llvm/Support/Alignment.h"
 #include "llvm/Support/BinaryStreamArray.h"
 #include "llvm/Support/BinaryStreamRef.h"
 #include "llvm/Support/ConvertUTF.h"
@@ -89,7 +90,7 @@
   template <typename T> Error readEnum(T &Dest) {
     static_assert(std::is_enum<T>::value,
                   "Cannot call readEnum with non-enum value!");
-    typename std::underlying_type<T>::type N;
+    std::underlying_type_t<T> N;
     if (auto EC = readInteger(N))
       return EC;
     Dest = static_cast<T>(N);
@@ -148,14 +149,14 @@
   /// returns an appropriate error code.
   Error readStreamRef(BinaryStreamRef &Ref, uint32_t Length);
 
-  /// Read \p Length bytes from the underlying stream into \p Stream.  This is
+  /// Read \p Length bytes from the underlying stream into \p Ref.  This is
   /// equivalent to calling getUnderlyingStream().slice(Offset, Length).
   /// Updates the stream's offset to point after the newly read object.  Never
   /// causes a copy.
   ///
   /// \returns a success error code if the data was successfully read, otherwise
   /// returns an appropriate error code.
-  Error readSubstream(BinarySubstreamRef &Stream, uint32_t Size);
+  Error readSubstream(BinarySubstreamRef &Ref, uint32_t Length);
 
   /// Get a pointer to an object of type T from the underlying stream, as if by
   /// memcpy, and store the result into \p Dest.  It is up to the caller to
@@ -198,7 +199,7 @@
     if (auto EC = readBytes(Bytes, NumElements * sizeof(T)))
       return EC;
 
-    assert(alignmentAdjustment(Bytes.data(), alignof(T)) == 0 &&
+    assert(isAddrAligned(Align::Of<T>(), Bytes.data()) &&
            "Reading at invalid alignment!");
 
     Array = ArrayRef<T>(reinterpret_cast<const T *>(Bytes.data()), NumElements);
diff --git a/linux-x64/clang/include/llvm/Support/BinaryStreamRef.h b/linux-x64/clang/include/llvm/Support/BinaryStreamRef.h
index 7427b8d..ba4c387 100644
--- a/linux-x64/clang/include/llvm/Support/BinaryStreamRef.h
+++ b/linux-x64/clang/include/llvm/Support/BinaryStreamRef.h
@@ -121,12 +121,12 @@
 
   bool valid() const { return BorrowedImpl != nullptr; }
 
-  bool operator==(const RefType &Other) const {
-    if (BorrowedImpl != Other.BorrowedImpl)
+  friend bool operator==(const RefType &LHS, const RefType &RHS) {
+    if (LHS.BorrowedImpl != RHS.BorrowedImpl)
       return false;
-    if (ViewOffset != Other.ViewOffset)
+    if (LHS.ViewOffset != RHS.ViewOffset)
       return false;
-    if (Length != Other.Length)
+    if (LHS.Length != RHS.Length)
       return false;
     return true;
   }
@@ -198,7 +198,7 @@
 };
 
 struct BinarySubstreamRef {
-  uint32_t Offset;            // Offset in the parent stream
+  uint32_t Offset = 0;        // Offset in the parent stream
   BinaryStreamRef StreamData; // Stream Data
 
   BinarySubstreamRef slice(uint32_t Off, uint32_t Size) const {
@@ -211,8 +211,8 @@
   BinarySubstreamRef keep_front(uint32_t N) const { return slice(0, N); }
 
   std::pair<BinarySubstreamRef, BinarySubstreamRef>
-  split(uint32_t Offset) const {
-    return std::make_pair(keep_front(Offset), drop_front(Offset));
+  split(uint32_t Off) const {
+    return std::make_pair(keep_front(Off), drop_front(Off));
   }
 
   uint32_t size() const { return StreamData.getLength(); }
diff --git a/linux-x64/clang/include/llvm/Support/BinaryStreamWriter.h b/linux-x64/clang/include/llvm/Support/BinaryStreamWriter.h
index 86d2389..ceba792 100644
--- a/linux-x64/clang/include/llvm/Support/BinaryStreamWriter.h
+++ b/linux-x64/clang/include/llvm/Support/BinaryStreamWriter.h
@@ -75,7 +75,7 @@
     static_assert(std::is_enum<T>::value,
                   "Cannot call writeEnum with non-Enum type");
 
-    using U = typename std::underlying_type<T>::type;
+    using U = std::underlying_type_t<T>;
     return writeInteger<U>(static_cast<U>(Num));
   }
 
diff --git a/linux-x64/clang/include/llvm/Support/BranchProbability.h b/linux-x64/clang/include/llvm/Support/BranchProbability.h
index cd9d369..6c7ad1f 100644
--- a/linux-x64/clang/include/llvm/Support/BranchProbability.h
+++ b/linux-x64/clang/include/llvm/Support/BranchProbability.h
@@ -32,8 +32,8 @@
   uint32_t N;
 
   // Denominator, which is a constant value.
-  static const uint32_t D = 1u << 31;
-  static const uint32_t UnknownN = UINT32_MAX;
+  static constexpr uint32_t D = 1u << 31;
+  static constexpr uint32_t UnknownN = UINT32_MAX;
 
   // Construct a BranchProbability with only numerator assuming the denominator
   // is 1<<31. For internal use only.
diff --git a/linux-x64/clang/include/llvm/Support/CFGDiff.h b/linux-x64/clang/include/llvm/Support/CFGDiff.h
new file mode 100644
index 0000000..c90b9ac
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Support/CFGDiff.h
@@ -0,0 +1,177 @@
+//===- CFGDiff.h - Define a CFG snapshot. -----------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines specializations of GraphTraits that allows generic
+// algorithms to see a different snapshot of a CFG.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_SUPPORT_CFGDIFF_H
+#define LLVM_SUPPORT_CFGDIFF_H
+
+#include "llvm/ADT/GraphTraits.h"
+#include "llvm/ADT/iterator.h"
+#include "llvm/ADT/iterator_range.h"
+#include "llvm/Support/CFGUpdate.h"
+#include "llvm/Support/type_traits.h"
+#include <cassert>
+#include <cstddef>
+#include <iterator>
+
+// Two booleans are used to define orders in graphs:
+// InverseGraph defines when we need to reverse the whole graph and is as such
+// also equivalent to applying updates in reverse.
+// InverseEdge defines whether we want to change the edges direction. E.g., for
+// a non-inversed graph, the children are naturally the successors when
+// InverseEdge is false and the predecessors when InverseEdge is true.
+
+namespace llvm {
+
+namespace detail {
+template <typename Range>
+auto reverse_if_helper(Range &&R, std::integral_constant<bool, false>) {
+  return std::forward<Range>(R);
+}
+
+template <typename Range>
+auto reverse_if_helper(Range &&R, std::integral_constant<bool, true>) {
+  return llvm::reverse(std::forward<Range>(R));
+}
+
+template <bool B, typename Range> auto reverse_if(Range &&R) {
+  return reverse_if_helper(std::forward<Range>(R),
+                           std::integral_constant<bool, B>{});
+}
+} // namespace detail
+
+// GraphDiff defines a CFG snapshot: given a set of Update<NodePtr>, provides
+// a getChildren method to get a Node's children based on the additional updates
+// in the snapshot. The current diff treats the CFG as a graph rather than a
+// multigraph. Added edges are pruned to be unique, and deleted edges will
+// remove all existing edges between two blocks.
+template <typename NodePtr, bool InverseGraph = false> class GraphDiff {
+  struct DeletesInserts {
+    SmallVector<NodePtr, 2> DI[2];
+  };
+  using UpdateMapType = SmallDenseMap<NodePtr, DeletesInserts>;
+  UpdateMapType Succ;
+  UpdateMapType Pred;
+
+  // By default, it is assumed that, given a CFG and a set of updates, we wish
+  // to apply these updates as given. If UpdatedAreReverseApplied is set, the
+  // updates will be applied in reverse: deleted edges are considered re-added
+  // and inserted edges are considered deleted when returning children.
+  bool UpdatedAreReverseApplied;
+
+  // Keep the list of legalized updates for a deterministic order of updates
+  // when using a GraphDiff for incremental updates in the DominatorTree.
+  // The list is kept in reverse to allow popping from end.
+  SmallVector<cfg::Update<NodePtr>, 4> LegalizedUpdates;
+
+  void printMap(raw_ostream &OS, const UpdateMapType &M) const {
+    StringRef DIText[2] = {"Delete", "Insert"};
+    for (auto Pair : M) {
+      for (unsigned IsInsert = 0; IsInsert <= 1; ++IsInsert) {
+        OS << DIText[IsInsert] << " edges: \n";
+        for (auto Child : Pair.second.DI[IsInsert]) {
+          OS << "(";
+          Pair.first->printAsOperand(OS, false);
+          OS << ", ";
+          Child->printAsOperand(OS, false);
+          OS << ") ";
+        }
+      }
+    }
+    OS << "\n";
+  }
+
+public:
+  GraphDiff() : UpdatedAreReverseApplied(false) {}
+  GraphDiff(ArrayRef<cfg::Update<NodePtr>> Updates,
+            bool ReverseApplyUpdates = false) {
+    cfg::LegalizeUpdates<NodePtr>(Updates, LegalizedUpdates, InverseGraph);
+    for (auto U : LegalizedUpdates) {
+      unsigned IsInsert =
+          (U.getKind() == cfg::UpdateKind::Insert) == !ReverseApplyUpdates;
+      Succ[U.getFrom()].DI[IsInsert].push_back(U.getTo());
+      Pred[U.getTo()].DI[IsInsert].push_back(U.getFrom());
+    }
+    UpdatedAreReverseApplied = ReverseApplyUpdates;
+  }
+
+  auto getLegalizedUpdates() const {
+    return make_range(LegalizedUpdates.begin(), LegalizedUpdates.end());
+  }
+
+  unsigned getNumLegalizedUpdates() const { return LegalizedUpdates.size(); }
+
+  cfg::Update<NodePtr> popUpdateForIncrementalUpdates() {
+    assert(!LegalizedUpdates.empty() && "No updates to apply!");
+    auto U = LegalizedUpdates.pop_back_val();
+    unsigned IsInsert =
+        (U.getKind() == cfg::UpdateKind::Insert) == !UpdatedAreReverseApplied;
+    auto &SuccDIList = Succ[U.getFrom()];
+    auto &SuccList = SuccDIList.DI[IsInsert];
+    assert(SuccList.back() == U.getTo());
+    SuccList.pop_back();
+    if (SuccList.empty() && SuccDIList.DI[!IsInsert].empty())
+      Succ.erase(U.getFrom());
+
+    auto &PredDIList = Pred[U.getTo()];
+    auto &PredList = PredDIList.DI[IsInsert];
+    assert(PredList.back() == U.getFrom());
+    PredList.pop_back();
+    if (PredList.empty() && PredDIList.DI[!IsInsert].empty())
+      Pred.erase(U.getTo());
+    return U;
+  }
+
+  using VectRet = SmallVector<NodePtr, 8>;
+  template <bool InverseEdge> VectRet getChildren(NodePtr N) const {
+    using DirectedNodeT =
+        std::conditional_t<InverseEdge, Inverse<NodePtr>, NodePtr>;
+    auto R = children<DirectedNodeT>(N);
+    VectRet Res = VectRet(detail::reverse_if<!InverseEdge>(R));
+
+    // Remove nullptr children for clang.
+    llvm::erase_value(Res, nullptr);
+
+    auto &Children = (InverseEdge != InverseGraph) ? Pred : Succ;
+    auto It = Children.find(N);
+    if (It == Children.end())
+      return Res;
+
+    // Remove children present in the CFG but not in the snapshot.
+    for (auto *Child : It->second.DI[0])
+      llvm::erase_value(Res, Child);
+
+    // Add children present in the snapshot for not in the real CFG.
+    auto &AddedChildren = It->second.DI[1];
+    llvm::append_range(Res, AddedChildren);
+
+    return Res;
+  }
+
+  void print(raw_ostream &OS) const {
+    OS << "===== GraphDiff: CFG edge changes to create a CFG snapshot. \n"
+          "===== (Note: notion of children/inverse_children depends on "
+          "the direction of edges and the graph.)\n";
+    OS << "Children to delete/insert:\n\t";
+    printMap(OS, Succ);
+    OS << "Inverse_children to delete/insert:\n\t";
+    printMap(OS, Pred);
+    OS << "\n";
+  }
+
+#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+  LLVM_DUMP_METHOD void dump() const { print(dbgs()); }
+#endif
+};
+} // end namespace llvm
+
+#endif // LLVM_SUPPORT_CFGDIFF_H
diff --git a/linux-x64/clang/include/llvm/Support/CFGUpdate.h b/linux-x64/clang/include/llvm/Support/CFGUpdate.h
index eeaf5d0..3a12b9d 100644
--- a/linux-x64/clang/include/llvm/Support/CFGUpdate.h
+++ b/linux-x64/clang/include/llvm/Support/CFGUpdate.h
@@ -14,7 +14,6 @@
 #ifndef LLVM_SUPPORT_CFGUPDATE_H
 #define LLVM_SUPPORT_CFGUPDATE_H
 
-#include "llvm/ADT/APInt.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/PointerIntPair.h"
 #include "llvm/Support/Compiler.h"
@@ -62,7 +61,7 @@
 template <typename NodePtr>
 void LegalizeUpdates(ArrayRef<Update<NodePtr>> AllUpdates,
                      SmallVectorImpl<Update<NodePtr>> &Result,
-                     bool InverseGraph) {
+                     bool InverseGraph, bool ReverseResultOrder = false) {
   // Count the total number of inserions of each edge.
   // Each insertion adds 1 and deletion subtracts 1. The end number should be
   // one of {-1 (deletion), 0 (NOP), +1 (insertion)}. Otherwise, the sequence
@@ -104,11 +103,11 @@
       Operations[{U.getTo(), U.getFrom()}] = int(i);
   }
 
-  llvm::sort(Result,
-             [&Operations](const Update<NodePtr> &A, const Update<NodePtr> &B) {
-               return Operations[{A.getFrom(), A.getTo()}] >
-                      Operations[{B.getFrom(), B.getTo()}];
-             });
+  llvm::sort(Result, [&](const Update<NodePtr> &A, const Update<NodePtr> &B) {
+    const auto &OpA = Operations[{A.getFrom(), A.getTo()}];
+    const auto &OpB = Operations[{B.getFrom(), B.getTo()}];
+    return ReverseResultOrder ? OpA < OpB : OpA > OpB;
+  });
 }
 
 } // end namespace cfg
diff --git a/linux-x64/clang/include/llvm/Support/CRC.h b/linux-x64/clang/include/llvm/Support/CRC.h
index 6ea8e3e..210890a 100644
--- a/linux-x64/clang/include/llvm/Support/CRC.h
+++ b/linux-x64/clang/include/llvm/Support/CRC.h
@@ -6,20 +6,55 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// This file contains basic functions for calculating Cyclic Redundancy Check
-// or CRC.
+// This file contains implementations of CRC functions.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_CRC_H
 #define LLVM_SUPPORT_CRC_H
 
-#include "llvm/ADT/StringRef.h"
 #include "llvm/Support/DataTypes.h"
 
 namespace llvm {
-/// zlib independent CRC32 calculation.
-uint32_t crc32(uint32_t CRC, StringRef S);
+template <typename T> class ArrayRef;
+
+// Compute the CRC-32 of Data.
+uint32_t crc32(ArrayRef<uint8_t> Data);
+
+// Compute the running CRC-32 of Data, with CRC being the previous value of the
+// checksum.
+uint32_t crc32(uint32_t CRC, ArrayRef<uint8_t> Data);
+
+// Class for computing the JamCRC.
+//
+// We will use the "Rocksoft^tm Model CRC Algorithm" to describe the properties
+// of this CRC:
+//   Width  : 32
+//   Poly   : 04C11DB7
+//   Init   : FFFFFFFF
+//   RefIn  : True
+//   RefOut : True
+//   XorOut : 00000000
+//   Check  : 340BC6D9 (result of CRC for "123456789")
+//
+// In other words, this is the same as CRC-32, except that XorOut is 0 instead
+// of FFFFFFFF.
+//
+// N.B.  We permit flexibility of the "Init" value.  Some consumers of this need
+//       it to be zero.
+class JamCRC {
+public:
+  JamCRC(uint32_t Init = 0xFFFFFFFFU) : CRC(Init) {}
+
+  // Update the CRC calculation with Data.
+  void update(ArrayRef<uint8_t> Data);
+
+  uint32_t getCRC() const { return CRC; }
+
+private:
+  uint32_t CRC;
+};
+
 } // end namespace llvm
 
 #endif
diff --git a/linux-x64/clang/include/llvm/Support/CachePruning.h b/linux-x64/clang/include/llvm/Support/CachePruning.h
index a72a864..10d6372 100644
--- a/linux-x64/clang/include/llvm/Support/CachePruning.h
+++ b/linux-x64/clang/include/llvm/Support/CachePruning.h
@@ -14,12 +14,13 @@
 #ifndef LLVM_SUPPORT_CACHE_PRUNING_H
 #define LLVM_SUPPORT_CACHE_PRUNING_H
 
-#include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/Optional.h"
 #include <chrono>
 
 namespace llvm {
 
 template <typename T> class Expected;
+class StringRef;
 
 /// Policy for the pruneCache() function. A default constructed
 /// CachePruningPolicy provides a reasonable default policy.
diff --git a/linux-x64/clang/include/llvm/Support/Casting.h b/linux-x64/clang/include/llvm/Support/Casting.h
index 46bdedb..d6f7793 100644
--- a/linux-x64/clang/include/llvm/Support/Casting.h
+++ b/linux-x64/clang/include/llvm/Support/Casting.h
@@ -61,8 +61,7 @@
 
 /// Always allow upcasts, and perform no dynamic check for them.
 template <typename To, typename From>
-struct isa_impl<
-    To, From, typename std::enable_if<std::is_base_of<To, From>::value>::type> {
+struct isa_impl<To, From, std::enable_if_t<std::is_base_of<To, From>::value>> {
   static inline bool doit(const From &) { return true; }
 };
 
@@ -133,24 +132,30 @@
   }
 };
 
-// isa<X> - Return true if the parameter to the template is an instance of the
-// template type argument.  Used like this:
+// isa<X> - Return true if the parameter to the template is an instance of one
+// of the template type arguments.  Used like this:
 //
 //  if (isa<Type>(myVal)) { ... }
+//  if (isa<Type0, Type1, Type2>(myVal)) { ... }
 //
 template <class X, class Y> LLVM_NODISCARD inline bool isa(const Y &Val) {
   return isa_impl_wrap<X, const Y,
                        typename simplify_type<const Y>::SimpleType>::doit(Val);
 }
 
+template <typename First, typename Second, typename... Rest, typename Y>
+LLVM_NODISCARD inline bool isa(const Y &Val) {
+  return isa<First>(Val) || isa<Second, Rest...>(Val);
+}
+
 // isa_and_nonnull<X> - Functionally identical to isa, except that a null value
 // is accepted.
 //
-template <class X, class Y>
+template <typename... X, class Y>
 LLVM_NODISCARD inline bool isa_and_nonnull(const Y &Val) {
   if (!Val)
     return false;
-  return isa<X>(Val);
+  return isa<X...>(Val);
 }
 
 //===----------------------------------------------------------------------===//
@@ -184,7 +189,7 @@
 struct cast_retty_impl<To, std::unique_ptr<From>> {
 private:
   using PointerType = typename cast_retty_impl<To, From *>::ret_type;
-  using ResultType = typename std::remove_pointer<PointerType>::type;
+  using ResultType = std::remove_pointer_t<PointerType>;
 
 public:
   using ret_type = std::unique_ptr<ResultType>;
@@ -244,8 +249,8 @@
 //  cast<Instruction>(myVal)->getParent()
 //
 template <class X, class Y>
-inline typename std::enable_if<!is_simple_type<Y>::value,
-                               typename cast_retty<X, const Y>::ret_type>::type
+inline std::enable_if_t<!is_simple_type<Y>::value,
+                        typename cast_retty<X, const Y>::ret_type>
 cast(const Y &Val) {
   assert(isa<X>(Val) && "cast<Ty>() argument of incompatible type!");
   return cast_convert_val<
@@ -280,10 +285,9 @@
 // accepted.
 //
 template <class X, class Y>
-LLVM_NODISCARD inline
-    typename std::enable_if<!is_simple_type<Y>::value,
-                            typename cast_retty<X, const Y>::ret_type>::type
-    cast_or_null(const Y &Val) {
+LLVM_NODISCARD inline std::enable_if_t<
+    !is_simple_type<Y>::value, typename cast_retty<X, const Y>::ret_type>
+cast_or_null(const Y &Val) {
   if (!Val)
     return nullptr;
   assert(isa<X>(Val) && "cast_or_null<Ty>() argument of incompatible type!");
@@ -291,10 +295,9 @@
 }
 
 template <class X, class Y>
-LLVM_NODISCARD inline
-    typename std::enable_if<!is_simple_type<Y>::value,
-                            typename cast_retty<X, Y>::ret_type>::type
-    cast_or_null(Y &Val) {
+LLVM_NODISCARD inline std::enable_if_t<!is_simple_type<Y>::value,
+                                       typename cast_retty<X, Y>::ret_type>
+cast_or_null(Y &Val) {
   if (!Val)
     return nullptr;
   assert(isa<X>(Val) && "cast_or_null<Ty>() argument of incompatible type!");
@@ -326,10 +329,9 @@
 //
 
 template <class X, class Y>
-LLVM_NODISCARD inline
-    typename std::enable_if<!is_simple_type<Y>::value,
-                            typename cast_retty<X, const Y>::ret_type>::type
-    dyn_cast(const Y &Val) {
+LLVM_NODISCARD inline std::enable_if_t<
+    !is_simple_type<Y>::value, typename cast_retty<X, const Y>::ret_type>
+dyn_cast(const Y &Val) {
   return isa<X>(Val) ? cast<X>(Val) : nullptr;
 }
 
@@ -347,18 +349,16 @@
 // value is accepted.
 //
 template <class X, class Y>
-LLVM_NODISCARD inline
-    typename std::enable_if<!is_simple_type<Y>::value,
-                            typename cast_retty<X, const Y>::ret_type>::type
-    dyn_cast_or_null(const Y &Val) {
+LLVM_NODISCARD inline std::enable_if_t<
+    !is_simple_type<Y>::value, typename cast_retty<X, const Y>::ret_type>
+dyn_cast_or_null(const Y &Val) {
   return (Val && isa<X>(Val)) ? cast<X>(Val) : nullptr;
 }
 
 template <class X, class Y>
-LLVM_NODISCARD inline
-    typename std::enable_if<!is_simple_type<Y>::value,
-                            typename cast_retty<X, Y>::ret_type>::type
-    dyn_cast_or_null(Y &Val) {
+LLVM_NODISCARD inline std::enable_if_t<!is_simple_type<Y>::value,
+                                       typename cast_retty<X, Y>::ret_type>
+dyn_cast_or_null(Y &Val) {
   return (Val && isa<X>(Val)) ? cast<X>(Val) : nullptr;
 }
 
@@ -382,8 +382,7 @@
 }
 
 template <class X, class Y>
-LLVM_NODISCARD inline auto unique_dyn_cast(std::unique_ptr<Y> &&Val)
-    -> decltype(cast<X>(Val)) {
+LLVM_NODISCARD inline auto unique_dyn_cast(std::unique_ptr<Y> &&Val) {
   return unique_dyn_cast<X, Y>(Val);
 }
 
@@ -398,8 +397,7 @@
 }
 
 template <class X, class Y>
-LLVM_NODISCARD inline auto unique_dyn_cast_or_null(std::unique_ptr<Y> &&Val)
-    -> decltype(cast<X>(Val)) {
+LLVM_NODISCARD inline auto unique_dyn_cast_or_null(std::unique_ptr<Y> &&Val) {
   return unique_dyn_cast_or_null<X, Y>(Val);
 }
 
diff --git a/linux-x64/clang/include/llvm/Support/CheckedArithmetic.h b/linux-x64/clang/include/llvm/Support/CheckedArithmetic.h
index 8a50e3d..09e6d7e 100644
--- a/linux-x64/clang/include/llvm/Support/CheckedArithmetic.h
+++ b/linux-x64/clang/include/llvm/Support/CheckedArithmetic.h
@@ -25,11 +25,11 @@
 /// \p RHS.
 /// \return Empty optional if the operation overflows, or result otherwise.
 template <typename T, typename F>
-typename std::enable_if<std::is_integral<T>::value && sizeof(T) * 8 <= 64,
-                        llvm::Optional<T>>::type
+std::enable_if_t<std::is_integral<T>::value && sizeof(T) * 8 <= 64,
+                 llvm::Optional<T>>
 checkedOp(T LHS, T RHS, F Op, bool Signed = true) {
-  llvm::APInt ALHS(/*BitSize=*/sizeof(T) * 8, LHS, Signed);
-  llvm::APInt ARHS(/*BitSize=*/sizeof(T) * 8, RHS, Signed);
+  llvm::APInt ALHS(sizeof(T) * 8, LHS, Signed);
+  llvm::APInt ARHS(sizeof(T) * 8, RHS, Signed);
   bool Overflow;
   llvm::APInt Out = (ALHS.*Op)(ARHS, Overflow);
   if (Overflow)
@@ -44,7 +44,7 @@
 /// \return Optional of sum if no signed overflow occurred,
 /// \c None otherwise.
 template <typename T>
-typename std::enable_if<std::is_signed<T>::value, llvm::Optional<T>>::type
+std::enable_if_t<std::is_signed<T>::value, llvm::Optional<T>>
 checkedAdd(T LHS, T RHS) {
   return checkedOp(LHS, RHS, &llvm::APInt::sadd_ov);
 }
@@ -53,7 +53,7 @@
 /// \return Optional of sum if no signed overflow occurred,
 /// \c None otherwise.
 template <typename T>
-typename std::enable_if<std::is_signed<T>::value, llvm::Optional<T>>::type
+std::enable_if_t<std::is_signed<T>::value, llvm::Optional<T>>
 checkedSub(T LHS, T RHS) {
   return checkedOp(LHS, RHS, &llvm::APInt::ssub_ov);
 }
@@ -62,7 +62,7 @@
 /// \return Optional of product if no signed overflow occurred,
 /// \c None otherwise.
 template <typename T>
-typename std::enable_if<std::is_signed<T>::value, llvm::Optional<T>>::type
+std::enable_if_t<std::is_signed<T>::value, llvm::Optional<T>>
 checkedMul(T LHS, T RHS) {
   return checkedOp(LHS, RHS, &llvm::APInt::smul_ov);
 }
@@ -71,7 +71,7 @@
 /// \return Optional of result if no signed overflow occurred,
 /// \c None otherwise.
 template <typename T>
-typename std::enable_if<std::is_signed<T>::value, llvm::Optional<T>>::type
+std::enable_if_t<std::is_signed<T>::value, llvm::Optional<T>>
 checkedMulAdd(T A, T B, T C) {
   if (auto Product = checkedMul(A, B))
     return checkedAdd(*Product, C);
@@ -82,7 +82,7 @@
 /// \return Optional of sum if no unsigned overflow occurred,
 /// \c None otherwise.
 template <typename T>
-typename std::enable_if<std::is_unsigned<T>::value, llvm::Optional<T>>::type
+std::enable_if_t<std::is_unsigned<T>::value, llvm::Optional<T>>
 checkedAddUnsigned(T LHS, T RHS) {
   return checkedOp(LHS, RHS, &llvm::APInt::uadd_ov, /*Signed=*/false);
 }
@@ -91,7 +91,7 @@
 /// \return Optional of product if no unsigned overflow occurred,
 /// \c None otherwise.
 template <typename T>
-typename std::enable_if<std::is_unsigned<T>::value, llvm::Optional<T>>::type
+std::enable_if_t<std::is_unsigned<T>::value, llvm::Optional<T>>
 checkedMulUnsigned(T LHS, T RHS) {
   return checkedOp(LHS, RHS, &llvm::APInt::umul_ov, /*Signed=*/false);
 }
@@ -100,7 +100,7 @@
 /// \return Optional of result if no unsigned overflow occurred,
 /// \c None otherwise.
 template <typename T>
-typename std::enable_if<std::is_unsigned<T>::value, llvm::Optional<T>>::type
+std::enable_if_t<std::is_unsigned<T>::value, llvm::Optional<T>>
 checkedMulAddUnsigned(T A, T B, T C) {
   if (auto Product = checkedMulUnsigned(A, B))
     return checkedAddUnsigned(*Product, C);
diff --git a/linux-x64/clang/include/llvm/Support/Chrono.h b/linux-x64/clang/include/llvm/Support/Chrono.h
index 334ab60..098512d 100644
--- a/linux-x64/clang/include/llvm/Support/Chrono.h
+++ b/linux-x64/clang/include/llvm/Support/Chrono.h
@@ -112,8 +112,8 @@
 struct format_provider<std::chrono::duration<Rep, Period>> {
 private:
   typedef std::chrono::duration<Rep, Period> Dur;
-  typedef typename std::conditional<
-      std::chrono::treat_as_floating_point<Rep>::value, double, intmax_t>::type
+  typedef std::conditional_t<std::chrono::treat_as_floating_point<Rep>::value,
+                             double, intmax_t>
       InternalRep;
 
   template <typename AsPeriod> static InternalRep getAs(const Dur &D) {
diff --git a/linux-x64/clang/include/llvm/Support/CodeGen.h b/linux-x64/clang/include/llvm/Support/CodeGen.h
index a3f423e..e2aa2b6 100644
--- a/linux-x64/clang/include/llvm/Support/CodeGen.h
+++ b/linux-x64/clang/include/llvm/Support/CodeGen.h
@@ -57,6 +57,15 @@
     };
   }
 
+  /// These enums are meant to be passed into addPassesToEmitFile to indicate
+  /// what type of file to emit, and returned by it to indicate what type of
+  /// file could actually be made.
+  enum CodeGenFileType {
+    CGFT_AssemblyFile,
+    CGFT_ObjectFile,
+    CGFT_Null         // Do not emit any output.
+  };
+
   // Specify effect of frame pointer elimination optimization.
   namespace FramePointer {
     enum FP {All, NonLeaf, None};
diff --git a/linux-x64/clang/include/llvm/Support/CommandLine.h b/linux-x64/clang/include/llvm/Support/CommandLine.h
index 3cc2c3c..38f3e18 100644
--- a/linux-x64/clang/include/llvm/Support/CommandLine.h
+++ b/linux-x64/clang/include/llvm/Support/CommandLine.h
@@ -20,6 +20,8 @@
 #define LLVM_SUPPORT_COMMANDLINE_H
 
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/None.h"
+#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
@@ -29,6 +31,7 @@
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/ManagedStatic.h"
+#include "llvm/Support/VirtualFileSystem.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cassert>
 #include <climits>
@@ -42,7 +45,6 @@
 namespace llvm {
 
 class StringSaver;
-class raw_ostream;
 
 /// cl Namespace - This namespace contains all of the command line option
 /// processing machinery.  It is intentionally a short name to make qualified
@@ -69,13 +71,6 @@
                              const char *EnvVar = nullptr,
                              bool LongOptionsUseDoubleDash = false);
 
-//===----------------------------------------------------------------------===//
-// ParseEnvironmentOptions - Environment variable option processing alternate
-//                           entry point.
-//
-void ParseEnvironmentOptions(const char *progName, const char *envvar,
-                             const char *Overview = "");
-
 // Function pointer type for printing version information.
 using VersionPrinterTy = std::function<void(raw_ostream &)>;
 
@@ -468,6 +463,42 @@
   template <class Opt> void apply(Opt &O) const { O.addSubCommand(Sub); }
 };
 
+// Specify a callback function to be called when an option is seen.
+// Can be used to set other options automatically.
+template <typename R, typename Ty> struct cb {
+  std::function<R(Ty)> CB;
+
+  cb(std::function<R(Ty)> CB) : CB(CB) {}
+
+  template <typename Opt> void apply(Opt &O) const { O.setCallback(CB); }
+};
+
+namespace detail {
+template <typename F>
+struct callback_traits : public callback_traits<decltype(&F::operator())> {};
+
+template <typename R, typename C, typename... Args>
+struct callback_traits<R (C::*)(Args...) const> {
+  using result_type = R;
+  using arg_type = std::tuple_element_t<0, std::tuple<Args...>>;
+  static_assert(sizeof...(Args) == 1, "callback function must have one and only one parameter");
+  static_assert(std::is_same<result_type, void>::value,
+                "callback return type must be void");
+  static_assert(std::is_lvalue_reference<arg_type>::value &&
+                    std::is_const<std::remove_reference_t<arg_type>>::value,
+                "callback arg_type must be a const lvalue reference");
+};
+} // namespace detail
+
+template <typename F>
+cb<typename detail::callback_traits<F>::result_type,
+   typename detail::callback_traits<F>::arg_type>
+callback(F CB) {
+  using result_type = typename detail::callback_traits<F>::result_type;
+  using arg_type = typename detail::callback_traits<F>::arg_type;
+  return cb<result_type, arg_type>(CB);
+}
+
 //===----------------------------------------------------------------------===//
 // OptionValue class
 
@@ -641,7 +672,7 @@
       : Values(Options) {}
 
   template <class Opt> void apply(Opt &O) const {
-    for (auto Value : Values)
+    for (const auto &Value : Values)
       O.getParser().addLiteralOption(Value.Name, Value.Value,
                                      Value.Description);
   }
@@ -952,6 +983,50 @@
 extern template class basic_parser<int>;
 
 //--------------------------------------------------
+// parser<long>
+//
+template <> class parser<long> final : public basic_parser<long> {
+public:
+  parser(Option &O) : basic_parser(O) {}
+
+  // parse - Return true on error.
+  bool parse(Option &O, StringRef ArgName, StringRef Arg, long &Val);
+
+  // getValueName - Overload in subclass to provide a better default value.
+  StringRef getValueName() const override { return "long"; }
+
+  void printOptionDiff(const Option &O, long V, OptVal Default,
+                       size_t GlobalWidth) const;
+
+  // An out-of-line virtual method to provide a 'home' for this class.
+  void anchor() override;
+};
+
+extern template class basic_parser<long>;
+
+//--------------------------------------------------
+// parser<long long>
+//
+template <> class parser<long long> : public basic_parser<long long> {
+public:
+  parser(Option &O) : basic_parser(O) {}
+
+  // parse - Return true on error.
+  bool parse(Option &O, StringRef ArgName, StringRef Arg, long long &Val);
+
+  // getValueName - Overload in subclass to provide a better default value.
+  StringRef getValueName() const override { return "long"; }
+
+  void printOptionDiff(const Option &O, long long V, OptVal Default,
+                       size_t GlobalWidth) const;
+
+  // An out-of-line virtual method to provide a 'home' for this class.
+  void anchor() override;
+};
+
+extern template class basic_parser<long long>;
+
+//--------------------------------------------------
 // parser<unsigned>
 //
 template <> class parser<unsigned> : public basic_parser<unsigned> {
@@ -1341,6 +1416,7 @@
       return true; // Parse error!
     this->setValue(Val);
     this->setPosition(pos);
+    Callback(Val);
     return false;
   }
 
@@ -1368,16 +1444,16 @@
     }
   }
 
-  template <class T, class = typename std::enable_if<
-            std::is_assignable<T&, T>::value>::type>
+  template <class T,
+            class = std::enable_if_t<std::is_assignable<T &, T>::value>>
   void setDefaultImpl() {
     const OptionValue<DataType> &V = this->getDefault();
     if (V.hasValue())
       this->setValue(V.getValue());
   }
 
-  template <class T, class = typename std::enable_if<
-            !std::is_assignable<T&, T>::value>::type>
+  template <class T,
+            class = std::enable_if_t<!std::is_assignable<T &, T>::value>>
   void setDefaultImpl(...) {}
 
   void setDefault() override { setDefaultImpl<DataType>(); }
@@ -1399,15 +1475,24 @@
 
   template <class T> DataType &operator=(const T &Val) {
     this->setValue(Val);
+    Callback(Val);
     return this->getValue();
   }
 
   template <class... Mods>
   explicit opt(const Mods &... Ms)
-      : Option(Optional, NotHidden), Parser(*this) {
+      : Option(llvm::cl::Optional, NotHidden), Parser(*this) {
     apply(this, Ms...);
     done();
   }
+
+  void setCallback(
+      std::function<void(const typename ParserClass::parser_data_type &)> CB) {
+    Callback = CB;
+  }
+
+  std::function<void(const typename ParserClass::parser_data_type &)> Callback =
+      [](const typename ParserClass::parser_data_type &) {};
 };
 
 extern template class opt<unsigned>;
@@ -1513,8 +1598,8 @@
   reference front() { return Storage.front(); }
   const_reference front() const { return Storage.front(); }
 
-  operator std::vector<DataType>&() { return Storage; }
-  operator ArrayRef<DataType>() { return Storage; }
+  operator std::vector<DataType> &() { return Storage; }
+  operator ArrayRef<DataType>() const { return Storage; }
   std::vector<DataType> *operator&() { return &Storage; }
   const std::vector<DataType> *operator&() const { return &Storage; }
 
@@ -1547,6 +1632,7 @@
     list_storage<DataType, StorageClass>::addValue(Val);
     setPosition(pos);
     Positions.push_back(pos);
+    Callback(Val);
     return false;
   }
 
@@ -1593,6 +1679,14 @@
     apply(this, Ms...);
     done();
   }
+
+  void setCallback(
+      std::function<void(const typename ParserClass::parser_data_type &)> CB) {
+    Callback = CB;
+  }
+
+  std::function<void(const typename ParserClass::parser_data_type &)> Callback =
+      [](const typename ParserClass::parser_data_type &) {};
 };
 
 // multi_val - Modifier to set the number of additional values.
@@ -1693,6 +1787,7 @@
     this->addValue(Val);
     setPosition(pos);
     Positions.push_back(pos);
+    Callback(Val);
     return false;
   }
 
@@ -1734,6 +1829,14 @@
     apply(this, Ms...);
     done();
   }
+
+  void setCallback(
+      std::function<void(const typename ParserClass::parser_data_type &)> CB) {
+    Callback = CB;
+  }
+
+  std::function<void(const typename ParserClass::parser_data_type &)> Callback =
+      [](const typename ParserClass::parser_data_type &) {};
 };
 
 //===----------------------------------------------------------------------===//
@@ -1831,7 +1934,7 @@
 //
 
 /// Use this to get a StringMap to all registered named options
-/// (e.g. -help). Note \p Map Should be an empty StringMap.
+/// (e.g. -help).
 ///
 /// \return A reference to the StringMap used by the cl APIs to parse options.
 ///
@@ -1916,6 +2019,13 @@
                                 SmallVectorImpl<const char *> &NewArgv,
                                 bool MarkEOLs = false);
 
+/// Tokenizes a Windows command line while attempting to avoid copies. If no
+/// quoting or escaping was used, this produces substrings of the original
+/// string. If a token requires unquoting, it will be allocated with the
+/// StringSaver.
+void TokenizeWindowsCommandLineNoCopy(StringRef Source, StringSaver &Saver,
+                                      SmallVectorImpl<StringRef> &NewArgv);
+
 /// String tokenization function type.  Should be compatible with either
 /// Windows or Unix command line tokenizers.
 using TokenizerCallback = void (*)(StringRef Source, StringSaver &Saver,
@@ -1964,10 +2074,24 @@
 /// with nullptrs in the Argv vector.
 /// \param [in] RelativeNames true if names of nested response files must be
 /// resolved relative to including file.
+/// \param [in] FS File system used for all file access when running the tool.
+/// \param [in] CurrentDir Path used to resolve relative rsp files. If set to
+/// None, process' cwd is used instead.
 /// \return true if all @files were expanded successfully or there were none.
-bool ExpandResponseFiles(StringSaver &Saver, TokenizerCallback Tokenizer,
-                         SmallVectorImpl<const char *> &Argv,
-                         bool MarkEOLs = false, bool RelativeNames = false);
+bool ExpandResponseFiles(
+    StringSaver &Saver, TokenizerCallback Tokenizer,
+    SmallVectorImpl<const char *> &Argv, bool MarkEOLs = false,
+    bool RelativeNames = false,
+    llvm::vfs::FileSystem &FS = *llvm::vfs::getRealFileSystem(),
+    llvm::Optional<llvm::StringRef> CurrentDir = llvm::None);
+
+/// A convenience helper which concatenates the options specified by the
+/// environment variable EnvVar and command line options, then expands response
+/// files recursively. The tokenizer is a predefined GNU or Windows one.
+/// \return true if all @files were expanded successfully or there were none.
+bool expandResponseFiles(int Argc, const char *const *Argv, const char *EnvVar,
+                         StringSaver &Saver,
+                         SmallVectorImpl<const char *> &NewArgv);
 
 /// Mark all options not part of this category as cl::ReallyHidden.
 ///
@@ -2000,6 +2124,9 @@
 /// where no options are supported.
 void ResetCommandLineParser();
 
+/// Parses `Arg` into the option handler `Handler`.
+bool ProvidePositionalOption(Option *Handler, StringRef Arg, int i);
+
 } // end namespace cl
 
 } // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/Support/Compiler.h b/linux-x64/clang/include/llvm/Support/Compiler.h
index 3f4f465..9348ada 100644
--- a/linux-x64/clang/include/llvm/Support/Compiler.h
+++ b/linux-x64/clang/include/llvm/Support/Compiler.h
@@ -7,7 +7,8 @@
 //===----------------------------------------------------------------------===//
 //
 // This file defines several macros, based on the current compiler.  This allows
-// use of compiler-specific features in a way that remains portable.
+// use of compiler-specific features in a way that remains portable. This header
+// can be included from either C or C++.
 //
 //===----------------------------------------------------------------------===//
 
@@ -16,7 +17,9 @@
 
 #include "llvm/Config/llvm-config.h"
 
+#ifdef __cplusplus
 #include <new>
+#endif
 #include <stddef.h>
 
 #if defined(_MSC_VER)
@@ -35,14 +38,20 @@
 # define __has_attribute(x) 0
 #endif
 
-#ifndef __has_cpp_attribute
-# define __has_cpp_attribute(x) 0
-#endif
-
 #ifndef __has_builtin
 # define __has_builtin(x) 0
 #endif
 
+// Only use __has_cpp_attribute in C++ mode. GCC defines __has_cpp_attribute in
+// C mode, but the :: in __has_cpp_attribute(scoped::attribute) is invalid.
+#ifndef LLVM_HAS_CPP_ATTRIBUTE
+#if defined(__cplusplus) && defined(__has_cpp_attribute)
+# define LLVM_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x)
+#else
+# define LLVM_HAS_CPP_ATTRIBUTE(x) 0
+#endif
+#endif
+
 /// \macro LLVM_GNUC_PREREQ
 /// Extend the default __GNUC_PREREQ even if glibc's features.h isn't
 /// available.
@@ -62,13 +71,21 @@
 /// \macro LLVM_MSC_PREREQ
 /// Is the compiler MSVC of at least the specified version?
 /// The common \param version values to check for are:
-///  * 1900: Microsoft Visual Studio 2015 / 14.0
+/// * 1910: VS2017, version 15.1 & 15.2
+/// * 1911: VS2017, version 15.3 & 15.4
+/// * 1912: VS2017, version 15.5
+/// * 1913: VS2017, version 15.6
+/// * 1914: VS2017, version 15.7
+/// * 1915: VS2017, version 15.8
+/// * 1916: VS2017, version 15.9
+/// * 1920: VS2019, version 16.0
+/// * 1921: VS2019, version 16.1
 #ifdef _MSC_VER
 #define LLVM_MSC_PREREQ(version) (_MSC_VER >= (version))
 
-// We require at least MSVC 2015.
-#if !LLVM_MSC_PREREQ(1900)
-#error LLVM requires at least MSVC 2015.
+// We require at least MSVC 2017.
+#if !LLVM_MSC_PREREQ(1910)
+#error LLVM requires at least MSVC 2017.
 #endif
 
 #else
@@ -78,7 +95,8 @@
 /// Does the compiler support ref-qualifiers for *this?
 ///
 /// Sadly, this is separate from just rvalue reference support because GCC
-/// and MSVC implemented this later than everything else.
+/// and MSVC implemented this later than everything else. This appears to be
+/// corrected in MSVC 2019 but not MSVC 2017.
 #if __has_feature(cxx_rvalue_references) || LLVM_GNUC_PREREQ(4, 8, 1)
 #define LLVM_HAS_RVALUE_REFERENCE_THIS 1
 #else
@@ -100,11 +118,17 @@
 /// not accessible from outside it.  Can also be used to mark variables and
 /// functions, making them private to any shared library they are linked into.
 /// On PE/COFF targets, library visibility is the default, so this isn't needed.
+///
+/// LLVM_EXTERNAL_VISIBILITY - classes, functions, and variables marked with
+/// this attribute will be made public and visible outside of any shared library
+/// they are linked in to.
 #if (__has_attribute(visibility) || LLVM_GNUC_PREREQ(4, 0, 0)) &&              \
     !defined(__MINGW32__) && !defined(__CYGWIN__) && !defined(_WIN32)
 #define LLVM_LIBRARY_VISIBILITY __attribute__ ((visibility("hidden")))
+#define LLVM_EXTERNAL_VISIBILITY __attribute__ ((visibility("default")))
 #else
 #define LLVM_LIBRARY_VISIBILITY
+#define LLVM_EXTERNAL_VISIBILITY
 #endif
 
 #if defined(__GNUC__)
@@ -120,14 +144,18 @@
 #endif
 
 /// LLVM_NODISCARD - Warn if a type or return value is discarded.
-#if __cplusplus > 201402L && __has_cpp_attribute(nodiscard)
+
+// Use the 'nodiscard' attribute in C++17 or newer mode.
+#if defined(__cplusplus) && __cplusplus > 201402L && LLVM_HAS_CPP_ATTRIBUTE(nodiscard)
 #define LLVM_NODISCARD [[nodiscard]]
-#elif !__cplusplus
-// Workaround for llvm.org/PR23435, since clang 3.6 and below emit a spurious
-// error when __has_cpp_attribute is given a scoped attribute in C mode.
-#define LLVM_NODISCARD
-#elif __has_cpp_attribute(clang::warn_unused_result)
+#elif LLVM_HAS_CPP_ATTRIBUTE(clang::warn_unused_result)
 #define LLVM_NODISCARD [[clang::warn_unused_result]]
+// Clang in C++14 mode claims that it has the 'nodiscard' attribute, but also
+// warns in the pedantic mode that 'nodiscard' is a C++17 extension (PR33518).
+// Use the 'nodiscard' attribute in C++14 mode only with GCC.
+// TODO: remove this workaround when PR33518 is resolved.
+#elif defined(__GNUC__) && LLVM_HAS_CPP_ATTRIBUTE(nodiscard)
+#define LLVM_NODISCARD [[nodiscard]]
 #else
 #define LLVM_NODISCARD
 #endif
@@ -139,7 +167,7 @@
 // The clang-tidy check bugprone-use-after-move recognizes this attribute as a
 // marker that a moved-from object has left the indeterminate state and can be
 // reused.
-#if __has_cpp_attribute(clang::reinitializes)
+#if LLVM_HAS_CPP_ATTRIBUTE(clang::reinitializes)
 #define LLVM_ATTRIBUTE_REINITIALIZES [[clang::reinitializes]]
 #else
 #define LLVM_ATTRIBUTE_REINITIALIZES
@@ -206,11 +234,11 @@
 /// 3.4 supported this but is buggy in various cases and produces unimplemented
 /// errors, just use it in GCC 4.0 and later.
 #if __has_attribute(always_inline) || LLVM_GNUC_PREREQ(4, 0, 0)
-#define LLVM_ATTRIBUTE_ALWAYS_INLINE __attribute__((always_inline))
+#define LLVM_ATTRIBUTE_ALWAYS_INLINE inline __attribute__((always_inline))
 #elif defined(_MSC_VER)
 #define LLVM_ATTRIBUTE_ALWAYS_INLINE __forceinline
 #else
-#define LLVM_ATTRIBUTE_ALWAYS_INLINE
+#define LLVM_ATTRIBUTE_ALWAYS_INLINE inline
 #endif
 
 #ifdef __GNUC__
@@ -240,15 +268,13 @@
 #endif
 
 /// LLVM_FALLTHROUGH - Mark fallthrough cases in switch statements.
-#if __cplusplus > 201402L && __has_cpp_attribute(fallthrough)
+#if defined(__cplusplus) && __cplusplus > 201402L && LLVM_HAS_CPP_ATTRIBUTE(fallthrough)
 #define LLVM_FALLTHROUGH [[fallthrough]]
-#elif __has_cpp_attribute(gnu::fallthrough)
+#elif LLVM_HAS_CPP_ATTRIBUTE(gnu::fallthrough)
 #define LLVM_FALLTHROUGH [[gnu::fallthrough]]
-#elif !__cplusplus
-// Workaround for llvm.org/PR23435, since clang 3.6 and below emit a spurious
-// error when __has_cpp_attribute is given a scoped attribute in C mode.
-#define LLVM_FALLTHROUGH
-#elif __has_cpp_attribute(clang::fallthrough)
+#elif __has_attribute(fallthrough)
+#define LLVM_FALLTHROUGH __attribute__((fallthrough))
+#elif LLVM_HAS_CPP_ATTRIBUTE(clang::fallthrough)
 #define LLVM_FALLTHROUGH [[clang::fallthrough]]
 #else
 #define LLVM_FALLTHROUGH
@@ -256,13 +282,29 @@
 
 /// LLVM_REQUIRE_CONSTANT_INITIALIZATION - Apply this to globals to ensure that
 /// they are constant initialized.
-#if __has_cpp_attribute(clang::require_constant_initialization)
+#if LLVM_HAS_CPP_ATTRIBUTE(clang::require_constant_initialization)
 #define LLVM_REQUIRE_CONSTANT_INITIALIZATION                                   \
   [[clang::require_constant_initialization]]
 #else
 #define LLVM_REQUIRE_CONSTANT_INITIALIZATION
 #endif
 
+/// LLVM_GSL_OWNER - Apply this to owning classes like SmallVector to enable
+/// lifetime warnings.
+#if LLVM_HAS_CPP_ATTRIBUTE(gsl::Owner)
+#define LLVM_GSL_OWNER [[gsl::Owner]]
+#else
+#define LLVM_GSL_OWNER
+#endif
+
+/// LLVM_GSL_POINTER - Apply this to non-owning classes like
+/// StringRef to enable lifetime warnings.
+#if LLVM_HAS_CPP_ATTRIBUTE(gsl::Pointer)
+#define LLVM_GSL_POINTER [[gsl::Pointer]]
+#else
+#define LLVM_GSL_POINTER
+#endif
+
 /// LLVM_EXTENSION - Support compilers where we have a keyword to suppress
 /// pedantic diagnostics.
 #ifdef __GNUC__
@@ -272,19 +314,9 @@
 #endif
 
 // LLVM_ATTRIBUTE_DEPRECATED(decl, "message")
-#if __has_feature(attribute_deprecated_with_message)
-# define LLVM_ATTRIBUTE_DEPRECATED(decl, message) \
-  decl __attribute__((deprecated(message)))
-#elif defined(__GNUC__)
-# define LLVM_ATTRIBUTE_DEPRECATED(decl, message) \
-  decl __attribute__((deprecated))
-#elif defined(_MSC_VER)
-# define LLVM_ATTRIBUTE_DEPRECATED(decl, message) \
-  __declspec(deprecated(message)) decl
-#else
-# define LLVM_ATTRIBUTE_DEPRECATED(decl, message) \
-  decl
-#endif
+// This macro will be removed.
+// Use C++14's attribute instead: [[deprecated("message")]]
+#define LLVM_ATTRIBUTE_DEPRECATED(decl, message) [[deprecated(message)]] decl
 
 /// LLVM_BUILTIN_UNREACHABLE - On compilers which support it, expands
 /// to an expression which states that it is undefined behavior for the
@@ -331,21 +363,12 @@
 #if __has_builtin(__builtin_assume_aligned) || LLVM_GNUC_PREREQ(4, 7, 0)
 # define LLVM_ASSUME_ALIGNED(p, a) __builtin_assume_aligned(p, a)
 #elif defined(LLVM_BUILTIN_UNREACHABLE)
-// As of today, clang does not support __builtin_assume_aligned.
 # define LLVM_ASSUME_ALIGNED(p, a) \
            (((uintptr_t(p) % (a)) == 0) ? (p) : (LLVM_BUILTIN_UNREACHABLE, (p)))
 #else
 # define LLVM_ASSUME_ALIGNED(p, a) (p)
 #endif
 
-/// \macro LLVM_ALIGNAS
-/// Used to specify a minimum alignment for a structure or variable.
-#if __GNUC__ && !__has_feature(cxx_alignas) && !LLVM_GNUC_PREREQ(4, 8, 1)
-# define LLVM_ALIGNAS(x) __attribute__((aligned(x)))
-#else
-# define LLVM_ALIGNAS(x) alignas(x)
-#endif
-
 /// \macro LLVM_PACKED
 /// Used to specify a packed structure.
 /// LLVM_PACKED(
@@ -376,8 +399,8 @@
 
 /// \macro LLVM_PTR_SIZE
 /// A constant integer equivalent to the value of sizeof(void*).
-/// Generally used in combination with LLVM_ALIGNAS or when doing computation in
-/// the preprocessor.
+/// Generally used in combination with alignas or when doing computation in the
+/// preprocessor.
 #ifdef __SIZEOF_POINTER__
 # define LLVM_PTR_SIZE __SIZEOF_POINTER__
 #elif defined(_WIN64)
@@ -395,10 +418,12 @@
 #if __has_feature(memory_sanitizer)
 # define LLVM_MEMORY_SANITIZER_BUILD 1
 # include <sanitizer/msan_interface.h>
+# define LLVM_NO_SANITIZE_MEMORY_ATTRIBUTE __attribute__((no_sanitize_memory))
 #else
 # define LLVM_MEMORY_SANITIZER_BUILD 0
 # define __msan_allocated_memory(p, size)
 # define __msan_unpoison(p, size)
+# define LLVM_NO_SANITIZE_MEMORY_ATTRIBUTE
 #endif
 
 /// \macro LLVM_ADDRESS_SANITIZER_BUILD
@@ -493,19 +518,15 @@
 /// extern globals, and static globals.
 ///
 /// This is essentially an extremely restricted analog to C++11's thread_local
-/// support, and uses that when available. However, it falls back on
-/// platform-specific or vendor-provided extensions when necessary. These
-/// extensions don't support many of the C++11 thread_local's features. You
-/// should only use this for PODs that you can statically initialize to
-/// some constant value. In almost all circumstances this is most appropriate
-/// for use with a pointer, integer, or small aggregation of pointers and
-/// integers.
+/// support. It uses thread_local if available, falling back on gcc __thread
+/// if not. __thread doesn't support many of the C++11 thread_local's
+/// features. You should only use this for PODs that you can statically
+/// initialize to some constant value. In almost all circumstances this is most
+/// appropriate for use with a pointer, integer, or small aggregation of
+/// pointers and integers.
 #if LLVM_ENABLE_THREADS
-#if __has_feature(cxx_thread_local)
+#if __has_feature(cxx_thread_local) || defined(_MSC_VER)
 #define LLVM_THREAD_LOCAL thread_local
-#elif defined(_MSC_VER)
-// MSVC supports this with a __declspec.
-#define LLVM_THREAD_LOCAL __declspec(thread)
 #else
 // Clang, GCC, and other compatible compilers used __thread prior to C++11 and
 // we only need the restricted functionality that provides.
@@ -527,46 +548,4 @@
 #define LLVM_ENABLE_EXCEPTIONS 1
 #endif
 
-namespace llvm {
-
-/// Allocate a buffer of memory with the given size and alignment.
-///
-/// When the compiler supports aligned operator new, this will use it to to
-/// handle even over-aligned allocations.
-///
-/// However, this doesn't make any attempt to leverage the fancier techniques
-/// like posix_memalign due to portability. It is mostly intended to allow
-/// compatibility with platforms that, after aligned allocation was added, use
-/// reduced default alignment.
-inline void *allocate_buffer(size_t Size, size_t Alignment) {
-  return ::operator new(Size
-#ifdef __cpp_aligned_new
-                        ,
-                        std::align_val_t(Alignment)
-#endif
-  );
-}
-
-/// Deallocate a buffer of memory with the given size and alignment.
-///
-/// If supported, this will used the sized delete operator. Also if supported,
-/// this will pass the alignment to the delete operator.
-///
-/// The pointer must have been allocated with the corresponding new operator,
-/// most likely using the above helper.
-inline void deallocate_buffer(void *Ptr, size_t Size, size_t Alignment) {
-  ::operator delete(Ptr
-#ifdef __cpp_sized_deallocation
-                    ,
-                    Size
-#endif
-#ifdef __cpp_aligned_new
-                    ,
-                    std::align_val_t(Alignment)
-#endif
-  );
-}
-
-} // End namespace llvm
-
 #endif
diff --git a/linux-x64/clang/include/llvm/Support/CrashRecoveryContext.h b/linux-x64/clang/include/llvm/Support/CrashRecoveryContext.h
index feb449e..f756635 100644
--- a/linux-x64/clang/include/llvm/Support/CrashRecoveryContext.h
+++ b/linux-x64/clang/include/llvm/Support/CrashRecoveryContext.h
@@ -44,11 +44,11 @@
 /// executed in any case, whether crash occurs or not. These actions may be used
 /// to reclaim resources in the case of crash.
 class CrashRecoveryContext {
-  void *Impl;
-  CrashRecoveryContextCleanup *head;
+  void *Impl = nullptr;
+  CrashRecoveryContextCleanup *head = nullptr;
 
 public:
-  CrashRecoveryContext() : Impl(nullptr), head(nullptr) {}
+  CrashRecoveryContext();
   ~CrashRecoveryContext();
 
   /// Register cleanup handler, which is used when the recovery context is
@@ -99,7 +99,20 @@
 
   /// Explicitly trigger a crash recovery in the current process, and
   /// return failure from RunSafely(). This function does not return.
-  void HandleCrash();
+  LLVM_ATTRIBUTE_NORETURN
+  void HandleExit(int RetCode);
+
+  /// Throw again a signal or an exception, after it was catched once by a
+  /// CrashRecoveryContext.
+  static bool throwIfCrash(int RetCode);
+
+  /// In case of a crash, this is the crash identifier.
+  int RetCode = 0;
+
+  /// Selects whether handling of failures should be done in the same way as
+  /// for regular crashes. When this is active, a crash would print the
+  /// callstack, clean-up any temporary files and create a coredump/minidump.
+  bool DumpStackAndCleanupOnFailure = false;
 };
 
 /// Abstract base class of cleanup handlers.
@@ -111,12 +124,12 @@
 /// a crash recovery context.
 class CrashRecoveryContextCleanup {
 protected:
-  CrashRecoveryContext *context;
+  CrashRecoveryContext *context = nullptr;
   CrashRecoveryContextCleanup(CrashRecoveryContext *context)
-      : context(context), cleanupFired(false) {}
+      : context(context) {}
 
 public:
-  bool cleanupFired;
+  bool cleanupFired = false;
 
   virtual ~CrashRecoveryContextCleanup();
   virtual void recoverResources() = 0;
@@ -127,7 +140,7 @@
 
 private:
   friend class CrashRecoveryContext;
-  CrashRecoveryContextCleanup *prev, *next;
+  CrashRecoveryContextCleanup *prev = nullptr, *next = nullptr;
 };
 
 /// Base class of cleanup handler that controls recovery of resources of the
@@ -172,7 +185,7 @@
       : CrashRecoveryContextCleanupBase<
             CrashRecoveryContextDestructorCleanup<T>, T>(context, resource) {}
 
-  virtual void recoverResources() {
+  void recoverResources() override {
     this->resource->~T();
   }
 };
diff --git a/linux-x64/clang/include/llvm/Support/DOTGraphTraits.h b/linux-x64/clang/include/llvm/Support/DOTGraphTraits.h
index ec01b7d..a73538f 100644
--- a/linux-x64/clang/include/llvm/Support/DOTGraphTraits.h
+++ b/linux-x64/clang/include/llvm/Support/DOTGraphTraits.h
@@ -60,7 +60,8 @@
 
   /// isNodeHidden - If the function returns true, the given node is not
   /// displayed in the graph.
-  static bool isNodeHidden(const void *) {
+  template <typename GraphType>
+  static bool isNodeHidden(const void *, const GraphType &) {
     return false;
   }
 
diff --git a/linux-x64/clang/include/llvm/Support/DataExtractor.h b/linux-x64/clang/include/llvm/Support/DataExtractor.h
index 6b08a2a..f9335c1 100644
--- a/linux-x64/clang/include/llvm/Support/DataExtractor.h
+++ b/linux-x64/clang/include/llvm/Support/DataExtractor.h
@@ -11,6 +11,7 @@
 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/DataTypes.h"
+#include "llvm/Support/Error.h"
 
 namespace llvm {
 
@@ -42,6 +43,38 @@
   uint8_t IsLittleEndian;
   uint8_t AddressSize;
 public:
+  /// A class representing a position in a DataExtractor, as well as any error
+  /// encountered during extraction. It enables one to extract a sequence of
+  /// values without error-checking and then checking for errors in bulk at the
+  /// end. The class holds an Error object, so failing to check the result of
+  /// the parse will result in a runtime error. The error flag is sticky and
+  /// will cause all subsequent extraction functions to fail without even
+  /// attempting to parse and without updating the Cursor offset. After clearing
+  /// the error flag, one can again use the Cursor object for parsing.
+  class Cursor {
+    uint64_t Offset;
+    Error Err;
+
+    friend class DataExtractor;
+
+  public:
+    /// Construct a cursor for extraction from the given offset.
+    explicit Cursor(uint64_t Offset) : Offset(Offset), Err(Error::success()) {}
+
+    /// Checks whether the cursor is valid (i.e. no errors were encountered). In
+    /// case of errors, this does not clear the error flag -- one must call
+    /// takeError() instead.
+    explicit operator bool() { return !Err; }
+
+    /// Return the current position of this Cursor. In the error state this is
+    /// the position of the Cursor before the first error was encountered.
+    uint64_t tell() const { return Offset; }
+
+    /// Return error contained inside this Cursor, if any. Clears the internal
+    /// Cursor state.
+    Error takeError() { return std::move(Err); }
+  };
+
   /// Construct with a buffer that is owned by the caller.
   ///
   /// This constructor allows us to use data that is owned by the
@@ -49,6 +82,11 @@
   /// valid.
   DataExtractor(StringRef Data, bool IsLittleEndian, uint8_t AddressSize)
     : Data(Data), IsLittleEndian(IsLittleEndian), AddressSize(AddressSize) {}
+  DataExtractor(ArrayRef<uint8_t> Data, bool IsLittleEndian,
+                uint8_t AddressSize)
+      : Data(StringRef(reinterpret_cast<const char *>(Data.data()),
+                       Data.size())),
+        IsLittleEndian(IsLittleEndian), AddressSize(AddressSize) {}
 
   /// Get the data pointed to by this extractor.
   StringRef getData() const { return Data; }
@@ -67,25 +105,38 @@
   /// updated with the offset of the byte that follows the NULL
   /// terminator byte.
   ///
-  /// @param[in,out] offset_ptr
+  /// @param[in,out] OffsetPtr
   ///     A pointer to an offset within the data that will be advanced
   ///     by the appropriate number of bytes if the value is extracted
   ///     correctly. If the offset is out of bounds or there are not
   ///     enough bytes to extract this value, the offset will be left
   ///     unmodified.
   ///
+  /// @param[in,out] Err
+  ///     A pointer to an Error object. Upon return the Error object is set to
+  ///     indicate the result (success/failure) of the function. If the Error
+  ///     object is already set when calling this function, no extraction is
+  ///     performed.
+  ///
   /// @return
   ///     A pointer to the C string value in the data. If the offset
   ///     pointed to by \a offset_ptr is out of bounds, or if the
   ///     offset plus the length of the C string is out of bounds,
   ///     NULL will be returned.
-  const char *getCStr(uint32_t *offset_ptr) const;
+  const char *getCStr(uint64_t *OffsetPtr, Error *Err = nullptr) const {
+    return getCStrRef(OffsetPtr, Err).data();
+  }
 
-  /// Extract a C string from \a *OffsetPtr.
+  /// Extract a C string from the location given by the cursor. In case of an
+  /// extraction error, or if the cursor is already in an error state, a
+  /// nullptr is returned.
+  const char *getCStr(Cursor &C) const { return getCStrRef(C).data(); }
+
+  /// Extract a C string from \a *offset_ptr.
   ///
   /// Returns a StringRef for the C String from the data at the offset
-  /// pointed to by \a OffsetPtr. A variable length NULL terminated C
-  /// string will be extracted and the \a OffsetPtr will be
+  /// pointed to by \a offset_ptr. A variable length NULL terminated C
+  /// string will be extracted and the \a offset_ptr will be
   /// updated with the offset of the byte that follows the NULL
   /// terminator byte.
   ///
@@ -96,12 +147,95 @@
   ///     enough bytes to extract this value, the offset will be left
   ///     unmodified.
   ///
+  /// @param[in,out] Err
+  ///     A pointer to an Error object. Upon return the Error object is set to
+  ///     indicate the result (success/failure) of the function. If the Error
+  ///     object is already set when calling this function, no extraction is
+  ///     performed.
+  ///
+  /// \return
+  ///     A StringRef for the C string value in the data. If the offset
+  ///     pointed to by \a offset_ptr is out of bounds, or if the
+  ///     offset plus the length of the C string is out of bounds,
+  ///     a default-initialized StringRef will be returned.
+  StringRef getCStrRef(uint64_t *OffsetPtr, Error *Err = nullptr) const;
+
+  /// Extract a C string (as a StringRef) from the location given by the cursor.
+  /// In case of an extraction error, or if the cursor is already in an error
+  /// state, a default-initialized StringRef is returned.
+  StringRef getCStrRef(Cursor &C) const {
+    return getCStrRef(&C.Offset, &C.Err);
+  }
+
+  /// Extract a fixed length string from \a *OffsetPtr and consume \a Length
+  /// bytes.
+  ///
+  /// Returns a StringRef for the string from the data at the offset
+  /// pointed to by \a OffsetPtr. A fixed length C string will be extracted
+  /// and the \a OffsetPtr will be advanced by \a Length bytes.
+  ///
+  /// \param[in,out] OffsetPtr
+  ///     A pointer to an offset within the data that will be advanced
+  ///     by the appropriate number of bytes if the value is extracted
+  ///     correctly. If the offset is out of bounds or there are not
+  ///     enough bytes to extract this value, the offset will be left
+  ///     unmodified.
+  ///
+  /// \param[in] Length
+  ///     The length of the fixed length string to extract. If there are not
+  ///     enough bytes in the data to extract the full string, the offset will
+  ///     be left unmodified.
+  ///
+  /// \param[in] TrimChars
+  ///     A set of characters to trim from the end of the string. Fixed length
+  ///     strings are commonly either NULL terminated by one or more zero
+  ///     bytes. Some clients have one or more spaces at the end of the string,
+  ///     but a good default is to trim the NULL characters.
+  ///
   /// \return
   ///     A StringRef for the C string value in the data. If the offset
   ///     pointed to by \a OffsetPtr is out of bounds, or if the
   ///     offset plus the length of the C string is out of bounds,
   ///     a default-initialized StringRef will be returned.
-  StringRef getCStrRef(uint32_t *OffsetPtr) const;
+  StringRef getFixedLengthString(uint64_t *OffsetPtr,
+      uint64_t Length, StringRef TrimChars = {"\0", 1}) const;
+
+  /// Extract a fixed number of bytes from the specified offset.
+  ///
+  /// Returns a StringRef for the bytes from the data at the offset
+  /// pointed to by \a OffsetPtr. A fixed length C string will be extracted
+  /// and the \a OffsetPtr will be advanced by \a Length bytes.
+  ///
+  /// \param[in,out] OffsetPtr
+  ///     A pointer to an offset within the data that will be advanced
+  ///     by the appropriate number of bytes if the value is extracted
+  ///     correctly. If the offset is out of bounds or there are not
+  ///     enough bytes to extract this value, the offset will be left
+  ///     unmodified.
+  ///
+  /// \param[in] Length
+  ///     The number of bytes to extract. If there are not enough bytes in the
+  ///     data to extract all of the bytes, the offset will be left unmodified.
+  ///
+  /// @param[in,out] Err
+  ///     A pointer to an Error object. Upon return the Error object is set to
+  ///     indicate the result (success/failure) of the function. If the Error
+  ///     object is already set when calling this function, no extraction is
+  ///     performed.
+  ///
+  /// \return
+  ///     A StringRef for the extracted bytes. If the offset pointed to by
+  ///     \a OffsetPtr is out of bounds, or if the offset plus the length
+  ///     is out of bounds, a default-initialized StringRef will be returned.
+  StringRef getBytes(uint64_t *OffsetPtr, uint64_t Length,
+                     Error *Err = nullptr) const;
+
+  /// Extract a fixed number of bytes from the location given by the cursor. In
+  /// case of an extraction error, or if the cursor is already in an error
+  /// state, a default-initialized StringRef is returned.
+  StringRef getBytes(Cursor &C, uint64_t Length) {
+    return getBytes(&C.Offset, Length, &C.Err);
+  }
 
   /// Extract an unsigned integer of size \a byte_size from \a
   /// *offset_ptr.
@@ -124,10 +258,24 @@
   /// @param[in] byte_size
   ///     The size in byte of the integer to extract.
   ///
+  /// @param[in,out] Err
+  ///     A pointer to an Error object. Upon return the Error object is set to
+  ///     indicate the result (success/failure) of the function. If the Error
+  ///     object is already set when calling this function, no extraction is
+  ///     performed.
+  ///
   /// @return
   ///     The unsigned integer value that was extracted, or zero on
   ///     failure.
-  uint64_t getUnsigned(uint32_t *offset_ptr, uint32_t byte_size) const;
+  uint64_t getUnsigned(uint64_t *offset_ptr, uint32_t byte_size,
+                       Error *Err = nullptr) const;
+
+  /// Extract an unsigned integer of the given size from the location given by
+  /// the cursor. In case of an extraction error, or if the cursor is already in
+  /// an error state, zero is returned.
+  uint64_t getUnsigned(Cursor &C, uint32_t Size) const {
+    return getUnsigned(&C.Offset, Size, &C.Err);
+  }
 
   /// Extract an signed integer of size \a byte_size from \a *offset_ptr.
   ///
@@ -152,7 +300,7 @@
   /// @return
   ///     The sign extended signed integer value that was extracted,
   ///     or zero on failure.
-  int64_t getSigned(uint32_t *offset_ptr, uint32_t size) const;
+  int64_t getSigned(uint64_t *offset_ptr, uint32_t size) const;
 
   //------------------------------------------------------------------
   /// Extract an pointer from \a *offset_ptr.
@@ -171,10 +319,15 @@
   ///
   /// @return
   ///     The extracted pointer value as a 64 integer.
-  uint64_t getAddress(uint32_t *offset_ptr) const {
+  uint64_t getAddress(uint64_t *offset_ptr) const {
     return getUnsigned(offset_ptr, AddressSize);
   }
 
+  /// Extract a pointer-sized unsigned integer from the location given by the
+  /// cursor. In case of an extraction error, or if the cursor is already in
+  /// an error state, zero is returned.
+  uint64_t getAddress(Cursor &C) const { return getUnsigned(C, AddressSize); }
+
   /// Extract a uint8_t value from \a *offset_ptr.
   ///
   /// Extract a single uint8_t from the binary data at the offset
@@ -187,9 +340,20 @@
   ///     enough bytes to extract this value, the offset will be left
   ///     unmodified.
   ///
+  /// @param[in,out] Err
+  ///     A pointer to an Error object. Upon return the Error object is set to
+  ///     indicate the result (success/failure) of the function. If the Error
+  ///     object is already set when calling this function, no extraction is
+  ///     performed.
+  ///
   /// @return
   ///     The extracted uint8_t value.
-  uint8_t getU8(uint32_t *offset_ptr) const;
+  uint8_t getU8(uint64_t *offset_ptr, Error *Err = nullptr) const;
+
+  /// Extract a single uint8_t value from the location given by the cursor. In
+  /// case of an extraction error, or if the cursor is already in an error
+  /// state, zero is returned.
+  uint8_t getU8(Cursor &C) const { return getU8(&C.Offset, &C.Err); }
 
   /// Extract \a count uint8_t values from \a *offset_ptr.
   ///
@@ -214,7 +378,27 @@
   /// @return
   ///     \a dst if all values were properly extracted and copied,
   ///     NULL otherise.
-  uint8_t *getU8(uint32_t *offset_ptr, uint8_t *dst, uint32_t count) const;
+  uint8_t *getU8(uint64_t *offset_ptr, uint8_t *dst, uint32_t count) const;
+
+  /// Extract \a Count uint8_t values from the location given by the cursor and
+  /// store them into the destination buffer. In case of an extraction error, or
+  /// if the cursor is already in an error state, a nullptr is returned and the
+  /// destination buffer is left unchanged.
+  uint8_t *getU8(Cursor &C, uint8_t *Dst, uint32_t Count) const;
+
+  /// Extract \a Count uint8_t values from the location given by the cursor and
+  /// store them into the destination vector. The vector is resized to fit the
+  /// extracted data. In case of an extraction error, or if the cursor is
+  /// already in an error state, the destination vector is left unchanged and
+  /// cursor is placed into an error state.
+  void getU8(Cursor &C, SmallVectorImpl<uint8_t> &Dst, uint32_t Count) const {
+    if (isValidOffsetForDataOfSize(C.Offset, Count))
+      Dst.resize(Count);
+
+    // This relies on the fact that getU8 will not attempt to write to the
+    // buffer if isValidOffsetForDataOfSize(C.Offset, Count) is false.
+    getU8(C, Dst.data(), Count);
+  }
 
   //------------------------------------------------------------------
   /// Extract a uint16_t value from \a *offset_ptr.
@@ -229,10 +413,21 @@
   ///     enough bytes to extract this value, the offset will be left
   ///     unmodified.
   ///
+  /// @param[in,out] Err
+  ///     A pointer to an Error object. Upon return the Error object is set to
+  ///     indicate the result (success/failure) of the function. If the Error
+  ///     object is already set when calling this function, no extraction is
+  ///     performed.
+  ///
   /// @return
   ///     The extracted uint16_t value.
   //------------------------------------------------------------------
-  uint16_t getU16(uint32_t *offset_ptr) const;
+  uint16_t getU16(uint64_t *offset_ptr, Error *Err = nullptr) const;
+
+  /// Extract a single uint16_t value from the location given by the cursor. In
+  /// case of an extraction error, or if the cursor is already in an error
+  /// state, zero is returned.
+  uint16_t getU16(Cursor &C) const { return getU16(&C.Offset, &C.Err); }
 
   /// Extract \a count uint16_t values from \a *offset_ptr.
   ///
@@ -257,7 +452,7 @@
   /// @return
   ///     \a dst if all values were properly extracted and copied,
   ///     NULL otherise.
-  uint16_t *getU16(uint32_t *offset_ptr, uint16_t *dst, uint32_t count) const;
+  uint16_t *getU16(uint64_t *offset_ptr, uint16_t *dst, uint32_t count) const;
 
   /// Extract a 24-bit unsigned value from \a *offset_ptr and return it
   /// in a uint32_t.
@@ -266,15 +461,26 @@
   /// \a offset_ptr, construct a uint32_t from them and update the offset
   /// on success.
   ///
-  /// @param[in,out] offset_ptr
+  /// @param[in,out] OffsetPtr
   ///     A pointer to an offset within the data that will be advanced
   ///     by the 3 bytes if the value is extracted correctly. If the offset
   ///     is out of bounds or there are not enough bytes to extract this value,
   ///     the offset will be left unmodified.
   ///
+  /// @param[in,out] Err
+  ///     A pointer to an Error object. Upon return the Error object is set to
+  ///     indicate the result (success/failure) of the function. If the Error
+  ///     object is already set when calling this function, no extraction is
+  ///     performed.
+  ///
   /// @return
   ///     The extracted 24-bit value represented in a uint32_t.
-  uint32_t getU24(uint32_t *offset_ptr) const;
+  uint32_t getU24(uint64_t *OffsetPtr, Error *Err = nullptr) const;
+
+  /// Extract a single 24-bit unsigned value from the location given by the
+  /// cursor. In case of an extraction error, or if the cursor is already in an
+  /// error state, zero is returned.
+  uint32_t getU24(Cursor &C) const { return getU24(&C.Offset, &C.Err); }
 
   /// Extract a uint32_t value from \a *offset_ptr.
   ///
@@ -288,9 +494,20 @@
   ///     enough bytes to extract this value, the offset will be left
   ///     unmodified.
   ///
+  /// @param[in,out] Err
+  ///     A pointer to an Error object. Upon return the Error object is set to
+  ///     indicate the result (success/failure) of the function. If the Error
+  ///     object is already set when calling this function, no extraction is
+  ///     performed.
+  ///
   /// @return
   ///     The extracted uint32_t value.
-  uint32_t getU32(uint32_t *offset_ptr) const;
+  uint32_t getU32(uint64_t *offset_ptr, Error *Err = nullptr) const;
+
+  /// Extract a single uint32_t value from the location given by the cursor. In
+  /// case of an extraction error, or if the cursor is already in an error
+  /// state, zero is returned.
+  uint32_t getU32(Cursor &C) const { return getU32(&C.Offset, &C.Err); }
 
   /// Extract \a count uint32_t values from \a *offset_ptr.
   ///
@@ -315,7 +532,7 @@
   /// @return
   ///     \a dst if all values were properly extracted and copied,
   ///     NULL otherise.
-  uint32_t *getU32(uint32_t *offset_ptr, uint32_t *dst, uint32_t count) const;
+  uint32_t *getU32(uint64_t *offset_ptr, uint32_t *dst, uint32_t count) const;
 
   /// Extract a uint64_t value from \a *offset_ptr.
   ///
@@ -329,9 +546,20 @@
   ///     enough bytes to extract this value, the offset will be left
   ///     unmodified.
   ///
+  /// @param[in,out] Err
+  ///     A pointer to an Error object. Upon return the Error object is set to
+  ///     indicate the result (success/failure) of the function. If the Error
+  ///     object is already set when calling this function, no extraction is
+  ///     performed.
+  ///
   /// @return
   ///     The extracted uint64_t value.
-  uint64_t getU64(uint32_t *offset_ptr) const;
+  uint64_t getU64(uint64_t *offset_ptr, Error *Err = nullptr) const;
+
+  /// Extract a single uint64_t value from the location given by the cursor. In
+  /// case of an extraction error, or if the cursor is already in an error
+  /// state, zero is returned.
+  uint64_t getU64(Cursor &C) const { return getU64(&C.Offset, &C.Err); }
 
   /// Extract \a count uint64_t values from \a *offset_ptr.
   ///
@@ -356,7 +584,7 @@
   /// @return
   ///     \a dst if all values were properly extracted and copied,
   ///     NULL otherise.
-  uint64_t *getU64(uint32_t *offset_ptr, uint64_t *dst, uint32_t count) const;
+  uint64_t *getU64(uint64_t *offset_ptr, uint64_t *dst, uint32_t count) const;
 
   /// Extract a signed LEB128 value from \a *offset_ptr.
   ///
@@ -365,16 +593,27 @@
   /// pointed to by \a offset_ptr will be updated with the offset of
   /// the byte following the last extracted byte.
   ///
-  /// @param[in,out] offset_ptr
+  /// @param[in,out] OffsetPtr
   ///     A pointer to an offset within the data that will be advanced
   ///     by the appropriate number of bytes if the value is extracted
   ///     correctly. If the offset is out of bounds or there are not
   ///     enough bytes to extract this value, the offset will be left
   ///     unmodified.
   ///
+  /// @param[in,out] Err
+  ///     A pointer to an Error object. Upon return the Error object is set to
+  ///     indicate the result (success/failure) of the function. If the Error
+  ///     object is already set when calling this function, no extraction is
+  ///     performed.
+  ///
   /// @return
   ///     The extracted signed integer value.
-  int64_t getSLEB128(uint32_t *offset_ptr) const;
+  int64_t getSLEB128(uint64_t *OffsetPtr, Error *Err = nullptr) const;
+
+  /// Extract an signed LEB128 value from the location given by the cursor.
+  /// In case of an extraction error, or if the cursor is already in an error
+  /// state, zero is returned.
+  int64_t getSLEB128(Cursor &C) const { return getSLEB128(&C.Offset, &C.Err); }
 
   /// Extract a unsigned LEB128 value from \a *offset_ptr.
   ///
@@ -390,23 +629,44 @@
   ///     enough bytes to extract this value, the offset will be left
   ///     unmodified.
   ///
+  /// @param[in,out] Err
+  ///     A pointer to an Error object. Upon return the Error object is set to
+  ///     indicate the result (success/failure) of the function. If the Error
+  ///     object is already set when calling this function, no extraction is
+  ///     performed.
+  ///
   /// @return
   ///     The extracted unsigned integer value.
-  uint64_t getULEB128(uint32_t *offset_ptr) const;
+  uint64_t getULEB128(uint64_t *offset_ptr, llvm::Error *Err = nullptr) const;
+
+  /// Extract an unsigned LEB128 value from the location given by the cursor.
+  /// In case of an extraction error, or if the cursor is already in an error
+  /// state, zero is returned.
+  uint64_t getULEB128(Cursor &C) const { return getULEB128(&C.Offset, &C.Err); }
+
+  /// Advance the Cursor position by the given number of bytes. No-op if the
+  /// cursor is in an error state.
+  void skip(Cursor &C, uint64_t Length) const;
+
+  /// Return true iff the cursor is at the end of the buffer, regardless of the
+  /// error state of the cursor. The only way both eof and error states can be
+  /// true is if one attempts a read while the cursor is at the very end of the
+  /// data buffer.
+  bool eof(const Cursor &C) const { return size() == C.Offset; }
 
   /// Test the validity of \a offset.
   ///
   /// @return
   ///     \b true if \a offset is a valid offset into the data in this
   ///     object, \b false otherwise.
-  bool isValidOffset(uint32_t offset) const { return Data.size() > offset; }
+  bool isValidOffset(uint64_t offset) const { return size() > offset; }
 
   /// Test the availability of \a length bytes of data from \a offset.
   ///
   /// @return
   ///     \b true if \a offset is a valid offset and there are \a
   ///     length bytes available at that offset, \b false otherwise.
-  bool isValidOffsetForDataOfSize(uint32_t offset, uint32_t length) const {
+  bool isValidOffsetForDataOfSize(uint64_t offset, uint64_t length) const {
     return offset + length >= offset && isValidOffset(offset + length - 1);
   }
 
@@ -417,9 +677,28 @@
   ///     \b true if \a offset is a valid offset and there are enough
   ///     bytes for a pointer available at that offset, \b false
   ///     otherwise.
-  bool isValidOffsetForAddress(uint32_t offset) const {
+  bool isValidOffsetForAddress(uint64_t offset) const {
     return isValidOffsetForDataOfSize(offset, AddressSize);
   }
+
+  /// Return the number of bytes in the underlying buffer.
+  size_t size() const { return Data.size(); }
+
+protected:
+  // Make it possible for subclasses to access these fields without making them
+  // public.
+  static uint64_t &getOffset(Cursor &C) { return C.Offset; }
+  static Error &getError(Cursor &C) { return C.Err; }
+
+private:
+  /// If it is possible to read \a Size bytes at offset \a Offset, returns \b
+  /// true. Otherwise, returns \b false. If \a E is not nullptr, also sets the
+  /// error object to indicate an error.
+  bool prepareRead(uint64_t Offset, uint64_t Size, Error *E) const;
+
+  template <typename T> T getU(uint64_t *OffsetPtr, Error *Err) const;
+  template <typename T>
+  T *getUs(uint64_t *OffsetPtr, T *Dst, uint32_t Count, Error *Err) const;
 };
 
 } // namespace llvm
diff --git a/linux-x64/clang/include/llvm/Support/DebugCounter.h b/linux-x64/clang/include/llvm/Support/DebugCounter.h
index e7d1fa6..cd9474a 100644
--- a/linux-x64/clang/include/llvm/Support/DebugCounter.h
+++ b/linux-x64/clang/include/llvm/Support/DebugCounter.h
@@ -44,14 +44,15 @@
 #define LLVM_SUPPORT_DEBUGCOUNTER_H
 
 #include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/UniqueVector.h"
-#include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
-#include "llvm/Support/raw_ostream.h"
 #include <string>
 
 namespace llvm {
 
+class raw_ostream;
+
 class DebugCounter {
 public:
   ~DebugCounter();
@@ -68,7 +69,7 @@
   // line option parsing. The main reason to register counters is to produce a
   // nice list of them on the command line, but i'm not sure this is worth it.
   static unsigned registerCounter(StringRef Name, StringRef Desc) {
-    return instance().addCounter(Name, Desc);
+    return instance().addCounter(std::string(Name), std::string(Desc));
   }
   inline static bool shouldExecute(unsigned CounterName) {
     if (!isCountingEnabled())
diff --git a/linux-x64/clang/include/llvm/Support/ELFAttributeParser.h b/linux-x64/clang/include/llvm/Support/ELFAttributeParser.h
new file mode 100644
index 0000000..8bf87b2
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Support/ELFAttributeParser.h
@@ -0,0 +1,72 @@
+//===- ELF AttributeParser.h - ELF Attribute Parser -------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_SUPPORT_ELFATTRIBUTEPARSER_H
+#define LLVM_SUPPORT_ELFATTRIBUTEPARSER_H
+
+#include "ELFAttributes.h"
+#include "ScopedPrinter.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/Support/DataExtractor.h"
+#include "llvm/Support/Error.h"
+
+#include <unordered_map>
+
+namespace llvm {
+class StringRef;
+
+class ELFAttributeParser {
+  StringRef vendor;
+  std::unordered_map<unsigned, unsigned> attributes;
+  std::unordered_map<unsigned, StringRef> attributesStr;
+
+  virtual Error handler(uint64_t tag, bool &handled) = 0;
+
+protected:
+  ScopedPrinter *sw;
+  TagNameMap tagToStringMap;
+  DataExtractor de{ArrayRef<uint8_t>{}, true, 0};
+  DataExtractor::Cursor cursor{0};
+
+  void printAttribute(unsigned tag, unsigned value, StringRef valueDesc);
+
+  Error parseStringAttribute(const char *name, unsigned tag,
+                             ArrayRef<const char *> strings);
+  Error parseAttributeList(uint32_t length);
+  void parseIndexList(SmallVectorImpl<uint8_t> &indexList);
+  Error parseSubsection(uint32_t length);
+
+public:
+  virtual ~ELFAttributeParser() { static_cast<void>(!cursor.takeError()); }
+  Error integerAttribute(unsigned tag);
+  Error stringAttribute(unsigned tag);
+
+  ELFAttributeParser(ScopedPrinter *sw, TagNameMap tagNameMap, StringRef vendor)
+      : vendor(vendor), sw(sw), tagToStringMap(tagNameMap) {}
+
+  ELFAttributeParser(TagNameMap tagNameMap, StringRef vendor)
+      : vendor(vendor), sw(nullptr), tagToStringMap(tagNameMap) {}
+
+  Error parse(ArrayRef<uint8_t> section, support::endianness endian);
+
+  Optional<unsigned> getAttributeValue(unsigned tag) const {
+    auto I = attributes.find(tag);
+    if (I == attributes.end())
+      return None;
+    return I->second;
+  }
+  Optional<StringRef> getAttributeString(unsigned tag) const {
+    auto I = attributesStr.find(tag);
+    if (I == attributesStr.end())
+      return None;
+    return I->second;
+  }
+};
+
+} // namespace llvm
+#endif
diff --git a/linux-x64/clang/include/llvm/Support/ELFAttributes.h b/linux-x64/clang/include/llvm/Support/ELFAttributes.h
new file mode 100644
index 0000000..c8a7ae1
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Support/ELFAttributes.h
@@ -0,0 +1,37 @@
+//===-- ELFAttributes.h - ELF Attributes ------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_SUPPORT_ELFATTRIBUTES_H
+#define LLVM_SUPPORT_ELFATTRIBUTES_H
+
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/StringRef.h"
+
+namespace llvm {
+
+struct TagNameItem {
+  unsigned attr;
+  StringRef tagName;
+};
+
+using TagNameMap = ArrayRef<TagNameItem>;
+
+namespace ELFAttrs {
+
+enum AttrType : unsigned { File = 1, Section = 2, Symbol = 3 };
+
+StringRef attrTypeAsString(unsigned attr, TagNameMap tagNameMap,
+                           bool hasTagPrefix = true);
+Optional<unsigned> attrTypeFromString(StringRef tag, TagNameMap tagNameMap);
+
+// Magic numbers for ELF attributes.
+enum AttrMagic { Format_Version = 0x41 };
+
+} // namespace ELFAttrs
+} // namespace llvm
+#endif
diff --git a/linux-x64/clang/include/llvm/Support/Endian.h b/linux-x64/clang/include/llvm/Support/Endian.h
index d8be944..5e7c1e9 100644
--- a/linux-x64/clang/include/llvm/Support/Endian.h
+++ b/linux-x64/clang/include/llvm/Support/Endian.h
@@ -13,9 +13,7 @@
 #ifndef LLVM_SUPPORT_ENDIAN_H
 #define LLVM_SUPPORT_ENDIAN_H
 
-#include "llvm/Support/AlignOf.h"
 #include "llvm/Support/Compiler.h"
-#include "llvm/Support/Host.h"
 #include "llvm/Support/SwapByteOrder.h"
 #include <cassert>
 #include <cstddef>
@@ -111,7 +109,7 @@
 }
 
 template <typename value_type>
-using make_unsigned_t = typename std::make_unsigned<value_type>::type;
+using make_unsigned_t = std::make_unsigned_t<value_type>;
 
 /// Read a value of a particular endianness from memory, for a location
 /// that starts at the given bit offset within the first byte.
@@ -203,9 +201,8 @@
 
 namespace detail {
 
-template<typename ValueType,
-         endianness Endian,
-         std::size_t Alignment>
+template <typename ValueType, endianness Endian, std::size_t Alignment,
+          std::size_t ALIGN = PickAlignment<ValueType, Alignment>::value>
 struct packed_endian_specific_integral {
   using value_type = ValueType;
   static constexpr endianness endian = Endian;
@@ -246,8 +243,9 @@
   }
 
 private:
-  AlignedCharArray<PickAlignment<value_type, alignment>::value,
-                   sizeof(value_type)> Value;
+  struct {
+    alignas(ALIGN) char buffer[sizeof(value_type)];
+  } Value;
 
 public:
   struct ref {
diff --git a/linux-x64/clang/include/llvm/Support/Errno.h b/linux-x64/clang/include/llvm/Support/Errno.h
index aedb5fb..dc3b332 100644
--- a/linux-x64/clang/include/llvm/Support/Errno.h
+++ b/linux-x64/clang/include/llvm/Support/Errno.h
@@ -30,8 +30,8 @@
 std::string StrError(int errnum);
 
 template <typename FailT, typename Fun, typename... Args>
-inline auto RetryAfterSignal(const FailT &Fail, const Fun &F,
-                             const Args &... As) -> decltype(F(As...)) {
+inline decltype(auto) RetryAfterSignal(const FailT &Fail, const Fun &F,
+                                       const Args &... As) {
   decltype(F(As...)) Res;
   do {
     errno = 0;
diff --git a/linux-x64/clang/include/llvm/Support/Error.h b/linux-x64/clang/include/llvm/Support/Error.h
index 299fce7..c0f7c10 100644
--- a/linux-x64/clang/include/llvm/Support/Error.h
+++ b/linux-x64/clang/include/llvm/Support/Error.h
@@ -155,10 +155,10 @@
 /// they're moved-assigned or constructed from Success values that have already
 /// been checked. This enforces checking through all levels of the call stack.
 class LLVM_NODISCARD Error {
-  // Both ErrorList and FileError need to be able to yank ErrorInfoBase
-  // pointers out of this class to add to the error list.
+  // ErrorList needs to be able to yank ErrorInfoBase pointers out of Errors
+  // to add to the error list. It can't rely on handleErrors for this, since
+  // handleErrors does not support ErrorList handlers.
   friend class ErrorList;
-  friend class FileError;
 
   // handleErrors needs to be able to set the Checked flag.
   template <typename... HandlerTs>
@@ -269,9 +269,13 @@
   }
 
   ErrorInfoBase *getPtr() const {
+#if LLVM_ENABLE_ABI_BREAKING_CHECKS
     return reinterpret_cast<ErrorInfoBase*>(
              reinterpret_cast<uintptr_t>(Payload) &
              ~static_cast<uintptr_t>(0x1));
+#else
+    return Payload;
+#endif
   }
 
   void setPtr(ErrorInfoBase *EI) {
@@ -294,10 +298,12 @@
   }
 
   void setChecked(bool V) {
+#if LLVM_ENABLE_ABI_BREAKING_CHECKS
     Payload = reinterpret_cast<ErrorInfoBase*>(
                 (reinterpret_cast<uintptr_t>(Payload) &
                   ~static_cast<uintptr_t>(0x1)) |
                   (V ? 0 : 1));
+#endif
   }
 
   std::unique_ptr<ErrorInfoBase> takePayload() {
@@ -328,7 +334,7 @@
 /// Make a Error instance representing failure using the given error info
 /// type.
 template <typename ErrT, typename... ArgTs> Error make_error(ArgTs &&... Args) {
-  return Error(llvm::make_unique<ErrT>(std::forward<ArgTs>(Args)...));
+  return Error(std::make_unique<ErrT>(std::forward<ArgTs>(Args)...));
 }
 
 /// Base class for user error types. Users should declare their error types
@@ -434,21 +440,21 @@
   template <class T1> friend class ExpectedAsOutParameter;
   template <class OtherT> friend class Expected;
 
-  static const bool isRef = std::is_reference<T>::value;
+  static constexpr bool isRef = std::is_reference<T>::value;
 
-  using wrap = std::reference_wrapper<typename std::remove_reference<T>::type>;
+  using wrap = std::reference_wrapper<std::remove_reference_t<T>>;
 
   using error_type = std::unique_ptr<ErrorInfoBase>;
 
 public:
-  using storage_type = typename std::conditional<isRef, wrap, T>::type;
+  using storage_type = std::conditional_t<isRef, wrap, T>;
   using value_type = T;
 
 private:
-  using reference = typename std::remove_reference<T>::type &;
-  using const_reference = const typename std::remove_reference<T>::type &;
-  using pointer = typename std::remove_reference<T>::type *;
-  using const_pointer = const typename std::remove_reference<T>::type *;
+  using reference = std::remove_reference_t<T> &;
+  using const_reference = const std::remove_reference_t<T> &;
+  using pointer = std::remove_reference_t<T> *;
+  using const_pointer = const std::remove_reference_t<T> *;
 
 public:
   /// Create an Expected<T> error value from the given Error.
@@ -472,12 +478,12 @@
   /// must be convertible to T.
   template <typename OtherT>
   Expected(OtherT &&Val,
-           typename std::enable_if<std::is_convertible<OtherT, T>::value>::type
-               * = nullptr)
+           std::enable_if_t<std::is_convertible<OtherT, T>::value> * = nullptr)
       : HasError(false)
 #if LLVM_ENABLE_ABI_BREAKING_CHECKS
         // Expected is unchecked upon construction in Debug builds.
-        , Unchecked(true)
+        ,
+        Unchecked(true)
 #endif
   {
     new (getStorage()) storage_type(std::forward<OtherT>(Val));
@@ -489,9 +495,9 @@
   /// Move construct an Expected<T> value from an Expected<OtherT>, where OtherT
   /// must be convertible to T.
   template <class OtherT>
-  Expected(Expected<OtherT> &&Other,
-           typename std::enable_if<std::is_convertible<OtherT, T>::value>::type
-               * = nullptr) {
+  Expected(
+      Expected<OtherT> &&Other,
+      std::enable_if_t<std::is_convertible<OtherT, T>::value> * = nullptr) {
     moveConstruct(std::move(Other));
   }
 
@@ -500,8 +506,7 @@
   template <class OtherT>
   explicit Expected(
       Expected<OtherT> &&Other,
-      typename std::enable_if<!std::is_convertible<OtherT, T>::value>::type * =
-          nullptr) {
+      std::enable_if_t<!std::is_convertible<OtherT, T>::value> * = nullptr) {
     moveConstruct(std::move(Other));
   }
 
@@ -548,7 +553,7 @@
   /// Take ownership of the stored error.
   /// After calling this the Expected<T> is in an indeterminate state that can
   /// only be safely destructed. No further calls (beside the destructor) should
-  /// be made on the Expected<T> vaule.
+  /// be made on the Expected<T> value.
   Error takeError() {
 #if LLVM_ENABLE_ABI_BREAKING_CHECKS
     Unchecked = false;
@@ -624,22 +629,22 @@
 
   storage_type *getStorage() {
     assert(!HasError && "Cannot get value when an error exists!");
-    return reinterpret_cast<storage_type *>(TStorage.buffer);
+    return reinterpret_cast<storage_type *>(&TStorage);
   }
 
   const storage_type *getStorage() const {
     assert(!HasError && "Cannot get value when an error exists!");
-    return reinterpret_cast<const storage_type *>(TStorage.buffer);
+    return reinterpret_cast<const storage_type *>(&TStorage);
   }
 
   error_type *getErrorStorage() {
     assert(HasError && "Cannot get error when a value exists!");
-    return reinterpret_cast<error_type *>(ErrorStorage.buffer);
+    return reinterpret_cast<error_type *>(&ErrorStorage);
   }
 
   const error_type *getErrorStorage() const {
     assert(HasError && "Cannot get error when a value exists!");
-    return reinterpret_cast<const error_type *>(ErrorStorage.buffer);
+    return reinterpret_cast<const error_type *>(&ErrorStorage);
   }
 
   // Used by ExpectedAsOutParameter to reset the checked flag.
@@ -704,6 +709,12 @@
   if (Err) {
     if (!Msg)
       Msg = "Failure value returned from cantFail wrapped call";
+#ifndef NDEBUG
+    std::string Str;
+    raw_string_ostream OS(Str);
+    OS << Msg << "\n" << Err;
+    Msg = OS.str().c_str();
+#endif
     llvm_unreachable(Msg);
   }
 }
@@ -728,6 +739,13 @@
   else {
     if (!Msg)
       Msg = "Failure value returned from cantFail wrapped call";
+#ifndef NDEBUG
+    std::string Str;
+    raw_string_ostream OS(Str);
+    auto E = ValOrErr.takeError();
+    OS << Msg << "\n" << E;
+    Msg = OS.str().c_str();
+#endif
     llvm_unreachable(Msg);
   }
 }
@@ -752,6 +770,13 @@
   else {
     if (!Msg)
       Msg = "Failure value returned from cantFail wrapped call";
+#ifndef NDEBUG
+    std::string Str;
+    raw_string_ostream OS(Str);
+    auto E = ValOrErr.takeError();
+    OS << Msg << "\n" << E;
+    Msg = OS.str().c_str();
+#endif
     llvm_unreachable(Msg);
   }
 }
@@ -982,6 +1007,20 @@
   handleAllErrors(std::move(Err), [](const ErrorInfoBase &) {});
 }
 
+/// Convert an Expected to an Optional without doing anything. This method
+/// should be used only where an error can be considered a reasonable and
+/// expected return value.
+///
+/// Uses of this method are potentially indicative of problems: perhaps the
+/// error should be propagated further, or the error-producer should just
+/// return an Optional in the first place.
+template <typename T> Optional<T> expectedToOptional(Expected<T> &&E) {
+  if (E)
+    return std::move(*E);
+  consumeError(E.takeError());
+  return None;
+}
+
 /// Helper for converting an Error to a bool.
 ///
 /// This method returns true if Err is in an error state, or false if it is
@@ -1170,6 +1209,10 @@
 
 Error createStringError(std::error_code EC, char const *Msg);
 
+inline Error createStringError(std::error_code EC, const Twine &S) {
+  return createStringError(EC, S.str().c_str());
+}
+
 template <typename... Ts>
 inline Error createStringError(std::errc EC, char const *Fmt,
                                const Ts &... Vals) {
@@ -1194,6 +1237,8 @@
     Err->log(OS);
   }
 
+  StringRef getFileName() { return FileName; }
+
   Error takeError() { return Error(std::move(Err)); }
 
   std::error_code convertToErrorCode() const override;
@@ -1213,8 +1258,14 @@
   }
 
   static Error build(const Twine &F, Optional<size_t> Line, Error E) {
+    std::unique_ptr<ErrorInfoBase> Payload;
+    handleAllErrors(std::move(E),
+                    [&](std::unique_ptr<ErrorInfoBase> EIB) -> Error {
+                      Payload = std::move(EIB);
+                      return Error::success();
+                    });
     return Error(
-        std::unique_ptr<FileError>(new FileError(F, Line, E.takePayload())));
+        std::unique_ptr<FileError>(new FileError(F, Line, std::move(Payload))));
   }
 
   std::string FileName;
diff --git a/linux-x64/clang/include/llvm/Support/ErrorHandling.h b/linux-x64/clang/include/llvm/Support/ErrorHandling.h
index f75c298..0ec0242 100644
--- a/linux-x64/clang/include/llvm/Support/ErrorHandling.h
+++ b/linux-x64/clang/include/llvm/Support/ErrorHandling.h
@@ -66,7 +66,7 @@
 ///
 /// If no error handler is installed the default is to print the message to
 /// standard error, followed by a newline.
-/// After the error handler is called this function will call exit(1), it
+/// After the error handler is called this function will call abort(), it
 /// does not return.
 LLVM_ATTRIBUTE_NORETURN void report_fatal_error(const char *reason,
                                                 bool gen_crash_diag = true);
@@ -103,17 +103,18 @@
 
 /// Reports a bad alloc error, calling any user defined bad alloc
 /// error handler. In contrast to the generic 'report_fatal_error'
-/// functions, this function is expected to return, e.g. the user
-/// defined error handler throws an exception.
+/// functions, this function might not terminate, e.g. the user
+/// defined error handler throws an exception, but it won't return.
 ///
 /// Note: When throwing an exception in the bad alloc handler, make sure that
 /// the following unwind succeeds, e.g. do not trigger additional allocations
 /// in the unwind chain.
 ///
-/// If no error handler is installed (default), then a bad_alloc exception
-/// is thrown, if LLVM is compiled with exception support, otherwise an
-/// assertion is called.
-void report_bad_alloc_error(const char *Reason, bool GenCrashDiag = true);
+/// If no error handler is installed (default), throws a bad_alloc exception
+/// if LLVM is compiled with exception support. Otherwise prints the error
+/// to standard error and calls abort().
+LLVM_ATTRIBUTE_NORETURN void report_bad_alloc_error(const char *Reason,
+                                                    bool GenCrashDiag = true);
 
 /// This function calls abort(), and prints the optional message to stderr.
 /// Use the llvm_unreachable macro (that adds location info), instead of
@@ -127,7 +128,7 @@
 /// In !NDEBUG builds, prints the message and location info to stderr.
 /// In NDEBUG builds, becomes an optimizer hint that the current location
 /// is not supposed to be reachable.  On compilers that don't support
-/// such hints, prints a reduced message instead.
+/// such hints, prints a reduced message instead and aborts the program.
 ///
 /// Use this instead of assert(0).  It conveys intent more clearly and
 /// allows compilers to omit some unnecessary code.
diff --git a/linux-x64/clang/include/llvm/Support/ErrorOr.h b/linux-x64/clang/include/llvm/Support/ErrorOr.h
index 8211f4d..b654c9c 100644
--- a/linux-x64/clang/include/llvm/Support/ErrorOr.h
+++ b/linux-x64/clang/include/llvm/Support/ErrorOr.h
@@ -56,25 +56,25 @@
 class ErrorOr {
   template <class OtherT> friend class ErrorOr;
 
-  static const bool isRef = std::is_reference<T>::value;
+  static constexpr bool isRef = std::is_reference<T>::value;
 
-  using wrap = std::reference_wrapper<typename std::remove_reference<T>::type>;
+  using wrap = std::reference_wrapper<std::remove_reference_t<T>>;
 
 public:
-  using storage_type = typename std::conditional<isRef, wrap, T>::type;
+  using storage_type = std::conditional_t<isRef, wrap, T>;
 
 private:
-  using reference = typename std::remove_reference<T>::type &;
-  using const_reference = const typename std::remove_reference<T>::type &;
-  using pointer = typename std::remove_reference<T>::type *;
-  using const_pointer = const typename std::remove_reference<T>::type *;
+  using reference = std::remove_reference_t<T> &;
+  using const_reference = const std::remove_reference_t<T> &;
+  using pointer = std::remove_reference_t<T> *;
+  using const_pointer = const std::remove_reference_t<T> *;
 
 public:
   template <class E>
   ErrorOr(E ErrorCode,
-          typename std::enable_if<std::is_error_code_enum<E>::value ||
-                                      std::is_error_condition_enum<E>::value,
-                                  void *>::type = nullptr)
+          std::enable_if_t<std::is_error_code_enum<E>::value ||
+                               std::is_error_condition_enum<E>::value,
+                           void *> = nullptr)
       : HasError(true) {
     new (getErrorStorage()) std::error_code(make_error_code(ErrorCode));
   }
@@ -85,8 +85,7 @@
 
   template <class OtherT>
   ErrorOr(OtherT &&Val,
-          typename std::enable_if<std::is_convertible<OtherT, T>::value>::type
-              * = nullptr)
+          std::enable_if_t<std::is_convertible<OtherT, T>::value> * = nullptr)
       : HasError(false) {
     new (getStorage()) storage_type(std::forward<OtherT>(Val));
   }
@@ -96,18 +95,16 @@
   }
 
   template <class OtherT>
-  ErrorOr(
-      const ErrorOr<OtherT> &Other,
-      typename std::enable_if<std::is_convertible<OtherT, T>::value>::type * =
-          nullptr) {
+  ErrorOr(const ErrorOr<OtherT> &Other,
+          std::enable_if_t<std::is_convertible<OtherT, T>::value> * = nullptr) {
     copyConstruct(Other);
   }
 
   template <class OtherT>
   explicit ErrorOr(
       const ErrorOr<OtherT> &Other,
-      typename std::enable_if<
-          !std::is_convertible<OtherT, const T &>::value>::type * = nullptr) {
+      std::enable_if_t<!std::is_convertible<OtherT, const T &>::value> * =
+          nullptr) {
     copyConstruct(Other);
   }
 
@@ -116,10 +113,8 @@
   }
 
   template <class OtherT>
-  ErrorOr(
-      ErrorOr<OtherT> &&Other,
-      typename std::enable_if<std::is_convertible<OtherT, T>::value>::type * =
-          nullptr) {
+  ErrorOr(ErrorOr<OtherT> &&Other,
+          std::enable_if_t<std::is_convertible<OtherT, T>::value> * = nullptr) {
     moveConstruct(std::move(Other));
   }
 
@@ -128,8 +123,7 @@
   template <class OtherT>
   explicit ErrorOr(
       ErrorOr<OtherT> &&Other,
-      typename std::enable_if<!std::is_convertible<OtherT, T>::value>::type * =
-          nullptr) {
+      std::enable_if_t<!std::is_convertible<OtherT, T>::value> * = nullptr) {
     moveConstruct(std::move(Other));
   }
 
@@ -241,17 +235,17 @@
 
   storage_type *getStorage() {
     assert(!HasError && "Cannot get value when an error exists!");
-    return reinterpret_cast<storage_type*>(TStorage.buffer);
+    return reinterpret_cast<storage_type *>(&TStorage);
   }
 
   const storage_type *getStorage() const {
     assert(!HasError && "Cannot get value when an error exists!");
-    return reinterpret_cast<const storage_type*>(TStorage.buffer);
+    return reinterpret_cast<const storage_type *>(&TStorage);
   }
 
   std::error_code *getErrorStorage() {
     assert(HasError && "Cannot get error when a value exists!");
-    return reinterpret_cast<std::error_code *>(ErrorStorage.buffer);
+    return reinterpret_cast<std::error_code *>(&ErrorStorage);
   }
 
   const std::error_code *getErrorStorage() const {
@@ -266,9 +260,9 @@
 };
 
 template <class T, class E>
-typename std::enable_if<std::is_error_code_enum<E>::value ||
-                            std::is_error_condition_enum<E>::value,
-                        bool>::type
+std::enable_if_t<std::is_error_code_enum<E>::value ||
+                     std::is_error_condition_enum<E>::value,
+                 bool>
 operator==(const ErrorOr<T> &Err, E Code) {
   return Err.getError() == Code;
 }
diff --git a/linux-x64/clang/include/llvm/Support/ExitCodes.h b/linux-x64/clang/include/llvm/Support/ExitCodes.h
new file mode 100644
index 0000000..b9041f5
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Support/ExitCodes.h
@@ -0,0 +1,33 @@
+//===-- llvm/Support/ExitCodes.h - Exit codes for exit()  -------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file contains definitions of exit codes for exit() function. They are
+/// either defined by sysexits.h if it is supported, or defined here if
+/// sysexits.h is not supported.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_SUPPORT_EXITCODES_H
+#define LLVM_SUPPORT_EXITCODES_H
+
+#include "llvm/Config/llvm-config.h"
+
+#if HAVE_SYSEXITS_H
+#include <sysexits.h>
+#elif __MVS__
+// <sysexits.h> does not exist on z/OS. The only value used in LLVM is
+// EX_IOERR, which is used to signal a special error condition (broken pipe).
+// Define the macro with its usual value from BSD systems, which is chosen to
+// not clash with more standard exit codes like 1.
+#define EX_IOERR 74
+#elif LLVM_ON_UNIX
+#error Exit code EX_IOERR not available
+#endif
+
+#endif
diff --git a/linux-x64/clang/include/llvm/Support/ExtensibleRTTI.h b/linux-x64/clang/include/llvm/Support/ExtensibleRTTI.h
new file mode 100644
index 0000000..6b8510c
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Support/ExtensibleRTTI.h
@@ -0,0 +1,135 @@
+//===-- llvm/Support/ExtensibleRTTI.h - ExtensibleRTTI support --*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// \file
+//
+// Defines an extensible RTTI mechanism designed to work with Casting.h.
+//
+// Extensible RTTI differs from LLVM's primary RTTI mechanism (see
+// llvm.org/docs/HowToSetUpLLVMStyleRTTI.html) by supporting open type
+// hierarchies, where new types can be added from outside libraries without
+// needing to change existing code. LLVM's primary RTTI mechanism should be
+// preferred where possible, but where open hierarchies are needed this system
+// can be used.
+//
+// The RTTIRoot class defines methods for comparing type ids. Implementations
+// of these methods can be injected into new classes using the RTTIExtends
+// class template.
+//
+// E.g.
+//
+//   @code{.cpp}
+//   class MyBaseClass : public RTTIExtends<MyBaseClass, RTTIRoot> {
+//   public:
+//     static char ID;
+//     virtual void foo() = 0;
+//   };
+//
+//   class MyDerivedClass1 : public RTTIExtends<MyDerivedClass1, MyBaseClass> {
+//   public:
+//     static char ID;
+//     void foo() override {}
+//   };
+//
+//   class MyDerivedClass2 : public RTTIExtends<MyDerivedClass2, MyBaseClass> {
+//   public:
+//     static char ID;
+//     void foo() override {}
+//   };
+//
+//   char MyBaseClass::ID = 0;
+//   char MyDerivedClass1::ID = 0;
+//   char MyDerivedClass2:: ID = 0;
+//
+//   void fn() {
+//     std::unique_ptr<MyBaseClass> B = llvm::make_unique<MyDerivedClass1>();
+//     llvm::outs() << isa<MyBaseClass>(B) << "\n"; // Outputs "1".
+//     llvm::outs() << isa<MyDerivedClass1>(B) << "\n"; // Outputs "1".
+//     llvm::outs() << isa<MyDerivedClass2>(B) << "\n"; // Outputs "0'.
+//   }
+//
+//   @endcode
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_SUPPORT_EXTENSIBLERTTI_H
+#define LLVM_SUPPORT_EXTENSIBLERTTI_H
+
+namespace llvm {
+
+template <typename ThisT, typename ParentT> class RTTIExtends;
+
+/// Base class for the extensible RTTI hierarchy.
+///
+/// This class defines virtual methods, dynamicClassID and isA, that enable
+/// type comparisons.
+class RTTIRoot {
+public:
+  virtual ~RTTIRoot() = default;
+
+  /// Returns the class ID for this type.
+  static const void *classID() { return &ID; }
+
+  /// Returns the class ID for the dynamic type of this RTTIRoot instance.
+  virtual const void *dynamicClassID() const = 0;
+
+  /// Returns true if this class's ID matches the given class ID.
+  virtual bool isA(const void *const ClassID) const {
+    return ClassID == classID();
+  }
+
+  /// Check whether this instance is a subclass of QueryT.
+  template <typename QueryT>
+  bool isA() const { return isA(QueryT::classID()); }
+
+private:
+  virtual void anchor();
+
+  static char ID;
+};
+
+/// Inheritance utility for extensible RTTI.
+///
+/// Supports single inheritance only: A class can only have one
+/// ExtensibleRTTI-parent (i.e. a parent for which the isa<> test will work),
+/// though it can have many non-ExtensibleRTTI parents.
+///
+/// RTTIExtents uses CRTP so the first template argument to RTTIExtends is the
+/// newly introduced type, and the *second* argument is the parent class.
+///
+/// class MyType : public RTTIExtends<MyType, RTTIRoot> {
+/// public:
+///   static char ID;
+/// };
+///
+/// class MyDerivedType : public RTTIExtends<MyDerivedType, MyType> {
+/// public:
+///   static char ID;
+/// };
+///
+template <typename ThisT, typename ParentT>
+class RTTIExtends : public ParentT {
+public:
+  // Inherit constructors from ParentT.
+  using ParentT::ParentT;
+
+  static const void *classID() { return &ThisT::ID; }
+
+  const void *dynamicClassID() const override { return &ThisT::ID; }
+
+  bool isA(const void *const ClassID) const override {
+    return ClassID == classID() || ParentT::isA(ClassID);
+  }
+
+  static bool classof(const RTTIRoot *R) { return R->isA<ThisT>(); }
+};
+
+} // end namespace llvm
+
+#endif // LLVM_SUPPORT_EXTENSIBLERTTI_H
diff --git a/linux-x64/clang/include/llvm/Support/Extension.def b/linux-x64/clang/include/llvm/Support/Extension.def
new file mode 100644
index 0000000..cb872c0
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Support/Extension.def
@@ -0,0 +1,3 @@
+//extension handlers
+HANDLE_EXTENSION(Polly)
+#undef HANDLE_EXTENSION
diff --git a/linux-x64/clang/include/llvm/Support/FileCheck.h b/linux-x64/clang/include/llvm/Support/FileCheck.h
deleted file mode 100644
index b3a8433..0000000
--- a/linux-x64/clang/include/llvm/Support/FileCheck.h
+++ /dev/null
@@ -1,693 +0,0 @@
-//==-- llvm/Support/FileCheck.h ---------------------------*- C++ -*-==//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-/// \file This file has some utilities to use FileCheck as an API
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_SUPPORT_FILECHECK_H
-#define LLVM_SUPPORT_FILECHECK_H
-
-#include "llvm/ADT/StringMap.h"
-#include "llvm/Support/MemoryBuffer.h"
-#include "llvm/Support/Regex.h"
-#include "llvm/Support/SourceMgr.h"
-#include <vector>
-#include <map>
-
-namespace llvm {
-
-/// Contains info about various FileCheck options.
-struct FileCheckRequest {
-  std::vector<std::string> CheckPrefixes;
-  bool NoCanonicalizeWhiteSpace = false;
-  std::vector<std::string> ImplicitCheckNot;
-  std::vector<std::string> GlobalDefines;
-  bool AllowEmptyInput = false;
-  bool MatchFullLines = false;
-  bool EnableVarScope = false;
-  bool AllowDeprecatedDagOverlap = false;
-  bool Verbose = false;
-  bool VerboseVerbose = false;
-};
-
-//===----------------------------------------------------------------------===//
-// Numeric substitution handling code.
-//===----------------------------------------------------------------------===//
-
-/// Class representing a numeric variable and its associated current value.
-class FileCheckNumericVariable {
-private:
-  /// Name of the numeric variable.
-  StringRef Name;
-
-  /// Value of numeric variable, if defined, or None otherwise.
-  Optional<uint64_t> Value;
-
-  /// Line number where this variable is defined. Used to determine whether a
-  /// variable is defined on the same line as a given use.
-  size_t DefLineNumber;
-
-public:
-  /// Constructor for a variable \p Name defined at line \p DefLineNumber.
-  FileCheckNumericVariable(size_t DefLineNumber, StringRef Name)
-      : Name(Name), DefLineNumber(DefLineNumber) {}
-
-  /// Constructor for numeric variable \p Name with a known \p Value at parse
-  /// time (e.g. the @LINE numeric variable).
-  FileCheckNumericVariable(StringRef Name, uint64_t Value)
-      : Name(Name), Value(Value), DefLineNumber(0) {}
-
-  /// \returns name of this numeric variable.
-  StringRef getName() const { return Name; }
-
-  /// \returns this variable's value.
-  Optional<uint64_t> getValue() const { return Value; }
-
-  /// Sets value of this numeric variable, if undefined. Triggers an assertion
-  /// failure if the variable is actually defined.
-  void setValue(uint64_t Value);
-
-  /// Clears value of this numeric variable, regardless of whether it is
-  /// currently defined or not.
-  void clearValue();
-
-  /// \returns the line number where this variable is defined.
-  size_t getDefLineNumber() { return DefLineNumber; }
-};
-
-/// Type of functions evaluating a given binary operation.
-using binop_eval_t = uint64_t (*)(uint64_t, uint64_t);
-
-/// Class to represent an undefined variable error which prints that variable's
-/// name between quotes when printed.
-class FileCheckUndefVarError : public ErrorInfo<FileCheckUndefVarError> {
-private:
-  StringRef VarName;
-
-public:
-  static char ID;
-
-  FileCheckUndefVarError(StringRef VarName) : VarName(VarName) {}
-
-  StringRef getVarName() const { return VarName; }
-
-  std::error_code convertToErrorCode() const override {
-    return inconvertibleErrorCode();
-  }
-
-  /// Print name of variable associated with this error.
-  void log(raw_ostream &OS) const override {
-    OS << "\"";
-    OS.write_escaped(VarName) << "\"";
-  }
-};
-
-/// Class representing an expression consisting of either a single numeric
-/// variable or a binary operation between a numeric variable and an
-/// immediate.
-class FileCheckExpression {
-private:
-  /// Left operand.
-  FileCheckNumericVariable *LeftOp;
-
-  /// Right operand.
-  uint64_t RightOp;
-
-  /// Pointer to function that can evaluate this binary operation.
-  binop_eval_t EvalBinop;
-
-public:
-  FileCheckExpression(binop_eval_t EvalBinop,
-                      FileCheckNumericVariable *OperandLeft,
-                      uint64_t OperandRight)
-      : LeftOp(OperandLeft), RightOp(OperandRight), EvalBinop(EvalBinop) {}
-
-  /// Evaluates the value of this expression, using EvalBinop to perform the
-  /// binary operation it consists of. \returns an error if the numeric
-  /// variable used is undefined, or the expression value otherwise.
-  Expected<uint64_t> eval() const;
-};
-
-class FileCheckPatternContext;
-
-/// Class representing a substitution to perform in the RegExStr string.
-class FileCheckSubstitution {
-protected:
-  /// Pointer to a class instance holding, among other things, the table with
-  /// the values of live string variables at the start of any given CHECK line.
-  /// Used for substituting string variables with the text they were defined
-  /// as. Expressions are linked to the numeric variables they use at
-  /// parse time and directly access the value of the numeric variable to
-  /// evaluate their value.
-  FileCheckPatternContext *Context;
-
-  /// The string that needs to be substituted for something else. For a
-  /// string variable this is its name, otherwise this is the whole expression.
-  StringRef FromStr;
-
-  // Index in RegExStr of where to do the substitution.
-  size_t InsertIdx;
-
-public:
-  FileCheckSubstitution(FileCheckPatternContext *Context, StringRef VarName,
-                        size_t InsertIdx)
-      : Context(Context), FromStr(VarName), InsertIdx(InsertIdx) {}
-
-  virtual ~FileCheckSubstitution() = default;
-
-  /// \returns the string to be substituted for something else.
-  StringRef getFromString() const { return FromStr; }
-
-  /// \returns the index where the substitution is to be performed in RegExStr.
-  size_t getIndex() const { return InsertIdx; }
-
-  /// \returns a string containing the result of the substitution represented
-  /// by this class instance or an error if substitution failed.
-  virtual Expected<std::string> getResult() const = 0;
-};
-
-class FileCheckStringSubstitution : public FileCheckSubstitution {
-public:
-  FileCheckStringSubstitution(FileCheckPatternContext *Context,
-                              StringRef VarName, size_t InsertIdx)
-      : FileCheckSubstitution(Context, VarName, InsertIdx) {}
-
-  /// \returns the text that the string variable in this substitution matched
-  /// when defined, or an error if the variable is undefined.
-  Expected<std::string> getResult() const override;
-};
-
-class FileCheckNumericSubstitution : public FileCheckSubstitution {
-private:
-  /// Pointer to the class representing the expression whose value is to be
-  /// substituted.
-  FileCheckExpression *Expression;
-
-public:
-  FileCheckNumericSubstitution(FileCheckPatternContext *Context,
-                               StringRef ExpressionStr,
-                               FileCheckExpression *Expression,
-                               size_t InsertIdx)
-      : FileCheckSubstitution(Context, ExpressionStr, InsertIdx),
-        Expression(Expression) {}
-
-  /// \returns a string containing the result of evaluating the expression in
-  /// this substitution, or an error if evaluation failed.
-  Expected<std::string> getResult() const override;
-};
-
-//===----------------------------------------------------------------------===//
-// Pattern handling code.
-//===----------------------------------------------------------------------===//
-
-namespace Check {
-
-enum FileCheckKind {
-  CheckNone = 0,
-  CheckPlain,
-  CheckNext,
-  CheckSame,
-  CheckNot,
-  CheckDAG,
-  CheckLabel,
-  CheckEmpty,
-
-  /// Indicates the pattern only matches the end of file. This is used for
-  /// trailing CHECK-NOTs.
-  CheckEOF,
-
-  /// Marks when parsing found a -NOT check combined with another CHECK suffix.
-  CheckBadNot,
-
-  /// Marks when parsing found a -COUNT directive with invalid count value.
-  CheckBadCount
-};
-
-class FileCheckType {
-  FileCheckKind Kind;
-  int Count; ///< optional Count for some checks
-
-public:
-  FileCheckType(FileCheckKind Kind = CheckNone) : Kind(Kind), Count(1) {}
-  FileCheckType(const FileCheckType &) = default;
-
-  operator FileCheckKind() const { return Kind; }
-
-  int getCount() const { return Count; }
-  FileCheckType &setCount(int C);
-
-  // \returns a description of \p Prefix.
-  std::string getDescription(StringRef Prefix) const;
-};
-} // namespace Check
-
-struct FileCheckDiag;
-
-/// Class holding the FileCheckPattern global state, shared by all patterns:
-/// tables holding values of variables and whether they are defined or not at
-/// any given time in the matching process.
-class FileCheckPatternContext {
-  friend class FileCheckPattern;
-
-private:
-  /// When matching a given pattern, this holds the value of all the string
-  /// variables defined in previous patterns. In a pattern, only the last
-  /// definition for a given variable is recorded in this table.
-  /// Back-references are used for uses after any the other definition.
-  StringMap<StringRef> GlobalVariableTable;
-
-  /// Map of all string variables defined so far. Used at parse time to detect
-  /// a name conflict between a numeric variable and a string variable when
-  /// the former is defined on a later line than the latter.
-  StringMap<bool> DefinedVariableTable;
-
-  /// When matching a given pattern, this holds the pointers to the classes
-  /// representing the numeric variables defined in previous patterns. When
-  /// matching a pattern all definitions for that pattern are recorded in the
-  /// NumericVariableDefs table in the FileCheckPattern instance of that
-  /// pattern.
-  StringMap<FileCheckNumericVariable *> GlobalNumericVariableTable;
-
-  /// Pointer to the class instance representing the @LINE pseudo variable for
-  /// easily updating its value.
-  FileCheckNumericVariable *LineVariable = nullptr;
-
-  /// Vector holding pointers to all parsed expressions. Used to automatically
-  /// free the expressions once they are guaranteed to no longer be used.
-  std::vector<std::unique_ptr<FileCheckExpression>> Expressions;
-
-  /// Vector holding pointers to all parsed numeric variables. Used to
-  /// automatically free them once they are guaranteed to no longer be used.
-  std::vector<std::unique_ptr<FileCheckNumericVariable>> NumericVariables;
-
-  /// Vector holding pointers to all substitutions. Used to automatically free
-  /// them once they are guaranteed to no longer be used.
-  std::vector<std::unique_ptr<FileCheckSubstitution>> Substitutions;
-
-public:
-  /// \returns the value of string variable \p VarName or an error if no such
-  /// variable has been defined.
-  Expected<StringRef> getPatternVarValue(StringRef VarName);
-
-  /// Defines string and numeric variables from definitions given on the
-  /// command line, passed as a vector of [#]VAR=VAL strings in
-  /// \p CmdlineDefines. \returns an error list containing diagnostics against
-  /// \p SM for all definition parsing failures, if any, or Success otherwise.
-  Error defineCmdlineVariables(std::vector<std::string> &CmdlineDefines,
-                               SourceMgr &SM);
-
-  /// Create @LINE pseudo variable. Value is set when pattern are being
-  /// matched.
-  void createLineVariable();
-
-  /// Undefines local variables (variables whose name does not start with a '$'
-  /// sign), i.e. removes them from GlobalVariableTable and from
-  /// GlobalNumericVariableTable and also clears the value of numeric
-  /// variables.
-  void clearLocalVars();
-
-private:
-  /// Makes a new expression instance and registers it for destruction when
-  /// the context is destroyed.
-  FileCheckExpression *makeExpression(binop_eval_t EvalBinop,
-                                      FileCheckNumericVariable *OperandLeft,
-                                      uint64_t OperandRight);
-
-  /// Makes a new numeric variable and registers it for destruction when the
-  /// context is destroyed.
-  template <class... Types>
-  FileCheckNumericVariable *makeNumericVariable(Types... args);
-
-  /// Makes a new string substitution and registers it for destruction when the
-  /// context is destroyed.
-  FileCheckSubstitution *makeStringSubstitution(StringRef VarName,
-                                                size_t InsertIdx);
-
-  /// Makes a new numeric substitution and registers it for destruction when
-  /// the context is destroyed.
-  FileCheckSubstitution *
-  makeNumericSubstitution(StringRef ExpressionStr,
-                          FileCheckExpression *Expression, size_t InsertIdx);
-};
-
-/// Class to represent an error holding a diagnostic with location information
-/// used when printing it.
-class FileCheckErrorDiagnostic : public ErrorInfo<FileCheckErrorDiagnostic> {
-private:
-  SMDiagnostic Diagnostic;
-
-public:
-  static char ID;
-
-  FileCheckErrorDiagnostic(SMDiagnostic &&Diag) : Diagnostic(Diag) {}
-
-  std::error_code convertToErrorCode() const override {
-    return inconvertibleErrorCode();
-  }
-
-  /// Print diagnostic associated with this error when printing the error.
-  void log(raw_ostream &OS) const override { Diagnostic.print(nullptr, OS); }
-
-  static Error get(const SourceMgr &SM, SMLoc Loc, const Twine &ErrMsg) {
-    return make_error<FileCheckErrorDiagnostic>(
-        SM.GetMessage(Loc, SourceMgr::DK_Error, ErrMsg));
-  }
-
-  static Error get(const SourceMgr &SM, StringRef Buffer, const Twine &ErrMsg) {
-    return get(SM, SMLoc::getFromPointer(Buffer.data()), ErrMsg);
-  }
-};
-
-class FileCheckNotFoundError : public ErrorInfo<FileCheckNotFoundError> {
-public:
-  static char ID;
-
-  std::error_code convertToErrorCode() const override {
-    return inconvertibleErrorCode();
-  }
-
-  /// Print diagnostic associated with this error when printing the error.
-  void log(raw_ostream &OS) const override {
-    OS << "String not found in input";
-  }
-};
-
-class FileCheckPattern {
-  SMLoc PatternLoc;
-
-  /// A fixed string to match as the pattern or empty if this pattern requires
-  /// a regex match.
-  StringRef FixedStr;
-
-  /// A regex string to match as the pattern or empty if this pattern requires
-  /// a fixed string to match.
-  std::string RegExStr;
-
-  /// Entries in this vector represent a substitution of a string variable or
-  /// an expression in the RegExStr regex at match time. For example, in the
-  /// case of a CHECK directive with the pattern "foo[[bar]]baz[[#N+1]]",
-  /// RegExStr will contain "foobaz" and we'll get two entries in this vector
-  /// that tells us to insert the value of string variable "bar" at offset 3
-  /// and the value of expression "N+1" at offset 6.
-  std::vector<FileCheckSubstitution *> Substitutions;
-
-  /// Maps names of string variables defined in a pattern to the number of
-  /// their parenthesis group in RegExStr capturing their last definition.
-  ///
-  /// E.g. for the pattern "foo[[bar:.*]]baz([[bar]][[QUUX]][[bar:.*]])",
-  /// RegExStr will be "foo(.*)baz(\1<quux value>(.*))" where <quux value> is
-  /// the value captured for QUUX on the earlier line where it was defined, and
-  /// VariableDefs will map "bar" to the third parenthesis group which captures
-  /// the second definition of "bar".
-  ///
-  /// Note: uses std::map rather than StringMap to be able to get the key when
-  /// iterating over values.
-  std::map<StringRef, unsigned> VariableDefs;
-
-  /// Structure representing the definition of a numeric variable in a pattern.
-  /// It holds the pointer to the class representing the numeric variable whose
-  /// value is being defined and the number of the parenthesis group in
-  /// RegExStr to capture that value.
-  struct FileCheckNumericVariableMatch {
-    /// Pointer to class representing the numeric variable whose value is being
-    /// defined.
-    FileCheckNumericVariable *DefinedNumericVariable;
-
-    /// Number of the parenthesis group in RegExStr that captures the value of
-    /// this numeric variable definition.
-    unsigned CaptureParenGroup;
-  };
-
-  /// Holds the number of the parenthesis group in RegExStr and pointer to the
-  /// corresponding FileCheckNumericVariable class instance of all numeric
-  /// variable definitions. Used to set the matched value of all those
-  /// variables.
-  StringMap<FileCheckNumericVariableMatch> NumericVariableDefs;
-
-  /// Pointer to a class instance holding the global state shared by all
-  /// patterns:
-  /// - separate tables with the values of live string and numeric variables
-  ///   respectively at the start of any given CHECK line;
-  /// - table holding whether a string variable has been defined at any given
-  ///   point during the parsing phase.
-  FileCheckPatternContext *Context;
-
-  Check::FileCheckType CheckTy;
-
-  /// Line number for this CHECK pattern. Used to determine whether a variable
-  /// definition is made on an earlier line to the one with this CHECK.
-  size_t LineNumber;
-
-public:
-  FileCheckPattern(Check::FileCheckType Ty, FileCheckPatternContext *Context,
-                   size_t Line)
-      : Context(Context), CheckTy(Ty), LineNumber(Line) {}
-
-  /// \returns the location in source code.
-  SMLoc getLoc() const { return PatternLoc; }
-
-  /// \returns the pointer to the global state for all patterns in this
-  /// FileCheck instance.
-  FileCheckPatternContext *getContext() const { return Context; }
-
-  /// \returns whether \p C is a valid first character for a variable name.
-  static bool isValidVarNameStart(char C);
-  /// Parses the string at the start of \p Str for a variable name. \returns
-  /// an error holding a diagnostic against \p SM if parsing fail, or the
-  /// name of the variable otherwise. In the latter case, sets \p IsPseudo to
-  /// indicate if it is a pseudo variable and strips \p Str from the variable
-  /// name.
-  static Expected<StringRef> parseVariable(StringRef &Str, bool &IsPseudo,
-                                           const SourceMgr &SM);
-  /// Parses \p Expr for the name of a numeric variable to be defined at line
-  /// \p LineNumber. \returns a pointer to the class instance representing that
-  /// variable, creating it if needed, or an error holding a diagnostic against
-  /// \p SM should defining such a variable be invalid.
-  static Expected<FileCheckNumericVariable *>
-  parseNumericVariableDefinition(StringRef &Expr,
-                                 FileCheckPatternContext *Context,
-                                 size_t LineNumber, const SourceMgr &SM);
-  /// Parses \p Expr for a numeric substitution block. \returns the class
-  /// representing the AST of the expression whose value must be substituted,
-  /// or an error holding a diagnostic against \p SM if parsing fails. If
-  /// substitution was successful, sets \p DefinedNumericVariable to point to
-  /// the class representing the numeric variable defined in this numeric
-  /// substitution block, or None if this block does not define any variable.
-  Expected<FileCheckExpression *> parseNumericSubstitutionBlock(
-      StringRef Expr,
-      Optional<FileCheckNumericVariable *> &DefinedNumericVariable,
-      const SourceMgr &SM) const;
-  /// Parses the pattern in \p PatternStr and initializes this FileCheckPattern
-  /// instance accordingly.
-  ///
-  /// \p Prefix provides which prefix is being matched, \p Req describes the
-  /// global options that influence the parsing such as whitespace
-  /// canonicalization, \p SM provides the SourceMgr used for error reports.
-  /// \returns true in case of an error, false otherwise.
-  bool parsePattern(StringRef PatternStr, StringRef Prefix, SourceMgr &SM,
-                    const FileCheckRequest &Req);
-  /// Matches the pattern string against the input buffer \p Buffer
-  ///
-  /// \returns the position that is matched or an error indicating why matching
-  /// failed. If there is a match, updates \p MatchLen with the size of the
-  /// matched string.
-  ///
-  /// The GlobalVariableTable StringMap in the FileCheckPatternContext class
-  /// instance provides the current values of FileCheck string variables and
-  /// is updated if this match defines new values. Likewise, the
-  /// GlobalNumericVariableTable StringMap in the same class provides the
-  /// current values of FileCheck numeric variables and is updated if this
-  /// match defines new numeric values.
-  Expected<size_t> match(StringRef Buffer, size_t &MatchLen,
-                         const SourceMgr &SM) const;
-  /// Prints the value of successful substitutions or the name of the undefined
-  /// string or numeric variable preventing a successful substitution.
-  void printSubstitutions(const SourceMgr &SM, StringRef Buffer,
-                          SMRange MatchRange = None) const;
-  void printFuzzyMatch(const SourceMgr &SM, StringRef Buffer,
-                       std::vector<FileCheckDiag> *Diags) const;
-
-  bool hasVariable() const {
-    return !(Substitutions.empty() && VariableDefs.empty());
-  }
-
-  Check::FileCheckType getCheckTy() const { return CheckTy; }
-
-  int getCount() const { return CheckTy.getCount(); }
-
-private:
-  bool AddRegExToRegEx(StringRef RS, unsigned &CurParen, SourceMgr &SM);
-  void AddBackrefToRegEx(unsigned BackrefNum);
-  /// Computes an arbitrary estimate for the quality of matching this pattern
-  /// at the start of \p Buffer; a distance of zero should correspond to a
-  /// perfect match.
-  unsigned computeMatchDistance(StringRef Buffer) const;
-  /// Finds the closing sequence of a regex variable usage or definition.
-  ///
-  /// \p Str has to point in the beginning of the definition (right after the
-  /// opening sequence). \p SM holds the SourceMgr used for error repporting.
-  ///  \returns the offset of the closing sequence within Str, or npos if it
-  /// was not found.
-  size_t FindRegexVarEnd(StringRef Str, SourceMgr &SM);
-
-  /// Parses \p Expr for the use of a numeric variable. \returns the pointer to
-  /// the class instance representing that variable if successful, or an error
-  /// holding a diagnostic against \p SM otherwise.
-  Expected<FileCheckNumericVariable *>
-  parseNumericVariableUse(StringRef &Expr, const SourceMgr &SM) const;
-  /// Parses \p Expr for a binary operation.
-  /// \returns the class representing the binary operation of the expression,
-  /// or an error holding a diagnostic against \p SM otherwise.
-  Expected<FileCheckExpression *> parseBinop(StringRef &Expr,
-                                             const SourceMgr &SM) const;
-};
-
-//===----------------------------------------------------------------------===//
-/// Summary of a FileCheck diagnostic.
-//===----------------------------------------------------------------------===//
-
-struct FileCheckDiag {
-  /// What is the FileCheck directive for this diagnostic?
-  Check::FileCheckType CheckTy;
-  /// Where is the FileCheck directive for this diagnostic?
-  unsigned CheckLine, CheckCol;
-  /// What type of match result does this diagnostic describe?
-  ///
-  /// A directive's supplied pattern is said to be either expected or excluded
-  /// depending on whether the pattern must have or must not have a match in
-  /// order for the directive to succeed.  For example, a CHECK directive's
-  /// pattern is expected, and a CHECK-NOT directive's pattern is excluded.
-  /// All match result types whose names end with "Excluded" are for excluded
-  /// patterns, and all others are for expected patterns.
-  ///
-  /// There might be more than one match result for a single pattern.  For
-  /// example, there might be several discarded matches
-  /// (MatchFoundButDiscarded) before either a good match
-  /// (MatchFoundAndExpected) or a failure to match (MatchNoneButExpected),
-  /// and there might be a fuzzy match (MatchFuzzy) after the latter.
-  enum MatchType {
-    /// Indicates a good match for an expected pattern.
-    MatchFoundAndExpected,
-    /// Indicates a match for an excluded pattern.
-    MatchFoundButExcluded,
-    /// Indicates a match for an expected pattern, but the match is on the
-    /// wrong line.
-    MatchFoundButWrongLine,
-    /// Indicates a discarded match for an expected pattern.
-    MatchFoundButDiscarded,
-    /// Indicates no match for an excluded pattern.
-    MatchNoneAndExcluded,
-    /// Indicates no match for an expected pattern, but this might follow good
-    /// matches when multiple matches are expected for the pattern, or it might
-    /// follow discarded matches for the pattern.
-    MatchNoneButExpected,
-    /// Indicates a fuzzy match that serves as a suggestion for the next
-    /// intended match for an expected pattern with too few or no good matches.
-    MatchFuzzy,
-  } MatchTy;
-  /// The search range if MatchTy is MatchNoneAndExcluded or
-  /// MatchNoneButExpected, or the match range otherwise.
-  unsigned InputStartLine;
-  unsigned InputStartCol;
-  unsigned InputEndLine;
-  unsigned InputEndCol;
-  FileCheckDiag(const SourceMgr &SM, const Check::FileCheckType &CheckTy,
-                SMLoc CheckLoc, MatchType MatchTy, SMRange InputRange);
-};
-
-//===----------------------------------------------------------------------===//
-// Check Strings.
-//===----------------------------------------------------------------------===//
-
-/// A check that we found in the input file.
-struct FileCheckString {
-  /// The pattern to match.
-  FileCheckPattern Pat;
-
-  /// Which prefix name this check matched.
-  StringRef Prefix;
-
-  /// The location in the match file that the check string was specified.
-  SMLoc Loc;
-
-  /// All of the strings that are disallowed from occurring between this match
-  /// string and the previous one (or start of file).
-  std::vector<FileCheckPattern> DagNotStrings;
-
-  FileCheckString(const FileCheckPattern &P, StringRef S, SMLoc L)
-      : Pat(P), Prefix(S), Loc(L) {}
-
-  /// Matches check string and its "not strings" and/or "dag strings".
-  size_t Check(const SourceMgr &SM, StringRef Buffer, bool IsLabelScanMode,
-               size_t &MatchLen, FileCheckRequest &Req,
-               std::vector<FileCheckDiag> *Diags) const;
-
-  /// Verifies that there is a single line in the given \p Buffer. Errors are
-  /// reported against \p SM.
-  bool CheckNext(const SourceMgr &SM, StringRef Buffer) const;
-  /// Verifies that there is no newline in the given \p Buffer. Errors are
-  /// reported against \p SM.
-  bool CheckSame(const SourceMgr &SM, StringRef Buffer) const;
-  /// Verifies that none of the strings in \p NotStrings are found in the given
-  /// \p Buffer. Errors are reported against \p SM and diagnostics recorded in
-  /// \p Diags according to the verbosity level set in \p Req.
-  bool CheckNot(const SourceMgr &SM, StringRef Buffer,
-                const std::vector<const FileCheckPattern *> &NotStrings,
-                const FileCheckRequest &Req,
-                std::vector<FileCheckDiag> *Diags) const;
-  /// Matches "dag strings" and their mixed "not strings".
-  size_t CheckDag(const SourceMgr &SM, StringRef Buffer,
-                  std::vector<const FileCheckPattern *> &NotStrings,
-                  const FileCheckRequest &Req,
-                  std::vector<FileCheckDiag> *Diags) const;
-};
-
-/// FileCheck class takes the request and exposes various methods that
-/// use information from the request.
-class FileCheck {
-  FileCheckRequest Req;
-  FileCheckPatternContext PatternContext;
-
-public:
-  FileCheck(FileCheckRequest Req) : Req(Req) {}
-
-  // Combines the check prefixes into a single regex so that we can efficiently
-  // scan for any of the set.
-  //
-  // The semantics are that the longest-match wins which matches our regex
-  // library.
-  Regex buildCheckPrefixRegex();
-
-  /// Reads the check file from \p Buffer and records the expected strings it
-  /// contains in the \p CheckStrings vector. Errors are reported against
-  /// \p SM.
-  ///
-  /// Only expected strings whose prefix is one of those listed in \p PrefixRE
-  /// are recorded. \returns true in case of an error, false otherwise.
-  bool ReadCheckFile(SourceMgr &SM, StringRef Buffer, Regex &PrefixRE,
-                     std::vector<FileCheckString> &CheckStrings);
-
-  bool ValidateCheckPrefixes();
-
-  /// Canonicalizes whitespaces in the file. Line endings are replaced with
-  /// UNIX-style '\n'.
-  StringRef CanonicalizeFile(MemoryBuffer &MB,
-                             SmallVectorImpl<char> &OutputBuffer);
-
-  /// Checks the input to FileCheck provided in the \p Buffer against the
-  /// \p CheckStrings read from the check file and record diagnostics emitted
-  /// in \p Diags. Errors are recorded against \p SM.
-  ///
-  /// \returns false if the input fails to satisfy the checks.
-  bool CheckInput(SourceMgr &SM, StringRef Buffer,
-                  ArrayRef<FileCheckString> CheckStrings,
-                  std::vector<FileCheckDiag> *Diags = nullptr);
-};
-} // namespace llvm
-#endif
diff --git a/linux-x64/clang/include/llvm/Support/FileCollector.h b/linux-x64/clang/include/llvm/Support/FileCollector.h
new file mode 100644
index 0000000..cbb870e
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Support/FileCollector.h
@@ -0,0 +1,128 @@
+//===-- FileCollector.h -----------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_SUPPORT_FILE_COLLECTOR_H
+#define LLVM_SUPPORT_FILE_COLLECTOR_H
+
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringMap.h"
+#include "llvm/ADT/StringSet.h"
+#include "llvm/Support/VirtualFileSystem.h"
+#include <mutex>
+#include <string>
+
+namespace llvm {
+class FileCollectorFileSystem;
+class Twine;
+
+class FileCollectorBase {
+public:
+  FileCollectorBase();
+  virtual ~FileCollectorBase();
+
+  void addFile(const Twine &file);
+  void addDirectory(const Twine &Dir);
+
+protected:
+  bool markAsSeen(StringRef Path) {
+    if (Path.empty())
+      return false;
+    return Seen.insert(Path).second;
+  }
+
+  virtual void addFileImpl(StringRef SrcPath) = 0;
+
+  virtual llvm::vfs::directory_iterator
+  addDirectoryImpl(const llvm::Twine &Dir,
+                   IntrusiveRefCntPtr<vfs::FileSystem> FS,
+                   std::error_code &EC) = 0;
+
+  /// Synchronizes access to internal data structures.
+  std::mutex Mutex;
+
+  /// Tracks already seen files so they can be skipped.
+  StringSet<> Seen;
+};
+
+/// Captures file system interaction and generates data to be later replayed
+/// with the RedirectingFileSystem.
+///
+/// For any file that gets accessed we eventually create:
+/// - a copy of the file inside Root
+/// - a record in RedirectingFileSystem mapping that maps:
+///   current real path -> path to the copy in Root
+///
+/// That intent is that later when the mapping is used by RedirectingFileSystem
+/// it simulates the state of FS that we collected.
+///
+/// We generate file copies and mapping lazily - see writeMapping and copyFiles.
+/// We don't try to capture the state of the file at the exact time when it's
+/// accessed. Files might get changed, deleted ... we record only the "final"
+/// state.
+///
+/// In order to preserve the relative topology of files we use their real paths
+/// as relative paths inside of the Root.
+class FileCollector : public FileCollectorBase {
+public:
+  /// \p Root is the directory where collected files are will be stored.
+  /// \p OverlayRoot is VFS mapping root.
+  /// \p Root directory gets created in copyFiles unless it already exists.
+  FileCollector(std::string Root, std::string OverlayRoot);
+
+  /// Write the yaml mapping (for the VFS) to the given file.
+  std::error_code writeMapping(StringRef MappingFile);
+
+  /// Copy the files into the root directory.
+  ///
+  /// When StopOnError is true (the default) we abort as soon as one file
+  /// cannot be copied. This is relatively common, for example when a file was
+  /// removed after it was added to the mapping.
+  std::error_code copyFiles(bool StopOnError = true);
+
+  /// Create a VFS that uses \p Collector to collect files accessed via \p
+  /// BaseFS.
+  static IntrusiveRefCntPtr<vfs::FileSystem>
+  createCollectorVFS(IntrusiveRefCntPtr<vfs::FileSystem> BaseFS,
+                     std::shared_ptr<FileCollector> Collector);
+
+private:
+  friend FileCollectorFileSystem;
+
+  bool getRealPath(StringRef SrcPath, SmallVectorImpl<char> &Result);
+
+  void addFileToMapping(StringRef VirtualPath, StringRef RealPath) {
+    if (sys::fs::is_directory(VirtualPath))
+      VFSWriter.addDirectoryMapping(VirtualPath, RealPath);
+    else
+      VFSWriter.addFileMapping(VirtualPath, RealPath);
+  }
+
+protected:
+  void addFileImpl(StringRef SrcPath) override;
+
+  llvm::vfs::directory_iterator
+  addDirectoryImpl(const llvm::Twine &Dir,
+                   IntrusiveRefCntPtr<vfs::FileSystem> FS,
+                   std::error_code &EC) override;
+
+  /// The directory where collected files are copied to in copyFiles().
+  const std::string Root;
+
+  /// The root directory where the VFS overlay lives.
+  const std::string OverlayRoot;
+
+  /// The yaml mapping writer.
+  vfs::YAMLVFSWriter VFSWriter;
+
+  /// Caches RealPath calls when resolving symlinks.
+  StringMap<std::string> SymlinkMap;
+};
+
+} // end namespace llvm
+
+#endif // LLVM_SUPPORT_FILE_COLLECTOR_H
diff --git a/linux-x64/clang/include/llvm/Support/FileOutputBuffer.h b/linux-x64/clang/include/llvm/Support/FileOutputBuffer.h
index 999f551..8eb36d0 100644
--- a/linux-x64/clang/include/llvm/Support/FileOutputBuffer.h
+++ b/linux-x64/clang/include/llvm/Support/FileOutputBuffer.h
@@ -13,11 +13,9 @@
 #ifndef LLVM_SUPPORT_FILEOUTPUTBUFFER_H
 #define LLVM_SUPPORT_FILEOUTPUTBUFFER_H
 
-#include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/DataTypes.h"
 #include "llvm/Support/Error.h"
-#include "llvm/Support/FileSystem.h"
 
 namespace llvm {
 /// FileOutputBuffer - This interface provides simple way to create an in-memory
@@ -32,6 +30,10 @@
   enum {
     /// set the 'x' bit on the resulting file
     F_executable = 1,
+
+    /// Don't use mmap and instead write an in-memory buffer to a file when this
+    /// buffer is closed.
+    F_no_mmap = 2,
   };
 
   /// Factory method to create an OutputBuffer object which manages a read/write
diff --git a/linux-x64/clang/include/llvm/Support/FileSystem.h b/linux-x64/clang/include/llvm/Support/FileSystem.h
index 3f2c939..2483aae 100644
--- a/linux-x64/clang/include/llvm/Support/FileSystem.h
+++ b/linux-x64/clang/include/llvm/Support/FileSystem.h
@@ -34,6 +34,7 @@
 #include "llvm/Support/Error.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/ErrorOr.h"
+#include "llvm/Support/FileSystem/UniqueID.h"
 #include "llvm/Support/MD5.h"
 #include <cassert>
 #include <cstdint>
@@ -42,7 +43,6 @@
 #include <stack>
 #include <string>
 #include <system_error>
-#include <tuple>
 #include <vector>
 
 #ifdef HAVE_SYS_STAT_H
@@ -131,26 +131,6 @@
       static_cast<unsigned short>(~static_cast<unsigned short>(x)));
 }
 
-class UniqueID {
-  uint64_t Device;
-  uint64_t File;
-
-public:
-  UniqueID() = default;
-  UniqueID(uint64_t Device, uint64_t File) : Device(Device), File(File) {}
-
-  bool operator==(const UniqueID &Other) const {
-    return Device == Other.Device && File == Other.File;
-  }
-  bool operator!=(const UniqueID &Other) const { return !(*this == Other); }
-  bool operator<(const UniqueID &Other) const {
-    return std::tie(Device, File) < std::tie(Other.Device, Other.File);
-  }
-
-  uint64_t getDevice() const { return Device; }
-  uint64_t getFile() const { return File; }
-};
-
 /// Represents the result of a call to directory_iterator::status(). This is a
 /// subset of the information returned by a regular sys::fs::status() call, and
 /// represents the information provided by Windows FileFirstFile/FindNextFile.
@@ -665,15 +645,17 @@
 ///
 /// @param Path File to set permissions on.
 /// @param Permissions New file permissions.
-/// @param RespectUmask If true then Permissions will be changed to respect the
-///        umask of the current process.
 /// @returns errc::success if the permissions were successfully set, otherwise
 ///          a platform-specific error_code.
 /// @note On Windows, all permissions except *_write are ignored. Using any of
 ///       owner_write, group_write, or all_write will make the file writable.
 ///       Otherwise, the file will be marked as read-only.
-std::error_code setPermissions(const Twine &Path, perms Permissions,
-                               bool RespectUmask = false);
+std::error_code setPermissions(const Twine &Path, perms Permissions);
+
+/// Vesion of setPermissions accepting a file descriptor.
+/// TODO Delete the path based overload once we implement the FD based overload
+/// on Windows.
+std::error_code setPermissions(int FD, perms Permissions);
 
 /// Get file permissions.
 ///
@@ -989,29 +971,27 @@
 /// Returns kInvalidFile when the stream is closed.
 file_t getStderrHandle();
 
-/// Reads \p Buf.size() bytes from \p FileHandle into \p Buf. The number of
-/// bytes actually read is returned in \p BytesRead. On Unix, this is equivalent
-/// to `*BytesRead = ::read(FD, Buf.data(), Buf.size())`, with error reporting.
-/// BytesRead will contain zero when reaching EOF.
+/// Reads \p Buf.size() bytes from \p FileHandle into \p Buf. Returns the number
+/// of bytes actually read. On Unix, this is equivalent to `return ::read(FD,
+/// Buf.data(), Buf.size())`, with error reporting. Returns 0 when reaching EOF.
 ///
 /// @param FileHandle File to read from.
 /// @param Buf Buffer to read into.
-/// @param BytesRead Output parameter of the number of bytes read.
-/// @returns The error, if any, or errc::success.
-std::error_code readNativeFile(file_t FileHandle, MutableArrayRef<char> Buf,
-                               size_t *BytesRead);
+/// @returns The number of bytes read, or error.
+Expected<size_t> readNativeFile(file_t FileHandle, MutableArrayRef<char> Buf);
 
 /// Reads \p Buf.size() bytes from \p FileHandle at offset \p Offset into \p
 /// Buf. If 'pread' is available, this will use that, otherwise it will use
-/// 'lseek'. Bytes requested beyond the end of the file will be zero
-/// initialized.
+/// 'lseek'. Returns the number of bytes actually read. Returns 0 when reaching
+/// EOF.
 ///
 /// @param FileHandle File to read from.
 /// @param Buf Buffer to read into.
 /// @param Offset Offset into the file at which the read should occur.
-/// @returns The error, if any, or errc::success.
-std::error_code readNativeFileSlice(file_t FileHandle,
-                                    MutableArrayRef<char> Buf, size_t Offset);
+/// @returns The number of bytes read, or error.
+Expected<size_t> readNativeFileSlice(file_t FileHandle,
+                                     MutableArrayRef<char> Buf,
+                                     uint64_t Offset);
 
 /// @brief Opens the file with the given name in a write-only or read-write
 /// mode, returning its open file descriptor. If the file does not exist, it
@@ -1131,6 +1111,43 @@
 openNativeFileForRead(const Twine &Name, OpenFlags Flags = OF_None,
                       SmallVectorImpl<char> *RealPath = nullptr);
 
+/// Try to locks the file during the specified time.
+///
+/// This function implements advisory locking on entire file. If it returns
+/// <em>errc::success</em>, the file is locked by the calling process. Until the
+/// process unlocks the file by calling \a unlockFile, all attempts to lock the
+/// same file will fail/block. The process that locked the file may assume that
+/// none of other processes read or write this file, provided that all processes
+/// lock the file prior to accessing its content.
+///
+/// @param FD      The descriptor representing the file to lock.
+/// @param Timeout Time in milliseconds that the process should wait before
+///                reporting lock failure. Zero value means try to get lock only
+///                once.
+/// @returns errc::success if lock is successfully obtained,
+/// errc::no_lock_available if the file cannot be locked, or platform-specific
+/// error_code otherwise.
+///
+/// @note Care should be taken when using this function in a multithreaded
+/// context, as it may not prevent other threads in the same process from
+/// obtaining a lock on the same file, even if they are using a different file
+/// descriptor.
+std::error_code
+tryLockFile(int FD,
+            std::chrono::milliseconds Timeout = std::chrono::milliseconds(0));
+
+/// Lock the file.
+///
+/// This function acts as @ref tryLockFile but it waits infinitely.
+std::error_code lockFile(int FD);
+
+/// Unlock the file.
+///
+/// @param FD The descriptor representing the file to unlock.
+/// @returns errc::success if lock is successfully released or platform-specific
+/// error_code otherwise.
+std::error_code unlockFile(int FD);
+
 /// @brief Close the file object.  This should be used instead of ::close for
 /// portability. On error, the caller should assume the file is closed, as is
 /// the case for Process::SafelyCloseFileDescriptor
@@ -1142,6 +1159,35 @@
 /// means that the filesystem may have failed to perform some buffered writes.
 std::error_code closeFile(file_t &F);
 
+/// RAII class that facilitates file locking.
+class FileLocker {
+  int FD; ///< Locked file handle.
+  FileLocker(int FD) : FD(FD) {}
+  friend class llvm::raw_fd_ostream;
+
+public:
+  FileLocker(const FileLocker &L) = delete;
+  FileLocker(FileLocker &&L) : FD(L.FD) { L.FD = -1; }
+  ~FileLocker() {
+    if (FD != -1)
+      unlockFile(FD);
+  }
+  FileLocker &operator=(FileLocker &&L) {
+    FD = L.FD;
+    L.FD = -1;
+    return *this;
+  }
+  FileLocker &operator=(const FileLocker &L) = delete;
+  std::error_code unlock() {
+    if (FD != -1) {
+      std::error_code Result = unlockFile(FD);
+      FD = -1;
+      return Result;
+    }
+    return std::error_code();
+  }
+};
+
 std::error_code getUniqueID(const Twine Path, UniqueID &Result);
 
 /// Get disk space usage information.
@@ -1215,9 +1261,9 @@
   // that whole structure, callers end up paying for a stat().
   // std::filesystem::directory_entry may be a better model.
   std::string Path;
-  file_type Type;           // Most platforms can provide this.
-  bool FollowSymlinks;      // Affects the behavior of status().
-  basic_file_status Status; // If available.
+  file_type Type = file_type::type_unknown; // Most platforms can provide this.
+  bool FollowSymlinks = true;               // Affects the behavior of status().
+  basic_file_status Status;                 // If available.
 
 public:
   explicit directory_entry(const Twine &Path, bool FollowSymlinks = true,
diff --git a/linux-x64/clang/include/llvm/Support/FileSystem/UniqueID.h b/linux-x64/clang/include/llvm/Support/FileSystem/UniqueID.h
new file mode 100644
index 0000000..229410c
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Support/FileSystem/UniqueID.h
@@ -0,0 +1,52 @@
+//===- llvm/Support/FileSystem/UniqueID.h - UniqueID for files --*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is cut out of llvm/Support/FileSystem.h to allow UniqueID to be
+// reused without bloating the includes.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_SUPPORT_FILESYSTEM_UNIQUEID_H
+#define LLVM_SUPPORT_FILESYSTEM_UNIQUEID_H
+
+#include <cstdint>
+
+namespace llvm {
+namespace sys {
+namespace fs {
+
+class UniqueID {
+  uint64_t Device;
+  uint64_t File;
+
+public:
+  UniqueID() = default;
+  UniqueID(uint64_t Device, uint64_t File) : Device(Device), File(File) {}
+
+  bool operator==(const UniqueID &Other) const {
+    return Device == Other.Device && File == Other.File;
+  }
+  bool operator!=(const UniqueID &Other) const { return !(*this == Other); }
+  bool operator<(const UniqueID &Other) const {
+    /// Don't use std::tie since it bloats the compile time of this header.
+    if (Device < Other.Device)
+      return true;
+    if (Other.Device < Device)
+      return false;
+    return File < Other.File;
+  }
+
+  uint64_t getDevice() const { return Device; }
+  uint64_t getFile() const { return File; }
+};
+
+} // end namespace fs
+} // end namespace sys
+} // end namespace llvm
+
+#endif // LLVM_SUPPORT_FILESYSTEM_UNIQUEID_H
diff --git a/linux-x64/clang/include/llvm/Support/FileUtilities.h b/linux-x64/clang/include/llvm/Support/FileUtilities.h
index 16b2206..04efdce 100644
--- a/linux-x64/clang/include/llvm/Support/FileUtilities.h
+++ b/linux-x64/clang/include/llvm/Support/FileUtilities.h
@@ -14,6 +14,9 @@
 #ifndef LLVM_SUPPORT_FILEUTILITIES_H
 #define LLVM_SUPPORT_FILEUTILITIES_H
 
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/Errc.h"
+#include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 
@@ -72,6 +75,41 @@
     /// will not be removed when the object is destroyed.
     void releaseFile() { DeleteIt = false; }
   };
+
+  enum class atomic_write_error {
+    failed_to_create_uniq_file = 0,
+    output_stream_error,
+    failed_to_rename_temp_file
+  };
+
+  class AtomicFileWriteError : public llvm::ErrorInfo<AtomicFileWriteError> {
+  public:
+    AtomicFileWriteError(atomic_write_error Error) : Error(Error) {}
+
+    void log(raw_ostream &OS) const override;
+
+    const atomic_write_error Error;
+    static char ID;
+
+  private:
+    // Users are not expected to use error_code.
+    std::error_code convertToErrorCode() const override {
+      return llvm::inconvertibleErrorCode();
+    }
+  };
+
+  // atomic_write_error + whatever the Writer can return
+
+  /// Creates a unique file with name according to the given \p TempPathModel,
+  /// writes content of \p Buffer to the file and renames it to \p FinalPath.
+  ///
+  /// \returns \c AtomicFileWriteError in case of error.
+  llvm::Error writeFileAtomically(StringRef TempPathModel, StringRef FinalPath,
+                                  StringRef Buffer);
+
+  llvm::Error
+  writeFileAtomically(StringRef TempPathModel, StringRef FinalPath,
+                      std::function<llvm::Error(llvm::raw_ostream &)> Writer);
 } // End llvm namespace
 
 #endif
diff --git a/linux-x64/clang/include/llvm/Support/Format.h b/linux-x64/clang/include/llvm/Support/Format.h
index 77dcbae..9dd7b40 100644
--- a/linux-x64/clang/include/llvm/Support/Format.h
+++ b/linux-x64/clang/include/llvm/Support/Format.h
@@ -29,6 +29,7 @@
 #include <cassert>
 #include <cstdio>
 #include <tuple>
+#include <utility>
 
 namespace llvm {
 
@@ -91,7 +92,7 @@
 
   template <std::size_t... Is>
   int snprint_tuple(char *Buffer, unsigned BufferSize,
-                    index_sequence<Is...>) const {
+                    std::index_sequence<Is...>) const {
 #ifdef _MSC_VER
     return _snprintf(Buffer, BufferSize, Fmt, std::get<Is>(Vals)...);
 #else
@@ -106,7 +107,7 @@
   }
 
   int snprint(char *Buffer, unsigned BufferSize) const override {
-    return snprint_tuple(Buffer, BufferSize, index_sequence_for<Ts...>());
+    return snprint_tuple(Buffer, BufferSize, std::index_sequence_for<Ts...>());
   }
 };
 
diff --git a/linux-x64/clang/include/llvm/Support/FormatAdapters.h b/linux-x64/clang/include/llvm/Support/FormatAdapters.h
index a0e8cc4..495205d 100644
--- a/linux-x64/clang/include/llvm/Support/FormatAdapters.h
+++ b/linux-x64/clang/include/llvm/Support/FormatAdapters.h
@@ -9,7 +9,6 @@
 #ifndef LLVM_SUPPORT_FORMATADAPTERS_H
 #define LLVM_SUPPORT_FORMATADAPTERS_H
 
-#include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/FormatCommon.h"
@@ -35,7 +34,7 @@
       : FormatAdapter<T>(std::forward<T>(Item)), Where(Where), Amount(Amount),
         Fill(Fill) {}
 
-  void format(llvm::raw_ostream &Stream, StringRef Style) {
+  void format(llvm::raw_ostream &Stream, StringRef Style) override {
     auto Adapter = detail::build_format_adapter(std::forward<T>(this->Item));
     FmtAlign(Adapter, Where, Amount, Fill).format(Stream, Style);
   }
@@ -49,7 +48,7 @@
   PadAdapter(T &&Item, size_t Left, size_t Right)
       : FormatAdapter<T>(std::forward<T>(Item)), Left(Left), Right(Right) {}
 
-  void format(llvm::raw_ostream &Stream, StringRef Style) {
+  void format(llvm::raw_ostream &Stream, StringRef Style) override {
     auto Adapter = detail::build_format_adapter(std::forward<T>(this->Item));
     Stream.indent(Left);
     Adapter.format(Stream, Style);
@@ -64,7 +63,7 @@
   RepeatAdapter(T &&Item, size_t Count)
       : FormatAdapter<T>(std::forward<T>(Item)), Count(Count) {}
 
-  void format(llvm::raw_ostream &Stream, StringRef Style) {
+  void format(llvm::raw_ostream &Stream, StringRef Style) override {
     auto Adapter = detail::build_format_adapter(std::forward<T>(this->Item));
     for (size_t I = 0; I < Count; ++I) {
       Adapter.format(Stream, Style);
@@ -77,7 +76,9 @@
   ErrorAdapter(Error &&Item) : FormatAdapter(std::move(Item)) {}
   ErrorAdapter(ErrorAdapter &&) = default;
   ~ErrorAdapter() { consumeError(std::move(Item)); }
-  void format(llvm::raw_ostream &Stream, StringRef Style) { Stream << Item; }
+  void format(llvm::raw_ostream &Stream, StringRef Style) override {
+    Stream << Item;
+  }
 };
 }
 
diff --git a/linux-x64/clang/include/llvm/Support/FormatProviders.h b/linux-x64/clang/include/llvm/Support/FormatProviders.h
index 629a484..c31481a 100644
--- a/linux-x64/clang/include/llvm/Support/FormatProviders.h
+++ b/linux-x64/clang/include/llvm/Support/FormatProviders.h
@@ -124,7 +124,7 @@
 
 template <typename T>
 struct format_provider<
-    T, typename std::enable_if<detail::use_integral_formatter<T>::value>::type>
+    T, std::enable_if_t<detail::use_integral_formatter<T>::value>>
     : public detail::HelperFunctions {
 private:
 public:
@@ -173,7 +173,7 @@
 /// cases indicates the minimum number of nibbles to print.
 template <typename T>
 struct format_provider<
-    T, typename std::enable_if<detail::use_pointer_formatter<T>::value>::type>
+    T, std::enable_if_t<detail::use_pointer_formatter<T>::value>>
     : public detail::HelperFunctions {
 private:
 public:
@@ -198,7 +198,7 @@
 
 template <typename T>
 struct format_provider<
-    T, typename std::enable_if<detail::use_string_formatter<T>::value>::type> {
+    T, std::enable_if_t<detail::use_string_formatter<T>::value>> {
   static void format(const T &V, llvm::raw_ostream &Stream, StringRef Style) {
     size_t N = StringRef::npos;
     if (!Style.empty() && Style.getAsInteger(10, N)) {
@@ -230,8 +230,8 @@
 /// character.  Otherwise, it is treated as an integer options string.
 ///
 template <typename T>
-struct format_provider<
-    T, typename std::enable_if<detail::use_char_formatter<T>::value>::type> {
+struct format_provider<T,
+                       std::enable_if_t<detail::use_char_formatter<T>::value>> {
   static void format(const char &V, llvm::raw_ostream &Stream,
                      StringRef Style) {
     if (Style.empty())
@@ -296,8 +296,8 @@
 /// else.
 
 template <typename T>
-struct format_provider<
-    T, typename std::enable_if<detail::use_double_formatter<T>::value>::type>
+struct format_provider<T,
+                       std::enable_if_t<detail::use_double_formatter<T>::value>>
     : public detail::HelperFunctions {
   static void format(const T &V, llvm::raw_ostream &Stream, StringRef Style) {
     FloatStyle S;
diff --git a/linux-x64/clang/include/llvm/Support/FormatVariadic.h b/linux-x64/clang/include/llvm/Support/FormatVariadic.h
index 5bbda9d..094b054 100644
--- a/linux-x64/clang/include/llvm/Support/FormatVariadic.h
+++ b/linux-x64/clang/include/llvm/Support/FormatVariadic.h
@@ -25,6 +25,7 @@
 #ifndef LLVM_SUPPORT_FORMATVARIADIC_H
 #define LLVM_SUPPORT_FORMATVARIADIC_H
 
+#include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallString.h"
@@ -57,29 +58,14 @@
   size_t Index = 0;
   size_t Align = 0;
   AlignStyle Where = AlignStyle::Right;
-  char Pad;
+  char Pad = 0;
   StringRef Options;
 };
 
 class formatv_object_base {
 protected:
-  // The parameters are stored in a std::tuple, which does not provide runtime
-  // indexing capabilities.  In order to enable runtime indexing, we use this
-  // structure to put the parameters into a std::vector.  Since the parameters
-  // are not all the same type, we use some type-erasure by wrapping the
-  // parameters in a template class that derives from a non-template superclass.
-  // Essentially, we are converting a std::tuple<Derived<Ts...>> to a
-  // std::vector<Base*>.
-  struct create_adapters {
-    template <typename... Ts>
-    std::vector<detail::format_adapter *> operator()(Ts &... Items) {
-      return std::vector<detail::format_adapter *>{&Items...};
-    }
-  };
-
   StringRef Fmt;
-  std::vector<detail::format_adapter *> Adapters;
-  std::vector<ReplacementItem> Replacements;
+  ArrayRef<detail::format_adapter *> Adapters;
 
   static bool consumeFieldLayout(StringRef &Spec, AlignStyle &Where,
                                  size_t &Align, char &Pad);
@@ -87,23 +73,16 @@
   static std::pair<ReplacementItem, StringRef>
   splitLiteralAndReplacement(StringRef Fmt);
 
-public:
-  formatv_object_base(StringRef Fmt, std::size_t ParamCount)
-      : Fmt(Fmt), Replacements(parseFormatString(Fmt)) {
-    Adapters.reserve(ParamCount);
-  }
+  formatv_object_base(StringRef Fmt,
+                      ArrayRef<detail::format_adapter *> Adapters)
+      : Fmt(Fmt), Adapters(Adapters) {}
 
   formatv_object_base(formatv_object_base const &rhs) = delete;
+  formatv_object_base(formatv_object_base &&rhs) = default;
 
-  formatv_object_base(formatv_object_base &&rhs)
-      : Fmt(std::move(rhs.Fmt)),
-        Adapters(), // Adapters are initialized by formatv_object
-        Replacements(std::move(rhs.Replacements)) {
-    Adapters.reserve(rhs.Adapters.size());
-  };
-
+public:
   void format(raw_ostream &S) const {
-    for (auto &R : Replacements) {
+    for (auto &R : parseFormatString(Fmt)) {
       if (R.Type == ReplacementType::Empty)
         continue;
       if (R.Type == ReplacementType::Literal) {
@@ -121,7 +100,7 @@
       Align.format(S, R.Options);
     }
   }
-  static std::vector<ReplacementItem> parseFormatString(StringRef Fmt);
+  static SmallVector<ReplacementItem, 2> parseFormatString(StringRef Fmt);
 
   static Optional<ReplacementItem> parseReplacementItem(StringRef Spec);
 
@@ -150,12 +129,29 @@
   // of the parameters, we have to own the storage for the parameters here, and
   // have the base class store type-erased pointers into this tuple.
   Tuple Parameters;
+  std::array<detail::format_adapter *, std::tuple_size<Tuple>::value>
+      ParameterPointers;
+
+  // The parameters are stored in a std::tuple, which does not provide runtime
+  // indexing capabilities.  In order to enable runtime indexing, we use this
+  // structure to put the parameters into a std::array.  Since the parameters
+  // are not all the same type, we use some type-erasure by wrapping the
+  // parameters in a template class that derives from a non-template superclass.
+  // Essentially, we are converting a std::tuple<Derived<Ts...>> to a
+  // std::array<Base*>.
+  struct create_adapters {
+    template <typename... Ts>
+    std::array<detail::format_adapter *, std::tuple_size<Tuple>::value>
+    operator()(Ts &... Items) {
+      return {{&Items...}};
+    }
+  };
 
 public:
   formatv_object(StringRef Fmt, Tuple &&Params)
-      : formatv_object_base(Fmt, std::tuple_size<Tuple>::value),
+      : formatv_object_base(Fmt, ParameterPointers),
         Parameters(std::move(Params)) {
-    Adapters = apply_tuple(create_adapters(), Parameters);
+    ParameterPointers = apply_tuple(create_adapters(), Parameters);
   }
 
   formatv_object(formatv_object const &rhs) = delete;
@@ -163,7 +159,8 @@
   formatv_object(formatv_object &&rhs)
       : formatv_object_base(std::move(rhs)),
         Parameters(std::move(rhs.Parameters)) {
-    Adapters = apply_tuple(create_adapters(), Parameters);
+    ParameterPointers = apply_tuple(create_adapters(), Parameters);
+    Adapters = ParameterPointers;
   }
 };
 
@@ -208,10 +205,10 @@
 //
 // The characters '{' and '}' are reserved and cannot appear anywhere within a
 // replacement sequence.  Outside of a replacement sequence, in order to print
-// a literal '{' or '}' it must be doubled -- "{{" to print a literal '{' and
-// "}}" to print a literal '}'.
+// a literal '{' it must be doubled as "{{".
 //
 // ===Parameter Indexing===
+//
 // `index` specifies the index of the parameter in the parameter pack to format
 // into the output.  Note that it is possible to refer to the same parameter
 // index multiple times in a given format string.  This makes it possible to
diff --git a/linux-x64/clang/include/llvm/Support/FormatVariadicDetails.h b/linux-x64/clang/include/llvm/Support/FormatVariadicDetails.h
index e3c1851..d5e67b7 100644
--- a/linux-x64/clang/include/llvm/Support/FormatVariadicDetails.h
+++ b/linux-x64/clang/include/llvm/Support/FormatVariadicDetails.h
@@ -36,7 +36,7 @@
   explicit provider_format_adapter(T &&Item) : Item(std::forward<T>(Item)) {}
 
   void format(llvm::raw_ostream &S, StringRef Options) override {
-    format_provider<typename std::decay<T>::type>::format(Item, S, Options);
+    format_provider<std::decay_t<T>>::format(Item, S, Options);
   }
 };
 
@@ -59,7 +59,7 @@
 //
 template <class T> class has_FormatProvider {
 public:
-  using Decayed = typename std::decay<T>::type;
+  using Decayed = std::decay_t<T>;
   typedef void (*Signature_format)(const Decayed &, llvm::raw_ostream &,
                                    StringRef);
 
@@ -75,14 +75,14 @@
 // Test if raw_ostream& << T -> raw_ostream& is findable via ADL.
 template <class T> class has_StreamOperator {
 public:
-  using ConstRefT = const typename std::decay<T>::type &;
+  using ConstRefT = const std::decay_t<T> &;
 
   template <typename U>
-  static char test(typename std::enable_if<
-                   std::is_same<decltype(std::declval<llvm::raw_ostream &>()
-                                         << std::declval<U>()),
-                                llvm::raw_ostream &>::value,
-                   int *>::type);
+  static char test(
+      std::enable_if_t<std::is_same<decltype(std::declval<llvm::raw_ostream &>()
+                                             << std::declval<U>()),
+                                    llvm::raw_ostream &>::value,
+                       int *>);
 
   template <typename U> static double test(...);
 
@@ -95,8 +95,8 @@
 struct uses_format_member
     : public std::integral_constant<
           bool,
-          std::is_base_of<format_adapter,
-                          typename std::remove_reference<T>::type>::value> {};
+          std::is_base_of<format_adapter, std::remove_reference_t<T>>::value> {
+};
 
 // Simple template that decides whether a type T should use the format_provider
 // based format() invocation.  The member function takes priority, so this test
@@ -127,34 +127,32 @@
 };
 
 template <typename T>
-typename std::enable_if<uses_format_member<T>::value, T>::type
+std::enable_if_t<uses_format_member<T>::value, T>
 build_format_adapter(T &&Item) {
   return std::forward<T>(Item);
 }
 
 template <typename T>
-typename std::enable_if<uses_format_provider<T>::value,
-                        provider_format_adapter<T>>::type
+std::enable_if_t<uses_format_provider<T>::value, provider_format_adapter<T>>
 build_format_adapter(T &&Item) {
   return provider_format_adapter<T>(std::forward<T>(Item));
 }
 
 template <typename T>
-typename std::enable_if<uses_stream_operator<T>::value,
-                        stream_operator_format_adapter<T>>::type
+std::enable_if_t<uses_stream_operator<T>::value,
+                 stream_operator_format_adapter<T>>
 build_format_adapter(T &&Item) {
   // If the caller passed an Error by value, then stream_operator_format_adapter
   // would be responsible for consuming it.
   // Make the caller opt into this by calling fmt_consume().
   static_assert(
-      !std::is_same<llvm::Error, typename std::remove_cv<T>::type>::value,
+      !std::is_same<llvm::Error, std::remove_cv_t<T>>::value,
       "llvm::Error-by-value must be wrapped in fmt_consume() for formatv");
   return stream_operator_format_adapter<T>(std::forward<T>(Item));
 }
 
 template <typename T>
-typename std::enable_if<uses_missing_provider<T>::value,
-                        missing_format_adapter<T>>::type
+std::enable_if_t<uses_missing_provider<T>::value, missing_format_adapter<T>>
 build_format_adapter(T &&Item) {
   return missing_format_adapter<T>();
 }
diff --git a/linux-x64/clang/include/llvm/Support/FormattedStream.h b/linux-x64/clang/include/llvm/Support/FormattedStream.h
index b49c8d8..5f937cf 100644
--- a/linux-x64/clang/include/llvm/Support/FormattedStream.h
+++ b/linux-x64/clang/include/llvm/Support/FormattedStream.h
@@ -14,6 +14,7 @@
 #ifndef LLVM_SUPPORT_FORMATTEDSTREAM_H
 #define LLVM_SUPPORT_FORMATTEDSTREAM_H
 
+#include "llvm/ADT/SmallString.h"
 #include "llvm/Support/raw_ostream.h"
 #include <utility>
 
@@ -21,8 +22,11 @@
 
 /// formatted_raw_ostream - A raw_ostream that wraps another one and keeps track
 /// of line and column position, allowing padding out to specific column
-/// boundaries and querying the number of lines written to the stream.
-///
+/// boundaries and querying the number of lines written to the stream. This
+/// assumes that the contents of the stream is valid UTF-8 encoded text. This
+/// doesn't attempt to handle everything Unicode can do (combining characters,
+/// right-to-left markers, etc), but should cover the cases likely to appear in
+/// source code or diagnostic messages.
 class formatted_raw_ostream : public raw_ostream {
   /// TheStream - The real stream we output to. We set it to be
   /// unbuffered, since we're already doing our own buffering.
@@ -40,6 +44,14 @@
   ///
   const char *Scanned;
 
+  /// PartialUTF8Char - Either empty or a prefix of a UTF-8 code unit sequence
+  /// for a Unicode scalar value which should be prepended to the buffer for the
+  /// next call to ComputePosition. This is needed when the buffer is flushed
+  /// when it ends part-way through the UTF-8 encoding of a Unicode scalar
+  /// value, so that we can compute the display width of the character once we
+  /// have the rest of it.
+  SmallString<4> PartialUTF8Char;
+
   void write_impl(const char *Ptr, size_t Size) override;
 
   /// current_pos - Return the current position within the stream,
@@ -52,10 +64,16 @@
   }
 
   /// ComputePosition - Examine the given output buffer and figure out the new
-  /// position after output.
-  ///
+  /// position after output. This is safe to call multiple times on the same
+  /// buffer, as it records the most recently scanned character and resumes from
+  /// there when the buffer has not been flushed.
   void ComputePosition(const char *Ptr, size_t size);
 
+  /// UpdatePosition - scan the characters in [Ptr, Ptr+Size), and update the
+  /// line and column numbers. Unlike ComputePosition, this must be called
+  /// exactly once on each region of the buffer.
+  void UpdatePosition(const char *Ptr, size_t Size);
+
   void setStream(raw_ostream &Stream) {
     releaseStream();
 
@@ -105,11 +123,17 @@
   /// \param NewCol - The column to move to.
   formatted_raw_ostream &PadToColumn(unsigned NewCol);
 
-  /// getColumn - Return the column number
-  unsigned getColumn() { return Position.first; }
+  unsigned getColumn() {
+    // Calculate current position, taking buffer contents into account.
+    ComputePosition(getBufferStart(), GetNumBytesInBuffer());
+    return Position.first;
+  }
 
-  /// getLine - Return the line number
-  unsigned getLine() { return Position.second; }
+  unsigned getLine() {
+    // Calculate current position, taking buffer contents into account.
+    ComputePosition(getBufferStart(), GetNumBytesInBuffer());
+    return Position.second;
+  }
 
   raw_ostream &resetColor() override {
     TheStream->resetColor();
diff --git a/linux-x64/clang/include/llvm/Support/GenericDomTree.h b/linux-x64/clang/include/llvm/Support/GenericDomTree.h
index 9962080..28b2537 100644
--- a/linux-x64/clang/include/llvm/Support/GenericDomTree.h
+++ b/linux-x64/clang/include/llvm/Support/GenericDomTree.h
@@ -25,10 +25,10 @@
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/GraphTraits.h"
-#include "llvm/ADT/PointerIntPair.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
+#include "llvm/Support/CFGDiff.h"
 #include "llvm/Support/CFGUpdate.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
@@ -38,7 +38,6 @@
 #include <memory>
 #include <type_traits>
 #include <utility>
-#include <vector>
 
 namespace llvm {
 
@@ -61,7 +60,7 @@
   NodeT *TheBB;
   DomTreeNodeBase *IDom;
   unsigned Level;
-  std::vector<DomTreeNodeBase *> Children;
+  SmallVector<DomTreeNodeBase *, 4> Children;
   mutable unsigned DFSNumIn = ~0;
   mutable unsigned DFSNumOut = ~0;
 
@@ -69,27 +68,34 @@
   DomTreeNodeBase(NodeT *BB, DomTreeNodeBase *iDom)
       : TheBB(BB), IDom(iDom), Level(IDom ? IDom->Level + 1 : 0) {}
 
-  using iterator = typename std::vector<DomTreeNodeBase *>::iterator;
+  using iterator = typename SmallVector<DomTreeNodeBase *, 4>::iterator;
   using const_iterator =
-      typename std::vector<DomTreeNodeBase *>::const_iterator;
+      typename SmallVector<DomTreeNodeBase *, 4>::const_iterator;
 
   iterator begin() { return Children.begin(); }
   iterator end() { return Children.end(); }
   const_iterator begin() const { return Children.begin(); }
   const_iterator end() const { return Children.end(); }
 
+  DomTreeNodeBase *const &back() const { return Children.back(); }
+  DomTreeNodeBase *&back() { return Children.back(); }
+
+  iterator_range<iterator> children() { return make_range(begin(), end()); }
+  iterator_range<const_iterator> children() const {
+    return make_range(begin(), end());
+  }
+
   NodeT *getBlock() const { return TheBB; }
   DomTreeNodeBase *getIDom() const { return IDom; }
   unsigned getLevel() const { return Level; }
 
-  const std::vector<DomTreeNodeBase *> &getChildren() const { return Children; }
-
   std::unique_ptr<DomTreeNodeBase> addChild(
       std::unique_ptr<DomTreeNodeBase> C) {
     Children.push_back(C.get());
     return C;
   }
 
+  bool isLeaf() const { return Children.empty(); }
   size_t getNumChildren() const { return Children.size(); }
 
   void clearAllChildren() { Children.clear(); }
@@ -205,7 +211,10 @@
 
 template <typename DomTreeT>
 void ApplyUpdates(DomTreeT &DT,
-                  ArrayRef<typename DomTreeT::UpdateType> Updates);
+                  GraphDiff<typename DomTreeT::NodePtr,
+                            DomTreeT::IsPostDominator> &PreViewCFG,
+                  GraphDiff<typename DomTreeT::NodePtr,
+                            DomTreeT::IsPostDominator> *PostViewCFG);
 
 template <typename DomTreeT>
 bool Verify(const DomTreeT &DT, typename DomTreeT::VerificationLevel VL);
@@ -225,7 +234,7 @@
   using ParentPtr = decltype(std::declval<NodeT *>()->getParent());
   static_assert(std::is_pointer<ParentPtr>::value,
                 "Currently NodeT's parent must be a pointer type");
-  using ParentType = typename std::remove_pointer<ParentPtr>::type;
+  using ParentType = std::remove_pointer_t<ParentPtr>;
   static constexpr bool IsPostDominator = IsPostDom;
 
   using UpdateType = cfg::Update<NodePtr>;
@@ -242,7 +251,7 @@
   using DomTreeNodeMapType =
      DenseMap<NodeT *, std::unique_ptr<DomTreeNodeBase<NodeT>>>;
   DomTreeNodeMapType DomTreeNodes;
-  DomTreeNodeBase<NodeT> *RootNode;
+  DomTreeNodeBase<NodeT> *RootNode = nullptr;
   ParentPtr Parent = nullptr;
 
   mutable bool DFSInfoValid = false;
@@ -277,11 +286,27 @@
   DominatorTreeBase(const DominatorTreeBase &) = delete;
   DominatorTreeBase &operator=(const DominatorTreeBase &) = delete;
 
-  /// getRoots - Return the root blocks of the current CFG.  This may include
-  /// multiple blocks if we are computing post dominators.  For forward
-  /// dominators, this will always be a single block (the entry node).
+  /// Iteration over roots.
   ///
-  const SmallVectorImpl<NodeT *> &getRoots() const { return Roots; }
+  /// This may include multiple blocks if we are computing post dominators.
+  /// For forward dominators, this will always be a single block (the entry
+  /// block).
+  using root_iterator = typename SmallVectorImpl<NodeT *>::iterator;
+  using const_root_iterator = typename SmallVectorImpl<NodeT *>::const_iterator;
+
+  root_iterator root_begin() { return Roots.begin(); }
+  const_root_iterator root_begin() const { return Roots.begin(); }
+  root_iterator root_end() { return Roots.end(); }
+  const_root_iterator root_end() const { return Roots.end(); }
+
+  size_t root_size() const { return Roots.size(); }
+
+  iterator_range<root_iterator> roots() {
+    return make_range(root_begin(), root_end());
+  }
+  iterator_range<const_root_iterator> roots() const {
+    return make_range(root_begin(), root_end());
+  }
 
   /// isPostDominator - Returns true if analysis based of postdoms
   ///
@@ -319,8 +344,6 @@
     return false;
   }
 
-  void releaseMemory() { reset(); }
-
   /// getNode - return the (Post)DominatorTree node for the specified basic
   /// block.  This is the same as using operator[] on this class.  The result
   /// may (but is not required to) be null for a forward (backwards)
@@ -440,8 +463,8 @@
     return this->Roots[0];
   }
 
-  /// findNearestCommonDominator - Find nearest common dominator basic block
-  /// for basic block A and B. If there is no such block then return nullptr.
+  /// Find nearest common dominator basic block for basic block A and B. A and B
+  /// must have tree nodes.
   NodeT *findNearestCommonDominator(NodeT *A, NodeT *B) const {
     assert(A && B && "Pointers are not valid");
     assert(A->getParent() == B->getParent() &&
@@ -457,18 +480,18 @@
 
     DomTreeNodeBase<NodeT> *NodeA = getNode(A);
     DomTreeNodeBase<NodeT> *NodeB = getNode(B);
-
-    if (!NodeA || !NodeB) return nullptr;
+    assert(NodeA && "A must be in the tree");
+    assert(NodeB && "B must be in the tree");
 
     // Use level information to go up the tree until the levels match. Then
     // continue going up til we arrive at the same node.
-    while (NodeA && NodeA != NodeB) {
+    while (NodeA != NodeB) {
       if (NodeA->getLevel() < NodeB->getLevel()) std::swap(NodeA, NodeB);
 
       NodeA = NodeA->IDom;
     }
 
-    return NodeA ? NodeA->getBlock() : nullptr;
+    return NodeA->getBlock();
   }
 
   const NodeT *findNearestCommonDominator(const NodeT *A,
@@ -515,10 +538,39 @@
   /// The type of updates is the same for DomTreeBase<T> and PostDomTreeBase<T>
   /// with the same template parameter T.
   ///
-  /// \param Updates An unordered sequence of updates to perform.
+  /// \param Updates An unordered sequence of updates to perform. The current
+  /// CFG and the reverse of these updates provides the pre-view of the CFG.
   ///
   void applyUpdates(ArrayRef<UpdateType> Updates) {
-    DomTreeBuilder::ApplyUpdates(*this, Updates);
+    GraphDiff<NodePtr, IsPostDominator> PreViewCFG(
+        Updates, /*ReverseApplyUpdates=*/true);
+    DomTreeBuilder::ApplyUpdates(*this, PreViewCFG, nullptr);
+  }
+
+  /// \param Updates An unordered sequence of updates to perform. The current
+  /// CFG and the reverse of these updates provides the pre-view of the CFG.
+  /// \param PostViewUpdates An unordered sequence of update to perform in order
+  /// to obtain a post-view of the CFG. The DT will be updated assuming the
+  /// obtained PostViewCFG is the desired end state.
+  void applyUpdates(ArrayRef<UpdateType> Updates,
+                    ArrayRef<UpdateType> PostViewUpdates) {
+    if (Updates.empty()) {
+      GraphDiff<NodePtr, IsPostDom> PostViewCFG(PostViewUpdates);
+      DomTreeBuilder::ApplyUpdates(*this, PostViewCFG, &PostViewCFG);
+    } else {
+      // PreViewCFG needs to merge Updates and PostViewCFG. The updates in
+      // Updates need to be reversed, and match the direction in PostViewCFG.
+      // The PostViewCFG is created with updates reversed (equivalent to changes
+      // made to the CFG), so the PreViewCFG needs all the updates reverse
+      // applied.
+      SmallVector<UpdateType> AllUpdates(Updates.begin(), Updates.end());
+      for (auto &Update : PostViewUpdates)
+        AllUpdates.push_back(Update);
+      GraphDiff<NodePtr, IsPostDom> PreViewCFG(AllUpdates,
+                                               /*ReverseApplyUpdates=*/true);
+      GraphDiff<NodePtr, IsPostDom> PostViewCFG(PostViewUpdates);
+      DomTreeBuilder::ApplyUpdates(*this, PreViewCFG, &PostViewCFG);
+    }
   }
 
   /// Inform the dominator tree about a CFG edge insertion and update the tree.
@@ -570,8 +622,7 @@
     DomTreeNodeBase<NodeT> *IDomNode = getNode(DomBB);
     assert(IDomNode && "Not immediate dominator specified for block!");
     DFSInfoValid = false;
-    return (DomTreeNodes[BB] = IDomNode->addChild(
-                llvm::make_unique<DomTreeNodeBase<NodeT>>(BB, IDomNode))).get();
+    return createChild(BB, IDomNode);
   }
 
   /// Add a new node to the forward dominator tree and make it a new root.
@@ -584,8 +635,7 @@
     assert(!this->isPostDominator() &&
            "Cannot change root of post-dominator tree");
     DFSInfoValid = false;
-    DomTreeNodeBase<NodeT> *NewNode = (DomTreeNodes[BB] =
-      llvm::make_unique<DomTreeNodeBase<NodeT>>(BB, nullptr)).get();
+    DomTreeNodeBase<NodeT> *NewNode = createNode(BB);
     if (Roots.empty()) {
       addRoot(BB);
     } else {
@@ -620,7 +670,7 @@
   void eraseNode(NodeT *BB) {
     DomTreeNodeBase<NodeT> *Node = getNode(BB);
     assert(Node && "Removing node that isn't in dominator tree.");
-    assert(Node->getChildren().empty() && "Node is not a leaf node.");
+    assert(Node->isLeaf() && "Node is not a leaf node.");
 
     DFSInfoValid = false;
 
@@ -754,9 +804,6 @@
     return DomTreeBuilder::Verify(*this, VL);
   }
 
-protected:
-  void addRoot(NodeT *BB) { this->Roots.push_back(BB); }
-
   void reset() {
     DomTreeNodes.clear();
     Roots.clear();
@@ -766,6 +813,21 @@
     SlowQueries = 0;
   }
 
+protected:
+  void addRoot(NodeT *BB) { this->Roots.push_back(BB); }
+
+  DomTreeNodeBase<NodeT> *createChild(NodeT *BB, DomTreeNodeBase<NodeT> *IDom) {
+    return (DomTreeNodes[BB] = IDom->addChild(
+                std::make_unique<DomTreeNodeBase<NodeT>>(BB, IDom)))
+        .get();
+  }
+
+  DomTreeNodeBase<NodeT> *createNode(NodeT *BB) {
+    return (DomTreeNodes[BB] =
+                std::make_unique<DomTreeNodeBase<NodeT>>(BB, nullptr))
+        .get();
+  }
+
   // NewBB is split and now it has one successor. Update dominator tree to
   // reflect this change.
   template <class N>
@@ -777,14 +839,14 @@
            "NewBB should have a single successor!");
     NodeRef NewBBSucc = *GraphT::child_begin(NewBB);
 
-    std::vector<NodeRef> PredBlocks;
-    for (const auto &Pred : children<Inverse<N>>(NewBB))
+    SmallVector<NodeRef, 4> PredBlocks;
+    for (auto Pred : children<Inverse<N>>(NewBB))
       PredBlocks.push_back(Pred);
 
     assert(!PredBlocks.empty() && "No predblocks?");
 
     bool NewBBDominatesNewBBSucc = true;
-    for (const auto &Pred : children<Inverse<N>>(NewBBSucc)) {
+    for (auto Pred : children<Inverse<N>>(NewBBSucc)) {
       if (Pred != NewBB && !dominates(NewBBSucc, Pred) &&
           isReachableFromEntry(Pred)) {
         NewBBDominatesNewBBSucc = false;
diff --git a/linux-x64/clang/include/llvm/Support/GenericDomTreeConstruction.h b/linux-x64/clang/include/llvm/Support/GenericDomTreeConstruction.h
index ccceba8..4b59ad1 100644
--- a/linux-x64/clang/include/llvm/Support/GenericDomTreeConstruction.h
+++ b/linux-x64/clang/include/llvm/Support/GenericDomTreeConstruction.h
@@ -7,11 +7,11 @@
 //===----------------------------------------------------------------------===//
 /// \file
 ///
-/// Generic dominator tree construction - This file provides routines to
+/// Generic dominator tree construction - this file provides routines to
 /// construct immediate dominator information for a flow-graph based on the
 /// Semi-NCA algorithm described in this dissertation:
 ///
-///   Linear-Time Algorithms for Dominators and Related Problems
+///   [1] Linear-Time Algorithms for Dominators and Related Problems
 ///   Loukas Georgiadis, Princeton University, November 2005, pp. 21-23:
 ///   ftp://ftp.cs.princeton.edu/reports/2005/737.pdf
 ///
@@ -20,13 +20,15 @@
 ///
 /// O(n^2) worst cases happen when the computation of nearest common ancestors
 /// requires O(n) average time, which is very unlikely in real world. If this
-/// ever turns out to be an issue, consider implementing a hybrid algorithm.
+/// ever turns out to be an issue, consider implementing a hybrid algorithm
+/// that uses SLT to perform full constructions and SemiNCA for incremental
+/// updates.
 ///
 /// The file uses the Depth Based Search algorithm to perform incremental
 /// updates (insertion and deletions). The implemented algorithm is based on
 /// this publication:
 ///
-///   An Experimental Study of Dynamic Dominators
+///   [2] An Experimental Study of Dynamic Dominators
 ///   Loukas Georgiadis, et al., April 12 2016, pp. 5-7, 9-10:
 ///   https://arxiv.org/pdf/1604.02711.pdf
 ///
@@ -35,7 +37,6 @@
 #ifndef LLVM_SUPPORT_GENERICDOMTREECONSTRUCTION_H
 #define LLVM_SUPPORT_GENERICDOMTREECONSTRUCTION_H
 
-#include <queue>
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/DepthFirstIterator.h"
@@ -43,6 +44,7 @@
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/GenericDomTree.h"
+#include <queue>
 
 #define DEBUG_TYPE "dom-tree-builder"
 
@@ -56,6 +58,7 @@
   using TreeNodePtr = DomTreeNodeBase<NodeT> *;
   using RootsT = decltype(DomTreeT::Roots);
   static constexpr bool IsPostDom = DomTreeT::IsPostDominator;
+  using GraphDiffT = GraphDiff<NodePtr, IsPostDom>;
 
   // Information record used by Semi-NCA during tree construction.
   struct InfoRec {
@@ -75,21 +78,17 @@
   using UpdateT = typename DomTreeT::UpdateType;
   using UpdateKind = typename DomTreeT::UpdateKind;
   struct BatchUpdateInfo {
-    SmallVector<UpdateT, 4> Updates;
-    using NodePtrAndKind = PointerIntPair<NodePtr, 1, UpdateKind>;
+    // Note: Updates inside PreViewCFG are aleady legalized.
+    BatchUpdateInfo(GraphDiffT &PreViewCFG, GraphDiffT *PostViewCFG = nullptr)
+        : PreViewCFG(PreViewCFG), PostViewCFG(PostViewCFG),
+          NumLegalized(PreViewCFG.getNumLegalizedUpdates()) {}
 
-    // In order to be able to walk a CFG that is out of sync with the CFG
-    // DominatorTree last knew about, use the list of updates to reconstruct
-    // previous CFG versions of the current CFG. For each node, we store a set
-    // of its virtually added/deleted future successors and predecessors.
-    // Note that these children are from the future relative to what the
-    // DominatorTree knows about -- using them to gets us some snapshot of the
-    // CFG from the past (relative to the state of the CFG).
-    DenseMap<NodePtr, SmallVector<NodePtrAndKind, 4>> FutureSuccessors;
-    DenseMap<NodePtr, SmallVector<NodePtrAndKind, 4>> FuturePredecessors;
     // Remembers if the whole tree was recalculated at some point during the
     // current batch update.
     bool IsRecalculated = false;
+    GraphDiffT &PreViewCFG;
+    GraphDiffT *PostViewCFG;
+    const size_t NumLegalized;
   };
 
   BatchUpdateInfo *BatchUpdates;
@@ -105,66 +104,24 @@
     // in progress, we need this information to continue it.
   }
 
-  template <bool Inverse>
-  struct ChildrenGetter {
-    using ResultTy = SmallVector<NodePtr, 8>;
+  template <bool Inversed>
+  static SmallVector<NodePtr, 8> getChildren(NodePtr N, BatchUpdatePtr BUI) {
+    if (BUI)
+      return BUI->PreViewCFG.template getChildren<Inversed>(N);
+    return getChildren<Inversed>(N);
+  }
 
-    static ResultTy Get(NodePtr N, std::integral_constant<bool, false>) {
-      auto RChildren = reverse(children<NodePtr>(N));
-      return ResultTy(RChildren.begin(), RChildren.end());
-    }
+  template <bool Inversed>
+  static SmallVector<NodePtr, 8> getChildren(NodePtr N) {
+    using DirectedNodeT =
+        std::conditional_t<Inversed, Inverse<NodePtr>, NodePtr>;
+    auto R = children<DirectedNodeT>(N);
+    SmallVector<NodePtr, 8> Res(detail::reverse_if<!Inversed>(R));
 
-    static ResultTy Get(NodePtr N, std::integral_constant<bool, true>) {
-      auto IChildren = inverse_children<NodePtr>(N);
-      return ResultTy(IChildren.begin(), IChildren.end());
-    }
-
-    using Tag = std::integral_constant<bool, Inverse>;
-
-    // The function below is the core part of the batch updater. It allows the
-    // Depth Based Search algorithm to perform incremental updates in lockstep
-    // with updates to the CFG. We emulated lockstep CFG updates by getting its
-    // next snapshots by reverse-applying future updates.
-    static ResultTy Get(NodePtr N, BatchUpdatePtr BUI) {
-      ResultTy Res = Get(N, Tag());
-      // If there's no batch update in progress, simply return node's children.
-      if (!BUI) return Res;
-
-      // CFG children are actually its *most current* children, and we have to
-      // reverse-apply the future updates to get the node's children at the
-      // point in time the update was performed.
-      auto &FutureChildren = (Inverse != IsPostDom) ? BUI->FuturePredecessors
-                                                    : BUI->FutureSuccessors;
-      auto FCIt = FutureChildren.find(N);
-      if (FCIt == FutureChildren.end()) return Res;
-
-      for (auto ChildAndKind : FCIt->second) {
-        const NodePtr Child = ChildAndKind.getPointer();
-        const UpdateKind UK = ChildAndKind.getInt();
-
-        // Reverse-apply the future update.
-        if (UK == UpdateKind::Insert) {
-          // If there's an insertion in the future, it means that the edge must
-          // exist in the current CFG, but was not present in it before.
-          assert(llvm::find(Res, Child) != Res.end()
-                 && "Expected child not found in the CFG");
-          Res.erase(std::remove(Res.begin(), Res.end(), Child), Res.end());
-          LLVM_DEBUG(dbgs() << "\tHiding edge " << BlockNamePrinter(N) << " -> "
-                            << BlockNamePrinter(Child) << "\n");
-        } else {
-          // If there's an deletion in the future, it means that the edge cannot
-          // exist in the current CFG, but existed in it before.
-          assert(llvm::find(Res, Child) == Res.end() &&
-                 "Unexpected child found in the CFG");
-          LLVM_DEBUG(dbgs() << "\tShowing virtual edge " << BlockNamePrinter(N)
-                            << " -> " << BlockNamePrinter(Child) << "\n");
-          Res.push_back(Child);
-        }
-      }
-
-      return Res;
-    }
-  };
+    // Remove nullptr children for clang.
+    llvm::erase_value(Res, nullptr);
+    return Res;
+  }
 
   NodePtr getIDom(NodePtr BB) const {
     auto InfoIt = NodeToInfo.find(BB);
@@ -185,9 +142,7 @@
 
     // Add a new tree node for this NodeT, and link it as a child of
     // IDomNode
-    return (DT.DomTreeNodes[BB] = IDomNode->addChild(
-        llvm::make_unique<DomTreeNodeBase<NodeT>>(BB, IDomNode)))
-        .get();
+    return DT.createChild(BB, IDomNode);
   }
 
   static bool AlwaysDescend(NodePtr, NodePtr) { return true; }
@@ -208,6 +163,8 @@
     }
   };
 
+  using NodeOrderMap = DenseMap<NodePtr, unsigned>;
+
   // Custom DFS implementation which can skip nodes based on a provided
   // predicate. It also collects ReverseChildren so that we don't have to spend
   // time getting predecessors in SemiNCA.
@@ -215,9 +172,13 @@
   // If IsReverse is set to true, the DFS walk will be performed backwards
   // relative to IsPostDom -- using reverse edges for dominators and forward
   // edges for postdominators.
+  //
+  // If SuccOrder is specified then in this order the DFS traverses the children
+  // otherwise the order is implied by the results of getChildren().
   template <bool IsReverse = false, typename DescendCondition>
   unsigned runDFS(NodePtr V, unsigned LastNum, DescendCondition Condition,
-                  unsigned AttachToNum) {
+                  unsigned AttachToNum,
+                  const NodeOrderMap *SuccOrder = nullptr) {
     assert(V);
     SmallVector<NodePtr, 64> WorkList = {V};
     if (NodeToInfo.count(V) != 0) NodeToInfo[V].Parent = AttachToNum;
@@ -233,8 +194,14 @@
       NumToNode.push_back(BB);
 
       constexpr bool Direction = IsReverse != IsPostDom;  // XOR.
-      for (const NodePtr Succ :
-           ChildrenGetter<Direction>::Get(BB, BatchUpdates)) {
+      auto Successors = getChildren<Direction>(BB, BatchUpdates);
+      if (SuccOrder && Successors.size() > 1)
+        llvm::sort(
+            Successors.begin(), Successors.end(), [=](NodePtr A, NodePtr B) {
+              return SuccOrder->find(A)->second < SuccOrder->find(B)->second;
+            });
+
+      for (const NodePtr Succ : Successors) {
         const auto SIT = NodeToInfo.find(Succ);
         // Don't visit nodes more than once but remember to collect
         // ReverseChildren.
@@ -369,7 +336,7 @@
   // to CFG nodes within infinite loops.
   static bool HasForwardSuccessors(const NodePtr N, BatchUpdatePtr BUI) {
     assert(N && "N must be a valid node");
-    return !ChildrenGetter<false>::Get(N, BUI).empty();
+    return !getChildren<false>(N, BUI).empty();
   }
 
   static NodePtr GetEntryNode(const DomTreeT &DT) {
@@ -430,6 +397,32 @@
     // nodes.
     if (Total + 1 != Num) {
       HasNonTrivialRoots = true;
+
+      // SuccOrder is the order of blocks in the function. It is needed to make
+      // the calculation of the FurthestAway node and the whole PostDomTree
+      // immune to swap successors transformation (e.g. canonicalizing branch
+      // predicates). SuccOrder is initialized lazily only for successors of
+      // reverse unreachable nodes.
+      Optional<NodeOrderMap> SuccOrder;
+      auto InitSuccOrderOnce = [&]() {
+        SuccOrder = NodeOrderMap();
+        for (const auto Node : nodes(DT.Parent))
+          if (SNCA.NodeToInfo.count(Node) == 0)
+            for (const auto Succ : getChildren<false>(Node, SNCA.BatchUpdates))
+              SuccOrder->try_emplace(Succ, 0);
+
+        // Add mapping for all entries of SuccOrder.
+        unsigned NodeNum = 0;
+        for (const auto Node : nodes(DT.Parent)) {
+          ++NodeNum;
+          auto Order = SuccOrder->find(Node);
+          if (Order != SuccOrder->end()) {
+            assert(Order->second == 0);
+            Order->second = NodeNum;
+          }
+        }
+      };
+
       // Make another DFS pass over all other nodes to find the
       // reverse-unreachable blocks, and find the furthest paths we'll be able
       // to make.
@@ -454,7 +447,12 @@
           // expensive and does not always lead to a minimal set of roots.
           LLVM_DEBUG(dbgs() << "\t\t\tRunning forward DFS\n");
 
-          const unsigned NewNum = SNCA.runDFS<true>(I, Num, AlwaysDescend, Num);
+          if (!SuccOrder)
+            InitSuccOrderOnce();
+          assert(SuccOrder);
+
+          const unsigned NewNum =
+              SNCA.runDFS<true>(I, Num, AlwaysDescend, Num, &*SuccOrder);
           const NodePtr FurthestAway = SNCA.NumToNode[NewNum];
           LLVM_DEBUG(dbgs() << "\t\t\tFound a new furthest away node "
                             << "(non-trivial root): "
@@ -530,7 +528,7 @@
         // If we wound another root in a (forward) DFS walk, remove the current
         // root from the set of roots, as it is reverse-reachable from the other
         // one.
-        if (llvm::find(Roots, N) != Roots.end()) {
+        if (llvm::is_contained(Roots, N)) {
           LLVM_DEBUG(dbgs() << "\tForward DFS walk found another root "
                             << BlockNamePrinter(N) << "\n\tRemoving root "
                             << BlockNamePrinter(Root) << "\n");
@@ -563,12 +561,21 @@
     auto *Parent = DT.Parent;
     DT.reset();
     DT.Parent = Parent;
-    SemiNCAInfo SNCA(nullptr);  // Since we are rebuilding the whole tree,
-                                // there's no point doing it incrementally.
+    // If the update is using the actual CFG, BUI is null. If it's using a view,
+    // BUI is non-null and the PreCFGView is used. When calculating from
+    // scratch, make the PreViewCFG equal to the PostCFGView, so Post is used.
+    BatchUpdatePtr PostViewBUI = nullptr;
+    if (BUI && BUI->PostViewCFG) {
+      BUI->PreViewCFG = *BUI->PostViewCFG;
+      PostViewBUI = BUI;
+    }
+    // This is rebuilding the whole tree, not incrementally, but PostViewBUI is
+    // used in case the caller needs a DT update with a CFGView.
+    SemiNCAInfo SNCA(PostViewBUI);
 
     // Step #0: Number blocks in depth-first order and initialize variables used
     // in later stages of the algorithm.
-    DT.Roots = FindRoots(DT, nullptr);
+    DT.Roots = FindRoots(DT, PostViewBUI);
     SNCA.doFullDFSWalk(DT, AlwaysDescend);
 
     SNCA.runSemiNCA(DT);
@@ -585,9 +592,7 @@
     // all real exits (including multiple exit blocks, infinite loops).
     NodePtr Root = IsPostDom ? nullptr : DT.Roots[0];
 
-    DT.RootNode = (DT.DomTreeNodes[Root] =
-                       llvm::make_unique<DomTreeNodeBase<NodeT>>(Root, nullptr))
-        .get();
+    DT.RootNode = DT.createNode(Root);
     SNCA.attachNewSubtree(DT, DT.RootNode);
   }
 
@@ -597,8 +602,6 @@
     // Loop over all of the discovered blocks in the function...
     for (size_t i = 1, e = NumToNode.size(); i != e; ++i) {
       NodePtr W = NumToNode[i];
-      LLVM_DEBUG(dbgs() << "\tdiscovered a new reachable node "
-                        << BlockNamePrinter(W) << "\n");
 
       // Don't replace this with 'count', the insertion side effect is important
       if (DT.DomTreeNodes[W]) continue;  // Haven't calculated this node yet?
@@ -610,8 +613,7 @@
 
       // Add a new tree node for this BasicBlock, and link it as a child of
       // IDomNode.
-      DT.DomTreeNodes[W] = IDomNode->addChild(
-          llvm::make_unique<DomTreeNodeBase<NodeT>>(W, IDomNode));
+      DT.createChild(W, IDomNode);
     }
   }
 
@@ -661,10 +663,7 @@
 
       // The unreachable node becomes a new root -- a tree node for it.
       TreeNodePtr VirtualRoot = DT.getNode(nullptr);
-      FromTN =
-          (DT.DomTreeNodes[From] = VirtualRoot->addChild(
-               llvm::make_unique<DomTreeNodeBase<NodeT>>(From, VirtualRoot)))
-              .get();
+      FromTN = DT.createChild(From, VirtualRoot);
       DT.Roots.push_back(From);
     }
 
@@ -687,8 +686,7 @@
     // root.
     if (!DT.isVirtualRoot(To->getIDom())) return false;
 
-    auto RIt = llvm::find(DT.Roots, To->getBlock());
-    if (RIt == DT.Roots.end())
+    if (!llvm::is_contained(DT.Roots, To->getBlock()))
       return false;  // To is not a root, nothing to update.
 
     LLVM_DEBUG(dbgs() << "\t\tAfter the insertion, " << BlockNamePrinter(To)
@@ -732,7 +730,7 @@
       LLVM_DEBUG(dbgs() << "Roots are different in updated trees\n"
                         << "The entire tree needs to be rebuilt\n");
       // It may be possible to update the tree without recalculating it, but
-      // we do not know yet how to do it, and it happens rarely in practise.
+      // we do not know yet how to do it, and it happens rarely in practice.
       CalculateFromScratch(DT, BUI);
     }
   }
@@ -757,13 +755,13 @@
     LLVM_DEBUG(dbgs() << "\t\tNCA == " << BlockNamePrinter(NCD) << "\n");
     const unsigned NCDLevel = NCD->getLevel();
 
-    // Based on Lemma 2.5 from the second paper, after insertion of (From,To), v
-    // is affected iff depth(NCD)+1 < depth(v) && a path P from To to v exists
-    // where every w on P s.t. depth(v) <= depth(w)
+    // Based on Lemma 2.5 from [2], after insertion of (From,To), v is affected
+    // iff depth(NCD)+1 < depth(v) && a path P from To to v exists where every
+    // w on P s.t. depth(v) <= depth(w)
     //
     // This reduces to a widest path problem (maximizing the depth of the
     // minimum vertex in the path) which can be solved by a modified version of
-    // Dijkstra with a bucket queue (named depth-based search in the paper).
+    // Dijkstra with a bucket queue (named depth-based search in [2]).
 
     // To is in the path, so depth(NCD)+1 < depth(v) <= depth(To). Nothing
     // affected if this does not hold.
@@ -795,8 +793,7 @@
         //
         // Invariant: there is an optimal path from `To` to TN with the minimum
         // depth being CurrentLevel.
-        for (const NodePtr Succ :
-             ChildrenGetter<IsPostDom>::Get(TN->getBlock(), BUI)) {
+        for (const NodePtr Succ : getChildren<IsPostDom>(TN->getBlock(), BUI)) {
           const TreeNodePtr SuccTN = DT.getNode(Succ);
           assert(SuccTN &&
                  "Unreachable successor found at reachable insertion");
@@ -926,8 +923,8 @@
     // the DomTree about it.
     // The check is O(N), so run it only in debug configuration.
     auto IsSuccessor = [BUI](const NodePtr SuccCandidate, const NodePtr Of) {
-      auto Successors = ChildrenGetter<IsPostDom>::Get(Of, BUI);
-      return llvm::find(Successors, SuccCandidate) != Successors.end();
+      auto Successors = getChildren<IsPostDom>(Of, BUI);
+      return llvm::is_contained(Successors, SuccCandidate);
     };
     (void)IsSuccessor;
     assert(!IsSuccessor(To, From) && "Deleted edge still exists in the CFG!");
@@ -957,7 +954,7 @@
                         << BlockNamePrinter(ToIDom) << "\n");
 
       // To remains reachable after deletion.
-      // (Based on the caption under Figure 4. from the second paper.)
+      // (Based on the caption under Figure 4. from [2].)
       if (FromTN != ToIDom || HasProperSupport(DT, BUI, ToTN))
         DeleteReachable(DT, BUI, FromTN, ToTN);
       else
@@ -976,7 +973,7 @@
     LLVM_DEBUG(dbgs() << "\tRebuilding subtree\n");
 
     // Find the top of the subtree that needs to be rebuilt.
-    // (Based on the lemma 2.6 from the second paper.)
+    // (Based on the lemma 2.6 from [2].)
     const NodePtr ToIDom =
         DT.findNearestCommonDominator(FromTN->getBlock(), ToTN->getBlock());
     assert(ToIDom || DT.isPostDominator());
@@ -1008,20 +1005,19 @@
   }
 
   // Checks if a node has proper support, as defined on the page 3 and later
-  // explained on the page 7 of the second paper.
+  // explained on the page 7 of [2].
   static bool HasProperSupport(DomTreeT &DT, const BatchUpdatePtr BUI,
                                const TreeNodePtr TN) {
     LLVM_DEBUG(dbgs() << "IsReachableFromIDom " << BlockNamePrinter(TN)
                       << "\n");
-    for (const NodePtr Pred :
-         ChildrenGetter<!IsPostDom>::Get(TN->getBlock(), BUI)) {
+    auto TNB = TN->getBlock();
+    for (const NodePtr Pred : getChildren<!IsPostDom>(TNB, BUI)) {
       LLVM_DEBUG(dbgs() << "\tPred " << BlockNamePrinter(Pred) << "\n");
       if (!DT.getNode(Pred)) continue;
 
-      const NodePtr Support =
-          DT.findNearestCommonDominator(TN->getBlock(), Pred);
+      const NodePtr Support = DT.findNearestCommonDominator(TNB, Pred);
       LLVM_DEBUG(dbgs() << "\tSupport " << BlockNamePrinter(Support) << "\n");
-      if (Support != TN->getBlock()) {
+      if (Support != TNB) {
         LLVM_DEBUG(dbgs() << "\t" << BlockNamePrinter(TN)
                           << " is reachable from support "
                           << BlockNamePrinter(Support) << "\n");
@@ -1033,7 +1029,7 @@
   }
 
   // Handle deletions that make destination node unreachable.
-  // (Based on the lemma 2.7 from the second paper.)
+  // (Based on the lemma 2.7 from the [2].)
   static void DeleteUnreachable(DomTreeT &DT, const BatchUpdatePtr BUI,
                                 const TreeNodePtr ToTN) {
     LLVM_DEBUG(dbgs() << "Deleting unreachable subtree "
@@ -1062,7 +1058,7 @@
       const TreeNodePtr TN = DT.getNode(To);
       assert(TN);
       if (TN->getLevel() > Level) return true;
-      if (llvm::find(AffectedQueue, To) == AffectedQueue.end())
+      if (!llvm::is_contained(AffectedQueue, To))
         AffectedQueue.push_back(To);
 
       return false;
@@ -1152,53 +1148,34 @@
   //===--------------------- DomTree Batch Updater --------------------------===
   //~~
 
-  static void ApplyUpdates(DomTreeT &DT, ArrayRef<UpdateT> Updates) {
-    const size_t NumUpdates = Updates.size();
+  static void ApplyUpdates(DomTreeT &DT, GraphDiffT &PreViewCFG,
+                           GraphDiffT *PostViewCFG) {
+    // Note: the PostViewCFG is only used when computing from scratch. It's data
+    // should already included in the PreViewCFG for incremental updates.
+    const size_t NumUpdates = PreViewCFG.getNumLegalizedUpdates();
     if (NumUpdates == 0)
       return;
 
     // Take the fast path for a single update and avoid running the batch update
     // machinery.
     if (NumUpdates == 1) {
-      const auto &Update = Updates.front();
-      if (Update.getKind() == UpdateKind::Insert)
-        DT.insertEdge(Update.getFrom(), Update.getTo());
-      else
-        DT.deleteEdge(Update.getFrom(), Update.getTo());
-
+      UpdateT Update = PreViewCFG.popUpdateForIncrementalUpdates();
+      if (!PostViewCFG) {
+        if (Update.getKind() == UpdateKind::Insert)
+          InsertEdge(DT, /*BUI=*/nullptr, Update.getFrom(), Update.getTo());
+        else
+          DeleteEdge(DT, /*BUI=*/nullptr, Update.getFrom(), Update.getTo());
+      } else {
+        BatchUpdateInfo BUI(*PostViewCFG, PostViewCFG);
+        if (Update.getKind() == UpdateKind::Insert)
+          InsertEdge(DT, &BUI, Update.getFrom(), Update.getTo());
+        else
+          DeleteEdge(DT, &BUI, Update.getFrom(), Update.getTo());
+      }
       return;
     }
 
-    BatchUpdateInfo BUI;
-    LLVM_DEBUG(dbgs() << "Legalizing " << BUI.Updates.size() << " updates\n");
-    cfg::LegalizeUpdates<NodePtr>(Updates, BUI.Updates, IsPostDom);
-
-    const size_t NumLegalized = BUI.Updates.size();
-    BUI.FutureSuccessors.reserve(NumLegalized);
-    BUI.FuturePredecessors.reserve(NumLegalized);
-
-    // Use the legalized future updates to initialize future successors and
-    // predecessors. Note that these sets will only decrease size over time, as
-    // the next CFG snapshots slowly approach the actual (current) CFG.
-    for (UpdateT &U : BUI.Updates) {
-      BUI.FutureSuccessors[U.getFrom()].push_back({U.getTo(), U.getKind()});
-      BUI.FuturePredecessors[U.getTo()].push_back({U.getFrom(), U.getKind()});
-    }
-
-#if 0
-    // FIXME: The LLVM_DEBUG macro only plays well with a modular
-    // build of LLVM when the header is marked as textual, but doing
-    // so causes redefinition errors.
-    LLVM_DEBUG(dbgs() << "About to apply " << NumLegalized << " updates\n");
-    LLVM_DEBUG(if (NumLegalized < 32) for (const auto &U
-                                           : reverse(BUI.Updates)) {
-      dbgs() << "\t";
-      U.dump();
-      dbgs() << "\n";
-    });
-    LLVM_DEBUG(dbgs() << "\n");
-#endif
-
+    BatchUpdateInfo BUI(PreViewCFG, PostViewCFG);
     // Recalculate the DominatorTree when the number of updates
     // exceeds a threshold, which usually makes direct updating slower than
     // recalculation. We select this threshold proportional to the
@@ -1208,21 +1185,21 @@
 
     // Make unittests of the incremental algorithm work
     if (DT.DomTreeNodes.size() <= 100) {
-      if (NumLegalized > DT.DomTreeNodes.size())
+      if (BUI.NumLegalized > DT.DomTreeNodes.size())
         CalculateFromScratch(DT, &BUI);
-    } else if (NumLegalized > DT.DomTreeNodes.size() / 40)
+    } else if (BUI.NumLegalized > DT.DomTreeNodes.size() / 40)
       CalculateFromScratch(DT, &BUI);
 
     // If the DominatorTree was recalculated at some point, stop the batch
     // updates. Full recalculations ignore batch updates and look at the actual
     // CFG.
-    for (size_t i = 0; i < NumLegalized && !BUI.IsRecalculated; ++i)
+    for (size_t i = 0; i < BUI.NumLegalized && !BUI.IsRecalculated; ++i)
       ApplyNextUpdate(DT, BUI);
   }
 
   static void ApplyNextUpdate(DomTreeT &DT, BatchUpdateInfo &BUI) {
-    assert(!BUI.Updates.empty() && "No updates to apply!");
-    UpdateT CurrentUpdate = BUI.Updates.pop_back_val();
+    // Popping the next update, will move the PreViewCFG to the next snapshot.
+    UpdateT CurrentUpdate = BUI.PreViewCFG.popUpdateForIncrementalUpdates();
 #if 0
     // FIXME: The LLVM_DEBUG macro only plays well with a modular
     // build of LLVM when the header is marked as textual, but doing
@@ -1231,21 +1208,6 @@
     LLVM_DEBUG(CurrentUpdate.dump(); dbgs() << "\n");
 #endif
 
-    // Move to the next snapshot of the CFG by removing the reverse-applied
-    // current update. Since updates are performed in the same order they are
-    // legalized it's sufficient to pop the last item here.
-    auto &FS = BUI.FutureSuccessors[CurrentUpdate.getFrom()];
-    assert(FS.back().getPointer() == CurrentUpdate.getTo() &&
-           FS.back().getInt() == CurrentUpdate.getKind());
-    FS.pop_back();
-    if (FS.empty()) BUI.FutureSuccessors.erase(CurrentUpdate.getFrom());
-
-    auto &FP = BUI.FuturePredecessors[CurrentUpdate.getTo()];
-    assert(FP.back().getPointer() == CurrentUpdate.getFrom() &&
-           FP.back().getInt() == CurrentUpdate.getKind());
-    FP.pop_back();
-    if (FP.empty()) BUI.FuturePredecessors.erase(CurrentUpdate.getTo());
-
     if (CurrentUpdate.getKind() == UpdateKind::Insert)
       InsertEdge(DT, &BUI, CurrentUpdate.getFrom(), CurrentUpdate.getTo());
     else
@@ -1372,7 +1334,7 @@
     if (!DT.DFSInfoValid || !DT.Parent)
       return true;
 
-    const NodePtr RootBB = IsPostDom ? nullptr : DT.getRoots()[0];
+    const NodePtr RootBB = IsPostDom ? nullptr : *DT.root_begin();
     const TreeNodePtr Root = DT.getNode(RootBB);
 
     auto PrintNodeAndDFSNums = [](const TreeNodePtr TN) {
@@ -1396,7 +1358,7 @@
       const TreeNodePtr Node = NodeToTN.second.get();
 
       // Handle tree leaves.
-      if (Node->getChildren().empty()) {
+      if (Node->isLeaf()) {
         if (Node->getDFSNumIn() + 1 != Node->getDFSNumOut()) {
           errs() << "Tree leaf should have DFSOut = DFSIn + 1:\n\t";
           PrintNodeAndDFSNums(Node);
@@ -1493,9 +1455,9 @@
   // LEFT, and thus, LEFT is really an ancestor (in the dominator tree) of
   // RIGHT, not a sibling.
 
-  // It is possible to verify the parent and sibling properties in
-  // linear time, but the algorithms are complex. Instead, we do it in a
-  // straightforward N^2 and N^3 way below, using direct path reachability.
+  // It is possible to verify the parent and sibling properties in linear time,
+  // but the algorithms are complex. Instead, we do it in a straightforward
+  // N^2 and N^3 way below, using direct path reachability.
 
   // Checks if the tree has the parent property: if for all edges from V to W in
   // the input graph, such that V is reachable, the parent of W in the tree is
@@ -1508,7 +1470,8 @@
     for (auto &NodeToTN : DT.DomTreeNodes) {
       const TreeNodePtr TN = NodeToTN.second.get();
       const NodePtr BB = TN->getBlock();
-      if (!BB || TN->getChildren().empty()) continue;
+      if (!BB || TN->isLeaf())
+        continue;
 
       LLVM_DEBUG(dbgs() << "Verifying parent property of node "
                         << BlockNamePrinter(TN) << "\n");
@@ -1517,7 +1480,7 @@
         return From != BB && To != BB;
       });
 
-      for (TreeNodePtr Child : TN->getChildren())
+      for (TreeNodePtr Child : TN->children())
         if (NodeToInfo.count(Child->getBlock()) != 0) {
           errs() << "Child " << BlockNamePrinter(Child)
                  << " reachable after its parent " << BlockNamePrinter(BB)
@@ -1541,17 +1504,17 @@
     for (auto &NodeToTN : DT.DomTreeNodes) {
       const TreeNodePtr TN = NodeToTN.second.get();
       const NodePtr BB = TN->getBlock();
-      if (!BB || TN->getChildren().empty()) continue;
+      if (!BB || TN->isLeaf())
+        continue;
 
-      const auto &Siblings = TN->getChildren();
-      for (const TreeNodePtr N : Siblings) {
+      for (const TreeNodePtr N : TN->children()) {
         clear();
         NodePtr BBN = N->getBlock();
         doFullDFSWalk(DT, [BBN](NodePtr From, NodePtr To) {
           return From != BBN && To != BBN;
         });
 
-        for (const TreeNodePtr S : Siblings) {
+        for (const TreeNodePtr S : TN->children()) {
           if (S == N) continue;
 
           if (NodeToInfo.count(S->getBlock()) == 0) {
@@ -1571,7 +1534,7 @@
 
   // Check if the given tree is the same as a freshly computed one for the same
   // Parent.
-  // Running time: O(N^2), but faster in practise (same as tree construction).
+  // Running time: O(N^2), but faster in practice (same as tree construction).
   //
   // Note that this does not check if that the tree construction algorithm is
   // correct and should be only used for fast (but possibly unsound)
@@ -1603,19 +1566,11 @@
 template <typename DomTreeT>
 void CalculateWithUpdates(DomTreeT &DT,
                           ArrayRef<typename DomTreeT::UpdateType> Updates) {
-  // TODO: Move BUI creation in common method, reuse in ApplyUpdates.
-  typename SemiNCAInfo<DomTreeT>::BatchUpdateInfo BUI;
-  LLVM_DEBUG(dbgs() << "Legalizing " << BUI.Updates.size() << " updates\n");
-  cfg::LegalizeUpdates<typename DomTreeT::NodePtr>(Updates, BUI.Updates,
-                                                   DomTreeT::IsPostDominator);
-  const size_t NumLegalized = BUI.Updates.size();
-  BUI.FutureSuccessors.reserve(NumLegalized);
-  BUI.FuturePredecessors.reserve(NumLegalized);
-  for (auto &U : BUI.Updates) {
-    BUI.FutureSuccessors[U.getFrom()].push_back({U.getTo(), U.getKind()});
-    BUI.FuturePredecessors[U.getTo()].push_back({U.getFrom(), U.getKind()});
-  }
-
+  // FIXME: Updated to use the PreViewCFG and behave the same as until now.
+  // This behavior is however incorrect; this actually needs the PostViewCFG.
+  GraphDiff<typename DomTreeT::NodePtr, DomTreeT::IsPostDominator> PreViewCFG(
+      Updates, /*ReverseApplyUpdates=*/true);
+  typename SemiNCAInfo<DomTreeT>::BatchUpdateInfo BUI(PreViewCFG);
   SemiNCAInfo<DomTreeT>::CalculateFromScratch(DT, &BUI);
 }
 
@@ -1635,8 +1590,11 @@
 
 template <class DomTreeT>
 void ApplyUpdates(DomTreeT &DT,
-                  ArrayRef<typename DomTreeT::UpdateType> Updates) {
-  SemiNCAInfo<DomTreeT>::ApplyUpdates(DT, Updates);
+                  GraphDiff<typename DomTreeT::NodePtr,
+                            DomTreeT::IsPostDominator> &PreViewCFG,
+                  GraphDiff<typename DomTreeT::NodePtr,
+                            DomTreeT::IsPostDominator> *PostViewCFG) {
+  SemiNCAInfo<DomTreeT>::ApplyUpdates(DT, PreViewCFG, PostViewCFG);
 }
 
 template <class DomTreeT>
@@ -1648,12 +1606,12 @@
   if (!SNCA.IsSameAsFreshTree(DT))
     return false;
 
-  // Common checks to verify the properties of the tree. O(N log N) at worst
+  // Common checks to verify the properties of the tree. O(N log N) at worst.
   if (!SNCA.verifyRoots(DT) || !SNCA.verifyReachability(DT) ||
       !SNCA.VerifyLevels(DT) || !SNCA.VerifyDFSNumbers(DT))
     return false;
 
-  // Extra checks depending on VerificationLevel. Up to O(N^3)
+  // Extra checks depending on VerificationLevel. Up to O(N^3).
   if (VL == DomTreeT::VerificationLevel::Basic ||
       VL == DomTreeT::VerificationLevel::Full)
     if (!SNCA.verifyParentProperty(DT))
diff --git a/linux-x64/clang/include/llvm/Support/GenericIteratedDominanceFrontier.h b/linux-x64/clang/include/llvm/Support/GenericIteratedDominanceFrontier.h
index fcd2133..a8fca70 100644
--- a/linux-x64/clang/include/llvm/Support/GenericIteratedDominanceFrontier.h
+++ b/linux-x64/clang/include/llvm/Support/GenericIteratedDominanceFrontier.h
@@ -57,7 +57,7 @@
 template <class NodeTy, bool IsPostDom> class IDFCalculatorBase {
 public:
   using OrderedNodeTy =
-      typename std::conditional<IsPostDom, Inverse<NodeTy *>, NodeTy *>::type;
+      std::conditional_t<IsPostDom, Inverse<NodeTy *>, NodeTy *>;
   using ChildrenGetterTy =
       IDFCalculatorDetail::ChildrenGetterTy<NodeTy, IsPostDom>;
 
@@ -117,8 +117,7 @@
 
 template <class NodeTy, bool IsPostDom>
 typename ChildrenGetterTy<NodeTy, IsPostDom>::ChildrenTy
-ChildrenGetterTy<NodeTy, IsPostDom>::get(
-    const ChildrenGetterTy<NodeTy, IsPostDom>::NodeRef &N) {
+ChildrenGetterTy<NodeTy, IsPostDom>::get(const NodeRef &N) {
   using OrderedNodeTy =
       typename IDFCalculatorBase<NodeTy, IsPostDom>::OrderedNodeTy;
 
@@ -130,7 +129,7 @@
 
 template <class NodeTy, bool IsPostDom>
 void IDFCalculatorBase<NodeTy, IsPostDom>::calculate(
-    SmallVectorImpl<NodeTy *> &PHIBlocks) {
+    SmallVectorImpl<NodeTy *> &IDFBlocks) {
   // Use a priority queue keyed on dominator tree level so that inserted nodes
   // are handled from the bottom of the dominator tree upwards. We also augment
   // the level with a DFS number to ensure that the blocks are ordered in a
@@ -145,15 +144,16 @@
 
   DT.updateDFSNumbers();
 
-  for (NodeTy *BB : *DefBlocks) {
-    if (DomTreeNodeBase<NodeTy> *Node = DT.getNode(BB))
-      PQ.push({Node, std::make_pair(Node->getLevel(), Node->getDFSNumIn())});
-  }
-
   SmallVector<DomTreeNodeBase<NodeTy> *, 32> Worklist;
   SmallPtrSet<DomTreeNodeBase<NodeTy> *, 32> VisitedPQ;
   SmallPtrSet<DomTreeNodeBase<NodeTy> *, 32> VisitedWorklist;
 
+  for (NodeTy *BB : *DefBlocks)
+    if (DomTreeNodeBase<NodeTy> *Node = DT.getNode(BB)) {
+      PQ.push({Node, std::make_pair(Node->getLevel(), Node->getDFSNumIn())});
+      VisitedWorklist.insert(Node);
+    }
+
   while (!PQ.empty()) {
     DomTreeNodePair RootPair = PQ.top();
     PQ.pop();
@@ -165,9 +165,8 @@
     // most Root's level are added to the iterated dominance frontier of the
     // definition set.
 
-    Worklist.clear();
+    assert(Worklist.empty());
     Worklist.push_back(Root);
-    VisitedWorklist.insert(Root);
 
     while (!Worklist.empty()) {
       DomTreeNodeBase<NodeTy> *Node = Worklist.pop_back_val();
@@ -188,7 +187,7 @@
         if (useLiveIn && !LiveInBlocks->count(SuccBB))
           return;
 
-        PHIBlocks.emplace_back(SuccBB);
+        IDFBlocks.emplace_back(SuccBB);
         if (!DefBlocks->count(SuccBB))
           PQ.push(std::make_pair(
               SuccNode, std::make_pair(SuccLevel, SuccNode->getDFSNumIn())));
diff --git a/linux-x64/clang/include/llvm/Support/GlobPattern.h b/linux-x64/clang/include/llvm/Support/GlobPattern.h
index 66a4cd9..b79de6f 100644
--- a/linux-x64/clang/include/llvm/Support/GlobPattern.h
+++ b/linux-x64/clang/include/llvm/Support/GlobPattern.h
@@ -16,21 +16,31 @@
 
 #include "llvm/ADT/BitVector.h"
 #include "llvm/ADT/Optional.h"
-#include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Error.h"
 #include <vector>
 
 // This class represents a glob pattern. Supported metacharacters
-// are "*", "?", "[<chars>]" and "[^<chars>]".
+// are "*", "?", "\", "[<chars>]", "[^<chars>]", and "[!<chars>]".
 namespace llvm {
-class BitVector;
+
 template <typename T> class ArrayRef;
+class StringRef;
 
 class GlobPattern {
 public:
   static Expected<GlobPattern> create(StringRef Pat);
   bool match(StringRef S) const;
 
+  // Returns true for glob pattern "*". Can be used to avoid expensive
+  // preparation/acquisition of the input for match().
+  bool isTrivialMatchAll() const {
+    if (Prefix && Prefix->empty()) {
+      assert(!Suffix);
+      return true;
+    }
+    return false;
+  }
+
 private:
   bool matchOne(ArrayRef<BitVector> Pat, StringRef S) const;
 
diff --git a/linux-x64/clang/include/llvm/Support/GraphWriter.h b/linux-x64/clang/include/llvm/Support/GraphWriter.h
index 466a044..1f60fbc 100644
--- a/linux-x64/clang/include/llvm/Support/GraphWriter.h
+++ b/linux-x64/clang/include/llvm/Support/GraphWriter.h
@@ -126,7 +126,7 @@
   }
 
   void writeHeader(const std::string &Title) {
-    std::string GraphName = DTraits.getGraphName(G);
+    std::string GraphName(DTraits.getGraphName(G));
 
     if (!Title.empty())
       O << "digraph \"" << DOT::EscapeString(Title) << "\" {\n";
@@ -158,9 +158,7 @@
         writeNode(Node);
   }
 
-  bool isNodeHidden(NodeRef Node) {
-    return DTraits.isNodeHidden(Node);
-  }
+  bool isNodeHidden(NodeRef Node) { return DTraits.isNodeHidden(Node, G); }
 
   void writeNode(NodeRef Node) {
     std::string NodeAttributes = DTraits.getNodeAttributes(Node, G);
@@ -228,10 +226,10 @@
     child_iterator EI = GTraits::child_begin(Node);
     child_iterator EE = GTraits::child_end(Node);
     for (unsigned i = 0; EI != EE && i != 64; ++EI, ++i)
-      if (!DTraits.isNodeHidden(*EI))
+      if (!DTraits.isNodeHidden(*EI, G))
         writeEdge(Node, i, EI);
     for (; EI != EE; ++EI)
-      if (!DTraits.isNodeHidden(*EI))
+      if (!DTraits.isNodeHidden(*EI, G))
         writeEdge(Node, 64, EI);
   }
 
@@ -330,11 +328,8 @@
                        const Twine &Title = "",
                        std::string Filename = "") {
   int FD;
-  // Windows can't always handle long paths, so limit the length of the name.
-  std::string N = Name.str();
-  N = N.substr(0, std::min<std::size_t>(N.size(), 140));
   if (Filename.empty()) {
-    Filename = createGraphFilename(N, FD);
+    Filename = createGraphFilename(Name.str(), FD);
   } else {
     std::error_code EC = sys::fs::openFileForWrite(Filename, FD);
 
@@ -344,6 +339,8 @@
     } else if (EC) {
       errs() << "error writing into file" << "\n";
       return "";
+    } else {
+      errs() << "writing to the newly created file " << Filename << "\n";
     }
   }
   raw_fd_ostream O(FD, /*shouldClose=*/ true);
@@ -359,6 +356,17 @@
   return Filename;
 }
 
+/// DumpDotGraph - Just dump a dot graph to the user-provided file name.
+#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+template <typename GraphType>
+LLVM_DUMP_METHOD void
+dumpDotGraphToFile(const GraphType &G, const Twine &FileName,
+                   const Twine &Title, bool ShortNames = false,
+                   const Twine &Name = "") {
+  llvm::WriteGraph(G, Name, ShortNames, Title, FileName.str());
+}
+#endif
+
 /// ViewGraph - Emit a dot graph, run 'dot', run gv on the postscript file,
 /// then cleanup.  For use from the debugger.
 ///
diff --git a/linux-x64/clang/include/llvm/Support/Host.h b/linux-x64/clang/include/llvm/Support/Host.h
index b37cc51..d4ef389 100644
--- a/linux-x64/clang/include/llvm/Support/Host.h
+++ b/linux-x64/clang/include/llvm/Support/Host.h
@@ -13,41 +13,15 @@
 #ifndef LLVM_SUPPORT_HOST_H
 #define LLVM_SUPPORT_HOST_H
 
-#include "llvm/ADT/StringMap.h"
-
-#if defined(__linux__) || defined(__GNU__) || defined(__HAIKU__)
-#include <endian.h>
-#elif defined(_AIX)
-#include <sys/machine.h>
-#elif defined(__sun)
-/* Solaris provides _BIG_ENDIAN/_LITTLE_ENDIAN selector in sys/types.h */
-#include <sys/types.h>
-#define BIG_ENDIAN 4321
-#define LITTLE_ENDIAN 1234
-#if defined(_BIG_ENDIAN)
-#define BYTE_ORDER BIG_ENDIAN
-#else
-#define BYTE_ORDER LITTLE_ENDIAN
-#endif
-#else
-#if !defined(BYTE_ORDER) && !defined(_WIN32)
-#include <machine/endian.h>
-#endif
-#endif
-
 #include <string>
 
 namespace llvm {
+class MallocAllocator;
+class StringRef;
+template <typename ValueTy, typename AllocatorTy> class StringMap;
+
 namespace sys {
 
-#if defined(BYTE_ORDER) && defined(BIG_ENDIAN) && BYTE_ORDER == BIG_ENDIAN
-constexpr bool IsBigEndianHost = true;
-#else
-constexpr bool IsBigEndianHost = false;
-#endif
-
-  static const bool IsLittleEndianHost = !IsBigEndianHost;
-
   /// getDefaultTargetTriple() - Return the default target triple the compiler
   /// has been configured to produce code for.
   ///
@@ -78,7 +52,7 @@
   /// all valid LLVM feature names.
   ///
   /// \return - True on success.
-  bool getHostCPUFeatures(StringMap<bool> &Features);
+  bool getHostCPUFeatures(StringMap<bool, MallocAllocator> &Features);
 
   /// Get the number of physical cores (as opposed to logical cores returned
   /// from thread::hardware_concurrency(), which includes hyperthreads).
diff --git a/linux-x64/clang/include/llvm/Support/InitLLVM.h b/linux-x64/clang/include/llvm/Support/InitLLVM.h
index 57a0ebc..879dc15 100644
--- a/linux-x64/clang/include/llvm/Support/InitLLVM.h
+++ b/linux-x64/clang/include/llvm/Support/InitLLVM.h
@@ -9,6 +9,7 @@
 #ifndef LLVM_SUPPORT_LLVM_H
 #define LLVM_SUPPORT_LLVM_H
 
+#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/PrettyStackTrace.h"
@@ -17,9 +18,13 @@
 // the following one-time initializations:
 //
 //  1. Setting up a signal handler so that pretty stack trace is printed out
-//     if a process crashes.
+//     if a process crashes. A signal handler that exits when a failed write to
+//     a pipe occurs may optionally be installed: this is on-by-default.
 //
-//  2. If running on Windows, obtain command line arguments using a
+//  2. Set up the global new-handler which is called when a memory allocation
+//     attempt fails.
+//
+//  3. If running on Windows, obtain command line arguments using a
 //     multibyte character-aware API and convert arguments into UTF-8
 //     encoding, so that you can assume that command line arguments are
 //     always encoded in UTF-8 on any platform.
@@ -29,16 +34,18 @@
 namespace llvm {
 class InitLLVM {
 public:
-  InitLLVM(int &Argc, const char **&Argv);
-  InitLLVM(int &Argc, char **&Argv)
-      : InitLLVM(Argc, const_cast<const char **&>(Argv)) {}
+  InitLLVM(int &Argc, const char **&Argv,
+           bool InstallPipeSignalExitHandler = true);
+  InitLLVM(int &Argc, char **&Argv, bool InstallPipeSignalExitHandler = true)
+      : InitLLVM(Argc, const_cast<const char **&>(Argv),
+                 InstallPipeSignalExitHandler) {}
 
   ~InitLLVM();
 
 private:
   BumpPtrAllocator Alloc;
   SmallVector<const char *, 0> Args;
-  PrettyStackTraceProgram StackPrinter;
+  Optional<PrettyStackTraceProgram> StackPrinter;
 };
 } // namespace llvm
 
diff --git a/linux-x64/clang/include/llvm/Support/InstructionCost.h b/linux-x64/clang/include/llvm/Support/InstructionCost.h
new file mode 100644
index 0000000..725f849
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Support/InstructionCost.h
@@ -0,0 +1,237 @@
+//===- InstructionCost.h ----------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+/// \file
+/// This file defines an InstructionCost class that is used when calculating
+/// the cost of an instruction, or a group of instructions. In addition to a
+/// numeric value representing the cost the class also contains a state that
+/// can be used to encode particular properties, i.e. a cost being invalid or
+/// unknown.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_SUPPORT_INSTRUCTIONCOST_H
+#define LLVM_SUPPORT_INSTRUCTIONCOST_H
+
+#include "llvm/ADT/Optional.h"
+
+namespace llvm {
+
+class raw_ostream;
+
+class InstructionCost {
+public:
+  using CostType = int;
+
+  /// These states can currently be used to indicate whether a cost is valid or
+  /// invalid. Examples of an invalid cost might be where the cost is
+  /// prohibitively expensive and the user wants to prevent certain
+  /// optimizations being performed. Or perhaps the cost is simply unknown
+  /// because the operation makes no sense in certain circumstances. These
+  /// states can be expanded in future to support other cases if necessary.
+  enum CostState { Valid, Invalid };
+
+private:
+  CostType Value;
+  CostState State;
+
+  void propagateState(const InstructionCost &RHS) {
+    if (RHS.State == Invalid)
+      State = Invalid;
+  }
+
+public:
+  InstructionCost() = default;
+
+  InstructionCost(CostType Val) : Value(Val), State(Valid) {}
+
+  static InstructionCost getInvalid(CostType Val = 0) {
+    InstructionCost Tmp(Val);
+    Tmp.setInvalid();
+    return Tmp;
+  }
+
+  bool isValid() const { return State == Valid; }
+  void setValid() { State = Valid; }
+  void setInvalid() { State = Invalid; }
+  CostState getState() const { return State; }
+
+  /// This function is intended to be used as sparingly as possible, since the
+  /// class provides the full range of operator support required for arithmetic
+  /// and comparisons.
+  Optional<CostType> getValue() const {
+    if (isValid())
+      return Value;
+    return None;
+  }
+
+  /// For all of the arithmetic operators provided here any invalid state is
+  /// perpetuated and cannot be removed. Once a cost becomes invalid it stays
+  /// invalid, and it also inherits any invalid state from the RHS. Regardless
+  /// of the state, arithmetic and comparisons work on the actual values in the
+  /// same way as they would on a basic type, such as integer.
+
+  InstructionCost &operator+=(const InstructionCost &RHS) {
+    propagateState(RHS);
+    Value += RHS.Value;
+    return *this;
+  }
+
+  InstructionCost &operator+=(const CostType RHS) {
+    InstructionCost RHS2(RHS);
+    *this += RHS2;
+    return *this;
+  }
+
+  InstructionCost &operator-=(const InstructionCost &RHS) {
+    propagateState(RHS);
+    Value -= RHS.Value;
+    return *this;
+  }
+
+  InstructionCost &operator-=(const CostType RHS) {
+    InstructionCost RHS2(RHS);
+    *this -= RHS2;
+    return *this;
+  }
+
+  InstructionCost &operator*=(const InstructionCost &RHS) {
+    propagateState(RHS);
+    Value *= RHS.Value;
+    return *this;
+  }
+
+  InstructionCost &operator*=(const CostType RHS) {
+    InstructionCost RHS2(RHS);
+    *this *= RHS2;
+    return *this;
+  }
+
+  InstructionCost &operator/=(const InstructionCost &RHS) {
+    propagateState(RHS);
+    Value /= RHS.Value;
+    return *this;
+  }
+
+  InstructionCost &operator/=(const CostType RHS) {
+    InstructionCost RHS2(RHS);
+    *this /= RHS2;
+    return *this;
+  }
+
+  InstructionCost &operator++() {
+    *this += 1;
+    return *this;
+  }
+
+  InstructionCost operator++(int) {
+    InstructionCost Copy = *this;
+    ++*this;
+    return Copy;
+  }
+
+  InstructionCost &operator--() {
+    *this -= 1;
+    return *this;
+  }
+
+  InstructionCost operator--(int) {
+    InstructionCost Copy = *this;
+    --*this;
+    return Copy;
+  }
+
+  bool operator==(const InstructionCost &RHS) const {
+    return State == RHS.State && Value == RHS.Value;
+  }
+
+  bool operator!=(const InstructionCost &RHS) const { return !(*this == RHS); }
+
+  bool operator==(const CostType RHS) const {
+    return State == Valid && Value == RHS;
+  }
+
+  bool operator!=(const CostType RHS) const { return !(*this == RHS); }
+
+  /// For the comparison operators we have chosen to use total ordering with
+  /// the following rules:
+  ///  1. If either of the states != Valid then a lexicographical order is
+  ///     applied based upon the state.
+  ///  2. If both states are valid then order based upon value.
+  /// This avoids having to add asserts the comparison operators that the states
+  /// are valid and users can test for validity of the cost explicitly.
+  bool operator<(const InstructionCost &RHS) const {
+    if (State != Valid || RHS.State != Valid)
+      return State < RHS.State;
+    return Value < RHS.Value;
+  }
+
+  bool operator>(const InstructionCost &RHS) const { return RHS < *this; }
+
+  bool operator<=(const InstructionCost &RHS) const { return !(RHS < *this); }
+
+  bool operator>=(const InstructionCost &RHS) const { return !(*this < RHS); }
+
+  bool operator<(const CostType RHS) const {
+    InstructionCost RHS2(RHS);
+    return *this < RHS2;
+  }
+
+  bool operator>(const CostType RHS) const {
+    InstructionCost RHS2(RHS);
+    return *this > RHS2;
+  }
+
+  bool operator<=(const CostType RHS) const {
+    InstructionCost RHS2(RHS);
+    return *this <= RHS2;
+  }
+
+  bool operator>=(const CostType RHS) const {
+    InstructionCost RHS2(RHS);
+    return *this >= RHS2;
+  }
+
+  void print(raw_ostream &OS) const;
+};
+
+inline InstructionCost operator+(const InstructionCost &LHS,
+                                 const InstructionCost &RHS) {
+  InstructionCost LHS2(LHS);
+  LHS2 += RHS;
+  return LHS2;
+}
+
+inline InstructionCost operator-(const InstructionCost &LHS,
+                                 const InstructionCost &RHS) {
+  InstructionCost LHS2(LHS);
+  LHS2 -= RHS;
+  return LHS2;
+}
+
+inline InstructionCost operator*(const InstructionCost &LHS,
+                                 const InstructionCost &RHS) {
+  InstructionCost LHS2(LHS);
+  LHS2 *= RHS;
+  return LHS2;
+}
+
+inline InstructionCost operator/(const InstructionCost &LHS,
+                                 const InstructionCost &RHS) {
+  InstructionCost LHS2(LHS);
+  LHS2 /= RHS;
+  return LHS2;
+}
+
+inline raw_ostream &operator<<(raw_ostream &OS, const InstructionCost &V) {
+  V.print(OS);
+  return OS;
+}
+
+} // namespace llvm
+
+#endif
diff --git a/linux-x64/clang/include/llvm/Support/ItaniumManglingCanonicalizer.h b/linux-x64/clang/include/llvm/Support/ItaniumManglingCanonicalizer.h
index 6920000..8e1b3d6 100644
--- a/linux-x64/clang/include/llvm/Support/ItaniumManglingCanonicalizer.h
+++ b/linux-x64/clang/include/llvm/Support/ItaniumManglingCanonicalizer.h
@@ -14,11 +14,13 @@
 #ifndef LLVM_SUPPORT_ITANIUMMANGLINGCANONICALIZER_H
 #define LLVM_SUPPORT_ITANIUMMANGLINGCANONICALIZER_H
 
-#include "llvm/ADT/StringRef.h"
-
 #include <cstddef>
+#include <cstdint>
 
 namespace llvm {
+
+class StringRef;
+
 /// Canonicalizer for mangled names.
 ///
 /// This class allows specifying a list of "equivalent" manglings. For example,
diff --git a/linux-x64/clang/include/llvm/Support/JSON.h b/linux-x64/clang/include/llvm/Support/JSON.h
index 0ca4109..c753cee 100644
--- a/linux-x64/clang/include/llvm/Support/JSON.h
+++ b/linux-x64/clang/include/llvm/Support/JSON.h
@@ -122,6 +122,8 @@
   std::pair<iterator, bool> try_emplace(ObjectKey &&K, Ts &&... Args) {
     return M.try_emplace(std::move(K), std::forward<Ts>(Args)...);
   }
+  bool erase(StringRef K);
+  void erase(iterator I) { M.erase(I); }
 
   iterator find(StringRef K) { return M.find_as(K); }
   const_iterator find(StringRef K) const { return M.find_as(K); }
@@ -251,7 +253,14 @@
 /// === Converting JSON values to C++ types ===
 ///
 /// The convention is to have a deserializer function findable via ADL:
-///     fromJSON(const json::Value&, T&)->bool
+///     fromJSON(const json::Value&, T&, Path) -> bool
+///
+/// The return value indicates overall success, and Path is used for precise
+/// error reporting. (The Path::Root passed in at the top level fromJSON call
+/// captures any nested error and can render it in context).
+/// If conversion fails, fromJSON calls Path::report() and immediately returns.
+/// This ensures that the first fatal error survives.
+///
 /// Deserializers are provided for:
 ///   - bool
 ///   - int and int64_t
@@ -327,32 +336,28 @@
   Value(std::nullptr_t) : Type(T_Null) {}
   // Boolean (disallow implicit conversions).
   // (The last template parameter is a dummy to keep templates distinct.)
-  template <
-      typename T,
-      typename = typename std::enable_if<std::is_same<T, bool>::value>::type,
-      bool = false>
+  template <typename T,
+            typename = std::enable_if_t<std::is_same<T, bool>::value>,
+            bool = false>
   Value(T B) : Type(T_Boolean) {
     create<bool>(B);
   }
   // Integers (except boolean). Must be non-narrowing convertible to int64_t.
-  template <
-      typename T,
-      typename = typename std::enable_if<std::is_integral<T>::value>::type,
-      typename = typename std::enable_if<!std::is_same<T, bool>::value>::type>
+  template <typename T, typename = std::enable_if_t<std::is_integral<T>::value>,
+            typename = std::enable_if_t<!std::is_same<T, bool>::value>>
   Value(T I) : Type(T_Integer) {
     create<int64_t>(int64_t{I});
   }
   // Floating point. Must be non-narrowing convertible to double.
   template <typename T,
-            typename =
-                typename std::enable_if<std::is_floating_point<T>::value>::type,
+            typename = std::enable_if_t<std::is_floating_point<T>::value>,
             double * = nullptr>
   Value(T D) : Type(T_Double) {
     create<double>(double{D});
   }
   // Serializable types: with a toJSON(const T&)->Value function, found by ADL.
   template <typename T,
-            typename = typename std::enable_if<std::is_same<
+            typename = std::enable_if_t<std::is_same<
                 Value, decltype(toJSON(*(const T *)nullptr))>::value>,
             Value * = nullptr>
   Value(const T &V) : Value(toJSON(V)) {}
@@ -451,12 +456,12 @@
   friend class Object;
 
   template <typename T, typename... U> void create(U &&... V) {
-    new (reinterpret_cast<T *>(Union.buffer)) T(std::forward<U>(V)...);
+    new (reinterpret_cast<T *>(&Union)) T(std::forward<U>(V)...);
   }
   template <typename T> T &as() const {
     // Using this two-step static_cast via void * instead of reinterpret_cast
     // silences a -Wstrict-aliasing false positive from GCC6 and earlier.
-    void *Storage = static_cast<void *>(Union.buffer);
+    void *Storage = static_cast<void *>(&Union);
     return *static_cast<T *>(Storage);
   }
 
@@ -555,75 +560,173 @@
 inline std::pair<Object::iterator, bool> Object::insert(KV E) {
   return try_emplace(std::move(E.K), std::move(E.V));
 }
+inline bool Object::erase(StringRef K) {
+  return M.erase(ObjectKey(K));
+}
+
+/// A "cursor" marking a position within a Value.
+/// The Value is a tree, and this is the path from the root to the current node.
+/// This is used to associate errors with particular subobjects.
+class Path {
+public:
+  class Root;
+
+  /// Records that the value at the current path is invalid.
+  /// Message is e.g. "expected number" and becomes part of the final error.
+  /// This overwrites any previously written error message in the root.
+  void report(llvm::StringLiteral Message);
+
+  /// The root may be treated as a Path.
+  Path(Root &R) : Parent(nullptr), Seg(&R) {}
+  /// Derives a path for an array element: this[Index]
+  Path index(unsigned Index) const { return Path(this, Segment(Index)); }
+  /// Derives a path for an object field: this.Field
+  Path field(StringRef Field) const { return Path(this, Segment(Field)); }
+
+private:
+  /// One element in a JSON path: an object field (.foo) or array index [27].
+  /// Exception: the root Path encodes a pointer to the Path::Root.
+  class Segment {
+    uintptr_t Pointer;
+    unsigned Offset;
+
+  public:
+    Segment() = default;
+    Segment(Root *R) : Pointer(reinterpret_cast<uintptr_t>(R)) {}
+    Segment(llvm::StringRef Field)
+        : Pointer(reinterpret_cast<uintptr_t>(Field.data())),
+          Offset(static_cast<unsigned>(Field.size())) {}
+    Segment(unsigned Index) : Pointer(0), Offset(Index) {}
+
+    bool isField() const { return Pointer != 0; }
+    StringRef field() const {
+      return StringRef(reinterpret_cast<const char *>(Pointer), Offset);
+    }
+    unsigned index() const { return Offset; }
+    Root *root() const { return reinterpret_cast<Root *>(Pointer); }
+  };
+
+  const Path *Parent;
+  Segment Seg;
+
+  Path(const Path *Parent, Segment S) : Parent(Parent), Seg(S) {}
+};
+
+/// The root is the trivial Path to the root value.
+/// It also stores the latest reported error and the path where it occurred.
+class Path::Root {
+  llvm::StringRef Name;
+  llvm::StringLiteral ErrorMessage;
+  std::vector<Path::Segment> ErrorPath; // Only valid in error state. Reversed.
+
+  friend void Path::report(llvm::StringLiteral Message);
+
+public:
+  Root(llvm::StringRef Name = "") : Name(Name), ErrorMessage("") {}
+  // No copy/move allowed as there are incoming pointers.
+  Root(Root &&) = delete;
+  Root &operator=(Root &&) = delete;
+  Root(const Root &) = delete;
+  Root &operator=(const Root &) = delete;
+
+  /// Returns the last error reported, or else a generic error.
+  Error getError() const;
+  /// Print the root value with the error shown inline as a comment.
+  /// Unrelated parts of the value are elided for brevity, e.g.
+  ///   {
+  ///      "id": 42,
+  ///      "name": /* expected string */ null,
+  ///      "properties": { ... }
+  ///   }
+  void printErrorContext(const Value &, llvm::raw_ostream &) const;
+};
 
 // Standard deserializers are provided for primitive types.
 // See comments on Value.
-inline bool fromJSON(const Value &E, std::string &Out) {
+inline bool fromJSON(const Value &E, std::string &Out, Path P) {
   if (auto S = E.getAsString()) {
-    Out = *S;
+    Out = std::string(*S);
     return true;
   }
+  P.report("expected string");
   return false;
 }
-inline bool fromJSON(const Value &E, int &Out) {
+inline bool fromJSON(const Value &E, int &Out, Path P) {
   if (auto S = E.getAsInteger()) {
     Out = *S;
     return true;
   }
+  P.report("expected integer");
   return false;
 }
-inline bool fromJSON(const Value &E, int64_t &Out) {
+inline bool fromJSON(const Value &E, int64_t &Out, Path P) {
   if (auto S = E.getAsInteger()) {
     Out = *S;
     return true;
   }
+  P.report("expected integer");
   return false;
 }
-inline bool fromJSON(const Value &E, double &Out) {
+inline bool fromJSON(const Value &E, double &Out, Path P) {
   if (auto S = E.getAsNumber()) {
     Out = *S;
     return true;
   }
+  P.report("expected number");
   return false;
 }
-inline bool fromJSON(const Value &E, bool &Out) {
+inline bool fromJSON(const Value &E, bool &Out, Path P) {
   if (auto S = E.getAsBoolean()) {
     Out = *S;
     return true;
   }
+  P.report("expected boolean");
   return false;
 }
-template <typename T> bool fromJSON(const Value &E, llvm::Optional<T> &Out) {
+inline bool fromJSON(const Value &E, std::nullptr_t &Out, Path P) {
+  if (auto S = E.getAsNull()) {
+    Out = *S;
+    return true;
+  }
+  P.report("expected null");
+  return false;
+}
+template <typename T>
+bool fromJSON(const Value &E, llvm::Optional<T> &Out, Path P) {
   if (E.getAsNull()) {
     Out = llvm::None;
     return true;
   }
   T Result;
-  if (!fromJSON(E, Result))
+  if (!fromJSON(E, Result, P))
     return false;
   Out = std::move(Result);
   return true;
 }
-template <typename T> bool fromJSON(const Value &E, std::vector<T> &Out) {
+template <typename T>
+bool fromJSON(const Value &E, std::vector<T> &Out, Path P) {
   if (auto *A = E.getAsArray()) {
     Out.clear();
     Out.resize(A->size());
     for (size_t I = 0; I < A->size(); ++I)
-      if (!fromJSON((*A)[I], Out[I]))
+      if (!fromJSON((*A)[I], Out[I], P.index(I)))
         return false;
     return true;
   }
+  P.report("expected array");
   return false;
 }
 template <typename T>
-bool fromJSON(const Value &E, std::map<std::string, T> &Out) {
+bool fromJSON(const Value &E, std::map<std::string, T> &Out, Path P) {
   if (auto *O = E.getAsObject()) {
     Out.clear();
     for (const auto &KV : *O)
-      if (!fromJSON(KV.second, Out[llvm::StringRef(KV.first)]))
+      if (!fromJSON(KV.second, Out[std::string(llvm::StringRef(KV.first))],
+                    P.field(KV.first)))
         return false;
     return true;
   }
+  P.report("expected object");
   return false;
 }
 
@@ -636,42 +739,59 @@
 ///
 /// Example:
 /// \code
-///   bool fromJSON(const Value &E, MyStruct &R) {
-///     ObjectMapper O(E);
-///     if (!O || !O.map("mandatory_field", R.MandatoryField))
-///       return false;
-///     O.map("optional_field", R.OptionalField);
-///     return true;
+///   bool fromJSON(const Value &E, MyStruct &R, Path P) {
+///     ObjectMapper O(E, P);
+///     // When returning false, error details were already reported.
+///     return O && O.map("mandatory_field", R.MandatoryField) &&
+///         O.mapOptional("optional_field", R.OptionalField);
 ///   }
 /// \endcode
 class ObjectMapper {
 public:
-  ObjectMapper(const Value &E) : O(E.getAsObject()) {}
+  /// If O is not an object, this mapper is invalid and an error is reported.
+  ObjectMapper(const Value &E, Path P) : O(E.getAsObject()), P(P) {
+    if (!O)
+      P.report("expected object");
+  }
 
   /// True if the expression is an object.
   /// Must be checked before calling map().
-  operator bool() { return O; }
+  operator bool() const { return O; }
 
-  /// Maps a property to a field, if it exists.
-  template <typename T> bool map(StringRef Prop, T &Out) {
+  /// Maps a property to a field.
+  /// If the property is missing or invalid, reports an error.
+  template <typename T> bool map(StringLiteral Prop, T &Out) {
     assert(*this && "Must check this is an object before calling map()");
     if (const Value *E = O->get(Prop))
-      return fromJSON(*E, Out);
+      return fromJSON(*E, Out, P.field(Prop));
+    P.field(Prop).report("missing value");
     return false;
   }
 
   /// Maps a property to a field, if it exists.
+  /// If the property exists and is invalid, reports an error.
   /// (Optional requires special handling, because missing keys are OK).
-  template <typename T> bool map(StringRef Prop, llvm::Optional<T> &Out) {
+  template <typename T> bool map(StringLiteral Prop, llvm::Optional<T> &Out) {
     assert(*this && "Must check this is an object before calling map()");
     if (const Value *E = O->get(Prop))
-      return fromJSON(*E, Out);
+      return fromJSON(*E, Out, P.field(Prop));
     Out = llvm::None;
     return true;
   }
 
+  /// Maps a property to a field, if it exists.
+  /// If the property exists and is invalid, reports an error.
+  /// If the property does not exist, Out is unchanged.
+  template <typename T> bool mapOptional(StringLiteral Prop, T &Out) {
+    assert(*this && "Must check this is an object before calling map()");
+    if (const Value *E = O->get(Prop))
+      return fromJSON(*E, Out, P.field(Prop));
+    return true;
+  }
+
 private:
   const Object *O;
+  Path P;
 };
 
 /// Parses the provided JSON source, or returns a ParseError.
@@ -695,9 +815,24 @@
   }
 };
 
+/// Version of parse() that converts the parsed value to the type T.
+/// RootName describes the root object and is used in error messages.
+template <typename T>
+Expected<T> parse(const llvm::StringRef &JSON, const char *RootName = "") {
+  auto V = parse(JSON);
+  if (!V)
+    return V.takeError();
+  Path::Root R(RootName);
+  T Result;
+  if (fromJSON(*V, Result, R))
+    return std::move(Result);
+  return R.getError();
+}
+
 /// json::OStream allows writing well-formed JSON without materializing
 /// all structures as json::Value ahead of time.
 /// It's faster, lower-level, and less safe than OS << json::Value.
+/// It also allows emitting more constructs, such as comments.
 ///
 /// Only one "top-level" object can be written to a stream.
 /// Simplest usage involves passing lambdas (Blocks) to fill in containers:
@@ -709,7 +844,7 @@
 ///         J.attribute("timestamp", int64_t(E.Time));
 ///         J.attributeArray("participants", [&] {
 ///           for (const Participant &P : E.Participants)
-///             J.string(P.toString());
+///             J.value(P.toString());
 ///         });
 ///       });
 ///   });
@@ -783,6 +918,21 @@
     Contents();
     objectEnd();
   }
+  /// Emit an externally-serialized value.
+  /// The caller must write exactly one valid JSON value to the provided stream.
+  /// No validation or formatting of this value occurs.
+  void rawValue(llvm::function_ref<void(raw_ostream &)> Contents) {
+    rawValueBegin();
+    Contents(OS);
+    rawValueEnd();
+  }
+  void rawValue(llvm::StringRef Contents) {
+    rawValue([&](raw_ostream &OS) { OS << Contents; });
+  }
+  /// Emit a JavaScript comment associated with the next printed value.
+  /// The string must be valid until the next attribute or value is emitted.
+  /// Comments are not part of standard JSON, and many parsers reject them!
+  void comment(llvm::StringRef);
 
   // High level functions to output object attributes.
   // Valid only within an object (any number of times).
@@ -809,8 +959,10 @@
   void objectEnd();
   void attributeBegin(llvm::StringRef Key);
   void attributeEnd();
+  raw_ostream &rawValueBegin();
+  void rawValueEnd();
 
- private:
+private:
   void attributeImpl(llvm::StringRef Key, Block Contents) {
     attributeBegin(Key);
     Contents();
@@ -818,18 +970,21 @@
   }
 
   void valueBegin();
+  void flushComment();
   void newline();
 
   enum Context {
     Singleton, // Top level, or object attribute.
     Array,
     Object,
+    RawValue, // External code writing a value to OS directly.
   };
   struct State {
     Context Ctx = Singleton;
     bool HasValue = false;
   };
   llvm::SmallVector<State, 16> Stack; // Never empty.
+  llvm::StringRef PendingComment;
   llvm::raw_ostream &OS;
   unsigned IndentSize;
   unsigned Indent = 0;
diff --git a/linux-x64/clang/include/llvm/Support/JamCRC.h b/linux-x64/clang/include/llvm/Support/JamCRC.h
deleted file mode 100644
index b6fc4e7..0000000
--- a/linux-x64/clang/include/llvm/Support/JamCRC.h
+++ /dev/null
@@ -1,48 +0,0 @@
-//===-- llvm/Support/JamCRC.h - Cyclic Redundancy Check ---------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// This file contains an implementation of JamCRC.
-//
-// We will use the "Rocksoft^tm Model CRC Algorithm" to describe the properties
-// of this CRC:
-//   Width  : 32
-//   Poly   : 04C11DB7
-//   Init   : FFFFFFFF
-//   RefIn  : True
-//   RefOut : True
-//   XorOut : 00000000
-//   Check  : 340BC6D9 (result of CRC for "123456789")
-//
-// N.B.  We permit flexibility of the "Init" value.  Some consumers of this need
-//       it to be zero.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_SUPPORT_JAMCRC_H
-#define LLVM_SUPPORT_JAMCRC_H
-
-#include "llvm/Support/DataTypes.h"
-
-namespace llvm {
-template <typename T> class ArrayRef;
-
-class JamCRC {
-public:
-  JamCRC(uint32_t Init = 0xFFFFFFFFU) : CRC(Init) {}
-
-  // Update the CRC calculation with Data.
-  void update(ArrayRef<char> Data);
-
-  uint32_t getCRC() const { return CRC; }
-
-private:
-  uint32_t CRC;
-};
-} // End of namespace llvm
-
-#endif
diff --git a/linux-x64/clang/include/llvm/Support/KnownBits.h b/linux-x64/clang/include/llvm/Support/KnownBits.h
index 07fd94e..d854aad 100644
--- a/linux-x64/clang/include/llvm/Support/KnownBits.h
+++ b/linux-x64/clang/include/llvm/Support/KnownBits.h
@@ -15,6 +15,7 @@
 #define LLVM_SUPPORT_KNOWNBITS_H
 
 #include "llvm/ADT/APInt.h"
+#include "llvm/ADT/Optional.h"
 
 namespace llvm {
 
@@ -97,6 +98,12 @@
   /// Returns true if this value is known to be non-negative.
   bool isNonNegative() const { return Zero.isSignBitSet(); }
 
+  /// Returns true if this value is known to be non-zero.
+  bool isNonZero() const { return !One.isNullValue(); }
+
+  /// Returns true if this value is known to be positive.
+  bool isStrictlyPositive() const { return Zero.isSignBitSet() && !One.isNullValue(); }
+
   /// Make this value negative.
   void makeNegative() {
     One.setSignBit();
@@ -107,41 +114,107 @@
     Zero.setSignBit();
   }
 
-  /// Truncate the underlying known Zero and One bits. This is equivalent
-  /// to truncating the value we're tracking.
+  /// Return the minimal unsigned value possible given these KnownBits.
+  APInt getMinValue() const {
+    // Assume that all bits that aren't known-ones are zeros.
+    return One;
+  }
+
+  /// Return the minimal signed value possible given these KnownBits.
+  APInt getSignedMinValue() const {
+    // Assume that all bits that aren't known-ones are zeros.
+    APInt Min = One;
+    // Sign bit is unknown.
+    if (Zero.isSignBitClear())
+      Min.setSignBit();
+    return Min;
+  }
+
+  /// Return the maximal unsigned value possible given these KnownBits.
+  APInt getMaxValue() const {
+    // Assume that all bits that aren't known-zeros are ones.
+    return ~Zero;
+  }
+
+  /// Return the maximal signed value possible given these KnownBits.
+  APInt getSignedMaxValue() const {
+    // Assume that all bits that aren't known-zeros are ones.
+    APInt Max = ~Zero;
+    // Sign bit is unknown.
+    if (One.isSignBitClear())
+      Max.clearSignBit();
+    return Max;
+  }
+
+  /// Return known bits for a truncation of the value we're tracking.
   KnownBits trunc(unsigned BitWidth) const {
     return KnownBits(Zero.trunc(BitWidth), One.trunc(BitWidth));
   }
 
-  /// Extends the underlying known Zero and One bits.
-  /// By setting ExtendedBitsAreKnownZero=true this will be equivalent to
-  /// zero extending the value we're tracking.
-  /// With ExtendedBitsAreKnownZero=false the extended bits are set to unknown.
-  KnownBits zext(unsigned BitWidth, bool ExtendedBitsAreKnownZero) const {
+  /// Return known bits for an "any" extension of the value we're tracking,
+  /// where we don't know anything about the extended bits.
+  KnownBits anyext(unsigned BitWidth) const {
+    return KnownBits(Zero.zext(BitWidth), One.zext(BitWidth));
+  }
+
+  /// Return known bits for a zero extension of the value we're tracking.
+  KnownBits zext(unsigned BitWidth) const {
     unsigned OldBitWidth = getBitWidth();
     APInt NewZero = Zero.zext(BitWidth);
-    if (ExtendedBitsAreKnownZero)
-      NewZero.setBitsFrom(OldBitWidth);
+    NewZero.setBitsFrom(OldBitWidth);
     return KnownBits(NewZero, One.zext(BitWidth));
   }
 
-  /// Sign extends the underlying known Zero and One bits. This is equivalent
-  /// to sign extending the value we're tracking.
+  /// Return known bits for a sign extension of the value we're tracking.
   KnownBits sext(unsigned BitWidth) const {
     return KnownBits(Zero.sext(BitWidth), One.sext(BitWidth));
   }
 
-  /// Extends or truncates the underlying known Zero and One bits. When
-  /// extending the extended bits can either be set as known zero (if
-  /// ExtendedBitsAreKnownZero=true) or as unknown (if
-  /// ExtendedBitsAreKnownZero=false).
-  KnownBits zextOrTrunc(unsigned BitWidth,
-                        bool ExtendedBitsAreKnownZero) const {
+  /// Return known bits for an "any" extension or truncation of the value we're
+  /// tracking.
+  KnownBits anyextOrTrunc(unsigned BitWidth) const {
     if (BitWidth > getBitWidth())
-      return zext(BitWidth, ExtendedBitsAreKnownZero);
-    return KnownBits(Zero.zextOrTrunc(BitWidth), One.zextOrTrunc(BitWidth));
+      return anyext(BitWidth);
+    if (BitWidth < getBitWidth())
+      return trunc(BitWidth);
+    return *this;
   }
 
+  /// Return known bits for a zero extension or truncation of the value we're
+  /// tracking.
+  KnownBits zextOrTrunc(unsigned BitWidth) const {
+    if (BitWidth > getBitWidth())
+      return zext(BitWidth);
+    if (BitWidth < getBitWidth())
+      return trunc(BitWidth);
+    return *this;
+  }
+
+  /// Return known bits for a sign extension or truncation of the value we're
+  /// tracking.
+  KnownBits sextOrTrunc(unsigned BitWidth) const {
+    if (BitWidth > getBitWidth())
+      return sext(BitWidth);
+    if (BitWidth < getBitWidth())
+      return trunc(BitWidth);
+    return *this;
+  }
+
+  /// Return known bits for a in-register sign extension of the value we're
+  /// tracking.
+  KnownBits sextInReg(unsigned SrcBitWidth) const;
+
+  /// Return a KnownBits with the extracted bits
+  /// [bitPosition,bitPosition+numBits).
+  KnownBits extractBits(unsigned NumBits, unsigned BitPosition) const {
+    return KnownBits(Zero.extractBits(NumBits, BitPosition),
+                     One.extractBits(NumBits, BitPosition));
+  }
+
+  /// Return KnownBits based on this, but updated given that the underlying
+  /// value is known to be greater than or equal to Val.
+  KnownBits makeGE(const APInt &Val) const;
+
   /// Returns the minimum number of trailing zero bits.
   unsigned countMinTrailingZeros() const {
     return Zero.countTrailingOnes();
@@ -202,6 +275,16 @@
     return getBitWidth() - Zero.countPopulation();
   }
 
+  /// Create known bits from a known constant.
+  static KnownBits makeConstant(const APInt &C) {
+    return KnownBits(~C, C);
+  }
+
+  /// Compute known bits common to LHS and RHS.
+  static KnownBits commonBits(const KnownBits &LHS, const KnownBits &RHS) {
+    return KnownBits(LHS.Zero & RHS.Zero, LHS.One & RHS.One);
+  }
+
   /// Compute known bits resulting from adding LHS, RHS and a 1-bit Carry.
   static KnownBits computeForAddCarry(
       const KnownBits &LHS, const KnownBits &RHS, const KnownBits &Carry);
@@ -209,8 +292,136 @@
   /// Compute known bits resulting from adding LHS and RHS.
   static KnownBits computeForAddSub(bool Add, bool NSW, const KnownBits &LHS,
                                     KnownBits RHS);
+
+  /// Compute known bits resulting from multiplying LHS and RHS.
+  static KnownBits computeForMul(const KnownBits &LHS, const KnownBits &RHS);
+
+  /// Compute known bits for udiv(LHS, RHS).
+  static KnownBits udiv(const KnownBits &LHS, const KnownBits &RHS);
+
+  /// Compute known bits for urem(LHS, RHS).
+  static KnownBits urem(const KnownBits &LHS, const KnownBits &RHS);
+
+  /// Compute known bits for srem(LHS, RHS).
+  static KnownBits srem(const KnownBits &LHS, const KnownBits &RHS);
+
+  /// Compute known bits for umax(LHS, RHS).
+  static KnownBits umax(const KnownBits &LHS, const KnownBits &RHS);
+
+  /// Compute known bits for umin(LHS, RHS).
+  static KnownBits umin(const KnownBits &LHS, const KnownBits &RHS);
+
+  /// Compute known bits for smax(LHS, RHS).
+  static KnownBits smax(const KnownBits &LHS, const KnownBits &RHS);
+
+  /// Compute known bits for smin(LHS, RHS).
+  static KnownBits smin(const KnownBits &LHS, const KnownBits &RHS);
+
+  /// Compute known bits for shl(LHS, RHS).
+  /// NOTE: RHS (shift amount) bitwidth doesn't need to be the same as LHS.
+  static KnownBits shl(const KnownBits &LHS, const KnownBits &RHS);
+
+  /// Compute known bits for lshr(LHS, RHS).
+  /// NOTE: RHS (shift amount) bitwidth doesn't need to be the same as LHS.
+  static KnownBits lshr(const KnownBits &LHS, const KnownBits &RHS);
+
+  /// Compute known bits for ashr(LHS, RHS).
+  /// NOTE: RHS (shift amount) bitwidth doesn't need to be the same as LHS.
+  static KnownBits ashr(const KnownBits &LHS, const KnownBits &RHS);
+
+  /// Determine if these known bits always give the same ICMP_EQ result.
+  static Optional<bool> eq(const KnownBits &LHS, const KnownBits &RHS);
+
+  /// Determine if these known bits always give the same ICMP_NE result.
+  static Optional<bool> ne(const KnownBits &LHS, const KnownBits &RHS);
+
+  /// Determine if these known bits always give the same ICMP_UGT result.
+  static Optional<bool> ugt(const KnownBits &LHS, const KnownBits &RHS);
+
+  /// Determine if these known bits always give the same ICMP_UGE result.
+  static Optional<bool> uge(const KnownBits &LHS, const KnownBits &RHS);
+
+  /// Determine if these known bits always give the same ICMP_ULT result.
+  static Optional<bool> ult(const KnownBits &LHS, const KnownBits &RHS);
+
+  /// Determine if these known bits always give the same ICMP_ULE result.
+  static Optional<bool> ule(const KnownBits &LHS, const KnownBits &RHS);
+
+  /// Determine if these known bits always give the same ICMP_SGT result.
+  static Optional<bool> sgt(const KnownBits &LHS, const KnownBits &RHS);
+
+  /// Determine if these known bits always give the same ICMP_SGE result.
+  static Optional<bool> sge(const KnownBits &LHS, const KnownBits &RHS);
+
+  /// Determine if these known bits always give the same ICMP_SLT result.
+  static Optional<bool> slt(const KnownBits &LHS, const KnownBits &RHS);
+
+  /// Determine if these known bits always give the same ICMP_SLE result.
+  static Optional<bool> sle(const KnownBits &LHS, const KnownBits &RHS);
+
+  /// Insert the bits from a smaller known bits starting at bitPosition.
+  void insertBits(const KnownBits &SubBits, unsigned BitPosition) {
+    Zero.insertBits(SubBits.Zero, BitPosition);
+    One.insertBits(SubBits.One, BitPosition);
+  }
+
+  /// Return a subset of the known bits from [bitPosition,bitPosition+numBits).
+  KnownBits extractBits(unsigned NumBits, unsigned BitPosition) {
+    return KnownBits(Zero.extractBits(NumBits, BitPosition),
+                     One.extractBits(NumBits, BitPosition));
+  }
+
+  /// Update known bits based on ANDing with RHS.
+  KnownBits &operator&=(const KnownBits &RHS);
+
+  /// Update known bits based on ORing with RHS.
+  KnownBits &operator|=(const KnownBits &RHS);
+
+  /// Update known bits based on XORing with RHS.
+  KnownBits &operator^=(const KnownBits &RHS);
+
+  /// Compute known bits for the absolute value.
+  KnownBits abs(bool IntMinIsPoison = false) const;
+
+  KnownBits byteSwap() {
+    return KnownBits(Zero.byteSwap(), One.byteSwap());
+  }
+
+  KnownBits reverseBits() {
+    return KnownBits(Zero.reverseBits(), One.reverseBits());
+  }
 };
 
+inline KnownBits operator&(KnownBits LHS, const KnownBits &RHS) {
+  LHS &= RHS;
+  return LHS;
+}
+
+inline KnownBits operator&(const KnownBits &LHS, KnownBits &&RHS) {
+  RHS &= LHS;
+  return std::move(RHS);
+}
+
+inline KnownBits operator|(KnownBits LHS, const KnownBits &RHS) {
+  LHS |= RHS;
+  return LHS;
+}
+
+inline KnownBits operator|(const KnownBits &LHS, KnownBits &&RHS) {
+  RHS |= LHS;
+  return std::move(RHS);
+}
+
+inline KnownBits operator^(KnownBits LHS, const KnownBits &RHS) {
+  LHS ^= RHS;
+  return LHS;
+}
+
+inline KnownBits operator^(const KnownBits &LHS, KnownBits &&RHS) {
+  RHS ^= LHS;
+  return std::move(RHS);
+}
+
 } // end namespace llvm
 
 #endif
diff --git a/linux-x64/clang/include/llvm/Support/LEB128.h b/linux-x64/clang/include/llvm/Support/LEB128.h
index a02b83c..8ab3543 100644
--- a/linux-x64/clang/include/llvm/Support/LEB128.h
+++ b/linux-x64/clang/include/llvm/Support/LEB128.h
@@ -134,7 +134,7 @@
   if (error)
     *error = nullptr;
   do {
-    if (end && p == end) {
+    if (p == end) {
       if (error)
         *error = "malformed uleb128, extends past end";
       if (n)
@@ -168,7 +168,7 @@
   if (error)
     *error = nullptr;
   do {
-    if (end && p == end) {
+    if (p == end) {
       if (error)
         *error = "malformed sleb128, extends past end";
       if (n)
diff --git a/linux-x64/clang/include/llvm/Support/LineIterator.h b/linux-x64/clang/include/llvm/Support/LineIterator.h
index c9f10ca..b391412 100644
--- a/linux-x64/clang/include/llvm/Support/LineIterator.h
+++ b/linux-x64/clang/include/llvm/Support/LineIterator.h
@@ -9,8 +9,10 @@
 #ifndef LLVM_SUPPORT_LINEITERATOR_H
 #define LLVM_SUPPORT_LINEITERATOR_H
 
+#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/DataTypes.h"
+#include "llvm/Support/MemoryBufferRef.h"
 #include <iterator>
 
 namespace llvm {
@@ -30,16 +32,20 @@
 /// Note that this iterator requires the buffer to be nul terminated.
 class line_iterator
     : public std::iterator<std::forward_iterator_tag, StringRef> {
-  const MemoryBuffer *Buffer;
-  char CommentMarker;
-  bool SkipBlanks;
+  Optional<MemoryBufferRef> Buffer;
+  char CommentMarker = '\0';
+  bool SkipBlanks = true;
 
-  unsigned LineNumber;
+  unsigned LineNumber = 1;
   StringRef CurrentLine;
 
 public:
   /// Default construct an "end" iterator.
-  line_iterator() : Buffer(nullptr) {}
+  line_iterator() = default;
+
+  /// Construct a new iterator around an unowned memory buffer.
+  explicit line_iterator(const MemoryBufferRef &Buffer, bool SkipBlanks = true,
+                         char CommentMarker = '\0');
 
   /// Construct a new iterator around some memory buffer.
   explicit line_iterator(const MemoryBuffer &Buffer, bool SkipBlanks = true,
diff --git a/linux-x64/clang/include/llvm/Support/LockFileManager.h b/linux-x64/clang/include/llvm/Support/LockFileManager.h
index 57e4fbd..ab66621 100644
--- a/linux-x64/clang/include/llvm/Support/LockFileManager.h
+++ b/linux-x64/clang/include/llvm/Support/LockFileManager.h
@@ -77,7 +77,9 @@
   operator LockFileState() const { return getState(); }
 
   /// For a shared lock, wait until the owner releases the lock.
-  WaitForUnlockResult waitForUnlock();
+  /// Total timeout for the file to appear is ~1.5 minutes.
+  /// \param MaxSeconds the maximum total wait time in seconds.
+  WaitForUnlockResult waitForUnlock(const unsigned MaxSeconds = 90);
 
   /// Remove the lock file.  This may delete a different lock file than
   /// the one previously read if there is a race.
diff --git a/linux-x64/clang/include/llvm/Support/LowLevelTypeImpl.h b/linux-x64/clang/include/llvm/Support/LowLevelTypeImpl.h
index 0e02b6e..c1d516f 100644
--- a/linux-x64/clang/include/llvm/Support/LowLevelTypeImpl.h
+++ b/linux-x64/clang/include/llvm/Support/LowLevelTypeImpl.h
@@ -27,6 +27,7 @@
 #define LLVM_SUPPORT_LOWLEVELTYPEIMPL_H
 
 #include "llvm/ADT/DenseMapInfo.h"
+#include "llvm/Support/Debug.h"
 #include "llvm/Support/MachineValueType.h"
 #include <cassert>
 
@@ -137,6 +138,28 @@
                       : LLT::scalar(NewEltSize);
   }
 
+  /// Return a vector or scalar with the same element type and the new number of
+  /// elements.
+  LLT changeNumElements(unsigned NewNumElts) const {
+    return LLT::scalarOrVector(NewNumElts, getScalarType());
+  }
+
+  /// Return a type that is \p Factor times smaller. Reduces the number of
+  /// elements if this is a vector, or the bitwidth for scalar/pointers. Does
+  /// not attempt to handle cases that aren't evenly divisible.
+  LLT divide(int Factor) const {
+    assert(Factor != 1);
+    if (isVector()) {
+      assert(getNumElements() % Factor == 0);
+      return scalarOrVector(getNumElements() / Factor, getElementType());
+    }
+
+    assert(getSizeInBits() % Factor == 0);
+    return scalar(getSizeInBits() / Factor);
+  }
+
+  bool isByteSized() const { return (getSizeInBits() & 7) == 0; }
+
   unsigned getScalarSizeInBits() const {
     assert(RawData != 0 && "Invalid Type");
     if (!IsVector) {
@@ -172,6 +195,13 @@
 
   void print(raw_ostream &OS) const;
 
+#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+  LLVM_DUMP_METHOD void dump() const {
+    print(dbgs());
+    dbgs() << '\n';
+  }
+#endif
+
   bool operator==(const LLT &RHS) const {
     return IsPointer == RHS.IsPointer && IsVector == RHS.IsVector &&
            RHS.RawData == RawData;
diff --git a/linux-x64/clang/include/llvm/Support/MD5.h b/linux-x64/clang/include/llvm/Support/MD5.h
index bb2bdbf..3b2d5b9 100644
--- a/linux-x64/clang/include/llvm/Support/MD5.h
+++ b/linux-x64/clang/include/llvm/Support/MD5.h
@@ -28,7 +28,6 @@
 #ifndef LLVM_SUPPORT_MD5_H
 #define LLVM_SUPPORT_MD5_H
 
-#include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Endian.h"
 #include <array>
@@ -36,6 +35,7 @@
 
 namespace llvm {
 
+template <unsigned N> class SmallString;
 template <typename T> class ArrayRef;
 
 class MD5 {
diff --git a/linux-x64/clang/include/llvm/Support/MSVCErrorWorkarounds.h b/linux-x64/clang/include/llvm/Support/MSVCErrorWorkarounds.h
index 30e8feb..bf983dc 100644
--- a/linux-x64/clang/include/llvm/Support/MSVCErrorWorkarounds.h
+++ b/linux-x64/clang/include/llvm/Support/MSVCErrorWorkarounds.h
@@ -59,22 +59,19 @@
   template <typename OtherT>
   MSVCPExpected(
       OtherT &&Val,
-      typename std::enable_if<std::is_convertible<OtherT, T>::value>::type * =
-          nullptr)
+      std::enable_if_t<std::is_convertible<OtherT, T>::value> * = nullptr)
       : Expected<T>(std::move(Val)) {}
 
   template <class OtherT>
   MSVCPExpected(
       Expected<OtherT> &&Other,
-      typename std::enable_if<std::is_convertible<OtherT, T>::value>::type * =
-          nullptr)
+      std::enable_if_t<std::is_convertible<OtherT, T>::value> * = nullptr)
       : Expected<T>(std::move(Other)) {}
 
   template <class OtherT>
   explicit MSVCPExpected(
       Expected<OtherT> &&Other,
-      typename std::enable_if<!std::is_convertible<OtherT, T>::value>::type * =
-          nullptr)
+      std::enable_if_t<!std::is_convertible<OtherT, T>::value> * = nullptr)
       : Expected<T>(std::move(Other)) {}
 };
 
diff --git a/linux-x64/clang/include/llvm/Support/MachineValueType.h b/linux-x64/clang/include/llvm/Support/MachineValueType.h
index a9b130f..1c600d0 100644
--- a/linux-x64/clang/include/llvm/Support/MachineValueType.h
+++ b/linux-x64/clang/include/llvm/Support/MachineValueType.h
@@ -17,6 +17,7 @@
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MathExtras.h"
+#include "llvm/Support/TypeSize.h"
 #include <cassert>
 
 namespace llvm {
@@ -46,175 +47,214 @@
       FIRST_INTEGER_VALUETYPE = i1,
       LAST_INTEGER_VALUETYPE  = i128,
 
-      f16            =   8,   // This is a 16 bit floating point value
-      f32            =   9,   // This is a 32 bit floating point value
-      f64            =  10,   // This is a 64 bit floating point value
-      f80            =  11,   // This is a 80 bit floating point value
-      f128           =  12,   // This is a 128 bit floating point value
-      ppcf128        =  13,   // This is a PPC 128-bit floating point value
+      bf16           =   8,   // This is a 16 bit brain floating point value
+      f16            =   9,   // This is a 16 bit floating point value
+      f32            =  10,   // This is a 32 bit floating point value
+      f64            =  11,   // This is a 64 bit floating point value
+      f80            =  12,   // This is a 80 bit floating point value
+      f128           =  13,   // This is a 128 bit floating point value
+      ppcf128        =  14,   // This is a PPC 128-bit floating point value
 
-      FIRST_FP_VALUETYPE = f16,
+      FIRST_FP_VALUETYPE = bf16,
       LAST_FP_VALUETYPE  = ppcf128,
 
-      v1i1           =  14,   //    1 x i1
-      v2i1           =  15,   //    2 x i1
-      v4i1           =  16,   //    4 x i1
-      v8i1           =  17,   //    8 x i1
-      v16i1          =  18,   //   16 x i1
-      v32i1          =  19,   //   32 x i1
-      v64i1          =  20,   //   64 x i1
-      v128i1         =  21,   //  128 x i1
-      v512i1         =  22,   //  512 x i1
-      v1024i1        =  23,   // 1024 x i1
+      v1i1           =  15,   //    1 x i1
+      v2i1           =  16,   //    2 x i1
+      v4i1           =  17,   //    4 x i1
+      v8i1           =  18,   //    8 x i1
+      v16i1          =  19,   //   16 x i1
+      v32i1          =  20,   //   32 x i1
+      v64i1          =  21,   //   64 x i1
+      v128i1         =  22,   //  128 x i1
+      v256i1         =  23,   //  256 x i1
+      v512i1         =  24,   //  512 x i1
+      v1024i1        =  25,   // 1024 x i1
 
-      v1i8           =  24,   //  1 x i8
-      v2i8           =  25,   //  2 x i8
-      v4i8           =  26,   //  4 x i8
-      v8i8           =  27,   //  8 x i8
-      v16i8          =  28,   // 16 x i8
-      v32i8          =  29,   // 32 x i8
-      v64i8          =  30,   // 64 x i8
-      v128i8         =  31,   //128 x i8
-      v256i8         =  32,   //256 x i8
+      v1i8           =  26,   //  1 x i8
+      v2i8           =  27,   //  2 x i8
+      v4i8           =  28,   //  4 x i8
+      v8i8           =  29,   //  8 x i8
+      v16i8          =  30,   // 16 x i8
+      v32i8          =  31,   // 32 x i8
+      v64i8          =  32,   // 64 x i8
+      v128i8         =  33,   //128 x i8
+      v256i8         =  34,   //256 x i8
 
-      v1i16          =  33,   //  1 x i16
-      v2i16          =  34,   //  2 x i16
-      v4i16          =  35,   //  4 x i16
-      v8i16          =  36,   //  8 x i16
-      v16i16         =  37,   // 16 x i16
-      v32i16         =  38,   // 32 x i16
-      v64i16         =  39,   // 64 x i16
-      v128i16        =  40,   //128 x i16
+      v1i16          =  35,   //  1 x i16
+      v2i16          =  36,   //  2 x i16
+      v3i16          =  37,   //  3 x i16
+      v4i16          =  38,   //  4 x i16
+      v8i16          =  39,   //  8 x i16
+      v16i16         =  40,   // 16 x i16
+      v32i16         =  41,   // 32 x i16
+      v64i16         =  42,   // 64 x i16
+      v128i16        =  43,   //128 x i16
 
-      v1i32          =  41,   //    1 x i32
-      v2i32          =  42,   //    2 x i32
-      v3i32          =  43,   //    3 x i32
-      v4i32          =  44,   //    4 x i32
-      v5i32          =  45,   //    5 x i32
-      v8i32          =  46,   //    8 x i32
-      v16i32         =  47,   //   16 x i32
-      v32i32         =  48,   //   32 x i32
-      v64i32         =  49,   //   64 x i32
-      v128i32        =  50,   //  128 x i32
-      v256i32        =  51,   //  256 x i32
-      v512i32        =  52,   //  512 x i32
-      v1024i32       =  53,   // 1024 x i32
-      v2048i32       =  54,   // 2048 x i32
+      v1i32          =  44,   //    1 x i32
+      v2i32          =  45,   //    2 x i32
+      v3i32          =  46,   //    3 x i32
+      v4i32          =  47,   //    4 x i32
+      v5i32          =  48,   //    5 x i32
+      v8i32          =  49,   //    8 x i32
+      v16i32         =  50,   //   16 x i32
+      v32i32         =  51,   //   32 x i32
+      v64i32         =  52,   //   64 x i32
+      v128i32        =  53,   //  128 x i32
+      v256i32        =  54,   //  256 x i32
+      v512i32        =  55,   //  512 x i32
+      v1024i32       =  56,   // 1024 x i32
+      v2048i32       =  57,   // 2048 x i32
 
-      v1i64          =  55,   //  1 x i64
-      v2i64          =  56,   //  2 x i64
-      v4i64          =  57,   //  4 x i64
-      v8i64          =  58,   //  8 x i64
-      v16i64         =  59,   // 16 x i64
-      v32i64         =  60,   // 32 x i64
+      v1i64          =  58,   //  1 x i64
+      v2i64          =  59,   //  2 x i64
+      v4i64          =  60,   //  4 x i64
+      v8i64          =  61,   //  8 x i64
+      v16i64         =  62,   // 16 x i64
+      v32i64         =  63,   // 32 x i64
+      v64i64         =  64,   // 64 x i64
+      v128i64        =  65,   // 128 x i64
+      v256i64        =  66,   // 256 x i64
 
-      v1i128         =  61,   //  1 x i128
+      v1i128         =  67,   //  1 x i128
 
-      // Scalable integer types
-      nxv1i1         =  62,   // n x  1 x i1
-      nxv2i1         =  63,   // n x  2 x i1
-      nxv4i1         =  64,   // n x  4 x i1
-      nxv8i1         =  65,   // n x  8 x i1
-      nxv16i1        =  66,   // n x 16 x i1
-      nxv32i1        =  67,   // n x 32 x i1
+      FIRST_INTEGER_FIXEDLEN_VECTOR_VALUETYPE = v1i1,
+      LAST_INTEGER_FIXEDLEN_VECTOR_VALUETYPE = v1i128,
 
-      nxv1i8         =  68,   // n x  1 x i8
-      nxv2i8         =  69,   // n x  2 x i8
-      nxv4i8         =  70,   // n x  4 x i8
-      nxv8i8         =  71,   // n x  8 x i8
-      nxv16i8        =  72,   // n x 16 x i8
-      nxv32i8        =  73,   // n x 32 x i8
+      v2f16          =  68,   //    2 x f16
+      v3f16          =  69,   //    3 x f16
+      v4f16          =  70,   //    4 x f16
+      v8f16          =  71,   //    8 x f16
+      v16f16         =  72,   //   16 x f16
+      v32f16         =  73,   //   32 x f16
+      v64f16         =  74,   //   64 x f16
+      v128f16        =  75,   //  128 x f16
+      v2bf16         =  76,   //    2 x bf16
+      v3bf16         =  77,   //    3 x bf16
+      v4bf16         =  78,   //    4 x bf16
+      v8bf16         =  79,   //    8 x bf16
+      v16bf16        =  80,   //   16 x bf16
+      v32bf16        =  81,   //   32 x bf16
+      v64bf16        =  82,   //   64 x bf16
+      v128bf16       =  83,   //  128 x bf16
+      v1f32          =  84,   //    1 x f32
+      v2f32          =  85,   //    2 x f32
+      v3f32          =  86,   //    3 x f32
+      v4f32          =  87,   //    4 x f32
+      v5f32          =  88,   //    5 x f32
+      v8f32          =  89,   //    8 x f32
+      v16f32         =  90,   //   16 x f32
+      v32f32         =  91,   //   32 x f32
+      v64f32         =  92,   //   64 x f32
+      v128f32        =  93,   //  128 x f32
+      v256f32        =  94,   //  256 x f32
+      v512f32        =  95,   //  512 x f32
+      v1024f32       =  96,   // 1024 x f32
+      v2048f32       =  97,   // 2048 x f32
+      v1f64          =  98,   //    1 x f64
+      v2f64          =  99,   //    2 x f64
+      v4f64          = 100,   //    4 x f64
+      v8f64          = 101,   //    8 x f64
+      v16f64         = 102,   //   16 x f64
+      v32f64         = 103,   //   32 x f64
+      v64f64         = 104,   //   64 x f64
+      v128f64        = 105,   //  128 x f64
+      v256f64        = 106,   //  256 x f64
 
-      nxv1i16        =  74,   // n x  1 x i16
-      nxv2i16        =  75,   // n x  2 x i16
-      nxv4i16        =  76,   // n x  4 x i16
-      nxv8i16        =  77,   // n x  8 x i16
-      nxv16i16       =  78,   // n x 16 x i16
-      nxv32i16       =  79,   // n x 32 x i16
+      FIRST_FP_FIXEDLEN_VECTOR_VALUETYPE = v2f16,
+      LAST_FP_FIXEDLEN_VECTOR_VALUETYPE = v256f64,
 
-      nxv1i32        =  80,   // n x  1 x i32
-      nxv2i32        =  81,   // n x  2 x i32
-      nxv4i32        =  82,   // n x  4 x i32
-      nxv8i32        =  83,   // n x  8 x i32
-      nxv16i32       =  84,   // n x 16 x i32
-      nxv32i32       =  85,   // n x 32 x i32
+      FIRST_FIXEDLEN_VECTOR_VALUETYPE = v1i1,
+      LAST_FIXEDLEN_VECTOR_VALUETYPE = v256f64,
 
-      nxv1i64        =  86,   // n x  1 x i64
-      nxv2i64        =  87,   // n x  2 x i64
-      nxv4i64        =  88,   // n x  4 x i64
-      nxv8i64        =  89,   // n x  8 x i64
-      nxv16i64       =  90,   // n x 16 x i64
-      nxv32i64       =  91,   // n x 32 x i64
+      nxv1i1         = 107,   // n x  1 x i1
+      nxv2i1         = 108,   // n x  2 x i1
+      nxv4i1         = 109,   // n x  4 x i1
+      nxv8i1         = 110,   // n x  8 x i1
+      nxv16i1        = 111,   // n x 16 x i1
+      nxv32i1        = 112,   // n x 32 x i1
+      nxv64i1        = 113,   // n x  64 x i1
 
-      FIRST_INTEGER_VECTOR_VALUETYPE = v1i1,
-      LAST_INTEGER_VECTOR_VALUETYPE = nxv32i64,
+      nxv1i8         = 114,   // n x  1 x i8
+      nxv2i8         = 115,   // n x  2 x i8
+      nxv4i8         = 116,   // n x  4 x i8
+      nxv8i8         = 117,   // n x  8 x i8
+      nxv16i8        = 118,   // n x 16 x i8
+      nxv32i8        = 119,   // n x 32 x i8
+      nxv64i8        = 120,   // n x  64 x i8
 
-      FIRST_INTEGER_SCALABLE_VALUETYPE = nxv1i1,
-      LAST_INTEGER_SCALABLE_VALUETYPE = nxv32i64,
+      nxv1i16        = 121,  // n x  1 x i16
+      nxv2i16        = 122,  // n x  2 x i16
+      nxv4i16        = 123,  // n x  4 x i16
+      nxv8i16        = 124,  // n x  8 x i16
+      nxv16i16       = 125,  // n x 16 x i16
+      nxv32i16       = 126,  // n x 32 x i16
 
-      v2f16          =  92,   //    2 x f16
-      v4f16          =  93,   //    4 x f16
-      v8f16          =  94,   //    8 x f16
-      v1f32          =  95,   //    1 x f32
-      v2f32          =  96,   //    2 x f32
-      v3f32          =  97,   //    3 x f32
-      v4f32          =  98,   //    4 x f32
-      v5f32          =  99,   //    5 x f32
-      v8f32          =  100,  //    8 x f32
-      v16f32         =  101,  //   16 x f32
-      v32f32         =  102,  //   32 x f32
-      v64f32         =  103,  //   64 x f32
-      v128f32        =  104,  //  128 x f32
-      v256f32        =  105,  //  256 x f32
-      v512f32        =  106,  //  512 x f32
-      v1024f32       =  107,  // 1024 x f32
-      v2048f32       =  108,  // 2048 x f32
-      v1f64          =  109,  //    1 x f64
-      v2f64          =  110,  //    2 x f64
-      v4f64          =  111,  //    4 x f64
-      v8f64          =  112,  //    8 x f64
+      nxv1i32        = 127,  // n x  1 x i32
+      nxv2i32        = 128,  // n x  2 x i32
+      nxv4i32        = 129,  // n x  4 x i32
+      nxv8i32        = 130,  // n x  8 x i32
+      nxv16i32       = 131,  // n x 16 x i32
+      nxv32i32       = 132,  // n x 32 x i32
 
-      nxv2f16        =  113,  // n x  2 x f16
-      nxv4f16        =  114,  // n x  4 x f16
-      nxv8f16        =  115,  // n x  8 x f16
-      nxv1f32        =  116,  // n x  1 x f32
-      nxv2f32        =  117,  // n x  2 x f32
-      nxv4f32        =  118,  // n x  4 x f32
-      nxv8f32        =  119,  // n x  8 x f32
-      nxv16f32       =  120,  // n x 16 x f32
-      nxv1f64        =  121,  // n x  1 x f64
-      nxv2f64        =  122,  // n x  2 x f64
-      nxv4f64        =  123,  // n x  4 x f64
-      nxv8f64        =  124,  // n x  8 x f64
+      nxv1i64        = 133,  // n x  1 x i64
+      nxv2i64        = 134,  // n x  2 x i64
+      nxv4i64        = 135,  // n x  4 x i64
+      nxv8i64        = 136,  // n x  8 x i64
+      nxv16i64       = 137,  // n x 16 x i64
+      nxv32i64       = 138,  // n x 32 x i64
 
-      FIRST_FP_VECTOR_VALUETYPE = v2f16,
-      LAST_FP_VECTOR_VALUETYPE = nxv8f64,
+      FIRST_INTEGER_SCALABLE_VECTOR_VALUETYPE = nxv1i1,
+      LAST_INTEGER_SCALABLE_VECTOR_VALUETYPE = nxv32i64,
 
-      FIRST_FP_SCALABLE_VALUETYPE = nxv2f16,
-      LAST_FP_SCALABLE_VALUETYPE = nxv8f64,
+      nxv1f16        = 139,   // n x   1 x f16
+      nxv2f16        = 140,  // n x  2 x f16
+      nxv4f16        = 141,  // n x  4 x f16
+      nxv8f16        = 142,  // n x  8 x f16
+      nxv16f16       = 143,   // n x  16 x f16
+      nxv32f16       = 144,   // n x  32 x f16
+      nxv2bf16       = 145,  // n x  2 x bf16
+      nxv4bf16       = 146,  // n x  4 x bf16
+      nxv8bf16       = 147,  // n x  8 x bf16
+      nxv1f32        = 148,  // n x  1 x f32
+      nxv2f32        = 149,  // n x  2 x f32
+      nxv4f32        = 150,  // n x  4 x f32
+      nxv8f32        = 151,  // n x  8 x f32
+      nxv16f32       = 152,  // n x 16 x f32
+      nxv1f64        = 153,  // n x  1 x f64
+      nxv2f64        = 154,  // n x  2 x f64
+      nxv4f64        = 155,  // n x  4 x f64
+      nxv8f64        = 156,  // n x  8 x f64
+
+      FIRST_FP_SCALABLE_VECTOR_VALUETYPE = nxv1f16,
+      LAST_FP_SCALABLE_VECTOR_VALUETYPE = nxv8f64,
+
+      FIRST_SCALABLE_VECTOR_VALUETYPE = nxv1i1,
+      LAST_SCALABLE_VECTOR_VALUETYPE = nxv8f64,
 
       FIRST_VECTOR_VALUETYPE = v1i1,
       LAST_VECTOR_VALUETYPE  = nxv8f64,
 
-      x86mmx         =  125,   // This is an X86 MMX value
+      x86mmx         = 157,   // This is an X86 MMX value
 
-      Glue           =  126,   // This glues nodes together during pre-RA sched
+      Glue           = 158,   // This glues nodes together during pre-RA sched
 
-      isVoid         =  127,   // This has no value
+      isVoid         = 159,   // This has no value
 
-      Untyped        =  128,   // This value takes a register, but has
-                               // unspecified type.  The register class
-                               // will be determined by the opcode.
+      Untyped        = 160,   // This value takes a register, but has
+                              // unspecified type.  The register class
+                              // will be determined by the opcode.
 
-      ExceptRef      = 129,    // WebAssembly's except_ref type
+      funcref        = 161,   // WebAssembly's funcref type
+      externref      = 162,   // WebAssembly's externref type
+      x86amx         = 163,   // This is an X86 AMX value
 
-      FIRST_VALUETYPE = 1,     // This is always the beginning of the list.
-      LAST_VALUETYPE =  130,   // This always remains at the end of the list.
+      FIRST_VALUETYPE =  1,   // This is always the beginning of the list.
+      LAST_VALUETYPE = 164,   // This always remains at the end of the list.
 
       // This is the current maximum for LAST_VALUETYPE.
       // MVT::MAX_ALLOWED_VALUETYPE is used for asserts and to size bit vectors
       // This value must be a multiple of 32.
-      MAX_ALLOWED_VALUETYPE = 160,
+      MAX_ALLOWED_VALUETYPE = 192,
 
       // A value of type llvm::TokenTy
       token          = 248,
@@ -253,41 +293,6 @@
 
     SimpleValueType SimpleTy = INVALID_SIMPLE_VALUE_TYPE;
 
-    // A class to represent the number of elements in a vector
-    //
-    // For fixed-length vectors, the total number of elements is equal to 'Min'
-    // For scalable vectors, the total number of elements is a multiple of 'Min'
-    class ElementCount {
-    public:
-      unsigned Min;
-      bool Scalable;
-
-      ElementCount(unsigned Min, bool Scalable)
-      : Min(Min), Scalable(Scalable) {}
-
-      ElementCount operator*(unsigned RHS) {
-        return { Min * RHS, Scalable };
-      }
-
-      ElementCount& operator*=(unsigned RHS) {
-        Min *= RHS;
-        return *this;
-      }
-
-      ElementCount operator/(unsigned RHS) {
-        return { Min / RHS, Scalable };
-      }
-
-      ElementCount& operator/=(unsigned RHS) {
-        Min /= RHS;
-        return *this;
-      }
-
-      bool operator==(const ElementCount& RHS) {
-        return Min == RHS.Min && Scalable == RHS.Scalable;
-      }
-    };
-
     constexpr MVT() = default;
     constexpr MVT(SimpleValueType SVT) : SimpleTy(SVT) {}
 
@@ -308,16 +313,20 @@
     bool isFloatingPoint() const {
       return ((SimpleTy >= MVT::FIRST_FP_VALUETYPE &&
                SimpleTy <= MVT::LAST_FP_VALUETYPE) ||
-              (SimpleTy >= MVT::FIRST_FP_VECTOR_VALUETYPE &&
-               SimpleTy <= MVT::LAST_FP_VECTOR_VALUETYPE));
+              (SimpleTy >= MVT::FIRST_FP_FIXEDLEN_VECTOR_VALUETYPE &&
+               SimpleTy <= MVT::LAST_FP_FIXEDLEN_VECTOR_VALUETYPE) ||
+              (SimpleTy >= MVT::FIRST_FP_SCALABLE_VECTOR_VALUETYPE &&
+               SimpleTy <= MVT::LAST_FP_SCALABLE_VECTOR_VALUETYPE));
     }
 
     /// Return true if this is an integer or a vector integer type.
     bool isInteger() const {
       return ((SimpleTy >= MVT::FIRST_INTEGER_VALUETYPE &&
                SimpleTy <= MVT::LAST_INTEGER_VALUETYPE) ||
-              (SimpleTy >= MVT::FIRST_INTEGER_VECTOR_VALUETYPE &&
-               SimpleTy <= MVT::LAST_INTEGER_VECTOR_VALUETYPE));
+              (SimpleTy >= MVT::FIRST_INTEGER_FIXEDLEN_VECTOR_VALUETYPE &&
+               SimpleTy <= MVT::LAST_INTEGER_FIXEDLEN_VECTOR_VALUETYPE) ||
+              (SimpleTy >= MVT::FIRST_INTEGER_SCALABLE_VECTOR_VALUETYPE &&
+               SimpleTy <= MVT::LAST_INTEGER_SCALABLE_VECTOR_VALUETYPE));
     }
 
     /// Return true if this is an integer, not including vectors.
@@ -335,10 +344,13 @@
     /// Return true if this is a vector value type where the
     /// runtime length is machine dependent
     bool isScalableVector() const {
-      return ((SimpleTy >= MVT::FIRST_INTEGER_SCALABLE_VALUETYPE &&
-               SimpleTy <= MVT::LAST_INTEGER_SCALABLE_VALUETYPE) ||
-              (SimpleTy >= MVT::FIRST_FP_SCALABLE_VALUETYPE &&
-               SimpleTy <= MVT::LAST_FP_SCALABLE_VALUETYPE));
+      return (SimpleTy >= MVT::FIRST_SCALABLE_VECTOR_VALUETYPE &&
+              SimpleTy <= MVT::LAST_SCALABLE_VECTOR_VALUETYPE);
+    }
+
+    bool isFixedLengthVector() const {
+      return (SimpleTy >= MVT::FIRST_FIXEDLEN_VECTOR_VALUETYPE &&
+              SimpleTy <= MVT::LAST_FIXEDLEN_VECTOR_VALUETYPE);
     }
 
     /// Return true if this is a 16-bit vector type.
@@ -349,17 +361,19 @@
 
     /// Return true if this is a 32-bit vector type.
     bool is32BitVector() const {
-      return (SimpleTy == MVT::v32i1 || SimpleTy == MVT::v4i8  ||
-              SimpleTy == MVT::v2i16 || SimpleTy == MVT::v1i32 ||
-              SimpleTy == MVT::v2f16 || SimpleTy == MVT::v1f32);
+      return (SimpleTy == MVT::v32i1 || SimpleTy == MVT::v4i8   ||
+              SimpleTy == MVT::v2i16 || SimpleTy == MVT::v1i32  ||
+              SimpleTy == MVT::v2f16 || SimpleTy == MVT::v2bf16 ||
+              SimpleTy == MVT::v1f32);
     }
 
     /// Return true if this is a 64-bit vector type.
     bool is64BitVector() const {
-      return (SimpleTy == MVT::v64i1 || SimpleTy == MVT::v8i8  ||
-              SimpleTy == MVT::v4i16 || SimpleTy == MVT::v2i32 ||
-              SimpleTy == MVT::v1i64 || SimpleTy == MVT::v4f16 ||
-              SimpleTy == MVT::v2f32 || SimpleTy == MVT::v1f64);
+      return (SimpleTy == MVT::v64i1  || SimpleTy == MVT::v8i8  ||
+              SimpleTy == MVT::v4i16  || SimpleTy == MVT::v2i32 ||
+              SimpleTy == MVT::v1i64  || SimpleTy == MVT::v4f16 ||
+              SimpleTy == MVT::v4bf16 ||SimpleTy == MVT::v2f32  ||
+              SimpleTy == MVT::v1f64);
     }
 
     /// Return true if this is a 128-bit vector type.
@@ -367,22 +381,25 @@
       return (SimpleTy == MVT::v128i1 || SimpleTy == MVT::v16i8  ||
               SimpleTy == MVT::v8i16  || SimpleTy == MVT::v4i32  ||
               SimpleTy == MVT::v2i64  || SimpleTy == MVT::v1i128 ||
-              SimpleTy == MVT::v8f16  || SimpleTy == MVT::v4f32  ||
-              SimpleTy == MVT::v2f64);
+              SimpleTy == MVT::v8f16  || SimpleTy == MVT::v8bf16 ||
+              SimpleTy == MVT::v4f32  || SimpleTy == MVT::v2f64);
     }
 
     /// Return true if this is a 256-bit vector type.
     bool is256BitVector() const {
-      return (SimpleTy == MVT::v8f32 || SimpleTy == MVT::v4f64  ||
-              SimpleTy == MVT::v32i8 || SimpleTy == MVT::v16i16 ||
-              SimpleTy == MVT::v8i32 || SimpleTy == MVT::v4i64);
+      return (SimpleTy == MVT::v16f16 || SimpleTy == MVT::v16bf16 ||
+              SimpleTy == MVT::v8f32  || SimpleTy == MVT::v4f64   ||
+              SimpleTy == MVT::v32i8  || SimpleTy == MVT::v16i16  ||
+              SimpleTy == MVT::v8i32  || SimpleTy == MVT::v4i64   ||
+              SimpleTy == MVT::v256i1);
     }
 
     /// Return true if this is a 512-bit vector type.
     bool is512BitVector() const {
-      return (SimpleTy == MVT::v16f32 || SimpleTy == MVT::v8f64  ||
-              SimpleTy == MVT::v512i1 || SimpleTy == MVT::v64i8  ||
-              SimpleTy == MVT::v32i16 || SimpleTy == MVT::v16i32 ||
+      return (SimpleTy == MVT::v32f16 || SimpleTy == MVT::v32bf16 ||
+              SimpleTy == MVT::v16f32 || SimpleTy == MVT::v8f64   ||
+              SimpleTy == MVT::v512i1 || SimpleTy == MVT::v64i8   ||
+              SimpleTy == MVT::v32i16 || SimpleTy == MVT::v16i32  ||
               SimpleTy == MVT::v8i64);
     }
 
@@ -390,20 +407,63 @@
     bool is1024BitVector() const {
       return (SimpleTy == MVT::v1024i1 || SimpleTy == MVT::v128i8 ||
               SimpleTy == MVT::v64i16  || SimpleTy == MVT::v32i32 ||
-              SimpleTy == MVT::v16i64);
+              SimpleTy == MVT::v16i64  || SimpleTy == MVT::v64f16 ||
+              SimpleTy == MVT::v32f32  || SimpleTy == MVT::v16f64 ||
+              SimpleTy == MVT::v64bf16);
     }
 
     /// Return true if this is a 2048-bit vector type.
     bool is2048BitVector() const {
-      return (SimpleTy == MVT::v256i8 || SimpleTy == MVT::v128i16 ||
-              SimpleTy == MVT::v64i32 || SimpleTy == MVT::v32i64);
+      return (SimpleTy == MVT::v256i8  || SimpleTy == MVT::v128i16 ||
+              SimpleTy == MVT::v64i32  || SimpleTy == MVT::v32i64  ||
+              SimpleTy == MVT::v128f16 || SimpleTy == MVT::v64f32  ||
+              SimpleTy == MVT::v32f64  || SimpleTy == MVT::v128bf16);
     }
 
     /// Return true if this is an overloaded type for TableGen.
     bool isOverloaded() const {
-      return (SimpleTy==MVT::Any  ||
-              SimpleTy==MVT::iAny || SimpleTy==MVT::fAny ||
-              SimpleTy==MVT::vAny || SimpleTy==MVT::iPTRAny);
+      return (SimpleTy == MVT::Any || SimpleTy == MVT::iAny ||
+              SimpleTy == MVT::fAny || SimpleTy == MVT::vAny ||
+              SimpleTy == MVT::iPTRAny);
+    }
+
+    /// Return a vector with the same number of elements as this vector, but
+    /// with the element type converted to an integer type with the same
+    /// bitwidth.
+    MVT changeVectorElementTypeToInteger() const {
+      MVT EltTy = getVectorElementType();
+      MVT IntTy = MVT::getIntegerVT(EltTy.getSizeInBits());
+      MVT VecTy = MVT::getVectorVT(IntTy, getVectorElementCount());
+      assert(VecTy.SimpleTy != MVT::INVALID_SIMPLE_VALUE_TYPE &&
+             "Simple vector VT not representable by simple integer vector VT!");
+      return VecTy;
+    }
+
+    /// Return a VT for a vector type whose attributes match ourselves
+    /// with the exception of the element type that is chosen by the caller.
+    MVT changeVectorElementType(MVT EltVT) const {
+      MVT VecTy = MVT::getVectorVT(EltVT, getVectorElementCount());
+      assert(VecTy.SimpleTy != MVT::INVALID_SIMPLE_VALUE_TYPE &&
+             "Simple vector VT not representable by simple integer vector VT!");
+      return VecTy;
+    }
+
+    /// Return the type converted to an equivalently sized integer or vector
+    /// with integer element type. Similar to changeVectorElementTypeToInteger,
+    /// but also handles scalars.
+    MVT changeTypeToInteger() {
+      if (isVector())
+        return changeVectorElementTypeToInteger();
+      return MVT::getIntegerVT(getSizeInBits());
+    }
+
+    /// Return a VT for a vector type with the same element type but
+    /// half the number of elements.
+    MVT getHalfNumVectorElementsVT() const {
+      MVT EltVT = getVectorElementType();
+      auto EltCnt = getVectorElementCount();
+      assert(EltCnt.isKnownEven() && "Splitting vector, but not in half!");
+      return getVectorVT(EltVT, EltCnt.divideCoefficientBy(2));
     }
 
     /// Returns true if the given vector is a power of 2.
@@ -440,6 +500,7 @@
       case v32i1:
       case v64i1:
       case v128i1:
+      case v256i1:
       case v512i1:
       case v1024i1:
       case nxv1i1:
@@ -447,7 +508,8 @@
       case nxv4i1:
       case nxv8i1:
       case nxv16i1:
-      case nxv32i1: return i1;
+      case nxv32i1:
+      case nxv64i1: return i1;
       case v1i8:
       case v2i8:
       case v4i8:
@@ -462,9 +524,11 @@
       case nxv4i8:
       case nxv8i8:
       case nxv16i8:
-      case nxv32i8: return i8;
+      case nxv32i8:
+      case nxv64i8: return i8;
       case v1i16:
       case v2i16:
+      case v3i16:
       case v4i16:
       case v8i16:
       case v16i16:
@@ -503,6 +567,9 @@
       case v8i64:
       case v16i64:
       case v32i64:
+      case v64i64:
+      case v128i64:
+      case v256i64:
       case nxv1i64:
       case nxv2i64:
       case nxv4i64:
@@ -511,11 +578,30 @@
       case nxv32i64: return i64;
       case v1i128: return i128;
       case v2f16:
+      case v3f16:
       case v4f16:
       case v8f16:
+      case v16f16:
+      case v32f16:
+      case v64f16:
+      case v128f16:
+      case nxv1f16:
       case nxv2f16:
       case nxv4f16:
-      case nxv8f16: return f16;
+      case nxv8f16:
+      case nxv16f16:
+      case nxv32f16: return f16;
+      case v2bf16:
+      case v3bf16:
+      case v4bf16:
+      case v8bf16:
+      case v16bf16:
+      case v32bf16:
+      case v64bf16:
+      case v128bf16:
+      case nxv2bf16:
+      case nxv4bf16:
+      case nxv8bf16: return bf16;
       case v1f32:
       case v2f32:
       case v3f32:
@@ -539,6 +625,11 @@
       case v2f64:
       case v4f64:
       case v8f64:
+      case v16f64:
+      case v32f64:
+      case v64f64:
+      case v128f64:
+      case v256f64:
       case nxv1f64:
       case nxv2f64:
       case nxv4f64:
@@ -558,41 +649,62 @@
       case v512i1:
       case v512i32:
       case v512f32: return 512;
+      case v256i1:
       case v256i8:
       case v256i32:
-      case v256f32: return 256;
+      case v256i64:
+      case v256f32:
+      case v256f64: return 256;
       case v128i1:
       case v128i8:
       case v128i16:
       case v128i32:
-      case v128f32: return 128;
+      case v128i64:
+      case v128f16:
+      case v128bf16:
+      case v128f32:
+      case v128f64: return 128;
       case v64i1:
       case v64i8:
       case v64i16:
       case v64i32:
-      case v64f32: return 64;
+      case v64i64:
+      case v64f16:
+      case v64bf16:
+      case v64f32:
+      case v64f64:
+      case nxv64i1:
+      case nxv64i8: return 64;
       case v32i1:
       case v32i8:
       case v32i16:
       case v32i32:
       case v32i64:
+      case v32f16:
+      case v32bf16:
       case v32f32:
+      case v32f64:
       case nxv32i1:
       case nxv32i8:
       case nxv32i16:
       case nxv32i32:
-      case nxv32i64: return 32;
+      case nxv32i64:
+      case nxv32f16: return 32;
       case v16i1:
       case v16i8:
       case v16i16:
       case v16i32:
       case v16i64:
+      case v16f16:
+      case v16bf16:
       case v16f32:
+      case v16f64:
       case nxv16i1:
       case nxv16i8:
       case nxv16i16:
       case nxv16i32:
       case nxv16i64:
+      case nxv16f16:
       case nxv16f32: return 16;
       case v8i1:
       case v8i8:
@@ -600,6 +712,7 @@
       case v8i32:
       case v8i64:
       case v8f16:
+      case v8bf16:
       case v8f32:
       case v8f64:
       case nxv8i1:
@@ -608,6 +721,7 @@
       case nxv8i32:
       case nxv8i64:
       case nxv8f16:
+      case nxv8bf16:
       case nxv8f32:
       case nxv8f64: return 8;
       case v5i32:
@@ -618,6 +732,7 @@
       case v4i32:
       case v4i64:
       case v4f16:
+      case v4bf16:
       case v4f32:
       case v4f64:
       case nxv4i1:
@@ -626,9 +741,13 @@
       case nxv4i32:
       case nxv4i64:
       case nxv4f16:
+      case nxv4bf16:
       case nxv4f32:
       case nxv4f64: return 4;
+      case v3i16:
       case v3i32:
+      case v3f16:
+      case v3bf16:
       case v3f32: return 3;
       case v2i1:
       case v2i8:
@@ -636,6 +755,7 @@
       case v2i32:
       case v2i64:
       case v2f16:
+      case v2bf16:
       case v2f32:
       case v2f64:
       case nxv2i1:
@@ -644,6 +764,7 @@
       case nxv2i32:
       case nxv2i64:
       case nxv2f16:
+      case nxv2bf16:
       case nxv2f32:
       case nxv2f64: return 2;
       case v1i1:
@@ -659,16 +780,27 @@
       case nxv1i16:
       case nxv1i32:
       case nxv1i64:
+      case nxv1f16:
       case nxv1f32:
       case nxv1f64: return 1;
       }
     }
 
-    MVT::ElementCount getVectorElementCount() const {
-      return { getVectorNumElements(), isScalableVector() };
+    ElementCount getVectorElementCount() const {
+      return ElementCount::get(getVectorNumElements(), isScalableVector());
     }
 
-    unsigned getSizeInBits() const {
+    /// Given a vector type, return the minimum number of elements it contains.
+    unsigned getVectorMinNumElements() const {
+      return getVectorElementCount().getKnownMinValue();
+    }
+
+    /// Returns the size of the specified MVT in bits.
+    ///
+    /// If the value type is a scalable vector type, the scalable property will
+    /// be set and the runtime size will be a positive integer multiple of the
+    /// base size.
+    TypeSize getSizeInBits() const {
       switch (SimpleTy) {
       default:
         llvm_unreachable("getSizeInBits called on extended MVT.");
@@ -688,39 +820,46 @@
       case Metadata:
         llvm_unreachable("Value type is metadata.");
       case i1:
-      case v1i1:
-      case nxv1i1: return 1;
-      case v2i1:
-      case nxv2i1: return 2;
-      case v4i1:
-      case nxv4i1: return 4;
+      case v1i1: return TypeSize::Fixed(1);
+      case nxv1i1: return TypeSize::Scalable(1);
+      case v2i1: return TypeSize::Fixed(2);
+      case nxv2i1: return TypeSize::Scalable(2);
+      case v4i1: return TypeSize::Fixed(4);
+      case nxv4i1: return TypeSize::Scalable(4);
       case i8  :
       case v1i8:
-      case v8i1:
+      case v8i1: return TypeSize::Fixed(8);
       case nxv1i8:
-      case nxv8i1: return 8;
+      case nxv8i1: return TypeSize::Scalable(8);
       case i16 :
       case f16:
+      case bf16:
       case v16i1:
       case v2i8:
-      case v1i16:
+      case v1i16: return TypeSize::Fixed(16);
       case nxv16i1:
       case nxv2i8:
-      case nxv1i16: return 16;
+      case nxv1i16:
+      case nxv1f16: return TypeSize::Scalable(16);
       case f32 :
       case i32 :
       case v32i1:
       case v4i8:
       case v2i16:
       case v2f16:
+      case v2bf16:
       case v1f32:
-      case v1i32:
+      case v1i32: return TypeSize::Fixed(32);
       case nxv32i1:
       case nxv4i8:
       case nxv2i16:
       case nxv1i32:
       case nxv2f16:
-      case nxv1f32: return 32;
+      case nxv2bf16:
+      case nxv1f32: return TypeSize::Scalable(32);
+      case v3i16:
+      case v3f16:
+      case v3bf16: return TypeSize::Fixed(48);
       case x86mmx:
       case f64 :
       case i64 :
@@ -730,18 +869,21 @@
       case v2i32:
       case v1i64:
       case v4f16:
+      case v4bf16:
       case v2f32:
-      case v1f64:
+      case v1f64: return TypeSize::Fixed(64);
+      case nxv64i1:
       case nxv8i8:
       case nxv4i16:
       case nxv2i32:
       case nxv1i64:
       case nxv4f16:
+      case nxv4bf16:
       case nxv2f32:
-      case nxv1f64: return 64;
-      case f80 :  return 80;
+      case nxv1f64: return TypeSize::Scalable(64);
+      case f80 :  return TypeSize::Fixed(80);
       case v3i32:
-      case v3f32: return 96;
+      case v3f32: return TypeSize::Fixed(96);
       case f128:
       case ppcf128:
       case i128:
@@ -752,103 +894,176 @@
       case v2i64:
       case v1i128:
       case v8f16:
+      case v8bf16:
       case v4f32:
-      case v2f64:
+      case v2f64: return TypeSize::Fixed(128);
       case nxv16i8:
       case nxv8i16:
       case nxv4i32:
       case nxv2i64:
       case nxv8f16:
+      case nxv8bf16:
       case nxv4f32:
-      case nxv2f64: return 128;
+      case nxv2f64: return TypeSize::Scalable(128);
       case v5i32:
-      case v5f32: return 160;
+      case v5f32: return TypeSize::Fixed(160);
+      case v256i1:
       case v32i8:
       case v16i16:
       case v8i32:
       case v4i64:
+      case v16f16:
+      case v16bf16:
       case v8f32:
-      case v4f64:
+      case v4f64: return TypeSize::Fixed(256);
       case nxv32i8:
       case nxv16i16:
       case nxv8i32:
       case nxv4i64:
+      case nxv16f16:
       case nxv8f32:
-      case nxv4f64: return 256;
+      case nxv4f64: return TypeSize::Scalable(256);
       case v512i1:
       case v64i8:
       case v32i16:
       case v16i32:
       case v8i64:
+      case v32f16:
+      case v32bf16:
       case v16f32:
-      case v8f64:
+      case v8f64: return TypeSize::Fixed(512);
+      case nxv64i8:
       case nxv32i16:
       case nxv16i32:
       case nxv8i64:
+      case nxv32f16:
       case nxv16f32:
-      case nxv8f64: return 512;
+      case nxv8f64: return TypeSize::Scalable(512);
       case v1024i1:
       case v128i8:
       case v64i16:
       case v32i32:
       case v16i64:
+      case v64f16:
+      case v64bf16:
       case v32f32:
+      case v16f64: return TypeSize::Fixed(1024);
       case nxv32i32:
-      case nxv16i64: return 1024;
+      case nxv16i64: return TypeSize::Scalable(1024);
       case v256i8:
       case v128i16:
       case v64i32:
       case v32i64:
+      case v128f16:
+      case v128bf16:
       case v64f32:
-      case nxv32i64: return 2048;
+      case v32f64: return TypeSize::Fixed(2048);
+      case nxv32i64: return TypeSize::Scalable(2048);
       case v128i32:
-      case v128f32:  return 4096;
+      case v64i64:
+      case v128f32:
+      case v64f64:  return TypeSize::Fixed(4096);
       case v256i32:
-      case v256f32:  return 8192;
+      case v128i64:
+      case v256f32:
+      case x86amx:
+      case v128f64:  return TypeSize::Fixed(8192);
       case v512i32:
-      case v512f32:  return 16384;
+      case v256i64:
+      case v512f32:
+      case v256f64:  return TypeSize::Fixed(16384);
       case v1024i32:
-      case v1024f32:  return 32768;
+      case v1024f32:  return TypeSize::Fixed(32768);
       case v2048i32:
-      case v2048f32:  return 65536;
-      case ExceptRef: return 0; // opaque type
+      case v2048f32:  return TypeSize::Fixed(65536);
+      case funcref:
+      case externref: return TypeSize::Fixed(0); // opaque type
       }
     }
 
-    unsigned getScalarSizeInBits() const {
-      return getScalarType().getSizeInBits();
+    /// Return the size of the specified fixed width value type in bits. The
+    /// function will assert if the type is scalable.
+    uint64_t getFixedSizeInBits() const {
+      return getSizeInBits().getFixedSize();
+    }
+
+    uint64_t getScalarSizeInBits() const {
+      return getScalarType().getSizeInBits().getFixedSize();
     }
 
     /// Return the number of bytes overwritten by a store of the specified value
     /// type.
-    unsigned getStoreSize() const {
-      return (getSizeInBits() + 7) / 8;
+    ///
+    /// If the value type is a scalable vector type, the scalable property will
+    /// be set and the runtime size will be a positive integer multiple of the
+    /// base size.
+    TypeSize getStoreSize() const {
+      TypeSize BaseSize = getSizeInBits();
+      return {(BaseSize.getKnownMinSize() + 7) / 8, BaseSize.isScalable()};
     }
 
     /// Return the number of bits overwritten by a store of the specified value
     /// type.
-    unsigned getStoreSizeInBits() const {
+    ///
+    /// If the value type is a scalable vector type, the scalable property will
+    /// be set and the runtime size will be a positive integer multiple of the
+    /// base size.
+    TypeSize getStoreSizeInBits() const {
       return getStoreSize() * 8;
     }
 
+    /// Returns true if the number of bits for the type is a multiple of an
+    /// 8-bit byte.
+    bool isByteSized() const { return getSizeInBits().isKnownMultipleOf(8); }
+
+    /// Return true if we know at compile time this has more bits than VT.
+    bool knownBitsGT(MVT VT) const {
+      return TypeSize::isKnownGT(getSizeInBits(), VT.getSizeInBits());
+    }
+
+    /// Return true if we know at compile time this has more than or the same
+    /// bits as VT.
+    bool knownBitsGE(MVT VT) const {
+      return TypeSize::isKnownGE(getSizeInBits(), VT.getSizeInBits());
+    }
+
+    /// Return true if we know at compile time this has fewer bits than VT.
+    bool knownBitsLT(MVT VT) const {
+      return TypeSize::isKnownLT(getSizeInBits(), VT.getSizeInBits());
+    }
+
+    /// Return true if we know at compile time this has fewer than or the same
+    /// bits as VT.
+    bool knownBitsLE(MVT VT) const {
+      return TypeSize::isKnownLE(getSizeInBits(), VT.getSizeInBits());
+    }
+
     /// Return true if this has more bits than VT.
     bool bitsGT(MVT VT) const {
-      return getSizeInBits() > VT.getSizeInBits();
+      assert(isScalableVector() == VT.isScalableVector() &&
+             "Comparison between scalable and fixed types");
+      return knownBitsGT(VT);
     }
 
     /// Return true if this has no less bits than VT.
     bool bitsGE(MVT VT) const {
-      return getSizeInBits() >= VT.getSizeInBits();
+      assert(isScalableVector() == VT.isScalableVector() &&
+             "Comparison between scalable and fixed types");
+      return knownBitsGE(VT);
     }
 
     /// Return true if this has less bits than VT.
     bool bitsLT(MVT VT) const {
-      return getSizeInBits() < VT.getSizeInBits();
+      assert(isScalableVector() == VT.isScalableVector() &&
+             "Comparison between scalable and fixed types");
+      return knownBitsLT(VT);
     }
 
     /// Return true if this has no more bits than VT.
     bool bitsLE(MVT VT) const {
-      return getSizeInBits() <= VT.getSizeInBits();
+      assert(isScalableVector() == VT.isScalableVector() &&
+             "Comparison between scalable and fixed types");
+      return knownBitsLE(VT);
     }
 
     static MVT getFloatingPointVT(unsigned BitWidth) {
@@ -900,6 +1115,7 @@
         if (NumElements == 32)   return MVT::v32i1;
         if (NumElements == 64)   return MVT::v64i1;
         if (NumElements == 128)  return MVT::v128i1;
+        if (NumElements == 256)  return MVT::v256i1;
         if (NumElements == 512)  return MVT::v512i1;
         if (NumElements == 1024) return MVT::v1024i1;
         break;
@@ -917,6 +1133,7 @@
       case MVT::i16:
         if (NumElements == 1)   return MVT::v1i16;
         if (NumElements == 2)   return MVT::v2i16;
+        if (NumElements == 3)   return MVT::v3i16;
         if (NumElements == 4)   return MVT::v4i16;
         if (NumElements == 8)   return MVT::v8i16;
         if (NumElements == 16)  return MVT::v16i16;
@@ -947,14 +1164,32 @@
         if (NumElements == 8)  return MVT::v8i64;
         if (NumElements == 16) return MVT::v16i64;
         if (NumElements == 32) return MVT::v32i64;
+        if (NumElements == 64) return MVT::v64i64;
+        if (NumElements == 128) return MVT::v128i64;
+        if (NumElements == 256) return MVT::v256i64;
         break;
       case MVT::i128:
         if (NumElements == 1)  return MVT::v1i128;
         break;
       case MVT::f16:
-        if (NumElements == 2)  return MVT::v2f16;
-        if (NumElements == 4)  return MVT::v4f16;
-        if (NumElements == 8)  return MVT::v8f16;
+        if (NumElements == 2)   return MVT::v2f16;
+        if (NumElements == 3)   return MVT::v3f16;
+        if (NumElements == 4)   return MVT::v4f16;
+        if (NumElements == 8)   return MVT::v8f16;
+        if (NumElements == 16)  return MVT::v16f16;
+        if (NumElements == 32)  return MVT::v32f16;
+        if (NumElements == 64)  return MVT::v64f16;
+        if (NumElements == 128) return MVT::v128f16;
+        break;
+      case MVT::bf16:
+        if (NumElements == 2)   return MVT::v2bf16;
+        if (NumElements == 3)   return MVT::v3bf16;
+        if (NumElements == 4)   return MVT::v4bf16;
+        if (NumElements == 8)   return MVT::v8bf16;
+        if (NumElements == 16)  return MVT::v16bf16;
+        if (NumElements == 32)  return MVT::v32bf16;
+        if (NumElements == 64)  return MVT::v64bf16;
+        if (NumElements == 128) return MVT::v128bf16;
         break;
       case MVT::f32:
         if (NumElements == 1)    return MVT::v1f32;
@@ -977,6 +1212,11 @@
         if (NumElements == 2)  return MVT::v2f64;
         if (NumElements == 4)  return MVT::v4f64;
         if (NumElements == 8)  return MVT::v8f64;
+        if (NumElements == 16) return MVT::v16f64;
+        if (NumElements == 32) return MVT::v32f64;
+        if (NumElements == 64) return MVT::v64f64;
+        if (NumElements == 128) return MVT::v128f64;
+        if (NumElements == 256) return MVT::v256f64;
         break;
       }
       return (MVT::SimpleValueType)(MVT::INVALID_SIMPLE_VALUE_TYPE);
@@ -993,6 +1233,7 @@
           if (NumElements == 8)  return MVT::nxv8i1;
           if (NumElements == 16) return MVT::nxv16i1;
           if (NumElements == 32) return MVT::nxv32i1;
+          if (NumElements == 64) return MVT::nxv64i1;
           break;
         case MVT::i8:
           if (NumElements == 1)  return MVT::nxv1i8;
@@ -1001,6 +1242,7 @@
           if (NumElements == 8)  return MVT::nxv8i8;
           if (NumElements == 16) return MVT::nxv16i8;
           if (NumElements == 32) return MVT::nxv32i8;
+          if (NumElements == 64) return MVT::nxv64i8;
           break;
         case MVT::i16:
           if (NumElements == 1)  return MVT::nxv1i16;
@@ -1027,9 +1269,17 @@
           if (NumElements == 32) return MVT::nxv32i64;
           break;
         case MVT::f16:
+          if (NumElements == 1)  return MVT::nxv1f16;
           if (NumElements == 2)  return MVT::nxv2f16;
           if (NumElements == 4)  return MVT::nxv4f16;
           if (NumElements == 8)  return MVT::nxv8f16;
+          if (NumElements == 16)  return MVT::nxv16f16;
+          if (NumElements == 32)  return MVT::nxv32f16;
+          break;
+        case MVT::bf16:
+          if (NumElements == 2)  return MVT::nxv2bf16;
+          if (NumElements == 4)  return MVT::nxv4bf16;
+          if (NumElements == 8)  return MVT::nxv8bf16;
           break;
         case MVT::f32:
           if (NumElements == 1)  return MVT::nxv1f32;
@@ -1054,10 +1304,10 @@
       return getVectorVT(VT, NumElements);
     }
 
-    static MVT getVectorVT(MVT VT, MVT::ElementCount EC) {
-      if (EC.Scalable)
-        return getScalableVectorVT(VT, EC.Min);
-      return getVectorVT(VT, EC.Min);
+    static MVT getVectorVT(MVT VT, ElementCount EC) {
+      if (EC.isScalable())
+        return getScalableVectorVT(VT, EC.getKnownMinValue());
+      return getVectorVT(VT, EC.getKnownMinValue());
     }
 
     /// Return the value type corresponding to the specified type.  This returns
@@ -1108,26 +1358,40 @@
                        (MVT::SimpleValueType)(MVT::LAST_VECTOR_VALUETYPE + 1));
     }
 
-    static mvt_range integer_vector_valuetypes() {
+    static mvt_range fixedlen_vector_valuetypes() {
       return mvt_range(
-          MVT::FIRST_INTEGER_VECTOR_VALUETYPE,
-          (MVT::SimpleValueType)(MVT::LAST_INTEGER_VECTOR_VALUETYPE + 1));
+               MVT::FIRST_FIXEDLEN_VECTOR_VALUETYPE,
+               (MVT::SimpleValueType)(MVT::LAST_FIXEDLEN_VECTOR_VALUETYPE + 1));
     }
 
-    static mvt_range fp_vector_valuetypes() {
+    static mvt_range scalable_vector_valuetypes() {
       return mvt_range(
-          MVT::FIRST_FP_VECTOR_VALUETYPE,
-          (MVT::SimpleValueType)(MVT::LAST_FP_VECTOR_VALUETYPE + 1));
+               MVT::FIRST_SCALABLE_VECTOR_VALUETYPE,
+               (MVT::SimpleValueType)(MVT::LAST_SCALABLE_VECTOR_VALUETYPE + 1));
+    }
+
+    static mvt_range integer_fixedlen_vector_valuetypes() {
+      return mvt_range(
+       MVT::FIRST_INTEGER_FIXEDLEN_VECTOR_VALUETYPE,
+       (MVT::SimpleValueType)(MVT::LAST_INTEGER_FIXEDLEN_VECTOR_VALUETYPE + 1));
+    }
+
+    static mvt_range fp_fixedlen_vector_valuetypes() {
+      return mvt_range(
+          MVT::FIRST_FP_FIXEDLEN_VECTOR_VALUETYPE,
+          (MVT::SimpleValueType)(MVT::LAST_FP_FIXEDLEN_VECTOR_VALUETYPE + 1));
     }
 
     static mvt_range integer_scalable_vector_valuetypes() {
-      return mvt_range(MVT::FIRST_INTEGER_SCALABLE_VALUETYPE,
-              (MVT::SimpleValueType)(MVT::LAST_INTEGER_SCALABLE_VALUETYPE + 1));
+      return mvt_range(
+       MVT::FIRST_INTEGER_SCALABLE_VECTOR_VALUETYPE,
+       (MVT::SimpleValueType)(MVT::LAST_INTEGER_SCALABLE_VECTOR_VALUETYPE + 1));
     }
 
     static mvt_range fp_scalable_vector_valuetypes() {
-      return mvt_range(MVT::FIRST_FP_SCALABLE_VALUETYPE,
-                   (MVT::SimpleValueType)(MVT::LAST_FP_SCALABLE_VALUETYPE + 1));
+      return mvt_range(
+            MVT::FIRST_FP_SCALABLE_VECTOR_VALUETYPE,
+            (MVT::SimpleValueType)(MVT::LAST_FP_SCALABLE_VECTOR_VALUETYPE + 1));
     }
     /// @}
   };
diff --git a/linux-x64/clang/include/llvm/Support/ManagedStatic.h b/linux-x64/clang/include/llvm/Support/ManagedStatic.h
index e65bb05..f2b4142 100644
--- a/linux-x64/clang/include/llvm/Support/ManagedStatic.h
+++ b/linux-x64/clang/include/llvm/Support/ManagedStatic.h
@@ -40,8 +40,8 @@
 // constexpr, a dynamic initializer may be emitted depending on optimization
 // settings. For the affected versions of MSVC, use the old linker
 // initialization pattern of not providing a constructor and leaving the fields
-// uninitialized.
-#if !defined(_MSC_VER) || defined(__clang__)
+// uninitialized. See http://llvm.org/PR41367 for details.
+#if !defined(_MSC_VER) || (_MSC_VER >= 1925) || defined(__clang__)
 #define LLVM_USE_CONSTEXPR_CTOR
 #endif
 
@@ -102,6 +102,12 @@
   }
 
   const C *operator->() const { return &**this; }
+
+  // Extract the instance, leaving the ManagedStatic uninitialized. The
+  // user is then responsible for the lifetime of the returned instance.
+  C *claim() {
+    return static_cast<C *>(Ptr.exchange(nullptr));
+  }
 };
 
 /// llvm_shutdown - Deallocate and destroy all ManagedStatic variables.
diff --git a/linux-x64/clang/include/llvm/Support/MathExtras.h b/linux-x64/clang/include/llvm/Support/MathExtras.h
index 85d5a5a..33b9065 100644
--- a/linux-x64/clang/include/llvm/Support/MathExtras.h
+++ b/linux-x64/clang/include/llvm/Support/MathExtras.h
@@ -14,10 +14,11 @@
 #define LLVM_SUPPORT_MATHEXTRAS_H
 
 #include "llvm/Support/Compiler.h"
-#include "llvm/Support/SwapByteOrder.h"
 #include <algorithm>
 #include <cassert>
 #include <climits>
+#include <cmath>
+#include <cstdint>
 #include <cstring>
 #include <limits>
 #include <type_traits>
@@ -39,6 +40,7 @@
 #endif
 
 namespace llvm {
+
 /// The behavior an operation has on an input of 0.
 enum ZeroBehavior {
   /// The returned value is undefined.
@@ -49,6 +51,42 @@
   ZB_Width
 };
 
+/// Mathematical constants.
+namespace numbers {
+// TODO: Track C++20 std::numbers.
+// TODO: Favor using the hexadecimal FP constants (requires C++17).
+constexpr double e          = 2.7182818284590452354, // (0x1.5bf0a8b145749P+1) https://oeis.org/A001113
+                 egamma     = .57721566490153286061, // (0x1.2788cfc6fb619P-1) https://oeis.org/A001620
+                 ln2        = .69314718055994530942, // (0x1.62e42fefa39efP-1) https://oeis.org/A002162
+                 ln10       = 2.3025850929940456840, // (0x1.24bb1bbb55516P+1) https://oeis.org/A002392
+                 log2e      = 1.4426950408889634074, // (0x1.71547652b82feP+0)
+                 log10e     = .43429448190325182765, // (0x1.bcb7b1526e50eP-2)
+                 pi         = 3.1415926535897932385, // (0x1.921fb54442d18P+1) https://oeis.org/A000796
+                 inv_pi     = .31830988618379067154, // (0x1.45f306bc9c883P-2) https://oeis.org/A049541
+                 sqrtpi     = 1.7724538509055160273, // (0x1.c5bf891b4ef6bP+0) https://oeis.org/A002161
+                 inv_sqrtpi = .56418958354775628695, // (0x1.20dd750429b6dP-1) https://oeis.org/A087197
+                 sqrt2      = 1.4142135623730950488, // (0x1.6a09e667f3bcdP+0) https://oeis.org/A00219
+                 inv_sqrt2  = .70710678118654752440, // (0x1.6a09e667f3bcdP-1)
+                 sqrt3      = 1.7320508075688772935, // (0x1.bb67ae8584caaP+0) https://oeis.org/A002194
+                 inv_sqrt3  = .57735026918962576451, // (0x1.279a74590331cP-1)
+                 phi        = 1.6180339887498948482; // (0x1.9e3779b97f4a8P+0) https://oeis.org/A001622
+constexpr float ef          = 2.71828183F, // (0x1.5bf0a8P+1) https://oeis.org/A001113
+                egammaf     = .577215665F, // (0x1.2788d0P-1) https://oeis.org/A001620
+                ln2f        = .693147181F, // (0x1.62e430P-1) https://oeis.org/A002162
+                ln10f       = 2.30258509F, // (0x1.26bb1cP+1) https://oeis.org/A002392
+                log2ef      = 1.44269504F, // (0x1.715476P+0)
+                log10ef     = .434294482F, // (0x1.bcb7b2P-2)
+                pif         = 3.14159265F, // (0x1.921fb6P+1) https://oeis.org/A000796
+                inv_pif     = .318309886F, // (0x1.45f306P-2) https://oeis.org/A049541
+                sqrtpif     = 1.77245385F, // (0x1.c5bf8aP+0) https://oeis.org/A002161
+                inv_sqrtpif = .564189584F, // (0x1.20dd76P-1) https://oeis.org/A087197
+                sqrt2f      = 1.41421356F, // (0x1.6a09e6P+0) https://oeis.org/A002193
+                inv_sqrt2f  = .707106781F, // (0x1.6a09e6P-1)
+                sqrt3f      = 1.73205081F, // (0x1.bb67aeP+0) https://oeis.org/A002194
+                inv_sqrt3f  = .577350269F, // (0x1.279a74P-1)
+                phif        = 1.61803399F; // (0x1.9e377aP+0) https://oeis.org/A001622
+} // namespace numbers
+
 namespace detail {
 template <typename T, std::size_t SizeOfT> struct TrailingZerosCounter {
   static unsigned count(T Val, ZeroBehavior) {
@@ -73,13 +111,13 @@
   }
 };
 
-#if __GNUC__ >= 4 || defined(_MSC_VER)
+#if defined(__GNUC__) || defined(_MSC_VER)
 template <typename T> struct TrailingZerosCounter<T, 4> {
   static unsigned count(T Val, ZeroBehavior ZB) {
     if (ZB != ZB_Undefined && Val == 0)
       return 32;
 
-#if __has_builtin(__builtin_ctz) || LLVM_GNUC_PREREQ(4, 0, 0)
+#if __has_builtin(__builtin_ctz) || defined(__GNUC__)
     return __builtin_ctz(Val);
 #elif defined(_MSC_VER)
     unsigned long Index;
@@ -95,7 +133,7 @@
     if (ZB != ZB_Undefined && Val == 0)
       return 64;
 
-#if __has_builtin(__builtin_ctzll) || LLVM_GNUC_PREREQ(4, 0, 0)
+#if __has_builtin(__builtin_ctzll) || defined(__GNUC__)
     return __builtin_ctzll(Val);
 #elif defined(_MSC_VER)
     unsigned long Index;
@@ -142,13 +180,13 @@
   }
 };
 
-#if __GNUC__ >= 4 || defined(_MSC_VER)
+#if defined(__GNUC__) || defined(_MSC_VER)
 template <typename T> struct LeadingZerosCounter<T, 4> {
   static unsigned count(T Val, ZeroBehavior ZB) {
     if (ZB != ZB_Undefined && Val == 0)
       return 32;
 
-#if __has_builtin(__builtin_clz) || LLVM_GNUC_PREREQ(4, 0, 0)
+#if __has_builtin(__builtin_clz) || defined(__GNUC__)
     return __builtin_clz(Val);
 #elif defined(_MSC_VER)
     unsigned long Index;
@@ -164,7 +202,7 @@
     if (ZB != ZB_Undefined && Val == 0)
       return 64;
 
-#if __has_builtin(__builtin_clzll) || LLVM_GNUC_PREREQ(4, 0, 0)
+#if __has_builtin(__builtin_clzll) || defined(__GNUC__)
     return __builtin_clzll(Val);
 #elif defined(_MSC_VER)
     unsigned long Index;
@@ -275,6 +313,34 @@
   return Val;
 }
 
+#if __has_builtin(__builtin_bitreverse8)
+template<>
+inline uint8_t reverseBits<uint8_t>(uint8_t Val) {
+  return __builtin_bitreverse8(Val);
+}
+#endif
+
+#if __has_builtin(__builtin_bitreverse16)
+template<>
+inline uint16_t reverseBits<uint16_t>(uint16_t Val) {
+  return __builtin_bitreverse16(Val);
+}
+#endif
+
+#if __has_builtin(__builtin_bitreverse32)
+template<>
+inline uint32_t reverseBits<uint32_t>(uint32_t Val) {
+  return __builtin_bitreverse32(Val);
+}
+#endif
+
+#if __has_builtin(__builtin_bitreverse64)
+template<>
+inline uint64_t reverseBits<uint64_t>(uint64_t Val) {
+  return __builtin_bitreverse64(Val);
+}
+#endif
+
 // NOTE: The following support functions use the _32/_64 extensions instead of
 // type overloading so that signed and unsigned integers can be used without
 // ambiguity.
@@ -327,14 +393,12 @@
 /// to keep MSVC from (incorrectly) warning on isUInt<64> that we're shifting
 /// left too many places.
 template <unsigned N>
-constexpr inline typename std::enable_if<(N < 64), bool>::type
-isUInt(uint64_t X) {
+constexpr inline std::enable_if_t<(N < 64), bool> isUInt(uint64_t X) {
   static_assert(N > 0, "isUInt<0> doesn't make sense");
   return X < (UINT64_C(1) << (N));
 }
 template <unsigned N>
-constexpr inline typename std::enable_if<N >= 64, bool>::type
-isUInt(uint64_t X) {
+constexpr inline std::enable_if_t<N >= 64, bool> isUInt(uint64_t X) {
   return true;
 }
 
@@ -376,7 +440,7 @@
 inline int64_t minIntN(int64_t N) {
   assert(N > 0 && N <= 64 && "integer width out of range");
 
-  return -(UINT64_C(1)<<(N-1));
+  return UINT64_C(1) + ~(UINT64_C(1) << (N - 1));
 }
 
 /// Gets the maximum value for a N-bit signed integer.
@@ -434,21 +498,6 @@
   return Value && !(Value & (Value - 1));
 }
 
-/// Return a byte-swapped representation of the 16-bit argument.
-inline uint16_t ByteSwap_16(uint16_t Value) {
-  return sys::SwapByteOrder_16(Value);
-}
-
-/// Return a byte-swapped representation of the 32-bit argument.
-inline uint32_t ByteSwap_32(uint32_t Value) {
-  return sys::SwapByteOrder_32(Value);
-}
-
-/// Return a byte-swapped representation of the 64-bit argument.
-inline uint64_t ByteSwap_64(uint64_t Value) {
-  return sys::SwapByteOrder_64(Value);
-}
-
 /// Count the number of ones from the most significant bit to the first
 /// zero bit.
 ///
@@ -486,7 +535,7 @@
   static unsigned count(T Value) {
     // Generic version, forward to 32 bits.
     static_assert(SizeOfT <= 4, "Not implemented!");
-#if __GNUC__ >= 4
+#if defined(__GNUC__)
     return __builtin_popcount(Value);
 #else
     uint32_t v = Value;
@@ -499,7 +548,7 @@
 
 template <typename T> struct PopulationCounter<T, 8> {
   static unsigned count(T Value) {
-#if __GNUC__ >= 4
+#if defined(__GNUC__)
     return __builtin_popcountll(Value);
 #else
     uint64_t v = Value;
@@ -523,6 +572,16 @@
   return detail::PopulationCounter<T, sizeof(T)>::count(Value);
 }
 
+/// Compile time Log2.
+/// Valid only for positive powers of two.
+template <size_t kValue> constexpr inline size_t CTLog2() {
+  static_assert(kValue > 0 && llvm::isPowerOf2_64(kValue),
+                "Value is not a valid power of 2");
+  return 1 + CTLog2<kValue / 2>();
+}
+
+template <> constexpr inline size_t CTLog2<1>() { return 0; }
+
 /// Return the log base 2 of the specified value.
 inline double Log2(double Value) {
 #if defined(__ANDROID_API__) && __ANDROID_API__ < 18
@@ -559,15 +618,20 @@
 }
 
 /// Return the greatest common divisor of the values using Euclid's algorithm.
-inline uint64_t GreatestCommonDivisor64(uint64_t A, uint64_t B) {
+template <typename T>
+inline T greatestCommonDivisor(T A, T B) {
   while (B) {
-    uint64_t T = B;
+    T Tmp = B;
     B = A % B;
-    A = T;
+    A = Tmp;
   }
   return A;
 }
 
+inline uint64_t GreatestCommonDivisor64(uint64_t A, uint64_t B) {
+  return greatestCommonDivisor<uint64_t>(A, B);
+}
+
 /// This function takes a 64-bit integer and returns the bit equivalent double.
 inline double BitsToDouble(uint64_t Bits) {
   double D;
@@ -615,25 +679,6 @@
   return (A | B) & (1 + ~(A | B));
 }
 
-/// Aligns \c Addr to \c Alignment bytes, rounding up.
-///
-/// Alignment should be a power of two.  This method rounds up, so
-/// alignAddr(7, 4) == 8 and alignAddr(8, 4) == 8.
-inline uintptr_t alignAddr(const void *Addr, size_t Alignment) {
-  assert(Alignment && isPowerOf2_64((uint64_t)Alignment) &&
-         "Alignment is not a power of two!");
-
-  assert((uintptr_t)Addr + Alignment - 1 >= (uintptr_t)Addr);
-
-  return (((uintptr_t)Addr + Alignment - 1) & ~(uintptr_t)(Alignment - 1));
-}
-
-/// Returns the necessary adjustment for aligning \c Ptr to \c Alignment
-/// bytes, rounding up.
-inline size_t alignmentAdjustment(const void *Ptr, size_t Alignment) {
-  return alignAddr(Ptr, Alignment) - (uintptr_t)Ptr;
-}
-
 /// Returns the next power of two (in 64-bits) that is strictly greater than A.
 /// Returns zero on overflow.
 inline uint64_t NextPowerOf2(uint64_t A) {
@@ -699,18 +744,10 @@
   return alignTo(Numerator, Denominator) / Denominator;
 }
 
-/// \c alignTo for contexts where a constant expression is required.
-/// \sa alignTo
-///
-/// \todo FIXME: remove when \c constexpr becomes really \c constexpr
-template <uint64_t Align>
-struct AlignTo {
-  static_assert(Align != 0u, "Align must be non-zero");
-  template <uint64_t Value>
-  struct from_value {
-    static const uint64_t value = (Value + Align - 1) / Align * Align;
-  };
-};
+/// Returns the integer nearest(Numerator / Denominator).
+inline uint64_t divideNearest(uint64_t Numerator, uint64_t Denominator) {
+  return (Numerator + (Denominator / 2)) / Denominator;
+}
 
 /// Returns the largest uint64_t less than or equal to \p Value and is
 /// \p Skew mod \p Align. \p Align must be non-zero
@@ -720,13 +757,6 @@
   return (Value - Skew) / Align * Align + Skew;
 }
 
-/// Returns the offset to the next integer (mod 2**64) that is greater than
-/// or equal to \p Value and is a multiple of \p Align. \p Align must be
-/// non-zero.
-inline uint64_t OffsetToAlignment(uint64_t Value, uint64_t Align) {
-  return alignTo(Value, Align) - Value;
-}
-
 /// Sign-extend the number in the bottom B bits of X to a 32-bit integer.
 /// Requires 0 < B <= 32.
 template <unsigned B> constexpr inline int32_t SignExtend32(uint32_t X) {
@@ -762,8 +792,7 @@
 /// Subtract two unsigned integers, X and Y, of type T and return the absolute
 /// value of the result.
 template <typename T>
-typename std::enable_if<std::is_unsigned<T>::value, T>::type
-AbsoluteDifference(T X, T Y) {
+std::enable_if_t<std::is_unsigned<T>::value, T> AbsoluteDifference(T X, T Y) {
   return std::max(X, Y) - std::min(X, Y);
 }
 
@@ -771,7 +800,7 @@
 /// maximum representable value of T on overflow.  ResultOverflowed indicates if
 /// the result is larger than the maximum representable value of type T.
 template <typename T>
-typename std::enable_if<std::is_unsigned<T>::value, T>::type
+std::enable_if_t<std::is_unsigned<T>::value, T>
 SaturatingAdd(T X, T Y, bool *ResultOverflowed = nullptr) {
   bool Dummy;
   bool &Overflowed = ResultOverflowed ? *ResultOverflowed : Dummy;
@@ -788,7 +817,7 @@
 /// maximum representable value of T on overflow.  ResultOverflowed indicates if
 /// the result is larger than the maximum representable value of type T.
 template <typename T>
-typename std::enable_if<std::is_unsigned<T>::value, T>::type
+std::enable_if_t<std::is_unsigned<T>::value, T>
 SaturatingMultiply(T X, T Y, bool *ResultOverflowed = nullptr) {
   bool Dummy;
   bool &Overflowed = ResultOverflowed ? *ResultOverflowed : Dummy;
@@ -834,7 +863,7 @@
 /// overflow. ResultOverflowed indicates if the result is larger than the
 /// maximum representable value of type T.
 template <typename T>
-typename std::enable_if<std::is_unsigned<T>::value, T>::type
+std::enable_if_t<std::is_unsigned<T>::value, T>
 SaturatingMultiplyAdd(T X, T Y, T A, bool *ResultOverflowed = nullptr) {
   bool Dummy;
   bool &Overflowed = ResultOverflowed ? *ResultOverflowed : Dummy;
@@ -848,6 +877,87 @@
 
 /// Use this rather than HUGE_VALF; the latter causes warnings on MSVC.
 extern const float huge_valf;
+
+
+/// Add two signed integers, computing the two's complement truncated result,
+/// returning true if overflow occured.
+template <typename T>
+std::enable_if_t<std::is_signed<T>::value, T> AddOverflow(T X, T Y, T &Result) {
+#if __has_builtin(__builtin_add_overflow)
+  return __builtin_add_overflow(X, Y, &Result);
+#else
+  // Perform the unsigned addition.
+  using U = std::make_unsigned_t<T>;
+  const U UX = static_cast<U>(X);
+  const U UY = static_cast<U>(Y);
+  const U UResult = UX + UY;
+
+  // Convert to signed.
+  Result = static_cast<T>(UResult);
+
+  // Adding two positive numbers should result in a positive number.
+  if (X > 0 && Y > 0)
+    return Result <= 0;
+  // Adding two negatives should result in a negative number.
+  if (X < 0 && Y < 0)
+    return Result >= 0;
+  return false;
+#endif
+}
+
+/// Subtract two signed integers, computing the two's complement truncated
+/// result, returning true if an overflow ocurred.
+template <typename T>
+std::enable_if_t<std::is_signed<T>::value, T> SubOverflow(T X, T Y, T &Result) {
+#if __has_builtin(__builtin_sub_overflow)
+  return __builtin_sub_overflow(X, Y, &Result);
+#else
+  // Perform the unsigned addition.
+  using U = std::make_unsigned_t<T>;
+  const U UX = static_cast<U>(X);
+  const U UY = static_cast<U>(Y);
+  const U UResult = UX - UY;
+
+  // Convert to signed.
+  Result = static_cast<T>(UResult);
+
+  // Subtracting a positive number from a negative results in a negative number.
+  if (X <= 0 && Y > 0)
+    return Result >= 0;
+  // Subtracting a negative number from a positive results in a positive number.
+  if (X >= 0 && Y < 0)
+    return Result <= 0;
+  return false;
+#endif
+}
+
+/// Multiply two signed integers, computing the two's complement truncated
+/// result, returning true if an overflow ocurred.
+template <typename T>
+std::enable_if_t<std::is_signed<T>::value, T> MulOverflow(T X, T Y, T &Result) {
+  // Perform the unsigned multiplication on absolute values.
+  using U = std::make_unsigned_t<T>;
+  const U UX = X < 0 ? (0 - static_cast<U>(X)) : static_cast<U>(X);
+  const U UY = Y < 0 ? (0 - static_cast<U>(Y)) : static_cast<U>(Y);
+  const U UResult = UX * UY;
+
+  // Convert to signed.
+  const bool IsNegative = (X < 0) ^ (Y < 0);
+  Result = IsNegative ? (0 - UResult) : UResult;
+
+  // If any of the args was 0, result is 0 and no overflow occurs.
+  if (UX == 0 || UY == 0)
+    return false;
+
+  // UX and UY are in [1, 2^n], where n is the number of digits.
+  // Check how the max allowed absolute value (2^n for negative, 2^(n-1) for
+  // positive) divided by an argument compares to the other.
+  if (IsNegative)
+    return UX > (static_cast<U>(std::numeric_limits<T>::max()) + U(1)) / UY;
+  else
+    return UX > (static_cast<U>(std::numeric_limits<T>::max())) / UY;
+}
+
 } // End llvm namespace
 
 #endif
diff --git a/linux-x64/clang/include/llvm/Support/MemAlloc.h b/linux-x64/clang/include/llvm/Support/MemAlloc.h
index 0e58691..d6012bd 100644
--- a/linux-x64/clang/include/llvm/Support/MemAlloc.h
+++ b/linux-x64/clang/include/llvm/Support/MemAlloc.h
@@ -62,5 +62,26 @@
   return Result;
 }
 
-}
+/// Allocate a buffer of memory with the given size and alignment.
+///
+/// When the compiler supports aligned operator new, this will use it to to
+/// handle even over-aligned allocations.
+///
+/// However, this doesn't make any attempt to leverage the fancier techniques
+/// like posix_memalign due to portability. It is mostly intended to allow
+/// compatibility with platforms that, after aligned allocation was added, use
+/// reduced default alignment.
+LLVM_ATTRIBUTE_RETURNS_NONNULL LLVM_ATTRIBUTE_RETURNS_NOALIAS void *
+allocate_buffer(size_t Size, size_t Alignment);
+
+/// Deallocate a buffer of memory with the given size and alignment.
+///
+/// If supported, this will used the sized delete operator. Also if supported,
+/// this will pass the alignment to the delete operator.
+///
+/// The pointer must have been allocated with the corresponding new operator,
+/// most likely using the above helper.
+void deallocate_buffer(void *Ptr, size_t Size, size_t Alignment);
+
+} // namespace llvm
 #endif
diff --git a/linux-x64/clang/include/llvm/Support/Memory.h b/linux-x64/clang/include/llvm/Support/Memory.h
index 6f22dd7..c045422 100644
--- a/linux-x64/clang/include/llvm/Support/Memory.h
+++ b/linux-x64/clang/include/llvm/Support/Memory.h
@@ -57,6 +57,17 @@
       MF_WRITE = 0x2000000,
       MF_EXEC = 0x4000000,
       MF_RWE_MASK = 0x7000000,
+
+      /// The \p MF_HUGE_HINT flag is used to indicate that the request for
+      /// a memory block should be satisfied with large pages if possible.
+      /// This is only a hint and small pages will be used as fallback.
+      ///
+      /// The presence or absence of this flag in the returned memory block
+      /// is (at least currently) *not* a reliable indicator that the memory
+      /// block will use or will not use large pages. On some systems a request
+      /// without this flag can be backed by large pages without this flag being
+      /// set, and on some other systems a request with this flag can fallback
+      /// to small pages without this flag being cleared.
       MF_HUGE_HINT = 0x0000001
     };
 
diff --git a/linux-x64/clang/include/llvm/Support/MemoryBuffer.h b/linux-x64/clang/include/llvm/Support/MemoryBuffer.h
index b5196cd..9e6ee25 100644
--- a/linux-x64/clang/include/llvm/Support/MemoryBuffer.h
+++ b/linux-x64/clang/include/llvm/Support/MemoryBuffer.h
@@ -19,14 +19,23 @@
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/CBindingWrapping.h"
 #include "llvm/Support/ErrorOr.h"
-#include "llvm/Support/FileSystem.h"
+#include "llvm/Support/MemoryBufferRef.h"
 #include <cstddef>
 #include <cstdint>
 #include <memory>
 
 namespace llvm {
-
-class MemoryBufferRef;
+namespace sys {
+namespace fs {
+// Duplicated from FileSystem.h to avoid a dependency.
+#if defined(_WIN32)
+// A Win32 HANDLE is a typedef of void*
+using file_t = void *;
+#else
+using file_t = int;
+#endif
+} // namespace fs
+} // namespace sys
 
 /// This interface provides simple read-only access to a block of memory, and
 /// provides simple methods for reading files and standard input into a memory
@@ -48,9 +57,6 @@
   void init(const char *BufStart, const char *BufEnd,
             bool RequiresNullTerminator);
 
-  static constexpr sys::fs::mapped_file_region::mapmode Mapmode =
-      sys::fs::mapped_file_region::readonly;
-
 public:
   MemoryBuffer(const MemoryBuffer &) = delete;
   MemoryBuffer &operator=(const MemoryBuffer &) = delete;
@@ -156,9 +162,6 @@
 protected:
   WritableMemoryBuffer() = default;
 
-  static constexpr sys::fs::mapped_file_region::mapmode Mapmode =
-      sys::fs::mapped_file_region::priv;
-
 public:
   using MemoryBuffer::getBuffer;
   using MemoryBuffer::getBufferEnd;
@@ -218,9 +221,6 @@
 protected:
   WriteThroughMemoryBuffer() = default;
 
-  static constexpr sys::fs::mapped_file_region::mapmode Mapmode =
-      sys::fs::mapped_file_region::readwrite;
-
 public:
   using MemoryBuffer::getBuffer;
   using MemoryBuffer::getBufferEnd;
@@ -258,26 +258,6 @@
   using MemoryBuffer::getSTDIN;
 };
 
-class MemoryBufferRef {
-  StringRef Buffer;
-  StringRef Identifier;
-
-public:
-  MemoryBufferRef() = default;
-  MemoryBufferRef(const MemoryBuffer& Buffer)
-      : Buffer(Buffer.getBuffer()), Identifier(Buffer.getBufferIdentifier()) {}
-  MemoryBufferRef(StringRef Buffer, StringRef Identifier)
-      : Buffer(Buffer), Identifier(Identifier) {}
-
-  StringRef getBuffer() const { return Buffer; }
-
-  StringRef getBufferIdentifier() const { return Identifier; }
-
-  const char *getBufferStart() const { return Buffer.begin(); }
-  const char *getBufferEnd() const { return Buffer.end(); }
-  size_t getBufferSize() const { return Buffer.size(); }
-};
-
 // Create wrappers for C Binding types (see CBindingWrapping.h).
 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(MemoryBuffer, LLVMMemoryBufferRef)
 
diff --git a/linux-x64/clang/include/llvm/Support/MemoryBufferRef.h b/linux-x64/clang/include/llvm/Support/MemoryBufferRef.h
new file mode 100644
index 0000000..b38a1f3
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Support/MemoryBufferRef.h
@@ -0,0 +1,56 @@
+//===- MemoryBufferRef.h - Memory Buffer Reference --------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+//  This file defines the MemoryBuffer interface.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_SUPPORT_MEMORYBUFFERREF_H
+#define LLVM_SUPPORT_MEMORYBUFFERREF_H
+
+#include "llvm/ADT/StringRef.h"
+
+namespace llvm {
+
+class MemoryBuffer;
+
+class MemoryBufferRef {
+  StringRef Buffer;
+  StringRef Identifier;
+
+public:
+  MemoryBufferRef() = default;
+  MemoryBufferRef(const MemoryBuffer &Buffer);
+  MemoryBufferRef(StringRef Buffer, StringRef Identifier)
+      : Buffer(Buffer), Identifier(Identifier) {}
+
+  StringRef getBuffer() const { return Buffer; }
+  StringRef getBufferIdentifier() const { return Identifier; }
+
+  const char *getBufferStart() const { return Buffer.begin(); }
+  const char *getBufferEnd() const { return Buffer.end(); }
+  size_t getBufferSize() const { return Buffer.size(); }
+
+  /// Check pointer identity (not value) of identifier and data.
+  friend bool operator==(const MemoryBufferRef &LHS,
+                         const MemoryBufferRef &RHS) {
+    return LHS.Buffer.begin() == RHS.Buffer.begin() &&
+           LHS.Buffer.end() == RHS.Buffer.end() &&
+           LHS.Identifier.begin() == RHS.Identifier.begin() &&
+           LHS.Identifier.end() == RHS.Identifier.end();
+  }
+
+  friend bool operator!=(const MemoryBufferRef &LHS,
+                         const MemoryBufferRef &RHS) {
+    return !(LHS == RHS);
+  }
+};
+
+} // namespace llvm
+
+#endif // LLVM_SUPPORT_MEMORYBUFFERREF_H
diff --git a/linux-x64/clang/include/llvm/Support/Mutex.h b/linux-x64/clang/include/llvm/Support/Mutex.h
index c3abfc7..1d8a0d3 100644
--- a/linux-x64/clang/include/llvm/Support/Mutex.h
+++ b/linux-x64/clang/include/llvm/Support/Mutex.h
@@ -13,97 +13,31 @@
 #ifndef LLVM_SUPPORT_MUTEX_H
 #define LLVM_SUPPORT_MUTEX_H
 
-#include "llvm/Config/llvm-config.h"
-#include "llvm/Support/Compiler.h"
 #include "llvm/Support/Threading.h"
 #include <cassert>
+#include <mutex>
 
 namespace llvm
 {
   namespace sys
   {
-    /// Platform agnostic Mutex class.
-    class MutexImpl
-    {
-    /// @name Constructors
-    /// @{
-    public:
-
-      /// Initializes the lock but doesn't acquire it. if \p recursive is set
-      /// to false, the lock will not be recursive which makes it cheaper but
-      /// also more likely to deadlock (same thread can't acquire more than
-      /// once).
-      /// Default Constructor.
-      explicit MutexImpl(bool recursive = true);
-
-      /// Releases and removes the lock
-      /// Destructor
-      ~MutexImpl();
-
-    /// @}
-    /// @name Methods
-    /// @{
-    public:
-
-      /// Attempts to unconditionally acquire the lock. If the lock is held by
-      /// another thread, this method will wait until it can acquire the lock.
-      /// @returns false if any kind of error occurs, true otherwise.
-      /// Unconditionally acquire the lock.
-      bool acquire();
-
-      /// Attempts to release the lock. If the lock is held by the current
-      /// thread, the lock is released allowing other threads to acquire the
-      /// lock.
-      /// @returns false if any kind of error occurs, true otherwise.
-      /// Unconditionally release the lock.
-      bool release();
-
-      /// Attempts to acquire the lock without blocking. If the lock is not
-      /// available, this function returns false quickly (without blocking). If
-      /// the lock is available, it is acquired.
-      /// @returns false if any kind of error occurs or the lock is not
-      /// available, true otherwise.
-      /// Try to acquire the lock.
-      bool tryacquire();
-
-    //@}
-    /// @name Platform Dependent Data
-    /// @{
-    private:
-#if defined(LLVM_ENABLE_THREADS) && LLVM_ENABLE_THREADS != 0
-      void* data_; ///< We don't know what the data will be
-#endif
-
-    /// @}
-    /// @name Do Not Implement
-    /// @{
-    private:
-      MutexImpl(const MutexImpl &) = delete;
-      void operator=(const MutexImpl &) = delete;
-    /// @}
-    };
-
-
     /// SmartMutex - A mutex with a compile time constant parameter that
     /// indicates whether this mutex should become a no-op when we're not
     /// running in multithreaded mode.
     template<bool mt_only>
     class SmartMutex {
-      MutexImpl impl;
-      unsigned acquired;
-      bool recursive;
-    public:
-      explicit SmartMutex(bool rec = true) :
-        impl(rec), acquired(0), recursive(rec) { }
+      std::recursive_mutex impl;
+      unsigned acquired = 0;
 
+    public:
       bool lock() {
         if (!mt_only || llvm_is_multithreaded()) {
-          return impl.acquire();
+          impl.lock();
+          return true;
         } else {
           // Single-threaded debugging code.  This would be racy in
           // multithreaded mode, but provides not sanity checks in single
           // threaded mode.
-          assert((recursive || acquired == 0) && "Lock already acquired!!");
           ++acquired;
           return true;
         }
@@ -111,13 +45,13 @@
 
       bool unlock() {
         if (!mt_only || llvm_is_multithreaded()) {
-          return impl.release();
+          impl.unlock();
+          return true;
         } else {
           // Single-threaded debugging code.  This would be racy in
           // multithreaded mode, but provides not sanity checks in single
           // threaded mode.
-          assert(((recursive && acquired) || (acquired == 1)) &&
-                 "Lock not acquired before release!");
+          assert(acquired && "Lock not acquired before release!");
           --acquired;
           return true;
         }
@@ -125,31 +59,16 @@
 
       bool try_lock() {
         if (!mt_only || llvm_is_multithreaded())
-          return impl.tryacquire();
+          return impl.try_lock();
         else return true;
       }
-
-      private:
-        SmartMutex(const SmartMutex<mt_only> & original);
-        void operator=(const SmartMutex<mt_only> &);
     };
 
     /// Mutex - A standard, always enforced mutex.
     typedef SmartMutex<false> Mutex;
 
-    template<bool mt_only>
-    class SmartScopedLock  {
-      SmartMutex<mt_only>& mtx;
-
-    public:
-      SmartScopedLock(SmartMutex<mt_only>& m) : mtx(m) {
-        mtx.lock();
-      }
-
-      ~SmartScopedLock() {
-        mtx.unlock();
-      }
-    };
+    template <bool mt_only>
+    using SmartScopedLock = std::lock_guard<SmartMutex<mt_only>>;
 
     typedef SmartScopedLock<false> ScopedLock;
   }
diff --git a/linux-x64/clang/include/llvm/Support/MutexGuard.h b/linux-x64/clang/include/llvm/Support/MutexGuard.h
deleted file mode 100644
index d86ced1..0000000
--- a/linux-x64/clang/include/llvm/Support/MutexGuard.h
+++ /dev/null
@@ -1,40 +0,0 @@
-//===-- Support/MutexGuard.h - Acquire/Release Mutex In Scope ---*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// This file defines a guard for a block of code that ensures a Mutex is locked
-// upon construction and released upon destruction.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_SUPPORT_MUTEXGUARD_H
-#define LLVM_SUPPORT_MUTEXGUARD_H
-
-#include "llvm/Support/Mutex.h"
-
-namespace llvm {
-  /// Instances of this class acquire a given Mutex Lock when constructed and
-  /// hold that lock until destruction. The intention is to instantiate one of
-  /// these on the stack at the top of some scope to be assured that C++
-  /// destruction of the object will always release the Mutex and thus avoid
-  /// a host of nasty multi-threading problems in the face of exceptions, etc.
-  /// Guard a section of code with a Mutex.
-  class MutexGuard {
-    sys::Mutex &M;
-    MutexGuard(const MutexGuard &) = delete;
-    void operator=(const MutexGuard &) = delete;
-  public:
-    MutexGuard(sys::Mutex &m) : M(m) { M.lock(); }
-    ~MutexGuard() { M.unlock(); }
-    /// holds - Returns true if this locker instance holds the specified lock.
-    /// This is mostly used in assertions to validate that the correct mutex
-    /// is held.
-    bool holds(const sys::Mutex& lock) const { return &M == &lock; }
-  };
-}
-
-#endif // LLVM_SUPPORT_MUTEXGUARD_H
diff --git a/linux-x64/clang/include/llvm/Support/NativeFormatting.h b/linux-x64/clang/include/llvm/Support/NativeFormatting.h
index 825a44c..e664d05 100644
--- a/linux-x64/clang/include/llvm/Support/NativeFormatting.h
+++ b/linux-x64/clang/include/llvm/Support/NativeFormatting.h
@@ -10,11 +10,10 @@
 #define LLVM_SUPPORT_NATIVE_FORMATTING_H
 
 #include "llvm/ADT/Optional.h"
-#include "llvm/Support/raw_ostream.h"
-
 #include <cstdint>
 
 namespace llvm {
+class raw_ostream;
 enum class FloatStyle { Exponent, ExponentUpper, Fixed, Percent };
 enum class IntegerStyle {
   Integer,
diff --git a/linux-x64/clang/include/llvm/Support/OnDiskHashTable.h b/linux-x64/clang/include/llvm/Support/OnDiskHashTable.h
index d84da92..11dc0de 100644
--- a/linux-x64/clang/include/llvm/Support/OnDiskHashTable.h
+++ b/linux-x64/clang/include/llvm/Support/OnDiskHashTable.h
@@ -13,6 +13,7 @@
 #ifndef LLVM_SUPPORT_ONDISKHASHTABLE_H
 #define LLVM_SUPPORT_ONDISKHASHTABLE_H
 
+#include "llvm/Support/Alignment.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/DataTypes.h"
 #include "llvm/Support/EndianStream.h"
@@ -207,7 +208,7 @@
 
     // Pad with zeros so that we can start the hashtable at an aligned address.
     offset_type TableOff = Out.tell();
-    uint64_t N = llvm::OffsetToAlignment(TableOff, alignof(offset_type));
+    uint64_t N = offsetToAlignment(TableOff, Align(alignof(offset_type)));
     TableOff += N;
     while (N--)
       LE.write<uint8_t>(0);
diff --git a/linux-x64/clang/include/llvm/Support/OptimizedStructLayout.h b/linux-x64/clang/include/llvm/Support/OptimizedStructLayout.h
new file mode 100644
index 0000000..773ddfe
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Support/OptimizedStructLayout.h
@@ -0,0 +1,142 @@
+//===-- OptimizedStructLayout.h - Struct layout algorithm ---------*- C++ -*-=//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+///
+/// This file provides an interface for laying out a sequence of fields
+/// as a struct in a way that attempts to minimizes the total space
+/// requirements of the struct while still satisfying the layout
+/// requirements of the individual fields.  The resulting layout may be
+/// substantially more compact than simply laying out the fields in their
+/// original order.
+///
+/// Fields may be pre-assigned fixed offsets.  They may also be given sizes
+/// that are not multiples of their alignments.  There is no currently no
+/// way to describe that a field has interior padding that other fields may
+/// be allocated into.
+///
+/// This algorithm does not claim to be "optimal" for several reasons:
+///
+/// - First, it does not guarantee that the result is minimal in size.
+///   There is no known efficient algoorithm to achieve minimality for
+///   unrestricted inputs.  Nonetheless, this algorithm 
+///
+/// - Second, there are other ways that a struct layout could be optimized
+///   besides space usage, such as locality.  This layout may have a mixed
+///   impact on locality: less overall memory may be used, but adjacent
+///   fields in the original array may be moved further from one another.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_SUPPORT_OPTIMIZEDSTRUCTLAYOUT_H
+#define LLVM_SUPPORT_OPTIMIZEDSTRUCTLAYOUT_H
+
+#include "llvm/Support/Alignment.h"
+#include "llvm/ADT/ArrayRef.h"
+#include <utility>
+
+namespace llvm {
+
+/// A field in a structure.
+struct OptimizedStructLayoutField {
+  /// A special value for Offset indicating that the field can be moved
+  /// anywhere.
+  static constexpr uint64_t FlexibleOffset = ~(uint64_t)0;
+
+  OptimizedStructLayoutField(const void *Id, uint64_t Size, Align Alignment,
+                             uint64_t FixedOffset = FlexibleOffset)
+      : Offset(FixedOffset), Size(Size), Id(Id), Alignment(Alignment) {
+    assert(Size > 0 && "adding an empty field to the layout");
+  }
+
+  /// The offset of this field in the final layout.  If this is
+  /// initialized to FlexibleOffset, layout will overwrite it with
+  /// the assigned offset of the field.
+  uint64_t Offset;
+
+  /// The required size of this field in bytes.  Does not have to be
+  /// a multiple of Alignment.  Must be non-zero.
+  uint64_t Size;
+
+  /// A opaque value which uniquely identifies this field.
+  const void *Id;
+
+  /// Private scratch space for the algorithm.  The implementation
+  /// must treat this as uninitialized memory on entry.
+  void *Scratch;
+
+  /// The required alignment of this field.
+  Align Alignment;
+
+  /// Return true if this field has been assigned a fixed offset.
+  /// After layout, this will be true of all the fields.
+  bool hasFixedOffset() const {
+    return (Offset != FlexibleOffset);
+  }
+
+  /// Given that this field has a fixed offset, return the offset
+  /// of the first byte following it.
+  uint64_t getEndOffset() const {
+    assert(hasFixedOffset());
+    return Offset + Size;
+  }
+};
+
+/// Compute a layout for a struct containing the given fields, making a
+/// best-effort attempt to minimize the amount of space required.
+///
+/// Two features are supported which require a more careful solution
+/// than the well-known "sort by decreasing alignment" solution:
+///
+/// - Fields may be assigned a fixed offset in the layout.  If there are
+///   gaps among the fixed-offset fields, the algorithm may attempt
+///   to allocate flexible-offset fields into those gaps.  If that's
+///   undesirable, the caller should "block out" those gaps by e.g.
+///   just creating a single fixed-offset field that represents the
+///   entire "header".
+///
+/// - The size of a field is not required to be a multiple of, or even
+///   greater than, the field's required alignment.  The only constraint
+///   on fields is that they must not be zero-sized.
+///
+/// To simplify the implementation, any fixed-offset fields in the
+/// layout must appear at the start of the field array, and they must
+/// be ordered by increasing offset.
+///
+/// The algorithm will produce a guaranteed-minimal layout with no
+/// interior padding in the following "C-style" case:
+///
+/// - every field's size is a multiple of its required alignment and
+/// - either no fields have initially fixed offsets, or the fixed-offset
+///   fields have no interior padding and end at an offset that is at
+///   least as aligned as all the flexible-offset fields.
+///
+/// Otherwise, while the algorithm will make a best-effort attempt to
+/// avoid padding, it cannot guarantee a minimal layout, as there is
+/// no known efficient algorithm for doing so.
+///
+/// The layout produced by this algorithm may not be stable across LLVM
+/// releases.  Do not use this anywhere where ABI stability is required.
+///
+/// Flexible-offset fields with the same size and alignment will be ordered
+/// the same way they were in the initial array.  Otherwise the current
+/// algorithm makes no effort to preserve the initial order of
+/// flexible-offset fields.
+///
+/// On return, all fields will have been assigned a fixed offset, and the
+/// array will be sorted in order of ascending offsets.  Note that this
+/// means that the fixed-offset fields may no longer form a strict prefix
+/// if there's any padding before they end.
+///
+/// The return value is the total size of the struct and its required
+/// alignment.  Note that the total size is not rounded up to a multiple
+/// of the required alignment; clients which require this can do so easily.
+std::pair<uint64_t, Align> performOptimizedStructLayout(
+                        MutableArrayRef<OptimizedStructLayoutField> Fields);
+
+} // namespace llvm
+
+#endif
diff --git a/linux-x64/clang/include/llvm/Support/Options.h b/linux-x64/clang/include/llvm/Support/Options.h
deleted file mode 100644
index d02ef85..0000000
--- a/linux-x64/clang/include/llvm/Support/Options.h
+++ /dev/null
@@ -1,119 +0,0 @@
-//===- llvm/Support/Options.h - Debug options support -----------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-/// \file
-/// This file declares helper objects for defining debug options that can be
-/// configured via the command line. The new API currently builds on the cl::opt
-/// API, but does not require the use of static globals.
-///
-/// With this API options are registered during initialization. For passes, this
-/// happens during pass initialization. Passes with options will call a static
-/// registerOptions method during initialization that registers options with the
-/// OptionRegistry. An example implementation of registerOptions is:
-///
-/// static void registerOptions() {
-///   OptionRegistry::registerOption<bool, Scalarizer,
-///                                &Scalarizer::ScalarizeLoadStore>(
-///       "scalarize-load-store",
-///       "Allow the scalarizer pass to scalarize loads and store", false);
-/// }
-///
-/// When reading data for options the interface is via the LLVMContext. Option
-/// data for passes should be read from the context during doInitialization. An
-/// example of reading the above option would be:
-///
-/// ScalarizeLoadStore =
-///   M.getContext().getOption<bool,
-///                            Scalarizer,
-///                            &Scalarizer::ScalarizeLoadStore>();
-///
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_SUPPORT_OPTIONS_H
-#define LLVM_SUPPORT_OPTIONS_H
-
-#include "llvm/ADT/DenseMap.h"
-#include "llvm/Support/CommandLine.h"
-
-namespace llvm {
-
-namespace detail {
-
-// Options are keyed of the unique address of a static character synthesized
-// based on template arguments.
-template <typename ValT, typename Base, ValT(Base::*Mem)> class OptionKey {
-public:
-  static char ID;
-};
-
-template <typename ValT, typename Base, ValT(Base::*Mem)>
-char OptionKey<ValT, Base, Mem>::ID = 0;
-
-} // namespace detail
-
-/// Singleton class used to register debug options.
-///
-/// The OptionRegistry is responsible for managing lifetimes of the options and
-/// provides interfaces for option registration and reading values from options.
-/// This object is a singleton, only one instance should ever exist so that all
-/// options are registered in the same place.
-class OptionRegistry {
-private:
-  DenseMap<void *, cl::Option *> Options;
-
-  /// Adds a cl::Option to the registry.
-  ///
-  /// \param Key unique key for option
-  /// \param O option to map to \p Key
-  ///
-  /// Allocated cl::Options are owned by the OptionRegistry and are deallocated
-  /// on destruction or removal
-  void addOption(void *Key, cl::Option *O);
-
-public:
-  ~OptionRegistry();
-  OptionRegistry() {}
-
-  /// Returns a reference to the singleton instance.
-  static OptionRegistry &instance();
-
-  /// Registers an option with the OptionRegistry singleton.
-  ///
-  /// \tparam ValT type of the option's data
-  /// \tparam Base class used to key the option
-  /// \tparam Mem member of \p Base used for keying the option
-  ///
-  /// Options are keyed off the template parameters to generate unique static
-  /// characters. The template parameters are (1) the type of the data the
-  /// option stores (\p ValT), the class that will read the option (\p Base),
-  /// and the member that the class will store the data into (\p Mem).
-  template <typename ValT, typename Base, ValT(Base::*Mem)>
-  static void registerOption(StringRef ArgStr, StringRef Desc,
-                             const ValT &InitValue) {
-    cl::opt<ValT> *Option = new cl::opt<ValT>(ArgStr, cl::desc(Desc),
-                                              cl::Hidden, cl::init(InitValue));
-    instance().addOption(&detail::OptionKey<ValT, Base, Mem>::ID, Option);
-  }
-
-  /// Returns the value of the option.
-  ///
-  /// \tparam ValT type of the option's data
-  /// \tparam Base class used to key the option
-  /// \tparam Mem member of \p Base used for keying the option
-  ///
-  /// Reads option values based on the key generated by the template parameters.
-  /// Keying for get() is the same as keying for registerOption.
-  template <typename ValT, typename Base, ValT(Base::*Mem)> ValT get() const {
-    auto It = Options.find(&detail::OptionKey<ValT, Base, Mem>::ID);
-    assert(It != Options.end() && "Option not in OptionRegistry");
-    return *(cl::opt<ValT> *)It->second;
-  }
-};
-
-} // namespace llvm
-
-#endif
diff --git a/linux-x64/clang/include/llvm/Support/Parallel.h b/linux-x64/clang/include/llvm/Support/Parallel.h
index eab9b49..d2f0067 100644
--- a/linux-x64/clang/include/llvm/Support/Parallel.h
+++ b/linux-x64/clang/include/llvm/Support/Parallel.h
@@ -11,35 +11,23 @@
 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Config/llvm-config.h"
+#include "llvm/Support/Error.h"
 #include "llvm/Support/MathExtras.h"
+#include "llvm/Support/Threading.h"
 
 #include <algorithm>
 #include <condition_variable>
 #include <functional>
 #include <mutex>
 
-#if defined(_MSC_VER) && LLVM_ENABLE_THREADS
-#pragma warning(push)
-#pragma warning(disable : 4530)
-#include <concrt.h>
-#include <ppl.h>
-#pragma warning(pop)
-#endif
-
 namespace llvm {
 
 namespace parallel {
-struct sequential_execution_policy {};
-struct parallel_execution_policy {};
 
-template <typename T>
-struct is_execution_policy
-    : public std::integral_constant<
-          bool, llvm::is_one_of<T, sequential_execution_policy,
-                                parallel_execution_policy>::value> {};
-
-constexpr sequential_execution_policy seq{};
-constexpr parallel_execution_policy par{};
+// Strategy for the default executor used by the parallel routines provided by
+// this file. It defaults to using all hardware threads and should be
+// initialized before the first use of parallel routines.
+extern ThreadPoolStrategy strategy;
 
 namespace detail {
 
@@ -84,23 +72,6 @@
   void sync() const { L.sync(); }
 };
 
-#if defined(_MSC_VER)
-template <class RandomAccessIterator, class Comparator>
-void parallel_sort(RandomAccessIterator Start, RandomAccessIterator End,
-                   const Comparator &Comp) {
-  concurrency::parallel_sort(Start, End, Comp);
-}
-template <class IterTy, class FuncTy>
-void parallel_for_each(IterTy Begin, IterTy End, FuncTy Fn) {
-  concurrency::parallel_for_each(Begin, End, Fn);
-}
-
-template <class IndexTy, class FuncTy>
-void parallel_for_each_n(IndexTy Begin, IndexTy End, FuncTy Fn) {
-  concurrency::parallel_for(Begin, End, Fn);
-}
-
-#else
 const ptrdiff_t MinParallelSize = 1024;
 
 /// Inclusive median.
@@ -150,13 +121,17 @@
                       llvm::Log2_64(std::distance(Start, End)) + 1);
 }
 
+// TaskGroup has a relatively high overhead, so we want to reduce
+// the number of spawn() calls. We'll create up to 1024 tasks here.
+// (Note that 1024 is an arbitrary number. This code probably needs
+// improving to take the number of available cores into account.)
+enum { MaxTasksPerGroup = 1024 };
+
 template <class IterTy, class FuncTy>
 void parallel_for_each(IterTy Begin, IterTy End, FuncTy Fn) {
-  // TaskGroup has a relatively high overhead, so we want to reduce
-  // the number of spawn() calls. We'll create up to 1024 tasks here.
-  // (Note that 1024 is an arbitrary number. This code probably needs
-  // improving to take the number of available cores into account.)
-  ptrdiff_t TaskSize = std::distance(Begin, End) / 1024;
+  // Limit the number of tasks to MaxTasksPerGroup to limit job scheduling
+  // overhead on large inputs.
+  ptrdiff_t TaskSize = std::distance(Begin, End) / MaxTasksPerGroup;
   if (TaskSize == 0)
     TaskSize = 1;
 
@@ -170,7 +145,9 @@
 
 template <class IndexTy, class FuncTy>
 void parallel_for_each_n(IndexTy Begin, IndexTy End, FuncTy Fn) {
-  ptrdiff_t TaskSize = (End - Begin) / 1024;
+  // Limit the number of tasks to MaxTasksPerGroup to limit job scheduling
+  // overhead on large inputs.
+  ptrdiff_t TaskSize = (End - Begin) / MaxTasksPerGroup;
   if (TaskSize == 0)
     TaskSize = 1;
 
@@ -186,65 +163,145 @@
     Fn(J);
 }
 
-#endif
+template <class IterTy, class ResultTy, class ReduceFuncTy,
+          class TransformFuncTy>
+ResultTy parallel_transform_reduce(IterTy Begin, IterTy End, ResultTy Init,
+                                   ReduceFuncTy Reduce,
+                                   TransformFuncTy Transform) {
+  // Limit the number of tasks to MaxTasksPerGroup to limit job scheduling
+  // overhead on large inputs.
+  size_t NumInputs = std::distance(Begin, End);
+  if (NumInputs == 0)
+    return std::move(Init);
+  size_t NumTasks = std::min(static_cast<size_t>(MaxTasksPerGroup), NumInputs);
+  std::vector<ResultTy> Results(NumTasks, Init);
+  {
+    // Each task processes either TaskSize or TaskSize+1 inputs. Any inputs
+    // remaining after dividing them equally amongst tasks are distributed as
+    // one extra input over the first tasks.
+    TaskGroup TG;
+    size_t TaskSize = NumInputs / NumTasks;
+    size_t RemainingInputs = NumInputs % NumTasks;
+    IterTy TBegin = Begin;
+    for (size_t TaskId = 0; TaskId < NumTasks; ++TaskId) {
+      IterTy TEnd = TBegin + TaskSize + (TaskId < RemainingInputs ? 1 : 0);
+      TG.spawn([=, &Transform, &Reduce, &Results] {
+        // Reduce the result of transformation eagerly within each task.
+        ResultTy R = Init;
+        for (IterTy It = TBegin; It != TEnd; ++It)
+          R = Reduce(R, Transform(*It));
+        Results[TaskId] = R;
+      });
+      TBegin = TEnd;
+    }
+    assert(TBegin == End);
+  }
+
+  // Do a final reduction. There are at most 1024 tasks, so this only adds
+  // constant single-threaded overhead for large inputs. Hopefully most
+  // reductions are cheaper than the transformation.
+  ResultTy FinalResult = std::move(Results.front());
+  for (ResultTy &PartialResult :
+       makeMutableArrayRef(Results.data() + 1, Results.size() - 1))
+    FinalResult = Reduce(FinalResult, std::move(PartialResult));
+  return std::move(FinalResult);
+}
 
 #endif
 
-template <typename Iter>
-using DefComparator =
-    std::less<typename std::iterator_traits<Iter>::value_type>;
-
 } // namespace detail
+} // namespace parallel
 
-// sequential algorithm implementations.
-template <class Policy, class RandomAccessIterator,
-          class Comparator = detail::DefComparator<RandomAccessIterator>>
-void sort(Policy policy, RandomAccessIterator Start, RandomAccessIterator End,
-          const Comparator &Comp = Comparator()) {
-  static_assert(is_execution_policy<Policy>::value,
-                "Invalid execution policy!");
+template <class RandomAccessIterator,
+          class Comparator = std::less<
+              typename std::iterator_traits<RandomAccessIterator>::value_type>>
+void parallelSort(RandomAccessIterator Start, RandomAccessIterator End,
+                  const Comparator &Comp = Comparator()) {
+#if LLVM_ENABLE_THREADS
+  if (parallel::strategy.ThreadsRequested != 1) {
+    parallel::detail::parallel_sort(Start, End, Comp);
+    return;
+  }
+#endif
   llvm::sort(Start, End, Comp);
 }
 
-template <class Policy, class IterTy, class FuncTy>
-void for_each(Policy policy, IterTy Begin, IterTy End, FuncTy Fn) {
-  static_assert(is_execution_policy<Policy>::value,
-                "Invalid execution policy!");
+template <class IterTy, class FuncTy>
+void parallelForEach(IterTy Begin, IterTy End, FuncTy Fn) {
+#if LLVM_ENABLE_THREADS
+  if (parallel::strategy.ThreadsRequested != 1) {
+    parallel::detail::parallel_for_each(Begin, End, Fn);
+    return;
+  }
+#endif
   std::for_each(Begin, End, Fn);
 }
 
-template <class Policy, class IndexTy, class FuncTy>
-void for_each_n(Policy policy, IndexTy Begin, IndexTy End, FuncTy Fn) {
-  static_assert(is_execution_policy<Policy>::value,
-                "Invalid execution policy!");
-  for (IndexTy I = Begin; I != End; ++I)
+template <class FuncTy>
+void parallelForEachN(size_t Begin, size_t End, FuncTy Fn) {
+#if LLVM_ENABLE_THREADS
+  if (parallel::strategy.ThreadsRequested != 1) {
+    parallel::detail::parallel_for_each_n(Begin, End, Fn);
+    return;
+  }
+#endif
+  for (size_t I = Begin; I != End; ++I)
     Fn(I);
 }
 
-// Parallel algorithm implementations, only available when LLVM_ENABLE_THREADS
-// is true.
+template <class IterTy, class ResultTy, class ReduceFuncTy,
+          class TransformFuncTy>
+ResultTy parallelTransformReduce(IterTy Begin, IterTy End, ResultTy Init,
+                                 ReduceFuncTy Reduce,
+                                 TransformFuncTy Transform) {
 #if LLVM_ENABLE_THREADS
-template <class RandomAccessIterator,
-          class Comparator = detail::DefComparator<RandomAccessIterator>>
-void sort(parallel_execution_policy policy, RandomAccessIterator Start,
-          RandomAccessIterator End, const Comparator &Comp = Comparator()) {
-  detail::parallel_sort(Start, End, Comp);
-}
-
-template <class IterTy, class FuncTy>
-void for_each(parallel_execution_policy policy, IterTy Begin, IterTy End,
-              FuncTy Fn) {
-  detail::parallel_for_each(Begin, End, Fn);
-}
-
-template <class IndexTy, class FuncTy>
-void for_each_n(parallel_execution_policy policy, IndexTy Begin, IndexTy End,
-                FuncTy Fn) {
-  detail::parallel_for_each_n(Begin, End, Fn);
-}
+  if (parallel::strategy.ThreadsRequested != 1) {
+    return parallel::detail::parallel_transform_reduce(Begin, End, Init, Reduce,
+                                                       Transform);
+  }
 #endif
+  for (IterTy I = Begin; I != End; ++I)
+    Init = Reduce(std::move(Init), Transform(*I));
+  return std::move(Init);
+}
 
-} // namespace parallel
+// Range wrappers.
+template <class RangeTy,
+          class Comparator = std::less<decltype(*std::begin(RangeTy()))>>
+void parallelSort(RangeTy &&R, const Comparator &Comp = Comparator()) {
+  parallelSort(std::begin(R), std::end(R), Comp);
+}
+
+template <class RangeTy, class FuncTy>
+void parallelForEach(RangeTy &&R, FuncTy Fn) {
+  parallelForEach(std::begin(R), std::end(R), Fn);
+}
+
+template <class RangeTy, class ResultTy, class ReduceFuncTy,
+          class TransformFuncTy>
+ResultTy parallelTransformReduce(RangeTy &&R, ResultTy Init,
+                                 ReduceFuncTy Reduce,
+                                 TransformFuncTy Transform) {
+  return parallelTransformReduce(std::begin(R), std::end(R), Init, Reduce,
+                                 Transform);
+}
+
+// Parallel for-each, but with error handling.
+template <class RangeTy, class FuncTy>
+Error parallelForEachError(RangeTy &&R, FuncTy Fn) {
+  // The transform_reduce algorithm requires that the initial value be copyable.
+  // Error objects are uncopyable. We only need to copy initial success values,
+  // so work around this mismatch via the C API. The C API represents success
+  // values with a null pointer. The joinErrors discards null values and joins
+  // multiple errors into an ErrorList.
+  return unwrap(parallelTransformReduce(
+      std::begin(R), std::end(R), wrap(Error::success()),
+      [](LLVMErrorRef Lhs, LLVMErrorRef Rhs) {
+        return wrap(joinErrors(unwrap(Lhs), unwrap(Rhs)));
+      },
+      [&Fn](auto &&V) { return wrap(Fn(V)); }));
+}
+
 } // namespace llvm
 
 #endif // LLVM_SUPPORT_PARALLEL_H
diff --git a/linux-x64/clang/include/llvm/Support/Path.h b/linux-x64/clang/include/llvm/Support/Path.h
index 5c0bee5..af70e08 100644
--- a/linux-x64/clang/include/llvm/Support/Path.h
+++ b/linux-x64/clang/include/llvm/Support/Path.h
@@ -47,15 +47,15 @@
 ///   foo/       => foo,.
 ///   /foo/bar   => /,foo,bar
 ///   ../        => ..,.
-///   C:\foo\bar => C:,/,foo,bar
+///   C:\foo\bar => C:,\,foo,bar
 /// @endcode
 class const_iterator
     : public iterator_facade_base<const_iterator, std::input_iterator_tag,
                                   const StringRef> {
-  StringRef Path;      ///< The entire path.
-  StringRef Component; ///< The current component. Not necessarily in Path.
-  size_t    Position;  ///< The iterators current position within Path.
-  Style S;             ///< The path style to use.
+  StringRef Path;          ///< The entire path.
+  StringRef Component;     ///< The current component. Not necessarily in Path.
+  size_t    Position = 0;  ///< The iterators current position within Path.
+  Style S = Style::native; ///< The path style to use.
 
   // An end iterator has Position = Path.size() + 1.
   friend const_iterator begin(StringRef path, Style style);
@@ -78,10 +78,10 @@
 class reverse_iterator
     : public iterator_facade_base<reverse_iterator, std::input_iterator_tag,
                                   const StringRef> {
-  StringRef Path;      ///< The entire path.
-  StringRef Component; ///< The current component. Not necessarily in Path.
-  size_t    Position;  ///< The iterators current position within Path.
-  Style S;             ///< The path style to use.
+  StringRef Path;          ///< The entire path.
+  StringRef Component;     ///< The current component. Not necessarily in Path.
+  size_t    Position = 0;  ///< The iterators current position within Path.
+  Style S = Style::native; ///< The path style to use.
 
   friend reverse_iterator rbegin(StringRef path, Style style);
   friend reverse_iterator rend(StringRef path);
@@ -121,6 +121,8 @@
 
 /// Remove the last component from \a path unless it is the root dir.
 ///
+/// Similar to the POSIX "dirname" utility.
+///
 /// @code
 ///   directory/filename.cpp => directory/
 ///   directory/             => directory
@@ -150,8 +152,14 @@
 ///
 /// @code
 ///   /foo, /old, /new => /foo
+///   /old, /old, /new => /new
+///   /old, /old/, /new => /old
 ///   /old/foo, /old, /new => /new/foo
+///   /old/foo, /old/, /new => /new/foo
+///   /old/foo, /old/, /new/ => /new/foo
+///   /oldfoo, /old, /new => /oldfoo
 ///   /foo, <empty>, /new => /new/foo
+///   /foo, <empty>, new => new/foo
 ///   /old/foo, /old, <empty> => /foo
 /// @endcode
 ///
@@ -159,8 +167,11 @@
 ///        start with \a NewPrefix.
 /// @param OldPrefix The path prefix to strip from \a Path.
 /// @param NewPrefix The path prefix to replace \a NewPrefix with.
-void replace_path_prefix(SmallVectorImpl<char> &Path,
-                         const StringRef &OldPrefix, const StringRef &NewPrefix,
+/// @param style The style used to match the prefix. Exact match using
+/// Posix style, case/separator insensitive match for Windows style.
+/// @result true if \a Path begins with OldPrefix
+bool replace_path_prefix(SmallVectorImpl<char> &Path, StringRef OldPrefix,
+                         StringRef NewPrefix,
                          Style style = Style::native);
 
 /// Append to path.
@@ -295,7 +306,7 @@
 ///
 /// @param path Input path.
 /// @result The filename part of \a path. This is defined as the last component
-///         of \a path.
+///         of \a path. Similar to the POSIX "basename" utility.
 StringRef filename(StringRef path, Style style = Style::native);
 
 /// Get stem.
@@ -360,6 +371,20 @@
 /// @result True if a home directory is set, false otherwise.
 bool home_directory(SmallVectorImpl<char> &result);
 
+/// Get the directory where packages should read user-specific configurations.
+/// e.g. $XDG_CONFIG_HOME.
+///
+/// @param result Holds the resulting path name.
+/// @result True if the appropriate path was determined, it need not exist.
+bool user_config_directory(SmallVectorImpl<char> &result);
+
+/// Get the directory where installed packages should put their
+/// machine-local cache, e.g. $XDG_CACHE_HOME.
+///
+/// @param result Holds the resulting path name.
+/// @result True if the appropriate path was determined, it need not exist.
+bool cache_directory(SmallVectorImpl<char> &result);
+
 /// Has root name?
 ///
 /// root_name != ""
@@ -426,10 +451,48 @@
 
 /// Is path absolute?
 ///
+/// According to cppreference.com, C++17 states: "An absolute path is a path
+/// that unambiguously identifies the location of a file without reference to
+/// an additional starting location."
+///
+/// In other words, the rules are:
+/// 1) POSIX style paths with nonempty root directory are absolute.
+/// 2) Windows style paths with nonempty root name and root directory are
+///    absolute.
+/// 3) No other paths are absolute.
+///
+/// \see has_root_name
+/// \see has_root_directory
+///
 /// @param path Input path.
 /// @result True if the path is absolute, false if it is not.
 bool is_absolute(const Twine &path, Style style = Style::native);
 
+/// Is path absolute using GNU rules?
+///
+/// GNU rules are:
+/// 1) Paths starting with a path separator are absolute.
+/// 2) Windows style paths are also absolute if they start with a character
+///    followed by ':'.
+/// 3) No other paths are absolute.
+///
+/// On Windows style the path "C:\Users\Default" has "C:" as root name and "\"
+/// as root directory.
+///
+/// Hence "C:" on Windows is absolute under GNU rules and not absolute under
+/// C++17 because it has no root directory. Likewise "/" and "\" on Windows are
+/// absolute under GNU and are not absolute under C++17 due to empty root name.
+///
+/// \see has_root_name
+/// \see has_root_directory
+///
+/// @param path Input path.
+/// @param style The style of \p path (e.g. Windows or POSIX). "native" style
+/// means to derive the style from the host.
+/// @result True if the path is absolute following GNU rules, false if it is
+/// not.
+bool is_absolute_gnu(const Twine &path, Style style = Style::native);
+
 /// Is path relative?
 ///
 /// @param path Input path.
@@ -451,10 +514,6 @@
 bool remove_dots(SmallVectorImpl<char> &path, bool remove_dot_dot = false,
                  Style style = Style::native);
 
-#if defined(_WIN32)
-std::error_code widenPath(const Twine &Path8, SmallVectorImpl<wchar_t> &Path16);
-#endif
-
 } // end namespace path
 } // end namespace sys
 } // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/Support/PluginLoader.h b/linux-x64/clang/include/llvm/Support/PluginLoader.h
index c0c516b..95c087f 100644
--- a/linux-x64/clang/include/llvm/Support/PluginLoader.h
+++ b/linux-x64/clang/include/llvm/Support/PluginLoader.h
@@ -16,7 +16,11 @@
 #ifndef LLVM_SUPPORT_PLUGINLOADER_H
 #define LLVM_SUPPORT_PLUGINLOADER_H
 
+#ifndef DONT_GET_PLUGIN_LOADER_OPTION
 #include "llvm/Support/CommandLine.h"
+#endif
+
+#include <string>
 
 namespace llvm {
   struct PluginLoader {
diff --git a/linux-x64/clang/include/llvm/Support/PointerLikeTypeTraits.h b/linux-x64/clang/include/llvm/Support/PointerLikeTypeTraits.h
index 1e7e5b5..1b15f93 100644
--- a/linux-x64/clang/include/llvm/Support/PointerLikeTypeTraits.h
+++ b/linux-x64/clang/include/llvm/Support/PointerLikeTypeTraits.h
@@ -15,7 +15,7 @@
 #define LLVM_SUPPORT_POINTERLIKETYPETRAITS_H
 
 #include "llvm/Support/DataTypes.h"
-#include <assert.h>
+#include <cassert>
 #include <type_traits>
 
 namespace llvm {
@@ -37,8 +37,9 @@
 };
 
 // sizeof(T) is valid only for a complete T.
-template <typename T> struct HasPointerLikeTypeTraits<
-  T, decltype((sizeof(PointerLikeTypeTraits<T>) + sizeof(T)), void())> {
+template <typename T>
+struct HasPointerLikeTypeTraits<
+    T, decltype((sizeof(PointerLikeTypeTraits<T>) + sizeof(T)), void())> {
   static const bool value = true;
 };
 
@@ -56,7 +57,8 @@
   static inline void *getAsVoidPointer(T *P) { return P; }
   static inline T *getFromVoidPointer(void *P) { return static_cast<T *>(P); }
 
-  enum { NumLowBitsAvailable = detail::ConstantLog2<alignof(T)>::value };
+  static constexpr int NumLowBitsAvailable =
+      detail::ConstantLog2<alignof(T)>::value;
 };
 
 template <> struct PointerLikeTypeTraits<void *> {
@@ -70,7 +72,7 @@
   ///
   /// All clients should use assertions to do a run-time check to ensure that
   /// this is actually true.
-  enum { NumLowBitsAvailable = 2 };
+  static constexpr int NumLowBitsAvailable = 2;
 };
 
 // Provide PointerLikeTypeTraits for const things.
@@ -83,7 +85,7 @@
   static inline const T getFromVoidPointer(const void *P) {
     return NonConst::getFromVoidPointer(const_cast<void *>(P));
   }
-  enum { NumLowBitsAvailable = NonConst::NumLowBitsAvailable };
+  static constexpr int NumLowBitsAvailable = NonConst::NumLowBitsAvailable;
 };
 
 // Provide PointerLikeTypeTraits for const pointers.
@@ -96,7 +98,7 @@
   static inline const T *getFromVoidPointer(const void *P) {
     return NonConst::getFromVoidPointer(const_cast<void *>(P));
   }
-  enum { NumLowBitsAvailable = NonConst::NumLowBitsAvailable };
+  static constexpr int NumLowBitsAvailable = NonConst::NumLowBitsAvailable;
 };
 
 // Provide PointerLikeTypeTraits for uintptr_t.
@@ -108,7 +110,7 @@
     return reinterpret_cast<uintptr_t>(P);
   }
   // No bits are available!
-  enum { NumLowBitsAvailable = 0 };
+  static constexpr int NumLowBitsAvailable = 0;
 };
 
 /// Provide suitable custom traits struct for function pointers.
@@ -121,7 +123,8 @@
 /// potentially use alignment attributes on functions to satisfy that.
 template <int Alignment, typename FunctionPointerT>
 struct FunctionPointerLikeTypeTraits {
-  enum { NumLowBitsAvailable = detail::ConstantLog2<Alignment>::value };
+  static constexpr int NumLowBitsAvailable =
+      detail::ConstantLog2<Alignment>::value;
   static inline void *getAsVoidPointer(FunctionPointerT P) {
     assert((reinterpret_cast<uintptr_t>(P) &
             ~((uintptr_t)-1 << NumLowBitsAvailable)) == 0 &&
diff --git a/linux-x64/clang/include/llvm/Support/PrettyStackTrace.h b/linux-x64/clang/include/llvm/Support/PrettyStackTrace.h
index f6ed7c9..ac25cff 100644
--- a/linux-x64/clang/include/llvm/Support/PrettyStackTrace.h
+++ b/linux-x64/clang/include/llvm/Support/PrettyStackTrace.h
@@ -21,8 +21,29 @@
 namespace llvm {
   class raw_ostream;
 
+  /// Enables dumping a "pretty" stack trace when the program crashes.
+  ///
+  /// \see PrettyStackTraceEntry
   void EnablePrettyStackTrace();
 
+  /// Enables (or disables) dumping a "pretty" stack trace when the user sends
+  /// SIGINFO or SIGUSR1 to the current process.
+  ///
+  /// This is a per-thread decision so that a program can choose to print stack
+  /// traces only on a primary thread, or on all threads that use
+  /// PrettyStackTraceEntry.
+  ///
+  /// \see EnablePrettyStackTrace
+  /// \see PrettyStackTraceEntry
+  void EnablePrettyStackTraceOnSigInfoForThisThread(bool ShouldEnable = true);
+
+  /// Replaces the generic bug report message that is output upon
+  /// a crash.
+  void setBugReportMsg(const char *Msg);
+
+  /// Get the bug report message that will be output upon a crash.
+  const char *getBugReportMsg();
+
   /// PrettyStackTraceEntry - This class is used to represent a frame of the
   /// "pretty" stack trace that is dumped when a program crashes. You can define
   /// subclasses of this and declare them on the program stack: when they are
diff --git a/linux-x64/clang/include/llvm/Support/Process.h b/linux-x64/clang/include/llvm/Support/Process.h
index 67e3791..729917b 100644
--- a/linux-x64/clang/include/llvm/Support/Process.h
+++ b/linux-x64/clang/include/llvm/Support/Process.h
@@ -25,10 +25,11 @@
 #define LLVM_SUPPORT_PROCESS_H
 
 #include "llvm/ADT/Optional.h"
-#include "llvm/Support/Allocator.h"
+#include "llvm/Support/AllocatorBase.h"
 #include "llvm/Support/Chrono.h"
 #include "llvm/Support/DataTypes.h"
 #include "llvm/Support/Error.h"
+#include "llvm/Support/Program.h"
 #include <system_error>
 
 namespace llvm {
@@ -42,6 +43,11 @@
 /// current executing process.
 class Process {
 public:
+  using Pid = int32_t;
+
+  /// Get the process's identifier.
+  static Pid getProcessId();
+
   /// Get the process's page size.
   /// This may fail if the underlying syscall returns an error. In most cases,
   /// page size information is used for optimization, and this error can be
@@ -102,10 +108,12 @@
   /// considered.
   static Optional<std::string> FindInEnvPath(StringRef EnvName,
                                              StringRef FileName,
-                                             ArrayRef<std::string> IgnoreList);
+                                             ArrayRef<std::string> IgnoreList,
+                                             char Separator = EnvPathSeparator);
 
   static Optional<std::string> FindInEnvPath(StringRef EnvName,
-                                             StringRef FileName);
+                                             StringRef FileName,
+                                             char Separator = EnvPathSeparator);
 
   // This functions ensures that the standard file descriptors (input, output,
   // and error) are properly mapped to a file descriptor before we use any of
@@ -201,6 +209,13 @@
   /// Get the result of a process wide random number generator. The
   /// generator will be automatically seeded in non-deterministic fashion.
   static unsigned GetRandomNumber();
+
+  /// Equivalent to ::exit(), except when running inside a CrashRecoveryContext.
+  /// In that case, the control flow will resume after RunSafely(), like for a
+  /// crash, rather than exiting the current process.
+  /// Use \arg NoCleanup for calling _exit() instead of exit().
+  LLVM_ATTRIBUTE_NORETURN
+  static void Exit(int RetCode, bool NoCleanup = false);
 };
 
 }
diff --git a/linux-x64/clang/include/llvm/Support/Program.h b/linux-x64/clang/include/llvm/Support/Program.h
index 6b2315c..bfd2719 100644
--- a/linux-x64/clang/include/llvm/Support/Program.h
+++ b/linux-x64/clang/include/llvm/Support/Program.h
@@ -14,10 +14,12 @@
 #define LLVM_SUPPORT_PROGRAM_H
 
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/BitVector.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Config/llvm-config.h"
 #include "llvm/Support/ErrorOr.h"
+#include <chrono>
 #include <system_error>
 
 namespace llvm {
@@ -35,7 +37,7 @@
   typedef unsigned long procid_t; // Must match the type of DWORD on Windows.
   typedef void *process_t;        // Must match the type of HANDLE on Windows.
 #else
-  typedef pid_t procid_t;
+  typedef ::pid_t procid_t;
   typedef procid_t process_t;
 #endif
 
@@ -52,6 +54,13 @@
     ProcessInfo();
   };
 
+  /// This struct encapsulates information about a process execution.
+  struct ProcessStatistics {
+    std::chrono::microseconds TotalTime;
+    std::chrono::microseconds UserTime;
+    uint64_t PeakMemory = 0; ///< Maximum resident set size in KiB.
+  };
+
   /// Find the first executable file \p Name in \p Paths.
   ///
   /// This does not perform hashing as a shell would but instead stats each PATH
@@ -116,10 +125,16 @@
       ///< string instance in which error messages will be returned. If the
       ///< string is non-empty upon return an error occurred while invoking the
       ///< program.
-      bool *ExecutionFailed = nullptr);
+      bool *ExecutionFailed = nullptr,
+      Optional<ProcessStatistics> *ProcStat = nullptr, ///< If non-zero,
+      /// provides a pointer to a structure in which process execution
+      /// statistics will be stored.
+      BitVector *AffinityMask = nullptr ///< CPUs or processors the new
+                                        /// program shall run on.
+  );
 
   /// Similar to ExecuteAndWait, but returns immediately.
-  /// @returns The \see ProcessInfo of the newly launced process.
+  /// @returns The \see ProcessInfo of the newly launched process.
   /// \note On Microsoft Windows systems, users will need to either call
   /// \see Wait until the process finished execution or win32 CloseHandle() API
   /// on ProcessInfo.ProcessHandle to avoid memory leaks.
@@ -128,7 +143,8 @@
                             ArrayRef<Optional<StringRef>> Redirects = {},
                             unsigned MemoryLimit = 0,
                             std::string *ErrMsg = nullptr,
-                            bool *ExecutionFailed = nullptr);
+                            bool *ExecutionFailed = nullptr,
+                            BitVector *AffinityMask = nullptr);
 
   /// Return true if the given arguments fit within system-specific
   /// argument length limits.
@@ -182,25 +198,31 @@
   /// \note Users of this function should always check the ReturnCode member of
   /// the \see ProcessInfo returned from this function.
   ProcessInfo Wait(
-      const ProcessInfo &PI, ///< The child process that should be waited on.
+      const ProcessInfo &PI,  ///< The child process that should be waited on.
       unsigned SecondsToWait, ///< If non-zero, this specifies the amount of
       ///< time to wait for the child process to exit. If the time expires, the
       ///< child is killed and this function returns. If zero, this function
       ///< will perform a non-blocking wait on the child process.
       bool WaitUntilTerminates, ///< If true, ignores \p SecondsToWait and waits
       ///< until child has terminated.
-      std::string *ErrMsg = nullptr ///< If non-zero, provides a pointer to a
+      std::string *ErrMsg = nullptr, ///< If non-zero, provides a pointer to a
       ///< string instance in which error messages will be returned. If the
       ///< string is non-empty upon return an error occurred while invoking the
       ///< program.
-      );
+      Optional<ProcessStatistics> *ProcStat = nullptr ///< If non-zero, provides
+      /// a pointer to a structure in which process execution statistics will be
+      /// stored.
+  );
+
+  /// Print a command argument, and optionally quote it.
+  void printArg(llvm::raw_ostream &OS, StringRef Arg, bool Quote);
 
 #if defined(_WIN32)
   /// Given a list of command line arguments, quote and escape them as necessary
   /// to build a single flat command line appropriate for calling CreateProcess
   /// on
   /// Windows.
-  std::string flattenWindowsCommandLine(ArrayRef<StringRef> Args);
+  ErrorOr<std::wstring> flattenWindowsCommandLine(ArrayRef<StringRef> Args);
 #endif
   }
 }
diff --git a/linux-x64/clang/include/llvm/Support/RISCVAttributeParser.h b/linux-x64/clang/include/llvm/Support/RISCVAttributeParser.h
new file mode 100644
index 0000000..3e62941
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Support/RISCVAttributeParser.h
@@ -0,0 +1,37 @@
+//===-- RISCVAttributeParser.h - RISCV Attribute Parser ---------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_SUPPORT_RISCVATTRIBUTEPARSER_H
+#define LLVM_SUPPORT_RISCVATTRIBUTEPARSER_H
+
+#include "llvm/Support/ELFAttributeParser.h"
+#include "llvm/Support/RISCVAttributes.h"
+
+namespace llvm {
+class RISCVAttributeParser : public ELFAttributeParser {
+  struct DisplayHandler {
+    RISCVAttrs::AttrType attribute;
+    Error (RISCVAttributeParser::*routine)(unsigned);
+  };
+  static const DisplayHandler displayRoutines[];
+
+  Error handler(uint64_t tag, bool &handled) override;
+
+  Error unalignedAccess(unsigned tag);
+  Error stackAlign(unsigned tag);
+
+public:
+  RISCVAttributeParser(ScopedPrinter *sw)
+      : ELFAttributeParser(sw, RISCVAttrs::RISCVAttributeTags, "riscv") {}
+  RISCVAttributeParser()
+      : ELFAttributeParser(RISCVAttrs::RISCVAttributeTags, "riscv") {}
+};
+
+} // namespace llvm
+
+#endif
diff --git a/linux-x64/clang/include/llvm/Support/RISCVAttributes.h b/linux-x64/clang/include/llvm/Support/RISCVAttributes.h
new file mode 100644
index 0000000..caded95
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Support/RISCVAttributes.h
@@ -0,0 +1,44 @@
+//===-- RISCVAttributes.h - RISCV Attributes --------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains enumerations for RISCV attributes as defined in RISC-V
+// ELF psABI specification.
+//
+// RISC-V ELF psABI specification
+//
+// https://github.com/riscv/riscv-elf-psabi-doc/blob/master/riscv-elf.md
+//
+//===----------------------------------------------------------------------===//
+#ifndef LLVM_SUPPORT_RISCVATTRIBUTES_H
+#define LLVM_SUPPORT_RISCVATTRIBUTES_H
+
+#include "llvm/Support/ELFAttributes.h"
+
+namespace llvm {
+namespace RISCVAttrs {
+
+extern const TagNameMap RISCVAttributeTags;
+
+enum AttrType : unsigned {
+  // Attribute types in ELF/.riscv.attributes.
+  STACK_ALIGN = 4,
+  ARCH = 5,
+  UNALIGNED_ACCESS = 6,
+  PRIV_SPEC = 8,
+  PRIV_SPEC_MINOR = 10,
+  PRIV_SPEC_REVISION = 12,
+};
+
+enum StackAlign { ALIGN_4 = 4, ALIGN_16 = 16 };
+
+enum { NOT_ALLOWED = 0, ALLOWED = 1 };
+
+} // namespace RISCVAttrs
+} // namespace llvm
+
+#endif
diff --git a/linux-x64/clang/include/llvm/Support/RISCVTargetParser.def b/linux-x64/clang/include/llvm/Support/RISCVTargetParser.def
new file mode 100644
index 0000000..6a06f92
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Support/RISCVTargetParser.def
@@ -0,0 +1,27 @@
+#ifndef PROC_ALIAS
+#define PROC_ALIAS(NAME, RV32, RV64)
+#endif
+
+PROC_ALIAS("generic", "generic-rv32", "generic-rv64")
+PROC_ALIAS("rocket", "rocket-rv32", "rocket-rv64")
+PROC_ALIAS("sifive-7-series", "sifive-7-rv32", "sifive-7-rv64")
+
+#undef PROC_ALIAS
+
+#ifndef PROC
+#define PROC(ENUM, NAME, FEATURES, DEFAULT_MARCH)
+#endif
+
+PROC(INVALID, {"invalid"}, FK_INVALID, {""})
+PROC(GENERIC_RV32, {"generic-rv32"}, FK_NONE, {""})
+PROC(GENERIC_RV64, {"generic-rv64"}, FK_64BIT, {""})
+PROC(ROCKET_RV32, {"rocket-rv32"}, FK_NONE, {""})
+PROC(ROCKET_RV64, {"rocket-rv64"}, FK_64BIT, {""})
+PROC(SIFIVE_732, {"sifive-7-rv32"}, FK_NONE, {""})
+PROC(SIFIVE_764, {"sifive-7-rv64"}, FK_64BIT, {""})
+PROC(SIFIVE_E31, {"sifive-e31"}, FK_NONE, {"rv32imac"})
+PROC(SIFIVE_U54, {"sifive-u54"}, FK_64BIT, {"rv64gc"})
+PROC(SIFIVE_E76, {"sifive-e76"}, FK_NONE, {"rv32imafc"})
+PROC(SIFIVE_U74, {"sifive-u74"}, FK_64BIT, {"rv64gc"})
+
+#undef PROC
diff --git a/linux-x64/clang/include/llvm/Support/RWMutex.h b/linux-x64/clang/include/llvm/Support/RWMutex.h
index 9cd57cb..150bc7d 100644
--- a/linux-x64/clang/include/llvm/Support/RWMutex.h
+++ b/linux-x64/clang/include/llvm/Support/RWMutex.h
@@ -16,161 +16,184 @@
 #include "llvm/Config/llvm-config.h"
 #include "llvm/Support/Threading.h"
 #include <cassert>
+#include <mutex>
+#include <shared_mutex>
+
+// std::shared_timed_mutex is only availble on macOS 10.12 and later.
+#if defined(__APPLE__) && defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__)
+#if __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 101200
+#define LLVM_USE_RW_MUTEX_IMPL
+#endif
+#endif
 
 namespace llvm {
 namespace sys {
 
-    /// Platform agnostic RWMutex class.
-    class RWMutexImpl
-    {
-    /// @name Constructors
-    /// @{
-    public:
+#if defined(LLVM_USE_RW_MUTEX_IMPL)
+/// Platform agnostic RWMutex class.
+class RWMutexImpl {
+  /// @name Constructors
+  /// @{
+public:
+  /// Initializes the lock but doesn't acquire it.
+  /// Default Constructor.
+  explicit RWMutexImpl();
 
-      /// Initializes the lock but doesn't acquire it.
-      /// Default Constructor.
-      explicit RWMutexImpl();
+  /// @}
+  /// @name Do Not Implement
+  /// @{
+  RWMutexImpl(const RWMutexImpl &original) = delete;
+  RWMutexImpl &operator=(const RWMutexImpl &) = delete;
+  /// @}
 
-    /// @}
-    /// @name Do Not Implement
-    /// @{
-      RWMutexImpl(const RWMutexImpl & original) = delete;
-      RWMutexImpl &operator=(const RWMutexImpl &) = delete;
-    /// @}
+  /// Releases and removes the lock
+  /// Destructor
+  ~RWMutexImpl();
 
-      /// Releases and removes the lock
-      /// Destructor
-      ~RWMutexImpl();
+  /// @}
+  /// @name Methods
+  /// @{
+public:
+  /// Attempts to unconditionally acquire the lock in reader mode. If the
+  /// lock is held by a writer, this method will wait until it can acquire
+  /// the lock.
+  /// @returns false if any kind of error occurs, true otherwise.
+  /// Unconditionally acquire the lock in reader mode.
+  bool lock_shared();
 
-    /// @}
-    /// @name Methods
-    /// @{
-    public:
+  /// Attempts to release the lock in reader mode.
+  /// @returns false if any kind of error occurs, true otherwise.
+  /// Unconditionally release the lock in reader mode.
+  bool unlock_shared();
 
-      /// Attempts to unconditionally acquire the lock in reader mode. If the
-      /// lock is held by a writer, this method will wait until it can acquire
-      /// the lock.
-      /// @returns false if any kind of error occurs, true otherwise.
-      /// Unconditionally acquire the lock in reader mode.
-      bool reader_acquire();
+  /// Attempts to unconditionally acquire the lock in reader mode. If the
+  /// lock is held by any readers, this method will wait until it can
+  /// acquire the lock.
+  /// @returns false if any kind of error occurs, true otherwise.
+  /// Unconditionally acquire the lock in writer mode.
+  bool lock();
 
-      /// Attempts to release the lock in reader mode.
-      /// @returns false if any kind of error occurs, true otherwise.
-      /// Unconditionally release the lock in reader mode.
-      bool reader_release();
+  /// Attempts to release the lock in writer mode.
+  /// @returns false if any kind of error occurs, true otherwise.
+  /// Unconditionally release the lock in write mode.
+  bool unlock();
 
-      /// Attempts to unconditionally acquire the lock in reader mode. If the
-      /// lock is held by any readers, this method will wait until it can
-      /// acquire the lock.
-      /// @returns false if any kind of error occurs, true otherwise.
-      /// Unconditionally acquire the lock in writer mode.
-      bool writer_acquire();
-
-      /// Attempts to release the lock in writer mode.
-      /// @returns false if any kind of error occurs, true otherwise.
-      /// Unconditionally release the lock in write mode.
-      bool writer_release();
-
-    //@}
-    /// @name Platform Dependent Data
-    /// @{
-    private:
+  //@}
+  /// @name Platform Dependent Data
+  /// @{
+private:
 #if defined(LLVM_ENABLE_THREADS) && LLVM_ENABLE_THREADS != 0
-      void* data_ = nullptr; ///< We don't know what the data will be
+  void *data_ = nullptr; ///< We don't know what the data will be
 #endif
-    };
+};
+#endif
 
-    /// SmartMutex - An R/W mutex with a compile time constant parameter that
-    /// indicates whether this mutex should become a no-op when we're not
-    /// running in multithreaded mode.
-    template<bool mt_only>
-    class SmartRWMutex {
-      RWMutexImpl impl;
-      unsigned readers = 0;
-      unsigned writers = 0;
+/// SmartMutex - An R/W mutex with a compile time constant parameter that
+/// indicates whether this mutex should become a no-op when we're not
+/// running in multithreaded mode.
+template <bool mt_only> class SmartRWMutex {
+  // shared_mutex (C++17) is more efficient than shared_timed_mutex (C++14)
+  // on Windows and always available on MSVC.
+#if defined(_MSC_VER) || __cplusplus > 201402L
+  std::shared_mutex impl;
+#else
+#if !defined(LLVM_USE_RW_MUTEX_IMPL)
+  std::shared_timed_mutex impl;
+#else
+  RWMutexImpl impl;
+#endif
+#endif
+  unsigned readers = 0;
+  unsigned writers = 0;
 
-    public:
-      explicit SmartRWMutex() = default;
-      SmartRWMutex(const SmartRWMutex<mt_only> & original) = delete;
-      SmartRWMutex<mt_only> &operator=(const SmartRWMutex<mt_only> &) = delete;
+public:
+  bool lock_shared() {
+    if (!mt_only || llvm_is_multithreaded()) {
+      impl.lock_shared();
+      return true;
+    }
 
-      bool lock_shared() {
-        if (!mt_only || llvm_is_multithreaded())
-          return impl.reader_acquire();
+    // Single-threaded debugging code.  This would be racy in multithreaded
+    // mode, but provides not sanity checks in single threaded mode.
+    ++readers;
+    return true;
+  }
 
-        // Single-threaded debugging code.  This would be racy in multithreaded
-        // mode, but provides not sanity checks in single threaded mode.
-        ++readers;
-        return true;
-      }
+  bool unlock_shared() {
+    if (!mt_only || llvm_is_multithreaded()) {
+      impl.unlock_shared();
+      return true;
+    }
 
-      bool unlock_shared() {
-        if (!mt_only || llvm_is_multithreaded())
-          return impl.reader_release();
+    // Single-threaded debugging code.  This would be racy in multithreaded
+    // mode, but provides not sanity checks in single threaded mode.
+    assert(readers > 0 && "Reader lock not acquired before release!");
+    --readers;
+    return true;
+  }
 
-        // Single-threaded debugging code.  This would be racy in multithreaded
-        // mode, but provides not sanity checks in single threaded mode.
-        assert(readers > 0 && "Reader lock not acquired before release!");
-        --readers;
-        return true;
-      }
+  bool lock() {
+    if (!mt_only || llvm_is_multithreaded()) {
+      impl.lock();
+      return true;
+    }
 
-      bool lock() {
-        if (!mt_only || llvm_is_multithreaded())
-          return impl.writer_acquire();
+    // Single-threaded debugging code.  This would be racy in multithreaded
+    // mode, but provides not sanity checks in single threaded mode.
+    assert(writers == 0 && "Writer lock already acquired!");
+    ++writers;
+    return true;
+  }
 
-        // Single-threaded debugging code.  This would be racy in multithreaded
-        // mode, but provides not sanity checks in single threaded mode.
-        assert(writers == 0 && "Writer lock already acquired!");
-        ++writers;
-        return true;
-      }
+  bool unlock() {
+    if (!mt_only || llvm_is_multithreaded()) {
+      impl.unlock();
+      return true;
+    }
 
-      bool unlock() {
-        if (!mt_only || llvm_is_multithreaded())
-          return impl.writer_release();
+    // Single-threaded debugging code.  This would be racy in multithreaded
+    // mode, but provides not sanity checks in single threaded mode.
+    assert(writers == 1 && "Writer lock not acquired before release!");
+    --writers;
+    return true;
+  }
+};
 
-        // Single-threaded debugging code.  This would be racy in multithreaded
-        // mode, but provides not sanity checks in single threaded mode.
-        assert(writers == 1 && "Writer lock not acquired before release!");
-        --writers;
-        return true;
-      }
-    };
+typedef SmartRWMutex<false> RWMutex;
 
-    typedef SmartRWMutex<false> RWMutex;
+/// ScopedReader - RAII acquisition of a reader lock
+#if !defined(LLVM_USE_RW_MUTEX_IMPL)
+template <bool mt_only>
+using SmartScopedReader = const std::shared_lock<SmartRWMutex<mt_only>>;
+#else
+template <bool mt_only> struct SmartScopedReader {
+  SmartRWMutex<mt_only> &mutex;
 
-    /// ScopedReader - RAII acquisition of a reader lock
-    template<bool mt_only>
-    struct SmartScopedReader {
-      SmartRWMutex<mt_only>& mutex;
+  explicit SmartScopedReader(SmartRWMutex<mt_only> &m) : mutex(m) {
+    mutex.lock_shared();
+  }
 
-      explicit SmartScopedReader(SmartRWMutex<mt_only>& m) : mutex(m) {
-        mutex.lock_shared();
-      }
+  ~SmartScopedReader() { mutex.unlock_shared(); }
+};
+#endif
+typedef SmartScopedReader<false> ScopedReader;
 
-      ~SmartScopedReader() {
-        mutex.unlock_shared();
-      }
-    };
+/// ScopedWriter - RAII acquisition of a writer lock
+#if !defined(LLVM_USE_RW_MUTEX_IMPL)
+template <bool mt_only>
+using SmartScopedWriter = std::lock_guard<SmartRWMutex<mt_only>>;
+#else
+template <bool mt_only> struct SmartScopedWriter {
+  SmartRWMutex<mt_only> &mutex;
 
-    typedef SmartScopedReader<false> ScopedReader;
+  explicit SmartScopedWriter(SmartRWMutex<mt_only> &m) : mutex(m) {
+    mutex.lock();
+  }
 
-    /// ScopedWriter - RAII acquisition of a writer lock
-    template<bool mt_only>
-    struct SmartScopedWriter {
-      SmartRWMutex<mt_only>& mutex;
-
-      explicit SmartScopedWriter(SmartRWMutex<mt_only>& m) : mutex(m) {
-        mutex.lock();
-      }
-
-      ~SmartScopedWriter() {
-        mutex.unlock();
-      }
-    };
-
-    typedef SmartScopedWriter<false> ScopedWriter;
+  ~SmartScopedWriter() { mutex.unlock(); }
+};
+#endif
+typedef SmartScopedWriter<false> ScopedWriter;
 
 } // end namespace sys
 } // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/Support/Regex.h b/linux-x64/clang/include/llvm/Support/Regex.h
index 2d19b10..ae4b951 100644
--- a/linux-x64/clang/include/llvm/Support/Regex.h
+++ b/linux-x64/clang/include/llvm/Support/Regex.h
@@ -16,6 +16,7 @@
 #ifndef LLVM_SUPPORT_REGEX_H
 #define LLVM_SUPPORT_REGEX_H
 
+#include "llvm/ADT/BitmaskEnum.h"
 #include <string>
 
 struct llvm_regex;
@@ -26,25 +27,31 @@
 
   class Regex {
   public:
-    enum {
-      NoFlags=0,
+    enum RegexFlags : unsigned {
+      NoFlags = 0,
       /// Compile for matching that ignores upper/lower case distinctions.
-      IgnoreCase=1,
+      IgnoreCase = 1,
       /// Compile for newline-sensitive matching. With this flag '[^' bracket
       /// expressions and '.' never match newline. A ^ anchor matches the
       /// null string after any newline in the string in addition to its normal
       /// function, and the $ anchor matches the null string before any
       /// newline in the string in addition to its normal function.
-      Newline=2,
+      Newline = 2,
       /// By default, the POSIX extended regular expression (ERE) syntax is
       /// assumed. Pass this flag to turn on basic regular expressions (BRE)
       /// instead.
-      BasicRegex=4
+      BasicRegex = 4,
+
+      LLVM_MARK_AS_BITMASK_ENUM(BasicRegex)
     };
 
     Regex();
     /// Compiles the given regular expression \p Regex.
-    Regex(StringRef Regex, unsigned Flags = NoFlags);
+    ///
+    /// \param Regex - referenced string is no longer needed after this
+    /// constructor does finish.  Only its compiled form is kept stored.
+    Regex(StringRef Regex, RegexFlags Flags = NoFlags);
+    Regex(StringRef Regex, unsigned Flags);
     Regex(const Regex &) = delete;
     Regex &operator=(Regex regex) {
       std::swap(preg, regex.preg);
@@ -54,9 +61,10 @@
     Regex(Regex &&regex);
     ~Regex();
 
-    /// isValid - returns the error encountered during regex compilation, or
-    /// matching, if any.
+    /// isValid - returns the error encountered during regex compilation, if
+    /// any.
     bool isValid(std::string &Error) const;
+    bool isValid() const { return !error; }
 
     /// getNumMatches - In a valid regex, return the number of parenthesized
     /// matches it contains.  The number filled in by match will include this
@@ -69,8 +77,12 @@
     /// with references to the matched group expressions (inside \p String),
     /// the first group is always the entire pattern.
     ///
+    /// \param Error - If non-null, any errors in the matching will be recorded
+    /// as a non-empty string. If there is no error, it will be an empty string.
+    ///
     /// This returns true on a successful match.
-    bool match(StringRef String, SmallVectorImpl<StringRef> *Matches = nullptr);
+    bool match(StringRef String, SmallVectorImpl<StringRef> *Matches = nullptr,
+               std::string *Error = nullptr) const;
 
     /// sub - Return the result of replacing the first match of the regex in
     /// \p String with the \p Repl string. Backreferences like "\0" in the
@@ -81,9 +93,9 @@
     ///
     /// \param Error If non-null, any errors in the substitution (invalid
     /// backreferences, trailing backslashes) will be recorded as a non-empty
-    /// string.
+    /// string. If there is no error, it will be an empty string.
     std::string sub(StringRef Repl, StringRef String,
-                    std::string *Error = nullptr);
+                    std::string *Error = nullptr) const;
 
     /// If this function returns true, ^Str$ is an extended regular
     /// expression that matches Str and only Str.
diff --git a/linux-x64/clang/include/llvm/Support/Registry.h b/linux-x64/clang/include/llvm/Support/Registry.h
index 4d8aa5f..5bb6a25 100644
--- a/linux-x64/clang/include/llvm/Support/Registry.h
+++ b/linux-x64/clang/include/llvm/Support/Registry.h
@@ -115,7 +115,7 @@
       entry Entry;
       node Node;
 
-      static std::unique_ptr<T> CtorFn() { return make_unique<V>(); }
+      static std::unique_ptr<T> CtorFn() { return std::make_unique<V>(); }
 
     public:
       Add(StringRef Name, StringRef Desc)
diff --git a/linux-x64/clang/include/llvm/Support/SHA1.h b/linux-x64/clang/include/llvm/Support/SHA1.h
index 87fe94b..efd8513 100644
--- a/linux-x64/clang/include/llvm/Support/SHA1.h
+++ b/linux-x64/clang/include/llvm/Support/SHA1.h
@@ -15,8 +15,6 @@
 #ifndef LLVM_SUPPORT_SHA1_H
 #define LLVM_SUPPORT_SHA1_H
 
-#include "llvm/ADT/ArrayRef.h"
-
 #include <array>
 #include <cstdint>
 
@@ -36,10 +34,7 @@
   void update(ArrayRef<uint8_t> Data);
 
   /// Digest more data.
-  void update(StringRef Str) {
-    update(ArrayRef<uint8_t>((uint8_t *)const_cast<char *>(Str.data()),
-                             Str.size()));
-  }
+  void update(StringRef Str);
 
   /// Return a reference to the current raw 160-bits SHA1 for the digested data
   /// since the last call to init(). This call will add data to the internal
diff --git a/linux-x64/clang/include/llvm/Support/ScalableSize.h b/linux-x64/clang/include/llvm/Support/ScalableSize.h
deleted file mode 100644
index 96bf043..0000000
--- a/linux-x64/clang/include/llvm/Support/ScalableSize.h
+++ /dev/null
@@ -1,43 +0,0 @@
-//===- ScalableSize.h - Scalable vector size info ---------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// This file provides a struct that can be used to query the size of IR types
-// which may be scalable vectors. It provides convenience operators so that
-// it can be used in much the same way as a single scalar value.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_SUPPORT_SCALABLESIZE_H
-#define LLVM_SUPPORT_SCALABLESIZE_H
-
-namespace llvm {
-
-class ElementCount {
-public:
-  unsigned Min;  // Minimum number of vector elements.
-  bool Scalable; // If true, NumElements is a multiple of 'Min' determined
-                 // at runtime rather than compile time.
-
-  ElementCount(unsigned Min, bool Scalable)
-  : Min(Min), Scalable(Scalable) {}
-
-  ElementCount operator*(unsigned RHS) {
-    return { Min * RHS, Scalable };
-  }
-  ElementCount operator/(unsigned RHS) {
-    return { Min / RHS, Scalable };
-  }
-
-  bool operator==(const ElementCount& RHS) const {
-    return Min == RHS.Min && Scalable == RHS.Scalable;
-  }
-};
-
-} // end namespace llvm
-
-#endif // LLVM_SUPPORT_SCALABLESIZE_H
diff --git a/linux-x64/clang/include/llvm/Support/ScaledNumber.h b/linux-x64/clang/include/llvm/Support/ScaledNumber.h
index 552da34..a5261e4 100644
--- a/linux-x64/clang/include/llvm/Support/ScaledNumber.h
+++ b/linux-x64/clang/include/llvm/Support/ScaledNumber.h
@@ -418,7 +418,7 @@
 class raw_ostream;
 class ScaledNumberBase {
 public:
-  static const int DefaultPrecision = 10;
+  static constexpr int DefaultPrecision = 10;
 
   static void dump(uint64_t D, int16_t E, int Width);
   static raw_ostream &print(raw_ostream &OS, uint64_t D, int16_t E, int Width,
@@ -499,7 +499,7 @@
 private:
   typedef std::numeric_limits<DigitsType> DigitsLimits;
 
-  static const int Width = sizeof(DigitsType) * 8;
+  static constexpr int Width = sizeof(DigitsType) * 8;
   static_assert(Width <= 64, "invalid integer width for digits");
 
 private:
diff --git a/linux-x64/clang/include/llvm/Support/Signals.h b/linux-x64/clang/include/llvm/Support/Signals.h
index 9f2cb85..44f5a75 100644
--- a/linux-x64/clang/include/llvm/Support/Signals.h
+++ b/linux-x64/clang/include/llvm/Support/Signals.h
@@ -50,7 +50,9 @@
   void DisableSystemDialogsOnCrash();
 
   /// Print the stack trace using the given \c raw_ostream object.
-  void PrintStackTrace(raw_ostream &OS);
+  /// \param Depth refers to the number of stackframes to print. If not
+  ///        specified, the entire frame is printed.
+  void PrintStackTrace(raw_ostream &OS, int Depth = 0);
 
   // Run all registered signal handlers.
   void RunSignalHandlers();
@@ -65,13 +67,58 @@
   /// This function registers a function to be called when the user "interrupts"
   /// the program (typically by pressing ctrl-c).  When the user interrupts the
   /// program, the specified interrupt function is called instead of the program
-  /// being killed, and the interrupt function automatically disabled.  Note
-  /// that interrupt functions are not allowed to call any non-reentrant
+  /// being killed, and the interrupt function automatically disabled.
+  ///
+  /// Note that interrupt functions are not allowed to call any non-reentrant
   /// functions.  An null interrupt function pointer disables the current
   /// installed function.  Note also that the handler may be executed on a
   /// different thread on some platforms.
-  /// Register a function to be called when ctrl-c is pressed.
   void SetInterruptFunction(void (*IF)());
+
+  /// Registers a function to be called when an "info" signal is delivered to
+  /// the process.
+  ///
+  /// On POSIX systems, this will be SIGUSR1; on systems that have it, SIGINFO
+  /// will also be used (typically ctrl-t).
+  ///
+  /// Note that signal handlers are not allowed to call any non-reentrant
+  /// functions.  An null function pointer disables the current installed
+  /// function.  Note also that the handler may be executed on a different
+  /// thread on some platforms.
+  void SetInfoSignalFunction(void (*Handler)());
+
+  /// Registers a function to be called in a "one-shot" manner when a pipe
+  /// signal is delivered to the process (i.e., on a failed write to a pipe).
+  /// After the pipe signal is handled once, the handler is unregistered.
+  ///
+  /// The LLVM signal handling code will not install any handler for the pipe
+  /// signal unless one is provided with this API (see \ref
+  /// DefaultOneShotPipeSignalHandler). This handler must be provided before
+  /// any other LLVM signal handlers are installed: the \ref InitLLVM
+  /// constructor has a flag that can simplify this setup.
+  ///
+  /// Note that the handler is not allowed to call any non-reentrant
+  /// functions.  A null handler pointer disables the current installed
+  /// function.  Note also that the handler may be executed on a
+  /// different thread on some platforms.
+  ///
+  /// This is a no-op on Windows.
+  void SetOneShotPipeSignalFunction(void (*Handler)());
+
+  /// On Unix systems, this function exits with an "IO error" exit code.
+  /// This is a no-op on Windows.
+  void DefaultOneShotPipeSignalHandler();
+
+  /// This function does the following:
+  /// - clean up any temporary files registered with RemoveFileOnSignal()
+  /// - dump the callstack from the exception context
+  /// - call any relevant interrupt/signal handlers
+  /// - create a core/mini dump of the exception context whenever possible
+  /// Context is a system-specific failure context: it is the signal type on
+  /// Unix; the ExceptionContext on Windows.
+  void CleanupOnSignal(uintptr_t Context);
+
+  void unregisterHandlers();
 } // End sys namespace
 } // End llvm namespace
 
diff --git a/linux-x64/clang/include/llvm/Support/Signposts.h b/linux-x64/clang/include/llvm/Support/Signposts.h
index b5a8c3d..8036b1f 100644
--- a/linux-x64/clang/include/llvm/Support/Signposts.h
+++ b/linux-x64/clang/include/llvm/Support/Signposts.h
@@ -17,9 +17,10 @@
 #ifndef LLVM_SUPPORT_SIGNPOSTS_H
 #define LLVM_SUPPORT_SIGNPOSTS_H
 
+#include "llvm/ADT/StringRef.h"
+
 namespace llvm {
 class SignpostEmitterImpl;
-class Timer;
 
 /// Manages the emission of signposts into the recording method supported by
 /// the OS.
@@ -32,10 +33,10 @@
 
   bool isEnabled() const;
 
-  /// Begin a signposted interval for the given timer.
-  void startTimerInterval(Timer *T);
-  /// End a signposted interval for the given timer.
-  void endTimerInterval(Timer *T);
+  /// Begin a signposted interval for a given object.
+  void startInterval(const void *O, StringRef Name);
+  /// End a signposted interval for a given object.
+  void endInterval(const void *O, StringRef Name);
 };
 
 } // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/Support/SmallVectorMemoryBuffer.h b/linux-x64/clang/include/llvm/Support/SmallVectorMemoryBuffer.h
index b63b58e..62900b7 100644
--- a/linux-x64/clang/include/llvm/Support/SmallVectorMemoryBuffer.h
+++ b/linux-x64/clang/include/llvm/Support/SmallVectorMemoryBuffer.h
@@ -44,7 +44,7 @@
   /// Construct a named SmallVectorMemoryBuffer from the given
   /// SmallVector r-value and StringRef.
   SmallVectorMemoryBuffer(SmallVectorImpl<char> &&SV, StringRef Name)
-      : SV(std::move(SV)), BufferName(Name) {
+      : SV(std::move(SV)), BufferName(std::string(Name)) {
     init(this->SV.begin(), this->SV.end(), false);
   }
 
diff --git a/linux-x64/clang/include/llvm/Support/SourceMgr.h b/linux-x64/clang/include/llvm/Support/SourceMgr.h
index 7b081d3..28716b4 100644
--- a/linux-x64/clang/include/llvm/Support/SourceMgr.h
+++ b/linux-x64/clang/include/llvm/Support/SourceMgr.h
@@ -15,19 +15,9 @@
 #ifndef LLVM_SUPPORT_SOURCEMGR_H
 #define LLVM_SUPPORT_SOURCEMGR_H
 
-#include "llvm/ADT/ArrayRef.h"
-#include "llvm/ADT/None.h"
-#include "llvm/ADT/PointerUnion.h"
 #include "llvm/ADT/SmallVector.h"
-#include "llvm/ADT/StringRef.h"
-#include "llvm/ADT/Twine.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/SMLoc.h"
-#include <algorithm>
-#include <cassert>
-#include <memory>
-#include <string>
-#include <utility>
 #include <vector>
 
 namespace llvm {
@@ -57,29 +47,29 @@
     /// The memory buffer for the file.
     std::unique_ptr<MemoryBuffer> Buffer;
 
-    /// Helper type for OffsetCache below: since we're storing many offsets
-    /// into relatively small files (often smaller than 2^8 or 2^16 bytes),
-    /// we select the offset vector element type dynamically based on the
-    /// size of Buffer.
-    using VariableSizeOffsets = PointerUnion4<std::vector<uint8_t> *,
-                                              std::vector<uint16_t> *,
-                                              std::vector<uint32_t> *,
-                                              std::vector<uint64_t> *>;
-
     /// Vector of offsets into Buffer at which there are line-endings
     /// (lazily populated). Once populated, the '\n' that marks the end of
     /// line number N from [1..] is at Buffer[OffsetCache[N-1]]. Since
     /// these offsets are in sorted (ascending) order, they can be
     /// binary-searched for the first one after any given offset (eg. an
     /// offset corresponding to a particular SMLoc).
-    mutable VariableSizeOffsets OffsetCache;
+    ///
+    /// Since we're storing offsets into relatively small files (often smaller
+    /// than 2^8 or 2^16 bytes), we select the offset vector element type
+    /// dynamically based on the size of Buffer.
+    mutable void *OffsetCache = nullptr;
 
-    /// Populate \c OffsetCache and look up a given \p Ptr in it, assuming
-    /// it points somewhere into \c Buffer. The static type parameter \p T
-    /// must be an unsigned integer type from uint{8,16,32,64}_t large
-    /// enough to store offsets inside \c Buffer.
-    template<typename T>
+    /// Look up a given \p Ptr in in the buffer, determining which line it came
+    /// from.
     unsigned getLineNumber(const char *Ptr) const;
+    template <typename T>
+    unsigned getLineNumberSpecialized(const char *Ptr) const;
+
+    /// Return a pointer to the first character of the specified line number or
+    /// null if the line number is invalid.
+    const char *getPointerForLineNumber(unsigned LineNo) const;
+    template <typename T>
+    const char *getPointerForLineNumberSpecialized(unsigned LineNo) const;
 
     /// This is the location of the parent include, or null if at the top level.
     SMLoc IncludeLoc;
@@ -106,6 +96,8 @@
   SourceMgr() = default;
   SourceMgr(const SourceMgr &) = delete;
   SourceMgr &operator=(const SourceMgr &) = delete;
+  SourceMgr(SourceMgr &&) = default;
+  SourceMgr &operator=(SourceMgr &&) = default;
   ~SourceMgr() = default;
 
   void setIncludeDirs(const std::vector<std::string> &Dirs) {
@@ -132,9 +124,7 @@
     return Buffers[i - 1].Buffer.get();
   }
 
-  unsigned getNumBuffers() const {
-    return Buffers.size();
-  }
+  unsigned getNumBuffers() const { return Buffers.size(); }
 
   unsigned getMainFileID() const {
     assert(getNumBuffers());
@@ -182,20 +172,29 @@
   std::pair<unsigned, unsigned> getLineAndColumn(SMLoc Loc,
                                                  unsigned BufferID = 0) const;
 
+  /// Get a string with the \p SMLoc filename and line number
+  /// formatted in the standard style.
+  std::string getFormattedLocationNoOffset(SMLoc Loc,
+                                           bool IncludePath = false) const;
+
+  /// Given a line and column number in a mapped buffer, turn it into an SMLoc.
+  /// This will return a null SMLoc if the line/column location is invalid.
+  SMLoc FindLocForLineAndColumn(unsigned BufferID, unsigned LineNo,
+                                unsigned ColNo);
+
   /// Emit a message about the specified location with the specified string.
   ///
   /// \param ShowColors Display colored messages if output is a terminal and
   /// the default error handler is used.
-  void PrintMessage(raw_ostream &OS, SMLoc Loc, DiagKind Kind,
-                    const Twine &Msg,
-                    ArrayRef<SMRange> Ranges = None,
-                    ArrayRef<SMFixIt> FixIts = None,
+  void PrintMessage(raw_ostream &OS, SMLoc Loc, DiagKind Kind, const Twine &Msg,
+                    ArrayRef<SMRange> Ranges = {},
+                    ArrayRef<SMFixIt> FixIts = {},
                     bool ShowColors = true) const;
 
   /// Emits a diagnostic to llvm::errs().
   void PrintMessage(SMLoc Loc, DiagKind Kind, const Twine &Msg,
-                    ArrayRef<SMRange> Ranges = None,
-                    ArrayRef<SMFixIt> FixIts = None,
+                    ArrayRef<SMRange> Ranges = {},
+                    ArrayRef<SMFixIt> FixIts = {},
                     bool ShowColors = true) const;
 
   /// Emits a manually-constructed diagnostic to the given output stream.
@@ -211,8 +210,8 @@
   /// \param Msg If non-null, the kind of message (e.g., "error") which is
   /// prefixed to the message.
   SMDiagnostic GetMessage(SMLoc Loc, DiagKind Kind, const Twine &Msg,
-                          ArrayRef<SMRange> Ranges = None,
-                          ArrayRef<SMFixIt> FixIts = None) const;
+                          ArrayRef<SMRange> Ranges = {},
+                          ArrayRef<SMFixIt> FixIts = {}) const;
 
   /// Prints the names of included files and the line of the file they were
   /// included from. A diagnostic handler can use this before printing its
@@ -230,17 +229,10 @@
   std::string Text;
 
 public:
-  // FIXME: Twine.str() is not very efficient.
-  SMFixIt(SMLoc Loc, const Twine &Insertion)
-    : Range(Loc, Loc), Text(Insertion.str()) {
-    assert(Loc.isValid());
-  }
+  SMFixIt(SMRange R, const Twine &Replacement);
 
-  // FIXME: Twine.str() is not very efficient.
-  SMFixIt(SMRange R, const Twine &Replacement)
-    : Range(R), Text(Replacement.str()) {
-    assert(R.isValid());
-  }
+  SMFixIt(SMLoc Loc, const Twine &Replacement)
+      : SMFixIt(SMRange(Loc, Loc), Replacement) {}
 
   StringRef getText() const { return Text; }
   SMRange getRange() const { return Range; }
@@ -272,14 +264,13 @@
   SMDiagnostic() = default;
   // Diagnostic with no location (e.g. file not found, command line arg error).
   SMDiagnostic(StringRef filename, SourceMgr::DiagKind Knd, StringRef Msg)
-    : Filename(filename), LineNo(-1), ColumnNo(-1), Kind(Knd), Message(Msg) {}
+      : Filename(filename), LineNo(-1), ColumnNo(-1), Kind(Knd), Message(Msg) {}
 
   // Diagnostic with a location.
-  SMDiagnostic(const SourceMgr &sm, SMLoc L, StringRef FN,
-               int Line, int Col, SourceMgr::DiagKind Kind,
-               StringRef Msg, StringRef LineStr,
-               ArrayRef<std::pair<unsigned,unsigned>> Ranges,
-               ArrayRef<SMFixIt> FixIts = None);
+  SMDiagnostic(const SourceMgr &sm, SMLoc L, StringRef FN, int Line, int Col,
+               SourceMgr::DiagKind Kind, StringRef Msg, StringRef LineStr,
+               ArrayRef<std::pair<unsigned, unsigned>> Ranges,
+               ArrayRef<SMFixIt> FixIts = {});
 
   const SourceMgr *getSourceMgr() const { return SM; }
   SMLoc getLoc() const { return Loc; }
@@ -291,13 +282,9 @@
   StringRef getLineContents() const { return LineContents; }
   ArrayRef<std::pair<unsigned, unsigned>> getRanges() const { return Ranges; }
 
-  void addFixIt(const SMFixIt &Hint) {
-    FixIts.push_back(Hint);
-  }
+  void addFixIt(const SMFixIt &Hint) { FixIts.push_back(Hint); }
 
-  ArrayRef<SMFixIt> getFixIts() const {
-    return FixIts;
-  }
+  ArrayRef<SMFixIt> getFixIts() const { return FixIts; }
 
   void print(const char *ProgName, raw_ostream &S, bool ShowColors = true,
              bool ShowKindLabel = true) const;
diff --git a/linux-x64/clang/include/llvm/Support/SpecialCaseList.h b/linux-x64/clang/include/llvm/Support/SpecialCaseList.h
index b740026..d022a8f 100644
--- a/linux-x64/clang/include/llvm/Support/SpecialCaseList.h
+++ b/linux-x64/clang/include/llvm/Support/SpecialCaseList.h
@@ -7,8 +7,8 @@
 //
 // This is a utility class used to parse user-provided text files with
 // "special case lists" for code sanitizers. Such files are used to
-// define an "ABI list" for DataFlowSanitizer and blacklists for sanitizers
-// like AddressSanitizer or UndefinedBehaviorSanitizer.
+// define an "ABI list" for DataFlowSanitizer and allow/exclusion lists for
+// sanitizers like AddressSanitizer or UndefinedBehaviorSanitizer.
 //
 // Empty lines and lines starting with "#" are ignored. Sections are defined
 // using a '[section_name]' header and can be used to specify sanitizers the
@@ -19,18 +19,18 @@
 //   prefix:wildcard_expression[=category]
 // If category is not specified, it is assumed to be empty string.
 // Definitions of "prefix" and "category" are sanitizer-specific. For example,
-// sanitizer blacklists support prefixes "src", "fun" and "global".
+// sanitizer exclusion support prefixes "src", "fun" and "global".
 // Wildcard expressions define, respectively, source files, functions or
 // globals which shouldn't be instrumented.
 // Examples of categories:
 //   "functional": used in DFSan to list functions with pure functional
 //                 semantics.
-//   "init": used in ASan blacklist to disable initialization-order bugs
+//   "init": used in ASan exclusion list to disable initialization-order bugs
 //           detection for certain globals or source files.
 // Full special case list file example:
 // ---
 // [address]
-// # Blacklisted items:
+// # Excluded items:
 // fun:*_ZN4base6subtle*
 // global:*global_with_bad_access_or_initialization*
 // global:*global_with_initialization_issues*=init
@@ -52,23 +52,27 @@
 #define LLVM_SUPPORT_SPECIALCASELIST_H
 
 #include "llvm/ADT/StringMap.h"
-#include "llvm/ADT/StringSet.h"
 #include "llvm/Support/Regex.h"
 #include "llvm/Support/TrigramIndex.h"
+#include <memory>
 #include <string>
 #include <vector>
 
 namespace llvm {
 class MemoryBuffer;
-class Regex;
 class StringRef;
 
+namespace vfs {
+class FileSystem;
+}
+
 class SpecialCaseList {
 public:
   /// Parses the special case list entries from files. On failure, returns
   /// 0 and writes an error message to string.
   static std::unique_ptr<SpecialCaseList>
-  create(const std::vector<std::string> &Paths, std::string &Error);
+  create(const std::vector<std::string> &Paths, llvm::vfs::FileSystem &FS,
+         std::string &Error);
   /// Parses the special case list from a memory buffer. On failure, returns
   /// 0 and writes an error message to string.
   static std::unique_ptr<SpecialCaseList> create(const MemoryBuffer *MB,
@@ -76,7 +80,7 @@
   /// Parses the special case list entries from files. On failure, reports a
   /// fatal error.
   static std::unique_ptr<SpecialCaseList>
-  createOrDie(const std::vector<std::string> &Paths);
+  createOrDie(const std::vector<std::string> &Paths, llvm::vfs::FileSystem &FS);
 
   ~SpecialCaseList();
 
@@ -94,7 +98,7 @@
   ///   @Prefix:<E>=@Category
   /// \endcode
   /// where @Query satisfies wildcard expression <E> in a given @Section.
-  /// Returns zero if there is no blacklist entry corresponding to this
+  /// Returns zero if there is no exclusion entry corresponding to this
   /// expression.
   unsigned inSectionBlame(StringRef Section, StringRef Prefix, StringRef Query,
                           StringRef Category = StringRef()) const;
@@ -103,7 +107,7 @@
   // Implementations of the create*() functions that can also be used by derived
   // classes.
   bool createInternal(const std::vector<std::string> &Paths,
-                      std::string &Error);
+                      vfs::FileSystem &VFS, std::string &Error);
   bool createInternal(const MemoryBuffer *MB, std::string &Error);
 
   SpecialCaseList() = default;
diff --git a/linux-x64/clang/include/llvm/Support/StringPool.h b/linux-x64/clang/include/llvm/Support/StringPool.h
deleted file mode 100644
index a4f4591..0000000
--- a/linux-x64/clang/include/llvm/Support/StringPool.h
+++ /dev/null
@@ -1,139 +0,0 @@
-//===- StringPool.h - Interned string pool ----------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// This file declares an interned string pool, which helps reduce the cost of
-// strings by using the same storage for identical strings.
-//
-// To intern a string:
-//
-//   StringPool Pool;
-//   PooledStringPtr Str = Pool.intern("wakka wakka");
-//
-// To use the value of an interned string, use operator bool and operator*:
-//
-//   if (Str)
-//     cerr << "the string is" << *Str << "\n";
-//
-// Pooled strings are immutable, but you can change a PooledStringPtr to point
-// to another instance. So that interned strings can eventually be freed,
-// strings in the string pool are reference-counted (automatically).
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_SUPPORT_STRINGPOOL_H
-#define LLVM_SUPPORT_STRINGPOOL_H
-
-#include "llvm/ADT/StringMap.h"
-#include "llvm/ADT/StringRef.h"
-#include <cassert>
-
-namespace llvm {
-
-  class PooledStringPtr;
-
-  /// StringPool - An interned string pool. Use the intern method to add a
-  /// string. Strings are removed automatically as PooledStringPtrs are
-  /// destroyed.
-  class StringPool {
-    /// PooledString - This is the value of an entry in the pool's interning
-    /// table.
-    struct PooledString {
-      StringPool *Pool = nullptr;  ///< So the string can remove itself.
-      unsigned Refcount = 0;       ///< Number of referencing PooledStringPtrs.
-
-    public:
-      PooledString() = default;
-    };
-
-    friend class PooledStringPtr;
-
-    using table_t = StringMap<PooledString>;
-    using entry_t = StringMapEntry<PooledString>;
-    table_t InternTable;
-
-  public:
-    StringPool();
-    ~StringPool();
-
-    /// intern - Adds a string to the pool and returns a reference-counted
-    /// pointer to it. No additional memory is allocated if the string already
-    /// exists in the pool.
-    PooledStringPtr intern(StringRef Str);
-
-    /// empty - Checks whether the pool is empty. Returns true if so.
-    ///
-    inline bool empty() const { return InternTable.empty(); }
-  };
-
-  /// PooledStringPtr - A pointer to an interned string. Use operator bool to
-  /// test whether the pointer is valid, and operator * to get the string if so.
-  /// This is a lightweight value class with storage requirements equivalent to
-  /// a single pointer, but it does have reference-counting overhead when
-  /// copied.
-  class PooledStringPtr {
-    using entry_t = StringPool::entry_t;
-
-    entry_t *S = nullptr;
-
-  public:
-    PooledStringPtr() = default;
-
-    explicit PooledStringPtr(entry_t *E) : S(E) {
-      if (S) ++S->getValue().Refcount;
-    }
-
-    PooledStringPtr(const PooledStringPtr &That) : S(That.S) {
-      if (S) ++S->getValue().Refcount;
-    }
-
-    PooledStringPtr &operator=(const PooledStringPtr &That) {
-      if (S != That.S) {
-        clear();
-        S = That.S;
-        if (S) ++S->getValue().Refcount;
-      }
-      return *this;
-    }
-
-    void clear() {
-      if (!S)
-        return;
-      if (--S->getValue().Refcount == 0) {
-        S->getValue().Pool->InternTable.remove(S);
-        S->Destroy();
-      }
-      S = nullptr;
-    }
-
-    ~PooledStringPtr() { clear(); }
-
-    inline const char *begin() const {
-      assert(*this && "Attempt to dereference empty PooledStringPtr!");
-      return S->getKeyData();
-    }
-
-    inline const char *end() const {
-      assert(*this && "Attempt to dereference empty PooledStringPtr!");
-      return S->getKeyData() + S->getKeyLength();
-    }
-
-    inline unsigned size() const {
-      assert(*this && "Attempt to dereference empty PooledStringPtr!");
-      return S->getKeyLength();
-    }
-
-    inline const char *operator*() const { return begin(); }
-    inline explicit operator bool() const { return S != nullptr; }
-
-    inline bool operator==(const PooledStringPtr &That) const { return S == That.S; }
-    inline bool operator!=(const PooledStringPtr &That) const { return S != That.S; }
-  };
-
-} // end namespace llvm
-
-#endif // LLVM_SUPPORT_STRINGPOOL_H
diff --git a/linux-x64/clang/include/llvm/Support/SuffixTree.h b/linux-x64/clang/include/llvm/Support/SuffixTree.h
new file mode 100644
index 0000000..352fba5
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Support/SuffixTree.h
@@ -0,0 +1,350 @@
+//===- llvm/ADT/SuffixTree.h - Tree for substrings --------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the Suffix Tree class and Suffix Tree Node struct.
+//
+//===----------------------------------------------------------------------===//
+#ifndef LLVM_SUPPORT_SUFFIXTREE_H
+#define LLVM_SUPPORT_SUFFIXTREE_H
+
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/Support/Allocator.h"
+#include <vector>
+
+namespace llvm {
+
+/// Represents an undefined index in the suffix tree.
+const unsigned EmptyIdx = -1;
+
+/// A node in a suffix tree which represents a substring or suffix.
+///
+/// Each node has either no children or at least two children, with the root
+/// being a exception in the empty tree.
+///
+/// Children are represented as a map between unsigned integers and nodes. If
+/// a node N has a child M on unsigned integer k, then the mapping represented
+/// by N is a proper prefix of the mapping represented by M. Note that this,
+/// although similar to a trie is somewhat different: each node stores a full
+/// substring of the full mapping rather than a single character state.
+///
+/// Each internal node contains a pointer to the internal node representing
+/// the same string, but with the first character chopped off. This is stored
+/// in \p Link. Each leaf node stores the start index of its respective
+/// suffix in \p SuffixIdx.
+struct SuffixTreeNode {
+
+  /// The children of this node.
+  ///
+  /// A child existing on an unsigned integer implies that from the mapping
+  /// represented by the current node, there is a way to reach another
+  /// mapping by tacking that character on the end of the current string.
+  llvm::DenseMap<unsigned, SuffixTreeNode *> Children;
+
+  /// The start index of this node's substring in the main string.
+  unsigned StartIdx = EmptyIdx;
+
+  /// The end index of this node's substring in the main string.
+  ///
+  /// Every leaf node must have its \p EndIdx incremented at the end of every
+  /// step in the construction algorithm. To avoid having to update O(N)
+  /// nodes individually at the end of every step, the end index is stored
+  /// as a pointer.
+  unsigned *EndIdx = nullptr;
+
+  /// For leaves, the start index of the suffix represented by this node.
+  ///
+  /// For all other nodes, this is ignored.
+  unsigned SuffixIdx = EmptyIdx;
+
+  /// For internal nodes, a pointer to the internal node representing
+  /// the same sequence with the first character chopped off.
+  ///
+  /// This acts as a shortcut in Ukkonen's algorithm. One of the things that
+  /// Ukkonen's algorithm does to achieve linear-time construction is
+  /// keep track of which node the next insert should be at. This makes each
+  /// insert O(1), and there are a total of O(N) inserts. The suffix link
+  /// helps with inserting children of internal nodes.
+  ///
+  /// Say we add a child to an internal node with associated mapping S. The
+  /// next insertion must be at the node representing S - its first character.
+  /// This is given by the way that we iteratively build the tree in Ukkonen's
+  /// algorithm. The main idea is to look at the suffixes of each prefix in the
+  /// string, starting with the longest suffix of the prefix, and ending with
+  /// the shortest. Therefore, if we keep pointers between such nodes, we can
+  /// move to the next insertion point in O(1) time. If we don't, then we'd
+  /// have to query from the root, which takes O(N) time. This would make the
+  /// construction algorithm O(N^2) rather than O(N).
+  SuffixTreeNode *Link = nullptr;
+
+  /// The length of the string formed by concatenating the edge labels from the
+  /// root to this node.
+  unsigned ConcatLen = 0;
+
+  /// Returns true if this node is a leaf.
+  bool isLeaf() const { return SuffixIdx != EmptyIdx; }
+
+  /// Returns true if this node is the root of its owning \p SuffixTree.
+  bool isRoot() const { return StartIdx == EmptyIdx; }
+
+  /// Return the number of elements in the substring associated with this node.
+  size_t size() const {
+
+    // Is it the root? If so, it's the empty string so return 0.
+    if (isRoot())
+      return 0;
+
+    assert(*EndIdx != EmptyIdx && "EndIdx is undefined!");
+
+    // Size = the number of elements in the string.
+    // For example, [0 1 2 3] has length 4, not 3. 3-0 = 3, so we have 3-0+1.
+    return *EndIdx - StartIdx + 1;
+  }
+
+  SuffixTreeNode(unsigned StartIdx, unsigned *EndIdx, SuffixTreeNode *Link)
+      : StartIdx(StartIdx), EndIdx(EndIdx), Link(Link) {}
+
+  SuffixTreeNode() {}
+};
+
+/// A data structure for fast substring queries.
+///
+/// Suffix trees represent the suffixes of their input strings in their leaves.
+/// A suffix tree is a type of compressed trie structure where each node
+/// represents an entire substring rather than a single character. Each leaf
+/// of the tree is a suffix.
+///
+/// A suffix tree can be seen as a type of state machine where each state is a
+/// substring of the full string. The tree is structured so that, for a string
+/// of length N, there are exactly N leaves in the tree. This structure allows
+/// us to quickly find repeated substrings of the input string.
+///
+/// In this implementation, a "string" is a vector of unsigned integers.
+/// These integers may result from hashing some data type. A suffix tree can
+/// contain 1 or many strings, which can then be queried as one large string.
+///
+/// The suffix tree is implemented using Ukkonen's algorithm for linear-time
+/// suffix tree construction. Ukkonen's algorithm is explained in more detail
+/// in the paper by Esko Ukkonen "On-line construction of suffix trees. The
+/// paper is available at
+///
+/// https://www.cs.helsinki.fi/u/ukkonen/SuffixT1withFigs.pdf
+class SuffixTree {
+public:
+  /// Each element is an integer representing an instruction in the module.
+  llvm::ArrayRef<unsigned> Str;
+
+  /// A repeated substring in the tree.
+  struct RepeatedSubstring {
+    /// The length of the string.
+    unsigned Length;
+
+    /// The start indices of each occurrence.
+    std::vector<unsigned> StartIndices;
+  };
+
+private:
+  /// Maintains each node in the tree.
+  llvm::SpecificBumpPtrAllocator<SuffixTreeNode> NodeAllocator;
+
+  /// The root of the suffix tree.
+  ///
+  /// The root represents the empty string. It is maintained by the
+  /// \p NodeAllocator like every other node in the tree.
+  SuffixTreeNode *Root = nullptr;
+
+  /// Maintains the end indices of the internal nodes in the tree.
+  ///
+  /// Each internal node is guaranteed to never have its end index change
+  /// during the construction algorithm; however, leaves must be updated at
+  /// every step. Therefore, we need to store leaf end indices by reference
+  /// to avoid updating O(N) leaves at every step of construction. Thus,
+  /// every internal node must be allocated its own end index.
+  llvm::BumpPtrAllocator InternalEndIdxAllocator;
+
+  /// The end index of each leaf in the tree.
+  unsigned LeafEndIdx = -1;
+
+  /// Helper struct which keeps track of the next insertion point in
+  /// Ukkonen's algorithm.
+  struct ActiveState {
+    /// The next node to insert at.
+    SuffixTreeNode *Node = nullptr;
+
+    /// The index of the first character in the substring currently being added.
+    unsigned Idx = EmptyIdx;
+
+    /// The length of the substring we have to add at the current step.
+    unsigned Len = 0;
+  };
+
+  /// The point the next insertion will take place at in the
+  /// construction algorithm.
+  ActiveState Active;
+
+  /// Allocate a leaf node and add it to the tree.
+  ///
+  /// \param Parent The parent of this node.
+  /// \param StartIdx The start index of this node's associated string.
+  /// \param Edge The label on the edge leaving \p Parent to this node.
+  ///
+  /// \returns A pointer to the allocated leaf node.
+  SuffixTreeNode *insertLeaf(SuffixTreeNode &Parent, unsigned StartIdx,
+                             unsigned Edge);
+
+  /// Allocate an internal node and add it to the tree.
+  ///
+  /// \param Parent The parent of this node. Only null when allocating the root.
+  /// \param StartIdx The start index of this node's associated string.
+  /// \param EndIdx The end index of this node's associated string.
+  /// \param Edge The label on the edge leaving \p Parent to this node.
+  ///
+  /// \returns A pointer to the allocated internal node.
+  SuffixTreeNode *insertInternalNode(SuffixTreeNode *Parent, unsigned StartIdx,
+                                     unsigned EndIdx, unsigned Edge);
+
+  /// Set the suffix indices of the leaves to the start indices of their
+  /// respective suffixes.
+  void setSuffixIndices();
+
+  /// Construct the suffix tree for the prefix of the input ending at
+  /// \p EndIdx.
+  ///
+  /// Used to construct the full suffix tree iteratively. At the end of each
+  /// step, the constructed suffix tree is either a valid suffix tree, or a
+  /// suffix tree with implicit suffixes. At the end of the final step, the
+  /// suffix tree is a valid tree.
+  ///
+  /// \param EndIdx The end index of the current prefix in the main string.
+  /// \param SuffixesToAdd The number of suffixes that must be added
+  /// to complete the suffix tree at the current phase.
+  ///
+  /// \returns The number of suffixes that have not been added at the end of
+  /// this step.
+  unsigned extend(unsigned EndIdx, unsigned SuffixesToAdd);
+
+public:
+  /// Construct a suffix tree from a sequence of unsigned integers.
+  ///
+  /// \param Str The string to construct the suffix tree for.
+  SuffixTree(const std::vector<unsigned> &Str);
+
+  /// Iterator for finding all repeated substrings in the suffix tree.
+  struct RepeatedSubstringIterator {
+  private:
+    /// The current node we're visiting.
+    SuffixTreeNode *N = nullptr;
+
+    /// The repeated substring associated with this node.
+    RepeatedSubstring RS;
+
+    /// The nodes left to visit.
+    std::vector<SuffixTreeNode *> ToVisit;
+
+    /// The minimum length of a repeated substring to find.
+    /// Since we're outlining, we want at least two instructions in the range.
+    /// FIXME: This may not be true for targets like X86 which support many
+    /// instruction lengths.
+    const unsigned MinLength = 2;
+
+    /// Move the iterator to the next repeated substring.
+    void advance() {
+      // Clear the current state. If we're at the end of the range, then this
+      // is the state we want to be in.
+      RS = RepeatedSubstring();
+      N = nullptr;
+
+      // Each leaf node represents a repeat of a string.
+      std::vector<SuffixTreeNode *> LeafChildren;
+
+      // Continue visiting nodes until we find one which repeats more than once.
+      while (!ToVisit.empty()) {
+        SuffixTreeNode *Curr = ToVisit.back();
+        ToVisit.pop_back();
+        LeafChildren.clear();
+
+        // Keep track of the length of the string associated with the node. If
+        // it's too short, we'll quit.
+        unsigned Length = Curr->ConcatLen;
+
+        // Iterate over each child, saving internal nodes for visiting, and
+        // leaf nodes in LeafChildren. Internal nodes represent individual
+        // strings, which may repeat.
+        for (auto &ChildPair : Curr->Children) {
+          // Save all of this node's children for processing.
+          if (!ChildPair.second->isLeaf())
+            ToVisit.push_back(ChildPair.second);
+
+          // It's not an internal node, so it must be a leaf. If we have a
+          // long enough string, then save the leaf children.
+          else if (Length >= MinLength)
+            LeafChildren.push_back(ChildPair.second);
+        }
+
+        // The root never represents a repeated substring. If we're looking at
+        // that, then skip it.
+        if (Curr->isRoot())
+          continue;
+
+        // Do we have any repeated substrings?
+        if (LeafChildren.size() >= 2) {
+          // Yes. Update the state to reflect this, and then bail out.
+          N = Curr;
+          RS.Length = Length;
+          for (SuffixTreeNode *Leaf : LeafChildren)
+            RS.StartIndices.push_back(Leaf->SuffixIdx);
+          break;
+        }
+      }
+
+      // At this point, either NewRS is an empty RepeatedSubstring, or it was
+      // set in the above loop. Similarly, N is either nullptr, or the node
+      // associated with NewRS.
+    }
+
+  public:
+    /// Return the current repeated substring.
+    RepeatedSubstring &operator*() { return RS; }
+
+    RepeatedSubstringIterator &operator++() {
+      advance();
+      return *this;
+    }
+
+    RepeatedSubstringIterator operator++(int I) {
+      RepeatedSubstringIterator It(*this);
+      advance();
+      return It;
+    }
+
+    bool operator==(const RepeatedSubstringIterator &Other) const {
+      return N == Other.N;
+    }
+    bool operator!=(const RepeatedSubstringIterator &Other) const {
+      return !(*this == Other);
+    }
+
+    RepeatedSubstringIterator(SuffixTreeNode *N) : N(N) {
+      // Do we have a non-null node?
+      if (N) {
+        // Yes. At the first step, we need to visit all of N's children.
+        // Note: This means that we visit N last.
+        ToVisit.push_back(N);
+        advance();
+      }
+    }
+  };
+
+  typedef RepeatedSubstringIterator iterator;
+  iterator begin() { return iterator(Root); }
+  iterator end() { return iterator(nullptr); }
+};
+
+} // namespace llvm
+
+#endif // LLVM_SUPPORT_SUFFIXTREE_H
diff --git a/linux-x64/clang/include/llvm/Support/SwapByteOrder.h b/linux-x64/clang/include/llvm/Support/SwapByteOrder.h
index 06a447a..e8612ba 100644
--- a/linux-x64/clang/include/llvm/Support/SwapByteOrder.h
+++ b/linux-x64/clang/include/llvm/Support/SwapByteOrder.h
@@ -14,20 +14,43 @@
 #ifndef LLVM_SUPPORT_SWAPBYTEORDER_H
 #define LLVM_SUPPORT_SWAPBYTEORDER_H
 
-#include "llvm/Support/Compiler.h"
-#include "llvm/Support/DataTypes.h"
 #include <cstddef>
+#include <cstdint>
 #include <type_traits>
 #if defined(_MSC_VER) && !defined(_DEBUG)
 #include <stdlib.h>
 #endif
 
-namespace llvm {
-namespace sys {
+#if defined(__linux__) || defined(__GNU__) || defined(__HAIKU__) ||            \
+    defined(__Fuchsia__) || defined(__EMSCRIPTEN__)
+#include <endian.h>
+#elif defined(_AIX)
+#include <sys/machine.h>
+#elif defined(__sun)
+/* Solaris provides _BIG_ENDIAN/_LITTLE_ENDIAN selector in sys/types.h */
+#include <sys/types.h>
+#define BIG_ENDIAN 4321
+#define LITTLE_ENDIAN 1234
+#if defined(_BIG_ENDIAN)
+#define BYTE_ORDER BIG_ENDIAN
+#else
+#define BYTE_ORDER LITTLE_ENDIAN
+#endif
+#elif defined(__MVS__)
+#define BIG_ENDIAN 4321
+#define LITTLE_ENDIAN 1234
+#define BYTE_ORDER BIG_ENDIAN
+#else
+#if !defined(BYTE_ORDER) && !defined(_WIN32)
+#include <machine/endian.h>
+#endif
+#endif
 
-/// SwapByteOrder_16 - This function returns a byte-swapped representation of
+namespace llvm {
+
+/// ByteSwap_16 - This function returns a byte-swapped representation of
 /// the 16-bit argument.
-inline uint16_t SwapByteOrder_16(uint16_t value) {
+inline uint16_t ByteSwap_16(uint16_t value) {
 #if defined(_MSC_VER) && !defined(_DEBUG)
   // The DLL version of the runtime lacks these functions (bug!?), but in a
   // release build they're replaced with BSWAP instructions anyway.
@@ -39,10 +62,9 @@
 #endif
 }
 
-/// SwapByteOrder_32 - This function returns a byte-swapped representation of
-/// the 32-bit argument.
-inline uint32_t SwapByteOrder_32(uint32_t value) {
-#if defined(__llvm__) || (LLVM_GNUC_PREREQ(4, 3, 0) && !defined(__ICC))
+/// This function returns a byte-swapped representation of the 32-bit argument.
+inline uint32_t ByteSwap_32(uint32_t value) {
+#if defined(__llvm__) || (defined(__GNUC__) && !defined(__ICC))
   return __builtin_bswap32(value);
 #elif defined(_MSC_VER) && !defined(_DEBUG)
   return _byteswap_ulong(value);
@@ -55,45 +77,55 @@
 #endif
 }
 
-/// SwapByteOrder_64 - This function returns a byte-swapped representation of
-/// the 64-bit argument.
-inline uint64_t SwapByteOrder_64(uint64_t value) {
-#if defined(__llvm__) || (LLVM_GNUC_PREREQ(4, 3, 0) && !defined(__ICC))
+/// This function returns a byte-swapped representation of the 64-bit argument.
+inline uint64_t ByteSwap_64(uint64_t value) {
+#if defined(__llvm__) || (defined(__GNUC__) && !defined(__ICC))
   return __builtin_bswap64(value);
 #elif defined(_MSC_VER) && !defined(_DEBUG)
   return _byteswap_uint64(value);
 #else
-  uint64_t Hi = SwapByteOrder_32(uint32_t(value));
-  uint32_t Lo = SwapByteOrder_32(uint32_t(value >> 32));
+  uint64_t Hi = ByteSwap_32(uint32_t(value));
+  uint32_t Lo = ByteSwap_32(uint32_t(value >> 32));
   return (Hi << 32) | Lo;
 #endif
 }
 
+namespace sys {
+
+#if defined(BYTE_ORDER) && defined(BIG_ENDIAN) && BYTE_ORDER == BIG_ENDIAN
+constexpr bool IsBigEndianHost = true;
+#else
+constexpr bool IsBigEndianHost = false;
+#endif
+
+static const bool IsLittleEndianHost = !IsBigEndianHost;
+
 inline unsigned char  getSwappedBytes(unsigned char C) { return C; }
 inline   signed char  getSwappedBytes(signed char C) { return C; }
 inline          char  getSwappedBytes(char C) { return C; }
 
-inline unsigned short getSwappedBytes(unsigned short C) { return SwapByteOrder_16(C); }
-inline   signed short getSwappedBytes(  signed short C) { return SwapByteOrder_16(C); }
+inline unsigned short getSwappedBytes(unsigned short C) { return ByteSwap_16(C); }
+inline   signed short getSwappedBytes(  signed short C) { return ByteSwap_16(C); }
 
-inline unsigned int   getSwappedBytes(unsigned int   C) { return SwapByteOrder_32(C); }
-inline   signed int   getSwappedBytes(  signed int   C) { return SwapByteOrder_32(C); }
+inline unsigned int   getSwappedBytes(unsigned int   C) { return ByteSwap_32(C); }
+inline   signed int   getSwappedBytes(  signed int   C) { return ByteSwap_32(C); }
 
-#if __LONG_MAX__ == __INT_MAX__
-inline unsigned long  getSwappedBytes(unsigned long  C) { return SwapByteOrder_32(C); }
-inline   signed long  getSwappedBytes(  signed long  C) { return SwapByteOrder_32(C); }
-#elif __LONG_MAX__ == __LONG_LONG_MAX__
-inline unsigned long  getSwappedBytes(unsigned long  C) { return SwapByteOrder_64(C); }
-inline   signed long  getSwappedBytes(  signed long  C) { return SwapByteOrder_64(C); }
-#else
-#error "Unknown long size!"
-#endif
+inline unsigned long getSwappedBytes(unsigned long C) {
+  // Handle LLP64 and LP64 platforms.
+  return sizeof(long) == sizeof(int) ? ByteSwap_32((uint32_t)C)
+                                     : ByteSwap_64((uint64_t)C);
+}
+inline signed long getSwappedBytes(signed long C) {
+  // Handle LLP64 and LP64 platforms.
+  return sizeof(long) == sizeof(int) ? ByteSwap_32((uint32_t)C)
+                                     : ByteSwap_64((uint64_t)C);
+}
 
 inline unsigned long long getSwappedBytes(unsigned long long C) {
-  return SwapByteOrder_64(C);
+  return ByteSwap_64(C);
 }
 inline signed long long getSwappedBytes(signed long long C) {
-  return SwapByteOrder_64(C);
+  return ByteSwap_64(C);
 }
 
 inline float getSwappedBytes(float C) {
@@ -102,7 +134,7 @@
     float f;
   } in, out;
   in.f = C;
-  out.i = SwapByteOrder_32(in.i);
+  out.i = ByteSwap_32(in.i);
   return out.f;
 }
 
@@ -112,15 +144,14 @@
     double d;
   } in, out;
   in.d = C;
-  out.i = SwapByteOrder_64(in.i);
+  out.i = ByteSwap_64(in.i);
   return out.d;
 }
 
 template <typename T>
-inline typename std::enable_if<std::is_enum<T>::value, T>::type
-getSwappedBytes(T C) {
+inline std::enable_if_t<std::is_enum<T>::value, T> getSwappedBytes(T C) {
   return static_cast<T>(
-      getSwappedBytes(static_cast<typename std::underlying_type<T>::type>(C)));
+      getSwappedBytes(static_cast<std::underlying_type_t<T>>(C)));
 }
 
 template<typename T>
diff --git a/linux-x64/clang/include/llvm/Support/SymbolRemappingReader.h b/linux-x64/clang/include/llvm/Support/SymbolRemappingReader.h
index 2b9ab57..820cf9e 100644
--- a/linux-x64/clang/include/llvm/Support/SymbolRemappingReader.h
+++ b/linux-x64/clang/include/llvm/Support/SymbolRemappingReader.h
@@ -68,7 +68,7 @@
 
 class SymbolRemappingParseError : public ErrorInfo<SymbolRemappingParseError> {
 public:
-  SymbolRemappingParseError(StringRef File, int64_t Line, Twine Message)
+  SymbolRemappingParseError(StringRef File, int64_t Line, const Twine &Message)
       : File(File), Line(Line), Message(Message.str()) {}
 
   void log(llvm::raw_ostream &OS) const override {
diff --git a/linux-x64/clang/include/llvm/Support/SystemUtils.h b/linux-x64/clang/include/llvm/Support/SystemUtils.h
index 77deddb..786bea3 100644
--- a/linux-x64/clang/include/llvm/Support/SystemUtils.h
+++ b/linux-x64/clang/include/llvm/Support/SystemUtils.h
@@ -15,17 +15,16 @@
 #define LLVM_SUPPORT_SYSTEMUTILS_H
 
 namespace llvm {
-  class raw_ostream;
+class raw_ostream;
 
 /// Determine if the raw_ostream provided is connected to a terminal. If so,
 /// generate a warning message to errs() advising against display of bitcode
 /// and return true. Otherwise just return false.
 /// Check for output written to a console
 bool CheckBitcodeOutputToConsole(
-  raw_ostream &stream_to_check, ///< The stream to be checked
-  bool print_warning = true     ///< Control whether warnings are printed
+    raw_ostream &stream_to_check ///< The stream to be checked
 );
 
-} // End llvm namespace
+} // namespace llvm
 
 #endif
diff --git a/linux-x64/clang/include/llvm/Support/TargetOpcodes.def b/linux-x64/clang/include/llvm/Support/TargetOpcodes.def
index fa02463..a63d404 100644
--- a/linux-x64/clang/include/llvm/Support/TargetOpcodes.def
+++ b/linux-x64/clang/include/llvm/Support/TargetOpcodes.def
@@ -77,6 +77,10 @@
 /// DBG_VALUE - a mapping of the llvm.dbg.value intrinsic
 HANDLE_TARGET_OPCODE(DBG_VALUE)
 
+/// DBG_INSTR_REF - A mapping of llvm.dbg.value referring to the instruction
+/// that defines the value, rather than a virtual register.
+HANDLE_TARGET_OPCODE(DBG_INSTR_REF)
+
 /// DBG_LABEL - a mapping of the llvm.dbg.label intrinsic
 HANDLE_TARGET_OPCODE(DBG_LABEL)
 
@@ -106,6 +110,9 @@
 HANDLE_TARGET_OPCODE(LIFETIME_START)
 HANDLE_TARGET_OPCODE(LIFETIME_END)
 
+/// Pseudo probe
+HANDLE_TARGET_OPCODE(PSEUDO_PROBE)
+
 /// A Stackmap instruction captures the location of live variables at its
 /// position in the instruction stream. It is followed by a shadow of bytes
 /// that must lie within the function and not contain another stackmap.
@@ -127,6 +134,12 @@
 /// additionally expand this pseudo after register allocation.
 HANDLE_TARGET_OPCODE(LOAD_STACK_GUARD)
 
+/// These are used to support call sites that must have the stack adjusted
+/// before the call (e.g. to initialize an argument passed by value).
+/// See llvm.call.preallocated.{setup,arg} in the LangRef for more details.
+HANDLE_TARGET_OPCODE(PREALLOCATED_SETUP)
+HANDLE_TARGET_OPCODE(PREALLOCATED_ARG)
+
 /// Call instruction with associated vm state for deoptimization and list
 /// of live pointers for relocation by the garbage collector.  It is
 /// intended to support garbage collection with fully precise relocating
@@ -279,12 +292,24 @@
 /// COPY is the relevant instruction.
 HANDLE_TARGET_OPCODE(G_BITCAST)
 
+/// Generic freeze.
+HANDLE_TARGET_OPCODE(G_FREEZE)
+
 /// INTRINSIC trunc intrinsic.
 HANDLE_TARGET_OPCODE(G_INTRINSIC_TRUNC)
 
 /// INTRINSIC round intrinsic.
 HANDLE_TARGET_OPCODE(G_INTRINSIC_ROUND)
 
+/// INTRINSIC round to integer intrinsic.
+HANDLE_TARGET_OPCODE(G_INTRINSIC_LRINT)
+
+/// INTRINSIC roundeven intrinsic.
+HANDLE_TARGET_OPCODE(G_INTRINSIC_ROUNDEVEN)
+
+/// INTRINSIC readcyclecounter
+HANDLE_TARGET_OPCODE(G_READCYCLECOUNTER)
+
 /// Generic load (including anyext load)
 HANDLE_TARGET_OPCODE(G_LOAD)
 
@@ -294,9 +319,21 @@
 /// Generic zeroext load
 HANDLE_TARGET_OPCODE(G_ZEXTLOAD)
 
+/// Generic indexed load (including anyext load)
+HANDLE_TARGET_OPCODE(G_INDEXED_LOAD)
+
+/// Generic indexed signext load
+HANDLE_TARGET_OPCODE(G_INDEXED_SEXTLOAD)
+
+/// Generic indexed zeroext load
+HANDLE_TARGET_OPCODE(G_INDEXED_ZEXTLOAD)
+
 /// Generic store.
 HANDLE_TARGET_OPCODE(G_STORE)
 
+/// Generic indexed store.
+HANDLE_TARGET_OPCODE(G_INDEXED_STORE)
+
 /// Generic atomic cmpxchg with internal success check.
 HANDLE_TARGET_OPCODE(G_ATOMIC_CMPXCHG_WITH_SUCCESS)
 
@@ -315,6 +352,8 @@
 HANDLE_TARGET_OPCODE(G_ATOMICRMW_MIN)
 HANDLE_TARGET_OPCODE(G_ATOMICRMW_UMAX)
 HANDLE_TARGET_OPCODE(G_ATOMICRMW_UMIN)
+HANDLE_TARGET_OPCODE(G_ATOMICRMW_FADD)
+HANDLE_TARGET_OPCODE(G_ATOMICRMW_FSUB)
 
 // Generic atomic fence
 HANDLE_TARGET_OPCODE(G_FENCE)
@@ -354,6 +393,7 @@
 
 // Generic sign extend
 HANDLE_TARGET_OPCODE(G_SEXT)
+HANDLE_TARGET_OPCODE(G_SEXT_INREG)
 
 // Generic zero extend
 HANDLE_TARGET_OPCODE(G_ZEXT)
@@ -367,6 +407,12 @@
 // Generic arithmetic right-shift
 HANDLE_TARGET_OPCODE(G_ASHR)
 
+// Generic funnel left shift
+HANDLE_TARGET_OPCODE(G_FSHL)
+
+// Generic funnel right shift
+HANDLE_TARGET_OPCODE(G_FSHR)
+
 /// Generic integer-base comparison, also applicable to vectors of integers.
 HANDLE_TARGET_OPCODE(G_ICMP)
 
@@ -424,6 +470,48 @@
 // the high half of the result.
 HANDLE_TARGET_OPCODE(G_SMULH)
 
+/// Generic saturating unsigned addition.
+HANDLE_TARGET_OPCODE(G_UADDSAT)
+
+/// Generic saturating signed addition.
+HANDLE_TARGET_OPCODE(G_SADDSAT)
+
+/// Generic saturating unsigned subtraction.
+HANDLE_TARGET_OPCODE(G_USUBSAT)
+
+/// Generic saturating signed subtraction.
+HANDLE_TARGET_OPCODE(G_SSUBSAT)
+
+/// Generic saturating unsigned left shift.
+HANDLE_TARGET_OPCODE(G_USHLSAT)
+
+/// Generic saturating signed left shift.
+HANDLE_TARGET_OPCODE(G_SSHLSAT)
+
+// Perform signed fixed point multiplication
+HANDLE_TARGET_OPCODE(G_SMULFIX)
+
+// Perform unsigned fixed point multiplication
+HANDLE_TARGET_OPCODE(G_UMULFIX)
+
+// Perform signed, saturating fixed point multiplication
+HANDLE_TARGET_OPCODE(G_SMULFIXSAT)
+
+// Perform unsigned, saturating fixed point multiplication
+HANDLE_TARGET_OPCODE(G_UMULFIXSAT)
+
+// Perform signed fixed point division
+HANDLE_TARGET_OPCODE(G_SDIVFIX)
+
+// Perform unsigned fixed point division
+HANDLE_TARGET_OPCODE(G_UDIVFIX)
+
+// Perform signed, saturating fixed point division
+HANDLE_TARGET_OPCODE(G_SDIVFIXSAT)
+
+// Perform unsigned, saturating fixed point division
+HANDLE_TARGET_OPCODE(G_UDIVFIXSAT)
+
 /// Generic FP addition.
 HANDLE_TARGET_OPCODE(G_FADD)
 
@@ -436,6 +524,9 @@
 /// Generic FMA multiplication. Behaves like llvm fma intrinsic
 HANDLE_TARGET_OPCODE(G_FMA)
 
+/// Generic FP multiply and add. Behaves as separate fmul and fadd.
+HANDLE_TARGET_OPCODE(G_FMAD)
+
 /// Generic FP division.
 HANDLE_TARGET_OPCODE(G_FDIV)
 
@@ -445,6 +536,9 @@
 /// Generic FP exponentiation.
 HANDLE_TARGET_OPCODE(G_FPOW)
 
+/// Generic FP exponentiation, with an integer exponent.
+HANDLE_TARGET_OPCODE(G_FPOWI)
+
 /// Generic base-e exponential of a value.
 HANDLE_TARGET_OPCODE(G_FEXP)
 
@@ -493,12 +587,23 @@
 /// Generic FP canonicalize value.
 HANDLE_TARGET_OPCODE(G_FCANONICALIZE)
 
-/// Generic pointer offset
-HANDLE_TARGET_OPCODE(G_GEP)
+/// FP min/max matching libm's fmin/fmax
+HANDLE_TARGET_OPCODE(G_FMINNUM)
+HANDLE_TARGET_OPCODE(G_FMAXNUM)
 
-/// Clear the specified number of low bits in a pointer. This rounds the value
-/// *down* to the given alignment.
-HANDLE_TARGET_OPCODE(G_PTR_MASK)
+/// FP min/max matching IEEE-754 2008's minnum/maxnum semantics.
+HANDLE_TARGET_OPCODE(G_FMINNUM_IEEE)
+HANDLE_TARGET_OPCODE(G_FMAXNUM_IEEE)
+
+/// FP min/max matching IEEE-754 2018 draft semantics.
+HANDLE_TARGET_OPCODE(G_FMINIMUM)
+HANDLE_TARGET_OPCODE(G_FMAXIMUM)
+
+/// Generic pointer offset
+HANDLE_TARGET_OPCODE(G_PTR_ADD)
+
+/// Clear the specified bits in a pointer.
+HANDLE_TARGET_OPCODE(G_PTRMASK)
 
 /// Generic signed integer minimum.
 HANDLE_TARGET_OPCODE(G_SMIN)
@@ -512,6 +617,9 @@
 /// Generic unsigned integer maximum.
 HANDLE_TARGET_OPCODE(G_UMAX)
 
+/// Generic integer absolute value.
+HANDLE_TARGET_OPCODE(G_ABS)
+
 /// Generic BRANCH instruction. This is an unconditional branch.
 HANDLE_TARGET_OPCODE(G_BR)
 
@@ -545,6 +653,9 @@
 /// Generic byte swap.
 HANDLE_TARGET_OPCODE(G_BSWAP)
 
+/// Generic bit reverse.
+HANDLE_TARGET_OPCODE(G_BITREVERSE)
+
 /// Floating point ceil.
 HANDLE_TARGET_OPCODE(G_FCEIL)
 
@@ -575,12 +686,54 @@
 /// Generic jump table address
 HANDLE_TARGET_OPCODE(G_JUMP_TABLE)
 
-// TODO: Add more generic opcodes as we move along.
+/// Generic dynamic stack allocation.
+HANDLE_TARGET_OPCODE(G_DYN_STACKALLOC)
+
+/// Strict floating point instructions.
+HANDLE_TARGET_OPCODE(G_STRICT_FADD)
+HANDLE_TARGET_OPCODE(G_STRICT_FSUB)
+HANDLE_TARGET_OPCODE(G_STRICT_FMUL)
+HANDLE_TARGET_OPCODE(G_STRICT_FDIV)
+HANDLE_TARGET_OPCODE(G_STRICT_FREM)
+HANDLE_TARGET_OPCODE(G_STRICT_FMA)
+HANDLE_TARGET_OPCODE(G_STRICT_FSQRT)
+
+/// read_register intrinsic
+HANDLE_TARGET_OPCODE(G_READ_REGISTER)
+
+/// write_register intrinsic
+HANDLE_TARGET_OPCODE(G_WRITE_REGISTER)
+
+/// llvm.memcpy intrinsic
+HANDLE_TARGET_OPCODE(G_MEMCPY)
+
+/// llvm.memmove intrinsic
+HANDLE_TARGET_OPCODE(G_MEMMOVE)
+
+/// llvm.memset intrinsic
+HANDLE_TARGET_OPCODE(G_MEMSET)
+
+/// Vector reductions
+HANDLE_TARGET_OPCODE(G_VECREDUCE_SEQ_FADD)
+HANDLE_TARGET_OPCODE(G_VECREDUCE_SEQ_FMUL)
+HANDLE_TARGET_OPCODE(G_VECREDUCE_FADD)
+HANDLE_TARGET_OPCODE(G_VECREDUCE_FMUL)
+HANDLE_TARGET_OPCODE(G_VECREDUCE_FMAX)
+HANDLE_TARGET_OPCODE(G_VECREDUCE_FMIN)
+HANDLE_TARGET_OPCODE(G_VECREDUCE_ADD)
+HANDLE_TARGET_OPCODE(G_VECREDUCE_MUL)
+HANDLE_TARGET_OPCODE(G_VECREDUCE_AND)
+HANDLE_TARGET_OPCODE(G_VECREDUCE_OR)
+HANDLE_TARGET_OPCODE(G_VECREDUCE_XOR)
+HANDLE_TARGET_OPCODE(G_VECREDUCE_SMAX)
+HANDLE_TARGET_OPCODE(G_VECREDUCE_SMIN)
+HANDLE_TARGET_OPCODE(G_VECREDUCE_UMAX)
+HANDLE_TARGET_OPCODE(G_VECREDUCE_UMIN)
 
 /// Marker for the end of the generic opcode.
 /// This is used to check if an opcode is in the range of the
 /// generic opcodes.
-HANDLE_TARGET_OPCODE_MARKER(PRE_ISEL_GENERIC_OPCODE_END, G_JUMP_TABLE)
+HANDLE_TARGET_OPCODE_MARKER(PRE_ISEL_GENERIC_OPCODE_END, G_VECREDUCE_UMIN)
 
 /// BUILTIN_OP_END - This must be the last enum value in this list.
 /// The target-specific post-isel opcode values start here.
diff --git a/linux-x64/clang/include/llvm/Support/TargetParser.h b/linux-x64/clang/include/llvm/Support/TargetParser.h
index a7e1a75..450e713 100644
--- a/linux-x64/clang/include/llvm/Support/TargetParser.h
+++ b/linux-x64/clang/include/llvm/Support/TargetParser.h
@@ -25,55 +25,12 @@
 class StringRef;
 
 // Target specific information in their own namespaces.
-// (ARM/AArch64 are declared in ARM/AArch64TargetParser.h)
+// (ARM/AArch64/X86 are declared in ARM/AArch64/X86TargetParser.h)
 // These should be generated from TableGen because the information is already
 // there, and there is where new information about targets will be added.
 // FIXME: To TableGen this we need to make some table generated files available
 // even if the back-end is not compiled with LLVM, plus we need to create a new
 // back-end to TableGen to create these clean tables.
-namespace X86 {
-
-// This should be kept in sync with libcc/compiler-rt as its included by clang
-// as a proxy for what's in libgcc/compiler-rt.
-enum ProcessorVendors : unsigned {
-  VENDOR_DUMMY,
-#define X86_VENDOR(ENUM, STRING) \
-  ENUM,
-#include "llvm/Support/X86TargetParser.def"
-  VENDOR_OTHER
-};
-
-// This should be kept in sync with libcc/compiler-rt as its included by clang
-// as a proxy for what's in libgcc/compiler-rt.
-enum ProcessorTypes : unsigned {
-  CPU_TYPE_DUMMY,
-#define X86_CPU_TYPE(ARCHNAME, ENUM) \
-  ENUM,
-#include "llvm/Support/X86TargetParser.def"
-  CPU_TYPE_MAX
-};
-
-// This should be kept in sync with libcc/compiler-rt as its included by clang
-// as a proxy for what's in libgcc/compiler-rt.
-enum ProcessorSubtypes : unsigned {
-  CPU_SUBTYPE_DUMMY,
-#define X86_CPU_SUBTYPE(ARCHNAME, ENUM) \
-  ENUM,
-#include "llvm/Support/X86TargetParser.def"
-  CPU_SUBTYPE_MAX
-};
-
-// This should be kept in sync with libcc/compiler-rt as it should be used
-// by clang as a proxy for what's in libgcc/compiler-rt.
-enum ProcessorFeatures {
-#define X86_FEATURE(VAL, ENUM) \
-  ENUM = VAL,
-#include "llvm/Support/X86TargetParser.def"
-
-};
-
-} // namespace X86
-
 namespace AMDGPU {
 
 /// GPU kinds supported by the AMDGPU target.
@@ -105,17 +62,20 @@
   // AMDGCN-based processors.
   GK_GFX600 = 32,
   GK_GFX601 = 33,
+  GK_GFX602 = 34,
 
   GK_GFX700 = 40,
   GK_GFX701 = 41,
   GK_GFX702 = 42,
   GK_GFX703 = 43,
   GK_GFX704 = 44,
+  GK_GFX705 = 45,
 
   GK_GFX801 = 50,
   GK_GFX802 = 51,
   GK_GFX803 = 52,
-  GK_GFX810 = 53,
+  GK_GFX805 = 53,
+  GK_GFX810 = 54,
 
   GK_GFX900 = 60,
   GK_GFX902 = 61,
@@ -123,13 +83,18 @@
   GK_GFX906 = 63,
   GK_GFX908 = 64,
   GK_GFX909 = 65,
+  GK_GFX90C = 66,
 
   GK_GFX1010 = 71,
   GK_GFX1011 = 72,
   GK_GFX1012 = 73,
+  GK_GFX1030 = 75,
+  GK_GFX1031 = 76,
+  GK_GFX1032 = 77,
+  GK_GFX1033 = 78,
 
   GK_AMDGCN_FIRST = GK_GFX600,
-  GK_AMDGCN_LAST = GK_GFX1012,
+  GK_AMDGCN_LAST = GK_GFX1033,
 };
 
 /// Instruction set architecture version.
@@ -151,12 +116,21 @@
 
   // Common features.
   FEATURE_FAST_FMA_F32 = 1 << 4,
-  FEATURE_FAST_DENORMAL_F32 = 1 << 5
+  FEATURE_FAST_DENORMAL_F32 = 1 << 5,
+
+  // Wavefront 32 is available.
+  FEATURE_WAVE32 = 1 << 6,
+
+  // Xnack is available.
+  FEATURE_XNACK = 1 << 7,
+
+  // Sram-ecc is available.
+  FEATURE_SRAMECC = 1 << 8,
 };
 
 StringRef getArchNameAMDGCN(GPUKind AK);
 StringRef getArchNameR600(GPUKind AK);
-StringRef getCanonicalArchName(StringRef Arch);
+StringRef getCanonicalArchName(const Triple &T, StringRef Arch);
 GPUKind parseArchAMDGCN(StringRef CPU);
 GPUKind parseArchR600(StringRef CPU);
 unsigned getArchAttrAMDGCN(GPUKind AK);
@@ -169,6 +143,36 @@
 
 } // namespace AMDGPU
 
+namespace RISCV {
+
+enum CPUKind : unsigned {
+#define PROC(ENUM, NAME, FEATURES, DEFAULT_MARCH) CK_##ENUM,
+#include "RISCVTargetParser.def"
+};
+
+enum FeatureKind : unsigned {
+  FK_INVALID = 0,
+  FK_NONE = 1,
+  FK_STDEXTM = 1 << 2,
+  FK_STDEXTA = 1 << 3,
+  FK_STDEXTF = 1 << 4,
+  FK_STDEXTD = 1 << 5,
+  FK_STDEXTC = 1 << 6,
+  FK_64BIT = 1 << 7,
+};
+
+bool checkCPUKind(CPUKind Kind, bool IsRV64);
+bool checkTuneCPUKind(CPUKind Kind, bool IsRV64);
+CPUKind parseCPUKind(StringRef CPU);
+CPUKind parseTuneCPUKind(StringRef CPU, bool IsRV64);
+StringRef getMArchFromMcpu(StringRef CPU);
+void fillValidCPUArchList(SmallVectorImpl<StringRef> &Values, bool IsRV64);
+void fillValidTuneCPUArchList(SmallVectorImpl<StringRef> &Values, bool IsRV64);
+bool getCPUFeaturesExceptStdExt(CPUKind Kind, std::vector<StringRef> &Features);
+StringRef resolveTuneCPUAlias(StringRef TuneCPU, bool IsRV64);
+
+} // namespace RISCV
+
 } // namespace llvm
 
 #endif
diff --git a/linux-x64/clang/include/llvm/Support/TargetRegistry.h b/linux-x64/clang/include/llvm/Support/TargetRegistry.h
index bf75650..2c65eb6 100644
--- a/linux-x64/clang/include/llvm/Support/TargetRegistry.h
+++ b/linux-x64/clang/include/llvm/Support/TargetRegistry.h
@@ -128,7 +128,8 @@
   using ArchMatchFnTy = bool (*)(Triple::ArchType Arch);
 
   using MCAsmInfoCtorFnTy = MCAsmInfo *(*)(const MCRegisterInfo &MRI,
-                                           const Triple &TT);
+                                           const Triple &TT,
+                                           const MCTargetOptions &Options);
   using MCInstrInfoCtorFnTy = MCInstrInfo *(*)();
   using MCInstrAnalysisCtorFnTy = MCInstrAnalysis *(*)(const MCInstrInfo *Info);
   using MCRegInfoCtorFnTy = MCRegisterInfo *(*)(const Triple &TT);
@@ -335,11 +336,11 @@
   /// feature set; it should always be provided. Generally this should be
   /// either the target triple from the module, or the target triple of the
   /// host if that does not exist.
-  MCAsmInfo *createMCAsmInfo(const MCRegisterInfo &MRI,
-                             StringRef TheTriple) const {
+  MCAsmInfo *createMCAsmInfo(const MCRegisterInfo &MRI, StringRef TheTriple,
+                             const MCTargetOptions &Options) const {
     if (!MCAsmInfoCtorFn)
       return nullptr;
-    return MCAsmInfoCtorFn(MRI, Triple(TheTriple));
+    return MCAsmInfoCtorFn(MRI, Triple(TheTriple), Options);
   }
 
   /// createMCInstrInfo - Create a MCInstrInfo implementation.
@@ -473,7 +474,7 @@
                                      const MCSubtargetInfo &STI, bool RelaxAll,
                                      bool IncrementalLinkerCompatible,
                                      bool DWARFMustBeAtTheEnd) const {
-    MCStreamer *S;
+    MCStreamer *S = nullptr;
     switch (T.getObjectFormat()) {
     case Triple::UnknownObjectFormat:
       llvm_unreachable("Unknown object format");
@@ -509,9 +510,11 @@
         S = createWasmStreamer(Ctx, std::move(TAB), std::move(OW),
                                std::move(Emitter), RelaxAll);
       break;
+    case Triple::GOFF:
+      report_fatal_error("GOFF MCObjectStreamer not implemented yet");
     case Triple::XCOFF:
-        S = createXCOFFStreamer(Ctx, std::move(TAB), std::move(OW),
-                                std::move(Emitter), RelaxAll);
+      S = createXCOFFStreamer(Ctx, std::move(TAB), std::move(OW),
+                              std::move(Emitter), RelaxAll);
       break;
     }
     if (ObjectTargetStreamerCtorFn)
@@ -948,9 +951,9 @@
   }
 
 private:
-  static MCAsmInfo *Allocator(const MCRegisterInfo & /*MRI*/,
-                              const Triple &TT) {
-    return new MCAsmInfoImpl(TT);
+  static MCAsmInfo *Allocator(const MCRegisterInfo & /*MRI*/, const Triple &TT,
+                              const MCTargetOptions &Options) {
+    return new MCAsmInfoImpl(TT, Options);
   }
 };
 
diff --git a/linux-x64/clang/include/llvm/Support/TaskQueue.h b/linux-x64/clang/include/llvm/Support/TaskQueue.h
index df2ffde..6901a55 100644
--- a/linux-x64/clang/include/llvm/Support/TaskQueue.h
+++ b/linux-x64/clang/include/llvm/Support/TaskQueue.h
@@ -38,7 +38,7 @@
   // type-specialized domain (before type erasure) and then erase this into a
   // std::function.
   template <typename Callable> struct Task {
-    using ResultTy = typename std::result_of<Callable()>::type;
+    using ResultTy = std::result_of_t<Callable()>;
     explicit Task(Callable C, TaskQueue &Parent)
         : C(std::move(C)), P(std::make_shared<std::promise<ResultTy>>()),
           Parent(&Parent) {}
@@ -78,13 +78,13 @@
   /// used to wait for the task (and all previous tasks that have not yet
   /// completed) to finish.
   template <typename Callable>
-  std::future<typename std::result_of<Callable()>::type> async(Callable &&C) {
+  std::future<std::result_of_t<Callable()>> async(Callable &&C) {
 #if !LLVM_ENABLE_THREADS
     static_assert(false,
                   "TaskQueue requires building with LLVM_ENABLE_THREADS!");
 #endif
     Task<Callable> T{std::move(C), *this};
-    using ResultTy = typename std::result_of<Callable()>::type;
+    using ResultTy = std::result_of_t<Callable()>;
     std::future<ResultTy> F = T.P->get_future();
     {
       std::lock_guard<std::mutex> Lock(QueueLock);
@@ -98,7 +98,7 @@
         IsTaskInFlight = true;
       }
     }
-    return std::move(F);
+    return F;
   }
 
 private:
diff --git a/linux-x64/clang/include/llvm/Support/ThreadPool.h b/linux-x64/clang/include/llvm/Support/ThreadPool.h
index 4bcbaa3..528fb32 100644
--- a/linux-x64/clang/include/llvm/Support/ThreadPool.h
+++ b/linux-x64/clang/include/llvm/Support/ThreadPool.h
@@ -14,6 +14,7 @@
 #define LLVM_SUPPORT_THREAD_POOL_H
 
 #include "llvm/Config/llvm-config.h"
+#include "llvm/Support/Threading.h"
 #include "llvm/Support/thread.h"
 
 #include <future>
@@ -38,12 +39,11 @@
   using TaskTy = std::function<void()>;
   using PackagedTaskTy = std::packaged_task<void()>;
 
-  /// Construct a pool with the number of threads found by
-  /// hardware_concurrency().
-  ThreadPool();
-
-  /// Construct a pool of \p ThreadCount threads
-  ThreadPool(unsigned ThreadCount);
+  /// Construct a pool using the hardware strategy \p S for mapping hardware
+  /// execution resources (threads, cores, CPUs)
+  /// Defaults to using the maximum execution resources in the system, but
+  /// accounting for the affinity mask.
+  ThreadPool(ThreadPoolStrategy S = hardware_concurrency());
 
   /// Blocking destructor: the pool will wait for all the threads to complete.
   ~ThreadPool();
@@ -68,7 +68,11 @@
   /// It is an error to try to add new tasks while blocking on this call.
   void wait();
 
+  unsigned getThreadCount() const { return ThreadCount; }
+
 private:
+  bool workCompletedUnlocked() { return !ActiveThreads && Tasks.empty(); }
+
   /// Asynchronous submission of a task to the pool. The returned future can be
   /// used to wait for the task to finish and is *non-blocking* on destruction.
   std::shared_future<void> asyncImpl(TaskTy F);
@@ -83,17 +87,18 @@
   std::mutex QueueLock;
   std::condition_variable QueueCondition;
 
-  /// Locking and signaling for job completion
-  std::mutex CompletionLock;
+  /// Signaling for job completion
   std::condition_variable CompletionCondition;
 
   /// Keep track of the number of thread actually busy
-  std::atomic<unsigned> ActiveThreads;
+  unsigned ActiveThreads = 0;
 
 #if LLVM_ENABLE_THREADS // avoids warning for unused variable
   /// Signal for the destruction of the pool, asking thread to exit.
-  bool EnableFlag;
+  bool EnableFlag = true;
 #endif
+
+  unsigned ThreadCount;
 };
 }
 
diff --git a/linux-x64/clang/include/llvm/Support/Threading.h b/linux-x64/clang/include/llvm/Support/Threading.h
index 46d413d..46cf825 100644
--- a/linux-x64/clang/include/llvm/Support/Threading.h
+++ b/linux-x64/clang/include/llvm/Support/Threading.h
@@ -14,6 +14,8 @@
 #ifndef LLVM_SUPPORT_THREADING_H
 #define LLVM_SUPPORT_THREADING_H
 
+#include "llvm/ADT/BitVector.h"
+#include "llvm/ADT/FunctionExtras.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Config/llvm-config.h" // for LLVM_ON_UNIX
 #include "llvm/Support/Compiler.h"
@@ -52,9 +54,8 @@
 /// false otherwise.
 bool llvm_is_multithreaded();
 
-/// llvm_execute_on_thread - Execute the given \p UserFn on a separate
-/// thread, passing it the provided \p UserData and waits for thread
-/// completion.
+/// Execute the given \p UserFn on a separate thread, passing it the provided \p
+/// UserData and waits for thread completion.
 ///
 /// This function does not guarantee that the code will actually be executed
 /// on a separate thread or honoring the requested stack size, but tries to do
@@ -62,10 +63,26 @@
 ///
 /// \param UserFn - The callback to execute.
 /// \param UserData - An argument to pass to the callback function.
-/// \param RequestedStackSize - If non-zero, a requested size (in bytes) for
-/// the thread stack.
-void llvm_execute_on_thread(void (*UserFn)(void *), void *UserData,
-                            unsigned RequestedStackSize = 0);
+/// \param StackSizeInBytes - A requested size (in bytes) for the thread stack
+/// (or None for default)
+void llvm_execute_on_thread(
+    void (*UserFn)(void *), void *UserData,
+    llvm::Optional<unsigned> StackSizeInBytes = llvm::None);
+
+/// Schedule the given \p Func for execution on a separate thread, then return
+/// to the caller immediately. Roughly equivalent to
+/// `std::thread(Func).detach()`, except it allows requesting a specific stack
+/// size, if supported for the platform.
+///
+/// This function would report a fatal error if it can't execute the code
+/// on a separate thread.
+///
+/// \param Func - The callback to execute.
+/// \param StackSizeInBytes - A requested size (in bytes) for the thread stack
+/// (or None for default)
+void llvm_execute_on_thread_async(
+    llvm::unique_function<void()> Func,
+    llvm::Optional<unsigned> StackSizeInBytes = llvm::None);
 
 #if LLVM_THREADING_USE_STD_CALL_ONCE
 
@@ -127,20 +144,91 @@
 #endif
   }
 
-  /// Get the amount of currency to use for tasks requiring significant
-  /// memory or other resources. Currently based on physical cores, if
-  /// available for the host system, otherwise falls back to
-  /// thread::hardware_concurrency().
-  /// Returns 1 when LLVM is configured with LLVM_ENABLE_THREADS=OFF
-  unsigned heavyweight_hardware_concurrency();
+  /// This tells how a thread pool will be used
+  class ThreadPoolStrategy {
+  public:
+    // The default value (0) means all available threads should be used,
+    // taking the affinity mask into account. If set, this value only represents
+    // a suggested high bound, the runtime might choose a lower value (not
+    // higher).
+    unsigned ThreadsRequested = 0;
 
-  /// Get the number of threads that the current program can execute
-  /// concurrently. On some systems std::thread::hardware_concurrency() returns
-  /// the total number of cores, without taking affinity into consideration.
-  /// Returns 1 when LLVM is configured with LLVM_ENABLE_THREADS=OFF.
-  /// Fallback to std::thread::hardware_concurrency() if sched_getaffinity is
-  /// not available.
-  unsigned hardware_concurrency();
+    // If SMT is active, use hyper threads. If false, there will be only one
+    // std::thread per core.
+    bool UseHyperThreads = true;
+
+    // If set, will constrain 'ThreadsRequested' to the number of hardware
+    // threads, or hardware cores.
+    bool Limit = false;
+
+    /// Retrieves the max available threads for the current strategy. This
+    /// accounts for affinity masks and takes advantage of all CPU sockets.
+    unsigned compute_thread_count() const;
+
+    /// Assign the current thread to an ideal hardware CPU or NUMA node. In a
+    /// multi-socket system, this ensures threads are assigned to all CPU
+    /// sockets. \p ThreadPoolNum represents a number bounded by [0,
+    /// compute_thread_count()).
+    void apply_thread_strategy(unsigned ThreadPoolNum) const;
+
+    /// Finds the CPU socket where a thread should go. Returns 'None' if the
+    /// thread shall remain on the actual CPU socket.
+    Optional<unsigned> compute_cpu_socket(unsigned ThreadPoolNum) const;
+  };
+
+  /// Build a strategy from a number of threads as a string provided in \p Num.
+  /// When Num is above the max number of threads specified by the \p Default
+  /// strategy, we attempt to equally allocate the threads on all CPU sockets.
+  /// "0" or an empty string will return the \p Default strategy.
+  /// "all" for using all hardware threads.
+  Optional<ThreadPoolStrategy>
+  get_threadpool_strategy(StringRef Num, ThreadPoolStrategy Default = {});
+
+  /// Returns a thread strategy for tasks requiring significant memory or other
+  /// resources. To be used for workloads where hardware_concurrency() proves to
+  /// be less efficient. Avoid this strategy if doing lots of I/O. Currently
+  /// based on physical cores, if available for the host system, otherwise falls
+  /// back to hardware_concurrency(). Returns 1 when LLVM is configured with
+  /// LLVM_ENABLE_THREADS = OFF.
+  inline ThreadPoolStrategy
+  heavyweight_hardware_concurrency(unsigned ThreadCount = 0) {
+    ThreadPoolStrategy S;
+    S.UseHyperThreads = false;
+    S.ThreadsRequested = ThreadCount;
+    return S;
+  }
+
+  /// Like heavyweight_hardware_concurrency() above, but builds a strategy
+  /// based on the rules described for get_threadpool_strategy().
+  /// If \p Num is invalid, returns a default strategy where one thread per
+  /// hardware core is used.
+  inline ThreadPoolStrategy heavyweight_hardware_concurrency(StringRef Num) {
+    Optional<ThreadPoolStrategy> S =
+        get_threadpool_strategy(Num, heavyweight_hardware_concurrency());
+    if (S)
+      return *S;
+    return heavyweight_hardware_concurrency();
+  }
+
+  /// Returns a default thread strategy where all available hardware resources
+  /// are to be used, except for those initially excluded by an affinity mask.
+  /// This function takes affinity into consideration. Returns 1 when LLVM is
+  /// configured with LLVM_ENABLE_THREADS=OFF.
+  inline ThreadPoolStrategy hardware_concurrency(unsigned ThreadCount = 0) {
+    ThreadPoolStrategy S;
+    S.ThreadsRequested = ThreadCount;
+    return S;
+  }
+
+  /// Returns an optimal thread strategy to execute specified amount of tasks.
+  /// This strategy should prevent us from creating too many threads if we
+  /// occasionaly have an unexpectedly small amount of tasks.
+  inline ThreadPoolStrategy optimal_concurrency(unsigned TaskCount = 0) {
+    ThreadPoolStrategy S;
+    S.Limit = true;
+    S.ThreadsRequested = TaskCount;
+    return S;
+  }
 
   /// Return the current thread id, as used in various OS system calls.
   /// Note that not all platforms guarantee that the value returned will be
@@ -168,6 +256,14 @@
   /// the operation succeeded or failed is returned.
   void get_thread_name(SmallVectorImpl<char> &Name);
 
+  /// Returns a mask that represents on which hardware thread, core, CPU, NUMA
+  /// group, the calling thread can be executed. On Windows, threads cannot
+  /// cross CPU sockets boundaries.
+  llvm::BitVector get_thread_affinity_mask();
+
+  /// Returns how many physical CPUs or NUMA groups the system has.
+  unsigned get_cpus();
+
   enum class ThreadPriority {
     Background = 0,
     Default = 1,
diff --git a/linux-x64/clang/include/llvm/Support/TimeProfiler.h b/linux-x64/clang/include/llvm/Support/TimeProfiler.h
index 72b6f71..b6f8a64 100644
--- a/linux-x64/clang/include/llvm/Support/TimeProfiler.h
+++ b/linux-x64/clang/include/llvm/Support/TimeProfiler.h
@@ -9,31 +9,44 @@
 #ifndef LLVM_SUPPORT_TIME_PROFILER_H
 #define LLVM_SUPPORT_TIME_PROFILER_H
 
+#include "llvm/Support/Error.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace llvm {
 
 struct TimeTraceProfiler;
-extern TimeTraceProfiler *TimeTraceProfilerInstance;
+TimeTraceProfiler *getTimeTraceProfilerInstance();
 
 /// Initialize the time trace profiler.
 /// This sets up the global \p TimeTraceProfilerInstance
 /// variable to be the profiler instance.
-void timeTraceProfilerInitialize();
+void timeTraceProfilerInitialize(unsigned TimeTraceGranularity,
+                                 StringRef ProcName);
 
 /// Cleanup the time trace profiler, if it was initialized.
 void timeTraceProfilerCleanup();
 
+/// Finish a time trace profiler running on a worker thread.
+void timeTraceProfilerFinishThread();
+
 /// Is the time trace profiler enabled, i.e. initialized?
 inline bool timeTraceProfilerEnabled() {
-  return TimeTraceProfilerInstance != nullptr;
+  return getTimeTraceProfilerInstance() != nullptr;
 }
 
-/// Write profiling data to output file.
+/// Write profiling data to output stream.
 /// Data produced is JSON, in Chrome "Trace Event" format, see
 /// https://docs.google.com/document/d/1CvAClvFfyA5R-PhYUmn5OOQtYMH4h6I0nSsKchNAySU/preview
 void timeTraceProfilerWrite(raw_pwrite_stream &OS);
 
+/// Write profiling data to a file.
+/// The function will write to \p PreferredFileName if provided, if not
+/// then will write to \p FallbackFileName appending .time-trace.
+/// Returns a StringError indicating a failure if the function is
+/// unable to open the file for writing.
+Error timeTraceProfilerWrite(StringRef PreferredFileName,
+                             StringRef FallbackFileName);
+
 /// Manually begin a time section, with the given \p Name and \p Detail.
 /// Profiler copies the string data, so the pointers can be given into
 /// temporaries. Time sections can be hierarchical; every Begin must have a
@@ -57,16 +70,20 @@
   TimeTraceScope(TimeTraceScope &&) = delete;
   TimeTraceScope &operator=(TimeTraceScope &&) = delete;
 
+  TimeTraceScope(StringRef Name) {
+    if (getTimeTraceProfilerInstance() != nullptr)
+      timeTraceProfilerBegin(Name, StringRef(""));
+  }
   TimeTraceScope(StringRef Name, StringRef Detail) {
-    if (TimeTraceProfilerInstance != nullptr)
+    if (getTimeTraceProfilerInstance() != nullptr)
       timeTraceProfilerBegin(Name, Detail);
   }
   TimeTraceScope(StringRef Name, llvm::function_ref<std::string()> Detail) {
-    if (TimeTraceProfilerInstance != nullptr)
+    if (getTimeTraceProfilerInstance() != nullptr)
       timeTraceProfilerBegin(Name, Detail);
   }
   ~TimeTraceScope() {
-    if (TimeTraceProfilerInstance != nullptr)
+    if (getTimeTraceProfilerInstance() != nullptr)
       timeTraceProfilerEnd();
   }
 };
diff --git a/linux-x64/clang/include/llvm/Support/Timer.h b/linux-x64/clang/include/llvm/Support/Timer.h
index 76c9bc7..045ac44 100644
--- a/linux-x64/clang/include/llvm/Support/Timer.h
+++ b/linux-x64/clang/include/llvm/Support/Timer.h
@@ -78,18 +78,18 @@
   TimeRecord StartTime;     ///< The time startTimer() was last called.
   std::string Name;         ///< The name of this time variable.
   std::string Description;  ///< Description of this time variable.
-  bool Running;             ///< Is the timer currently running?
-  bool Triggered;           ///< Has the timer ever been triggered?
+  bool Running = false;     ///< Is the timer currently running?
+  bool Triggered = false;   ///< Has the timer ever been triggered?
   TimerGroup *TG = nullptr; ///< The TimerGroup this Timer is in.
 
-  Timer **Prev;             ///< Pointer to \p Next of previous timer in group.
-  Timer *Next;              ///< Next timer in the group.
+  Timer **Prev = nullptr;   ///< Pointer to \p Next of previous timer in group.
+  Timer *Next = nullptr;    ///< Next timer in the group.
 public:
-  explicit Timer(StringRef Name, StringRef Description) {
-    init(Name, Description);
+  explicit Timer(StringRef TimerName, StringRef TimerDescription) {
+    init(TimerName, TimerDescription);
   }
-  Timer(StringRef Name, StringRef Description, TimerGroup &tg) {
-    init(Name, Description, tg);
+  Timer(StringRef TimerName, StringRef TimerDescription, TimerGroup &tg) {
+    init(TimerName, TimerDescription, tg);
   }
   Timer(const Timer &RHS) {
     assert(!RHS.TG && "Can only copy uninitialized timers");
@@ -102,8 +102,8 @@
 
   /// Create an uninitialized timer, client must use 'init'.
   explicit Timer() {}
-  void init(StringRef Name, StringRef Description);
-  void init(StringRef Name, StringRef Description, TimerGroup &tg);
+  void init(StringRef TimerName, StringRef TimerDescription);
+  void init(StringRef TimerName, StringRef TimerDescription, TimerGroup &tg);
 
   const std::string &getName() const { return Name; }
   const std::string &getDescription() const { return Description; }
@@ -174,6 +174,7 @@
     std::string Description;
 
     PrintRecord(const PrintRecord &Other) = default;
+    PrintRecord &operator=(const PrintRecord &Other) = default;
     PrintRecord(const TimeRecord &Time, const std::string &Name,
                 const std::string &Description)
       : Time(Time), Name(Name), Description(Description) {}
@@ -229,6 +230,11 @@
   /// used by the Statistic code to influence the construction and destruction
   /// order of the global timer lists.
   static void ConstructTimerLists();
+
+  /// This makes the default group unmanaged, and lets the user manage the
+  /// group's lifetime.
+  static std::unique_ptr<TimerGroup> aquireDefaultGroup();
+
 private:
   friend class Timer;
   friend void PrintStatisticsJSON(raw_ostream &OS);
diff --git a/linux-x64/clang/include/llvm/Support/ToolOutputFile.h b/linux-x64/clang/include/llvm/Support/ToolOutputFile.h
index a99e327..cf01b9e 100644
--- a/linux-x64/clang/include/llvm/Support/ToolOutputFile.h
+++ b/linux-x64/clang/include/llvm/Support/ToolOutputFile.h
@@ -13,6 +13,7 @@
 #ifndef LLVM_SUPPORT_TOOLOUTPUTFILE_H
 #define LLVM_SUPPORT_TOOLOUTPUTFILE_H
 
+#include "llvm/ADT/Optional.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace llvm {
@@ -38,8 +39,12 @@
     ~CleanupInstaller();
   } Installer;
 
-  /// The contained stream. This is intentionally declared after Installer.
-  raw_fd_ostream OS;
+  /// Storage for the stream, if we're owning our own stream. This is
+  /// intentionally declared after Installer.
+  Optional<raw_fd_ostream> OSHolder;
+
+  /// The actual stream to use.
+  raw_fd_ostream *OS;
 
 public:
   /// This constructor's arguments are passed to raw_fd_ostream's
@@ -50,7 +55,7 @@
   ToolOutputFile(StringRef Filename, int FD);
 
   /// Return the contained raw_fd_ostream.
-  raw_fd_ostream &os() { return OS; }
+  raw_fd_ostream &os() { return *OS; }
 
   /// Indicate that the tool's job wrt this output file has been successful and
   /// the file should not be deleted.
diff --git a/linux-x64/clang/include/llvm/Support/TrailingObjects.h b/linux-x64/clang/include/llvm/Support/TrailingObjects.h
index 8cf4f7a..0d9c450 100644
--- a/linux-x64/clang/include/llvm/Support/TrailingObjects.h
+++ b/linux-x64/clang/include/llvm/Support/TrailingObjects.h
@@ -47,6 +47,7 @@
 #define LLVM_SUPPORT_TRAILINGOBJECTS_H
 
 #include "llvm/Support/AlignOf.h"
+#include "llvm/Support/Alignment.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/type_traits.h"
@@ -87,11 +88,6 @@
   template <typename T> struct OverloadToken {};
 };
 
-/// This helper template works-around MSVC 2013's lack of useful
-/// alignas() support. The argument to alignas(), in MSVC, is
-/// required to be a literal integer. But, you *can* use template
-/// specialization to select between a bunch of different alignas()
-/// expressions...
 template <int Align>
 class TrailingObjectsAligner : public TrailingObjectsBase {};
 template <>
@@ -172,7 +168,7 @@
 
     if (requiresRealignment())
       return reinterpret_cast<const NextTy *>(
-          llvm::alignAddr(Ptr, alignof(NextTy)));
+          alignAddr(Ptr, Align::Of<NextTy>()));
     else
       return reinterpret_cast<const NextTy *>(Ptr);
   }
@@ -186,7 +182,7 @@
                     Obj, TrailingObjectsBase::OverloadToken<PrevTy>());
 
     if (requiresRealignment())
-      return reinterpret_cast<NextTy *>(llvm::alignAddr(Ptr, alignof(NextTy)));
+      return reinterpret_cast<NextTy *>(alignAddr(Ptr, Align::Of<NextTy>()));
     else
       return reinterpret_cast<NextTy *>(Ptr);
   }
@@ -254,9 +250,7 @@
   // because BaseTy isn't complete at class instantiation time, but
   // will be by the time this function is instantiated.
   static void verifyTrailingObjectsAssertions() {
-#ifdef LLVM_IS_FINAL
-    static_assert(LLVM_IS_FINAL(BaseTy), "BaseTy must be final.");
-#endif
+    static_assert(std::is_final<BaseTy>(), "BaseTy must be final.");
   }
 
   // These two methods are the base of the recursion for this method.
@@ -332,8 +326,8 @@
   /// used in the class; they are supplied here redundantly only so
   /// that it's clear what the counts are counting in callers.
   template <typename... Tys>
-  static constexpr typename std::enable_if<
-      std::is_same<Foo<TrailingTys...>, Foo<Tys...>>::value, size_t>::type
+  static constexpr std::enable_if_t<
+      std::is_same<Foo<TrailingTys...>, Foo<Tys...>>::value, size_t>
   additionalSizeToAlloc(typename trailing_objects_internal::ExtractSecondType<
                         TrailingTys, size_t>::type... Counts) {
     return ParentType::additionalSizeToAllocImpl(0, Counts...);
@@ -344,8 +338,8 @@
   /// additionalSizeToAlloc, except it *does* include the size of the base
   /// object.
   template <typename... Tys>
-  static constexpr typename std::enable_if<
-      std::is_same<Foo<TrailingTys...>, Foo<Tys...>>::value, size_t>::type
+  static constexpr std::enable_if_t<
+      std::is_same<Foo<TrailingTys...>, Foo<Tys...>>::value, size_t>
   totalSizeToAlloc(typename trailing_objects_internal::ExtractSecondType<
                    TrailingTys, size_t>::type... Counts) {
     return sizeof(BaseTy) + ParentType::additionalSizeToAllocImpl(0, Counts...);
@@ -369,7 +363,9 @@
   template <typename... Tys> struct FixedSizeStorage {
     template <size_t... Counts> struct with_counts {
       enum { Size = totalSizeToAlloc<Tys...>(Counts...) };
-      typedef llvm::AlignedCharArray<alignof(BaseTy), Size> type;
+      struct type {
+        alignas(BaseTy) char buffer[Size];
+      };
     };
   };
 
diff --git a/linux-x64/clang/include/llvm/Support/TrigramIndex.h b/linux-x64/clang/include/llvm/Support/TrigramIndex.h
index 9351c2d..360ab94 100644
--- a/linux-x64/clang/include/llvm/Support/TrigramIndex.h
+++ b/linux-x64/clang/include/llvm/Support/TrigramIndex.h
@@ -27,8 +27,7 @@
 #define LLVM_SUPPORT_TRIGRAMINDEX_H
 
 #include "llvm/ADT/SmallVector.h"
-#include "llvm/ADT/StringMap.h"
-
+#include "llvm/ADT/StringRef.h"
 #include <string>
 #include <unordered_map>
 #include <vector>
diff --git a/linux-x64/clang/include/llvm/Support/TypeSize.h b/linux-x64/clang/include/llvm/Support/TypeSize.h
new file mode 100644
index 0000000..d277aff
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Support/TypeSize.h
@@ -0,0 +1,531 @@
+//===- TypeSize.h - Wrapper around type sizes -------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file provides a struct that can be used to query the size of IR types
+// which may be scalable vectors. It provides convenience operators so that
+// it can be used in much the same way as a single scalar value.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_SUPPORT_TYPESIZE_H
+#define LLVM_SUPPORT_TYPESIZE_H
+
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/Support/MathExtras.h"
+#include "llvm/Support/WithColor.h"
+
+#include <algorithm>
+#include <array>
+#include <cassert>
+#include <cstdint>
+#include <type_traits>
+
+namespace llvm {
+
+template <typename LeafTy> struct LinearPolyBaseTypeTraits {};
+
+//===----------------------------------------------------------------------===//
+// LinearPolyBase - a base class for linear polynomials with multiple
+// dimensions. This can e.g. be used to describe offsets that are have both a
+// fixed and scalable component.
+//===----------------------------------------------------------------------===//
+
+/// LinearPolyBase describes a linear polynomial:
+///  c0 * scale0 + c1 * scale1 + ... + cK * scaleK
+/// where the scale is implicit, so only the coefficients are encoded.
+template <typename LeafTy>
+class LinearPolyBase {
+public:
+  using ScalarTy = typename LinearPolyBaseTypeTraits<LeafTy>::ScalarTy;
+  static constexpr auto Dimensions = LinearPolyBaseTypeTraits<LeafTy>::Dimensions;
+  static_assert(Dimensions != std::numeric_limits<unsigned>::max(),
+                "Dimensions out of range");
+
+private:
+  std::array<ScalarTy, Dimensions> Coefficients;
+
+protected:
+  LinearPolyBase(ArrayRef<ScalarTy> Values) {
+    std::copy(Values.begin(), Values.end(), Coefficients.begin());
+  }
+
+public:
+  friend LeafTy &operator+=(LeafTy &LHS, const LeafTy &RHS) {
+    for (unsigned I=0; I<Dimensions; ++I)
+      LHS.Coefficients[I] += RHS.Coefficients[I];
+    return LHS;
+  }
+
+  friend LeafTy &operator-=(LeafTy &LHS, const LeafTy &RHS) {
+    for (unsigned I=0; I<Dimensions; ++I)
+      LHS.Coefficients[I] -= RHS.Coefficients[I];
+    return LHS;
+  }
+
+  friend LeafTy &operator*=(LeafTy &LHS, ScalarTy RHS) {
+    for (auto &C : LHS.Coefficients)
+      C *= RHS;
+    return LHS;
+  }
+
+  friend LeafTy operator+(const LeafTy &LHS, const LeafTy &RHS) {
+    LeafTy Copy = LHS;
+    return Copy += RHS;
+  }
+
+  friend LeafTy operator-(const LeafTy &LHS, const LeafTy &RHS) {
+    LeafTy Copy = LHS;
+    return Copy -= RHS;
+  }
+
+  friend LeafTy operator*(const LeafTy &LHS, ScalarTy RHS) {
+    LeafTy Copy = LHS;
+    return Copy *= RHS;
+  }
+
+  template <typename U = ScalarTy>
+  friend typename std::enable_if_t<std::is_signed<U>::value, LeafTy>
+  operator-(const LeafTy &LHS) {
+    LeafTy Copy = LHS;
+    return Copy *= -1;
+  }
+
+  bool operator==(const LinearPolyBase &RHS) const {
+    return std::equal(Coefficients.begin(), Coefficients.end(),
+                      RHS.Coefficients.begin());
+  }
+
+  bool operator!=(const LinearPolyBase &RHS) const {
+    return !(*this == RHS);
+  }
+
+  bool isZero() const {
+    return all_of(Coefficients, [](const ScalarTy &C) { return C == 0; });
+  }
+  bool isNonZero() const { return !isZero(); }
+  explicit operator bool() const { return isNonZero(); }
+
+  ScalarTy getValue(unsigned Dim) const { return Coefficients[Dim]; }
+};
+
+//===----------------------------------------------------------------------===//
+// StackOffset - Represent an offset with named fixed and scalable components.
+//===----------------------------------------------------------------------===//
+
+class StackOffset;
+template <> struct LinearPolyBaseTypeTraits<StackOffset> {
+  using ScalarTy = int64_t;
+  static constexpr unsigned Dimensions = 2;
+};
+
+/// StackOffset is a class to represent an offset with 2 dimensions,
+/// named fixed and scalable, respectively. This class allows a value for both
+/// dimensions to depict e.g. "8 bytes and 16 scalable bytes", which is needed
+/// to represent stack offsets.
+class StackOffset : public LinearPolyBase<StackOffset> {
+protected:
+  StackOffset(ScalarTy Fixed, ScalarTy Scalable)
+      : LinearPolyBase<StackOffset>({Fixed, Scalable}) {}
+
+public:
+  StackOffset() : StackOffset({0, 0}) {}
+  StackOffset(const LinearPolyBase<StackOffset> &Other)
+      : LinearPolyBase<StackOffset>(Other) {}
+  static StackOffset getFixed(ScalarTy Fixed) { return {Fixed, 0}; }
+  static StackOffset getScalable(ScalarTy Scalable) { return {0, Scalable}; }
+  static StackOffset get(ScalarTy Fixed, ScalarTy Scalable) {
+    return {Fixed, Scalable};
+  }
+
+  ScalarTy getFixed() const { return this->getValue(0); }
+  ScalarTy getScalable() const { return this->getValue(1); }
+};
+
+//===----------------------------------------------------------------------===//
+// UnivariateLinearPolyBase - a base class for linear polynomials with multiple
+// dimensions, but where only one dimension can be set at any time.
+// This can e.g. be used to describe sizes that are either fixed or scalable.
+//===----------------------------------------------------------------------===//
+
+/// UnivariateLinearPolyBase is a base class for ElementCount and TypeSize.
+/// Like LinearPolyBase it tries to represent a linear polynomial
+/// where only one dimension can be set at any time, e.g.
+///   0 * scale0 + 0 * scale1 + ... + cJ * scaleJ + ... + 0 * scaleK
+/// The dimension that is set is the univariate dimension.
+template <typename LeafTy>
+class UnivariateLinearPolyBase {
+public:
+  using ScalarTy = typename LinearPolyBaseTypeTraits<LeafTy>::ScalarTy;
+  static constexpr auto Dimensions = LinearPolyBaseTypeTraits<LeafTy>::Dimensions;
+  static_assert(Dimensions != std::numeric_limits<unsigned>::max(),
+                "Dimensions out of range");
+
+protected:
+  ScalarTy Value;         // The value at the univeriate dimension.
+  unsigned UnivariateDim; // The univeriate dimension.
+
+  UnivariateLinearPolyBase(ScalarTy Val, unsigned UnivariateDim)
+      : Value(Val), UnivariateDim(UnivariateDim) {
+    assert(UnivariateDim < Dimensions && "Dimension out of range");
+  }
+
+  friend LeafTy &operator+=(LeafTy &LHS, const LeafTy &RHS) {
+    assert(LHS.UnivariateDim == RHS.UnivariateDim && "Invalid dimensions");
+    LHS.Value += RHS.Value;
+    return LHS;
+  }
+
+  friend LeafTy &operator-=(LeafTy &LHS, const LeafTy &RHS) {
+    assert(LHS.UnivariateDim == RHS.UnivariateDim && "Invalid dimensions");
+    LHS.Value -= RHS.Value;
+    return LHS;
+  }
+
+  friend LeafTy &operator*=(LeafTy &LHS, ScalarTy RHS) {
+    LHS.Value *= RHS;
+    return LHS;
+  }
+
+  friend LeafTy operator+(const LeafTy &LHS, const LeafTy &RHS) {
+    LeafTy Copy = LHS;
+    return Copy += RHS;
+  }
+
+  friend LeafTy operator-(const LeafTy &LHS, const LeafTy &RHS) {
+    LeafTy Copy = LHS;
+    return Copy -= RHS;
+  }
+
+  friend LeafTy operator*(const LeafTy &LHS, ScalarTy RHS) {
+    LeafTy Copy = LHS;
+    return Copy *= RHS;
+  }
+
+  template <typename U = ScalarTy>
+  friend typename std::enable_if<std::is_signed<U>::value, LeafTy>::type
+  operator-(const LeafTy &LHS) {
+    LeafTy Copy = LHS;
+    return Copy *= -1;
+  }
+
+public:
+  bool operator==(const UnivariateLinearPolyBase &RHS) const {
+    return Value == RHS.Value && UnivariateDim == RHS.UnivariateDim;
+  }
+
+  bool operator!=(const UnivariateLinearPolyBase &RHS) const {
+    return !(*this == RHS);
+  }
+
+  bool isZero() const { return !Value; }
+  bool isNonZero() const { return !isZero(); }
+  explicit operator bool() const { return isNonZero(); }
+  ScalarTy getValue() const { return Value; }
+  ScalarTy getValue(unsigned Dim) const {
+    return Dim == UnivariateDim ? Value : 0;
+  }
+
+  /// Add \p RHS to the value at the univariate dimension.
+  LeafTy getWithIncrement(ScalarTy RHS) {
+    return static_cast<LeafTy>(
+        UnivariateLinearPolyBase(Value + RHS, UnivariateDim));
+  }
+
+  /// Subtract \p RHS from the value at the univariate dimension.
+  LeafTy getWithDecrement(ScalarTy RHS) {
+    return static_cast<LeafTy>(
+        UnivariateLinearPolyBase(Value - RHS, UnivariateDim));
+  }
+};
+
+
+//===----------------------------------------------------------------------===//
+// LinearPolySize - base class for fixed- or scalable sizes.
+//  ^  ^ 
+//  |  |
+//  |  +----- ElementCount - Leaf class to represent an element count
+//  |                        (vscale x unsigned)
+//  |
+//  +-------- TypeSize - Leaf class to represent a type size
+//                       (vscale x uint64_t)
+//===----------------------------------------------------------------------===//
+
+/// LinearPolySize is a base class to represent sizes. It is either
+/// fixed-sized or it is scalable-sized, but it cannot be both.
+template <typename LeafTy>
+class LinearPolySize : public UnivariateLinearPolyBase<LeafTy> {
+  // Make the parent class a friend, so that it can access the protected
+  // conversion/copy-constructor for UnivariatePolyBase<LeafTy> ->
+  // LinearPolySize<LeafTy>.
+  friend class UnivariateLinearPolyBase<LeafTy>;
+
+public:
+  using ScalarTy = typename UnivariateLinearPolyBase<LeafTy>::ScalarTy;
+  enum Dims : unsigned { FixedDim = 0, ScalableDim = 1 };
+
+protected:
+  LinearPolySize(ScalarTy MinVal, Dims D)
+      : UnivariateLinearPolyBase<LeafTy>(MinVal, D) {}
+
+  LinearPolySize(const UnivariateLinearPolyBase<LeafTy> &V)
+      : UnivariateLinearPolyBase<LeafTy>(V) {}
+
+public:
+
+  static LeafTy getFixed(ScalarTy MinVal) {
+    return static_cast<LeafTy>(LinearPolySize(MinVal, FixedDim));
+  }
+  static LeafTy getScalable(ScalarTy MinVal) {
+    return static_cast<LeafTy>(LinearPolySize(MinVal, ScalableDim));
+  }
+  static LeafTy get(ScalarTy MinVal, bool Scalable) {
+    return static_cast<LeafTy>(
+        LinearPolySize(MinVal, Scalable ? ScalableDim : FixedDim));
+  }
+  static LeafTy getNull() { return get(0, false); }
+
+  /// Returns the minimum value this size can represent.
+  ScalarTy getKnownMinValue() const { return this->getValue(); }
+  /// Returns whether the size is scaled by a runtime quantity (vscale).
+  bool isScalable() const { return this->UnivariateDim == ScalableDim; }
+  /// A return value of true indicates we know at compile time that the number
+  /// of elements (vscale * Min) is definitely even. However, returning false
+  /// does not guarantee that the total number of elements is odd.
+  bool isKnownEven() const { return (getKnownMinValue() & 0x1) == 0; }
+  /// This function tells the caller whether the element count is known at
+  /// compile time to be a multiple of the scalar value RHS.
+  bool isKnownMultipleOf(ScalarTy RHS) const {
+    return getKnownMinValue() % RHS == 0;
+  }
+
+  // Return the minimum value with the assumption that the count is exact.
+  // Use in places where a scalable count doesn't make sense (e.g. non-vector
+  // types, or vectors in backends which don't support scalable vectors).
+  ScalarTy getFixedValue() const {
+    assert(!isScalable() &&
+           "Request for a fixed element count on a scalable object");
+    return getKnownMinValue();
+  }
+
+  // For some cases, size ordering between scalable and fixed size types cannot
+  // be determined at compile time, so such comparisons aren't allowed.
+  //
+  // e.g. <vscale x 2 x i16> could be bigger than <4 x i32> with a runtime
+  // vscale >= 5, equal sized with a vscale of 4, and smaller with
+  // a vscale <= 3.
+  //
+  // All the functions below make use of the fact vscale is always >= 1, which
+  // means that <vscale x 4 x i32> is guaranteed to be >= <4 x i32>, etc.
+
+  static bool isKnownLT(const LinearPolySize &LHS, const LinearPolySize &RHS) {
+    if (!LHS.isScalable() || RHS.isScalable())
+      return LHS.getKnownMinValue() < RHS.getKnownMinValue();
+    return false;
+  }
+
+  static bool isKnownGT(const LinearPolySize &LHS, const LinearPolySize &RHS) {
+    if (LHS.isScalable() || !RHS.isScalable())
+      return LHS.getKnownMinValue() > RHS.getKnownMinValue();
+    return false;
+  }
+
+  static bool isKnownLE(const LinearPolySize &LHS, const LinearPolySize &RHS) {
+    if (!LHS.isScalable() || RHS.isScalable())
+      return LHS.getKnownMinValue() <= RHS.getKnownMinValue();
+    return false;
+  }
+
+  static bool isKnownGE(const LinearPolySize &LHS, const LinearPolySize &RHS) {
+    if (LHS.isScalable() || !RHS.isScalable())
+      return LHS.getKnownMinValue() >= RHS.getKnownMinValue();
+    return false;
+  }
+
+  /// We do not provide the '/' operator here because division for polynomial
+  /// types does not work in the same way as for normal integer types. We can
+  /// only divide the minimum value (or coefficient) by RHS, which is not the
+  /// same as
+  ///   (Min * Vscale) / RHS
+  /// The caller is recommended to use this function in combination with
+  /// isKnownMultipleOf(RHS), which lets the caller know if it's possible to
+  /// perform a lossless divide by RHS.
+  LeafTy divideCoefficientBy(ScalarTy RHS) const {
+    return static_cast<LeafTy>(
+        LinearPolySize::get(getKnownMinValue() / RHS, isScalable()));
+  }
+
+  LeafTy coefficientNextPowerOf2() const {
+    return static_cast<LeafTy>(LinearPolySize::get(
+        static_cast<ScalarTy>(llvm::NextPowerOf2(getKnownMinValue())),
+        isScalable()));
+  }
+
+  /// Printing function.
+  void print(raw_ostream &OS) const {
+    if (isScalable())
+      OS << "vscale x ";
+    OS << getKnownMinValue();
+  }
+};
+
+class ElementCount;
+template <> struct LinearPolyBaseTypeTraits<ElementCount> {
+  using ScalarTy = unsigned;
+  static constexpr unsigned Dimensions = 2;
+};
+
+class ElementCount : public LinearPolySize<ElementCount> {
+public:
+
+  ElementCount(const LinearPolySize<ElementCount> &V) : LinearPolySize(V) {}
+
+  /// Counting predicates.
+  ///
+  ///@{ Number of elements..
+  /// Exactly one element.
+  bool isScalar() const { return !isScalable() && getKnownMinValue() == 1; }
+  /// One or more elements.
+  bool isVector() const {
+    return (isScalable() && getKnownMinValue() != 0) || getKnownMinValue() > 1;
+  }
+  ///@}
+};
+
+// This class is used to represent the size of types. If the type is of fixed
+class TypeSize;
+template <> struct LinearPolyBaseTypeTraits<TypeSize> {
+  using ScalarTy = uint64_t;
+  static constexpr unsigned Dimensions = 2;
+};
+
+// TODO: Most functionality in this class will gradually be phased out
+// so it will resemble LinearPolySize as much as possible.
+//
+// TypeSize is used to represent the size of types. If the type is of fixed
+// size, it will represent the exact size. If the type is a scalable vector,
+// it will represent the known minimum size.
+class TypeSize : public LinearPolySize<TypeSize> {
+public:
+  TypeSize(const LinearPolySize<TypeSize> &V) : LinearPolySize(V) {}
+  TypeSize(ScalarTy MinVal, bool IsScalable)
+      : LinearPolySize(LinearPolySize::get(MinVal, IsScalable)) {}
+
+  static TypeSize Fixed(ScalarTy MinVal) { return TypeSize(MinVal, false); }
+  static TypeSize Scalable(ScalarTy MinVal) { return TypeSize(MinVal, true); }
+
+  ScalarTy getFixedSize() const { return getFixedValue(); }
+  ScalarTy getKnownMinSize() const { return getKnownMinValue(); }
+
+  // All code for this class below this point is needed because of the
+  // temporary implicit conversion to uint64_t. The operator overloads are
+  // needed because otherwise the conversion of the parent class
+  // UnivariateLinearPolyBase -> TypeSize is ambiguous.
+  // TODO: Remove the implicit conversion.
+
+  // Casts to a uint64_t if this is a fixed-width size.
+  //
+  // This interface is deprecated and will be removed in a future version
+  // of LLVM in favour of upgrading uses that rely on this implicit conversion
+  // to uint64_t. Calls to functions that return a TypeSize should use the
+  // proper interfaces to TypeSize.
+  // In practice this is mostly calls to MVT/EVT::getSizeInBits().
+  //
+  // To determine how to upgrade the code:
+  //
+  //   if (<algorithm works for both scalable and fixed-width vectors>)
+  //     use getKnownMinValue()
+  //   else if (<algorithm works only for fixed-width vectors>) {
+  //     if <algorithm can be adapted for both scalable and fixed-width vectors>
+  //       update the algorithm and use getKnownMinValue()
+  //     else
+  //       bail out early for scalable vectors and use getFixedValue()
+  //   }
+  operator ScalarTy() const {
+#ifdef STRICT_FIXED_SIZE_VECTORS
+    return getFixedValue();
+#else
+    if (isScalable())
+      WithColor::warning() << "Compiler has made implicit assumption that "
+                              "TypeSize is not scalable. This may or may not "
+                              "lead to broken code.\n";
+    return getKnownMinValue();
+#endif
+  }
+
+  // Additional operators needed to avoid ambiguous parses
+  // because of the implicit conversion hack.
+  friend TypeSize operator*(const TypeSize &LHS, const int RHS) {
+    return LHS * (ScalarTy)RHS;
+  }
+  friend TypeSize operator*(const TypeSize &LHS, const unsigned RHS) {
+    return LHS * (ScalarTy)RHS;
+  }
+  friend TypeSize operator*(const TypeSize &LHS, const int64_t RHS) {
+    return LHS * (ScalarTy)RHS;
+  }
+  friend TypeSize operator*(const int LHS, const TypeSize &RHS) {
+    return RHS * LHS;
+  }
+  friend TypeSize operator*(const unsigned LHS, const TypeSize &RHS) {
+    return RHS * LHS;
+  }
+  friend TypeSize operator*(const int64_t LHS, const TypeSize &RHS) {
+    return RHS * LHS;
+  }
+  friend TypeSize operator*(const uint64_t LHS, const TypeSize &RHS) {
+    return RHS * LHS;
+  }
+};
+
+//===----------------------------------------------------------------------===//
+// Utilities
+//===----------------------------------------------------------------------===//
+
+/// Returns a TypeSize with a known minimum size that is the next integer
+/// (mod 2**64) that is greater than or equal to \p Value and is a multiple
+/// of \p Align. \p Align must be non-zero.
+///
+/// Similar to the alignTo functions in MathExtras.h
+inline TypeSize alignTo(TypeSize Size, uint64_t Align) {
+  assert(Align != 0u && "Align must be non-zero");
+  return {(Size.getKnownMinValue() + Align - 1) / Align * Align,
+          Size.isScalable()};
+}
+
+/// Stream operator function for `LinearPolySize`.
+template <typename LeafTy>
+inline raw_ostream &operator<<(raw_ostream &OS,
+                               const LinearPolySize<LeafTy> &PS) {
+  PS.print(OS);
+  return OS;
+}
+
+template <typename T> struct DenseMapInfo;
+template <> struct DenseMapInfo<ElementCount> {
+  static inline ElementCount getEmptyKey() {
+    return ElementCount::getScalable(~0U);
+  }
+  static inline ElementCount getTombstoneKey() {
+    return ElementCount::getFixed(~0U - 1);
+  }
+  static unsigned getHashValue(const ElementCount &EltCnt) {
+    unsigned HashVal = EltCnt.getKnownMinValue() * 37U;
+    if (EltCnt.isScalable())
+      return (HashVal - 1U);
+
+    return HashVal;
+  }
+
+  static bool isEqual(const ElementCount &LHS, const ElementCount &RHS) {
+    return LHS == RHS;
+  }
+};
+
+} // end namespace llvm
+
+#endif // LLVM_SUPPORT_TypeSize_H
diff --git a/linux-x64/clang/include/llvm/Support/UnicodeCharRanges.h b/linux-x64/clang/include/llvm/Support/UnicodeCharRanges.h
index 4b59f8a..73d3603 100644
--- a/linux-x64/clang/include/llvm/Support/UnicodeCharRanges.h
+++ b/linux-x64/clang/include/llvm/Support/UnicodeCharRanges.h
@@ -9,11 +9,8 @@
 #define LLVM_SUPPORT_UNICODECHARRANGES_H
 
 #include "llvm/ADT/ArrayRef.h"
-#include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/Debug.h"
-#include "llvm/Support/Mutex.h"
-#include "llvm/Support/MutexGuard.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 
diff --git a/linux-x64/clang/include/llvm/Support/UniqueLock.h b/linux-x64/clang/include/llvm/Support/UniqueLock.h
deleted file mode 100644
index 0a887ad..0000000
--- a/linux-x64/clang/include/llvm/Support/UniqueLock.h
+++ /dev/null
@@ -1,68 +0,0 @@
-//===- Support/UniqueLock.h - Acquire/Release Mutex In Scope ----*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// This file defines a guard for a block of code that ensures a Mutex is locked
-// upon construction and released upon destruction.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_SUPPORT_UNIQUE_LOCK_H
-#define LLVM_SUPPORT_UNIQUE_LOCK_H
-
-#include <cassert>
-
-namespace llvm {
-
-  /// A pared-down imitation of std::unique_lock from C++11. Contrary to the
-  /// name, it's really more of a wrapper for a lock. It may or may not have
-  /// an associated mutex, which is guaranteed to be locked upon creation
-  /// and unlocked after destruction. unique_lock can also unlock the mutex
-  /// and re-lock it freely during its lifetime.
-  /// Guard a section of code with a mutex.
-  template<typename MutexT>
-  class unique_lock {
-    MutexT *M = nullptr;
-    bool locked = false;
-
-  public:
-    unique_lock() = default;
-    explicit unique_lock(MutexT &m) : M(&m), locked(true) { M->lock(); }
-    unique_lock(const unique_lock &) = delete;
-     unique_lock &operator=(const unique_lock &) = delete;
-
-    void operator=(unique_lock &&o) {
-      if (owns_lock())
-        M->unlock();
-      M = o.M;
-      locked = o.locked;
-      o.M = nullptr;
-      o.locked = false;
-    }
-
-    ~unique_lock() { if (owns_lock()) M->unlock(); }
-
-    void lock() {
-      assert(!locked && "mutex already locked!");
-      assert(M && "no associated mutex!");
-      M->lock();
-      locked = true;
-    }
-
-    void unlock() {
-      assert(locked && "unlocking a mutex that isn't locked!");
-      assert(M && "no associated mutex!");
-      M->unlock();
-      locked = false;
-    }
-
-    bool owns_lock() { return locked; }
-  };
-
-} // end namespace llvm
-
-#endif // LLVM_SUPPORT_UNIQUE_LOCK_H
diff --git a/linux-x64/clang/include/llvm/Support/VCSRevision.h b/linux-x64/clang/include/llvm/Support/VCSRevision.h
index 3ad6886..3fe7a5f 100644
--- a/linux-x64/clang/include/llvm/Support/VCSRevision.h
+++ b/linux-x64/clang/include/llvm/Support/VCSRevision.h
@@ -1,2 +1,2 @@
-#define LLVM_REVISION "e0caee08e5f09b374a27a676d04978c81fcb1928"
-#define LLVM_REPOSITORY "/buildbot/tmp/tmpyQwgD_"
+#define LLVM_REVISION "c935d99d7cf2016289302412d708641d52d2f7ee"
+#define LLVM_REPOSITORY "/buildbot/src/android/llvm-toolchain/out/llvm-project/llvm"
diff --git a/linux-x64/clang/include/llvm/Support/VersionTuple.h b/linux-x64/clang/include/llvm/Support/VersionTuple.h
index 14736d6..6f3711f 100644
--- a/linux-x64/clang/include/llvm/Support/VersionTuple.h
+++ b/linux-x64/clang/include/llvm/Support/VersionTuple.h
@@ -14,13 +14,14 @@
 #ifndef LLVM_SUPPORT_VERSIONTUPLE_H
 #define LLVM_SUPPORT_VERSIONTUPLE_H
 
+#include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/Optional.h"
-#include "llvm/ADT/StringRef.h"
-#include "llvm/Support/raw_ostream.h"
 #include <string>
 #include <tuple>
 
 namespace llvm {
+class raw_ostream;
+class StringRef;
 
 /// Represents a version number in the form major[.minor[.subminor[.build]]].
 class VersionTuple {
@@ -87,6 +88,13 @@
     return Build;
   }
 
+  /// Return a version tuple that contains only the first 3 version components.
+  VersionTuple withoutBuild() const {
+    if (HasBuild)
+      return VersionTuple(Major, Minor, Subminor);
+    return *this;
+  }
+
   /// Determine if two version numbers are equivalent. If not
   /// provided, minor and subminor version numbers are considered to be zero.
   friend bool operator==(const VersionTuple &X, const VersionTuple &Y) {
@@ -137,6 +145,10 @@
     return !(X < Y);
   }
 
+  friend llvm::hash_code hash_value(const VersionTuple &VT) {
+    return llvm::hash_combine(VT.Major, VT.Minor, VT.Subminor, VT.Build);
+  }
+
   /// Retrieve a string representation of the version number.
   std::string getAsString() const;
 
diff --git a/linux-x64/clang/include/llvm/Support/VirtualFileSystem.h b/linux-x64/clang/include/llvm/Support/VirtualFileSystem.h
index 31c9e85..d483fc3 100644
--- a/linux-x64/clang/include/llvm/Support/VirtualFileSystem.h
+++ b/linux-x64/clang/include/llvm/Support/VirtualFileSystem.h
@@ -19,7 +19,6 @@
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
-#include "llvm/ADT/Twine.h"
 #include "llvm/Support/Chrono.h"
 #include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/FileSystem.h"
@@ -35,9 +34,14 @@
 #include <utility>
 #include <vector>
 
+// ANDROID x86_64 defined the FS macro
+#undef FS
+
 namespace llvm {
 
 class MemoryBuffer;
+class MemoryBufferRef;
+class Twine;
 
 namespace vfs {
 
@@ -126,7 +130,7 @@
 /// Only information available on most platforms is included.
 class directory_entry {
   std::string Path;
-  llvm::sys::fs::file_type Type;
+  llvm::sys::fs::file_type Type = llvm::sys::fs::file_type::type_unknown;
 
 public:
   directory_entry() = default;
@@ -293,7 +297,7 @@
   /// \param Path A path that is modified to be an absolute path.
   /// \returns success if \a path has been made absolute, otherwise a
   ///          platform-specific error_code.
-  std::error_code makeAbsolute(SmallVectorImpl<char> &Path) const;
+  virtual std::error_code makeAbsolute(SmallVectorImpl<char> &Path) const;
 };
 
 /// Gets an \p vfs::FileSystem for the 'real' file system, as seen by
@@ -463,7 +467,8 @@
   /// false if the file or directory already exists in the file system with
   /// different contents.
   bool addFileNoOwn(const Twine &Path, time_t ModificationTime,
-                    llvm::MemoryBuffer *Buffer, Optional<uint32_t> User = None,
+                    const llvm::MemoryBufferRef &Buffer,
+                    Optional<uint32_t> User = None,
                     Optional<uint32_t> Group = None,
                     Optional<llvm::sys::fs::file_type> Type = None,
                     Optional<llvm::sys::fs::perms> Perms = None);
@@ -498,7 +503,7 @@
 
 /// Gets a \p FileSystem for a virtual file system described in YAML
 /// format.
-IntrusiveRefCntPtr<FileSystem>
+std::unique_ptr<FileSystem>
 getVFSFromYAML(std::unique_ptr<llvm::MemoryBuffer> Buffer,
                llvm::SourceMgr::DiagHandlerTy DiagHandler,
                StringRef YAMLFilePath, void *DiagContext = nullptr,
@@ -506,10 +511,12 @@
 
 struct YAMLVFSEntry {
   template <typename T1, typename T2>
-  YAMLVFSEntry(T1 &&VPath, T2 &&RPath)
-      : VPath(std::forward<T1>(VPath)), RPath(std::forward<T2>(RPath)) {}
+  YAMLVFSEntry(T1 &&VPath, T2 &&RPath, bool IsDirectory = false)
+      : VPath(std::forward<T1>(VPath)), RPath(std::forward<T2>(RPath)),
+        IsDirectory(IsDirectory) {}
   std::string VPath;
   std::string RPath;
+  bool IsDirectory = false;
 };
 
 class VFSFromYamlDirIterImpl;
@@ -532,7 +539,7 @@
 /// \endverbatim
 ///
 /// All configuration options are optional.
-///   'case-sensitive': <boolean, default=true>
+///   'case-sensitive': <boolean, default=(true for Posix, false for Windows)>
 ///   'use-external-names': <boolean, default=true>
 ///   'overlay-relative': <boolean, default=false>
 ///   'fallthrough': <boolean, default=true>
@@ -647,9 +654,30 @@
   friend class VFSFromYamlDirIterImpl;
   friend class RedirectingFileSystemParser;
 
+  bool shouldUseExternalFS() const {
+    return ExternalFSValidWD && IsFallthrough;
+  }
+
+  // In a RedirectingFileSystem, keys can be specified in Posix or Windows
+  // style (or even a mixture of both), so this comparison helper allows
+  // slashes (representing a root) to match backslashes (and vice versa).  Note
+  // that, other than the root, path components should not contain slashes or
+  // backslashes.
+  bool pathComponentMatches(llvm::StringRef lhs, llvm::StringRef rhs) const {
+    if ((CaseSensitive ? lhs.equals(rhs) : lhs.equals_lower(rhs)))
+      return true;
+    return (lhs == "/" && rhs == "\\") || (lhs == "\\" && rhs == "/");
+  }
+
   /// The root(s) of the virtual file system.
   std::vector<std::unique_ptr<Entry>> Roots;
 
+  /// The current working directory of the file system.
+  std::string WorkingDirectory;
+
+  /// Whether the current working directory is valid for the external FS.
+  bool ExternalFSValidWD = false;
+
   /// The file system to use for external references.
   IntrusiveRefCntPtr<FileSystem> ExternalFS;
 
@@ -664,7 +692,12 @@
   /// Whether to perform case-sensitive comparisons.
   ///
   /// Currently, case-insensitive matching only works correctly with ASCII.
-  bool CaseSensitive = true;
+  bool CaseSensitive =
+#ifdef _WIN32
+      false;
+#else
+      true;
+#endif
 
   /// IsRelativeOverlay marks whether a ExternalContentsPrefixDir path must
   /// be prefixed in every 'external-contents' when reading from YAML files.
@@ -679,18 +712,7 @@
   bool IsFallthrough = true;
   /// @}
 
-  /// Virtual file paths and external files could be canonicalized without "..",
-  /// "." and "./" in their paths. FIXME: some unittests currently fail on
-  /// win32 when using remove_dots and remove_leading_dotslash on paths.
-  bool UseCanonicalizedPaths =
-#ifdef _WIN32
-      false;
-#else
-      true;
-#endif
-
-  RedirectingFileSystem(IntrusiveRefCntPtr<FileSystem> ExternalFS)
-      : ExternalFS(std::move(ExternalFS)) {}
+  RedirectingFileSystem(IntrusiveRefCntPtr<FileSystem> ExternalFS);
 
   /// Looks up the path <tt>[Start, End)</tt> in \p From, possibly
   /// recursing into the contents of \p From if it is a directory.
@@ -707,11 +729,16 @@
 
   /// Parses \p Buffer, which is expected to be in YAML format and
   /// returns a virtual file system representing its contents.
-  static RedirectingFileSystem *
+  static std::unique_ptr<RedirectingFileSystem>
   create(std::unique_ptr<MemoryBuffer> Buffer,
          SourceMgr::DiagHandlerTy DiagHandler, StringRef YAMLFilePath,
          void *DiagContext, IntrusiveRefCntPtr<FileSystem> ExternalFS);
 
+  /// Redirect each of the remapped files from first to second.
+  static std::unique_ptr<RedirectingFileSystem>
+  create(ArrayRef<std::pair<std::string, std::string>> RemappedFiles,
+         bool UseExternalNames, FileSystem &ExternalFS);
+
   ErrorOr<Status> status(const Twine &Path) override;
   ErrorOr<std::unique_ptr<File>> openFileForRead(const Twine &Path) override;
 
@@ -724,15 +751,22 @@
 
   std::error_code isLocal(const Twine &Path, bool &Result) override;
 
+  std::error_code makeAbsolute(SmallVectorImpl<char> &Path) const override;
+
   directory_iterator dir_begin(const Twine &Dir, std::error_code &EC) override;
 
   void setExternalContentsPrefixDir(StringRef PrefixDir);
 
   StringRef getExternalContentsPrefixDir() const;
 
+  void setFallthrough(bool Fallthrough);
+
+  std::vector<llvm::StringRef> getRoots() const;
+
+  void dump(raw_ostream &OS) const;
+  void dumpEntry(raw_ostream &OS, Entry *E, int NumSpaces = 0) const;
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
   LLVM_DUMP_METHOD void dump() const;
-  LLVM_DUMP_METHOD void dumpEntry(Entry *E, int NumSpaces = 0) const;
 #endif
 };
 
@@ -753,10 +787,13 @@
   Optional<bool> UseExternalNames;
   std::string OverlayDir;
 
+  void addEntry(StringRef VirtualPath, StringRef RealPath, bool IsDirectory);
+
 public:
   YAMLVFSWriter() = default;
 
   void addFileMapping(StringRef VirtualPath, StringRef RealPath);
+  void addDirectoryMapping(StringRef VirtualPath, StringRef RealPath);
 
   void setCaseSensitivity(bool CaseSensitive) {
     IsCaseSensitive = CaseSensitive;
diff --git a/linux-x64/clang/include/llvm/Support/Win64EH.h b/linux-x64/clang/include/llvm/Support/Win64EH.h
index bdd23b4..9359fcb 100644
--- a/linux-x64/clang/include/llvm/Support/Win64EH.h
+++ b/linux-x64/clang/include/llvm/Support/Win64EH.h
@@ -30,18 +30,22 @@
   UOP_SetFPReg,
   UOP_SaveNonVol,
   UOP_SaveNonVolBig,
-  UOP_SaveXMM128 = 8,
+  UOP_Epilog,
+  UOP_SpareCode,
+  UOP_SaveXMM128,
   UOP_SaveXMM128Big,
   UOP_PushMachFrame,
   // The following set of unwind opcodes is for ARM64.  They are documented at
   // https://docs.microsoft.com/en-us/cpp/build/arm64-exception-handling
   UOP_AllocMedium,
+  UOP_SaveR19R20X,
   UOP_SaveFPLRX,
   UOP_SaveFPLR,
   UOP_SaveReg,
   UOP_SaveRegX,
   UOP_SaveRegP,
   UOP_SaveRegPX,
+  UOP_SaveLRPair,
   UOP_SaveFReg,
   UOP_SaveFRegX,
   UOP_SaveFRegP,
@@ -49,7 +53,11 @@
   UOP_SetFP,
   UOP_AddFP,
   UOP_Nop,
-  UOP_End
+  UOP_End,
+  UOP_SaveNext,
+  UOP_TrapFrame,
+  UOP_Context,
+  UOP_ClearUnwoundToCall
 };
 
 /// UnwindCode - This union describes a single operation in a function prolog,
diff --git a/linux-x64/clang/include/llvm/Support/Windows/WindowsSupport.h b/linux-x64/clang/include/llvm/Support/Windows/WindowsSupport.h
new file mode 100644
index 0000000..bd5a90c
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Support/Windows/WindowsSupport.h
@@ -0,0 +1,249 @@
+//===- WindowsSupport.h - Common Windows Include File -----------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines things specific to Windows implementations.  In addition to
+// providing some helpers for working with win32 APIs, this header wraps
+// <windows.h> with some portability macros.  Always include WindowsSupport.h
+// instead of including <windows.h> directly.
+//
+//===----------------------------------------------------------------------===//
+
+//===----------------------------------------------------------------------===//
+//=== WARNING: Implementation here must contain only generic Win32 code that
+//===          is guaranteed to work on *all* Win32 variants.
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_SUPPORT_WINDOWSSUPPORT_H
+#define LLVM_SUPPORT_WINDOWSSUPPORT_H
+
+// mingw-w64 tends to define it as 0x0502 in its headers.
+#undef _WIN32_WINNT
+#undef _WIN32_IE
+
+// Require at least Windows 7 API.
+#define _WIN32_WINNT 0x0601
+#define _WIN32_IE    0x0800 // MinGW at it again. FIXME: verify if still needed.
+#define WIN32_LEAN_AND_MEAN
+#ifndef NOMINMAX
+#define NOMINMAX
+#endif
+
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringExtras.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/Twine.h"
+#include "llvm/Config/config.h" // Get build system configuration settings
+#include "llvm/Support/Allocator.h"
+#include "llvm/Support/Chrono.h"
+#include "llvm/Support/Compiler.h"
+#include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/VersionTuple.h"
+#include <cassert>
+#include <string>
+#include <system_error>
+#include <windows.h>
+
+// Must be included after windows.h
+#include <wincrypt.h>
+
+namespace llvm {
+
+/// Determines if the program is running on Windows 8 or newer. This
+/// reimplements one of the helpers in the Windows 8.1 SDK, which are intended
+/// to supercede raw calls to GetVersionEx. Old SDKs, Cygwin, and MinGW don't
+/// yet have VersionHelpers.h, so we have our own helper.
+bool RunningWindows8OrGreater();
+
+/// Returns the Windows version as Major.Minor.0.BuildNumber. Uses
+/// RtlGetVersion or GetVersionEx under the hood depending on what is available.
+/// GetVersionEx is deprecated, but this API exposes the build number which can
+/// be useful for working around certain kernel bugs.
+llvm::VersionTuple GetWindowsOSVersion();
+
+bool MakeErrMsg(std::string *ErrMsg, const std::string &prefix);
+
+// Include GetLastError() in a fatal error message.
+LLVM_ATTRIBUTE_NORETURN inline void ReportLastErrorFatal(const char *Msg) {
+  std::string ErrMsg;
+  MakeErrMsg(&ErrMsg, Msg);
+  llvm::report_fatal_error(ErrMsg);
+}
+
+template <typename HandleTraits>
+class ScopedHandle {
+  typedef typename HandleTraits::handle_type handle_type;
+  handle_type Handle;
+
+  ScopedHandle(const ScopedHandle &other) = delete;
+  void operator=(const ScopedHandle &other) = delete;
+public:
+  ScopedHandle()
+    : Handle(HandleTraits::GetInvalid()) {}
+
+  explicit ScopedHandle(handle_type h)
+    : Handle(h) {}
+
+  ~ScopedHandle() {
+    if (HandleTraits::IsValid(Handle))
+      HandleTraits::Close(Handle);
+  }
+
+  handle_type take() {
+    handle_type t = Handle;
+    Handle = HandleTraits::GetInvalid();
+    return t;
+  }
+
+  ScopedHandle &operator=(handle_type h) {
+    if (HandleTraits::IsValid(Handle))
+      HandleTraits::Close(Handle);
+    Handle = h;
+    return *this;
+  }
+
+  // True if Handle is valid.
+  explicit operator bool() const {
+    return HandleTraits::IsValid(Handle) ? true : false;
+  }
+
+  operator handle_type() const {
+    return Handle;
+  }
+};
+
+struct CommonHandleTraits {
+  typedef HANDLE handle_type;
+
+  static handle_type GetInvalid() {
+    return INVALID_HANDLE_VALUE;
+  }
+
+  static void Close(handle_type h) {
+    ::CloseHandle(h);
+  }
+
+  static bool IsValid(handle_type h) {
+    return h != GetInvalid();
+  }
+};
+
+struct JobHandleTraits : CommonHandleTraits {
+  static handle_type GetInvalid() {
+    return NULL;
+  }
+};
+
+struct CryptContextTraits : CommonHandleTraits {
+  typedef HCRYPTPROV handle_type;
+
+  static handle_type GetInvalid() {
+    return 0;
+  }
+
+  static void Close(handle_type h) {
+    ::CryptReleaseContext(h, 0);
+  }
+
+  static bool IsValid(handle_type h) {
+    return h != GetInvalid();
+  }
+};
+
+struct RegTraits : CommonHandleTraits {
+  typedef HKEY handle_type;
+
+  static handle_type GetInvalid() {
+    return NULL;
+  }
+
+  static void Close(handle_type h) {
+    ::RegCloseKey(h);
+  }
+
+  static bool IsValid(handle_type h) {
+    return h != GetInvalid();
+  }
+};
+
+struct FindHandleTraits : CommonHandleTraits {
+  static void Close(handle_type h) {
+    ::FindClose(h);
+  }
+};
+
+struct FileHandleTraits : CommonHandleTraits {};
+
+typedef ScopedHandle<CommonHandleTraits> ScopedCommonHandle;
+typedef ScopedHandle<FileHandleTraits>   ScopedFileHandle;
+typedef ScopedHandle<CryptContextTraits> ScopedCryptContext;
+typedef ScopedHandle<RegTraits>          ScopedRegHandle;
+typedef ScopedHandle<FindHandleTraits>   ScopedFindHandle;
+typedef ScopedHandle<JobHandleTraits>    ScopedJobHandle;
+
+template <class T>
+class SmallVectorImpl;
+
+template <class T>
+typename SmallVectorImpl<T>::const_pointer
+c_str(SmallVectorImpl<T> &str) {
+  str.push_back(0);
+  str.pop_back();
+  return str.data();
+}
+
+namespace sys {
+
+inline std::chrono::nanoseconds toDuration(FILETIME Time) {
+  ULARGE_INTEGER TimeInteger;
+  TimeInteger.LowPart = Time.dwLowDateTime;
+  TimeInteger.HighPart = Time.dwHighDateTime;
+
+  // FILETIME's are # of 100 nanosecond ticks (1/10th of a microsecond)
+  return std::chrono::nanoseconds(100 * TimeInteger.QuadPart);
+}
+
+inline TimePoint<> toTimePoint(FILETIME Time) {
+  ULARGE_INTEGER TimeInteger;
+  TimeInteger.LowPart = Time.dwLowDateTime;
+  TimeInteger.HighPart = Time.dwHighDateTime;
+
+  // Adjust for different epoch
+  TimeInteger.QuadPart -= 11644473600ll * 10000000;
+
+  // FILETIME's are # of 100 nanosecond ticks (1/10th of a microsecond)
+  return TimePoint<>(std::chrono::nanoseconds(100 * TimeInteger.QuadPart));
+}
+
+inline FILETIME toFILETIME(TimePoint<> TP) {
+  ULARGE_INTEGER TimeInteger;
+  TimeInteger.QuadPart = TP.time_since_epoch().count() / 100;
+  TimeInteger.QuadPart += 11644473600ll * 10000000;
+
+  FILETIME Time;
+  Time.dwLowDateTime = TimeInteger.LowPart;
+  Time.dwHighDateTime = TimeInteger.HighPart;
+  return Time;
+}
+
+namespace windows {
+// Returns command line arguments. Unlike arguments given to main(),
+// this function guarantees that the returned arguments are encoded in
+// UTF-8 regardless of the current code page setting.
+std::error_code GetCommandLineArguments(SmallVectorImpl<const char *> &Args,
+                                        BumpPtrAllocator &Alloc);
+
+/// Convert UTF-8 path to a suitable UTF-16 path for use with the Win32 Unicode
+/// File API.
+std::error_code widenPath(const Twine &Path8, SmallVectorImpl<wchar_t> &Path16,
+                          size_t MaxPathLen = MAX_PATH);
+
+} // end namespace windows
+} // end namespace sys
+} // end namespace llvm.
+
+#endif
diff --git a/linux-x64/clang/include/llvm/Support/WithColor.h b/linux-x64/clang/include/llvm/Support/WithColor.h
index f4e1075..eea4a72 100644
--- a/linux-x64/clang/include/llvm/Support/WithColor.h
+++ b/linux-x64/clang/include/llvm/Support/WithColor.h
@@ -9,14 +9,18 @@
 #ifndef LLVM_SUPPORT_WITHCOLOR_H
 #define LLVM_SUPPORT_WITHCOLOR_H
 
-#include "llvm/ADT/StringRef.h"
-#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/raw_ostream.h"
 
 namespace llvm {
 
-extern cl::OptionCategory ColorCategory;
+class Error;
+class StringRef;
 
-class raw_ostream;
+namespace cl {
+class OptionCategory;
+}
+
+extern cl::OptionCategory ColorCategory;
 
 // Symbolic names for various syntax elements.
 enum class HighlightColor {
@@ -32,31 +36,43 @@
   Remark
 };
 
+enum class ColorMode {
+  /// Determine whether to use color based on the command line argument and the
+  /// raw_ostream.
+  Auto,
+  /// Enable colors. Because raw_ostream is the one implementing colors, this
+  /// has no effect if the stream does not support colors or has colors
+  /// disabled.
+  Enable,
+  /// Disable colors.
+  Disable,
+};
+
 /// An RAII object that temporarily switches an output stream to a specific
 /// color.
 class WithColor {
   raw_ostream &OS;
-  bool DisableColors;
+  ColorMode Mode;
 
 public:
   /// To be used like this: WithColor(OS, HighlightColor::String) << "text";
   /// @param OS The output stream
   /// @param S Symbolic name for syntax element to color
-  /// @param DisableColors Whether to ignore color changes regardless of -color
-  /// and support in OS
-  WithColor(raw_ostream &OS, HighlightColor S, bool DisableColors = false);
+  /// @param Mode Enable, disable or compute whether to use colors.
+  WithColor(raw_ostream &OS, HighlightColor S,
+            ColorMode Mode = ColorMode::Auto);
   /// To be used like this: WithColor(OS, raw_ostream::Black) << "text";
   /// @param OS The output stream
   /// @param Color ANSI color to use, the special SAVEDCOLOR can be used to
   /// change only the bold attribute, and keep colors untouched
   /// @param Bold Bold/brighter text, default false
   /// @param BG If true, change the background, default: change foreground
-  /// @param DisableColors Whether to ignore color changes regardless of -color
-  /// and support in OS
+  /// @param Mode Enable, disable or compute whether to use colors.
   WithColor(raw_ostream &OS,
             raw_ostream::Colors Color = raw_ostream::SAVEDCOLOR,
-            bool Bold = false, bool BG = false, bool DisableColors = false)
-      : OS(OS), DisableColors(DisableColors) {
+            bool Bold = false, bool BG = false,
+            ColorMode Mode = ColorMode::Auto)
+      : OS(OS), Mode(Mode) {
     changeColor(Color, Bold, BG);
   }
   ~WithColor();
@@ -108,6 +124,14 @@
   /// Reset the colors to terminal defaults. Call this when you are done
   /// outputting colored text, or before program exit.
   WithColor &resetColor();
+
+  /// Implement default handling for Error.
+  /// Print "error: " to stderr.
+  static void defaultErrorHandler(Error Err);
+
+  /// Implement default handling for Warning.
+  /// Print "warning: " to stderr.
+  static void defaultWarningHandler(Error Warning);
 };
 
 } // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/Support/X86DisassemblerDecoderCommon.h b/linux-x64/clang/include/llvm/Support/X86DisassemblerDecoderCommon.h
index baf842b..5697ff9 100644
--- a/linux-x64/clang/include/llvm/Support/X86DisassemblerDecoderCommon.h
+++ b/linux-x64/clang/include/llvm/Support/X86DisassemblerDecoderCommon.h
@@ -361,6 +361,7 @@
   ENUM_ENTRY(ENCODING_RM_CD16,"R/M operand with CDisp scaling of 16")          \
   ENUM_ENTRY(ENCODING_RM_CD32,"R/M operand with CDisp scaling of 32")          \
   ENUM_ENTRY(ENCODING_RM_CD64,"R/M operand with CDisp scaling of 64")          \
+  ENUM_ENTRY(ENCODING_SIB,      "Force SIB operand in ModR/M byte.")           \
   ENUM_ENTRY(ENCODING_VSIB,     "VSIB operand in ModR/M byte.")                \
   ENUM_ENTRY(ENCODING_VSIB_CD2, "VSIB operand with CDisp scaling of 2")        \
   ENUM_ENTRY(ENCODING_VSIB_CD4, "VSIB operand with CDisp scaling of 4")        \
@@ -374,7 +375,7 @@
   ENUM_ENTRY(ENCODING_IW,     "2-byte")                                        \
   ENUM_ENTRY(ENCODING_ID,     "4-byte")                                        \
   ENUM_ENTRY(ENCODING_IO,     "8-byte")                                        \
-  ENUM_ENTRY(ENCODING_RB,     "(AL..DIL, R8L..R15L) Register code added to "   \
+  ENUM_ENTRY(ENCODING_RB,     "(AL..DIL, R8B..R15B) Register code added to "   \
                               "the opcode byte")                               \
   ENUM_ENTRY(ENCODING_RW,     "(AX..DI, R8W..R15W)")                           \
   ENUM_ENTRY(ENCODING_RD,     "(EAX..EDI, R8D..R15D)")                         \
@@ -411,6 +412,7 @@
   ENUM_ENTRY(TYPE_IMM,        "immediate operand")                             \
   ENUM_ENTRY(TYPE_UIMM8,      "1-byte unsigned immediate operand")             \
   ENUM_ENTRY(TYPE_M,          "Memory operand")                                \
+  ENUM_ENTRY(TYPE_MSIB,       "Memory operand force sib encoding")             \
   ENUM_ENTRY(TYPE_MVSIBX,     "Memory operand using XMM index")                \
   ENUM_ENTRY(TYPE_MVSIBY,     "Memory operand using YMM index")                \
   ENUM_ENTRY(TYPE_MVSIBZ,     "Memory operand using ZMM index")                \
@@ -424,6 +426,7 @@
   ENUM_ENTRY(TYPE_ZMM,        "64-byte")                                       \
   ENUM_ENTRY(TYPE_VK,         "mask register")                                 \
   ENUM_ENTRY(TYPE_VK_PAIR,    "mask register pair")                            \
+  ENUM_ENTRY(TYPE_TMM,        "tile")                                          \
   ENUM_ENTRY(TYPE_SEGMENTREG, "Segment register operand")                      \
   ENUM_ENTRY(TYPE_DEBUGREG,   "Debug register operand")                        \
   ENUM_ENTRY(TYPE_CONTROLREG, "Control register operand")                      \
diff --git a/linux-x64/clang/include/llvm/Support/X86TargetParser.def b/linux-x64/clang/include/llvm/Support/X86TargetParser.def
index 1749be3..ec19ce4 100644
--- a/linux-x64/clang/include/llvm/Support/X86TargetParser.def
+++ b/linux-x64/clang/include/llvm/Support/X86TargetParser.def
@@ -19,153 +19,185 @@
 X86_VENDOR(VENDOR_AMD,   "amd")
 #undef X86_VENDOR
 
-// This macro is used to implement CPU types that have an alias. As of now
-// there is only ever one alias.
-#ifndef X86_CPU_TYPE_COMPAT_WITH_ALIAS
-#define X86_CPU_TYPE_COMPAT_WITH_ALIAS(ARCHNAME, ENUM, STR, ALIAS) X86_CPU_TYPE_COMPAT(ARCHNAME, ENUM, STR)
-#endif
-
 // This macro is used for cpu types present in compiler-rt/libgcc.
-#ifndef X86_CPU_TYPE_COMPAT
-#define X86_CPU_TYPE_COMPAT(ARCHNAME, ENUM, STR) X86_CPU_TYPE(ARCHNAME, ENUM)
+#ifndef X86_CPU_TYPE
+#define X86_CPU_TYPE(ENUM, STR)
 #endif
 
-#ifndef X86_CPU_TYPE
-#define X86_CPU_TYPE(ARCHNAME, ENUM)
+#ifndef X86_CPU_TYPE_ALIAS
+#define X86_CPU_TYPE_ALIAS(ENUM, STR)
 #endif
-// The first part of this list must match what is implemented in libgcc and
-// compilert-rt. Clang uses this to know how to implement __builtin_cpu_is.
-X86_CPU_TYPE_COMPAT_WITH_ALIAS("bonnell",       INTEL_BONNELL,       "bonnell", "atom")
-X86_CPU_TYPE_COMPAT           ("core2",         INTEL_CORE2,         "core2")
-X86_CPU_TYPE_COMPAT           ("nehalem",       INTEL_COREI7,        "corei7")
-X86_CPU_TYPE_COMPAT_WITH_ALIAS("amdfam10",      AMDFAM10H,           "amdfam10h", "amdfam10")
-X86_CPU_TYPE_COMPAT_WITH_ALIAS("bdver1",        AMDFAM15H,           "amdfam15h", "amdfam15")
-X86_CPU_TYPE_COMPAT_WITH_ALIAS("silvermont",    INTEL_SILVERMONT,    "silvermont", "slm")
-X86_CPU_TYPE_COMPAT           ("knl",           INTEL_KNL,           "knl")
-X86_CPU_TYPE_COMPAT           ("btver1",        AMD_BTVER1,          "btver1")
-X86_CPU_TYPE_COMPAT           ("btver2",        AMD_BTVER2,          "btver2")
-X86_CPU_TYPE_COMPAT           ("znver1",        AMDFAM17H,           "amdfam17h")
-X86_CPU_TYPE_COMPAT           ("knm",           INTEL_KNM,           "knm")
-X86_CPU_TYPE_COMPAT           ("goldmont",      INTEL_GOLDMONT,      "goldmont")
-X86_CPU_TYPE_COMPAT           ("goldmont-plus", INTEL_GOLDMONT_PLUS, "goldmont-plus")
-X86_CPU_TYPE_COMPAT           ("tremont",       INTEL_TREMONT,       "tremont")
-// Entries below this are not in libgcc/compiler-rt.
-X86_CPU_TYPE                  ("i386",        INTEL_i386)
-X86_CPU_TYPE                  ("i486",        INTEL_i486)
-X86_CPU_TYPE                  ("pentium",     INTEL_PENTIUM)
-X86_CPU_TYPE                  ("pentium-mmx", INTEL_PENTIUM_MMX)
-X86_CPU_TYPE                  ("pentiumpro",  INTEL_PENTIUM_PRO)
-X86_CPU_TYPE                  ("pentium2",    INTEL_PENTIUM_II)
-X86_CPU_TYPE                  ("pentium3",    INTEL_PENTIUM_III)
-X86_CPU_TYPE                  ("pentium4",    INTEL_PENTIUM_IV)
-X86_CPU_TYPE                  ("pentium-m",   INTEL_PENTIUM_M)
-X86_CPU_TYPE                  ("yonah",       INTEL_CORE_DUO)
-X86_CPU_TYPE                  ("nocona",      INTEL_NOCONA)
-X86_CPU_TYPE                  ("prescott",    INTEL_PRESCOTT)
-X86_CPU_TYPE                  ("i486",        AMD_i486)
-X86_CPU_TYPE                  ("pentium",     AMDPENTIUM)
-X86_CPU_TYPE                  ("athlon",      AMD_ATHLON)
-X86_CPU_TYPE                  ("athlon-xp",   AMD_ATHLON_XP)
-X86_CPU_TYPE                  ("k8",          AMD_K8)
-X86_CPU_TYPE                  ("k8-sse3",     AMD_K8SSE3)
-#undef X86_CPU_TYPE_COMPAT_WITH_ALIAS
-#undef X86_CPU_TYPE_COMPAT
+
+// This list must match what is implemented in libgcc and compilert-rt. Clang
+// uses this to know how to implement __builtin_cpu_is.
+X86_CPU_TYPE(INTEL_BONNELL,       "bonnell")
+X86_CPU_TYPE(INTEL_CORE2,         "core2")
+X86_CPU_TYPE(INTEL_COREI7,        "corei7")
+X86_CPU_TYPE(AMDFAM10H,           "amdfam10h")
+X86_CPU_TYPE(AMDFAM15H,           "amdfam15h")
+X86_CPU_TYPE(INTEL_SILVERMONT,    "silvermont")
+X86_CPU_TYPE(INTEL_KNL,           "knl")
+X86_CPU_TYPE(AMD_BTVER1,          "btver1")
+X86_CPU_TYPE(AMD_BTVER2,          "btver2")
+X86_CPU_TYPE(AMDFAM17H,           "amdfam17h")
+X86_CPU_TYPE(INTEL_KNM,           "knm")
+X86_CPU_TYPE(INTEL_GOLDMONT,      "goldmont")
+X86_CPU_TYPE(INTEL_GOLDMONT_PLUS, "goldmont-plus")
+X86_CPU_TYPE(INTEL_TREMONT,       "tremont")
+X86_CPU_TYPE(AMDFAM19H,           "amdfam19h")
+
+// Alternate names supported by __builtin_cpu_is and target multiversioning.
+X86_CPU_TYPE_ALIAS(INTEL_BONNELL,    "atom")
+X86_CPU_TYPE_ALIAS(AMDFAM10H,        "amdfam10")
+X86_CPU_TYPE_ALIAS(AMDFAM15H,        "amdfam15")
+X86_CPU_TYPE_ALIAS(INTEL_SILVERMONT, "slm")
+
+#undef X86_CPU_TYPE_ALIAS
 #undef X86_CPU_TYPE
 
 // This macro is used for cpu subtypes present in compiler-rt/libgcc.
-#ifndef X86_CPU_SUBTYPE_COMPAT
-#define X86_CPU_SUBTYPE_COMPAT(ARCHNAME, ENUM, STR) X86_CPU_SUBTYPE(ARCHNAME, ENUM)
-#endif
-
 #ifndef X86_CPU_SUBTYPE
-#define X86_CPU_SUBTYPE(ARCHNAME, ENUM)
+#define X86_CPU_SUBTYPE(ENUM, STR)
 #endif
 
-// The first part of this list must match what is implemented in libgcc and
-// compilert-rt. Clang uses this to know how to implement __builtin_cpu_is.
-X86_CPU_SUBTYPE_COMPAT("nehalem",        INTEL_COREI7_NEHALEM,        "nehalem")
-X86_CPU_SUBTYPE_COMPAT("westmere",       INTEL_COREI7_WESTMERE,       "westmere")
-X86_CPU_SUBTYPE_COMPAT("sandybridge",    INTEL_COREI7_SANDYBRIDGE,    "sandybridge")
-X86_CPU_SUBTYPE_COMPAT("amdfam10",       AMDFAM10H_BARCELONA,         "barcelona")
-X86_CPU_SUBTYPE_COMPAT("amdfam10",       AMDFAM10H_SHANGHAI,          "shanghai")
-X86_CPU_SUBTYPE_COMPAT("amdfam10",       AMDFAM10H_ISTANBUL,          "istanbul")
-X86_CPU_SUBTYPE_COMPAT("bdver1",         AMDFAM15H_BDVER1,            "bdver1")
-X86_CPU_SUBTYPE_COMPAT("bdver2",         AMDFAM15H_BDVER2,            "bdver2")
-X86_CPU_SUBTYPE_COMPAT("bdver3",         AMDFAM15H_BDVER3,            "bdver3")
-X86_CPU_SUBTYPE_COMPAT("bdver4",         AMDFAM15H_BDVER4,            "bdver4")
-X86_CPU_SUBTYPE_COMPAT("znver1",         AMDFAM17H_ZNVER1,            "znver1")
-X86_CPU_SUBTYPE_COMPAT("ivybridge",      INTEL_COREI7_IVYBRIDGE,      "ivybridge")
-X86_CPU_SUBTYPE_COMPAT("haswell",        INTEL_COREI7_HASWELL,        "haswell")
-X86_CPU_SUBTYPE_COMPAT("broadwell",      INTEL_COREI7_BROADWELL,      "broadwell")
-X86_CPU_SUBTYPE_COMPAT("skylake",        INTEL_COREI7_SKYLAKE,        "skylake")
-X86_CPU_SUBTYPE_COMPAT("skylake-avx512", INTEL_COREI7_SKYLAKE_AVX512, "skylake-avx512")
-X86_CPU_SUBTYPE_COMPAT("cannonlake",     INTEL_COREI7_CANNONLAKE,     "cannonlake")
-X86_CPU_SUBTYPE_COMPAT("icelake-client", INTEL_COREI7_ICELAKE_CLIENT, "icelake-client")
-X86_CPU_SUBTYPE_COMPAT("icelake-server", INTEL_COREI7_ICELAKE_SERVER, "icelake-server")
-X86_CPU_SUBTYPE_COMPAT("znver2",         AMDFAM17H_ZNVER2,            "znver2")
-X86_CPU_SUBTYPE_COMPAT("cascadelake",    INTEL_COREI7_CASCADELAKE,    "cascadelake")
-// Entries below this are not in libgcc/compiler-rt.
-X86_CPU_SUBTYPE       ("core2",          INTEL_CORE2_65)
-X86_CPU_SUBTYPE       ("penryn",         INTEL_CORE2_45)
-X86_CPU_SUBTYPE       ("k6",             AMDPENTIUM_K6)
-X86_CPU_SUBTYPE       ("k6-2",           AMDPENTIUM_K62)
-X86_CPU_SUBTYPE       ("k6-3",           AMDPENTIUM_K63)
-X86_CPU_SUBTYPE       ("geode",          AMDPENTIUM_GEODE)
-X86_CPU_SUBTYPE       ("cooperlake",     INTEL_COREI7_COOPERLAKE)
-#undef X86_CPU_SUBTYPE_COMPAT
+// This list must match what is implemented in libgcc and compilert-rt. Clang
+// uses this to know how to implement __builtin_cpu_is.
+X86_CPU_SUBTYPE(INTEL_COREI7_NEHALEM,        "nehalem")
+X86_CPU_SUBTYPE(INTEL_COREI7_WESTMERE,       "westmere")
+X86_CPU_SUBTYPE(INTEL_COREI7_SANDYBRIDGE,    "sandybridge")
+X86_CPU_SUBTYPE(AMDFAM10H_BARCELONA,         "barcelona")
+X86_CPU_SUBTYPE(AMDFAM10H_SHANGHAI,          "shanghai")
+X86_CPU_SUBTYPE(AMDFAM10H_ISTANBUL,          "istanbul")
+X86_CPU_SUBTYPE(AMDFAM15H_BDVER1,            "bdver1")
+X86_CPU_SUBTYPE(AMDFAM15H_BDVER2,            "bdver2")
+X86_CPU_SUBTYPE(AMDFAM15H_BDVER3,            "bdver3")
+X86_CPU_SUBTYPE(AMDFAM15H_BDVER4,            "bdver4")
+X86_CPU_SUBTYPE(AMDFAM17H_ZNVER1,            "znver1")
+X86_CPU_SUBTYPE(INTEL_COREI7_IVYBRIDGE,      "ivybridge")
+X86_CPU_SUBTYPE(INTEL_COREI7_HASWELL,        "haswell")
+X86_CPU_SUBTYPE(INTEL_COREI7_BROADWELL,      "broadwell")
+X86_CPU_SUBTYPE(INTEL_COREI7_SKYLAKE,        "skylake")
+X86_CPU_SUBTYPE(INTEL_COREI7_SKYLAKE_AVX512, "skylake-avx512")
+X86_CPU_SUBTYPE(INTEL_COREI7_CANNONLAKE,     "cannonlake")
+X86_CPU_SUBTYPE(INTEL_COREI7_ICELAKE_CLIENT, "icelake-client")
+X86_CPU_SUBTYPE(INTEL_COREI7_ICELAKE_SERVER, "icelake-server")
+X86_CPU_SUBTYPE(AMDFAM17H_ZNVER2,            "znver2")
+X86_CPU_SUBTYPE(INTEL_COREI7_CASCADELAKE,    "cascadelake")
+X86_CPU_SUBTYPE(INTEL_COREI7_TIGERLAKE,      "tigerlake")
+X86_CPU_SUBTYPE(INTEL_COREI7_COOPERLAKE,     "cooperlake")
+X86_CPU_SUBTYPE(INTEL_COREI7_SAPPHIRERAPIDS, "sapphirerapids")
+X86_CPU_SUBTYPE(INTEL_COREI7_ALDERLAKE,      "alderlake")
+X86_CPU_SUBTYPE(AMDFAM19H_ZNVER3,            "znver3")
 #undef X86_CPU_SUBTYPE
 
 
 // This macro is used for cpu types present in compiler-rt/libgcc.
 #ifndef X86_FEATURE_COMPAT
-#define X86_FEATURE_COMPAT(VAL, ENUM, STR) X86_FEATURE(VAL, ENUM)
+#define X86_FEATURE_COMPAT(ENUM, STR) X86_FEATURE(ENUM, STR)
 #endif
 
 #ifndef X86_FEATURE
-#define X86_FEATURE(VAL, ENUM)
+#define X86_FEATURE(ENUM, STR)
 #endif
-X86_FEATURE_COMPAT( 0, FEATURE_CMOV,            "cmov")
-X86_FEATURE_COMPAT( 1, FEATURE_MMX,             "mmx")
-X86_FEATURE_COMPAT( 2, FEATURE_POPCNT,          "popcnt")
-X86_FEATURE_COMPAT( 3, FEATURE_SSE,             "sse")
-X86_FEATURE_COMPAT( 4, FEATURE_SSE2,            "sse2")
-X86_FEATURE_COMPAT( 5, FEATURE_SSE3,            "sse3")
-X86_FEATURE_COMPAT( 6, FEATURE_SSSE3,           "ssse3")
-X86_FEATURE_COMPAT( 7, FEATURE_SSE4_1,          "sse4.1")
-X86_FEATURE_COMPAT( 8, FEATURE_SSE4_2,          "sse4.2")
-X86_FEATURE_COMPAT( 9, FEATURE_AVX,             "avx")
-X86_FEATURE_COMPAT(10, FEATURE_AVX2,            "avx2")
-X86_FEATURE_COMPAT(11, FEATURE_SSE4_A,          "sse4a")
-X86_FEATURE_COMPAT(12, FEATURE_FMA4,            "fma4")
-X86_FEATURE_COMPAT(13, FEATURE_XOP,             "xop")
-X86_FEATURE_COMPAT(14, FEATURE_FMA,             "fma")
-X86_FEATURE_COMPAT(15, FEATURE_AVX512F,         "avx512f")
-X86_FEATURE_COMPAT(16, FEATURE_BMI,             "bmi")
-X86_FEATURE_COMPAT(17, FEATURE_BMI2,            "bmi2")
-X86_FEATURE_COMPAT(18, FEATURE_AES,             "aes")
-X86_FEATURE_COMPAT(19, FEATURE_PCLMUL,          "pclmul")
-X86_FEATURE_COMPAT(20, FEATURE_AVX512VL,        "avx512vl")
-X86_FEATURE_COMPAT(21, FEATURE_AVX512BW,        "avx512bw")
-X86_FEATURE_COMPAT(22, FEATURE_AVX512DQ,        "avx512dq")
-X86_FEATURE_COMPAT(23, FEATURE_AVX512CD,        "avx512cd")
-X86_FEATURE_COMPAT(24, FEATURE_AVX512ER,        "avx512er")
-X86_FEATURE_COMPAT(25, FEATURE_AVX512PF,        "avx512pf")
-X86_FEATURE_COMPAT(26, FEATURE_AVX512VBMI,      "avx512vbmi")
-X86_FEATURE_COMPAT(27, FEATURE_AVX512IFMA,      "avx512ifma")
-X86_FEATURE_COMPAT(28, FEATURE_AVX5124VNNIW,    "avx5124vnniw")
-X86_FEATURE_COMPAT(29, FEATURE_AVX5124FMAPS,    "avx5124fmaps")
-X86_FEATURE_COMPAT(30, FEATURE_AVX512VPOPCNTDQ, "avx512vpopcntdq")
-X86_FEATURE_COMPAT(31, FEATURE_AVX512VBMI2,     "avx512vbmi2")
-X86_FEATURE_COMPAT(32, FEATURE_GFNI,            "gfni")
-X86_FEATURE_COMPAT(33, FEATURE_VPCLMULQDQ,      "vpclmulqdq")
-X86_FEATURE_COMPAT(34, FEATURE_AVX512VNNI,      "avx512vnni")
-X86_FEATURE_COMPAT(35, FEATURE_AVX512BITALG,    "avx512bitalg")
+
+X86_FEATURE_COMPAT(CMOV,            "cmov")
+X86_FEATURE_COMPAT(MMX,             "mmx")
+X86_FEATURE_COMPAT(POPCNT,          "popcnt")
+X86_FEATURE_COMPAT(SSE,             "sse")
+X86_FEATURE_COMPAT(SSE2,            "sse2")
+X86_FEATURE_COMPAT(SSE3,            "sse3")
+X86_FEATURE_COMPAT(SSSE3,           "ssse3")
+X86_FEATURE_COMPAT(SSE4_1,          "sse4.1")
+X86_FEATURE_COMPAT(SSE4_2,          "sse4.2")
+X86_FEATURE_COMPAT(AVX,             "avx")
+X86_FEATURE_COMPAT(AVX2,            "avx2")
+X86_FEATURE_COMPAT(SSE4_A,          "sse4a")
+X86_FEATURE_COMPAT(FMA4,            "fma4")
+X86_FEATURE_COMPAT(XOP,             "xop")
+X86_FEATURE_COMPAT(FMA,             "fma")
+X86_FEATURE_COMPAT(AVX512F,         "avx512f")
+X86_FEATURE_COMPAT(BMI,             "bmi")
+X86_FEATURE_COMPAT(BMI2,            "bmi2")
+X86_FEATURE_COMPAT(AES,             "aes")
+X86_FEATURE_COMPAT(PCLMUL,          "pclmul")
+X86_FEATURE_COMPAT(AVX512VL,        "avx512vl")
+X86_FEATURE_COMPAT(AVX512BW,        "avx512bw")
+X86_FEATURE_COMPAT(AVX512DQ,        "avx512dq")
+X86_FEATURE_COMPAT(AVX512CD,        "avx512cd")
+X86_FEATURE_COMPAT(AVX512ER,        "avx512er")
+X86_FEATURE_COMPAT(AVX512PF,        "avx512pf")
+X86_FEATURE_COMPAT(AVX512VBMI,      "avx512vbmi")
+X86_FEATURE_COMPAT(AVX512IFMA,      "avx512ifma")
+X86_FEATURE_COMPAT(AVX5124VNNIW,    "avx5124vnniw")
+X86_FEATURE_COMPAT(AVX5124FMAPS,    "avx5124fmaps")
+X86_FEATURE_COMPAT(AVX512VPOPCNTDQ, "avx512vpopcntdq")
+X86_FEATURE_COMPAT(AVX512VBMI2,     "avx512vbmi2")
+X86_FEATURE_COMPAT(GFNI,            "gfni")
+X86_FEATURE_COMPAT(VPCLMULQDQ,      "vpclmulqdq")
+X86_FEATURE_COMPAT(AVX512VNNI,      "avx512vnni")
+X86_FEATURE_COMPAT(AVX512BITALG,    "avx512bitalg")
+X86_FEATURE_COMPAT(AVX512BF16,      "avx512bf16")
+X86_FEATURE_COMPAT(AVX512VP2INTERSECT, "avx512vp2intersect")
 // Features below here are not in libgcc/compiler-rt.
-X86_FEATURE       (64, FEATURE_MOVBE)
-X86_FEATURE       (65, FEATURE_ADX)
-X86_FEATURE       (66, FEATURE_EM64T)
-X86_FEATURE       (67, FEATURE_CLFLUSHOPT)
-X86_FEATURE       (68, FEATURE_SHA)
-X86_FEATURE       (69, FEATURE_AVX512BF16)
+X86_FEATURE       (3DNOW,           "3dnow")
+X86_FEATURE       (3DNOWA,          "3dnowa")
+X86_FEATURE       (64BIT,           "64bit")
+X86_FEATURE       (ADX,             "adx")
+X86_FEATURE       (AMX_BF16,        "amx-bf16")
+X86_FEATURE       (AMX_INT8,        "amx-int8")
+X86_FEATURE       (AMX_TILE,        "amx-tile")
+X86_FEATURE       (CLDEMOTE,        "cldemote")
+X86_FEATURE       (CLFLUSHOPT,      "clflushopt")
+X86_FEATURE       (CLWB,            "clwb")
+X86_FEATURE       (CLZERO,          "clzero")
+X86_FEATURE       (CMPXCHG16B,      "cx16")
+X86_FEATURE       (CMPXCHG8B,       "cx8")
+X86_FEATURE       (ENQCMD,          "enqcmd")
+X86_FEATURE       (F16C,            "f16c")
+X86_FEATURE       (FSGSBASE,        "fsgsbase")
+X86_FEATURE       (FXSR,            "fxsr")
+X86_FEATURE       (INVPCID,         "invpcid")
+X86_FEATURE       (KL,              "kl")
+X86_FEATURE       (WIDEKL,          "widekl")
+X86_FEATURE       (LWP,             "lwp")
+X86_FEATURE       (LZCNT,           "lzcnt")
+X86_FEATURE       (MOVBE,           "movbe")
+X86_FEATURE       (MOVDIR64B,       "movdir64b")
+X86_FEATURE       (MOVDIRI,         "movdiri")
+X86_FEATURE       (MWAITX,          "mwaitx")
+X86_FEATURE       (PCONFIG,         "pconfig")
+X86_FEATURE       (PKU,             "pku")
+X86_FEATURE       (PREFETCHWT1,     "prefetchwt1")
+X86_FEATURE       (PRFCHW,          "prfchw")
+X86_FEATURE       (PTWRITE,         "ptwrite")
+X86_FEATURE       (RDPID,           "rdpid")
+X86_FEATURE       (RDRND,           "rdrnd")
+X86_FEATURE       (RDSEED,          "rdseed")
+X86_FEATURE       (RTM,             "rtm")
+X86_FEATURE       (SAHF,            "sahf")
+X86_FEATURE       (SERIALIZE,       "serialize")
+X86_FEATURE       (SGX,             "sgx")
+X86_FEATURE       (SHA,             "sha")
+X86_FEATURE       (SHSTK,           "shstk")
+X86_FEATURE       (TBM,             "tbm")
+X86_FEATURE       (TSXLDTRK,        "tsxldtrk")
+X86_FEATURE       (UINTR,           "uintr")
+X86_FEATURE       (VAES,            "vaes")
+X86_FEATURE       (VZEROUPPER,      "vzeroupper")
+X86_FEATURE       (WAITPKG,         "waitpkg")
+X86_FEATURE       (WBNOINVD,        "wbnoinvd")
+X86_FEATURE       (X87,             "x87")
+X86_FEATURE       (XSAVE,           "xsave")
+X86_FEATURE       (XSAVEC,          "xsavec")
+X86_FEATURE       (XSAVEOPT,        "xsaveopt")
+X86_FEATURE       (XSAVES,          "xsaves")
+X86_FEATURE       (HRESET,          "hreset")
+X86_FEATURE       (AVXVNNI,         "avxvnni")
+// These features aren't really CPU features, but the frontend can set them.
+X86_FEATURE       (RETPOLINE_EXTERNAL_THUNK,    "retpoline-external-thunk")
+X86_FEATURE       (RETPOLINE_INDIRECT_BRANCHES, "retpoline-indirect-branches")
+X86_FEATURE       (RETPOLINE_INDIRECT_CALLS,    "retpoline-indirect-calls")
+X86_FEATURE       (LVI_CFI,                     "lvi-cfi")
+X86_FEATURE       (LVI_LOAD_HARDENING,          "lvi-load-hardening")
 #undef X86_FEATURE_COMPAT
 #undef X86_FEATURE
diff --git a/linux-x64/clang/include/llvm/Support/X86TargetParser.h b/linux-x64/clang/include/llvm/Support/X86TargetParser.h
new file mode 100644
index 0000000..2d50830
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Support/X86TargetParser.h
@@ -0,0 +1,159 @@
+//===-- X86TargetParser - Parser for X86 features ---------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements a target parser to recognise X86 hardware features.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_SUPPORT_X86TARGETPARSERCOMMON_H
+#define LLVM_SUPPORT_X86TARGETPARSERCOMMON_H
+
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringMap.h"
+
+namespace llvm {
+class StringRef;
+
+namespace X86 {
+
+// This should be kept in sync with libcc/compiler-rt as its included by clang
+// as a proxy for what's in libgcc/compiler-rt.
+enum ProcessorVendors : unsigned {
+  VENDOR_DUMMY,
+#define X86_VENDOR(ENUM, STRING) \
+  ENUM,
+#include "llvm/Support/X86TargetParser.def"
+  VENDOR_OTHER
+};
+
+// This should be kept in sync with libcc/compiler-rt as its included by clang
+// as a proxy for what's in libgcc/compiler-rt.
+enum ProcessorTypes : unsigned {
+  CPU_TYPE_DUMMY,
+#define X86_CPU_TYPE(ENUM, STRING) \
+  ENUM,
+#include "llvm/Support/X86TargetParser.def"
+  CPU_TYPE_MAX
+};
+
+// This should be kept in sync with libcc/compiler-rt as its included by clang
+// as a proxy for what's in libgcc/compiler-rt.
+enum ProcessorSubtypes : unsigned {
+  CPU_SUBTYPE_DUMMY,
+#define X86_CPU_SUBTYPE(ENUM, STRING) \
+  ENUM,
+#include "llvm/Support/X86TargetParser.def"
+  CPU_SUBTYPE_MAX
+};
+
+// This should be kept in sync with libcc/compiler-rt as it should be used
+// by clang as a proxy for what's in libgcc/compiler-rt.
+enum ProcessorFeatures {
+#define X86_FEATURE(ENUM, STRING) FEATURE_##ENUM,
+#include "llvm/Support/X86TargetParser.def"
+  CPU_FEATURE_MAX
+};
+
+enum CPUKind {
+  CK_None,
+  CK_i386,
+  CK_i486,
+  CK_WinChipC6,
+  CK_WinChip2,
+  CK_C3,
+  CK_i586,
+  CK_Pentium,
+  CK_PentiumMMX,
+  CK_PentiumPro,
+  CK_i686,
+  CK_Pentium2,
+  CK_Pentium3,
+  CK_PentiumM,
+  CK_C3_2,
+  CK_Yonah,
+  CK_Pentium4,
+  CK_Prescott,
+  CK_Nocona,
+  CK_Core2,
+  CK_Penryn,
+  CK_Bonnell,
+  CK_Silvermont,
+  CK_Goldmont,
+  CK_GoldmontPlus,
+  CK_Tremont,
+  CK_Nehalem,
+  CK_Westmere,
+  CK_SandyBridge,
+  CK_IvyBridge,
+  CK_Haswell,
+  CK_Broadwell,
+  CK_SkylakeClient,
+  CK_SkylakeServer,
+  CK_Cascadelake,
+  CK_Cooperlake,
+  CK_Cannonlake,
+  CK_IcelakeClient,
+  CK_IcelakeServer,
+  CK_Tigerlake,
+  CK_SapphireRapids,
+  CK_Alderlake,
+  CK_KNL,
+  CK_KNM,
+  CK_Lakemont,
+  CK_K6,
+  CK_K6_2,
+  CK_K6_3,
+  CK_Athlon,
+  CK_AthlonXP,
+  CK_K8,
+  CK_K8SSE3,
+  CK_AMDFAM10,
+  CK_BTVER1,
+  CK_BTVER2,
+  CK_BDVER1,
+  CK_BDVER2,
+  CK_BDVER3,
+  CK_BDVER4,
+  CK_ZNVER1,
+  CK_ZNVER2,
+  CK_ZNVER3,
+  CK_x86_64,
+  CK_x86_64_v2,
+  CK_x86_64_v3,
+  CK_x86_64_v4,
+  CK_Geode,
+};
+
+/// Parse \p CPU string into a CPUKind. Will only accept 64-bit capable CPUs if
+/// \p Only64Bit is true.
+CPUKind parseArchX86(StringRef CPU, bool Only64Bit = false);
+CPUKind parseTuneCPU(StringRef CPU, bool Only64Bit = false);
+
+/// Provide a list of valid CPU names. If \p Only64Bit is true, the list will
+/// only contain 64-bit capable CPUs.
+void fillValidCPUArchList(SmallVectorImpl<StringRef> &Values,
+                          bool Only64Bit = false);
+/// Provide a list of valid -mtune names.
+void fillValidTuneCPUList(SmallVectorImpl<StringRef> &Values,
+                          bool Only64Bit = false);
+
+/// Get the key feature prioritizing target multiversioning.
+ProcessorFeatures getKeyFeature(CPUKind Kind);
+
+/// Fill in the features that \p CPU supports into \p Features.
+void getFeaturesForCPU(StringRef CPU, SmallVectorImpl<StringRef> &Features);
+
+/// Set or clear entries in \p Features that are implied to be enabled/disabled
+/// by the provided \p Feature.
+void updateImpliedFeatures(StringRef Feature, bool Enabled,
+                           StringMap<bool> &Features);
+
+} // namespace X86
+} // namespace llvm
+
+#endif
diff --git a/linux-x64/clang/include/llvm/Support/YAMLParser.h b/linux-x64/clang/include/llvm/Support/YAMLParser.h
index 3570119..759e11a 100644
--- a/linux-x64/clang/include/llvm/Support/YAMLParser.h
+++ b/linux-x64/clang/include/llvm/Support/YAMLParser.h
@@ -40,6 +40,7 @@
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/SMLoc.h"
+#include "llvm/Support/SourceMgr.h"
 #include <cassert>
 #include <cstddef>
 #include <iterator>
@@ -51,7 +52,6 @@
 namespace llvm {
 
 class MemoryBufferRef;
-class SourceMgr;
 class raw_ostream;
 class Twine;
 
@@ -78,6 +78,9 @@
 /// escaped, but emitted verbatim.
 std::string escape(StringRef Input, bool EscapePrintable = true);
 
+/// Parse \p S as a bool according to https://yaml.org/type/bool.html.
+llvm::Optional<bool> parseBool(StringRef S);
+
 /// This class represents a YAML stream potentially containing multiple
 ///        documents.
 class Stream {
@@ -100,7 +103,10 @@
     return !failed();
   }
 
-  void printError(Node *N, const Twine &Msg);
+  void printError(Node *N, const Twine &Msg,
+                  SourceMgr::DiagKind Kind = SourceMgr::DK_Error);
+  void printError(const SMRange &Range, const Twine &Msg,
+                  SourceMgr::DiagKind Kind = SourceMgr::DK_Error);
 
 private:
   friend class Document;
@@ -139,7 +145,7 @@
 
   void operator delete(void *Ptr, BumpPtrAllocator &Alloc,
                        size_t Size) noexcept {
-    Alloc.Deallocate(Ptr, Size);
+    Alloc.Deallocate(Ptr, Size, 0);
   }
 
   void operator delete(void *) noexcept = delete;
@@ -222,7 +228,7 @@
 
   /// Gets the value of this node as a StringRef.
   ///
-  /// \param Storage is used to store the content of the returned StringRef iff
+  /// \param Storage is used to store the content of the returned StringRef if
   ///        it requires any modification from how it appeared in the source.
   ///        This happens with escaped characters and multi-line literals.
   StringRef getValue(SmallVectorImpl<char> &Storage) const;
@@ -509,7 +515,6 @@
       : Node(NK_Alias, D, StringRef(), StringRef()), Name(Val) {}
 
   StringRef getName() const { return Name; }
-  Node *getTarget();
 
   static bool classof(const Node *N) { return N->getType() == NK_Alias; }
 
diff --git a/linux-x64/clang/include/llvm/Support/YAMLTraits.h b/linux-x64/clang/include/llvm/Support/YAMLTraits.h
index 2185cd7..bdd27dd 100644
--- a/linux-x64/clang/include/llvm/Support/YAMLTraits.h
+++ b/linux-x64/clang/include/llvm/Support/YAMLTraits.h
@@ -19,7 +19,9 @@
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/Regex.h"
+#include "llvm/Support/SMLoc.h"
 #include "llvm/Support/SourceMgr.h"
+#include "llvm/Support/VersionTuple.h"
 #include "llvm/Support/YAMLParser.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cassert>
@@ -61,7 +63,7 @@
   // Must provide:
   // static void mapping(IO &io, T &fields);
   // Optionally may provide:
-  // static StringRef validate(IO &io, T &fields);
+  // static std::string validate(IO &io, T &fields);
   //
   // The optional flow flag will cause generated YAML to use a flow mapping
   // (e.g. { a: 0, b: 1 }):
@@ -83,7 +85,7 @@
   // Must provide:
   // static void mapping(IO &io, T &fields, Context &Ctx);
   // Optionally may provide:
-  // static StringRef validate(IO &io, T &fields, Context &Ctx);
+  // static std::string validate(IO &io, T &fields, Context &Ctx);
   //
   // The optional flow flag will cause generated YAML to use a flow mapping
   // (e.g. { a: 0, b: 1 }):
@@ -421,7 +423,7 @@
 
 // Test if MappingContextTraits<T>::validate() is defined on type T.
 template <class T, class Context> struct has_MappingValidateTraits {
-  using Signature_validate = StringRef (*)(class IO &, T &, Context &);
+  using Signature_validate = std::string (*)(class IO &, T &, Context &);
 
   template <typename U>
   static char test(SameType<Signature_validate, &U::validate>*);
@@ -435,7 +437,7 @@
 
 // Test if MappingTraits<T>::validate() is defined on type T.
 template <class T> struct has_MappingValidateTraits<T, EmptyContext> {
-  using Signature_validate = StringRef (*)(class IO &, T &);
+  using Signature_validate = std::string (*)(class IO &, T &);
 
   template <typename U>
   static char test(SameType<Signature_validate, &U::validate> *);
@@ -637,6 +639,7 @@
 }
 
 inline bool isBool(StringRef S) {
+  // FIXME: using parseBool is causing multiple tests to fail.
   return S.equals("true") || S.equals("True") || S.equals("TRUE") ||
          S.equals("false") || S.equals("False") || S.equals("FALSE");
 }
@@ -649,23 +652,25 @@
 inline QuotingType needsQuotes(StringRef S) {
   if (S.empty())
     return QuotingType::Single;
-  if (isspace(S.front()) || isspace(S.back()))
-    return QuotingType::Single;
+
+  QuotingType MaxQuotingNeeded = QuotingType::None;
+  if (isSpace(static_cast<unsigned char>(S.front())) ||
+      isSpace(static_cast<unsigned char>(S.back())))
+    MaxQuotingNeeded = QuotingType::Single;
   if (isNull(S))
-    return QuotingType::Single;
+    MaxQuotingNeeded = QuotingType::Single;
   if (isBool(S))
-    return QuotingType::Single;
+    MaxQuotingNeeded = QuotingType::Single;
   if (isNumeric(S))
-    return QuotingType::Single;
+    MaxQuotingNeeded = QuotingType::Single;
 
   // 7.3.3 Plain Style
   // Plain scalars must not begin with most indicators, as this would cause
   // ambiguity with other YAML constructs.
   static constexpr char Indicators[] = R"(-?:\,[]{}#&*!|>'"%@`)";
   if (S.find_first_of(Indicators) == 0)
-    return QuotingType::Single;
+    MaxQuotingNeeded = QuotingType::Single;
 
-  QuotingType MaxQuotingNeeded = QuotingType::None;
   for (unsigned char C : S) {
     // Alphanum is safe.
     if (isAlnum(C))
@@ -683,11 +688,11 @@
     case 0x9:
       continue;
     // LF(0xA) and CR(0xD) may delimit values and so require at least single
-    // quotes.
+    // quotes. LLVM YAML parser cannot handle single quoted multiline so use
+    // double quoting to produce valid YAML.
     case 0xA:
     case 0xD:
-      MaxQuotingNeeded = QuotingType::Single;
-      continue;
+      return QuotingType::Double;
     // DEL (0x7F) are excluded from the allowed character range.
     case 0x7F:
       return QuotingType::Double;
@@ -748,7 +753,7 @@
   IO(void *Ctxt = nullptr);
   virtual ~IO();
 
-  virtual bool outputting() = 0;
+  virtual bool outputting() const = 0;
 
   virtual unsigned beginSequence() = 0;
   virtual bool preflightElement(unsigned, void *&) = 0;
@@ -787,6 +792,7 @@
   virtual NodeKind getNodeKind() = 0;
 
   virtual void setError(const Twine &) = 0;
+  virtual void setAllowUnknownKeys(bool Allow);
 
   template <typename T>
   void enumCase(T &Val, const char* Str, const T ConstVal) {
@@ -842,7 +848,7 @@
       Val = Val | ConstVal;
   }
 
-  void *getContext();
+  void *getContext() const;
   void setContext(void *);
 
   template <typename T> void mapRequired(const char *Key, T &Val) {
@@ -867,7 +873,7 @@
   }
 
   template <typename T, typename Context>
-  typename std::enable_if<has_SequenceTraits<T>::value, void>::type
+  std::enable_if_t<has_SequenceTraits<T>::value, void>
   mapOptionalWithContext(const char *Key, T &Val, Context &Ctx) {
     // omit key/value instead of outputting empty sequence
     if (this->canElideEmptySequence() && !(Val.begin() != Val.end()))
@@ -882,7 +888,7 @@
   }
 
   template <typename T, typename Context>
-  typename std::enable_if<!has_SequenceTraits<T>::value, void>::type
+  std::enable_if_t<!has_SequenceTraits<T>::value, void>
   mapOptionalWithContext(const char *Key, T &Val, Context &Ctx) {
     this->processKey(Key, Val, false, Ctx);
   }
@@ -900,24 +906,7 @@
   template <typename T, typename Context>
   void processKeyWithDefault(const char *Key, Optional<T> &Val,
                              const Optional<T> &DefaultValue, bool Required,
-                             Context &Ctx) {
-    assert(DefaultValue.hasValue() == false &&
-           "Optional<T> shouldn't have a value!");
-    void *SaveInfo;
-    bool UseDefault = true;
-    const bool sameAsDefault = outputting() && !Val.hasValue();
-    if (!outputting() && !Val.hasValue())
-      Val = T();
-    if (Val.hasValue() &&
-        this->preflightKey(Key, Required, sameAsDefault, UseDefault,
-                           SaveInfo)) {
-      yamlize(*this, Val.getValue(), Required, Ctx);
-      this->postflightKey(SaveInfo);
-    } else {
-      if (UseDefault)
-        Val = DefaultValue;
-    }
-  }
+                             Context &Ctx);
 
   template <typename T, typename Context>
   void processKeyWithDefault(const char *Key, T &Val, const T &DefaultValue,
@@ -964,7 +953,7 @@
 } // end namespace detail
 
 template <typename T>
-typename std::enable_if<has_ScalarEnumerationTraits<T>::value, void>::type
+std::enable_if_t<has_ScalarEnumerationTraits<T>::value, void>
 yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) {
   io.beginEnumScalar();
   ScalarEnumerationTraits<T>::enumeration(io, Val);
@@ -972,7 +961,7 @@
 }
 
 template <typename T>
-typename std::enable_if<has_ScalarBitSetTraits<T>::value, void>::type
+std::enable_if_t<has_ScalarBitSetTraits<T>::value, void>
 yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) {
   bool DoClear;
   if ( io.beginBitSetScalar(DoClear) ) {
@@ -984,8 +973,8 @@
 }
 
 template <typename T>
-typename std::enable_if<has_ScalarTraits<T>::value, void>::type
-yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) {
+std::enable_if_t<has_ScalarTraits<T>::value, void> yamlize(IO &io, T &Val, bool,
+                                                           EmptyContext &Ctx) {
   if ( io.outputting() ) {
     std::string Storage;
     raw_string_ostream Buffer(Storage);
@@ -1004,7 +993,7 @@
 }
 
 template <typename T>
-typename std::enable_if<has_BlockScalarTraits<T>::value, void>::type
+std::enable_if_t<has_BlockScalarTraits<T>::value, void>
 yamlize(IO &YamlIO, T &Val, bool, EmptyContext &Ctx) {
   if (YamlIO.outputting()) {
     std::string Storage;
@@ -1023,7 +1012,7 @@
 }
 
 template <typename T>
-typename std::enable_if<has_TaggedScalarTraits<T>::value, void>::type
+std::enable_if_t<has_TaggedScalarTraits<T>::value, void>
 yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) {
   if (io.outputting()) {
     std::string ScalarStorage, TagStorage;
@@ -1048,14 +1037,14 @@
 }
 
 template <typename T, typename Context>
-typename std::enable_if<validatedMappingTraits<T, Context>::value, void>::type
+std::enable_if_t<validatedMappingTraits<T, Context>::value, void>
 yamlize(IO &io, T &Val, bool, Context &Ctx) {
   if (has_FlowTraits<MappingTraits<T>>::value)
     io.beginFlowMapping();
   else
     io.beginMapping();
   if (io.outputting()) {
-    StringRef Err = MappingTraits<T>::validate(io, Val);
+    std::string Err = MappingTraits<T>::validate(io, Val);
     if (!Err.empty()) {
       errs() << Err << "\n";
       assert(Err.empty() && "invalid struct trying to be written as yaml");
@@ -1063,7 +1052,7 @@
   }
   detail::doMapping(io, Val, Ctx);
   if (!io.outputting()) {
-    StringRef Err = MappingTraits<T>::validate(io, Val);
+    std::string Err = MappingTraits<T>::validate(io, Val);
     if (!Err.empty())
       io.setError(Err);
   }
@@ -1074,7 +1063,7 @@
 }
 
 template <typename T, typename Context>
-typename std::enable_if<unvalidatedMappingTraits<T, Context>::value, void>::type
+std::enable_if_t<unvalidatedMappingTraits<T, Context>::value, void>
 yamlize(IO &io, T &Val, bool, Context &Ctx) {
   if (has_FlowTraits<MappingTraits<T>>::value) {
     io.beginFlowMapping();
@@ -1088,7 +1077,7 @@
 }
 
 template <typename T>
-typename std::enable_if<has_CustomMappingTraits<T>::value, void>::type
+std::enable_if_t<has_CustomMappingTraits<T>::value, void>
 yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) {
   if ( io.outputting() ) {
     io.beginMapping();
@@ -1103,7 +1092,7 @@
 }
 
 template <typename T>
-typename std::enable_if<has_PolymorphicTraits<T>::value, void>::type
+std::enable_if_t<has_PolymorphicTraits<T>::value, void>
 yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) {
   switch (io.outputting() ? PolymorphicTraits<T>::getKind(Val)
                           : io.getNodeKind()) {
@@ -1117,13 +1106,13 @@
 }
 
 template <typename T>
-typename std::enable_if<missingTraits<T, EmptyContext>::value, void>::type
+std::enable_if_t<missingTraits<T, EmptyContext>::value, void>
 yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) {
   char missing_yaml_trait_for_type[sizeof(MissingTrait<T>)];
 }
 
 template <typename T, typename Context>
-typename std::enable_if<has_SequenceTraits<T>::value, void>::type
+std::enable_if_t<has_SequenceTraits<T>::value, void>
 yamlize(IO &io, T &Seq, bool, Context &Ctx) {
   if ( has_FlowTraits< SequenceTraits<T>>::value ) {
     unsigned incnt = io.beginFlowSequence();
@@ -1246,10 +1235,9 @@
 // type.  This way endian aware types are supported whenever the traits are
 // defined for the underlying type.
 template <typename value_type, support::endianness endian, size_t alignment>
-struct ScalarTraits<
-    support::detail::packed_endian_specific_integral<value_type, endian,
-                                                     alignment>,
-    typename std::enable_if<has_ScalarTraits<value_type>::value>::type> {
+struct ScalarTraits<support::detail::packed_endian_specific_integral<
+                        value_type, endian, alignment>,
+                    std::enable_if_t<has_ScalarTraits<value_type>::value>> {
   using endian_type =
       support::detail::packed_endian_specific_integral<value_type, endian,
                                                        alignment>;
@@ -1274,8 +1262,7 @@
 struct ScalarEnumerationTraits<
     support::detail::packed_endian_specific_integral<value_type, endian,
                                                      alignment>,
-    typename std::enable_if<
-        has_ScalarEnumerationTraits<value_type>::value>::type> {
+    std::enable_if_t<has_ScalarEnumerationTraits<value_type>::value>> {
   using endian_type =
       support::detail::packed_endian_specific_integral<value_type, endian,
                                                        alignment>;
@@ -1291,7 +1278,7 @@
 struct ScalarBitSetTraits<
     support::detail::packed_endian_specific_integral<value_type, endian,
                                                      alignment>,
-    typename std::enable_if<has_ScalarBitSetTraits<value_type>::value>::type> {
+    std::enable_if_t<has_ScalarBitSetTraits<value_type>::value>> {
   using endian_type =
       support::detail::packed_endian_specific_integral<value_type, endian,
                                                        alignment>;
@@ -1402,7 +1389,7 @@
   std::error_code error();
 
 private:
-  bool outputting() override;
+  bool outputting() const override;
   bool mapTag(StringRef, bool) override;
   void beginMapping() override;
   void endMapping() override;
@@ -1487,9 +1474,10 @@
 
     static bool classof(const MapHNode *) { return true; }
 
-    using NameToNode = StringMap<std::unique_ptr<HNode>>;
+    using NameToNodeAndLoc =
+        StringMap<std::pair<std::unique_ptr<HNode>, SMRange>>;
 
-    NameToNode Mapping;
+    NameToNodeAndLoc Mapping;
     SmallVector<std::string, 6> ValidKeys;
   };
 
@@ -1511,6 +1499,11 @@
   std::unique_ptr<Input::HNode> createHNodes(Node *node);
   void setError(HNode *hnode, const Twine &message);
   void setError(Node *node, const Twine &message);
+  void setError(const SMRange &Range, const Twine &message);
+
+  void reportWarning(HNode *hnode, const Twine &message);
+  void reportWarning(Node *hnode, const Twine &message);
+  void reportWarning(const SMRange &Range, const Twine &message);
 
 public:
   // These are only used by operator>>. They could be private
@@ -1521,6 +1514,8 @@
   /// Returns the current node that's being parsed by the YAML Parser.
   const Node *getCurrentNode() const;
 
+  void setAllowUnknownKeys(bool Allow) override;
+
 private:
   SourceMgr                           SrcMgr; // must be before Strm
   std::unique_ptr<llvm::yaml::Stream> Strm;
@@ -1530,7 +1525,8 @@
   document_iterator                   DocIterator;
   std::vector<bool>                   BitValuesUsed;
   HNode *CurrentNode = nullptr;
-  bool                                ScalarMatchFound;
+  bool                                ScalarMatchFound = false;
+  bool AllowUnknownKeys = false;
 };
 
 ///
@@ -1549,7 +1545,7 @@
   /// anyway.
   void setWriteDefaultValues(bool Write) { WriteDefaultValues = Write; }
 
-  bool outputting() override;
+  bool outputting() const override;
   bool mapTag(StringRef, bool) override;
   void beginMapping() override;
   void endMapping() override;
@@ -1620,10 +1616,47 @@
   bool NeedBitValueComma = false;
   bool NeedFlowSequenceComma = false;
   bool EnumerationMatchFound = false;
-  bool NeedsNewLine = false;
   bool WriteDefaultValues = false;
+  StringRef Padding;
+  StringRef PaddingBeforeContainer;
 };
 
+template <typename T, typename Context>
+void IO::processKeyWithDefault(const char *Key, Optional<T> &Val,
+                               const Optional<T> &DefaultValue, bool Required,
+                               Context &Ctx) {
+  assert(DefaultValue.hasValue() == false &&
+         "Optional<T> shouldn't have a value!");
+  void *SaveInfo;
+  bool UseDefault = true;
+  const bool sameAsDefault = outputting() && !Val.hasValue();
+  if (!outputting() && !Val.hasValue())
+    Val = T();
+  if (Val.hasValue() &&
+      this->preflightKey(Key, Required, sameAsDefault, UseDefault, SaveInfo)) {
+
+    // When reading an Optional<X> key from a YAML description, we allow the
+    // special "<none>" value, which can be used to specify that no value was
+    // requested, i.e. the DefaultValue will be assigned. The DefaultValue is
+    // usually None.
+    bool IsNone = false;
+    if (!outputting())
+      if (auto *Node = dyn_cast<ScalarNode>(((Input *)this)->getCurrentNode()))
+        // We use rtrim to ignore possible white spaces that might exist when a
+        // comment is present on the same line.
+        IsNone = Node->getRawValue().rtrim(' ') == "<none>";
+
+    if (IsNone)
+      Val = DefaultValue;
+    else
+      yamlize(*this, Val.getValue(), Required, Ctx);
+    this->postflightKey(SaveInfo);
+  } else {
+    if (UseDefault)
+      Val = DefaultValue;
+  }
+}
+
 /// YAML I/O does conversion based on types. But often native data types
 /// are just a typedef of built in intergral types (e.g. int).  But the C++
 /// type matching system sees through the typedef and all the typedefed types
@@ -1684,10 +1717,15 @@
   static QuotingType mustQuote(StringRef) { return QuotingType::None; }
 };
 
+template <> struct ScalarTraits<VersionTuple> {
+  static void output(const VersionTuple &Value, void *, llvm::raw_ostream &Out);
+  static StringRef input(StringRef, void *, VersionTuple &);
+  static QuotingType mustQuote(StringRef) { return QuotingType::None; }
+};
+
 // Define non-member operator>> so that Input can stream in a document list.
 template <typename T>
-inline
-typename std::enable_if<has_DocumentListTraits<T>::value, Input &>::type
+inline std::enable_if_t<has_DocumentListTraits<T>::value, Input &>
 operator>>(Input &yin, T &docList) {
   int i = 0;
   EmptyContext Ctx;
@@ -1703,8 +1741,7 @@
 
 // Define non-member operator>> so that Input can stream in a map as a document.
 template <typename T>
-inline typename std::enable_if<has_MappingTraits<T, EmptyContext>::value,
-                               Input &>::type
+inline std::enable_if_t<has_MappingTraits<T, EmptyContext>::value, Input &>
 operator>>(Input &yin, T &docMap) {
   EmptyContext Ctx;
   yin.setCurrentDocument();
@@ -1715,8 +1752,7 @@
 // Define non-member operator>> so that Input can stream in a sequence as
 // a document.
 template <typename T>
-inline
-typename std::enable_if<has_SequenceTraits<T>::value, Input &>::type
+inline std::enable_if_t<has_SequenceTraits<T>::value, Input &>
 operator>>(Input &yin, T &docSeq) {
   EmptyContext Ctx;
   if (yin.setCurrentDocument())
@@ -1726,8 +1762,7 @@
 
 // Define non-member operator>> so that Input can stream in a block scalar.
 template <typename T>
-inline
-typename std::enable_if<has_BlockScalarTraits<T>::value, Input &>::type
+inline std::enable_if_t<has_BlockScalarTraits<T>::value, Input &>
 operator>>(Input &In, T &Val) {
   EmptyContext Ctx;
   if (In.setCurrentDocument())
@@ -1737,8 +1772,7 @@
 
 // Define non-member operator>> so that Input can stream in a string map.
 template <typename T>
-inline
-typename std::enable_if<has_CustomMappingTraits<T>::value, Input &>::type
+inline std::enable_if_t<has_CustomMappingTraits<T>::value, Input &>
 operator>>(Input &In, T &Val) {
   EmptyContext Ctx;
   if (In.setCurrentDocument())
@@ -1748,7 +1782,7 @@
 
 // Define non-member operator>> so that Input can stream in a polymorphic type.
 template <typename T>
-inline typename std::enable_if<has_PolymorphicTraits<T>::value, Input &>::type
+inline std::enable_if_t<has_PolymorphicTraits<T>::value, Input &>
 operator>>(Input &In, T &Val) {
   EmptyContext Ctx;
   if (In.setCurrentDocument())
@@ -1758,8 +1792,7 @@
 
 // Provide better error message about types missing a trait specialization
 template <typename T>
-inline typename std::enable_if<missingTraits<T, EmptyContext>::value,
-                               Input &>::type
+inline std::enable_if_t<missingTraits<T, EmptyContext>::value, Input &>
 operator>>(Input &yin, T &docSeq) {
   char missing_yaml_trait_for_type[sizeof(MissingTrait<T>)];
   return yin;
@@ -1767,8 +1800,7 @@
 
 // Define non-member operator<< so that Output can stream out document list.
 template <typename T>
-inline
-typename std::enable_if<has_DocumentListTraits<T>::value, Output &>::type
+inline std::enable_if_t<has_DocumentListTraits<T>::value, Output &>
 operator<<(Output &yout, T &docList) {
   EmptyContext Ctx;
   yout.beginDocuments();
@@ -1786,8 +1818,7 @@
 
 // Define non-member operator<< so that Output can stream out a map.
 template <typename T>
-inline typename std::enable_if<has_MappingTraits<T, EmptyContext>::value,
-                               Output &>::type
+inline std::enable_if_t<has_MappingTraits<T, EmptyContext>::value, Output &>
 operator<<(Output &yout, T &map) {
   EmptyContext Ctx;
   yout.beginDocuments();
@@ -1801,8 +1832,7 @@
 
 // Define non-member operator<< so that Output can stream out a sequence.
 template <typename T>
-inline
-typename std::enable_if<has_SequenceTraits<T>::value, Output &>::type
+inline std::enable_if_t<has_SequenceTraits<T>::value, Output &>
 operator<<(Output &yout, T &seq) {
   EmptyContext Ctx;
   yout.beginDocuments();
@@ -1816,8 +1846,7 @@
 
 // Define non-member operator<< so that Output can stream out a block scalar.
 template <typename T>
-inline
-typename std::enable_if<has_BlockScalarTraits<T>::value, Output &>::type
+inline std::enable_if_t<has_BlockScalarTraits<T>::value, Output &>
 operator<<(Output &Out, T &Val) {
   EmptyContext Ctx;
   Out.beginDocuments();
@@ -1831,8 +1860,7 @@
 
 // Define non-member operator<< so that Output can stream out a string map.
 template <typename T>
-inline
-typename std::enable_if<has_CustomMappingTraits<T>::value, Output &>::type
+inline std::enable_if_t<has_CustomMappingTraits<T>::value, Output &>
 operator<<(Output &Out, T &Val) {
   EmptyContext Ctx;
   Out.beginDocuments();
@@ -1847,7 +1875,7 @@
 // Define non-member operator<< so that Output can stream out a polymorphic
 // type.
 template <typename T>
-inline typename std::enable_if<has_PolymorphicTraits<T>::value, Output &>::type
+inline std::enable_if_t<has_PolymorphicTraits<T>::value, Output &>
 operator<<(Output &Out, T &Val) {
   EmptyContext Ctx;
   Out.beginDocuments();
@@ -1864,8 +1892,7 @@
 
 // Provide better error message about types missing a trait specialization
 template <typename T>
-inline typename std::enable_if<missingTraits<T, EmptyContext>::value,
-                               Output &>::type
+inline std::enable_if_t<missingTraits<T, EmptyContext>::value, Output &>
 operator<<(Output &yout, T &seq) {
   char missing_yaml_trait_for_type[sizeof(MissingTrait<T>)];
   return yout;
@@ -1896,25 +1923,25 @@
 // If T has SequenceElementTraits, then vector<T> and SmallVector<T, N> have
 // SequenceTraits that do the obvious thing.
 template <typename T>
-struct SequenceTraits<std::vector<T>,
-                      typename std::enable_if<CheckIsBool<
-                          SequenceElementTraits<T>::flow>::value>::type>
+struct SequenceTraits<
+    std::vector<T>,
+    std::enable_if_t<CheckIsBool<SequenceElementTraits<T>::flow>::value>>
     : SequenceTraitsImpl<std::vector<T>, SequenceElementTraits<T>::flow> {};
 template <typename T, unsigned N>
-struct SequenceTraits<SmallVector<T, N>,
-                      typename std::enable_if<CheckIsBool<
-                          SequenceElementTraits<T>::flow>::value>::type>
+struct SequenceTraits<
+    SmallVector<T, N>,
+    std::enable_if_t<CheckIsBool<SequenceElementTraits<T>::flow>::value>>
     : SequenceTraitsImpl<SmallVector<T, N>, SequenceElementTraits<T>::flow> {};
 template <typename T>
-struct SequenceTraits<SmallVectorImpl<T>,
-                      typename std::enable_if<CheckIsBool<
-                          SequenceElementTraits<T>::flow>::value>::type>
+struct SequenceTraits<
+    SmallVectorImpl<T>,
+    std::enable_if_t<CheckIsBool<SequenceElementTraits<T>::flow>::value>>
     : SequenceTraitsImpl<SmallVectorImpl<T>, SequenceElementTraits<T>::flow> {};
 
 // Sequences of fundamental types use flow formatting.
 template <typename T>
-struct SequenceElementTraits<
-    T, typename std::enable_if<std::is_fundamental<T>::value>::type> {
+struct SequenceElementTraits<T,
+                             std::enable_if_t<std::is_fundamental<T>::value>> {
   static const bool flow = true;
 };
 
@@ -1934,7 +1961,7 @@
   using map_type = std::map<std::string, T>;
 
   static void inputOne(IO &io, StringRef key, map_type &v) {
-    io.mapRequired(key.str().c_str(), v[key]);
+    io.mapRequired(key.str().c_str(), v[std::string(key)]);
   }
 
   static void output(IO &io, map_type &v) {
@@ -2033,4 +2060,9 @@
   }                                                                            \
   }
 
+LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(llvm::yaml::Hex64)
+LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(llvm::yaml::Hex32)
+LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(llvm::yaml::Hex16)
+LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(llvm::yaml::Hex8)
+
 #endif // LLVM_SUPPORT_YAMLTRAITS_H
diff --git a/linux-x64/clang/include/llvm/Support/circular_raw_ostream.h b/linux-x64/clang/include/llvm/Support/circular_raw_ostream.h
index 4ecdb17..d2f01ea 100644
--- a/linux-x64/clang/include/llvm/Support/circular_raw_ostream.h
+++ b/linux-x64/clang/include/llvm/Support/circular_raw_ostream.h
@@ -27,12 +27,12 @@
     /// stream and is responsible for cleanup, memory management
     /// issues, etc.
     ///
-    static const bool TAKE_OWNERSHIP = true;
+    static constexpr bool TAKE_OWNERSHIP = true;
 
     /// REFERENCE_ONLY - Tell this stream it should not manage the
     /// held stream.
     ///
-    static const bool REFERENCE_ONLY = false;
+    static constexpr bool REFERENCE_ONLY = false;
 
   private:
     /// TheStream - The real stream we output to. We set it to be
@@ -122,6 +122,10 @@
       delete[] BufferArray;
     }
 
+    bool is_displayed() const override {
+      return TheStream->is_displayed();
+    }
+
     /// setStream - Tell the circular_raw_ostream to output a
     /// different stream.  "Owns" tells circular_raw_ostream whether
     /// it should take responsibility for managing the underlying
diff --git a/linux-x64/clang/include/llvm/Support/raw_ostream.h b/linux-x64/clang/include/llvm/Support/raw_ostream.h
index 48bb623..bd15f97 100644
--- a/linux-x64/clang/include/llvm/Support/raw_ostream.h
+++ b/linux-x64/clang/include/llvm/Support/raw_ostream.h
@@ -15,12 +15,15 @@
 
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/Support/DataTypes.h"
 #include <cassert>
+#include <chrono>
 #include <cstddef>
 #include <cstdint>
 #include <cstring>
 #include <string>
 #include <system_error>
+#include <type_traits>
 
 namespace llvm {
 
@@ -29,12 +32,14 @@
 class FormattedString;
 class FormattedNumber;
 class FormattedBytes;
+template <class T> class LLVM_NODISCARD Expected;
 
 namespace sys {
 namespace fs {
 enum FileAccess : unsigned;
 enum OpenFlags : unsigned;
 enum CreationDisposition : unsigned;
+class FileLocker;
 } // end namespace fs
 } // end namespace sys
 
@@ -43,7 +48,16 @@
 /// buffered disciplines etc. It is a simple buffer that outputs
 /// a chunk at a time.
 class raw_ostream {
+public:
+  // Class kinds to support LLVM-style RTTI.
+  enum class OStreamKind {
+    OK_OStream,
+    OK_FDStream,
+  };
+
 private:
+  OStreamKind Kind;
+
   /// The buffer is handled in such a way that the buffer is
   /// uninitialized, unbuffered, or out of space when OutBufCur >=
   /// OutBufEnd. Thus a single comparison suffices to determine if we
@@ -63,8 +77,13 @@
   /// for a \see write_impl() call to handle the data which has been put into
   /// this buffer.
   char *OutBufStart, *OutBufEnd, *OutBufCur;
+  bool ColorEnabled = false;
 
-  enum BufferKind {
+  /// Optional stream this stream is tied to. If this stream is written to, the
+  /// tied-to stream will be flushed first.
+  raw_ostream *TiedStream = nullptr;
+
+  enum class BufferKind {
     Unbuffered = 0,
     InternalBuffer,
     ExternalBuffer
@@ -72,7 +91,7 @@
 
 public:
   // color order matches ANSI escape sequence, don't change
-  enum Colors {
+  enum class Colors {
     BLACK = 0,
     RED,
     GREEN,
@@ -81,11 +100,25 @@
     MAGENTA,
     CYAN,
     WHITE,
-    SAVEDCOLOR
+    SAVEDCOLOR,
+    RESET,
   };
 
-  explicit raw_ostream(bool unbuffered = false)
-      : BufferMode(unbuffered ? Unbuffered : InternalBuffer) {
+  static constexpr Colors BLACK = Colors::BLACK;
+  static constexpr Colors RED = Colors::RED;
+  static constexpr Colors GREEN = Colors::GREEN;
+  static constexpr Colors YELLOW = Colors::YELLOW;
+  static constexpr Colors BLUE = Colors::BLUE;
+  static constexpr Colors MAGENTA = Colors::MAGENTA;
+  static constexpr Colors CYAN = Colors::CYAN;
+  static constexpr Colors WHITE = Colors::WHITE;
+  static constexpr Colors SAVEDCOLOR = Colors::SAVEDCOLOR;
+  static constexpr Colors RESET = Colors::RESET;
+
+  explicit raw_ostream(bool unbuffered = false,
+                       OStreamKind K = OStreamKind::OK_OStream)
+      : Kind(K), BufferMode(unbuffered ? BufferKind::Unbuffered
+                                       : BufferKind::InternalBuffer) {
     // Start out ready to flush.
     OutBufStart = OutBufEnd = OutBufCur = nullptr;
   }
@@ -98,6 +131,8 @@
   /// tell - Return the current offset with the file.
   uint64_t tell() const { return current_pos() + GetNumBytesInBuffer(); }
 
+  OStreamKind get_kind() const { return Kind; }
+
   //===--------------------------------------------------------------------===//
   // Configuration Interface
   //===--------------------------------------------------------------------===//
@@ -109,13 +144,13 @@
   /// Set the stream to be buffered, using the specified buffer size.
   void SetBufferSize(size_t Size) {
     flush();
-    SetBufferAndMode(new char[Size], Size, InternalBuffer);
+    SetBufferAndMode(new char[Size], Size, BufferKind::InternalBuffer);
   }
 
   size_t GetBufferSize() const {
     // If we're supposed to be buffered but haven't actually gotten around
     // to allocating the buffer yet, return the value that would be used.
-    if (BufferMode != Unbuffered && OutBufStart == nullptr)
+    if (BufferMode != BufferKind::Unbuffered && OutBufStart == nullptr)
       return preferred_buffer_size();
 
     // Otherwise just return the size of the allocated buffer.
@@ -127,7 +162,7 @@
   /// when the stream is being set to unbuffered.
   void SetUnbuffered() {
     flush();
-    SetBufferAndMode(nullptr, 0, Unbuffered);
+    SetBufferAndMode(nullptr, 0, BufferKind::Unbuffered);
   }
 
   size_t GetNumBytesInBuffer() const {
@@ -214,6 +249,9 @@
   /// Output \p N in hexadecimal, without any prefix or padding.
   raw_ostream &write_hex(unsigned long long N);
 
+  // Change the foreground color of text.
+  raw_ostream &operator<<(Colors C);
+
   /// Output a formatted UUID with dash separators.
   using uuid_t = uint8_t[16];
   raw_ostream &write_uuid(const uuid_t UUID);
@@ -253,21 +291,15 @@
   /// @param Bold bold/brighter text, default false
   /// @param BG if true change the background, default: change foreground
   /// @returns itself so it can be used within << invocations
-  virtual raw_ostream &changeColor(enum Colors Color,
-                                   bool Bold = false,
-                                   bool BG = false) {
-    (void)Color;
-    (void)Bold;
-    (void)BG;
-    return *this;
-  }
+  virtual raw_ostream &changeColor(enum Colors Color, bool Bold = false,
+                                   bool BG = false);
 
   /// Resets the colors to terminal defaults. Call this when you are done
   /// outputting colored text, or before program exit.
-  virtual raw_ostream &resetColor() { return *this; }
+  virtual raw_ostream &resetColor();
 
   /// Reverses the foreground and background colors.
-  virtual raw_ostream &reverseColor() { return *this; }
+  virtual raw_ostream &reverseColor();
 
   /// This function determines if this stream is connected to a "tty" or
   /// "console" window. That is, the output would be displayed to the user
@@ -275,8 +307,17 @@
   virtual bool is_displayed() const { return false; }
 
   /// This function determines if this stream is displayed and supports colors.
+  /// The result is unaffected by calls to enable_color().
   virtual bool has_colors() const { return is_displayed(); }
 
+  // Enable or disable colors. Once enable_colors(false) is called,
+  // changeColor() has no effect until enable_colors(true) is called.
+  virtual void enable_colors(bool enable) { ColorEnabled = enable; }
+
+  /// Tie this stream to the specified stream. Replaces any existing tied-to
+  /// stream. Specifying a nullptr unties the stream.
+  void tie(raw_ostream *TieTo) { TiedStream = TieTo; }
+
   //===--------------------------------------------------------------------===//
   // Subclass Interface
   //===--------------------------------------------------------------------===//
@@ -306,7 +347,7 @@
   /// use only by subclasses which can arrange for the output to go directly
   /// into the desired output buffer, instead of being copied on each flush.
   void SetBuffer(char *BufferStart, size_t Size) {
-    SetBufferAndMode(BufferStart, Size, ExternalBuffer);
+    SetBufferAndMode(BufferStart, Size, BufferKind::ExternalBuffer);
   }
 
   /// Return an efficient buffer size for the underlying output mechanism.
@@ -331,9 +372,27 @@
   /// unused bytes in the buffer.
   void copy_to_buffer(const char *Ptr, size_t Size);
 
+  /// Compute whether colors should be used and do the necessary work such as
+  /// flushing. The result is affected by calls to enable_color().
+  bool prepare_colors();
+
+  /// Flush the tied-to stream (if present) and then write the required data.
+  void flush_tied_then_write(const char *Ptr, size_t Size);
+
   virtual void anchor();
 };
 
+/// Call the appropriate insertion operator, given an rvalue reference to a
+/// raw_ostream object and return a stream of the same type as the argument.
+template <typename OStream, typename T>
+std::enable_if_t<!std::is_reference<OStream>::value &&
+                     std::is_base_of<raw_ostream, OStream>::value,
+                 OStream &&>
+operator<<(OStream &&OS, const T &Value) {
+  OS << Value;
+  return std::move(OS);
+}
+
 /// An abstract base class for streams implementations that also support a
 /// pwrite operation. This is useful for code that can mostly stream out data,
 /// but needs to patch in a header that needs to know the output size.
@@ -342,8 +401,9 @@
   void anchor() override;
 
 public:
-  explicit raw_pwrite_stream(bool Unbuffered = false)
-      : raw_ostream(Unbuffered) {}
+  explicit raw_pwrite_stream(bool Unbuffered = false,
+                             OStreamKind K = OStreamKind::OK_OStream)
+      : raw_ostream(Unbuffered, K) {}
   void pwrite(const char *Ptr, size_t Size, uint64_t Offset) {
 #ifndef NDEBUG
     uint64_t Pos = tell();
@@ -365,8 +425,8 @@
 class raw_fd_ostream : public raw_pwrite_stream {
   int FD;
   bool ShouldClose;
-
-  bool SupportsSeeking;
+  bool SupportsSeeking = false;
+  mutable Optional<bool> HasColors;
 
 #ifdef _WIN32
   /// True if this fd refers to a Windows console device. Mintty and other
@@ -376,7 +436,7 @@
 
   std::error_code EC;
 
-  uint64_t pos;
+  uint64_t pos = 0;
 
   /// See raw_ostream::write_impl.
   void write_impl(const char *Ptr, size_t Size) override;
@@ -390,10 +450,17 @@
   /// Determine an efficient buffer size.
   size_t preferred_buffer_size() const override;
 
+  void anchor() override;
+
+protected:
   /// Set the flag indicating that an output error has been encountered.
   void error_detected(std::error_code EC) { this->EC = EC; }
 
-  void anchor() override;
+  /// Return the file descriptor.
+  int get_fd() const { return FD; }
+
+  // Update the file position by increasing \p Delta.
+  void inc_pos(uint64_t Delta) { pos += Delta; }
 
 public:
   /// Open the specified file for writing. If an error occurs, information
@@ -418,7 +485,8 @@
   /// FD is the file descriptor that this writes to.  If ShouldClose is true,
   /// this closes the file when the stream is destroyed. If FD is for stdout or
   /// stderr, it will not be closed.
-  raw_fd_ostream(int fd, bool shouldClose, bool unbuffered=false);
+  raw_fd_ostream(int fd, bool shouldClose, bool unbuffered = false,
+                 OStreamKind K = OStreamKind::OK_OStream);
 
   ~raw_fd_ostream() override;
 
@@ -426,18 +494,12 @@
   /// fsync.
   void close();
 
-  bool supportsSeeking() { return SupportsSeeking; }
+  bool supportsSeeking() const { return SupportsSeeking; }
 
   /// Flushes the stream and repositions the underlying file descriptor position
   /// to the offset specified from the beginning of the file.
   uint64_t seek(uint64_t off);
 
-  raw_ostream &changeColor(enum Colors colors, bool bold=false,
-                           bool bg=false) override;
-  raw_ostream &resetColor() override;
-
-  raw_ostream &reverseColor() override;
-
   bool is_displayed() const override;
 
   bool has_colors() const override;
@@ -460,20 +522,83 @@
   ///      - from The Zen of Python, by Tim Peters
   ///
   void clear_error() { EC = std::error_code(); }
+
+  /// Locks the underlying file.
+  ///
+  /// @returns RAII object that releases the lock upon leaving the scope, if the
+  ///          locking was successful. Otherwise returns corresponding
+  ///          error code.
+  ///
+  /// The function blocks the current thread until the lock become available or
+  /// error occurs.
+  ///
+  /// Possible use of this function may be as follows:
+  ///
+  ///   @code{.cpp}
+  ///   if (auto L = stream.lock()) {
+  ///     // ... do action that require file to be locked.
+  ///   } else {
+  ///     handleAllErrors(std::move(L.takeError()), [&](ErrorInfoBase &EIB) {
+  ///       // ... handle lock error.
+  ///     });
+  ///   }
+  ///   @endcode
+  LLVM_NODISCARD Expected<sys::fs::FileLocker> lock();
+
+  /// Tries to lock the underlying file within the specified period.
+  ///
+  /// @returns RAII object that releases the lock upon leaving the scope, if the
+  ///          locking was successful. Otherwise returns corresponding
+  ///          error code.
+  ///
+  /// It is used as @ref lock.
+  LLVM_NODISCARD
+  Expected<sys::fs::FileLocker> tryLockFor(std::chrono::milliseconds Timeout);
 };
 
-/// This returns a reference to a raw_ostream for standard output. Use it like:
-/// outs() << "foo" << "bar";
-raw_ostream &outs();
+/// This returns a reference to a raw_fd_ostream for standard output. Use it
+/// like: outs() << "foo" << "bar";
+raw_fd_ostream &outs();
 
-/// This returns a reference to a raw_ostream for standard error. Use it like:
-/// errs() << "foo" << "bar";
-raw_ostream &errs();
+/// This returns a reference to a raw_ostream for standard error.
+/// Use it like: errs() << "foo" << "bar";
+/// By default, the stream is tied to stdout to ensure stdout is flushed before
+/// stderr is written, to ensure the error messages are written in their
+/// expected place.
+raw_fd_ostream &errs();
 
 /// This returns a reference to a raw_ostream which simply discards output.
 raw_ostream &nulls();
 
 //===----------------------------------------------------------------------===//
+// File Streams
+//===----------------------------------------------------------------------===//
+
+/// A raw_ostream of a file for reading/writing/seeking.
+///
+class raw_fd_stream : public raw_fd_ostream {
+public:
+  /// Open the specified file for reading/writing/seeking. If an error occurs,
+  /// information about the error is put into EC, and the stream should be
+  /// immediately destroyed.
+  raw_fd_stream(StringRef Filename, std::error_code &EC);
+
+  /// This reads the \p Size bytes into a buffer pointed by \p Ptr.
+  ///
+  /// \param Ptr The start of the buffer to hold data to be read.
+  ///
+  /// \param Size The number of bytes to be read.
+  ///
+  /// On success, the number of bytes read is returned, and the file position is
+  /// advanced by this number. On error, -1 is returned, use error() to get the
+  /// error code.
+  ssize_t read(char *Ptr, size_t Size);
+
+  /// Check if \p OS is a pointer of type raw_fd_stream*.
+  static bool classof(const raw_ostream *OS);
+};
+
+//===----------------------------------------------------------------------===//
 // Output Stream Adaptors
 //===----------------------------------------------------------------------===//
 
@@ -490,7 +615,9 @@
   uint64_t current_pos() const override { return OS.size(); }
 
 public:
-  explicit raw_string_ostream(std::string &O) : OS(O) {}
+  explicit raw_string_ostream(std::string &O) : OS(O) {
+    SetUnbuffered();
+  }
   ~raw_string_ostream() override;
 
   /// Flushes the stream contents to the target string and returns  the string's
@@ -531,7 +658,7 @@
   void flush() = delete;
 
   /// Return a StringRef for the vector contents.
-  StringRef str() { return StringRef(OS.data(), OS.size()); }
+  StringRef str() const { return StringRef(OS.data(), OS.size()); }
 };
 
 /// A raw_ostream that discards all output.
diff --git a/linux-x64/clang/include/llvm/Support/type_traits.h b/linux-x64/clang/include/llvm/Support/type_traits.h
index c8c6a76..7b7d5d9 100644
--- a/linux-x64/clang/include/llvm/Support/type_traits.h
+++ b/linux-x64/clang/include/llvm/Support/type_traits.h
@@ -17,11 +17,6 @@
 #include <type_traits>
 #include <utility>
 
-#ifndef __has_feature
-#define LLVM_DEFINED_HAS_FEATURE
-#define __has_feature(x) 0
-#endif
-
 namespace llvm {
 
 
@@ -33,7 +28,7 @@
 /// Also note that enum classes aren't implicitly convertible to integral types,
 /// the value may therefore need to be explicitly converted before being used.
 template <typename T> class is_integral_or_enum {
-  using UnderlyingT = typename std::remove_reference<T>::type;
+  using UnderlyingT = std::remove_reference_t<T>;
 
 public:
   static const bool value =
@@ -50,7 +45,7 @@
 
 template <typename T>
 struct add_lvalue_reference_if_not_pointer<
-    T, typename std::enable_if<std::is_pointer<T>::value>::type> {
+    T, std::enable_if_t<std::is_pointer<T>::value>> {
   using type = T;
 };
 
@@ -60,9 +55,8 @@
 struct add_const_past_pointer { using type = const T; };
 
 template <typename T>
-struct add_const_past_pointer<
-    T, typename std::enable_if<std::is_pointer<T>::value>::type> {
-  using type = const typename std::remove_pointer<T>::type *;
+struct add_const_past_pointer<T, std::enable_if_t<std::is_pointer<T>::value>> {
+  using type = const std::remove_pointer_t<T> *;
 };
 
 template <typename T, typename Enable = void>
@@ -70,8 +64,8 @@
   using type = const T &;
 };
 template <typename T>
-struct const_pointer_or_const_ref<
-    T, typename std::enable_if<std::is_pointer<T>::value>::type> {
+struct const_pointer_or_const_ref<T,
+                                  std::enable_if_t<std::is_pointer<T>::value>> {
   using type = typename add_const_past_pointer<T>::type;
 };
 
@@ -194,17 +188,4 @@
 
 } // end namespace llvm
 
-// If the compiler supports detecting whether a class is final, define
-// an LLVM_IS_FINAL macro. If it cannot be defined properly, this
-// macro will be left undefined.
-#if __cplusplus >= 201402L || defined(_MSC_VER)
-#define LLVM_IS_FINAL(Ty) std::is_final<Ty>()
-#elif __has_feature(is_final) || LLVM_GNUC_PREREQ(4, 7, 0)
-#define LLVM_IS_FINAL(Ty) __is_final(Ty)
-#endif
-
-#ifdef LLVM_DEFINED_HAS_FEATURE
-#undef __has_feature
-#endif
-
 #endif // LLVM_SUPPORT_TYPE_TRAITS_H
diff --git a/linux-x64/clang/include/llvm/TableGen/Automaton.td b/linux-x64/clang/include/llvm/TableGen/Automaton.td
new file mode 100644
index 0000000..13ced2a
--- /dev/null
+++ b/linux-x64/clang/include/llvm/TableGen/Automaton.td
@@ -0,0 +1,95 @@
+//===- Automaton.td ----------------------------------------*- tablegen -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the key top-level classes needed to produce a reasonably
+// generic finite-state automaton.
+//
+//===----------------------------------------------------------------------===//
+
+// Define a record inheriting from GenericAutomaton to generate a reasonably
+// generic finite-state automaton over a set of actions and states.
+//
+// This automaton is defined by:
+//   1) a state space (explicit, always bits<32>).
+//   2) a set of input symbols (actions, explicit) and
+//   3) a transition function from state + action -> state.
+//
+// A theoretical automaton is defined by <Q, S, d, q0, F>:
+//   Q: A set of possible states.
+//   S: (sigma) The input alphabet.
+//   d: (delta) The transition function f(q in Q, s in S) -> q' in Q.
+//   F: The set of final (accepting) states.
+//
+// Because generating all possible states is tedious, we instead define the
+// transition function only and crawl all reachable states starting from the
+// initial state with all inputs under all transitions until termination.
+//
+// We define F = S, that is, all valid states are accepting.
+//
+// To ensure the generation of the automaton terminates, the state transitions
+// are defined as a lattice (meaning every transitioned-to state is more
+// specific than the transitioned-from state, for some definition of specificity).
+// Concretely a transition may set one or more bits in the state that were
+// previously zero to one. If any bit was not zero, the transition is invalid.
+//
+// Instead of defining all possible states (which would be cumbersome), the user
+// provides a set of possible Transitions from state A, consuming an input
+// symbol A to state B. The Transition object transforms state A to state B and
+// acts as a predicate. This means the state space can be discovered by crawling
+// all the possible transitions until none are valid.
+//
+// This automaton is considered to be nondeterministic, meaning that multiple
+// transitions can occur from any (state, action) pair. The generated automaton
+// is determinized, meaning that is executes in O(k) time where k is the input
+// sequence length.
+//
+// In addition to a generated automaton that determines if a sequence of inputs
+// is accepted or not, a table is emitted that allows determining a plausible
+// sequence of states traversed to accept that input.
+class GenericAutomaton {
+  // Name of a class that inherits from Transition. All records inheriting from
+  // this class will be considered when constructing the automaton.
+  string TransitionClass;
+
+  // Names of fields within TransitionClass that define the action symbol. This
+  // defines the action as an N-tuple.
+  //
+  // Each symbol field can be of class, int, string or code type.
+  //   If the type of a field is a class, the Record's name is used verbatim
+  //     in C++ and the class name is used as the C++ type name.
+  //   If the type of a field is a string, code or int, that is also used
+  //     verbatim in C++.
+  //
+  // To override the C++ type name for field F, define a field called TypeOf_F.
+  // This should be a string that will be used verbatim in C++.
+  //
+  // As an example, to define a 2-tuple with an enum and a string, one might:
+  //   def MyTransition : Transition {
+  //     MyEnum S1;
+  //     int S2;
+  //   }
+  //   def MyAutomaton : GenericAutomaton }{
+  //     let TransitionClass = "Transition";
+  //     let SymbolFields = ["S1", "S2"];
+  //     let TypeOf_S1 = "MyEnumInCxxKind";
+  //   }
+  list<string> SymbolFields;
+}
+
+// All transitions inherit from Transition.
+class Transition {
+  // A transition S' = T(S) is valid if, for every set bit in NewState, the
+  // corresponding bit in S is clear. That is:
+  //   def T(S):
+  //     S' = S | NewState
+  //     return S' if S' != S else Failure
+  //
+  // The automaton generator uses this property to crawl the set of possible
+  // transitions from a starting state of 0b0.
+  bits<32> NewState;
+}
diff --git a/linux-x64/clang/include/llvm/TableGen/DirectiveEmitter.h b/linux-x64/clang/include/llvm/TableGen/DirectiveEmitter.h
new file mode 100644
index 0000000..41258ad
--- /dev/null
+++ b/linux-x64/clang/include/llvm/TableGen/DirectiveEmitter.h
@@ -0,0 +1,216 @@
+#ifndef LLVM_TABLEGEN_DIRECTIVEEMITTER_H
+#define LLVM_TABLEGEN_DIRECTIVEEMITTER_H
+
+#include "llvm/ADT/StringExtras.h"
+#include "llvm/TableGen/Record.h"
+
+namespace llvm {
+
+// Wrapper class that contains DirectiveLanguage's information defined in
+// DirectiveBase.td and provides helper methods for accessing it.
+class DirectiveLanguage {
+public:
+  explicit DirectiveLanguage(const llvm::RecordKeeper &Records)
+      : Records(Records) {
+    const auto &DirectiveLanguages = getDirectiveLanguages();
+    Def = DirectiveLanguages[0];
+  }
+
+  StringRef getName() const { return Def->getValueAsString("name"); }
+
+  StringRef getCppNamespace() const {
+    return Def->getValueAsString("cppNamespace");
+  }
+
+  StringRef getDirectivePrefix() const {
+    return Def->getValueAsString("directivePrefix");
+  }
+
+  StringRef getClausePrefix() const {
+    return Def->getValueAsString("clausePrefix");
+  }
+
+  StringRef getIncludeHeader() const {
+    return Def->getValueAsString("includeHeader");
+  }
+
+  StringRef getClauseEnumSetClass() const {
+    return Def->getValueAsString("clauseEnumSetClass");
+  }
+
+  StringRef getFlangClauseBaseClass() const {
+    return Def->getValueAsString("flangClauseBaseClass");
+  }
+
+  bool hasMakeEnumAvailableInNamespace() const {
+    return Def->getValueAsBit("makeEnumAvailableInNamespace");
+  }
+
+  bool hasEnableBitmaskEnumInNamespace() const {
+    return Def->getValueAsBit("enableBitmaskEnumInNamespace");
+  }
+
+  const std::vector<Record *> getDirectives() const {
+    return Records.getAllDerivedDefinitions("Directive");
+  }
+
+  const std::vector<Record *> getClauses() const {
+    return Records.getAllDerivedDefinitions("Clause");
+  }
+
+  bool HasValidityErrors() const;
+
+private:
+  const llvm::Record *Def;
+  const llvm::RecordKeeper &Records;
+
+  const std::vector<Record *> getDirectiveLanguages() const {
+    return Records.getAllDerivedDefinitions("DirectiveLanguage");
+  }
+};
+
+// Base record class used for Directive and Clause class defined in
+// DirectiveBase.td.
+class BaseRecord {
+public:
+  explicit BaseRecord(const llvm::Record *Def) : Def(Def) {}
+
+  StringRef getName() const { return Def->getValueAsString("name"); }
+
+  StringRef getAlternativeName() const {
+    return Def->getValueAsString("alternativeName");
+  }
+
+  // Returns the name of the directive formatted for output. Whitespace are
+  // replaced with underscores.
+  std::string getFormattedName() {
+    StringRef Name = Def->getValueAsString("name");
+    std::string N = Name.str();
+    std::replace(N.begin(), N.end(), ' ', '_');
+    return N;
+  }
+
+  bool isDefault() const { return Def->getValueAsBit("isDefault"); }
+
+  // Returns the record name.
+  const StringRef getRecordName() const { return Def->getName(); }
+
+protected:
+  const llvm::Record *Def;
+};
+
+// Wrapper class that contains a Directive's information defined in
+// DirectiveBase.td and provides helper methods for accessing it.
+class Directive : public BaseRecord {
+public:
+  explicit Directive(const llvm::Record *Def) : BaseRecord(Def) {}
+
+  std::vector<Record *> getAllowedClauses() const {
+    return Def->getValueAsListOfDefs("allowedClauses");
+  }
+
+  std::vector<Record *> getAllowedOnceClauses() const {
+    return Def->getValueAsListOfDefs("allowedOnceClauses");
+  }
+
+  std::vector<Record *> getAllowedExclusiveClauses() const {
+    return Def->getValueAsListOfDefs("allowedExclusiveClauses");
+  }
+
+  std::vector<Record *> getRequiredClauses() const {
+    return Def->getValueAsListOfDefs("requiredClauses");
+  }
+};
+
+// Wrapper class that contains Clause's information defined in DirectiveBase.td
+// and provides helper methods for accessing it.
+class Clause : public BaseRecord {
+public:
+  explicit Clause(const llvm::Record *Def) : BaseRecord(Def) {}
+
+  // Optional field.
+  StringRef getClangClass() const {
+    return Def->getValueAsString("clangClass");
+  }
+
+  // Optional field.
+  StringRef getFlangClass() const {
+    return Def->getValueAsString("flangClass");
+  }
+
+  // Optional field.
+  StringRef getFlangClassValue() const {
+    return Def->getValueAsString("flangClassValue");
+  }
+
+  // Get the formatted name for Flang parser class. The generic formatted class
+  // name is constructed from the name were the first letter of each word is
+  // captitalized and the underscores are removed.
+  // ex: async -> Async
+  //     num_threads -> NumThreads
+  std::string getFormattedParserClassName() {
+    StringRef Name = Def->getValueAsString("name");
+    std::string N = Name.str();
+    bool Cap = true;
+    std::transform(N.begin(), N.end(), N.begin(), [&Cap](unsigned char C) {
+      if (Cap == true) {
+        C = llvm::toUpper(C);
+        Cap = false;
+      } else if (C == '_') {
+        Cap = true;
+      }
+      return C;
+    });
+    N.erase(std::remove(N.begin(), N.end(), '_'), N.end());
+    return N;
+  }
+
+  // Optional field.
+  StringRef getEnumName() const {
+    return Def->getValueAsString("enumClauseValue");
+  }
+
+  std::vector<Record *> getClauseVals() const {
+    return Def->getValueAsListOfDefs("allowedClauseValues");
+  }
+
+  bool isValueOptional() const { return Def->getValueAsBit("isValueOptional"); }
+
+  bool isValueList() const { return Def->getValueAsBit("isValueList"); }
+
+  StringRef getDefaultValue() const {
+    return Def->getValueAsString("defaultValue");
+  }
+
+  bool isImplicit() const { return Def->getValueAsBit("isImplicit"); }
+};
+
+// Wrapper class that contains VersionedClause's information defined in
+// DirectiveBase.td and provides helper methods for accessing it.
+class VersionedClause {
+public:
+  explicit VersionedClause(const llvm::Record *Def) : Def(Def) {}
+
+  // Return the specific clause record wrapped in the Clause class.
+  Clause getClause() const { return Clause{Def->getValueAsDef("clause")}; }
+
+  int64_t getMinVersion() const { return Def->getValueAsInt("minVersion"); }
+
+  int64_t getMaxVersion() const { return Def->getValueAsInt("maxVersion"); }
+
+private:
+  const llvm::Record *Def;
+};
+
+class ClauseVal : public BaseRecord {
+public:
+  explicit ClauseVal(const llvm::Record *Def) : BaseRecord(Def) {}
+
+  int getValue() const { return Def->getValueAsInt("value"); }
+
+  bool isUserVisible() const { return Def->getValueAsBit("isUserValue"); }
+};
+
+} // namespace llvm
+
+#endif
diff --git a/linux-x64/clang/include/llvm/TableGen/Error.h b/linux-x64/clang/include/llvm/TableGen/Error.h
index 7c83b62..f63b50a 100644
--- a/linux-x64/clang/include/llvm/TableGen/Error.h
+++ b/linux-x64/clang/include/llvm/TableGen/Error.h
@@ -15,22 +15,38 @@
 #define LLVM_TABLEGEN_ERROR_H
 
 #include "llvm/Support/SourceMgr.h"
+#include "llvm/TableGen/Record.h"
 
 namespace llvm {
 
+void PrintNote(const Twine &Msg);
 void PrintNote(ArrayRef<SMLoc> NoteLoc, const Twine &Msg);
 
+LLVM_ATTRIBUTE_NORETURN void PrintFatalNote(const Twine &Msg);
+LLVM_ATTRIBUTE_NORETURN void PrintFatalNote(ArrayRef<SMLoc> ErrorLoc,
+                                            const Twine &Msg);
+LLVM_ATTRIBUTE_NORETURN void PrintFatalNote(const Record *Rec,
+                                            const Twine &Msg);
+LLVM_ATTRIBUTE_NORETURN void PrintFatalNote(const RecordVal *RecVal,
+                                            const Twine &Msg);
+
+void PrintWarning(const Twine &Msg);
 void PrintWarning(ArrayRef<SMLoc> WarningLoc, const Twine &Msg);
 void PrintWarning(const char *Loc, const Twine &Msg);
-void PrintWarning(const Twine &Msg);
 
+void PrintError(const Twine &Msg);
 void PrintError(ArrayRef<SMLoc> ErrorLoc, const Twine &Msg);
 void PrintError(const char *Loc, const Twine &Msg);
-void PrintError(const Twine &Msg);
+void PrintError(const Record *Rec, const Twine &Msg);
+void PrintError(const RecordVal *RecVal, const Twine &Msg);
 
 LLVM_ATTRIBUTE_NORETURN void PrintFatalError(const Twine &Msg);
 LLVM_ATTRIBUTE_NORETURN void PrintFatalError(ArrayRef<SMLoc> ErrorLoc,
                                              const Twine &Msg);
+LLVM_ATTRIBUTE_NORETURN void PrintFatalError(const Record *Rec,
+                                             const Twine &Msg);
+LLVM_ATTRIBUTE_NORETURN void PrintFatalError(const RecordVal *RecVal,
+                                             const Twine &Msg);
 
 extern SourceMgr SrcMgr;
 extern unsigned ErrorsPrinted;
diff --git a/linux-x64/clang/include/llvm/TableGen/Main.h b/linux-x64/clang/include/llvm/TableGen/Main.h
index e464cd4..4e05da3 100644
--- a/linux-x64/clang/include/llvm/TableGen/Main.h
+++ b/linux-x64/clang/include/llvm/TableGen/Main.h
@@ -22,7 +22,7 @@
 /// Returns true on error, false otherwise.
 using TableGenMainFn = bool (raw_ostream &OS, RecordKeeper &Records);
 
-int TableGenMain(char *argv0, TableGenMainFn *MainFn);
+int TableGenMain(const char *argv0, TableGenMainFn *MainFn);
 
 } // end namespace llvm
 
diff --git a/linux-x64/clang/include/llvm/TableGen/Record.h b/linux-x64/clang/include/llvm/TableGen/Record.h
index bf7f022..2853a47 100644
--- a/linux-x64/clang/include/llvm/TableGen/Record.h
+++ b/linux-x64/clang/include/llvm/TableGen/Record.h
@@ -24,6 +24,7 @@
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/SMLoc.h"
+#include "llvm/Support/Timer.h"
 #include "llvm/Support/TrailingObjects.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
@@ -57,7 +58,6 @@
   enum RecTyKind {
     BitRecTyKind,
     BitsRecTyKind,
-    CodeRecTyKind,
     IntRecTyKind,
     StringRecTyKind,
     ListRecTyKind,
@@ -67,6 +67,7 @@
 
 private:
   RecTyKind Kind;
+  /// ListRecTy of the list that has elements of this type.
   ListRecTy *ListTy = nullptr;
 
 public:
@@ -87,7 +88,7 @@
   /// a bit set is not an int, but they are convertible.
   virtual bool typeIsA(const RecTy *RHS) const;
 
-  /// Returns the type representing list<this>.
+  /// Returns the type representing list<thistype>.
   ListRecTy *getListTy();
 };
 
@@ -136,24 +137,6 @@
   bool typeIsA(const RecTy *RHS) const override;
 };
 
-/// 'code' - Represent a code fragment
-class CodeRecTy : public RecTy {
-  static CodeRecTy Shared;
-
-  CodeRecTy() : RecTy(CodeRecTyKind) {}
-
-public:
-  static bool classof(const RecTy *RT) {
-    return RT->getRecTyKind() == CodeRecTyKind;
-  }
-
-  static CodeRecTy *get() { return &Shared; }
-
-  std::string getAsString() const override { return "code"; }
-
-  bool typeIsConvertibleTo(const RecTy *RHS) const override;
-};
-
 /// 'int' - Represent an integer value of no particular size
 class IntRecTy : public RecTy {
   static IntRecTy Shared;
@@ -190,14 +173,14 @@
   bool typeIsConvertibleTo(const RecTy *RHS) const override;
 };
 
-/// 'list<Ty>' - Represent a list of values, all of which must be of
-/// the specified type.
+/// 'list<Ty>' - Represent a list of element values, all of which must be of
+/// the specified type. The type is stored in ElementTy.
 class ListRecTy : public RecTy {
   friend ListRecTy *RecTy::getListTy();
 
-  RecTy *Ty;
+  RecTy *ElementTy;
 
-  explicit ListRecTy(RecTy *T) : RecTy(ListRecTyKind), Ty(T) {}
+  explicit ListRecTy(RecTy *T) : RecTy(ListRecTyKind), ElementTy(T) {}
 
 public:
   static bool classof(const RecTy *RT) {
@@ -205,7 +188,7 @@
   }
 
   static ListRecTy *get(RecTy *T) { return T->getListTy(); }
-  RecTy *getElementType() const { return Ty; }
+  RecTy *getElementType() const { return ElementTy; }
 
   std::string getAsString() const override;
 
@@ -304,7 +287,6 @@
     IK_FirstTypedInit,
     IK_BitInit,
     IK_BitsInit,
-    IK_CodeInit,
     IK_DagInit,
     IK_DefInit,
     IK_FieldInit,
@@ -337,6 +319,7 @@
   virtual void anchor();
 
 public:
+  /// Get the kind (type) of the value.
   InitKind getKind() const { return Kind; }
 
 protected:
@@ -347,63 +330,61 @@
   Init &operator=(const Init &) = delete;
   virtual ~Init() = default;
 
-  /// This virtual method should be overridden by values that may
-  /// not be completely specified yet.
+  /// Is this a complete value with no unset (uninitialized) subvalues?
   virtual bool isComplete() const { return true; }
 
   /// Is this a concrete and fully resolved value without any references or
   /// stuck operations? Unset values are concrete.
   virtual bool isConcrete() const { return false; }
 
-  /// Print out this value.
+  /// Print this value.
   void print(raw_ostream &OS) const { OS << getAsString(); }
 
-  /// Convert this value to a string form.
+  /// Convert this value to a literal form.
   virtual std::string getAsString() const = 0;
-  /// Convert this value to a string form,
-  /// without adding quote markers.  This primaruly affects
-  /// StringInits where we will not surround the string value with
-  /// quotes.
+
+  /// Convert this value to a literal form,
+  /// without adding quotes around a string.
   virtual std::string getAsUnquotedString() const { return getAsString(); }
 
-  /// Debugging method that may be called through a debugger, just
+  /// Debugging method that may be called through a debugger; just
   /// invokes print on stderr.
   void dump() const;
 
-  /// If this initializer is convertible to Ty, return an initializer whose
-  /// type is-a Ty, generating a !cast operation if required. Otherwise, return
-  /// nullptr.
+  /// If this value is convertible to type \p Ty, return a value whose
+  /// type is \p Ty, generating a !cast operation if required.
+  /// Otherwise, return null.
   virtual Init *getCastTo(RecTy *Ty) const = 0;
 
-  /// Convert to an initializer whose type is-a Ty, or return nullptr if this
-  /// is not possible (this can happen if the initializer's type is convertible
-  /// to Ty, but there are unresolved references).
+  /// Convert to a value whose type is \p Ty, or return null if this
+  /// is not possible. This can happen if the value's type is convertible
+  /// to \p Ty, but there are unresolved references.
   virtual Init *convertInitializerTo(RecTy *Ty) const = 0;
 
-  /// This method is used to implement the bitrange
-  /// selection operator.  Given an initializer, it selects the specified bits
-  /// out, returning them as a new init of bits type.  If it is not legal to use
-  /// the bit subscript operator on this initializer, return null.
+  /// This function is used to implement the bit range
+  /// selection operator. Given a value, it selects the specified bits,
+  /// returning them as a new \p Init of type \p bits. If it is not legal
+  /// to use the bit selection operator on this value, null is returned.
   virtual Init *convertInitializerBitRange(ArrayRef<unsigned> Bits) const {
     return nullptr;
   }
 
-  /// This method is used to implement the list slice
-  /// selection operator.  Given an initializer, it selects the specified list
-  /// elements, returning them as a new init of list type.  If it is not legal
-  /// to take a slice of this, return null.
+  /// This function is used to implement the list slice
+  /// selection operator.  Given a value, it selects the specified list
+  /// elements, returning them as a new \p Init of type \p list. If it
+  /// is not legal to use the slice operator, null is returned.
   virtual Init *convertInitListSlice(ArrayRef<unsigned> Elements) const {
     return nullptr;
   }
 
-  /// This method is used to implement the FieldInit class.
-  /// Implementors of this method should return the type of the named field if
-  /// they are of record type.
+  /// This function is used to implement the FieldInit class.
+  /// Implementors of this method should return the type of the named
+  /// field if they are of type record.
   virtual RecTy *getFieldType(StringInit *FieldName) const {
     return nullptr;
   }
 
-  /// This method is used by classes that refer to other
+  /// This function is used by classes that refer to other
   /// variables which may not be defined at the time the expression is formed.
   /// If a value is set for the variable later, this method will be called on
   /// users of the value to allow the value to propagate out.
@@ -411,8 +392,7 @@
     return const_cast<Init *>(this);
   }
 
-  /// This method is used to return the initializer for the specified
-  /// bit.
+  /// Get the \p Init value of the specified bit.
   virtual Init *getBit(unsigned Bit) const = 0;
 };
 
@@ -420,14 +400,14 @@
   I.print(OS); return OS;
 }
 
-/// This is the common super-class of types that have a specific,
-/// explicit, type.
+/// This is the common superclass of types that have a specific,
+/// explicit type, stored in ValueTy.
 class TypedInit : public Init {
-  RecTy *Ty;
+  RecTy *ValueTy;
 
 protected:
   explicit TypedInit(InitKind K, RecTy *T, uint8_t Opc = 0)
-    : Init(K, Opc), Ty(T) {}
+      : Init(K, Opc), ValueTy(T) {}
 
 public:
   TypedInit(const TypedInit &) = delete;
@@ -438,7 +418,8 @@
            I->getKind() <= IK_LastTypedInit;
   }
 
-  RecTy *getType() const { return Ty; }
+  /// Get the type of the Init as a RecTy.
+  RecTy *getType() const { return ValueTy; }
 
   Init *getCastTo(RecTy *Ty) const override;
   Init *convertInitializerTo(RecTy *Ty) const override;
@@ -448,12 +429,11 @@
 
   /// This method is used to implement the FieldInit class.
   /// Implementors of this method should return the type of the named field if
-  /// they are of record type.
-  ///
+  /// they are of type record.
   RecTy *getFieldType(StringInit *FieldName) const override;
 };
 
-/// '?' - Represents an uninitialized value
+/// '?' - Represents an uninitialized value.
 class UnsetInit : public Init {
   UnsetInit() : Init(IK_UnsetInit) {}
 
@@ -465,6 +445,7 @@
     return I->getKind() == IK_UnsetInit;
   }
 
+  /// Get the singleton unset Init.
   static UnsetInit *get();
 
   Init *getCastTo(RecTy *Ty) const override;
@@ -474,8 +455,12 @@
     return const_cast<UnsetInit*>(this);
   }
 
+  /// Is this a complete value with no unset (uninitialized) subvalues?
   bool isComplete() const override { return false; }
+
   bool isConcrete() const override { return true; }
+
+  /// Get the string representation of the Init.
   std::string getAsString() const override { return "?"; }
 };
 
@@ -592,10 +577,18 @@
 
 /// "foo" - Represent an initialization by a string value.
 class StringInit : public TypedInit {
-  StringRef Value;
+public:
+  enum StringFormat {
+    SF_String, // Format as "text"
+    SF_Code,   // Format as [{text}]
+  };
 
-  explicit StringInit(StringRef V)
-      : TypedInit(IK_StringInit, StringRecTy::get()), Value(V) {}
+private:
+  StringRef Value;
+  StringFormat Format;
+
+  explicit StringInit(StringRef V, StringFormat Fmt)
+      : TypedInit(IK_StringInit, StringRecTy::get()), Value(V), Format(Fmt) {}
 
 public:
   StringInit(const StringInit &) = delete;
@@ -605,51 +598,30 @@
     return I->getKind() == IK_StringInit;
   }
 
-  static StringInit *get(StringRef);
+  static StringInit *get(StringRef, StringFormat Fmt = SF_String);
+
+  static StringFormat determineFormat(StringFormat Fmt1, StringFormat Fmt2) {
+    return (Fmt1 == SF_Code || Fmt2 == SF_Code) ? SF_Code : SF_String;
+  }
 
   StringRef getValue() const { return Value; }
+  StringFormat getFormat() const { return Format; }  
+  bool hasCodeFormat() const { return Format == SF_Code; }
 
   Init *convertInitializerTo(RecTy *Ty) const override;
 
   bool isConcrete() const override { return true; }
-  std::string getAsString() const override { return "\"" + Value.str() + "\""; }
 
-  std::string getAsUnquotedString() const override { return Value; }
-
-  Init *getBit(unsigned Bit) const override {
-    llvm_unreachable("Illegal bit reference off string");
-  }
-};
-
-class CodeInit : public TypedInit {
-  StringRef Value;
-  SMLoc Loc;
-
-  explicit CodeInit(StringRef V, const SMLoc &Loc)
-      : TypedInit(IK_CodeInit, static_cast<RecTy *>(CodeRecTy::get())),
-        Value(V), Loc(Loc) {}
-
-public:
-  CodeInit(const StringInit &) = delete;
-  CodeInit &operator=(const StringInit &) = delete;
-
-  static bool classof(const Init *I) {
-    return I->getKind() == IK_CodeInit;
-  }
-
-  static CodeInit *get(StringRef, const SMLoc &Loc);
-
-  StringRef getValue() const { return Value; }
-  const SMLoc &getLoc() const { return Loc; }
-
-  Init *convertInitializerTo(RecTy *Ty) const override;
-
-  bool isConcrete() const override { return true; }
   std::string getAsString() const override {
-    return "[{" + Value.str() + "}]";
+    if (Format == SF_String)
+      return "\"" + Value.str() + "\"";
+    else
+      return "[{" + Value.str() + "}]";
   }
 
-  std::string getAsUnquotedString() const override { return Value; }
+  std::string getAsUnquotedString() const override {
+    return std::string(Value);
+  }
 
   Init *getBit(unsigned Bit) const override {
     llvm_unreachable("Illegal bit reference off string");
@@ -751,7 +723,7 @@
 ///
 class UnOpInit : public OpInit, public FoldingSetNode {
 public:
-  enum UnaryOp : uint8_t { CAST, HEAD, TAIL, SIZE, EMPTY };
+  enum UnaryOp : uint8_t { CAST, NOT, HEAD, TAIL, SIZE, EMPTY, GETDAGOP };
 
 private:
   Init *LHS;
@@ -800,9 +772,9 @@
 /// !op (X, Y) - Combine two inits.
 class BinOpInit : public OpInit, public FoldingSetNode {
 public:
-  enum BinaryOp : uint8_t { ADD, MUL, AND, OR, SHL, SRA, SRL, LISTCONCAT,
-                            LISTSPLAT, STRCONCAT, CONCAT, EQ, NE, LE, LT, GE,
-                            GT };
+  enum BinaryOp : uint8_t { ADD, SUB, MUL, AND, OR, XOR, SHL, SRA, SRL, LISTCONCAT,
+                            LISTSPLAT, STRCONCAT, INTERLEAVE, CONCAT, EQ,
+                            NE, LE, LT, GE, GT, SETDAGOP };
 
 private:
   Init *LHS, *RHS;
@@ -822,7 +794,6 @@
                         RecTy *Type);
   static Init *getStrConcat(Init *lhs, Init *rhs);
   static Init *getListConcat(TypedInit *lhs, Init *rhs);
-  static Init *getListSplat(TypedInit *lhs, Init *rhs);
 
   void Profile(FoldingSetNodeID &ID) const;
 
@@ -858,7 +829,7 @@
 /// !op (X, Y, Z) - Combine two inits.
 class TernOpInit : public OpInit, public FoldingSetNode {
 public:
-  enum TernaryOp : uint8_t { SUBST, FOREACH, IF, DAG };
+  enum TernaryOp : uint8_t { SUBST, FOREACH, FILTER, IF, DAG, SUBSTR };
 
 private:
   Init *LHS, *MHS, *RHS;
@@ -1098,7 +1069,7 @@
 
   Init *getBit(unsigned Bit) const override;
 
-  std::string getAsString() const override { return getName(); }
+  std::string getAsString() const override { return std::string(getName()); }
 };
 
 /// Opcode{0} - Represent access to one bit of a variable or field.
@@ -1263,7 +1234,14 @@
 
   FieldInit(Init *R, StringInit *FN)
       : TypedInit(IK_FieldInit, R->getFieldType(FN)), Rec(R), FieldName(FN) {
-    assert(getType() && "FieldInit with non-record type!");
+#ifndef NDEBUG
+    if (!getType()) {
+      llvm::errs() << "In Record = " << Rec->getAsString()
+                   << ", got FieldName = " << *FieldName
+                   << " with non-record type!\n";
+      llvm_unreachable("FieldInit with non-record type!");
+    }
+#endif
   }
 
 public:
@@ -1284,6 +1262,7 @@
   Init *resolveReferences(Resolver &R) const override;
   Init *Fold(Record *CurRec) const;
 
+  bool isConcrete() const override;
   std::string getAsString() const override {
     return Rec->getAsString() + "." + FieldName->getValue().str();
   }
@@ -1323,6 +1302,7 @@
   void Profile(FoldingSetNodeID &ID) const;
 
   Init *getOperator() const { return Val; }
+  Record *getOperatorAsDef(ArrayRef<SMLoc> Loc) const;
 
   StringInit *getName() const { return ValName; }
 
@@ -1384,30 +1364,70 @@
 //  High-Level Classes
 //===----------------------------------------------------------------------===//
 
+/// This class represents a field in a record, including its name, type,
+/// value, and source location.
 class RecordVal {
   friend class Record;
 
+public:
+  enum FieldKind {
+    FK_Normal,        // A normal record field.
+    FK_NonconcreteOK, // A field that can be nonconcrete ('field' keyword).
+    FK_TemplateArg,   // A template argument.
+  };
+
+private:
   Init *Name;
-  PointerIntPair<RecTy *, 1, bool> TyAndPrefix;
+  SMLoc Loc; // Source location of definition of name.
+  PointerIntPair<RecTy *, 2, FieldKind> TyAndKind;
   Init *Value;
 
 public:
-  RecordVal(Init *N, RecTy *T, bool P);
+  RecordVal(Init *N, RecTy *T, FieldKind K);
+  RecordVal(Init *N, SMLoc Loc, RecTy *T, FieldKind K);
 
+  /// Get the name of the field as a StringRef.
   StringRef getName() const;
+
+  /// Get the name of the field as an Init.
   Init *getNameInit() const { return Name; }
 
+  /// Get the name of the field as a std::string.
   std::string getNameInitAsString() const {
     return getNameInit()->getAsUnquotedString();
   }
 
-  bool getPrefix() const { return TyAndPrefix.getInt(); }
-  RecTy *getType() const { return TyAndPrefix.getPointer(); }
+  /// Get the source location of the point where the field was defined.
+  const SMLoc &getLoc() const { return Loc; }
+
+  /// Is this a field where nonconcrete values are okay?
+  bool isNonconcreteOK() const {
+    return TyAndKind.getInt() == FK_NonconcreteOK;
+  }
+
+  /// Is this a template argument?
+  bool isTemplateArg() const {
+    return TyAndKind.getInt() == FK_TemplateArg;
+  }
+
+  /// Get the type of the field value as a RecTy.
+  RecTy *getType() const { return TyAndKind.getPointer(); }
+
+  /// Get the type of the field for printing purposes.
+  std::string getPrintType() const;
+
+  /// Get the value of the field as an Init.
   Init *getValue() const { return Value; }
 
+  /// Set the value of the field from an Init.
   bool setValue(Init *V);
 
+  /// Set the value and source location of the field.
+  bool setValue(Init *V, SMLoc NewLoc);
+
   void dump() const;
+
+  /// Print the value to an output stream, possibly with a semicolon.
   void print(raw_ostream &OS, bool PrintSem = true) const;
 };
 
@@ -1425,15 +1445,18 @@
   SmallVector<SMLoc, 4> Locs;
   SmallVector<Init *, 0> TemplateArgs;
   SmallVector<RecordVal, 0> Values;
+  // Vector of [source location, condition Init, message Init].
+  SmallVector<std::tuple<SMLoc, Init *, Init *>, 0> Assertions;
 
-  // All superclasses in the inheritance forest in reverse preorder (yes, it
+  // All superclasses in the inheritance forest in post-order (yes, it
   // must be a forest; diamond-shaped inheritance is not allowed).
   SmallVector<std::pair<Record *, SMRange>, 0> SuperClasses;
 
   // Tracks Record instances. Not owned by Record.
   RecordKeeper &TrackedRecords;
 
-  DefInit *TheInit = nullptr;
+  // The DefInit corresponding to this record.
+  DefInit *CorrespondingDefInit = nullptr;
 
   // Unique record ID.
   unsigned ID;
@@ -1457,8 +1480,8 @@
       : Record(StringInit::get(N), locs, records, false, Class) {}
 
   // When copy-constructing a Record, we must still guarantee a globally unique
-  // ID number.  Don't copy TheInit either since it's owned by the original
-  // record. All other fields can be copied normally.
+  // ID number. Don't copy CorrespondingDefInit either, since it's owned by the
+  // original record. All other fields can be copied normally.
   Record(const Record &O)
     : Name(O.Name), Locs(O.Locs), TemplateArgs(O.TemplateArgs),
       Values(O.Values), SuperClasses(O.SuperClasses),
@@ -1498,11 +1521,18 @@
 
   ArrayRef<RecordVal> getValues() const { return Values; }
 
+  ArrayRef<std::tuple<SMLoc, Init *, Init *>> getAssertions() const {
+    return Assertions;
+  }
+
   ArrayRef<std::pair<Record *, SMRange>>  getSuperClasses() const {
     return SuperClasses;
   }
 
-  /// Append the direct super classes of this record to Classes.
+  /// Determine whether this record has the specified direct superclass.
+  bool hasDirectSuperClass(const Record *SuperClass) const;
+
+  /// Append the direct superclasses of this record to Classes.
   void getDirectSuperClasses(SmallVectorImpl<Record *> &Classes) const;
 
   bool isTemplateArg(Init *Name) const {
@@ -1552,6 +1582,10 @@
     removeValue(StringInit::get(Name));
   }
 
+  void addAssertion(SMLoc Loc, Init *Condition, Init *Message) {
+    Assertions.push_back(std::make_tuple(Loc, Condition, Message));
+  }
+
   bool isSubClassOf(const Record *R) const {
     for (const auto &SCPair : SuperClasses)
       if (SCPair.first == R)
@@ -1572,7 +1606,8 @@
   }
 
   void addSuperClass(Record *R, SMRange Range) {
-    assert(!TheInit && "changing type of record after it has been referenced");
+    assert(!CorrespondingDefInit &&
+           "changing type of record after it has been referenced");
     assert(!isSubClassOf(R) && "Already subclassing record!");
     SuperClasses.push_back(std::make_pair(R, Range));
   }
@@ -1591,11 +1626,6 @@
   /// recursion / infinite loops.
   void resolveReferences(Resolver &R, const RecordVal *SkipVal = nullptr);
 
-  /// If anything in this record refers to RV, replace the
-  /// reference to RV with the RHS of RV.  If RV is null, we resolve all
-  /// possible references.
-  void resolveReferencesTo(const RecordVal *RV);
-
   RecordKeeper &getRecords() const {
     return TrackedRecords;
   }
@@ -1604,13 +1634,15 @@
     return IsAnonymous;
   }
 
-  void print(raw_ostream &OS) const;
   void dump() const;
 
   //===--------------------------------------------------------------------===//
   // High-level methods useful to tablegen back-ends
   //
 
+  ///Return the source location for the named field.
+  SMLoc getFieldLoc(StringRef FieldName) const;
+
   /// Return the initializer for a value with the specified name,
   /// or throw an exception if the field does not exist.
   Init *getValueInit(StringRef FieldName) const;
@@ -1626,6 +1658,11 @@
   StringRef getValueAsString(StringRef FieldName) const;
 
   /// This method looks up the specified field and returns
+  /// its value as a string, throwing an exception if the field if the value is
+  /// not a string and llvm::Optional() if the field does not exist.
+  llvm::Optional<StringRef> getValueAsOptionalString(StringRef FieldName) const;
+
+  /// This method looks up the specified field and returns
   /// its value as a BitsInit, throwing an exception if the field does not exist
   /// or if the value is not the right type.
   BitsInit *getValueAsBitsInit(StringRef FieldName) const;
@@ -1655,6 +1692,12 @@
   /// the value is not the right type.
   Record *getValueAsDef(StringRef FieldName) const;
 
+  /// This method looks up the specified field and returns its value as a
+  /// Record, returning null if the field exists but is "uninitialized"
+  /// (i.e. set to `?`), and throwing an exception if the field does not
+  /// exist or if its value is not the right type.
+  Record *getValueAsOptionalDef(StringRef FieldName) const;
+
   /// This method looks up the specified field and returns its
   /// value as a bit, throwing an exception if the field does not exist or if
   /// the value is not the right type.
@@ -1680,26 +1723,50 @@
 
 class RecordKeeper {
   friend class RecordRecTy;
-  using RecordMap = std::map<std::string, std::unique_ptr<Record>>;
+
+  using RecordMap = std::map<std::string, std::unique_ptr<Record>, std::less<>>;
+  using GlobalMap = std::map<std::string, Init *, std::less<>>;
+
+  std::string InputFilename;
   RecordMap Classes, Defs;
+  mutable StringMap<std::vector<Record *>> ClassRecordsMap;
   FoldingSet<RecordRecTy> RecordTypePool;
-  std::map<std::string, Init *> ExtraGlobals;
+  std::map<std::string, Init *, std::less<>> ExtraGlobals;
   unsigned AnonCounter = 0;
 
+  // These members are for the phase timing feature. We need a timer group,
+  // the last timer started, and a flag to say whether the last timer
+  // is the special "backend overall timer."
+  TimerGroup *TimingGroup = nullptr;
+  Timer *LastTimer = nullptr;
+  bool BackendTimer = false;
+
 public:
+  /// Get the main TableGen input file's name.
+  const std::string getInputFilename() const { return InputFilename; }
+
+  /// Get the map of classes.
   const RecordMap &getClasses() const { return Classes; }
+
+  /// Get the map of records (defs).
   const RecordMap &getDefs() const { return Defs; }
 
+  /// Get the map of global variables.
+  const GlobalMap &getGlobals() const { return ExtraGlobals; }
+
+  /// Get the class with the specified name.
   Record *getClass(StringRef Name) const {
     auto I = Classes.find(Name);
     return I == Classes.end() ? nullptr : I->second.get();
   }
 
+  /// Get the concrete record with the specified name.
   Record *getDef(StringRef Name) const {
     auto I = Defs.find(Name);
     return I == Defs.end() ? nullptr : I->second.get();
   }
 
+  /// Get the \p Init value of the specified global variable.
   Init *getGlobal(StringRef Name) const {
     if (Record *R = getDef(Name))
       return R->getDefInit();
@@ -1707,22 +1774,26 @@
     return It == ExtraGlobals.end() ? nullptr : It->second;
   }
 
+  void saveInputFilename(std::string Filename) {
+    InputFilename = Filename;
+  }
+
   void addClass(std::unique_ptr<Record> R) {
-    bool Ins = Classes.insert(std::make_pair(R->getName(),
+    bool Ins = Classes.insert(std::make_pair(std::string(R->getName()),
                                              std::move(R))).second;
     (void)Ins;
     assert(Ins && "Class already exists");
   }
 
   void addDef(std::unique_ptr<Record> R) {
-    bool Ins = Defs.insert(std::make_pair(R->getName(),
+    bool Ins = Defs.insert(std::make_pair(std::string(R->getName()),
                                           std::move(R))).second;
     (void)Ins;
     assert(Ins && "Record already exists");
   }
 
   void addExtraGlobal(StringRef Name, Init *I) {
-    bool Ins = ExtraGlobals.insert(std::make_pair(Name, I)).second;
+    bool Ins = ExtraGlobals.insert(std::make_pair(std::string(Name), I)).second;
     (void)Ins;
     assert(!getDef(Name));
     assert(Ins && "Global already exists");
@@ -1730,14 +1801,42 @@
 
   Init *getNewAnonymousName();
 
-  //===--------------------------------------------------------------------===//
-  // High-level helper methods, useful for tablegen backends...
+  /// Start phase timing; called if the --time-phases option is specified.
+  void startPhaseTiming() {
+    TimingGroup = new TimerGroup("TableGen", "TableGen Phase Timing");
+  }
 
-  /// This method returns all concrete definitions
-  /// that derive from the specified class name.  A class with the specified
-  /// name must exist.
+  /// Start timing a phase. Automatically stops any previous phase timer.
+  void startTimer(StringRef Name);
+
+  /// Stop timing a phase.
+  void stopTimer();
+
+  /// Start timing the overall backend. If the backend itself starts a timer,
+  /// then this timer is cleared.
+  void startBackendTimer(StringRef Name);
+
+  /// Stop timing the overall backend.
+  void stopBackendTimer();
+
+  /// Stop phase timing and print the report.
+  void stopPhaseTiming() {
+    if (TimingGroup)
+      delete TimingGroup;
+  }
+
+  //===--------------------------------------------------------------------===//
+  // High-level helper methods, useful for tablegen backends.
+
+  /// Get all the concrete records that inherit from the one specified
+  /// class. The class must be defined.
   std::vector<Record *> getAllDerivedDefinitions(StringRef ClassName) const;
 
+  /// Get all the concrete records that inherit from all the specified
+  /// classes. The classes must be defined.
+  std::vector<Record *> getAllDerivedDefinitions(
+      ArrayRef<StringRef> ClassNames) const;
+
   void dump() const;
 };
 
@@ -1913,25 +2012,6 @@
   bool keepUnsetBits() const override { return true; }
 };
 
-/// Resolve all references to a specific RecordVal.
-//
-// TODO: This is used for resolving references to template arguments, in a
-//       rather inefficient way. Change those uses to resolve all template
-//       arguments simultaneously and get rid of this class.
-class RecordValResolver final : public Resolver {
-  const RecordVal *RV;
-
-public:
-  explicit RecordValResolver(Record &R, const RecordVal *RV)
-      : Resolver(&R), RV(RV) {}
-
-  Init *resolve(Init *VarName) override {
-    if (VarName == RV->getNameInit())
-      return RV->getValue();
-    return nullptr;
-  }
-};
-
 /// Delegate resolving to a sub-resolver, but shadow some variable names.
 class ShadowResolver final : public Resolver {
   Resolver &R;
@@ -1982,6 +2062,7 @@
   Init *resolve(Init *VarName) override;
 };
 
+void EmitDetailedRecords(RecordKeeper &RK, raw_ostream &OS);
 void EmitJSON(RecordKeeper &RK, raw_ostream &OS);
 
 } // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/TableGen/SearchableTable.td b/linux-x64/clang/include/llvm/TableGen/SearchableTable.td
index 2680c71..61dfa5c 100644
--- a/linux-x64/clang/include/llvm/TableGen/SearchableTable.td
+++ b/linux-x64/clang/include/llvm/TableGen/SearchableTable.td
@@ -67,9 +67,13 @@
   // List of the names of fields of collected records that contain the data for
   // table entries, in the order that is used for initialization in C++.
   //
-  // For each field of the table named XXX, TableGen will look for a value
-  // called TypeOf_XXX and use that as a more detailed description of the
-  // type of the field if present. This is required for fields whose type
+  // TableGen needs to know the type of the fields so that it can format
+  // the initializers correctly. It can infer the type of bit, bits, string,
+  // Intrinsic, and Instruction values. 
+  //
+  // For each field of the table named xxx, TableGen will look for a field
+  // named TypeOf_xxx and use that as a more detailed description of the
+  // type of the field. This is required for fields whose type
   // cannot be deduced automatically, such as enum fields. For example:
   //
   //   def MyEnum : GenericEnum {
@@ -85,15 +89,15 @@
   //   def MyTable : GenericTable {
   //     let FilterClass = "MyTableEntry";
   //     let Fields = ["V", ...];
-  //     GenericEnum TypeOf_V = MyEnum;
+  //     string TypeOf_V = "MyEnum";
   //   }
   //
-  // Fields of type bit, bits<N>, string, Intrinsic, and Instruction (or
-  // derived classes of those) are supported natively.
+  // If a string field was initialized with a code literal, TableGen will
+  // emit the code verbatim. However, if a string field was initialized
+  // in some other way, but should be interpreted as code, then a TypeOf_xxx
+  // field is necessary, with a value of "code":
   //
-  // Additionally, fields of type `code` can appear, where the value is used
-  // verbatim as an initializer. However, these fields cannot be used as
-  // search keys.
+  //     string TypeOf_Predicate = "code";
   list<string> Fields;
 
   // (Optional) List of fields that make up the primary key.
@@ -103,7 +107,7 @@
   string PrimaryKeyName;
 
   // See SearchIndex.EarlyOut
-  bit PrimaryKeyEarlyOut = 0;
+  bit PrimaryKeyEarlyOut = false;
 }
 
 // Define a record derived from this class to generate an additional search
@@ -124,7 +128,7 @@
   // instructions.
   //
   // Can only be used when the first field is an integral (non-string) type.
-  bit EarlyOut = 0;
+  bit EarlyOut = false;
 }
 
 // Legacy table type with integrated enum.
diff --git a/linux-x64/clang/include/llvm/TableGen/StringToOffsetTable.h b/linux-x64/clang/include/llvm/TableGen/StringToOffsetTable.h
index 76ce518..7fcf20a 100644
--- a/linux-x64/clang/include/llvm/TableGen/StringToOffsetTable.h
+++ b/linux-x64/clang/include/llvm/TableGen/StringToOffsetTable.h
@@ -45,7 +45,7 @@
     // Escape the string.
     SmallString<256> Str;
     raw_svector_ostream(Str).write_escaped(AggregateString);
-    AggregateString = Str.str();
+    AggregateString = std::string(Str.str());
 
     O << "    \"";
     unsigned CharsPrinted = 0;
diff --git a/linux-x64/clang/include/llvm/Target/CGPassBuilderOption.h b/linux-x64/clang/include/llvm/Target/CGPassBuilderOption.h
new file mode 100644
index 0000000..c3a221e
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Target/CGPassBuilderOption.h
@@ -0,0 +1,65 @@
+//===- CGPassBuilderOption.h - Options for pass builder ---------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file declares the CCState and CCValAssign classes, used for lowering
+// and implementing calling conventions.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CODEGEN_PASSBUILDER_OPTION_H
+#define LLVM_CODEGEN_PASSBUILDER_OPTION_H
+
+#include "llvm/ADT/Optional.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Target/TargetOptions.h"
+#include <vector>
+
+namespace llvm {
+class TargetMachine;
+
+enum class RunOutliner { TargetDefault, AlwaysOutline, NeverOutline };
+enum class RegAllocType { Default, Basic, Fast, Greedy, PBQP };
+enum class CFLAAType { None, Steensgaard, Andersen, Both };
+
+// Not one-on-one but mostly corresponding to commandline options in
+// TargetPassConfig.cpp.
+struct CGPassBuilderOption {
+  Optional<bool> OptimizeRegAlloc;
+  Optional<bool> EnableIPRA;
+  bool DebugPM = false;
+  bool DisableVerify = false;
+  bool EnableImplicitNullChecks = false;
+  bool EnableBlockPlacementStats = false;
+  bool MISchedPostRA = false;
+  bool EarlyLiveIntervals = false;
+
+  bool DisableLSR = false;
+  bool DisableCGP = false;
+  bool PrintLSR = false;
+  bool DisableMergeICmps = false;
+  bool DisablePartialLibcallInlining = false;
+  bool DisableConstantHoisting = false;
+  bool PrintISelInput = false;
+  bool PrintGCInfo = false;
+  bool RequiresCodeGenSCCOrder = false;
+
+  RunOutliner EnableMachineOutliner = RunOutliner::TargetDefault;
+  RegAllocType RegAlloc = RegAllocType::Default;
+  CFLAAType UseCFLAA = CFLAAType::None;
+  Optional<GlobalISelAbortMode> EnableGlobalISelAbort;
+
+  Optional<bool> VerifyMachineCode;
+  Optional<bool> EnableFastISelOption;
+  Optional<bool> EnableGlobalISelOption;
+};
+
+CGPassBuilderOption getCGPassBuilderOption();
+
+} // namespace llvm
+
+#endif // LLVM_CODEGEN_PASSBUILDER_OPTION_H
diff --git a/linux-x64/clang/include/llvm/Target/GenericOpcodes.td b/linux-x64/clang/include/llvm/Target/GenericOpcodes.td
index 11fbf62..2099259 100644
--- a/linux-x64/clang/include/llvm/Target/GenericOpcodes.td
+++ b/linux-x64/clang/include/llvm/Target/GenericOpcodes.td
@@ -15,14 +15,32 @@
 // Unary ops.
 //------------------------------------------------------------------------------
 
-class GenericInstruction : StandardPseudoInstruction;
+class GenericInstruction : StandardPseudoInstruction {
+  let isPreISelOpcode = true;
+}
+
+// Provide a variant of an instruction with the same operands, but
+// different instruction flags. This is intended to provide a
+// convenient way to define strict floating point variants of ordinary
+// floating point instructions.
+class ConstrainedIntruction<GenericInstruction baseInst> :
+  GenericInstruction {
+  let OutOperandList = baseInst.OutOperandList;
+  let InOperandList =  baseInst.InOperandList;
+  let isCommutable = baseInst.isCommutable;
+
+  // TODO: Do we need a better way to mark reads from FP mode than
+  // hasSideEffects?
+  let hasSideEffects = true;
+  let mayRaiseFPException = true;
+}
 
 // Extend the underlying scalar type of an operation, leaving the high bits
 // unspecified.
 def G_ANYEXT : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type1:$src);
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
 }
 
 // Sign extend the underlying scalar type of an operation, copying the sign bit
@@ -30,7 +48,21 @@
 def G_SEXT : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type1:$src);
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
+}
+
+// Sign extend the a value from an arbitrary bit position, copying the sign bit
+// into all bits above it. This is equivalent to a shl + ashr pair with an
+// appropriate shift amount. $sz is an immediate (MachineOperand::isImm()
+// returns true) to allow targets to have some bitwidths legal and others
+// lowered. This opcode is particularly useful if the target has sign-extension
+// instructions that are cheaper than the constituent shifts as the optimizer is
+// able to make decisions on whether it's better to hang on to the G_SEXT_INREG
+// or to lower it and optimize the individual shifts.
+def G_SEXT_INREG : GenericInstruction {
+  let OutOperandList = (outs type0:$dst);
+  let InOperandList = (ins type0:$src, untyped_imm_0:$sz);
+  let hasSideEffects = false;
 }
 
 // Zero extend the underlying scalar type of an operation, putting zero bits
@@ -38,7 +70,7 @@
 def G_ZEXT : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type1:$src);
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
 }
 
 
@@ -47,132 +79,150 @@
 def G_TRUNC : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type1:$src);
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
 }
 
 def G_IMPLICIT_DEF : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins);
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
 }
 
 def G_PHI : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins variable_ops);
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
 }
 
 def G_FRAME_INDEX : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins unknown:$src2);
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
 }
 
 def G_GLOBAL_VALUE : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins unknown:$src);
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
 }
 
 def G_INTTOPTR : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type1:$src);
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
 }
 
 def G_PTRTOINT : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type1:$src);
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
 }
 
 def G_BITCAST : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type1:$src);
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
 }
 
 // Only supports scalar result types
 def G_CONSTANT : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins unknown:$imm);
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
 }
 
 // Only supports scalar result types
 def G_FCONSTANT : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins unknown:$imm);
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
 }
 
 def G_VASTART : GenericInstruction {
   let OutOperandList = (outs);
   let InOperandList = (ins type0:$list);
-  let hasSideEffects = 0;
-  let mayStore = 1;
+  let hasSideEffects = false;
+  let mayStore = true;
 }
 
 def G_VAARG : GenericInstruction {
   let OutOperandList = (outs type0:$val);
   let InOperandList = (ins type1:$list, unknown:$align);
-  let hasSideEffects = 0;
-  let mayLoad = 1;
-  let mayStore = 1;
+  let hasSideEffects = false;
+  let mayLoad = true;
+  let mayStore = true;
 }
 
 def G_CTLZ : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type1:$src);
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
 }
 
 def G_CTLZ_ZERO_UNDEF : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type1:$src);
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
 }
 
 def G_CTTZ : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type1:$src);
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
 }
 
 def G_CTTZ_ZERO_UNDEF : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type1:$src);
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
 }
 
 def G_CTPOP : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type1:$src);
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
 }
 
 def G_BSWAP : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type0:$src);
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
+}
+
+def G_BITREVERSE : GenericInstruction {
+  let OutOperandList = (outs type0:$dst);
+  let InOperandList = (ins type0:$src);
+  let hasSideEffects = false;
 }
 
 def G_ADDRSPACE_CAST : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type1:$src);
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
 }
 
 def G_BLOCK_ADDR : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins unknown:$ba);
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
 }
 
 def G_JUMP_TABLE : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins unknown:$jti);
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
+}
+
+def G_DYN_STACKALLOC : GenericInstruction {
+  let OutOperandList = (outs ptype0:$dst);
+  let InOperandList = (ins type1:$size, i32imm:$align);
+  let hasSideEffects = true;
+}
+
+def G_FREEZE : GenericInstruction {
+  let OutOperandList = (outs type0:$dst);
+  let InOperandList = (ins type0:$src);
+  let hasSideEffects = false;
 }
 
 //------------------------------------------------------------------------------
@@ -183,167 +233,192 @@
 def G_ADD : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type0:$src1, type0:$src2);
-  let hasSideEffects = 0;
-  let isCommutable = 1;
+  let hasSideEffects = false;
+  let isCommutable = true;
 }
 
 // Generic subtraction.
 def G_SUB : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type0:$src1, type0:$src2);
-  let hasSideEffects = 0;
-  let isCommutable = 0;
+  let hasSideEffects = false;
+  let isCommutable = false;
 }
 
 // Generic multiplication.
 def G_MUL : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type0:$src1, type0:$src2);
-  let hasSideEffects = 0;
-  let isCommutable = 1;
+  let hasSideEffects = false;
+  let isCommutable = true;
 }
 
 // Generic signed division.
 def G_SDIV : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type0:$src1, type0:$src2);
-  let hasSideEffects = 0;
-  let isCommutable = 0;
+  let hasSideEffects = false;
+  let isCommutable = false;
 }
 
 // Generic unsigned division.
 def G_UDIV : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type0:$src1, type0:$src2);
-  let hasSideEffects = 0;
-  let isCommutable = 0;
+  let hasSideEffects = false;
+  let isCommutable = false;
 }
 
 // Generic signed remainder.
 def G_SREM : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type0:$src1, type0:$src2);
-  let hasSideEffects = 0;
-  let isCommutable = 0;
+  let hasSideEffects = false;
+  let isCommutable = false;
 }
 
 // Generic unsigned remainder.
 def G_UREM : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type0:$src1, type0:$src2);
-  let hasSideEffects = 0;
-  let isCommutable = 0;
+  let hasSideEffects = false;
+  let isCommutable = false;
 }
 
 // Generic bitwise and.
 def G_AND : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type0:$src1, type0:$src2);
-  let hasSideEffects = 0;
-  let isCommutable = 1;
+  let hasSideEffects = false;
+  let isCommutable = true;
 }
 
 // Generic bitwise or.
 def G_OR : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type0:$src1, type0:$src2);
-  let hasSideEffects = 0;
-  let isCommutable = 1;
+  let hasSideEffects = false;
+  let isCommutable = true;
 }
 
 // Generic bitwise xor.
 def G_XOR : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type0:$src1, type0:$src2);
-  let hasSideEffects = 0;
-  let isCommutable = 1;
+  let hasSideEffects = false;
+  let isCommutable = true;
 }
 
 // Generic left-shift.
 def G_SHL : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type0:$src1, type1:$src2);
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
 }
 
 // Generic logical right-shift.
 def G_LSHR : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type0:$src1, type1:$src2);
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
 }
 
 // Generic arithmetic right-shift.
 def G_ASHR : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type0:$src1, type1:$src2);
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
+}
+
+/// Funnel 'double' shifts take 3 operands, 2 inputs and the shift amount.
+/// fshl(X,Y,Z): (X << (Z % bitwidth)) | (Y >> (bitwidth - (Z % bitwidth)))
+def G_FSHL : GenericInstruction {
+  let OutOperandList = (outs type0:$dst);
+  let InOperandList = (ins type0:$src1, type0:$src2, type1:$src3);
+  let hasSideEffects = false;
+}
+
+/// Funnel 'double' shifts take 3 operands, 2 inputs and the shift amount.
+/// fshr(X,Y,Z): (X << (bitwidth - (Z % bitwidth))) | (Y >> (Z % bitwidth))
+def G_FSHR : GenericInstruction {
+  let OutOperandList = (outs type0:$dst);
+  let InOperandList = (ins type0:$src1, type0:$src2, type1:$src3);
+  let hasSideEffects = false;
 }
 
 // Generic integer comparison.
 def G_ICMP : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins unknown:$tst, type1:$src1, type1:$src2);
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
 }
 
 // Generic floating-point comparison.
 def G_FCMP : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins unknown:$tst, type1:$src1, type1:$src2);
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
 }
 
 // Generic select
 def G_SELECT : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type1:$tst, type0:$src1, type0:$src2);
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
 }
 
 // Generic pointer offset.
-def G_GEP : GenericInstruction {
+def G_PTR_ADD : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type0:$src1, type1:$src2);
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
 }
 
-def G_PTR_MASK : GenericInstruction {
-  let OutOperandList = (outs type0:$dst);
-  let InOperandList = (ins type0:$src, unknown:$bits);
-  let hasSideEffects = 0;
+// Generic pointer mask. type1 should be an integer with the same
+// bitwidth as the pointer type.
+def G_PTRMASK : GenericInstruction {
+  let OutOperandList = (outs ptype0:$dst);
+  let InOperandList = (ins ptype0:$src, type1:$bits);
+  let hasSideEffects = false;
 }
 
 // Generic signed integer minimum.
 def G_SMIN : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type0:$src1, type0:$src2);
-  let hasSideEffects = 0;
-  let isCommutable = 1;
+  let hasSideEffects = false;
+  let isCommutable = true;
 }
 
 // Generic signed integer maximum.
 def G_SMAX : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type0:$src1, type0:$src2);
-  let hasSideEffects = 0;
-  let isCommutable = 1;
+  let hasSideEffects = false;
+  let isCommutable = true;
 }
 
 // Generic unsigned integer minimum.
 def G_UMIN : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type0:$src1, type0:$src2);
-  let hasSideEffects = 0;
-  let isCommutable = 1;
+  let hasSideEffects = false;
+  let isCommutable = true;
 }
 
 // Generic unsigned integer maximum.
 def G_UMAX : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type0:$src1, type0:$src2);
-  let hasSideEffects = 0;
-  let isCommutable = 1;
+  let hasSideEffects = false;
+  let isCommutable = true;
+}
+
+// Generic integer absolute value.
+def G_ABS : GenericInstruction {
+  let OutOperandList = (outs type0:$dst);
+  let InOperandList = (ins type0:$src);
+  let hasSideEffects = false;
 }
 
 //------------------------------------------------------------------------------
@@ -354,73 +429,73 @@
 def G_UADDO : GenericInstruction {
   let OutOperandList = (outs type0:$dst, type1:$carry_out);
   let InOperandList = (ins type0:$src1, type0:$src2);
-  let hasSideEffects = 0;
-  let isCommutable = 1;
+  let hasSideEffects = false;
+  let isCommutable = true;
 }
 
 // Generic unsigned addition consuming and producing a carry flag.
 def G_UADDE : GenericInstruction {
   let OutOperandList = (outs type0:$dst, type1:$carry_out);
   let InOperandList = (ins type0:$src1, type0:$src2, type1:$carry_in);
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
 }
 
 // Generic signed addition producing a carry flag.
 def G_SADDO : GenericInstruction {
   let OutOperandList = (outs type0:$dst, type1:$carry_out);
   let InOperandList = (ins type0:$src1, type0:$src2);
-  let hasSideEffects = 0;
-  let isCommutable = 1;
+  let hasSideEffects = false;
+  let isCommutable = true;
 }
 
 // Generic signed addition consuming and producing a carry flag.
 def G_SADDE : GenericInstruction {
   let OutOperandList = (outs type0:$dst, type1:$carry_out);
   let InOperandList = (ins type0:$src1, type0:$src2, type1:$carry_in);
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
 }
 
 // Generic unsigned subtraction producing a carry flag.
 def G_USUBO : GenericInstruction {
   let OutOperandList = (outs type0:$dst, type1:$carry_out);
   let InOperandList = (ins type0:$src1, type0:$src2);
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
 }
 // Generic unsigned subtraction consuming and producing a carry flag.
 def G_USUBE : GenericInstruction {
   let OutOperandList = (outs type0:$dst, type1:$carry_out);
   let InOperandList = (ins type0:$src1, type0:$src2, type1:$carry_in);
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
 }
 
 // Generic signed subtraction producing a carry flag.
 def G_SSUBO : GenericInstruction {
   let OutOperandList = (outs type0:$dst, type1:$carry_out);
   let InOperandList = (ins type0:$src1, type0:$src2);
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
 }
 
 // Generic signed subtraction consuming and producing a carry flag.
 def G_SSUBE : GenericInstruction {
   let OutOperandList = (outs type0:$dst, type1:$carry_out);
   let InOperandList = (ins type0:$src1, type0:$src2, type1:$carry_in);
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
 }
 
 // Generic unsigned multiplication producing a carry flag.
 def G_UMULO : GenericInstruction {
   let OutOperandList = (outs type0:$dst, type1:$carry_out);
   let InOperandList = (ins type0:$src1, type0:$src2);
-  let hasSideEffects = 0;
-  let isCommutable = 1;
+  let hasSideEffects = false;
+  let isCommutable = true;
 }
 
 // Generic signed multiplication producing a carry flag.
 def G_SMULO : GenericInstruction {
   let OutOperandList = (outs type0:$dst, type1:$carry_out);
   let InOperandList = (ins type0:$src1, type0:$src2);
-  let hasSideEffects = 0;
-  let isCommutable = 1;
+  let hasSideEffects = false;
+  let isCommutable = true;
 }
 
 // Multiply two numbers at twice the incoming bit width (unsigned) and return
@@ -428,8 +503,8 @@
 def G_UMULH : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type0:$src1, type0:$src2);
-  let hasSideEffects = 0;
-  let isCommutable = 1;
+  let hasSideEffects = false;
+  let isCommutable = true;
 }
 
 // Multiply two numbers at twice the incoming bit width (signed) and return
@@ -437,8 +512,131 @@
 def G_SMULH : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type0:$src1, type0:$src2);
-  let hasSideEffects = 0;
-  let isCommutable = 1;
+  let hasSideEffects = false;
+  let isCommutable = true;
+}
+
+//------------------------------------------------------------------------------
+// Saturating ops
+//------------------------------------------------------------------------------
+
+// Generic saturating unsigned addition.
+def G_UADDSAT : GenericInstruction {
+  let OutOperandList = (outs type0:$dst);
+  let InOperandList = (ins type0:$src1, type0:$src2);
+  let hasSideEffects = false;
+  let isCommutable = true;
+}
+
+// Generic saturating signed addition.
+def G_SADDSAT : GenericInstruction {
+  let OutOperandList = (outs type0:$dst);
+  let InOperandList = (ins type0:$src1, type0:$src2);
+  let hasSideEffects = false;
+  let isCommutable = true;
+}
+
+// Generic saturating unsigned subtraction.
+def G_USUBSAT : GenericInstruction {
+  let OutOperandList = (outs type0:$dst);
+  let InOperandList = (ins type0:$src1, type0:$src2);
+  let hasSideEffects = false;
+  let isCommutable = false;
+}
+
+// Generic saturating signed subtraction.
+def G_SSUBSAT : GenericInstruction {
+  let OutOperandList = (outs type0:$dst);
+  let InOperandList = (ins type0:$src1, type0:$src2);
+  let hasSideEffects = false;
+  let isCommutable = false;
+}
+
+// Generic saturating unsigned left shift.
+def G_USHLSAT : GenericInstruction {
+  let OutOperandList = (outs type0:$dst);
+  let InOperandList = (ins type0:$src1, type1:$src2);
+  let hasSideEffects = false;
+  let isCommutable = false;
+}
+
+// Generic saturating signed left shift.
+def G_SSHLSAT : GenericInstruction {
+  let OutOperandList = (outs type0:$dst);
+  let InOperandList = (ins type0:$src1, type1:$src2);
+  let hasSideEffects = false;
+  let isCommutable = false;
+}
+
+/// RESULT = [US]MULFIX(LHS, RHS, SCALE) - Perform fixed point
+/// multiplication on 2 integers with the same width and scale. SCALE
+/// represents the scale of both operands as fixed point numbers. This
+/// SCALE parameter must be a constant integer. A scale of zero is
+/// effectively performing multiplication on 2 integers.
+def G_SMULFIX : GenericInstruction {
+  let OutOperandList = (outs type0:$dst);
+  let InOperandList = (ins type0:$src0, type0:$src1, untyped_imm_0:$scale);
+  let hasSideEffects = false;
+  let isCommutable = true;
+}
+
+def G_UMULFIX : GenericInstruction {
+  let OutOperandList = (outs type0:$dst);
+  let InOperandList = (ins type0:$src0, type0:$src1, untyped_imm_0:$scale);
+  let hasSideEffects = false;
+  let isCommutable = true;
+}
+
+/// Same as the corresponding unsaturated fixed point instructions, but the
+/// result is clamped between the min and max values representable by the
+/// bits of the first 2 operands.
+def G_SMULFIXSAT : GenericInstruction {
+  let OutOperandList = (outs type0:$dst);
+  let InOperandList = (ins type0:$src0, type0:$src1, untyped_imm_0:$scale);
+  let hasSideEffects = false;
+  let isCommutable = true;
+}
+
+def G_UMULFIXSAT : GenericInstruction {
+  let OutOperandList = (outs type0:$dst);
+  let InOperandList = (ins type0:$src0, type0:$src1, untyped_imm_0:$scale);
+  let hasSideEffects = false;
+  let isCommutable = true;
+}
+
+/// RESULT = [US]DIVFIX(LHS, RHS, SCALE) - Perform fixed point division on
+/// 2 integers with the same width and scale. SCALE represents the scale
+/// of both operands as fixed point numbers. This SCALE parameter must be a
+/// constant integer.
+def G_SDIVFIX : GenericInstruction {
+  let OutOperandList = (outs type0:$dst);
+  let InOperandList = (ins type0:$src0, type0:$src1, untyped_imm_0:$scale);
+  let hasSideEffects = false;
+  let isCommutable = false;
+}
+
+def G_UDIVFIX : GenericInstruction {
+  let OutOperandList = (outs type0:$dst);
+  let InOperandList = (ins type0:$src0, type0:$src1, untyped_imm_0:$scale);
+  let hasSideEffects = false;
+  let isCommutable = false;
+}
+
+/// Same as the corresponding unsaturated fixed point instructions,
+/// but the result is clamped between the min and max values
+/// representable by the bits of the first 2 operands.
+def G_SDIVFIXSAT : GenericInstruction {
+  let OutOperandList = (outs type0:$dst);
+  let InOperandList = (ins type0:$src0, type0:$src1, untyped_imm_0:$scale);
+  let hasSideEffects = false;
+  let isCommutable = false;
+}
+
+def G_UDIVFIXSAT : GenericInstruction {
+  let OutOperandList = (outs type0:$dst);
+  let InOperandList = (ins type0:$src0, type0:$src1, untyped_imm_0:$scale);
+  let hasSideEffects = false;
+  let isCommutable = false;
 }
 
 //------------------------------------------------------------------------------
@@ -448,61 +646,117 @@
 def G_FNEG : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type0:$src);
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
 }
 
 def G_FPEXT : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type1:$src);
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
 }
 
 def G_FPTRUNC : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type1:$src);
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
 }
 
 def G_FPTOSI : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type1:$src);
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
 }
 
 def G_FPTOUI : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type1:$src);
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
 }
 
 def G_SITOFP : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type1:$src);
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
 }
 
 def G_UITOFP : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type1:$src);
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
 }
 
 def G_FABS : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type0:$src);
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
 }
 
 def G_FCOPYSIGN : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type0:$src0, type1:$src1);
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
 }
 
 def G_FCANONICALIZE : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type0:$src);
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
+}
+
+// FMINNUM/FMAXNUM - Perform floating-point minimum or maximum on two
+// values.
+//
+// In the case where a single input is a NaN (either signaling or quiet),
+// the non-NaN input is returned.
+//
+// The return value of (FMINNUM 0.0, -0.0) could be either 0.0 or -0.0.
+def G_FMINNUM : GenericInstruction {
+  let OutOperandList = (outs type0:$dst);
+  let InOperandList = (ins type0:$src1, type0:$src2);
+  let hasSideEffects = false;
+  let isCommutable = true;
+}
+
+def G_FMAXNUM : GenericInstruction {
+  let OutOperandList = (outs type0:$dst);
+  let InOperandList = (ins type0:$src1, type0:$src2);
+  let hasSideEffects = false;
+  let isCommutable = true;
+}
+
+// FMINNUM_IEEE/FMAXNUM_IEEE - Perform floating-point minimum or maximum on
+// two values, following the IEEE-754 2008 definition. This differs from
+// FMINNUM/FMAXNUM in the handling of signaling NaNs. If one input is a
+// signaling NaN, returns a quiet NaN.
+def G_FMINNUM_IEEE : GenericInstruction {
+  let OutOperandList = (outs type0:$dst);
+  let InOperandList = (ins type0:$src1, type0:$src2);
+  let hasSideEffects = false;
+  let isCommutable = true;
+}
+
+def G_FMAXNUM_IEEE : GenericInstruction {
+  let OutOperandList = (outs type0:$dst);
+  let InOperandList = (ins type0:$src1, type0:$src2);
+  let hasSideEffects = false;
+  let isCommutable = true;
+}
+
+// FMINIMUM/FMAXIMUM - NaN-propagating minimum/maximum that also treat -0.0
+// as less than 0.0. While FMINNUM_IEEE/FMAXNUM_IEEE follow IEEE 754-2008
+// semantics, FMINIMUM/FMAXIMUM follow IEEE 754-2018 draft semantics.
+def G_FMINIMUM : GenericInstruction {
+  let OutOperandList = (outs type0:$dst);
+  let InOperandList = (ins type0:$src1, type0:$src2);
+  let hasSideEffects = false;
+  let isCommutable = true;
+}
+
+def G_FMAXIMUM : GenericInstruction {
+  let OutOperandList = (outs type0:$dst);
+  let InOperandList = (ins type0:$src1, type0:$src2);
+  let hasSideEffects = false;
+  let isCommutable = true;
 }
 
 //------------------------------------------------------------------------------
@@ -513,24 +767,24 @@
 def G_FADD : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type0:$src1, type0:$src2);
-  let hasSideEffects = 0;
-  let isCommutable = 1;
+  let hasSideEffects = false;
+  let isCommutable = true;
 }
 
 // Generic FP subtraction.
 def G_FSUB : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type0:$src1, type0:$src2);
-  let hasSideEffects = 0;
-  let isCommutable = 0;
+  let hasSideEffects = false;
+  let isCommutable = false;
 }
 
 // Generic FP multiplication.
 def G_FMUL : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type0:$src1, type0:$src2);
-  let hasSideEffects = 0;
-  let isCommutable = 1;
+  let hasSideEffects = false;
+  let isCommutable = true;
 }
 
 // Generic fused multiply-add instruction.
@@ -538,85 +792,101 @@
 def G_FMA : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type0:$src1, type0:$src2, type0:$src3);
-  let hasSideEffects = 0;
-  let isCommutable = 0;
+  let hasSideEffects = false;
+  let isCommutable = false;
+}
+
+/// Generic FP multiply and add. Perform a * b + c, while getting the
+/// same result as the separately rounded operations, unlike G_FMA.
+def G_FMAD : GenericInstruction {
+  let OutOperandList = (outs type0:$dst);
+  let InOperandList = (ins type0:$src1, type0:$src2, type0:$src3);
+  let hasSideEffects = false;
+  let isCommutable = false;
 }
 
 // Generic FP division.
 def G_FDIV : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type0:$src1, type0:$src2);
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
 }
 
 // Generic FP remainder.
 def G_FREM : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type0:$src1, type0:$src2);
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
 }
 
 // Floating point exponentiation.
 def G_FPOW : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type0:$src1, type0:$src2);
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
+}
+
+// Floating point exponentiation, with an integer power.
+def G_FPOWI : GenericInstruction {
+  let OutOperandList = (outs type0:$dst);
+  let InOperandList = (ins type0:$src0, type1:$src1);
+  let hasSideEffects = false;
 }
 
 // Floating point base-e exponential of a value.
 def G_FEXP : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type0:$src1);
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
 }
 
 // Floating point base-2 exponential of a value.
 def G_FEXP2 : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type0:$src1);
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
 }
 
-// Floating point base-2 logarithm of a value.
+// Floating point base-e logarithm of a value.
 def G_FLOG : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type0:$src1);
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
 }
 
 // Floating point base-2 logarithm of a value.
 def G_FLOG2 : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type0:$src1);
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
 }
 
 // Floating point base-10 logarithm of a value.
 def G_FLOG10 : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type0:$src1);
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
 }
 
 // Floating point ceiling of a value.
 def G_FCEIL : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type0:$src1);
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
 }
 
 // Floating point cosine of a value.
 def G_FCOS : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type0:$src1);
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
 }
 
 // Floating point sine of a value.
 def G_FSIN : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type0:$src1);
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
 }
 
 // Floating point square root of a value.
@@ -626,28 +896,28 @@
 def G_FSQRT : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type0:$src1);
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
 }
 
 // Floating point floor of a value.
 def G_FFLOOR : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type0:$src1);
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
 }
 
 // Floating point round to next integer.
 def G_FRINT : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type0:$src1);
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
 }
 
 // Floating point round to the nearest integer.
 def G_FNEARBYINT : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type0:$src1);
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
 }
 
 //------------------------------------------------------------------------------
@@ -656,49 +926,106 @@
 def G_INTRINSIC_TRUNC : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type0:$src1);
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
 }
 
 def G_INTRINSIC_ROUND : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type0:$src1);
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
+}
+
+def G_INTRINSIC_LRINT : GenericInstruction {
+  let OutOperandList = (outs type0:$dst);
+  let InOperandList = (ins type1:$src);
+  let hasSideEffects = false;
+}
+
+def G_INTRINSIC_ROUNDEVEN : GenericInstruction {
+  let OutOperandList = (outs type0:$dst);
+  let InOperandList = (ins type0:$src1);
+  let hasSideEffects = false;
+}
+
+def G_READCYCLECOUNTER : GenericInstruction {
+  let OutOperandList = (outs type0:$dst);
+  let InOperandList = (ins);
+  let hasSideEffects = true;
 }
 
 //------------------------------------------------------------------------------
 // Memory ops
 //------------------------------------------------------------------------------
 
-// Generic load. Expects a MachineMemOperand in addition to explicit operands.
+// Generic load. Expects a MachineMemOperand in addition to explicit
+// operands. If the result size is larger than the memory size, the
+// high bits are undefined. If the result is a vector type and larger
+// than the memory size, the high elements are undefined (i.e. this is
+// not a per-element, vector anyextload)
 def G_LOAD : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins ptype1:$addr);
-  let hasSideEffects = 0;
-  let mayLoad = 1;
+  let hasSideEffects = false;
+  let mayLoad = true;
 }
 
 // Generic sign-extended load. Expects a MachineMemOperand in addition to explicit operands.
 def G_SEXTLOAD : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins ptype1:$addr);
-  let hasSideEffects = 0;
-  let mayLoad = 1;
+  let hasSideEffects = false;
+  let mayLoad = true;
 }
 
 // Generic zero-extended load. Expects a MachineMemOperand in addition to explicit operands.
 def G_ZEXTLOAD : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins ptype1:$addr);
-  let hasSideEffects = 0;
-  let mayLoad = 1;
+  let hasSideEffects = false;
+  let mayLoad = true;
+}
+
+// Generic indexed load. Combines a GEP with a load. $newaddr is set to $base + $offset.
+// If $am is 0 (post-indexed), then the value is loaded from $base; if $am is 1 (pre-indexed)
+//  then the value is loaded from $newaddr.
+def G_INDEXED_LOAD : GenericInstruction {
+  let OutOperandList = (outs type0:$dst, ptype1:$newaddr);
+  let InOperandList = (ins ptype1:$base, type2:$offset, unknown:$am);
+  let hasSideEffects = false;
+  let mayLoad = true;
+}
+
+// Same as G_INDEXED_LOAD except that the load performed is sign-extending, as with G_SEXTLOAD.
+def G_INDEXED_SEXTLOAD : GenericInstruction {
+  let OutOperandList = (outs type0:$dst, ptype1:$newaddr);
+  let InOperandList = (ins ptype1:$base, type2:$offset, unknown:$am);
+  let hasSideEffects = false;
+  let mayLoad = true;
+}
+
+// Same as G_INDEXED_LOAD except that the load performed is zero-extending, as with G_ZEXTLOAD.
+def G_INDEXED_ZEXTLOAD : GenericInstruction {
+  let OutOperandList = (outs type0:$dst, ptype1:$newaddr);
+  let InOperandList = (ins ptype1:$base, type2:$offset, unknown:$am);
+  let hasSideEffects = false;
+  let mayLoad = true;
 }
 
 // Generic store. Expects a MachineMemOperand in addition to explicit operands.
 def G_STORE : GenericInstruction {
   let OutOperandList = (outs);
   let InOperandList = (ins type0:$src, ptype1:$addr);
-  let hasSideEffects = 0;
-  let mayStore = 1;
+  let hasSideEffects = false;
+  let mayStore = true;
+}
+
+// Combines a store with a GEP. See description of G_INDEXED_LOAD for indexing behaviour.
+def G_INDEXED_STORE : GenericInstruction {
+  let OutOperandList = (outs ptype0:$newaddr);
+  let InOperandList = (ins type1:$src, ptype0:$base, ptype2:$offset,
+                           unknown:$am);
+  let hasSideEffects = false;
+  let mayStore = true;
 }
 
 // Generic atomic cmpxchg with internal success check. Expects a
@@ -706,9 +1033,9 @@
 def G_ATOMIC_CMPXCHG_WITH_SUCCESS : GenericInstruction {
   let OutOperandList = (outs type0:$oldval, type1:$success);
   let InOperandList = (ins type2:$addr, type0:$cmpval, type0:$newval);
-  let hasSideEffects = 0;
-  let mayLoad = 1;
-  let mayStore = 1;
+  let hasSideEffects = false;
+  let mayLoad = true;
+  let mayStore = true;
 }
 
 // Generic atomic cmpxchg. Expects a MachineMemOperand in addition to explicit
@@ -716,9 +1043,9 @@
 def G_ATOMIC_CMPXCHG : GenericInstruction {
   let OutOperandList = (outs type0:$oldval);
   let InOperandList = (ins ptype1:$addr, type0:$cmpval, type0:$newval);
-  let hasSideEffects = 0;
-  let mayLoad = 1;
-  let mayStore = 1;
+  let hasSideEffects = false;
+  let mayLoad = true;
+  let mayStore = true;
 }
 
 // Generic atomicrmw. Expects a MachineMemOperand in addition to explicit
@@ -726,9 +1053,9 @@
 class G_ATOMICRMW_OP : GenericInstruction {
   let OutOperandList = (outs type0:$oldval);
   let InOperandList = (ins ptype1:$addr, type0:$val);
-  let hasSideEffects = 0;
-  let mayLoad = 1;
-  let mayStore = 1;
+  let hasSideEffects = false;
+  let mayLoad = true;
+  let mayStore = true;
 }
 
 def G_ATOMICRMW_XCHG : G_ATOMICRMW_OP;
@@ -742,11 +1069,13 @@
 def G_ATOMICRMW_MIN : G_ATOMICRMW_OP;
 def G_ATOMICRMW_UMAX : G_ATOMICRMW_OP;
 def G_ATOMICRMW_UMIN : G_ATOMICRMW_OP;
+def G_ATOMICRMW_FADD : G_ATOMICRMW_OP;
+def G_ATOMICRMW_FSUB : G_ATOMICRMW_OP;
 
 def G_FENCE : GenericInstruction {
   let OutOperandList = (outs);
   let InOperandList = (ins i32imm:$ordering, i32imm:$scope);
-  let hasSideEffects = 1;
+  let hasSideEffects = true;
 }
 
 //------------------------------------------------------------------------------
@@ -758,8 +1087,8 @@
 // register banks have been selected.
 def G_EXTRACT : GenericInstruction {
   let OutOperandList = (outs type0:$res);
-  let InOperandList = (ins type1:$src, unknown:$offset);
-  let hasSideEffects = 0;
+  let InOperandList = (ins type1:$src, untyped_imm_0:$offset);
+  let hasSideEffects = false;
 }
 
 // Extract multiple registers specified size, starting from blocks given by
@@ -771,14 +1100,14 @@
 def G_UNMERGE_VALUES : GenericInstruction {
   let OutOperandList = (outs type0:$dst0, variable_ops);
   let InOperandList = (ins type1:$src);
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
 }
 
 // Insert a smaller register into a larger one at the specified bit-index.
 def G_INSERT : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
-  let InOperandList = (ins type0:$src, type1:$op, unknown:$offset);
-  let hasSideEffects = 0;
+  let InOperandList = (ins type0:$src, type1:$op, untyped_imm_0:$offset);
+  let hasSideEffects = false;
 }
 
 // Concatenate multiple registers of the same size into a wider register.
@@ -788,7 +1117,7 @@
 def G_MERGE_VALUES : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type1:$src0, variable_ops);
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
 }
 
 /// Create a vector from multiple scalar registers. No implicit
@@ -797,7 +1126,7 @@
 def G_BUILD_VECTOR : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type1:$src0, variable_ops);
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
 }
 
 /// Like G_BUILD_VECTOR, but truncates the larger operand types to fit the
@@ -805,30 +1134,38 @@
 def G_BUILD_VECTOR_TRUNC : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type1:$src0, variable_ops);
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
 }
 
 /// Create a vector by concatenating vectors together.
 def G_CONCAT_VECTORS : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type1:$src0, variable_ops);
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
 }
 
 // Intrinsic without side effects.
 def G_INTRINSIC : GenericInstruction {
   let OutOperandList = (outs);
   let InOperandList = (ins unknown:$intrin, variable_ops);
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
+
+  // Conservatively assume this is convergent. If there turnes out to
+  // be a need, there should be separate convergent intrinsic opcodes.
+  let isConvergent = 1;
 }
 
 // Intrinsic with side effects.
 def G_INTRINSIC_W_SIDE_EFFECTS : GenericInstruction {
   let OutOperandList = (outs);
   let InOperandList = (ins unknown:$intrin, variable_ops);
-  let hasSideEffects = 1;
-  let mayLoad = 1;
-  let mayStore = 1;
+  let hasSideEffects = true;
+  let mayLoad = true;
+  let mayStore = true;
+
+  // Conservatively assume this is convergent. If there turnes out to
+  // be a need, there should be separate convergent intrinsic opcodes.
+  let isConvergent = true;
 }
 
 //------------------------------------------------------------------------------
@@ -839,37 +1176,61 @@
 def G_BR : GenericInstruction {
   let OutOperandList = (outs);
   let InOperandList = (ins unknown:$src1);
-  let hasSideEffects = 0;
-  let isBranch = 1;
-  let isTerminator = 1;
-  let isBarrier = 1;
+  let hasSideEffects = false;
+  let isBranch = true;
+  let isTerminator = true;
+  let isBarrier = true;
 }
 
 // Generic conditional branch.
 def G_BRCOND : GenericInstruction {
   let OutOperandList = (outs);
   let InOperandList = (ins type0:$tst, unknown:$truebb);
-  let hasSideEffects = 0;
-  let isBranch = 1;
-  let isTerminator = 1;
+  let hasSideEffects = false;
+  let isBranch = true;
+  let isTerminator = true;
 }
 
 // Generic indirect branch.
 def G_BRINDIRECT : GenericInstruction {
   let OutOperandList = (outs);
   let InOperandList = (ins type0:$src1);
-  let hasSideEffects = 0;
-  let isBranch = 1;
-  let isTerminator = 1;
+  let hasSideEffects = false;
+  let isBranch = true;
+  let isTerminator = true;
+  let isBarrier = true;
+  let isIndirectBranch = true;
 }
 
 // Generic branch to jump table entry
 def G_BRJT : GenericInstruction {
   let OutOperandList = (outs);
   let InOperandList = (ins ptype0:$tbl, unknown:$jti, type1:$idx);
-  let hasSideEffects = 0;
-  let isBranch = 1;
-  let isTerminator = 1;
+  let hasSideEffects = false;
+  let isBranch = true;
+  let isTerminator = true;
+  let isBarrier = true;
+  let isIndirectBranch = true;
+}
+
+def G_READ_REGISTER : GenericInstruction {
+  let OutOperandList = (outs type0:$dst);
+  let InOperandList = (ins unknown:$register);
+  let hasSideEffects = true;
+
+  // Assume convergent. It's probably not worth the effort of somehow
+  // modeling convergent and nonconvergent register accesses.
+  let isConvergent = true;
+}
+
+def G_WRITE_REGISTER : GenericInstruction {
+  let OutOperandList = (outs);
+  let InOperandList = (ins unknown:$register, type0:$value);
+  let hasSideEffects = true;
+
+  // Assume convergent. It's probably not worth the effort of somehow
+  // modeling convergent and nonconvergent register accesses.
+  let isConvergent = true;
 }
 
 //------------------------------------------------------------------------------
@@ -880,21 +1241,99 @@
 def G_INSERT_VECTOR_ELT : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type0:$src, type1:$elt, type2:$idx);
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
 }
 
 // Generic extractelement.
 def G_EXTRACT_VECTOR_ELT : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type1:$src, type2:$idx);
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
 }
 
 // Generic shufflevector.
+//
+// The mask operand should be an IR Constant which exactly matches the
+// corresponding mask for the IR shufflevector instruction.
 def G_SHUFFLE_VECTOR: GenericInstruction {
   let OutOperandList = (outs type0:$dst);
-  let InOperandList = (ins type1:$v1, type1:$v2, type2:$mask);
-  let hasSideEffects = 0;
+  let InOperandList = (ins type1:$v1, type1:$v2, unknown:$mask);
+  let hasSideEffects = false;
 }
 
-// TODO: Add the other generic opcodes.
+//------------------------------------------------------------------------------
+// Vector reductions
+//------------------------------------------------------------------------------
+
+class VectorReduction : GenericInstruction {
+  let OutOperandList = (outs type0:$dst);
+  let InOperandList = (ins type1:$v);
+  let hasSideEffects = false;
+}
+
+def G_VECREDUCE_SEQ_FADD : GenericInstruction {
+  let OutOperandList = (outs type0:$dst);
+  let InOperandList = (ins type1:$acc, type2:$v);
+  let hasSideEffects = false;
+}
+
+def G_VECREDUCE_SEQ_FMUL : GenericInstruction {
+  let OutOperandList = (outs type0:$dst);
+  let InOperandList = (ins type1:$acc, type2:$v);
+  let hasSideEffects = false;
+}
+
+def G_VECREDUCE_FADD : VectorReduction;
+def G_VECREDUCE_FMUL : VectorReduction;
+
+def G_VECREDUCE_FMAX : VectorReduction;
+def G_VECREDUCE_FMIN : VectorReduction;
+
+def G_VECREDUCE_ADD : VectorReduction;
+def G_VECREDUCE_MUL : VectorReduction;
+def G_VECREDUCE_AND : VectorReduction;
+def G_VECREDUCE_OR : VectorReduction;
+def G_VECREDUCE_XOR : VectorReduction;
+def G_VECREDUCE_SMAX : VectorReduction;
+def G_VECREDUCE_SMIN : VectorReduction;
+def G_VECREDUCE_UMAX : VectorReduction;
+def G_VECREDUCE_UMIN : VectorReduction;
+
+//------------------------------------------------------------------------------
+// Constrained floating point ops
+//------------------------------------------------------------------------------
+
+def G_STRICT_FADD : ConstrainedIntruction<G_FADD>;
+def G_STRICT_FSUB : ConstrainedIntruction<G_FSUB>;
+def G_STRICT_FMUL : ConstrainedIntruction<G_FMUL>;
+def G_STRICT_FDIV : ConstrainedIntruction<G_FDIV>;
+def G_STRICT_FREM : ConstrainedIntruction<G_FREM>;
+def G_STRICT_FMA : ConstrainedIntruction<G_FMA>;
+def G_STRICT_FSQRT : ConstrainedIntruction<G_FSQRT>;
+
+//------------------------------------------------------------------------------
+// Memory intrinsics
+//------------------------------------------------------------------------------
+
+def G_MEMCPY : GenericInstruction {
+  let OutOperandList = (outs);
+  let InOperandList = (ins ptype0:$dst_addr, ptype1:$src_addr, type2:$size, untyped_imm_0:$tailcall);
+  let hasSideEffects = false;
+  let mayLoad = true;
+  let mayStore = true;
+}
+
+def G_MEMMOVE : GenericInstruction {
+  let OutOperandList = (outs);
+  let InOperandList = (ins ptype0:$dst_addr, ptype1:$src_addr, type2:$size, untyped_imm_0:$tailcall);
+  let hasSideEffects = false;
+  let mayLoad = true;
+  let mayStore = true;
+}
+
+def G_MEMSET : GenericInstruction {
+  let OutOperandList = (outs);
+  let InOperandList = (ins ptype0:$dst_addr, type1:$value, type2:$size, untyped_imm_0:$tailcall);
+  let hasSideEffects = false;
+  let mayStore = true;
+}
diff --git a/linux-x64/clang/include/llvm/Target/GlobalISel/Combine.td b/linux-x64/clang/include/llvm/Target/GlobalISel/Combine.td
new file mode 100644
index 0000000..e352e49
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Target/GlobalISel/Combine.td
@@ -0,0 +1,590 @@
+//===- Combine.td - Combine rule definitions ---------------*- tablegen -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Declare GlobalISel combine rules and provide mechanisms to opt-out.
+//
+//===----------------------------------------------------------------------===//
+
+// Common base class for GICombineRule and GICombineGroup.
+class GICombine {
+  // See GICombineGroup. We only declare it here to make the tablegen pass
+  // simpler.
+  list<GICombine> Rules = ?;
+}
+
+// A group of combine rules that can be added to a GICombiner or another group.
+class GICombineGroup<list<GICombine> rules> : GICombine {
+  // The rules contained in this group. The rules in a group are flattened into
+  // a single list and sorted into whatever order is most efficient. However,
+  // they will never be re-ordered such that behaviour differs from the
+  // specified order. It is therefore possible to use the order of rules in this
+  // list to describe priorities.
+  let Rules = rules;
+}
+
+class GICombinerHelperArg<string type, string name> {
+  string Type = type;
+  string Name = name;
+}
+
+// Declares a combiner helper class
+class GICombinerHelper<string classname, list<GICombine> rules>
+    : GICombineGroup<rules> {
+  // The class name to use in the generated output.
+  string Classname = classname;
+  // The name of a run-time compiler option that will be generated to disable
+  // specific rules within this combiner.
+  string DisableRuleOption = ?;
+  // The state class to inherit from (if any). The generated helper will inherit
+  // from this class and will forward arguments to its constructors.
+  string StateClass = "";
+  // Any additional arguments that should be appended to the tryCombine*().
+  list<GICombinerHelperArg> AdditionalArguments =
+      [GICombinerHelperArg<"CombinerHelper &", "Helper">];
+}
+class GICombineRule<dag defs, dag match, dag apply> : GICombine {
+  /// Defines the external interface of the match rule. This includes:
+  /// * The names of the root nodes (requires at least one)
+  /// See GIDefKind for details.
+  dag Defs = defs;
+
+  /// Defines the things which must be true for the pattern to match
+  /// See GIMatchKind for details.
+  dag Match = match;
+
+  /// Defines the things which happen after the decision is made to apply a
+  /// combine rule.
+  /// See GIApplyKind for details.
+  dag Apply = apply;
+}
+
+/// The operator at the root of a GICombineRule.Defs dag.
+def defs;
+
+/// All arguments of the defs operator must be subclasses of GIDefKind or
+/// sub-dags whose operator is GIDefKindWithArgs.
+class GIDefKind;
+class GIDefKindWithArgs;
+/// Declare a root node. There must be at least one of these in every combine
+/// rule.
+/// TODO: The plan is to elide `root` definitions and determine it from the DAG
+///       itself with an overide for situations where the usual determination
+///       is incorrect.
+def root : GIDefKind;
+
+/// Declares data that is passed from the match stage to the apply stage.
+class GIDefMatchData<string type> : GIDefKind {
+  /// A C++ type name indicating the storage type.
+  string Type = type;
+}
+
+def extending_load_matchdata : GIDefMatchData<"PreferredTuple">;
+def indexed_load_store_matchdata : GIDefMatchData<"IndexedLoadStoreMatchInfo">;
+def instruction_steps_matchdata: GIDefMatchData<"InstructionStepsMatchInfo">;
+
+/// The operator at the root of a GICombineRule.Match dag.
+def match;
+/// All arguments of the match operator must be either:
+/// * A subclass of GIMatchKind
+/// * A subclass of GIMatchKindWithArgs
+/// * A subclass of Instruction
+/// * A MIR code block (deprecated)
+/// The GIMatchKind and GIMatchKindWithArgs cases are described in more detail
+/// in their definitions below.
+/// For the Instruction case, these are collected into a DAG where operand names
+/// that occur multiple times introduce edges.
+class GIMatchKind;
+class GIMatchKindWithArgs;
+
+/// In lieu of having proper macro support. Trivial one-off opcode checks can be
+/// performed with this.
+def wip_match_opcode : GIMatchKindWithArgs;
+
+/// The operator at the root of a GICombineRule.Apply dag.
+def apply;
+/// All arguments of the apply operator must be subclasses of GIApplyKind, or
+/// sub-dags whose operator is GIApplyKindWithArgs, or an MIR block
+/// (deprecated).
+class GIApplyKind;
+class GIApplyKindWithArgs;
+
+def copy_prop : GICombineRule<
+  (defs root:$d),
+  (match (COPY $d, $s):$mi,
+         [{ return Helper.matchCombineCopy(*${mi}); }]),
+  (apply [{ Helper.applyCombineCopy(*${mi}); }])>;
+
+def extending_loads : GICombineRule<
+  (defs root:$root, extending_load_matchdata:$matchinfo),
+  (match (wip_match_opcode G_LOAD, G_SEXTLOAD, G_ZEXTLOAD):$root,
+         [{ return Helper.matchCombineExtendingLoads(*${root}, ${matchinfo}); }]),
+  (apply [{ Helper.applyCombineExtendingLoads(*${root}, ${matchinfo}); }])>;
+def combines_for_extload: GICombineGroup<[extending_loads]>;
+
+def sext_trunc_sextload : GICombineRule<
+  (defs root:$d),
+  (match (wip_match_opcode G_SEXT_INREG):$d,
+         [{ return Helper.matchSextTruncSextLoad(*${d}); }]),
+  (apply [{ Helper.applySextTruncSextLoad(*${d}); }])>;
+
+def sext_inreg_of_load_matchdata : GIDefMatchData<"std::tuple<Register, unsigned>">;
+def sext_inreg_of_load : GICombineRule<
+  (defs root:$root, sext_inreg_of_load_matchdata:$matchinfo),
+  (match (wip_match_opcode G_SEXT_INREG):$root,
+         [{ return Helper.matchSextInRegOfLoad(*${root}, ${matchinfo}); }]),
+  (apply [{ return Helper.applySextInRegOfLoad(*${root}, ${matchinfo}); }])>;
+
+def combine_indexed_load_store : GICombineRule<
+  (defs root:$root, indexed_load_store_matchdata:$matchinfo),
+  (match (wip_match_opcode G_LOAD, G_SEXTLOAD, G_ZEXTLOAD, G_STORE):$root,
+         [{ return Helper.matchCombineIndexedLoadStore(*${root}, ${matchinfo}); }]),
+  (apply [{ Helper.applyCombineIndexedLoadStore(*${root}, ${matchinfo}); }])>;
+
+def opt_brcond_by_inverting_cond : GICombineRule<
+  (defs root:$root),
+  (match (wip_match_opcode G_BR):$root,
+         [{ return Helper.matchOptBrCondByInvertingCond(*${root}); }]),
+  (apply [{ Helper.applyOptBrCondByInvertingCond(*${root}); }])>;
+
+def ptr_add_immed_matchdata : GIDefMatchData<"PtrAddChain">;
+def ptr_add_immed_chain : GICombineRule<
+  (defs root:$d, ptr_add_immed_matchdata:$matchinfo),
+  (match (wip_match_opcode G_PTR_ADD):$d,
+         [{ return Helper.matchPtrAddImmedChain(*${d}, ${matchinfo}); }]),
+  (apply [{ Helper.applyPtrAddImmedChain(*${d}, ${matchinfo}); }])>;
+
+// Fold shift (shift base x), y -> shift base, (x+y), if shifts are same
+def shift_immed_matchdata : GIDefMatchData<"RegisterImmPair">;
+def shift_immed_chain : GICombineRule<
+  (defs root:$d, shift_immed_matchdata:$matchinfo),
+  (match (wip_match_opcode G_SHL, G_ASHR, G_LSHR, G_SSHLSAT, G_USHLSAT):$d,
+         [{ return Helper.matchShiftImmedChain(*${d}, ${matchinfo}); }]),
+  (apply [{ Helper.applyShiftImmedChain(*${d}, ${matchinfo}); }])>;
+
+// Transform shift (logic (shift X, C0), Y), C1
+//        -> logic (shift X, (C0+C1)), (shift Y, C1), if shifts are same
+def shift_of_shifted_logic_matchdata : GIDefMatchData<"ShiftOfShiftedLogic">;
+def shift_of_shifted_logic_chain : GICombineRule<
+  (defs root:$d, shift_of_shifted_logic_matchdata:$matchinfo),
+  (match (wip_match_opcode G_SHL, G_ASHR, G_LSHR, G_USHLSAT, G_SSHLSAT):$d,
+         [{ return Helper.matchShiftOfShiftedLogic(*${d}, ${matchinfo}); }]),
+  (apply [{ Helper.applyShiftOfShiftedLogic(*${d}, ${matchinfo}); }])>;
+
+def mul_to_shl_matchdata : GIDefMatchData<"unsigned">;
+def mul_to_shl : GICombineRule<
+  (defs root:$d, mul_to_shl_matchdata:$matchinfo),
+  (match (G_MUL $d, $op1, $op2):$mi,
+         [{ return Helper.matchCombineMulToShl(*${mi}, ${matchinfo}); }]),
+  (apply [{ Helper.applyCombineMulToShl(*${mi}, ${matchinfo}); }])>;
+
+// shl ([asz]ext x), y => zext (shl x, y), if shift does not overflow int
+def reduce_shl_of_extend_matchdata : GIDefMatchData<"RegisterImmPair">;
+def reduce_shl_of_extend : GICombineRule<
+  (defs root:$dst, reduce_shl_of_extend_matchdata:$matchinfo),
+  (match (G_SHL $dst, $src0, $src1):$mi,
+         [{ return Helper.matchCombineShlOfExtend(*${mi}, ${matchinfo}); }]),
+  (apply [{ Helper.applyCombineShlOfExtend(*${mi}, ${matchinfo}); }])>;
+
+// [us]itofp(undef) = 0, because the result value is bounded.
+def undef_to_fp_zero : GICombineRule<
+  (defs root:$root),
+  (match (wip_match_opcode G_UITOFP, G_SITOFP):$root,
+         [{ return Helper.matchAnyExplicitUseIsUndef(*${root}); }]),
+  (apply [{ Helper.replaceInstWithFConstant(*${root}, 0.0); }])>;
+
+def undef_to_int_zero: GICombineRule<
+  (defs root:$root),
+  (match (wip_match_opcode G_AND, G_MUL):$root,
+         [{ return Helper.matchAnyExplicitUseIsUndef(*${root}); }]),
+  (apply [{ Helper.replaceInstWithConstant(*${root}, 0); }])>;
+
+def undef_to_negative_one: GICombineRule<
+  (defs root:$root),
+  (match (wip_match_opcode G_OR):$root,
+         [{ return Helper.matchAnyExplicitUseIsUndef(*${root}); }]),
+  (apply [{ Helper.replaceInstWithConstant(*${root}, -1); }])>;
+
+def binop_left_undef_to_zero: GICombineRule<
+  (defs root:$root),
+  (match (wip_match_opcode G_SHL):$root,
+         [{ return Helper.matchOperandIsUndef(*${root}, 1); }]),
+  (apply [{ Helper.replaceInstWithConstant(*${root}, 0); }])>;
+
+// Instructions where if any source operand is undef, the instruction can be
+// replaced with undef.
+def propagate_undef_any_op: GICombineRule<
+  (defs root:$root),
+  (match (wip_match_opcode G_ADD, G_FPTOSI, G_FPTOUI, G_SUB, G_XOR, G_TRUNC):$root,
+         [{ return Helper.matchAnyExplicitUseIsUndef(*${root}); }]),
+  (apply [{ Helper.replaceInstWithUndef(*${root}); }])>;
+
+// Instructions where if all source operands are undef, the instruction can be
+// replaced with undef.
+def propagate_undef_all_ops: GICombineRule<
+  (defs root:$root),
+  (match (wip_match_opcode G_SHUFFLE_VECTOR):$root,
+          [{ return Helper.matchAllExplicitUsesAreUndef(*${root}); }]),
+  (apply [{ Helper.replaceInstWithUndef(*${root}); }])>;
+
+// Replace a G_SHUFFLE_VECTOR with an undef mask with a G_IMPLICIT_DEF.
+def propagate_undef_shuffle_mask: GICombineRule<
+  (defs root:$root),
+  (match (wip_match_opcode G_SHUFFLE_VECTOR):$root,
+         [{ return Helper.matchUndefShuffleVectorMask(*${root}); }]),
+  (apply [{ Helper.replaceInstWithUndef(*${root}); }])>;
+
+// Fold (cond ? x : x) -> x
+def select_same_val: GICombineRule<
+  (defs root:$root),
+  (match (wip_match_opcode G_SELECT):$root,
+    [{ return Helper.matchSelectSameVal(*${root}); }]),
+  (apply [{ return Helper.replaceSingleDefInstWithOperand(*${root}, 2); }])
+>;
+
+// Fold (undef ? x : y) -> y
+def select_undef_cmp: GICombineRule<
+  (defs root:$root),
+  (match (wip_match_opcode G_SELECT):$root,
+    [{ return Helper.matchUndefSelectCmp(*${root}); }]),
+  (apply [{ return Helper.replaceSingleDefInstWithOperand(*${root}, 2); }])
+>;
+
+// Fold (true ? x : y) -> x
+// Fold (false ? x : y) -> y
+def select_constant_cmp_matchdata : GIDefMatchData<"unsigned">;
+def select_constant_cmp: GICombineRule<
+  (defs root:$root, select_constant_cmp_matchdata:$matchinfo),
+  (match (wip_match_opcode G_SELECT):$root,
+    [{ return Helper.matchConstantSelectCmp(*${root}, ${matchinfo}); }]),
+  (apply [{ return Helper.replaceSingleDefInstWithOperand(*${root}, ${matchinfo}); }])
+>;
+
+// Fold x op 0 -> x
+def right_identity_zero: GICombineRule<
+  (defs root:$root),
+  (match (wip_match_opcode G_SUB, G_ADD, G_OR, G_XOR, G_SHL, G_ASHR, G_LSHR):$root,
+    [{ return Helper.matchConstantOp(${root}->getOperand(2), 0); }]),
+  (apply [{ return Helper.replaceSingleDefInstWithOperand(*${root}, 1); }])
+>;
+
+// Fold x op 1 -> x
+def right_identity_one: GICombineRule<
+  (defs root:$root),
+  (match (wip_match_opcode G_MUL):$root,
+    [{ return Helper.matchConstantOp(${root}->getOperand(2), 1); }]),
+  (apply [{ return Helper.replaceSingleDefInstWithOperand(*${root}, 1); }])
+>;
+
+// Fold (x op x) - > x
+def binop_same_val: GICombineRule<
+  (defs root:$root),
+  (match (wip_match_opcode G_AND, G_OR):$root,
+    [{ return Helper.matchBinOpSameVal(*${root}); }]),
+  (apply [{ return Helper.replaceSingleDefInstWithOperand(*${root}, 1); }])
+>;
+
+// Fold (0 op x) - > 0
+def binop_left_to_zero: GICombineRule<
+  (defs root:$root),
+  (match (wip_match_opcode G_SDIV, G_UDIV, G_SREM, G_UREM):$root,
+    [{ return Helper.matchOperandIsZero(*${root}, 1); }]),
+  (apply [{ return Helper.replaceSingleDefInstWithOperand(*${root}, 1); }])
+>;
+
+def urem_pow2_to_mask : GICombineRule<
+  (defs root:$root),
+  (match (wip_match_opcode G_UREM):$root,
+    [{ return Helper.matchOperandIsKnownToBeAPowerOfTwo(*${root}, 2); }]),
+  (apply [{ return Helper.applySimplifyURemByPow2(*${root}); }])
+>;
+
+// Fold (x op 0) - > 0
+def binop_right_to_zero: GICombineRule<
+  (defs root:$root),
+  (match (wip_match_opcode G_MUL):$root,
+    [{ return Helper.matchOperandIsZero(*${root}, 2); }]),
+  (apply [{ return Helper.replaceSingleDefInstWithOperand(*${root}, 2); }])
+>;
+
+// Erase stores of undef values.
+def erase_undef_store : GICombineRule<
+  (defs root:$root),
+  (match (wip_match_opcode G_STORE):$root,
+    [{ return Helper.matchUndefStore(*${root}); }]),
+  (apply [{ return Helper.eraseInst(*${root}); }])
+>;
+
+def simplify_add_to_sub_matchinfo: GIDefMatchData<"std::tuple<Register, Register>">;
+def simplify_add_to_sub: GICombineRule <
+  (defs root:$root, simplify_add_to_sub_matchinfo:$info),
+  (match (wip_match_opcode G_ADD):$root,
+    [{ return Helper.matchSimplifyAddToSub(*${root}, ${info}); }]),
+  (apply [{ return Helper.applySimplifyAddToSub(*${root}, ${info});}])
+>;
+
+// Fold fp_op(cst) to the constant result of the floating point operation.
+def constant_fp_op_matchinfo: GIDefMatchData<"Optional<APFloat>">;
+def constant_fp_op: GICombineRule <
+  (defs root:$root, constant_fp_op_matchinfo:$info),
+  (match (wip_match_opcode G_FNEG, G_FABS, G_FPTRUNC, G_FSQRT, G_FLOG2):$root,
+    [{ return Helper.matchCombineConstantFoldFpUnary(*${root}, ${info}); }]),
+  (apply [{ return Helper.applyCombineConstantFoldFpUnary(*${root}, ${info}); }])
+>;
+
+// Fold int2ptr(ptr2int(x)) -> x
+def p2i_to_i2p_matchinfo: GIDefMatchData<"Register">;
+def p2i_to_i2p: GICombineRule<
+  (defs root:$root, p2i_to_i2p_matchinfo:$info),
+  (match (wip_match_opcode G_INTTOPTR):$root,
+    [{ return Helper.matchCombineI2PToP2I(*${root}, ${info}); }]),
+  (apply [{ return Helper.applyCombineI2PToP2I(*${root}, ${info}); }])
+>;
+
+// Fold ptr2int(int2ptr(x)) -> x
+def i2p_to_p2i_matchinfo: GIDefMatchData<"Register">;
+def i2p_to_p2i: GICombineRule<
+  (defs root:$root, i2p_to_p2i_matchinfo:$info),
+  (match (wip_match_opcode G_PTRTOINT):$root,
+    [{ return Helper.matchCombineP2IToI2P(*${root}, ${info}); }]),
+  (apply [{ return Helper.applyCombineP2IToI2P(*${root}, ${info}); }])
+>;
+
+// Fold add ptrtoint(x), y -> ptrtoint (ptr_add x), y
+def add_p2i_to_ptradd_matchinfo : GIDefMatchData<"std::pair<Register, bool>">;
+def add_p2i_to_ptradd : GICombineRule<
+  (defs root:$root, add_p2i_to_ptradd_matchinfo:$info),
+  (match (wip_match_opcode G_ADD):$root,
+    [{ return Helper.matchCombineAddP2IToPtrAdd(*${root}, ${info}); }]),
+  (apply [{ return Helper.applyCombineAddP2IToPtrAdd(*${root}, ${info}); }])
+>;
+
+// Fold (ptr_add (int2ptr C1), C2) -> C1 + C2
+def const_ptradd_to_i2p_matchinfo : GIDefMatchData<"int64_t">;
+def const_ptradd_to_i2p: GICombineRule<
+  (defs root:$root, const_ptradd_to_i2p_matchinfo:$info),
+  (match (wip_match_opcode G_PTR_ADD):$root,
+    [{ return Helper.matchCombineConstPtrAddToI2P(*${root}, ${info}); }]),
+  (apply [{ return Helper.applyCombineConstPtrAddToI2P(*${root}, ${info}); }])
+>;
+
+// Simplify: (logic_op (op x...), (op y...)) -> (op (logic_op x, y))
+def hoist_logic_op_with_same_opcode_hands: GICombineRule <
+  (defs root:$root, instruction_steps_matchdata:$info),
+  (match (wip_match_opcode G_AND, G_OR, G_XOR):$root,
+    [{ return Helper.matchHoistLogicOpWithSameOpcodeHands(*${root}, ${info}); }]),
+  (apply [{ return Helper.applyBuildInstructionSteps(*${root}, ${info});}])
+>;
+
+// Fold ashr (shl x, C), C -> sext_inreg (C)
+def shl_ashr_to_sext_inreg_matchinfo : GIDefMatchData<"std::tuple<Register, int64_t>">;
+def shl_ashr_to_sext_inreg : GICombineRule<
+  (defs root:$root, shl_ashr_to_sext_inreg_matchinfo:$info),
+  (match (wip_match_opcode G_ASHR): $root,
+    [{ return Helper.matchAshrShlToSextInreg(*${root}, ${info}); }]),
+  (apply [{ return Helper.applyAshShlToSextInreg(*${root}, ${info});}])
+>;
+// Fold (x & y) -> x or (x & y) -> y when (x & y) is known to equal x or equal y.
+def redundant_and_matchinfo : GIDefMatchData<"Register">;
+def redundant_and: GICombineRule <
+  (defs root:$root, redundant_and_matchinfo:$matchinfo),
+  (match (wip_match_opcode G_AND):$root,
+         [{ return Helper.matchRedundantAnd(*${root}, ${matchinfo}); }]),
+  (apply [{ return Helper.replaceSingleDefInstWithReg(*${root}, ${matchinfo}); }])
+>;
+
+// Fold (x | y) -> x or (x | y) -> y when (x | y) is known to equal x or equal y.
+def redundant_or_matchinfo : GIDefMatchData<"Register">;
+def redundant_or: GICombineRule <
+  (defs root:$root, redundant_or_matchinfo:$matchinfo),
+  (match (wip_match_opcode G_OR):$root,
+         [{ return Helper.matchRedundantOr(*${root}, ${matchinfo}); }]),
+  (apply [{ return Helper.replaceSingleDefInstWithReg(*${root}, ${matchinfo}); }])
+>;
+
+// If the input is already sign extended, just drop the extension.
+// sext_inreg x, K ->
+//   if computeNumSignBits(x) >= (x.getScalarSizeInBits() - K + 1)
+def redundant_sext_inreg: GICombineRule <
+  (defs root:$root),
+  (match (wip_match_opcode G_SEXT_INREG):$root,
+         [{ return Helper.matchRedundantSExtInReg(*${root}); }]),
+     (apply [{ return Helper.replaceSingleDefInstWithOperand(*${root}, 1); }])
+>;
+
+// Fold (anyext (trunc x)) -> x if the source type is same as
+// the destination type.
+def anyext_trunc_fold_matchinfo : GIDefMatchData<"Register">;
+def anyext_trunc_fold: GICombineRule <
+  (defs root:$root, anyext_trunc_fold_matchinfo:$matchinfo),
+  (match (wip_match_opcode G_ANYEXT):$root,
+         [{ return Helper.matchCombineAnyExtTrunc(*${root}, ${matchinfo}); }]),
+  (apply [{ return Helper.applyCombineAnyExtTrunc(*${root}, ${matchinfo}); }])
+>;
+
+// Fold ([asz]ext ([asz]ext x)) -> ([asz]ext x).
+def ext_ext_fold_matchinfo : GIDefMatchData<"std::tuple<Register, unsigned>">;
+def ext_ext_fold: GICombineRule <
+  (defs root:$root, ext_ext_fold_matchinfo:$matchinfo),
+  (match (wip_match_opcode G_ANYEXT, G_SEXT, G_ZEXT):$root,
+         [{ return Helper.matchCombineExtOfExt(*${root}, ${matchinfo}); }]),
+  (apply [{ return Helper.applyCombineExtOfExt(*${root}, ${matchinfo}); }])
+>;
+
+def not_cmp_fold_matchinfo : GIDefMatchData<"SmallVector<Register, 4>">;
+def not_cmp_fold : GICombineRule<
+  (defs root:$d, not_cmp_fold_matchinfo:$info),
+  (match (wip_match_opcode G_XOR): $d,
+  [{ return Helper.matchNotCmp(*${d}, ${info}); }]),
+  (apply [{ return Helper.applyNotCmp(*${d}, ${info}); }])
+>;
+
+// Fold (fneg (fneg x)) -> x.
+def fneg_fneg_fold_matchinfo : GIDefMatchData<"Register">;
+def fneg_fneg_fold: GICombineRule <
+  (defs root:$root, fneg_fneg_fold_matchinfo:$matchinfo),
+  (match (wip_match_opcode G_FNEG):$root,
+         [{ return Helper.matchCombineFNegOfFNeg(*${root}, ${matchinfo}); }]),
+  (apply [{ return Helper.replaceSingleDefInstWithReg(*${root}, ${matchinfo}); }])
+>;
+
+// Fold (unmerge(merge x, y, z)) -> z, y, z.
+def unmerge_merge_matchinfo : GIDefMatchData<"SmallVector<Register, 8>">;
+def unmerge_merge : GICombineRule<
+  (defs root:$d, unmerge_merge_matchinfo:$info),
+  (match (wip_match_opcode G_UNMERGE_VALUES): $d,
+  [{ return Helper.matchCombineUnmergeMergeToPlainValues(*${d}, ${info}); }]),
+  (apply [{ return Helper.applyCombineUnmergeMergeToPlainValues(*${d}, ${info}); }])
+>;
+
+// Fold (fabs (fabs x)) -> (fabs x).
+def fabs_fabs_fold_matchinfo : GIDefMatchData<"Register">;
+def fabs_fabs_fold: GICombineRule<
+  (defs root:$root, fabs_fabs_fold_matchinfo:$matchinfo),
+  (match (wip_match_opcode G_FABS):$root,
+         [{ return Helper.matchCombineFAbsOfFAbs(*${root}, ${matchinfo}); }]),
+  (apply [{ return Helper.applyCombineFAbsOfFAbs(*${root}, ${matchinfo}); }])
+>;
+
+// Fold (unmerge cst) -> cst1, cst2, ...
+def unmerge_cst_matchinfo : GIDefMatchData<"SmallVector<APInt, 8>">;
+def unmerge_cst : GICombineRule<
+  (defs root:$d, unmerge_cst_matchinfo:$info),
+  (match (wip_match_opcode G_UNMERGE_VALUES): $d,
+  [{ return Helper.matchCombineUnmergeConstant(*${d}, ${info}); }]),
+  (apply [{ return Helper.applyCombineUnmergeConstant(*${d}, ${info}); }])
+>;
+
+// Transform x,y<dead> = unmerge z -> x = trunc z.
+def unmerge_dead_to_trunc : GICombineRule<
+  (defs root:$d),
+  (match (wip_match_opcode G_UNMERGE_VALUES): $d,
+  [{ return Helper.matchCombineUnmergeWithDeadLanesToTrunc(*${d}); }]),
+  (apply [{ return Helper.applyCombineUnmergeWithDeadLanesToTrunc(*${d}); }])
+>;
+
+// Transform x,y = unmerge(zext(z)) -> x = zext z; y = 0.
+def unmerge_zext_to_zext : GICombineRule<
+  (defs root:$d),
+  (match (wip_match_opcode G_UNMERGE_VALUES): $d,
+  [{ return Helper.matchCombineUnmergeZExtToZExt(*${d}); }]),
+  (apply [{ return Helper.applyCombineUnmergeZExtToZExt(*${d}); }])
+>;
+
+// Fold trunc ([asz]ext x) -> x or ([asz]ext x) or (trunc x).
+def trunc_ext_fold_matchinfo : GIDefMatchData<"std::pair<Register, unsigned>">;
+def trunc_ext_fold: GICombineRule <
+  (defs root:$root, trunc_ext_fold_matchinfo:$matchinfo),
+  (match (wip_match_opcode G_TRUNC):$root,
+         [{ return Helper.matchCombineTruncOfExt(*${root}, ${matchinfo}); }]),
+  (apply [{ return Helper.applyCombineTruncOfExt(*${root}, ${matchinfo}); }])
+>;
+
+// Fold trunc (shl x, K) -> shl (trunc x), K => K < VT.getScalarSizeInBits().
+def trunc_shl_matchinfo : GIDefMatchData<"std::pair<Register, Register>">;
+def trunc_shl: GICombineRule <
+  (defs root:$root, trunc_shl_matchinfo:$matchinfo),
+  (match (wip_match_opcode G_TRUNC):$root,
+         [{ return Helper.matchCombineTruncOfShl(*${root}, ${matchinfo}); }]),
+  (apply [{ return Helper.applyCombineTruncOfShl(*${root}, ${matchinfo}); }])
+>;
+
+// Transform (mul x, -1) -> (sub 0, x)
+def mul_by_neg_one: GICombineRule <
+  (defs root:$root),
+  (match (wip_match_opcode G_MUL):$root,
+         [{ return Helper.matchConstantOp(${root}->getOperand(2), -1); }]),
+  (apply [{ return Helper.applyCombineMulByNegativeOne(*${root}); }])
+>;
+
+// Fold (xor (and x, y), y) -> (and (not x), y)
+def xor_of_and_with_same_reg_matchinfo :
+    GIDefMatchData<"std::pair<Register, Register>">;
+def xor_of_and_with_same_reg: GICombineRule <
+  (defs root:$root, xor_of_and_with_same_reg_matchinfo:$matchinfo),
+  (match (wip_match_opcode G_XOR):$root,
+         [{ return Helper.matchXorOfAndWithSameReg(*${root}, ${matchinfo}); }]),
+  (apply [{ return Helper.applyXorOfAndWithSameReg(*${root}, ${matchinfo}); }])
+>;
+
+// Transform (ptr_add 0, x) -> (int_to_ptr x)
+def ptr_add_with_zero: GICombineRule<
+  (defs root:$root),
+  (match (wip_match_opcode G_PTR_ADD):$root,
+         [{ return Helper.matchPtrAddZero(*${root}); }]),
+  (apply [{ return Helper.applyPtrAddZero(*${root}); }])>;
+
+def regs_small_vec : GIDefMatchData<"SmallVector<Register, 4>">;
+def combine_insert_vec_elts_build_vector : GICombineRule<
+  (defs root:$root, regs_small_vec:$info),
+  (match (wip_match_opcode G_INSERT_VECTOR_ELT):$root,
+    [{ return Helper.matchCombineInsertVecElts(*${root}, ${info}); }]),
+  (apply [{ return Helper.applyCombineInsertVecElts(*${root}, ${info}); }])>;
+
+// Currently only the one combine above.
+def insert_vec_elt_combines : GICombineGroup<
+                            [combine_insert_vec_elts_build_vector]>;
+
+// FIXME: These should use the custom predicate feature once it lands.
+def undef_combines : GICombineGroup<[undef_to_fp_zero, undef_to_int_zero,
+                                     undef_to_negative_one,
+                                     binop_left_undef_to_zero,
+                                     propagate_undef_any_op,
+                                     propagate_undef_all_ops,
+                                     propagate_undef_shuffle_mask,
+                                     erase_undef_store]>;
+
+def identity_combines : GICombineGroup<[select_same_val, right_identity_zero,
+                                        binop_same_val, binop_left_to_zero,
+                                        binop_right_to_zero, p2i_to_i2p,
+                                        i2p_to_p2i, anyext_trunc_fold,
+                                        fneg_fneg_fold, right_identity_one]>;
+
+def const_combines : GICombineGroup<[constant_fp_op, const_ptradd_to_i2p]>;
+
+def known_bits_simplifications : GICombineGroup<[
+  redundant_and, redundant_sext_inreg, redundant_or, urem_pow2_to_mask]>;
+
+def width_reduction_combines : GICombineGroup<[reduce_shl_of_extend]>;
+
+def select_combines : GICombineGroup<[select_undef_cmp, select_constant_cmp]>;
+
+def trivial_combines : GICombineGroup<[copy_prop, mul_to_shl, add_p2i_to_ptradd,
+                                       mul_by_neg_one]>;
+
+def all_combines : GICombineGroup<[trivial_combines, insert_vec_elt_combines,
+    ptr_add_immed_chain, combines_for_extload, combine_indexed_load_store,
+    undef_combines, identity_combines, simplify_add_to_sub,
+    hoist_logic_op_with_same_opcode_hands,
+    shl_ashr_to_sext_inreg, sext_inreg_of_load,
+    width_reduction_combines, select_combines,
+    known_bits_simplifications, ext_ext_fold,
+    not_cmp_fold, opt_brcond_by_inverting_cond,
+    unmerge_merge, fabs_fabs_fold, unmerge_cst, unmerge_dead_to_trunc,
+    unmerge_zext_to_zext, trunc_ext_fold, trunc_shl,
+    const_combines, xor_of_and_with_same_reg, ptr_add_with_zero,
+    shift_immed_chain, shift_of_shifted_logic_chain]>;
diff --git a/linux-x64/clang/include/llvm/Target/GlobalISel/SelectionDAGCompat.td b/linux-x64/clang/include/llvm/Target/GlobalISel/SelectionDAGCompat.td
index 6cc58d6..6fb8a6b 100644
--- a/linux-x64/clang/include/llvm/Target/GlobalISel/SelectionDAGCompat.td
+++ b/linux-x64/clang/include/llvm/Target/GlobalISel/SelectionDAGCompat.td
@@ -26,7 +26,8 @@
   // SelectionDAG has separate nodes for atomic and non-atomic memory operations
   // (ISD::LOAD, ISD::ATOMIC_LOAD, ISD::STORE, ISD::ATOMIC_STORE) but GlobalISel
   // stores this information in the MachineMemoryOperand.
-  bit CheckMMOIsNonAtomic = 0;
+  bit CheckMMOIsNonAtomic = false;
+  bit CheckMMOIsAtomic = false;
 
   // SelectionDAG has one node for all loads and uses predicates to
   // differentiate them. GlobalISel on the other hand uses separate opcodes.
@@ -34,6 +35,10 @@
   // depending on the predicates on the node.
   Instruction IfSignExtend = ?;
   Instruction IfZeroExtend = ?;
+
+  // SelectionDAG has one setcc for all compares. This differentiates
+  // for G_ICMP and G_FCMP.
+  Instruction IfFloatingPoint = ?;
 }
 
 // These are defined in the same order as the G_* instructions.
@@ -46,6 +51,9 @@
 // G_PTRTOINT - SelectionDAG has no equivalent.
 def : GINodeEquiv<G_CONSTANT, imm>;
 def : GINodeEquiv<G_FCONSTANT, fpimm>;
+def : GINodeEquiv<G_IMPLICIT_DEF, undef>;
+def : GINodeEquiv<G_FRAME_INDEX, frameindex>;
+def : GINodeEquiv<G_BLOCK_ADDR, blockaddress>;
 def : GINodeEquiv<G_ADD, add>;
 def : GINodeEquiv<G_SUB, sub>;
 def : GINodeEquiv<G_MUL, mul>;
@@ -61,6 +69,20 @@
 def : GINodeEquiv<G_SHL, shl>;
 def : GINodeEquiv<G_LSHR, srl>;
 def : GINodeEquiv<G_ASHR, sra>;
+def : GINodeEquiv<G_SADDSAT, saddsat>;
+def : GINodeEquiv<G_UADDSAT, uaddsat>;
+def : GINodeEquiv<G_SSUBSAT, ssubsat>;
+def : GINodeEquiv<G_USUBSAT, usubsat>;
+def : GINodeEquiv<G_SSHLSAT, sshlsat>;
+def : GINodeEquiv<G_USHLSAT, ushlsat>;
+def : GINodeEquiv<G_SMULFIX, smulfix>;
+def : GINodeEquiv<G_UMULFIX, umulfix>;
+def : GINodeEquiv<G_SMULFIXSAT, smulfixsat>;
+def : GINodeEquiv<G_UMULFIXSAT, umulfixsat>;
+def : GINodeEquiv<G_SDIVFIX, sdivfix>;
+def : GINodeEquiv<G_UDIVFIX, udivfix>;
+def : GINodeEquiv<G_SDIVFIXSAT, sdivfixsat>;
+def : GINodeEquiv<G_UDIVFIXSAT, udivfixsat>;
 def : GINodeEquiv<G_SELECT, select>;
 def : GINodeEquiv<G_FNEG, fneg>;
 def : GINodeEquiv<G_FPEXT, fpextend>;
@@ -72,6 +94,7 @@
 def : GINodeEquiv<G_FADD, fadd>;
 def : GINodeEquiv<G_FSUB, fsub>;
 def : GINodeEquiv<G_FMA, fma>;
+def : GINodeEquiv<G_FMAD, fmad>;
 def : GINodeEquiv<G_FMUL, fmul>;
 def : GINodeEquiv<G_FDIV, fdiv>;
 def : GINodeEquiv<G_FREM, frem>;
@@ -85,13 +108,17 @@
 def : GINodeEquiv<G_INTRINSIC_W_SIDE_EFFECTS, intrinsic_w_chain>;
 def : GINodeEquiv<G_BR, br>;
 def : GINodeEquiv<G_BSWAP, bswap>;
+def : GINodeEquiv<G_BITREVERSE, bitreverse>;
+def : GINodeEquiv<G_FSHL, fshl>;
+def : GINodeEquiv<G_FSHR, fshr>;
 def : GINodeEquiv<G_CTLZ, ctlz>;
 def : GINodeEquiv<G_CTTZ, cttz>;
 def : GINodeEquiv<G_CTLZ_ZERO_UNDEF, ctlz_zero_undef>;
 def : GINodeEquiv<G_CTTZ_ZERO_UNDEF, cttz_zero_undef>;
 def : GINodeEquiv<G_CTPOP, ctpop>;
-def : GINodeEquiv<G_EXTRACT_VECTOR_ELT, vector_extract>;
+def : GINodeEquiv<G_EXTRACT_VECTOR_ELT, extractelt>;
 def : GINodeEquiv<G_CONCAT_VECTORS, concat_vectors>;
+def : GINodeEquiv<G_BUILD_VECTOR, build_vector>;
 def : GINodeEquiv<G_FCEIL, fceil>;
 def : GINodeEquiv<G_FCOS, fcos>;
 def : GINodeEquiv<G_FSIN, fsin>;
@@ -100,10 +127,28 @@
 def : GINodeEquiv<G_FFLOOR, ffloor>;
 def : GINodeEquiv<G_FRINT, frint>;
 def : GINodeEquiv<G_FNEARBYINT, fnearbyint>;
+def : GINodeEquiv<G_INTRINSIC_TRUNC, ftrunc>;
+def : GINodeEquiv<G_INTRINSIC_ROUND, fround>;
+def : GINodeEquiv<G_INTRINSIC_LRINT, lrint>;
+def : GINodeEquiv<G_FCOPYSIGN, fcopysign>;
 def : GINodeEquiv<G_SMIN, smin>;
 def : GINodeEquiv<G_SMAX, smax>;
 def : GINodeEquiv<G_UMIN, umin>;
 def : GINodeEquiv<G_UMAX, umax>;
+def : GINodeEquiv<G_ABS, abs>;
+def : GINodeEquiv<G_FMINNUM, fminnum>;
+def : GINodeEquiv<G_FMAXNUM, fmaxnum>;
+def : GINodeEquiv<G_FMINNUM_IEEE, fminnum_ieee>;
+def : GINodeEquiv<G_FMAXNUM_IEEE, fmaxnum_ieee>;
+def : GINodeEquiv<G_READCYCLECOUNTER, readcyclecounter>;
+
+def : GINodeEquiv<G_STRICT_FADD, strict_fadd>;
+def : GINodeEquiv<G_STRICT_FSUB, strict_fsub>;
+def : GINodeEquiv<G_STRICT_FMUL, strict_fmul>;
+def : GINodeEquiv<G_STRICT_FDIV, strict_fdiv>;
+def : GINodeEquiv<G_STRICT_FREM, strict_frem>;
+def : GINodeEquiv<G_STRICT_FMA, strict_fma>;
+def : GINodeEquiv<G_STRICT_FSQRT, strict_fsqrt>;
 
 // Broadly speaking G_LOAD is equivalent to ISD::LOAD but there are some
 // complications that tablegen must take care of. For example, Predicates such
@@ -113,10 +158,15 @@
 // separate nodes for them. This GINodeEquiv maps the non-atomic loads to
 // G_LOAD with a non-atomic MachineMemOperand.
 def : GINodeEquiv<G_LOAD, ld> {
-  let CheckMMOIsNonAtomic = 1;
+  let CheckMMOIsNonAtomic = true;
   let IfSignExtend = G_SEXTLOAD;
   let IfZeroExtend = G_ZEXTLOAD;
 }
+
+def : GINodeEquiv<G_ICMP, setcc> {
+  let IfFloatingPoint = G_FCMP;
+}
+
 // Broadly speaking G_STORE is equivalent to ISD::STORE but there are some
 // complications that tablegen must take care of. For example, predicates such
 // as isTruncStore require that this is not a perfect 1:1 mapping since a
@@ -124,7 +174,18 @@
 // G_STORE handles both atomic and non-atomic stores where as SelectionDAG had
 // separate nodes for them. This GINodeEquiv maps the non-atomic stores to
 // G_STORE with a non-atomic MachineMemOperand.
-def : GINodeEquiv<G_STORE, st> { let CheckMMOIsNonAtomic = 1; }
+def : GINodeEquiv<G_STORE, st> { let CheckMMOIsNonAtomic = true; }
+
+def : GINodeEquiv<G_LOAD, atomic_load> {
+  let CheckMMOIsNonAtomic = false;
+  let CheckMMOIsAtomic = true;
+}
+
+// Operands are swapped for atomic_store vs. regular store
+def : GINodeEquiv<G_STORE, atomic_store> {
+  let CheckMMOIsNonAtomic = false;
+  let CheckMMOIsAtomic = true;
+}
 
 def : GINodeEquiv<G_ATOMIC_CMPXCHG, atomic_cmp_swap>;
 def : GINodeEquiv<G_ATOMICRMW_XCHG, atomic_swap>;
@@ -138,6 +199,8 @@
 def : GINodeEquiv<G_ATOMICRMW_MAX, atomic_load_max>;
 def : GINodeEquiv<G_ATOMICRMW_UMIN, atomic_load_umin>;
 def : GINodeEquiv<G_ATOMICRMW_UMAX, atomic_load_umax>;
+def : GINodeEquiv<G_ATOMICRMW_FADD, atomic_load_fadd>;
+def : GINodeEquiv<G_ATOMICRMW_FSUB, atomic_load_fsub>;
 def : GINodeEquiv<G_FENCE, atomic_fence>;
 
 // Specifies the GlobalISel equivalents for SelectionDAG's ComplexPattern.
diff --git a/linux-x64/clang/include/llvm/Target/GlobalISel/Target.td b/linux-x64/clang/include/llvm/Target/GlobalISel/Target.td
index 538ca65..135d4a5 100644
--- a/linux-x64/clang/include/llvm/Target/GlobalISel/Target.td
+++ b/linux-x64/clang/include/llvm/Target/GlobalISel/Target.td
@@ -38,11 +38,10 @@
 
   // The function that determines whether the operand matches. It should be of
   // the form:
-  //   bool select(const MatchOperand &Root, MatchOperand &Result1)
-  // and should have the same number of ResultX arguments as the number of
-  // result operands. It must return true on successful match and false
-  // otherwise. If it returns true, then all the ResultX arguments must be
-  // overwritten.
+  //   ComplexRendererFn select(MachineOperand &Root) const;
+  // where Root is the root of the match.  The function should return nullptr
+  // on match failure, or a ComplexRendererFn that renders the operand in case
+  // of a successful match.
   string MatcherFn = matcherfn;
 }
 
@@ -55,6 +54,12 @@
 class GICustomOperandRenderer<string rendererfn> {
   // The function renders the operand(s) of the matched instruction to
   // the specified instruction. It should be of the form:
-  //   void render(MachineInstrBuilder &MIB, const MachineInstr &MI)
+  //   void render(MachineInstrBuilder &MIB, const MachineInstr &MI,
+  //               int OpIdx = -1)
+  //
+  // If OpIdx is specified (i.e. not invalid/negative), this
+  // references the source operand MI.getOperand(OpIdx). Otherwise,
+  // this is the value defined by MI. This is to support the case
+  // where there is no corresponding instruction to match.
   string RendererFn = rendererfn;
 }
diff --git a/linux-x64/clang/include/llvm/Target/Target.td b/linux-x64/clang/include/llvm/Target/Target.td
index d58662e..1c97d70 100644
--- a/linux-x64/clang/include/llvm/Target/Target.td
+++ b/linux-x64/clang/include/llvm/Target/Target.td
@@ -110,9 +110,9 @@
 // ComposedSubRegIndex - A sub-register that is the result of composing A and B.
 // Offset is set to the sum of A and B's Offsets. Size is set to B's Size.
 class ComposedSubRegIndex<SubRegIndex A, SubRegIndex B>
-  : SubRegIndex<B.Size, !if(!eq(A.Offset, -1), -1,
-                        !if(!eq(B.Offset, -1), -1,
-                            !add(A.Offset, B.Offset)))> {
+  : SubRegIndex<B.Size, !cond(!eq(A.Offset, -1): -1,
+                              !eq(B.Offset, -1): -1,
+                              true:              !add(A.Offset, B.Offset))> {
   // See SubRegIndex.
   let ComposedOf = [A, B];
 }
@@ -166,20 +166,21 @@
   // CostPerUse - Additional cost of instructions using this register compared
   // to other registers in its class. The register allocator will try to
   // minimize the number of instructions using a register with a CostPerUse.
-  // This is used by the x86-64 and ARM Thumb targets where some registers
-  // require larger instruction encodings.
+  // This is used by the ARC target, by the ARM Thumb and x86-64 targets, where
+  // some registers require larger instruction encodings, by the RISC-V target,
+  // where some registers preclude using some C instructions.
   int CostPerUse = 0;
 
   // CoveredBySubRegs - When this bit is set, the value of this register is
   // completely determined by the value of its sub-registers.  For example, the
   // x86 register AX is covered by its sub-registers AL and AH, but EAX is not
   // covered by its sub-register AX.
-  bit CoveredBySubRegs = 0;
+  bit CoveredBySubRegs = false;
 
   // HWEncoding - The target specific hardware encoding for this register.
   bits<16> HWEncoding = 0;
 
-  bit isArtificial = 0;
+  bit isArtificial = false;
 }
 
 // RegisterWithSubRegs - This can be used to define instances of Register which
@@ -223,7 +224,7 @@
   list<ValueType> RegTypes = regTypes;
 
   // Size - Specify the spill size in bits of the registers.  A default value of
-  // zero lets tablgen pick an appropriate size.
+  // zero lets tablegen pick an appropriate size.
   int Size = 0;
 
   // Alignment - Specify the alignment required of the registers when they are
@@ -251,7 +252,7 @@
   // isAllocatable - Specify that the register class can be used for virtual
   // registers and register allocation.  Some register classes are only used to
   // model instruction operand constraints, and should have isAllocatable = 0.
-  bit isAllocatable = 1;
+  bit isAllocatable = true;
 
   // AltOrders - List of alternative allocation orders. The default order is
   // MemberList itself, and that is good enough for most targets since the
@@ -275,6 +276,17 @@
   // constrained classes first. The value has to be in the range [0,63].
   int AllocationPriority = 0;
 
+  // Generate register pressure set for this register class and any class
+  // synthesized from it. Set to 0 to inhibit unneeded pressure sets.
+  bit GeneratePressureSet = true;
+
+  // Weight override for register pressure calculation. This is the value
+  // TargetRegisterClass::getRegClassWeight() will return. The weight is in
+  // units of pressure for this register class. If unset tablegen will
+  // calculate a weight based on a number of register units in this register
+  // class registers. The weight is per register.
+  int Weight = ?;
+
   // The diagnostic type to present when referencing this operand in a match
   // failure error message. If this is empty, the default Match_InvalidOperand
   // diagnostic type will be used. If this is "<name>", a Match_<name> enum
@@ -351,7 +363,11 @@
 // RegisterTuples instances can be used in other set operations to form
 // register classes and so on. This is the only way of using the generated
 // registers.
-class RegisterTuples<list<SubRegIndex> Indices, list<dag> Regs> {
+//
+// RegNames may be specified to supply asm names for the generated tuples.
+// If used must have the same size as the list of produced registers.
+class RegisterTuples<list<SubRegIndex> Indices, list<dag> Regs,
+                     list<string> RegNames = []> {
   // SubRegs - N lists of registers to be zipped up. Super-registers are
   // synthesized from the first element of each SubRegs list, the second
   // element and so on.
@@ -360,6 +376,9 @@
   // SubRegIndices - N SubRegIndex instances. This provides the names of the
   // sub-registers in the synthesized super-registers.
   list<SubRegIndex> SubRegIndices = Indices;
+
+  // List of asm names for the generated tuple registers.
+  list<string> RegAsmNames = RegNames;
 }
 
 
@@ -433,7 +452,16 @@
   // DecodeInstB() is not able to determine if all possible values of ?? are
   // valid or not. If DecodeInstB() returns Fail the decoder will attempt to
   // decode the bitpattern as InstA too.
-  bit hasCompleteDecoder = 1;
+  bit hasCompleteDecoder = true;
+}
+
+// Allows specifying an InstructionEncoding by HwMode. If an Instruction specifies
+// an EncodingByHwMode, its Inst and Size members are ignored and Ts are used
+// to encode and decode based on HwMode.
+class EncodingByHwMode<list<HwMode> Ms = [], list<InstructionEncoding> Ts = []>
+    : HwModeSelect<Ms> {
+  // The length of this list must be the same as the length of Ms.
+  list<InstructionEncoding> Objects = Ts;
 }
 
 //===----------------------------------------------------------------------===//
@@ -447,6 +475,10 @@
   dag InOperandList;        // An dag containing the MI use operand list.
   string AsmString = "";    // The .s format to print the instruction with.
 
+  // Allows specifying a canonical InstructionEncoding by HwMode. If non-empty,
+  // the Inst member of this Instruction is ignored.
+  EncodingByHwMode EncodingInfos;
+
   // Pattern - Set to the DAG pattern for this instruction, if we know of one,
   // otherwise, uninitialized.
   list<dag> Pattern;
@@ -472,56 +504,61 @@
   // Added complexity passed onto matching pattern.
   int AddedComplexity  = 0;
 
+  // Indicates if this is a pre-isel opcode that should be
+  // legalized/regbankselected/selected.
+  bit isPreISelOpcode = false;
+
   // These bits capture information about the high-level semantics of the
   // instruction.
-  bit isReturn     = 0;     // Is this instruction a return instruction?
-  bit isBranch     = 0;     // Is this instruction a branch instruction?
-  bit isEHScopeReturn = 0;  // Does this instruction end an EH scope?
-  bit isIndirectBranch = 0; // Is this instruction an indirect branch?
-  bit isCompare    = 0;     // Is this instruction a comparison instruction?
-  bit isMoveImm    = 0;     // Is this instruction a move immediate instruction?
-  bit isMoveReg    = 0;     // Is this instruction a move register instruction?
-  bit isBitcast    = 0;     // Is this instruction a bitcast instruction?
-  bit isSelect     = 0;     // Is this instruction a select instruction?
-  bit isBarrier    = 0;     // Can control flow fall through this instruction?
-  bit isCall       = 0;     // Is this instruction a call instruction?
-  bit isAdd        = 0;     // Is this instruction an add instruction?
-  bit isTrap       = 0;     // Is this instruction a trap instruction?
-  bit canFoldAsLoad = 0;    // Can this be folded as a simple memory operand?
-  bit mayLoad      = ?;     // Is it possible for this inst to read memory?
-  bit mayStore     = ?;     // Is it possible for this inst to write memory?
-  bit mayRaiseFPException = 0; // Can this raise a floating-point exception?
-  bit isConvertibleToThreeAddress = 0;  // Can this 2-addr instruction promote?
-  bit isCommutable = 0;     // Is this 3 operand instruction commutable?
-  bit isTerminator = 0;     // Is this part of the terminator for a basic block?
-  bit isReMaterializable = 0; // Is this instruction re-materializable?
-  bit isPredicable = 0;     // 1 means this instruction is predicable
-                            // even if it does not have any operand
-                            // tablegen can identify as a predicate
-  bit isUnpredicable = 0;   // 1 means this instruction is not predicable
-                            // even if it _does_ have a predicate operand
-  bit hasDelaySlot = 0;     // Does this instruction have an delay slot?
-  bit usesCustomInserter = 0; // Pseudo instr needing special help.
-  bit hasPostISelHook = 0;  // To be *adjusted* after isel by target hook.
-  bit hasCtrlDep   = 0;     // Does this instruction r/w ctrl-flow chains?
-  bit isNotDuplicable = 0;  // Is it unsafe to duplicate this instruction?
-  bit isConvergent = 0;     // Is this instruction convergent?
-  bit isAsCheapAsAMove = 0; // As cheap (or cheaper) than a move instruction.
-  bit hasExtraSrcRegAllocReq = 0; // Sources have special regalloc requirement?
-  bit hasExtraDefRegAllocReq = 0; // Defs have special regalloc requirement?
-  bit isRegSequence = 0;    // Is this instruction a kind of reg sequence?
-                            // If so, make sure to override
-                            // TargetInstrInfo::getRegSequenceLikeInputs.
-  bit isPseudo     = 0;     // Is this instruction a pseudo-instruction?
-                            // If so, won't have encoding information for
-                            // the [MC]CodeEmitter stuff.
-  bit isExtractSubreg = 0;  // Is this instruction a kind of extract subreg?
-                             // If so, make sure to override
-                             // TargetInstrInfo::getExtractSubregLikeInputs.
-  bit isInsertSubreg = 0;   // Is this instruction a kind of insert subreg?
-                            // If so, make sure to override
-                            // TargetInstrInfo::getInsertSubregLikeInputs.
-  bit variadicOpsAreDefs = 0; // Are variadic operands definitions?
+  bit isReturn     = false;     // Is this instruction a return instruction?
+  bit isBranch     = false;     // Is this instruction a branch instruction?
+  bit isEHScopeReturn = false;  // Does this instruction end an EH scope?
+  bit isIndirectBranch = false; // Is this instruction an indirect branch?
+  bit isCompare    = false;     // Is this instruction a comparison instruction?
+  bit isMoveImm    = false;     // Is this instruction a move immediate instruction?
+  bit isMoveReg    = false;     // Is this instruction a move register instruction?
+  bit isBitcast    = false;     // Is this instruction a bitcast instruction?
+  bit isSelect     = false;     // Is this instruction a select instruction?
+  bit isBarrier    = false;     // Can control flow fall through this instruction?
+  bit isCall       = false;     // Is this instruction a call instruction?
+  bit isAdd        = false;     // Is this instruction an add instruction?
+  bit isTrap       = false;     // Is this instruction a trap instruction?
+  bit canFoldAsLoad = false;    // Can this be folded as a simple memory operand?
+  bit mayLoad      = ?;         // Is it possible for this inst to read memory?
+  bit mayStore     = ?;         // Is it possible for this inst to write memory?
+  bit mayRaiseFPException = false; // Can this raise a floating-point exception?
+  bit isConvertibleToThreeAddress = false;  // Can this 2-addr instruction promote?
+  bit isCommutable = false;     // Is this 3 operand instruction commutable?
+  bit isTerminator = false;     // Is this part of the terminator for a basic block?
+  bit isReMaterializable = false; // Is this instruction re-materializable?
+  bit isPredicable = false;     // 1 means this instruction is predicable
+                                // even if it does not have any operand
+                                // tablegen can identify as a predicate
+  bit isUnpredicable = false;   // 1 means this instruction is not predicable
+                                // even if it _does_ have a predicate operand
+  bit hasDelaySlot = false;     // Does this instruction have an delay slot?
+  bit usesCustomInserter = false; // Pseudo instr needing special help.
+  bit hasPostISelHook = false;  // To be *adjusted* after isel by target hook.
+  bit hasCtrlDep   = false;     // Does this instruction r/w ctrl-flow chains?
+  bit isNotDuplicable = false;  // Is it unsafe to duplicate this instruction?
+  bit isConvergent = false;     // Is this instruction convergent?
+  bit isAuthenticated = false;  // Does this instruction authenticate a pointer?
+  bit isAsCheapAsAMove = false; // As cheap (or cheaper) than a move instruction.
+  bit hasExtraSrcRegAllocReq = false; // Sources have special regalloc requirement?
+  bit hasExtraDefRegAllocReq = false; // Defs have special regalloc requirement?
+  bit isRegSequence = false;    // Is this instruction a kind of reg sequence?
+                                // If so, make sure to override
+                                // TargetInstrInfo::getRegSequenceLikeInputs.
+  bit isPseudo     = false;     // Is this instruction a pseudo-instruction?
+                                // If so, won't have encoding information for
+                                // the [MC]CodeEmitter stuff.
+  bit isExtractSubreg = false;  // Is this instruction a kind of extract subreg?
+                                // If so, make sure to override
+                                // TargetInstrInfo::getExtractSubregLikeInputs.
+  bit isInsertSubreg = false;   // Is this instruction a kind of insert subreg?
+                                // If so, make sure to override
+                                // TargetInstrInfo::getInsertSubregLikeInputs.
+  bit variadicOpsAreDefs = false; // Are variadic operands definitions?
 
   // Does the instruction have side effects that are not captured by any
   // operands of the instruction or other flags?
@@ -544,15 +581,15 @@
   //   CodeEmitter unchanged, but duplicates a canonical instruction
   //   definition's encoding and should be ignored when constructing the
   //   assembler match tables.
-  bit isCodeGenOnly = 0;
+  bit isCodeGenOnly = false;
 
   // Is this instruction a pseudo instruction for use by the assembler parser.
-  bit isAsmParserOnly = 0;
+  bit isAsmParserOnly = false;
 
   // This instruction is not expected to be queried for scheduling latencies
   // and therefore needs no scheduling information even for a complete
   // scheduling model.
-  bit hasNoSchedulingInfo = 0;
+  bit hasNoSchedulingInfo = false;
 
   InstrItinClass Itinerary = NoItinerary;// Execution steps used for scheduling.
 
@@ -593,13 +630,13 @@
   /// UseNamedOperandTable - If set, the operand indices of this instruction
   /// can be queried via the getNamedOperandIdx() function which is generated
   /// by TableGen.
-  bit UseNamedOperandTable = 0;
+  bit UseNamedOperandTable = false;
 
   /// Should FastISel ignore this instruction. For certain ISAs, they have
   /// instructions which map to the same ISD Opcode, value type operands and
   /// instruction selection predicates. FastISel cannot handle such cases, but
   /// SelectionDAG can.
-  bit FastISelShouldIgnore = 0;
+  bit FastISelShouldIgnore = false;
 }
 
 /// Defines an additional encoding that disassembles to the given instruction
@@ -614,7 +651,7 @@
 /// pseudo.
 class PseudoInstExpansion<dag Result> {
   dag ResultInst = Result;     // The instruction to generate.
-  bit isPseudo = 1;
+  bit isPseudo = true;
 }
 
 /// Predicates - These are extra conditionals which are turned into instruction
@@ -625,16 +662,23 @@
   /// AssemblerMatcherPredicate - If this feature can be used by the assembler
   /// matcher, this is true.  Targets should set this by inheriting their
   /// feature from the AssemblerPredicate class in addition to Predicate.
-  bit AssemblerMatcherPredicate = 0;
+  bit AssemblerMatcherPredicate = false;
 
-  /// AssemblerCondString - Name of the subtarget feature being tested used
-  /// as alternative condition string used for assembler matcher.
-  /// e.g. "ModeThumb" is translated to "(Bits & ModeThumb) != 0".
-  ///      "!ModeThumb" is translated to "(Bits & ModeThumb) == 0".
-  /// It can also list multiple features separated by ",".
-  /// e.g. "ModeThumb,FeatureThumb2" is translated to
+  /// AssemblerCondDag - Set of subtarget features being tested used
+  /// as alternative condition string used for assembler matcher. Must be used
+  /// with (all_of) to indicate that all features must be present, or (any_of)
+  /// to indicate that at least one must be. The required lack of presence of
+  /// a feature can be tested using a (not) node including the feature.
+  /// e.g. "(all_of ModeThumb)" is translated to "(Bits & ModeThumb) != 0".
+  ///      "(all_of (not ModeThumb))" is translated to
+  ///      "(Bits & ModeThumb) == 0".
+  ///      "(all_of ModeThumb, FeatureThumb2)" is translated to
   ///      "(Bits & ModeThumb) != 0 && (Bits & FeatureThumb2) != 0".
-  string AssemblerCondString = "";
+  ///      "(any_of ModeTumb, FeatureThumb2)" is translated to
+  ///      "(Bits & ModeThumb) != 0 || (Bits & FeatureThumb2) != 0".
+  /// all_of and any_of cannot be combined in a single dag, instead multiple
+  /// predicates can be placed onto Instruction definitions.
+  dag AssemblerCondDag;
 
   /// PredicateName - User-level name to use for the predicate. Mainly for use
   /// in diagnostics such as missing feature errors in the asm matcher.
@@ -644,7 +688,7 @@
   /// every function change. Most predicates can leave this at '0'.
   ///
   /// Ignored by SelectionDAG, it always recomputes the predicate on every use.
-  bit RecomputePerFunction = 0;
+  bit RecomputePerFunction = false;
 }
 
 /// NoHonorSignDependentRounding - This predicate is true if support for
@@ -659,7 +703,7 @@
 /// ops definition - This is just a simple marker used to identify the operand
 /// list for an instruction. outs and ins are identical both syntactically and
 /// semantically; they are used to define def operands and use operands to
-/// improve readibility. This should be used like this:
+/// improve readability. This should be used like this:
 ///     (outs R32:$dst), (ins R32:$src1, R32:$src2) or something similar.
 def ops;
 def outs;
@@ -744,7 +788,7 @@
   /// marked as IsOptional.
   ///
   /// Optional arguments must be at the end of the operand list.
-  bit IsOptional = 0;
+  bit IsOptional = false;
 
   /// The name of the method on the target specific asm parser that returns the
   /// default operand for this optional operand. This method is only used if
@@ -765,7 +809,7 @@
   ValueType Type = ty;
   string PrintMethod = "printOperand";
   string EncoderMethod = "";
-  bit hasCompleteDecoder = 1;
+  bit hasCompleteDecoder = true;
   string OperandType = "OPERAND_UNKNOWN";
   dag MIOperandInfo = (ops);
 
@@ -833,7 +877,8 @@
 // have the same LLT).
 class TypedOperand<string Ty> : Operand<untyped> {
   let OperandType = Ty;
-  bit IsPointer = 0;
+  bit IsPointer = false;
+  bit IsImmediate = false;
 }
 
 def type0 : TypedOperand<"OPERAND_GENERIC_0">;
@@ -843,7 +888,7 @@
 def type4 : TypedOperand<"OPERAND_GENERIC_4">;
 def type5 : TypedOperand<"OPERAND_GENERIC_5">;
 
-let IsPointer = 1 in {
+let IsPointer = true in {
   def ptype0 : TypedOperand<"OPERAND_GENERIC_0">;
   def ptype1 : TypedOperand<"OPERAND_GENERIC_1">;
   def ptype2 : TypedOperand<"OPERAND_GENERIC_2">;
@@ -852,10 +897,20 @@
   def ptype5 : TypedOperand<"OPERAND_GENERIC_5">;
 }
 
+// untyped_imm is for operands where isImm() will be true. It currently has no
+// special behaviour and is only used for clarity.
+def untyped_imm_0 : TypedOperand<"OPERAND_GENERIC_IMM_0"> {
+  let IsImmediate = true;
+}
+
 /// zero_reg definition - Special node to stand for the zero register.
 ///
 def zero_reg;
 
+/// undef_tied_input - Special node to indicate an input register tied
+/// to an output which defaults to IMPLICIT_DEF.
+def undef_tied_input;
+
 /// All operands which the MC layer classifies as predicates should inherit from
 /// this class in some manner. This is already handled for the most commonly
 /// used PredicateOperand, but may be useful in other circumstances.
@@ -897,7 +952,7 @@
   // For instance, while both Sparc and PowerPC are big-endian platforms, the
   // Sparc manual specifies its instructions in the format [31..0] (big), while
   // PowerPC specifies them using the format [0..31] (little).
-  bit isLittleEndianEncoding = 0;
+  bit isLittleEndianEncoding = false;
 
   // The instruction properties mayLoad, mayStore, and hasSideEffects are unset
   // by default, and TableGen will infer their value from the instruction
@@ -908,7 +963,7 @@
   // is set, it will guess a safe value instead.
   //
   // This option is a temporary migration help. It will go away.
-  bit guessInstructionProperties = 1;
+  bit guessInstructionProperties = true;
 
   // TableGen's instruction encoder generator has support for matching operands
   // to bit-field variables both by name and by position. While matching by
@@ -920,7 +975,7 @@
   // This option is temporary; it will go away once the TableGen decoder
   // generator has better support for complex operands and targets have
   // migrated away from using positionally encoded operands.
-  bit decodePositionallyEncodedOperands = 0;
+  bit decodePositionallyEncodedOperands = false;
 
   // When set, this indicates that there will be no overlap between those
   // operands that are matched by ordering (positional operands) and those
@@ -929,7 +984,7 @@
   // This option is temporary; it will go away once the TableGen decoder
   // generator has better support for complex operands and targets have
   // migrated away from using positionally encoded operands.
-  bit noNamedPositionallyEncodedOperands = 0;
+  bit noNamedPositionallyEncodedOperands = false;
 }
 
 // Standard Pseudo Instructions.
@@ -939,184 +994,209 @@
 // targets that set guessInstructionProperties=0. Any local definition of
 // mayLoad/mayStore takes precedence over these default values.
 class StandardPseudoInstruction : Instruction {
-  let mayLoad = 0;
-  let mayStore = 0;
-  let isCodeGenOnly = 1;
-  let isPseudo = 1;
-  let hasNoSchedulingInfo = 1;
+  let mayLoad = false;
+  let mayStore = false;
+  let isCodeGenOnly = true;
+  let isPseudo = true;
+  let hasNoSchedulingInfo = true;
   let Namespace = "TargetOpcode";
 }
 def PHI : StandardPseudoInstruction {
   let OutOperandList = (outs unknown:$dst);
   let InOperandList = (ins variable_ops);
   let AsmString = "PHINODE";
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
 }
 def INLINEASM : StandardPseudoInstruction {
   let OutOperandList = (outs);
   let InOperandList = (ins variable_ops);
   let AsmString = "";
-  let hasSideEffects = 0;  // Note side effect is encoded in an operand.
+  let hasSideEffects = false;  // Note side effect is encoded in an operand.
 }
 def INLINEASM_BR : StandardPseudoInstruction {
   let OutOperandList = (outs);
   let InOperandList = (ins variable_ops);
   let AsmString = "";
-  let hasSideEffects = 0;  // Note side effect is encoded in an operand.
-  let isTerminator = 1;
-  let isBranch = 1;
-  let isIndirectBranch = 1;
+  // Unlike INLINEASM, this is always treated as having side-effects.
+  let hasSideEffects = true;
+  // Despite potentially branching, this instruction is intentionally _not_
+  // marked as a terminator or a branch.
 }
 def CFI_INSTRUCTION : StandardPseudoInstruction {
   let OutOperandList = (outs);
   let InOperandList = (ins i32imm:$id);
   let AsmString = "";
-  let hasCtrlDep = 1;
-  let hasSideEffects = 0;
-  let isNotDuplicable = 1;
+  let hasCtrlDep = true;
+  let hasSideEffects = false;
+  let isNotDuplicable = true;
 }
 def EH_LABEL : StandardPseudoInstruction {
   let OutOperandList = (outs);
   let InOperandList = (ins i32imm:$id);
   let AsmString = "";
-  let hasCtrlDep = 1;
-  let hasSideEffects = 0;
-  let isNotDuplicable = 1;
+  let hasCtrlDep = true;
+  let hasSideEffects = false;
+  let isNotDuplicable = true;
 }
 def GC_LABEL : StandardPseudoInstruction {
   let OutOperandList = (outs);
   let InOperandList = (ins i32imm:$id);
   let AsmString = "";
-  let hasCtrlDep = 1;
-  let hasSideEffects = 0;
-  let isNotDuplicable = 1;
+  let hasCtrlDep = true;
+  let hasSideEffects = false;
+  let isNotDuplicable = true;
 }
 def ANNOTATION_LABEL : StandardPseudoInstruction {
   let OutOperandList = (outs);
   let InOperandList = (ins i32imm:$id);
   let AsmString = "";
-  let hasCtrlDep = 1;
-  let hasSideEffects = 0;
-  let isNotDuplicable = 1;
+  let hasCtrlDep = true;
+  let hasSideEffects = false;
+  let isNotDuplicable = true;
 }
 def KILL : StandardPseudoInstruction {
   let OutOperandList = (outs);
   let InOperandList = (ins variable_ops);
   let AsmString = "";
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
 }
 def EXTRACT_SUBREG : StandardPseudoInstruction {
   let OutOperandList = (outs unknown:$dst);
   let InOperandList = (ins unknown:$supersrc, i32imm:$subidx);
   let AsmString = "";
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
 }
 def INSERT_SUBREG : StandardPseudoInstruction {
   let OutOperandList = (outs unknown:$dst);
   let InOperandList = (ins unknown:$supersrc, unknown:$subsrc, i32imm:$subidx);
   let AsmString = "";
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
   let Constraints = "$supersrc = $dst";
 }
 def IMPLICIT_DEF : StandardPseudoInstruction {
   let OutOperandList = (outs unknown:$dst);
   let InOperandList = (ins);
   let AsmString = "";
-  let hasSideEffects = 0;
-  let isReMaterializable = 1;
-  let isAsCheapAsAMove = 1;
+  let hasSideEffects = false;
+  let isReMaterializable = true;
+  let isAsCheapAsAMove = true;
 }
 def SUBREG_TO_REG : StandardPseudoInstruction {
   let OutOperandList = (outs unknown:$dst);
   let InOperandList = (ins unknown:$implsrc, unknown:$subsrc, i32imm:$subidx);
   let AsmString = "";
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
 }
 def COPY_TO_REGCLASS : StandardPseudoInstruction {
   let OutOperandList = (outs unknown:$dst);
   let InOperandList = (ins unknown:$src, i32imm:$regclass);
   let AsmString = "";
-  let hasSideEffects = 0;
-  let isAsCheapAsAMove = 1;
+  let hasSideEffects = false;
+  let isAsCheapAsAMove = true;
 }
 def DBG_VALUE : StandardPseudoInstruction {
   let OutOperandList = (outs);
   let InOperandList = (ins variable_ops);
   let AsmString = "DBG_VALUE";
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
+}
+def DBG_INSTR_REF : StandardPseudoInstruction {
+  let OutOperandList = (outs);
+  let InOperandList = (ins variable_ops);
+  let AsmString = "DBG_INSTR_REF";
+  let hasSideEffects = false;
 }
 def DBG_LABEL : StandardPseudoInstruction {
   let OutOperandList = (outs);
   let InOperandList = (ins unknown:$label);
   let AsmString = "DBG_LABEL";
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
 }
 def REG_SEQUENCE : StandardPseudoInstruction {
   let OutOperandList = (outs unknown:$dst);
   let InOperandList = (ins unknown:$supersrc, variable_ops);
   let AsmString = "";
-  let hasSideEffects = 0;
-  let isAsCheapAsAMove = 1;
+  let hasSideEffects = false;
+  let isAsCheapAsAMove = true;
 }
 def COPY : StandardPseudoInstruction {
   let OutOperandList = (outs unknown:$dst);
   let InOperandList = (ins unknown:$src);
   let AsmString = "";
-  let hasSideEffects = 0;
-  let isAsCheapAsAMove = 1;
-  let hasNoSchedulingInfo = 0;
+  let hasSideEffects = false;
+  let isAsCheapAsAMove = true;
+  let hasNoSchedulingInfo = false;
 }
 def BUNDLE : StandardPseudoInstruction {
   let OutOperandList = (outs);
   let InOperandList = (ins variable_ops);
   let AsmString = "BUNDLE";
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
 }
 def LIFETIME_START : StandardPseudoInstruction {
   let OutOperandList = (outs);
   let InOperandList = (ins i32imm:$id);
   let AsmString = "LIFETIME_START";
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
 }
 def LIFETIME_END : StandardPseudoInstruction {
   let OutOperandList = (outs);
   let InOperandList = (ins i32imm:$id);
   let AsmString = "LIFETIME_END";
-  let hasSideEffects = 0;
+  let hasSideEffects = false;
 }
+def PSEUDO_PROBE : StandardPseudoInstruction {
+  let OutOperandList = (outs);
+  let InOperandList = (ins i64imm:$guid, i64imm:$index, i8imm:$type, i32imm:$attr);
+  let AsmString = "PSEUDO_PROBE";
+  let hasSideEffects = 1;
+}
+
 def STACKMAP : StandardPseudoInstruction {
   let OutOperandList = (outs);
   let InOperandList = (ins i64imm:$id, i32imm:$nbytes, variable_ops);
-  let hasSideEffects = 1;
-  let isCall = 1;
-  let mayLoad = 1;
-  let usesCustomInserter = 1;
+  let hasSideEffects = true;
+  let isCall = true;
+  let mayLoad = true;
+  let usesCustomInserter = true;
 }
 def PATCHPOINT : StandardPseudoInstruction {
   let OutOperandList = (outs unknown:$dst);
   let InOperandList = (ins i64imm:$id, i32imm:$nbytes, unknown:$callee,
                        i32imm:$nargs, i32imm:$cc, variable_ops);
-  let hasSideEffects = 1;
-  let isCall = 1;
-  let mayLoad = 1;
-  let usesCustomInserter = 1;
+  let hasSideEffects = true;
+  let isCall = true;
+  let mayLoad = true;
+  let usesCustomInserter = true;
 }
 def STATEPOINT : StandardPseudoInstruction {
-  let OutOperandList = (outs);
+  let OutOperandList = (outs variable_ops);
   let InOperandList = (ins variable_ops);
-  let usesCustomInserter = 1;
-  let mayLoad = 1;
-  let mayStore = 1;
-  let hasSideEffects = 1;
-  let isCall = 1;
+  let usesCustomInserter = true;
+  let mayLoad = true;
+  let mayStore = true;
+  let hasSideEffects = true;
+  let isCall = true;
 }
 def LOAD_STACK_GUARD : StandardPseudoInstruction {
   let OutOperandList = (outs ptr_rc:$dst);
   let InOperandList = (ins);
-  let mayLoad = 1;
-  bit isReMaterializable = 1;
-  let hasSideEffects = 0;
-  bit isPseudo = 1;
+  let mayLoad = true;
+  bit isReMaterializable = true;
+  let hasSideEffects = false;
+  bit isPseudo = true;
+}
+def PREALLOCATED_SETUP : StandardPseudoInstruction {
+  let OutOperandList = (outs);
+  let InOperandList = (ins i32imm:$a);
+  let usesCustomInserter = true;
+  let hasSideEffects = true;
+}
+def PREALLOCATED_ARG : StandardPseudoInstruction {
+  let OutOperandList = (outs ptr_rc:$loc);
+  let InOperandList = (ins i32imm:$a, i32imm:$b);
+  let usesCustomInserter = true;
+  let hasSideEffects = true;
 }
 def LOCAL_ESCAPE : StandardPseudoInstruction {
   // This instruction is really just a label. It has to be part of the chain so
@@ -1124,93 +1204,94 @@
   // no side effects.
   let OutOperandList = (outs);
   let InOperandList = (ins ptr_rc:$symbol, i32imm:$id);
-  let hasSideEffects = 0;
-  let hasCtrlDep = 1;
+  let hasSideEffects = false;
+  let hasCtrlDep = true;
 }
 def FAULTING_OP : StandardPseudoInstruction {
   let OutOperandList = (outs unknown:$dst);
   let InOperandList = (ins variable_ops);
-  let usesCustomInserter = 1;
-  let hasSideEffects = 1;
-  let mayLoad = 1;
-  let mayStore = 1;
-  let isTerminator = 1;
-  let isBranch = 1;
+  let usesCustomInserter = true;
+  let hasSideEffects = true;
+  let mayLoad = true;
+  let mayStore = true;
+  let isTerminator = true;
+  let isBranch = true;
 }
 def PATCHABLE_OP : StandardPseudoInstruction {
   let OutOperandList = (outs);
   let InOperandList = (ins variable_ops);
-  let usesCustomInserter = 1;
-  let mayLoad = 1;
-  let mayStore = 1;
-  let hasSideEffects = 1;
+  let usesCustomInserter = true;
+  let mayLoad = true;
+  let mayStore = true;
+  let hasSideEffects = true;
 }
 def PATCHABLE_FUNCTION_ENTER : StandardPseudoInstruction {
   let OutOperandList = (outs);
   let InOperandList = (ins);
   let AsmString = "# XRay Function Enter.";
-  let usesCustomInserter = 1;
-  let hasSideEffects = 0;
+  let usesCustomInserter = true;
+  let hasSideEffects = true;
 }
 def PATCHABLE_RET : StandardPseudoInstruction {
   let OutOperandList = (outs);
   let InOperandList = (ins variable_ops);
   let AsmString = "# XRay Function Patchable RET.";
-  let usesCustomInserter = 1;
-  let hasSideEffects = 1;
-  let isTerminator = 1;
-  let isReturn = 1;
+  let usesCustomInserter = true;
+  let hasSideEffects = true;
+  let isTerminator = true;
+  let isReturn = true;
 }
 def PATCHABLE_FUNCTION_EXIT : StandardPseudoInstruction {
   let OutOperandList = (outs);
   let InOperandList = (ins);
   let AsmString = "# XRay Function Exit.";
-  let usesCustomInserter = 1;
-  let hasSideEffects = 0; // FIXME: is this correct?
-  let isReturn = 0; // Original return instruction will follow
+  let usesCustomInserter = true;
+  let hasSideEffects = true;
+  let isReturn = false; // Original return instruction will follow
 }
 def PATCHABLE_TAIL_CALL : StandardPseudoInstruction {
   let OutOperandList = (outs);
   let InOperandList = (ins variable_ops);
   let AsmString = "# XRay Tail Call Exit.";
-  let usesCustomInserter = 1;
-  let hasSideEffects = 1;
-  let isReturn = 1;
+  let usesCustomInserter = true;
+  let hasSideEffects = true;
+  let isReturn = true;
 }
 def PATCHABLE_EVENT_CALL : StandardPseudoInstruction {
   let OutOperandList = (outs);
-  let InOperandList = (ins ptr_rc:$event, i8imm:$size);
+  let InOperandList = (ins ptr_rc:$event, unknown:$size);
   let AsmString = "# XRay Custom Event Log.";
-  let usesCustomInserter = 1;
-  let isCall = 1;
-  let mayLoad = 1;
-  let mayStore = 1;
-  let hasSideEffects = 1;
+  let usesCustomInserter = true;
+  let isCall = true;
+  let mayLoad = true;
+  let mayStore = true;
+  let hasSideEffects = true;
 }
 def PATCHABLE_TYPED_EVENT_CALL : StandardPseudoInstruction {
   let OutOperandList = (outs);
-  let InOperandList = (ins i16imm:$type, ptr_rc:$event, i32imm:$size);
+  let InOperandList = (ins unknown:$type, ptr_rc:$event, unknown:$size);
   let AsmString = "# XRay Typed Event Log.";
-  let usesCustomInserter = 1;
-  let isCall = 1;
-  let mayLoad = 1;
-  let mayStore = 1;
-  let hasSideEffects = 1;
+  let usesCustomInserter = true;
+  let isCall = true;
+  let mayLoad = true;
+  let mayStore = true;
+  let hasSideEffects = true;
 }
 def FENTRY_CALL : StandardPseudoInstruction {
   let OutOperandList = (outs);
   let InOperandList = (ins);
   let AsmString = "# FEntry call";
-  let usesCustomInserter = 1;
-  let mayLoad = 1;
-  let mayStore = 1;
-  let hasSideEffects = 1;
+  let usesCustomInserter = true;
+  let isCall = true;
+  let mayLoad = true;
+  let mayStore = true;
+  let hasSideEffects = true;
 }
 def ICALL_BRANCH_FUNNEL : StandardPseudoInstruction {
   let OutOperandList = (outs);
   let InOperandList = (ins variable_ops);
   let AsmString = "";
-  let hasSideEffects = 1;
+  let hasSideEffects = true;
 }
 
 // Generic opcodes used in GlobalISel.
@@ -1236,7 +1317,7 @@
 
   // ShouldEmitMatchRegisterName - Set to false if the target needs a hand
   // written register name matcher
-  bit ShouldEmitMatchRegisterName = 1;
+  bit ShouldEmitMatchRegisterName = true;
 
   // Set to true if the target needs a generated 'alternative register name'
   // matcher.
@@ -1244,7 +1325,7 @@
   // This generates a function which can be used to lookup registers from
   // their aliases. This function will fail when called on targets where
   // several registers share the same alias (i.e. not a 1:1 mapping).
-  bit ShouldEmitMatchRegisterAltName = 0;
+  bit ShouldEmitMatchRegisterAltName = false;
 
   // Set to true if MatchRegisterName and MatchRegisterAltName functions
   // should be generated even if there are duplicate register names. The
@@ -1252,19 +1333,19 @@
   // (e.g. in validateTargetOperandClass), and there are no guarantees about
   // which numeric register identifier will be returned in the case of
   // multiple matches.
-  bit AllowDuplicateRegisterNames = 0;
+  bit AllowDuplicateRegisterNames = false;
 
   // HasMnemonicFirst - Set to false if target instructions don't always
   // start with a mnemonic as the first token.
-  bit HasMnemonicFirst = 1;
+  bit HasMnemonicFirst = true;
 
   // ReportMultipleNearMisses -
   // When 0, the assembly matcher reports an error for one encoding or operand
   // that did not match the parsed instruction.
-  // When 1, the assmebly matcher returns a list of encodings that were close
+  // When 1, the assembly matcher returns a list of encodings that were close
   // to matching the parsed instruction, so to allow more detailed error
   // messages.
-  bit ReportMultipleNearMisses = 0;
+  bit ReportMultipleNearMisses = false;
 }
 def DefaultAsmParser : AsmParser;
 
@@ -1275,7 +1356,7 @@
 //
 class AsmParserVariant {
   // Variant - AsmParsers can be of multiple different variants.  Variants are
-  // used to support targets that need to parser multiple formats for the
+  // used to support targets that need to parse multiple formats for the
   // assembly language.
   int Variant = 0;
 
@@ -1304,11 +1385,15 @@
 }
 def DefaultAsmParserVariant : AsmParserVariant;
 
+// Operators for combining SubtargetFeatures in AssemblerPredicates
+def any_of;
+def all_of;
+
 /// AssemblerPredicate - This is a Predicate that can be used when the assembler
 /// matches instructions and aliases.
-class AssemblerPredicate<string cond, string name = ""> {
-  bit AssemblerMatcherPredicate = 1;
-  string AssemblerCondString = cond;
+class AssemblerPredicate<dag cond, string name = ""> {
+  bit AssemblerMatcherPredicate = true;
+  dag AssemblerCondDag = cond;
   string PredicateName = name;
 }
 
@@ -1382,7 +1467,7 @@
   // Setting this to 0 will cause the alias to ignore the Result instruction's
   // defined AsmMatchConverter and instead use the function generated by the
   // dag Result.
-  bit UseInstAsmMatchConverter = 1;
+  bit UseInstAsmMatchConverter = true;
 
   // Assembler variant name to use for this alias. If not specified then
   // assembler variants will be determined based on AsmString
@@ -1487,7 +1572,8 @@
 // by the scheduler.  Each Processor definition requires corresponding
 // instruction itineraries.
 //
-class Processor<string n, ProcessorItineraries pi, list<SubtargetFeature> f> {
+class Processor<string n, ProcessorItineraries pi, list<SubtargetFeature> f,
+                list<SubtargetFeature> tunef = []> {
   // Name - Chip set name.  Used by command line (-mcpu=) to determine the
   // appropriate target chip.
   //
@@ -1503,6 +1589,12 @@
 
   // Features - list of
   list<SubtargetFeature> Features = f;
+
+  // TuneFeatures - list of features for tuning for this CPU. If the target
+  // supports -mtune, this should contain the list of features used to make
+  // microarchitectural optimization decisions for a given processor.  While
+  // Features should contain the architectural features for the processor.
+  list<SubtargetFeature> TuneFeatures = tunef;
 }
 
 // ProcessorModel allows subtargets to specify the more general
@@ -1511,8 +1603,9 @@
 //
 // Although this class always passes NoItineraries to the Processor
 // class, the SchedMachineModel may still define valid Itineraries.
-class ProcessorModel<string n, SchedMachineModel m, list<SubtargetFeature> f>
-  : Processor<n, NoItineraries, f> {
+class ProcessorModel<string n, SchedMachineModel m, list<SubtargetFeature> f,
+                     list<SubtargetFeature> tunef = []>
+  : Processor<n, NoItineraries, f, tunef> {
   let SchedModel = m;
 }
 
diff --git a/linux-x64/clang/include/llvm/Target/TargetCallingConv.td b/linux-x64/clang/include/llvm/Target/TargetCallingConv.td
index 1bc03cf..b3d4fe9 100644
--- a/linux-x64/clang/include/llvm/Target/TargetCallingConv.td
+++ b/linux-x64/clang/include/llvm/Target/TargetCallingConv.td
@@ -41,6 +41,11 @@
 class CCIfByVal<CCAction A> : CCIf<"ArgFlags.isByVal()", A> {
 }
 
+/// CCIfPreallocated - If the current argument has Preallocated parameter attribute,
+/// apply Action A.
+class CCIfPreallocated<CCAction A> : CCIf<"ArgFlags.isPreallocated()", A> {
+}
+
 /// CCIfSwiftSelf - If the current argument has swiftself parameter attribute,
 /// apply Action A.
 class CCIfSwiftSelf<CCAction A> : CCIf<"ArgFlags.isSwiftSelf()", A> {
@@ -51,6 +56,11 @@
 class CCIfSwiftError<CCAction A> : CCIf<"ArgFlags.isSwiftError()", A> {
 }
 
+/// CCIfCFGuardTarget - If the current argument has cfguardtarget parameter
+/// attribute, apply Action A.
+class CCIfCFGuardTarget<CCAction A> : CCIf<"ArgFlags.isCFGuardTarget()", A> {
+}
+
 /// CCIfConsecutiveRegs - If the current argument has InConsecutiveRegs
 /// parameter attribute, apply Action A.
 class CCIfConsecutiveRegs<CCAction A> : CCIf<"ArgFlags.isInConsecutiveRegs()", A> {
@@ -152,6 +162,12 @@
   ValueType DestTy = destTy;
 }
 
+/// CCTruncToType - If applied, this truncates the specified current value to
+/// the specified type.
+class CCTruncToType<ValueType destTy> : CCAction {
+  ValueType DestTy = destTy;
+}
+
 /// CCPassIndirect - If applied, this stores the value to stack and passes the pointer
 /// as normal argument.
 class CCPassIndirect<ValueType destTy> : CCAction {
@@ -171,15 +187,15 @@
 
   /// If true, this calling convention will be emitted as externally visible in
   /// the llvm namespaces instead of as a static function.
-  bit Entry = 0;
+  bit Entry = false;
 
-  bit Custom = 0;
+  bit Custom = false;
 }
 
 /// CustomCallingConv - An instance of this is used to declare calling
 /// conventions that are implemented using a custom function of the same name.
 class CustomCallingConv : CallingConv<[]> {
-  let Custom = 1;
+  let Custom = true;
 }
 
 /// CalleeSavedRegs - A list of callee saved registers for a given calling
diff --git a/linux-x64/clang/include/llvm/Target/TargetInstrPredicate.td b/linux-x64/clang/include/llvm/Target/TargetInstrPredicate.td
index 5623461..9f2cde9 100644
--- a/linux-x64/clang/include/llvm/Target/TargetInstrPredicate.td
+++ b/linux-x64/clang/include/llvm/Target/TargetInstrPredicate.td
@@ -11,7 +11,7 @@
 // MCInstPredicate definitions are used by target scheduling models to describe
 // constraints on instructions.
 //
-// Here is an example of an MCInstPredicate definition in tablegen:
+// Here is an example of an MCInstPredicate definition in TableGen:
 //
 // def MCInstPredicateExample : CheckAll<[
 //    CheckOpcode<[BLR]>,
@@ -126,6 +126,11 @@
 // Check if register operand at index `Index` is the invalid register.
 class CheckInvalidRegOperand<int Index> : CheckOperandBase<Index>;
 
+// Return true if machine operand at position `Index` is a valid
+// register operand.
+class CheckValidRegOperand<int Index> :
+  CheckNot<CheckInvalidRegOperand<Index>>;
+
 // Check that the operand at position `Index` is immediate `Imm`.
 // If field `FunctionMapper` is a non-empty string, then function
 // `FunctionMapper` is applied to the operand value, and the return value is then
@@ -254,6 +259,20 @@
   string MachineInstrFnName = MachineInstrFn;
 }
 
+// Similar to CheckFunctionPredicate. However it assumes that MachineInstrFn is
+// a method in TargetInstrInfo, and MCInstrFn takes an extra pointer to
+// MCInstrInfo.
+//
+// It Expands to:
+//  - TIIPointer->MachineInstrFn(MI)
+//  - MCInstrFn(MI, MCII);
+class CheckFunctionPredicateWithTII<string MCInstFn, string MachineInstrFn, string
+TIIPointer = "TII"> : MCInstPredicate {
+  string MCInstFnName = MCInstFn;
+  string TIIPtrName = TIIPointer;
+  string MachineInstrFnName = MachineInstrFn;
+}
+
 // Used to classify machine instructions based on a machine instruction
 // predicate.
 //
@@ -300,8 +319,8 @@
 //  - A list of subtarget hooks (Delegates) that are called from this function.
 //
 class STIPredicateDecl<string name, MCInstPredicate default = FalsePred,
-                       bit overrides = 1, bit expandForMC = 1,
-                       bit updatesOpcodeMask = 0,
+                       bit overrides = true, bit expandForMC = true,
+                       bit updatesOpcodeMask = false,
                        list<STIPredicateDecl> delegates = []> {
   string Name = name;
 
@@ -336,7 +355,7 @@
 
 // Convenience classes and definitions used by processor scheduling models to
 // describe dependency breaking instructions and move elimination candidates.
-let UpdatesOpcodeMask = 1 in {
+let UpdatesOpcodeMask = true in {
 
 def IsZeroIdiomDecl : STIPredicateDecl<"isZeroIdiom">;
 
diff --git a/linux-x64/clang/include/llvm/Target/TargetIntrinsicInfo.h b/linux-x64/clang/include/llvm/Target/TargetIntrinsicInfo.h
index ef571b1..dc59f11 100644
--- a/linux-x64/clang/include/llvm/Target/TargetIntrinsicInfo.h
+++ b/linux-x64/clang/include/llvm/Target/TargetIntrinsicInfo.h
@@ -14,7 +14,6 @@
 #define LLVM_TARGET_TARGETINTRINSICINFO_H
 
 #include "llvm/ADT/StringRef.h"
-#include "llvm/Support/Compiler.h"
 #include <string>
 
 namespace llvm {
diff --git a/linux-x64/clang/include/llvm/Target/TargetItinerary.td b/linux-x64/clang/include/llvm/Target/TargetItinerary.td
index b68ed04..a432d4e 100644
--- a/linux-x64/clang/include/llvm/Target/TargetItinerary.td
+++ b/linux-x64/clang/include/llvm/Target/TargetItinerary.td
@@ -1,4 +1,4 @@
-//===- TargetItinerary.td - Target Itinierary Description --*- tablegen -*-===//
+//===- TargetItinerary.td - Target Itinerary Description --*- tablegen -*-====//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -8,7 +8,7 @@
 //
 // This file defines the target-independent scheduling interfaces
 // which should be implemented by each target that uses instruction
-// itineraries for scheduling. Itineraries are details reservation
+// itineraries for scheduling. Itineraries are detailed reservation
 // tables for each instruction class. They are most appropriate for
 // in-order machine with complicated scheduling or bundling constraints.
 //
@@ -127,6 +127,17 @@
   list<FuncUnit> FU = fu;
   list<Bypass> BP = bp;
   list<InstrItinData> IID = iid;
+  // The packetizer automaton to use for this itinerary. By default all
+  // itineraries for a target are bundled up into the same automaton. This only
+  // works correctly when there are no conflicts in functional unit IDs between
+  // itineraries. For example, given two itineraries A<[SLOT_A]>, B<[SLOT_B]>,
+  // SLOT_A and SLOT_B will be assigned the same functional unit index, and
+  // the generated packetizer will confuse instructions referencing these slots.
+  //
+  // To avoid this, setting PacketizerNamespace to non-"" will cause this
+  // itinerary to be generated in a different automaton. The subtarget will need
+  // to declare a method "create##Namespace##DFAPacketizer()".
+  string PacketizerNamespace = "";
 }
 
 // NoItineraries - A marker that can be used by processors without schedule
diff --git a/linux-x64/clang/include/llvm/Target/TargetLoweringObjectFile.h b/linux-x64/clang/include/llvm/Target/TargetLoweringObjectFile.h
index 7e094a1..ff27cea 100644
--- a/linux-x64/clang/include/llvm/Target/TargetLoweringObjectFile.h
+++ b/linux-x64/clang/include/llvm/Target/TargetLoweringObjectFile.h
@@ -14,16 +14,17 @@
 #ifndef LLVM_CODEGEN_TARGETLOWERINGOBJECTFILE_H
 #define LLVM_CODEGEN_TARGETLOWERINGOBJECTFILE_H
 
-#include "llvm/ADT/ArrayRef.h"
-#include "llvm/ADT/StringRef.h"
-#include "llvm/IR/Module.h"
 #include "llvm/MC/MCObjectFileInfo.h"
-#include "llvm/MC/SectionKind.h"
 #include <cstdint>
 
 namespace llvm {
 
+class Constant;
+class DataLayout;
+class Function;
+class GlobalObject;
 class GlobalValue;
+class MachineBasicBlock;
 class MachineModuleInfo;
 class Mangler;
 class MCContext;
@@ -33,11 +34,13 @@
 class MCSymbolRefExpr;
 class MCStreamer;
 class MCValue;
+class Module;
+class SectionKind;
+class StringRef;
 class TargetMachine;
+class DSOLocalEquivalent;
 
 class TargetLoweringObjectFile : public MCObjectFileInfo {
-  MCContext *Ctx = nullptr;
-
   /// Name-mangler for global names.
   Mangler *Mang = nullptr;
 
@@ -45,12 +48,14 @@
   bool SupportIndirectSymViaGOTPCRel = false;
   bool SupportGOTPCRelWithOffset = true;
   bool SupportDebugThreadLocalLocation = true;
+  bool SupportDSOLocalEquivalentLowering = false;
 
   /// PersonalityEncoding, LSDAEncoding, TTypeEncoding - Some encoding values
   /// for EH.
   unsigned PersonalityEncoding = 0;
   unsigned LSDAEncoding = 0;
   unsigned TTypeEncoding = 0;
+  unsigned CallSiteEncoding = 0;
 
   /// This section contains the static constructor pointer list.
   MCSection *StaticCtorSection = nullptr;
@@ -58,6 +63,8 @@
   /// This section contains the static destructor pointer list.
   MCSection *StaticDtorSection = nullptr;
 
+  const TargetMachine *TM = nullptr;
+
 public:
   TargetLoweringObjectFile() = default;
   TargetLoweringObjectFile(const TargetLoweringObjectFile &) = delete;
@@ -65,7 +72,6 @@
   operator=(const TargetLoweringObjectFile &) = delete;
   virtual ~TargetLoweringObjectFile();
 
-  MCContext &getContext() const { return *Ctx; }
   Mangler &getMangler() const { return *Mang; }
 
   /// This method must be called before any actual lowering is done.  This
@@ -79,15 +85,22 @@
   /// Emit the module-level metadata that the platform cares about.
   virtual void emitModuleMetadata(MCStreamer &Streamer, Module &M) const {}
 
+  /// Emit Call Graph Profile metadata.
+  void emitCGProfileMetadata(MCStreamer &Streamer, Module &M) const;
+
   /// Get the module-level metadata that the platform cares about.
   virtual void getModuleMetadata(Module &M) {}
 
   /// Given a constant with the SectionKind, return a section that it should be
   /// placed in.
   virtual MCSection *getSectionForConstant(const DataLayout &DL,
-                                           SectionKind Kind,
-                                           const Constant *C,
-                                           unsigned &Align) const;
+                                           SectionKind Kind, const Constant *C,
+                                           Align &Alignment) const;
+
+  virtual MCSection *
+  getSectionForMachineBasicBlock(const Function &F,
+                                 const MachineBasicBlock &MBB,
+                                 const TargetMachine &TM) const;
 
   /// Classify the specified global variable into a set of target independent
   /// categories embodied in SectionKind.
@@ -104,9 +117,7 @@
   /// variable or function definition. This should not be passed external (or
   /// available externally) globals.
   MCSection *SectionForGlobal(const GlobalObject *GO,
-                              const TargetMachine &TM) const {
-    return SectionForGlobal(GO, getKindForGlobal(GO, TM), TM);
-  }
+                              const TargetMachine &TM) const;
 
   virtual void getNameWithPrefix(SmallVectorImpl<char> &OutName,
                                  const GlobalValue *GV,
@@ -114,6 +125,10 @@
 
   virtual MCSection *getSectionForJumpTable(const Function &F,
                                             const TargetMachine &TM) const;
+  virtual MCSection *getSectionForLSDA(const Function &F,
+                                       const TargetMachine &TM) const {
+    return LSDASection;
+  }
 
   virtual bool shouldPutJumpTableInFunctionSection(bool UsesLabelDifference,
                                                    const Function &F) const;
@@ -147,6 +162,7 @@
   unsigned getPersonalityEncoding() const { return PersonalityEncoding; }
   unsigned getLSDAEncoding() const { return LSDAEncoding; }
   unsigned getTTypeEncoding() const { return TTypeEncoding; }
+  unsigned getCallSiteEncoding() const;
 
   const MCExpr *getTTypeReference(const MCSymbolRefExpr *Sym, unsigned Encoding,
                                   MCStreamer &Streamer) const;
@@ -171,6 +187,17 @@
     return nullptr;
   }
 
+  /// Target supports a native lowering of a dso_local_equivalent constant
+  /// without needing to replace it with equivalent IR.
+  bool supportDSOLocalEquivalentLowering() const {
+    return SupportDSOLocalEquivalentLowering;
+  }
+
+  virtual const MCExpr *lowerDSOLocalEquivalent(const DSOLocalEquivalent *Equiv,
+                                                const TargetMachine &TM) const {
+    return nullptr;
+  }
+
   /// Target supports replacing a data "PC"-relative access to a symbol
   /// through another symbol, by accessing the later via a GOT entry instead?
   bool supportIndirectSymViaGOTPCRel() const {
@@ -189,7 +216,8 @@
   }
 
   /// Get the target specific PC relative GOT entry relocation
-  virtual const MCExpr *getIndirectSymViaGOTPCRel(const MCSymbol *Sym,
+  virtual const MCExpr *getIndirectSymViaGOTPCRel(const GlobalValue *GV,
+                                                  const MCSymbol *Sym,
                                                   const MCValue &MV,
                                                   int64_t Offset,
                                                   MachineModuleInfo *MMI,
@@ -197,18 +225,51 @@
     return nullptr;
   }
 
-  virtual void emitLinkerFlagsForGlobal(raw_ostream &OS,
-                                        const GlobalValue *GV) const {}
-
-  virtual void emitLinkerFlagsForUsed(raw_ostream &OS,
-                                      const GlobalValue *GV) const {}
-
   /// If supported, return the section to use for the llvm.commandline
   /// metadata. Otherwise, return nullptr.
   virtual MCSection *getSectionForCommandLines() const {
     return nullptr;
   }
 
+  /// On targets that use separate function descriptor symbols, return a section
+  /// for the descriptor given its symbol. Use only with defined functions.
+  virtual MCSection *
+  getSectionForFunctionDescriptor(const Function *F,
+                                  const TargetMachine &TM) const {
+    return nullptr;
+  }
+
+  /// On targets that support TOC entries, return a section for the entry given
+  /// the symbol it refers to.
+  /// TODO: Implement this interface for existing ELF targets.
+  virtual MCSection *getSectionForTOCEntry(const MCSymbol *S,
+                                           const TargetMachine &TM) const {
+    return nullptr;
+  }
+
+  /// On targets that associate external references with a section, return such
+  /// a section for the given external global.
+  virtual MCSection *
+  getSectionForExternalReference(const GlobalObject *GO,
+                                 const TargetMachine &TM) const {
+    return nullptr;
+  }
+
+  /// Targets that have a special convention for their symbols could use
+  /// this hook to return a specialized symbol.
+  virtual MCSymbol *getTargetSymbol(const GlobalValue *GV,
+                                    const TargetMachine &TM) const {
+    return nullptr;
+  }
+
+  /// If supported, return the function entry point symbol.
+  /// Otherwise, returns nulltpr.
+  /// Func must be a function or an alias which has a function as base object.
+  virtual MCSymbol *getFunctionEntryPointSymbol(const GlobalValue *Func,
+                                                const TargetMachine &TM) const {
+    return nullptr;
+  }
+
 protected:
   virtual MCSection *SelectSectionForGlobal(const GlobalObject *GO,
                                             SectionKind Kind,
diff --git a/linux-x64/clang/include/llvm/Target/TargetMachine.h b/linux-x64/clang/include/llvm/Target/TargetMachine.h
index cdf9f8b..e1fb53d 100644
--- a/linux-x64/clang/include/llvm/Target/TargetMachine.h
+++ b/linux-x64/clang/include/llvm/Target/TargetMachine.h
@@ -16,24 +16,36 @@
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/IR/DataLayout.h"
+#include "llvm/IR/PassManager.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/CodeGen.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Target/CGPassBuilderOption.h"
 #include "llvm/Target/TargetOptions.h"
 #include <string>
 
 namespace llvm {
 
+class AAManager;
+template <typename IRUnitT, typename AnalysisManagerT, typename... ExtraArgTs>
+class PassManager;
+using ModulePassManager = PassManager<Module>;
+
 class Function;
 class GlobalValue;
-class MachineModuleInfo;
+class MachineFunctionPassManager;
+class MachineFunctionAnalysisManager;
+class MachineModuleInfoWrapperPass;
 class Mangler;
 class MCAsmInfo;
 class MCContext;
 class MCInstrInfo;
 class MCRegisterInfo;
+class MCStreamer;
 class MCSubtargetInfo;
 class MCSymbol;
 class raw_pwrite_stream;
+class PassBuilder;
 class PassManagerBuilder;
 struct PerFunctionMIParsingState;
 class SMDiagnostic;
@@ -111,6 +123,7 @@
   const Triple &getTargetTriple() const { return TargetTriple; }
   StringRef getTargetCPU() const { return TargetCPU; }
   StringRef getTargetFeatureString() const { return TargetFS; }
+  void setTargetFeatureString(StringRef FS) { TargetFS = std::string(FS); }
 
   /// Virtual method implemented by subclasses that returns a reference to that
   /// target's TargetSubtargetInfo-derived member variable.
@@ -237,11 +250,21 @@
   void setSupportsDefaultOutlining(bool Enable) {
     Options.SupportsDefaultOutlining = Enable;
   }
+  void setSupportsDebugEntryValues(bool Enable) {
+    Options.SupportsDebugEntryValues = Enable;
+  }
 
-  bool shouldPrintMachineCode() const { return Options.PrintMachineCode; }
+  bool getAIXExtendedAltivecABI() const {
+    return Options.EnableAIXExtendedAltivecABI;
+  }
 
   bool getUniqueSectionNames() const { return Options.UniqueSectionNames; }
 
+  /// Return true if unique basic block section names must be generated.
+  bool getUniqueBasicBlockSectionNames() const {
+    return Options.UniqueBasicBlockSectionNames;
+  }
+
   /// Return true if data objects should be emitted into their own section,
   /// corresponds to -fdata-sections.
   bool getDataSections() const {
@@ -254,6 +277,40 @@
     return Options.FunctionSections;
   }
 
+  /// Return true if visibility attribute should not be emitted in XCOFF,
+  /// corresponding to -mignore-xcoff-visibility.
+  bool getIgnoreXCOFFVisibility() const {
+    return Options.IgnoreXCOFFVisibility;
+  }
+
+  /// Return true if XCOFF traceback table should be emitted,
+  /// corresponding to -xcoff-traceback-table.
+  bool getXCOFFTracebackTable() const { return Options.XCOFFTracebackTable; }
+
+  /// If basic blocks should be emitted into their own section,
+  /// corresponding to -fbasic-block-sections.
+  llvm::BasicBlockSection getBBSectionsType() const {
+    return Options.BBSections;
+  }
+
+  /// Get the list of functions and basic block ids that need unique sections.
+  const MemoryBuffer *getBBSectionsFuncListBuf() const {
+    return Options.BBSectionsFuncListBuf.get();
+  }
+
+  /// Returns true if a cast between SrcAS and DestAS is a noop.
+  virtual bool isNoopAddrSpaceCast(unsigned SrcAS, unsigned DestAS) const {
+    return false;
+  }
+
+  /// If the specified generic pointer could be assumed as a pointer to a
+  /// specific address space, return that address space.
+  ///
+  /// Under offloading programming, the offloading target may be passed with
+  /// values only prepared on the host side and could assume certain
+  /// properties.
+  virtual unsigned getAssumedAddrSpace(const Value *V) const { return -1; }
+
   /// Get a \c TargetIRAnalysis appropriate for the target.
   ///
   /// This is used to construct the new pass manager's target IR analysis pass,
@@ -271,25 +328,26 @@
   /// PassManagerBuilder::addExtension.
   virtual void adjustPassManager(PassManagerBuilder &) {}
 
-  /// These enums are meant to be passed into addPassesToEmitFile to indicate
-  /// what type of file to emit, and returned by it to indicate what type of
-  /// file could actually be made.
-  enum CodeGenFileType {
-    CGFT_AssemblyFile,
-    CGFT_ObjectFile,
-    CGFT_Null         // Do not emit any output.
-  };
+  /// Allow the target to modify the pass pipeline with New Pass Manager
+  /// (similar to adjustPassManager for Legacy Pass manager).
+  virtual void registerPassBuilderCallbacks(PassBuilder &,
+                                            bool DebugPassManager) {}
+
+  /// Allow the target to register alias analyses with the AAManager for use
+  /// with the new pass manager. Only affects the "default" AAManager.
+  virtual void registerDefaultAliasAnalyses(AAManager &) {}
 
   /// Add passes to the specified pass manager to get the specified file
   /// emitted.  Typically this will involve several steps of code generation.
   /// This method should return true if emission of this file type is not
   /// supported, or false on success.
-  /// \p MMI is an optional parameter that, if set to non-nullptr,
+  /// \p MMIWP is an optional parameter that, if set to non-nullptr,
   /// will be used to set the MachineModuloInfo for this PM.
-  virtual bool addPassesToEmitFile(PassManagerBase &, raw_pwrite_stream &,
-                                   raw_pwrite_stream *, CodeGenFileType,
-                                   bool /*DisableVerify*/ = true,
-                                   MachineModuleInfo *MMI = nullptr) {
+  virtual bool
+  addPassesToEmitFile(PassManagerBase &, raw_pwrite_stream &,
+                      raw_pwrite_stream *, CodeGenFileType,
+                      bool /*DisableVerify*/ = true,
+                      MachineModuleInfoWrapperPass *MMIWP = nullptr) {
     return true;
   }
 
@@ -314,6 +372,10 @@
   void getNameWithPrefix(SmallVectorImpl<char> &Name, const GlobalValue *GV,
                          Mangler &Mang, bool MayAlwaysUsePrivate = false) const;
   MCSymbol *getSymbol(const GlobalValue *GV) const;
+
+  /// The integer bit size to use for SjLj based exception handling.
+  static constexpr unsigned DefaultSjLjDataSize = 32;
+  virtual unsigned getSjLjDataSize() const { return DefaultSjLjDataSize; }
 };
 
 /// This class describes a target machine that is implemented with the LLVM
@@ -341,12 +403,28 @@
 
   /// Add passes to the specified pass manager to get the specified file
   /// emitted.  Typically this will involve several steps of code generation.
-  /// \p MMI is an optional parameter that, if set to non-nullptr,
-  /// will be used to set the MachineModuloInfofor this PM.
-  bool addPassesToEmitFile(PassManagerBase &PM, raw_pwrite_stream &Out,
-                           raw_pwrite_stream *DwoOut, CodeGenFileType FileType,
-                           bool DisableVerify = true,
-                           MachineModuleInfo *MMI = nullptr) override;
+  /// \p MMIWP is an optional parameter that, if set to non-nullptr,
+  /// will be used to set the MachineModuloInfo for this PM.
+  bool
+  addPassesToEmitFile(PassManagerBase &PM, raw_pwrite_stream &Out,
+                      raw_pwrite_stream *DwoOut, CodeGenFileType FileType,
+                      bool DisableVerify = true,
+                      MachineModuleInfoWrapperPass *MMIWP = nullptr) override;
+
+  virtual Error buildCodeGenPipeline(ModulePassManager &,
+                                     MachineFunctionPassManager &,
+                                     MachineFunctionAnalysisManager &,
+                                     raw_pwrite_stream &, raw_pwrite_stream *,
+                                     CodeGenFileType, CGPassBuilderOption,
+                                     PassInstrumentationCallbacks *) {
+    return make_error<StringError>("buildCodeGenPipeline is not overriden",
+                                   inconvertibleErrorCode());
+  }
+
+  virtual std::pair<StringRef, bool> getPassNameFromLegacyName(StringRef) {
+    llvm_unreachable(
+        "getPassNameFromLegacyName parseMIRPipeline is not overriden");
+  }
 
   /// Add passes to the specified pass manager to get machine code emitted with
   /// the MCJIT. This method returns true if machine code is not supported. It
@@ -365,14 +443,20 @@
   /// Adds an AsmPrinter pass to the pipeline that prints assembly or
   /// machine code from the MI representation.
   bool addAsmPrinter(PassManagerBase &PM, raw_pwrite_stream &Out,
-                     raw_pwrite_stream *DwoOut, CodeGenFileType FileTYpe,
+                     raw_pwrite_stream *DwoOut, CodeGenFileType FileType,
                      MCContext &Context);
 
-  /// True if the target uses physical regs at Prolog/Epilog insertion
-  /// time. If true (most machines), all vregs must be allocated before
-  /// PEI. If false (virtual-register machines), then callee-save register
-  /// spilling and scavenging are not needed or used.
-  virtual bool usesPhysRegsForPEI() const { return true; }
+  Expected<std::unique_ptr<MCStreamer>>
+  createMCStreamer(raw_pwrite_stream &Out, raw_pwrite_stream *DwoOut,
+                   CodeGenFileType FileType, MCContext &Ctx);
+
+  /// True if the target uses physical regs (as nearly all targets do). False
+  /// for stack machines such as WebAssembly and other virtual-register
+  /// machines. If true, all vregs must be allocated before PEI. If false, then
+  /// callee-save register spilling and scavenging are not needed or used. If
+  /// false, implicitly defined registers will still be assumed to be physical
+  /// registers, except that variadic defs will be allocated vregs.
+  virtual bool usesPhysRegsForValues() const { return true; }
 
   /// True if the target wants to use interprocedural register allocation by
   /// default. The -enable-ipra flag can be used to override this.
diff --git a/linux-x64/clang/include/llvm/Target/TargetOptions.h b/linux-x64/clang/include/llvm/Target/TargetOptions.h
index 8cc2a60..91d3726 100644
--- a/linux-x64/clang/include/llvm/Target/TargetOptions.h
+++ b/linux-x64/clang/include/llvm/Target/TargetOptions.h
@@ -14,11 +14,15 @@
 #ifndef LLVM_TARGET_TARGETOPTIONS_H
 #define LLVM_TARGET_TARGETOPTIONS_H
 
+#include "llvm/ADT/FloatingPointMode.h"
 #include "llvm/MC/MCTargetOptions.h"
 
+#include <memory>
+
 namespace llvm {
+  struct fltSemantics;
   class MachineFunction;
-  class Module;
+  class MemoryBuffer;
 
   namespace FloatABI {
     enum ABIType {
@@ -54,14 +58,26 @@
     };
   }
 
-  namespace FPDenormal {
-    enum DenormalMode {
-      IEEE,           // IEEE 754 denormal numbers
-      PreserveSign,   // the sign of a flushed-to-zero number is preserved in
-                      // the sign of 0
-      PositiveZero    // denormals are flushed to positive zero
-    };
-  }
+  enum class BasicBlockSection {
+    All,    // Use Basic Block Sections for all basic blocks.  A section
+            // for every basic block can significantly bloat object file sizes.
+    List,   // Get list of functions & BBs from a file. Selectively enables
+            // basic block sections for a subset of basic blocks which can be
+            // used to control object size bloats from creating sections.
+    Labels, // Do not use Basic Block Sections but label basic blocks.  This
+            // is useful when associating profile counts from virtual addresses
+            // to basic blocks.
+    Preset, // Similar to list but the blocks are identified by passes which
+            // seek to use Basic Block Sections, e.g. MachineFunctionSplitter.
+            // This option cannot be set via the command line.
+    None    // Do not use Basic Block Sections.
+  };
+
+  enum class StackProtectorGuards {
+    None,
+    TLS,
+    Global
+  };
 
   enum class EABI {
     Unknown,
@@ -106,25 +122,25 @@
   class TargetOptions {
   public:
     TargetOptions()
-        : PrintMachineCode(false), UnsafeFPMath(false), NoInfsFPMath(false),
-          NoNaNsFPMath(false), NoTrappingFPMath(false),
-          NoSignedZerosFPMath(false),
+        : UnsafeFPMath(false), NoInfsFPMath(false), NoNaNsFPMath(false),
+          NoTrappingFPMath(true), NoSignedZerosFPMath(false),
+          EnableAIXExtendedAltivecABI(false),
           HonorSignDependentRoundingFPMathOption(false), NoZerosInBSS(false),
           GuaranteedTailCallOpt(false), StackSymbolOrdering(true),
           EnableFastISel(false), EnableGlobalISel(false), UseInitArray(false),
           DisableIntegratedAS(false), RelaxELFRelocations(false),
           FunctionSections(false), DataSections(false),
-          UniqueSectionNames(true), TrapUnreachable(false),
-          NoTrapAfterNoreturn(false), EmulatedTLS(false),
-          ExplicitEmulatedTLS(false), EnableIPRA(false),
+          IgnoreXCOFFVisibility(false), XCOFFTracebackTable(true),
+          UniqueSectionNames(true), UniqueBasicBlockSectionNames(false),
+          TrapUnreachable(false), NoTrapAfterNoreturn(false), TLSSize(0),
+          EmulatedTLS(false), ExplicitEmulatedTLS(false), EnableIPRA(false),
           EmitStackSizeSection(false), EnableMachineOutliner(false),
-          SupportsDefaultOutlining(false), EmitAddrsig(false),
-          EnableDebugEntryValues(false) {}
-
-    /// PrintMachineCode - This flag is enabled when the -print-machineinstrs
-    /// option is specified on the command line, and should enable debugging
-    /// output from the code generator.
-    unsigned PrintMachineCode : 1;
+          EnableMachineFunctionSplitter(false), SupportsDefaultOutlining(false),
+          EmitAddrsig(false), EmitCallSiteInfo(false),
+          SupportsDebugEntryValues(false), EnableDebugEntryValues(false),
+          PseudoProbeForProfiling(false), ValueTrackingVariableLocations(false),
+          ForceDwarfFrameSection(false), XRayOmitFunctionIndex(false),
+          FPDenormalMode(DenormalMode::IEEE, DenormalMode::IEEE) {}
 
     /// DisableFramePointerElim - This returns true if frame pointer elimination
     /// optimization should be disabled for the given machine function.
@@ -160,6 +176,12 @@
     /// argument or result as insignificant.
     unsigned NoSignedZerosFPMath : 1;
 
+    /// EnableAIXExtendedAltivecABI - This flag returns true when -vec-extabi is
+    /// specified. The code generator is then able to use both volatile and
+    /// nonvolitle vector regisers. When false, the code generator only uses
+    /// volatile vector registers which is the default setting on AIX.
+    unsigned EnableAIXExtendedAltivecABI : 1;
+
     /// HonorSignDependentRoundingFPMath - This returns true when the
     /// -enable-sign-dependent-rounding-fp-math is specified.  If this returns
     /// false (the default), the code generator is allowed to assume that the
@@ -222,8 +244,17 @@
     /// Emit data into separate sections.
     unsigned DataSections : 1;
 
+    /// Do not emit visibility attribute for xcoff.
+    unsigned IgnoreXCOFFVisibility : 1;
+
+    /// Emit XCOFF traceback table.
+    unsigned XCOFFTracebackTable : 1;
+
     unsigned UniqueSectionNames : 1;
 
+    /// Use unique names for basic block sections.
+    unsigned UniqueBasicBlockSectionNames : 1;
+
     /// Emit target-specific trap instruction for 'unreachable' IR instructions.
     unsigned TrapUnreachable : 1;
 
@@ -231,6 +262,9 @@
     /// noreturn calls, even if TrapUnreachable is true.
     unsigned NoTrapAfterNoreturn : 1;
 
+    /// Bit size of immediate TLS offsets (0 == use the default).
+    unsigned TLSSize : 8;
+
     /// EmulatedTLS - This flag enables emulated TLS model, using emutls
     /// function in the runtime library..
     unsigned EmulatedTLS : 1;
@@ -247,14 +281,60 @@
     /// Enables the MachineOutliner pass.
     unsigned EnableMachineOutliner : 1;
 
+    /// Enables the MachineFunctionSplitter pass.
+    unsigned EnableMachineFunctionSplitter : 1;
+
     /// Set if the target supports default outlining behaviour.
     unsigned SupportsDefaultOutlining : 1;
 
     /// Emit address-significance table.
     unsigned EmitAddrsig : 1;
 
-    /// Emit debug info about parameter's entry values.
-    unsigned EnableDebugEntryValues : 1;
+    /// Emit basic blocks into separate sections.
+    BasicBlockSection BBSections = BasicBlockSection::None;
+
+    /// Memory Buffer that contains information on sampled basic blocks and used
+    /// to selectively generate basic block sections.
+    std::shared_ptr<MemoryBuffer> BBSectionsFuncListBuf;
+
+    /// The flag enables call site info production. It is used only for debug
+    /// info, and it is restricted only to optimized code. This can be used for
+    /// something else, so that should be controlled in the frontend.
+    unsigned EmitCallSiteInfo : 1;
+    /// Set if the target supports the debug entry values by default.
+    unsigned SupportsDebugEntryValues : 1;
+    /// When set to true, the EnableDebugEntryValues option forces production
+    /// of debug entry values even if the target does not officially support
+    /// it. Useful for testing purposes only. This flag should never be checked
+    /// directly, always use \ref ShouldEmitDebugEntryValues instead.
+     unsigned EnableDebugEntryValues : 1;
+    /// NOTE: There are targets that still do not support the debug entry values
+    /// production.
+    bool ShouldEmitDebugEntryValues() const;
+
+    /// Emit pseudo probes into the binary for sample profiling
+    unsigned PseudoProbeForProfiling : 1;
+
+    // When set to true, use experimental new debug variable location tracking,
+    // which seeks to follow the values of variables rather than their location,
+    // post isel.
+    unsigned ValueTrackingVariableLocations : 1;
+
+    /// Emit DWARF debug frame section.
+    unsigned ForceDwarfFrameSection : 1;
+
+    /// Emit XRay Function Index section
+    unsigned XRayOmitFunctionIndex : 1;
+
+    /// Stack protector guard offset to use.
+    unsigned StackProtectorGuardOffset : 32;
+
+    /// Stack protector guard mode to use, e.g. tls, global.
+    StackProtectorGuards StackProtectorGuard =
+                                         StackProtectorGuards::None;
+
+    /// Stack protector guard reg to use, e.g. usually fs or gs in X86.
+    std::string StackProtectorGuardReg = "None";
 
     /// FloatABIType - This setting is set by -float-abi=xxx option is specfied
     /// on the command line. This setting may either be Default, Soft, or Hard.
@@ -292,9 +372,32 @@
     /// Which debugger to tune for.
     DebuggerKind DebuggerTuning = DebuggerKind::Default;
 
-    /// FPDenormalMode - This flags specificies which denormal numbers the code
-    /// is permitted to require.
-    FPDenormal::DenormalMode FPDenormalMode = FPDenormal::IEEE;
+  private:
+    /// Flushing mode to assume in default FP environment.
+    DenormalMode FPDenormalMode;
+
+    /// Flushing mode to assume in default FP environment, for float/vector of
+    /// float.
+    DenormalMode FP32DenormalMode;
+
+  public:
+    void setFPDenormalMode(DenormalMode Mode) {
+      FPDenormalMode = Mode;
+    }
+
+    void setFP32DenormalMode(DenormalMode Mode) {
+      FP32DenormalMode = Mode;
+    }
+
+    DenormalMode getRawFPDenormalMode() const {
+      return FPDenormalMode;
+    }
+
+    DenormalMode getRawFP32DenormalMode() const {
+      return FP32DenormalMode;
+    }
+
+    DenormalMode getDenormalMode(const fltSemantics &FPType) const;
 
     /// What exception model to use
     ExceptionHandling ExceptionModel = ExceptionHandling::None;
diff --git a/linux-x64/clang/include/llvm/Target/TargetPfmCounters.td b/linux-x64/clang/include/llvm/Target/TargetPfmCounters.td
index e1d5013..b00f3e1 100644
--- a/linux-x64/clang/include/llvm/Target/TargetPfmCounters.td
+++ b/linux-x64/clang/include/llvm/Target/TargetPfmCounters.td
@@ -7,6 +7,8 @@
 //===----------------------------------------------------------------------===//
 //
 // This file defines the target-independent interfaces for performance counters.
+//
+//===----------------------------------------------------------------------===//
 
 // Definition of a hardware counters from libpfm identifiers.
 class PfmCounter<string counter> {
diff --git a/linux-x64/clang/include/llvm/Target/TargetSchedule.td b/linux-x64/clang/include/llvm/Target/TargetSchedule.td
index a36d259..a822878 100644
--- a/linux-x64/clang/include/llvm/Target/TargetSchedule.td
+++ b/linux-x64/clang/include/llvm/Target/TargetSchedule.td
@@ -87,7 +87,7 @@
   // Per-cycle resources tables.
   ProcessorItineraries Itineraries = NoItineraries;
 
-  bit PostRAScheduler = 0; // Enable Post RegAlloc Scheduler pass.
+  bit PostRAScheduler = false; // Enable Post RegAlloc Scheduler pass.
 
   // Subtargets that define a model for only a subset of instructions
   // that have a scheduling class (itinerary class or SchedRW list)
@@ -96,13 +96,13 @@
   // be an error. This should only be set during initial bringup,
   // or there will be no way to catch simple errors in the model
   // resulting from changes to the instruction definitions.
-  bit CompleteModel = 1;
+  bit CompleteModel = true;
 
   // Indicates that we should do full overlap checking for multiple InstrRWs
-  // definining the same instructions within the same SchedMachineModel.
+  // defining the same instructions within the same SchedMachineModel.
   // FIXME: Remove when all in tree targets are clean with the full check
   // enabled.
-  bit FullInstRWOverlapCheck = 1;
+  bit FullInstRWOverlapCheck = true;
 
   // A processor may only implement part of published ISA, due to either new ISA
   // extensions, (e.g. Pentium 4 doesn't have AVX) or implementation
@@ -118,12 +118,12 @@
   // field.
   list<Predicate> UnsupportedFeatures = [];
 
-  bit NoModel = 0; // Special tag to indicate missing machine model.
+  bit NoModel = false; // Special tag to indicate missing machine model.
 }
 
 def NoSchedModel : SchedMachineModel {
-  let NoModel = 1;
-  let CompleteModel = 0;
+  let NoModel = true;
+  let CompleteModel = false;
 }
 
 // Define a kind of processor resource that may be common across
@@ -163,7 +163,7 @@
 // differently. Here we refer to stage between decoding into micro-ops
 // and moving them into a reservation station.) Normally NumMicroOps
 // is sufficient to limit dispatch/issue groups. However, some
-// processors can form groups of with only certain combinitions of
+// processors can form groups of with only certain combinations of
 // instruction types. e.g. POWER7.
 //
 // Use BufferSize = 1 for in-order execution units. This is used for
@@ -254,14 +254,14 @@
   list<int> ResourceCycles = [];
   int Latency = 1;
   int NumMicroOps = 1;
-  bit BeginGroup = 0;
-  bit EndGroup = 0;
+  bit BeginGroup = false;
+  bit EndGroup = false;
   // Allow a processor to mark some scheduling classes as unsupported
   // for stronger verification.
-  bit Unsupported = 0;
+  bit Unsupported = false;
   // Allow a processor to mark some scheduling classes as single-issue.
   // SingleIssue is an alias for Begin/End Group.
-  bit SingleIssue = 0;
+  bit SingleIssue = false;
   SchedMachineModel SchedModel = ?;
 }
 
@@ -317,7 +317,7 @@
   list<SchedWrite> ValidWrites = writes;
   // Allow a processor to mark some scheduling classes as unsupported
   // for stronger verification.
-  bit Unsupported = 0;
+  bit Unsupported = false;
   SchedMachineModel SchedModel = ?;
 }
 
@@ -395,7 +395,7 @@
 // SchedModel silences warnings but is ignored.
 class SchedVariant<list<SchedVar> variants> {
   list<SchedVar> Variants = variants;
-  bit Variadic = 0;
+  bit Variadic = false;
   SchedMachineModel SchedModel = ?;
 }
 
@@ -428,7 +428,7 @@
   dag Instrs = instrlist;
   SchedMachineModel SchedModel = ?;
   // Allow a subtarget to mark some instructions as unsupported.
-  bit Unsupported = 0;
+  bit Unsupported = false;
 }
 
 // Map a set of itinerary classes to SchedReadWrite resources. This is
@@ -535,7 +535,7 @@
 
 class RegisterFile<int numPhysRegs, list<RegisterClass> Classes = [],
                    list<int> Costs = [], list<bit> AllowMoveElim = [],
-                   int MaxMoveElimPerCy = 0, bit AllowZeroMoveElimOnly = 0> {
+                   int MaxMoveElimPerCy = 0, bit AllowZeroMoveElimOnly = false> {
   list<RegisterClass> RegClasses = Classes;
   list<int> RegCosts = Costs;
   list<bit> AllowMoveElimination = AllowMoveElim;
@@ -563,10 +563,10 @@
 
 // Base class for Load/StoreQueue.  It is used to identify processor resources
 // which describe load/store queues in the LS unit.
-class MemoryQueue<ProcResource PR> {
-  ProcResource QueueDescriptor = PR;
+class MemoryQueue<ProcResourceKind PR> {
+  ProcResourceKind QueueDescriptor = PR;
   SchedMachineModel SchedModel = ?;
 }
 
-class LoadQueue<ProcResource LDQueue> : MemoryQueue<LDQueue>;
-class StoreQueue<ProcResource STQueue> : MemoryQueue<STQueue>;
+class LoadQueue<ProcResourceKind LDQueue> : MemoryQueue<LDQueue>;
+class StoreQueue<ProcResourceKind STQueue> : MemoryQueue<STQueue>;
diff --git a/linux-x64/clang/include/llvm/Target/TargetSelectionDAG.td b/linux-x64/clang/include/llvm/Target/TargetSelectionDAG.td
index 3b5c767..a09feca 100644
--- a/linux-x64/clang/include/llvm/Target/TargetSelectionDAG.td
+++ b/linux-x64/clang/include/llvm/Target/TargetSelectionDAG.td
@@ -124,7 +124,7 @@
 def SDTIntBinHiLoOp : SDTypeProfile<2, 2, [ // mulhi, mullo, sdivrem, udivrem
   SDTCisSameAs<0, 1>, SDTCisSameAs<0, 2>, SDTCisSameAs<0, 3>,SDTCisInt<0>
 ]>;
-def SDTIntScaledBinOp : SDTypeProfile<1, 3, [  // smulfix, umulfix
+def SDTIntScaledBinOp : SDTypeProfile<1, 3, [  // smulfix, sdivfix, etc
   SDTCisSameAs<0, 1>, SDTCisSameAs<0, 2>, SDTCisInt<0>, SDTCisInt<3>
 ]>;
 
@@ -137,9 +137,12 @@
 def SDTFPTernaryOp : SDTypeProfile<1, 3, [  // fmadd, fnmsub, etc.
   SDTCisSameAs<0, 1>, SDTCisSameAs<0, 2>, SDTCisSameAs<0, 3>, SDTCisFP<0>
 ]>;
-def SDTIntUnaryOp : SDTypeProfile<1, 1, [   // ctlz, cttz
+def SDTIntUnaryOp : SDTypeProfile<1, 1, [ // bitreverse
   SDTCisSameAs<0, 1>, SDTCisInt<0>
 ]>;
+def SDTIntBitCountUnaryOp : SDTypeProfile<1, 1, [   // ctlz, cttz
+  SDTCisInt<0>, SDTCisInt<1>
+]>;
 def SDTIntExtendOp : SDTypeProfile<1, 1, [  // sext, zext, anyext
   SDTCisInt<0>, SDTCisInt<1>, SDTCisOpSmallerThanOp<1, 0>, SDTCisSameNumEltsAs<0, 1>
 ]>;
@@ -161,6 +164,9 @@
 def SDTFPToIntOp : SDTypeProfile<1, 1, [    // fp_to_[su]int
   SDTCisInt<0>, SDTCisFP<1>, SDTCisSameNumEltsAs<0, 1>
 ]>;
+def SDTFPToIntSatOp : SDTypeProfile<1, 2, [    // fp_to_[su]int_sat
+  SDTCisInt<0>, SDTCisFP<1>, SDTCisInt<2>, SDTCisSameNumEltsAs<0, 1>
+]>;
 def SDTExtInreg : SDTypeProfile<1, 2, [     // sext_inreg
   SDTCisSameAs<0, 1>, SDTCisInt<0>, SDTCisVT<2, OtherVT>,
   SDTCisVTSmallerThanOp<2, 1>
@@ -209,6 +215,8 @@
 
 def SDTNone : SDTypeProfile<0, 0, []>;      // ret, trap
 
+def SDTUBSANTrap : SDTypeProfile<0, 1, []>;      // ubsantrap
+
 def SDTLoad : SDTypeProfile<1, 1, [         // load
   SDTCisPtrTy<1>
 ]>;
@@ -221,13 +229,13 @@
   SDTCisSameAs<0, 2>, SDTCisPtrTy<0>, SDTCisPtrTy<3>
 ]>;
 
-def SDTMaskedStore: SDTypeProfile<0, 3, [       // masked store
-  SDTCisVec<0>, SDTCisPtrTy<1>, SDTCisVec<2>, SDTCisSameNumEltsAs<0, 2>
+def SDTMaskedStore: SDTypeProfile<0, 4, [       // masked store
+  SDTCisVec<0>, SDTCisPtrTy<1>, SDTCisPtrTy<2>, SDTCisVec<3>, SDTCisSameNumEltsAs<0, 3>
 ]>;
 
-def SDTMaskedLoad: SDTypeProfile<1, 3, [       // masked load
-  SDTCisVec<0>, SDTCisPtrTy<1>, SDTCisVec<2>, SDTCisSameAs<0, 3>,
-  SDTCisSameNumEltsAs<0, 2>
+def SDTMaskedLoad: SDTypeProfile<1, 4, [       // masked load
+  SDTCisVec<0>, SDTCisPtrTy<1>, SDTCisPtrTy<2>, SDTCisVec<3>, SDTCisSameAs<0, 4>,
+  SDTCisSameNumEltsAs<0, 3>
 ]>;
 
 def SDTVecShuffle : SDTypeProfile<1, 2, [
@@ -239,6 +247,13 @@
 def SDTVecInsert : SDTypeProfile<1, 3, [    // vector insert
   SDTCisEltOfVec<2, 1>, SDTCisSameAs<0, 1>, SDTCisPtrTy<3>
 ]>;
+def SDTVecReduce : SDTypeProfile<1, 1, [    // vector reduction
+  SDTCisInt<0>, SDTCisVec<1>
+]>;
+def SDTFPVecReduce : SDTypeProfile<1, 1, [  // FP vector reduction
+  SDTCisFP<0>, SDTCisVec<1>
+]>;
+
 
 def SDTSubVecExtract : SDTypeProfile<1, 2, [// subvector extract
   SDTCisSubVecOfVec<0,1>, SDTCisInt<2>
@@ -310,6 +325,7 @@
 def bb         : SDNode<"ISD::BasicBlock", SDTOther   , [], "BasicBlockSDNode">;
 def cond       : SDNode<"ISD::CONDCODE"  , SDTOther   , [], "CondCodeSDNode">;
 def undef      : SDNode<"ISD::UNDEF"     , SDTUNDEF   , []>;
+def vscale     : SDNode<"ISD::VSCALE"    , SDTIntUnaryOp, []>;
 def globaladdr : SDNode<"ISD::GlobalAddress",         SDTPtrLeaf, [],
                         "GlobalAddressSDNode">;
 def tglobaladdr : SDNode<"ISD::TargetGlobalAddress",  SDTPtrLeaf, [],
@@ -389,10 +405,17 @@
 def uaddsat    : SDNode<"ISD::UADDSAT"   , SDTIntBinOp, [SDNPCommutative]>;
 def ssubsat    : SDNode<"ISD::SSUBSAT"   , SDTIntBinOp>;
 def usubsat    : SDNode<"ISD::USUBSAT"   , SDTIntBinOp>;
+def sshlsat    : SDNode<"ISD::SSHLSAT"   , SDTIntBinOp>;
+def ushlsat    : SDNode<"ISD::USHLSAT"   , SDTIntBinOp>;
 
 def smulfix    : SDNode<"ISD::SMULFIX"   , SDTIntScaledBinOp, [SDNPCommutative]>;
 def smulfixsat : SDNode<"ISD::SMULFIXSAT", SDTIntScaledBinOp, [SDNPCommutative]>;
 def umulfix    : SDNode<"ISD::UMULFIX"   , SDTIntScaledBinOp, [SDNPCommutative]>;
+def umulfixsat : SDNode<"ISD::UMULFIXSAT", SDTIntScaledBinOp, [SDNPCommutative]>;
+def sdivfix    : SDNode<"ISD::SDIVFIX"   , SDTIntScaledBinOp>;
+def sdivfixsat : SDNode<"ISD::SDIVFIXSAT", SDTIntScaledBinOp>;
+def udivfix    : SDNode<"ISD::UDIVFIX"   , SDTIntScaledBinOp>;
+def udivfixsat : SDNode<"ISD::UDIVFIXSAT", SDTIntScaledBinOp>;
 
 def sext_inreg : SDNode<"ISD::SIGN_EXTEND_INREG", SDTExtInreg>;
 def sext_invec : SDNode<"ISD::SIGN_EXTEND_VECTOR_INREG", SDTExtInvec>;
@@ -401,11 +424,11 @@
 def abs        : SDNode<"ISD::ABS"        , SDTIntUnaryOp>;
 def bitreverse : SDNode<"ISD::BITREVERSE" , SDTIntUnaryOp>;
 def bswap      : SDNode<"ISD::BSWAP"      , SDTIntUnaryOp>;
-def ctlz       : SDNode<"ISD::CTLZ"       , SDTIntUnaryOp>;
-def cttz       : SDNode<"ISD::CTTZ"       , SDTIntUnaryOp>;
-def ctpop      : SDNode<"ISD::CTPOP"      , SDTIntUnaryOp>;
-def ctlz_zero_undef : SDNode<"ISD::CTLZ_ZERO_UNDEF", SDTIntUnaryOp>;
-def cttz_zero_undef : SDNode<"ISD::CTTZ_ZERO_UNDEF", SDTIntUnaryOp>;
+def ctlz       : SDNode<"ISD::CTLZ"       , SDTIntBitCountUnaryOp>;
+def cttz       : SDNode<"ISD::CTTZ"       , SDTIntBitCountUnaryOp>;
+def ctpop      : SDNode<"ISD::CTPOP"      , SDTIntBitCountUnaryOp>;
+def ctlz_zero_undef : SDNode<"ISD::CTLZ_ZERO_UNDEF", SDTIntBitCountUnaryOp>;
+def cttz_zero_undef : SDNode<"ISD::CTTZ_ZERO_UNDEF", SDTIntBitCountUnaryOp>;
 def sext       : SDNode<"ISD::SIGN_EXTEND", SDTIntExtendOp>;
 def zext       : SDNode<"ISD::ZERO_EXTEND", SDTIntExtendOp>;
 def anyext     : SDNode<"ISD::ANY_EXTEND" , SDTIntExtendOp>;
@@ -415,13 +438,20 @@
 def extractelt : SDNode<"ISD::EXTRACT_VECTOR_ELT", SDTVecExtract>;
 def insertelt  : SDNode<"ISD::INSERT_VECTOR_ELT", SDTVecInsert>;
 
+def vecreduce_add  : SDNode<"ISD::VECREDUCE_ADD", SDTVecReduce>;
+def vecreduce_smax  : SDNode<"ISD::VECREDUCE_SMAX", SDTVecReduce>;
+def vecreduce_umax  : SDNode<"ISD::VECREDUCE_UMAX", SDTVecReduce>;
+def vecreduce_smin  : SDNode<"ISD::VECREDUCE_SMIN", SDTVecReduce>;
+def vecreduce_umin  : SDNode<"ISD::VECREDUCE_UMIN", SDTVecReduce>;
+def vecreduce_fadd  : SDNode<"ISD::VECREDUCE_FADD", SDTFPVecReduce>;
+
 def fadd       : SDNode<"ISD::FADD"       , SDTFPBinOp, [SDNPCommutative]>;
 def fsub       : SDNode<"ISD::FSUB"       , SDTFPBinOp>;
 def fmul       : SDNode<"ISD::FMUL"       , SDTFPBinOp, [SDNPCommutative]>;
 def fdiv       : SDNode<"ISD::FDIV"       , SDTFPBinOp>;
 def frem       : SDNode<"ISD::FREM"       , SDTFPBinOp>;
-def fma        : SDNode<"ISD::FMA"        , SDTFPTernaryOp>;
-def fmad       : SDNode<"ISD::FMAD"       , SDTFPTernaryOp>;
+def fma        : SDNode<"ISD::FMA"        , SDTFPTernaryOp, [SDNPCommutative]>;
+def fmad       : SDNode<"ISD::FMAD"       , SDTFPTernaryOp, [SDNPCommutative]>;
 def fabs       : SDNode<"ISD::FABS"       , SDTFPUnaryOp>;
 def fminnum    : SDNode<"ISD::FMINNUM"    , SDTFPBinOp,
                                   [SDNPCommutative, SDNPAssociative]>;
@@ -464,6 +494,8 @@
 def uint_to_fp : SDNode<"ISD::UINT_TO_FP" , SDTIntToFPOp>;
 def fp_to_sint : SDNode<"ISD::FP_TO_SINT" , SDTFPToIntOp>;
 def fp_to_uint : SDNode<"ISD::FP_TO_UINT" , SDTFPToIntOp>;
+def fp_to_sint_sat : SDNode<"ISD::FP_TO_SINT_SAT" , SDTFPToIntSatOp>;
+def fp_to_uint_sat : SDNode<"ISD::FP_TO_UINT_SAT" , SDTFPToIntSatOp>;
 def f16_to_fp  : SDNode<"ISD::FP16_TO_FP" , SDTIntToFPOp>;
 def fp_to_f16  : SDNode<"ISD::FP_TO_FP16" , SDTFPToIntOp>;
 
@@ -478,7 +510,7 @@
 def strict_frem       : SDNode<"ISD::STRICT_FREM",
                                SDTFPBinOp, [SDNPHasChain]>;
 def strict_fma        : SDNode<"ISD::STRICT_FMA",
-                               SDTFPTernaryOp, [SDNPHasChain]>;
+                               SDTFPTernaryOp, [SDNPHasChain, SDNPCommutative]>;
 def strict_fsqrt      : SDNode<"ISD::STRICT_FSQRT",
                                SDTFPUnaryOp, [SDNPHasChain]>;
 def strict_fsin       : SDNode<"ISD::STRICT_FSIN",
@@ -493,12 +525,20 @@
                                SDTFPUnaryOp, [SDNPHasChain]>;
 def strict_frint      : SDNode<"ISD::STRICT_FRINT",
                                SDTFPUnaryOp, [SDNPHasChain]>;
+def strict_lrint      : SDNode<"ISD::STRICT_LRINT",
+                               SDTFPToIntOp, [SDNPHasChain]>;
+def strict_llrint     : SDNode<"ISD::STRICT_LLRINT",
+                               SDTFPToIntOp, [SDNPHasChain]>;
 def strict_fnearbyint : SDNode<"ISD::STRICT_FNEARBYINT",
                                SDTFPUnaryOp, [SDNPHasChain]>;
 def strict_fceil      : SDNode<"ISD::STRICT_FCEIL",
                                SDTFPUnaryOp, [SDNPHasChain]>;
 def strict_ffloor     : SDNode<"ISD::STRICT_FFLOOR",
                                SDTFPUnaryOp, [SDNPHasChain]>;
+def strict_lround     : SDNode<"ISD::STRICT_LROUND",
+                               SDTFPToIntOp, [SDNPHasChain]>;
+def strict_llround    : SDNode<"ISD::STRICT_LLROUND",
+                               SDTFPToIntOp, [SDNPHasChain]>;
 def strict_fround     : SDNode<"ISD::STRICT_FROUND",
                                SDTFPUnaryOp, [SDNPHasChain]>;
 def strict_ftrunc     : SDNode<"ISD::STRICT_FTRUNC",
@@ -509,10 +549,26 @@
 def strict_fmaxnum    : SDNode<"ISD::STRICT_FMAXNUM",
                                SDTFPBinOp, [SDNPHasChain,
                                             SDNPCommutative, SDNPAssociative]>;
+def strict_fminimum   : SDNode<"ISD::STRICT_FMINIMUM",
+                               SDTFPBinOp, [SDNPHasChain,
+                                            SDNPCommutative, SDNPAssociative]>;
+def strict_fmaximum   : SDNode<"ISD::STRICT_FMAXIMUM",
+                               SDTFPBinOp, [SDNPHasChain,
+                                            SDNPCommutative, SDNPAssociative]>;
 def strict_fpround    : SDNode<"ISD::STRICT_FP_ROUND",
                                SDTFPRoundOp, [SDNPHasChain]>;
 def strict_fpextend   : SDNode<"ISD::STRICT_FP_EXTEND",
                                SDTFPExtendOp, [SDNPHasChain]>;
+def strict_fp_to_sint : SDNode<"ISD::STRICT_FP_TO_SINT",
+                               SDTFPToIntOp, [SDNPHasChain]>;
+def strict_fp_to_uint : SDNode<"ISD::STRICT_FP_TO_UINT",
+                               SDTFPToIntOp, [SDNPHasChain]>;
+def strict_sint_to_fp : SDNode<"ISD::STRICT_SINT_TO_FP",
+                               SDTIntToFPOp, [SDNPHasChain]>;
+def strict_uint_to_fp : SDNode<"ISD::STRICT_UINT_TO_FP",
+                               SDTIntToFPOp, [SDNPHasChain]>;
+def strict_fsetcc  : SDNode<"ISD::STRICT_FSETCC",  SDTSetCC, [SDNPHasChain]>;
+def strict_fsetccs : SDNode<"ISD::STRICT_FSETCCS", SDTSetCC, [SDNPHasChain]>;
 
 def setcc      : SDNode<"ISD::SETCC"      , SDTSetCC>;
 def select     : SDNode<"ISD::SELECT"     , SDTSelect>;
@@ -526,13 +582,13 @@
 def catchret   : SDNode<"ISD::CATCHRET"   , SDTCatchret,
                         [SDNPHasChain, SDNPSideEffect]>;
 def cleanupret : SDNode<"ISD::CLEANUPRET" , SDTNone,   [SDNPHasChain]>;
-def catchpad   : SDNode<"ISD::CATCHPAD"   , SDTNone,
-                        [SDNPHasChain, SDNPSideEffect]>;
 
 def trap       : SDNode<"ISD::TRAP"       , SDTNone,
                         [SDNPHasChain, SDNPSideEffect]>;
 def debugtrap  : SDNode<"ISD::DEBUGTRAP"  , SDTNone,
                         [SDNPHasChain, SDNPSideEffect]>;
+def ubsantrap  : SDNode<"ISD::UBSANTRAP"  , SDTUBSANTrap,
+                        [SDNPHasChain, SDNPSideEffect]>;
 
 def prefetch   : SDNode<"ISD::PREFETCH"   , SDTPrefetch,
                         [SDNPHasChain, SDNPMayLoad, SDNPMayStore,
@@ -596,6 +652,7 @@
 
 def vector_shuffle : SDNode<"ISD::VECTOR_SHUFFLE", SDTVecShuffle, []>;
 def build_vector : SDNode<"ISD::BUILD_VECTOR", SDTypeProfile<1, -1, []>, []>;
+def splat_vector : SDNode<"ISD::SPLAT_VECTOR", SDTypeProfile<1, 1, []>, []>;
 def scalar_to_vector : SDNode<"ISD::SCALAR_TO_VECTOR", SDTypeProfile<1, 1, []>,
                               []>;
 
@@ -629,25 +686,42 @@
 def intrinsic_wo_chain : SDNode<"ISD::INTRINSIC_WO_CHAIN",
                                 SDTypeProfile<1, -1, [SDTCisPtrTy<1>]>, []>;
 
-def SDT_assertext : SDTypeProfile<1, 1,
+def SDT_assert : SDTypeProfile<1, 1,
   [SDTCisInt<0>, SDTCisInt<1>, SDTCisSameAs<1, 0>]>;
-def assertsext : SDNode<"ISD::AssertSext", SDT_assertext>;
-def assertzext : SDNode<"ISD::AssertZext", SDT_assertext>;
+def assertsext : SDNode<"ISD::AssertSext", SDT_assert>;
+def assertzext : SDNode<"ISD::AssertZext", SDT_assert>;
+def assertalign : SDNode<"ISD::AssertAlign", SDT_assert>;
 
 
 //===----------------------------------------------------------------------===//
 // Selection DAG Condition Codes
 
-class CondCode; // ISD::CondCode enums
-def SETOEQ : CondCode; def SETOGT : CondCode;
-def SETOGE : CondCode; def SETOLT : CondCode; def SETOLE : CondCode;
-def SETONE : CondCode; def SETO   : CondCode; def SETUO  : CondCode;
-def SETUEQ : CondCode; def SETUGT : CondCode; def SETUGE : CondCode;
-def SETULT : CondCode; def SETULE : CondCode; def SETUNE : CondCode;
+class CondCode<string fcmpName = "", string icmpName = ""> {
+  string ICmpPredicate = icmpName;
+  string FCmpPredicate = fcmpName;
+}
 
-def SETEQ : CondCode; def SETGT : CondCode; def SETGE : CondCode;
-def SETLT : CondCode; def SETLE : CondCode; def SETNE : CondCode;
-
+// ISD::CondCode enums, and mapping to CmpInst::Predicate names
+def SETOEQ : CondCode<"FCMP_OEQ">;
+def SETOGT : CondCode<"FCMP_OGT">;
+def SETOGE : CondCode<"FCMP_OGE">;
+def SETOLT : CondCode<"FCMP_OLT">;
+def SETOLE : CondCode<"FCMP_OLE">;
+def SETONE : CondCode<"FCMP_ONE">;
+def SETO   : CondCode<"FCMP_ORD">;
+def SETUO  : CondCode<"FCMP_UNO">;
+def SETUEQ : CondCode<"FCMP_UEQ">;
+def SETUGT : CondCode<"FCMP_UGT", "ICMP_UGT">;
+def SETUGE : CondCode<"FCMP_UGE", "ICMP_UGE">;
+def SETULT : CondCode<"FCMP_ULT", "ICMP_ULT">;
+def SETULE : CondCode<"FCMP_ULE", "ICMP_ULE">;
+def SETUNE : CondCode<"FCMP_UNE">;
+def SETEQ : CondCode<"", "ICMP_EQ">;
+def SETGT : CondCode<"", "ICMP_SGT">;
+def SETGE : CondCode<"", "ICMP_SGE">;
+def SETLT : CondCode<"", "ICMP_SLT">;
+def SETLE : CondCode<"", "ICMP_SLE">;
+def SETNE : CondCode<"", "ICMP_NE">;
 
 //===----------------------------------------------------------------------===//
 // Selection DAG Node Transformation Functions.
@@ -664,19 +738,6 @@
 def NOOP_SDNodeXForm : SDNodeXForm<imm, [{}]>;
 
 //===----------------------------------------------------------------------===//
-// PatPred Subclasses.
-//
-// These allow specifying different sorts of predicates that control whether a
-// node is matched.
-//
-class PatPred;
-
-class CodePatPred<code predicate> : PatPred {
-  code PredicateCode = predicate;
-}
-
-
-//===----------------------------------------------------------------------===//
 // Selection DAG Pattern Fragments.
 //
 // Pattern fragments are reusable chunks of dags that match specific things.
@@ -688,7 +749,7 @@
 /// PatFrags - Represents a set of pattern fragments.  Each single fragment
 /// can match something on the DAG, from a single node to multiple nested other
 /// fragments.   The whole set of fragments matches if any of the single
-/// fragemnts match.  This allows e.g. matching and "add with overflow" and
+/// fragments match.  This allows e.g. matching and "add with overflow" and
 /// a regular "add" with the same fragment set.
 ///
 class PatFrags<dag ops, list<dag> frags, code pred = [{}],
@@ -707,7 +768,7 @@
   // This is useful when Fragments involves associative / commutative
   // operators: a single piece of code can easily refer to all operands even
   // when re-associated / commuted variants of the fragment are matched.
-  bit PredicateCodeUsesOperands = 0;
+  bit PredicateCodeUsesOperands = false;
 
   // Define a few pre-packaged predicates. This helps GlobalISel import
   // existing rules from SelectionDAG for many common cases.
@@ -737,6 +798,14 @@
   // cast<StoreSDNode>(N)->isTruncatingStore();
   bit IsTruncStore = ?;
 
+  // cast<MemSDNode>(N)->getAddressSpace() ==
+  // If this empty, accept any address space.
+  list<int> AddressSpaces = ?;
+
+  // cast<MemSDNode>(N)->getAlignment() >=
+  // If this is empty, accept any alignment.
+  int MinAlignment = ?;
+
   // cast<AtomicSDNode>(N)->getOrdering() == AtomicOrdering::Monotonic
   bit IsAtomicOrderingMonotonic = ?;
   // cast<AtomicSDNode>(N)->getOrdering() == AtomicOrdering::Acquire
@@ -798,15 +867,20 @@
               SDNode ImmNode = imm>
   : PatFrag<(ops), (vt ImmNode), [{}], xform> {
   let ImmediateCode = pred;
-  bit FastIselShouldIgnore = 0;
+  bit FastIselShouldIgnore = false;
 
   // Is the data type of the immediate an APInt?
-  bit IsAPInt = 0;
+  bit IsAPInt = false;
 
   // Is the data type of the immediate an APFloat?
-  bit IsAPFloat = 0;
+  bit IsAPFloat = false;
 }
 
+// Convenience wrapper for ImmLeaf to use timm/TargetConstant instead
+// of imm/Constant.
+class TImmLeaf<ValueType vt, code pred, SDNodeXForm xform = NOOP_SDNodeXForm,
+  SDNode ImmNode = timm> : ImmLeaf<vt, pred, xform, ImmNode>;
+
 // An ImmLeaf except that Imm is an APInt. This is useful when you need to
 // zero-extend the immediate instead of sign-extend it.
 //
@@ -816,8 +890,8 @@
 // IntImmLeaf will allow GlobalISel to import the rule.
 class IntImmLeaf<ValueType vt, code pred, SDNodeXForm xform = NOOP_SDNodeXForm>
     : ImmLeaf<vt, pred, xform> {
-  let IsAPInt = 1;
-  let FastIselShouldIgnore = 1;
+  let IsAPInt = true;
+  let FastIselShouldIgnore = true;
 }
 
 // An ImmLeaf except that Imm is an APFloat.
@@ -826,8 +900,8 @@
 // generate code for rules that make use of it.
 class FPImmLeaf<ValueType vt, code pred, SDNodeXForm xform = NOOP_SDNodeXForm>
   : ImmLeaf<vt, pred, xform, fpimm> {
-  let IsAPFloat = 1;
-  let FastIselShouldIgnore = 1;
+  let IsAPFloat = true;
+  let FastIselShouldIgnore = true;
 }
 
 // Leaf fragments.
@@ -835,17 +909,23 @@
 def vtInt      : PatLeaf<(vt),  [{ return N->getVT().isInteger(); }]>;
 def vtFP       : PatLeaf<(vt),  [{ return N->getVT().isFloatingPoint(); }]>;
 
-// Use ISD::isBuildVectorAllOnes or ISD::isBuildVectorAllZeros to look for
-// the corresponding build_vector. Will look through bitcasts except when used
-// as a pattern root.
-def immAllOnesV; // ISD::isBuildVectorAllOnes
-def immAllZerosV; // ISD::isBuildVectorAllZeros
+// Use ISD::isConstantSplatVectorAllOnes or ISD::isConstantSplatVectorAllZeros
+// to look for the corresponding build_vector or splat_vector. Will look through
+// bitcasts and check for either opcode, except when used as a pattern root.
+// When used as a pattern root, only fixed-length build_vector and scalable
+// splat_vector are supported.
+def immAllOnesV; // ISD::isConstantSplatVectorAllOnes
+def immAllZerosV; // ISD::isConstantSplatVectorAllZeros
 
 // Other helper fragments.
 def not  : PatFrag<(ops node:$in), (xor node:$in, -1)>;
 def vnot : PatFrag<(ops node:$in), (xor node:$in, immAllOnesV)>;
 def ineg : PatFrag<(ops node:$in), (sub 0, node:$in)>;
 
+def zanyext : PatFrags<(ops node:$op),
+                       [(zext node:$op),
+                        (anyext node:$op)]>;
+
 // null_frag - The null pattern operator is used in multiclass instantiations
 // which accept an SDPatternOperator for use in matching patterns for internal
 // definitions. When expanding a pattern, if the null fragment is referenced
@@ -855,213 +935,222 @@
 
 // load fragments.
 def unindexedload : PatFrag<(ops node:$ptr), (ld node:$ptr)> {
-  let IsLoad = 1;
-  let IsUnindexed = 1;
+  let IsLoad = true;
+  let IsUnindexed = true;
 }
 def load : PatFrag<(ops node:$ptr), (unindexedload node:$ptr)> {
-  let IsLoad = 1;
-  let IsNonExtLoad = 1;
+  let IsLoad = true;
+  let IsNonExtLoad = true;
 }
 
 // extending load fragments.
 def extload   : PatFrag<(ops node:$ptr), (unindexedload node:$ptr)> {
-  let IsLoad = 1;
-  let IsAnyExtLoad = 1;
+  let IsLoad = true;
+  let IsAnyExtLoad = true;
 }
 def sextload  : PatFrag<(ops node:$ptr), (unindexedload node:$ptr)> {
-  let IsLoad = 1;
-  let IsSignExtLoad = 1;
+  let IsLoad = true;
+  let IsSignExtLoad = true;
 }
 def zextload  : PatFrag<(ops node:$ptr), (unindexedload node:$ptr)> {
-  let IsLoad = 1;
-  let IsZeroExtLoad = 1;
+  let IsLoad = true;
+  let IsZeroExtLoad = true;
 }
 
 def extloadi1  : PatFrag<(ops node:$ptr), (extload node:$ptr)> {
-  let IsLoad = 1;
+  let IsLoad = true;
   let MemoryVT = i1;
 }
 def extloadi8  : PatFrag<(ops node:$ptr), (extload node:$ptr)> {
-  let IsLoad = 1;
+  let IsLoad = true;
   let MemoryVT = i8;
 }
 def extloadi16 : PatFrag<(ops node:$ptr), (extload node:$ptr)> {
-  let IsLoad = 1;
+  let IsLoad = true;
   let MemoryVT = i16;
 }
 def extloadi32 : PatFrag<(ops node:$ptr), (extload node:$ptr)> {
-  let IsLoad = 1;
+  let IsLoad = true;
   let MemoryVT = i32;
 }
+def extloadf16 : PatFrag<(ops node:$ptr), (extload node:$ptr)> {
+  let IsLoad = true;
+  let MemoryVT = f16;
+}
 def extloadf32 : PatFrag<(ops node:$ptr), (extload node:$ptr)> {
-  let IsLoad = 1;
+  let IsLoad = true;
   let MemoryVT = f32;
 }
 def extloadf64 : PatFrag<(ops node:$ptr), (extload node:$ptr)> {
-  let IsLoad = 1;
+  let IsLoad = true;
   let MemoryVT = f64;
 }
 
 def sextloadi1  : PatFrag<(ops node:$ptr), (sextload node:$ptr)> {
-  let IsLoad = 1;
+  let IsLoad = true;
   let MemoryVT = i1;
 }
 def sextloadi8  : PatFrag<(ops node:$ptr), (sextload node:$ptr)> {
-  let IsLoad = 1;
+  let IsLoad = true;
   let MemoryVT = i8;
 }
 def sextloadi16 : PatFrag<(ops node:$ptr), (sextload node:$ptr)> {
-  let IsLoad = 1;
+  let IsLoad = true;
   let MemoryVT = i16;
 }
 def sextloadi32 : PatFrag<(ops node:$ptr), (sextload node:$ptr)> {
-  let IsLoad = 1;
+  let IsLoad = true;
   let MemoryVT = i32;
 }
 
 def zextloadi1  : PatFrag<(ops node:$ptr), (zextload node:$ptr)> {
-  let IsLoad = 1;
+  let IsLoad = true;
   let MemoryVT = i1;
 }
 def zextloadi8  : PatFrag<(ops node:$ptr), (zextload node:$ptr)> {
-  let IsLoad = 1;
+  let IsLoad = true;
   let MemoryVT = i8;
 }
 def zextloadi16 : PatFrag<(ops node:$ptr), (zextload node:$ptr)> {
-  let IsLoad = 1;
+  let IsLoad = true;
   let MemoryVT = i16;
 }
 def zextloadi32 : PatFrag<(ops node:$ptr), (zextload node:$ptr)> {
-  let IsLoad = 1;
+  let IsLoad = true;
   let MemoryVT = i32;
 }
 
 def extloadvi1  : PatFrag<(ops node:$ptr), (extload node:$ptr)> {
-  let IsLoad = 1;
+  let IsLoad = true;
   let ScalarMemoryVT = i1;
 }
 def extloadvi8  : PatFrag<(ops node:$ptr), (extload node:$ptr)> {
-  let IsLoad = 1;
+  let IsLoad = true;
   let ScalarMemoryVT = i8;
 }
 def extloadvi16 : PatFrag<(ops node:$ptr), (extload node:$ptr)> {
-  let IsLoad = 1;
+  let IsLoad = true;
   let ScalarMemoryVT = i16;
 }
 def extloadvi32 : PatFrag<(ops node:$ptr), (extload node:$ptr)> {
-  let IsLoad = 1;
+  let IsLoad = true;
   let ScalarMemoryVT = i32;
 }
 def extloadvf32 : PatFrag<(ops node:$ptr), (extload node:$ptr)> {
-  let IsLoad = 1;
+  let IsLoad = true;
   let ScalarMemoryVT = f32;
 }
 def extloadvf64 : PatFrag<(ops node:$ptr), (extload node:$ptr)> {
-  let IsLoad = 1;
+  let IsLoad = true;
   let ScalarMemoryVT = f64;
 }
 
 def sextloadvi1  : PatFrag<(ops node:$ptr), (sextload node:$ptr)> {
-  let IsLoad = 1;
+  let IsLoad = true;
   let ScalarMemoryVT = i1;
 }
 def sextloadvi8  : PatFrag<(ops node:$ptr), (sextload node:$ptr)> {
-  let IsLoad = 1;
+  let IsLoad = true;
   let ScalarMemoryVT = i8;
 }
 def sextloadvi16 : PatFrag<(ops node:$ptr), (sextload node:$ptr)> {
-  let IsLoad = 1;
+  let IsLoad = true;
   let ScalarMemoryVT = i16;
 }
 def sextloadvi32 : PatFrag<(ops node:$ptr), (sextload node:$ptr)> {
-  let IsLoad = 1;
+  let IsLoad = true;
   let ScalarMemoryVT = i32;
 }
 
 def zextloadvi1  : PatFrag<(ops node:$ptr), (zextload node:$ptr)> {
-  let IsLoad = 1;
+  let IsLoad = true;
   let ScalarMemoryVT = i1;
 }
 def zextloadvi8  : PatFrag<(ops node:$ptr), (zextload node:$ptr)> {
-  let IsLoad = 1;
+  let IsLoad = true;
   let ScalarMemoryVT = i8;
 }
 def zextloadvi16 : PatFrag<(ops node:$ptr), (zextload node:$ptr)> {
-  let IsLoad = 1;
+  let IsLoad = true;
   let ScalarMemoryVT = i16;
 }
 def zextloadvi32 : PatFrag<(ops node:$ptr), (zextload node:$ptr)> {
-  let IsLoad = 1;
+  let IsLoad = true;
   let ScalarMemoryVT = i32;
 }
 
 // store fragments.
 def unindexedstore : PatFrag<(ops node:$val, node:$ptr),
                              (st node:$val, node:$ptr)> {
-  let IsStore = 1;
-  let IsUnindexed = 1;
+  let IsStore = true;
+  let IsUnindexed = true;
 }
 def store : PatFrag<(ops node:$val, node:$ptr),
                     (unindexedstore node:$val, node:$ptr)> {
-  let IsStore = 1;
-  let IsTruncStore = 0;
+  let IsStore = true;
+  let IsTruncStore = false;
 }
 
 // truncstore fragments.
 def truncstore : PatFrag<(ops node:$val, node:$ptr),
                          (unindexedstore node:$val, node:$ptr)> {
-  let IsStore = 1;
-  let IsTruncStore = 1;
+  let IsStore = true;
+  let IsTruncStore = true;
 }
 def truncstorei8 : PatFrag<(ops node:$val, node:$ptr),
                            (truncstore node:$val, node:$ptr)> {
-  let IsStore = 1;
+  let IsStore = true;
   let MemoryVT = i8;
 }
 def truncstorei16 : PatFrag<(ops node:$val, node:$ptr),
                             (truncstore node:$val, node:$ptr)> {
-  let IsStore = 1;
+  let IsStore = true;
   let MemoryVT = i16;
 }
 def truncstorei32 : PatFrag<(ops node:$val, node:$ptr),
                             (truncstore node:$val, node:$ptr)> {
-  let IsStore = 1;
+  let IsStore = true;
   let MemoryVT = i32;
 }
+def truncstoref16 : PatFrag<(ops node:$val, node:$ptr),
+                            (truncstore node:$val, node:$ptr)> {
+  let IsStore = true;
+  let MemoryVT = f16;
+}
 def truncstoref32 : PatFrag<(ops node:$val, node:$ptr),
                             (truncstore node:$val, node:$ptr)> {
-  let IsStore = 1;
+  let IsStore = true;
   let MemoryVT = f32;
 }
 def truncstoref64 : PatFrag<(ops node:$val, node:$ptr),
                             (truncstore node:$val, node:$ptr)> {
-  let IsStore = 1;
+  let IsStore = true;
   let MemoryVT = f64;
 }
 
 def truncstorevi8 : PatFrag<(ops node:$val, node:$ptr),
                             (truncstore node:$val, node:$ptr)> {
-  let IsStore = 1;
+  let IsStore = true;
   let ScalarMemoryVT = i8;
 }
 
 def truncstorevi16 : PatFrag<(ops node:$val, node:$ptr),
                              (truncstore node:$val, node:$ptr)> {
-  let IsStore = 1;
+  let IsStore = true;
   let ScalarMemoryVT = i16;
 }
 
 def truncstorevi32 : PatFrag<(ops node:$val, node:$ptr),
                              (truncstore node:$val, node:$ptr)> {
-  let IsStore = 1;
+  let IsStore = true;
   let ScalarMemoryVT = i32;
 }
 
 // indexed store fragments.
 def istore : PatFrag<(ops node:$val, node:$base, node:$offset),
                      (ist node:$val, node:$base, node:$offset)> {
-  let IsStore = 1;
-  let IsTruncStore = 0;
+  let IsStore = true;
+  let IsTruncStore = false;
 }
 
 def pre_store : PatFrag<(ops node:$val, node:$base, node:$offset),
@@ -1072,8 +1161,8 @@
 
 def itruncstore : PatFrag<(ops node:$val, node:$base, node:$offset),
                           (ist node:$val, node:$base, node:$offset)> {
-  let IsStore = 1;
-  let IsTruncStore = 1;
+  let IsStore = true;
+  let IsTruncStore = true;
 }
 def pre_truncst : PatFrag<(ops node:$val, node:$base, node:$offset),
                           (itruncstore node:$val, node:$base, node:$offset), [{
@@ -1082,29 +1171,39 @@
 }]>;
 def pre_truncsti1 : PatFrag<(ops node:$val, node:$base, node:$offset),
                             (pre_truncst node:$val, node:$base, node:$offset)> {
-  let IsStore = 1;
+  let IsStore = true;
   let MemoryVT = i1;
 }
 def pre_truncsti8 : PatFrag<(ops node:$val, node:$base, node:$offset),
                             (pre_truncst node:$val, node:$base, node:$offset)> {
-  let IsStore = 1;
+  let IsStore = true;
   let MemoryVT = i8;
 }
 def pre_truncsti16 : PatFrag<(ops node:$val, node:$base, node:$offset),
                              (pre_truncst node:$val, node:$base, node:$offset)> {
-  let IsStore = 1;
+  let IsStore = true;
   let MemoryVT = i16;
 }
 def pre_truncsti32 : PatFrag<(ops node:$val, node:$base, node:$offset),
                              (pre_truncst node:$val, node:$base, node:$offset)> {
-  let IsStore = 1;
+  let IsStore = true;
   let MemoryVT = i32;
 }
 def pre_truncstf32 : PatFrag<(ops node:$val, node:$base, node:$offset),
                              (pre_truncst node:$val, node:$base, node:$offset)> {
-  let IsStore = 1;
+  let IsStore = true;
   let MemoryVT = f32;
 }
+def pre_truncstvi8 : PatFrag<(ops node:$val, node:$base, node:$offset),
+                             (pre_truncst node:$val, node:$base, node:$offset)> {
+  let IsStore = true;
+  let ScalarMemoryVT = i8;
+}
+def pre_truncstvi16 : PatFrag<(ops node:$val, node:$base, node:$offset),
+                              (pre_truncst node:$val, node:$base, node:$offset)> {
+  let IsStore = true;
+  let ScalarMemoryVT = i16;
+}
 
 def post_store : PatFrag<(ops node:$val, node:$ptr, node:$offset),
                          (istore node:$val, node:$ptr, node:$offset), [{
@@ -1119,37 +1218,49 @@
 }]>;
 def post_truncsti1 : PatFrag<(ops node:$val, node:$base, node:$offset),
                              (post_truncst node:$val, node:$base, node:$offset)> {
-  let IsStore = 1;
+  let IsStore = true;
   let MemoryVT = i1;
 }
 def post_truncsti8 : PatFrag<(ops node:$val, node:$base, node:$offset),
                              (post_truncst node:$val, node:$base, node:$offset)> {
-  let IsStore = 1;
+  let IsStore = true;
   let MemoryVT = i8;
 }
 def post_truncsti16 : PatFrag<(ops node:$val, node:$base, node:$offset),
                               (post_truncst node:$val, node:$base, node:$offset)> {
-  let IsStore = 1;
+  let IsStore = true;
   let MemoryVT = i16;
 }
 def post_truncsti32 : PatFrag<(ops node:$val, node:$base, node:$offset),
                               (post_truncst node:$val, node:$base, node:$offset)> {
-  let IsStore = 1;
+  let IsStore = true;
   let MemoryVT = i32;
 }
 def post_truncstf32 : PatFrag<(ops node:$val, node:$base, node:$offset),
                               (post_truncst node:$val, node:$base, node:$offset)> {
-  let IsStore = 1;
+  let IsStore = true;
   let MemoryVT = f32;
 }
+def post_truncstvi8 : PatFrag<(ops node:$val, node:$base, node:$offset),
+                              (post_truncst node:$val, node:$base, node:$offset)> {
+  let IsStore = true;
+  let ScalarMemoryVT = i8;
+}
+def post_truncstvi16 : PatFrag<(ops node:$val, node:$base, node:$offset),
+                               (post_truncst node:$val, node:$base, node:$offset)> {
+  let IsStore = true;
+  let ScalarMemoryVT = i16;
+}
 
-def nonvolatile_load : PatFrag<(ops node:$ptr),
-                               (load node:$ptr), [{
-  return !cast<LoadSDNode>(N)->isVolatile();
+// TODO: Split these into volatile and unordered flavors to enable
+// selectively legal optimizations for each.  (See D66309)
+def simple_load : PatFrag<(ops node:$ptr),
+                          (load node:$ptr), [{
+  return cast<LoadSDNode>(N)->isSimple();
 }]>;
-def nonvolatile_store : PatFrag<(ops node:$val, node:$ptr),
-                                (store node:$val, node:$ptr), [{
-  return !cast<StoreSDNode>(N)->isVolatile();
+def simple_store : PatFrag<(ops node:$val, node:$ptr),
+                           (store node:$val, node:$ptr), [{
+  return cast<StoreSDNode>(N)->isSimple();
 }]>;
 
 // nontemporal store fragments.
@@ -1271,6 +1382,12 @@
 def any_frint      : PatFrags<(ops node:$src),
                               [(strict_frint node:$src),
                                (frint node:$src)]>;
+def any_lrint      : PatFrags<(ops node:$src),
+                              [(strict_lrint node:$src),
+                               (lrint node:$src)]>;
+def any_llrint     : PatFrags<(ops node:$src),
+                              [(strict_llrint node:$src),
+                               (llrint node:$src)]>;
 def any_fnearbyint : PatFrags<(ops node:$src),
                               [(strict_fnearbyint node:$src),
                                (fnearbyint node:$src)]>;
@@ -1280,6 +1397,12 @@
 def any_ffloor     : PatFrags<(ops node:$src),
                               [(strict_ffloor node:$src),
                                (ffloor node:$src)]>;
+def any_lround     : PatFrags<(ops node:$src),
+                              [(strict_lround node:$src),
+                               (lround node:$src)]>;
+def any_llround    : PatFrags<(ops node:$src),
+                              [(strict_llround node:$src),
+                               (llround node:$src)]>;
 def any_fround     : PatFrags<(ops node:$src),
                               [(strict_fround node:$src),
                                (fround node:$src)]>;
@@ -1292,6 +1415,12 @@
 def any_fminnum    : PatFrags<(ops node:$lhs, node:$rhs),
                               [(strict_fminnum node:$lhs, node:$rhs),
                                (fminnum node:$lhs, node:$rhs)]>;
+def any_fmaximum   : PatFrags<(ops node:$lhs, node:$rhs),
+                              [(strict_fmaximum node:$lhs, node:$rhs),
+                               (fmaximum node:$lhs, node:$rhs)]>;
+def any_fminimum   : PatFrags<(ops node:$lhs, node:$rhs),
+                              [(strict_fminimum node:$lhs, node:$rhs),
+                               (fminimum node:$lhs, node:$rhs)]>;
 def any_fpround    : PatFrags<(ops node:$src),
                               [(strict_fpround node:$src),
                                (fpround node:$src)]>;
@@ -1304,83 +1433,101 @@
 def any_extloadf64 : PatFrags<(ops node:$ptr),
                               [(strict_extloadf64 node:$ptr),
                                (extloadf64 node:$ptr)]>;
+def any_fp_to_sint : PatFrags<(ops node:$src),
+                              [(strict_fp_to_sint node:$src),
+                               (fp_to_sint node:$src)]>;
+def any_fp_to_uint : PatFrags<(ops node:$src),
+                              [(strict_fp_to_uint node:$src),
+                               (fp_to_uint node:$src)]>;
+def any_sint_to_fp : PatFrags<(ops node:$src),
+                              [(strict_sint_to_fp node:$src),
+                               (sint_to_fp node:$src)]>;
+def any_uint_to_fp : PatFrags<(ops node:$src),
+                              [(strict_uint_to_fp node:$src),
+                               (uint_to_fp node:$src)]>;
+def any_fsetcc : PatFrags<(ops node:$lhs, node:$rhs, node:$pred),
+                          [(strict_fsetcc node:$lhs, node:$rhs, node:$pred),
+                           (setcc node:$lhs, node:$rhs, node:$pred)]>;
+def any_fsetccs : PatFrags<(ops node:$lhs, node:$rhs, node:$pred),
+                          [(strict_fsetccs node:$lhs, node:$rhs, node:$pred),
+                           (setcc node:$lhs, node:$rhs, node:$pred)]>;
 
 multiclass binary_atomic_op_ord<SDNode atomic_op> {
-  def #NAME#_monotonic : PatFrag<(ops node:$ptr, node:$val),
-      (!cast<SDPatternOperator>(#NAME) node:$ptr, node:$val)> {
-    let IsAtomic = 1;
-    let IsAtomicOrderingMonotonic = 1;
+  def NAME#_monotonic : PatFrag<(ops node:$ptr, node:$val),
+      (!cast<SDPatternOperator>(NAME) node:$ptr, node:$val)> {
+    let IsAtomic = true;
+    let IsAtomicOrderingMonotonic = true;
   }
-  def #NAME#_acquire : PatFrag<(ops node:$ptr, node:$val),
-      (!cast<SDPatternOperator>(#NAME) node:$ptr, node:$val)> {
-    let IsAtomic = 1;
-    let IsAtomicOrderingAcquire = 1;
+  def NAME#_acquire : PatFrag<(ops node:$ptr, node:$val),
+      (!cast<SDPatternOperator>(NAME) node:$ptr, node:$val)> {
+    let IsAtomic = true;
+    let IsAtomicOrderingAcquire = true;
   }
-  def #NAME#_release : PatFrag<(ops node:$ptr, node:$val),
-      (!cast<SDPatternOperator>(#NAME) node:$ptr, node:$val)> {
-    let IsAtomic = 1;
-    let IsAtomicOrderingRelease = 1;
+  def NAME#_release : PatFrag<(ops node:$ptr, node:$val),
+      (!cast<SDPatternOperator>(NAME) node:$ptr, node:$val)> {
+    let IsAtomic = true;
+    let IsAtomicOrderingRelease = true;
   }
-  def #NAME#_acq_rel : PatFrag<(ops node:$ptr, node:$val),
-      (!cast<SDPatternOperator>(#NAME) node:$ptr, node:$val)> {
-    let IsAtomic = 1;
-    let IsAtomicOrderingAcquireRelease = 1;
+  def NAME#_acq_rel : PatFrag<(ops node:$ptr, node:$val),
+      (!cast<SDPatternOperator>(NAME) node:$ptr, node:$val)> {
+    let IsAtomic = true;
+    let IsAtomicOrderingAcquireRelease = true;
   }
-  def #NAME#_seq_cst : PatFrag<(ops node:$ptr, node:$val),
-      (!cast<SDPatternOperator>(#NAME) node:$ptr, node:$val)> {
-    let IsAtomic = 1;
-    let IsAtomicOrderingSequentiallyConsistent = 1;
+  def NAME#_seq_cst : PatFrag<(ops node:$ptr, node:$val),
+      (!cast<SDPatternOperator>(NAME) node:$ptr, node:$val)> {
+    let IsAtomic = true;
+    let IsAtomicOrderingSequentiallyConsistent = true;
   }
 }
 
 multiclass ternary_atomic_op_ord<SDNode atomic_op> {
-  def #NAME#_monotonic : PatFrag<(ops node:$ptr, node:$cmp, node:$val),
-      (!cast<SDPatternOperator>(#NAME) node:$ptr, node:$cmp, node:$val)> {
-    let IsAtomic = 1;
-    let IsAtomicOrderingMonotonic = 1;
+  def NAME#_monotonic : PatFrag<(ops node:$ptr, node:$cmp, node:$val),
+      (!cast<SDPatternOperator>(NAME) node:$ptr, node:$cmp, node:$val)> {
+    let IsAtomic = true;
+    let IsAtomicOrderingMonotonic = true;
   }
-  def #NAME#_acquire : PatFrag<(ops node:$ptr, node:$cmp, node:$val),
-      (!cast<SDPatternOperator>(#NAME) node:$ptr, node:$cmp, node:$val)> {
-    let IsAtomic = 1;
-    let IsAtomicOrderingAcquire = 1;
+  def NAME#_acquire : PatFrag<(ops node:$ptr, node:$cmp, node:$val),
+      (!cast<SDPatternOperator>(NAME) node:$ptr, node:$cmp, node:$val)> {
+    let IsAtomic = true;
+    let IsAtomicOrderingAcquire = true;
   }
-  def #NAME#_release : PatFrag<(ops node:$ptr, node:$cmp, node:$val),
-      (!cast<SDPatternOperator>(#NAME) node:$ptr, node:$cmp, node:$val)> {
-    let IsAtomic = 1;
-    let IsAtomicOrderingRelease = 1;
+  def NAME#_release : PatFrag<(ops node:$ptr, node:$cmp, node:$val),
+      (!cast<SDPatternOperator>(NAME) node:$ptr, node:$cmp, node:$val)> {
+    let IsAtomic = true;
+    let IsAtomicOrderingRelease = true;
   }
-  def #NAME#_acq_rel : PatFrag<(ops node:$ptr, node:$cmp, node:$val),
-      (!cast<SDPatternOperator>(#NAME) node:$ptr, node:$cmp, node:$val)> {
-    let IsAtomic = 1;
-    let IsAtomicOrderingAcquireRelease = 1;
+  def NAME#_acq_rel : PatFrag<(ops node:$ptr, node:$cmp, node:$val),
+      (!cast<SDPatternOperator>(NAME) node:$ptr, node:$cmp, node:$val)> {
+    let IsAtomic = true;
+    let IsAtomicOrderingAcquireRelease = true;
   }
-  def #NAME#_seq_cst : PatFrag<(ops node:$ptr, node:$cmp, node:$val),
-      (!cast<SDPatternOperator>(#NAME) node:$ptr, node:$cmp, node:$val)> {
-    let IsAtomic = 1;
-    let IsAtomicOrderingSequentiallyConsistent = 1;
+  def NAME#_seq_cst : PatFrag<(ops node:$ptr, node:$cmp, node:$val),
+      (!cast<SDPatternOperator>(NAME) node:$ptr, node:$cmp, node:$val)> {
+    let IsAtomic = true;
+    let IsAtomicOrderingSequentiallyConsistent = true;
   }
 }
 
-multiclass binary_atomic_op<SDNode atomic_op> {
+multiclass binary_atomic_op<SDNode atomic_op, bit IsInt = 1> {
   def _8 : PatFrag<(ops node:$ptr, node:$val),
                    (atomic_op  node:$ptr, node:$val)> {
-    let IsAtomic = 1;
-    let MemoryVT = i8;
+    let IsAtomic = true;
+    let MemoryVT = !if(IsInt, i8, ?);
   }
   def _16 : PatFrag<(ops node:$ptr, node:$val),
                     (atomic_op node:$ptr, node:$val)> {
-    let IsAtomic = 1;
-    let MemoryVT = i16;
+    let IsAtomic = true;
+    let MemoryVT = !if(IsInt, i16, f16);
   }
   def _32 : PatFrag<(ops node:$ptr, node:$val),
                     (atomic_op node:$ptr, node:$val)> {
-    let IsAtomic = 1;
-    let MemoryVT = i32;
+    let IsAtomic = true;
+    let MemoryVT = !if(IsInt, i32, f32);
   }
   def _64 : PatFrag<(ops node:$ptr, node:$val),
                     (atomic_op node:$ptr, node:$val)> {
-    let IsAtomic = 1;
-    let MemoryVT = i64;
+    let IsAtomic = true;
+    let MemoryVT = !if(IsInt, i64, f64);
   }
 
   defm NAME#_8  : binary_atomic_op_ord<atomic_op>;
@@ -1392,22 +1539,22 @@
 multiclass ternary_atomic_op<SDNode atomic_op> {
   def _8 : PatFrag<(ops node:$ptr, node:$cmp, node:$val),
                    (atomic_op  node:$ptr, node:$cmp, node:$val)> {
-    let IsAtomic = 1;
+    let IsAtomic = true;
     let MemoryVT = i8;
   }
   def _16 : PatFrag<(ops node:$ptr, node:$cmp, node:$val),
                     (atomic_op node:$ptr, node:$cmp, node:$val)> {
-    let IsAtomic = 1;
+    let IsAtomic = true;
     let MemoryVT = i16;
   }
   def _32 : PatFrag<(ops node:$ptr, node:$cmp, node:$val),
                     (atomic_op node:$ptr, node:$cmp, node:$val)> {
-    let IsAtomic = 1;
+    let IsAtomic = true;
     let MemoryVT = i32;
   }
   def _64 : PatFrag<(ops node:$ptr, node:$cmp, node:$val),
                     (atomic_op node:$ptr, node:$cmp, node:$val)> {
-    let IsAtomic = 1;
+    let IsAtomic = true;
     let MemoryVT = i64;
   }
 
@@ -1435,25 +1582,25 @@
 def atomic_load_8 :
   PatFrag<(ops node:$ptr),
           (atomic_load node:$ptr)> {
-  let IsAtomic = 1;
+  let IsAtomic = true;
   let MemoryVT = i8;
 }
 def atomic_load_16 :
   PatFrag<(ops node:$ptr),
           (atomic_load node:$ptr)> {
-  let IsAtomic = 1;
+  let IsAtomic = true;
   let MemoryVT = i16;
 }
 def atomic_load_32 :
   PatFrag<(ops node:$ptr),
           (atomic_load node:$ptr)> {
-  let IsAtomic = 1;
+  let IsAtomic = true;
   let MemoryVT = i32;
 }
 def atomic_load_64 :
   PatFrag<(ops node:$ptr),
           (atomic_load node:$ptr)> {
-  let IsAtomic = 1;
+  let IsAtomic = true;
   let MemoryVT = i64;
 }
 
diff --git a/linux-x64/clang/include/llvm/Testing/Support/Annotations.h b/linux-x64/clang/include/llvm/Testing/Support/Annotations.h
index aad1a44..cc99d10 100644
--- a/linux-x64/clang/include/llvm/Testing/Support/Annotations.h
+++ b/linux-x64/clang/include/llvm/Testing/Support/Annotations.h
@@ -68,12 +68,14 @@
   /// Crashes if there isn't exactly one.
   size_t point(llvm::StringRef Name = "") const;
   /// Returns the position of all points marked by ^ (or $name^) in the text.
+  /// Order matches the order within the text.
   std::vector<size_t> points(llvm::StringRef Name = "") const;
 
   /// Returns the location of the range marked by [[ ]] (or $name[[ ]]).
   /// Crashes if there isn't exactly one.
   Range range(llvm::StringRef Name = "") const;
   /// Returns the location of all ranges marked by [[ ]] (or $name[[ ]]).
+  /// They are ordered by start position within the text.
   std::vector<Range> ranges(llvm::StringRef Name = "") const;
 
 private:
diff --git a/linux-x64/clang/include/llvm/Testing/Support/Error.h b/linux-x64/clang/include/llvm/Testing/Support/Error.h
index 85328f2..cd5b79c 100644
--- a/linux-x64/clang/include/llvm/Testing/Support/Error.h
+++ b/linux-x64/clang/include/llvm/Testing/Support/Error.h
@@ -128,6 +128,36 @@
 private:
   Optional<testing::Matcher<InfoT &>> Matcher;
 };
+
+class ErrorMessageMatches
+    : public testing::MatcherInterface<const ErrorHolder &> {
+public:
+  explicit ErrorMessageMatches(
+      testing::Matcher<std::vector<std::string>> Matcher)
+      : Matcher(std::move(Matcher)) {}
+
+  bool MatchAndExplain(const ErrorHolder &Holder,
+                       testing::MatchResultListener *listener) const override {
+    std::vector<std::string> Messages;
+    for (const std::shared_ptr<ErrorInfoBase> &Info: Holder.Infos)
+      Messages.push_back(Info->message());
+
+    return Matcher.MatchAndExplain(Messages, listener);
+  }
+
+  void DescribeTo(std::ostream *OS) const override {
+    *OS << "failed with Error whose message ";
+    Matcher.DescribeTo(OS);
+  }
+
+  void DescribeNegationTo(std::ostream *OS) const override {
+    *OS << "failed with an Error whose message ";
+    Matcher.DescribeNegationTo(OS);
+  }
+
+private:
+  testing::Matcher<std::vector<std::string>> Matcher;
+};
 } // namespace detail
 
 #define EXPECT_THAT_ERROR(Err, Matcher)                                        \
@@ -154,6 +184,18 @@
       testing::SafeMatcherCast<InfoT &>(Matcher)));
 }
 
+template <typename... M>
+testing::Matcher<const detail::ErrorHolder &> FailedWithMessage(M... Matcher) {
+  static_assert(sizeof...(M) > 0, "");
+  return MakeMatcher(
+      new detail::ErrorMessageMatches(testing::ElementsAre(Matcher...)));
+}
+
+template <typename M>
+testing::Matcher<const detail::ErrorHolder &> FailedWithMessageArray(M Matcher) {
+  return MakeMatcher(new detail::ErrorMessageMatches(Matcher));
+}
+
 template <typename M>
 detail::ValueMatchesPoly<M> HasValue(M Matcher) {
   return detail::ValueMatchesPoly<M>(Matcher);
diff --git a/linux-x64/clang/include/llvm/Testing/Support/SupportHelpers.h b/linux-x64/clang/include/llvm/Testing/Support/SupportHelpers.h
index 38726b1..2419fc9 100644
--- a/linux-x64/clang/include/llvm/Testing/Support/SupportHelpers.h
+++ b/linux-x64/clang/include/llvm/Testing/Support/SupportHelpers.h
@@ -12,6 +12,8 @@
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/Error.h"
+#include "llvm/Support/FileSystem.h"
+#include "llvm/Support/Path.h"
 #include "llvm/Support/raw_os_ostream.h"
 #include "gmock/gmock-matchers.h"
 #include "gtest/gtest-printers.h"
@@ -103,7 +105,143 @@
   return detail::ValueIsMatcher<InnerMatcher>(ValueMatcher);
 }
 namespace unittest {
+
 SmallString<128> getInputFileDirectory(const char *Argv0);
+
+/// A RAII object that creates a temporary directory upon initialization and
+/// removes it upon destruction.
+class TempDir {
+  SmallString<128> Path;
+
+public:
+  /// Creates a managed temporary directory.
+  ///
+  /// @param Name The name of the directory to create.
+  /// @param Unique If true, the directory will be created using
+  ///               llvm::sys::fs::createUniqueDirectory.
+  explicit TempDir(StringRef Name, bool Unique = false) {
+    std::error_code EC;
+    if (Unique) {
+      EC = llvm::sys::fs::createUniqueDirectory(Name, Path);
+      if (!EC) {
+        // Resolve any symlinks in the new directory.
+        std::string UnresolvedPath(Path.str());
+        EC = llvm::sys::fs::real_path(UnresolvedPath, Path);
+      }
+    } else {
+      Path = Name;
+      EC = llvm::sys::fs::create_directory(Path);
+    }
+    if (EC)
+      Path.clear();
+    EXPECT_FALSE(EC) << EC.message();
+  }
+
+  ~TempDir() {
+    if (!Path.empty()) {
+      EXPECT_FALSE(llvm::sys::fs::remove_directories(Path.str()));
+    }
+  }
+
+  TempDir(const TempDir &) = delete;
+  TempDir &operator=(const TempDir &) = delete;
+
+  TempDir(TempDir &&) = default;
+  TempDir &operator=(TempDir &&) = default;
+
+  /// The path to the temporary directory.
+  StringRef path() const { return Path; }
+
+  /// The null-terminated C string pointing to the path.
+  const char *c_str() { return Path.c_str(); }
+
+  /// Creates a new path by appending the argument to the path of the managed
+  /// directory using the native path separator.
+  SmallString<128> path(StringRef component) const {
+    SmallString<128> Result(Path);
+    SmallString<128> ComponentToAppend(component);
+    llvm::sys::path::native(ComponentToAppend);
+    llvm::sys::path::append(Result, Twine(ComponentToAppend));
+    return Result;
+  }
+};
+
+/// A RAII object that creates a link upon initialization and
+/// removes it upon destruction.
+///
+/// The link may be a soft or a hard link, depending on the platform.
+class TempLink {
+  SmallString<128> Path;
+
+public:
+  /// Creates a managed link at path Link pointing to Target.
+  TempLink(StringRef Target, StringRef Link) {
+    Path = Link;
+    std::error_code EC = sys::fs::create_link(Target, Link);
+    if (EC)
+      Path.clear();
+    EXPECT_FALSE(EC);
+  }
+  ~TempLink() {
+    if (!Path.empty()) {
+      EXPECT_FALSE(llvm::sys::fs::remove(Path.str()));
+    }
+  }
+
+  TempLink(const TempLink &) = delete;
+  TempLink &operator=(const TempLink &) = delete;
+
+  TempLink(TempLink &&) = default;
+  TempLink &operator=(TempLink &&) = default;
+
+  /// The path to the link.
+  StringRef path() const { return Path; }
+};
+
+/// A RAII object that creates a file upon initialization and
+/// removes it upon destruction.
+class TempFile {
+  SmallString<128> Path;
+
+public:
+  /// Creates a managed file.
+  ///
+  /// @param Name The name of the file to create.
+  /// @param Contents The string to write to the file.
+  /// @param Unique If true, the file will be created using
+  ///               llvm::sys::fs::createTemporaryFile.
+  TempFile(StringRef Name, StringRef Suffix = "", StringRef Contents = "",
+           bool Unique = false) {
+    std::error_code EC;
+    int fd;
+    if (Unique) {
+      EC = llvm::sys::fs::createTemporaryFile(Name, Suffix, fd, Path);
+    } else {
+      Path = Name;
+      if (!Suffix.empty()) {
+        Path.append(".");
+        Path.append(Suffix);
+      }
+      EC = llvm::sys::fs::openFileForWrite(Path, fd);
+    }
+    EXPECT_FALSE(EC);
+    raw_fd_ostream OS(fd, /*shouldClose*/ true);
+    OS << Contents;
+    OS.flush();
+    EXPECT_FALSE(OS.error());
+    if (EC || OS.error())
+      Path.clear();
+  }
+  ~TempFile() {
+    if (!Path.empty()) {
+      EXPECT_FALSE(llvm::sys::fs::remove(Path.str()));
+    }
+  }
+
+  /// The path to the file.
+  StringRef path() const { return Path; }
+};
+
 } // namespace unittest
 } // namespace llvm
 
diff --git a/linux-x64/clang/include/llvm/TextAPI/MachO/Architecture.def b/linux-x64/clang/include/llvm/TextAPI/MachO/Architecture.def
index 4c695fe..2fcae3b 100644
--- a/linux-x64/clang/include/llvm/TextAPI/MachO/Architecture.def
+++ b/linux-x64/clang/include/llvm/TextAPI/MachO/Architecture.def
@@ -13,26 +13,27 @@
 ///
 /// X86 architectures sorted by cpu type and sub type id.
 ///
-ARCHINFO(i386, MachO::CPU_TYPE_I386, MachO::CPU_SUBTYPE_I386_ALL)
-ARCHINFO(x86_64, MachO::CPU_TYPE_X86_64, MachO::CPU_SUBTYPE_X86_64_ALL)
-ARCHINFO(x86_64h, MachO::CPU_TYPE_X86_64, MachO::CPU_SUBTYPE_X86_64_H)
+ARCHINFO(i386, MachO::CPU_TYPE_I386, MachO::CPU_SUBTYPE_I386_ALL, 32)
+ARCHINFO(x86_64, MachO::CPU_TYPE_X86_64, MachO::CPU_SUBTYPE_X86_64_ALL, 64)
+ARCHINFO(x86_64h, MachO::CPU_TYPE_X86_64, MachO::CPU_SUBTYPE_X86_64_H, 64)
 
 
 ///
 /// ARM architectures sorted by cpu sub type id.
 ///
-ARCHINFO(armv4t, MachO::CPU_TYPE_ARM, MachO::CPU_SUBTYPE_ARM_V4T)
-ARCHINFO(armv6, MachO::CPU_TYPE_ARM, MachO::CPU_SUBTYPE_ARM_V6)
-ARCHINFO(armv5, MachO::CPU_TYPE_ARM, MachO::CPU_SUBTYPE_ARM_V5TEJ)
-ARCHINFO(armv7, MachO::CPU_TYPE_ARM, MachO::CPU_SUBTYPE_ARM_V7)
-ARCHINFO(armv7s, MachO::CPU_TYPE_ARM, MachO::CPU_SUBTYPE_ARM_V7S)
-ARCHINFO(armv7k, MachO::CPU_TYPE_ARM, MachO::CPU_SUBTYPE_ARM_V7K)
-ARCHINFO(armv6m, MachO::CPU_TYPE_ARM, MachO::CPU_SUBTYPE_ARM_V6M)
-ARCHINFO(armv7m, MachO::CPU_TYPE_ARM, MachO::CPU_SUBTYPE_ARM_V7M)
-ARCHINFO(armv7em, MachO::CPU_TYPE_ARM, MachO::CPU_SUBTYPE_ARM_V7EM)
+ARCHINFO(armv4t, MachO::CPU_TYPE_ARM, MachO::CPU_SUBTYPE_ARM_V4T, 32)
+ARCHINFO(armv6, MachO::CPU_TYPE_ARM, MachO::CPU_SUBTYPE_ARM_V6, 32)
+ARCHINFO(armv5, MachO::CPU_TYPE_ARM, MachO::CPU_SUBTYPE_ARM_V5TEJ, 32)
+ARCHINFO(armv7, MachO::CPU_TYPE_ARM, MachO::CPU_SUBTYPE_ARM_V7, 32)
+ARCHINFO(armv7s, MachO::CPU_TYPE_ARM, MachO::CPU_SUBTYPE_ARM_V7S, 32)
+ARCHINFO(armv7k, MachO::CPU_TYPE_ARM, MachO::CPU_SUBTYPE_ARM_V7K, 32)
+ARCHINFO(armv6m, MachO::CPU_TYPE_ARM, MachO::CPU_SUBTYPE_ARM_V6M, 32)
+ARCHINFO(armv7m, MachO::CPU_TYPE_ARM, MachO::CPU_SUBTYPE_ARM_V7M, 32)
+ARCHINFO(armv7em, MachO::CPU_TYPE_ARM, MachO::CPU_SUBTYPE_ARM_V7EM, 32)
 
 
 ///
 /// ARM64 architectures sorted by cpu sub type id.
 ///
-ARCHINFO(arm64, MachO::CPU_TYPE_ARM64, MachO::CPU_SUBTYPE_ARM64_ALL)
+ARCHINFO(arm64, MachO::CPU_TYPE_ARM64, MachO::CPU_SUBTYPE_ARM64_ALL, 64)
+ARCHINFO(arm64e, MachO::CPU_TYPE_ARM64, MachO::CPU_SUBTYPE_ARM64E, 64)
diff --git a/linux-x64/clang/include/llvm/TextAPI/MachO/Architecture.h b/linux-x64/clang/include/llvm/TextAPI/MachO/Architecture.h
index 055baeb..7a9f951 100644
--- a/linux-x64/clang/include/llvm/TextAPI/MachO/Architecture.h
+++ b/linux-x64/clang/include/llvm/TextAPI/MachO/Architecture.h
@@ -13,15 +13,19 @@
 #ifndef LLVM_TEXTAPI_MACHO_ARCHITECTURE_H
 #define LLVM_TEXTAPI_MACHO_ARCHITECTURE_H
 
-#include "llvm/ADT/StringRef.h"
-#include "llvm/Support/raw_ostream.h"
+#include <cstdint>
+#include <utility>
 
 namespace llvm {
+class raw_ostream;
+class StringRef;
+class Triple;
+
 namespace MachO {
 
 /// Defines the architecture slices that are supported by Text-based Stub files.
 enum Architecture : uint8_t {
-#define ARCHINFO(Arch, Type, SubType) AK_##Arch,
+#define ARCHINFO(Arch, Type, SubType, NumBits) AK_##Arch,
 #include "llvm/TextAPI/MachO/Architecture.def"
 #undef ARCHINFO
   AK_unknown, // this has to go last.
@@ -39,6 +43,12 @@
 /// Convert an architecture slice to a CPU Type and Subtype pair.
 std::pair<uint32_t, uint32_t> getCPUTypeFromArchitecture(Architecture Arch);
 
+/// Convert a target to an architecture slice.
+Architecture mapToArchitecture(const llvm::Triple &Target);
+
+/// Check if architecture is 64 bit.
+bool is64Bit(Architecture);
+
 raw_ostream &operator<<(raw_ostream &OS, Architecture Arch);
 
 } // end namespace MachO.
diff --git a/linux-x64/clang/include/llvm/TextAPI/MachO/ArchitectureSet.h b/linux-x64/clang/include/llvm/TextAPI/MachO/ArchitectureSet.h
index d8dfc7f..c48a4a7 100644
--- a/linux-x64/clang/include/llvm/TextAPI/MachO/ArchitectureSet.h
+++ b/linux-x64/clang/include/llvm/TextAPI/MachO/ArchitectureSet.h
@@ -13,14 +13,17 @@
 #ifndef LLVM_TEXTAPI_MACHO_ARCHITECTURE_SET_H
 #define LLVM_TEXTAPI_MACHO_ARCHITECTURE_SET_H
 
-#include "llvm/Support/raw_ostream.h"
 #include "llvm/TextAPI/MachO/Architecture.h"
 #include <cstddef>
 #include <iterator>
 #include <limits>
+#include <string>
+#include <tuple>
 #include <vector>
 
 namespace llvm {
+class raw_ostream;
+
 namespace MachO {
 
 class ArchitectureSet {
@@ -59,6 +62,10 @@
 
   ArchSetType rawValue() const { return ArchSet; }
 
+  bool hasX86() const {
+    return has(AK_i386) || has(AK_x86_64) || has(AK_x86_64h);
+  }
+
   template <typename Ty>
   class arch_iterator
       : public std::iterator<std::forward_iterator_tag, Architecture, size_t> {
diff --git a/linux-x64/clang/include/llvm/TextAPI/MachO/InterfaceFile.h b/linux-x64/clang/include/llvm/TextAPI/MachO/InterfaceFile.h
index e722449..09d2b8c 100644
--- a/linux-x64/clang/include/llvm/TextAPI/MachO/InterfaceFile.h
+++ b/linux-x64/clang/include/llvm/TextAPI/MachO/InterfaceFile.h
@@ -26,21 +26,13 @@
 #include "llvm/TextAPI/MachO/Architecture.h"
 #include "llvm/TextAPI/MachO/ArchitectureSet.h"
 #include "llvm/TextAPI/MachO/PackedVersion.h"
+#include "llvm/TextAPI/MachO/Platform.h"
 #include "llvm/TextAPI/MachO/Symbol.h"
+#include "llvm/TextAPI/MachO/Target.h"
 
 namespace llvm {
 namespace MachO {
 
-/// Defines the list of MachO platforms.
-enum class PlatformKind : unsigned {
-  unknown,
-  macOS = MachO::PLATFORM_MACOS,
-  iOS = MachO::PLATFORM_IOS,
-  tvOS = MachO::PLATFORM_TVOS,
-  watchOS = MachO::PLATFORM_WATCHOS,
-  bridgeOS = MachO::PLATFORM_BRIDGEOS,
-};
-
 /// Defines a list of Objective-C constraints.
 enum class ObjCConstraintType : unsigned {
   /// No constraint.
@@ -75,6 +67,9 @@
   /// Text-based stub file (.tbd) version 3.0
   TBD_V3  = 1U <<  2,
 
+  /// Text-based stub file (.tbd) version 4.0
+  TBD_V4  = 1U <<  3,
+
   All     = ~0U,
 
   LLVM_MARK_AS_BITMASK_ENUM(/*LargestValue=*/All),
@@ -89,29 +84,42 @@
 
   InterfaceFileRef(StringRef InstallName) : InstallName(InstallName) {}
 
-  InterfaceFileRef(StringRef InstallName, ArchitectureSet Archs)
-      : InstallName(InstallName), Architectures(Archs) {}
+  InterfaceFileRef(StringRef InstallName, const TargetList Targets)
+      : InstallName(InstallName), Targets(std::move(Targets)) {}
 
   StringRef getInstallName() const { return InstallName; };
-  void addArchitectures(ArchitectureSet Archs) { Architectures |= Archs; }
-  ArchitectureSet getArchitectures() const { return Architectures; }
-  bool hasArchitecture(Architecture Arch) const {
-    return Architectures.has(Arch);
+
+  void addTarget(const Target &Target);
+  template <typename RangeT> void addTargets(RangeT &&Targets) {
+    for (const auto &Target : Targets)
+      addTarget(Target(Target));
   }
 
+  using const_target_iterator = TargetList::const_iterator;
+  using const_target_range = llvm::iterator_range<const_target_iterator>;
+  const_target_range targets() const { return {Targets}; }
+
+  ArchitectureSet getArchitectures() const {
+    return mapToArchitectureSet(Targets);
+  }
+
+  PlatformSet getPlatforms() const { return mapToPlatformSet(Targets); }
+
   bool operator==(const InterfaceFileRef &O) const {
-    return std::tie(InstallName, Architectures) ==
-           std::tie(O.InstallName, O.Architectures);
+    return std::tie(InstallName, Targets) == std::tie(O.InstallName, O.Targets);
+  }
+
+  bool operator!=(const InterfaceFileRef &O) const {
+    return std::tie(InstallName, Targets) != std::tie(O.InstallName, O.Targets);
   }
 
   bool operator<(const InterfaceFileRef &O) const {
-    return std::tie(InstallName, Architectures) <
-           std::tie(O.InstallName, O.Architectures);
+    return std::tie(InstallName, Targets) < std::tie(O.InstallName, O.Targets);
   }
 
 private:
   std::string InstallName;
-  ArchitectureSet Architectures;
+  TargetList Targets;
 };
 
 } // end namespace MachO.
@@ -150,7 +158,7 @@
   /// Set the path from which this file was generated (if applicable).
   ///
   /// \param Path_ The path to the source file.
-  void setPath(StringRef Path_) { Path = Path_; }
+  void setPath(StringRef Path_) { Path = std::string(Path_); }
 
   /// Get the path from which this file was generated (if applicable).
   ///
@@ -170,30 +178,48 @@
   /// \return The file type.
   FileType getFileType() const { return FileKind; }
 
-  /// Set the platform.
-  void setPlatform(PlatformKind Platform_) { Platform = Platform_; }
-
-  /// Get the platform.
-  PlatformKind getPlatform() const { return Platform; }
-
-  /// Specify the set of supported architectures by this file.
-  void setArchitectures(ArchitectureSet Architectures_) {
-    Architectures = Architectures_;
+  /// Get the architectures.
+  ///
+  /// \return The applicable architectures.
+  ArchitectureSet getArchitectures() const {
+    return mapToArchitectureSet(Targets);
   }
 
-  /// Add the set of supported architectures by this file.
-  void addArchitectures(ArchitectureSet Architectures_) {
-    Architectures |= Architectures_;
+  /// Get the platforms.
+  ///
+  /// \return The applicable platforms.
+  PlatformSet getPlatforms() const { return mapToPlatformSet(Targets); }
+
+  /// Set and add target.
+  ///
+  /// \param Target the target to add into.
+  void addTarget(const Target &Target);
+
+  /// Set and add targets.
+  ///
+  /// Add the subset of llvm::triples that is supported by Tapi
+  ///
+  /// \param Targets the collection of targets.
+  template <typename RangeT> void addTargets(RangeT &&Targets) {
+    for (const auto &Target_ : Targets)
+      addTarget(Target(Target_));
   }
 
-  /// Add supported architecture by this file..
-  void addArch(Architecture Arch) { Architectures.set(Arch); }
+  using const_target_iterator = TargetList::const_iterator;
+  using const_target_range = llvm::iterator_range<const_target_iterator>;
+  const_target_range targets() const { return {Targets}; }
 
-  /// Get the set of supported architectures.
-  ArchitectureSet getArchitectures() const { return Architectures; }
+  using const_filtered_target_iterator =
+      llvm::filter_iterator<const_target_iterator,
+                            std::function<bool(const Target &)>>;
+  using const_filtered_target_range =
+      llvm::iterator_range<const_filtered_target_iterator>;
+  const_filtered_target_range targets(ArchitectureSet Archs) const;
 
   /// Set the install name of the library.
-  void setInstallName(StringRef InstallName_) { InstallName = InstallName_; }
+  void setInstallName(StringRef InstallName_) {
+    InstallName = std::string(InstallName_);
+  }
 
   /// Get the install name of the library.
   StringRef getInstallName() const { return InstallName; }
@@ -244,11 +270,18 @@
   /// Check if this file was generated during InstallAPI.
   bool isInstallAPI() const { return IsInstallAPI; }
 
-  /// Set the parent umbrella framework.
-  void setParentUmbrella(StringRef Parent) { ParentUmbrella = Parent; }
+  /// Set the parent umbrella frameworks.
+  /// \param Target_ The target applicable to Parent
+  /// \param Parent  The name of Parent
+  void addParentUmbrella(const Target &Target_, StringRef Parent);
 
-  /// Get the parent umbrella framework.
-  StringRef getParentUmbrella() const { return ParentUmbrella; }
+  /// Get the list of Parent Umbrella frameworks.
+  ///
+  /// \return Returns a list of target information and install name of parent
+  /// umbrellas.
+  const std::vector<std::pair<Target, std::string>> &umbrellas() const {
+    return ParentUmbrellas;
+  }
 
   /// Add an allowable client.
   ///
@@ -257,9 +290,9 @@
   /// that is being generated needs to match one of the allowable clients or the
   /// linker refuses to link this library.
   ///
-  /// \param Name The name of the client that is allowed to link this library.
-  /// \param Architectures The set of architecture for which this applies.
-  void addAllowableClient(StringRef Name, ArchitectureSet Architectures);
+  /// \param InstallName The name of the client that is allowed to link this library.
+  /// \param Target The target triple for which this applies.
+  void addAllowableClient(StringRef InstallName, const Target &Target);
 
   /// Get the list of allowable clients.
   ///
@@ -271,9 +304,8 @@
   /// Add a re-exported library.
   ///
   /// \param InstallName The name of the library to re-export.
-  /// \param Architectures The set of architecture for which this applies.
-  void addReexportedLibrary(StringRef InstallName,
-                            ArchitectureSet Architectures);
+  /// \param Target The target triple for which this applies.
+  void addReexportedLibrary(StringRef InstallName, const Target &Target);
 
   /// Get the list of re-exported libraries.
   ///
@@ -282,27 +314,41 @@
     return ReexportedLibraries;
   }
 
-  /// Add an architecture/UUID pair.
+  /// Add an Target/UUID pair.
   ///
-  /// \param Arch The architecture for which this applies.
+  /// \param Target The target triple for which this applies.
   /// \param UUID The UUID of the library for the specified architecture.
-  void addUUID(Architecture Arch, StringRef UUID);
+  void addUUID(const Target &Target, StringRef UUID);
 
-  /// Add an architecture/UUID pair.
+  /// Add an Target/UUID pair.
   ///
-  /// \param Arch The architecture for which this applies.
+  /// \param Target The target triple for which this applies.
   /// \param UUID The UUID of the library for the specified architecture.
-  void addUUID(Architecture Arch, uint8_t UUID[16]);
+  void addUUID(const Target &Target, uint8_t UUID[16]);
 
-  /// Get the list of architecture/UUID pairs.
+  /// Get the list of Target/UUID pairs.
   ///
-  /// \return Returns a list of architecture/UUID pairs.
-  const std::vector<std::pair<Architecture, std::string>> &uuids() const {
+  /// \return Returns a list of Target/UUID pairs.
+  const std::vector<std::pair<Target, std::string>> &uuids() const {
     return UUIDs;
   }
 
+  /// Add a library for inlining to top level library.
+  ///
+  ///\param Document The library to inline with top level library.
+  void addDocument(std::shared_ptr<InterfaceFile> &&Document) {
+    Documents.emplace_back(std::move(Document));
+  }
+
+  /// Get the list of inlined libraries.
+  ///
+  /// \return Returns a list of the inlined frameworks.
+  const std::vector<std::shared_ptr<InterfaceFile>> &documents() const {
+    return Documents;
+  }
+
   /// Add a symbol to the symbols list or extend an existing one.
-  void addSymbol(SymbolKind Kind, StringRef Name, ArchitectureSet Architectures,
+  void addSymbol(SymbolKind Kind, StringRef Name, const TargetList &Targets,
                  SymbolFlags Flags = SymbolFlags::None);
 
   using SymbolMapType = DenseMap<SymbolsMapKey, Symbol *>;
@@ -320,84 +366,35 @@
     reference operator*() const { return I->second; }
     pointer operator->() const { return I->second; }
   };
+
   using const_symbol_range = iterator_range<const_symbol_iterator>;
 
-  // Custom iterator to return only exported symbols.
-  struct const_export_iterator
-      : public iterator_adaptor_base<
-            const_export_iterator, const_symbol_iterator,
-            std::forward_iterator_tag, const Symbol *> {
-    const_symbol_iterator _end;
-
-    void skipToNextSymbol() {
-      while (I != _end && I->isUndefined())
-        ++I;
-    }
-
-    const_export_iterator() = default;
-    template <typename U>
-    const_export_iterator(U &&it, U &&end)
-        : iterator_adaptor_base(std::forward<U &&>(it)),
-          _end(std::forward<U &&>(end)) {
-      skipToNextSymbol();
-    }
-
-    const_export_iterator &operator++() {
-      ++I;
-      skipToNextSymbol();
-      return *this;
-    }
-
-    const_export_iterator operator++(int) {
-      const_export_iterator tmp(*this);
-      ++(*this);
-      return tmp;
-    }
-  };
-  using const_export_range = llvm::iterator_range<const_export_iterator>;
-
-  // Custom iterator to return only undefined symbols.
-  struct const_undefined_iterator
-      : public iterator_adaptor_base<
-            const_undefined_iterator, const_symbol_iterator,
-            std::forward_iterator_tag, const Symbol *> {
-    const_symbol_iterator _end;
-
-    void skipToNextSymbol() {
-      while (I != _end && !I->isUndefined())
-        ++I;
-    }
-
-    const_undefined_iterator() = default;
-    template <typename U>
-    const_undefined_iterator(U &&it, U &&end)
-        : iterator_adaptor_base(std::forward<U &&>(it)),
-          _end(std::forward<U &&>(end)) {
-      skipToNextSymbol();
-    }
-
-    const_undefined_iterator &operator++() {
-      ++I;
-      skipToNextSymbol();
-      return *this;
-    }
-
-    const_undefined_iterator operator++(int) {
-      const_undefined_iterator tmp(*this);
-      ++(*this);
-      return tmp;
-    }
-  };
-  using const_undefined_range = llvm::iterator_range<const_undefined_iterator>;
+  using const_filtered_symbol_iterator =
+      filter_iterator<const_symbol_iterator,
+                      std::function<bool(const Symbol *)>>;
+  using const_filtered_symbol_range =
+      iterator_range<const_filtered_symbol_iterator>;
 
   const_symbol_range symbols() const {
     return {Symbols.begin(), Symbols.end()};
   }
-  const_export_range exports() const {
-    return {{Symbols.begin(), Symbols.end()}, {Symbols.end(), Symbols.end()}};
+
+  const_filtered_symbol_range exports() const {
+    std::function<bool(const Symbol *)> fn = [](const Symbol *Symbol) {
+      return !Symbol->isUndefined();
+    };
+    return make_filter_range(
+        make_range<const_symbol_iterator>({Symbols.begin()}, {Symbols.end()}),
+        fn);
   }
-  const_undefined_range undefineds() const {
-    return {{Symbols.begin(), Symbols.end()}, {Symbols.end(), Symbols.end()}};
+
+  const_filtered_symbol_range undefineds() const {
+    std::function<bool(const Symbol *)> fn = [](const Symbol *Symbol) {
+      return Symbol->isUndefined();
+    };
+    return make_filter_range(
+        make_range<const_symbol_iterator>({Symbols.begin()}, {Symbols.end()}),
+        fn);
   }
 
 private:
@@ -411,10 +408,9 @@
     return StringRef(reinterpret_cast<const char *>(Ptr), String.size());
   }
 
+  TargetList Targets;
   std::string Path;
   FileType FileKind;
-  PlatformKind Platform;
-  ArchitectureSet Architectures;
   std::string InstallName;
   PackedVersion CurrentVersion;
   PackedVersion CompatibilityVersion;
@@ -423,10 +419,11 @@
   bool IsAppExtensionSafe{false};
   bool IsInstallAPI{false};
   ObjCConstraintType ObjcConstraint = ObjCConstraintType::None;
-  std::string ParentUmbrella;
+  std::vector<std::pair<Target, std::string>> ParentUmbrellas;
   std::vector<InterfaceFileRef> AllowableClients;
   std::vector<InterfaceFileRef> ReexportedLibraries;
-  std::vector<std::pair<Architecture, std::string>> UUIDs;
+  std::vector<std::shared_ptr<InterfaceFile>> Documents;
+  std::vector<std::pair<Target, std::string>> UUIDs;
   SymbolMapType Symbols;
 };
 
diff --git a/linux-x64/clang/include/llvm/TextAPI/MachO/PackedVersion.h b/linux-x64/clang/include/llvm/TextAPI/MachO/PackedVersion.h
index 2d01380..0d9158a 100644
--- a/linux-x64/clang/include/llvm/TextAPI/MachO/PackedVersion.h
+++ b/linux-x64/clang/include/llvm/TextAPI/MachO/PackedVersion.h
@@ -13,10 +13,13 @@
 #ifndef LLVM_TEXTAPI_MACHO_PACKED_VERSION_H
 #define LLVM_TEXTAPI_MACHO_PACKED_VERSION_H
 
-#include "llvm/ADT/StringRef.h"
-#include "llvm/Support/raw_ostream.h"
+#include <cstdint>
+#include <utility>
 
 namespace llvm {
+class raw_ostream;
+class StringRef;
+
 namespace MachO {
 
 class PackedVersion {
diff --git a/linux-x64/clang/include/llvm/TextAPI/MachO/Platform.h b/linux-x64/clang/include/llvm/TextAPI/MachO/Platform.h
new file mode 100644
index 0000000..fc59b86
--- /dev/null
+++ b/linux-x64/clang/include/llvm/TextAPI/MachO/Platform.h
@@ -0,0 +1,46 @@
+//===- llvm/TextAPI/MachO/Platform.h - Platform -----------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Defines the Platforms supported by Tapi and helpers.
+//
+//===----------------------------------------------------------------------===//
+#ifndef LLVM_TEXTAPI_MACHO_PLATFORM_H
+#define LLVM_TEXTAPI_MACHO_PLATFORM_H
+
+#include "llvm/ADT/SmallSet.h"
+#include "llvm/BinaryFormat/MachO.h"
+
+namespace llvm {
+namespace MachO {
+
+/// Defines the list of MachO platforms.
+enum class PlatformKind : unsigned {
+  unknown,
+  macOS = MachO::PLATFORM_MACOS,
+  iOS = MachO::PLATFORM_IOS,
+  tvOS = MachO::PLATFORM_TVOS,
+  watchOS = MachO::PLATFORM_WATCHOS,
+  bridgeOS = MachO::PLATFORM_BRIDGEOS,
+  macCatalyst = MachO::PLATFORM_MACCATALYST,
+  iOSSimulator = MachO::PLATFORM_IOSSIMULATOR,
+  tvOSSimulator = MachO::PLATFORM_TVOSSIMULATOR,
+  watchOSSimulator = MachO::PLATFORM_WATCHOSSIMULATOR,
+  driverKit = MachO::PLATFORM_DRIVERKIT,
+};
+
+using PlatformSet = SmallSet<PlatformKind, 3>;
+
+PlatformKind mapToPlatformKind(PlatformKind Platform, bool WantSim);
+PlatformKind mapToPlatformKind(const Triple &Target);
+PlatformSet mapToPlatformSet(ArrayRef<Triple> Targets);
+StringRef getPlatformName(PlatformKind Platform);
+
+} // end namespace MachO.
+} // end namespace llvm.
+
+#endif // LLVM_TEXTAPI_MACHO_PLATFORM_H
diff --git a/linux-x64/clang/include/llvm/TextAPI/MachO/Symbol.h b/linux-x64/clang/include/llvm/TextAPI/MachO/Symbol.h
index 3c7ff5e..1b1632c 100644
--- a/linux-x64/clang/include/llvm/TextAPI/MachO/Symbol.h
+++ b/linux-x64/clang/include/llvm/TextAPI/MachO/Symbol.h
@@ -14,6 +14,7 @@
 #include "llvm/Support/Error.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/TextAPI/MachO/ArchitectureSet.h"
+#include "llvm/TextAPI/MachO/Target.h"
 
 namespace llvm {
 namespace MachO {
@@ -37,7 +38,10 @@
   /// Undefined
   Undefined        = 1U << 3,
 
-  LLVM_MARK_AS_BITMASK_ENUM(/*LargestValue=*/Undefined),
+  /// Rexported
+  Rexported        = 1U << 4,
+
+  LLVM_MARK_AS_BITMASK_ENUM(/*LargestValue=*/Rexported),
 };
 
 // clang-format on
@@ -49,16 +53,18 @@
   ObjectiveCInstanceVariable,
 };
 
+using TargetList = SmallVector<Target, 5>;
 class Symbol {
 public:
-  constexpr Symbol(SymbolKind Kind, StringRef Name,
-                   ArchitectureSet Architectures, SymbolFlags Flags)
-      : Name(Name), Architectures(Architectures), Kind(Kind), Flags(Flags) {}
+  Symbol(SymbolKind Kind, StringRef Name, TargetList Targets, SymbolFlags Flags)
+      : Name(Name), Targets(std::move(Targets)), Kind(Kind), Flags(Flags) {}
 
+  void addTarget(Target target) { Targets.emplace_back(target); }
   SymbolKind getKind() const { return Kind; }
   StringRef getName() const { return Name; }
-  ArchitectureSet getArchitectures() const { return Architectures; }
-  void addArchitectures(ArchitectureSet Archs) { Architectures |= Archs; }
+  ArchitectureSet getArchitectures() const {
+    return mapToArchitectureSet(Targets);
+  }
   SymbolFlags getFlags() const { return Flags; }
 
   bool isWeakDefined() const {
@@ -78,6 +84,21 @@
     return (Flags & SymbolFlags::Undefined) == SymbolFlags::Undefined;
   }
 
+  bool isReexported() const {
+    return (Flags & SymbolFlags::Rexported) == SymbolFlags::Rexported;
+  }
+
+  using const_target_iterator = TargetList::const_iterator;
+  using const_target_range = llvm::iterator_range<const_target_iterator>;
+  const_target_range targets() const { return {Targets}; }
+
+  using const_filtered_target_iterator =
+      llvm::filter_iterator<const_target_iterator,
+                            std::function<bool(const Target &)>>;
+  using const_filtered_target_range =
+      llvm::iterator_range<const_filtered_target_iterator>;
+  const_filtered_target_range targets(ArchitectureSet architectures) const;
+
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
   void dump(raw_ostream &OS) const;
   void dump() const { dump(llvm::errs()); }
@@ -85,7 +106,7 @@
 
 private:
   StringRef Name;
-  ArchitectureSet Architectures;
+  TargetList Targets;
   SymbolKind Kind;
   SymbolFlags Flags;
 };
diff --git a/linux-x64/clang/include/llvm/TextAPI/MachO/Target.h b/linux-x64/clang/include/llvm/TextAPI/MachO/Target.h
new file mode 100644
index 0000000..5fe44cb
--- /dev/null
+++ b/linux-x64/clang/include/llvm/TextAPI/MachO/Target.h
@@ -0,0 +1,68 @@
+//===- llvm/TextAPI/Target.h - TAPI Target ----------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TEXTAPI_MACHO_TARGET_H
+#define LLVM_TEXTAPI_MACHO_TARGET_H
+
+#include "llvm/ADT/Triple.h"
+#include "llvm/Support/Error.h"
+#include "llvm/TextAPI/MachO/Architecture.h"
+#include "llvm/TextAPI/MachO/ArchitectureSet.h"
+#include "llvm/TextAPI/MachO/Platform.h"
+
+namespace llvm {
+namespace MachO {
+
+// This is similar to a llvm Triple, but the triple doesn't have all the
+// information we need. For example there is no enum value for x86_64h. The
+// only way to get that information is to parse the triple string.
+class Target {
+public:
+  Target() = default;
+  Target(Architecture Arch, PlatformKind Platform)
+      : Arch(Arch), Platform(Platform) {}
+  explicit Target(const llvm::Triple &Triple)
+      : Arch(mapToArchitecture(Triple)), Platform(mapToPlatformKind(Triple)) {}
+
+  static llvm::Expected<Target> create(StringRef Target);
+
+  operator std::string() const;
+
+  Architecture Arch;
+  PlatformKind Platform;
+};
+
+inline bool operator==(const Target &LHS, const Target &RHS) {
+  return std::tie(LHS.Arch, LHS.Platform) == std::tie(RHS.Arch, RHS.Platform);
+}
+
+inline bool operator!=(const Target &LHS, const Target &RHS) {
+  return std::tie(LHS.Arch, LHS.Platform) != std::tie(RHS.Arch, RHS.Platform);
+}
+
+inline bool operator<(const Target &LHS, const Target &RHS) {
+  return std::tie(LHS.Arch, LHS.Platform) < std::tie(RHS.Arch, RHS.Platform);
+}
+
+inline bool operator==(const Target &LHS, const Architecture &RHS) {
+  return LHS.Arch == RHS;
+}
+
+inline bool operator!=(const Target &LHS, const Architecture &RHS) {
+  return LHS.Arch != RHS;
+}
+
+PlatformSet mapToPlatformSet(ArrayRef<Target> Targets);
+ArchitectureSet mapToArchitectureSet(ArrayRef<Target> Targets);
+
+raw_ostream &operator<<(raw_ostream &OS, const Target &Target);
+
+} // namespace MachO
+} // namespace llvm
+
+#endif // LLVM_TEXTAPI_MACHO_TARGET_H
diff --git a/linux-x64/clang/include/llvm/TextAPI/MachO/TextAPIReader.h b/linux-x64/clang/include/llvm/TextAPI/MachO/TextAPIReader.h
index 6d9c09d..889b8aa 100644
--- a/linux-x64/clang/include/llvm/TextAPI/MachO/TextAPIReader.h
+++ b/linux-x64/clang/include/llvm/TextAPI/MachO/TextAPIReader.h
@@ -10,9 +10,11 @@
 #define LLVM_TEXTAPI_MACHO_READER_H
 
 #include "llvm/Support/Error.h"
-#include "llvm/Support/MemoryBuffer.h"
 
 namespace llvm {
+
+class MemoryBufferRef;
+
 namespace MachO {
 
 class InterfaceFile;
@@ -20,10 +22,7 @@
 class TextAPIReader {
 public:
   static Expected<std::unique_ptr<InterfaceFile>>
-  get(std::unique_ptr<MemoryBuffer> InputBuffer);
-
-  static Expected<std::unique_ptr<InterfaceFile>>
-  getUnmanaged(llvm::MemoryBuffer *InputBuffer);
+  get(MemoryBufferRef InputBuffer);
 
   TextAPIReader() = delete;
 };
diff --git a/linux-x64/clang/include/llvm/TextAPI/MachO/TextAPIWriter.h b/linux-x64/clang/include/llvm/TextAPI/MachO/TextAPIWriter.h
index 2a45bb8..109ac8e 100644
--- a/linux-x64/clang/include/llvm/TextAPI/MachO/TextAPIWriter.h
+++ b/linux-x64/clang/include/llvm/TextAPI/MachO/TextAPIWriter.h
@@ -9,9 +9,11 @@
 #ifndef LLVM_TEXTAPI_MACHO_WRITER_H
 #define LLVM_TEXTAPI_MACHO_WRITER_H
 
-#include "llvm/Support/MemoryBuffer.h"
-
 namespace llvm {
+
+class Error;
+class raw_ostream;
+
 namespace MachO {
 
 class InterfaceFile;
diff --git a/linux-x64/clang/include/llvm/Transforms/AggressiveInstCombine/AggressiveInstCombine.h b/linux-x64/clang/include/llvm/Transforms/AggressiveInstCombine/AggressiveInstCombine.h
index 887c880..e5e24e0 100644
--- a/linux-x64/clang/include/llvm/Transforms/AggressiveInstCombine/AggressiveInstCombine.h
+++ b/linux-x64/clang/include/llvm/Transforms/AggressiveInstCombine/AggressiveInstCombine.h
@@ -17,7 +17,6 @@
 #ifndef LLVM_TRANSFORMS_AGGRESSIVE_INSTCOMBINE_INSTCOMBINE_H
 #define LLVM_TRANSFORMS_AGGRESSIVE_INSTCOMBINE_INSTCOMBINE_H
 
-#include "llvm/IR/Function.h"
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
diff --git a/linux-x64/clang/include/llvm/Transforms/CFGuard.h b/linux-x64/clang/include/llvm/Transforms/CFGuard.h
new file mode 100644
index 0000000..86fcbc3
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Transforms/CFGuard.h
@@ -0,0 +1,26 @@
+//===-- CFGuard.h - CFGuard Transformations ---------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===---------------------------------------------------------------------===//
+// Windows Control Flow Guard passes (/guard:cf).
+//===---------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_CFGUARD_H
+#define LLVM_TRANSFORMS_CFGUARD_H
+
+namespace llvm {
+
+class FunctionPass;
+
+/// Insert Control FLow Guard checks on indirect function calls.
+FunctionPass *createCFGuardCheckPass();
+
+/// Insert Control FLow Guard dispatches on indirect function calls.
+FunctionPass *createCFGuardDispatchPass();
+
+} // namespace llvm
+
+#endif
diff --git a/linux-x64/clang/include/llvm/Transforms/Coroutines.h b/linux-x64/clang/include/llvm/Transforms/Coroutines.h
index 9df3ec0..2043592 100644
--- a/linux-x64/clang/include/llvm/Transforms/Coroutines.h
+++ b/linux-x64/clang/include/llvm/Transforms/Coroutines.h
@@ -20,17 +20,17 @@
 void addCoroutinePassesToExtensionPoints(PassManagerBuilder &Builder);
 
 /// Lower coroutine intrinsics that are not needed by later passes.
-Pass *createCoroEarlyPass();
+Pass *createCoroEarlyLegacyPass();
 
 /// Split up coroutines into multiple functions driving their state machines.
-Pass *createCoroSplitPass();
+Pass *createCoroSplitLegacyPass(bool ReuseFrameSlot = false);
 
 /// Analyze coroutines use sites, devirtualize resume/destroy calls and elide
 /// heap allocation for coroutine frame where possible.
-Pass *createCoroElidePass();
+Pass *createCoroElideLegacyPass();
 
 /// Lower all remaining coroutine intrinsics.
-Pass *createCoroCleanupPass();
+Pass *createCoroCleanupLegacyPass();
 
 }
 
diff --git a/linux-x64/clang/include/llvm/Transforms/Coroutines/CoroCleanup.h b/linux-x64/clang/include/llvm/Transforms/Coroutines/CoroCleanup.h
new file mode 100644
index 0000000..7ecdc05
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Transforms/Coroutines/CoroCleanup.h
@@ -0,0 +1,29 @@
+//===-- CoroCleanup.h - Lower all coroutine related intrinsics --*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// \file
+// This file delcares a pass that lowers all remaining coroutine intrinsics.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_COROUTINES_COROCLEANUP_H
+#define LLVM_TRANSFORMS_COROUTINES_COROCLEANUP_H
+
+#include "llvm/IR/PassManager.h"
+
+namespace llvm {
+
+class Function;
+
+struct CoroCleanupPass : PassInfoMixin<CoroCleanupPass> {
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static bool isRequired() { return true; }
+};
+} // end namespace llvm
+
+#endif // LLVM_TRANSFORMS_COROUTINES_COROCLEANUP_H
diff --git a/linux-x64/clang/include/llvm/Transforms/Coroutines/CoroEarly.h b/linux-x64/clang/include/llvm/Transforms/Coroutines/CoroEarly.h
new file mode 100644
index 0000000..3f5ec2a
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Transforms/Coroutines/CoroEarly.h
@@ -0,0 +1,32 @@
+//===---- CoroEarly.h - Lower early coroutine intrinsics --------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// \file
+// This file provides the interface to the early coroutine intrinsic lowering
+// pass. This pass lowers coroutine intrinsics that hide the details of the
+// exact calling convention for coroutine resume and destroy functions and
+// details of the structure of the coroutine frame.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_COROUTINES_COROEARLY_H
+#define LLVM_TRANSFORMS_COROUTINES_COROEARLY_H
+
+#include "llvm/IR/PassManager.h"
+
+namespace llvm {
+
+class Function;
+
+struct CoroEarlyPass : PassInfoMixin<CoroEarlyPass> {
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static bool isRequired() { return true; }
+};
+} // end namespace llvm
+
+#endif // LLVM_TRANSFORMS_COROUTINES_COROEARLY_H
diff --git a/linux-x64/clang/include/llvm/Transforms/Coroutines/CoroElide.h b/linux-x64/clang/include/llvm/Transforms/Coroutines/CoroElide.h
new file mode 100644
index 0000000..ff73cf2
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Transforms/Coroutines/CoroElide.h
@@ -0,0 +1,31 @@
+//===---- CoroElide.h - Coroutine frame allocation elision ------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// \file
+// This file declares a pass that replaces dynamic allocation of coroutine
+// frames with alloca and replaces calls to llvm.coro.resume and
+// llvm.coro.destroy with direct calls to coroutine sub-functions.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_COROUTINES_COROELIDE_H
+#define LLVM_TRANSFORMS_COROUTINES_COROELIDE_H
+
+#include "llvm/IR/PassManager.h"
+
+namespace llvm {
+
+class Function;
+
+struct CoroElidePass : PassInfoMixin<CoroElidePass> {
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static bool isRequired() { return true; }
+};
+} // end namespace llvm
+
+#endif // LLVM_TRANSFORMS_COROUTINES_COROELIDE_H
diff --git a/linux-x64/clang/include/llvm/Transforms/Coroutines/CoroSplit.h b/linux-x64/clang/include/llvm/Transforms/Coroutines/CoroSplit.h
new file mode 100644
index 0000000..f4eef19
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Transforms/Coroutines/CoroSplit.h
@@ -0,0 +1,35 @@
+//===- CoroSplit.h - Converts a coroutine into a state machine -*- C++ -*--===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// \file
+// This file declares the pass that builds the coroutine frame and outlines
+// the resume and destroy parts of the coroutine into separate functions.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_COROUTINES_COROSPLIT_H
+#define LLVM_TRANSFORMS_COROUTINES_COROSPLIT_H
+
+#include "llvm/Analysis/CGSCCPassManager.h"
+#include "llvm/Analysis/LazyCallGraph.h"
+#include "llvm/IR/PassManager.h"
+
+namespace llvm {
+
+struct CoroSplitPass : PassInfoMixin<CoroSplitPass> {
+  CoroSplitPass(bool ReuseFrameSlot = false) : ReuseFrameSlot(ReuseFrameSlot) {}
+
+  PreservedAnalyses run(LazyCallGraph::SCC &C, CGSCCAnalysisManager &AM,
+                        LazyCallGraph &CG, CGSCCUpdateResult &UR);
+  static bool isRequired() { return true; }
+
+  bool ReuseFrameSlot;
+};
+} // end namespace llvm
+
+#endif // LLVM_TRANSFORMS_COROUTINES_COROSPLIT_H
diff --git a/linux-x64/clang/include/llvm/Transforms/HelloNew/HelloWorld.h b/linux-x64/clang/include/llvm/Transforms/HelloNew/HelloWorld.h
new file mode 100644
index 0000000..6c75303
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Transforms/HelloNew/HelloWorld.h
@@ -0,0 +1,23 @@
+//===-- HelloWorld.h - Example Transformations ------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_HELLONEW_HELLOWORLD_H
+#define LLVM_TRANSFORMS_HELLONEW_HELLOWORLD_H
+
+#include "llvm/IR/PassManager.h"
+
+namespace llvm {
+
+class HelloWorldPass : public PassInfoMixin<HelloWorldPass> {
+public:
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+};
+
+} // namespace llvm
+
+#endif // LLVM_TRANSFORMS_HELLONEW_HELLOWORLD_H
diff --git a/linux-x64/clang/include/llvm/Transforms/IPO.h b/linux-x64/clang/include/llvm/Transforms/IPO.h
index de0c80f..af35718 100644
--- a/linux-x64/clang/include/llvm/Transforms/IPO.h
+++ b/linux-x64/clang/include/llvm/Transforms/IPO.h
@@ -25,13 +25,19 @@
 class ModuleSummaryIndex;
 class ModulePass;
 class Pass;
-class Function;
 class BasicBlock;
 class GlobalValue;
 class raw_ostream;
 
 //===----------------------------------------------------------------------===//
 //
+// This pass adds !annotation metadata to entries in the
+// @llvm.global.annotations global constant.
+//
+ModulePass *createAnnotation2MetadataLegacyPass();
+
+//===----------------------------------------------------------------------===//
+//
 // These functions removes symbols from functions and modules.  If OnlyDebugInfo
 // is true, only debugging information is removed from the module.
 //
@@ -84,10 +90,12 @@
 //===----------------------------------------------------------------------===//
 /// createGVExtractionPass - If deleteFn is true, this pass deletes
 /// the specified global values. Otherwise, it deletes as much of the module as
-/// possible, except for the global values specified.
+/// possible, except for the global values specified. If keepConstInit is true,
+/// the initializers of global constants are not deleted even if they are
+/// unused.
 ///
 ModulePass *createGVExtractionPass(std::vector<GlobalValue*>& GVs, bool
-                                   deleteFn = false);
+                                  deleteFn = false, bool keepConstInit = false);
 
 //===----------------------------------------------------------------------===//
 /// This pass performs iterative function importing from other modules.
@@ -151,10 +159,8 @@
 Pass *createArgumentPromotionPass(unsigned maxElements = 3);
 
 //===----------------------------------------------------------------------===//
-/// createIPConstantPropagationPass - This pass propagates constants from call
-/// sites into the bodies of functions.
-///
-ModulePass *createIPConstantPropagationPass();
+/// createOpenMPOptLegacyPass - OpenMP specific optimizations.
+Pass *createOpenMPOptLegacyPass();
 
 //===----------------------------------------------------------------------===//
 /// createIPSCCPPass - This pass propagates constants from call sites into the
@@ -210,6 +216,11 @@
 ModulePass *createHotColdSplittingPass();
 
 //===----------------------------------------------------------------------===//
+/// createIROutlinerPass - This pass finds similar code regions and factors
+/// those regions out into functions.
+ModulePass *createIROutlinerPass();
+
+//===----------------------------------------------------------------------===//
 /// createPartialInliningPass - This pass inlines parts of functions.
 ///
 ModulePass *createPartialInliningPass();
@@ -236,12 +247,15 @@
 /// The behavior depends on the summary arguments:
 /// - If ExportSummary is non-null, this pass will export type identifiers to
 ///   the given summary.
-/// - Otherwise, if ImportSummary is non-null, this pass will import type
-///   identifiers from the given summary.
-/// - Otherwise it does neither.
-/// It is invalid for both ExportSummary and ImportSummary to be non-null.
+/// - If ImportSummary is non-null, this pass will import type identifiers from
+///   the given summary.
+/// - Otherwise, if both are null and DropTypeTests is true, all type test
+///   assume sequences will be removed from the IR.
+/// It is invalid for both ExportSummary and ImportSummary to be non-null
+/// unless DropTypeTests is true.
 ModulePass *createLowerTypeTestsPass(ModuleSummaryIndex *ExportSummary,
-                                     const ModuleSummaryIndex *ImportSummary);
+                                     const ModuleSummaryIndex *ImportSummary,
+                                     bool DropTypeTests = false);
 
 /// This pass export CFI checks for use by external modules.
 ModulePass *createCrossDSOCFIPass();
diff --git a/linux-x64/clang/include/llvm/Transforms/IPO/AlwaysInliner.h b/linux-x64/clang/include/llvm/Transforms/IPO/AlwaysInliner.h
index 64e2523..6a208df 100644
--- a/linux-x64/clang/include/llvm/Transforms/IPO/AlwaysInliner.h
+++ b/linux-x64/clang/include/llvm/Transforms/IPO/AlwaysInliner.h
@@ -34,6 +34,7 @@
       : InsertLifetime(InsertLifetime) {}
 
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &);
+  static bool isRequired() { return true; }
 };
 
 /// Create a legacy pass manager instance of a pass to inline and remove
diff --git a/linux-x64/clang/include/llvm/Transforms/IPO/Annotation2Metadata.h b/linux-x64/clang/include/llvm/Transforms/IPO/Annotation2Metadata.h
new file mode 100644
index 0000000..cf7137b
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Transforms/IPO/Annotation2Metadata.h
@@ -0,0 +1,30 @@
+//===- Annotation2Metadata.h - Add !annotation metadata. --------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// New pass manager pass to convert @llvm.global.annotations to !annotation
+// metadata.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_IPO_ANNOTATION2METADATA_H
+#define LLVM_TRANSFORMS_IPO_ANNOTATION2METADATA_H
+
+#include "llvm/IR/PassManager.h"
+
+namespace llvm {
+
+class Module;
+
+/// Pass to convert @llvm.global.annotations to !annotation metadata.
+struct Annotation2MetadataPass : public PassInfoMixin<Annotation2MetadataPass> {
+  PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+};
+
+} // end namespace llvm
+
+#endif // LLVM_TRANSFORMS_IPO_SCCP_H
diff --git a/linux-x64/clang/include/llvm/Transforms/IPO/ArgumentPromotion.h b/linux-x64/clang/include/llvm/Transforms/IPO/ArgumentPromotion.h
index c8afb7b..6d6cb58 100644
--- a/linux-x64/clang/include/llvm/Transforms/IPO/ArgumentPromotion.h
+++ b/linux-x64/clang/include/llvm/Transforms/IPO/ArgumentPromotion.h
@@ -14,6 +14,7 @@
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
+class TargetTransformInfo;
 
 /// Argument promotion pass.
 ///
@@ -26,6 +27,17 @@
 public:
   ArgumentPromotionPass(unsigned MaxElements = 3u) : MaxElements(MaxElements) {}
 
+  /// Check if callers and the callee \p F agree how promoted arguments would be
+  /// passed. The ones that they do not agree on are eliminated from the sets but
+  /// the return value has to be observed as well.
+  static bool areFunctionArgsABICompatible(
+      const Function &F, const TargetTransformInfo &TTI,
+      SmallPtrSetImpl<Argument *> &ArgsToPromote,
+      SmallPtrSetImpl<Argument *> &ByValArgsToTransform);
+
+  /// Checks if a type could have padding bytes.
+  static bool isDenselyPacked(Type *type, const DataLayout &DL);
+
   PreservedAnalyses run(LazyCallGraph::SCC &C, CGSCCAnalysisManager &AM,
                         LazyCallGraph &CG, CGSCCUpdateResult &UR);
 };
diff --git a/linux-x64/clang/include/llvm/Transforms/IPO/Attributor.h b/linux-x64/clang/include/llvm/Transforms/IPO/Attributor.h
index 8f0f9eb..dbaf945 100644
--- a/linux-x64/clang/include/llvm/Transforms/IPO/Attributor.h
+++ b/linux-x64/clang/include/llvm/Transforms/IPO/Attributor.h
@@ -29,7 +29,7 @@
 // automatically capture a potential dependence from Q to P. This dependence
 // will cause P to be reevaluated whenever Q changes in the future.
 //
-// The Attributor will only reevaluated abstract attributes that might have
+// The Attributor will only reevaluate abstract attributes that might have
 // changed since the last iteration. That means that the Attribute will not
 // revisit all instructions/blocks/functions in the module but only query
 // an update from a subset of the abstract attributes.
@@ -60,20 +60,20 @@
 // manifest their result in the IR for passes to come.
 //
 // Attribute manifestation is not mandatory. If desired, there is support to
-// generate a single LLVM-IR attribute already in the AbstractAttribute base
-// class. In the simplest case, a subclass overloads
-// `AbstractAttribute::getManifestPosition()` and
-// `AbstractAttribute::getAttrKind()` to return the appropriate values. The
-// Attributor manifestation framework will then create and place a new attribute
-// if it is allowed to do so (based on the abstract state). Other use cases can
-// be achieved by overloading other abstract attribute methods.
+// generate a single or multiple LLVM-IR attributes already in the helper struct
+// IRAttribute. In the simplest case, a subclass inherits from IRAttribute with
+// a proper Attribute::AttrKind as template parameter. The Attributor
+// manifestation framework will then create and place a new attribute if it is
+// allowed to do so (based on the abstract state). Other use cases can be
+// achieved by overloading AbstractAttribute or IRAttribute methods.
 //
 //
 // The "mechanics" of adding a new "abstract attribute":
 // - Define a class (transitively) inheriting from AbstractAttribute and one
 //   (which could be the same) that (transitively) inherits from AbstractState.
 //   For the latter, consider the already available BooleanState and
-//   IntegerState if they fit your needs, e.g., you require only a bit-encoding.
+//   {Inc,Dec,Bit}IntegerState if they fit your needs, e.g., you require only a
+//   number tracking or bit-encoding.
 // - Implement all pure methods. Also use overloading if the attribute is not
 //   conforming with the "default" behavior: A (set of) LLVM-IR attribute(s) for
 //   an argument, call site argument, function return value, or function. See
@@ -97,19 +97,44 @@
 #ifndef LLVM_TRANSFORMS_IPO_ATTRIBUTOR_H
 #define LLVM_TRANSFORMS_IPO_ATTRIBUTOR_H
 
+#include "llvm/ADT/DenseSet.h"
+#include "llvm/ADT/GraphTraits.h"
+#include "llvm/ADT/MapVector.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/SetVector.h"
+#include "llvm/Analysis/AssumeBundleQueries.h"
+#include "llvm/Analysis/CFG.h"
+#include "llvm/Analysis/CGSCCPassManager.h"
 #include "llvm/Analysis/LazyCallGraph.h"
-#include "llvm/IR/CallSite.h"
+#include "llvm/Analysis/LoopInfo.h"
+#include "llvm/Analysis/MustExecute.h"
+#include "llvm/Analysis/PostDominators.h"
+#include "llvm/Analysis/TargetLibraryInfo.h"
+#include "llvm/IR/AbstractCallSite.h"
+#include "llvm/IR/ConstantRange.h"
 #include "llvm/IR/PassManager.h"
+#include "llvm/Support/Allocator.h"
+#include "llvm/Support/Casting.h"
+#include "llvm/Support/TimeProfiler.h"
+#include "llvm/Transforms/Utils/CallGraphUpdater.h"
 
 namespace llvm {
 
+struct AADepGraphNode;
+struct AADepGraph;
+struct Attributor;
 struct AbstractAttribute;
 struct InformationCache;
+struct AAIsDead;
 
+class AAManager;
+class AAResults;
 class Function;
 
-/// Simple enum class that forces the status to be spelled out explicitly.
-///
+/// The value passed to the line option that defines the maximal initialization
+/// chain length.
+extern unsigned MaxInitializationChainLength;
+
 ///{
 enum class ChangeStatus {
   CHANGED,
@@ -118,8 +143,843 @@
 
 ChangeStatus operator|(ChangeStatus l, ChangeStatus r);
 ChangeStatus operator&(ChangeStatus l, ChangeStatus r);
+
+enum class DepClassTy {
+  REQUIRED,
+  OPTIONAL,
+};
 ///}
 
+/// The data structure for the nodes of a dependency graph
+struct AADepGraphNode {
+public:
+  virtual ~AADepGraphNode(){};
+  using DepTy = PointerIntPair<AADepGraphNode *, 1>;
+
+protected:
+  /// Set of dependency graph nodes which should be updated if this one
+  /// is updated. The bit encodes if it is optional.
+  TinyPtrVector<DepTy> Deps;
+
+  static AADepGraphNode *DepGetVal(DepTy &DT) { return DT.getPointer(); }
+  static AbstractAttribute *DepGetValAA(DepTy &DT) {
+    return cast<AbstractAttribute>(DT.getPointer());
+  }
+
+  operator AbstractAttribute *() { return cast<AbstractAttribute>(this); }
+
+public:
+  using iterator =
+      mapped_iterator<TinyPtrVector<DepTy>::iterator, decltype(&DepGetVal)>;
+  using aaiterator =
+      mapped_iterator<TinyPtrVector<DepTy>::iterator, decltype(&DepGetValAA)>;
+
+  aaiterator begin() { return aaiterator(Deps.begin(), &DepGetValAA); }
+  aaiterator end() { return aaiterator(Deps.end(), &DepGetValAA); }
+  iterator child_begin() { return iterator(Deps.begin(), &DepGetVal); }
+  iterator child_end() { return iterator(Deps.end(), &DepGetVal); }
+
+  virtual void print(raw_ostream &OS) const { OS << "AADepNode Impl\n"; }
+  TinyPtrVector<DepTy> &getDeps() { return Deps; }
+
+  friend struct Attributor;
+  friend struct AADepGraph;
+};
+
+/// The data structure for the dependency graph
+///
+/// Note that in this graph if there is an edge from A to B (A -> B),
+/// then it means that B depends on A, and when the state of A is
+/// updated, node B should also be updated
+struct AADepGraph {
+  AADepGraph() {}
+  ~AADepGraph() {}
+
+  using DepTy = AADepGraphNode::DepTy;
+  static AADepGraphNode *DepGetVal(DepTy &DT) { return DT.getPointer(); }
+  using iterator =
+      mapped_iterator<TinyPtrVector<DepTy>::iterator, decltype(&DepGetVal)>;
+
+  /// There is no root node for the dependency graph. But the SCCIterator
+  /// requires a single entry point, so we maintain a fake("synthetic") root
+  /// node that depends on every node.
+  AADepGraphNode SyntheticRoot;
+  AADepGraphNode *GetEntryNode() { return &SyntheticRoot; }
+
+  iterator begin() { return SyntheticRoot.child_begin(); }
+  iterator end() { return SyntheticRoot.child_end(); }
+
+  void viewGraph();
+
+  /// Dump graph to file
+  void dumpGraph();
+
+  /// Print dependency graph
+  void print();
+};
+
+/// Helper to describe and deal with positions in the LLVM-IR.
+///
+/// A position in the IR is described by an anchor value and an "offset" that
+/// could be the argument number, for call sites and arguments, or an indicator
+/// of the "position kind". The kinds, specified in the Kind enum below, include
+/// the locations in the attribute list, i.a., function scope and return value,
+/// as well as a distinction between call sites and functions. Finally, there
+/// are floating values that do not have a corresponding attribute list
+/// position.
+struct IRPosition {
+
+  /// The positions we distinguish in the IR.
+  enum Kind : char {
+    IRP_INVALID,  ///< An invalid position.
+    IRP_FLOAT,    ///< A position that is not associated with a spot suitable
+                  ///< for attributes. This could be any value or instruction.
+    IRP_RETURNED, ///< An attribute for the function return value.
+    IRP_CALL_SITE_RETURNED, ///< An attribute for a call site return value.
+    IRP_FUNCTION,           ///< An attribute for a function (scope).
+    IRP_CALL_SITE,          ///< An attribute for a call site (function scope).
+    IRP_ARGUMENT,           ///< An attribute for a function argument.
+    IRP_CALL_SITE_ARGUMENT, ///< An attribute for a call site argument.
+  };
+
+  /// Default constructor available to create invalid positions implicitly. All
+  /// other positions need to be created explicitly through the appropriate
+  /// static member function.
+  IRPosition() : Enc(nullptr, ENC_VALUE) { verify(); }
+
+  /// Create a position describing the value of \p V.
+  static const IRPosition value(const Value &V) {
+    if (auto *Arg = dyn_cast<Argument>(&V))
+      return IRPosition::argument(*Arg);
+    if (auto *CB = dyn_cast<CallBase>(&V))
+      return IRPosition::callsite_returned(*CB);
+    return IRPosition(const_cast<Value &>(V), IRP_FLOAT);
+  }
+
+  /// Create a position describing the function scope of \p F.
+  static const IRPosition function(const Function &F) {
+    return IRPosition(const_cast<Function &>(F), IRP_FUNCTION);
+  }
+
+  /// Create a position describing the returned value of \p F.
+  static const IRPosition returned(const Function &F) {
+    return IRPosition(const_cast<Function &>(F), IRP_RETURNED);
+  }
+
+  /// Create a position describing the argument \p Arg.
+  static const IRPosition argument(const Argument &Arg) {
+    return IRPosition(const_cast<Argument &>(Arg), IRP_ARGUMENT);
+  }
+
+  /// Create a position describing the function scope of \p CB.
+  static const IRPosition callsite_function(const CallBase &CB) {
+    return IRPosition(const_cast<CallBase &>(CB), IRP_CALL_SITE);
+  }
+
+  /// Create a position describing the returned value of \p CB.
+  static const IRPosition callsite_returned(const CallBase &CB) {
+    return IRPosition(const_cast<CallBase &>(CB), IRP_CALL_SITE_RETURNED);
+  }
+
+  /// Create a position describing the argument of \p CB at position \p ArgNo.
+  static const IRPosition callsite_argument(const CallBase &CB,
+                                            unsigned ArgNo) {
+    return IRPosition(const_cast<Use &>(CB.getArgOperandUse(ArgNo)),
+                      IRP_CALL_SITE_ARGUMENT);
+  }
+
+  /// Create a position describing the argument of \p ACS at position \p ArgNo.
+  static const IRPosition callsite_argument(AbstractCallSite ACS,
+                                            unsigned ArgNo) {
+    if (ACS.getNumArgOperands() <= ArgNo)
+      return IRPosition();
+    int CSArgNo = ACS.getCallArgOperandNo(ArgNo);
+    if (CSArgNo >= 0)
+      return IRPosition::callsite_argument(
+          cast<CallBase>(*ACS.getInstruction()), CSArgNo);
+    return IRPosition();
+  }
+
+  /// Create a position with function scope matching the "context" of \p IRP.
+  /// If \p IRP is a call site (see isAnyCallSitePosition()) then the result
+  /// will be a call site position, otherwise the function position of the
+  /// associated function.
+  static const IRPosition function_scope(const IRPosition &IRP) {
+    if (IRP.isAnyCallSitePosition()) {
+      return IRPosition::callsite_function(
+          cast<CallBase>(IRP.getAnchorValue()));
+    }
+    assert(IRP.getAssociatedFunction());
+    return IRPosition::function(*IRP.getAssociatedFunction());
+  }
+
+  bool operator==(const IRPosition &RHS) const { return Enc == RHS.Enc; }
+  bool operator!=(const IRPosition &RHS) const { return !(*this == RHS); }
+
+  /// Return the value this abstract attribute is anchored with.
+  ///
+  /// The anchor value might not be the associated value if the latter is not
+  /// sufficient to determine where arguments will be manifested. This is, so
+  /// far, only the case for call site arguments as the value is not sufficient
+  /// to pinpoint them. Instead, we can use the call site as an anchor.
+  Value &getAnchorValue() const {
+    switch (getEncodingBits()) {
+    case ENC_VALUE:
+    case ENC_RETURNED_VALUE:
+    case ENC_FLOATING_FUNCTION:
+      return *getAsValuePtr();
+    case ENC_CALL_SITE_ARGUMENT_USE:
+      return *(getAsUsePtr()->getUser());
+    default:
+      llvm_unreachable("Unkown encoding!");
+    };
+  }
+
+  /// Return the associated function, if any.
+  Function *getAssociatedFunction() const {
+    if (auto *CB = dyn_cast<CallBase>(&getAnchorValue())) {
+      // We reuse the logic that associates callback calles to arguments of a
+      // call site here to identify the callback callee as the associated
+      // function.
+      if (Argument *Arg = getAssociatedArgument())
+        return Arg->getParent();
+      return CB->getCalledFunction();
+    }
+    return getAnchorScope();
+  }
+
+  /// Return the associated argument, if any.
+  Argument *getAssociatedArgument() const;
+
+  /// Return true if the position refers to a function interface, that is the
+  /// function scope, the function return, or an argument.
+  bool isFnInterfaceKind() const {
+    switch (getPositionKind()) {
+    case IRPosition::IRP_FUNCTION:
+    case IRPosition::IRP_RETURNED:
+    case IRPosition::IRP_ARGUMENT:
+      return true;
+    default:
+      return false;
+    }
+  }
+
+  /// Return the Function surrounding the anchor value.
+  Function *getAnchorScope() const {
+    Value &V = getAnchorValue();
+    if (isa<Function>(V))
+      return &cast<Function>(V);
+    if (isa<Argument>(V))
+      return cast<Argument>(V).getParent();
+    if (isa<Instruction>(V))
+      return cast<Instruction>(V).getFunction();
+    return nullptr;
+  }
+
+  /// Return the context instruction, if any.
+  Instruction *getCtxI() const {
+    Value &V = getAnchorValue();
+    if (auto *I = dyn_cast<Instruction>(&V))
+      return I;
+    if (auto *Arg = dyn_cast<Argument>(&V))
+      if (!Arg->getParent()->isDeclaration())
+        return &Arg->getParent()->getEntryBlock().front();
+    if (auto *F = dyn_cast<Function>(&V))
+      if (!F->isDeclaration())
+        return &(F->getEntryBlock().front());
+    return nullptr;
+  }
+
+  /// Return the value this abstract attribute is associated with.
+  Value &getAssociatedValue() const {
+    if (getCallSiteArgNo() < 0 || isa<Argument>(&getAnchorValue()))
+      return getAnchorValue();
+    assert(isa<CallBase>(&getAnchorValue()) && "Expected a call base!");
+    return *cast<CallBase>(&getAnchorValue())
+                ->getArgOperand(getCallSiteArgNo());
+  }
+
+  /// Return the type this abstract attribute is associated with.
+  Type *getAssociatedType() const {
+    if (getPositionKind() == IRPosition::IRP_RETURNED)
+      return getAssociatedFunction()->getReturnType();
+    return getAssociatedValue().getType();
+  }
+
+  /// Return the callee argument number of the associated value if it is an
+  /// argument or call site argument, otherwise a negative value. In contrast to
+  /// `getCallSiteArgNo` this method will always return the "argument number"
+  /// from the perspective of the callee. This may not the same as the call site
+  /// if this is a callback call.
+  int getCalleeArgNo() const {
+    return getArgNo(/* CallbackCalleeArgIfApplicable */ true);
+  }
+
+  /// Return the call site argument number of the associated value if it is an
+  /// argument or call site argument, otherwise a negative value. In contrast to
+  /// `getCalleArgNo` this method will always return the "operand number" from
+  /// the perspective of the call site. This may not the same as the callee
+  /// perspective if this is a callback call.
+  int getCallSiteArgNo() const {
+    return getArgNo(/* CallbackCalleeArgIfApplicable */ false);
+  }
+
+  /// Return the index in the attribute list for this position.
+  unsigned getAttrIdx() const {
+    switch (getPositionKind()) {
+    case IRPosition::IRP_INVALID:
+    case IRPosition::IRP_FLOAT:
+      break;
+    case IRPosition::IRP_FUNCTION:
+    case IRPosition::IRP_CALL_SITE:
+      return AttributeList::FunctionIndex;
+    case IRPosition::IRP_RETURNED:
+    case IRPosition::IRP_CALL_SITE_RETURNED:
+      return AttributeList::ReturnIndex;
+    case IRPosition::IRP_ARGUMENT:
+    case IRPosition::IRP_CALL_SITE_ARGUMENT:
+      return getCallSiteArgNo() + AttributeList::FirstArgIndex;
+    }
+    llvm_unreachable(
+        "There is no attribute index for a floating or invalid position!");
+  }
+
+  /// Return the associated position kind.
+  Kind getPositionKind() const {
+    char EncodingBits = getEncodingBits();
+    if (EncodingBits == ENC_CALL_SITE_ARGUMENT_USE)
+      return IRP_CALL_SITE_ARGUMENT;
+    if (EncodingBits == ENC_FLOATING_FUNCTION)
+      return IRP_FLOAT;
+
+    Value *V = getAsValuePtr();
+    if (!V)
+      return IRP_INVALID;
+    if (isa<Argument>(V))
+      return IRP_ARGUMENT;
+    if (isa<Function>(V))
+      return isReturnPosition(EncodingBits) ? IRP_RETURNED : IRP_FUNCTION;
+    if (isa<CallBase>(V))
+      return isReturnPosition(EncodingBits) ? IRP_CALL_SITE_RETURNED
+                                            : IRP_CALL_SITE;
+    return IRP_FLOAT;
+  }
+
+  /// TODO: Figure out if the attribute related helper functions should live
+  ///       here or somewhere else.
+
+  /// Return true if any kind in \p AKs existing in the IR at a position that
+  /// will affect this one. See also getAttrs(...).
+  /// \param IgnoreSubsumingPositions Flag to determine if subsuming positions,
+  ///                                 e.g., the function position if this is an
+  ///                                 argument position, should be ignored.
+  bool hasAttr(ArrayRef<Attribute::AttrKind> AKs,
+               bool IgnoreSubsumingPositions = false,
+               Attributor *A = nullptr) const;
+
+  /// Return the attributes of any kind in \p AKs existing in the IR at a
+  /// position that will affect this one. While each position can only have a
+  /// single attribute of any kind in \p AKs, there are "subsuming" positions
+  /// that could have an attribute as well. This method returns all attributes
+  /// found in \p Attrs.
+  /// \param IgnoreSubsumingPositions Flag to determine if subsuming positions,
+  ///                                 e.g., the function position if this is an
+  ///                                 argument position, should be ignored.
+  void getAttrs(ArrayRef<Attribute::AttrKind> AKs,
+                SmallVectorImpl<Attribute> &Attrs,
+                bool IgnoreSubsumingPositions = false,
+                Attributor *A = nullptr) const;
+
+  /// Remove the attribute of kind \p AKs existing in the IR at this position.
+  void removeAttrs(ArrayRef<Attribute::AttrKind> AKs) const {
+    if (getPositionKind() == IRP_INVALID || getPositionKind() == IRP_FLOAT)
+      return;
+
+    AttributeList AttrList;
+    auto *CB = dyn_cast<CallBase>(&getAnchorValue());
+    if (CB)
+      AttrList = CB->getAttributes();
+    else
+      AttrList = getAssociatedFunction()->getAttributes();
+
+    LLVMContext &Ctx = getAnchorValue().getContext();
+    for (Attribute::AttrKind AK : AKs)
+      AttrList = AttrList.removeAttribute(Ctx, getAttrIdx(), AK);
+
+    if (CB)
+      CB->setAttributes(AttrList);
+    else
+      getAssociatedFunction()->setAttributes(AttrList);
+  }
+
+  bool isAnyCallSitePosition() const {
+    switch (getPositionKind()) {
+    case IRPosition::IRP_CALL_SITE:
+    case IRPosition::IRP_CALL_SITE_RETURNED:
+    case IRPosition::IRP_CALL_SITE_ARGUMENT:
+      return true;
+    default:
+      return false;
+    }
+  }
+
+  /// Return true if the position is an argument or call site argument.
+  bool isArgumentPosition() const {
+    switch (getPositionKind()) {
+    case IRPosition::IRP_ARGUMENT:
+    case IRPosition::IRP_CALL_SITE_ARGUMENT:
+      return true;
+    default:
+      return false;
+    }
+  }
+
+  /// Special DenseMap key values.
+  ///
+  ///{
+  static const IRPosition EmptyKey;
+  static const IRPosition TombstoneKey;
+  ///}
+
+  /// Conversion into a void * to allow reuse of pointer hashing.
+  operator void *() const { return Enc.getOpaqueValue(); }
+
+private:
+  /// Private constructor for special values only!
+  explicit IRPosition(void *Ptr) { Enc.setFromOpaqueValue(Ptr); }
+
+  /// IRPosition anchored at \p AnchorVal with kind/argument numbet \p PK.
+  explicit IRPosition(Value &AnchorVal, Kind PK) {
+    switch (PK) {
+    case IRPosition::IRP_INVALID:
+      llvm_unreachable("Cannot create invalid IRP with an anchor value!");
+      break;
+    case IRPosition::IRP_FLOAT:
+      // Special case for floating functions.
+      if (isa<Function>(AnchorVal))
+        Enc = {&AnchorVal, ENC_FLOATING_FUNCTION};
+      else
+        Enc = {&AnchorVal, ENC_VALUE};
+      break;
+    case IRPosition::IRP_FUNCTION:
+    case IRPosition::IRP_CALL_SITE:
+      Enc = {&AnchorVal, ENC_VALUE};
+      break;
+    case IRPosition::IRP_RETURNED:
+    case IRPosition::IRP_CALL_SITE_RETURNED:
+      Enc = {&AnchorVal, ENC_RETURNED_VALUE};
+      break;
+    case IRPosition::IRP_ARGUMENT:
+      Enc = {&AnchorVal, ENC_VALUE};
+      break;
+    case IRPosition::IRP_CALL_SITE_ARGUMENT:
+      llvm_unreachable(
+          "Cannot create call site argument IRP with an anchor value!");
+      break;
+    }
+    verify();
+  }
+
+  /// Return the callee argument number of the associated value if it is an
+  /// argument or call site argument. See also `getCalleeArgNo` and
+  /// `getCallSiteArgNo`.
+  int getArgNo(bool CallbackCalleeArgIfApplicable) const {
+    if (CallbackCalleeArgIfApplicable)
+      if (Argument *Arg = getAssociatedArgument())
+        return Arg->getArgNo();
+    switch (getPositionKind()) {
+    case IRPosition::IRP_ARGUMENT:
+      return cast<Argument>(getAsValuePtr())->getArgNo();
+    case IRPosition::IRP_CALL_SITE_ARGUMENT: {
+      Use &U = *getAsUsePtr();
+      return cast<CallBase>(U.getUser())->getArgOperandNo(&U);
+    }
+    default:
+      return -1;
+    }
+  }
+
+  /// IRPosition for the use \p U. The position kind \p PK needs to be
+  /// IRP_CALL_SITE_ARGUMENT, the anchor value is the user, the associated value
+  /// the used value.
+  explicit IRPosition(Use &U, Kind PK) {
+    assert(PK == IRP_CALL_SITE_ARGUMENT &&
+           "Use constructor is for call site arguments only!");
+    Enc = {&U, ENC_CALL_SITE_ARGUMENT_USE};
+    verify();
+  }
+
+  /// Verify internal invariants.
+  void verify();
+
+  /// Return the attributes of kind \p AK existing in the IR as attribute.
+  bool getAttrsFromIRAttr(Attribute::AttrKind AK,
+                          SmallVectorImpl<Attribute> &Attrs) const;
+
+  /// Return the attributes of kind \p AK existing in the IR as operand bundles
+  /// of an llvm.assume.
+  bool getAttrsFromAssumes(Attribute::AttrKind AK,
+                           SmallVectorImpl<Attribute> &Attrs,
+                           Attributor &A) const;
+
+  /// Return the underlying pointer as Value *, valid for all positions but
+  /// IRP_CALL_SITE_ARGUMENT.
+  Value *getAsValuePtr() const {
+    assert(getEncodingBits() != ENC_CALL_SITE_ARGUMENT_USE &&
+           "Not a value pointer!");
+    return reinterpret_cast<Value *>(Enc.getPointer());
+  }
+
+  /// Return the underlying pointer as Use *, valid only for
+  /// IRP_CALL_SITE_ARGUMENT positions.
+  Use *getAsUsePtr() const {
+    assert(getEncodingBits() == ENC_CALL_SITE_ARGUMENT_USE &&
+           "Not a value pointer!");
+    return reinterpret_cast<Use *>(Enc.getPointer());
+  }
+
+  /// Return true if \p EncodingBits describe a returned or call site returned
+  /// position.
+  static bool isReturnPosition(char EncodingBits) {
+    return EncodingBits == ENC_RETURNED_VALUE;
+  }
+
+  /// Return true if the encoding bits describe a returned or call site returned
+  /// position.
+  bool isReturnPosition() const { return isReturnPosition(getEncodingBits()); }
+
+  /// The encoding of the IRPosition is a combination of a pointer and two
+  /// encoding bits. The values of the encoding bits are defined in the enum
+  /// below. The pointer is either a Value* (for the first three encoding bit
+  /// combinations) or Use* (for ENC_CALL_SITE_ARGUMENT_USE).
+  ///
+  ///{
+  enum {
+    ENC_VALUE = 0b00,
+    ENC_RETURNED_VALUE = 0b01,
+    ENC_FLOATING_FUNCTION = 0b10,
+    ENC_CALL_SITE_ARGUMENT_USE = 0b11,
+  };
+
+  // Reserve the maximal amount of bits so there is no need to mask out the
+  // remaining ones. We will not encode anything else in the pointer anyway.
+  static constexpr int NumEncodingBits =
+      PointerLikeTypeTraits<void *>::NumLowBitsAvailable;
+  static_assert(NumEncodingBits >= 2, "At least two bits are required!");
+
+  /// The pointer with the encoding bits.
+  PointerIntPair<void *, NumEncodingBits, char> Enc;
+  ///}
+
+  /// Return the encoding bits.
+  char getEncodingBits() const { return Enc.getInt(); }
+};
+
+/// Helper that allows IRPosition as a key in a DenseMap.
+template <> struct DenseMapInfo<IRPosition> : DenseMapInfo<void *> {
+  static inline IRPosition getEmptyKey() { return IRPosition::EmptyKey; }
+  static inline IRPosition getTombstoneKey() {
+    return IRPosition::TombstoneKey;
+  }
+};
+
+/// A visitor class for IR positions.
+///
+/// Given a position P, the SubsumingPositionIterator allows to visit "subsuming
+/// positions" wrt. attributes/information. Thus, if a piece of information
+/// holds for a subsuming position, it also holds for the position P.
+///
+/// The subsuming positions always include the initial position and then,
+/// depending on the position kind, additionally the following ones:
+/// - for IRP_RETURNED:
+///   - the function (IRP_FUNCTION)
+/// - for IRP_ARGUMENT:
+///   - the function (IRP_FUNCTION)
+/// - for IRP_CALL_SITE:
+///   - the callee (IRP_FUNCTION), if known
+/// - for IRP_CALL_SITE_RETURNED:
+///   - the callee (IRP_RETURNED), if known
+///   - the call site (IRP_FUNCTION)
+///   - the callee (IRP_FUNCTION), if known
+/// - for IRP_CALL_SITE_ARGUMENT:
+///   - the argument of the callee (IRP_ARGUMENT), if known
+///   - the callee (IRP_FUNCTION), if known
+///   - the position the call site argument is associated with if it is not
+///     anchored to the call site, e.g., if it is an argument then the argument
+///     (IRP_ARGUMENT)
+class SubsumingPositionIterator {
+  SmallVector<IRPosition, 4> IRPositions;
+  using iterator = decltype(IRPositions)::iterator;
+
+public:
+  SubsumingPositionIterator(const IRPosition &IRP);
+  iterator begin() { return IRPositions.begin(); }
+  iterator end() { return IRPositions.end(); }
+};
+
+/// Wrapper for FunctoinAnalysisManager.
+struct AnalysisGetter {
+  template <typename Analysis>
+  typename Analysis::Result *getAnalysis(const Function &F) {
+    if (!FAM || !F.getParent())
+      return nullptr;
+    return &FAM->getResult<Analysis>(const_cast<Function &>(F));
+  }
+
+  AnalysisGetter(FunctionAnalysisManager &FAM) : FAM(&FAM) {}
+  AnalysisGetter() {}
+
+private:
+  FunctionAnalysisManager *FAM = nullptr;
+};
+
+/// Data structure to hold cached (LLVM-IR) information.
+///
+/// All attributes are given an InformationCache object at creation time to
+/// avoid inspection of the IR by all of them individually. This default
+/// InformationCache will hold information required by 'default' attributes,
+/// thus the ones deduced when Attributor::identifyDefaultAbstractAttributes(..)
+/// is called.
+///
+/// If custom abstract attributes, registered manually through
+/// Attributor::registerAA(...), need more information, especially if it is not
+/// reusable, it is advised to inherit from the InformationCache and cast the
+/// instance down in the abstract attributes.
+struct InformationCache {
+  InformationCache(const Module &M, AnalysisGetter &AG,
+                   BumpPtrAllocator &Allocator, SetVector<Function *> *CGSCC)
+      : DL(M.getDataLayout()), Allocator(Allocator),
+        Explorer(
+            /* ExploreInterBlock */ true, /* ExploreCFGForward */ true,
+            /* ExploreCFGBackward */ true,
+            /* LIGetter */
+            [&](const Function &F) { return AG.getAnalysis<LoopAnalysis>(F); },
+            /* DTGetter */
+            [&](const Function &F) {
+              return AG.getAnalysis<DominatorTreeAnalysis>(F);
+            },
+            /* PDTGetter */
+            [&](const Function &F) {
+              return AG.getAnalysis<PostDominatorTreeAnalysis>(F);
+            }),
+        AG(AG), CGSCC(CGSCC) {
+    if (CGSCC)
+      initializeModuleSlice(*CGSCC);
+  }
+
+  ~InformationCache() {
+    // The FunctionInfo objects are allocated via a BumpPtrAllocator, we call
+    // the destructor manually.
+    for (auto &It : FuncInfoMap)
+      It.getSecond()->~FunctionInfo();
+  }
+
+  /// Apply \p CB to all uses of \p F. If \p LookThroughConstantExprUses is
+  /// true, constant expression users are not given to \p CB but their uses are
+  /// traversed transitively.
+  template <typename CBTy>
+  static void foreachUse(Function &F, CBTy CB,
+                         bool LookThroughConstantExprUses = true) {
+    SmallVector<Use *, 8> Worklist(make_pointer_range(F.uses()));
+
+    for (unsigned Idx = 0; Idx < Worklist.size(); ++Idx) {
+      Use &U = *Worklist[Idx];
+
+      // Allow use in constant bitcasts and simply look through them.
+      if (LookThroughConstantExprUses && isa<ConstantExpr>(U.getUser())) {
+        for (Use &CEU : cast<ConstantExpr>(U.getUser())->uses())
+          Worklist.push_back(&CEU);
+        continue;
+      }
+
+      CB(U);
+    }
+  }
+
+  /// Initialize the ModuleSlice member based on \p SCC. ModuleSlices contains
+  /// (a subset of) all functions that we can look at during this SCC traversal.
+  /// This includes functions (transitively) called from the SCC and the
+  /// (transitive) callers of SCC functions. We also can look at a function if
+  /// there is a "reference edge", i.a., if the function somehow uses (!=calls)
+  /// a function in the SCC or a caller of a function in the SCC.
+  void initializeModuleSlice(SetVector<Function *> &SCC) {
+    ModuleSlice.insert(SCC.begin(), SCC.end());
+
+    SmallPtrSet<Function *, 16> Seen;
+    SmallVector<Function *, 16> Worklist(SCC.begin(), SCC.end());
+    while (!Worklist.empty()) {
+      Function *F = Worklist.pop_back_val();
+      ModuleSlice.insert(F);
+
+      for (Instruction &I : instructions(*F))
+        if (auto *CB = dyn_cast<CallBase>(&I))
+          if (Function *Callee = CB->getCalledFunction())
+            if (Seen.insert(Callee).second)
+              Worklist.push_back(Callee);
+    }
+
+    Seen.clear();
+    Worklist.append(SCC.begin(), SCC.end());
+    while (!Worklist.empty()) {
+      Function *F = Worklist.pop_back_val();
+      ModuleSlice.insert(F);
+
+      // Traverse all transitive uses.
+      foreachUse(*F, [&](Use &U) {
+        if (auto *UsrI = dyn_cast<Instruction>(U.getUser()))
+          if (Seen.insert(UsrI->getFunction()).second)
+            Worklist.push_back(UsrI->getFunction());
+      });
+    }
+  }
+
+  /// The slice of the module we are allowed to look at.
+  SmallPtrSet<Function *, 8> ModuleSlice;
+
+  /// A vector type to hold instructions.
+  using InstructionVectorTy = SmallVector<Instruction *, 8>;
+
+  /// A map type from opcodes to instructions with this opcode.
+  using OpcodeInstMapTy = DenseMap<unsigned, InstructionVectorTy *>;
+
+  /// Return the map that relates "interesting" opcodes with all instructions
+  /// with that opcode in \p F.
+  OpcodeInstMapTy &getOpcodeInstMapForFunction(const Function &F) {
+    return getFunctionInfo(F).OpcodeInstMap;
+  }
+
+  /// Return the instructions in \p F that may read or write memory.
+  InstructionVectorTy &getReadOrWriteInstsForFunction(const Function &F) {
+    return getFunctionInfo(F).RWInsts;
+  }
+
+  /// Return MustBeExecutedContextExplorer
+  MustBeExecutedContextExplorer &getMustBeExecutedContextExplorer() {
+    return Explorer;
+  }
+
+  /// Return TargetLibraryInfo for function \p F.
+  TargetLibraryInfo *getTargetLibraryInfoForFunction(const Function &F) {
+    return AG.getAnalysis<TargetLibraryAnalysis>(F);
+  }
+
+  /// Return AliasAnalysis Result for function \p F.
+  AAResults *getAAResultsForFunction(const Function &F);
+
+  /// Return true if \p Arg is involved in a must-tail call, thus the argument
+  /// of the caller or callee.
+  bool isInvolvedInMustTailCall(const Argument &Arg) {
+    FunctionInfo &FI = getFunctionInfo(*Arg.getParent());
+    return FI.CalledViaMustTail || FI.ContainsMustTailCall;
+  }
+
+  /// Return the analysis result from a pass \p AP for function \p F.
+  template <typename AP>
+  typename AP::Result *getAnalysisResultForFunction(const Function &F) {
+    return AG.getAnalysis<AP>(F);
+  }
+
+  /// Return SCC size on call graph for function \p F or 0 if unknown.
+  unsigned getSccSize(const Function &F) {
+    if (CGSCC && CGSCC->count(const_cast<Function *>(&F)))
+      return CGSCC->size();
+    return 0;
+  }
+
+  /// Return datalayout used in the module.
+  const DataLayout &getDL() { return DL; }
+
+  /// Return the map conaining all the knowledge we have from `llvm.assume`s.
+  const RetainedKnowledgeMap &getKnowledgeMap() const { return KnowledgeMap; }
+
+  /// Return if \p To is potentially reachable form \p From or not
+  /// If the same query was answered, return cached result
+  bool getPotentiallyReachable(const Instruction &From, const Instruction &To) {
+    auto KeyPair = std::make_pair(&From, &To);
+    auto Iter = PotentiallyReachableMap.find(KeyPair);
+    if (Iter != PotentiallyReachableMap.end())
+      return Iter->second;
+    const Function &F = *From.getFunction();
+    bool Result = isPotentiallyReachable(
+        &From, &To, nullptr, AG.getAnalysis<DominatorTreeAnalysis>(F),
+        AG.getAnalysis<LoopAnalysis>(F));
+    PotentiallyReachableMap.insert(std::make_pair(KeyPair, Result));
+    return Result;
+  }
+
+  /// Check whether \p F is part of module slice.
+  bool isInModuleSlice(const Function &F) {
+    return ModuleSlice.count(const_cast<Function *>(&F));
+  }
+
+private:
+  struct FunctionInfo {
+    ~FunctionInfo();
+
+    /// A nested map that remembers all instructions in a function with a
+    /// certain instruction opcode (Instruction::getOpcode()).
+    OpcodeInstMapTy OpcodeInstMap;
+
+    /// A map from functions to their instructions that may read or write
+    /// memory.
+    InstructionVectorTy RWInsts;
+
+    /// Function is called by a `musttail` call.
+    bool CalledViaMustTail;
+
+    /// Function contains a `musttail` call.
+    bool ContainsMustTailCall;
+  };
+
+  /// A map type from functions to informatio about it.
+  DenseMap<const Function *, FunctionInfo *> FuncInfoMap;
+
+  /// Return information about the function \p F, potentially by creating it.
+  FunctionInfo &getFunctionInfo(const Function &F) {
+    FunctionInfo *&FI = FuncInfoMap[&F];
+    if (!FI) {
+      FI = new (Allocator) FunctionInfo();
+      initializeInformationCache(F, *FI);
+    }
+    return *FI;
+  }
+
+  /// Initialize the function information cache \p FI for the function \p F.
+  ///
+  /// This method needs to be called for all function that might be looked at
+  /// through the information cache interface *prior* to looking at them.
+  void initializeInformationCache(const Function &F, FunctionInfo &FI);
+
+  /// The datalayout used in the module.
+  const DataLayout &DL;
+
+  /// The allocator used to allocate memory, e.g. for `FunctionInfo`s.
+  BumpPtrAllocator &Allocator;
+
+  /// MustBeExecutedContextExplorer
+  MustBeExecutedContextExplorer Explorer;
+
+  /// A map with knowledge retained in `llvm.assume` instructions.
+  RetainedKnowledgeMap KnowledgeMap;
+
+  /// Getters for analysis.
+  AnalysisGetter &AG;
+
+  /// The underlying CGSCC, or null if not available.
+  SetVector<Function *> *CGSCC;
+
+  /// Set of inlineable functions
+  SmallPtrSet<const Function *, 8> InlineableFunctions;
+
+  /// A map for caching results of queries for isPotentiallyReachable
+  DenseMap<std::pair<const Instruction *, const Instruction *>, bool>
+      PotentiallyReachableMap;
+
+  /// Give the Attributor access to the members so
+  /// Attributor::identifyDefaultAbstractAttributes(...) can initialize them.
+  friend struct Attributor;
+};
+
 /// The fixpoint analysis framework that orchestrates the attribute deduction.
 ///
 /// The Attributor provides a general abstract analysis framework (guided
@@ -148,7 +1008,20 @@
 /// NOTE: The mechanics of adding a new "concrete" abstract attribute are
 ///       described in the file comment.
 struct Attributor {
-  ~Attributor() { DeleteContainerPointers(AllAbstractAttributes); }
+  /// Constructor
+  ///
+  /// \param Functions The set of functions we are deriving attributes for.
+  /// \param InfoCache Cache to hold various information accessible for
+  ///                  the abstract attributes.
+  /// \param CGUpdater Helper to update an underlying call graph.
+  /// \param Allowed If not null, a set limiting the attribute opportunities.
+  Attributor(SetVector<Function *> &Functions, InformationCache &InfoCache,
+             CallGraphUpdater &CGUpdater,
+             DenseSet<const char *> *Allowed = nullptr)
+      : Allocator(InfoCache.Allocator), Functions(Functions),
+        InfoCache(InfoCache), CGUpdater(CGUpdater), Allowed(Allowed) {}
+
+  ~Attributor();
 
   /// Run the analyses until a fixpoint is reached or enforced (timeout).
   ///
@@ -158,10 +1031,11 @@
   /// \Returns CHANGED if the IR was changed, otherwise UNCHANGED.
   ChangeStatus run();
 
-  /// Lookup an abstract attribute of type \p AAType anchored at value \p V and
-  /// argument number \p ArgNo. If no attribute is found and \p V is a call base
-  /// instruction, the called function is tried as a value next. Thus, the
-  /// returned abstract attribute might be anchored at the callee of \p V.
+  /// Lookup an abstract attribute of type \p AAType at position \p IRP. While
+  /// no abstract attribute is found equivalent positions are checked, see
+  /// SubsumingPositionIterator. Thus, the returned abstract attribute
+  /// might be anchored at a different position, e.g., the callee if \p IRP is a
+  /// call base.
   ///
   /// This method is the only (supported) way an abstract attribute can retrieve
   /// information from another abstract attribute. As an example, take an
@@ -170,160 +1044,652 @@
   /// most optimistic information for other abstract attributes in-flight, e.g.
   /// the one reasoning about the "captured" state for the argument or the one
   /// reasoning on the memory access behavior of the function as a whole.
+  ///
+  /// If the flag \p TrackDependence is set to false the dependence from
+  /// \p QueryingAA to the return abstract attribute is not automatically
+  /// recorded. This should only be used if the caller will record the
+  /// dependence explicitly if necessary, thus if it the returned abstract
+  /// attribute is used for reasoning. To record the dependences explicitly use
+  /// the `Attributor::recordDependence` method.
   template <typename AAType>
-  const AAType *getAAFor(AbstractAttribute &QueryingAA, const Value &V,
-                         int ArgNo = -1) {
-    static_assert(std::is_base_of<AbstractAttribute, AAType>::value,
-                  "Cannot query an attribute with a type not derived from "
-                  "'AbstractAttribute'!");
-    assert(AAType::ID != Attribute::None &&
-           "Cannot lookup generic abstract attributes!");
+  const AAType &getAAFor(const AbstractAttribute &QueryingAA,
+                         const IRPosition &IRP, bool TrackDependence = true,
+                         DepClassTy DepClass = DepClassTy::REQUIRED) {
+    return getOrCreateAAFor<AAType>(IRP, &QueryingAA, TrackDependence, DepClass,
+                                    /* ForceUpdate */ false);
+  }
 
-    // Determine the argument number automatically for llvm::Arguments.
-    if (auto *Arg = dyn_cast<Argument>(&V))
-      ArgNo = Arg->getArgNo();
+  /// Similar to getAAFor but the return abstract attribute will be updated (via
+  /// `AbstractAttribute::update`) even if it is found in the cache. This is
+  /// especially useful for AAIsDead as changes in liveness can make updates
+  /// possible/useful that were not happening before as the abstract attribute
+  /// was assumed dead.
+  template <typename AAType>
+  const AAType &getAndUpdateAAFor(const AbstractAttribute &QueryingAA,
+                                  const IRPosition &IRP,
+                                  bool TrackDependence = true,
+                                  DepClassTy DepClass = DepClassTy::REQUIRED) {
+    return getOrCreateAAFor<AAType>(IRP, &QueryingAA, TrackDependence, DepClass,
+                                    /* ForceUpdate */ true);
+  }
 
-    // If a function was given together with an argument number, perform the
-    // lookup for the actual argument instead. Don't do it for variadic
-    // arguments.
-    if (ArgNo >= 0 && isa<Function>(&V) &&
-        cast<Function>(&V)->arg_size() > (size_t)ArgNo)
-      return getAAFor<AAType>(
-          QueryingAA, *(cast<Function>(&V)->arg_begin() + ArgNo), ArgNo);
+  /// The version of getAAFor that allows to omit a querying abstract
+  /// attribute. Using this after Attributor started running is restricted to
+  /// only the Attributor itself. Initial seeding of AAs can be done via this
+  /// function.
+  /// NOTE: ForceUpdate is ignored in any stage other than the update stage.
+  template <typename AAType>
+  const AAType &getOrCreateAAFor(const IRPosition &IRP,
+                                 const AbstractAttribute *QueryingAA = nullptr,
+                                 bool TrackDependence = false,
+                                 DepClassTy DepClass = DepClassTy::OPTIONAL,
+                                 bool ForceUpdate = false) {
+    if (AAType *AAPtr = lookupAAFor<AAType>(IRP, QueryingAA, TrackDependence)) {
+      if (ForceUpdate && Phase == AttributorPhase::UPDATE)
+        updateAA(*AAPtr);
+      return *AAPtr;
+    }
 
-    // Lookup the abstract attribute of type AAType. If found, return it after
-    // registering a dependence of QueryingAA on the one returned attribute.
-    const auto &KindToAbstractAttributeMap = AAMap.lookup({&V, ArgNo});
-    if (AAType *AA = static_cast<AAType *>(
-            KindToAbstractAttributeMap.lookup(AAType::ID))) {
-      QueryMap[AA].insert(&QueryingAA);
+    // No matching attribute found, create one.
+    // Use the static create method.
+    auto &AA = AAType::createForPosition(IRP, *this);
+
+    // If we are currenty seeding attributes, enforce seeding rules.
+    if (Phase == AttributorPhase::SEEDING && !shouldSeedAttribute(AA)) {
+      AA.getState().indicatePessimisticFixpoint();
       return AA;
     }
 
-    // If no abstract attribute was found and we look for a call site argument,
-    // defer to the actual argument instead.
-    ImmutableCallSite ICS(&V);
-    if (ICS && ICS.getCalledValue())
-      return getAAFor<AAType>(QueryingAA, *ICS.getCalledValue(), ArgNo);
+    registerAA(AA);
 
-    // No matching attribute found
-    return nullptr;
+    // For now we ignore naked and optnone functions.
+    bool Invalidate = Allowed && !Allowed->count(&AAType::ID);
+    const Function *FnScope = IRP.getAnchorScope();
+    if (FnScope)
+      Invalidate |= FnScope->hasFnAttribute(Attribute::Naked) ||
+                    FnScope->hasFnAttribute(Attribute::OptimizeNone);
+
+    // Avoid too many nested initializations to prevent a stack overflow.
+    Invalidate |= InitializationChainLength > MaxInitializationChainLength;
+
+    // Bootstrap the new attribute with an initial update to propagate
+    // information, e.g., function -> call site. If it is not on a given
+    // Allowed we will not perform updates at all.
+    if (Invalidate) {
+      AA.getState().indicatePessimisticFixpoint();
+      return AA;
+    }
+
+    {
+      TimeTraceScope TimeScope(AA.getName() + "::initialize");
+      ++InitializationChainLength;
+      AA.initialize(*this);
+      --InitializationChainLength;
+    }
+
+    // Initialize and update is allowed for code outside of the current function
+    // set, but only if it is part of module slice we are allowed to look at.
+    // Only exception is AAIsDeadFunction whose initialization is prevented
+    // directly, since we don't to compute it twice.
+    if (FnScope && !Functions.count(const_cast<Function *>(FnScope))) {
+      if (!getInfoCache().isInModuleSlice(*FnScope)) {
+        AA.getState().indicatePessimisticFixpoint();
+        return AA;
+      }
+    }
+
+    // If this is queried in the manifest stage, we force the AA to indicate
+    // pessimistic fixpoint immediately.
+    if (Phase == AttributorPhase::MANIFEST) {
+      AA.getState().indicatePessimisticFixpoint();
+      return AA;
+    }
+
+    // Allow seeded attributes to declare dependencies.
+    // Remember the seeding state.
+    AttributorPhase OldPhase = Phase;
+    Phase = AttributorPhase::UPDATE;
+
+    updateAA(AA);
+
+    Phase = OldPhase;
+
+    if (TrackDependence && AA.getState().isValidState())
+      recordDependence(AA, const_cast<AbstractAttribute &>(*QueryingAA),
+                       DepClass);
+    return AA;
   }
 
+  /// Return the attribute of \p AAType for \p IRP if existing. This also allows
+  /// non-AA users lookup.
+  template <typename AAType>
+  AAType *lookupAAFor(const IRPosition &IRP,
+                      const AbstractAttribute *QueryingAA = nullptr,
+                      bool TrackDependence = false,
+                      DepClassTy DepClass = DepClassTy::OPTIONAL) {
+    static_assert(std::is_base_of<AbstractAttribute, AAType>::value,
+                  "Cannot query an attribute with a type not derived from "
+                  "'AbstractAttribute'!");
+    assert((QueryingAA || !TrackDependence) &&
+           "Cannot track dependences without a QueryingAA!");
+
+    // Lookup the abstract attribute of type AAType. If found, return it after
+    // registering a dependence of QueryingAA on the one returned attribute.
+    AbstractAttribute *AAPtr = AAMap.lookup({&AAType::ID, IRP});
+    if (!AAPtr)
+      return nullptr;
+
+    AAType *AA = static_cast<AAType *>(AAPtr);
+
+    // Do not register a dependence on an attribute with an invalid state.
+    if (TrackDependence && AA->getState().isValidState())
+      recordDependence(*AA, const_cast<AbstractAttribute &>(*QueryingAA),
+                       DepClass);
+    return AA;
+  }
+
+  /// Explicitly record a dependence from \p FromAA to \p ToAA, that is if
+  /// \p FromAA changes \p ToAA should be updated as well.
+  ///
+  /// This method should be used in conjunction with the `getAAFor` method and
+  /// with the TrackDependence flag passed to the method set to false. This can
+  /// be beneficial to avoid false dependences but it requires the users of
+  /// `getAAFor` to explicitly record true dependences through this method.
+  /// The \p DepClass flag indicates if the dependence is striclty necessary.
+  /// That means for required dependences, if \p FromAA changes to an invalid
+  /// state, \p ToAA can be moved to a pessimistic fixpoint because it required
+  /// information from \p FromAA but none are available anymore.
+  void recordDependence(const AbstractAttribute &FromAA,
+                        const AbstractAttribute &ToAA, DepClassTy DepClass);
+
   /// Introduce a new abstract attribute into the fixpoint analysis.
   ///
   /// Note that ownership of the attribute is given to the Attributor. It will
   /// invoke delete for the Attributor on destruction of the Attributor.
   ///
-  /// Attributes are identified by
-  ///  (1) their anchored value (see AA.getAnchoredValue()),
-  ///  (2) their argument number (\p ArgNo, or Argument::getArgNo()), and
-  ///  (3) their default attribute kind (see AAType::ID).
-  template <typename AAType> AAType &registerAA(AAType &AA, int ArgNo = -1) {
+  /// Attributes are identified by their IR position (AAType::getIRPosition())
+  /// and the address of their static member (see AAType::ID).
+  template <typename AAType> AAType &registerAA(AAType &AA) {
     static_assert(std::is_base_of<AbstractAttribute, AAType>::value,
                   "Cannot register an attribute with a type not derived from "
                   "'AbstractAttribute'!");
-
-    // Determine the anchor value and the argument number which are used to
-    // lookup the attribute together with AAType::ID.
-    Value &AnchoredVal = AA.getAnchoredValue();
-    if (auto *Arg = dyn_cast<Argument>(&AnchoredVal))
-      ArgNo = Arg->getArgNo();
-
     // Put the attribute in the lookup map structure and the container we use to
     // keep track of all attributes.
-    AAMap[{&AnchoredVal, ArgNo}][AAType::ID] = &AA;
-    AllAbstractAttributes.push_back(&AA);
+    const IRPosition &IRP = AA.getIRPosition();
+    AbstractAttribute *&AAPtr = AAMap[{&AAType::ID, IRP}];
+
+    assert(!AAPtr && "Attribute already in map!");
+    AAPtr = &AA;
+
+    // Register AA with the synthetic root only before the manifest stage.
+    if (Phase == AttributorPhase::SEEDING || Phase == AttributorPhase::UPDATE)
+      DG.SyntheticRoot.Deps.push_back(
+          AADepGraphNode::DepTy(&AA, unsigned(DepClassTy::REQUIRED)));
+
     return AA;
   }
 
+  /// Return the internal information cache.
+  InformationCache &getInfoCache() { return InfoCache; }
+
+  /// Return true if this is a module pass, false otherwise.
+  bool isModulePass() const {
+    return !Functions.empty() &&
+           Functions.size() == Functions.front()->getParent()->size();
+  }
+
+  /// Return true if we derive attributes for \p Fn
+  bool isRunOn(Function &Fn) const {
+    return Functions.empty() || Functions.count(&Fn);
+  }
+
   /// Determine opportunities to derive 'default' attributes in \p F and create
   /// abstract attribute objects for them.
   ///
   /// \param F The function that is checked for attribute opportunities.
-  /// \param InfoCache A cache for information queryable by the new attributes.
-  /// \param Whitelist If not null, a set limiting the attribute opportunities.
   ///
   /// Note that abstract attribute instances are generally created even if the
   /// IR already contains the information they would deduce. The most important
   /// reason for this is the single interface, the one of the abstract attribute
   /// instance, which can be queried without the need to look at the IR in
   /// various places.
-  void identifyDefaultAbstractAttributes(
-      Function &F, InformationCache &InfoCache,
-      DenseSet</* Attribute::AttrKind */ unsigned> *Whitelist = nullptr);
+  void identifyDefaultAbstractAttributes(Function &F);
 
-private:
-  /// The set of all abstract attributes.
-  ///{
-  using AAVector = SmallVector<AbstractAttribute *, 64>;
-  AAVector AllAbstractAttributes;
-  ///}
-
-  /// A nested map to lookup abstract attributes based on the anchored value and
-  /// an argument positions (or -1) on the outer level, and attribute kinds
-  /// (Attribute::AttrKind) on the inner level.
-  ///{
-  using KindToAbstractAttributeMap = DenseMap<unsigned, AbstractAttribute *>;
-  DenseMap<std::pair<const Value *, int>, KindToAbstractAttributeMap> AAMap;
-  ///}
-
-  /// A map from abstract attributes to the ones that queried them through calls
-  /// to the getAAFor<...>(...) method.
-  ///{
-  using QueryMapTy =
-      DenseMap<AbstractAttribute *, SetVector<AbstractAttribute *>>;
-  QueryMapTy QueryMap;
-  ///}
-};
-
-/// Data structure to hold cached (LLVM-IR) information.
-///
-/// All attributes are given an InformationCache object at creation time to
-/// avoid inspection of the IR by all of them individually. This default
-/// InformationCache will hold information required by 'default' attributes,
-/// thus the ones deduced when Attributor::identifyDefaultAbstractAttributes(..)
-/// is called.
-///
-/// If custom abstract attributes, registered manually through
-/// Attributor::registerAA(...), need more information, especially if it is not
-/// reusable, it is advised to inherit from the InformationCache and cast the
-/// instance down in the abstract attributes.
-struct InformationCache {
-  /// A map type from opcodes to instructions with this opcode.
-  using OpcodeInstMapTy = DenseMap<unsigned, SmallVector<Instruction *, 32>>;
-
-  /// Return the map that relates "interesting" opcodes with all instructions
-  /// with that opcode in \p F.
-  OpcodeInstMapTy &getOpcodeInstMapForFunction(Function &F) {
-    return FuncInstOpcodeMap[&F];
+  /// Determine whether the function \p F is IPO amendable
+  ///
+  /// If a function is exactly defined or it has alwaysinline attribute
+  /// and is viable to be inlined, we say it is IPO amendable
+  bool isFunctionIPOAmendable(const Function &F) {
+    return F.hasExactDefinition() || InfoCache.InlineableFunctions.count(&F);
   }
 
-  /// A vector type to hold instructions.
-  using InstructionVectorTy = std::vector<Instruction *>;
+  /// Mark the internal function \p F as live.
+  ///
+  /// This will trigger the identification and initialization of attributes for
+  /// \p F.
+  void markLiveInternalFunction(const Function &F) {
+    assert(F.hasLocalLinkage() &&
+           "Only local linkage is assumed dead initially.");
 
-  /// Return the instructions in \p F that may read or write memory.
-  InstructionVectorTy &getReadOrWriteInstsForFunction(Function &F) {
-    return FuncRWInstsMap[&F];
+    identifyDefaultAbstractAttributes(const_cast<Function &>(F));
   }
 
+  /// Helper function to remove callsite.
+  void removeCallSite(CallInst *CI) {
+    if (!CI)
+      return;
+
+    CGUpdater.removeCallSite(*CI);
+  }
+
+  /// Record that \p U is to be replaces with \p NV after information was
+  /// manifested. This also triggers deletion of trivially dead istructions.
+  bool changeUseAfterManifest(Use &U, Value &NV) {
+    Value *&V = ToBeChangedUses[&U];
+    if (V && (V->stripPointerCasts() == NV.stripPointerCasts() ||
+              isa_and_nonnull<UndefValue>(V)))
+      return false;
+    assert((!V || V == &NV || isa<UndefValue>(NV)) &&
+           "Use was registered twice for replacement with different values!");
+    V = &NV;
+    return true;
+  }
+
+  /// Helper function to replace all uses of \p V with \p NV. Return true if
+  /// there is any change. The flag \p ChangeDroppable indicates if dropppable
+  /// uses should be changed too.
+  bool changeValueAfterManifest(Value &V, Value &NV,
+                                bool ChangeDroppable = true) {
+    bool Changed = false;
+    for (auto &U : V.uses())
+      if (ChangeDroppable || !U.getUser()->isDroppable())
+        Changed |= changeUseAfterManifest(U, NV);
+
+    return Changed;
+  }
+
+  /// Record that \p I is to be replaced with `unreachable` after information
+  /// was manifested.
+  void changeToUnreachableAfterManifest(Instruction *I) {
+    ToBeChangedToUnreachableInsts.insert(I);
+  }
+
+  /// Record that \p II has at least one dead successor block. This information
+  /// is used, e.g., to replace \p II with a call, after information was
+  /// manifested.
+  void registerInvokeWithDeadSuccessor(InvokeInst &II) {
+    InvokeWithDeadSuccessor.push_back(&II);
+  }
+
+  /// Record that \p I is deleted after information was manifested. This also
+  /// triggers deletion of trivially dead istructions.
+  void deleteAfterManifest(Instruction &I) { ToBeDeletedInsts.insert(&I); }
+
+  /// Record that \p BB is deleted after information was manifested. This also
+  /// triggers deletion of trivially dead istructions.
+  void deleteAfterManifest(BasicBlock &BB) { ToBeDeletedBlocks.insert(&BB); }
+
+  /// Record that \p F is deleted after information was manifested.
+  void deleteAfterManifest(Function &F) { ToBeDeletedFunctions.insert(&F); }
+
+  /// If \p V is assumed to be a constant, return it, if it is unclear yet,
+  /// return None, otherwise return `nullptr`.
+  Optional<Constant *> getAssumedConstant(const Value &V,
+                                          const AbstractAttribute &AA,
+                                          bool &UsedAssumedInformation);
+
+  /// Return true if \p AA (or its context instruction) is assumed dead.
+  ///
+  /// If \p LivenessAA is not provided it is queried.
+  bool isAssumedDead(const AbstractAttribute &AA, const AAIsDead *LivenessAA,
+                     bool CheckBBLivenessOnly = false,
+                     DepClassTy DepClass = DepClassTy::OPTIONAL);
+
+  /// Return true if \p I is assumed dead.
+  ///
+  /// If \p LivenessAA is not provided it is queried.
+  bool isAssumedDead(const Instruction &I, const AbstractAttribute *QueryingAA,
+                     const AAIsDead *LivenessAA,
+                     bool CheckBBLivenessOnly = false,
+                     DepClassTy DepClass = DepClassTy::OPTIONAL);
+
+  /// Return true if \p U is assumed dead.
+  ///
+  /// If \p FnLivenessAA is not provided it is queried.
+  bool isAssumedDead(const Use &U, const AbstractAttribute *QueryingAA,
+                     const AAIsDead *FnLivenessAA,
+                     bool CheckBBLivenessOnly = false,
+                     DepClassTy DepClass = DepClassTy::OPTIONAL);
+
+  /// Return true if \p IRP is assumed dead.
+  ///
+  /// If \p FnLivenessAA is not provided it is queried.
+  bool isAssumedDead(const IRPosition &IRP, const AbstractAttribute *QueryingAA,
+                     const AAIsDead *FnLivenessAA,
+                     bool CheckBBLivenessOnly = false,
+                     DepClassTy DepClass = DepClassTy::OPTIONAL);
+
+  /// Check \p Pred on all (transitive) uses of \p V.
+  ///
+  /// This method will evaluate \p Pred on all (transitive) uses of the
+  /// associated value and return true if \p Pred holds every time.
+  bool checkForAllUses(function_ref<bool(const Use &, bool &)> Pred,
+                       const AbstractAttribute &QueryingAA, const Value &V,
+                       DepClassTy LivenessDepClass = DepClassTy::OPTIONAL);
+
+  /// Helper struct used in the communication between an abstract attribute (AA)
+  /// that wants to change the signature of a function and the Attributor which
+  /// applies the changes. The struct is partially initialized with the
+  /// information from the AA (see the constructor). All other members are
+  /// provided by the Attributor prior to invoking any callbacks.
+  struct ArgumentReplacementInfo {
+    /// Callee repair callback type
+    ///
+    /// The function repair callback is invoked once to rewire the replacement
+    /// arguments in the body of the new function. The argument replacement info
+    /// is passed, as build from the registerFunctionSignatureRewrite call, as
+    /// well as the replacement function and an iteratore to the first
+    /// replacement argument.
+    using CalleeRepairCBTy = std::function<void(
+        const ArgumentReplacementInfo &, Function &, Function::arg_iterator)>;
+
+    /// Abstract call site (ACS) repair callback type
+    ///
+    /// The abstract call site repair callback is invoked once on every abstract
+    /// call site of the replaced function (\see ReplacedFn). The callback needs
+    /// to provide the operands for the call to the new replacement function.
+    /// The number and type of the operands appended to the provided vector
+    /// (second argument) is defined by the number and types determined through
+    /// the replacement type vector (\see ReplacementTypes). The first argument
+    /// is the ArgumentReplacementInfo object registered with the Attributor
+    /// through the registerFunctionSignatureRewrite call.
+    using ACSRepairCBTy =
+        std::function<void(const ArgumentReplacementInfo &, AbstractCallSite,
+                           SmallVectorImpl<Value *> &)>;
+
+    /// Simple getters, see the corresponding members for details.
+    ///{
+
+    Attributor &getAttributor() const { return A; }
+    const Function &getReplacedFn() const { return ReplacedFn; }
+    const Argument &getReplacedArg() const { return ReplacedArg; }
+    unsigned getNumReplacementArgs() const { return ReplacementTypes.size(); }
+    const SmallVectorImpl<Type *> &getReplacementTypes() const {
+      return ReplacementTypes;
+    }
+
+    ///}
+
+  private:
+    /// Constructor that takes the argument to be replaced, the types of
+    /// the replacement arguments, as well as callbacks to repair the call sites
+    /// and new function after the replacement happened.
+    ArgumentReplacementInfo(Attributor &A, Argument &Arg,
+                            ArrayRef<Type *> ReplacementTypes,
+                            CalleeRepairCBTy &&CalleeRepairCB,
+                            ACSRepairCBTy &&ACSRepairCB)
+        : A(A), ReplacedFn(*Arg.getParent()), ReplacedArg(Arg),
+          ReplacementTypes(ReplacementTypes.begin(), ReplacementTypes.end()),
+          CalleeRepairCB(std::move(CalleeRepairCB)),
+          ACSRepairCB(std::move(ACSRepairCB)) {}
+
+    /// Reference to the attributor to allow access from the callbacks.
+    Attributor &A;
+
+    /// The "old" function replaced by ReplacementFn.
+    const Function &ReplacedFn;
+
+    /// The "old" argument replaced by new ones defined via ReplacementTypes.
+    const Argument &ReplacedArg;
+
+    /// The types of the arguments replacing ReplacedArg.
+    const SmallVector<Type *, 8> ReplacementTypes;
+
+    /// Callee repair callback, see CalleeRepairCBTy.
+    const CalleeRepairCBTy CalleeRepairCB;
+
+    /// Abstract call site (ACS) repair callback, see ACSRepairCBTy.
+    const ACSRepairCBTy ACSRepairCB;
+
+    /// Allow access to the private members from the Attributor.
+    friend struct Attributor;
+  };
+
+  /// Check if we can rewrite a function signature.
+  ///
+  /// The argument \p Arg is replaced with new ones defined by the number,
+  /// order, and types in \p ReplacementTypes.
+  ///
+  /// \returns True, if the replacement can be registered, via
+  /// registerFunctionSignatureRewrite, false otherwise.
+  bool isValidFunctionSignatureRewrite(Argument &Arg,
+                                       ArrayRef<Type *> ReplacementTypes);
+
+  /// Register a rewrite for a function signature.
+  ///
+  /// The argument \p Arg is replaced with new ones defined by the number,
+  /// order, and types in \p ReplacementTypes. The rewiring at the call sites is
+  /// done through \p ACSRepairCB and at the callee site through
+  /// \p CalleeRepairCB.
+  ///
+  /// \returns True, if the replacement was registered, false otherwise.
+  bool registerFunctionSignatureRewrite(
+      Argument &Arg, ArrayRef<Type *> ReplacementTypes,
+      ArgumentReplacementInfo::CalleeRepairCBTy &&CalleeRepairCB,
+      ArgumentReplacementInfo::ACSRepairCBTy &&ACSRepairCB);
+
+  /// Check \p Pred on all function call sites.
+  ///
+  /// This method will evaluate \p Pred on call sites and return
+  /// true if \p Pred holds in every call sites. However, this is only possible
+  /// all call sites are known, hence the function has internal linkage.
+  /// If true is returned, \p AllCallSitesKnown is set if all possible call
+  /// sites of the function have been visited.
+  bool checkForAllCallSites(function_ref<bool(AbstractCallSite)> Pred,
+                            const AbstractAttribute &QueryingAA,
+                            bool RequireAllCallSites, bool &AllCallSitesKnown);
+
+  /// Check \p Pred on all values potentially returned by \p F.
+  ///
+  /// This method will evaluate \p Pred on all values potentially returned by
+  /// the function associated with \p QueryingAA. The returned values are
+  /// matched with their respective return instructions. Returns true if \p Pred
+  /// holds on all of them.
+  bool checkForAllReturnedValuesAndReturnInsts(
+      function_ref<bool(Value &, const SmallSetVector<ReturnInst *, 4> &)> Pred,
+      const AbstractAttribute &QueryingAA);
+
+  /// Check \p Pred on all values potentially returned by the function
+  /// associated with \p QueryingAA.
+  ///
+  /// This is the context insensitive version of the method above.
+  bool checkForAllReturnedValues(function_ref<bool(Value &)> Pred,
+                                 const AbstractAttribute &QueryingAA);
+
+  /// Check \p Pred on all instructions with an opcode present in \p Opcodes.
+  ///
+  /// This method will evaluate \p Pred on all instructions with an opcode
+  /// present in \p Opcode and return true if \p Pred holds on all of them.
+  bool checkForAllInstructions(function_ref<bool(Instruction &)> Pred,
+                               const AbstractAttribute &QueryingAA,
+                               const ArrayRef<unsigned> &Opcodes,
+                               bool CheckBBLivenessOnly = false);
+
+  /// Check \p Pred on all call-like instructions (=CallBased derived).
+  ///
+  /// See checkForAllCallLikeInstructions(...) for more information.
+  bool checkForAllCallLikeInstructions(function_ref<bool(Instruction &)> Pred,
+                                       const AbstractAttribute &QueryingAA) {
+    return checkForAllInstructions(Pred, QueryingAA,
+                                   {(unsigned)Instruction::Invoke,
+                                    (unsigned)Instruction::CallBr,
+                                    (unsigned)Instruction::Call});
+  }
+
+  /// Check \p Pred on all Read/Write instructions.
+  ///
+  /// This method will evaluate \p Pred on all instructions that read or write
+  /// to memory present in the information cache and return true if \p Pred
+  /// holds on all of them.
+  bool checkForAllReadWriteInstructions(function_ref<bool(Instruction &)> Pred,
+                                        AbstractAttribute &QueryingAA);
+
+  /// Create a shallow wrapper for \p F such that \p F has internal linkage
+  /// afterwards. It also sets the original \p F 's name to anonymous
+  ///
+  /// A wrapper is a function with the same type (and attributes) as \p F
+  /// that will only call \p F and return the result, if any.
+  ///
+  /// Assuming the declaration of looks like:
+  ///   rty F(aty0 arg0, ..., atyN argN);
+  ///
+  /// The wrapper will then look as follows:
+  ///   rty wrapper(aty0 arg0, ..., atyN argN) {
+  ///     return F(arg0, ..., argN);
+  ///   }
+  ///
+  static void createShallowWrapper(Function &F);
+
+  /// Return the data layout associated with the anchor scope.
+  const DataLayout &getDataLayout() const { return InfoCache.DL; }
+
+  /// The allocator used to allocate memory, e.g. for `AbstractAttribute`s.
+  BumpPtrAllocator &Allocator;
+
 private:
-  /// A map type from functions to opcode to instruction maps.
-  using FuncInstOpcodeMapTy = DenseMap<Function *, OpcodeInstMapTy>;
+  /// This method will do fixpoint iteration until fixpoint or the
+  /// maximum iteration count is reached.
+  ///
+  /// If the maximum iteration count is reached, This method will
+  /// indicate pessimistic fixpoint on attributes that transitively depend
+  /// on attributes that were scheduled for an update.
+  void runTillFixpoint();
 
-  /// A map type from functions to their read or write instructions.
-  using FuncRWInstsMapTy = DenseMap<Function *, InstructionVectorTy>;
+  /// Gets called after scheduling, manifests attributes to the LLVM IR.
+  ChangeStatus manifestAttributes();
 
-  /// A nested map that remembers all instructions in a function with a certain
-  /// instruction opcode (Instruction::getOpcode()).
-  FuncInstOpcodeMapTy FuncInstOpcodeMap;
+  /// Gets called after attributes have been manifested, cleans up the IR.
+  /// Deletes dead functions, blocks and instructions.
+  /// Rewrites function signitures and updates the call graph.
+  ChangeStatus cleanupIR();
 
-  /// A map from functions to their instructions that may read or write memory.
-  FuncRWInstsMapTy FuncRWInstsMap;
+  /// Identify internal functions that are effectively dead, thus not reachable
+  /// from a live entry point. The functions are added to ToBeDeletedFunctions.
+  void identifyDeadInternalFunctions();
 
-  /// Give the Attributor access to the members so
-  /// Attributor::identifyDefaultAbstractAttributes(...) can initialize them.
-  friend struct Attributor;
+  /// Run `::update` on \p AA and track the dependences queried while doing so.
+  /// Also adjust the state if we know further updates are not necessary.
+  ChangeStatus updateAA(AbstractAttribute &AA);
+
+  /// Remember the dependences on the top of the dependence stack such that they
+  /// may trigger further updates. (\see DependenceStack)
+  void rememberDependences();
+
+  /// Check \p Pred on all call sites of \p Fn.
+  ///
+  /// This method will evaluate \p Pred on call sites and return
+  /// true if \p Pred holds in every call sites. However, this is only possible
+  /// all call sites are known, hence the function has internal linkage.
+  /// If true is returned, \p AllCallSitesKnown is set if all possible call
+  /// sites of the function have been visited.
+  bool checkForAllCallSites(function_ref<bool(AbstractCallSite)> Pred,
+                            const Function &Fn, bool RequireAllCallSites,
+                            const AbstractAttribute *QueryingAA,
+                            bool &AllCallSitesKnown);
+
+  /// Apply all requested function signature rewrites
+  /// (\see registerFunctionSignatureRewrite) and return Changed if the module
+  /// was altered.
+  ChangeStatus
+  rewriteFunctionSignatures(SmallPtrSetImpl<Function *> &ModifiedFns);
+
+  /// Check if the Attribute \p AA should be seeded.
+  /// See getOrCreateAAFor.
+  bool shouldSeedAttribute(AbstractAttribute &AA);
+
+  /// A nested map to lookup abstract attributes based on the argument position
+  /// on the outer level, and the addresses of the static member (AAType::ID) on
+  /// the inner level.
+  ///{
+  using AAMapKeyTy = std::pair<const char *, IRPosition>;
+  DenseMap<AAMapKeyTy, AbstractAttribute *> AAMap;
+  ///}
+
+  /// Map to remember all requested signature changes (= argument replacements).
+  DenseMap<Function *, SmallVector<std::unique_ptr<ArgumentReplacementInfo>, 8>>
+      ArgumentReplacementMap;
+
+  /// The set of functions we are deriving attributes for.
+  SetVector<Function *> &Functions;
+
+  /// The information cache that holds pre-processed (LLVM-IR) information.
+  InformationCache &InfoCache;
+
+  /// Helper to update an underlying call graph.
+  CallGraphUpdater &CGUpdater;
+
+  /// Abstract Attribute dependency graph
+  AADepGraph DG;
+
+  /// Set of functions for which we modified the content such that it might
+  /// impact the call graph.
+  SmallPtrSet<Function *, 8> CGModifiedFunctions;
+
+  /// Information about a dependence. If FromAA is changed ToAA needs to be
+  /// updated as well.
+  struct DepInfo {
+    const AbstractAttribute *FromAA;
+    const AbstractAttribute *ToAA;
+    DepClassTy DepClass;
+  };
+
+  /// The dependence stack is used to track dependences during an
+  /// `AbstractAttribute::update` call. As `AbstractAttribute::update` can be
+  /// recursive we might have multiple vectors of dependences in here. The stack
+  /// size, should be adjusted according to the expected recursion depth and the
+  /// inner dependence vector size to the expected number of dependences per
+  /// abstract attribute. Since the inner vectors are actually allocated on the
+  /// stack we can be generous with their size.
+  using DependenceVector = SmallVector<DepInfo, 8>;
+  SmallVector<DependenceVector *, 16> DependenceStack;
+
+  /// If not null, a set limiting the attribute opportunities.
+  const DenseSet<const char *> *Allowed;
+
+  /// A set to remember the functions we already assume to be live and visited.
+  DenseSet<const Function *> VisitedFunctions;
+
+  /// Uses we replace with a new value after manifest is done. We will remove
+  /// then trivially dead instructions as well.
+  DenseMap<Use *, Value *> ToBeChangedUses;
+
+  /// Instructions we replace with `unreachable` insts after manifest is done.
+  SmallDenseSet<WeakVH, 16> ToBeChangedToUnreachableInsts;
+
+  /// Invoke instructions with at least a single dead successor block.
+  SmallVector<WeakVH, 16> InvokeWithDeadSuccessor;
+
+  /// A flag that indicates which stage of the process we are in. Initially, the
+  /// phase is SEEDING. Phase is changed in `Attributor::run()`
+  enum class AttributorPhase {
+    SEEDING,
+    UPDATE,
+    MANIFEST,
+    CLEANUP,
+  } Phase = AttributorPhase::SEEDING;
+
+  /// The current initialization chain length. Tracked to avoid stack overflows.
+  unsigned InitializationChainLength = 0;
+
+  /// Functions, blocks, and instructions we delete after manifest is done.
+  ///
+  ///{
+  SmallPtrSet<Function *, 8> ToBeDeletedFunctions;
+  SmallPtrSet<BasicBlock *, 8> ToBeDeletedBlocks;
+  SmallDenseSet<WeakVH, 8> ToBeDeletedInsts;
+  ///}
+
+  friend AADepGraph;
 };
 
 /// An interface to query the internal state of an abstract attribute.
@@ -339,9 +1705,10 @@
 ///
 /// All methods need to be implemented by the subclass. For the common use case,
 /// a single boolean state or a bit-encoded state, the BooleanState and
-/// IntegerState classes are already provided. An abstract attribute can inherit
-/// from them to get the abstract state interface and additional methods to
-/// directly modify the state based if needed. See the class comments for help.
+/// {Inc,Dec,Bit}IntegerState classes are already provided. An abstract
+/// attribute can inherit from them to get the abstract state interface and
+/// additional methods to directly modify the state based if needed. See the
+/// class comments for help.
 struct AbstractState {
   virtual ~AbstractState() {}
 
@@ -357,13 +1724,17 @@
   ///
   /// This will usually make the optimistically assumed state the known to be
   /// true state.
-  virtual void indicateOptimisticFixpoint() = 0;
+  ///
+  /// \returns ChangeStatus::UNCHANGED as the assumed value should not change.
+  virtual ChangeStatus indicateOptimisticFixpoint() = 0;
 
   /// Indicate that the abstract state should converge to the pessimistic state.
   ///
   /// This will usually revert the optimistically assumed state to the known to
   /// be true state.
-  virtual void indicatePessimisticFixpoint() = 0;
+  ///
+  /// \returns ChangeStatus::CHANGED as the assumed value may change.
+  virtual ChangeStatus indicatePessimisticFixpoint() = 0;
 };
 
 /// Simple state with integers encoding.
@@ -376,15 +1747,24 @@
 /// force/inidicate a fixpoint. If an optimistic one is indicated, the known
 /// state will catch up with the assumed one, for a pessimistic fixpoint it is
 /// the other way around.
-struct IntegerState : public AbstractState {
-  /// Undrlying integer type, we assume 32 bits to be enough.
-  using base_t = uint32_t;
+template <typename base_ty, base_ty BestState, base_ty WorstState>
+struct IntegerStateBase : public AbstractState {
+  using base_t = base_ty;
 
-  /// Initialize the (best) state.
-  IntegerState(base_t BestState = ~0) : Assumed(BestState) {}
+  IntegerStateBase() {}
+  IntegerStateBase(base_t Assumed) : Assumed(Assumed) {}
+
+  /// Return the best possible representable state.
+  static constexpr base_t getBestState() { return BestState; }
+  static constexpr base_t getBestState(const IntegerStateBase &) {
+    return getBestState();
+  }
 
   /// Return the worst possible representable state.
-  static constexpr base_t getWorstState() { return 0; }
+  static constexpr base_t getWorstState() { return WorstState; }
+  static constexpr base_t getWorstState(const IntegerStateBase &) {
+    return getWorstState();
+  }
 
   /// See AbstractState::isValidState()
   /// NOTE: For now we simply pretend that the worst possible state is invalid.
@@ -394,10 +1774,16 @@
   bool isAtFixpoint() const override { return Assumed == Known; }
 
   /// See AbstractState::indicateOptimisticFixpoint(...)
-  void indicateOptimisticFixpoint() override { Known = Assumed; }
+  ChangeStatus indicateOptimisticFixpoint() override {
+    Known = Assumed;
+    return ChangeStatus::UNCHANGED;
+  }
 
   /// See AbstractState::indicatePessimisticFixpoint(...)
-  void indicatePessimisticFixpoint() override { Assumed = Known; }
+  ChangeStatus indicatePessimisticFixpoint() override {
+    Assumed = Known;
+    return ChangeStatus::CHANGED;
+  }
 
   /// Return the known state encoding
   base_t getKnown() const { return Known; }
@@ -405,49 +1791,432 @@
   /// Return the assumed state encoding.
   base_t getAssumed() const { return Assumed; }
 
-  /// Return true if the bits set in \p BitsEncoding are "known bits".
-  bool isKnown(base_t BitsEncoding) const {
-    return (Known & BitsEncoding) == BitsEncoding;
+  /// Equality for IntegerStateBase.
+  bool
+  operator==(const IntegerStateBase<base_t, BestState, WorstState> &R) const {
+    return this->getAssumed() == R.getAssumed() &&
+           this->getKnown() == R.getKnown();
   }
 
-  /// Return true if the bits set in \p BitsEncoding are "assumed bits".
-  bool isAssumed(base_t BitsEncoding) const {
-    return (Assumed & BitsEncoding) == BitsEncoding;
+  /// Inequality for IntegerStateBase.
+  bool
+  operator!=(const IntegerStateBase<base_t, BestState, WorstState> &R) const {
+    return !(*this == R);
   }
 
-  /// Add the bits in \p BitsEncoding to the "known bits".
-  IntegerState &addKnownBits(base_t Bits) {
-    // Make sure we never miss any "known bits".
-    Assumed |= Bits;
-    Known |= Bits;
-    return *this;
+  /// "Clamp" this state with \p R. The result is subtype dependent but it is
+  /// intended that only information assumed in both states will be assumed in
+  /// this one afterwards.
+  void operator^=(const IntegerStateBase<base_t, BestState, WorstState> &R) {
+    handleNewAssumedValue(R.getAssumed());
   }
 
-  /// Remove the bits in \p BitsEncoding from the "assumed bits" if not known.
-  IntegerState &removeAssumedBits(base_t BitsEncoding) {
-    // Make sure we never loose any "known bits".
-    Assumed = (Assumed & ~BitsEncoding) | Known;
-    return *this;
+  /// "Clamp" this state with \p R. The result is subtype dependent but it is
+  /// intended that information known in either state will be known in
+  /// this one afterwards.
+  void operator+=(const IntegerStateBase<base_t, BestState, WorstState> &R) {
+    handleNewKnownValue(R.getKnown());
   }
 
-  /// Keep only "assumed bits" also set in \p BitsEncoding but all known ones.
-  IntegerState &intersectAssumedBits(base_t BitsEncoding) {
-    // Make sure we never loose any "known bits".
-    Assumed = (Assumed & BitsEncoding) | Known;
-    return *this;
+  void operator|=(const IntegerStateBase<base_t, BestState, WorstState> &R) {
+    joinOR(R.getAssumed(), R.getKnown());
   }
 
-private:
+  void operator&=(const IntegerStateBase<base_t, BestState, WorstState> &R) {
+    joinAND(R.getAssumed(), R.getKnown());
+  }
+
+protected:
+  /// Handle a new assumed value \p Value. Subtype dependent.
+  virtual void handleNewAssumedValue(base_t Value) = 0;
+
+  /// Handle a new known value \p Value. Subtype dependent.
+  virtual void handleNewKnownValue(base_t Value) = 0;
+
+  /// Handle a  value \p Value. Subtype dependent.
+  virtual void joinOR(base_t AssumedValue, base_t KnownValue) = 0;
+
+  /// Handle a new assumed value \p Value. Subtype dependent.
+  virtual void joinAND(base_t AssumedValue, base_t KnownValue) = 0;
+
   /// The known state encoding in an integer of type base_t.
   base_t Known = getWorstState();
 
   /// The assumed state encoding in an integer of type base_t.
-  base_t Assumed;
+  base_t Assumed = getBestState();
+};
+
+/// Specialization of the integer state for a bit-wise encoding.
+template <typename base_ty = uint32_t, base_ty BestState = ~base_ty(0),
+          base_ty WorstState = 0>
+struct BitIntegerState
+    : public IntegerStateBase<base_ty, BestState, WorstState> {
+  using base_t = base_ty;
+
+  /// Return true if the bits set in \p BitsEncoding are "known bits".
+  bool isKnown(base_t BitsEncoding) const {
+    return (this->Known & BitsEncoding) == BitsEncoding;
+  }
+
+  /// Return true if the bits set in \p BitsEncoding are "assumed bits".
+  bool isAssumed(base_t BitsEncoding) const {
+    return (this->Assumed & BitsEncoding) == BitsEncoding;
+  }
+
+  /// Add the bits in \p BitsEncoding to the "known bits".
+  BitIntegerState &addKnownBits(base_t Bits) {
+    // Make sure we never miss any "known bits".
+    this->Assumed |= Bits;
+    this->Known |= Bits;
+    return *this;
+  }
+
+  /// Remove the bits in \p BitsEncoding from the "assumed bits" if not known.
+  BitIntegerState &removeAssumedBits(base_t BitsEncoding) {
+    return intersectAssumedBits(~BitsEncoding);
+  }
+
+  /// Remove the bits in \p BitsEncoding from the "known bits".
+  BitIntegerState &removeKnownBits(base_t BitsEncoding) {
+    this->Known = (this->Known & ~BitsEncoding);
+    return *this;
+  }
+
+  /// Keep only "assumed bits" also set in \p BitsEncoding but all known ones.
+  BitIntegerState &intersectAssumedBits(base_t BitsEncoding) {
+    // Make sure we never loose any "known bits".
+    this->Assumed = (this->Assumed & BitsEncoding) | this->Known;
+    return *this;
+  }
+
+private:
+  void handleNewAssumedValue(base_t Value) override {
+    intersectAssumedBits(Value);
+  }
+  void handleNewKnownValue(base_t Value) override { addKnownBits(Value); }
+  void joinOR(base_t AssumedValue, base_t KnownValue) override {
+    this->Known |= KnownValue;
+    this->Assumed |= AssumedValue;
+  }
+  void joinAND(base_t AssumedValue, base_t KnownValue) override {
+    this->Known &= KnownValue;
+    this->Assumed &= AssumedValue;
+  }
+};
+
+/// Specialization of the integer state for an increasing value, hence ~0u is
+/// the best state and 0 the worst.
+template <typename base_ty = uint32_t, base_ty BestState = ~base_ty(0),
+          base_ty WorstState = 0>
+struct IncIntegerState
+    : public IntegerStateBase<base_ty, BestState, WorstState> {
+  using super = IntegerStateBase<base_ty, BestState, WorstState>;
+  using base_t = base_ty;
+
+  IncIntegerState() : super() {}
+  IncIntegerState(base_t Assumed) : super(Assumed) {}
+
+  /// Return the best possible representable state.
+  static constexpr base_t getBestState() { return BestState; }
+  static constexpr base_t
+  getBestState(const IncIntegerState<base_ty, BestState, WorstState> &) {
+    return getBestState();
+  }
+
+  /// Take minimum of assumed and \p Value.
+  IncIntegerState &takeAssumedMinimum(base_t Value) {
+    // Make sure we never loose "known value".
+    this->Assumed = std::max(std::min(this->Assumed, Value), this->Known);
+    return *this;
+  }
+
+  /// Take maximum of known and \p Value.
+  IncIntegerState &takeKnownMaximum(base_t Value) {
+    // Make sure we never loose "known value".
+    this->Assumed = std::max(Value, this->Assumed);
+    this->Known = std::max(Value, this->Known);
+    return *this;
+  }
+
+private:
+  void handleNewAssumedValue(base_t Value) override {
+    takeAssumedMinimum(Value);
+  }
+  void handleNewKnownValue(base_t Value) override { takeKnownMaximum(Value); }
+  void joinOR(base_t AssumedValue, base_t KnownValue) override {
+    this->Known = std::max(this->Known, KnownValue);
+    this->Assumed = std::max(this->Assumed, AssumedValue);
+  }
+  void joinAND(base_t AssumedValue, base_t KnownValue) override {
+    this->Known = std::min(this->Known, KnownValue);
+    this->Assumed = std::min(this->Assumed, AssumedValue);
+  }
+};
+
+/// Specialization of the integer state for a decreasing value, hence 0 is the
+/// best state and ~0u the worst.
+template <typename base_ty = uint32_t>
+struct DecIntegerState : public IntegerStateBase<base_ty, 0, ~base_ty(0)> {
+  using base_t = base_ty;
+
+  /// Take maximum of assumed and \p Value.
+  DecIntegerState &takeAssumedMaximum(base_t Value) {
+    // Make sure we never loose "known value".
+    this->Assumed = std::min(std::max(this->Assumed, Value), this->Known);
+    return *this;
+  }
+
+  /// Take minimum of known and \p Value.
+  DecIntegerState &takeKnownMinimum(base_t Value) {
+    // Make sure we never loose "known value".
+    this->Assumed = std::min(Value, this->Assumed);
+    this->Known = std::min(Value, this->Known);
+    return *this;
+  }
+
+private:
+  void handleNewAssumedValue(base_t Value) override {
+    takeAssumedMaximum(Value);
+  }
+  void handleNewKnownValue(base_t Value) override { takeKnownMinimum(Value); }
+  void joinOR(base_t AssumedValue, base_t KnownValue) override {
+    this->Assumed = std::min(this->Assumed, KnownValue);
+    this->Assumed = std::min(this->Assumed, AssumedValue);
+  }
+  void joinAND(base_t AssumedValue, base_t KnownValue) override {
+    this->Assumed = std::max(this->Assumed, KnownValue);
+    this->Assumed = std::max(this->Assumed, AssumedValue);
+  }
 };
 
 /// Simple wrapper for a single bit (boolean) state.
-struct BooleanState : public IntegerState {
-  BooleanState() : IntegerState(1){};
+struct BooleanState : public IntegerStateBase<bool, 1, 0> {
+  using super = IntegerStateBase<bool, 1, 0>;
+  using base_t = IntegerStateBase::base_t;
+
+  BooleanState() : super() {}
+  BooleanState(base_t Assumed) : super(Assumed) {}
+
+  /// Set the assumed value to \p Value but never below the known one.
+  void setAssumed(bool Value) { Assumed &= (Known | Value); }
+
+  /// Set the known and asssumed value to \p Value.
+  void setKnown(bool Value) {
+    Known |= Value;
+    Assumed |= Value;
+  }
+
+  /// Return true if the state is assumed to hold.
+  bool isAssumed() const { return getAssumed(); }
+
+  /// Return true if the state is known to hold.
+  bool isKnown() const { return getKnown(); }
+
+private:
+  void handleNewAssumedValue(base_t Value) override {
+    if (!Value)
+      Assumed = Known;
+  }
+  void handleNewKnownValue(base_t Value) override {
+    if (Value)
+      Known = (Assumed = Value);
+  }
+  void joinOR(base_t AssumedValue, base_t KnownValue) override {
+    Known |= KnownValue;
+    Assumed |= AssumedValue;
+  }
+  void joinAND(base_t AssumedValue, base_t KnownValue) override {
+    Known &= KnownValue;
+    Assumed &= AssumedValue;
+  }
+};
+
+/// State for an integer range.
+struct IntegerRangeState : public AbstractState {
+
+  /// Bitwidth of the associated value.
+  uint32_t BitWidth;
+
+  /// State representing assumed range, initially set to empty.
+  ConstantRange Assumed;
+
+  /// State representing known range, initially set to [-inf, inf].
+  ConstantRange Known;
+
+  IntegerRangeState(uint32_t BitWidth)
+      : BitWidth(BitWidth), Assumed(ConstantRange::getEmpty(BitWidth)),
+        Known(ConstantRange::getFull(BitWidth)) {}
+
+  IntegerRangeState(const ConstantRange &CR)
+      : BitWidth(CR.getBitWidth()), Assumed(CR),
+        Known(getWorstState(CR.getBitWidth())) {}
+
+  /// Return the worst possible representable state.
+  static ConstantRange getWorstState(uint32_t BitWidth) {
+    return ConstantRange::getFull(BitWidth);
+  }
+
+  /// Return the best possible representable state.
+  static ConstantRange getBestState(uint32_t BitWidth) {
+    return ConstantRange::getEmpty(BitWidth);
+  }
+  static ConstantRange getBestState(const IntegerRangeState &IRS) {
+    return getBestState(IRS.getBitWidth());
+  }
+
+  /// Return associated values' bit width.
+  uint32_t getBitWidth() const { return BitWidth; }
+
+  /// See AbstractState::isValidState()
+  bool isValidState() const override {
+    return BitWidth > 0 && !Assumed.isFullSet();
+  }
+
+  /// See AbstractState::isAtFixpoint()
+  bool isAtFixpoint() const override { return Assumed == Known; }
+
+  /// See AbstractState::indicateOptimisticFixpoint(...)
+  ChangeStatus indicateOptimisticFixpoint() override {
+    Known = Assumed;
+    return ChangeStatus::CHANGED;
+  }
+
+  /// See AbstractState::indicatePessimisticFixpoint(...)
+  ChangeStatus indicatePessimisticFixpoint() override {
+    Assumed = Known;
+    return ChangeStatus::CHANGED;
+  }
+
+  /// Return the known state encoding
+  ConstantRange getKnown() const { return Known; }
+
+  /// Return the assumed state encoding.
+  ConstantRange getAssumed() const { return Assumed; }
+
+  /// Unite assumed range with the passed state.
+  void unionAssumed(const ConstantRange &R) {
+    // Don't loose a known range.
+    Assumed = Assumed.unionWith(R).intersectWith(Known);
+  }
+
+  /// See IntegerRangeState::unionAssumed(..).
+  void unionAssumed(const IntegerRangeState &R) {
+    unionAssumed(R.getAssumed());
+  }
+
+  /// Unite known range with the passed state.
+  void unionKnown(const ConstantRange &R) {
+    // Don't loose a known range.
+    Known = Known.unionWith(R);
+    Assumed = Assumed.unionWith(Known);
+  }
+
+  /// See IntegerRangeState::unionKnown(..).
+  void unionKnown(const IntegerRangeState &R) { unionKnown(R.getKnown()); }
+
+  /// Intersect known range with the passed state.
+  void intersectKnown(const ConstantRange &R) {
+    Assumed = Assumed.intersectWith(R);
+    Known = Known.intersectWith(R);
+  }
+
+  /// See IntegerRangeState::intersectKnown(..).
+  void intersectKnown(const IntegerRangeState &R) {
+    intersectKnown(R.getKnown());
+  }
+
+  /// Equality for IntegerRangeState.
+  bool operator==(const IntegerRangeState &R) const {
+    return getAssumed() == R.getAssumed() && getKnown() == R.getKnown();
+  }
+
+  /// "Clamp" this state with \p R. The result is subtype dependent but it is
+  /// intended that only information assumed in both states will be assumed in
+  /// this one afterwards.
+  IntegerRangeState operator^=(const IntegerRangeState &R) {
+    // NOTE: `^=` operator seems like `intersect` but in this case, we need to
+    // take `union`.
+    unionAssumed(R);
+    return *this;
+  }
+
+  IntegerRangeState operator&=(const IntegerRangeState &R) {
+    // NOTE: `&=` operator seems like `intersect` but in this case, we need to
+    // take `union`.
+    unionKnown(R);
+    unionAssumed(R);
+    return *this;
+  }
+};
+/// Helper struct necessary as the modular build fails if the virtual method
+/// IRAttribute::manifest is defined in the Attributor.cpp.
+struct IRAttributeManifest {
+  static ChangeStatus manifestAttrs(Attributor &A, const IRPosition &IRP,
+                                    const ArrayRef<Attribute> &DeducedAttrs);
+};
+
+/// Helper to tie a abstract state implementation to an abstract attribute.
+template <typename StateTy, typename BaseType, class... Ts>
+struct StateWrapper : public BaseType, public StateTy {
+  /// Provide static access to the type of the state.
+  using StateType = StateTy;
+
+  StateWrapper(const IRPosition &IRP, Ts... Args)
+      : BaseType(IRP), StateTy(Args...) {}
+
+  /// See AbstractAttribute::getState(...).
+  StateType &getState() override { return *this; }
+
+  /// See AbstractAttribute::getState(...).
+  const StateType &getState() const override { return *this; }
+};
+
+/// Helper class that provides common functionality to manifest IR attributes.
+template <Attribute::AttrKind AK, typename BaseType>
+struct IRAttribute : public BaseType {
+  IRAttribute(const IRPosition &IRP) : BaseType(IRP) {}
+
+  /// See AbstractAttribute::initialize(...).
+  virtual void initialize(Attributor &A) override {
+    const IRPosition &IRP = this->getIRPosition();
+    if (isa<UndefValue>(IRP.getAssociatedValue()) ||
+        this->hasAttr(getAttrKind(), /* IgnoreSubsumingPositions */ false,
+                      &A)) {
+      this->getState().indicateOptimisticFixpoint();
+      return;
+    }
+
+    bool IsFnInterface = IRP.isFnInterfaceKind();
+    const Function *FnScope = IRP.getAnchorScope();
+    // TODO: Not all attributes require an exact definition. Find a way to
+    //       enable deduction for some but not all attributes in case the
+    //       definition might be changed at runtime, see also
+    //       http://lists.llvm.org/pipermail/llvm-dev/2018-February/121275.html.
+    // TODO: We could always determine abstract attributes and if sufficient
+    //       information was found we could duplicate the functions that do not
+    //       have an exact definition.
+    if (IsFnInterface && (!FnScope || !A.isFunctionIPOAmendable(*FnScope)))
+      this->getState().indicatePessimisticFixpoint();
+  }
+
+  /// See AbstractAttribute::manifest(...).
+  ChangeStatus manifest(Attributor &A) override {
+    if (isa<UndefValue>(this->getIRPosition().getAssociatedValue()))
+      return ChangeStatus::UNCHANGED;
+    SmallVector<Attribute, 4> DeducedAttrs;
+    getDeducedAttributes(this->getAnchorValue().getContext(), DeducedAttrs);
+    return IRAttributeManifest::manifestAttrs(A, this->getIRPosition(),
+                                              DeducedAttrs);
+  }
+
+  /// Return the kind that identifies the abstract attribute implementation.
+  Attribute::AttrKind getAttrKind() const { return AK; }
+
+  /// Return the deduced attributes in \p Attrs.
+  virtual void getDeducedAttributes(LLVMContext &Ctx,
+                                    SmallVectorImpl<Attribute> &Attrs) const {
+    Attrs.emplace_back(Attribute::get(Ctx, getAttrKind()));
+  }
 };
 
 /// Base struct for all "concrete attribute" deductions.
@@ -493,34 +2262,22 @@
 ///       both directions will be added in the future.
 /// NOTE: The mechanics of adding a new "concrete" abstract attribute are
 ///       described in the file comment.
-struct AbstractAttribute {
+struct AbstractAttribute : public IRPosition, public AADepGraphNode {
+  using StateType = AbstractState;
 
-  /// The positions attributes can be manifested in.
-  enum ManifestPosition {
-    MP_ARGUMENT,           ///< An attribute for a function argument.
-    MP_CALL_SITE_ARGUMENT, ///< An attribute for a call site argument.
-    MP_FUNCTION,           ///< An attribute for a function as a whole.
-    MP_RETURNED,           ///< An attribute for the function return value.
-  };
-
-  /// An abstract attribute associated with \p AssociatedVal and anchored at
-  /// \p AnchoredVal.
-  ///
-  /// \param AssociatedVal The value this abstract attribute is associated with.
-  /// \param AnchoredVal The value this abstract attributes is anchored at.
-  /// \param InfoCache Cached information accessible to the abstract attribute.
-  AbstractAttribute(Value *AssociatedVal, Value &AnchoredVal,
-                    InformationCache &InfoCache)
-      : AssociatedVal(AssociatedVal), AnchoredVal(AnchoredVal),
-        InfoCache(InfoCache) {}
-
-  /// An abstract attribute associated with and anchored at \p V.
-  AbstractAttribute(Value &V, InformationCache &InfoCache)
-      : AbstractAttribute(&V, V, InfoCache) {}
+  AbstractAttribute(const IRPosition &IRP) : IRPosition(IRP) {}
 
   /// Virtual destructor.
   virtual ~AbstractAttribute() {}
 
+  /// This function is used to identify if an \p DGN is of type
+  /// AbstractAttribute so that the dyn_cast and cast can use such information
+  /// to cast an AADepGraphNode to an AbstractAttribute.
+  ///
+  /// We eagerly return true here because all AADepGraphNodes except for the
+  /// Synthethis Node are of type AbstractAttribute
+  static bool classof(const AADepGraphNode *DGN) { return true; }
+
   /// Initialize the state with the information in the Attributor \p A.
   ///
   /// This function is called by the Attributor once all abstract attributes
@@ -532,55 +2289,27 @@
   virtual void initialize(Attributor &A) {}
 
   /// Return the internal abstract state for inspection.
-  virtual const AbstractState &getState() const = 0;
+  virtual StateType &getState() = 0;
+  virtual const StateType &getState() const = 0;
 
-  /// Return the value this abstract attribute is anchored with.
-  ///
-  /// The anchored value might not be the associated value if the latter is not
-  /// sufficient to determine where arguments will be manifested. This is mostly
-  /// the case for call site arguments as the value is not sufficient to
-  /// pinpoint them. Instead, we can use the call site as an anchor.
-  ///
-  ///{
-  Value &getAnchoredValue() { return AnchoredVal; }
-  const Value &getAnchoredValue() const { return AnchoredVal; }
-  ///}
-
-  /// Return the llvm::Function surrounding the anchored value.
-  ///
-  ///{
-  Function &getAnchorScope();
-  const Function &getAnchorScope() const;
-  ///}
-
-  /// Return the value this abstract attribute is associated with.
-  ///
-  /// The abstract state usually represents this value.
-  ///
-  ///{
-  virtual Value *getAssociatedValue() { return AssociatedVal; }
-  virtual const Value *getAssociatedValue() const { return AssociatedVal; }
-  ///}
-
-  /// Return the position this abstract state is manifested in.
-  virtual ManifestPosition getManifestPosition() const = 0;
-
-  /// Return the kind that identifies the abstract attribute implementation.
-  virtual Attribute::AttrKind getAttrKind() const = 0;
-
-  /// Return the deduced attributes in \p Attrs.
-  virtual void getDeducedAttributes(SmallVectorImpl<Attribute> &Attrs) const {
-    LLVMContext &Ctx = AnchoredVal.getContext();
-    Attrs.emplace_back(Attribute::get(Ctx, getAttrKind()));
-  }
+  /// Return an IR position, see struct IRPosition.
+  const IRPosition &getIRPosition() const { return *this; };
+  IRPosition &getIRPosition() { return *this; };
 
   /// Helper functions, for debug purposes only.
   ///{
-  virtual void print(raw_ostream &OS) const;
+  void print(raw_ostream &OS) const override;
+  virtual void printWithDeps(raw_ostream &OS) const;
   void dump() const { print(dbgs()); }
 
   /// This function should return the "summarized" assumed state as string.
   virtual const std::string getAsStr() const = 0;
+
+  /// This function should return the name of the AbstractAttribute
+  virtual const std::string getName() const = 0;
+
+  /// This function should return the address of the ID of the AbstractAttribute
+  virtual const char *getIdAddr() const = 0;
   ///}
 
   /// Allow the Attributor access to the protected methods.
@@ -599,10 +2328,16 @@
   /// represented by the abstract attribute in the LLVM-IR.
   ///
   /// \Return CHANGED if the IR was altered, otherwise UNCHANGED.
-  virtual ChangeStatus manifest(Attributor &A);
+  virtual ChangeStatus manifest(Attributor &A) {
+    return ChangeStatus::UNCHANGED;
+  }
 
-  /// Return the internal abstract state for careful modification.
-  virtual AbstractState &getState() = 0;
+  /// Hook to enable custom statistic tracking, called after manifest that
+  /// resulted in a change if statistics are enabled.
+  ///
+  /// We require subclasses to provide an implementation so we remember to
+  /// add statistics for them.
+  virtual void trackStatistics() const = 0;
 
   /// The actual update/transfer function which has to be implemented by the
   /// derived classes.
@@ -612,15 +2347,6 @@
   ///
   /// \Return CHANGED if the internal state changed, otherwise UNCHANGED.
   virtual ChangeStatus updateImpl(Attributor &A) = 0;
-
-  /// The value this abstract attribute is associated with.
-  Value *AssociatedVal;
-
-  /// The value this abstract attribute is anchored at.
-  Value &AnchoredVal;
-
-  /// The information cache accessible to this abstract attribute.
-  InformationCache &InfoCache;
 };
 
 /// Forward declarations of output streams for debug purposes.
@@ -628,56 +2354,1442 @@
 ///{
 raw_ostream &operator<<(raw_ostream &OS, const AbstractAttribute &AA);
 raw_ostream &operator<<(raw_ostream &OS, ChangeStatus S);
-raw_ostream &operator<<(raw_ostream &OS, AbstractAttribute::ManifestPosition);
+raw_ostream &operator<<(raw_ostream &OS, IRPosition::Kind);
+raw_ostream &operator<<(raw_ostream &OS, const IRPosition &);
 raw_ostream &operator<<(raw_ostream &OS, const AbstractState &State);
+template <typename base_ty, base_ty BestState, base_ty WorstState>
+raw_ostream &
+operator<<(raw_ostream &OS,
+           const IntegerStateBase<base_ty, BestState, WorstState> &S) {
+  return OS << "(" << S.getKnown() << "-" << S.getAssumed() << ")"
+            << static_cast<const AbstractState &>(S);
+}
+raw_ostream &operator<<(raw_ostream &OS, const IntegerRangeState &State);
 ///}
 
 struct AttributorPass : public PassInfoMixin<AttributorPass> {
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
 };
+struct AttributorCGSCCPass : public PassInfoMixin<AttributorCGSCCPass> {
+  PreservedAnalyses run(LazyCallGraph::SCC &C, CGSCCAnalysisManager &AM,
+                        LazyCallGraph &CG, CGSCCUpdateResult &UR);
+};
 
 Pass *createAttributorLegacyPass();
+Pass *createAttributorCGSCCLegacyPass();
 
 /// ----------------------------------------------------------------------------
 ///                       Abstract Attribute Classes
 /// ----------------------------------------------------------------------------
 
 /// An abstract attribute for the returned values of a function.
-struct AAReturnedValues : public AbstractAttribute {
-  /// See AbstractAttribute::AbstractAttribute(...).
-  AAReturnedValues(Function &F, InformationCache &InfoCache)
-      : AbstractAttribute(F, InfoCache) {}
+struct AAReturnedValues
+    : public IRAttribute<Attribute::Returned, AbstractAttribute> {
+  AAReturnedValues(const IRPosition &IRP, Attributor &A) : IRAttribute(IRP) {}
+
+  /// Return an assumed unique return value if a single candidate is found. If
+  /// there cannot be one, return a nullptr. If it is not clear yet, return the
+  /// Optional::NoneType.
+  Optional<Value *> getAssumedUniqueReturnValue(Attributor &A) const;
 
   /// Check \p Pred on all returned values.
   ///
   /// This method will evaluate \p Pred on returned values and return
   /// true if (1) all returned values are known, and (2) \p Pred returned true
   /// for all returned values.
-  virtual bool
-  checkForallReturnedValues(std::function<bool(Value &)> &Pred) const = 0;
+  ///
+  /// Note: Unlike the Attributor::checkForAllReturnedValuesAndReturnInsts
+  /// method, this one will not filter dead return instructions.
+  virtual bool checkForAllReturnedValuesAndReturnInsts(
+      function_ref<bool(Value &, const SmallSetVector<ReturnInst *, 4> &)> Pred)
+      const = 0;
 
-  /// See AbstractAttribute::getAttrKind()
-  virtual Attribute::AttrKind getAttrKind() const override { return ID; }
+  using iterator =
+      MapVector<Value *, SmallSetVector<ReturnInst *, 4>>::iterator;
+  using const_iterator =
+      MapVector<Value *, SmallSetVector<ReturnInst *, 4>>::const_iterator;
+  virtual llvm::iterator_range<iterator> returned_values() = 0;
+  virtual llvm::iterator_range<const_iterator> returned_values() const = 0;
 
-  /// The identifier used by the Attributor for this class of attributes.
-  static constexpr Attribute::AttrKind ID = Attribute::Returned;
+  virtual size_t getNumReturnValues() const = 0;
+  virtual const SmallSetVector<CallBase *, 4> &getUnresolvedCalls() const = 0;
+
+  /// Create an abstract attribute view for the position \p IRP.
+  static AAReturnedValues &createForPosition(const IRPosition &IRP,
+                                             Attributor &A);
+
+  /// See AbstractAttribute::getName()
+  const std::string getName() const override { return "AAReturnedValues"; }
+
+  /// See AbstractAttribute::getIdAddr()
+  const char *getIdAddr() const override { return &ID; }
+
+  /// This function should return true if the type of the \p AA is
+  /// AAReturnedValues
+  static bool classof(const AbstractAttribute *AA) {
+    return (AA->getIdAddr() == &ID);
+  }
+
+  /// Unique ID (due to the unique address)
+  static const char ID;
 };
 
-struct AANoUnwind : public AbstractAttribute {
-    /// An abstract interface for all nosync attributes.
-    AANoUnwind(Value &V, InformationCache &InfoCache)
-        : AbstractAttribute(V, InfoCache) {}
+struct AANoUnwind
+    : public IRAttribute<Attribute::NoUnwind,
+                         StateWrapper<BooleanState, AbstractAttribute>> {
+  AANoUnwind(const IRPosition &IRP, Attributor &A) : IRAttribute(IRP) {}
 
-    /// See AbstractAttribute::getAttrKind()/
-    virtual Attribute::AttrKind getAttrKind() const override { return ID; }
+  /// Returns true if nounwind is assumed.
+  bool isAssumedNoUnwind() const { return getAssumed(); }
 
-    static constexpr Attribute::AttrKind ID = Attribute::NoUnwind;
+  /// Returns true if nounwind is known.
+  bool isKnownNoUnwind() const { return getKnown(); }
 
-    /// Returns true if nounwind is assumed.
-    virtual bool isAssumedNoUnwind() const = 0;
+  /// Create an abstract attribute view for the position \p IRP.
+  static AANoUnwind &createForPosition(const IRPosition &IRP, Attributor &A);
 
-    /// Returns true if nounwind is known.
-    virtual bool isKnownNoUnwind() const = 0;
+  /// See AbstractAttribute::getName()
+  const std::string getName() const override { return "AANoUnwind"; }
+
+  /// See AbstractAttribute::getIdAddr()
+  const char *getIdAddr() const override { return &ID; }
+
+  /// This function should return true if the type of the \p AA is AANoUnwind
+  static bool classof(const AbstractAttribute *AA) {
+    return (AA->getIdAddr() == &ID);
+  }
+
+  /// Unique ID (due to the unique address)
+  static const char ID;
+};
+
+struct AANoSync
+    : public IRAttribute<Attribute::NoSync,
+                         StateWrapper<BooleanState, AbstractAttribute>> {
+  AANoSync(const IRPosition &IRP, Attributor &A) : IRAttribute(IRP) {}
+
+  /// Returns true if "nosync" is assumed.
+  bool isAssumedNoSync() const { return getAssumed(); }
+
+  /// Returns true if "nosync" is known.
+  bool isKnownNoSync() const { return getKnown(); }
+
+  /// Create an abstract attribute view for the position \p IRP.
+  static AANoSync &createForPosition(const IRPosition &IRP, Attributor &A);
+
+  /// See AbstractAttribute::getName()
+  const std::string getName() const override { return "AANoSync"; }
+
+  /// See AbstractAttribute::getIdAddr()
+  const char *getIdAddr() const override { return &ID; }
+
+  /// This function should return true if the type of the \p AA is AANoSync
+  static bool classof(const AbstractAttribute *AA) {
+    return (AA->getIdAddr() == &ID);
+  }
+
+  /// Unique ID (due to the unique address)
+  static const char ID;
+};
+
+/// An abstract interface for all nonnull attributes.
+struct AANonNull
+    : public IRAttribute<Attribute::NonNull,
+                         StateWrapper<BooleanState, AbstractAttribute>> {
+  AANonNull(const IRPosition &IRP, Attributor &A) : IRAttribute(IRP) {}
+
+  /// Return true if we assume that the underlying value is nonnull.
+  bool isAssumedNonNull() const { return getAssumed(); }
+
+  /// Return true if we know that underlying value is nonnull.
+  bool isKnownNonNull() const { return getKnown(); }
+
+  /// Create an abstract attribute view for the position \p IRP.
+  static AANonNull &createForPosition(const IRPosition &IRP, Attributor &A);
+
+  /// See AbstractAttribute::getName()
+  const std::string getName() const override { return "AANonNull"; }
+
+  /// See AbstractAttribute::getIdAddr()
+  const char *getIdAddr() const override { return &ID; }
+
+  /// This function should return true if the type of the \p AA is AANonNull
+  static bool classof(const AbstractAttribute *AA) {
+    return (AA->getIdAddr() == &ID);
+  }
+
+  /// Unique ID (due to the unique address)
+  static const char ID;
+};
+
+/// An abstract attribute for norecurse.
+struct AANoRecurse
+    : public IRAttribute<Attribute::NoRecurse,
+                         StateWrapper<BooleanState, AbstractAttribute>> {
+  AANoRecurse(const IRPosition &IRP, Attributor &A) : IRAttribute(IRP) {}
+
+  /// Return true if "norecurse" is assumed.
+  bool isAssumedNoRecurse() const { return getAssumed(); }
+
+  /// Return true if "norecurse" is known.
+  bool isKnownNoRecurse() const { return getKnown(); }
+
+  /// Create an abstract attribute view for the position \p IRP.
+  static AANoRecurse &createForPosition(const IRPosition &IRP, Attributor &A);
+
+  /// See AbstractAttribute::getName()
+  const std::string getName() const override { return "AANoRecurse"; }
+
+  /// See AbstractAttribute::getIdAddr()
+  const char *getIdAddr() const override { return &ID; }
+
+  /// This function should return true if the type of the \p AA is AANoRecurse
+  static bool classof(const AbstractAttribute *AA) {
+    return (AA->getIdAddr() == &ID);
+  }
+
+  /// Unique ID (due to the unique address)
+  static const char ID;
+};
+
+/// An abstract attribute for willreturn.
+struct AAWillReturn
+    : public IRAttribute<Attribute::WillReturn,
+                         StateWrapper<BooleanState, AbstractAttribute>> {
+  AAWillReturn(const IRPosition &IRP, Attributor &A) : IRAttribute(IRP) {}
+
+  /// Return true if "willreturn" is assumed.
+  bool isAssumedWillReturn() const { return getAssumed(); }
+
+  /// Return true if "willreturn" is known.
+  bool isKnownWillReturn() const { return getKnown(); }
+
+  /// Create an abstract attribute view for the position \p IRP.
+  static AAWillReturn &createForPosition(const IRPosition &IRP, Attributor &A);
+
+  /// See AbstractAttribute::getName()
+  const std::string getName() const override { return "AAWillReturn"; }
+
+  /// See AbstractAttribute::getIdAddr()
+  const char *getIdAddr() const override { return &ID; }
+
+  /// This function should return true if the type of the \p AA is AAWillReturn
+  static bool classof(const AbstractAttribute *AA) {
+    return (AA->getIdAddr() == &ID);
+  }
+
+  /// Unique ID (due to the unique address)
+  static const char ID;
+};
+
+/// An abstract attribute for undefined behavior.
+struct AAUndefinedBehavior
+    : public StateWrapper<BooleanState, AbstractAttribute> {
+  using Base = StateWrapper<BooleanState, AbstractAttribute>;
+  AAUndefinedBehavior(const IRPosition &IRP, Attributor &A) : Base(IRP) {}
+
+  /// Return true if "undefined behavior" is assumed.
+  bool isAssumedToCauseUB() const { return getAssumed(); }
+
+  /// Return true if "undefined behavior" is assumed for a specific instruction.
+  virtual bool isAssumedToCauseUB(Instruction *I) const = 0;
+
+  /// Return true if "undefined behavior" is known.
+  bool isKnownToCauseUB() const { return getKnown(); }
+
+  /// Return true if "undefined behavior" is known for a specific instruction.
+  virtual bool isKnownToCauseUB(Instruction *I) const = 0;
+
+  /// Create an abstract attribute view for the position \p IRP.
+  static AAUndefinedBehavior &createForPosition(const IRPosition &IRP,
+                                                Attributor &A);
+
+  /// See AbstractAttribute::getName()
+  const std::string getName() const override { return "AAUndefinedBehavior"; }
+
+  /// See AbstractAttribute::getIdAddr()
+  const char *getIdAddr() const override { return &ID; }
+
+  /// This function should return true if the type of the \p AA is
+  /// AAUndefineBehavior
+  static bool classof(const AbstractAttribute *AA) {
+    return (AA->getIdAddr() == &ID);
+  }
+
+  /// Unique ID (due to the unique address)
+  static const char ID;
+};
+
+/// An abstract interface to determine reachability of point A to B.
+struct AAReachability : public StateWrapper<BooleanState, AbstractAttribute> {
+  using Base = StateWrapper<BooleanState, AbstractAttribute>;
+  AAReachability(const IRPosition &IRP, Attributor &A) : Base(IRP) {}
+
+  /// Returns true if 'From' instruction is assumed to reach, 'To' instruction.
+  /// Users should provide two positions they are interested in, and the class
+  /// determines (and caches) reachability.
+  bool isAssumedReachable(Attributor &A, const Instruction &From,
+                          const Instruction &To) const {
+    return A.getInfoCache().getPotentiallyReachable(From, To);
+  }
+
+  /// Returns true if 'From' instruction is known to reach, 'To' instruction.
+  /// Users should provide two positions they are interested in, and the class
+  /// determines (and caches) reachability.
+  bool isKnownReachable(Attributor &A, const Instruction &From,
+                        const Instruction &To) const {
+    return A.getInfoCache().getPotentiallyReachable(From, To);
+  }
+
+  /// Create an abstract attribute view for the position \p IRP.
+  static AAReachability &createForPosition(const IRPosition &IRP,
+                                           Attributor &A);
+
+  /// See AbstractAttribute::getName()
+  const std::string getName() const override { return "AAReachability"; }
+
+  /// See AbstractAttribute::getIdAddr()
+  const char *getIdAddr() const override { return &ID; }
+
+  /// This function should return true if the type of the \p AA is
+  /// AAReachability
+  static bool classof(const AbstractAttribute *AA) {
+    return (AA->getIdAddr() == &ID);
+  }
+
+  /// Unique ID (due to the unique address)
+  static const char ID;
+};
+
+/// An abstract interface for all noalias attributes.
+struct AANoAlias
+    : public IRAttribute<Attribute::NoAlias,
+                         StateWrapper<BooleanState, AbstractAttribute>> {
+  AANoAlias(const IRPosition &IRP, Attributor &A) : IRAttribute(IRP) {}
+
+  /// Return true if we assume that the underlying value is alias.
+  bool isAssumedNoAlias() const { return getAssumed(); }
+
+  /// Return true if we know that underlying value is noalias.
+  bool isKnownNoAlias() const { return getKnown(); }
+
+  /// Create an abstract attribute view for the position \p IRP.
+  static AANoAlias &createForPosition(const IRPosition &IRP, Attributor &A);
+
+  /// See AbstractAttribute::getName()
+  const std::string getName() const override { return "AANoAlias"; }
+
+  /// See AbstractAttribute::getIdAddr()
+  const char *getIdAddr() const override { return &ID; }
+
+  /// This function should return true if the type of the \p AA is AANoAlias
+  static bool classof(const AbstractAttribute *AA) {
+    return (AA->getIdAddr() == &ID);
+  }
+
+  /// Unique ID (due to the unique address)
+  static const char ID;
+};
+
+/// An AbstractAttribute for nofree.
+struct AANoFree
+    : public IRAttribute<Attribute::NoFree,
+                         StateWrapper<BooleanState, AbstractAttribute>> {
+  AANoFree(const IRPosition &IRP, Attributor &A) : IRAttribute(IRP) {}
+
+  /// Return true if "nofree" is assumed.
+  bool isAssumedNoFree() const { return getAssumed(); }
+
+  /// Return true if "nofree" is known.
+  bool isKnownNoFree() const { return getKnown(); }
+
+  /// Create an abstract attribute view for the position \p IRP.
+  static AANoFree &createForPosition(const IRPosition &IRP, Attributor &A);
+
+  /// See AbstractAttribute::getName()
+  const std::string getName() const override { return "AANoFree"; }
+
+  /// See AbstractAttribute::getIdAddr()
+  const char *getIdAddr() const override { return &ID; }
+
+  /// This function should return true if the type of the \p AA is AANoFree
+  static bool classof(const AbstractAttribute *AA) {
+    return (AA->getIdAddr() == &ID);
+  }
+
+  /// Unique ID (due to the unique address)
+  static const char ID;
+};
+
+/// An AbstractAttribute for noreturn.
+struct AANoReturn
+    : public IRAttribute<Attribute::NoReturn,
+                         StateWrapper<BooleanState, AbstractAttribute>> {
+  AANoReturn(const IRPosition &IRP, Attributor &A) : IRAttribute(IRP) {}
+
+  /// Return true if the underlying object is assumed to never return.
+  bool isAssumedNoReturn() const { return getAssumed(); }
+
+  /// Return true if the underlying object is known to never return.
+  bool isKnownNoReturn() const { return getKnown(); }
+
+  /// Create an abstract attribute view for the position \p IRP.
+  static AANoReturn &createForPosition(const IRPosition &IRP, Attributor &A);
+
+  /// See AbstractAttribute::getName()
+  const std::string getName() const override { return "AANoReturn"; }
+
+  /// See AbstractAttribute::getIdAddr()
+  const char *getIdAddr() const override { return &ID; }
+
+  /// This function should return true if the type of the \p AA is AANoReturn
+  static bool classof(const AbstractAttribute *AA) {
+    return (AA->getIdAddr() == &ID);
+  }
+
+  /// Unique ID (due to the unique address)
+  static const char ID;
+};
+
+/// An abstract interface for liveness abstract attribute.
+struct AAIsDead : public StateWrapper<BooleanState, AbstractAttribute> {
+  using Base = StateWrapper<BooleanState, AbstractAttribute>;
+  AAIsDead(const IRPosition &IRP, Attributor &A) : Base(IRP) {}
+
+protected:
+  /// The query functions are protected such that other attributes need to go
+  /// through the Attributor interfaces: `Attributor::isAssumedDead(...)`
+
+  /// Returns true if the underlying value is assumed dead.
+  virtual bool isAssumedDead() const = 0;
+
+  /// Returns true if the underlying value is known dead.
+  virtual bool isKnownDead() const = 0;
+
+  /// Returns true if \p BB is assumed dead.
+  virtual bool isAssumedDead(const BasicBlock *BB) const = 0;
+
+  /// Returns true if \p BB is known dead.
+  virtual bool isKnownDead(const BasicBlock *BB) const = 0;
+
+  /// Returns true if \p I is assumed dead.
+  virtual bool isAssumedDead(const Instruction *I) const = 0;
+
+  /// Returns true if \p I is known dead.
+  virtual bool isKnownDead(const Instruction *I) const = 0;
+
+  /// This method is used to check if at least one instruction in a collection
+  /// of instructions is live.
+  template <typename T> bool isLiveInstSet(T begin, T end) const {
+    for (const auto &I : llvm::make_range(begin, end)) {
+      assert(I->getFunction() == getIRPosition().getAssociatedFunction() &&
+             "Instruction must be in the same anchor scope function.");
+
+      if (!isAssumedDead(I))
+        return true;
+    }
+
+    return false;
+  }
+
+public:
+  /// Create an abstract attribute view for the position \p IRP.
+  static AAIsDead &createForPosition(const IRPosition &IRP, Attributor &A);
+
+  /// Determine if \p F might catch asynchronous exceptions.
+  static bool mayCatchAsynchronousExceptions(const Function &F) {
+    return F.hasPersonalityFn() && !canSimplifyInvokeNoUnwind(&F);
+  }
+
+  /// Return if the edge from \p From BB to \p To BB is assumed dead.
+  /// This is specifically useful in AAReachability.
+  virtual bool isEdgeDead(const BasicBlock *From, const BasicBlock *To) const {
+    return false;
+  }
+
+  /// See AbstractAttribute::getName()
+  const std::string getName() const override { return "AAIsDead"; }
+
+  /// See AbstractAttribute::getIdAddr()
+  const char *getIdAddr() const override { return &ID; }
+
+  /// This function should return true if the type of the \p AA is AAIsDead
+  static bool classof(const AbstractAttribute *AA) {
+    return (AA->getIdAddr() == &ID);
+  }
+
+  /// Unique ID (due to the unique address)
+  static const char ID;
+
+  friend struct Attributor;
+};
+
+/// State for dereferenceable attribute
+struct DerefState : AbstractState {
+
+  static DerefState getBestState() { return DerefState(); }
+  static DerefState getBestState(const DerefState &) { return getBestState(); }
+
+  /// Return the worst possible representable state.
+  static DerefState getWorstState() {
+    DerefState DS;
+    DS.indicatePessimisticFixpoint();
+    return DS;
+  }
+  static DerefState getWorstState(const DerefState &) {
+    return getWorstState();
+  }
+
+  /// State representing for dereferenceable bytes.
+  IncIntegerState<> DerefBytesState;
+
+  /// Map representing for accessed memory offsets and sizes.
+  /// A key is Offset and a value is size.
+  /// If there is a load/store instruction something like,
+  ///   p[offset] = v;
+  /// (offset, sizeof(v)) will be inserted to this map.
+  /// std::map is used because we want to iterate keys in ascending order.
+  std::map<int64_t, uint64_t> AccessedBytesMap;
+
+  /// Helper function to calculate dereferenceable bytes from current known
+  /// bytes and accessed bytes.
+  ///
+  /// int f(int *A){
+  ///    *A = 0;
+  ///    *(A+2) = 2;
+  ///    *(A+1) = 1;
+  ///    *(A+10) = 10;
+  /// }
+  /// ```
+  /// In that case, AccessedBytesMap is `{0:4, 4:4, 8:4, 40:4}`.
+  /// AccessedBytesMap is std::map so it is iterated in accending order on
+  /// key(Offset). So KnownBytes will be updated like this:
+  ///
+  /// |Access | KnownBytes
+  /// |(0, 4)| 0 -> 4
+  /// |(4, 4)| 4 -> 8
+  /// |(8, 4)| 8 -> 12
+  /// |(40, 4) | 12 (break)
+  void computeKnownDerefBytesFromAccessedMap() {
+    int64_t KnownBytes = DerefBytesState.getKnown();
+    for (auto &Access : AccessedBytesMap) {
+      if (KnownBytes < Access.first)
+        break;
+      KnownBytes = std::max(KnownBytes, Access.first + (int64_t)Access.second);
+    }
+
+    DerefBytesState.takeKnownMaximum(KnownBytes);
+  }
+
+  /// State representing that whether the value is globaly dereferenceable.
+  BooleanState GlobalState;
+
+  /// See AbstractState::isValidState()
+  bool isValidState() const override { return DerefBytesState.isValidState(); }
+
+  /// See AbstractState::isAtFixpoint()
+  bool isAtFixpoint() const override {
+    return !isValidState() ||
+           (DerefBytesState.isAtFixpoint() && GlobalState.isAtFixpoint());
+  }
+
+  /// See AbstractState::indicateOptimisticFixpoint(...)
+  ChangeStatus indicateOptimisticFixpoint() override {
+    DerefBytesState.indicateOptimisticFixpoint();
+    GlobalState.indicateOptimisticFixpoint();
+    return ChangeStatus::UNCHANGED;
+  }
+
+  /// See AbstractState::indicatePessimisticFixpoint(...)
+  ChangeStatus indicatePessimisticFixpoint() override {
+    DerefBytesState.indicatePessimisticFixpoint();
+    GlobalState.indicatePessimisticFixpoint();
+    return ChangeStatus::CHANGED;
+  }
+
+  /// Update known dereferenceable bytes.
+  void takeKnownDerefBytesMaximum(uint64_t Bytes) {
+    DerefBytesState.takeKnownMaximum(Bytes);
+
+    // Known bytes might increase.
+    computeKnownDerefBytesFromAccessedMap();
+  }
+
+  /// Update assumed dereferenceable bytes.
+  void takeAssumedDerefBytesMinimum(uint64_t Bytes) {
+    DerefBytesState.takeAssumedMinimum(Bytes);
+  }
+
+  /// Add accessed bytes to the map.
+  void addAccessedBytes(int64_t Offset, uint64_t Size) {
+    uint64_t &AccessedBytes = AccessedBytesMap[Offset];
+    AccessedBytes = std::max(AccessedBytes, Size);
+
+    // Known bytes might increase.
+    computeKnownDerefBytesFromAccessedMap();
+  }
+
+  /// Equality for DerefState.
+  bool operator==(const DerefState &R) const {
+    return this->DerefBytesState == R.DerefBytesState &&
+           this->GlobalState == R.GlobalState;
+  }
+
+  /// Inequality for DerefState.
+  bool operator!=(const DerefState &R) const { return !(*this == R); }
+
+  /// See IntegerStateBase::operator^=
+  DerefState operator^=(const DerefState &R) {
+    DerefBytesState ^= R.DerefBytesState;
+    GlobalState ^= R.GlobalState;
+    return *this;
+  }
+
+  /// See IntegerStateBase::operator+=
+  DerefState operator+=(const DerefState &R) {
+    DerefBytesState += R.DerefBytesState;
+    GlobalState += R.GlobalState;
+    return *this;
+  }
+
+  /// See IntegerStateBase::operator&=
+  DerefState operator&=(const DerefState &R) {
+    DerefBytesState &= R.DerefBytesState;
+    GlobalState &= R.GlobalState;
+    return *this;
+  }
+
+  /// See IntegerStateBase::operator|=
+  DerefState operator|=(const DerefState &R) {
+    DerefBytesState |= R.DerefBytesState;
+    GlobalState |= R.GlobalState;
+    return *this;
+  }
+
+protected:
+  const AANonNull *NonNullAA = nullptr;
+};
+
+/// An abstract interface for all dereferenceable attribute.
+struct AADereferenceable
+    : public IRAttribute<Attribute::Dereferenceable,
+                         StateWrapper<DerefState, AbstractAttribute>> {
+  AADereferenceable(const IRPosition &IRP, Attributor &A) : IRAttribute(IRP) {}
+
+  /// Return true if we assume that the underlying value is nonnull.
+  bool isAssumedNonNull() const {
+    return NonNullAA && NonNullAA->isAssumedNonNull();
+  }
+
+  /// Return true if we know that the underlying value is nonnull.
+  bool isKnownNonNull() const {
+    return NonNullAA && NonNullAA->isKnownNonNull();
+  }
+
+  /// Return true if we assume that underlying value is
+  /// dereferenceable(_or_null) globally.
+  bool isAssumedGlobal() const { return GlobalState.getAssumed(); }
+
+  /// Return true if we know that underlying value is
+  /// dereferenceable(_or_null) globally.
+  bool isKnownGlobal() const { return GlobalState.getKnown(); }
+
+  /// Return assumed dereferenceable bytes.
+  uint32_t getAssumedDereferenceableBytes() const {
+    return DerefBytesState.getAssumed();
+  }
+
+  /// Return known dereferenceable bytes.
+  uint32_t getKnownDereferenceableBytes() const {
+    return DerefBytesState.getKnown();
+  }
+
+  /// Create an abstract attribute view for the position \p IRP.
+  static AADereferenceable &createForPosition(const IRPosition &IRP,
+                                              Attributor &A);
+
+  /// See AbstractAttribute::getName()
+  const std::string getName() const override { return "AADereferenceable"; }
+
+  /// See AbstractAttribute::getIdAddr()
+  const char *getIdAddr() const override { return &ID; }
+
+  /// This function should return true if the type of the \p AA is
+  /// AADereferenceable
+  static bool classof(const AbstractAttribute *AA) {
+    return (AA->getIdAddr() == &ID);
+  }
+
+  /// Unique ID (due to the unique address)
+  static const char ID;
+};
+
+using AAAlignmentStateType =
+    IncIntegerState<uint32_t, Value::MaximumAlignment, 0>;
+/// An abstract interface for all align attributes.
+struct AAAlign : public IRAttribute<
+                     Attribute::Alignment,
+                     StateWrapper<AAAlignmentStateType, AbstractAttribute>> {
+  AAAlign(const IRPosition &IRP, Attributor &A) : IRAttribute(IRP) {}
+
+  /// Return assumed alignment.
+  unsigned getAssumedAlign() const { return getAssumed(); }
+
+  /// Return known alignment.
+  unsigned getKnownAlign() const { return getKnown(); }
+
+  /// See AbstractAttribute::getName()
+  const std::string getName() const override { return "AAAlign"; }
+
+  /// See AbstractAttribute::getIdAddr()
+  const char *getIdAddr() const override { return &ID; }
+
+  /// This function should return true if the type of the \p AA is AAAlign
+  static bool classof(const AbstractAttribute *AA) {
+    return (AA->getIdAddr() == &ID);
+  }
+
+  /// Create an abstract attribute view for the position \p IRP.
+  static AAAlign &createForPosition(const IRPosition &IRP, Attributor &A);
+
+  /// Unique ID (due to the unique address)
+  static const char ID;
+};
+
+/// An abstract interface for all nocapture attributes.
+struct AANoCapture
+    : public IRAttribute<
+          Attribute::NoCapture,
+          StateWrapper<BitIntegerState<uint16_t, 7, 0>, AbstractAttribute>> {
+  AANoCapture(const IRPosition &IRP, Attributor &A) : IRAttribute(IRP) {}
+
+  /// State encoding bits. A set bit in the state means the property holds.
+  /// NO_CAPTURE is the best possible state, 0 the worst possible state.
+  enum {
+    NOT_CAPTURED_IN_MEM = 1 << 0,
+    NOT_CAPTURED_IN_INT = 1 << 1,
+    NOT_CAPTURED_IN_RET = 1 << 2,
+
+    /// If we do not capture the value in memory or through integers we can only
+    /// communicate it back as a derived pointer.
+    NO_CAPTURE_MAYBE_RETURNED = NOT_CAPTURED_IN_MEM | NOT_CAPTURED_IN_INT,
+
+    /// If we do not capture the value in memory, through integers, or as a
+    /// derived pointer we know it is not captured.
+    NO_CAPTURE =
+        NOT_CAPTURED_IN_MEM | NOT_CAPTURED_IN_INT | NOT_CAPTURED_IN_RET,
+  };
+
+  /// Return true if we know that the underlying value is not captured in its
+  /// respective scope.
+  bool isKnownNoCapture() const { return isKnown(NO_CAPTURE); }
+
+  /// Return true if we assume that the underlying value is not captured in its
+  /// respective scope.
+  bool isAssumedNoCapture() const { return isAssumed(NO_CAPTURE); }
+
+  /// Return true if we know that the underlying value is not captured in its
+  /// respective scope but we allow it to escape through a "return".
+  bool isKnownNoCaptureMaybeReturned() const {
+    return isKnown(NO_CAPTURE_MAYBE_RETURNED);
+  }
+
+  /// Return true if we assume that the underlying value is not captured in its
+  /// respective scope but we allow it to escape through a "return".
+  bool isAssumedNoCaptureMaybeReturned() const {
+    return isAssumed(NO_CAPTURE_MAYBE_RETURNED);
+  }
+
+  /// Create an abstract attribute view for the position \p IRP.
+  static AANoCapture &createForPosition(const IRPosition &IRP, Attributor &A);
+
+  /// See AbstractAttribute::getName()
+  const std::string getName() const override { return "AANoCapture"; }
+
+  /// See AbstractAttribute::getIdAddr()
+  const char *getIdAddr() const override { return &ID; }
+
+  /// This function should return true if the type of the \p AA is AANoCapture
+  static bool classof(const AbstractAttribute *AA) {
+    return (AA->getIdAddr() == &ID);
+  }
+
+  /// Unique ID (due to the unique address)
+  static const char ID;
+};
+
+/// An abstract interface for value simplify abstract attribute.
+struct AAValueSimplify : public StateWrapper<BooleanState, AbstractAttribute> {
+  using Base = StateWrapper<BooleanState, AbstractAttribute>;
+  AAValueSimplify(const IRPosition &IRP, Attributor &A) : Base(IRP) {}
+
+  /// Return an assumed simplified value if a single candidate is found. If
+  /// there cannot be one, return original value. If it is not clear yet, return
+  /// the Optional::NoneType.
+  virtual Optional<Value *> getAssumedSimplifiedValue(Attributor &A) const = 0;
+
+  /// Create an abstract attribute view for the position \p IRP.
+  static AAValueSimplify &createForPosition(const IRPosition &IRP,
+                                            Attributor &A);
+
+  /// See AbstractAttribute::getName()
+  const std::string getName() const override { return "AAValueSimplify"; }
+
+  /// See AbstractAttribute::getIdAddr()
+  const char *getIdAddr() const override { return &ID; }
+
+  /// This function should return true if the type of the \p AA is
+  /// AAValueSimplify
+  static bool classof(const AbstractAttribute *AA) {
+    return (AA->getIdAddr() == &ID);
+  }
+
+  /// Unique ID (due to the unique address)
+  static const char ID;
+};
+
+struct AAHeapToStack : public StateWrapper<BooleanState, AbstractAttribute> {
+  using Base = StateWrapper<BooleanState, AbstractAttribute>;
+  AAHeapToStack(const IRPosition &IRP, Attributor &A) : Base(IRP) {}
+
+  /// Returns true if HeapToStack conversion is assumed to be possible.
+  bool isAssumedHeapToStack() const { return getAssumed(); }
+
+  /// Returns true if HeapToStack conversion is known to be possible.
+  bool isKnownHeapToStack() const { return getKnown(); }
+
+  /// Create an abstract attribute view for the position \p IRP.
+  static AAHeapToStack &createForPosition(const IRPosition &IRP, Attributor &A);
+
+  /// See AbstractAttribute::getName()
+  const std::string getName() const override { return "AAHeapToStack"; }
+
+  /// See AbstractAttribute::getIdAddr()
+  const char *getIdAddr() const override { return &ID; }
+
+  /// This function should return true if the type of the \p AA is AAHeapToStack
+  static bool classof(const AbstractAttribute *AA) {
+    return (AA->getIdAddr() == &ID);
+  }
+
+  /// Unique ID (due to the unique address)
+  static const char ID;
+};
+
+/// An abstract interface for privatizability.
+///
+/// A pointer is privatizable if it can be replaced by a new, private one.
+/// Privatizing pointer reduces the use count, interaction between unrelated
+/// code parts.
+///
+/// In order for a pointer to be privatizable its value cannot be observed
+/// (=nocapture), it is (for now) not written (=readonly & noalias), we know
+/// what values are necessary to make the private copy look like the original
+/// one, and the values we need can be loaded (=dereferenceable).
+struct AAPrivatizablePtr
+    : public StateWrapper<BooleanState, AbstractAttribute> {
+  using Base = StateWrapper<BooleanState, AbstractAttribute>;
+  AAPrivatizablePtr(const IRPosition &IRP, Attributor &A) : Base(IRP) {}
+
+  /// Returns true if pointer privatization is assumed to be possible.
+  bool isAssumedPrivatizablePtr() const { return getAssumed(); }
+
+  /// Returns true if pointer privatization is known to be possible.
+  bool isKnownPrivatizablePtr() const { return getKnown(); }
+
+  /// Return the type we can choose for a private copy of the underlying
+  /// value. None means it is not clear yet, nullptr means there is none.
+  virtual Optional<Type *> getPrivatizableType() const = 0;
+
+  /// Create an abstract attribute view for the position \p IRP.
+  static AAPrivatizablePtr &createForPosition(const IRPosition &IRP,
+                                              Attributor &A);
+
+  /// See AbstractAttribute::getName()
+  const std::string getName() const override { return "AAPrivatizablePtr"; }
+
+  /// See AbstractAttribute::getIdAddr()
+  const char *getIdAddr() const override { return &ID; }
+
+  /// This function should return true if the type of the \p AA is
+  /// AAPricatizablePtr
+  static bool classof(const AbstractAttribute *AA) {
+    return (AA->getIdAddr() == &ID);
+  }
+
+  /// Unique ID (due to the unique address)
+  static const char ID;
+};
+
+/// An abstract interface for memory access kind related attributes
+/// (readnone/readonly/writeonly).
+struct AAMemoryBehavior
+    : public IRAttribute<
+          Attribute::ReadNone,
+          StateWrapper<BitIntegerState<uint8_t, 3>, AbstractAttribute>> {
+  AAMemoryBehavior(const IRPosition &IRP, Attributor &A) : IRAttribute(IRP) {}
+
+  /// State encoding bits. A set bit in the state means the property holds.
+  /// BEST_STATE is the best possible state, 0 the worst possible state.
+  enum {
+    NO_READS = 1 << 0,
+    NO_WRITES = 1 << 1,
+    NO_ACCESSES = NO_READS | NO_WRITES,
+
+    BEST_STATE = NO_ACCESSES,
+  };
+  static_assert(BEST_STATE == getBestState(), "Unexpected BEST_STATE value");
+
+  /// Return true if we know that the underlying value is not read or accessed
+  /// in its respective scope.
+  bool isKnownReadNone() const { return isKnown(NO_ACCESSES); }
+
+  /// Return true if we assume that the underlying value is not read or accessed
+  /// in its respective scope.
+  bool isAssumedReadNone() const { return isAssumed(NO_ACCESSES); }
+
+  /// Return true if we know that the underlying value is not accessed
+  /// (=written) in its respective scope.
+  bool isKnownReadOnly() const { return isKnown(NO_WRITES); }
+
+  /// Return true if we assume that the underlying value is not accessed
+  /// (=written) in its respective scope.
+  bool isAssumedReadOnly() const { return isAssumed(NO_WRITES); }
+
+  /// Return true if we know that the underlying value is not read in its
+  /// respective scope.
+  bool isKnownWriteOnly() const { return isKnown(NO_READS); }
+
+  /// Return true if we assume that the underlying value is not read in its
+  /// respective scope.
+  bool isAssumedWriteOnly() const { return isAssumed(NO_READS); }
+
+  /// Create an abstract attribute view for the position \p IRP.
+  static AAMemoryBehavior &createForPosition(const IRPosition &IRP,
+                                             Attributor &A);
+
+  /// See AbstractAttribute::getName()
+  const std::string getName() const override { return "AAMemoryBehavior"; }
+
+  /// See AbstractAttribute::getIdAddr()
+  const char *getIdAddr() const override { return &ID; }
+
+  /// This function should return true if the type of the \p AA is
+  /// AAMemoryBehavior
+  static bool classof(const AbstractAttribute *AA) {
+    return (AA->getIdAddr() == &ID);
+  }
+
+  /// Unique ID (due to the unique address)
+  static const char ID;
+};
+
+/// An abstract interface for all memory location attributes
+/// (readnone/argmemonly/inaccessiblememonly/inaccessibleorargmemonly).
+struct AAMemoryLocation
+    : public IRAttribute<
+          Attribute::ReadNone,
+          StateWrapper<BitIntegerState<uint32_t, 511>, AbstractAttribute>> {
+  using MemoryLocationsKind = StateType::base_t;
+
+  AAMemoryLocation(const IRPosition &IRP, Attributor &A) : IRAttribute(IRP) {}
+
+  /// Encoding of different locations that could be accessed by a memory
+  /// access.
+  enum {
+    ALL_LOCATIONS = 0,
+    NO_LOCAL_MEM = 1 << 0,
+    NO_CONST_MEM = 1 << 1,
+    NO_GLOBAL_INTERNAL_MEM = 1 << 2,
+    NO_GLOBAL_EXTERNAL_MEM = 1 << 3,
+    NO_GLOBAL_MEM = NO_GLOBAL_INTERNAL_MEM | NO_GLOBAL_EXTERNAL_MEM,
+    NO_ARGUMENT_MEM = 1 << 4,
+    NO_INACCESSIBLE_MEM = 1 << 5,
+    NO_MALLOCED_MEM = 1 << 6,
+    NO_UNKOWN_MEM = 1 << 7,
+    NO_LOCATIONS = NO_LOCAL_MEM | NO_CONST_MEM | NO_GLOBAL_INTERNAL_MEM |
+                   NO_GLOBAL_EXTERNAL_MEM | NO_ARGUMENT_MEM |
+                   NO_INACCESSIBLE_MEM | NO_MALLOCED_MEM | NO_UNKOWN_MEM,
+
+    // Helper bit to track if we gave up or not.
+    VALID_STATE = NO_LOCATIONS + 1,
+
+    BEST_STATE = NO_LOCATIONS | VALID_STATE,
+  };
+  static_assert(BEST_STATE == getBestState(), "Unexpected BEST_STATE value");
+
+  /// Return true if we know that the associated functions has no observable
+  /// accesses.
+  bool isKnownReadNone() const { return isKnown(NO_LOCATIONS); }
+
+  /// Return true if we assume that the associated functions has no observable
+  /// accesses.
+  bool isAssumedReadNone() const {
+    return isAssumed(NO_LOCATIONS) | isAssumedStackOnly();
+  }
+
+  /// Return true if we know that the associated functions has at most
+  /// local/stack accesses.
+  bool isKnowStackOnly() const {
+    return isKnown(inverseLocation(NO_LOCAL_MEM, true, true));
+  }
+
+  /// Return true if we assume that the associated functions has at most
+  /// local/stack accesses.
+  bool isAssumedStackOnly() const {
+    return isAssumed(inverseLocation(NO_LOCAL_MEM, true, true));
+  }
+
+  /// Return true if we know that the underlying value will only access
+  /// inaccesible memory only (see Attribute::InaccessibleMemOnly).
+  bool isKnownInaccessibleMemOnly() const {
+    return isKnown(inverseLocation(NO_INACCESSIBLE_MEM, true, true));
+  }
+
+  /// Return true if we assume that the underlying value will only access
+  /// inaccesible memory only (see Attribute::InaccessibleMemOnly).
+  bool isAssumedInaccessibleMemOnly() const {
+    return isAssumed(inverseLocation(NO_INACCESSIBLE_MEM, true, true));
+  }
+
+  /// Return true if we know that the underlying value will only access
+  /// argument pointees (see Attribute::ArgMemOnly).
+  bool isKnownArgMemOnly() const {
+    return isKnown(inverseLocation(NO_ARGUMENT_MEM, true, true));
+  }
+
+  /// Return true if we assume that the underlying value will only access
+  /// argument pointees (see Attribute::ArgMemOnly).
+  bool isAssumedArgMemOnly() const {
+    return isAssumed(inverseLocation(NO_ARGUMENT_MEM, true, true));
+  }
+
+  /// Return true if we know that the underlying value will only access
+  /// inaccesible memory or argument pointees (see
+  /// Attribute::InaccessibleOrArgMemOnly).
+  bool isKnownInaccessibleOrArgMemOnly() const {
+    return isKnown(
+        inverseLocation(NO_INACCESSIBLE_MEM | NO_ARGUMENT_MEM, true, true));
+  }
+
+  /// Return true if we assume that the underlying value will only access
+  /// inaccesible memory or argument pointees (see
+  /// Attribute::InaccessibleOrArgMemOnly).
+  bool isAssumedInaccessibleOrArgMemOnly() const {
+    return isAssumed(
+        inverseLocation(NO_INACCESSIBLE_MEM | NO_ARGUMENT_MEM, true, true));
+  }
+
+  /// Return true if the underlying value may access memory through arguement
+  /// pointers of the associated function, if any.
+  bool mayAccessArgMem() const { return !isAssumed(NO_ARGUMENT_MEM); }
+
+  /// Return true if only the memory locations specififed by \p MLK are assumed
+  /// to be accessed by the associated function.
+  bool isAssumedSpecifiedMemOnly(MemoryLocationsKind MLK) const {
+    return isAssumed(MLK);
+  }
+
+  /// Return the locations that are assumed to be not accessed by the associated
+  /// function, if any.
+  MemoryLocationsKind getAssumedNotAccessedLocation() const {
+    return getAssumed();
+  }
+
+  /// Return the inverse of location \p Loc, thus for NO_XXX the return
+  /// describes ONLY_XXX. The flags \p AndLocalMem and \p AndConstMem determine
+  /// if local (=stack) and constant memory are allowed as well. Most of the
+  /// time we do want them to be included, e.g., argmemonly allows accesses via
+  /// argument pointers or local or constant memory accesses.
+  static MemoryLocationsKind
+  inverseLocation(MemoryLocationsKind Loc, bool AndLocalMem, bool AndConstMem) {
+    return NO_LOCATIONS & ~(Loc | (AndLocalMem ? NO_LOCAL_MEM : 0) |
+                            (AndConstMem ? NO_CONST_MEM : 0));
+  };
+
+  /// Return the locations encoded by \p MLK as a readable string.
+  static std::string getMemoryLocationsAsStr(MemoryLocationsKind MLK);
+
+  /// Simple enum to distinguish read/write/read-write accesses.
+  enum AccessKind {
+    NONE = 0,
+    READ = 1 << 0,
+    WRITE = 1 << 1,
+    READ_WRITE = READ | WRITE,
+  };
+
+  /// Check \p Pred on all accesses to the memory kinds specified by \p MLK.
+  ///
+  /// This method will evaluate \p Pred on all accesses (access instruction +
+  /// underlying accessed memory pointer) and it will return true if \p Pred
+  /// holds every time.
+  virtual bool checkForAllAccessesToMemoryKind(
+      function_ref<bool(const Instruction *, const Value *, AccessKind,
+                        MemoryLocationsKind)>
+          Pred,
+      MemoryLocationsKind MLK) const = 0;
+
+  /// Create an abstract attribute view for the position \p IRP.
+  static AAMemoryLocation &createForPosition(const IRPosition &IRP,
+                                             Attributor &A);
+
+  /// See AbstractState::getAsStr().
+  const std::string getAsStr() const override {
+    return getMemoryLocationsAsStr(getAssumedNotAccessedLocation());
+  }
+
+  /// See AbstractAttribute::getName()
+  const std::string getName() const override { return "AAMemoryLocation"; }
+
+  /// See AbstractAttribute::getIdAddr()
+  const char *getIdAddr() const override { return &ID; }
+
+  /// This function should return true if the type of the \p AA is
+  /// AAMemoryLocation
+  static bool classof(const AbstractAttribute *AA) {
+    return (AA->getIdAddr() == &ID);
+  }
+
+  /// Unique ID (due to the unique address)
+  static const char ID;
+};
+
+/// An abstract interface for range value analysis.
+struct AAValueConstantRange
+    : public StateWrapper<IntegerRangeState, AbstractAttribute, uint32_t> {
+  using Base = StateWrapper<IntegerRangeState, AbstractAttribute, uint32_t>;
+  AAValueConstantRange(const IRPosition &IRP, Attributor &A)
+      : Base(IRP, IRP.getAssociatedType()->getIntegerBitWidth()) {}
+
+  /// See AbstractAttribute::getState(...).
+  IntegerRangeState &getState() override { return *this; }
+  const IntegerRangeState &getState() const override { return *this; }
+
+  /// Create an abstract attribute view for the position \p IRP.
+  static AAValueConstantRange &createForPosition(const IRPosition &IRP,
+                                                 Attributor &A);
+
+  /// Return an assumed range for the assocaited value a program point \p CtxI.
+  /// If \p I is nullptr, simply return an assumed range.
+  virtual ConstantRange
+  getAssumedConstantRange(Attributor &A,
+                          const Instruction *CtxI = nullptr) const = 0;
+
+  /// Return a known range for the assocaited value at a program point \p CtxI.
+  /// If \p I is nullptr, simply return a known range.
+  virtual ConstantRange
+  getKnownConstantRange(Attributor &A,
+                        const Instruction *CtxI = nullptr) const = 0;
+
+  /// Return an assumed constant for the assocaited value a program point \p
+  /// CtxI.
+  Optional<ConstantInt *>
+  getAssumedConstantInt(Attributor &A,
+                        const Instruction *CtxI = nullptr) const {
+    ConstantRange RangeV = getAssumedConstantRange(A, CtxI);
+    if (auto *C = RangeV.getSingleElement())
+      return cast<ConstantInt>(
+          ConstantInt::get(getAssociatedValue().getType(), *C));
+    if (RangeV.isEmptySet())
+      return llvm::None;
+    return nullptr;
+  }
+
+  /// See AbstractAttribute::getName()
+  const std::string getName() const override { return "AAValueConstantRange"; }
+
+  /// See AbstractAttribute::getIdAddr()
+  const char *getIdAddr() const override { return &ID; }
+
+  /// This function should return true if the type of the \p AA is
+  /// AAValueConstantRange
+  static bool classof(const AbstractAttribute *AA) {
+    return (AA->getIdAddr() == &ID);
+  }
+
+  /// Unique ID (due to the unique address)
+  static const char ID;
+};
+
+/// A class for a set state.
+/// The assumed boolean state indicates whether the corresponding set is full
+/// set or not. If the assumed state is false, this is the worst state. The
+/// worst state (invalid state) of set of potential values is when the set
+/// contains every possible value (i.e. we cannot in any way limit the value
+/// that the target position can take). That never happens naturally, we only
+/// force it. As for the conditions under which we force it, see
+/// AAPotentialValues.
+template <typename MemberTy, typename KeyInfo = DenseMapInfo<MemberTy>>
+struct PotentialValuesState : AbstractState {
+  using SetTy = DenseSet<MemberTy, KeyInfo>;
+
+  PotentialValuesState() : IsValidState(true), UndefIsContained(false) {}
+
+  PotentialValuesState(bool IsValid)
+      : IsValidState(IsValid), UndefIsContained(false) {}
+
+  /// See AbstractState::isValidState(...)
+  bool isValidState() const override { return IsValidState.isValidState(); }
+
+  /// See AbstractState::isAtFixpoint(...)
+  bool isAtFixpoint() const override { return IsValidState.isAtFixpoint(); }
+
+  /// See AbstractState::indicatePessimisticFixpoint(...)
+  ChangeStatus indicatePessimisticFixpoint() override {
+    return IsValidState.indicatePessimisticFixpoint();
+  }
+
+  /// See AbstractState::indicateOptimisticFixpoint(...)
+  ChangeStatus indicateOptimisticFixpoint() override {
+    return IsValidState.indicateOptimisticFixpoint();
+  }
+
+  /// Return the assumed state
+  PotentialValuesState &getAssumed() { return *this; }
+  const PotentialValuesState &getAssumed() const { return *this; }
+
+  /// Return this set. We should check whether this set is valid or not by
+  /// isValidState() before calling this function.
+  const SetTy &getAssumedSet() const {
+    assert(isValidState() && "This set shoud not be used when it is invalid!");
+    return Set;
+  }
+
+  /// Returns whether this state contains an undef value or not.
+  bool undefIsContained() const {
+    assert(isValidState() && "This flag shoud not be used when it is invalid!");
+    return UndefIsContained;
+  }
+
+  bool operator==(const PotentialValuesState &RHS) const {
+    if (isValidState() != RHS.isValidState())
+      return false;
+    if (!isValidState() && !RHS.isValidState())
+      return true;
+    if (undefIsContained() != RHS.undefIsContained())
+      return false;
+    return Set == RHS.getAssumedSet();
+  }
+
+  /// Maximum number of potential values to be tracked.
+  /// This is set by -attributor-max-potential-values command line option
+  static unsigned MaxPotentialValues;
+
+  /// Return empty set as the best state of potential values.
+  static PotentialValuesState getBestState() {
+    return PotentialValuesState(true);
+  }
+
+  static PotentialValuesState getBestState(PotentialValuesState &PVS) {
+    return getBestState();
+  }
+
+  /// Return full set as the worst state of potential values.
+  static PotentialValuesState getWorstState() {
+    return PotentialValuesState(false);
+  }
+
+  /// Union assumed set with the passed value.
+  void unionAssumed(const MemberTy &C) { insert(C); }
+
+  /// Union assumed set with assumed set of the passed state \p PVS.
+  void unionAssumed(const PotentialValuesState &PVS) { unionWith(PVS); }
+
+  /// Union assumed set with an undef value.
+  void unionAssumedWithUndef() { unionWithUndef(); }
+
+  /// "Clamp" this state with \p PVS.
+  PotentialValuesState operator^=(const PotentialValuesState &PVS) {
+    IsValidState ^= PVS.IsValidState;
+    unionAssumed(PVS);
+    return *this;
+  }
+
+  PotentialValuesState operator&=(const PotentialValuesState &PVS) {
+    IsValidState &= PVS.IsValidState;
+    unionAssumed(PVS);
+    return *this;
+  }
+
+private:
+  /// Check the size of this set, and invalidate when the size is no
+  /// less than \p MaxPotentialValues threshold.
+  void checkAndInvalidate() {
+    if (Set.size() >= MaxPotentialValues)
+      indicatePessimisticFixpoint();
+  }
+
+  /// If this state contains both undef and not undef, we can reduce
+  /// undef to the not undef value.
+  void reduceUndefValue() { UndefIsContained = UndefIsContained & Set.empty(); }
+
+  /// Insert an element into this set.
+  void insert(const MemberTy &C) {
+    if (!isValidState())
+      return;
+    Set.insert(C);
+    checkAndInvalidate();
+  }
+
+  /// Take union with R.
+  void unionWith(const PotentialValuesState &R) {
+    /// If this is a full set, do nothing.;
+    if (!isValidState())
+      return;
+    /// If R is full set, change L to a full set.
+    if (!R.isValidState()) {
+      indicatePessimisticFixpoint();
+      return;
+    }
+    for (const MemberTy &C : R.Set)
+      Set.insert(C);
+    UndefIsContained |= R.undefIsContained();
+    reduceUndefValue();
+    checkAndInvalidate();
+  }
+
+  /// Take union with an undef value.
+  void unionWithUndef() {
+    UndefIsContained = true;
+    reduceUndefValue();
+  }
+
+  /// Take intersection with R.
+  void intersectWith(const PotentialValuesState &R) {
+    /// If R is a full set, do nothing.
+    if (!R.isValidState())
+      return;
+    /// If this is a full set, change this to R.
+    if (!isValidState()) {
+      *this = R;
+      return;
+    }
+    SetTy IntersectSet;
+    for (const MemberTy &C : Set) {
+      if (R.Set.count(C))
+        IntersectSet.insert(C);
+    }
+    Set = IntersectSet;
+    UndefIsContained &= R.undefIsContained();
+    reduceUndefValue();
+  }
+
+  /// A helper state which indicate whether this state is valid or not.
+  BooleanState IsValidState;
+
+  /// Container for potential values
+  SetTy Set;
+
+  /// Flag for undef value
+  bool UndefIsContained;
+};
+
+using PotentialConstantIntValuesState = PotentialValuesState<APInt>;
+
+raw_ostream &operator<<(raw_ostream &OS,
+                        const PotentialConstantIntValuesState &R);
+
+/// An abstract interface for potential values analysis.
+///
+/// This AA collects potential values for each IR position.
+/// An assumed set of potential values is initialized with the empty set (the
+/// best state) and it will grow monotonically as we find more potential values
+/// for this position.
+/// The set might be forced to the worst state, that is, to contain every
+/// possible value for this position in 2 cases.
+///   1. We surpassed the \p MaxPotentialValues threshold. This includes the
+///      case that this position is affected (e.g. because of an operation) by a
+///      Value that is in the worst state.
+///   2. We tried to initialize on a Value that we cannot handle (e.g. an
+///      operator we do not currently handle).
+///
+/// TODO: Support values other than constant integers.
+struct AAPotentialValues
+    : public StateWrapper<PotentialConstantIntValuesState, AbstractAttribute> {
+  using Base = StateWrapper<PotentialConstantIntValuesState, AbstractAttribute>;
+  AAPotentialValues(const IRPosition &IRP, Attributor &A) : Base(IRP) {}
+
+  /// See AbstractAttribute::getState(...).
+  PotentialConstantIntValuesState &getState() override { return *this; }
+  const PotentialConstantIntValuesState &getState() const override {
+    return *this;
+  }
+
+  /// Create an abstract attribute view for the position \p IRP.
+  static AAPotentialValues &createForPosition(const IRPosition &IRP,
+                                              Attributor &A);
+
+  /// Return assumed constant for the associated value
+  Optional<ConstantInt *>
+  getAssumedConstantInt(Attributor &A,
+                        const Instruction *CtxI = nullptr) const {
+    if (!isValidState())
+      return nullptr;
+    if (getAssumedSet().size() == 1)
+      return cast<ConstantInt>(ConstantInt::get(getAssociatedValue().getType(),
+                                                *(getAssumedSet().begin())));
+    if (getAssumedSet().size() == 0) {
+      if (undefIsContained())
+        return cast<ConstantInt>(
+            ConstantInt::get(getAssociatedValue().getType(), 0));
+      return llvm::None;
+    }
+
+    return nullptr;
+  }
+
+  /// See AbstractAttribute::getName()
+  const std::string getName() const override { return "AAPotentialValues"; }
+
+  /// See AbstractAttribute::getIdAddr()
+  const char *getIdAddr() const override { return &ID; }
+
+  /// This function should return true if the type of the \p AA is
+  /// AAPotentialValues
+  static bool classof(const AbstractAttribute *AA) {
+    return (AA->getIdAddr() == &ID);
+  }
+
+  /// Unique ID (due to the unique address)
+  static const char ID;
+};
+
+/// An abstract interface for all noundef attributes.
+struct AANoUndef
+    : public IRAttribute<Attribute::NoUndef,
+                         StateWrapper<BooleanState, AbstractAttribute>> {
+  AANoUndef(const IRPosition &IRP, Attributor &A) : IRAttribute(IRP) {}
+
+  /// Return true if we assume that the underlying value is noundef.
+  bool isAssumedNoUndef() const { return getAssumed(); }
+
+  /// Return true if we know that underlying value is noundef.
+  bool isKnownNoUndef() const { return getKnown(); }
+
+  /// Create an abstract attribute view for the position \p IRP.
+  static AANoUndef &createForPosition(const IRPosition &IRP, Attributor &A);
+
+  /// See AbstractAttribute::getName()
+  const std::string getName() const override { return "AANoUndef"; }
+
+  /// See AbstractAttribute::getIdAddr()
+  const char *getIdAddr() const override { return &ID; }
+
+  /// This function should return true if the type of the \p AA is AANoUndef
+  static bool classof(const AbstractAttribute *AA) {
+    return (AA->getIdAddr() == &ID);
+  }
+
+  /// Unique ID (due to the unique address)
+  static const char ID;
+};
+
+/// Run options, used by the pass manager.
+enum AttributorRunOption {
+  NONE = 0,
+  MODULE = 1 << 0,
+  CGSCC = 1 << 1,
+  ALL = MODULE | CGSCC
 };
 
 } // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/Transforms/IPO/BlockExtractor.h b/linux-x64/clang/include/llvm/Transforms/IPO/BlockExtractor.h
new file mode 100644
index 0000000..deeb5eb
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Transforms/IPO/BlockExtractor.h
@@ -0,0 +1,25 @@
+//===- BlockExtractor.h - Extracts blocks into their own functions --------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This pass extracts the specified basic blocks from the module into their
+// own functions.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_IPO_BLOCKEXTRACTOR_H
+#define LLVM_TRANSFORMS_IPO_BLOCKEXTRACTOR_H
+
+#include "llvm/IR/PassManager.h"
+
+namespace llvm {
+struct BlockExtractorPass : PassInfoMixin<BlockExtractorPass> {
+  PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+};
+} // namespace llvm
+
+#endif // LLVM_TRANSFORMS_IPO_BLOCKEXTRACTOR_H
diff --git a/linux-x64/clang/include/llvm/Transforms/IPO/CalledValuePropagation.h b/linux-x64/clang/include/llvm/Transforms/IPO/CalledValuePropagation.h
index c2626d0..7826337 100644
--- a/linux-x64/clang/include/llvm/Transforms/IPO/CalledValuePropagation.h
+++ b/linux-x64/clang/include/llvm/Transforms/IPO/CalledValuePropagation.h
@@ -19,7 +19,6 @@
 #ifndef LLVM_TRANSFORMS_IPO_CALLEDVALUEPROPAGATION_H
 #define LLVM_TRANSFORMS_IPO_CALLEDVALUEPROPAGATION_H
 
-#include "llvm/IR/Module.h"
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
diff --git a/linux-x64/clang/include/llvm/Transforms/IPO/CrossDSOCFI.h b/linux-x64/clang/include/llvm/Transforms/IPO/CrossDSOCFI.h
index 8440df6..d34a510 100644
--- a/linux-x64/clang/include/llvm/Transforms/IPO/CrossDSOCFI.h
+++ b/linux-x64/clang/include/llvm/Transforms/IPO/CrossDSOCFI.h
@@ -14,7 +14,6 @@
 #ifndef LLVM_TRANSFORMS_IPO_CROSSDSOCFI_H
 #define LLVM_TRANSFORMS_IPO_CROSSDSOCFI_H
 
-#include "llvm/IR/Module.h"
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
diff --git a/linux-x64/clang/include/llvm/Transforms/IPO/DeadArgumentElimination.h b/linux-x64/clang/include/llvm/Transforms/IPO/DeadArgumentElimination.h
index 73797bc..496ceea 100644
--- a/linux-x64/clang/include/llvm/Transforms/IPO/DeadArgumentElimination.h
+++ b/linux-x64/clang/include/llvm/Transforms/IPO/DeadArgumentElimination.h
@@ -128,6 +128,7 @@
   Liveness SurveyUses(const Value *V, UseVector &MaybeLiveUses);
 
   void SurveyFunction(const Function &F);
+  bool IsLive(const RetOrArg &RA);
   void MarkValue(const RetOrArg &RA, Liveness L,
                  const UseVector &MaybeLiveUses);
   void MarkLive(const RetOrArg &RA);
diff --git a/linux-x64/clang/include/llvm/Transforms/IPO/ForceFunctionAttrs.h b/linux-x64/clang/include/llvm/Transforms/IPO/ForceFunctionAttrs.h
index 7379009..fd99843 100644
--- a/linux-x64/clang/include/llvm/Transforms/IPO/ForceFunctionAttrs.h
+++ b/linux-x64/clang/include/llvm/Transforms/IPO/ForceFunctionAttrs.h
@@ -13,7 +13,6 @@
 #ifndef LLVM_TRANSFORMS_IPO_FORCEFUNCTIONATTRS_H
 #define LLVM_TRANSFORMS_IPO_FORCEFUNCTIONATTRS_H
 
-#include "llvm/IR/Module.h"
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
diff --git a/linux-x64/clang/include/llvm/Transforms/IPO/FunctionImport.h b/linux-x64/clang/include/llvm/Transforms/IPO/FunctionImport.h
index bbf270c..6eaf82a 100644
--- a/linux-x64/clang/include/llvm/Transforms/IPO/FunctionImport.h
+++ b/linux-x64/clang/include/llvm/Transforms/IPO/FunctionImport.h
@@ -98,15 +98,17 @@
   using ImportMapTy = StringMap<FunctionsToImportTy>;
 
   /// The set contains an entry for every global value the module exports.
-  using ExportSetTy = std::unordered_set<GlobalValue::GUID>;
+  using ExportSetTy = DenseSet<ValueInfo>;
 
   /// A function of this type is used to load modules referenced by the index.
   using ModuleLoaderTy =
       std::function<Expected<std::unique_ptr<Module>>(StringRef Identifier)>;
 
   /// Create a Function Importer.
-  FunctionImporter(const ModuleSummaryIndex &Index, ModuleLoaderTy ModuleLoader)
-      : Index(Index), ModuleLoader(std::move(ModuleLoader)) {}
+  FunctionImporter(const ModuleSummaryIndex &Index, ModuleLoaderTy ModuleLoader,
+                   bool ClearDSOLocalOnDeclarations)
+      : Index(Index), ModuleLoader(std::move(ModuleLoader)),
+        ClearDSOLocalOnDeclarations(ClearDSOLocalOnDeclarations) {}
 
   /// Import functions in Module \p M based on the supplied import list.
   Expected<bool> importFunctions(Module &M, const ImportMapTy &ImportList);
@@ -117,6 +119,10 @@
 
   /// Factory function to load a Module for a given identifier
   ModuleLoaderTy ModuleLoader;
+
+  /// See the comment of ClearDSOLocalOnDeclarations in
+  /// Utils/FunctionImportUtils.h.
+  bool ClearDSOLocalOnDeclarations;
 };
 
 /// The function importing pass
diff --git a/linux-x64/clang/include/llvm/Transforms/IPO/GlobalDCE.h b/linux-x64/clang/include/llvm/Transforms/IPO/GlobalDCE.h
index c434484..0a68518 100644
--- a/linux-x64/clang/include/llvm/Transforms/IPO/GlobalDCE.h
+++ b/linux-x64/clang/include/llvm/Transforms/IPO/GlobalDCE.h
@@ -43,11 +43,25 @@
   /// Comdat -> Globals in that Comdat section.
   std::unordered_multimap<Comdat *, GlobalValue *> ComdatMembers;
 
+  /// !type metadata -> set of (vtable, offset) pairs
+  DenseMap<Metadata *, SmallSet<std::pair<GlobalVariable *, uint64_t>, 4>>
+      TypeIdMap;
+
+  // Global variables which are vtables, and which we have enough information
+  // about to safely do dead virtual function elimination.
+  SmallPtrSet<GlobalValue *, 32> VFESafeVTables;
+
   void UpdateGVDependencies(GlobalValue &GV);
   void MarkLive(GlobalValue &GV,
                 SmallVectorImpl<GlobalValue *> *Updates = nullptr);
   bool RemoveUnusedGlobalValue(GlobalValue &GV);
 
+  // Dead virtual function elimination.
+  void AddVirtualFunctionDependencies(Module &M);
+  void ScanVTables(Module &M);
+  void ScanTypeCheckedLoadIntrinsics(Module &M);
+  void ScanVTableLoad(Function *Caller, Metadata *TypeId, uint64_t CallOffset);
+
   void ComputeDependencies(Value *V, SmallPtrSetImpl<GlobalValue *> &U);
 };
 
diff --git a/linux-x64/clang/include/llvm/Transforms/IPO/HotColdSplitting.h b/linux-x64/clang/include/llvm/Transforms/IPO/HotColdSplitting.h
index 7366884..8c3049f 100644
--- a/linux-x64/clang/include/llvm/Transforms/IPO/HotColdSplitting.h
+++ b/linux-x64/clang/include/llvm/Transforms/IPO/HotColdSplitting.h
@@ -17,6 +17,45 @@
 namespace llvm {
 
 class Module;
+class ProfileSummaryInfo;
+class BlockFrequencyInfo;
+class TargetTransformInfo;
+class OptimizationRemarkEmitter;
+class AssumptionCache;
+class DominatorTree;
+class CodeExtractorAnalysisCache;
+
+/// A sequence of basic blocks.
+///
+/// A 0-sized SmallVector is slightly cheaper to move than a std::vector.
+using BlockSequence = SmallVector<BasicBlock *, 0>;
+
+class HotColdSplitting {
+public:
+  HotColdSplitting(ProfileSummaryInfo *ProfSI,
+                   function_ref<BlockFrequencyInfo *(Function &)> GBFI,
+                   function_ref<TargetTransformInfo &(Function &)> GTTI,
+                   std::function<OptimizationRemarkEmitter &(Function &)> *GORE,
+                   function_ref<AssumptionCache *(Function &)> LAC)
+      : PSI(ProfSI), GetBFI(GBFI), GetTTI(GTTI), GetORE(GORE), LookupAC(LAC) {}
+  bool run(Module &M);
+
+private:
+  bool isFunctionCold(const Function &F) const;
+  bool shouldOutlineFrom(const Function &F) const;
+  bool outlineColdRegions(Function &F, bool HasProfileSummary);
+  Function *extractColdRegion(const BlockSequence &Region,
+                              const CodeExtractorAnalysisCache &CEAC,
+                              DominatorTree &DT, BlockFrequencyInfo *BFI,
+                              TargetTransformInfo &TTI,
+                              OptimizationRemarkEmitter &ORE,
+                              AssumptionCache *AC, unsigned Count);
+  ProfileSummaryInfo *PSI;
+  function_ref<BlockFrequencyInfo *(Function &)> GetBFI;
+  function_ref<TargetTransformInfo &(Function &)> GetTTI;
+  std::function<OptimizationRemarkEmitter &(Function &)> *GetORE;
+  function_ref<AssumptionCache *(Function &)> LookupAC;
+};
 
 /// Pass to outline cold regions.
 class HotColdSplittingPass : public PassInfoMixin<HotColdSplittingPass> {
diff --git a/linux-x64/clang/include/llvm/Transforms/IPO/IROutliner.h b/linux-x64/clang/include/llvm/Transforms/IPO/IROutliner.h
new file mode 100644
index 0000000..0346803
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Transforms/IPO/IROutliner.h
@@ -0,0 +1,357 @@
+//===- IROutliner.h - Extract similar IR regions into functions ------------==//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// \file
+// The interface file for the IROutliner which is used by the IROutliner Pass.
+//
+// The outliner uses the IRSimilarityIdentifier to identify the similar regions
+// of code.  It evaluates each set of IRSimilarityCandidates with an estimate of
+// whether it will provide code size reduction.  Each region is extracted using
+// the code extractor.  These extracted functions are consolidated into a single
+// function and called from the extracted call site.
+//
+// For example:
+// \code
+//   %1 = add i32 %a, %b
+//   %2 = add i32 %b, %a
+//   %3 = add i32 %b, %a
+//   %4 = add i32 %a, %b
+// \endcode
+// would become function
+// \code
+// define internal void outlined_ir_function(i32 %0, i32 %1) {
+//   %1 = add i32 %0, %1
+//   %2 = add i32 %1, %0
+//   ret void
+// }
+// \endcode
+// with calls:
+// \code
+//   call void outlined_ir_function(i32 %a, i32 %b)
+//   call void outlined_ir_function(i32 %b, i32 %a)
+// \endcode
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_IPO_IROUTLINER_H
+#define LLVM_TRANSFORMS_IPO_IROUTLINER_H
+
+#include "llvm/Analysis/IRSimilarityIdentifier.h"
+#include "llvm/IR/PassManager.h"
+#include "llvm/IR/ValueMap.h"
+#include "llvm/Transforms/Utils/CodeExtractor.h"
+#include <set>
+
+struct OutlinableGroup;
+
+namespace llvm {
+using namespace IRSimilarity;
+
+class Module;
+class TargetTransformInfo;
+class OptimizationRemarkEmitter;
+
+/// The OutlinableRegion holds all the information for a specific region, or
+/// sequence of instructions. This includes what values need to be hoisted to
+/// arguments from the extracted function, inputs and outputs to the region, and
+/// mapping from the extracted function arguments to overall function arguments.
+struct OutlinableRegion {
+  /// Describes the region of code.
+  IRSimilarityCandidate *Candidate;
+
+  /// If this region is outlined, the front and back IRInstructionData could
+  /// potentially become invalidated if the only new instruction is a call.
+  /// This ensures that we replace in the instruction in the IRInstructionData.
+  IRInstructionData *NewFront = nullptr;
+  IRInstructionData *NewBack = nullptr;
+
+  /// The number of extracted inputs from the CodeExtractor.
+  unsigned NumExtractedInputs;
+
+  /// The corresponding BasicBlock with the appropriate stores for this
+  /// OutlinableRegion in the overall function.
+  unsigned OutputBlockNum;
+
+  /// Mapping the extracted argument number to the argument number in the
+  /// overall function.  Since there will be inputs, such as elevated constants
+  /// that are not the same in each region in a SimilarityGroup, or values that
+  /// cannot be sunk into the extracted section in every region, we must keep
+  /// track of which extracted argument maps to which overall argument.
+  DenseMap<unsigned, unsigned> ExtractedArgToAgg;
+  DenseMap<unsigned, unsigned> AggArgToExtracted;
+
+  /// Mapping of the argument number in the deduplicated function
+  /// to a given constant, which is used when creating the arguments to the call
+  /// to the newly created deduplicated function.  This is handled separately
+  /// since the CodeExtractor does not recognize constants.
+  DenseMap<unsigned, Constant *> AggArgToConstant;
+
+  /// The global value numbers that are used as outputs for this section. Once
+  /// extracted, each output will be stored to an output register.  This
+  /// documents the global value numbers that are used in this pattern.
+  SmallVector<unsigned, 4> GVNStores;
+
+  /// Used to create an outlined function.
+  CodeExtractor *CE = nullptr;
+
+  /// The call site of the extracted region.
+  CallInst *Call = nullptr;
+
+  /// The function for the extracted region.
+  Function *ExtractedFunction = nullptr;
+
+  /// Flag for whether we have split out the IRSimilarityCanidate. That is,
+  /// make the region contained the IRSimilarityCandidate its own BasicBlock.
+  bool CandidateSplit = false;
+
+  /// Flag for whether we should not consider this region for extraction.
+  bool IgnoreRegion = false;
+
+  /// The BasicBlock that is before the start of the region BasicBlock,
+  /// only defined when the region has been split.
+  BasicBlock *PrevBB = nullptr;
+
+  /// The BasicBlock that contains the starting instruction of the region.
+  BasicBlock *StartBB = nullptr;
+
+  /// The BasicBlock that contains the ending instruction of the region.
+  BasicBlock *EndBB = nullptr;
+
+  /// The BasicBlock that is after the start of the region BasicBlock,
+  /// only defined when the region has been split.
+  BasicBlock *FollowBB = nullptr;
+
+  /// The Outlinable Group that contains this region and structurally similar
+  /// regions to this region.
+  OutlinableGroup *Parent = nullptr;
+
+  OutlinableRegion(IRSimilarityCandidate &C, OutlinableGroup &Group)
+      : Candidate(&C), Parent(&Group) {
+    StartBB = C.getStartBB();
+    EndBB = C.getEndBB();
+  }
+
+  /// For the contained region, split the parent BasicBlock at the starting and
+  /// ending instructions of the contained IRSimilarityCandidate.
+  void splitCandidate();
+
+  /// For the contained region, reattach the BasicBlock at the starting and
+  /// ending instructions of the contained IRSimilarityCandidate, or if the
+  /// function has been extracted, the start and end of the BasicBlock
+  /// containing the called function.
+  void reattachCandidate();
+
+  /// Get the size of the code removed from the region.
+  ///
+  /// \param [in] TTI - The TargetTransformInfo for the parent function.
+  /// \returns the code size of the region
+  unsigned getBenefit(TargetTransformInfo &TTI);
+};
+
+/// This class is a pass that identifies similarity in a Module, extracts
+/// instances of the similarity, and then consolidating the similar regions
+/// in an effort to reduce code size.  It uses the IRSimilarityIdentifier pass
+/// to identify the similar regions of code, and then extracts the similar
+/// sections into a single function.  See the above for an example as to
+/// how code is extracted and consolidated into a single function.
+class IROutliner {
+public:
+  IROutliner(function_ref<TargetTransformInfo &(Function &)> GTTI,
+             function_ref<IRSimilarityIdentifier &(Module &)> GIRSI,
+             function_ref<OptimizationRemarkEmitter &(Function &)> GORE)
+      : getTTI(GTTI), getIRSI(GIRSI), getORE(GORE) {}
+  bool run(Module &M);
+
+private:
+  /// Find repeated similar code sequences in \p M and outline them into new
+  /// Functions.
+  ///
+  /// \param [in] M - The module to outline from.
+  /// \returns The number of Functions created.
+  unsigned doOutline(Module &M);
+
+  /// Remove all the IRSimilarityCandidates from \p CandidateVec that have
+  /// instructions contained in a previously outlined region and put the
+  /// remaining regions in \p CurrentGroup.
+  ///
+  /// \param [in] CandidateVec - List of similarity candidates for regions with
+  /// the same similarity structure.
+  /// \param [in,out] CurrentGroup - Contains the potential sections to
+  /// be outlined.
+  void
+  pruneIncompatibleRegions(std::vector<IRSimilarityCandidate> &CandidateVec,
+                           OutlinableGroup &CurrentGroup);
+
+  /// Create the function based on the overall types found in the current
+  /// regions being outlined.
+  ///
+  /// \param M - The module to outline from.
+  /// \param [in,out] CG - The OutlinableGroup for the regions to be outlined.
+  /// \param [in] FunctionNameSuffix - How many functions have we previously
+  /// created.
+  /// \returns the newly created function.
+  Function *createFunction(Module &M, OutlinableGroup &CG,
+                           unsigned FunctionNameSuffix);
+
+  /// Identify the needed extracted inputs in a section, and add to the overall
+  /// function if needed.
+  ///
+  /// \param [in] M - The module to outline from.
+  /// \param [in,out] Region - The region to be extracted.
+  /// \param [in] NotSame - The global value numbers of the Values in the region
+  /// that do not have the same Constant in each strucutrally similar region.
+  void findAddInputsOutputs(Module &M, OutlinableRegion &Region,
+                            DenseSet<unsigned> &NotSame);
+
+  /// Find the number of instructions that will be removed by extracting the
+  /// OutlinableRegions in \p CurrentGroup.
+  ///
+  /// \param [in] CurrentGroup - The collection of OutlinableRegions to be
+  /// analyzed.
+  /// \returns the number of outlined instructions across all regions.
+  unsigned findBenefitFromAllRegions(OutlinableGroup &CurrentGroup);
+
+  /// Find the number of instructions that will be added by reloading arguments.
+  ///
+  /// \param [in] CurrentGroup - The collection of OutlinableRegions to be
+  /// analyzed.
+  /// \returns the number of added reload instructions across all regions.
+  unsigned findCostOutputReloads(OutlinableGroup &CurrentGroup);
+
+  /// Find the cost and the benefit of \p CurrentGroup and save it back to
+  /// \p CurrentGroup.
+  ///
+  /// \param [in] M - The module being analyzed
+  /// \param [in,out] CurrentGroup - The overall outlined section
+  void findCostBenefit(Module &M, OutlinableGroup &CurrentGroup);
+
+  /// Update the output mapping based on the load instruction, and the outputs
+  /// of the extracted function.
+  ///
+  /// \param Region - The region extracted
+  /// \param Outputs - The outputs from the extracted function.
+  /// \param LI - The load instruction used to update the mapping.
+  void updateOutputMapping(OutlinableRegion &Region,
+                           ArrayRef<Value *> Outputs, LoadInst *LI);
+
+  /// Extract \p Region into its own function.
+  ///
+  /// \param [in] Region - The region to be extracted into its own function.
+  /// \returns True if it was successfully outlined.
+  bool extractSection(OutlinableRegion &Region);
+
+  /// For the similarities found, and the extracted sections, create a single
+  /// outlined function with appropriate output blocks as necessary.
+  ///
+  /// \param [in] M - The module to outline from
+  /// \param [in] CurrentGroup - The set of extracted sections to consolidate.
+  /// \param [in,out] FuncsToRemove - List of functions to remove from the
+  /// module after outlining is completed.
+  /// \param [in,out] OutlinedFunctionNum - the number of new outlined
+  /// functions.
+  void deduplicateExtractedSections(Module &M, OutlinableGroup &CurrentGroup,
+                                    std::vector<Function *> &FuncsToRemove,
+                                    unsigned &OutlinedFunctionNum);
+
+  /// If true, enables us to outline from functions that have LinkOnceFromODR
+  /// linkages.
+  bool OutlineFromLinkODRs = false;
+
+  /// If false, we do not worry if the cost is greater than the benefit.  This
+  /// is for debugging and testing, so that we can test small cases to ensure
+  /// that the outlining is being done correctly.
+  bool CostModel = true;
+
+  /// The set of outlined Instructions, identified by their location in the
+  /// sequential ordering of instructions in a Module.
+  DenseSet<unsigned> Outlined;
+
+  /// TargetTransformInfo lambda for target specific information.
+  function_ref<TargetTransformInfo &(Function &)> getTTI;
+
+  /// A mapping from newly created reloaded output values to the original value.
+  /// If an value is replace by an output from an outlined region, this maps
+  /// that Value, back to its original Value.
+  DenseMap<Value *, Value *> OutputMappings;
+
+  /// IRSimilarityIdentifier lambda to retrieve IRSimilarityIdentifier.
+  function_ref<IRSimilarityIdentifier &(Module &)> getIRSI;
+
+  /// The optimization remark emitter for the pass.
+  function_ref<OptimizationRemarkEmitter &(Function &)> getORE;
+
+  /// The memory allocator used to allocate the CodeExtractors.
+  SpecificBumpPtrAllocator<CodeExtractor> ExtractorAllocator;
+
+  /// The memory allocator used to allocate the OutlinableRegions.
+  SpecificBumpPtrAllocator<OutlinableRegion> RegionAllocator;
+
+  /// The memory allocator used to allocate new IRInstructionData.
+  SpecificBumpPtrAllocator<IRInstructionData> InstDataAllocator;
+
+  /// Custom InstVisitor to classify different instructions for whether it can
+  /// be analyzed for similarity.  This is needed as there may be instruction we
+  /// can identify as having similarity, but are more complicated to outline.
+  struct InstructionAllowed : public InstVisitor<InstructionAllowed, bool> {
+    InstructionAllowed() {}
+
+    // TODO: Determine a scheme to resolve when the label is similar enough.
+    bool visitBranchInst(BranchInst &BI) { return false; }
+    // TODO: Determine a scheme to resolve when the labels are similar enough.
+    bool visitPHINode(PHINode &PN) { return false; }
+    // TODO: Handle allocas.
+    bool visitAllocaInst(AllocaInst &AI) { return false; }
+    // VAArg instructions are not allowed since this could cause difficulty when
+    // differentiating between different sets of variable instructions in
+    // the deduplicated outlined regions.
+    bool visitVAArgInst(VAArgInst &VI) { return false; }
+    // We exclude all exception handling cases since they are so context
+    // dependent.
+    bool visitLandingPadInst(LandingPadInst &LPI) { return false; }
+    bool visitFuncletPadInst(FuncletPadInst &FPI) { return false; }
+    // DebugInfo should be included in the regions, but should not be
+    // analyzed for similarity as it has no bearing on the outcome of the
+    // program.
+    bool visitDbgInfoIntrinsic(DbgInfoIntrinsic &DII) { return true; }
+    // TODO: Handle specific intrinsics individually from those that can be
+    // handled.
+    bool IntrinsicInst(IntrinsicInst &II) { return false; }
+    // We only handle CallInsts that are not indirect, since we cannot guarantee
+    // that they have a name in these cases.
+    bool visitCallInst(CallInst &CI) {
+      Function *F = CI.getCalledFunction();
+      if (!F || CI.isIndirectCall() || !F->hasName())
+        return false;
+      return true;
+    }
+    // TODO: Handle FreezeInsts.  Since a frozen value could be frozen inside
+    // the outlined region, and then returned as an output, this will have to be
+    // handled differently.
+    bool visitFreezeInst(FreezeInst &CI) { return false; }
+    // TODO: We do not current handle similarity that changes the control flow.
+    bool visitInvokeInst(InvokeInst &II) { return false; }
+    // TODO: We do not current handle similarity that changes the control flow.
+    bool visitCallBrInst(CallBrInst &CBI) { return false; }
+    // TODO: Handle interblock similarity.
+    bool visitTerminator(Instruction &I) { return false; }
+    bool visitInstruction(Instruction &I) { return true; }
+  };
+
+  /// A InstVisitor used to exclude certain instructions from being outlined.
+  InstructionAllowed InstructionClassifier;
+};
+
+/// Pass to outline similar regions.
+class IROutlinerPass : public PassInfoMixin<IROutlinerPass> {
+public:
+  PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+};
+
+} // end namespace llvm
+
+#endif // LLVM_TRANSFORMS_IPO_IROUTLINER_H
diff --git a/linux-x64/clang/include/llvm/Transforms/IPO/Inliner.h b/linux-x64/clang/include/llvm/Transforms/IPO/Inliner.h
index 8202b94..b6e793a 100644
--- a/linux-x64/clang/include/llvm/Transforms/IPO/Inliner.h
+++ b/linux-x64/clang/include/llvm/Transforms/IPO/Inliner.h
@@ -11,9 +11,9 @@
 
 #include "llvm/Analysis/CGSCCPassManager.h"
 #include "llvm/Analysis/CallGraphSCCPass.h"
+#include "llvm/Analysis/InlineAdvisor.h"
 #include "llvm/Analysis/InlineCost.h"
 #include "llvm/Analysis/LazyCallGraph.h"
-#include "llvm/IR/CallSite.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/Transforms/Utils/ImportedFunctionsInliningStatistics.h"
 #include <utility>
@@ -36,6 +36,8 @@
   /// call the implementation here.
   void getAnalysisUsage(AnalysisUsage &Info) const override;
 
+  using llvm::Pass::doInitialization;
+
   bool doInitialization(CallGraph &CG) override;
 
   /// Main run interface method, this implements the interface required by the
@@ -51,7 +53,7 @@
   /// This method must be implemented by the subclass to determine the cost of
   /// inlining the specified call site.  If the cost returned is greater than
   /// the current inline threshold, the call site is not inlined.
-  virtual InlineCost getInlineCost(CallSite CS) = 0;
+  virtual InlineCost getInlineCost(CallBase &CB) = 0;
 
   /// Remove dead functions.
   ///
@@ -74,6 +76,7 @@
 protected:
   AssumptionCacheTracker *ACT;
   ProfileSummaryInfo *PSI;
+  std::function<const TargetLibraryInfo &(Function &)> GetTLI;
   ImportedFunctionsInliningStatistics ImportedFunctionsStats;
 };
 
@@ -93,21 +96,54 @@
 /// passes be composed to achieve the same end result.
 class InlinerPass : public PassInfoMixin<InlinerPass> {
 public:
-  InlinerPass(InlineParams Params = getInlineParams())
-      : Params(std::move(Params)) {}
+  InlinerPass(bool OnlyMandatory = false) : OnlyMandatory(OnlyMandatory) {}
   ~InlinerPass();
-  InlinerPass(InlinerPass &&Arg)
-      : Params(std::move(Arg.Params)),
-        ImportedFunctionsStats(std::move(Arg.ImportedFunctionsStats)) {}
+  InlinerPass(InlinerPass &&Arg) = default;
 
   PreservedAnalyses run(LazyCallGraph::SCC &C, CGSCCAnalysisManager &AM,
                         LazyCallGraph &CG, CGSCCUpdateResult &UR);
 
 private:
-  InlineParams Params;
+  InlineAdvisor &getAdvisor(const ModuleAnalysisManagerCGSCCProxy::Result &MAM,
+                            FunctionAnalysisManager &FAM, Module &M);
   std::unique_ptr<ImportedFunctionsInliningStatistics> ImportedFunctionsStats;
+  std::unique_ptr<DefaultInlineAdvisor> OwnedDefaultAdvisor;
+  const bool OnlyMandatory;
 };
 
+/// Module pass, wrapping the inliner pass. This works in conjunction with the
+/// InlineAdvisorAnalysis to facilitate inlining decisions taking into account
+/// module-wide state, that need to keep track of inter-inliner pass runs, for
+/// a given module. An InlineAdvisor is configured and kept alive for the
+/// duration of the ModuleInlinerWrapperPass::run.
+class ModuleInlinerWrapperPass
+    : public PassInfoMixin<ModuleInlinerWrapperPass> {
+public:
+  ModuleInlinerWrapperPass(
+      InlineParams Params = getInlineParams(), bool Debugging = false,
+      bool MandatoryFirst = true,
+      InliningAdvisorMode Mode = InliningAdvisorMode::Default,
+      unsigned MaxDevirtIterations = 0);
+  ModuleInlinerWrapperPass(ModuleInlinerWrapperPass &&Arg) = default;
+
+  PreservedAnalyses run(Module &, ModuleAnalysisManager &);
+
+  /// Allow adding more CGSCC passes, besides inlining. This should be called
+  /// before run is called, as part of pass pipeline building.
+  CGSCCPassManager &getPM() { return PM; }
+
+  /// Allow adding module-level analyses benefiting the contained CGSCC passes.
+  template <class T> void addRequiredModuleAnalysis() {
+    MPM.addPass(RequireAnalysisPass<T, Module>());
+  }
+
+private:
+  const InlineParams Params;
+  const InliningAdvisorMode Mode;
+  const unsigned MaxDevirtIterations;
+  CGSCCPassManager PM;
+  ModulePassManager MPM;
+};
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_IPO_INLINER_H
diff --git a/linux-x64/clang/include/llvm/Transforms/IPO/LoopExtractor.h b/linux-x64/clang/include/llvm/Transforms/IPO/LoopExtractor.h
new file mode 100644
index 0000000..def3c59
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Transforms/IPO/LoopExtractor.h
@@ -0,0 +1,32 @@
+//===- LoopExtractor.h - Extract each loop into a new function ------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// A pass wrapper around the ExtractLoop() scalar transformation to extract each
+// top-level loop into its own new function. If the loop is the ONLY loop in a
+// given function, it is not touched. This is a pass most useful for debugging
+// via bugpoint.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_IPO_LOOPEXTRACTOR_H
+#define LLVM_TRANSFORMS_IPO_LOOPEXTRACTOR_H
+
+#include "llvm/IR/PassManager.h"
+
+namespace llvm {
+
+struct LoopExtractorPass : public PassInfoMixin<LoopExtractorPass> {
+  LoopExtractorPass(unsigned NumLoops = ~0) : NumLoops(NumLoops) {}
+  PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+
+private:
+  unsigned NumLoops;
+};
+} // namespace llvm
+
+#endif // LLVM_TRANSFORMS_IPO_LOOPEXTRACTOR_H
diff --git a/linux-x64/clang/include/llvm/Transforms/IPO/LowerTypeTests.h b/linux-x64/clang/include/llvm/Transforms/IPO/LowerTypeTests.h
index 39b23f5..eb682c4 100644
--- a/linux-x64/clang/include/llvm/Transforms/IPO/LowerTypeTests.h
+++ b/linux-x64/clang/include/llvm/Transforms/IPO/LowerTypeTests.h
@@ -193,15 +193,24 @@
                 uint64_t &AllocByteOffset, uint8_t &AllocMask);
 };
 
+bool isJumpTableCanonical(Function *F);
+
 } // end namespace lowertypetests
 
 class LowerTypeTestsPass : public PassInfoMixin<LowerTypeTestsPass> {
+  bool UseCommandLine = false;
+
+  ModuleSummaryIndex *ExportSummary = nullptr;
+  const ModuleSummaryIndex *ImportSummary = nullptr;
+  bool DropTypeTests = true;
+
 public:
-  ModuleSummaryIndex *ExportSummary;
-  const ModuleSummaryIndex *ImportSummary;
+  LowerTypeTestsPass() : UseCommandLine(true) {}
   LowerTypeTestsPass(ModuleSummaryIndex *ExportSummary,
-                     const ModuleSummaryIndex *ImportSummary)
-      : ExportSummary(ExportSummary), ImportSummary(ImportSummary) {}
+                     const ModuleSummaryIndex *ImportSummary,
+                     bool DropTypeTests = false)
+      : ExportSummary(ExportSummary), ImportSummary(ImportSummary),
+        DropTypeTests(DropTypeTests) {}
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
 };
 
diff --git a/linux-x64/clang/include/llvm/Transforms/IPO/MergeFunctions.h b/linux-x64/clang/include/llvm/Transforms/IPO/MergeFunctions.h
new file mode 100644
index 0000000..822f0fd
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Transforms/IPO/MergeFunctions.h
@@ -0,0 +1,32 @@
+//===- MergeFunctions.h - Merge Identical Functions -------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This pass transforms simple global variables that never have their address
+// taken.  If obviously true, it marks read/write globals as constant, deletes
+// variables only stored to, etc.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_IPO_MERGEFUNCTIONS_H
+#define LLVM_TRANSFORMS_IPO_MERGEFUNCTIONS_H
+
+#include "llvm/IR/PassManager.h"
+
+namespace llvm {
+
+class Module;
+
+/// Merge identical functions.
+class MergeFunctionsPass : public PassInfoMixin<MergeFunctionsPass> {
+public:
+  PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+};
+
+} // end namespace llvm
+
+#endif // LLVM_TRANSFORMS_IPO_MERGEFUNCTIONS_H
diff --git a/linux-x64/clang/include/llvm/Transforms/IPO/OpenMPOpt.h b/linux-x64/clang/include/llvm/Transforms/IPO/OpenMPOpt.h
new file mode 100644
index 0000000..9b72ee0
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Transforms/IPO/OpenMPOpt.h
@@ -0,0 +1,76 @@
+//===- IPO/OpenMPOpt.h - Collection of OpenMP optimizations -----*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_IPO_OPENMP_OPT_H
+#define LLVM_TRANSFORMS_IPO_OPENMP_OPT_H
+
+#include "llvm/Analysis/CGSCCPassManager.h"
+#include "llvm/Analysis/LazyCallGraph.h"
+#include "llvm/IR/PassManager.h"
+
+namespace llvm {
+
+namespace omp {
+
+/// Summary of a kernel (=entry point for target offloading).
+using Kernel = Function *;
+
+/// Helper to remember if the module contains OpenMP (runtime calls), to be used
+/// foremost with containsOpenMP.
+struct OpenMPInModule {
+  OpenMPInModule &operator=(bool Found) {
+    if (Found)
+      Value = OpenMPInModule::OpenMP::FOUND;
+    else
+      Value = OpenMPInModule::OpenMP::NOT_FOUND;
+    return *this;
+  }
+  bool isKnown() { return Value != OpenMP::UNKNOWN; }
+  operator bool() { return Value != OpenMP::NOT_FOUND; }
+
+  /// Does this function \p F contain any OpenMP runtime calls?
+  bool containsOMPRuntimeCalls(Function *F) const {
+    return FuncsWithOMPRuntimeCalls.contains(F);
+  }
+
+  /// Return the known kernels (=GPU entry points) in the module.
+  SmallPtrSetImpl<Kernel> &getKernels() { return Kernels; }
+
+  /// Identify kernels in the module and populate the Kernels set.
+  void identifyKernels(Module &M);
+
+private:
+  enum class OpenMP { FOUND, NOT_FOUND, UNKNOWN } Value = OpenMP::UNKNOWN;
+
+  friend bool containsOpenMP(Module &M, OpenMPInModule &OMPInModule);
+
+  /// In which functions are OpenMP runtime calls present?
+  SmallPtrSet<Function *, 32> FuncsWithOMPRuntimeCalls;
+
+  /// Collection of known kernels (=GPU entry points) in the module.
+  SmallPtrSet<Kernel, 8> Kernels;
+};
+
+/// Helper to determine if \p M contains OpenMP (runtime calls).
+bool containsOpenMP(Module &M, OpenMPInModule &OMPInModule);
+
+} // namespace omp
+
+/// OpenMP optimizations pass.
+class OpenMPOptPass : public PassInfoMixin<OpenMPOptPass> {
+  /// Helper to remember if the module contains OpenMP (runtime calls).
+  omp::OpenMPInModule OMPInModule;
+
+public:
+  PreservedAnalyses run(LazyCallGraph::SCC &C, CGSCCAnalysisManager &AM,
+                        LazyCallGraph &CG, CGSCCUpdateResult &UR);
+};
+
+} // end namespace llvm
+
+#endif // LLVM_TRANSFORMS_IPO_OPENMP_OPT_H
diff --git a/linux-x64/clang/include/llvm/Transforms/IPO/PassManagerBuilder.h b/linux-x64/clang/include/llvm/Transforms/IPO/PassManagerBuilder.h
index 63ff00a..a9928c3 100644
--- a/linux-x64/clang/include/llvm/Transforms/IPO/PassManagerBuilder.h
+++ b/linux-x64/clang/include/llvm/Transforms/IPO/PassManagerBuilder.h
@@ -14,6 +14,7 @@
 #ifndef LLVM_TRANSFORMS_IPO_PASSMANAGERBUILDER_H
 #define LLVM_TRANSFORMS_IPO_PASSMANAGERBUILDER_H
 
+#include "llvm-c/Transforms/PassManagerBuilder.h"
 #include <functional>
 #include <memory>
 #include <string>
@@ -62,6 +63,8 @@
   typedef std::function<void(const PassManagerBuilder &Builder,
                              legacy::PassManagerBase &PM)>
       ExtensionFn;
+  typedef int GlobalExtensionID;
+
   enum ExtensionPointTy {
     /// EP_EarlyAsPossible - This extension point allows adding passes before
     /// any other transformations, allowing them to see the code as it is coming
@@ -153,6 +156,7 @@
 
   bool DisableTailCalls;
   bool DisableUnrollLoops;
+  bool CallGraphProfile;
   bool SLPVectorize;
   bool LoopVectorize;
   bool LoopsInterleaved;
@@ -193,7 +197,17 @@
   /// Adds an extension that will be used by all PassManagerBuilder instances.
   /// This is intended to be used by plugins, to register a set of
   /// optimisations to run automatically.
-  static void addGlobalExtension(ExtensionPointTy Ty, ExtensionFn Fn);
+  ///
+  /// \returns A global extension identifier that can be used to remove the
+  /// extension.
+  static GlobalExtensionID addGlobalExtension(ExtensionPointTy Ty,
+                                              ExtensionFn Fn);
+  /// Removes an extension that was previously added using addGlobalExtension.
+  /// This is also intended to be used by plugins, to remove any extension that
+  /// was previously registered before being unloaded.
+  ///
+  /// \param ExtensionID Identifier of the extension to be removed.
+  static void removeGlobalExtension(GlobalExtensionID ExtensionID);
   void addExtension(ExtensionPointTy Ty, ExtensionFn Fn);
 
 private:
@@ -204,7 +218,6 @@
   void addLateLTOOptimizationPasses(legacy::PassManagerBase &PM);
   void addPGOInstrPasses(legacy::PassManagerBase &MPM, bool IsCS);
   void addFunctionSimplificationPasses(legacy::PassManagerBase &MPM);
-  void addInstructionCombiningPass(legacy::PassManagerBase &MPM) const;
 
 public:
   /// populateFunctionPassManager - This fills in the function pass manager,
@@ -222,12 +235,30 @@
 /// used by optimizer plugins to allow all front ends to transparently use
 /// them.  Create a static instance of this class in your plugin, providing a
 /// private function that the PassManagerBuilder can use to add your passes.
-struct RegisterStandardPasses {
+class RegisterStandardPasses {
+  PassManagerBuilder::GlobalExtensionID ExtensionID;
+
+public:
   RegisterStandardPasses(PassManagerBuilder::ExtensionPointTy Ty,
                          PassManagerBuilder::ExtensionFn Fn) {
-    PassManagerBuilder::addGlobalExtension(Ty, std::move(Fn));
+    ExtensionID = PassManagerBuilder::addGlobalExtension(Ty, std::move(Fn));
+  }
+
+  ~RegisterStandardPasses() {
+    // If the collection holding the global extensions is destroyed after the
+    // plugin is unloaded, the extension has to be removed here. Indeed, the
+    // destructor of the ExtensionFn may reference code in the plugin.
+    PassManagerBuilder::removeGlobalExtension(ExtensionID);
   }
 };
 
+inline PassManagerBuilder *unwrap(LLVMPassManagerBuilderRef P) {
+    return reinterpret_cast<PassManagerBuilder*>(P);
+}
+
+inline LLVMPassManagerBuilderRef wrap(PassManagerBuilder *P) {
+  return reinterpret_cast<LLVMPassManagerBuilderRef>(P);
+}
+
 } // end namespace llvm
 #endif
diff --git a/linux-x64/clang/include/llvm/Transforms/IPO/SampleContextTracker.h b/linux-x64/clang/include/llvm/Transforms/IPO/SampleContextTracker.h
new file mode 100644
index 0000000..5b26001
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Transforms/IPO/SampleContextTracker.h
@@ -0,0 +1,141 @@
+//===- Transforms/IPO/SampleContextTracker.h --------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+/// \file
+/// This file provides the interface for context-sensitive profile tracker used
+/// by CSSPGO.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_IPO_SAMPLECONTEXTTRACKER_H
+#define LLVM_TRANSFORMS_IPO_SAMPLECONTEXTTRACKER_H
+
+#include "llvm/ADT/SmallSet.h"
+#include "llvm/ADT/StringMap.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/IR/DebugInfoMetadata.h"
+#include "llvm/IR/Instructions.h"
+#include "llvm/ProfileData/SampleProf.h"
+#include <list>
+#include <map>
+
+using namespace llvm;
+using namespace sampleprof;
+
+namespace llvm {
+
+// Internal trie tree representation used for tracking context tree and sample
+// profiles. The path from root node to a given node represents the context of
+// that nodes' profile.
+class ContextTrieNode {
+public:
+  ContextTrieNode(ContextTrieNode *Parent = nullptr,
+                  StringRef FName = StringRef(),
+                  FunctionSamples *FSamples = nullptr,
+                  LineLocation CallLoc = {0, 0})
+      : ParentContext(Parent), FuncName(FName), FuncSamples(FSamples),
+        CallSiteLoc(CallLoc){};
+  ContextTrieNode *getChildContext(const LineLocation &CallSite,
+                                   StringRef CalleeName);
+  ContextTrieNode *getChildContext(const LineLocation &CallSite);
+  ContextTrieNode *getOrCreateChildContext(const LineLocation &CallSite,
+                                           StringRef CalleeName,
+                                           bool AllowCreate = true);
+
+  ContextTrieNode &moveToChildContext(const LineLocation &CallSite,
+                                      ContextTrieNode &&NodeToMove,
+                                      StringRef ContextStrToRemove,
+                                      bool DeleteNode = true);
+  void removeChildContext(const LineLocation &CallSite, StringRef CalleeName);
+  std::map<uint32_t, ContextTrieNode> &getAllChildContext();
+  const StringRef getFuncName() const;
+  FunctionSamples *getFunctionSamples() const;
+  void setFunctionSamples(FunctionSamples *FSamples);
+  LineLocation getCallSiteLoc() const;
+  ContextTrieNode *getParentContext() const;
+  void setParentContext(ContextTrieNode *Parent);
+  void dump();
+
+private:
+  static uint32_t nodeHash(StringRef ChildName, const LineLocation &Callsite);
+
+  // Map line+discriminator location to child context
+  std::map<uint32_t, ContextTrieNode> AllChildContext;
+
+  // Link to parent context node
+  ContextTrieNode *ParentContext;
+
+  // Function name for current context
+  StringRef FuncName;
+
+  // Function Samples for current context
+  FunctionSamples *FuncSamples;
+
+  // Callsite location in parent context
+  LineLocation CallSiteLoc;
+};
+
+// Profile tracker that manages profiles and its associated context. It
+// provides interfaces used by sample profile loader to query context profile or
+// base profile for given function or location; it also manages context tree
+// manipulation that is needed to accommodate inline decisions so we have
+// accurate post-inline profile for functions. Internally context profiles
+// are organized in a trie, with each node representing profile for specific
+// calling context and the context is identified by path from root to the node.
+class SampleContextTracker {
+public:
+  SampleContextTracker(StringMap<FunctionSamples> &Profiles);
+  // Query context profile for a specific callee with given name at a given
+  // call-site. The full context is identified by location of call instruction.
+  FunctionSamples *getCalleeContextSamplesFor(const CallBase &Inst,
+                                              StringRef CalleeName);
+  // Query context profile for a given location. The full context
+  // is identified by input DILocation.
+  FunctionSamples *getContextSamplesFor(const DILocation *DIL);
+  // Query context profile for a given sample contxt of a function.
+  FunctionSamples *getContextSamplesFor(const SampleContext &Context);
+  // Query base profile for a given function. A base profile is a merged view
+  // of all context profiles for contexts that are not inlined.
+  FunctionSamples *getBaseSamplesFor(const Function &Func,
+                                     bool MergeContext = true);
+  // Query base profile for a given function by name.
+  FunctionSamples *getBaseSamplesFor(StringRef Name, bool MergeContext);
+  // Mark a context profile as inlined when function is inlined.
+  // This makes sure that inlined context profile will be excluded in
+  // function's base profile.
+  void markContextSamplesInlined(const FunctionSamples *InlinedSamples);
+  // Dump the internal context profile trie.
+  void dump();
+
+private:
+  ContextTrieNode *getContextFor(const DILocation *DIL);
+  ContextTrieNode *getContextFor(const SampleContext &Context);
+  ContextTrieNode *getCalleeContextFor(const DILocation *DIL,
+                                       StringRef CalleeName);
+  ContextTrieNode *getOrCreateContextPath(const SampleContext &Context,
+                                          bool AllowCreate);
+  ContextTrieNode *getTopLevelContextNode(StringRef FName);
+  ContextTrieNode &addTopLevelContextNode(StringRef FName);
+  ContextTrieNode &promoteMergeContextSamplesTree(ContextTrieNode &NodeToPromo);
+  void promoteMergeContextSamplesTree(const Instruction &Inst,
+                                      StringRef CalleeName);
+  void mergeContextNode(ContextTrieNode &FromNode, ContextTrieNode &ToNode,
+                        StringRef ContextStrToRemove);
+  ContextTrieNode &promoteMergeContextSamplesTree(ContextTrieNode &FromNode,
+                                                  ContextTrieNode &ToNodeParent,
+                                                  StringRef ContextStrToRemove);
+
+  // Map from function name to context profiles (excluding base profile)
+  StringMap<SmallSet<FunctionSamples *, 16>> FuncToCtxtProfileSet;
+
+  // Root node for context trie tree
+  ContextTrieNode RootContext;
+};
+
+} // end namespace llvm
+#endif // LLVM_TRANSFORMS_IPO_SAMPLECONTEXTTRACKER_H
diff --git a/linux-x64/clang/include/llvm/Transforms/IPO/SampleProfile.h b/linux-x64/clang/include/llvm/Transforms/IPO/SampleProfile.h
index a5ad445..3d929b9 100644
--- a/linux-x64/clang/include/llvm/Transforms/IPO/SampleProfile.h
+++ b/linux-x64/clang/include/llvm/Transforms/IPO/SampleProfile.h
@@ -24,17 +24,18 @@
 /// The sample profiler data loader pass.
 class SampleProfileLoaderPass : public PassInfoMixin<SampleProfileLoaderPass> {
 public:
-  SampleProfileLoaderPass(std::string File = "", std::string RemappingFile = "",
-                          bool IsThinLTOPreLink = false)
+  SampleProfileLoaderPass(
+      std::string File = "", std::string RemappingFile = "",
+      ThinOrFullLTOPhase LTOPhase = ThinOrFullLTOPhase::None)
       : ProfileFileName(File), ProfileRemappingFileName(RemappingFile),
-        IsThinLTOPreLink(IsThinLTOPreLink) {}
+        LTOPhase(LTOPhase) {}
 
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
 
 private:
   std::string ProfileFileName;
   std::string ProfileRemappingFileName;
-  bool IsThinLTOPreLink;
+  ThinOrFullLTOPhase LTOPhase;
 };
 
 } // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/Transforms/IPO/SampleProfileProbe.h b/linux-x64/clang/include/llvm/Transforms/IPO/SampleProfileProbe.h
new file mode 100644
index 0000000..78117fd
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Transforms/IPO/SampleProfileProbe.h
@@ -0,0 +1,106 @@
+//===- Transforms/IPO/SampleProfileProbe.h ----------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+/// \file
+/// This file provides the interface for the pseudo probe implementation for
+/// AutoFDO.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_IPO_SAMPLEPROFILEPROBE_H
+#define LLVM_TRANSFORMS_IPO_SAMPLEPROFILEPROBE_H
+
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/IR/PassManager.h"
+#include "llvm/IR/PseudoProbe.h"
+#include "llvm/ProfileData/SampleProf.h"
+#include "llvm/Target/TargetMachine.h"
+#include <unordered_map>
+
+namespace llvm {
+
+class Module;
+
+using namespace sampleprof;
+using BlockIdMap = std::unordered_map<BasicBlock *, uint32_t>;
+using InstructionIdMap = std::unordered_map<Instruction *, uint32_t>;
+
+enum class PseudoProbeReservedId { Invalid = 0, Last = Invalid };
+
+class PseudoProbeDescriptor {
+  uint64_t FunctionGUID;
+  uint64_t FunctionHash;
+
+public:
+  PseudoProbeDescriptor(uint64_t GUID, uint64_t Hash)
+      : FunctionGUID(GUID), FunctionHash(Hash) {}
+  uint64_t getFunctionGUID() const { return FunctionGUID; }
+  uint64_t getFunctionHash() const { return FunctionHash; }
+};
+
+// This class serves sample counts correlation for SampleProfileLoader by
+// analyzing pseudo probes and their function descriptors injected by
+// SampleProfileProber.
+class PseudoProbeManager {
+  DenseMap<uint64_t, PseudoProbeDescriptor> GUIDToProbeDescMap;
+
+  const PseudoProbeDescriptor *getDesc(const Function &F) const;
+
+public:
+  PseudoProbeManager(const Module &M);
+  bool moduleIsProbed(const Module &M) const;
+  bool profileIsValid(const Function &F, const FunctionSamples &Samples) const;
+};
+
+/// Sample profile pseudo prober.
+///
+/// Insert pseudo probes for block sampling and value sampling.
+class SampleProfileProber {
+public:
+  // Give an empty module id when the prober is not used for instrumentation.
+  SampleProfileProber(Function &F, const std::string &CurModuleUniqueId);
+  void instrumentOneFunc(Function &F, TargetMachine *TM);
+
+private:
+  Function *getFunction() const { return F; }
+  uint64_t getFunctionHash() const { return FunctionHash; }
+  uint32_t getBlockId(const BasicBlock *BB) const;
+  uint32_t getCallsiteId(const Instruction *Call) const;
+  void computeCFGHash();
+  void computeProbeIdForBlocks();
+  void computeProbeIdForCallsites();
+
+  Function *F;
+
+  /// The current module ID that is used to name a static object as a comdat
+  /// group.
+  std::string CurModuleUniqueId;
+
+  /// A CFG hash code used to identify a function code changes.
+  uint64_t FunctionHash;
+
+  /// Map basic blocks to the their pseudo probe ids.
+  BlockIdMap BlockProbeIds;
+
+  /// Map indirect calls to the their pseudo probe ids.
+  InstructionIdMap CallProbeIds;
+
+  /// The ID of the last probe, Can be used to number a new probe.
+  uint32_t LastProbeId;
+};
+
+class SampleProfileProbePass : public PassInfoMixin<SampleProfileProbePass> {
+  TargetMachine *TM;
+
+public:
+  SampleProfileProbePass(TargetMachine *TM) : TM(TM) {}
+  PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+};
+
+} // end namespace llvm
+#endif // LLVM_TRANSFORMS_IPO_SAMPLEPROFILEPROBE_H
diff --git a/linux-x64/clang/include/llvm/Transforms/IPO/StripSymbols.h b/linux-x64/clang/include/llvm/Transforms/IPO/StripSymbols.h
new file mode 100644
index 0000000..dd76d48
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Transforms/IPO/StripSymbols.h
@@ -0,0 +1,47 @@
+//===- StripSymbols.h - Strip symbols and debug info from a module --------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// The StripSymbols transformation implements code stripping. Specifically, it
+// can delete:
+//
+//   * names for virtual registers
+//   * symbols for internal globals and functions
+//   * debug information
+//
+// Note that this transformation makes code much less readable, so it should
+// only be used in situations where the 'strip' utility would be used, such as
+// reducing code size or making it harder to reverse engineer code.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_IPO_STRIPSYMBOLS_H
+#define LLVM_TRANSFORMS_IPO_STRIPSYMBOLS_H
+
+#include "llvm/IR/PassManager.h"
+
+namespace llvm {
+
+struct StripSymbolsPass : PassInfoMixin<StripSymbolsPass> {
+  PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+};
+
+struct StripNonDebugSymbolsPass : PassInfoMixin<StripNonDebugSymbolsPass> {
+  PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+};
+
+struct StripDebugDeclarePass : PassInfoMixin<StripDebugDeclarePass> {
+  PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+};
+
+struct StripDeadDebugInfoPass : PassInfoMixin<StripDeadDebugInfoPass> {
+  PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+};
+
+} // end namespace llvm
+
+#endif // LLVM_TRANSFORMS_IPO_STRIPSYMBOLS_H
diff --git a/linux-x64/clang/include/llvm/Transforms/IPO/SyntheticCountsPropagation.h b/linux-x64/clang/include/llvm/Transforms/IPO/SyntheticCountsPropagation.h
index 0b3ba86..0637d62 100644
--- a/linux-x64/clang/include/llvm/Transforms/IPO/SyntheticCountsPropagation.h
+++ b/linux-x64/clang/include/llvm/Transforms/IPO/SyntheticCountsPropagation.h
@@ -1,13 +1,17 @@
+//=- SyntheticCountsPropagation.h - Propagate function counts -----*- C++ -*-=//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
 #ifndef LLVM_TRANSFORMS_IPO_SYNTHETIC_COUNTS_PROPAGATION_H
 #define LLVM_TRANSFORMS_IPO_SYNTHETIC_COUNTS_PROPAGATION_H
 
-#include "llvm/ADT/STLExtras.h"
-#include "llvm/IR/CallSite.h"
 #include "llvm/IR/PassManager.h"
-#include "llvm/Support/ScaledNumber.h"
 
 namespace llvm {
-class Function;
 class Module;
 
 class SyntheticCountsPropagation
diff --git a/linux-x64/clang/include/llvm/Transforms/IPO/WholeProgramDevirt.h b/linux-x64/clang/include/llvm/Transforms/IPO/WholeProgramDevirt.h
index 509fcc8..6e92f8f 100644
--- a/linux-x64/clang/include/llvm/Transforms/IPO/WholeProgramDevirt.h
+++ b/linux-x64/clang/include/llvm/Transforms/IPO/WholeProgramDevirt.h
@@ -16,8 +16,10 @@
 
 #include "llvm/IR/Module.h"
 #include "llvm/IR/PassManager.h"
+#include "llvm/Transforms/IPO/FunctionImport.h"
 #include <cassert>
 #include <cstdint>
+#include <set>
 #include <utility>
 #include <vector>
 
@@ -28,6 +30,7 @@
 class Function;
 class GlobalVariable;
 class ModuleSummaryIndex;
+struct ValueInfo;
 
 namespace wholeprogramdevirt {
 
@@ -220,6 +223,9 @@
 struct WholeProgramDevirtPass : public PassInfoMixin<WholeProgramDevirtPass> {
   ModuleSummaryIndex *ExportSummary;
   const ModuleSummaryIndex *ImportSummary;
+  bool UseCommandLine = false;
+  WholeProgramDevirtPass()
+      : ExportSummary(nullptr), ImportSummary(nullptr), UseCommandLine(true) {}
   WholeProgramDevirtPass(ModuleSummaryIndex *ExportSummary,
                          const ModuleSummaryIndex *ImportSummary)
       : ExportSummary(ExportSummary), ImportSummary(ImportSummary) {
@@ -228,6 +234,34 @@
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &);
 };
 
+struct VTableSlotSummary {
+  StringRef TypeID;
+  uint64_t ByteOffset;
+};
+
+void updateVCallVisibilityInModule(Module &M,
+                                   bool WholeProgramVisibilityEnabledInLTO);
+void updateVCallVisibilityInIndex(ModuleSummaryIndex &Index,
+                                  bool WholeProgramVisibilityEnabledInLTO);
+
+/// Perform index-based whole program devirtualization on the \p Summary
+/// index. Any devirtualized targets used by a type test in another module
+/// are added to the \p ExportedGUIDs set. For any local devirtualized targets
+/// only used within the defining module, the information necessary for
+/// locating the corresponding WPD resolution is recorded for the ValueInfo
+/// in case it is exported by cross module importing (in which case the
+/// devirtualized target name will need adjustment).
+void runWholeProgramDevirtOnIndex(
+    ModuleSummaryIndex &Summary, std::set<GlobalValue::GUID> &ExportedGUIDs,
+    std::map<ValueInfo, std::vector<VTableSlotSummary>> &LocalWPDTargetsMap);
+
+/// Call after cross-module importing to update the recorded single impl
+/// devirt target names for any locals that were exported.
+void updateIndexWPDForExports(
+    ModuleSummaryIndex &Summary,
+    function_ref<bool(StringRef, ValueInfo)> isExported,
+    std::map<ValueInfo, std::vector<VTableSlotSummary>> &LocalWPDTargetsMap);
+
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_IPO_WHOLEPROGRAMDEVIRT_H
diff --git a/linux-x64/clang/include/llvm/Transforms/InstCombine/InstCombine.h b/linux-x64/clang/include/llvm/Transforms/InstCombine/InstCombine.h
index 8894d96..0ad4f54 100644
--- a/linux-x64/clang/include/llvm/Transforms/InstCombine/InstCombine.h
+++ b/linux-x64/clang/include/llvm/Transforms/InstCombine/InstCombine.h
@@ -24,13 +24,13 @@
 
 class InstCombinePass : public PassInfoMixin<InstCombinePass> {
   InstCombineWorklist Worklist;
-  bool ExpensiveCombines;
+  const unsigned MaxIterations;
 
 public:
   static StringRef name() { return "InstCombinePass"; }
 
-  explicit InstCombinePass(bool ExpensiveCombines = true)
-      : ExpensiveCombines(ExpensiveCombines) {}
+  explicit InstCombinePass();
+  explicit InstCombinePass(unsigned MaxIterations);
 
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
 };
@@ -41,15 +41,13 @@
 /// will try to combine all instructions in the function.
 class InstructionCombiningPass : public FunctionPass {
   InstCombineWorklist Worklist;
-  const bool ExpensiveCombines;
+  const unsigned MaxIterations;
 
 public:
   static char ID; // Pass identification, replacement for typeid
 
-  InstructionCombiningPass(bool ExpensiveCombines = true)
-      : FunctionPass(ID), ExpensiveCombines(ExpensiveCombines) {
-    initializeInstructionCombiningPassPass(*PassRegistry::getPassRegistry());
-  }
+  explicit InstructionCombiningPass();
+  explicit InstructionCombiningPass(unsigned MaxIterations);
 
   void getAnalysisUsage(AnalysisUsage &AU) const override;
   bool runOnFunction(Function &F) override;
@@ -67,7 +65,8 @@
 // into:
 //    %Z = add int 2, %X
 //
-FunctionPass *createInstructionCombiningPass(bool ExpensiveCombines = true);
+FunctionPass *createInstructionCombiningPass();
+FunctionPass *createInstructionCombiningPass(unsigned MaxIterations);
 }
 
 #endif
diff --git a/linux-x64/clang/include/llvm/Transforms/InstCombine/InstCombineWorklist.h b/linux-x64/clang/include/llvm/Transforms/InstCombine/InstCombineWorklist.h
index 6c33bdb..25aabe1 100644
--- a/linux-x64/clang/include/llvm/Transforms/InstCombine/InstCombineWorklist.h
+++ b/linux-x64/clang/include/llvm/Transforms/InstCombine/InstCombineWorklist.h
@@ -11,6 +11,7 @@
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/IR/Instruction.h"
 #include "llvm/Support/Compiler.h"
@@ -24,8 +25,12 @@
 /// InstCombineWorklist - This is the worklist management logic for
 /// InstCombine.
 class InstCombineWorklist {
-  SmallVector<Instruction*, 256> Worklist;
-  DenseMap<Instruction*, unsigned> WorklistMap;
+  SmallVector<Instruction *, 256> Worklist;
+  DenseMap<Instruction *, unsigned> WorklistMap;
+  /// These instructions will be added in reverse order after the current
+  /// combine has finished. This means that these instructions will be visited
+  /// in the order they have been added.
+  SmallSetVector<Instruction *, 16> Deferred;
 
 public:
   InstCombineWorklist() = default;
@@ -33,69 +38,83 @@
   InstCombineWorklist(InstCombineWorklist &&) = default;
   InstCombineWorklist &operator=(InstCombineWorklist &&) = default;
 
-  bool isEmpty() const { return Worklist.empty(); }
+  bool isEmpty() const { return Worklist.empty() && Deferred.empty(); }
 
-  /// Add - Add the specified instruction to the worklist if it isn't already
-  /// in it.
-  void Add(Instruction *I) {
+  /// Add instruction to the worklist.
+  /// Instructions will be visited in the order they are added.
+  /// You likely want to use this method.
+  void add(Instruction *I) {
+    if (Deferred.insert(I))
+      LLVM_DEBUG(dbgs() << "IC: ADD DEFERRED: " << *I << '\n');
+  }
+
+  /// Add value to the worklist if it is an instruction.
+  /// Instructions will be visited in the order they are added.
+  void addValue(Value *V) {
+    if (Instruction *I = dyn_cast<Instruction>(V))
+      add(I);
+  }
+
+  /// Push the instruction onto the worklist stack.
+  /// Instructions that have been added first will be visited last.
+  void push(Instruction *I) {
+    assert(I);
+    assert(I->getParent() && "Instruction not inserted yet?");
+
     if (WorklistMap.insert(std::make_pair(I, Worklist.size())).second) {
       LLVM_DEBUG(dbgs() << "IC: ADD: " << *I << '\n');
       Worklist.push_back(I);
     }
   }
 
-  void AddValue(Value *V) {
+  void pushValue(Value *V) {
     if (Instruction *I = dyn_cast<Instruction>(V))
-      Add(I);
+      push(I);
   }
 
-  /// AddInitialGroup - Add the specified batch of stuff in reverse order.
-  /// which should only be done when the worklist is empty and when the group
-  /// has no duplicates.
-  void AddInitialGroup(ArrayRef<Instruction *> List) {
-    assert(Worklist.empty() && "Worklist must be empty to add initial group");
-    Worklist.reserve(List.size()+16);
-    WorklistMap.reserve(List.size());
-    LLVM_DEBUG(dbgs() << "IC: ADDING: " << List.size()
-                      << " instrs to worklist\n");
-    unsigned Idx = 0;
-    for (Instruction *I : reverse(List)) {
-      WorklistMap.insert(std::make_pair(I, Idx++));
-      Worklist.push_back(I);
-    }
+  Instruction *popDeferred() {
+    if (Deferred.empty())
+      return nullptr;
+    return Deferred.pop_back_val();
   }
 
-  // Remove - remove I from the worklist if it exists.
-  void Remove(Instruction *I) {
+  void reserve(size_t Size) {
+    Worklist.reserve(Size + 16);
+    WorklistMap.reserve(Size);
+  }
+
+  /// Remove I from the worklist if it exists.
+  void remove(Instruction *I) {
     DenseMap<Instruction*, unsigned>::iterator It = WorklistMap.find(I);
-    if (It == WorklistMap.end()) return; // Not in worklist.
+    if (It != WorklistMap.end()) {
+      // Don't bother moving everything down, just null out the slot.
+      Worklist[It->second] = nullptr;
+      WorklistMap.erase(It);
+    }
 
-    // Don't bother moving everything down, just null out the slot.
-    Worklist[It->second] = nullptr;
-
-    WorklistMap.erase(It);
+    Deferred.remove(I);
   }
 
-  Instruction *RemoveOne() {
+  Instruction *removeOne() {
+    if (Worklist.empty())
+      return nullptr;
     Instruction *I = Worklist.pop_back_val();
     WorklistMap.erase(I);
     return I;
   }
 
-  /// AddUsersToWorkList - When an instruction is simplified, add all users of
-  /// the instruction to the work lists because they might get more simplified
-  /// now.
-  ///
-  void AddUsersToWorkList(Instruction &I) {
+  /// When an instruction is simplified, add all users of the instruction
+  /// to the work lists because they might get more simplified now.
+  void pushUsersToWorkList(Instruction &I) {
     for (User *U : I.users())
-      Add(cast<Instruction>(U));
+      push(cast<Instruction>(U));
   }
 
 
-  /// Zap - check that the worklist is empty and nuke the backing store for
-  /// the map if it is large.
-  void Zap() {
+  /// Check that the worklist is empty and nuke the backing store for the map.
+  void zap() {
     assert(WorklistMap.empty() && "Worklist empty, but map not?");
+    assert(Deferred.empty() && "Deferred instructions left over");
 
     // Do an explicit clear, this shrinks the map if needed.
     WorklistMap.clear();
diff --git a/linux-x64/clang/include/llvm/Transforms/InstCombine/InstCombiner.h b/linux-x64/clang/include/llvm/Transforms/InstCombine/InstCombiner.h
new file mode 100644
index 0000000..a5aed72
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Transforms/InstCombine/InstCombiner.h
@@ -0,0 +1,529 @@
+//===- InstCombiner.h - InstCombine implementation --------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+/// \file
+///
+/// This file provides the interface for the instcombine pass implementation.
+/// The interface is used for generic transformations in this folder and
+/// target specific combinations in the targets.
+/// The visitor implementation is in \c InstCombinerImpl in
+/// \c InstCombineInternal.h.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_INSTCOMBINE_INSTCOMBINER_H
+#define LLVM_TRANSFORMS_INSTCOMBINE_INSTCOMBINER_H
+
+#include "llvm/Analysis/InstructionSimplify.h"
+#include "llvm/Analysis/TargetFolder.h"
+#include "llvm/Analysis/ValueTracking.h"
+#include "llvm/IR/IRBuilder.h"
+#include "llvm/IR/PatternMatch.h"
+#include "llvm/Support/Debug.h"
+#include "llvm/Support/KnownBits.h"
+#include "llvm/Transforms/InstCombine/InstCombineWorklist.h"
+#include <cassert>
+
+#define DEBUG_TYPE "instcombine"
+
+namespace llvm {
+
+class AAResults;
+class AssumptionCache;
+class ProfileSummaryInfo;
+class TargetLibraryInfo;
+class TargetTransformInfo;
+
+/// The core instruction combiner logic.
+///
+/// This class provides both the logic to recursively visit instructions and
+/// combine them.
+class LLVM_LIBRARY_VISIBILITY InstCombiner {
+  /// Only used to call target specific inst combining.
+  TargetTransformInfo &TTI;
+
+public:
+  /// Maximum size of array considered when transforming.
+  uint64_t MaxArraySizeForCombine = 0;
+
+  /// An IRBuilder that automatically inserts new instructions into the
+  /// worklist.
+  using BuilderTy = IRBuilder<TargetFolder, IRBuilderCallbackInserter>;
+  BuilderTy &Builder;
+
+protected:
+  /// A worklist of the instructions that need to be simplified.
+  InstCombineWorklist &Worklist;
+
+  // Mode in which we are running the combiner.
+  const bool MinimizeSize;
+
+  AAResults *AA;
+
+  // Required analyses.
+  AssumptionCache &AC;
+  TargetLibraryInfo &TLI;
+  DominatorTree &DT;
+  const DataLayout &DL;
+  const SimplifyQuery SQ;
+  OptimizationRemarkEmitter &ORE;
+  BlockFrequencyInfo *BFI;
+  ProfileSummaryInfo *PSI;
+
+  // Optional analyses. When non-null, these can both be used to do better
+  // combining and will be updated to reflect any changes.
+  LoopInfo *LI;
+
+  bool MadeIRChange = false;
+
+public:
+  InstCombiner(InstCombineWorklist &Worklist, BuilderTy &Builder,
+               bool MinimizeSize, AAResults *AA, AssumptionCache &AC,
+               TargetLibraryInfo &TLI, TargetTransformInfo &TTI,
+               DominatorTree &DT, OptimizationRemarkEmitter &ORE,
+               BlockFrequencyInfo *BFI, ProfileSummaryInfo *PSI,
+               const DataLayout &DL, LoopInfo *LI)
+      : TTI(TTI), Builder(Builder), Worklist(Worklist),
+        MinimizeSize(MinimizeSize), AA(AA), AC(AC), TLI(TLI), DT(DT), DL(DL),
+        SQ(DL, &TLI, &DT, &AC), ORE(ORE), BFI(BFI), PSI(PSI), LI(LI) {}
+
+  virtual ~InstCombiner() {}
+
+  /// Return the source operand of a potentially bitcasted value while
+  /// optionally checking if it has one use. If there is no bitcast or the one
+  /// use check is not met, return the input value itself.
+  static Value *peekThroughBitcast(Value *V, bool OneUseOnly = false) {
+    if (auto *BitCast = dyn_cast<BitCastInst>(V))
+      if (!OneUseOnly || BitCast->hasOneUse())
+        return BitCast->getOperand(0);
+
+    // V is not a bitcast or V has more than one use and OneUseOnly is true.
+    return V;
+  }
+
+  /// Assign a complexity or rank value to LLVM Values. This is used to reduce
+  /// the amount of pattern matching needed for compares and commutative
+  /// instructions. For example, if we have:
+  ///   icmp ugt X, Constant
+  /// or
+  ///   xor (add X, Constant), cast Z
+  ///
+  /// We do not have to consider the commuted variants of these patterns because
+  /// canonicalization based on complexity guarantees the above ordering.
+  ///
+  /// This routine maps IR values to various complexity ranks:
+  ///   0 -> undef
+  ///   1 -> Constants
+  ///   2 -> Other non-instructions
+  ///   3 -> Arguments
+  ///   4 -> Cast and (f)neg/not instructions
+  ///   5 -> Other instructions
+  static unsigned getComplexity(Value *V) {
+    if (isa<Instruction>(V)) {
+      if (isa<CastInst>(V) || match(V, m_Neg(PatternMatch::m_Value())) ||
+          match(V, m_Not(PatternMatch::m_Value())) ||
+          match(V, m_FNeg(PatternMatch::m_Value())))
+        return 4;
+      return 5;
+    }
+    if (isa<Argument>(V))
+      return 3;
+    return isa<Constant>(V) ? (isa<UndefValue>(V) ? 0 : 1) : 2;
+  }
+
+  /// Predicate canonicalization reduces the number of patterns that need to be
+  /// matched by other transforms. For example, we may swap the operands of a
+  /// conditional branch or select to create a compare with a canonical
+  /// (inverted) predicate which is then more likely to be matched with other
+  /// values.
+  static bool isCanonicalPredicate(CmpInst::Predicate Pred) {
+    switch (Pred) {
+    case CmpInst::ICMP_NE:
+    case CmpInst::ICMP_ULE:
+    case CmpInst::ICMP_SLE:
+    case CmpInst::ICMP_UGE:
+    case CmpInst::ICMP_SGE:
+    // TODO: There are 16 FCMP predicates. Should others be (not) canonical?
+    case CmpInst::FCMP_ONE:
+    case CmpInst::FCMP_OLE:
+    case CmpInst::FCMP_OGE:
+      return false;
+    default:
+      return true;
+    }
+  }
+
+  /// Given an exploded icmp instruction, return true if the comparison only
+  /// checks the sign bit. If it only checks the sign bit, set TrueIfSigned if
+  /// the result of the comparison is true when the input value is signed.
+  static bool isSignBitCheck(ICmpInst::Predicate Pred, const APInt &RHS,
+                             bool &TrueIfSigned) {
+    switch (Pred) {
+    case ICmpInst::ICMP_SLT: // True if LHS s< 0
+      TrueIfSigned = true;
+      return RHS.isNullValue();
+    case ICmpInst::ICMP_SLE: // True if LHS s<= -1
+      TrueIfSigned = true;
+      return RHS.isAllOnesValue();
+    case ICmpInst::ICMP_SGT: // True if LHS s> -1
+      TrueIfSigned = false;
+      return RHS.isAllOnesValue();
+    case ICmpInst::ICMP_SGE: // True if LHS s>= 0
+      TrueIfSigned = false;
+      return RHS.isNullValue();
+    case ICmpInst::ICMP_UGT:
+      // True if LHS u> RHS and RHS == sign-bit-mask - 1
+      TrueIfSigned = true;
+      return RHS.isMaxSignedValue();
+    case ICmpInst::ICMP_UGE:
+      // True if LHS u>= RHS and RHS == sign-bit-mask (2^7, 2^15, 2^31, etc)
+      TrueIfSigned = true;
+      return RHS.isMinSignedValue();
+    case ICmpInst::ICMP_ULT:
+      // True if LHS u< RHS and RHS == sign-bit-mask (2^7, 2^15, 2^31, etc)
+      TrueIfSigned = false;
+      return RHS.isMinSignedValue();
+    case ICmpInst::ICMP_ULE:
+      // True if LHS u<= RHS and RHS == sign-bit-mask - 1
+      TrueIfSigned = false;
+      return RHS.isMaxSignedValue();
+    default:
+      return false;
+    }
+  }
+
+  /// Add one to a Constant
+  static Constant *AddOne(Constant *C) {
+    return ConstantExpr::getAdd(C, ConstantInt::get(C->getType(), 1));
+  }
+
+  /// Subtract one from a Constant
+  static Constant *SubOne(Constant *C) {
+    return ConstantExpr::getSub(C, ConstantInt::get(C->getType(), 1));
+  }
+
+  llvm::Optional<std::pair<
+      CmpInst::Predicate,
+      Constant *>> static getFlippedStrictnessPredicateAndConstant(CmpInst::
+                                                                       Predicate
+                                                                           Pred,
+                                                                   Constant *C);
+
+  static bool shouldAvoidAbsorbingNotIntoSelect(const SelectInst &SI) {
+    // a ? b : false and a ? true : b are the canonical form of logical and/or.
+    // This includes !a ? b : false and !a ? true : b. Absorbing the not into
+    // the select by swapping operands would break recognition of this pattern
+    // in other analyses, so don't do that.
+    return match(&SI, PatternMatch::m_LogicalAnd(PatternMatch::m_Value(),
+                                                 PatternMatch::m_Value())) ||
+           match(&SI, PatternMatch::m_LogicalOr(PatternMatch::m_Value(),
+                                                PatternMatch::m_Value()));
+  }
+
+  /// Return true if the specified value is free to invert (apply ~ to).
+  /// This happens in cases where the ~ can be eliminated.  If WillInvertAllUses
+  /// is true, work under the assumption that the caller intends to remove all
+  /// uses of V and only keep uses of ~V.
+  ///
+  /// See also: canFreelyInvertAllUsersOf()
+  static bool isFreeToInvert(Value *V, bool WillInvertAllUses) {
+    // ~(~(X)) -> X.
+    if (match(V, m_Not(PatternMatch::m_Value())))
+      return true;
+
+    // Constants can be considered to be not'ed values.
+    if (match(V, PatternMatch::m_AnyIntegralConstant()))
+      return true;
+
+    // Compares can be inverted if all of their uses are being modified to use
+    // the ~V.
+    if (isa<CmpInst>(V))
+      return WillInvertAllUses;
+
+    // If `V` is of the form `A + Constant` then `-1 - V` can be folded into
+    // `(-1 - Constant) - A` if we are willing to invert all of the uses.
+    if (BinaryOperator *BO = dyn_cast<BinaryOperator>(V))
+      if (BO->getOpcode() == Instruction::Add ||
+          BO->getOpcode() == Instruction::Sub)
+        if (isa<Constant>(BO->getOperand(0)) ||
+            isa<Constant>(BO->getOperand(1)))
+          return WillInvertAllUses;
+
+    // Selects with invertible operands are freely invertible
+    if (match(V,
+              m_Select(PatternMatch::m_Value(), m_Not(PatternMatch::m_Value()),
+                       m_Not(PatternMatch::m_Value()))))
+      return WillInvertAllUses;
+
+    return false;
+  }
+
+  /// Given i1 V, can every user of V be freely adapted if V is changed to !V ?
+  /// InstCombine's canonicalizeICmpPredicate() must be kept in sync with this
+  /// fn.
+  ///
+  /// See also: isFreeToInvert()
+  static bool canFreelyInvertAllUsersOf(Value *V, Value *IgnoredUser) {
+    // Look at every user of V.
+    for (Use &U : V->uses()) {
+      if (U.getUser() == IgnoredUser)
+        continue; // Don't consider this user.
+
+      auto *I = cast<Instruction>(U.getUser());
+      switch (I->getOpcode()) {
+      case Instruction::Select:
+        if (U.getOperandNo() != 0) // Only if the value is used as select cond.
+          return false;
+        if (shouldAvoidAbsorbingNotIntoSelect(*cast<SelectInst>(I)))
+          return false;
+        break;
+      case Instruction::Br:
+        assert(U.getOperandNo() == 0 && "Must be branching on that value.");
+        break; // Free to invert by swapping true/false values/destinations.
+      case Instruction::Xor: // Can invert 'xor' if it's a 'not', by ignoring
+                             // it.
+        if (!match(I, m_Not(PatternMatch::m_Value())))
+          return false; // Not a 'not'.
+        break;
+      default:
+        return false; // Don't know, likely not freely invertible.
+      }
+      // So far all users were free to invert...
+    }
+    return true; // Can freely invert all users!
+  }
+
+  /// Some binary operators require special handling to avoid poison and
+  /// undefined behavior. If a constant vector has undef elements, replace those
+  /// undefs with identity constants if possible because those are always safe
+  /// to execute. If no identity constant exists, replace undef with some other
+  /// safe constant.
+  static Constant *
+  getSafeVectorConstantForBinop(BinaryOperator::BinaryOps Opcode, Constant *In,
+                                bool IsRHSConstant) {
+    auto *InVTy = cast<FixedVectorType>(In->getType());
+
+    Type *EltTy = InVTy->getElementType();
+    auto *SafeC = ConstantExpr::getBinOpIdentity(Opcode, EltTy, IsRHSConstant);
+    if (!SafeC) {
+      // TODO: Should this be available as a constant utility function? It is
+      // similar to getBinOpAbsorber().
+      if (IsRHSConstant) {
+        switch (Opcode) {
+        case Instruction::SRem: // X % 1 = 0
+        case Instruction::URem: // X %u 1 = 0
+          SafeC = ConstantInt::get(EltTy, 1);
+          break;
+        case Instruction::FRem: // X % 1.0 (doesn't simplify, but it is safe)
+          SafeC = ConstantFP::get(EltTy, 1.0);
+          break;
+        default:
+          llvm_unreachable(
+              "Only rem opcodes have no identity constant for RHS");
+        }
+      } else {
+        switch (Opcode) {
+        case Instruction::Shl:  // 0 << X = 0
+        case Instruction::LShr: // 0 >>u X = 0
+        case Instruction::AShr: // 0 >> X = 0
+        case Instruction::SDiv: // 0 / X = 0
+        case Instruction::UDiv: // 0 /u X = 0
+        case Instruction::SRem: // 0 % X = 0
+        case Instruction::URem: // 0 %u X = 0
+        case Instruction::Sub:  // 0 - X (doesn't simplify, but it is safe)
+        case Instruction::FSub: // 0.0 - X (doesn't simplify, but it is safe)
+        case Instruction::FDiv: // 0.0 / X (doesn't simplify, but it is safe)
+        case Instruction::FRem: // 0.0 % X = 0
+          SafeC = Constant::getNullValue(EltTy);
+          break;
+        default:
+          llvm_unreachable("Expected to find identity constant for opcode");
+        }
+      }
+    }
+    assert(SafeC && "Must have safe constant for binop");
+    unsigned NumElts = InVTy->getNumElements();
+    SmallVector<Constant *, 16> Out(NumElts);
+    for (unsigned i = 0; i != NumElts; ++i) {
+      Constant *C = In->getAggregateElement(i);
+      Out[i] = isa<UndefValue>(C) ? SafeC : C;
+    }
+    return ConstantVector::get(Out);
+  }
+
+  /// Create and insert the idiom we use to indicate a block is unreachable
+  /// without having to rewrite the CFG from within InstCombine.
+  static void CreateNonTerminatorUnreachable(Instruction *InsertAt) {
+    auto &Ctx = InsertAt->getContext();
+    new StoreInst(ConstantInt::getTrue(Ctx),
+                  UndefValue::get(Type::getInt1PtrTy(Ctx)), InsertAt);
+  }
+
+  void addToWorklist(Instruction *I) { Worklist.push(I); }
+
+  AssumptionCache &getAssumptionCache() const { return AC; }
+  TargetLibraryInfo &getTargetLibraryInfo() const { return TLI; }
+  DominatorTree &getDominatorTree() const { return DT; }
+  const DataLayout &getDataLayout() const { return DL; }
+  const SimplifyQuery &getSimplifyQuery() const { return SQ; }
+  OptimizationRemarkEmitter &getOptimizationRemarkEmitter() const {
+    return ORE;
+  }
+  BlockFrequencyInfo *getBlockFrequencyInfo() const { return BFI; }
+  ProfileSummaryInfo *getProfileSummaryInfo() const { return PSI; }
+  LoopInfo *getLoopInfo() const { return LI; }
+
+  // Call target specific combiners
+  Optional<Instruction *> targetInstCombineIntrinsic(IntrinsicInst &II);
+  Optional<Value *>
+  targetSimplifyDemandedUseBitsIntrinsic(IntrinsicInst &II, APInt DemandedMask,
+                                         KnownBits &Known,
+                                         bool &KnownBitsComputed);
+  Optional<Value *> targetSimplifyDemandedVectorEltsIntrinsic(
+      IntrinsicInst &II, APInt DemandedElts, APInt &UndefElts,
+      APInt &UndefElts2, APInt &UndefElts3,
+      std::function<void(Instruction *, unsigned, APInt, APInt &)>
+          SimplifyAndSetOp);
+
+  /// Inserts an instruction \p New before instruction \p Old
+  ///
+  /// Also adds the new instruction to the worklist and returns \p New so that
+  /// it is suitable for use as the return from the visitation patterns.
+  Instruction *InsertNewInstBefore(Instruction *New, Instruction &Old) {
+    assert(New && !New->getParent() &&
+           "New instruction already inserted into a basic block!");
+    BasicBlock *BB = Old.getParent();
+    BB->getInstList().insert(Old.getIterator(), New); // Insert inst
+    Worklist.push(New);
+    return New;
+  }
+
+  /// Same as InsertNewInstBefore, but also sets the debug loc.
+  Instruction *InsertNewInstWith(Instruction *New, Instruction &Old) {
+    New->setDebugLoc(Old.getDebugLoc());
+    return InsertNewInstBefore(New, Old);
+  }
+
+  /// A combiner-aware RAUW-like routine.
+  ///
+  /// This method is to be used when an instruction is found to be dead,
+  /// replaceable with another preexisting expression. Here we add all uses of
+  /// I to the worklist, replace all uses of I with the new value, then return
+  /// I, so that the inst combiner will know that I was modified.
+  Instruction *replaceInstUsesWith(Instruction &I, Value *V) {
+    // If there are no uses to replace, then we return nullptr to indicate that
+    // no changes were made to the program.
+    if (I.use_empty())
+      return nullptr;
+
+    Worklist.pushUsersToWorkList(I); // Add all modified instrs to worklist.
+
+    // If we are replacing the instruction with itself, this must be in a
+    // segment of unreachable code, so just clobber the instruction.
+    if (&I == V)
+      V = UndefValue::get(I.getType());
+
+    LLVM_DEBUG(dbgs() << "IC: Replacing " << I << "\n"
+                      << "    with " << *V << '\n');
+
+    I.replaceAllUsesWith(V);
+    return &I;
+  }
+
+  /// Replace operand of instruction and add old operand to the worklist.
+  Instruction *replaceOperand(Instruction &I, unsigned OpNum, Value *V) {
+    Worklist.addValue(I.getOperand(OpNum));
+    I.setOperand(OpNum, V);
+    return &I;
+  }
+
+  /// Replace use and add the previously used value to the worklist.
+  void replaceUse(Use &U, Value *NewValue) {
+    Worklist.addValue(U);
+    U = NewValue;
+  }
+
+  /// Combiner aware instruction erasure.
+  ///
+  /// When dealing with an instruction that has side effects or produces a void
+  /// value, we can't rely on DCE to delete the instruction. Instead, visit
+  /// methods should return the value returned by this function.
+  virtual Instruction *eraseInstFromFunction(Instruction &I) = 0;
+
+  void computeKnownBits(const Value *V, KnownBits &Known, unsigned Depth,
+                        const Instruction *CxtI) const {
+    llvm::computeKnownBits(V, Known, DL, Depth, &AC, CxtI, &DT);
+  }
+
+  KnownBits computeKnownBits(const Value *V, unsigned Depth,
+                             const Instruction *CxtI) const {
+    return llvm::computeKnownBits(V, DL, Depth, &AC, CxtI, &DT);
+  }
+
+  bool isKnownToBeAPowerOfTwo(const Value *V, bool OrZero = false,
+                              unsigned Depth = 0,
+                              const Instruction *CxtI = nullptr) {
+    return llvm::isKnownToBeAPowerOfTwo(V, DL, OrZero, Depth, &AC, CxtI, &DT);
+  }
+
+  bool MaskedValueIsZero(const Value *V, const APInt &Mask, unsigned Depth = 0,
+                         const Instruction *CxtI = nullptr) const {
+    return llvm::MaskedValueIsZero(V, Mask, DL, Depth, &AC, CxtI, &DT);
+  }
+
+  unsigned ComputeNumSignBits(const Value *Op, unsigned Depth = 0,
+                              const Instruction *CxtI = nullptr) const {
+    return llvm::ComputeNumSignBits(Op, DL, Depth, &AC, CxtI, &DT);
+  }
+
+  OverflowResult computeOverflowForUnsignedMul(const Value *LHS,
+                                               const Value *RHS,
+                                               const Instruction *CxtI) const {
+    return llvm::computeOverflowForUnsignedMul(LHS, RHS, DL, &AC, CxtI, &DT);
+  }
+
+  OverflowResult computeOverflowForSignedMul(const Value *LHS, const Value *RHS,
+                                             const Instruction *CxtI) const {
+    return llvm::computeOverflowForSignedMul(LHS, RHS, DL, &AC, CxtI, &DT);
+  }
+
+  OverflowResult computeOverflowForUnsignedAdd(const Value *LHS,
+                                               const Value *RHS,
+                                               const Instruction *CxtI) const {
+    return llvm::computeOverflowForUnsignedAdd(LHS, RHS, DL, &AC, CxtI, &DT);
+  }
+
+  OverflowResult computeOverflowForSignedAdd(const Value *LHS, const Value *RHS,
+                                             const Instruction *CxtI) const {
+    return llvm::computeOverflowForSignedAdd(LHS, RHS, DL, &AC, CxtI, &DT);
+  }
+
+  OverflowResult computeOverflowForUnsignedSub(const Value *LHS,
+                                               const Value *RHS,
+                                               const Instruction *CxtI) const {
+    return llvm::computeOverflowForUnsignedSub(LHS, RHS, DL, &AC, CxtI, &DT);
+  }
+
+  OverflowResult computeOverflowForSignedSub(const Value *LHS, const Value *RHS,
+                                             const Instruction *CxtI) const {
+    return llvm::computeOverflowForSignedSub(LHS, RHS, DL, &AC, CxtI, &DT);
+  }
+
+  virtual bool SimplifyDemandedBits(Instruction *I, unsigned OpNo,
+                                    const APInt &DemandedMask, KnownBits &Known,
+                                    unsigned Depth = 0) = 0;
+  virtual Value *
+  SimplifyDemandedVectorElts(Value *V, APInt DemandedElts, APInt &UndefElts,
+                             unsigned Depth = 0,
+                             bool AllowMultipleUsers = false) = 0;
+};
+
+} // namespace llvm
+
+#undef DEBUG_TYPE
+
+#endif
diff --git a/linux-x64/clang/include/llvm/Transforms/Instrumentation.h b/linux-x64/clang/include/llvm/Transforms/Instrumentation.h
index 8b70d29..c960d5b 100644
--- a/linux-x64/clang/include/llvm/Transforms/Instrumentation.h
+++ b/linux-x64/clang/include/llvm/Transforms/Instrumentation.h
@@ -28,6 +28,7 @@
 class ModulePass;
 class OptimizationRemarkEmitter;
 class Comdat;
+class CallBase;
 
 /// Instrumentation passes often insert conditional checks into entry blocks.
 /// Call this function before splitting the entry block to move instructions
@@ -62,20 +63,11 @@
   // gcc's gcov-io.h
   char Version[4];
 
-  // Emit a "cfg checksum" that follows the "line number checksum" of a
-  // function. This affects both .gcno and .gcda files.
-  bool UseCfgChecksum;
-
   // Add the 'noredzone' attribute to added runtime library calls.
   bool NoRedZone;
 
-  // Emit the name of the function in the .gcda files. This is redundant, as
-  // the function identifier can be used to find the name from the .gcno file.
-  bool FunctionNamesInData;
-
-  // Emit the exit block immediately after the start block, rather than after
-  // all of the function body's blocks.
-  bool ExitBlockBeforeBody;
+  // Use atomic profile counter increments.
+  bool Atomic = false;
 
   // Regexes separated by a semi-colon to filter the files to instrument.
   std::string Filter;
@@ -99,6 +91,8 @@
                                                      bool SamplePGO = false);
 FunctionPass *createPGOMemOPSizeOptLegacyPass();
 
+ModulePass *createCGProfileLegacyPass();
+
 // The pgo-specific indirect call promotion function declared below is used by
 // the pgo-driven indirect call promotion and sample profile passes. It's a
 // wrapper around llvm::promoteCall, et al. that additionally computes !prof
@@ -106,7 +100,7 @@
 // generic utilities.
 namespace pgo {
 
-// Helper function that transforms Inst (either an indirect-call instruction, or
+// Helper function that transforms CB (either an indirect-call instruction, or
 // an invoke instruction , to a conditional call to F. This is like:
 //     if (Inst.CalledValue == F)
 //        F(...);
@@ -119,10 +113,9 @@
 // If \p AttachProfToDirectCall is true, a prof metadata is attached to the
 // new direct call to contain \p Count.
 // Returns the promoted direct call instruction.
-Instruction *promoteIndirectCall(Instruction *Inst, Function *F, uint64_t Count,
-                                 uint64_t TotalCount,
-                                 bool AttachProfToDirectCall,
-                                 OptimizationRemarkEmitter *ORE);
+CallBase &promoteIndirectCall(CallBase &CB, Function *F, uint64_t Count,
+                              uint64_t TotalCount, bool AttachProfToDirectCall,
+                              OptimizationRemarkEmitter *ORE);
 } // namespace pgo
 
 /// Options for the frontend instrumentation based profiling pass.
@@ -153,9 +146,8 @@
 ModulePass *createInstrOrderFilePass();
 
 // Insert DataFlowSanitizer (dynamic data flow analysis) instrumentation
-ModulePass *createDataFlowSanitizerPass(
-    const std::vector<std::string> &ABIListFiles = std::vector<std::string>(),
-    void *(*getArgTLS)() = nullptr, void *(*getRetValTLS)() = nullptr);
+ModulePass *createDataFlowSanitizerLegacyPassPass(
+    const std::vector<std::string> &ABIListFiles = std::vector<std::string>());
 
 // Options for sanitizer coverage instrumentation.
 struct SanitizerCoverageOptions {
@@ -174,6 +166,7 @@
   bool TracePC = false;
   bool TracePCGuard = false;
   bool Inline8bitCounters = false;
+  bool InlineBoolFlag = false;
   bool PCTable = false;
   bool NoPrune = false;
   bool StackDepth = false;
@@ -181,10 +174,6 @@
   SanitizerCoverageOptions() = default;
 };
 
-// Insert SanitizerCoverage instrumentation.
-ModulePass *createSanitizerCoverageModulePass(
-    const SanitizerCoverageOptions &Options = SanitizerCoverageOptions());
-
 /// Calculate what to divide by to scale counts.
 ///
 /// Given the maximum count, calculate a divisor that will scale all the
diff --git a/linux-x64/clang/include/llvm/Transforms/Instrumentation/AddressSanitizer.h b/linux-x64/clang/include/llvm/Transforms/Instrumentation/AddressSanitizer.h
index 40007a9..53ad0cb 100644
--- a/linux-x64/clang/include/llvm/Transforms/Instrumentation/AddressSanitizer.h
+++ b/linux-x64/clang/include/llvm/Transforms/Instrumentation/AddressSanitizer.h
@@ -39,7 +39,7 @@
     LocationMetadata SourceLoc;
     StringRef Name;
     bool IsDynInit = false;
-    bool IsBlacklisted = false;
+    bool IsExcluded = false;
 
     Entry() = default;
   };
@@ -102,6 +102,7 @@
                                 bool Recover = false,
                                 bool UseAfterScope = false);
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static bool isRequired() { return true; }
 
 private:
   bool CompileKernel;
@@ -122,6 +123,7 @@
                                       bool UseGlobalGC = true,
                                       bool UseOdrIndicator = false);
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+  static bool isRequired() { return true; }
 
 private:
   bool CompileKernel;
diff --git a/linux-x64/clang/include/llvm/Transforms/Instrumentation/AddressSanitizerCommon.h b/linux-x64/clang/include/llvm/Transforms/Instrumentation/AddressSanitizerCommon.h
new file mode 100644
index 0000000..7da0bf8
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Transforms/Instrumentation/AddressSanitizerCommon.h
@@ -0,0 +1,49 @@
+//===--------- Definition of the AddressSanitizer class ---------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file declares common infrastructure for AddressSanitizer and
+// HWAddressSanitizer.
+//
+//===----------------------------------------------------------------------===//
+#ifndef LLVM_TRANSFORMS_INSTRUMENTATION_ADDRESSSANITIZERCOMMON_H
+#define LLVM_TRANSFORMS_INSTRUMENTATION_ADDRESSSANITIZERCOMMON_H
+
+#include "llvm/IR/Instruction.h"
+#include "llvm/IR/Module.h"
+
+namespace llvm {
+
+class InterestingMemoryOperand {
+public:
+  Use *PtrUse;
+  bool IsWrite;
+  Type *OpType;
+  uint64_t TypeSize;
+  MaybeAlign Alignment;
+  // The mask Value, if we're looking at a masked load/store.
+  Value *MaybeMask;
+
+  InterestingMemoryOperand(Instruction *I, unsigned OperandNo, bool IsWrite,
+                           class Type *OpType, MaybeAlign Alignment,
+                           Value *MaybeMask = nullptr)
+      : IsWrite(IsWrite), OpType(OpType), Alignment(Alignment),
+        MaybeMask(MaybeMask) {
+    const DataLayout &DL = I->getModule()->getDataLayout();
+    TypeSize = DL.getTypeStoreSizeInBits(OpType);
+    PtrUse = &I->getOperandUse(OperandNo);
+  }
+
+  Instruction *getInsn() { return cast<Instruction>(PtrUse->getUser()); }
+
+  Value *getPtr() { return PtrUse->get(); }
+};
+
+} // namespace llvm
+
+#endif
diff --git a/linux-x64/clang/include/llvm/Transforms/Instrumentation/BoundsChecking.h b/linux-x64/clang/include/llvm/Transforms/Instrumentation/BoundsChecking.h
index 120c6a8..8d70f14 100644
--- a/linux-x64/clang/include/llvm/Transforms/Instrumentation/BoundsChecking.h
+++ b/linux-x64/clang/include/llvm/Transforms/Instrumentation/BoundsChecking.h
@@ -17,6 +17,7 @@
 /// stores, and other memory intrinsics.
 struct BoundsCheckingPass : PassInfoMixin<BoundsCheckingPass> {
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static bool isRequired() { return true; }
 };
 
 
diff --git a/linux-x64/clang/include/llvm/Transforms/Instrumentation/CGProfile.h b/linux-x64/clang/include/llvm/Transforms/Instrumentation/CGProfile.h
index 28fd380..4cb45fd 100644
--- a/linux-x64/clang/include/llvm/Transforms/Instrumentation/CGProfile.h
+++ b/linux-x64/clang/include/llvm/Transforms/Instrumentation/CGProfile.h
@@ -19,11 +19,6 @@
 class CGProfilePass : public PassInfoMixin<CGProfilePass> {
 public:
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
-
-private:
-  void addModuleFlags(
-      Module &M,
-      MapVector<std::pair<Function *, Function *>, uint64_t> &Counts) const;
 };
 } // end namespace llvm
 
diff --git a/linux-x64/clang/include/llvm/Transforms/Instrumentation/DataFlowSanitizer.h b/linux-x64/clang/include/llvm/Transforms/Instrumentation/DataFlowSanitizer.h
new file mode 100644
index 0000000..9b57b1f
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Transforms/Instrumentation/DataFlowSanitizer.h
@@ -0,0 +1,32 @@
+//===- DataFlowSanitizer.h - dynamic data flow analysis -------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+#ifndef LLVM_TRANSFORMS_INSTRUMENTATION_DATAFLOWSANITIZER_H
+#define LLVM_TRANSFORMS_INSTRUMENTATION_DATAFLOWSANITIZER_H
+
+#include "llvm/IR/Module.h"
+#include "llvm/IR/PassManager.h"
+#include <string>
+#include <vector>
+
+namespace llvm {
+
+class DataFlowSanitizerPass : public PassInfoMixin<DataFlowSanitizerPass> {
+private:
+  std::vector<std::string> ABIListFiles;
+
+public:
+  DataFlowSanitizerPass(
+      const std::vector<std::string> &ABIListFiles = std::vector<std::string>())
+      : ABIListFiles(ABIListFiles) {}
+  PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+  static bool isRequired() { return true; }
+};
+
+} // namespace llvm
+
+#endif
diff --git a/linux-x64/clang/include/llvm/Transforms/Instrumentation/GCOVProfiler.h b/linux-x64/clang/include/llvm/Transforms/Instrumentation/GCOVProfiler.h
index b3971e4..2766cc5 100644
--- a/linux-x64/clang/include/llvm/Transforms/Instrumentation/GCOVProfiler.h
+++ b/linux-x64/clang/include/llvm/Transforms/Instrumentation/GCOVProfiler.h
@@ -26,5 +26,5 @@
   GCOVOptions GCOVOpts;
 };
 
-} // End llvm namespace
+} // namespace llvm
 #endif
diff --git a/linux-x64/clang/include/llvm/Transforms/Instrumentation/HWAddressSanitizer.h b/linux-x64/clang/include/llvm/Transforms/Instrumentation/HWAddressSanitizer.h
index e34cf6c..68b4732 100644
--- a/linux-x64/clang/include/llvm/Transforms/Instrumentation/HWAddressSanitizer.h
+++ b/linux-x64/clang/include/llvm/Transforms/Instrumentation/HWAddressSanitizer.h
@@ -26,7 +26,8 @@
 public:
   explicit HWAddressSanitizerPass(bool CompileKernel = false,
                                   bool Recover = false);
-  PreservedAnalyses run(Function &F, FunctionAnalysisManager &FAM);
+  PreservedAnalyses run(Module &M, ModuleAnalysisManager &MAM);
+  static bool isRequired() { return true; }
 
 private:
   bool CompileKernel;
@@ -36,6 +37,24 @@
 FunctionPass *createHWAddressSanitizerLegacyPassPass(bool CompileKernel = false,
                                                      bool Recover = false);
 
+namespace HWASanAccessInfo {
+
+// Bit field positions for the accessinfo parameter to
+// llvm.hwasan.check.memaccess. Shared between the pass and the backend. Bits
+// 0-15 are also used by the runtime.
+enum {
+  AccessSizeShift = 0, // 4 bits
+  IsWriteShift = 4,
+  RecoverShift = 5,
+  MatchAllShift = 16, // 8 bits
+  HasMatchAllShift = 24,
+  CompileKernelShift = 25,
+};
+
+enum { RuntimeMask = 0xffff };
+
+} // namespace HWASanAccessInfo
+
 } // namespace llvm
 
 #endif
diff --git a/linux-x64/clang/include/llvm/Transforms/Instrumentation/InstrProfiling.h b/linux-x64/clang/include/llvm/Transforms/Instrumentation/InstrProfiling.h
index 8f76d4a..5ce72cd 100644
--- a/linux-x64/clang/include/llvm/Transforms/Instrumentation/InstrProfiling.h
+++ b/linux-x64/clang/include/llvm/Transforms/Instrumentation/InstrProfiling.h
@@ -39,13 +39,14 @@
       : Options(Options), IsCS(IsCS) {}
 
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
-  bool run(Module &M, const TargetLibraryInfo &TLI);
+  bool run(Module &M,
+           std::function<const TargetLibraryInfo &(Function &F)> GetTLI);
 
 private:
   InstrProfOptions Options;
   Module *M;
   Triple TT;
-  const TargetLibraryInfo *TLI;
+  std::function<const TargetLibraryInfo &(Function &F)> GetTLI;
   struct PerFunctionProfileData {
     uint32_t NumValueSites[IPVK_Last + 1];
     GlobalVariable *RegionCounters = nullptr;
@@ -67,11 +68,6 @@
   // vector of counter load/store pairs to be register promoted.
   std::vector<LoadStorePair> PromotionCandidates;
 
-  // The start value of precise value profile range for memory intrinsic sizes.
-  int64_t MemOPSizeRangeStart;
-  // The end value of precise value profile range for memory intrinsic sizes.
-  int64_t MemOPSizeRangeLast;
-
   int64_t TotalCountersPromoted = 0;
 
   /// Lower instrumentation intrinsics in the function. Returns true if there
@@ -81,6 +77,9 @@
   /// Register-promote counter loads and stores in loops.
   void promoteCounterLoadStores(Function *F);
 
+  /// Returns true if relocating counters at runtime is enabled.
+  bool isRuntimeCounterRelocationEnabled() const;
+
   /// Returns true if profile counter update register promotion is enabled.
   bool isCounterPromotionEnabled() const;
 
diff --git a/linux-x64/clang/include/llvm/Transforms/Instrumentation/MemProfiler.h b/linux-x64/clang/include/llvm/Transforms/Instrumentation/MemProfiler.h
new file mode 100644
index 0000000..ac6a07d
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Transforms/Instrumentation/MemProfiler.h
@@ -0,0 +1,51 @@
+//===--------- Definition of the MemProfiler class --------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file declares the MemProfiler class.
+//
+//===----------------------------------------------------------------------===//
+#ifndef LLVM_TRANSFORMS_INSTRUMENTATION_MEMPROFILER_H
+#define LLVM_TRANSFORMS_INSTRUMENTATION_MEMPROFILER_H
+
+#include "llvm/IR/Function.h"
+#include "llvm/IR/Module.h"
+#include "llvm/IR/PassManager.h"
+
+namespace llvm {
+
+/// Public interface to the memory profiler pass for instrumenting code to
+/// profile memory accesses.
+///
+/// The profiler itself is a function pass that works by inserting various
+/// calls to the MemProfiler runtime library functions. The runtime library
+/// essentially replaces malloc() and free() with custom implementations that
+/// record data about the allocations.
+class MemProfilerPass : public PassInfoMixin<MemProfilerPass> {
+public:
+  explicit MemProfilerPass();
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static bool isRequired() { return true; }
+};
+
+/// Public interface to the memory profiler module pass for instrumenting code
+/// to profile memory allocations and accesses.
+class ModuleMemProfilerPass : public PassInfoMixin<ModuleMemProfilerPass> {
+public:
+  explicit ModuleMemProfilerPass();
+  PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+  static bool isRequired() { return true; }
+};
+
+// Insert MemProfiler instrumentation
+FunctionPass *createMemProfilerFunctionPass();
+ModulePass *createModuleMemProfilerLegacyPassPass();
+
+} // namespace llvm
+
+#endif
diff --git a/linux-x64/clang/include/llvm/Transforms/Instrumentation/MemorySanitizer.h b/linux-x64/clang/include/llvm/Transforms/Instrumentation/MemorySanitizer.h
index 0739d9e..f5f9ec7 100644
--- a/linux-x64/clang/include/llvm/Transforms/Instrumentation/MemorySanitizer.h
+++ b/linux-x64/clang/include/llvm/Transforms/Instrumentation/MemorySanitizer.h
@@ -19,12 +19,11 @@
 namespace llvm {
 
 struct MemorySanitizerOptions {
-  MemorySanitizerOptions() = default;
-  MemorySanitizerOptions(int TrackOrigins, bool Recover, bool Kernel)
-      : TrackOrigins(TrackOrigins), Recover(Recover), Kernel(Kernel) {}
-  int TrackOrigins = 0;
-  bool Recover = false;
-  bool Kernel = false;
+  MemorySanitizerOptions() : MemorySanitizerOptions(0, false, false){};
+  MemorySanitizerOptions(int TrackOrigins, bool Recover, bool Kernel);
+  bool Kernel;
+  int TrackOrigins;
+  bool Recover;
 };
 
 // Insert MemorySanitizer instrumentation (detection of uninitialized reads)
@@ -41,6 +40,8 @@
   MemorySanitizerPass(MemorySanitizerOptions Options) : Options(Options) {}
 
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &FAM);
+  PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+  static bool isRequired() { return true; }
 
 private:
   MemorySanitizerOptions Options;
diff --git a/linux-x64/clang/include/llvm/Transforms/Instrumentation/SanitizerCoverage.h b/linux-x64/clang/include/llvm/Transforms/Instrumentation/SanitizerCoverage.h
new file mode 100644
index 0000000..e3d268c
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Transforms/Instrumentation/SanitizerCoverage.h
@@ -0,0 +1,67 @@
+//===--------- Definition of the SanitizerCoverage class --------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file declares the SanitizerCoverage class which is a port of the legacy
+// SanitizerCoverage pass to use the new PassManager infrastructure.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_INSTRUMENTATION_SANITIZERCOVERAGE_H
+#define LLVM_TRANSFORMS_INSTRUMENTATION_SANITIZERCOVERAGE_H
+
+#include "llvm/IR/Module.h"
+#include "llvm/IR/PassManager.h"
+#include "llvm/Support/SpecialCaseList.h"
+#include "llvm/Support/VirtualFileSystem.h"
+#include "llvm/Transforms/Instrumentation.h"
+
+namespace llvm {
+
+/// This is the ModuleSanitizerCoverage pass used in the new pass manager. The
+/// pass instruments functions for coverage, adds initialization calls to the
+/// module for trace PC guards and 8bit counters if they are requested, and
+/// appends globals to llvm.compiler.used.
+class ModuleSanitizerCoveragePass
+    : public PassInfoMixin<ModuleSanitizerCoveragePass> {
+public:
+  explicit ModuleSanitizerCoveragePass(
+      SanitizerCoverageOptions Options = SanitizerCoverageOptions(),
+      const std::vector<std::string> &AllowlistFiles =
+          std::vector<std::string>(),
+      const std::vector<std::string> &BlocklistFiles =
+          std::vector<std::string>())
+      : Options(Options) {
+    if (AllowlistFiles.size() > 0)
+      Allowlist = SpecialCaseList::createOrDie(AllowlistFiles,
+                                               *vfs::getRealFileSystem());
+    if (BlocklistFiles.size() > 0)
+      Blocklist = SpecialCaseList::createOrDie(BlocklistFiles,
+                                               *vfs::getRealFileSystem());
+  }
+  PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+  static bool isRequired() { return true; }
+
+private:
+  SanitizerCoverageOptions Options;
+
+  std::unique_ptr<SpecialCaseList> Allowlist;
+  std::unique_ptr<SpecialCaseList> Blocklist;
+};
+
+// Insert SanitizerCoverage instrumentation.
+ModulePass *createModuleSanitizerCoverageLegacyPassPass(
+    const SanitizerCoverageOptions &Options = SanitizerCoverageOptions(),
+    const std::vector<std::string> &AllowlistFiles = std::vector<std::string>(),
+    const std::vector<std::string> &BlocklistFiles =
+        std::vector<std::string>());
+
+} // namespace llvm
+
+#endif
diff --git a/linux-x64/clang/include/llvm/Transforms/Instrumentation/ThreadSanitizer.h b/linux-x64/clang/include/llvm/Transforms/Instrumentation/ThreadSanitizer.h
index b4e7d99..f9c5076 100644
--- a/linux-x64/clang/include/llvm/Transforms/Instrumentation/ThreadSanitizer.h
+++ b/linux-x64/clang/include/llvm/Transforms/Instrumentation/ThreadSanitizer.h
@@ -27,6 +27,9 @@
 /// yet, the pass inserts the declarations. Otherwise the existing globals are
 struct ThreadSanitizerPass : public PassInfoMixin<ThreadSanitizerPass> {
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &FAM);
+  PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+  static bool isRequired() { return true; }
 };
+
 } // namespace llvm
 #endif /* LLVM_TRANSFORMS_INSTRUMENTATION_THREADSANITIZER_H */
diff --git a/linux-x64/clang/include/llvm/Transforms/ObjCARC.h b/linux-x64/clang/include/llvm/Transforms/ObjCARC.h
index 2f114c7..a89df95 100644
--- a/linux-x64/clang/include/llvm/Transforms/ObjCARC.h
+++ b/linux-x64/clang/include/llvm/Transforms/ObjCARC.h
@@ -14,6 +14,8 @@
 #ifndef LLVM_TRANSFORMS_OBJCARC_H
 #define LLVM_TRANSFORMS_OBJCARC_H
 
+#include "llvm/IR/PassManager.h"
+
 namespace llvm {
 
 class Pass;
@@ -42,6 +44,22 @@
 //
 Pass *createObjCARCOptPass();
 
+struct ObjCARCOptPass : public PassInfoMixin<ObjCARCOptPass> {
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+};
+
+struct ObjCARCContractPass : public PassInfoMixin<ObjCARCContractPass> {
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+};
+
+struct ObjCARCAPElimPass : public PassInfoMixin<ObjCARCAPElimPass> {
+  PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+};
+
+struct ObjCARCExpandPass : public PassInfoMixin<ObjCARCExpandPass> {
+  PreservedAnalyses run(Function &M, FunctionAnalysisManager &AM);
+};
+
 } // End llvm namespace
 
 #endif
diff --git a/linux-x64/clang/include/llvm/Transforms/Scalar.h b/linux-x64/clang/include/llvm/Transforms/Scalar.h
index f9360b5..3217257 100644
--- a/linux-x64/clang/include/llvm/Transforms/Scalar.h
+++ b/linux-x64/clang/include/llvm/Transforms/Scalar.h
@@ -14,25 +14,15 @@
 #ifndef LLVM_TRANSFORMS_SCALAR_H
 #define LLVM_TRANSFORMS_SCALAR_H
 
+#include "llvm/Transforms/Utils/SimplifyCFGOptions.h"
 #include <functional>
 
 namespace llvm {
 
-class BasicBlockPass;
 class Function;
 class FunctionPass;
 class ModulePass;
 class Pass;
-class GetElementPtrInst;
-class PassInfo;
-class TargetLowering;
-class TargetMachine;
-
-//===----------------------------------------------------------------------===//
-//
-// ConstantPropagation - A worklist driven constant propagation pass
-//
-FunctionPass *createConstantPropagationPass();
 
 //===----------------------------------------------------------------------===//
 //
@@ -43,17 +33,22 @@
 
 //===----------------------------------------------------------------------===//
 //
+// AnnotationRemarks - Emit remarks for !annotation metadata.
+//
+FunctionPass *createAnnotationRemarksLegacyPass();
+
+//===----------------------------------------------------------------------===//
+//
 // SCCP - Sparse conditional constant propagation.
 //
 FunctionPass *createSCCPPass();
 
 //===----------------------------------------------------------------------===//
 //
-// DeadInstElimination - This pass quickly removes trivially dead instructions
-// without modifying the CFG of the function.  It is a BasicBlockPass, so it
-// runs efficiently when queued next to other BasicBlockPass's.
+// RedundantDbgInstElimination - This pass removes redundant dbg intrinsics
+// without modifying the CFG of the function.  It is a FunctionPass.
 //
-Pass *createDeadInstEliminationPass();
+Pass *createRedundantDbgInstEliminationPass();
 
 //===----------------------------------------------------------------------===//
 //
@@ -162,6 +157,12 @@
 
 //===----------------------------------------------------------------------===//
 //
+// LoopFlatten - This pass flattens nested loops into a single loop.
+//
+FunctionPass *createLoopFlattenPass();
+
+//===----------------------------------------------------------------------===//
+//
 // LoopStrengthReduce - This pass is strength reduces GEP instructions that use
 // a loop's canonical induction variable as one of their indices.
 //
@@ -244,10 +245,12 @@
 //===----------------------------------------------------------------------===//
 //
 // JumpThreading - Thread control through mult-pred/multi-succ blocks where some
-// preds always go to some succ. Thresholds other than minus one override the
-// internal BB duplication default threshold.
+// preds always go to some succ. If FreezeSelectCond is true, unfold the
+// condition of a select that unfolds to branch. Thresholds other than minus one
+// override the internal BB duplication default threshold.
 //
-FunctionPass *createJumpThreadingPass(int Threshold = -1);
+FunctionPass *createJumpThreadingPass(bool FreezeSelectCond = false,
+                                      int Threshold = -1);
 
 //===----------------------------------------------------------------------===//
 //
@@ -255,8 +258,7 @@
 // simplify terminator instructions, convert switches to lookup tables, etc.
 //
 FunctionPass *createCFGSimplificationPass(
-    unsigned Threshold = 1, bool ForwardSwitchCond = false,
-    bool ConvertSwitch = false, bool KeepLoops = true, bool SinkCommon = false,
+    SimplifyCFGOptions Options = SimplifyCFGOptions(),
     std::function<bool(const Function &)> Ftor = nullptr);
 
 //===----------------------------------------------------------------------===//
@@ -308,7 +310,7 @@
 // MergedLoadStoreMotion - This pass merges loads and stores in diamonds. Loads
 // are hoisted into the header, while stores sink into the footer.
 //
-FunctionPass *createMergedLoadStoreMotionPass();
+FunctionPass *createMergedLoadStoreMotionPass(bool SplitFooterBB = false);
 
 //===----------------------------------------------------------------------===//
 //
@@ -345,6 +347,13 @@
 
 //===----------------------------------------------------------------------===//
 //
+// ConstraintElimination - This pass eliminates conditions based on found
+//                         constraints.
+//
+FunctionPass *createConstraintEliminationPass();
+
+//===----------------------------------------------------------------------===//
+//
 // Sink - Code Sinking
 //
 FunctionPass *createSinkingPass();
@@ -363,6 +372,19 @@
 
 //===----------------------------------------------------------------------===//
 //
+// LowerMatrixIntrinsics - Lower matrix intrinsics to vector operations.
+//
+Pass *createLowerMatrixIntrinsicsPass();
+
+//===----------------------------------------------------------------------===//
+//
+// LowerMatrixIntrinsicsMinimal - Lower matrix intrinsics to vector operations
+//                               (lightweight, does not require extra analysis)
+//
+Pass *createLowerMatrixIntrinsicsMinimalPass();
+
+//===----------------------------------------------------------------------===//
+//
 // LowerWidenableCondition - Lower widenable condition to i1 true.
 //
 Pass *createLowerWidenableConditionPass();
@@ -397,6 +419,13 @@
 
 //===----------------------------------------------------------------------===//
 //
+// LowerConstantIntrinsicss - Expand any remaining llvm.objectsize and
+// llvm.is.constant intrinsic calls, even for the unknown cases.
+//
+FunctionPass *createLowerConstantIntrinsicsPass();
+
+//===----------------------------------------------------------------------===//
+//
 // PartiallyInlineLibCalls - Tries to inline the fast path of library
 // calls such as sqrt.
 //
@@ -509,6 +538,21 @@
 // transformations.
 //
 Pass *createWarnMissedTransformationsPass();
+
+//===----------------------------------------------------------------------===//
+//
+// This pass does instruction simplification on each
+// instruction in a function.
+//
+FunctionPass *createInstSimplifyLegacyPass();
+
+
+//===----------------------------------------------------------------------===//
+//
+// createScalarizeMaskedMemIntrinPass - Replace masked load, store, gather
+// and scatter intrinsics with scalar code when target doesn't support them.
+//
+FunctionPass *createScalarizeMaskedMemIntrinLegacyPass();
 } // End llvm namespace
 
 #endif
diff --git a/linux-x64/clang/include/llvm/Transforms/Scalar/AlignmentFromAssumptions.h b/linux-x64/clang/include/llvm/Transforms/Scalar/AlignmentFromAssumptions.h
index fb1687e..10b6e1c 100644
--- a/linux-x64/clang/include/llvm/Transforms/Scalar/AlignmentFromAssumptions.h
+++ b/linux-x64/clang/include/llvm/Transforms/Scalar/AlignmentFromAssumptions.h
@@ -17,13 +17,15 @@
 #ifndef LLVM_TRANSFORMS_SCALAR_ALIGNMENTFROMASSUMPTIONS_H
 #define LLVM_TRANSFORMS_SCALAR_ALIGNMENTFROMASSUMPTIONS_H
 
-#include "llvm/Analysis/ScalarEvolution.h"
-#include "llvm/IR/Function.h"
-#include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 
+class AssumptionCache;
+class DominatorTree;
+class ScalarEvolution;
+class SCEV;
+
 struct AlignmentFromAssumptionsPass
     : public PassInfoMixin<AlignmentFromAssumptionsPass> {
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
@@ -35,9 +37,9 @@
   ScalarEvolution *SE = nullptr;
   DominatorTree *DT = nullptr;
 
-  bool extractAlignmentInfo(CallInst *I, Value *&AAPtr, const SCEV *&AlignSCEV,
-                            const SCEV *&OffSCEV);
-  bool processAssumption(CallInst *I);
+  bool extractAlignmentInfo(CallInst *I, unsigned Idx, Value *&AAPtr,
+                            const SCEV *&AlignSCEV, const SCEV *&OffSCEV);
+  bool processAssumption(CallInst *I, unsigned Idx);
 };
 }
 
diff --git a/linux-x64/clang/include/llvm/Transforms/Scalar/AnnotationRemarks.h b/linux-x64/clang/include/llvm/Transforms/Scalar/AnnotationRemarks.h
new file mode 100644
index 0000000..f161976
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Transforms/Scalar/AnnotationRemarks.h
@@ -0,0 +1,26 @@
+//===- AnnotationRemarks.cpp - Emit remarks for !annotation MD --*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// \file
+// This file defines AnnotationRemarksPass for the new pass manager.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_SCALAR_ANNOTATION_REMARKS_H
+#define LLVM_TRANSFORMS_SCALAR_ANNOTATION_REMARKS_H
+
+#include "llvm/IR/Function.h"
+#include "llvm/IR/PassManager.h"
+
+namespace llvm {
+struct AnnotationRemarksPass : public PassInfoMixin<AnnotationRemarksPass> {
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+};
+} // namespace llvm
+
+#endif // LLVM_TRANSFORMS_SCALAR_ANNOTATION_REMARKS_H
diff --git a/linux-x64/clang/include/llvm/Transforms/Scalar/CallSiteSplitting.h b/linux-x64/clang/include/llvm/Transforms/Scalar/CallSiteSplitting.h
index b605563..74cbf84 100644
--- a/linux-x64/clang/include/llvm/Transforms/Scalar/CallSiteSplitting.h
+++ b/linux-x64/clang/include/llvm/Transforms/Scalar/CallSiteSplitting.h
@@ -9,13 +9,8 @@
 #ifndef LLVM_TRANSFORMS_SCALAR_CALLSITESPLITTING__H
 #define LLVM_TRANSFORMS_SCALAR_CALLSITESPLITTING__H
 
-#include "llvm/ADT/SetVector.h"
-#include "llvm/Analysis/AssumptionCache.h"
-#include "llvm/IR/Dominators.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/PassManager.h"
-#include "llvm/Support/Compiler.h"
-#include <vector>
 
 namespace llvm {
 
diff --git a/linux-x64/clang/include/llvm/Transforms/Scalar/ConstantHoisting.h b/linux-x64/clang/include/llvm/Transforms/Scalar/ConstantHoisting.h
index 6b0fc9c..11379e5 100644
--- a/linux-x64/clang/include/llvm/Transforms/Scalar/ConstantHoisting.h
+++ b/linux-x64/clang/include/llvm/Transforms/Scalar/ConstantHoisting.h
@@ -14,7 +14,7 @@
 // cost. If the constant can be folded into the instruction (the cost is
 // TCC_Free) or the cost is just a simple operation (TCC_BASIC), then we don't
 // consider it expensive and leave it alone. This is the default behavior and
-// the default implementation of getIntImmCost will always return TCC_Free.
+// the default implementation of getIntImmCostInst will always return TCC_Free.
 //
 // If the cost is more than TCC_BASIC, then the integer constant can't be folded
 // into the instruction and it might be beneficial to hoist the constant.
@@ -37,7 +37,9 @@
 #define LLVM_TRANSFORMS_SCALAR_CONSTANTHOISTING_H
 
 #include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/PointerUnion.h"
+#include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/IR/PassManager.h"
@@ -154,21 +156,21 @@
 
   /// Keeps track of constant candidates found in the function.
   using ConstCandVecType = std::vector<consthoist::ConstantCandidate>;
-  using GVCandVecMapType = DenseMap<GlobalVariable *, ConstCandVecType>;
+  using GVCandVecMapType = MapVector<GlobalVariable *, ConstCandVecType>;
   ConstCandVecType ConstIntCandVec;
   GVCandVecMapType ConstGEPCandMap;
 
   /// These are the final constants we decided to hoist.
   using ConstInfoVecType = SmallVector<consthoist::ConstantInfo, 8>;
-  using GVInfoVecMapType = DenseMap<GlobalVariable *, ConstInfoVecType>;
+  using GVInfoVecMapType = MapVector<GlobalVariable *, ConstInfoVecType>;
   ConstInfoVecType ConstIntInfoVec;
   GVInfoVecMapType ConstGEPInfoMap;
 
   /// Keep track of cast instructions we already cloned.
-  SmallDenseMap<Instruction *, Instruction *> ClonedCastMap;
+  MapVector<Instruction *, Instruction *> ClonedCastMap;
 
   Instruction *findMatInsertPt(Instruction *Inst, unsigned Idx = ~0U) const;
-  SmallPtrSet<Instruction *, 8>
+  SetVector<Instruction *>
   findConstantInsertionPoint(const consthoist::ConstantInfo &ConstInfo) const;
   void collectConstantCandidates(ConstCandMapType &ConstCandMap,
                                  Instruction *Inst, unsigned Idx,
@@ -196,7 +198,6 @@
   // constant GEP base.
   bool emitBaseConstants(GlobalVariable *BaseGV);
   void deleteDeadCastInst() const;
-  bool optimizeConstants(Function &Fn);
 };
 
 } // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/Transforms/Scalar/ConstraintElimination.h b/linux-x64/clang/include/llvm/Transforms/Scalar/ConstraintElimination.h
new file mode 100644
index 0000000..544a6c2
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Transforms/Scalar/ConstraintElimination.h
@@ -0,0 +1,24 @@
+//===- ConstraintElimination.h - Constraint elimination pass ----*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_SCALAR_CONSTRAINTELIMINATION_H
+#define LLVM_TRANSFORMS_SCALAR_CONSTRAINTELIMINATION_H
+
+#include "llvm/IR/PassManager.h"
+
+namespace llvm {
+
+class ConstraintEliminationPass
+    : public PassInfoMixin<ConstraintEliminationPass> {
+public:
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager &);
+};
+
+} // end namespace llvm
+
+#endif // LLVM_TRANSFORMS_SCALAR_CONSTRAINTELIMINATION_H
diff --git a/linux-x64/clang/include/llvm/Transforms/Scalar/DCE.h b/linux-x64/clang/include/llvm/Transforms/Scalar/DCE.h
index 974e4b2..4d83296 100644
--- a/linux-x64/clang/include/llvm/Transforms/Scalar/DCE.h
+++ b/linux-x64/clang/include/llvm/Transforms/Scalar/DCE.h
@@ -23,6 +23,12 @@
 public:
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
 };
+
+class RedundantDbgInstEliminationPass
+    : public PassInfoMixin<RedundantDbgInstEliminationPass> {
+public:
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+};
 }
 
 #endif // LLVM_TRANSFORMS_SCALAR_DCE_H
diff --git a/linux-x64/clang/include/llvm/Transforms/Scalar/Float2Int.h b/linux-x64/clang/include/llvm/Transforms/Scalar/Float2Int.h
index 06aeb83..5fb47af 100644
--- a/linux-x64/clang/include/llvm/Transforms/Scalar/Float2Int.h
+++ b/linux-x64/clang/include/llvm/Transforms/Scalar/Float2Int.h
@@ -16,7 +16,9 @@
 
 #include "llvm/ADT/EquivalenceClasses.h"
 #include "llvm/ADT/MapVector.h"
+#include "llvm/ADT/SetVector.h"
 #include "llvm/IR/ConstantRange.h"
+#include "llvm/IR/Dominators.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/PassManager.h"
 
@@ -26,22 +28,22 @@
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
 
   // Glue for old PM.
-  bool runImpl(Function &F);
+  bool runImpl(Function &F, const DominatorTree &DT);
 
 private:
-  void findRoots(Function &F, SmallPtrSet<Instruction *, 8> &Roots);
+  void findRoots(Function &F, const DominatorTree &DT);
   void seen(Instruction *I, ConstantRange R);
   ConstantRange badRange();
   ConstantRange unknownRange();
   ConstantRange validateRange(ConstantRange R);
-  void walkBackwards(const SmallPtrSetImpl<Instruction *> &Roots);
+  void walkBackwards();
   void walkForwards();
   bool validateAndTransform();
   Value *convert(Instruction *I, Type *ToTy);
   void cleanup();
 
   MapVector<Instruction *, ConstantRange> SeenInsts;
-  SmallPtrSet<Instruction *, 8> Roots;
+  SmallSetVector<Instruction *, 8> Roots;
   EquivalenceClasses<Instruction *> ECs;
   MapVector<Instruction *, Value *> ConvertedInsts;
   LLVMContext *Ctx;
diff --git a/linux-x64/clang/include/llvm/Transforms/Scalar/GVN.h b/linux-x64/clang/include/llvm/Transforms/Scalar/GVN.h
index 9fe00a9..d6b3c8c 100644
--- a/linux-x64/clang/include/llvm/Transforms/Scalar/GVN.h
+++ b/linux-x64/clang/include/llvm/Transforms/Scalar/GVN.h
@@ -20,7 +20,6 @@
 #include "llvm/ADT/PostOrderIterator.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallVector.h"
-#include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/Analysis/InstructionPrecedenceTracking.h"
 #include "llvm/Analysis/MemoryDependenceAnalysis.h"
 #include "llvm/IR/Dominators.h"
@@ -35,6 +34,7 @@
 
 namespace llvm {
 
+class AAResults;
 class AssumptionCache;
 class BasicBlock;
 class BranchInst;
@@ -46,11 +46,12 @@
 class IntrinsicInst;
 class LoadInst;
 class LoopInfo;
+class MemorySSA;
+class MemorySSAUpdater;
 class OptimizationRemarkEmitter;
 class PHINode;
 class TargetLibraryInfo;
 class Value;
-
 /// A private "module" namespace for types and utilities used by GVN. These
 /// are implementation details and should not be used by clients.
 namespace gvn LLVM_LIBRARY_VISIBILITY {
@@ -61,14 +62,64 @@
 
 } // end namespace gvn
 
+/// A set of parameters to control various transforms performed by GVN pass.
+//  Each of the optional boolean parameters can be set to:
+///      true - enabling the transformation.
+///      false - disabling the transformation.
+///      None - relying on a global default.
+/// Intended use is to create a default object, modify parameters with
+/// additional setters and then pass it to GVN.
+struct GVNOptions {
+  Optional<bool> AllowPRE = None;
+  Optional<bool> AllowLoadPRE = None;
+  Optional<bool> AllowLoadInLoopPRE = None;
+  Optional<bool> AllowLoadPRESplitBackedge = None;
+  Optional<bool> AllowMemDep = None;
+
+  GVNOptions() = default;
+
+  /// Enables or disables PRE in GVN.
+  GVNOptions &setPRE(bool PRE) {
+    AllowPRE = PRE;
+    return *this;
+  }
+
+  /// Enables or disables PRE of loads in GVN.
+  GVNOptions &setLoadPRE(bool LoadPRE) {
+    AllowLoadPRE = LoadPRE;
+    return *this;
+  }
+
+  GVNOptions &setLoadInLoopPRE(bool LoadInLoopPRE) {
+    AllowLoadInLoopPRE = LoadInLoopPRE;
+    return *this;
+  }
+
+  /// Enables or disables PRE of loads in GVN.
+  GVNOptions &setLoadPRESplitBackedge(bool LoadPRESplitBackedge) {
+    AllowLoadPRESplitBackedge = LoadPRESplitBackedge;
+    return *this;
+  }
+
+  /// Enables or disables use of MemDepAnalysis.
+  GVNOptions &setMemDep(bool MemDep) {
+    AllowMemDep = MemDep;
+    return *this;
+  }
+};
+
 /// The core GVN pass object.
 ///
 /// FIXME: We should have a good summary of the GVN algorithm implemented by
 /// this particular pass here.
 class GVN : public PassInfoMixin<GVN> {
+  GVNOptions Options;
+
 public:
   struct Expression;
 
+  GVN(GVNOptions Options = {}) : Options(Options) {}
+
   /// Run the pass over the function.
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
 
@@ -80,9 +131,15 @@
   }
 
   DominatorTree &getDominatorTree() const { return *DT; }
-  AliasAnalysis *getAliasAnalysis() const { return VN.getAliasAnalysis(); }
+  AAResults *getAliasAnalysis() const { return VN.getAliasAnalysis(); }
   MemoryDependenceResults &getMemDep() const { return *MD; }
 
+  bool isPREEnabled() const;
+  bool isLoadPREEnabled() const;
+  bool isLoadInLoopPREEnabled() const;
+  bool isLoadPRESplitBackedgeEnabled() const;
+  bool isMemDepEnabled() const;
+
   /// This class holds the mapping between values and value numbers.  It is used
   /// as an efficient mechanism to determine the expression-wise equivalence of
   /// two values.
@@ -94,7 +151,7 @@
     // value number to the index of Expression in Expressions. We use it
     // instead of a DenseMap because filling such mapping is faster than
     // filling a DenseMap and the compile time is a little better.
-    uint32_t nextExprNumber;
+    uint32_t nextExprNumber = 0;
 
     std::vector<Expression> Expressions;
     std::vector<uint32_t> ExprIdx;
@@ -107,9 +164,9 @@
         DenseMap<std::pair<uint32_t, const BasicBlock *>, uint32_t>;
     PhiTranslateMap PhiTranslateTable;
 
-    AliasAnalysis *AA;
-    MemoryDependenceResults *MD;
-    DominatorTree *DT;
+    AAResults *AA = nullptr;
+    MemoryDependenceResults *MD = nullptr;
+    DominatorTree *DT = nullptr;
 
     uint32_t nextValueNumber = 1;
 
@@ -120,6 +177,8 @@
     uint32_t lookupOrAddCall(CallInst *C);
     uint32_t phiTranslateImpl(const BasicBlock *BB, const BasicBlock *PhiBlock,
                               uint32_t Num, GVN &Gvn);
+    bool areCallValsEqual(uint32_t Num, uint32_t NewNum, const BasicBlock *Pred,
+                          const BasicBlock *PhiBlock, GVN &Gvn);
     std::pair<uint32_t, bool> assignExpNewValueNum(Expression &exp);
     bool areAllValsInBB(uint32_t num, const BasicBlock *BB, GVN &Gvn);
 
@@ -128,6 +187,7 @@
     ValueTable(const ValueTable &Arg);
     ValueTable(ValueTable &&Arg);
     ~ValueTable();
+    ValueTable &operator=(const ValueTable &Arg);
 
     uint32_t lookupOrAdd(Value *V);
     uint32_t lookup(Value *V, bool Verify = true) const;
@@ -140,8 +200,8 @@
     void add(Value *V, uint32_t num);
     void clear();
     void erase(Value *v);
-    void setAliasAnalysis(AliasAnalysis *A) { AA = A; }
-    AliasAnalysis *getAliasAnalysis() const { return AA; }
+    void setAliasAnalysis(AAResults *A) { AA = A; }
+    AAResults *getAliasAnalysis() const { return AA; }
     void setMemDep(MemoryDependenceResults *M) { MD = M; }
     void setDomTree(DominatorTree *D) { DT = D; }
     uint32_t getNextUnusedValueNumber() { return nextValueNumber; }
@@ -152,13 +212,15 @@
   friend class gvn::GVNLegacyPass;
   friend struct DenseMapInfo<Expression>;
 
-  MemoryDependenceResults *MD;
-  DominatorTree *DT;
-  const TargetLibraryInfo *TLI;
-  AssumptionCache *AC;
+  MemoryDependenceResults *MD = nullptr;
+  DominatorTree *DT = nullptr;
+  const TargetLibraryInfo *TLI = nullptr;
+  AssumptionCache *AC = nullptr;
   SetVector<BasicBlock *> DeadBlocks;
-  OptimizationRemarkEmitter *ORE;
-  ImplicitControlFlowTracking *ICF;
+  OptimizationRemarkEmitter *ORE = nullptr;
+  ImplicitControlFlowTracking *ICF = nullptr;
+  LoopInfo *LI = nullptr;
+  MemorySSAUpdater *MSSAU = nullptr;
 
   ValueTable VN;
 
@@ -175,7 +237,7 @@
   // Block-local map of equivalent values to their leader, does not
   // propagate to any successors. Entries added mid-block are applied
   // to the remaining instructions in the block.
-  SmallMapVector<Value *, Constant *, 4> ReplaceWithConstMap;
+  SmallMapVector<Value *, Value *, 4> ReplaceOperandsWithMap;
   SmallVector<Instruction *, 8> InstrsToErase;
 
   // Map the block to reversed postorder traversal number. It is used to
@@ -194,7 +256,7 @@
   bool runImpl(Function &F, AssumptionCache &RunAC, DominatorTree &RunDT,
                const TargetLibraryInfo &RunTLI, AAResults &RunAA,
                MemoryDependenceResults *RunMD, LoopInfo *LI,
-               OptimizationRemarkEmitter *ORE);
+               OptimizationRemarkEmitter *ORE, MemorySSA *MSSA = nullptr);
 
   /// Push a new Value to the LeaderTable onto the list for its value number.
   void addToLeaderTable(uint32_t N, Value *V, const BasicBlock *BB) {
@@ -276,11 +338,10 @@
                                  BasicBlock *Curr, unsigned int ValNo);
   Value *findLeader(const BasicBlock *BB, uint32_t num);
   void cleanupGlobalSets();
-  void fillImplicitControlFlowInfo(BasicBlock *BB);
   void verifyRemoved(const Instruction *I) const;
   bool splitCriticalEdges();
   BasicBlock *splitCriticalEdges(BasicBlock *Pred, BasicBlock *Succ);
-  bool replaceOperandsWithConsts(Instruction *I) const;
+  bool replaceOperandsForInBlockEquality(Instruction *I) const;
   bool propagateEquality(Value *LHS, Value *RHS, const BasicBlockEdge &Root,
                          bool DominatesByEdge);
   bool processFoldableCondBr(BranchInst *BI);
@@ -290,8 +351,8 @@
 };
 
 /// Create a legacy GVN pass. This also allows parameterizing whether or not
-/// loads are eliminated by the pass.
-FunctionPass *createGVNPass(bool NoLoads = false);
+/// MemDep is enabled.
+FunctionPass *createGVNPass(bool NoMemDepAnalysis = false);
 
 /// A simple and fast domtree-based GVN pass to hoist common expressions
 /// from sibling branches.
diff --git a/linux-x64/clang/include/llvm/Transforms/Scalar/GVNExpression.h b/linux-x64/clang/include/llvm/Transforms/Scalar/GVNExpression.h
index 3dc4515..c4a0487 100644
--- a/linux-x64/clang/include/llvm/Transforms/Scalar/GVNExpression.h
+++ b/linux-x64/clang/include/llvm/Transforms/Scalar/GVNExpression.h
@@ -323,7 +323,6 @@
 class LoadExpression final : public MemoryExpression {
 private:
   LoadInst *Load;
-  unsigned Alignment;
 
 public:
   LoadExpression(unsigned NumOperands, LoadInst *L,
@@ -332,9 +331,7 @@
 
   LoadExpression(enum ExpressionType EType, unsigned NumOperands, LoadInst *L,
                  const MemoryAccess *MemoryLeader)
-      : MemoryExpression(NumOperands, EType, MemoryLeader), Load(L) {
-    Alignment = L ? L->getAlignment() : 0;
-  }
+      : MemoryExpression(NumOperands, EType, MemoryLeader), Load(L) {}
 
   LoadExpression() = delete;
   LoadExpression(const LoadExpression &) = delete;
@@ -348,9 +345,6 @@
   LoadInst *getLoadInst() const { return Load; }
   void setLoadInst(LoadInst *L) { Load = L; }
 
-  unsigned getAlignment() const { return Alignment; }
-  void setAlignment(unsigned Align) { Alignment = Align; }
-
   bool equals(const Expression &Other) const override;
   bool exactlyEquals(const Expression &Other) const override {
     return Expression::exactlyEquals(Other) &&
diff --git a/linux-x64/clang/include/llvm/Transforms/Scalar/IndVarSimplify.h b/linux-x64/clang/include/llvm/Transforms/Scalar/IndVarSimplify.h
index 3c20537..b5d544f 100644
--- a/linux-x64/clang/include/llvm/Transforms/Scalar/IndVarSimplify.h
+++ b/linux-x64/clang/include/llvm/Transforms/Scalar/IndVarSimplify.h
@@ -23,7 +23,11 @@
 class LPMUpdater;
 
 class IndVarSimplifyPass : public PassInfoMixin<IndVarSimplifyPass> {
+  /// Perform IV widening during the pass.
+  bool WidenIndVars;
+
 public:
+  IndVarSimplifyPass(bool WidenIndVars = true) : WidenIndVars(WidenIndVars) {}
   PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
                         LoopStandardAnalysisResults &AR, LPMUpdater &U);
 };
diff --git a/linux-x64/clang/include/llvm/Transforms/Scalar/InductiveRangeCheckElimination.h b/linux-x64/clang/include/llvm/Transforms/Scalar/InductiveRangeCheckElimination.h
index b1e7007..11fb80e 100644
--- a/linux-x64/clang/include/llvm/Transforms/Scalar/InductiveRangeCheckElimination.h
+++ b/linux-x64/clang/include/llvm/Transforms/Scalar/InductiveRangeCheckElimination.h
@@ -15,14 +15,12 @@
 #define LLVM_TRANSFORMS_SCALAR_INDUCTIVERANGECHECKELIMINATION_H
 
 #include "llvm/IR/PassManager.h"
-#include "llvm/Transforms/Scalar/LoopPassManager.h"
 
 namespace llvm {
 
 class IRCEPass : public PassInfoMixin<IRCEPass> {
 public:
-  PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
-                        LoopStandardAnalysisResults &AR, LPMUpdater &U);
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
 };
 
 } // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/Transforms/Scalar/InferAddressSpaces.h b/linux-x64/clang/include/llvm/Transforms/Scalar/InferAddressSpaces.h
new file mode 100644
index 0000000..9a56b07
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Transforms/Scalar/InferAddressSpaces.h
@@ -0,0 +1,27 @@
+//===- InferAddressSpace.h - ----------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_SCALAR_INFERADDRESSSPACES_H
+#define LLVM_TRANSFORMS_SCALAR_INFERADDRESSSPACES_H
+
+#include "llvm/IR/PassManager.h"
+
+namespace llvm {
+
+struct InferAddressSpacesPass : PassInfoMixin<InferAddressSpacesPass> {
+  InferAddressSpacesPass();
+  InferAddressSpacesPass(unsigned AddressSpace);
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+
+private:
+  unsigned FlatAddrSpace = 0;
+};
+
+} // end namespace llvm
+
+#endif // LLVM_TRANSFORMS_SCALAR_INFERADDRESSSPACES_H
diff --git a/linux-x64/clang/include/llvm/Transforms/Scalar/InstSimplifyPass.h b/linux-x64/clang/include/llvm/Transforms/Scalar/InstSimplifyPass.h
index 0c30b62..f36695a 100644
--- a/linux-x64/clang/include/llvm/Transforms/Scalar/InstSimplifyPass.h
+++ b/linux-x64/clang/include/llvm/Transforms/Scalar/InstSimplifyPass.h
@@ -36,10 +36,6 @@
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
 };
 
-/// Create a legacy pass that does instruction simplification on each
-/// instruction in a function.
-FunctionPass *createInstSimplifyLegacyPass();
-
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_UTILS_INSTSIMPLIFYPASS_H
diff --git a/linux-x64/clang/include/llvm/Transforms/Scalar/JumpThreading.h b/linux-x64/clang/include/llvm/Transforms/Scalar/JumpThreading.h
index 0464d40..951f4e4 100644
--- a/linux-x64/clang/include/llvm/Transforms/Scalar/JumpThreading.h
+++ b/linux-x64/clang/include/llvm/Transforms/Scalar/JumpThreading.h
@@ -19,7 +19,6 @@
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/SmallVector.h"
-#include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/Analysis/BlockFrequencyInfo.h"
 #include "llvm/Analysis/BranchProbabilityInfo.h"
 #include "llvm/Analysis/DomTreeUpdater.h"
@@ -29,6 +28,7 @@
 
 namespace llvm {
 
+class AAResults;
 class BasicBlock;
 class BinaryOperator;
 class BranchInst;
@@ -41,6 +41,8 @@
 class LazyValueInfo;
 class LoadInst;
 class PHINode;
+class SelectInst;
+class SwitchInst;
 class TargetLibraryInfo;
 class Value;
 
@@ -77,7 +79,7 @@
 class JumpThreadingPass : public PassInfoMixin<JumpThreadingPass> {
   TargetLibraryInfo *TLI;
   LazyValueInfo *LVI;
-  AliasAnalysis *AA;
+  AAResults *AA;
   DomTreeUpdater *DTU;
   std::unique_ptr<BlockFrequencyInfo> BFI;
   std::unique_ptr<BranchProbabilityInfo> BPI;
@@ -90,15 +92,17 @@
 #endif
 
   unsigned BBDupThreshold;
+  unsigned DefaultBBDupThreshold;
+  bool InsertFreezeWhenUnfoldingSelect;
 
 public:
-  JumpThreadingPass(int T = -1);
+  JumpThreadingPass(bool InsertFreezeWhenUnfoldingSelect = false, int T = -1);
 
   // Glue for old PM.
-  bool runImpl(Function &F, TargetLibraryInfo *TLI_, LazyValueInfo *LVI_,
-               AliasAnalysis *AA_, DomTreeUpdater *DTU_, bool HasProfileData_,
-               std::unique_ptr<BlockFrequencyInfo> BFI_,
-               std::unique_ptr<BranchProbabilityInfo> BPI_);
+  bool runImpl(Function &F, TargetLibraryInfo *TLI, LazyValueInfo *LVI,
+               AAResults *AA, DomTreeUpdater *DTU, bool HasProfileData,
+               std::unique_ptr<BlockFrequencyInfo> BFI,
+               std::unique_ptr<BranchProbabilityInfo> BPI);
 
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
 
@@ -107,51 +111,65 @@
     BPI.reset();
   }
 
-  void FindLoopHeaders(Function &F);
-  bool ProcessBlock(BasicBlock *BB);
-  bool ThreadEdge(BasicBlock *BB, const SmallVectorImpl<BasicBlock *> &PredBBs,
+  void findLoopHeaders(Function &F);
+  bool processBlock(BasicBlock *BB);
+  bool maybeMergeBasicBlockIntoOnlyPred(BasicBlock *BB);
+  void updateSSA(BasicBlock *BB, BasicBlock *NewBB,
+                 DenseMap<Instruction *, Value *> &ValueMapping);
+  DenseMap<Instruction *, Value *> cloneInstructions(BasicBlock::iterator BI,
+                                                     BasicBlock::iterator BE,
+                                                     BasicBlock *NewBB,
+                                                     BasicBlock *PredBB);
+  bool tryThreadEdge(BasicBlock *BB,
+                     const SmallVectorImpl<BasicBlock *> &PredBBs,
+                     BasicBlock *SuccBB);
+  void threadEdge(BasicBlock *BB, const SmallVectorImpl<BasicBlock *> &PredBBs,
                   BasicBlock *SuccBB);
-  bool DuplicateCondBranchOnPHIIntoPred(
+  bool duplicateCondBranchOnPHIIntoPred(
       BasicBlock *BB, const SmallVectorImpl<BasicBlock *> &PredBBs);
 
-  bool ComputeValueKnownInPredecessorsImpl(
+  bool computeValueKnownInPredecessorsImpl(
       Value *V, BasicBlock *BB, jumpthreading::PredValueInfo &Result,
       jumpthreading::ConstantPreference Preference,
-      DenseSet<std::pair<Value *, BasicBlock *>> &RecursionSet,
-      Instruction *CxtI = nullptr);
+      DenseSet<Value *> &RecursionSet, Instruction *CxtI = nullptr);
   bool
-  ComputeValueKnownInPredecessors(Value *V, BasicBlock *BB,
+  computeValueKnownInPredecessors(Value *V, BasicBlock *BB,
                                   jumpthreading::PredValueInfo &Result,
                                   jumpthreading::ConstantPreference Preference,
                                   Instruction *CxtI = nullptr) {
-    DenseSet<std::pair<Value *, BasicBlock *>> RecursionSet;
-    return ComputeValueKnownInPredecessorsImpl(V, BB, Result, Preference,
+    DenseSet<Value *> RecursionSet;
+    return computeValueKnownInPredecessorsImpl(V, BB, Result, Preference,
                                                RecursionSet, CxtI);
   }
 
-  bool ProcessThreadableEdges(Value *Cond, BasicBlock *BB,
+  Constant *evaluateOnPredecessorEdge(BasicBlock *BB, BasicBlock *PredPredBB,
+                                      Value *cond);
+  bool maybethreadThroughTwoBasicBlocks(BasicBlock *BB, Value *Cond);
+  void threadThroughTwoBasicBlocks(BasicBlock *PredPredBB, BasicBlock *PredBB,
+                                   BasicBlock *BB, BasicBlock *SuccBB);
+  bool processThreadableEdges(Value *Cond, BasicBlock *BB,
                               jumpthreading::ConstantPreference Preference,
                               Instruction *CxtI = nullptr);
 
-  bool ProcessBranchOnPHI(PHINode *PN);
-  bool ProcessBranchOnXOR(BinaryOperator *BO);
-  bool ProcessImpliedCondition(BasicBlock *BB);
+  bool processBranchOnPHI(PHINode *PN);
+  bool processBranchOnXOR(BinaryOperator *BO);
+  bool processImpliedCondition(BasicBlock *BB);
 
-  bool SimplifyPartiallyRedundantLoad(LoadInst *LI);
-  void UnfoldSelectInstr(BasicBlock *Pred, BasicBlock *BB, SelectInst *SI,
+  bool simplifyPartiallyRedundantLoad(LoadInst *LI);
+  void unfoldSelectInstr(BasicBlock *Pred, BasicBlock *BB, SelectInst *SI,
                          PHINode *SIUse, unsigned Idx);
 
-  bool TryToUnfoldSelect(CmpInst *CondCmp, BasicBlock *BB);
-  bool TryToUnfoldSelect(SwitchInst *SI, BasicBlock *BB);
-  bool TryToUnfoldSelectInCurrBB(BasicBlock *BB);
+  bool tryToUnfoldSelect(CmpInst *CondCmp, BasicBlock *BB);
+  bool tryToUnfoldSelect(SwitchInst *SI, BasicBlock *BB);
+  bool tryToUnfoldSelectInCurrBB(BasicBlock *BB);
 
-  bool ProcessGuards(BasicBlock *BB);
-  bool ThreadGuard(BasicBlock *BB, IntrinsicInst *Guard, BranchInst *BI);
+  bool processGuards(BasicBlock *BB);
+  bool threadGuard(BasicBlock *BB, IntrinsicInst *Guard, BranchInst *BI);
 
 private:
-  BasicBlock *SplitBlockPreds(BasicBlock *BB, ArrayRef<BasicBlock *> Preds,
+  BasicBlock *splitBlockPreds(BasicBlock *BB, ArrayRef<BasicBlock *> Preds,
                               const char *Suffix);
-  void UpdateBlockFreqAndEdgeWeight(BasicBlock *PredBB, BasicBlock *BB,
+  void updateBlockFreqAndEdgeWeight(BasicBlock *PredBB, BasicBlock *BB,
                                     BasicBlock *NewBB, BasicBlock *SuccBB);
   /// Check if the block has profile metadata for its outgoing edges.
   bool doesBlockHaveProfileData(BasicBlock *BB);
diff --git a/linux-x64/clang/include/llvm/Transforms/Scalar/LICM.h b/linux-x64/clang/include/llvm/Transforms/Scalar/LICM.h
index f0ea928..a8f1c53 100644
--- a/linux-x64/clang/include/llvm/Transforms/Scalar/LICM.h
+++ b/linux-x64/clang/include/llvm/Transforms/Scalar/LICM.h
@@ -34,6 +34,7 @@
 
 #include "llvm/Analysis/LoopInfo.h"
 #include "llvm/IR/PassManager.h"
+#include "llvm/Support/CommandLine.h"
 #include "llvm/Transforms/Scalar/LoopPassManager.h"
 
 namespace llvm {
diff --git a/linux-x64/clang/include/llvm/Transforms/Scalar/LoopFlatten.h b/linux-x64/clang/include/llvm/Transforms/Scalar/LoopFlatten.h
new file mode 100644
index 0000000..41f91f0
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Transforms/Scalar/LoopFlatten.h
@@ -0,0 +1,32 @@
+//===- LoopFlatten.h - Loop Flatten ----------------  -----------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file provides the interface for the Loop Flatten Pass.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_SCALAR_LOOPFLATTEN_H
+#define LLVM_TRANSFORMS_SCALAR_LOOPFLATTEN_H
+
+#include "llvm/Analysis/LoopAnalysisManager.h"
+#include "llvm/Analysis/LoopInfo.h"
+#include "llvm/IR/PassManager.h"
+#include "llvm/Transforms/Scalar/LoopPassManager.h"
+
+namespace llvm {
+
+class LoopFlattenPass : public PassInfoMixin<LoopFlattenPass> {
+public:
+  LoopFlattenPass() = default;
+
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+};
+
+} // end namespace llvm
+
+#endif // LLVM_TRANSFORMS_SCALAR_LOOPFLATTEN_H
diff --git a/linux-x64/clang/include/llvm/Transforms/Scalar/LoopIdiomRecognize.h b/linux-x64/clang/include/llvm/Transforms/Scalar/LoopIdiomRecognize.h
index d2fff8b..0c6406d 100644
--- a/linux-x64/clang/include/llvm/Transforms/Scalar/LoopIdiomRecognize.h
+++ b/linux-x64/clang/include/llvm/Transforms/Scalar/LoopIdiomRecognize.h
@@ -23,6 +23,19 @@
 class Loop;
 class LPMUpdater;
 
+/// Options to disable Loop Idiom Recognize, which can be shared with other
+/// passes.
+struct DisableLIRP {
+  /// When true, the entire pass is disabled.
+  static bool All;
+
+  /// When true, Memset is disabled.
+  static bool Memset;
+
+  /// When true, Memcpy is disabled.
+  static bool Memcpy;
+};
+
 /// Performs Loop Idiom Recognize Pass.
 class LoopIdiomRecognizePass : public PassInfoMixin<LoopIdiomRecognizePass> {
 public:
diff --git a/linux-x64/clang/include/llvm/Transforms/Scalar/LoopInterchange.h b/linux-x64/clang/include/llvm/Transforms/Scalar/LoopInterchange.h
new file mode 100644
index 0000000..9f50fc5
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Transforms/Scalar/LoopInterchange.h
@@ -0,0 +1,24 @@
+//===- LoopInterchange.h - Loop interchange pass --------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_SCALAR_LOOPINTERCHANGE_H
+#define LLVM_TRANSFORMS_SCALAR_LOOPINTERCHANGE_H
+
+#include "llvm/IR/PassManager.h"
+#include "llvm/Transforms/Scalar/LoopPassManager.h"
+
+namespace llvm {
+
+struct LoopInterchangePass : public PassInfoMixin<LoopInterchangePass> {
+  PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
+                        LoopStandardAnalysisResults &AR, LPMUpdater &U);
+};
+
+} // end namespace llvm
+
+#endif // LLVM_TRANSFORMS_SCALAR_LOOPINTERCHANGE_H
diff --git a/linux-x64/clang/include/llvm/Transforms/Scalar/LoopPassManager.h b/linux-x64/clang/include/llvm/Transforms/Scalar/LoopPassManager.h
index 61ec585..2a342fc 100644
--- a/linux-x64/clang/include/llvm/Transforms/Scalar/LoopPassManager.h
+++ b/linux-x64/clang/include/llvm/Transforms/Scalar/LoopPassManager.h
@@ -36,39 +36,163 @@
 #ifndef LLVM_TRANSFORMS_SCALAR_LOOPPASSMANAGER_H
 #define LLVM_TRANSFORMS_SCALAR_LOOPPASSMANAGER_H
 
-#include "llvm/ADT/PostOrderIterator.h"
 #include "llvm/ADT/PriorityWorklist.h"
-#include "llvm/ADT/STLExtras.h"
-#include "llvm/Analysis/AliasAnalysis.h"
-#include "llvm/Analysis/BasicAliasAnalysis.h"
-#include "llvm/Analysis/GlobalsModRef.h"
 #include "llvm/Analysis/LoopAnalysisManager.h"
 #include "llvm/Analysis/LoopInfo.h"
-#include "llvm/Analysis/ScalarEvolution.h"
-#include "llvm/Analysis/ScalarEvolutionAliasAnalysis.h"
-#include "llvm/Analysis/TargetLibraryInfo.h"
-#include "llvm/Analysis/TargetTransformInfo.h"
+#include "llvm/Analysis/LoopNestAnalysis.h"
 #include "llvm/IR/Dominators.h"
+#include "llvm/IR/PassInstrumentation.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/Transforms/Utils/LCSSA.h"
 #include "llvm/Transforms/Utils/LoopSimplify.h"
+#include "llvm/Transforms/Utils/LoopUtils.h"
+#include <memory>
 
 namespace llvm {
 
 // Forward declarations of an update tracking API used in the pass manager.
 class LPMUpdater;
 
+namespace {
+
+template <typename PassT>
+using HasRunOnLoopT = decltype(std::declval<PassT>().run(
+    std::declval<Loop &>(), std::declval<LoopAnalysisManager &>(),
+    std::declval<LoopStandardAnalysisResults &>(),
+    std::declval<LPMUpdater &>()));
+
+} // namespace
+
 // Explicit specialization and instantiation declarations for the pass manager.
 // See the comments on the definition of the specialization for details on how
 // it differs from the primary template.
 template <>
-PreservedAnalyses
-PassManager<Loop, LoopAnalysisManager, LoopStandardAnalysisResults &,
-            LPMUpdater &>::run(Loop &InitialL, LoopAnalysisManager &AM,
-                               LoopStandardAnalysisResults &AnalysisResults,
-                               LPMUpdater &U);
-extern template class PassManager<Loop, LoopAnalysisManager,
-                                  LoopStandardAnalysisResults &, LPMUpdater &>;
+class PassManager<Loop, LoopAnalysisManager, LoopStandardAnalysisResults &,
+                  LPMUpdater &>
+    : public PassInfoMixin<
+          PassManager<Loop, LoopAnalysisManager, LoopStandardAnalysisResults &,
+                      LPMUpdater &>> {
+public:
+  /// Construct a pass manager.
+  ///
+  /// If \p DebugLogging is true, we'll log our progress to llvm::dbgs().
+  explicit PassManager(bool DebugLogging = false)
+      : DebugLogging(DebugLogging) {}
+
+  // FIXME: These are equivalent to the default move constructor/move
+  // assignment. However, using = default triggers linker errors due to the
+  // explicit instantiations below. Find a way to use the default and remove the
+  // duplicated code here.
+  PassManager(PassManager &&Arg)
+      : IsLoopNestPass(std::move(Arg.IsLoopNestPass)),
+        LoopPasses(std::move(Arg.LoopPasses)),
+        LoopNestPasses(std::move(Arg.LoopNestPasses)),
+        DebugLogging(std::move(Arg.DebugLogging)) {}
+
+  PassManager &operator=(PassManager &&RHS) {
+    IsLoopNestPass = std::move(RHS.IsLoopNestPass);
+    LoopPasses = std::move(RHS.LoopPasses);
+    LoopNestPasses = std::move(RHS.LoopNestPasses);
+    DebugLogging = std::move(RHS.DebugLogging);
+    return *this;
+  }
+
+  PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
+                        LoopStandardAnalysisResults &AR, LPMUpdater &U);
+
+  /// Add either a loop pass or a loop-nest pass to the pass manager. Append \p
+  /// Pass to the list of loop passes if it has a dedicated \fn run() method for
+  /// loops and to the list of loop-nest passes if the \fn run() method is for
+  /// loop-nests instead. Also append whether \p Pass is loop-nest pass or not
+  /// to the end of \var IsLoopNestPass so we can easily identify the types of
+  /// passes in the pass manager later.
+  template <typename PassT>
+  std::enable_if_t<is_detected<HasRunOnLoopT, PassT>::value>
+  addPass(PassT Pass) {
+    using LoopPassModelT =
+        detail::PassModel<Loop, PassT, PreservedAnalyses, LoopAnalysisManager,
+                          LoopStandardAnalysisResults &, LPMUpdater &>;
+    IsLoopNestPass.push_back(false);
+    LoopPasses.emplace_back(new LoopPassModelT(std::move(Pass)));
+  }
+
+  template <typename PassT>
+  std::enable_if_t<!is_detected<HasRunOnLoopT, PassT>::value>
+  addPass(PassT Pass) {
+    using LoopNestPassModelT =
+        detail::PassModel<LoopNest, PassT, PreservedAnalyses,
+                          LoopAnalysisManager, LoopStandardAnalysisResults &,
+                          LPMUpdater &>;
+    IsLoopNestPass.push_back(true);
+    LoopNestPasses.emplace_back(new LoopNestPassModelT(std::move(Pass)));
+  }
+
+  // Specializations of `addPass` for `RepeatedPass`. These are necessary since
+  // `RepeatedPass` has a templated `run` method that will result in incorrect
+  // detection of `HasRunOnLoopT`.
+  template <typename PassT>
+  std::enable_if_t<is_detected<HasRunOnLoopT, PassT>::value>
+  addPass(RepeatedPass<PassT> Pass) {
+    using RepeatedLoopPassModelT =
+        detail::PassModel<Loop, RepeatedPass<PassT>, PreservedAnalyses,
+                          LoopAnalysisManager, LoopStandardAnalysisResults &,
+                          LPMUpdater &>;
+    IsLoopNestPass.push_back(false);
+    LoopPasses.emplace_back(new RepeatedLoopPassModelT(std::move(Pass)));
+  }
+
+  template <typename PassT>
+  std::enable_if_t<!is_detected<HasRunOnLoopT, PassT>::value>
+  addPass(RepeatedPass<PassT> Pass) {
+    using RepeatedLoopNestPassModelT =
+        detail::PassModel<LoopNest, RepeatedPass<PassT>, PreservedAnalyses,
+                          LoopAnalysisManager, LoopStandardAnalysisResults &,
+                          LPMUpdater &>;
+    IsLoopNestPass.push_back(true);
+    LoopNestPasses.emplace_back(
+        new RepeatedLoopNestPassModelT(std::move(Pass)));
+  }
+
+  bool isEmpty() const { return LoopPasses.empty() && LoopNestPasses.empty(); }
+
+  static bool isRequired() { return true; }
+
+  size_t getNumLoopPasses() const { return LoopPasses.size(); }
+  size_t getNumLoopNestPasses() const { return LoopNestPasses.size(); }
+
+protected:
+  using LoopPassConceptT =
+      detail::PassConcept<Loop, LoopAnalysisManager,
+                          LoopStandardAnalysisResults &, LPMUpdater &>;
+  using LoopNestPassConceptT =
+      detail::PassConcept<LoopNest, LoopAnalysisManager,
+                          LoopStandardAnalysisResults &, LPMUpdater &>;
+
+  // BitVector that identifies whether the passes are loop passes or loop-nest
+  // passes (true for loop-nest passes).
+  BitVector IsLoopNestPass;
+  std::vector<std::unique_ptr<LoopPassConceptT>> LoopPasses;
+  std::vector<std::unique_ptr<LoopNestPassConceptT>> LoopNestPasses;
+
+  /// Flag indicating whether we should do debug logging.
+  bool DebugLogging;
+
+  /// Run either a loop pass or a loop-nest pass. Returns `None` if
+  /// PassInstrumentation's BeforePass returns false. Otherwise, returns the
+  /// preserved analyses of the pass.
+  template <typename IRUnitT, typename PassT>
+  Optional<PreservedAnalyses>
+  runSinglePass(IRUnitT &IR, PassT &Pass, LoopAnalysisManager &AM,
+                LoopStandardAnalysisResults &AR, LPMUpdater &U,
+                PassInstrumentation &PI);
+
+  PreservedAnalyses runWithLoopNestPasses(Loop &L, LoopAnalysisManager &AM,
+                                          LoopStandardAnalysisResults &AR,
+                                          LPMUpdater &U);
+  PreservedAnalyses runWithoutLoopNestPasses(Loop &L, LoopAnalysisManager &AM,
+                                             LoopStandardAnalysisResults &AR,
+                                             LPMUpdater &U);
+};
 
 /// The Loop pass manager.
 ///
@@ -101,41 +225,7 @@
     RequireAnalysisPass<AnalysisT, Loop, LoopAnalysisManager,
                         LoopStandardAnalysisResults &, LPMUpdater &>;
 
-namespace internal {
-/// Helper to implement appending of loops onto a worklist.
-///
-/// We want to process loops in postorder, but the worklist is a LIFO data
-/// structure, so we append to it in *reverse* postorder.
-///
-/// For trees, a preorder traversal is a viable reverse postorder, so we
-/// actually append using a preorder walk algorithm.
-template <typename RangeT>
-inline void appendLoopsToWorklist(RangeT &&Loops,
-                                  SmallPriorityWorklist<Loop *, 4> &Worklist) {
-  // We use an internal worklist to build up the preorder traversal without
-  // recursion.
-  SmallVector<Loop *, 4> PreOrderLoops, PreOrderWorklist;
-
-  // We walk the initial sequence of loops in reverse because we generally want
-  // to visit defs before uses and the worklist is LIFO.
-  for (Loop *RootL : reverse(Loops)) {
-    assert(PreOrderLoops.empty() && "Must start with an empty preorder walk.");
-    assert(PreOrderWorklist.empty() &&
-           "Must start with an empty preorder walk worklist.");
-    PreOrderWorklist.push_back(RootL);
-    do {
-      Loop *L = PreOrderWorklist.pop_back_val();
-      PreOrderWorklist.append(L->begin(), L->end());
-      PreOrderLoops.push_back(L);
-    } while (!PreOrderWorklist.empty());
-
-    Worklist.insert(std::move(PreOrderLoops));
-    PreOrderLoops.clear();
-  }
-}
-}
-
-template <typename LoopPassT> class FunctionToLoopPassAdaptor;
+class FunctionToLoopPassAdaptor;
 
 /// This class provides an interface for updating the loop pass manager based
 /// on mutations to the loop nest.
@@ -143,6 +233,13 @@
 /// A reference to an instance of this class is passed as an argument to each
 /// Loop pass, and Loop passes should use it to update LPM infrastructure if
 /// they modify the loop nest structure.
+///
+/// \c LPMUpdater comes with two modes: the loop mode and the loop-nest mode. In
+/// loop mode, all the loops in the function will be pushed into the worklist
+/// and when new loops are added to the pipeline, their subloops are also
+/// inserted recursively. On the other hand, in loop-nest mode, only top-level
+/// loops are contained in the worklist and the addition of new (top-level)
+/// loops will not trigger the addition of their subloops.
 class LPMUpdater {
 public:
   /// This can be queried by loop passes which run other loop passes (like pass
@@ -164,6 +261,8 @@
   /// state, this routine will mark that the current loop should be skipped by
   /// the rest of the pass management infrastructure.
   void markLoopAsDeleted(Loop &L, llvm::StringRef Name) {
+    assert((!LoopNestMode || L.isOutermost()) &&
+           "L should be a top-level loop in loop-nest mode.");
     LAM.clear(L, Name);
     assert((&L == CurrentL || CurrentL->contains(&L)) &&
            "Cannot delete a loop outside of the "
@@ -179,6 +278,8 @@
   /// loops within them will be visited in postorder as usual for the loop pass
   /// manager.
   void addChildLoops(ArrayRef<Loop *> NewChildLoops) {
+    assert(!LoopNestMode &&
+           "Child loops should not be pushed in loop-nest mode.");
     // Insert ourselves back into the worklist first, as this loop should be
     // revisited after all the children have been processed.
     Worklist.insert(CurrentL);
@@ -190,7 +291,7 @@
                                                   "the current loop!");
 #endif
 
-    internal::appendLoopsToWorklist(NewChildLoops, Worklist);
+    appendLoopsToWorklist(NewChildLoops, Worklist);
 
     // Also skip further processing of the current loop--it will be revisited
     // after all of its newly added children are accounted for.
@@ -210,7 +311,10 @@
              "All of the new loops must be siblings of the current loop!");
 #endif
 
-    internal::appendLoopsToWorklist(NewSibLoops, Worklist);
+    if (LoopNestMode)
+      Worklist.insert(NewSibLoops);
+    else
+      appendLoopsToWorklist(NewSibLoops, Worklist);
 
     // No need to skip the current loop or revisit it, as sibling loops
     // shouldn't impact anything.
@@ -230,7 +334,7 @@
   }
 
 private:
-  template <typename LoopPassT> friend class llvm::FunctionToLoopPassAdaptor;
+  friend class llvm::FunctionToLoopPassAdaptor;
 
   /// The \c FunctionToLoopPassAdaptor's worklist of loops to process.
   SmallPriorityWorklist<Loop *, 4> &Worklist;
@@ -240,6 +344,7 @@
 
   Loop *CurrentL;
   bool SkipCurrentLoop;
+  const bool LoopNestMode;
 
 #ifndef NDEBUG
   // In debug builds we also track the parent loop to implement asserts even in
@@ -248,10 +353,33 @@
 #endif
 
   LPMUpdater(SmallPriorityWorklist<Loop *, 4> &Worklist,
-             LoopAnalysisManager &LAM)
-      : Worklist(Worklist), LAM(LAM) {}
+             LoopAnalysisManager &LAM, bool LoopNestMode = false)
+      : Worklist(Worklist), LAM(LAM), LoopNestMode(LoopNestMode) {}
 };
 
+template <typename IRUnitT, typename PassT>
+Optional<PreservedAnalyses> LoopPassManager::runSinglePass(
+    IRUnitT &IR, PassT &Pass, LoopAnalysisManager &AM,
+    LoopStandardAnalysisResults &AR, LPMUpdater &U, PassInstrumentation &PI) {
+  // Check the PassInstrumentation's BeforePass callbacks before running the
+  // pass, skip its execution completely if asked to (callback returns false).
+  if (!PI.runBeforePass<IRUnitT>(*Pass, IR))
+    return None;
+
+  PreservedAnalyses PA;
+  {
+    TimeTraceScope TimeScope(Pass->name(), IR.getName());
+    PA = Pass->run(IR, AM, AR, U);
+  }
+
+  // do not pass deleted Loop into the instrumentation
+  if (U.skipCurrentLoop())
+    PI.runAfterPassInvalidated<IRUnitT>(*Pass, PA);
+  else
+    PI.runAfterPass<IRUnitT>(*Pass, IR, PA);
+  return PA;
+}
+
 /// Adaptor that maps from a function to its loops.
 ///
 /// Designed to allow composition of a LoopPass(Manager) and a
@@ -259,152 +387,107 @@
 /// FunctionAnalysisManager it will run the \c LoopAnalysisManagerFunctionProxy
 /// analysis prior to running the loop passes over the function to enable a \c
 /// LoopAnalysisManager to be used within this run safely.
-template <typename LoopPassT>
+///
+/// The adaptor comes with two modes: the loop mode and the loop-nest mode, and
+/// the worklist updater lived inside will be in the same mode as the adaptor
+/// (refer to the documentation of \c LPMUpdater for more detailed explanation).
+/// Specifically, in loop mode, all loops in the funciton will be pushed into
+/// the worklist and processed by \p Pass, while only top-level loops are
+/// processed in loop-nest mode. Please refer to the various specializations of
+/// \fn createLoopFunctionToLoopPassAdaptor to see when loop mode and loop-nest
+/// mode are used.
 class FunctionToLoopPassAdaptor
-    : public PassInfoMixin<FunctionToLoopPassAdaptor<LoopPassT>> {
+    : public PassInfoMixin<FunctionToLoopPassAdaptor> {
 public:
-  explicit FunctionToLoopPassAdaptor(LoopPassT Pass, bool DebugLogging = false)
-      : Pass(std::move(Pass)), LoopCanonicalizationFPM(DebugLogging) {
+  using PassConceptT =
+      detail::PassConcept<Loop, LoopAnalysisManager,
+                          LoopStandardAnalysisResults &, LPMUpdater &>;
+
+  explicit FunctionToLoopPassAdaptor(std::unique_ptr<PassConceptT> Pass,
+                                     bool UseMemorySSA = false,
+                                     bool UseBlockFrequencyInfo = false,
+                                     bool DebugLogging = false,
+                                     bool LoopNestMode = false)
+      : Pass(std::move(Pass)), LoopCanonicalizationFPM(DebugLogging),
+        UseMemorySSA(UseMemorySSA),
+        UseBlockFrequencyInfo(UseBlockFrequencyInfo),
+        LoopNestMode(LoopNestMode) {
     LoopCanonicalizationFPM.addPass(LoopSimplifyPass());
     LoopCanonicalizationFPM.addPass(LCSSAPass());
   }
 
   /// Runs the loop passes across every loop in the function.
-  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM) {
-    // Before we even compute any loop analyses, first run a miniature function
-    // pass pipeline to put loops into their canonical form. Note that we can
-    // directly build up function analyses after this as the function pass
-    // manager handles all the invalidation at that layer.
-    PassInstrumentation PI = AM.getResult<PassInstrumentationAnalysis>(F);
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
 
-    PreservedAnalyses PA = PreservedAnalyses::all();
-    // Check the PassInstrumentation's BeforePass callbacks before running the
-    // canonicalization pipeline.
-    if (PI.runBeforePass<Function>(LoopCanonicalizationFPM, F)) {
-      PA = LoopCanonicalizationFPM.run(F, AM);
-      PI.runAfterPass<Function>(LoopCanonicalizationFPM, F);
-    }
+  static bool isRequired() { return true; }
 
-    // Get the loop structure for this function
-    LoopInfo &LI = AM.getResult<LoopAnalysis>(F);
-
-    // If there are no loops, there is nothing to do here.
-    if (LI.empty())
-      return PA;
-
-    // Get the analysis results needed by loop passes.
-    MemorySSA *MSSA = EnableMSSALoopDependency
-                          ? (&AM.getResult<MemorySSAAnalysis>(F).getMSSA())
-                          : nullptr;
-    LoopStandardAnalysisResults LAR = {AM.getResult<AAManager>(F),
-                                       AM.getResult<AssumptionAnalysis>(F),
-                                       AM.getResult<DominatorTreeAnalysis>(F),
-                                       AM.getResult<LoopAnalysis>(F),
-                                       AM.getResult<ScalarEvolutionAnalysis>(F),
-                                       AM.getResult<TargetLibraryAnalysis>(F),
-                                       AM.getResult<TargetIRAnalysis>(F),
-                                       MSSA};
-
-    // Setup the loop analysis manager from its proxy. It is important that
-    // this is only done when there are loops to process and we have built the
-    // LoopStandardAnalysisResults object. The loop analyses cached in this
-    // manager have access to those analysis results and so it must invalidate
-    // itself when they go away.
-    LoopAnalysisManager &LAM =
-        AM.getResult<LoopAnalysisManagerFunctionProxy>(F).getManager();
-
-    // A postorder worklist of loops to process.
-    SmallPriorityWorklist<Loop *, 4> Worklist;
-
-    // Register the worklist and loop analysis manager so that loop passes can
-    // update them when they mutate the loop nest structure.
-    LPMUpdater Updater(Worklist, LAM);
-
-    // Add the loop nests in the reverse order of LoopInfo. For some reason,
-    // they are stored in RPO w.r.t. the control flow graph in LoopInfo. For
-    // the purpose of unrolling, loop deletion, and LICM, we largely want to
-    // work forward across the CFG so that we visit defs before uses and can
-    // propagate simplifications from one loop nest into the next.
-    // FIXME: Consider changing the order in LoopInfo.
-    internal::appendLoopsToWorklist(reverse(LI), Worklist);
-
-    do {
-      Loop *L = Worklist.pop_back_val();
-
-      // Reset the update structure for this loop.
-      Updater.CurrentL = L;
-      Updater.SkipCurrentLoop = false;
-
-#ifndef NDEBUG
-      // Save a parent loop pointer for asserts.
-      Updater.ParentL = L->getParentLoop();
-
-      // Verify the loop structure and LCSSA form before visiting the loop.
-      L->verifyLoop();
-      assert(L->isRecursivelyLCSSAForm(LAR.DT, LI) &&
-             "Loops must remain in LCSSA form!");
-#endif
-      // Check the PassInstrumentation's BeforePass callbacks before running the
-      // pass, skip its execution completely if asked to (callback returns
-      // false).
-      if (!PI.runBeforePass<Loop>(Pass, *L))
-        continue;
-      PreservedAnalyses PassPA = Pass.run(*L, LAM, LAR, Updater);
-
-      // Do not pass deleted Loop into the instrumentation.
-      if (Updater.skipCurrentLoop())
-        PI.runAfterPassInvalidated<Loop>(Pass);
-      else
-        PI.runAfterPass<Loop>(Pass, *L);
-
-      // FIXME: We should verify the set of analyses relevant to Loop passes
-      // are preserved.
-
-      // If the loop hasn't been deleted, we need to handle invalidation here.
-      if (!Updater.skipCurrentLoop())
-        // We know that the loop pass couldn't have invalidated any other
-        // loop's analyses (that's the contract of a loop pass), so directly
-        // handle the loop analysis manager's invalidation here.
-        LAM.invalidate(*L, PassPA);
-
-      // Then intersect the preserved set so that invalidation of module
-      // analyses will eventually occur when the module pass completes.
-      PA.intersect(std::move(PassPA));
-    } while (!Worklist.empty());
-
-    // By definition we preserve the proxy. We also preserve all analyses on
-    // Loops. This precludes *any* invalidation of loop analyses by the proxy,
-    // but that's OK because we've taken care to invalidate analyses in the
-    // loop analysis manager incrementally above.
-    PA.preserveSet<AllAnalysesOn<Loop>>();
-    PA.preserve<LoopAnalysisManagerFunctionProxy>();
-    // We also preserve the set of standard analyses.
-    PA.preserve<DominatorTreeAnalysis>();
-    PA.preserve<LoopAnalysis>();
-    PA.preserve<ScalarEvolutionAnalysis>();
-    if (EnableMSSALoopDependency)
-      PA.preserve<MemorySSAAnalysis>();
-    // FIXME: What we really want to do here is preserve an AA category, but
-    // that concept doesn't exist yet.
-    PA.preserve<AAManager>();
-    PA.preserve<BasicAA>();
-    PA.preserve<GlobalsAA>();
-    PA.preserve<SCEVAA>();
-    return PA;
-  }
+  bool isLoopNestMode() const { return LoopNestMode; }
 
 private:
-  LoopPassT Pass;
+  std::unique_ptr<PassConceptT> Pass;
 
   FunctionPassManager LoopCanonicalizationFPM;
+
+  bool UseMemorySSA = false;
+  bool UseBlockFrequencyInfo = false;
+  const bool LoopNestMode;
 };
 
 /// A function to deduce a loop pass type and wrap it in the templated
 /// adaptor.
+///
+/// If \p Pass is a loop pass, the returned adaptor will be in loop mode.
 template <typename LoopPassT>
-FunctionToLoopPassAdaptor<LoopPassT>
-createFunctionToLoopPassAdaptor(LoopPassT Pass, bool DebugLogging = false) {
-  return FunctionToLoopPassAdaptor<LoopPassT>(std::move(Pass), DebugLogging);
+inline std::enable_if_t<is_detected<HasRunOnLoopT, LoopPassT>::value,
+                        FunctionToLoopPassAdaptor>
+createFunctionToLoopPassAdaptor(LoopPassT Pass, bool UseMemorySSA = false,
+                                bool UseBlockFrequencyInfo = false,
+                                bool DebugLogging = false) {
+  using PassModelT =
+      detail::PassModel<Loop, LoopPassT, PreservedAnalyses, LoopAnalysisManager,
+                        LoopStandardAnalysisResults &, LPMUpdater &>;
+  return FunctionToLoopPassAdaptor(
+      std::make_unique<PassModelT>(std::move(Pass)), UseMemorySSA,
+      UseBlockFrequencyInfo, DebugLogging, false);
+}
+
+/// If \p Pass is a loop-nest pass, \p Pass will first be wrapped into a
+/// \c LoopPassManager and the returned adaptor will be in loop-nest mode.
+template <typename LoopNestPassT>
+inline std::enable_if_t<!is_detected<HasRunOnLoopT, LoopNestPassT>::value,
+                        FunctionToLoopPassAdaptor>
+createFunctionToLoopPassAdaptor(LoopNestPassT Pass, bool UseMemorySSA = false,
+                                bool UseBlockFrequencyInfo = false,
+                                bool DebugLogging = false) {
+  LoopPassManager LPM(DebugLogging);
+  LPM.addPass(std::move(Pass));
+  using PassModelT =
+      detail::PassModel<Loop, LoopPassManager, PreservedAnalyses,
+                        LoopAnalysisManager, LoopStandardAnalysisResults &,
+                        LPMUpdater &>;
+  return FunctionToLoopPassAdaptor(std::make_unique<PassModelT>(std::move(LPM)),
+                                   UseMemorySSA, UseBlockFrequencyInfo,
+                                   DebugLogging, true);
+}
+
+/// If \p Pass is an instance of \c LoopPassManager, the returned adaptor will
+/// be in loop-nest mode if the pass manager contains only loop-nest passes.
+template <>
+inline FunctionToLoopPassAdaptor
+createFunctionToLoopPassAdaptor<LoopPassManager>(LoopPassManager LPM,
+                                                 bool UseMemorySSA,
+                                                 bool UseBlockFrequencyInfo,
+                                                 bool DebugLogging) {
+  // Check if LPM contains any loop pass and if it does not, returns an adaptor
+  // in loop-nest mode.
+  using PassModelT =
+      detail::PassModel<Loop, LoopPassManager, PreservedAnalyses,
+                        LoopAnalysisManager, LoopStandardAnalysisResults &,
+                        LPMUpdater &>;
+  bool LoopNestMode = (LPM.getNumLoopPasses() == 0);
+  return FunctionToLoopPassAdaptor(std::make_unique<PassModelT>(std::move(LPM)),
+                                   UseMemorySSA, UseBlockFrequencyInfo,
+                                   DebugLogging, LoopNestMode);
 }
 
 /// Pass for printing a loop's contents as textual IR.
diff --git a/linux-x64/clang/include/llvm/Transforms/Scalar/LoopReroll.h b/linux-x64/clang/include/llvm/Transforms/Scalar/LoopReroll.h
new file mode 100644
index 0000000..6ae309e
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Transforms/Scalar/LoopReroll.h
@@ -0,0 +1,27 @@
+//===- LoopReroll.h - Loop rerolling pass ---------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_SCALAR_LOOPREROLL_H
+#define LLVM_TRANSFORMS_SCALAR_LOOPREROLL_H
+
+#include "llvm/IR/PassManager.h"
+#include "llvm/Transforms/Scalar/LoopPassManager.h"
+
+namespace llvm {
+
+class Function;
+
+class LoopRerollPass : public PassInfoMixin<LoopRerollPass> {
+public:
+  PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
+                        LoopStandardAnalysisResults &AR, LPMUpdater &U);
+};
+
+} // end namespace llvm
+
+#endif // LLVM_TRANSFORMS_SCALAR_LOOPREROLL_H
diff --git a/linux-x64/clang/include/llvm/Transforms/Scalar/LoopUnrollAndJamPass.h b/linux-x64/clang/include/llvm/Transforms/Scalar/LoopUnrollAndJamPass.h
index 7920269..bd83a6a 100644
--- a/linux-x64/clang/include/llvm/Transforms/Scalar/LoopUnrollAndJamPass.h
+++ b/linux-x64/clang/include/llvm/Transforms/Scalar/LoopUnrollAndJamPass.h
@@ -9,15 +9,10 @@
 #ifndef LLVM_TRANSFORMS_SCALAR_LOOPUNROLLANDJAMPASS_H
 #define LLVM_TRANSFORMS_SCALAR_LOOPUNROLLANDJAMPASS_H
 
-#include "llvm/Analysis/LoopAnalysisManager.h"
-#include "llvm/Analysis/LoopInfo.h"
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
-
-class Loop;
-struct LoopStandardAnalysisResults;
-class LPMUpdater;
+class Function;
 
 /// A simple loop rotation transformation.
 class LoopUnrollAndJamPass : public PassInfoMixin<LoopUnrollAndJamPass> {
@@ -25,8 +20,7 @@
 
 public:
   explicit LoopUnrollAndJamPass(int OptLevel = 2) : OptLevel(OptLevel) {}
-  PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
-                        LoopStandardAnalysisResults &AR, LPMUpdater &U);
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
 };
 
 } // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/Transforms/Scalar/LoopUnrollPass.h b/linux-x64/clang/include/llvm/Transforms/Scalar/LoopUnrollPass.h
index a84d889..7b049bd 100644
--- a/linux-x64/clang/include/llvm/Transforms/Scalar/LoopUnrollPass.h
+++ b/linux-x64/clang/include/llvm/Transforms/Scalar/LoopUnrollPass.h
@@ -12,6 +12,7 @@
 #include "llvm/ADT/Optional.h"
 #include "llvm/Analysis/LoopAnalysisManager.h"
 #include "llvm/IR/PassManager.h"
+#include "llvm/Support/CommandLine.h"
 
 namespace llvm {
 
@@ -62,6 +63,8 @@
   Optional<bool> AllowPeeling;
   Optional<bool> AllowRuntime;
   Optional<bool> AllowUpperBound;
+  Optional<bool> AllowProfileBasedPeeling;
+  Optional<unsigned> FullUnrollMaxCount;
   int OptLevel;
 
   /// If false, use a cost model to determine whether unrolling of a loop is
@@ -110,6 +113,18 @@
     OptLevel = O;
     return *this;
   }
+
+  // Enables or disables loop peeling basing on profile.
+  LoopUnrollOptions &setProfileBasedPeeling(int O) {
+    AllowProfileBasedPeeling = O;
+    return *this;
+  }
+
+  // Sets the max full unroll count.
+  LoopUnrollOptions &setFullUnrollMaxCount(unsigned O) {
+    FullUnrollMaxCount = O;
+    return *this;
+  }
 };
 
 /// Loop unroll pass that will support both full and partial unrolling.
diff --git a/linux-x64/clang/include/llvm/Transforms/Scalar/LoopVersioningLICM.h b/linux-x64/clang/include/llvm/Transforms/Scalar/LoopVersioningLICM.h
new file mode 100644
index 0000000..87d6d67
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Transforms/Scalar/LoopVersioningLICM.h
@@ -0,0 +1,25 @@
+//===- LoopVersioningLICM.h - LICM Loop Versioning ------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_SCALAR_LOOPVERSIONINGLICM_H
+#define LLVM_TRANSFORMS_SCALAR_LOOPVERSIONINGLICM_H
+
+#include "llvm/IR/PassManager.h"
+#include "llvm/Transforms/Scalar/LoopPassManager.h"
+
+namespace llvm {
+
+class LoopVersioningLICMPass : public PassInfoMixin<LoopVersioningLICMPass> {
+public:
+  PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
+                        LoopStandardAnalysisResults &LAR, LPMUpdater &U);
+};
+
+} // namespace llvm
+
+#endif // LLVM_TRANSFORMS_SCALAR_LOOPVERSIONINGLICM_H
diff --git a/linux-x64/clang/include/llvm/Transforms/Scalar/LowerAtomic.h b/linux-x64/clang/include/llvm/Transforms/Scalar/LowerAtomic.h
index 40f8ca5..1d55508 100644
--- a/linux-x64/clang/include/llvm/Transforms/Scalar/LowerAtomic.h
+++ b/linux-x64/clang/include/llvm/Transforms/Scalar/LowerAtomic.h
@@ -22,6 +22,7 @@
 class LowerAtomicPass : public PassInfoMixin<LowerAtomicPass> {
 public:
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &);
+  static bool isRequired() { return true; }
 };
 }
 
diff --git a/linux-x64/clang/include/llvm/Transforms/Scalar/LowerConstantIntrinsics.h b/linux-x64/clang/include/llvm/Transforms/Scalar/LowerConstantIntrinsics.h
new file mode 100644
index 0000000..a5ad4a2
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Transforms/Scalar/LowerConstantIntrinsics.h
@@ -0,0 +1,41 @@
+//===- LowerConstantIntrinsics.h - Lower constant int. pass -*- C++ -*-========//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+/// \file
+///
+/// The header file for the LowerConstantIntrinsics pass as used by the new pass
+/// manager.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_SCALAR_LOWERCONSTANTINTRINSICS_H
+#define LLVM_TRANSFORMS_SCALAR_LOWERCONSTANTINTRINSICS_H
+
+#include "llvm/IR/Function.h"
+#include "llvm/IR/PassManager.h"
+
+namespace llvm {
+
+struct LowerConstantIntrinsicsPass :
+    PassInfoMixin<LowerConstantIntrinsicsPass> {
+public:
+  explicit LowerConstantIntrinsicsPass() {}
+
+  /// Run the pass over the function.
+  ///
+  /// This will lower all remaining 'objectsize' and 'is.constant'`
+  /// intrinsic calls in this function, even when the argument has no known
+  /// size or is not a constant respectively. The resulting constant is
+  /// propagated and conditional branches are resolved where possible.
+  /// This complements the Instruction Simplification and
+  /// Instruction Combination passes of the optimized pass chain.
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager &);
+};
+
+}
+
+#endif
diff --git a/linux-x64/clang/include/llvm/Transforms/Scalar/LowerExpectIntrinsic.h b/linux-x64/clang/include/llvm/Transforms/Scalar/LowerExpectIntrinsic.h
index 4e47ff7..22b2e64 100644
--- a/linux-x64/clang/include/llvm/Transforms/Scalar/LowerExpectIntrinsic.h
+++ b/linux-x64/clang/include/llvm/Transforms/Scalar/LowerExpectIntrinsic.h
@@ -17,6 +17,7 @@
 
 #include "llvm/IR/Function.h"
 #include "llvm/IR/PassManager.h"
+#include "llvm/Support/CommandLine.h"
 
 namespace llvm {
 
@@ -31,6 +32,8 @@
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &);
 };
 
+extern cl::opt<uint32_t> LikelyBranchWeight;
+extern cl::opt<uint32_t> UnlikelyBranchWeight;
 }
 
 #endif
diff --git a/linux-x64/clang/include/llvm/Transforms/Scalar/LowerMatrixIntrinsics.h b/linux-x64/clang/include/llvm/Transforms/Scalar/LowerMatrixIntrinsics.h
new file mode 100644
index 0000000..a2a31d3
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Transforms/Scalar/LowerMatrixIntrinsics.h
@@ -0,0 +1,30 @@
+//===- LowerMatrixIntrinsics.h - Lower matrix intrinsics. -------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This pass lowers matrix intrinsics down to vector operations.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_SCALAR_LOWERMATRIXINTRINSICSPASS_H
+#define LLVM_TRANSFORMS_SCALAR_LOWERMATRIXINTRINSICSPASS_H
+
+#include "llvm/IR/PassManager.h"
+
+namespace llvm {
+class LowerMatrixIntrinsicsPass
+    : public PassInfoMixin<LowerMatrixIntrinsicsPass> {
+  bool Minimal;
+
+public:
+  LowerMatrixIntrinsicsPass(bool Minimal = false) : Minimal(Minimal) {}
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static bool isRequired() { return true; }
+};
+} // namespace llvm
+
+#endif
diff --git a/linux-x64/clang/include/llvm/Transforms/Scalar/MemCpyOptimizer.h b/linux-x64/clang/include/llvm/Transforms/Scalar/MemCpyOptimizer.h
index 5386f58..635b706 100644
--- a/linux-x64/clang/include/llvm/Transforms/Scalar/MemCpyOptimizer.h
+++ b/linux-x64/clang/include/llvm/Transforms/Scalar/MemCpyOptimizer.h
@@ -14,23 +14,26 @@
 #ifndef LLVM_TRANSFORMS_SCALAR_MEMCPYOPTIMIZER_H
 #define LLVM_TRANSFORMS_SCALAR_MEMCPYOPTIMIZER_H
 
-#include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/IR/BasicBlock.h"
-#include "llvm/IR/CallSite.h"
 #include "llvm/IR/PassManager.h"
 #include <cstdint>
 #include <functional>
 
 namespace llvm {
 
+class AAResults;
 class AssumptionCache;
+class CallBase;
 class CallInst;
 class DominatorTree;
 class Function;
 class Instruction;
+class LoadInst;
 class MemCpyInst;
 class MemMoveInst;
 class MemoryDependenceResults;
+class MemorySSA;
+class MemorySSAUpdater;
 class MemSetInst;
 class StoreInst;
 class TargetLibraryInfo;
@@ -39,9 +42,11 @@
 class MemCpyOptPass : public PassInfoMixin<MemCpyOptPass> {
   MemoryDependenceResults *MD = nullptr;
   TargetLibraryInfo *TLI = nullptr;
-  std::function<AliasAnalysis &()> LookupAliasAnalysis;
-  std::function<AssumptionCache &()> LookupAssumptionCache;
-  std::function<DominatorTree &()> LookupDomTree;
+  AAResults *AA = nullptr;
+  AssumptionCache *AC = nullptr;
+  DominatorTree *DT = nullptr;
+  MemorySSA *MSSA = nullptr;
+  MemorySSAUpdater *MSSAU = nullptr;
 
 public:
   MemCpyOptPass() = default;
@@ -49,27 +54,28 @@
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
 
   // Glue for the old PM.
-  bool runImpl(Function &F, MemoryDependenceResults *MD_,
-               TargetLibraryInfo *TLI_,
-               std::function<AliasAnalysis &()> LookupAliasAnalysis_,
-               std::function<AssumptionCache &()> LookupAssumptionCache_,
-               std::function<DominatorTree &()> LookupDomTree_);
+  bool runImpl(Function &F, MemoryDependenceResults *MD, TargetLibraryInfo *TLI,
+               AAResults *AA, AssumptionCache *AC, DominatorTree *DT,
+               MemorySSA *MSSA);
 
 private:
   // Helper functions
   bool processStore(StoreInst *SI, BasicBlock::iterator &BBI);
   bool processMemSet(MemSetInst *SI, BasicBlock::iterator &BBI);
-  bool processMemCpy(MemCpyInst *M);
+  bool processMemCpy(MemCpyInst *M, BasicBlock::iterator &BBI);
   bool processMemMove(MemMoveInst *M);
-  bool performCallSlotOptzn(Instruction *cpy, Value *cpyDst, Value *cpySrc,
-                            uint64_t cpyLen, unsigned cpyAlign, CallInst *C);
+  bool performCallSlotOptzn(Instruction *cpyLoad, Instruction *cpyStore,
+                            Value *cpyDst, Value *cpySrc, uint64_t cpyLen,
+                            Align cpyAlign, CallInst *C);
   bool processMemCpyMemCpyDependence(MemCpyInst *M, MemCpyInst *MDep);
-  bool processMemSetMemCpyDependence(MemCpyInst *M, MemSetInst *MDep);
-  bool performMemCpyToMemSetOptzn(MemCpyInst *M, MemSetInst *MDep);
-  bool processByValArgument(CallSite CS, unsigned ArgNo);
+  bool processMemSetMemCpyDependence(MemCpyInst *MemCpy, MemSetInst *MemSet);
+  bool performMemCpyToMemSetOptzn(MemCpyInst *MemCpy, MemSetInst *MemSet);
+  bool processByValArgument(CallBase &CB, unsigned ArgNo);
   Instruction *tryMergingIntoMemset(Instruction *I, Value *StartPtr,
                                     Value *ByteVal);
+  bool moveUp(StoreInst *SI, Instruction *P, const LoadInst *LI);
 
+  void eraseInstruction(Instruction *I);
   bool iterateOnFunction(Function &F);
 };
 
diff --git a/linux-x64/clang/include/llvm/Transforms/Scalar/MergedLoadStoreMotion.h b/linux-x64/clang/include/llvm/Transforms/Scalar/MergedLoadStoreMotion.h
index 9071a56..c5f6d6e 100644
--- a/linux-x64/clang/include/llvm/Transforms/Scalar/MergedLoadStoreMotion.h
+++ b/linux-x64/clang/include/llvm/Transforms/Scalar/MergedLoadStoreMotion.h
@@ -27,12 +27,28 @@
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
-class MergedLoadStoreMotionPass
-    : public PassInfoMixin<MergedLoadStoreMotionPass> {
-public:
-  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+struct MergedLoadStoreMotionOptions {
+  bool SplitFooterBB;
+  MergedLoadStoreMotionOptions(bool SplitFooterBB = false)
+      : SplitFooterBB(SplitFooterBB) {}
+
+  MergedLoadStoreMotionOptions &splitFooterBB(bool SFBB) {
+    SplitFooterBB = SFBB;
+    return *this;
+  }
 };
 
+class MergedLoadStoreMotionPass
+    : public PassInfoMixin<MergedLoadStoreMotionPass> {
+  MergedLoadStoreMotionOptions Options;
+
+public:
+  MergedLoadStoreMotionPass()
+      : MergedLoadStoreMotionPass(MergedLoadStoreMotionOptions()) {}
+  MergedLoadStoreMotionPass(const MergedLoadStoreMotionOptions &PassOptions)
+      : Options(PassOptions) {}
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+};
 }
 
 #endif // LLVM_TRANSFORMS_SCALAR_MERGEDLOADSTOREMOTION_H
diff --git a/linux-x64/clang/include/llvm/Transforms/Scalar/NaryReassociate.h b/linux-x64/clang/include/llvm/Transforms/Scalar/NaryReassociate.h
index 26f5fe1..5fa7427 100644
--- a/linux-x64/clang/include/llvm/Transforms/Scalar/NaryReassociate.h
+++ b/linux-x64/clang/include/llvm/Transforms/Scalar/NaryReassociate.h
@@ -114,7 +114,7 @@
   bool doOneIteration(Function &F);
 
   // Reassociates I for better CSE.
-  Instruction *tryReassociate(Instruction *I);
+  Instruction *tryReassociate(Instruction *I, const SCEV *&OrigSCEV);
 
   // Reassociate GEP for better CSE.
   Instruction *tryReassociateGEP(GetElementPtrInst *GEP);
diff --git a/linux-x64/clang/include/llvm/Transforms/Scalar/Reassociate.h b/linux-x64/clang/include/llvm/Transforms/Scalar/Reassociate.h
index 2db8d8c..28794d2 100644
--- a/linux-x64/clang/include/llvm/Transforms/Scalar/Reassociate.h
+++ b/linux-x64/clang/include/llvm/Transforms/Scalar/Reassociate.h
@@ -25,7 +25,6 @@
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/PostOrderIterator.h"
 #include "llvm/ADT/SetVector.h"
-#include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/IR/ValueHandle.h"
 #include <deque>
@@ -37,6 +36,7 @@
 class BinaryOperator;
 class Function;
 class Instruction;
+class IRBuilderBase;
 class Value;
 
 /// A private "module" namespace for types and utilities used by Reassociate.
@@ -114,7 +114,7 @@
   bool CombineXorOpnd(Instruction *I, reassociate::XorOpnd *Opnd1,
                       reassociate::XorOpnd *Opnd2, APInt &ConstOpnd,
                       Value *&Res);
-  Value *buildMinimalMultiplyDAG(IRBuilder<> &Builder,
+  Value *buildMinimalMultiplyDAG(IRBuilderBase &Builder,
                                  SmallVectorImpl<reassociate::Factor> &Factors);
   Value *OptimizeMul(BinaryOperator *I,
                      SmallVectorImpl<reassociate::ValueEntry> &Ops);
@@ -122,7 +122,9 @@
   void EraseInst(Instruction *I);
   void RecursivelyEraseDeadInsts(Instruction *I, OrderedSet &Insts);
   void OptimizeInst(Instruction *I);
-  Instruction *canonicalizeNegConstExpr(Instruction *I);
+  Instruction *canonicalizeNegFPConstantsForOp(Instruction *I, Instruction *Op,
+                                               Value *OtherOp);
+  Instruction *canonicalizeNegFPConstants(Instruction *I);
   void BuildPairMap(ReversePostOrderTraversal<Function *> &RPOT);
 };
 
diff --git a/linux-x64/clang/include/llvm/Transforms/Scalar/Reg2Mem.h b/linux-x64/clang/include/llvm/Transforms/Scalar/Reg2Mem.h
new file mode 100644
index 0000000..25f6563
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Transforms/Scalar/Reg2Mem.h
@@ -0,0 +1,27 @@
+//===- Reg2Mem.h - Convert registers to allocas -----------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file provides the interface for the RegToMem Pass.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_SCALAR_REG2MEM_H
+#define LLVM_TRANSFORMS_SCALAR_REG2MEM_H
+
+#include "llvm/IR/PassManager.h"
+
+namespace llvm {
+
+class RegToMemPass : public PassInfoMixin<RegToMemPass> {
+public:
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+};
+
+} // end namespace llvm
+
+#endif // LLVM_TRANSFORMS_SCALAR_REG2MEM_H
diff --git a/linux-x64/clang/include/llvm/Transforms/Scalar/SCCP.h b/linux-x64/clang/include/llvm/Transforms/Scalar/SCCP.h
index 0ffd983..45e674a 100644
--- a/linux-x64/clang/include/llvm/Transforms/Scalar/SCCP.h
+++ b/linux-x64/clang/include/llvm/Transforms/Scalar/SCCP.h
@@ -45,7 +45,8 @@
   PostDominatorTree *PDT;
 };
 
-bool runIPSCCP(Module &M, const DataLayout &DL, const TargetLibraryInfo *TLI,
+bool runIPSCCP(Module &M, const DataLayout &DL,
+               std::function<const TargetLibraryInfo &(Function &)> GetTLI,
                function_ref<AnalysisResultsForFn(Function &)> getAnalysis);
 } // end namespace llvm
 
diff --git a/linux-x64/clang/include/llvm/Transforms/Scalar/SROA.h b/linux-x64/clang/include/llvm/Transforms/Scalar/SROA.h
index 864a0cb..6ef7c6b 100644
--- a/linux-x64/clang/include/llvm/Transforms/Scalar/SROA.h
+++ b/linux-x64/clang/include/llvm/Transforms/Scalar/SROA.h
@@ -18,6 +18,7 @@
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/IR/PassManager.h"
+#include "llvm/IR/ValueHandle.h"
 #include <vector>
 
 namespace llvm {
@@ -77,8 +78,8 @@
 
   /// A collection of instructions to delete.
   /// We try to batch deletions to simplify code and make things a bit more
-  /// efficient.
-  SetVector<Instruction *, SmallVector<Instruction *, 8>> DeadInsts;
+  /// efficient. We also make sure there is no dangling pointers.
+  SmallVector<WeakVH, 8> DeadInsts;
 
   /// Post-promotion worklist.
   ///
diff --git a/linux-x64/clang/include/llvm/Transforms/Scalar/ScalarizeMaskedMemIntrin.h b/linux-x64/clang/include/llvm/Transforms/Scalar/ScalarizeMaskedMemIntrin.h
new file mode 100644
index 0000000..19339ca
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Transforms/Scalar/ScalarizeMaskedMemIntrin.h
@@ -0,0 +1,29 @@
+//===- ScalarizeMaskedMemIntrin.h - Scalarize unsupported masked mem ----===//
+//                                    instrinsics
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This pass replaces masked memory intrinsics - when unsupported by the target
+// - with a chain of basic blocks, that deal with the elements one-by-one if the
+// appropriate mask bit is set.
+//
+//===----------------------------------------------------------------------===//
+//
+#ifndef LLVM_TRANSFORMS_SCALAR_SCALARIZE_MASKED_MEMINTRIN_H
+#define LLVM_TRANSFORMS_SCALAR_SCALARIZE_MASKED_MEMINTRIN_H
+
+#include "llvm/IR/PassManager.h"
+
+namespace llvm {
+
+struct ScalarizeMaskedMemIntrinPass
+    : public PassInfoMixin<ScalarizeMaskedMemIntrinPass> {
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+};
+} // end namespace llvm
+
+#endif
diff --git a/linux-x64/clang/include/llvm/Transforms/Scalar/SeparateConstOffsetFromGEP.h b/linux-x64/clang/include/llvm/Transforms/Scalar/SeparateConstOffsetFromGEP.h
new file mode 100644
index 0000000..5bd6ce1
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Transforms/Scalar/SeparateConstOffsetFromGEP.h
@@ -0,0 +1,27 @@
+//===- SeparateConstOffsetFromGEP.h ---------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_SCALAR_SEPARATECONSTOFFSETFROMGEP_H
+#define LLVM_TRANSFORMS_SCALAR_SEPARATECONSTOFFSETFROMGEP_H
+
+#include "llvm/IR/PassManager.h"
+
+namespace llvm {
+
+class SeparateConstOffsetFromGEPPass
+    : public PassInfoMixin<SeparateConstOffsetFromGEPPass> {
+  bool LowerGEP;
+
+public:
+  SeparateConstOffsetFromGEPPass(bool LowerGEP = false) : LowerGEP(LowerGEP) {}
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager &);
+};
+
+} // end namespace llvm
+
+#endif // LLVM_TRANSFORMS_SCALAR_SEPARATECONSTOFFSETFROMGEP_H
diff --git a/linux-x64/clang/include/llvm/Transforms/Scalar/SimplifyCFG.h b/linux-x64/clang/include/llvm/Transforms/Scalar/SimplifyCFG.h
index f9792d3..7c53938 100644
--- a/linux-x64/clang/include/llvm/Transforms/Scalar/SimplifyCFG.h
+++ b/linux-x64/clang/include/llvm/Transforms/Scalar/SimplifyCFG.h
@@ -14,9 +14,9 @@
 #ifndef LLVM_TRANSFORMS_SCALAR_SIMPLIFYCFG_H
 #define LLVM_TRANSFORMS_SCALAR_SIMPLIFYCFG_H
 
-#include "llvm/Transforms/Utils/Local.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/PassManager.h"
+#include "llvm/Transforms/Utils/SimplifyCFGOptions.h"
 
 namespace llvm {
 
@@ -34,13 +34,7 @@
   /// rather than optimal IR. That is, by default we bypass transformations that
   /// are likely to improve performance but make analysis for other passes more
   /// difficult.
-  SimplifyCFGPass()
-      : SimplifyCFGPass(SimplifyCFGOptions()
-                            .forwardSwitchCondToPhi(false)
-                            .convertSwitchToLookupTable(false)
-                            .needCanonicalLoops(true)
-                            .sinkCommonInsts(false)) {}
-
+  SimplifyCFGPass();
 
   /// Construct a pass with optional optimizations.
   SimplifyCFGPass(const SimplifyCFGOptions &PassOptions);
diff --git a/linux-x64/clang/include/llvm/Transforms/Scalar/StraightLineStrengthReduce.h b/linux-x64/clang/include/llvm/Transforms/Scalar/StraightLineStrengthReduce.h
new file mode 100644
index 0000000..11233cc
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Transforms/Scalar/StraightLineStrengthReduce.h
@@ -0,0 +1,24 @@
+//===- StraightLineStrengthReduce.h - -----------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_SCALAR_STRAIGHTLINESTRENGTHREDUCE_H
+#define LLVM_TRANSFORMS_SCALAR_STRAIGHTLINESTRENGTHREDUCE_H
+
+#include "llvm/IR/PassManager.h"
+
+namespace llvm {
+
+class StraightLineStrengthReducePass
+    : public PassInfoMixin<StraightLineStrengthReducePass> {
+public:
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+};
+
+} // namespace llvm
+
+#endif // LLVM_TRANSFORMS_SCALAR_STRAIGHTLINESTRENGTHREDUCE_H
diff --git a/linux-x64/clang/include/llvm/Transforms/Scalar/StructurizeCFG.h b/linux-x64/clang/include/llvm/Transforms/Scalar/StructurizeCFG.h
new file mode 100644
index 0000000..50d41ac
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Transforms/Scalar/StructurizeCFG.h
@@ -0,0 +1,20 @@
+//===- StructurizeCFG.h ---------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_SCALAR_STRUCTURIZECFG_H
+#define LLVM_TRANSFORMS_SCALAR_STRUCTURIZECFG_H
+
+#include "llvm/IR/PassManager.h"
+
+namespace llvm {
+struct StructurizeCFGPass : PassInfoMixin<StructurizeCFGPass> {
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+};
+} // namespace llvm
+
+#endif // LLVM_TRANSFORMS_SCALAR_STRUCTURIZECFG_H
diff --git a/linux-x64/clang/include/llvm/Transforms/Utils.h b/linux-x64/clang/include/llvm/Transforms/Utils.h
index 6e03453..9162a86 100644
--- a/linux-x64/clang/include/llvm/Transforms/Utils.h
+++ b/linux-x64/clang/include/llvm/Transforms/Utils.h
@@ -26,6 +26,12 @@
 ModulePass *createMetaRenamerPass();
 
 //===----------------------------------------------------------------------===//
+// createUniqueInternalLinkageNamesPass - Make internal linkage symbol names
+// unique.
+//
+ModulePass *createUniqueInternalLinkageNamesPass();
+
+//===----------------------------------------------------------------------===//
 //
 // LowerInvoke - This pass removes invoke instructions, converting them to call
 // instructions.
@@ -111,7 +117,7 @@
 
 /// This function returns a new pass that downgrades the debug info in the
 /// module to line tables only.
-ModulePass *createStripNonLineTableDebugInfoPass();
+ModulePass *createStripNonLineTableDebugLegacyPass();
 
 //===----------------------------------------------------------------------===//
 //
@@ -119,6 +125,42 @@
 // number of conditional branches in the hot paths based on profiles.
 //
 FunctionPass *createControlHeightReductionLegacyPass();
-}
+
+//===----------------------------------------------------------------------===//
+//
+// InjectTLIMappingsLegacy - populates the VFABI attribute with the
+// scalar-to-vector mappings from the TargetLibraryInfo.
+//
+FunctionPass *createInjectTLIMappingsLegacyPass();
+
+//===----------------------------------------------------------------------===//
+//
+// UnifyLoopExits - For each loop, creates a new block N such that all exiting
+// blocks branch to N, and then N distributes control flow to all the original
+// exit blocks.
+//
+FunctionPass *createUnifyLoopExitsPass();
+
+//===----------------------------------------------------------------------===//
+//
+// FixIrreducible - Convert each SCC with irreducible control-flow
+// into a natural loop.
+//
+FunctionPass *createFixIrreduciblePass();
+
+//===----------------------------------------------------------------------===//
+//
+// AssumeSimplify - remove redundant assumes and merge assumes in the same
+// BasicBlock when possible.
+//
+FunctionPass *createAssumeSimplifyPass();
+
+//===----------------------------------------------------------------------===//
+//
+// CanonicalizeFreezeInLoops - Canonicalize freeze instructions in loops so they
+// don't block SCEV.
+//
+Pass *createCanonicalizeFreezeInLoopsPass();
+} // namespace llvm
 
 #endif
diff --git a/linux-x64/clang/include/llvm/Transforms/Utils/AMDGPUEmitPrintf.h b/linux-x64/clang/include/llvm/Transforms/Utils/AMDGPUEmitPrintf.h
new file mode 100644
index 0000000..65dbf47
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Transforms/Utils/AMDGPUEmitPrintf.h
@@ -0,0 +1,25 @@
+//===- AMDGPUEmitPrintf.h ---------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Utility function to lower a printf call into a series of device
+// library calls on the AMDGPU target.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_UTILS_AMDGPUEMITPRINTF_H
+#define LLVM_TRANSFORMS_UTILS_AMDGPUEMITPRINTF_H
+
+#include "llvm/IR/IRBuilder.h"
+
+namespace llvm {
+
+Value *emitAMDGPUPrintfCall(IRBuilder<> &Builder, ArrayRef<Value *> Args);
+
+} // end namespace llvm
+
+#endif // LLVM_TRANSFORMS_UTILS_AMDGPUEMITPRINTF_H
diff --git a/linux-x64/clang/include/llvm/Transforms/Utils/AssumeBundleBuilder.h b/linux-x64/clang/include/llvm/Transforms/Utils/AssumeBundleBuilder.h
new file mode 100644
index 0000000..8e00982
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Transforms/Utils/AssumeBundleBuilder.h
@@ -0,0 +1,60 @@
+//===- AssumeBundleBuilder.h - utils to build assume bundles ----*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contain tools to preserve informations. They should be used before
+// performing a transformation that may move and delete instructions as those
+// transformation may destroy or worsen information that can be derived from the
+// IR.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_UTILS_ASSUMEBUNDLEBUILDER_H
+#define LLVM_TRANSFORMS_UTILS_ASSUMEBUNDLEBUILDER_H
+
+#include "llvm/IR/Attributes.h"
+#include "llvm/IR/Instruction.h"
+#include "llvm/IR/PassManager.h"
+
+namespace llvm {
+class IntrinsicInst;
+class AssumptionCache;
+class DominatorTree;
+
+/// Build a call to llvm.assume to preserve informations that can be derived
+/// from the given instruction.
+/// If no information derived from \p I, this call returns null.
+/// The returned instruction is not inserted anywhere.
+IntrinsicInst *buildAssumeFromInst(Instruction *I);
+
+/// Calls BuildAssumeFromInst and if the resulting llvm.assume is valid insert
+/// if before I. This is usually what need to be done to salvage the knowledge
+/// contained in the instruction I.
+/// The AssumptionCache must be provided if it is available or the cache may
+/// become silently be invalid.
+/// The DominatorTree can optionally be provided to enable cross-block
+/// reasoning.
+void salvageKnowledge(Instruction *I, AssumptionCache *AC = nullptr,
+                      DominatorTree *DT = nullptr);
+
+/// This pass attempts to minimize the number of assume without loosing any
+/// information.
+struct AssumeSimplifyPass : public PassInfoMixin<AssumeSimplifyPass> {
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+};
+
+FunctionPass *createAssumeSimplifyPass();
+
+/// This pass will try to build an llvm.assume for every instruction in the
+/// function. Its main purpose is testing.
+struct AssumeBuilderPass : public PassInfoMixin<AssumeBuilderPass> {
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+};
+
+} // namespace llvm
+
+#endif
diff --git a/linux-x64/clang/include/llvm/Transforms/Utils/BasicBlockUtils.h b/linux-x64/clang/include/llvm/Transforms/Utils/BasicBlockUtils.h
index 4d861ff..1dda739 100644
--- a/linux-x64/clang/include/llvm/Transforms/Utils/BasicBlockUtils.h
+++ b/linux-x64/clang/include/llvm/Transforms/Utils/BasicBlockUtils.h
@@ -17,7 +17,9 @@
 // FIXME: Move to this file: BasicBlock::removePredecessor, BB::splitBasicBlock
 
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/SetVector.h"
 #include "llvm/Analysis/DomTreeUpdater.h"
+#include "llvm/Analysis/LoopInfo.h"
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/CFG.h"
 #include "llvm/IR/InstrTypes.h"
@@ -72,21 +74,43 @@
 /// in it, fold them away. This handles the case when all entries to the PHI
 /// nodes in a block are guaranteed equal, such as when the block has exactly
 /// one predecessor.
-void FoldSingleEntryPHINodes(BasicBlock *BB,
+bool FoldSingleEntryPHINodes(BasicBlock *BB,
                              MemoryDependenceResults *MemDep = nullptr);
 
 /// Examine each PHI in the given block and delete it if it is dead. Also
 /// recursively delete any operands that become dead as a result. This includes
 /// tracing the def-use list from the PHI to see if it is ultimately unused or
 /// if it reaches an unused cycle. Return true if any PHIs were deleted.
-bool DeleteDeadPHIs(BasicBlock *BB, const TargetLibraryInfo *TLI = nullptr);
+bool DeleteDeadPHIs(BasicBlock *BB, const TargetLibraryInfo *TLI = nullptr,
+                    MemorySSAUpdater *MSSAU = nullptr);
 
 /// Attempts to merge a block into its predecessor, if possible. The return
 /// value indicates success or failure.
+/// By default do not merge blocks if BB's predecessor has multiple successors.
+/// If PredecessorWithTwoSuccessors = true, the blocks can only be merged
+/// if BB's Pred has a branch to BB and to AnotherBB, and BB has a single
+/// successor Sing. In this case the branch will be updated with Sing instead of
+/// BB, and BB will still be merged into its predecessor and removed.
 bool MergeBlockIntoPredecessor(BasicBlock *BB, DomTreeUpdater *DTU = nullptr,
                                LoopInfo *LI = nullptr,
                                MemorySSAUpdater *MSSAU = nullptr,
-                               MemoryDependenceResults *MemDep = nullptr);
+                               MemoryDependenceResults *MemDep = nullptr,
+                               bool PredecessorWithTwoSuccessors = false);
+
+/// Merge block(s) sucessors, if possible. Return true if at least two
+/// of the blocks were merged together.
+/// In order to merge, each block must be terminated by an unconditional
+/// branch. If L is provided, then the blocks merged into their predecessors
+/// must be in L. In addition, This utility calls on another utility:
+/// MergeBlockIntoPredecessor. Blocks are successfully merged when the call to
+/// MergeBlockIntoPredecessor returns true.
+bool MergeBlockSuccessorsIntoGivenBlocks(
+    SmallPtrSetImpl<BasicBlock *> &MergeBlocks, Loop *L = nullptr,
+    DomTreeUpdater *DTU = nullptr, LoopInfo *LI = nullptr);
+
+/// Try to remove redundant dbg.value instructions from given basic block.
+/// Returns true if at least one instruction was removed.
+bool RemoveRedundantDbgInstrs(BasicBlock *BB);
 
 /// Replace all uses of an instruction (specified by BI) with a value, then
 /// remove and delete the original instruction.
@@ -117,6 +141,10 @@
   bool KeepOneInputPHIs = false;
   bool PreserveLCSSA = false;
   bool IgnoreUnreachableDests = false;
+  /// SplitCriticalEdge is guaranteed to preserve loop-simplify form if LI is
+  /// provided. If it cannot be preserved, no splitting will take place. If it
+  /// is not set, preserve loop-simplify form if possible.
+  bool PreserveLoopSimplify = true;
 
   CriticalEdgeSplittingOptions(DominatorTree *DT = nullptr,
                                LoopInfo *LI = nullptr,
@@ -143,6 +171,11 @@
     IgnoreUnreachableDests = true;
     return *this;
   }
+
+  CriticalEdgeSplittingOptions &unsetPreserveLoopSimplify() {
+    PreserveLoopSimplify = false;
+    return *this;
+  }
 };
 
 /// If this edge is a critical edge, insert a new node to split the critical
@@ -163,7 +196,8 @@
 /// to.
 BasicBlock *SplitCriticalEdge(Instruction *TI, unsigned SuccNum,
                               const CriticalEdgeSplittingOptions &Options =
-                                  CriticalEdgeSplittingOptions());
+                                  CriticalEdgeSplittingOptions(),
+                              const Twine &BBName = "");
 
 inline BasicBlock *
 SplitCriticalEdge(BasicBlock *BB, succ_iterator SI,
@@ -211,18 +245,71 @@
                                const CriticalEdgeSplittingOptions &Options =
                                    CriticalEdgeSplittingOptions());
 
-/// Split the edge connecting specified block.
+/// Split the edge connecting the specified blocks, and return the newly created
+/// basic block between \p From and \p To.
 BasicBlock *SplitEdge(BasicBlock *From, BasicBlock *To,
                       DominatorTree *DT = nullptr, LoopInfo *LI = nullptr,
-                      MemorySSAUpdater *MSSAU = nullptr);
+                      MemorySSAUpdater *MSSAU = nullptr,
+                      const Twine &BBName = "");
 
-/// Split the specified block at the specified instruction - everything before
-/// SplitPt stays in Old and everything starting with SplitPt moves to a new
-/// block. The two blocks are joined by an unconditional branch and the loop
-/// info is updated.
+/// Split the specified block at the specified instruction.
+///
+/// If \p Before is true, splitBlockBefore handles the block
+/// splitting. Otherwise, execution proceeds as described below.
+///
+/// Everything before \p SplitPt stays in \p Old and everything starting with \p
+/// SplitPt moves to a new block. The two blocks are joined by an unconditional
+/// branch. The new block with name \p BBName is returned.
+///
+/// FIXME: deprecated, switch to the DomTreeUpdater-based one.
+BasicBlock *SplitBlock(BasicBlock *Old, Instruction *SplitPt, DominatorTree *DT,
+                       LoopInfo *LI = nullptr,
+                       MemorySSAUpdater *MSSAU = nullptr,
+                       const Twine &BBName = "", bool Before = false);
+
+/// Split the specified block at the specified instruction.
+///
+/// If \p Before is true, splitBlockBefore handles the block
+/// splitting. Otherwise, execution proceeds as described below.
+///
+/// Everything before \p SplitPt stays in \p Old and everything starting with \p
+/// SplitPt moves to a new block. The two blocks are joined by an unconditional
+/// branch. The new block with name \p BBName is returned.
 BasicBlock *SplitBlock(BasicBlock *Old, Instruction *SplitPt,
-                       DominatorTree *DT = nullptr, LoopInfo *LI = nullptr,
-                       MemorySSAUpdater *MSSAU = nullptr);
+                       DomTreeUpdater *DTU = nullptr, LoopInfo *LI = nullptr,
+                       MemorySSAUpdater *MSSAU = nullptr,
+                       const Twine &BBName = "", bool Before = false);
+
+/// Split the specified block at the specified instruction \p SplitPt.
+/// All instructions before \p SplitPt are moved to a new block and all
+/// instructions after \p SplitPt stay in the old block. The new block and the
+/// old block are joined by inserting an unconditional branch to the end of the
+/// new block. The new block with name \p BBName is returned.
+BasicBlock *splitBlockBefore(BasicBlock *Old, Instruction *SplitPt,
+                             DomTreeUpdater *DTU, LoopInfo *LI,
+                             MemorySSAUpdater *MSSAU, const Twine &BBName = "");
+
+/// This method introduces at least one new basic block into the function and
+/// moves some of the predecessors of BB to be predecessors of the new block.
+/// The new predecessors are indicated by the Preds array. The new block is
+/// given a suffix of 'Suffix'. Returns new basic block to which predecessors
+/// from Preds are now pointing.
+///
+/// If BB is a landingpad block then additional basicblock might be introduced.
+/// It will have Suffix+".split_lp". See SplitLandingPadPredecessors for more
+/// details on this case.
+///
+/// This currently updates the LLVM IR, DominatorTree, LoopInfo, and LCCSA but
+/// no other analyses. In particular, it does not preserve LoopSimplify
+/// (because it's complicated to handle the case where one of the edges being
+/// split is an exit of a loop with other exits).
+///
+/// FIXME: deprecated, switch to the DomTreeUpdater-based one.
+BasicBlock *SplitBlockPredecessors(BasicBlock *BB, ArrayRef<BasicBlock *> Preds,
+                                   const char *Suffix, DominatorTree *DT,
+                                   LoopInfo *LI = nullptr,
+                                   MemorySSAUpdater *MSSAU = nullptr,
+                                   bool PreserveLCSSA = false);
 
 /// This method introduces at least one new basic block into the function and
 /// moves some of the predecessors of BB to be predecessors of the new block.
@@ -240,7 +327,7 @@
 /// split is an exit of a loop with other exits).
 BasicBlock *SplitBlockPredecessors(BasicBlock *BB, ArrayRef<BasicBlock *> Preds,
                                    const char *Suffix,
-                                   DominatorTree *DT = nullptr,
+                                   DomTreeUpdater *DTU = nullptr,
                                    LoopInfo *LI = nullptr,
                                    MemorySSAUpdater *MSSAU = nullptr,
                                    bool PreserveLCSSA = false);
@@ -256,10 +343,31 @@
 /// no other analyses. In particular, it does not preserve LoopSimplify
 /// (because it's complicated to handle the case where one of the edges being
 /// split is an exit of a loop with other exits).
+///
+/// FIXME: deprecated, switch to the DomTreeUpdater-based one.
+void SplitLandingPadPredecessors(BasicBlock *OrigBB,
+                                 ArrayRef<BasicBlock *> Preds,
+                                 const char *Suffix, const char *Suffix2,
+                                 SmallVectorImpl<BasicBlock *> &NewBBs,
+                                 DominatorTree *DT, LoopInfo *LI = nullptr,
+                                 MemorySSAUpdater *MSSAU = nullptr,
+                                 bool PreserveLCSSA = false);
+
+/// This method transforms the landing pad, OrigBB, by introducing two new basic
+/// blocks into the function. One of those new basic blocks gets the
+/// predecessors listed in Preds. The other basic block gets the remaining
+/// predecessors of OrigBB. The landingpad instruction OrigBB is clone into both
+/// of the new basic blocks. The new blocks are given the suffixes 'Suffix1' and
+/// 'Suffix2', and are returned in the NewBBs vector.
+///
+/// This currently updates the LLVM IR, DominatorTree, LoopInfo, and LCCSA but
+/// no other analyses. In particular, it does not preserve LoopSimplify
+/// (because it's complicated to handle the case where one of the edges being
+/// split is an exit of a loop with other exits).
 void SplitLandingPadPredecessors(
     BasicBlock *OrigBB, ArrayRef<BasicBlock *> Preds, const char *Suffix,
     const char *Suffix2, SmallVectorImpl<BasicBlock *> &NewBBs,
-    DominatorTree *DT = nullptr, LoopInfo *LI = nullptr,
+    DomTreeUpdater *DTU = nullptr, LoopInfo *LI = nullptr,
     MemorySSAUpdater *MSSAU = nullptr, bool PreserveLCSSA = false);
 
 /// This method duplicates the specified return instruction into a predecessor
@@ -291,10 +399,39 @@
 /// Returns the NewBasicBlock's terminator.
 ///
 /// Updates DT and LI if given.
+///
+/// FIXME: deprecated, switch to the DomTreeUpdater-based one.
+Instruction *SplitBlockAndInsertIfThen(Value *Cond, Instruction *SplitBefore,
+                                       bool Unreachable, MDNode *BranchWeights,
+                                       DominatorTree *DT,
+                                       LoopInfo *LI = nullptr,
+                                       BasicBlock *ThenBlock = nullptr);
+
+/// Split the containing block at the specified instruction - everything before
+/// SplitBefore stays in the old basic block, and the rest of the instructions
+/// in the BB are moved to a new block. The two blocks are connected by a
+/// conditional branch (with value of Cmp being the condition).
+/// Before:
+///   Head
+///   SplitBefore
+///   Tail
+/// After:
+///   Head
+///   if (Cond)
+///     ThenBlock
+///   SplitBefore
+///   Tail
+///
+/// If \p ThenBlock is not specified, a new block will be created for it.
+/// If \p Unreachable is true, the newly created block will end with
+/// UnreachableInst, otherwise it branches to Tail.
+/// Returns the NewBasicBlock's terminator.
+///
+/// Updates DT and LI if given.
 Instruction *SplitBlockAndInsertIfThen(Value *Cond, Instruction *SplitBefore,
                                        bool Unreachable,
                                        MDNode *BranchWeights = nullptr,
-                                       DominatorTree *DT = nullptr,
+                                       DomTreeUpdater *DTU = nullptr,
                                        LoopInfo *LI = nullptr,
                                        BasicBlock *ThenBlock = nullptr);
 
@@ -351,6 +488,81 @@
                                   BranchProbabilityInfo *BPI = nullptr,
                                   BlockFrequencyInfo *BFI = nullptr);
 
+/// Given a set of incoming and outgoing blocks, create a "hub" such that every
+/// edge from an incoming block InBB to an outgoing block OutBB is now split
+/// into two edges, one from InBB to the hub and another from the hub to
+/// OutBB. The hub consists of a series of guard blocks, one for each outgoing
+/// block. Each guard block conditionally branches to the corresponding outgoing
+/// block, or the next guard block in the chain. These guard blocks are returned
+/// in the argument vector.
+///
+/// Since the control flow edges from InBB to OutBB have now been replaced, the
+/// function also updates any PHINodes in OutBB. For each such PHINode, the
+/// operands corresponding to incoming blocks are moved to a new PHINode in the
+/// hub, and the hub is made an operand of the original PHINode.
+///
+/// Input CFG:
+/// ----------
+///
+///                    Def
+///                     |
+///                     v
+///           In1      In2
+///            |        |
+///            |        |
+///            v        v
+///  Foo ---> Out1     Out2
+///                     |
+///                     v
+///                    Use
+///
+///
+/// Create hub: Incoming = {In1, In2}, Outgoing = {Out1, Out2}
+/// ----------------------------------------------------------
+///
+///             Def
+///              |
+///              v
+///  In1        In2          Foo
+///   |    Hub   |            |
+///   |    + - - | - - +      |
+///   |    '     v     '      V
+///   +------> Guard1 -----> Out1
+///        '     |     '
+///        '     v     '
+///        '   Guard2 -----> Out2
+///        '           '      |
+///        + - - - - - +      |
+///                           v
+///                          Use
+///
+/// Limitations:
+/// -----------
+/// 1. This assumes that all terminators in the CFG are direct branches (the
+///    "br" instruction). The presence of any other control flow such as
+///    indirectbr, switch or callbr will cause an assert.
+///
+/// 2. The updates to the PHINodes are not sufficient to restore SSA
+///    form. Consider a definition Def, its use Use, incoming block In2 and
+///    outgoing block Out2, such that:
+///    a. In2 is reachable from D or contains D.
+///    b. U is reachable from Out2 or is contained in Out2.
+///    c. U is not a PHINode if U is contained in Out2.
+///
+///    Clearly, Def dominates Out2 since the program is valid SSA. But when the
+///    hub is introduced, there is a new path through the hub along which Use is
+///    reachable from entry without passing through Def, and SSA is no longer
+///    valid. To fix this, we need to look at all the blocks post-dominated by
+///    the hub on the one hand, and dominated by Out2 on the other. This is left
+///    for the caller to accomplish, since each specific use of this function
+///    may have additional information which simplifies this fixup. For example,
+///    see restoreSSA() in the UnifyLoopExits pass.
+BasicBlock *CreateControlFlowHub(DomTreeUpdater *DTU,
+                                 SmallVectorImpl<BasicBlock *> &GuardBlocks,
+                                 const SetVector<BasicBlock *> &Predecessors,
+                                 const SetVector<BasicBlock *> &Successors,
+                                 const StringRef Prefix);
+
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_UTILS_BASICBLOCKUTILS_H
diff --git a/linux-x64/clang/include/llvm/Transforms/Utils/BuildLibCalls.h b/linux-x64/clang/include/llvm/Transforms/Utils/BuildLibCalls.h
index 8421c31..e7d4193 100644
--- a/linux-x64/clang/include/llvm/Transforms/Utils/BuildLibCalls.h
+++ b/linux-x64/clang/include/llvm/Transforms/Utils/BuildLibCalls.h
@@ -15,12 +15,11 @@
 #define LLVM_TRANSFORMS_UTILS_BUILDLIBCALLS_H
 
 #include "llvm/Analysis/TargetLibraryInfo.h"
-#include "llvm/IR/IRBuilder.h"
 
 namespace llvm {
   class Value;
   class DataLayout;
-  class TargetLibraryInfo;
+  class IRBuilderBase;
 
   /// Analyze the name and prototype of the given function and set any
   /// applicable attributes.
@@ -30,131 +29,139 @@
   bool inferLibFuncAttributes(Function &F, const TargetLibraryInfo &TLI);
   bool inferLibFuncAttributes(Module *M, StringRef Name, const TargetLibraryInfo &TLI);
 
-  /// Check whether the overloaded unary floating point function
+  /// Check whether the overloaded floating point function
   /// corresponding to \a Ty is available.
-  bool hasUnaryFloatFn(const TargetLibraryInfo *TLI, Type *Ty,
-                       LibFunc DoubleFn, LibFunc FloatFn,
-                       LibFunc LongDoubleFn);
+  bool hasFloatFn(const TargetLibraryInfo *TLI, Type *Ty,
+                  LibFunc DoubleFn, LibFunc FloatFn, LibFunc LongDoubleFn);
 
-  /// Get the name of the overloaded unary floating point function
+  /// Get the name of the overloaded floating point function
   /// corresponding to \a Ty.
-  StringRef getUnaryFloatFn(const TargetLibraryInfo *TLI, Type *Ty,
-                            LibFunc DoubleFn, LibFunc FloatFn,
-                            LibFunc LongDoubleFn);
+  StringRef getFloatFnName(const TargetLibraryInfo *TLI, Type *Ty,
+                           LibFunc DoubleFn, LibFunc FloatFn,
+                           LibFunc LongDoubleFn);
 
   /// Return V if it is an i8*, otherwise cast it to i8*.
-  Value *castToCStr(Value *V, IRBuilder<> &B);
+  Value *castToCStr(Value *V, IRBuilderBase &B);
 
   /// Emit a call to the strlen function to the builder, for the specified
   /// pointer. Ptr is required to be some pointer type, and the return value has
   /// 'intptr_t' type.
-  Value *emitStrLen(Value *Ptr, IRBuilder<> &B, const DataLayout &DL,
+  Value *emitStrLen(Value *Ptr, IRBuilderBase &B, const DataLayout &DL,
                     const TargetLibraryInfo *TLI);
 
+  /// Emit a call to the strdup function to the builder, for the specified
+  /// pointer. Ptr is required to be some pointer type, and the return value has
+  /// 'i8*' type.
+  Value *emitStrDup(Value *Ptr, IRBuilderBase &B, const TargetLibraryInfo *TLI);
+
   /// Emit a call to the strnlen function to the builder, for the specified
   /// pointer. Ptr is required to be some pointer type, MaxLen must be of size_t
   /// type, and the return value has 'intptr_t' type.
-  Value *emitStrNLen(Value *Ptr, Value *MaxLen, IRBuilder<> &B,
+  Value *emitStrNLen(Value *Ptr, Value *MaxLen, IRBuilderBase &B,
                      const DataLayout &DL, const TargetLibraryInfo *TLI);
 
   /// Emit a call to the strchr function to the builder, for the specified
   /// pointer and character. Ptr is required to be some pointer type, and the
   /// return value has 'i8*' type.
-  Value *emitStrChr(Value *Ptr, char C, IRBuilder<> &B,
+  Value *emitStrChr(Value *Ptr, char C, IRBuilderBase &B,
                     const TargetLibraryInfo *TLI);
 
   /// Emit a call to the strncmp function to the builder.
-  Value *emitStrNCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilder<> &B,
+  Value *emitStrNCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilderBase &B,
                      const DataLayout &DL, const TargetLibraryInfo *TLI);
 
   /// Emit a call to the strcpy function to the builder, for the specified
   /// pointer arguments.
-  Value *emitStrCpy(Value *Dst, Value *Src, IRBuilder<> &B,
+  Value *emitStrCpy(Value *Dst, Value *Src, IRBuilderBase &B,
                     const TargetLibraryInfo *TLI);
 
   /// Emit a call to the stpcpy function to the builder, for the specified
   /// pointer arguments.
-  Value *emitStpCpy(Value *Dst, Value *Src, IRBuilder<> &B,
+  Value *emitStpCpy(Value *Dst, Value *Src, IRBuilderBase &B,
                     const TargetLibraryInfo *TLI);
 
   /// Emit a call to the strncpy function to the builder, for the specified
   /// pointer arguments and length.
-  Value *emitStrNCpy(Value *Dst, Value *Src, Value *Len, IRBuilder<> &B,
+  Value *emitStrNCpy(Value *Dst, Value *Src, Value *Len, IRBuilderBase &B,
                      const TargetLibraryInfo *TLI);
 
   /// Emit a call to the stpncpy function to the builder, for the specified
   /// pointer arguments and length.
-  Value *emitStpNCpy(Value *Dst, Value *Src, Value *Len, IRBuilder<> &B,
+  Value *emitStpNCpy(Value *Dst, Value *Src, Value *Len, IRBuilderBase &B,
                      const TargetLibraryInfo *TLI);
 
   /// Emit a call to the __memcpy_chk function to the builder. This expects that
   /// the Len and ObjSize have type 'intptr_t' and Dst/Src are pointers.
   Value *emitMemCpyChk(Value *Dst, Value *Src, Value *Len, Value *ObjSize,
-                       IRBuilder<> &B, const DataLayout &DL,
+                       IRBuilderBase &B, const DataLayout &DL,
                        const TargetLibraryInfo *TLI);
 
+  /// Emit a call to the mempcpy function.
+  Value *emitMemPCpy(Value *Dst, Value *Src, Value *Len, IRBuilderBase &B,
+                     const DataLayout &DL, const TargetLibraryInfo *TLI);
+
   /// Emit a call to the memchr function. This assumes that Ptr is a pointer,
   /// Val is an i32 value, and Len is an 'intptr_t' value.
-  Value *emitMemChr(Value *Ptr, Value *Val, Value *Len, IRBuilder<> &B,
+  Value *emitMemChr(Value *Ptr, Value *Val, Value *Len, IRBuilderBase &B,
                     const DataLayout &DL, const TargetLibraryInfo *TLI);
 
   /// Emit a call to the memcmp function.
-  Value *emitMemCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilder<> &B,
+  Value *emitMemCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilderBase &B,
                     const DataLayout &DL, const TargetLibraryInfo *TLI);
 
   /// Emit a call to the bcmp function.
-  Value *emitBCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilder<> &B,
+  Value *emitBCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilderBase &B,
                   const DataLayout &DL, const TargetLibraryInfo *TLI);
 
   /// Emit a call to the memccpy function.
   Value *emitMemCCpy(Value *Ptr1, Value *Ptr2, Value *Val, Value *Len,
-                     IRBuilder<> &B, const TargetLibraryInfo *TLI);
+                     IRBuilderBase &B, const TargetLibraryInfo *TLI);
 
   /// Emit a call to the snprintf function.
   Value *emitSNPrintf(Value *Dest, Value *Size, Value *Fmt,
-                      ArrayRef<Value *> Args, IRBuilder<> &B,
+                      ArrayRef<Value *> Args, IRBuilderBase &B,
                       const TargetLibraryInfo *TLI);
 
   /// Emit a call to the sprintf function.
   Value *emitSPrintf(Value *Dest, Value *Fmt, ArrayRef<Value *> VariadicArgs,
-                     IRBuilder<> &B, const TargetLibraryInfo *TLI);
+                     IRBuilderBase &B, const TargetLibraryInfo *TLI);
 
   /// Emit a call to the strcat function.
-  Value *emitStrCat(Value *Dest, Value *Src, IRBuilder<> &B,
+  Value *emitStrCat(Value *Dest, Value *Src, IRBuilderBase &B,
                     const TargetLibraryInfo *TLI);
 
   /// Emit a call to the strlcpy function.
-  Value *emitStrLCpy(Value *Dest, Value *Src, Value *Size, IRBuilder<> &B,
+  Value *emitStrLCpy(Value *Dest, Value *Src, Value *Size, IRBuilderBase &B,
                      const TargetLibraryInfo *TLI);
 
   /// Emit a call to the strlcat function.
-  Value *emitStrLCat(Value *Dest, Value *Src, Value *Size, IRBuilder<> &B,
+  Value *emitStrLCat(Value *Dest, Value *Src, Value *Size, IRBuilderBase &B,
                      const TargetLibraryInfo *TLI);
 
   /// Emit a call to the strncat function.
-  Value *emitStrNCat(Value *Dest, Value *Src, Value *Size, IRBuilder<> &B,
+  Value *emitStrNCat(Value *Dest, Value *Src, Value *Size, IRBuilderBase &B,
                      const TargetLibraryInfo *TLI);
 
   /// Emit a call to the vsnprintf function.
   Value *emitVSNPrintf(Value *Dest, Value *Size, Value *Fmt, Value *VAList,
-                       IRBuilder<> &B, const TargetLibraryInfo *TLI);
+                       IRBuilderBase &B, const TargetLibraryInfo *TLI);
 
   /// Emit a call to the vsprintf function.
-  Value *emitVSPrintf(Value *Dest, Value *Fmt, Value *VAList, IRBuilder<> &B,
+  Value *emitVSPrintf(Value *Dest, Value *Fmt, Value *VAList, IRBuilderBase &B,
                       const TargetLibraryInfo *TLI);
 
   /// Emit a call to the unary function named 'Name' (e.g.  'floor'). This
   /// function is known to take a single of type matching 'Op' and returns one
   /// value with the same type. If 'Op' is a long double, 'l' is added as the
   /// suffix of name, if 'Op' is a float, we add a 'f' suffix.
-  Value *emitUnaryFloatFnCall(Value *Op, StringRef Name, IRBuilder<> &B,
+  Value *emitUnaryFloatFnCall(Value *Op, StringRef Name, IRBuilderBase &B,
                               const AttributeList &Attrs);
 
   /// Emit a call to the unary function DoubleFn, FloatFn or LongDoubleFn,
   /// depending of the type of Op.
   Value *emitUnaryFloatFnCall(Value *Op, const TargetLibraryInfo *TLI,
                               LibFunc DoubleFn, LibFunc FloatFn,
-                              LibFunc LongDoubleFn, IRBuilder<> &B,
+                              LibFunc LongDoubleFn, IRBuilderBase &B,
                               const AttributeList &Attrs);
 
   /// Emit a call to the binary function named 'Name' (e.g. 'fmin'). This
@@ -162,67 +169,44 @@
   /// value with the same type. If 'Op1/Op2' are long double, 'l' is added as
   /// the suffix of name, if 'Op1/Op2' are float, we add a 'f' suffix.
   Value *emitBinaryFloatFnCall(Value *Op1, Value *Op2, StringRef Name,
-                               IRBuilder<> &B, const AttributeList &Attrs);
+                               IRBuilderBase &B, const AttributeList &Attrs);
+
+  /// Emit a call to the binary function DoubleFn, FloatFn or LongDoubleFn,
+  /// depending of the type of Op1.
+  Value *emitBinaryFloatFnCall(Value *Op1, Value *Op2,
+                               const TargetLibraryInfo *TLI, LibFunc DoubleFn,
+                               LibFunc FloatFn, LibFunc LongDoubleFn,
+                               IRBuilderBase &B, const AttributeList &Attrs);
 
   /// Emit a call to the putchar function. This assumes that Char is an integer.
-  Value *emitPutChar(Value *Char, IRBuilder<> &B, const TargetLibraryInfo *TLI);
+  Value *emitPutChar(Value *Char, IRBuilderBase &B,
+                     const TargetLibraryInfo *TLI);
 
   /// Emit a call to the puts function. This assumes that Str is some pointer.
-  Value *emitPutS(Value *Str, IRBuilder<> &B, const TargetLibraryInfo *TLI);
+  Value *emitPutS(Value *Str, IRBuilderBase &B, const TargetLibraryInfo *TLI);
 
   /// Emit a call to the fputc function. This assumes that Char is an i32, and
   /// File is a pointer to FILE.
-  Value *emitFPutC(Value *Char, Value *File, IRBuilder<> &B,
+  Value *emitFPutC(Value *Char, Value *File, IRBuilderBase &B,
                    const TargetLibraryInfo *TLI);
 
-  /// Emit a call to the fputc_unlocked function. This assumes that Char is an
-  /// i32, and File is a pointer to FILE.
-  Value *emitFPutCUnlocked(Value *Char, Value *File, IRBuilder<> &B,
-                           const TargetLibraryInfo *TLI);
-
   /// Emit a call to the fputs function. Str is required to be a pointer and
   /// File is a pointer to FILE.
-  Value *emitFPutS(Value *Str, Value *File, IRBuilder<> &B,
+  Value *emitFPutS(Value *Str, Value *File, IRBuilderBase &B,
                    const TargetLibraryInfo *TLI);
 
-  /// Emit a call to the fputs_unlocked function. Str is required to be a
-  /// pointer and File is a pointer to FILE.
-  Value *emitFPutSUnlocked(Value *Str, Value *File, IRBuilder<> &B,
-                           const TargetLibraryInfo *TLI);
-
   /// Emit a call to the fwrite function. This assumes that Ptr is a pointer,
   /// Size is an 'intptr_t', and File is a pointer to FILE.
-  Value *emitFWrite(Value *Ptr, Value *Size, Value *File, IRBuilder<> &B,
+  Value *emitFWrite(Value *Ptr, Value *Size, Value *File, IRBuilderBase &B,
                     const DataLayout &DL, const TargetLibraryInfo *TLI);
 
   /// Emit a call to the malloc function.
-  Value *emitMalloc(Value *Num, IRBuilder<> &B, const DataLayout &DL,
+  Value *emitMalloc(Value *Num, IRBuilderBase &B, const DataLayout &DL,
                     const TargetLibraryInfo *TLI);
 
   /// Emit a call to the calloc function.
   Value *emitCalloc(Value *Num, Value *Size, const AttributeList &Attrs,
-                    IRBuilder<> &B, const TargetLibraryInfo &TLI);
-
-  /// Emit a call to the fwrite_unlocked function. This assumes that Ptr is a
-  /// pointer, Size is an 'intptr_t', N is nmemb and File is a pointer to FILE.
-  Value *emitFWriteUnlocked(Value *Ptr, Value *Size, Value *N, Value *File,
-                            IRBuilder<> &B, const DataLayout &DL,
-                            const TargetLibraryInfo *TLI);
-
-  /// Emit a call to the fgetc_unlocked function. File is a pointer to FILE.
-  Value *emitFGetCUnlocked(Value *File, IRBuilder<> &B,
-                           const TargetLibraryInfo *TLI);
-
-  /// Emit a call to the fgets_unlocked function. Str is required to be a
-  /// pointer, Size is an i32 and File is a pointer to FILE.
-  Value *emitFGetSUnlocked(Value *Str, Value *Size, Value *File, IRBuilder<> &B,
-                           const TargetLibraryInfo *TLI);
-
-  /// Emit a call to the fread_unlocked function. This assumes that Ptr is a
-  /// pointer, Size is an 'intptr_t', N is nmemb and File is a pointer to FILE.
-  Value *emitFReadUnlocked(Value *Ptr, Value *Size, Value *N, Value *File,
-                           IRBuilder<> &B, const DataLayout &DL,
-                           const TargetLibraryInfo *TLI);
+                    IRBuilderBase &B, const TargetLibraryInfo &TLI);
 }
 
 #endif
diff --git a/linux-x64/clang/include/llvm/Transforms/Utils/BypassSlowDivision.h b/linux-x64/clang/include/llvm/Transforms/Utils/BypassSlowDivision.h
index 4710559..bd98c90 100644
--- a/linux-x64/clang/include/llvm/Transforms/Utils/BypassSlowDivision.h
+++ b/linux-x64/clang/include/llvm/Transforms/Utils/BypassSlowDivision.h
@@ -19,6 +19,7 @@
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseMapInfo.h"
+#include "llvm/IR/ValueHandle.h"
 #include <cstdint>
 
 namespace llvm {
@@ -28,8 +29,10 @@
 
 struct DivRemMapKey {
   bool SignedOp;
-  Value *Dividend;
-  Value *Divisor;
+  AssertingVH<Value> Dividend;
+  AssertingVH<Value> Divisor;
+
+  DivRemMapKey() = default;
 
   DivRemMapKey(bool InSignedOp, Value *InDividend, Value *InDivisor)
       : SignedOp(InSignedOp), Dividend(InDividend), Divisor(InDivisor) {}
@@ -50,8 +53,10 @@
   }
 
   static unsigned getHashValue(const DivRemMapKey &Val) {
-    return (unsigned)(reinterpret_cast<uintptr_t>(Val.Dividend) ^
-                      reinterpret_cast<uintptr_t>(Val.Divisor)) ^
+    return (unsigned)(reinterpret_cast<uintptr_t>(
+                          static_cast<Value *>(Val.Dividend)) ^
+                      reinterpret_cast<uintptr_t>(
+                          static_cast<Value *>(Val.Divisor))) ^
            (unsigned)Val.SignedOp;
   }
 };
diff --git a/linux-x64/clang/include/llvm/Transforms/Utils/CallGraphUpdater.h b/linux-x64/clang/include/llvm/Transforms/Utils/CallGraphUpdater.h
new file mode 100644
index 0000000..f8211d6
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Transforms/Utils/CallGraphUpdater.h
@@ -0,0 +1,109 @@
+//===- CallGraphUpdater.h - A (lazy) call graph update helper ---*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+/// \file
+///
+/// This file provides interfaces used to manipulate a call graph, regardless
+/// if it is a "old style" CallGraph or an "new style" LazyCallGraph.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_UTILS_CALLGRAPHUPDATER_H
+#define LLVM_TRANSFORMS_UTILS_CALLGRAPHUPDATER_H
+
+#include "llvm/Analysis/CGSCCPassManager.h"
+#include "llvm/Analysis/CallGraph.h"
+#include "llvm/Analysis/CallGraphSCCPass.h"
+#include "llvm/Analysis/LazyCallGraph.h"
+
+namespace llvm {
+
+/// Wrapper to unify "old style" CallGraph and "new style" LazyCallGraph. This
+/// simplifies the interface and the call sites, e.g., new and old pass manager
+/// passes can share the same code.
+class CallGraphUpdater {
+  /// Containers for functions which we did replace or want to delete when
+  /// `finalize` is called. This can happen explicitly or as part of the
+  /// destructor. Dead functions in comdat sections are tracked separately
+  /// because a function with discardable linakage in a COMDAT should only
+  /// be dropped if the entire COMDAT is dropped, see git ac07703842cf.
+  ///{
+  SmallPtrSet<Function *, 16> ReplacedFunctions;
+  SmallVector<Function *, 16> DeadFunctions;
+  SmallVector<Function *, 16> DeadFunctionsInComdats;
+  ///}
+
+  /// Old PM variables
+  ///{
+  CallGraph *CG = nullptr;
+  CallGraphSCC *CGSCC = nullptr;
+  ///}
+
+  /// New PM variables
+  ///{
+  LazyCallGraph *LCG = nullptr;
+  LazyCallGraph::SCC *SCC = nullptr;
+  CGSCCAnalysisManager *AM = nullptr;
+  CGSCCUpdateResult *UR = nullptr;
+  FunctionAnalysisManager *FAM = nullptr;
+  ///}
+
+public:
+  CallGraphUpdater() {}
+  ~CallGraphUpdater() { finalize(); }
+
+  /// Initializers for usage outside of a CGSCC pass, inside a CGSCC pass in
+  /// the old and new pass manager (PM).
+  ///{
+  void initialize(CallGraph &CG, CallGraphSCC &SCC) {
+    this->CG = &CG;
+    this->CGSCC = &SCC;
+  }
+  void initialize(LazyCallGraph &LCG, LazyCallGraph::SCC &SCC,
+                  CGSCCAnalysisManager &AM, CGSCCUpdateResult &UR) {
+    this->LCG = &LCG;
+    this->SCC = &SCC;
+    this->AM = &AM;
+    this->UR = &UR;
+    FAM =
+        &AM.getResult<FunctionAnalysisManagerCGSCCProxy>(SCC, LCG).getManager();
+  }
+  ///}
+
+  /// Finalizer that will trigger actions like function removal from the CG.
+  bool finalize();
+
+  /// Remove \p Fn from the call graph.
+  void removeFunction(Function &Fn);
+
+  /// After an CGSCC pass changes a function in ways that affect the call
+  /// graph, this method can be called to update it.
+  void reanalyzeFunction(Function &Fn);
+
+  /// If a new function was created by outlining, this method can be called
+  /// to update the call graph for the new function. Note that the old one
+  /// still needs to be re-analyzed or manually updated.
+  void registerOutlinedFunction(Function &OriginalFn, Function &NewFn);
+
+  /// Replace \p OldFn in the call graph (and SCC) with \p NewFn. The uses
+  /// outside the call graph and the function \p OldFn are not modified.
+  /// Note that \p OldFn is also removed from the call graph
+  /// (\see removeFunction).
+  void replaceFunctionWith(Function &OldFn, Function &NewFn);
+
+  /// Remove the call site \p CS from the call graph.
+  void removeCallSite(CallBase &CS);
+
+  /// Replace \p OldCS with the new call site \p NewCS.
+  /// \return True if the replacement was successful, otherwise False. In the
+  /// latter case the parent function of \p OldCB needs to be re-analyzed.
+  bool replaceCallSite(CallBase &OldCS, CallBase &NewCS);
+};
+
+} // end namespace llvm
+
+#endif // LLVM_TRANSFORMS_UTILS_CALLGRAPHUPDATER_H
diff --git a/linux-x64/clang/include/llvm/Transforms/Utils/CallPromotionUtils.h b/linux-x64/clang/include/llvm/Transforms/Utils/CallPromotionUtils.h
index d9d171c..daa8898 100644
--- a/linux-x64/clang/include/llvm/Transforms/Utils/CallPromotionUtils.h
+++ b/linux-x64/clang/include/llvm/Transforms/Utils/CallPromotionUtils.h
@@ -14,9 +14,11 @@
 #ifndef LLVM_TRANSFORMS_UTILS_CALLPROMOTIONUTILS_H
 #define LLVM_TRANSFORMS_UTILS_CALLPROMOTIONUTILS_H
 
-#include "llvm/IR/CallSite.h"
-
 namespace llvm {
+class CallBase;
+class CastInst;
+class Function;
+class MDNode;
 
 /// Return true if the given indirect call site can be made to call \p Callee.
 ///
@@ -25,7 +27,7 @@
 /// match exactly, they must at least be bitcast compatible. If \p FailureReason
 /// is non-null and the indirect call cannot be promoted, the failure reason
 /// will be stored in it.
-bool isLegalToPromote(CallSite CS, Function *Callee,
+bool isLegalToPromote(const CallBase &CB, Function *Callee,
                       const char **FailureReason = nullptr);
 
 /// Promote the given indirect call site to unconditionally call \p Callee.
@@ -35,8 +37,8 @@
 /// of the callee, bitcast instructions are inserted where appropriate. If \p
 /// RetBitCast is non-null, it will be used to store the return value bitcast,
 /// if created.
-Instruction *promoteCall(CallSite CS, Function *Callee,
-                         CastInst **RetBitCast = nullptr);
+CallBase &promoteCall(CallBase &CB, Function *Callee,
+                      CastInst **RetBitCast = nullptr);
 
 /// Promote the given indirect call site to conditionally call \p Callee.
 ///
@@ -45,8 +47,31 @@
 /// indirect call site is promoted, placed in the "then" block, and returned. If
 /// \p BranchWeights is non-null, it will be used to set !prof metadata on the
 /// new conditional branch.
-Instruction *promoteCallWithIfThenElse(CallSite CS, Function *Callee,
-                                       MDNode *BranchWeights = nullptr);
+CallBase &promoteCallWithIfThenElse(CallBase &CB, Function *Callee,
+                                    MDNode *BranchWeights = nullptr);
+
+/// Try to promote (devirtualize) a virtual call on an Alloca. Return true on
+/// success.
+///
+/// Look for a pattern like:
+///
+///  %o = alloca %class.Impl
+///  %1 = getelementptr %class.Impl, %class.Impl* %o, i64 0, i32 0, i32 0
+///  store i32 (...)** bitcast (i8** getelementptr inbounds
+///      ({ [3 x i8*] }, { [3 x i8*] }* @_ZTV4Impl, i64 0, inrange i32 0, i64 2)
+///      to i32 (...)**), i32 (...)*** %1
+///  %2 = getelementptr inbounds %class.Impl, %class.Impl* %o, i64 0, i32 0
+///  %3 = bitcast %class.Interface* %2 to void (%class.Interface*)***
+///  %vtable.i = load void (%class.Interface*)**, void (%class.Interface*)*** %3
+///  %4 = load void (%class.Interface*)*, void (%class.Interface*)** %vtable.i
+///  call void %4(%class.Interface* nonnull %2)
+///
+/// @_ZTV4Impl = linkonce_odr dso_local unnamed_addr constant { [3 x i8*] }
+///     { [3 x i8*]
+///     [i8* null, i8* bitcast ({ i8*, i8*, i8* }* @_ZTI4Impl to i8*),
+///     i8* bitcast (void (%class.Impl*)* @_ZN4Impl3RunEv to i8*)] }
+///
+bool tryPromoteCall(CallBase &CB);
 
 } // end namespace llvm
 
diff --git a/linux-x64/clang/include/llvm/Transforms/Utils/CanonicalizeFreezeInLoops.h b/linux-x64/clang/include/llvm/Transforms/Utils/CanonicalizeFreezeInLoops.h
new file mode 100644
index 0000000..3481a09
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Transforms/Utils/CanonicalizeFreezeInLoops.h
@@ -0,0 +1,33 @@
+//==- CanonicalizeFreezeInLoop.h - Canonicalize freezes in a loop-*- C++ -*-==//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file canonicalizes freeze instructions in a loop.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_UTILS_CANONICALIZE_FREEZES_IN_LOOPS_H
+#define LLVM_TRANSFORMS_UTILS_CANONICALIZE_FREEZES_IN_LOOPS_H
+
+#include "llvm/Analysis/LoopAnalysisManager.h"
+#include "llvm/Analysis/LoopInfo.h"
+#include "llvm/IR/PassManager.h"
+
+namespace llvm {
+class LPMUpdater;
+
+/// A pass that canonicalizes freeze instructions in a loop.
+class CanonicalizeFreezeInLoopsPass
+    : public PassInfoMixin<CanonicalizeFreezeInLoopsPass> {
+public:
+  PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
+                        LoopStandardAnalysisResults &AR, LPMUpdater &U);
+};
+
+} // end namespace llvm
+
+#endif // LLVM_TRANSFORMS_UTILS_CANONICALIZE_FREEZES_IN_LOOPS_H
diff --git a/linux-x64/clang/include/llvm/Transforms/Utils/Cloning.h b/linux-x64/clang/include/llvm/Transforms/Utils/Cloning.h
index 872ab9c..dffb780 100644
--- a/linux-x64/clang/include/llvm/Transforms/Utils/Cloning.h
+++ b/linux-x64/clang/include/llvm/Transforms/Utils/Cloning.h
@@ -19,10 +19,8 @@
 
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/Twine.h"
-#include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/Analysis/AssumptionCache.h"
 #include "llvm/Analysis/InlineCost.h"
-#include "llvm/IR/CallSite.h"
 #include "llvm/IR/ValueHandle.h"
 #include "llvm/Transforms/Utils/ValueMapper.h"
 #include <functional>
@@ -31,6 +29,7 @@
 
 namespace llvm {
 
+class AAResults;
 class AllocaInst;
 class BasicBlock;
 class BlockFrequencyInfo;
@@ -172,19 +171,19 @@
 /// the auxiliary results produced by it.
 class InlineFunctionInfo {
 public:
-  explicit InlineFunctionInfo(CallGraph *cg = nullptr,
-                              std::function<AssumptionCache &(Function &)>
-                                  *GetAssumptionCache = nullptr,
-                              ProfileSummaryInfo *PSI = nullptr,
-                              BlockFrequencyInfo *CallerBFI = nullptr,
-                              BlockFrequencyInfo *CalleeBFI = nullptr)
+  explicit InlineFunctionInfo(
+      CallGraph *cg = nullptr,
+      function_ref<AssumptionCache &(Function &)> GetAssumptionCache = nullptr,
+      ProfileSummaryInfo *PSI = nullptr,
+      BlockFrequencyInfo *CallerBFI = nullptr,
+      BlockFrequencyInfo *CalleeBFI = nullptr)
       : CG(cg), GetAssumptionCache(GetAssumptionCache), PSI(PSI),
         CallerBFI(CallerBFI), CalleeBFI(CalleeBFI) {}
 
   /// If non-null, InlineFunction will update the callgraph to reflect the
   /// changes it makes.
   CallGraph *CG;
-  std::function<AssumptionCache &(Function &)> *GetAssumptionCache;
+  function_ref<AssumptionCache &(Function &)> GetAssumptionCache;
   ProfileSummaryInfo *PSI;
   BlockFrequencyInfo *CallerBFI, *CalleeBFI;
 
@@ -201,7 +200,7 @@
   /// 'InlineFunction' fills this in by scanning the inlined instructions, and
   /// only if CG is null. If CG is non-null, instead the value handle
   /// `InlinedCalls` above is used.
-  SmallVector<CallSite, 8> InlinedCallSites;
+  SmallVector<CallBase *, 8> InlinedCallSites;
 
   void reset() {
     StaticAllocas.clear();
@@ -229,10 +228,7 @@
 /// and all varargs at the callsite will be passed to any calls to
 /// ForwardVarArgsTo. The caller of InlineFunction has to make sure any varargs
 /// are only used by ForwardVarArgsTo.
-InlineResult InlineFunction(CallBase *CB, InlineFunctionInfo &IFI,
-                            AAResults *CalleeAAR = nullptr,
-                            bool InsertLifetime = true);
-InlineResult InlineFunction(CallSite CS, InlineFunctionInfo &IFI,
+InlineResult InlineFunction(CallBase &CB, InlineFunctionInfo &IFI,
                             AAResults *CalleeAAR = nullptr,
                             bool InsertLifetime = true,
                             Function *ForwardVarArgsTo = nullptr);
diff --git a/linux-x64/clang/include/llvm/Transforms/Utils/CodeExtractor.h b/linux-x64/clang/include/llvm/Transforms/Utils/CodeExtractor.h
index becbf0e..1d9f2d1 100644
--- a/linux-x64/clang/include/llvm/Transforms/Utils/CodeExtractor.h
+++ b/linux-x64/clang/include/llvm/Transforms/Utils/CodeExtractor.h
@@ -22,6 +22,7 @@
 
 namespace llvm {
 
+class AllocaInst;
 class BasicBlock;
 class BlockFrequency;
 class BlockFrequencyInfo;
@@ -36,6 +37,38 @@
 class Type;
 class Value;
 
+/// A cache for the CodeExtractor analysis. The operation \ref
+/// CodeExtractor::extractCodeRegion is guaranteed not to invalidate this
+/// object. This object should conservatively be considered invalid if any
+/// other mutating operations on the IR occur.
+///
+/// Constructing this object is O(n) in the size of the function.
+class CodeExtractorAnalysisCache {
+  /// The allocas in the function.
+  SmallVector<AllocaInst *, 16> Allocas;
+
+  /// Base memory addresses of load/store instructions, grouped by block.
+  DenseMap<BasicBlock *, DenseSet<Value *>> BaseMemAddrs;
+
+  /// Blocks which contain instructions which may have unknown side-effects
+  /// on memory.
+  DenseSet<BasicBlock *> SideEffectingBlocks;
+
+  void findSideEffectInfoForBlock(BasicBlock &BB);
+
+public:
+  CodeExtractorAnalysisCache(Function &F);
+
+  /// Get the allocas in the function at the time the analysis was created.
+  /// Note that some of these allocas may no longer be present in the function,
+  /// due to \ref CodeExtractor::extractCodeRegion.
+  ArrayRef<AllocaInst *> getAllocas() const { return Allocas; }
+
+  /// Check whether \p BB contains an instruction thought to load from, store
+  /// to, or otherwise clobber the alloca \p Addr.
+  bool doesBlockContainClobberOfAddr(BasicBlock &BB, AllocaInst *Addr) const;
+};
+
   /// Utility class for extracting code into a new function.
   ///
   /// This utility provides a simple interface for extracting some sequence of
@@ -104,13 +137,23 @@
     ///
     /// Returns zero when called on a CodeExtractor instance where isEligible
     /// returns false.
-    Function *extractCodeRegion();
+    Function *extractCodeRegion(const CodeExtractorAnalysisCache &CEAC);
+
+    /// Verify that assumption cache isn't stale after a region is extracted.
+    /// Returns true when verifier finds errors. AssumptionCache is passed as
+    /// parameter to make this function stateless.
+    static bool verifyAssumptionCache(const Function &OldFunc,
+                                      const Function &NewFunc,
+                                      AssumptionCache *AC);
 
     /// Test whether this code extractor is eligible.
     ///
     /// Based on the blocks used when constructing the code extractor,
     /// determine whether it is eligible for extraction.
-    bool isEligible() const { return !Blocks.empty(); }
+    /// 
+    /// Checks that varargs handling (with vastart and vaend) is only done in
+    /// the outlined blocks.
+    bool isEligible() const;
 
     /// Compute the set of input values and output values for the code.
     ///
@@ -127,7 +170,9 @@
     /// region.
     ///
     /// Returns true if it is safe to do the code motion.
-    bool isLegalToShrinkwrapLifetimeMarkers(Instruction *AllocaAddr) const;
+    bool
+    isLegalToShrinkwrapLifetimeMarkers(const CodeExtractorAnalysisCache &CEAC,
+                                       Instruction *AllocaAddr) const;
 
     /// Find the set of allocas whose life ranges are contained within the
     /// outlined region.
@@ -137,7 +182,8 @@
     /// are used by the lifetime markers are also candidates for shrink-
     /// wrapping. The instructions that need to be sunk are collected in
     /// 'Allocas'.
-    void findAllocas(ValueSet &SinkCands, ValueSet &HoistCands,
+    void findAllocas(const CodeExtractorAnalysisCache &CEAC,
+                     ValueSet &SinkCands, ValueSet &HoistCands,
                      BasicBlock *&ExitBlock) const;
 
     /// Find or create a block within the outline region for placing hoisted
@@ -151,6 +197,17 @@
     BasicBlock *findOrCreateBlockForHoisting(BasicBlock *CommonExitBlock);
 
   private:
+    struct LifetimeMarkerInfo {
+      bool SinkLifeStart = false;
+      bool HoistLifeEnd = false;
+      Instruction *LifeStart = nullptr;
+      Instruction *LifeEnd = nullptr;
+    };
+
+    LifetimeMarkerInfo
+    getLifetimeMarkers(const CodeExtractorAnalysisCache &CEAC,
+                       Instruction *Addr, BasicBlock *ExitBlock) const;
+
     void severSplitPHINodesOfEntry(BasicBlock *&Header);
     void severSplitPHINodesOfExits(const SmallPtrSetImpl<BasicBlock *> &Exits);
     void splitReturnBlocks();
diff --git a/linux-x64/clang/include/llvm/Transforms/Utils/CodeMoverUtils.h b/linux-x64/clang/include/llvm/Transforms/Utils/CodeMoverUtils.h
new file mode 100644
index 0000000..630f936
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Transforms/Utils/CodeMoverUtils.h
@@ -0,0 +1,67 @@
+//===- Transform/Utils/CodeMoverUtils.h - CodeMover Utils -------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This family of functions determine movements are safe on basic blocks, and
+// instructions contained within a function.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_UTILS_CODEMOVERUTILS_H
+#define LLVM_TRANSFORMS_UTILS_CODEMOVERUTILS_H
+
+namespace llvm {
+
+class BasicBlock;
+class DependenceInfo;
+class DominatorTree;
+class Instruction;
+class PostDominatorTree;
+
+/// Return true if \p I0 and \p I1 are control flow equivalent.
+/// Two instructions are control flow equivalent if their basic blocks are
+/// control flow equivalent.
+bool isControlFlowEquivalent(const Instruction &I0, const Instruction &I1,
+                             const DominatorTree &DT,
+                             const PostDominatorTree &PDT);
+
+/// Return true if \p BB0 and \p BB1 are control flow equivalent.
+/// Two basic blocks are control flow equivalent if when one executes, the other
+/// is guaranteed to execute.
+bool isControlFlowEquivalent(const BasicBlock &BB0, const BasicBlock &BB1,
+                             const DominatorTree &DT,
+                             const PostDominatorTree &PDT);
+
+/// Return true if \p I can be safely moved before \p InsertPoint.
+bool isSafeToMoveBefore(Instruction &I, Instruction &InsertPoint,
+                        DominatorTree &DT,
+                        const PostDominatorTree *PDT = nullptr,
+                        DependenceInfo *DI = nullptr);
+
+/// Return true if all instructions (except the terminator) in \p BB can be
+/// safely moved before \p InsertPoint.
+bool isSafeToMoveBefore(BasicBlock &BB, Instruction &InsertPoint,
+                        DominatorTree &DT,
+                        const PostDominatorTree *PDT = nullptr,
+                        DependenceInfo *DI = nullptr);
+
+/// Move instructions, in an order-preserving manner, from \p FromBB to the
+/// beginning of \p ToBB when proven safe.
+void moveInstructionsToTheBeginning(BasicBlock &FromBB, BasicBlock &ToBB,
+                                    DominatorTree &DT,
+                                    const PostDominatorTree &PDT,
+                                    DependenceInfo &DI);
+
+/// Move instructions, in an order-preserving manner, from \p FromBB to the end
+/// of \p ToBB when proven safe.
+void moveInstructionsToTheEnd(BasicBlock &FromBB, BasicBlock &ToBB,
+                              DominatorTree &DT, const PostDominatorTree &PDT,
+                              DependenceInfo &DI);
+
+} // end namespace llvm
+
+#endif // LLVM_TRANSFORMS_UTILS_CODEMOVERUTILS_H
diff --git a/linux-x64/clang/include/llvm/Transforms/Utils/Debugify.h b/linux-x64/clang/include/llvm/Transforms/Utils/Debugify.h
new file mode 100644
index 0000000..30e7d8e
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Transforms/Utils/Debugify.h
@@ -0,0 +1,151 @@
+//===- Debugify.h - Attach synthetic debug info to everything -------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file Interface to the `debugify` synthetic debug info testing utility.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORM_UTILS_DEBUGIFY_H
+#define LLVM_TRANSFORM_UTILS_DEBUGIFY_H
+
+#include "llvm/ADT/MapVector.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Bitcode/BitcodeWriterPass.h"
+#include "llvm/IR/IRPrintingPasses.h"
+#include "llvm/IR/LegacyPassManager.h"
+#include "llvm/IR/PassManager.h"
+
+namespace llvm {
+class DIBuilder;
+
+/// Add synthesized debug information to a module.
+///
+/// \param M The module to add debug information to.
+/// \param Functions A range of functions to add debug information to.
+/// \param Banner A prefix string to add to debug/error messages.
+/// \param ApplyToMF A call back that will add debug information to the
+///                  MachineFunction for a Function. If nullptr, then the
+///                  MachineFunction (if any) will not be modified.
+bool applyDebugifyMetadata(
+    Module &M, iterator_range<Module::iterator> Functions, StringRef Banner,
+    std::function<bool(DIBuilder &, Function &)> ApplyToMF);
+
+/// Strip out all of the metadata and debug info inserted by debugify. If no
+/// llvm.debugify module-level named metadata is present, this is a no-op.
+/// Returns true if any change was made.
+bool stripDebugifyMetadata(Module &M);
+
+llvm::ModulePass *createDebugifyModulePass();
+llvm::FunctionPass *createDebugifyFunctionPass();
+
+struct NewPMDebugifyPass : public llvm::PassInfoMixin<NewPMDebugifyPass> {
+  llvm::PreservedAnalyses run(llvm::Module &M, llvm::ModuleAnalysisManager &AM);
+};
+
+/// Track how much `debugify` information has been lost.
+struct DebugifyStatistics {
+  /// Number of missing dbg.values.
+  unsigned NumDbgValuesMissing = 0;
+
+  /// Number of dbg.values expected.
+  unsigned NumDbgValuesExpected = 0;
+
+  /// Number of instructions with empty debug locations.
+  unsigned NumDbgLocsMissing = 0;
+
+  /// Number of instructions expected to have debug locations.
+  unsigned NumDbgLocsExpected = 0;
+
+  /// Get the ratio of missing/expected dbg.values.
+  float getMissingValueRatio() const {
+    return float(NumDbgValuesMissing) / float(NumDbgLocsExpected);
+  }
+
+  /// Get the ratio of missing/expected instructions with locations.
+  float getEmptyLocationRatio() const {
+    return float(NumDbgLocsMissing) / float(NumDbgLocsExpected);
+  }
+};
+
+/// Map pass names to a per-pass DebugifyStatistics instance.
+using DebugifyStatsMap = llvm::MapVector<llvm::StringRef, DebugifyStatistics>;
+
+void exportDebugifyStats(StringRef Path, const DebugifyStatsMap &Map);
+
+llvm::ModulePass *
+createCheckDebugifyModulePass(bool Strip = false,
+                              llvm::StringRef NameOfWrappedPass = "",
+                              DebugifyStatsMap *StatsMap = nullptr);
+
+llvm::FunctionPass *
+createCheckDebugifyFunctionPass(bool Strip = false,
+                                llvm::StringRef NameOfWrappedPass = "",
+                                DebugifyStatsMap *StatsMap = nullptr);
+
+struct NewPMCheckDebugifyPass
+    : public llvm::PassInfoMixin<NewPMCheckDebugifyPass> {
+  llvm::PreservedAnalyses run(llvm::Module &M, llvm::ModuleAnalysisManager &AM);
+};
+
+struct DebugifyEachInstrumentation {
+  DebugifyStatsMap StatsMap;
+
+  void registerCallbacks(PassInstrumentationCallbacks &PIC);
+};
+
+/// DebugifyCustomPassManager wraps each pass with the debugify passes if
+/// needed.
+/// NOTE: We support legacy custom pass manager only.
+/// TODO: Add New PM support for custom pass manager.
+class DebugifyCustomPassManager : public legacy::PassManager {
+  DebugifyStatsMap DIStatsMap;
+  bool EnableDebugifyEach = false;
+
+public:
+  using super = legacy::PassManager;
+
+  void add(Pass *P) override {
+    // Wrap each pass with (-check)-debugify passes if requested, making
+    // exceptions for passes which shouldn't see -debugify instrumentation.
+    bool WrapWithDebugify = EnableDebugifyEach && !P->getAsImmutablePass() &&
+                            !isIRPrintingPass(P) && !isBitcodeWriterPass(P);
+    if (!WrapWithDebugify) {
+      super::add(P);
+      return;
+    }
+
+    // Apply -debugify/-check-debugify before/after each pass and collect
+    // debug info loss statistics.
+    PassKind Kind = P->getPassKind();
+    StringRef Name = P->getPassName();
+
+    // TODO: Implement Debugify for LoopPass.
+    switch (Kind) {
+    case PT_Function:
+      super::add(createDebugifyFunctionPass());
+      super::add(P);
+      super::add(createCheckDebugifyFunctionPass(true, Name, &DIStatsMap));
+      break;
+    case PT_Module:
+      super::add(createDebugifyModulePass());
+      super::add(P);
+      super::add(createCheckDebugifyModulePass(true, Name, &DIStatsMap));
+      break;
+    default:
+      super::add(P);
+      break;
+    }
+  }
+
+  void enableDebugifyEach() { EnableDebugifyEach = true; }
+
+  const DebugifyStatsMap &getDebugifyStatsMap() const { return DIStatsMap; }
+};
+} // namespace llvm
+
+#endif // LLVM_TRANSFORM_UTILS_DEBUGIFY_H
diff --git a/linux-x64/clang/include/llvm/Transforms/Utils/Evaluator.h b/linux-x64/clang/include/llvm/Transforms/Utils/Evaluator.h
index bffd65f..31034d9 100644
--- a/linux-x64/clang/include/llvm/Transforms/Utils/Evaluator.h
+++ b/linux-x64/clang/include/llvm/Transforms/Utils/Evaluator.h
@@ -17,8 +17,8 @@
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/IR/BasicBlock.h"
-#include "llvm/IR/CallSite.h"
 #include "llvm/IR/GlobalVariable.h"
+#include "llvm/IR/Instructions.h"
 #include "llvm/IR/Value.h"
 #include "llvm/Support/Casting.h"
 #include <cassert>
@@ -73,15 +73,6 @@
     ValueStack.back()[V] = C;
   }
 
-  /// Given call site return callee and list of its formal arguments
-  Function *getCalleeWithFormalArgs(CallSite &CS,
-                                    SmallVector<Constant *, 8> &Formals);
-
-  /// Given call site and callee returns list of callee formal argument
-  /// values converting them when necessary
-  bool getFormalParams(CallSite &CS, Function *F,
-                       SmallVector<Constant *, 8> &Formals);
-
   /// Casts call result to a type of bitcast call expression
   Constant *castCallResultIfNeeded(Value *CallExpr, Constant *RV);
 
@@ -94,6 +85,15 @@
   }
 
 private:
+  /// Given call site return callee and list of its formal arguments
+  Function *getCalleeWithFormalArgs(CallBase &CB,
+                                    SmallVectorImpl<Constant *> &Formals);
+
+  /// Given call site and callee returns list of callee formal argument
+  /// values converting them when necessary
+  bool getFormalParams(CallBase &CB, Function *F,
+                       SmallVectorImpl<Constant *> &Formals);
+
   Constant *ComputeLoadResult(Constant *P);
 
   /// As we compute SSA register values, we store their contents here. The back
diff --git a/linux-x64/clang/include/llvm/Transforms/Utils/FixIrreducible.h b/linux-x64/clang/include/llvm/Transforms/Utils/FixIrreducible.h
new file mode 100644
index 0000000..0c00b7b
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Transforms/Utils/FixIrreducible.h
@@ -0,0 +1,20 @@
+//===- FixIrreducible.h - Convert irreducible control-flow into loops -----===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_UTILS_FIXIRREDUCIBLE_H
+#define LLVM_TRANSFORMS_UTILS_FIXIRREDUCIBLE_H
+
+#include "llvm/IR/PassManager.h"
+
+namespace llvm {
+struct FixIrreduciblePass : PassInfoMixin<FixIrreduciblePass> {
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+};
+} // namespace llvm
+
+#endif // LLVM_TRANSFORMS_UTILS_FIXIRREDUCIBLE_H
diff --git a/linux-x64/clang/include/llvm/Transforms/Utils/FunctionComparator.h b/linux-x64/clang/include/llvm/Transforms/Utils/FunctionComparator.h
index 4e2571b..e808a50 100644
--- a/linux-x64/clang/include/llvm/Transforms/Utils/FunctionComparator.h
+++ b/linux-x64/clang/include/llvm/Transforms/Utils/FunctionComparator.h
@@ -332,7 +332,7 @@
   int cmpInlineAsm(const InlineAsm *L, const InlineAsm *R) const;
   int cmpAttrs(const AttributeList L, const AttributeList R) const;
   int cmpRangeMetadata(const MDNode *L, const MDNode *R) const;
-  int cmpOperandBundlesSchema(const Instruction *L, const Instruction *R) const;
+  int cmpOperandBundlesSchema(const CallBase &LCS, const CallBase &RCS) const;
 
   /// Compare two GEPs for equivalent pointer arithmetic.
   /// Parts to be compared for each comparison stage,
diff --git a/linux-x64/clang/include/llvm/Transforms/Utils/FunctionImportUtils.h b/linux-x64/clang/include/llvm/Transforms/Utils/FunctionImportUtils.h
index 9c2a9ea..acdd8ff 100644
--- a/linux-x64/clang/include/llvm/Transforms/Utils/FunctionImportUtils.h
+++ b/linux-x64/clang/include/llvm/Transforms/Utils/FunctionImportUtils.h
@@ -39,6 +39,19 @@
   /// as part of a different backend compilation process.
   bool HasExportedFunctions = false;
 
+  /// Set to true (only applicatable to ELF -fpic) if dso_local should be
+  /// dropped for a declaration.
+  ///
+  /// On ELF, the assembler is conservative and assumes a global default
+  /// visibility symbol can be interposable. No direct access relocation is
+  /// allowed, if the definition is not in the translation unit, even if the
+  /// definition is available in the linkage unit. Thus we need to clear
+  /// dso_local to disable direct access.
+  ///
+  /// This flag should not be set for -fno-pic or -fpie, which would
+  /// unnecessarily disable direct access.
+  bool ClearDSOLocalOnDeclarations;
+
   /// Set of llvm.*used values, in order to validate that we don't try
   /// to promote any non-renamable values.
   SmallPtrSet<GlobalValue *, 8> Used;
@@ -49,7 +62,7 @@
   DenseMap<const Comdat *, Comdat *> RenamedComdats;
 
   /// Check if we should promote the given local value to global scope.
-  bool shouldPromoteLocalToGlobal(const GlobalValue *SGV);
+  bool shouldPromoteLocalToGlobal(const GlobalValue *SGV, ValueInfo VI);
 
 #ifndef NDEBUG
   /// Check if the given value is a local that can't be renamed (promoted).
@@ -67,11 +80,9 @@
   /// import SGV as a definition, otherwise import as a declaration.
   bool doImportAsDefinition(const GlobalValue *SGV);
 
-  /// Get the name for SGV that should be used in the linked destination
-  /// module. Specifically, this handles the case where we need to rename
-  /// a local that is being promoted to global scope, which it will always
-  /// do when \p DoPromote is true (or when importing a local).
-  std::string getName(const GlobalValue *SGV, bool DoPromote);
+  /// Get the name for a local SGV that should be promoted and renamed to global
+  /// scope in the linked destination module.
+  std::string getPromotedName(const GlobalValue *SGV);
 
   /// Process globals so that they can be used in ThinLTO. This includes
   /// promoting local variables so that they can be reference externally by
@@ -87,10 +98,11 @@
   GlobalValue::LinkageTypes getLinkage(const GlobalValue *SGV, bool DoPromote);
 
 public:
-  FunctionImportGlobalProcessing(
-      Module &M, const ModuleSummaryIndex &Index,
-      SetVector<GlobalValue *> *GlobalsToImport = nullptr)
-      : M(M), ImportIndex(Index), GlobalsToImport(GlobalsToImport) {
+  FunctionImportGlobalProcessing(Module &M, const ModuleSummaryIndex &Index,
+                                 SetVector<GlobalValue *> *GlobalsToImport,
+                                 bool ClearDSOLocalOnDeclarations)
+      : M(M), ImportIndex(Index), GlobalsToImport(GlobalsToImport),
+        ClearDSOLocalOnDeclarations(ClearDSOLocalOnDeclarations) {
     // If we have a ModuleSummaryIndex but no function to import,
     // then this is the primary module being compiled in a ThinLTO
     // backend compilation, and we need to see if it has functions that
@@ -107,15 +119,13 @@
   }
 
   bool run();
-
-  static bool doImportAsDefinition(const GlobalValue *SGV,
-                                   SetVector<GlobalValue *> *GlobalsToImport);
 };
 
 /// Perform in-place global value handling on the given Module for
 /// exported local functions renamed and promoted for ThinLTO.
 bool renameModuleForThinLTO(
     Module &M, const ModuleSummaryIndex &Index,
+    bool ClearDSOLocalOnDeclarations,
     SetVector<GlobalValue *> *GlobalsToImport = nullptr);
 
 /// Compute synthetic function entry counts.
diff --git a/linux-x64/clang/include/llvm/Transforms/Utils/GuardUtils.h b/linux-x64/clang/include/llvm/Transforms/Utils/GuardUtils.h
index 3b365c5..7ab5d9e 100644
--- a/linux-x64/clang/include/llvm/Transforms/Utils/GuardUtils.h
+++ b/linux-x64/clang/include/llvm/Transforms/Utils/GuardUtils.h
@@ -14,15 +14,30 @@
 
 namespace llvm {
 
+class BranchInst;
 class CallInst;
 class Function;
+class Value;
 
 /// Splits control flow at point of \p Guard, replacing it with explicit branch
 /// by the condition of guard's first argument. The taken branch then goes to
 /// the block that contains  \p Guard's successors, and the non-taken branch
 /// goes to a newly-created deopt block that contains a sole call of the
-/// deoptimize function \p DeoptIntrinsic.
-void makeGuardControlFlowExplicit(Function *DeoptIntrinsic, CallInst *Guard);
+/// deoptimize function \p DeoptIntrinsic.  If 'UseWC' is set, preserve the
+/// widenable nature of the guard by lowering to equivelent form.  If not set,
+/// lower to a form without widenable semantics.
+void makeGuardControlFlowExplicit(Function *DeoptIntrinsic, CallInst *Guard,
+                                  bool UseWC);
+
+/// Given a branch we know is widenable (defined per Analysis/GuardUtils.h),
+/// widen it such that condition 'NewCond' is also known to hold on the taken
+/// path.  Branch remains widenable after transform.
+void widenWidenableBranch(BranchInst *WidenableBR, Value *NewCond);
+
+/// Given a branch we know is widenable (defined per Analysis/GuardUtils.h),
+/// *set* it's condition such that (only) 'Cond' is known to hold on the taken
+/// path and that the branch remains widenable after transform.
+void setWidenableBranchCond(BranchInst *WidenableBR, Value *Cond);
 
 } // llvm
 
diff --git a/linux-x64/clang/include/llvm/Transforms/Utils/InjectTLIMappings.h b/linux-x64/clang/include/llvm/Transforms/Utils/InjectTLIMappings.h
new file mode 100644
index 0000000..84e4fee
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Transforms/Utils/InjectTLIMappings.h
@@ -0,0 +1,37 @@
+//===- InjectTLIMAppings.h - TLI to VFABI attribute injection  ------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Populates the VFABI attribute with the scalar-to-vector mappings
+// from the TargetLibraryInfo.
+//
+//===----------------------------------------------------------------------===//
+#ifndef LLVM_TRANSFORMS_UTILS_INJECTTLIMAPPINGS_H
+#define LLVM_TRANSFORMS_UTILS_INJECTTLIMAPPINGS_H
+
+#include "llvm/IR/PassManager.h"
+#include "llvm/InitializePasses.h"
+
+namespace llvm {
+class InjectTLIMappings : public PassInfoMixin<InjectTLIMappings> {
+public:
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+};
+
+// Legacy pass
+class InjectTLIMappingsLegacy : public FunctionPass {
+public:
+  static char ID;
+  InjectTLIMappingsLegacy() : FunctionPass(ID) {
+    initializeInjectTLIMappingsLegacyPass(*PassRegistry::getPassRegistry());
+  }
+  void getAnalysisUsage(AnalysisUsage &AU) const override;
+  bool runOnFunction(Function &F) override;
+};
+
+} // End namespace llvm
+#endif // LLVM_TRANSFORMS_UTILS_INJECTTLIMAPPINGS_H
diff --git a/linux-x64/clang/include/llvm/Transforms/Utils/InstructionNamer.h b/linux-x64/clang/include/llvm/Transforms/Utils/InstructionNamer.h
new file mode 100644
index 0000000..4f4cc26
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Transforms/Utils/InstructionNamer.h
@@ -0,0 +1,20 @@
+//===- InstructionNamer.h - Give anonymous instructions names -------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_UTILS_INSTRUCTIONNAMER_H
+#define LLVM_TRANSFORMS_UTILS_INSTRUCTIONNAMER_H
+
+#include "llvm/IR/PassManager.h"
+
+namespace llvm {
+struct InstructionNamerPass : PassInfoMixin<InstructionNamerPass> {
+  PreservedAnalyses run(Function &, FunctionAnalysisManager &);
+};
+} // namespace llvm
+
+#endif // LLVM_TRANSFORMS_UTILS_INSTRUCTIONNAMER_H
diff --git a/linux-x64/clang/include/llvm/Transforms/Utils/Local.h b/linux-x64/clang/include/llvm/Transforms/Utils/Local.h
index ff516f2..ebfb62a 100644
--- a/linux-x64/clang/include/llvm/Transforms/Utils/Local.h
+++ b/linux-x64/clang/include/llvm/Transforms/Utils/Local.h
@@ -19,35 +19,39 @@
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/TinyPtrVector.h"
-#include "llvm/Analysis/AliasAnalysis.h"
-#include "llvm/Analysis/DomTreeUpdater.h"
 #include "llvm/Analysis/Utils/Local.h"
 #include "llvm/IR/Constant.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/Dominators.h"
-#include "llvm/IR/GetElementPtrTypeIterator.h"
 #include "llvm/IR/Operator.h"
 #include "llvm/IR/Type.h"
 #include "llvm/IR/User.h"
 #include "llvm/IR/Value.h"
+#include "llvm/IR/ValueHandle.h"
 #include "llvm/Support/Casting.h"
+#include "llvm/Support/CommandLine.h"
+#include "llvm/Transforms/Utils/SimplifyCFGOptions.h"
 #include <cstdint>
 #include <limits>
 
 namespace llvm {
 
+class AAResults;
 class AllocaInst;
 class AssumptionCache;
 class BasicBlock;
 class BranchInst;
+class CallBase;
 class CallInst;
+class DbgDeclareInst;
 class DbgVariableIntrinsic;
 class DbgValueInst;
 class DIBuilder;
+class DomTreeUpdater;
 class Function;
 class Instruction;
-class LazyValueInfo;
+class InvokeInst;
 class LoadInst;
 class MDNode;
 class MemorySSAUpdater;
@@ -56,57 +60,6 @@
 class TargetLibraryInfo;
 class TargetTransformInfo;
 
-/// A set of parameters used to control the transforms in the SimplifyCFG pass.
-/// Options may change depending on the position in the optimization pipeline.
-/// For example, canonical form that includes switches and branches may later be
-/// replaced by lookup tables and selects.
-struct SimplifyCFGOptions {
-  int BonusInstThreshold;
-  bool ForwardSwitchCondToPhi;
-  bool ConvertSwitchToLookupTable;
-  bool NeedCanonicalLoop;
-  bool SinkCommonInsts;
-  AssumptionCache *AC;
-
-  SimplifyCFGOptions(unsigned BonusThreshold = 1,
-                     bool ForwardSwitchCond = false,
-                     bool SwitchToLookup = false, bool CanonicalLoops = true,
-                     bool SinkCommon = false,
-                     AssumptionCache *AssumpCache = nullptr)
-      : BonusInstThreshold(BonusThreshold),
-        ForwardSwitchCondToPhi(ForwardSwitchCond),
-        ConvertSwitchToLookupTable(SwitchToLookup),
-        NeedCanonicalLoop(CanonicalLoops),
-        SinkCommonInsts(SinkCommon),
-        AC(AssumpCache) {}
-
-  // Support 'builder' pattern to set members by name at construction time.
-  SimplifyCFGOptions &bonusInstThreshold(int I) {
-    BonusInstThreshold = I;
-    return *this;
-  }
-  SimplifyCFGOptions &forwardSwitchCondToPhi(bool B) {
-    ForwardSwitchCondToPhi = B;
-    return *this;
-  }
-  SimplifyCFGOptions &convertSwitchToLookupTable(bool B) {
-    ConvertSwitchToLookupTable = B;
-    return *this;
-  }
-  SimplifyCFGOptions &needCanonicalLoops(bool B) {
-    NeedCanonicalLoop = B;
-    return *this;
-  }
-  SimplifyCFGOptions &sinkCommonInsts(bool B) {
-    SinkCommonInsts = B;
-    return *this;
-  }
-  SimplifyCFGOptions &setAssumptionCache(AssumptionCache *Cache) {
-    AC = Cache;
-    return *this;
-  }
-};
-
 //===----------------------------------------------------------------------===//
 //  Local constant propagation.
 //
@@ -142,7 +95,9 @@
 /// recursively. Return true if any instructions were deleted.
 bool RecursivelyDeleteTriviallyDeadInstructions(
     Value *V, const TargetLibraryInfo *TLI = nullptr,
-    MemorySSAUpdater *MSSAU = nullptr);
+    MemorySSAUpdater *MSSAU = nullptr,
+    std::function<void(Value *)> AboutToDeleteCallback =
+        std::function<void(Value *)>());
 
 /// Delete all of the instructions in `DeadInsts`, and all other instructions
 /// that deleting these in turn causes to be trivially dead.
@@ -153,8 +108,20 @@
 /// `DeadInsts` will be used as scratch storage for this routine and will be
 /// empty afterward.
 void RecursivelyDeleteTriviallyDeadInstructions(
-    SmallVectorImpl<Instruction *> &DeadInsts,
-    const TargetLibraryInfo *TLI = nullptr, MemorySSAUpdater *MSSAU = nullptr);
+    SmallVectorImpl<WeakTrackingVH> &DeadInsts,
+    const TargetLibraryInfo *TLI = nullptr, MemorySSAUpdater *MSSAU = nullptr,
+    std::function<void(Value *)> AboutToDeleteCallback =
+        std::function<void(Value *)>());
+
+/// Same functionality as RecursivelyDeleteTriviallyDeadInstructions, but allow
+/// instructions that are not trivially dead. These will be ignored.
+/// Returns true if any changes were made, i.e. any instructions trivially dead
+/// were found and deleted.
+bool RecursivelyDeleteTriviallyDeadInstructionsPermissive(
+    SmallVectorImpl<WeakTrackingVH> &DeadInsts,
+    const TargetLibraryInfo *TLI = nullptr, MemorySSAUpdater *MSSAU = nullptr,
+    std::function<void(Value *)> AboutToDeleteCallback =
+        std::function<void(Value *)>());
 
 /// If the specified value is an effectively dead PHI node, due to being a
 /// def-use chain of single-use nodes that either forms a cycle or is terminated
@@ -162,7 +129,8 @@
 /// operands trivially dead, delete them too, recursively. Return true if a
 /// change was made.
 bool RecursivelyDeleteDeadPHINode(PHINode *PN,
-                                  const TargetLibraryInfo *TLI = nullptr);
+                                  const TargetLibraryInfo *TLI = nullptr,
+                                  MemorySSAUpdater *MSSAU = nullptr);
 
 /// Scan the specified basic block and try to simplify any instructions in it
 /// and recursively delete dead instructions.
@@ -182,20 +150,6 @@
 //  Control Flow Graph Restructuring.
 //
 
-/// Like BasicBlock::removePredecessor, this method is called when we're about
-/// to delete Pred as a predecessor of BB. If BB contains any PHI nodes, this
-/// drops the entries in the PHI nodes for Pred.
-///
-/// Unlike the removePredecessor method, this attempts to simplify uses of PHI
-/// nodes that collapse into identity values.  For example, if we have:
-///   x = phi(1, 0, 0, 0)
-///   y = and x, z
-///
-/// .. and delete the predecessor corresponding to the '1', this will attempt to
-/// recursively fold the 'and' to 0.
-void RemovePredecessorAndSimplify(BasicBlock *BB, BasicBlock *Pred,
-                                  DomTreeUpdater *DTU = nullptr);
-
 /// BB is a block with one predecessor and its predecessor is known to have one
 /// successor (BB!). Eliminate the edge between them, moving the instructions in
 /// the predecessor into BB. This deletes the predecessor block.
@@ -219,19 +173,23 @@
 /// It returns true if a modification was made, possibly deleting the basic
 /// block that was pointed to. LoopHeaders is an optional input parameter
 /// providing the set of loop headers that SimplifyCFG should not eliminate.
+extern cl::opt<bool> RequireAndPreserveDomTree;
 bool simplifyCFG(BasicBlock *BB, const TargetTransformInfo &TTI,
+                 DomTreeUpdater *DTU = nullptr,
                  const SimplifyCFGOptions &Options = {},
                  SmallPtrSetImpl<BasicBlock *> *LoopHeaders = nullptr);
 
 /// This function is used to flatten a CFG. For example, it uses parallel-and
 /// and parallel-or mode to collapse if-conditions and merge if-regions with
 /// identical statements.
-bool FlattenCFG(BasicBlock *BB, AliasAnalysis *AA = nullptr);
+bool FlattenCFG(BasicBlock *BB, AAResults *AA = nullptr);
 
 /// If this basic block is ONLY a setcc and a branch, and if a predecessor
 /// branches to us and one of our successors, fold the setcc into the
 /// predecessor and use logical operations to pick the right destination.
-bool FoldBranchToCommonDest(BranchInst *BI, MemorySSAUpdater *MSSAU = nullptr,
+bool FoldBranchToCommonDest(BranchInst *BI, llvm::DomTreeUpdater *DTU = nullptr,
+                            MemorySSAUpdater *MSSAU = nullptr,
+                            const TargetTransformInfo *TTI = nullptr,
                             unsigned BonusInstThreshold = 1);
 
 /// This function takes a virtual register computed by an Instruction and
@@ -257,20 +215,29 @@
 /// so if alignment is important, a more reliable approach is to simply align
 /// all global variables and allocation instructions to their preferred
 /// alignment from the beginning.
-unsigned getOrEnforceKnownAlignment(Value *V, unsigned PrefAlign,
-                                    const DataLayout &DL,
-                                    const Instruction *CxtI = nullptr,
-                                    AssumptionCache *AC = nullptr,
-                                    const DominatorTree *DT = nullptr);
+Align getOrEnforceKnownAlignment(Value *V, MaybeAlign PrefAlign,
+                                 const DataLayout &DL,
+                                 const Instruction *CxtI = nullptr,
+                                 AssumptionCache *AC = nullptr,
+                                 const DominatorTree *DT = nullptr);
 
 /// Try to infer an alignment for the specified pointer.
-inline unsigned getKnownAlignment(Value *V, const DataLayout &DL,
-                                  const Instruction *CxtI = nullptr,
-                                  AssumptionCache *AC = nullptr,
-                                  const DominatorTree *DT = nullptr) {
-  return getOrEnforceKnownAlignment(V, 0, DL, CxtI, AC, DT);
+inline Align getKnownAlignment(Value *V, const DataLayout &DL,
+                               const Instruction *CxtI = nullptr,
+                               AssumptionCache *AC = nullptr,
+                               const DominatorTree *DT = nullptr) {
+  return getOrEnforceKnownAlignment(V, MaybeAlign(), DL, CxtI, AC, DT);
 }
 
+/// Create a call that matches the invoke \p II in terms of arguments,
+/// attributes, debug information, etc. The call is not placed in a block and it
+/// will not have a name. The invoke instruction is not removed, nor are the
+/// uses replaced by the new call.
+CallInst *createCallMatchingInvoke(InvokeInst *II);
+
+/// This function converts the specified invoek into a normall call.
+void changeToCall(InvokeInst *II, DomTreeUpdater *DTU = nullptr);
+
 ///===---------------------------------------------------------------------===//
 ///  Dbg Intrinsic utilities
 ///
@@ -303,6 +270,10 @@
 /// dbg.addr intrinsics.
 TinyPtrVector<DbgVariableIntrinsic *> FindDbgAddrUses(Value *V);
 
+/// Like \c FindDbgAddrUses, but only returns dbg.declare intrinsics, not
+/// dbg.addr.
+TinyPtrVector<DbgDeclareInst *> FindDbgDeclareUses(Value *V);
+
 /// Finds the llvm.dbg.value intrinsics describing a value.
 void findDbgValues(SmallVectorImpl<DbgValueInst *> &DbgValues, Value *V);
 
@@ -314,20 +285,9 @@
 /// additional DW_OP_deref is prepended to the expression. If Offset
 /// is non-zero, a constant displacement is added to the expression
 /// (between the optional Deref operations). Offset can be negative.
-bool replaceDbgDeclare(Value *Address, Value *NewAddress,
-                       Instruction *InsertBefore, DIBuilder &Builder,
+bool replaceDbgDeclare(Value *Address, Value *NewAddress, DIBuilder &Builder,
                        uint8_t DIExprFlags, int Offset);
 
-/// Replaces llvm.dbg.declare instruction when the alloca it describes
-/// is replaced with a new value. If Deref is true, an additional
-/// DW_OP_deref is prepended to the expression. If Offset is non-zero,
-/// a constant displacement is added to the expression (between the
-/// optional Deref operations). Offset can be negative. The new
-/// llvm.dbg.declare is inserted immediately after AI.
-bool replaceDbgDeclareForAlloca(AllocaInst *AI, Value *NewAllocaAddress,
-                                DIBuilder &Builder, uint8_t DIExprFlags,
-                                int Offset);
-
 /// Replaces multiple llvm.dbg.value instructions when the alloca it describes
 /// is replaced with a new value. If Offset is non-zero, a constant displacement
 /// is added to the expression (after the mandatory Deref). Offset can be
@@ -336,18 +296,17 @@
 void replaceDbgValueForAlloca(AllocaInst *AI, Value *NewAllocaAddress,
                               DIBuilder &Builder, int Offset = 0);
 
-/// Finds alloca where the value comes from.
-AllocaInst *findAllocaForValue(Value *V,
-                               DenseMap<Value *, AllocaInst *> &AllocaForValue);
-
 /// Assuming the instruction \p I is going to be deleted, attempt to salvage
-/// debug users of \p I by writing the effect of \p I in a DIExpression.
-/// Returns true if any debug users were updated.
-bool salvageDebugInfo(Instruction &I);
+/// debug users of \p I by writing the effect of \p I in a DIExpression. If it
+/// cannot be salvaged changes its debug uses to undef.
+void salvageDebugInfo(Instruction &I);
+
 
 /// Implementation of salvageDebugInfo, applying only to instructions in
-/// \p Insns, rather than all debug users of \p I.
-bool salvageDebugInfoForDbgValues(Instruction &I,
+/// \p Insns, rather than all debug users from findDbgUsers( \p I).
+/// Returns true if any debug users were updated.
+/// Mark undef if salvaging cannot be completed.
+void salvageDebugInfoForDbgValues(Instruction &I,
                                   ArrayRef<DbgVariableIntrinsic *> Insns);
 
 /// Given an instruction \p I and DIExpression \p DIExpr operating on it, write
@@ -374,9 +333,13 @@
 bool replaceAllDbgUsesWith(Instruction &From, Value &To, Instruction &DomPoint,
                            DominatorTree &DT);
 
-/// Remove all instructions from a basic block other than it's terminator
-/// and any present EH pad instructions.
-unsigned removeAllNonTerminatorAndEHPadInstructions(BasicBlock *BB);
+/// Remove all instructions from a basic block other than its terminator
+/// and any present EH pad instructions. Returns a pair where the first element
+/// is the number of instructions (excluding debug info instrinsics) that have
+/// been removed, and the second element is the number of debug info intrinsics
+/// that have been removed.
+std::pair<unsigned, unsigned>
+removeAllNonTerminatorAndEHPadInstructions(BasicBlock *BB);
 
 /// Insert an unreachable instruction before the specified
 /// instruction, making it and the rest of the code in the block dead.
@@ -403,8 +366,7 @@
 /// Remove all blocks that can not be reached from the function's entry.
 ///
 /// Returns true if any basic block was removed.
-bool removeUnreachableBlocks(Function &F, LazyValueInfo *LVI = nullptr,
-                             DomTreeUpdater *DTU = nullptr,
+bool removeUnreachableBlocks(Function &F, DomTreeUpdater *DTU = nullptr,
                              MemorySSAUpdater *MSSAU = nullptr);
 
 /// Combine the metadata of two instructions so that K can replace J. Some
@@ -424,6 +386,10 @@
 void combineMetadataForCSE(Instruction *K, const Instruction *J,
                            bool DoesKMove);
 
+/// Copy the metadata from the source instruction to the destination (the
+/// replacement for the source instruction).
+void copyMetadataForLoad(LoadInst &Dest, const LoadInst &Source);
+
 /// Patch the replacement so that it is not more restrictive than the value
 /// being replaced. It assumes that the replacement does not get moved from
 /// its original position.
@@ -514,6 +480,13 @@
 /// value?
 bool canReplaceOperandWithVariable(const Instruction *I, unsigned OpIdx);
 
+//===----------------------------------------------------------------------===//
+//  Value helper functions
+//
+
+/// Invert the given true/false value, possibly reusing an existing copy.
+Value *invertCondition(Value *Condition);
+
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_UTILS_LOCAL_H
diff --git a/linux-x64/clang/include/llvm/Transforms/Utils/LoopPeel.h b/linux-x64/clang/include/llvm/Transforms/Utils/LoopPeel.h
new file mode 100644
index 0000000..8f857e1
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Transforms/Utils/LoopPeel.h
@@ -0,0 +1,40 @@
+//===- llvm/Transforms/Utils/LoopPeel.h ----- Peeling utilities -*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines some loop peeling utilities. It does not define any
+// actual pass or policy.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_UTILS_LOOPPEEL_H
+#define LLVM_TRANSFORMS_UTILS_LOOPPEEL_H
+
+#include "llvm/Analysis/TargetTransformInfo.h"
+
+namespace llvm {
+
+bool canPeel(Loop *L);
+
+bool peelLoop(Loop *L, unsigned PeelCount, LoopInfo *LI, ScalarEvolution *SE,
+              DominatorTree *DT, AssumptionCache *AC, bool PreserveLCSSA);
+
+TargetTransformInfo::PeelingPreferences
+gatherPeelingPreferences(Loop *L, ScalarEvolution &SE,
+                         const TargetTransformInfo &TTI,
+                         Optional<bool> UserAllowPeeling,
+                         Optional<bool> UserAllowProfileBasedPeeling,
+                         bool UnrollingSpecficValues = false);
+
+void computePeelCount(Loop *L, unsigned LoopSize,
+                      TargetTransformInfo::PeelingPreferences &PP,
+                      unsigned &TripCount, ScalarEvolution &SE,
+                      unsigned Threshold = UINT_MAX);
+
+} // end namespace llvm
+
+#endif // LLVM_TRANSFORMS_UTILS_LOOPPEEL_H
diff --git a/linux-x64/clang/include/llvm/Transforms/Utils/LoopSimplify.h b/linux-x64/clang/include/llvm/Transforms/Utils/LoopSimplify.h
index 2c1df79..d017fd1 100644
--- a/linux-x64/clang/include/llvm/Transforms/Utils/LoopSimplify.h
+++ b/linux-x64/clang/include/llvm/Transforms/Utils/LoopSimplify.h
@@ -38,14 +38,16 @@
 #ifndef LLVM_TRANSFORMS_UTILS_LOOPSIMPLIFY_H
 #define LLVM_TRANSFORMS_UTILS_LOOPSIMPLIFY_H
 
-#include "llvm/Analysis/AssumptionCache.h"
-#include "llvm/Analysis/ScalarEvolution.h"
-#include "llvm/IR/Dominators.h"
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 
+class AssumptionCache;
+class DominatorTree;
+class Loop;
+class LoopInfo;
 class MemorySSAUpdater;
+class ScalarEvolution;
 
 /// This pass is responsible for loop canonicalization.
 class LoopSimplifyPass : public PassInfoMixin<LoopSimplifyPass> {
diff --git a/linux-x64/clang/include/llvm/Transforms/Utils/LoopUtils.h b/linux-x64/clang/include/llvm/Transforms/Utils/LoopUtils.h
index 68bdded..940747b 100644
--- a/linux-x64/clang/include/llvm/Transforms/Utils/LoopUtils.h
+++ b/linux-x64/clang/include/llvm/Transforms/Utils/LoopUtils.h
@@ -13,42 +13,44 @@
 #ifndef LLVM_TRANSFORMS_UTILS_LOOPUTILS_H
 #define LLVM_TRANSFORMS_UTILS_LOOPUTILS_H
 
-#include "llvm/ADT/DenseMap.h"
-#include "llvm/ADT/Optional.h"
-#include "llvm/ADT/SetVector.h"
-#include "llvm/ADT/SmallPtrSet.h"
-#include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
-#include "llvm/Analysis/AliasAnalysis.h"
-#include "llvm/Analysis/DemandedBits.h"
-#include "llvm/Analysis/EHPersonalities.h"
 #include "llvm/Analysis/IVDescriptors.h"
-#include "llvm/Analysis/MustExecute.h"
 #include "llvm/Analysis/TargetTransformInfo.h"
-#include "llvm/IR/Dominators.h"
-#include "llvm/IR/IRBuilder.h"
-#include "llvm/IR/InstrTypes.h"
-#include "llvm/IR/Operator.h"
-#include "llvm/IR/ValueHandle.h"
-#include "llvm/Support/Casting.h"
+#include "llvm/Transforms/Utils/ValueMapper.h"
 
 namespace llvm {
 
+template <typename T> class DomTreeNodeBase;
+using DomTreeNode = DomTreeNodeBase<BasicBlock>;
+class AAResults;
 class AliasSet;
 class AliasSetTracker;
 class BasicBlock;
-class DataLayout;
+class BlockFrequencyInfo;
+class IRBuilderBase;
 class Loop;
 class LoopInfo;
 class MemoryAccess;
+class MemorySSA;
 class MemorySSAUpdater;
 class OptimizationRemarkEmitter;
-class PredicatedScalarEvolution;
 class PredIteratorCache;
 class ScalarEvolution;
 class SCEV;
+class SCEVExpander;
 class TargetLibraryInfo;
-class TargetTransformInfo;
+class LPPassManager;
+class Instruction;
+struct RuntimeCheckingPtrGroup;
+typedef std::pair<const RuntimeCheckingPtrGroup *,
+                  const RuntimeCheckingPtrGroup *>
+    RuntimePointerCheck;
+
+template <typename T> class Optional;
+template <typename T, unsigned N> class SmallSetVector;
+template <typename T, unsigned N> class SmallVector;
+template <typename T> class SmallVectorImpl;
+template <typename T, unsigned N> class SmallPriorityWorklist;
 
 BasicBlock *InsertPreheaderForLoop(Loop *L, DominatorTree *DT, LoopInfo *LI,
                                    MemorySSAUpdater *MSSAU, bool PreserveLCSSA);
@@ -72,8 +74,14 @@
 /// changes to CFG, preserved.
 ///
 /// Returns true if any modifications are made.
-bool formLCSSAForInstructions(SmallVectorImpl<Instruction *> &Worklist,
-                              DominatorTree &DT, LoopInfo &LI);
+///
+/// This function may introduce unused PHI nodes. If \p PHIsToRemove is not
+/// nullptr, those are added to it (before removing, the caller has to check if
+/// they still do not have any uses). Otherwise the PHIs are directly removed.
+bool formLCSSAForInstructions(
+    SmallVectorImpl<Instruction *> &Worklist, const DominatorTree &DT,
+    const LoopInfo &LI, ScalarEvolution *SE, IRBuilderBase &Builder,
+    SmallVectorImpl<PHINode *> *PHIsToRemove = nullptr);
 
 /// Put loop into LCSSA form.
 ///
@@ -87,7 +95,8 @@
 /// If ScalarEvolution is passed in, it will be preserved.
 ///
 /// Returns true if any modifications are made to the loop.
-bool formLCSSA(Loop &L, DominatorTree &DT, LoopInfo *LI, ScalarEvolution *SE);
+bool formLCSSA(Loop &L, const DominatorTree &DT, const LoopInfo *LI,
+               ScalarEvolution *SE);
 
 /// Put a loop nest into LCSSA form.
 ///
@@ -98,12 +107,31 @@
 /// If ScalarEvolution is passed in, it will be preserved.
 ///
 /// Returns true if any modifications are made to the loop.
-bool formLCSSARecursively(Loop &L, DominatorTree &DT, LoopInfo *LI,
+bool formLCSSARecursively(Loop &L, const DominatorTree &DT, const LoopInfo *LI,
                           ScalarEvolution *SE);
 
-struct SinkAndHoistLICMFlags {
-  bool NoOfMemAccTooLarge;
-  unsigned LicmMssaOptCounter;
+/// Flags controlling how much is checked when sinking or hoisting
+/// instructions.  The number of memory access in the loop (and whether there
+/// are too many) is determined in the constructors when using MemorySSA.
+class SinkAndHoistLICMFlags {
+public:
+  // Explicitly set limits.
+  SinkAndHoistLICMFlags(unsigned LicmMssaOptCap,
+                        unsigned LicmMssaNoAccForPromotionCap, bool IsSink,
+                        Loop *L = nullptr, MemorySSA *MSSA = nullptr);
+  // Use default limits.
+  SinkAndHoistLICMFlags(bool IsSink, Loop *L = nullptr,
+                        MemorySSA *MSSA = nullptr);
+
+  void setIsSink(bool B) { IsSink = B; }
+  bool getIsSink() { return IsSink; }
+  bool tooManyMemoryAccesses() { return NoOfMemAccTooLarge; }
+  bool tooManyClobberingCalls() { return LicmMssaOptCounter >= LicmMssaOptCap; }
+  void incrementClobberingCalls() { ++LicmMssaOptCounter; }
+
+protected:
+  bool NoOfMemAccTooLarge = false;
+  unsigned LicmMssaOptCounter = 0;
   unsigned LicmMssaOptCap;
   unsigned LicmMssaNoAccForPromotionCap;
   bool IsSink;
@@ -113,27 +141,29 @@
 /// dominated by the specified block, and that are in the current loop) in
 /// reverse depth first order w.r.t the DominatorTree. This allows us to visit
 /// uses before definitions, allowing us to sink a loop body in one pass without
-/// iteration. Takes DomTreeNode, AliasAnalysis, LoopInfo, DominatorTree,
-/// DataLayout, TargetLibraryInfo, Loop, AliasSet information for all
+/// iteration. Takes DomTreeNode, AAResults, LoopInfo, DominatorTree,
+/// BlockFrequencyInfo, TargetLibraryInfo, Loop, AliasSet information for all
 /// instructions of the loop and loop safety information as
 /// arguments. Diagnostics is emitted via \p ORE. It returns changed status.
-bool sinkRegion(DomTreeNode *, AliasAnalysis *, LoopInfo *, DominatorTree *,
-                TargetLibraryInfo *, TargetTransformInfo *, Loop *,
-                AliasSetTracker *, MemorySSAUpdater *, ICFLoopSafetyInfo *,
+bool sinkRegion(DomTreeNode *, AAResults *, LoopInfo *, DominatorTree *,
+                BlockFrequencyInfo *, TargetLibraryInfo *,
+                TargetTransformInfo *, Loop *, AliasSetTracker *,
+                MemorySSAUpdater *, ICFLoopSafetyInfo *,
                 SinkAndHoistLICMFlags &, OptimizationRemarkEmitter *);
 
 /// Walk the specified region of the CFG (defined by all blocks
 /// dominated by the specified block, and that are in the current loop) in depth
 /// first order w.r.t the DominatorTree.  This allows us to visit definitions
 /// before uses, allowing us to hoist a loop body in one pass without iteration.
-/// Takes DomTreeNode, AliasAnalysis, LoopInfo, DominatorTree, DataLayout,
-/// TargetLibraryInfo, Loop, AliasSet information for all instructions of the
-/// loop and loop safety information as arguments. Diagnostics is emitted via \p
-/// ORE. It returns changed status.
-bool hoistRegion(DomTreeNode *, AliasAnalysis *, LoopInfo *, DominatorTree *,
-                 TargetLibraryInfo *, Loop *, AliasSetTracker *,
-                 MemorySSAUpdater *, ICFLoopSafetyInfo *,
-                 SinkAndHoistLICMFlags &, OptimizationRemarkEmitter *);
+/// Takes DomTreeNode, AAResults, LoopInfo, DominatorTree,
+/// BlockFrequencyInfo, TargetLibraryInfo, Loop, AliasSet information for all
+/// instructions of the loop and loop safety information as arguments.
+/// Diagnostics is emitted via \p ORE. It returns changed status.
+bool hoistRegion(DomTreeNode *, AAResults *, LoopInfo *, DominatorTree *,
+                 BlockFrequencyInfo *, TargetLibraryInfo *, Loop *,
+                 AliasSetTracker *, MemorySSAUpdater *, ScalarEvolution *,
+                 ICFLoopSafetyInfo *, SinkAndHoistLICMFlags &,
+                 OptimizationRemarkEmitter *);
 
 /// This function deletes dead loops. The caller of this function needs to
 /// guarantee that the loop is infact dead.
@@ -142,12 +172,18 @@
 ///   - The loop needs to have a Preheader
 ///   - A unique dedicated exit block must exist
 ///
-/// This also updates the relevant analysis information in \p DT, \p SE, and \p
-/// LI if pointers to those are provided.
+/// This also updates the relevant analysis information in \p DT, \p SE, \p LI
+/// and \p MSSA if pointers to those are provided.
 /// It also updates the loop PM if an updater struct is provided.
 
 void deleteDeadLoop(Loop *L, DominatorTree *DT, ScalarEvolution *SE,
-                    LoopInfo *LI);
+                    LoopInfo *LI, MemorySSA *MSSA = nullptr);
+
+/// Remove the backedge of the specified loop.  Handles loop nests and general
+/// loop structures subject to the precondition that the loop has no parent
+/// loop and has a single latch block.  Preserves all listed analyses.
+void breakLoopBackedge(Loop *L, DominatorTree &DT, ScalarEvolution &SE,
+                       LoopInfo &LI, MemorySSA *MSSA);
 
 /// Try to promote memory values to scalars by sinking stores out of
 /// the loop and moving loads to before the loop.  We do this by looping over
@@ -183,6 +219,13 @@
 /// Find named metadata for a loop with an integer value.
 llvm::Optional<int> getOptionalIntLoopAttribute(Loop *TheLoop, StringRef Name);
 
+/// Find a combination of metadata ("llvm.loop.vectorize.width" and
+/// "llvm.loop.vectorize.scalable.enable") for a loop and use it to construct a
+/// ElementCount. If the metadata "llvm.loop.vectorize.width" cannot be found
+/// then None is returned.
+Optional<ElementCount>
+getOptionalElementCountLoopAttribute(Loop *TheLoop);
+
 /// Create a new loop identifier for a loop created from a loop transformation.
 ///
 /// @param OrigLoopID The loop ID of the loop before the transformation.
@@ -215,6 +258,12 @@
 /// Look for the loop attribute that disables all transformation heuristic.
 bool hasDisableAllTransformsHint(const Loop *L);
 
+/// Look for the loop attribute that disables the LICM transformation heuristics.
+bool hasDisableLICMTransformsHint(const Loop *L);
+
+/// Look for the loop attribute that requires progress within the loop.
+bool hasMustProgress(const Loop *L);
+
 /// The mode sets how eager a transformation should be applied.
 enum TransformationMode {
   /// The pass can use heuristics to determine whether a transformation should
@@ -252,13 +301,30 @@
 /// @}
 
 /// Set input string into loop metadata by keeping other values intact.
+/// If the string is already in loop metadata update value if it is
+/// different.
 void addStringMetadataToLoop(Loop *TheLoop, const char *MDString,
                              unsigned V = 0);
 
-/// Get a loop's estimated trip count based on branch weight metadata.
+/// Returns true if Name is applied to TheLoop and enabled.
+bool getBooleanLoopAttribute(const Loop *TheLoop, StringRef Name);
+
+/// Returns a loop's estimated trip count based on branch weight metadata.
+/// In addition if \p EstimatedLoopInvocationWeight is not null it is
+/// initialized with weight of loop's latch leading to the exit.
 /// Returns 0 when the count is estimated to be 0, or None when a meaningful
 /// estimate can not be made.
-Optional<unsigned> getLoopEstimatedTripCount(Loop *L);
+Optional<unsigned>
+getLoopEstimatedTripCount(Loop *L,
+                          unsigned *EstimatedLoopInvocationWeight = nullptr);
+
+/// Set a loop's branch weight metadata to reflect that loop has \p
+/// EstimatedTripCount iterations and \p EstimatedLoopInvocationWeight exits
+/// through latch. Returns true if metadata is successfully updated, false
+/// otherwise. Note that loop must have a latch block which controls loop exit
+/// in order to succeed.
+bool setLoopEstimatedTripCount(Loop *L, unsigned EstimatedTripCount,
+                               unsigned EstimatedLoopInvocationWeight);
 
 /// Check inner loop (L) backedge count is known to be invariant on all
 /// iterations of its outer loop. If the loop has no parent, this is trivially
@@ -288,44 +354,37 @@
                         OptimizationRemarkEmitter *ORE = nullptr);
 
 /// Returns a Min/Max operation corresponding to MinMaxRecurrenceKind.
-Value *createMinMaxOp(IRBuilder<> &Builder,
-                      RecurrenceDescriptor::MinMaxRecurrenceKind RK,
-                      Value *Left, Value *Right);
+Value *createMinMaxOp(IRBuilderBase &Builder, RecurKind RK, Value *Left,
+                      Value *Right);
 
 /// Generates an ordered vector reduction using extracts to reduce the value.
-Value *
-getOrderedReduction(IRBuilder<> &Builder, Value *Acc, Value *Src, unsigned Op,
-                    RecurrenceDescriptor::MinMaxRecurrenceKind MinMaxKind =
-                        RecurrenceDescriptor::MRK_Invalid,
-                    ArrayRef<Value *> RedOps = None);
+Value *getOrderedReduction(IRBuilderBase &Builder, Value *Acc, Value *Src,
+                           unsigned Op, RecurKind MinMaxKind = RecurKind::None,
+                           ArrayRef<Value *> RedOps = None);
 
 /// Generates a vector reduction using shufflevectors to reduce the value.
 /// Fast-math-flags are propagated using the IRBuilder's setting.
-Value *getShuffleReduction(IRBuilder<> &Builder, Value *Src, unsigned Op,
-                           RecurrenceDescriptor::MinMaxRecurrenceKind
-                               MinMaxKind = RecurrenceDescriptor::MRK_Invalid,
+Value *getShuffleReduction(IRBuilderBase &Builder, Value *Src, unsigned Op,
+                           RecurKind MinMaxKind = RecurKind::None,
                            ArrayRef<Value *> RedOps = None);
 
 /// Create a target reduction of the given vector. The reduction operation
 /// is described by the \p Opcode parameter. min/max reductions require
-/// additional information supplied in \p Flags.
+/// additional information supplied in \p RdxKind.
 /// The target is queried to determine if intrinsics or shuffle sequences are
 /// required to implement the reduction.
 /// Fast-math-flags are propagated using the IRBuilder's setting.
-Value *createSimpleTargetReduction(IRBuilder<> &B,
-                                   const TargetTransformInfo *TTI,
-                                   unsigned Opcode, Value *Src,
-                                   TargetTransformInfo::ReductionFlags Flags =
-                                       TargetTransformInfo::ReductionFlags(),
+Value *createSimpleTargetReduction(IRBuilderBase &B,
+                                   const TargetTransformInfo *TTI, Value *Src,
+                                   RecurKind RdxKind,
                                    ArrayRef<Value *> RedOps = None);
 
 /// Create a generic target reduction using a recurrence descriptor \p Desc
 /// The target is queried to determine if intrinsics or shuffle sequences are
 /// required to implement the reduction.
 /// Fast-math-flags are propagated using the RecurrenceDescriptor.
-Value *createTargetReduction(IRBuilder<> &B, const TargetTransformInfo *TTI,
-                             RecurrenceDescriptor &Desc, Value *Src,
-                             bool NoNaN = false);
+Value *createTargetReduction(IRBuilderBase &B, const TargetTransformInfo *TTI,
+                             RecurrenceDescriptor &Desc, Value *Src);
 
 /// Get the intersection (logical and) of all of the potential IR flags
 /// of each scalar operation (VL) that will be converted into a vector (I).
@@ -351,6 +410,77 @@
 bool cannotBeMinInLoop(const SCEV *S, const Loop *L, ScalarEvolution &SE,
                        bool Signed);
 
+enum ReplaceExitVal { NeverRepl, OnlyCheapRepl, NoHardUse, AlwaysRepl };
+
+/// If the final value of any expressions that are recurrent in the loop can
+/// be computed, substitute the exit values from the loop into any instructions
+/// outside of the loop that use the final values of the current expressions.
+/// Return the number of loop exit values that have been replaced, and the
+/// corresponding phi node will be added to DeadInsts.
+int rewriteLoopExitValues(Loop *L, LoopInfo *LI, TargetLibraryInfo *TLI,
+                          ScalarEvolution *SE, const TargetTransformInfo *TTI,
+                          SCEVExpander &Rewriter, DominatorTree *DT,
+                          ReplaceExitVal ReplaceExitValue,
+                          SmallVector<WeakTrackingVH, 16> &DeadInsts);
+
+/// Set weights for \p UnrolledLoop and \p RemainderLoop based on weights for
+/// \p OrigLoop and the following distribution of \p OrigLoop iteration among \p
+/// UnrolledLoop and \p RemainderLoop. \p UnrolledLoop receives weights that
+/// reflect TC/UF iterations, and \p RemainderLoop receives weights that reflect
+/// the remaining TC%UF iterations.
+///
+/// Note that \p OrigLoop may be equal to either \p UnrolledLoop or \p
+/// RemainderLoop in which case weights for \p OrigLoop are updated accordingly.
+/// Note also behavior is undefined if \p UnrolledLoop and \p RemainderLoop are
+/// equal. \p UF must be greater than zero.
+/// If \p OrigLoop has no profile info associated nothing happens.
+///
+/// This utility may be useful for such optimizations as unroller and
+/// vectorizer as it's typical transformation for them.
+void setProfileInfoAfterUnrolling(Loop *OrigLoop, Loop *UnrolledLoop,
+                                  Loop *RemainderLoop, uint64_t UF);
+
+/// Utility that implements appending of loops onto a worklist given a range.
+/// We want to process loops in postorder, but the worklist is a LIFO data
+/// structure, so we append to it in *reverse* postorder.
+/// For trees, a preorder traversal is a viable reverse postorder, so we
+/// actually append using a preorder walk algorithm.
+template <typename RangeT>
+void appendLoopsToWorklist(RangeT &&, SmallPriorityWorklist<Loop *, 4> &);
+/// Utility that implements appending of loops onto a worklist given a range.
+/// It has the same behavior as appendLoopsToWorklist, but assumes the range of
+/// loops has already been reversed, so it processes loops in the given order.
+template <typename RangeT>
+void appendReversedLoopsToWorklist(RangeT &&,
+                                   SmallPriorityWorklist<Loop *, 4> &);
+
+/// Utility that implements appending of loops onto a worklist given LoopInfo.
+/// Calls the templated utility taking a Range of loops, handing it the Loops
+/// in LoopInfo, iterated in reverse. This is because the loops are stored in
+/// RPO w.r.t. the control flow graph in LoopInfo. For the purpose of unrolling,
+/// loop deletion, and LICM, we largely want to work forward across the CFG so
+/// that we visit defs before uses and can propagate simplifications from one
+/// loop nest into the next. Calls appendReversedLoopsToWorklist with the
+/// already reversed loops in LI.
+/// FIXME: Consider changing the order in LoopInfo.
+void appendLoopsToWorklist(LoopInfo &, SmallPriorityWorklist<Loop *, 4> &);
+
+/// Recursively clone the specified loop and all of its children,
+/// mapping the blocks with the specified map.
+Loop *cloneLoop(Loop *L, Loop *PL, ValueToValueMapTy &VM,
+                LoopInfo *LI, LPPassManager *LPM);
+
+/// Add code that checks at runtime if the accessed arrays in \p PointerChecks
+/// overlap.
+///
+/// Returns a pair of instructions where the first element is the first
+/// instruction generated in possibly a sequence of instructions and the
+/// second value is the final comparator value or NULL if no check is needed.
+std::pair<Instruction *, Instruction *>
+addRuntimeChecks(Instruction *Loc, Loop *TheLoop,
+                 const SmallVectorImpl<RuntimePointerCheck> &PointerChecks,
+                 ScalarEvolution *SE);
+
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_UTILS_LOOPUTILS_H
diff --git a/linux-x64/clang/include/llvm/Transforms/Utils/LoopVersioning.h b/linux-x64/clang/include/llvm/Transforms/Utils/LoopVersioning.h
index 355c4d7..4a8831e 100644
--- a/linux-x64/clang/include/llvm/Transforms/Utils/LoopVersioning.h
+++ b/linux-x64/clang/include/llvm/Transforms/Utils/LoopVersioning.h
@@ -15,8 +15,8 @@
 #ifndef LLVM_TRANSFORMS_UTILS_LOOPVERSIONING_H
 #define LLVM_TRANSFORMS_UTILS_LOOPVERSIONING_H
 
-#include "llvm/Analysis/LoopAccessAnalysis.h"
 #include "llvm/Analysis/ScalarEvolution.h"
+#include "llvm/IR/PassManager.h"
 #include "llvm/Transforms/Utils/LoopUtils.h"
 #include "llvm/Transforms/Utils/ValueMapper.h"
 
@@ -25,7 +25,12 @@
 class Loop;
 class LoopAccessInfo;
 class LoopInfo;
-class ScalarEvolution;
+struct RuntimeCheckingPtrGroup;
+typedef std::pair<const RuntimeCheckingPtrGroup *,
+                  const RuntimeCheckingPtrGroup *>
+    RuntimePointerCheck;
+
+template <typename T> class ArrayRef;
 
 /// This class emits a version of the loop where run-time checks ensure
 /// that may-alias pointers can't overlap.
@@ -38,9 +43,9 @@
   /// It uses runtime check provided by the user. If \p UseLAIChecks is true,
   /// we will retain the default checks made by LAI. Otherwise, construct an
   /// object having no checks and we expect the user to add them.
-  LoopVersioning(const LoopAccessInfo &LAI, Loop *L, LoopInfo *LI,
-                 DominatorTree *DT, ScalarEvolution *SE,
-                 bool UseLAIChecks = true);
+  LoopVersioning(const LoopAccessInfo &LAI,
+                 ArrayRef<RuntimePointerCheck> Checks, Loop *L, LoopInfo *LI,
+                 DominatorTree *DT, ScalarEvolution *SE);
 
   /// Performs the CFG manipulation part of versioning the loop including
   /// the DominatorTree and LoopInfo updates.
@@ -70,13 +75,6 @@
   /// loop may alias (i.e. one of the memchecks failed).
   Loop *getNonVersionedLoop() { return NonVersionedLoop; }
 
-  /// Sets the runtime alias checks for versioning the loop.
-  void setAliasChecks(
-      SmallVector<RuntimePointerChecking::PointerCheck, 4> Checks);
-
-  /// Sets the runtime SCEV checks for versioning the loop.
-  void setSCEVChecks(SCEVUnionPredicate Check);
-
   /// Annotate memory instructions in the versioned loop with no-alias
   /// metadata based on the memchecks issued.
   ///
@@ -122,22 +120,20 @@
   ValueToValueMapTy VMap;
 
   /// The set of alias checks that we are versioning for.
-  SmallVector<RuntimePointerChecking::PointerCheck, 4> AliasChecks;
+  SmallVector<RuntimePointerCheck, 4> AliasChecks;
 
   /// The set of SCEV checks that we are versioning for.
-  SCEVUnionPredicate Preds;
+  const SCEVUnionPredicate &Preds;
 
   /// Maps a pointer to the pointer checking group that the pointer
   /// belongs to.
-  DenseMap<const Value *, const RuntimePointerChecking::CheckingPtrGroup *>
-      PtrToGroup;
+  DenseMap<const Value *, const RuntimeCheckingPtrGroup *> PtrToGroup;
 
   /// The alias scope corresponding to a pointer checking group.
-  DenseMap<const RuntimePointerChecking::CheckingPtrGroup *, MDNode *>
-      GroupToScope;
+  DenseMap<const RuntimeCheckingPtrGroup *, MDNode *> GroupToScope;
 
   /// The list of alias scopes that a pointer checking group can't alias.
-  DenseMap<const RuntimePointerChecking::CheckingPtrGroup *, MDNode *>
+  DenseMap<const RuntimeCheckingPtrGroup *, MDNode *>
       GroupToNonAliasingScopeList;
 
   /// Analyses used.
@@ -146,6 +142,14 @@
   DominatorTree *DT;
   ScalarEvolution *SE;
 };
+
+/// Expose LoopVersioning as a pass.  Currently this is only used for
+/// unit-testing.  It adds all memchecks necessary to remove all may-aliasing
+/// array accesses from the loop.
+class LoopVersioningPass : public PassInfoMixin<LoopVersioningPass> {
+public:
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager &FAM);
+};
 }
 
 #endif
diff --git a/linux-x64/clang/include/llvm/Transforms/Utils/LowerMemIntrinsics.h b/linux-x64/clang/include/llvm/Transforms/Utils/LowerMemIntrinsics.h
index 8e9d7b5..8d09560 100644
--- a/linux-x64/clang/include/llvm/Transforms/Utils/LowerMemIntrinsics.h
+++ b/linux-x64/clang/include/llvm/Transforms/Utils/LowerMemIntrinsics.h
@@ -23,12 +23,13 @@
 class MemSetInst;
 class TargetTransformInfo;
 class Value;
+struct Align;
 
 /// Emit a loop implementing the semantics of llvm.memcpy where the size is not
 /// a compile-time constant. Loop will be insterted at \p InsertBefore.
 void createMemCpyLoopUnknownSize(Instruction *InsertBefore, Value *SrcAddr,
                                  Value *DstAddr, Value *CopyLen,
-                                 unsigned SrcAlign, unsigned DestAlign,
+                                 Align SrcAlign, Align DestAlign,
                                  bool SrcIsVolatile, bool DstIsVolatile,
                                  const TargetTransformInfo &TTI);
 
@@ -36,11 +37,10 @@
 /// compile time constant. Loop is inserted at \p InsertBefore.
 void createMemCpyLoopKnownSize(Instruction *InsertBefore, Value *SrcAddr,
                                Value *DstAddr, ConstantInt *CopyLen,
-                               unsigned SrcAlign, unsigned DestAlign,
+                               Align SrcAlign, Align DestAlign,
                                bool SrcIsVolatile, bool DstIsVolatile,
                                const TargetTransformInfo &TTI);
 
-
 /// Expand \p MemCpy as a loop. \p MemCpy is not deleted.
 void expandMemCpyAsLoop(MemCpyInst *MemCpy, const TargetTransformInfo &TTI);
 
diff --git a/linux-x64/clang/include/llvm/Transforms/Utils/LowerSwitch.h b/linux-x64/clang/include/llvm/Transforms/Utils/LowerSwitch.h
new file mode 100644
index 0000000..9708698
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Transforms/Utils/LowerSwitch.h
@@ -0,0 +1,26 @@
+//===- LowerSwitch.h - Eliminate Switch instructions ----------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// The LowerSwitch transformation rewrites switch instructions with a sequence
+// of branches, which allows targets to get away with not implementing the
+// switch instruction until it is convenient.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_UTILS_LOWERSWITCH_H
+#define LLVM_TRANSFORMS_UTILS_LOWERSWITCH_H
+
+#include "llvm/IR/PassManager.h"
+
+namespace llvm {
+struct LowerSwitchPass : public PassInfoMixin<LowerSwitchPass> {
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+};
+} // namespace llvm
+
+#endif // LLVM_TRANSFORMS_UTILS_LOWERSWITCH_H
diff --git a/linux-x64/clang/include/llvm/Transforms/Utils/MatrixUtils.h b/linux-x64/clang/include/llvm/Transforms/Utils/MatrixUtils.h
new file mode 100644
index 0000000..39a0d4b
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Transforms/Utils/MatrixUtils.h
@@ -0,0 +1,94 @@
+//===- MatrixUtils.h - Utilities to lower matrix intrinsics -----*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Utilities for generating tiled loops for matrix operations.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_UTILS_MATRIXUTILS_H
+#define LLVM_TRANSFORMS_UTILS_MATRIXUTILS_H
+
+#include "llvm/ADT/StringRef.h"
+
+namespace llvm {
+class DomTreeUpdater;
+class BasicBlock;
+class Value;
+class Loop;
+class LoopInfo;
+class IRBuilderBase;
+
+/// A helper struct to create IR loop nests for tiling in IR of the following
+/// form:
+///   for CurrentColumn = 0..NumColumns
+///     for CurrentRow = 0..NumRows
+///       for CurrentInner = 0..NumInner
+struct TileInfo {
+  /// Number of rows of the matrix.
+  unsigned NumRows;
+
+  /// Number of columns of the matrix.
+  unsigned NumColumns;
+
+  /// Number of columns of the first matrix of a multiply /
+  /// number of rows of the second matrix of a multiply.
+  unsigned NumInner;
+
+  /// Number of rows/columns in a tile.
+  unsigned TileSize = -1;
+
+  /// Start row of the current tile to compute.
+  Value *CurrentRow;
+
+  /// Start column of the current tile to compute.
+  Value *CurrentCol;
+
+  /// Current tile offset during the tile computation.
+  Value *CurrentK;
+
+  /// Header of the outermost loop iterating from 0..NumColumns.
+  BasicBlock *ColumnLoopHeader = nullptr;
+
+  /// Header of the second loop iterating from 0..NumRows.
+  BasicBlock *RowLoopHeader = nullptr;
+  /// Latch of the second loop iterating from 0..NumRows.
+  BasicBlock *RowLoopLatch = nullptr;
+  /// Header of the innermost loop iterating from 0..NumInner.
+  BasicBlock *InnerLoopHeader = nullptr;
+  /// Latch of the innermost loop iterating from 0..NumInner.
+  BasicBlock *InnerLoopLatch = nullptr;
+
+  TileInfo(unsigned NumRows, unsigned NumColumns, unsigned NumInner,
+           unsigned TileSize)
+      : NumRows(NumRows), NumColumns(NumColumns), NumInner(NumInner),
+        TileSize(TileSize) {}
+
+  /// Creates an IR loop nests for tiling of the form below. Returns the block
+  /// for the inner loop body and sets {Column,Row,Inner}LoopHeader/Latch
+  /// fields.
+  ///
+  /// for CurrentColumn = 0..NumColumns
+  ///   for CurrentRow = 0..NumRows
+  ///     for CurrentInner = 0..NumInner
+  BasicBlock *CreateTiledLoops(BasicBlock *Start, BasicBlock *End,
+                               IRBuilderBase &B, DomTreeUpdater &DTU,
+                               LoopInfo &LI);
+
+private:
+  /// Creates a new loop with header, body and latch blocks that iterates from
+  /// [0, Bound). Updates \p Preheader to branch to the new header and uses \p
+  /// Exit as exit block.  Adds the new loop blocks to \L and applies dominator
+  /// tree updates to \p DTU.
+  static BasicBlock *CreateLoop(BasicBlock *Preheader, BasicBlock *Exit,
+                                Value *Bound, Value *Step, StringRef Name,
+                                IRBuilderBase &B, DomTreeUpdater &DTU, Loop *L,
+                                LoopInfo &LI);
+};
+} // namespace llvm
+
+#endif
diff --git a/linux-x64/clang/include/llvm/Transforms/Utils/MetaRenamer.h b/linux-x64/clang/include/llvm/Transforms/Utils/MetaRenamer.h
new file mode 100644
index 0000000..fff3dff
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Transforms/Utils/MetaRenamer.h
@@ -0,0 +1,26 @@
+//===- MetaRenamer.h - Rename everything with metasyntatic names ----------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This pass renames everything with metasyntatic names. The intent is to use
+// this pass after bugpoint reduction to conceal the nature of the original
+// program.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_UTILS_METARENAMER_H
+#define LLVM_TRANSFORMS_UTILS_METARENAMER_H
+
+#include "llvm/IR/PassManager.h"
+
+namespace llvm {
+struct MetaRenamerPass : PassInfoMixin<MetaRenamerPass> {
+  PreservedAnalyses run(Module &, ModuleAnalysisManager &);
+};
+} // namespace llvm
+
+#endif // LLVM_TRANSFORMS_UTILS_METARENAMER_H
diff --git a/linux-x64/clang/include/llvm/Transforms/Utils/ModuleUtils.h b/linux-x64/clang/include/llvm/Transforms/Utils/ModuleUtils.h
index c69af55..65added 100644
--- a/linux-x64/clang/include/llvm/Transforms/Utils/ModuleUtils.h
+++ b/linux-x64/clang/include/llvm/Transforms/Utils/ModuleUtils.h
@@ -13,6 +13,7 @@
 #ifndef LLVM_TRANSFORMS_UTILS_MODULEUTILS_H
 #define LLVM_TRANSFORMS_UTILS_MODULEUTILS_H
 
+#include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include <utility> // for std::pair
 
@@ -23,9 +24,7 @@
 class Function;
 class FunctionCallee;
 class GlobalValue;
-class GlobalVariable;
 class Constant;
-class StringRef;
 class Value;
 class Type;
 
@@ -43,6 +42,10 @@
 FunctionCallee declareSanitizerInitFunction(Module &M, StringRef InitName,
                                             ArrayRef<Type *> InitArgTypes);
 
+/// Creates sanitizer constructor function.
+/// \return Returns pointer to constructor.
+Function *createSanitizerCtor(Module &M, StringRef CtorName);
+
 /// Creates sanitizer constructor function, and calls sanitizer's init
 /// function from it.
 /// \return Returns pair of pointers to constructor, and init functions
@@ -108,6 +111,13 @@
 /// unique identifier for this module, so we return the empty string.
 std::string getUniqueModuleId(Module *M);
 
+class CallInst;
+namespace VFABI {
+/// Overwrite the Vector Function ABI variants attribute with the names provide
+/// in \p VariantMappings.
+void setVectorVariantNames(CallInst *CI,
+                           const SmallVector<std::string, 8> &VariantMappings);
+} // End VFABI namespace
 } // End llvm namespace
 
 #endif //  LLVM_TRANSFORMS_UTILS_MODULEUTILS_H
diff --git a/linux-x64/clang/include/llvm/Transforms/Utils/PredicateInfo.h b/linux-x64/clang/include/llvm/Transforms/Utils/PredicateInfo.h
index da4a5dc..c922476 100644
--- a/linux-x64/clang/include/llvm/Transforms/Utils/PredicateInfo.h
+++ b/linux-x64/clang/include/llvm/Transforms/Utils/PredicateInfo.h
@@ -51,49 +51,32 @@
 #define LLVM_TRANSFORMS_UTILS_PREDICATEINFO_H
 
 #include "llvm/ADT/DenseMap.h"
-#include "llvm/ADT/DenseSet.h"
-#include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallSet.h"
-#include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/ilist.h"
 #include "llvm/ADT/ilist_node.h"
-#include "llvm/ADT/iterator.h"
-#include "llvm/Analysis/AssumptionCache.h"
-#include "llvm/Analysis/OrderedInstructions.h"
-#include "llvm/IR/BasicBlock.h"
-#include "llvm/IR/Dominators.h"
 #include "llvm/IR/Instructions.h"
-#include "llvm/IR/IntrinsicInst.h"
-#include "llvm/IR/Module.h"
-#include "llvm/IR/OperandTraits.h"
-#include "llvm/IR/Type.h"
-#include "llvm/IR/Use.h"
-#include "llvm/IR/User.h"
+#include "llvm/IR/PassManager.h"
 #include "llvm/IR/Value.h"
 #include "llvm/IR/ValueHandle.h"
 #include "llvm/Pass.h"
-#include "llvm/PassAnalysisSupport.h"
-#include "llvm/Support/Casting.h"
-#include "llvm/Support/Compiler.h"
-#include "llvm/Support/ErrorHandling.h"
-#include <algorithm>
-#include <cassert>
-#include <cstddef>
-#include <iterator>
-#include <memory>
-#include <utility>
 
 namespace llvm {
 
+class AssumptionCache;
 class DominatorTree;
 class Function;
-class Instruction;
-class MemoryAccess;
-class LLVMContext;
+class IntrinsicInst;
 class raw_ostream;
 
 enum PredicateType { PT_Branch, PT_Assume, PT_Switch };
 
+/// Constraint for a predicate of the form "cmp Pred Op, OtherOp", where Op
+/// is the value the constraint applies to (the ssa.copy result).
+struct PredicateConstraint {
+  CmpInst::Predicate Predicate;
+  Value *OtherOp;
+};
+
 // Base class for all predicate information we provide.
 // All of our predicate information has at least a comparison.
 class PredicateBase : public ilist_node<PredicateBase> {
@@ -103,37 +86,38 @@
   // This can be use by passes, when destroying predicateinfo, to know
   // whether they can just drop the intrinsic, or have to merge metadata.
   Value *OriginalOp;
+  // The renamed operand in the condition used for this predicate. For nested
+  // predicates, this is different to OriginalOp which refers to the initial
+  // operand.
+  Value *RenamedOp;
+  // The condition associated with this predicate.
+  Value *Condition;
+
   PredicateBase(const PredicateBase &) = delete;
   PredicateBase &operator=(const PredicateBase &) = delete;
   PredicateBase() = delete;
   virtual ~PredicateBase() = default;
-
-protected:
-  PredicateBase(PredicateType PT, Value *Op) : Type(PT), OriginalOp(Op) {}
-};
-
-class PredicateWithCondition : public PredicateBase {
-public:
-  Value *Condition;
   static bool classof(const PredicateBase *PB) {
     return PB->Type == PT_Assume || PB->Type == PT_Branch ||
            PB->Type == PT_Switch;
   }
 
+  /// Fetch condition in the form of PredicateConstraint, if possible.
+  Optional<PredicateConstraint> getConstraint() const;
+
 protected:
-  PredicateWithCondition(PredicateType PT, Value *Op, Value *Condition)
-      : PredicateBase(PT, Op), Condition(Condition) {}
+  PredicateBase(PredicateType PT, Value *Op, Value *Condition)
+      : Type(PT), OriginalOp(Op), Condition(Condition) {}
 };
 
 // Provides predicate information for assumes.  Since assumes are always true,
 // we simply provide the assume instruction, so you can tell your relative
 // position to it.
-class PredicateAssume : public PredicateWithCondition {
+class PredicateAssume : public PredicateBase {
 public:
   IntrinsicInst *AssumeInst;
   PredicateAssume(Value *Op, IntrinsicInst *AssumeInst, Value *Condition)
-      : PredicateWithCondition(PT_Assume, Op, Condition),
-        AssumeInst(AssumeInst) {}
+      : PredicateBase(PT_Assume, Op, Condition), AssumeInst(AssumeInst) {}
   PredicateAssume() = delete;
   static bool classof(const PredicateBase *PB) {
     return PB->Type == PT_Assume;
@@ -143,7 +127,7 @@
 // Mixin class for edge predicates.  The FROM block is the block where the
 // predicate originates, and the TO block is the block where the predicate is
 // valid.
-class PredicateWithEdge : public PredicateWithCondition {
+class PredicateWithEdge : public PredicateBase {
 public:
   BasicBlock *From;
   BasicBlock *To;
@@ -155,7 +139,7 @@
 protected:
   PredicateWithEdge(PredicateType PType, Value *Op, BasicBlock *From,
                     BasicBlock *To, Value *Cond)
-      : PredicateWithCondition(PType, Op, Cond), From(From), To(To) {}
+      : PredicateBase(PType, Op, Cond), From(From), To(To) {}
 };
 
 // Provides predicate information for branches.
@@ -189,26 +173,9 @@
   }
 };
 
-// This name is used in a few places, so kick it into their own namespace
-namespace PredicateInfoClasses {
-struct ValueDFS;
-}
-
 /// Encapsulates PredicateInfo, including all data associated with memory
 /// accesses.
 class PredicateInfo {
-private:
-  // Used to store information about each value we might rename.
-  struct ValueInfo {
-    // Information about each possible copy. During processing, this is each
-    // inserted info. After processing, we move the uninserted ones to the
-    // uninserted vector.
-    SmallVector<PredicateBase *, 4> Infos;
-    SmallVector<PredicateBase *, 4> UninsertedInfos;
-  };
-  // This owns the all the predicate infos in the function, placed or not.
-  iplist<PredicateBase> AllInfos;
-
 public:
   PredicateInfo(Function &, DominatorTree &, AssumptionCache &);
   ~PredicateInfo();
@@ -226,42 +193,18 @@
   // Used by PredicateInfo annotater, dumpers, and wrapper pass.
   friend class PredicateInfoAnnotatedWriter;
   friend class PredicateInfoPrinterLegacyPass;
+  friend class PredicateInfoBuilder;
 
 private:
-  void buildPredicateInfo();
-  void processAssume(IntrinsicInst *, BasicBlock *, SmallPtrSetImpl<Value *> &);
-  void processBranch(BranchInst *, BasicBlock *, SmallPtrSetImpl<Value *> &);
-  void processSwitch(SwitchInst *, BasicBlock *, SmallPtrSetImpl<Value *> &);
-  void renameUses(SmallPtrSetImpl<Value *> &);
-  using ValueDFS = PredicateInfoClasses::ValueDFS;
-  typedef SmallVectorImpl<ValueDFS> ValueDFSStack;
-  void convertUsesToDFSOrdered(Value *, SmallVectorImpl<ValueDFS> &);
-  Value *materializeStack(unsigned int &, ValueDFSStack &, Value *);
-  bool stackIsInScope(const ValueDFSStack &, const ValueDFS &) const;
-  void popStackUntilDFSScope(ValueDFSStack &, const ValueDFS &);
-  ValueInfo &getOrCreateValueInfo(Value *);
-  void addInfoFor(SmallPtrSetImpl<Value *> &OpsToRename, Value *Op,
-                  PredicateBase *PB);
-  const ValueInfo &getValueInfo(Value *) const;
   Function &F;
-  DominatorTree &DT;
-  AssumptionCache &AC;
-  OrderedInstructions OI;
+
+  // This owns the all the predicate infos in the function, placed or not.
+  iplist<PredicateBase> AllInfos;
+
   // This maps from copy operands to Predicate Info. Note that it does not own
   // the Predicate Info, they belong to the ValueInfo structs in the ValueInfos
   // vector.
   DenseMap<const Value *, const PredicateBase *> PredicateMap;
-  // This stores info about each operand or comparison result we make copies
-  // of.  The real ValueInfos start at index 1, index 0 is unused so that we can
-  // more easily detect invalid indexing.
-  SmallVector<ValueInfo, 32> ValueInfos;
-  // This gives the index into the ValueInfos array for a given Value.  Because
-  // 0 is not a valid Value Info index, you can use DenseMap::lookup and tell
-  // whether it returned a valid result.
-  DenseMap<Value *, unsigned int> ValueInfoNums;
-  // The set of edges along which we can only handle phi uses, due to critical
-  // edges.
-  DenseSet<std::pair<BasicBlock *, BasicBlock *>> EdgeUsesOnly;
   // The set of ssa_copy declarations we created with our custom mangling.
   SmallSet<AssertingVH<Function>, 20> CreatedDeclarations;
 };
diff --git a/linux-x64/clang/include/llvm/Transforms/Utils/PromoteMemToReg.h b/linux-x64/clang/include/llvm/Transforms/Utils/PromoteMemToReg.h
index b2b4507..f827ffd 100644
--- a/linux-x64/clang/include/llvm/Transforms/Utils/PromoteMemToReg.h
+++ b/linux-x64/clang/include/llvm/Transforms/Utils/PromoteMemToReg.h
@@ -19,7 +19,6 @@
 template <typename T> class ArrayRef;
 class AllocaInst;
 class DominatorTree;
-class AliasSetTracker;
 class AssumptionCache;
 
 /// Return true if this alloca is legal for promotion.
diff --git a/linux-x64/clang/include/llvm/Transforms/Utils/SSAUpdaterBulk.h b/linux-x64/clang/include/llvm/Transforms/Utils/SSAUpdaterBulk.h
index 5d17d6f..3a78e22 100644
--- a/linux-x64/clang/include/llvm/Transforms/Utils/SSAUpdaterBulk.h
+++ b/linux-x64/clang/include/llvm/Transforms/Utils/SSAUpdaterBulk.h
@@ -14,7 +14,6 @@
 #define LLVM_TRANSFORMS_UTILS_SSAUPDATERBULK_H
 
 #include "llvm/ADT/DenseMap.h"
-#include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/IR/PredIteratorCache.h"
 
diff --git a/linux-x64/clang/include/llvm/Transforms/Utils/ScalarEvolutionExpander.h b/linux-x64/clang/include/llvm/Transforms/Utils/ScalarEvolutionExpander.h
new file mode 100644
index 0000000..547245c
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Transforms/Utils/ScalarEvolutionExpander.h
@@ -0,0 +1,511 @@
+//===---- llvm/Analysis/ScalarEvolutionExpander.h - SCEV Exprs --*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the classes used to generate code from scalar expressions.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_ANALYSIS_SCALAREVOLUTIONEXPANDER_H
+#define LLVM_ANALYSIS_SCALAREVOLUTIONEXPANDER_H
+
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/DenseSet.h"
+#include "llvm/ADT/Optional.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/Analysis/ScalarEvolutionExpressions.h"
+#include "llvm/Analysis/ScalarEvolutionNormalization.h"
+#include "llvm/Analysis/TargetFolder.h"
+#include "llvm/Analysis/TargetTransformInfo.h"
+#include "llvm/IR/IRBuilder.h"
+#include "llvm/IR/ValueHandle.h"
+#include "llvm/Support/CommandLine.h"
+
+namespace llvm {
+extern cl::opt<unsigned> SCEVCheapExpansionBudget;
+
+/// Return true if the given expression is safe to expand in the sense that
+/// all materialized values are safe to speculate anywhere their operands are
+/// defined.
+bool isSafeToExpand(const SCEV *S, ScalarEvolution &SE);
+
+/// Return true if the given expression is safe to expand in the sense that
+/// all materialized values are defined and safe to speculate at the specified
+/// location and their operands are defined at this location.
+bool isSafeToExpandAt(const SCEV *S, const Instruction *InsertionPoint,
+                      ScalarEvolution &SE);
+
+/// struct for holding enough information to help calculate the cost of the
+/// given SCEV when expanded into IR.
+struct SCEVOperand {
+  explicit SCEVOperand(unsigned Opc, int Idx, const SCEV *S) :
+    ParentOpcode(Opc), OperandIdx(Idx), S(S) { }
+  /// LLVM instruction opcode that uses the operand.
+  unsigned ParentOpcode;
+  /// The use index of an expanded instruction.
+  int OperandIdx;
+  /// The SCEV operand to be costed.
+  const SCEV* S;
+};
+
+/// This class uses information about analyze scalars to rewrite expressions
+/// in canonical form.
+///
+/// Clients should create an instance of this class when rewriting is needed,
+/// and destroy it when finished to allow the release of the associated
+/// memory.
+class SCEVExpander : public SCEVVisitor<SCEVExpander, Value *> {
+  ScalarEvolution &SE;
+  const DataLayout &DL;
+
+  // New instructions receive a name to identify them with the current pass.
+  const char *IVName;
+
+  /// Indicates whether LCSSA phis should be created for inserted values.
+  bool PreserveLCSSA;
+
+  // InsertedExpressions caches Values for reuse, so must track RAUW.
+  DenseMap<std::pair<const SCEV *, Instruction *>, TrackingVH<Value>>
+      InsertedExpressions;
+
+  // InsertedValues only flags inserted instructions so needs no RAUW.
+  DenseSet<AssertingVH<Value>> InsertedValues;
+  DenseSet<AssertingVH<Value>> InsertedPostIncValues;
+
+  /// Keep track of the existing IR values re-used during expansion.
+  /// FIXME: Ideally re-used instructions would not be added to
+  /// InsertedValues/InsertedPostIncValues.
+  SmallPtrSet<Value *, 16> ReusedValues;
+
+  /// A memoization of the "relevant" loop for a given SCEV.
+  DenseMap<const SCEV *, const Loop *> RelevantLoops;
+
+  /// Addrecs referring to any of the given loops are expanded in post-inc
+  /// mode. For example, expanding {1,+,1}<L> in post-inc mode returns the add
+  /// instruction that adds one to the phi for {0,+,1}<L>, as opposed to a new
+  /// phi starting at 1. This is only supported in non-canonical mode.
+  PostIncLoopSet PostIncLoops;
+
+  /// When this is non-null, addrecs expanded in the loop it indicates should
+  /// be inserted with increments at IVIncInsertPos.
+  const Loop *IVIncInsertLoop;
+
+  /// When expanding addrecs in the IVIncInsertLoop loop, insert the IV
+  /// increment at this position.
+  Instruction *IVIncInsertPos;
+
+  /// Phis that complete an IV chain. Reuse
+  DenseSet<AssertingVH<PHINode>> ChainedPhis;
+
+  /// When true, SCEVExpander tries to expand expressions in "canonical" form.
+  /// When false, expressions are expanded in a more literal form.
+  ///
+  /// In "canonical" form addrecs are expanded as arithmetic based on a
+  /// canonical induction variable. Note that CanonicalMode doesn't guarantee
+  /// that all expressions are expanded in "canonical" form. For some
+  /// expressions literal mode can be preferred.
+  bool CanonicalMode;
+
+  /// When invoked from LSR, the expander is in "strength reduction" mode. The
+  /// only difference is that phi's are only reused if they are already in
+  /// "expanded" form.
+  bool LSRMode;
+
+  typedef IRBuilder<TargetFolder, IRBuilderCallbackInserter> BuilderType;
+  BuilderType Builder;
+
+  // RAII object that stores the current insertion point and restores it when
+  // the object is destroyed. This includes the debug location.  Duplicated
+  // from InsertPointGuard to add SetInsertPoint() which is used to updated
+  // InsertPointGuards stack when insert points are moved during SCEV
+  // expansion.
+  class SCEVInsertPointGuard {
+    IRBuilderBase &Builder;
+    AssertingVH<BasicBlock> Block;
+    BasicBlock::iterator Point;
+    DebugLoc DbgLoc;
+    SCEVExpander *SE;
+
+    SCEVInsertPointGuard(const SCEVInsertPointGuard &) = delete;
+    SCEVInsertPointGuard &operator=(const SCEVInsertPointGuard &) = delete;
+
+  public:
+    SCEVInsertPointGuard(IRBuilderBase &B, SCEVExpander *SE)
+        : Builder(B), Block(B.GetInsertBlock()), Point(B.GetInsertPoint()),
+          DbgLoc(B.getCurrentDebugLocation()), SE(SE) {
+      SE->InsertPointGuards.push_back(this);
+    }
+
+    ~SCEVInsertPointGuard() {
+      // These guards should always created/destroyed in FIFO order since they
+      // are used to guard lexically scoped blocks of code in
+      // ScalarEvolutionExpander.
+      assert(SE->InsertPointGuards.back() == this);
+      SE->InsertPointGuards.pop_back();
+      Builder.restoreIP(IRBuilderBase::InsertPoint(Block, Point));
+      Builder.SetCurrentDebugLocation(DbgLoc);
+    }
+
+    BasicBlock::iterator GetInsertPoint() const { return Point; }
+    void SetInsertPoint(BasicBlock::iterator I) { Point = I; }
+  };
+
+  /// Stack of pointers to saved insert points, used to keep insert points
+  /// consistent when instructions are moved.
+  SmallVector<SCEVInsertPointGuard *, 8> InsertPointGuards;
+
+#ifndef NDEBUG
+  const char *DebugType;
+#endif
+
+  friend struct SCEVVisitor<SCEVExpander, Value *>;
+
+public:
+  /// Construct a SCEVExpander in "canonical" mode.
+  explicit SCEVExpander(ScalarEvolution &se, const DataLayout &DL,
+                        const char *name, bool PreserveLCSSA = true)
+      : SE(se), DL(DL), IVName(name), PreserveLCSSA(PreserveLCSSA),
+        IVIncInsertLoop(nullptr), IVIncInsertPos(nullptr), CanonicalMode(true),
+        LSRMode(false),
+        Builder(se.getContext(), TargetFolder(DL),
+                IRBuilderCallbackInserter(
+                    [this](Instruction *I) { rememberInstruction(I); })) {
+#ifndef NDEBUG
+    DebugType = "";
+#endif
+  }
+
+  ~SCEVExpander() {
+    // Make sure the insert point guard stack is consistent.
+    assert(InsertPointGuards.empty());
+  }
+
+#ifndef NDEBUG
+  void setDebugType(const char *s) { DebugType = s; }
+#endif
+
+  /// Erase the contents of the InsertedExpressions map so that users trying
+  /// to expand the same expression into multiple BasicBlocks or different
+  /// places within the same BasicBlock can do so.
+  void clear() {
+    InsertedExpressions.clear();
+    InsertedValues.clear();
+    InsertedPostIncValues.clear();
+    ReusedValues.clear();
+    ChainedPhis.clear();
+  }
+
+  /// Return a vector containing all instructions inserted during expansion.
+  SmallVector<Instruction *, 32> getAllInsertedInstructions() const {
+    SmallVector<Instruction *, 32> Result;
+    for (auto &VH : InsertedValues) {
+      Value *V = VH;
+      if (ReusedValues.contains(V))
+        continue;
+      if (auto *Inst = dyn_cast<Instruction>(V))
+        Result.push_back(Inst);
+    }
+    for (auto &VH : InsertedPostIncValues) {
+      Value *V = VH;
+      if (ReusedValues.contains(V))
+        continue;
+      if (auto *Inst = dyn_cast<Instruction>(V))
+        Result.push_back(Inst);
+    }
+
+    return Result;
+  }
+
+  /// Return true for expressions that can't be evaluated at runtime
+  /// within given \b Budget.
+  ///
+  /// At is a parameter which specifies point in code where user is going to
+  /// expand this expression. Sometimes this knowledge can lead to
+  /// a less pessimistic cost estimation.
+  bool isHighCostExpansion(const SCEV *Expr, Loop *L, unsigned Budget,
+                           const TargetTransformInfo *TTI,
+                           const Instruction *At) {
+    assert(TTI && "This function requires TTI to be provided.");
+    assert(At && "This function requires At instruction to be provided.");
+    if (!TTI)      // In assert-less builds, avoid crashing
+      return true; // by always claiming to be high-cost.
+    SmallVector<SCEVOperand, 8> Worklist;
+    SmallPtrSet<const SCEV *, 8> Processed;
+    int BudgetRemaining = Budget * TargetTransformInfo::TCC_Basic;
+    Worklist.emplace_back(-1, -1, Expr);
+    while (!Worklist.empty()) {
+      const SCEVOperand WorkItem = Worklist.pop_back_val();
+      if (isHighCostExpansionHelper(WorkItem, L, *At, BudgetRemaining,
+                                    *TTI, Processed, Worklist))
+        return true;
+    }
+    assert(BudgetRemaining >= 0 && "Should have returned from inner loop.");
+    return false;
+  }
+
+  /// Return the induction variable increment's IV operand.
+  Instruction *getIVIncOperand(Instruction *IncV, Instruction *InsertPos,
+                               bool allowScale);
+
+  /// Utility for hoisting an IV increment.
+  bool hoistIVInc(Instruction *IncV, Instruction *InsertPos);
+
+  /// replace congruent phis with their most canonical representative. Return
+  /// the number of phis eliminated.
+  unsigned replaceCongruentIVs(Loop *L, const DominatorTree *DT,
+                               SmallVectorImpl<WeakTrackingVH> &DeadInsts,
+                               const TargetTransformInfo *TTI = nullptr);
+
+  /// Insert code to directly compute the specified SCEV expression into the
+  /// program.  The code is inserted into the specified block.
+  Value *expandCodeFor(const SCEV *SH, Type *Ty, Instruction *I) {
+    return expandCodeForImpl(SH, Ty, I, true);
+  }
+
+  /// Insert code to directly compute the specified SCEV expression into the
+  /// program.  The code is inserted into the SCEVExpander's current
+  /// insertion point. If a type is specified, the result will be expanded to
+  /// have that type, with a cast if necessary.
+  Value *expandCodeFor(const SCEV *SH, Type *Ty = nullptr) {
+    return expandCodeForImpl(SH, Ty, true);
+  }
+
+  /// Generates a code sequence that evaluates this predicate.  The inserted
+  /// instructions will be at position \p Loc.  The result will be of type i1
+  /// and will have a value of 0 when the predicate is false and 1 otherwise.
+  Value *expandCodeForPredicate(const SCEVPredicate *Pred, Instruction *Loc);
+
+  /// A specialized variant of expandCodeForPredicate, handling the case when
+  /// we are expanding code for a SCEVEqualPredicate.
+  Value *expandEqualPredicate(const SCEVEqualPredicate *Pred, Instruction *Loc);
+
+  /// Generates code that evaluates if the \p AR expression will overflow.
+  Value *generateOverflowCheck(const SCEVAddRecExpr *AR, Instruction *Loc,
+                               bool Signed);
+
+  /// A specialized variant of expandCodeForPredicate, handling the case when
+  /// we are expanding code for a SCEVWrapPredicate.
+  Value *expandWrapPredicate(const SCEVWrapPredicate *P, Instruction *Loc);
+
+  /// A specialized variant of expandCodeForPredicate, handling the case when
+  /// we are expanding code for a SCEVUnionPredicate.
+  Value *expandUnionPredicate(const SCEVUnionPredicate *Pred, Instruction *Loc);
+
+  /// Set the current IV increment loop and position.
+  void setIVIncInsertPos(const Loop *L, Instruction *Pos) {
+    assert(!CanonicalMode &&
+           "IV increment positions are not supported in CanonicalMode");
+    IVIncInsertLoop = L;
+    IVIncInsertPos = Pos;
+  }
+
+  /// Enable post-inc expansion for addrecs referring to the given
+  /// loops. Post-inc expansion is only supported in non-canonical mode.
+  void setPostInc(const PostIncLoopSet &L) {
+    assert(!CanonicalMode &&
+           "Post-inc expansion is not supported in CanonicalMode");
+    PostIncLoops = L;
+  }
+
+  /// Disable all post-inc expansion.
+  void clearPostInc() {
+    PostIncLoops.clear();
+
+    // When we change the post-inc loop set, cached expansions may no
+    // longer be valid.
+    InsertedPostIncValues.clear();
+  }
+
+  /// Disable the behavior of expanding expressions in canonical form rather
+  /// than in a more literal form. Non-canonical mode is useful for late
+  /// optimization passes.
+  void disableCanonicalMode() { CanonicalMode = false; }
+
+  void enableLSRMode() { LSRMode = true; }
+
+  /// Set the current insertion point. This is useful if multiple calls to
+  /// expandCodeFor() are going to be made with the same insert point and the
+  /// insert point may be moved during one of the expansions (e.g. if the
+  /// insert point is not a block terminator).
+  void setInsertPoint(Instruction *IP) {
+    assert(IP);
+    Builder.SetInsertPoint(IP);
+  }
+
+  /// Clear the current insertion point. This is useful if the instruction
+  /// that had been serving as the insertion point may have been deleted.
+  void clearInsertPoint() { Builder.ClearInsertionPoint(); }
+
+  /// Set location information used by debugging information.
+  void SetCurrentDebugLocation(DebugLoc L) {
+    Builder.SetCurrentDebugLocation(std::move(L));
+  }
+
+  /// Get location information used by debugging information.
+  DebugLoc getCurrentDebugLocation() const {
+    return Builder.getCurrentDebugLocation();
+  }
+
+  /// Return true if the specified instruction was inserted by the code
+  /// rewriter.  If so, the client should not modify the instruction. Note that
+  /// this also includes instructions re-used during expansion.
+  bool isInsertedInstruction(Instruction *I) const {
+    return InsertedValues.count(I) || InsertedPostIncValues.count(I);
+  }
+
+  void setChainedPhi(PHINode *PN) { ChainedPhis.insert(PN); }
+
+  /// Try to find the ValueOffsetPair for S. The function is mainly used to
+  /// check whether S can be expanded cheaply.  If this returns a non-None
+  /// value, we know we can codegen the `ValueOffsetPair` into a suitable
+  /// expansion identical with S so that S can be expanded cheaply.
+  ///
+  /// L is a hint which tells in which loop to look for the suitable value.
+  /// On success return value which is equivalent to the expanded S at point
+  /// At. Return nullptr if value was not found.
+  ///
+  /// Note that this function does not perform an exhaustive search. I.e if it
+  /// didn't find any value it does not mean that there is no such value.
+  ///
+  Optional<ScalarEvolution::ValueOffsetPair>
+  getRelatedExistingExpansion(const SCEV *S, const Instruction *At, Loop *L);
+
+  /// Returns a suitable insert point after \p I, that dominates \p
+  /// MustDominate. Skips instructions inserted by the expander.
+  BasicBlock::iterator findInsertPointAfter(Instruction *I,
+                                            Instruction *MustDominate);
+
+private:
+  LLVMContext &getContext() const { return SE.getContext(); }
+
+  /// Insert code to directly compute the specified SCEV expression into the
+  /// program. The code is inserted into the SCEVExpander's current
+  /// insertion point. If a type is specified, the result will be expanded to
+  /// have that type, with a cast if necessary. If \p Root is true, this
+  /// indicates that \p SH is the top-level expression to expand passed from
+  /// an external client call.
+  Value *expandCodeForImpl(const SCEV *SH, Type *Ty, bool Root);
+
+  /// Insert code to directly compute the specified SCEV expression into the
+  /// program. The code is inserted into the specified block. If \p
+  /// Root is true, this indicates that \p SH is the top-level expression to
+  /// expand passed from an external client call.
+  Value *expandCodeForImpl(const SCEV *SH, Type *Ty, Instruction *I, bool Root);
+
+  /// Recursive helper function for isHighCostExpansion.
+  bool isHighCostExpansionHelper(
+    const SCEVOperand &WorkItem, Loop *L, const Instruction &At,
+    int &BudgetRemaining, const TargetTransformInfo &TTI,
+    SmallPtrSetImpl<const SCEV *> &Processed,
+    SmallVectorImpl<SCEVOperand> &Worklist);
+
+  /// Insert the specified binary operator, doing a small amount of work to
+  /// avoid inserting an obviously redundant operation, and hoisting to an
+  /// outer loop when the opportunity is there and it is safe.
+  Value *InsertBinop(Instruction::BinaryOps Opcode, Value *LHS, Value *RHS,
+                     SCEV::NoWrapFlags Flags, bool IsSafeToHoist);
+
+  /// Arrange for there to be a cast of V to Ty at IP, reusing an existing
+  /// cast if a suitable one exists, moving an existing cast if a suitable one
+  /// exists but isn't in the right place, or creating a new one.
+  Value *ReuseOrCreateCast(Value *V, Type *Ty, Instruction::CastOps Op,
+                           BasicBlock::iterator IP);
+
+  /// Insert a cast of V to the specified type, which must be possible with a
+  /// noop cast, doing what we can to share the casts.
+  Value *InsertNoopCastOfTo(Value *V, Type *Ty);
+
+  /// Expand a SCEVAddExpr with a pointer type into a GEP instead of using
+  /// ptrtoint+arithmetic+inttoptr.
+  Value *expandAddToGEP(const SCEV *const *op_begin, const SCEV *const *op_end,
+                        PointerType *PTy, Type *Ty, Value *V);
+  Value *expandAddToGEP(const SCEV *Op, PointerType *PTy, Type *Ty, Value *V);
+
+  /// Find a previous Value in ExprValueMap for expand.
+  ScalarEvolution::ValueOffsetPair
+  FindValueInExprValueMap(const SCEV *S, const Instruction *InsertPt);
+
+  Value *expand(const SCEV *S);
+
+  /// Determine the most "relevant" loop for the given SCEV.
+  const Loop *getRelevantLoop(const SCEV *);
+
+  Value *visitConstant(const SCEVConstant *S) { return S->getValue(); }
+
+  Value *visitPtrToIntExpr(const SCEVPtrToIntExpr *S);
+
+  Value *visitTruncateExpr(const SCEVTruncateExpr *S);
+
+  Value *visitZeroExtendExpr(const SCEVZeroExtendExpr *S);
+
+  Value *visitSignExtendExpr(const SCEVSignExtendExpr *S);
+
+  Value *visitAddExpr(const SCEVAddExpr *S);
+
+  Value *visitMulExpr(const SCEVMulExpr *S);
+
+  Value *visitUDivExpr(const SCEVUDivExpr *S);
+
+  Value *visitAddRecExpr(const SCEVAddRecExpr *S);
+
+  Value *visitSMaxExpr(const SCEVSMaxExpr *S);
+
+  Value *visitUMaxExpr(const SCEVUMaxExpr *S);
+
+  Value *visitSMinExpr(const SCEVSMinExpr *S);
+
+  Value *visitUMinExpr(const SCEVUMinExpr *S);
+
+  Value *visitUnknown(const SCEVUnknown *S) { return S->getValue(); }
+
+  void rememberInstruction(Value *I);
+
+  bool isNormalAddRecExprPHI(PHINode *PN, Instruction *IncV, const Loop *L);
+
+  bool isExpandedAddRecExprPHI(PHINode *PN, Instruction *IncV, const Loop *L);
+
+  Value *expandAddRecExprLiterally(const SCEVAddRecExpr *);
+  PHINode *getAddRecExprPHILiterally(const SCEVAddRecExpr *Normalized,
+                                     const Loop *L, Type *ExpandTy, Type *IntTy,
+                                     Type *&TruncTy, bool &InvertStep);
+  Value *expandIVInc(PHINode *PN, Value *StepV, const Loop *L, Type *ExpandTy,
+                     Type *IntTy, bool useSubtract);
+
+  void hoistBeforePos(DominatorTree *DT, Instruction *InstToHoist,
+                      Instruction *Pos, PHINode *LoopPhi);
+
+  void fixupInsertPoints(Instruction *I);
+
+  /// If required, create LCSSA PHIs for \p Users' operand \p OpIdx. If new
+  /// LCSSA PHIs have been created, return the LCSSA PHI available at \p User.
+  /// If no PHIs have been created, return the unchanged operand \p OpIdx.
+  Value *fixupLCSSAFormFor(Instruction *User, unsigned OpIdx);
+};
+
+/// Helper to remove instructions inserted during SCEV expansion, unless they
+/// are marked as used.
+class SCEVExpanderCleaner {
+  SCEVExpander &Expander;
+
+  DominatorTree &DT;
+
+  /// Indicates whether the result of the expansion is used. If false, the
+  /// instructions added during expansion are removed.
+  bool ResultUsed;
+
+public:
+  SCEVExpanderCleaner(SCEVExpander &Expander, DominatorTree &DT)
+      : Expander(Expander), DT(DT), ResultUsed(false) {}
+
+  ~SCEVExpanderCleaner();
+
+  /// Indicate that the result of the expansion is used.
+  void markResultUsed() { ResultUsed = true; }
+};
+} // namespace llvm
+
+#endif
diff --git a/linux-x64/clang/include/llvm/Transforms/Utils/SimplifyCFGOptions.h b/linux-x64/clang/include/llvm/Transforms/Utils/SimplifyCFGOptions.h
new file mode 100644
index 0000000..fb3a749
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Transforms/Utils/SimplifyCFGOptions.h
@@ -0,0 +1,77 @@
+//===- SimplifyCFGOptions.h - Control structure for SimplifyCFG -*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// A set of parameters used to control the transforms in the SimplifyCFG pass.
+// Options may change depending on the position in the optimization pipeline.
+// For example, canonical form that includes switches and branches may later be
+// replaced by lookup tables and selects.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_UTILS_SIMPLIFYCFGOPTIONS_H
+#define LLVM_TRANSFORMS_UTILS_SIMPLIFYCFGOPTIONS_H
+
+namespace llvm {
+
+class AssumptionCache;
+
+struct SimplifyCFGOptions {
+  int BonusInstThreshold = 1;
+  bool ForwardSwitchCondToPhi = false;
+  bool ConvertSwitchToLookupTable = false;
+  bool NeedCanonicalLoop = true;
+  bool HoistCommonInsts = false;
+  bool SinkCommonInsts = false;
+  bool SimplifyCondBranch = true;
+  bool FoldTwoEntryPHINode = true;
+
+  AssumptionCache *AC = nullptr;
+
+  // Support 'builder' pattern to set members by name at construction time.
+  SimplifyCFGOptions &bonusInstThreshold(int I) {
+    BonusInstThreshold = I;
+    return *this;
+  }
+  SimplifyCFGOptions &forwardSwitchCondToPhi(bool B) {
+    ForwardSwitchCondToPhi = B;
+    return *this;
+  }
+  SimplifyCFGOptions &convertSwitchToLookupTable(bool B) {
+    ConvertSwitchToLookupTable = B;
+    return *this;
+  }
+  SimplifyCFGOptions &needCanonicalLoops(bool B) {
+    NeedCanonicalLoop = B;
+    return *this;
+  }
+  SimplifyCFGOptions &hoistCommonInsts(bool B) {
+    HoistCommonInsts = B;
+    return *this;
+  }
+  SimplifyCFGOptions &sinkCommonInsts(bool B) {
+    SinkCommonInsts = B;
+    return *this;
+  }
+  SimplifyCFGOptions &setAssumptionCache(AssumptionCache *Cache) {
+    AC = Cache;
+    return *this;
+  }
+  SimplifyCFGOptions &setSimplifyCondBranch(bool B) {
+    SimplifyCondBranch = B;
+    return *this;
+  }
+
+  SimplifyCFGOptions &setFoldTwoEntryPHINode(bool B) {
+    FoldTwoEntryPHINode = B;
+    return *this;
+  }
+};
+
+} // namespace llvm
+
+#endif // LLVM_TRANSFORMS_UTILS_SIMPLIFYCFGOPTIONS_H
diff --git a/linux-x64/clang/include/llvm/Transforms/Utils/SimplifyIndVar.h b/linux-x64/clang/include/llvm/Transforms/Utils/SimplifyIndVar.h
index dec73ef..4ba56fb 100644
--- a/linux-x64/clang/include/llvm/Transforms/Utils/SimplifyIndVar.h
+++ b/linux-x64/clang/include/llvm/Transforms/Utils/SimplifyIndVar.h
@@ -15,6 +15,8 @@
 #ifndef LLVM_TRANSFORMS_UTILS_SIMPLIFYINDVAR_H
 #define LLVM_TRANSFORMS_UTILS_SIMPLIFYINDVAR_H
 
+#include "llvm/Analysis/ScalarEvolutionExpressions.h"
+#include "llvm/IR/ConstantRange.h"
 #include "llvm/IR/ValueHandle.h"
 
 namespace llvm {
@@ -26,6 +28,7 @@
 class PHINode;
 class ScalarEvolution;
 class SCEVExpander;
+class TargetTransformInfo;
 
 /// Interface for visiting interesting IV users that are recognized but not
 /// simplified by this utility.
@@ -46,13 +49,36 @@
 /// simplifyUsersOfIV - Simplify instructions that use this induction variable
 /// by using ScalarEvolution to analyze the IV's recurrence.
 bool simplifyUsersOfIV(PHINode *CurrIV, ScalarEvolution *SE, DominatorTree *DT,
-                       LoopInfo *LI, SmallVectorImpl<WeakTrackingVH> &Dead,
+                       LoopInfo *LI, const TargetTransformInfo *TTI,
+                       SmallVectorImpl<WeakTrackingVH> &Dead,
                        SCEVExpander &Rewriter, IVVisitor *V = nullptr);
 
 /// SimplifyLoopIVs - Simplify users of induction variables within this
 /// loop. This does not actually change or add IVs.
 bool simplifyLoopIVs(Loop *L, ScalarEvolution *SE, DominatorTree *DT,
-                     LoopInfo *LI, SmallVectorImpl<WeakTrackingVH> &Dead);
+                     LoopInfo *LI, const TargetTransformInfo *TTI,
+                     SmallVectorImpl<WeakTrackingVH> &Dead);
+
+/// Collect information about induction variables that are used by sign/zero
+/// extend operations. This information is recorded by CollectExtend and provides
+/// the input to WidenIV.
+struct WideIVInfo {
+  PHINode *NarrowIV = nullptr;
+
+  // Widest integer type created [sz]ext
+  Type *WidestNativeType = nullptr;
+
+  // Was a sext user seen before a zext?
+  bool IsSigned = false;
+};
+
+/// Widen Induction Variables - Extend the width of an IV to cover its
+/// widest uses.
+PHINode *createWideIV(const WideIVInfo &WI,
+    LoopInfo *LI, ScalarEvolution *SE, SCEVExpander &Rewriter,
+    DominatorTree *DT, SmallVectorImpl<WeakTrackingVH> &DeadInsts,
+    unsigned &NumElimExt, unsigned &NumWidened,
+    bool HasGuards, bool UsePostIncrementRanges);
 
 } // end namespace llvm
 
diff --git a/linux-x64/clang/include/llvm/Transforms/Utils/SimplifyLibCalls.h b/linux-x64/clang/include/llvm/Transforms/Utils/SimplifyLibCalls.h
index 2572094..8703434 100644
--- a/linux-x64/clang/include/llvm/Transforms/Utils/SimplifyLibCalls.h
+++ b/linux-x64/clang/include/llvm/Transforms/Utils/SimplifyLibCalls.h
@@ -16,7 +16,6 @@
 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
-#include "llvm/IR/IRBuilder.h"
 
 namespace llvm {
 class StringRef;
@@ -24,8 +23,7 @@
 class CallInst;
 class DataLayout;
 class Instruction;
-class TargetLibraryInfo;
-class BasicBlock;
+class IRBuilderBase;
 class Function;
 class OptimizationRemarkEmitter;
 class BlockFrequencyInfo;
@@ -50,25 +48,27 @@
   /// optimal value to replace the instruction with or 0 if a more
   /// optimal form can't be found.
   /// The call must not be an indirect call.
-  Value *optimizeCall(CallInst *CI);
+  Value *optimizeCall(CallInst *CI, IRBuilderBase &B);
 
 private:
-  Value *optimizeMemCpyChk(CallInst *CI, IRBuilder<> &B);
-  Value *optimizeMemMoveChk(CallInst *CI, IRBuilder<> &B);
-  Value *optimizeMemSetChk(CallInst *CI, IRBuilder<> &B);
+  Value *optimizeMemCpyChk(CallInst *CI, IRBuilderBase &B);
+  Value *optimizeMemMoveChk(CallInst *CI, IRBuilderBase &B);
+  Value *optimizeMemSetChk(CallInst *CI, IRBuilderBase &B);
 
   /// Str/Stp cpy are similar enough to be handled in the same functions.
-  Value *optimizeStrpCpyChk(CallInst *CI, IRBuilder<> &B, LibFunc Func);
-  Value *optimizeStrpNCpyChk(CallInst *CI, IRBuilder<> &B, LibFunc Func);
-  Value *optimizeMemCCpyChk(CallInst *CI, IRBuilder<> &B);
-  Value *optimizeSNPrintfChk(CallInst *CI, IRBuilder<> &B);
-  Value *optimizeSPrintfChk(CallInst *CI,IRBuilder<> &B);
-  Value *optimizeStrCatChk(CallInst *CI, IRBuilder<> &B);
-  Value *optimizeStrLCat(CallInst *CI, IRBuilder<> &B);
-  Value *optimizeStrNCatChk(CallInst *CI, IRBuilder<> &B);
-  Value *optimizeStrLCpyChk(CallInst *CI, IRBuilder<> &B);
-  Value *optimizeVSNPrintfChk(CallInst *CI, IRBuilder<> &B);
-  Value *optimizeVSPrintfChk(CallInst *CI, IRBuilder<> &B);
+  Value *optimizeStrpCpyChk(CallInst *CI, IRBuilderBase &B, LibFunc Func);
+  Value *optimizeStrpNCpyChk(CallInst *CI, IRBuilderBase &B, LibFunc Func);
+  Value *optimizeStrLenChk(CallInst *CI, IRBuilderBase &B);
+  Value *optimizeMemPCpyChk(CallInst *CI, IRBuilderBase &B);
+  Value *optimizeMemCCpyChk(CallInst *CI, IRBuilderBase &B);
+  Value *optimizeSNPrintfChk(CallInst *CI, IRBuilderBase &B);
+  Value *optimizeSPrintfChk(CallInst *CI,IRBuilderBase &B);
+  Value *optimizeStrCatChk(CallInst *CI, IRBuilderBase &B);
+  Value *optimizeStrLCat(CallInst *CI, IRBuilderBase &B);
+  Value *optimizeStrNCatChk(CallInst *CI, IRBuilderBase &B);
+  Value *optimizeStrLCpyChk(CallInst *CI, IRBuilderBase &B);
+  Value *optimizeVSNPrintfChk(CallInst *CI, IRBuilderBase &B);
+  Value *optimizeVSPrintfChk(CallInst *CI, IRBuilderBase &B);
 
   /// Checks whether the call \p CI to a fortified libcall is foldable
   /// to the non-fortified version.
@@ -126,7 +126,13 @@
   /// Erase an instruction from its parent with our eraser.
   void eraseFromParent(Instruction *I);
 
-  Value *foldMallocMemset(CallInst *Memset, IRBuilder<> &B);
+  /// Replace an instruction with a value and erase it from its parent.
+  void substituteInParent(Instruction *I, Value *With) {
+    replaceAllUsesWith(I, With);
+    eraseFromParent(I);
+  }
+
+  Value *foldMallocMemset(CallInst *Memset, IRBuilderBase &B);
 
 public:
   LibCallSimplifier(
@@ -144,94 +150,96 @@
   /// other instructions that use the given instruction were modified
   /// and the given instruction is dead.
   /// The call must not be an indirect call.
-  Value *optimizeCall(CallInst *CI);
+  Value *optimizeCall(CallInst *CI, IRBuilderBase &B);
 
 private:
   // String and Memory Library Call Optimizations
-  Value *optimizeStrCat(CallInst *CI, IRBuilder<> &B);
-  Value *optimizeStrNCat(CallInst *CI, IRBuilder<> &B);
-  Value *optimizeStrChr(CallInst *CI, IRBuilder<> &B);
-  Value *optimizeStrRChr(CallInst *CI, IRBuilder<> &B);
-  Value *optimizeStrCmp(CallInst *CI, IRBuilder<> &B);
-  Value *optimizeStrNCmp(CallInst *CI, IRBuilder<> &B);
-  Value *optimizeStrCpy(CallInst *CI, IRBuilder<> &B);
-  Value *optimizeStpCpy(CallInst *CI, IRBuilder<> &B);
-  Value *optimizeStrNCpy(CallInst *CI, IRBuilder<> &B);
-  Value *optimizeStrLen(CallInst *CI, IRBuilder<> &B);
-  Value *optimizeStrPBrk(CallInst *CI, IRBuilder<> &B);
-  Value *optimizeStrTo(CallInst *CI, IRBuilder<> &B);
-  Value *optimizeStrSpn(CallInst *CI, IRBuilder<> &B);
-  Value *optimizeStrCSpn(CallInst *CI, IRBuilder<> &B);
-  Value *optimizeStrStr(CallInst *CI, IRBuilder<> &B);
-  Value *optimizeMemChr(CallInst *CI, IRBuilder<> &B);
-  Value *optimizeMemCmp(CallInst *CI, IRBuilder<> &B);
-  Value *optimizeBCmp(CallInst *CI, IRBuilder<> &B);
-  Value *optimizeMemCmpBCmpCommon(CallInst *CI, IRBuilder<> &B);
-  Value *optimizeMemCpy(CallInst *CI, IRBuilder<> &B);
-  Value *optimizeMemMove(CallInst *CI, IRBuilder<> &B);
-  Value *optimizeMemSet(CallInst *CI, IRBuilder<> &B);
-  Value *optimizeRealloc(CallInst *CI, IRBuilder<> &B);
-  Value *optimizeWcslen(CallInst *CI, IRBuilder<> &B);
+  Value *optimizeStrCat(CallInst *CI, IRBuilderBase &B);
+  Value *optimizeStrNCat(CallInst *CI, IRBuilderBase &B);
+  Value *optimizeStrChr(CallInst *CI, IRBuilderBase &B);
+  Value *optimizeStrRChr(CallInst *CI, IRBuilderBase &B);
+  Value *optimizeStrCmp(CallInst *CI, IRBuilderBase &B);
+  Value *optimizeStrNCmp(CallInst *CI, IRBuilderBase &B);
+  Value *optimizeStrNDup(CallInst *CI, IRBuilderBase &B);
+  Value *optimizeStrCpy(CallInst *CI, IRBuilderBase &B);
+  Value *optimizeStpCpy(CallInst *CI, IRBuilderBase &B);
+  Value *optimizeStrNCpy(CallInst *CI, IRBuilderBase &B);
+  Value *optimizeStrLen(CallInst *CI, IRBuilderBase &B);
+  Value *optimizeStrPBrk(CallInst *CI, IRBuilderBase &B);
+  Value *optimizeStrTo(CallInst *CI, IRBuilderBase &B);
+  Value *optimizeStrSpn(CallInst *CI, IRBuilderBase &B);
+  Value *optimizeStrCSpn(CallInst *CI, IRBuilderBase &B);
+  Value *optimizeStrStr(CallInst *CI, IRBuilderBase &B);
+  Value *optimizeMemChr(CallInst *CI, IRBuilderBase &B);
+  Value *optimizeMemRChr(CallInst *CI, IRBuilderBase &B);
+  Value *optimizeMemCmp(CallInst *CI, IRBuilderBase &B);
+  Value *optimizeBCmp(CallInst *CI, IRBuilderBase &B);
+  Value *optimizeMemCmpBCmpCommon(CallInst *CI, IRBuilderBase &B);
+  Value *optimizeMemCCpy(CallInst *CI, IRBuilderBase &B);
+  Value *optimizeMemPCpy(CallInst *CI, IRBuilderBase &B);
+  Value *optimizeMemCpy(CallInst *CI, IRBuilderBase &B);
+  Value *optimizeMemMove(CallInst *CI, IRBuilderBase &B);
+  Value *optimizeMemSet(CallInst *CI, IRBuilderBase &B);
+  Value *optimizeRealloc(CallInst *CI, IRBuilderBase &B);
+  Value *optimizeWcslen(CallInst *CI, IRBuilderBase &B);
+  Value *optimizeBCopy(CallInst *CI, IRBuilderBase &B);
   // Wrapper for all String/Memory Library Call Optimizations
-  Value *optimizeStringMemoryLibCall(CallInst *CI, IRBuilder<> &B);
+  Value *optimizeStringMemoryLibCall(CallInst *CI, IRBuilderBase &B);
 
   // Math Library Optimizations
-  Value *optimizeCAbs(CallInst *CI, IRBuilder<> &B);
-  Value *optimizePow(CallInst *CI, IRBuilder<> &B);
-  Value *replacePowWithExp(CallInst *Pow, IRBuilder<> &B);
-  Value *replacePowWithSqrt(CallInst *Pow, IRBuilder<> &B);
-  Value *optimizeExp2(CallInst *CI, IRBuilder<> &B);
-  Value *optimizeFMinFMax(CallInst *CI, IRBuilder<> &B);
-  Value *optimizeLog(CallInst *CI, IRBuilder<> &B);
-  Value *optimizeSqrt(CallInst *CI, IRBuilder<> &B);
-  Value *optimizeSinCosPi(CallInst *CI, IRBuilder<> &B);
-  Value *optimizeTan(CallInst *CI, IRBuilder<> &B);
+  Value *optimizeCAbs(CallInst *CI, IRBuilderBase &B);
+  Value *optimizePow(CallInst *CI, IRBuilderBase &B);
+  Value *replacePowWithExp(CallInst *Pow, IRBuilderBase &B);
+  Value *replacePowWithSqrt(CallInst *Pow, IRBuilderBase &B);
+  Value *optimizeExp2(CallInst *CI, IRBuilderBase &B);
+  Value *optimizeFMinFMax(CallInst *CI, IRBuilderBase &B);
+  Value *optimizeLog(CallInst *CI, IRBuilderBase &B);
+  Value *optimizeSqrt(CallInst *CI, IRBuilderBase &B);
+  Value *optimizeSinCosPi(CallInst *CI, IRBuilderBase &B);
+  Value *optimizeTan(CallInst *CI, IRBuilderBase &B);
   // Wrapper for all floating point library call optimizations
   Value *optimizeFloatingPointLibCall(CallInst *CI, LibFunc Func,
-                                      IRBuilder<> &B);
+                                      IRBuilderBase &B);
 
   // Integer Library Call Optimizations
-  Value *optimizeFFS(CallInst *CI, IRBuilder<> &B);
-  Value *optimizeFls(CallInst *CI, IRBuilder<> &B);
-  Value *optimizeAbs(CallInst *CI, IRBuilder<> &B);
-  Value *optimizeIsDigit(CallInst *CI, IRBuilder<> &B);
-  Value *optimizeIsAscii(CallInst *CI, IRBuilder<> &B);
-  Value *optimizeToAscii(CallInst *CI, IRBuilder<> &B);
-  Value *optimizeAtoi(CallInst *CI, IRBuilder<> &B);
-  Value *optimizeStrtol(CallInst *CI, IRBuilder<> &B);
+  Value *optimizeFFS(CallInst *CI, IRBuilderBase &B);
+  Value *optimizeFls(CallInst *CI, IRBuilderBase &B);
+  Value *optimizeAbs(CallInst *CI, IRBuilderBase &B);
+  Value *optimizeIsDigit(CallInst *CI, IRBuilderBase &B);
+  Value *optimizeIsAscii(CallInst *CI, IRBuilderBase &B);
+  Value *optimizeToAscii(CallInst *CI, IRBuilderBase &B);
+  Value *optimizeAtoi(CallInst *CI, IRBuilderBase &B);
+  Value *optimizeStrtol(CallInst *CI, IRBuilderBase &B);
 
   // Formatting and IO Library Call Optimizations
-  Value *optimizeErrorReporting(CallInst *CI, IRBuilder<> &B,
+  Value *optimizeErrorReporting(CallInst *CI, IRBuilderBase &B,
                                 int StreamArg = -1);
-  Value *optimizePrintF(CallInst *CI, IRBuilder<> &B);
-  Value *optimizeSPrintF(CallInst *CI, IRBuilder<> &B);
-  Value *optimizeSnPrintF(CallInst *CI, IRBuilder<> &B);
-  Value *optimizeFPrintF(CallInst *CI, IRBuilder<> &B);
-  Value *optimizeFWrite(CallInst *CI, IRBuilder<> &B);
-  Value *optimizeFRead(CallInst *CI, IRBuilder<> &B);
-  Value *optimizeFPuts(CallInst *CI, IRBuilder<> &B);
-  Value *optimizeFGets(CallInst *CI, IRBuilder<> &B);
-  Value *optimizeFPutc(CallInst *CI, IRBuilder<> &B);
-  Value *optimizeFGetc(CallInst *CI, IRBuilder<> &B);
-  Value *optimizePuts(CallInst *CI, IRBuilder<> &B);
+  Value *optimizePrintF(CallInst *CI, IRBuilderBase &B);
+  Value *optimizeSPrintF(CallInst *CI, IRBuilderBase &B);
+  Value *optimizeSnPrintF(CallInst *CI, IRBuilderBase &B);
+  Value *optimizeFPrintF(CallInst *CI, IRBuilderBase &B);
+  Value *optimizeFWrite(CallInst *CI, IRBuilderBase &B);
+  Value *optimizeFPuts(CallInst *CI, IRBuilderBase &B);
+  Value *optimizePuts(CallInst *CI, IRBuilderBase &B);
 
   // Helper methods
-  Value *emitStrLenMemCpy(Value *Src, Value *Dst, uint64_t Len, IRBuilder<> &B);
+  Value *emitStrLenMemCpy(Value *Src, Value *Dst, uint64_t Len,
+                          IRBuilderBase &B);
   void classifyArgUse(Value *Val, Function *F, bool IsFloat,
                       SmallVectorImpl<CallInst *> &SinCalls,
                       SmallVectorImpl<CallInst *> &CosCalls,
                       SmallVectorImpl<CallInst *> &SinCosCalls);
-  Value *optimizePrintFString(CallInst *CI, IRBuilder<> &B);
-  Value *optimizeSPrintFString(CallInst *CI, IRBuilder<> &B);
-  Value *optimizeSnPrintFString(CallInst *CI, IRBuilder<> &B);
-  Value *optimizeFPrintFString(CallInst *CI, IRBuilder<> &B);
+  Value *optimizePrintFString(CallInst *CI, IRBuilderBase &B);
+  Value *optimizeSPrintFString(CallInst *CI, IRBuilderBase &B);
+  Value *optimizeSnPrintFString(CallInst *CI, IRBuilderBase &B);
+  Value *optimizeFPrintFString(CallInst *CI, IRBuilderBase &B);
 
   /// hasFloatVersion - Checks if there is a float version of the specified
   /// function by checking for an existing function with name FuncName + f
   bool hasFloatVersion(StringRef FuncName);
 
   /// Shared code to optimize strlen+wcslen.
-  Value *optimizeStringLength(CallInst *CI, IRBuilder<> &B, unsigned CharSize);
+  Value *optimizeStringLength(CallInst *CI, IRBuilderBase &B, unsigned CharSize);
 };
 } // End llvm namespace
 
diff --git a/linux-x64/clang/include/llvm/Transforms/Utils/SizeOpts.h b/linux-x64/clang/include/llvm/Transforms/Utils/SizeOpts.h
index 1a052c6..3c1173b 100644
--- a/linux-x64/clang/include/llvm/Transforms/Utils/SizeOpts.h
+++ b/linux-x64/clang/include/llvm/Transforms/Utils/SizeOpts.h
@@ -13,21 +13,94 @@
 #ifndef LLVM_TRANSFORMS_UTILS_SIZEOPTS_H
 #define LLVM_TRANSFORMS_UTILS_SIZEOPTS_H
 
+#include "llvm/Analysis/BlockFrequencyInfo.h"
+#include "llvm/Analysis/ProfileSummaryInfo.h"
+#include "llvm/Support/CommandLine.h"
+
+extern llvm::cl::opt<bool> EnablePGSO;
+extern llvm::cl::opt<bool> PGSOLargeWorkingSetSizeOnly;
+extern llvm::cl::opt<bool> PGSOColdCodeOnly;
+extern llvm::cl::opt<bool> PGSOColdCodeOnlyForInstrPGO;
+extern llvm::cl::opt<bool> PGSOColdCodeOnlyForSamplePGO;
+extern llvm::cl::opt<bool> PGSOColdCodeOnlyForPartialSamplePGO;
+extern llvm::cl::opt<bool> ForcePGSO;
+extern llvm::cl::opt<int> PgsoCutoffInstrProf;
+extern llvm::cl::opt<int> PgsoCutoffSampleProf;
+
 namespace llvm {
 
 class BasicBlock;
 class BlockFrequencyInfo;
 class Function;
-class ProfileSummaryInfo;
 
-/// Returns true if function \p F is suggested to be size-optimized base on the
+enum class PGSOQueryType {
+  IRPass, // A query call from an IR-level transform pass.
+  Test,   // A query call from a unit test.
+  Other,  // Others.
+};
+
+static inline bool isPGSOColdCodeOnly(ProfileSummaryInfo *PSI) {
+  return PGSOColdCodeOnly ||
+         (PSI->hasInstrumentationProfile() && PGSOColdCodeOnlyForInstrPGO) ||
+         (PSI->hasSampleProfile() &&
+          ((!PSI->hasPartialSampleProfile() && PGSOColdCodeOnlyForSamplePGO) ||
+           (PSI->hasPartialSampleProfile() &&
+            PGSOColdCodeOnlyForPartialSamplePGO))) ||
+         (PGSOLargeWorkingSetSizeOnly && !PSI->hasLargeWorkingSetSize());
+}
+
+template<typename AdapterT, typename FuncT, typename BFIT>
+bool shouldFuncOptimizeForSizeImpl(const FuncT *F, ProfileSummaryInfo *PSI,
+                                   BFIT *BFI, PGSOQueryType QueryType) {
+  assert(F);
+  if (!PSI || !BFI || !PSI->hasProfileSummary())
+    return false;
+  if (ForcePGSO)
+    return true;
+  if (!EnablePGSO)
+    return false;
+  if (isPGSOColdCodeOnly(PSI))
+    return AdapterT::isFunctionColdInCallGraph(F, PSI, *BFI);
+  if (PSI->hasSampleProfile())
+    // The "isCold" check seems to work better for Sample PGO as it could have
+    // many profile-unannotated functions.
+    return AdapterT::isFunctionColdInCallGraphNthPercentile(
+        PgsoCutoffSampleProf, F, PSI, *BFI);
+  return !AdapterT::isFunctionHotInCallGraphNthPercentile(PgsoCutoffInstrProf,
+                                                          F, PSI, *BFI);
+}
+
+template<typename AdapterT, typename BlockTOrBlockFreq, typename BFIT>
+bool shouldOptimizeForSizeImpl(BlockTOrBlockFreq BBOrBlockFreq, ProfileSummaryInfo *PSI,
+                               BFIT *BFI, PGSOQueryType QueryType) {
+  if (!PSI || !BFI || !PSI->hasProfileSummary())
+    return false;
+  if (ForcePGSO)
+    return true;
+  if (!EnablePGSO)
+    return false;
+  if (isPGSOColdCodeOnly(PSI))
+    return AdapterT::isColdBlock(BBOrBlockFreq, PSI, BFI);
+  if (PSI->hasSampleProfile())
+    // The "isCold" check seems to work better for Sample PGO as it could have
+    // many profile-unannotated functions.
+    return AdapterT::isColdBlockNthPercentile(PgsoCutoffSampleProf,
+                                              BBOrBlockFreq, PSI, BFI);
+  return !AdapterT::isHotBlockNthPercentile(PgsoCutoffInstrProf, BBOrBlockFreq,
+                                            PSI, BFI);
+}
+
+/// Returns true if function \p F is suggested to be size-optimized based on the
 /// profile.
-bool shouldOptimizeForSize(Function *F, ProfileSummaryInfo *PSI,
-                           BlockFrequencyInfo *BFI);
-/// Returns true if basic block \p BB is suggested to be size-optimized base
-/// on the profile.
-bool shouldOptimizeForSize(BasicBlock *BB, ProfileSummaryInfo *PSI,
-                           BlockFrequencyInfo *BFI);
+bool shouldOptimizeForSize(const Function *F, ProfileSummaryInfo *PSI,
+                           BlockFrequencyInfo *BFI,
+                           PGSOQueryType QueryType = PGSOQueryType::Other);
+
+/// Returns true if basic block \p BB is suggested to be size-optimized based on
+/// the profile.
+bool shouldOptimizeForSize(const BasicBlock *BB, ProfileSummaryInfo *PSI,
+                           BlockFrequencyInfo *BFI,
+                           PGSOQueryType QueryType = PGSOQueryType::Other);
 
 } // end namespace llvm
 
diff --git a/linux-x64/clang/include/llvm/Transforms/Utils/StripGCRelocates.h b/linux-x64/clang/include/llvm/Transforms/Utils/StripGCRelocates.h
new file mode 100644
index 0000000..13e6d8a
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Transforms/Utils/StripGCRelocates.h
@@ -0,0 +1,25 @@
+//===- StripGCRelocates.h - -----------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_UTILS_STRIPGCRELOCATES_H
+#define LLVM_TRANSFORMS_UTILS_STRIPGCRELOCATES_H
+
+#include "llvm/IR/PassManager.h"
+
+namespace llvm {
+
+class Function;
+
+class StripGCRelocates : public PassInfoMixin<StripGCRelocates> {
+public:
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+};
+
+} // end namespace llvm
+
+#endif // LLVM_TRANSFORMS_UTILS_STRIPGCRELOCATES_H
diff --git a/linux-x64/clang/include/llvm/Transforms/Utils/StripNonLineTableDebugInfo.h b/linux-x64/clang/include/llvm/Transforms/Utils/StripNonLineTableDebugInfo.h
new file mode 100644
index 0000000..20d0aab
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Transforms/Utils/StripNonLineTableDebugInfo.h
@@ -0,0 +1,26 @@
+//===- StripNonLineTableDebugInfo.h - -------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_UTILS_STRIPNONLINETABLEDEBUGINFO_H
+#define LLVM_TRANSFORMS_UTILS_STRIPNONLINETABLEDEBUGINFO_H
+
+#include "llvm/IR/PassManager.h"
+
+namespace llvm {
+
+class Module;
+
+class StripNonLineTableDebugInfoPass
+    : public PassInfoMixin<StripNonLineTableDebugInfoPass> {
+public:
+  PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+};
+
+} // end namespace llvm
+
+#endif // LLVM_TRANSFORMS_UTILS_STRIPNONLINETABLEDEBUGINFO_H
diff --git a/linux-x64/clang/include/llvm/Transforms/Utils/UnifyFunctionExitNodes.h b/linux-x64/clang/include/llvm/Transforms/Utils/UnifyFunctionExitNodes.h
index f68534e..20b3602 100644
--- a/linux-x64/clang/include/llvm/Transforms/Utils/UnifyFunctionExitNodes.h
+++ b/linux-x64/clang/include/llvm/Transforms/Utils/UnifyFunctionExitNodes.h
@@ -7,47 +7,39 @@
 //===----------------------------------------------------------------------===//
 //
 // This pass is used to ensure that functions have at most one return and one
-// unwind instruction in them.  Additionally, it keeps track of which node is
-// the new exit node of the CFG.  If there are no return or unwind instructions
-// in the function, the getReturnBlock/getUnwindBlock methods will return a null
-// pointer.
+// unreachable instruction in them.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TRANSFORMS_UTILS_UNIFYFUNCTIONEXITNODES_H
 #define LLVM_TRANSFORMS_UTILS_UNIFYFUNCTIONEXITNODES_H
 
+#include "llvm/IR/PassManager.h"
 #include "llvm/Pass.h"
-#include "llvm/PassRegistry.h"
 
 namespace llvm {
 
-struct UnifyFunctionExitNodes : public FunctionPass {
-  BasicBlock *ReturnBlock = nullptr;
-  BasicBlock *UnwindBlock = nullptr;
-  BasicBlock *UnreachableBlock;
+class BasicBlock;
 
+class UnifyFunctionExitNodesLegacyPass : public FunctionPass {
 public:
   static char ID; // Pass identification, replacement for typeid
-  UnifyFunctionExitNodes() : FunctionPass(ID) {
-    initializeUnifyFunctionExitNodesPass(*PassRegistry::getPassRegistry());
-  }
+  UnifyFunctionExitNodesLegacyPass();
 
   // We can preserve non-critical-edgeness when we unify function exit nodes
   void getAnalysisUsage(AnalysisUsage &AU) const override;
 
-  // getReturn|Unwind|UnreachableBlock - Return the new single (or nonexistent)
-  // return, unwind, or unreachable  basic blocks in the CFG.
-  //
-  BasicBlock *getReturnBlock() const { return ReturnBlock; }
-  BasicBlock *getUnwindBlock() const { return UnwindBlock; }
-  BasicBlock *getUnreachableBlock() const { return UnreachableBlock; }
-
   bool runOnFunction(Function &F) override;
 };
 
 Pass *createUnifyFunctionExitNodesPass();
 
+class UnifyFunctionExitNodesPass
+    : public PassInfoMixin<UnifyFunctionExitNodesPass> {
+public:
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+};
+
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_UTILS_UNIFYFUNCTIONEXITNODES_H
diff --git a/linux-x64/clang/include/llvm/Transforms/Utils/UnifyLoopExits.h b/linux-x64/clang/include/llvm/Transforms/Utils/UnifyLoopExits.h
new file mode 100644
index 0000000..0b219cd
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Transforms/Utils/UnifyLoopExits.h
@@ -0,0 +1,22 @@
+//===- UnifyLoopExits.h - Redirect exiting edges to one block -*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_UTILS_UNIFYLOOPEXITS_H
+#define LLVM_TRANSFORMS_UTILS_UNIFYLOOPEXITS_H
+
+#include "llvm/IR/PassManager.h"
+
+namespace llvm {
+
+class UnifyLoopExitsPass : public PassInfoMixin<UnifyLoopExitsPass> {
+public:
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+};
+} // namespace llvm
+
+#endif // LLVM_TRANSFORMS_UTILS_UNIFYLOOPEXITS_H
diff --git a/linux-x64/clang/include/llvm/Transforms/Utils/UniqueInternalLinkageNames.h b/linux-x64/clang/include/llvm/Transforms/Utils/UniqueInternalLinkageNames.h
new file mode 100644
index 0000000..637b5d8
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Transforms/Utils/UniqueInternalLinkageNames.h
@@ -0,0 +1,31 @@
+//===-- UniqueInternalLinkageNames.h - Uniq. Int. Linkage Names -*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements unique naming of internal linkage symbols with option
+// -funique-internal-linkage-symbols.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_UTILS_UNIQUEINTERNALLINKAGENAMES_H
+#define LLVM_TRANSFORMS_UTILS_UNIQUEINTERNALLINKAGENAMES_H
+
+#include "llvm/IR/Module.h"
+#include "llvm/IR/PassManager.h"
+
+namespace llvm {
+
+/// Simple pass that provides a name to every anonymous globals.
+class UniqueInternalLinkageNamesPass
+    : public PassInfoMixin<UniqueInternalLinkageNamesPass> {
+public:
+  PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+};
+
+} // end namespace llvm
+
+#endif // LLVM_TRANSFORMS_UTILS_UNIQUEINTERNALLINKAGENAMES_H
diff --git a/linux-x64/clang/include/llvm/Transforms/Utils/UnrollLoop.h b/linux-x64/clang/include/llvm/Transforms/Utils/UnrollLoop.h
index 593ca26..4254bd7 100644
--- a/linux-x64/clang/include/llvm/Transforms/Utils/UnrollLoop.h
+++ b/linux-x64/clang/include/llvm/Transforms/Utils/UnrollLoop.h
@@ -16,9 +16,7 @@
 #define LLVM_TRANSFORMS_UTILS_UNROLLLOOP_H
 
 #include "llvm/ADT/DenseMap.h"
-#include "llvm/ADT/StringRef.h"
 #include "llvm/Analysis/TargetTransformInfo.h"
-#include "llvm/Transforms/Utils/ValueMapper.h"
 
 namespace llvm {
 
@@ -33,6 +31,8 @@
 class ProfileSummaryInfo;
 class OptimizationRemarkEmitter;
 class ScalarEvolution;
+class StringRef;
+class Value;
 
 using NewLoopsMap = SmallDenseMap<const Loop *, Loop *, 4>;
 
@@ -80,50 +80,43 @@
 
 LoopUnrollResult UnrollLoop(Loop *L, UnrollLoopOptions ULO, LoopInfo *LI,
                             ScalarEvolution *SE, DominatorTree *DT,
-                            AssumptionCache *AC, OptimizationRemarkEmitter *ORE,
-                            bool PreserveLCSSA, Loop **RemainderLoop = nullptr);
+                            AssumptionCache *AC,
+                            const llvm::TargetTransformInfo *TTI,
+                            OptimizationRemarkEmitter *ORE, bool PreserveLCSSA,
+                            Loop **RemainderLoop = nullptr);
 
-bool UnrollRuntimeLoopRemainder(Loop *L, unsigned Count,
-                                bool AllowExpensiveTripCount,
-                                bool UseEpilogRemainder, bool UnrollRemainder,
-                                bool ForgetAllSCEV, LoopInfo *LI,
-                                ScalarEvolution *SE, DominatorTree *DT,
-                                AssumptionCache *AC, bool PreserveLCSSA,
-                                Loop **ResultLoop = nullptr);
-
-void computePeelCount(Loop *L, unsigned LoopSize,
-                      TargetTransformInfo::UnrollingPreferences &UP,
-                      unsigned &TripCount, ScalarEvolution &SE);
-
-bool canPeel(Loop *L);
-
-bool peelLoop(Loop *L, unsigned PeelCount, LoopInfo *LI, ScalarEvolution *SE,
-              DominatorTree *DT, AssumptionCache *AC, bool PreserveLCSSA);
+bool UnrollRuntimeLoopRemainder(
+    Loop *L, unsigned Count, bool AllowExpensiveTripCount,
+    bool UseEpilogRemainder, bool UnrollRemainder, bool ForgetAllSCEV,
+    LoopInfo *LI, ScalarEvolution *SE, DominatorTree *DT, AssumptionCache *AC,
+    const TargetTransformInfo *TTI, bool PreserveLCSSA,
+    Loop **ResultLoop = nullptr);
 
 LoopUnrollResult UnrollAndJamLoop(Loop *L, unsigned Count, unsigned TripCount,
                                   unsigned TripMultiple, bool UnrollRemainder,
                                   LoopInfo *LI, ScalarEvolution *SE,
                                   DominatorTree *DT, AssumptionCache *AC,
+                                  const TargetTransformInfo *TTI,
                                   OptimizationRemarkEmitter *ORE,
                                   Loop **EpilogueLoop = nullptr);
 
 bool isSafeToUnrollAndJam(Loop *L, ScalarEvolution &SE, DominatorTree &DT,
-                          DependenceInfo &DI);
+                          DependenceInfo &DI, LoopInfo &LI);
 
 bool computeUnrollCount(Loop *L, const TargetTransformInfo &TTI,
                         DominatorTree &DT, LoopInfo *LI, ScalarEvolution &SE,
                         const SmallPtrSetImpl<const Value *> &EphValues,
                         OptimizationRemarkEmitter *ORE, unsigned &TripCount,
-                        unsigned MaxTripCount, unsigned &TripMultiple,
-                        unsigned LoopSize,
+                        unsigned MaxTripCount, bool MaxOrZero,
+                        unsigned &TripMultiple, unsigned LoopSize,
                         TargetTransformInfo::UnrollingPreferences &UP,
+                        TargetTransformInfo::PeelingPreferences &PP,
                         bool &UseUpperBound);
 
-void remapInstruction(Instruction *I, ValueToValueMapTy &VMap);
-
 void simplifyLoopAfterUnroll(Loop *L, bool SimplifyIVs, LoopInfo *LI,
                              ScalarEvolution *SE, DominatorTree *DT,
-                             AssumptionCache *AC);
+                             AssumptionCache *AC,
+                             const TargetTransformInfo *TTI);
 
 MDNode *GetUnrollMetadata(MDNode *LoopID, StringRef Name);
 
@@ -132,7 +125,7 @@
     BlockFrequencyInfo *BFI, ProfileSummaryInfo *PSI, int OptLevel,
     Optional<unsigned> UserThreshold, Optional<unsigned> UserCount,
     Optional<bool> UserAllowPartial, Optional<bool> UserRuntime,
-    Optional<bool> UserUpperBound, Optional<bool> UserAllowPeeling);
+    Optional<bool> UserUpperBound, Optional<unsigned> UserFullUnrollMaxCount);
 
 unsigned ApproximateLoopSize(const Loop *L, unsigned &NumCalls,
                              bool &NotDuplicatable, bool &Convergent,
diff --git a/linux-x64/clang/include/llvm/Transforms/Utils/VNCoercion.h b/linux-x64/clang/include/llvm/Transforms/Utils/VNCoercion.h
index f67b9ed..1cc751d 100644
--- a/linux-x64/clang/include/llvm/Transforms/Utils/VNCoercion.h
+++ b/linux-x64/clang/include/llvm/Transforms/Utils/VNCoercion.h
@@ -20,14 +20,14 @@
 
 #ifndef LLVM_TRANSFORMS_UTILS_VNCOERCION_H
 #define LLVM_TRANSFORMS_UTILS_VNCOERCION_H
-#include "llvm/IR/IRBuilder.h"
 
 namespace llvm {
-class Function;
+class Constant;
 class StoreInst;
 class LoadInst;
 class MemIntrinsic;
 class Instruction;
+class IRBuilderBase;
 class Value;
 class Type;
 class DataLayout;
@@ -44,7 +44,7 @@
 ///
 /// If we can't do it, return null.
 Value *coerceAvailableValueToLoadType(Value *StoredVal, Type *LoadedTy,
-                                      IRBuilder<> &IRB, const DataLayout &DL);
+                                      IRBuilderBase &IRB, const DataLayout &DL);
 
 /// This function determines whether a value for the pointer LoadPtr can be
 /// extracted from the store at DepSI.
diff --git a/linux-x64/clang/include/llvm/Transforms/Utils/ValueMapper.h b/linux-x64/clang/include/llvm/Transforms/Utils/ValueMapper.h
index 1952a21..ff5bfc6 100644
--- a/linux-x64/clang/include/llvm/Transforms/Utils/ValueMapper.h
+++ b/linux-x64/clang/include/llvm/Transforms/Utils/ValueMapper.h
@@ -22,7 +22,7 @@
 
 class Constant;
 class Function;
-class GlobalAlias;
+class GlobalIndirectSymbol;
 class GlobalVariable;
 class Instruction;
 class MDNode;
@@ -120,7 +120,7 @@
 /// instance:
 /// - \a scheduleMapGlobalInitializer()
 /// - \a scheduleMapAppendingVariable()
-/// - \a scheduleMapGlobalAliasee()
+/// - \a scheduleMapGlobalIndirectSymbol()
 /// - \a scheduleRemapFunction()
 ///
 /// Sometimes a callback needs a different mapping context.  Such a context can
@@ -180,8 +180,9 @@
                                     bool IsOldCtorDtor,
                                     ArrayRef<Constant *> NewMembers,
                                     unsigned MappingContextID = 0);
-  void scheduleMapGlobalAliasee(GlobalAlias &GA, Constant &Aliasee,
-                                unsigned MappingContextID = 0);
+  void scheduleMapGlobalIndirectSymbol(GlobalIndirectSymbol &GIS,
+                                       Constant &Target,
+                                       unsigned MappingContextID = 0);
   void scheduleRemapFunction(Function &F, unsigned MappingContextID = 0);
 };
 
diff --git a/linux-x64/clang/include/llvm/Transforms/Vectorize.h b/linux-x64/clang/include/llvm/Transforms/Vectorize.h
index 88a0e49..bc75142 100644
--- a/linux-x64/clang/include/llvm/Transforms/Vectorize.h
+++ b/linux-x64/clang/include/llvm/Transforms/Vectorize.h
@@ -16,7 +16,6 @@
 
 namespace llvm {
 class BasicBlock;
-class BasicBlockPass;
 class Pass;
 
 //===----------------------------------------------------------------------===//
@@ -139,6 +138,12 @@
 //
 Pass *createLoadStoreVectorizerPass();
 
+//===----------------------------------------------------------------------===//
+//
+// Optimize partial vector operations using target cost models.
+//
+Pass *createVectorCombinePass();
+
 } // End llvm namespace
 
 #endif
diff --git a/linux-x64/clang/include/llvm/Transforms/Vectorize/LoopVectorizationLegality.h b/linux-x64/clang/include/llvm/Transforms/Vectorize/LoopVectorizationLegality.h
index b144006..2f80b43 100644
--- a/linux-x64/clang/include/llvm/Transforms/Vectorize/LoopVectorizationLegality.h
+++ b/linux-x64/clang/include/llvm/Transforms/Vectorize/LoopVectorizationLegality.h
@@ -29,22 +29,11 @@
 #include "llvm/ADT/MapVector.h"
 #include "llvm/Analysis/LoopAccessAnalysis.h"
 #include "llvm/Analysis/OptimizationRemarkEmitter.h"
+#include "llvm/Support/TypeSize.h"
 #include "llvm/Transforms/Utils/LoopUtils.h"
 
 namespace llvm {
 
-/// Create an analysis remark that explains why vectorization failed
-///
-/// \p PassName is the name of the pass (e.g. can be AlwaysPrint).  \p
-/// RemarkName is the identifier for the remark.  If \p I is passed it is an
-/// instruction that prevents vectorization.  Otherwise \p TheLoop is used for
-/// the location of the remark.  \return the remark object that can be
-/// streamed to.
-OptimizationRemarkAnalysis createLVMissedAnalysis(const char *PassName,
-                                                  StringRef RemarkName,
-                                                  Loop *TheLoop,
-                                                  Instruction *I = nullptr);
-
 /// Utility class for getting and setting loop vectorizer hints in the form
 /// of loop metadata.
 /// This class keeps a number of loop annotations locally (as member variables)
@@ -55,7 +44,14 @@
 /// for example 'force', means a decision has been made. So, we need to be
 /// careful NOT to add them if the user hasn't specifically asked so.
 class LoopVectorizeHints {
-  enum HintKind { HK_WIDTH, HK_UNROLL, HK_FORCE, HK_ISVECTORIZED };
+  enum HintKind {
+    HK_WIDTH,
+    HK_UNROLL,
+    HK_FORCE,
+    HK_ISVECTORIZED,
+    HK_PREDICATE,
+    HK_SCALABLE
+  };
 
   /// Hint - associates name and validation with the hint value.
   struct Hint {
@@ -81,6 +77,12 @@
   /// Already Vectorized
   Hint IsVectorized;
 
+  /// Vector Predicate
+  Hint Predicate;
+
+  /// Says whether we should use fixed width or scalable vectorization.
+  Hint Scalable;
+
   /// Return the loop metadata prefix.
   static StringRef Prefix() { return "llvm.loop."; }
 
@@ -106,9 +108,12 @@
   /// Dumps all the hint information.
   void emitRemarkWithHints() const;
 
-  unsigned getWidth() const { return Width.Value; }
+  ElementCount getWidth() const {
+    return ElementCount::get(Width.Value, isScalable());
+  }
   unsigned getInterleave() const { return Interleave.Value; }
   unsigned getIsVectorized() const { return IsVectorized.Value; }
+  unsigned getPredicate() const { return Predicate.Value; }
   enum ForceKind getForce() const {
     if ((ForceKind)Force.Value == FK_Undefined &&
         hasDisableAllTransformsHint(TheLoop))
@@ -116,6 +121,8 @@
     return (ForceKind)Force.Value;
   }
 
+  bool isScalable() const { return Scalable.Value; }
+
   /// If hints are provided that force vectorization, use the AlwaysPrint
   /// pass name to force the frontend to print the diagnostic.
   const char *vectorizeAnalysisPassName() const;
@@ -126,7 +133,9 @@
     // enabled by default because can be unsafe or inefficient. For example,
     // reordering floating-point operations will change the way round-off
     // error accumulates in the loop.
-    return getForce() == LoopVectorizeHints::FK_Enabled || getWidth() > 1;
+    ElementCount EC = getWidth();
+    return getForce() == LoopVectorizeHints::FK_Enabled ||
+           EC.getKnownMinValue() > 1;
   }
 
   bool isPotentiallyUnsafe() const {
@@ -205,17 +214,18 @@
 public:
   LoopVectorizationLegality(
       Loop *L, PredicatedScalarEvolution &PSE, DominatorTree *DT,
-      TargetTransformInfo *TTI, TargetLibraryInfo *TLI, AliasAnalysis *AA,
+      TargetTransformInfo *TTI, TargetLibraryInfo *TLI, AAResults *AA,
       Function *F, std::function<const LoopAccessInfo &(Loop &)> *GetLAA,
       LoopInfo *LI, OptimizationRemarkEmitter *ORE,
       LoopVectorizationRequirements *R, LoopVectorizeHints *H, DemandedBits *DB,
-      AssumptionCache *AC)
+      AssumptionCache *AC, BlockFrequencyInfo *BFI, ProfileSummaryInfo *PSI)
       : TheLoop(L), LI(LI), PSE(PSE), TTI(TTI), TLI(TLI), DT(DT),
-        GetLAA(GetLAA), ORE(ORE), Requirements(R), Hints(H), DB(DB), AC(AC) {}
+        GetLAA(GetLAA), ORE(ORE), Requirements(R), Hints(H), DB(DB), AC(AC),
+        BFI(BFI), PSI(PSI) {}
 
   /// ReductionList contains the reduction descriptors for all
   /// of the reductions that were found in the loop.
-  using ReductionList = DenseMap<PHINode *, RecurrenceDescriptor>;
+  using ReductionList = MapVector<PHINode *, RecurrenceDescriptor>;
 
   /// InductionList saves induction variables and maps them to the
   /// induction descriptor.
@@ -235,20 +245,21 @@
   bool canVectorize(bool UseVPlanNativePath);
 
   /// Return true if we can vectorize this loop while folding its tail by
-  /// masking.
-  bool canFoldTailByMasking();
+  /// masking, and mark all respective loads/stores for masking.
+  /// This object's state is only modified iff this function returns true.
+  bool prepareToFoldTailByMasking();
 
   /// Returns the primary induction variable.
   PHINode *getPrimaryInduction() { return PrimaryInduction; }
 
   /// Returns the reduction variables found in the loop.
-  ReductionList *getReductionVars() { return &Reductions; }
+  ReductionList &getReductionVars() { return Reductions; }
 
   /// Returns the induction variables found in the loop.
-  InductionList *getInductionVars() { return &Inductions; }
+  InductionList &getInductionVars() { return Inductions; }
 
   /// Return the first-order recurrences found in the loop.
-  RecurrenceSet *getFirstOrderRecurrences() { return &FirstOrderRecurrences; }
+  RecurrenceSet &getFirstOrderRecurrences() { return FirstOrderRecurrences; }
 
   /// Return the set of instructions to sink to handle first-order recurrences.
   DenseMap<Instruction *, Instruction *> &getSinkAfter() { return SinkAfter; }
@@ -294,6 +305,19 @@
   /// Returns true if the value V is uniform within the loop.
   bool isUniform(Value *V);
 
+  /// A uniform memory op is a load or store which accesses the same memory
+  /// location on all lanes.
+  bool isUniformMemOp(Instruction &I) {
+    Value *Ptr = getLoadStorePointerOperand(&I);
+    if (!Ptr)
+      return false;
+    // Note: There's nothing inherent which prevents predicated loads and
+    // stores from being uniform.  The current lowering simply doesn't handle
+    // it; in particular, the cost model distinguishes scatter/gather from
+    // scalar w/predication, and we currently rely on the scalar path.
+    return isUniform(Ptr) && !blockNeedsPredication(I.getParent());
+  }
+
   /// Returns the information that we collected about runtime memory check.
   const RuntimePointerChecking *getRuntimePointerChecking() const {
     return LAI->getRuntimePointerChecking();
@@ -301,17 +325,21 @@
 
   const LoopAccessInfo *getLAI() const { return LAI; }
 
+  bool isSafeForAnyVectorWidth() const {
+    return LAI->getDepChecker().isSafeForAnyVectorWidth();
+  }
+
   unsigned getMaxSafeDepDistBytes() { return LAI->getMaxSafeDepDistBytes(); }
 
-  uint64_t getMaxSafeRegisterWidth() const {
-    return LAI->getDepChecker().getMaxSafeRegisterWidth();
+  uint64_t getMaxSafeVectorWidthInBits() const {
+    return LAI->getDepChecker().getMaxSafeVectorWidthInBits();
   }
 
   bool hasStride(Value *V) { return LAI->hasStride(V); }
 
   /// Returns true if vector representation of the instruction \p I
   /// requires mask.
-  bool isMaskRequired(const Instruction *I) { return (MaskedOp.count(I) != 0); }
+  bool isMaskRequired(const Instruction *I) { return MaskedOp.contains(I); }
 
   unsigned getNumStores() const { return LAI->getNumStores(); }
   unsigned getNumLoads() const { return LAI->getNumLoads(); }
@@ -319,6 +347,12 @@
   // Returns true if the NoNaN attribute is set on the function.
   bool hasFunNoNaNAttr() const { return HasFunNoNaNAttr; }
 
+  /// Returns all assume calls in predicated blocks. They need to be dropped
+  /// when flattening the CFG.
+  const SmallPtrSetImpl<Instruction *> &getConditionalAssumes() const {
+    return ConditionalAssumes;
+  }
+
 private:
   /// Return true if the pre-header, exiting and latch blocks of \p Lp and all
   /// its nested loops are considered legal for vectorization. These legal
@@ -362,9 +396,22 @@
   bool canVectorizeOuterLoop();
 
   /// Return true if all of the instructions in the block can be speculatively
-  /// executed. \p SafePtrs is a list of addresses that are known to be legal
-  /// and we know that we can read from them without segfault.
-  bool blockCanBePredicated(BasicBlock *BB, SmallPtrSetImpl<Value *> &SafePtrs);
+  /// executed, and record the loads/stores that require masking. If's that
+  /// guard loads can be ignored under "assume safety" unless \p PreserveGuards
+  /// is true. This can happen when we introduces guards for which the original
+  /// "unguarded-loads are safe" assumption does not hold. For example, the
+  /// vectorizer's fold-tail transformation changes the loop to execute beyond
+  /// its original trip-count, under a proper guard, which should be preserved.
+  /// \p SafePtrs is a list of addresses that are known to be legal and we know
+  /// that we can read from them without segfault.
+  /// \p MaskedOp is a list of instructions that have to be transformed into
+  /// calls to the appropriate masked intrinsic when the loop is vectorized.
+  /// \p ConditionalAssumes is a list of assume instructions in predicated
+  /// blocks that must be dropped if the CFG gets flattened.
+  bool blockCanBePredicated(BasicBlock *BB, SmallPtrSetImpl<Value *> &SafePtrs,
+                            SmallPtrSetImpl<const Instruction *> &MaskedOp,
+                            SmallPtrSetImpl<Instruction *> &ConditionalAssumes,
+                            bool PreserveGuards = false) const;
 
   /// Updates the vectorization state by adding \p Phi to the inductions list.
   /// This can set \p Phi as the main induction of the loop if \p Phi is a
@@ -382,14 +429,6 @@
     return LAI ? &LAI->getSymbolicStrides() : nullptr;
   }
 
-  /// Reports a vectorization illegality: print \p DebugMsg for debugging
-  /// purposes along with the corresponding optimization remark \p RemarkName.
-  /// If \p I is passed it is an instruction that prevents vectorization.
-  /// Otherwise the loop is used for the location of the remark.
-  void reportVectorizationFailure(const StringRef DebugMsg,
-      const StringRef OREMsg, const StringRef ORETag,
-      Instruction *I = nullptr) const;
-
   /// The loop that we evaluate.
   Loop *TheLoop;
 
@@ -452,8 +491,8 @@
   /// Holds the widest induction type encountered.
   Type *WidestIndTy = nullptr;
 
-  /// Allowed outside users. This holds the induction and reduction
-  /// vars which can be accessed from outside the loop.
+  /// Allowed outside users. This holds the variables that can be accessed from
+  /// outside the loop.
   SmallPtrSet<Value *, 4> AllowedExit;
 
   /// Can we assume the absence of NaNs.
@@ -476,6 +515,14 @@
   /// While vectorizing these instructions we have to generate a
   /// call to the appropriate masked intrinsic
   SmallPtrSet<const Instruction *, 8> MaskedOp;
+
+  /// Assume instructions in predicated blocks must be dropped if the CFG gets
+  /// flattened.
+  SmallPtrSet<Instruction *, 8> ConditionalAssumes;
+
+  /// BFI and PSI are used to check for profile guided size optimizations.
+  BlockFrequencyInfo *BFI;
+  ProfileSummaryInfo *PSI;
 };
 
 } // namespace llvm
diff --git a/linux-x64/clang/include/llvm/Transforms/Vectorize/LoopVectorize.h b/linux-x64/clang/include/llvm/Transforms/Vectorize/LoopVectorize.h
index d1ec06a..ecb44a7 100644
--- a/linux-x64/clang/include/llvm/Transforms/Vectorize/LoopVectorize.h
+++ b/linux-x64/clang/include/llvm/Transforms/Vectorize/LoopVectorize.h
@@ -56,12 +56,13 @@
 #ifndef LLVM_TRANSFORMS_VECTORIZE_LOOPVECTORIZE_H
 #define LLVM_TRANSFORMS_VECTORIZE_LOOPVECTORIZE_H
 
-#include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/IR/PassManager.h"
+#include "llvm/Support/CommandLine.h"
 #include <functional>
 
 namespace llvm {
 
+class AAResults;
 class AssumptionCache;
 class BlockFrequencyInfo;
 class DemandedBits;
@@ -115,8 +116,18 @@
   }
 };
 
+/// Storage for information about made changes.
+struct LoopVectorizeResult {
+  bool MadeAnyChange;
+  bool MadeCFGChange;
+
+  LoopVectorizeResult(bool MadeAnyChange, bool MadeCFGChange)
+      : MadeAnyChange(MadeAnyChange), MadeCFGChange(MadeCFGChange) {}
+};
+
 /// The LoopVectorize Pass.
 struct LoopVectorizePass : public PassInfoMixin<LoopVectorizePass> {
+private:
   /// If false, consider all loops for interleaving.
   /// If true, only loops that explicitly request interleaving are considered.
   bool InterleaveOnlyWhenForced;
@@ -125,9 +136,8 @@
   /// If true, only loops that explicitly request vectorization are considered.
   bool VectorizeOnlyWhenForced;
 
-  LoopVectorizePass(LoopVectorizeOptions Opts = {})
-      : InterleaveOnlyWhenForced(Opts.InterleaveOnlyWhenForced),
-        VectorizeOnlyWhenForced(Opts.VectorizeOnlyWhenForced) {}
+public:
+  LoopVectorizePass(LoopVectorizeOptions Opts = {});
 
   ScalarEvolution *SE;
   LoopInfo *LI;
@@ -136,7 +146,7 @@
   BlockFrequencyInfo *BFI;
   TargetLibraryInfo *TLI;
   DemandedBits *DB;
-  AliasAnalysis *AA;
+  AAResults *AA;
   AssumptionCache *AC;
   std::function<const LoopAccessInfo &(Loop &)> *GetLAA;
   OptimizationRemarkEmitter *ORE;
@@ -145,16 +155,25 @@
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
 
   // Shim for old PM.
-  bool runImpl(Function &F, ScalarEvolution &SE_, LoopInfo &LI_,
-               TargetTransformInfo &TTI_, DominatorTree &DT_,
-               BlockFrequencyInfo &BFI_, TargetLibraryInfo *TLI_,
-               DemandedBits &DB_, AliasAnalysis &AA_, AssumptionCache &AC_,
-               std::function<const LoopAccessInfo &(Loop &)> &GetLAA_,
-               OptimizationRemarkEmitter &ORE_, ProfileSummaryInfo *PSI_);
+  LoopVectorizeResult
+  runImpl(Function &F, ScalarEvolution &SE_, LoopInfo &LI_,
+          TargetTransformInfo &TTI_, DominatorTree &DT_,
+          BlockFrequencyInfo &BFI_, TargetLibraryInfo *TLI_, DemandedBits &DB_,
+          AAResults &AA_, AssumptionCache &AC_,
+          std::function<const LoopAccessInfo &(Loop &)> &GetLAA_,
+          OptimizationRemarkEmitter &ORE_, ProfileSummaryInfo *PSI_);
 
   bool processLoop(Loop *L);
 };
 
+/// Reports a vectorization failure: print \p DebugMsg for debugging
+/// purposes along with the corresponding optimization remark \p RemarkName.
+/// If \p I is passed, it is an instruction that prevents vectorization.
+/// Otherwise, the loop \p TheLoop is used for the location of the remark.
+void reportVectorizationFailure(const StringRef DebugMsg,
+    const StringRef OREMsg, const StringRef ORETag,
+    OptimizationRemarkEmitter *ORE, Loop *TheLoop, Instruction *I = nullptr);
+
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_VECTORIZE_LOOPVECTORIZE_H
diff --git a/linux-x64/clang/include/llvm/Transforms/Vectorize/SLPVectorizer.h b/linux-x64/clang/include/llvm/Transforms/Vectorize/SLPVectorizer.h
index ac6afb7..52a5793 100644
--- a/linux-x64/clang/include/llvm/Transforms/Vectorize/SLPVectorizer.h
+++ b/linux-x64/clang/include/llvm/Transforms/Vectorize/SLPVectorizer.h
@@ -22,12 +22,11 @@
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/None.h"
 #include "llvm/ADT/SmallVector.h"
-#include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/IR/PassManager.h"
-#include "llvm/IR/ValueHandle.h"
 
 namespace llvm {
 
+class AAResults;
 class AssumptionCache;
 class BasicBlock;
 class CmpInst;
@@ -35,6 +34,7 @@
 class DemandedBits;
 class DominatorTree;
 class Function;
+class GetElementPtrInst;
 class InsertElementInst;
 class InsertValueInst;
 class Instruction;
@@ -55,18 +55,16 @@
 
 } // end namespace slpvectorizer
 
-extern cl::opt<bool> RunSLPVectorization;
-
 struct SLPVectorizerPass : public PassInfoMixin<SLPVectorizerPass> {
   using StoreList = SmallVector<StoreInst *, 8>;
   using StoreListMap = MapVector<Value *, StoreList>;
-  using WeakTrackingVHList = SmallVector<WeakTrackingVH, 8>;
-  using WeakTrackingVHListMap = MapVector<Value *, WeakTrackingVHList>;
+  using GEPList = SmallVector<GetElementPtrInst *, 8>;
+  using GEPListMap = MapVector<Value *, GEPList>;
 
   ScalarEvolution *SE = nullptr;
   TargetTransformInfo *TTI = nullptr;
   TargetLibraryInfo *TLI = nullptr;
-  AliasAnalysis *AA = nullptr;
+  AAResults *AA = nullptr;
   LoopInfo *LI = nullptr;
   DominatorTree *DT = nullptr;
   AssumptionCache *AC = nullptr;
@@ -78,7 +76,7 @@
 
   // Glue for old PM.
   bool runImpl(Function &F, ScalarEvolution *SE_, TargetTransformInfo *TTI_,
-               TargetLibraryInfo *TLI_, AliasAnalysis *AA_, LoopInfo *LI_,
+               TargetLibraryInfo *TLI_, AAResults *AA_, LoopInfo *LI_,
                DominatorTree *DT_, AssumptionCache *AC_, DemandedBits *DB_,
                OptimizationRemarkEmitter *ORE_);
 
@@ -96,11 +94,15 @@
   bool tryToVectorizePair(Value *A, Value *B, slpvectorizer::BoUpSLP &R);
 
   /// Try to vectorize a list of operands.
-  /// \param UserCost Cost of the user operations of \p VL if they may affect
-  /// the cost of the vectorization.
+  /// When \p InsertUses is provided and its entries are non-zero
+  /// then users of \p VL are known to be InsertElement instructions
+  /// each associated with same VL entry index. Their cost is then
+  /// used to adjust cost of the vectorization assuming instcombine pass
+  /// then optimizes ExtractElement-InsertElement sequence.
   /// \returns true if a value was vectorized.
   bool tryToVectorizeList(ArrayRef<Value *> VL, slpvectorizer::BoUpSLP &R,
-                          int UserCost = 0, bool AllowReorder = false);
+                          bool AllowReorder = false,
+                          ArrayRef<Value *> InsertUses = None);
 
   /// Try to vectorize a chain that may start at the operands of \p I.
   bool tryToVectorize(Instruction *I, slpvectorizer::BoUpSLP &R);
@@ -131,7 +133,7 @@
 
   /// Tries to vectorize constructs started from CmpInst, InsertValueInst or
   /// InsertElementInst instructions.
-  bool vectorizeSimpleInstructions(SmallVectorImpl<WeakVH> &Instructions,
+  bool vectorizeSimpleInstructions(SmallVectorImpl<Instruction *> &Instructions,
                                    BasicBlock *BB, slpvectorizer::BoUpSLP &R);
 
   /// Scan the basic block and look for patterns that are likely to start
@@ -139,7 +141,7 @@
   bool vectorizeChainsInBlock(BasicBlock *BB, slpvectorizer::BoUpSLP &R);
 
   bool vectorizeStoreChain(ArrayRef<Value *> Chain, slpvectorizer::BoUpSLP &R,
-                           unsigned VecRegSize);
+                           unsigned Idx);
 
   bool vectorizeStores(ArrayRef<StoreInst *> Stores, slpvectorizer::BoUpSLP &R);
 
@@ -147,7 +149,7 @@
   StoreListMap Stores;
 
   /// The getelementptr instructions in a basic block organized by base pointer.
-  WeakTrackingVHListMap GEPs;
+  GEPListMap GEPs;
 };
 
 } // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/Transforms/Vectorize/VectorCombine.h b/linux-x64/clang/include/llvm/Transforms/Vectorize/VectorCombine.h
new file mode 100644
index 0000000..15e2331
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Transforms/Vectorize/VectorCombine.h
@@ -0,0 +1,30 @@
+//===-------- VectorCombine.h - Optimize partial vector operations --------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This pass optimizes scalar/vector interactions using target cost models. The
+// transforms implemented here may not fit in traditional loop-based or SLP
+// vectorization passes.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_VECTOR_VECTORCOMBINE_H
+#define LLVM_TRANSFORMS_VECTOR_VECTORCOMBINE_H
+
+#include "llvm/IR/PassManager.h"
+
+namespace llvm {
+
+/// Optimize scalar/vector interactions in IR using target cost models.
+struct VectorCombinePass : public PassInfoMixin<VectorCombinePass> {
+public:
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager &);
+};
+
+}
+#endif // LLVM_TRANSFORMS_VECTOR_VECTORCOMBINE_H
+
diff --git a/linux-x64/clang/include/llvm/XRay/FDRRecordProducer.h b/linux-x64/clang/include/llvm/XRay/FDRRecordProducer.h
index b530a85..043d915 100644
--- a/linux-x64/clang/include/llvm/XRay/FDRRecordProducer.h
+++ b/linux-x64/clang/include/llvm/XRay/FDRRecordProducer.h
@@ -27,7 +27,7 @@
 class FileBasedRecordProducer : public RecordProducer {
   const XRayFileHeader &Header;
   DataExtractor &E;
-  uint32_t &OffsetPtr;
+  uint64_t &OffsetPtr;
   uint32_t CurrentBufferBytes = 0;
 
   // Helper function which gets the next record by speculatively reading through
@@ -36,7 +36,7 @@
 
 public:
   FileBasedRecordProducer(const XRayFileHeader &FH, DataExtractor &DE,
-                          uint32_t &OP)
+                          uint64_t &OP)
       : Header(FH), E(DE), OffsetPtr(OP) {}
 
   /// This producer encapsulates the logic for loading a File-backed
diff --git a/linux-x64/clang/include/llvm/XRay/FDRRecords.h b/linux-x64/clang/include/llvm/XRay/FDRRecords.h
index a8ce74b..d53e6aa 100644
--- a/linux-x64/clang/include/llvm/XRay/FDRRecords.h
+++ b/linux-x64/clang/include/llvm/XRay/FDRRecords.h
@@ -289,7 +289,7 @@
 };
 
 class CallArgRecord : public MetadataRecord {
-  uint64_t Arg;
+  uint64_t Arg = 0;
   friend class RecordInitializer;
 
 public:
@@ -371,8 +371,8 @@
 
 class FunctionRecord : public Record {
   RecordTypes Kind;
-  int32_t FuncId;
-  uint32_t Delta;
+  int32_t FuncId = 0;
+  uint32_t Delta = 0;
   friend class RecordInitializer;
 
   static constexpr unsigned kFunctionRecordSize = 8;
@@ -417,16 +417,16 @@
 
 class RecordInitializer : public RecordVisitor {
   DataExtractor &E;
-  uint32_t &OffsetPtr;
+  uint64_t &OffsetPtr;
   uint16_t Version;
 
 public:
   static constexpr uint16_t DefaultVersion = 5u;
 
-  explicit RecordInitializer(DataExtractor &DE, uint32_t &OP, uint16_t V)
+  explicit RecordInitializer(DataExtractor &DE, uint64_t &OP, uint16_t V)
       : RecordVisitor(), E(DE), OffsetPtr(OP), Version(V) {}
 
-  explicit RecordInitializer(DataExtractor &DE, uint32_t &OP)
+  explicit RecordInitializer(DataExtractor &DE, uint64_t &OP)
       : RecordInitializer(DE, OP, DefaultVersion) {}
 
   Error visit(BufferExtents &) override;
diff --git a/linux-x64/clang/include/llvm/XRay/FileHeaderReader.h b/linux-x64/clang/include/llvm/XRay/FileHeaderReader.h
index 1c9681c..30878f3 100644
--- a/linux-x64/clang/include/llvm/XRay/FileHeaderReader.h
+++ b/linux-x64/clang/include/llvm/XRay/FileHeaderReader.h
@@ -24,7 +24,7 @@
 /// Convenience function for loading the file header given a data extractor at a
 /// specified offset.
 Expected<XRayFileHeader> readBinaryFormatHeader(DataExtractor &HeaderExtractor,
-                                                uint32_t &OffsetPtr);
+                                                uint64_t &OffsetPtr);
 
 } // namespace xray
 } // namespace llvm
diff --git a/linux-x64/clang/include/llvm/XRay/Graph.h b/linux-x64/clang/include/llvm/XRay/Graph.h
index 0046815..d368f7e 100644
--- a/linux-x64/clang/include/llvm/XRay/Graph.h
+++ b/linux-x64/clang/include/llvm/XRay/Graph.h
@@ -126,14 +126,14 @@
   /// set.
   template <bool IsConst, bool IsOut,
             typename BaseIt = typename NeighborSetT::const_iterator,
-            typename T = typename std::conditional<IsConst, const EdgeValueType,
-                                                   EdgeValueType>::type>
+            typename T =
+                std::conditional_t<IsConst, const EdgeValueType, EdgeValueType>>
   class NeighborEdgeIteratorT
       : public iterator_adaptor_base<
             NeighborEdgeIteratorT<IsConst, IsOut>, BaseIt,
             typename std::iterator_traits<BaseIt>::iterator_category, T> {
     using InternalEdgeMapT =
-        typename std::conditional<IsConst, const EdgeMapT, EdgeMapT>::type;
+        std::conditional_t<IsConst, const EdgeMapT, EdgeMapT>;
 
     friend class NeighborEdgeIteratorT<false, IsOut, BaseIt, EdgeValueType>;
     friend class NeighborEdgeIteratorT<true, IsOut, BaseIt,
@@ -144,7 +144,7 @@
 
   public:
     template <bool IsConstDest,
-              typename = typename std::enable_if<IsConstDest && !IsConst>::type>
+              typename = std::enable_if<IsConstDest && !IsConst>>
     operator NeighborEdgeIteratorT<IsConstDest, IsOut, BaseIt,
                                    const EdgeValueType>() const {
       return NeighborEdgeIteratorT<IsConstDest, IsOut, BaseIt,
@@ -199,9 +199,9 @@
   public:
     using iterator = NeighborEdgeIteratorT<isConst, isOut>;
     using const_iterator = NeighborEdgeIteratorT<true, isOut>;
-    using GraphT = typename std::conditional<isConst, const Graph, Graph>::type;
+    using GraphT = std::conditional_t<isConst, const Graph, Graph>;
     using InternalEdgeMapT =
-        typename std::conditional<isConst, const EdgeMapT, EdgeMapT>::type;
+        std::conditional_t<isConst, const EdgeMapT, EdgeMapT>;
 
   private:
     InternalEdgeMapT &M;
@@ -272,10 +272,10 @@
   /// the number of elements in the range and whether the range is empty.
   template <bool isConst> class VertexView {
   public:
-    using iterator = typename std::conditional<isConst, ConstVertexIterator,
-                                               VertexIterator>::type;
+    using iterator =
+        std::conditional_t<isConst, ConstVertexIterator, VertexIterator>;
     using const_iterator = ConstVertexIterator;
-    using GraphT = typename std::conditional<isConst, const Graph, Graph>::type;
+    using GraphT = std::conditional_t<isConst, const Graph, Graph>;
 
   private:
     GraphT &G;
@@ -309,10 +309,10 @@
   /// the number of elements in the range and whether the range is empty.
   template <bool isConst> class EdgeView {
   public:
-    using iterator = typename std::conditional<isConst, ConstEdgeIterator,
-                                               EdgeIterator>::type;
+    using iterator =
+        std::conditional_t<isConst, ConstEdgeIterator, EdgeIterator>;
     using const_iterator = ConstEdgeIterator;
-    using GraphT = typename std::conditional<isConst, const Graph, Graph>::type;
+    using GraphT = std::conditional_t<isConst, const Graph, Graph>;
 
   private:
     GraphT &G;
diff --git a/linux-x64/clang/include/llvm/XRay/InstrumentationMap.h b/linux-x64/clang/include/llvm/XRay/InstrumentationMap.h
index 5cbe5c4..aae9034 100644
--- a/linux-x64/clang/include/llvm/XRay/InstrumentationMap.h
+++ b/linux-x64/clang/include/llvm/XRay/InstrumentationMap.h
@@ -50,6 +50,8 @@
 
   /// Whether the sled was annotated to always be instrumented.
   bool AlwaysInstrument;
+
+  unsigned char Version;
 };
 
 struct YAMLXRaySledEntry {
@@ -59,6 +61,7 @@
   SledEntry::FunctionKinds Kind;
   bool AlwaysInstrument;
   std::string FunctionName;
+  unsigned char Version;
 };
 
 /// The InstrumentationMap represents the computed function id's and indicated
@@ -120,6 +123,7 @@
     IO.mapRequired("kind", Entry.Kind);
     IO.mapRequired("always-instrument", Entry.AlwaysInstrument);
     IO.mapOptional("function-name", Entry.FunctionName);
+    IO.mapOptional("version", Entry.Version, 0);
   }
 
   static constexpr bool flow = true;